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/slab.h>
  33 #include <linux/delay.h>
  34 #include <linux/videodev2.h>
  35 #include <linux/module.h>
  36
  37 #include <media/v4l2-device.h>
  38 #include <media/v4l2-common.h>
  39 #include <media/v4l2-mediabus.h>
  40 #include <media/v4l2-chip-ident.h>
  41 #include <media/v4l2-ctrls.h>
  42 #include <media/tvp514x.h>
  43
  44 #include "tvp514x_regs.h"
  45
  46 /* Module Name */
  47 #define TVP514X_MODULE_NAME             "tvp514x"
  48
  49 /* Private macros for TVP */
  50 #define I2C_RETRY_COUNT                 (5)
  51 #define LOCK_RETRY_COUNT                (5)
  52 #define LOCK_RETRY_DELAY                (200)
  53
  54 /* Debug functions */
  55 static bool debug;
  56 module_param(debug, bool, 0644);
  57 MODULE_PARM_DESC(debug, "Debug level (0-1)");
  58
  59 MODULE_AUTHOR("Texas Instruments");
  60 MODULE_DESCRIPTION("TVP514X linux decoder driver");
  61 MODULE_LICENSE("GPL");
  62
  63 /* enum tvp514x_std - enum for supported standards */
  64 enum tvp514x_std {
  65         STD_NTSC_MJ = 0,
  66         STD_PAL_BDGHIN,
  67         STD_INVALID
  68 };
  69
  70 /**
  71  * struct tvp514x_std_info - Structure to store standard informations
  72  * @width: Line width in pixels
  73  * @height:Number of active lines
  74  * @video_std: Value to write in REG_VIDEO_STD register
  75  * @standard: v4l2 standard structure information
  76  */
  77 struct tvp514x_std_info {
  78         unsigned long width;
  79         unsigned long height;
  80         u8 video_std;
  81         struct v4l2_standard standard;
  82 };
  83
  84 static struct tvp514x_reg tvp514x_reg_list_default[0x40];
  85
  86 static int tvp514x_s_stream(struct v4l2_subdev *sd, int enable);
  87 /**
  88  * struct tvp514x_decoder - TVP5146/47 decoder object
  89  * @sd: Subdevice Slave handle
  90  * @tvp514x_regs: copy of hw's regs with preset values.
  91  * @pdata: Board specific
  92  * @ver: Chip version
  93  * @streaming: TVP5146/47 decoder streaming - enabled or disabled.
  94  * @current_std: Current standard
  95  * @num_stds: Number of standards
  96  * @std_list: Standards list
  97  * @input: Input routing at chip level
  98  * @output: Output routing at chip level
  99  */
 100 struct tvp514x_decoder {
 101         struct v4l2_subdev sd;
 102         struct v4l2_ctrl_handler hdl;
 103         struct tvp514x_reg tvp514x_regs[ARRAY_SIZE(tvp514x_reg_list_default)];
 104         const struct tvp514x_platform_data *pdata;
 105
 106         int ver;
 107         int streaming;
 108
 109         enum tvp514x_std current_std;
 110         int num_stds;
 111         const 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  * Supported standards -
 204  *
 205  * Currently supports two standards only, need to add support for rest of the
 206  * modes, like SECAM, etc...
 207  */
 208 static const struct tvp514x_std_info tvp514x_std_list[] = {
 209         /* Standard: STD_NTSC_MJ */
 210         [STD_NTSC_MJ] = {
 211          .width = NTSC_NUM_ACTIVE_PIXELS,
 212          .height = NTSC_NUM_ACTIVE_LINES,
 213          .video_std = VIDEO_STD_NTSC_MJ_BIT,
 214          .standard = {
 215                       .index = 0,
 216                       .id = V4L2_STD_NTSC,
 217                       .name = "NTSC",
 218                       .frameperiod = {1001, 30000},
 219                       .framelines = 525
 220                      },
 221         /* Standard: STD_PAL_BDGHIN */
 222         },
 223         [STD_PAL_BDGHIN] = {
 224          .width = PAL_NUM_ACTIVE_PIXELS,
 225          .height = PAL_NUM_ACTIVE_LINES,
 226          .video_std = VIDEO_STD_PAL_BDGHIN_BIT,
 227          .standard = {
 228                       .index = 1,
 229                       .id = V4L2_STD_PAL,
 230                       .name = "PAL",
 231                       .frameperiod = {1, 25},
 232                       .framelines = 625
 233                      },
 234         },
 235         /* Standard: need to add for additional standard */
 236 };
 237
 238
 239 static inline struct tvp514x_decoder *to_decoder(struct v4l2_subdev *sd)
 240 {
 241         return container_of(sd, struct tvp514x_decoder, sd);
 242 }
 243
 244 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
 245 {
 246         return &container_of(ctrl->handler, struct tvp514x_decoder, hdl)->sd;
 247 }
 248
 249
 250 /**
 251  * tvp514x_read_reg() - Read a value from a register in an TVP5146/47.
 252  * @sd: ptr to v4l2_subdev struct
 253  * @reg: TVP5146/47 register address
 254  *
 255  * Returns value read if successful, or non-zero (-1) otherwise.
 256  */
 257 static int tvp514x_read_reg(struct v4l2_subdev *sd, u8 reg)
 258 {
 259         int err, retry = 0;
 260         struct i2c_client *client = v4l2_get_subdevdata(sd);
 261
 262 read_again:
 263
 264         err = i2c_smbus_read_byte_data(client, reg);
 265         if (err < 0) {
 266                 if (retry <= I2C_RETRY_COUNT) {
 267                         v4l2_warn(sd, "Read: retry ... %d\n", retry);
 268                         retry++;
 269                         msleep_interruptible(10);
 270                         goto read_again;
 271                 }
 272         }
 273
 274         return err;
 275 }
 276
 277 /**
 278  * dump_reg() - dump the register content of TVP5146/47.
 279  * @sd: ptr to v4l2_subdev struct
 280  * @reg: TVP5146/47 register address
 281  */
 282 static void dump_reg(struct v4l2_subdev *sd, u8 reg)
 283 {
 284         u32 val;
 285
 286         val = tvp514x_read_reg(sd, reg);
 287         v4l2_info(sd, "Reg(0x%.2X): 0x%.2X\n", reg, val);
 288 }
 289
 290 /**
 291  * tvp514x_write_reg() - Write a value to a register in TVP5146/47
 292  * @sd: ptr to v4l2_subdev struct
 293  * @reg: TVP5146/47 register address
 294  * @val: value to be written to the register
 295  *
 296  * Write a value to a register in an TVP5146/47 decoder device.
 297  * Returns zero if successful, or non-zero otherwise.
 298  */
 299 static int tvp514x_write_reg(struct v4l2_subdev *sd, u8 reg, u8 val)
 300 {
 301         int err, retry = 0;
 302         struct i2c_client *client = v4l2_get_subdevdata(sd);
 303
 304 write_again:
 305
 306         err = i2c_smbus_write_byte_data(client, reg, val);
 307         if (err) {
 308                 if (retry <= I2C_RETRY_COUNT) {
 309                         v4l2_warn(sd, "Write: retry ... %d\n", retry);
 310                         retry++;
 311                         msleep_interruptible(10);
 312                         goto write_again;
 313                 }
 314         }
 315
 316         return err;
 317 }
 318
 319 /**
 320  * tvp514x_write_regs() : Initializes a list of TVP5146/47 registers
 321  * @sd: ptr to v4l2_subdev struct
 322  * @reglist: list of TVP5146/47 registers and values
 323  *
 324  * Initializes a list of TVP5146/47 registers:-
 325  *              if token is TOK_TERM, then entire write operation terminates
 326  *              if token is TOK_DELAY, then a delay of 'val' msec is introduced
 327  *              if token is TOK_SKIP, then the register write is skipped
 328  *              if token is TOK_WRITE, then the register write is performed
 329  * Returns zero if successful, or non-zero otherwise.
 330  */
 331 static int tvp514x_write_regs(struct v4l2_subdev *sd,
 332                               const struct tvp514x_reg reglist[])
 333 {
 334         int err;
 335         const struct tvp514x_reg *next = reglist;
 336
 337         for (; next->token != TOK_TERM; next++) {
 338                 if (next->token == TOK_DELAY) {
 339                         msleep(next->val);
 340                         continue;
 341                 }
 342
 343                 if (next->token == TOK_SKIP)
 344                         continue;
 345
 346                 err = tvp514x_write_reg(sd, next->reg, (u8) next->val);
 347                 if (err) {
 348                         v4l2_err(sd, "Write failed. Err[%d]\n", err);
 349                         return err;
 350                 }
 351         }
 352         return 0;
 353 }
 354
 355 /**
 356  * tvp514x_query_current_std() : Query the current standard detected by TVP5146/47
 357  * @sd: ptr to v4l2_subdev struct
 358  *
 359  * Returns the current standard detected by TVP5146/47, STD_INVALID if there is no
 360  * standard detected.
 361  */
 362 static enum tvp514x_std tvp514x_query_current_std(struct v4l2_subdev *sd)
 363 {
 364         u8 std, std_status;
 365
 366         std = tvp514x_read_reg(sd, REG_VIDEO_STD);
 367         if ((std & VIDEO_STD_MASK) == VIDEO_STD_AUTO_SWITCH_BIT)
 368                 /* use the standard status register */
 369                 std_status = tvp514x_read_reg(sd, REG_VIDEO_STD_STATUS);
 370         else
 371                 /* use the standard register itself */
 372                 std_status = std;
 373
 374         switch (std_status & VIDEO_STD_MASK) {
 375         case VIDEO_STD_NTSC_MJ_BIT:
 376                 return STD_NTSC_MJ;
 377
 378         case VIDEO_STD_PAL_BDGHIN_BIT:
 379                 return STD_PAL_BDGHIN;
 380
 381         default:
 382                 return STD_INVALID;
 383         }
 384
 385         return STD_INVALID;
 386 }
 387
 388 /* TVP5146/47 register dump function */
 389 static void tvp514x_reg_dump(struct v4l2_subdev *sd)
 390 {
 391         dump_reg(sd, REG_INPUT_SEL);
 392         dump_reg(sd, REG_AFE_GAIN_CTRL);
 393         dump_reg(sd, REG_VIDEO_STD);
 394         dump_reg(sd, REG_OPERATION_MODE);
 395         dump_reg(sd, REG_COLOR_KILLER);
 396         dump_reg(sd, REG_LUMA_CONTROL1);
 397         dump_reg(sd, REG_LUMA_CONTROL2);
 398         dump_reg(sd, REG_LUMA_CONTROL3);
 399         dump_reg(sd, REG_BRIGHTNESS);
 400         dump_reg(sd, REG_CONTRAST);
 401         dump_reg(sd, REG_SATURATION);
 402         dump_reg(sd, REG_HUE);
 403         dump_reg(sd, REG_CHROMA_CONTROL1);
 404         dump_reg(sd, REG_CHROMA_CONTROL2);
 405         dump_reg(sd, REG_COMP_PR_SATURATION);
 406         dump_reg(sd, REG_COMP_Y_CONTRAST);
 407         dump_reg(sd, REG_COMP_PB_SATURATION);
 408         dump_reg(sd, REG_COMP_Y_BRIGHTNESS);
 409         dump_reg(sd, REG_AVID_START_PIXEL_LSB);
 410         dump_reg(sd, REG_AVID_START_PIXEL_MSB);
 411         dump_reg(sd, REG_AVID_STOP_PIXEL_LSB);
 412         dump_reg(sd, REG_AVID_STOP_PIXEL_MSB);
 413         dump_reg(sd, REG_HSYNC_START_PIXEL_LSB);
 414         dump_reg(sd, REG_HSYNC_START_PIXEL_MSB);
 415         dump_reg(sd, REG_HSYNC_STOP_PIXEL_LSB);
 416         dump_reg(sd, REG_HSYNC_STOP_PIXEL_MSB);
 417         dump_reg(sd, REG_VSYNC_START_LINE_LSB);
 418         dump_reg(sd, REG_VSYNC_START_LINE_MSB);
 419         dump_reg(sd, REG_VSYNC_STOP_LINE_LSB);
 420         dump_reg(sd, REG_VSYNC_STOP_LINE_MSB);
 421         dump_reg(sd, REG_VBLK_START_LINE_LSB);
 422         dump_reg(sd, REG_VBLK_START_LINE_MSB);
 423         dump_reg(sd, REG_VBLK_STOP_LINE_LSB);
 424         dump_reg(sd, REG_VBLK_STOP_LINE_MSB);
 425         dump_reg(sd, REG_SYNC_CONTROL);
 426         dump_reg(sd, REG_OUTPUT_FORMATTER1);
 427         dump_reg(sd, REG_OUTPUT_FORMATTER2);
 428         dump_reg(sd, REG_OUTPUT_FORMATTER3);
 429         dump_reg(sd, REG_OUTPUT_FORMATTER4);
 430         dump_reg(sd, REG_OUTPUT_FORMATTER5);
 431         dump_reg(sd, REG_OUTPUT_FORMATTER6);
 432         dump_reg(sd, REG_CLEAR_LOST_LOCK);
 433 }
 434
 435 /**
 436  * tvp514x_configure() - Configure the TVP5146/47 registers
 437  * @sd: ptr to v4l2_subdev struct
 438  * @decoder: ptr to tvp514x_decoder structure
 439  *
 440  * Returns zero if successful, or non-zero otherwise.
 441  */
 442 static int tvp514x_configure(struct v4l2_subdev *sd,
 443                 struct tvp514x_decoder *decoder)
 444 {
 445         int err;
 446
 447         /* common register initialization */
 448         err =
 449             tvp514x_write_regs(sd, decoder->tvp514x_regs);
 450         if (err)
 451                 return err;
 452
 453         if (debug)
 454                 tvp514x_reg_dump(sd);
 455
 456         return 0;
 457 }
 458
 459 /**
 460  * tvp514x_detect() - Detect if an tvp514x is present, and if so which revision.
 461  * @sd: pointer to standard V4L2 sub-device structure
 462  * @decoder: pointer to tvp514x_decoder structure
 463  *
 464  * A device is considered to be detected if the chip ID (LSB and MSB)
 465  * registers match the expected values.
 466  * Any value of the rom version register is accepted.
 467  * Returns ENODEV error number if no device is detected, or zero
 468  * if a device is detected.
 469  */
 470 static int tvp514x_detect(struct v4l2_subdev *sd,
 471                 struct tvp514x_decoder *decoder)
 472 {
 473         u8 chip_id_msb, chip_id_lsb, rom_ver;
 474         struct i2c_client *client = v4l2_get_subdevdata(sd);
 475
 476         chip_id_msb = tvp514x_read_reg(sd, REG_CHIP_ID_MSB);
 477         chip_id_lsb = tvp514x_read_reg(sd, REG_CHIP_ID_LSB);
 478         rom_ver = tvp514x_read_reg(sd, REG_ROM_VERSION);
 479
 480         v4l2_dbg(1, debug, sd,
 481                  "chip id detected msb:0x%x lsb:0x%x rom version:0x%x\n",
 482                  chip_id_msb, chip_id_lsb, rom_ver);
 483         if ((chip_id_msb != TVP514X_CHIP_ID_MSB)
 484                 || ((chip_id_lsb != TVP5146_CHIP_ID_LSB)
 485                 && (chip_id_lsb != TVP5147_CHIP_ID_LSB))) {
 486                 /* We didn't read the values we expected, so this must not be
 487                  * an TVP5146/47.
 488                  */
 489                 v4l2_err(sd, "chip id mismatch msb:0x%x lsb:0x%x\n",
 490                                 chip_id_msb, chip_id_lsb);
 491                 return -ENODEV;
 492         }
 493
 494         decoder->ver = rom_ver;
 495
 496         v4l2_info(sd, "%s (Version - 0x%.2x) found at 0x%x (%s)\n",
 497                         client->name, decoder->ver,
 498                         client->addr << 1, client->adapter->name);
 499         return 0;
 500 }
 501
 502 /**
 503  * tvp514x_querystd() - V4L2 decoder interface handler for querystd
 504  * @sd: pointer to standard V4L2 sub-device structure
 505  * @std_id: standard V4L2 std_id ioctl enum
 506  *
 507  * Returns the current standard detected by TVP5146/47. If no active input is
 508  * detected then *std_id is set to 0 and the function returns 0.
 509  */
 510 static int tvp514x_querystd(struct v4l2_subdev *sd, v4l2_std_id *std_id)
 511 {
 512         struct tvp514x_decoder *decoder = to_decoder(sd);
 513         enum tvp514x_std current_std;
 514         enum tvp514x_input input_sel;
 515         u8 sync_lock_status, lock_mask;
 516
 517         if (std_id == NULL)
 518                 return -EINVAL;
 519
 520         *std_id = V4L2_STD_UNKNOWN;
 521
 522         /* query the current standard */
 523         current_std = tvp514x_query_current_std(sd);
 524         if (current_std == STD_INVALID)
 525                 return 0;
 526
 527         input_sel = decoder->input;
 528
 529         switch (input_sel) {
 530         case INPUT_CVBS_VI1A:
 531         case INPUT_CVBS_VI1B:
 532         case INPUT_CVBS_VI1C:
 533         case INPUT_CVBS_VI2A:
 534         case INPUT_CVBS_VI2B:
 535         case INPUT_CVBS_VI2C:
 536         case INPUT_CVBS_VI3A:
 537         case INPUT_CVBS_VI3B:
 538         case INPUT_CVBS_VI3C:
 539         case INPUT_CVBS_VI4A:
 540                 lock_mask = STATUS_CLR_SUBCAR_LOCK_BIT |
 541                         STATUS_HORZ_SYNC_LOCK_BIT |
 542                         STATUS_VIRT_SYNC_LOCK_BIT;
 543                 break;
 544
 545         case INPUT_SVIDEO_VI2A_VI1A:
 546         case INPUT_SVIDEO_VI2B_VI1B:
 547         case INPUT_SVIDEO_VI2C_VI1C:
 548         case INPUT_SVIDEO_VI2A_VI3A:
 549         case INPUT_SVIDEO_VI2B_VI3B:
 550         case INPUT_SVIDEO_VI2C_VI3C:
 551         case INPUT_SVIDEO_VI4A_VI1A:
 552         case INPUT_SVIDEO_VI4A_VI1B:
 553         case INPUT_SVIDEO_VI4A_VI1C:
 554         case INPUT_SVIDEO_VI4A_VI3A:
 555         case INPUT_SVIDEO_VI4A_VI3B:
 556         case INPUT_SVIDEO_VI4A_VI3C:
 557                 lock_mask = STATUS_HORZ_SYNC_LOCK_BIT |
 558                         STATUS_VIRT_SYNC_LOCK_BIT;
 559                 break;
 560                 /*Need to add other interfaces*/
 561         default:
 562                 return -EINVAL;
 563         }
 564         /* check whether signal is locked */
 565         sync_lock_status = tvp514x_read_reg(sd, REG_STATUS1);
 566         if (lock_mask != (sync_lock_status & lock_mask))
 567                 return 0;       /* No input detected */
 568
 569         *std_id = decoder->std_list[current_std].standard.id;
 570
 571         v4l2_dbg(1, debug, sd, "Current STD: %s\n",
 572                         decoder->std_list[current_std].standard.name);
 573         return 0;
 574 }
 575
 576 /**
 577  * tvp514x_s_std() - V4L2 decoder interface handler for s_std
 578  * @sd: pointer to standard V4L2 sub-device structure
 579  * @std_id: standard V4L2 v4l2_std_id ioctl enum
 580  *
 581  * If std_id is supported, sets the requested standard. Otherwise, returns
 582  * -EINVAL
 583  */
 584 static int tvp514x_s_std(struct v4l2_subdev *sd, v4l2_std_id std_id)
 585 {
 586         struct tvp514x_decoder *decoder = to_decoder(sd);
 587         int err, i;
 588
 589         for (i = 0; i < decoder->num_stds; i++)
 590                 if (std_id & decoder->std_list[i].standard.id)
 591                         break;
 592
 593         if ((i == decoder->num_stds) || (i == STD_INVALID))
 594                 return -EINVAL;
 595
 596         err = tvp514x_write_reg(sd, REG_VIDEO_STD,
 597                                 decoder->std_list[i].video_std);
 598         if (err)
 599                 return err;
 600
 601         decoder->current_std = i;
 602         decoder->tvp514x_regs[REG_VIDEO_STD].val =
 603                 decoder->std_list[i].video_std;
 604
 605         v4l2_dbg(1, debug, sd, "Standard set to: %s\n",
 606                         decoder->std_list[i].standard.name);
 607         return 0;
 608 }
 609
 610 /**
 611  * tvp514x_s_routing() - V4L2 decoder interface handler for s_routing
 612  * @sd: pointer to standard V4L2 sub-device structure
 613  * @input: input selector for routing the signal
 614  * @output: output selector for routing the signal
 615  * @config: config value. Not used
 616  *
 617  * If index is valid, selects the requested input. Otherwise, returns -EINVAL if
 618  * the input is not supported or there is no active signal present in the
 619  * selected input.
 620  */
 621 static int tvp514x_s_routing(struct v4l2_subdev *sd,
 622                                 u32 input, u32 output, u32 config)
 623 {
 624         struct tvp514x_decoder *decoder = to_decoder(sd);
 625         int err;
 626         enum tvp514x_input input_sel;
 627         enum tvp514x_output output_sel;
 628         u8 sync_lock_status, lock_mask;
 629         int try_count = LOCK_RETRY_COUNT;
 630
 631         if ((input >= INPUT_INVALID) ||
 632                         (output >= OUTPUT_INVALID))
 633                 /* Index out of bound */
 634                 return -EINVAL;
 635
 636         /*
 637          * For the sequence streamon -> streamoff and again s_input
 638          * it fails to lock the signal, since streamoff puts TVP514x
 639          * into power off state which leads to failure in sub-sequent s_input.
 640          *
 641          * So power up the TVP514x device here, since it is important to lock
 642          * the signal at this stage.
 643          */
 644         if (!decoder->streaming)
 645                 tvp514x_s_stream(sd, 1);
 646
 647         input_sel = input;
 648         output_sel = output;
 649
 650         err = tvp514x_write_reg(sd, REG_INPUT_SEL, input_sel);
 651         if (err)
 652                 return err;
 653
 654         output_sel |= tvp514x_read_reg(sd,
 655                         REG_OUTPUT_FORMATTER1) & 0x7;
 656         err = tvp514x_write_reg(sd, REG_OUTPUT_FORMATTER1,
 657                         output_sel);
 658         if (err)
 659                 return err;
 660
 661         decoder->tvp514x_regs[REG_INPUT_SEL].val = input_sel;
 662         decoder->tvp514x_regs[REG_OUTPUT_FORMATTER1].val = output_sel;
 663
 664         /* Clear status */
 665         msleep(LOCK_RETRY_DELAY);
 666         err =
 667             tvp514x_write_reg(sd, REG_CLEAR_LOST_LOCK, 0x01);
 668         if (err)
 669                 return err;
 670
 671         switch (input_sel) {
 672         case INPUT_CVBS_VI1A:
 673         case INPUT_CVBS_VI1B:
 674         case INPUT_CVBS_VI1C:
 675         case INPUT_CVBS_VI2A:
 676         case INPUT_CVBS_VI2B:
 677         case INPUT_CVBS_VI2C:
 678         case INPUT_CVBS_VI3A:
 679         case INPUT_CVBS_VI3B:
 680         case INPUT_CVBS_VI3C:
 681         case INPUT_CVBS_VI4A:
 682                 lock_mask = STATUS_CLR_SUBCAR_LOCK_BIT |
 683                         STATUS_HORZ_SYNC_LOCK_BIT |
 684                         STATUS_VIRT_SYNC_LOCK_BIT;
 685                 break;
 686
 687         case INPUT_SVIDEO_VI2A_VI1A:
 688         case INPUT_SVIDEO_VI2B_VI1B:
 689         case INPUT_SVIDEO_VI2C_VI1C:
 690         case INPUT_SVIDEO_VI2A_VI3A:
 691         case INPUT_SVIDEO_VI2B_VI3B:
 692         case INPUT_SVIDEO_VI2C_VI3C:
 693         case INPUT_SVIDEO_VI4A_VI1A:
 694         case INPUT_SVIDEO_VI4A_VI1B:
 695         case INPUT_SVIDEO_VI4A_VI1C:
 696         case INPUT_SVIDEO_VI4A_VI3A:
 697         case INPUT_SVIDEO_VI4A_VI3B:
 698         case INPUT_SVIDEO_VI4A_VI3C:
 699                 lock_mask = STATUS_HORZ_SYNC_LOCK_BIT |
 700                         STATUS_VIRT_SYNC_LOCK_BIT;
 701                 break;
 702         /* Need to add other interfaces*/
 703         default:
 704                 return -EINVAL;
 705         }
 706
 707         while (try_count-- > 0) {
 708                 /* Allow decoder to sync up with new input */
 709                 msleep(LOCK_RETRY_DELAY);
 710
 711                 sync_lock_status = tvp514x_read_reg(sd,
 712                                 REG_STATUS1);
 713                 if (lock_mask == (sync_lock_status & lock_mask))
 714                         /* Input detected */
 715                         break;
 716         }
 717
 718         if (try_count < 0)
 719                 return -EINVAL;
 720
 721         decoder->input = input;
 722         decoder->output = output;
 723
 724         v4l2_dbg(1, debug, sd, "Input set to: %d\n", input_sel);
 725
 726         return 0;
 727 }
 728
 729 /**
 730  * tvp514x_s_ctrl() - V4L2 decoder interface handler for s_ctrl
 731  * @ctrl: pointer to v4l2_ctrl structure
 732  *
 733  * If the requested control is supported, sets the control's current
 734  * value in HW. Otherwise, returns -EINVAL if the control is not supported.
 735  */
 736 static int tvp514x_s_ctrl(struct v4l2_ctrl *ctrl)
 737 {
 738         struct v4l2_subdev *sd = to_sd(ctrl);
 739         struct tvp514x_decoder *decoder = to_decoder(sd);
 740         int err = -EINVAL, value;
 741
 742         value = ctrl->val;
 743
 744         switch (ctrl->id) {
 745         case V4L2_CID_BRIGHTNESS:
 746                 err = tvp514x_write_reg(sd, REG_BRIGHTNESS, value);
 747                 if (!err)
 748                         decoder->tvp514x_regs[REG_BRIGHTNESS].val = value;
 749                 break;
 750         case V4L2_CID_CONTRAST:
 751                 err = tvp514x_write_reg(sd, REG_CONTRAST, value);
 752                 if (!err)
 753                         decoder->tvp514x_regs[REG_CONTRAST].val = value;
 754                 break;
 755         case V4L2_CID_SATURATION:
 756                 err = tvp514x_write_reg(sd, REG_SATURATION, value);
 757                 if (!err)
 758                         decoder->tvp514x_regs[REG_SATURATION].val = value;
 759                 break;
 760         case V4L2_CID_HUE:
 761                 if (value == 180)
 762                         value = 0x7F;
 763                 else if (value == -180)
 764                         value = 0x80;
 765                 err = tvp514x_write_reg(sd, REG_HUE, value);
 766                 if (!err)
 767                         decoder->tvp514x_regs[REG_HUE].val = value;
 768                 break;
 769         case V4L2_CID_AUTOGAIN:
 770                 err = tvp514x_write_reg(sd, REG_AFE_GAIN_CTRL, value ? 0x0f : 0x0c);
 771                 if (!err)
 772                         decoder->tvp514x_regs[REG_AFE_GAIN_CTRL].val = value;
 773                 break;
 774         }
 775
 776         v4l2_dbg(1, debug, sd, "Set Control: ID - %d - %d\n",
 777                         ctrl->id, ctrl->val);
 778         return err;
 779 }
 780
 781 /**
 782  * tvp514x_enum_mbus_fmt() - V4L2 decoder interface handler for enum_mbus_fmt
 783  * @sd: pointer to standard V4L2 sub-device structure
 784  * @index: index of pixelcode to retrieve
 785  * @code: receives the pixelcode
 786  *
 787  * Enumerates supported mediabus formats
 788  */
 789 static int
 790 tvp514x_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index,
 791                                         enum v4l2_mbus_pixelcode *code)
 792 {
 793         if (index)
 794                 return -EINVAL;
 795
 796         *code = V4L2_MBUS_FMT_YUYV10_2X10;
 797         return 0;
 798 }
 799
 800 /**
 801  * tvp514x_mbus_fmt_cap() - V4L2 decoder interface handler for try/s/g_mbus_fmt
 802  * @sd: pointer to standard V4L2 sub-device structure
 803  * @f: pointer to the mediabus format structure
 804  *
 805  * Negotiates the image capture size and mediabus format.
 806  */
 807 static int
 808 tvp514x_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *f)
 809 {
 810         struct tvp514x_decoder *decoder = to_decoder(sd);
 811         enum tvp514x_std current_std;
 812
 813         if (f == NULL)
 814                 return -EINVAL;
 815
 816         /* Calculate height and width based on current standard */
 817         current_std = decoder->current_std;
 818
 819         f->code = V4L2_MBUS_FMT_YUYV10_2X10;
 820         f->width = decoder->std_list[current_std].width;
 821         f->height = decoder->std_list[current_std].height;
 822         f->field = V4L2_FIELD_INTERLACED;
 823         f->colorspace = V4L2_COLORSPACE_SMPTE170M;
 824
 825         v4l2_dbg(1, debug, sd, "MBUS_FMT: Width - %d, Height - %d\n",
 826                         f->width, f->height);
 827         return 0;
 828 }
 829
 830 /**
 831  * tvp514x_g_parm() - V4L2 decoder interface handler for g_parm
 832  * @sd: pointer to standard V4L2 sub-device structure
 833  * @a: pointer to standard V4L2 VIDIOC_G_PARM ioctl structure
 834  *
 835  * Returns the decoder's video CAPTURE parameters.
 836  */
 837 static int
 838 tvp514x_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
 839 {
 840         struct tvp514x_decoder *decoder = to_decoder(sd);
 841         struct v4l2_captureparm *cparm;
 842         enum tvp514x_std current_std;
 843
 844         if (a == NULL)
 845                 return -EINVAL;
 846
 847         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 848                 /* only capture is supported */
 849                 return -EINVAL;
 850
 851         /* get the current standard */
 852         current_std = decoder->current_std;
 853
 854         cparm = &a->parm.capture;
 855         cparm->capability = V4L2_CAP_TIMEPERFRAME;
 856         cparm->timeperframe =
 857                 decoder->std_list[current_std].standard.frameperiod;
 858
 859         return 0;
 860 }
 861
 862 /**
 863  * tvp514x_s_parm() - V4L2 decoder interface handler for s_parm
 864  * @sd: pointer to standard V4L2 sub-device structure
 865  * @a: pointer to standard V4L2 VIDIOC_S_PARM ioctl structure
 866  *
 867  * Configures the decoder to use the input parameters, if possible. If
 868  * not possible, returns the appropriate error code.
 869  */
 870 static int
 871 tvp514x_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
 872 {
 873         struct tvp514x_decoder *decoder = to_decoder(sd);
 874         struct v4l2_fract *timeperframe;
 875         enum tvp514x_std current_std;
 876
 877         if (a == NULL)
 878                 return -EINVAL;
 879
 880         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 881                 /* only capture is supported */
 882                 return -EINVAL;
 883
 884         timeperframe = &a->parm.capture.timeperframe;
 885
 886         /* get the current standard */
 887         current_std = decoder->current_std;
 888
 889         *timeperframe =
 890             decoder->std_list[current_std].standard.frameperiod;
 891
 892         return 0;
 893 }
 894
 895 /**
 896  * tvp514x_s_stream() - V4L2 decoder i/f handler for s_stream
 897  * @sd: pointer to standard V4L2 sub-device structure
 898  * @enable: streaming enable or disable
 899  *
 900  * Sets streaming to enable or disable, if possible.
 901  */
 902 static int tvp514x_s_stream(struct v4l2_subdev *sd, int enable)
 903 {
 904         int err = 0;
 905         struct i2c_client *client = v4l2_get_subdevdata(sd);
 906         struct tvp514x_decoder *decoder = to_decoder(sd);
 907
 908         if (decoder->streaming == enable)
 909                 return 0;
 910
 911         switch (enable) {
 912         case 0:
 913         {
 914                 /* Power Down Sequence */
 915                 err = tvp514x_write_reg(sd, REG_OPERATION_MODE, 0x01);
 916                 if (err) {
 917                         v4l2_err(sd, "Unable to turn off decoder\n");
 918                         return err;
 919                 }
 920                 decoder->streaming = enable;
 921                 break;
 922         }
 923         case 1:
 924         {
 925                 struct tvp514x_reg *int_seq = (struct tvp514x_reg *)
 926                                 client->driver->id_table->driver_data;
 927
 928                 /* Power Up Sequence */
 929                 err = tvp514x_write_regs(sd, int_seq);
 930                 if (err) {
 931                         v4l2_err(sd, "Unable to turn on decoder\n");
 932                         return err;
 933                 }
 934                 /* Detect if not already detected */
 935                 err = tvp514x_detect(sd, decoder);
 936                 if (err) {
 937                         v4l2_err(sd, "Unable to detect decoder\n");
 938                         return err;
 939                 }
 940                 err = tvp514x_configure(sd, decoder);
 941                 if (err) {
 942                         v4l2_err(sd, "Unable to configure decoder\n");
 943                         return err;
 944                 }
 945                 decoder->streaming = enable;
 946                 break;
 947         }
 948         default:
 949                 err = -ENODEV;
 950                 break;
 951         }
 952
 953         return err;
 954 }
 955
 956 static const struct v4l2_ctrl_ops tvp514x_ctrl_ops = {
 957         .s_ctrl = tvp514x_s_ctrl,
 958 };
 959
 960 static const struct v4l2_subdev_core_ops tvp514x_core_ops = {
 961         .g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
 962         .try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
 963         .s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
 964         .g_ctrl = v4l2_subdev_g_ctrl,
 965         .s_ctrl = v4l2_subdev_s_ctrl,
 966         .queryctrl = v4l2_subdev_queryctrl,
 967         .querymenu = v4l2_subdev_querymenu,
 968         .s_std = tvp514x_s_std,
 969 };
 970
 971 static const struct v4l2_subdev_video_ops tvp514x_video_ops = {
 972         .s_routing = tvp514x_s_routing,
 973         .querystd = tvp514x_querystd,
 974         .enum_mbus_fmt = tvp514x_enum_mbus_fmt,
 975         .g_mbus_fmt = tvp514x_mbus_fmt,
 976         .try_mbus_fmt = tvp514x_mbus_fmt,
 977         .s_mbus_fmt = tvp514x_mbus_fmt,
 978         .g_parm = tvp514x_g_parm,
 979         .s_parm = tvp514x_s_parm,
 980         .s_stream = tvp514x_s_stream,
 981 };
 982
 983 static const struct v4l2_subdev_ops tvp514x_ops = {
 984         .core = &tvp514x_core_ops,
 985         .video = &tvp514x_video_ops,
 986 };
 987
 988 static struct tvp514x_decoder tvp514x_dev = {
 989         .streaming = 0,
 990         .current_std = STD_NTSC_MJ,
 991         .std_list = tvp514x_std_list,
 992         .num_stds = ARRAY_SIZE(tvp514x_std_list),
 993
 994 };
 995
 996 /**
 997  * tvp514x_probe() - decoder driver i2c probe handler
 998  * @client: i2c driver client device structure
 999  * @id: i2c driver id table
1000  *
1001  * Register decoder as an i2c client device and V4L2
1002  * device.
1003  */
1004 static int
1005 tvp514x_probe(struct i2c_client *client, const struct i2c_device_id *id)
1006 {
1007         struct tvp514x_decoder *decoder;
1008         struct v4l2_subdev *sd;
1009
1010         /* Check if the adapter supports the needed features */
1011         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1012                 return -EIO;
1013
1014         if (!client->dev.platform_data) {
1015                 v4l2_err(client, "No platform data!!\n");
1016                 return -ENODEV;
1017         }
1018
1019         decoder = kzalloc(sizeof(*decoder), GFP_KERNEL);
1020         if (!decoder)
1021                 return -ENOMEM;
1022
1023         /* Initialize the tvp514x_decoder with default configuration */
1024         *decoder = tvp514x_dev;
1025         /* Copy default register configuration */
1026         memcpy(decoder->tvp514x_regs, tvp514x_reg_list_default,
1027                         sizeof(tvp514x_reg_list_default));
1028
1029         /* Copy board specific information here */
1030         decoder->pdata = client->dev.platform_data;
1031
1032         /**
1033          * Fetch platform specific data, and configure the
1034          * tvp514x_reg_list[] accordingly. Since this is one
1035          * time configuration, no need to preserve.
1036          */
1037         decoder->tvp514x_regs[REG_OUTPUT_FORMATTER2].val |=
1038                 (decoder->pdata->clk_polarity << 1);
1039         decoder->tvp514x_regs[REG_SYNC_CONTROL].val |=
1040                 ((decoder->pdata->hs_polarity << 2) |
1041                  (decoder->pdata->vs_polarity << 3));
1042         /* Set default standard to auto */
1043         decoder->tvp514x_regs[REG_VIDEO_STD].val =
1044                 VIDEO_STD_AUTO_SWITCH_BIT;
1045
1046         /* Register with V4L2 layer as slave device */
1047         sd = &decoder->sd;
1048         v4l2_i2c_subdev_init(sd, client, &tvp514x_ops);
1049
1050         v4l2_ctrl_handler_init(&decoder->hdl, 5);
1051         v4l2_ctrl_new_std(&decoder->hdl, &tvp514x_ctrl_ops,
1052                 V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
1053         v4l2_ctrl_new_std(&decoder->hdl, &tvp514x_ctrl_ops,
1054                 V4L2_CID_CONTRAST, 0, 255, 1, 128);
1055         v4l2_ctrl_new_std(&decoder->hdl, &tvp514x_ctrl_ops,
1056                 V4L2_CID_SATURATION, 0, 255, 1, 128);
1057         v4l2_ctrl_new_std(&decoder->hdl, &tvp514x_ctrl_ops,
1058                 V4L2_CID_HUE, -180, 180, 180, 0);
1059         v4l2_ctrl_new_std(&decoder->hdl, &tvp514x_ctrl_ops,
1060                 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1061         sd->ctrl_handler = &decoder->hdl;
1062         if (decoder->hdl.error) {
1063                 int err = decoder->hdl.error;
1064
1065                 v4l2_ctrl_handler_free(&decoder->hdl);
1066                 kfree(decoder);
1067                 return err;
1068         }
1069         v4l2_ctrl_handler_setup(&decoder->hdl);
1070
1071         v4l2_info(sd, "%s decoder driver registered !!\n", sd->name);
1072
1073         return 0;
1074
1075 }
1076
1077 /**
1078  * tvp514x_remove() - decoder driver i2c remove handler
1079  * @client: i2c driver client device structure
1080  *
1081  * Unregister decoder as an i2c client device and V4L2
1082  * device. Complement of tvp514x_probe().
1083  */
1084 static int tvp514x_remove(struct i2c_client *client)
1085 {
1086         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1087         struct tvp514x_decoder *decoder = to_decoder(sd);
1088
1089         v4l2_device_unregister_subdev(sd);
1090         v4l2_ctrl_handler_free(&decoder->hdl);
1091         kfree(decoder);
1092         return 0;
1093 }
1094 /* TVP5146 Init/Power on Sequence */
1095 static const struct tvp514x_reg tvp5146_init_reg_seq[] = {
1096         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x02},
1097         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1098         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0x80},
1099         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1100         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1101         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1102         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1103         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1104         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
1105         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1106         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1107         {TOK_TERM, 0, 0},
1108 };
1109
1110 /* TVP5147 Init/Power on Sequence */
1111 static const struct tvp514x_reg tvp5147_init_reg_seq[] =        {
1112         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x02},
1113         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1114         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0x80},
1115         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1116         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1117         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1118         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1119         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1120         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x16},
1121         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1122         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xA0},
1123         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x16},
1124         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1125         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1126         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1127         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
1128         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1129         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1130         {TOK_TERM, 0, 0},
1131 };
1132
1133 /* TVP5146M2/TVP5147M1 Init/Power on Sequence */
1134 static const struct tvp514x_reg tvp514xm_init_reg_seq[] = {
1135         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1136         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1137         {TOK_TERM, 0, 0},
1138 };
1139
1140 /**
1141  * I2C Device Table -
1142  *
1143  * name - Name of the actual device/chip.
1144  * driver_data - Driver data
1145  */
1146 static const struct i2c_device_id tvp514x_id[] = {
1147         {"tvp5146", (unsigned long)tvp5146_init_reg_seq},
1148         {"tvp5146m2", (unsigned long)tvp514xm_init_reg_seq},
1149         {"tvp5147", (unsigned long)tvp5147_init_reg_seq},
1150         {"tvp5147m1", (unsigned long)tvp514xm_init_reg_seq},
1151         {},
1152 };
1153
1154 MODULE_DEVICE_TABLE(i2c, tvp514x_id);
1155
1156 static struct i2c_driver tvp514x_driver = {
1157         .driver = {
1158                 .owner = THIS_MODULE,
1159                 .name = TVP514X_MODULE_NAME,
1160         },
1161         .probe = tvp514x_probe,
1162         .remove = tvp514x_remove,
1163         .id_table = tvp514x_id,
1164 };
1165
1166 static int __init tvp514x_init(void)
1167 {
1168         return i2c_add_driver(&tvp514x_driver);
1169 }
1170
1171 static void __exit tvp514x_exit(void)
1172 {
1173         i2c_del_driver(&tvp514x_driver);
1174 }
1175
1176 module_init(tvp514x_init);
1177 module_exit(tvp514x_exit);