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 (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 | |
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(adapter: i2c->adapter, addr: i2c->addr, flags: i2c->flags, |
193 | I2C_SMBUS_READ, command: reg, I2C_SMBUS_BYTE_DATA, data: &data); |
194 | |
195 | if (ret < 0) |
196 | return ret; |
197 | |
198 | *val = data.byte; |
199 | return 0; |
200 | } |
201 | |
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(adapter: i2c->adapter, addr: i2c->addr, flags: i2c->flags, |
209 | I2C_SMBUS_WRITE, command: reg, I2C_SMBUS_BYTE_DATA, |
210 | data: &data); |
211 | } |
212 | |
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, val: &status); |
220 | if (ret) |
221 | return ret; |
222 | status &= ~mask; |
223 | status |= val & mask; |
224 | return sii902x_write_unlocked(i2c, reg, val: status); |
225 | } |
226 | |
227 | static inline struct sii902x *bridge_to_sii902x(struct drm_bridge *bridge) |
228 | { |
229 | return container_of(bridge, struct sii902x, bridge); |
230 | } |
231 | |
232 | static inline struct sii902x *connector_to_sii902x(struct drm_connector *con) |
233 | { |
234 | return container_of(con, struct sii902x, connector); |
235 | } |
236 | |
237 | static void sii902x_reset(struct sii902x *sii902x) |
238 | { |
239 | if (!sii902x->reset_gpio) |
240 | return; |
241 | |
242 | gpiod_set_value_cansleep(desc: sii902x->reset_gpio, value: 1); |
243 | |
244 | /* The datasheet says treset-min = 100us. Make it 150us to be sure. */ |
245 | usleep_range(min: 150, max: 200); |
246 | |
247 | gpiod_set_value_cansleep(desc: sii902x->reset_gpio, value: 0); |
248 | } |
249 | |
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(map: sii902x->regmap, SII902X_INT_STATUS, val: &status); |
257 | |
258 | mutex_unlock(lock: &sii902x->mutex); |
259 | |
260 | return (status & SII902X_PLUGGED_STATUS) ? |
261 | connector_status_connected : connector_status_disconnected; |
262 | } |
263 | |
264 | static enum drm_connector_status |
265 | sii902x_connector_detect(struct drm_connector *connector, bool force) |
266 | { |
267 | struct sii902x *sii902x = connector_to_sii902x(con: 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 | |
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, adapter: 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(lock: &sii902x->mutex); |
297 | |
298 | return edid; |
299 | } |
300 | |
301 | static int sii902x_get_modes(struct drm_connector *connector) |
302 | { |
303 | struct sii902x *sii902x = connector_to_sii902x(con: 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(objp: edid); |
312 | } |
313 | |
314 | return num; |
315 | } |
316 | |
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 | |
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(map: sii902x->regmap, SII902X_SYS_CTRL_DATA, |
337 | SII902X_SYS_CTRL_PWR_DWN, |
338 | SII902X_SYS_CTRL_PWR_DWN); |
339 | |
340 | mutex_unlock(lock: &sii902x->mutex); |
341 | } |
342 | |
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(map: sii902x->regmap, SII902X_PWR_STATE_CTRL, |
350 | SII902X_AVI_POWER_STATE_MSK, |
351 | SII902X_AVI_POWER_STATE_D(0)); |
352 | regmap_update_bits(map: sii902x->regmap, SII902X_SYS_CTRL_DATA, |
353 | SII902X_SYS_CTRL_PWR_DWN, val: 0); |
354 | |
355 | mutex_unlock(lock: &sii902x->mutex); |
356 | } |
357 | |
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(mode: 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(map: sii902x->regmap, SII902X_SYS_CTRL_DATA, |
389 | SII902X_SYS_CTRL_OUTPUT_MODE, val: output_mode); |
390 | if (ret) |
391 | goto out; |
392 | |
393 | ret = regmap_bulk_write(map: regmap, SII902X_TPI_VIDEO_DATA, val: buf, val_count: 10); |
394 | if (ret) |
395 | goto out; |
396 | |
397 | ret = drm_hdmi_avi_infoframe_from_display_mode(frame: &frame, |
398 | connector: &sii902x->connector, mode: 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: &frame, buffer: buf, size: 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(map: regmap, SII902X_TPI_AVI_INFOFRAME, |
412 | val: buf + HDMI_INFOFRAME_HEADER_SIZE - 1, |
413 | HDMI_AVI_INFOFRAME_SIZE + 1); |
414 | |
415 | out: |
416 | mutex_unlock(lock: &sii902x->mutex); |
417 | } |
418 | |
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(encoder: bridge->encoder, bridge: sii902x->next_bridge, |
429 | previous: bridge, flags); |
430 | |
431 | drm_connector_helper_add(connector: &sii902x->connector, |
432 | funcs: &sii902x_connector_helper_funcs); |
433 | |
434 | if (!drm_core_check_feature(dev: drm, feature: 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(dev: drm, connector: &sii902x->connector, |
441 | funcs: &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(info: &sii902x->connector.display_info, |
452 | formats: &bus_format, num_formats: 1); |
453 | if (ret) |
454 | return ret; |
455 | |
456 | drm_connector_attach_encoder(connector: &sii902x->connector, encoder: bridge->encoder); |
457 | |
458 | return 0; |
459 | } |
460 | |
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 | |
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 | |
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(n: 1, size: 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 | |
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 | |
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(map: 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 | |
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 | |
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(clk: 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(clk: sii902x->audio.mclk); |
662 | ret = sii902x_select_mclk_div(i2s_config_reg: &i2s_config_reg, |
663 | rate: params->sample_rate, mclk: 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(map: sii902x->regmap, |
672 | SII902X_TPI_AUDIO_CONFIG_BYTE2_REG, |
673 | val: config_byte2_reg); |
674 | if (ret < 0) |
675 | goto out; |
676 | |
677 | ret = regmap_write(map: sii902x->regmap, SII902X_TPI_I2S_INPUT_CONFIG_REG, |
678 | val: 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(map: sii902x->regmap, |
685 | SII902X_TPI_I2S_ENABLE_MAPPING_REG, |
686 | val: sii902x->audio.i2s_fifo_sequence[i]); |
687 | |
688 | ret = regmap_write(map: sii902x->regmap, SII902X_TPI_AUDIO_CONFIG_BYTE3_REG, |
689 | val: config_byte3_reg); |
690 | if (ret) |
691 | goto out; |
692 | |
693 | ret = regmap_bulk_write(map: sii902x->regmap, SII902X_TPI_I2S_STRM_HDR_BASE, |
694 | val: 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(frame: ¶ms->cea, buffer: infoframe_buf, |
701 | size: 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(map: sii902x->regmap, |
709 | SII902X_TPI_MISC_INFOFRAME_BASE, |
710 | val: 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(map: sii902x->regmap, SII902X_IND_SET_PAGE, val: 0x02); |
717 | if (ret) |
718 | goto out; |
719 | |
720 | ret = regmap_write(map: sii902x->regmap, SII902X_IND_OFFSET, val: 0x24); |
721 | if (ret) |
722 | goto out; |
723 | |
724 | ret = regmap_write(map: sii902x->regmap, SII902X_IND_VALUE, val: 0x02); |
725 | if (ret) |
726 | goto out; |
727 | |
728 | dev_dbg(dev, "%s: hdmi audio enabled\n" , __func__); |
729 | out: |
730 | mutex_unlock(lock: &sii902x->mutex); |
731 | |
732 | if (ret) { |
733 | clk_disable_unprepare(clk: sii902x->audio.mclk); |
734 | dev_err(dev, "%s: hdmi audio enable failed: %d\n" , __func__, |
735 | ret); |
736 | } |
737 | |
738 | return ret; |
739 | } |
740 | |
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(map: sii902x->regmap, SII902X_TPI_AUDIO_CONFIG_BYTE2_REG, |
748 | SII902X_TPI_AUDIO_INTERFACE_DISABLE); |
749 | |
750 | mutex_unlock(lock: &sii902x->mutex); |
751 | |
752 | clk_disable_unprepare(clk: sii902x->audio.mclk); |
753 | } |
754 | |
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, mute: enable); |
763 | |
764 | mutex_unlock(lock: &sii902x->mutex); |
765 | |
766 | return 0; |
767 | } |
768 | |
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(lock: &sii902x->mutex); |
780 | |
781 | return 0; |
782 | } |
783 | |
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(node: 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 | |
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(np: dev->of_node, propname: "#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(np: dev->of_node, |
844 | propname: "sil,i2s-data-lanes" , |
845 | out_values: lanes, sz_min: 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, id: "mclk" ); |
867 | if (IS_ERR(ptr: 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(ptr: sii902x->audio.mclk); |
871 | } |
872 | |
873 | sii902x->audio.pdev = platform_device_register_data( |
874 | parent: dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO, |
875 | data: &codec_data, size: sizeof(codec_data)); |
876 | |
877 | return PTR_ERR_OR_ZERO(ptr: 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 | |
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(map: sii902x->regmap, SII902X_INT_STATUS, val: &status); |
906 | regmap_write(map: sii902x->regmap, SII902X_INT_STATUS, val: status); |
907 | |
908 | mutex_unlock(lock: &sii902x->mutex); |
909 | |
910 | if ((status & SII902X_HOTPLUG_EVENT) && sii902x->bridge.dev) { |
911 | drm_helper_hpd_irq_event(dev: sii902x->bridge.dev); |
912 | drm_bridge_hpd_notify(bridge: &sii902x->bridge, status: (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 | */ |
932 | static int sii902x_i2c_bypass_select(struct i2c_mux_core *mux, u32 chan_id) |
933 | { |
934 | struct sii902x *sii902x = i2c_mux_priv(muxc: 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(i2c: 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(i2c: sii902x->i2c, SII902X_SYS_CTRL_DATA, |
950 | val: &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(i2c: sii902x->i2c, SII902X_SYS_CTRL_DATA, |
962 | val: 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 | */ |
977 | static int sii902x_i2c_bypass_deselect(struct i2c_mux_core *mux, u32 chan_id) |
978 | { |
979 | struct sii902x *sii902x = i2c_mux_priv(muxc: 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(i2c: sii902x->i2c, SII902X_SYS_CTRL_DATA, |
1001 | val: &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(i2c: sii902x->i2c, SII902X_SYS_CTRL_DATA, |
1010 | SII902X_SYS_CTRL_DDC_BUS_REQ | |
1011 | SII902X_SYS_CTRL_DDC_BUS_GRTD, val: 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(i2c: sii902x->i2c, SII902X_SYS_CTRL_DATA, |
1019 | val: &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 | |
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(map: sii902x->regmap, SII902X_REG_TPI_RQB, val: 0x0); |
1051 | if (ret) |
1052 | return ret; |
1053 | |
1054 | ret = regmap_bulk_read(map: sii902x->regmap, SII902X_REG_CHIPID(0), |
1055 | val: &chipid, val_count: 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(map: sii902x->regmap, SII902X_INT_STATUS, val: &status); |
1069 | regmap_write(map: sii902x->regmap, SII902X_INT_STATUS, val: status); |
1070 | |
1071 | if (sii902x->i2c->irq > 0) { |
1072 | regmap_write(map: sii902x->regmap, SII902X_INT_ENABLE, |
1073 | SII902X_HOTPLUG_EVENT); |
1074 | |
1075 | ret = devm_request_threaded_irq(dev, irq: sii902x->i2c->irq, NULL, |
1076 | thread_fn: sii902x_interrupt, |
1077 | IRQF_ONESHOT, devname: dev_name(dev), |
1078 | dev_id: sii902x); |
1079 | if (ret) |
1080 | return ret; |
1081 | } |
1082 | |
1083 | sii902x->bridge.funcs = &sii902x_bridge_funcs; |
1084 | sii902x->bridge.of_node = dev->of_node; |
1085 | sii902x->bridge.timings = &default_sii902x_timings; |
1086 | sii902x->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID; |
1087 | |
1088 | if (sii902x->i2c->irq > 0) |
1089 | sii902x->bridge.ops |= DRM_BRIDGE_OP_HPD; |
1090 | |
1091 | drm_bridge_add(bridge: &sii902x->bridge); |
1092 | |
1093 | sii902x_audio_codec_init(sii902x, dev); |
1094 | |
1095 | i2c_set_clientdata(client: sii902x->i2c, data: sii902x); |
1096 | |
1097 | sii902x->i2cmux = i2c_mux_alloc(parent: sii902x->i2c->adapter, dev, |
1098 | max_adapters: 1, sizeof_priv: 0, I2C_MUX_GATE, |
1099 | select: sii902x_i2c_bypass_select, |
1100 | deselect: sii902x_i2c_bypass_deselect); |
1101 | if (!sii902x->i2cmux) |
1102 | return -ENOMEM; |
1103 | |
1104 | sii902x->i2cmux->priv = sii902x; |
1105 | return i2c_mux_add_adapter(muxc: sii902x->i2cmux, force_nr: 0, chan_id: 0, class: 0); |
1106 | } |
1107 | |
1108 | static int sii902x_probe(struct i2c_client *client) |
1109 | { |
1110 | struct device *dev = &client->dev; |
1111 | struct device_node *endpoint; |
1112 | struct sii902x *sii902x; |
1113 | static const char * const supplies[] = {"iovcc" , "cvcc12" }; |
1114 | int ret; |
1115 | |
1116 | ret = i2c_check_functionality(adap: client->adapter, |
1117 | I2C_FUNC_SMBUS_BYTE_DATA); |
1118 | if (!ret) { |
1119 | dev_err(dev, "I2C adapter not suitable\n" ); |
1120 | return -EIO; |
1121 | } |
1122 | |
1123 | sii902x = devm_kzalloc(dev, size: sizeof(*sii902x), GFP_KERNEL); |
1124 | if (!sii902x) |
1125 | return -ENOMEM; |
1126 | |
1127 | sii902x->i2c = client; |
1128 | sii902x->regmap = devm_regmap_init_i2c(client, &sii902x_regmap_config); |
1129 | if (IS_ERR(ptr: sii902x->regmap)) |
1130 | return PTR_ERR(ptr: sii902x->regmap); |
1131 | |
1132 | sii902x->reset_gpio = devm_gpiod_get_optional(dev, con_id: "reset" , |
1133 | flags: GPIOD_OUT_LOW); |
1134 | if (IS_ERR(ptr: sii902x->reset_gpio)) { |
1135 | dev_err(dev, "Failed to retrieve/request reset gpio: %ld\n" , |
1136 | PTR_ERR(sii902x->reset_gpio)); |
1137 | return PTR_ERR(ptr: sii902x->reset_gpio); |
1138 | } |
1139 | |
1140 | endpoint = of_graph_get_endpoint_by_regs(parent: dev->of_node, port_reg: 1, reg: -1); |
1141 | if (endpoint) { |
1142 | struct device_node *remote = of_graph_get_remote_port_parent(node: endpoint); |
1143 | |
1144 | of_node_put(node: endpoint); |
1145 | if (!remote) { |
1146 | dev_err(dev, "Endpoint in port@1 unconnected\n" ); |
1147 | return -ENODEV; |
1148 | } |
1149 | |
1150 | if (!of_device_is_available(device: remote)) { |
1151 | dev_err(dev, "port@1 remote device is disabled\n" ); |
1152 | of_node_put(node: remote); |
1153 | return -ENODEV; |
1154 | } |
1155 | |
1156 | sii902x->next_bridge = of_drm_find_bridge(np: remote); |
1157 | of_node_put(node: remote); |
1158 | if (!sii902x->next_bridge) |
1159 | return dev_err_probe(dev, err: -EPROBE_DEFER, |
1160 | fmt: "Failed to find remote bridge\n" ); |
1161 | } |
1162 | |
1163 | mutex_init(&sii902x->mutex); |
1164 | |
1165 | ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(supplies), id: supplies); |
1166 | if (ret < 0) |
1167 | return dev_err_probe(dev, err: ret, fmt: "Failed to enable supplies" ); |
1168 | |
1169 | return sii902x_init(sii902x); |
1170 | } |
1171 | |
1172 | static void sii902x_remove(struct i2c_client *client) |
1173 | |
1174 | { |
1175 | struct sii902x *sii902x = i2c_get_clientdata(client); |
1176 | |
1177 | i2c_mux_del_adapters(muxc: sii902x->i2cmux); |
1178 | drm_bridge_remove(bridge: &sii902x->bridge); |
1179 | } |
1180 | |
1181 | static const struct of_device_id sii902x_dt_ids[] = { |
1182 | { .compatible = "sil,sii9022" , }, |
1183 | { } |
1184 | }; |
1185 | MODULE_DEVICE_TABLE(of, sii902x_dt_ids); |
1186 | |
1187 | static const struct i2c_device_id sii902x_i2c_ids[] = { |
1188 | { "sii9022" , 0 }, |
1189 | { }, |
1190 | }; |
1191 | MODULE_DEVICE_TABLE(i2c, sii902x_i2c_ids); |
1192 | |
1193 | static struct i2c_driver sii902x_driver = { |
1194 | .probe = sii902x_probe, |
1195 | .remove = sii902x_remove, |
1196 | .driver = { |
1197 | .name = "sii902x" , |
1198 | .of_match_table = sii902x_dt_ids, |
1199 | }, |
1200 | .id_table = sii902x_i2c_ids, |
1201 | }; |
1202 | module_i2c_driver(sii902x_driver); |
1203 | |
1204 | MODULE_AUTHOR("Boris Brezillon <boris.brezillon@free-electrons.com>" ); |
1205 | MODULE_DESCRIPTION("SII902x RGB -> HDMI bridges" ); |
1206 | MODULE_LICENSE("GPL" ); |
1207 | |