drivers/gpu/drm/bridge/cadence/cdns-mhdp8546-core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Cadence MHDP8546 DP bridge driver.
   4  *
   5  * Copyright (C) 2020 Cadence Design Systems, Inc.
   6  *
   7  * Authors: Quentin Schulz <quentin.schulz@free-electrons.com>
   8  *          Swapnil Jakhade <sjakhade@cadence.com>
   9  *          Yuti Amonkar <yamonkar@cadence.com>
  10  *          Tomi Valkeinen <tomi.valkeinen@ti.com>
  11  *          Jyri Sarha <jsarha@ti.com>
  12  *
  13  * TODO:
  14  *     - Implement optimized mailbox communication using mailbox interrupts
  15  *     - Add support for power management
  16  *     - Add support for features like audio, MST and fast link training
  17  *     - Implement request_fw_cancel to handle HW_STATE
  18  *     - Fix asynchronous loading of firmware implementation
  19  *     - Add DRM helper function for cdns_mhdp_lower_link_rate
  20  */
  21
  22 #include <linux/clk.h>
  23 #include <linux/delay.h>
  24 #include <linux/err.h>
  25 #include <linux/firmware.h>
  26 #include <linux/io.h>
  27 #include <linux/iopoll.h>
  28 #include <linux/irq.h>
  29 #include <linux/module.h>
  30 #include <linux/of.h>
  31 #include <linux/of_device.h>
  32 #include <linux/phy/phy.h>
  33 #include <linux/phy/phy-dp.h>
  34 #include <linux/platform_device.h>
  35 #include <linux/slab.h>
  36 #include <linux/wait.h>
  37
  38 #include <drm/drm_atomic.h>
  39 #include <drm/drm_atomic_helper.h>
  40 #include <drm/drm_atomic_state_helper.h>
  41 #include <drm/drm_bridge.h>
  42 #include <drm/drm_connector.h>
  43 #include <drm/drm_crtc_helper.h>
  44 #include <drm/drm_dp_helper.h>
  45 #include <drm/drm_hdcp.h>
  46 #include <drm/drm_modeset_helper_vtables.h>
  47 #include <drm/drm_print.h>
  48 #include <drm/drm_probe_helper.h>
  49
  50 #include <asm/unaligned.h>
  51
  52 #include "cdns-mhdp8546-core.h"
  53 #include "cdns-mhdp8546-hdcp.h"
  54 #include "cdns-mhdp8546-j721e.h"
  55
  56 static int cdns_mhdp_mailbox_read(struct cdns_mhdp_device *mhdp)
  57 {
  58         int ret, empty;
  59
  60         WARN_ON(!mutex_is_locked(&mhdp->mbox_mutex));
  61
  62         ret = readx_poll_timeout(readl, mhdp->regs + CDNS_MAILBOX_EMPTY,
  63                                  empty, !empty, MAILBOX_RETRY_US,
  64                                  MAILBOX_TIMEOUT_US);
  65         if (ret < 0)
  66                 return ret;
  67
  68         return readl(mhdp->regs + CDNS_MAILBOX_RX_DATA) & 0xff;
  69 }
  70
  71 static int cdns_mhdp_mailbox_write(struct cdns_mhdp_device *mhdp, u8 val)
  72 {
  73         int ret, full;
  74
  75         WARN_ON(!mutex_is_locked(&mhdp->mbox_mutex));
  76
  77         ret = readx_poll_timeout(readl, mhdp->regs + CDNS_MAILBOX_FULL,
  78                                  full, !full, MAILBOX_RETRY_US,
  79                                  MAILBOX_TIMEOUT_US);
  80         if (ret < 0)
  81                 return ret;
  82
  83         writel(val, mhdp->regs + CDNS_MAILBOX_TX_DATA);
  84
  85         return 0;
  86 }
  87
  88 static int cdns_mhdp_mailbox_recv_header(struct cdns_mhdp_device *mhdp,
  89                                          u8 module_id, u8 opcode,
  90                                          u16 req_size)
  91 {
  92         u32 mbox_size, i;
  93         u8 header[4];
  94         int ret;
  95
  96         /* read the header of the message */
  97         for (i = 0; i < sizeof(header); i++) {
  98                 ret = cdns_mhdp_mailbox_read(mhdp);
  99                 if (ret < 0)
 100                         return ret;
 101
 102                 header[i] = ret;
 103         }
 104
 105         mbox_size = get_unaligned_be16(header + 2);
 106
 107         if (opcode != header[0] || module_id != header[1] ||
 108             req_size != mbox_size) {
 109                 /*
 110                  * If the message in mailbox is not what we want, we need to
 111                  * clear the mailbox by reading its contents.
 112                  */
 113                 for (i = 0; i < mbox_size; i++)
 114                         if (cdns_mhdp_mailbox_read(mhdp) < 0)
 115                                 break;
 116
 117                 return -EINVAL;
 118         }
 119
 120         return 0;
 121 }
 122
 123 static int cdns_mhdp_mailbox_recv_data(struct cdns_mhdp_device *mhdp,
 124                                        u8 *buff, u16 buff_size)
 125 {
 126         u32 i;
 127         int ret;
 128
 129         for (i = 0; i < buff_size; i++) {
 130                 ret = cdns_mhdp_mailbox_read(mhdp);
 131                 if (ret < 0)
 132                         return ret;
 133
 134                 buff[i] = ret;
 135         }
 136
 137         return 0;
 138 }
 139
 140 static int cdns_mhdp_mailbox_send(struct cdns_mhdp_device *mhdp, u8 module_id,
 141                                   u8 opcode, u16 size, u8 *message)
 142 {
 143         u8 header[4];
 144         int ret, i;
 145
 146         header[0] = opcode;
 147         header[1] = module_id;
 148         put_unaligned_be16(size, header + 2);
 149
 150         for (i = 0; i < sizeof(header); i++) {
 151                 ret = cdns_mhdp_mailbox_write(mhdp, header[i]);
 152                 if (ret)
 153                         return ret;
 154         }
 155
 156         for (i = 0; i < size; i++) {
 157                 ret = cdns_mhdp_mailbox_write(mhdp, message[i]);
 158                 if (ret)
 159                         return ret;
 160         }
 161
 162         return 0;
 163 }
 164
 165 static
 166 int cdns_mhdp_reg_read(struct cdns_mhdp_device *mhdp, u32 addr, u32 *value)
 167 {
 168         u8 msg[4], resp[8];
 169         int ret;
 170
 171         put_unaligned_be32(addr, msg);
 172
 173         mutex_lock(&mhdp->mbox_mutex);
 174
 175         ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_GENERAL,
 176                                      GENERAL_REGISTER_READ,
 177                                      sizeof(msg), msg);
 178         if (ret)
 179                 goto out;
 180
 181         ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_GENERAL,
 182                                             GENERAL_REGISTER_READ,
 183                                             sizeof(resp));
 184         if (ret)
 185                 goto out;
 186
 187         ret = cdns_mhdp_mailbox_recv_data(mhdp, resp, sizeof(resp));
 188         if (ret)
 189                 goto out;
 190
 191         /* Returned address value should be the same as requested */
 192         if (memcmp(msg, resp, sizeof(msg))) {
 193                 ret = -EINVAL;
 194                 goto out;
 195         }
 196
 197         *value = get_unaligned_be32(resp + 4);
 198
 199 out:
 200         mutex_unlock(&mhdp->mbox_mutex);
 201         if (ret) {
 202                 dev_err(mhdp->dev, "Failed to read register\n");
 203                 *value = 0;
 204         }
 205
 206         return ret;
 207 }
 208
 209 static
 210 int cdns_mhdp_reg_write(struct cdns_mhdp_device *mhdp, u16 addr, u32 val)
 211 {
 212         u8 msg[6];
 213         int ret;
 214
 215         put_unaligned_be16(addr, msg);
 216         put_unaligned_be32(val, msg + 2);
 217
 218         mutex_lock(&mhdp->mbox_mutex);
 219
 220         ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
 221                                      DPTX_WRITE_REGISTER, sizeof(msg), msg);
 222
 223         mutex_unlock(&mhdp->mbox_mutex);
 224
 225         return ret;
 226 }
 227
 228 static
 229 int cdns_mhdp_reg_write_bit(struct cdns_mhdp_device *mhdp, u16 addr,
 230                             u8 start_bit, u8 bits_no, u32 val)
 231 {
 232         u8 field[8];
 233         int ret;
 234
 235         put_unaligned_be16(addr, field);
 236         field[2] = start_bit;
 237         field[3] = bits_no;
 238         put_unaligned_be32(val, field + 4);
 239
 240         mutex_lock(&mhdp->mbox_mutex);
 241
 242         ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
 243                                      DPTX_WRITE_FIELD, sizeof(field), field);
 244
 245         mutex_unlock(&mhdp->mbox_mutex);
 246
 247         return ret;
 248 }
 249
 250 static
 251 int cdns_mhdp_dpcd_read(struct cdns_mhdp_device *mhdp,
 252                         u32 addr, u8 *data, u16 len)
 253 {
 254         u8 msg[5], reg[5];
 255         int ret;
 256
 257         put_unaligned_be16(len, msg);
 258         put_unaligned_be24(addr, msg + 2);
 259
 260         mutex_lock(&mhdp->mbox_mutex);
 261
 262         ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
 263                                      DPTX_READ_DPCD, sizeof(msg), msg);
 264         if (ret)
 265                 goto out;
 266
 267         ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
 268                                             DPTX_READ_DPCD,
 269                                             sizeof(reg) + len);
 270         if (ret)
 271                 goto out;
 272
 273         ret = cdns_mhdp_mailbox_recv_data(mhdp, reg, sizeof(reg));
 274         if (ret)
 275                 goto out;
 276
 277         ret = cdns_mhdp_mailbox_recv_data(mhdp, data, len);
 278
 279 out:
 280         mutex_unlock(&mhdp->mbox_mutex);
 281
 282         return ret;
 283 }
 284
 285 static
 286 int cdns_mhdp_dpcd_write(struct cdns_mhdp_device *mhdp, u32 addr, u8 value)
 287 {
 288         u8 msg[6], reg[5];
 289         int ret;
 290
 291         put_unaligned_be16(1, msg);
 292         put_unaligned_be24(addr, msg + 2);
 293         msg[5] = value;
 294
 295         mutex_lock(&mhdp->mbox_mutex);
 296
 297         ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
 298                                      DPTX_WRITE_DPCD, sizeof(msg), msg);
 299         if (ret)
 300                 goto out;
 301
 302         ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
 303                                             DPTX_WRITE_DPCD, sizeof(reg));
 304         if (ret)
 305                 goto out;
 306
 307         ret = cdns_mhdp_mailbox_recv_data(mhdp, reg, sizeof(reg));
 308         if (ret)
 309                 goto out;
 310
 311         if (addr != get_unaligned_be24(reg + 2))
 312                 ret = -EINVAL;
 313
 314 out:
 315         mutex_unlock(&mhdp->mbox_mutex);
 316
 317         if (ret)
 318                 dev_err(mhdp->dev, "dpcd write failed: %d\n", ret);
 319         return ret;
 320 }
 321
 322 static
 323 int cdns_mhdp_set_firmware_active(struct cdns_mhdp_device *mhdp, bool enable)
 324 {
 325         u8 msg[5];
 326         int ret, i;
 327
 328         msg[0] = GENERAL_MAIN_CONTROL;
 329         msg[1] = MB_MODULE_ID_GENERAL;
 330         msg[2] = 0;
 331         msg[3] = 1;
 332         msg[4] = enable ? FW_ACTIVE : FW_STANDBY;
 333
 334         mutex_lock(&mhdp->mbox_mutex);
 335
 336         for (i = 0; i < sizeof(msg); i++) {
 337                 ret = cdns_mhdp_mailbox_write(mhdp, msg[i]);
 338                 if (ret)
 339                         goto out;
 340         }
 341
 342         /* read the firmware state */
 343         ret = cdns_mhdp_mailbox_recv_data(mhdp, msg, sizeof(msg));
 344         if (ret)
 345                 goto out;
 346
 347         ret = 0;
 348
 349 out:
 350         mutex_unlock(&mhdp->mbox_mutex);
 351
 352         if (ret < 0)
 353                 dev_err(mhdp->dev, "set firmware active failed\n");
 354         return ret;
 355 }
 356
 357 static
 358 int cdns_mhdp_get_hpd_status(struct cdns_mhdp_device *mhdp)
 359 {
 360         u8 status;
 361         int ret;
 362
 363         mutex_lock(&mhdp->mbox_mutex);
 364
 365         ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
 366                                      DPTX_HPD_STATE, 0, NULL);
 367         if (ret)
 368                 goto err_get_hpd;
 369
 370         ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
 371                                             DPTX_HPD_STATE,
 372                                             sizeof(status));
 373         if (ret)
 374                 goto err_get_hpd;
 375
 376         ret = cdns_mhdp_mailbox_recv_data(mhdp, &status, sizeof(status));
 377         if (ret)
 378                 goto err_get_hpd;
 379
 380         mutex_unlock(&mhdp->mbox_mutex);
 381
 382         dev_dbg(mhdp->dev, "%s: HPD %splugged\n", __func__,
 383                 status ? "" : "un");
 384
 385         return status;
 386
 387 err_get_hpd:
 388         mutex_unlock(&mhdp->mbox_mutex);
 389
 390         return ret;
 391 }
 392
 393 static
 394 int cdns_mhdp_get_edid_block(void *data, u8 *edid,
 395                              unsigned int block, size_t length)
 396 {
 397         struct cdns_mhdp_device *mhdp = data;
 398         u8 msg[2], reg[2], i;
 399         int ret;
 400
 401         mutex_lock(&mhdp->mbox_mutex);
 402
 403         for (i = 0; i < 4; i++) {
 404                 msg[0] = block / 2;
 405                 msg[1] = block % 2;
 406
 407                 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
 408                                              DPTX_GET_EDID, sizeof(msg), msg);
 409                 if (ret)
 410                         continue;
 411
 412                 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
 413                                                     DPTX_GET_EDID,
 414                                                     sizeof(reg) + length);
 415                 if (ret)
 416                         continue;
 417
 418                 ret = cdns_mhdp_mailbox_recv_data(mhdp, reg, sizeof(reg));
 419                 if (ret)
 420                         continue;
 421
 422                 ret = cdns_mhdp_mailbox_recv_data(mhdp, edid, length);
 423                 if (ret)
 424                         continue;
 425
 426                 if (reg[0] == length && reg[1] == block / 2)
 427                         break;
 428         }
 429
 430         mutex_unlock(&mhdp->mbox_mutex);
 431
 432         if (ret)
 433                 dev_err(mhdp->dev, "get block[%d] edid failed: %d\n",
 434                         block, ret);
 435
 436         return ret;
 437 }
 438
 439 static
 440 int cdns_mhdp_read_hpd_event(struct cdns_mhdp_device *mhdp)
 441 {
 442         u8 event = 0;
 443         int ret;
 444
 445         mutex_lock(&mhdp->mbox_mutex);
 446
 447         ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
 448                                      DPTX_READ_EVENT, 0, NULL);
 449         if (ret)
 450                 goto out;
 451
 452         ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
 453                                             DPTX_READ_EVENT, sizeof(event));
 454         if (ret < 0)
 455                 goto out;
 456
 457         ret = cdns_mhdp_mailbox_recv_data(mhdp, &event, sizeof(event));
 458 out:
 459         mutex_unlock(&mhdp->mbox_mutex);
 460
 461         if (ret < 0)
 462                 return ret;
 463
 464         dev_dbg(mhdp->dev, "%s: %s%s%s%s\n", __func__,
 465                 (event & DPTX_READ_EVENT_HPD_TO_HIGH) ? "TO_HIGH " : "",
 466                 (event & DPTX_READ_EVENT_HPD_TO_LOW) ? "TO_LOW " : "",
 467                 (event & DPTX_READ_EVENT_HPD_PULSE) ? "PULSE " : "",
 468                 (event & DPTX_READ_EVENT_HPD_STATE) ? "HPD_STATE " : "");
 469
 470         return event;
 471 }
 472
 473 static
 474 int cdns_mhdp_adjust_lt(struct cdns_mhdp_device *mhdp, unsigned int nlanes,
 475                         unsigned int udelay, const u8 *lanes_data,
 476                         u8 link_status[DP_LINK_STATUS_SIZE])
 477 {
 478         u8 payload[7];
 479         u8 hdr[5]; /* For DPCD read response header */
 480         u32 addr;
 481         int ret;
 482
 483         if (nlanes != 4 && nlanes != 2 && nlanes != 1) {
 484                 dev_err(mhdp->dev, "invalid number of lanes: %u\n", nlanes);
 485                 ret = -EINVAL;
 486                 goto out;
 487         }
 488
 489         payload[0] = nlanes;
 490         put_unaligned_be16(udelay, payload + 1);
 491         memcpy(payload + 3, lanes_data, nlanes);
 492
 493         mutex_lock(&mhdp->mbox_mutex);
 494
 495         ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
 496                                      DPTX_ADJUST_LT,
 497                                      sizeof(payload), payload);
 498         if (ret)
 499                 goto out;
 500
 501         /* Yes, read the DPCD read command response */
 502         ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
 503                                             DPTX_READ_DPCD,
 504                                             sizeof(hdr) + DP_LINK_STATUS_SIZE);
 505         if (ret)
 506                 goto out;
 507
 508         ret = cdns_mhdp_mailbox_recv_data(mhdp, hdr, sizeof(hdr));
 509         if (ret)
 510                 goto out;
 511
 512         addr = get_unaligned_be24(hdr + 2);
 513         if (addr != DP_LANE0_1_STATUS)
 514                 goto out;
 515
 516         ret = cdns_mhdp_mailbox_recv_data(mhdp, link_status,
 517                                           DP_LINK_STATUS_SIZE);
 518
 519 out:
 520         mutex_unlock(&mhdp->mbox_mutex);
 521
 522         if (ret)
 523                 dev_err(mhdp->dev, "Failed to adjust Link Training.\n");
 524
 525         return ret;
 526 }
 527
 528 /**
 529  * cdns_mhdp_link_power_up() - power up a DisplayPort link
 530  * @aux: DisplayPort AUX channel
 531  * @link: pointer to a structure containing the link configuration
 532  *
 533  * Returns 0 on success or a negative error code on failure.
 534  */
 535 static
 536 int cdns_mhdp_link_power_up(struct drm_dp_aux *aux, struct cdns_mhdp_link *link)
 537 {
 538         u8 value;
 539         int err;
 540
 541         /* DP_SET_POWER register is only available on DPCD v1.1 and later */
 542         if (link->revision < 0x11)
 543                 return 0;
 544
 545         err = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value);
 546         if (err < 0)
 547                 return err;
 548
 549         value &= ~DP_SET_POWER_MASK;
 550         value |= DP_SET_POWER_D0;
 551
 552         err = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value);
 553         if (err < 0)
 554                 return err;
 555
 556         /*
 557          * According to the DP 1.1 specification, a "Sink Device must exit the
 558          * power saving state within 1 ms" (Section 2.5.3.1, Table 5-52, "Sink
 559          * Control Field" (register 0x600).
 560          */
 561         usleep_range(1000, 2000);
 562
 563         return 0;
 564 }
 565
 566 /**
 567  * cdns_mhdp_link_power_down() - power down a DisplayPort link
 568  * @aux: DisplayPort AUX channel
 569  * @link: pointer to a structure containing the link configuration
 570  *
 571  * Returns 0 on success or a negative error code on failure.
 572  */
 573 static
 574 int cdns_mhdp_link_power_down(struct drm_dp_aux *aux,
 575                               struct cdns_mhdp_link *link)
 576 {
 577         u8 value;
 578         int err;
 579
 580         /* DP_SET_POWER register is only available on DPCD v1.1 and later */
 581         if (link->revision < 0x11)
 582                 return 0;
 583
 584         err = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value);
 585         if (err < 0)
 586                 return err;
 587
 588         value &= ~DP_SET_POWER_MASK;
 589         value |= DP_SET_POWER_D3;
 590
 591         err = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value);
 592         if (err < 0)
 593                 return err;
 594
 595         return 0;
 596 }
 597
 598 /**
 599  * cdns_mhdp_link_configure() - configure a DisplayPort link
 600  * @aux: DisplayPort AUX channel
 601  * @link: pointer to a structure containing the link configuration
 602  *
 603  * Returns 0 on success or a negative error code on failure.
 604  */
 605 static
 606 int cdns_mhdp_link_configure(struct drm_dp_aux *aux,
 607                              struct cdns_mhdp_link *link)
 608 {
 609         u8 values[2];
 610         int err;
 611
 612         values[0] = drm_dp_link_rate_to_bw_code(link->rate);
 613         values[1] = link->num_lanes;
 614
 615         if (link->capabilities & DP_LINK_CAP_ENHANCED_FRAMING)
 616                 values[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
 617
 618         err = drm_dp_dpcd_write(aux, DP_LINK_BW_SET, values, sizeof(values));
 619         if (err < 0)
 620                 return err;
 621
 622         return 0;
 623 }
 624
 625 static unsigned int cdns_mhdp_max_link_rate(struct cdns_mhdp_device *mhdp)
 626 {
 627         return min(mhdp->host.link_rate, mhdp->sink.link_rate);
 628 }
 629
 630 static u8 cdns_mhdp_max_num_lanes(struct cdns_mhdp_device *mhdp)
 631 {
 632         return min(mhdp->sink.lanes_cnt, mhdp->host.lanes_cnt);
 633 }
 634
 635 static u8 cdns_mhdp_eq_training_pattern_supported(struct cdns_mhdp_device *mhdp)
 636 {
 637         return fls(mhdp->host.pattern_supp & mhdp->sink.pattern_supp);
 638 }
 639
 640 static bool cdns_mhdp_get_ssc_supported(struct cdns_mhdp_device *mhdp)
 641 {
 642         /* Check if SSC is supported by both sides */
 643         return mhdp->host.ssc && mhdp->sink.ssc;
 644 }
 645
 646 static enum drm_connector_status cdns_mhdp_detect(struct cdns_mhdp_device *mhdp)
 647 {
 648         dev_dbg(mhdp->dev, "%s: %d\n", __func__, mhdp->plugged);
 649
 650         if (mhdp->plugged)
 651                 return connector_status_connected;
 652         else
 653                 return connector_status_disconnected;
 654 }
 655
 656 static int cdns_mhdp_check_fw_version(struct cdns_mhdp_device *mhdp)
 657 {
 658         u32 major_num, minor_num, revision;
 659         u32 fw_ver, lib_ver;
 660
 661         fw_ver = (readl(mhdp->regs + CDNS_VER_H) << 8)
 662                | readl(mhdp->regs + CDNS_VER_L);
 663
 664         lib_ver = (readl(mhdp->regs + CDNS_LIB_H_ADDR) << 8)
 665                 | readl(mhdp->regs + CDNS_LIB_L_ADDR);
 666
 667         if (lib_ver < 33984) {
 668                 /*
 669                  * Older FW versions with major number 1, used to store FW
 670                  * version information by storing repository revision number
 671                  * in registers. This is for identifying these FW versions.
 672                  */
 673                 major_num = 1;
 674                 minor_num = 2;
 675                 if (fw_ver == 26098) {
 676                         revision = 15;
 677                 } else if (lib_ver == 0 && fw_ver == 0) {
 678                         revision = 17;
 679                 } else {
 680                         dev_err(mhdp->dev, "Unsupported FW version: fw_ver = %u, lib_ver = %u\n",
 681                                 fw_ver, lib_ver);
 682                         return -ENODEV;
 683                 }
 684         } else {
 685                 /* To identify newer FW versions with major number 2 onwards. */
 686                 major_num = fw_ver / 10000;
 687                 minor_num = (fw_ver / 100) % 100;
 688                 revision = (fw_ver % 10000) % 100;
 689         }
 690
 691         dev_dbg(mhdp->dev, "FW version: v%u.%u.%u\n", major_num, minor_num,
 692                 revision);
 693         return 0;
 694 }
 695
 696 static int cdns_mhdp_fw_activate(const struct firmware *fw,
 697                                  struct cdns_mhdp_device *mhdp)
 698 {
 699         unsigned int reg;
 700         int ret;
 701
 702         /* Release uCPU reset and stall it. */
 703         writel(CDNS_CPU_STALL, mhdp->regs + CDNS_APB_CTRL);
 704
 705         memcpy_toio(mhdp->regs + CDNS_MHDP_IMEM, fw->data, fw->size);
 706
 707         /* Leave debug mode, release stall */
 708         writel(0, mhdp->regs + CDNS_APB_CTRL);
 709
 710         /*
 711          * Wait for the KEEP_ALIVE "message" on the first 8 bits.
 712          * Updated each sched "tick" (~2ms)
 713          */
 714         ret = readl_poll_timeout(mhdp->regs + CDNS_KEEP_ALIVE, reg,
 715                                  reg & CDNS_KEEP_ALIVE_MASK, 500,
 716                                  CDNS_KEEP_ALIVE_TIMEOUT);
 717         if (ret) {
 718                 dev_err(mhdp->dev,
 719                         "device didn't give any life sign: reg %d\n", reg);
 720                 return ret;
 721         }
 722
 723         ret = cdns_mhdp_check_fw_version(mhdp);
 724         if (ret)
 725                 return ret;
 726
 727         /* Init events to 0 as it's not cleared by FW at boot but on read */
 728         readl(mhdp->regs + CDNS_SW_EVENT0);
 729         readl(mhdp->regs + CDNS_SW_EVENT1);
 730         readl(mhdp->regs + CDNS_SW_EVENT2);
 731         readl(mhdp->regs + CDNS_SW_EVENT3);
 732
 733         /* Activate uCPU */
 734         ret = cdns_mhdp_set_firmware_active(mhdp, true);
 735         if (ret)
 736                 return ret;
 737
 738         spin_lock(&mhdp->start_lock);
 739
 740         mhdp->hw_state = MHDP_HW_READY;
 741
 742         /*
 743          * Here we must keep the lock while enabling the interrupts
 744          * since it would otherwise be possible that interrupt enable
 745          * code is executed after the bridge is detached. The similar
 746          * situation is not possible in attach()/detach() callbacks
 747          * since the hw_state changes from MHDP_HW_READY to
 748          * MHDP_HW_STOPPED happens only due to driver removal when
 749          * bridge should already be detached.
 750          */
 751         if (mhdp->bridge_attached)
 752                 writel(~(u32)CDNS_APB_INT_MASK_SW_EVENT_INT,
 753                        mhdp->regs + CDNS_APB_INT_MASK);
 754
 755         spin_unlock(&mhdp->start_lock);
 756
 757         wake_up(&mhdp->fw_load_wq);
 758         dev_dbg(mhdp->dev, "DP FW activated\n");
 759
 760         return 0;
 761 }
 762
 763 static void cdns_mhdp_fw_cb(const struct firmware *fw, void *context)
 764 {
 765         struct cdns_mhdp_device *mhdp = context;
 766         bool bridge_attached;
 767         int ret;
 768
 769         dev_dbg(mhdp->dev, "firmware callback\n");
 770
 771         if (!fw || !fw->data) {
 772                 dev_err(mhdp->dev, "%s: No firmware.\n", __func__);
 773                 return;
 774         }
 775
 776         ret = cdns_mhdp_fw_activate(fw, mhdp);
 777
 778         release_firmware(fw);
 779
 780         if (ret)
 781                 return;
 782
 783         /*
 784          *  XXX how to make sure the bridge is still attached when
 785          *      calling drm_kms_helper_hotplug_event() after releasing
 786          *      the lock? We should not hold the spin lock when
 787          *      calling drm_kms_helper_hotplug_event() since it may
 788          *      cause a dead lock. FB-dev console calls detect from the
 789          *      same thread just down the call stack started here.
 790          */
 791         spin_lock(&mhdp->start_lock);
 792         bridge_attached = mhdp->bridge_attached;
 793         spin_unlock(&mhdp->start_lock);
 794         if (bridge_attached) {
 795                 if (mhdp->connector.dev)
 796                         drm_kms_helper_hotplug_event(mhdp->bridge.dev);
 797                 else
 798                         drm_bridge_hpd_notify(&mhdp->bridge, cdns_mhdp_detect(mhdp));
 799         }
 800 }
 801
 802 static int cdns_mhdp_load_firmware(struct cdns_mhdp_device *mhdp)
 803 {
 804         int ret;
 805
 806         ret = request_firmware_nowait(THIS_MODULE, true, FW_NAME, mhdp->dev,
 807                                       GFP_KERNEL, mhdp, cdns_mhdp_fw_cb);
 808         if (ret) {
 809                 dev_err(mhdp->dev, "failed to load firmware (%s), ret: %d\n",
 810                         FW_NAME, ret);
 811                 return ret;
 812         }
 813
 814         return 0;
 815 }
 816
 817 static ssize_t cdns_mhdp_transfer(struct drm_dp_aux *aux,
 818                                   struct drm_dp_aux_msg *msg)
 819 {
 820         struct cdns_mhdp_device *mhdp = dev_get_drvdata(aux->dev);
 821         int ret;
 822
 823         if (msg->request != DP_AUX_NATIVE_WRITE &&
 824             msg->request != DP_AUX_NATIVE_READ)
 825                 return -EOPNOTSUPP;
 826
 827         if (msg->request == DP_AUX_NATIVE_WRITE) {
 828                 const u8 *buf = msg->buffer;
 829                 unsigned int i;
 830
 831                 for (i = 0; i < msg->size; ++i) {
 832                         ret = cdns_mhdp_dpcd_write(mhdp,
 833                                                    msg->address + i, buf[i]);
 834                         if (!ret)
 835                                 continue;
 836
 837                         dev_err(mhdp->dev,
 838                                 "Failed to write DPCD addr %u\n",
 839                                 msg->address + i);
 840
 841                         return ret;
 842                 }
 843         } else {
 844                 ret = cdns_mhdp_dpcd_read(mhdp, msg->address,
 845                                           msg->buffer, msg->size);
 846                 if (ret) {
 847                         dev_err(mhdp->dev,
 848                                 "Failed to read DPCD addr %u\n",
 849                                 msg->address);
 850
 851                         return ret;
 852                 }
 853         }
 854
 855         return msg->size;
 856 }
 857
 858 static int cdns_mhdp_link_training_init(struct cdns_mhdp_device *mhdp)
 859 {
 860         union phy_configure_opts phy_cfg;
 861         u32 reg32;
 862         int ret;
 863
 864         drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
 865                            DP_TRAINING_PATTERN_DISABLE);
 866
 867         /* Reset PHY configuration */
 868         reg32 = CDNS_PHY_COMMON_CONFIG | CDNS_PHY_TRAINING_TYPE(1);
 869         if (!mhdp->host.scrambler)
 870                 reg32 |= CDNS_PHY_SCRAMBLER_BYPASS;
 871
 872         cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
 873
 874         cdns_mhdp_reg_write(mhdp, CDNS_DP_ENHNCD,
 875                             mhdp->sink.enhanced & mhdp->host.enhanced);
 876
 877         cdns_mhdp_reg_write(mhdp, CDNS_DP_LANE_EN,
 878                             CDNS_DP_LANE_EN_LANES(mhdp->link.num_lanes));
 879
 880         cdns_mhdp_link_configure(&mhdp->aux, &mhdp->link);
 881         phy_cfg.dp.link_rate = mhdp->link.rate / 100;
 882         phy_cfg.dp.lanes = mhdp->link.num_lanes;
 883
 884         memset(phy_cfg.dp.voltage, 0, sizeof(phy_cfg.dp.voltage));
 885         memset(phy_cfg.dp.pre, 0, sizeof(phy_cfg.dp.pre));
 886
 887         phy_cfg.dp.ssc = cdns_mhdp_get_ssc_supported(mhdp);
 888         phy_cfg.dp.set_lanes = true;
 889         phy_cfg.dp.set_rate = true;
 890         phy_cfg.dp.set_voltages = true;
 891         ret = phy_configure(mhdp->phy,  &phy_cfg);
 892         if (ret) {
 893                 dev_err(mhdp->dev, "%s: phy_configure() failed: %d\n",
 894                         __func__, ret);
 895                 return ret;
 896         }
 897
 898         cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG,
 899                             CDNS_PHY_COMMON_CONFIG |
 900                             CDNS_PHY_TRAINING_EN |
 901                             CDNS_PHY_TRAINING_TYPE(1) |
 902                             CDNS_PHY_SCRAMBLER_BYPASS);
 903
 904         drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
 905                            DP_TRAINING_PATTERN_1 | DP_LINK_SCRAMBLING_DISABLE);
 906
 907         return 0;
 908 }
 909
 910 static void cdns_mhdp_get_adjust_train(struct cdns_mhdp_device *mhdp,
 911                                        u8 link_status[DP_LINK_STATUS_SIZE],
 912                                        u8 lanes_data[CDNS_DP_MAX_NUM_LANES],
 913                                        union phy_configure_opts *phy_cfg)
 914 {
 915         u8 adjust, max_pre_emph, max_volt_swing;
 916         u8 set_volt, set_pre;
 917         unsigned int i;
 918
 919         max_pre_emph = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis)
 920                            << DP_TRAIN_PRE_EMPHASIS_SHIFT;
 921         max_volt_swing = CDNS_VOLT_SWING(mhdp->host.volt_swing);
 922
 923         for (i = 0; i < mhdp->link.num_lanes; i++) {
 924                 /* Check if Voltage swing and pre-emphasis are within limits */
 925                 adjust = drm_dp_get_adjust_request_voltage(link_status, i);
 926                 set_volt = min(adjust, max_volt_swing);
 927
 928                 adjust = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
 929                 set_pre = min(adjust, max_pre_emph)
 930                           >> DP_TRAIN_PRE_EMPHASIS_SHIFT;
 931
 932                 /*
 933                  * Voltage swing level and pre-emphasis level combination is
 934                  * not allowed: leaving pre-emphasis as-is, and adjusting
 935                  * voltage swing.
 936                  */
 937                 if (set_volt + set_pre > 3)
 938                         set_volt = 3 - set_pre;
 939
 940                 phy_cfg->dp.voltage[i] = set_volt;
 941                 lanes_data[i] = set_volt;
 942
 943                 if (set_volt == max_volt_swing)
 944                         lanes_data[i] |= DP_TRAIN_MAX_SWING_REACHED;
 945
 946                 phy_cfg->dp.pre[i] = set_pre;
 947                 lanes_data[i] |= (set_pre << DP_TRAIN_PRE_EMPHASIS_SHIFT);
 948
 949                 if (set_pre == (max_pre_emph >> DP_TRAIN_PRE_EMPHASIS_SHIFT))
 950                         lanes_data[i] |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
 951         }
 952 }
 953
 954 static
 955 void cdns_mhdp_set_adjust_request_voltage(u8 link_status[DP_LINK_STATUS_SIZE],
 956                                           unsigned int lane, u8 volt)
 957 {
 958         unsigned int s = ((lane & 1) ?
 959                           DP_ADJUST_VOLTAGE_SWING_LANE1_SHIFT :
 960                           DP_ADJUST_VOLTAGE_SWING_LANE0_SHIFT);
 961         unsigned int idx = DP_ADJUST_REQUEST_LANE0_1 - DP_LANE0_1_STATUS + (lane >> 1);
 962
 963         link_status[idx] &= ~(DP_ADJUST_VOLTAGE_SWING_LANE0_MASK << s);
 964         link_status[idx] |= volt << s;
 965 }
 966
 967 static
 968 void cdns_mhdp_set_adjust_request_pre_emphasis(u8 link_status[DP_LINK_STATUS_SIZE],
 969                                                unsigned int lane, u8 pre_emphasis)
 970 {
 971         unsigned int s = ((lane & 1) ?
 972                           DP_ADJUST_PRE_EMPHASIS_LANE1_SHIFT :
 973                           DP_ADJUST_PRE_EMPHASIS_LANE0_SHIFT);
 974         unsigned int idx = DP_ADJUST_REQUEST_LANE0_1 - DP_LANE0_1_STATUS + (lane >> 1);
 975
 976         link_status[idx] &= ~(DP_ADJUST_PRE_EMPHASIS_LANE0_MASK << s);
 977         link_status[idx] |= pre_emphasis << s;
 978 }
 979
 980 static void cdns_mhdp_adjust_requested_eq(struct cdns_mhdp_device *mhdp,
 981                                           u8 link_status[DP_LINK_STATUS_SIZE])
 982 {
 983         u8 max_pre = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis);
 984         u8 max_volt = CDNS_VOLT_SWING(mhdp->host.volt_swing);
 985         unsigned int i;
 986         u8 volt, pre;
 987
 988         for (i = 0; i < mhdp->link.num_lanes; i++) {
 989                 volt = drm_dp_get_adjust_request_voltage(link_status, i);
 990                 pre = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
 991                 if (volt + pre > 3)
 992                         cdns_mhdp_set_adjust_request_voltage(link_status, i,
 993                                                              3 - pre);
 994                 if (mhdp->host.volt_swing & CDNS_FORCE_VOLT_SWING)
 995                         cdns_mhdp_set_adjust_request_voltage(link_status, i,
 996                                                              max_volt);
 997                 if (mhdp->host.pre_emphasis & CDNS_FORCE_PRE_EMPHASIS)
 998                         cdns_mhdp_set_adjust_request_pre_emphasis(link_status,
 999                                                                   i, max_pre);
1000         }
1001 }
1002
1003 static void cdns_mhdp_print_lt_status(const char *prefix,
1004                                       struct cdns_mhdp_device *mhdp,
1005                                       union phy_configure_opts *phy_cfg)
1006 {
1007         char vs[8] = "0/0/0/0";
1008         char pe[8] = "0/0/0/0";
1009         unsigned int i;
1010
1011         for (i = 0; i < mhdp->link.num_lanes; i++) {
1012                 vs[i * 2] = '0' + phy_cfg->dp.voltage[i];
1013                 pe[i * 2] = '0' + phy_cfg->dp.pre[i];
1014         }
1015
1016         vs[i * 2 - 1] = '\0';
1017         pe[i * 2 - 1] = '\0';
1018
1019         dev_dbg(mhdp->dev, "%s, %u lanes, %u Mbps, vs %s, pe %s\n",
1020                 prefix,
1021                 mhdp->link.num_lanes, mhdp->link.rate / 100,
1022                 vs, pe);
1023 }
1024
1025 static bool cdns_mhdp_link_training_channel_eq(struct cdns_mhdp_device *mhdp,
1026                                                u8 eq_tps,
1027                                                unsigned int training_interval)
1028 {
1029         u8 lanes_data[CDNS_DP_MAX_NUM_LANES], fail_counter_short = 0;
1030         u8 link_status[DP_LINK_STATUS_SIZE];
1031         union phy_configure_opts phy_cfg;
1032         u32 reg32;
1033         int ret;
1034         bool r;
1035
1036         dev_dbg(mhdp->dev, "Starting EQ phase\n");
1037
1038         /* Enable link training TPS[eq_tps] in PHY */
1039         reg32 = CDNS_PHY_COMMON_CONFIG | CDNS_PHY_TRAINING_EN |
1040                 CDNS_PHY_TRAINING_TYPE(eq_tps);
1041         if (eq_tps != 4)
1042                 reg32 |= CDNS_PHY_SCRAMBLER_BYPASS;
1043         cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
1044
1045         drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
1046                            (eq_tps != 4) ? eq_tps | DP_LINK_SCRAMBLING_DISABLE :
1047                            CDNS_DP_TRAINING_PATTERN_4);
1048
1049         drm_dp_dpcd_read_link_status(&mhdp->aux, link_status);
1050
1051         do {
1052                 cdns_mhdp_get_adjust_train(mhdp, link_status, lanes_data,
1053                                            &phy_cfg);
1054                 phy_cfg.dp.lanes = mhdp->link.num_lanes;
1055                 phy_cfg.dp.ssc = cdns_mhdp_get_ssc_supported(mhdp);
1056                 phy_cfg.dp.set_lanes = false;
1057                 phy_cfg.dp.set_rate = false;
1058                 phy_cfg.dp.set_voltages = true;
1059                 ret = phy_configure(mhdp->phy,  &phy_cfg);
1060                 if (ret) {
1061                         dev_err(mhdp->dev, "%s: phy_configure() failed: %d\n",
1062                                 __func__, ret);
1063                         goto err;
1064                 }
1065
1066                 cdns_mhdp_adjust_lt(mhdp, mhdp->link.num_lanes,
1067                                     training_interval, lanes_data, link_status);
1068
1069                 r = drm_dp_clock_recovery_ok(link_status, mhdp->link.num_lanes);
1070                 if (!r)
1071                         goto err;
1072
1073                 if (drm_dp_channel_eq_ok(link_status, mhdp->link.num_lanes)) {
1074                         cdns_mhdp_print_lt_status("EQ phase ok", mhdp,
1075                                                   &phy_cfg);
1076                         return true;
1077                 }
1078
1079                 fail_counter_short++;
1080
1081                 cdns_mhdp_adjust_requested_eq(mhdp, link_status);
1082         } while (fail_counter_short < 5);
1083
1084 err:
1085         cdns_mhdp_print_lt_status("EQ phase failed", mhdp, &phy_cfg);
1086
1087         return false;
1088 }
1089
1090 static void cdns_mhdp_adjust_requested_cr(struct cdns_mhdp_device *mhdp,
1091                                           u8 link_status[DP_LINK_STATUS_SIZE],
1092                                           u8 *req_volt, u8 *req_pre)
1093 {
1094         const u8 max_volt = CDNS_VOLT_SWING(mhdp->host.volt_swing);
1095         const u8 max_pre = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis);
1096         unsigned int i;
1097
1098         for (i = 0; i < mhdp->link.num_lanes; i++) {
1099                 u8 val;
1100
1101                 val = mhdp->host.volt_swing & CDNS_FORCE_VOLT_SWING ?
1102                       max_volt : req_volt[i];
1103                 cdns_mhdp_set_adjust_request_voltage(link_status, i, val);
1104
1105                 val = mhdp->host.pre_emphasis & CDNS_FORCE_PRE_EMPHASIS ?
1106                       max_pre : req_pre[i];
1107                 cdns_mhdp_set_adjust_request_pre_emphasis(link_status, i, val);
1108         }
1109 }
1110
1111 static
1112 void cdns_mhdp_validate_cr(struct cdns_mhdp_device *mhdp, bool *cr_done,
1113                            bool *same_before_adjust, bool *max_swing_reached,
1114                            u8 before_cr[CDNS_DP_MAX_NUM_LANES],
1115                            u8 after_cr[DP_LINK_STATUS_SIZE], u8 *req_volt,
1116                            u8 *req_pre)
1117 {
1118         const u8 max_volt = CDNS_VOLT_SWING(mhdp->host.volt_swing);
1119         const u8 max_pre = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis);
1120         bool same_pre, same_volt;
1121         unsigned int i;
1122         u8 adjust;
1123
1124         *same_before_adjust = false;
1125         *max_swing_reached = false;
1126         *cr_done = drm_dp_clock_recovery_ok(after_cr, mhdp->link.num_lanes);
1127
1128         for (i = 0; i < mhdp->link.num_lanes; i++) {
1129                 adjust = drm_dp_get_adjust_request_voltage(after_cr, i);
1130                 req_volt[i] = min(adjust, max_volt);
1131
1132                 adjust = drm_dp_get_adjust_request_pre_emphasis(after_cr, i) >>
1133                       DP_TRAIN_PRE_EMPHASIS_SHIFT;
1134                 req_pre[i] = min(adjust, max_pre);
1135
1136                 same_pre = (before_cr[i] & DP_TRAIN_PRE_EMPHASIS_MASK) ==
1137                            req_pre[i] << DP_TRAIN_PRE_EMPHASIS_SHIFT;
1138                 same_volt = (before_cr[i] & DP_TRAIN_VOLTAGE_SWING_MASK) ==
1139                             req_volt[i];
1140                 if (same_pre && same_volt)
1141                         *same_before_adjust = true;
1142
1143                 /* 3.1.5.2 in DP Standard v1.4. Table 3-1 */
1144                 if (!*cr_done && req_volt[i] + req_pre[i] >= 3) {
1145                         *max_swing_reached = true;
1146                         return;
1147                 }
1148         }
1149 }
1150
1151 static bool cdns_mhdp_link_training_cr(struct cdns_mhdp_device *mhdp)
1152 {
1153         u8 lanes_data[CDNS_DP_MAX_NUM_LANES],
1154         fail_counter_short = 0, fail_counter_cr_long = 0;
1155         u8 link_status[DP_LINK_STATUS_SIZE];
1156         bool cr_done;
1157         union phy_configure_opts phy_cfg;
1158         int ret;
1159
1160         dev_dbg(mhdp->dev, "Starting CR phase\n");
1161
1162         ret = cdns_mhdp_link_training_init(mhdp);
1163         if (ret)
1164                 goto err;
1165
1166         drm_dp_dpcd_read_link_status(&mhdp->aux, link_status);
1167
1168         do {
1169                 u8 requested_adjust_volt_swing[CDNS_DP_MAX_NUM_LANES] = {};
1170                 u8 requested_adjust_pre_emphasis[CDNS_DP_MAX_NUM_LANES] = {};
1171                 bool same_before_adjust, max_swing_reached;
1172
1173                 cdns_mhdp_get_adjust_train(mhdp, link_status, lanes_data,
1174                                            &phy_cfg);
1175                 phy_cfg.dp.lanes = mhdp->link.num_lanes;
1176                 phy_cfg.dp.ssc = cdns_mhdp_get_ssc_supported(mhdp);
1177                 phy_cfg.dp.set_lanes = false;
1178                 phy_cfg.dp.set_rate = false;
1179                 phy_cfg.dp.set_voltages = true;
1180                 ret = phy_configure(mhdp->phy,  &phy_cfg);
1181                 if (ret) {
1182                         dev_err(mhdp->dev, "%s: phy_configure() failed: %d\n",
1183                                 __func__, ret);
1184                         goto err;
1185                 }
1186
1187                 cdns_mhdp_adjust_lt(mhdp, mhdp->link.num_lanes, 100,
1188                                     lanes_data, link_status);
1189
1190                 cdns_mhdp_validate_cr(mhdp, &cr_done, &same_before_adjust,
1191                                       &max_swing_reached, lanes_data,
1192                                       link_status,
1193                                       requested_adjust_volt_swing,
1194                                       requested_adjust_pre_emphasis);
1195
1196                 if (max_swing_reached) {
1197                         dev_err(mhdp->dev, "CR: max swing reached\n");
1198                         goto err;
1199                 }
1200
1201                 if (cr_done) {
1202                         cdns_mhdp_print_lt_status("CR phase ok", mhdp,
1203                                                   &phy_cfg);
1204                         return true;
1205                 }
1206
1207                 /* Not all CR_DONE bits set */
1208                 fail_counter_cr_long++;
1209
1210                 if (same_before_adjust) {
1211                         fail_counter_short++;
1212                         continue;
1213                 }
1214
1215                 fail_counter_short = 0;
1216                 /*
1217                  * Voltage swing/pre-emphasis adjust requested
1218                  * during CR phase
1219                  */
1220                 cdns_mhdp_adjust_requested_cr(mhdp, link_status,
1221                                               requested_adjust_volt_swing,
1222                                               requested_adjust_pre_emphasis);
1223         } while (fail_counter_short < 5 && fail_counter_cr_long < 10);
1224
1225 err:
1226         cdns_mhdp_print_lt_status("CR phase failed", mhdp, &phy_cfg);
1227
1228         return false;
1229 }
1230
1231 static void cdns_mhdp_lower_link_rate(struct cdns_mhdp_link *link)
1232 {
1233         switch (drm_dp_link_rate_to_bw_code(link->rate)) {
1234         case DP_LINK_BW_2_7:
1235                 link->rate = drm_dp_bw_code_to_link_rate(DP_LINK_BW_1_62);
1236                 break;
1237         case DP_LINK_BW_5_4:
1238                 link->rate = drm_dp_bw_code_to_link_rate(DP_LINK_BW_2_7);
1239                 break;
1240         case DP_LINK_BW_8_1:
1241                 link->rate = drm_dp_bw_code_to_link_rate(DP_LINK_BW_5_4);
1242                 break;
1243         }
1244 }
1245
1246 static int cdns_mhdp_link_training(struct cdns_mhdp_device *mhdp,
1247                                    unsigned int training_interval)
1248 {
1249         u32 reg32;
1250         const u8 eq_tps = cdns_mhdp_eq_training_pattern_supported(mhdp);
1251         int ret;
1252
1253         while (1) {
1254                 if (!cdns_mhdp_link_training_cr(mhdp)) {
1255                         if (drm_dp_link_rate_to_bw_code(mhdp->link.rate) !=
1256                             DP_LINK_BW_1_62) {
1257                                 dev_dbg(mhdp->dev,
1258                                         "Reducing link rate during CR phase\n");
1259                                 cdns_mhdp_lower_link_rate(&mhdp->link);
1260
1261                                 continue;
1262                         } else if (mhdp->link.num_lanes > 1) {
1263                                 dev_dbg(mhdp->dev,
1264                                         "Reducing lanes number during CR phase\n");
1265                                 mhdp->link.num_lanes >>= 1;
1266                                 mhdp->link.rate = cdns_mhdp_max_link_rate(mhdp);
1267
1268                                 continue;
1269                         }
1270
1271                         dev_err(mhdp->dev,
1272                                 "Link training failed during CR phase\n");
1273                         goto err;
1274                 }
1275
1276                 if (cdns_mhdp_link_training_channel_eq(mhdp, eq_tps,
1277                                                        training_interval))
1278                         break;
1279
1280                 if (mhdp->link.num_lanes > 1) {
1281                         dev_dbg(mhdp->dev,
1282                                 "Reducing lanes number during EQ phase\n");
1283                         mhdp->link.num_lanes >>= 1;
1284
1285                         continue;
1286                 } else if (drm_dp_link_rate_to_bw_code(mhdp->link.rate) !=
1287                            DP_LINK_BW_1_62) {
1288                         dev_dbg(mhdp->dev,
1289                                 "Reducing link rate during EQ phase\n");
1290                         cdns_mhdp_lower_link_rate(&mhdp->link);
1291                         mhdp->link.num_lanes = cdns_mhdp_max_num_lanes(mhdp);
1292
1293                         continue;
1294                 }
1295
1296                 dev_err(mhdp->dev, "Link training failed during EQ phase\n");
1297                 goto err;
1298         }
1299
1300         dev_dbg(mhdp->dev, "Link training ok. Lanes: %u, Rate %u Mbps\n",
1301                 mhdp->link.num_lanes, mhdp->link.rate / 100);
1302
1303         drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
1304                            mhdp->host.scrambler ? 0 :
1305                            DP_LINK_SCRAMBLING_DISABLE);
1306
1307         ret = cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &reg32);
1308         if (ret < 0) {
1309                 dev_err(mhdp->dev,
1310                         "Failed to read CDNS_DP_FRAMER_GLOBAL_CONFIG %d\n",
1311                         ret);
1312                 return ret;
1313         }
1314         reg32 &= ~GENMASK(1, 0);
1315         reg32 |= CDNS_DP_NUM_LANES(mhdp->link.num_lanes);
1316         reg32 |= CDNS_DP_WR_FAILING_EDGE_VSYNC;
1317         reg32 |= CDNS_DP_FRAMER_EN;
1318         cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, reg32);
1319
1320         /* Reset PHY config */
1321         reg32 = CDNS_PHY_COMMON_CONFIG | CDNS_PHY_TRAINING_TYPE(1);
1322         if (!mhdp->host.scrambler)
1323                 reg32 |= CDNS_PHY_SCRAMBLER_BYPASS;
1324         cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
1325
1326         return 0;
1327 err:
1328         /* Reset PHY config */
1329         reg32 = CDNS_PHY_COMMON_CONFIG | CDNS_PHY_TRAINING_TYPE(1);
1330         if (!mhdp->host.scrambler)
1331                 reg32 |= CDNS_PHY_SCRAMBLER_BYPASS;
1332         cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
1333
1334         drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
1335                            DP_TRAINING_PATTERN_DISABLE);
1336
1337         return -EIO;
1338 }
1339
1340 static u32 cdns_mhdp_get_training_interval_us(struct cdns_mhdp_device *mhdp,
1341                                               u32 interval)
1342 {
1343         if (interval == 0)
1344                 return 400;
1345         if (interval < 5)
1346                 return 4000 << (interval - 1);
1347         dev_err(mhdp->dev,
1348                 "wrong training interval returned by DPCD: %d\n", interval);
1349         return 0;
1350 }
1351
1352 static void cdns_mhdp_fill_host_caps(struct cdns_mhdp_device *mhdp)
1353 {
1354         unsigned int link_rate;
1355
1356         /* Get source capabilities based on PHY attributes */
1357
1358         mhdp->host.lanes_cnt = mhdp->phy->attrs.bus_width;
1359         if (!mhdp->host.lanes_cnt)
1360                 mhdp->host.lanes_cnt = 4;
1361
1362         link_rate = mhdp->phy->attrs.max_link_rate;
1363         if (!link_rate)
1364                 link_rate = drm_dp_bw_code_to_link_rate(DP_LINK_BW_8_1);
1365         else
1366                 /* PHY uses Mb/s, DRM uses tens of kb/s. */
1367                 link_rate *= 100;
1368
1369         mhdp->host.link_rate = link_rate;
1370         mhdp->host.volt_swing = CDNS_VOLT_SWING(3);
1371         mhdp->host.pre_emphasis = CDNS_PRE_EMPHASIS(3);
1372         mhdp->host.pattern_supp = CDNS_SUPPORT_TPS(1) |
1373                                   CDNS_SUPPORT_TPS(2) | CDNS_SUPPORT_TPS(3) |
1374                                   CDNS_SUPPORT_TPS(4);
1375         mhdp->host.lane_mapping = CDNS_LANE_MAPPING_NORMAL;
1376         mhdp->host.fast_link = false;
1377         mhdp->host.enhanced = true;
1378         mhdp->host.scrambler = true;
1379         mhdp->host.ssc = false;
1380 }
1381
1382 static void cdns_mhdp_fill_sink_caps(struct cdns_mhdp_device *mhdp,
1383                                      u8 dpcd[DP_RECEIVER_CAP_SIZE])
1384 {
1385         mhdp->sink.link_rate = mhdp->link.rate;
1386         mhdp->sink.lanes_cnt = mhdp->link.num_lanes;
1387         mhdp->sink.enhanced = !!(mhdp->link.capabilities &
1388                                  DP_LINK_CAP_ENHANCED_FRAMING);
1389
1390         /* Set SSC support */
1391         mhdp->sink.ssc = !!(dpcd[DP_MAX_DOWNSPREAD] &
1392                                   DP_MAX_DOWNSPREAD_0_5);
1393
1394         /* Set TPS support */
1395         mhdp->sink.pattern_supp = CDNS_SUPPORT_TPS(1) | CDNS_SUPPORT_TPS(2);
1396         if (drm_dp_tps3_supported(dpcd))
1397                 mhdp->sink.pattern_supp |= CDNS_SUPPORT_TPS(3);
1398         if (drm_dp_tps4_supported(dpcd))
1399                 mhdp->sink.pattern_supp |= CDNS_SUPPORT_TPS(4);
1400
1401         /* Set fast link support */
1402         mhdp->sink.fast_link = !!(dpcd[DP_MAX_DOWNSPREAD] &
1403                                   DP_NO_AUX_HANDSHAKE_LINK_TRAINING);
1404 }
1405
1406 static int cdns_mhdp_link_up(struct cdns_mhdp_device *mhdp)
1407 {
1408         u8 dpcd[DP_RECEIVER_CAP_SIZE], amp[2];
1409         u32 resp, interval, interval_us;
1410         u8 ext_cap_chk = 0;
1411         unsigned int addr;
1412         int err;
1413
1414         WARN_ON(!mutex_is_locked(&mhdp->link_mutex));
1415
1416         drm_dp_dpcd_readb(&mhdp->aux, DP_TRAINING_AUX_RD_INTERVAL,
1417                           &ext_cap_chk);
1418
1419         if (ext_cap_chk & DP_EXTENDED_RECEIVER_CAP_FIELD_PRESENT)
1420                 addr = DP_DP13_DPCD_REV;
1421         else
1422                 addr = DP_DPCD_REV;
1423
1424         err = drm_dp_dpcd_read(&mhdp->aux, addr, dpcd, DP_RECEIVER_CAP_SIZE);
1425         if (err < 0) {
1426                 dev_err(mhdp->dev, "Failed to read receiver capabilities\n");
1427                 return err;
1428         }
1429
1430         mhdp->link.revision = dpcd[0];
1431         mhdp->link.rate = drm_dp_bw_code_to_link_rate(dpcd[1]);
1432         mhdp->link.num_lanes = dpcd[2] & DP_MAX_LANE_COUNT_MASK;
1433
1434         if (dpcd[2] & DP_ENHANCED_FRAME_CAP)
1435                 mhdp->link.capabilities |= DP_LINK_CAP_ENHANCED_FRAMING;
1436
1437         dev_dbg(mhdp->dev, "Set sink device power state via DPCD\n");
1438         cdns_mhdp_link_power_up(&mhdp->aux, &mhdp->link);
1439
1440         cdns_mhdp_fill_sink_caps(mhdp, dpcd);
1441
1442         mhdp->link.rate = cdns_mhdp_max_link_rate(mhdp);
1443         mhdp->link.num_lanes = cdns_mhdp_max_num_lanes(mhdp);
1444
1445         /* Disable framer for link training */
1446         err = cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &resp);
1447         if (err < 0) {
1448                 dev_err(mhdp->dev,
1449                         "Failed to read CDNS_DP_FRAMER_GLOBAL_CONFIG %d\n",
1450                         err);
1451                 return err;
1452         }
1453
1454         resp &= ~CDNS_DP_FRAMER_EN;
1455         cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, resp);
1456
1457         /* Spread AMP if required, enable 8b/10b coding */
1458         amp[0] = cdns_mhdp_get_ssc_supported(mhdp) ? DP_SPREAD_AMP_0_5 : 0;
1459         amp[1] = DP_SET_ANSI_8B10B;
1460         drm_dp_dpcd_write(&mhdp->aux, DP_DOWNSPREAD_CTRL, amp, 2);
1461
1462         if (mhdp->host.fast_link & mhdp->sink.fast_link) {
1463                 dev_err(mhdp->dev, "fastlink not supported\n");
1464                 return -EOPNOTSUPP;
1465         }
1466
1467         interval = dpcd[DP_TRAINING_AUX_RD_INTERVAL] & DP_TRAINING_AUX_RD_MASK;
1468         interval_us = cdns_mhdp_get_training_interval_us(mhdp, interval);
1469         if (!interval_us ||
1470             cdns_mhdp_link_training(mhdp, interval_us)) {
1471                 dev_err(mhdp->dev, "Link training failed. Exiting.\n");
1472                 return -EIO;
1473         }
1474
1475         mhdp->link_up = true;
1476
1477         return 0;
1478 }
1479
1480 static void cdns_mhdp_link_down(struct cdns_mhdp_device *mhdp)
1481 {
1482         WARN_ON(!mutex_is_locked(&mhdp->link_mutex));
1483
1484         if (mhdp->plugged)
1485                 cdns_mhdp_link_power_down(&mhdp->aux, &mhdp->link);
1486
1487         mhdp->link_up = false;
1488 }
1489
1490 static struct edid *cdns_mhdp_get_edid(struct cdns_mhdp_device *mhdp,
1491                                        struct drm_connector *connector)
1492 {
1493         if (!mhdp->plugged)
1494                 return NULL;
1495
1496         return drm_do_get_edid(connector, cdns_mhdp_get_edid_block, mhdp);
1497 }
1498
1499 static int cdns_mhdp_get_modes(struct drm_connector *connector)
1500 {
1501         struct cdns_mhdp_device *mhdp = connector_to_mhdp(connector);
1502         struct edid *edid;
1503         int num_modes;
1504
1505         if (!mhdp->plugged)
1506                 return 0;
1507
1508         edid = cdns_mhdp_get_edid(mhdp, connector);
1509         if (!edid) {
1510                 dev_err(mhdp->dev, "Failed to read EDID\n");
1511                 return 0;
1512         }
1513
1514         drm_connector_update_edid_property(connector, edid);
1515         num_modes = drm_add_edid_modes(connector, edid);
1516         kfree(edid);
1517
1518         /*
1519          * HACK: Warn about unsupported display formats until we deal
1520          *       with them correctly.
1521          */
1522         if (connector->display_info.color_formats &&
1523             !(connector->display_info.color_formats &
1524               mhdp->display_fmt.color_format))
1525                 dev_warn(mhdp->dev,
1526                          "%s: No supported color_format found (0x%08x)\n",
1527                         __func__, connector->display_info.color_formats);
1528
1529         if (connector->display_info.bpc &&
1530             connector->display_info.bpc < mhdp->display_fmt.bpc)
1531                 dev_warn(mhdp->dev, "%s: Display bpc only %d < %d\n",
1532                          __func__, connector->display_info.bpc,
1533                          mhdp->display_fmt.bpc);
1534
1535         return num_modes;
1536 }
1537
1538 static int cdns_mhdp_connector_detect(struct drm_connector *conn,
1539                                       struct drm_modeset_acquire_ctx *ctx,
1540                                       bool force)
1541 {
1542         struct cdns_mhdp_device *mhdp = connector_to_mhdp(conn);
1543
1544         return cdns_mhdp_detect(mhdp);
1545 }
1546
1547 static u32 cdns_mhdp_get_bpp(struct cdns_mhdp_display_fmt *fmt)
1548 {
1549         u32 bpp;
1550
1551         if (fmt->y_only)
1552                 return fmt->bpc;
1553
1554         switch (fmt->color_format) {
1555         case DRM_COLOR_FORMAT_RGB444:
1556         case DRM_COLOR_FORMAT_YCRCB444:
1557                 bpp = fmt->bpc * 3;
1558                 break;
1559         case DRM_COLOR_FORMAT_YCRCB422:
1560                 bpp = fmt->bpc * 2;
1561                 break;
1562         case DRM_COLOR_FORMAT_YCRCB420:
1563                 bpp = fmt->bpc * 3 / 2;
1564                 break;
1565         default:
1566                 bpp = fmt->bpc * 3;
1567                 WARN_ON(1);
1568         }
1569         return bpp;
1570 }
1571
1572 static
1573 bool cdns_mhdp_bandwidth_ok(struct cdns_mhdp_device *mhdp,
1574                             const struct drm_display_mode *mode,
1575                             unsigned int lanes, unsigned int rate)
1576 {
1577         u32 max_bw, req_bw, bpp;
1578
1579         /*
1580          * mode->clock is expressed in kHz. Multiplying by bpp and dividing by 8
1581          * we get the number of kB/s. DisplayPort applies a 8b-10b encoding, the
1582          * value thus equals the bandwidth in 10kb/s units, which matches the
1583          * units of the rate parameter.
1584          */
1585
1586         bpp = cdns_mhdp_get_bpp(&mhdp->display_fmt);
1587         req_bw = mode->clock * bpp / 8;
1588         max_bw = lanes * rate;
1589         if (req_bw > max_bw) {
1590                 dev_dbg(mhdp->dev,
1591                         "Unsupported Mode: %s, Req BW: %u, Available Max BW:%u\n",
1592                         mode->name, req_bw, max_bw);
1593
1594                 return false;
1595         }
1596
1597         return true;
1598 }
1599
1600 static
1601 enum drm_mode_status cdns_mhdp_mode_valid(struct drm_connector *conn,
1602                                           struct drm_display_mode *mode)
1603 {
1604         struct cdns_mhdp_device *mhdp = connector_to_mhdp(conn);
1605
1606         mutex_lock(&mhdp->link_mutex);
1607
1608         if (!cdns_mhdp_bandwidth_ok(mhdp, mode, mhdp->link.num_lanes,
1609                                     mhdp->link.rate)) {
1610                 mutex_unlock(&mhdp->link_mutex);
1611                 return MODE_CLOCK_HIGH;
1612         }
1613
1614         mutex_unlock(&mhdp->link_mutex);
1615         return MODE_OK;
1616 }
1617
1618 static int cdns_mhdp_connector_atomic_check(struct drm_connector *conn,
1619                                             struct drm_atomic_state *state)
1620 {
1621         struct cdns_mhdp_device *mhdp = connector_to_mhdp(conn);
1622         struct drm_connector_state *old_state, *new_state;
1623         struct drm_crtc_state *crtc_state;
1624         u64 old_cp, new_cp;
1625
1626         if (!mhdp->hdcp_supported)
1627                 return 0;
1628
1629         old_state = drm_atomic_get_old_connector_state(state, conn);
1630         new_state = drm_atomic_get_new_connector_state(state, conn);
1631         old_cp = old_state->content_protection;
1632         new_cp = new_state->content_protection;
1633
1634         if (old_state->hdcp_content_type != new_state->hdcp_content_type &&
1635             new_cp != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
1636                 new_state->content_protection = DRM_MODE_CONTENT_PROTECTION_DESIRED;
1637                 goto mode_changed;
1638         }
1639
1640         if (!new_state->crtc) {
1641                 if (old_cp == DRM_MODE_CONTENT_PROTECTION_ENABLED)
1642                         new_state->content_protection = DRM_MODE_CONTENT_PROTECTION_DESIRED;
1643                 return 0;
1644         }
1645
1646         if (old_cp == new_cp ||
1647             (old_cp == DRM_MODE_CONTENT_PROTECTION_DESIRED &&
1648              new_cp == DRM_MODE_CONTENT_PROTECTION_ENABLED))
1649                 return 0;
1650
1651 mode_changed:
1652         crtc_state = drm_atomic_get_new_crtc_state(state, new_state->crtc);
1653         crtc_state->mode_changed = true;
1654
1655         return 0;
1656 }
1657
1658 static const struct drm_connector_helper_funcs cdns_mhdp_conn_helper_funcs = {
1659         .detect_ctx = cdns_mhdp_connector_detect,
1660         .get_modes = cdns_mhdp_get_modes,
1661         .mode_valid = cdns_mhdp_mode_valid,
1662         .atomic_check = cdns_mhdp_connector_atomic_check,
1663 };
1664
1665 static const struct drm_connector_funcs cdns_mhdp_conn_funcs = {
1666         .fill_modes = drm_helper_probe_single_connector_modes,
1667         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
1668         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
1669         .reset = drm_atomic_helper_connector_reset,
1670         .destroy = drm_connector_cleanup,
1671 };
1672
1673 static int cdns_mhdp_connector_init(struct cdns_mhdp_device *mhdp)
1674 {
1675         u32 bus_format = MEDIA_BUS_FMT_RGB121212_1X36;
1676         struct drm_connector *conn = &mhdp->connector;
1677         struct drm_bridge *bridge = &mhdp->bridge;
1678         int ret;
1679
1680         if (!bridge->encoder) {
1681                 dev_err(mhdp->dev, "Parent encoder object not found");
1682                 return -ENODEV;
1683         }
1684
1685         conn->polled = DRM_CONNECTOR_POLL_HPD;
1686
1687         ret = drm_connector_init(bridge->dev, conn, &cdns_mhdp_conn_funcs,
1688                                  DRM_MODE_CONNECTOR_DisplayPort);
1689         if (ret) {
1690                 dev_err(mhdp->dev, "Failed to initialize connector with drm\n");
1691                 return ret;
1692         }
1693
1694         drm_connector_helper_add(conn, &cdns_mhdp_conn_helper_funcs);
1695
1696         ret = drm_display_info_set_bus_formats(&conn->display_info,
1697                                                &bus_format, 1);
1698         if (ret)
1699                 return ret;
1700
1701         ret = drm_connector_attach_encoder(conn, bridge->encoder);
1702         if (ret) {
1703                 dev_err(mhdp->dev, "Failed to attach connector to encoder\n");
1704                 return ret;
1705         }
1706
1707         if (mhdp->hdcp_supported)
1708                 ret = drm_connector_attach_content_protection_property(conn, true);
1709
1710         return ret;
1711 }
1712
1713 static int cdns_mhdp_attach(struct drm_bridge *bridge,
1714                             enum drm_bridge_attach_flags flags)
1715 {
1716         struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
1717         bool hw_ready;
1718         int ret;
1719
1720         dev_dbg(mhdp->dev, "%s\n", __func__);
1721
1722         mhdp->aux.drm_dev = bridge->dev;
1723         ret = drm_dp_aux_register(&mhdp->aux);
1724         if (ret < 0)
1725                 return ret;
1726
1727         if (!(flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)) {
1728                 ret = cdns_mhdp_connector_init(mhdp);
1729                 if (ret)
1730                         goto aux_unregister;
1731         }
1732
1733         spin_lock(&mhdp->start_lock);
1734
1735         mhdp->bridge_attached = true;
1736         hw_ready = mhdp->hw_state == MHDP_HW_READY;
1737
1738         spin_unlock(&mhdp->start_lock);
1739
1740         /* Enable SW event interrupts */
1741         if (hw_ready)
1742                 writel(~(u32)CDNS_APB_INT_MASK_SW_EVENT_INT,
1743                        mhdp->regs + CDNS_APB_INT_MASK);
1744
1745         return 0;
1746 aux_unregister:
1747         drm_dp_aux_unregister(&mhdp->aux);
1748         return ret;
1749 }
1750
1751 static void cdns_mhdp_configure_video(struct cdns_mhdp_device *mhdp,
1752                                       const struct drm_display_mode *mode)
1753 {
1754         unsigned int dp_framer_sp = 0, msa_horizontal_1,
1755                 msa_vertical_1, bnd_hsync2vsync, hsync2vsync_pol_ctrl,
1756                 misc0 = 0, misc1 = 0, pxl_repr,
1757                 front_porch, back_porch, msa_h0, msa_v0, hsync, vsync,
1758                 dp_vertical_1;
1759         u8 stream_id = mhdp->stream_id;
1760         u32 bpp, bpc, pxlfmt, framer;
1761         int ret;
1762
1763         pxlfmt = mhdp->display_fmt.color_format;
1764         bpc = mhdp->display_fmt.bpc;
1765
1766         /*
1767          * If YCBCR supported and stream not SD, use ITU709
1768          * Need to handle ITU version with YCBCR420 when supported
1769          */
1770         if ((pxlfmt == DRM_COLOR_FORMAT_YCRCB444 ||
1771              pxlfmt == DRM_COLOR_FORMAT_YCRCB422) && mode->crtc_vdisplay >= 720)
1772                 misc0 = DP_YCBCR_COEFFICIENTS_ITU709;
1773
1774         bpp = cdns_mhdp_get_bpp(&mhdp->display_fmt);
1775
1776         switch (pxlfmt) {
1777         case DRM_COLOR_FORMAT_RGB444:
1778                 pxl_repr = CDNS_DP_FRAMER_RGB << CDNS_DP_FRAMER_PXL_FORMAT;
1779                 misc0 |= DP_COLOR_FORMAT_RGB;
1780                 break;
1781         case DRM_COLOR_FORMAT_YCRCB444:
1782                 pxl_repr = CDNS_DP_FRAMER_YCBCR444 << CDNS_DP_FRAMER_PXL_FORMAT;
1783                 misc0 |= DP_COLOR_FORMAT_YCbCr444 | DP_TEST_DYNAMIC_RANGE_CEA;
1784                 break;
1785         case DRM_COLOR_FORMAT_YCRCB422:
1786                 pxl_repr = CDNS_DP_FRAMER_YCBCR422 << CDNS_DP_FRAMER_PXL_FORMAT;
1787                 misc0 |= DP_COLOR_FORMAT_YCbCr422 | DP_TEST_DYNAMIC_RANGE_CEA;
1788                 break;
1789         case DRM_COLOR_FORMAT_YCRCB420:
1790                 pxl_repr = CDNS_DP_FRAMER_YCBCR420 << CDNS_DP_FRAMER_PXL_FORMAT;
1791                 break;
1792         default:
1793                 pxl_repr = CDNS_DP_FRAMER_Y_ONLY << CDNS_DP_FRAMER_PXL_FORMAT;
1794         }
1795
1796         switch (bpc) {
1797         case 6:
1798                 misc0 |= DP_TEST_BIT_DEPTH_6;
1799                 pxl_repr |= CDNS_DP_FRAMER_6_BPC;
1800                 break;
1801         case 8:
1802                 misc0 |= DP_TEST_BIT_DEPTH_8;
1803                 pxl_repr |= CDNS_DP_FRAMER_8_BPC;
1804                 break;
1805         case 10:
1806                 misc0 |= DP_TEST_BIT_DEPTH_10;
1807                 pxl_repr |= CDNS_DP_FRAMER_10_BPC;
1808                 break;
1809         case 12:
1810                 misc0 |= DP_TEST_BIT_DEPTH_12;
1811                 pxl_repr |= CDNS_DP_FRAMER_12_BPC;
1812                 break;
1813         case 16:
1814                 misc0 |= DP_TEST_BIT_DEPTH_16;
1815                 pxl_repr |= CDNS_DP_FRAMER_16_BPC;
1816                 break;
1817         }
1818
1819         bnd_hsync2vsync = CDNS_IP_BYPASS_V_INTERFACE;
1820         if (mode->flags & DRM_MODE_FLAG_INTERLACE)
1821                 bnd_hsync2vsync |= CDNS_IP_DET_INTERLACE_FORMAT;
1822
1823         cdns_mhdp_reg_write(mhdp, CDNS_BND_HSYNC2VSYNC(stream_id),
1824                             bnd_hsync2vsync);
1825
1826         hsync2vsync_pol_ctrl = 0;
1827         if (mode->flags & DRM_MODE_FLAG_NHSYNC)
1828                 hsync2vsync_pol_ctrl |= CDNS_H2V_HSYNC_POL_ACTIVE_LOW;
1829         if (mode->flags & DRM_MODE_FLAG_NVSYNC)
1830                 hsync2vsync_pol_ctrl |= CDNS_H2V_VSYNC_POL_ACTIVE_LOW;
1831         cdns_mhdp_reg_write(mhdp, CDNS_HSYNC2VSYNC_POL_CTRL(stream_id),
1832                             hsync2vsync_pol_ctrl);
1833
1834         cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_PXL_REPR(stream_id), pxl_repr);
1835
1836         if (mode->flags & DRM_MODE_FLAG_INTERLACE)
1837                 dp_framer_sp |= CDNS_DP_FRAMER_INTERLACE;
1838         if (mode->flags & DRM_MODE_FLAG_NHSYNC)
1839                 dp_framer_sp |= CDNS_DP_FRAMER_HSYNC_POL_LOW;
1840         if (mode->flags & DRM_MODE_FLAG_NVSYNC)
1841                 dp_framer_sp |= CDNS_DP_FRAMER_VSYNC_POL_LOW;
1842         cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_SP(stream_id), dp_framer_sp);
1843
1844         front_porch = mode->crtc_hsync_start - mode->crtc_hdisplay;
1845         back_porch = mode->crtc_htotal - mode->crtc_hsync_end;
1846         cdns_mhdp_reg_write(mhdp, CDNS_DP_FRONT_BACK_PORCH(stream_id),
1847                             CDNS_DP_FRONT_PORCH(front_porch) |
1848                             CDNS_DP_BACK_PORCH(back_porch));
1849
1850         cdns_mhdp_reg_write(mhdp, CDNS_DP_BYTE_COUNT(stream_id),
1851                             mode->crtc_hdisplay * bpp / 8);
1852
1853         msa_h0 = mode->crtc_htotal - mode->crtc_hsync_start;
1854         cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_HORIZONTAL_0(stream_id),
1855                             CDNS_DP_MSAH0_H_TOTAL(mode->crtc_htotal) |
1856                             CDNS_DP_MSAH0_HSYNC_START(msa_h0));
1857
1858         hsync = mode->crtc_hsync_end - mode->crtc_hsync_start;
1859         msa_horizontal_1 = CDNS_DP_MSAH1_HSYNC_WIDTH(hsync) |
1860                            CDNS_DP_MSAH1_HDISP_WIDTH(mode->crtc_hdisplay);
1861         if (mode->flags & DRM_MODE_FLAG_NHSYNC)
1862                 msa_horizontal_1 |= CDNS_DP_MSAH1_HSYNC_POL_LOW;
1863         cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_HORIZONTAL_1(stream_id),
1864                             msa_horizontal_1);
1865
1866         msa_v0 = mode->crtc_vtotal - mode->crtc_vsync_start;
1867         cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_VERTICAL_0(stream_id),
1868                             CDNS_DP_MSAV0_V_TOTAL(mode->crtc_vtotal) |
1869                             CDNS_DP_MSAV0_VSYNC_START(msa_v0));
1870
1871         vsync = mode->crtc_vsync_end - mode->crtc_vsync_start;
1872         msa_vertical_1 = CDNS_DP_MSAV1_VSYNC_WIDTH(vsync) |
1873                          CDNS_DP_MSAV1_VDISP_WIDTH(mode->crtc_vdisplay);
1874         if (mode->flags & DRM_MODE_FLAG_NVSYNC)
1875                 msa_vertical_1 |= CDNS_DP_MSAV1_VSYNC_POL_LOW;
1876         cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_VERTICAL_1(stream_id),
1877                             msa_vertical_1);
1878
1879         if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
1880             mode->crtc_vtotal % 2 == 0)
1881                 misc1 = DP_TEST_INTERLACED;
1882         if (mhdp->display_fmt.y_only)
1883                 misc1 |= CDNS_DP_TEST_COLOR_FORMAT_RAW_Y_ONLY;
1884         /* Use VSC SDP for Y420 */
1885         if (pxlfmt == DRM_COLOR_FORMAT_YCRCB420)
1886                 misc1 = CDNS_DP_TEST_VSC_SDP;
1887
1888         cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_MISC(stream_id),
1889                             misc0 | (misc1 << 8));
1890
1891         cdns_mhdp_reg_write(mhdp, CDNS_DP_HORIZONTAL(stream_id),
1892                             CDNS_DP_H_HSYNC_WIDTH(hsync) |
1893                             CDNS_DP_H_H_TOTAL(mode->crtc_hdisplay));
1894
1895         cdns_mhdp_reg_write(mhdp, CDNS_DP_VERTICAL_0(stream_id),
1896                             CDNS_DP_V0_VHEIGHT(mode->crtc_vdisplay) |
1897                             CDNS_DP_V0_VSTART(msa_v0));
1898
1899         dp_vertical_1 = CDNS_DP_V1_VTOTAL(mode->crtc_vtotal);
1900         if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
1901             mode->crtc_vtotal % 2 == 0)
1902                 dp_vertical_1 |= CDNS_DP_V1_VTOTAL_EVEN;
1903
1904         cdns_mhdp_reg_write(mhdp, CDNS_DP_VERTICAL_1(stream_id), dp_vertical_1);
1905
1906         cdns_mhdp_reg_write_bit(mhdp, CDNS_DP_VB_ID(stream_id), 2, 1,
1907                                 (mode->flags & DRM_MODE_FLAG_INTERLACE) ?
1908                                 CDNS_DP_VB_ID_INTERLACED : 0);
1909
1910         ret = cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &framer);
1911         if (ret < 0) {
1912                 dev_err(mhdp->dev,
1913                         "Failed to read CDNS_DP_FRAMER_GLOBAL_CONFIG %d\n",
1914                         ret);
1915                 return;
1916         }
1917         framer |= CDNS_DP_FRAMER_EN;
1918         framer &= ~CDNS_DP_NO_VIDEO_MODE;
1919         cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, framer);
1920 }
1921
1922 static void cdns_mhdp_sst_enable(struct cdns_mhdp_device *mhdp,
1923                                  const struct drm_display_mode *mode)
1924 {
1925         u32 rate, vs, required_bandwidth, available_bandwidth;
1926         s32 line_thresh1, line_thresh2, line_thresh = 0;
1927         int pxlclock = mode->crtc_clock;
1928         u32 tu_size = 64;
1929         u32 bpp;
1930
1931         /* Get rate in MSymbols per second per lane */
1932         rate = mhdp->link.rate / 1000;
1933
1934         bpp = cdns_mhdp_get_bpp(&mhdp->display_fmt);
1935
1936         required_bandwidth = pxlclock * bpp / 8;
1937         available_bandwidth = mhdp->link.num_lanes * rate;
1938
1939         vs = tu_size * required_bandwidth / available_bandwidth;
1940         vs /= 1000;
1941
1942         if (vs == tu_size)
1943                 vs = tu_size - 1;
1944
1945         line_thresh1 = ((vs + 1) << 5) * 8 / bpp;
1946         line_thresh2 = (pxlclock << 5) / 1000 / rate * (vs + 1) - (1 << 5);
1947         line_thresh = line_thresh1 - line_thresh2 / (s32)mhdp->link.num_lanes;
1948         line_thresh = (line_thresh >> 5) + 2;
1949
1950         mhdp->stream_id = 0;
1951
1952         cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_TU,
1953                             CDNS_DP_FRAMER_TU_VS(vs) |
1954                             CDNS_DP_FRAMER_TU_SIZE(tu_size) |
1955                             CDNS_DP_FRAMER_TU_CNT_RST_EN);
1956
1957         cdns_mhdp_reg_write(mhdp, CDNS_DP_LINE_THRESH(0),
1958                             line_thresh & GENMASK(5, 0));
1959
1960         cdns_mhdp_reg_write(mhdp, CDNS_DP_STREAM_CONFIG_2(0),
1961                             CDNS_DP_SC2_TU_VS_DIFF((tu_size - vs > 3) ?
1962                                                    0 : tu_size - vs));
1963
1964         cdns_mhdp_configure_video(mhdp, mode);
1965 }
1966
1967 static void cdns_mhdp_atomic_enable(struct drm_bridge *bridge,
1968                                     struct drm_bridge_state *bridge_state)
1969 {
1970         struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
1971         struct drm_atomic_state *state = bridge_state->base.state;
1972         struct cdns_mhdp_bridge_state *mhdp_state;
1973         struct drm_crtc_state *crtc_state;
1974         struct drm_connector *connector;
1975         struct drm_connector_state *conn_state;
1976         struct drm_bridge_state *new_state;
1977         const struct drm_display_mode *mode;
1978         u32 resp;
1979         int ret;
1980
1981         dev_dbg(mhdp->dev, "bridge enable\n");
1982
1983         mutex_lock(&mhdp->link_mutex);
1984
1985         if (mhdp->plugged && !mhdp->link_up) {
1986                 ret = cdns_mhdp_link_up(mhdp);
1987                 if (ret < 0)
1988                         goto out;
1989         }
1990
1991         if (mhdp->info && mhdp->info->ops && mhdp->info->ops->enable)
1992                 mhdp->info->ops->enable(mhdp);
1993
1994         /* Enable VIF clock for stream 0 */
1995         ret = cdns_mhdp_reg_read(mhdp, CDNS_DPTX_CAR, &resp);
1996         if (ret < 0) {
1997                 dev_err(mhdp->dev, "Failed to read CDNS_DPTX_CAR %d\n", ret);
1998                 goto out;
1999         }
2000
2001         cdns_mhdp_reg_write(mhdp, CDNS_DPTX_CAR,
2002                             resp | CDNS_VIF_CLK_EN | CDNS_VIF_CLK_RSTN);
2003
2004         connector = drm_atomic_get_new_connector_for_encoder(state,
2005                                                              bridge->encoder);
2006         if (WARN_ON(!connector))
2007                 goto out;
2008
2009         conn_state = drm_atomic_get_new_connector_state(state, connector);
2010         if (WARN_ON(!conn_state))
2011                 goto out;
2012
2013         if (mhdp->hdcp_supported &&
2014             mhdp->hw_state == MHDP_HW_READY &&
2015             conn_state->content_protection ==
2016             DRM_MODE_CONTENT_PROTECTION_DESIRED) {
2017                 mutex_unlock(&mhdp->link_mutex);
2018                 cdns_mhdp_hdcp_enable(mhdp, conn_state->hdcp_content_type);
2019                 mutex_lock(&mhdp->link_mutex);
2020         }
2021
2022         crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc);
2023         if (WARN_ON(!crtc_state))
2024                 goto out;
2025
2026         mode = &crtc_state->adjusted_mode;
2027
2028         new_state = drm_atomic_get_new_bridge_state(state, bridge);
2029         if (WARN_ON(!new_state))
2030                 goto out;
2031
2032         if (!cdns_mhdp_bandwidth_ok(mhdp, mode, mhdp->link.num_lanes,
2033                                     mhdp->link.rate)) {
2034                 ret = -EINVAL;
2035                 goto out;
2036         }
2037
2038         cdns_mhdp_sst_enable(mhdp, mode);
2039
2040         mhdp_state = to_cdns_mhdp_bridge_state(new_state);
2041
2042         mhdp_state->current_mode = drm_mode_duplicate(bridge->dev, mode);
2043         drm_mode_set_name(mhdp_state->current_mode);
2044
2045         dev_dbg(mhdp->dev, "%s: Enabling mode %s\n", __func__, mode->name);
2046
2047         mhdp->bridge_enabled = true;
2048
2049 out:
2050         mutex_unlock(&mhdp->link_mutex);
2051         if (ret < 0)
2052                 schedule_work(&mhdp->modeset_retry_work);
2053 }
2054
2055 static void cdns_mhdp_atomic_disable(struct drm_bridge *bridge,
2056                                      struct drm_bridge_state *bridge_state)
2057 {
2058         struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2059         u32 resp;
2060
2061         dev_dbg(mhdp->dev, "%s\n", __func__);
2062
2063         mutex_lock(&mhdp->link_mutex);
2064
2065         if (mhdp->hdcp_supported)
2066                 cdns_mhdp_hdcp_disable(mhdp);
2067
2068         mhdp->bridge_enabled = false;
2069         cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &resp);
2070         resp &= ~CDNS_DP_FRAMER_EN;
2071         resp |= CDNS_DP_NO_VIDEO_MODE;
2072         cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, resp);
2073
2074         cdns_mhdp_link_down(mhdp);
2075
2076         /* Disable VIF clock for stream 0 */
2077         cdns_mhdp_reg_read(mhdp, CDNS_DPTX_CAR, &resp);
2078         cdns_mhdp_reg_write(mhdp, CDNS_DPTX_CAR,
2079                             resp & ~(CDNS_VIF_CLK_EN | CDNS_VIF_CLK_RSTN));
2080
2081         if (mhdp->info && mhdp->info->ops && mhdp->info->ops->disable)
2082                 mhdp->info->ops->disable(mhdp);
2083
2084         mutex_unlock(&mhdp->link_mutex);
2085 }
2086
2087 static void cdns_mhdp_detach(struct drm_bridge *bridge)
2088 {
2089         struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2090
2091         dev_dbg(mhdp->dev, "%s\n", __func__);
2092
2093         drm_dp_aux_unregister(&mhdp->aux);
2094
2095         spin_lock(&mhdp->start_lock);
2096
2097         mhdp->bridge_attached = false;
2098
2099         spin_unlock(&mhdp->start_lock);
2100
2101         writel(~0, mhdp->regs + CDNS_APB_INT_MASK);
2102 }
2103
2104 static struct drm_bridge_state *
2105 cdns_mhdp_bridge_atomic_duplicate_state(struct drm_bridge *bridge)
2106 {
2107         struct cdns_mhdp_bridge_state *state;
2108
2109         state = kzalloc(sizeof(*state), GFP_KERNEL);
2110         if (!state)
2111                 return NULL;
2112
2113         __drm_atomic_helper_bridge_duplicate_state(bridge, &state->base);
2114
2115         return &state->base;
2116 }
2117
2118 static void
2119 cdns_mhdp_bridge_atomic_destroy_state(struct drm_bridge *bridge,
2120                                       struct drm_bridge_state *state)
2121 {
2122         struct cdns_mhdp_bridge_state *cdns_mhdp_state;
2123
2124         cdns_mhdp_state = to_cdns_mhdp_bridge_state(state);
2125
2126         if (cdns_mhdp_state->current_mode) {
2127                 drm_mode_destroy(bridge->dev, cdns_mhdp_state->current_mode);
2128                 cdns_mhdp_state->current_mode = NULL;
2129         }
2130
2131         kfree(cdns_mhdp_state);
2132 }
2133
2134 static struct drm_bridge_state *
2135 cdns_mhdp_bridge_atomic_reset(struct drm_bridge *bridge)
2136 {
2137         struct cdns_mhdp_bridge_state *cdns_mhdp_state;
2138
2139         cdns_mhdp_state = kzalloc(sizeof(*cdns_mhdp_state), GFP_KERNEL);
2140         if (!cdns_mhdp_state)
2141                 return NULL;
2142
2143         __drm_atomic_helper_bridge_reset(bridge, &cdns_mhdp_state->base);
2144
2145         return &cdns_mhdp_state->base;
2146 }
2147
2148 static int cdns_mhdp_atomic_check(struct drm_bridge *bridge,
2149                                   struct drm_bridge_state *bridge_state,
2150                                   struct drm_crtc_state *crtc_state,
2151                                   struct drm_connector_state *conn_state)
2152 {
2153         struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2154         const struct drm_display_mode *mode = &crtc_state->adjusted_mode;
2155
2156         mutex_lock(&mhdp->link_mutex);
2157
2158         if (!cdns_mhdp_bandwidth_ok(mhdp, mode, mhdp->link.num_lanes,
2159                                     mhdp->link.rate)) {
2160                 dev_err(mhdp->dev, "%s: Not enough BW for %s (%u lanes at %u Mbps)\n",
2161                         __func__, mode->name, mhdp->link.num_lanes,
2162                         mhdp->link.rate / 100);
2163                 mutex_unlock(&mhdp->link_mutex);
2164                 return -EINVAL;
2165         }
2166
2167         mutex_unlock(&mhdp->link_mutex);
2168         return 0;
2169 }
2170
2171 static enum drm_connector_status cdns_mhdp_bridge_detect(struct drm_bridge *bridge)
2172 {
2173         struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2174
2175         return cdns_mhdp_detect(mhdp);
2176 }
2177
2178 static struct edid *cdns_mhdp_bridge_get_edid(struct drm_bridge *bridge,
2179                                               struct drm_connector *connector)
2180 {
2181         struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2182
2183         return cdns_mhdp_get_edid(mhdp, connector);
2184 }
2185
2186 static void cdns_mhdp_bridge_hpd_enable(struct drm_bridge *bridge)
2187 {
2188         struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2189
2190         /* Enable SW event interrupts */
2191         if (mhdp->bridge_attached)
2192                 writel(~(u32)CDNS_APB_INT_MASK_SW_EVENT_INT,
2193                        mhdp->regs + CDNS_APB_INT_MASK);
2194 }
2195
2196 static void cdns_mhdp_bridge_hpd_disable(struct drm_bridge *bridge)
2197 {
2198         struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2199
2200         writel(CDNS_APB_INT_MASK_SW_EVENT_INT, mhdp->regs + CDNS_APB_INT_MASK);
2201 }
2202
2203 static const struct drm_bridge_funcs cdns_mhdp_bridge_funcs = {
2204         .atomic_enable = cdns_mhdp_atomic_enable,
2205         .atomic_disable = cdns_mhdp_atomic_disable,
2206         .atomic_check = cdns_mhdp_atomic_check,
2207         .attach = cdns_mhdp_attach,
2208         .detach = cdns_mhdp_detach,
2209         .atomic_duplicate_state = cdns_mhdp_bridge_atomic_duplicate_state,
2210         .atomic_destroy_state = cdns_mhdp_bridge_atomic_destroy_state,
2211         .atomic_reset = cdns_mhdp_bridge_atomic_reset,
2212         .detect = cdns_mhdp_bridge_detect,
2213         .get_edid = cdns_mhdp_bridge_get_edid,
2214         .hpd_enable = cdns_mhdp_bridge_hpd_enable,
2215         .hpd_disable = cdns_mhdp_bridge_hpd_disable,
2216 };
2217
2218 static bool cdns_mhdp_detect_hpd(struct cdns_mhdp_device *mhdp, bool *hpd_pulse)
2219 {
2220         int hpd_event, hpd_status;
2221
2222         *hpd_pulse = false;
2223
2224         hpd_event = cdns_mhdp_read_hpd_event(mhdp);
2225
2226         /* Getting event bits failed, bail out */
2227         if (hpd_event < 0) {
2228                 dev_warn(mhdp->dev, "%s: read event failed: %d\n",
2229                          __func__, hpd_event);
2230                 return false;
2231         }
2232
2233         hpd_status = cdns_mhdp_get_hpd_status(mhdp);
2234         if (hpd_status < 0) {
2235                 dev_warn(mhdp->dev, "%s: get hpd status failed: %d\n",
2236                          __func__, hpd_status);
2237                 return false;
2238         }
2239
2240         if (hpd_event & DPTX_READ_EVENT_HPD_PULSE)
2241                 *hpd_pulse = true;
2242
2243         return !!hpd_status;
2244 }
2245
2246 static int cdns_mhdp_update_link_status(struct cdns_mhdp_device *mhdp)
2247 {
2248         struct cdns_mhdp_bridge_state *cdns_bridge_state;
2249         struct drm_display_mode *current_mode;
2250         bool old_plugged = mhdp->plugged;
2251         struct drm_bridge_state *state;
2252         u8 status[DP_LINK_STATUS_SIZE];
2253         bool hpd_pulse;
2254         int ret = 0;
2255
2256         mutex_lock(&mhdp->link_mutex);
2257
2258         mhdp->plugged = cdns_mhdp_detect_hpd(mhdp, &hpd_pulse);
2259
2260         if (!mhdp->plugged) {
2261                 cdns_mhdp_link_down(mhdp);
2262                 mhdp->link.rate = mhdp->host.link_rate;
2263                 mhdp->link.num_lanes = mhdp->host.lanes_cnt;
2264                 goto out;
2265         }
2266
2267         /*
2268          * If we get a HPD pulse event and we were and still are connected,
2269          * check the link status. If link status is ok, there's nothing to do
2270          * as we don't handle DP interrupts. If link status is bad, continue
2271          * with full link setup.
2272          */
2273         if (hpd_pulse && old_plugged == mhdp->plugged) {
2274                 ret = drm_dp_dpcd_read_link_status(&mhdp->aux, status);
2275
2276                 /*
2277                  * If everything looks fine, just return, as we don't handle
2278                  * DP IRQs.
2279                  */
2280                 if (ret > 0 &&
2281                     drm_dp_channel_eq_ok(status, mhdp->link.num_lanes) &&
2282                     drm_dp_clock_recovery_ok(status, mhdp->link.num_lanes))
2283                         goto out;
2284
2285                 /* If link is bad, mark link as down so that we do a new LT */
2286                 mhdp->link_up = false;
2287         }
2288
2289         if (!mhdp->link_up) {
2290                 ret = cdns_mhdp_link_up(mhdp);
2291                 if (ret < 0)
2292                         goto out;
2293         }
2294
2295         if (mhdp->bridge_enabled) {
2296                 state = drm_priv_to_bridge_state(mhdp->bridge.base.state);
2297                 if (!state) {
2298                         ret = -EINVAL;
2299                         goto out;
2300                 }
2301
2302                 cdns_bridge_state = to_cdns_mhdp_bridge_state(state);
2303                 if (!cdns_bridge_state) {
2304                         ret = -EINVAL;
2305                         goto out;
2306                 }
2307
2308                 current_mode = cdns_bridge_state->current_mode;
2309                 if (!current_mode) {
2310                         ret = -EINVAL;
2311                         goto out;
2312                 }
2313
2314                 if (!cdns_mhdp_bandwidth_ok(mhdp, current_mode, mhdp->link.num_lanes,
2315                                             mhdp->link.rate)) {
2316                         ret = -EINVAL;
2317                         goto out;
2318                 }
2319
2320                 dev_dbg(mhdp->dev, "%s: Enabling mode %s\n", __func__,
2321                         current_mode->name);
2322
2323                 cdns_mhdp_sst_enable(mhdp, current_mode);
2324         }
2325 out:
2326         mutex_unlock(&mhdp->link_mutex);
2327         return ret;
2328 }
2329
2330 static void cdns_mhdp_modeset_retry_fn(struct work_struct *work)
2331 {
2332         struct cdns_mhdp_device *mhdp;
2333         struct drm_connector *conn;
2334
2335         mhdp = container_of(work, typeof(*mhdp), modeset_retry_work);
2336
2337         conn = &mhdp->connector;
2338
2339         /* Grab the locks before changing connector property */
2340         mutex_lock(&conn->dev->mode_config.mutex);
2341
2342         /*
2343          * Set connector link status to BAD and send a Uevent to notify
2344          * userspace to do a modeset.
2345          */
2346         drm_connector_set_link_status_property(conn, DRM_MODE_LINK_STATUS_BAD);
2347         mutex_unlock(&conn->dev->mode_config.mutex);
2348
2349         /* Send Hotplug uevent so userspace can reprobe */
2350         drm_kms_helper_hotplug_event(mhdp->bridge.dev);
2351 }
2352
2353 static irqreturn_t cdns_mhdp_irq_handler(int irq, void *data)
2354 {
2355         struct cdns_mhdp_device *mhdp = data;
2356         u32 apb_stat, sw_ev0;
2357         bool bridge_attached;
2358
2359         apb_stat = readl(mhdp->regs + CDNS_APB_INT_STATUS);
2360         if (!(apb_stat & CDNS_APB_INT_MASK_SW_EVENT_INT))
2361                 return IRQ_NONE;
2362
2363         sw_ev0 = readl(mhdp->regs + CDNS_SW_EVENT0);
2364
2365         /*
2366          *  Calling drm_kms_helper_hotplug_event() when not attached
2367          *  to drm device causes an oops because the drm_bridge->dev
2368          *  is NULL. See cdns_mhdp_fw_cb() comments for details about the
2369          *  problems related drm_kms_helper_hotplug_event() call.
2370          */
2371         spin_lock(&mhdp->start_lock);
2372         bridge_attached = mhdp->bridge_attached;
2373         spin_unlock(&mhdp->start_lock);
2374
2375         if (bridge_attached && (sw_ev0 & CDNS_DPTX_HPD)) {
2376                 schedule_work(&mhdp->hpd_work);
2377         }
2378
2379         if (sw_ev0 & ~CDNS_DPTX_HPD) {
2380                 mhdp->sw_events |= (sw_ev0 & ~CDNS_DPTX_HPD);
2381                 wake_up(&mhdp->sw_events_wq);
2382         }
2383
2384         return IRQ_HANDLED;
2385 }
2386
2387 u32 cdns_mhdp_wait_for_sw_event(struct cdns_mhdp_device *mhdp, u32 event)
2388 {
2389         u32 ret;
2390
2391         ret = wait_event_timeout(mhdp->sw_events_wq,
2392                                  mhdp->sw_events & event,
2393                                  msecs_to_jiffies(500));
2394         if (!ret) {
2395                 dev_dbg(mhdp->dev, "SW event 0x%x timeout\n", event);
2396                 goto sw_event_out;
2397         }
2398
2399         ret = mhdp->sw_events;
2400         mhdp->sw_events &= ~event;
2401
2402 sw_event_out:
2403         return ret;
2404 }
2405
2406 static void cdns_mhdp_hpd_work(struct work_struct *work)
2407 {
2408         struct cdns_mhdp_device *mhdp = container_of(work,
2409                                                      struct cdns_mhdp_device,
2410                                                      hpd_work);
2411         int ret;
2412
2413         ret = cdns_mhdp_update_link_status(mhdp);
2414         if (mhdp->connector.dev) {
2415                 if (ret < 0)
2416                         schedule_work(&mhdp->modeset_retry_work);
2417                 else
2418                         drm_kms_helper_hotplug_event(mhdp->bridge.dev);
2419         } else {
2420                 drm_bridge_hpd_notify(&mhdp->bridge, cdns_mhdp_detect(mhdp));
2421         }
2422 }
2423
2424 static int cdns_mhdp_probe(struct platform_device *pdev)
2425 {
2426         struct device *dev = &pdev->dev;
2427         struct cdns_mhdp_device *mhdp;
2428         unsigned long rate;
2429         struct clk *clk;
2430         int ret;
2431         int irq;
2432
2433         mhdp = devm_kzalloc(dev, sizeof(*mhdp), GFP_KERNEL);
2434         if (!mhdp)
2435                 return -ENOMEM;
2436
2437         clk = devm_clk_get(dev, NULL);
2438         if (IS_ERR(clk)) {
2439                 dev_err(dev, "couldn't get clk: %ld\n", PTR_ERR(clk));
2440                 return PTR_ERR(clk);
2441         }
2442
2443         mhdp->clk = clk;
2444         mhdp->dev = dev;
2445         mutex_init(&mhdp->mbox_mutex);
2446         mutex_init(&mhdp->link_mutex);
2447         spin_lock_init(&mhdp->start_lock);
2448
2449         drm_dp_aux_init(&mhdp->aux);
2450         mhdp->aux.dev = dev;
2451         mhdp->aux.transfer = cdns_mhdp_transfer;
2452
2453         mhdp->regs = devm_platform_ioremap_resource(pdev, 0);
2454         if (IS_ERR(mhdp->regs)) {
2455                 dev_err(dev, "Failed to get memory resource\n");
2456                 return PTR_ERR(mhdp->regs);
2457         }
2458
2459         mhdp->sapb_regs = devm_platform_ioremap_resource_byname(pdev, "mhdptx-sapb");
2460         if (IS_ERR(mhdp->sapb_regs)) {
2461                 mhdp->hdcp_supported = false;
2462                 dev_warn(dev,
2463                          "Failed to get SAPB memory resource, HDCP not supported\n");
2464         } else {
2465                 mhdp->hdcp_supported = true;
2466         }
2467
2468         mhdp->phy = devm_of_phy_get_by_index(dev, pdev->dev.of_node, 0);
2469         if (IS_ERR(mhdp->phy)) {
2470                 dev_err(dev, "no PHY configured\n");
2471                 return PTR_ERR(mhdp->phy);
2472         }
2473
2474         platform_set_drvdata(pdev, mhdp);
2475
2476         mhdp->info = of_device_get_match_data(dev);
2477
2478         clk_prepare_enable(clk);
2479
2480         pm_runtime_enable(dev);
2481         ret = pm_runtime_get_sync(dev);
2482         if (ret < 0) {
2483                 dev_err(dev, "pm_runtime_get_sync failed\n");
2484                 pm_runtime_disable(dev);
2485                 goto clk_disable;
2486         }
2487
2488         if (mhdp->info && mhdp->info->ops && mhdp->info->ops->init) {
2489                 ret = mhdp->info->ops->init(mhdp);
2490                 if (ret != 0) {
2491                         dev_err(dev, "MHDP platform initialization failed: %d\n",
2492                                 ret);
2493                         goto runtime_put;
2494                 }
2495         }
2496
2497         rate = clk_get_rate(clk);
2498         writel(rate % 1000000, mhdp->regs + CDNS_SW_CLK_L);
2499         writel(rate / 1000000, mhdp->regs + CDNS_SW_CLK_H);
2500
2501         dev_dbg(dev, "func clk rate %lu Hz\n", rate);
2502
2503         writel(~0, mhdp->regs + CDNS_APB_INT_MASK);
2504
2505         irq = platform_get_irq(pdev, 0);
2506         ret = devm_request_threaded_irq(mhdp->dev, irq, NULL,
2507                                         cdns_mhdp_irq_handler, IRQF_ONESHOT,
2508                                         "mhdp8546", mhdp);
2509         if (ret) {
2510                 dev_err(dev, "cannot install IRQ %d\n", irq);
2511                 ret = -EIO;
2512                 goto plat_fini;
2513         }
2514
2515         cdns_mhdp_fill_host_caps(mhdp);
2516
2517         /* Initialize link rate and num of lanes to host values */
2518         mhdp->link.rate = mhdp->host.link_rate;
2519         mhdp->link.num_lanes = mhdp->host.lanes_cnt;
2520
2521         /* The only currently supported format */
2522         mhdp->display_fmt.y_only = false;
2523         mhdp->display_fmt.color_format = DRM_COLOR_FORMAT_RGB444;
2524         mhdp->display_fmt.bpc = 8;
2525
2526         mhdp->bridge.of_node = pdev->dev.of_node;
2527         mhdp->bridge.funcs = &cdns_mhdp_bridge_funcs;
2528         mhdp->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID |
2529                            DRM_BRIDGE_OP_HPD;
2530         mhdp->bridge.type = DRM_MODE_CONNECTOR_DisplayPort;
2531         if (mhdp->info)
2532                 mhdp->bridge.timings = mhdp->info->timings;
2533
2534         ret = phy_init(mhdp->phy);
2535         if (ret) {
2536                 dev_err(mhdp->dev, "Failed to initialize PHY: %d\n", ret);
2537                 goto plat_fini;
2538         }
2539
2540         /* Initialize the work for modeset in case of link train failure */
2541         INIT_WORK(&mhdp->modeset_retry_work, cdns_mhdp_modeset_retry_fn);
2542         INIT_WORK(&mhdp->hpd_work, cdns_mhdp_hpd_work);
2543
2544         init_waitqueue_head(&mhdp->fw_load_wq);
2545         init_waitqueue_head(&mhdp->sw_events_wq);
2546
2547         ret = cdns_mhdp_load_firmware(mhdp);
2548         if (ret)
2549                 goto phy_exit;
2550
2551         if (mhdp->hdcp_supported)
2552                 cdns_mhdp_hdcp_init(mhdp);
2553
2554         drm_bridge_add(&mhdp->bridge);
2555
2556         return 0;
2557
2558 phy_exit:
2559         phy_exit(mhdp->phy);
2560 plat_fini:
2561         if (mhdp->info && mhdp->info->ops && mhdp->info->ops->exit)
2562                 mhdp->info->ops->exit(mhdp);
2563 runtime_put:
2564         pm_runtime_put_sync(dev);
2565         pm_runtime_disable(dev);
2566 clk_disable:
2567         clk_disable_unprepare(mhdp->clk);
2568
2569         return ret;
2570 }
2571
2572 static int cdns_mhdp_remove(struct platform_device *pdev)
2573 {
2574         struct cdns_mhdp_device *mhdp = platform_get_drvdata(pdev);
2575         unsigned long timeout = msecs_to_jiffies(100);
2576         bool stop_fw = false;
2577         int ret;
2578
2579         drm_bridge_remove(&mhdp->bridge);
2580
2581         ret = wait_event_timeout(mhdp->fw_load_wq,
2582                                  mhdp->hw_state == MHDP_HW_READY,
2583                                  timeout);
2584         if (ret == 0)
2585                 dev_err(mhdp->dev, "%s: Timeout waiting for fw loading\n",
2586                         __func__);
2587         else
2588                 stop_fw = true;
2589
2590         spin_lock(&mhdp->start_lock);
2591         mhdp->hw_state = MHDP_HW_STOPPED;
2592         spin_unlock(&mhdp->start_lock);
2593
2594         if (stop_fw)
2595                 ret = cdns_mhdp_set_firmware_active(mhdp, false);
2596
2597         phy_exit(mhdp->phy);
2598
2599         if (mhdp->info && mhdp->info->ops && mhdp->info->ops->exit)
2600                 mhdp->info->ops->exit(mhdp);
2601
2602         pm_runtime_put_sync(&pdev->dev);
2603         pm_runtime_disable(&pdev->dev);
2604
2605         cancel_work_sync(&mhdp->modeset_retry_work);
2606         flush_scheduled_work();
2607
2608         clk_disable_unprepare(mhdp->clk);
2609
2610         return ret;
2611 }
2612
2613 static const struct of_device_id mhdp_ids[] = {
2614         { .compatible = "cdns,mhdp8546", },
2615 #ifdef CONFIG_DRM_CDNS_MHDP8546_J721E
2616         { .compatible = "ti,j721e-mhdp8546",
2617           .data = &(const struct cdns_mhdp_platform_info) {
2618                   .timings = &mhdp_ti_j721e_bridge_timings,
2619                   .ops = &mhdp_ti_j721e_ops,
2620           },
2621         },
2622 #endif
2623         { /* sentinel */ }
2624 };
2625 MODULE_DEVICE_TABLE(of, mhdp_ids);
2626
2627 static struct platform_driver mhdp_driver = {
2628         .driver = {
2629                 .name           = "cdns-mhdp8546",
2630                 .of_match_table = of_match_ptr(mhdp_ids),
2631         },
2632         .probe  = cdns_mhdp_probe,
2633         .remove = cdns_mhdp_remove,
2634 };
2635 module_platform_driver(mhdp_driver);
2636
2637 MODULE_FIRMWARE(FW_NAME);
2638
2639 MODULE_AUTHOR("Quentin Schulz <quentin.schulz@free-electrons.com>");
2640 MODULE_AUTHOR("Swapnil Jakhade <sjakhade@cadence.com>");
2641 MODULE_AUTHOR("Yuti Amonkar <yamonkar@cadence.com>");
2642 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
2643 MODULE_AUTHOR("Jyri Sarha <jsarha@ti.com>");
2644 MODULE_DESCRIPTION("Cadence MHDP8546 DP bridge driver");
2645 MODULE_LICENSE("GPL");
2646 MODULE_ALIAS("platform:cdns-mhdp8546");