aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/tvp514x.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/video/tvp514x.c')
-rw-r--r--drivers/media/video/tvp514x.c875
1 files changed, 349 insertions, 526 deletions
diff --git a/drivers/media/video/tvp514x.c b/drivers/media/video/tvp514x.c
index 3750f7fadb12..c8386e2f7a99 100644
--- a/drivers/media/video/tvp514x.c
+++ b/drivers/media/video/tvp514x.c
@@ -31,7 +31,10 @@
31#include <linux/i2c.h> 31#include <linux/i2c.h>
32#include <linux/delay.h> 32#include <linux/delay.h>
33#include <linux/videodev2.h> 33#include <linux/videodev2.h>
34#include <media/v4l2-int-device.h> 34
35#include <media/v4l2-device.h>
36#include <media/v4l2-common.h>
37#include <media/v4l2-chip-ident.h>
35#include <media/tvp514x.h> 38#include <media/tvp514x.h>
36 39
37#include "tvp514x_regs.h" 40#include "tvp514x_regs.h"
@@ -49,13 +52,11 @@ static int debug;
49module_param(debug, bool, 0644); 52module_param(debug, bool, 0644);
50MODULE_PARM_DESC(debug, "Debug level (0-1)"); 53MODULE_PARM_DESC(debug, "Debug level (0-1)");
51 54
52#define dump_reg(client, reg, val) \ 55MODULE_AUTHOR("Texas Instruments");
53 do { \ 56MODULE_DESCRIPTION("TVP514X linux decoder driver");
54 val = tvp514x_read_reg(client, reg); \ 57MODULE_LICENSE("GPL");
55 v4l_info(client, "Reg(0x%.2X): 0x%.2X\n", reg, val); \
56 } while (0)
57 58
58/** 59/*
59 * enum tvp514x_std - enum for supported standards 60 * enum tvp514x_std - enum for supported standards
60 */ 61 */
61enum tvp514x_std { 62enum tvp514x_std {
@@ -64,15 +65,7 @@ enum tvp514x_std {
64 STD_INVALID 65 STD_INVALID
65}; 66};
66 67
67/** 68/*
68 * enum tvp514x_state - enum for different decoder states
69 */
70enum tvp514x_state {
71 STATE_NOT_DETECTED,
72 STATE_DETECTED
73};
74
75/**
76 * struct tvp514x_std_info - Structure to store standard informations 69 * struct tvp514x_std_info - Structure to store standard informations
77 * @width: Line width in pixels 70 * @width: Line width in pixels
78 * @height:Number of active lines 71 * @height:Number of active lines
@@ -87,35 +80,29 @@ struct tvp514x_std_info {
87}; 80};
88 81
89static struct tvp514x_reg tvp514x_reg_list_default[0x40]; 82static struct tvp514x_reg tvp514x_reg_list_default[0x40];
90/** 83/*
91 * struct tvp514x_decoder - TVP5146/47 decoder object 84 * struct tvp514x_decoder - TVP5146/47 decoder object
92 * @v4l2_int_device: Slave handle 85 * @sd: Subdevice Slave handle
93 * @tvp514x_slave: Slave pointer which is used by @v4l2_int_device
94 * @tvp514x_regs: copy of hw's regs with preset values. 86 * @tvp514x_regs: copy of hw's regs with preset values.
95 * @pdata: Board specific 87 * @pdata: Board specific
96 * @client: I2C client data
97 * @id: Entry from I2C table
98 * @ver: Chip version 88 * @ver: Chip version
99 * @state: TVP5146/47 decoder state - detected or not-detected 89 * @streaming: TVP5146/47 decoder streaming - enabled or disabled.
100 * @pix: Current pixel format 90 * @pix: Current pixel format
101 * @num_fmts: Number of formats 91 * @num_fmts: Number of formats
102 * @fmt_list: Format list 92 * @fmt_list: Format list
103 * @current_std: Current standard 93 * @current_std: Current standard
104 * @num_stds: Number of standards 94 * @num_stds: Number of standards
105 * @std_list: Standards list 95 * @std_list: Standards list
106 * @route: input and output routing at chip level 96 * @input: Input routing at chip level
97 * @output: Output routing at chip level
107 */ 98 */
108struct tvp514x_decoder { 99struct tvp514x_decoder {
109 struct v4l2_int_device v4l2_int_device; 100 struct v4l2_subdev sd;
110 struct v4l2_int_slave tvp514x_slave;
111 struct tvp514x_reg tvp514x_regs[ARRAY_SIZE(tvp514x_reg_list_default)]; 101 struct tvp514x_reg tvp514x_regs[ARRAY_SIZE(tvp514x_reg_list_default)];
112 const struct tvp514x_platform_data *pdata; 102 const struct tvp514x_platform_data *pdata;
113 struct i2c_client *client;
114
115 struct i2c_device_id *id;
116 103
117 int ver; 104 int ver;
118 enum tvp514x_state state; 105 int streaming;
119 106
120 struct v4l2_pix_format pix; 107 struct v4l2_pix_format pix;
121 int num_fmts; 108 int num_fmts;
@@ -124,8 +111,11 @@ struct tvp514x_decoder {
124 enum tvp514x_std current_std; 111 enum tvp514x_std current_std;
125 int num_stds; 112 int num_stds;
126 struct tvp514x_std_info *std_list; 113 struct tvp514x_std_info *std_list;
127 114 /*
128 struct v4l2_routing route; 115 * Input and Output Routing parameters
116 */
117 u32 input;
118 u32 output;
129}; 119};
130 120
131/* TVP514x default register values */ 121/* TVP514x default register values */
@@ -191,7 +181,8 @@ static struct tvp514x_reg tvp514x_reg_list_default[] = {
191 {TOK_TERM, 0, 0}, 181 {TOK_TERM, 0, 0},
192}; 182};
193 183
194/* List of image formats supported by TVP5146/47 decoder 184/*
185 * List of image formats supported by TVP5146/47 decoder
195 * Currently we are using 8 bit mode only, but can be 186 * Currently we are using 8 bit mode only, but can be
196 * extended to 10/20 bit mode. 187 * extended to 10/20 bit mode.
197 */ 188 */
@@ -240,35 +231,29 @@ static struct tvp514x_std_info tvp514x_std_list[] = {
240 }, 231 },
241 /* Standard: need to add for additional standard */ 232 /* Standard: need to add for additional standard */
242}; 233};
243/* 234
244 * Control structure for Auto Gain 235
245 * This is temporary data, will get replaced once 236static inline struct tvp514x_decoder *to_decoder(struct v4l2_subdev *sd)
246 * v4l2_ctrl_query_fill supports it. 237{
247 */ 238 return container_of(sd, struct tvp514x_decoder, sd);
248static const struct v4l2_queryctrl tvp514x_autogain_ctrl = { 239}
249 .id = V4L2_CID_AUTOGAIN, 240
250 .name = "Gain, Automatic",
251 .type = V4L2_CTRL_TYPE_BOOLEAN,
252 .minimum = 0,
253 .maximum = 1,
254 .step = 1,
255 .default_value = 1,
256};
257 241
258/* 242/*
259 * Read a value from a register in an TVP5146/47 decoder device. 243 * Read a value from a register in an TVP5146/47 decoder device.
260 * Returns value read if successful, or non-zero (-1) otherwise. 244 * Returns value read if successful, or non-zero (-1) otherwise.
261 */ 245 */
262static int tvp514x_read_reg(struct i2c_client *client, u8 reg) 246static int tvp514x_read_reg(struct v4l2_subdev *sd, u8 reg)
263{ 247{
264 int err; 248 int err, retry = 0;
265 int retry = 0; 249 struct i2c_client *client = v4l2_get_subdevdata(sd);
250
266read_again: 251read_again:
267 252
268 err = i2c_smbus_read_byte_data(client, reg); 253 err = i2c_smbus_read_byte_data(client, reg);
269 if (err == -1) { 254 if (err == -1) {
270 if (retry <= I2C_RETRY_COUNT) { 255 if (retry <= I2C_RETRY_COUNT) {
271 v4l_warn(client, "Read: retry ... %d\n", retry); 256 v4l2_warn(sd, "Read: retry ... %d\n", retry);
272 retry++; 257 retry++;
273 msleep_interruptible(10); 258 msleep_interruptible(10);
274 goto read_again; 259 goto read_again;
@@ -278,20 +263,29 @@ read_again:
278 return err; 263 return err;
279} 264}
280 265
266static void dump_reg(struct v4l2_subdev *sd, u8 reg)
267{
268 u32 val;
269
270 val = tvp514x_read_reg(sd, reg);
271 v4l2_info(sd, "Reg(0x%.2X): 0x%.2X\n", reg, val);
272}
273
281/* 274/*
282 * Write a value to a register in an TVP5146/47 decoder device. 275 * Write a value to a register in an TVP5146/47 decoder device.
283 * Returns zero if successful, or non-zero otherwise. 276 * Returns zero if successful, or non-zero otherwise.
284 */ 277 */
285static int tvp514x_write_reg(struct i2c_client *client, u8 reg, u8 val) 278static int tvp514x_write_reg(struct v4l2_subdev *sd, u8 reg, u8 val)
286{ 279{
287 int err; 280 int err, retry = 0;
288 int retry = 0; 281 struct i2c_client *client = v4l2_get_subdevdata(sd);
282
289write_again: 283write_again:
290 284
291 err = i2c_smbus_write_byte_data(client, reg, val); 285 err = i2c_smbus_write_byte_data(client, reg, val);
292 if (err) { 286 if (err) {
293 if (retry <= I2C_RETRY_COUNT) { 287 if (retry <= I2C_RETRY_COUNT) {
294 v4l_warn(client, "Write: retry ... %d\n", retry); 288 v4l2_warn(sd, "Write: retry ... %d\n", retry);
295 retry++; 289 retry++;
296 msleep_interruptible(10); 290 msleep_interruptible(10);
297 goto write_again; 291 goto write_again;
@@ -311,7 +305,7 @@ write_again:
311 * reglist - list of registers to be written 305 * reglist - list of registers to be written
312 * Returns zero if successful, or non-zero otherwise. 306 * Returns zero if successful, or non-zero otherwise.
313 */ 307 */
314static int tvp514x_write_regs(struct i2c_client *client, 308static int tvp514x_write_regs(struct v4l2_subdev *sd,
315 const struct tvp514x_reg reglist[]) 309 const struct tvp514x_reg reglist[])
316{ 310{
317 int err; 311 int err;
@@ -326,9 +320,9 @@ static int tvp514x_write_regs(struct i2c_client *client,
326 if (next->token == TOK_SKIP) 320 if (next->token == TOK_SKIP)
327 continue; 321 continue;
328 322
329 err = tvp514x_write_reg(client, next->reg, (u8) next->val); 323 err = tvp514x_write_reg(sd, next->reg, (u8) next->val);
330 if (err) { 324 if (err) {
331 v4l_err(client, "Write failed. Err[%d]\n", err); 325 v4l2_err(sd, "Write failed. Err[%d]\n", err);
332 return err; 326 return err;
333 } 327 }
334 } 328 }
@@ -339,17 +333,15 @@ static int tvp514x_write_regs(struct i2c_client *client,
339 * tvp514x_get_current_std: 333 * tvp514x_get_current_std:
340 * Returns the current standard detected by TVP5146/47 334 * Returns the current standard detected by TVP5146/47
341 */ 335 */
342static enum tvp514x_std tvp514x_get_current_std(struct tvp514x_decoder 336static enum tvp514x_std tvp514x_get_current_std(struct v4l2_subdev *sd)
343 *decoder)
344{ 337{
345 u8 std, std_status; 338 u8 std, std_status;
346 339
347 std = tvp514x_read_reg(decoder->client, REG_VIDEO_STD); 340 std = tvp514x_read_reg(sd, REG_VIDEO_STD);
348 if ((std & VIDEO_STD_MASK) == VIDEO_STD_AUTO_SWITCH_BIT) { 341 if ((std & VIDEO_STD_MASK) == VIDEO_STD_AUTO_SWITCH_BIT)
349 /* use the standard status register */ 342 /* use the standard status register */
350 std_status = tvp514x_read_reg(decoder->client, 343 std_status = tvp514x_read_reg(sd, REG_VIDEO_STD_STATUS);
351 REG_VIDEO_STD_STATUS); 344 else
352 } else
353 std_status = std; /* use the standard register itself */ 345 std_status = std; /* use the standard register itself */
354 346
355 switch (std_status & VIDEO_STD_MASK) { 347 switch (std_status & VIDEO_STD_MASK) {
@@ -369,70 +361,69 @@ static enum tvp514x_std tvp514x_get_current_std(struct tvp514x_decoder
369/* 361/*
370 * TVP5146/47 register dump function 362 * TVP5146/47 register dump function
371 */ 363 */
372static void tvp514x_reg_dump(struct tvp514x_decoder *decoder) 364static void tvp514x_reg_dump(struct v4l2_subdev *sd)
373{ 365{
374 u8 value; 366 dump_reg(sd, REG_INPUT_SEL);
375 367 dump_reg(sd, REG_AFE_GAIN_CTRL);
376 dump_reg(decoder->client, REG_INPUT_SEL, value); 368 dump_reg(sd, REG_VIDEO_STD);
377 dump_reg(decoder->client, REG_AFE_GAIN_CTRL, value); 369 dump_reg(sd, REG_OPERATION_MODE);
378 dump_reg(decoder->client, REG_VIDEO_STD, value); 370 dump_reg(sd, REG_COLOR_KILLER);
379 dump_reg(decoder->client, REG_OPERATION_MODE, value); 371 dump_reg(sd, REG_LUMA_CONTROL1);
380 dump_reg(decoder->client, REG_COLOR_KILLER, value); 372 dump_reg(sd, REG_LUMA_CONTROL2);
381 dump_reg(decoder->client, REG_LUMA_CONTROL1, value); 373 dump_reg(sd, REG_LUMA_CONTROL3);
382 dump_reg(decoder->client, REG_LUMA_CONTROL2, value); 374 dump_reg(sd, REG_BRIGHTNESS);
383 dump_reg(decoder->client, REG_LUMA_CONTROL3, value); 375 dump_reg(sd, REG_CONTRAST);
384 dump_reg(decoder->client, REG_BRIGHTNESS, value); 376 dump_reg(sd, REG_SATURATION);
385 dump_reg(decoder->client, REG_CONTRAST, value); 377 dump_reg(sd, REG_HUE);
386 dump_reg(decoder->client, REG_SATURATION, value); 378 dump_reg(sd, REG_CHROMA_CONTROL1);
387 dump_reg(decoder->client, REG_HUE, value); 379 dump_reg(sd, REG_CHROMA_CONTROL2);
388 dump_reg(decoder->client, REG_CHROMA_CONTROL1, value); 380 dump_reg(sd, REG_COMP_PR_SATURATION);
389 dump_reg(decoder->client, REG_CHROMA_CONTROL2, value); 381 dump_reg(sd, REG_COMP_Y_CONTRAST);
390 dump_reg(decoder->client, REG_COMP_PR_SATURATION, value); 382 dump_reg(sd, REG_COMP_PB_SATURATION);
391 dump_reg(decoder->client, REG_COMP_Y_CONTRAST, value); 383 dump_reg(sd, REG_COMP_Y_BRIGHTNESS);
392 dump_reg(decoder->client, REG_COMP_PB_SATURATION, value); 384 dump_reg(sd, REG_AVID_START_PIXEL_LSB);
393 dump_reg(decoder->client, REG_COMP_Y_BRIGHTNESS, value); 385 dump_reg(sd, REG_AVID_START_PIXEL_MSB);
394 dump_reg(decoder->client, REG_AVID_START_PIXEL_LSB, value); 386 dump_reg(sd, REG_AVID_STOP_PIXEL_LSB);
395 dump_reg(decoder->client, REG_AVID_START_PIXEL_MSB, value); 387 dump_reg(sd, REG_AVID_STOP_PIXEL_MSB);
396 dump_reg(decoder->client, REG_AVID_STOP_PIXEL_LSB, value); 388 dump_reg(sd, REG_HSYNC_START_PIXEL_LSB);
397 dump_reg(decoder->client, REG_AVID_STOP_PIXEL_MSB, value); 389 dump_reg(sd, REG_HSYNC_START_PIXEL_MSB);
398 dump_reg(decoder->client, REG_HSYNC_START_PIXEL_LSB, value); 390 dump_reg(sd, REG_HSYNC_STOP_PIXEL_LSB);
399 dump_reg(decoder->client, REG_HSYNC_START_PIXEL_MSB, value); 391 dump_reg(sd, REG_HSYNC_STOP_PIXEL_MSB);
400 dump_reg(decoder->client, REG_HSYNC_STOP_PIXEL_LSB, value); 392 dump_reg(sd, REG_VSYNC_START_LINE_LSB);
401 dump_reg(decoder->client, REG_HSYNC_STOP_PIXEL_MSB, value); 393 dump_reg(sd, REG_VSYNC_START_LINE_MSB);
402 dump_reg(decoder->client, REG_VSYNC_START_LINE_LSB, value); 394 dump_reg(sd, REG_VSYNC_STOP_LINE_LSB);
403 dump_reg(decoder->client, REG_VSYNC_START_LINE_MSB, value); 395 dump_reg(sd, REG_VSYNC_STOP_LINE_MSB);
404 dump_reg(decoder->client, REG_VSYNC_STOP_LINE_LSB, value); 396 dump_reg(sd, REG_VBLK_START_LINE_LSB);
405 dump_reg(decoder->client, REG_VSYNC_STOP_LINE_MSB, value); 397 dump_reg(sd, REG_VBLK_START_LINE_MSB);
406 dump_reg(decoder->client, REG_VBLK_START_LINE_LSB, value); 398 dump_reg(sd, REG_VBLK_STOP_LINE_LSB);
407 dump_reg(decoder->client, REG_VBLK_START_LINE_MSB, value); 399 dump_reg(sd, REG_VBLK_STOP_LINE_MSB);
408 dump_reg(decoder->client, REG_VBLK_STOP_LINE_LSB, value); 400 dump_reg(sd, REG_SYNC_CONTROL);
409 dump_reg(decoder->client, REG_VBLK_STOP_LINE_MSB, value); 401 dump_reg(sd, REG_OUTPUT_FORMATTER1);
410 dump_reg(decoder->client, REG_SYNC_CONTROL, value); 402 dump_reg(sd, REG_OUTPUT_FORMATTER2);
411 dump_reg(decoder->client, REG_OUTPUT_FORMATTER1, value); 403 dump_reg(sd, REG_OUTPUT_FORMATTER3);
412 dump_reg(decoder->client, REG_OUTPUT_FORMATTER2, value); 404 dump_reg(sd, REG_OUTPUT_FORMATTER4);
413 dump_reg(decoder->client, REG_OUTPUT_FORMATTER3, value); 405 dump_reg(sd, REG_OUTPUT_FORMATTER5);
414 dump_reg(decoder->client, REG_OUTPUT_FORMATTER4, value); 406 dump_reg(sd, REG_OUTPUT_FORMATTER6);
415 dump_reg(decoder->client, REG_OUTPUT_FORMATTER5, value); 407 dump_reg(sd, REG_CLEAR_LOST_LOCK);
416 dump_reg(decoder->client, REG_OUTPUT_FORMATTER6, value);
417 dump_reg(decoder->client, REG_CLEAR_LOST_LOCK, value);
418} 408}
419 409
420/* 410/*
421 * Configure the TVP5146/47 with the current register settings 411 * Configure the TVP5146/47 with the current register settings
422 * Returns zero if successful, or non-zero otherwise. 412 * Returns zero if successful, or non-zero otherwise.
423 */ 413 */
424static int tvp514x_configure(struct tvp514x_decoder *decoder) 414static int tvp514x_configure(struct v4l2_subdev *sd,
415 struct tvp514x_decoder *decoder)
425{ 416{
426 int err; 417 int err;
427 418
428 /* common register initialization */ 419 /* common register initialization */
429 err = 420 err =
430 tvp514x_write_regs(decoder->client, decoder->tvp514x_regs); 421 tvp514x_write_regs(sd, decoder->tvp514x_regs);
431 if (err) 422 if (err)
432 return err; 423 return err;
433 424
434 if (debug) 425 if (debug)
435 tvp514x_reg_dump(decoder); 426 tvp514x_reg_dump(sd);
436 427
437 return 0; 428 return 0;
438} 429}
@@ -445,15 +436,17 @@ static int tvp514x_configure(struct tvp514x_decoder *decoder)
445 * Returns ENODEV error number if no device is detected, or zero 436 * Returns ENODEV error number if no device is detected, or zero
446 * if a device is detected. 437 * if a device is detected.
447 */ 438 */
448static int tvp514x_detect(struct tvp514x_decoder *decoder) 439static int tvp514x_detect(struct v4l2_subdev *sd,
440 struct tvp514x_decoder *decoder)
449{ 441{
450 u8 chip_id_msb, chip_id_lsb, rom_ver; 442 u8 chip_id_msb, chip_id_lsb, rom_ver;
443 struct i2c_client *client = v4l2_get_subdevdata(sd);
451 444
452 chip_id_msb = tvp514x_read_reg(decoder->client, REG_CHIP_ID_MSB); 445 chip_id_msb = tvp514x_read_reg(sd, REG_CHIP_ID_MSB);
453 chip_id_lsb = tvp514x_read_reg(decoder->client, REG_CHIP_ID_LSB); 446 chip_id_lsb = tvp514x_read_reg(sd, REG_CHIP_ID_LSB);
454 rom_ver = tvp514x_read_reg(decoder->client, REG_ROM_VERSION); 447 rom_ver = tvp514x_read_reg(sd, REG_ROM_VERSION);
455 448
456 v4l_dbg(1, debug, decoder->client, 449 v4l2_dbg(1, debug, sd,
457 "chip id detected msb:0x%x lsb:0x%x rom version:0x%x\n", 450 "chip id detected msb:0x%x lsb:0x%x rom version:0x%x\n",
458 chip_id_msb, chip_id_lsb, rom_ver); 451 chip_id_msb, chip_id_lsb, rom_ver);
459 if ((chip_id_msb != TVP514X_CHIP_ID_MSB) 452 if ((chip_id_msb != TVP514X_CHIP_ID_MSB)
@@ -462,19 +455,16 @@ static int tvp514x_detect(struct tvp514x_decoder *decoder)
462 /* We didn't read the values we expected, so this must not be 455 /* We didn't read the values we expected, so this must not be
463 * an TVP5146/47. 456 * an TVP5146/47.
464 */ 457 */
465 v4l_err(decoder->client, 458 v4l2_err(sd, "chip id mismatch msb:0x%x lsb:0x%x\n",
466 "chip id mismatch msb:0x%x lsb:0x%x\n", 459 chip_id_msb, chip_id_lsb);
467 chip_id_msb, chip_id_lsb);
468 return -ENODEV; 460 return -ENODEV;
469 } 461 }
470 462
471 decoder->ver = rom_ver; 463 decoder->ver = rom_ver;
472 decoder->state = STATE_DETECTED;
473 464
474 v4l_info(decoder->client, 465 v4l2_info(sd, "%s (Version - 0x%.2x) found at 0x%x (%s)\n",
475 "%s found at 0x%x (%s)\n", decoder->client->name, 466 client->name, decoder->ver,
476 decoder->client->addr << 1, 467 client->addr << 1, client->adapter->name);
477 decoder->client->adapter->name);
478 return 0; 468 return 0;
479} 469}
480 470
@@ -483,17 +473,17 @@ static int tvp514x_detect(struct tvp514x_decoder *decoder)
483 * TVP5146/47 decoder driver. 473 * TVP5146/47 decoder driver.
484 */ 474 */
485 475
486/** 476/*
487 * ioctl_querystd - V4L2 decoder interface handler for VIDIOC_QUERYSTD ioctl 477 * tvp514x_querystd - V4L2 decoder interface handler for VIDIOC_QUERYSTD ioctl
488 * @s: pointer to standard V4L2 device structure 478 * @sd: pointer to standard V4L2 sub-device structure
489 * @std_id: standard V4L2 std_id ioctl enum 479 * @std_id: standard V4L2 std_id ioctl enum
490 * 480 *
491 * Returns the current standard detected by TVP5146/47. If no active input is 481 * Returns the current standard detected by TVP5146/47. If no active input is
492 * detected, returns -EINVAL 482 * detected, returns -EINVAL
493 */ 483 */
494static int ioctl_querystd(struct v4l2_int_device *s, v4l2_std_id *std_id) 484static int tvp514x_querystd(struct v4l2_subdev *sd, v4l2_std_id *std_id)
495{ 485{
496 struct tvp514x_decoder *decoder = s->priv; 486 struct tvp514x_decoder *decoder = to_decoder(sd);
497 enum tvp514x_std current_std; 487 enum tvp514x_std current_std;
498 enum tvp514x_input input_sel; 488 enum tvp514x_input input_sel;
499 u8 sync_lock_status, lock_mask; 489 u8 sync_lock_status, lock_mask;
@@ -502,11 +492,11 @@ static int ioctl_querystd(struct v4l2_int_device *s, v4l2_std_id *std_id)
502 return -EINVAL; 492 return -EINVAL;
503 493
504 /* get the current standard */ 494 /* get the current standard */
505 current_std = tvp514x_get_current_std(decoder); 495 current_std = tvp514x_get_current_std(sd);
506 if (current_std == STD_INVALID) 496 if (current_std == STD_INVALID)
507 return -EINVAL; 497 return -EINVAL;
508 498
509 input_sel = decoder->route.input; 499 input_sel = decoder->input;
510 500
511 switch (input_sel) { 501 switch (input_sel) {
512 case INPUT_CVBS_VI1A: 502 case INPUT_CVBS_VI1A:
@@ -544,42 +534,39 @@ static int ioctl_querystd(struct v4l2_int_device *s, v4l2_std_id *std_id)
544 return -EINVAL; 534 return -EINVAL;
545 } 535 }
546 /* check whether signal is locked */ 536 /* check whether signal is locked */
547 sync_lock_status = tvp514x_read_reg(decoder->client, REG_STATUS1); 537 sync_lock_status = tvp514x_read_reg(sd, REG_STATUS1);
548 if (lock_mask != (sync_lock_status & lock_mask)) 538 if (lock_mask != (sync_lock_status & lock_mask))
549 return -EINVAL; /* No input detected */ 539 return -EINVAL; /* No input detected */
550 540
551 decoder->current_std = current_std; 541 decoder->current_std = current_std;
552 *std_id = decoder->std_list[current_std].standard.id; 542 *std_id = decoder->std_list[current_std].standard.id;
553 543
554 v4l_dbg(1, debug, decoder->client, "Current STD: %s", 544 v4l2_dbg(1, debug, sd, "Current STD: %s",
555 decoder->std_list[current_std].standard.name); 545 decoder->std_list[current_std].standard.name);
556 return 0; 546 return 0;
557} 547}
558 548
559/** 549/*
560 * ioctl_s_std - V4L2 decoder interface handler for VIDIOC_S_STD ioctl 550 * tvp514x_s_std - V4L2 decoder interface handler for VIDIOC_S_STD ioctl
561 * @s: pointer to standard V4L2 device structure 551 * @sd: pointer to standard V4L2 sub-device structure
562 * @std_id: standard V4L2 v4l2_std_id ioctl enum 552 * @std_id: standard V4L2 v4l2_std_id ioctl enum
563 * 553 *
564 * If std_id is supported, sets the requested standard. Otherwise, returns 554 * If std_id is supported, sets the requested standard. Otherwise, returns
565 * -EINVAL 555 * -EINVAL
566 */ 556 */
567static int ioctl_s_std(struct v4l2_int_device *s, v4l2_std_id *std_id) 557static int tvp514x_s_std(struct v4l2_subdev *sd, v4l2_std_id std_id)
568{ 558{
569 struct tvp514x_decoder *decoder = s->priv; 559 struct tvp514x_decoder *decoder = to_decoder(sd);
570 int err, i; 560 int err, i;
571 561
572 if (std_id == NULL)
573 return -EINVAL;
574
575 for (i = 0; i < decoder->num_stds; i++) 562 for (i = 0; i < decoder->num_stds; i++)
576 if (*std_id & decoder->std_list[i].standard.id) 563 if (std_id & decoder->std_list[i].standard.id)
577 break; 564 break;
578 565
579 if ((i == decoder->num_stds) || (i == STD_INVALID)) 566 if ((i == decoder->num_stds) || (i == STD_INVALID))
580 return -EINVAL; 567 return -EINVAL;
581 568
582 err = tvp514x_write_reg(decoder->client, REG_VIDEO_STD, 569 err = tvp514x_write_reg(sd, REG_VIDEO_STD,
583 decoder->std_list[i].video_std); 570 decoder->std_list[i].video_std);
584 if (err) 571 if (err)
585 return err; 572 return err;
@@ -588,24 +575,24 @@ static int ioctl_s_std(struct v4l2_int_device *s, v4l2_std_id *std_id)
588 decoder->tvp514x_regs[REG_VIDEO_STD].val = 575 decoder->tvp514x_regs[REG_VIDEO_STD].val =
589 decoder->std_list[i].video_std; 576 decoder->std_list[i].video_std;
590 577
591 v4l_dbg(1, debug, decoder->client, "Standard set to: %s", 578 v4l2_dbg(1, debug, sd, "Standard set to: %s",
592 decoder->std_list[i].standard.name); 579 decoder->std_list[i].standard.name);
593 return 0; 580 return 0;
594} 581}
595 582
596/** 583/*
597 * ioctl_s_routing - V4L2 decoder interface handler for VIDIOC_S_INPUT ioctl 584 * tvp514x_s_routing - V4L2 decoder interface handler for VIDIOC_S_INPUT ioctl
598 * @s: pointer to standard V4L2 device structure 585 * @sd: pointer to standard V4L2 sub-device structure
599 * @index: number of the input 586 * @index: number of the input
600 * 587 *
601 * If index is valid, selects the requested input. Otherwise, returns -EINVAL if 588 * If index is valid, selects the requested input. Otherwise, returns -EINVAL if
602 * the input is not supported or there is no active signal present in the 589 * the input is not supported or there is no active signal present in the
603 * selected input. 590 * selected input.
604 */ 591 */
605static int ioctl_s_routing(struct v4l2_int_device *s, 592static int tvp514x_s_routing(struct v4l2_subdev *sd,
606 struct v4l2_routing *route) 593 u32 input, u32 output, u32 config)
607{ 594{
608 struct tvp514x_decoder *decoder = s->priv; 595 struct tvp514x_decoder *decoder = to_decoder(sd);
609 int err; 596 int err;
610 enum tvp514x_input input_sel; 597 enum tvp514x_input input_sel;
611 enum tvp514x_output output_sel; 598 enum tvp514x_output output_sel;
@@ -613,20 +600,20 @@ static int ioctl_s_routing(struct v4l2_int_device *s,
613 u8 sync_lock_status, lock_mask; 600 u8 sync_lock_status, lock_mask;
614 int try_count = LOCK_RETRY_COUNT; 601 int try_count = LOCK_RETRY_COUNT;
615 602
616 if ((!route) || (route->input >= INPUT_INVALID) || 603 if ((input >= INPUT_INVALID) ||
617 (route->output >= OUTPUT_INVALID)) 604 (output >= OUTPUT_INVALID))
618 return -EINVAL; /* Index out of bound */ 605 return -EINVAL; /* Index out of bound */
619 606
620 input_sel = route->input; 607 input_sel = input;
621 output_sel = route->output; 608 output_sel = output;
622 609
623 err = tvp514x_write_reg(decoder->client, REG_INPUT_SEL, input_sel); 610 err = tvp514x_write_reg(sd, REG_INPUT_SEL, input_sel);
624 if (err) 611 if (err)
625 return err; 612 return err;
626 613
627 output_sel |= tvp514x_read_reg(decoder->client, 614 output_sel |= tvp514x_read_reg(sd,
628 REG_OUTPUT_FORMATTER1) & 0x7; 615 REG_OUTPUT_FORMATTER1) & 0x7;
629 err = tvp514x_write_reg(decoder->client, REG_OUTPUT_FORMATTER1, 616 err = tvp514x_write_reg(sd, REG_OUTPUT_FORMATTER1,
630 output_sel); 617 output_sel);
631 if (err) 618 if (err)
632 return err; 619 return err;
@@ -637,7 +624,7 @@ static int ioctl_s_routing(struct v4l2_int_device *s,
637 /* Clear status */ 624 /* Clear status */
638 msleep(LOCK_RETRY_DELAY); 625 msleep(LOCK_RETRY_DELAY);
639 err = 626 err =
640 tvp514x_write_reg(decoder->client, REG_CLEAR_LOST_LOCK, 0x01); 627 tvp514x_write_reg(sd, REG_CLEAR_LOST_LOCK, 0x01);
641 if (err) 628 if (err)
642 return err; 629 return err;
643 630
@@ -682,11 +669,11 @@ static int ioctl_s_routing(struct v4l2_int_device *s,
682 msleep(LOCK_RETRY_DELAY); 669 msleep(LOCK_RETRY_DELAY);
683 670
684 /* get the current standard for future reference */ 671 /* get the current standard for future reference */
685 current_std = tvp514x_get_current_std(decoder); 672 current_std = tvp514x_get_current_std(sd);
686 if (current_std == STD_INVALID) 673 if (current_std == STD_INVALID)
687 continue; 674 continue;
688 675
689 sync_lock_status = tvp514x_read_reg(decoder->client, 676 sync_lock_status = tvp514x_read_reg(sd,
690 REG_STATUS1); 677 REG_STATUS1);
691 if (lock_mask == (sync_lock_status & lock_mask)) 678 if (lock_mask == (sync_lock_status & lock_mask))
692 break; /* Input detected */ 679 break; /* Input detected */
@@ -696,28 +683,26 @@ static int ioctl_s_routing(struct v4l2_int_device *s,
696 return -EINVAL; 683 return -EINVAL;
697 684
698 decoder->current_std = current_std; 685 decoder->current_std = current_std;
699 decoder->route.input = route->input; 686 decoder->input = input;
700 decoder->route.output = route->output; 687 decoder->output = output;
701 688
702 v4l_dbg(1, debug, decoder->client, 689 v4l2_dbg(1, debug, sd, "Input set to: %d, std : %d",
703 "Input set to: %d, std : %d",
704 input_sel, current_std); 690 input_sel, current_std);
705 691
706 return 0; 692 return 0;
707} 693}
708 694
709/** 695/*
710 * ioctl_queryctrl - V4L2 decoder interface handler for VIDIOC_QUERYCTRL ioctl 696 * tvp514x_queryctrl - V4L2 decoder interface handler for VIDIOC_QUERYCTRL ioctl
711 * @s: pointer to standard V4L2 device structure 697 * @sd: pointer to standard V4L2 sub-device structure
712 * @qctrl: standard V4L2 v4l2_queryctrl structure 698 * @qctrl: standard V4L2 v4l2_queryctrl structure
713 * 699 *
714 * If the requested control is supported, returns the control information. 700 * If the requested control is supported, returns the control information.
715 * Otherwise, returns -EINVAL if the control is not supported. 701 * Otherwise, returns -EINVAL if the control is not supported.
716 */ 702 */
717static int 703static int
718ioctl_queryctrl(struct v4l2_int_device *s, struct v4l2_queryctrl *qctrl) 704tvp514x_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qctrl)
719{ 705{
720 struct tvp514x_decoder *decoder = s->priv;
721 int err = -EINVAL; 706 int err = -EINVAL;
722 707
723 if (qctrl == NULL) 708 if (qctrl == NULL)
@@ -744,30 +729,27 @@ ioctl_queryctrl(struct v4l2_int_device *s, struct v4l2_queryctrl *qctrl)
744 err = v4l2_ctrl_query_fill(qctrl, -180, 180, 180, 0); 729 err = v4l2_ctrl_query_fill(qctrl, -180, 180, 180, 0);
745 break; 730 break;
746 case V4L2_CID_AUTOGAIN: 731 case V4L2_CID_AUTOGAIN:
747 /* Autogain is either 0 or 1*/ 732 /*
748 memcpy(qctrl, &tvp514x_autogain_ctrl, 733 * Auto Gain supported is -
749 sizeof(struct v4l2_queryctrl)); 734 * 0 - 1 (Default - 1)
750 err = 0; 735 */
736 err = v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
751 break; 737 break;
752 default: 738 default:
753 v4l_err(decoder->client, 739 v4l2_err(sd, "invalid control id %d\n", qctrl->id);
754 "invalid control id %d\n", qctrl->id);
755 return err; 740 return err;
756 } 741 }
757 742
758 v4l_dbg(1, debug, decoder->client, 743 v4l2_dbg(1, debug, sd, "Query Control:%s: Min - %d, Max - %d, Def - %d",
759 "Query Control: %s : Min - %d, Max - %d, Def - %d", 744 qctrl->name, qctrl->minimum, qctrl->maximum,
760 qctrl->name,
761 qctrl->minimum,
762 qctrl->maximum,
763 qctrl->default_value); 745 qctrl->default_value);
764 746
765 return err; 747 return err;
766} 748}
767 749
768/** 750/*
769 * ioctl_g_ctrl - V4L2 decoder interface handler for VIDIOC_G_CTRL ioctl 751 * tvp514x_g_ctrl - V4L2 decoder interface handler for VIDIOC_G_CTRL ioctl
770 * @s: pointer to standard V4L2 device structure 752 * @sd: pointer to standard V4L2 sub-device structure
771 * @ctrl: pointer to v4l2_control structure 753 * @ctrl: pointer to v4l2_control structure
772 * 754 *
773 * If the requested control is supported, returns the control's current 755 * If the requested control is supported, returns the control's current
@@ -775,9 +757,9 @@ ioctl_queryctrl(struct v4l2_int_device *s, struct v4l2_queryctrl *qctrl)
775 * supported. 757 * supported.
776 */ 758 */
777static int 759static int
778ioctl_g_ctrl(struct v4l2_int_device *s, struct v4l2_control *ctrl) 760tvp514x_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
779{ 761{
780 struct tvp514x_decoder *decoder = s->priv; 762 struct tvp514x_decoder *decoder = to_decoder(sd);
781 763
782 if (ctrl == NULL) 764 if (ctrl == NULL)
783 return -EINVAL; 765 return -EINVAL;
@@ -811,74 +793,70 @@ ioctl_g_ctrl(struct v4l2_int_device *s, struct v4l2_control *ctrl)
811 793
812 break; 794 break;
813 default: 795 default:
814 v4l_err(decoder->client, 796 v4l2_err(sd, "invalid control id %d\n", ctrl->id);
815 "invalid control id %d\n", ctrl->id);
816 return -EINVAL; 797 return -EINVAL;
817 } 798 }
818 799
819 v4l_dbg(1, debug, decoder->client, 800 v4l2_dbg(1, debug, sd, "Get Control: ID - %d - %d",
820 "Get Control: ID - %d - %d",
821 ctrl->id, ctrl->value); 801 ctrl->id, ctrl->value);
822 return 0; 802 return 0;
823} 803}
824 804
825/** 805/*
826 * ioctl_s_ctrl - V4L2 decoder interface handler for VIDIOC_S_CTRL ioctl 806 * tvp514x_s_ctrl - V4L2 decoder interface handler for VIDIOC_S_CTRL ioctl
827 * @s: pointer to standard V4L2 device structure 807 * @sd: pointer to standard V4L2 sub-device structure
828 * @ctrl: pointer to v4l2_control structure 808 * @ctrl: pointer to v4l2_control structure
829 * 809 *
830 * If the requested control is supported, sets the control's current 810 * If the requested control is supported, sets the control's current
831 * value in HW. Otherwise, returns -EINVAL if the control is not supported. 811 * value in HW. Otherwise, returns -EINVAL if the control is not supported.
832 */ 812 */
833static int 813static int
834ioctl_s_ctrl(struct v4l2_int_device *s, struct v4l2_control *ctrl) 814tvp514x_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
835{ 815{
836 struct tvp514x_decoder *decoder = s->priv; 816 struct tvp514x_decoder *decoder = to_decoder(sd);
837 int err = -EINVAL, value; 817 int err = -EINVAL, value;
838 818
839 if (ctrl == NULL) 819 if (ctrl == NULL)
840 return err; 820 return err;
841 821
842 value = (__s32) ctrl->value; 822 value = ctrl->value;
843 823
844 switch (ctrl->id) { 824 switch (ctrl->id) {
845 case V4L2_CID_BRIGHTNESS: 825 case V4L2_CID_BRIGHTNESS:
846 if (ctrl->value < 0 || ctrl->value > 255) { 826 if (ctrl->value < 0 || ctrl->value > 255) {
847 v4l_err(decoder->client, 827 v4l2_err(sd, "invalid brightness setting %d\n",
848 "invalid brightness setting %d\n",
849 ctrl->value); 828 ctrl->value);
850 return -ERANGE; 829 return -ERANGE;
851 } 830 }
852 err = tvp514x_write_reg(decoder->client, REG_BRIGHTNESS, 831 err = tvp514x_write_reg(sd, REG_BRIGHTNESS,
853 value); 832 value);
854 if (err) 833 if (err)
855 return err; 834 return err;
835
856 decoder->tvp514x_regs[REG_BRIGHTNESS].val = value; 836 decoder->tvp514x_regs[REG_BRIGHTNESS].val = value;
857 break; 837 break;
858 case V4L2_CID_CONTRAST: 838 case V4L2_CID_CONTRAST:
859 if (ctrl->value < 0 || ctrl->value > 255) { 839 if (ctrl->value < 0 || ctrl->value > 255) {
860 v4l_err(decoder->client, 840 v4l2_err(sd, "invalid contrast setting %d\n",
861 "invalid contrast setting %d\n",
862 ctrl->value); 841 ctrl->value);
863 return -ERANGE; 842 return -ERANGE;
864 } 843 }
865 err = tvp514x_write_reg(decoder->client, REG_CONTRAST, 844 err = tvp514x_write_reg(sd, REG_CONTRAST, value);
866 value);
867 if (err) 845 if (err)
868 return err; 846 return err;
847
869 decoder->tvp514x_regs[REG_CONTRAST].val = value; 848 decoder->tvp514x_regs[REG_CONTRAST].val = value;
870 break; 849 break;
871 case V4L2_CID_SATURATION: 850 case V4L2_CID_SATURATION:
872 if (ctrl->value < 0 || ctrl->value > 255) { 851 if (ctrl->value < 0 || ctrl->value > 255) {
873 v4l_err(decoder->client, 852 v4l2_err(sd, "invalid saturation setting %d\n",
874 "invalid saturation setting %d\n",
875 ctrl->value); 853 ctrl->value);
876 return -ERANGE; 854 return -ERANGE;
877 } 855 }
878 err = tvp514x_write_reg(decoder->client, REG_SATURATION, 856 err = tvp514x_write_reg(sd, REG_SATURATION, value);
879 value);
880 if (err) 857 if (err)
881 return err; 858 return err;
859
882 decoder->tvp514x_regs[REG_SATURATION].val = value; 860 decoder->tvp514x_regs[REG_SATURATION].val = value;
883 break; 861 break;
884 case V4L2_CID_HUE: 862 case V4L2_CID_HUE:
@@ -889,15 +867,13 @@ ioctl_s_ctrl(struct v4l2_int_device *s, struct v4l2_control *ctrl)
889 else if (value == 0) 867 else if (value == 0)
890 value = 0; 868 value = 0;
891 else { 869 else {
892 v4l_err(decoder->client, 870 v4l2_err(sd, "invalid hue setting %d\n", ctrl->value);
893 "invalid hue setting %d\n",
894 ctrl->value);
895 return -ERANGE; 871 return -ERANGE;
896 } 872 }
897 err = tvp514x_write_reg(decoder->client, REG_HUE, 873 err = tvp514x_write_reg(sd, REG_HUE, value);
898 value);
899 if (err) 874 if (err)
900 return err; 875 return err;
876
901 decoder->tvp514x_regs[REG_HUE].val = value; 877 decoder->tvp514x_regs[REG_HUE].val = value;
902 break; 878 break;
903 case V4L2_CID_AUTOGAIN: 879 case V4L2_CID_AUTOGAIN:
@@ -906,41 +882,38 @@ ioctl_s_ctrl(struct v4l2_int_device *s, struct v4l2_control *ctrl)
906 else if (value == 0) 882 else if (value == 0)
907 value = 0x0C; 883 value = 0x0C;
908 else { 884 else {
909 v4l_err(decoder->client, 885 v4l2_err(sd, "invalid auto gain setting %d\n",
910 "invalid auto gain setting %d\n",
911 ctrl->value); 886 ctrl->value);
912 return -ERANGE; 887 return -ERANGE;
913 } 888 }
914 err = tvp514x_write_reg(decoder->client, REG_AFE_GAIN_CTRL, 889 err = tvp514x_write_reg(sd, REG_AFE_GAIN_CTRL, value);
915 value);
916 if (err) 890 if (err)
917 return err; 891 return err;
892
918 decoder->tvp514x_regs[REG_AFE_GAIN_CTRL].val = value; 893 decoder->tvp514x_regs[REG_AFE_GAIN_CTRL].val = value;
919 break; 894 break;
920 default: 895 default:
921 v4l_err(decoder->client, 896 v4l2_err(sd, "invalid control id %d\n", ctrl->id);
922 "invalid control id %d\n", ctrl->id);
923 return err; 897 return err;
924 } 898 }
925 899
926 v4l_dbg(1, debug, decoder->client, 900 v4l2_dbg(1, debug, sd, "Set Control: ID - %d - %d",
927 "Set Control: ID - %d - %d",
928 ctrl->id, ctrl->value); 901 ctrl->id, ctrl->value);
929 902
930 return err; 903 return err;
931} 904}
932 905
933/** 906/*
934 * ioctl_enum_fmt_cap - Implement the CAPTURE buffer VIDIOC_ENUM_FMT ioctl 907 * tvp514x_enum_fmt_cap - Implement the CAPTURE buffer VIDIOC_ENUM_FMT ioctl
935 * @s: pointer to standard V4L2 device structure 908 * @sd: pointer to standard V4L2 sub-device structure
936 * @fmt: standard V4L2 VIDIOC_ENUM_FMT ioctl structure 909 * @fmt: standard V4L2 VIDIOC_ENUM_FMT ioctl structure
937 * 910 *
938 * Implement the VIDIOC_ENUM_FMT ioctl to enumerate supported formats 911 * Implement the VIDIOC_ENUM_FMT ioctl to enumerate supported formats
939 */ 912 */
940static int 913static int
941ioctl_enum_fmt_cap(struct v4l2_int_device *s, struct v4l2_fmtdesc *fmt) 914tvp514x_enum_fmt_cap(struct v4l2_subdev *sd, struct v4l2_fmtdesc *fmt)
942{ 915{
943 struct tvp514x_decoder *decoder = s->priv; 916 struct tvp514x_decoder *decoder = to_decoder(sd);
944 int index; 917 int index;
945 918
946 if (fmt == NULL) 919 if (fmt == NULL)
@@ -956,16 +929,15 @@ ioctl_enum_fmt_cap(struct v4l2_int_device *s, struct v4l2_fmtdesc *fmt)
956 memcpy(fmt, &decoder->fmt_list[index], 929 memcpy(fmt, &decoder->fmt_list[index],
957 sizeof(struct v4l2_fmtdesc)); 930 sizeof(struct v4l2_fmtdesc));
958 931
959 v4l_dbg(1, debug, decoder->client, 932 v4l2_dbg(1, debug, sd, "Current FMT: index - %d (%s)",
960 "Current FMT: index - %d (%s)",
961 decoder->fmt_list[index].index, 933 decoder->fmt_list[index].index,
962 decoder->fmt_list[index].description); 934 decoder->fmt_list[index].description);
963 return 0; 935 return 0;
964} 936}
965 937
966/** 938/*
967 * ioctl_try_fmt_cap - Implement the CAPTURE buffer VIDIOC_TRY_FMT ioctl 939 * tvp514x_try_fmt_cap - Implement the CAPTURE buffer VIDIOC_TRY_FMT ioctl
968 * @s: pointer to standard V4L2 device structure 940 * @sd: pointer to standard V4L2 sub-device structure
969 * @f: pointer to standard V4L2 VIDIOC_TRY_FMT ioctl structure 941 * @f: pointer to standard V4L2 VIDIOC_TRY_FMT ioctl structure
970 * 942 *
971 * Implement the VIDIOC_TRY_FMT ioctl for the CAPTURE buffer type. This 943 * Implement the VIDIOC_TRY_FMT ioctl for the CAPTURE buffer type. This
@@ -973,9 +945,9 @@ ioctl_enum_fmt_cap(struct v4l2_int_device *s, struct v4l2_fmtdesc *fmt)
973 * without actually making it take effect. 945 * without actually making it take effect.
974 */ 946 */
975static int 947static int
976ioctl_try_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f) 948tvp514x_try_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
977{ 949{
978 struct tvp514x_decoder *decoder = s->priv; 950 struct tvp514x_decoder *decoder = to_decoder(sd);
979 int ifmt; 951 int ifmt;
980 struct v4l2_pix_format *pix; 952 struct v4l2_pix_format *pix;
981 enum tvp514x_std current_std; 953 enum tvp514x_std current_std;
@@ -989,7 +961,7 @@ ioctl_try_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
989 pix = &f->fmt.pix; 961 pix = &f->fmt.pix;
990 962
991 /* Calculate height and width based on current standard */ 963 /* Calculate height and width based on current standard */
992 current_std = tvp514x_get_current_std(decoder); 964 current_std = tvp514x_get_current_std(sd);
993 if (current_std == STD_INVALID) 965 if (current_std == STD_INVALID)
994 return -EINVAL; 966 return -EINVAL;
995 967
@@ -1012,17 +984,16 @@ ioctl_try_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
1012 pix->colorspace = V4L2_COLORSPACE_SMPTE170M; 984 pix->colorspace = V4L2_COLORSPACE_SMPTE170M;
1013 pix->priv = 0; 985 pix->priv = 0;
1014 986
1015 v4l_dbg(1, debug, decoder->client, 987 v4l2_dbg(1, debug, sd, "Try FMT: pixelformat - %s, bytesperline - %d"
1016 "Try FMT: pixelformat - %s, bytesperline - %d"
1017 "Width - %d, Height - %d", 988 "Width - %d, Height - %d",
1018 decoder->fmt_list[ifmt].description, pix->bytesperline, 989 decoder->fmt_list[ifmt].description, pix->bytesperline,
1019 pix->width, pix->height); 990 pix->width, pix->height);
1020 return 0; 991 return 0;
1021} 992}
1022 993
1023/** 994/*
1024 * ioctl_s_fmt_cap - V4L2 decoder interface handler for VIDIOC_S_FMT ioctl 995 * tvp514x_s_fmt_cap - V4L2 decoder interface handler for VIDIOC_S_FMT ioctl
1025 * @s: pointer to standard V4L2 device structure 996 * @sd: pointer to standard V4L2 sub-device structure
1026 * @f: pointer to standard V4L2 VIDIOC_S_FMT ioctl structure 997 * @f: pointer to standard V4L2 VIDIOC_S_FMT ioctl structure
1027 * 998 *
1028 * If the requested format is supported, configures the HW to use that 999 * If the requested format is supported, configures the HW to use that
@@ -1030,9 +1001,9 @@ ioctl_try_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
1030 * correctly configured. 1001 * correctly configured.
1031 */ 1002 */
1032static int 1003static int
1033ioctl_s_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f) 1004tvp514x_s_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
1034{ 1005{
1035 struct tvp514x_decoder *decoder = s->priv; 1006 struct tvp514x_decoder *decoder = to_decoder(sd);
1036 struct v4l2_pix_format *pix; 1007 struct v4l2_pix_format *pix;
1037 int rval; 1008 int rval;
1038 1009
@@ -1043,7 +1014,7 @@ ioctl_s_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
1043 return -EINVAL; /* only capture is supported */ 1014 return -EINVAL; /* only capture is supported */
1044 1015
1045 pix = &f->fmt.pix; 1016 pix = &f->fmt.pix;
1046 rval = ioctl_try_fmt_cap(s, f); 1017 rval = tvp514x_try_fmt_cap(sd, f);
1047 if (rval) 1018 if (rval)
1048 return rval; 1019 return rval;
1049 1020
@@ -1052,18 +1023,18 @@ ioctl_s_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
1052 return rval; 1023 return rval;
1053} 1024}
1054 1025
1055/** 1026/*
1056 * ioctl_g_fmt_cap - V4L2 decoder interface handler for ioctl_g_fmt_cap 1027 * tvp514x_g_fmt_cap - V4L2 decoder interface handler for tvp514x_g_fmt_cap
1057 * @s: pointer to standard V4L2 device structure 1028 * @sd: pointer to standard V4L2 sub-device structure
1058 * @f: pointer to standard V4L2 v4l2_format structure 1029 * @f: pointer to standard V4L2 v4l2_format structure
1059 * 1030 *
1060 * Returns the decoder's current pixel format in the v4l2_format 1031 * Returns the decoder's current pixel format in the v4l2_format
1061 * parameter. 1032 * parameter.
1062 */ 1033 */
1063static int 1034static int
1064ioctl_g_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f) 1035tvp514x_g_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
1065{ 1036{
1066 struct tvp514x_decoder *decoder = s->priv; 1037 struct tvp514x_decoder *decoder = to_decoder(sd);
1067 1038
1068 if (f == NULL) 1039 if (f == NULL)
1069 return -EINVAL; 1040 return -EINVAL;
@@ -1073,25 +1044,24 @@ ioctl_g_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
1073 1044
1074 f->fmt.pix = decoder->pix; 1045 f->fmt.pix = decoder->pix;
1075 1046
1076 v4l_dbg(1, debug, decoder->client, 1047 v4l2_dbg(1, debug, sd, "Current FMT: bytesperline - %d"
1077 "Current FMT: bytesperline - %d"
1078 "Width - %d, Height - %d", 1048 "Width - %d, Height - %d",
1079 decoder->pix.bytesperline, 1049 decoder->pix.bytesperline,
1080 decoder->pix.width, decoder->pix.height); 1050 decoder->pix.width, decoder->pix.height);
1081 return 0; 1051 return 0;
1082} 1052}
1083 1053
1084/** 1054/*
1085 * ioctl_g_parm - V4L2 decoder interface handler for VIDIOC_G_PARM ioctl 1055 * tvp514x_g_parm - V4L2 decoder interface handler for VIDIOC_G_PARM ioctl
1086 * @s: pointer to standard V4L2 device structure 1056 * @sd: pointer to standard V4L2 sub-device structure
1087 * @a: pointer to standard V4L2 VIDIOC_G_PARM ioctl structure 1057 * @a: pointer to standard V4L2 VIDIOC_G_PARM ioctl structure
1088 * 1058 *
1089 * Returns the decoder's video CAPTURE parameters. 1059 * Returns the decoder's video CAPTURE parameters.
1090 */ 1060 */
1091static int 1061static int
1092ioctl_g_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a) 1062tvp514x_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
1093{ 1063{
1094 struct tvp514x_decoder *decoder = s->priv; 1064 struct tvp514x_decoder *decoder = to_decoder(sd);
1095 struct v4l2_captureparm *cparm; 1065 struct v4l2_captureparm *cparm;
1096 enum tvp514x_std current_std; 1066 enum tvp514x_std current_std;
1097 1067
@@ -1105,7 +1075,7 @@ ioctl_g_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a)
1105 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1075 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1106 1076
1107 /* get the current standard */ 1077 /* get the current standard */
1108 current_std = tvp514x_get_current_std(decoder); 1078 current_std = tvp514x_get_current_std(sd);
1109 if (current_std == STD_INVALID) 1079 if (current_std == STD_INVALID)
1110 return -EINVAL; 1080 return -EINVAL;
1111 1081
@@ -1119,18 +1089,18 @@ ioctl_g_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a)
1119 return 0; 1089 return 0;
1120} 1090}
1121 1091
1122/** 1092/*
1123 * ioctl_s_parm - V4L2 decoder interface handler for VIDIOC_S_PARM ioctl 1093 * tvp514x_s_parm - V4L2 decoder interface handler for VIDIOC_S_PARM ioctl
1124 * @s: pointer to standard V4L2 device structure 1094 * @sd: pointer to standard V4L2 sub-device structure
1125 * @a: pointer to standard V4L2 VIDIOC_S_PARM ioctl structure 1095 * @a: pointer to standard V4L2 VIDIOC_S_PARM ioctl structure
1126 * 1096 *
1127 * Configures the decoder to use the input parameters, if possible. If 1097 * Configures the decoder to use the input parameters, if possible. If
1128 * not possible, returns the appropriate error code. 1098 * not possible, returns the appropriate error code.
1129 */ 1099 */
1130static int 1100static int
1131ioctl_s_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a) 1101tvp514x_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
1132{ 1102{
1133 struct tvp514x_decoder *decoder = s->priv; 1103 struct tvp514x_decoder *decoder = to_decoder(sd);
1134 struct v4l2_fract *timeperframe; 1104 struct v4l2_fract *timeperframe;
1135 enum tvp514x_std current_std; 1105 enum tvp514x_std current_std;
1136 1106
@@ -1143,7 +1113,7 @@ ioctl_s_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a)
1143 timeperframe = &a->parm.capture.timeperframe; 1113 timeperframe = &a->parm.capture.timeperframe;
1144 1114
1145 /* get the current standard */ 1115 /* get the current standard */
1146 current_std = tvp514x_get_current_std(decoder); 1116 current_std = tvp514x_get_current_std(sd);
1147 if (current_std == STD_INVALID) 1117 if (current_std == STD_INVALID)
1148 return -EINVAL; 1118 return -EINVAL;
1149 1119
@@ -1155,112 +1125,59 @@ ioctl_s_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a)
1155 return 0; 1125 return 0;
1156} 1126}
1157 1127
1158/** 1128/*
1159 * ioctl_g_ifparm - V4L2 decoder interface handler for vidioc_int_g_ifparm_num 1129 * tvp514x_s_stream - V4L2 decoder interface handler for vidioc_int_s_power_num
1160 * @s: pointer to standard V4L2 device structure 1130 * @sd: pointer to standard V4L2 sub-device structure
1161 * @p: pointer to standard V4L2 vidioc_int_g_ifparm_num ioctl structure 1131 * @enable: streaming enable or disable
1162 *
1163 * Gets slave interface parameters.
1164 * Calculates the required xclk value to support the requested
1165 * clock parameters in p. This value is returned in the p
1166 * parameter.
1167 */
1168static int ioctl_g_ifparm(struct v4l2_int_device *s, struct v4l2_ifparm *p)
1169{
1170 struct tvp514x_decoder *decoder = s->priv;
1171 int rval;
1172
1173 if (p == NULL)
1174 return -EINVAL;
1175
1176 if (NULL == decoder->pdata->ifparm)
1177 return -EINVAL;
1178
1179 rval = decoder->pdata->ifparm(p);
1180 if (rval) {
1181 v4l_err(decoder->client, "g_ifparm.Err[%d]\n", rval);
1182 return rval;
1183 }
1184
1185 p->u.bt656.clock_curr = TVP514X_XCLK_BT656;
1186
1187 return 0;
1188}
1189
1190/**
1191 * ioctl_g_priv - V4L2 decoder interface handler for vidioc_int_g_priv_num
1192 * @s: pointer to standard V4L2 device structure
1193 * @p: void pointer to hold decoder's private data address
1194 *
1195 * Returns device's (decoder's) private data area address in p parameter
1196 */
1197static int ioctl_g_priv(struct v4l2_int_device *s, void *p)
1198{
1199 struct tvp514x_decoder *decoder = s->priv;
1200
1201 if (NULL == decoder->pdata->priv_data_set)
1202 return -EINVAL;
1203
1204 return decoder->pdata->priv_data_set(p);
1205}
1206
1207/**
1208 * ioctl_s_power - V4L2 decoder interface handler for vidioc_int_s_power_num
1209 * @s: pointer to standard V4L2 device structure
1210 * @on: power state to which device is to be set
1211 * 1132 *
1212 * Sets devices power state to requrested state, if possible. 1133 * Sets streaming to enable or disable, if possible.
1213 */ 1134 */
1214static int ioctl_s_power(struct v4l2_int_device *s, enum v4l2_power on) 1135static int tvp514x_s_stream(struct v4l2_subdev *sd, int enable)
1215{ 1136{
1216 struct tvp514x_decoder *decoder = s->priv;
1217 int err = 0; 1137 int err = 0;
1138 struct i2c_client *client = v4l2_get_subdevdata(sd);
1139 struct tvp514x_decoder *decoder = to_decoder(sd);
1218 1140
1219 switch (on) { 1141 if (decoder->streaming == enable)
1220 case V4L2_POWER_OFF: 1142 return 0;
1221 /* Power Down Sequence */
1222 err =
1223 tvp514x_write_reg(decoder->client, REG_OPERATION_MODE,
1224 0x01);
1225 /* Disable mux for TVP5146/47 decoder data path */
1226 if (decoder->pdata->power_set)
1227 err |= decoder->pdata->power_set(on);
1228 decoder->state = STATE_NOT_DETECTED;
1229 break;
1230 1143
1231 case V4L2_POWER_STANDBY: 1144 switch (enable) {
1232 if (decoder->pdata->power_set) 1145 case 0:
1233 err = decoder->pdata->power_set(on); 1146 {
1147 /* Power Down Sequence */
1148 err = tvp514x_write_reg(sd, REG_OPERATION_MODE, 0x01);
1149 if (err) {
1150 v4l2_err(sd, "Unable to turn off decoder\n");
1151 return err;
1152 }
1153 decoder->streaming = enable;
1234 break; 1154 break;
1155 }
1156 case 1:
1157 {
1158 struct tvp514x_reg *int_seq = (struct tvp514x_reg *)
1159 client->driver->id_table->driver_data;
1235 1160
1236 case V4L2_POWER_ON: 1161 /* Power Up Sequence */
1237 /* Enable mux for TVP5146/47 decoder data path */ 1162 err = tvp514x_write_regs(sd, int_seq);
1238 if ((decoder->pdata->power_set) && 1163 if (err) {
1239 (decoder->state == STATE_NOT_DETECTED)) { 1164 v4l2_err(sd, "Unable to turn on decoder\n");
1240 int i; 1165 return err;
1241 struct tvp514x_init_seq *int_seq = 1166 }
1242 (struct tvp514x_init_seq *) 1167 /* Detect if not already detected */
1243 decoder->id->driver_data; 1168 err = tvp514x_detect(sd, decoder);
1244 1169 if (err) {
1245 err = decoder->pdata->power_set(on); 1170 v4l2_err(sd, "Unable to detect decoder\n");
1246 1171 return err;
1247 /* Power Up Sequence */
1248 for (i = 0; i < int_seq->no_regs; i++) {
1249 err |= tvp514x_write_reg(decoder->client,
1250 int_seq->init_reg_seq[i].reg,
1251 int_seq->init_reg_seq[i].val);
1252 }
1253 /* Detect the sensor is not already detected */
1254 err |= tvp514x_detect(decoder);
1255 if (err) {
1256 v4l_err(decoder->client,
1257 "Unable to detect decoder\n");
1258 return err;
1259 }
1260 } 1172 }
1261 err |= tvp514x_configure(decoder); 1173 err = tvp514x_configure(sd, decoder);
1174 if (err) {
1175 v4l2_err(sd, "Unable to configure decoder\n");
1176 return err;
1177 }
1178 decoder->streaming = enable;
1262 break; 1179 break;
1263 1180 }
1264 default: 1181 default:
1265 err = -ENODEV; 1182 err = -ENODEV;
1266 break; 1183 break;
@@ -1269,93 +1186,37 @@ static int ioctl_s_power(struct v4l2_int_device *s, enum v4l2_power on)
1269 return err; 1186 return err;
1270} 1187}
1271 1188
1272/** 1189static const struct v4l2_subdev_core_ops tvp514x_core_ops = {
1273 * ioctl_init - V4L2 decoder interface handler for VIDIOC_INT_INIT 1190 .queryctrl = tvp514x_queryctrl,
1274 * @s: pointer to standard V4L2 device structure 1191 .g_ctrl = tvp514x_g_ctrl,
1275 * 1192 .s_ctrl = tvp514x_s_ctrl,
1276 * Initialize the decoder device (calls tvp514x_configure()) 1193 .s_std = tvp514x_s_std,
1277 */ 1194};
1278static int ioctl_init(struct v4l2_int_device *s)
1279{
1280 struct tvp514x_decoder *decoder = s->priv;
1281
1282 /* Set default standard to auto */
1283 decoder->tvp514x_regs[REG_VIDEO_STD].val =
1284 VIDEO_STD_AUTO_SWITCH_BIT;
1285
1286 return tvp514x_configure(decoder);
1287}
1288
1289/**
1290 * ioctl_dev_exit - V4L2 decoder interface handler for vidioc_int_dev_exit_num
1291 * @s: pointer to standard V4L2 device structure
1292 *
1293 * Delinitialise the dev. at slave detach. The complement of ioctl_dev_init.
1294 */
1295static int ioctl_dev_exit(struct v4l2_int_device *s)
1296{
1297 return 0;
1298}
1299
1300/**
1301 * ioctl_dev_init - V4L2 decoder interface handler for vidioc_int_dev_init_num
1302 * @s: pointer to standard V4L2 device structure
1303 *
1304 * Initialise the device when slave attaches to the master. Returns 0 if
1305 * TVP5146/47 device could be found, otherwise returns appropriate error.
1306 */
1307static int ioctl_dev_init(struct v4l2_int_device *s)
1308{
1309 struct tvp514x_decoder *decoder = s->priv;
1310 int err;
1311
1312 err = tvp514x_detect(decoder);
1313 if (err < 0) {
1314 v4l_err(decoder->client,
1315 "Unable to detect decoder\n");
1316 return err;
1317 }
1318
1319 v4l_info(decoder->client,
1320 "chip version 0x%.2x detected\n", decoder->ver);
1321 1195
1322 return 0; 1196static const struct v4l2_subdev_video_ops tvp514x_video_ops = {
1323} 1197 .s_routing = tvp514x_s_routing,
1198 .querystd = tvp514x_querystd,
1199 .enum_fmt = tvp514x_enum_fmt_cap,
1200 .g_fmt = tvp514x_g_fmt_cap,
1201 .try_fmt = tvp514x_try_fmt_cap,
1202 .s_fmt = tvp514x_s_fmt_cap,
1203 .g_parm = tvp514x_g_parm,
1204 .s_parm = tvp514x_s_parm,
1205 .s_stream = tvp514x_s_stream,
1206};
1324 1207
1325static struct v4l2_int_ioctl_desc tvp514x_ioctl_desc[] = { 1208static const struct v4l2_subdev_ops tvp514x_ops = {
1326 {vidioc_int_dev_init_num, (v4l2_int_ioctl_func*) ioctl_dev_init}, 1209 .core = &tvp514x_core_ops,
1327 {vidioc_int_dev_exit_num, (v4l2_int_ioctl_func*) ioctl_dev_exit}, 1210 .video = &tvp514x_video_ops,
1328 {vidioc_int_s_power_num, (v4l2_int_ioctl_func*) ioctl_s_power},
1329 {vidioc_int_g_priv_num, (v4l2_int_ioctl_func*) ioctl_g_priv},
1330 {vidioc_int_g_ifparm_num, (v4l2_int_ioctl_func*) ioctl_g_ifparm},
1331 {vidioc_int_init_num, (v4l2_int_ioctl_func*) ioctl_init},
1332 {vidioc_int_enum_fmt_cap_num,
1333 (v4l2_int_ioctl_func *) ioctl_enum_fmt_cap},
1334 {vidioc_int_try_fmt_cap_num,
1335 (v4l2_int_ioctl_func *) ioctl_try_fmt_cap},
1336 {vidioc_int_g_fmt_cap_num,
1337 (v4l2_int_ioctl_func *) ioctl_g_fmt_cap},
1338 {vidioc_int_s_fmt_cap_num,
1339 (v4l2_int_ioctl_func *) ioctl_s_fmt_cap},
1340 {vidioc_int_g_parm_num, (v4l2_int_ioctl_func *) ioctl_g_parm},
1341 {vidioc_int_s_parm_num, (v4l2_int_ioctl_func *) ioctl_s_parm},
1342 {vidioc_int_queryctrl_num,
1343 (v4l2_int_ioctl_func *) ioctl_queryctrl},
1344 {vidioc_int_g_ctrl_num, (v4l2_int_ioctl_func *) ioctl_g_ctrl},
1345 {vidioc_int_s_ctrl_num, (v4l2_int_ioctl_func *) ioctl_s_ctrl},
1346 {vidioc_int_querystd_num, (v4l2_int_ioctl_func *) ioctl_querystd},
1347 {vidioc_int_s_std_num, (v4l2_int_ioctl_func *) ioctl_s_std},
1348 {vidioc_int_s_video_routing_num,
1349 (v4l2_int_ioctl_func *) ioctl_s_routing},
1350}; 1211};
1351 1212
1352static struct tvp514x_decoder tvp514x_dev = { 1213static struct tvp514x_decoder tvp514x_dev = {
1353 .state = STATE_NOT_DETECTED, 1214 .streaming = 0,
1354 1215
1355 .fmt_list = tvp514x_fmt_list, 1216 .fmt_list = tvp514x_fmt_list,
1356 .num_fmts = ARRAY_SIZE(tvp514x_fmt_list), 1217 .num_fmts = ARRAY_SIZE(tvp514x_fmt_list),
1357 1218
1358 .pix = { /* Default to NTSC 8-bit YUV 422 */ 1219 .pix = {/* Default to NTSC 8-bit YUV 422 */
1359 .width = NTSC_NUM_ACTIVE_PIXELS, 1220 .width = NTSC_NUM_ACTIVE_PIXELS,
1360 .height = NTSC_NUM_ACTIVE_LINES, 1221 .height = NTSC_NUM_ACTIVE_LINES,
1361 .pixelformat = V4L2_PIX_FMT_UYVY, 1222 .pixelformat = V4L2_PIX_FMT_UYVY,
@@ -1369,20 +1230,13 @@ static struct tvp514x_decoder tvp514x_dev = {
1369 .current_std = STD_NTSC_MJ, 1230 .current_std = STD_NTSC_MJ,
1370 .std_list = tvp514x_std_list, 1231 .std_list = tvp514x_std_list,
1371 .num_stds = ARRAY_SIZE(tvp514x_std_list), 1232 .num_stds = ARRAY_SIZE(tvp514x_std_list),
1372 .v4l2_int_device = { 1233
1373 .module = THIS_MODULE,
1374 .name = TVP514X_MODULE_NAME,
1375 .type = v4l2_int_type_slave,
1376 },
1377 .tvp514x_slave = {
1378 .ioctls = tvp514x_ioctl_desc,
1379 .num_ioctls = ARRAY_SIZE(tvp514x_ioctl_desc),
1380 },
1381}; 1234};
1382 1235
1383/** 1236/*
1384 * tvp514x_probe - decoder driver i2c probe handler 1237 * tvp514x_probe - decoder driver i2c probe handler
1385 * @client: i2c driver client device structure 1238 * @client: i2c driver client device structure
1239 * @id: i2c driver id table
1386 * 1240 *
1387 * Register decoder as an i2c client device and V4L2 1241 * Register decoder as an i2c client device and V4L2
1388 * device. 1242 * device.
@@ -1391,82 +1245,71 @@ static int
1391tvp514x_probe(struct i2c_client *client, const struct i2c_device_id *id) 1245tvp514x_probe(struct i2c_client *client, const struct i2c_device_id *id)
1392{ 1246{
1393 struct tvp514x_decoder *decoder; 1247 struct tvp514x_decoder *decoder;
1394 int err; 1248 struct v4l2_subdev *sd;
1395 1249
1396 /* Check if the adapter supports the needed features */ 1250 /* Check if the adapter supports the needed features */
1397 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1251 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1398 return -EIO; 1252 return -EIO;
1399 1253
1254 if (!client->dev.platform_data) {
1255 v4l2_err(client, "No platform data!!\n");
1256 return -ENODEV;
1257 }
1258
1400 decoder = kzalloc(sizeof(*decoder), GFP_KERNEL); 1259 decoder = kzalloc(sizeof(*decoder), GFP_KERNEL);
1401 if (!decoder) 1260 if (!decoder)
1402 return -ENOMEM; 1261 return -ENOMEM;
1403 1262
1404 if (!client->dev.platform_data) { 1263 /*
1405 v4l_err(client, "No platform data!!\n"); 1264 * Initialize the tvp514x_decoder with default configuration
1406 err = -ENODEV; 1265 */
1407 goto out_free;
1408 }
1409
1410 *decoder = tvp514x_dev; 1266 *decoder = tvp514x_dev;
1411 decoder->v4l2_int_device.priv = decoder; 1267 /* Copy default register configuration */
1412 decoder->pdata = client->dev.platform_data;
1413 decoder->v4l2_int_device.u.slave = &decoder->tvp514x_slave;
1414 memcpy(decoder->tvp514x_regs, tvp514x_reg_list_default, 1268 memcpy(decoder->tvp514x_regs, tvp514x_reg_list_default,
1415 sizeof(tvp514x_reg_list_default)); 1269 sizeof(tvp514x_reg_list_default));
1270
1271 /*
1272 * Copy board specific information here
1273 */
1274 decoder->pdata = client->dev.platform_data;
1275
1416 /* 1276 /*
1417 * Fetch platform specific data, and configure the 1277 * Fetch platform specific data, and configure the
1418 * tvp514x_reg_list[] accordingly. Since this is one 1278 * tvp514x_reg_list[] accordingly. Since this is one
1419 * time configuration, no need to preserve. 1279 * time configuration, no need to preserve.
1420 */ 1280 */
1421 decoder->tvp514x_regs[REG_OUTPUT_FORMATTER2].val |= 1281 decoder->tvp514x_regs[REG_OUTPUT_FORMATTER2].val |=
1422 (decoder->pdata->clk_polarity << 1); 1282 (decoder->pdata->clk_polarity << 1);
1423 decoder->tvp514x_regs[REG_SYNC_CONTROL].val |= 1283 decoder->tvp514x_regs[REG_SYNC_CONTROL].val |=
1424 ((decoder->pdata->hs_polarity << 2) | 1284 ((decoder->pdata->hs_polarity << 2) |
1425 (decoder->pdata->vs_polarity << 3)); 1285 (decoder->pdata->vs_polarity << 3));
1426 /* 1286 /* Set default standard to auto */
1427 * Save the id data, required for power up sequence 1287 decoder->tvp514x_regs[REG_VIDEO_STD].val =
1428 */ 1288 VIDEO_STD_AUTO_SWITCH_BIT;
1429 decoder->id = (struct i2c_device_id *)id;
1430 /* Attach to Master */
1431 strcpy(decoder->v4l2_int_device.u.slave->attach_to,
1432 decoder->pdata->master);
1433 decoder->client = client;
1434 i2c_set_clientdata(client, decoder);
1435 1289
1436 /* Register with V4L2 layer as slave device */ 1290 /* Register with V4L2 layer as slave device */
1437 err = v4l2_int_device_register(&decoder->v4l2_int_device); 1291 sd = &decoder->sd;
1438 if (err) { 1292 v4l2_i2c_subdev_init(sd, client, &tvp514x_ops);
1439 i2c_set_clientdata(client, NULL); 1293
1440 v4l_err(client, 1294 v4l2_info(sd, "%s decoder driver registered !!\n", sd->name);
1441 "Unable to register to v4l2. Err[%d]\n", err); 1295
1442 goto out_free;
1443
1444 } else
1445 v4l_info(client, "Registered to v4l2 master %s!!\n",
1446 decoder->pdata->master);
1447 return 0; 1296 return 0;
1448 1297
1449out_free:
1450 kfree(decoder);
1451 return err;
1452} 1298}
1453 1299
1454/** 1300/*
1455 * tvp514x_remove - decoder driver i2c remove handler 1301 * tvp514x_remove - decoder driver i2c remove handler
1456 * @client: i2c driver client device structure 1302 * @client: i2c driver client device structure
1457 * 1303 *
1458 * Unregister decoder as an i2c client device and V4L2 1304 * Unregister decoder as an i2c client device and V4L2
1459 * device. Complement of tvp514x_probe(). 1305 * device. Complement of tvp514x_probe().
1460 */ 1306 */
1461static int __exit tvp514x_remove(struct i2c_client *client) 1307static int tvp514x_remove(struct i2c_client *client)
1462{ 1308{
1463 struct tvp514x_decoder *decoder = i2c_get_clientdata(client); 1309 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1464 1310 struct tvp514x_decoder *decoder = to_decoder(sd);
1465 if (!client->adapter)
1466 return -ENODEV; /* our client isn't attached */
1467 1311
1468 v4l2_int_device_unregister(&decoder->v4l2_int_device); 1312 v4l2_device_unregister_subdev(sd);
1469 i2c_set_clientdata(client, NULL);
1470 kfree(decoder); 1313 kfree(decoder);
1471 return 0; 1314 return 0;
1472} 1315}
@@ -1485,11 +1328,9 @@ static const struct tvp514x_reg tvp5146_init_reg_seq[] = {
1485 {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00}, 1328 {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
1486 {TOK_WRITE, REG_OPERATION_MODE, 0x01}, 1329 {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1487 {TOK_WRITE, REG_OPERATION_MODE, 0x00}, 1330 {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1331 {TOK_TERM, 0, 0},
1488}; 1332};
1489static const struct tvp514x_init_seq tvp5146_init = { 1333
1490 .no_regs = ARRAY_SIZE(tvp5146_init_reg_seq),
1491 .init_reg_seq = tvp5146_init_reg_seq,
1492};
1493/* 1334/*
1494 * TVP5147 Init/Power on Sequence 1335 * TVP5147 Init/Power on Sequence
1495 */ 1336 */
@@ -1512,22 +1353,18 @@ static const struct tvp514x_reg tvp5147_init_reg_seq[] = {
1512 {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00}, 1353 {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
1513 {TOK_WRITE, REG_OPERATION_MODE, 0x01}, 1354 {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1514 {TOK_WRITE, REG_OPERATION_MODE, 0x00}, 1355 {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1356 {TOK_TERM, 0, 0},
1515}; 1357};
1516static const struct tvp514x_init_seq tvp5147_init = { 1358
1517 .no_regs = ARRAY_SIZE(tvp5147_init_reg_seq),
1518 .init_reg_seq = tvp5147_init_reg_seq,
1519};
1520/* 1359/*
1521 * TVP5146M2/TVP5147M1 Init/Power on Sequence 1360 * TVP5146M2/TVP5147M1 Init/Power on Sequence
1522 */ 1361 */
1523static const struct tvp514x_reg tvp514xm_init_reg_seq[] = { 1362static const struct tvp514x_reg tvp514xm_init_reg_seq[] = {
1524 {TOK_WRITE, REG_OPERATION_MODE, 0x01}, 1363 {TOK_WRITE, REG_OPERATION_MODE, 0x01},
1525 {TOK_WRITE, REG_OPERATION_MODE, 0x00}, 1364 {TOK_WRITE, REG_OPERATION_MODE, 0x00},
1365 {TOK_TERM, 0, 0},
1526}; 1366};
1527static const struct tvp514x_init_seq tvp514xm_init = { 1367
1528 .no_regs = ARRAY_SIZE(tvp514xm_init_reg_seq),
1529 .init_reg_seq = tvp514xm_init_reg_seq,
1530};
1531/* 1368/*
1532 * I2C Device Table - 1369 * I2C Device Table -
1533 * 1370 *
@@ -1535,48 +1372,34 @@ static const struct tvp514x_init_seq tvp514xm_init = {
1535 * driver_data - Driver data 1372 * driver_data - Driver data
1536 */ 1373 */
1537static const struct i2c_device_id tvp514x_id[] = { 1374static const struct i2c_device_id tvp514x_id[] = {
1538 {"tvp5146", (unsigned long)&tvp5146_init}, 1375 {"tvp5146", (unsigned long)tvp5146_init_reg_seq},
1539 {"tvp5146m2", (unsigned long)&tvp514xm_init}, 1376 {"tvp5146m2", (unsigned long)tvp514xm_init_reg_seq},
1540 {"tvp5147", (unsigned long)&tvp5147_init}, 1377 {"tvp5147", (unsigned long)tvp5147_init_reg_seq},
1541 {"tvp5147m1", (unsigned long)&tvp514xm_init}, 1378 {"tvp5147m1", (unsigned long)tvp514xm_init_reg_seq},
1542 {}, 1379 {},
1543}; 1380};
1544 1381
1545MODULE_DEVICE_TABLE(i2c, tvp514x_id); 1382MODULE_DEVICE_TABLE(i2c, tvp514x_id);
1546 1383
1547static struct i2c_driver tvp514x_i2c_driver = { 1384static struct i2c_driver tvp514x_driver = {
1548 .driver = { 1385 .driver = {
1549 .name = TVP514X_MODULE_NAME, 1386 .owner = THIS_MODULE,
1550 .owner = THIS_MODULE, 1387 .name = TVP514X_MODULE_NAME,
1551 }, 1388 },
1552 .probe = tvp514x_probe, 1389 .probe = tvp514x_probe,
1553 .remove = __exit_p(tvp514x_remove), 1390 .remove = tvp514x_remove,
1554 .id_table = tvp514x_id, 1391 .id_table = tvp514x_id,
1555}; 1392};
1556 1393
1557/**
1558 * tvp514x_init
1559 *
1560 * Module init function
1561 */
1562static int __init tvp514x_init(void) 1394static int __init tvp514x_init(void)
1563{ 1395{
1564 return i2c_add_driver(&tvp514x_i2c_driver); 1396 return i2c_add_driver(&tvp514x_driver);
1565} 1397}
1566 1398
1567/** 1399static void __exit tvp514x_exit(void)
1568 * tvp514x_cleanup
1569 *
1570 * Module exit function
1571 */
1572static void __exit tvp514x_cleanup(void)
1573{ 1400{
1574 i2c_del_driver(&tvp514x_i2c_driver); 1401 i2c_del_driver(&tvp514x_driver);
1575} 1402}
1576 1403
1577module_init(tvp514x_init); 1404module_init(tvp514x_init);
1578module_exit(tvp514x_cleanup); 1405module_exit(tvp514x_exit);
1579
1580MODULE_AUTHOR("Texas Instruments");
1581MODULE_DESCRIPTION("TVP514X linux decoder driver");
1582MODULE_LICENSE("GPL");