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