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