]> Git Repo - linux.git/blob - drivers/gpu/drm/selftests/test-drm_damage_helper.c
Merge tag 'drivers-5.15' of git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc
[linux.git] / drivers / gpu / drm / selftests / test-drm_damage_helper.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Test case for drm_damage_helper functions
4  */
5
6 #define pr_fmt(fmt) "drm_damage_helper: " fmt
7
8 #include <drm/drm_damage_helper.h>
9 #include <drm/drm_plane.h>
10 #include <drm/drm_drv.h>
11
12 #include "test-drm_modeset_common.h"
13
14 struct drm_driver mock_driver;
15 static struct drm_device mock_device;
16 static struct drm_object_properties mock_obj_props;
17 static struct drm_plane mock_plane;
18 static struct drm_property mock_prop;
19
20 static void mock_setup(struct drm_plane_state *state)
21 {
22         static bool setup_done = false;
23
24         state->plane = &mock_plane;
25
26         if (setup_done)
27                 return;
28
29         /* just enough so that drm_plane_enable_fb_damage_clips() works */
30         mock_device.driver = &mock_driver;
31         mock_device.mode_config.prop_fb_damage_clips = &mock_prop;
32         mock_plane.dev = &mock_device;
33         mock_plane.base.properties = &mock_obj_props;
34         mock_prop.base.id = 1; /* 0 is an invalid id */
35         mock_prop.dev = &mock_device;
36
37         drm_plane_enable_fb_damage_clips(&mock_plane);
38 }
39
40 static void set_plane_src(struct drm_plane_state *state, int x1, int y1, int x2,
41                           int y2)
42 {
43         state->src.x1 = x1;
44         state->src.y1 = y1;
45         state->src.x2 = x2;
46         state->src.y2 = y2;
47 }
48
49 static void set_damage_clip(struct drm_mode_rect *r, int x1, int y1, int x2,
50                             int y2)
51 {
52         r->x1 = x1;
53         r->y1 = y1;
54         r->x2 = x2;
55         r->y2 = y2;
56 }
57
58 static void set_damage_blob(struct drm_property_blob *damage_blob,
59                             struct drm_mode_rect *r, uint32_t size)
60 {
61         damage_blob->length = size;
62         damage_blob->data = r;
63 }
64
65 static void set_plane_damage(struct drm_plane_state *state,
66                              struct drm_property_blob *damage_blob)
67 {
68         state->fb_damage_clips = damage_blob;
69 }
70
71 static bool check_damage_clip(struct drm_plane_state *state, struct drm_rect *r,
72                               int x1, int y1, int x2, int y2)
73 {
74         /*
75          * Round down x1/y1 and round up x2/y2. This is because damage is not in
76          * 16.16 fixed point so to catch all pixels.
77          */
78         int src_x1 = state->src.x1 >> 16;
79         int src_y1 = state->src.y1 >> 16;
80         int src_x2 = (state->src.x2 >> 16) + !!(state->src.x2 & 0xFFFF);
81         int src_y2 = (state->src.y2 >> 16) + !!(state->src.y2 & 0xFFFF);
82
83         if (x1 >= x2 || y1 >= y2) {
84                 pr_err("Cannot have damage clip with no dimension.\n");
85                 return false;
86         }
87
88         if (x1 < src_x1 || y1 < src_y1 || x2 > src_x2 || y2 > src_y2) {
89                 pr_err("Damage cannot be outside rounded plane src.\n");
90                 return false;
91         }
92
93         if (r->x1 != x1 || r->y1 != y1 || r->x2 != x2 || r->y2 != y2) {
94                 pr_err("Damage = %d %d %d %d\n", r->x1, r->y1, r->x2, r->y2);
95                 return false;
96         }
97
98         return true;
99 }
100
101 const struct drm_framebuffer fb = {
102         .width = 2048,
103         .height = 2048
104 };
105
106 /* common mocked structs many tests need */
107 #define MOCK_VARIABLES() \
108         struct drm_plane_state old_state; \
109         struct drm_plane_state state = { \
110                 .crtc = ZERO_SIZE_PTR, \
111                 .fb = (struct drm_framebuffer *) &fb, \
112                 .visible = true, \
113         }; \
114         mock_setup(&old_state); \
115         mock_setup(&state);
116
117 int igt_damage_iter_no_damage(void *ignored)
118 {
119         struct drm_atomic_helper_damage_iter iter;
120         struct drm_rect clip;
121         uint32_t num_hits = 0;
122
123         MOCK_VARIABLES();
124
125         /* Plane src same as fb size. */
126         set_plane_src(&old_state, 0, 0, fb.width << 16, fb.height << 16);
127         set_plane_src(&state, 0, 0, fb.width << 16, fb.height << 16);
128         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
129         drm_atomic_for_each_plane_damage(&iter, &clip)
130                 num_hits++;
131
132         FAIL(num_hits != 1, "Should return plane src as damage.");
133         FAIL_ON(!check_damage_clip(&state, &clip, 0, 0, 2048, 2048));
134
135         return 0;
136 }
137
138 int igt_damage_iter_no_damage_fractional_src(void *ignored)
139 {
140         struct drm_atomic_helper_damage_iter iter;
141         struct drm_rect clip;
142         uint32_t num_hits = 0;
143
144         MOCK_VARIABLES();
145
146         /* Plane src has fractional part. */
147         set_plane_src(&old_state, 0x3fffe, 0x3fffe,
148                       0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
149         set_plane_src(&state, 0x3fffe, 0x3fffe,
150                       0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
151         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
152         drm_atomic_for_each_plane_damage(&iter, &clip)
153                 num_hits++;
154
155         FAIL(num_hits != 1, "Should return rounded off plane src as damage.");
156         FAIL_ON(!check_damage_clip(&state, &clip, 3, 3, 1028, 772));
157
158         return 0;
159 }
160
161 int igt_damage_iter_no_damage_src_moved(void *ignored)
162 {
163         struct drm_atomic_helper_damage_iter iter;
164         struct drm_rect clip;
165         uint32_t num_hits = 0;
166
167         MOCK_VARIABLES();
168
169         /* Plane src moved since old plane state. */
170         set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
171         set_plane_src(&state, 10 << 16, 10 << 16,
172                       (10 + 1024) << 16, (10 + 768) << 16);
173         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
174         drm_atomic_for_each_plane_damage(&iter, &clip)
175                 num_hits++;
176
177         FAIL(num_hits != 1, "Should return plane src as damage.");
178         FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 1034, 778));
179
180         return 0;
181 }
182
183 int igt_damage_iter_no_damage_fractional_src_moved(void *ignored)
184 {
185         struct drm_atomic_helper_damage_iter iter;
186         struct drm_rect clip;
187         uint32_t num_hits = 0;
188
189         MOCK_VARIABLES();
190
191         /* Plane src has fractional part and it moved since old plane state. */
192         set_plane_src(&old_state, 0x3fffe, 0x3fffe,
193                       0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
194         set_plane_src(&state, 0x40002, 0x40002,
195                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
196         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
197         drm_atomic_for_each_plane_damage(&iter, &clip)
198                 num_hits++;
199
200         FAIL(num_hits != 1, "Should return plane src as damage.");
201         FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029, 773));
202
203         return 0;
204 }
205
206 int igt_damage_iter_no_damage_not_visible(void *ignored)
207 {
208         struct drm_atomic_helper_damage_iter iter;
209         struct drm_rect clip;
210         uint32_t num_hits = 0;
211
212         MOCK_VARIABLES();
213
214         state.visible = false;
215
216         mock_setup(&old_state);
217
218         set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
219         set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
220         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
221         drm_atomic_for_each_plane_damage(&iter, &clip)
222                 num_hits++;
223
224         FAIL(num_hits != 0, "Should have no damage.");
225
226         return 0;
227 }
228
229 int igt_damage_iter_no_damage_no_crtc(void *ignored)
230 {
231         struct drm_atomic_helper_damage_iter iter;
232         struct drm_rect clip;
233         uint32_t num_hits = 0;
234
235         MOCK_VARIABLES();
236
237         state.crtc = NULL;
238
239         set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
240         set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
241         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
242         drm_atomic_for_each_plane_damage(&iter, &clip)
243                 num_hits++;
244
245         FAIL(num_hits != 0, "Should have no damage.");
246
247         return 0;
248 }
249
250 int igt_damage_iter_no_damage_no_fb(void *ignored)
251 {
252         struct drm_atomic_helper_damage_iter iter;
253         struct drm_plane_state old_state;
254         struct drm_rect clip;
255         uint32_t num_hits = 0;
256
257         struct drm_plane_state state = {
258                 .crtc = ZERO_SIZE_PTR,
259                 .fb = 0,
260         };
261
262         mock_setup(&old_state);
263
264         set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
265         set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
266         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
267         drm_atomic_for_each_plane_damage(&iter, &clip)
268                 num_hits++;
269
270         FAIL(num_hits != 0, "Should have no damage.");
271
272         return 0;
273 }
274
275 int igt_damage_iter_simple_damage(void *ignored)
276 {
277         struct drm_atomic_helper_damage_iter iter;
278         struct drm_property_blob damage_blob;
279         struct drm_mode_rect damage;
280         struct drm_rect clip;
281         uint32_t num_hits = 0;
282
283         MOCK_VARIABLES();
284
285         set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
286         set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
287         /* Damage set to plane src */
288         set_damage_clip(&damage, 0, 0, 1024, 768);
289         set_damage_blob(&damage_blob, &damage, sizeof(damage));
290         set_plane_damage(&state, &damage_blob);
291         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
292         drm_atomic_for_each_plane_damage(&iter, &clip)
293                 num_hits++;
294
295         FAIL(num_hits != 1, "Should return damage when set.");
296         FAIL_ON(!check_damage_clip(&state, &clip, 0, 0, 1024, 768));
297
298         return 0;
299 }
300
301 int igt_damage_iter_single_damage(void *ignored)
302 {
303         struct drm_atomic_helper_damage_iter iter;
304         struct drm_property_blob damage_blob;
305         struct drm_mode_rect damage;
306         struct drm_rect clip;
307         uint32_t num_hits = 0;
308
309         MOCK_VARIABLES();
310
311         set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
312         set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
313         set_damage_clip(&damage, 256, 192, 768, 576);
314         set_damage_blob(&damage_blob, &damage, sizeof(damage));
315         set_plane_damage(&state, &damage_blob);
316         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
317         drm_atomic_for_each_plane_damage(&iter, &clip)
318                 num_hits++;
319
320         FAIL(num_hits != 1, "Should return damage when set.");
321         FAIL_ON(!check_damage_clip(&state, &clip, 256, 192, 768, 576));
322
323         return 0;
324 }
325
326 int igt_damage_iter_single_damage_intersect_src(void *ignored)
327 {
328         struct drm_atomic_helper_damage_iter iter;
329         struct drm_property_blob damage_blob;
330         struct drm_mode_rect damage;
331         struct drm_rect clip;
332         uint32_t num_hits = 0;
333
334         MOCK_VARIABLES();
335
336         set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
337         set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
338         /* Damage intersect with plane src. */
339         set_damage_clip(&damage, 256, 192, 1360, 768);
340         set_damage_blob(&damage_blob, &damage, sizeof(damage));
341         set_plane_damage(&state, &damage_blob);
342         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
343         drm_atomic_for_each_plane_damage(&iter, &clip)
344                 num_hits++;
345
346         FAIL(num_hits != 1, "Should return damage clipped to src.");
347         FAIL_ON(!check_damage_clip(&state, &clip, 256, 192, 1024, 768));
348
349         return 0;
350 }
351
352 int igt_damage_iter_single_damage_outside_src(void *ignored)
353 {
354         struct drm_atomic_helper_damage_iter iter;
355         struct drm_property_blob damage_blob;
356         struct drm_mode_rect damage;
357         struct drm_rect clip;
358         uint32_t num_hits = 0;
359
360         MOCK_VARIABLES();
361
362         set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
363         set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
364         /* Damage clip outside plane src */
365         set_damage_clip(&damage, 1360, 1360, 1380, 1380);
366         set_damage_blob(&damage_blob, &damage, sizeof(damage));
367         set_plane_damage(&state, &damage_blob);
368         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
369         drm_atomic_for_each_plane_damage(&iter, &clip)
370                 num_hits++;
371
372         FAIL(num_hits != 0, "Should have no damage.");
373
374         return 0;
375 }
376
377 int igt_damage_iter_single_damage_fractional_src(void *ignored)
378 {
379         struct drm_atomic_helper_damage_iter iter;
380         struct drm_property_blob damage_blob;
381         struct drm_mode_rect damage;
382         struct drm_rect clip;
383         uint32_t num_hits = 0;
384
385         MOCK_VARIABLES();
386
387         /* Plane src has fractional part. */
388         set_plane_src(&old_state, 0x40002, 0x40002,
389                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
390         set_plane_src(&state, 0x40002, 0x40002,
391                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
392         set_damage_clip(&damage, 10, 10, 256, 330);
393         set_damage_blob(&damage_blob, &damage, sizeof(damage));
394         set_plane_damage(&state, &damage_blob);
395         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
396         drm_atomic_for_each_plane_damage(&iter, &clip)
397                 num_hits++;
398
399         FAIL(num_hits != 1, "Should return damage when set.");
400         FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 256, 330));
401
402         return 0;
403 }
404
405 int igt_damage_iter_single_damage_intersect_fractional_src(void *ignored)
406 {
407         struct drm_atomic_helper_damage_iter iter;
408         struct drm_property_blob damage_blob;
409         struct drm_mode_rect damage;
410         struct drm_rect clip;
411         uint32_t num_hits = 0;
412
413         MOCK_VARIABLES();
414
415         /* Plane src has fractional part. */
416         set_plane_src(&old_state, 0x40002, 0x40002,
417                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
418         set_plane_src(&state, 0x40002, 0x40002,
419                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
420         /* Damage intersect with plane src. */
421         set_damage_clip(&damage, 10, 1, 1360, 330);
422         set_damage_blob(&damage_blob, &damage, sizeof(damage));
423         set_plane_damage(&state, &damage_blob);
424         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
425         drm_atomic_for_each_plane_damage(&iter, &clip)
426                 num_hits++;
427
428         FAIL(num_hits != 1, "Should return damage clipped to rounded off src.");
429         FAIL_ON(!check_damage_clip(&state, &clip, 10, 4, 1029, 330));
430
431         return 0;
432 }
433
434 int igt_damage_iter_single_damage_outside_fractional_src(void *ignored)
435 {
436         struct drm_atomic_helper_damage_iter iter;
437         struct drm_property_blob damage_blob;
438         struct drm_mode_rect damage;
439         struct drm_rect clip;
440         uint32_t num_hits = 0;
441
442         MOCK_VARIABLES();
443
444         /* Plane src has fractional part. */
445         set_plane_src(&old_state, 0x40002, 0x40002,
446                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
447         set_plane_src(&state, 0x40002, 0x40002,
448                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
449         /* Damage clip outside plane src */
450         set_damage_clip(&damage, 1360, 1360, 1380, 1380);
451         set_damage_blob(&damage_blob, &damage, sizeof(damage));
452         set_plane_damage(&state, &damage_blob);
453         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
454         drm_atomic_for_each_plane_damage(&iter, &clip)
455                 num_hits++;
456
457         FAIL(num_hits != 0, "Should have no damage.");
458
459         return 0;
460 }
461
462 int igt_damage_iter_single_damage_src_moved(void *ignored)
463 {
464         struct drm_atomic_helper_damage_iter iter;
465         struct drm_property_blob damage_blob;
466         struct drm_mode_rect damage;
467         struct drm_rect clip;
468         uint32_t num_hits = 0;
469
470         MOCK_VARIABLES();
471
472         /* Plane src moved since old plane state. */
473         set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
474         set_plane_src(&state, 10 << 16, 10 << 16,
475                       (10 + 1024) << 16, (10 + 768) << 16);
476         set_damage_clip(&damage, 20, 30, 256, 256);
477         set_damage_blob(&damage_blob, &damage, sizeof(damage));
478         set_plane_damage(&state, &damage_blob);
479         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
480         drm_atomic_for_each_plane_damage(&iter, &clip)
481                 num_hits++;
482
483         FAIL(num_hits != 1, "Should return plane src as damage.");
484         FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 1034, 778));
485
486         return 0;
487 }
488
489 int igt_damage_iter_single_damage_fractional_src_moved(void *ignored)
490 {
491         struct drm_atomic_helper_damage_iter iter;
492         struct drm_property_blob damage_blob;
493         struct drm_mode_rect damage;
494         struct drm_rect clip;
495         uint32_t num_hits = 0;
496
497         MOCK_VARIABLES();
498
499         /* Plane src with fractional part moved since old plane state. */
500         set_plane_src(&old_state, 0x3fffe, 0x3fffe,
501                       0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
502         set_plane_src(&state, 0x40002, 0x40002,
503                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
504         /* Damage intersect with plane src. */
505         set_damage_clip(&damage, 20, 30, 1360, 256);
506         set_damage_blob(&damage_blob, &damage, sizeof(damage));
507         set_plane_damage(&state, &damage_blob);
508         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
509         drm_atomic_for_each_plane_damage(&iter, &clip)
510                 num_hits++;
511
512         FAIL(num_hits != 1, "Should return rounded off plane src as damage.");
513         FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029, 773));
514
515         return 0;
516 }
517
518 int igt_damage_iter_damage(void *ignored)
519 {
520         struct drm_atomic_helper_damage_iter iter;
521         struct drm_property_blob damage_blob;
522         struct drm_mode_rect damage[2];
523         struct drm_rect clip;
524         uint32_t num_hits = 0;
525
526         MOCK_VARIABLES();
527
528         set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
529         set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
530         /* 2 damage clips. */
531         set_damage_clip(&damage[0], 20, 30, 200, 180);
532         set_damage_clip(&damage[1], 240, 200, 280, 250);
533         set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
534         set_plane_damage(&state, &damage_blob);
535         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
536         drm_atomic_for_each_plane_damage(&iter, &clip) {
537                 if (num_hits == 0)
538                         FAIL_ON(!check_damage_clip(&state, &clip, 20, 30, 200, 180));
539                 if (num_hits == 1)
540                         FAIL_ON(!check_damage_clip(&state, &clip, 240, 200, 280, 250));
541                 num_hits++;
542         }
543
544         FAIL(num_hits != 2, "Should return damage when set.");
545
546         return 0;
547 }
548
549 int igt_damage_iter_damage_one_intersect(void *ignored)
550 {
551         struct drm_atomic_helper_damage_iter iter;
552         struct drm_property_blob damage_blob;
553         struct drm_mode_rect damage[2];
554         struct drm_rect clip;
555         uint32_t num_hits = 0;
556
557         MOCK_VARIABLES();
558
559         set_plane_src(&old_state, 0x40002, 0x40002,
560                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
561         set_plane_src(&state, 0x40002, 0x40002,
562                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
563         /* 2 damage clips, one intersect plane src. */
564         set_damage_clip(&damage[0], 20, 30, 200, 180);
565         set_damage_clip(&damage[1], 2, 2, 1360, 1360);
566         set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
567         set_plane_damage(&state, &damage_blob);
568         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
569         drm_atomic_for_each_plane_damage(&iter, &clip) {
570                 if (num_hits == 0)
571                         FAIL_ON(!check_damage_clip(&state, &clip, 20, 30, 200, 180));
572                 if (num_hits == 1)
573                         FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029, 773));
574                 num_hits++;
575         }
576
577         FAIL(num_hits != 2, "Should return damage when set.");
578
579         return 0;
580 }
581
582 int igt_damage_iter_damage_one_outside(void *ignored)
583 {
584         struct drm_atomic_helper_damage_iter iter;
585         struct drm_property_blob damage_blob;
586         struct drm_mode_rect damage[2];
587         struct drm_rect clip;
588         uint32_t num_hits = 0;
589
590         MOCK_VARIABLES();
591
592         set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
593         set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
594         /* 2 damage clips, one outside plane src. */
595         set_damage_clip(&damage[0], 1360, 1360, 1380, 1380);
596         set_damage_clip(&damage[1], 240, 200, 280, 250);
597         set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
598         set_plane_damage(&state, &damage_blob);
599         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
600         drm_atomic_for_each_plane_damage(&iter, &clip)
601                 num_hits++;
602
603         FAIL(num_hits != 1, "Should return damage when set.");
604         FAIL_ON(!check_damage_clip(&state, &clip, 240, 200, 280, 250));
605
606         return 0;
607 }
608
609 int igt_damage_iter_damage_src_moved(void *ignored)
610 {
611         struct drm_atomic_helper_damage_iter iter;
612         struct drm_property_blob damage_blob;
613         struct drm_mode_rect damage[2];
614         struct drm_rect clip;
615         uint32_t num_hits = 0;
616
617         MOCK_VARIABLES();
618
619         set_plane_src(&old_state, 0x40002, 0x40002,
620                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
621         set_plane_src(&state, 0x3fffe, 0x3fffe,
622                       0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
623         /* 2 damage clips, one outside plane src. */
624         set_damage_clip(&damage[0], 1360, 1360, 1380, 1380);
625         set_damage_clip(&damage[1], 240, 200, 280, 250);
626         set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
627         set_plane_damage(&state, &damage_blob);
628         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
629         drm_atomic_for_each_plane_damage(&iter, &clip)
630                 num_hits++;
631
632         FAIL(num_hits != 1, "Should return round off plane src as damage.");
633         FAIL_ON(!check_damage_clip(&state, &clip, 3, 3, 1028, 772));
634
635         return 0;
636 }
637
638 int igt_damage_iter_damage_not_visible(void *ignored)
639 {
640         struct drm_atomic_helper_damage_iter iter;
641         struct drm_property_blob damage_blob;
642         struct drm_mode_rect damage[2];
643         struct drm_rect clip;
644         uint32_t num_hits = 0;
645
646         MOCK_VARIABLES();
647
648         state.visible = false;
649
650         set_plane_src(&old_state, 0x40002, 0x40002,
651                       0x40002 + (1024 << 16), 0x40002 + (768 << 16));
652         set_plane_src(&state, 0x3fffe, 0x3fffe,
653                       0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
654         /* 2 damage clips, one outside plane src. */
655         set_damage_clip(&damage[0], 1360, 1360, 1380, 1380);
656         set_damage_clip(&damage[1], 240, 200, 280, 250);
657         set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
658         set_plane_damage(&state, &damage_blob);
659         drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
660         drm_atomic_for_each_plane_damage(&iter, &clip)
661                 num_hits++;
662
663         FAIL(num_hits != 0, "Should not return any damage.");
664
665         return 0;
666 }
This page took 0.075657 seconds and 4 git commands to generate.