1/* 2 * tvp5150 - Texas Instruments TVP5150A/AM1 video decoder driver 3 * 4 * Copyright (c) 2005,2006 Mauro Carvalho Chehab (mchehab@infradead.org) 5 * This code is placed under the terms of the GNU General Public License v2 6 */ 7 8#include <linux/i2c.h> 9#include <linux/slab.h> 10#include <linux/videodev2.h> 11#include <linux/delay.h> 12#include <linux/module.h> 13#include <media/v4l2-device.h> 14#include <media/tvp5150.h> 15#include <media/v4l2-chip-ident.h> 16#include <media/v4l2-ctrls.h> 17 18#include "tvp5150_reg.h" 19 20#define TVP5150_H_MAX 720 21#define TVP5150_V_MAX_525_60 480 22#define TVP5150_V_MAX_OTHERS 576 23#define TVP5150_MAX_CROP_LEFT 511 24#define TVP5150_MAX_CROP_TOP 127 25#define TVP5150_CROP_SHIFT 2 26 27MODULE_DESCRIPTION("Texas Instruments TVP5150A video decoder driver"); 28MODULE_AUTHOR("Mauro Carvalho Chehab"); 29MODULE_LICENSE("GPL"); 30 31 32static int debug; 33module_param(debug, int, 0); 34MODULE_PARM_DESC(debug, "Debug level (0-2)"); 35 36struct tvp5150 { 37 struct v4l2_subdev sd; 38 struct v4l2_ctrl_handler hdl; 39 struct v4l2_rect rect; 40 41 v4l2_std_id norm; /* Current set standard */ 42 u32 input; 43 u32 output; 44 int enable; 45}; 46 47static inline struct tvp5150 *to_tvp5150(struct v4l2_subdev *sd) 48{ 49 return container_of(sd, struct tvp5150, sd); 50} 51 52static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl) 53{ 54 return &container_of(ctrl->handler, struct tvp5150, hdl)->sd; 55} 56 57static int tvp5150_read(struct v4l2_subdev *sd, unsigned char addr) 58{ 59 struct i2c_client *c = v4l2_get_subdevdata(sd); 60 unsigned char buffer[1]; 61 int rc; 62 63 buffer[0] = addr; 64 if (1 != (rc = i2c_master_send(c, buffer, 1))) 65 v4l2_dbg(0, debug, sd, "i2c i/o error: rc == %d (should be 1)\n", rc); 66 67 msleep(10); 68 69 if (1 != (rc = i2c_master_recv(c, buffer, 1))) 70 v4l2_dbg(0, debug, sd, "i2c i/o error: rc == %d (should be 1)\n", rc); 71 72 v4l2_dbg(2, debug, sd, "tvp5150: read 0x%02x = 0x%02x\n", addr, buffer[0]); 73 74 return (buffer[0]); 75} 76 77static inline void tvp5150_write(struct v4l2_subdev *sd, unsigned char addr, 78 unsigned char value) 79{ 80 struct i2c_client *c = v4l2_get_subdevdata(sd); 81 unsigned char buffer[2]; 82 int rc; 83 84 buffer[0] = addr; 85 buffer[1] = value; 86 v4l2_dbg(2, debug, sd, "tvp5150: writing 0x%02x 0x%02x\n", buffer[0], buffer[1]); 87 if (2 != (rc = i2c_master_send(c, buffer, 2))) 88 v4l2_dbg(0, debug, sd, "i2c i/o error: rc == %d (should be 2)\n", rc); 89} 90 91static void dump_reg_range(struct v4l2_subdev *sd, char *s, u8 init, 92 const u8 end, int max_line) 93{ 94 int i = 0; 95 96 while (init != (u8)(end + 1)) { 97 if ((i % max_line) == 0) { 98 if (i > 0) 99 printk("\n"); 100 printk("tvp5150: %s reg 0x%02x = ", s, init); 101 } 102 printk("%02x ", tvp5150_read(sd, init)); 103 104 init++; 105 i++; 106 } 107 printk("\n"); 108} 109 110static int tvp5150_log_status(struct v4l2_subdev *sd) 111{ 112 printk("tvp5150: Video input source selection #1 = 0x%02x\n", 113 tvp5150_read(sd, TVP5150_VD_IN_SRC_SEL_1)); 114 printk("tvp5150: Analog channel controls = 0x%02x\n", 115 tvp5150_read(sd, TVP5150_ANAL_CHL_CTL)); 116 printk("tvp5150: Operation mode controls = 0x%02x\n", 117 tvp5150_read(sd, TVP5150_OP_MODE_CTL)); 118 printk("tvp5150: Miscellaneous controls = 0x%02x\n", 119 tvp5150_read(sd, TVP5150_MISC_CTL)); 120 printk("tvp5150: Autoswitch mask= 0x%02x\n", 121 tvp5150_read(sd, TVP5150_AUTOSW_MSK)); 122 printk("tvp5150: Color killer threshold control = 0x%02x\n", 123 tvp5150_read(sd, TVP5150_COLOR_KIL_THSH_CTL)); 124 printk("tvp5150: Luminance processing controls #1 #2 and #3 = %02x %02x %02x\n", 125 tvp5150_read(sd, TVP5150_LUMA_PROC_CTL_1), 126 tvp5150_read(sd, TVP5150_LUMA_PROC_CTL_2), 127 tvp5150_read(sd, TVP5150_LUMA_PROC_CTL_3)); 128 printk("tvp5150: Brightness control = 0x%02x\n", 129 tvp5150_read(sd, TVP5150_BRIGHT_CTL)); 130 printk("tvp5150: Color saturation control = 0x%02x\n", 131 tvp5150_read(sd, TVP5150_SATURATION_CTL)); 132 printk("tvp5150: Hue control = 0x%02x\n", 133 tvp5150_read(sd, TVP5150_HUE_CTL)); 134 printk("tvp5150: Contrast control = 0x%02x\n", 135 tvp5150_read(sd, TVP5150_CONTRAST_CTL)); 136 printk("tvp5150: Outputs and data rates select = 0x%02x\n", 137 tvp5150_read(sd, TVP5150_DATA_RATE_SEL)); 138 printk("tvp5150: Configuration shared pins = 0x%02x\n", 139 tvp5150_read(sd, TVP5150_CONF_SHARED_PIN)); 140 printk("tvp5150: Active video cropping start = 0x%02x%02x\n", 141 tvp5150_read(sd, TVP5150_ACT_VD_CROP_ST_MSB), 142 tvp5150_read(sd, TVP5150_ACT_VD_CROP_ST_LSB)); 143 printk("tvp5150: Active video cropping stop = 0x%02x%02x\n", 144 tvp5150_read(sd, TVP5150_ACT_VD_CROP_STP_MSB), 145 tvp5150_read(sd, TVP5150_ACT_VD_CROP_STP_LSB)); 146 printk("tvp5150: Genlock/RTC = 0x%02x\n", 147 tvp5150_read(sd, TVP5150_GENLOCK)); 148 printk("tvp5150: Horizontal sync start = 0x%02x\n", 149 tvp5150_read(sd, TVP5150_HORIZ_SYNC_START)); 150 printk("tvp5150: Vertical blanking start = 0x%02x\n", 151 tvp5150_read(sd, TVP5150_VERT_BLANKING_START)); 152 printk("tvp5150: Vertical blanking stop = 0x%02x\n", 153 tvp5150_read(sd, TVP5150_VERT_BLANKING_STOP)); 154 printk("tvp5150: Chrominance processing control #1 and #2 = %02x %02x\n", 155 tvp5150_read(sd, TVP5150_CHROMA_PROC_CTL_1), 156 tvp5150_read(sd, TVP5150_CHROMA_PROC_CTL_2)); 157 printk("tvp5150: Interrupt reset register B = 0x%02x\n", 158 tvp5150_read(sd, TVP5150_INT_RESET_REG_B)); 159 printk("tvp5150: Interrupt enable register B = 0x%02x\n", 160 tvp5150_read(sd, TVP5150_INT_ENABLE_REG_B)); 161 printk("tvp5150: Interrupt configuration register B = 0x%02x\n", 162 tvp5150_read(sd, TVP5150_INTT_CONFIG_REG_B)); 163 printk("tvp5150: Video standard = 0x%02x\n", 164 tvp5150_read(sd, TVP5150_VIDEO_STD)); 165 printk("tvp5150: Chroma gain factor: Cb=0x%02x Cr=0x%02x\n", 166 tvp5150_read(sd, TVP5150_CB_GAIN_FACT), 167 tvp5150_read(sd, TVP5150_CR_GAIN_FACTOR)); 168 printk("tvp5150: Macrovision on counter = 0x%02x\n", 169 tvp5150_read(sd, TVP5150_MACROVISION_ON_CTR)); 170 printk("tvp5150: Macrovision off counter = 0x%02x\n", 171 tvp5150_read(sd, TVP5150_MACROVISION_OFF_CTR)); 172 printk("tvp5150: ITU-R BT.656.%d timing(TVP5150AM1 only)\n", 173 (tvp5150_read(sd, TVP5150_REV_SELECT) & 1) ? 3 : 4); 174 printk("tvp5150: Device ID = %02x%02x\n", 175 tvp5150_read(sd, TVP5150_MSB_DEV_ID), 176 tvp5150_read(sd, TVP5150_LSB_DEV_ID)); 177 printk("tvp5150: ROM version = (hex) %02x.%02x\n", 178 tvp5150_read(sd, TVP5150_ROM_MAJOR_VER), 179 tvp5150_read(sd, TVP5150_ROM_MINOR_VER)); 180 printk("tvp5150: Vertical line count = 0x%02x%02x\n", 181 tvp5150_read(sd, TVP5150_VERT_LN_COUNT_MSB), 182 tvp5150_read(sd, TVP5150_VERT_LN_COUNT_LSB)); 183 printk("tvp5150: Interrupt status register B = 0x%02x\n", 184 tvp5150_read(sd, TVP5150_INT_STATUS_REG_B)); 185 printk("tvp5150: Interrupt active register B = 0x%02x\n", 186 tvp5150_read(sd, TVP5150_INT_ACTIVE_REG_B)); 187 printk("tvp5150: Status regs #1 to #5 = %02x %02x %02x %02x %02x\n", 188 tvp5150_read(sd, TVP5150_STATUS_REG_1), 189 tvp5150_read(sd, TVP5150_STATUS_REG_2), 190 tvp5150_read(sd, TVP5150_STATUS_REG_3), 191 tvp5150_read(sd, TVP5150_STATUS_REG_4), 192 tvp5150_read(sd, TVP5150_STATUS_REG_5)); 193 194 dump_reg_range(sd, "Teletext filter 1", TVP5150_TELETEXT_FIL1_INI, 195 TVP5150_TELETEXT_FIL1_END, 8); 196 dump_reg_range(sd, "Teletext filter 2", TVP5150_TELETEXT_FIL2_INI, 197 TVP5150_TELETEXT_FIL2_END, 8); 198 199 printk("tvp5150: Teletext filter enable = 0x%02x\n", 200 tvp5150_read(sd, TVP5150_TELETEXT_FIL_ENA)); 201 printk("tvp5150: Interrupt status register A = 0x%02x\n", 202 tvp5150_read(sd, TVP5150_INT_STATUS_REG_A)); 203 printk("tvp5150: Interrupt enable register A = 0x%02x\n", 204 tvp5150_read(sd, TVP5150_INT_ENABLE_REG_A)); 205 printk("tvp5150: Interrupt configuration = 0x%02x\n", 206 tvp5150_read(sd, TVP5150_INT_CONF)); 207 printk("tvp5150: VDP status register = 0x%02x\n", 208 tvp5150_read(sd, TVP5150_VDP_STATUS_REG)); 209 printk("tvp5150: FIFO word count = 0x%02x\n", 210 tvp5150_read(sd, TVP5150_FIFO_WORD_COUNT)); 211 printk("tvp5150: FIFO interrupt threshold = 0x%02x\n", 212 tvp5150_read(sd, TVP5150_FIFO_INT_THRESHOLD)); 213 printk("tvp5150: FIFO reset = 0x%02x\n", 214 tvp5150_read(sd, TVP5150_FIFO_RESET)); 215 printk("tvp5150: Line number interrupt = 0x%02x\n", 216 tvp5150_read(sd, TVP5150_LINE_NUMBER_INT)); 217 printk("tvp5150: Pixel alignment register = 0x%02x%02x\n", 218 tvp5150_read(sd, TVP5150_PIX_ALIGN_REG_HIGH), 219 tvp5150_read(sd, TVP5150_PIX_ALIGN_REG_LOW)); 220 printk("tvp5150: FIFO output control = 0x%02x\n", 221 tvp5150_read(sd, TVP5150_FIFO_OUT_CTRL)); 222 printk("tvp5150: Full field enable = 0x%02x\n", 223 tvp5150_read(sd, TVP5150_FULL_FIELD_ENA)); 224 printk("tvp5150: Full field mode register = 0x%02x\n", 225 tvp5150_read(sd, TVP5150_FULL_FIELD_MODE_REG)); 226 227 dump_reg_range(sd, "CC data", TVP5150_CC_DATA_INI, 228 TVP5150_CC_DATA_END, 8); 229 230 dump_reg_range(sd, "WSS data", TVP5150_WSS_DATA_INI, 231 TVP5150_WSS_DATA_END, 8); 232 233 dump_reg_range(sd, "VPS data", TVP5150_VPS_DATA_INI, 234 TVP5150_VPS_DATA_END, 8); 235 236 dump_reg_range(sd, "VITC data", TVP5150_VITC_DATA_INI, 237 TVP5150_VITC_DATA_END, 10); 238 239 dump_reg_range(sd, "Line mode", TVP5150_LINE_MODE_INI, 240 TVP5150_LINE_MODE_END, 8); 241 return 0; 242} 243 244/**************************************************************************** 245 Basic functions 246 ****************************************************************************/ 247 248static inline void tvp5150_selmux(struct v4l2_subdev *sd) 249{ 250 int opmode = 0; 251 struct tvp5150 *decoder = to_tvp5150(sd); 252 int input = 0; 253 unsigned char val; 254 255 if ((decoder->output & TVP5150_BLACK_SCREEN) || !decoder->enable) 256 input = 8; 257 258 switch (decoder->input) { 259 case TVP5150_COMPOSITE1: 260 input |= 2; 261 /* fall through */ 262 case TVP5150_COMPOSITE0: 263 break; 264 case TVP5150_SVIDEO: 265 default: 266 input |= 1; 267 break; 268 } 269 270 v4l2_dbg(1, debug, sd, "Selecting video route: route input=%i, output=%i " 271 "=> tvp5150 input=%i, opmode=%i\n", 272 decoder->input, decoder->output, 273 input, opmode); 274 275 tvp5150_write(sd, TVP5150_OP_MODE_CTL, opmode); 276 tvp5150_write(sd, TVP5150_VD_IN_SRC_SEL_1, input); 277 278 /* Svideo should enable YCrCb output and disable GPCL output 279 * For Composite and TV, it should be the reverse 280 */ 281 val = tvp5150_read(sd, TVP5150_MISC_CTL); 282 if (decoder->input == TVP5150_SVIDEO) 283 val = (val & ~0x40) | 0x10; 284 else 285 val = (val & ~0x10) | 0x40; 286 tvp5150_write(sd, TVP5150_MISC_CTL, val); 287}; 288 289struct i2c_reg_value { 290 unsigned char reg; 291 unsigned char value; 292}; 293 294/* Default values as sugested at TVP5150AM1 datasheet */ 295static const struct i2c_reg_value tvp5150_init_default[] = { 296 { /* 0x00 */ 297 TVP5150_VD_IN_SRC_SEL_1,0x00 298 }, 299 { /* 0x01 */ 300 TVP5150_ANAL_CHL_CTL,0x15 301 }, 302 { /* 0x02 */ 303 TVP5150_OP_MODE_CTL,0x00 304 }, 305 { /* 0x03 */ 306 TVP5150_MISC_CTL,0x01 307 }, 308 { /* 0x06 */ 309 TVP5150_COLOR_KIL_THSH_CTL,0x10 310 }, 311 { /* 0x07 */ 312 TVP5150_LUMA_PROC_CTL_1,0x60 313 }, 314 { /* 0x08 */ 315 TVP5150_LUMA_PROC_CTL_2,0x00 316 }, 317 { /* 0x09 */ 318 TVP5150_BRIGHT_CTL,0x80 319 }, 320 { /* 0x0a */ 321 TVP5150_SATURATION_CTL,0x80 322 }, 323 { /* 0x0b */ 324 TVP5150_HUE_CTL,0x00 325 }, 326 { /* 0x0c */ 327 TVP5150_CONTRAST_CTL,0x80 328 }, 329 { /* 0x0d */ 330 TVP5150_DATA_RATE_SEL,0x47 331 }, 332 { /* 0x0e */ 333 TVP5150_LUMA_PROC_CTL_3,0x00 334 }, 335 { /* 0x0f */ 336 TVP5150_CONF_SHARED_PIN,0x08 337 }, 338 { /* 0x11 */ 339 TVP5150_ACT_VD_CROP_ST_MSB,0x00 340 }, 341 { /* 0x12 */ 342 TVP5150_ACT_VD_CROP_ST_LSB,0x00 343 }, 344 { /* 0x13 */ 345 TVP5150_ACT_VD_CROP_STP_MSB,0x00 346 }, 347 { /* 0x14 */ 348 TVP5150_ACT_VD_CROP_STP_LSB,0x00 349 }, 350 { /* 0x15 */ 351 TVP5150_GENLOCK,0x01 352 }, 353 { /* 0x16 */ 354 TVP5150_HORIZ_SYNC_START,0x80 355 }, 356 { /* 0x18 */ 357 TVP5150_VERT_BLANKING_START,0x00 358 }, 359 { /* 0x19 */ 360 TVP5150_VERT_BLANKING_STOP,0x00 361 }, 362 { /* 0x1a */ 363 TVP5150_CHROMA_PROC_CTL_1,0x0c 364 }, 365 { /* 0x1b */ 366 TVP5150_CHROMA_PROC_CTL_2,0x14 367 }, 368 { /* 0x1c */ 369 TVP5150_INT_RESET_REG_B,0x00 370 }, 371 { /* 0x1d */ 372 TVP5150_INT_ENABLE_REG_B,0x00 373 }, 374 { /* 0x1e */ 375 TVP5150_INTT_CONFIG_REG_B,0x00 376 }, 377 { /* 0x28 */ 378 TVP5150_VIDEO_STD,0x00 379 }, 380 { /* 0x2e */ 381 TVP5150_MACROVISION_ON_CTR,0x0f 382 }, 383 { /* 0x2f */ 384 TVP5150_MACROVISION_OFF_CTR,0x01 385 }, 386 { /* 0xbb */ 387 TVP5150_TELETEXT_FIL_ENA,0x00 388 }, 389 { /* 0xc0 */ 390 TVP5150_INT_STATUS_REG_A,0x00 391 }, 392 { /* 0xc1 */ 393 TVP5150_INT_ENABLE_REG_A,0x00 394 }, 395 { /* 0xc2 */ 396 TVP5150_INT_CONF,0x04 397 }, 398 { /* 0xc8 */ 399 TVP5150_FIFO_INT_THRESHOLD,0x80 400 }, 401 { /* 0xc9 */ 402 TVP5150_FIFO_RESET,0x00 403 }, 404 { /* 0xca */ 405 TVP5150_LINE_NUMBER_INT,0x00 406 }, 407 { /* 0xcb */ 408 TVP5150_PIX_ALIGN_REG_LOW,0x4e 409 }, 410 { /* 0xcc */ 411 TVP5150_PIX_ALIGN_REG_HIGH,0x00 412 }, 413 { /* 0xcd */ 414 TVP5150_FIFO_OUT_CTRL,0x01 415 }, 416 { /* 0xcf */ 417 TVP5150_FULL_FIELD_ENA,0x00 418 }, 419 { /* 0xd0 */ 420 TVP5150_LINE_MODE_INI,0x00 421 }, 422 { /* 0xfc */ 423 TVP5150_FULL_FIELD_MODE_REG,0x7f 424 }, 425 { /* end of data */ 426 0xff,0xff 427 } 428}; 429 430/* Default values as sugested at TVP5150AM1 datasheet */ 431static const struct i2c_reg_value tvp5150_init_enable[] = { 432 { 433 TVP5150_CONF_SHARED_PIN, 2 434 },{ /* Automatic offset and AGC enabled */ 435 TVP5150_ANAL_CHL_CTL, 0x15 436 },{ /* Activate YCrCb output 0x9 or 0xd ? */ 437 TVP5150_MISC_CTL, 0x6f 438 },{ /* Activates video std autodetection for all standards */ 439 TVP5150_AUTOSW_MSK, 0x0 440 },{ /* Default format: 0x47. For 4:2:2: 0x40 */ 441 TVP5150_DATA_RATE_SEL, 0x47 442 },{ 443 TVP5150_CHROMA_PROC_CTL_1, 0x0c 444 },{ 445 TVP5150_CHROMA_PROC_CTL_2, 0x54 446 },{ /* Non documented, but initialized on WinTV USB2 */ 447 0x27, 0x20 448 },{ 449 0xff,0xff 450 } 451}; 452 453struct tvp5150_vbi_type { 454 unsigned int vbi_type; 455 unsigned int ini_line; 456 unsigned int end_line; 457 unsigned int by_field :1; 458}; 459 460struct i2c_vbi_ram_value { 461 u16 reg; 462 struct tvp5150_vbi_type type; 463 unsigned char values[16]; 464}; 465 466/* This struct have the values for each supported VBI Standard 467 * by 468 tvp5150_vbi_types should follow the same order as vbi_ram_default 469 * value 0 means rom position 0x10, value 1 means rom position 0x30 470 * and so on. There are 16 possible locations from 0 to 15. 471 */ 472 473static struct i2c_vbi_ram_value vbi_ram_default[] = 474{ 475 /* FIXME: Current api doesn't handle all VBI types, those not 476 yet supported are placed under #if 0 */ 477#if 0 478 {0x010, /* Teletext, SECAM, WST System A */ 479 {V4L2_SLICED_TELETEXT_SECAM,6,23,1}, 480 { 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x26, 481 0xe6, 0xb4, 0x0e, 0x00, 0x00, 0x00, 0x10, 0x00 } 482 }, 483#endif 484 {0x030, /* Teletext, PAL, WST System B */ 485 {V4L2_SLICED_TELETEXT_B,6,22,1}, 486 { 0xaa, 0xaa, 0xff, 0xff, 0x27, 0x2e, 0x20, 0x2b, 487 0xa6, 0x72, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00 } 488 }, 489#if 0 490 {0x050, /* Teletext, PAL, WST System C */ 491 {V4L2_SLICED_TELETEXT_PAL_C,6,22,1}, 492 { 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x22, 493 0xa6, 0x98, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 } 494 }, 495 {0x070, /* Teletext, NTSC, WST System B */ 496 {V4L2_SLICED_TELETEXT_NTSC_B,10,21,1}, 497 { 0xaa, 0xaa, 0xff, 0xff, 0x27, 0x2e, 0x20, 0x23, 498 0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 } 499 }, 500 {0x090, /* Tetetext, NTSC NABTS System C */ 501 {V4L2_SLICED_TELETEXT_NTSC_C,10,21,1}, 502 { 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x22, 503 0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x15, 0x00 } 504 }, 505 {0x0b0, /* Teletext, NTSC-J, NABTS System D */ 506 {V4L2_SLICED_TELETEXT_NTSC_D,10,21,1}, 507 { 0xaa, 0xaa, 0xff, 0xff, 0xa7, 0x2e, 0x20, 0x23, 508 0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 } 509 }, 510 {0x0d0, /* Closed Caption, PAL/SECAM */ 511 {V4L2_SLICED_CAPTION_625,22,22,1}, 512 { 0xaa, 0x2a, 0xff, 0x3f, 0x04, 0x51, 0x6e, 0x02, 513 0xa6, 0x7b, 0x09, 0x00, 0x00, 0x00, 0x27, 0x00 } 514 }, 515#endif 516 {0x0f0, /* Closed Caption, NTSC */ 517 {V4L2_SLICED_CAPTION_525,21,21,1}, 518 { 0xaa, 0x2a, 0xff, 0x3f, 0x04, 0x51, 0x6e, 0x02, 519 0x69, 0x8c, 0x09, 0x00, 0x00, 0x00, 0x27, 0x00 } 520 }, 521 {0x110, /* Wide Screen Signal, PAL/SECAM */ 522 {V4L2_SLICED_WSS_625,23,23,1}, 523 { 0x5b, 0x55, 0xc5, 0xff, 0x00, 0x71, 0x6e, 0x42, 524 0xa6, 0xcd, 0x0f, 0x00, 0x00, 0x00, 0x3a, 0x00 } 525 }, 526#if 0 527 {0x130, /* Wide Screen Signal, NTSC C */ 528 {V4L2_SLICED_WSS_525,20,20,1}, 529 { 0x38, 0x00, 0x3f, 0x00, 0x00, 0x71, 0x6e, 0x43, 530 0x69, 0x7c, 0x08, 0x00, 0x00, 0x00, 0x39, 0x00 } 531 }, 532 {0x150, /* Vertical Interval Timecode (VITC), PAL/SECAM */ 533 {V4l2_SLICED_VITC_625,6,22,0}, 534 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x6d, 0x49, 535 0xa6, 0x85, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00 } 536 }, 537 {0x170, /* Vertical Interval Timecode (VITC), NTSC */ 538 {V4l2_SLICED_VITC_525,10,20,0}, 539 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x6d, 0x49, 540 0x69, 0x94, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00 } 541 }, 542#endif 543 {0x190, /* Video Program System (VPS), PAL */ 544 {V4L2_SLICED_VPS,16,16,0}, 545 { 0xaa, 0xaa, 0xff, 0xff, 0xba, 0xce, 0x2b, 0x0d, 546 0xa6, 0xda, 0x0b, 0x00, 0x00, 0x00, 0x60, 0x00 } 547 }, 548 /* 0x1d0 User programmable */ 549 550 /* End of struct */ 551 { (u16)-1 } 552}; 553 554static int tvp5150_write_inittab(struct v4l2_subdev *sd, 555 const struct i2c_reg_value *regs) 556{ 557 while (regs->reg != 0xff) { 558 tvp5150_write(sd, regs->reg, regs->value); 559 regs++; 560 } 561 return 0; 562} 563 564static int tvp5150_vdp_init(struct v4l2_subdev *sd, 565 const struct i2c_vbi_ram_value *regs) 566{ 567 unsigned int i; 568 569 /* Disable Full Field */ 570 tvp5150_write(sd, TVP5150_FULL_FIELD_ENA, 0); 571 572 /* Before programming, Line mode should be at 0xff */ 573 for (i = TVP5150_LINE_MODE_INI; i <= TVP5150_LINE_MODE_END; i++) 574 tvp5150_write(sd, i, 0xff); 575 576 /* Load Ram Table */ 577 while (regs->reg != (u16)-1) { 578 tvp5150_write(sd, TVP5150_CONF_RAM_ADDR_HIGH, regs->reg >> 8); 579 tvp5150_write(sd, TVP5150_CONF_RAM_ADDR_LOW, regs->reg); 580 581 for (i = 0; i < 16; i++) 582 tvp5150_write(sd, TVP5150_VDP_CONF_RAM_DATA, regs->values[i]); 583 584 regs++; 585 } 586 return 0; 587} 588 589/* Fills VBI capabilities based on i2c_vbi_ram_value struct */ 590static int tvp5150_g_sliced_vbi_cap(struct v4l2_subdev *sd, 591 struct v4l2_sliced_vbi_cap *cap) 592{ 593 const struct i2c_vbi_ram_value *regs = vbi_ram_default; 594 int line; 595 596 v4l2_dbg(1, debug, sd, "g_sliced_vbi_cap\n"); 597 memset(cap, 0, sizeof *cap); 598 599 while (regs->reg != (u16)-1 ) { 600 for (line=regs->type.ini_line;line<=regs->type.end_line;line++) { 601 cap->service_lines[0][line] |= regs->type.vbi_type; 602 } 603 cap->service_set |= regs->type.vbi_type; 604 605 regs++; 606 } 607 return 0; 608} 609 610/* Set vbi processing 611 * type - one of tvp5150_vbi_types 612 * line - line to gather data 613 * fields: bit 0 field1, bit 1, field2 614 * flags (default=0xf0) is a bitmask, were set means: 615 * bit 7: enable filtering null bytes on CC 616 * bit 6: send data also to FIFO 617 * bit 5: don't allow data with errors on FIFO 618 * bit 4: enable ECC when possible 619 * pix_align = pix alignment: 620 * LSB = field1 621 * MSB = field2 622 */ 623static int tvp5150_set_vbi(struct v4l2_subdev *sd, 624 const struct i2c_vbi_ram_value *regs, 625 unsigned int type,u8 flags, int line, 626 const int fields) 627{ 628 struct tvp5150 *decoder = to_tvp5150(sd); 629 v4l2_std_id std = decoder->norm; 630 u8 reg; 631 int pos=0; 632 633 if (std == V4L2_STD_ALL) { 634 v4l2_err(sd, "VBI can't be configured without knowing number of lines\n"); 635 return 0; 636 } else if (std & V4L2_STD_625_50) { 637 /* Don't follow NTSC Line number convension */ 638 line += 3; 639 } 640 641 if (line<6||line>27) 642 return 0; 643 644 while (regs->reg != (u16)-1 ) { 645 if ((type & regs->type.vbi_type) && 646 (line>=regs->type.ini_line) && 647 (line<=regs->type.end_line)) { 648 type=regs->type.vbi_type; 649 break; 650 } 651 652 regs++; 653 pos++; 654 } 655 if (regs->reg == (u16)-1) 656 return 0; 657 658 type=pos | (flags & 0xf0); 659 reg=((line-6)<<1)+TVP5150_LINE_MODE_INI; 660 661 if (fields&1) { 662 tvp5150_write(sd, reg, type); 663 } 664 665 if (fields&2) { 666 tvp5150_write(sd, reg+1, type); 667 } 668 669 return type; 670} 671 672static int tvp5150_get_vbi(struct v4l2_subdev *sd, 673 const struct i2c_vbi_ram_value *regs, int line) 674{ 675 struct tvp5150 *decoder = to_tvp5150(sd); 676 v4l2_std_id std = decoder->norm; 677 u8 reg; 678 int pos, type = 0; 679 680 if (std == V4L2_STD_ALL) { 681 v4l2_err(sd, "VBI can't be configured without knowing number of lines\n"); 682 return 0; 683 } else if (std & V4L2_STD_625_50) { 684 /* Don't follow NTSC Line number convension */ 685 line += 3; 686 } 687 688 if (line < 6 || line > 27) 689 return 0; 690 691 reg = ((line - 6) << 1) + TVP5150_LINE_MODE_INI; 692 693 pos = tvp5150_read(sd, reg) & 0x0f; 694 if (pos < 0x0f) 695 type = regs[pos].type.vbi_type; 696 697 pos = tvp5150_read(sd, reg + 1) & 0x0f; 698 if (pos < 0x0f) 699 type |= regs[pos].type.vbi_type; 700 701 return type; 702} 703 704static int tvp5150_set_std(struct v4l2_subdev *sd, v4l2_std_id std) 705{ 706 struct tvp5150 *decoder = to_tvp5150(sd); 707 int fmt = 0; 708 709 decoder->norm = std; 710 711 /* First tests should be against specific std */ 712 713 if (std == V4L2_STD_ALL) { 714 fmt = VIDEO_STD_AUTO_SWITCH_BIT; /* Autodetect mode */ 715 } else if (std & V4L2_STD_NTSC_443) { 716 fmt = VIDEO_STD_NTSC_4_43_BIT; 717 } else if (std & V4L2_STD_PAL_M) { 718 fmt = VIDEO_STD_PAL_M_BIT; 719 } else if (std & (V4L2_STD_PAL_N | V4L2_STD_PAL_Nc)) { 720 fmt = VIDEO_STD_PAL_COMBINATION_N_BIT; 721 } else { 722 /* Then, test against generic ones */ 723 if (std & V4L2_STD_NTSC) 724 fmt = VIDEO_STD_NTSC_MJ_BIT; 725 else if (std & V4L2_STD_PAL) 726 fmt = VIDEO_STD_PAL_BDGHIN_BIT; 727 else if (std & V4L2_STD_SECAM) 728 fmt = VIDEO_STD_SECAM_BIT; 729 } 730 731 v4l2_dbg(1, debug, sd, "Set video std register to %d.\n", fmt); 732 tvp5150_write(sd, TVP5150_VIDEO_STD, fmt); 733 return 0; 734} 735 736static int tvp5150_s_std(struct v4l2_subdev *sd, v4l2_std_id std) 737{ 738 struct tvp5150 *decoder = to_tvp5150(sd); 739 740 if (decoder->norm == std) 741 return 0; 742 743 /* Change cropping height limits */ 744 if (std & V4L2_STD_525_60) 745 decoder->rect.height = TVP5150_V_MAX_525_60; 746 else 747 decoder->rect.height = TVP5150_V_MAX_OTHERS; 748 749 750 return tvp5150_set_std(sd, std); 751} 752 753static int tvp5150_reset(struct v4l2_subdev *sd, u32 val) 754{ 755 struct tvp5150 *decoder = to_tvp5150(sd); 756 757 /* Initializes TVP5150 to its default values */ 758 tvp5150_write_inittab(sd, tvp5150_init_default); 759 760 /* Initializes VDP registers */ 761 tvp5150_vdp_init(sd, vbi_ram_default); 762 763 /* Selects decoder input */ 764 tvp5150_selmux(sd); 765 766 /* Initializes TVP5150 to stream enabled values */ 767 tvp5150_write_inittab(sd, tvp5150_init_enable); 768 769 /* Initialize image preferences */ 770 v4l2_ctrl_handler_setup(&decoder->hdl); 771 772 tvp5150_set_std(sd, decoder->norm); 773 return 0; 774}; 775 776static int tvp5150_s_ctrl(struct v4l2_ctrl *ctrl) 777{ 778 struct v4l2_subdev *sd = to_sd(ctrl); 779 780 switch (ctrl->id) { 781 case V4L2_CID_BRIGHTNESS: 782 tvp5150_write(sd, TVP5150_BRIGHT_CTL, ctrl->val); 783 return 0; 784 case V4L2_CID_CONTRAST: 785 tvp5150_write(sd, TVP5150_CONTRAST_CTL, ctrl->val); 786 return 0; 787 case V4L2_CID_SATURATION: 788 tvp5150_write(sd, TVP5150_SATURATION_CTL, ctrl->val); 789 return 0; 790 case V4L2_CID_HUE: 791 tvp5150_write(sd, TVP5150_HUE_CTL, ctrl->val); 792 return 0; 793 } 794 return -EINVAL; 795} 796 797static v4l2_std_id tvp5150_read_std(struct v4l2_subdev *sd) 798{ 799 int val = tvp5150_read(sd, TVP5150_STATUS_REG_5); 800 801 switch (val & 0x0F) { 802 case 0x01: 803 return V4L2_STD_NTSC; 804 case 0x03: 805 return V4L2_STD_PAL; 806 case 0x05: 807 return V4L2_STD_PAL_M; 808 case 0x07: 809 return V4L2_STD_PAL_N | V4L2_STD_PAL_Nc; 810 case 0x09: 811 return V4L2_STD_NTSC_443; 812 case 0xb: 813 return V4L2_STD_SECAM; 814 default: 815 return V4L2_STD_UNKNOWN; 816 } 817} 818 819static int tvp5150_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index, 820 enum v4l2_mbus_pixelcode *code) 821{ 822 if (index) 823 return -EINVAL; 824 825 *code = V4L2_MBUS_FMT_YUYV8_2X8; 826 return 0; 827} 828 829static int tvp5150_mbus_fmt(struct v4l2_subdev *sd, 830 struct v4l2_mbus_framefmt *f) 831{ 832 struct tvp5150 *decoder = to_tvp5150(sd); 833 v4l2_std_id std; 834 835 if (f == NULL) 836 return -EINVAL; 837 838 tvp5150_reset(sd, 0); 839 840 /* Calculate height and width based on current standard */ 841 if (decoder->norm == V4L2_STD_ALL) 842 std = tvp5150_read_std(sd); 843 else 844 std = decoder->norm; 845 846 f->width = decoder->rect.width; 847 f->height = decoder->rect.height; 848 849 f->code = V4L2_MBUS_FMT_YUYV8_2X8; 850 f->field = V4L2_FIELD_SEQ_TB; 851 f->colorspace = V4L2_COLORSPACE_SMPTE170M; 852 853 v4l2_dbg(1, debug, sd, "width = %d, height = %d\n", f->width, 854 f->height); 855 return 0; 856} 857 858static int tvp5150_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a) 859{ 860 struct v4l2_rect rect = a->c; 861 struct tvp5150 *decoder = to_tvp5150(sd); 862 v4l2_std_id std; 863 int hmax; 864 865 v4l2_dbg(1, debug, sd, "%s left=%d, top=%d, width=%d, height=%d\n", 866 __func__, rect.left, rect.top, rect.width, rect.height); 867 868 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 869 return -EINVAL; 870 871 /* tvp5150 has some special limits */ 872 rect.left = clamp(rect.left, 0, TVP5150_MAX_CROP_LEFT); 873 rect.width = clamp(rect.width, 874 TVP5150_H_MAX - TVP5150_MAX_CROP_LEFT - rect.left, 875 TVP5150_H_MAX - rect.left); 876 rect.top = clamp(rect.top, 0, TVP5150_MAX_CROP_TOP); 877 878 /* Calculate height based on current standard */ 879 if (decoder->norm == V4L2_STD_ALL) 880 std = tvp5150_read_std(sd); 881 else 882 std = decoder->norm; 883 884 if (std & V4L2_STD_525_60) 885 hmax = TVP5150_V_MAX_525_60; 886 else 887 hmax = TVP5150_V_MAX_OTHERS; 888 889 rect.height = clamp(rect.height, 890 hmax - TVP5150_MAX_CROP_TOP - rect.top, 891 hmax - rect.top); 892 893 tvp5150_write(sd, TVP5150_VERT_BLANKING_START, rect.top); 894 tvp5150_write(sd, TVP5150_VERT_BLANKING_STOP, 895 rect.top + rect.height - hmax); 896 tvp5150_write(sd, TVP5150_ACT_VD_CROP_ST_MSB, 897 rect.left >> TVP5150_CROP_SHIFT); 898 tvp5150_write(sd, TVP5150_ACT_VD_CROP_ST_LSB, 899 rect.left | (1 << TVP5150_CROP_SHIFT)); 900 tvp5150_write(sd, TVP5150_ACT_VD_CROP_STP_MSB, 901 (rect.left + rect.width - TVP5150_MAX_CROP_LEFT) >> 902 TVP5150_CROP_SHIFT); 903 tvp5150_write(sd, TVP5150_ACT_VD_CROP_STP_LSB, 904 rect.left + rect.width - TVP5150_MAX_CROP_LEFT); 905 906 decoder->rect = rect; 907 908 return 0; 909} 910 911static int tvp5150_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a) 912{ 913 struct tvp5150 *decoder = container_of(sd, struct tvp5150, sd); 914 915 a->c = decoder->rect; 916 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 917 918 return 0; 919} 920 921static int tvp5150_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a) 922{ 923 struct tvp5150 *decoder = container_of(sd, struct tvp5150, sd); 924 v4l2_std_id std; 925 926 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 927 return -EINVAL; 928 929 a->bounds.left = 0; 930 a->bounds.top = 0; 931 a->bounds.width = TVP5150_H_MAX; 932 933 /* Calculate height based on current standard */ 934 if (decoder->norm == V4L2_STD_ALL) 935 std = tvp5150_read_std(sd); 936 else 937 std = decoder->norm; 938 939 if (std & V4L2_STD_525_60) 940 a->bounds.height = TVP5150_V_MAX_525_60; 941 else 942 a->bounds.height = TVP5150_V_MAX_OTHERS; 943 944 a->defrect = a->bounds; 945 a->pixelaspect.numerator = 1; 946 a->pixelaspect.denominator = 1; 947 948 return 0; 949} 950 951/**************************************************************************** 952 I2C Command 953 ****************************************************************************/ 954 955static int tvp5150_s_routing(struct v4l2_subdev *sd, 956 u32 input, u32 output, u32 config) 957{ 958 struct tvp5150 *decoder = to_tvp5150(sd); 959 960 decoder->input = input; 961 decoder->output = output; 962 tvp5150_selmux(sd); 963 return 0; 964} 965 966static int tvp5150_s_raw_fmt(struct v4l2_subdev *sd, struct v4l2_vbi_format *fmt) 967{ 968 /* this is for capturing 36 raw vbi lines 969 if there's a way to cut off the beginning 2 vbi lines 970 with the tvp5150 then the vbi line count could be lowered 971 to 17 lines/field again, although I couldn't find a register 972 which could do that cropping */ 973 if (fmt->sample_format == V4L2_PIX_FMT_GREY) 974 tvp5150_write(sd, TVP5150_LUMA_PROC_CTL_1, 0x70); 975 if (fmt->count[0] == 18 && fmt->count[1] == 18) { 976 tvp5150_write(sd, TVP5150_VERT_BLANKING_START, 0x00); 977 tvp5150_write(sd, TVP5150_VERT_BLANKING_STOP, 0x01); 978 } 979 return 0; 980} 981 982static int tvp5150_s_sliced_fmt(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_format *svbi) 983{ 984 int i; 985 986 if (svbi->service_set != 0) { 987 for (i = 0; i <= 23; i++) { 988 svbi->service_lines[1][i] = 0; 989 svbi->service_lines[0][i] = 990 tvp5150_set_vbi(sd, vbi_ram_default, 991 svbi->service_lines[0][i], 0xf0, i, 3); 992 } 993 /* Enables FIFO */ 994 tvp5150_write(sd, TVP5150_FIFO_OUT_CTRL, 1); 995 } else { 996 /* Disables FIFO*/ 997 tvp5150_write(sd, TVP5150_FIFO_OUT_CTRL, 0); 998 999 /* Disable Full Field */ 1000 tvp5150_write(sd, TVP5150_FULL_FIELD_ENA, 0); 1001 1002 /* Disable Line modes */ 1003 for (i = TVP5150_LINE_MODE_INI; i <= TVP5150_LINE_MODE_END; i++) 1004 tvp5150_write(sd, i, 0xff); 1005 } 1006 return 0; 1007} 1008 1009static int tvp5150_g_sliced_fmt(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_format *svbi) 1010{ 1011 int i, mask = 0; 1012 1013 memset(svbi, 0, sizeof(*svbi)); 1014 1015 for (i = 0; i <= 23; i++) { 1016 svbi->service_lines[0][i] = 1017 tvp5150_get_vbi(sd, vbi_ram_default, i); 1018 mask |= svbi->service_lines[0][i]; 1019 } 1020 svbi->service_set = mask; 1021 return 0; 1022} 1023 1024static int tvp5150_g_chip_ident(struct v4l2_subdev *sd, 1025 struct v4l2_dbg_chip_ident *chip) 1026{ 1027 int rev; 1028 struct i2c_client *client = v4l2_get_subdevdata(sd); 1029 1030 rev = tvp5150_read(sd, TVP5150_ROM_MAJOR_VER) << 8 | 1031 tvp5150_read(sd, TVP5150_ROM_MINOR_VER); 1032 1033 return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_TVP5150, 1034 rev); 1035} 1036 1037 1038#ifdef CONFIG_VIDEO_ADV_DEBUG 1039static int tvp5150_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg) 1040{ 1041 struct i2c_client *client = v4l2_get_subdevdata(sd); 1042 1043 if (!v4l2_chip_match_i2c_client(client, ®->match)) 1044 return -EINVAL; 1045 if (!capable(CAP_SYS_ADMIN)) 1046 return -EPERM; 1047 reg->val = tvp5150_read(sd, reg->reg & 0xff); 1048 reg->size = 1; 1049 return 0; 1050} 1051 1052static int tvp5150_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg) 1053{ 1054 struct i2c_client *client = v4l2_get_subdevdata(sd); 1055 1056 if (!v4l2_chip_match_i2c_client(client, ®->match)) 1057 return -EINVAL; 1058 if (!capable(CAP_SYS_ADMIN)) 1059 return -EPERM; 1060 tvp5150_write(sd, reg->reg & 0xff, reg->val & 0xff); 1061 return 0; 1062} 1063#endif 1064 1065static int tvp5150_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt) 1066{ 1067 int status = tvp5150_read(sd, 0x88); 1068 1069 vt->signal = ((status & 0x04) && (status & 0x02)) ? 0xffff : 0x0; 1070 return 0; 1071} 1072 1073/* ----------------------------------------------------------------------- */ 1074 1075static const struct v4l2_ctrl_ops tvp5150_ctrl_ops = { 1076 .s_ctrl = tvp5150_s_ctrl, 1077}; 1078 1079static const struct v4l2_subdev_core_ops tvp5150_core_ops = { 1080 .log_status = tvp5150_log_status, 1081 .g_ext_ctrls = v4l2_subdev_g_ext_ctrls, 1082 .try_ext_ctrls = v4l2_subdev_try_ext_ctrls, 1083 .s_ext_ctrls = v4l2_subdev_s_ext_ctrls, 1084 .g_ctrl = v4l2_subdev_g_ctrl, 1085 .s_ctrl = v4l2_subdev_s_ctrl, 1086 .queryctrl = v4l2_subdev_queryctrl, 1087 .querymenu = v4l2_subdev_querymenu, 1088 .s_std = tvp5150_s_std, 1089 .reset = tvp5150_reset, 1090 .g_chip_ident = tvp5150_g_chip_ident, 1091#ifdef CONFIG_VIDEO_ADV_DEBUG 1092 .g_register = tvp5150_g_register, 1093 .s_register = tvp5150_s_register, 1094#endif 1095}; 1096 1097static const struct v4l2_subdev_tuner_ops tvp5150_tuner_ops = { 1098 .g_tuner = tvp5150_g_tuner, 1099}; 1100 1101static const struct v4l2_subdev_video_ops tvp5150_video_ops = { 1102 .s_routing = tvp5150_s_routing, 1103 .enum_mbus_fmt = tvp5150_enum_mbus_fmt, 1104 .s_mbus_fmt = tvp5150_mbus_fmt, 1105 .try_mbus_fmt = tvp5150_mbus_fmt, 1106 .g_mbus_fmt = tvp5150_mbus_fmt, 1107 .s_crop = tvp5150_s_crop, 1108 .g_crop = tvp5150_g_crop, 1109 .cropcap = tvp5150_cropcap, 1110}; 1111 1112static const struct v4l2_subdev_vbi_ops tvp5150_vbi_ops = { 1113 .g_sliced_vbi_cap = tvp5150_g_sliced_vbi_cap, 1114 .g_sliced_fmt = tvp5150_g_sliced_fmt, 1115 .s_sliced_fmt = tvp5150_s_sliced_fmt, 1116 .s_raw_fmt = tvp5150_s_raw_fmt, 1117}; 1118 1119static const struct v4l2_subdev_ops tvp5150_ops = { 1120 .core = &tvp5150_core_ops, 1121 .tuner = &tvp5150_tuner_ops, 1122 .video = &tvp5150_video_ops, 1123 .vbi = &tvp5150_vbi_ops, 1124}; 1125 1126 1127/**************************************************************************** 1128 I2C Client & Driver 1129 ****************************************************************************/ 1130 1131static int tvp5150_probe(struct i2c_client *c, 1132 const struct i2c_device_id *id) 1133{ 1134 struct tvp5150 *core; 1135 struct v4l2_subdev *sd; 1136 u8 msb_id, lsb_id, msb_rom, lsb_rom; 1137 1138 /* Check if the adapter supports the needed features */ 1139 if (!i2c_check_functionality(c->adapter, 1140 I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) 1141 return -EIO; 1142 1143 core = kzalloc(sizeof(struct tvp5150), GFP_KERNEL); 1144 if (!core) { 1145 return -ENOMEM; 1146 } 1147 sd = &core->sd; 1148 v4l2_i2c_subdev_init(sd, c, &tvp5150_ops); 1149 v4l_info(c, "chip found @ 0x%02x (%s)\n", 1150 c->addr << 1, c->adapter->name); 1151 1152 msb_id = tvp5150_read(sd, TVP5150_MSB_DEV_ID); 1153 lsb_id = tvp5150_read(sd, TVP5150_LSB_DEV_ID); 1154 msb_rom = tvp5150_read(sd, TVP5150_ROM_MAJOR_VER); 1155 lsb_rom = tvp5150_read(sd, TVP5150_ROM_MINOR_VER); 1156 1157 if (msb_rom == 4 && lsb_rom == 0) { /* Is TVP5150AM1 */ 1158 v4l2_info(sd, "tvp%02x%02xam1 detected.\n", msb_id, lsb_id); 1159 1160 /* ITU-T BT.656.4 timing */ 1161 tvp5150_write(sd, TVP5150_REV_SELECT, 0); 1162 } else { 1163 if (msb_rom == 3 || lsb_rom == 0x21) { /* Is TVP5150A */ 1164 v4l2_info(sd, "tvp%02x%02xa detected.\n", msb_id, lsb_id); 1165 } else { 1166 v4l2_info(sd, "*** unknown tvp%02x%02x chip detected.\n", 1167 msb_id, lsb_id); 1168 v4l2_info(sd, "*** Rom ver is %d.%d\n", msb_rom, lsb_rom); 1169 } 1170 } 1171 1172 core->norm = V4L2_STD_ALL; /* Default is autodetect */ 1173 core->input = TVP5150_COMPOSITE1; 1174 core->enable = 1; 1175 1176 v4l2_ctrl_handler_init(&core->hdl, 4); 1177 v4l2_ctrl_new_std(&core->hdl, &tvp5150_ctrl_ops, 1178 V4L2_CID_BRIGHTNESS, 0, 255, 1, 128); 1179 v4l2_ctrl_new_std(&core->hdl, &tvp5150_ctrl_ops, 1180 V4L2_CID_CONTRAST, 0, 255, 1, 128); 1181 v4l2_ctrl_new_std(&core->hdl, &tvp5150_ctrl_ops, 1182 V4L2_CID_SATURATION, 0, 255, 1, 128); 1183 v4l2_ctrl_new_std(&core->hdl, &tvp5150_ctrl_ops, 1184 V4L2_CID_HUE, -128, 127, 1, 0); 1185 sd->ctrl_handler = &core->hdl; 1186 if (core->hdl.error) { 1187 int err = core->hdl.error; 1188 1189 v4l2_ctrl_handler_free(&core->hdl); 1190 kfree(core); 1191 return err; 1192 } 1193 v4l2_ctrl_handler_setup(&core->hdl); 1194 1195 /* Default is no cropping */ 1196 core->rect.top = 0; 1197 if (tvp5150_read_std(sd) & V4L2_STD_525_60) 1198 core->rect.height = TVP5150_V_MAX_525_60; 1199 else 1200 core->rect.height = TVP5150_V_MAX_OTHERS; 1201 core->rect.left = 0; 1202 core->rect.width = TVP5150_H_MAX; 1203 1204 if (debug > 1) 1205 tvp5150_log_status(sd); 1206 return 0; 1207} 1208 1209static int tvp5150_remove(struct i2c_client *c) 1210{ 1211 struct v4l2_subdev *sd = i2c_get_clientdata(c); 1212 struct tvp5150 *decoder = to_tvp5150(sd); 1213 1214 v4l2_dbg(1, debug, sd, 1215 "tvp5150.c: removing tvp5150 adapter on address 0x%x\n", 1216 c->addr << 1); 1217 1218 v4l2_device_unregister_subdev(sd); 1219 v4l2_ctrl_handler_free(&decoder->hdl); 1220 kfree(to_tvp5150(sd)); 1221 return 0; 1222} 1223 1224/* ----------------------------------------------------------------------- */ 1225 1226static const struct i2c_device_id tvp5150_id[] = { 1227 { "tvp5150", 0 }, 1228 { } 1229}; 1230MODULE_DEVICE_TABLE(i2c, tvp5150_id); 1231 1232static struct i2c_driver tvp5150_driver = { 1233 .driver = { 1234 .owner = THIS_MODULE, 1235 .name = "tvp5150", 1236 }, 1237 .probe = tvp5150_probe, 1238 .remove = tvp5150_remove, 1239 .id_table = tvp5150_id, 1240}; 1241 1242module_i2c_driver(tvp5150_driver); 1243