1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2018, The Linux Foundation. All rights reserved. 4 * Copyright (c) 2019-2020. Linaro Limited. 5 */ 6 7 #include <linux/gpio/consumer.h> 8 #include <linux/i2c.h> 9 #include <linux/interrupt.h> 10 #include <linux/media-bus-format.h> 11 #include <linux/module.h> 12 #include <linux/of_graph.h> 13 #include <linux/platform_device.h> 14 #include <linux/regmap.h> 15 #include <linux/regulator/consumer.h> 16 17 #include <sound/hdmi-codec.h> 18 19 #include <drm/drm_atomic_helper.h> 20 #include <drm/drm_bridge.h> 21 #include <drm/drm_edid.h> 22 #include <drm/drm_mipi_dsi.h> 23 #include <drm/drm_of.h> 24 #include <drm/drm_print.h> 25 #include <drm/drm_probe_helper.h> 26 #include <drm/display/drm_hdmi_helper.h> 27 #include <drm/display/drm_hdmi_state_helper.h> 28 29 #define EDID_SEG_SIZE 256 30 #define EDID_LEN 32 31 #define EDID_LOOP 8 32 #define KEY_DDC_ACCS_DONE 0x02 33 #define DDC_NO_ACK 0x50 34 35 #define LT9611_4LANES 0 36 37 struct lt9611 { 38 struct device *dev; 39 struct drm_bridge bridge; 40 struct drm_bridge *next_bridge; 41 42 struct regmap *regmap; 43 44 struct device_node *dsi0_node; 45 struct device_node *dsi1_node; 46 struct mipi_dsi_device *dsi0; 47 struct mipi_dsi_device *dsi1; 48 49 bool ac_mode; 50 51 struct gpio_desc *reset_gpio; 52 struct gpio_desc *enable_gpio; 53 54 bool power_on; 55 bool sleep; 56 57 struct regulator_bulk_data supplies[2]; 58 59 struct i2c_client *client; 60 61 enum drm_connector_status status; 62 63 u8 edid_buf[EDID_SEG_SIZE]; 64 }; 65 66 #define LT9611_PAGE_CONTROL 0xff 67 68 static const struct regmap_range_cfg lt9611_ranges[] = { 69 { 70 .name = "register_range", 71 .range_min = 0, 72 .range_max = 0x85ff, 73 .selector_reg = LT9611_PAGE_CONTROL, 74 .selector_mask = 0xff, 75 .selector_shift = 0, 76 .window_start = 0, 77 .window_len = 0x100, 78 }, 79 }; 80 81 static const struct regmap_config lt9611_regmap_config = { 82 .reg_bits = 8, 83 .val_bits = 8, 84 .max_register = 0xffff, 85 .ranges = lt9611_ranges, 86 .num_ranges = ARRAY_SIZE(lt9611_ranges), 87 }; 88 89 static struct lt9611 *bridge_to_lt9611(struct drm_bridge *bridge) 90 { 91 return container_of(bridge, struct lt9611, bridge); 92 } 93 94 static int lt9611_mipi_input_analog(struct lt9611 *lt9611) 95 { 96 const struct reg_sequence reg_cfg[] = { 97 { 0x8106, 0x40 }, /* port A rx current */ 98 { 0x810a, 0xfe }, /* port A ldo voltage set */ 99 { 0x810b, 0xbf }, /* enable port A lprx */ 100 { 0x8111, 0x40 }, /* port B rx current */ 101 { 0x8115, 0xfe }, /* port B ldo voltage set */ 102 { 0x8116, 0xbf }, /* enable port B lprx */ 103 104 { 0x811c, 0x03 }, /* PortA clk lane no-LP mode */ 105 { 0x8120, 0x03 }, /* PortB clk lane with-LP mode */ 106 }; 107 108 return regmap_multi_reg_write(lt9611->regmap, reg_cfg, ARRAY_SIZE(reg_cfg)); 109 } 110 111 static int lt9611_mipi_input_digital(struct lt9611 *lt9611, 112 const struct drm_display_mode *mode) 113 { 114 struct reg_sequence reg_cfg[] = { 115 { 0x8300, LT9611_4LANES }, 116 { 0x830a, 0x00 }, 117 { 0x824f, 0x80 }, 118 { 0x8250, 0x10 }, 119 { 0x8302, 0x0a }, 120 { 0x8306, 0x0a }, 121 }; 122 123 if (lt9611->dsi1_node) 124 reg_cfg[1].def = 0x03; 125 126 return regmap_multi_reg_write(lt9611->regmap, reg_cfg, ARRAY_SIZE(reg_cfg)); 127 } 128 129 static void lt9611_mipi_video_setup(struct lt9611 *lt9611, 130 const struct drm_display_mode *mode) 131 { 132 u32 h_total, hactive, hsync_len, hfront_porch, hsync_porch; 133 u32 v_total, vactive, vsync_len, vfront_porch, vsync_porch; 134 135 h_total = mode->htotal; 136 v_total = mode->vtotal; 137 138 hactive = mode->hdisplay; 139 hsync_len = mode->hsync_end - mode->hsync_start; 140 hfront_porch = mode->hsync_start - mode->hdisplay; 141 hsync_porch = mode->htotal - mode->hsync_start; 142 143 vactive = mode->vdisplay; 144 vsync_len = mode->vsync_end - mode->vsync_start; 145 vfront_porch = mode->vsync_start - mode->vdisplay; 146 vsync_porch = mode->vtotal - mode->vsync_start; 147 148 regmap_write(lt9611->regmap, 0x830d, (u8)(v_total / 256)); 149 regmap_write(lt9611->regmap, 0x830e, (u8)(v_total % 256)); 150 151 regmap_write(lt9611->regmap, 0x830f, (u8)(vactive / 256)); 152 regmap_write(lt9611->regmap, 0x8310, (u8)(vactive % 256)); 153 154 regmap_write(lt9611->regmap, 0x8311, (u8)(h_total / 256)); 155 regmap_write(lt9611->regmap, 0x8312, (u8)(h_total % 256)); 156 157 regmap_write(lt9611->regmap, 0x8313, (u8)(hactive / 256)); 158 regmap_write(lt9611->regmap, 0x8314, (u8)(hactive % 256)); 159 160 regmap_write(lt9611->regmap, 0x8315, (u8)(vsync_len % 256)); 161 regmap_write(lt9611->regmap, 0x8316, (u8)(hsync_len % 256)); 162 163 regmap_write(lt9611->regmap, 0x8317, (u8)(vfront_porch % 256)); 164 165 regmap_write(lt9611->regmap, 0x8318, (u8)(vsync_porch % 256)); 166 167 regmap_write(lt9611->regmap, 0x8319, (u8)(hfront_porch % 256)); 168 169 regmap_write(lt9611->regmap, 0x831a, (u8)(hsync_porch / 256) | 170 ((hfront_porch / 256) << 4)); 171 regmap_write(lt9611->regmap, 0x831b, (u8)(hsync_porch % 256)); 172 } 173 174 static void lt9611_pcr_setup(struct lt9611 *lt9611, const struct drm_display_mode *mode, unsigned int postdiv) 175 { 176 unsigned int pcr_m = mode->clock * 5 * postdiv / 27000; 177 const struct reg_sequence reg_cfg[] = { 178 { 0x830b, 0x01 }, 179 { 0x830c, 0x10 }, 180 { 0x8348, 0x00 }, 181 { 0x8349, 0x81 }, 182 183 /* stage 1 */ 184 { 0x8321, 0x4a }, 185 { 0x8324, 0x71 }, 186 { 0x8325, 0x30 }, 187 { 0x832a, 0x01 }, 188 189 /* stage 2 */ 190 { 0x834a, 0x40 }, 191 192 /* MK limit */ 193 { 0x832d, 0x38 }, 194 { 0x8331, 0x08 }, 195 }; 196 u8 pol = 0x10; 197 198 if (mode->flags & DRM_MODE_FLAG_NHSYNC) 199 pol |= 0x2; 200 if (mode->flags & DRM_MODE_FLAG_NVSYNC) 201 pol |= 0x1; 202 regmap_write(lt9611->regmap, 0x831d, pol); 203 204 regmap_multi_reg_write(lt9611->regmap, reg_cfg, ARRAY_SIZE(reg_cfg)); 205 if (lt9611->dsi1_node) { 206 unsigned int hact = mode->hdisplay; 207 208 hact >>= 2; 209 hact += 0x50; 210 hact = min(hact, 0x3e0U); 211 regmap_write(lt9611->regmap, 0x830b, hact / 256); 212 regmap_write(lt9611->regmap, 0x830c, hact % 256); 213 regmap_write(lt9611->regmap, 0x8348, hact / 256); 214 regmap_write(lt9611->regmap, 0x8349, hact % 256); 215 } 216 217 regmap_write(lt9611->regmap, 0x8326, pcr_m); 218 219 /* pcr rst */ 220 regmap_write(lt9611->regmap, 0x8011, 0x5a); 221 regmap_write(lt9611->regmap, 0x8011, 0xfa); 222 } 223 224 static int lt9611_pll_setup(struct lt9611 *lt9611, const struct drm_display_mode *mode, unsigned int *postdiv) 225 { 226 unsigned int pclk = mode->clock; 227 const struct reg_sequence reg_cfg[] = { 228 /* txpll init */ 229 { 0x8123, 0x40 }, 230 { 0x8124, 0x64 }, 231 { 0x8125, 0x80 }, 232 { 0x8126, 0x55 }, 233 { 0x812c, 0x37 }, 234 { 0x812f, 0x01 }, 235 { 0x8126, 0x55 }, 236 { 0x8127, 0x66 }, 237 { 0x8128, 0x88 }, 238 { 0x812a, 0x20 }, 239 }; 240 241 regmap_multi_reg_write(lt9611->regmap, reg_cfg, ARRAY_SIZE(reg_cfg)); 242 243 if (pclk > 150000) { 244 regmap_write(lt9611->regmap, 0x812d, 0x88); 245 *postdiv = 1; 246 } else if (pclk > 70000) { 247 regmap_write(lt9611->regmap, 0x812d, 0x99); 248 *postdiv = 2; 249 } else { 250 regmap_write(lt9611->regmap, 0x812d, 0xaa); 251 *postdiv = 4; 252 } 253 254 /* 255 * first divide pclk by 2 first 256 * - write divide by 64k to 19:16 bits which means shift by 17 257 * - write divide by 256 to 15:8 bits which means shift by 9 258 * - write remainder to 7:0 bits, which means shift by 1 259 */ 260 regmap_write(lt9611->regmap, 0x82e3, pclk >> 17); /* pclk[19:16] */ 261 regmap_write(lt9611->regmap, 0x82e4, pclk >> 9); /* pclk[15:8] */ 262 regmap_write(lt9611->regmap, 0x82e5, pclk >> 1); /* pclk[7:0] */ 263 264 regmap_write(lt9611->regmap, 0x82de, 0x20); 265 regmap_write(lt9611->regmap, 0x82de, 0xe0); 266 267 regmap_write(lt9611->regmap, 0x8016, 0xf1); 268 regmap_write(lt9611->regmap, 0x8016, 0xf3); 269 270 return 0; 271 } 272 273 static int lt9611_read_video_check(struct lt9611 *lt9611, unsigned int reg) 274 { 275 unsigned int temp, temp2; 276 int ret; 277 278 ret = regmap_read(lt9611->regmap, reg, &temp); 279 if (ret) 280 return ret; 281 temp <<= 8; 282 ret = regmap_read(lt9611->regmap, reg + 1, &temp2); 283 if (ret) 284 return ret; 285 286 return (temp + temp2); 287 } 288 289 static int lt9611_video_check(struct lt9611 *lt9611) 290 { 291 u32 v_total, vactive, hactive_a, hactive_b, h_total_sysclk; 292 int temp; 293 294 /* top module video check */ 295 296 /* vactive */ 297 temp = lt9611_read_video_check(lt9611, 0x8282); 298 if (temp < 0) 299 goto end; 300 vactive = temp; 301 302 /* v_total */ 303 temp = lt9611_read_video_check(lt9611, 0x826c); 304 if (temp < 0) 305 goto end; 306 v_total = temp; 307 308 /* h_total_sysclk */ 309 temp = lt9611_read_video_check(lt9611, 0x8286); 310 if (temp < 0) 311 goto end; 312 h_total_sysclk = temp; 313 314 /* hactive_a */ 315 temp = lt9611_read_video_check(lt9611, 0x8382); 316 if (temp < 0) 317 goto end; 318 hactive_a = temp / 3; 319 320 /* hactive_b */ 321 temp = lt9611_read_video_check(lt9611, 0x8386); 322 if (temp < 0) 323 goto end; 324 hactive_b = temp / 3; 325 326 dev_info(lt9611->dev, 327 "video check: hactive_a=%d, hactive_b=%d, vactive=%d, v_total=%d, h_total_sysclk=%d\n", 328 hactive_a, hactive_b, vactive, v_total, h_total_sysclk); 329 330 return 0; 331 332 end: 333 dev_err(lt9611->dev, "read video check error\n"); 334 return temp; 335 } 336 337 static void lt9611_hdmi_tx_digital(struct lt9611 *lt9611, bool is_hdmi) 338 { 339 if (is_hdmi) 340 regmap_write(lt9611->regmap, 0x82d6, 0x8c); 341 else 342 regmap_write(lt9611->regmap, 0x82d6, 0x0c); 343 regmap_write(lt9611->regmap, 0x82d7, 0x04); 344 } 345 346 static void lt9611_hdmi_tx_phy(struct lt9611 *lt9611) 347 { 348 struct reg_sequence reg_cfg[] = { 349 { 0x8130, 0x6a }, 350 { 0x8131, 0x44 }, /* HDMI DC mode */ 351 { 0x8132, 0x4a }, 352 { 0x8133, 0x0b }, 353 { 0x8134, 0x00 }, 354 { 0x8135, 0x00 }, 355 { 0x8136, 0x00 }, 356 { 0x8137, 0x44 }, 357 { 0x813f, 0x0f }, 358 { 0x8140, 0xa0 }, 359 { 0x8141, 0xa0 }, 360 { 0x8142, 0xa0 }, 361 { 0x8143, 0xa0 }, 362 { 0x8144, 0x0a }, 363 }; 364 365 /* HDMI AC mode */ 366 if (lt9611->ac_mode) 367 reg_cfg[2].def = 0x73; 368 369 regmap_multi_reg_write(lt9611->regmap, reg_cfg, ARRAY_SIZE(reg_cfg)); 370 } 371 372 static irqreturn_t lt9611_irq_thread_handler(int irq, void *dev_id) 373 { 374 struct lt9611 *lt9611 = dev_id; 375 unsigned int irq_flag0 = 0; 376 unsigned int irq_flag3 = 0; 377 378 regmap_read(lt9611->regmap, 0x820f, &irq_flag3); 379 regmap_read(lt9611->regmap, 0x820c, &irq_flag0); 380 381 /* hpd changed low */ 382 if (irq_flag3 & 0x80) { 383 dev_info(lt9611->dev, "hdmi cable disconnected\n"); 384 385 regmap_write(lt9611->regmap, 0x8207, 0xbf); 386 regmap_write(lt9611->regmap, 0x8207, 0x3f); 387 } 388 389 /* hpd changed high */ 390 if (irq_flag3 & 0x40) { 391 dev_info(lt9611->dev, "hdmi cable connected\n"); 392 393 regmap_write(lt9611->regmap, 0x8207, 0x7f); 394 regmap_write(lt9611->regmap, 0x8207, 0x3f); 395 } 396 397 if (irq_flag3 & 0xc0 && lt9611->bridge.dev) 398 drm_kms_helper_hotplug_event(lt9611->bridge.dev); 399 400 /* video input changed */ 401 if (irq_flag0 & 0x01) { 402 dev_info(lt9611->dev, "video input changed\n"); 403 regmap_write(lt9611->regmap, 0x829e, 0xff); 404 regmap_write(lt9611->regmap, 0x829e, 0xf7); 405 regmap_write(lt9611->regmap, 0x8204, 0xff); 406 regmap_write(lt9611->regmap, 0x8204, 0xfe); 407 } 408 409 return IRQ_HANDLED; 410 } 411 412 static void lt9611_enable_hpd_interrupts(struct lt9611 *lt9611) 413 { 414 unsigned int val; 415 416 regmap_read(lt9611->regmap, 0x8203, &val); 417 418 val &= ~0xc0; 419 regmap_write(lt9611->regmap, 0x8203, val); 420 regmap_write(lt9611->regmap, 0x8207, 0xff); /* clear */ 421 regmap_write(lt9611->regmap, 0x8207, 0x3f); 422 } 423 424 static void lt9611_sleep_setup(struct lt9611 *lt9611) 425 { 426 const struct reg_sequence sleep_setup[] = { 427 { 0x8024, 0x76 }, 428 { 0x8023, 0x01 }, 429 { 0x8157, 0x03 }, /* set addr pin as output */ 430 { 0x8149, 0x0b }, 431 432 { 0x8102, 0x48 }, /* MIPI Rx power down */ 433 { 0x8123, 0x80 }, 434 { 0x8130, 0x00 }, 435 { 0x8011, 0x0a }, 436 }; 437 438 regmap_multi_reg_write(lt9611->regmap, 439 sleep_setup, ARRAY_SIZE(sleep_setup)); 440 lt9611->sleep = true; 441 } 442 443 static int lt9611_power_on(struct lt9611 *lt9611) 444 { 445 int ret; 446 const struct reg_sequence seq[] = { 447 /* LT9611_System_Init */ 448 { 0x8101, 0x18 }, /* sel xtal clock */ 449 450 /* timer for frequency meter */ 451 { 0x821b, 0x69 }, /* timer 2 */ 452 { 0x821c, 0x78 }, 453 { 0x82cb, 0x69 }, /* timer 1 */ 454 { 0x82cc, 0x78 }, 455 456 /* irq init */ 457 { 0x8251, 0x01 }, 458 { 0x8258, 0x0a }, /* hpd irq */ 459 { 0x8259, 0x80 }, /* hpd debounce width */ 460 { 0x829e, 0xf7 }, /* video check irq */ 461 462 /* power consumption for work */ 463 { 0x8004, 0xf0 }, 464 { 0x8006, 0xf0 }, 465 { 0x800a, 0x80 }, 466 { 0x800b, 0x40 }, 467 { 0x800d, 0xef }, 468 { 0x8011, 0xfa }, 469 }; 470 471 if (lt9611->power_on) 472 return 0; 473 474 ret = regmap_multi_reg_write(lt9611->regmap, seq, ARRAY_SIZE(seq)); 475 if (!ret) 476 lt9611->power_on = true; 477 478 return ret; 479 } 480 481 static int lt9611_power_off(struct lt9611 *lt9611) 482 { 483 int ret; 484 485 ret = regmap_write(lt9611->regmap, 0x8130, 0x6a); 486 if (!ret) 487 lt9611->power_on = false; 488 489 return ret; 490 } 491 492 static void lt9611_reset(struct lt9611 *lt9611) 493 { 494 gpiod_set_value_cansleep(lt9611->reset_gpio, 1); 495 msleep(20); 496 497 gpiod_set_value_cansleep(lt9611->reset_gpio, 0); 498 msleep(20); 499 500 gpiod_set_value_cansleep(lt9611->reset_gpio, 1); 501 msleep(100); 502 } 503 504 static void lt9611_assert_5v(struct lt9611 *lt9611) 505 { 506 if (!lt9611->enable_gpio) 507 return; 508 509 gpiod_set_value_cansleep(lt9611->enable_gpio, 1); 510 msleep(20); 511 } 512 513 static int lt9611_regulator_init(struct lt9611 *lt9611) 514 { 515 int ret; 516 517 lt9611->supplies[0].supply = "vdd"; 518 lt9611->supplies[1].supply = "vcc"; 519 520 ret = devm_regulator_bulk_get(lt9611->dev, 2, lt9611->supplies); 521 if (ret < 0) 522 return ret; 523 524 return regulator_set_load(lt9611->supplies[0].consumer, 300000); 525 } 526 527 static int lt9611_regulator_enable(struct lt9611 *lt9611) 528 { 529 int ret; 530 531 ret = regulator_enable(lt9611->supplies[0].consumer); 532 if (ret < 0) 533 return ret; 534 535 usleep_range(1000, 10000); 536 537 ret = regulator_enable(lt9611->supplies[1].consumer); 538 if (ret < 0) { 539 regulator_disable(lt9611->supplies[0].consumer); 540 return ret; 541 } 542 543 return 0; 544 } 545 546 static enum drm_connector_status lt9611_bridge_detect(struct drm_bridge *bridge) 547 { 548 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 549 unsigned int reg_val = 0; 550 int connected = 0; 551 552 regmap_read(lt9611->regmap, 0x825e, ®_val); 553 connected = (reg_val & (BIT(2) | BIT(0))); 554 555 lt9611->status = connected ? connector_status_connected : 556 connector_status_disconnected; 557 558 return lt9611->status; 559 } 560 561 static int lt9611_read_edid(struct lt9611 *lt9611) 562 { 563 unsigned int temp; 564 int ret = 0; 565 int i, j; 566 567 /* memset to clear old buffer, if any */ 568 memset(lt9611->edid_buf, 0, sizeof(lt9611->edid_buf)); 569 570 regmap_write(lt9611->regmap, 0x8503, 0xc9); 571 572 /* 0xA0 is EDID device address */ 573 regmap_write(lt9611->regmap, 0x8504, 0xa0); 574 /* 0x00 is EDID offset address */ 575 regmap_write(lt9611->regmap, 0x8505, 0x00); 576 577 /* length for read */ 578 regmap_write(lt9611->regmap, 0x8506, EDID_LEN); 579 regmap_write(lt9611->regmap, 0x8514, 0x7f); 580 581 for (i = 0; i < EDID_LOOP; i++) { 582 /* offset address */ 583 regmap_write(lt9611->regmap, 0x8505, i * EDID_LEN); 584 regmap_write(lt9611->regmap, 0x8507, 0x36); 585 regmap_write(lt9611->regmap, 0x8507, 0x31); 586 regmap_write(lt9611->regmap, 0x8507, 0x37); 587 usleep_range(5000, 10000); 588 589 regmap_read(lt9611->regmap, 0x8540, &temp); 590 591 if (temp & KEY_DDC_ACCS_DONE) { 592 for (j = 0; j < EDID_LEN; j++) { 593 regmap_read(lt9611->regmap, 0x8583, &temp); 594 lt9611->edid_buf[i * EDID_LEN + j] = temp; 595 } 596 597 } else if (temp & DDC_NO_ACK) { /* DDC No Ack or Abitration lost */ 598 dev_err(lt9611->dev, "read edid failed: no ack\n"); 599 ret = -EIO; 600 goto end; 601 602 } else { 603 dev_err(lt9611->dev, "read edid failed: access not done\n"); 604 ret = -EIO; 605 goto end; 606 } 607 } 608 609 end: 610 regmap_write(lt9611->regmap, 0x8507, 0x1f); 611 return ret; 612 } 613 614 static int 615 lt9611_get_edid_block(void *data, u8 *buf, unsigned int block, size_t len) 616 { 617 struct lt9611 *lt9611 = data; 618 int ret; 619 620 if (len > 128) 621 return -EINVAL; 622 623 /* supports up to 1 extension block */ 624 /* TODO: add support for more extension blocks */ 625 if (block > 1) 626 return -EINVAL; 627 628 if (block == 0) { 629 ret = lt9611_read_edid(lt9611); 630 if (ret) { 631 dev_err(lt9611->dev, "edid read failed\n"); 632 return ret; 633 } 634 } 635 636 block %= 2; 637 memcpy(buf, lt9611->edid_buf + (block * 128), len); 638 639 return 0; 640 } 641 642 /* bridge funcs */ 643 static void lt9611_bridge_atomic_enable(struct drm_bridge *bridge, 644 struct drm_atomic_state *state) 645 { 646 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 647 struct drm_connector *connector; 648 struct drm_connector_state *conn_state; 649 struct drm_crtc_state *crtc_state; 650 struct drm_display_mode *mode; 651 unsigned int postdiv; 652 653 connector = drm_atomic_get_new_connector_for_encoder(state, bridge->encoder); 654 if (WARN_ON(!connector)) 655 return; 656 657 conn_state = drm_atomic_get_new_connector_state(state, connector); 658 if (WARN_ON(!conn_state)) 659 return; 660 661 crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc); 662 if (WARN_ON(!crtc_state)) 663 return; 664 665 mode = &crtc_state->adjusted_mode; 666 667 lt9611_mipi_input_digital(lt9611, mode); 668 lt9611_pll_setup(lt9611, mode, &postdiv); 669 lt9611_mipi_video_setup(lt9611, mode); 670 lt9611_pcr_setup(lt9611, mode, postdiv); 671 672 if (lt9611_power_on(lt9611)) { 673 dev_err(lt9611->dev, "power on failed\n"); 674 return; 675 } 676 677 lt9611_mipi_input_analog(lt9611); 678 drm_atomic_helper_connector_hdmi_update_infoframes(connector, state); 679 lt9611_hdmi_tx_digital(lt9611, connector->display_info.is_hdmi); 680 lt9611_hdmi_tx_phy(lt9611); 681 682 msleep(500); 683 684 lt9611_video_check(lt9611); 685 686 /* Enable HDMI output */ 687 regmap_write(lt9611->regmap, 0x8130, 0xea); 688 } 689 690 static void lt9611_bridge_atomic_disable(struct drm_bridge *bridge, 691 struct drm_atomic_state *state) 692 { 693 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 694 int ret; 695 696 /* Disable HDMI output */ 697 ret = regmap_write(lt9611->regmap, 0x8130, 0x6a); 698 if (ret) { 699 dev_err(lt9611->dev, "video on failed\n"); 700 return; 701 } 702 703 if (lt9611_power_off(lt9611)) { 704 dev_err(lt9611->dev, "power on failed\n"); 705 return; 706 } 707 } 708 709 static struct mipi_dsi_device *lt9611_attach_dsi(struct lt9611 *lt9611, 710 struct device_node *dsi_node) 711 { 712 const struct mipi_dsi_device_info info = { "lt9611", 0, lt9611->dev->of_node}; 713 struct mipi_dsi_device *dsi; 714 struct mipi_dsi_host *host; 715 struct device *dev = lt9611->dev; 716 int ret; 717 718 host = of_find_mipi_dsi_host_by_node(dsi_node); 719 if (!host) 720 return ERR_PTR(dev_err_probe(lt9611->dev, -EPROBE_DEFER, "failed to find dsi host\n")); 721 722 dsi = devm_mipi_dsi_device_register_full(dev, host, &info); 723 if (IS_ERR(dsi)) { 724 dev_err(lt9611->dev, "failed to create dsi device\n"); 725 return dsi; 726 } 727 728 dsi->lanes = 4; 729 dsi->format = MIPI_DSI_FMT_RGB888; 730 dsi->mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_SYNC_PULSE | 731 MIPI_DSI_MODE_VIDEO_HSE; 732 733 ret = devm_mipi_dsi_attach(dev, dsi); 734 if (ret < 0) { 735 dev_err(dev, "failed to attach dsi to host\n"); 736 return ERR_PTR(ret); 737 } 738 739 return dsi; 740 } 741 742 static int lt9611_bridge_attach(struct drm_bridge *bridge, 743 enum drm_bridge_attach_flags flags) 744 { 745 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 746 747 return drm_bridge_attach(bridge->encoder, lt9611->next_bridge, 748 bridge, flags); 749 } 750 751 static enum drm_mode_status lt9611_bridge_mode_valid(struct drm_bridge *bridge, 752 const struct drm_display_info *info, 753 const struct drm_display_mode *mode) 754 { 755 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 756 757 if (mode->hdisplay > 3840) 758 return MODE_BAD_HVALUE; 759 760 if (mode->hdisplay > 2000 && !lt9611->dsi1_node) 761 return MODE_PANEL; 762 763 return MODE_OK; 764 } 765 766 static void lt9611_bridge_atomic_pre_enable(struct drm_bridge *bridge, 767 struct drm_atomic_state *state) 768 { 769 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 770 static const struct reg_sequence reg_cfg[] = { 771 { 0x8102, 0x12 }, 772 { 0x8123, 0x40 }, 773 { 0x8130, 0xea }, 774 { 0x8011, 0xfa }, 775 }; 776 777 if (!lt9611->sleep) 778 return; 779 780 regmap_multi_reg_write(lt9611->regmap, 781 reg_cfg, ARRAY_SIZE(reg_cfg)); 782 783 lt9611->sleep = false; 784 } 785 786 static void lt9611_bridge_atomic_post_disable(struct drm_bridge *bridge, 787 struct drm_atomic_state *state) 788 { 789 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 790 791 lt9611_sleep_setup(lt9611); 792 } 793 794 static const struct drm_edid *lt9611_bridge_edid_read(struct drm_bridge *bridge, 795 struct drm_connector *connector) 796 { 797 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 798 799 lt9611_power_on(lt9611); 800 return drm_edid_read_custom(connector, lt9611_get_edid_block, lt9611); 801 } 802 803 static void lt9611_bridge_hpd_enable(struct drm_bridge *bridge) 804 { 805 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 806 807 lt9611_enable_hpd_interrupts(lt9611); 808 } 809 810 #define MAX_INPUT_SEL_FORMATS 1 811 812 static u32 * 813 lt9611_atomic_get_input_bus_fmts(struct drm_bridge *bridge, 814 struct drm_bridge_state *bridge_state, 815 struct drm_crtc_state *crtc_state, 816 struct drm_connector_state *conn_state, 817 u32 output_fmt, 818 unsigned int *num_input_fmts) 819 { 820 u32 *input_fmts; 821 822 *num_input_fmts = 0; 823 824 input_fmts = kcalloc(MAX_INPUT_SEL_FORMATS, sizeof(*input_fmts), 825 GFP_KERNEL); 826 if (!input_fmts) 827 return NULL; 828 829 /* This is the DSI-end bus format */ 830 input_fmts[0] = MEDIA_BUS_FMT_RGB888_1X24; 831 *num_input_fmts = 1; 832 833 return input_fmts; 834 } 835 836 /* 837 * Other working frames: 838 * - 0x01, 0x84df 839 * - 0x04, 0x84c0 840 */ 841 #define LT9611_INFOFRAME_AUDIO 0x02 842 #define LT9611_INFOFRAME_AVI 0x08 843 #define LT9611_INFOFRAME_SPD 0x10 844 #define LT9611_INFOFRAME_VENDOR 0x20 845 846 static int lt9611_hdmi_clear_infoframe(struct drm_bridge *bridge, 847 enum hdmi_infoframe_type type) 848 { 849 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 850 unsigned int mask; 851 852 switch (type) { 853 case HDMI_INFOFRAME_TYPE_AUDIO: 854 mask = LT9611_INFOFRAME_AUDIO; 855 break; 856 857 case HDMI_INFOFRAME_TYPE_AVI: 858 mask = LT9611_INFOFRAME_AVI; 859 break; 860 861 case HDMI_INFOFRAME_TYPE_SPD: 862 mask = LT9611_INFOFRAME_SPD; 863 break; 864 865 case HDMI_INFOFRAME_TYPE_VENDOR: 866 mask = LT9611_INFOFRAME_VENDOR; 867 break; 868 869 default: 870 drm_dbg_driver(lt9611->bridge.dev, "Unsupported HDMI InfoFrame %x\n", type); 871 mask = 0; 872 break; 873 } 874 875 if (mask) 876 regmap_update_bits(lt9611->regmap, 0x843d, mask, 0); 877 878 return 0; 879 } 880 881 static int lt9611_hdmi_write_infoframe(struct drm_bridge *bridge, 882 enum hdmi_infoframe_type type, 883 const u8 *buffer, size_t len) 884 { 885 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 886 unsigned int mask, addr; 887 int i; 888 889 switch (type) { 890 case HDMI_INFOFRAME_TYPE_AUDIO: 891 mask = LT9611_INFOFRAME_AUDIO; 892 addr = 0x84b2; 893 break; 894 895 case HDMI_INFOFRAME_TYPE_AVI: 896 mask = LT9611_INFOFRAME_AVI; 897 addr = 0x8440; 898 break; 899 900 case HDMI_INFOFRAME_TYPE_SPD: 901 mask = LT9611_INFOFRAME_SPD; 902 addr = 0x8493; 903 break; 904 905 case HDMI_INFOFRAME_TYPE_VENDOR: 906 mask = LT9611_INFOFRAME_VENDOR; 907 addr = 0x8474; 908 break; 909 910 default: 911 drm_dbg_driver(lt9611->bridge.dev, "Unsupported HDMI InfoFrame %x\n", type); 912 mask = 0; 913 break; 914 } 915 916 if (mask) { 917 for (i = 0; i < len; i++) 918 regmap_write(lt9611->regmap, addr + i, buffer[i]); 919 920 regmap_update_bits(lt9611->regmap, 0x843d, mask, mask); 921 } 922 923 return 0; 924 } 925 926 static enum drm_mode_status 927 lt9611_hdmi_tmds_char_rate_valid(const struct drm_bridge *bridge, 928 const struct drm_display_mode *mode, 929 unsigned long long tmds_rate) 930 { 931 /* 297 MHz for 4k@30 mode */ 932 if (tmds_rate > 297000000) 933 return MODE_CLOCK_HIGH; 934 935 return MODE_OK; 936 } 937 938 static int lt9611_hdmi_audio_startup(struct drm_connector *connector, 939 struct drm_bridge *bridge) 940 { 941 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 942 943 regmap_write(lt9611->regmap, 0x82d6, 0x8c); 944 regmap_write(lt9611->regmap, 0x82d7, 0x04); 945 946 regmap_write(lt9611->regmap, 0x8406, 0x08); 947 regmap_write(lt9611->regmap, 0x8407, 0x10); 948 949 regmap_write(lt9611->regmap, 0x8434, 0xd5); 950 951 return 0; 952 } 953 954 static int lt9611_hdmi_audio_prepare(struct drm_connector *connector, 955 struct drm_bridge *bridge, 956 struct hdmi_codec_daifmt *fmt, 957 struct hdmi_codec_params *hparms) 958 { 959 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 960 961 if (hparms->sample_rate == 48000) 962 regmap_write(lt9611->regmap, 0x840f, 0x2b); 963 else if (hparms->sample_rate == 96000) 964 regmap_write(lt9611->regmap, 0x840f, 0xab); 965 else 966 return -EINVAL; 967 968 regmap_write(lt9611->regmap, 0x8435, 0x00); 969 regmap_write(lt9611->regmap, 0x8436, 0x18); 970 regmap_write(lt9611->regmap, 0x8437, 0x00); 971 972 return drm_atomic_helper_connector_hdmi_update_audio_infoframe(connector, 973 &hparms->cea); 974 } 975 976 static void lt9611_hdmi_audio_shutdown(struct drm_connector *connector, 977 struct drm_bridge *bridge) 978 { 979 struct lt9611 *lt9611 = bridge_to_lt9611(bridge); 980 981 drm_atomic_helper_connector_hdmi_clear_audio_infoframe(connector); 982 983 regmap_write(lt9611->regmap, 0x8406, 0x00); 984 regmap_write(lt9611->regmap, 0x8407, 0x00); 985 } 986 987 static const struct drm_bridge_funcs lt9611_bridge_funcs = { 988 .attach = lt9611_bridge_attach, 989 .mode_valid = lt9611_bridge_mode_valid, 990 .detect = lt9611_bridge_detect, 991 .edid_read = lt9611_bridge_edid_read, 992 .hpd_enable = lt9611_bridge_hpd_enable, 993 994 .atomic_pre_enable = lt9611_bridge_atomic_pre_enable, 995 .atomic_enable = lt9611_bridge_atomic_enable, 996 .atomic_disable = lt9611_bridge_atomic_disable, 997 .atomic_post_disable = lt9611_bridge_atomic_post_disable, 998 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, 999 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, 1000 .atomic_reset = drm_atomic_helper_bridge_reset, 1001 .atomic_get_input_bus_fmts = lt9611_atomic_get_input_bus_fmts, 1002 1003 .hdmi_tmds_char_rate_valid = lt9611_hdmi_tmds_char_rate_valid, 1004 .hdmi_write_infoframe = lt9611_hdmi_write_infoframe, 1005 .hdmi_clear_infoframe = lt9611_hdmi_clear_infoframe, 1006 1007 .hdmi_audio_startup = lt9611_hdmi_audio_startup, 1008 .hdmi_audio_prepare = lt9611_hdmi_audio_prepare, 1009 .hdmi_audio_shutdown = lt9611_hdmi_audio_shutdown, 1010 }; 1011 1012 static int lt9611_parse_dt(struct device *dev, 1013 struct lt9611 *lt9611) 1014 { 1015 lt9611->dsi0_node = of_graph_get_remote_node(dev->of_node, 0, -1); 1016 if (!lt9611->dsi0_node) { 1017 dev_err(lt9611->dev, "failed to get remote node for primary dsi\n"); 1018 return -ENODEV; 1019 } 1020 1021 lt9611->dsi1_node = of_graph_get_remote_node(dev->of_node, 1, -1); 1022 1023 lt9611->ac_mode = of_property_read_bool(dev->of_node, "lt,ac-mode"); 1024 1025 return drm_of_find_panel_or_bridge(dev->of_node, 2, -1, NULL, <9611->next_bridge); 1026 } 1027 1028 static int lt9611_gpio_init(struct lt9611 *lt9611) 1029 { 1030 struct device *dev = lt9611->dev; 1031 1032 lt9611->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); 1033 if (IS_ERR(lt9611->reset_gpio)) { 1034 dev_err(dev, "failed to acquire reset gpio\n"); 1035 return PTR_ERR(lt9611->reset_gpio); 1036 } 1037 1038 lt9611->enable_gpio = devm_gpiod_get_optional(dev, "enable", 1039 GPIOD_OUT_LOW); 1040 if (IS_ERR(lt9611->enable_gpio)) { 1041 dev_err(dev, "failed to acquire enable gpio\n"); 1042 return PTR_ERR(lt9611->enable_gpio); 1043 } 1044 1045 return 0; 1046 } 1047 1048 static int lt9611_read_device_rev(struct lt9611 *lt9611) 1049 { 1050 unsigned int rev; 1051 int ret; 1052 1053 regmap_write(lt9611->regmap, 0x80ee, 0x01); 1054 ret = regmap_read(lt9611->regmap, 0x8002, &rev); 1055 if (ret) 1056 dev_err(lt9611->dev, "failed to read revision: %d\n", ret); 1057 else 1058 dev_info(lt9611->dev, "LT9611 revision: 0x%x\n", rev); 1059 1060 return ret; 1061 } 1062 1063 static int lt9611_probe(struct i2c_client *client) 1064 { 1065 struct lt9611 *lt9611; 1066 struct device *dev = &client->dev; 1067 int ret; 1068 1069 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 1070 dev_err(dev, "device doesn't support I2C\n"); 1071 return -ENODEV; 1072 } 1073 1074 lt9611 = devm_kzalloc(dev, sizeof(*lt9611), GFP_KERNEL); 1075 if (!lt9611) 1076 return -ENOMEM; 1077 1078 lt9611->dev = dev; 1079 lt9611->client = client; 1080 lt9611->sleep = false; 1081 1082 lt9611->regmap = devm_regmap_init_i2c(client, <9611_regmap_config); 1083 if (IS_ERR(lt9611->regmap)) { 1084 dev_err(lt9611->dev, "regmap i2c init failed\n"); 1085 return PTR_ERR(lt9611->regmap); 1086 } 1087 1088 ret = lt9611_parse_dt(dev, lt9611); 1089 if (ret) { 1090 dev_err(dev, "failed to parse device tree\n"); 1091 return ret; 1092 } 1093 1094 ret = lt9611_gpio_init(lt9611); 1095 if (ret < 0) 1096 goto err_of_put; 1097 1098 ret = lt9611_regulator_init(lt9611); 1099 if (ret < 0) 1100 goto err_of_put; 1101 1102 lt9611_assert_5v(lt9611); 1103 1104 ret = lt9611_regulator_enable(lt9611); 1105 if (ret) 1106 goto err_of_put; 1107 1108 lt9611_reset(lt9611); 1109 1110 ret = lt9611_read_device_rev(lt9611); 1111 if (ret) { 1112 dev_err(dev, "failed to read chip rev\n"); 1113 goto err_disable_regulators; 1114 } 1115 1116 ret = devm_request_threaded_irq(dev, client->irq, NULL, 1117 lt9611_irq_thread_handler, 1118 IRQF_ONESHOT, "lt9611", lt9611); 1119 if (ret) { 1120 dev_err(dev, "failed to request irq\n"); 1121 goto err_disable_regulators; 1122 } 1123 1124 i2c_set_clientdata(client, lt9611); 1125 1126 /* Disable Audio InfoFrame, enabled by default */ 1127 regmap_update_bits(lt9611->regmap, 0x843d, LT9611_INFOFRAME_AUDIO, 0); 1128 1129 lt9611->bridge.funcs = <9611_bridge_funcs; 1130 lt9611->bridge.of_node = client->dev.of_node; 1131 lt9611->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID | 1132 DRM_BRIDGE_OP_HPD | DRM_BRIDGE_OP_MODES | 1133 DRM_BRIDGE_OP_HDMI; 1134 lt9611->bridge.type = DRM_MODE_CONNECTOR_HDMIA; 1135 lt9611->bridge.vendor = "Lontium"; 1136 lt9611->bridge.product = "LT9611"; 1137 lt9611->bridge.hdmi_audio_dev = dev; 1138 lt9611->bridge.hdmi_audio_max_i2s_playback_channels = 8; 1139 lt9611->bridge.hdmi_audio_dai_port = 2; 1140 1141 drm_bridge_add(<9611->bridge); 1142 1143 /* Attach primary DSI */ 1144 lt9611->dsi0 = lt9611_attach_dsi(lt9611, lt9611->dsi0_node); 1145 if (IS_ERR(lt9611->dsi0)) { 1146 ret = PTR_ERR(lt9611->dsi0); 1147 goto err_remove_bridge; 1148 } 1149 1150 /* Attach secondary DSI, if specified */ 1151 if (lt9611->dsi1_node) { 1152 lt9611->dsi1 = lt9611_attach_dsi(lt9611, lt9611->dsi1_node); 1153 if (IS_ERR(lt9611->dsi1)) { 1154 ret = PTR_ERR(lt9611->dsi1); 1155 goto err_remove_bridge; 1156 } 1157 } 1158 1159 lt9611_enable_hpd_interrupts(lt9611); 1160 1161 return 0; 1162 1163 err_remove_bridge: 1164 drm_bridge_remove(<9611->bridge); 1165 1166 err_disable_regulators: 1167 regulator_bulk_disable(ARRAY_SIZE(lt9611->supplies), lt9611->supplies); 1168 1169 err_of_put: 1170 of_node_put(lt9611->dsi1_node); 1171 of_node_put(lt9611->dsi0_node); 1172 1173 return ret; 1174 } 1175 1176 static void lt9611_remove(struct i2c_client *client) 1177 { 1178 struct lt9611 *lt9611 = i2c_get_clientdata(client); 1179 1180 disable_irq(client->irq); 1181 drm_bridge_remove(<9611->bridge); 1182 1183 regulator_bulk_disable(ARRAY_SIZE(lt9611->supplies), lt9611->supplies); 1184 1185 of_node_put(lt9611->dsi1_node); 1186 of_node_put(lt9611->dsi0_node); 1187 } 1188 1189 static const struct i2c_device_id lt9611_id[] = { 1190 { "lontium,lt9611" }, 1191 {} 1192 }; 1193 MODULE_DEVICE_TABLE(i2c, lt9611_id); 1194 1195 static const struct of_device_id lt9611_match_table[] = { 1196 { .compatible = "lontium,lt9611" }, 1197 { } 1198 }; 1199 MODULE_DEVICE_TABLE(of, lt9611_match_table); 1200 1201 static struct i2c_driver lt9611_driver = { 1202 .driver = { 1203 .name = "lt9611", 1204 .of_match_table = lt9611_match_table, 1205 }, 1206 .probe = lt9611_probe, 1207 .remove = lt9611_remove, 1208 .id_table = lt9611_id, 1209 }; 1210 module_i2c_driver(lt9611_driver); 1211 1212 MODULE_DESCRIPTION("Lontium LT9611 DSI/HDMI bridge driver"); 1213 MODULE_LICENSE("GPL v2"); 1214