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