?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
jme: Do not enable NIC WoL functions on S0
[linux/fpc-iii.git] / drivers / media / i2c / adv7511.c
blob621e4c0582975c8196e02a59fbc4f966e8e1e047
1 /*
2 * Analog Devices ADV7511 HDMI Transmitter Device Driver
3 *
4 * Copyright 2013 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
5 *
6 * This program is free software; you may redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
11 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
12 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
13 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
14 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
15 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
16 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17 * SOFTWARE.
18 */
19
20
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/slab.h>
24 #include <linux/i2c.h>
25 #include <linux/delay.h>
26 #include <linux/videodev2.h>
27 #include <linux/gpio.h>
28 #include <linux/workqueue.h>
29 #include <linux/v4l2-dv-timings.h>
30 #include <media/v4l2-device.h>
31 #include <media/v4l2-common.h>
32 #include <media/v4l2-ctrls.h>
33 #include <media/v4l2-dv-timings.h>
34 #include <media/adv7511.h>
35
36 static int debug;
37 module_param(debug, int, 0644);
38 MODULE_PARM_DESC(debug, "debug level (0-2)");
39
40 MODULE_DESCRIPTION("Analog Devices ADV7511 HDMI Transmitter Device Driver");
41 MODULE_AUTHOR("Hans Verkuil");
42 MODULE_LICENSE("GPL");
43
44 #define MASK_ADV7511_EDID_RDY_INT 0x04
45 #define MASK_ADV7511_MSEN_INT 0x40
46 #define MASK_ADV7511_HPD_INT 0x80
47
48 #define MASK_ADV7511_HPD_DETECT 0x40
49 #define MASK_ADV7511_MSEN_DETECT 0x20
50 #define MASK_ADV7511_EDID_RDY 0x10
51
52 #define EDID_MAX_RETRIES (8)
53 #define EDID_DELAY 250
54 #define EDID_MAX_SEGM 8
55
56 #define ADV7511_MAX_WIDTH 1920
57 #define ADV7511_MAX_HEIGHT 1200
58 #define ADV7511_MIN_PIXELCLOCK 20000000
59 #define ADV7511_MAX_PIXELCLOCK 225000000
60
61 /*
62 **********************************************************************
63 *
64 * Arrays with configuration parameters for the ADV7511
65 *
66 **********************************************************************
67 */
68
69 struct i2c_reg_value {
70 unsigned char reg;
71 unsigned char value;
72 };
73
74 struct adv7511_state_edid {
75 /* total number of blocks */
76 u32 blocks;
77 /* Number of segments read */
78 u32 segments;
79 uint8_t data[EDID_MAX_SEGM * 256];
80 /* Number of EDID read retries left */
81 unsigned read_retries;
82 bool complete;
83 };
84
85 struct adv7511_state {
86 struct adv7511_platform_data pdata;
87 struct v4l2_subdev sd;
88 struct media_pad pad;
89 struct v4l2_ctrl_handler hdl;
90 int chip_revision;
91 uint8_t i2c_edid_addr;
92 uint8_t i2c_cec_addr;
93 /* Is the adv7511 powered on? */
94 bool power_on;
95 /* Did we receive hotplug and rx-sense signals? */
96 bool have_monitor;
97 /* timings from s_dv_timings */
98 struct v4l2_dv_timings dv_timings;
99 /* controls */
100 struct v4l2_ctrl *hdmi_mode_ctrl;
101 struct v4l2_ctrl *hotplug_ctrl;
102 struct v4l2_ctrl *rx_sense_ctrl;
103 struct v4l2_ctrl *have_edid0_ctrl;
104 struct v4l2_ctrl *rgb_quantization_range_ctrl;
105 struct i2c_client *i2c_edid;
106 struct adv7511_state_edid edid;
107 /* Running counter of the number of detected EDIDs (for debugging) */
108 unsigned edid_detect_counter;
109 struct workqueue_struct *work_queue;
110 struct delayed_work edid_handler; /* work entry */
111 };
112
113 static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd);
114 static bool adv7511_check_edid_status(struct v4l2_subdev *sd);
115 static void adv7511_setup(struct v4l2_subdev *sd);
116 static int adv7511_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq);
117 static int adv7511_s_clock_freq(struct v4l2_subdev *sd, u32 freq);
118
119
120 static const struct v4l2_dv_timings_cap adv7511_timings_cap = {
121 .type = V4L2_DV_BT_656_1120,
122 /* keep this initialization for compatibility with GCC < 4.4.6 */
123 .reserved = { 0 },
124 V4L2_INIT_BT_TIMINGS(0, ADV7511_MAX_WIDTH, 0, ADV7511_MAX_HEIGHT,
125 ADV7511_MIN_PIXELCLOCK, ADV7511_MAX_PIXELCLOCK,
126 V4L2_DV_BT_STD_CEA861 | V4L2_DV_BT_STD_DMT |
127 V4L2_DV_BT_STD_GTF | V4L2_DV_BT_STD_CVT,
128 V4L2_DV_BT_CAP_PROGRESSIVE | V4L2_DV_BT_CAP_REDUCED_BLANKING |
129 V4L2_DV_BT_CAP_CUSTOM)
130 };
131
132 static inline struct adv7511_state *get_adv7511_state(struct v4l2_subdev *sd)
133 {
134 return container_of(sd, struct adv7511_state, sd);
135 }
136
137 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
138 {
139 return &container_of(ctrl->handler, struct adv7511_state, hdl)->sd;
140 }
141
142 /* ------------------------ I2C ----------------------------------------------- */
143
144 static s32 adv_smbus_read_byte_data_check(struct i2c_client *client,
145 u8 command, bool check)
146 {
147 union i2c_smbus_data data;
148
149 if (!i2c_smbus_xfer(client->adapter, client->addr, client->flags,
150 I2C_SMBUS_READ, command,
151 I2C_SMBUS_BYTE_DATA, &data))
152 return data.byte;
153 if (check)
154 v4l_err(client, "error reading %02x, %02x\n",
155 client->addr, command);
156 return -1;
157 }
158
159 static s32 adv_smbus_read_byte_data(struct i2c_client *client, u8 command)
160 {
161 int i;
162 for (i = 0; i < 3; i++) {
163 int ret = adv_smbus_read_byte_data_check(client, command, true);
164 if (ret >= 0) {
165 if (i)
166 v4l_err(client, "read ok after %d retries\n", i);
167 return ret;
168 }
169 }
170 v4l_err(client, "read failed\n");
171 return -1;
172 }
173
174 static int adv7511_rd(struct v4l2_subdev *sd, u8 reg)
175 {
176 struct i2c_client *client = v4l2_get_subdevdata(sd);
177
178 return adv_smbus_read_byte_data(client, reg);
179 }
180
181 static int adv7511_wr(struct v4l2_subdev *sd, u8 reg, u8 val)
182 {
183 struct i2c_client *client = v4l2_get_subdevdata(sd);
184 int ret;
185 int i;
186
187 for (i = 0; i < 3; i++) {
188 ret = i2c_smbus_write_byte_data(client, reg, val);
189 if (ret == 0)
190 return 0;
191 }
192 v4l2_err(sd, "%s: i2c write error\n", __func__);
193 return ret;
194 }
195
196 /* To set specific bits in the register, a clear-mask is given (to be AND-ed),
197 and then the value-mask (to be OR-ed). */
198 static inline void adv7511_wr_and_or(struct v4l2_subdev *sd, u8 reg, uint8_t clr_mask, uint8_t val_mask)
199 {
200 adv7511_wr(sd, reg, (adv7511_rd(sd, reg) & clr_mask) | val_mask);
201 }
202
203 static int adv_smbus_read_i2c_block_data(struct i2c_client *client,
204 u8 command, unsigned length, u8 *values)
205 {
206 union i2c_smbus_data data;
207 int ret;
208
209 if (length > I2C_SMBUS_BLOCK_MAX)
210 length = I2C_SMBUS_BLOCK_MAX;
211 data.block[0] = length;
212
213 ret = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
214 I2C_SMBUS_READ, command,
215 I2C_SMBUS_I2C_BLOCK_DATA, &data);
216 memcpy(values, data.block + 1, length);
217 return ret;
218 }
219
220 static inline void adv7511_edid_rd(struct v4l2_subdev *sd, uint16_t len, uint8_t *buf)
221 {
222 struct adv7511_state *state = get_adv7511_state(sd);
223 int i;
224 int err = 0;
225
226 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
227
228 for (i = 0; !err && i < len; i += I2C_SMBUS_BLOCK_MAX)
229 err = adv_smbus_read_i2c_block_data(state->i2c_edid, i,
230 I2C_SMBUS_BLOCK_MAX, buf + i);
231 if (err)
232 v4l2_err(sd, "%s: i2c read error\n", __func__);
233 }
234
235 static inline bool adv7511_have_hotplug(struct v4l2_subdev *sd)
236 {
237 return adv7511_rd(sd, 0x42) & MASK_ADV7511_HPD_DETECT;
238 }
239
240 static inline bool adv7511_have_rx_sense(struct v4l2_subdev *sd)
241 {
242 return adv7511_rd(sd, 0x42) & MASK_ADV7511_MSEN_DETECT;
243 }
244
245 static void adv7511_csc_conversion_mode(struct v4l2_subdev *sd, uint8_t mode)
246 {
247 adv7511_wr_and_or(sd, 0x18, 0x9f, (mode & 0x3)<<5);
248 }
249
250 static void adv7511_csc_coeff(struct v4l2_subdev *sd,
251 u16 A1, u16 A2, u16 A3, u16 A4,
252 u16 B1, u16 B2, u16 B3, u16 B4,
253 u16 C1, u16 C2, u16 C3, u16 C4)
254 {
255 /* A */
256 adv7511_wr_and_or(sd, 0x18, 0xe0, A1>>8);
257 adv7511_wr(sd, 0x19, A1);
258 adv7511_wr_and_or(sd, 0x1A, 0xe0, A2>>8);
259 adv7511_wr(sd, 0x1B, A2);
260 adv7511_wr_and_or(sd, 0x1c, 0xe0, A3>>8);
261 adv7511_wr(sd, 0x1d, A3);
262 adv7511_wr_and_or(sd, 0x1e, 0xe0, A4>>8);
263 adv7511_wr(sd, 0x1f, A4);
264
265 /* B */
266 adv7511_wr_and_or(sd, 0x20, 0xe0, B1>>8);
267 adv7511_wr(sd, 0x21, B1);
268 adv7511_wr_and_or(sd, 0x22, 0xe0, B2>>8);
269 adv7511_wr(sd, 0x23, B2);
270 adv7511_wr_and_or(sd, 0x24, 0xe0, B3>>8);
271 adv7511_wr(sd, 0x25, B3);
272 adv7511_wr_and_or(sd, 0x26, 0xe0, B4>>8);
273 adv7511_wr(sd, 0x27, B4);
274
275 /* C */
276 adv7511_wr_and_or(sd, 0x28, 0xe0, C1>>8);
277 adv7511_wr(sd, 0x29, C1);
278 adv7511_wr_and_or(sd, 0x2A, 0xe0, C2>>8);
279 adv7511_wr(sd, 0x2B, C2);
280 adv7511_wr_and_or(sd, 0x2C, 0xe0, C3>>8);
281 adv7511_wr(sd, 0x2D, C3);
282 adv7511_wr_and_or(sd, 0x2E, 0xe0, C4>>8);
283 adv7511_wr(sd, 0x2F, C4);
284 }
285
286 static void adv7511_csc_rgb_full2limit(struct v4l2_subdev *sd, bool enable)
287 {
288 if (enable) {
289 uint8_t csc_mode = 0;
290 adv7511_csc_conversion_mode(sd, csc_mode);
291 adv7511_csc_coeff(sd,
292 4096-564, 0, 0, 256,
293 0, 4096-564, 0, 256,
294 0, 0, 4096-564, 256);
295 /* enable CSC */
296 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x80);
297 /* AVI infoframe: Limited range RGB (16-235) */
298 adv7511_wr_and_or(sd, 0x57, 0xf3, 0x04);
299 } else {
300 /* disable CSC */
301 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x0);
302 /* AVI infoframe: Full range RGB (0-255) */
303 adv7511_wr_and_or(sd, 0x57, 0xf3, 0x08);
304 }
305 }
306
307 static void adv7511_set_IT_content_AVI_InfoFrame(struct v4l2_subdev *sd)
308 {
309 struct adv7511_state *state = get_adv7511_state(sd);
310 if (state->dv_timings.bt.standards & V4L2_DV_BT_STD_CEA861) {
311 /* CEA format, not IT */
312 adv7511_wr_and_or(sd, 0x57, 0x7f, 0x00);
313 } else {
314 /* IT format */
315 adv7511_wr_and_or(sd, 0x57, 0x7f, 0x80);
316 }
317 }
318
319 static int adv7511_set_rgb_quantization_mode(struct v4l2_subdev *sd, struct v4l2_ctrl *ctrl)
320 {
321 switch (ctrl->val) {
322 default:
323 return -EINVAL;
324 break;
325 case V4L2_DV_RGB_RANGE_AUTO: {
326 /* automatic */
327 struct adv7511_state *state = get_adv7511_state(sd);
328
329 if (state->dv_timings.bt.standards & V4L2_DV_BT_STD_CEA861) {
330 /* cea format, RGB limited range (16-235) */
331 adv7511_csc_rgb_full2limit(sd, true);
332 } else {
333 /* not cea format, RGB full range (0-255) */
334 adv7511_csc_rgb_full2limit(sd, false);
335 }
336 }
337 break;
338 case V4L2_DV_RGB_RANGE_LIMITED:
339 /* RGB limited range (16-235) */
340 adv7511_csc_rgb_full2limit(sd, true);
341 break;
342 case V4L2_DV_RGB_RANGE_FULL:
343 /* RGB full range (0-255) */
344 adv7511_csc_rgb_full2limit(sd, false);
345 break;
346 }
347 return 0;
348 }
349
350 /* ------------------------------ CTRL OPS ------------------------------ */
351
352 static int adv7511_s_ctrl(struct v4l2_ctrl *ctrl)
353 {
354 struct v4l2_subdev *sd = to_sd(ctrl);
355 struct adv7511_state *state = get_adv7511_state(sd);
356
357 v4l2_dbg(1, debug, sd, "%s: ctrl id: %d, ctrl->val %d\n", __func__, ctrl->id, ctrl->val);
358
359 if (state->hdmi_mode_ctrl == ctrl) {
360 /* Set HDMI or DVI-D */
361 adv7511_wr_and_or(sd, 0xaf, 0xfd, ctrl->val == V4L2_DV_TX_MODE_HDMI ? 0x02 : 0x00);
362 return 0;
363 }
364 if (state->rgb_quantization_range_ctrl == ctrl)
365 return adv7511_set_rgb_quantization_mode(sd, ctrl);
366
367 return -EINVAL;
368 }
369
370 static const struct v4l2_ctrl_ops adv7511_ctrl_ops = {
371 .s_ctrl = adv7511_s_ctrl,
372 };
373
374 /* ---------------------------- CORE OPS ------------------------------------------- */
375
376 #ifdef CONFIG_VIDEO_ADV_DEBUG
377 static void adv7511_inv_register(struct v4l2_subdev *sd)
378 {
379 v4l2_info(sd, "0x000-0x0ff: Main Map\n");
380 }
381
382 static int adv7511_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
383 {
384 reg->size = 1;
385 switch (reg->reg >> 8) {
386 case 0:
387 reg->val = adv7511_rd(sd, reg->reg & 0xff);
388 break;
389 default:
390 v4l2_info(sd, "Register %03llx not supported\n", reg->reg);
391 adv7511_inv_register(sd);
392 break;
393 }
394 return 0;
395 }
396
397 static int adv7511_s_register(struct v4l2_subdev *sd, const struct v4l2_dbg_register *reg)
398 {
399 switch (reg->reg >> 8) {
400 case 0:
401 adv7511_wr(sd, reg->reg & 0xff, reg->val & 0xff);
402 break;
403 default:
404 v4l2_info(sd, "Register %03llx not supported\n", reg->reg);
405 adv7511_inv_register(sd);
406 break;
407 }
408 return 0;
409 }
410 #endif
411
412 static int adv7511_log_status(struct v4l2_subdev *sd)
413 {
414 struct adv7511_state *state = get_adv7511_state(sd);
415 struct adv7511_state_edid *edid = &state->edid;
416
417 static const char * const states[] = {
418 "in reset",
419 "reading EDID",
420 "idle",
421 "initializing HDCP",
422 "HDCP enabled",
423 "initializing HDCP repeater",
424 "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"
425 };
426 static const char * const errors[] = {
427 "no error",
428 "bad receiver BKSV",
429 "Ri mismatch",
430 "Pj mismatch",
431 "i2c error",
432 "timed out",
433 "max repeater cascade exceeded",
434 "hash check failed",
435 "too many devices",
436 "9", "A", "B", "C", "D", "E", "F"
437 };
438
439 v4l2_info(sd, "power %s\n", state->power_on ? "on" : "off");
440 v4l2_info(sd, "%s hotplug, %s Rx Sense, %s EDID (%d block(s))\n",
441 (adv7511_rd(sd, 0x42) & MASK_ADV7511_HPD_DETECT) ? "detected" : "no",
442 (adv7511_rd(sd, 0x42) & MASK_ADV7511_MSEN_DETECT) ? "detected" : "no",
443 edid->segments ? "found" : "no",
444 edid->blocks);
445 v4l2_info(sd, "%s output %s\n",
446 (adv7511_rd(sd, 0xaf) & 0x02) ?
447 "HDMI" : "DVI-D",
448 (adv7511_rd(sd, 0xa1) & 0x3c) ?
449 "disabled" : "enabled");
450 v4l2_info(sd, "state: %s, error: %s, detect count: %u, msk/irq: %02x/%02x\n",
451 states[adv7511_rd(sd, 0xc8) & 0xf],
452 errors[adv7511_rd(sd, 0xc8) >> 4], state->edid_detect_counter,
453 adv7511_rd(sd, 0x94), adv7511_rd(sd, 0x96));
454 v4l2_info(sd, "RGB quantization: %s range\n", adv7511_rd(sd, 0x18) & 0x80 ? "limited" : "full");
455 if (adv7511_rd(sd, 0xaf) & 0x02) {
456 /* HDMI only */
457 u8 manual_cts = adv7511_rd(sd, 0x0a) & 0x80;
458 u32 N = (adv7511_rd(sd, 0x01) & 0xf) << 16 |
459 adv7511_rd(sd, 0x02) << 8 |
460 adv7511_rd(sd, 0x03);
461 u8 vic_detect = adv7511_rd(sd, 0x3e) >> 2;
462 u8 vic_sent = adv7511_rd(sd, 0x3d) & 0x3f;
463 u32 CTS;
464
465 if (manual_cts)
466 CTS = (adv7511_rd(sd, 0x07) & 0xf) << 16 |
467 adv7511_rd(sd, 0x08) << 8 |
468 adv7511_rd(sd, 0x09);
469 else
470 CTS = (adv7511_rd(sd, 0x04) & 0xf) << 16 |
471 adv7511_rd(sd, 0x05) << 8 |
472 adv7511_rd(sd, 0x06);
473 v4l2_info(sd, "CTS %s mode: N %d, CTS %d\n",
474 manual_cts ? "manual" : "automatic", N, CTS);
475 v4l2_info(sd, "VIC: detected %d, sent %d\n",
476 vic_detect, vic_sent);
477 }
478 if (state->dv_timings.type == V4L2_DV_BT_656_1120)
479 v4l2_print_dv_timings(sd->name, "timings: ",
480 &state->dv_timings, false);
481 else
482 v4l2_info(sd, "no timings set\n");
483 v4l2_info(sd, "i2c edid addr: 0x%x\n", state->i2c_edid_addr);
484 v4l2_info(sd, "i2c cec addr: 0x%x\n", state->i2c_cec_addr);
485 return 0;
486 }
487
488 /* Power up/down adv7511 */
489 static int adv7511_s_power(struct v4l2_subdev *sd, int on)
490 {
491 struct adv7511_state *state = get_adv7511_state(sd);
492 const int retries = 20;
493 int i;
494
495 v4l2_dbg(1, debug, sd, "%s: power %s\n", __func__, on ? "on" : "off");
496
497 state->power_on = on;
498
499 if (!on) {
500 /* Power down */
501 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x40);
502 return true;
503 }
504
505 /* Power up */
506 /* The adv7511 does not always come up immediately.
507 Retry multiple times. */
508 for (i = 0; i < retries; i++) {
509 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x0);
510 if ((adv7511_rd(sd, 0x41) & 0x40) == 0)
511 break;
512 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x40);
513 msleep(10);
514 }
515 if (i == retries) {
516 v4l2_dbg(1, debug, sd, "%s: failed to powerup the adv7511!\n", __func__);
517 adv7511_s_power(sd, 0);
518 return false;
519 }
520 if (i > 1)
521 v4l2_dbg(1, debug, sd, "%s: needed %d retries to powerup the adv7511\n", __func__, i);
522
523 /* Reserved registers that must be set */
524 adv7511_wr(sd, 0x98, 0x03);
525 adv7511_wr_and_or(sd, 0x9a, 0xfe, 0x70);
526 adv7511_wr(sd, 0x9c, 0x30);
527 adv7511_wr_and_or(sd, 0x9d, 0xfc, 0x01);
528 adv7511_wr(sd, 0xa2, 0xa4);
529 adv7511_wr(sd, 0xa3, 0xa4);
530 adv7511_wr(sd, 0xe0, 0xd0);
531 adv7511_wr(sd, 0xf9, 0x00);
532
533 adv7511_wr(sd, 0x43, state->i2c_edid_addr);
534
535 /* Set number of attempts to read the EDID */
536 adv7511_wr(sd, 0xc9, 0xf);
537 return true;
538 }
539
540 /* Enable interrupts */
541 static void adv7511_set_isr(struct v4l2_subdev *sd, bool enable)
542 {
543 uint8_t irqs = MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT;
544 uint8_t irqs_rd;
545 int retries = 100;
546
547 v4l2_dbg(2, debug, sd, "%s: %s\n", __func__, enable ? "enable" : "disable");
548
549 /* The datasheet says that the EDID ready interrupt should be
550 disabled if there is no hotplug. */
551 if (!enable)
552 irqs = 0;
553 else if (adv7511_have_hotplug(sd))
554 irqs |= MASK_ADV7511_EDID_RDY_INT;
555
556 /*
557 * This i2c write can fail (approx. 1 in 1000 writes). But it
558 * is essential that this register is correct, so retry it
559 * multiple times.
560 *
561 * Note that the i2c write does not report an error, but the readback
562 * clearly shows the wrong value.
563 */
564 do {
565 adv7511_wr(sd, 0x94, irqs);
566 irqs_rd = adv7511_rd(sd, 0x94);
567 } while (retries-- && irqs_rd != irqs);
568
569 if (irqs_rd == irqs)
570 return;
571 v4l2_err(sd, "Could not set interrupts: hw failure?\n");
572 }
573
574 /* Interrupt handler */
575 static int adv7511_isr(struct v4l2_subdev *sd, u32 status, bool *handled)
576 {
577 uint8_t irq_status;
578
579 /* disable interrupts to prevent a race condition */
580 adv7511_set_isr(sd, false);
581 irq_status = adv7511_rd(sd, 0x96);
582 /* clear detected interrupts */
583 adv7511_wr(sd, 0x96, irq_status);
584
585 v4l2_dbg(1, debug, sd, "%s: irq 0x%x\n", __func__, irq_status);
586
587 if (irq_status & (MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT))
588 adv7511_check_monitor_present_status(sd);
589 if (irq_status & MASK_ADV7511_EDID_RDY_INT)
590 adv7511_check_edid_status(sd);
591
592 /* enable interrupts */
593 adv7511_set_isr(sd, true);
594
595 if (handled)
596 *handled = true;
597 return 0;
598 }
599
600 static const struct v4l2_subdev_core_ops adv7511_core_ops = {
601 .log_status = adv7511_log_status,
602 #ifdef CONFIG_VIDEO_ADV_DEBUG
603 .g_register = adv7511_g_register,
604 .s_register = adv7511_s_register,
605 #endif
606 .s_power = adv7511_s_power,
607 .interrupt_service_routine = adv7511_isr,
608 };
609
610 /* ------------------------------ VIDEO OPS ------------------------------ */
611
612 /* Enable/disable adv7511 output */
613 static int adv7511_s_stream(struct v4l2_subdev *sd, int enable)
614 {
615 struct adv7511_state *state = get_adv7511_state(sd);
616
617 v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis"));
618 adv7511_wr_and_or(sd, 0xa1, ~0x3c, (enable ? 0 : 0x3c));
619 if (enable) {
620 adv7511_check_monitor_present_status(sd);
621 } else {
622 adv7511_s_power(sd, 0);
623 state->have_monitor = false;
624 }
625 return 0;
626 }
627
628 static int adv7511_s_dv_timings(struct v4l2_subdev *sd,
629 struct v4l2_dv_timings *timings)
630 {
631 struct adv7511_state *state = get_adv7511_state(sd);
632
633 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
634
635 /* quick sanity check */
636 if (!v4l2_valid_dv_timings(timings, &adv7511_timings_cap, NULL, NULL))
637 return -EINVAL;
638
639 /* Fill the optional fields .standards and .flags in struct v4l2_dv_timings
640 if the format is one of the CEA or DMT timings. */
641 v4l2_find_dv_timings_cap(timings, &adv7511_timings_cap, 0, NULL, NULL);
642
643 timings->bt.flags &= ~V4L2_DV_FL_REDUCED_FPS;
644
645 /* save timings */
646 state->dv_timings = *timings;
647
648 /* update quantization range based on new dv_timings */
649 adv7511_set_rgb_quantization_mode(sd, state->rgb_quantization_range_ctrl);
650
651 /* update AVI infoframe */
652 adv7511_set_IT_content_AVI_InfoFrame(sd);
653
654 return 0;
655 }
656
657 static int adv7511_g_dv_timings(struct v4l2_subdev *sd,
658 struct v4l2_dv_timings *timings)
659 {
660 struct adv7511_state *state = get_adv7511_state(sd);
661
662 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
663
664 if (!timings)
665 return -EINVAL;
666
667 *timings = state->dv_timings;
668
669 return 0;
670 }
671
672 static int adv7511_enum_dv_timings(struct v4l2_subdev *sd,
673 struct v4l2_enum_dv_timings *timings)
674 {
675 if (timings->pad != 0)
676 return -EINVAL;
677
678 return v4l2_enum_dv_timings_cap(timings, &adv7511_timings_cap, NULL, NULL);
679 }
680
681 static int adv7511_dv_timings_cap(struct v4l2_subdev *sd,
682 struct v4l2_dv_timings_cap *cap)
683 {
684 if (cap->pad != 0)
685 return -EINVAL;
686
687 *cap = adv7511_timings_cap;
688 return 0;
689 }
690
691 static const struct v4l2_subdev_video_ops adv7511_video_ops = {
692 .s_stream = adv7511_s_stream,
693 .s_dv_timings = adv7511_s_dv_timings,
694 .g_dv_timings = adv7511_g_dv_timings,
695 };
696
697 /* ------------------------------ AUDIO OPS ------------------------------ */
698 static int adv7511_s_audio_stream(struct v4l2_subdev *sd, int enable)
699 {
700 v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis"));
701
702 if (enable)
703 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x80);
704 else
705 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x40);
706
707 return 0;
708 }
709
710 static int adv7511_s_clock_freq(struct v4l2_subdev *sd, u32 freq)
711 {
712 u32 N;
713
714 switch (freq) {
715 case 32000: N = 4096; break;
716 case 44100: N = 6272; break;
717 case 48000: N = 6144; break;
718 case 88200: N = 12544; break;
719 case 96000: N = 12288; break;
720 case 176400: N = 25088; break;
721 case 192000: N = 24576; break;
722 default:
723 return -EINVAL;
724 }
725
726 /* Set N (used with CTS to regenerate the audio clock) */
727 adv7511_wr(sd, 0x01, (N >> 16) & 0xf);
728 adv7511_wr(sd, 0x02, (N >> 8) & 0xff);
729 adv7511_wr(sd, 0x03, N & 0xff);
730
731 return 0;
732 }
733
734 static int adv7511_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq)
735 {
736 u32 i2s_sf;
737
738 switch (freq) {
739 case 32000: i2s_sf = 0x30; break;
740 case 44100: i2s_sf = 0x00; break;
741 case 48000: i2s_sf = 0x20; break;
742 case 88200: i2s_sf = 0x80; break;
743 case 96000: i2s_sf = 0xa0; break;
744 case 176400: i2s_sf = 0xc0; break;
745 case 192000: i2s_sf = 0xe0; break;
746 default:
747 return -EINVAL;
748 }
749
750 /* Set sampling frequency for I2S audio to 48 kHz */
751 adv7511_wr_and_or(sd, 0x15, 0xf, i2s_sf);
752
753 return 0;
754 }
755
756 static int adv7511_s_routing(struct v4l2_subdev *sd, u32 input, u32 output, u32 config)
757 {
758 /* Only 2 channels in use for application */
759 adv7511_wr_and_or(sd, 0x73, 0xf8, 0x1);
760 /* Speaker mapping */
761 adv7511_wr(sd, 0x76, 0x00);
762
763 /* 16 bit audio word length */
764 adv7511_wr_and_or(sd, 0x14, 0xf0, 0x02);
765
766 return 0;
767 }
768
769 static const struct v4l2_subdev_audio_ops adv7511_audio_ops = {
770 .s_stream = adv7511_s_audio_stream,
771 .s_clock_freq = adv7511_s_clock_freq,
772 .s_i2s_clock_freq = adv7511_s_i2s_clock_freq,
773 .s_routing = adv7511_s_routing,
774 };
775
776 /* ---------------------------- PAD OPS ------------------------------------- */
777
778 static int adv7511_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
779 {
780 struct adv7511_state *state = get_adv7511_state(sd);
781
782 if (edid->pad != 0)
783 return -EINVAL;
784 if ((edid->blocks == 0) || (edid->blocks > 256))
785 return -EINVAL;
786 if (!state->edid.segments) {
787 v4l2_dbg(1, debug, sd, "EDID segment 0 not found\n");
788 return -ENODATA;
789 }
790 if (edid->start_block >= state->edid.segments * 2)
791 return -E2BIG;
792 if ((edid->blocks + edid->start_block) >= state->edid.segments * 2)
793 edid->blocks = state->edid.segments * 2 - edid->start_block;
794
795 memcpy(edid->edid, &state->edid.data[edid->start_block * 128],
796 128 * edid->blocks);
797 return 0;
798 }
799
800 static const struct v4l2_subdev_pad_ops adv7511_pad_ops = {
801 .get_edid = adv7511_get_edid,
802 .enum_dv_timings = adv7511_enum_dv_timings,
803 .dv_timings_cap = adv7511_dv_timings_cap,
804 };
805
806 /* --------------------- SUBDEV OPS --------------------------------------- */
807
808 static const struct v4l2_subdev_ops adv7511_ops = {
809 .core = &adv7511_core_ops,
810 .pad = &adv7511_pad_ops,
811 .video = &adv7511_video_ops,
812 .audio = &adv7511_audio_ops,
813 };
814
815 /* ----------------------------------------------------------------------- */
816 static void adv7511_dbg_dump_edid(int lvl, int debug, struct v4l2_subdev *sd, int segment, uint8_t *buf)
817 {
818 if (debug >= lvl) {
819 int i, j;
820 v4l2_dbg(lvl, debug, sd, "edid segment %d\n", segment);
821 for (i = 0; i < 256; i += 16) {
822 u8 b[128];
823 u8 *bp = b;
824 if (i == 128)
825 v4l2_dbg(lvl, debug, sd, "\n");
826 for (j = i; j < i + 16; j++) {
827 sprintf(bp, "0x%02x, ", buf[j]);
828 bp += 6;
829 }
830 bp[0] = '\0';
831 v4l2_dbg(lvl, debug, sd, "%s\n", b);
832 }
833 }
834 }
835
836 static void adv7511_notify_no_edid(struct v4l2_subdev *sd)
837 {
838 struct adv7511_state *state = get_adv7511_state(sd);
839 struct adv7511_edid_detect ed;
840
841 /* We failed to read the EDID, so send an event for this. */
842 ed.present = false;
843 ed.segment = adv7511_rd(sd, 0xc4);
844 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
845 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, 0x0);
846 }
847
848 static void adv7511_edid_handler(struct work_struct *work)
849 {
850 struct delayed_work *dwork = to_delayed_work(work);
851 struct adv7511_state *state = container_of(dwork, struct adv7511_state, edid_handler);
852 struct v4l2_subdev *sd = &state->sd;
853
854 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
855
856 if (adv7511_check_edid_status(sd)) {
857 /* Return if we received the EDID. */
858 return;
859 }
860
861 if (adv7511_have_hotplug(sd)) {
862 /* We must retry reading the EDID several times, it is possible
863 * that initially the EDID couldn't be read due to i2c errors
864 * (DVI connectors are particularly prone to this problem). */
865 if (state->edid.read_retries) {
866 state->edid.read_retries--;
867 v4l2_dbg(1, debug, sd, "%s: edid read failed\n", __func__);
868 state->have_monitor = false;
869 adv7511_s_power(sd, false);
870 adv7511_s_power(sd, true);
871 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
872 return;
873 }
874 }
875
876 /* We failed to read the EDID, so send an event for this. */
877 adv7511_notify_no_edid(sd);
878 v4l2_dbg(1, debug, sd, "%s: no edid found\n", __func__);
879 }
880
881 static void adv7511_audio_setup(struct v4l2_subdev *sd)
882 {
883 v4l2_dbg(1, debug, sd, "%s\n", __func__);
884
885 adv7511_s_i2s_clock_freq(sd, 48000);
886 adv7511_s_clock_freq(sd, 48000);
887 adv7511_s_routing(sd, 0, 0, 0);
888 }
889
890 /* Configure hdmi transmitter. */
891 static void adv7511_setup(struct v4l2_subdev *sd)
892 {
893 struct adv7511_state *state = get_adv7511_state(sd);
894 v4l2_dbg(1, debug, sd, "%s\n", __func__);
895
896 /* Input format: RGB 4:4:4 */
897 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x0);
898 /* Output format: RGB 4:4:4 */
899 adv7511_wr_and_or(sd, 0x16, 0x7f, 0x0);
900 /* 1st order interpolation 4:2:2 -> 4:4:4 up conversion, Aspect ratio: 16:9 */
901 adv7511_wr_and_or(sd, 0x17, 0xf9, 0x06);
902 /* Disable pixel repetition */
903 adv7511_wr_and_or(sd, 0x3b, 0x9f, 0x0);
904 /* Disable CSC */
905 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x0);
906 /* Output format: RGB 4:4:4, Active Format Information is valid,
907 * underscanned */
908 adv7511_wr_and_or(sd, 0x55, 0x9c, 0x12);
909 /* AVI Info frame packet enable, Audio Info frame disable */
910 adv7511_wr_and_or(sd, 0x44, 0xe7, 0x10);
911 /* Colorimetry, Active format aspect ratio: same as picure. */
912 adv7511_wr(sd, 0x56, 0xa8);
913 /* No encryption */
914 adv7511_wr_and_or(sd, 0xaf, 0xed, 0x0);
915
916 /* Positive clk edge capture for input video clock */
917 adv7511_wr_and_or(sd, 0xba, 0x1f, 0x60);
918
919 adv7511_audio_setup(sd);
920
921 v4l2_ctrl_handler_setup(&state->hdl);
922 }
923
924 static void adv7511_notify_monitor_detect(struct v4l2_subdev *sd)
925 {
926 struct adv7511_monitor_detect mdt;
927 struct adv7511_state *state = get_adv7511_state(sd);
928
929 mdt.present = state->have_monitor;
930 v4l2_subdev_notify(sd, ADV7511_MONITOR_DETECT, (void *)&mdt);
931 }
932
933 static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd)
934 {
935 struct adv7511_state *state = get_adv7511_state(sd);
936 /* read hotplug and rx-sense state */
937 uint8_t status = adv7511_rd(sd, 0x42);
938
939 v4l2_dbg(1, debug, sd, "%s: status: 0x%x%s%s\n",
940 __func__,
941 status,
942 status & MASK_ADV7511_HPD_DETECT ? ", hotplug" : "",
943 status & MASK_ADV7511_MSEN_DETECT ? ", rx-sense" : "");
944
945 /* update read only ctrls */
946 v4l2_ctrl_s_ctrl(state->hotplug_ctrl, adv7511_have_hotplug(sd) ? 0x1 : 0x0);
947 v4l2_ctrl_s_ctrl(state->rx_sense_ctrl, adv7511_have_rx_sense(sd) ? 0x1 : 0x0);
948
949 if ((status & MASK_ADV7511_HPD_DETECT) && ((status & MASK_ADV7511_MSEN_DETECT) || state->edid.segments)) {
950 v4l2_dbg(1, debug, sd, "%s: hotplug and (rx-sense or edid)\n", __func__);
951 if (!state->have_monitor) {
952 v4l2_dbg(1, debug, sd, "%s: monitor detected\n", __func__);
953 state->have_monitor = true;
954 adv7511_set_isr(sd, true);
955 if (!adv7511_s_power(sd, true)) {
956 v4l2_dbg(1, debug, sd, "%s: monitor detected, powerup failed\n", __func__);
957 return;
958 }
959 adv7511_setup(sd);
960 adv7511_notify_monitor_detect(sd);
961 state->edid.read_retries = EDID_MAX_RETRIES;
962 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
963 }
964 } else if (status & MASK_ADV7511_HPD_DETECT) {
965 v4l2_dbg(1, debug, sd, "%s: hotplug detected\n", __func__);
966 state->edid.read_retries = EDID_MAX_RETRIES;
967 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
968 } else if (!(status & MASK_ADV7511_HPD_DETECT)) {
969 v4l2_dbg(1, debug, sd, "%s: hotplug not detected\n", __func__);
970 if (state->have_monitor) {
971 v4l2_dbg(1, debug, sd, "%s: monitor not detected\n", __func__);
972 state->have_monitor = false;
973 adv7511_notify_monitor_detect(sd);
974 }
975 adv7511_s_power(sd, false);
976 memset(&state->edid, 0, sizeof(struct adv7511_state_edid));
977 adv7511_notify_no_edid(sd);
978 }
979 }
980
981 static bool edid_block_verify_crc(uint8_t *edid_block)
982 {
983 uint8_t sum = 0;
984 int i;
985
986 for (i = 0; i < 128; i++)
987 sum += edid_block[i];
988 return sum == 0;
989 }
990
991 static bool edid_verify_crc(struct v4l2_subdev *sd, u32 segment)
992 {
993 struct adv7511_state *state = get_adv7511_state(sd);
994 u32 blocks = state->edid.blocks;
995 uint8_t *data = state->edid.data;
996
997 if (!edid_block_verify_crc(&data[segment * 256]))
998 return false;
999 if ((segment + 1) * 2 <= blocks)
1000 return edid_block_verify_crc(&data[segment * 256 + 128]);
1001 return true;
1002 }
1003
1004 static bool edid_verify_header(struct v4l2_subdev *sd, u32 segment)
1005 {
1006 static const u8 hdmi_header[] = {
1007 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00
1008 };
1009 struct adv7511_state *state = get_adv7511_state(sd);
1010 u8 *data = state->edid.data;
1011
1012 if (segment != 0)
1013 return true;
1014 return !memcmp(data, hdmi_header, sizeof(hdmi_header));
1015 }
1016
1017 static bool adv7511_check_edid_status(struct v4l2_subdev *sd)
1018 {
1019 struct adv7511_state *state = get_adv7511_state(sd);
1020 uint8_t edidRdy = adv7511_rd(sd, 0xc5);
1021
1022 v4l2_dbg(1, debug, sd, "%s: edid ready (retries: %d)\n",
1023 __func__, EDID_MAX_RETRIES - state->edid.read_retries);
1024
1025 if (state->edid.complete)
1026 return true;
1027
1028 if (edidRdy & MASK_ADV7511_EDID_RDY) {
1029 int segment = adv7511_rd(sd, 0xc4);
1030 struct adv7511_edid_detect ed;
1031
1032 if (segment >= EDID_MAX_SEGM) {
1033 v4l2_err(sd, "edid segment number too big\n");
1034 return false;
1035 }
1036 v4l2_dbg(1, debug, sd, "%s: got segment %d\n", __func__, segment);
1037 adv7511_edid_rd(sd, 256, &state->edid.data[segment * 256]);
1038 adv7511_dbg_dump_edid(2, debug, sd, segment, &state->edid.data[segment * 256]);
1039 if (segment == 0) {
1040 state->edid.blocks = state->edid.data[0x7e] + 1;
1041 v4l2_dbg(1, debug, sd, "%s: %d blocks in total\n", __func__, state->edid.blocks);
1042 }
1043 if (!edid_verify_crc(sd, segment) ||
1044 !edid_verify_header(sd, segment)) {
1045 /* edid crc error, force reread of edid segment */
1046 v4l2_err(sd, "%s: edid crc or header error\n", __func__);
1047 state->have_monitor = false;
1048 adv7511_s_power(sd, false);
1049 adv7511_s_power(sd, true);
1050 return false;
1051 }
1052 /* one more segment read ok */
1053 state->edid.segments = segment + 1;
1054 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, 0x1);
1055 if (((state->edid.data[0x7e] >> 1) + 1) > state->edid.segments) {
1056 /* Request next EDID segment */
1057 v4l2_dbg(1, debug, sd, "%s: request segment %d\n", __func__, state->edid.segments);
1058 adv7511_wr(sd, 0xc9, 0xf);
1059 adv7511_wr(sd, 0xc4, state->edid.segments);
1060 state->edid.read_retries = EDID_MAX_RETRIES;
1061 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
1062 return false;
1063 }
1064
1065 v4l2_dbg(1, debug, sd, "%s: edid complete with %d segment(s)\n", __func__, state->edid.segments);
1066 state->edid.complete = true;
1067
1068 /* report when we have all segments
1069 but report only for segment 0
1070 */
1071 ed.present = true;
1072 ed.segment = 0;
1073 state->edid_detect_counter++;
1074 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
1075 return ed.present;
1076 }
1077
1078 return false;
1079 }
1080
1081 /* ----------------------------------------------------------------------- */
1082 /* Setup ADV7511 */
1083 static void adv7511_init_setup(struct v4l2_subdev *sd)
1084 {
1085 struct adv7511_state *state = get_adv7511_state(sd);
1086 struct adv7511_state_edid *edid = &state->edid;
1087
1088 v4l2_dbg(1, debug, sd, "%s\n", __func__);
1089
1090 /* clear all interrupts */
1091 adv7511_wr(sd, 0x96, 0xff);
1092 /*
1093 * Stop HPD from resetting a lot of registers.
1094 * It might leave the chip in a partly un-initialized state,
1095 * in particular with regards to hotplug bounces.
1096 */
1097 adv7511_wr_and_or(sd, 0xd6, 0x3f, 0xc0);
1098 memset(edid, 0, sizeof(struct adv7511_state_edid));
1099 state->have_monitor = false;
1100 adv7511_set_isr(sd, false);
1101 adv7511_s_stream(sd, false);
1102 adv7511_s_audio_stream(sd, false);
1103 }
1104
1105 static int adv7511_probe(struct i2c_client *client, const struct i2c_device_id *id)
1106 {
1107 struct adv7511_state *state;
1108 struct adv7511_platform_data *pdata = client->dev.platform_data;
1109 struct v4l2_ctrl_handler *hdl;
1110 struct v4l2_subdev *sd;
1111 u8 chip_id[2];
1112 int err = -EIO;
1113
1114 /* Check if the adapter supports the needed features */
1115 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1116 return -EIO;
1117
1118 state = devm_kzalloc(&client->dev, sizeof(struct adv7511_state), GFP_KERNEL);
1119 if (!state)
1120 return -ENOMEM;
1121
1122 /* Platform data */
1123 if (!pdata) {
1124 v4l_err(client, "No platform data!\n");
1125 return -ENODEV;
1126 }
1127 memcpy(&state->pdata, pdata, sizeof(state->pdata));
1128
1129 sd = &state->sd;
1130
1131 v4l2_dbg(1, debug, sd, "detecting adv7511 client on address 0x%x\n",
1132 client->addr << 1);
1133
1134 v4l2_i2c_subdev_init(sd, client, &adv7511_ops);
1135
1136 hdl = &state->hdl;
1137 v4l2_ctrl_handler_init(hdl, 10);
1138 /* add in ascending ID order */
1139 state->hdmi_mode_ctrl = v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1140 V4L2_CID_DV_TX_MODE, V4L2_DV_TX_MODE_HDMI,
1141 0, V4L2_DV_TX_MODE_DVI_D);
1142 state->hotplug_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1143 V4L2_CID_DV_TX_HOTPLUG, 0, 1, 0, 0);
1144 state->rx_sense_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1145 V4L2_CID_DV_TX_RXSENSE, 0, 1, 0, 0);
1146 state->have_edid0_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1147 V4L2_CID_DV_TX_EDID_PRESENT, 0, 1, 0, 0);
1148 state->rgb_quantization_range_ctrl =
1149 v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1150 V4L2_CID_DV_TX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
1151 0, V4L2_DV_RGB_RANGE_AUTO);
1152 sd->ctrl_handler = hdl;
1153 if (hdl->error) {
1154 err = hdl->error;
1155 goto err_hdl;
1156 }
1157 state->hdmi_mode_ctrl->is_private = true;
1158 state->hotplug_ctrl->is_private = true;
1159 state->rx_sense_ctrl->is_private = true;
1160 state->have_edid0_ctrl->is_private = true;
1161 state->rgb_quantization_range_ctrl->is_private = true;
1162
1163 state->pad.flags = MEDIA_PAD_FL_SINK;
1164 err = media_entity_init(&sd->entity, 1, &state->pad, 0);
1165 if (err)
1166 goto err_hdl;
1167
1168 /* EDID and CEC i2c addr */
1169 state->i2c_edid_addr = state->pdata.i2c_edid << 1;
1170 state->i2c_cec_addr = state->pdata.i2c_cec << 1;
1171
1172 state->chip_revision = adv7511_rd(sd, 0x0);
1173 chip_id[0] = adv7511_rd(sd, 0xf5);
1174 chip_id[1] = adv7511_rd(sd, 0xf6);
1175 if (chip_id[0] != 0x75 || chip_id[1] != 0x11) {
1176 v4l2_err(sd, "chip_id != 0x7511, read 0x%02x%02x\n", chip_id[0], chip_id[1]);
1177 err = -EIO;
1178 goto err_entity;
1179 }
1180
1181 state->i2c_edid = i2c_new_dummy(client->adapter, state->i2c_edid_addr >> 1);
1182 if (state->i2c_edid == NULL) {
1183 v4l2_err(sd, "failed to register edid i2c client\n");
1184 err = -ENOMEM;
1185 goto err_entity;
1186 }
1187
1188 adv7511_wr(sd, 0xe2, 0x01); /* power down cec section */
1189 state->work_queue = create_singlethread_workqueue(sd->name);
1190 if (state->work_queue == NULL) {
1191 v4l2_err(sd, "could not create workqueue\n");
1192 err = -ENOMEM;
1193 goto err_unreg_cec;
1194 }
1195
1196 INIT_DELAYED_WORK(&state->edid_handler, adv7511_edid_handler);
1197
1198 adv7511_init_setup(sd);
1199 adv7511_set_isr(sd, true);
1200 adv7511_check_monitor_present_status(sd);
1201
1202 v4l2_info(sd, "%s found @ 0x%x (%s)\n", client->name,
1203 client->addr << 1, client->adapter->name);
1204 return 0;
1205
1206 err_unreg_cec:
1207 i2c_unregister_device(state->i2c_edid);
1208 err_entity:
1209 media_entity_cleanup(&sd->entity);
1210 err_hdl:
1211 v4l2_ctrl_handler_free(&state->hdl);
1212 return err;
1213 }
1214
1215 /* ----------------------------------------------------------------------- */
1216
1217 static int adv7511_remove(struct i2c_client *client)
1218 {
1219 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1220 struct adv7511_state *state = get_adv7511_state(sd);
1221
1222 state->chip_revision = -1;
1223
1224 v4l2_dbg(1, debug, sd, "%s removed @ 0x%x (%s)\n", client->name,
1225 client->addr << 1, client->adapter->name);
1226
1227 adv7511_init_setup(sd);
1228 cancel_delayed_work(&state->edid_handler);
1229 i2c_unregister_device(state->i2c_edid);
1230 destroy_workqueue(state->work_queue);
1231 v4l2_device_unregister_subdev(sd);
1232 media_entity_cleanup(&sd->entity);
1233 v4l2_ctrl_handler_free(sd->ctrl_handler);
1234 return 0;
1235 }
1236
1237 /* ----------------------------------------------------------------------- */
1238
1239 static struct i2c_device_id adv7511_id[] = {
1240 { "adv7511", 0 },
1241 { }
1242 };
1243 MODULE_DEVICE_TABLE(i2c, adv7511_id);
1244
1245 static struct i2c_driver adv7511_driver = {
1246 .driver = {
1247 .owner = THIS_MODULE,
1248 .name = "adv7511",
1249 },
1250 .probe = adv7511_probe,
1251 .remove = adv7511_remove,
1252 .id_table = adv7511_id,
1253 };
1254
1255 module_i2c_driver(adv7511_driver);
Linux with added FPC-III support