xref: /openbmc/linux/drivers/gpu/drm/bridge/sii902x.c (revision 4f59acbe)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2018 Renesas Electronics
4  *
5  * Copyright (C) 2016 Atmel
6  *		      Bo Shen <voice.shen@atmel.com>
7  *
8  * Authors:	      Bo Shen <voice.shen@atmel.com>
9  *		      Boris Brezillon <boris.brezillon@free-electrons.com>
10  *		      Wu, Songjun <Songjun.Wu@atmel.com>
11  *
12  * Copyright (C) 2010-2011 Freescale Semiconductor, Inc. All Rights Reserved.
13  */
14 
15 #include <linux/gpio/consumer.h>
16 #include <linux/i2c-mux.h>
17 #include <linux/i2c.h>
18 #include <linux/media-bus-format.h>
19 #include <linux/module.h>
20 #include <linux/regmap.h>
21 #include <linux/regulator/consumer.h>
22 #include <linux/clk.h>
23 
24 #include <drm/drm_atomic_helper.h>
25 #include <drm/drm_bridge.h>
26 #include <drm/drm_drv.h>
27 #include <drm/drm_edid.h>
28 #include <drm/drm_print.h>
29 #include <drm/drm_probe_helper.h>
30 
31 #include <sound/hdmi-codec.h>
32 
33 #define SII902X_TPI_VIDEO_DATA			0x0
34 
35 #define SII902X_TPI_PIXEL_REPETITION		0x8
36 #define SII902X_TPI_AVI_PIXEL_REP_BUS_24BIT     BIT(5)
37 #define SII902X_TPI_AVI_PIXEL_REP_RISING_EDGE   BIT(4)
38 #define SII902X_TPI_AVI_PIXEL_REP_4X		3
39 #define SII902X_TPI_AVI_PIXEL_REP_2X		1
40 #define SII902X_TPI_AVI_PIXEL_REP_NONE		0
41 #define SII902X_TPI_CLK_RATIO_HALF		(0 << 6)
42 #define SII902X_TPI_CLK_RATIO_1X		(1 << 6)
43 #define SII902X_TPI_CLK_RATIO_2X		(2 << 6)
44 #define SII902X_TPI_CLK_RATIO_4X		(3 << 6)
45 
46 #define SII902X_TPI_AVI_IN_FORMAT		0x9
47 #define SII902X_TPI_AVI_INPUT_BITMODE_12BIT	BIT(7)
48 #define SII902X_TPI_AVI_INPUT_DITHER		BIT(6)
49 #define SII902X_TPI_AVI_INPUT_RANGE_LIMITED	(2 << 2)
50 #define SII902X_TPI_AVI_INPUT_RANGE_FULL	(1 << 2)
51 #define SII902X_TPI_AVI_INPUT_RANGE_AUTO	(0 << 2)
52 #define SII902X_TPI_AVI_INPUT_COLORSPACE_BLACK	(3 << 0)
53 #define SII902X_TPI_AVI_INPUT_COLORSPACE_YUV422	(2 << 0)
54 #define SII902X_TPI_AVI_INPUT_COLORSPACE_YUV444	(1 << 0)
55 #define SII902X_TPI_AVI_INPUT_COLORSPACE_RGB	(0 << 0)
56 
57 #define SII902X_TPI_AVI_INFOFRAME		0x0c
58 
59 #define SII902X_SYS_CTRL_DATA			0x1a
60 #define SII902X_SYS_CTRL_PWR_DWN		BIT(4)
61 #define SII902X_SYS_CTRL_AV_MUTE		BIT(3)
62 #define SII902X_SYS_CTRL_DDC_BUS_REQ		BIT(2)
63 #define SII902X_SYS_CTRL_DDC_BUS_GRTD		BIT(1)
64 #define SII902X_SYS_CTRL_OUTPUT_MODE		BIT(0)
65 #define SII902X_SYS_CTRL_OUTPUT_HDMI		1
66 #define SII902X_SYS_CTRL_OUTPUT_DVI		0
67 
68 #define SII902X_REG_CHIPID(n)			(0x1b + (n))
69 
70 #define SII902X_PWR_STATE_CTRL			0x1e
71 #define SII902X_AVI_POWER_STATE_MSK		GENMASK(1, 0)
72 #define SII902X_AVI_POWER_STATE_D(l)		((l) & SII902X_AVI_POWER_STATE_MSK)
73 
74 /* Audio  */
75 #define SII902X_TPI_I2S_ENABLE_MAPPING_REG	0x1f
76 #define SII902X_TPI_I2S_CONFIG_FIFO0			(0 << 0)
77 #define SII902X_TPI_I2S_CONFIG_FIFO1			(1 << 0)
78 #define SII902X_TPI_I2S_CONFIG_FIFO2			(2 << 0)
79 #define SII902X_TPI_I2S_CONFIG_FIFO3			(3 << 0)
80 #define SII902X_TPI_I2S_LEFT_RIGHT_SWAP			(1 << 2)
81 #define SII902X_TPI_I2S_AUTO_DOWNSAMPLE			(1 << 3)
82 #define SII902X_TPI_I2S_SELECT_SD0			(0 << 4)
83 #define SII902X_TPI_I2S_SELECT_SD1			(1 << 4)
84 #define SII902X_TPI_I2S_SELECT_SD2			(2 << 4)
85 #define SII902X_TPI_I2S_SELECT_SD3			(3 << 4)
86 #define SII902X_TPI_I2S_FIFO_ENABLE			(1 << 7)
87 
88 #define SII902X_TPI_I2S_INPUT_CONFIG_REG	0x20
89 #define SII902X_TPI_I2S_FIRST_BIT_SHIFT_YES		(0 << 0)
90 #define SII902X_TPI_I2S_FIRST_BIT_SHIFT_NO		(1 << 0)
91 #define SII902X_TPI_I2S_SD_DIRECTION_MSB_FIRST		(0 << 1)
92 #define SII902X_TPI_I2S_SD_DIRECTION_LSB_FIRST		(1 << 1)
93 #define SII902X_TPI_I2S_SD_JUSTIFY_LEFT			(0 << 2)
94 #define SII902X_TPI_I2S_SD_JUSTIFY_RIGHT		(1 << 2)
95 #define SII902X_TPI_I2S_WS_POLARITY_LOW			(0 << 3)
96 #define SII902X_TPI_I2S_WS_POLARITY_HIGH		(1 << 3)
97 #define SII902X_TPI_I2S_MCLK_MULTIPLIER_128		(0 << 4)
98 #define SII902X_TPI_I2S_MCLK_MULTIPLIER_256		(1 << 4)
99 #define SII902X_TPI_I2S_MCLK_MULTIPLIER_384		(2 << 4)
100 #define SII902X_TPI_I2S_MCLK_MULTIPLIER_512		(3 << 4)
101 #define SII902X_TPI_I2S_MCLK_MULTIPLIER_768		(4 << 4)
102 #define SII902X_TPI_I2S_MCLK_MULTIPLIER_1024		(5 << 4)
103 #define SII902X_TPI_I2S_MCLK_MULTIPLIER_1152		(6 << 4)
104 #define SII902X_TPI_I2S_MCLK_MULTIPLIER_192		(7 << 4)
105 #define SII902X_TPI_I2S_SCK_EDGE_FALLING		(0 << 7)
106 #define SII902X_TPI_I2S_SCK_EDGE_RISING			(1 << 7)
107 
108 #define SII902X_TPI_I2S_STRM_HDR_BASE	0x21
109 #define SII902X_TPI_I2S_STRM_HDR_SIZE	5
110 
111 #define SII902X_TPI_AUDIO_CONFIG_BYTE2_REG	0x26
112 #define SII902X_TPI_AUDIO_CODING_STREAM_HEADER		(0 << 0)
113 #define SII902X_TPI_AUDIO_CODING_PCM			(1 << 0)
114 #define SII902X_TPI_AUDIO_CODING_AC3			(2 << 0)
115 #define SII902X_TPI_AUDIO_CODING_MPEG1			(3 << 0)
116 #define SII902X_TPI_AUDIO_CODING_MP3			(4 << 0)
117 #define SII902X_TPI_AUDIO_CODING_MPEG2			(5 << 0)
118 #define SII902X_TPI_AUDIO_CODING_AAC			(6 << 0)
119 #define SII902X_TPI_AUDIO_CODING_DTS			(7 << 0)
120 #define SII902X_TPI_AUDIO_CODING_ATRAC			(8 << 0)
121 #define SII902X_TPI_AUDIO_MUTE_DISABLE			(0 << 4)
122 #define SII902X_TPI_AUDIO_MUTE_ENABLE			(1 << 4)
123 #define SII902X_TPI_AUDIO_LAYOUT_2_CHANNELS		(0 << 5)
124 #define SII902X_TPI_AUDIO_LAYOUT_8_CHANNELS		(1 << 5)
125 #define SII902X_TPI_AUDIO_INTERFACE_DISABLE		(0 << 6)
126 #define SII902X_TPI_AUDIO_INTERFACE_SPDIF		(1 << 6)
127 #define SII902X_TPI_AUDIO_INTERFACE_I2S			(2 << 6)
128 
129 #define SII902X_TPI_AUDIO_CONFIG_BYTE3_REG	0x27
130 #define SII902X_TPI_AUDIO_FREQ_STREAM			(0 << 3)
131 #define SII902X_TPI_AUDIO_FREQ_32KHZ			(1 << 3)
132 #define SII902X_TPI_AUDIO_FREQ_44KHZ			(2 << 3)
133 #define SII902X_TPI_AUDIO_FREQ_48KHZ			(3 << 3)
134 #define SII902X_TPI_AUDIO_FREQ_88KHZ			(4 << 3)
135 #define SII902X_TPI_AUDIO_FREQ_96KHZ			(5 << 3)
136 #define SII902X_TPI_AUDIO_FREQ_176KHZ			(6 << 3)
137 #define SII902X_TPI_AUDIO_FREQ_192KHZ			(7 << 3)
138 #define SII902X_TPI_AUDIO_SAMPLE_SIZE_STREAM		(0 << 6)
139 #define SII902X_TPI_AUDIO_SAMPLE_SIZE_16		(1 << 6)
140 #define SII902X_TPI_AUDIO_SAMPLE_SIZE_20		(2 << 6)
141 #define SII902X_TPI_AUDIO_SAMPLE_SIZE_24		(3 << 6)
142 
143 #define SII902X_TPI_AUDIO_CONFIG_BYTE4_REG	0x28
144 
145 #define SII902X_INT_ENABLE			0x3c
146 #define SII902X_INT_STATUS			0x3d
147 #define SII902X_HOTPLUG_EVENT			BIT(0)
148 #define SII902X_PLUGGED_STATUS			BIT(2)
149 
150 #define SII902X_REG_TPI_RQB			0xc7
151 
152 /* Indirect internal register access */
153 #define SII902X_IND_SET_PAGE			0xbc
154 #define SII902X_IND_OFFSET			0xbd
155 #define SII902X_IND_VALUE			0xbe
156 
157 #define SII902X_TPI_MISC_INFOFRAME_BASE		0xbf
158 #define SII902X_TPI_MISC_INFOFRAME_END		0xde
159 #define SII902X_TPI_MISC_INFOFRAME_SIZE	\
160 	(SII902X_TPI_MISC_INFOFRAME_END - SII902X_TPI_MISC_INFOFRAME_BASE)
161 
162 #define SII902X_I2C_BUS_ACQUISITION_TIMEOUT_MS	500
163 
164 #define SII902X_AUDIO_PORT_INDEX		3
165 
166 struct sii902x {
167 	struct i2c_client *i2c;
168 	struct regmap *regmap;
169 	struct drm_bridge bridge;
170 	struct drm_bridge *next_bridge;
171 	struct drm_connector connector;
172 	struct gpio_desc *reset_gpio;
173 	struct i2c_mux_core *i2cmux;
174 	bool sink_is_hdmi;
175 	/*
176 	 * Mutex protects audio and video functions from interfering
177 	 * each other, by keeping their i2c command sequences atomic.
178 	 */
179 	struct mutex mutex;
180 	struct sii902x_audio {
181 		struct platform_device *pdev;
182 		struct clk *mclk;
183 		u32 i2s_fifo_sequence[4];
184 	} audio;
185 };
186 
sii902x_read_unlocked(struct i2c_client * i2c,u8 reg,u8 * val)187 static int sii902x_read_unlocked(struct i2c_client *i2c, u8 reg, u8 *val)
188 {
189 	union i2c_smbus_data data;
190 	int ret;
191 
192 	ret = __i2c_smbus_xfer(i2c->adapter, i2c->addr, i2c->flags,
193 			       I2C_SMBUS_READ, reg, I2C_SMBUS_BYTE_DATA, &data);
194 
195 	if (ret < 0)
196 		return ret;
197 
198 	*val = data.byte;
199 	return 0;
200 }
201 
sii902x_write_unlocked(struct i2c_client * i2c,u8 reg,u8 val)202 static int sii902x_write_unlocked(struct i2c_client *i2c, u8 reg, u8 val)
203 {
204 	union i2c_smbus_data data;
205 
206 	data.byte = val;
207 
208 	return __i2c_smbus_xfer(i2c->adapter, i2c->addr, i2c->flags,
209 				I2C_SMBUS_WRITE, reg, I2C_SMBUS_BYTE_DATA,
210 				&data);
211 }
212 
sii902x_update_bits_unlocked(struct i2c_client * i2c,u8 reg,u8 mask,u8 val)213 static int sii902x_update_bits_unlocked(struct i2c_client *i2c, u8 reg, u8 mask,
214 					u8 val)
215 {
216 	int ret;
217 	u8 status;
218 
219 	ret = sii902x_read_unlocked(i2c, reg, &status);
220 	if (ret)
221 		return ret;
222 	status &= ~mask;
223 	status |= val & mask;
224 	return sii902x_write_unlocked(i2c, reg, status);
225 }
226 
bridge_to_sii902x(struct drm_bridge * bridge)227 static inline struct sii902x *bridge_to_sii902x(struct drm_bridge *bridge)
228 {
229 	return container_of(bridge, struct sii902x, bridge);
230 }
231 
connector_to_sii902x(struct drm_connector * con)232 static inline struct sii902x *connector_to_sii902x(struct drm_connector *con)
233 {
234 	return container_of(con, struct sii902x, connector);
235 }
236 
sii902x_reset(struct sii902x * sii902x)237 static void sii902x_reset(struct sii902x *sii902x)
238 {
239 	if (!sii902x->reset_gpio)
240 		return;
241 
242 	gpiod_set_value_cansleep(sii902x->reset_gpio, 1);
243 
244 	/* The datasheet says treset-min = 100us. Make it 150us to be sure. */
245 	usleep_range(150, 200);
246 
247 	gpiod_set_value_cansleep(sii902x->reset_gpio, 0);
248 }
249 
sii902x_detect(struct sii902x * sii902x)250 static enum drm_connector_status sii902x_detect(struct sii902x *sii902x)
251 {
252 	unsigned int status;
253 
254 	mutex_lock(&sii902x->mutex);
255 
256 	regmap_read(sii902x->regmap, SII902X_INT_STATUS, &status);
257 
258 	mutex_unlock(&sii902x->mutex);
259 
260 	return (status & SII902X_PLUGGED_STATUS) ?
261 	       connector_status_connected : connector_status_disconnected;
262 }
263 
264 static enum drm_connector_status
sii902x_connector_detect(struct drm_connector * connector,bool force)265 sii902x_connector_detect(struct drm_connector *connector, bool force)
266 {
267 	struct sii902x *sii902x = connector_to_sii902x(connector);
268 
269 	return sii902x_detect(sii902x);
270 }
271 
272 static const struct drm_connector_funcs sii902x_connector_funcs = {
273 	.detect = sii902x_connector_detect,
274 	.fill_modes = drm_helper_probe_single_connector_modes,
275 	.destroy = drm_connector_cleanup,
276 	.reset = drm_atomic_helper_connector_reset,
277 	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
278 	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
279 };
280 
sii902x_get_edid(struct sii902x * sii902x,struct drm_connector * connector)281 static struct edid *sii902x_get_edid(struct sii902x *sii902x,
282 				     struct drm_connector *connector)
283 {
284 	struct edid *edid;
285 
286 	mutex_lock(&sii902x->mutex);
287 
288 	edid = drm_get_edid(connector, sii902x->i2cmux->adapter[0]);
289 	if (edid) {
290 		if (drm_detect_hdmi_monitor(edid))
291 			sii902x->sink_is_hdmi = true;
292 		else
293 			sii902x->sink_is_hdmi = false;
294 	}
295 
296 	mutex_unlock(&sii902x->mutex);
297 
298 	return edid;
299 }
300 
sii902x_get_modes(struct drm_connector * connector)301 static int sii902x_get_modes(struct drm_connector *connector)
302 {
303 	struct sii902x *sii902x = connector_to_sii902x(connector);
304 	struct edid *edid;
305 	int num = 0;
306 
307 	edid = sii902x_get_edid(sii902x, connector);
308 	drm_connector_update_edid_property(connector, edid);
309 	if (edid) {
310 		num = drm_add_edid_modes(connector, edid);
311 		kfree(edid);
312 	}
313 
314 	return num;
315 }
316 
sii902x_mode_valid(struct drm_connector * connector,struct drm_display_mode * mode)317 static enum drm_mode_status sii902x_mode_valid(struct drm_connector *connector,
318 					       struct drm_display_mode *mode)
319 {
320 	/* TODO: check mode */
321 
322 	return MODE_OK;
323 }
324 
325 static const struct drm_connector_helper_funcs sii902x_connector_helper_funcs = {
326 	.get_modes = sii902x_get_modes,
327 	.mode_valid = sii902x_mode_valid,
328 };
329 
sii902x_bridge_disable(struct drm_bridge * bridge)330 static void sii902x_bridge_disable(struct drm_bridge *bridge)
331 {
332 	struct sii902x *sii902x = bridge_to_sii902x(bridge);
333 
334 	mutex_lock(&sii902x->mutex);
335 
336 	regmap_update_bits(sii902x->regmap, SII902X_SYS_CTRL_DATA,
337 			   SII902X_SYS_CTRL_PWR_DWN,
338 			   SII902X_SYS_CTRL_PWR_DWN);
339 
340 	mutex_unlock(&sii902x->mutex);
341 }
342 
sii902x_bridge_enable(struct drm_bridge * bridge)343 static void sii902x_bridge_enable(struct drm_bridge *bridge)
344 {
345 	struct sii902x *sii902x = bridge_to_sii902x(bridge);
346 
347 	mutex_lock(&sii902x->mutex);
348 
349 	regmap_update_bits(sii902x->regmap, SII902X_PWR_STATE_CTRL,
350 			   SII902X_AVI_POWER_STATE_MSK,
351 			   SII902X_AVI_POWER_STATE_D(0));
352 	regmap_update_bits(sii902x->regmap, SII902X_SYS_CTRL_DATA,
353 			   SII902X_SYS_CTRL_PWR_DWN, 0);
354 
355 	mutex_unlock(&sii902x->mutex);
356 }
357 
sii902x_bridge_mode_set(struct drm_bridge * bridge,const struct drm_display_mode * mode,const struct drm_display_mode * adj)358 static void sii902x_bridge_mode_set(struct drm_bridge *bridge,
359 				    const struct drm_display_mode *mode,
360 				    const struct drm_display_mode *adj)
361 {
362 	struct sii902x *sii902x = bridge_to_sii902x(bridge);
363 	u8 output_mode = SII902X_SYS_CTRL_OUTPUT_DVI;
364 	struct regmap *regmap = sii902x->regmap;
365 	u8 buf[HDMI_INFOFRAME_SIZE(AVI)];
366 	struct hdmi_avi_infoframe frame;
367 	u16 pixel_clock_10kHz = adj->clock / 10;
368 	int ret;
369 
370 	if (sii902x->sink_is_hdmi)
371 		output_mode = SII902X_SYS_CTRL_OUTPUT_HDMI;
372 
373 	buf[0] = pixel_clock_10kHz & 0xff;
374 	buf[1] = pixel_clock_10kHz >> 8;
375 	buf[2] = drm_mode_vrefresh(adj);
376 	buf[3] = 0x00;
377 	buf[4] = adj->hdisplay;
378 	buf[5] = adj->hdisplay >> 8;
379 	buf[6] = adj->vdisplay;
380 	buf[7] = adj->vdisplay >> 8;
381 	buf[8] = SII902X_TPI_CLK_RATIO_1X | SII902X_TPI_AVI_PIXEL_REP_NONE |
382 		 SII902X_TPI_AVI_PIXEL_REP_BUS_24BIT;
383 	buf[9] = SII902X_TPI_AVI_INPUT_RANGE_AUTO |
384 		 SII902X_TPI_AVI_INPUT_COLORSPACE_RGB;
385 
386 	mutex_lock(&sii902x->mutex);
387 
388 	ret = regmap_update_bits(sii902x->regmap, SII902X_SYS_CTRL_DATA,
389 				 SII902X_SYS_CTRL_OUTPUT_MODE, output_mode);
390 	if (ret)
391 		goto out;
392 
393 	ret = regmap_bulk_write(regmap, SII902X_TPI_VIDEO_DATA, buf, 10);
394 	if (ret)
395 		goto out;
396 
397 	ret = drm_hdmi_avi_infoframe_from_display_mode(&frame,
398 						       &sii902x->connector, adj);
399 	if (ret < 0) {
400 		DRM_ERROR("couldn't fill AVI infoframe\n");
401 		goto out;
402 	}
403 
404 	ret = hdmi_avi_infoframe_pack(&frame, buf, sizeof(buf));
405 	if (ret < 0) {
406 		DRM_ERROR("failed to pack AVI infoframe: %d\n", ret);
407 		goto out;
408 	}
409 
410 	/* Do not send the infoframe header, but keep the CRC field. */
411 	regmap_bulk_write(regmap, SII902X_TPI_AVI_INFOFRAME,
412 			  buf + HDMI_INFOFRAME_HEADER_SIZE - 1,
413 			  HDMI_AVI_INFOFRAME_SIZE + 1);
414 
415 out:
416 	mutex_unlock(&sii902x->mutex);
417 }
418 
sii902x_bridge_attach(struct drm_bridge * bridge,enum drm_bridge_attach_flags flags)419 static int sii902x_bridge_attach(struct drm_bridge *bridge,
420 				 enum drm_bridge_attach_flags flags)
421 {
422 	struct sii902x *sii902x = bridge_to_sii902x(bridge);
423 	u32 bus_format = MEDIA_BUS_FMT_RGB888_1X24;
424 	struct drm_device *drm = bridge->dev;
425 	int ret;
426 
427 	if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
428 		return drm_bridge_attach(bridge->encoder, sii902x->next_bridge,
429 					 bridge, flags);
430 
431 	drm_connector_helper_add(&sii902x->connector,
432 				 &sii902x_connector_helper_funcs);
433 
434 	if (!drm_core_check_feature(drm, DRIVER_ATOMIC)) {
435 		dev_err(&sii902x->i2c->dev,
436 			"sii902x driver is only compatible with DRM devices supporting atomic updates\n");
437 		return -ENOTSUPP;
438 	}
439 
440 	ret = drm_connector_init(drm, &sii902x->connector,
441 				 &sii902x_connector_funcs,
442 				 DRM_MODE_CONNECTOR_HDMIA);
443 	if (ret)
444 		return ret;
445 
446 	if (sii902x->i2c->irq > 0)
447 		sii902x->connector.polled = DRM_CONNECTOR_POLL_HPD;
448 	else
449 		sii902x->connector.polled = DRM_CONNECTOR_POLL_CONNECT;
450 
451 	ret = drm_display_info_set_bus_formats(&sii902x->connector.display_info,
452 					       &bus_format, 1);
453 	if (ret)
454 		return ret;
455 
456 	drm_connector_attach_encoder(&sii902x->connector, bridge->encoder);
457 
458 	return 0;
459 }
460 
sii902x_bridge_detect(struct drm_bridge * bridge)461 static enum drm_connector_status sii902x_bridge_detect(struct drm_bridge *bridge)
462 {
463 	struct sii902x *sii902x = bridge_to_sii902x(bridge);
464 
465 	return sii902x_detect(sii902x);
466 }
467 
sii902x_bridge_get_edid(struct drm_bridge * bridge,struct drm_connector * connector)468 static struct edid *sii902x_bridge_get_edid(struct drm_bridge *bridge,
469 					    struct drm_connector *connector)
470 {
471 	struct sii902x *sii902x = bridge_to_sii902x(bridge);
472 
473 	return sii902x_get_edid(sii902x, connector);
474 }
475 
sii902x_bridge_atomic_get_input_bus_fmts(struct drm_bridge * bridge,struct drm_bridge_state * bridge_state,struct drm_crtc_state * crtc_state,struct drm_connector_state * conn_state,u32 output_fmt,unsigned int * num_input_fmts)476 static u32 *sii902x_bridge_atomic_get_input_bus_fmts(struct drm_bridge *bridge,
477 						     struct drm_bridge_state *bridge_state,
478 						     struct drm_crtc_state *crtc_state,
479 						     struct drm_connector_state *conn_state,
480 						     u32 output_fmt,
481 						     unsigned int *num_input_fmts)
482 {
483 	u32 *input_fmts;
484 
485 	*num_input_fmts = 0;
486 
487 	input_fmts = kcalloc(1, sizeof(*input_fmts), GFP_KERNEL);
488 	if (!input_fmts)
489 		return NULL;
490 
491 	input_fmts[0] = MEDIA_BUS_FMT_RGB888_1X24;
492 	*num_input_fmts = 1;
493 
494 	return input_fmts;
495 }
496 
sii902x_bridge_atomic_check(struct drm_bridge * bridge,struct drm_bridge_state * bridge_state,struct drm_crtc_state * crtc_state,struct drm_connector_state * conn_state)497 static int sii902x_bridge_atomic_check(struct drm_bridge *bridge,
498 				       struct drm_bridge_state *bridge_state,
499 				       struct drm_crtc_state *crtc_state,
500 				       struct drm_connector_state *conn_state)
501 {
502 	/*
503 	 * There might be flags negotiation supported in future but
504 	 * set the bus flags in atomic_check statically for now.
505 	 */
506 	bridge_state->input_bus_cfg.flags = bridge->timings->input_bus_flags;
507 
508 	return 0;
509 }
510 
511 static const struct drm_bridge_funcs sii902x_bridge_funcs = {
512 	.attach = sii902x_bridge_attach,
513 	.mode_set = sii902x_bridge_mode_set,
514 	.disable = sii902x_bridge_disable,
515 	.enable = sii902x_bridge_enable,
516 	.detect = sii902x_bridge_detect,
517 	.get_edid = sii902x_bridge_get_edid,
518 	.atomic_reset = drm_atomic_helper_bridge_reset,
519 	.atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
520 	.atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
521 	.atomic_get_input_bus_fmts = sii902x_bridge_atomic_get_input_bus_fmts,
522 	.atomic_check = sii902x_bridge_atomic_check,
523 };
524 
sii902x_mute(struct sii902x * sii902x,bool mute)525 static int sii902x_mute(struct sii902x *sii902x, bool mute)
526 {
527 	struct device *dev = &sii902x->i2c->dev;
528 	unsigned int val = mute ? SII902X_TPI_AUDIO_MUTE_ENABLE :
529 		SII902X_TPI_AUDIO_MUTE_DISABLE;
530 
531 	dev_dbg(dev, "%s: %s\n", __func__, mute ? "Muted" : "Unmuted");
532 
533 	return regmap_update_bits(sii902x->regmap,
534 				  SII902X_TPI_AUDIO_CONFIG_BYTE2_REG,
535 				  SII902X_TPI_AUDIO_MUTE_ENABLE, val);
536 }
537 
538 static const int sii902x_mclk_div_table[] = {
539 	128, 256, 384, 512, 768, 1024, 1152, 192 };
540 
sii902x_select_mclk_div(u8 * i2s_config_reg,unsigned int rate,unsigned int mclk)541 static int sii902x_select_mclk_div(u8 *i2s_config_reg, unsigned int rate,
542 				   unsigned int mclk)
543 {
544 	int div = mclk / rate;
545 	int distance = 100000;
546 	u8 i, nearest = 0;
547 
548 	for (i = 0; i < ARRAY_SIZE(sii902x_mclk_div_table); i++) {
549 		unsigned int d = abs(div - sii902x_mclk_div_table[i]);
550 
551 		if (d >= distance)
552 			continue;
553 
554 		nearest = i;
555 		distance = d;
556 		if (d == 0)
557 			break;
558 	}
559 
560 	*i2s_config_reg |= nearest << 4;
561 
562 	return sii902x_mclk_div_table[nearest];
563 }
564 
565 static const struct sii902x_sample_freq {
566 	u32 freq;
567 	u8 val;
568 } sii902x_sample_freq[] = {
569 	{ .freq = 32000,	.val = SII902X_TPI_AUDIO_FREQ_32KHZ },
570 	{ .freq = 44000,	.val = SII902X_TPI_AUDIO_FREQ_44KHZ },
571 	{ .freq = 48000,	.val = SII902X_TPI_AUDIO_FREQ_48KHZ },
572 	{ .freq = 88000,	.val = SII902X_TPI_AUDIO_FREQ_88KHZ },
573 	{ .freq = 96000,	.val = SII902X_TPI_AUDIO_FREQ_96KHZ },
574 	{ .freq = 176000,	.val = SII902X_TPI_AUDIO_FREQ_176KHZ },
575 	{ .freq = 192000,	.val = SII902X_TPI_AUDIO_FREQ_192KHZ },
576 };
577 
sii902x_audio_hw_params(struct device * dev,void * data,struct hdmi_codec_daifmt * daifmt,struct hdmi_codec_params * params)578 static int sii902x_audio_hw_params(struct device *dev, void *data,
579 				   struct hdmi_codec_daifmt *daifmt,
580 				   struct hdmi_codec_params *params)
581 {
582 	struct sii902x *sii902x = dev_get_drvdata(dev);
583 	u8 i2s_config_reg = SII902X_TPI_I2S_SD_DIRECTION_MSB_FIRST;
584 	u8 config_byte2_reg = (SII902X_TPI_AUDIO_INTERFACE_I2S |
585 			       SII902X_TPI_AUDIO_MUTE_ENABLE |
586 			       SII902X_TPI_AUDIO_CODING_PCM);
587 	u8 config_byte3_reg = 0;
588 	u8 infoframe_buf[HDMI_INFOFRAME_SIZE(AUDIO)];
589 	unsigned long mclk_rate;
590 	int i, ret;
591 
592 	if (daifmt->bit_clk_provider || daifmt->frame_clk_provider) {
593 		dev_dbg(dev, "%s: I2S clock provider mode not supported\n",
594 			__func__);
595 		return -EINVAL;
596 	}
597 
598 	switch (daifmt->fmt) {
599 	case HDMI_I2S:
600 		i2s_config_reg |= SII902X_TPI_I2S_FIRST_BIT_SHIFT_YES |
601 			SII902X_TPI_I2S_SD_JUSTIFY_LEFT;
602 		break;
603 	case HDMI_RIGHT_J:
604 		i2s_config_reg |= SII902X_TPI_I2S_SD_JUSTIFY_RIGHT;
605 		break;
606 	case HDMI_LEFT_J:
607 		i2s_config_reg |= SII902X_TPI_I2S_SD_JUSTIFY_LEFT;
608 		break;
609 	default:
610 		dev_dbg(dev, "%s: Unsupported i2s format %u\n", __func__,
611 			daifmt->fmt);
612 		return -EINVAL;
613 	}
614 
615 	if (daifmt->bit_clk_inv)
616 		i2s_config_reg |= SII902X_TPI_I2S_SCK_EDGE_FALLING;
617 	else
618 		i2s_config_reg |= SII902X_TPI_I2S_SCK_EDGE_RISING;
619 
620 	if (daifmt->frame_clk_inv)
621 		i2s_config_reg |= SII902X_TPI_I2S_WS_POLARITY_LOW;
622 	else
623 		i2s_config_reg |= SII902X_TPI_I2S_WS_POLARITY_HIGH;
624 
625 	if (params->channels > 2)
626 		config_byte2_reg |= SII902X_TPI_AUDIO_LAYOUT_8_CHANNELS;
627 	else
628 		config_byte2_reg |= SII902X_TPI_AUDIO_LAYOUT_2_CHANNELS;
629 
630 	switch (params->sample_width) {
631 	case 16:
632 		config_byte3_reg |= SII902X_TPI_AUDIO_SAMPLE_SIZE_16;
633 		break;
634 	case 20:
635 		config_byte3_reg |= SII902X_TPI_AUDIO_SAMPLE_SIZE_20;
636 		break;
637 	case 24:
638 	case 32:
639 		config_byte3_reg |= SII902X_TPI_AUDIO_SAMPLE_SIZE_24;
640 		break;
641 	default:
642 		dev_err(dev, "%s: Unsupported sample width %u\n", __func__,
643 			params->sample_width);
644 		return -EINVAL;
645 	}
646 
647 	for (i = 0; i < ARRAY_SIZE(sii902x_sample_freq); i++) {
648 		if (params->sample_rate == sii902x_sample_freq[i].freq) {
649 			config_byte3_reg |= sii902x_sample_freq[i].val;
650 			break;
651 		}
652 	}
653 
654 	ret = clk_prepare_enable(sii902x->audio.mclk);
655 	if (ret) {
656 		dev_err(dev, "Enabling mclk failed: %d\n", ret);
657 		return ret;
658 	}
659 
660 	if (sii902x->audio.mclk) {
661 		mclk_rate = clk_get_rate(sii902x->audio.mclk);
662 		ret = sii902x_select_mclk_div(&i2s_config_reg,
663 					      params->sample_rate, mclk_rate);
664 		if (mclk_rate != ret * params->sample_rate)
665 			dev_dbg(dev, "Inaccurate reference clock (%ld/%d != %u)\n",
666 				mclk_rate, ret, params->sample_rate);
667 	}
668 
669 	mutex_lock(&sii902x->mutex);
670 
671 	ret = regmap_write(sii902x->regmap,
672 			   SII902X_TPI_AUDIO_CONFIG_BYTE2_REG,
673 			   config_byte2_reg);
674 	if (ret < 0)
675 		goto out;
676 
677 	ret = regmap_write(sii902x->regmap, SII902X_TPI_I2S_INPUT_CONFIG_REG,
678 			   i2s_config_reg);
679 	if (ret)
680 		goto out;
681 
682 	for (i = 0; i < ARRAY_SIZE(sii902x->audio.i2s_fifo_sequence) &&
683 		    sii902x->audio.i2s_fifo_sequence[i]; i++)
684 		regmap_write(sii902x->regmap,
685 			     SII902X_TPI_I2S_ENABLE_MAPPING_REG,
686 			     sii902x->audio.i2s_fifo_sequence[i]);
687 
688 	ret = regmap_write(sii902x->regmap, SII902X_TPI_AUDIO_CONFIG_BYTE3_REG,
689 			   config_byte3_reg);
690 	if (ret)
691 		goto out;
692 
693 	ret = regmap_bulk_write(sii902x->regmap, SII902X_TPI_I2S_STRM_HDR_BASE,
694 				params->iec.status,
695 				min((size_t) SII902X_TPI_I2S_STRM_HDR_SIZE,
696 				    sizeof(params->iec.status)));
697 	if (ret)
698 		goto out;
699 
700 	ret = hdmi_audio_infoframe_pack(&params->cea, infoframe_buf,
701 					sizeof(infoframe_buf));
702 	if (ret < 0) {
703 		dev_err(dev, "%s: Failed to pack audio infoframe: %d\n",
704 			__func__, ret);
705 		goto out;
706 	}
707 
708 	ret = regmap_bulk_write(sii902x->regmap,
709 				SII902X_TPI_MISC_INFOFRAME_BASE,
710 				infoframe_buf,
711 				min(ret, SII902X_TPI_MISC_INFOFRAME_SIZE));
712 	if (ret)
713 		goto out;
714 
715 	/* Decode Level 0 Packets */
716 	ret = regmap_write(sii902x->regmap, SII902X_IND_SET_PAGE, 0x02);
717 	if (ret)
718 		goto out;
719 
720 	ret = regmap_write(sii902x->regmap, SII902X_IND_OFFSET, 0x24);
721 	if (ret)
722 		goto out;
723 
724 	ret = regmap_write(sii902x->regmap, SII902X_IND_VALUE, 0x02);
725 	if (ret)
726 		goto out;
727 
728 	dev_dbg(dev, "%s: hdmi audio enabled\n", __func__);
729 out:
730 	mutex_unlock(&sii902x->mutex);
731 
732 	if (ret) {
733 		clk_disable_unprepare(sii902x->audio.mclk);
734 		dev_err(dev, "%s: hdmi audio enable failed: %d\n", __func__,
735 			ret);
736 	}
737 
738 	return ret;
739 }
740 
sii902x_audio_shutdown(struct device * dev,void * data)741 static void sii902x_audio_shutdown(struct device *dev, void *data)
742 {
743 	struct sii902x *sii902x = dev_get_drvdata(dev);
744 
745 	mutex_lock(&sii902x->mutex);
746 
747 	regmap_write(sii902x->regmap, SII902X_TPI_AUDIO_CONFIG_BYTE2_REG,
748 		     SII902X_TPI_AUDIO_INTERFACE_DISABLE);
749 
750 	mutex_unlock(&sii902x->mutex);
751 
752 	clk_disable_unprepare(sii902x->audio.mclk);
753 }
754 
sii902x_audio_mute(struct device * dev,void * data,bool enable,int direction)755 static int sii902x_audio_mute(struct device *dev, void *data,
756 			      bool enable, int direction)
757 {
758 	struct sii902x *sii902x = dev_get_drvdata(dev);
759 
760 	mutex_lock(&sii902x->mutex);
761 
762 	sii902x_mute(sii902x, enable);
763 
764 	mutex_unlock(&sii902x->mutex);
765 
766 	return 0;
767 }
768 
sii902x_audio_get_eld(struct device * dev,void * data,uint8_t * buf,size_t len)769 static int sii902x_audio_get_eld(struct device *dev, void *data,
770 				 uint8_t *buf, size_t len)
771 {
772 	struct sii902x *sii902x = dev_get_drvdata(dev);
773 
774 	mutex_lock(&sii902x->mutex);
775 
776 	memcpy(buf, sii902x->connector.eld,
777 	       min(sizeof(sii902x->connector.eld), len));
778 
779 	mutex_unlock(&sii902x->mutex);
780 
781 	return 0;
782 }
783 
sii902x_audio_get_dai_id(struct snd_soc_component * component,struct device_node * endpoint)784 static int sii902x_audio_get_dai_id(struct snd_soc_component *component,
785 				    struct device_node *endpoint)
786 {
787 	struct of_endpoint of_ep;
788 	int ret;
789 
790 	ret = of_graph_parse_endpoint(endpoint, &of_ep);
791 	if (ret < 0)
792 		return ret;
793 
794 	/*
795 	 * HDMI sound should be located at reg = <3>
796 	 * Return expected DAI index 0.
797 	 */
798 	if (of_ep.port == SII902X_AUDIO_PORT_INDEX)
799 		return 0;
800 
801 	return -EINVAL;
802 }
803 
804 static const struct hdmi_codec_ops sii902x_audio_codec_ops = {
805 	.hw_params = sii902x_audio_hw_params,
806 	.audio_shutdown = sii902x_audio_shutdown,
807 	.mute_stream = sii902x_audio_mute,
808 	.get_eld = sii902x_audio_get_eld,
809 	.get_dai_id = sii902x_audio_get_dai_id,
810 	.no_capture_mute = 1,
811 };
812 
sii902x_audio_codec_init(struct sii902x * sii902x,struct device * dev)813 static int sii902x_audio_codec_init(struct sii902x *sii902x,
814 				    struct device *dev)
815 {
816 	static const u8 audio_fifo_id[] = {
817 		SII902X_TPI_I2S_CONFIG_FIFO0,
818 		SII902X_TPI_I2S_CONFIG_FIFO1,
819 		SII902X_TPI_I2S_CONFIG_FIFO2,
820 		SII902X_TPI_I2S_CONFIG_FIFO3,
821 	};
822 	static const u8 i2s_lane_id[] = {
823 		SII902X_TPI_I2S_SELECT_SD0,
824 		SII902X_TPI_I2S_SELECT_SD1,
825 		SII902X_TPI_I2S_SELECT_SD2,
826 		SII902X_TPI_I2S_SELECT_SD3,
827 	};
828 	struct hdmi_codec_pdata codec_data = {
829 		.ops = &sii902x_audio_codec_ops,
830 		.i2s = 1, /* Only i2s support for now. */
831 		.spdif = 0,
832 		.max_i2s_channels = 0,
833 	};
834 	u8 lanes[4];
835 	int num_lanes, i;
836 
837 	if (!of_property_read_bool(dev->of_node, "#sound-dai-cells")) {
838 		dev_dbg(dev, "%s: No \"#sound-dai-cells\", no audio\n",
839 			__func__);
840 		return 0;
841 	}
842 
843 	num_lanes = of_property_read_variable_u8_array(dev->of_node,
844 						       "sil,i2s-data-lanes",
845 						       lanes, 1,
846 						       ARRAY_SIZE(lanes));
847 
848 	if (num_lanes == -EINVAL) {
849 		dev_dbg(dev,
850 			"%s: No \"sil,i2s-data-lanes\", use default <0>\n",
851 			__func__);
852 		num_lanes = 1;
853 		lanes[0] = 0;
854 	} else if (num_lanes < 0) {
855 		dev_err(dev,
856 			"%s: Error gettin \"sil,i2s-data-lanes\": %d\n",
857 			__func__, num_lanes);
858 		return num_lanes;
859 	}
860 	codec_data.max_i2s_channels = 2 * num_lanes;
861 
862 	for (i = 0; i < num_lanes; i++)
863 		sii902x->audio.i2s_fifo_sequence[i] |= audio_fifo_id[i] |
864 			i2s_lane_id[lanes[i]] |	SII902X_TPI_I2S_FIFO_ENABLE;
865 
866 	sii902x->audio.mclk = devm_clk_get_optional(dev, "mclk");
867 	if (IS_ERR(sii902x->audio.mclk)) {
868 		dev_err(dev, "%s: No clock (audio mclk) found: %ld\n",
869 			__func__, PTR_ERR(sii902x->audio.mclk));
870 		return PTR_ERR(sii902x->audio.mclk);
871 	}
872 
873 	sii902x->audio.pdev = platform_device_register_data(
874 		dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO,
875 		&codec_data, sizeof(codec_data));
876 
877 	return PTR_ERR_OR_ZERO(sii902x->audio.pdev);
878 }
879 
880 static const struct regmap_range sii902x_volatile_ranges[] = {
881 	{ .range_min = 0, .range_max = 0xff },
882 };
883 
884 static const struct regmap_access_table sii902x_volatile_table = {
885 	.yes_ranges = sii902x_volatile_ranges,
886 	.n_yes_ranges = ARRAY_SIZE(sii902x_volatile_ranges),
887 };
888 
889 static const struct regmap_config sii902x_regmap_config = {
890 	.reg_bits = 8,
891 	.val_bits = 8,
892 	.disable_locking = true, /* struct sii902x mutex should be enough */
893 	.max_register = SII902X_TPI_MISC_INFOFRAME_END,
894 	.volatile_table = &sii902x_volatile_table,
895 	.cache_type = REGCACHE_NONE,
896 };
897 
sii902x_interrupt(int irq,void * data)898 static irqreturn_t sii902x_interrupt(int irq, void *data)
899 {
900 	struct sii902x *sii902x = data;
901 	unsigned int status = 0;
902 
903 	mutex_lock(&sii902x->mutex);
904 
905 	regmap_read(sii902x->regmap, SII902X_INT_STATUS, &status);
906 	regmap_write(sii902x->regmap, SII902X_INT_STATUS, status);
907 
908 	mutex_unlock(&sii902x->mutex);
909 
910 	if ((status & SII902X_HOTPLUG_EVENT) && sii902x->bridge.dev) {
911 		drm_helper_hpd_irq_event(sii902x->bridge.dev);
912 		drm_bridge_hpd_notify(&sii902x->bridge, (status & SII902X_PLUGGED_STATUS)
913 								? connector_status_connected
914 								: connector_status_disconnected);
915 	}
916 
917 	return IRQ_HANDLED;
918 }
919 
920 /*
921  * The purpose of sii902x_i2c_bypass_select is to enable the pass through
922  * mode of the HDMI transmitter. Do not use regmap from within this function,
923  * only use sii902x_*_unlocked functions to read/modify/write registers.
924  * We are holding the parent adapter lock here, keep this in mind before
925  * adding more i2c transactions.
926  *
927  * Also, since SII902X_SYS_CTRL_DATA is used with regmap_update_bits elsewhere
928  * in this driver, we need to make sure that we only touch 0x1A[2:1] from
929  * within sii902x_i2c_bypass_select and sii902x_i2c_bypass_deselect, and that
930  * we leave the remaining bits as we have found them.
931  */
sii902x_i2c_bypass_select(struct i2c_mux_core * mux,u32 chan_id)932 static int sii902x_i2c_bypass_select(struct i2c_mux_core *mux, u32 chan_id)
933 {
934 	struct sii902x *sii902x = i2c_mux_priv(mux);
935 	struct device *dev = &sii902x->i2c->dev;
936 	unsigned long timeout;
937 	u8 status;
938 	int ret;
939 
940 	ret = sii902x_update_bits_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA,
941 					   SII902X_SYS_CTRL_DDC_BUS_REQ,
942 					   SII902X_SYS_CTRL_DDC_BUS_REQ);
943 	if (ret)
944 		return ret;
945 
946 	timeout = jiffies +
947 		  msecs_to_jiffies(SII902X_I2C_BUS_ACQUISITION_TIMEOUT_MS);
948 	do {
949 		ret = sii902x_read_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA,
950 					    &status);
951 		if (ret)
952 			return ret;
953 	} while (!(status & SII902X_SYS_CTRL_DDC_BUS_GRTD) &&
954 		 time_before(jiffies, timeout));
955 
956 	if (!(status & SII902X_SYS_CTRL_DDC_BUS_GRTD)) {
957 		dev_err(dev, "Failed to acquire the i2c bus\n");
958 		return -ETIMEDOUT;
959 	}
960 
961 	return sii902x_write_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA,
962 				      status);
963 }
964 
965 /*
966  * The purpose of sii902x_i2c_bypass_deselect is to disable the pass through
967  * mode of the HDMI transmitter. Do not use regmap from within this function,
968  * only use sii902x_*_unlocked functions to read/modify/write registers.
969  * We are holding the parent adapter lock here, keep this in mind before
970  * adding more i2c transactions.
971  *
972  * Also, since SII902X_SYS_CTRL_DATA is used with regmap_update_bits elsewhere
973  * in this driver, we need to make sure that we only touch 0x1A[2:1] from
974  * within sii902x_i2c_bypass_select and sii902x_i2c_bypass_deselect, and that
975  * we leave the remaining bits as we have found them.
976  */
sii902x_i2c_bypass_deselect(struct i2c_mux_core * mux,u32 chan_id)977 static int sii902x_i2c_bypass_deselect(struct i2c_mux_core *mux, u32 chan_id)
978 {
979 	struct sii902x *sii902x = i2c_mux_priv(mux);
980 	struct device *dev = &sii902x->i2c->dev;
981 	unsigned long timeout;
982 	unsigned int retries;
983 	u8 status;
984 	int ret;
985 
986 	/*
987 	 * When the HDMI transmitter is in pass through mode, we need an
988 	 * (undocumented) additional delay between STOP and START conditions
989 	 * to guarantee the bus won't get stuck.
990 	 */
991 	udelay(30);
992 
993 	/*
994 	 * Sometimes the I2C bus can stall after failure to use the
995 	 * EDID channel. Retry a few times to see if things clear
996 	 * up, else continue anyway.
997 	 */
998 	retries = 5;
999 	do {
1000 		ret = sii902x_read_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA,
1001 					    &status);
1002 		retries--;
1003 	} while (ret && retries);
1004 	if (ret) {
1005 		dev_err(dev, "failed to read status (%d)\n", ret);
1006 		return ret;
1007 	}
1008 
1009 	ret = sii902x_update_bits_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA,
1010 					   SII902X_SYS_CTRL_DDC_BUS_REQ |
1011 					   SII902X_SYS_CTRL_DDC_BUS_GRTD, 0);
1012 	if (ret)
1013 		return ret;
1014 
1015 	timeout = jiffies +
1016 		  msecs_to_jiffies(SII902X_I2C_BUS_ACQUISITION_TIMEOUT_MS);
1017 	do {
1018 		ret = sii902x_read_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA,
1019 					    &status);
1020 		if (ret)
1021 			return ret;
1022 	} while (status & (SII902X_SYS_CTRL_DDC_BUS_REQ |
1023 			   SII902X_SYS_CTRL_DDC_BUS_GRTD) &&
1024 		 time_before(jiffies, timeout));
1025 
1026 	if (status & (SII902X_SYS_CTRL_DDC_BUS_REQ |
1027 		      SII902X_SYS_CTRL_DDC_BUS_GRTD)) {
1028 		dev_err(dev, "failed to release the i2c bus\n");
1029 		return -ETIMEDOUT;
1030 	}
1031 
1032 	return 0;
1033 }
1034 
1035 static const struct drm_bridge_timings default_sii902x_timings = {
1036 	.input_bus_flags = DRM_BUS_FLAG_PIXDATA_SAMPLE_NEGEDGE
1037 		 | DRM_BUS_FLAG_SYNC_SAMPLE_NEGEDGE
1038 		 | DRM_BUS_FLAG_DE_HIGH,
1039 };
1040 
sii902x_init(struct sii902x * sii902x)1041 static int sii902x_init(struct sii902x *sii902x)
1042 {
1043 	struct device *dev = &sii902x->i2c->dev;
1044 	unsigned int status = 0;
1045 	u8 chipid[4];
1046 	int ret;
1047 
1048 	sii902x_reset(sii902x);
1049 
1050 	ret = regmap_write(sii902x->regmap, SII902X_REG_TPI_RQB, 0x0);
1051 	if (ret)
1052 		return ret;
1053 
1054 	ret = regmap_bulk_read(sii902x->regmap, SII902X_REG_CHIPID(0),
1055 			       &chipid, 4);
1056 	if (ret) {
1057 		dev_err(dev, "regmap_read failed %d\n", ret);
1058 		return ret;
1059 	}
1060 
1061 	if (chipid[0] != 0xb0) {
1062 		dev_err(dev, "Invalid chipid: %02x (expecting 0xb0)\n",
1063 			chipid[0]);
1064 		return -EINVAL;
1065 	}
1066 
1067 	/* Clear all pending interrupts */
1068 	regmap_read(sii902x->regmap, SII902X_INT_STATUS, &status);
1069 	regmap_write(sii902x->regmap, SII902X_INT_STATUS, status);
1070 
1071 	if (sii902x->i2c->irq > 0) {
1072 		regmap_write(sii902x->regmap, SII902X_INT_ENABLE,
1073 			     SII902X_HOTPLUG_EVENT);
1074 
1075 		ret = devm_request_threaded_irq(dev, sii902x->i2c->irq, NULL,
1076 						sii902x_interrupt,
1077 						IRQF_ONESHOT, dev_name(dev),
1078 						sii902x);
1079 		if (ret)
1080 			return ret;
1081 	}
1082 
1083 	ret = sii902x_audio_codec_init(sii902x, dev);
1084 	if (ret)
1085 		return ret;
1086 
1087 	i2c_set_clientdata(sii902x->i2c, sii902x);
1088 
1089 	sii902x->i2cmux = i2c_mux_alloc(sii902x->i2c->adapter, dev,
1090 					1, 0, I2C_MUX_GATE,
1091 					sii902x_i2c_bypass_select,
1092 					sii902x_i2c_bypass_deselect);
1093 	if (!sii902x->i2cmux) {
1094 		ret = -ENOMEM;
1095 		goto err_unreg_audio;
1096 	}
1097 
1098 	sii902x->i2cmux->priv = sii902x;
1099 	ret = i2c_mux_add_adapter(sii902x->i2cmux, 0, 0, 0);
1100 	if (ret)
1101 		goto err_unreg_audio;
1102 
1103 	sii902x->bridge.funcs = &sii902x_bridge_funcs;
1104 	sii902x->bridge.of_node = dev->of_node;
1105 	sii902x->bridge.timings = &default_sii902x_timings;
1106 	sii902x->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID;
1107 
1108 	if (sii902x->i2c->irq > 0)
1109 		sii902x->bridge.ops |= DRM_BRIDGE_OP_HPD;
1110 
1111 	drm_bridge_add(&sii902x->bridge);
1112 
1113 	return 0;
1114 
1115 err_unreg_audio:
1116 	if (!PTR_ERR_OR_ZERO(sii902x->audio.pdev))
1117 		platform_device_unregister(sii902x->audio.pdev);
1118 
1119 	return ret;
1120 }
1121 
sii902x_probe(struct i2c_client * client)1122 static int sii902x_probe(struct i2c_client *client)
1123 {
1124 	struct device *dev = &client->dev;
1125 	struct device_node *endpoint;
1126 	struct sii902x *sii902x;
1127 	static const char * const supplies[] = {"iovcc", "cvcc12"};
1128 	int ret;
1129 
1130 	ret = i2c_check_functionality(client->adapter,
1131 				      I2C_FUNC_SMBUS_BYTE_DATA);
1132 	if (!ret) {
1133 		dev_err(dev, "I2C adapter not suitable\n");
1134 		return -EIO;
1135 	}
1136 
1137 	sii902x = devm_kzalloc(dev, sizeof(*sii902x), GFP_KERNEL);
1138 	if (!sii902x)
1139 		return -ENOMEM;
1140 
1141 	sii902x->i2c = client;
1142 	sii902x->regmap = devm_regmap_init_i2c(client, &sii902x_regmap_config);
1143 	if (IS_ERR(sii902x->regmap))
1144 		return PTR_ERR(sii902x->regmap);
1145 
1146 	sii902x->reset_gpio = devm_gpiod_get_optional(dev, "reset",
1147 						      GPIOD_OUT_LOW);
1148 	if (IS_ERR(sii902x->reset_gpio)) {
1149 		dev_err(dev, "Failed to retrieve/request reset gpio: %ld\n",
1150 			PTR_ERR(sii902x->reset_gpio));
1151 		return PTR_ERR(sii902x->reset_gpio);
1152 	}
1153 
1154 	endpoint = of_graph_get_endpoint_by_regs(dev->of_node, 1, -1);
1155 	if (endpoint) {
1156 		struct device_node *remote = of_graph_get_remote_port_parent(endpoint);
1157 
1158 		of_node_put(endpoint);
1159 		if (!remote) {
1160 			dev_err(dev, "Endpoint in port@1 unconnected\n");
1161 			return -ENODEV;
1162 		}
1163 
1164 		if (!of_device_is_available(remote)) {
1165 			dev_err(dev, "port@1 remote device is disabled\n");
1166 			of_node_put(remote);
1167 			return -ENODEV;
1168 		}
1169 
1170 		sii902x->next_bridge = of_drm_find_bridge(remote);
1171 		of_node_put(remote);
1172 		if (!sii902x->next_bridge)
1173 			return dev_err_probe(dev, -EPROBE_DEFER,
1174 					     "Failed to find remote bridge\n");
1175 	}
1176 
1177 	mutex_init(&sii902x->mutex);
1178 
1179 	ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(supplies), supplies);
1180 	if (ret < 0)
1181 		return dev_err_probe(dev, ret, "Failed to enable supplies");
1182 
1183 	return sii902x_init(sii902x);
1184 }
1185 
sii902x_remove(struct i2c_client * client)1186 static void sii902x_remove(struct i2c_client *client)
1187 {
1188 	struct sii902x *sii902x = i2c_get_clientdata(client);
1189 
1190 	drm_bridge_remove(&sii902x->bridge);
1191 	i2c_mux_del_adapters(sii902x->i2cmux);
1192 
1193 	if (!PTR_ERR_OR_ZERO(sii902x->audio.pdev))
1194 		platform_device_unregister(sii902x->audio.pdev);
1195 }
1196 
1197 static const struct of_device_id sii902x_dt_ids[] = {
1198 	{ .compatible = "sil,sii9022", },
1199 	{ }
1200 };
1201 MODULE_DEVICE_TABLE(of, sii902x_dt_ids);
1202 
1203 static const struct i2c_device_id sii902x_i2c_ids[] = {
1204 	{ "sii9022", 0 },
1205 	{ },
1206 };
1207 MODULE_DEVICE_TABLE(i2c, sii902x_i2c_ids);
1208 
1209 static struct i2c_driver sii902x_driver = {
1210 	.probe = sii902x_probe,
1211 	.remove = sii902x_remove,
1212 	.driver = {
1213 		.name = "sii902x",
1214 		.of_match_table = sii902x_dt_ids,
1215 	},
1216 	.id_table = sii902x_i2c_ids,
1217 };
1218 module_i2c_driver(sii902x_driver);
1219 
1220 MODULE_AUTHOR("Boris Brezillon <boris.brezillon@free-electrons.com>");
1221 MODULE_DESCRIPTION("SII902x RGB -> HDMI bridges");
1222 MODULE_LICENSE("GPL");
1223