1 /* 2 * Copyright (C) 2013, NVIDIA Corporation. All rights reserved. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sub license, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the 12 * next paragraph) shall be included in all copies or substantial portions 13 * of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24 #include <linux/debugfs.h> 25 #include <linux/delay.h> 26 #include <linux/gpio/consumer.h> 27 #include <linux/iopoll.h> 28 #include <linux/module.h> 29 #include <linux/of_platform.h> 30 #include <linux/platform_device.h> 31 #include <linux/pm_runtime.h> 32 #include <linux/regulator/consumer.h> 33 34 #include <video/display_timing.h> 35 #include <video/of_display_timing.h> 36 #include <video/videomode.h> 37 38 #include <drm/display/drm_dp_aux_bus.h> 39 #include <drm/display/drm_dp_helper.h> 40 #include <drm/drm_crtc.h> 41 #include <drm/drm_device.h> 42 #include <drm/drm_panel.h> 43 44 /** 45 * struct panel_delay - Describes delays for a simple panel. 46 */ 47 struct panel_delay { 48 /** 49 * @hpd_reliable: Time for HPD to be reliable 50 * 51 * The time (in milliseconds) that it takes after powering the panel 52 * before the HPD signal is reliable. Ideally this is 0 but some panels, 53 * board designs, or bad pulldown configs can cause a glitch here. 54 * 55 * NOTE: on some old panel data this number appers to be much too big. 56 * Presumably some old panels simply didn't have HPD hooked up and put 57 * the hpd_absent here because this field predates the 58 * hpd_absent. While that works, it's non-ideal. 59 */ 60 unsigned int hpd_reliable; 61 62 /** 63 * @hpd_absent: Time to wait if HPD isn't hooked up. 64 * 65 * Add this to the prepare delay if we know Hot Plug Detect isn't used. 66 * 67 * This is T3-max on eDP timing diagrams or the delay from power on 68 * until HPD is guaranteed to be asserted. 69 */ 70 unsigned int hpd_absent; 71 72 /** 73 * @prepare_to_enable: Time between prepare and enable. 74 * 75 * The minimum time, in milliseconds, that needs to have passed 76 * between when prepare finished and enable may begin. If at 77 * enable time less time has passed since prepare finished, 78 * the driver waits for the remaining time. 79 * 80 * If a fixed enable delay is also specified, we'll start 81 * counting before delaying for the fixed delay. 82 * 83 * If a fixed prepare delay is also specified, we won't start 84 * counting until after the fixed delay. We can't overlap this 85 * fixed delay with the min time because the fixed delay 86 * doesn't happen at the end of the function if a HPD GPIO was 87 * specified. 88 * 89 * In other words: 90 * prepare() 91 * ... 92 * // do fixed prepare delay 93 * // wait for HPD GPIO if applicable 94 * // start counting for prepare_to_enable 95 * 96 * enable() 97 * // do fixed enable delay 98 * // enforce prepare_to_enable min time 99 * 100 * This is not specified in a standard way on eDP timing diagrams. 101 * It is effectively the time from HPD going high till you can 102 * turn on the backlight. 103 */ 104 unsigned int prepare_to_enable; 105 106 /** 107 * @enable: Time for the panel to display a valid frame. 108 * 109 * The time (in milliseconds) that it takes for the panel to 110 * display the first valid frame after starting to receive 111 * video data. 112 * 113 * This is (T6-min + max(T7-max, T8-min)) on eDP timing diagrams or 114 * the delay after link training finishes until we can turn the 115 * backlight on and see valid data. 116 */ 117 unsigned int enable; 118 119 /** 120 * @disable: Time for the panel to turn the display off. 121 * 122 * The time (in milliseconds) that it takes for the panel to 123 * turn the display off (no content is visible). 124 * 125 * This is T9-min (delay from backlight off to end of valid video 126 * data) on eDP timing diagrams. It is not common to set. 127 */ 128 unsigned int disable; 129 130 /** 131 * @unprepare: Time to power down completely. 132 * 133 * The time (in milliseconds) that it takes for the panel 134 * to power itself down completely. 135 * 136 * This time is used to prevent a future "prepare" from 137 * starting until at least this many milliseconds has passed. 138 * If at prepare time less time has passed since unprepare 139 * finished, the driver waits for the remaining time. 140 * 141 * This is T12-min on eDP timing diagrams. 142 */ 143 unsigned int unprepare; 144 }; 145 146 /** 147 * struct panel_desc - Describes a simple panel. 148 */ 149 struct panel_desc { 150 /** 151 * @modes: Pointer to array of fixed modes appropriate for this panel. 152 * 153 * If only one mode then this can just be the address of the mode. 154 * NOTE: cannot be used with "timings" and also if this is specified 155 * then you cannot override the mode in the device tree. 156 */ 157 const struct drm_display_mode *modes; 158 159 /** @num_modes: Number of elements in modes array. */ 160 unsigned int num_modes; 161 162 /** 163 * @timings: Pointer to array of display timings 164 * 165 * NOTE: cannot be used with "modes" and also these will be used to 166 * validate a device tree override if one is present. 167 */ 168 const struct display_timing *timings; 169 170 /** @num_timings: Number of elements in timings array. */ 171 unsigned int num_timings; 172 173 /** @bpc: Bits per color. */ 174 unsigned int bpc; 175 176 /** @size: Structure containing the physical size of this panel. */ 177 struct { 178 /** 179 * @size.width: Width (in mm) of the active display area. 180 */ 181 unsigned int width; 182 183 /** 184 * @size.height: Height (in mm) of the active display area. 185 */ 186 unsigned int height; 187 } size; 188 189 /** @delay: Structure containing various delay values for this panel. */ 190 struct panel_delay delay; 191 }; 192 193 /** 194 * struct edp_panel_entry - Maps panel ID to delay / panel name. 195 */ 196 struct edp_panel_entry { 197 /** @panel_id: 32-bit ID for panel, encoded with drm_edid_encode_panel_id(). */ 198 u32 panel_id; 199 200 /** @delay: The power sequencing delays needed for this panel. */ 201 const struct panel_delay *delay; 202 203 /** @name: Name of this panel (for printing to logs). */ 204 const char *name; 205 }; 206 207 struct panel_edp { 208 struct drm_panel base; 209 bool enabled; 210 bool no_hpd; 211 212 bool prepared; 213 214 ktime_t prepared_time; 215 ktime_t unprepared_time; 216 217 const struct panel_desc *desc; 218 219 struct regulator *supply; 220 struct i2c_adapter *ddc; 221 struct drm_dp_aux *aux; 222 223 struct gpio_desc *enable_gpio; 224 struct gpio_desc *hpd_gpio; 225 226 const struct edp_panel_entry *detected_panel; 227 228 struct edid *edid; 229 230 struct drm_display_mode override_mode; 231 232 enum drm_panel_orientation orientation; 233 }; 234 235 static inline struct panel_edp *to_panel_edp(struct drm_panel *panel) 236 { 237 return container_of(panel, struct panel_edp, base); 238 } 239 240 static unsigned int panel_edp_get_timings_modes(struct panel_edp *panel, 241 struct drm_connector *connector) 242 { 243 struct drm_display_mode *mode; 244 unsigned int i, num = 0; 245 246 for (i = 0; i < panel->desc->num_timings; i++) { 247 const struct display_timing *dt = &panel->desc->timings[i]; 248 struct videomode vm; 249 250 videomode_from_timing(dt, &vm); 251 mode = drm_mode_create(connector->dev); 252 if (!mode) { 253 dev_err(panel->base.dev, "failed to add mode %ux%u\n", 254 dt->hactive.typ, dt->vactive.typ); 255 continue; 256 } 257 258 drm_display_mode_from_videomode(&vm, mode); 259 260 mode->type |= DRM_MODE_TYPE_DRIVER; 261 262 if (panel->desc->num_timings == 1) 263 mode->type |= DRM_MODE_TYPE_PREFERRED; 264 265 drm_mode_probed_add(connector, mode); 266 num++; 267 } 268 269 return num; 270 } 271 272 static unsigned int panel_edp_get_display_modes(struct panel_edp *panel, 273 struct drm_connector *connector) 274 { 275 struct drm_display_mode *mode; 276 unsigned int i, num = 0; 277 278 for (i = 0; i < panel->desc->num_modes; i++) { 279 const struct drm_display_mode *m = &panel->desc->modes[i]; 280 281 mode = drm_mode_duplicate(connector->dev, m); 282 if (!mode) { 283 dev_err(panel->base.dev, "failed to add mode %ux%u@%u\n", 284 m->hdisplay, m->vdisplay, 285 drm_mode_vrefresh(m)); 286 continue; 287 } 288 289 mode->type |= DRM_MODE_TYPE_DRIVER; 290 291 if (panel->desc->num_modes == 1) 292 mode->type |= DRM_MODE_TYPE_PREFERRED; 293 294 drm_mode_set_name(mode); 295 296 drm_mode_probed_add(connector, mode); 297 num++; 298 } 299 300 return num; 301 } 302 303 static int panel_edp_get_non_edid_modes(struct panel_edp *panel, 304 struct drm_connector *connector) 305 { 306 struct drm_display_mode *mode; 307 bool has_override = panel->override_mode.type; 308 unsigned int num = 0; 309 310 if (!panel->desc) 311 return 0; 312 313 if (has_override) { 314 mode = drm_mode_duplicate(connector->dev, 315 &panel->override_mode); 316 if (mode) { 317 drm_mode_probed_add(connector, mode); 318 num = 1; 319 } else { 320 dev_err(panel->base.dev, "failed to add override mode\n"); 321 } 322 } 323 324 /* Only add timings if override was not there or failed to validate */ 325 if (num == 0 && panel->desc->num_timings) 326 num = panel_edp_get_timings_modes(panel, connector); 327 328 /* 329 * Only add fixed modes if timings/override added no mode. 330 * 331 * We should only ever have either the display timings specified 332 * or a fixed mode. Anything else is rather bogus. 333 */ 334 WARN_ON(panel->desc->num_timings && panel->desc->num_modes); 335 if (num == 0) 336 num = panel_edp_get_display_modes(panel, connector); 337 338 connector->display_info.bpc = panel->desc->bpc; 339 connector->display_info.width_mm = panel->desc->size.width; 340 connector->display_info.height_mm = panel->desc->size.height; 341 342 return num; 343 } 344 345 static void panel_edp_wait(ktime_t start_ktime, unsigned int min_ms) 346 { 347 ktime_t now_ktime, min_ktime; 348 349 if (!min_ms) 350 return; 351 352 min_ktime = ktime_add(start_ktime, ms_to_ktime(min_ms)); 353 now_ktime = ktime_get(); 354 355 if (ktime_before(now_ktime, min_ktime)) 356 msleep(ktime_to_ms(ktime_sub(min_ktime, now_ktime)) + 1); 357 } 358 359 static int panel_edp_disable(struct drm_panel *panel) 360 { 361 struct panel_edp *p = to_panel_edp(panel); 362 363 if (!p->enabled) 364 return 0; 365 366 if (p->desc->delay.disable) 367 msleep(p->desc->delay.disable); 368 369 p->enabled = false; 370 371 return 0; 372 } 373 374 static int panel_edp_suspend(struct device *dev) 375 { 376 struct panel_edp *p = dev_get_drvdata(dev); 377 378 gpiod_set_value_cansleep(p->enable_gpio, 0); 379 regulator_disable(p->supply); 380 p->unprepared_time = ktime_get(); 381 382 return 0; 383 } 384 385 static int panel_edp_unprepare(struct drm_panel *panel) 386 { 387 struct panel_edp *p = to_panel_edp(panel); 388 int ret; 389 390 /* Unpreparing when already unprepared is a no-op */ 391 if (!p->prepared) 392 return 0; 393 394 pm_runtime_mark_last_busy(panel->dev); 395 ret = pm_runtime_put_autosuspend(panel->dev); 396 if (ret < 0) 397 return ret; 398 p->prepared = false; 399 400 return 0; 401 } 402 403 static int panel_edp_get_hpd_gpio(struct device *dev, struct panel_edp *p) 404 { 405 int err; 406 407 p->hpd_gpio = devm_gpiod_get_optional(dev, "hpd", GPIOD_IN); 408 if (IS_ERR(p->hpd_gpio)) { 409 err = PTR_ERR(p->hpd_gpio); 410 411 if (err != -EPROBE_DEFER) 412 dev_err(dev, "failed to get 'hpd' GPIO: %d\n", err); 413 414 return err; 415 } 416 417 return 0; 418 } 419 420 static int panel_edp_prepare_once(struct panel_edp *p) 421 { 422 struct device *dev = p->base.dev; 423 unsigned int delay; 424 int err; 425 int hpd_asserted; 426 unsigned long hpd_wait_us; 427 428 panel_edp_wait(p->unprepared_time, p->desc->delay.unprepare); 429 430 err = regulator_enable(p->supply); 431 if (err < 0) { 432 dev_err(dev, "failed to enable supply: %d\n", err); 433 return err; 434 } 435 436 gpiod_set_value_cansleep(p->enable_gpio, 1); 437 438 delay = p->desc->delay.hpd_reliable; 439 if (p->no_hpd) 440 delay = max(delay, p->desc->delay.hpd_absent); 441 if (delay) 442 msleep(delay); 443 444 if (p->hpd_gpio) { 445 if (p->desc->delay.hpd_absent) 446 hpd_wait_us = p->desc->delay.hpd_absent * 1000UL; 447 else 448 hpd_wait_us = 2000000; 449 450 err = readx_poll_timeout(gpiod_get_value_cansleep, p->hpd_gpio, 451 hpd_asserted, hpd_asserted, 452 1000, hpd_wait_us); 453 if (hpd_asserted < 0) 454 err = hpd_asserted; 455 456 if (err) { 457 if (err != -ETIMEDOUT) 458 dev_err(dev, 459 "error waiting for hpd GPIO: %d\n", err); 460 goto error; 461 } 462 } 463 464 p->prepared_time = ktime_get(); 465 466 return 0; 467 468 error: 469 gpiod_set_value_cansleep(p->enable_gpio, 0); 470 regulator_disable(p->supply); 471 p->unprepared_time = ktime_get(); 472 473 return err; 474 } 475 476 /* 477 * Some panels simply don't always come up and need to be power cycled to 478 * work properly. We'll allow for a handful of retries. 479 */ 480 #define MAX_PANEL_PREPARE_TRIES 5 481 482 static int panel_edp_resume(struct device *dev) 483 { 484 struct panel_edp *p = dev_get_drvdata(dev); 485 int ret; 486 int try; 487 488 for (try = 0; try < MAX_PANEL_PREPARE_TRIES; try++) { 489 ret = panel_edp_prepare_once(p); 490 if (ret != -ETIMEDOUT) 491 break; 492 } 493 494 if (ret == -ETIMEDOUT) 495 dev_err(dev, "Prepare timeout after %d tries\n", try); 496 else if (try) 497 dev_warn(dev, "Prepare needed %d retries\n", try); 498 499 return ret; 500 } 501 502 static int panel_edp_prepare(struct drm_panel *panel) 503 { 504 struct panel_edp *p = to_panel_edp(panel); 505 int ret; 506 507 /* Preparing when already prepared is a no-op */ 508 if (p->prepared) 509 return 0; 510 511 ret = pm_runtime_get_sync(panel->dev); 512 if (ret < 0) { 513 pm_runtime_put_autosuspend(panel->dev); 514 return ret; 515 } 516 517 p->prepared = true; 518 519 return 0; 520 } 521 522 static int panel_edp_enable(struct drm_panel *panel) 523 { 524 struct panel_edp *p = to_panel_edp(panel); 525 unsigned int delay; 526 527 if (p->enabled) 528 return 0; 529 530 delay = p->desc->delay.enable; 531 532 /* 533 * If there is a "prepare_to_enable" delay then that's supposed to be 534 * the delay from HPD going high until we can turn the backlight on. 535 * However, we can only count this if HPD is handled by the panel 536 * driver, not if it goes to a dedicated pin on the controller. 537 * If we aren't handling the HPD pin ourselves then the best we 538 * can do is assume that HPD went high immediately before we were 539 * called (and link training took zero time). 540 * 541 * NOTE: if we ever end up in this "if" statement then we're 542 * guaranteed that the panel_edp_wait() call below will do no delay. 543 * It already handles that case, though, so we don't need any special 544 * code for it. 545 */ 546 if (p->desc->delay.prepare_to_enable && !p->hpd_gpio && !p->no_hpd) 547 delay = max(delay, p->desc->delay.prepare_to_enable); 548 549 if (delay) 550 msleep(delay); 551 552 panel_edp_wait(p->prepared_time, p->desc->delay.prepare_to_enable); 553 554 p->enabled = true; 555 556 return 0; 557 } 558 559 static int panel_edp_get_modes(struct drm_panel *panel, 560 struct drm_connector *connector) 561 { 562 struct panel_edp *p = to_panel_edp(panel); 563 int num = 0; 564 565 /* probe EDID if a DDC bus is available */ 566 if (p->ddc) { 567 pm_runtime_get_sync(panel->dev); 568 569 if (!p->edid) 570 p->edid = drm_get_edid(connector, p->ddc); 571 572 if (p->edid) 573 num += drm_add_edid_modes(connector, p->edid); 574 575 pm_runtime_mark_last_busy(panel->dev); 576 pm_runtime_put_autosuspend(panel->dev); 577 } 578 579 /* 580 * Add hard-coded panel modes. Don't call this if there are no timings 581 * and no modes (the generic edp-panel case) because it will clobber 582 * the display_info that was already set by drm_add_edid_modes(). 583 */ 584 if (p->desc->num_timings || p->desc->num_modes) 585 num += panel_edp_get_non_edid_modes(p, connector); 586 else if (!num) 587 dev_warn(p->base.dev, "No display modes\n"); 588 589 /* set up connector's "panel orientation" property */ 590 drm_connector_set_panel_orientation(connector, p->orientation); 591 592 return num; 593 } 594 595 static int panel_edp_get_timings(struct drm_panel *panel, 596 unsigned int num_timings, 597 struct display_timing *timings) 598 { 599 struct panel_edp *p = to_panel_edp(panel); 600 unsigned int i; 601 602 if (p->desc->num_timings < num_timings) 603 num_timings = p->desc->num_timings; 604 605 if (timings) 606 for (i = 0; i < num_timings; i++) 607 timings[i] = p->desc->timings[i]; 608 609 return p->desc->num_timings; 610 } 611 612 static int detected_panel_show(struct seq_file *s, void *data) 613 { 614 struct drm_panel *panel = s->private; 615 struct panel_edp *p = to_panel_edp(panel); 616 617 if (IS_ERR(p->detected_panel)) 618 seq_puts(s, "UNKNOWN\n"); 619 else if (!p->detected_panel) 620 seq_puts(s, "HARDCODED\n"); 621 else 622 seq_printf(s, "%s\n", p->detected_panel->name); 623 624 return 0; 625 } 626 627 DEFINE_SHOW_ATTRIBUTE(detected_panel); 628 629 static void panel_edp_debugfs_init(struct drm_panel *panel, struct dentry *root) 630 { 631 debugfs_create_file("detected_panel", 0600, root, panel, &detected_panel_fops); 632 } 633 634 static const struct drm_panel_funcs panel_edp_funcs = { 635 .disable = panel_edp_disable, 636 .unprepare = panel_edp_unprepare, 637 .prepare = panel_edp_prepare, 638 .enable = panel_edp_enable, 639 .get_modes = panel_edp_get_modes, 640 .get_timings = panel_edp_get_timings, 641 .debugfs_init = panel_edp_debugfs_init, 642 }; 643 644 #define PANEL_EDP_BOUNDS_CHECK(to_check, bounds, field) \ 645 (to_check->field.typ >= bounds->field.min && \ 646 to_check->field.typ <= bounds->field.max) 647 static void panel_edp_parse_panel_timing_node(struct device *dev, 648 struct panel_edp *panel, 649 const struct display_timing *ot) 650 { 651 const struct panel_desc *desc = panel->desc; 652 struct videomode vm; 653 unsigned int i; 654 655 if (WARN_ON(desc->num_modes)) { 656 dev_err(dev, "Reject override mode: panel has a fixed mode\n"); 657 return; 658 } 659 if (WARN_ON(!desc->num_timings)) { 660 dev_err(dev, "Reject override mode: no timings specified\n"); 661 return; 662 } 663 664 for (i = 0; i < panel->desc->num_timings; i++) { 665 const struct display_timing *dt = &panel->desc->timings[i]; 666 667 if (!PANEL_EDP_BOUNDS_CHECK(ot, dt, hactive) || 668 !PANEL_EDP_BOUNDS_CHECK(ot, dt, hfront_porch) || 669 !PANEL_EDP_BOUNDS_CHECK(ot, dt, hback_porch) || 670 !PANEL_EDP_BOUNDS_CHECK(ot, dt, hsync_len) || 671 !PANEL_EDP_BOUNDS_CHECK(ot, dt, vactive) || 672 !PANEL_EDP_BOUNDS_CHECK(ot, dt, vfront_porch) || 673 !PANEL_EDP_BOUNDS_CHECK(ot, dt, vback_porch) || 674 !PANEL_EDP_BOUNDS_CHECK(ot, dt, vsync_len)) 675 continue; 676 677 if (ot->flags != dt->flags) 678 continue; 679 680 videomode_from_timing(ot, &vm); 681 drm_display_mode_from_videomode(&vm, &panel->override_mode); 682 panel->override_mode.type |= DRM_MODE_TYPE_DRIVER | 683 DRM_MODE_TYPE_PREFERRED; 684 break; 685 } 686 687 if (WARN_ON(!panel->override_mode.type)) 688 dev_err(dev, "Reject override mode: No display_timing found\n"); 689 } 690 691 static const struct edp_panel_entry *find_edp_panel(u32 panel_id); 692 693 static int generic_edp_panel_probe(struct device *dev, struct panel_edp *panel) 694 { 695 struct panel_desc *desc; 696 u32 panel_id; 697 char vend[4]; 698 u16 product_id; 699 u32 reliable_ms = 0; 700 u32 absent_ms = 0; 701 int ret; 702 703 desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL); 704 if (!desc) 705 return -ENOMEM; 706 panel->desc = desc; 707 708 /* 709 * Read the dts properties for the initial probe. These are used by 710 * the runtime resume code which will get called by the 711 * pm_runtime_get_sync() call below. 712 */ 713 of_property_read_u32(dev->of_node, "hpd-reliable-delay-ms", &reliable_ms); 714 desc->delay.hpd_reliable = reliable_ms; 715 of_property_read_u32(dev->of_node, "hpd-absent-delay-ms", &absent_ms); 716 desc->delay.hpd_reliable = absent_ms; 717 718 /* Power the panel on so we can read the EDID */ 719 ret = pm_runtime_get_sync(dev); 720 if (ret < 0) { 721 dev_err(dev, "Couldn't power on panel to read EDID: %d\n", ret); 722 goto exit; 723 } 724 725 panel_id = drm_edid_get_panel_id(panel->ddc); 726 if (!panel_id) { 727 dev_err(dev, "Couldn't identify panel via EDID\n"); 728 ret = -EIO; 729 goto exit; 730 } 731 drm_edid_decode_panel_id(panel_id, vend, &product_id); 732 733 panel->detected_panel = find_edp_panel(panel_id); 734 735 /* 736 * We're using non-optimized timings and want it really obvious that 737 * someone needs to add an entry to the table, so we'll do a WARN_ON 738 * splat. 739 */ 740 if (WARN_ON(!panel->detected_panel)) { 741 dev_warn(dev, 742 "Unknown panel %s %#06x, using conservative timings\n", 743 vend, product_id); 744 745 /* 746 * It's highly likely that the panel will work if we use very 747 * conservative timings, so let's do that. We already know that 748 * the HPD-related delays must have worked since we got this 749 * far, so we really just need the "unprepare" / "enable" 750 * delays. We don't need "prepare_to_enable" since that 751 * overlaps the "enable" delay anyway. 752 * 753 * Nearly all panels have a "unprepare" delay of 500 ms though 754 * there are a few with 1000. Let's stick 2000 in just to be 755 * super conservative. 756 * 757 * An "enable" delay of 80 ms seems the most common, but we'll 758 * throw in 200 ms to be safe. 759 */ 760 desc->delay.unprepare = 2000; 761 desc->delay.enable = 200; 762 763 panel->detected_panel = ERR_PTR(-EINVAL); 764 } else { 765 dev_info(dev, "Detected %s %s (%#06x)\n", 766 vend, panel->detected_panel->name, product_id); 767 768 /* Update the delay; everything else comes from EDID */ 769 desc->delay = *panel->detected_panel->delay; 770 } 771 772 ret = 0; 773 exit: 774 pm_runtime_mark_last_busy(dev); 775 pm_runtime_put_autosuspend(dev); 776 777 return ret; 778 } 779 780 static int panel_edp_probe(struct device *dev, const struct panel_desc *desc, 781 struct drm_dp_aux *aux) 782 { 783 struct panel_edp *panel; 784 struct display_timing dt; 785 struct device_node *ddc; 786 int err; 787 788 panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL); 789 if (!panel) 790 return -ENOMEM; 791 792 panel->enabled = false; 793 panel->prepared_time = 0; 794 panel->desc = desc; 795 panel->aux = aux; 796 797 panel->no_hpd = of_property_read_bool(dev->of_node, "no-hpd"); 798 if (!panel->no_hpd) { 799 err = panel_edp_get_hpd_gpio(dev, panel); 800 if (err) 801 return err; 802 } 803 804 panel->supply = devm_regulator_get(dev, "power"); 805 if (IS_ERR(panel->supply)) 806 return PTR_ERR(panel->supply); 807 808 panel->enable_gpio = devm_gpiod_get_optional(dev, "enable", 809 GPIOD_OUT_LOW); 810 if (IS_ERR(panel->enable_gpio)) { 811 err = PTR_ERR(panel->enable_gpio); 812 if (err != -EPROBE_DEFER) 813 dev_err(dev, "failed to request GPIO: %d\n", err); 814 return err; 815 } 816 817 err = of_drm_get_panel_orientation(dev->of_node, &panel->orientation); 818 if (err) { 819 dev_err(dev, "%pOF: failed to get orientation %d\n", dev->of_node, err); 820 return err; 821 } 822 823 ddc = of_parse_phandle(dev->of_node, "ddc-i2c-bus", 0); 824 if (ddc) { 825 panel->ddc = of_find_i2c_adapter_by_node(ddc); 826 of_node_put(ddc); 827 828 if (!panel->ddc) 829 return -EPROBE_DEFER; 830 } else if (aux) { 831 panel->ddc = &aux->ddc; 832 } 833 834 if (!of_get_display_timing(dev->of_node, "panel-timing", &dt)) 835 panel_edp_parse_panel_timing_node(dev, panel, &dt); 836 837 dev_set_drvdata(dev, panel); 838 839 drm_panel_init(&panel->base, dev, &panel_edp_funcs, DRM_MODE_CONNECTOR_eDP); 840 841 err = drm_panel_of_backlight(&panel->base); 842 if (err) 843 goto err_finished_ddc_init; 844 845 /* 846 * We use runtime PM for prepare / unprepare since those power the panel 847 * on and off and those can be very slow operations. This is important 848 * to optimize powering the panel on briefly to read the EDID before 849 * fully enabling the panel. 850 */ 851 pm_runtime_enable(dev); 852 pm_runtime_set_autosuspend_delay(dev, 1000); 853 pm_runtime_use_autosuspend(dev); 854 855 if (of_device_is_compatible(dev->of_node, "edp-panel")) { 856 err = generic_edp_panel_probe(dev, panel); 857 if (err) { 858 dev_err_probe(dev, err, 859 "Couldn't detect panel nor find a fallback\n"); 860 goto err_finished_pm_runtime; 861 } 862 /* generic_edp_panel_probe() replaces desc in the panel */ 863 desc = panel->desc; 864 } else if (desc->bpc != 6 && desc->bpc != 8 && desc->bpc != 10) { 865 dev_warn(dev, "Expected bpc in {6,8,10} but got: %u\n", desc->bpc); 866 } 867 868 if (!panel->base.backlight && panel->aux) { 869 pm_runtime_get_sync(dev); 870 err = drm_panel_dp_aux_backlight(&panel->base, panel->aux); 871 pm_runtime_mark_last_busy(dev); 872 pm_runtime_put_autosuspend(dev); 873 if (err) 874 goto err_finished_pm_runtime; 875 } 876 877 drm_panel_add(&panel->base); 878 879 return 0; 880 881 err_finished_pm_runtime: 882 pm_runtime_dont_use_autosuspend(dev); 883 pm_runtime_disable(dev); 884 err_finished_ddc_init: 885 if (panel->ddc && (!panel->aux || panel->ddc != &panel->aux->ddc)) 886 put_device(&panel->ddc->dev); 887 888 return err; 889 } 890 891 static int panel_edp_remove(struct device *dev) 892 { 893 struct panel_edp *panel = dev_get_drvdata(dev); 894 895 drm_panel_remove(&panel->base); 896 drm_panel_disable(&panel->base); 897 drm_panel_unprepare(&panel->base); 898 899 pm_runtime_dont_use_autosuspend(dev); 900 pm_runtime_disable(dev); 901 if (panel->ddc && (!panel->aux || panel->ddc != &panel->aux->ddc)) 902 put_device(&panel->ddc->dev); 903 904 kfree(panel->edid); 905 panel->edid = NULL; 906 907 return 0; 908 } 909 910 static void panel_edp_shutdown(struct device *dev) 911 { 912 struct panel_edp *panel = dev_get_drvdata(dev); 913 914 drm_panel_disable(&panel->base); 915 drm_panel_unprepare(&panel->base); 916 } 917 918 static const struct display_timing auo_b101ean01_timing = { 919 .pixelclock = { 65300000, 72500000, 75000000 }, 920 .hactive = { 1280, 1280, 1280 }, 921 .hfront_porch = { 18, 119, 119 }, 922 .hback_porch = { 21, 21, 21 }, 923 .hsync_len = { 32, 32, 32 }, 924 .vactive = { 800, 800, 800 }, 925 .vfront_porch = { 4, 4, 4 }, 926 .vback_porch = { 8, 8, 8 }, 927 .vsync_len = { 18, 20, 20 }, 928 }; 929 930 static const struct panel_desc auo_b101ean01 = { 931 .timings = &auo_b101ean01_timing, 932 .num_timings = 1, 933 .bpc = 6, 934 .size = { 935 .width = 217, 936 .height = 136, 937 }, 938 }; 939 940 static const struct drm_display_mode auo_b116xak01_mode = { 941 .clock = 69300, 942 .hdisplay = 1366, 943 .hsync_start = 1366 + 48, 944 .hsync_end = 1366 + 48 + 32, 945 .htotal = 1366 + 48 + 32 + 10, 946 .vdisplay = 768, 947 .vsync_start = 768 + 4, 948 .vsync_end = 768 + 4 + 6, 949 .vtotal = 768 + 4 + 6 + 15, 950 .flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC, 951 }; 952 953 static const struct panel_desc auo_b116xak01 = { 954 .modes = &auo_b116xak01_mode, 955 .num_modes = 1, 956 .bpc = 6, 957 .size = { 958 .width = 256, 959 .height = 144, 960 }, 961 .delay = { 962 .hpd_absent = 200, 963 }, 964 }; 965 966 static const struct drm_display_mode auo_b116xw03_mode = { 967 .clock = 70589, 968 .hdisplay = 1366, 969 .hsync_start = 1366 + 40, 970 .hsync_end = 1366 + 40 + 40, 971 .htotal = 1366 + 40 + 40 + 32, 972 .vdisplay = 768, 973 .vsync_start = 768 + 10, 974 .vsync_end = 768 + 10 + 12, 975 .vtotal = 768 + 10 + 12 + 6, 976 .flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC, 977 }; 978 979 static const struct panel_desc auo_b116xw03 = { 980 .modes = &auo_b116xw03_mode, 981 .num_modes = 1, 982 .bpc = 6, 983 .size = { 984 .width = 256, 985 .height = 144, 986 }, 987 .delay = { 988 .enable = 400, 989 }, 990 }; 991 992 static const struct drm_display_mode auo_b133han05_mode = { 993 .clock = 142600, 994 .hdisplay = 1920, 995 .hsync_start = 1920 + 58, 996 .hsync_end = 1920 + 58 + 42, 997 .htotal = 1920 + 58 + 42 + 60, 998 .vdisplay = 1080, 999 .vsync_start = 1080 + 3, 1000 .vsync_end = 1080 + 3 + 5, 1001 .vtotal = 1080 + 3 + 5 + 54, 1002 }; 1003 1004 static const struct panel_desc auo_b133han05 = { 1005 .modes = &auo_b133han05_mode, 1006 .num_modes = 1, 1007 .bpc = 8, 1008 .size = { 1009 .width = 293, 1010 .height = 165, 1011 }, 1012 .delay = { 1013 .hpd_reliable = 100, 1014 .enable = 20, 1015 .unprepare = 50, 1016 }, 1017 }; 1018 1019 static const struct drm_display_mode auo_b133htn01_mode = { 1020 .clock = 150660, 1021 .hdisplay = 1920, 1022 .hsync_start = 1920 + 172, 1023 .hsync_end = 1920 + 172 + 80, 1024 .htotal = 1920 + 172 + 80 + 60, 1025 .vdisplay = 1080, 1026 .vsync_start = 1080 + 25, 1027 .vsync_end = 1080 + 25 + 10, 1028 .vtotal = 1080 + 25 + 10 + 10, 1029 }; 1030 1031 static const struct panel_desc auo_b133htn01 = { 1032 .modes = &auo_b133htn01_mode, 1033 .num_modes = 1, 1034 .bpc = 6, 1035 .size = { 1036 .width = 293, 1037 .height = 165, 1038 }, 1039 .delay = { 1040 .hpd_reliable = 105, 1041 .enable = 20, 1042 .unprepare = 50, 1043 }, 1044 }; 1045 1046 static const struct drm_display_mode auo_b133xtn01_mode = { 1047 .clock = 69500, 1048 .hdisplay = 1366, 1049 .hsync_start = 1366 + 48, 1050 .hsync_end = 1366 + 48 + 32, 1051 .htotal = 1366 + 48 + 32 + 20, 1052 .vdisplay = 768, 1053 .vsync_start = 768 + 3, 1054 .vsync_end = 768 + 3 + 6, 1055 .vtotal = 768 + 3 + 6 + 13, 1056 }; 1057 1058 static const struct panel_desc auo_b133xtn01 = { 1059 .modes = &auo_b133xtn01_mode, 1060 .num_modes = 1, 1061 .bpc = 6, 1062 .size = { 1063 .width = 293, 1064 .height = 165, 1065 }, 1066 }; 1067 1068 static const struct drm_display_mode auo_b140han06_mode = { 1069 .clock = 141000, 1070 .hdisplay = 1920, 1071 .hsync_start = 1920 + 16, 1072 .hsync_end = 1920 + 16 + 16, 1073 .htotal = 1920 + 16 + 16 + 152, 1074 .vdisplay = 1080, 1075 .vsync_start = 1080 + 3, 1076 .vsync_end = 1080 + 3 + 14, 1077 .vtotal = 1080 + 3 + 14 + 19, 1078 }; 1079 1080 static const struct panel_desc auo_b140han06 = { 1081 .modes = &auo_b140han06_mode, 1082 .num_modes = 1, 1083 .bpc = 8, 1084 .size = { 1085 .width = 309, 1086 .height = 174, 1087 }, 1088 .delay = { 1089 .hpd_reliable = 100, 1090 .enable = 20, 1091 .unprepare = 50, 1092 }, 1093 }; 1094 1095 static const struct drm_display_mode boe_nv101wxmn51_modes[] = { 1096 { 1097 .clock = 71900, 1098 .hdisplay = 1280, 1099 .hsync_start = 1280 + 48, 1100 .hsync_end = 1280 + 48 + 32, 1101 .htotal = 1280 + 48 + 32 + 80, 1102 .vdisplay = 800, 1103 .vsync_start = 800 + 3, 1104 .vsync_end = 800 + 3 + 5, 1105 .vtotal = 800 + 3 + 5 + 24, 1106 }, 1107 { 1108 .clock = 57500, 1109 .hdisplay = 1280, 1110 .hsync_start = 1280 + 48, 1111 .hsync_end = 1280 + 48 + 32, 1112 .htotal = 1280 + 48 + 32 + 80, 1113 .vdisplay = 800, 1114 .vsync_start = 800 + 3, 1115 .vsync_end = 800 + 3 + 5, 1116 .vtotal = 800 + 3 + 5 + 24, 1117 }, 1118 }; 1119 1120 static const struct panel_desc boe_nv101wxmn51 = { 1121 .modes = boe_nv101wxmn51_modes, 1122 .num_modes = ARRAY_SIZE(boe_nv101wxmn51_modes), 1123 .bpc = 8, 1124 .size = { 1125 .width = 217, 1126 .height = 136, 1127 }, 1128 .delay = { 1129 /* TODO: should be hpd-absent and no-hpd should be set? */ 1130 .hpd_reliable = 210, 1131 .enable = 50, 1132 .unprepare = 160, 1133 }, 1134 }; 1135 1136 static const struct drm_display_mode boe_nv110wtm_n61_modes[] = { 1137 { 1138 .clock = 207800, 1139 .hdisplay = 2160, 1140 .hsync_start = 2160 + 48, 1141 .hsync_end = 2160 + 48 + 32, 1142 .htotal = 2160 + 48 + 32 + 100, 1143 .vdisplay = 1440, 1144 .vsync_start = 1440 + 3, 1145 .vsync_end = 1440 + 3 + 6, 1146 .vtotal = 1440 + 3 + 6 + 31, 1147 .flags = DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC, 1148 }, 1149 { 1150 .clock = 138500, 1151 .hdisplay = 2160, 1152 .hsync_start = 2160 + 48, 1153 .hsync_end = 2160 + 48 + 32, 1154 .htotal = 2160 + 48 + 32 + 100, 1155 .vdisplay = 1440, 1156 .vsync_start = 1440 + 3, 1157 .vsync_end = 1440 + 3 + 6, 1158 .vtotal = 1440 + 3 + 6 + 31, 1159 .flags = DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC, 1160 }, 1161 }; 1162 1163 static const struct panel_desc boe_nv110wtm_n61 = { 1164 .modes = boe_nv110wtm_n61_modes, 1165 .num_modes = ARRAY_SIZE(boe_nv110wtm_n61_modes), 1166 .bpc = 8, 1167 .size = { 1168 .width = 233, 1169 .height = 155, 1170 }, 1171 .delay = { 1172 .hpd_absent = 200, 1173 .prepare_to_enable = 80, 1174 .enable = 50, 1175 .unprepare = 500, 1176 }, 1177 }; 1178 1179 /* Also used for boe_nv133fhm_n62 */ 1180 static const struct drm_display_mode boe_nv133fhm_n61_modes = { 1181 .clock = 147840, 1182 .hdisplay = 1920, 1183 .hsync_start = 1920 + 48, 1184 .hsync_end = 1920 + 48 + 32, 1185 .htotal = 1920 + 48 + 32 + 200, 1186 .vdisplay = 1080, 1187 .vsync_start = 1080 + 3, 1188 .vsync_end = 1080 + 3 + 6, 1189 .vtotal = 1080 + 3 + 6 + 31, 1190 .flags = DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC, 1191 }; 1192 1193 /* Also used for boe_nv133fhm_n62 */ 1194 static const struct panel_desc boe_nv133fhm_n61 = { 1195 .modes = &boe_nv133fhm_n61_modes, 1196 .num_modes = 1, 1197 .bpc = 6, 1198 .size = { 1199 .width = 294, 1200 .height = 165, 1201 }, 1202 .delay = { 1203 /* 1204 * When power is first given to the panel there's a short 1205 * spike on the HPD line. It was explained that this spike 1206 * was until the TCON data download was complete. On 1207 * one system this was measured at 8 ms. We'll put 15 ms 1208 * in the prepare delay just to be safe. That means: 1209 * - If HPD isn't hooked up you still have 200 ms delay. 1210 * - If HPD is hooked up we won't try to look at it for the 1211 * first 15 ms. 1212 */ 1213 .hpd_reliable = 15, 1214 .hpd_absent = 200, 1215 1216 .unprepare = 500, 1217 }, 1218 }; 1219 1220 static const struct drm_display_mode boe_nv140fhmn49_modes[] = { 1221 { 1222 .clock = 148500, 1223 .hdisplay = 1920, 1224 .hsync_start = 1920 + 48, 1225 .hsync_end = 1920 + 48 + 32, 1226 .htotal = 2200, 1227 .vdisplay = 1080, 1228 .vsync_start = 1080 + 3, 1229 .vsync_end = 1080 + 3 + 5, 1230 .vtotal = 1125, 1231 }, 1232 }; 1233 1234 static const struct panel_desc boe_nv140fhmn49 = { 1235 .modes = boe_nv140fhmn49_modes, 1236 .num_modes = ARRAY_SIZE(boe_nv140fhmn49_modes), 1237 .bpc = 6, 1238 .size = { 1239 .width = 309, 1240 .height = 174, 1241 }, 1242 .delay = { 1243 /* TODO: should be hpd-absent and no-hpd should be set? */ 1244 .hpd_reliable = 210, 1245 .enable = 50, 1246 .unprepare = 160, 1247 }, 1248 }; 1249 1250 static const struct drm_display_mode innolux_n116bca_ea1_mode = { 1251 .clock = 76420, 1252 .hdisplay = 1366, 1253 .hsync_start = 1366 + 136, 1254 .hsync_end = 1366 + 136 + 30, 1255 .htotal = 1366 + 136 + 30 + 60, 1256 .vdisplay = 768, 1257 .vsync_start = 768 + 8, 1258 .vsync_end = 768 + 8 + 12, 1259 .vtotal = 768 + 8 + 12 + 12, 1260 .flags = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC, 1261 }; 1262 1263 static const struct panel_desc innolux_n116bca_ea1 = { 1264 .modes = &innolux_n116bca_ea1_mode, 1265 .num_modes = 1, 1266 .bpc = 6, 1267 .size = { 1268 .width = 256, 1269 .height = 144, 1270 }, 1271 .delay = { 1272 .hpd_absent = 200, 1273 .prepare_to_enable = 80, 1274 .unprepare = 500, 1275 }, 1276 }; 1277 1278 /* 1279 * Datasheet specifies that at 60 Hz refresh rate: 1280 * - total horizontal time: { 1506, 1592, 1716 } 1281 * - total vertical time: { 788, 800, 868 } 1282 * 1283 * ...but doesn't go into exactly how that should be split into a front 1284 * porch, back porch, or sync length. For now we'll leave a single setting 1285 * here which allows a bit of tweaking of the pixel clock at the expense of 1286 * refresh rate. 1287 */ 1288 static const struct display_timing innolux_n116bge_timing = { 1289 .pixelclock = { 72600000, 76420000, 80240000 }, 1290 .hactive = { 1366, 1366, 1366 }, 1291 .hfront_porch = { 136, 136, 136 }, 1292 .hback_porch = { 60, 60, 60 }, 1293 .hsync_len = { 30, 30, 30 }, 1294 .vactive = { 768, 768, 768 }, 1295 .vfront_porch = { 8, 8, 8 }, 1296 .vback_porch = { 12, 12, 12 }, 1297 .vsync_len = { 12, 12, 12 }, 1298 .flags = DISPLAY_FLAGS_VSYNC_LOW | DISPLAY_FLAGS_HSYNC_LOW, 1299 }; 1300 1301 static const struct panel_desc innolux_n116bge = { 1302 .timings = &innolux_n116bge_timing, 1303 .num_timings = 1, 1304 .bpc = 6, 1305 .size = { 1306 .width = 256, 1307 .height = 144, 1308 }, 1309 }; 1310 1311 static const struct drm_display_mode innolux_n125hce_gn1_mode = { 1312 .clock = 162000, 1313 .hdisplay = 1920, 1314 .hsync_start = 1920 + 40, 1315 .hsync_end = 1920 + 40 + 40, 1316 .htotal = 1920 + 40 + 40 + 80, 1317 .vdisplay = 1080, 1318 .vsync_start = 1080 + 4, 1319 .vsync_end = 1080 + 4 + 4, 1320 .vtotal = 1080 + 4 + 4 + 24, 1321 }; 1322 1323 static const struct panel_desc innolux_n125hce_gn1 = { 1324 .modes = &innolux_n125hce_gn1_mode, 1325 .num_modes = 1, 1326 .bpc = 8, 1327 .size = { 1328 .width = 276, 1329 .height = 155, 1330 }, 1331 }; 1332 1333 static const struct drm_display_mode innolux_p120zdg_bf1_mode = { 1334 .clock = 206016, 1335 .hdisplay = 2160, 1336 .hsync_start = 2160 + 48, 1337 .hsync_end = 2160 + 48 + 32, 1338 .htotal = 2160 + 48 + 32 + 80, 1339 .vdisplay = 1440, 1340 .vsync_start = 1440 + 3, 1341 .vsync_end = 1440 + 3 + 10, 1342 .vtotal = 1440 + 3 + 10 + 27, 1343 .flags = DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC, 1344 }; 1345 1346 static const struct panel_desc innolux_p120zdg_bf1 = { 1347 .modes = &innolux_p120zdg_bf1_mode, 1348 .num_modes = 1, 1349 .bpc = 8, 1350 .size = { 1351 .width = 254, 1352 .height = 169, 1353 }, 1354 .delay = { 1355 .hpd_absent = 200, 1356 .unprepare = 500, 1357 }, 1358 }; 1359 1360 static const struct drm_display_mode ivo_m133nwf4_r0_mode = { 1361 .clock = 138778, 1362 .hdisplay = 1920, 1363 .hsync_start = 1920 + 24, 1364 .hsync_end = 1920 + 24 + 48, 1365 .htotal = 1920 + 24 + 48 + 88, 1366 .vdisplay = 1080, 1367 .vsync_start = 1080 + 3, 1368 .vsync_end = 1080 + 3 + 12, 1369 .vtotal = 1080 + 3 + 12 + 17, 1370 .flags = DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC, 1371 }; 1372 1373 static const struct panel_desc ivo_m133nwf4_r0 = { 1374 .modes = &ivo_m133nwf4_r0_mode, 1375 .num_modes = 1, 1376 .bpc = 8, 1377 .size = { 1378 .width = 294, 1379 .height = 165, 1380 }, 1381 .delay = { 1382 .hpd_absent = 200, 1383 .unprepare = 500, 1384 }, 1385 }; 1386 1387 static const struct drm_display_mode kingdisplay_kd116n21_30nv_a010_mode = { 1388 .clock = 81000, 1389 .hdisplay = 1366, 1390 .hsync_start = 1366 + 40, 1391 .hsync_end = 1366 + 40 + 32, 1392 .htotal = 1366 + 40 + 32 + 62, 1393 .vdisplay = 768, 1394 .vsync_start = 768 + 5, 1395 .vsync_end = 768 + 5 + 5, 1396 .vtotal = 768 + 5 + 5 + 122, 1397 .flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC, 1398 }; 1399 1400 static const struct panel_desc kingdisplay_kd116n21_30nv_a010 = { 1401 .modes = &kingdisplay_kd116n21_30nv_a010_mode, 1402 .num_modes = 1, 1403 .bpc = 6, 1404 .size = { 1405 .width = 256, 1406 .height = 144, 1407 }, 1408 .delay = { 1409 .hpd_absent = 200, 1410 }, 1411 }; 1412 1413 static const struct drm_display_mode lg_lp079qx1_sp0v_mode = { 1414 .clock = 200000, 1415 .hdisplay = 1536, 1416 .hsync_start = 1536 + 12, 1417 .hsync_end = 1536 + 12 + 16, 1418 .htotal = 1536 + 12 + 16 + 48, 1419 .vdisplay = 2048, 1420 .vsync_start = 2048 + 8, 1421 .vsync_end = 2048 + 8 + 4, 1422 .vtotal = 2048 + 8 + 4 + 8, 1423 .flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC, 1424 }; 1425 1426 static const struct panel_desc lg_lp079qx1_sp0v = { 1427 .modes = &lg_lp079qx1_sp0v_mode, 1428 .num_modes = 1, 1429 .size = { 1430 .width = 129, 1431 .height = 171, 1432 }, 1433 }; 1434 1435 static const struct drm_display_mode lg_lp097qx1_spa1_mode = { 1436 .clock = 205210, 1437 .hdisplay = 2048, 1438 .hsync_start = 2048 + 150, 1439 .hsync_end = 2048 + 150 + 5, 1440 .htotal = 2048 + 150 + 5 + 5, 1441 .vdisplay = 1536, 1442 .vsync_start = 1536 + 3, 1443 .vsync_end = 1536 + 3 + 1, 1444 .vtotal = 1536 + 3 + 1 + 9, 1445 }; 1446 1447 static const struct panel_desc lg_lp097qx1_spa1 = { 1448 .modes = &lg_lp097qx1_spa1_mode, 1449 .num_modes = 1, 1450 .size = { 1451 .width = 208, 1452 .height = 147, 1453 }, 1454 }; 1455 1456 static const struct drm_display_mode lg_lp120up1_mode = { 1457 .clock = 162300, 1458 .hdisplay = 1920, 1459 .hsync_start = 1920 + 40, 1460 .hsync_end = 1920 + 40 + 40, 1461 .htotal = 1920 + 40 + 40 + 80, 1462 .vdisplay = 1280, 1463 .vsync_start = 1280 + 4, 1464 .vsync_end = 1280 + 4 + 4, 1465 .vtotal = 1280 + 4 + 4 + 12, 1466 }; 1467 1468 static const struct panel_desc lg_lp120up1 = { 1469 .modes = &lg_lp120up1_mode, 1470 .num_modes = 1, 1471 .bpc = 8, 1472 .size = { 1473 .width = 267, 1474 .height = 183, 1475 }, 1476 }; 1477 1478 static const struct drm_display_mode lg_lp129qe_mode = { 1479 .clock = 285250, 1480 .hdisplay = 2560, 1481 .hsync_start = 2560 + 48, 1482 .hsync_end = 2560 + 48 + 32, 1483 .htotal = 2560 + 48 + 32 + 80, 1484 .vdisplay = 1700, 1485 .vsync_start = 1700 + 3, 1486 .vsync_end = 1700 + 3 + 10, 1487 .vtotal = 1700 + 3 + 10 + 36, 1488 }; 1489 1490 static const struct panel_desc lg_lp129qe = { 1491 .modes = &lg_lp129qe_mode, 1492 .num_modes = 1, 1493 .bpc = 8, 1494 .size = { 1495 .width = 272, 1496 .height = 181, 1497 }, 1498 }; 1499 1500 static const struct drm_display_mode neweast_wjfh116008a_modes[] = { 1501 { 1502 .clock = 138500, 1503 .hdisplay = 1920, 1504 .hsync_start = 1920 + 48, 1505 .hsync_end = 1920 + 48 + 32, 1506 .htotal = 1920 + 48 + 32 + 80, 1507 .vdisplay = 1080, 1508 .vsync_start = 1080 + 3, 1509 .vsync_end = 1080 + 3 + 5, 1510 .vtotal = 1080 + 3 + 5 + 23, 1511 .flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC, 1512 }, { 1513 .clock = 110920, 1514 .hdisplay = 1920, 1515 .hsync_start = 1920 + 48, 1516 .hsync_end = 1920 + 48 + 32, 1517 .htotal = 1920 + 48 + 32 + 80, 1518 .vdisplay = 1080, 1519 .vsync_start = 1080 + 3, 1520 .vsync_end = 1080 + 3 + 5, 1521 .vtotal = 1080 + 3 + 5 + 23, 1522 .flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC, 1523 } 1524 }; 1525 1526 static const struct panel_desc neweast_wjfh116008a = { 1527 .modes = neweast_wjfh116008a_modes, 1528 .num_modes = 2, 1529 .bpc = 6, 1530 .size = { 1531 .width = 260, 1532 .height = 150, 1533 }, 1534 .delay = { 1535 .hpd_reliable = 110, 1536 .enable = 20, 1537 .unprepare = 500, 1538 }, 1539 }; 1540 1541 static const struct drm_display_mode samsung_lsn122dl01_c01_mode = { 1542 .clock = 271560, 1543 .hdisplay = 2560, 1544 .hsync_start = 2560 + 48, 1545 .hsync_end = 2560 + 48 + 32, 1546 .htotal = 2560 + 48 + 32 + 80, 1547 .vdisplay = 1600, 1548 .vsync_start = 1600 + 2, 1549 .vsync_end = 1600 + 2 + 5, 1550 .vtotal = 1600 + 2 + 5 + 57, 1551 }; 1552 1553 static const struct panel_desc samsung_lsn122dl01_c01 = { 1554 .modes = &samsung_lsn122dl01_c01_mode, 1555 .num_modes = 1, 1556 .size = { 1557 .width = 263, 1558 .height = 164, 1559 }, 1560 }; 1561 1562 static const struct drm_display_mode samsung_ltn140at29_301_mode = { 1563 .clock = 76300, 1564 .hdisplay = 1366, 1565 .hsync_start = 1366 + 64, 1566 .hsync_end = 1366 + 64 + 48, 1567 .htotal = 1366 + 64 + 48 + 128, 1568 .vdisplay = 768, 1569 .vsync_start = 768 + 2, 1570 .vsync_end = 768 + 2 + 5, 1571 .vtotal = 768 + 2 + 5 + 17, 1572 }; 1573 1574 static const struct panel_desc samsung_ltn140at29_301 = { 1575 .modes = &samsung_ltn140at29_301_mode, 1576 .num_modes = 1, 1577 .bpc = 6, 1578 .size = { 1579 .width = 320, 1580 .height = 187, 1581 }, 1582 }; 1583 1584 static const struct drm_display_mode sharp_ld_d5116z01b_mode = { 1585 .clock = 168480, 1586 .hdisplay = 1920, 1587 .hsync_start = 1920 + 48, 1588 .hsync_end = 1920 + 48 + 32, 1589 .htotal = 1920 + 48 + 32 + 80, 1590 .vdisplay = 1280, 1591 .vsync_start = 1280 + 3, 1592 .vsync_end = 1280 + 3 + 10, 1593 .vtotal = 1280 + 3 + 10 + 57, 1594 .flags = DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC, 1595 }; 1596 1597 static const struct panel_desc sharp_ld_d5116z01b = { 1598 .modes = &sharp_ld_d5116z01b_mode, 1599 .num_modes = 1, 1600 .bpc = 8, 1601 .size = { 1602 .width = 260, 1603 .height = 120, 1604 }, 1605 }; 1606 1607 static const struct display_timing sharp_lq123p1jx31_timing = { 1608 .pixelclock = { 252750000, 252750000, 266604720 }, 1609 .hactive = { 2400, 2400, 2400 }, 1610 .hfront_porch = { 48, 48, 48 }, 1611 .hback_porch = { 80, 80, 84 }, 1612 .hsync_len = { 32, 32, 32 }, 1613 .vactive = { 1600, 1600, 1600 }, 1614 .vfront_porch = { 3, 3, 3 }, 1615 .vback_porch = { 33, 33, 120 }, 1616 .vsync_len = { 10, 10, 10 }, 1617 .flags = DISPLAY_FLAGS_VSYNC_LOW | DISPLAY_FLAGS_HSYNC_LOW, 1618 }; 1619 1620 static const struct panel_desc sharp_lq123p1jx31 = { 1621 .timings = &sharp_lq123p1jx31_timing, 1622 .num_timings = 1, 1623 .bpc = 8, 1624 .size = { 1625 .width = 259, 1626 .height = 173, 1627 }, 1628 .delay = { 1629 .hpd_reliable = 110, 1630 .enable = 50, 1631 .unprepare = 550, 1632 }, 1633 }; 1634 1635 static const struct drm_display_mode sharp_lq140m1jw46_mode[] = { 1636 { 1637 .clock = 346500, 1638 .hdisplay = 1920, 1639 .hsync_start = 1920 + 48, 1640 .hsync_end = 1920 + 48 + 32, 1641 .htotal = 1920 + 48 + 32 + 80, 1642 .vdisplay = 1080, 1643 .vsync_start = 1080 + 3, 1644 .vsync_end = 1080 + 3 + 5, 1645 .vtotal = 1080 + 3 + 5 + 69, 1646 .flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC, 1647 }, { 1648 .clock = 144370, 1649 .hdisplay = 1920, 1650 .hsync_start = 1920 + 48, 1651 .hsync_end = 1920 + 48 + 32, 1652 .htotal = 1920 + 48 + 32 + 80, 1653 .vdisplay = 1080, 1654 .vsync_start = 1080 + 3, 1655 .vsync_end = 1080 + 3 + 5, 1656 .vtotal = 1080 + 3 + 5 + 69, 1657 .flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC, 1658 }, 1659 }; 1660 1661 static const struct panel_desc sharp_lq140m1jw46 = { 1662 .modes = sharp_lq140m1jw46_mode, 1663 .num_modes = ARRAY_SIZE(sharp_lq140m1jw46_mode), 1664 .bpc = 8, 1665 .size = { 1666 .width = 309, 1667 .height = 174, 1668 }, 1669 .delay = { 1670 .hpd_absent = 80, 1671 .enable = 50, 1672 .unprepare = 500, 1673 }, 1674 }; 1675 1676 static const struct drm_display_mode starry_kr122ea0sra_mode = { 1677 .clock = 147000, 1678 .hdisplay = 1920, 1679 .hsync_start = 1920 + 16, 1680 .hsync_end = 1920 + 16 + 16, 1681 .htotal = 1920 + 16 + 16 + 32, 1682 .vdisplay = 1200, 1683 .vsync_start = 1200 + 15, 1684 .vsync_end = 1200 + 15 + 2, 1685 .vtotal = 1200 + 15 + 2 + 18, 1686 .flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC, 1687 }; 1688 1689 static const struct panel_desc starry_kr122ea0sra = { 1690 .modes = &starry_kr122ea0sra_mode, 1691 .num_modes = 1, 1692 .size = { 1693 .width = 263, 1694 .height = 164, 1695 }, 1696 .delay = { 1697 /* TODO: should be hpd-absent and no-hpd should be set? */ 1698 .hpd_reliable = 10 + 200, 1699 .enable = 50, 1700 .unprepare = 10 + 500, 1701 }, 1702 }; 1703 1704 static const struct of_device_id platform_of_match[] = { 1705 { 1706 /* Must be first */ 1707 .compatible = "edp-panel", 1708 }, { 1709 .compatible = "auo,b101ean01", 1710 .data = &auo_b101ean01, 1711 }, { 1712 .compatible = "auo,b116xa01", 1713 .data = &auo_b116xak01, 1714 }, { 1715 .compatible = "auo,b116xw03", 1716 .data = &auo_b116xw03, 1717 }, { 1718 .compatible = "auo,b133han05", 1719 .data = &auo_b133han05, 1720 }, { 1721 .compatible = "auo,b133htn01", 1722 .data = &auo_b133htn01, 1723 }, { 1724 .compatible = "auo,b133xtn01", 1725 .data = &auo_b133xtn01, 1726 }, { 1727 .compatible = "auo,b140han06", 1728 .data = &auo_b140han06, 1729 }, { 1730 .compatible = "boe,nv101wxmn51", 1731 .data = &boe_nv101wxmn51, 1732 }, { 1733 .compatible = "boe,nv110wtm-n61", 1734 .data = &boe_nv110wtm_n61, 1735 }, { 1736 .compatible = "boe,nv133fhm-n61", 1737 .data = &boe_nv133fhm_n61, 1738 }, { 1739 .compatible = "boe,nv133fhm-n62", 1740 .data = &boe_nv133fhm_n61, 1741 }, { 1742 .compatible = "boe,nv140fhmn49", 1743 .data = &boe_nv140fhmn49, 1744 }, { 1745 .compatible = "innolux,n116bca-ea1", 1746 .data = &innolux_n116bca_ea1, 1747 }, { 1748 .compatible = "innolux,n116bge", 1749 .data = &innolux_n116bge, 1750 }, { 1751 .compatible = "innolux,n125hce-gn1", 1752 .data = &innolux_n125hce_gn1, 1753 }, { 1754 .compatible = "innolux,p120zdg-bf1", 1755 .data = &innolux_p120zdg_bf1, 1756 }, { 1757 .compatible = "ivo,m133nwf4-r0", 1758 .data = &ivo_m133nwf4_r0, 1759 }, { 1760 .compatible = "kingdisplay,kd116n21-30nv-a010", 1761 .data = &kingdisplay_kd116n21_30nv_a010, 1762 }, { 1763 .compatible = "lg,lp079qx1-sp0v", 1764 .data = &lg_lp079qx1_sp0v, 1765 }, { 1766 .compatible = "lg,lp097qx1-spa1", 1767 .data = &lg_lp097qx1_spa1, 1768 }, { 1769 .compatible = "lg,lp120up1", 1770 .data = &lg_lp120up1, 1771 }, { 1772 .compatible = "lg,lp129qe", 1773 .data = &lg_lp129qe, 1774 }, { 1775 .compatible = "neweast,wjfh116008a", 1776 .data = &neweast_wjfh116008a, 1777 }, { 1778 .compatible = "samsung,lsn122dl01-c01", 1779 .data = &samsung_lsn122dl01_c01, 1780 }, { 1781 .compatible = "samsung,ltn140at29-301", 1782 .data = &samsung_ltn140at29_301, 1783 }, { 1784 .compatible = "sharp,ld-d5116z01b", 1785 .data = &sharp_ld_d5116z01b, 1786 }, { 1787 .compatible = "sharp,lq123p1jx31", 1788 .data = &sharp_lq123p1jx31, 1789 }, { 1790 .compatible = "sharp,lq140m1jw46", 1791 .data = &sharp_lq140m1jw46, 1792 }, { 1793 .compatible = "starry,kr122ea0sra", 1794 .data = &starry_kr122ea0sra, 1795 }, { 1796 /* sentinel */ 1797 } 1798 }; 1799 MODULE_DEVICE_TABLE(of, platform_of_match); 1800 1801 static const struct panel_delay delay_200_500_p2e80 = { 1802 .hpd_absent = 200, 1803 .unprepare = 500, 1804 .prepare_to_enable = 80, 1805 }; 1806 1807 static const struct panel_delay delay_200_500_p2e100 = { 1808 .hpd_absent = 200, 1809 .unprepare = 500, 1810 .prepare_to_enable = 100, 1811 }; 1812 1813 static const struct panel_delay delay_200_500_e50 = { 1814 .hpd_absent = 200, 1815 .unprepare = 500, 1816 .enable = 50, 1817 }; 1818 1819 static const struct panel_delay delay_200_500_e80_d50 = { 1820 .hpd_absent = 200, 1821 .unprepare = 500, 1822 .enable = 80, 1823 .disable = 50, 1824 }; 1825 1826 static const struct panel_delay delay_100_500_e200 = { 1827 .hpd_absent = 100, 1828 .unprepare = 500, 1829 .enable = 200, 1830 }; 1831 1832 #define EDP_PANEL_ENTRY(vend_chr_0, vend_chr_1, vend_chr_2, product_id, _delay, _name) \ 1833 { \ 1834 .name = _name, \ 1835 .panel_id = drm_edid_encode_panel_id(vend_chr_0, vend_chr_1, vend_chr_2, \ 1836 product_id), \ 1837 .delay = _delay \ 1838 } 1839 1840 /* 1841 * This table is used to figure out power sequencing delays for panels that 1842 * are detected by EDID. Entries here may point to entries in the 1843 * platform_of_match table (if a panel is listed in both places). 1844 * 1845 * Sort first by vendor, then by product ID. 1846 */ 1847 static const struct edp_panel_entry edp_panels[] = { 1848 EDP_PANEL_ENTRY('A', 'U', 'O', 0x405c, &auo_b116xak01.delay, "B116XAK01"), 1849 EDP_PANEL_ENTRY('A', 'U', 'O', 0x615c, &delay_200_500_e50, "B116XAN06.1"), 1850 EDP_PANEL_ENTRY('A', 'U', 'O', 0x8594, &delay_200_500_e50, "B133UAN01.0"), 1851 1852 EDP_PANEL_ENTRY('B', 'O', 'E', 0x0786, &delay_200_500_p2e80, "NV116WHM-T01"), 1853 EDP_PANEL_ENTRY('B', 'O', 'E', 0x07d1, &boe_nv133fhm_n61.delay, "NV133FHM-N61"), 1854 EDP_PANEL_ENTRY('B', 'O', 'E', 0x082d, &boe_nv133fhm_n61.delay, "NV133FHM-N62"), 1855 EDP_PANEL_ENTRY('B', 'O', 'E', 0x098d, &boe_nv110wtm_n61.delay, "NV110WTM-N61"), 1856 EDP_PANEL_ENTRY('B', 'O', 'E', 0x0a5d, &delay_200_500_e50, "NV116WHM-N45"), 1857 1858 EDP_PANEL_ENTRY('C', 'M', 'N', 0x114c, &innolux_n116bca_ea1.delay, "N116BCA-EA1"), 1859 1860 EDP_PANEL_ENTRY('K', 'D', 'B', 0x0624, &kingdisplay_kd116n21_30nv_a010.delay, "116N21-30NV-A010"), 1861 EDP_PANEL_ENTRY('K', 'D', 'B', 0x1120, &delay_200_500_e80_d50, "116N29-30NK-C007"), 1862 1863 EDP_PANEL_ENTRY('S', 'H', 'P', 0x1523, &sharp_lq140m1jw46.delay, "LQ140M1JW46"), 1864 EDP_PANEL_ENTRY('S', 'H', 'P', 0x154c, &delay_200_500_p2e100, "LQ116M1JW10"), 1865 1866 EDP_PANEL_ENTRY('S', 'T', 'A', 0x0100, &delay_100_500_e200, "2081116HHD028001-51D"), 1867 1868 { /* sentinal */ } 1869 }; 1870 1871 static const struct edp_panel_entry *find_edp_panel(u32 panel_id) 1872 { 1873 const struct edp_panel_entry *panel; 1874 1875 if (!panel_id) 1876 return NULL; 1877 1878 for (panel = edp_panels; panel->panel_id; panel++) 1879 if (panel->panel_id == panel_id) 1880 return panel; 1881 1882 return NULL; 1883 } 1884 1885 static int panel_edp_platform_probe(struct platform_device *pdev) 1886 { 1887 const struct of_device_id *id; 1888 1889 /* Skip one since "edp-panel" is only supported on DP AUX bus */ 1890 id = of_match_node(platform_of_match + 1, pdev->dev.of_node); 1891 if (!id) 1892 return -ENODEV; 1893 1894 return panel_edp_probe(&pdev->dev, id->data, NULL); 1895 } 1896 1897 static int panel_edp_platform_remove(struct platform_device *pdev) 1898 { 1899 return panel_edp_remove(&pdev->dev); 1900 } 1901 1902 static void panel_edp_platform_shutdown(struct platform_device *pdev) 1903 { 1904 panel_edp_shutdown(&pdev->dev); 1905 } 1906 1907 static const struct dev_pm_ops panel_edp_pm_ops = { 1908 SET_RUNTIME_PM_OPS(panel_edp_suspend, panel_edp_resume, NULL) 1909 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 1910 pm_runtime_force_resume) 1911 }; 1912 1913 static struct platform_driver panel_edp_platform_driver = { 1914 .driver = { 1915 .name = "panel-edp", 1916 .of_match_table = platform_of_match, 1917 .pm = &panel_edp_pm_ops, 1918 }, 1919 .probe = panel_edp_platform_probe, 1920 .remove = panel_edp_platform_remove, 1921 .shutdown = panel_edp_platform_shutdown, 1922 }; 1923 1924 static int panel_edp_dp_aux_ep_probe(struct dp_aux_ep_device *aux_ep) 1925 { 1926 const struct of_device_id *id; 1927 1928 id = of_match_node(platform_of_match, aux_ep->dev.of_node); 1929 if (!id) 1930 return -ENODEV; 1931 1932 return panel_edp_probe(&aux_ep->dev, id->data, aux_ep->aux); 1933 } 1934 1935 static void panel_edp_dp_aux_ep_remove(struct dp_aux_ep_device *aux_ep) 1936 { 1937 panel_edp_remove(&aux_ep->dev); 1938 } 1939 1940 static void panel_edp_dp_aux_ep_shutdown(struct dp_aux_ep_device *aux_ep) 1941 { 1942 panel_edp_shutdown(&aux_ep->dev); 1943 } 1944 1945 static struct dp_aux_ep_driver panel_edp_dp_aux_ep_driver = { 1946 .driver = { 1947 .name = "panel-simple-dp-aux", 1948 .of_match_table = platform_of_match, /* Same as platform one! */ 1949 .pm = &panel_edp_pm_ops, 1950 }, 1951 .probe = panel_edp_dp_aux_ep_probe, 1952 .remove = panel_edp_dp_aux_ep_remove, 1953 .shutdown = panel_edp_dp_aux_ep_shutdown, 1954 }; 1955 1956 static int __init panel_edp_init(void) 1957 { 1958 int err; 1959 1960 err = platform_driver_register(&panel_edp_platform_driver); 1961 if (err < 0) 1962 return err; 1963 1964 err = dp_aux_dp_driver_register(&panel_edp_dp_aux_ep_driver); 1965 if (err < 0) 1966 goto err_did_platform_register; 1967 1968 return 0; 1969 1970 err_did_platform_register: 1971 platform_driver_unregister(&panel_edp_platform_driver); 1972 1973 return err; 1974 } 1975 module_init(panel_edp_init); 1976 1977 static void __exit panel_edp_exit(void) 1978 { 1979 dp_aux_dp_driver_unregister(&panel_edp_dp_aux_ep_driver); 1980 platform_driver_unregister(&panel_edp_platform_driver); 1981 } 1982 module_exit(panel_edp_exit); 1983 1984 MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>"); 1985 MODULE_DESCRIPTION("DRM Driver for Simple eDP Panels"); 1986 MODULE_LICENSE("GPL and additional rights"); 1987