1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2018, The Linux Foundation. All rights reserved. 4 */ 5 6 #include <linux/device.h> 7 #include <linux/delay.h> 8 #include <linux/gpio/consumer.h> 9 #include <linux/i2c.h> 10 #include <linux/regmap.h> 11 12 #include <drm/drm_probe_helper.h> 13 #include <drm/drm_atomic_helper.h> 14 #include <drm/drm_mipi_dsi.h> 15 #include <drm/drm_of.h> 16 17 #include <video/videomode.h> 18 19 #define I2C_MAIN 0 20 #define I2C_ADDR_MAIN 0x48 21 22 #define I2C_CEC_DSI 1 23 #define I2C_ADDR_CEC_DSI 0x49 24 25 #define I2C_MAX_IDX 2 26 27 struct lt8912 { 28 struct device *dev; 29 struct drm_bridge bridge; 30 struct drm_connector connector; 31 32 struct i2c_client *i2c_client[I2C_MAX_IDX]; 33 struct regmap *regmap[I2C_MAX_IDX]; 34 35 struct device_node *host_node; 36 struct drm_bridge *hdmi_port; 37 38 struct mipi_dsi_device *dsi; 39 40 struct gpio_desc *gp_reset; 41 42 struct videomode mode; 43 44 u8 data_lanes; 45 bool is_power_on; 46 bool is_attached; 47 }; 48 49 static int lt8912_write_init_config(struct lt8912 *lt) 50 { 51 const struct reg_sequence seq[] = { 52 /* Digital clock en*/ 53 {0x08, 0xff}, 54 {0x09, 0xff}, 55 {0x0a, 0xff}, 56 {0x0b, 0x7c}, 57 {0x0c, 0xff}, 58 {0x42, 0x04}, 59 60 /*Tx Analog*/ 61 {0x31, 0xb1}, 62 {0x32, 0xb1}, 63 {0x33, 0x0e}, 64 {0x37, 0x00}, 65 {0x38, 0x22}, 66 {0x60, 0x82}, 67 68 /*Cbus Analog*/ 69 {0x39, 0x45}, 70 {0x3a, 0x00}, 71 {0x3b, 0x00}, 72 73 /*HDMI Pll Analog*/ 74 {0x44, 0x31}, 75 {0x55, 0x44}, 76 {0x57, 0x01}, 77 {0x5a, 0x02}, 78 79 /*MIPI Analog*/ 80 {0x3e, 0xd6}, 81 {0x3f, 0xd4}, 82 {0x41, 0x3c}, 83 {0xB2, 0x00}, 84 }; 85 86 return regmap_multi_reg_write(lt->regmap[I2C_MAIN], seq, ARRAY_SIZE(seq)); 87 } 88 89 static int lt8912_write_mipi_basic_config(struct lt8912 *lt) 90 { 91 const struct reg_sequence seq[] = { 92 {0x12, 0x04}, 93 {0x14, 0x00}, 94 {0x15, 0x00}, 95 {0x1a, 0x03}, 96 {0x1b, 0x03}, 97 }; 98 99 return regmap_multi_reg_write(lt->regmap[I2C_CEC_DSI], seq, ARRAY_SIZE(seq)); 100 }; 101 102 static int lt8912_write_dds_config(struct lt8912 *lt) 103 { 104 const struct reg_sequence seq[] = { 105 {0x4e, 0xff}, 106 {0x4f, 0x56}, 107 {0x50, 0x69}, 108 {0x51, 0x80}, 109 {0x1f, 0x5e}, 110 {0x20, 0x01}, 111 {0x21, 0x2c}, 112 {0x22, 0x01}, 113 {0x23, 0xfa}, 114 {0x24, 0x00}, 115 {0x25, 0xc8}, 116 {0x26, 0x00}, 117 {0x27, 0x5e}, 118 {0x28, 0x01}, 119 {0x29, 0x2c}, 120 {0x2a, 0x01}, 121 {0x2b, 0xfa}, 122 {0x2c, 0x00}, 123 {0x2d, 0xc8}, 124 {0x2e, 0x00}, 125 {0x42, 0x64}, 126 {0x43, 0x00}, 127 {0x44, 0x04}, 128 {0x45, 0x00}, 129 {0x46, 0x59}, 130 {0x47, 0x00}, 131 {0x48, 0xf2}, 132 {0x49, 0x06}, 133 {0x4a, 0x00}, 134 {0x4b, 0x72}, 135 {0x4c, 0x45}, 136 {0x4d, 0x00}, 137 {0x52, 0x08}, 138 {0x53, 0x00}, 139 {0x54, 0xb2}, 140 {0x55, 0x00}, 141 {0x56, 0xe4}, 142 {0x57, 0x0d}, 143 {0x58, 0x00}, 144 {0x59, 0xe4}, 145 {0x5a, 0x8a}, 146 {0x5b, 0x00}, 147 {0x5c, 0x34}, 148 {0x1e, 0x4f}, 149 {0x51, 0x00}, 150 }; 151 152 return regmap_multi_reg_write(lt->regmap[I2C_CEC_DSI], seq, ARRAY_SIZE(seq)); 153 } 154 155 static int lt8912_write_rxlogicres_config(struct lt8912 *lt) 156 { 157 int ret; 158 159 ret = regmap_write(lt->regmap[I2C_MAIN], 0x03, 0x7f); 160 usleep_range(10000, 20000); 161 ret |= regmap_write(lt->regmap[I2C_MAIN], 0x03, 0xff); 162 163 return ret; 164 }; 165 166 static int lt8912_write_lvds_config(struct lt8912 *lt) 167 { 168 const struct reg_sequence seq[] = { 169 {0x44, 0x30}, 170 {0x51, 0x05}, 171 {0x50, 0x24}, 172 {0x51, 0x2d}, 173 {0x52, 0x04}, 174 {0x69, 0x0e}, 175 {0x69, 0x8e}, 176 {0x6a, 0x00}, 177 {0x6c, 0xb8}, 178 {0x6b, 0x51}, 179 {0x04, 0xfb}, 180 {0x04, 0xff}, 181 {0x7f, 0x00}, 182 {0xa8, 0x13}, 183 {0x02, 0xf7}, 184 {0x02, 0xff}, 185 {0x03, 0xcf}, 186 {0x03, 0xff}, 187 }; 188 189 return regmap_multi_reg_write(lt->regmap[I2C_CEC_DSI], seq, ARRAY_SIZE(seq)); 190 }; 191 192 static inline struct lt8912 *bridge_to_lt8912(struct drm_bridge *b) 193 { 194 return container_of(b, struct lt8912, bridge); 195 } 196 197 static inline struct lt8912 *connector_to_lt8912(struct drm_connector *c) 198 { 199 return container_of(c, struct lt8912, connector); 200 } 201 202 static const struct regmap_config lt8912_regmap_config = { 203 .reg_bits = 8, 204 .val_bits = 8, 205 .max_register = 0xff, 206 }; 207 208 static int lt8912_init_i2c(struct lt8912 *lt, struct i2c_client *client) 209 { 210 unsigned int i; 211 /* 212 * At this time we only initialize 2 chips, but the lt8912 provides 213 * a third interface for the audio over HDMI configuration. 214 */ 215 struct i2c_board_info info[] = { 216 { I2C_BOARD_INFO("lt8912p0", I2C_ADDR_MAIN), }, 217 { I2C_BOARD_INFO("lt8912p1", I2C_ADDR_CEC_DSI), }, 218 }; 219 220 if (!lt) 221 return -ENODEV; 222 223 for (i = 0; i < ARRAY_SIZE(info); i++) { 224 if (i > 0) { 225 lt->i2c_client[i] = i2c_new_dummy_device(client->adapter, 226 info[i].addr); 227 if (IS_ERR(lt->i2c_client[i])) 228 return PTR_ERR(lt->i2c_client[i]); 229 } 230 231 lt->regmap[i] = devm_regmap_init_i2c(lt->i2c_client[i], 232 <8912_regmap_config); 233 if (IS_ERR(lt->regmap[i])) 234 return PTR_ERR(lt->regmap[i]); 235 } 236 return 0; 237 } 238 239 static int lt8912_free_i2c(struct lt8912 *lt) 240 { 241 unsigned int i; 242 243 for (i = 1; i < I2C_MAX_IDX; i++) 244 i2c_unregister_device(lt->i2c_client[i]); 245 246 return 0; 247 } 248 249 static int lt8912_hard_power_on(struct lt8912 *lt) 250 { 251 gpiod_set_value_cansleep(lt->gp_reset, 0); 252 msleep(20); 253 254 return 0; 255 } 256 257 static void lt8912_hard_power_off(struct lt8912 *lt) 258 { 259 gpiod_set_value_cansleep(lt->gp_reset, 1); 260 msleep(20); 261 lt->is_power_on = false; 262 } 263 264 static int lt8912_video_setup(struct lt8912 *lt) 265 { 266 u32 hactive, h_total, hpw, hfp, hbp; 267 u32 vactive, v_total, vpw, vfp, vbp; 268 u8 settle = 0x08; 269 int ret; 270 271 if (!lt) 272 return -EINVAL; 273 274 hactive = lt->mode.hactive; 275 hfp = lt->mode.hfront_porch; 276 hpw = lt->mode.hsync_len; 277 hbp = lt->mode.hback_porch; 278 h_total = hactive + hfp + hpw + hbp; 279 280 vactive = lt->mode.vactive; 281 vfp = lt->mode.vfront_porch; 282 vpw = lt->mode.vsync_len; 283 vbp = lt->mode.vback_porch; 284 v_total = vactive + vfp + vpw + vbp; 285 286 if (vactive <= 600) 287 settle = 0x04; 288 else if (vactive == 1080) 289 settle = 0x0a; 290 291 ret = regmap_write(lt->regmap[I2C_CEC_DSI], 0x10, 0x01); 292 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x11, settle); 293 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x18, hpw); 294 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x19, vpw); 295 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x1c, hactive & 0xff); 296 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x1d, hactive >> 8); 297 298 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x2f, 0x0c); 299 300 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x34, h_total & 0xff); 301 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x35, h_total >> 8); 302 303 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x36, v_total & 0xff); 304 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x37, v_total >> 8); 305 306 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x38, vbp & 0xff); 307 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x39, vbp >> 8); 308 309 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x3a, vfp & 0xff); 310 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x3b, vfp >> 8); 311 312 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x3c, hbp & 0xff); 313 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x3d, hbp >> 8); 314 315 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x3e, hfp & 0xff); 316 ret |= regmap_write(lt->regmap[I2C_CEC_DSI], 0x3f, hfp >> 8); 317 318 return ret; 319 } 320 321 static int lt8912_soft_power_on(struct lt8912 *lt) 322 { 323 if (!lt->is_power_on) { 324 u32 lanes = lt->data_lanes; 325 326 lt8912_write_init_config(lt); 327 regmap_write(lt->regmap[I2C_CEC_DSI], 0x13, lanes & 3); 328 329 lt8912_write_mipi_basic_config(lt); 330 331 lt->is_power_on = true; 332 } 333 334 return 0; 335 } 336 337 static int lt8912_video_on(struct lt8912 *lt) 338 { 339 int ret; 340 341 ret = lt8912_video_setup(lt); 342 if (ret < 0) 343 goto end; 344 345 ret = lt8912_write_dds_config(lt); 346 if (ret < 0) 347 goto end; 348 349 ret = lt8912_write_rxlogicres_config(lt); 350 if (ret < 0) 351 goto end; 352 353 ret = lt8912_write_lvds_config(lt); 354 if (ret < 0) 355 goto end; 356 357 end: 358 return ret; 359 } 360 361 static enum drm_connector_status lt8912_check_cable_status(struct lt8912 *lt) 362 { 363 int ret; 364 unsigned int reg_val; 365 366 ret = regmap_read(lt->regmap[I2C_MAIN], 0xC1, ®_val); 367 if (ret) 368 return connector_status_unknown; 369 370 if (reg_val & BIT(7)) 371 return connector_status_connected; 372 373 return connector_status_disconnected; 374 } 375 376 static enum drm_connector_status 377 lt8912_connector_detect(struct drm_connector *connector, bool force) 378 { 379 struct lt8912 *lt = connector_to_lt8912(connector); 380 381 if (lt->hdmi_port->ops & DRM_BRIDGE_OP_DETECT) 382 return drm_bridge_detect(lt->hdmi_port); 383 384 return lt8912_check_cable_status(lt); 385 } 386 387 static const struct drm_connector_funcs lt8912_connector_funcs = { 388 .detect = lt8912_connector_detect, 389 .fill_modes = drm_helper_probe_single_connector_modes, 390 .destroy = drm_connector_cleanup, 391 .reset = drm_atomic_helper_connector_reset, 392 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 393 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 394 }; 395 396 static enum drm_mode_status 397 lt8912_connector_mode_valid(struct drm_connector *connector, 398 struct drm_display_mode *mode) 399 { 400 if (mode->clock > 150000) 401 return MODE_CLOCK_HIGH; 402 403 if (mode->hdisplay > 1920) 404 return MODE_BAD_HVALUE; 405 406 if (mode->vdisplay > 1080) 407 return MODE_BAD_VVALUE; 408 409 return MODE_OK; 410 } 411 412 static int lt8912_connector_get_modes(struct drm_connector *connector) 413 { 414 struct edid *edid; 415 int ret = -1; 416 int num = 0; 417 struct lt8912 *lt = connector_to_lt8912(connector); 418 u32 bus_format = MEDIA_BUS_FMT_RGB888_1X24; 419 420 edid = drm_bridge_get_edid(lt->hdmi_port, connector); 421 if (edid) { 422 drm_connector_update_edid_property(connector, edid); 423 num = drm_add_edid_modes(connector, edid); 424 } else { 425 return ret; 426 } 427 428 ret = drm_display_info_set_bus_formats(&connector->display_info, 429 &bus_format, 1); 430 if (ret) 431 num = ret; 432 433 kfree(edid); 434 return num; 435 } 436 437 static const struct drm_connector_helper_funcs lt8912_connector_helper_funcs = { 438 .get_modes = lt8912_connector_get_modes, 439 .mode_valid = lt8912_connector_mode_valid, 440 }; 441 442 static void lt8912_bridge_mode_set(struct drm_bridge *bridge, 443 const struct drm_display_mode *mode, 444 const struct drm_display_mode *adj) 445 { 446 struct lt8912 *lt = bridge_to_lt8912(bridge); 447 448 drm_display_mode_to_videomode(adj, <->mode); 449 } 450 451 static void lt8912_bridge_enable(struct drm_bridge *bridge) 452 { 453 struct lt8912 *lt = bridge_to_lt8912(bridge); 454 455 lt8912_video_on(lt); 456 } 457 458 static int lt8912_attach_dsi(struct lt8912 *lt) 459 { 460 struct device *dev = lt->dev; 461 struct mipi_dsi_host *host; 462 struct mipi_dsi_device *dsi; 463 int ret = -1; 464 const struct mipi_dsi_device_info info = { .type = "lt8912", 465 .channel = 0, 466 .node = NULL, 467 }; 468 469 host = of_find_mipi_dsi_host_by_node(lt->host_node); 470 if (!host) { 471 dev_err(dev, "failed to find dsi host\n"); 472 return -EPROBE_DEFER; 473 } 474 475 dsi = devm_mipi_dsi_device_register_full(dev, host, &info); 476 if (IS_ERR(dsi)) { 477 ret = PTR_ERR(dsi); 478 dev_err(dev, "failed to create dsi device (%d)\n", ret); 479 return ret; 480 } 481 482 lt->dsi = dsi; 483 484 dsi->lanes = lt->data_lanes; 485 dsi->format = MIPI_DSI_FMT_RGB888; 486 487 dsi->mode_flags = MIPI_DSI_MODE_VIDEO | 488 MIPI_DSI_MODE_VIDEO_BURST | 489 MIPI_DSI_MODE_LPM | 490 MIPI_DSI_MODE_NO_EOT_PACKET; 491 492 ret = devm_mipi_dsi_attach(dev, dsi); 493 if (ret < 0) { 494 dev_err(dev, "failed to attach dsi to host\n"); 495 return ret; 496 } 497 498 return 0; 499 } 500 501 static int lt8912_bridge_connector_init(struct drm_bridge *bridge) 502 { 503 int ret; 504 struct lt8912 *lt = bridge_to_lt8912(bridge); 505 struct drm_connector *connector = <->connector; 506 507 connector->polled = DRM_CONNECTOR_POLL_CONNECT | 508 DRM_CONNECTOR_POLL_DISCONNECT; 509 510 ret = drm_connector_init(bridge->dev, connector, 511 <8912_connector_funcs, 512 lt->hdmi_port->type); 513 if (ret) 514 goto exit; 515 516 drm_connector_helper_add(connector, <8912_connector_helper_funcs); 517 518 connector->dpms = DRM_MODE_DPMS_OFF; 519 drm_connector_attach_encoder(connector, bridge->encoder); 520 521 exit: 522 return ret; 523 } 524 525 static int lt8912_bridge_attach(struct drm_bridge *bridge, 526 enum drm_bridge_attach_flags flags) 527 { 528 struct lt8912 *lt = bridge_to_lt8912(bridge); 529 int ret; 530 531 if (!(flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)) { 532 ret = lt8912_bridge_connector_init(bridge); 533 if (ret) { 534 dev_err(lt->dev, "Failed to init bridge ! (%d)\n", ret); 535 return ret; 536 } 537 } 538 539 ret = lt8912_hard_power_on(lt); 540 if (ret) 541 return ret; 542 543 ret = lt8912_soft_power_on(lt); 544 if (ret) 545 goto error; 546 547 lt->is_attached = true; 548 549 return 0; 550 551 error: 552 lt8912_hard_power_off(lt); 553 return ret; 554 } 555 556 static void lt8912_bridge_detach(struct drm_bridge *bridge) 557 { 558 struct lt8912 *lt = bridge_to_lt8912(bridge); 559 560 if (lt->is_attached) { 561 lt8912_hard_power_off(lt); 562 drm_connector_unregister(<->connector); 563 drm_connector_cleanup(<->connector); 564 } 565 } 566 567 static enum drm_connector_status 568 lt8912_bridge_detect(struct drm_bridge *bridge) 569 { 570 struct lt8912 *lt = bridge_to_lt8912(bridge); 571 572 if (lt->hdmi_port->ops & DRM_BRIDGE_OP_DETECT) 573 return drm_bridge_detect(lt->hdmi_port); 574 575 return lt8912_check_cable_status(lt); 576 } 577 578 static struct edid *lt8912_bridge_get_edid(struct drm_bridge *bridge, 579 struct drm_connector *connector) 580 { 581 struct lt8912 *lt = bridge_to_lt8912(bridge); 582 583 /* 584 * edid must be read through the ddc bus but it must be 585 * given to the hdmi connector node. 586 */ 587 if (lt->hdmi_port->ops & DRM_BRIDGE_OP_EDID) 588 return drm_bridge_get_edid(lt->hdmi_port, connector); 589 590 dev_warn(lt->dev, "The connected bridge does not supports DRM_BRIDGE_OP_EDID\n"); 591 return NULL; 592 } 593 594 static const struct drm_bridge_funcs lt8912_bridge_funcs = { 595 .attach = lt8912_bridge_attach, 596 .detach = lt8912_bridge_detach, 597 .mode_set = lt8912_bridge_mode_set, 598 .enable = lt8912_bridge_enable, 599 .detect = lt8912_bridge_detect, 600 .get_edid = lt8912_bridge_get_edid, 601 }; 602 603 static int lt8912_parse_dt(struct lt8912 *lt) 604 { 605 struct gpio_desc *gp_reset; 606 struct device *dev = lt->dev; 607 int ret; 608 int data_lanes; 609 struct device_node *port_node; 610 struct device_node *endpoint; 611 612 gp_reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); 613 if (IS_ERR(gp_reset)) { 614 ret = PTR_ERR(gp_reset); 615 if (ret != -EPROBE_DEFER) 616 dev_err(dev, "Failed to get reset gpio: %d\n", ret); 617 return ret; 618 } 619 lt->gp_reset = gp_reset; 620 621 endpoint = of_graph_get_endpoint_by_regs(dev->of_node, 0, -1); 622 if (!endpoint) 623 return -ENODEV; 624 625 data_lanes = of_property_count_u32_elems(endpoint, "data-lanes"); 626 of_node_put(endpoint); 627 if (data_lanes < 0) { 628 dev_err(lt->dev, "%s: Bad data-lanes property\n", __func__); 629 return data_lanes; 630 } 631 lt->data_lanes = data_lanes; 632 633 lt->host_node = of_graph_get_remote_node(dev->of_node, 0, -1); 634 if (!lt->host_node) { 635 dev_err(lt->dev, "%s: Failed to get remote port\n", __func__); 636 return -ENODEV; 637 } 638 639 port_node = of_graph_get_remote_node(dev->of_node, 1, -1); 640 if (!port_node) { 641 dev_err(lt->dev, "%s: Failed to get connector port\n", __func__); 642 ret = -ENODEV; 643 goto err_free_host_node; 644 } 645 646 lt->hdmi_port = of_drm_find_bridge(port_node); 647 if (!lt->hdmi_port) { 648 dev_err(lt->dev, "%s: Failed to get hdmi port\n", __func__); 649 ret = -ENODEV; 650 goto err_free_host_node; 651 } 652 653 if (!of_device_is_compatible(port_node, "hdmi-connector")) { 654 dev_err(lt->dev, "%s: Failed to get hdmi port\n", __func__); 655 ret = -EINVAL; 656 goto err_free_host_node; 657 } 658 659 of_node_put(port_node); 660 return 0; 661 662 err_free_host_node: 663 of_node_put(port_node); 664 of_node_put(lt->host_node); 665 return ret; 666 } 667 668 static int lt8912_put_dt(struct lt8912 *lt) 669 { 670 of_node_put(lt->host_node); 671 return 0; 672 } 673 674 static int lt8912_probe(struct i2c_client *client, 675 const struct i2c_device_id *id) 676 { 677 static struct lt8912 *lt; 678 int ret = 0; 679 struct device *dev = &client->dev; 680 681 lt = devm_kzalloc(dev, sizeof(struct lt8912), GFP_KERNEL); 682 if (!lt) 683 return -ENOMEM; 684 685 lt->dev = dev; 686 lt->i2c_client[0] = client; 687 688 ret = lt8912_parse_dt(lt); 689 if (ret) 690 goto err_dt_parse; 691 692 ret = lt8912_init_i2c(lt, client); 693 if (ret) 694 goto err_i2c; 695 696 i2c_set_clientdata(client, lt); 697 698 lt->bridge.funcs = <8912_bridge_funcs; 699 lt->bridge.of_node = dev->of_node; 700 lt->bridge.ops = (DRM_BRIDGE_OP_EDID | 701 DRM_BRIDGE_OP_DETECT); 702 703 drm_bridge_add(<->bridge); 704 705 ret = lt8912_attach_dsi(lt); 706 if (ret) 707 goto err_attach; 708 709 return 0; 710 711 err_attach: 712 drm_bridge_remove(<->bridge); 713 lt8912_free_i2c(lt); 714 err_i2c: 715 lt8912_put_dt(lt); 716 err_dt_parse: 717 return ret; 718 } 719 720 static int lt8912_remove(struct i2c_client *client) 721 { 722 struct lt8912 *lt = i2c_get_clientdata(client); 723 724 lt8912_bridge_detach(<->bridge); 725 drm_bridge_remove(<->bridge); 726 lt8912_free_i2c(lt); 727 lt8912_put_dt(lt); 728 return 0; 729 } 730 731 static const struct of_device_id lt8912_dt_match[] = { 732 {.compatible = "lontium,lt8912b"}, 733 {} 734 }; 735 MODULE_DEVICE_TABLE(of, lt8912_dt_match); 736 737 static const struct i2c_device_id lt8912_id[] = { 738 {"lt8912", 0}, 739 {}, 740 }; 741 MODULE_DEVICE_TABLE(i2c, lt8912_id); 742 743 static struct i2c_driver lt8912_i2c_driver = { 744 .driver = { 745 .name = "lt8912", 746 .of_match_table = lt8912_dt_match, 747 }, 748 .probe = lt8912_probe, 749 .remove = lt8912_remove, 750 .id_table = lt8912_id, 751 }; 752 module_i2c_driver(lt8912_i2c_driver); 753 754 MODULE_AUTHOR("Adrien Grassein <adrien.grassein@gmail.com>"); 755 MODULE_DESCRIPTION("lt8912 drm driver"); 756 MODULE_LICENSE("GPL v2"); 757