drivers/gpu/drm/panel/panel-edp.c

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