1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
57static DEFINE_MUTEX(ge_b850v3_lvds_dev_mutex);
58
59struct 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
66static struct ge_b850v3_lvds *ge_b850v3_lvds_ptr;
67
68static 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
110
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
128err:
129 kfree(block);
130 return NULL;
131}
132
133static 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
143static 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
157static 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
163static const struct
164drm_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
169static 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
187static 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
193static 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
202static 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
228static 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
243static 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
250 i2c_smbus_write_word_data(stdp4028_i2c,
251 STDP4028_IRQ_OUT_CONF_REG,
252 STDP4028_DPTX_DP_IRQ_EN);
253
254
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
265static 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
271static 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
287success:
288 mutex_unlock(&ge_b850v3_lvds_dev_mutex);
289 return 0;
290}
291
292static void ge_b850v3_lvds_remove(void)
293{
294 mutex_lock(&ge_b850v3_lvds_dev_mutex);
295
296
297
298
299 if (!ge_b850v3_lvds_ptr)
300 goto out;
301
302 drm_bridge_remove(&ge_b850v3_lvds_ptr->bridge);
303
304 ge_b850v3_lvds_ptr = NULL;
305out:
306 mutex_unlock(&ge_b850v3_lvds_dev_mutex);
307}
308
309static int stdp4028_ge_b850v3_fw_probe(struct i2c_client *stdp4028_i2c,
310 const struct i2c_device_id *id)
311{
312 struct device *dev = &stdp4028_i2c->dev;
313 int ret;
314
315 ret = ge_b850v3_lvds_init(dev);
316
317 if (ret)
318 return ret;
319
320 ge_b850v3_lvds_ptr->stdp4028_i2c = stdp4028_i2c;
321 i2c_set_clientdata(stdp4028_i2c, ge_b850v3_lvds_ptr);
322
323
324 ge_b850v3_lvds_ptr->bridge.funcs = &ge_b850v3_lvds_funcs;
325 ge_b850v3_lvds_ptr->bridge.ops = DRM_BRIDGE_OP_DETECT |
326 DRM_BRIDGE_OP_EDID;
327 ge_b850v3_lvds_ptr->bridge.type = DRM_MODE_CONNECTOR_DisplayPort;
328 ge_b850v3_lvds_ptr->bridge.of_node = dev->of_node;
329 drm_bridge_add(&ge_b850v3_lvds_ptr->bridge);
330
331
332 i2c_smbus_write_word_data(stdp4028_i2c,
333 STDP4028_DPTX_IRQ_STS_REG,
334 STDP4028_DPTX_IRQ_CLEAR);
335
336 if (!stdp4028_i2c->irq)
337 return 0;
338
339 return devm_request_threaded_irq(&stdp4028_i2c->dev,
340 stdp4028_i2c->irq, NULL,
341 ge_b850v3_lvds_irq_handler,
342 IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
343 "ge-b850v3-lvds-dp", ge_b850v3_lvds_ptr);
344}
345
346static int stdp4028_ge_b850v3_fw_remove(struct i2c_client *stdp4028_i2c)
347{
348 ge_b850v3_lvds_remove();
349
350 return 0;
351}
352
353static const struct i2c_device_id stdp4028_ge_b850v3_fw_i2c_table[] = {
354 {"stdp4028_ge_fw", 0},
355 {},
356};
357MODULE_DEVICE_TABLE(i2c, stdp4028_ge_b850v3_fw_i2c_table);
358
359static const struct of_device_id stdp4028_ge_b850v3_fw_match[] = {
360 { .compatible = "megachips,stdp4028-ge-b850v3-fw" },
361 {},
362};
363MODULE_DEVICE_TABLE(of, stdp4028_ge_b850v3_fw_match);
364
365static struct i2c_driver stdp4028_ge_b850v3_fw_driver = {
366 .id_table = stdp4028_ge_b850v3_fw_i2c_table,
367 .probe = stdp4028_ge_b850v3_fw_probe,
368 .remove = stdp4028_ge_b850v3_fw_remove,
369 .driver = {
370 .name = "stdp4028-ge-b850v3-fw",
371 .of_match_table = stdp4028_ge_b850v3_fw_match,
372 },
373};
374
375static int stdp2690_ge_b850v3_fw_probe(struct i2c_client *stdp2690_i2c,
376 const struct i2c_device_id *id)
377{
378 struct device *dev = &stdp2690_i2c->dev;
379 int ret;
380
381 ret = ge_b850v3_lvds_init(dev);
382
383 if (ret)
384 return ret;
385
386 ge_b850v3_lvds_ptr->stdp2690_i2c = stdp2690_i2c;
387 i2c_set_clientdata(stdp2690_i2c, ge_b850v3_lvds_ptr);
388
389 return 0;
390}
391
392static int stdp2690_ge_b850v3_fw_remove(struct i2c_client *stdp2690_i2c)
393{
394 ge_b850v3_lvds_remove();
395
396 return 0;
397}
398
399static const struct i2c_device_id stdp2690_ge_b850v3_fw_i2c_table[] = {
400 {"stdp2690_ge_fw", 0},
401 {},
402};
403MODULE_DEVICE_TABLE(i2c, stdp2690_ge_b850v3_fw_i2c_table);
404
405static const struct of_device_id stdp2690_ge_b850v3_fw_match[] = {
406 { .compatible = "megachips,stdp2690-ge-b850v3-fw" },
407 {},
408};
409MODULE_DEVICE_TABLE(of, stdp2690_ge_b850v3_fw_match);
410
411static struct i2c_driver stdp2690_ge_b850v3_fw_driver = {
412 .id_table = stdp2690_ge_b850v3_fw_i2c_table,
413 .probe = stdp2690_ge_b850v3_fw_probe,
414 .remove = stdp2690_ge_b850v3_fw_remove,
415 .driver = {
416 .name = "stdp2690-ge-b850v3-fw",
417 .of_match_table = stdp2690_ge_b850v3_fw_match,
418 },
419};
420
421static int __init stdpxxxx_ge_b850v3_init(void)
422{
423 int ret;
424
425 ret = i2c_add_driver(&stdp4028_ge_b850v3_fw_driver);
426 if (ret)
427 return ret;
428
429 return i2c_add_driver(&stdp2690_ge_b850v3_fw_driver);
430}
431module_init(stdpxxxx_ge_b850v3_init);
432
433static void __exit stdpxxxx_ge_b850v3_exit(void)
434{
435 i2c_del_driver(&stdp2690_ge_b850v3_fw_driver);
436 i2c_del_driver(&stdp4028_ge_b850v3_fw_driver);
437}
438module_exit(stdpxxxx_ge_b850v3_exit);
439
440MODULE_AUTHOR("Peter Senna Tschudin <peter.senna@collabora.com>");
441MODULE_AUTHOR("Martyn Welch <martyn.welch@collabora.co.uk>");
442MODULE_DESCRIPTION("GE LVDS to DP++ display bridge)");
443MODULE_LICENSE("GPL v2");
444
