1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2020 BayLibre, SAS 4 * Author: Phong LE <ple@baylibre.com> 5 * Copyright (C) 2018-2019, Artem Mygaiev 6 * Copyright (C) 2017, Fresco Logic, Incorporated. 7 * 8 */ 9 10 #include <linux/module.h> 11 #include <linux/device.h> 12 #include <linux/interrupt.h> 13 #include <linux/i2c.h> 14 #include <linux/bitfield.h> 15 #include <linux/property.h> 16 #include <linux/regmap.h> 17 #include <linux/of_graph.h> 18 #include <linux/gpio/consumer.h> 19 #include <linux/pinctrl/consumer.h> 20 #include <linux/regulator/consumer.h> 21 22 #include <drm/drm_atomic_helper.h> 23 #include <drm/drm_bridge.h> 24 #include <drm/drm_crtc_helper.h> 25 #include <drm/drm_edid.h> 26 #include <drm/drm_modes.h> 27 #include <drm/drm_print.h> 28 #include <drm/drm_probe_helper.h> 29 30 #define IT66121_VENDOR_ID0_REG 0x00 31 #define IT66121_VENDOR_ID1_REG 0x01 32 #define IT66121_DEVICE_ID0_REG 0x02 33 #define IT66121_DEVICE_ID1_REG 0x03 34 35 #define IT66121_VENDOR_ID0 0x54 36 #define IT66121_VENDOR_ID1 0x49 37 #define IT66121_DEVICE_ID0 0x12 38 #define IT66121_DEVICE_ID1 0x06 39 #define IT66121_REVISION_MASK GENMASK(7, 4) 40 #define IT66121_DEVICE_ID1_MASK GENMASK(3, 0) 41 42 #define IT66121_MASTER_SEL_REG 0x10 43 #define IT66121_MASTER_SEL_HOST BIT(0) 44 45 #define IT66121_AFE_DRV_REG 0x61 46 #define IT66121_AFE_DRV_RST BIT(4) 47 #define IT66121_AFE_DRV_PWD BIT(5) 48 49 #define IT66121_INPUT_MODE_REG 0x70 50 #define IT66121_INPUT_MODE_RGB (0 << 6) 51 #define IT66121_INPUT_MODE_YUV422 BIT(6) 52 #define IT66121_INPUT_MODE_YUV444 (2 << 6) 53 #define IT66121_INPUT_MODE_CCIR656 BIT(4) 54 #define IT66121_INPUT_MODE_SYNCEMB BIT(3) 55 #define IT66121_INPUT_MODE_DDR BIT(2) 56 57 #define IT66121_INPUT_CSC_REG 0x72 58 #define IT66121_INPUT_CSC_ENDITHER BIT(7) 59 #define IT66121_INPUT_CSC_ENUDFILTER BIT(6) 60 #define IT66121_INPUT_CSC_DNFREE_GO BIT(5) 61 #define IT66121_INPUT_CSC_RGB_TO_YUV 0x02 62 #define IT66121_INPUT_CSC_YUV_TO_RGB 0x03 63 #define IT66121_INPUT_CSC_NO_CONV 0x00 64 65 #define IT66121_AFE_XP_REG 0x62 66 #define IT66121_AFE_XP_GAINBIT BIT(7) 67 #define IT66121_AFE_XP_PWDPLL BIT(6) 68 #define IT66121_AFE_XP_ENI BIT(5) 69 #define IT66121_AFE_XP_ENO BIT(4) 70 #define IT66121_AFE_XP_RESETB BIT(3) 71 #define IT66121_AFE_XP_PWDI BIT(2) 72 73 #define IT66121_AFE_IP_REG 0x64 74 #define IT66121_AFE_IP_GAINBIT BIT(7) 75 #define IT66121_AFE_IP_PWDPLL BIT(6) 76 #define IT66121_AFE_IP_CKSEL_05 (0 << 4) 77 #define IT66121_AFE_IP_CKSEL_1 BIT(4) 78 #define IT66121_AFE_IP_CKSEL_2 (2 << 4) 79 #define IT66121_AFE_IP_CKSEL_2OR4 (3 << 4) 80 #define IT66121_AFE_IP_ER0 BIT(3) 81 #define IT66121_AFE_IP_RESETB BIT(2) 82 #define IT66121_AFE_IP_ENC BIT(1) 83 #define IT66121_AFE_IP_EC1 BIT(0) 84 85 #define IT66121_AFE_XP_EC1_REG 0x68 86 #define IT66121_AFE_XP_EC1_LOWCLK BIT(4) 87 88 #define IT66121_SW_RST_REG 0x04 89 #define IT66121_SW_RST_REF BIT(5) 90 #define IT66121_SW_RST_AREF BIT(4) 91 #define IT66121_SW_RST_VID BIT(3) 92 #define IT66121_SW_RST_AUD BIT(2) 93 #define IT66121_SW_RST_HDCP BIT(0) 94 95 #define IT66121_DDC_COMMAND_REG 0x15 96 #define IT66121_DDC_COMMAND_BURST_READ 0x0 97 #define IT66121_DDC_COMMAND_EDID_READ 0x3 98 #define IT66121_DDC_COMMAND_FIFO_CLR 0x9 99 #define IT66121_DDC_COMMAND_SCL_PULSE 0xA 100 #define IT66121_DDC_COMMAND_ABORT 0xF 101 102 #define IT66121_HDCP_REG 0x20 103 #define IT66121_HDCP_CPDESIRED BIT(0) 104 #define IT66121_HDCP_EN1P1FEAT BIT(1) 105 106 #define IT66121_INT_STATUS1_REG 0x06 107 #define IT66121_INT_STATUS1_AUD_OVF BIT(7) 108 #define IT66121_INT_STATUS1_DDC_NOACK BIT(5) 109 #define IT66121_INT_STATUS1_DDC_FIFOERR BIT(4) 110 #define IT66121_INT_STATUS1_DDC_BUSHANG BIT(2) 111 #define IT66121_INT_STATUS1_RX_SENS_STATUS BIT(1) 112 #define IT66121_INT_STATUS1_HPD_STATUS BIT(0) 113 114 #define IT66121_DDC_HEADER_REG 0x11 115 #define IT66121_DDC_HEADER_HDCP 0x74 116 #define IT66121_DDC_HEADER_EDID 0xA0 117 118 #define IT66121_DDC_OFFSET_REG 0x12 119 #define IT66121_DDC_BYTE_REG 0x13 120 #define IT66121_DDC_SEGMENT_REG 0x14 121 #define IT66121_DDC_RD_FIFO_REG 0x17 122 123 #define IT66121_CLK_BANK_REG 0x0F 124 #define IT66121_CLK_BANK_PWROFF_RCLK BIT(6) 125 #define IT66121_CLK_BANK_PWROFF_ACLK BIT(5) 126 #define IT66121_CLK_BANK_PWROFF_TXCLK BIT(4) 127 #define IT66121_CLK_BANK_PWROFF_CRCLK BIT(3) 128 #define IT66121_CLK_BANK_0 0 129 #define IT66121_CLK_BANK_1 1 130 131 #define IT66121_INT_REG 0x05 132 #define IT66121_INT_ACTIVE_HIGH BIT(7) 133 #define IT66121_INT_OPEN_DRAIN BIT(6) 134 #define IT66121_INT_TX_CLK_OFF BIT(0) 135 136 #define IT66121_INT_MASK1_REG 0x09 137 #define IT66121_INT_MASK1_AUD_OVF BIT(7) 138 #define IT66121_INT_MASK1_DDC_NOACK BIT(5) 139 #define IT66121_INT_MASK1_DDC_FIFOERR BIT(4) 140 #define IT66121_INT_MASK1_DDC_BUSHANG BIT(2) 141 #define IT66121_INT_MASK1_RX_SENS BIT(1) 142 #define IT66121_INT_MASK1_HPD BIT(0) 143 144 #define IT66121_INT_CLR1_REG 0x0C 145 #define IT66121_INT_CLR1_PKTACP BIT(7) 146 #define IT66121_INT_CLR1_PKTNULL BIT(6) 147 #define IT66121_INT_CLR1_PKTGEN BIT(5) 148 #define IT66121_INT_CLR1_KSVLISTCHK BIT(4) 149 #define IT66121_INT_CLR1_AUTHDONE BIT(3) 150 #define IT66121_INT_CLR1_AUTHFAIL BIT(2) 151 #define IT66121_INT_CLR1_RX_SENS BIT(1) 152 #define IT66121_INT_CLR1_HPD BIT(0) 153 154 #define IT66121_AV_MUTE_REG 0xC1 155 #define IT66121_AV_MUTE_ON BIT(0) 156 #define IT66121_AV_MUTE_BLUESCR BIT(1) 157 158 #define IT66121_PKT_GEN_CTRL_REG 0xC6 159 #define IT66121_PKT_GEN_CTRL_ON BIT(0) 160 #define IT66121_PKT_GEN_CTRL_RPT BIT(1) 161 162 #define IT66121_AVIINFO_DB1_REG 0x158 163 #define IT66121_AVIINFO_DB2_REG 0x159 164 #define IT66121_AVIINFO_DB3_REG 0x15A 165 #define IT66121_AVIINFO_DB4_REG 0x15B 166 #define IT66121_AVIINFO_DB5_REG 0x15C 167 #define IT66121_AVIINFO_CSUM_REG 0x15D 168 #define IT66121_AVIINFO_DB6_REG 0x15E 169 #define IT66121_AVIINFO_DB7_REG 0x15F 170 #define IT66121_AVIINFO_DB8_REG 0x160 171 #define IT66121_AVIINFO_DB9_REG 0x161 172 #define IT66121_AVIINFO_DB10_REG 0x162 173 #define IT66121_AVIINFO_DB11_REG 0x163 174 #define IT66121_AVIINFO_DB12_REG 0x164 175 #define IT66121_AVIINFO_DB13_REG 0x165 176 177 #define IT66121_AVI_INFO_PKT_REG 0xCD 178 #define IT66121_AVI_INFO_PKT_ON BIT(0) 179 #define IT66121_AVI_INFO_PKT_RPT BIT(1) 180 181 #define IT66121_HDMI_MODE_REG 0xC0 182 #define IT66121_HDMI_MODE_HDMI BIT(0) 183 184 #define IT66121_SYS_STATUS_REG 0x0E 185 #define IT66121_SYS_STATUS_ACTIVE_IRQ BIT(7) 186 #define IT66121_SYS_STATUS_HPDETECT BIT(6) 187 #define IT66121_SYS_STATUS_SENDECTECT BIT(5) 188 #define IT66121_SYS_STATUS_VID_STABLE BIT(4) 189 #define IT66121_SYS_STATUS_AUD_CTS_CLR BIT(1) 190 #define IT66121_SYS_STATUS_CLEAR_IRQ BIT(0) 191 192 #define IT66121_DDC_STATUS_REG 0x16 193 #define IT66121_DDC_STATUS_TX_DONE BIT(7) 194 #define IT66121_DDC_STATUS_ACTIVE BIT(6) 195 #define IT66121_DDC_STATUS_NOACK BIT(5) 196 #define IT66121_DDC_STATUS_WAIT_BUS BIT(4) 197 #define IT66121_DDC_STATUS_ARBI_LOSE BIT(3) 198 #define IT66121_DDC_STATUS_FIFO_FULL BIT(2) 199 #define IT66121_DDC_STATUS_FIFO_EMPTY BIT(1) 200 #define IT66121_DDC_STATUS_FIFO_VALID BIT(0) 201 202 #define IT66121_EDID_SLEEP_US 20000 203 #define IT66121_EDID_TIMEOUT_US 200000 204 #define IT66121_EDID_FIFO_SIZE 32 205 #define IT66121_AFE_CLK_HIGH 80000 /* Khz */ 206 207 struct it66121_ctx { 208 struct regmap *regmap; 209 struct drm_bridge bridge; 210 struct drm_bridge *next_bridge; 211 struct drm_connector *connector; 212 struct device *dev; 213 struct gpio_desc *gpio_reset; 214 struct i2c_client *client; 215 struct regulator_bulk_data supplies[3]; 216 u32 bus_width; 217 struct mutex lock; /* Protects fields below and device registers */ 218 struct hdmi_avi_infoframe hdmi_avi_infoframe; 219 }; 220 221 static const struct regmap_range_cfg it66121_regmap_banks[] = { 222 { 223 .name = "it66121", 224 .range_min = 0x00, 225 .range_max = 0x1FF, 226 .selector_reg = IT66121_CLK_BANK_REG, 227 .selector_mask = 0x1, 228 .selector_shift = 0, 229 .window_start = 0x00, 230 .window_len = 0x130, 231 }, 232 }; 233 234 static const struct regmap_config it66121_regmap_config = { 235 .val_bits = 8, 236 .reg_bits = 8, 237 .max_register = 0x1FF, 238 .ranges = it66121_regmap_banks, 239 .num_ranges = ARRAY_SIZE(it66121_regmap_banks), 240 }; 241 242 static void it66121_hw_reset(struct it66121_ctx *ctx) 243 { 244 gpiod_set_value(ctx->gpio_reset, 1); 245 msleep(20); 246 gpiod_set_value(ctx->gpio_reset, 0); 247 } 248 249 static inline int ite66121_power_on(struct it66121_ctx *ctx) 250 { 251 return regulator_bulk_enable(ARRAY_SIZE(ctx->supplies), ctx->supplies); 252 } 253 254 static inline int ite66121_power_off(struct it66121_ctx *ctx) 255 { 256 return regulator_bulk_disable(ARRAY_SIZE(ctx->supplies), ctx->supplies); 257 } 258 259 static inline int it66121_preamble_ddc(struct it66121_ctx *ctx) 260 { 261 return regmap_write(ctx->regmap, IT66121_MASTER_SEL_REG, IT66121_MASTER_SEL_HOST); 262 } 263 264 static inline int it66121_fire_afe(struct it66121_ctx *ctx) 265 { 266 return regmap_write(ctx->regmap, IT66121_AFE_DRV_REG, 0); 267 } 268 269 /* TOFIX: Handle YCbCr Input & Output */ 270 static int it66121_configure_input(struct it66121_ctx *ctx) 271 { 272 int ret; 273 u8 mode = IT66121_INPUT_MODE_RGB; 274 275 if (ctx->bus_width == 12) 276 mode |= IT66121_INPUT_MODE_DDR; 277 278 ret = regmap_write(ctx->regmap, IT66121_INPUT_MODE_REG, mode); 279 if (ret) 280 return ret; 281 282 return regmap_write(ctx->regmap, IT66121_INPUT_CSC_REG, IT66121_INPUT_CSC_NO_CONV); 283 } 284 285 /** 286 * it66121_configure_afe() - Configure the analog front end 287 * @ctx: it66121_ctx object 288 * @mode: mode to configure 289 * 290 * RETURNS: 291 * zero if success, a negative error code otherwise. 292 */ 293 static int it66121_configure_afe(struct it66121_ctx *ctx, 294 const struct drm_display_mode *mode) 295 { 296 int ret; 297 298 ret = regmap_write(ctx->regmap, IT66121_AFE_DRV_REG, 299 IT66121_AFE_DRV_RST); 300 if (ret) 301 return ret; 302 303 if (mode->clock > IT66121_AFE_CLK_HIGH) { 304 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_XP_REG, 305 IT66121_AFE_XP_GAINBIT | 306 IT66121_AFE_XP_ENO, 307 IT66121_AFE_XP_GAINBIT); 308 if (ret) 309 return ret; 310 311 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_IP_REG, 312 IT66121_AFE_IP_GAINBIT | 313 IT66121_AFE_IP_ER0 | 314 IT66121_AFE_IP_EC1, 315 IT66121_AFE_IP_GAINBIT); 316 if (ret) 317 return ret; 318 319 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_XP_EC1_REG, 320 IT66121_AFE_XP_EC1_LOWCLK, 0x80); 321 if (ret) 322 return ret; 323 } else { 324 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_XP_REG, 325 IT66121_AFE_XP_GAINBIT | 326 IT66121_AFE_XP_ENO, 327 IT66121_AFE_XP_ENO); 328 if (ret) 329 return ret; 330 331 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_IP_REG, 332 IT66121_AFE_IP_GAINBIT | 333 IT66121_AFE_IP_ER0 | 334 IT66121_AFE_IP_EC1, IT66121_AFE_IP_ER0 | 335 IT66121_AFE_IP_EC1); 336 if (ret) 337 return ret; 338 339 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_XP_EC1_REG, 340 IT66121_AFE_XP_EC1_LOWCLK, 341 IT66121_AFE_XP_EC1_LOWCLK); 342 if (ret) 343 return ret; 344 } 345 346 /* Clear reset flags */ 347 ret = regmap_write_bits(ctx->regmap, IT66121_SW_RST_REG, 348 IT66121_SW_RST_REF | IT66121_SW_RST_VID, 0); 349 if (ret) 350 return ret; 351 352 return it66121_fire_afe(ctx); 353 } 354 355 static inline int it66121_wait_ddc_ready(struct it66121_ctx *ctx) 356 { 357 int ret, val; 358 u32 busy = IT66121_DDC_STATUS_NOACK | IT66121_DDC_STATUS_WAIT_BUS | 359 IT66121_DDC_STATUS_ARBI_LOSE; 360 361 ret = regmap_read_poll_timeout(ctx->regmap, IT66121_DDC_STATUS_REG, val, true, 362 IT66121_EDID_SLEEP_US, IT66121_EDID_TIMEOUT_US); 363 if (ret) 364 return ret; 365 366 if (val & busy) 367 return -EAGAIN; 368 369 return 0; 370 } 371 372 static int it66121_clear_ddc_fifo(struct it66121_ctx *ctx) 373 { 374 int ret; 375 376 ret = it66121_preamble_ddc(ctx); 377 if (ret) 378 return ret; 379 380 return regmap_write(ctx->regmap, IT66121_DDC_COMMAND_REG, 381 IT66121_DDC_COMMAND_FIFO_CLR); 382 } 383 384 static int it66121_abort_ddc_ops(struct it66121_ctx *ctx) 385 { 386 int ret; 387 unsigned int swreset, cpdesire; 388 389 ret = regmap_read(ctx->regmap, IT66121_SW_RST_REG, &swreset); 390 if (ret) 391 return ret; 392 393 ret = regmap_read(ctx->regmap, IT66121_HDCP_REG, &cpdesire); 394 if (ret) 395 return ret; 396 397 ret = regmap_write(ctx->regmap, IT66121_HDCP_REG, 398 cpdesire & (~IT66121_HDCP_CPDESIRED & 0xFF)); 399 if (ret) 400 return ret; 401 402 ret = regmap_write(ctx->regmap, IT66121_SW_RST_REG, 403 (swreset | IT66121_SW_RST_HDCP)); 404 if (ret) 405 return ret; 406 407 ret = it66121_preamble_ddc(ctx); 408 if (ret) 409 return ret; 410 411 ret = regmap_write(ctx->regmap, IT66121_DDC_COMMAND_REG, 412 IT66121_DDC_COMMAND_ABORT); 413 if (ret) 414 return ret; 415 416 return it66121_wait_ddc_ready(ctx); 417 } 418 419 static int it66121_get_edid_block(void *context, u8 *buf, 420 unsigned int block, size_t len) 421 { 422 struct it66121_ctx *ctx = context; 423 unsigned int val; 424 int remain = len; 425 int offset = 0; 426 int ret, cnt; 427 428 offset = (block % 2) * len; 429 block = block / 2; 430 431 ret = regmap_read(ctx->regmap, IT66121_INT_STATUS1_REG, &val); 432 if (ret) 433 return ret; 434 435 if (val & IT66121_INT_STATUS1_DDC_BUSHANG) { 436 ret = it66121_abort_ddc_ops(ctx); 437 if (ret) 438 return ret; 439 } 440 441 ret = it66121_clear_ddc_fifo(ctx); 442 if (ret) 443 return ret; 444 445 while (remain > 0) { 446 cnt = (remain > IT66121_EDID_FIFO_SIZE) ? 447 IT66121_EDID_FIFO_SIZE : remain; 448 ret = it66121_preamble_ddc(ctx); 449 if (ret) 450 return ret; 451 452 ret = regmap_write(ctx->regmap, IT66121_DDC_COMMAND_REG, 453 IT66121_DDC_COMMAND_FIFO_CLR); 454 if (ret) 455 return ret; 456 457 ret = it66121_wait_ddc_ready(ctx); 458 if (ret) 459 return ret; 460 461 ret = regmap_read(ctx->regmap, IT66121_INT_STATUS1_REG, &val); 462 if (ret) 463 return ret; 464 465 if (val & IT66121_INT_STATUS1_DDC_BUSHANG) { 466 ret = it66121_abort_ddc_ops(ctx); 467 if (ret) 468 return ret; 469 } 470 471 ret = it66121_preamble_ddc(ctx); 472 if (ret) 473 return ret; 474 475 ret = regmap_write(ctx->regmap, IT66121_DDC_HEADER_REG, 476 IT66121_DDC_HEADER_EDID); 477 if (ret) 478 return ret; 479 480 ret = regmap_write(ctx->regmap, IT66121_DDC_OFFSET_REG, offset); 481 if (ret) 482 return ret; 483 484 ret = regmap_write(ctx->regmap, IT66121_DDC_BYTE_REG, cnt); 485 if (ret) 486 return ret; 487 488 ret = regmap_write(ctx->regmap, IT66121_DDC_SEGMENT_REG, block); 489 if (ret) 490 return ret; 491 492 ret = regmap_write(ctx->regmap, IT66121_DDC_COMMAND_REG, 493 IT66121_DDC_COMMAND_EDID_READ); 494 if (ret) 495 return ret; 496 497 offset += cnt; 498 remain -= cnt; 499 500 /* Per programming manual, sleep here before emptying the FIFO */ 501 msleep(20); 502 503 ret = it66121_wait_ddc_ready(ctx); 504 if (ret) 505 return ret; 506 507 do { 508 ret = regmap_read(ctx->regmap, IT66121_DDC_RD_FIFO_REG, &val); 509 if (ret) 510 return ret; 511 *(buf++) = val; 512 cnt--; 513 } while (cnt > 0); 514 } 515 516 return 0; 517 } 518 519 static bool it66121_is_hpd_detect(struct it66121_ctx *ctx) 520 { 521 int val; 522 523 if (regmap_read(ctx->regmap, IT66121_SYS_STATUS_REG, &val)) 524 return false; 525 526 return val & IT66121_SYS_STATUS_HPDETECT; 527 } 528 529 static int it66121_bridge_attach(struct drm_bridge *bridge, 530 enum drm_bridge_attach_flags flags) 531 { 532 struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge); 533 int ret; 534 535 if (!(flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)) 536 return -EINVAL; 537 538 ret = drm_bridge_attach(bridge->encoder, ctx->next_bridge, bridge, flags); 539 540 ret = regmap_write_bits(ctx->regmap, IT66121_CLK_BANK_REG, 541 IT66121_CLK_BANK_PWROFF_RCLK, 0); 542 if (ret) 543 return ret; 544 545 ret = regmap_write_bits(ctx->regmap, IT66121_INT_REG, 546 IT66121_INT_TX_CLK_OFF, 0); 547 if (ret) 548 return ret; 549 550 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_DRV_REG, 551 IT66121_AFE_DRV_PWD, 0); 552 if (ret) 553 return ret; 554 555 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_XP_REG, 556 IT66121_AFE_XP_PWDI | IT66121_AFE_XP_PWDPLL, 0); 557 if (ret) 558 return ret; 559 560 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_IP_REG, 561 IT66121_AFE_IP_PWDPLL, 0); 562 if (ret) 563 return ret; 564 565 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_DRV_REG, 566 IT66121_AFE_DRV_RST, 0); 567 if (ret) 568 return ret; 569 570 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_XP_REG, 571 IT66121_AFE_XP_RESETB, IT66121_AFE_XP_RESETB); 572 if (ret) 573 return ret; 574 575 ret = regmap_write_bits(ctx->regmap, IT66121_AFE_IP_REG, 576 IT66121_AFE_IP_RESETB, IT66121_AFE_IP_RESETB); 577 if (ret) 578 return ret; 579 580 ret = regmap_write_bits(ctx->regmap, IT66121_SW_RST_REG, 581 IT66121_SW_RST_REF, 582 IT66121_SW_RST_REF); 583 if (ret) 584 return ret; 585 586 /* Per programming manual, sleep here for bridge to settle */ 587 msleep(50); 588 589 /* Start interrupts */ 590 return regmap_write_bits(ctx->regmap, IT66121_INT_MASK1_REG, 591 IT66121_INT_MASK1_DDC_NOACK | 592 IT66121_INT_MASK1_DDC_FIFOERR | 593 IT66121_INT_MASK1_DDC_BUSHANG, 0); 594 } 595 596 static int it66121_set_mute(struct it66121_ctx *ctx, bool mute) 597 { 598 int ret; 599 unsigned int val = 0; 600 601 if (mute) 602 val = IT66121_AV_MUTE_ON; 603 604 ret = regmap_write_bits(ctx->regmap, IT66121_AV_MUTE_REG, IT66121_AV_MUTE_ON, val); 605 if (ret) 606 return ret; 607 608 return regmap_write(ctx->regmap, IT66121_PKT_GEN_CTRL_REG, 609 IT66121_PKT_GEN_CTRL_ON | IT66121_PKT_GEN_CTRL_RPT); 610 } 611 612 #define MAX_OUTPUT_SEL_FORMATS 1 613 614 static u32 *it66121_bridge_atomic_get_output_bus_fmts(struct drm_bridge *bridge, 615 struct drm_bridge_state *bridge_state, 616 struct drm_crtc_state *crtc_state, 617 struct drm_connector_state *conn_state, 618 unsigned int *num_output_fmts) 619 { 620 u32 *output_fmts; 621 622 output_fmts = kcalloc(MAX_OUTPUT_SEL_FORMATS, sizeof(*output_fmts), 623 GFP_KERNEL); 624 if (!output_fmts) 625 return NULL; 626 627 /* TOFIX handle more than MEDIA_BUS_FMT_RGB888_1X24 as output format */ 628 output_fmts[0] = MEDIA_BUS_FMT_RGB888_1X24; 629 *num_output_fmts = 1; 630 631 return output_fmts; 632 } 633 634 #define MAX_INPUT_SEL_FORMATS 1 635 636 static u32 *it66121_bridge_atomic_get_input_bus_fmts(struct drm_bridge *bridge, 637 struct drm_bridge_state *bridge_state, 638 struct drm_crtc_state *crtc_state, 639 struct drm_connector_state *conn_state, 640 u32 output_fmt, 641 unsigned int *num_input_fmts) 642 { 643 struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge); 644 u32 *input_fmts; 645 646 *num_input_fmts = 0; 647 648 input_fmts = kcalloc(MAX_INPUT_SEL_FORMATS, sizeof(*input_fmts), 649 GFP_KERNEL); 650 if (!input_fmts) 651 return NULL; 652 653 if (ctx->bus_width == 12) 654 /* IT66121FN Datasheet specifies Little-Endian ordering */ 655 input_fmts[0] = MEDIA_BUS_FMT_RGB888_2X12_LE; 656 else 657 /* TOFIX support more input bus formats in 24bit width */ 658 input_fmts[0] = MEDIA_BUS_FMT_RGB888_1X24; 659 *num_input_fmts = 1; 660 661 return input_fmts; 662 } 663 664 static void it66121_bridge_enable(struct drm_bridge *bridge, 665 struct drm_bridge_state *bridge_state) 666 { 667 struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge); 668 struct drm_atomic_state *state = bridge_state->base.state; 669 670 ctx->connector = drm_atomic_get_new_connector_for_encoder(state, bridge->encoder); 671 672 it66121_set_mute(ctx, false); 673 } 674 675 static void it66121_bridge_disable(struct drm_bridge *bridge, 676 struct drm_bridge_state *bridge_state) 677 { 678 struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge); 679 680 it66121_set_mute(ctx, true); 681 682 ctx->connector = NULL; 683 } 684 685 static 686 void it66121_bridge_mode_set(struct drm_bridge *bridge, 687 const struct drm_display_mode *mode, 688 const struct drm_display_mode *adjusted_mode) 689 { 690 int ret, i; 691 u8 buf[HDMI_INFOFRAME_SIZE(AVI)]; 692 struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge); 693 const u16 aviinfo_reg[HDMI_AVI_INFOFRAME_SIZE] = { 694 IT66121_AVIINFO_DB1_REG, 695 IT66121_AVIINFO_DB2_REG, 696 IT66121_AVIINFO_DB3_REG, 697 IT66121_AVIINFO_DB4_REG, 698 IT66121_AVIINFO_DB5_REG, 699 IT66121_AVIINFO_DB6_REG, 700 IT66121_AVIINFO_DB7_REG, 701 IT66121_AVIINFO_DB8_REG, 702 IT66121_AVIINFO_DB9_REG, 703 IT66121_AVIINFO_DB10_REG, 704 IT66121_AVIINFO_DB11_REG, 705 IT66121_AVIINFO_DB12_REG, 706 IT66121_AVIINFO_DB13_REG 707 }; 708 709 mutex_lock(&ctx->lock); 710 711 hdmi_avi_infoframe_init(&ctx->hdmi_avi_infoframe); 712 713 ret = drm_hdmi_avi_infoframe_from_display_mode(&ctx->hdmi_avi_infoframe, ctx->connector, 714 adjusted_mode); 715 if (ret) { 716 DRM_ERROR("Failed to setup AVI infoframe: %d\n", ret); 717 goto unlock; 718 } 719 720 ret = hdmi_avi_infoframe_pack(&ctx->hdmi_avi_infoframe, buf, sizeof(buf)); 721 if (ret < 0) { 722 DRM_ERROR("Failed to pack infoframe: %d\n", ret); 723 goto unlock; 724 } 725 726 /* Write new AVI infoframe packet */ 727 for (i = 0; i < HDMI_AVI_INFOFRAME_SIZE; i++) { 728 if (regmap_write(ctx->regmap, aviinfo_reg[i], buf[i + HDMI_INFOFRAME_HEADER_SIZE])) 729 goto unlock; 730 } 731 if (regmap_write(ctx->regmap, IT66121_AVIINFO_CSUM_REG, buf[3])) 732 goto unlock; 733 734 /* Enable AVI infoframe */ 735 if (regmap_write(ctx->regmap, IT66121_AVI_INFO_PKT_REG, 736 IT66121_AVI_INFO_PKT_ON | IT66121_AVI_INFO_PKT_RPT)) 737 goto unlock; 738 739 /* Set TX mode to HDMI */ 740 if (regmap_write(ctx->regmap, IT66121_HDMI_MODE_REG, IT66121_HDMI_MODE_HDMI)) 741 goto unlock; 742 743 if (regmap_write_bits(ctx->regmap, IT66121_CLK_BANK_REG, 744 IT66121_CLK_BANK_PWROFF_TXCLK, IT66121_CLK_BANK_PWROFF_TXCLK)) 745 goto unlock; 746 747 if (it66121_configure_input(ctx)) 748 goto unlock; 749 750 if (it66121_configure_afe(ctx, adjusted_mode)) 751 goto unlock; 752 753 regmap_write_bits(ctx->regmap, IT66121_CLK_BANK_REG, IT66121_CLK_BANK_PWROFF_TXCLK, 0); 754 755 unlock: 756 mutex_unlock(&ctx->lock); 757 } 758 759 static enum drm_mode_status it66121_bridge_mode_valid(struct drm_bridge *bridge, 760 const struct drm_display_info *info, 761 const struct drm_display_mode *mode) 762 { 763 struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge); 764 unsigned long max_clock; 765 766 max_clock = (ctx->bus_width == 12) ? 74250 : 148500; 767 768 if (mode->clock > max_clock) 769 return MODE_CLOCK_HIGH; 770 771 if (mode->clock < 25000) 772 return MODE_CLOCK_LOW; 773 774 return MODE_OK; 775 } 776 777 static enum drm_connector_status it66121_bridge_detect(struct drm_bridge *bridge) 778 { 779 struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge); 780 781 return it66121_is_hpd_detect(ctx) ? connector_status_connected 782 : connector_status_disconnected; 783 } 784 785 static void it66121_bridge_hpd_enable(struct drm_bridge *bridge) 786 { 787 struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge); 788 int ret; 789 790 ret = regmap_write_bits(ctx->regmap, IT66121_INT_MASK1_REG, IT66121_INT_MASK1_HPD, 0); 791 if (ret) 792 dev_err(ctx->dev, "failed to enable HPD IRQ\n"); 793 } 794 795 static void it66121_bridge_hpd_disable(struct drm_bridge *bridge) 796 { 797 struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge); 798 int ret; 799 800 ret = regmap_write_bits(ctx->regmap, IT66121_INT_MASK1_REG, 801 IT66121_INT_MASK1_HPD, IT66121_INT_MASK1_HPD); 802 if (ret) 803 dev_err(ctx->dev, "failed to disable HPD IRQ\n"); 804 } 805 806 static struct edid *it66121_bridge_get_edid(struct drm_bridge *bridge, 807 struct drm_connector *connector) 808 { 809 struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge); 810 struct edid *edid; 811 812 mutex_lock(&ctx->lock); 813 edid = drm_do_get_edid(connector, it66121_get_edid_block, ctx); 814 mutex_unlock(&ctx->lock); 815 816 return edid; 817 } 818 819 static const struct drm_bridge_funcs it66121_bridge_funcs = { 820 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, 821 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, 822 .atomic_reset = drm_atomic_helper_bridge_reset, 823 .attach = it66121_bridge_attach, 824 .atomic_get_output_bus_fmts = it66121_bridge_atomic_get_output_bus_fmts, 825 .atomic_get_input_bus_fmts = it66121_bridge_atomic_get_input_bus_fmts, 826 .atomic_enable = it66121_bridge_enable, 827 .atomic_disable = it66121_bridge_disable, 828 .mode_set = it66121_bridge_mode_set, 829 .mode_valid = it66121_bridge_mode_valid, 830 .detect = it66121_bridge_detect, 831 .get_edid = it66121_bridge_get_edid, 832 .hpd_enable = it66121_bridge_hpd_enable, 833 .hpd_disable = it66121_bridge_hpd_disable, 834 }; 835 836 static irqreturn_t it66121_irq_threaded_handler(int irq, void *dev_id) 837 { 838 int ret; 839 unsigned int val; 840 struct it66121_ctx *ctx = dev_id; 841 struct device *dev = ctx->dev; 842 enum drm_connector_status status; 843 bool event = false; 844 845 mutex_lock(&ctx->lock); 846 847 ret = regmap_read(ctx->regmap, IT66121_SYS_STATUS_REG, &val); 848 if (ret) 849 goto unlock; 850 851 if (!(val & IT66121_SYS_STATUS_ACTIVE_IRQ)) 852 goto unlock; 853 854 ret = regmap_read(ctx->regmap, IT66121_INT_STATUS1_REG, &val); 855 if (ret) { 856 dev_err(dev, "Cannot read STATUS1_REG %d\n", ret); 857 } else { 858 if (val & IT66121_INT_STATUS1_DDC_FIFOERR) 859 it66121_clear_ddc_fifo(ctx); 860 if (val & (IT66121_INT_STATUS1_DDC_BUSHANG | 861 IT66121_INT_STATUS1_DDC_NOACK)) 862 it66121_abort_ddc_ops(ctx); 863 if (val & IT66121_INT_STATUS1_HPD_STATUS) { 864 regmap_write_bits(ctx->regmap, IT66121_INT_CLR1_REG, 865 IT66121_INT_CLR1_HPD, IT66121_INT_CLR1_HPD); 866 867 status = it66121_is_hpd_detect(ctx) ? connector_status_connected 868 : connector_status_disconnected; 869 870 event = true; 871 } 872 } 873 874 regmap_write_bits(ctx->regmap, IT66121_SYS_STATUS_REG, 875 IT66121_SYS_STATUS_CLEAR_IRQ, 876 IT66121_SYS_STATUS_CLEAR_IRQ); 877 878 unlock: 879 mutex_unlock(&ctx->lock); 880 881 if (event) 882 drm_bridge_hpd_notify(&ctx->bridge, status); 883 884 return IRQ_HANDLED; 885 } 886 887 static int it66121_probe(struct i2c_client *client, 888 const struct i2c_device_id *id) 889 { 890 u32 vendor_ids[2], device_ids[2], revision_id; 891 struct device_node *ep; 892 int ret; 893 struct it66121_ctx *ctx; 894 struct device *dev = &client->dev; 895 896 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 897 dev_err(dev, "I2C check functionality failed.\n"); 898 return -ENXIO; 899 } 900 901 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); 902 if (!ctx) 903 return -ENOMEM; 904 905 ep = of_graph_get_endpoint_by_regs(dev->of_node, 0, 0); 906 if (!ep) 907 return -EINVAL; 908 909 ctx->dev = dev; 910 ctx->client = client; 911 912 of_property_read_u32(ep, "bus-width", &ctx->bus_width); 913 of_node_put(ep); 914 915 if (ctx->bus_width != 12 && ctx->bus_width != 24) 916 return -EINVAL; 917 918 ep = of_graph_get_remote_node(dev->of_node, 1, -1); 919 if (!ep) 920 return -EPROBE_DEFER; 921 922 ctx->next_bridge = of_drm_find_bridge(ep); 923 of_node_put(ep); 924 925 i2c_set_clientdata(client, ctx); 926 mutex_init(&ctx->lock); 927 928 ctx->supplies[0].supply = "vcn33"; 929 ctx->supplies[1].supply = "vcn18"; 930 ctx->supplies[2].supply = "vrf12"; 931 ret = devm_regulator_bulk_get(ctx->dev, 3, ctx->supplies); 932 if (ret) { 933 dev_err(ctx->dev, "regulator_bulk failed\n"); 934 return ret; 935 } 936 937 ret = ite66121_power_on(ctx); 938 if (ret) 939 return ret; 940 941 it66121_hw_reset(ctx); 942 943 ctx->regmap = devm_regmap_init_i2c(client, &it66121_regmap_config); 944 if (IS_ERR(ctx->regmap)) { 945 ite66121_power_off(ctx); 946 return PTR_ERR(ctx->regmap); 947 } 948 949 regmap_read(ctx->regmap, IT66121_VENDOR_ID0_REG, &vendor_ids[0]); 950 regmap_read(ctx->regmap, IT66121_VENDOR_ID1_REG, &vendor_ids[1]); 951 regmap_read(ctx->regmap, IT66121_DEVICE_ID0_REG, &device_ids[0]); 952 regmap_read(ctx->regmap, IT66121_DEVICE_ID1_REG, &device_ids[1]); 953 954 /* Revision is shared with DEVICE_ID1 */ 955 revision_id = FIELD_GET(IT66121_REVISION_MASK, device_ids[1]); 956 device_ids[1] &= IT66121_DEVICE_ID1_MASK; 957 958 if (vendor_ids[0] != IT66121_VENDOR_ID0 || vendor_ids[1] != IT66121_VENDOR_ID1 || 959 device_ids[0] != IT66121_DEVICE_ID0 || device_ids[1] != IT66121_DEVICE_ID1) { 960 ite66121_power_off(ctx); 961 return -ENODEV; 962 } 963 964 ctx->bridge.funcs = &it66121_bridge_funcs; 965 ctx->bridge.of_node = dev->of_node; 966 ctx->bridge.type = DRM_MODE_CONNECTOR_HDMIA; 967 ctx->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID | DRM_BRIDGE_OP_HPD; 968 969 ret = devm_request_threaded_irq(dev, client->irq, NULL, it66121_irq_threaded_handler, 970 IRQF_ONESHOT, dev_name(dev), ctx); 971 if (ret < 0) { 972 dev_err(dev, "Failed to request irq %d:%d\n", client->irq, ret); 973 ite66121_power_off(ctx); 974 return ret; 975 } 976 977 drm_bridge_add(&ctx->bridge); 978 979 dev_info(ctx->dev, "IT66121 revision %d probed\n", revision_id); 980 981 return 0; 982 } 983 984 static int it66121_remove(struct i2c_client *client) 985 { 986 struct it66121_ctx *ctx = i2c_get_clientdata(client); 987 988 ite66121_power_off(ctx); 989 drm_bridge_remove(&ctx->bridge); 990 mutex_destroy(&ctx->lock); 991 992 return 0; 993 } 994 995 static const struct of_device_id it66121_dt_match[] = { 996 { .compatible = "ite,it66121" }, 997 { } 998 }; 999 MODULE_DEVICE_TABLE(of, it66121_dt_match); 1000 1001 static const struct i2c_device_id it66121_id[] = { 1002 { "it66121", 0 }, 1003 { } 1004 }; 1005 MODULE_DEVICE_TABLE(i2c, it66121_id); 1006 1007 static struct i2c_driver it66121_driver = { 1008 .driver = { 1009 .name = "it66121", 1010 .of_match_table = it66121_dt_match, 1011 }, 1012 .probe = it66121_probe, 1013 .remove = it66121_remove, 1014 .id_table = it66121_id, 1015 }; 1016 1017 module_i2c_driver(it66121_driver); 1018 1019 MODULE_AUTHOR("Phong LE"); 1020 MODULE_DESCRIPTION("IT66121 HDMI transmitter driver"); 1021 MODULE_LICENSE("GPL v2"); 1022