2 * tvp5150 - Texas Instruments TVP5150A/AM1 video decoder driver
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
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-ctrls.h>
17 #include "tvp5150_reg.h"
19 #define TVP5150_H_MAX 720U
20 #define TVP5150_V_MAX_525_60 480U
21 #define TVP5150_V_MAX_OTHERS 576U
22 #define TVP5150_MAX_CROP_LEFT 511
23 #define TVP5150_MAX_CROP_TOP 127
24 #define TVP5150_CROP_SHIFT 2
26 MODULE_DESCRIPTION("Texas Instruments TVP5150A video decoder driver");
27 MODULE_AUTHOR("Mauro Carvalho Chehab");
28 MODULE_LICENSE("GPL");
32 module_param(debug
, int, 0644);
33 MODULE_PARM_DESC(debug
, "Debug level (0-2)");
36 struct v4l2_subdev sd
;
37 struct v4l2_ctrl_handler hdl
;
38 struct v4l2_rect rect
;
40 v4l2_std_id norm
; /* Current set standard */
46 static inline struct tvp5150
*to_tvp5150(struct v4l2_subdev
*sd
)
48 return container_of(sd
, struct tvp5150
, sd
);
51 static inline struct v4l2_subdev
*to_sd(struct v4l2_ctrl
*ctrl
)
53 return &container_of(ctrl
->handler
, struct tvp5150
, hdl
)->sd
;
56 static int tvp5150_read(struct v4l2_subdev
*sd
, unsigned char addr
)
58 struct i2c_client
*c
= v4l2_get_subdevdata(sd
);
61 rc
= i2c_smbus_read_byte_data(c
, addr
);
63 v4l2_err(sd
, "i2c i/o error: rc == %d\n", rc
);
67 v4l2_dbg(2, debug
, sd
, "tvp5150: read 0x%02x = 0x%02x\n", addr
, rc
);
72 static inline void tvp5150_write(struct v4l2_subdev
*sd
, unsigned char addr
,
75 struct i2c_client
*c
= v4l2_get_subdevdata(sd
);
78 v4l2_dbg(2, debug
, sd
, "tvp5150: writing 0x%02x 0x%02x\n", addr
, value
);
79 rc
= i2c_smbus_write_byte_data(c
, addr
, value
);
81 v4l2_dbg(0, debug
, sd
, "i2c i/o error: rc == %d\n", rc
);
84 static void dump_reg_range(struct v4l2_subdev
*sd
, char *s
, u8 init
,
85 const u8 end
, int max_line
)
89 while (init
!= (u8
)(end
+ 1)) {
90 if ((i
% max_line
) == 0) {
93 printk("tvp5150: %s reg 0x%02x = ", s
, init
);
95 printk("%02x ", tvp5150_read(sd
, init
));
103 static int tvp5150_log_status(struct v4l2_subdev
*sd
)
105 printk("tvp5150: Video input source selection #1 = 0x%02x\n",
106 tvp5150_read(sd
, TVP5150_VD_IN_SRC_SEL_1
));
107 printk("tvp5150: Analog channel controls = 0x%02x\n",
108 tvp5150_read(sd
, TVP5150_ANAL_CHL_CTL
));
109 printk("tvp5150: Operation mode controls = 0x%02x\n",
110 tvp5150_read(sd
, TVP5150_OP_MODE_CTL
));
111 printk("tvp5150: Miscellaneous controls = 0x%02x\n",
112 tvp5150_read(sd
, TVP5150_MISC_CTL
));
113 printk("tvp5150: Autoswitch mask= 0x%02x\n",
114 tvp5150_read(sd
, TVP5150_AUTOSW_MSK
));
115 printk("tvp5150: Color killer threshold control = 0x%02x\n",
116 tvp5150_read(sd
, TVP5150_COLOR_KIL_THSH_CTL
));
117 printk("tvp5150: Luminance processing controls #1 #2 and #3 = %02x %02x %02x\n",
118 tvp5150_read(sd
, TVP5150_LUMA_PROC_CTL_1
),
119 tvp5150_read(sd
, TVP5150_LUMA_PROC_CTL_2
),
120 tvp5150_read(sd
, TVP5150_LUMA_PROC_CTL_3
));
121 printk("tvp5150: Brightness control = 0x%02x\n",
122 tvp5150_read(sd
, TVP5150_BRIGHT_CTL
));
123 printk("tvp5150: Color saturation control = 0x%02x\n",
124 tvp5150_read(sd
, TVP5150_SATURATION_CTL
));
125 printk("tvp5150: Hue control = 0x%02x\n",
126 tvp5150_read(sd
, TVP5150_HUE_CTL
));
127 printk("tvp5150: Contrast control = 0x%02x\n",
128 tvp5150_read(sd
, TVP5150_CONTRAST_CTL
));
129 printk("tvp5150: Outputs and data rates select = 0x%02x\n",
130 tvp5150_read(sd
, TVP5150_DATA_RATE_SEL
));
131 printk("tvp5150: Configuration shared pins = 0x%02x\n",
132 tvp5150_read(sd
, TVP5150_CONF_SHARED_PIN
));
133 printk("tvp5150: Active video cropping start = 0x%02x%02x\n",
134 tvp5150_read(sd
, TVP5150_ACT_VD_CROP_ST_MSB
),
135 tvp5150_read(sd
, TVP5150_ACT_VD_CROP_ST_LSB
));
136 printk("tvp5150: Active video cropping stop = 0x%02x%02x\n",
137 tvp5150_read(sd
, TVP5150_ACT_VD_CROP_STP_MSB
),
138 tvp5150_read(sd
, TVP5150_ACT_VD_CROP_STP_LSB
));
139 printk("tvp5150: Genlock/RTC = 0x%02x\n",
140 tvp5150_read(sd
, TVP5150_GENLOCK
));
141 printk("tvp5150: Horizontal sync start = 0x%02x\n",
142 tvp5150_read(sd
, TVP5150_HORIZ_SYNC_START
));
143 printk("tvp5150: Vertical blanking start = 0x%02x\n",
144 tvp5150_read(sd
, TVP5150_VERT_BLANKING_START
));
145 printk("tvp5150: Vertical blanking stop = 0x%02x\n",
146 tvp5150_read(sd
, TVP5150_VERT_BLANKING_STOP
));
147 printk("tvp5150: Chrominance processing control #1 and #2 = %02x %02x\n",
148 tvp5150_read(sd
, TVP5150_CHROMA_PROC_CTL_1
),
149 tvp5150_read(sd
, TVP5150_CHROMA_PROC_CTL_2
));
150 printk("tvp5150: Interrupt reset register B = 0x%02x\n",
151 tvp5150_read(sd
, TVP5150_INT_RESET_REG_B
));
152 printk("tvp5150: Interrupt enable register B = 0x%02x\n",
153 tvp5150_read(sd
, TVP5150_INT_ENABLE_REG_B
));
154 printk("tvp5150: Interrupt configuration register B = 0x%02x\n",
155 tvp5150_read(sd
, TVP5150_INTT_CONFIG_REG_B
));
156 printk("tvp5150: Video standard = 0x%02x\n",
157 tvp5150_read(sd
, TVP5150_VIDEO_STD
));
158 printk("tvp5150: Chroma gain factor: Cb=0x%02x Cr=0x%02x\n",
159 tvp5150_read(sd
, TVP5150_CB_GAIN_FACT
),
160 tvp5150_read(sd
, TVP5150_CR_GAIN_FACTOR
));
161 printk("tvp5150: Macrovision on counter = 0x%02x\n",
162 tvp5150_read(sd
, TVP5150_MACROVISION_ON_CTR
));
163 printk("tvp5150: Macrovision off counter = 0x%02x\n",
164 tvp5150_read(sd
, TVP5150_MACROVISION_OFF_CTR
));
165 printk("tvp5150: ITU-R BT.656.%d timing(TVP5150AM1 only)\n",
166 (tvp5150_read(sd
, TVP5150_REV_SELECT
) & 1) ? 3 : 4);
167 printk("tvp5150: Device ID = %02x%02x\n",
168 tvp5150_read(sd
, TVP5150_MSB_DEV_ID
),
169 tvp5150_read(sd
, TVP5150_LSB_DEV_ID
));
170 printk("tvp5150: ROM version = (hex) %02x.%02x\n",
171 tvp5150_read(sd
, TVP5150_ROM_MAJOR_VER
),
172 tvp5150_read(sd
, TVP5150_ROM_MINOR_VER
));
173 printk("tvp5150: Vertical line count = 0x%02x%02x\n",
174 tvp5150_read(sd
, TVP5150_VERT_LN_COUNT_MSB
),
175 tvp5150_read(sd
, TVP5150_VERT_LN_COUNT_LSB
));
176 printk("tvp5150: Interrupt status register B = 0x%02x\n",
177 tvp5150_read(sd
, TVP5150_INT_STATUS_REG_B
));
178 printk("tvp5150: Interrupt active register B = 0x%02x\n",
179 tvp5150_read(sd
, TVP5150_INT_ACTIVE_REG_B
));
180 printk("tvp5150: Status regs #1 to #5 = %02x %02x %02x %02x %02x\n",
181 tvp5150_read(sd
, TVP5150_STATUS_REG_1
),
182 tvp5150_read(sd
, TVP5150_STATUS_REG_2
),
183 tvp5150_read(sd
, TVP5150_STATUS_REG_3
),
184 tvp5150_read(sd
, TVP5150_STATUS_REG_4
),
185 tvp5150_read(sd
, TVP5150_STATUS_REG_5
));
187 dump_reg_range(sd
, "Teletext filter 1", TVP5150_TELETEXT_FIL1_INI
,
188 TVP5150_TELETEXT_FIL1_END
, 8);
189 dump_reg_range(sd
, "Teletext filter 2", TVP5150_TELETEXT_FIL2_INI
,
190 TVP5150_TELETEXT_FIL2_END
, 8);
192 printk("tvp5150: Teletext filter enable = 0x%02x\n",
193 tvp5150_read(sd
, TVP5150_TELETEXT_FIL_ENA
));
194 printk("tvp5150: Interrupt status register A = 0x%02x\n",
195 tvp5150_read(sd
, TVP5150_INT_STATUS_REG_A
));
196 printk("tvp5150: Interrupt enable register A = 0x%02x\n",
197 tvp5150_read(sd
, TVP5150_INT_ENABLE_REG_A
));
198 printk("tvp5150: Interrupt configuration = 0x%02x\n",
199 tvp5150_read(sd
, TVP5150_INT_CONF
));
200 printk("tvp5150: VDP status register = 0x%02x\n",
201 tvp5150_read(sd
, TVP5150_VDP_STATUS_REG
));
202 printk("tvp5150: FIFO word count = 0x%02x\n",
203 tvp5150_read(sd
, TVP5150_FIFO_WORD_COUNT
));
204 printk("tvp5150: FIFO interrupt threshold = 0x%02x\n",
205 tvp5150_read(sd
, TVP5150_FIFO_INT_THRESHOLD
));
206 printk("tvp5150: FIFO reset = 0x%02x\n",
207 tvp5150_read(sd
, TVP5150_FIFO_RESET
));
208 printk("tvp5150: Line number interrupt = 0x%02x\n",
209 tvp5150_read(sd
, TVP5150_LINE_NUMBER_INT
));
210 printk("tvp5150: Pixel alignment register = 0x%02x%02x\n",
211 tvp5150_read(sd
, TVP5150_PIX_ALIGN_REG_HIGH
),
212 tvp5150_read(sd
, TVP5150_PIX_ALIGN_REG_LOW
));
213 printk("tvp5150: FIFO output control = 0x%02x\n",
214 tvp5150_read(sd
, TVP5150_FIFO_OUT_CTRL
));
215 printk("tvp5150: Full field enable = 0x%02x\n",
216 tvp5150_read(sd
, TVP5150_FULL_FIELD_ENA
));
217 printk("tvp5150: Full field mode register = 0x%02x\n",
218 tvp5150_read(sd
, TVP5150_FULL_FIELD_MODE_REG
));
220 dump_reg_range(sd
, "CC data", TVP5150_CC_DATA_INI
,
221 TVP5150_CC_DATA_END
, 8);
223 dump_reg_range(sd
, "WSS data", TVP5150_WSS_DATA_INI
,
224 TVP5150_WSS_DATA_END
, 8);
226 dump_reg_range(sd
, "VPS data", TVP5150_VPS_DATA_INI
,
227 TVP5150_VPS_DATA_END
, 8);
229 dump_reg_range(sd
, "VITC data", TVP5150_VITC_DATA_INI
,
230 TVP5150_VITC_DATA_END
, 10);
232 dump_reg_range(sd
, "Line mode", TVP5150_LINE_MODE_INI
,
233 TVP5150_LINE_MODE_END
, 8);
237 /****************************************************************************
239 ****************************************************************************/
241 static inline void tvp5150_selmux(struct v4l2_subdev
*sd
)
244 struct tvp5150
*decoder
= to_tvp5150(sd
);
248 if ((decoder
->output
& TVP5150_BLACK_SCREEN
) || !decoder
->enable
)
251 switch (decoder
->input
) {
252 case TVP5150_COMPOSITE1
:
255 case TVP5150_COMPOSITE0
:
263 v4l2_dbg(1, debug
, sd
, "Selecting video route: route input=%i, output=%i "
264 "=> tvp5150 input=%i, opmode=%i\n",
265 decoder
->input
, decoder
->output
,
268 tvp5150_write(sd
, TVP5150_OP_MODE_CTL
, opmode
);
269 tvp5150_write(sd
, TVP5150_VD_IN_SRC_SEL_1
, input
);
271 /* Svideo should enable YCrCb output and disable GPCL output
272 * For Composite and TV, it should be the reverse
274 val
= tvp5150_read(sd
, TVP5150_MISC_CTL
);
276 v4l2_err(sd
, "%s: failed with error = %d\n", __func__
, val
);
280 if (decoder
->input
== TVP5150_SVIDEO
)
281 val
= (val
& ~0x40) | 0x10;
283 val
= (val
& ~0x10) | 0x40;
284 tvp5150_write(sd
, TVP5150_MISC_CTL
, val
);
287 struct i2c_reg_value
{
292 /* Default values as sugested at TVP5150AM1 datasheet */
293 static const struct i2c_reg_value tvp5150_init_default
[] = {
295 TVP5150_VD_IN_SRC_SEL_1
,0x00
298 TVP5150_ANAL_CHL_CTL
,0x15
301 TVP5150_OP_MODE_CTL
,0x00
304 TVP5150_MISC_CTL
,0x01
307 TVP5150_COLOR_KIL_THSH_CTL
,0x10
310 TVP5150_LUMA_PROC_CTL_1
,0x60
313 TVP5150_LUMA_PROC_CTL_2
,0x00
316 TVP5150_BRIGHT_CTL
,0x80
319 TVP5150_SATURATION_CTL
,0x80
325 TVP5150_CONTRAST_CTL
,0x80
328 TVP5150_DATA_RATE_SEL
,0x47
331 TVP5150_LUMA_PROC_CTL_3
,0x00
334 TVP5150_CONF_SHARED_PIN
,0x08
337 TVP5150_ACT_VD_CROP_ST_MSB
,0x00
340 TVP5150_ACT_VD_CROP_ST_LSB
,0x00
343 TVP5150_ACT_VD_CROP_STP_MSB
,0x00
346 TVP5150_ACT_VD_CROP_STP_LSB
,0x00
352 TVP5150_HORIZ_SYNC_START
,0x80
355 TVP5150_VERT_BLANKING_START
,0x00
358 TVP5150_VERT_BLANKING_STOP
,0x00
361 TVP5150_CHROMA_PROC_CTL_1
,0x0c
364 TVP5150_CHROMA_PROC_CTL_2
,0x14
367 TVP5150_INT_RESET_REG_B
,0x00
370 TVP5150_INT_ENABLE_REG_B
,0x00
373 TVP5150_INTT_CONFIG_REG_B
,0x00
376 TVP5150_VIDEO_STD
,0x00
379 TVP5150_MACROVISION_ON_CTR
,0x0f
382 TVP5150_MACROVISION_OFF_CTR
,0x01
385 TVP5150_TELETEXT_FIL_ENA
,0x00
388 TVP5150_INT_STATUS_REG_A
,0x00
391 TVP5150_INT_ENABLE_REG_A
,0x00
394 TVP5150_INT_CONF
,0x04
397 TVP5150_FIFO_INT_THRESHOLD
,0x80
400 TVP5150_FIFO_RESET
,0x00
403 TVP5150_LINE_NUMBER_INT
,0x00
406 TVP5150_PIX_ALIGN_REG_LOW
,0x4e
409 TVP5150_PIX_ALIGN_REG_HIGH
,0x00
412 TVP5150_FIFO_OUT_CTRL
,0x01
415 TVP5150_FULL_FIELD_ENA
,0x00
418 TVP5150_LINE_MODE_INI
,0x00
421 TVP5150_FULL_FIELD_MODE_REG
,0x7f
428 /* Default values as sugested at TVP5150AM1 datasheet */
429 static const struct i2c_reg_value tvp5150_init_enable
[] = {
431 TVP5150_CONF_SHARED_PIN
, 2
432 },{ /* Automatic offset and AGC enabled */
433 TVP5150_ANAL_CHL_CTL
, 0x15
434 },{ /* Activate YCrCb output 0x9 or 0xd ? */
435 TVP5150_MISC_CTL
, 0x6f
436 },{ /* Activates video std autodetection for all standards */
437 TVP5150_AUTOSW_MSK
, 0x0
438 },{ /* Default format: 0x47. For 4:2:2: 0x40 */
439 TVP5150_DATA_RATE_SEL
, 0x47
441 TVP5150_CHROMA_PROC_CTL_1
, 0x0c
443 TVP5150_CHROMA_PROC_CTL_2
, 0x54
444 },{ /* Non documented, but initialized on WinTV USB2 */
451 struct tvp5150_vbi_type
{
452 unsigned int vbi_type
;
453 unsigned int ini_line
;
454 unsigned int end_line
;
455 unsigned int by_field
:1;
458 struct i2c_vbi_ram_value
{
460 struct tvp5150_vbi_type type
;
461 unsigned char values
[16];
464 /* This struct have the values for each supported VBI Standard
466 tvp5150_vbi_types should follow the same order as vbi_ram_default
467 * value 0 means rom position 0x10, value 1 means rom position 0x30
468 * and so on. There are 16 possible locations from 0 to 15.
471 static struct i2c_vbi_ram_value vbi_ram_default
[] =
473 /* FIXME: Current api doesn't handle all VBI types, those not
474 yet supported are placed under #if 0 */
476 {0x010, /* Teletext, SECAM, WST System A */
477 {V4L2_SLICED_TELETEXT_SECAM
,6,23,1},
478 { 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x26,
479 0xe6, 0xb4, 0x0e, 0x00, 0x00, 0x00, 0x10, 0x00 }
482 {0x030, /* Teletext, PAL, WST System B */
483 {V4L2_SLICED_TELETEXT_B
,6,22,1},
484 { 0xaa, 0xaa, 0xff, 0xff, 0x27, 0x2e, 0x20, 0x2b,
485 0xa6, 0x72, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00 }
488 {0x050, /* Teletext, PAL, WST System C */
489 {V4L2_SLICED_TELETEXT_PAL_C
,6,22,1},
490 { 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x22,
491 0xa6, 0x98, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
493 {0x070, /* Teletext, NTSC, WST System B */
494 {V4L2_SLICED_TELETEXT_NTSC_B
,10,21,1},
495 { 0xaa, 0xaa, 0xff, 0xff, 0x27, 0x2e, 0x20, 0x23,
496 0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
498 {0x090, /* Tetetext, NTSC NABTS System C */
499 {V4L2_SLICED_TELETEXT_NTSC_C
,10,21,1},
500 { 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x22,
501 0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x15, 0x00 }
503 {0x0b0, /* Teletext, NTSC-J, NABTS System D */
504 {V4L2_SLICED_TELETEXT_NTSC_D
,10,21,1},
505 { 0xaa, 0xaa, 0xff, 0xff, 0xa7, 0x2e, 0x20, 0x23,
506 0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
508 {0x0d0, /* Closed Caption, PAL/SECAM */
509 {V4L2_SLICED_CAPTION_625
,22,22,1},
510 { 0xaa, 0x2a, 0xff, 0x3f, 0x04, 0x51, 0x6e, 0x02,
511 0xa6, 0x7b, 0x09, 0x00, 0x00, 0x00, 0x27, 0x00 }
514 {0x0f0, /* Closed Caption, NTSC */
515 {V4L2_SLICED_CAPTION_525
,21,21,1},
516 { 0xaa, 0x2a, 0xff, 0x3f, 0x04, 0x51, 0x6e, 0x02,
517 0x69, 0x8c, 0x09, 0x00, 0x00, 0x00, 0x27, 0x00 }
519 {0x110, /* Wide Screen Signal, PAL/SECAM */
520 {V4L2_SLICED_WSS_625
,23,23,1},
521 { 0x5b, 0x55, 0xc5, 0xff, 0x00, 0x71, 0x6e, 0x42,
522 0xa6, 0xcd, 0x0f, 0x00, 0x00, 0x00, 0x3a, 0x00 }
525 {0x130, /* Wide Screen Signal, NTSC C */
526 {V4L2_SLICED_WSS_525
,20,20,1},
527 { 0x38, 0x00, 0x3f, 0x00, 0x00, 0x71, 0x6e, 0x43,
528 0x69, 0x7c, 0x08, 0x00, 0x00, 0x00, 0x39, 0x00 }
530 {0x150, /* Vertical Interval Timecode (VITC), PAL/SECAM */
531 {V4l2_SLICED_VITC_625
,6,22,0},
532 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x6d, 0x49,
533 0xa6, 0x85, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00 }
535 {0x170, /* Vertical Interval Timecode (VITC), NTSC */
536 {V4l2_SLICED_VITC_525
,10,20,0},
537 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x6d, 0x49,
538 0x69, 0x94, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00 }
541 {0x190, /* Video Program System (VPS), PAL */
542 {V4L2_SLICED_VPS
,16,16,0},
543 { 0xaa, 0xaa, 0xff, 0xff, 0xba, 0xce, 0x2b, 0x0d,
544 0xa6, 0xda, 0x0b, 0x00, 0x00, 0x00, 0x60, 0x00 }
546 /* 0x1d0 User programmable */
552 static int tvp5150_write_inittab(struct v4l2_subdev
*sd
,
553 const struct i2c_reg_value
*regs
)
555 while (regs
->reg
!= 0xff) {
556 tvp5150_write(sd
, regs
->reg
, regs
->value
);
562 static int tvp5150_vdp_init(struct v4l2_subdev
*sd
,
563 const struct i2c_vbi_ram_value
*regs
)
567 /* Disable Full Field */
568 tvp5150_write(sd
, TVP5150_FULL_FIELD_ENA
, 0);
570 /* Before programming, Line mode should be at 0xff */
571 for (i
= TVP5150_LINE_MODE_INI
; i
<= TVP5150_LINE_MODE_END
; i
++)
572 tvp5150_write(sd
, i
, 0xff);
575 while (regs
->reg
!= (u16
)-1) {
576 tvp5150_write(sd
, TVP5150_CONF_RAM_ADDR_HIGH
, regs
->reg
>> 8);
577 tvp5150_write(sd
, TVP5150_CONF_RAM_ADDR_LOW
, regs
->reg
);
579 for (i
= 0; i
< 16; i
++)
580 tvp5150_write(sd
, TVP5150_VDP_CONF_RAM_DATA
, regs
->values
[i
]);
587 /* Fills VBI capabilities based on i2c_vbi_ram_value struct */
588 static int tvp5150_g_sliced_vbi_cap(struct v4l2_subdev
*sd
,
589 struct v4l2_sliced_vbi_cap
*cap
)
591 const struct i2c_vbi_ram_value
*regs
= vbi_ram_default
;
594 v4l2_dbg(1, debug
, sd
, "g_sliced_vbi_cap\n");
595 memset(cap
, 0, sizeof *cap
);
597 while (regs
->reg
!= (u16
)-1 ) {
598 for (line
=regs
->type
.ini_line
;line
<=regs
->type
.end_line
;line
++) {
599 cap
->service_lines
[0][line
] |= regs
->type
.vbi_type
;
601 cap
->service_set
|= regs
->type
.vbi_type
;
608 /* Set vbi processing
609 * type - one of tvp5150_vbi_types
610 * line - line to gather data
611 * fields: bit 0 field1, bit 1, field2
612 * flags (default=0xf0) is a bitmask, were set means:
613 * bit 7: enable filtering null bytes on CC
614 * bit 6: send data also to FIFO
615 * bit 5: don't allow data with errors on FIFO
616 * bit 4: enable ECC when possible
617 * pix_align = pix alignment:
621 static int tvp5150_set_vbi(struct v4l2_subdev
*sd
,
622 const struct i2c_vbi_ram_value
*regs
,
623 unsigned int type
,u8 flags
, int line
,
626 struct tvp5150
*decoder
= to_tvp5150(sd
);
627 v4l2_std_id std
= decoder
->norm
;
631 if (std
== V4L2_STD_ALL
) {
632 v4l2_err(sd
, "VBI can't be configured without knowing number of lines\n");
634 } else if (std
& V4L2_STD_625_50
) {
635 /* Don't follow NTSC Line number convension */
642 while (regs
->reg
!= (u16
)-1 ) {
643 if ((type
& regs
->type
.vbi_type
) &&
644 (line
>=regs
->type
.ini_line
) &&
645 (line
<=regs
->type
.end_line
)) {
646 type
=regs
->type
.vbi_type
;
653 if (regs
->reg
== (u16
)-1)
656 type
=pos
| (flags
& 0xf0);
657 reg
=((line
-6)<<1)+TVP5150_LINE_MODE_INI
;
660 tvp5150_write(sd
, reg
, type
);
664 tvp5150_write(sd
, reg
+1, type
);
670 static int tvp5150_get_vbi(struct v4l2_subdev
*sd
,
671 const struct i2c_vbi_ram_value
*regs
, int line
)
673 struct tvp5150
*decoder
= to_tvp5150(sd
);
674 v4l2_std_id std
= decoder
->norm
;
679 if (std
== V4L2_STD_ALL
) {
680 v4l2_err(sd
, "VBI can't be configured without knowing number of lines\n");
682 } else if (std
& V4L2_STD_625_50
) {
683 /* Don't follow NTSC Line number convension */
687 if (line
< 6 || line
> 27)
690 reg
= ((line
- 6) << 1) + TVP5150_LINE_MODE_INI
;
692 for (i
= 0; i
<= 1; i
++) {
693 ret
= tvp5150_read(sd
, reg
+ i
);
695 v4l2_err(sd
, "%s: failed with error = %d\n",
701 type
|= regs
[pos
].type
.vbi_type
;
707 static int tvp5150_set_std(struct v4l2_subdev
*sd
, v4l2_std_id std
)
709 struct tvp5150
*decoder
= to_tvp5150(sd
);
714 /* First tests should be against specific std */
716 if (std
== V4L2_STD_NTSC_443
) {
717 fmt
= VIDEO_STD_NTSC_4_43_BIT
;
718 } else if (std
== V4L2_STD_PAL_M
) {
719 fmt
= VIDEO_STD_PAL_M_BIT
;
720 } else if (std
== V4L2_STD_PAL_N
|| std
== V4L2_STD_PAL_Nc
) {
721 fmt
= VIDEO_STD_PAL_COMBINATION_N_BIT
;
723 /* Then, test against generic ones */
724 if (std
& V4L2_STD_NTSC
)
725 fmt
= VIDEO_STD_NTSC_MJ_BIT
;
726 else if (std
& V4L2_STD_PAL
)
727 fmt
= VIDEO_STD_PAL_BDGHIN_BIT
;
728 else if (std
& V4L2_STD_SECAM
)
729 fmt
= VIDEO_STD_SECAM_BIT
;
732 v4l2_dbg(1, debug
, sd
, "Set video std register to %d.\n", fmt
);
733 tvp5150_write(sd
, TVP5150_VIDEO_STD
, fmt
);
737 static int tvp5150_s_std(struct v4l2_subdev
*sd
, v4l2_std_id std
)
739 struct tvp5150
*decoder
= to_tvp5150(sd
);
741 if (decoder
->norm
== std
)
744 /* Change cropping height limits */
745 if (std
& V4L2_STD_525_60
)
746 decoder
->rect
.height
= TVP5150_V_MAX_525_60
;
748 decoder
->rect
.height
= TVP5150_V_MAX_OTHERS
;
751 return tvp5150_set_std(sd
, std
);
754 static int tvp5150_reset(struct v4l2_subdev
*sd
, u32 val
)
756 struct tvp5150
*decoder
= to_tvp5150(sd
);
758 /* Initializes TVP5150 to its default values */
759 tvp5150_write_inittab(sd
, tvp5150_init_default
);
761 /* Initializes VDP registers */
762 tvp5150_vdp_init(sd
, vbi_ram_default
);
764 /* Selects decoder input */
767 /* Initializes TVP5150 to stream enabled values */
768 tvp5150_write_inittab(sd
, tvp5150_init_enable
);
770 /* Initialize image preferences */
771 v4l2_ctrl_handler_setup(&decoder
->hdl
);
773 tvp5150_set_std(sd
, decoder
->norm
);
777 static int tvp5150_s_ctrl(struct v4l2_ctrl
*ctrl
)
779 struct v4l2_subdev
*sd
= to_sd(ctrl
);
782 case V4L2_CID_BRIGHTNESS
:
783 tvp5150_write(sd
, TVP5150_BRIGHT_CTL
, ctrl
->val
);
785 case V4L2_CID_CONTRAST
:
786 tvp5150_write(sd
, TVP5150_CONTRAST_CTL
, ctrl
->val
);
788 case V4L2_CID_SATURATION
:
789 tvp5150_write(sd
, TVP5150_SATURATION_CTL
, ctrl
->val
);
792 tvp5150_write(sd
, TVP5150_HUE_CTL
, ctrl
->val
);
798 static v4l2_std_id
tvp5150_read_std(struct v4l2_subdev
*sd
)
800 int val
= tvp5150_read(sd
, TVP5150_STATUS_REG_5
);
802 switch (val
& 0x0F) {
804 return V4L2_STD_NTSC
;
808 return V4L2_STD_PAL_M
;
810 return V4L2_STD_PAL_N
| V4L2_STD_PAL_Nc
;
812 return V4L2_STD_NTSC_443
;
814 return V4L2_STD_SECAM
;
816 return V4L2_STD_UNKNOWN
;
820 static int tvp5150_enum_mbus_code(struct v4l2_subdev
*sd
,
821 struct v4l2_subdev_pad_config
*cfg
,
822 struct v4l2_subdev_mbus_code_enum
*code
)
824 if (code
->pad
|| code
->index
)
827 code
->code
= MEDIA_BUS_FMT_UYVY8_2X8
;
831 static int tvp5150_fill_fmt(struct v4l2_subdev
*sd
,
832 struct v4l2_subdev_pad_config
*cfg
,
833 struct v4l2_subdev_format
*format
)
835 struct v4l2_mbus_framefmt
*f
;
836 struct tvp5150
*decoder
= to_tvp5150(sd
);
838 if (!format
|| format
->pad
)
843 tvp5150_reset(sd
, 0);
845 f
->width
= decoder
->rect
.width
;
846 f
->height
= decoder
->rect
.height
;
848 f
->code
= MEDIA_BUS_FMT_UYVY8_2X8
;
849 f
->field
= V4L2_FIELD_SEQ_TB
;
850 f
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
852 v4l2_dbg(1, debug
, sd
, "width = %d, height = %d\n", f
->width
,
857 static int tvp5150_s_crop(struct v4l2_subdev
*sd
, const struct v4l2_crop
*a
)
859 struct v4l2_rect rect
= a
->c
;
860 struct tvp5150
*decoder
= to_tvp5150(sd
);
864 v4l2_dbg(1, debug
, sd
, "%s left=%d, top=%d, width=%d, height=%d\n",
865 __func__
, rect
.left
, rect
.top
, rect
.width
, rect
.height
);
867 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
870 /* tvp5150 has some special limits */
871 rect
.left
= clamp(rect
.left
, 0, TVP5150_MAX_CROP_LEFT
);
872 rect
.width
= clamp_t(unsigned int, rect
.width
,
873 TVP5150_H_MAX
- TVP5150_MAX_CROP_LEFT
- rect
.left
,
874 TVP5150_H_MAX
- rect
.left
);
875 rect
.top
= clamp(rect
.top
, 0, TVP5150_MAX_CROP_TOP
);
877 /* Calculate height based on current standard */
878 if (decoder
->norm
== V4L2_STD_ALL
)
879 std
= tvp5150_read_std(sd
);
883 if (std
& V4L2_STD_525_60
)
884 hmax
= TVP5150_V_MAX_525_60
;
886 hmax
= TVP5150_V_MAX_OTHERS
;
888 rect
.height
= clamp_t(unsigned int, rect
.height
,
889 hmax
- TVP5150_MAX_CROP_TOP
- rect
.top
,
892 tvp5150_write(sd
, TVP5150_VERT_BLANKING_START
, rect
.top
);
893 tvp5150_write(sd
, TVP5150_VERT_BLANKING_STOP
,
894 rect
.top
+ rect
.height
- hmax
);
895 tvp5150_write(sd
, TVP5150_ACT_VD_CROP_ST_MSB
,
896 rect
.left
>> TVP5150_CROP_SHIFT
);
897 tvp5150_write(sd
, TVP5150_ACT_VD_CROP_ST_LSB
,
898 rect
.left
| (1 << TVP5150_CROP_SHIFT
));
899 tvp5150_write(sd
, TVP5150_ACT_VD_CROP_STP_MSB
,
900 (rect
.left
+ rect
.width
- TVP5150_MAX_CROP_LEFT
) >>
902 tvp5150_write(sd
, TVP5150_ACT_VD_CROP_STP_LSB
,
903 rect
.left
+ rect
.width
- TVP5150_MAX_CROP_LEFT
);
905 decoder
->rect
= rect
;
910 static int tvp5150_g_crop(struct v4l2_subdev
*sd
, struct v4l2_crop
*a
)
912 struct tvp5150
*decoder
= to_tvp5150(sd
);
914 a
->c
= decoder
->rect
;
915 a
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
920 static int tvp5150_cropcap(struct v4l2_subdev
*sd
, struct v4l2_cropcap
*a
)
922 struct tvp5150
*decoder
= to_tvp5150(sd
);
925 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
930 a
->bounds
.width
= TVP5150_H_MAX
;
932 /* Calculate height based on current standard */
933 if (decoder
->norm
== V4L2_STD_ALL
)
934 std
= tvp5150_read_std(sd
);
938 if (std
& V4L2_STD_525_60
)
939 a
->bounds
.height
= TVP5150_V_MAX_525_60
;
941 a
->bounds
.height
= TVP5150_V_MAX_OTHERS
;
943 a
->defrect
= a
->bounds
;
944 a
->pixelaspect
.numerator
= 1;
945 a
->pixelaspect
.denominator
= 1;
950 /****************************************************************************
952 ****************************************************************************/
954 static int tvp5150_s_routing(struct v4l2_subdev
*sd
,
955 u32 input
, u32 output
, u32 config
)
957 struct tvp5150
*decoder
= to_tvp5150(sd
);
959 decoder
->input
= input
;
960 decoder
->output
= output
;
965 static int tvp5150_s_raw_fmt(struct v4l2_subdev
*sd
, struct v4l2_vbi_format
*fmt
)
967 /* this is for capturing 36 raw vbi lines
968 if there's a way to cut off the beginning 2 vbi lines
969 with the tvp5150 then the vbi line count could be lowered
970 to 17 lines/field again, although I couldn't find a register
971 which could do that cropping */
972 if (fmt
->sample_format
== V4L2_PIX_FMT_GREY
)
973 tvp5150_write(sd
, TVP5150_LUMA_PROC_CTL_1
, 0x70);
974 if (fmt
->count
[0] == 18 && fmt
->count
[1] == 18) {
975 tvp5150_write(sd
, TVP5150_VERT_BLANKING_START
, 0x00);
976 tvp5150_write(sd
, TVP5150_VERT_BLANKING_STOP
, 0x01);
981 static int tvp5150_s_sliced_fmt(struct v4l2_subdev
*sd
, struct v4l2_sliced_vbi_format
*svbi
)
985 if (svbi
->service_set
!= 0) {
986 for (i
= 0; i
<= 23; i
++) {
987 svbi
->service_lines
[1][i
] = 0;
988 svbi
->service_lines
[0][i
] =
989 tvp5150_set_vbi(sd
, vbi_ram_default
,
990 svbi
->service_lines
[0][i
], 0xf0, i
, 3);
993 tvp5150_write(sd
, TVP5150_FIFO_OUT_CTRL
, 1);
996 tvp5150_write(sd
, TVP5150_FIFO_OUT_CTRL
, 0);
998 /* Disable Full Field */
999 tvp5150_write(sd
, TVP5150_FULL_FIELD_ENA
, 0);
1001 /* Disable Line modes */
1002 for (i
= TVP5150_LINE_MODE_INI
; i
<= TVP5150_LINE_MODE_END
; i
++)
1003 tvp5150_write(sd
, i
, 0xff);
1008 static int tvp5150_g_sliced_fmt(struct v4l2_subdev
*sd
, struct v4l2_sliced_vbi_format
*svbi
)
1012 memset(svbi
->service_lines
, 0, sizeof(svbi
->service_lines
));
1014 for (i
= 0; i
<= 23; i
++) {
1015 svbi
->service_lines
[0][i
] =
1016 tvp5150_get_vbi(sd
, vbi_ram_default
, i
);
1017 mask
|= svbi
->service_lines
[0][i
];
1019 svbi
->service_set
= mask
;
1023 #ifdef CONFIG_VIDEO_ADV_DEBUG
1024 static int tvp5150_g_register(struct v4l2_subdev
*sd
, struct v4l2_dbg_register
*reg
)
1028 res
= tvp5150_read(sd
, reg
->reg
& 0xff);
1030 v4l2_err(sd
, "%s: failed with error = %d\n", __func__
, res
);
1039 static int tvp5150_s_register(struct v4l2_subdev
*sd
, const struct v4l2_dbg_register
*reg
)
1041 tvp5150_write(sd
, reg
->reg
& 0xff, reg
->val
& 0xff);
1046 static int tvp5150_g_tuner(struct v4l2_subdev
*sd
, struct v4l2_tuner
*vt
)
1048 int status
= tvp5150_read(sd
, 0x88);
1050 vt
->signal
= ((status
& 0x04) && (status
& 0x02)) ? 0xffff : 0x0;
1054 /* ----------------------------------------------------------------------- */
1056 static const struct v4l2_ctrl_ops tvp5150_ctrl_ops
= {
1057 .s_ctrl
= tvp5150_s_ctrl
,
1060 static const struct v4l2_subdev_core_ops tvp5150_core_ops
= {
1061 .log_status
= tvp5150_log_status
,
1062 .reset
= tvp5150_reset
,
1063 #ifdef CONFIG_VIDEO_ADV_DEBUG
1064 .g_register
= tvp5150_g_register
,
1065 .s_register
= tvp5150_s_register
,
1069 static const struct v4l2_subdev_tuner_ops tvp5150_tuner_ops
= {
1070 .g_tuner
= tvp5150_g_tuner
,
1073 static const struct v4l2_subdev_video_ops tvp5150_video_ops
= {
1074 .s_std
= tvp5150_s_std
,
1075 .s_routing
= tvp5150_s_routing
,
1076 .s_crop
= tvp5150_s_crop
,
1077 .g_crop
= tvp5150_g_crop
,
1078 .cropcap
= tvp5150_cropcap
,
1081 static const struct v4l2_subdev_vbi_ops tvp5150_vbi_ops
= {
1082 .g_sliced_vbi_cap
= tvp5150_g_sliced_vbi_cap
,
1083 .g_sliced_fmt
= tvp5150_g_sliced_fmt
,
1084 .s_sliced_fmt
= tvp5150_s_sliced_fmt
,
1085 .s_raw_fmt
= tvp5150_s_raw_fmt
,
1088 static const struct v4l2_subdev_pad_ops tvp5150_pad_ops
= {
1089 .enum_mbus_code
= tvp5150_enum_mbus_code
,
1090 .set_fmt
= tvp5150_fill_fmt
,
1091 .get_fmt
= tvp5150_fill_fmt
,
1094 static const struct v4l2_subdev_ops tvp5150_ops
= {
1095 .core
= &tvp5150_core_ops
,
1096 .tuner
= &tvp5150_tuner_ops
,
1097 .video
= &tvp5150_video_ops
,
1098 .vbi
= &tvp5150_vbi_ops
,
1099 .pad
= &tvp5150_pad_ops
,
1103 /****************************************************************************
1105 ****************************************************************************/
1107 static int tvp5150_probe(struct i2c_client
*c
,
1108 const struct i2c_device_id
*id
)
1110 struct tvp5150
*core
;
1111 struct v4l2_subdev
*sd
;
1115 /* Check if the adapter supports the needed features */
1116 if (!i2c_check_functionality(c
->adapter
,
1117 I2C_FUNC_SMBUS_READ_BYTE
| I2C_FUNC_SMBUS_WRITE_BYTE_DATA
))
1120 core
= devm_kzalloc(&c
->dev
, sizeof(*core
), GFP_KERNEL
);
1124 v4l2_i2c_subdev_init(sd
, c
, &tvp5150_ops
);
1127 * Read consequent registers - TVP5150_MSB_DEV_ID, TVP5150_LSB_DEV_ID,
1128 * TVP5150_ROM_MAJOR_VER, TVP5150_ROM_MINOR_VER
1130 for (i
= 0; i
< 4; i
++) {
1131 res
= tvp5150_read(sd
, TVP5150_MSB_DEV_ID
+ i
);
1134 tvp5150_id
[i
] = res
;
1137 v4l_info(c
, "chip found @ 0x%02x (%s)\n",
1138 c
->addr
<< 1, c
->adapter
->name
);
1140 if (tvp5150_id
[2] == 4 && tvp5150_id
[3] == 0) { /* Is TVP5150AM1 */
1141 v4l2_info(sd
, "tvp%02x%02xam1 detected.\n",
1142 tvp5150_id
[0], tvp5150_id
[1]);
1144 /* ITU-T BT.656.4 timing */
1145 tvp5150_write(sd
, TVP5150_REV_SELECT
, 0);
1148 if (tvp5150_id
[2] == 3 || tvp5150_id
[3] == 0x21) {
1149 v4l2_info(sd
, "tvp%02x%02xa detected.\n",
1150 tvp5150_id
[0], tvp5150_id
[1]);
1152 v4l2_info(sd
, "*** unknown tvp%02x%02x chip detected.\n",
1153 tvp5150_id
[0], tvp5150_id
[1]);
1154 v4l2_info(sd
, "*** Rom ver is %d.%d\n",
1155 tvp5150_id
[2], tvp5150_id
[3]);
1159 core
->norm
= V4L2_STD_ALL
; /* Default is autodetect */
1160 core
->input
= TVP5150_COMPOSITE1
;
1163 v4l2_ctrl_handler_init(&core
->hdl
, 4);
1164 v4l2_ctrl_new_std(&core
->hdl
, &tvp5150_ctrl_ops
,
1165 V4L2_CID_BRIGHTNESS
, 0, 255, 1, 128);
1166 v4l2_ctrl_new_std(&core
->hdl
, &tvp5150_ctrl_ops
,
1167 V4L2_CID_CONTRAST
, 0, 255, 1, 128);
1168 v4l2_ctrl_new_std(&core
->hdl
, &tvp5150_ctrl_ops
,
1169 V4L2_CID_SATURATION
, 0, 255, 1, 128);
1170 v4l2_ctrl_new_std(&core
->hdl
, &tvp5150_ctrl_ops
,
1171 V4L2_CID_HUE
, -128, 127, 1, 0);
1172 sd
->ctrl_handler
= &core
->hdl
;
1173 if (core
->hdl
.error
) {
1174 res
= core
->hdl
.error
;
1175 v4l2_ctrl_handler_free(&core
->hdl
);
1178 v4l2_ctrl_handler_setup(&core
->hdl
);
1180 /* Default is no cropping */
1182 if (tvp5150_read_std(sd
) & V4L2_STD_525_60
)
1183 core
->rect
.height
= TVP5150_V_MAX_525_60
;
1185 core
->rect
.height
= TVP5150_V_MAX_OTHERS
;
1186 core
->rect
.left
= 0;
1187 core
->rect
.width
= TVP5150_H_MAX
;
1190 tvp5150_log_status(sd
);
1194 static int tvp5150_remove(struct i2c_client
*c
)
1196 struct v4l2_subdev
*sd
= i2c_get_clientdata(c
);
1197 struct tvp5150
*decoder
= to_tvp5150(sd
);
1199 v4l2_dbg(1, debug
, sd
,
1200 "tvp5150.c: removing tvp5150 adapter on address 0x%x\n",
1203 v4l2_device_unregister_subdev(sd
);
1204 v4l2_ctrl_handler_free(&decoder
->hdl
);
1208 /* ----------------------------------------------------------------------- */
1210 static const struct i2c_device_id tvp5150_id
[] = {
1214 MODULE_DEVICE_TABLE(i2c
, tvp5150_id
);
1216 static struct i2c_driver tvp5150_driver
= {
1218 .owner
= THIS_MODULE
,
1221 .probe
= tvp5150_probe
,
1222 .remove
= tvp5150_remove
,
1223 .id_table
= tvp5150_id
,
1226 module_i2c_driver(tvp5150_driver
);