?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mfd: wm8350-i2c: Make sure the i2c regmap functions are compiled
[linux/fpc-iii.git] / drivers / media / i2c / adv7511.c
blob71995401eab00be25d4207a1b1df93da1414d89e
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 (state->dv_timings.type == V4L2_DV_BT_656_1120)
456 v4l2_print_dv_timings(sd->name, "timings: ",
457 &state->dv_timings, false);
458 else
459 v4l2_info(sd, "no timings set\n");
460 v4l2_info(sd, "i2c edid addr: 0x%x\n", state->i2c_edid_addr);
461 v4l2_info(sd, "i2c cec addr: 0x%x\n", state->i2c_cec_addr);
462 return 0;
463 }
464
465 /* Power up/down adv7511 */
466 static int adv7511_s_power(struct v4l2_subdev *sd, int on)
467 {
468 struct adv7511_state *state = get_adv7511_state(sd);
469 const int retries = 20;
470 int i;
471
472 v4l2_dbg(1, debug, sd, "%s: power %s\n", __func__, on ? "on" : "off");
473
474 state->power_on = on;
475
476 if (!on) {
477 /* Power down */
478 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x40);
479 return true;
480 }
481
482 /* Power up */
483 /* The adv7511 does not always come up immediately.
484 Retry multiple times. */
485 for (i = 0; i < retries; i++) {
486 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x0);
487 if ((adv7511_rd(sd, 0x41) & 0x40) == 0)
488 break;
489 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x40);
490 msleep(10);
491 }
492 if (i == retries) {
493 v4l2_dbg(1, debug, sd, "%s: failed to powerup the adv7511!\n", __func__);
494 adv7511_s_power(sd, 0);
495 return false;
496 }
497 if (i > 1)
498 v4l2_dbg(1, debug, sd, "%s: needed %d retries to powerup the adv7511\n", __func__, i);
499
500 /* Reserved registers that must be set */
501 adv7511_wr(sd, 0x98, 0x03);
502 adv7511_wr_and_or(sd, 0x9a, 0xfe, 0x70);
503 adv7511_wr(sd, 0x9c, 0x30);
504 adv7511_wr_and_or(sd, 0x9d, 0xfc, 0x01);
505 adv7511_wr(sd, 0xa2, 0xa4);
506 adv7511_wr(sd, 0xa3, 0xa4);
507 adv7511_wr(sd, 0xe0, 0xd0);
508 adv7511_wr(sd, 0xf9, 0x00);
509
510 adv7511_wr(sd, 0x43, state->i2c_edid_addr);
511
512 /* Set number of attempts to read the EDID */
513 adv7511_wr(sd, 0xc9, 0xf);
514 return true;
515 }
516
517 /* Enable interrupts */
518 static void adv7511_set_isr(struct v4l2_subdev *sd, bool enable)
519 {
520 uint8_t irqs = MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT;
521 uint8_t irqs_rd;
522 int retries = 100;
523
524 v4l2_dbg(2, debug, sd, "%s: %s\n", __func__, enable ? "enable" : "disable");
525
526 /* The datasheet says that the EDID ready interrupt should be
527 disabled if there is no hotplug. */
528 if (!enable)
529 irqs = 0;
530 else if (adv7511_have_hotplug(sd))
531 irqs |= MASK_ADV7511_EDID_RDY_INT;
532
533 /*
534 * This i2c write can fail (approx. 1 in 1000 writes). But it
535 * is essential that this register is correct, so retry it
536 * multiple times.
537 *
538 * Note that the i2c write does not report an error, but the readback
539 * clearly shows the wrong value.
540 */
541 do {
542 adv7511_wr(sd, 0x94, irqs);
543 irqs_rd = adv7511_rd(sd, 0x94);
544 } while (retries-- && irqs_rd != irqs);
545
546 if (irqs_rd == irqs)
547 return;
548 v4l2_err(sd, "Could not set interrupts: hw failure?\n");
549 }
550
551 /* Interrupt handler */
552 static int adv7511_isr(struct v4l2_subdev *sd, u32 status, bool *handled)
553 {
554 uint8_t irq_status;
555
556 /* disable interrupts to prevent a race condition */
557 adv7511_set_isr(sd, false);
558 irq_status = adv7511_rd(sd, 0x96);
559 /* clear detected interrupts */
560 adv7511_wr(sd, 0x96, irq_status);
561
562 v4l2_dbg(1, debug, sd, "%s: irq 0x%x\n", __func__, irq_status);
563
564 if (irq_status & (MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT))
565 adv7511_check_monitor_present_status(sd);
566 if (irq_status & MASK_ADV7511_EDID_RDY_INT)
567 adv7511_check_edid_status(sd);
568
569 /* enable interrupts */
570 adv7511_set_isr(sd, true);
571
572 if (handled)
573 *handled = true;
574 return 0;
575 }
576
577 static int adv7511_get_edid(struct v4l2_subdev *sd, struct v4l2_subdev_edid *edid)
578 {
579 struct adv7511_state *state = get_adv7511_state(sd);
580
581 if (edid->pad != 0)
582 return -EINVAL;
583 if ((edid->blocks == 0) || (edid->blocks > 256))
584 return -EINVAL;
585 if (!edid->edid)
586 return -EINVAL;
587 if (!state->edid.segments) {
588 v4l2_dbg(1, debug, sd, "EDID segment 0 not found\n");
589 return -ENODATA;
590 }
591 if (edid->start_block >= state->edid.segments * 2)
592 return -E2BIG;
593 if ((edid->blocks + edid->start_block) >= state->edid.segments * 2)
594 edid->blocks = state->edid.segments * 2 - edid->start_block;
595
596 memcpy(edid->edid, &state->edid.data[edid->start_block * 128],
597 128 * edid->blocks);
598 return 0;
599 }
600
601 static const struct v4l2_subdev_pad_ops adv7511_pad_ops = {
602 .get_edid = adv7511_get_edid,
603 };
604
605 static const struct v4l2_subdev_core_ops adv7511_core_ops = {
606 .log_status = adv7511_log_status,
607 #ifdef CONFIG_VIDEO_ADV_DEBUG
608 .g_register = adv7511_g_register,
609 .s_register = adv7511_s_register,
610 #endif
611 .s_power = adv7511_s_power,
612 .interrupt_service_routine = adv7511_isr,
613 };
614
615 /* ------------------------------ VIDEO OPS ------------------------------ */
616
617 /* Enable/disable adv7511 output */
618 static int adv7511_s_stream(struct v4l2_subdev *sd, int enable)
619 {
620 struct adv7511_state *state = get_adv7511_state(sd);
621
622 v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis"));
623 adv7511_wr_and_or(sd, 0xa1, ~0x3c, (enable ? 0 : 0x3c));
624 if (enable) {
625 adv7511_check_monitor_present_status(sd);
626 } else {
627 adv7511_s_power(sd, 0);
628 state->have_monitor = false;
629 }
630 return 0;
631 }
632
633 static int adv7511_s_dv_timings(struct v4l2_subdev *sd,
634 struct v4l2_dv_timings *timings)
635 {
636 struct adv7511_state *state = get_adv7511_state(sd);
637
638 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
639
640 /* quick sanity check */
641 if (!v4l2_valid_dv_timings(timings, &adv7511_timings_cap, NULL, NULL))
642 return -EINVAL;
643
644 /* Fill the optional fields .standards and .flags in struct v4l2_dv_timings
645 if the format is one of the CEA or DMT timings. */
646 v4l2_find_dv_timings_cap(timings, &adv7511_timings_cap, 0, NULL, NULL);
647
648 timings->bt.flags &= ~V4L2_DV_FL_REDUCED_FPS;
649
650 /* save timings */
651 state->dv_timings = *timings;
652
653 /* update quantization range based on new dv_timings */
654 adv7511_set_rgb_quantization_mode(sd, state->rgb_quantization_range_ctrl);
655
656 /* update AVI infoframe */
657 adv7511_set_IT_content_AVI_InfoFrame(sd);
658
659 return 0;
660 }
661
662 static int adv7511_g_dv_timings(struct v4l2_subdev *sd,
663 struct v4l2_dv_timings *timings)
664 {
665 struct adv7511_state *state = get_adv7511_state(sd);
666
667 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
668
669 if (!timings)
670 return -EINVAL;
671
672 *timings = state->dv_timings;
673
674 return 0;
675 }
676
677 static int adv7511_enum_dv_timings(struct v4l2_subdev *sd,
678 struct v4l2_enum_dv_timings *timings)
679 {
680 return v4l2_enum_dv_timings_cap(timings, &adv7511_timings_cap, NULL, NULL);
681 }
682
683 static int adv7511_dv_timings_cap(struct v4l2_subdev *sd,
684 struct v4l2_dv_timings_cap *cap)
685 {
686 *cap = adv7511_timings_cap;
687 return 0;
688 }
689
690 static const struct v4l2_subdev_video_ops adv7511_video_ops = {
691 .s_stream = adv7511_s_stream,
692 .s_dv_timings = adv7511_s_dv_timings,
693 .g_dv_timings = adv7511_g_dv_timings,
694 .enum_dv_timings = adv7511_enum_dv_timings,
695 .dv_timings_cap = adv7511_dv_timings_cap,
696 };
697
698 /* ------------------------------ AUDIO OPS ------------------------------ */
699 static int adv7511_s_audio_stream(struct v4l2_subdev *sd, int enable)
700 {
701 v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis"));
702
703 if (enable)
704 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x80);
705 else
706 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x40);
707
708 return 0;
709 }
710
711 static int adv7511_s_clock_freq(struct v4l2_subdev *sd, u32 freq)
712 {
713 u32 N;
714
715 switch (freq) {
716 case 32000: N = 4096; break;
717 case 44100: N = 6272; break;
718 case 48000: N = 6144; break;
719 case 88200: N = 12544; break;
720 case 96000: N = 12288; break;
721 case 176400: N = 25088; break;
722 case 192000: N = 24576; break;
723 default:
724 return -EINVAL;
725 }
726
727 /* Set N (used with CTS to regenerate the audio clock) */
728 adv7511_wr(sd, 0x01, (N >> 16) & 0xf);
729 adv7511_wr(sd, 0x02, (N >> 8) & 0xff);
730 adv7511_wr(sd, 0x03, N & 0xff);
731
732 return 0;
733 }
734
735 static int adv7511_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq)
736 {
737 u32 i2s_sf;
738
739 switch (freq) {
740 case 32000: i2s_sf = 0x30; break;
741 case 44100: i2s_sf = 0x00; break;
742 case 48000: i2s_sf = 0x20; break;
743 case 88200: i2s_sf = 0x80; break;
744 case 96000: i2s_sf = 0xa0; break;
745 case 176400: i2s_sf = 0xc0; break;
746 case 192000: i2s_sf = 0xe0; break;
747 default:
748 return -EINVAL;
749 }
750
751 /* Set sampling frequency for I2S audio to 48 kHz */
752 adv7511_wr_and_or(sd, 0x15, 0xf, i2s_sf);
753
754 return 0;
755 }
756
757 static int adv7511_s_routing(struct v4l2_subdev *sd, u32 input, u32 output, u32 config)
758 {
759 /* Only 2 channels in use for application */
760 adv7511_wr_and_or(sd, 0x73, 0xf8, 0x1);
761 /* Speaker mapping */
762 adv7511_wr(sd, 0x76, 0x00);
763
764 /* 16 bit audio word length */
765 adv7511_wr_and_or(sd, 0x14, 0xf0, 0x02);
766
767 return 0;
768 }
769
770 static const struct v4l2_subdev_audio_ops adv7511_audio_ops = {
771 .s_stream = adv7511_s_audio_stream,
772 .s_clock_freq = adv7511_s_clock_freq,
773 .s_i2s_clock_freq = adv7511_s_i2s_clock_freq,
774 .s_routing = adv7511_s_routing,
775 };
776
777 /* --------------------- SUBDEV OPS --------------------------------------- */
778
779 static const struct v4l2_subdev_ops adv7511_ops = {
780 .core = &adv7511_core_ops,
781 .pad = &adv7511_pad_ops,
782 .video = &adv7511_video_ops,
783 .audio = &adv7511_audio_ops,
784 };
785
786 /* ----------------------------------------------------------------------- */
787 static void adv7511_dbg_dump_edid(int lvl, int debug, struct v4l2_subdev *sd, int segment, uint8_t *buf)
788 {
789 if (debug >= lvl) {
790 int i, j;
791 v4l2_dbg(lvl, debug, sd, "edid segment %d\n", segment);
792 for (i = 0; i < 256; i += 16) {
793 u8 b[128];
794 u8 *bp = b;
795 if (i == 128)
796 v4l2_dbg(lvl, debug, sd, "\n");
797 for (j = i; j < i + 16; j++) {
798 sprintf(bp, "0x%02x, ", buf[j]);
799 bp += 6;
800 }
801 bp[0] = '\0';
802 v4l2_dbg(lvl, debug, sd, "%s\n", b);
803 }
804 }
805 }
806
807 static void adv7511_notify_no_edid(struct v4l2_subdev *sd)
808 {
809 struct adv7511_state *state = get_adv7511_state(sd);
810 struct adv7511_edid_detect ed;
811
812 /* We failed to read the EDID, so send an event for this. */
813 ed.present = false;
814 ed.segment = adv7511_rd(sd, 0xc4);
815 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
816 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, 0x0);
817 }
818
819 static void adv7511_edid_handler(struct work_struct *work)
820 {
821 struct delayed_work *dwork = to_delayed_work(work);
822 struct adv7511_state *state = container_of(dwork, struct adv7511_state, edid_handler);
823 struct v4l2_subdev *sd = &state->sd;
824
825 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
826
827 if (adv7511_check_edid_status(sd)) {
828 /* Return if we received the EDID. */
829 return;
830 }
831
832 if (adv7511_have_hotplug(sd)) {
833 /* We must retry reading the EDID several times, it is possible
834 * that initially the EDID couldn't be read due to i2c errors
835 * (DVI connectors are particularly prone to this problem). */
836 if (state->edid.read_retries) {
837 state->edid.read_retries--;
838 v4l2_dbg(1, debug, sd, "%s: edid read failed\n", __func__);
839 state->have_monitor = false;
840 adv7511_s_power(sd, false);
841 adv7511_s_power(sd, true);
842 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
843 return;
844 }
845 }
846
847 /* We failed to read the EDID, so send an event for this. */
848 adv7511_notify_no_edid(sd);
849 v4l2_dbg(1, debug, sd, "%s: no edid found\n", __func__);
850 }
851
852 static void adv7511_audio_setup(struct v4l2_subdev *sd)
853 {
854 v4l2_dbg(1, debug, sd, "%s\n", __func__);
855
856 adv7511_s_i2s_clock_freq(sd, 48000);
857 adv7511_s_clock_freq(sd, 48000);
858 adv7511_s_routing(sd, 0, 0, 0);
859 }
860
861 /* Configure hdmi transmitter. */
862 static void adv7511_setup(struct v4l2_subdev *sd)
863 {
864 struct adv7511_state *state = get_adv7511_state(sd);
865 v4l2_dbg(1, debug, sd, "%s\n", __func__);
866
867 /* Input format: RGB 4:4:4 */
868 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x0);
869 /* Output format: RGB 4:4:4 */
870 adv7511_wr_and_or(sd, 0x16, 0x7f, 0x0);
871 /* 1st order interpolation 4:2:2 -> 4:4:4 up conversion, Aspect ratio: 16:9 */
872 adv7511_wr_and_or(sd, 0x17, 0xf9, 0x06);
873 /* Disable pixel repetition */
874 adv7511_wr_and_or(sd, 0x3b, 0x9f, 0x0);
875 /* Disable CSC */
876 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x0);
877 /* Output format: RGB 4:4:4, Active Format Information is valid,
878 * underscanned */
879 adv7511_wr_and_or(sd, 0x55, 0x9c, 0x12);
880 /* AVI Info frame packet enable, Audio Info frame disable */
881 adv7511_wr_and_or(sd, 0x44, 0xe7, 0x10);
882 /* Colorimetry, Active format aspect ratio: same as picure. */
883 adv7511_wr(sd, 0x56, 0xa8);
884 /* No encryption */
885 adv7511_wr_and_or(sd, 0xaf, 0xed, 0x0);
886
887 /* Positive clk edge capture for input video clock */
888 adv7511_wr_and_or(sd, 0xba, 0x1f, 0x60);
889
890 adv7511_audio_setup(sd);
891
892 v4l2_ctrl_handler_setup(&state->hdl);
893 }
894
895 static void adv7511_notify_monitor_detect(struct v4l2_subdev *sd)
896 {
897 struct adv7511_monitor_detect mdt;
898 struct adv7511_state *state = get_adv7511_state(sd);
899
900 mdt.present = state->have_monitor;
901 v4l2_subdev_notify(sd, ADV7511_MONITOR_DETECT, (void *)&mdt);
902 }
903
904 static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd)
905 {
906 struct adv7511_state *state = get_adv7511_state(sd);
907 /* read hotplug and rx-sense state */
908 uint8_t status = adv7511_rd(sd, 0x42);
909
910 v4l2_dbg(1, debug, sd, "%s: status: 0x%x%s%s\n",
911 __func__,
912 status,
913 status & MASK_ADV7511_HPD_DETECT ? ", hotplug" : "",
914 status & MASK_ADV7511_MSEN_DETECT ? ", rx-sense" : "");
915
916 /* update read only ctrls */
917 v4l2_ctrl_s_ctrl(state->hotplug_ctrl, adv7511_have_hotplug(sd) ? 0x1 : 0x0);
918 v4l2_ctrl_s_ctrl(state->rx_sense_ctrl, adv7511_have_rx_sense(sd) ? 0x1 : 0x0);
919
920 if ((status & MASK_ADV7511_HPD_DETECT) && ((status & MASK_ADV7511_MSEN_DETECT) || state->edid.segments)) {
921 v4l2_dbg(1, debug, sd, "%s: hotplug and (rx-sense or edid)\n", __func__);
922 if (!state->have_monitor) {
923 v4l2_dbg(1, debug, sd, "%s: monitor detected\n", __func__);
924 state->have_monitor = true;
925 adv7511_set_isr(sd, true);
926 if (!adv7511_s_power(sd, true)) {
927 v4l2_dbg(1, debug, sd, "%s: monitor detected, powerup failed\n", __func__);
928 return;
929 }
930 adv7511_setup(sd);
931 adv7511_notify_monitor_detect(sd);
932 state->edid.read_retries = EDID_MAX_RETRIES;
933 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
934 }
935 } else if (status & MASK_ADV7511_HPD_DETECT) {
936 v4l2_dbg(1, debug, sd, "%s: hotplug detected\n", __func__);
937 state->edid.read_retries = EDID_MAX_RETRIES;
938 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
939 } else if (!(status & MASK_ADV7511_HPD_DETECT)) {
940 v4l2_dbg(1, debug, sd, "%s: hotplug not detected\n", __func__);
941 if (state->have_monitor) {
942 v4l2_dbg(1, debug, sd, "%s: monitor not detected\n", __func__);
943 state->have_monitor = false;
944 adv7511_notify_monitor_detect(sd);
945 }
946 adv7511_s_power(sd, false);
947 memset(&state->edid, 0, sizeof(struct adv7511_state_edid));
948 adv7511_notify_no_edid(sd);
949 }
950 }
951
952 static bool edid_block_verify_crc(uint8_t *edid_block)
953 {
954 int i;
955 uint8_t sum = 0;
956
957 for (i = 0; i < 128; i++)
958 sum += *(edid_block + i);
959 return (sum == 0);
960 }
961
962 static bool edid_segment_verify_crc(struct v4l2_subdev *sd, u32 segment)
963 {
964 struct adv7511_state *state = get_adv7511_state(sd);
965 u32 blocks = state->edid.blocks;
966 uint8_t *data = state->edid.data;
967
968 if (edid_block_verify_crc(&data[segment * 256])) {
969 if ((segment + 1) * 2 <= blocks)
970 return edid_block_verify_crc(&data[segment * 256 + 128]);
971 return true;
972 }
973 return false;
974 }
975
976 static bool adv7511_check_edid_status(struct v4l2_subdev *sd)
977 {
978 struct adv7511_state *state = get_adv7511_state(sd);
979 uint8_t edidRdy = adv7511_rd(sd, 0xc5);
980
981 v4l2_dbg(1, debug, sd, "%s: edid ready (retries: %d)\n",
982 __func__, EDID_MAX_RETRIES - state->edid.read_retries);
983
984 if (state->edid.complete)
985 return true;
986
987 if (edidRdy & MASK_ADV7511_EDID_RDY) {
988 int segment = adv7511_rd(sd, 0xc4);
989 struct adv7511_edid_detect ed;
990
991 if (segment >= EDID_MAX_SEGM) {
992 v4l2_err(sd, "edid segment number too big\n");
993 return false;
994 }
995 v4l2_dbg(1, debug, sd, "%s: got segment %d\n", __func__, segment);
996 adv7511_edid_rd(sd, 256, &state->edid.data[segment * 256]);
997 adv7511_dbg_dump_edid(2, debug, sd, segment, &state->edid.data[segment * 256]);
998 if (segment == 0) {
999 state->edid.blocks = state->edid.data[0x7e] + 1;
1000 v4l2_dbg(1, debug, sd, "%s: %d blocks in total\n", __func__, state->edid.blocks);
1001 }
1002 if (!edid_segment_verify_crc(sd, segment)) {
1003 /* edid crc error, force reread of edid segment */
1004 v4l2_dbg(1, debug, sd, "%s: edid crc error\n", __func__);
1005 state->have_monitor = false;
1006 adv7511_s_power(sd, false);
1007 adv7511_s_power(sd, true);
1008 return false;
1009 }
1010 /* one more segment read ok */
1011 state->edid.segments = segment + 1;
1012 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, 0x1);
1013 if (((state->edid.data[0x7e] >> 1) + 1) > state->edid.segments) {
1014 /* Request next EDID segment */
1015 v4l2_dbg(1, debug, sd, "%s: request segment %d\n", __func__, state->edid.segments);
1016 adv7511_wr(sd, 0xc9, 0xf);
1017 adv7511_wr(sd, 0xc4, state->edid.segments);
1018 state->edid.read_retries = EDID_MAX_RETRIES;
1019 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
1020 return false;
1021 }
1022
1023 v4l2_dbg(1, debug, sd, "%s: edid complete with %d segment(s)\n", __func__, state->edid.segments);
1024 state->edid.complete = true;
1025
1026 /* report when we have all segments
1027 but report only for segment 0
1028 */
1029 ed.present = true;
1030 ed.segment = 0;
1031 state->edid_detect_counter++;
1032 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
1033 return ed.present;
1034 }
1035
1036 return false;
1037 }
1038
1039 /* ----------------------------------------------------------------------- */
1040 /* Setup ADV7511 */
1041 static void adv7511_init_setup(struct v4l2_subdev *sd)
1042 {
1043 struct adv7511_state *state = get_adv7511_state(sd);
1044 struct adv7511_state_edid *edid = &state->edid;
1045
1046 v4l2_dbg(1, debug, sd, "%s\n", __func__);
1047
1048 /* clear all interrupts */
1049 adv7511_wr(sd, 0x96, 0xff);
1050 memset(edid, 0, sizeof(struct adv7511_state_edid));
1051 state->have_monitor = false;
1052 adv7511_set_isr(sd, false);
1053 adv7511_s_stream(sd, false);
1054 adv7511_s_audio_stream(sd, false);
1055 }
1056
1057 static int adv7511_probe(struct i2c_client *client, const struct i2c_device_id *id)
1058 {
1059 struct adv7511_state *state;
1060 struct adv7511_platform_data *pdata = client->dev.platform_data;
1061 struct v4l2_ctrl_handler *hdl;
1062 struct v4l2_subdev *sd;
1063 u8 chip_id[2];
1064 int err = -EIO;
1065
1066 /* Check if the adapter supports the needed features */
1067 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1068 return -EIO;
1069
1070 state = devm_kzalloc(&client->dev, sizeof(struct adv7511_state), GFP_KERNEL);
1071 if (!state)
1072 return -ENOMEM;
1073
1074 /* Platform data */
1075 if (!pdata) {
1076 v4l_err(client, "No platform data!\n");
1077 return -ENODEV;
1078 }
1079 memcpy(&state->pdata, pdata, sizeof(state->pdata));
1080
1081 sd = &state->sd;
1082
1083 v4l2_dbg(1, debug, sd, "detecting adv7511 client on address 0x%x\n",
1084 client->addr << 1);
1085
1086 v4l2_i2c_subdev_init(sd, client, &adv7511_ops);
1087
1088 hdl = &state->hdl;
1089 v4l2_ctrl_handler_init(hdl, 10);
1090 /* add in ascending ID order */
1091 state->hdmi_mode_ctrl = v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1092 V4L2_CID_DV_TX_MODE, V4L2_DV_TX_MODE_HDMI,
1093 0, V4L2_DV_TX_MODE_DVI_D);
1094 state->hotplug_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1095 V4L2_CID_DV_TX_HOTPLUG, 0, 1, 0, 0);
1096 state->rx_sense_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1097 V4L2_CID_DV_TX_RXSENSE, 0, 1, 0, 0);
1098 state->have_edid0_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1099 V4L2_CID_DV_TX_EDID_PRESENT, 0, 1, 0, 0);
1100 state->rgb_quantization_range_ctrl =
1101 v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1102 V4L2_CID_DV_TX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
1103 0, V4L2_DV_RGB_RANGE_AUTO);
1104 sd->ctrl_handler = hdl;
1105 if (hdl->error) {
1106 err = hdl->error;
1107 goto err_hdl;
1108 }
1109 state->hdmi_mode_ctrl->is_private = true;
1110 state->hotplug_ctrl->is_private = true;
1111 state->rx_sense_ctrl->is_private = true;
1112 state->have_edid0_ctrl->is_private = true;
1113 state->rgb_quantization_range_ctrl->is_private = true;
1114
1115 state->pad.flags = MEDIA_PAD_FL_SINK;
1116 err = media_entity_init(&sd->entity, 1, &state->pad, 0);
1117 if (err)
1118 goto err_hdl;
1119
1120 /* EDID and CEC i2c addr */
1121 state->i2c_edid_addr = state->pdata.i2c_edid << 1;
1122 state->i2c_cec_addr = state->pdata.i2c_cec << 1;
1123
1124 state->chip_revision = adv7511_rd(sd, 0x0);
1125 chip_id[0] = adv7511_rd(sd, 0xf5);
1126 chip_id[1] = adv7511_rd(sd, 0xf6);
1127 if (chip_id[0] != 0x75 || chip_id[1] != 0x11) {
1128 v4l2_err(sd, "chip_id != 0x7511, read 0x%02x%02x\n", chip_id[0], chip_id[1]);
1129 err = -EIO;
1130 goto err_entity;
1131 }
1132
1133 state->i2c_edid = i2c_new_dummy(client->adapter, state->i2c_edid_addr >> 1);
1134 if (state->i2c_edid == NULL) {
1135 v4l2_err(sd, "failed to register edid i2c client\n");
1136 err = -ENOMEM;
1137 goto err_entity;
1138 }
1139
1140 adv7511_wr(sd, 0xe2, 0x01); /* power down cec section */
1141 state->work_queue = create_singlethread_workqueue(sd->name);
1142 if (state->work_queue == NULL) {
1143 v4l2_err(sd, "could not create workqueue\n");
1144 err = -ENOMEM;
1145 goto err_unreg_cec;
1146 }
1147
1148 INIT_DELAYED_WORK(&state->edid_handler, adv7511_edid_handler);
1149
1150 adv7511_init_setup(sd);
1151 adv7511_set_isr(sd, true);
1152 adv7511_check_monitor_present_status(sd);
1153
1154 v4l2_info(sd, "%s found @ 0x%x (%s)\n", client->name,
1155 client->addr << 1, client->adapter->name);
1156 return 0;
1157
1158 err_unreg_cec:
1159 i2c_unregister_device(state->i2c_edid);
1160 err_entity:
1161 media_entity_cleanup(&sd->entity);
1162 err_hdl:
1163 v4l2_ctrl_handler_free(&state->hdl);
1164 return err;
1165 }
1166
1167 /* ----------------------------------------------------------------------- */
1168
1169 static int adv7511_remove(struct i2c_client *client)
1170 {
1171 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1172 struct adv7511_state *state = get_adv7511_state(sd);
1173
1174 state->chip_revision = -1;
1175
1176 v4l2_dbg(1, debug, sd, "%s removed @ 0x%x (%s)\n", client->name,
1177 client->addr << 1, client->adapter->name);
1178
1179 adv7511_init_setup(sd);
1180 cancel_delayed_work(&state->edid_handler);
1181 i2c_unregister_device(state->i2c_edid);
1182 destroy_workqueue(state->work_queue);
1183 v4l2_device_unregister_subdev(sd);
1184 media_entity_cleanup(&sd->entity);
1185 v4l2_ctrl_handler_free(sd->ctrl_handler);
1186 return 0;
1187 }
1188
1189 /* ----------------------------------------------------------------------- */
1190
1191 static struct i2c_device_id adv7511_id[] = {
1192 { "adv7511", 0 },
1193 { }
1194 };
1195 MODULE_DEVICE_TABLE(i2c, adv7511_id);
1196
1197 static struct i2c_driver adv7511_driver = {
1198 .driver = {
1199 .owner = THIS_MODULE,
1200 .name = "adv7511",
1201 },
1202 .probe = adv7511_probe,
1203 .remove = adv7511_remove,
1204 .id_table = adv7511_id,
1205 };
1206
1207 module_i2c_driver(adv7511_driver);
Linux with added FPC-III support