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