2 * drivers/media/video/tvp514x.c
4 * TI TVP5146/47 decoder driver
6 * Copyright (C) 2008 Texas Instruments Inc
7 * Author: Vaibhav Hiremath <hvaibhav@ti.com>
10 * Sivaraj R <sivaraj@ti.com>
11 * Brijesh R Jadav <brijesh.j@ti.com>
12 * Hardik Shah <hardik.shah@ti.com>
13 * Manjunath Hadli <mrh@ti.com>
14 * Karicheri Muralidharan <m-karicheri2@ti.com>
16 * This package is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License version 2 as
18 * published by the Free Software Foundation.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31 #include <linux/i2c.h>
32 #include <linux/slab.h>
33 #include <linux/delay.h>
34 #include <linux/videodev2.h>
36 #include <media/v4l2-device.h>
37 #include <media/v4l2-common.h>
38 #include <media/v4l2-chip-ident.h>
39 #include <media/tvp514x.h>
41 #include "tvp514x_regs.h"
44 #define TVP514X_MODULE_NAME "tvp514x"
46 /* Private macros for TVP */
47 #define I2C_RETRY_COUNT (5)
48 #define LOCK_RETRY_COUNT (5)
49 #define LOCK_RETRY_DELAY (200)
53 module_param(debug, bool, 0644);
54 MODULE_PARM_DESC(debug, "Debug level (0-1)");
56 MODULE_AUTHOR("Texas Instruments");
57 MODULE_DESCRIPTION("TVP514X linux decoder driver");
58 MODULE_LICENSE("GPL");
60 /* enum tvp514x_std - enum for supported standards */
68 * struct tvp514x_std_info - Structure to store standard informations
69 * @width: Line width in pixels
70 * @height:Number of active lines
71 * @video_std: Value to write in REG_VIDEO_STD register
72 * @standard: v4l2 standard structure information
74 struct tvp514x_std_info {
78 struct v4l2_standard standard;
81 static struct tvp514x_reg tvp514x_reg_list_default[0x40];
83 static int tvp514x_s_stream(struct v4l2_subdev *sd, int enable);
85 * struct tvp514x_decoder - TVP5146/47 decoder object
86 * @sd: Subdevice Slave handle
87 * @tvp514x_regs: copy of hw's regs with preset values.
88 * @pdata: Board specific
90 * @streaming: TVP5146/47 decoder streaming - enabled or disabled.
91 * @pix: Current pixel format
92 * @num_fmts: Number of formats
93 * @fmt_list: Format list
94 * @current_std: Current standard
95 * @num_stds: Number of standards
96 * @std_list: Standards list
97 * @input: Input routing at chip level
98 * @output: Output routing at chip level
100 struct tvp514x_decoder {
101 struct v4l2_subdev sd;
102 struct tvp514x_reg tvp514x_regs[ARRAY_SIZE(tvp514x_reg_list_default)];
103 const struct tvp514x_platform_data *pdata;
108 struct v4l2_pix_format pix;
110 const struct v4l2_fmtdesc *fmt_list;
112 enum tvp514x_std current_std;
114 struct tvp514x_std_info *std_list;
115 /* Input and Output Routing parameters */
120 /* TVP514x default register values */
121 static struct tvp514x_reg tvp514x_reg_list_default[] = {
122 /* Composite selected */
123 {TOK_WRITE, REG_INPUT_SEL, 0x05},
124 {TOK_WRITE, REG_AFE_GAIN_CTRL, 0x0F},
126 {TOK_WRITE, REG_VIDEO_STD, 0x00},
127 {TOK_WRITE, REG_OPERATION_MODE, 0x00},
128 {TOK_SKIP, REG_AUTOSWITCH_MASK, 0x3F},
129 {TOK_WRITE, REG_COLOR_KILLER, 0x10},
130 {TOK_WRITE, REG_LUMA_CONTROL1, 0x00},
131 {TOK_WRITE, REG_LUMA_CONTROL2, 0x00},
132 {TOK_WRITE, REG_LUMA_CONTROL3, 0x02},
133 {TOK_WRITE, REG_BRIGHTNESS, 0x80},
134 {TOK_WRITE, REG_CONTRAST, 0x80},
135 {TOK_WRITE, REG_SATURATION, 0x80},
136 {TOK_WRITE, REG_HUE, 0x00},
137 {TOK_WRITE, REG_CHROMA_CONTROL1, 0x00},
138 {TOK_WRITE, REG_CHROMA_CONTROL2, 0x0E},
140 {TOK_SKIP, 0x0F, 0x00},
141 {TOK_WRITE, REG_COMP_PR_SATURATION, 0x80},
142 {TOK_WRITE, REG_COMP_Y_CONTRAST, 0x80},
143 {TOK_WRITE, REG_COMP_PB_SATURATION, 0x80},
145 {TOK_SKIP, 0x13, 0x00},
146 {TOK_WRITE, REG_COMP_Y_BRIGHTNESS, 0x80},
148 {TOK_SKIP, 0x15, 0x00},
150 {TOK_SKIP, REG_AVID_START_PIXEL_LSB, 0x55},
151 {TOK_SKIP, REG_AVID_START_PIXEL_MSB, 0x00},
152 {TOK_SKIP, REG_AVID_STOP_PIXEL_LSB, 0x25},
153 {TOK_SKIP, REG_AVID_STOP_PIXEL_MSB, 0x03},
155 {TOK_SKIP, REG_HSYNC_START_PIXEL_LSB, 0x00},
156 {TOK_SKIP, REG_HSYNC_START_PIXEL_MSB, 0x00},
157 {TOK_SKIP, REG_HSYNC_STOP_PIXEL_LSB, 0x40},
158 {TOK_SKIP, REG_HSYNC_STOP_PIXEL_MSB, 0x00},
160 {TOK_SKIP, REG_VSYNC_START_LINE_LSB, 0x04},
161 {TOK_SKIP, REG_VSYNC_START_LINE_MSB, 0x00},
162 {TOK_SKIP, REG_VSYNC_STOP_LINE_LSB, 0x07},
163 {TOK_SKIP, REG_VSYNC_STOP_LINE_MSB, 0x00},
165 {TOK_SKIP, REG_VBLK_START_LINE_LSB, 0x01},
166 {TOK_SKIP, REG_VBLK_START_LINE_MSB, 0x00},
167 {TOK_SKIP, REG_VBLK_STOP_LINE_LSB, 0x15},
168 {TOK_SKIP, REG_VBLK_STOP_LINE_MSB, 0x00},
170 {TOK_SKIP, 0x26, 0x00},
172 {TOK_SKIP, 0x27, 0x00},
173 {TOK_SKIP, REG_FAST_SWTICH_CONTROL, 0xCC},
175 {TOK_SKIP, 0x29, 0x00},
176 {TOK_SKIP, REG_FAST_SWTICH_SCART_DELAY, 0x00},
178 {TOK_SKIP, 0x2B, 0x00},
179 {TOK_SKIP, REG_SCART_DELAY, 0x00},
180 {TOK_SKIP, REG_CTI_DELAY, 0x00},
181 {TOK_SKIP, REG_CTI_CONTROL, 0x00},
183 {TOK_SKIP, 0x2F, 0x00},
185 {TOK_SKIP, 0x30, 0x00},
187 {TOK_SKIP, 0x31, 0x00},
188 /* HS, VS active high */
189 {TOK_WRITE, REG_SYNC_CONTROL, 0x00},
191 {TOK_WRITE, REG_OUTPUT_FORMATTER1, 0x00},
192 /* Enable clk & data */
193 {TOK_WRITE, REG_OUTPUT_FORMATTER2, 0x11},
194 /* Enable AVID & FLD */
195 {TOK_WRITE, REG_OUTPUT_FORMATTER3, 0xEE},
197 {TOK_WRITE, REG_OUTPUT_FORMATTER4, 0xAF},
198 {TOK_WRITE, REG_OUTPUT_FORMATTER5, 0xFF},
199 {TOK_WRITE, REG_OUTPUT_FORMATTER6, 0xFF},
201 {TOK_WRITE, REG_CLEAR_LOST_LOCK, 0x01},
206 * List of image formats supported by TVP5146/47 decoder
207 * Currently we are using 8 bit mode only, but can be
208 * extended to 10/20 bit mode.
210 static const struct v4l2_fmtdesc tvp514x_fmt_list[] = {
213 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
215 .description = "8-bit UYVY 4:2:2 Format",
216 .pixelformat = V4L2_PIX_FMT_UYVY,
221 * Supported standards -
223 * Currently supports two standards only, need to add support for rest of the
224 * modes, like SECAM, etc...
226 static struct tvp514x_std_info tvp514x_std_list[] = {
227 /* Standard: STD_NTSC_MJ */
229 .width = NTSC_NUM_ACTIVE_PIXELS,
230 .height = NTSC_NUM_ACTIVE_LINES,
231 .video_std = VIDEO_STD_NTSC_MJ_BIT,
236 .frameperiod = {1001, 30000},
239 /* Standard: STD_PAL_BDGHIN */
242 .width = PAL_NUM_ACTIVE_PIXELS,
243 .height = PAL_NUM_ACTIVE_LINES,
244 .video_std = VIDEO_STD_PAL_BDGHIN_BIT,
249 .frameperiod = {1, 25},
253 /* Standard: need to add for additional standard */
257 static inline struct tvp514x_decoder *to_decoder(struct v4l2_subdev *sd)
259 return container_of(sd, struct tvp514x_decoder, sd);
264 * tvp514x_read_reg() - Read a value from a register in an TVP5146/47.
265 * @sd: ptr to v4l2_subdev struct
266 * @reg: TVP5146/47 register address
268 * Returns value read if successful, or non-zero (-1) otherwise.
270 static int tvp514x_read_reg(struct v4l2_subdev *sd, u8 reg)
273 struct i2c_client *client = v4l2_get_subdevdata(sd);
277 err = i2c_smbus_read_byte_data(client, reg);
279 if (retry <= I2C_RETRY_COUNT) {
280 v4l2_warn(sd, "Read: retry ... %d\n", retry);
282 msleep_interruptible(10);
291 * dump_reg() - dump the register content of TVP5146/47.
292 * @sd: ptr to v4l2_subdev struct
293 * @reg: TVP5146/47 register address
295 static void dump_reg(struct v4l2_subdev *sd, u8 reg)
299 val = tvp514x_read_reg(sd, reg);
300 v4l2_info(sd, "Reg(0x%.2X): 0x%.2X\n", reg, val);
304 * tvp514x_write_reg() - Write a value to a register in TVP5146/47
305 * @sd: ptr to v4l2_subdev struct
306 * @reg: TVP5146/47 register address
307 * @val: value to be written to the register
309 * Write a value to a register in an TVP5146/47 decoder device.
310 * Returns zero if successful, or non-zero otherwise.
312 static int tvp514x_write_reg(struct v4l2_subdev *sd, u8 reg, u8 val)
315 struct i2c_client *client = v4l2_get_subdevdata(sd);
319 err = i2c_smbus_write_byte_data(client, reg, val);
321 if (retry <= I2C_RETRY_COUNT) {
322 v4l2_warn(sd, "Write: retry ... %d\n", retry);
324 msleep_interruptible(10);
333 * tvp514x_write_regs() : Initializes a list of TVP5146/47 registers
334 * @sd: ptr to v4l2_subdev struct
335 * @reglist: list of TVP5146/47 registers and values
337 * Initializes a list of TVP5146/47 registers:-
338 * if token is TOK_TERM, then entire write operation terminates
339 * if token is TOK_DELAY, then a delay of 'val' msec is introduced
340 * if token is TOK_SKIP, then the register write is skipped
341 * if token is TOK_WRITE, then the register write is performed
342 * Returns zero if successful, or non-zero otherwise.
344 static int tvp514x_write_regs(struct v4l2_subdev *sd,
345 const struct tvp514x_reg reglist[])
348 const struct tvp514x_reg *next = reglist;
350 for (; next->token != TOK_TERM; next++) {
351 if (next->token == TOK_DELAY) {
356 if (next->token == TOK_SKIP)
359 err = tvp514x_write_reg(sd, next->reg, (u8) next->val);
361 v4l2_err(sd, "Write failed. Err[%d]\n", err);
369 * tvp514x_get_current_std() : Get the current standard detected by TVP5146/47
370 * @sd: ptr to v4l2_subdev struct
372 * Get current standard detected by TVP5146/47, STD_INVALID if there is no
375 static enum tvp514x_std tvp514x_get_current_std(struct v4l2_subdev *sd)
379 std = tvp514x_read_reg(sd, REG_VIDEO_STD);
380 if ((std & VIDEO_STD_MASK) == VIDEO_STD_AUTO_SWITCH_BIT)
381 /* use the standard status register */
382 std_status = tvp514x_read_reg(sd, REG_VIDEO_STD_STATUS);
384 /* use the standard register itself */
387 switch (std_status & VIDEO_STD_MASK) {
388 case VIDEO_STD_NTSC_MJ_BIT:
391 case VIDEO_STD_PAL_BDGHIN_BIT:
392 return STD_PAL_BDGHIN;
401 /* TVP5146/47 register dump function */
402 static void tvp514x_reg_dump(struct v4l2_subdev *sd)
404 dump_reg(sd, REG_INPUT_SEL);
405 dump_reg(sd, REG_AFE_GAIN_CTRL);
406 dump_reg(sd, REG_VIDEO_STD);
407 dump_reg(sd, REG_OPERATION_MODE);
408 dump_reg(sd, REG_COLOR_KILLER);
409 dump_reg(sd, REG_LUMA_CONTROL1);
410 dump_reg(sd, REG_LUMA_CONTROL2);
411 dump_reg(sd, REG_LUMA_CONTROL3);
412 dump_reg(sd, REG_BRIGHTNESS);
413 dump_reg(sd, REG_CONTRAST);
414 dump_reg(sd, REG_SATURATION);
415 dump_reg(sd, REG_HUE);
416 dump_reg(sd, REG_CHROMA_CONTROL1);
417 dump_reg(sd, REG_CHROMA_CONTROL2);
418 dump_reg(sd, REG_COMP_PR_SATURATION);
419 dump_reg(sd, REG_COMP_Y_CONTRAST);
420 dump_reg(sd, REG_COMP_PB_SATURATION);
421 dump_reg(sd, REG_COMP_Y_BRIGHTNESS);
422 dump_reg(sd, REG_AVID_START_PIXEL_LSB);
423 dump_reg(sd, REG_AVID_START_PIXEL_MSB);
424 dump_reg(sd, REG_AVID_STOP_PIXEL_LSB);
425 dump_reg(sd, REG_AVID_STOP_PIXEL_MSB);
426 dump_reg(sd, REG_HSYNC_START_PIXEL_LSB);
427 dump_reg(sd, REG_HSYNC_START_PIXEL_MSB);
428 dump_reg(sd, REG_HSYNC_STOP_PIXEL_LSB);
429 dump_reg(sd, REG_HSYNC_STOP_PIXEL_MSB);
430 dump_reg(sd, REG_VSYNC_START_LINE_LSB);
431 dump_reg(sd, REG_VSYNC_START_LINE_MSB);
432 dump_reg(sd, REG_VSYNC_STOP_LINE_LSB);
433 dump_reg(sd, REG_VSYNC_STOP_LINE_MSB);
434 dump_reg(sd, REG_VBLK_START_LINE_LSB);
435 dump_reg(sd, REG_VBLK_START_LINE_MSB);
436 dump_reg(sd, REG_VBLK_STOP_LINE_LSB);
437 dump_reg(sd, REG_VBLK_STOP_LINE_MSB);
438 dump_reg(sd, REG_SYNC_CONTROL);
439 dump_reg(sd, REG_OUTPUT_FORMATTER1);
440 dump_reg(sd, REG_OUTPUT_FORMATTER2);
441 dump_reg(sd, REG_OUTPUT_FORMATTER3);
442 dump_reg(sd, REG_OUTPUT_FORMATTER4);
443 dump_reg(sd, REG_OUTPUT_FORMATTER5);
444 dump_reg(sd, REG_OUTPUT_FORMATTER6);
445 dump_reg(sd, REG_CLEAR_LOST_LOCK);
449 * tvp514x_configure() - Configure the TVP5146/47 registers
450 * @sd: ptr to v4l2_subdev struct
451 * @decoder: ptr to tvp514x_decoder structure
453 * Returns zero if successful, or non-zero otherwise.
455 static int tvp514x_configure(struct v4l2_subdev *sd,
456 struct tvp514x_decoder *decoder)
460 /* common register initialization */
462 tvp514x_write_regs(sd, decoder->tvp514x_regs);
467 tvp514x_reg_dump(sd);
473 * tvp514x_detect() - Detect if an tvp514x is present, and if so which revision.
474 * @sd: pointer to standard V4L2 sub-device structure
475 * @decoder: pointer to tvp514x_decoder structure
477 * A device is considered to be detected if the chip ID (LSB and MSB)
478 * registers match the expected values.
479 * Any value of the rom version register is accepted.
480 * Returns ENODEV error number if no device is detected, or zero
481 * if a device is detected.
483 static int tvp514x_detect(struct v4l2_subdev *sd,
484 struct tvp514x_decoder *decoder)
486 u8 chip_id_msb, chip_id_lsb, rom_ver;
487 struct i2c_client *client = v4l2_get_subdevdata(sd);
489 chip_id_msb = tvp514x_read_reg(sd, REG_CHIP_ID_MSB);
490 chip_id_lsb = tvp514x_read_reg(sd, REG_CHIP_ID_LSB);
491 rom_ver = tvp514x_read_reg(sd, REG_ROM_VERSION);
493 v4l2_dbg(1, debug, sd,
494 "chip id detected msb:0x%x lsb:0x%x rom version:0x%x\n",
495 chip_id_msb, chip_id_lsb, rom_ver);
496 if ((chip_id_msb != TVP514X_CHIP_ID_MSB)
497 || ((chip_id_lsb != TVP5146_CHIP_ID_LSB)
498 && (chip_id_lsb != TVP5147_CHIP_ID_LSB))) {
499 /* We didn't read the values we expected, so this must not be
502 v4l2_err(sd, "chip id mismatch msb:0x%x lsb:0x%x\n",
503 chip_id_msb, chip_id_lsb);
507 decoder->ver = rom_ver;
509 v4l2_info(sd, "%s (Version - 0x%.2x) found at 0x%x (%s)\n",
510 client->name, decoder->ver,
511 client->addr << 1, client->adapter->name);
516 * tvp514x_querystd() - V4L2 decoder interface handler for querystd
517 * @sd: pointer to standard V4L2 sub-device structure
518 * @std_id: standard V4L2 std_id ioctl enum
520 * Returns the current standard detected by TVP5146/47. If no active input is
521 * detected, returns -EINVAL
523 static int tvp514x_querystd(struct v4l2_subdev *sd, v4l2_std_id *std_id)
525 struct tvp514x_decoder *decoder = to_decoder(sd);
526 enum tvp514x_std current_std;
527 enum tvp514x_input input_sel;
528 u8 sync_lock_status, lock_mask;
533 /* get the current standard */
534 current_std = tvp514x_get_current_std(sd);
535 if (current_std == STD_INVALID)
538 input_sel = decoder->input;
541 case INPUT_CVBS_VI1A:
542 case INPUT_CVBS_VI1B:
543 case INPUT_CVBS_VI1C:
544 case INPUT_CVBS_VI2A:
545 case INPUT_CVBS_VI2B:
546 case INPUT_CVBS_VI2C:
547 case INPUT_CVBS_VI3A:
548 case INPUT_CVBS_VI3B:
549 case INPUT_CVBS_VI3C:
550 case INPUT_CVBS_VI4A:
551 lock_mask = STATUS_CLR_SUBCAR_LOCK_BIT |
552 STATUS_HORZ_SYNC_LOCK_BIT |
553 STATUS_VIRT_SYNC_LOCK_BIT;
556 case INPUT_SVIDEO_VI2A_VI1A:
557 case INPUT_SVIDEO_VI2B_VI1B:
558 case INPUT_SVIDEO_VI2C_VI1C:
559 case INPUT_SVIDEO_VI2A_VI3A:
560 case INPUT_SVIDEO_VI2B_VI3B:
561 case INPUT_SVIDEO_VI2C_VI3C:
562 case INPUT_SVIDEO_VI4A_VI1A:
563 case INPUT_SVIDEO_VI4A_VI1B:
564 case INPUT_SVIDEO_VI4A_VI1C:
565 case INPUT_SVIDEO_VI4A_VI3A:
566 case INPUT_SVIDEO_VI4A_VI3B:
567 case INPUT_SVIDEO_VI4A_VI3C:
568 lock_mask = STATUS_HORZ_SYNC_LOCK_BIT |
569 STATUS_VIRT_SYNC_LOCK_BIT;
571 /*Need to add other interfaces*/
575 /* check whether signal is locked */
576 sync_lock_status = tvp514x_read_reg(sd, REG_STATUS1);
577 if (lock_mask != (sync_lock_status & lock_mask))
578 return -EINVAL; /* No input detected */
580 decoder->current_std = current_std;
581 *std_id = decoder->std_list[current_std].standard.id;
583 v4l2_dbg(1, debug, sd, "Current STD: %s",
584 decoder->std_list[current_std].standard.name);
589 * tvp514x_s_std() - V4L2 decoder interface handler for s_std
590 * @sd: pointer to standard V4L2 sub-device structure
591 * @std_id: standard V4L2 v4l2_std_id ioctl enum
593 * If std_id is supported, sets the requested standard. Otherwise, returns
596 static int tvp514x_s_std(struct v4l2_subdev *sd, v4l2_std_id std_id)
598 struct tvp514x_decoder *decoder = to_decoder(sd);
601 for (i = 0; i < decoder->num_stds; i++)
602 if (std_id & decoder->std_list[i].standard.id)
605 if ((i == decoder->num_stds) || (i == STD_INVALID))
608 err = tvp514x_write_reg(sd, REG_VIDEO_STD,
609 decoder->std_list[i].video_std);
613 decoder->current_std = i;
614 decoder->tvp514x_regs[REG_VIDEO_STD].val =
615 decoder->std_list[i].video_std;
617 v4l2_dbg(1, debug, sd, "Standard set to: %s",
618 decoder->std_list[i].standard.name);
623 * tvp514x_s_routing() - V4L2 decoder interface handler for s_routing
624 * @sd: pointer to standard V4L2 sub-device structure
625 * @input: input selector for routing the signal
626 * @output: output selector for routing the signal
627 * @config: config value. Not used
629 * If index is valid, selects the requested input. Otherwise, returns -EINVAL if
630 * the input is not supported or there is no active signal present in the
633 static int tvp514x_s_routing(struct v4l2_subdev *sd,
634 u32 input, u32 output, u32 config)
636 struct tvp514x_decoder *decoder = to_decoder(sd);
638 enum tvp514x_input input_sel;
639 enum tvp514x_output output_sel;
640 enum tvp514x_std current_std = STD_INVALID;
641 u8 sync_lock_status, lock_mask;
642 int try_count = LOCK_RETRY_COUNT;
644 if ((input >= INPUT_INVALID) ||
645 (output >= OUTPUT_INVALID))
646 /* Index out of bound */
650 * For the sequence streamon -> streamoff and again s_input
651 * it fails to lock the signal, since streamoff puts TVP514x
652 * into power off state which leads to failure in sub-sequent s_input.
654 * So power up the TVP514x device here, since it is important to lock
655 * the signal at this stage.
657 if (!decoder->streaming)
658 tvp514x_s_stream(sd, 1);
663 err = tvp514x_write_reg(sd, REG_INPUT_SEL, input_sel);
667 output_sel |= tvp514x_read_reg(sd,
668 REG_OUTPUT_FORMATTER1) & 0x7;
669 err = tvp514x_write_reg(sd, REG_OUTPUT_FORMATTER1,
674 decoder->tvp514x_regs[REG_INPUT_SEL].val = input_sel;
675 decoder->tvp514x_regs[REG_OUTPUT_FORMATTER1].val = output_sel;
678 msleep(LOCK_RETRY_DELAY);
680 tvp514x_write_reg(sd, REG_CLEAR_LOST_LOCK, 0x01);
685 case INPUT_CVBS_VI1A:
686 case INPUT_CVBS_VI1B:
687 case INPUT_CVBS_VI1C:
688 case INPUT_CVBS_VI2A:
689 case INPUT_CVBS_VI2B:
690 case INPUT_CVBS_VI2C:
691 case INPUT_CVBS_VI3A:
692 case INPUT_CVBS_VI3B:
693 case INPUT_CVBS_VI3C:
694 case INPUT_CVBS_VI4A:
695 lock_mask = STATUS_CLR_SUBCAR_LOCK_BIT |
696 STATUS_HORZ_SYNC_LOCK_BIT |
697 STATUS_VIRT_SYNC_LOCK_BIT;
700 case INPUT_SVIDEO_VI2A_VI1A:
701 case INPUT_SVIDEO_VI2B_VI1B:
702 case INPUT_SVIDEO_VI2C_VI1C:
703 case INPUT_SVIDEO_VI2A_VI3A:
704 case INPUT_SVIDEO_VI2B_VI3B:
705 case INPUT_SVIDEO_VI2C_VI3C:
706 case INPUT_SVIDEO_VI4A_VI1A:
707 case INPUT_SVIDEO_VI4A_VI1B:
708 case INPUT_SVIDEO_VI4A_VI1C:
709 case INPUT_SVIDEO_VI4A_VI3A:
710 case INPUT_SVIDEO_VI4A_VI3B:
711 case INPUT_SVIDEO_VI4A_VI3C:
712 lock_mask = STATUS_HORZ_SYNC_LOCK_BIT |
713 STATUS_VIRT_SYNC_LOCK_BIT;
715 /* Need to add other interfaces*/
720 while (try_count-- > 0) {
721 /* Allow decoder to sync up with new input */
722 msleep(LOCK_RETRY_DELAY);
724 /* get the current standard for future reference */
725 current_std = tvp514x_get_current_std(sd);
726 if (current_std == STD_INVALID)
729 sync_lock_status = tvp514x_read_reg(sd,
731 if (lock_mask == (sync_lock_status & lock_mask))
736 if ((current_std == STD_INVALID) || (try_count < 0))
739 decoder->current_std = current_std;
740 decoder->input = input;
741 decoder->output = output;
743 v4l2_dbg(1, debug, sd, "Input set to: %d, std : %d",
744 input_sel, current_std);
750 * tvp514x_queryctrl() - V4L2 decoder interface handler for queryctrl
751 * @sd: pointer to standard V4L2 sub-device structure
752 * @qctrl: standard V4L2 v4l2_queryctrl structure
754 * If the requested control is supported, returns the control information.
755 * Otherwise, returns -EINVAL if the control is not supported.
758 tvp514x_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qctrl)
766 case V4L2_CID_BRIGHTNESS:
767 /* Brightness supported is (0-255), */
768 err = v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
770 case V4L2_CID_CONTRAST:
771 case V4L2_CID_SATURATION:
773 * Saturation and Contrast supported is -
774 * Contrast: 0 - 255 (Default - 128)
775 * Saturation: 0 - 255 (Default - 128)
777 err = v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
780 /* Hue Supported is -
781 * Hue - -180 - +180 (Default - 0, Step - +180)
783 err = v4l2_ctrl_query_fill(qctrl, -180, 180, 180, 0);
785 case V4L2_CID_AUTOGAIN:
787 * Auto Gain supported is -
788 * 0 - 1 (Default - 1)
790 err = v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
793 v4l2_err(sd, "invalid control id %d\n", qctrl->id);
797 v4l2_dbg(1, debug, sd, "Query Control:%s: Min - %d, Max - %d, Def - %d",
798 qctrl->name, qctrl->minimum, qctrl->maximum,
799 qctrl->default_value);
805 * tvp514x_g_ctrl() - V4L2 decoder interface handler for g_ctrl
806 * @sd: pointer to standard V4L2 sub-device structure
807 * @ctrl: pointer to v4l2_control structure
809 * If the requested control is supported, returns the control's current
810 * value from the decoder. Otherwise, returns -EINVAL if the control is not
814 tvp514x_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
816 struct tvp514x_decoder *decoder = to_decoder(sd);
822 case V4L2_CID_BRIGHTNESS:
823 ctrl->value = decoder->tvp514x_regs[REG_BRIGHTNESS].val;
825 case V4L2_CID_CONTRAST:
826 ctrl->value = decoder->tvp514x_regs[REG_CONTRAST].val;
828 case V4L2_CID_SATURATION:
829 ctrl->value = decoder->tvp514x_regs[REG_SATURATION].val;
832 ctrl->value = decoder->tvp514x_regs[REG_HUE].val;
833 if (ctrl->value == 0x7F)
835 else if (ctrl->value == 0x80)
841 case V4L2_CID_AUTOGAIN:
842 ctrl->value = decoder->tvp514x_regs[REG_AFE_GAIN_CTRL].val;
843 if ((ctrl->value & 0x3) == 3)
850 v4l2_err(sd, "invalid control id %d\n", ctrl->id);
854 v4l2_dbg(1, debug, sd, "Get Control: ID - %d - %d",
855 ctrl->id, ctrl->value);
860 * tvp514x_s_ctrl() - V4L2 decoder interface handler for s_ctrl
861 * @sd: pointer to standard V4L2 sub-device structure
862 * @ctrl: pointer to v4l2_control structure
864 * If the requested control is supported, sets the control's current
865 * value in HW. Otherwise, returns -EINVAL if the control is not supported.
868 tvp514x_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
870 struct tvp514x_decoder *decoder = to_decoder(sd);
871 int err = -EINVAL, value;
879 case V4L2_CID_BRIGHTNESS:
880 if (ctrl->value < 0 || ctrl->value > 255) {
881 v4l2_err(sd, "invalid brightness setting %d\n",
885 err = tvp514x_write_reg(sd, REG_BRIGHTNESS,
890 decoder->tvp514x_regs[REG_BRIGHTNESS].val = value;
892 case V4L2_CID_CONTRAST:
893 if (ctrl->value < 0 || ctrl->value > 255) {
894 v4l2_err(sd, "invalid contrast setting %d\n",
898 err = tvp514x_write_reg(sd, REG_CONTRAST, value);
902 decoder->tvp514x_regs[REG_CONTRAST].val = value;
904 case V4L2_CID_SATURATION:
905 if (ctrl->value < 0 || ctrl->value > 255) {
906 v4l2_err(sd, "invalid saturation setting %d\n",
910 err = tvp514x_write_reg(sd, REG_SATURATION, value);
914 decoder->tvp514x_regs[REG_SATURATION].val = value;
919 else if (value == -180)
924 v4l2_err(sd, "invalid hue setting %d\n", ctrl->value);
927 err = tvp514x_write_reg(sd, REG_HUE, value);
931 decoder->tvp514x_regs[REG_HUE].val = value;
933 case V4L2_CID_AUTOGAIN:
939 v4l2_err(sd, "invalid auto gain setting %d\n",
943 err = tvp514x_write_reg(sd, REG_AFE_GAIN_CTRL, value);
947 decoder->tvp514x_regs[REG_AFE_GAIN_CTRL].val = value;
950 v4l2_err(sd, "invalid control id %d\n", ctrl->id);
954 v4l2_dbg(1, debug, sd, "Set Control: ID - %d - %d",
955 ctrl->id, ctrl->value);
961 * tvp514x_enum_fmt_cap() - V4L2 decoder interface handler for enum_fmt
962 * @sd: pointer to standard V4L2 sub-device structure
963 * @fmt: standard V4L2 VIDIOC_ENUM_FMT ioctl structure
965 * Implement the VIDIOC_ENUM_FMT ioctl to enumerate supported formats
968 tvp514x_enum_fmt_cap(struct v4l2_subdev *sd, struct v4l2_fmtdesc *fmt)
970 struct tvp514x_decoder *decoder = to_decoder(sd);
977 if ((index >= decoder->num_fmts) || (index < 0))
978 /* Index out of bound */
981 if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
982 /* only capture is supported */
985 memcpy(fmt, &decoder->fmt_list[index],
986 sizeof(struct v4l2_fmtdesc));
988 v4l2_dbg(1, debug, sd, "Current FMT: index - %d (%s)",
989 decoder->fmt_list[index].index,
990 decoder->fmt_list[index].description);
995 * tvp514x_try_fmt_cap() - V4L2 decoder interface handler for try_fmt
996 * @sd: pointer to standard V4L2 sub-device structure
997 * @f: pointer to standard V4L2 VIDIOC_TRY_FMT ioctl structure
999 * Implement the VIDIOC_TRY_FMT ioctl for the CAPTURE buffer type. This
1000 * ioctl is used to negotiate the image capture size and pixel format
1001 * without actually making it take effect.
1004 tvp514x_try_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
1006 struct tvp514x_decoder *decoder = to_decoder(sd);
1008 struct v4l2_pix_format *pix;
1009 enum tvp514x_std current_std;
1014 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1015 /* only capture is supported */
1016 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1020 /* Calculate height and width based on current standard */
1021 current_std = tvp514x_get_current_std(sd);
1022 if (current_std == STD_INVALID)
1025 decoder->current_std = current_std;
1026 pix->width = decoder->std_list[current_std].width;
1027 pix->height = decoder->std_list[current_std].height;
1029 for (ifmt = 0; ifmt < decoder->num_fmts; ifmt++) {
1030 if (pix->pixelformat ==
1031 decoder->fmt_list[ifmt].pixelformat)
1034 if (ifmt == decoder->num_fmts)
1035 /* None of the format matched, select default */
1037 pix->pixelformat = decoder->fmt_list[ifmt].pixelformat;
1039 pix->field = V4L2_FIELD_INTERLACED;
1040 pix->bytesperline = pix->width * 2;
1041 pix->sizeimage = pix->bytesperline * pix->height;
1042 pix->colorspace = V4L2_COLORSPACE_SMPTE170M;
1045 v4l2_dbg(1, debug, sd, "Try FMT: pixelformat - %s, bytesperline - %d"
1046 "Width - %d, Height - %d",
1047 decoder->fmt_list[ifmt].description, pix->bytesperline,
1048 pix->width, pix->height);
1053 * tvp514x_s_fmt_cap() - V4L2 decoder interface handler for s_fmt
1054 * @sd: pointer to standard V4L2 sub-device structure
1055 * @f: pointer to standard V4L2 VIDIOC_S_FMT ioctl structure
1057 * If the requested format is supported, configures the HW to use that
1058 * format, returns error code if format not supported or HW can't be
1059 * correctly configured.
1062 tvp514x_s_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
1064 struct tvp514x_decoder *decoder = to_decoder(sd);
1065 struct v4l2_pix_format *pix;
1071 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1072 /* only capture is supported */
1076 rval = tvp514x_try_fmt_cap(sd, f);
1080 decoder->pix = *pix;
1086 * tvp514x_g_fmt_cap() - V4L2 decoder interface handler for tvp514x_g_fmt_cap
1087 * @sd: pointer to standard V4L2 sub-device structure
1088 * @f: pointer to standard V4L2 v4l2_format structure
1090 * Returns the decoder's current pixel format in the v4l2_format
1094 tvp514x_g_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
1096 struct tvp514x_decoder *decoder = to_decoder(sd);
1101 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1102 /* only capture is supported */
1105 f->fmt.pix = decoder->pix;
1107 v4l2_dbg(1, debug, sd, "Current FMT: bytesperline - %d"
1108 "Width - %d, Height - %d",
1109 decoder->pix.bytesperline,
1110 decoder->pix.width, decoder->pix.height);
1115 * tvp514x_g_parm() - V4L2 decoder interface handler for g_parm
1116 * @sd: pointer to standard V4L2 sub-device structure
1117 * @a: pointer to standard V4L2 VIDIOC_G_PARM ioctl structure
1119 * Returns the decoder's video CAPTURE parameters.
1122 tvp514x_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
1124 struct tvp514x_decoder *decoder = to_decoder(sd);
1125 struct v4l2_captureparm *cparm;
1126 enum tvp514x_std current_std;
1131 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1132 /* only capture is supported */
1135 memset(a, 0, sizeof(*a));
1136 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1138 /* get the current standard */
1139 current_std = tvp514x_get_current_std(sd);
1140 if (current_std == STD_INVALID)
1143 decoder->current_std = current_std;
1145 cparm = &a->parm.capture;
1146 cparm->capability = V4L2_CAP_TIMEPERFRAME;
1147 cparm->timeperframe =
1148 decoder->std_list[current_std].standard.frameperiod;
1154 * tvp514x_s_parm() - V4L2 decoder interface handler for s_parm
1155 * @sd: pointer to standard V4L2 sub-device structure
1156 * @a: pointer to standard V4L2 VIDIOC_S_PARM ioctl structure
1158 * Configures the decoder to use the input parameters, if possible. If
1159 * not possible, returns the appropriate error code.
1162 tvp514x_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
1164 struct tvp514x_decoder *decoder = to_decoder(sd);
1165 struct v4l2_fract *timeperframe;
1166 enum tvp514x_std current_std;
1171 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1172 /* only capture is supported */
1175 timeperframe = &a->parm.capture.timeperframe;
1177 /* get the current standard */
1178 current_std = tvp514x_get_current_std(sd);
1179 if (current_std == STD_INVALID)
1182 decoder->current_std = current_std;
1185 decoder->std_list[current_std].standard.frameperiod;
1191 * tvp514x_s_stream() - V4L2 decoder i/f handler for s_stream
1192 * @sd: pointer to standard V4L2 sub-device structure
1193 * @enable: streaming enable or disable
1195 * Sets streaming to enable or disable, if possible.
1197 static int tvp514x_s_stream(struct v4l2_subdev *sd, int enable)
1200 struct i2c_client *client = v4l2_get_subdevdata(sd);
1201 struct tvp514x_decoder *decoder = to_decoder(sd);
1203 if (decoder->streaming == enable)
1209 /* Power Down Sequence */
1210 err = tvp514x_write_reg(sd, REG_OPERATION_MODE, 0x01);
1212 v4l2_err(sd, "Unable to turn off decoder\n");
1215 decoder->streaming = enable;
1220 struct tvp514x_reg *int_seq = (struct tvp514x_reg *)
1221 client->driver->id_table->driver_data;
1223 /* Power Up Sequence */
1224 err = tvp514x_write_regs(sd, int_seq);
1226 v4l2_err(sd, "Unable to turn on decoder\n");
1229 /* Detect if not already detected */
1230 err = tvp514x_detect(sd, decoder);
1232 v4l2_err(sd, "Unable to detect decoder\n");
1235 err = tvp514x_configure(sd, decoder);
1237 v4l2_err(sd, "Unable to configure decoder\n");
1240 decoder->streaming = enable;
1251 static const struct v4l2_subdev_core_ops tvp514x_core_ops = {
1252 .queryctrl = tvp514x_queryctrl,
1253 .g_ctrl = tvp514x_g_ctrl,
1254 .s_ctrl = tvp514x_s_ctrl,
1255 .s_std = tvp514x_s_std,
1258 static const struct v4l2_subdev_video_ops tvp514x_video_ops = {
1259 .s_routing = tvp514x_s_routing,
1260 .querystd = tvp514x_querystd,
1261 .enum_fmt = tvp514x_enum_fmt_cap,
1262 .g_fmt = tvp514x_g_fmt_cap,
1263 .try_fmt = tvp514x_try_fmt_cap,
1264 .s_fmt = tvp514x_s_fmt_cap,
1265 .g_parm = tvp514x_g_parm,
1266 .s_parm = tvp514x_s_parm,
1267 .s_stream = tvp514x_s_stream,
1270 static const struct v4l2_subdev_ops tvp514x_ops = {
1271 .core = &tvp514x_core_ops,
1272 .video = &tvp514x_video_ops,
1275 static struct tvp514x_decoder tvp514x_dev = {
1278 .fmt_list = tvp514x_fmt_list,
1279 .num_fmts = ARRAY_SIZE(tvp514x_fmt_list),
1282 /* Default to NTSC 8-bit YUV 422 */
1283 .width = NTSC_NUM_ACTIVE_PIXELS,
1284 .height = NTSC_NUM_ACTIVE_LINES,
1285 .pixelformat = V4L2_PIX_FMT_UYVY,
1286 .field = V4L2_FIELD_INTERLACED,
1287 .bytesperline = NTSC_NUM_ACTIVE_PIXELS * 2,
1289 NTSC_NUM_ACTIVE_PIXELS * 2 * NTSC_NUM_ACTIVE_LINES,
1290 .colorspace = V4L2_COLORSPACE_SMPTE170M,
1293 .current_std = STD_NTSC_MJ,
1294 .std_list = tvp514x_std_list,
1295 .num_stds = ARRAY_SIZE(tvp514x_std_list),
1300 * tvp514x_probe() - decoder driver i2c probe handler
1301 * @client: i2c driver client device structure
1302 * @id: i2c driver id table
1304 * Register decoder as an i2c client device and V4L2
1308 tvp514x_probe(struct i2c_client *client, const struct i2c_device_id *id)
1310 struct tvp514x_decoder *decoder;
1311 struct v4l2_subdev *sd;
1313 /* Check if the adapter supports the needed features */
1314 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1317 if (!client->dev.platform_data) {
1318 v4l2_err(client, "No platform data!!\n");
1322 decoder = kzalloc(sizeof(*decoder), GFP_KERNEL);
1326 /* Initialize the tvp514x_decoder with default configuration */
1327 *decoder = tvp514x_dev;
1328 /* Copy default register configuration */
1329 memcpy(decoder->tvp514x_regs, tvp514x_reg_list_default,
1330 sizeof(tvp514x_reg_list_default));
1332 /* Copy board specific information here */
1333 decoder->pdata = client->dev.platform_data;
1336 * Fetch platform specific data, and configure the
1337 * tvp514x_reg_list[] accordingly. Since this is one
1338 * time configuration, no need to preserve.
1340 decoder->tvp514x_regs[REG_OUTPUT_FORMATTER2].val |=
1341 (decoder->pdata->clk_polarity << 1);
1342 decoder->tvp514x_regs[REG_SYNC_CONTROL].val |=
1343 ((decoder->pdata->hs_polarity << 2) |
1344 (decoder->pdata->vs_polarity << 3));
1345 /* Set default standard to auto */
1346 decoder->tvp514x_regs[REG_VIDEO_STD].val =
1347 VIDEO_STD_AUTO_SWITCH_BIT;
1349 /* Register with V4L2 layer as slave device */
1351 v4l2_i2c_subdev_init(sd, client, &tvp514x_ops);
1353 v4l2_info(sd, "%s decoder driver registered !!\n", sd->name);
1360 * tvp514x_remove() - decoder driver i2c remove handler
1361 * @client: i2c driver client device structure
1363 * Unregister decoder as an i2c client device and V4L2
1364 * device. Complement of tvp514x_probe().
1366 static int tvp514x_remove(struct i2c_client *client)
1368 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1369 struct tvp514x_decoder *decoder = to_decoder(sd);
1371 v4l2_device_unregister_subdev(sd);
1375 /* TVP5146 Init/Power on Sequence */
1376 static const struct tvp514x_reg tvp5146_init_reg_seq[] = {
1377 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x02},
1378 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1379 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0x80},
1380 {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1381 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1382 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1383 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1384 {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1385 {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
1386 {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1387 {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1391 /* TVP5147 Init/Power on Sequence */
1392 static const struct tvp514x_reg tvp5147_init_reg_seq[] = {
1393 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x02},
1394 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1395 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0x80},
1396 {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1397 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1398 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1399 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1400 {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1401 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x16},
1402 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1403 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xA0},
1404 {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x16},
1405 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1406 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1407 {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1408 {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
1409 {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1410 {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1414 /* TVP5146M2/TVP5147M1 Init/Power on Sequence */
1415 static const struct tvp514x_reg tvp514xm_init_reg_seq[] = {
1416 {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1417 {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1422 * I2C Device Table -
1424 * name - Name of the actual device/chip.
1425 * driver_data - Driver data
1427 static const struct i2c_device_id tvp514x_id[] = {
1428 {"tvp5146", (unsigned long)tvp5146_init_reg_seq},
1429 {"tvp5146m2", (unsigned long)tvp514xm_init_reg_seq},
1430 {"tvp5147", (unsigned long)tvp5147_init_reg_seq},
1431 {"tvp5147m1", (unsigned long)tvp514xm_init_reg_seq},
1435 MODULE_DEVICE_TABLE(i2c, tvp514x_id);
1437 static struct i2c_driver tvp514x_driver = {
1439 .owner = THIS_MODULE,
1440 .name = TVP514X_MODULE_NAME,
1442 .probe = tvp514x_probe,
1443 .remove = tvp514x_remove,
1444 .id_table = tvp514x_id,
1447 static int __init tvp514x_init(void)
1449 return i2c_add_driver(&tvp514x_driver);
1452 static void __exit tvp514x_exit(void)
1454 i2c_del_driver(&tvp514x_driver);
1457 module_init(tvp514x_init);
1458 module_exit(tvp514x_exit);