drivers/gpu/drm/tegra/dpaux.c

   1 /*
   2  * Copyright (C) 2013 NVIDIA Corporation
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  */
   8
   9 #include <linux/clk.h>
  10 #include <linux/delay.h>
  11 #include <linux/gpio.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/io.h>
  14 #include <linux/of_gpio.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/reset.h>
  17 #include <linux/regulator/consumer.h>
  18 #include <linux/workqueue.h>
  19
  20 #include <drm/drm_dp_helper.h>
  21 #include <drm/drm_panel.h>
  22
  23 #include "dpaux.h"
  24 #include "drm.h"
  25
  26 static DEFINE_MUTEX(dpaux_lock);
  27 static LIST_HEAD(dpaux_list);
  28
  29 struct tegra_dpaux {
  30         struct drm_dp_aux aux;
  31         struct device *dev;
  32
  33         void __iomem *regs;
  34         int irq;
  35
  36         struct tegra_output *output;
  37
  38         struct reset_control *rst;
  39         struct clk *clk_parent;
  40         struct clk *clk;
  41
  42         struct regulator *vdd;
  43
  44         struct completion complete;
  45         struct work_struct work;
  46         struct list_head list;
  47 };
  48
  49 static inline struct tegra_dpaux *to_dpaux(struct drm_dp_aux *aux)
  50 {
  51         return container_of(aux, struct tegra_dpaux, aux);
  52 }
  53
  54 static inline struct tegra_dpaux *work_to_dpaux(struct work_struct *work)
  55 {
  56         return container_of(work, struct tegra_dpaux, work);
  57 }
  58
  59 static inline u32 tegra_dpaux_readl(struct tegra_dpaux *dpaux,
  60                                     unsigned long offset)
  61 {
  62         return readl(dpaux->regs + (offset << 2));
  63 }
  64
  65 static inline void tegra_dpaux_writel(struct tegra_dpaux *dpaux,
  66                                       u32 value, unsigned long offset)
  67 {
  68         writel(value, dpaux->regs + (offset << 2));
  69 }
  70
  71 static void tegra_dpaux_write_fifo(struct tegra_dpaux *dpaux, const u8 *buffer,
  72                                    size_t size)
  73 {
  74         size_t i, j;
  75
  76         for (i = 0; i < DIV_ROUND_UP(size, 4); i++) {
  77                 size_t num = min_t(size_t, size - i * 4, 4);
  78                 u32 value = 0;
  79
  80                 for (j = 0; j < num; j++)
  81                         value |= buffer[i * 4 + j] << (j * 8);
  82
  83                 tegra_dpaux_writel(dpaux, value, DPAUX_DP_AUXDATA_WRITE(i));
  84         }
  85 }
  86
  87 static void tegra_dpaux_read_fifo(struct tegra_dpaux *dpaux, u8 *buffer,
  88                                   size_t size)
  89 {
  90         size_t i, j;
  91
  92         for (i = 0; i < DIV_ROUND_UP(size, 4); i++) {
  93                 size_t num = min_t(size_t, size - i * 4, 4);
  94                 u32 value;
  95
  96                 value = tegra_dpaux_readl(dpaux, DPAUX_DP_AUXDATA_READ(i));
  97
  98                 for (j = 0; j < num; j++)
  99                         buffer[i * 4 + j] = value >> (j * 8);
 100         }
 101 }
 102
 103 static ssize_t tegra_dpaux_transfer(struct drm_dp_aux *aux,
 104                                     struct drm_dp_aux_msg *msg)
 105 {
 106         unsigned long timeout = msecs_to_jiffies(250);
 107         struct tegra_dpaux *dpaux = to_dpaux(aux);
 108         unsigned long status;
 109         ssize_t ret = 0;
 110         u32 value;
 111
 112         /* Tegra has 4x4 byte DP AUX transmit and receive FIFOs. */
 113         if (msg->size > 16)
 114                 return -EINVAL;
 115
 116         /*
 117          * Allow zero-sized messages only for I2C, in which case they specify
 118          * address-only transactions.
 119          */
 120         if (msg->size < 1) {
 121                 switch (msg->request & ~DP_AUX_I2C_MOT) {
 122                 case DP_AUX_I2C_WRITE_STATUS_UPDATE:
 123                 case DP_AUX_I2C_WRITE:
 124                 case DP_AUX_I2C_READ:
 125                         value = DPAUX_DP_AUXCTL_CMD_ADDRESS_ONLY;
 126                         break;
 127
 128                 default:
 129                         return -EINVAL;
 130                 }
 131         } else {
 132                 /* For non-zero-sized messages, set the CMDLEN field. */
 133                 value = DPAUX_DP_AUXCTL_CMDLEN(msg->size - 1);
 134         }
 135
 136         switch (msg->request & ~DP_AUX_I2C_MOT) {
 137         case DP_AUX_I2C_WRITE:
 138                 if (msg->request & DP_AUX_I2C_MOT)
 139                         value |= DPAUX_DP_AUXCTL_CMD_MOT_WR;
 140                 else
 141                         value |= DPAUX_DP_AUXCTL_CMD_I2C_WR;
 142
 143                 break;
 144
 145         case DP_AUX_I2C_READ:
 146                 if (msg->request & DP_AUX_I2C_MOT)
 147                         value |= DPAUX_DP_AUXCTL_CMD_MOT_RD;
 148                 else
 149                         value |= DPAUX_DP_AUXCTL_CMD_I2C_RD;
 150
 151                 break;
 152
 153         case DP_AUX_I2C_WRITE_STATUS_UPDATE:
 154                 if (msg->request & DP_AUX_I2C_MOT)
 155                         value |= DPAUX_DP_AUXCTL_CMD_MOT_RQ;
 156                 else
 157                         value |= DPAUX_DP_AUXCTL_CMD_I2C_RQ;
 158
 159                 break;
 160
 161         case DP_AUX_NATIVE_WRITE:
 162                 value |= DPAUX_DP_AUXCTL_CMD_AUX_WR;
 163                 break;
 164
 165         case DP_AUX_NATIVE_READ:
 166                 value |= DPAUX_DP_AUXCTL_CMD_AUX_RD;
 167                 break;
 168
 169         default:
 170                 return -EINVAL;
 171         }
 172
 173         tegra_dpaux_writel(dpaux, msg->address, DPAUX_DP_AUXADDR);
 174         tegra_dpaux_writel(dpaux, value, DPAUX_DP_AUXCTL);
 175
 176         if ((msg->request & DP_AUX_I2C_READ) == 0) {
 177                 tegra_dpaux_write_fifo(dpaux, msg->buffer, msg->size);
 178                 ret = msg->size;
 179         }
 180
 181         /* start transaction */
 182         value = tegra_dpaux_readl(dpaux, DPAUX_DP_AUXCTL);
 183         value |= DPAUX_DP_AUXCTL_TRANSACTREQ;
 184         tegra_dpaux_writel(dpaux, value, DPAUX_DP_AUXCTL);
 185
 186         status = wait_for_completion_timeout(&dpaux->complete, timeout);
 187         if (!status)
 188                 return -ETIMEDOUT;
 189
 190         /* read status and clear errors */
 191         value = tegra_dpaux_readl(dpaux, DPAUX_DP_AUXSTAT);
 192         tegra_dpaux_writel(dpaux, 0xf00, DPAUX_DP_AUXSTAT);
 193
 194         if (value & DPAUX_DP_AUXSTAT_TIMEOUT_ERROR)
 195                 return -ETIMEDOUT;
 196
 197         if ((value & DPAUX_DP_AUXSTAT_RX_ERROR) ||
 198             (value & DPAUX_DP_AUXSTAT_SINKSTAT_ERROR) ||
 199             (value & DPAUX_DP_AUXSTAT_NO_STOP_ERROR))
 200                 return -EIO;
 201
 202         switch ((value & DPAUX_DP_AUXSTAT_REPLY_TYPE_MASK) >> 16) {
 203         case 0x00:
 204                 msg->reply = DP_AUX_NATIVE_REPLY_ACK;
 205                 break;
 206
 207         case 0x01:
 208                 msg->reply = DP_AUX_NATIVE_REPLY_NACK;
 209                 break;
 210
 211         case 0x02:
 212                 msg->reply = DP_AUX_NATIVE_REPLY_DEFER;
 213                 break;
 214
 215         case 0x04:
 216                 msg->reply = DP_AUX_I2C_REPLY_NACK;
 217                 break;
 218
 219         case 0x08:
 220                 msg->reply = DP_AUX_I2C_REPLY_DEFER;
 221                 break;
 222         }
 223
 224         if ((msg->size > 0) && (msg->reply == DP_AUX_NATIVE_REPLY_ACK)) {
 225                 if (msg->request & DP_AUX_I2C_READ) {
 226                         size_t count = value & DPAUX_DP_AUXSTAT_REPLY_MASK;
 227
 228                         if (WARN_ON(count != msg->size))
 229                                 count = min_t(size_t, count, msg->size);
 230
 231                         tegra_dpaux_read_fifo(dpaux, msg->buffer, count);
 232                         ret = count;
 233                 }
 234         }
 235
 236         return ret;
 237 }
 238
 239 static void tegra_dpaux_hotplug(struct work_struct *work)
 240 {
 241         struct tegra_dpaux *dpaux = work_to_dpaux(work);
 242
 243         if (dpaux->output)
 244                 drm_helper_hpd_irq_event(dpaux->output->connector.dev);
 245 }
 246
 247 static irqreturn_t tegra_dpaux_irq(int irq, void *data)
 248 {
 249         struct tegra_dpaux *dpaux = data;
 250         irqreturn_t ret = IRQ_HANDLED;
 251         u32 value;
 252
 253         /* clear interrupts */
 254         value = tegra_dpaux_readl(dpaux, DPAUX_INTR_AUX);
 255         tegra_dpaux_writel(dpaux, value, DPAUX_INTR_AUX);
 256
 257         if (value & (DPAUX_INTR_PLUG_EVENT | DPAUX_INTR_UNPLUG_EVENT))
 258                 schedule_work(&dpaux->work);
 259
 260         if (value & DPAUX_INTR_IRQ_EVENT) {
 261                 /* TODO: handle this */
 262         }
 263
 264         if (value & DPAUX_INTR_AUX_DONE)
 265                 complete(&dpaux->complete);
 266
 267         return ret;
 268 }
 269
 270 static void tegra_dpaux_pad_power_down(struct tegra_dpaux *dpaux)
 271 {
 272         u32 value = tegra_dpaux_readl(dpaux, DPAUX_HYBRID_SPARE);
 273
 274         value |= DPAUX_HYBRID_SPARE_PAD_POWER_DOWN;
 275
 276         tegra_dpaux_writel(dpaux, value, DPAUX_HYBRID_SPARE);
 277 }
 278
 279 static void tegra_dpaux_pad_power_up(struct tegra_dpaux *dpaux)
 280 {
 281         u32 value = tegra_dpaux_readl(dpaux, DPAUX_HYBRID_SPARE);
 282
 283         value &= ~DPAUX_HYBRID_SPARE_PAD_POWER_DOWN;
 284
 285         tegra_dpaux_writel(dpaux, value, DPAUX_HYBRID_SPARE);
 286 }
 287
 288 static int tegra_dpaux_pad_config(struct tegra_dpaux *dpaux, unsigned function)
 289 {
 290         u32 value;
 291
 292         switch (function) {
 293         case DPAUX_HYBRID_PADCTL_MODE_AUX:
 294                 value = DPAUX_HYBRID_PADCTL_AUX_CMH(2) |
 295                         DPAUX_HYBRID_PADCTL_AUX_DRVZ(4) |
 296                         DPAUX_HYBRID_PADCTL_AUX_DRVI(0x18) |
 297                         DPAUX_HYBRID_PADCTL_AUX_INPUT_RCV |
 298                         DPAUX_HYBRID_PADCTL_MODE_AUX;
 299                 break;
 300
 301         case DPAUX_HYBRID_PADCTL_MODE_I2C:
 302                 value = DPAUX_HYBRID_PADCTL_I2C_SDA_INPUT_RCV |
 303                         DPAUX_HYBRID_PADCTL_I2C_SCL_INPUT_RCV |
 304                         DPAUX_HYBRID_PADCTL_MODE_I2C;
 305                 break;
 306
 307         default:
 308                 return -ENOTSUPP;
 309         }
 310
 311         tegra_dpaux_writel(dpaux, value, DPAUX_HYBRID_PADCTL);
 312         tegra_dpaux_pad_power_up(dpaux);
 313
 314         return 0;
 315 }
 316
 317 static int tegra_dpaux_probe(struct platform_device *pdev)
 318 {
 319         struct tegra_dpaux *dpaux;
 320         struct resource *regs;
 321         u32 value;
 322         int err;
 323
 324         dpaux = devm_kzalloc(&pdev->dev, sizeof(*dpaux), GFP_KERNEL);
 325         if (!dpaux)
 326                 return -ENOMEM;
 327
 328         INIT_WORK(&dpaux->work, tegra_dpaux_hotplug);
 329         init_completion(&dpaux->complete);
 330         INIT_LIST_HEAD(&dpaux->list);
 331         dpaux->dev = &pdev->dev;
 332
 333         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 334         dpaux->regs = devm_ioremap_resource(&pdev->dev, regs);
 335         if (IS_ERR(dpaux->regs))
 336                 return PTR_ERR(dpaux->regs);
 337
 338         dpaux->irq = platform_get_irq(pdev, 0);
 339         if (dpaux->irq < 0) {
 340                 dev_err(&pdev->dev, "failed to get IRQ\n");
 341                 return -ENXIO;
 342         }
 343
 344         if (!pdev->dev.pm_domain) {
 345                 dpaux->rst = devm_reset_control_get(&pdev->dev, "dpaux");
 346                 if (IS_ERR(dpaux->rst)) {
 347                         dev_err(&pdev->dev,
 348                                 "failed to get reset control: %ld\n",
 349                                 PTR_ERR(dpaux->rst));
 350                         return PTR_ERR(dpaux->rst);
 351                 }
 352         }
 353
 354         dpaux->clk = devm_clk_get(&pdev->dev, NULL);
 355         if (IS_ERR(dpaux->clk)) {
 356                 dev_err(&pdev->dev, "failed to get module clock: %ld\n",
 357                         PTR_ERR(dpaux->clk));
 358                 return PTR_ERR(dpaux->clk);
 359         }
 360
 361         err = clk_prepare_enable(dpaux->clk);
 362         if (err < 0) {
 363                 dev_err(&pdev->dev, "failed to enable module clock: %d\n",
 364                         err);
 365                 return err;
 366         }
 367
 368         if (dpaux->rst)
 369                 reset_control_deassert(dpaux->rst);
 370
 371         dpaux->clk_parent = devm_clk_get(&pdev->dev, "parent");
 372         if (IS_ERR(dpaux->clk_parent)) {
 373                 dev_err(&pdev->dev, "failed to get parent clock: %ld\n",
 374                         PTR_ERR(dpaux->clk_parent));
 375                 err = PTR_ERR(dpaux->clk_parent);
 376                 goto assert_reset;
 377         }
 378
 379         err = clk_prepare_enable(dpaux->clk_parent);
 380         if (err < 0) {
 381                 dev_err(&pdev->dev, "failed to enable parent clock: %d\n",
 382                         err);
 383                 goto assert_reset;
 384         }
 385
 386         err = clk_set_rate(dpaux->clk_parent, 270000000);
 387         if (err < 0) {
 388                 dev_err(&pdev->dev, "failed to set clock to 270 MHz: %d\n",
 389                         err);
 390                 goto disable_parent_clk;
 391         }
 392
 393         dpaux->vdd = devm_regulator_get(&pdev->dev, "vdd");
 394         if (IS_ERR(dpaux->vdd)) {
 395                 dev_err(&pdev->dev, "failed to get VDD supply: %ld\n",
 396                         PTR_ERR(dpaux->vdd));
 397                 err = PTR_ERR(dpaux->vdd);
 398                 goto disable_parent_clk;
 399         }
 400
 401         err = devm_request_irq(dpaux->dev, dpaux->irq, tegra_dpaux_irq, 0,
 402                                dev_name(dpaux->dev), dpaux);
 403         if (err < 0) {
 404                 dev_err(dpaux->dev, "failed to request IRQ#%u: %d\n",
 405                         dpaux->irq, err);
 406                 goto disable_parent_clk;
 407         }
 408
 409         disable_irq(dpaux->irq);
 410
 411         dpaux->aux.transfer = tegra_dpaux_transfer;
 412         dpaux->aux.dev = &pdev->dev;
 413
 414         err = drm_dp_aux_register(&dpaux->aux);
 415         if (err < 0)
 416                 goto disable_parent_clk;
 417
 418         /*
 419          * Assume that by default the DPAUX/I2C pads will be used for HDMI,
 420          * so power them up and configure them in I2C mode.
 421          *
 422          * The DPAUX code paths reconfigure the pads in AUX mode, but there
 423          * is no possibility to perform the I2C mode configuration in the
 424          * HDMI path.
 425          */
 426         err = tegra_dpaux_pad_config(dpaux, DPAUX_HYBRID_PADCTL_MODE_I2C);
 427         if (err < 0)
 428                 return err;
 429
 430         /* enable and clear all interrupts */
 431         value = DPAUX_INTR_AUX_DONE | DPAUX_INTR_IRQ_EVENT |
 432                 DPAUX_INTR_UNPLUG_EVENT | DPAUX_INTR_PLUG_EVENT;
 433         tegra_dpaux_writel(dpaux, value, DPAUX_INTR_EN_AUX);
 434         tegra_dpaux_writel(dpaux, value, DPAUX_INTR_AUX);
 435
 436         mutex_lock(&dpaux_lock);
 437         list_add_tail(&dpaux->list, &dpaux_list);
 438         mutex_unlock(&dpaux_lock);
 439
 440         platform_set_drvdata(pdev, dpaux);
 441
 442         return 0;
 443
 444 disable_parent_clk:
 445         clk_disable_unprepare(dpaux->clk_parent);
 446 assert_reset:
 447         if (dpaux->rst)
 448                 reset_control_assert(dpaux->rst);
 449
 450         clk_disable_unprepare(dpaux->clk);
 451
 452         return err;
 453 }
 454
 455 static int tegra_dpaux_remove(struct platform_device *pdev)
 456 {
 457         struct tegra_dpaux *dpaux = platform_get_drvdata(pdev);
 458
 459         /* make sure pads are powered down when not in use */
 460         tegra_dpaux_pad_power_down(dpaux);
 461
 462         drm_dp_aux_unregister(&dpaux->aux);
 463
 464         mutex_lock(&dpaux_lock);
 465         list_del(&dpaux->list);
 466         mutex_unlock(&dpaux_lock);
 467
 468         cancel_work_sync(&dpaux->work);
 469
 470         clk_disable_unprepare(dpaux->clk_parent);
 471
 472         if (dpaux->rst)
 473                 reset_control_assert(dpaux->rst);
 474
 475         clk_disable_unprepare(dpaux->clk);
 476
 477         return 0;
 478 }
 479
 480 static const struct of_device_id tegra_dpaux_of_match[] = {
 481         { .compatible = "nvidia,tegra210-dpaux", },
 482         { .compatible = "nvidia,tegra124-dpaux", },
 483         { },
 484 };
 485 MODULE_DEVICE_TABLE(of, tegra_dpaux_of_match);
 486
 487 struct platform_driver tegra_dpaux_driver = {
 488         .driver = {
 489                 .name = "tegra-dpaux",
 490                 .of_match_table = tegra_dpaux_of_match,
 491         },
 492         .probe = tegra_dpaux_probe,
 493         .remove = tegra_dpaux_remove,
 494 };
 495
 496 struct drm_dp_aux *drm_dp_aux_find_by_of_node(struct device_node *np)
 497 {
 498         struct tegra_dpaux *dpaux;
 499
 500         mutex_lock(&dpaux_lock);
 501
 502         list_for_each_entry(dpaux, &dpaux_list, list)
 503                 if (np == dpaux->dev->of_node) {
 504                         mutex_unlock(&dpaux_lock);
 505                         return &dpaux->aux;
 506                 }
 507
 508         mutex_unlock(&dpaux_lock);
 509
 510         return NULL;
 511 }
 512
 513 int drm_dp_aux_attach(struct drm_dp_aux *aux, struct tegra_output *output)
 514 {
 515         struct tegra_dpaux *dpaux = to_dpaux(aux);
 516         unsigned long timeout;
 517         int err;
 518
 519         output->connector.polled = DRM_CONNECTOR_POLL_HPD;
 520         dpaux->output = output;
 521
 522         err = regulator_enable(dpaux->vdd);
 523         if (err < 0)
 524                 return err;
 525
 526         timeout = jiffies + msecs_to_jiffies(250);
 527
 528         while (time_before(jiffies, timeout)) {
 529                 enum drm_connector_status status;
 530
 531                 status = drm_dp_aux_detect(aux);
 532                 if (status == connector_status_connected) {
 533                         enable_irq(dpaux->irq);
 534                         return 0;
 535                 }
 536
 537                 usleep_range(1000, 2000);
 538         }
 539
 540         return -ETIMEDOUT;
 541 }
 542
 543 int drm_dp_aux_detach(struct drm_dp_aux *aux)
 544 {
 545         struct tegra_dpaux *dpaux = to_dpaux(aux);
 546         unsigned long timeout;
 547         int err;
 548
 549         disable_irq(dpaux->irq);
 550
 551         err = regulator_disable(dpaux->vdd);
 552         if (err < 0)
 553                 return err;
 554
 555         timeout = jiffies + msecs_to_jiffies(250);
 556
 557         while (time_before(jiffies, timeout)) {
 558                 enum drm_connector_status status;
 559
 560                 status = drm_dp_aux_detect(aux);
 561                 if (status == connector_status_disconnected) {
 562                         dpaux->output = NULL;
 563                         return 0;
 564                 }
 565
 566                 usleep_range(1000, 2000);
 567         }
 568
 569         return -ETIMEDOUT;
 570 }
 571
 572 enum drm_connector_status drm_dp_aux_detect(struct drm_dp_aux *aux)
 573 {
 574         struct tegra_dpaux *dpaux = to_dpaux(aux);
 575         u32 value;
 576
 577         value = tegra_dpaux_readl(dpaux, DPAUX_DP_AUXSTAT);
 578
 579         if (value & DPAUX_DP_AUXSTAT_HPD_STATUS)
 580                 return connector_status_connected;
 581
 582         return connector_status_disconnected;
 583 }
 584
 585 int drm_dp_aux_enable(struct drm_dp_aux *aux)
 586 {
 587         struct tegra_dpaux *dpaux = to_dpaux(aux);
 588
 589         return tegra_dpaux_pad_config(dpaux, DPAUX_HYBRID_PADCTL_MODE_AUX);
 590 }
 591
 592 int drm_dp_aux_disable(struct drm_dp_aux *aux)
 593 {
 594         struct tegra_dpaux *dpaux = to_dpaux(aux);
 595
 596         tegra_dpaux_pad_power_down(dpaux);
 597
 598         return 0;
 599 }
 600
 601 int drm_dp_aux_prepare(struct drm_dp_aux *aux, u8 encoding)
 602 {
 603         int err;
 604
 605         err = drm_dp_dpcd_writeb(aux, DP_MAIN_LINK_CHANNEL_CODING_SET,
 606                                  encoding);
 607         if (err < 0)
 608                 return err;
 609
 610         return 0;
 611 }
 612
 613 int drm_dp_aux_train(struct drm_dp_aux *aux, struct drm_dp_link *link,
 614                      u8 pattern)
 615 {
 616         u8 tp = pattern & DP_TRAINING_PATTERN_MASK;
 617         u8 status[DP_LINK_STATUS_SIZE], values[4];
 618         unsigned int i;
 619         int err;
 620
 621         err = drm_dp_dpcd_writeb(aux, DP_TRAINING_PATTERN_SET, pattern);
 622         if (err < 0)
 623                 return err;
 624
 625         if (tp == DP_TRAINING_PATTERN_DISABLE)
 626                 return 0;
 627
 628         for (i = 0; i < link->num_lanes; i++)
 629                 values[i] = DP_TRAIN_MAX_PRE_EMPHASIS_REACHED |
 630                             DP_TRAIN_PRE_EMPH_LEVEL_0 |
 631                             DP_TRAIN_MAX_SWING_REACHED |
 632                             DP_TRAIN_VOLTAGE_SWING_LEVEL_0;
 633
 634         err = drm_dp_dpcd_write(aux, DP_TRAINING_LANE0_SET, values,
 635                                 link->num_lanes);
 636         if (err < 0)
 637                 return err;
 638
 639         usleep_range(500, 1000);
 640
 641         err = drm_dp_dpcd_read_link_status(aux, status);
 642         if (err < 0)
 643                 return err;
 644
 645         switch (tp) {
 646         case DP_TRAINING_PATTERN_1:
 647                 if (!drm_dp_clock_recovery_ok(status, link->num_lanes))
 648                         return -EAGAIN;
 649
 650                 break;
 651
 652         case DP_TRAINING_PATTERN_2:
 653                 if (!drm_dp_channel_eq_ok(status, link->num_lanes))
 654                         return -EAGAIN;
 655
 656                 break;
 657
 658         default:
 659                 dev_err(aux->dev, "unsupported training pattern %u\n", tp);
 660                 return -EINVAL;
 661         }
 662
 663         err = drm_dp_dpcd_writeb(aux, DP_EDP_CONFIGURATION_SET, 0);
 664         if (err < 0)
 665                 return err;
 666
 667         return 0;
 668 }