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