drivers/gpu/drm/bridge/analogix-anx78xx.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright(c) 2016, Analogix Semiconductor.
   4  *
   5  * Based on anx7808 driver obtained from chromeos with copyright:
   6  * Copyright(c) 2013, Google Inc.
   7  */
   8 #include <linux/delay.h>
   9 #include <linux/err.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/i2c.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/of_irq.h>
  16 #include <linux/of_platform.h>
  17 #include <linux/regmap.h>
  18 #include <linux/regulator/consumer.h>
  19 #include <linux/types.h>
  20
  21 #include <drm/drm_atomic_helper.h>
  22 #include <drm/drm_crtc.h>
  23 #include <drm/drm_dp_helper.h>
  24 #include <drm/drm_edid.h>
  25 #include <drm/drm_print.h>
  26 #include <drm/drm_probe_helper.h>
  27
  28 #include "analogix-anx78xx.h"
  29
  30 #define I2C_NUM_ADDRESSES       5
  31 #define I2C_IDX_TX_P0           0
  32 #define I2C_IDX_TX_P1           1
  33 #define I2C_IDX_TX_P2           2
  34 #define I2C_IDX_RX_P0           3
  35 #define I2C_IDX_RX_P1           4
  36
  37 #define XTAL_CLK                270 /* 27M */
  38 #define AUX_CH_BUFFER_SIZE      16
  39 #define AUX_WAIT_TIMEOUT_MS     15
  40
  41 static const u8 anx78xx_i2c_addresses[] = {
  42         [I2C_IDX_TX_P0] = TX_P0,
  43         [I2C_IDX_TX_P1] = TX_P1,
  44         [I2C_IDX_TX_P2] = TX_P2,
  45         [I2C_IDX_RX_P0] = RX_P0,
  46         [I2C_IDX_RX_P1] = RX_P1,
  47 };
  48
  49 struct anx78xx_platform_data {
  50         struct regulator *dvdd10;
  51         struct gpio_desc *gpiod_hpd;
  52         struct gpio_desc *gpiod_pd;
  53         struct gpio_desc *gpiod_reset;
  54
  55         int hpd_irq;
  56         int intp_irq;
  57 };
  58
  59 struct anx78xx {
  60         struct drm_dp_aux aux;
  61         struct drm_bridge bridge;
  62         struct i2c_client *client;
  63         struct edid *edid;
  64         struct drm_connector connector;
  65         struct drm_dp_link link;
  66         struct anx78xx_platform_data pdata;
  67         struct mutex lock;
  68
  69         /*
  70          * I2C Slave addresses of ANX7814 are mapped as TX_P0, TX_P1, TX_P2,
  71          * RX_P0 and RX_P1.
  72          */
  73         struct i2c_client *i2c_dummy[I2C_NUM_ADDRESSES];
  74         struct regmap *map[I2C_NUM_ADDRESSES];
  75
  76         u16 chipid;
  77         u8 dpcd[DP_RECEIVER_CAP_SIZE];
  78
  79         bool powered;
  80 };
  81
  82 static inline struct anx78xx *connector_to_anx78xx(struct drm_connector *c)
  83 {
  84         return container_of(c, struct anx78xx, connector);
  85 }
  86
  87 static inline struct anx78xx *bridge_to_anx78xx(struct drm_bridge *bridge)
  88 {
  89         return container_of(bridge, struct anx78xx, bridge);
  90 }
  91
  92 static int anx78xx_set_bits(struct regmap *map, u8 reg, u8 mask)
  93 {
  94         return regmap_update_bits(map, reg, mask, mask);
  95 }
  96
  97 static int anx78xx_clear_bits(struct regmap *map, u8 reg, u8 mask)
  98 {
  99         return regmap_update_bits(map, reg, mask, 0);
 100 }
 101
 102 static bool anx78xx_aux_op_finished(struct anx78xx *anx78xx)
 103 {
 104         unsigned int value;
 105         int err;
 106
 107         err = regmap_read(anx78xx->map[I2C_IDX_TX_P0], SP_DP_AUX_CH_CTRL2_REG,
 108                           &value);
 109         if (err < 0)
 110                 return false;
 111
 112         return (value & SP_AUX_EN) == 0;
 113 }
 114
 115 static int anx78xx_aux_wait(struct anx78xx *anx78xx)
 116 {
 117         unsigned long timeout;
 118         unsigned int status;
 119         int err;
 120
 121         timeout = jiffies + msecs_to_jiffies(AUX_WAIT_TIMEOUT_MS) + 1;
 122
 123         while (!anx78xx_aux_op_finished(anx78xx)) {
 124                 if (time_after(jiffies, timeout)) {
 125                         if (!anx78xx_aux_op_finished(anx78xx)) {
 126                                 DRM_ERROR("Timed out waiting AUX to finish\n");
 127                                 return -ETIMEDOUT;
 128                         }
 129
 130                         break;
 131                 }
 132
 133                 usleep_range(1000, 2000);
 134         }
 135
 136         /* Read the AUX channel access status */
 137         err = regmap_read(anx78xx->map[I2C_IDX_TX_P0], SP_AUX_CH_STATUS_REG,
 138                           &status);
 139         if (err < 0) {
 140                 DRM_ERROR("Failed to read from AUX channel: %d\n", err);
 141                 return err;
 142         }
 143
 144         if (status & SP_AUX_STATUS) {
 145                 DRM_ERROR("Failed to wait for AUX channel (status: %02x)\n",
 146                           status);
 147                 return -ETIMEDOUT;
 148         }
 149
 150         return 0;
 151 }
 152
 153 static int anx78xx_aux_address(struct anx78xx *anx78xx, unsigned int addr)
 154 {
 155         int err;
 156
 157         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_AUX_ADDR_7_0_REG,
 158                            addr & 0xff);
 159         if (err)
 160                 return err;
 161
 162         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_AUX_ADDR_15_8_REG,
 163                            (addr & 0xff00) >> 8);
 164         if (err)
 165                 return err;
 166
 167         /*
 168          * DP AUX CH Address Register #2, only update bits[3:0]
 169          * [7:4] RESERVED
 170          * [3:0] AUX_ADDR[19:16], Register control AUX CH address.
 171          */
 172         err = regmap_update_bits(anx78xx->map[I2C_IDX_TX_P0],
 173                                  SP_AUX_ADDR_19_16_REG,
 174                                  SP_AUX_ADDR_19_16_MASK,
 175                                  (addr & 0xf0000) >> 16);
 176
 177         if (err)
 178                 return err;
 179
 180         return 0;
 181 }
 182
 183 static ssize_t anx78xx_aux_transfer(struct drm_dp_aux *aux,
 184                                     struct drm_dp_aux_msg *msg)
 185 {
 186         struct anx78xx *anx78xx = container_of(aux, struct anx78xx, aux);
 187         u8 ctrl1 = msg->request;
 188         u8 ctrl2 = SP_AUX_EN;
 189         u8 *buffer = msg->buffer;
 190         int err;
 191
 192         /* The DP AUX transmit and receive buffer has 16 bytes. */
 193         if (WARN_ON(msg->size > AUX_CH_BUFFER_SIZE))
 194                 return -E2BIG;
 195
 196         /* Zero-sized messages specify address-only transactions. */
 197         if (msg->size < 1)
 198                 ctrl2 |= SP_ADDR_ONLY;
 199         else    /* For non-zero-sized set the length field. */
 200                 ctrl1 |= (msg->size - 1) << SP_AUX_LENGTH_SHIFT;
 201
 202         if ((msg->request & DP_AUX_I2C_READ) == 0) {
 203                 /* When WRITE | MOT write values to data buffer */
 204                 err = regmap_bulk_write(anx78xx->map[I2C_IDX_TX_P0],
 205                                         SP_DP_BUF_DATA0_REG, buffer,
 206                                         msg->size);
 207                 if (err)
 208                         return err;
 209         }
 210
 211         /* Write address and request */
 212         err = anx78xx_aux_address(anx78xx, msg->address);
 213         if (err)
 214                 return err;
 215
 216         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_DP_AUX_CH_CTRL1_REG,
 217                            ctrl1);
 218         if (err)
 219                 return err;
 220
 221         /* Start transaction */
 222         err = regmap_update_bits(anx78xx->map[I2C_IDX_TX_P0],
 223                                  SP_DP_AUX_CH_CTRL2_REG, SP_ADDR_ONLY |
 224                                  SP_AUX_EN, ctrl2);
 225         if (err)
 226                 return err;
 227
 228         err = anx78xx_aux_wait(anx78xx);
 229         if (err)
 230                 return err;
 231
 232         msg->reply = DP_AUX_I2C_REPLY_ACK;
 233
 234         if ((msg->size > 0) && (msg->request & DP_AUX_I2C_READ)) {
 235                 /* Read values from data buffer */
 236                 err = regmap_bulk_read(anx78xx->map[I2C_IDX_TX_P0],
 237                                        SP_DP_BUF_DATA0_REG, buffer,
 238                                        msg->size);
 239                 if (err)
 240                         return err;
 241         }
 242
 243         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P0],
 244                                  SP_DP_AUX_CH_CTRL2_REG, SP_ADDR_ONLY);
 245         if (err)
 246                 return err;
 247
 248         return msg->size;
 249 }
 250
 251 static int anx78xx_set_hpd(struct anx78xx *anx78xx)
 252 {
 253         int err;
 254
 255         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_RX_P0],
 256                                  SP_TMDS_CTRL_BASE + 7, SP_PD_RT);
 257         if (err)
 258                 return err;
 259
 260         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL3_REG,
 261                                SP_HPD_OUT);
 262         if (err)
 263                 return err;
 264
 265         return 0;
 266 }
 267
 268 static int anx78xx_clear_hpd(struct anx78xx *anx78xx)
 269 {
 270         int err;
 271
 272         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL3_REG,
 273                                  SP_HPD_OUT);
 274         if (err)
 275                 return err;
 276
 277         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0],
 278                                SP_TMDS_CTRL_BASE + 7, SP_PD_RT);
 279         if (err)
 280                 return err;
 281
 282         return 0;
 283 }
 284
 285 static const struct reg_sequence tmds_phy_initialization[] = {
 286         { SP_TMDS_CTRL_BASE +  1, 0x90 },
 287         { SP_TMDS_CTRL_BASE +  2, 0xa9 },
 288         { SP_TMDS_CTRL_BASE +  6, 0x92 },
 289         { SP_TMDS_CTRL_BASE +  7, 0x80 },
 290         { SP_TMDS_CTRL_BASE + 20, 0xf2 },
 291         { SP_TMDS_CTRL_BASE + 22, 0xc4 },
 292         { SP_TMDS_CTRL_BASE + 23, 0x18 },
 293 };
 294
 295 static int anx78xx_rx_initialization(struct anx78xx *anx78xx)
 296 {
 297         int err;
 298
 299         err = regmap_write(anx78xx->map[I2C_IDX_RX_P0], SP_HDMI_MUTE_CTRL_REG,
 300                            SP_AUD_MUTE | SP_VID_MUTE);
 301         if (err)
 302                 return err;
 303
 304         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0], SP_CHIP_CTRL_REG,
 305                                SP_MAN_HDMI5V_DET | SP_PLLLOCK_CKDT_EN |
 306                                SP_DIGITAL_CKDT_EN);
 307         if (err)
 308                 return err;
 309
 310         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0],
 311                                SP_SOFTWARE_RESET1_REG, SP_HDCP_MAN_RST |
 312                                SP_SW_MAN_RST | SP_TMDS_RST | SP_VIDEO_RST);
 313         if (err)
 314                 return err;
 315
 316         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_RX_P0],
 317                                  SP_SOFTWARE_RESET1_REG, SP_HDCP_MAN_RST |
 318                                  SP_SW_MAN_RST | SP_TMDS_RST | SP_VIDEO_RST);
 319         if (err)
 320                 return err;
 321
 322         /* Sync detect change, GP set mute */
 323         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0],
 324                                SP_AUD_EXCEPTION_ENABLE_BASE + 1, BIT(5) |
 325                                BIT(6));
 326         if (err)
 327                 return err;
 328
 329         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0],
 330                                SP_AUD_EXCEPTION_ENABLE_BASE + 3,
 331                                SP_AEC_EN21);
 332         if (err)
 333                 return err;
 334
 335         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0], SP_AUDVID_CTRL_REG,
 336                                SP_AVC_EN | SP_AAC_OE | SP_AAC_EN);
 337         if (err)
 338                 return err;
 339
 340         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_RX_P0],
 341                                  SP_SYSTEM_POWER_DOWN1_REG, SP_PWDN_CTRL);
 342         if (err)
 343                 return err;
 344
 345         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0],
 346                                SP_VID_DATA_RANGE_CTRL_REG, SP_R2Y_INPUT_LIMIT);
 347         if (err)
 348                 return err;
 349
 350         /* Enable DDC stretch */
 351         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
 352                            SP_DP_EXTRA_I2C_DEV_ADDR_REG, SP_I2C_EXTRA_ADDR);
 353         if (err)
 354                 return err;
 355
 356         /* TMDS phy initialization */
 357         err = regmap_multi_reg_write(anx78xx->map[I2C_IDX_RX_P0],
 358                                      tmds_phy_initialization,
 359                                      ARRAY_SIZE(tmds_phy_initialization));
 360         if (err)
 361                 return err;
 362
 363         err = anx78xx_clear_hpd(anx78xx);
 364         if (err)
 365                 return err;
 366
 367         return 0;
 368 }
 369
 370 static const u8 dp_tx_output_precise_tune_bits[20] = {
 371         0x01, 0x03, 0x07, 0x7f, 0x71, 0x6b, 0x7f,
 372         0x73, 0x7f, 0x7f, 0x00, 0x00, 0x00, 0x00,
 373         0x0c, 0x42, 0x1e, 0x3e, 0x72, 0x7e,
 374 };
 375
 376 static int anx78xx_link_phy_initialization(struct anx78xx *anx78xx)
 377 {
 378         int err;
 379
 380         /*
 381          * REVISIT : It is writing to a RESERVED bits in Analog Control 0
 382          * register.
 383          */
 384         err = regmap_write(anx78xx->map[I2C_IDX_TX_P2], SP_ANALOG_CTRL0_REG,
 385                            0x02);
 386         if (err)
 387                 return err;
 388
 389         /*
 390          * Write DP TX output emphasis precise tune bits.
 391          */
 392         err = regmap_bulk_write(anx78xx->map[I2C_IDX_TX_P1],
 393                                 SP_DP_TX_LT_CTRL0_REG,
 394                                 dp_tx_output_precise_tune_bits,
 395                                 ARRAY_SIZE(dp_tx_output_precise_tune_bits));
 396
 397         if (err)
 398                 return err;
 399
 400         return 0;
 401 }
 402
 403 static int anx78xx_xtal_clk_sel(struct anx78xx *anx78xx)
 404 {
 405         unsigned int value;
 406         int err;
 407
 408         err = regmap_update_bits(anx78xx->map[I2C_IDX_TX_P2],
 409                                  SP_ANALOG_DEBUG2_REG,
 410                                  SP_XTAL_FRQ | SP_FORCE_SW_OFF_BYPASS,
 411                                  SP_XTAL_FRQ_27M);
 412         if (err)
 413                 return err;
 414
 415         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_DP_AUX_CH_CTRL3_REG,
 416                            XTAL_CLK & SP_WAIT_COUNTER_7_0_MASK);
 417         if (err)
 418                 return err;
 419
 420         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_DP_AUX_CH_CTRL4_REG,
 421                            ((XTAL_CLK & 0xff00) >> 2) | (XTAL_CLK / 10));
 422         if (err)
 423                 return err;
 424
 425         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
 426                            SP_I2C_GEN_10US_TIMER0_REG, XTAL_CLK & 0xff);
 427         if (err)
 428                 return err;
 429
 430         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
 431                            SP_I2C_GEN_10US_TIMER1_REG,
 432                            (XTAL_CLK & 0xff00) >> 8);
 433         if (err)
 434                 return err;
 435
 436         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_AUX_MISC_CTRL_REG,
 437                            XTAL_CLK / 10 - 1);
 438         if (err)
 439                 return err;
 440
 441         err = regmap_read(anx78xx->map[I2C_IDX_RX_P0],
 442                           SP_HDMI_US_TIMER_CTRL_REG,
 443                           &value);
 444         if (err)
 445                 return err;
 446
 447         err = regmap_write(anx78xx->map[I2C_IDX_RX_P0],
 448                            SP_HDMI_US_TIMER_CTRL_REG,
 449                            (value & SP_MS_TIMER_MARGIN_10_8_MASK) |
 450                            ((((XTAL_CLK / 10) >> 1) - 2) << 3));
 451         if (err)
 452                 return err;
 453
 454         return 0;
 455 }
 456
 457 static const struct reg_sequence otp_key_protect[] = {
 458         { SP_OTP_KEY_PROTECT1_REG, SP_OTP_PSW1 },
 459         { SP_OTP_KEY_PROTECT2_REG, SP_OTP_PSW2 },
 460         { SP_OTP_KEY_PROTECT3_REG, SP_OTP_PSW3 },
 461 };
 462
 463 static int anx78xx_tx_initialization(struct anx78xx *anx78xx)
 464 {
 465         int err;
 466
 467         /* Set terminal resistor to 50 ohm */
 468         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_DP_AUX_CH_CTRL2_REG,
 469                            0x30);
 470         if (err)
 471                 return err;
 472
 473         /* Enable aux double diff output */
 474         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
 475                                SP_DP_AUX_CH_CTRL2_REG, 0x08);
 476         if (err)
 477                 return err;
 478
 479         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P0],
 480                                  SP_DP_HDCP_CTRL_REG, SP_AUTO_EN |
 481                                  SP_AUTO_START);
 482         if (err)
 483                 return err;
 484
 485         err = regmap_multi_reg_write(anx78xx->map[I2C_IDX_TX_P0],
 486                                      otp_key_protect,
 487                                      ARRAY_SIZE(otp_key_protect));
 488         if (err)
 489                 return err;
 490
 491         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
 492                                SP_HDCP_KEY_COMMAND_REG, SP_DISABLE_SYNC_HDCP);
 493         if (err)
 494                 return err;
 495
 496         err = regmap_write(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL8_REG,
 497                            SP_VID_VRES_TH);
 498         if (err)
 499                 return err;
 500
 501         /*
 502          * DP HDCP auto authentication wait timer (when downstream starts to
 503          * auth, DP side will wait for this period then do auth automatically)
 504          */
 505         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_HDCP_AUTO_TIMER_REG,
 506                            0x00);
 507         if (err)
 508                 return err;
 509
 510         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
 511                                SP_DP_HDCP_CTRL_REG, SP_LINK_POLLING);
 512         if (err)
 513                 return err;
 514
 515         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
 516                                SP_DP_LINK_DEBUG_CTRL_REG, SP_M_VID_DEBUG);
 517         if (err)
 518                 return err;
 519
 520         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2],
 521                                SP_ANALOG_DEBUG2_REG, SP_POWERON_TIME_1P5MS);
 522         if (err)
 523                 return err;
 524
 525         err = anx78xx_xtal_clk_sel(anx78xx);
 526         if (err)
 527                 return err;
 528
 529         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_AUX_DEFER_CTRL_REG,
 530                            SP_DEFER_CTRL_EN | 0x0c);
 531         if (err)
 532                 return err;
 533
 534         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
 535                                SP_DP_POLLING_CTRL_REG,
 536                                SP_AUTO_POLLING_DISABLE);
 537         if (err)
 538                 return err;
 539
 540         /*
 541          * Short the link integrity check timer to speed up bstatus
 542          * polling for HDCP CTS item 1A-07
 543          */
 544         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
 545                            SP_HDCP_LINK_CHECK_TIMER_REG, 0x1d);
 546         if (err)
 547                 return err;
 548
 549         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
 550                                SP_DP_MISC_CTRL_REG, SP_EQ_TRAINING_LOOP);
 551         if (err)
 552                 return err;
 553
 554         /* Power down the main link by default */
 555         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
 556                                SP_DP_ANALOG_POWER_DOWN_REG, SP_CH0_PD);
 557         if (err)
 558                 return err;
 559
 560         err = anx78xx_link_phy_initialization(anx78xx);
 561         if (err)
 562                 return err;
 563
 564         /* Gen m_clk with downspreading */
 565         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
 566                                SP_DP_M_CALCULATION_CTRL_REG, SP_M_GEN_CLK_SEL);
 567         if (err)
 568                 return err;
 569
 570         return 0;
 571 }
 572
 573 static int anx78xx_enable_interrupts(struct anx78xx *anx78xx)
 574 {
 575         int err;
 576
 577         /*
 578          * BIT0: INT pin assertion polarity: 1 = assert high
 579          * BIT1: INT pin output type: 0 = push/pull
 580          */
 581         err = regmap_write(anx78xx->map[I2C_IDX_TX_P2], SP_INT_CTRL_REG, 0x01);
 582         if (err)
 583                 return err;
 584
 585         err = regmap_write(anx78xx->map[I2C_IDX_TX_P2],
 586                            SP_COMMON_INT_MASK4_REG, SP_HPD_LOST | SP_HPD_PLUG);
 587         if (err)
 588                 return err;
 589
 590         err = regmap_write(anx78xx->map[I2C_IDX_TX_P2], SP_DP_INT_MASK1_REG,
 591                            SP_TRAINING_FINISH);
 592         if (err)
 593                 return err;
 594
 595         err = regmap_write(anx78xx->map[I2C_IDX_RX_P0], SP_INT_MASK1_REG,
 596                            SP_CKDT_CHG | SP_SCDT_CHG);
 597         if (err)
 598                 return err;
 599
 600         return 0;
 601 }
 602
 603 static void anx78xx_poweron(struct anx78xx *anx78xx)
 604 {
 605         struct anx78xx_platform_data *pdata = &anx78xx->pdata;
 606         int err;
 607
 608         if (WARN_ON(anx78xx->powered))
 609                 return;
 610
 611         if (pdata->dvdd10) {
 612                 err = regulator_enable(pdata->dvdd10);
 613                 if (err) {
 614                         DRM_ERROR("Failed to enable DVDD10 regulator: %d\n",
 615                                   err);
 616                         return;
 617                 }
 618
 619                 usleep_range(1000, 2000);
 620         }
 621
 622         gpiod_set_value_cansleep(pdata->gpiod_reset, 1);
 623         usleep_range(1000, 2000);
 624
 625         gpiod_set_value_cansleep(pdata->gpiod_pd, 0);
 626         usleep_range(1000, 2000);
 627
 628         gpiod_set_value_cansleep(pdata->gpiod_reset, 0);
 629
 630         /* Power on registers module */
 631         anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2], SP_POWERDOWN_CTRL_REG,
 632                          SP_HDCP_PD | SP_AUDIO_PD | SP_VIDEO_PD | SP_LINK_PD);
 633         anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2], SP_POWERDOWN_CTRL_REG,
 634                            SP_REGISTER_PD | SP_TOTAL_PD);
 635
 636         anx78xx->powered = true;
 637 }
 638
 639 static void anx78xx_poweroff(struct anx78xx *anx78xx)
 640 {
 641         struct anx78xx_platform_data *pdata = &anx78xx->pdata;
 642         int err;
 643
 644         if (WARN_ON(!anx78xx->powered))
 645                 return;
 646
 647         gpiod_set_value_cansleep(pdata->gpiod_reset, 1);
 648         usleep_range(1000, 2000);
 649
 650         gpiod_set_value_cansleep(pdata->gpiod_pd, 1);
 651         usleep_range(1000, 2000);
 652
 653         if (pdata->dvdd10) {
 654                 err = regulator_disable(pdata->dvdd10);
 655                 if (err) {
 656                         DRM_ERROR("Failed to disable DVDD10 regulator: %d\n",
 657                                   err);
 658                         return;
 659                 }
 660
 661                 usleep_range(1000, 2000);
 662         }
 663
 664         anx78xx->powered = false;
 665 }
 666
 667 static int anx78xx_start(struct anx78xx *anx78xx)
 668 {
 669         int err;
 670
 671         /* Power on all modules */
 672         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2],
 673                                  SP_POWERDOWN_CTRL_REG,
 674                                  SP_HDCP_PD | SP_AUDIO_PD | SP_VIDEO_PD |
 675                                  SP_LINK_PD);
 676
 677         err = anx78xx_enable_interrupts(anx78xx);
 678         if (err) {
 679                 DRM_ERROR("Failed to enable interrupts: %d\n", err);
 680                 goto err_poweroff;
 681         }
 682
 683         err = anx78xx_rx_initialization(anx78xx);
 684         if (err) {
 685                 DRM_ERROR("Failed receiver initialization: %d\n", err);
 686                 goto err_poweroff;
 687         }
 688
 689         err = anx78xx_tx_initialization(anx78xx);
 690         if (err) {
 691                 DRM_ERROR("Failed transmitter initialization: %d\n", err);
 692                 goto err_poweroff;
 693         }
 694
 695         /*
 696          * This delay seems to help keep the hardware in a good state. Without
 697          * it, there are times where it fails silently.
 698          */
 699         usleep_range(10000, 15000);
 700
 701         return 0;
 702
 703 err_poweroff:
 704         DRM_ERROR("Failed SlimPort transmitter initialization: %d\n", err);
 705         anx78xx_poweroff(anx78xx);
 706
 707         return err;
 708 }
 709
 710 static int anx78xx_init_pdata(struct anx78xx *anx78xx)
 711 {
 712         struct anx78xx_platform_data *pdata = &anx78xx->pdata;
 713         struct device *dev = &anx78xx->client->dev;
 714
 715         /* 1.0V digital core power regulator  */
 716         pdata->dvdd10 = devm_regulator_get(dev, "dvdd10");
 717         if (IS_ERR(pdata->dvdd10)) {
 718                 DRM_ERROR("DVDD10 regulator not found\n");
 719                 return PTR_ERR(pdata->dvdd10);
 720         }
 721
 722         /* GPIO for HPD */
 723         pdata->gpiod_hpd = devm_gpiod_get(dev, "hpd", GPIOD_IN);
 724         if (IS_ERR(pdata->gpiod_hpd))
 725                 return PTR_ERR(pdata->gpiod_hpd);
 726
 727         /* GPIO for chip power down */
 728         pdata->gpiod_pd = devm_gpiod_get(dev, "pd", GPIOD_OUT_HIGH);
 729         if (IS_ERR(pdata->gpiod_pd))
 730                 return PTR_ERR(pdata->gpiod_pd);
 731
 732         /* GPIO for chip reset */
 733         pdata->gpiod_reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
 734
 735         return PTR_ERR_OR_ZERO(pdata->gpiod_reset);
 736 }
 737
 738 static int anx78xx_dp_link_training(struct anx78xx *anx78xx)
 739 {
 740         u8 dp_bw, value;
 741         int err;
 742
 743         err = regmap_write(anx78xx->map[I2C_IDX_RX_P0], SP_HDMI_MUTE_CTRL_REG,
 744                            0x0);
 745         if (err)
 746                 return err;
 747
 748         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2],
 749                                  SP_POWERDOWN_CTRL_REG,
 750                                  SP_TOTAL_PD);
 751         if (err)
 752                 return err;
 753
 754         err = drm_dp_dpcd_readb(&anx78xx->aux, DP_MAX_LINK_RATE, &dp_bw);
 755         if (err < 0)
 756                 return err;
 757
 758         switch (dp_bw) {
 759         case DP_LINK_BW_1_62:
 760         case DP_LINK_BW_2_7:
 761         case DP_LINK_BW_5_4:
 762                 break;
 763
 764         default:
 765                 DRM_DEBUG_KMS("DP bandwidth (%#02x) not supported\n", dp_bw);
 766                 return -EINVAL;
 767         }
 768
 769         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL1_REG,
 770                                SP_VIDEO_MUTE);
 771         if (err)
 772                 return err;
 773
 774         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2],
 775                                  SP_VID_CTRL1_REG, SP_VIDEO_EN);
 776         if (err)
 777                 return err;
 778
 779         /* Get DPCD info */
 780         err = drm_dp_dpcd_read(&anx78xx->aux, DP_DPCD_REV,
 781                                &anx78xx->dpcd, DP_RECEIVER_CAP_SIZE);
 782         if (err < 0) {
 783                 DRM_ERROR("Failed to read DPCD: %d\n", err);
 784                 return err;
 785         }
 786
 787         /* Clear channel x SERDES power down */
 788         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P0],
 789                                  SP_DP_ANALOG_POWER_DOWN_REG, SP_CH0_PD);
 790         if (err)
 791                 return err;
 792
 793         /* Check link capabilities */
 794         err = drm_dp_link_probe(&anx78xx->aux, &anx78xx->link);
 795         if (err < 0) {
 796                 DRM_ERROR("Failed to probe link capabilities: %d\n", err);
 797                 return err;
 798         }
 799
 800         /* Power up the sink */
 801         err = drm_dp_link_power_up(&anx78xx->aux, &anx78xx->link);
 802         if (err < 0) {
 803                 DRM_ERROR("Failed to power up DisplayPort link: %d\n", err);
 804                 return err;
 805         }
 806
 807         /* Possibly enable downspread on the sink */
 808         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
 809                            SP_DP_DOWNSPREAD_CTRL1_REG, 0);
 810         if (err)
 811                 return err;
 812
 813         if (anx78xx->dpcd[DP_MAX_DOWNSPREAD] & DP_MAX_DOWNSPREAD_0_5) {
 814                 DRM_DEBUG("Enable downspread on the sink\n");
 815                 /* 4000PPM */
 816                 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
 817                                    SP_DP_DOWNSPREAD_CTRL1_REG, 8);
 818                 if (err)
 819                         return err;
 820
 821                 err = drm_dp_dpcd_writeb(&anx78xx->aux, DP_DOWNSPREAD_CTRL,
 822                                          DP_SPREAD_AMP_0_5);
 823                 if (err < 0)
 824                         return err;
 825         } else {
 826                 err = drm_dp_dpcd_writeb(&anx78xx->aux, DP_DOWNSPREAD_CTRL, 0);
 827                 if (err < 0)
 828                         return err;
 829         }
 830
 831         /* Set the lane count and the link rate on the sink */
 832         if (drm_dp_enhanced_frame_cap(anx78xx->dpcd))
 833                 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
 834                                        SP_DP_SYSTEM_CTRL_BASE + 4,
 835                                        SP_ENHANCED_MODE);
 836         else
 837                 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P0],
 838                                          SP_DP_SYSTEM_CTRL_BASE + 4,
 839                                          SP_ENHANCED_MODE);
 840         if (err)
 841                 return err;
 842
 843         value = drm_dp_link_rate_to_bw_code(anx78xx->link.rate);
 844         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
 845                            SP_DP_MAIN_LINK_BW_SET_REG, value);
 846         if (err)
 847                 return err;
 848
 849         err = drm_dp_link_configure(&anx78xx->aux, &anx78xx->link);
 850         if (err < 0) {
 851                 DRM_ERROR("Failed to configure DisplayPort link: %d\n", err);
 852                 return err;
 853         }
 854
 855         /* Start training on the source */
 856         err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_DP_LT_CTRL_REG,
 857                            SP_LT_EN);
 858         if (err)
 859                 return err;
 860
 861         return 0;
 862 }
 863
 864 static int anx78xx_config_dp_output(struct anx78xx *anx78xx)
 865 {
 866         int err;
 867
 868         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL1_REG,
 869                                  SP_VIDEO_MUTE);
 870         if (err)
 871                 return err;
 872
 873         /* Enable DP output */
 874         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL1_REG,
 875                                SP_VIDEO_EN);
 876         if (err)
 877                 return err;
 878
 879         return 0;
 880 }
 881
 882 static int anx78xx_send_video_infoframe(struct anx78xx *anx78xx,
 883                                         struct hdmi_avi_infoframe *frame)
 884 {
 885         u8 buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AVI_INFOFRAME_SIZE];
 886         int err;
 887
 888         err = hdmi_avi_infoframe_pack(frame, buffer, sizeof(buffer));
 889         if (err < 0) {
 890                 DRM_ERROR("Failed to pack AVI infoframe: %d\n", err);
 891                 return err;
 892         }
 893
 894         err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P0],
 895                                  SP_PACKET_SEND_CTRL_REG, SP_AVI_IF_EN);
 896         if (err)
 897                 return err;
 898
 899         err = regmap_bulk_write(anx78xx->map[I2C_IDX_TX_P2],
 900                                 SP_INFOFRAME_AVI_DB1_REG, buffer,
 901                                 frame->length);
 902         if (err)
 903                 return err;
 904
 905         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
 906                                SP_PACKET_SEND_CTRL_REG, SP_AVI_IF_UD);
 907         if (err)
 908                 return err;
 909
 910         err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
 911                                SP_PACKET_SEND_CTRL_REG, SP_AVI_IF_EN);
 912         if (err)
 913                 return err;
 914
 915         return 0;
 916 }
 917
 918 static int anx78xx_get_downstream_info(struct anx78xx *anx78xx)
 919 {
 920         u8 value;
 921         int err;
 922
 923         err = drm_dp_dpcd_readb(&anx78xx->aux, DP_SINK_COUNT, &value);
 924         if (err < 0) {
 925                 DRM_ERROR("Get sink count failed %d\n", err);
 926                 return err;
 927         }
 928
 929         if (!DP_GET_SINK_COUNT(value)) {
 930                 DRM_ERROR("Downstream disconnected\n");
 931                 return -EIO;
 932         }
 933
 934         return 0;
 935 }
 936
 937 static int anx78xx_get_modes(struct drm_connector *connector)
 938 {
 939         struct anx78xx *anx78xx = connector_to_anx78xx(connector);
 940         int err, num_modes = 0;
 941
 942         if (WARN_ON(!anx78xx->powered))
 943                 return 0;
 944
 945         if (anx78xx->edid)
 946                 return drm_add_edid_modes(connector, anx78xx->edid);
 947
 948         mutex_lock(&anx78xx->lock);
 949
 950         err = anx78xx_get_downstream_info(anx78xx);
 951         if (err) {
 952                 DRM_ERROR("Failed to get downstream info: %d\n", err);
 953                 goto unlock;
 954         }
 955
 956         anx78xx->edid = drm_get_edid(connector, &anx78xx->aux.ddc);
 957         if (!anx78xx->edid) {
 958                 DRM_ERROR("Failed to read EDID\n");
 959                 goto unlock;
 960         }
 961
 962         err = drm_connector_update_edid_property(connector,
 963                                                  anx78xx->edid);
 964         if (err) {
 965                 DRM_ERROR("Failed to update EDID property: %d\n", err);
 966                 goto unlock;
 967         }
 968
 969         num_modes = drm_add_edid_modes(connector, anx78xx->edid);
 970
 971 unlock:
 972         mutex_unlock(&anx78xx->lock);
 973
 974         return num_modes;
 975 }
 976
 977 static const struct drm_connector_helper_funcs anx78xx_connector_helper_funcs = {
 978         .get_modes = anx78xx_get_modes,
 979 };
 980
 981 static enum drm_connector_status anx78xx_detect(struct drm_connector *connector,
 982                                                 bool force)
 983 {
 984         struct anx78xx *anx78xx = connector_to_anx78xx(connector);
 985
 986         if (!gpiod_get_value(anx78xx->pdata.gpiod_hpd))
 987                 return connector_status_disconnected;
 988
 989         return connector_status_connected;
 990 }
 991
 992 static const struct drm_connector_funcs anx78xx_connector_funcs = {
 993         .fill_modes = drm_helper_probe_single_connector_modes,
 994         .detect = anx78xx_detect,
 995         .destroy = drm_connector_cleanup,
 996         .reset = drm_atomic_helper_connector_reset,
 997         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 998         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 999 };
