projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] ad9389b: Add pad-level DV timings operations
[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");
3ecabed1
MB		 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 }
5a544cce
HV		 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 */
489static 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 */
541static 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 */
575static 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
b09dfac8 600static int adv7511_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
5a544cce
HV		 601{
602 struct adv7511_state *state = get_adv7511_state(sd);
603
604 if (edid->pad != 0)
605 return -EINVAL;
606 if ((edid->blocks == 0) || (edid->blocks > 256))
607 return -EINVAL;
608 if (!edid->edid)
609 return -EINVAL;
610 if (!state->edid.segments) {
611 v4l2_dbg(1, debug, sd, "EDID segment 0 not found\n");
612 return -ENODATA;
613 }
614 if (edid->start_block >= state->edid.segments * 2)
615 return -E2BIG;
616 if ((edid->blocks + edid->start_block) >= state->edid.segments * 2)
617 edid->blocks = state->edid.segments * 2 - edid->start_block;
618
619 memcpy(edid->edid, &state->edid.data[edid->start_block * 128],
620 128 * edid->blocks);
621 return 0;
622}
623
624static const struct v4l2_subdev_pad_ops adv7511_pad_ops = {
625 .get_edid = adv7511_get_edid,
626};
627
628static const struct v4l2_subdev_core_ops adv7511_core_ops = {
629 .log_status = adv7511_log_status,
630#ifdef CONFIG_VIDEO_ADV_DEBUG
631 .g_register = adv7511_g_register,
632 .s_register = adv7511_s_register,
633#endif
634 .s_power = adv7511_s_power,
635 .interrupt_service_routine = adv7511_isr,
636};
637
638/* ------------------------------ VIDEO OPS ------------------------------ */
639
640/* Enable/disable adv7511 output */
641static int adv7511_s_stream(struct v4l2_subdev *sd, int enable)
642{
643 struct adv7511_state *state = get_adv7511_state(sd);
644
645 v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis"));
646 adv7511_wr_and_or(sd, 0xa1, ~0x3c, (enable ? 0 : 0x3c));
647 if (enable) {
648 adv7511_check_monitor_present_status(sd);
649 } else {
650 adv7511_s_power(sd, 0);
651 state->have_monitor = false;
652 }
653 return 0;
654}
655
656static int adv7511_s_dv_timings(struct v4l2_subdev *sd,
657 struct v4l2_dv_timings *timings)
658{
659 struct adv7511_state *state = get_adv7511_state(sd);
660
661 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
662
663 /* quick sanity check */
664 if (!v4l2_valid_dv_timings(timings, &adv7511_timings_cap, NULL, NULL))
665 return -EINVAL;
666
667 /* Fill the optional fields .standards and .flags in struct v4l2_dv_timings
668 if the format is one of the CEA or DMT timings. */
669 v4l2_find_dv_timings_cap(timings, &adv7511_timings_cap, 0, NULL, NULL);
670
671 timings->bt.flags &= ~V4L2_DV_FL_REDUCED_FPS;
672
673 /* save timings */
674 state->dv_timings = *timings;
675
676 /* update quantization range based on new dv_timings */
677 adv7511_set_rgb_quantization_mode(sd, state->rgb_quantization_range_ctrl);
678
679 /* update AVI infoframe */
680 adv7511_set_IT_content_AVI_InfoFrame(sd);
681
682 return 0;
683}
684
685static int adv7511_g_dv_timings(struct v4l2_subdev *sd,
686 struct v4l2_dv_timings *timings)
687{
688 struct adv7511_state *state = get_adv7511_state(sd);
689
690 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
691
692 if (!timings)
693 return -EINVAL;
694
695 *timings = state->dv_timings;
696
697 return 0;
698}
699
700static int adv7511_enum_dv_timings(struct v4l2_subdev *sd,
701 struct v4l2_enum_dv_timings *timings)
702{
703 return v4l2_enum_dv_timings_cap(timings, &adv7511_timings_cap, NULL, NULL);
704}
705
706static int adv7511_dv_timings_cap(struct v4l2_subdev *sd,
707 struct v4l2_dv_timings_cap *cap)
708{
709 *cap = adv7511_timings_cap;
710 return 0;
711}
712
713static const struct v4l2_subdev_video_ops adv7511_video_ops = {
714 .s_stream = adv7511_s_stream,
715 .s_dv_timings = adv7511_s_dv_timings,
716 .g_dv_timings = adv7511_g_dv_timings,
717 .enum_dv_timings = adv7511_enum_dv_timings,
718 .dv_timings_cap = adv7511_dv_timings_cap,
719};
720
721/* ------------------------------ AUDIO OPS ------------------------------ */
722static int adv7511_s_audio_stream(struct v4l2_subdev *sd, int enable)
723{
724 v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis"));
725
726 if (enable)
727 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x80);
728 else
729 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x40);
730
731 return 0;
732}
733
734static int adv7511_s_clock_freq(struct v4l2_subdev *sd, u32 freq)
735{
736 u32 N;
737
738 switch (freq) {
739 case 32000: N = 4096; break;
740 case 44100: N = 6272; break;
741 case 48000: N = 6144; break;
742 case 88200: N = 12544; break;
743 case 96000: N = 12288; break;
744 case 176400: N = 25088; break;
745 case 192000: N = 24576; break;
746 default:
747 return -EINVAL;
748 }
749
750 /* Set N (used with CTS to regenerate the audio clock) */
751 adv7511_wr(sd, 0x01, (N >> 16) & 0xf);
752 adv7511_wr(sd, 0x02, (N >> 8) & 0xff);
753 adv7511_wr(sd, 0x03, N & 0xff);
754
755 return 0;
756}
757
758static int adv7511_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq)
759{
760 u32 i2s_sf;
761
762 switch (freq) {
763 case 32000: i2s_sf = 0x30; break;
764 case 44100: i2s_sf = 0x00; break;
765 case 48000: i2s_sf = 0x20; break;
766 case 88200: i2s_sf = 0x80; break;
767 case 96000: i2s_sf = 0xa0; break;
768 case 176400: i2s_sf = 0xc0; break;
769 case 192000: i2s_sf = 0xe0; break;
770 default:
771 return -EINVAL;
772 }
773
774 /* Set sampling frequency for I2S audio to 48 kHz */
775 adv7511_wr_and_or(sd, 0x15, 0xf, i2s_sf);
776
777 return 0;
778}
779
780static int adv7511_s_routing(struct v4l2_subdev *sd, u32 input, u32 output, u32 config)
781{
782 /* Only 2 channels in use for application */
783 adv7511_wr_and_or(sd, 0x73, 0xf8, 0x1);
784 /* Speaker mapping */
785 adv7511_wr(sd, 0x76, 0x00);
786
787 /* 16 bit audio word length */
788 adv7511_wr_and_or(sd, 0x14, 0xf0, 0x02);
789
790 return 0;
791}
792
793static const struct v4l2_subdev_audio_ops adv7511_audio_ops = {
794 .s_stream = adv7511_s_audio_stream,
795 .s_clock_freq = adv7511_s_clock_freq,
796 .s_i2s_clock_freq = adv7511_s_i2s_clock_freq,
797 .s_routing = adv7511_s_routing,
798};
799
800/* --------------------- SUBDEV OPS --------------------------------------- */
801
802static const struct v4l2_subdev_ops adv7511_ops = {
803 .core = &adv7511_core_ops,
804 .pad = &adv7511_pad_ops,
805 .video = &adv7511_video_ops,
806 .audio = &adv7511_audio_ops,
807};
808
809/* ----------------------------------------------------------------------- */
810static void adv7511_dbg_dump_edid(int lvl, int debug, struct v4l2_subdev *sd, int segment, uint8_t *buf)
811{
812 if (debug >= lvl) {
813 int i, j;
814 v4l2_dbg(lvl, debug, sd, "edid segment %d\n", segment);
815 for (i = 0; i < 256; i += 16) {
816 u8 b[128];
817 u8 *bp = b;
818 if (i == 128)
819 v4l2_dbg(lvl, debug, sd, "\n");
820 for (j = i; j < i + 16; j++) {
821 sprintf(bp, "0x%02x, ", buf[j]);
822 bp += 6;
823 }
824 bp[0] = '\0';
825 v4l2_dbg(lvl, debug, sd, "%s\n", b);
826 }
827 }
828}
829
830static void adv7511_edid_handler(struct work_struct *work)
831{
832 struct delayed_work *dwork = to_delayed_work(work);
833 struct adv7511_state *state = container_of(dwork, struct adv7511_state, edid_handler);
834 struct v4l2_subdev *sd = &state->sd;
835 struct adv7511_edid_detect ed;
836
837 v4l2_dbg(1, debug, sd, "%s:\n", __func__);
838
839 if (adv7511_check_edid_status(sd)) {
840 /* Return if we received the EDID. */
841 return;
842 }
843
844 if (adv7511_have_hotplug(sd)) {
845 /* We must retry reading the EDID several times, it is possible
846 * that initially the EDID couldn't be read due to i2c errors
847 * (DVI connectors are particularly prone to this problem). */
848 if (state->edid.read_retries) {
849 state->edid.read_retries--;
850 v4l2_dbg(1, debug, sd, "%s: edid read failed\n", __func__);
851 state->have_monitor = false;
852 adv7511_s_power(sd, false);
853 adv7511_s_power(sd, true);
854 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
855 return;
856 }
857 }
858
859 /* We failed to read the EDID, so send an event for this. */
860 ed.present = false;
861 ed.segment = adv7511_rd(sd, 0xc4);
862 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
863 v4l2_dbg(1, debug, sd, "%s: no edid found\n", __func__);
864}
865
866static void adv7511_audio_setup(struct v4l2_subdev *sd)
867{
868 v4l2_dbg(1, debug, sd, "%s\n", __func__);
869
870 adv7511_s_i2s_clock_freq(sd, 48000);
871 adv7511_s_clock_freq(sd, 48000);
872 adv7511_s_routing(sd, 0, 0, 0);
873}
874
875/* Configure hdmi transmitter. */
876static void adv7511_setup(struct v4l2_subdev *sd)
877{
878 struct adv7511_state *state = get_adv7511_state(sd);
879 v4l2_dbg(1, debug, sd, "%s\n", __func__);
880
881 /* Input format: RGB 4:4:4 */
882 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x0);
883 /* Output format: RGB 4:4:4 */
884 adv7511_wr_and_or(sd, 0x16, 0x7f, 0x0);
885 /* 1st order interpolation 4:2:2 -> 4:4:4 up conversion, Aspect ratio: 16:9 */
886 adv7511_wr_and_or(sd, 0x17, 0xf9, 0x06);
887 /* Disable pixel repetition */
888 adv7511_wr_and_or(sd, 0x3b, 0x9f, 0x0);
889 /* Disable CSC */
890 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x0);
891 /* Output format: RGB 4:4:4, Active Format Information is valid,
892 * underscanned */
893 adv7511_wr_and_or(sd, 0x55, 0x9c, 0x12);
894 /* AVI Info frame packet enable, Audio Info frame disable */
895 adv7511_wr_and_or(sd, 0x44, 0xe7, 0x10);
896 /* Colorimetry, Active format aspect ratio: same as picure. */
897 adv7511_wr(sd, 0x56, 0xa8);
898 /* No encryption */
899 adv7511_wr_and_or(sd, 0xaf, 0xed, 0x0);
900
901 /* Positive clk edge capture for input video clock */
902 adv7511_wr_and_or(sd, 0xba, 0x1f, 0x60);
903
904 adv7511_audio_setup(sd);
905
906 v4l2_ctrl_handler_setup(&state->hdl);
907}
908
909static void adv7511_notify_monitor_detect(struct v4l2_subdev *sd)
910{
911 struct adv7511_monitor_detect mdt;
912 struct adv7511_state *state = get_adv7511_state(sd);
913
914 mdt.present = state->have_monitor;
915 v4l2_subdev_notify(sd, ADV7511_MONITOR_DETECT, (void *)&mdt);
916}
917
918static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd)
919{
920 struct adv7511_state *state = get_adv7511_state(sd);
921 /* read hotplug and rx-sense state */
922 uint8_t status = adv7511_rd(sd, 0x42);
923
924 v4l2_dbg(1, debug, sd, "%s: status: 0x%x%s%s\n",
925 __func__,
926 status,
927 status & MASK_ADV7511_HPD_DETECT ? ", hotplug" : "",
928 status & MASK_ADV7511_MSEN_DETECT ? ", rx-sense" : "");
929
930 /* update read only ctrls */
931 v4l2_ctrl_s_ctrl(state->hotplug_ctrl, adv7511_have_hotplug(sd) ? 0x1 : 0x0);
932 v4l2_ctrl_s_ctrl(state->rx_sense_ctrl, adv7511_have_rx_sense(sd) ? 0x1 : 0x0);
933 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, state->edid.segments ? 0x1 : 0x0);
934
935 if ((status & MASK_ADV7511_HPD_DETECT) && ((status & MASK_ADV7511_MSEN_DETECT) || state->edid.segments)) {
936 v4l2_dbg(1, debug, sd, "%s: hotplug and (rx-sense or edid)\n", __func__);
937 if (!state->have_monitor) {
938 v4l2_dbg(1, debug, sd, "%s: monitor detected\n", __func__);
939 state->have_monitor = true;
940 adv7511_set_isr(sd, true);
941 if (!adv7511_s_power(sd, true)) {
942 v4l2_dbg(1, debug, sd, "%s: monitor detected, powerup failed\n", __func__);
943 return;
944 }
945 adv7511_setup(sd);
946 adv7511_notify_monitor_detect(sd);
947 state->edid.read_retries = EDID_MAX_RETRIES;
948 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
949 }
950 } else if (status & MASK_ADV7511_HPD_DETECT) {
951 v4l2_dbg(1, debug, sd, "%s: hotplug detected\n", __func__);
952 state->edid.read_retries = EDID_MAX_RETRIES;
953 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
954 } else if (!(status & MASK_ADV7511_HPD_DETECT)) {
955 v4l2_dbg(1, debug, sd, "%s: hotplug not detected\n", __func__);
956 if (state->have_monitor) {
957 v4l2_dbg(1, debug, sd, "%s: monitor not detected\n", __func__);
958 state->have_monitor = false;
959 adv7511_notify_monitor_detect(sd);
960 }
961 adv7511_s_power(sd, false);
962 memset(&state->edid, 0, sizeof(struct adv7511_state_edid));
963 }
964}
965
966static bool edid_block_verify_crc(uint8_t *edid_block)
967{
5a544cce 968 uint8_t sum = 0;
928b0fe7 969 int i;
5a544cce
HV		 970
971 for (i = 0; i < 128; i++)
928b0fe7
MB		 972 sum += edid_block[i];
973 return sum == 0;
5a544cce
HV		 974}
975
928b0fe7 976static bool edid_verify_crc(struct v4l2_subdev *sd, u32 segment)
5a544cce
HV		 977{
978 struct adv7511_state *state = get_adv7511_state(sd);
979 u32 blocks = state->edid.blocks;
980 uint8_t *data = state->edid.data;
981
928b0fe7
MB		 982 if (!edid_block_verify_crc(&data[segment * 256]))
983 return false;
984 if ((segment + 1) * 2 <= blocks)
985 return edid_block_verify_crc(&data[segment * 256 + 128]);
986 return true;
987}
988
989static bool edid_verify_header(struct v4l2_subdev *sd, u32 segment)
990{
991 static const u8 hdmi_header[] = {
992 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00
993 };
994 struct adv7511_state *state = get_adv7511_state(sd);
995 u8 *data = state->edid.data;
996
997 if (segment != 0)
5a544cce 998 return true;
928b0fe7 999 return !memcmp(data, hdmi_header, sizeof(hdmi_header));
5a544cce
HV		 1000}
1001
1002static bool adv7511_check_edid_status(struct v4l2_subdev *sd)
1003{
1004 struct adv7511_state *state = get_adv7511_state(sd);
1005 uint8_t edidRdy = adv7511_rd(sd, 0xc5);
1006
1007 v4l2_dbg(1, debug, sd, "%s: edid ready (retries: %d)\n",
1008 __func__, EDID_MAX_RETRIES - state->edid.read_retries);
1009
1010 if (state->edid.complete)
1011 return true;
1012
1013 if (edidRdy & MASK_ADV7511_EDID_RDY) {
1014 int segment = adv7511_rd(sd, 0xc4);
1015 struct adv7511_edid_detect ed;
1016
1017 if (segment >= EDID_MAX_SEGM) {
1018 v4l2_err(sd, "edid segment number too big\n");
1019 return false;
1020 }
1021 v4l2_dbg(1, debug, sd, "%s: got segment %d\n", __func__, segment);
1022 adv7511_edid_rd(sd, 256, &state->edid.data[segment * 256]);
1023 adv7511_dbg_dump_edid(2, debug, sd, segment, &state->edid.data[segment * 256]);
1024 if (segment == 0) {
1025 state->edid.blocks = state->edid.data[0x7e] + 1;
1026 v4l2_dbg(1, debug, sd, "%s: %d blocks in total\n", __func__, state->edid.blocks);
1027 }
928b0fe7
MB		 1028 if (!edid_verify_crc(sd, segment) ||
1029 !edid_verify_header(sd, segment)) {
5a544cce 1030 /* edid crc error, force reread of edid segment */
928b0fe7 1031 v4l2_err(sd, "%s: edid crc or header error\n", __func__);
5a544cce
HV		 1032 state->have_monitor = false;
1033 adv7511_s_power(sd, false);
1034 adv7511_s_power(sd, true);
1035 return false;
1036 }
1037 /* one more segment read ok */
1038 state->edid.segments = segment + 1;
1039 if (((state->edid.data[0x7e] >> 1) + 1) > state->edid.segments) {
1040 /* Request next EDID segment */
1041 v4l2_dbg(1, debug, sd, "%s: request segment %d\n", __func__, state->edid.segments);
1042 adv7511_wr(sd, 0xc9, 0xf);
1043 adv7511_wr(sd, 0xc4, state->edid.segments);
1044 state->edid.read_retries = EDID_MAX_RETRIES;
1045 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
1046 return false;
1047 }
1048
1049 v4l2_dbg(1, debug, sd, "%s: edid complete with %d segment(s)\n", __func__, state->edid.segments);
1050 state->edid.complete = true;
1051
1052 /* report when we have all segments
1053 but report only for segment 0
1054 */
1055 ed.present = true;
1056 ed.segment = 0;
1057 state->edid_detect_counter++;
1058 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, state->edid.segments ? 0x1 : 0x0);
1059 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
1060 return ed.present;
1061 }
1062
1063 return false;
1064}
1065
1066/* ----------------------------------------------------------------------- */
1067/* Setup ADV7511 */
1068static void adv7511_init_setup(struct v4l2_subdev *sd)
1069{
1070 struct adv7511_state *state = get_adv7511_state(sd);
1071 struct adv7511_state_edid *edid = &state->edid;
1072
1073 v4l2_dbg(1, debug, sd, "%s\n", __func__);
1074
1075 /* clear all interrupts */
1076 adv7511_wr(sd, 0x96, 0xff);
a62c6216
MB		 1077 /*
1078 * Stop HPD from resetting a lot of registers.
1079 * It might leave the chip in a partly un-initialized state,
1080 * in particular with regards to hotplug bounces.
1081 */
1082 adv7511_wr_and_or(sd, 0xd6, 0x3f, 0xc0);
5a544cce
HV		 1083 memset(edid, 0, sizeof(struct adv7511_state_edid));
1084 state->have_monitor = false;
1085 adv7511_set_isr(sd, false);
1086 adv7511_s_stream(sd, false);
1087 adv7511_s_audio_stream(sd, false);
1088}
1089
1090static int adv7511_probe(struct i2c_client *client, const struct i2c_device_id *id)
1091{
1092 struct adv7511_state *state;
1093 struct adv7511_platform_data *pdata = client->dev.platform_data;
1094 struct v4l2_ctrl_handler *hdl;
1095 struct v4l2_subdev *sd;
1096 u8 chip_id[2];
1097 int err = -EIO;
1098
1099 /* Check if the adapter supports the needed features */
1100 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1101 return -EIO;
1102
1103 state = devm_kzalloc(&client->dev, sizeof(struct adv7511_state), GFP_KERNEL);
1104 if (!state)
1105 return -ENOMEM;
1106
1107 /* Platform data */
1108 if (!pdata) {
1109 v4l_err(client, "No platform data!\n");
1110 return -ENODEV;
1111 }
1112 memcpy(&state->pdata, pdata, sizeof(state->pdata));
1113
1114 sd = &state->sd;
1115
1116 v4l2_dbg(1, debug, sd, "detecting adv7511 client on address 0x%x\n",
1117 client->addr << 1);
1118
1119 v4l2_i2c_subdev_init(sd, client, &adv7511_ops);
1120
1121 hdl = &state->hdl;
1122 v4l2_ctrl_handler_init(hdl, 10);
1123 /* add in ascending ID order */
1124 state->hdmi_mode_ctrl = v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1125 V4L2_CID_DV_TX_MODE, V4L2_DV_TX_MODE_HDMI,
1126 0, V4L2_DV_TX_MODE_DVI_D);
1127 state->hotplug_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1128 V4L2_CID_DV_TX_HOTPLUG, 0, 1, 0, 0);
1129 state->rx_sense_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1130 V4L2_CID_DV_TX_RXSENSE, 0, 1, 0, 0);
1131 state->have_edid0_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1132 V4L2_CID_DV_TX_EDID_PRESENT, 0, 1, 0, 0);
1133 state->rgb_quantization_range_ctrl =
1134 v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1135 V4L2_CID_DV_TX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
1136 0, V4L2_DV_RGB_RANGE_AUTO);
1137 sd->ctrl_handler = hdl;
1138 if (hdl->error) {
1139 err = hdl->error;
1140 goto err_hdl;
1141 }
1142 state->hdmi_mode_ctrl->is_private = true;
1143 state->hotplug_ctrl->is_private = true;
1144 state->rx_sense_ctrl->is_private = true;
1145 state->have_edid0_ctrl->is_private = true;
1146 state->rgb_quantization_range_ctrl->is_private = true;
1147
1148 state->pad.flags = MEDIA_PAD_FL_SINK;
1149 err = media_entity_init(&sd->entity, 1, &state->pad, 0);
1150 if (err)
1151 goto err_hdl;
1152
1153 /* EDID and CEC i2c addr */
1154 state->i2c_edid_addr = state->pdata.i2c_edid << 1;
1155 state->i2c_cec_addr = state->pdata.i2c_cec << 1;
1156
1157 state->chip_revision = adv7511_rd(sd, 0x0);
1158 chip_id[0] = adv7511_rd(sd, 0xf5);
1159 chip_id[1] = adv7511_rd(sd, 0xf6);
1160 if (chip_id[0] != 0x75 || chip_id[1] != 0x11) {
1161 v4l2_err(sd, "chip_id != 0x7511, read 0x%02x%02x\n", chip_id[0], chip_id[1]);
1162 err = -EIO;
1163 goto err_entity;
1164 }
1165
1166 state->i2c_edid = i2c_new_dummy(client->adapter, state->i2c_edid_addr >> 1);
1167 if (state->i2c_edid == NULL) {
1168 v4l2_err(sd, "failed to register edid i2c client\n");
f527b17a 1169 err = -ENOMEM;
5a544cce
HV		 1170 goto err_entity;
1171 }
1172
1173 adv7511_wr(sd, 0xe2, 0x01); /* power down cec section */
1174 state->work_queue = create_singlethread_workqueue(sd->name);
1175 if (state->work_queue == NULL) {
1176 v4l2_err(sd, "could not create workqueue\n");
f527b17a 1177 err = -ENOMEM;
5a544cce
HV		 1178 goto err_unreg_cec;
1179 }
1180
1181 INIT_DELAYED_WORK(&state->edid_handler, adv7511_edid_handler);
1182
1183 adv7511_init_setup(sd);
1184 adv7511_set_isr(sd, true);
1185 adv7511_check_monitor_present_status(sd);
1186
1187 v4l2_info(sd, "%s found @ 0x%x (%s)\n", client->name,
1188 client->addr << 1, client->adapter->name);
1189 return 0;
1190
1191err_unreg_cec:
1192 i2c_unregister_device(state->i2c_edid);
1193err_entity:
1194 media_entity_cleanup(&sd->entity);
1195err_hdl:
1196 v4l2_ctrl_handler_free(&state->hdl);
1197 return err;
1198}
1199
1200/* ----------------------------------------------------------------------- */
1201
1202static int adv7511_remove(struct i2c_client *client)
1203{
1204 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1205 struct adv7511_state *state = get_adv7511_state(sd);
1206
1207 state->chip_revision = -1;
1208
1209 v4l2_dbg(1, debug, sd, "%s removed @ 0x%x (%s)\n", client->name,
1210 client->addr << 1, client->adapter->name);
1211
1212 adv7511_init_setup(sd);
1213 cancel_delayed_work(&state->edid_handler);
1214 i2c_unregister_device(state->i2c_edid);
1215 destroy_workqueue(state->work_queue);
1216 v4l2_device_unregister_subdev(sd);
1217 media_entity_cleanup(&sd->entity);
1218 v4l2_ctrl_handler_free(sd->ctrl_handler);
1219 return 0;
1220}
1221
1222/* ----------------------------------------------------------------------- */
1223
1224static struct i2c_device_id adv7511_id[] = {
1225 { "adv7511", 0 },
1226 { }
1227};
1228MODULE_DEVICE_TABLE(i2c, adv7511_id);
1229
1230static struct i2c_driver adv7511_driver = {
1231 .driver = {
1232 .owner = THIS_MODULE,
1233 .name = "adv7511",
1234 },
1235 .probe = adv7511_probe,
1236 .remove = adv7511_remove,
1237 .id_table = adv7511_id,
1238};
1239
1240module_i2c_driver(adv7511_driver);
Linux kernel - Deliverables
This page took 0.154839 seconds and 5 git commands to generate.