drivers/media/i2c/tvp514x.c

   1 /*
   2  * drivers/media/i2c/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         /* To query the standard the TVP514x must power on the ADCs. */
 523         if (!decoder->streaming) {
 524                 tvp514x_s_stream(sd, 1);
 525                 msleep(LOCK_RETRY_DELAY);
 526         }
 527
 528         /* query the current standard */
 529         current_std = tvp514x_query_current_std(sd);
 530         if (current_std == STD_INVALID)
 531                 return 0;
 532
 533         input_sel = decoder->input;
 534
 535         switch (input_sel) {
 536         case INPUT_CVBS_VI1A:
 537         case INPUT_CVBS_VI1B:
 538         case INPUT_CVBS_VI1C:
 539         case INPUT_CVBS_VI2A:
 540         case INPUT_CVBS_VI2B:
 541         case INPUT_CVBS_VI2C:
 542         case INPUT_CVBS_VI3A:
 543         case INPUT_CVBS_VI3B:
 544         case INPUT_CVBS_VI3C:
 545         case INPUT_CVBS_VI4A:
 546                 lock_mask = STATUS_CLR_SUBCAR_LOCK_BIT |
 547                         STATUS_HORZ_SYNC_LOCK_BIT |
 548                         STATUS_VIRT_SYNC_LOCK_BIT;
 549                 break;
 550
 551         case INPUT_SVIDEO_VI2A_VI1A:
 552         case INPUT_SVIDEO_VI2B_VI1B:
 553         case INPUT_SVIDEO_VI2C_VI1C:
 554         case INPUT_SVIDEO_VI2A_VI3A:
 555         case INPUT_SVIDEO_VI2B_VI3B:
 556         case INPUT_SVIDEO_VI2C_VI3C:
 557         case INPUT_SVIDEO_VI4A_VI1A:
 558         case INPUT_SVIDEO_VI4A_VI1B:
 559         case INPUT_SVIDEO_VI4A_VI1C:
 560         case INPUT_SVIDEO_VI4A_VI3A:
 561         case INPUT_SVIDEO_VI4A_VI3B:
 562         case INPUT_SVIDEO_VI4A_VI3C:
 563                 lock_mask = STATUS_HORZ_SYNC_LOCK_BIT |
 564                         STATUS_VIRT_SYNC_LOCK_BIT;
 565                 break;
 566                 /*Need to add other interfaces*/
 567         default:
 568                 return -EINVAL;
 569         }
 570         /* check whether signal is locked */
 571         sync_lock_status = tvp514x_read_reg(sd, REG_STATUS1);
 572         if (lock_mask != (sync_lock_status & lock_mask))
 573                 return 0;       /* No input detected */
 574
 575         *std_id = decoder->std_list[current_std].standard.id;
 576
 577         v4l2_dbg(1, debug, sd, "Current STD: %s\n",
 578                         decoder->std_list[current_std].standard.name);
 579         return 0;
 580 }
 581
 582 /**
 583  * tvp514x_s_std() - V4L2 decoder interface handler for s_std
 584  * @sd: pointer to standard V4L2 sub-device structure
 585  * @std_id: standard V4L2 v4l2_std_id ioctl enum
 586  *
 587  * If std_id is supported, sets the requested standard. Otherwise, returns
 588  * -EINVAL
 589  */
 590 static int tvp514x_s_std(struct v4l2_subdev *sd, v4l2_std_id std_id)
 591 {
 592         struct tvp514x_decoder *decoder = to_decoder(sd);
 593         int err, i;
 594
 595         for (i = 0; i < decoder->num_stds; i++)
 596                 if (std_id & decoder->std_list[i].standard.id)
 597                         break;
 598
 599         if ((i == decoder->num_stds) || (i == STD_INVALID))
 600                 return -EINVAL;
 601
 602         err = tvp514x_write_reg(sd, REG_VIDEO_STD,
 603                                 decoder->std_list[i].video_std);
 604         if (err)
 605                 return err;
 606
 607         decoder->current_std = i;
 608         decoder->tvp514x_regs[REG_VIDEO_STD].val =
 609                 decoder->std_list[i].video_std;
 610
 611         v4l2_dbg(1, debug, sd, "Standard set to: %s\n",
 612                         decoder->std_list[i].standard.name);
 613         return 0;
 614 }
 615
 616 /**
 617  * tvp514x_s_routing() - V4L2 decoder interface handler for s_routing
 618  * @sd: pointer to standard V4L2 sub-device structure
 619  * @input: input selector for routing the signal
 620  * @output: output selector for routing the signal
 621  * @config: config value. Not used
 622  *
 623  * If index is valid, selects the requested input. Otherwise, returns -EINVAL if
 624  * the input is not supported or there is no active signal present in the
 625  * selected input.
 626  */
 627 static int tvp514x_s_routing(struct v4l2_subdev *sd,
 628                                 u32 input, u32 output, u32 config)
 629 {
 630         struct tvp514x_decoder *decoder = to_decoder(sd);
 631         int err;
 632         enum tvp514x_input input_sel;
 633         enum tvp514x_output output_sel;
 634
 635         if ((input >= INPUT_INVALID) ||
 636                         (output >= OUTPUT_INVALID))
 637                 /* Index out of bound */
 638                 return -EINVAL;
 639
 640         input_sel = input;
 641         output_sel = output;
 642
 643         err = tvp514x_write_reg(sd, REG_INPUT_SEL, input_sel);
 644         if (err)
 645                 return err;
 646
 647         output_sel |= tvp514x_read_reg(sd,
 648                         REG_OUTPUT_FORMATTER1) & 0x7;
 649         err = tvp514x_write_reg(sd, REG_OUTPUT_FORMATTER1,
 650                         output_sel);
 651         if (err)
 652                 return err;
 653
 654         decoder->tvp514x_regs[REG_INPUT_SEL].val = input_sel;
 655         decoder->tvp514x_regs[REG_OUTPUT_FORMATTER1].val = output_sel;
 656         decoder->input = input;
 657         decoder->output = output;
 658
 659         v4l2_dbg(1, debug, sd, "Input set to: %d\n", input_sel);
 660
 661         return 0;
 662 }
 663
 664 /**
 665  * tvp514x_s_ctrl() - V4L2 decoder interface handler for s_ctrl
 666  * @ctrl: pointer to v4l2_ctrl structure
 667  *
 668  * If the requested control is supported, sets the control's current
 669  * value in HW. Otherwise, returns -EINVAL if the control is not supported.
 670  */
 671 static int tvp514x_s_ctrl(struct v4l2_ctrl *ctrl)
 672 {
 673         struct v4l2_subdev *sd = to_sd(ctrl);
 674         struct tvp514x_decoder *decoder = to_decoder(sd);
 675         int err = -EINVAL, value;
 676
 677         value = ctrl->val;
 678
 679         switch (ctrl->id) {
 680         case V4L2_CID_BRIGHTNESS:
 681                 err = tvp514x_write_reg(sd, REG_BRIGHTNESS, value);
 682                 if (!err)
 683                         decoder->tvp514x_regs[REG_BRIGHTNESS].val = value;
 684                 break;
 685         case V4L2_CID_CONTRAST:
 686                 err = tvp514x_write_reg(sd, REG_CONTRAST, value);
 687                 if (!err)
 688                         decoder->tvp514x_regs[REG_CONTRAST].val = value;
 689                 break;
 690         case V4L2_CID_SATURATION:
 691                 err = tvp514x_write_reg(sd, REG_SATURATION, value);
 692                 if (!err)
 693                         decoder->tvp514x_regs[REG_SATURATION].val = value;
 694                 break;
 695         case V4L2_CID_HUE:
 696                 if (value == 180)
 697                         value = 0x7F;
 698                 else if (value == -180)
 699                         value = 0x80;
 700                 err = tvp514x_write_reg(sd, REG_HUE, value);
 701                 if (!err)
 702                         decoder->tvp514x_regs[REG_HUE].val = value;
 703                 break;
 704         case V4L2_CID_AUTOGAIN:
 705                 err = tvp514x_write_reg(sd, REG_AFE_GAIN_CTRL, value ? 0x0f : 0x0c);
 706                 if (!err)
 707                         decoder->tvp514x_regs[REG_AFE_GAIN_CTRL].val = value;
 708                 break;
 709         }
 710
 711         v4l2_dbg(1, debug, sd, "Set Control: ID - %d - %d\n",
 712                         ctrl->id, ctrl->val);
 713         return err;
 714 }
 715
 716 /**
 717  * tvp514x_enum_mbus_fmt() - V4L2 decoder interface handler for enum_mbus_fmt
 718  * @sd: pointer to standard V4L2 sub-device structure
 719  * @index: index of pixelcode to retrieve
 720  * @code: receives the pixelcode
 721  *
 722  * Enumerates supported mediabus formats
 723  */
 724 static int
 725 tvp514x_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index,
 726                                         enum v4l2_mbus_pixelcode *code)
 727 {
 728         if (index)
 729                 return -EINVAL;
 730
 731         *code = V4L2_MBUS_FMT_YUYV10_2X10;
 732         return 0;
 733 }
 734
 735 /**
 736  * tvp514x_mbus_fmt_cap() - V4L2 decoder interface handler for try/s/g_mbus_fmt
 737  * @sd: pointer to standard V4L2 sub-device structure
 738  * @f: pointer to the mediabus format structure
 739  *
 740  * Negotiates the image capture size and mediabus format.
 741  */
 742 static int
 743 tvp514x_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *f)
 744 {
 745         struct tvp514x_decoder *decoder = to_decoder(sd);
 746         enum tvp514x_std current_std;
 747
 748         if (f == NULL)
 749                 return -EINVAL;
 750
 751         /* Calculate height and width based on current standard */
 752         current_std = decoder->current_std;
 753
 754         f->code = V4L2_MBUS_FMT_YUYV10_2X10;
 755         f->width = decoder->std_list[current_std].width;
 756         f->height = decoder->std_list[current_std].height;
 757         f->field = V4L2_FIELD_INTERLACED;
 758         f->colorspace = V4L2_COLORSPACE_SMPTE170M;
 759
 760         v4l2_dbg(1, debug, sd, "MBUS_FMT: Width - %d, Height - %d\n",
 761                         f->width, f->height);
 762         return 0;
 763 }
 764
 765 /**
 766  * tvp514x_g_parm() - V4L2 decoder interface handler for g_parm
 767  * @sd: pointer to standard V4L2 sub-device structure
 768  * @a: pointer to standard V4L2 VIDIOC_G_PARM ioctl structure
 769  *
 770  * Returns the decoder's video CAPTURE parameters.
 771  */
 772 static int
 773 tvp514x_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
 774 {
 775         struct tvp514x_decoder *decoder = to_decoder(sd);
 776         struct v4l2_captureparm *cparm;
 777         enum tvp514x_std current_std;
 778
 779         if (a == NULL)
 780                 return -EINVAL;
 781
 782         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 783                 /* only capture is supported */
 784                 return -EINVAL;
 785
 786         /* get the current standard */
 787         current_std = decoder->current_std;
 788
 789         cparm = &a->parm.capture;
 790         cparm->capability = V4L2_CAP_TIMEPERFRAME;
 791         cparm->timeperframe =
 792                 decoder->std_list[current_std].standard.frameperiod;
 793
 794         return 0;
 795 }
 796
 797 /**
 798  * tvp514x_s_parm() - V4L2 decoder interface handler for s_parm
 799  * @sd: pointer to standard V4L2 sub-device structure
 800  * @a: pointer to standard V4L2 VIDIOC_S_PARM ioctl structure
 801  *
 802  * Configures the decoder to use the input parameters, if possible. If
 803  * not possible, returns the appropriate error code.
 804  */
 805 static int
 806 tvp514x_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
 807 {
 808         struct tvp514x_decoder *decoder = to_decoder(sd);
 809         struct v4l2_fract *timeperframe;
 810         enum tvp514x_std current_std;
 811
 812         if (a == NULL)
 813                 return -EINVAL;
 814
 815         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 816                 /* only capture is supported */
 817                 return -EINVAL;
 818
 819         timeperframe = &a->parm.capture.timeperframe;
 820
 821         /* get the current standard */
 822         current_std = decoder->current_std;
 823
 824         *timeperframe =
 825             decoder->std_list[current_std].standard.frameperiod;
 826
 827         return 0;
 828 }
 829
 830 /**
 831  * tvp514x_s_stream() - V4L2 decoder i/f handler for s_stream
 832  * @sd: pointer to standard V4L2 sub-device structure
 833  * @enable: streaming enable or disable
 834  *
 835  * Sets streaming to enable or disable, if possible.
 836  */
 837 static int tvp514x_s_stream(struct v4l2_subdev *sd, int enable)
 838 {
 839         int err = 0;
 840         struct i2c_client *client = v4l2_get_subdevdata(sd);
 841         struct tvp514x_decoder *decoder = to_decoder(sd);
 842
 843         if (decoder->streaming == enable)
 844                 return 0;
 845
 846         switch (enable) {
 847         case 0:
 848         {
 849                 /* Power Down Sequence */
 850                 err = tvp514x_write_reg(sd, REG_OPERATION_MODE, 0x01);
 851                 if (err) {
 852                         v4l2_err(sd, "Unable to turn off decoder\n");
 853                         return err;
 854                 }
 855                 decoder->streaming = enable;
 856                 break;
 857         }
 858         case 1:
 859         {
 860                 struct tvp514x_reg *int_seq = (struct tvp514x_reg *)
 861                                 client->driver->id_table->driver_data;
 862
 863                 /* Power Up Sequence */
 864                 err = tvp514x_write_regs(sd, int_seq);
 865                 if (err) {
 866                         v4l2_err(sd, "Unable to turn on decoder\n");
 867                         return err;
 868                 }
 869                 /* Detect if not already detected */
 870                 err = tvp514x_detect(sd, decoder);
 871                 if (err) {
 872                         v4l2_err(sd, "Unable to detect decoder\n");
 873                         return err;
 874                 }
 875                 err = tvp514x_configure(sd, decoder);
 876                 if (err) {
 877                         v4l2_err(sd, "Unable to configure decoder\n");
 878                         return err;
 879                 }
 880                 decoder->streaming = enable;
 881                 break;
 882         }
 883         default:
 884                 err = -ENODEV;
 885                 break;
 886         }
 887
 888         return err;
 889 }
 890
 891 static const struct v4l2_ctrl_ops tvp514x_ctrl_ops = {
 892         .s_ctrl = tvp514x_s_ctrl,
 893 };
 894
 895 static const struct v4l2_subdev_core_ops tvp514x_core_ops = {
 896         .g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
 897         .try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
 898         .s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
 899         .g_ctrl = v4l2_subdev_g_ctrl,
 900         .s_ctrl = v4l2_subdev_s_ctrl,
 901         .queryctrl = v4l2_subdev_queryctrl,
 902         .querymenu = v4l2_subdev_querymenu,
 903         .s_std = tvp514x_s_std,
 904 };
 905
 906 static const struct v4l2_subdev_video_ops tvp514x_video_ops = {
 907         .s_routing = tvp514x_s_routing,
 908         .querystd = tvp514x_querystd,
 909         .enum_mbus_fmt = tvp514x_enum_mbus_fmt,
 910         .g_mbus_fmt = tvp514x_mbus_fmt,
 911         .try_mbus_fmt = tvp514x_mbus_fmt,
 912         .s_mbus_fmt = tvp514x_mbus_fmt,
 913         .g_parm = tvp514x_g_parm,
 914         .s_parm = tvp514x_s_parm,
 915         .s_stream = tvp514x_s_stream,
 916 };
 917
 918 static const struct v4l2_subdev_ops tvp514x_ops = {
 919         .core = &tvp514x_core_ops,
 920         .video = &tvp514x_video_ops,
 921 };
 922
 923 static struct tvp514x_decoder tvp514x_dev = {
 924         .streaming = 0,
 925         .current_std = STD_NTSC_MJ,
 926         .std_list = tvp514x_std_list,
 927         .num_stds = ARRAY_SIZE(tvp514x_std_list),
 928
 929 };
 930
 931 /**
 932  * tvp514x_probe() - decoder driver i2c probe handler
 933  * @client: i2c driver client device structure
 934  * @id: i2c driver id table
 935  *
 936  * Register decoder as an i2c client device and V4L2
 937  * device.
 938  */
 939 static int
 940 tvp514x_probe(struct i2c_client *client, const struct i2c_device_id *id)
 941 {
 942         struct tvp514x_decoder *decoder;
 943         struct v4l2_subdev *sd;
 944
 945         /* Check if the adapter supports the needed features */
 946         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 947                 return -EIO;
 948
 949         if (!client->dev.platform_data) {
 950                 v4l2_err(client, "No platform data!!\n");
 951                 return -ENODEV;
 952         }
 953
 954         decoder = kzalloc(sizeof(*decoder), GFP_KERNEL);
 955         if (!decoder)
 956                 return -ENOMEM;
 957
 958         /* Initialize the tvp514x_decoder with default configuration */
 959         *decoder = tvp514x_dev;
 960         /* Copy default register configuration */
 961         memcpy(decoder->tvp514x_regs, tvp514x_reg_list_default,
 962                         sizeof(tvp514x_reg_list_default));
 963
 964         /* Copy board specific information here */
 965         decoder->pdata = client->dev.platform_data;
 966
 967         /**
 968          * Fetch platform specific data, and configure the
 969          * tvp514x_reg_list[] accordingly. Since this is one
 970          * time configuration, no need to preserve.
 971          */
 972         decoder->tvp514x_regs[REG_OUTPUT_FORMATTER2].val |=
 973                 (decoder->pdata->clk_polarity << 1);
 974         decoder->tvp514x_regs[REG_SYNC_CONTROL].val |=
 975                 ((decoder->pdata->hs_polarity << 2) |
 976                  (decoder->pdata->vs_polarity << 3));
 977         /* Set default standard to auto */
 978         decoder->tvp514x_regs[REG_VIDEO_STD].val =
 979                 VIDEO_STD_AUTO_SWITCH_BIT;
 980
 981         /* Register with V4L2 layer as slave device */
 982         sd = &decoder->sd;
 983         v4l2_i2c_subdev_init(sd, client, &tvp514x_ops);
 984
 985         v4l2_ctrl_handler_init(&decoder->hdl, 5);
 986         v4l2_ctrl_new_std(&decoder->hdl, &tvp514x_ctrl_ops,
 987                 V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
 988         v4l2_ctrl_new_std(&decoder->hdl, &tvp514x_ctrl_ops,
 989                 V4L2_CID_CONTRAST, 0, 255, 1, 128);
 990         v4l2_ctrl_new_std(&decoder->hdl, &tvp514x_ctrl_ops,
 991                 V4L2_CID_SATURATION, 0, 255, 1, 128);
 992         v4l2_ctrl_new_std(&decoder->hdl, &tvp514x_ctrl_ops,
 993                 V4L2_CID_HUE, -180, 180, 180, 0);
 994         v4l2_ctrl_new_std(&decoder->hdl, &tvp514x_ctrl_ops,
 995                 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
 996         sd->ctrl_handler = &decoder->hdl;
 997         if (decoder->hdl.error) {
 998                 int err = decoder->hdl.error;
 999
1000                 v4l2_ctrl_handler_free(&decoder->hdl);
1001                 kfree(decoder);
1002                 return err;
1003         }
1004         v4l2_ctrl_handler_setup(&decoder->hdl);
1005
1006         v4l2_info(sd, "%s decoder driver registered !!\n", sd->name);
1007
1008         return 0;
1009
1010 }
1011
1012 /**
1013  * tvp514x_remove() - decoder driver i2c remove handler
1014  * @client: i2c driver client device structure
1015  *
1016  * Unregister decoder as an i2c client device and V4L2
1017  * device. Complement of tvp514x_probe().
1018  */
1019 static int tvp514x_remove(struct i2c_client *client)
1020 {
1021         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1022         struct tvp514x_decoder *decoder = to_decoder(sd);
1023
1024         v4l2_device_unregister_subdev(sd);
1025         v4l2_ctrl_handler_free(&decoder->hdl);
1026         kfree(decoder);
1027         return 0;
1028 }
1029 /* TVP5146 Init/Power on Sequence */
1030 static const struct tvp514x_reg tvp5146_init_reg_seq[] = {
1031         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x02},
1032         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1033         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0x80},
1034         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1035         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1036         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1037         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1038         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1039         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
1040         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1041         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1042         {TOK_TERM, 0, 0},
1043 };
1044
1045 /* TVP5147 Init/Power on Sequence */
1046 static const struct tvp514x_reg tvp5147_init_reg_seq[] =        {
1047         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x02},
1048         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1049         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0x80},
1050         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1051         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1052         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1053         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1054         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x01},
1055         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x16},
1056         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1057         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xA0},
1058         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x16},
1059         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x60},
1060         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
1061         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS3, 0xB0},
1062         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
1063         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1064         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1065         {TOK_TERM, 0, 0},
1066 };
1067
1068 /* TVP5146M2/TVP5147M1 Init/Power on Sequence */
1069 static const struct tvp514x_reg tvp514xm_init_reg_seq[] = {
1070         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1071         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1072         {TOK_TERM, 0, 0},
1073 };
1074
1075 /**
1076  * I2C Device Table -
1077  *
1078  * name - Name of the actual device/chip.
1079  * driver_data - Driver data
1080  */
1081 static const struct i2c_device_id tvp514x_id[] = {
1082         {"tvp5146", (unsigned long)tvp5146_init_reg_seq},
1083         {"tvp5146m2", (unsigned long)tvp514xm_init_reg_seq},
1084         {"tvp5147", (unsigned long)tvp5147_init_reg_seq},
1085         {"tvp5147m1", (unsigned long)tvp514xm_init_reg_seq},
1086         {},
1087 };
1088
1089 MODULE_DEVICE_TABLE(i2c, tvp514x_id);
1090
1091 static struct i2c_driver tvp514x_driver = {
1092         .driver = {
1093                 .owner = THIS_MODULE,
1094                 .name = TVP514X_MODULE_NAME,
1095         },
1096         .probe = tvp514x_probe,
1097         .remove = tvp514x_remove,
1098         .id_table = tvp514x_id,
1099 };
1100
1101 module_i2c_driver(tvp514x_driver);