gud_pipe.c

  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 */
 32static bool gud_async_flush;
 33module_param_named(async_flush, gud_async_flush, bool, 0644);
 34MODULE_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
 42static bool gud_is_big_endian(void)
 43{
 44#if defined(__BIG_ENDIAN)
 45	return true;
 46#else
 47	return false;
 48#endif
 49}
 50
 51static 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
101static 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
152static 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;
169retry:
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
234struct gud_usb_bulk_context {
235	struct timer_list timer;
236	struct usb_sg_request sgr;
237};
238
239static 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
246static 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
273static 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
316void 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
324static 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
365void 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);
390out:
391	drm_dev_exit(idx);
392}
393
394static 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
435static 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
453int 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	}
577out:
578	kfree(req);
579
580	return ret;
581}
582
583void 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
635ctrl_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}