1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/errno.h>
24#include <linux/export.h>
25#include <linux/i2c.h>
26#include <linux/slab.h>
27#include <linux/string.h>
28#include <drm/drm_dp_dual_mode_helper.h>
29#include <drm/drmP.h>
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45#define DP_DUAL_MODE_SLAVE_ADDRESS 0x40
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60ssize_t drm_dp_dual_mode_read(struct i2c_adapter *adapter,
61 u8 offset, void *buffer, size_t size)
62{
63 struct i2c_msg msgs[] = {
64 {
65 .addr = DP_DUAL_MODE_SLAVE_ADDRESS,
66 .flags = 0,
67 .len = 1,
68 .buf = &offset,
69 },
70 {
71 .addr = DP_DUAL_MODE_SLAVE_ADDRESS,
72 .flags = I2C_M_RD,
73 .len = size,
74 .buf = buffer,
75 },
76 };
77 int ret;
78
79 ret = i2c_transfer(adapter, msgs, ARRAY_SIZE(msgs));
80 if (ret < 0)
81 return ret;
82 if (ret != ARRAY_SIZE(msgs))
83 return -EPROTO;
84
85 return 0;
86}
87EXPORT_SYMBOL(drm_dp_dual_mode_read);
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102ssize_t drm_dp_dual_mode_write(struct i2c_adapter *adapter,
103 u8 offset, const void *buffer, size_t size)
104{
105 struct i2c_msg msg = {
106 .addr = DP_DUAL_MODE_SLAVE_ADDRESS,
107 .flags = 0,
108 .len = 1 + size,
109 .buf = NULL,
110 };
111 void *data;
112 int ret;
113
114 data = kmalloc(msg.len, GFP_KERNEL);
115 if (!data)
116 return -ENOMEM;
117
118 msg.buf = data;
119
120 memcpy(data, &offset, 1);
121 memcpy(data + 1, buffer, size);
122
123 ret = i2c_transfer(adapter, &msg, 1);
124
125 kfree(data);
126
127 if (ret < 0)
128 return ret;
129 if (ret != 1)
130 return -EPROTO;
131
132 return 0;
133}
134EXPORT_SYMBOL(drm_dp_dual_mode_write);
135
136static bool is_hdmi_adaptor(const char hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN])
137{
138 static const char dp_dual_mode_hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN] =
139 "DP-HDMI ADAPTOR\x04";
140
141 return memcmp(hdmi_id, dp_dual_mode_hdmi_id,
142 sizeof(dp_dual_mode_hdmi_id)) == 0;
143}
144
145static bool is_type1_adaptor(uint8_t adaptor_id)
146{
147 return adaptor_id == 0 || adaptor_id == 0xff;
148}
149
150static bool is_type2_adaptor(uint8_t adaptor_id)
151{
152 return adaptor_id == (DP_DUAL_MODE_TYPE_TYPE2 |
153 DP_DUAL_MODE_REV_TYPE2);
154}
155
156static bool is_lspcon_adaptor(const char hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN],
157 const uint8_t adaptor_id)
158{
159 return is_hdmi_adaptor(hdmi_id) &&
160 (adaptor_id == (DP_DUAL_MODE_TYPE_TYPE2 |
161 DP_DUAL_MODE_TYPE_HAS_DPCD));
162}
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179enum drm_dp_dual_mode_type drm_dp_dual_mode_detect(struct i2c_adapter *adapter)
180{
181 char hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN] = {};
182 uint8_t adaptor_id = 0x00;
183 ssize_t ret;
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199 ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_HDMI_ID,
200 hdmi_id, sizeof(hdmi_id));
201 DRM_DEBUG_KMS("DP dual mode HDMI ID: %*pE (err %zd)\n",
202 ret ? 0 : (int)sizeof(hdmi_id), hdmi_id, ret);
203 if (ret)
204 return DRM_DP_DUAL_MODE_UNKNOWN;
205
206
207
208
209
210
211
212
213
214
215
216
217
218 ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_ADAPTOR_ID,
219 &adaptor_id, sizeof(adaptor_id));
220 DRM_DEBUG_KMS("DP dual mode adaptor ID: %02x (err %zd)\n",
221 adaptor_id, ret);
222 if (ret == 0) {
223 if (is_lspcon_adaptor(hdmi_id, adaptor_id))
224 return DRM_DP_DUAL_MODE_LSPCON;
225 if (is_type2_adaptor(adaptor_id)) {
226 if (is_hdmi_adaptor(hdmi_id))
227 return DRM_DP_DUAL_MODE_TYPE2_HDMI;
228 else
229 return DRM_DP_DUAL_MODE_TYPE2_DVI;
230 }
231
232
233
234
235
236 if (!is_type1_adaptor(adaptor_id) && adaptor_id != hdmi_id[0])
237 DRM_ERROR("Unexpected DP dual mode adaptor ID %02x\n",
238 adaptor_id);
239
240 }
241
242 if (is_hdmi_adaptor(hdmi_id))
243 return DRM_DP_DUAL_MODE_TYPE1_HDMI;
244 else
245 return DRM_DP_DUAL_MODE_TYPE1_DVI;
246}
247EXPORT_SYMBOL(drm_dp_dual_mode_detect);
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264int drm_dp_dual_mode_max_tmds_clock(enum drm_dp_dual_mode_type type,
265 struct i2c_adapter *adapter)
266{
267 uint8_t max_tmds_clock;
268 ssize_t ret;
269
270
271 if (type == DRM_DP_DUAL_MODE_NONE)
272 return 0;
273
274
275
276
277
278 if (type < DRM_DP_DUAL_MODE_TYPE2_DVI)
279 return 165000;
280
281 ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_MAX_TMDS_CLOCK,
282 &max_tmds_clock, sizeof(max_tmds_clock));
283 if (ret || max_tmds_clock == 0x00 || max_tmds_clock == 0xff) {
284 DRM_DEBUG_KMS("Failed to query max TMDS clock\n");
285 return 165000;
286 }
287
288 return max_tmds_clock * 5000 / 2;
289}
290EXPORT_SYMBOL(drm_dp_dual_mode_max_tmds_clock);
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308int drm_dp_dual_mode_get_tmds_output(enum drm_dp_dual_mode_type type,
309 struct i2c_adapter *adapter,
310 bool *enabled)
311{
312 uint8_t tmds_oen;
313 ssize_t ret;
314
315 if (type < DRM_DP_DUAL_MODE_TYPE2_DVI) {
316 *enabled = true;
317 return 0;
318 }
319
320 ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_TMDS_OEN,
321 &tmds_oen, sizeof(tmds_oen));
322 if (ret) {
323 DRM_DEBUG_KMS("Failed to query state of TMDS output buffers\n");
324 return ret;
325 }
326
327 *enabled = !(tmds_oen & DP_DUAL_MODE_TMDS_DISABLE);
328
329 return 0;
330}
331EXPORT_SYMBOL(drm_dp_dual_mode_get_tmds_output);
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348int drm_dp_dual_mode_set_tmds_output(enum drm_dp_dual_mode_type type,
349 struct i2c_adapter *adapter, bool enable)
350{
351 uint8_t tmds_oen = enable ? 0 : DP_DUAL_MODE_TMDS_DISABLE;
352 ssize_t ret;
353 int retry;
354
355 if (type < DRM_DP_DUAL_MODE_TYPE2_DVI)
356 return 0;
357
358
359
360
361
362 for (retry = 0; retry < 3; retry++) {
363 uint8_t tmp;
364
365 ret = drm_dp_dual_mode_write(adapter, DP_DUAL_MODE_TMDS_OEN,
366 &tmds_oen, sizeof(tmds_oen));
367 if (ret) {
368 DRM_DEBUG_KMS("Failed to %s TMDS output buffers (%d attempts)\n",
369 enable ? "enable" : "disable",
370 retry + 1);
371 return ret;
372 }
373
374 ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_TMDS_OEN,
375 &tmp, sizeof(tmp));
376 if (ret) {
377 DRM_DEBUG_KMS("I2C read failed during TMDS output buffer %s (%d attempts)\n",
378 enable ? "enabling" : "disabling",
379 retry + 1);
380 return ret;
381 }
382
383 if (tmp == tmds_oen)
384 return 0;
385 }
386
387 DRM_DEBUG_KMS("I2C write value mismatch during TMDS output buffer %s\n",
388 enable ? "enabling" : "disabling");
389
390 return -EIO;
391}
392EXPORT_SYMBOL(drm_dp_dual_mode_set_tmds_output);
393
394
395
396
397
398
399
400
401const char *drm_dp_get_dual_mode_type_name(enum drm_dp_dual_mode_type type)
402{
403 switch (type) {
404 case DRM_DP_DUAL_MODE_NONE:
405 return "none";
406 case DRM_DP_DUAL_MODE_TYPE1_DVI:
407 return "type 1 DVI";
408 case DRM_DP_DUAL_MODE_TYPE1_HDMI:
409 return "type 1 HDMI";
410 case DRM_DP_DUAL_MODE_TYPE2_DVI:
411 return "type 2 DVI";
412 case DRM_DP_DUAL_MODE_TYPE2_HDMI:
413 return "type 2 HDMI";
414 case DRM_DP_DUAL_MODE_LSPCON:
415 return "lspcon";
416 default:
417 WARN_ON(type != DRM_DP_DUAL_MODE_UNKNOWN);
418 return "unknown";
419 }
420}
421EXPORT_SYMBOL(drm_dp_get_dual_mode_type_name);
422
423
424
425
426
427
428
429
430
431
432
433int drm_lspcon_get_mode(struct i2c_adapter *adapter,
434 enum drm_lspcon_mode *mode)
435{
436 u8 data;
437 int ret = 0;
438 int retry;
439
440 if (!mode) {
441 DRM_ERROR("NULL input\n");
442 return -EINVAL;
443 }
444
445
446 for (retry = 0; retry < 6; retry++) {
447 if (retry)
448 usleep_range(500, 1000);
449
450 ret = drm_dp_dual_mode_read(adapter,
451 DP_DUAL_MODE_LSPCON_CURRENT_MODE,
452 &data, sizeof(data));
453 if (!ret)
454 break;
455 }
456
457 if (ret < 0) {
458 DRM_DEBUG_KMS("LSPCON read(0x80, 0x41) failed\n");
459 return -EFAULT;
460 }
461
462 if (data & DP_DUAL_MODE_LSPCON_MODE_PCON)
463 *mode = DRM_LSPCON_MODE_PCON;
464 else
465 *mode = DRM_LSPCON_MODE_LS;
466 return 0;
467}
468EXPORT_SYMBOL(drm_lspcon_get_mode);
469
470
471
472
473
474
475
476
477
478
479int drm_lspcon_set_mode(struct i2c_adapter *adapter,
480 enum drm_lspcon_mode mode)
481{
482 u8 data = 0;
483 int ret;
484 int time_out = 200;
485 enum drm_lspcon_mode current_mode;
486
487 if (mode == DRM_LSPCON_MODE_PCON)
488 data = DP_DUAL_MODE_LSPCON_MODE_PCON;
489
490
491 ret = drm_dp_dual_mode_write(adapter, DP_DUAL_MODE_LSPCON_MODE_CHANGE,
492 &data, sizeof(data));
493 if (ret < 0) {
494 DRM_ERROR("LSPCON mode change failed\n");
495 return ret;
496 }
497
498
499
500
501
502
503 do {
504 ret = drm_lspcon_get_mode(adapter, ¤t_mode);
505 if (ret) {
506 DRM_ERROR("can't confirm LSPCON mode change\n");
507 return ret;
508 } else {
509 if (current_mode != mode) {
510 msleep(10);
511 time_out -= 10;
512 } else {
513 DRM_DEBUG_KMS("LSPCON mode changed to %s\n",
514 mode == DRM_LSPCON_MODE_LS ?
515 "LS" : "PCON");
516 return 0;
517 }
518 }
519 } while (time_out);
520
521 DRM_ERROR("LSPCON mode change timed out\n");
522 return -ETIMEDOUT;
523}
524EXPORT_SYMBOL(drm_lspcon_set_mode);
525