1 /*
2 * Copyright © 2016 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
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 * DOC: dp dual mode helpers
33 *
34 * Helper functions to deal with DP dual mode (aka. DP++) adaptors.
35 *
36 * Type 1:
37 * Adaptor registers (if any) and the sink DDC bus may be accessed via I2C.
38 *
39 * Type 2:
40 * Adaptor registers and sink DDC bus can be accessed either via I2C or
41 * I2C-over-AUX. Source devices may choose to implement either of these
42 * access methods.
43 */
44
45 #define DP_DUAL_MODE_SLAVE_ADDRESS 0x40
46
47 /**
48 * drm_dp_dual_mode_read - Read from the DP dual mode adaptor register(s)
49 * @adapter: I2C adapter for the DDC bus
50 * @offset: register offset
51 * @buffer: buffer for return data
52 * @size: sizo of the buffer
53 *
54 * Reads @size bytes from the DP dual mode adaptor registers
55 * starting at @offset.
56 *
57 * Returns:
58 * 0 on success, negative error code on failure
59 */
drm_dp_dual_mode_read(struct i2c_adapter * adapter,u8 offset,void * buffer,size_t size)60 ssize_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 }
87 EXPORT_SYMBOL(drm_dp_dual_mode_read);
88
89 /**
90 * drm_dp_dual_mode_write - Write to the DP dual mode adaptor register(s)
91 * @adapter: I2C adapter for the DDC bus
92 * @offset: register offset
93 * @buffer: buffer for write data
94 * @size: sizo of the buffer
95 *
96 * Writes @size bytes to the DP dual mode adaptor registers
97 * starting at @offset.
98 *
99 * Returns:
100 * 0 on success, negative error code on failure
101 */
drm_dp_dual_mode_write(struct i2c_adapter * adapter,u8 offset,const void * buffer,size_t size)102 ssize_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, M_DRM, 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 }
134 EXPORT_SYMBOL(drm_dp_dual_mode_write);
135
is_hdmi_adaptor(const char hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN])136 static 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
is_type1_adaptor(uint8_t adaptor_id)145 static bool is_type1_adaptor(uint8_t adaptor_id)
146 {
147 return adaptor_id == 0 || adaptor_id == 0xff;
148 }
149
is_type2_adaptor(uint8_t adaptor_id)150 static 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
is_lspcon_adaptor(const char hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN],const uint8_t adaptor_id)156 static 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 * drm_dp_dual_mode_detect - Identify the DP dual mode adaptor
166 * @adapter: I2C adapter for the DDC bus
167 *
168 * Attempt to identify the type of the DP dual mode adaptor used.
169 *
170 * Note that when the answer is @DRM_DP_DUAL_MODE_UNKNOWN it's not
171 * certain whether we're dealing with a native HDMI port or
172 * a type 1 DVI dual mode adaptor. The driver will have to use
173 * some other hardware/driver specific mechanism to make that
174 * distinction.
175 *
176 * Returns:
177 * The type of the DP dual mode adaptor used
178 */
drm_dp_dual_mode_detect(struct i2c_adapter * adapter)179 enum 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 * Let's see if the adaptor is there the by reading the
187 * HDMI ID registers.
188 *
189 * Note that type 1 DVI adaptors are not required to implemnt
190 * any registers, and that presents a problem for detection.
191 * If the i2c transfer is nacked, we may or may not be dealing
192 * with a type 1 DVI adaptor. Some other mechanism of detecting
193 * the presence of the adaptor is required. One way would be
194 * to check the state of the CONFIG1 pin, Another method would
195 * simply require the driver to know whether the port is a DP++
196 * port or a native HDMI port. Both of these methods are entirely
197 * hardware/driver specific so we can't deal with them here.
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 * Sigh. Some (maybe all?) type 1 adaptors are broken and ack
208 * the offset but ignore it, and instead they just always return
209 * data from the start of the HDMI ID buffer. So for a broken
210 * type 1 HDMI adaptor a single byte read will always give us
211 * 0x44, and for a type 1 DVI adaptor it should give 0x00
212 * (assuming it implements any registers). Fortunately neither
213 * of those values will match the type 2 signature of the
214 * DP_DUAL_MODE_ADAPTOR_ID register so we can proceed with
215 * the type 2 adaptor detection safely even in the presence
216 * of broken type 1 adaptors.
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 * If neither a proper type 1 ID nor a broken type 1 adaptor
233 * as described above, assume type 1, but let the user know
234 * that we may have misdetected the type.
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 }
247 EXPORT_SYMBOL(drm_dp_dual_mode_detect);
248
249 /**
250 * drm_dp_dual_mode_max_tmds_clock - Max TMDS clock for DP dual mode adaptor
251 * @type: DP dual mode adaptor type
252 * @adapter: I2C adapter for the DDC bus
253 *
254 * Determine the max TMDS clock the adaptor supports based on the
255 * type of the dual mode adaptor and the DP_DUAL_MODE_MAX_TMDS_CLOCK
256 * register (on type2 adaptors). As some type 1 adaptors have
257 * problems with registers (see comments in drm_dp_dual_mode_detect())
258 * we don't read the register on those, instead we simply assume
259 * a 165 MHz limit based on the specification.
260 *
261 * Returns:
262 * Maximum supported TMDS clock rate for the DP dual mode adaptor in kHz.
263 */
drm_dp_dual_mode_max_tmds_clock(enum drm_dp_dual_mode_type type,struct i2c_adapter * adapter)264 int 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 /* native HDMI so no limit */
271 if (type == DRM_DP_DUAL_MODE_NONE)
272 return 0;
273
274 /*
275 * Type 1 adaptors are limited to 165MHz
276 * Type 2 adaptors can tells us their limit
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 }
290 EXPORT_SYMBOL(drm_dp_dual_mode_max_tmds_clock);
291
292 /**
293 * drm_dp_dual_mode_get_tmds_output - Get the state of the TMDS output buffers in the DP dual mode adaptor
294 * @type: DP dual mode adaptor type
295 * @adapter: I2C adapter for the DDC bus
296 * @enabled: current state of the TMDS output buffers
297 *
298 * Get the state of the TMDS output buffers in the adaptor. For
299 * type2 adaptors this is queried from the DP_DUAL_MODE_TMDS_OEN
300 * register. As some type 1 adaptors have problems with registers
301 * (see comments in drm_dp_dual_mode_detect()) we don't read the
302 * register on those, instead we simply assume that the buffers
303 * are always enabled.
304 *
305 * Returns:
306 * 0 on success, negative error code on failure
307 */
drm_dp_dual_mode_get_tmds_output(enum drm_dp_dual_mode_type type,struct i2c_adapter * adapter,bool * enabled)308 int 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 }
331 EXPORT_SYMBOL(drm_dp_dual_mode_get_tmds_output);
332
333 /**
334 * drm_dp_dual_mode_set_tmds_output - Enable/disable TMDS output buffers in the DP dual mode adaptor
335 * @type: DP dual mode adaptor type
336 * @adapter: I2C adapter for the DDC bus
337 * @enable: enable (as opposed to disable) the TMDS output buffers
338 *
339 * Set the state of the TMDS output buffers in the adaptor. For
340 * type2 this is set via the DP_DUAL_MODE_TMDS_OEN register. As
341 * some type 1 adaptors have problems with registers (see comments
342 * in drm_dp_dual_mode_detect()) we avoid touching the register,
343 * making this function a no-op on type 1 adaptors.
344 *
345 * Returns:
346 * 0 on success, negative error code on failure
347 */
drm_dp_dual_mode_set_tmds_output(enum drm_dp_dual_mode_type type,struct i2c_adapter * adapter,bool enable)348 int 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
354 if (type < DRM_DP_DUAL_MODE_TYPE2_DVI)
355 return 0;
356
357 ret = drm_dp_dual_mode_write(adapter, DP_DUAL_MODE_TMDS_OEN,
358 &tmds_oen, sizeof(tmds_oen));
359 if (ret) {
360 DRM_DEBUG_KMS("Failed to %s TMDS output buffers\n",
361 enable ? "enable" : "disable");
362 return ret;
363 }
364
365 return 0;
366 }
367 EXPORT_SYMBOL(drm_dp_dual_mode_set_tmds_output);
368
369 /**
370 * drm_dp_get_dual_mode_type_name - Get the name of the DP dual mode adaptor type as a string
371 * @type: DP dual mode adaptor type
372 *
373 * Returns:
374 * String representation of the DP dual mode adaptor type
375 */
drm_dp_get_dual_mode_type_name(enum drm_dp_dual_mode_type type)376 const char *drm_dp_get_dual_mode_type_name(enum drm_dp_dual_mode_type type)
377 {
378 switch (type) {
379 case DRM_DP_DUAL_MODE_NONE:
380 return "none";
381 case DRM_DP_DUAL_MODE_TYPE1_DVI:
382 return "type 1 DVI";
383 case DRM_DP_DUAL_MODE_TYPE1_HDMI:
384 return "type 1 HDMI";
385 case DRM_DP_DUAL_MODE_TYPE2_DVI:
386 return "type 2 DVI";
387 case DRM_DP_DUAL_MODE_TYPE2_HDMI:
388 return "type 2 HDMI";
389 case DRM_DP_DUAL_MODE_LSPCON:
390 return "lspcon";
391 default:
392 WARN_ON(type != DRM_DP_DUAL_MODE_UNKNOWN);
393 return "unknown";
394 }
395 }
396 EXPORT_SYMBOL(drm_dp_get_dual_mode_type_name);
397
398 /**
399 * drm_lspcon_get_mode: Get LSPCON's current mode of operation by
400 * reading offset (0x80, 0x41)
401 * @adapter: I2C-over-aux adapter
402 * @mode: current lspcon mode of operation output variable
403 *
404 * Returns:
405 * 0 on success, sets the current_mode value to appropriate mode
406 * -error on failure
407 */
drm_lspcon_get_mode(struct i2c_adapter * adapter,enum drm_lspcon_mode * mode)408 int drm_lspcon_get_mode(struct i2c_adapter *adapter,
409 enum drm_lspcon_mode *mode)
410 {
411 u8 data;
412 int ret = 0;
413 int retry;
414
415 if (!mode) {
416 DRM_ERROR("NULL input\n");
417 return -EINVAL;
418 }
419
420 /* Read Status: i2c over aux */
421 for (retry = 0; retry < 6; retry++) {
422 if (retry)
423 usleep_range(500, 1000);
424
425 ret = drm_dp_dual_mode_read(adapter,
426 DP_DUAL_MODE_LSPCON_CURRENT_MODE,
427 &data, sizeof(data));
428 if (!ret)
429 break;
430 }
431
432 if (ret < 0) {
433 DRM_DEBUG_KMS("LSPCON read(0x80, 0x41) failed\n");
434 return -EFAULT;
435 }
436
437 if (data & DP_DUAL_MODE_LSPCON_MODE_PCON)
438 *mode = DRM_LSPCON_MODE_PCON;
439 else
440 *mode = DRM_LSPCON_MODE_LS;
441 return 0;
442 }
443 EXPORT_SYMBOL(drm_lspcon_get_mode);
444
445 /**
446 * drm_lspcon_set_mode: Change LSPCON's mode of operation by
447 * writing offset (0x80, 0x40)
448 * @adapter: I2C-over-aux adapter
449 * @mode: required mode of operation
450 *
451 * Returns:
452 * 0 on success, -error on failure/timeout
453 */
drm_lspcon_set_mode(struct i2c_adapter * adapter,enum drm_lspcon_mode mode)454 int drm_lspcon_set_mode(struct i2c_adapter *adapter,
455 enum drm_lspcon_mode mode)
456 {
457 u8 data = 0;
458 int ret;
459 int time_out = 200;
460 enum drm_lspcon_mode current_mode;
461
462 if (mode == DRM_LSPCON_MODE_PCON)
463 data = DP_DUAL_MODE_LSPCON_MODE_PCON;
464
465 /* Change mode */
466 ret = drm_dp_dual_mode_write(adapter, DP_DUAL_MODE_LSPCON_MODE_CHANGE,
467 &data, sizeof(data));
468 if (ret < 0) {
469 DRM_ERROR("LSPCON mode change failed\n");
470 return ret;
471 }
472
473 /*
474 * Confirm mode change by reading the status bit.
475 * Sometimes, it takes a while to change the mode,
476 * so wait and retry until time out or done.
477 */
478 do {
479 ret = drm_lspcon_get_mode(adapter, ¤t_mode);
480 if (ret) {
481 DRM_ERROR("can't confirm LSPCON mode change\n");
482 return ret;
483 } else {
484 if (current_mode != mode) {
485 msleep(10);
486 time_out -= 10;
487 } else {
488 DRM_DEBUG_KMS("LSPCON mode changed to %s\n",
489 mode == DRM_LSPCON_MODE_LS ?
490 "LS" : "PCON");
491 return 0;
492 }
493 }
494 } while (time_out);
495
496 DRM_ERROR("LSPCON mode change timed out\n");
497 return -ETIMEDOUT;
498 }
499 EXPORT_SYMBOL(drm_lspcon_set_mode);
500