1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) Rockchip Electronics Co.Ltd
4 * Author:
5 * Guochun Huang <hero.huang@rock-chips.com>
6 */
7
8 #include <asm/unaligned.h>
9 #include <drm/drm_bridge.h>
10 #include <drm/drm_atomic_state_helper.h>
11 #include <drm/drm_mipi_dsi.h>
12 #include <drm/drm_modeset_helper_vtables.h>
13 #include <drm/drm_of.h>
14 #include <drm/drm_print.h>
15 #include <drm/drm_probe_helper.h>
16 #include <drm/drm_panel.h>
17 #include <linux/kernel.h>
18 #include <linux/delay.h>
19 #include <linux/clk.h>
20 #include <linux/gpio/consumer.h>
21 #include <linux/regulator/consumer.h>
22 #include <linux/i2c.h>
23 #include <linux/module.h>
24 #include <linux/of.h>
25 #include <linux/of_gpio.h>
26 #include <linux/regmap.h>
27
28 struct serdes_init_seq {
29 struct reg_sequence *reg_sequence;
30 unsigned int reg_seq_cnt;
31 };
32
33 struct bu18tl82 {
34 struct drm_bridge base;
35 struct drm_bridge *bridge;
36 struct device *dev;
37 struct regmap *regmap;
38 struct mipi_dsi_device *dsi;
39 struct device_node *dsi_node;
40 struct serdes_init_seq *serdes_init_seq;
41 bool sel_mipi;
42 struct gpio_desc *reset_gpio;
43 struct gpio_desc *enable_gpio;
44 };
45
46 static const struct regmap_config bu18tl82_regmap_config = {
47 .name = "bu18tl82",
48 .reg_bits = 16,
49 .val_bits = 8,
50 .max_register = 0x0700,
51 };
52
bridge_to_bu18tl82(struct drm_bridge * bridge)53 static struct bu18tl82 *bridge_to_bu18tl82(struct drm_bridge *bridge)
54 {
55 return container_of(bridge, struct bu18tl82, base);
56 }
57
bu18tl82_parse_init_seq(struct device * dev,const u16 * data,int length,struct serdes_init_seq * seq)58 static int bu18tl82_parse_init_seq(struct device *dev, const u16 *data,
59 int length, struct serdes_init_seq *seq)
60 {
61 struct reg_sequence *reg_sequence;
62 u16 *buf, *d;
63 unsigned int i, cnt;
64
65 if (!seq)
66 return -EINVAL;
67
68 buf = devm_kmemdup(dev, data, length, GFP_KERNEL);
69 if (!buf)
70 return -ENOMEM;
71
72 d = buf;
73 cnt = length / 4;
74 seq->reg_seq_cnt = cnt;
75
76 seq->reg_sequence = devm_kcalloc(dev, cnt, sizeof(struct reg_sequence), GFP_KERNEL);
77 if (!seq->reg_sequence)
78 return -ENOMEM;
79
80
81 for (i = 0; i < cnt; i++) {
82 reg_sequence = &seq->reg_sequence[i];
83 reg_sequence->reg = get_unaligned_be16(&d[0]);
84 reg_sequence->def = get_unaligned_be16(&d[1]);
85 d += 2;
86 }
87
88 return 0;
89 }
90
bu18tl82_get_init_seq(struct bu18tl82 * bu18tl82)91 static int bu18tl82_get_init_seq(struct bu18tl82 *bu18tl82)
92 {
93 struct device *dev = bu18tl82->dev;
94 struct device_node *np = dev->of_node;
95 const void *data;
96 int len, err;
97
98 data = of_get_property(np, "serdes-init-sequence", &len);
99 if (!data) {
100 dev_err(dev, "failed to get serdes-init-sequence\n");
101 return -EINVAL;
102 }
103
104 bu18tl82->serdes_init_seq = devm_kzalloc(dev, sizeof(*bu18tl82->serdes_init_seq),
105 GFP_KERNEL);
106 if (!bu18tl82->serdes_init_seq)
107 return -ENOMEM;
108
109 err = bu18tl82_parse_init_seq(dev, data, len, bu18tl82->serdes_init_seq);
110 if (err) {
111 dev_err(dev, "failed to parse serdes-init-sequence\n");
112 return err;
113 }
114
115 return 0;
116 }
117
bu18tl82_bridge_get_modes(struct drm_bridge * bridge,struct drm_connector * connector)118 static int bu18tl82_bridge_get_modes(struct drm_bridge *bridge,
119 struct drm_connector *connector)
120 {
121 struct bu18tl82 *bu18tl82 = bridge_to_bu18tl82(bridge);
122
123 return drm_bridge_get_modes(bu18tl82->bridge, connector);
124 }
125
bu18tl82_attach_dsi(struct bu18tl82 * bu18tl82,struct device_node * dsi_node)126 static struct mipi_dsi_device *bu18tl82_attach_dsi(struct bu18tl82 *bu18tl82,
127 struct device_node *dsi_node)
128 {
129 const struct mipi_dsi_device_info info = { "bu18tl82", 0, NULL };
130 struct mipi_dsi_device *dsi;
131 struct mipi_dsi_host *host;
132 int ret;
133
134 host = of_find_mipi_dsi_host_by_node(dsi_node);
135 if (!host) {
136 dev_err(bu18tl82->dev, "failed to find dsi host\n");
137 return ERR_PTR(-EPROBE_DEFER);
138 }
139
140 dsi = mipi_dsi_device_register_full(host, &info);
141 if (IS_ERR(dsi)) {
142 dev_err(bu18tl82->dev, "failed to create dsi device\n");
143 return dsi;
144 }
145
146 dsi->lanes = 4;
147 dsi->format = MIPI_DSI_FMT_RGB888;
148 dsi->mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_BURST |
149 MIPI_DSI_MODE_LPM | MIPI_DSI_MODE_EOT_PACKET;
150
151 ret = mipi_dsi_attach(dsi);
152 if (ret < 0) {
153 dev_err(bu18tl82->dev, "failed to attach dsi to host\n");
154 mipi_dsi_device_unregister(dsi);
155 return ERR_PTR(ret);
156 }
157
158 return dsi;
159 }
160
bu18tl82_bridge_attach(struct drm_bridge * bridge,enum drm_bridge_attach_flags flags)161 static int bu18tl82_bridge_attach(struct drm_bridge *bridge,
162 enum drm_bridge_attach_flags flags)
163 {
164 struct bu18tl82 *bu18tl82 = bridge_to_bu18tl82(bridge);
165 int ret;
166
167 ret = drm_of_find_panel_or_bridge(bu18tl82->dev->of_node, 1, -1,
168 NULL, &bu18tl82->bridge);
169 if (ret)
170 return ret;
171
172 if (bu18tl82->sel_mipi) {
173 /* Attach primary DSI */
174 bu18tl82->dsi = bu18tl82_attach_dsi(bu18tl82, bu18tl82->dsi_node);
175 if (IS_ERR(bu18tl82->dsi))
176 return PTR_ERR(bu18tl82->dsi);
177 }
178
179 ret = drm_bridge_attach(bridge->encoder, bu18tl82->bridge,
180 bridge, flags);
181 if (ret) {
182 if (bu18tl82->sel_mipi)
183 mipi_dsi_device_unregister(bu18tl82->dsi);
184
185 dev_err(bu18tl82->dev, "failed to attach bridge\n");
186 return ret;
187 }
188
189 return 0;
190 }
191
bu18tl82_bridge_detach(struct drm_bridge * bridge)192 static void bu18tl82_bridge_detach(struct drm_bridge *bridge)
193 {
194 struct bu18tl82 *bu18tl82 = bridge_to_bu18tl82(bridge);
195
196 if (bu18tl82->sel_mipi) {
197 mipi_dsi_detach(bu18tl82->dsi);
198 mipi_dsi_device_unregister(bu18tl82->dsi);
199 }
200 }
201
bu18tl82_bridge_enable(struct drm_bridge * bridge)202 static void bu18tl82_bridge_enable(struct drm_bridge *bridge)
203 {
204 }
205
bu18tl82_bridge_disable(struct drm_bridge * bridge)206 static void bu18tl82_bridge_disable(struct drm_bridge *bridge)
207 {
208 }
209
bu18tl82_bridge_pre_enable(struct drm_bridge * bridge)210 static void bu18tl82_bridge_pre_enable(struct drm_bridge *bridge)
211 {
212 struct bu18tl82 *bu18tl82 = bridge_to_bu18tl82(bridge);
213 struct serdes_init_seq *init_seq = bu18tl82->serdes_init_seq;
214 int ret;
215
216 if (bu18tl82->enable_gpio) {
217 gpiod_direction_output(bu18tl82->enable_gpio, 1);
218 msleep(20);
219 }
220
221 if (bu18tl82->reset_gpio) {
222 gpiod_direction_output(bu18tl82->reset_gpio, 0);
223 msleep(30);
224 }
225
226 ret = regmap_multi_reg_write(bu18tl82->regmap, init_seq->reg_sequence,
227 init_seq->reg_seq_cnt);
228 if (ret) {
229 dev_err(bu18tl82->dev, "failed to set register setting: %d\n", ret);
230 return;
231 }
232 msleep(160);
233 }
234
bu18tl82_bridge_post_disable(struct drm_bridge * bridge)235 static void bu18tl82_bridge_post_disable(struct drm_bridge *bridge)
236 {
237 struct bu18tl82 *bu18tl82 = bridge_to_bu18tl82(bridge);
238
239 if (bu18tl82->reset_gpio)
240 gpiod_direction_output(bu18tl82->reset_gpio, 1);
241
242 if (bu18tl82->enable_gpio)
243 gpiod_direction_output(bu18tl82->enable_gpio, 0);
244 }
245
246 static const struct drm_bridge_funcs bu18tl82_bridge_funcs = {
247 .attach = bu18tl82_bridge_attach,
248 .detach = bu18tl82_bridge_detach,
249 .enable = bu18tl82_bridge_enable,
250 .disable = bu18tl82_bridge_disable,
251 .pre_enable = bu18tl82_bridge_pre_enable,
252 .post_disable = bu18tl82_bridge_post_disable,
253 .get_modes = bu18tl82_bridge_get_modes,
254 };
255
bu18tl82_i2c_probe(struct i2c_client * client,const struct i2c_device_id * id)256 static int bu18tl82_i2c_probe(struct i2c_client *client,
257 const struct i2c_device_id *id)
258 {
259 struct device *dev = &client->dev;
260 struct bu18tl82 *bu18tl82;
261 int ret;
262
263 bu18tl82 = devm_kzalloc(dev, sizeof(*bu18tl82), GFP_KERNEL);
264 if (!bu18tl82)
265 return -ENOMEM;
266
267 bu18tl82->dev = dev;
268 i2c_set_clientdata(client, bu18tl82);
269
270 bu18tl82->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_ASIS);
271 if (IS_ERR(bu18tl82->reset_gpio))
272 return dev_err_probe(dev, PTR_ERR(bu18tl82->reset_gpio),
273 "failed to acquire reset gpio\n");
274
275 bu18tl82->enable_gpio = devm_gpiod_get_optional(dev, "enable", GPIOD_ASIS);
276 if (IS_ERR(bu18tl82->enable_gpio))
277 return dev_err_probe(dev, PTR_ERR(bu18tl82->enable_gpio),
278 "failed to acquire enable gpio\n");
279
280 bu18tl82->regmap = devm_regmap_init_i2c(client, &bu18tl82_regmap_config);
281 if (IS_ERR(bu18tl82->regmap))
282 return dev_err_probe(dev, PTR_ERR(bu18tl82->regmap),
283 "failed to initialize regmap\n");
284
285 bu18tl82->sel_mipi = of_property_read_bool(dev->of_node, "sel-mipi");
286
287 if (bu18tl82->sel_mipi) {
288 bu18tl82->dsi_node = of_graph_get_remote_node(dev->of_node, 0, -1);
289 if (!bu18tl82->dsi_node)
290 return dev_err_probe(dev, -ENODEV,
291 "failed to get remote node for dsi\n");
292 }
293
294 ret = bu18tl82_get_init_seq(bu18tl82);
295 if (ret)
296 return ret;
297
298 bu18tl82->base.funcs = &bu18tl82_bridge_funcs;
299 bu18tl82->base.of_node = dev->of_node;
300 bu18tl82->base.ops = DRM_BRIDGE_OP_MODES;
301
302 drm_bridge_add(&bu18tl82->base);
303
304 return 0;
305 }
306
bu18tl82_i2c_remove(struct i2c_client * client)307 static int bu18tl82_i2c_remove(struct i2c_client *client)
308 {
309 struct bu18tl82 *bu18tl82 = i2c_get_clientdata(client);
310
311 drm_bridge_remove(&bu18tl82->base);
312
313 return 0;
314 }
315
316 static const struct i2c_device_id bu18tl82_i2c_table[] = {
317 { "bu18tl82", 0 },
318 {}
319 };
320 MODULE_DEVICE_TABLE(i2c, bu18tl82_i2c_table);
321
322 static const struct of_device_id bu18tl82_of_match[] = {
323 { .compatible = "rohm,bu18tl82" },
324 {}
325 };
326 MODULE_DEVICE_TABLE(of, bu18tl82_of_match);
327
328 static struct i2c_driver bu18tl82_i2c_driver = {
329 .driver = {
330 .name = "bu18tl82",
331 .of_match_table = bu18tl82_of_match,
332 },
333 .probe = bu18tl82_i2c_probe,
334 .remove = bu18tl82_i2c_remove,
335 .id_table = bu18tl82_i2c_table,
336 };
337 module_i2c_driver(bu18tl82_i2c_driver);
338
339 MODULE_AUTHOR("Guochun Huang <hero.huang@rock-chips.com>");
340 MODULE_DESCRIPTION("Rohm BU18TL82 Clockless Link-BD Serializer with MIPI and LVDS Interface");
341 MODULE_LICENSE("GPL");
342