1000
1001 static int anx78xx_bridge_attach(struct drm_bridge *bridge)
1002 {
1003         struct anx78xx *anx78xx = bridge_to_anx78xx(bridge);
1004         int err;
1005
1006         if (!bridge->encoder) {
1007                 DRM_ERROR("Parent encoder object not found");
1008                 return -ENODEV;
1009         }
1010
1011         /* Register aux channel */
1012         anx78xx->aux.name = "DP-AUX";
1013         anx78xx->aux.dev = &anx78xx->client->dev;
1014         anx78xx->aux.transfer = anx78xx_aux_transfer;
1015
1016         err = drm_dp_aux_register(&anx78xx->aux);
1017         if (err < 0) {
1018                 DRM_ERROR("Failed to register aux channel: %d\n", err);
1019                 return err;
1020         }
1021
1022         err = drm_connector_init(bridge->dev, &anx78xx->connector,
1023                                  &anx78xx_connector_funcs,
1024                                  DRM_MODE_CONNECTOR_DisplayPort);
1025         if (err) {
1026                 DRM_ERROR("Failed to initialize connector: %d\n", err);
1027                 return err;
1028         }
1029
1030         drm_connector_helper_add(&anx78xx->connector,
1031                                  &anx78xx_connector_helper_funcs);
1032
1033         err = drm_connector_register(&anx78xx->connector);
1034         if (err) {
1035                 DRM_ERROR("Failed to register connector: %d\n", err);
1036                 return err;
1037         }
1038
1039         anx78xx->connector.polled = DRM_CONNECTOR_POLL_HPD;
1040
1041         err = drm_connector_attach_encoder(&anx78xx->connector,
1042                                            bridge->encoder);
1043         if (err) {
1044                 DRM_ERROR("Failed to link up connector to encoder: %d\n", err);
1045                 return err;
1046         }
1047
1048         return 0;
1049 }
1050
1051 static enum drm_mode_status
1052 anx78xx_bridge_mode_valid(struct drm_bridge *bridge,
1053                           const struct drm_display_mode *mode)
1054 {
1055         if (mode->flags & DRM_MODE_FLAG_INTERLACE)
1056                 return MODE_NO_INTERLACE;
1057
1058         /* Max 1200p at 5.4 Ghz, one lane */
1059         if (mode->clock > 154000)
1060                 return MODE_CLOCK_HIGH;
1061
1062         return MODE_OK;
1063 }
1064
1065 static void anx78xx_bridge_disable(struct drm_bridge *bridge)
1066 {
1067         struct anx78xx *anx78xx = bridge_to_anx78xx(bridge);
1068
1069         /* Power off all modules except configuration registers access */
1070         anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2], SP_POWERDOWN_CTRL_REG,
1071                          SP_HDCP_PD | SP_AUDIO_PD | SP_VIDEO_PD | SP_LINK_PD);
1072 }
1073
1074 static void anx78xx_bridge_mode_set(struct drm_bridge *bridge,
1075                                 const struct drm_display_mode *mode,
1076                                 const struct drm_display_mode *adjusted_mode)
1077 {
1078         struct anx78xx *anx78xx = bridge_to_anx78xx(bridge);
1079         struct hdmi_avi_infoframe frame;
1080         int err;
1081
1082         if (WARN_ON(!anx78xx->powered))
1083                 return;
1084
1085         mutex_lock(&anx78xx->lock);
1086
1087         err = drm_hdmi_avi_infoframe_from_display_mode(&frame,
1088                                                        &anx78xx->connector,
1089                                                        adjusted_mode);
1090         if (err) {
1091                 DRM_ERROR("Failed to setup AVI infoframe: %d\n", err);
1092                 goto unlock;
1093         }
1094
1095         err = anx78xx_send_video_infoframe(anx78xx, &frame);
1096         if (err)
1097                 DRM_ERROR("Failed to send AVI infoframe: %d\n", err);
1098
1099 unlock:
1100         mutex_unlock(&anx78xx->lock);
1101 }
1102
1103 static void anx78xx_bridge_enable(struct drm_bridge *bridge)
1104 {
1105         struct anx78xx *anx78xx = bridge_to_anx78xx(bridge);
1106         int err;
1107
1108         err = anx78xx_start(anx78xx);
1109         if (err) {
1110                 DRM_ERROR("Failed to initialize: %d\n", err);
1111                 return;
1112         }
1113
1114         err = anx78xx_set_hpd(anx78xx);
1115         if (err)
1116                 DRM_ERROR("Failed to set HPD: %d\n", err);
1117 }
1118
1119 static const struct drm_bridge_funcs anx78xx_bridge_funcs = {
1120         .attach = anx78xx_bridge_attach,
1121         .mode_valid = anx78xx_bridge_mode_valid,
1122         .disable = anx78xx_bridge_disable,
1123         .mode_set = anx78xx_bridge_mode_set,
1124         .enable = anx78xx_bridge_enable,
1125 };
1126
1127 static irqreturn_t anx78xx_hpd_threaded_handler(int irq, void *data)
1128 {
1129         struct anx78xx *anx78xx = data;
1130         int err;
1131
1132         if (anx78xx->powered)
1133                 return IRQ_HANDLED;
1134
1135         mutex_lock(&anx78xx->lock);
1136
1137         /* Cable is pulled, power on the chip */
1138         anx78xx_poweron(anx78xx);
1139
1140         err = anx78xx_enable_interrupts(anx78xx);
1141         if (err)
1142                 DRM_ERROR("Failed to enable interrupts: %d\n", err);
1143
1144         mutex_unlock(&anx78xx->lock);
1145
1146         return IRQ_HANDLED;
1147 }
1148
1149 static int anx78xx_handle_dp_int_1(struct anx78xx *anx78xx, u8 irq)
1150 {
1151         int err;
1152
1153         DRM_DEBUG_KMS("Handle DP interrupt 1: %02x\n", irq);
1154
1155         err = regmap_write(anx78xx->map[I2C_IDX_TX_P2], SP_DP_INT_STATUS1_REG,
1156                            irq);
1157         if (err)
1158                 return err;
1159
1160         if (irq & SP_TRAINING_FINISH) {
1161                 DRM_DEBUG_KMS("IRQ: hardware link training finished\n");
1162                 err = anx78xx_config_dp_output(anx78xx);
1163         }
1164
1165         return err;
1166 }
1167
1168 static bool anx78xx_handle_common_int_4(struct anx78xx *anx78xx, u8 irq)
1169 {
1170         bool event = false;
1171         int err;
1172
1173         DRM_DEBUG_KMS("Handle common interrupt 4: %02x\n", irq);
1174
1175         err = regmap_write(anx78xx->map[I2C_IDX_TX_P2],
1176                            SP_COMMON_INT_STATUS4_REG, irq);
1177         if (err) {
1178                 DRM_ERROR("Failed to write SP_COMMON_INT_STATUS4 %d\n", err);
1179                 return event;
1180         }
1181
1182         if (irq & SP_HPD_LOST) {
1183                 DRM_DEBUG_KMS("IRQ: Hot plug detect - cable is pulled out\n");
1184                 event = true;
1185                 anx78xx_poweroff(anx78xx);
1186                 /* Free cached EDID */
1187                 kfree(anx78xx->edid);
1188                 anx78xx->edid = NULL;
1189         } else if (irq & SP_HPD_PLUG) {
1190                 DRM_DEBUG_KMS("IRQ: Hot plug detect - cable plug\n");
1191                 event = true;
1192         }
1193
1194         return event;
1195 }
1196
1197 static void anx78xx_handle_hdmi_int_1(struct anx78xx *anx78xx, u8 irq)
1198 {
1199         unsigned int value;
1200         int err;
1201
1202         DRM_DEBUG_KMS("Handle HDMI interrupt 1: %02x\n", irq);
1203
1204         err = regmap_write(anx78xx->map[I2C_IDX_RX_P0], SP_INT_STATUS1_REG,
1205                            irq);
1206         if (err) {
1207                 DRM_ERROR("Write HDMI int 1 failed: %d\n", err);
1208                 return;
1209         }
1210
1211         if ((irq & SP_CKDT_CHG) || (irq & SP_SCDT_CHG)) {
1212                 DRM_DEBUG_KMS("IRQ: HDMI input detected\n");
1213
1214                 err = regmap_read(anx78xx->map[I2C_IDX_RX_P0],
1215                                   SP_SYSTEM_STATUS_REG, &value);
1216                 if (err) {
1217                         DRM_ERROR("Read system status reg failed: %d\n", err);
1218                         return;
1219                 }
1220
1221                 if (!(value & SP_TMDS_CLOCK_DET)) {
1222                         DRM_DEBUG_KMS("IRQ: *** Waiting for HDMI clock ***\n");
1223                         return;
1224                 }
1225
1226                 if (!(value & SP_TMDS_DE_DET)) {
1227                         DRM_DEBUG_KMS("IRQ: *** Waiting for HDMI signal ***\n");
1228                         return;
1229                 }
1230
1231                 err = anx78xx_dp_link_training(anx78xx);
1232                 if (err)
1233                         DRM_ERROR("Failed to start link training: %d\n", err);
1234         }
1235 }
1236
1237 static irqreturn_t anx78xx_intp_threaded_handler(int unused, void *data)
1238 {
1239         struct anx78xx *anx78xx = data;
1240         bool event = false;
1241         unsigned int irq;
1242         int err;
1243
1244         mutex_lock(&anx78xx->lock);
1245
1246         err = regmap_read(anx78xx->map[I2C_IDX_TX_P2], SP_DP_INT_STATUS1_REG,
1247                           &irq);
1248         if (err) {
1249                 DRM_ERROR("Failed to read DP interrupt 1 status: %d\n", err);
1250                 goto unlock;
1251         }
1252
1253         if (irq)
1254                 anx78xx_handle_dp_int_1(anx78xx, irq);
1255
1256         err = regmap_read(anx78xx->map[I2C_IDX_TX_P2],
1257                           SP_COMMON_INT_STATUS4_REG, &irq);
1258         if (err) {
1259                 DRM_ERROR("Failed to read common interrupt 4 status: %d\n",
1260                           err);
1261                 goto unlock;
1262         }
1263
1264         if (irq)
1265                 event = anx78xx_handle_common_int_4(anx78xx, irq);
1266
1267         /* Make sure we are still powered after handle HPD events */
1268         if (!anx78xx->powered)
1269                 goto unlock;
1270
1271         err = regmap_read(anx78xx->map[I2C_IDX_RX_P0], SP_INT_STATUS1_REG,
1272                           &irq);
1273         if (err) {
1274                 DRM_ERROR("Failed to read HDMI int 1 status: %d\n", err);
1275                 goto unlock;
1276         }
1277
1278         if (irq)
1279                 anx78xx_handle_hdmi_int_1(anx78xx, irq);
1280
1281 unlock:
1282         mutex_unlock(&anx78xx->lock);
1283
1284         if (event)
1285                 drm_helper_hpd_irq_event(anx78xx->connector.dev);
1286
1287         return IRQ_HANDLED;
1288 }
1289
1290 static void unregister_i2c_dummy_clients(struct anx78xx *anx78xx)
1291 {
1292         unsigned int i;
1293
1294         for (i = 0; i < ARRAY_SIZE(anx78xx->i2c_dummy); i++)
1295                 i2c_unregister_device(anx78xx->i2c_dummy[i]);
1296 }
1297
1298 static const struct regmap_config anx78xx_regmap_config = {
1299         .reg_bits = 8,
1300         .val_bits = 8,
1301 };
1302
1303 static const u16 anx78xx_chipid_list[] = {
1304         0x7812,
1305         0x7814,
1306         0x7818,
1307 };
1308
1309 static int anx78xx_i2c_probe(struct i2c_client *client,
1310                              const struct i2c_device_id *id)
1311 {
1312         struct anx78xx *anx78xx;
1313         struct anx78xx_platform_data *pdata;
1314         unsigned int i, idl, idh, version;
1315         bool found = false;
1316         int err;
1317
1318         anx78xx = devm_kzalloc(&client->dev, sizeof(*anx78xx), GFP_KERNEL);
1319         if (!anx78xx)
1320                 return -ENOMEM;
1321
1322         pdata = &anx78xx->pdata;
1323
1324         mutex_init(&anx78xx->lock);
1325
1326 #if IS_ENABLED(CONFIG_OF)
1327         anx78xx->bridge.of_node = client->dev.of_node;
1328 #endif
1329
1330         anx78xx->client = client;
1331         i2c_set_clientdata(client, anx78xx);
1332
1333         err = anx78xx_init_pdata(anx78xx);
1334         if (err) {
1335                 DRM_ERROR("Failed to initialize pdata: %d\n", err);
1336                 return err;
1337         }
1338
1339         pdata->hpd_irq = gpiod_to_irq(pdata->gpiod_hpd);
1340         if (pdata->hpd_irq < 0) {
1341                 DRM_ERROR("Failed to get HPD IRQ: %d\n", pdata->hpd_irq);
1342                 return -ENODEV;
1343         }
1344
1345         pdata->intp_irq = client->irq;
1346         if (!pdata->intp_irq) {
1347                 DRM_ERROR("Failed to get CABLE_DET and INTP IRQ\n");
1348                 return -ENODEV;
1349         }
1350
1351         /* Map slave addresses of ANX7814 */
1352         for (i = 0; i < I2C_NUM_ADDRESSES; i++) {
1353                 anx78xx->i2c_dummy[i] = i2c_new_dummy(client->adapter,
1354                                                 anx78xx_i2c_addresses[i] >> 1);
1355                 if (!anx78xx->i2c_dummy[i]) {
1356                         err = -ENOMEM;
1357                         DRM_ERROR("Failed to reserve I2C bus %02x\n",
1358                                   anx78xx_i2c_addresses[i]);
1359                         goto err_unregister_i2c;
1360                 }
1361
1362                 anx78xx->map[i] = devm_regmap_init_i2c(anx78xx->i2c_dummy[i],
1363                                                        &anx78xx_regmap_config);
1364                 if (IS_ERR(anx78xx->map[i])) {
1365                         err = PTR_ERR(anx78xx->map[i]);
1366                         DRM_ERROR("Failed regmap initialization %02x\n",
1367                                   anx78xx_i2c_addresses[i]);
1368                         goto err_unregister_i2c;
1369                 }
1370         }
1371
1372         /* Look for supported chip ID */
1373         anx78xx_poweron(anx78xx);
1374
1375         err = regmap_read(anx78xx->map[I2C_IDX_TX_P2], SP_DEVICE_IDL_REG,
1376                           &idl);
1377         if (err)
1378                 goto err_poweroff;
1379
1380         err = regmap_read(anx78xx->map[I2C_IDX_TX_P2], SP_DEVICE_IDH_REG,
1381                           &idh);
1382         if (err)
1383                 goto err_poweroff;
1384
1385         anx78xx->chipid = (u8)idl | ((u8)idh << 8);
1386
1387         err = regmap_read(anx78xx->map[I2C_IDX_TX_P2], SP_DEVICE_VERSION_REG,
1388                           &version);
1389         if (err)
1390                 goto err_poweroff;
1391
1392         for (i = 0; i < ARRAY_SIZE(anx78xx_chipid_list); i++) {
1393                 if (anx78xx->chipid == anx78xx_chipid_list[i]) {
1394                         DRM_INFO("Found ANX%x (ver. %d) SlimPort Transmitter\n",
1395                                  anx78xx->chipid, version);
1396                         found = true;
1397                         break;
1398                 }
1399         }
1400
1401         if (!found) {
1402                 DRM_ERROR("ANX%x (ver. %d) not supported by this driver\n",
1403                           anx78xx->chipid, version);
1404                 err = -ENODEV;
1405                 goto err_poweroff;
1406         }
1407
1408         err = devm_request_threaded_irq(&client->dev, pdata->hpd_irq, NULL,
1409                                         anx78xx_hpd_threaded_handler,
1410                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1411                                         "anx78xx-hpd", anx78xx);
1412         if (err) {
1413                 DRM_ERROR("Failed to request CABLE_DET threaded IRQ: %d\n",
1414                           err);
1415                 goto err_poweroff;
1416         }
1417
1418         err = devm_request_threaded_irq(&client->dev, pdata->intp_irq, NULL,
1419                                         anx78xx_intp_threaded_handler,
1420                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1421                                         "anx78xx-intp", anx78xx);
1422         if (err) {
1423                 DRM_ERROR("Failed to request INTP threaded IRQ: %d\n", err);
1424                 goto err_poweroff;
1425         }
1426
1427         anx78xx->bridge.funcs = &anx78xx_bridge_funcs;
1428
1429         drm_bridge_add(&anx78xx->bridge);
1430
1431         /* If cable is pulled out, just poweroff and wait for HPD event */
1432         if (!gpiod_get_value(anx78xx->pdata.gpiod_hpd))
1433                 anx78xx_poweroff(anx78xx);
1434
1435         return 0;
1436
1437 err_poweroff:
1438         anx78xx_poweroff(anx78xx);
1439
1440 err_unregister_i2c:
1441         unregister_i2c_dummy_clients(anx78xx);
1442         return err;
1443 }
1444
1445 static int anx78xx_i2c_remove(struct i2c_client *client)
1446 {
1447         struct anx78xx *anx78xx = i2c_get_clientdata(client);
1448
1449         drm_bridge_remove(&anx78xx->bridge);
1450
1451         unregister_i2c_dummy_clients(anx78xx);
1452
1453         kfree(anx78xx->edid);
1454
1455         return 0;
1456 }
1457
1458 static const struct i2c_device_id anx78xx_id[] = {
1459         { "anx7814", 0 },
1460         { /* sentinel */ }
1461 };
1462 MODULE_DEVICE_TABLE(i2c, anx78xx_id);
1463
1464 #if IS_ENABLED(CONFIG_OF)
1465 static const struct of_device_id anx78xx_match_table[] = {
1466         { .compatible = "analogix,anx7814", },
1467         { /* sentinel */ },
1468 };
1469 MODULE_DEVICE_TABLE(of, anx78xx_match_table);
1470 #endif
1471
1472 static struct i2c_driver anx78xx_driver = {
1473         .driver = {
1474                    .name = "anx7814",
1475                    .of_match_table = of_match_ptr(anx78xx_match_table),
1476                   },
1477         .probe = anx78xx_i2c_probe,
1478         .remove = anx78xx_i2c_remove,
1479         .id_table = anx78xx_id,
1480 };
1481 module_i2c_driver(anx78xx_driver);
1482
1483 MODULE_DESCRIPTION("ANX78xx SlimPort Transmitter driver");
1484 MODULE_AUTHOR("Enric Balletbo i Serra <enric.balletbo@collabora.com>");
1485 MODULE_LICENSE("GPL v2");