1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Analog Devices ADV7511 HDMI Transmitter Device Driver
4 *
5 * Copyright 2013 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
6 */
7
8 /*
9 * This file is named adv7511-v4l2.c so it doesn't conflict with the Analog
10 * Device ADV7511 (config fragment CONFIG_DRM_I2C_ADV7511).
11 */
12
13
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/i2c.h>
18 #include <linux/delay.h>
19 #include <linux/videodev2.h>
20 #include <linux/gpio.h>
21 #include <linux/workqueue.h>
22 #include <linux/hdmi.h>
23 #include <linux/v4l2-dv-timings.h>
24 #include <media/v4l2-device.h>
25 #include <media/v4l2-common.h>
26 #include <media/v4l2-ctrls.h>
27 #include <media/v4l2-dv-timings.h>
28 #include <media/i2c/adv7511.h>
29 #include <media/cec.h>
30
31 static int debug;
32 module_param(debug, int, 0644);
33 MODULE_PARM_DESC(debug, "debug level (0-2)");
34
35 MODULE_DESCRIPTION("Analog Devices ADV7511 HDMI Transmitter Device Driver");
36 MODULE_AUTHOR("Hans Verkuil");
37 MODULE_LICENSE("GPL v2");
38
39 #define MASK_ADV7511_EDID_RDY_INT 0x04
40 #define MASK_ADV7511_MSEN_INT 0x40
41 #define MASK_ADV7511_HPD_INT 0x80
42
43 #define MASK_ADV7511_HPD_DETECT 0x40
44 #define MASK_ADV7511_MSEN_DETECT 0x20
45 #define MASK_ADV7511_EDID_RDY 0x10
46
47 #define EDID_MAX_RETRIES (8)
48 #define EDID_DELAY 250
49 #define EDID_MAX_SEGM 8
50
51 #define ADV7511_MAX_WIDTH 1920
52 #define ADV7511_MAX_HEIGHT 1200
53 #define ADV7511_MIN_PIXELCLOCK 20000000
54 #define ADV7511_MAX_PIXELCLOCK 225000000
55
56 #define ADV7511_MAX_ADDRS (3)
57
58 /*
59 **********************************************************************
60 *
61 * Arrays with configuration parameters for the ADV7511
62 *
63 **********************************************************************
64 */
65
66 struct i2c_reg_value {
67 unsigned char reg;
68 unsigned char value;
69 };
70
71 struct adv7511_state_edid {
72 /* total number of blocks */
73 u32 blocks;
74 /* Number of segments read */
75 u32 segments;
76 u8 data[EDID_MAX_SEGM * 256];
77 /* Number of EDID read retries left */
78 unsigned read_retries;
79 bool complete;
80 };
81
82 struct adv7511_state {
83 struct adv7511_platform_data pdata;
84 struct v4l2_subdev sd;
85 struct media_pad pad;
86 struct v4l2_ctrl_handler hdl;
87 int chip_revision;
88 u8 i2c_edid_addr;
89 u8 i2c_pktmem_addr;
90 u8 i2c_cec_addr;
91
92 struct i2c_client *i2c_cec;
93 struct cec_adapter *cec_adap;
94 u8 cec_addr[ADV7511_MAX_ADDRS];
95 u8 cec_valid_addrs;
96 bool cec_enabled_adap;
97
98 /* Is the adv7511 powered on? */
99 bool power_on;
100 /* Did we receive hotplug and rx-sense signals? */
101 bool have_monitor;
102 bool enabled_irq;
103 /* timings from s_dv_timings */
104 struct v4l2_dv_timings dv_timings;
105 u32 fmt_code;
106 u32 colorspace;
107 u32 ycbcr_enc;
108 u32 quantization;
109 u32 xfer_func;
110 u32 content_type;
111 /* controls */
112 struct v4l2_ctrl *hdmi_mode_ctrl;
113 struct v4l2_ctrl *hotplug_ctrl;
114 struct v4l2_ctrl *rx_sense_ctrl;
115 struct v4l2_ctrl *have_edid0_ctrl;
116 struct v4l2_ctrl *rgb_quantization_range_ctrl;
117 struct v4l2_ctrl *content_type_ctrl;
118 struct i2c_client *i2c_edid;
119 struct i2c_client *i2c_pktmem;
120 struct adv7511_state_edid edid;
121 /* Running counter of the number of detected EDIDs (for debugging) */
122 unsigned edid_detect_counter;
123 struct workqueue_struct *work_queue;
124 struct delayed_work edid_handler; /* work entry */
125 };
126
127 static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd);
128 static bool adv7511_check_edid_status(struct v4l2_subdev *sd);
129 static void adv7511_setup(struct v4l2_subdev *sd);
130 static int adv7511_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq);
131 static int adv7511_s_clock_freq(struct v4l2_subdev *sd, u32 freq);
132
133
134 static const struct v4l2_dv_timings_cap adv7511_timings_cap = {
135 .type = V4L2_DV_BT_656_1120,
136 /* keep this initialization for compatibility with GCC < 4.4.6 */
137 .reserved = { 0 },
138 V4L2_INIT_BT_TIMINGS(640, ADV7511_MAX_WIDTH, 350, ADV7511_MAX_HEIGHT,
139 ADV7511_MIN_PIXELCLOCK, ADV7511_MAX_PIXELCLOCK,
140 V4L2_DV_BT_STD_CEA861 | V4L2_DV_BT_STD_DMT |
141 V4L2_DV_BT_STD_GTF | V4L2_DV_BT_STD_CVT,
142 V4L2_DV_BT_CAP_PROGRESSIVE | V4L2_DV_BT_CAP_REDUCED_BLANKING |
143 V4L2_DV_BT_CAP_CUSTOM)
144 };
145
get_adv7511_state(struct v4l2_subdev * sd)146 static inline struct adv7511_state *get_adv7511_state(struct v4l2_subdev *sd)
147 {
148 return container_of(sd, struct adv7511_state, sd);
149 }
150
to_sd(struct v4l2_ctrl * ctrl)151 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
152 {
153 return &container_of(ctrl->handler, struct adv7511_state, hdl)->sd;
154 }
155
156 /* ------------------------ I2C ----------------------------------------------- */
157
adv_smbus_read_byte_data_check(struct i2c_client * client,u8 command,bool check)158 static s32 adv_smbus_read_byte_data_check(struct i2c_client *client,
159 u8 command, bool check)
160 {
161 union i2c_smbus_data data;
162
163 if (!i2c_smbus_xfer(client->adapter, client->addr, client->flags,
164 I2C_SMBUS_READ, command,
165 I2C_SMBUS_BYTE_DATA, &data))
166 return data.byte;
167 if (check)
168 v4l_err(client, "error reading %02x, %02x\n",
169 client->addr, command);
170 return -1;
171 }
172
adv_smbus_read_byte_data(struct i2c_client * client,u8 command)173 static s32 adv_smbus_read_byte_data(struct i2c_client *client, u8 command)
174 {
175 int i;
176 for (i = 0; i < 3; i++) {
177 int ret = adv_smbus_read_byte_data_check(client, command, true);
178 if (ret >= 0) {
179 if (i)
180 v4l_err(client, "read ok after %d retries\n", i);
181 return ret;
182 }
183 }
184 v4l_err(client, "read failed\n");
185 return -1;
186 }
187
adv7511_rd(struct v4l2_subdev * sd,u8 reg)188 static int adv7511_rd(struct v4l2_subdev *sd, u8 reg)
189 {
190 struct i2c_client *client = v4l2_get_subdevdata(sd);
191
192 return adv_smbus_read_byte_data(client, reg);
193 }
194
adv7511_wr(struct v4l2_subdev * sd,u8 reg,u8 val)195 static int adv7511_wr(struct v4l2_subdev *sd, u8 reg, u8 val)
196 {
197 struct i2c_client *client = v4l2_get_subdevdata(sd);
198 int ret;
199 int i;
200
201 for (i = 0; i < 3; i++) {
202 ret = i2c_smbus_write_byte_data(client, reg, val);
203 if (ret == 0)
204 return 0;
205 }
206 v4l2_err(sd, "%s: i2c write error\n", __func__);
207 return ret;
208 }
209
210 /* To set specific bits in the register, a clear-mask is given (to be AND-ed),
211 and then the value-mask (to be OR-ed). */
adv7511_wr_and_or(struct v4l2_subdev * sd,u8 reg,u8 clr_mask,u8 val_mask)212 static inline void adv7511_wr_and_or(struct v4l2_subdev *sd, u8 reg, u8 clr_mask, u8 val_mask)
213 {
214 adv7511_wr(sd, reg, (adv7511_rd(sd, reg) & clr_mask) | val_mask);
215 }
216
adv7511_edid_rd(struct v4l2_subdev * sd,uint16_t len,uint8_t * buf)217 static int adv7511_edid_rd(struct v4l2_subdev *sd, uint16_t len, uint8_t *buf)
218 {
219 struct adv7511_state *state = get_adv7511_state(sd);
220 int i;
221
222 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
223
224 for (i = 0; i < len; i += I2C_SMBUS_BLOCK_MAX) {
225 s32 ret;
226
227 ret = i2c_smbus_read_i2c_block_data(state->i2c_edid, i,
228 I2C_SMBUS_BLOCK_MAX, buf + i);
229 if (ret < 0) {
230 v4l2_err(sd, "%s: i2c read error\n", __func__);
231 return ret;
232 }
233 }
234
235 return 0;
236 }
237
adv7511_cec_read(struct v4l2_subdev * sd,u8 reg)238 static inline int adv7511_cec_read(struct v4l2_subdev *sd, u8 reg)
239 {
240 struct adv7511_state *state = get_adv7511_state(sd);
241
242 return i2c_smbus_read_byte_data(state->i2c_cec, reg);
243 }
244
adv7511_cec_write(struct v4l2_subdev * sd,u8 reg,u8 val)245 static int adv7511_cec_write(struct v4l2_subdev *sd, u8 reg, u8 val)
246 {
247 struct adv7511_state *state = get_adv7511_state(sd);
248 int ret;
249 int i;
250
251 for (i = 0; i < 3; i++) {
252 ret = i2c_smbus_write_byte_data(state->i2c_cec, reg, val);
253 if (ret == 0)
254 return 0;
255 }
256 v4l2_err(sd, "%s: I2C Write Problem\n", __func__);
257 return ret;
258 }
259
adv7511_cec_write_and_or(struct v4l2_subdev * sd,u8 reg,u8 mask,u8 val)260 static inline int adv7511_cec_write_and_or(struct v4l2_subdev *sd, u8 reg, u8 mask,
261 u8 val)
262 {
263 return adv7511_cec_write(sd, reg, (adv7511_cec_read(sd, reg) & mask) | val);
264 }
265
adv7511_pktmem_rd(struct v4l2_subdev * sd,u8 reg)266 static int adv7511_pktmem_rd(struct v4l2_subdev *sd, u8 reg)
267 {
268 struct adv7511_state *state = get_adv7511_state(sd);
269
270 return adv_smbus_read_byte_data(state->i2c_pktmem, reg);
271 }
272
adv7511_pktmem_wr(struct v4l2_subdev * sd,u8 reg,u8 val)273 static int adv7511_pktmem_wr(struct v4l2_subdev *sd, u8 reg, u8 val)
274 {
275 struct adv7511_state *state = get_adv7511_state(sd);
276 int ret;
277 int i;
278
279 for (i = 0; i < 3; i++) {
280 ret = i2c_smbus_write_byte_data(state->i2c_pktmem, reg, val);
281 if (ret == 0)
282 return 0;
283 }
284 v4l2_err(sd, "%s: i2c write error\n", __func__);
285 return ret;
286 }
287
288 /* To set specific bits in the register, a clear-mask is given (to be AND-ed),
289 and then the value-mask (to be OR-ed). */
adv7511_pktmem_wr_and_or(struct v4l2_subdev * sd,u8 reg,u8 clr_mask,u8 val_mask)290 static inline void adv7511_pktmem_wr_and_or(struct v4l2_subdev *sd, u8 reg, u8 clr_mask, u8 val_mask)
291 {
292 adv7511_pktmem_wr(sd, reg, (adv7511_pktmem_rd(sd, reg) & clr_mask) | val_mask);
293 }
294
adv7511_have_hotplug(struct v4l2_subdev * sd)295 static inline bool adv7511_have_hotplug(struct v4l2_subdev *sd)
296 {
297 return adv7511_rd(sd, 0x42) & MASK_ADV7511_HPD_DETECT;
298 }
299
adv7511_have_rx_sense(struct v4l2_subdev * sd)300 static inline bool adv7511_have_rx_sense(struct v4l2_subdev *sd)
301 {
302 return adv7511_rd(sd, 0x42) & MASK_ADV7511_MSEN_DETECT;
303 }
304
adv7511_csc_conversion_mode(struct v4l2_subdev * sd,u8 mode)305 static void adv7511_csc_conversion_mode(struct v4l2_subdev *sd, u8 mode)
306 {
307 adv7511_wr_and_or(sd, 0x18, 0x9f, (mode & 0x3)<<5);
308 }
309
adv7511_csc_coeff(struct v4l2_subdev * sd,u16 A1,u16 A2,u16 A3,u16 A4,u16 B1,u16 B2,u16 B3,u16 B4,u16 C1,u16 C2,u16 C3,u16 C4)310 static void adv7511_csc_coeff(struct v4l2_subdev *sd,
311 u16 A1, u16 A2, u16 A3, u16 A4,
312 u16 B1, u16 B2, u16 B3, u16 B4,
313 u16 C1, u16 C2, u16 C3, u16 C4)
314 {
315 /* A */
316 adv7511_wr_and_or(sd, 0x18, 0xe0, A1>>8);
317 adv7511_wr(sd, 0x19, A1);
318 adv7511_wr_and_or(sd, 0x1A, 0xe0, A2>>8);
319 adv7511_wr(sd, 0x1B, A2);
320 adv7511_wr_and_or(sd, 0x1c, 0xe0, A3>>8);
321 adv7511_wr(sd, 0x1d, A3);
322 adv7511_wr_and_or(sd, 0x1e, 0xe0, A4>>8);
323 adv7511_wr(sd, 0x1f, A4);
324
325 /* B */
326 adv7511_wr_and_or(sd, 0x20, 0xe0, B1>>8);
327 adv7511_wr(sd, 0x21, B1);
328 adv7511_wr_and_or(sd, 0x22, 0xe0, B2>>8);
329 adv7511_wr(sd, 0x23, B2);
330 adv7511_wr_and_or(sd, 0x24, 0xe0, B3>>8);
331 adv7511_wr(sd, 0x25, B3);
332 adv7511_wr_and_or(sd, 0x26, 0xe0, B4>>8);
333 adv7511_wr(sd, 0x27, B4);
334
335 /* C */
336 adv7511_wr_and_or(sd, 0x28, 0xe0, C1>>8);
337 adv7511_wr(sd, 0x29, C1);
338 adv7511_wr_and_or(sd, 0x2A, 0xe0, C2>>8);
339 adv7511_wr(sd, 0x2B, C2);
340 adv7511_wr_and_or(sd, 0x2C, 0xe0, C3>>8);
341 adv7511_wr(sd, 0x2D, C3);
342 adv7511_wr_and_or(sd, 0x2E, 0xe0, C4>>8);
343 adv7511_wr(sd, 0x2F, C4);
344 }
345
adv7511_csc_rgb_full2limit(struct v4l2_subdev * sd,bool enable)346 static void adv7511_csc_rgb_full2limit(struct v4l2_subdev *sd, bool enable)
347 {
348 if (enable) {
349 u8 csc_mode = 0;
350 adv7511_csc_conversion_mode(sd, csc_mode);
351 adv7511_csc_coeff(sd,
352 4096-564, 0, 0, 256,
353 0, 4096-564, 0, 256,
354 0, 0, 4096-564, 256);
355 /* enable CSC */
356 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x80);
357 /* AVI infoframe: Limited range RGB (16-235) */
358 adv7511_wr_and_or(sd, 0x57, 0xf3, 0x04);
359 } else {
360 /* disable CSC */
361 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x0);
362 /* AVI infoframe: Full range RGB (0-255) */
363 adv7511_wr_and_or(sd, 0x57, 0xf3, 0x08);
364 }
365 }
366
adv7511_set_rgb_quantization_mode(struct v4l2_subdev * sd,struct v4l2_ctrl * ctrl)367 static void adv7511_set_rgb_quantization_mode(struct v4l2_subdev *sd, struct v4l2_ctrl *ctrl)
368 {
369 struct adv7511_state *state = get_adv7511_state(sd);
370
371 /* Only makes sense for RGB formats */
372 if (state->fmt_code != MEDIA_BUS_FMT_RGB888_1X24) {
373 /* so just keep quantization */
374 adv7511_csc_rgb_full2limit(sd, false);
375 return;
376 }
377
378 switch (ctrl->val) {
379 case V4L2_DV_RGB_RANGE_AUTO:
380 /* automatic */
381 if (state->dv_timings.bt.flags & V4L2_DV_FL_IS_CE_VIDEO) {
382 /* CE format, RGB limited range (16-235) */
383 adv7511_csc_rgb_full2limit(sd, true);
384 } else {
385 /* not CE format, RGB full range (0-255) */
386 adv7511_csc_rgb_full2limit(sd, false);
387 }
388 break;
389 case V4L2_DV_RGB_RANGE_LIMITED:
390 /* RGB limited range (16-235) */
391 adv7511_csc_rgb_full2limit(sd, true);
392 break;
393 case V4L2_DV_RGB_RANGE_FULL:
394 /* RGB full range (0-255) */
395 adv7511_csc_rgb_full2limit(sd, false);
396 break;
397 }
398 }
399
400 /* ------------------------------ CTRL OPS ------------------------------ */
401
adv7511_s_ctrl(struct v4l2_ctrl * ctrl)402 static int adv7511_s_ctrl(struct v4l2_ctrl *ctrl)
403 {
404 struct v4l2_subdev *sd = to_sd(ctrl);
405 struct adv7511_state *state = get_adv7511_state(sd);
406
407 v4l2_dbg(1, debug, sd, "%s: ctrl id: %d, ctrl->val %d\n", __func__, ctrl->id, ctrl->val);
408
409 if (state->hdmi_mode_ctrl == ctrl) {
410 /* Set HDMI or DVI-D */
411 adv7511_wr_and_or(sd, 0xaf, 0xfd, ctrl->val == V4L2_DV_TX_MODE_HDMI ? 0x02 : 0x00);
412 return 0;
413 }
414 if (state->rgb_quantization_range_ctrl == ctrl) {
415 adv7511_set_rgb_quantization_mode(sd, ctrl);
416 return 0;
417 }
418 if (state->content_type_ctrl == ctrl) {
419 u8 itc, cn;
420
421 state->content_type = ctrl->val;
422 itc = state->content_type != V4L2_DV_IT_CONTENT_TYPE_NO_ITC;
423 cn = itc ? state->content_type : V4L2_DV_IT_CONTENT_TYPE_GRAPHICS;
424 adv7511_wr_and_or(sd, 0x57, 0x7f, itc << 7);
425 adv7511_wr_and_or(sd, 0x59, 0xcf, cn << 4);
426 return 0;
427 }
428
429 return -EINVAL;
430 }
431
432 static const struct v4l2_ctrl_ops adv7511_ctrl_ops = {
433 .s_ctrl = adv7511_s_ctrl,
434 };
435
436 /* ---------------------------- CORE OPS ------------------------------------------- */
437
438 #ifdef CONFIG_VIDEO_ADV_DEBUG
adv7511_inv_register(struct v4l2_subdev * sd)439 static void adv7511_inv_register(struct v4l2_subdev *sd)
440 {
441 struct adv7511_state *state = get_adv7511_state(sd);
442
443 v4l2_info(sd, "0x000-0x0ff: Main Map\n");
444 if (state->i2c_cec)
445 v4l2_info(sd, "0x100-0x1ff: CEC Map\n");
446 }
447
adv7511_g_register(struct v4l2_subdev * sd,struct v4l2_dbg_register * reg)448 static int adv7511_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
449 {
450 struct adv7511_state *state = get_adv7511_state(sd);
451
452 reg->size = 1;
453 switch (reg->reg >> 8) {
454 case 0:
455 reg->val = adv7511_rd(sd, reg->reg & 0xff);
456 break;
457 case 1:
458 if (state->i2c_cec) {
459 reg->val = adv7511_cec_read(sd, reg->reg & 0xff);
460 break;
461 }
462 fallthrough;
463 default:
464 v4l2_info(sd, "Register %03llx not supported\n", reg->reg);
465 adv7511_inv_register(sd);
466 break;
467 }
468 return 0;
469 }
470
adv7511_s_register(struct v4l2_subdev * sd,const struct v4l2_dbg_register * reg)471 static int adv7511_s_register(struct v4l2_subdev *sd, const struct v4l2_dbg_register *reg)
472 {
473 struct adv7511_state *state = get_adv7511_state(sd);
474
475 switch (reg->reg >> 8) {
476 case 0:
477 adv7511_wr(sd, reg->reg & 0xff, reg->val & 0xff);
478 break;
479 case 1:
480 if (state->i2c_cec) {
481 adv7511_cec_write(sd, reg->reg & 0xff, reg->val & 0xff);
482 break;
483 }
484 fallthrough;
485 default:
486 v4l2_info(sd, "Register %03llx not supported\n", reg->reg);
487 adv7511_inv_register(sd);
488 break;
489 }
490 return 0;
491 }
492 #endif
493
494 struct adv7511_cfg_read_infoframe {
495 const char *desc;
496 u8 present_reg;
497 u8 present_mask;
498 u8 header[3];
499 u16 payload_addr;
500 };
501
hdmi_infoframe_checksum(u8 * ptr,size_t size)502 static u8 hdmi_infoframe_checksum(u8 *ptr, size_t size)
503 {
504 u8 csum = 0;
505 size_t i;
506
507 /* compute checksum */
508 for (i = 0; i < size; i++)
509 csum += ptr[i];
510
511 return 256 - csum;
512 }
513
log_infoframe(struct v4l2_subdev * sd,const struct adv7511_cfg_read_infoframe * cri)514 static void log_infoframe(struct v4l2_subdev *sd, const struct adv7511_cfg_read_infoframe *cri)
515 {
516 struct i2c_client *client = v4l2_get_subdevdata(sd);
517 struct device *dev = &client->dev;
518 union hdmi_infoframe frame;
519 u8 buffer[32];
520 u8 len;
521 int i;
522
523 if (!(adv7511_rd(sd, cri->present_reg) & cri->present_mask)) {
524 v4l2_info(sd, "%s infoframe not transmitted\n", cri->desc);
525 return;
526 }
527
528 memcpy(buffer, cri->header, sizeof(cri->header));
529
530 len = buffer[2];
531
532 if (len + 4 > sizeof(buffer)) {
533 v4l2_err(sd, "%s: invalid %s infoframe length %d\n", __func__, cri->desc, len);
534 return;
535 }
536
537 if (cri->payload_addr >= 0x100) {
538 for (i = 0; i < len; i++)
539 buffer[i + 4] = adv7511_pktmem_rd(sd, cri->payload_addr + i - 0x100);
540 } else {
541 for (i = 0; i < len; i++)
542 buffer[i + 4] = adv7511_rd(sd, cri->payload_addr + i);
543 }
544 buffer[3] = 0;
545 buffer[3] = hdmi_infoframe_checksum(buffer, len + 4);
546
547 if (hdmi_infoframe_unpack(&frame, buffer, len + 4) < 0) {
548 v4l2_err(sd, "%s: unpack of %s infoframe failed\n", __func__, cri->desc);
549 return;
550 }
551
552 hdmi_infoframe_log(KERN_INFO, dev, &frame);
553 }
554
adv7511_log_infoframes(struct v4l2_subdev * sd)555 static void adv7511_log_infoframes(struct v4l2_subdev *sd)
556 {
557 static const struct adv7511_cfg_read_infoframe cri[] = {
558 { "AVI", 0x44, 0x10, { 0x82, 2, 13 }, 0x55 },
559 { "Audio", 0x44, 0x08, { 0x84, 1, 10 }, 0x73 },
560 { "SDP", 0x40, 0x40, { 0x83, 1, 25 }, 0x103 },
561 };
562 int i;
563
564 for (i = 0; i < ARRAY_SIZE(cri); i++)
565 log_infoframe(sd, &cri[i]);
566 }
567
adv7511_log_status(struct v4l2_subdev * sd)568 static int adv7511_log_status(struct v4l2_subdev *sd)
569 {
570 struct adv7511_state *state = get_adv7511_state(sd);
571 struct adv7511_state_edid *edid = &state->edid;
572 int i;
573
574 static const char * const states[] = {
575 "in reset",
576 "reading EDID",
577 "idle",
578 "initializing HDCP",
579 "HDCP enabled",
580 "initializing HDCP repeater",
581 "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"
582 };
583 static const char * const errors[] = {
584 "no error",
585 "bad receiver BKSV",
586 "Ri mismatch",
587 "Pj mismatch",
588 "i2c error",
589 "timed out",
590 "max repeater cascade exceeded",
591 "hash check failed",
592 "too many devices",
593 "9", "A", "B", "C", "D", "E", "F"
594 };
595
596 v4l2_info(sd, "power %s\n", state->power_on ? "on" : "off");
597 v4l2_info(sd, "%s hotplug, %s Rx Sense, %s EDID (%d block(s))\n",
598 (adv7511_rd(sd, 0x42) & MASK_ADV7511_HPD_DETECT) ? "detected" : "no",
599 (adv7511_rd(sd, 0x42) & MASK_ADV7511_MSEN_DETECT) ? "detected" : "no",
600 edid->segments ? "found" : "no",
601 edid->blocks);
602 v4l2_info(sd, "%s output %s\n",
603 (adv7511_rd(sd, 0xaf) & 0x02) ?
604 "HDMI" : "DVI-D",
605 (adv7511_rd(sd, 0xa1) & 0x3c) ?
606 "disabled" : "enabled");
607 v4l2_info(sd, "state: %s, error: %s, detect count: %u, msk/irq: %02x/%02x\n",
608 states[adv7511_rd(sd, 0xc8) & 0xf],
609 errors[adv7511_rd(sd, 0xc8) >> 4], state->edid_detect_counter,
610 adv7511_rd(sd, 0x94), adv7511_rd(sd, 0x96));
611 v4l2_info(sd, "RGB quantization: %s range\n", adv7511_rd(sd, 0x18) & 0x80 ? "limited" : "full");
612 if (adv7511_rd(sd, 0xaf) & 0x02) {
613 /* HDMI only */
614 u8 manual_cts = adv7511_rd(sd, 0x0a) & 0x80;
615 u32 N = (adv7511_rd(sd, 0x01) & 0xf) << 16 |
616 adv7511_rd(sd, 0x02) << 8 |
617 adv7511_rd(sd, 0x03);
618 u8 vic_detect = adv7511_rd(sd, 0x3e) >> 2;
619 u8 vic_sent = adv7511_rd(sd, 0x3d) & 0x3f;
620 u32 CTS;
621
622 if (manual_cts)
623 CTS = (adv7511_rd(sd, 0x07) & 0xf) << 16 |
624 adv7511_rd(sd, 0x08) << 8 |
625 adv7511_rd(sd, 0x09);
626 else
627 CTS = (adv7511_rd(sd, 0x04) & 0xf) << 16 |
628 adv7511_rd(sd, 0x05) << 8 |
629 adv7511_rd(sd, 0x06);
630 v4l2_info(sd, "CTS %s mode: N %d, CTS %d\n",
631 manual_cts ? "manual" : "automatic", N, CTS);
632 v4l2_info(sd, "VIC: detected %d, sent %d\n",
633 vic_detect, vic_sent);
634 adv7511_log_infoframes(sd);
635 }
636 if (state->dv_timings.type == V4L2_DV_BT_656_1120)
637 v4l2_print_dv_timings(sd->name, "timings: ",
638 &state->dv_timings, false);
639 else
640 v4l2_info(sd, "no timings set\n");
641 v4l2_info(sd, "i2c edid addr: 0x%x\n", state->i2c_edid_addr);
642
643 if (state->i2c_cec == NULL)
644 return 0;
645
646 v4l2_info(sd, "i2c cec addr: 0x%x\n", state->i2c_cec_addr);
647
648 v4l2_info(sd, "CEC: %s\n", state->cec_enabled_adap ?
649 "enabled" : "disabled");
650 if (state->cec_enabled_adap) {
651 for (i = 0; i < ADV7511_MAX_ADDRS; i++) {
652 bool is_valid = state->cec_valid_addrs & (1 << i);
653
654 if (is_valid)
655 v4l2_info(sd, "CEC Logical Address: 0x%x\n",
656 state->cec_addr[i]);
657 }
658 }
659 v4l2_info(sd, "i2c pktmem addr: 0x%x\n", state->i2c_pktmem_addr);
660 return 0;
661 }
662
663 /* Power up/down adv7511 */
adv7511_s_power(struct v4l2_subdev * sd,int on)664 static int adv7511_s_power(struct v4l2_subdev *sd, int on)
665 {
666 struct adv7511_state *state = get_adv7511_state(sd);
667 const int retries = 20;
668 int i;
669
670 v4l2_dbg(1, debug, sd, "%s: power %s\n", __func__, on ? "on" : "off");
671
672 state->power_on = on;
673
674 if (!on) {
675 /* Power down */
676 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x40);
677 return true;
678 }
679
680 /* Power up */
681 /* The adv7511 does not always come up immediately.
682 Retry multiple times. */
683 for (i = 0; i < retries; i++) {
684 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x0);
685 if ((adv7511_rd(sd, 0x41) & 0x40) == 0)
686 break;
687 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x40);
688 msleep(10);
689 }
690 if (i == retries) {
691 v4l2_dbg(1, debug, sd, "%s: failed to powerup the adv7511!\n", __func__);
692 adv7511_s_power(sd, 0);
693 return false;
694 }
695 if (i > 1)
696 v4l2_dbg(1, debug, sd, "%s: needed %d retries to powerup the adv7511\n", __func__, i);
697
698 /* Reserved registers that must be set */
699 adv7511_wr(sd, 0x98, 0x03);
700 adv7511_wr_and_or(sd, 0x9a, 0xfe, 0x70);
701 adv7511_wr(sd, 0x9c, 0x30);
702 adv7511_wr_and_or(sd, 0x9d, 0xfc, 0x01);
703 adv7511_wr(sd, 0xa2, 0xa4);
704 adv7511_wr(sd, 0xa3, 0xa4);
705 adv7511_wr(sd, 0xe0, 0xd0);
706 adv7511_wr(sd, 0xf9, 0x00);
707
708 adv7511_wr(sd, 0x43, state->i2c_edid_addr);
709 adv7511_wr(sd, 0x45, state->i2c_pktmem_addr);
710
711 /* Set number of attempts to read the EDID */
712 adv7511_wr(sd, 0xc9, 0xf);
713 return true;
714 }
715
716 #if IS_ENABLED(CONFIG_VIDEO_ADV7511_CEC)
adv7511_cec_adap_enable(struct cec_adapter * adap,bool enable)717 static int adv7511_cec_adap_enable(struct cec_adapter *adap, bool enable)
718 {
719 struct adv7511_state *state = cec_get_drvdata(adap);
720 struct v4l2_subdev *sd = &state->sd;
721
722 if (state->i2c_cec == NULL)
723 return -EIO;
724
725 if (!state->cec_enabled_adap && enable) {
726 /* power up cec section */
727 adv7511_cec_write_and_or(sd, 0x4e, 0xfc, 0x01);
728 /* legacy mode and clear all rx buffers */
729 adv7511_cec_write(sd, 0x4a, 0x00);
730 adv7511_cec_write(sd, 0x4a, 0x07);
731 adv7511_cec_write_and_or(sd, 0x11, 0xfe, 0); /* initially disable tx */
732 /* enabled irqs: */
733 /* tx: ready */
734 /* tx: arbitration lost */
735 /* tx: retry timeout */
736 /* rx: ready 1 */
737 if (state->enabled_irq)
738 adv7511_wr_and_or(sd, 0x95, 0xc0, 0x39);
739 } else if (state->cec_enabled_adap && !enable) {
740 if (state->enabled_irq)
741 adv7511_wr_and_or(sd, 0x95, 0xc0, 0x00);
742 /* disable address mask 1-3 */
743 adv7511_cec_write_and_or(sd, 0x4b, 0x8f, 0x00);
744 /* power down cec section */
745 adv7511_cec_write_and_or(sd, 0x4e, 0xfc, 0x00);
746 state->cec_valid_addrs = 0;
747 }
748 state->cec_enabled_adap = enable;
749 return 0;
750 }
751
adv7511_cec_adap_log_addr(struct cec_adapter * adap,u8 addr)752 static int adv7511_cec_adap_log_addr(struct cec_adapter *adap, u8 addr)
753 {
754 struct adv7511_state *state = cec_get_drvdata(adap);
755 struct v4l2_subdev *sd = &state->sd;
756 unsigned int i, free_idx = ADV7511_MAX_ADDRS;
757
758 if (!state->cec_enabled_adap)
759 return addr == CEC_LOG_ADDR_INVALID ? 0 : -EIO;
760
761 if (addr == CEC_LOG_ADDR_INVALID) {
762 adv7511_cec_write_and_or(sd, 0x4b, 0x8f, 0);
763 state->cec_valid_addrs = 0;
764 return 0;
765 }
766
767 for (i = 0; i < ADV7511_MAX_ADDRS; i++) {
768 bool is_valid = state->cec_valid_addrs & (1 << i);
769
770 if (free_idx == ADV7511_MAX_ADDRS && !is_valid)
771 free_idx = i;
772 if (is_valid && state->cec_addr[i] == addr)
773 return 0;
774 }
775 if (i == ADV7511_MAX_ADDRS) {
776 i = free_idx;
777 if (i == ADV7511_MAX_ADDRS)
778 return -ENXIO;
779 }
780 state->cec_addr[i] = addr;
781 state->cec_valid_addrs |= 1 << i;
782
783 switch (i) {
784 case 0:
785 /* enable address mask 0 */
786 adv7511_cec_write_and_or(sd, 0x4b, 0xef, 0x10);
787 /* set address for mask 0 */
788 adv7511_cec_write_and_or(sd, 0x4c, 0xf0, addr);
789 break;
790 case 1:
791 /* enable address mask 1 */
792 adv7511_cec_write_and_or(sd, 0x4b, 0xdf, 0x20);
793 /* set address for mask 1 */
794 adv7511_cec_write_and_or(sd, 0x4c, 0x0f, addr << 4);
795 break;
796 case 2:
797 /* enable address mask 2 */
798 adv7511_cec_write_and_or(sd, 0x4b, 0xbf, 0x40);
799 /* set address for mask 1 */
800 adv7511_cec_write_and_or(sd, 0x4d, 0xf0, addr);
801 break;
802 }
803 return 0;
804 }
805
adv7511_cec_adap_transmit(struct cec_adapter * adap,u8 attempts,u32 signal_free_time,struct cec_msg * msg)806 static int adv7511_cec_adap_transmit(struct cec_adapter *adap, u8 attempts,
807 u32 signal_free_time, struct cec_msg *msg)
808 {
809 struct adv7511_state *state = cec_get_drvdata(adap);
810 struct v4l2_subdev *sd = &state->sd;
811 u8 len = msg->len;
812 unsigned int i;
813
814 v4l2_dbg(1, debug, sd, "%s: len %d\n", __func__, len);
815
816 if (len > 16) {
817 v4l2_err(sd, "%s: len exceeded 16 (%d)\n", __func__, len);
818 return -EINVAL;
819 }
820
821 /*
822 * The number of retries is the number of attempts - 1, but retry
823 * at least once. It's not clear if a value of 0 is allowed, so
824 * let's do at least one retry.
825 */
826 adv7511_cec_write_and_or(sd, 0x12, ~0x70, max(1, attempts - 1) << 4);
827
828 /* clear cec tx irq status */
829 adv7511_wr(sd, 0x97, 0x38);
830
831 /* write data */
832 for (i = 0; i < len; i++)
833 adv7511_cec_write(sd, i, msg->msg[i]);
834
835 /* set length (data + header) */
836 adv7511_cec_write(sd, 0x10, len);
837 /* start transmit, enable tx */
838 adv7511_cec_write(sd, 0x11, 0x01);
839 return 0;
840 }
841
adv_cec_tx_raw_status(struct v4l2_subdev * sd,u8 tx_raw_status)842 static void adv_cec_tx_raw_status(struct v4l2_subdev *sd, u8 tx_raw_status)
843 {
844 struct adv7511_state *state = get_adv7511_state(sd);
845
846 if ((adv7511_cec_read(sd, 0x11) & 0x01) == 0) {
847 v4l2_dbg(1, debug, sd, "%s: tx raw: tx disabled\n", __func__);
848 return;
849 }
850
851 if (tx_raw_status & 0x10) {
852 v4l2_dbg(1, debug, sd,
853 "%s: tx raw: arbitration lost\n", __func__);
854 cec_transmit_done(state->cec_adap, CEC_TX_STATUS_ARB_LOST,
855 1, 0, 0, 0);
856 return;
857 }
858 if (tx_raw_status & 0x08) {
859 u8 status;
860 u8 nack_cnt;
861 u8 low_drive_cnt;
862
863 v4l2_dbg(1, debug, sd, "%s: tx raw: retry failed\n", __func__);
864 /*
865 * We set this status bit since this hardware performs
866 * retransmissions.
867 */
868 status = CEC_TX_STATUS_MAX_RETRIES;
869 nack_cnt = adv7511_cec_read(sd, 0x14) & 0xf;
870 if (nack_cnt)
871 status |= CEC_TX_STATUS_NACK;
872 low_drive_cnt = adv7511_cec_read(sd, 0x14) >> 4;
873 if (low_drive_cnt)
874 status |= CEC_TX_STATUS_LOW_DRIVE;
875 cec_transmit_done(state->cec_adap, status,
876 0, nack_cnt, low_drive_cnt, 0);
877 return;
878 }
879 if (tx_raw_status & 0x20) {
880 v4l2_dbg(1, debug, sd, "%s: tx raw: ready ok\n", __func__);
881 cec_transmit_done(state->cec_adap, CEC_TX_STATUS_OK, 0, 0, 0, 0);
882 return;
883 }
884 }
885
886 static const struct cec_adap_ops adv7511_cec_adap_ops = {
887 .adap_enable = adv7511_cec_adap_enable,
888 .adap_log_addr = adv7511_cec_adap_log_addr,
889 .adap_transmit = adv7511_cec_adap_transmit,
890 };
891 #endif
892
893 /* Enable interrupts */
adv7511_set_isr(struct v4l2_subdev * sd,bool enable)894 static void adv7511_set_isr(struct v4l2_subdev *sd, bool enable)
895 {
896 struct adv7511_state *state = get_adv7511_state(sd);
897 u8 irqs = MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT;
898 u8 irqs_rd;
899 int retries = 100;
900
901 v4l2_dbg(2, debug, sd, "%s: %s\n", __func__, enable ? "enable" : "disable");
902
903 if (state->enabled_irq == enable)
904 return;
905 state->enabled_irq = enable;
906
907 /* The datasheet says that the EDID ready interrupt should be
908 disabled if there is no hotplug. */
909 if (!enable)
910 irqs = 0;
911 else if (adv7511_have_hotplug(sd))
912 irqs |= MASK_ADV7511_EDID_RDY_INT;
913
914 /*
915 * This i2c write can fail (approx. 1 in 1000 writes). But it
916 * is essential that this register is correct, so retry it
917 * multiple times.
918 *
919 * Note that the i2c write does not report an error, but the readback
920 * clearly shows the wrong value.
921 */
922 do {
923 adv7511_wr(sd, 0x94, irqs);
924 irqs_rd = adv7511_rd(sd, 0x94);
925 } while (retries-- && irqs_rd != irqs);
926
927 if (irqs_rd != irqs)
928 v4l2_err(sd, "Could not set interrupts: hw failure?\n");
929
930 adv7511_wr_and_or(sd, 0x95, 0xc0,
931 (state->cec_enabled_adap && enable) ? 0x39 : 0x00);
932 }
933
934 /* Interrupt handler */
adv7511_isr(struct v4l2_subdev * sd,u32 status,bool * handled)935 static int adv7511_isr(struct v4l2_subdev *sd, u32 status, bool *handled)
936 {
937 u8 irq_status;
938 u8 cec_irq;
939
940 /* disable interrupts to prevent a race condition */
941 adv7511_set_isr(sd, false);
942 irq_status = adv7511_rd(sd, 0x96);
943 cec_irq = adv7511_rd(sd, 0x97);
944 /* clear detected interrupts */
945 adv7511_wr(sd, 0x96, irq_status);
946 adv7511_wr(sd, 0x97, cec_irq);
947
948 v4l2_dbg(1, debug, sd, "%s: irq 0x%x, cec-irq 0x%x\n", __func__,
949 irq_status, cec_irq);
950
951 if (irq_status & (MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT))
952 adv7511_check_monitor_present_status(sd);
953 if (irq_status & MASK_ADV7511_EDID_RDY_INT)
954 adv7511_check_edid_status(sd);
955
956 #if IS_ENABLED(CONFIG_VIDEO_ADV7511_CEC)
957 if (cec_irq & 0x38)
958 adv_cec_tx_raw_status(sd, cec_irq);
959
960 if (cec_irq & 1) {
961 struct adv7511_state *state = get_adv7511_state(sd);
962 struct cec_msg msg;
963
964 msg.len = adv7511_cec_read(sd, 0x25) & 0x1f;
965
966 v4l2_dbg(1, debug, sd, "%s: cec msg len %d\n", __func__,
967 msg.len);
968
969 if (msg.len > 16)
970 msg.len = 16;
971
972 if (msg.len) {
973 u8 i;
974
975 for (i = 0; i < msg.len; i++)
976 msg.msg[i] = adv7511_cec_read(sd, i + 0x15);
977
978 adv7511_cec_write(sd, 0x4a, 0); /* toggle to re-enable rx 1 */
979 adv7511_cec_write(sd, 0x4a, 1);
980 cec_received_msg(state->cec_adap, &msg);
981 }
982 }
983 #endif
984
985 /* enable interrupts */
986 adv7511_set_isr(sd, true);
987
988 if (handled)
989 *handled = true;
990 return 0;
991 }
992
993 static const struct v4l2_subdev_core_ops adv7511_core_ops = {
994 .log_status = adv7511_log_status,
995 #ifdef CONFIG_VIDEO_ADV_DEBUG
996 .g_register = adv7511_g_register,
997 .s_register = adv7511_s_register,
998 #endif
999 .s_power = adv7511_s_power,
1000 .interrupt_service_routine = adv7511_isr,
1001 };
1002
1003 /* ------------------------------ VIDEO OPS ------------------------------ */
1004
1005 /* Enable/disable adv7511 output */
adv7511_s_stream(struct v4l2_subdev * sd,int enable)1006 static int adv7511_s_stream(struct v4l2_subdev *sd, int enable)
1007 {
1008 struct adv7511_state *state = get_adv7511_state(sd);
1009
1010 v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis"));
1011 adv7511_wr_and_or(sd, 0xa1, ~0x3c, (enable ? 0 : 0x3c));
1012 if (enable) {
1013 adv7511_check_monitor_present_status(sd);
1014 } else {
1015 adv7511_s_power(sd, 0);
1016 state->have_monitor = false;
1017 }
1018 return 0;
1019 }
1020
adv7511_s_dv_timings(struct v4l2_subdev * sd,struct v4l2_dv_timings * timings)1021 static int adv7511_s_dv_timings(struct v4l2_subdev *sd,
1022 struct v4l2_dv_timings *timings)
1023 {
1024 struct adv7511_state *state = get_adv7511_state(sd);
1025 struct v4l2_bt_timings *bt = &timings->bt;
1026 u32 fps;
1027
1028 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
1029
1030 /* quick sanity check */
1031 if (!v4l2_valid_dv_timings(timings, &adv7511_timings_cap, NULL, NULL))
1032 return -EINVAL;
1033
1034 /* Fill the optional fields .standards and .flags in struct v4l2_dv_timings
1035 if the format is one of the CEA or DMT timings. */
1036 v4l2_find_dv_timings_cap(timings, &adv7511_timings_cap, 0, NULL, NULL);
1037
1038 /* save timings */
1039 state->dv_timings = *timings;
1040
1041 /* set h/vsync polarities */
1042 adv7511_wr_and_or(sd, 0x17, 0x9f,
1043 ((bt->polarities & V4L2_DV_VSYNC_POS_POL) ? 0 : 0x40) |
1044 ((bt->polarities & V4L2_DV_HSYNC_POS_POL) ? 0 : 0x20));
1045
1046 fps = (u32)bt->pixelclock / (V4L2_DV_BT_FRAME_WIDTH(bt) * V4L2_DV_BT_FRAME_HEIGHT(bt));
1047 switch (fps) {
1048 case 24:
1049 adv7511_wr_and_or(sd, 0xfb, 0xf9, 1 << 1);
1050 break;
1051 case 25:
1052 adv7511_wr_and_or(sd, 0xfb, 0xf9, 2 << 1);
1053 break;
1054 case 30:
1055 adv7511_wr_and_or(sd, 0xfb, 0xf9, 3 << 1);
1056 break;
1057 default:
1058 adv7511_wr_and_or(sd, 0xfb, 0xf9, 0);
1059 break;
1060 }
1061
1062 /* update quantization range based on new dv_timings */
1063 adv7511_set_rgb_quantization_mode(sd, state->rgb_quantization_range_ctrl);
1064
1065 return 0;
1066 }
1067
adv7511_g_dv_timings(struct v4l2_subdev * sd,struct v4l2_dv_timings * timings)1068 static int adv7511_g_dv_timings(struct v4l2_subdev *sd,
1069 struct v4l2_dv_timings *timings)
1070 {
1071 struct adv7511_state *state = get_adv7511_state(sd);
1072
1073 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
1074
1075 if (!timings)
1076 return -EINVAL;
1077
1078 *timings = state->dv_timings;
1079
1080 return 0;
1081 }
1082
adv7511_enum_dv_timings(struct v4l2_subdev * sd,struct v4l2_enum_dv_timings * timings)1083 static int adv7511_enum_dv_timings(struct v4l2_subdev *sd,
1084 struct v4l2_enum_dv_timings *timings)
1085 {
1086 if (timings->pad != 0)
1087 return -EINVAL;
1088
1089 return v4l2_enum_dv_timings_cap(timings, &adv7511_timings_cap, NULL, NULL);
1090 }
1091
adv7511_dv_timings_cap(struct v4l2_subdev * sd,struct v4l2_dv_timings_cap * cap)1092 static int adv7511_dv_timings_cap(struct v4l2_subdev *sd,
1093 struct v4l2_dv_timings_cap *cap)
1094 {
1095 if (cap->pad != 0)
1096 return -EINVAL;
1097
1098 *cap = adv7511_timings_cap;
1099 return 0;
1100 }
1101
1102 static const struct v4l2_subdev_video_ops adv7511_video_ops = {
1103 .s_stream = adv7511_s_stream,
1104 .s_dv_timings = adv7511_s_dv_timings,
1105 .g_dv_timings = adv7511_g_dv_timings,
1106 };
1107
1108 /* ------------------------------ AUDIO OPS ------------------------------ */
adv7511_s_audio_stream(struct v4l2_subdev * sd,int enable)1109 static int adv7511_s_audio_stream(struct v4l2_subdev *sd, int enable)
1110 {
1111 v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis"));
1112
1113 if (enable)
1114 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x80);
1115 else
1116 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x40);
1117
1118 return 0;
1119 }
1120
adv7511_s_clock_freq(struct v4l2_subdev * sd,u32 freq)1121 static int adv7511_s_clock_freq(struct v4l2_subdev *sd, u32 freq)
1122 {
1123 u32 N;
1124
1125 switch (freq) {
1126 case 32000: N = 4096; break;
1127 case 44100: N = 6272; break;
1128 case 48000: N = 6144; break;
1129 case 88200: N = 12544; break;
1130 case 96000: N = 12288; break;
1131 case 176400: N = 25088; break;
1132 case 192000: N = 24576; break;
1133 default:
1134 return -EINVAL;
1135 }
1136
1137 /* Set N (used with CTS to regenerate the audio clock) */
1138 adv7511_wr(sd, 0x01, (N >> 16) & 0xf);
1139 adv7511_wr(sd, 0x02, (N >> 8) & 0xff);
1140 adv7511_wr(sd, 0x03, N & 0xff);
1141
1142 return 0;
1143 }
1144
adv7511_s_i2s_clock_freq(struct v4l2_subdev * sd,u32 freq)1145 static int adv7511_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq)
1146 {
1147 u32 i2s_sf;
1148
1149 switch (freq) {
1150 case 32000: i2s_sf = 0x30; break;
1151 case 44100: i2s_sf = 0x00; break;
1152 case 48000: i2s_sf = 0x20; break;
1153 case 88200: i2s_sf = 0x80; break;
1154 case 96000: i2s_sf = 0xa0; break;
1155 case 176400: i2s_sf = 0xc0; break;
1156 case 192000: i2s_sf = 0xe0; break;
1157 default:
1158 return -EINVAL;
1159 }
1160
1161 /* Set sampling frequency for I2S audio to 48 kHz */
1162 adv7511_wr_and_or(sd, 0x15, 0xf, i2s_sf);
1163
1164 return 0;
1165 }
1166
adv7511_s_routing(struct v4l2_subdev * sd,u32 input,u32 output,u32 config)1167 static int adv7511_s_routing(struct v4l2_subdev *sd, u32 input, u32 output, u32 config)
1168 {
1169 /* Only 2 channels in use for application */
1170 adv7511_wr_and_or(sd, 0x73, 0xf8, 0x1);
1171 /* Speaker mapping */
1172 adv7511_wr(sd, 0x76, 0x00);
1173
1174 /* 16 bit audio word length */
1175 adv7511_wr_and_or(sd, 0x14, 0xf0, 0x02);
1176
1177 return 0;
1178 }
1179
1180 static const struct v4l2_subdev_audio_ops adv7511_audio_ops = {
1181 .s_stream = adv7511_s_audio_stream,
1182 .s_clock_freq = adv7511_s_clock_freq,
1183 .s_i2s_clock_freq = adv7511_s_i2s_clock_freq,
1184 .s_routing = adv7511_s_routing,
1185 };
1186
1187 /* ---------------------------- PAD OPS ------------------------------------- */
1188
adv7511_get_edid(struct v4l2_subdev * sd,struct v4l2_edid * edid)1189 static int adv7511_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
1190 {
1191 struct adv7511_state *state = get_adv7511_state(sd);
1192
1193 memset(edid->reserved, 0, sizeof(edid->reserved));
1194
1195 if (edid->pad != 0)
1196 return -EINVAL;
1197
1198 if (edid->start_block == 0 && edid->blocks == 0) {
1199 edid->blocks = state->edid.blocks;
1200 return 0;
1201 }
1202
1203 if (state->edid.blocks == 0)
1204 return -ENODATA;
1205
1206 if (edid->start_block >= state->edid.blocks)
1207 return -EINVAL;
1208
1209 if (edid->start_block + edid->blocks > state->edid.blocks)
1210 edid->blocks = state->edid.blocks - edid->start_block;
1211
1212 memcpy(edid->edid, &state->edid.data[edid->start_block * 128],
1213 128 * edid->blocks);
1214
1215 return 0;
1216 }
1217
adv7511_enum_mbus_code(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_mbus_code_enum * code)1218 static int adv7511_enum_mbus_code(struct v4l2_subdev *sd,
1219 struct v4l2_subdev_state *sd_state,
1220 struct v4l2_subdev_mbus_code_enum *code)
1221 {
1222 if (code->pad != 0)
1223 return -EINVAL;
1224
1225 switch (code->index) {
1226 case 0:
1227 code->code = MEDIA_BUS_FMT_RGB888_1X24;
1228 break;
1229 case 1:
1230 code->code = MEDIA_BUS_FMT_YUYV8_1X16;
1231 break;
1232 case 2:
1233 code->code = MEDIA_BUS_FMT_UYVY8_1X16;
1234 break;
1235 default:
1236 return -EINVAL;
1237 }
1238 return 0;
1239 }
1240
adv7511_fill_format(struct adv7511_state * state,struct v4l2_mbus_framefmt * format)1241 static void adv7511_fill_format(struct adv7511_state *state,
1242 struct v4l2_mbus_framefmt *format)
1243 {
1244 format->width = state->dv_timings.bt.width;
1245 format->height = state->dv_timings.bt.height;
1246 format->field = V4L2_FIELD_NONE;
1247 }
1248
adv7511_get_fmt(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_format * format)1249 static int adv7511_get_fmt(struct v4l2_subdev *sd,
1250 struct v4l2_subdev_state *sd_state,
1251 struct v4l2_subdev_format *format)
1252 {
1253 struct adv7511_state *state = get_adv7511_state(sd);
1254
1255 if (format->pad != 0)
1256 return -EINVAL;
1257
1258 memset(&format->format, 0, sizeof(format->format));
1259 adv7511_fill_format(state, &format->format);
1260
1261 if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
1262 struct v4l2_mbus_framefmt *fmt;
1263
1264 fmt = v4l2_subdev_get_try_format(sd, sd_state, format->pad);
1265 format->format.code = fmt->code;
1266 format->format.colorspace = fmt->colorspace;
1267 format->format.ycbcr_enc = fmt->ycbcr_enc;
1268 format->format.quantization = fmt->quantization;
1269 format->format.xfer_func = fmt->xfer_func;
1270 } else {
1271 format->format.code = state->fmt_code;
1272 format->format.colorspace = state->colorspace;
1273 format->format.ycbcr_enc = state->ycbcr_enc;
1274 format->format.quantization = state->quantization;
1275 format->format.xfer_func = state->xfer_func;
1276 }
1277
1278 return 0;
1279 }
1280
adv7511_set_fmt(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_format * format)1281 static int adv7511_set_fmt(struct v4l2_subdev *sd,
1282 struct v4l2_subdev_state *sd_state,
1283 struct v4l2_subdev_format *format)
1284 {
1285 struct adv7511_state *state = get_adv7511_state(sd);
1286 /*
1287 * Bitfield namings come the CEA-861-F standard, table 8 "Auxiliary
1288 * Video Information (AVI) InfoFrame Format"
1289 *
1290 * c = Colorimetry
1291 * ec = Extended Colorimetry
1292 * y = RGB or YCbCr
1293 * q = RGB Quantization Range
1294 * yq = YCC Quantization Range
1295 */
1296 u8 c = HDMI_COLORIMETRY_NONE;
1297 u8 ec = HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
1298 u8 y = HDMI_COLORSPACE_RGB;
1299 u8 q = HDMI_QUANTIZATION_RANGE_DEFAULT;
1300 u8 yq = HDMI_YCC_QUANTIZATION_RANGE_LIMITED;
1301 u8 itc = state->content_type != V4L2_DV_IT_CONTENT_TYPE_NO_ITC;
1302 u8 cn = itc ? state->content_type : V4L2_DV_IT_CONTENT_TYPE_GRAPHICS;
1303
1304 if (format->pad != 0)
1305 return -EINVAL;
1306 switch (format->format.code) {
1307 case MEDIA_BUS_FMT_UYVY8_1X16:
1308 case MEDIA_BUS_FMT_YUYV8_1X16:
1309 case MEDIA_BUS_FMT_RGB888_1X24:
1310 break;
1311 default:
1312 return -EINVAL;
1313 }
1314
1315 adv7511_fill_format(state, &format->format);
1316 if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
1317 struct v4l2_mbus_framefmt *fmt;
1318
1319 fmt = v4l2_subdev_get_try_format(sd, sd_state, format->pad);
1320 fmt->code = format->format.code;
1321 fmt->colorspace = format->format.colorspace;
1322 fmt->ycbcr_enc = format->format.ycbcr_enc;
1323 fmt->quantization = format->format.quantization;
1324 fmt->xfer_func = format->format.xfer_func;
1325 return 0;
1326 }
1327
1328 switch (format->format.code) {
1329 case MEDIA_BUS_FMT_UYVY8_1X16:
1330 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x01);
1331 adv7511_wr_and_or(sd, 0x16, 0x03, 0xb8);
1332 y = HDMI_COLORSPACE_YUV422;
1333 break;
1334 case MEDIA_BUS_FMT_YUYV8_1X16:
1335 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x01);
1336 adv7511_wr_and_or(sd, 0x16, 0x03, 0xbc);
1337 y = HDMI_COLORSPACE_YUV422;
1338 break;
1339 case MEDIA_BUS_FMT_RGB888_1X24:
1340 default:
1341 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x00);
1342 adv7511_wr_and_or(sd, 0x16, 0x03, 0x00);
1343 break;
1344 }
1345 state->fmt_code = format->format.code;
1346 state->colorspace = format->format.colorspace;
1347 state->ycbcr_enc = format->format.ycbcr_enc;
1348 state->quantization = format->format.quantization;
1349 state->xfer_func = format->format.xfer_func;
1350
1351 switch (format->format.colorspace) {
1352 case V4L2_COLORSPACE_OPRGB:
1353 c = HDMI_COLORIMETRY_EXTENDED;
1354 ec = y ? HDMI_EXTENDED_COLORIMETRY_OPYCC_601 :
1355 HDMI_EXTENDED_COLORIMETRY_OPRGB;
1356 break;
1357 case V4L2_COLORSPACE_SMPTE170M:
1358 c = y ? HDMI_COLORIMETRY_ITU_601 : HDMI_COLORIMETRY_NONE;
1359 if (y && format->format.ycbcr_enc == V4L2_YCBCR_ENC_XV601) {
1360 c = HDMI_COLORIMETRY_EXTENDED;
1361 ec = HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
1362 }
1363 break;
1364 case V4L2_COLORSPACE_REC709:
1365 c = y ? HDMI_COLORIMETRY_ITU_709 : HDMI_COLORIMETRY_NONE;
1366 if (y && format->format.ycbcr_enc == V4L2_YCBCR_ENC_XV709) {
1367 c = HDMI_COLORIMETRY_EXTENDED;
1368 ec = HDMI_EXTENDED_COLORIMETRY_XV_YCC_709;
1369 }
1370 break;
1371 case V4L2_COLORSPACE_SRGB:
1372 c = y ? HDMI_COLORIMETRY_EXTENDED : HDMI_COLORIMETRY_NONE;
1373 ec = y ? HDMI_EXTENDED_COLORIMETRY_S_YCC_601 :
1374 HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
1375 break;
1376 case V4L2_COLORSPACE_BT2020:
1377 c = HDMI_COLORIMETRY_EXTENDED;
1378 if (y && format->format.ycbcr_enc == V4L2_YCBCR_ENC_BT2020_CONST_LUM)
1379 ec = 5; /* Not yet available in hdmi.h */
1380 else
1381 ec = 6; /* Not yet available in hdmi.h */
1382 break;
1383 default:
1384 break;
1385 }
1386
1387 /*
1388 * CEA-861-F says that for RGB formats the YCC range must match the
1389 * RGB range, although sources should ignore the YCC range.
1390 *
1391 * The RGB quantization range shouldn't be non-zero if the EDID doesn't
1392 * have the Q bit set in the Video Capabilities Data Block, however this
1393 * isn't checked at the moment. The assumption is that the application
1394 * knows the EDID and can detect this.
1395 *
1396 * The same is true for the YCC quantization range: non-standard YCC
1397 * quantization ranges should only be sent if the EDID has the YQ bit
1398 * set in the Video Capabilities Data Block.
1399 */
1400 switch (format->format.quantization) {
1401 case V4L2_QUANTIZATION_FULL_RANGE:
1402 q = y ? HDMI_QUANTIZATION_RANGE_DEFAULT :
1403 HDMI_QUANTIZATION_RANGE_FULL;
1404 yq = q ? q - 1 : HDMI_YCC_QUANTIZATION_RANGE_FULL;
1405 break;
1406 case V4L2_QUANTIZATION_LIM_RANGE:
1407 q = y ? HDMI_QUANTIZATION_RANGE_DEFAULT :
1408 HDMI_QUANTIZATION_RANGE_LIMITED;
1409 yq = q ? q - 1 : HDMI_YCC_QUANTIZATION_RANGE_LIMITED;
1410 break;
1411 }
1412
1413 adv7511_wr_and_or(sd, 0x4a, 0xbf, 0);
1414 adv7511_wr_and_or(sd, 0x55, 0x9f, y << 5);
1415 adv7511_wr_and_or(sd, 0x56, 0x3f, c << 6);
1416 adv7511_wr_and_or(sd, 0x57, 0x83, (ec << 4) | (q << 2) | (itc << 7));
1417 adv7511_wr_and_or(sd, 0x59, 0x0f, (yq << 6) | (cn << 4));
1418 adv7511_wr_and_or(sd, 0x4a, 0xff, 1);
1419 adv7511_set_rgb_quantization_mode(sd, state->rgb_quantization_range_ctrl);
1420
1421 return 0;
1422 }
1423
1424 static const struct v4l2_subdev_pad_ops adv7511_pad_ops = {
1425 .get_edid = adv7511_get_edid,
1426 .enum_mbus_code = adv7511_enum_mbus_code,
1427 .get_fmt = adv7511_get_fmt,
1428 .set_fmt = adv7511_set_fmt,
1429 .enum_dv_timings = adv7511_enum_dv_timings,
1430 .dv_timings_cap = adv7511_dv_timings_cap,
1431 };
1432
1433 /* --------------------- SUBDEV OPS --------------------------------------- */
1434
1435 static const struct v4l2_subdev_ops adv7511_ops = {
1436 .core = &adv7511_core_ops,
1437 .pad = &adv7511_pad_ops,
1438 .video = &adv7511_video_ops,
1439 .audio = &adv7511_audio_ops,
1440 };
1441
1442 /* ----------------------------------------------------------------------- */
adv7511_dbg_dump_edid(int lvl,int debug,struct v4l2_subdev * sd,int segment,u8 * buf)1443 static void adv7511_dbg_dump_edid(int lvl, int debug, struct v4l2_subdev *sd, int segment, u8 *buf)
1444 {
1445 if (debug >= lvl) {
1446 int i, j;
1447 v4l2_dbg(lvl, debug, sd, "edid segment %d\n", segment);
1448 for (i = 0; i < 256; i += 16) {
1449 u8 b[128];
1450 u8 *bp = b;
1451 if (i == 128)
1452 v4l2_dbg(lvl, debug, sd, "\n");
1453 for (j = i; j < i + 16; j++) {
1454 sprintf(bp, "0x%02x, ", buf[j]);
1455 bp += 6;
1456 }
1457 bp[0] = '\0';
1458 v4l2_dbg(lvl, debug, sd, "%s\n", b);
1459 }
1460 }
1461 }
1462
adv7511_notify_no_edid(struct v4l2_subdev * sd)1463 static void adv7511_notify_no_edid(struct v4l2_subdev *sd)
1464 {
1465 struct adv7511_state *state = get_adv7511_state(sd);
1466 struct adv7511_edid_detect ed;
1467
1468 /* We failed to read the EDID, so send an event for this. */
1469 ed.present = false;
1470 ed.segment = adv7511_rd(sd, 0xc4);
1471 ed.phys_addr = CEC_PHYS_ADDR_INVALID;
1472 cec_s_phys_addr(state->cec_adap, ed.phys_addr, false);
1473 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
1474 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, 0x0);
1475 }
1476
adv7511_edid_handler(struct work_struct * work)1477 static void adv7511_edid_handler(struct work_struct *work)
1478 {
1479 struct delayed_work *dwork = to_delayed_work(work);
1480 struct adv7511_state *state = container_of(dwork, struct adv7511_state, edid_handler);
1481 struct v4l2_subdev *sd = &state->sd;
1482
1483 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
1484
1485 if (adv7511_check_edid_status(sd)) {
1486 /* Return if we received the EDID. */
1487 return;
1488 }
1489
1490 if (adv7511_have_hotplug(sd)) {
1491 /* We must retry reading the EDID several times, it is possible
1492 * that initially the EDID couldn't be read due to i2c errors
1493 * (DVI connectors are particularly prone to this problem). */
1494 if (state->edid.read_retries) {
1495 state->edid.read_retries--;
1496 v4l2_dbg(1, debug, sd, "%s: edid read failed\n", __func__);
1497 state->have_monitor = false;
1498 adv7511_s_power(sd, false);
1499 adv7511_s_power(sd, true);
1500 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
1501 return;
1502 }
1503 }
1504
1505 /* We failed to read the EDID, so send an event for this. */
1506 adv7511_notify_no_edid(sd);
1507 v4l2_dbg(1, debug, sd, "%s: no edid found\n", __func__);
1508 }
1509
adv7511_audio_setup(struct v4l2_subdev * sd)1510 static void adv7511_audio_setup(struct v4l2_subdev *sd)
1511 {
1512 v4l2_dbg(1, debug, sd, "%s\n", __func__);
1513
1514 adv7511_s_i2s_clock_freq(sd, 48000);
1515 adv7511_s_clock_freq(sd, 48000);
1516 adv7511_s_routing(sd, 0, 0, 0);
1517 }
1518
1519 /* Configure hdmi transmitter. */
adv7511_setup(struct v4l2_subdev * sd)1520 static void adv7511_setup(struct v4l2_subdev *sd)
1521 {
1522 struct adv7511_state *state = get_adv7511_state(sd);
1523 v4l2_dbg(1, debug, sd, "%s\n", __func__);
1524
1525 /* Input format: RGB 4:4:4 */
1526 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x0);
1527 /* Output format: RGB 4:4:4 */
1528 adv7511_wr_and_or(sd, 0x16, 0x7f, 0x0);
1529 /* 1st order interpolation 4:2:2 -> 4:4:4 up conversion, Aspect ratio: 16:9 */
1530 adv7511_wr_and_or(sd, 0x17, 0xf9, 0x06);
1531 /* Disable pixel repetition */
1532 adv7511_wr_and_or(sd, 0x3b, 0x9f, 0x0);
1533 /* Disable CSC */
1534 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x0);
1535 /* Output format: RGB 4:4:4, Active Format Information is valid,
1536 * underscanned */
1537 adv7511_wr_and_or(sd, 0x55, 0x9c, 0x12);
1538 /* AVI Info frame packet enable, Audio Info frame disable */
1539 adv7511_wr_and_or(sd, 0x44, 0xe7, 0x10);
1540 /* Colorimetry, Active format aspect ratio: same as picure. */
1541 adv7511_wr(sd, 0x56, 0xa8);
1542 /* No encryption */
1543 adv7511_wr_and_or(sd, 0xaf, 0xed, 0x0);
1544
1545 /* Positive clk edge capture for input video clock */
1546 adv7511_wr_and_or(sd, 0xba, 0x1f, 0x60);
1547
1548 adv7511_audio_setup(sd);
1549
1550 v4l2_ctrl_handler_setup(&state->hdl);
1551 }
1552
adv7511_notify_monitor_detect(struct v4l2_subdev * sd)1553 static void adv7511_notify_monitor_detect(struct v4l2_subdev *sd)
1554 {
1555 struct adv7511_monitor_detect mdt;
1556 struct adv7511_state *state = get_adv7511_state(sd);
1557
1558 mdt.present = state->have_monitor;
1559 v4l2_subdev_notify(sd, ADV7511_MONITOR_DETECT, (void *)&mdt);
1560 }
1561
adv7511_check_monitor_present_status(struct v4l2_subdev * sd)1562 static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd)
1563 {
1564 struct adv7511_state *state = get_adv7511_state(sd);
1565 /* read hotplug and rx-sense state */
1566 u8 status = adv7511_rd(sd, 0x42);
1567
1568 v4l2_dbg(1, debug, sd, "%s: status: 0x%x%s%s\n",
1569 __func__,
1570 status,
1571 status & MASK_ADV7511_HPD_DETECT ? ", hotplug" : "",
1572 status & MASK_ADV7511_MSEN_DETECT ? ", rx-sense" : "");
1573
1574 /* update read only ctrls */
1575 v4l2_ctrl_s_ctrl(state->hotplug_ctrl, adv7511_have_hotplug(sd) ? 0x1 : 0x0);
1576 v4l2_ctrl_s_ctrl(state->rx_sense_ctrl, adv7511_have_rx_sense(sd) ? 0x1 : 0x0);
1577
1578 if ((status & MASK_ADV7511_HPD_DETECT) && ((status & MASK_ADV7511_MSEN_DETECT) || state->edid.segments)) {
1579 v4l2_dbg(1, debug, sd, "%s: hotplug and (rx-sense or edid)\n", __func__);
1580 if (!state->have_monitor) {
1581 v4l2_dbg(1, debug, sd, "%s: monitor detected\n", __func__);
1582 state->have_monitor = true;
1583 adv7511_set_isr(sd, true);
1584 if (!adv7511_s_power(sd, true)) {
1585 v4l2_dbg(1, debug, sd, "%s: monitor detected, powerup failed\n", __func__);
1586 return;
1587 }
1588 adv7511_setup(sd);
1589 adv7511_notify_monitor_detect(sd);
1590 state->edid.read_retries = EDID_MAX_RETRIES;
1591 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
1592 }
1593 } else if (status & MASK_ADV7511_HPD_DETECT) {
1594 v4l2_dbg(1, debug, sd, "%s: hotplug detected\n", __func__);
1595 state->edid.read_retries = EDID_MAX_RETRIES;
1596 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
1597 } else if (!(status & MASK_ADV7511_HPD_DETECT)) {
1598 v4l2_dbg(1, debug, sd, "%s: hotplug not detected\n", __func__);
1599 if (state->have_monitor) {
1600 v4l2_dbg(1, debug, sd, "%s: monitor not detected\n", __func__);
1601 state->have_monitor = false;
1602 adv7511_notify_monitor_detect(sd);
1603 }
1604 adv7511_s_power(sd, false);
1605 memset(&state->edid, 0, sizeof(struct adv7511_state_edid));
1606 adv7511_notify_no_edid(sd);
1607 }
1608 }
1609
edid_block_verify_crc(u8 * edid_block)1610 static bool edid_block_verify_crc(u8 *edid_block)
1611 {
1612 u8 sum = 0;
1613 int i;
1614
1615 for (i = 0; i < 128; i++)
1616 sum += edid_block[i];
1617 return sum == 0;
1618 }
1619
edid_verify_crc(struct v4l2_subdev * sd,u32 segment)1620 static bool edid_verify_crc(struct v4l2_subdev *sd, u32 segment)
1621 {
1622 struct adv7511_state *state = get_adv7511_state(sd);
1623 u32 blocks = state->edid.blocks;
1624 u8 *data = state->edid.data;
1625
1626 if (!edid_block_verify_crc(&data[segment * 256]))
1627 return false;
1628 if ((segment + 1) * 2 <= blocks)
1629 return edid_block_verify_crc(&data[segment * 256 + 128]);
1630 return true;
1631 }
1632
edid_verify_header(struct v4l2_subdev * sd,u32 segment)1633 static bool edid_verify_header(struct v4l2_subdev *sd, u32 segment)
1634 {
1635 static const u8 hdmi_header[] = {
1636 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00
1637 };
1638 struct adv7511_state *state = get_adv7511_state(sd);
1639 u8 *data = state->edid.data;
1640
1641 if (segment != 0)
1642 return true;
1643 return !memcmp(data, hdmi_header, sizeof(hdmi_header));
1644 }
1645
adv7511_check_edid_status(struct v4l2_subdev * sd)1646 static bool adv7511_check_edid_status(struct v4l2_subdev *sd)
1647 {
1648 struct adv7511_state *state = get_adv7511_state(sd);
1649 u8 edidRdy = adv7511_rd(sd, 0xc5);
1650
1651 v4l2_dbg(1, debug, sd, "%s: edid ready (retries: %d)\n",
1652 __func__, EDID_MAX_RETRIES - state->edid.read_retries);
1653
1654 if (state->edid.complete)
1655 return true;
1656
1657 if (edidRdy & MASK_ADV7511_EDID_RDY) {
1658 int segment = adv7511_rd(sd, 0xc4);
1659 struct adv7511_edid_detect ed;
1660 int err;
1661
1662 if (segment >= EDID_MAX_SEGM) {
1663 v4l2_err(sd, "edid segment number too big\n");
1664 return false;
1665 }
1666 v4l2_dbg(1, debug, sd, "%s: got segment %d\n", __func__, segment);
1667 err = adv7511_edid_rd(sd, 256, &state->edid.data[segment * 256]);
1668 if (!err) {
1669 adv7511_dbg_dump_edid(2, debug, sd, segment, &state->edid.data[segment * 256]);
1670 if (segment == 0) {
1671 state->edid.blocks = state->edid.data[0x7e] + 1;
1672 v4l2_dbg(1, debug, sd, "%s: %d blocks in total\n",
1673 __func__, state->edid.blocks);
1674 }
1675 }
1676
1677 if (err || !edid_verify_crc(sd, segment) || !edid_verify_header(sd, segment)) {
1678 /* Couldn't read EDID or EDID is invalid. Force retry! */
1679 if (!err)
1680 v4l2_err(sd, "%s: edid crc or header error\n", __func__);
1681 state->have_monitor = false;
1682 adv7511_s_power(sd, false);
1683 adv7511_s_power(sd, true);
1684 return false;
1685 }
1686 /* one more segment read ok */
1687 state->edid.segments = segment + 1;
1688 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, 0x1);
1689 if (((state->edid.data[0x7e] >> 1) + 1) > state->edid.segments) {
1690 /* Request next EDID segment */
1691 v4l2_dbg(1, debug, sd, "%s: request segment %d\n", __func__, state->edid.segments);
1692 adv7511_wr(sd, 0xc9, 0xf);
1693 adv7511_wr(sd, 0xc4, state->edid.segments);
1694 state->edid.read_retries = EDID_MAX_RETRIES;
1695 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
1696 return false;
1697 }
1698
1699 v4l2_dbg(1, debug, sd, "%s: edid complete with %d segment(s)\n", __func__, state->edid.segments);
1700 state->edid.complete = true;
1701 ed.phys_addr = cec_get_edid_phys_addr(state->edid.data,
1702 state->edid.segments * 256,
1703 NULL);
1704 /* report when we have all segments
1705 but report only for segment 0
1706 */
1707 ed.present = true;
1708 ed.segment = 0;
1709 state->edid_detect_counter++;
1710 cec_s_phys_addr(state->cec_adap, ed.phys_addr, false);
1711 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
1712 return ed.present;
1713 }
1714
1715 return false;
1716 }
1717
adv7511_registered(struct v4l2_subdev * sd)1718 static int adv7511_registered(struct v4l2_subdev *sd)
1719 {
1720 struct adv7511_state *state = get_adv7511_state(sd);
1721 struct i2c_client *client = v4l2_get_subdevdata(sd);
1722 int err;
1723
1724 err = cec_register_adapter(state->cec_adap, &client->dev);
1725 if (err)
1726 cec_delete_adapter(state->cec_adap);
1727 return err;
1728 }
1729
adv7511_unregistered(struct v4l2_subdev * sd)1730 static void adv7511_unregistered(struct v4l2_subdev *sd)
1731 {
1732 struct adv7511_state *state = get_adv7511_state(sd);
1733
1734 cec_unregister_adapter(state->cec_adap);
1735 }
1736
1737 static const struct v4l2_subdev_internal_ops adv7511_int_ops = {
1738 .registered = adv7511_registered,
1739 .unregistered = adv7511_unregistered,
1740 };
1741
1742 /* ----------------------------------------------------------------------- */
1743 /* Setup ADV7511 */
adv7511_init_setup(struct v4l2_subdev * sd)1744 static void adv7511_init_setup(struct v4l2_subdev *sd)
1745 {
1746 struct adv7511_state *state = get_adv7511_state(sd);
1747 struct adv7511_state_edid *edid = &state->edid;
1748 u32 cec_clk = state->pdata.cec_clk;
1749 u8 ratio;
1750
1751 v4l2_dbg(1, debug, sd, "%s\n", __func__);
1752
1753 /* clear all interrupts */
1754 adv7511_wr(sd, 0x96, 0xff);
1755 adv7511_wr(sd, 0x97, 0xff);
1756 /*
1757 * Stop HPD from resetting a lot of registers.
1758 * It might leave the chip in a partly un-initialized state,
1759 * in particular with regards to hotplug bounces.
1760 */
1761 adv7511_wr_and_or(sd, 0xd6, 0x3f, 0xc0);
1762 memset(edid, 0, sizeof(struct adv7511_state_edid));
1763 state->have_monitor = false;
1764 adv7511_set_isr(sd, false);
1765 adv7511_s_stream(sd, false);
1766 adv7511_s_audio_stream(sd, false);
1767
1768 if (state->i2c_cec == NULL)
1769 return;
1770
1771 v4l2_dbg(1, debug, sd, "%s: cec_clk %d\n", __func__, cec_clk);
1772
1773 /* cec soft reset */
1774 adv7511_cec_write(sd, 0x50, 0x01);
1775 adv7511_cec_write(sd, 0x50, 0x00);
1776
1777 /* legacy mode */
1778 adv7511_cec_write(sd, 0x4a, 0x00);
1779 adv7511_cec_write(sd, 0x4a, 0x07);
1780
1781 if (cec_clk % 750000 != 0)
1782 v4l2_err(sd, "%s: cec_clk %d, not multiple of 750 Khz\n",
1783 __func__, cec_clk);
1784
1785 ratio = (cec_clk / 750000) - 1;
1786 adv7511_cec_write(sd, 0x4e, ratio << 2);
1787 }
1788
adv7511_probe(struct i2c_client * client,const struct i2c_device_id * id)1789 static int adv7511_probe(struct i2c_client *client, const struct i2c_device_id *id)
1790 {
1791 struct adv7511_state *state;
1792 struct adv7511_platform_data *pdata = client->dev.platform_data;
1793 struct v4l2_ctrl_handler *hdl;
1794 struct v4l2_subdev *sd;
1795 u8 chip_id[2];
1796 int err = -EIO;
1797
1798 /* Check if the adapter supports the needed features */
1799 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1800 return -EIO;
1801
1802 state = devm_kzalloc(&client->dev, sizeof(struct adv7511_state), GFP_KERNEL);
1803 if (!state)
1804 return -ENOMEM;
1805
1806 /* Platform data */
1807 if (!pdata) {
1808 v4l_err(client, "No platform data!\n");
1809 return -ENODEV;
1810 }
1811 memcpy(&state->pdata, pdata, sizeof(state->pdata));
1812 state->fmt_code = MEDIA_BUS_FMT_RGB888_1X24;
1813 state->colorspace = V4L2_COLORSPACE_SRGB;
1814
1815 sd = &state->sd;
1816
1817 v4l2_dbg(1, debug, sd, "detecting adv7511 client on address 0x%x\n",
1818 client->addr << 1);
1819
1820 v4l2_i2c_subdev_init(sd, client, &adv7511_ops);
1821 sd->internal_ops = &adv7511_int_ops;
1822
1823 hdl = &state->hdl;
1824 v4l2_ctrl_handler_init(hdl, 10);
1825 /* add in ascending ID order */
1826 state->hdmi_mode_ctrl = v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1827 V4L2_CID_DV_TX_MODE, V4L2_DV_TX_MODE_HDMI,
1828 0, V4L2_DV_TX_MODE_DVI_D);
1829 state->hotplug_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1830 V4L2_CID_DV_TX_HOTPLUG, 0, 1, 0, 0);
1831 state->rx_sense_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1832 V4L2_CID_DV_TX_RXSENSE, 0, 1, 0, 0);
1833 state->have_edid0_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1834 V4L2_CID_DV_TX_EDID_PRESENT, 0, 1, 0, 0);
1835 state->rgb_quantization_range_ctrl =
1836 v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1837 V4L2_CID_DV_TX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
1838 0, V4L2_DV_RGB_RANGE_AUTO);
1839 state->content_type_ctrl =
1840 v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1841 V4L2_CID_DV_TX_IT_CONTENT_TYPE, V4L2_DV_IT_CONTENT_TYPE_NO_ITC,
1842 0, V4L2_DV_IT_CONTENT_TYPE_NO_ITC);
1843 sd->ctrl_handler = hdl;
1844 if (hdl->error) {
1845 err = hdl->error;
1846 goto err_hdl;
1847 }
1848 state->pad.flags = MEDIA_PAD_FL_SINK;
1849 sd->entity.function = MEDIA_ENT_F_DV_ENCODER;
1850 err = media_entity_pads_init(&sd->entity, 1, &state->pad);
1851 if (err)
1852 goto err_hdl;
1853
1854 /* EDID and CEC i2c addr */
1855 state->i2c_edid_addr = state->pdata.i2c_edid << 1;
1856 state->i2c_cec_addr = state->pdata.i2c_cec << 1;
1857 state->i2c_pktmem_addr = state->pdata.i2c_pktmem << 1;
1858
1859 state->chip_revision = adv7511_rd(sd, 0x0);
1860 chip_id[0] = adv7511_rd(sd, 0xf5);
1861 chip_id[1] = adv7511_rd(sd, 0xf6);
1862 if (chip_id[0] != 0x75 || chip_id[1] != 0x11) {
1863 v4l2_err(sd, "chip_id != 0x7511, read 0x%02x%02x\n", chip_id[0],
1864 chip_id[1]);
1865 err = -EIO;
1866 goto err_entity;
1867 }
1868
1869 state->i2c_edid = i2c_new_dummy_device(client->adapter,
1870 state->i2c_edid_addr >> 1);
1871 if (IS_ERR(state->i2c_edid)) {
1872 v4l2_err(sd, "failed to register edid i2c client\n");
1873 err = PTR_ERR(state->i2c_edid);
1874 goto err_entity;
1875 }
1876
1877 adv7511_wr(sd, 0xe1, state->i2c_cec_addr);
1878 if (state->pdata.cec_clk < 3000000 ||
1879 state->pdata.cec_clk > 100000000) {
1880 v4l2_err(sd, "%s: cec_clk %u outside range, disabling cec\n",
1881 __func__, state->pdata.cec_clk);
1882 state->pdata.cec_clk = 0;
1883 }
1884
1885 if (state->pdata.cec_clk) {
1886 state->i2c_cec = i2c_new_dummy_device(client->adapter,
1887 state->i2c_cec_addr >> 1);
1888 if (IS_ERR(state->i2c_cec)) {
1889 v4l2_err(sd, "failed to register cec i2c client\n");
1890 err = PTR_ERR(state->i2c_cec);
1891 goto err_unreg_edid;
1892 }
1893 adv7511_wr(sd, 0xe2, 0x00); /* power up cec section */
1894 } else {
1895 adv7511_wr(sd, 0xe2, 0x01); /* power down cec section */
1896 }
1897
1898 state->i2c_pktmem = i2c_new_dummy_device(client->adapter, state->i2c_pktmem_addr >> 1);
1899 if (IS_ERR(state->i2c_pktmem)) {
1900 v4l2_err(sd, "failed to register pktmem i2c client\n");
1901 err = PTR_ERR(state->i2c_pktmem);
1902 goto err_unreg_cec;
1903 }
1904
1905 state->work_queue = create_singlethread_workqueue(sd->name);
1906 if (state->work_queue == NULL) {
1907 v4l2_err(sd, "could not create workqueue\n");
1908 err = -ENOMEM;
1909 goto err_unreg_pktmem;
1910 }
1911
1912 INIT_DELAYED_WORK(&state->edid_handler, adv7511_edid_handler);
1913
1914 adv7511_init_setup(sd);
1915
1916 #if IS_ENABLED(CONFIG_VIDEO_ADV7511_CEC)
1917 state->cec_adap = cec_allocate_adapter(&adv7511_cec_adap_ops,
1918 state, dev_name(&client->dev), CEC_CAP_DEFAULTS,
1919 ADV7511_MAX_ADDRS);
1920 err = PTR_ERR_OR_ZERO(state->cec_adap);
1921 if (err) {
1922 destroy_workqueue(state->work_queue);
1923 goto err_unreg_pktmem;
1924 }
1925 #endif
1926
1927 adv7511_set_isr(sd, true);
1928 adv7511_check_monitor_present_status(sd);
1929
1930 v4l2_info(sd, "%s found @ 0x%x (%s)\n", client->name,
1931 client->addr << 1, client->adapter->name);
1932 return 0;
1933
1934 err_unreg_pktmem:
1935 i2c_unregister_device(state->i2c_pktmem);
1936 err_unreg_cec:
1937 i2c_unregister_device(state->i2c_cec);
1938 err_unreg_edid:
1939 i2c_unregister_device(state->i2c_edid);
1940 err_entity:
1941 media_entity_cleanup(&sd->entity);
1942 err_hdl:
1943 v4l2_ctrl_handler_free(&state->hdl);
1944 return err;
1945 }
1946
1947 /* ----------------------------------------------------------------------- */
1948
adv7511_remove(struct i2c_client * client)1949 static int adv7511_remove(struct i2c_client *client)
1950 {
1951 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1952 struct adv7511_state *state = get_adv7511_state(sd);
1953
1954 state->chip_revision = -1;
1955
1956 v4l2_dbg(1, debug, sd, "%s removed @ 0x%x (%s)\n", client->name,
1957 client->addr << 1, client->adapter->name);
1958
1959 adv7511_set_isr(sd, false);
1960 adv7511_init_setup(sd);
1961 cancel_delayed_work_sync(&state->edid_handler);
1962 i2c_unregister_device(state->i2c_edid);
1963 i2c_unregister_device(state->i2c_cec);
1964 i2c_unregister_device(state->i2c_pktmem);
1965 destroy_workqueue(state->work_queue);
1966 v4l2_device_unregister_subdev(sd);
1967 media_entity_cleanup(&sd->entity);
1968 v4l2_ctrl_handler_free(sd->ctrl_handler);
1969 return 0;
1970 }
1971
1972 /* ----------------------------------------------------------------------- */
1973
1974 static const struct i2c_device_id adv7511_id[] = {
1975 { "adv7511-v4l2", 0 },
1976 { }
1977 };
1978 MODULE_DEVICE_TABLE(i2c, adv7511_id);
1979
1980 static struct i2c_driver adv7511_driver = {
1981 .driver = {
1982 .name = "adv7511-v4l2",
1983 },
1984 .probe = adv7511_probe,
1985 .remove = adv7511_remove,
1986 .id_table = adv7511_id,
1987 };
1988
1989 module_i2c_driver(adv7511_driver);
1990