xref: /linux/drivers/gpu/drm/tiny/appletbdrm.c (revision cb8fef4b07f71da01843457b66e579ad248a625e)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Apple Touch Bar DRM Driver
4  *
5  * Copyright (c) 2023 Kerem Karabay <kekrby@gmail.com>
6  */
7 
8 #include <linux/align.h>
9 #include <linux/array_size.h>
10 #include <linux/bitops.h>
11 #include <linux/bug.h>
12 #include <linux/container_of.h>
13 #include <linux/err.h>
14 #include <linux/module.h>
15 #include <linux/overflow.h>
16 #include <linux/slab.h>
17 #include <linux/types.h>
18 #include <linux/unaligned.h>
19 #include <linux/usb.h>
20 
21 #include <drm/drm_atomic.h>
22 #include <drm/drm_atomic_helper.h>
23 #include <drm/drm_crtc.h>
24 #include <drm/drm_damage_helper.h>
25 #include <drm/drm_drv.h>
26 #include <drm/drm_encoder.h>
27 #include <drm/drm_format_helper.h>
28 #include <drm/drm_fourcc.h>
29 #include <drm/drm_framebuffer.h>
30 #include <drm/drm_gem_atomic_helper.h>
31 #include <drm/drm_gem_framebuffer_helper.h>
32 #include <drm/drm_gem_shmem_helper.h>
33 #include <drm/drm_modeset_helper.h>
34 #include <drm/drm_plane.h>
35 #include <drm/drm_print.h>
36 #include <drm/drm_probe_helper.h>
37 
38 #define APPLETBDRM_PIXEL_FORMAT		cpu_to_le32(0x52474241) /* RGBA, the actual format is BGR888 */
39 #define APPLETBDRM_BITS_PER_PIXEL	24
40 
41 #define APPLETBDRM_MSG_CLEAR_DISPLAY	cpu_to_le32(0x434c5244) /* CLRD */
42 #define APPLETBDRM_MSG_GET_INFORMATION	cpu_to_le32(0x47494e46) /* GINF */
43 #define APPLETBDRM_MSG_UPDATE_COMPLETE	cpu_to_le32(0x5544434c) /* UDCL */
44 #define APPLETBDRM_MSG_SIGNAL_READINESS	cpu_to_le32(0x52454459) /* REDY */
45 
46 #define APPLETBDRM_BULK_MSG_TIMEOUT	1000
47 
48 #define drm_to_adev(_drm)		container_of(_drm, struct appletbdrm_device, drm)
49 #define adev_to_udev(adev)		interface_to_usbdev(to_usb_interface((adev)->drm.dev))
50 
51 struct appletbdrm_msg_request_header {
52 	__le16 unk_00;
53 	__le16 unk_02;
54 	__le32 unk_04;
55 	__le32 unk_08;
56 	__le32 size;
57 } __packed;
58 
59 struct appletbdrm_msg_response_header {
60 	u8 unk_00[16];
61 	__le32 msg;
62 } __packed;
63 
64 struct appletbdrm_msg_simple_request {
65 	struct appletbdrm_msg_request_header header;
66 	__le32 msg;
67 	u8 unk_14[8];
68 	__le32 size;
69 } __packed;
70 
71 struct appletbdrm_msg_information {
72 	struct appletbdrm_msg_response_header header;
73 	u8 unk_14[12];
74 	__le32 width;
75 	__le32 height;
76 	u8 bits_per_pixel;
77 	__le32 bytes_per_row;
78 	__le32 orientation;
79 	__le32 bitmap_info;
80 	__le32 pixel_format;
81 	__le32 width_inches;	/* floating point */
82 	__le32 height_inches;	/* floating point */
83 } __packed;
84 
85 struct appletbdrm_frame {
86 	__le16 begin_x;
87 	__le16 begin_y;
88 	__le16 width;
89 	__le16 height;
90 	__le32 buf_size;
91 	u8 buf[];
92 } __packed;
93 
94 struct appletbdrm_fb_request_footer {
95 	u8 unk_00[12];
96 	__le32 unk_0c;
97 	u8 unk_10[12];
98 	__le32 unk_1c;
99 	__le64 timestamp;
100 	u8 unk_28[12];
101 	__le32 unk_34;
102 	u8 unk_38[20];
103 	__le32 unk_4c;
104 } __packed;
105 
106 struct appletbdrm_fb_request {
107 	struct appletbdrm_msg_request_header header;
108 	__le16 unk_10;
109 	u8 msg_id;
110 	u8 unk_13[29];
111 	/*
112 	 * Contents of `data`:
113 	 * - struct appletbdrm_frame frames[];
114 	 * - struct appletbdrm_fb_request_footer footer;
115 	 * - padding to make the total size a multiple of 16
116 	 */
117 	u8 data[];
118 } __packed;
119 
120 struct appletbdrm_fb_request_response {
121 	struct appletbdrm_msg_response_header header;
122 	u8 unk_14[12];
123 	__le64 timestamp;
124 } __packed;
125 
126 struct appletbdrm_device {
127 	unsigned int in_ep;
128 	unsigned int out_ep;
129 
130 	unsigned int width;
131 	unsigned int height;
132 
133 	struct drm_device drm;
134 	struct drm_display_mode mode;
135 	struct drm_connector connector;
136 	struct drm_plane primary_plane;
137 	struct drm_crtc crtc;
138 	struct drm_encoder encoder;
139 };
140 
141 struct appletbdrm_plane_state {
142 	struct drm_shadow_plane_state base;
143 	struct appletbdrm_fb_request *request;
144 	struct appletbdrm_fb_request_response *response;
145 	size_t request_size;
146 	size_t frames_size;
147 };
148 
149 static inline struct appletbdrm_plane_state *to_appletbdrm_plane_state(struct drm_plane_state *state)
150 {
151 	return container_of(state, struct appletbdrm_plane_state, base.base);
152 }
153 
154 static int appletbdrm_send_request(struct appletbdrm_device *adev,
155 				   struct appletbdrm_msg_request_header *request, size_t size)
156 {
157 	struct usb_device *udev = adev_to_udev(adev);
158 	struct drm_device *drm = &adev->drm;
159 	int ret, actual_size;
160 
161 	ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, adev->out_ep),
162 			   request, size, &actual_size, APPLETBDRM_BULK_MSG_TIMEOUT);
163 	if (ret) {
164 		drm_err(drm, "Failed to send message (%d)\n", ret);
165 		return ret;
166 	}
167 
168 	if (actual_size != size) {
169 		drm_err(drm, "Actual size (%d) doesn't match expected size (%zu)\n",
170 			actual_size, size);
171 		return -EIO;
172 	}
173 
174 	return 0;
175 }
176 
177 static int appletbdrm_read_response(struct appletbdrm_device *adev,
178 				    struct appletbdrm_msg_response_header *response,
179 				    size_t size, __le32 expected_response)
180 {
181 	struct usb_device *udev = adev_to_udev(adev);
182 	struct drm_device *drm = &adev->drm;
183 	int ret, actual_size;
184 	bool readiness_signal_received = false;
185 
186 retry:
187 	ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, adev->in_ep),
188 			   response, size, &actual_size, APPLETBDRM_BULK_MSG_TIMEOUT);
189 	if (ret) {
190 		drm_err(drm, "Failed to read response (%d)\n", ret);
191 		return ret;
192 	}
193 
194 	/*
195 	 * The device responds to the first request sent in a particular
196 	 * timeframe after the USB device configuration is set with a readiness
197 	 * signal, in which case the response should be read again
198 	 */
199 	if (response->msg == APPLETBDRM_MSG_SIGNAL_READINESS) {
200 		if (!readiness_signal_received) {
201 			readiness_signal_received = true;
202 			goto retry;
203 		}
204 
205 		drm_err(drm, "Encountered unexpected readiness signal\n");
206 		return -EINTR;
207 	}
208 
209 	if (actual_size != size) {
210 		drm_err(drm, "Actual size (%d) doesn't match expected size (%zu)\n",
211 			actual_size, size);
212 		return -EBADMSG;
213 	}
214 
215 	if (response->msg != expected_response) {
216 		drm_err(drm, "Unexpected response from device (expected %p4cl found %p4cl)\n",
217 			&expected_response, &response->msg);
218 		return -EIO;
219 	}
220 
221 	return 0;
222 }
223 
224 static int appletbdrm_send_msg(struct appletbdrm_device *adev, __le32 msg)
225 {
226 	struct appletbdrm_msg_simple_request *request;
227 	int ret;
228 
229 	request = kzalloc_obj(*request);
230 	if (!request)
231 		return -ENOMEM;
232 
233 	request->header.unk_00 = cpu_to_le16(2);
234 	request->header.unk_02 = cpu_to_le16(0x1512);
235 	request->header.size = cpu_to_le32(sizeof(*request) - sizeof(request->header));
236 	request->msg = msg;
237 	request->size = request->header.size;
238 
239 	ret = appletbdrm_send_request(adev, &request->header, sizeof(*request));
240 
241 	kfree(request);
242 
243 	return ret;
244 }
245 
246 static int appletbdrm_clear_display(struct appletbdrm_device *adev)
247 {
248 	return appletbdrm_send_msg(adev, APPLETBDRM_MSG_CLEAR_DISPLAY);
249 }
250 
251 static int appletbdrm_signal_readiness(struct appletbdrm_device *adev)
252 {
253 	return appletbdrm_send_msg(adev, APPLETBDRM_MSG_SIGNAL_READINESS);
254 }
255 
256 static int appletbdrm_get_information(struct appletbdrm_device *adev)
257 {
258 	struct appletbdrm_msg_information *info;
259 	struct drm_device *drm = &adev->drm;
260 	u8 bits_per_pixel;
261 	__le32 pixel_format;
262 	int ret;
263 
264 	info = kzalloc_obj(*info);
265 	if (!info)
266 		return -ENOMEM;
267 
268 	ret = appletbdrm_send_msg(adev, APPLETBDRM_MSG_GET_INFORMATION);
269 	if (ret)
270 		return ret;
271 
272 	ret = appletbdrm_read_response(adev, &info->header, sizeof(*info),
273 				       APPLETBDRM_MSG_GET_INFORMATION);
274 	if (ret)
275 		goto free_info;
276 
277 	bits_per_pixel = info->bits_per_pixel;
278 	pixel_format = get_unaligned(&info->pixel_format);
279 
280 	adev->width = get_unaligned_le32(&info->width);
281 	adev->height = get_unaligned_le32(&info->height);
282 
283 	if (bits_per_pixel != APPLETBDRM_BITS_PER_PIXEL) {
284 		drm_err(drm, "Encountered unexpected bits per pixel value (%d)\n", bits_per_pixel);
285 		ret = -EINVAL;
286 		goto free_info;
287 	}
288 
289 	if (pixel_format != APPLETBDRM_PIXEL_FORMAT) {
290 		drm_err(drm, "Encountered unknown pixel format (%p4cl)\n", &pixel_format);
291 		ret = -EINVAL;
292 		goto free_info;
293 	}
294 
295 free_info:
296 	kfree(info);
297 
298 	return ret;
299 }
300 
301 static u32 rect_size(struct drm_rect *rect)
302 {
303 	return drm_rect_width(rect) * drm_rect_height(rect) *
304 		(BITS_TO_BYTES(APPLETBDRM_BITS_PER_PIXEL));
305 }
306 
307 static int appletbdrm_connector_helper_get_modes(struct drm_connector *connector)
308 {
309 	struct appletbdrm_device *adev = drm_to_adev(connector->dev);
310 
311 	return drm_connector_helper_get_modes_fixed(connector, &adev->mode);
312 }
313 
314 static const u32 appletbdrm_primary_plane_formats[] = {
315 	DRM_FORMAT_BGR888,
316 	DRM_FORMAT_XRGB8888, /* emulated */
317 };
318 
319 static int appletbdrm_primary_plane_helper_begin_fb_access(struct drm_plane *plane,
320 							   struct drm_plane_state *new_plane_state)
321 {
322 	struct appletbdrm_plane_state *appletbdrm_state = to_appletbdrm_plane_state(new_plane_state);
323 	size_t frames_size = 0;
324 	struct drm_atomic_helper_damage_iter iter;
325 	struct drm_rect damage;
326 	size_t request_size;
327 
328 	drm_atomic_helper_damage_iter_init(&iter, plane->state, new_plane_state);
329 	drm_atomic_for_each_plane_damage(&iter, &damage) {
330 		frames_size += struct_size((struct appletbdrm_frame *)0, buf, rect_size(&damage));
331 	}
332 
333 	if (!frames_size)
334 		return 0;
335 
336 	request_size = ALIGN(sizeof(struct appletbdrm_fb_request) +
337 		       frames_size +
338 		       sizeof(struct appletbdrm_fb_request_footer), 16);
339 
340 	appletbdrm_state->request = kvzalloc(request_size, GFP_KERNEL);
341 
342 	if (!appletbdrm_state->request)
343 		return -ENOMEM;
344 
345 	appletbdrm_state->response = kzalloc_obj(*appletbdrm_state->response);
346 
347 	if (!appletbdrm_state->response)
348 		return -ENOMEM;
349 
350 	appletbdrm_state->request_size = request_size;
351 	appletbdrm_state->frames_size = frames_size;
352 
353 	return drm_gem_begin_shadow_fb_access(plane, new_plane_state);
354 }
355 
356 static int appletbdrm_primary_plane_helper_atomic_check(struct drm_plane *plane,
357 							struct drm_atomic_commit *state)
358 {
359 	struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
360 	struct drm_crtc *new_crtc = new_plane_state->crtc;
361 	struct drm_crtc_state *new_crtc_state = NULL;
362 	int ret;
363 
364 	if (new_crtc)
365 		new_crtc_state = drm_atomic_get_new_crtc_state(state, new_crtc);
366 
367 	ret = drm_atomic_helper_check_plane_state(new_plane_state, new_crtc_state,
368 						  DRM_PLANE_NO_SCALING,
369 						  DRM_PLANE_NO_SCALING,
370 						  false, false);
371 	if (ret)
372 		return ret;
373 	else if (!new_plane_state->visible)
374 		return 0;
375 
376 	return 0;
377 }
378 
379 static int appletbdrm_flush_damage(struct appletbdrm_device *adev,
380 				   struct drm_plane_state *old_state,
381 				   struct drm_plane_state *state)
382 {
383 	struct appletbdrm_plane_state *appletbdrm_state = to_appletbdrm_plane_state(state);
384 	struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(state);
385 	struct appletbdrm_fb_request_response *response = appletbdrm_state->response;
386 	struct appletbdrm_fb_request_footer *footer;
387 	struct drm_atomic_helper_damage_iter iter;
388 	struct drm_framebuffer *fb = state->fb;
389 	struct appletbdrm_fb_request *request = appletbdrm_state->request;
390 	struct drm_device *drm = &adev->drm;
391 	struct appletbdrm_frame *frame;
392 	u64 timestamp = ktime_get_ns();
393 	struct drm_rect damage;
394 	size_t frames_size = appletbdrm_state->frames_size;
395 	size_t request_size = appletbdrm_state->request_size;
396 	int ret;
397 
398 	if (!frames_size)
399 		return 0;
400 
401 	ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE);
402 	if (ret) {
403 		drm_err(drm, "Failed to start CPU framebuffer access (%d)\n", ret);
404 		goto end_fb_cpu_access;
405 	}
406 
407 	request->header.unk_00 = cpu_to_le16(2);
408 	request->header.unk_02 = cpu_to_le16(0x12);
409 	request->header.unk_04 = cpu_to_le32(9);
410 	request->header.size = cpu_to_le32(request_size - sizeof(request->header));
411 	request->unk_10 = cpu_to_le16(1);
412 	request->msg_id = timestamp;
413 
414 	frame = (struct appletbdrm_frame *)request->data;
415 
416 	drm_atomic_helper_damage_iter_init(&iter, old_state, state);
417 	drm_atomic_for_each_plane_damage(&iter, &damage) {
418 		struct drm_rect dst_clip = state->dst;
419 		struct iosys_map dst = IOSYS_MAP_INIT_VADDR(frame->buf);
420 		u32 buf_size = rect_size(&damage);
421 
422 		if (!drm_rect_intersect(&dst_clip, &damage))
423 			continue;
424 
425 		/*
426 		 * The coordinates need to be translated to the coordinate
427 		 * system the device expects, see the comment in
428 		 * appletbdrm_setup_mode_config
429 		 */
430 		frame->begin_x = cpu_to_le16(damage.y1);
431 		frame->begin_y = cpu_to_le16(adev->height - damage.x2);
432 		frame->width = cpu_to_le16(drm_rect_height(&damage));
433 		frame->height = cpu_to_le16(drm_rect_width(&damage));
434 		frame->buf_size = cpu_to_le32(buf_size);
435 
436 		switch (fb->format->format) {
437 		case DRM_FORMAT_XRGB8888:
438 			drm_fb_xrgb8888_to_bgr888(&dst, NULL, &shadow_plane_state->data[0], fb, &damage, &shadow_plane_state->fmtcnv_state);
439 			break;
440 		default:
441 			drm_fb_memcpy(&dst, NULL, &shadow_plane_state->data[0], fb, &damage);
442 			break;
443 		}
444 
445 		frame = (void *)frame + struct_size(frame, buf, buf_size);
446 	}
447 
448 	footer = (struct appletbdrm_fb_request_footer *)&request->data[frames_size];
449 
450 	footer->unk_0c = cpu_to_le32(0xfffe);
451 	footer->unk_1c = cpu_to_le32(0x80001);
452 	footer->unk_34 = cpu_to_le32(0x80002);
453 	footer->unk_4c = cpu_to_le32(0xffff);
454 	footer->timestamp = cpu_to_le64(timestamp);
455 
456 	ret = appletbdrm_send_request(adev, &request->header, request_size);
457 	if (ret)
458 		goto end_fb_cpu_access;
459 
460 	ret = appletbdrm_read_response(adev, &response->header, sizeof(*response),
461 				       APPLETBDRM_MSG_UPDATE_COMPLETE);
462 	if (ret)
463 		goto end_fb_cpu_access;
464 
465 	if (response->timestamp != footer->timestamp) {
466 		drm_err(drm, "Response timestamp (%llu) doesn't match request timestamp (%llu)\n",
467 			le64_to_cpu(response->timestamp), timestamp);
468 		goto end_fb_cpu_access;
469 	}
470 
471 end_fb_cpu_access:
472 	drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE);
473 
474 	return ret;
475 }
476 
477 static void appletbdrm_primary_plane_helper_atomic_update(struct drm_plane *plane,
478 							  struct drm_atomic_commit *old_state)
479 {
480 	struct appletbdrm_device *adev = drm_to_adev(plane->dev);
481 	struct drm_device *drm = plane->dev;
482 	struct drm_plane_state *plane_state = plane->state;
483 	struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(old_state, plane);
484 	int idx;
485 
486 	if (!drm_dev_enter(drm, &idx))
487 		return;
488 
489 	appletbdrm_flush_damage(adev, old_plane_state, plane_state);
490 
491 	drm_dev_exit(idx);
492 }
493 
494 static void appletbdrm_primary_plane_helper_atomic_disable(struct drm_plane *plane,
495 							   struct drm_atomic_commit *state)
496 {
497 	struct drm_device *dev = plane->dev;
498 	struct appletbdrm_device *adev = drm_to_adev(dev);
499 	int idx;
500 
501 	if (!drm_dev_enter(dev, &idx))
502 		return;
503 
504 	appletbdrm_clear_display(adev);
505 
506 	drm_dev_exit(idx);
507 }
508 
509 static struct drm_plane_state *appletbdrm_primary_plane_create_state(struct drm_plane *plane)
510 {
511 	struct appletbdrm_plane_state *appletbdrm_state;
512 
513 	appletbdrm_state = kzalloc_obj(*appletbdrm_state);
514 	if (!appletbdrm_state)
515 		return ERR_PTR(-ENOMEM);
516 
517 	__drm_gem_shadow_plane_state_init(plane, &appletbdrm_state->base);
518 
519 	return &(&appletbdrm_state->base)->base;
520 }
521 
522 static struct drm_plane_state *appletbdrm_primary_plane_duplicate_state(struct drm_plane *plane)
523 {
524 	struct drm_shadow_plane_state *new_shadow_plane_state;
525 	struct appletbdrm_plane_state *appletbdrm_state;
526 
527 	if (WARN_ON(!plane->state))
528 		return NULL;
529 
530 	appletbdrm_state = kzalloc_obj(*appletbdrm_state);
531 	if (!appletbdrm_state)
532 		return NULL;
533 
534 	/* Request and response are not duplicated and are allocated in .atomic_check */
535 	appletbdrm_state->request = NULL;
536 	appletbdrm_state->response = NULL;
537 
538 	appletbdrm_state->request_size = 0;
539 	appletbdrm_state->frames_size = 0;
540 
541 	new_shadow_plane_state = &appletbdrm_state->base;
542 
543 	__drm_gem_duplicate_shadow_plane_state(plane, new_shadow_plane_state);
544 
545 	return &new_shadow_plane_state->base;
546 }
547 
548 static void appletbdrm_primary_plane_destroy_state(struct drm_plane *plane,
549 						   struct drm_plane_state *state)
550 {
551 	struct appletbdrm_plane_state *appletbdrm_state = to_appletbdrm_plane_state(state);
552 
553 	kvfree(appletbdrm_state->request);
554 	kfree(appletbdrm_state->response);
555 
556 	__drm_gem_destroy_shadow_plane_state(&appletbdrm_state->base);
557 
558 	kfree(appletbdrm_state);
559 }
560 
561 static const struct drm_plane_helper_funcs appletbdrm_primary_plane_helper_funcs = {
562 	.begin_fb_access = appletbdrm_primary_plane_helper_begin_fb_access,
563 	.end_fb_access = drm_gem_end_shadow_fb_access,
564 	.atomic_check = appletbdrm_primary_plane_helper_atomic_check,
565 	.atomic_update = appletbdrm_primary_plane_helper_atomic_update,
566 	.atomic_disable = appletbdrm_primary_plane_helper_atomic_disable,
567 };
568 
569 static const struct drm_plane_funcs appletbdrm_primary_plane_funcs = {
570 	.update_plane = drm_atomic_helper_update_plane,
571 	.disable_plane = drm_atomic_helper_disable_plane,
572 	.atomic_create_state = appletbdrm_primary_plane_create_state,
573 	.atomic_duplicate_state = appletbdrm_primary_plane_duplicate_state,
574 	.atomic_destroy_state = appletbdrm_primary_plane_destroy_state,
575 	.destroy = drm_plane_cleanup,
576 };
577 
578 static enum drm_mode_status appletbdrm_crtc_helper_mode_valid(struct drm_crtc *crtc,
579 							  const struct drm_display_mode *mode)
580 {
581 	struct appletbdrm_device *adev = drm_to_adev(crtc->dev);
582 
583 	return drm_crtc_helper_mode_valid_fixed(crtc, mode, &adev->mode);
584 }
585 
586 static const struct drm_mode_config_funcs appletbdrm_mode_config_funcs = {
587 	.fb_create = drm_gem_fb_create_with_dirty,
588 	.atomic_check = drm_atomic_helper_check,
589 	.atomic_commit = drm_atomic_helper_commit,
590 };
591 
592 static const struct drm_connector_funcs appletbdrm_connector_funcs = {
593 	.atomic_create_state = drm_atomic_helper_connector_create_state,
594 	.destroy = drm_connector_cleanup,
595 	.fill_modes = drm_helper_probe_single_connector_modes,
596 	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
597 	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
598 };
599 
600 static const struct drm_connector_helper_funcs appletbdrm_connector_helper_funcs = {
601 	.get_modes = appletbdrm_connector_helper_get_modes,
602 };
603 
604 static const struct drm_crtc_helper_funcs appletbdrm_crtc_helper_funcs = {
605 	.mode_valid = appletbdrm_crtc_helper_mode_valid,
606 };
607 
608 static const struct drm_crtc_funcs appletbdrm_crtc_funcs = {
609 	.atomic_create_state = drm_atomic_helper_crtc_create_state,
610 	.destroy = drm_crtc_cleanup,
611 	.set_config = drm_atomic_helper_set_config,
612 	.page_flip = drm_atomic_helper_page_flip,
613 	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
614 	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
615 };
616 
617 static const struct drm_encoder_funcs appletbdrm_encoder_funcs = {
618 	.destroy = drm_encoder_cleanup,
619 };
620 
621 DEFINE_DRM_GEM_FOPS(appletbdrm_drm_fops);
622 
623 static const struct drm_driver appletbdrm_drm_driver = {
624 	DRM_GEM_SHMEM_DRIVER_OPS,
625 	.name			= "appletbdrm",
626 	.desc			= "Apple Touch Bar DRM Driver",
627 	.major			= 1,
628 	.minor			= 0,
629 	.driver_features	= DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
630 	.fops			= &appletbdrm_drm_fops,
631 };
632 
633 static int appletbdrm_setup_mode_config(struct appletbdrm_device *adev)
634 {
635 	struct drm_connector *connector = &adev->connector;
636 	struct drm_plane *primary_plane;
637 	struct drm_crtc *crtc;
638 	struct drm_encoder *encoder;
639 	struct drm_device *drm = &adev->drm;
640 	int ret;
641 
642 	ret = drmm_mode_config_init(drm);
643 	if (ret) {
644 		drm_err(drm, "Failed to initialize mode configuration\n");
645 		return ret;
646 	}
647 
648 	primary_plane = &adev->primary_plane;
649 	ret = drm_universal_plane_init(drm, primary_plane, 0,
650 				       &appletbdrm_primary_plane_funcs,
651 				       appletbdrm_primary_plane_formats,
652 				       ARRAY_SIZE(appletbdrm_primary_plane_formats),
653 				       NULL,
654 				       DRM_PLANE_TYPE_PRIMARY, NULL);
655 	if (ret) {
656 		drm_err(drm, "Failed to initialize universal plane object\n");
657 		return ret;
658 	}
659 
660 	drm_plane_helper_add(primary_plane, &appletbdrm_primary_plane_helper_funcs);
661 	drm_plane_enable_fb_damage_clips(primary_plane);
662 
663 	crtc = &adev->crtc;
664 	ret = drm_crtc_init_with_planes(drm, crtc, primary_plane, NULL,
665 					&appletbdrm_crtc_funcs, NULL);
666 	if (ret) {
667 		drm_err(drm, "Failed to initialize CRTC object\n");
668 		return ret;
669 	}
670 
671 	drm_crtc_helper_add(crtc, &appletbdrm_crtc_helper_funcs);
672 
673 	encoder = &adev->encoder;
674 	ret = drm_encoder_init(drm, encoder, &appletbdrm_encoder_funcs,
675 			       DRM_MODE_ENCODER_DAC, NULL);
676 	if (ret) {
677 		drm_err(drm, "Failed to initialize encoder\n");
678 		return ret;
679 	}
680 
681 	encoder->possible_crtcs = drm_crtc_mask(crtc);
682 
683 	/*
684 	 * The coordinate system used by the device is different from the
685 	 * coordinate system of the framebuffer in that the x and y axes are
686 	 * swapped, and that the y axis is inverted; so what the device reports
687 	 * as the height is actually the width of the framebuffer and vice
688 	 * versa.
689 	 */
690 	drm->mode_config.max_width = max(adev->height, DRM_SHADOW_PLANE_MAX_WIDTH);
691 	drm->mode_config.max_height = max(adev->width, DRM_SHADOW_PLANE_MAX_HEIGHT);
692 	drm->mode_config.preferred_depth = APPLETBDRM_BITS_PER_PIXEL;
693 	drm->mode_config.funcs = &appletbdrm_mode_config_funcs;
694 
695 	adev->mode = (struct drm_display_mode) {
696 		DRM_MODE_INIT(60, adev->height, adev->width,
697 			      DRM_MODE_RES_MM(adev->height, 218),
698 			      DRM_MODE_RES_MM(adev->width, 218))
699 	};
700 
701 	ret = drm_connector_init(drm, connector,
702 				 &appletbdrm_connector_funcs, DRM_MODE_CONNECTOR_USB);
703 	if (ret) {
704 		drm_err(drm, "Failed to initialize connector\n");
705 		return ret;
706 	}
707 
708 	drm_connector_helper_add(connector, &appletbdrm_connector_helper_funcs);
709 
710 	ret = drm_connector_set_panel_orientation(connector,
711 						  DRM_MODE_PANEL_ORIENTATION_RIGHT_UP);
712 	if (ret) {
713 		drm_err(drm, "Failed to set panel orientation\n");
714 		return ret;
715 	}
716 
717 	connector->display_info.non_desktop = true;
718 	ret = drm_object_property_set_value(&connector->base,
719 					    drm->mode_config.non_desktop_property, true);
720 	if (ret) {
721 		drm_err(drm, "Failed to set non-desktop property\n");
722 		return ret;
723 	}
724 
725 	ret = drm_connector_attach_encoder(connector, encoder);
726 
727 	if (ret) {
728 		drm_err(drm, "Failed to attach connector to encoder\n");
729 		return ret;
730 	}
731 
732 	drm_mode_config_reset(drm);
733 
734 	return 0;
735 }
736 
737 static int appletbdrm_probe(struct usb_interface *intf,
738 			    const struct usb_device_id *id)
739 {
740 	struct usb_endpoint_descriptor *bulk_in, *bulk_out;
741 	struct device *dev = &intf->dev;
742 	struct appletbdrm_device *adev;
743 	struct drm_device *drm = NULL;
744 	struct device *dma_dev;
745 	int ret;
746 
747 	ret = usb_find_common_endpoints(intf->cur_altsetting, &bulk_in, &bulk_out, NULL, NULL);
748 	if (ret) {
749 		drm_err(drm, "appletbdrm: Failed to find bulk endpoints\n");
750 		return ret;
751 	}
752 
753 	adev = devm_drm_dev_alloc(dev, &appletbdrm_drm_driver, struct appletbdrm_device, drm);
754 	if (IS_ERR(adev))
755 		return PTR_ERR(adev);
756 
757 	adev->in_ep = bulk_in->bEndpointAddress;
758 	adev->out_ep = bulk_out->bEndpointAddress;
759 
760 	drm = &adev->drm;
761 
762 	usb_set_intfdata(intf, adev);
763 
764 	dma_dev = usb_intf_get_dma_device(intf);
765 	if (dma_dev) {
766 		drm_dev_set_dma_dev(drm, dma_dev);
767 		put_device(dma_dev);
768 	} else {
769 		drm_warn(drm, "buffer sharing not supported"); /* not an error */
770 	}
771 
772 	ret = appletbdrm_get_information(adev);
773 	if (ret) {
774 		drm_err(drm, "Failed to get display information\n");
775 		return ret;
776 	}
777 
778 	ret = appletbdrm_signal_readiness(adev);
779 	if (ret) {
780 		drm_err(drm, "Failed to signal readiness\n");
781 		return ret;
782 	}
783 
784 	ret = appletbdrm_setup_mode_config(adev);
785 	if (ret) {
786 		drm_err(drm, "Failed to setup mode config\n");
787 		return ret;
788 	}
789 
790 	ret = drm_dev_register(drm, 0);
791 	if (ret) {
792 		drm_err(drm, "Failed to register DRM device\n");
793 		return ret;
794 	}
795 
796 	ret = appletbdrm_clear_display(adev);
797 	if (ret) {
798 		drm_err(drm, "Failed to clear display\n");
799 		return ret;
800 	}
801 
802 	return 0;
803 }
804 
805 static void appletbdrm_disconnect(struct usb_interface *intf)
806 {
807 	struct appletbdrm_device *adev = usb_get_intfdata(intf);
808 	struct drm_device *drm = &adev->drm;
809 
810 	drm_dev_unplug(drm);
811 	drm_atomic_helper_shutdown(drm);
812 }
813 
814 static void appletbdrm_shutdown(struct usb_interface *intf)
815 {
816 	struct appletbdrm_device *adev = usb_get_intfdata(intf);
817 
818 	/*
819 	 * The framebuffer needs to be cleared on shutdown since its content
820 	 * persists across boots
821 	 */
822 	drm_atomic_helper_shutdown(&adev->drm);
823 }
824 
825 static int appletbdrm_suspend(struct usb_interface *intf, pm_message_t message)
826 {
827 	struct appletbdrm_device *adev = usb_get_intfdata(intf);
828 
829 	return drm_mode_config_helper_suspend(&adev->drm);
830 }
831 
832 static int appletbdrm_resume(struct usb_interface *intf)
833 {
834 	struct appletbdrm_device *adev = usb_get_intfdata(intf);
835 
836 	return drm_mode_config_helper_resume(&adev->drm);
837 }
838 
839 static int appletbdrm_reset_resume(struct usb_interface *intf)
840 {
841 	struct appletbdrm_device *adev = usb_get_intfdata(intf);
842 	struct drm_device *drm = &adev->drm;
843 	int ret, resume_ret;
844 
845 	/*
846 	 * A reset puts the device back into its initial state, where it
847 	 * expects the same handshake as during probe. Resume the DRM side
848 	 * even if the handshake fails, so that the state saved on suspend
849 	 * is released.
850 	 */
851 	ret = appletbdrm_get_information(adev);
852 	if (ret) {
853 		drm_err(drm, "Failed to get display information\n");
854 		goto resume;
855 	}
856 
857 	ret = appletbdrm_signal_readiness(adev);
858 	if (ret)
859 		drm_err(drm, "Failed to signal readiness\n");
860 
861 resume:
862 	resume_ret = drm_mode_config_helper_resume(drm);
863 
864 	return ret ? ret : resume_ret;
865 }
866 
867 static const struct usb_device_id appletbdrm_usb_id_table[] = {
868 	{ USB_DEVICE_INTERFACE_CLASS(0x05ac, 0x8302, USB_CLASS_AUDIO_VIDEO) },
869 	{}
870 };
871 MODULE_DEVICE_TABLE(usb, appletbdrm_usb_id_table);
872 
873 static struct usb_driver appletbdrm_usb_driver = {
874 	.name		= "appletbdrm",
875 	.probe		= appletbdrm_probe,
876 	.disconnect	= appletbdrm_disconnect,
877 	.shutdown	= appletbdrm_shutdown,
878 	.suspend	= appletbdrm_suspend,
879 	.resume		= appletbdrm_resume,
880 	.reset_resume	= appletbdrm_reset_resume,
881 	.id_table	= appletbdrm_usb_id_table,
882 };
883 module_usb_driver(appletbdrm_usb_driver);
884 
885 MODULE_AUTHOR("Kerem Karabay <kekrby@gmail.com>");
886 MODULE_DESCRIPTION("Apple Touch Bar DRM Driver");
887 MODULE_LICENSE("GPL");
888