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