projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] adv7511: fix compilation with GCC < 4.4.6
[deliverable/linux.git] / drivers / media / i2c / adv7511.c
CommitLineData
5a544cce
HV		 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
36static int debug;
37module_param(debug, int, 0644);
38MODULE_PARM_DESC(debug, "debug level (0-2)");
39
40MODULE_DESCRIPTION("Analog Devices ADV7511 HDMI Transmitter Device Driver");
41MODULE_AUTHOR("Hans Verkuil");
42MODULE_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
69struct i2c_reg_value {
70 unsigned char reg;
71 unsigned char value;
72};
73
74struct 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
85struct 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
113static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd);
114static bool adv7511_check_edid_status(struct v4l2_subdev *sd);
115static void adv7511_setup(struct v4l2_subdev *sd);
116static int adv7511_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq);
117static int adv7511_s_clock_freq(struct v4l2_subdev *sd, u32 freq);
118
119
120static const struct v4l2_dv_timings_cap adv7511_timings_cap = {
121 .type = V4L2_DV_BT_656_1120,
aefd4a5a
GG		 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 |
5a544cce 127 V4L2_DV_BT_STD_GTF | V4L2_DV_BT_STD_CVT,
aefd4a5a
GG		 128 V4L2_DV_BT_CAP_PROGRESSIVE | V4L2_DV_BT_CAP_REDUCED_BLANKING |
129 V4L2_DV_BT_CAP_CUSTOM)
5a544cce
HV		 130};
131
132static inline struct adv7511_state *get_adv7511_state(struct v4l2_subdev *sd)
133{
134 return container_of(sd, struct adv7511_state, sd);
135}
136
137static 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
144static 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
159static 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
174static 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
181static 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). */
198static 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
203static 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
220static 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
235static inline bool adv7511_have_hotplug(struct v4l2_subdev *sd)
236{
237 return adv7511_rd(sd, 0x42) & MASK_ADV7511_HPD_DETECT;
238}
239
240static inline bool adv7511_have_rx_sense(struct v4l2_subdev *sd)
241{
242 return adv7511_rd(sd, 0x42) & MASK_ADV7511_MSEN_DETECT;
243}
244
245static 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
250static 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
286static 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
307static 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
319static 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
352static 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
370static 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
377static void adv7511_inv_register(struct v4l2_subdev *sd)
378{
379 v4l2_info(sd, "0x000-0x0ff: Main Map\n");
380}
381
382static 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
397static 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
412static 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 */
466static 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 */
518static 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 */
552static 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
577static 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
601static const struct v4l2_subdev_pad_ops adv7511_pad_ops = {
602 .get_edid = adv7511_get_edid,
603};
604
605static 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 */
618static 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
633static 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
662static 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
677static 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
683static 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
690static 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 ------------------------------ */
699static 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
711static 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
735static 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
757static 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
770static 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
779static 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/* ----------------------------------------------------------------------- */
787static 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
807static void adv7511_edid_handler(struct work_struct *work)
808{
809 struct delayed_work *dwork = to_delayed_work(work);
810 struct adv7511_state *state = container_of(dwork, struct adv7511_state, edid_handler);
811 struct v4l2_subdev *sd = &state->sd;
812 struct adv7511_edid_detect ed;
813
814 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
815
816 if (adv7511_check_edid_status(sd)) {
817 /* Return if we received the EDID. */
818 return;
819 }
820
821 if (adv7511_have_hotplug(sd)) {
822 /* We must retry reading the EDID several times, it is possible
823 * that initially the EDID couldn't be read due to i2c errors
824 * (DVI connectors are particularly prone to this problem). */
825 if (state->edid.read_retries) {
826 state->edid.read_retries--;
827 v4l2_dbg(1, debug, sd, "%s: edid read failed\n", __func__);
828 state->have_monitor = false;
829 adv7511_s_power(sd, false);
830 adv7511_s_power(sd, true);
831 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
832 return;
833 }
834 }
835
836 /* We failed to read the EDID, so send an event for this. */
837 ed.present = false;
838 ed.segment = adv7511_rd(sd, 0xc4);
839 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
840 v4l2_dbg(1, debug, sd, "%s: no edid found\n", __func__);
841}
842
843static void adv7511_audio_setup(struct v4l2_subdev *sd)
844{
845 v4l2_dbg(1, debug, sd, "%s\n", __func__);
846
847 adv7511_s_i2s_clock_freq(sd, 48000);
848 adv7511_s_clock_freq(sd, 48000);
849 adv7511_s_routing(sd, 0, 0, 0);
850}
851
852/* Configure hdmi transmitter. */
853static void adv7511_setup(struct v4l2_subdev *sd)
854{
855 struct adv7511_state *state = get_adv7511_state(sd);
856 v4l2_dbg(1, debug, sd, "%s\n", __func__);
857
858 /* Input format: RGB 4:4:4 */
859 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x0);
860 /* Output format: RGB 4:4:4 */
861 adv7511_wr_and_or(sd, 0x16, 0x7f, 0x0);
862 /* 1st order interpolation 4:2:2 -> 4:4:4 up conversion, Aspect ratio: 16:9 */
863 adv7511_wr_and_or(sd, 0x17, 0xf9, 0x06);
864 /* Disable pixel repetition */
865 adv7511_wr_and_or(sd, 0x3b, 0x9f, 0x0);
866 /* Disable CSC */
867 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x0);
868 /* Output format: RGB 4:4:4, Active Format Information is valid,
869 * underscanned */
870 adv7511_wr_and_or(sd, 0x55, 0x9c, 0x12);
871 /* AVI Info frame packet enable, Audio Info frame disable */
872 adv7511_wr_and_or(sd, 0x44, 0xe7, 0x10);
873 /* Colorimetry, Active format aspect ratio: same as picure. */
874 adv7511_wr(sd, 0x56, 0xa8);
875 /* No encryption */
876 adv7511_wr_and_or(sd, 0xaf, 0xed, 0x0);
877
878 /* Positive clk edge capture for input video clock */
879 adv7511_wr_and_or(sd, 0xba, 0x1f, 0x60);
880
881 adv7511_audio_setup(sd);
882
883 v4l2_ctrl_handler_setup(&state->hdl);
884}
885
886static void adv7511_notify_monitor_detect(struct v4l2_subdev *sd)
887{
888 struct adv7511_monitor_detect mdt;
889 struct adv7511_state *state = get_adv7511_state(sd);
890
891 mdt.present = state->have_monitor;
892 v4l2_subdev_notify(sd, ADV7511_MONITOR_DETECT, (void *)&mdt);
893}
894
895static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd)
896{
897 struct adv7511_state *state = get_adv7511_state(sd);
898 /* read hotplug and rx-sense state */
899 uint8_t status = adv7511_rd(sd, 0x42);
900
901 v4l2_dbg(1, debug, sd, "%s: status: 0x%x%s%s\n",
902 __func__,
903 status,
904 status & MASK_ADV7511_HPD_DETECT ? ", hotplug" : "",
905 status & MASK_ADV7511_MSEN_DETECT ? ", rx-sense" : "");
906
907 /* update read only ctrls */
908 v4l2_ctrl_s_ctrl(state->hotplug_ctrl, adv7511_have_hotplug(sd) ? 0x1 : 0x0);
909 v4l2_ctrl_s_ctrl(state->rx_sense_ctrl, adv7511_have_rx_sense(sd) ? 0x1 : 0x0);
910 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, state->edid.segments ? 0x1 : 0x0);
911
912 if ((status & MASK_ADV7511_HPD_DETECT) && ((status & MASK_ADV7511_MSEN_DETECT) || state->edid.segments)) {
913 v4l2_dbg(1, debug, sd, "%s: hotplug and (rx-sense or edid)\n", __func__);
914 if (!state->have_monitor) {
915 v4l2_dbg(1, debug, sd, "%s: monitor detected\n", __func__);
916 state->have_monitor = true;
917 adv7511_set_isr(sd, true);
918 if (!adv7511_s_power(sd, true)) {
919 v4l2_dbg(1, debug, sd, "%s: monitor detected, powerup failed\n", __func__);
920 return;
921 }
922 adv7511_setup(sd);
923 adv7511_notify_monitor_detect(sd);
924 state->edid.read_retries = EDID_MAX_RETRIES;
925 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
926 }
927 } else if (status & MASK_ADV7511_HPD_DETECT) {
928 v4l2_dbg(1, debug, sd, "%s: hotplug detected\n", __func__);
929 state->edid.read_retries = EDID_MAX_RETRIES;
930 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
931 } else if (!(status & MASK_ADV7511_HPD_DETECT)) {
932 v4l2_dbg(1, debug, sd, "%s: hotplug not detected\n", __func__);
933 if (state->have_monitor) {
934 v4l2_dbg(1, debug, sd, "%s: monitor not detected\n", __func__);
935 state->have_monitor = false;
936 adv7511_notify_monitor_detect(sd);
937 }
938 adv7511_s_power(sd, false);
939 memset(&state->edid, 0, sizeof(struct adv7511_state_edid));
940 }
941}
942
943static bool edid_block_verify_crc(uint8_t *edid_block)
944{
945 int i;
946 uint8_t sum = 0;
947
948 for (i = 0; i < 128; i++)
949 sum += *(edid_block + i);
950 return (sum == 0);
951}
952
953static bool edid_segment_verify_crc(struct v4l2_subdev *sd, u32 segment)
954{
955 struct adv7511_state *state = get_adv7511_state(sd);
956 u32 blocks = state->edid.blocks;
957 uint8_t *data = state->edid.data;
958
959 if (edid_block_verify_crc(&data[segment * 256])) {
960 if ((segment + 1) * 2 <= blocks)
961 return edid_block_verify_crc(&data[segment * 256 + 128]);
962 return true;
963 }
964 return false;
965}
966
967static bool adv7511_check_edid_status(struct v4l2_subdev *sd)
968{
969 struct adv7511_state *state = get_adv7511_state(sd);
970 uint8_t edidRdy = adv7511_rd(sd, 0xc5);
971
972 v4l2_dbg(1, debug, sd, "%s: edid ready (retries: %d)\n",
973 __func__, EDID_MAX_RETRIES - state->edid.read_retries);
974
975 if (state->edid.complete)
976 return true;
977
978 if (edidRdy & MASK_ADV7511_EDID_RDY) {
979 int segment = adv7511_rd(sd, 0xc4);
980 struct adv7511_edid_detect ed;
981
982 if (segment >= EDID_MAX_SEGM) {
983 v4l2_err(sd, "edid segment number too big\n");
984 return false;
985 }
986 v4l2_dbg(1, debug, sd, "%s: got segment %d\n", __func__, segment);
987 adv7511_edid_rd(sd, 256, &state->edid.data[segment * 256]);
988 adv7511_dbg_dump_edid(2, debug, sd, segment, &state->edid.data[segment * 256]);
989 if (segment == 0) {
990 state->edid.blocks = state->edid.data[0x7e] + 1;
991 v4l2_dbg(1, debug, sd, "%s: %d blocks in total\n", __func__, state->edid.blocks);
992 }
993 if (!edid_segment_verify_crc(sd, segment)) {
994 /* edid crc error, force reread of edid segment */
995 v4l2_dbg(1, debug, sd, "%s: edid crc error\n", __func__);
996 state->have_monitor = false;
997 adv7511_s_power(sd, false);
998 adv7511_s_power(sd, true);
999 return false;
1000 }
1001 /* one more segment read ok */
1002 state->edid.segments = segment + 1;
1003 if (((state->edid.data[0x7e] >> 1) + 1) > state->edid.segments) {
1004 /* Request next EDID segment */
1005 v4l2_dbg(1, debug, sd, "%s: request segment %d\n", __func__, state->edid.segments);
1006 adv7511_wr(sd, 0xc9, 0xf);
1007 adv7511_wr(sd, 0xc4, state->edid.segments);
1008 state->edid.read_retries = EDID_MAX_RETRIES;
1009 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
1010 return false;
1011 }
1012
1013 v4l2_dbg(1, debug, sd, "%s: edid complete with %d segment(s)\n", __func__, state->edid.segments);
1014 state->edid.complete = true;
1015
1016 /* report when we have all segments
1017 but report only for segment 0
1018 */
1019 ed.present = true;
1020 ed.segment = 0;
1021 state->edid_detect_counter++;
1022 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, state->edid.segments ? 0x1 : 0x0);
1023 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
1024 return ed.present;
1025 }
1026
1027 return false;
1028}
1029
1030/* ----------------------------------------------------------------------- */
1031/* Setup ADV7511 */
1032static void adv7511_init_setup(struct v4l2_subdev *sd)
1033{
1034 struct adv7511_state *state = get_adv7511_state(sd);
1035 struct adv7511_state_edid *edid = &state->edid;
1036
1037 v4l2_dbg(1, debug, sd, "%s\n", __func__);
1038
1039 /* clear all interrupts */
1040 adv7511_wr(sd, 0x96, 0xff);
1041 memset(edid, 0, sizeof(struct adv7511_state_edid));
1042 state->have_monitor = false;
1043 adv7511_set_isr(sd, false);
1044 adv7511_s_stream(sd, false);
1045 adv7511_s_audio_stream(sd, false);
1046}
1047
1048static int adv7511_probe(struct i2c_client *client, const struct i2c_device_id *id)
1049{
1050 struct adv7511_state *state;
1051 struct adv7511_platform_data *pdata = client->dev.platform_data;
1052 struct v4l2_ctrl_handler *hdl;
1053 struct v4l2_subdev *sd;
1054 u8 chip_id[2];
1055 int err = -EIO;
1056
1057 /* Check if the adapter supports the needed features */
1058 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1059 return -EIO;
1060
1061 state = devm_kzalloc(&client->dev, sizeof(struct adv7511_state), GFP_KERNEL);
1062 if (!state)
1063 return -ENOMEM;
1064
1065 /* Platform data */
1066 if (!pdata) {
1067 v4l_err(client, "No platform data!\n");
1068 return -ENODEV;
1069 }
1070 memcpy(&state->pdata, pdata, sizeof(state->pdata));
1071
1072 sd = &state->sd;
1073
1074 v4l2_dbg(1, debug, sd, "detecting adv7511 client on address 0x%x\n",
1075 client->addr << 1);
1076
1077 v4l2_i2c_subdev_init(sd, client, &adv7511_ops);
1078
1079 hdl = &state->hdl;
1080 v4l2_ctrl_handler_init(hdl, 10);
1081 /* add in ascending ID order */
1082 state->hdmi_mode_ctrl = v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1083 V4L2_CID_DV_TX_MODE, V4L2_DV_TX_MODE_HDMI,
1084 0, V4L2_DV_TX_MODE_DVI_D);
1085 state->hotplug_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1086 V4L2_CID_DV_TX_HOTPLUG, 0, 1, 0, 0);
1087 state->rx_sense_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1088 V4L2_CID_DV_TX_RXSENSE, 0, 1, 0, 0);
1089 state->have_edid0_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1090 V4L2_CID_DV_TX_EDID_PRESENT, 0, 1, 0, 0);
1091 state->rgb_quantization_range_ctrl =
1092 v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1093 V4L2_CID_DV_TX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
1094 0, V4L2_DV_RGB_RANGE_AUTO);
1095 sd->ctrl_handler = hdl;
1096 if (hdl->error) {
1097 err = hdl->error;
1098 goto err_hdl;
1099 }
1100 state->hdmi_mode_ctrl->is_private = true;
1101 state->hotplug_ctrl->is_private = true;
1102 state->rx_sense_ctrl->is_private = true;
1103 state->have_edid0_ctrl->is_private = true;
1104 state->rgb_quantization_range_ctrl->is_private = true;
1105
1106 state->pad.flags = MEDIA_PAD_FL_SINK;
1107 err = media_entity_init(&sd->entity, 1, &state->pad, 0);
1108 if (err)
1109 goto err_hdl;
1110
1111 /* EDID and CEC i2c addr */
1112 state->i2c_edid_addr = state->pdata.i2c_edid << 1;
1113 state->i2c_cec_addr = state->pdata.i2c_cec << 1;
1114
1115 state->chip_revision = adv7511_rd(sd, 0x0);
1116 chip_id[0] = adv7511_rd(sd, 0xf5);
1117 chip_id[1] = adv7511_rd(sd, 0xf6);
1118 if (chip_id[0] != 0x75 || chip_id[1] != 0x11) {
1119 v4l2_err(sd, "chip_id != 0x7511, read 0x%02x%02x\n", chip_id[0], chip_id[1]);
1120 err = -EIO;
1121 goto err_entity;
1122 }
1123
1124 state->i2c_edid = i2c_new_dummy(client->adapter, state->i2c_edid_addr >> 1);
1125 if (state->i2c_edid == NULL) {
1126 v4l2_err(sd, "failed to register edid i2c client\n");
1127 goto err_entity;
1128 }
1129
1130 adv7511_wr(sd, 0xe2, 0x01); /* power down cec section */
1131 state->work_queue = create_singlethread_workqueue(sd->name);
1132 if (state->work_queue == NULL) {
1133 v4l2_err(sd, "could not create workqueue\n");
1134 goto err_unreg_cec;
1135 }
1136
1137 INIT_DELAYED_WORK(&state->edid_handler, adv7511_edid_handler);
1138
1139 adv7511_init_setup(sd);
1140 adv7511_set_isr(sd, true);
1141 adv7511_check_monitor_present_status(sd);
1142
1143 v4l2_info(sd, "%s found @ 0x%x (%s)\n", client->name,
1144 client->addr << 1, client->adapter->name);
1145 return 0;
1146
1147err_unreg_cec:
1148 i2c_unregister_device(state->i2c_edid);
1149err_entity:
1150 media_entity_cleanup(&sd->entity);
1151err_hdl:
1152 v4l2_ctrl_handler_free(&state->hdl);
1153 return err;
1154}
1155
1156/* ----------------------------------------------------------------------- */
1157
1158static int adv7511_remove(struct i2c_client *client)
1159{
1160 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1161 struct adv7511_state *state = get_adv7511_state(sd);
1162
1163 state->chip_revision = -1;
1164
1165 v4l2_dbg(1, debug, sd, "%s removed @ 0x%x (%s)\n", client->name,
1166 client->addr << 1, client->adapter->name);
1167
1168 adv7511_init_setup(sd);
1169 cancel_delayed_work(&state->edid_handler);
1170 i2c_unregister_device(state->i2c_edid);
1171 destroy_workqueue(state->work_queue);
1172 v4l2_device_unregister_subdev(sd);
1173 media_entity_cleanup(&sd->entity);
1174 v4l2_ctrl_handler_free(sd->ctrl_handler);
1175 return 0;
1176}
1177
1178/* ----------------------------------------------------------------------- */
1179
1180static struct i2c_device_id adv7511_id[] = {
1181 { "adv7511", 0 },
1182 { }
1183};
1184MODULE_DEVICE_TABLE(i2c, adv7511_id);
1185
1186static struct i2c_driver adv7511_driver = {
1187 .driver = {
1188 .owner = THIS_MODULE,
1189 .name = "adv7511",
1190 },
1191 .probe = adv7511_probe,
1192 .remove = adv7511_remove,
1193 .id_table = adv7511_id,
1194};
1195
1196module_i2c_driver(adv7511_driver);
Linux kernel - Deliverables
This page took 0.075984 seconds and 5 git commands to generate.