1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2019 Hans de Goede <hdegoede@redhat.com> 4 */ 5 6 #include <linux/dma-buf.h> 7 #include <linux/module.h> 8 #include <linux/usb.h> 9 10 #include <drm/drm_atomic_helper.h> 11 #include <drm/drm_atomic_state_helper.h> 12 #include <drm/drm_connector.h> 13 #include <drm/drm_damage_helper.h> 14 #include <drm/drm_drv.h> 15 #include <drm/drm_fb_helper.h> 16 #include <drm/drm_file.h> 17 #include <drm/drm_format_helper.h> 18 #include <drm/drm_fourcc.h> 19 #include <drm/drm_gem_atomic_helper.h> 20 #include <drm/drm_gem_framebuffer_helper.h> 21 #include <drm/drm_gem_shmem_helper.h> 22 #include <drm/drm_ioctl.h> 23 #include <drm/drm_managed.h> 24 #include <drm/drm_modeset_helper_vtables.h> 25 #include <drm/drm_probe_helper.h> 26 #include <drm/drm_simple_kms_helper.h> 27 28 static bool eco_mode; 29 module_param(eco_mode, bool, 0644); 30 MODULE_PARM_DESC(eco_mode, "Turn on Eco mode (less bright, more silent)"); 31 32 #define DRIVER_NAME "gm12u320" 33 #define DRIVER_DESC "Grain Media GM12U320 USB projector display" 34 #define DRIVER_DATE "2019" 35 #define DRIVER_MAJOR 1 36 #define DRIVER_MINOR 0 37 38 /* 39 * The DLP has an actual width of 854 pixels, but that is not a multiple 40 * of 8, breaking things left and right, so we export a width of 848. 41 */ 42 #define GM12U320_USER_WIDTH 848 43 #define GM12U320_REAL_WIDTH 854 44 #define GM12U320_HEIGHT 480 45 46 #define GM12U320_BLOCK_COUNT 20 47 48 #define GM12U320_ERR(fmt, ...) \ 49 DRM_DEV_ERROR(gm12u320->dev.dev, fmt, ##__VA_ARGS__) 50 51 #define MISC_RCV_EPT 1 52 #define DATA_RCV_EPT 2 53 #define DATA_SND_EPT 3 54 #define MISC_SND_EPT 4 55 56 #define DATA_BLOCK_HEADER_SIZE 84 57 #define DATA_BLOCK_CONTENT_SIZE 64512 58 #define DATA_BLOCK_FOOTER_SIZE 20 59 #define DATA_BLOCK_SIZE (DATA_BLOCK_HEADER_SIZE + \ 60 DATA_BLOCK_CONTENT_SIZE + \ 61 DATA_BLOCK_FOOTER_SIZE) 62 #define DATA_LAST_BLOCK_CONTENT_SIZE 4032 63 #define DATA_LAST_BLOCK_SIZE (DATA_BLOCK_HEADER_SIZE + \ 64 DATA_LAST_BLOCK_CONTENT_SIZE + \ 65 DATA_BLOCK_FOOTER_SIZE) 66 67 #define CMD_SIZE 31 68 #define READ_STATUS_SIZE 13 69 #define MISC_VALUE_SIZE 4 70 71 #define CMD_TIMEOUT msecs_to_jiffies(200) 72 #define DATA_TIMEOUT msecs_to_jiffies(1000) 73 #define IDLE_TIMEOUT msecs_to_jiffies(2000) 74 #define FIRST_FRAME_TIMEOUT msecs_to_jiffies(2000) 75 76 #define MISC_REQ_GET_SET_ECO_A 0xff 77 #define MISC_REQ_GET_SET_ECO_B 0x35 78 /* Windows driver does once every second, with arg d = 1, other args 0 */ 79 #define MISC_REQ_UNKNOWN1_A 0xff 80 #define MISC_REQ_UNKNOWN1_B 0x38 81 /* Windows driver does this on init, with arg a, b = 0, c = 0xa0, d = 4 */ 82 #define MISC_REQ_UNKNOWN2_A 0xa5 83 #define MISC_REQ_UNKNOWN2_B 0x00 84 85 struct gm12u320_device { 86 struct drm_device dev; 87 struct device *dmadev; 88 struct drm_simple_display_pipe pipe; 89 struct drm_connector conn; 90 unsigned char *cmd_buf; 91 unsigned char *data_buf[GM12U320_BLOCK_COUNT]; 92 struct { 93 struct delayed_work work; 94 struct mutex lock; 95 struct drm_framebuffer *fb; 96 struct drm_rect rect; 97 int frame; 98 int draw_status_timeout; 99 struct dma_buf_map src_map; 100 } fb_update; 101 }; 102 103 #define to_gm12u320(__dev) container_of(__dev, struct gm12u320_device, dev) 104 105 static const char cmd_data[CMD_SIZE] = { 106 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00, 107 0x68, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x10, 0xff, 108 0x00, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x80, 0x00, 109 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 110 }; 111 112 static const char cmd_draw[CMD_SIZE] = { 113 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00, 114 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xfe, 115 0x00, 0x00, 0x00, 0xc0, 0xd1, 0x05, 0x00, 0x40, 116 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 117 }; 118 119 static const char cmd_misc[CMD_SIZE] = { 120 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00, 121 0x04, 0x00, 0x00, 0x00, 0x80, 0x01, 0x10, 0xfd, 122 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 123 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 124 }; 125 126 static const char data_block_header[DATA_BLOCK_HEADER_SIZE] = { 127 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 128 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 129 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 130 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 131 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 132 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 133 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 134 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 135 0xfb, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 136 0x00, 0x04, 0x15, 0x00, 0x00, 0xfc, 0x00, 0x00, 137 0x01, 0x00, 0x00, 0xdb 138 }; 139 140 static const char data_last_block_header[DATA_BLOCK_HEADER_SIZE] = { 141 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 142 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 143 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 144 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 145 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 146 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 147 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 148 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 149 0xfb, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 150 0x2a, 0x00, 0x20, 0x00, 0xc0, 0x0f, 0x00, 0x00, 151 0x01, 0x00, 0x00, 0xd7 152 }; 153 154 static const char data_block_footer[DATA_BLOCK_FOOTER_SIZE] = { 155 0xfb, 0x14, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 156 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 157 0x80, 0x00, 0x00, 0x4f 158 }; 159 160 static inline struct usb_device *gm12u320_to_usb_device(struct gm12u320_device *gm12u320) 161 { 162 return interface_to_usbdev(to_usb_interface(gm12u320->dev.dev)); 163 } 164 165 static int gm12u320_usb_alloc(struct gm12u320_device *gm12u320) 166 { 167 int i, block_size; 168 const char *hdr; 169 170 gm12u320->cmd_buf = drmm_kmalloc(&gm12u320->dev, CMD_SIZE, GFP_KERNEL); 171 if (!gm12u320->cmd_buf) 172 return -ENOMEM; 173 174 for (i = 0; i < GM12U320_BLOCK_COUNT; i++) { 175 if (i == GM12U320_BLOCK_COUNT - 1) { 176 block_size = DATA_LAST_BLOCK_SIZE; 177 hdr = data_last_block_header; 178 } else { 179 block_size = DATA_BLOCK_SIZE; 180 hdr = data_block_header; 181 } 182 183 gm12u320->data_buf[i] = drmm_kzalloc(&gm12u320->dev, 184 block_size, GFP_KERNEL); 185 if (!gm12u320->data_buf[i]) 186 return -ENOMEM; 187 188 memcpy(gm12u320->data_buf[i], hdr, DATA_BLOCK_HEADER_SIZE); 189 memcpy(gm12u320->data_buf[i] + 190 (block_size - DATA_BLOCK_FOOTER_SIZE), 191 data_block_footer, DATA_BLOCK_FOOTER_SIZE); 192 } 193 194 return 0; 195 } 196 197 static int gm12u320_misc_request(struct gm12u320_device *gm12u320, 198 u8 req_a, u8 req_b, 199 u8 arg_a, u8 arg_b, u8 arg_c, u8 arg_d) 200 { 201 struct usb_device *udev = gm12u320_to_usb_device(gm12u320); 202 int ret, len; 203 204 memcpy(gm12u320->cmd_buf, &cmd_misc, CMD_SIZE); 205 gm12u320->cmd_buf[20] = req_a; 206 gm12u320->cmd_buf[21] = req_b; 207 gm12u320->cmd_buf[22] = arg_a; 208 gm12u320->cmd_buf[23] = arg_b; 209 gm12u320->cmd_buf[24] = arg_c; 210 gm12u320->cmd_buf[25] = arg_d; 211 212 /* Send request */ 213 ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, MISC_SND_EPT), 214 gm12u320->cmd_buf, CMD_SIZE, &len, CMD_TIMEOUT); 215 if (ret || len != CMD_SIZE) { 216 GM12U320_ERR("Misc. req. error %d\n", ret); 217 return -EIO; 218 } 219 220 /* Read value */ 221 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, MISC_RCV_EPT), 222 gm12u320->cmd_buf, MISC_VALUE_SIZE, &len, 223 DATA_TIMEOUT); 224 if (ret || len != MISC_VALUE_SIZE) { 225 GM12U320_ERR("Misc. value error %d\n", ret); 226 return -EIO; 227 } 228 /* cmd_buf[0] now contains the read value, which we don't use */ 229 230 /* Read status */ 231 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, MISC_RCV_EPT), 232 gm12u320->cmd_buf, READ_STATUS_SIZE, &len, 233 CMD_TIMEOUT); 234 if (ret || len != READ_STATUS_SIZE) { 235 GM12U320_ERR("Misc. status error %d\n", ret); 236 return -EIO; 237 } 238 239 return 0; 240 } 241 242 static void gm12u320_32bpp_to_24bpp_packed(u8 *dst, u8 *src, int len) 243 { 244 while (len--) { 245 *dst++ = *src++; 246 *dst++ = *src++; 247 *dst++ = *src++; 248 src++; 249 } 250 } 251 252 static void gm12u320_copy_fb_to_blocks(struct gm12u320_device *gm12u320) 253 { 254 int block, dst_offset, len, remain, ret, x1, x2, y1, y2; 255 struct drm_framebuffer *fb; 256 void *vaddr; 257 u8 *src; 258 259 mutex_lock(&gm12u320->fb_update.lock); 260 261 if (!gm12u320->fb_update.fb) 262 goto unlock; 263 264 fb = gm12u320->fb_update.fb; 265 x1 = gm12u320->fb_update.rect.x1; 266 x2 = gm12u320->fb_update.rect.x2; 267 y1 = gm12u320->fb_update.rect.y1; 268 y2 = gm12u320->fb_update.rect.y2; 269 vaddr = gm12u320->fb_update.src_map.vaddr; /* TODO: Use mapping abstraction properly */ 270 271 if (fb->obj[0]->import_attach) { 272 ret = dma_buf_begin_cpu_access( 273 fb->obj[0]->import_attach->dmabuf, DMA_FROM_DEVICE); 274 if (ret) { 275 GM12U320_ERR("dma_buf_begin_cpu_access err: %d\n", ret); 276 goto put_fb; 277 } 278 } 279 280 src = vaddr + y1 * fb->pitches[0] + x1 * 4; 281 282 x1 += (GM12U320_REAL_WIDTH - GM12U320_USER_WIDTH) / 2; 283 x2 += (GM12U320_REAL_WIDTH - GM12U320_USER_WIDTH) / 2; 284 285 for (; y1 < y2; y1++) { 286 remain = 0; 287 len = (x2 - x1) * 3; 288 dst_offset = (y1 * GM12U320_REAL_WIDTH + x1) * 3; 289 block = dst_offset / DATA_BLOCK_CONTENT_SIZE; 290 dst_offset %= DATA_BLOCK_CONTENT_SIZE; 291 292 if ((dst_offset + len) > DATA_BLOCK_CONTENT_SIZE) { 293 remain = dst_offset + len - DATA_BLOCK_CONTENT_SIZE; 294 len = DATA_BLOCK_CONTENT_SIZE - dst_offset; 295 } 296 297 dst_offset += DATA_BLOCK_HEADER_SIZE; 298 len /= 3; 299 300 gm12u320_32bpp_to_24bpp_packed( 301 gm12u320->data_buf[block] + dst_offset, 302 src, len); 303 304 if (remain) { 305 block++; 306 dst_offset = DATA_BLOCK_HEADER_SIZE; 307 gm12u320_32bpp_to_24bpp_packed( 308 gm12u320->data_buf[block] + dst_offset, 309 src + len * 4, remain / 3); 310 } 311 src += fb->pitches[0]; 312 } 313 314 if (fb->obj[0]->import_attach) { 315 ret = dma_buf_end_cpu_access(fb->obj[0]->import_attach->dmabuf, 316 DMA_FROM_DEVICE); 317 if (ret) 318 GM12U320_ERR("dma_buf_end_cpu_access err: %d\n", ret); 319 } 320 put_fb: 321 drm_framebuffer_put(fb); 322 gm12u320->fb_update.fb = NULL; 323 unlock: 324 mutex_unlock(&gm12u320->fb_update.lock); 325 } 326 327 static void gm12u320_fb_update_work(struct work_struct *work) 328 { 329 struct gm12u320_device *gm12u320 = 330 container_of(to_delayed_work(work), struct gm12u320_device, 331 fb_update.work); 332 struct usb_device *udev = gm12u320_to_usb_device(gm12u320); 333 int block, block_size, len; 334 int ret = 0; 335 336 gm12u320_copy_fb_to_blocks(gm12u320); 337 338 for (block = 0; block < GM12U320_BLOCK_COUNT; block++) { 339 if (block == GM12U320_BLOCK_COUNT - 1) 340 block_size = DATA_LAST_BLOCK_SIZE; 341 else 342 block_size = DATA_BLOCK_SIZE; 343 344 /* Send data command to device */ 345 memcpy(gm12u320->cmd_buf, cmd_data, CMD_SIZE); 346 gm12u320->cmd_buf[8] = block_size & 0xff; 347 gm12u320->cmd_buf[9] = block_size >> 8; 348 gm12u320->cmd_buf[20] = 0xfc - block * 4; 349 gm12u320->cmd_buf[21] = 350 block | (gm12u320->fb_update.frame << 7); 351 352 ret = usb_bulk_msg(udev, 353 usb_sndbulkpipe(udev, DATA_SND_EPT), 354 gm12u320->cmd_buf, CMD_SIZE, &len, 355 CMD_TIMEOUT); 356 if (ret || len != CMD_SIZE) 357 goto err; 358 359 /* Send data block to device */ 360 ret = usb_bulk_msg(udev, 361 usb_sndbulkpipe(udev, DATA_SND_EPT), 362 gm12u320->data_buf[block], block_size, 363 &len, DATA_TIMEOUT); 364 if (ret || len != block_size) 365 goto err; 366 367 /* Read status */ 368 ret = usb_bulk_msg(udev, 369 usb_rcvbulkpipe(udev, DATA_RCV_EPT), 370 gm12u320->cmd_buf, READ_STATUS_SIZE, &len, 371 CMD_TIMEOUT); 372 if (ret || len != READ_STATUS_SIZE) 373 goto err; 374 } 375 376 /* Send draw command to device */ 377 memcpy(gm12u320->cmd_buf, cmd_draw, CMD_SIZE); 378 ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, DATA_SND_EPT), 379 gm12u320->cmd_buf, CMD_SIZE, &len, CMD_TIMEOUT); 380 if (ret || len != CMD_SIZE) 381 goto err; 382 383 /* Read status */ 384 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, DATA_RCV_EPT), 385 gm12u320->cmd_buf, READ_STATUS_SIZE, &len, 386 gm12u320->fb_update.draw_status_timeout); 387 if (ret || len != READ_STATUS_SIZE) 388 goto err; 389 390 gm12u320->fb_update.draw_status_timeout = CMD_TIMEOUT; 391 gm12u320->fb_update.frame = !gm12u320->fb_update.frame; 392 393 /* 394 * We must draw a frame every 2s otherwise the projector 395 * switches back to showing its logo. 396 */ 397 queue_delayed_work(system_long_wq, &gm12u320->fb_update.work, 398 IDLE_TIMEOUT); 399 400 return; 401 err: 402 /* Do not log errors caused by module unload or device unplug */ 403 if (ret != -ENODEV && ret != -ECONNRESET && ret != -ESHUTDOWN) 404 GM12U320_ERR("Frame update error: %d\n", ret); 405 } 406 407 static void gm12u320_fb_mark_dirty(struct drm_framebuffer *fb, const struct dma_buf_map *map, 408 struct drm_rect *dirty) 409 { 410 struct gm12u320_device *gm12u320 = to_gm12u320(fb->dev); 411 struct drm_framebuffer *old_fb = NULL; 412 bool wakeup = false; 413 414 mutex_lock(&gm12u320->fb_update.lock); 415 416 if (gm12u320->fb_update.fb != fb) { 417 old_fb = gm12u320->fb_update.fb; 418 drm_framebuffer_get(fb); 419 gm12u320->fb_update.fb = fb; 420 gm12u320->fb_update.rect = *dirty; 421 gm12u320->fb_update.src_map = *map; 422 wakeup = true; 423 } else { 424 struct drm_rect *rect = &gm12u320->fb_update.rect; 425 426 rect->x1 = min(rect->x1, dirty->x1); 427 rect->y1 = min(rect->y1, dirty->y1); 428 rect->x2 = max(rect->x2, dirty->x2); 429 rect->y2 = max(rect->y2, dirty->y2); 430 } 431 432 mutex_unlock(&gm12u320->fb_update.lock); 433 434 if (wakeup) 435 mod_delayed_work(system_long_wq, &gm12u320->fb_update.work, 0); 436 437 if (old_fb) 438 drm_framebuffer_put(old_fb); 439 } 440 441 static void gm12u320_stop_fb_update(struct gm12u320_device *gm12u320) 442 { 443 struct drm_framebuffer *old_fb; 444 445 cancel_delayed_work_sync(&gm12u320->fb_update.work); 446 447 mutex_lock(&gm12u320->fb_update.lock); 448 old_fb = gm12u320->fb_update.fb; 449 gm12u320->fb_update.fb = NULL; 450 dma_buf_map_clear(&gm12u320->fb_update.src_map); 451 mutex_unlock(&gm12u320->fb_update.lock); 452 453 drm_framebuffer_put(old_fb); 454 } 455 456 static int gm12u320_set_ecomode(struct gm12u320_device *gm12u320) 457 { 458 return gm12u320_misc_request(gm12u320, MISC_REQ_GET_SET_ECO_A, 459 MISC_REQ_GET_SET_ECO_B, 0x01 /* set */, 460 eco_mode ? 0x01 : 0x00, 0x00, 0x01); 461 } 462 463 /* ------------------------------------------------------------------ */ 464 /* gm12u320 connector */ 465 466 /* 467 * We use fake EDID info so that userspace know that it is dealing with 468 * an Acer projector, rather then listing this as an "unknown" monitor. 469 * Note this assumes this driver is only ever used with the Acer C120, if we 470 * add support for other devices the vendor and model should be parameterized. 471 */ 472 static struct edid gm12u320_edid = { 473 .header = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 }, 474 .mfg_id = { 0x04, 0x72 }, /* "ACR" */ 475 .prod_code = { 0x20, 0xc1 }, /* C120h */ 476 .serial = 0xaa55aa55, 477 .mfg_week = 1, 478 .mfg_year = 16, 479 .version = 1, /* EDID 1.3 */ 480 .revision = 3, /* EDID 1.3 */ 481 .input = 0x08, /* Analog input */ 482 .features = 0x0a, /* Pref timing in DTD 1 */ 483 .standard_timings = { { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 }, 484 { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 } }, 485 .detailed_timings = { { 486 .pixel_clock = 3383, 487 /* hactive = 848, hblank = 256 */ 488 .data.pixel_data.hactive_lo = 0x50, 489 .data.pixel_data.hblank_lo = 0x00, 490 .data.pixel_data.hactive_hblank_hi = 0x31, 491 /* vactive = 480, vblank = 28 */ 492 .data.pixel_data.vactive_lo = 0xe0, 493 .data.pixel_data.vblank_lo = 0x1c, 494 .data.pixel_data.vactive_vblank_hi = 0x10, 495 /* hsync offset 40 pw 128, vsync offset 1 pw 4 */ 496 .data.pixel_data.hsync_offset_lo = 0x28, 497 .data.pixel_data.hsync_pulse_width_lo = 0x80, 498 .data.pixel_data.vsync_offset_pulse_width_lo = 0x14, 499 .data.pixel_data.hsync_vsync_offset_pulse_width_hi = 0x00, 500 /* Digital separate syncs, hsync+, vsync+ */ 501 .data.pixel_data.misc = 0x1e, 502 }, { 503 .pixel_clock = 0, 504 .data.other_data.type = 0xfd, /* Monitor ranges */ 505 .data.other_data.data.range.min_vfreq = 59, 506 .data.other_data.data.range.max_vfreq = 61, 507 .data.other_data.data.range.min_hfreq_khz = 29, 508 .data.other_data.data.range.max_hfreq_khz = 32, 509 .data.other_data.data.range.pixel_clock_mhz = 4, /* 40 MHz */ 510 .data.other_data.data.range.flags = 0, 511 .data.other_data.data.range.formula.cvt = { 512 0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 }, 513 }, { 514 .pixel_clock = 0, 515 .data.other_data.type = 0xfc, /* Model string */ 516 .data.other_data.data.str.str = { 517 'P', 'r', 'o', 'j', 'e', 'c', 't', 'o', 'r', '\n', 518 ' ', ' ', ' ' }, 519 }, { 520 .pixel_clock = 0, 521 .data.other_data.type = 0xfe, /* Unspecified text / padding */ 522 .data.other_data.data.str.str = { 523 '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 524 ' ', ' ', ' ' }, 525 } }, 526 .checksum = 0x13, 527 }; 528 529 static int gm12u320_conn_get_modes(struct drm_connector *connector) 530 { 531 drm_connector_update_edid_property(connector, &gm12u320_edid); 532 return drm_add_edid_modes(connector, &gm12u320_edid); 533 } 534 535 static const struct drm_connector_helper_funcs gm12u320_conn_helper_funcs = { 536 .get_modes = gm12u320_conn_get_modes, 537 }; 538 539 static const struct drm_connector_funcs gm12u320_conn_funcs = { 540 .fill_modes = drm_helper_probe_single_connector_modes, 541 .destroy = drm_connector_cleanup, 542 .reset = drm_atomic_helper_connector_reset, 543 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 544 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 545 }; 546 547 static int gm12u320_conn_init(struct gm12u320_device *gm12u320) 548 { 549 drm_connector_helper_add(&gm12u320->conn, &gm12u320_conn_helper_funcs); 550 return drm_connector_init(&gm12u320->dev, &gm12u320->conn, 551 &gm12u320_conn_funcs, DRM_MODE_CONNECTOR_VGA); 552 } 553 554 /* ------------------------------------------------------------------ */ 555 /* gm12u320 (simple) display pipe */ 556 557 static void gm12u320_pipe_enable(struct drm_simple_display_pipe *pipe, 558 struct drm_crtc_state *crtc_state, 559 struct drm_plane_state *plane_state) 560 { 561 struct drm_rect rect = { 0, 0, GM12U320_USER_WIDTH, GM12U320_HEIGHT }; 562 struct gm12u320_device *gm12u320 = to_gm12u320(pipe->crtc.dev); 563 struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state); 564 565 gm12u320->fb_update.draw_status_timeout = FIRST_FRAME_TIMEOUT; 566 gm12u320_fb_mark_dirty(plane_state->fb, &shadow_plane_state->map[0], &rect); 567 } 568 569 static void gm12u320_pipe_disable(struct drm_simple_display_pipe *pipe) 570 { 571 struct gm12u320_device *gm12u320 = to_gm12u320(pipe->crtc.dev); 572 573 gm12u320_stop_fb_update(gm12u320); 574 } 575 576 static void gm12u320_pipe_update(struct drm_simple_display_pipe *pipe, 577 struct drm_plane_state *old_state) 578 { 579 struct drm_plane_state *state = pipe->plane.state; 580 struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(state); 581 struct drm_rect rect; 582 583 if (drm_atomic_helper_damage_merged(old_state, state, &rect)) 584 gm12u320_fb_mark_dirty(state->fb, &shadow_plane_state->map[0], &rect); 585 } 586 587 static const struct drm_simple_display_pipe_funcs gm12u320_pipe_funcs = { 588 .enable = gm12u320_pipe_enable, 589 .disable = gm12u320_pipe_disable, 590 .update = gm12u320_pipe_update, 591 DRM_GEM_SIMPLE_DISPLAY_PIPE_SHADOW_PLANE_FUNCS, 592 }; 593 594 static const uint32_t gm12u320_pipe_formats[] = { 595 DRM_FORMAT_XRGB8888, 596 }; 597 598 static const uint64_t gm12u320_pipe_modifiers[] = { 599 DRM_FORMAT_MOD_LINEAR, 600 DRM_FORMAT_MOD_INVALID 601 }; 602 603 /* 604 * FIXME: Dma-buf sharing requires DMA support by the importing device. 605 * This function is a workaround to make USB devices work as well. 606 * See todo.rst for how to fix the issue in the dma-buf framework. 607 */ 608 static struct drm_gem_object *gm12u320_gem_prime_import(struct drm_device *dev, 609 struct dma_buf *dma_buf) 610 { 611 struct gm12u320_device *gm12u320 = to_gm12u320(dev); 612 613 if (!gm12u320->dmadev) 614 return ERR_PTR(-ENODEV); 615 616 return drm_gem_prime_import_dev(dev, dma_buf, gm12u320->dmadev); 617 } 618 619 DEFINE_DRM_GEM_FOPS(gm12u320_fops); 620 621 static const struct drm_driver gm12u320_drm_driver = { 622 .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC, 623 624 .name = DRIVER_NAME, 625 .desc = DRIVER_DESC, 626 .date = DRIVER_DATE, 627 .major = DRIVER_MAJOR, 628 .minor = DRIVER_MINOR, 629 630 .fops = &gm12u320_fops, 631 DRM_GEM_SHMEM_DRIVER_OPS, 632 .gem_prime_import = gm12u320_gem_prime_import, 633 }; 634 635 static const struct drm_mode_config_funcs gm12u320_mode_config_funcs = { 636 .fb_create = drm_gem_fb_create_with_dirty, 637 .atomic_check = drm_atomic_helper_check, 638 .atomic_commit = drm_atomic_helper_commit, 639 }; 640 641 static int gm12u320_usb_probe(struct usb_interface *interface, 642 const struct usb_device_id *id) 643 { 644 struct gm12u320_device *gm12u320; 645 struct drm_device *dev; 646 int ret; 647 648 /* 649 * The gm12u320 presents itself to the system as 2 usb mass-storage 650 * interfaces, we only care about / need the first one. 651 */ 652 if (interface->cur_altsetting->desc.bInterfaceNumber != 0) 653 return -ENODEV; 654 655 gm12u320 = devm_drm_dev_alloc(&interface->dev, &gm12u320_drm_driver, 656 struct gm12u320_device, dev); 657 if (IS_ERR(gm12u320)) 658 return PTR_ERR(gm12u320); 659 dev = &gm12u320->dev; 660 661 gm12u320->dmadev = usb_intf_get_dma_device(to_usb_interface(dev->dev)); 662 if (!gm12u320->dmadev) 663 drm_warn(dev, "buffer sharing not supported"); /* not an error */ 664 665 INIT_DELAYED_WORK(&gm12u320->fb_update.work, gm12u320_fb_update_work); 666 mutex_init(&gm12u320->fb_update.lock); 667 668 ret = drmm_mode_config_init(dev); 669 if (ret) 670 goto err_put_device; 671 672 dev->mode_config.min_width = GM12U320_USER_WIDTH; 673 dev->mode_config.max_width = GM12U320_USER_WIDTH; 674 dev->mode_config.min_height = GM12U320_HEIGHT; 675 dev->mode_config.max_height = GM12U320_HEIGHT; 676 dev->mode_config.funcs = &gm12u320_mode_config_funcs; 677 678 ret = gm12u320_usb_alloc(gm12u320); 679 if (ret) 680 goto err_put_device; 681 682 ret = gm12u320_set_ecomode(gm12u320); 683 if (ret) 684 goto err_put_device; 685 686 ret = gm12u320_conn_init(gm12u320); 687 if (ret) 688 goto err_put_device; 689 690 ret = drm_simple_display_pipe_init(&gm12u320->dev, 691 &gm12u320->pipe, 692 &gm12u320_pipe_funcs, 693 gm12u320_pipe_formats, 694 ARRAY_SIZE(gm12u320_pipe_formats), 695 gm12u320_pipe_modifiers, 696 &gm12u320->conn); 697 if (ret) 698 goto err_put_device; 699 700 drm_mode_config_reset(dev); 701 702 usb_set_intfdata(interface, dev); 703 ret = drm_dev_register(dev, 0); 704 if (ret) 705 goto err_put_device; 706 707 drm_fbdev_generic_setup(dev, 0); 708 709 return 0; 710 711 err_put_device: 712 put_device(gm12u320->dmadev); 713 return ret; 714 } 715 716 static void gm12u320_usb_disconnect(struct usb_interface *interface) 717 { 718 struct drm_device *dev = usb_get_intfdata(interface); 719 struct gm12u320_device *gm12u320 = to_gm12u320(dev); 720 721 put_device(gm12u320->dmadev); 722 gm12u320->dmadev = NULL; 723 drm_dev_unplug(dev); 724 drm_atomic_helper_shutdown(dev); 725 } 726 727 static __maybe_unused int gm12u320_suspend(struct usb_interface *interface, 728 pm_message_t message) 729 { 730 struct drm_device *dev = usb_get_intfdata(interface); 731 732 return drm_mode_config_helper_suspend(dev); 733 } 734 735 static __maybe_unused int gm12u320_resume(struct usb_interface *interface) 736 { 737 struct drm_device *dev = usb_get_intfdata(interface); 738 struct gm12u320_device *gm12u320 = to_gm12u320(dev); 739 740 gm12u320_set_ecomode(gm12u320); 741 742 return drm_mode_config_helper_resume(dev); 743 } 744 745 static const struct usb_device_id id_table[] = { 746 { USB_DEVICE(0x1de1, 0xc102) }, 747 {}, 748 }; 749 MODULE_DEVICE_TABLE(usb, id_table); 750 751 static struct usb_driver gm12u320_usb_driver = { 752 .name = "gm12u320", 753 .probe = gm12u320_usb_probe, 754 .disconnect = gm12u320_usb_disconnect, 755 .id_table = id_table, 756 #ifdef CONFIG_PM 757 .suspend = gm12u320_suspend, 758 .resume = gm12u320_resume, 759 .reset_resume = gm12u320_resume, 760 #endif 761 }; 762 763 module_usb_driver(gm12u320_usb_driver); 764 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); 765 MODULE_LICENSE("GPL"); 766