Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / drivers / media / video / tvp514x.c
1 /*
2  * drivers/media/video/tvp514x.c
3  *
4  * TI TVP5146/47 decoder driver
5  *
6  * Copyright (C) 2008 Texas Instruments Inc
7  * Author: Vaibhav Hiremath <hvaibhav@ti.com>
8  *
9  * Contributors:
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>
15  *
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.
19  *
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.
24  *
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.
28  *
29  */
30
31 #include <linux/i2c.h>
32 #include <linux/delay.h>
33 #include <linux/videodev2.h>
34
35 #include <media/v4l2-device.h>
36 #include <media/v4l2-common.h>
37 #include <media/v4l2-chip-ident.h>
38 #include <media/tvp514x.h>
39
40 #include "tvp514x_regs.h"
41
42 /* Module Name */
43 #define TVP514X_MODULE_NAME             "tvp514x"
44
45 /* Private macros for TVP */
46 #define I2C_RETRY_COUNT                 (5)
47 #define LOCK_RETRY_COUNT                (5)
48 #define LOCK_RETRY_DELAY                (200)
49
50 /* Debug functions */
51 static int debug;
52 module_param(debug, bool, 0644);
53 MODULE_PARM_DESC(debug, "Debug level (0-1)");
54
55 MODULE_AUTHOR("Texas Instruments");
56 MODULE_DESCRIPTION("TVP514X linux decoder driver");
57 MODULE_LICENSE("GPL");
58
59 /* enum tvp514x_std - enum for supported standards */
60 enum tvp514x_std {
61         STD_NTSC_MJ = 0,
62         STD_PAL_BDGHIN,
63         STD_INVALID
64 };
65
66 /**
67  * struct tvp514x_std_info - Structure to store standard informations
68  * @width: Line width in pixels
69  * @height:Number of active lines
70  * @video_std: Value to write in REG_VIDEO_STD register
71  * @standard: v4l2 standard structure information
72  */
73 struct tvp514x_std_info {
74         unsigned long width;
75         unsigned long height;
76         u8 video_std;
77         struct v4l2_standard standard;
78 };
79
80 static struct tvp514x_reg tvp514x_reg_list_default[0x40];
81 /**
82  * struct tvp514x_decoder - TVP5146/47 decoder object
83  * @sd: Subdevice Slave handle
84  * @tvp514x_regs: copy of hw's regs with preset values.
85  * @pdata: Board specific
86  * @ver: Chip version
87  * @streaming: TVP5146/47 decoder streaming - enabled or disabled.
88  * @pix: Current pixel format
89  * @num_fmts: Number of formats
90  * @fmt_list: Format list
91  * @current_std: Current standard
92  * @num_stds: Number of standards
93  * @std_list: Standards list
94  * @input: Input routing at chip level
95  * @output: Output routing at chip level
96  */
97 struct tvp514x_decoder {
98         struct v4l2_subdev sd;
99         struct tvp514x_reg tvp514x_regs[ARRAY_SIZE(tvp514x_reg_list_default)];
100         const struct tvp514x_platform_data *pdata;
101
102         int ver;
103         int streaming;
104
105         struct v4l2_pix_format pix;
106         int num_fmts;
107         const struct v4l2_fmtdesc *fmt_list;
108
109         enum tvp514x_std current_std;
110         int num_stds;
111         struct tvp514x_std_info *std_list;
112         /* Input and Output Routing parameters */
113         u32 input;
114         u32 output;
115 };
116
117 /* TVP514x default register values */
118 static struct tvp514x_reg tvp514x_reg_list_default[] = {
119         /* Composite selected */
120         {TOK_WRITE, REG_INPUT_SEL, 0x05},
121         {TOK_WRITE, REG_AFE_GAIN_CTRL, 0x0F},
122         /* Auto mode */
123         {TOK_WRITE, REG_VIDEO_STD, 0x00},
124         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
125         {TOK_SKIP, REG_AUTOSWITCH_MASK, 0x3F},
126         {TOK_WRITE, REG_COLOR_KILLER, 0x10},
127         {TOK_WRITE, REG_LUMA_CONTROL1, 0x00},
128         {TOK_WRITE, REG_LUMA_CONTROL2, 0x00},
129         {TOK_WRITE, REG_LUMA_CONTROL3, 0x02},
130         {TOK_WRITE, REG_BRIGHTNESS, 0x80},
131         {TOK_WRITE, REG_CONTRAST, 0x80},
132         {TOK_WRITE, REG_SATURATION, 0x80},
133         {TOK_WRITE, REG_HUE, 0x00},
134         {TOK_WRITE, REG_CHROMA_CONTROL1, 0x00},
135         {TOK_WRITE, REG_CHROMA_CONTROL2, 0x0E},
136         /* Reserved */
137         {TOK_SKIP, 0x0F, 0x00},
138         {TOK_WRITE, REG_COMP_PR_SATURATION, 0x80},
139         {TOK_WRITE, REG_COMP_Y_CONTRAST, 0x80},
140         {TOK_WRITE, REG_COMP_PB_SATURATION, 0x80},
141         /* Reserved */
142         {TOK_SKIP, 0x13, 0x00},
143         {TOK_WRITE, REG_COMP_Y_BRIGHTNESS, 0x80},
144         /* Reserved */
145         {TOK_SKIP, 0x15, 0x00},
146         /* NTSC timing */
147         {TOK_SKIP, REG_AVID_START_PIXEL_LSB, 0x55},
148         {TOK_SKIP, REG_AVID_START_PIXEL_MSB, 0x00},
149         {TOK_SKIP, REG_AVID_STOP_PIXEL_LSB, 0x25},
150         {TOK_SKIP, REG_AVID_STOP_PIXEL_MSB, 0x03},
151         /* NTSC timing */
152         {TOK_SKIP, REG_HSYNC_START_PIXEL_LSB, 0x00},
153         {TOK_SKIP, REG_HSYNC_START_PIXEL_MSB, 0x00},
154         {TOK_SKIP, REG_HSYNC_STOP_PIXEL_LSB, 0x40},
155         {TOK_SKIP, REG_HSYNC_STOP_PIXEL_MSB, 0x00},
156         /* NTSC timing */
157         {TOK_SKIP, REG_VSYNC_START_LINE_LSB, 0x04},
158         {TOK_SKIP, REG_VSYNC_START_LINE_MSB, 0x00},
159         {TOK_SKIP, REG_VSYNC_STOP_LINE_LSB, 0x07},
160         {TOK_SKIP, REG_VSYNC_STOP_LINE_MSB, 0x00},
161         /* NTSC timing */
162         {TOK_SKIP, REG_VBLK_START_LINE_LSB, 0x01},
163         {TOK_SKIP, REG_VBLK_START_LINE_MSB, 0x00},
164         {TOK_SKIP, REG_VBLK_STOP_LINE_LSB, 0x15},
165         {TOK_SKIP, REG_VBLK_STOP_LINE_MSB, 0x00},
166         /* Reserved */
167         {TOK_SKIP, 0x26, 0x00},
168         /* Reserved */
169         {TOK_SKIP, 0x27, 0x00},
170         {TOK_SKIP, REG_FAST_SWTICH_CONTROL, 0xCC},
171         /* Reserved */
172         {TOK_SKIP, 0x29, 0x00},
173         {TOK_SKIP, REG_FAST_SWTICH_SCART_DELAY, 0x00},
174         /* Reserved */
175         {TOK_SKIP, 0x2B, 0x00},
176         {TOK_SKIP, REG_SCART_DELAY, 0x00},
177         {TOK_SKIP, REG_CTI_DELAY, 0x00},
178         {TOK_SKIP, REG_CTI_CONTROL, 0x00},
179         /* Reserved */
180         {TOK_SKIP, 0x2F, 0x00},
181         /* Reserved */
182         {TOK_SKIP, 0x30, 0x00},
183         /* Reserved */
184         {TOK_SKIP, 0x31, 0x00},
185         /* HS, VS active high */
186         {TOK_WRITE, REG_SYNC_CONTROL, 0x00},
187         /* 10-bit BT.656 */
188         {TOK_WRITE, REG_OUTPUT_FORMATTER1, 0x00},
189         /* Enable clk & data */
190         {TOK_WRITE, REG_OUTPUT_FORMATTER2, 0x11},
191         /* Enable AVID & FLD */
192         {TOK_WRITE, REG_OUTPUT_FORMATTER3, 0xEE},
193         /* Enable VS & HS */
194         {TOK_WRITE, REG_OUTPUT_FORMATTER4, 0xAF},
195         {TOK_WRITE, REG_OUTPUT_FORMATTER5, 0xFF},
196         {TOK_WRITE, REG_OUTPUT_FORMATTER6, 0xFF},
197         /* Clear status */
198         {TOK_WRITE, REG_CLEAR_LOST_LOCK, 0x01},
199         {TOK_TERM, 0, 0},
200 };
201
202 /**
203  * List of image formats supported by TVP5146/47 decoder
204  * Currently we are using 8 bit mode only, but can be
205  * extended to 10/20 bit mode.
206  */
207 static const struct v4l2_fmtdesc tvp514x_fmt_list[] = {
208         {
209          .index = 0,
210          .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
211          .flags = 0,
212          .description = "8-bit UYVY 4:2:2 Format",
213          .pixelformat = V4L2_PIX_FMT_UYVY,
214         },
215 };
216
217 /**
218  * Supported standards -
219  *
220  * Currently supports two standards only, need to add support for rest of the
221  * modes, like SECAM, etc...
222  */
223 static struct tvp514x_std_info tvp514x_std_list[] = {
224         /* Standard: STD_NTSC_MJ */
225         [STD_NTSC_MJ] = {
226          .width = NTSC_NUM_ACTIVE_PIXELS,
227          .height = NTSC_NUM_ACTIVE_LINES,
228          .video_std = VIDEO_STD_NTSC_MJ_BIT,
229          .standard = {
230                       .index = 0,
231                       .id = V4L2_STD_NTSC,
232                       .name = "NTSC",
233                       .frameperiod = {1001, 30000},
234                       .framelines = 525
235                      },
236         /* Standard: STD_PAL_BDGHIN */
237         },
238         [STD_PAL_BDGHIN] = {
239          .width = PAL_NUM_ACTIVE_PIXELS,
240          .height = PAL_NUM_ACTIVE_LINES,
241          .video_std = VIDEO_STD_PAL_BDGHIN_BIT,
242          .standard = {
243                       .index = 1,
244                       .id = V4L2_STD_PAL,
245                       .name = "PAL",
246                       .frameperiod = {1, 25},
247                       .framelines = 625
248                      },
249         },
250         /* Standard: need to add for additional standard */
251 };
252
253
254 static inline struct tvp514x_decoder *to_decoder(struct v4l2_subdev *sd)
255 {
256         return container_of(sd, struct tvp514x_decoder, sd);
257 }
258
259
260 /**
261  * tvp514x_read_reg() - Read a value from a register in an TVP5146/47.
262  * @sd: ptr to v4l2_subdev struct
263  * @reg: TVP5146/47 register address
264  *
265  * Returns value read if successful, or non-zero (-1) otherwise.
266  */
267 static int tvp514x_read_reg(struct v4l2_subdev *sd, u8 reg)
268 {
269         int err, retry = 0;
270         struct i2c_client *client = v4l2_get_subdevdata(sd);
271
272 read_again:
273
274         err = i2c_smbus_read_byte_data(client, reg);
275         if (err < 0) {
276                 if (retry <= I2C_RETRY_COUNT) {
277                         v4l2_warn(sd, "Read: retry ... %d\n", retry);
278                         retry++;
279                         msleep_interruptible(10);
280                         goto read_again;
281                 }
282         }
283
284         return err;
285 }
286
287 /**
288  * dump_reg() - dump the register content of TVP5146/47.
289  * @sd: ptr to v4l2_subdev struct
290  * @reg: TVP5146/47 register address
291  */
292 static void dump_reg(struct v4l2_subdev *sd, u8 reg)
293 {
294         u32 val;
295
296         val = tvp514x_read_reg(sd, reg);
297         v4l2_info(sd, "Reg(0x%.2X): 0x%.2X\n", reg, val);
298 }
299
300 /**
301  * tvp514x_write_reg() - Write a value to a register in TVP5146/47
302  * @sd: ptr to v4l2_subdev struct
303  * @reg: TVP5146/47 register address
304  * @val: value to be written to the register
305  *
306  * Write a value to a register in an TVP5146/47 decoder device.
307  * Returns zero if successful, or non-zero otherwise.
308  */
309 static int tvp514x_write_reg(struct v4l2_subdev *sd, u8 reg, u8 val)
310 {
311         int err, retry = 0;
312         struct i2c_client *client = v4l2_get_subdevdata(sd);
313
314 write_again:
315
316         err = i2c_smbus_write_byte_data(client, reg, val);
317         if (err) {
318                 if (retry <= I2C_RETRY_COUNT) {
319                         v4l2_warn(sd, "Write: retry ... %d\n", retry);
320                         retry++;
321                         msleep_interruptible(10);
322                         goto write_again;
323                 }
324         }
325
326         return err;
327 }
328
329 /**
330  * tvp514x_write_regs() : Initializes a list of TVP5146/47 registers
331  * @sd: ptr to v4l2_subdev struct
332  * @reglist: list of TVP5146/47 registers and values
333  *
334  * Initializes a list of TVP5146/47 registers:-
335  *              if token is TOK_TERM, then entire write operation terminates
336  *              if token is TOK_DELAY, then a delay of 'val' msec is introduced
337  *              if token is TOK_SKIP, then the register write is skipped
338  *              if token is TOK_WRITE, then the register write is performed
339  * Returns zero if successful, or non-zero otherwise.
340  */
341 static int tvp514x_write_regs(struct v4l2_subdev *sd,
342                               const struct tvp514x_reg reglist[])
343 {
344         int err;
345         const struct tvp514x_reg *next = reglist;
346
347         for (; next->token != TOK_TERM; next++) {
348                 if (next->token == TOK_DELAY) {
349                         msleep(next->val);
350                         continue;
351                 }
352
353                 if (next->token == TOK_SKIP)
354                         continue;
355
356                 err = tvp514x_write_reg(sd, next->reg, (u8) next->val);
357                 if (err) {
358                         v4l2_err(sd, "Write failed. Err[%d]\n", err);
359                         return err;
360                 }
361         }
362         return 0;
363 }
364
365 /**
366  * tvp514x_get_current_std() : Get the current standard detected by TVP5146/47
367  * @sd: ptr to v4l2_subdev struct
368  *
369  * Get current standard detected by TVP5146/47, STD_INVALID if there is no
370  * standard detected.
371  */
372 static enum tvp514x_std tvp514x_get_current_std(struct v4l2_subdev *sd)
373 {
374         u8 std, std_status;
375
376         std = tvp514x_read_reg(sd, REG_VIDEO_STD);
377         if ((std & VIDEO_STD_MASK) == VIDEO_STD_AUTO_SWITCH_BIT)
378                 /* use the standard status register */
379                 std_status = tvp514x_read_reg(sd, REG_VIDEO_STD_STATUS);
380         else
381                 /* use the standard register itself */
382                 std_status = std;
383
384         switch (std_status & VIDEO_STD_MASK) {
385         case VIDEO_STD_NTSC_MJ_BIT:
386                 return STD_NTSC_MJ;
387
388         case VIDEO_STD_PAL_BDGHIN_BIT:
389                 return STD_PAL_BDGHIN;
390
391         default:
392                 return STD_INVALID;
393         }
394
395         return STD_INVALID;
396 }
397
398 /* TVP5146/47 register dump function */
399 static void tvp514x_reg_dump(struct v4l2_subdev *sd)
400 {
401         dump_reg(sd, REG_INPUT_SEL);
402         dump_reg(sd, REG_AFE_GAIN_CTRL);
403         dump_reg(sd, REG_VIDEO_STD);
404         dump_reg(sd, REG_OPERATION_MODE);
405         dump_reg(sd, REG_COLOR_KILLER);
406         dump_reg(sd, REG_LUMA_CONTROL1);
407         dump_reg(sd, REG_LUMA_CONTROL2);
408         dump_reg(sd, REG_LUMA_CONTROL3);
409         dump_reg(sd, REG_BRIGHTNESS);
410         dump_reg(sd, REG_CONTRAST);
411         dump_reg(sd, REG_SATURATION);
412         dump_reg(sd, REG_HUE);
413         dump_reg(sd, REG_CHROMA_CONTROL1);
414         dump_reg(sd, REG_CHROMA_CONTROL2);
415         dump_reg(sd, REG_COMP_PR_SATURATION);
416         dump_reg(sd, REG_COMP_Y_CONTRAST);
417         dump_reg(sd, REG_COMP_PB_SATURATION);
418         dump_reg(sd, REG_COMP_Y_BRIGHTNESS);
419         dump_reg(sd, REG_AVID_START_PIXEL_LSB);
420         dump_reg(sd, REG_AVID_START_PIXEL_MSB);
421         dump_reg(sd, REG_AVID_STOP_PIXEL_LSB);
422         dump_reg(sd, REG_AVID_STOP_PIXEL_MSB);
423         dump_reg(sd, REG_HSYNC_START_PIXEL_LSB);
424         dump_reg(sd, REG_HSYNC_START_PIXEL_MSB);
425         dump_reg(sd, REG_HSYNC_STOP_PIXEL_LSB);
426         dump_reg(sd, REG_HSYNC_STOP_PIXEL_MSB);
427         dump_reg(sd, REG_VSYNC_START_LINE_LSB);
428         dump_reg(sd, REG_VSYNC_START_LINE_MSB);
429         dump_reg(sd, REG_VSYNC_STOP_LINE_LSB);
430         dump_reg(sd, REG_VSYNC_STOP_LINE_MSB);
431         dump_reg(sd, REG_VBLK_START_LINE_LSB);
432         dump_reg(sd, REG_VBLK_START_LINE_MSB);
433         dump_reg(sd, REG_VBLK_STOP_LINE_LSB);
434         dump_reg(sd, REG_VBLK_STOP_LINE_MSB);
435         dump_reg(sd, REG_SYNC_CONTROL);
436         dump_reg(sd, REG_OUTPUT_FORMATTER1);
437         dump_reg(sd, REG_OUTPUT_FORMATTER2);
438         dump_reg(sd, REG_OUTPUT_FORMATTER3);
439         dump_reg(sd, REG_OUTPUT_FORMATTER4);
440         dump_reg(sd, REG_OUTPUT_FORMATTER5);
441         dump_reg(sd, REG_OUTPUT_FORMATTER6);
442         dump_reg(sd, REG_CLEAR_LOST_LOCK);
443 }
444
445 /**
446  * tvp514x_configure() - Configure the TVP5146/47 registers
447  * @sd: ptr to v4l2_subdev struct
448  * @decoder: ptr to tvp514x_decoder structure
449  *
450  * Returns zero if successful, or non-zero otherwise.
451  */
452 static int tvp514x_configure(struct v4l2_subdev *sd,
453                 struct tvp514x_decoder *decoder)
454 {
455         int err;
456
457         /* common register initialization */
458         err =
459             tvp514x_write_regs(sd, decoder->tvp514x_regs);
460         if (err)
461                 return err;
462
463         if (debug)
464                 tvp514x_reg_dump(sd);
465
466         return 0;
467 }
468
469 /**
470  * tvp514x_detect() - Detect if an tvp514x is present, and if so which revision.
471  * @sd: pointer to standard V4L2 sub-device structure
472  * @decoder: pointer to tvp514x_decoder structure
473  *
474  * A device is considered to be detected if the chip ID (LSB and MSB)
475  * registers match the expected values.
476  * Any value of the rom version register is accepted.
477  * Returns ENODEV error number if no device is detected, or zero
478  * if a device is detected.
479  */
480 static int tvp514x_detect(struct v4l2_subdev *sd,
481                 struct tvp514x_decoder *decoder)
482 {
483         u8 chip_id_msb, chip_id_lsb, rom_ver;
484         struct i2c_client *client = v4l2_get_subdevdata(sd);
485
486         chip_id_msb = tvp514x_read_reg(sd, REG_CHIP_ID_MSB);
487         chip_id_lsb = tvp514x_read_reg(sd, REG_CHIP_ID_LSB);
488         rom_ver = tvp514x_read_reg(sd, REG_ROM_VERSION);
489
490         v4l2_dbg(1, debug, sd,
491                  "chip id detected msb:0x%x lsb:0x%x rom version:0x%x\n",
492                  chip_id_msb, chip_id_lsb, rom_ver);
493         if ((chip_id_msb != TVP514X_CHIP_ID_MSB)
494                 || ((chip_id_lsb != TVP5146_CHIP_ID_LSB)
495                 && (chip_id_lsb != TVP5147_CHIP_ID_LSB))) {
496                 /* We didn't read the values we expected, so this must not be
497                  * an TVP5146/47.
498                  */
499                 v4l2_err(sd, "chip id mismatch msb:0x%x lsb:0x%x\n",
500                                 chip_id_msb, chip_id_lsb);
501                 return -ENODEV;
502         }
503
504         decoder->ver = rom_ver;
505
506         v4l2_info(sd, "%s (Version - 0x%.2x) found at 0x%x (%s)\n",
507                         client->name, decoder->ver,
508                         client->addr << 1, client->adapter->name);
509         return 0;
510 }
511
512 /**
513  * tvp514x_querystd() - V4L2 decoder interface handler for querystd
514  * @sd: pointer to standard V4L2 sub-device structure
515  * @std_id: standard V4L2 std_id ioctl enum
516  *
517  * Returns the current standard detected by TVP5146/47. If no active input is
518  * detected, returns -EINVAL
519  */
520 static int tvp514x_querystd(struct v4l2_subdev *sd, v4l2_std_id *std_id)
521 {
522         struct tvp514x_decoder *decoder = to_decoder(sd);
523         enum tvp514x_std current_std;
524         enum tvp514x_input input_sel;
525         u8 sync_lock_status, lock_mask;
526
527         if (std_id == NULL)
528                 return -EINVAL;
529
530         /* get the current standard */
531         current_std = tvp514x_get_current_std(sd);
532         if (current_std == STD_INVALID)
533                 return -EINVAL;
534
535         input_sel = decoder->input;
536
537         switch (input_sel) {
538         case INPUT_CVBS_VI1A:
539         case INPUT_CVBS_VI1B:
540         case INPUT_CVBS_VI1C:
541         case INPUT_CVBS_VI2A:
542         case INPUT_CVBS_VI2B:
543         case INPUT_CVBS_VI2C:
544         case INPUT_CVBS_VI3A:
545         case INPUT_CVBS_VI3B:
546         case INPUT_CVBS_VI3C:
547         case INPUT_CVBS_VI4A:
548                 lock_mask = STATUS_CLR_SUBCAR_LOCK_BIT |
549                         STATUS_HORZ_SYNC_LOCK_BIT |
550                         STATUS_VIRT_SYNC_LOCK_BIT;
551                 break;
552
553         case INPUT_SVIDEO_VI2A_VI1A:
554         case INPUT_SVIDEO_VI2B_VI1B:
555         case INPUT_SVIDEO_VI2C_VI1C:
556         case INPUT_SVIDEO_VI2A_VI3A:
557         case INPUT_SVIDEO_VI2B_VI3B:
558         case INPUT_SVIDEO_VI2C_VI3C:
559         case INPUT_SVIDEO_VI4A_VI1A:
560         case INPUT_SVIDEO_VI4A_VI1B:
561         case INPUT_SVIDEO_VI4A_VI1C:
562         case INPUT_SVIDEO_VI4A_VI3A:
563         case INPUT_SVIDEO_VI4A_VI3B:
564         case INPUT_SVIDEO_VI4A_VI3C:
565                 lock_mask = STATUS_HORZ_SYNC_LOCK_BIT |
566                         STATUS_VIRT_SYNC_LOCK_BIT;
567                 break;
568                 /*Need to add other interfaces*/
569         default:
570                 return -EINVAL;
571         }
572         /* check whether signal is locked */
573         sync_lock_status = tvp514x_read_reg(sd, REG_STATUS1);
574         if (lock_mask != (sync_lock_status & lock_mask))
575                 return -EINVAL; /* No input detected */
576
577         decoder->current_std = current_std;
578         *std_id = decoder->std_list[current_std].standard.id;
579
580         v4l2_dbg(1, debug, sd, "Current STD: %s",
581                         decoder->std_list[current_std].standard.name);
582         return 0;
583 }
584
585 /**
586  * tvp514x_s_std() - V4L2 decoder interface handler for s_std
587  * @sd: pointer to standard V4L2 sub-device structure
588  * @std_id: standard V4L2 v4l2_std_id ioctl enum
589  *
590  * If std_id is supported, sets the requested standard. Otherwise, returns
591  * -EINVAL
592  */
593 static int tvp514x_s_std(struct v4l2_subdev *sd, v4l2_std_id std_id)
594 {
595         struct tvp514x_decoder *decoder = to_decoder(sd);
596         int err, i;
597
598         for (i = 0; i < decoder->num_stds; i++)
599                 if (std_id & decoder->std_list[i].standard.id)
600                         break;
601
602         if ((i == decoder->num_stds) || (i == STD_INVALID))
603                 return -EINVAL;
604
605         err = tvp514x_write_reg(sd, REG_VIDEO_STD,
606                                 decoder->std_list[i].video_std);
607         if (err)
608                 return err;
609
610         decoder->current_std = i;
611         decoder->tvp514x_regs[REG_VIDEO_STD].val =
612                 decoder->std_list[i].video_std;
613
614         v4l2_dbg(1, debug, sd, "Standard set to: %s",
615                         decoder->std_list[i].standard.name);
616         return 0;
617 }
618
619 /**
620  * tvp514x_s_routing() - V4L2 decoder interface handler for s_routing
621  * @sd: pointer to standard V4L2 sub-device structure
622  * @input: input selector for routing the signal
623  * @output: output selector for routing the signal
624  * @config: config value. Not used
625  *
626  * If index is valid, selects the requested input. Otherwise, returns -EINVAL if
627  * the input is not supported or there is no active signal present in the
628  * selected input.
629  */
630 static int tvp514x_s_routing(struct v4l2_subdev *sd,
631                                 u32 input, u32 output, u32 config)
632 {
633         struct tvp514x_decoder *decoder = to_decoder(sd);
634         int err;
635         enum tvp514x_input input_sel;
636         enum tvp514x_output output_sel;
637         enum tvp514x_std current_std = STD_INVALID;
638         u8 sync_lock_status, lock_mask;
639         int try_count = LOCK_RETRY_COUNT;
640
641         if ((input >= INPUT_INVALID) ||
642                         (output >= OUTPUT_INVALID))
643                 /* Index out of bound */
644                 return -EINVAL;
645
646         input_sel = input;
647         output_sel = output;
648
649         err = tvp514x_write_reg(sd, REG_INPUT_SEL, input_sel);
650         if (err)
651                 return err;
652
653         output_sel |= tvp514x_read_reg(sd,
654                         REG_OUTPUT_FORMATTER1) & 0x7;
655         err = tvp514x_write_reg(sd, REG_OUTPUT_FORMATTER1,
656                         output_sel);
657         if (err)
658                 return err;
659
660         decoder->tvp514x_regs[REG_INPUT_SEL].val = input_sel;
661         decoder->tvp514x_regs[REG_OUTPUT_FORMATTER1].val = output_sel;
662
663         /* Clear status */
664         msleep(LOCK_RETRY_DELAY);
665         err =
666             tvp514x_write_reg(sd, REG_CLEAR_LOST_LOCK, 0x01);
667         if (err)
668                 return err;
669
670         switch (input_sel) {
671         case INPUT_CVBS_VI1A:
672         case INPUT_CVBS_VI1B:
673         case INPUT_CVBS_VI1C:
674         case INPUT_CVBS_VI2A:
675         case INPUT_CVBS_VI2B:
676         case INPUT_CVBS_VI2C:
677         case INPUT_CVBS_VI3A:
678         case INPUT_CVBS_VI3B:
679         case INPUT_CVBS_VI3C:
680         case INPUT_CVBS_VI4A:
681                 lock_mask = STATUS_CLR_SUBCAR_LOCK_BIT |
682                         STATUS_HORZ_SYNC_LOCK_BIT |
683                         STATUS_VIRT_SYNC_LOCK_BIT;
684                 break;
685
686         case INPUT_SVIDEO_VI2A_VI1A:
687         case INPUT_SVIDEO_VI2B_VI1B:
688         case INPUT_SVIDEO_VI2C_VI1C:
689         case INPUT_SVIDEO_VI2A_VI3A:
690         case INPUT_SVIDEO_VI2B_VI3B:
691         case INPUT_SVIDEO_VI2C_VI3C:
692         case INPUT_SVIDEO_VI4A_VI1A:
693         case INPUT_SVIDEO_VI4A_VI1B:
694         case INPUT_SVIDEO_VI4A_VI1C:
695         case INPUT_SVIDEO_VI4A_VI3A:
696         case INPUT_SVIDEO_VI4A_VI3B:
697         case INPUT_SVIDEO_VI4A_VI3C:
698                 lock_mask = STATUS_HORZ_SYNC_LOCK_BIT |
699                         STATUS_VIRT_SYNC_LOCK_BIT;
700                 break;
701         /* Need to add other interfaces*/
702         default:
703                 return -EINVAL;
704         }
705
706         while (try_count-- > 0) {
707                 /* Allow decoder to sync up with new input */
708                 msleep(LOCK_RETRY_DELAY);
709
710                 /* get the current standard for future reference */
711                 current_std = tvp514x_get_current_std(sd);
712                 if (current_std == STD_INVALID)
713                         continue;
714
715                 sync_lock_status = tvp514x_read_reg(sd,
716                                 REG_STATUS1);
717                 if (lock_mask == (sync_lock_status & lock_mask))
718                         /* Input detected */
719                         break;
720         }
721
722         if ((current_std == STD_INVALID) || (try_count < 0))
723                 return -EINVAL;
724
725         decoder->current_std = current_std;
726         decoder->input = input;
727         decoder->output = output;
728
729         v4l2_dbg(1, debug, sd, "Input set to: %d, std : %d",
730                         input_sel, current_std);
731
732         return 0;
733 }
734
735 /**
736  * tvp514x_queryctrl() - V4L2 decoder interface handler for queryctrl
737  * @sd: pointer to standard V4L2 sub-device structure
738  * @qctrl: standard V4L2 v4l2_queryctrl structure
739  *
740  * If the requested control is supported, returns the control information.
741  * Otherwise, returns -EINVAL if the control is not supported.
742  */
743 static int
744 tvp514x_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qctrl)
745 {
746         int err = -EINVAL;
747
748         if (qctrl == NULL)
749                 return err;
750
751         switch (qctrl->id) {
752         case V4L2_CID_BRIGHTNESS:
753                 /* Brightness supported is (0-255), */
754                 err = v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
755                 break;
756         case V4L2_CID_CONTRAST:
757         case V4L2_CID_SATURATION:
758                 /**
759                  * Saturation and Contrast supported is -
760                  *      Contrast: 0 - 255 (Default - 128)
761                  *      Saturation: 0 - 255 (Default - 128)
762                  */
763                 err = v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
764                 break;
765         case V4L2_CID_HUE:
766                 /* Hue Supported is -
767                  *      Hue - -180 - +180 (Default - 0, Step - +180)
768                  */
769                 err = v4l2_ctrl_query_fill(qctrl, -180, 180, 180, 0);
770                 break;
771         case V4L2_CID_AUTOGAIN:
772                 /**
773                  * Auto Gain supported is -
774                  *      0 - 1 (Default - 1)
775                  */
776                 err = v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
777                 break;
778         default:
779                 v4l2_err(sd, "invalid control id %d\n", qctrl->id);
780                 return err;
781         }
782
783         v4l2_dbg(1, debug, sd, "Query Control:%s: Min - %d, Max - %d, Def - %d",
784                         qctrl->name, qctrl->minimum, qctrl->maximum,
785                         qctrl->default_value);
786
787         return err;
788 }
789
790 /**
791  * tvp514x_g_ctrl() - V4L2 decoder interface handler for g_ctrl
792  * @sd: pointer to standard V4L2 sub-device structure
793  * @ctrl: pointer to v4l2_control structure
794  *
795  * If the requested control is supported, returns the control's current
796  * value from the decoder. Otherwise, returns -EINVAL if the control is not
797  * supported.
798  */
799 static int
800 tvp514x_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
801 {
802         struct tvp514x_decoder *decoder = to_decoder(sd);
803
804         if (ctrl == NULL)
805                 return -EINVAL;
806
807         switch (ctrl->id) {
808         case V4L2_CID_BRIGHTNESS:
809                 ctrl->value = decoder->tvp514x_regs[REG_BRIGHTNESS].val;
810                 break;
811         case V4L2_CID_CONTRAST:
812                 ctrl->value = decoder->tvp514x_regs[REG_CONTRAST].val;
813                 break;
814         case V4L2_CID_SATURATION:
815                 ctrl->value = decoder->tvp514x_regs[REG_SATURATION].val;
816                 break;
817         case V4L2_CID_HUE:
818                 ctrl->value = decoder->tvp514x_regs[REG_HUE].val;
819                 if (ctrl->value == 0x7F)
820                         ctrl->value = 180;
821                 else if (ctrl->value == 0x80)
822                         ctrl->value = -180;
823                 else
824                         ctrl->value = 0;
825
826                 break;
827         case V4L2_CID_AUTOGAIN:
828                 ctrl->value = decoder->tvp514x_regs[REG_AFE_GAIN_CTRL].val;
829                 if ((ctrl->value & 0x3) == 3)
830                         ctrl->value = 1;
831                 else
832                         ctrl->value = 0;
833
834                 break;
835         default:
836                 v4l2_err(sd, "invalid control id %d\n", ctrl->id);
837                 return -EINVAL;
838         }
839
840         v4l2_dbg(1, debug, sd, "Get Control: ID - %d - %d",
841                         ctrl->id, ctrl->value);
842         return 0;
843 }
844
845 /**
846  * tvp514x_s_ctrl() - V4L2 decoder interface handler for s_ctrl
847  * @sd: pointer to standard V4L2 sub-device structure
848  * @ctrl: pointer to v4l2_control structure
849  *
850  * If the requested control is supported, sets the control's current
851  * value in HW. Otherwise, returns -EINVAL if the control is not supported.
852  */
853 static int
854 tvp514x_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
855 {
856         struct tvp514x_decoder *decoder = to_decoder(sd);
857         int err = -EINVAL, value;
858
859         if (ctrl == NULL)
860                 return err;
861
862         value = ctrl->value;
863
864         switch (ctrl->id) {
865         case V4L2_CID_BRIGHTNESS:
866                 if (ctrl->value < 0 || ctrl->value > 255) {
867                         v4l2_err(sd, "invalid brightness setting %d\n",
868                                         ctrl->value);
869                         return -ERANGE;
870                 }
871                 err = tvp514x_write_reg(sd, REG_BRIGHTNESS,
872                                 value);
873                 if (err)
874                         return err;
875
876                 decoder->tvp514x_regs[REG_BRIGHTNESS].val = value;
877                 break;
878         case V4L2_CID_CONTRAST:
879                 if (ctrl->value < 0 || ctrl->value > 255) {
880                         v4l2_err(sd, "invalid contrast setting %d\n",
881                                         ctrl->value);
882                         return -ERANGE;
883                 }
884                 err = tvp514x_write_reg(sd, REG_CONTRAST, value);
885                 if (err)
886                         return err;
887
888                 decoder->tvp514x_regs[REG_CONTRAST].val = value;
889                 break;
890         case V4L2_CID_SATURATION:
891                 if (ctrl->value < 0 || ctrl->value > 255) {
892                         v4l2_err(sd, "invalid saturation setting %d\n",
893                                         ctrl->value);
894                         return -ERANGE;
895                 }
896                 err = tvp514x_write_reg(sd, REG_SATURATION, value);
897                 if (err)
898                         return err;
899
900                 decoder->tvp514x_regs[REG_SATURATION].val = value;
901                 break;
902         case V4L2_CID_HUE:
903                 if (value == 180)
904                         value = 0x7F;
905                 else if (value == -180)
906                         value = 0x80;
907                 else if (value == 0)
908                         value = 0;
909                 else {
910                         v4l2_err(sd, "invalid hue setting %d\n", ctrl->value);
911                         return -ERANGE;
912                 }
913                 err = tvp514x_write_reg(sd, REG_HUE, value);
914                 if (err)
915                         return err;
916
917                 decoder->tvp514x_regs[REG_HUE].val = value;
918                 break;
919         case V4L2_CID_AUTOGAIN:
920                 if (value == 1)
921                         value = 0x0F;
922                 else if (value == 0)
923                         value = 0x0C;
924                 else {
925                         v4l2_err(sd, "invalid auto gain setting %d\n",
926                                         ctrl->value);
927                         return -ERANGE;
928                 }
929                 err = tvp514x_write_reg(sd, REG_AFE_GAIN_CTRL, value);
930                 if (err)
931                         return err;
932
933                 decoder->tvp514x_regs[REG_AFE_GAIN_CTRL].val = value;
934                 break;
935         default:
936                 v4l2_err(sd, "invalid control id %d\n", ctrl->id);
937                 return err;
938         }
939
940         v4l2_dbg(1, debug, sd, "Set Control: ID - %d - %d",
941                         ctrl->id, ctrl->value);
942
943         return err;
944 }
945
946 /**
947  * tvp514x_enum_fmt_cap() - V4L2 decoder interface handler for enum_fmt
948  * @sd: pointer to standard V4L2 sub-device structure
949  * @fmt: standard V4L2 VIDIOC_ENUM_FMT ioctl structure
950  *
951  * Implement the VIDIOC_ENUM_FMT ioctl to enumerate supported formats
952  */
953 static int
954 tvp514x_enum_fmt_cap(struct v4l2_subdev *sd, struct v4l2_fmtdesc *fmt)
955 {
956         struct tvp514x_decoder *decoder = to_decoder(sd);
957         int index;
958
959         if (fmt == NULL)
960                 return -EINVAL;
961
962         index = fmt->index;
963         if ((index >= decoder->num_fmts) || (index < 0))
964                 /* Index out of bound */
965                 return -EINVAL;
966
967         if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
968                 /* only capture is supported */
969                 return -EINVAL;
970
971         memcpy(fmt, &decoder->fmt_list[index],
972                 sizeof(struct v4l2_fmtdesc));
973
974         v4l2_dbg(1, debug, sd, "Current FMT: index - %d (%s)",
975                         decoder->fmt_list[index].index,
976                         decoder->fmt_list[index].description);
977         return 0;
978 }
979
980 /**
981  * tvp514x_try_fmt_cap() - V4L2 decoder interface handler for try_fmt
982  * @sd: pointer to standard V4L2 sub-device structure
983  * @f: pointer to standard V4L2 VIDIOC_TRY_FMT ioctl structure
984  *
985  * Implement the VIDIOC_TRY_FMT ioctl for the CAPTURE buffer type. This
986  * ioctl is used to negotiate the image capture size and pixel format
987  * without actually making it take effect.
988  */
989 static int
990 tvp514x_try_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
991 {
992         struct tvp514x_decoder *decoder = to_decoder(sd);
993         int ifmt;
994         struct v4l2_pix_format *pix;
995         enum tvp514x_std current_std;
996
997         if (f == NULL)
998                 return -EINVAL;
999
1000         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1001                 /* only capture is supported */
1002                 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1003
1004         pix = &f->fmt.pix;
1005
1006         /* Calculate height and width based on current standard */
1007         current_std = tvp514x_get_current_std(sd);
1008         if (current_std == STD_INVALID)
1009                 return -EINVAL;
1010
1011         decoder->current_std = current_std;
1012         pix->width = decoder->std_list[current_std].width;
1013         pix->height = decoder->std_list[current_std].height;
1014
1015         for (ifmt = 0; ifmt < decoder->num_fmts; ifmt++) {
1016                 if (pix->pixelformat ==
1017                         decoder->fmt_list[ifmt].pixelformat)
1018                         break;
1019         }
1020         if (ifmt == decoder->num_fmts)
1021                 /* None of the format matched, select default */
1022                 ifmt = 0;
1023         pix->pixelformat = decoder->fmt_list[ifmt].pixelformat;
1024
1025         pix->field = V4L2_FIELD_INTERLACED;
1026         pix->bytesperline = pix->width * 2;
1027         pix->sizeimage = pix->bytesperline * pix->height;
1028         pix->colorspace = V4L2_COLORSPACE_SMPTE170M;
1029         pix->priv = 0;
1030
1031         v4l2_dbg(1, debug, sd, "Try FMT: pixelformat - %s, bytesperline - %d"
1032                         "Width - %d, Height - %d",
1033                         decoder->fmt_list[ifmt].description, pix->bytesperline,
1034                         pix->width, pix->height);
1035         return 0;
1036 }
1037
1038 /**
1039  * tvp514x_s_fmt_cap() - V4L2 decoder interface handler for s_fmt
1040  * @sd: pointer to standard V4L2 sub-device structure
1041  * @f: pointer to standard V4L2 VIDIOC_S_FMT ioctl structure
1042  *
1043  * If the requested format is supported, configures the HW to use that
1044  * format, returns error code if format not supported or HW can't be
1045  * correctly configured.
1046  */
1047 static int
1048 tvp514x_s_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
1049 {
1050         struct tvp514x_decoder *decoder = to_decoder(sd);
1051         struct v4l2_pix_format *pix;
1052         int rval;
1053
1054         if (f == NULL)
1055                 return -EINVAL;
1056
1057         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1058                 /* only capture is supported */
1059                 return -EINVAL;
1060
1061         pix = &f->fmt.pix;
1062         rval = tvp514x_try_fmt_cap(sd, f);
1063         if (rval)
1064                 return rval;
1065
1066                 decoder->pix = *pix;
1067
1068         return rval;
1069 }
1070
1071 /**
1072  * tvp514x_g_fmt_cap() - V4L2 decoder interface handler for tvp514x_g_fmt_cap
1073  * @sd: pointer to standard V4L2 sub-device structure
1074  * @f: pointer to standard V4L2 v4l2_format structure
1075  *
1076  * Returns the decoder's current pixel format in the v4l2_format
1077  * parameter.
1078  */
1079 static int
1080 tvp514x_g_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
1081 {
1082         struct tvp514x_decoder *decoder = to_decoder(sd);
1083
1084         if (f == NULL)
1085                 return -EINVAL;
1086
1087         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1088                 /* only capture is supported */
1089                 return -EINVAL;
1090
1091         f->fmt.pix = decoder->pix;
1092
1093         v4l2_dbg(1, debug, sd, "Current FMT: bytesperline - %d"
1094                         "Width - %d, Height - %d",
1095                         decoder->pix.bytesperline,
1096                         decoder->pix.width, decoder->pix.height);
1097         return 0;
1098 }
1099
1100 /**
1101  * tvp514x_g_parm() - V4L2 decoder interface handler for g_parm
1102  * @sd: pointer to standard V4L2 sub-device structure
1103  * @a: pointer to standard V4L2 VIDIOC_G_PARM ioctl structure
1104  *
1105  * Returns the decoder's video CAPTURE parameters.
1106  */
1107 static int
1108 tvp514x_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
1109 {
1110         struct tvp514x_decoder *decoder = to_decoder(sd);
1111         struct v4l2_captureparm *cparm;
1112         enum tvp514x_std current_std;
1113
1114         if (a == NULL)
1115                 return -EINVAL;
1116
1117         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1118                 /* only capture is supported */
1119                 return -EINVAL;
1120
1121         memset(a, 0, sizeof(*a));
1122         a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1123
1124         /* get the current standard */
1125         current_std = tvp514x_get_current_std(sd);
1126         if (current_std == STD_INVALID)
1127                 return -EINVAL;
1128
1129         decoder->current_std = current_std;
1130
1131         cparm = &a->parm.capture;
1132         cparm->capability = V4L2_CAP_TIMEPERFRAME;
1133         cparm->timeperframe =
1134                 decoder->std_list[current_std].standard.frameperiod;
1135
1136         return 0;
1137 }
1138
1139 /**
1140  * tvp514x_s_parm() - V4L2 decoder interface handler for s_parm
1141  * @sd: pointer to standard V4L2 sub-device structure
1142  * @a: pointer to standard V4L2 VIDIOC_S_PARM ioctl structure
1143  *
1144  * Configures the decoder to use the input parameters, if possible. If
1145  * not possible, returns the appropriate error code.
1146  */
1147 static int
1148 tvp514x_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
1149 {
1150         struct tvp514x_decoder *decoder = to_decoder(sd);
1151         struct v4l2_fract *timeperframe;
1152         enum tvp514x_std current_std;
1153
1154         if (a == NULL)
1155                 return -EINVAL;
1156
1157         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1158                 /* only capture is supported */
1159                 return -EINVAL;
1160
1161         timeperframe = &a->parm.capture.timeperframe;
1162
1163         /* get the current standard */
1164         current_std = tvp514x_get_current_std(sd);
1165         if (current_std == STD_INVALID)
1166                 return -EINVAL;
1167
1168         decoder->current_std = current_std;
1169
1170         *timeperframe =
1171             decoder->std_list[current_std].standard.frameperiod;
1172
1173         return 0;
1174 }
1175
1176 /**
1177  * tvp514x_s_stream() - V4L2 decoder i/f handler for s_stream
1178  * @sd: pointer to standard V4L2 sub-device structure
1179  * @enable: streaming enable or disable
1180  *
1181  * Sets streaming to enable or disable, if possible.
1182  */
1183 static int tvp514x_s_stream(struct v4l2_subdev *sd, int enable)
1184 {
1185         int err = 0;
1186         struct i2c_client *client = v4l2_get_subdevdata(sd);
1187         struct tvp514x_decoder *decoder = to_decoder(sd);
1188
1189         if (decoder->streaming == enable)
1190                 return 0;
1191
1192         switch (enable) {
1193         case 0:
1194         {
1195                 /* Power Down Sequence */
1196                 err = tvp514x_write_reg(sd, REG_OPERATION_MODE, 0x01);
1197                 if (err) {
1198                         v4l2_err(sd, "Unable to turn off decoder\n");
1199                         return err;
1200                 }
1201                 decoder->streaming = enable;
1202                 break;
1203         }
1204         case 1:
1205         {
1206                 struct tvp514x_reg *int_seq = (struct tvp514x_reg *)
1207                                 client->driver->id_table->driver_data;
1208
1209                 /* Power Up Sequence */
1210                 err = tvp514x_write_regs(sd, int_seq);
1211                 if (err) {
1212                         v4l2_err(sd, "Unable to turn on decoder\n");
1213                         return err;
1214                 }
1215                 /* Detect if not already detected */
1216                 err = tvp514x_detect(sd, decoder);
1217                 if (err) {
1218                         v4l2_err(sd, "Unable to detect decoder\n");
1219                         return err;
1220                 }
1221                 err = tvp514x_configure(sd, decoder);
1222                 if (err) {
1223                         v4l2_err(sd, "Unable to configure decoder\n");
1224                         return err;
1225                 }
1226                 decoder->streaming = enable;
1227                 break;
1228         }
1229         default:
1230                 err = -ENODEV;
1231                 break;
1232         }
1233
1234         return err;
1235 }
1236
1237 static const struct v4l2_subdev_core_ops tvp514x_core_ops = {
1238         .queryctrl = tvp514x_queryctrl,
1239         .g_ctrl = tvp514x_g_ctrl,
1240         .s_ctrl = tvp514x_s_ctrl,
1241         .s_std = tvp514x_s_std,
1242 };
1243
1244 static const struct v4l2_subdev_video_ops tvp514x_video_ops = {
1245         .s_routing = tvp514x_s_routing,
1246         .querystd = tvp514x_querystd,
1247         .enum_fmt = tvp514x_enum_fmt_cap,
1248         .g_fmt = tvp514x_g_fmt_cap,
1249         .try_fmt = tvp514x_try_fmt_cap,
1250         .s_fmt = tvp514x_s_fmt_cap,
1251         .g_parm = tvp514x_g_parm,
1252         .s_parm = tvp514x_s_parm,
1253         .s_stream = tvp514x_s_stream,
1254 };
1255
1256 static const struct v4l2_subdev_ops tvp514x_ops = {
1257         .core = &tvp514x_core_ops,
1258         .video = &tvp514x_video_ops,
1259 };
1260
1261 static struct tvp514x_decoder tvp514x_dev = {
1262         .streaming = 0,
1263
1264         .fmt_list = tvp514x_fmt_list,
1265         .num_fmts = ARRAY_SIZE(tvp514x_fmt_list),
1266
1267         .pix = {
1268                 /* Default to NTSC 8-bit YUV 422 */
1269                 .width = NTSC_NUM_ACTIVE_PIXELS,
1270                 .height = NTSC_NUM_ACTIVE_LINES,
1271                 .pixelformat = V4L2_PIX_FMT_UYVY,
1272                 .field = V4L2_FIELD_INTERLACED,
1273                 .bytesperline = NTSC_NUM_ACTIVE_PIXELS * 2,
1274                 .sizeimage =
1275                 NTSC_NUM_ACTIVE_PIXELS * 2 * NTSC_NUM_ACTIVE_LINES,
1276                 .colorspace = V4L2_COLORSPACE_SMPTE170M,
1277                 },
1278
1279         .current_std = STD_NTSC_MJ,
1280         .std_list = tvp514x_std_list,
1281         .num_stds = ARRAY_SIZE(tvp514x_std_list),
1282
1283 };
1284
1285 /**
1286  * tvp514x_probe() - decoder driver i2c probe handler
1287  * @client: i2c driver client device structure
1288  * @id: i2c driver id table
1289  *
1290  * Register decoder as an i2c client device and V4L2
1291  * device.
1292  */
1293 static int
1294 tvp514x_probe(struct i2c_client *client, const struct i2c_device_id *id)
1295 {
1296         struct tvp514x_decoder *decoder;
1297         struct v4l2_subdev *sd;
1298
1299         /* Check if the adapter supports the needed features */
1300         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1301                 return -EIO;
1302
1303         if (!client->dev.platform_data) {
1304                 v4l2_err(client, "No platform data!!\n");
1305                 return -ENODEV;
1306         }
1307
1308         decoder = kzalloc(sizeof(*decoder), GFP_KERNEL);
1309         if (!decoder)
1310                 return -ENOMEM;
1311
1312         /* Initialize the tvp514x_decoder with default configuration */
1313         *decoder = tvp514x_dev;
1314         /* Copy default register configuration */
1315         memcpy(decoder->tvp514x_regs, tvp514x_reg_list_default,
1316                         sizeof(tvp514x_reg_list_default));
1317
1318         /* Copy board specific information here */
1319         decoder->pdata = client->dev.platform_data;
1320
1321         /**
1322          * Fetch platform specific data, and configure the
1323          * tvp514x_reg_list[] accordingly. Since this is one
1324          * time configuration, no need to preserve.
1325          */
1326         decoder->tvp514x_regs[REG_OUTPUT_FORMATTER2].val |=
1327                 (decoder->pdata->clk_polarity << 1);
1328         decoder->tvp514x_regs[REG_SYNC_CONTROL].val |=
1329                 ((decoder->pdata->hs_polarity << 2) |
1330                  (decoder->pdata->vs_polarity << 3));
1331         /* Set default standard to auto */
1332         decoder->tvp514x_regs[REG_VIDEO_STD].val =
1333                 VIDEO_STD_AUTO_SWITCH_BIT;
1334
1335         /* Register with V4L2 layer as slave device */
1336         sd = &decoder->sd;
1337         v4l2_i2c_subdev_init(sd, client, &tvp514x_ops);
1338
1339         v4l2_info(sd, "%s decoder driver registered !!\n", sd->name);
1340
1341         return 0;
1342
1343 }
1344
1345 /**
1346  * tvp514x_remove() - decoder driver i2c remove handler
1347  * @client: i2c driver client device structure
1348  *
1349  * Unregister decoder as an i2c client device and V4L2
1350  * device. Complement of tvp514x_probe().
1351  */
1352 static int tvp514x_remove(struct i2c_client *client)
1353 {
1354         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1355         struct tvp514x_decoder *decoder = to_decoder(sd);
1356
1357         v4l2_device_unregister_subdev(sd);
1358         kfree(decoder);
1359         return 0;
1360 }
1361 /* TVP5146 Init/Power on Sequence */
1362 static const struct tvp514x_reg tvp5146_init_reg_seq[] = {
1363         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x02},
1364         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1365         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0x80},
1366         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1367         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1368         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1369         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1370         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1371         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
1372         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1373         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1374         {TOK_TERM, 0, 0},
1375 };
1376
1377 /* TVP5147 Init/Power on Sequence */
1378 static const struct tvp514x_reg tvp5147_init_reg_seq[] =        {
1379         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x02},
1380         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1381         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0x80},
1382         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1383         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1384         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1385         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1386         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1387         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x16},
1388         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1389         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xA0},
1390         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x16},
1391         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1392         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1393         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1394         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
1395         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1396         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1397         {TOK_TERM, 0, 0},
1398 };
1399
1400 /* TVP5146M2/TVP5147M1 Init/Power on Sequence */
1401 static const struct tvp514x_reg tvp514xm_init_reg_seq[] = {
1402         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1403         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1404         {TOK_TERM, 0, 0},
1405 };
1406
1407 /**
1408  * I2C Device Table -
1409  *
1410  * name - Name of the actual device/chip.
1411  * driver_data - Driver data
1412  */
1413 static const struct i2c_device_id tvp514x_id[] = {
1414         {"tvp5146", (unsigned long)tvp5146_init_reg_seq},
1415         {"tvp5146m2", (unsigned long)tvp514xm_init_reg_seq},
1416         {"tvp5147", (unsigned long)tvp5147_init_reg_seq},
1417         {"tvp5147m1", (unsigned long)tvp514xm_init_reg_seq},
1418         {},
1419 };
1420
1421 MODULE_DEVICE_TABLE(i2c, tvp514x_id);
1422
1423 static struct i2c_driver tvp514x_driver = {
1424         .driver = {
1425                 .owner = THIS_MODULE,
1426                 .name = TVP514X_MODULE_NAME,
1427         },
1428         .probe = tvp514x_probe,
1429         .remove = tvp514x_remove,
1430         .id_table = tvp514x_id,
1431 };
1432
1433 static int __init tvp514x_init(void)
1434 {
1435         return i2c_add_driver(&tvp514x_driver);
1436 }
1437
1438 static void __exit tvp514x_exit(void)
1439 {
1440         i2c_del_driver(&tvp514x_driver);
1441 }
1442
1443 module_init(tvp514x_init);
1444 module_exit(tvp514x_exit);