1 // SPDX-License-Identifier: MIT
2 /*
3 * Copyright 2020 Noralf Trønnes
4 */
5
6 #include <linux/lz4.h>
7 #include <linux/usb.h>
8 #include <linux/vmalloc.h>
9 #include <linux/workqueue.h>
10
11 #include <drm/drm_atomic.h>
12 #include <drm/drm_connector.h>
13 #include <drm/drm_damage_helper.h>
14 #include <drm/drm_drv.h>
15 #include <drm/drm_format_helper.h>
16 #include <drm/drm_fourcc.h>
17 #include <drm/drm_framebuffer.h>
18 #include <drm/drm_gem.h>
19 #include <drm/drm_gem_atomic_helper.h>
20 #include <drm/drm_gem_framebuffer_helper.h>
21 #include <drm/drm_print.h>
22 #include <drm/drm_rect.h>
23 #include <drm/gud.h>
24
25 #include "gud_internal.h"
26
27 /*
28 * Some userspace rendering loops run all displays in the same loop.
29 * This means that a fast display will have to wait for a slow one.
30 * Such users might want to enable this module parameter.
31 */
32 static bool gud_async_flush;
33 module_param_named(async_flush, gud_async_flush, bool, 0644);
34 MODULE_PARM_DESC(async_flush, "Enable asynchronous flushing [default=0]");
35
36 /*
37 * FIXME: The driver is probably broken on Big Endian machines.
38 * See discussion:
39 * https://lore.kernel.org/dri-devel/CAKb7UvihLX0hgBOP3VBG7O+atwZcUVCPVuBdfmDMpg0NjXe-cQ@mail.gmail.com/
40 */
41
gud_is_big_endian(void)42 static bool gud_is_big_endian(void)
43 {
44 #if defined(__BIG_ENDIAN)
45 return true;
46 #else
47 return false;
48 #endif
49 }
50
gud_xrgb8888_to_r124(u8 * dst,const struct drm_format_info * format,void * src,struct drm_framebuffer * fb,struct drm_rect * rect,struct drm_format_conv_state * fmtcnv_state)51 static size_t gud_xrgb8888_to_r124(u8 *dst, const struct drm_format_info *format,
52 void *src, struct drm_framebuffer *fb,
53 struct drm_rect *rect,
54 struct drm_format_conv_state *fmtcnv_state)
55 {
56 unsigned int block_width = drm_format_info_block_width(format, 0);
57 unsigned int bits_per_pixel = 8 / block_width;
58 unsigned int x, y, width, height;
59 u8 pix, *pix8, *block = dst; /* Assign to silence compiler warning */
60 struct iosys_map dst_map, vmap;
61 size_t len;
62 void *buf;
63
64 drm_WARN_ON_ONCE(fb->dev, format->char_per_block[0] != 1);
65
66 /* Start on a byte boundary */
67 rect->x1 = ALIGN_DOWN(rect->x1, block_width);
68 width = drm_rect_width(rect);
69 height = drm_rect_height(rect);
70 len = drm_format_info_min_pitch(format, 0, width) * height;
71
72 buf = kmalloc_array(height, width, GFP_KERNEL);
73 if (!buf)
74 return 0;
75
76 iosys_map_set_vaddr(&dst_map, buf);
77 iosys_map_set_vaddr(&vmap, src);
78 drm_fb_xrgb8888_to_gray8(&dst_map, NULL, &vmap, fb, rect, fmtcnv_state);
79 pix8 = buf;
80
81 for (y = 0; y < height; y++) {
82 for (x = 0; x < width; x++) {
83 unsigned int pixpos = x % block_width; /* within byte from the left */
84 unsigned int pixshift = (block_width - pixpos - 1) * bits_per_pixel;
85
86 if (!pixpos) {
87 block = dst++;
88 *block = 0;
89 }
90
91 pix = (*pix8++) >> (8 - bits_per_pixel);
92 *block |= pix << pixshift;
93 }
94 }
95
96 kfree(buf);
97
98 return len;
99 }
100
gud_xrgb8888_to_color(u8 * dst,const struct drm_format_info * format,void * src,struct drm_framebuffer * fb,struct drm_rect * rect)101 static size_t gud_xrgb8888_to_color(u8 *dst, const struct drm_format_info *format,
102 void *src, struct drm_framebuffer *fb,
103 struct drm_rect *rect)
104 {
105 unsigned int block_width = drm_format_info_block_width(format, 0);
106 unsigned int bits_per_pixel = 8 / block_width;
107 u8 r, g, b, pix, *block = dst; /* Assign to silence compiler warning */
108 unsigned int x, y, width;
109 __le32 *sbuf32;
110 u32 pix32;
111 size_t len;
112
113 /* Start on a byte boundary */
114 rect->x1 = ALIGN_DOWN(rect->x1, block_width);
115 width = drm_rect_width(rect);
116 len = drm_format_info_min_pitch(format, 0, width) * drm_rect_height(rect);
117
118 for (y = rect->y1; y < rect->y2; y++) {
119 sbuf32 = src + (y * fb->pitches[0]);
120 sbuf32 += rect->x1;
121
122 for (x = 0; x < width; x++) {
123 unsigned int pixpos = x % block_width; /* within byte from the left */
124 unsigned int pixshift = (block_width - pixpos - 1) * bits_per_pixel;
125
126 if (!pixpos) {
127 block = dst++;
128 *block = 0;
129 }
130
131 pix32 = le32_to_cpu(*sbuf32++);
132 r = pix32 >> 16;
133 g = pix32 >> 8;
134 b = pix32;
135
136 switch (format->format) {
137 case GUD_DRM_FORMAT_XRGB1111:
138 pix = ((r >> 7) << 2) | ((g >> 7) << 1) | (b >> 7);
139 break;
140 default:
141 drm_WARN_ON_ONCE(fb->dev, 1);
142 return len;
143 }
144
145 *block |= pix << pixshift;
146 }
147 }
148
149 return len;
150 }
151
gud_prep_flush(struct gud_device * gdrm,struct drm_framebuffer * fb,const struct iosys_map * src,bool cached_reads,const struct drm_format_info * format,struct drm_rect * rect,struct gud_set_buffer_req * req,struct drm_format_conv_state * fmtcnv_state)152 static int gud_prep_flush(struct gud_device *gdrm, struct drm_framebuffer *fb,
153 const struct iosys_map *src, bool cached_reads,
154 const struct drm_format_info *format, struct drm_rect *rect,
155 struct gud_set_buffer_req *req,
156 struct drm_format_conv_state *fmtcnv_state)
157 {
158 u8 compression = gdrm->compression;
159 struct iosys_map dst;
160 void *vaddr, *buf;
161 size_t pitch, len;
162
163 pitch = drm_format_info_min_pitch(format, 0, drm_rect_width(rect));
164 len = pitch * drm_rect_height(rect);
165 if (len > gdrm->bulk_len)
166 return -E2BIG;
167
168 vaddr = src[0].vaddr;
169 retry:
170 if (compression)
171 buf = gdrm->compress_buf;
172 else
173 buf = gdrm->bulk_buf;
174 iosys_map_set_vaddr(&dst, buf);
175
176 /*
177 * Imported buffers are assumed to be write-combined and thus uncached
178 * with slow reads (at least on ARM).
179 */
180 if (format != fb->format) {
181 if (format->format == GUD_DRM_FORMAT_R1) {
182 len = gud_xrgb8888_to_r124(buf, format, vaddr, fb, rect, fmtcnv_state);
183 if (!len)
184 return -ENOMEM;
185 } else if (format->format == DRM_FORMAT_R8) {
186 drm_fb_xrgb8888_to_gray8(&dst, NULL, src, fb, rect, fmtcnv_state);
187 } else if (format->format == DRM_FORMAT_RGB332) {
188 drm_fb_xrgb8888_to_rgb332(&dst, NULL, src, fb, rect, fmtcnv_state);
189 } else if (format->format == DRM_FORMAT_RGB565) {
190 if (gud_is_big_endian()) {
191 drm_fb_xrgb8888_to_rgb565be(&dst, NULL, src, fb, rect,
192 fmtcnv_state);
193 } else {
194 drm_fb_xrgb8888_to_rgb565(&dst, NULL, src, fb, rect,
195 fmtcnv_state);
196 }
197 } else if (format->format == DRM_FORMAT_RGB888) {
198 drm_fb_xrgb8888_to_rgb888(&dst, NULL, src, fb, rect, fmtcnv_state);
199 } else {
200 len = gud_xrgb8888_to_color(buf, format, vaddr, fb, rect);
201 }
202 } else if (gud_is_big_endian() && format->cpp[0] > 1) {
203 drm_fb_swab(&dst, NULL, src, fb, rect, cached_reads, fmtcnv_state);
204 } else if (compression && cached_reads && pitch == fb->pitches[0]) {
205 /* can compress directly from the framebuffer */
206 buf = vaddr + rect->y1 * pitch;
207 } else {
208 drm_fb_memcpy(&dst, NULL, src, fb, rect);
209 }
210
211 memset(req, 0, sizeof(*req));
212 req->x = cpu_to_le32(rect->x1);
213 req->y = cpu_to_le32(rect->y1);
214 req->width = cpu_to_le32(drm_rect_width(rect));
215 req->height = cpu_to_le32(drm_rect_height(rect));
216 req->length = cpu_to_le32(len);
217
218 if (compression & GUD_COMPRESSION_LZ4) {
219 int complen;
220
221 complen = LZ4_compress_default(buf, gdrm->bulk_buf, len, len, gdrm->lz4_comp_mem);
222 if (complen <= 0) {
223 compression = 0;
224 goto retry;
225 }
226
227 req->compression = GUD_COMPRESSION_LZ4;
228 req->compressed_length = cpu_to_le32(complen);
229 }
230
231 return 0;
232 }
233
234 struct gud_usb_bulk_context {
235 struct timer_list timer;
236 struct usb_sg_request sgr;
237 };
238
gud_usb_bulk_timeout(struct timer_list * t)239 static void gud_usb_bulk_timeout(struct timer_list *t)
240 {
241 struct gud_usb_bulk_context *ctx = timer_container_of(ctx, t, timer);
242
243 usb_sg_cancel(&ctx->sgr);
244 }
245
gud_usb_bulk(struct gud_device * gdrm,size_t len)246 static int gud_usb_bulk(struct gud_device *gdrm, size_t len)
247 {
248 struct gud_usb_bulk_context ctx;
249 int ret;
250
251 ret = usb_sg_init(&ctx.sgr, gud_to_usb_device(gdrm), gdrm->bulk_pipe, 0,
252 gdrm->bulk_sgt.sgl, gdrm->bulk_sgt.nents, len, GFP_KERNEL);
253 if (ret)
254 return ret;
255
256 timer_setup_on_stack(&ctx.timer, gud_usb_bulk_timeout, 0);
257 mod_timer(&ctx.timer, jiffies + msecs_to_jiffies(3000));
258
259 usb_sg_wait(&ctx.sgr);
260
261 if (!timer_delete_sync(&ctx.timer))
262 ret = -ETIMEDOUT;
263 else if (ctx.sgr.status < 0)
264 ret = ctx.sgr.status;
265 else if (ctx.sgr.bytes != len)
266 ret = -EIO;
267
268 timer_destroy_on_stack(&ctx.timer);
269
270 return ret;
271 }
272
gud_flush_rect(struct gud_device * gdrm,struct drm_framebuffer * fb,const struct iosys_map * src,bool cached_reads,const struct drm_format_info * format,struct drm_rect * rect,struct drm_format_conv_state * fmtcnv_state)273 static int gud_flush_rect(struct gud_device *gdrm, struct drm_framebuffer *fb,
274 const struct iosys_map *src, bool cached_reads,
275 const struct drm_format_info *format, struct drm_rect *rect,
276 struct drm_format_conv_state *fmtcnv_state)
277 {
278 struct gud_set_buffer_req req;
279 size_t len, trlen;
280 int ret;
281
282 drm_dbg(&gdrm->drm, "Flushing [FB:%d] " DRM_RECT_FMT "\n", fb->base.id, DRM_RECT_ARG(rect));
283
284 ret = gud_prep_flush(gdrm, fb, src, cached_reads, format, rect, &req, fmtcnv_state);
285 if (ret)
286 return ret;
287
288 len = le32_to_cpu(req.length);
289
290 if (req.compression)
291 trlen = le32_to_cpu(req.compressed_length);
292 else
293 trlen = len;
294
295 gdrm->stats_length += len;
296 /* Did it wrap around? */
297 if (gdrm->stats_length <= len && gdrm->stats_actual_length) {
298 gdrm->stats_length = len;
299 gdrm->stats_actual_length = 0;
300 }
301 gdrm->stats_actual_length += trlen;
302
303 if (!(gdrm->flags & GUD_DISPLAY_FLAG_FULL_UPDATE) || gdrm->prev_flush_failed) {
304 ret = gud_usb_set(gdrm, GUD_REQ_SET_BUFFER, 0, &req, sizeof(req));
305 if (ret)
306 return ret;
307 }
308
309 ret = gud_usb_bulk(gdrm, trlen);
310 if (ret)
311 gdrm->stats_num_errors++;
312
313 return ret;
314 }
315
gud_clear_damage(struct gud_device * gdrm)316 void gud_clear_damage(struct gud_device *gdrm)
317 {
318 gdrm->damage.x1 = INT_MAX;
319 gdrm->damage.y1 = INT_MAX;
320 gdrm->damage.x2 = 0;
321 gdrm->damage.y2 = 0;
322 }
323
gud_flush_damage(struct gud_device * gdrm,struct drm_framebuffer * fb,const struct iosys_map * src,bool cached_reads,struct drm_rect * damage)324 static void gud_flush_damage(struct gud_device *gdrm, struct drm_framebuffer *fb,
325 const struct iosys_map *src, bool cached_reads,
326 struct drm_rect *damage)
327 {
328 struct drm_format_conv_state fmtcnv_state = DRM_FORMAT_CONV_STATE_INIT;
329 const struct drm_format_info *format;
330 unsigned int i, lines;
331 size_t pitch;
332 int ret;
333
334 format = fb->format;
335 if (format->format == DRM_FORMAT_XRGB8888 && gdrm->xrgb8888_emulation_format)
336 format = gdrm->xrgb8888_emulation_format;
337
338 /* Split update if it's too big */
339 pitch = drm_format_info_min_pitch(format, 0, drm_rect_width(damage));
340 lines = drm_rect_height(damage);
341
342 if (gdrm->bulk_len < lines * pitch)
343 lines = gdrm->bulk_len / pitch;
344
345 for (i = 0; i < DIV_ROUND_UP(drm_rect_height(damage), lines); i++) {
346 struct drm_rect rect = *damage;
347
348 rect.y1 += i * lines;
349 rect.y2 = min_t(u32, rect.y1 + lines, damage->y2);
350
351 ret = gud_flush_rect(gdrm, fb, src, cached_reads, format, &rect, &fmtcnv_state);
352 if (ret) {
353 if (ret != -ENODEV && ret != -ECONNRESET &&
354 ret != -ESHUTDOWN && ret != -EPROTO)
355 dev_err_ratelimited(fb->dev->dev,
356 "Failed to flush framebuffer: error=%d\n", ret);
357 gdrm->prev_flush_failed = true;
358 break;
359 }
360 }
361
362 drm_format_conv_state_release(&fmtcnv_state);
363 }
364
gud_flush_work(struct work_struct * work)365 void gud_flush_work(struct work_struct *work)
366 {
367 struct gud_device *gdrm = container_of(work, struct gud_device, work);
368 struct iosys_map shadow_map;
369 struct drm_framebuffer *fb;
370 struct drm_rect damage;
371 int idx;
372
373 if (!drm_dev_enter(&gdrm->drm, &idx))
374 return;
375
376 mutex_lock(&gdrm->damage_lock);
377 fb = gdrm->fb;
378 gdrm->fb = NULL;
379 iosys_map_set_vaddr(&shadow_map, gdrm->shadow_buf);
380 damage = gdrm->damage;
381 gud_clear_damage(gdrm);
382 mutex_unlock(&gdrm->damage_lock);
383
384 if (!fb)
385 goto out;
386
387 gud_flush_damage(gdrm, fb, &shadow_map, true, &damage);
388
389 drm_framebuffer_put(fb);
390 out:
391 drm_dev_exit(idx);
392 }
393
gud_fb_queue_damage(struct gud_device * gdrm,struct drm_framebuffer * fb,const struct iosys_map * src,struct drm_rect * damage)394 static int gud_fb_queue_damage(struct gud_device *gdrm, struct drm_framebuffer *fb,
395 const struct iosys_map *src, struct drm_rect *damage)
396 {
397 struct drm_framebuffer *old_fb = NULL;
398 struct iosys_map shadow_map;
399
400 mutex_lock(&gdrm->damage_lock);
401
402 if (!gdrm->shadow_buf) {
403 gdrm->shadow_buf = vcalloc(fb->pitches[0], fb->height);
404 if (!gdrm->shadow_buf) {
405 mutex_unlock(&gdrm->damage_lock);
406 return -ENOMEM;
407 }
408 }
409
410 iosys_map_set_vaddr(&shadow_map, gdrm->shadow_buf);
411 iosys_map_incr(&shadow_map, drm_fb_clip_offset(fb->pitches[0], fb->format, damage));
412 drm_fb_memcpy(&shadow_map, fb->pitches, src, fb, damage);
413
414 if (fb != gdrm->fb) {
415 old_fb = gdrm->fb;
416 drm_framebuffer_get(fb);
417 gdrm->fb = fb;
418 }
419
420 gdrm->damage.x1 = min(gdrm->damage.x1, damage->x1);
421 gdrm->damage.y1 = min(gdrm->damage.y1, damage->y1);
422 gdrm->damage.x2 = max(gdrm->damage.x2, damage->x2);
423 gdrm->damage.y2 = max(gdrm->damage.y2, damage->y2);
424
425 mutex_unlock(&gdrm->damage_lock);
426
427 queue_work(system_long_wq, &gdrm->work);
428
429 if (old_fb)
430 drm_framebuffer_put(old_fb);
431
432 return 0;
433 }
434
gud_fb_handle_damage(struct gud_device * gdrm,struct drm_framebuffer * fb,const struct iosys_map * src,struct drm_rect * damage)435 static void gud_fb_handle_damage(struct gud_device *gdrm, struct drm_framebuffer *fb,
436 const struct iosys_map *src, struct drm_rect *damage)
437 {
438 int ret;
439
440 if (gdrm->flags & GUD_DISPLAY_FLAG_FULL_UPDATE)
441 drm_rect_init(damage, 0, 0, fb->width, fb->height);
442
443 if (gud_async_flush) {
444 ret = gud_fb_queue_damage(gdrm, fb, src, damage);
445 if (ret != -ENOMEM)
446 return;
447 }
448
449 /* Imported buffers are assumed to be WriteCombined with uncached reads */
450 gud_flush_damage(gdrm, fb, src, !fb->obj[0]->import_attach, damage);
451 }
452
gud_plane_atomic_check(struct drm_plane * plane,struct drm_atomic_state * state)453 int gud_plane_atomic_check(struct drm_plane *plane,
454 struct drm_atomic_state *state)
455 {
456 struct gud_device *gdrm = to_gud_device(plane->dev);
457 struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
458 struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
459 struct drm_crtc *crtc = new_plane_state->crtc;
460 struct drm_crtc_state *crtc_state = NULL;
461 const struct drm_display_mode *mode;
462 struct drm_framebuffer *old_fb = old_plane_state->fb;
463 struct drm_connector_state *connector_state = NULL;
464 struct drm_framebuffer *fb = new_plane_state->fb;
465 const struct drm_format_info *format;
466 struct drm_connector *connector;
467 unsigned int i, num_properties;
468 struct gud_state_req *req;
469 int idx, ret;
470 size_t len;
471
472 if (crtc)
473 crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
474
475 ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
476 DRM_PLANE_NO_SCALING,
477 DRM_PLANE_NO_SCALING,
478 false, false);
479 if (ret)
480 return ret;
481
482 if (!new_plane_state->visible)
483 return 0;
484
485 if (old_plane_state->rotation != new_plane_state->rotation)
486 crtc_state->mode_changed = true;
487
488 mode = &crtc_state->mode;
489 format = fb->format;
490
491 if (old_fb && old_fb->format != format)
492 crtc_state->mode_changed = true;
493
494 if (!crtc_state->mode_changed && !crtc_state->connectors_changed)
495 return 0;
496
497 /* Only one connector is supported */
498 if (hweight32(crtc_state->connector_mask) != 1)
499 return -EINVAL;
500
501 if (format->format == DRM_FORMAT_XRGB8888 && gdrm->xrgb8888_emulation_format)
502 format = gdrm->xrgb8888_emulation_format;
503
504 for_each_new_connector_in_state(state, connector, connector_state, i) {
505 if (connector_state->crtc)
506 break;
507 }
508
509 /*
510 * DRM_IOCTL_MODE_OBJ_SETPROPERTY on the rotation property will not have
511 * the connector included in the state.
512 */
513 if (!connector_state) {
514 struct drm_connector_list_iter conn_iter;
515
516 drm_connector_list_iter_begin(plane->dev, &conn_iter);
517 drm_for_each_connector_iter(connector, &conn_iter) {
518 if (connector->state->crtc) {
519 connector_state = connector->state;
520 break;
521 }
522 }
523 drm_connector_list_iter_end(&conn_iter);
524 }
525
526 if (drm_WARN_ON_ONCE(plane->dev, !connector_state))
527 return -ENOENT;
528
529 len = struct_size(req, properties,
530 size_add(GUD_PROPERTIES_MAX_NUM, GUD_CONNECTOR_PROPERTIES_MAX_NUM));
531 req = kzalloc(len, GFP_KERNEL);
532 if (!req)
533 return -ENOMEM;
534
535 gud_from_display_mode(&req->mode, mode);
536
537 req->format = gud_from_fourcc(format->format);
538 if (drm_WARN_ON_ONCE(plane->dev, !req->format)) {
539 ret = -EINVAL;
540 goto out;
541 }
542
543 req->connector = drm_connector_index(connector_state->connector);
544
545 ret = gud_connector_fill_properties(connector_state, req->properties);
546 if (ret < 0)
547 goto out;
548
549 num_properties = ret;
550 for (i = 0; i < gdrm->num_properties; i++) {
551 u16 prop = gdrm->properties[i];
552 u64 val;
553
554 switch (prop) {
555 case GUD_PROPERTY_ROTATION:
556 /* DRM UAPI matches the protocol so use value directly */
557 val = new_plane_state->rotation;
558 break;
559 default:
560 drm_WARN_ON_ONCE(plane->dev, 1);
561 ret = -EINVAL;
562 goto out;
563 }
564
565 req->properties[num_properties + i].prop = cpu_to_le16(prop);
566 req->properties[num_properties + i].val = cpu_to_le64(val);
567 num_properties++;
568 }
569
570 if (drm_dev_enter(fb->dev, &idx)) {
571 len = struct_size(req, properties, num_properties);
572 ret = gud_usb_set(gdrm, GUD_REQ_SET_STATE_CHECK, 0, req, len);
573 drm_dev_exit(idx);
574 } else {
575 ret = -ENODEV;
576 }
577 out:
578 kfree(req);
579
580 return ret;
581 }
582
gud_plane_atomic_update(struct drm_plane * plane,struct drm_atomic_state * atomic_state)583 void gud_plane_atomic_update(struct drm_plane *plane,
584 struct drm_atomic_state *atomic_state)
585 {
586 struct drm_device *drm = plane->dev;
587 struct gud_device *gdrm = to_gud_device(drm);
588 struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(atomic_state, plane);
589 struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(atomic_state, plane);
590 struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(new_state);
591 struct drm_framebuffer *fb = new_state->fb;
592 struct drm_crtc *crtc = new_state->crtc;
593 struct drm_rect damage;
594 struct drm_atomic_helper_damage_iter iter;
595 int ret, idx;
596
597 if (!crtc || crtc->state->mode_changed || !crtc->state->enable) {
598 cancel_work_sync(&gdrm->work);
599 mutex_lock(&gdrm->damage_lock);
600 if (gdrm->fb) {
601 drm_framebuffer_put(gdrm->fb);
602 gdrm->fb = NULL;
603 }
604 gud_clear_damage(gdrm);
605 vfree(gdrm->shadow_buf);
606 gdrm->shadow_buf = NULL;
607 mutex_unlock(&gdrm->damage_lock);
608 }
609
610 if (!drm_dev_enter(drm, &idx))
611 return;
612
613 if (!old_state->fb)
614 gud_usb_set_u8(gdrm, GUD_REQ_SET_CONTROLLER_ENABLE, 1);
615
616 if (fb && (crtc->state->mode_changed || crtc->state->connectors_changed))
617 gud_usb_set(gdrm, GUD_REQ_SET_STATE_COMMIT, 0, NULL, 0);
618
619 if (crtc->state->active_changed)
620 gud_usb_set_u8(gdrm, GUD_REQ_SET_DISPLAY_ENABLE, crtc->state->active);
621
622 if (!fb)
623 goto ctrl_disable;
624
625 ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE);
626 if (ret)
627 goto ctrl_disable;
628
629 drm_atomic_helper_damage_iter_init(&iter, old_state, new_state);
630 drm_atomic_for_each_plane_damage(&iter, &damage)
631 gud_fb_handle_damage(gdrm, fb, &shadow_plane_state->data[0], &damage);
632
633 drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE);
634
635 ctrl_disable:
636 if (!crtc->state->enable)
637 gud_usb_set_u8(gdrm, GUD_REQ_SET_CONTROLLER_ENABLE, 0);
638
639 drm_dev_exit(idx);
640 }
641