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 */
 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 * 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 */
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 * 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 */
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	 * 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}
247EXPORT_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 */
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	/* 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}
290EXPORT_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 */
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 * 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 */
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	 * LSPCON adapters in low-power state may ignore the first write, so
360	 * read back and verify the written value a few times.
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 * drm_dp_get_dual_mode_type_name - Get the name of the DP dual mode adaptor type as a string
396 * @type: DP dual mode adaptor type
397 *
398 * Returns:
399 * String representation of the DP dual mode adaptor type
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 * drm_lspcon_get_mode: Get LSPCON's current mode of operation by
425 * reading offset (0x80, 0x41)
426 * @adapter: I2C-over-aux adapter
427 * @mode: current lspcon mode of operation output variable
428 *
429 * Returns:
430 * 0 on success, sets the current_mode value to appropriate mode
431 * -error on failure
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	/* Read Status: i2c over aux */
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 * drm_lspcon_set_mode: Change LSPCON's mode of operation by
472 * writing offset (0x80, 0x40)
473 * @adapter: I2C-over-aux adapter
474 * @mode: required mode of operation
475 *
476 * Returns:
477 * 0 on success, -error on failure/timeout
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	/* Change mode */
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	 * Confirm mode change by reading the status bit.
500	 * Sometimes, it takes a while to change the mode,
501	 * so wait and retry until time out or done.
502	 */
503	do {
504		ret = drm_lspcon_get_mode(adapter, &current_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);