SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 == -1) {
 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);