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

source code of linux/drivers/gpu/drm/bridge/lontium-lt8912b.c