1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Driver for MegaChips STDP4028 with GE B850v3 firmware (LVDS-DP)
4 * Driver for MegaChips STDP2690 with GE B850v3 firmware (DP-DP++)
5
6 * Copyright (c) 2017, Collabora Ltd.
7 * Copyright (c) 2017, General Electric Company
8
9
10 * This driver creates a drm_bridge and a drm_connector for the LVDS to DP++
11 * display bridge of the GE B850v3. There are two physical bridges on the video
12 * signal pipeline: a STDP4028(LVDS to DP) and a STDP2690(DP to DP++). The
13 * physical bridges are automatically configured by the input video signal, and
14 * the driver has no access to the video processing pipeline. The driver is
15 * only needed to read EDID from the STDP2690 and to handle HPD events from the
16 * STDP4028. The driver communicates with both bridges over i2c. The video
17 * signal pipeline is as follows:
18 *
19 * Host -> LVDS|--(STDP4028)--|DP -> DP|--(STDP2690)--|DP++ -> Video output
20 */
21
22 #include <linux/i2c.h>
23 #include <linux/module.h>
24 #include <linux/of.h>
25
26 #include <drm/drm_atomic.h>
27 #include <drm/drm_atomic_helper.h>
28 #include <drm/drm_bridge.h>
29 #include <drm/drm_edid.h>
30 #include <drm/drm_print.h>
31 #include <drm/drm_probe_helper.h>
32
33 #define EDID_EXT_BLOCK_CNT 0x7E
34
35 #define STDP4028_IRQ_OUT_CONF_REG 0x02
36 #define STDP4028_DPTX_IRQ_EN_REG 0x3C
37 #define STDP4028_DPTX_IRQ_STS_REG 0x3D
38 #define STDP4028_DPTX_STS_REG 0x3E
39
40 #define STDP4028_DPTX_DP_IRQ_EN 0x1000
41
42 #define STDP4028_DPTX_HOTPLUG_IRQ_EN 0x0400
43 #define STDP4028_DPTX_LINK_CH_IRQ_EN 0x2000
44 #define STDP4028_DPTX_IRQ_CONFIG \
45 (STDP4028_DPTX_LINK_CH_IRQ_EN | STDP4028_DPTX_HOTPLUG_IRQ_EN)
46
47 #define STDP4028_DPTX_HOTPLUG_STS 0x0200
48 #define STDP4028_DPTX_LINK_STS 0x1000
49 #define STDP4028_CON_STATE_CONNECTED \
50 (STDP4028_DPTX_HOTPLUG_STS | STDP4028_DPTX_LINK_STS)
51
52 #define STDP4028_DPTX_HOTPLUG_CH_STS 0x0400
53 #define STDP4028_DPTX_LINK_CH_STS 0x2000
54 #define STDP4028_DPTX_IRQ_CLEAR \
55 (STDP4028_DPTX_LINK_CH_STS | STDP4028_DPTX_HOTPLUG_CH_STS)
56
57 static DEFINE_MUTEX(ge_b850v3_lvds_dev_mutex);
58
59 struct ge_b850v3_lvds {
60 struct drm_connector connector;
61 struct drm_bridge bridge;
62 struct i2c_client *stdp4028_i2c;
63 struct i2c_client *stdp2690_i2c;
64 };
65
66 static struct ge_b850v3_lvds *ge_b850v3_lvds_ptr;
67
stdp2690_get_edid(struct i2c_client * client)68 static u8 *stdp2690_get_edid(struct i2c_client *client)
69 {
70 struct i2c_adapter *adapter = client->adapter;
71 unsigned char start = 0x00;
72 unsigned int total_size;
73 u8 *block = kmalloc(EDID_LENGTH, GFP_KERNEL);
74
75 struct i2c_msg msgs[] = {
76 {
77 .addr = client->addr,
78 .flags = 0,
79 .len = 1,
80 .buf = &start,
81 }, {
82 .addr = client->addr,
83 .flags = I2C_M_RD,
84 .len = EDID_LENGTH,
85 .buf = block,
86 }
87 };
88
89 if (!block)
90 return NULL;
91
92 if (i2c_transfer(adapter, msgs, 2) != 2) {
93 DRM_ERROR("Unable to read EDID.\n");
94 goto err;
95 }
96
97 if (!drm_edid_block_valid(block, 0, false, NULL)) {
98 DRM_ERROR("Invalid EDID data\n");
99 goto err;
100 }
101
102 total_size = (block[EDID_EXT_BLOCK_CNT] + 1) * EDID_LENGTH;
103 if (total_size > EDID_LENGTH) {
104 kfree(block);
105 block = kmalloc(total_size, GFP_KERNEL);
106 if (!block)
107 return NULL;
108
109 /* Yes, read the entire buffer, and do not skip the first
110 * EDID_LENGTH bytes.
111 */
112 start = 0x00;
113 msgs[1].len = total_size;
114 msgs[1].buf = block;
115
116 if (i2c_transfer(adapter, msgs, 2) != 2) {
117 DRM_ERROR("Unable to read EDID extension blocks.\n");
118 goto err;
119 }
120 if (!drm_edid_block_valid(block, 1, false, NULL)) {
121 DRM_ERROR("Invalid EDID data\n");
122 goto err;
123 }
124 }
125
126 return block;
127
128 err:
129 kfree(block);
130 return NULL;
131 }
132
ge_b850v3_lvds_get_edid(struct drm_bridge * bridge,struct drm_connector * connector)133 static struct edid *ge_b850v3_lvds_get_edid(struct drm_bridge *bridge,
134 struct drm_connector *connector)
135 {
136 struct i2c_client *client;
137
138 client = ge_b850v3_lvds_ptr->stdp2690_i2c;
139
140 return (struct edid *)stdp2690_get_edid(client);
141 }
142
ge_b850v3_lvds_get_modes(struct drm_connector * connector)143 static int ge_b850v3_lvds_get_modes(struct drm_connector *connector)
144 {
145 struct edid *edid;
146 int num_modes;
147
148 edid = ge_b850v3_lvds_get_edid(&ge_b850v3_lvds_ptr->bridge, connector);
149
150 drm_connector_update_edid_property(connector, edid);
151 num_modes = drm_add_edid_modes(connector, edid);
152 kfree(edid);
153
154 return num_modes;
155 }
156
ge_b850v3_lvds_mode_valid(struct drm_connector * connector,struct drm_display_mode * mode)157 static enum drm_mode_status ge_b850v3_lvds_mode_valid(
158 struct drm_connector *connector, struct drm_display_mode *mode)
159 {
160 return MODE_OK;
161 }
162
163 static const struct
164 drm_connector_helper_funcs ge_b850v3_lvds_connector_helper_funcs = {
165 .get_modes = ge_b850v3_lvds_get_modes,
166 .mode_valid = ge_b850v3_lvds_mode_valid,
167 };
168
ge_b850v3_lvds_bridge_detect(struct drm_bridge * bridge)169 static enum drm_connector_status ge_b850v3_lvds_bridge_detect(struct drm_bridge *bridge)
170 {
171 struct i2c_client *stdp4028_i2c =
172 ge_b850v3_lvds_ptr->stdp4028_i2c;
173 s32 link_state;
174
175 link_state = i2c_smbus_read_word_data(stdp4028_i2c,
176 STDP4028_DPTX_STS_REG);
177
178 if (link_state == STDP4028_CON_STATE_CONNECTED)
179 return connector_status_connected;
180
181 if (link_state == 0)
182 return connector_status_disconnected;
183
184 return connector_status_unknown;
185 }
186
ge_b850v3_lvds_detect(struct drm_connector * connector,bool force)187 static enum drm_connector_status ge_b850v3_lvds_detect(struct drm_connector *connector,
188 bool force)
189 {
190 return ge_b850v3_lvds_bridge_detect(&ge_b850v3_lvds_ptr->bridge);
191 }
192
193 static const struct drm_connector_funcs ge_b850v3_lvds_connector_funcs = {
194 .fill_modes = drm_helper_probe_single_connector_modes,
195 .detect = ge_b850v3_lvds_detect,
196 .destroy = drm_connector_cleanup,
197 .reset = drm_atomic_helper_connector_reset,
198 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
199 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
200 };
201
ge_b850v3_lvds_create_connector(struct drm_bridge * bridge)202 static int ge_b850v3_lvds_create_connector(struct drm_bridge *bridge)
203 {
204 struct drm_connector *connector = &ge_b850v3_lvds_ptr->connector;
205 int ret;
206
207 if (!bridge->encoder) {
208 DRM_ERROR("Parent encoder object not found");
209 return -ENODEV;
210 }
211
212 connector->polled = DRM_CONNECTOR_POLL_HPD;
213
214 drm_connector_helper_add(connector,
215 &ge_b850v3_lvds_connector_helper_funcs);
216
217 ret = drm_connector_init(bridge->dev, connector,
218 &ge_b850v3_lvds_connector_funcs,
219 DRM_MODE_CONNECTOR_DisplayPort);
220 if (ret) {
221 DRM_ERROR("Failed to initialize connector with drm\n");
222 return ret;
223 }
224
225 return drm_connector_attach_encoder(connector, bridge->encoder);
226 }
227
ge_b850v3_lvds_irq_handler(int irq,void * dev_id)228 static irqreturn_t ge_b850v3_lvds_irq_handler(int irq, void *dev_id)
229 {
230 struct i2c_client *stdp4028_i2c
231 = ge_b850v3_lvds_ptr->stdp4028_i2c;
232
233 i2c_smbus_write_word_data(stdp4028_i2c,
234 STDP4028_DPTX_IRQ_STS_REG,
235 STDP4028_DPTX_IRQ_CLEAR);
236
237 if (ge_b850v3_lvds_ptr->bridge.dev)
238 drm_kms_helper_hotplug_event(ge_b850v3_lvds_ptr->bridge.dev);
239
240 return IRQ_HANDLED;
241 }
242
ge_b850v3_lvds_attach(struct drm_bridge * bridge,enum drm_bridge_attach_flags flags)243 static int ge_b850v3_lvds_attach(struct drm_bridge *bridge,
244 enum drm_bridge_attach_flags flags)
245 {
246 struct i2c_client *stdp4028_i2c
247 = ge_b850v3_lvds_ptr->stdp4028_i2c;
248
249 /* Configures the bridge to re-enable interrupts after each ack. */
250 i2c_smbus_write_word_data(stdp4028_i2c,
251 STDP4028_IRQ_OUT_CONF_REG,
252 STDP4028_DPTX_DP_IRQ_EN);
253
254 /* Enable interrupts */
255 i2c_smbus_write_word_data(stdp4028_i2c,
256 STDP4028_DPTX_IRQ_EN_REG,
257 STDP4028_DPTX_IRQ_CONFIG);
258
259 if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
260 return 0;
261
262 return ge_b850v3_lvds_create_connector(bridge);
263 }
264
265 static const struct drm_bridge_funcs ge_b850v3_lvds_funcs = {
266 .attach = ge_b850v3_lvds_attach,
267 .detect = ge_b850v3_lvds_bridge_detect,
268 .get_edid = ge_b850v3_lvds_get_edid,
269 };
270
ge_b850v3_lvds_init(struct device * dev)271 static int ge_b850v3_lvds_init(struct device *dev)
272 {
273 mutex_lock(&ge_b850v3_lvds_dev_mutex);
274
275 if (ge_b850v3_lvds_ptr)
276 goto success;
277
278 ge_b850v3_lvds_ptr = devm_kzalloc(dev,
279 sizeof(*ge_b850v3_lvds_ptr),
280 GFP_KERNEL);
281
282 if (!ge_b850v3_lvds_ptr) {
283 mutex_unlock(&ge_b850v3_lvds_dev_mutex);
284 return -ENOMEM;
285 }
286
287 success:
288 mutex_unlock(&ge_b850v3_lvds_dev_mutex);
289 return 0;
290 }
291
ge_b850v3_lvds_remove(void)292 static void ge_b850v3_lvds_remove(void)
293 {
294 mutex_lock(&ge_b850v3_lvds_dev_mutex);
295 /*
296 * This check is to avoid both the drivers
297 * removing the bridge in their remove() function
298 */
299 if (!ge_b850v3_lvds_ptr ||
300 !ge_b850v3_lvds_ptr->stdp2690_i2c ||
301 !ge_b850v3_lvds_ptr->stdp4028_i2c)
302 goto out;
303
304 drm_bridge_remove(&ge_b850v3_lvds_ptr->bridge);
305
306 ge_b850v3_lvds_ptr = NULL;
307 out:
308 mutex_unlock(&ge_b850v3_lvds_dev_mutex);
309 }
310
ge_b850v3_register(void)311 static int ge_b850v3_register(void)
312 {
313 struct i2c_client *stdp4028_i2c = ge_b850v3_lvds_ptr->stdp4028_i2c;
314 struct device *dev = &stdp4028_i2c->dev;
315
316 /* drm bridge initialization */
317 ge_b850v3_lvds_ptr->bridge.funcs = &ge_b850v3_lvds_funcs;
318 ge_b850v3_lvds_ptr->bridge.ops = DRM_BRIDGE_OP_DETECT |
319 DRM_BRIDGE_OP_EDID;
320 ge_b850v3_lvds_ptr->bridge.type = DRM_MODE_CONNECTOR_DisplayPort;
321 ge_b850v3_lvds_ptr->bridge.of_node = dev->of_node;
322 drm_bridge_add(&ge_b850v3_lvds_ptr->bridge);
323
324 /* Clear pending interrupts since power up. */
325 i2c_smbus_write_word_data(stdp4028_i2c,
326 STDP4028_DPTX_IRQ_STS_REG,
327 STDP4028_DPTX_IRQ_CLEAR);
328
329 if (!stdp4028_i2c->irq)
330 return 0;
331
332 return devm_request_threaded_irq(&stdp4028_i2c->dev,
333 stdp4028_i2c->irq, NULL,
334 ge_b850v3_lvds_irq_handler,
335 IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
336 "ge-b850v3-lvds-dp", ge_b850v3_lvds_ptr);
337 }
338
stdp4028_ge_b850v3_fw_probe(struct i2c_client * stdp4028_i2c)339 static int stdp4028_ge_b850v3_fw_probe(struct i2c_client *stdp4028_i2c)
340 {
341 struct device *dev = &stdp4028_i2c->dev;
342 int ret;
343
344 ret = ge_b850v3_lvds_init(dev);
345
346 if (ret)
347 return ret;
348
349 ge_b850v3_lvds_ptr->stdp4028_i2c = stdp4028_i2c;
350 i2c_set_clientdata(stdp4028_i2c, ge_b850v3_lvds_ptr);
351
352 /* Only register after both bridges are probed */
353 if (!ge_b850v3_lvds_ptr->stdp2690_i2c)
354 return 0;
355
356 return ge_b850v3_register();
357 }
358
stdp4028_ge_b850v3_fw_remove(struct i2c_client * stdp4028_i2c)359 static void stdp4028_ge_b850v3_fw_remove(struct i2c_client *stdp4028_i2c)
360 {
361 ge_b850v3_lvds_remove();
362 }
363
364 static const struct i2c_device_id stdp4028_ge_b850v3_fw_i2c_table[] = {
365 {"stdp4028_ge_fw", 0},
366 {},
367 };
368 MODULE_DEVICE_TABLE(i2c, stdp4028_ge_b850v3_fw_i2c_table);
369
370 static const struct of_device_id stdp4028_ge_b850v3_fw_match[] = {
371 { .compatible = "megachips,stdp4028-ge-b850v3-fw" },
372 {},
373 };
374 MODULE_DEVICE_TABLE(of, stdp4028_ge_b850v3_fw_match);
375
376 static struct i2c_driver stdp4028_ge_b850v3_fw_driver = {
377 .id_table = stdp4028_ge_b850v3_fw_i2c_table,
378 .probe = stdp4028_ge_b850v3_fw_probe,
379 .remove = stdp4028_ge_b850v3_fw_remove,
380 .driver = {
381 .name = "stdp4028-ge-b850v3-fw",
382 .of_match_table = stdp4028_ge_b850v3_fw_match,
383 },
384 };
385
stdp2690_ge_b850v3_fw_probe(struct i2c_client * stdp2690_i2c)386 static int stdp2690_ge_b850v3_fw_probe(struct i2c_client *stdp2690_i2c)
387 {
388 struct device *dev = &stdp2690_i2c->dev;
389 int ret;
390
391 ret = ge_b850v3_lvds_init(dev);
392
393 if (ret)
394 return ret;
395
396 ge_b850v3_lvds_ptr->stdp2690_i2c = stdp2690_i2c;
397 i2c_set_clientdata(stdp2690_i2c, ge_b850v3_lvds_ptr);
398
399 /* Only register after both bridges are probed */
400 if (!ge_b850v3_lvds_ptr->stdp4028_i2c)
401 return 0;
402
403 return ge_b850v3_register();
404 }
405
stdp2690_ge_b850v3_fw_remove(struct i2c_client * stdp2690_i2c)406 static void stdp2690_ge_b850v3_fw_remove(struct i2c_client *stdp2690_i2c)
407 {
408 ge_b850v3_lvds_remove();
409 }
410
411 static const struct i2c_device_id stdp2690_ge_b850v3_fw_i2c_table[] = {
412 {"stdp2690_ge_fw", 0},
413 {},
414 };
415 MODULE_DEVICE_TABLE(i2c, stdp2690_ge_b850v3_fw_i2c_table);
416
417 static const struct of_device_id stdp2690_ge_b850v3_fw_match[] = {
418 { .compatible = "megachips,stdp2690-ge-b850v3-fw" },
419 {},
420 };
421 MODULE_DEVICE_TABLE(of, stdp2690_ge_b850v3_fw_match);
422
423 static struct i2c_driver stdp2690_ge_b850v3_fw_driver = {
424 .id_table = stdp2690_ge_b850v3_fw_i2c_table,
425 .probe = stdp2690_ge_b850v3_fw_probe,
426 .remove = stdp2690_ge_b850v3_fw_remove,
427 .driver = {
428 .name = "stdp2690-ge-b850v3-fw",
429 .of_match_table = stdp2690_ge_b850v3_fw_match,
430 },
431 };
432
stdpxxxx_ge_b850v3_init(void)433 static int __init stdpxxxx_ge_b850v3_init(void)
434 {
435 int ret;
436
437 ret = i2c_add_driver(&stdp4028_ge_b850v3_fw_driver);
438 if (ret)
439 return ret;
440
441 ret = i2c_add_driver(&stdp2690_ge_b850v3_fw_driver);
442 if (ret)
443 i2c_del_driver(&stdp4028_ge_b850v3_fw_driver);
444
445 return ret;
446 }
447 module_init(stdpxxxx_ge_b850v3_init);
448
stdpxxxx_ge_b850v3_exit(void)449 static void __exit stdpxxxx_ge_b850v3_exit(void)
450 {
451 i2c_del_driver(&stdp2690_ge_b850v3_fw_driver);
452 i2c_del_driver(&stdp4028_ge_b850v3_fw_driver);
453 }
454 module_exit(stdpxxxx_ge_b850v3_exit);
455
456 MODULE_AUTHOR("Peter Senna Tschudin <peter.senna@collabora.com>");
457 MODULE_AUTHOR("Martyn Welch <martyn.welch@collabora.co.uk>");
458 MODULE_DESCRIPTION("GE LVDS to DP++ display bridge)");
459 MODULE_LICENSE("GPL v2");
460