2 * tvp5150 - Texas Instruments TVP5150A/AM1 and TVP5151 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
8 #include <dt-bindings/media/tvp5150.h>
10 #include <linux/slab.h>
11 #include <linux/videodev2.h>
12 #include <linux/delay.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/module.h>
15 #include <linux/of_graph.h>
16 #include <media/v4l2-async.h>
17 #include <media/v4l2-device.h>
18 #include <media/v4l2-ctrls.h>
19 #include <media/v4l2-fwnode.h>
20 #include <media/v4l2-mc.h>
22 #include "tvp5150_reg.h"
24 #define TVP5150_H_MAX 720U
25 #define TVP5150_V_MAX_525_60 480U
26 #define TVP5150_V_MAX_OTHERS 576U
27 #define TVP5150_MAX_CROP_LEFT 511
28 #define TVP5150_MAX_CROP_TOP 127
29 #define TVP5150_CROP_SHIFT 2
31 MODULE_DESCRIPTION("Texas Instruments TVP5150A/TVP5150AM1/TVP5151 video decoder driver");
32 MODULE_AUTHOR("Mauro Carvalho Chehab");
33 MODULE_LICENSE("GPL");
37 module_param(debug
, int, 0644);
38 MODULE_PARM_DESC(debug
, "Debug level (0-2)");
40 #define dprintk0(__dev, __arg...) dev_dbg_lvl(__dev, 0, 0, __arg)
43 struct v4l2_subdev sd
;
44 #ifdef CONFIG_MEDIA_CONTROLLER
45 struct media_pad pads
[DEMOD_NUM_PADS
];
46 struct media_entity input_ent
[TVP5150_INPUT_NUM
];
47 struct media_pad input_pad
[TVP5150_INPUT_NUM
];
49 struct v4l2_ctrl_handler hdl
;
50 struct v4l2_rect rect
;
52 v4l2_std_id norm
; /* Current set standard */
60 enum v4l2_mbus_type mbus_type
;
63 static inline struct tvp5150
*to_tvp5150(struct v4l2_subdev
*sd
)
65 return container_of(sd
, struct tvp5150
, sd
);
68 static inline struct v4l2_subdev
*to_sd(struct v4l2_ctrl
*ctrl
)
70 return &container_of(ctrl
->handler
, struct tvp5150
, hdl
)->sd
;
73 static int tvp5150_read(struct v4l2_subdev
*sd
, unsigned char addr
)
75 struct i2c_client
*c
= v4l2_get_subdevdata(sd
);
78 rc
= i2c_smbus_read_byte_data(c
, addr
);
80 dev_err(sd
->dev
, "i2c i/o error: rc == %d\n", rc
);
84 dev_dbg_lvl(sd
->dev
, 2, debug
, "tvp5150: read 0x%02x = %02x\n", addr
, rc
);
89 static int tvp5150_write(struct v4l2_subdev
*sd
, unsigned char addr
,
92 struct i2c_client
*c
= v4l2_get_subdevdata(sd
);
95 dev_dbg_lvl(sd
->dev
, 2, debug
, "tvp5150: writing %02x %02x\n", addr
, value
);
96 rc
= i2c_smbus_write_byte_data(c
, addr
, value
);
98 dev_err(sd
->dev
, "i2c i/o error: rc == %d\n", rc
);
103 static void dump_reg_range(struct v4l2_subdev
*sd
, char *s
, u8 init
,
104 const u8 end
, int max_line
)
110 dprintk0(sd
->dev
, "too much data to dump\n");
114 for (i
= init
; i
< end
; i
+= max_line
) {
115 len
= (end
- i
> max_line
) ? max_line
: end
- i
;
117 for (j
= 0; j
< len
; j
++)
118 buf
[j
] = tvp5150_read(sd
, i
+ j
);
120 dprintk0(sd
->dev
, "%s reg %02x = %*ph\n", s
, i
, len
, buf
);
124 static int tvp5150_log_status(struct v4l2_subdev
*sd
)
126 dprintk0(sd
->dev
, "tvp5150: Video input source selection #1 = 0x%02x\n",
127 tvp5150_read(sd
, TVP5150_VD_IN_SRC_SEL_1
));
128 dprintk0(sd
->dev
, "tvp5150: Analog channel controls = 0x%02x\n",
129 tvp5150_read(sd
, TVP5150_ANAL_CHL_CTL
));
130 dprintk0(sd
->dev
, "tvp5150: Operation mode controls = 0x%02x\n",
131 tvp5150_read(sd
, TVP5150_OP_MODE_CTL
));
132 dprintk0(sd
->dev
, "tvp5150: Miscellaneous controls = 0x%02x\n",
133 tvp5150_read(sd
, TVP5150_MISC_CTL
));
134 dprintk0(sd
->dev
, "tvp5150: Autoswitch mask= 0x%02x\n",
135 tvp5150_read(sd
, TVP5150_AUTOSW_MSK
));
136 dprintk0(sd
->dev
, "tvp5150: Color killer threshold control = 0x%02x\n",
137 tvp5150_read(sd
, TVP5150_COLOR_KIL_THSH_CTL
));
138 dprintk0(sd
->dev
, "tvp5150: Luminance processing controls #1 #2 and #3 = %02x %02x %02x\n",
139 tvp5150_read(sd
, TVP5150_LUMA_PROC_CTL_1
),
140 tvp5150_read(sd
, TVP5150_LUMA_PROC_CTL_2
),
141 tvp5150_read(sd
, TVP5150_LUMA_PROC_CTL_3
));
142 dprintk0(sd
->dev
, "tvp5150: Brightness control = 0x%02x\n",
143 tvp5150_read(sd
, TVP5150_BRIGHT_CTL
));
144 dprintk0(sd
->dev
, "tvp5150: Color saturation control = 0x%02x\n",
145 tvp5150_read(sd
, TVP5150_SATURATION_CTL
));
146 dprintk0(sd
->dev
, "tvp5150: Hue control = 0x%02x\n",
147 tvp5150_read(sd
, TVP5150_HUE_CTL
));
148 dprintk0(sd
->dev
, "tvp5150: Contrast control = 0x%02x\n",
149 tvp5150_read(sd
, TVP5150_CONTRAST_CTL
));
150 dprintk0(sd
->dev
, "tvp5150: Outputs and data rates select = 0x%02x\n",
151 tvp5150_read(sd
, TVP5150_DATA_RATE_SEL
));
152 dprintk0(sd
->dev
, "tvp5150: Configuration shared pins = 0x%02x\n",
153 tvp5150_read(sd
, TVP5150_CONF_SHARED_PIN
));
154 dprintk0(sd
->dev
, "tvp5150: Active video cropping start = 0x%02x%02x\n",
155 tvp5150_read(sd
, TVP5150_ACT_VD_CROP_ST_MSB
),
156 tvp5150_read(sd
, TVP5150_ACT_VD_CROP_ST_LSB
));
157 dprintk0(sd
->dev
, "tvp5150: Active video cropping stop = 0x%02x%02x\n",
158 tvp5150_read(sd
, TVP5150_ACT_VD_CROP_STP_MSB
),
159 tvp5150_read(sd
, TVP5150_ACT_VD_CROP_STP_LSB
));
160 dprintk0(sd
->dev
, "tvp5150: Genlock/RTC = 0x%02x\n",
161 tvp5150_read(sd
, TVP5150_GENLOCK
));
162 dprintk0(sd
->dev
, "tvp5150: Horizontal sync start = 0x%02x\n",
163 tvp5150_read(sd
, TVP5150_HORIZ_SYNC_START
));
164 dprintk0(sd
->dev
, "tvp5150: Vertical blanking start = 0x%02x\n",
165 tvp5150_read(sd
, TVP5150_VERT_BLANKING_START
));
166 dprintk0(sd
->dev
, "tvp5150: Vertical blanking stop = 0x%02x\n",
167 tvp5150_read(sd
, TVP5150_VERT_BLANKING_STOP
));
168 dprintk0(sd
->dev
, "tvp5150: Chrominance processing control #1 and #2 = %02x %02x\n",
169 tvp5150_read(sd
, TVP5150_CHROMA_PROC_CTL_1
),
170 tvp5150_read(sd
, TVP5150_CHROMA_PROC_CTL_2
));
171 dprintk0(sd
->dev
, "tvp5150: Interrupt reset register B = 0x%02x\n",
172 tvp5150_read(sd
, TVP5150_INT_RESET_REG_B
));
173 dprintk0(sd
->dev
, "tvp5150: Interrupt enable register B = 0x%02x\n",
174 tvp5150_read(sd
, TVP5150_INT_ENABLE_REG_B
));
175 dprintk0(sd
->dev
, "tvp5150: Interrupt configuration register B = 0x%02x\n",
176 tvp5150_read(sd
, TVP5150_INTT_CONFIG_REG_B
));
177 dprintk0(sd
->dev
, "tvp5150: Video standard = 0x%02x\n",
178 tvp5150_read(sd
, TVP5150_VIDEO_STD
));
179 dprintk0(sd
->dev
, "tvp5150: Chroma gain factor: Cb=0x%02x Cr=0x%02x\n",
180 tvp5150_read(sd
, TVP5150_CB_GAIN_FACT
),
181 tvp5150_read(sd
, TVP5150_CR_GAIN_FACTOR
));
182 dprintk0(sd
->dev
, "tvp5150: Macrovision on counter = 0x%02x\n",
183 tvp5150_read(sd
, TVP5150_MACROVISION_ON_CTR
));
184 dprintk0(sd
->dev
, "tvp5150: Macrovision off counter = 0x%02x\n",
185 tvp5150_read(sd
, TVP5150_MACROVISION_OFF_CTR
));
186 dprintk0(sd
->dev
, "tvp5150: ITU-R BT.656.%d timing(TVP5150AM1 only)\n",
187 (tvp5150_read(sd
, TVP5150_REV_SELECT
) & 1) ? 3 : 4);
188 dprintk0(sd
->dev
, "tvp5150: Device ID = %02x%02x\n",
189 tvp5150_read(sd
, TVP5150_MSB_DEV_ID
),
190 tvp5150_read(sd
, TVP5150_LSB_DEV_ID
));
191 dprintk0(sd
->dev
, "tvp5150: ROM version = (hex) %02x.%02x\n",
192 tvp5150_read(sd
, TVP5150_ROM_MAJOR_VER
),
193 tvp5150_read(sd
, TVP5150_ROM_MINOR_VER
));
194 dprintk0(sd
->dev
, "tvp5150: Vertical line count = 0x%02x%02x\n",
195 tvp5150_read(sd
, TVP5150_VERT_LN_COUNT_MSB
),
196 tvp5150_read(sd
, TVP5150_VERT_LN_COUNT_LSB
));
197 dprintk0(sd
->dev
, "tvp5150: Interrupt status register B = 0x%02x\n",
198 tvp5150_read(sd
, TVP5150_INT_STATUS_REG_B
));
199 dprintk0(sd
->dev
, "tvp5150: Interrupt active register B = 0x%02x\n",
200 tvp5150_read(sd
, TVP5150_INT_ACTIVE_REG_B
));
201 dprintk0(sd
->dev
, "tvp5150: Status regs #1 to #5 = %02x %02x %02x %02x %02x\n",
202 tvp5150_read(sd
, TVP5150_STATUS_REG_1
),
203 tvp5150_read(sd
, TVP5150_STATUS_REG_2
),
204 tvp5150_read(sd
, TVP5150_STATUS_REG_3
),
205 tvp5150_read(sd
, TVP5150_STATUS_REG_4
),
206 tvp5150_read(sd
, TVP5150_STATUS_REG_5
));
208 dump_reg_range(sd
, "Teletext filter 1", TVP5150_TELETEXT_FIL1_INI
,
209 TVP5150_TELETEXT_FIL1_END
, 8);
210 dump_reg_range(sd
, "Teletext filter 2", TVP5150_TELETEXT_FIL2_INI
,
211 TVP5150_TELETEXT_FIL2_END
, 8);
213 dprintk0(sd
->dev
, "tvp5150: Teletext filter enable = 0x%02x\n",
214 tvp5150_read(sd
, TVP5150_TELETEXT_FIL_ENA
));
215 dprintk0(sd
->dev
, "tvp5150: Interrupt status register A = 0x%02x\n",
216 tvp5150_read(sd
, TVP5150_INT_STATUS_REG_A
));
217 dprintk0(sd
->dev
, "tvp5150: Interrupt enable register A = 0x%02x\n",
218 tvp5150_read(sd
, TVP5150_INT_ENABLE_REG_A
));
219 dprintk0(sd
->dev
, "tvp5150: Interrupt configuration = 0x%02x\n",
220 tvp5150_read(sd
, TVP5150_INT_CONF
));
221 dprintk0(sd
->dev
, "tvp5150: VDP status register = 0x%02x\n",
222 tvp5150_read(sd
, TVP5150_VDP_STATUS_REG
));
223 dprintk0(sd
->dev
, "tvp5150: FIFO word count = 0x%02x\n",
224 tvp5150_read(sd
, TVP5150_FIFO_WORD_COUNT
));
225 dprintk0(sd
->dev
, "tvp5150: FIFO interrupt threshold = 0x%02x\n",
226 tvp5150_read(sd
, TVP5150_FIFO_INT_THRESHOLD
));
227 dprintk0(sd
->dev
, "tvp5150: FIFO reset = 0x%02x\n",
228 tvp5150_read(sd
, TVP5150_FIFO_RESET
));
229 dprintk0(sd
->dev
, "tvp5150: Line number interrupt = 0x%02x\n",
230 tvp5150_read(sd
, TVP5150_LINE_NUMBER_INT
));
231 dprintk0(sd
->dev
, "tvp5150: Pixel alignment register = 0x%02x%02x\n",
232 tvp5150_read(sd
, TVP5150_PIX_ALIGN_REG_HIGH
),
233 tvp5150_read(sd
, TVP5150_PIX_ALIGN_REG_LOW
));
234 dprintk0(sd
->dev
, "tvp5150: FIFO output control = 0x%02x\n",
235 tvp5150_read(sd
, TVP5150_FIFO_OUT_CTRL
));
236 dprintk0(sd
->dev
, "tvp5150: Full field enable = 0x%02x\n",
237 tvp5150_read(sd
, TVP5150_FULL_FIELD_ENA
));
238 dprintk0(sd
->dev
, "tvp5150: Full field mode register = 0x%02x\n",
239 tvp5150_read(sd
, TVP5150_FULL_FIELD_MODE_REG
));
241 dump_reg_range(sd
, "CC data", TVP5150_CC_DATA_INI
,
242 TVP5150_CC_DATA_END
, 8);
244 dump_reg_range(sd
, "WSS data", TVP5150_WSS_DATA_INI
,
245 TVP5150_WSS_DATA_END
, 8);
247 dump_reg_range(sd
, "VPS data", TVP5150_VPS_DATA_INI
,
248 TVP5150_VPS_DATA_END
, 8);
250 dump_reg_range(sd
, "VITC data", TVP5150_VITC_DATA_INI
,
251 TVP5150_VITC_DATA_END
, 10);
253 dump_reg_range(sd
, "Line mode", TVP5150_LINE_MODE_INI
,
254 TVP5150_LINE_MODE_END
, 8);
258 /****************************************************************************
260 ****************************************************************************/
262 static void tvp5150_selmux(struct v4l2_subdev
*sd
)
265 struct tvp5150
*decoder
= to_tvp5150(sd
);
269 /* Only tvp5150am1 and tvp5151 have signal generator support */
270 if ((decoder
->dev_id
== 0x5150 && decoder
->rom_ver
== 0x0400) ||
271 (decoder
->dev_id
== 0x5151 && decoder
->rom_ver
== 0x0100)) {
272 if (!decoder
->enable
)
276 switch (decoder
->input
) {
277 case TVP5150_COMPOSITE1
:
280 case TVP5150_COMPOSITE0
:
288 dev_dbg_lvl(sd
->dev
, 1, debug
, "Selecting video route: route input=%i, output=%i => tvp5150 input=%i, opmode=%i\n",
289 decoder
->input
, decoder
->output
,
292 tvp5150_write(sd
, TVP5150_OP_MODE_CTL
, opmode
);
293 tvp5150_write(sd
, TVP5150_VD_IN_SRC_SEL_1
, input
);
296 * Setup the FID/GLCO/VLK/HVLK and INTREQ/GPCL/VBLK output signals. For
297 * S-Video we output the vertical lock (VLK) signal on FID/GLCO/VLK/HVLK
298 * and set INTREQ/GPCL/VBLK to logic 0. For composite we output the
299 * field indicator (FID) signal on FID/GLCO/VLK/HVLK and set
300 * INTREQ/GPCL/VBLK to logic 1.
302 val
= tvp5150_read(sd
, TVP5150_MISC_CTL
);
304 dev_err(sd
->dev
, "%s: failed with error = %d\n", __func__
, val
);
308 if (decoder
->input
== TVP5150_SVIDEO
)
309 val
= (val
& ~TVP5150_MISC_CTL_GPCL
) | TVP5150_MISC_CTL_HVLK
;
311 val
= (val
& ~TVP5150_MISC_CTL_HVLK
) | TVP5150_MISC_CTL_GPCL
;
312 tvp5150_write(sd
, TVP5150_MISC_CTL
, val
);
315 struct i2c_reg_value
{
320 /* Default values as sugested at TVP5150AM1 datasheet */
321 static const struct i2c_reg_value tvp5150_init_default
[] = {
323 TVP5150_VD_IN_SRC_SEL_1
,0x00
326 TVP5150_ANAL_CHL_CTL
,0x15
329 TVP5150_OP_MODE_CTL
,0x00
332 TVP5150_MISC_CTL
,0x01
335 TVP5150_COLOR_KIL_THSH_CTL
,0x10
338 TVP5150_LUMA_PROC_CTL_1
,0x60
341 TVP5150_LUMA_PROC_CTL_2
,0x00
344 TVP5150_BRIGHT_CTL
,0x80
347 TVP5150_SATURATION_CTL
,0x80
353 TVP5150_CONTRAST_CTL
,0x80
356 TVP5150_DATA_RATE_SEL
,0x47
359 TVP5150_LUMA_PROC_CTL_3
,0x00
362 TVP5150_CONF_SHARED_PIN
,0x08
365 TVP5150_ACT_VD_CROP_ST_MSB
,0x00
368 TVP5150_ACT_VD_CROP_ST_LSB
,0x00
371 TVP5150_ACT_VD_CROP_STP_MSB
,0x00
374 TVP5150_ACT_VD_CROP_STP_LSB
,0x00
380 TVP5150_HORIZ_SYNC_START
,0x80
383 TVP5150_VERT_BLANKING_START
,0x00
386 TVP5150_VERT_BLANKING_STOP
,0x00
389 TVP5150_CHROMA_PROC_CTL_1
,0x0c
392 TVP5150_CHROMA_PROC_CTL_2
,0x14
395 TVP5150_INT_RESET_REG_B
,0x00
398 TVP5150_INT_ENABLE_REG_B
,0x00
401 TVP5150_INTT_CONFIG_REG_B
,0x00
404 TVP5150_VIDEO_STD
,0x00
407 TVP5150_MACROVISION_ON_CTR
,0x0f
410 TVP5150_MACROVISION_OFF_CTR
,0x01
413 TVP5150_TELETEXT_FIL_ENA
,0x00
416 TVP5150_INT_STATUS_REG_A
,0x00
419 TVP5150_INT_ENABLE_REG_A
,0x00
422 TVP5150_INT_CONF
,0x04
425 TVP5150_FIFO_INT_THRESHOLD
,0x80
428 TVP5150_FIFO_RESET
,0x00
431 TVP5150_LINE_NUMBER_INT
,0x00
434 TVP5150_PIX_ALIGN_REG_LOW
,0x4e
437 TVP5150_PIX_ALIGN_REG_HIGH
,0x00
440 TVP5150_FIFO_OUT_CTRL
,0x01
443 TVP5150_FULL_FIELD_ENA
,0x00
446 TVP5150_LINE_MODE_INI
,0x00
449 TVP5150_FULL_FIELD_MODE_REG
,0x7f
456 /* Default values as sugested at TVP5150AM1 datasheet */
457 static const struct i2c_reg_value tvp5150_init_enable
[] = {
459 TVP5150_CONF_SHARED_PIN
, 2
460 },{ /* Automatic offset and AGC enabled */
461 TVP5150_ANAL_CHL_CTL
, 0x15
462 },{ /* Activate YCrCb output 0x9 or 0xd ? */
463 TVP5150_MISC_CTL
, TVP5150_MISC_CTL_GPCL
|
464 TVP5150_MISC_CTL_INTREQ_OE
|
465 TVP5150_MISC_CTL_YCBCR_OE
|
466 TVP5150_MISC_CTL_SYNC_OE
|
467 TVP5150_MISC_CTL_VBLANK
|
468 TVP5150_MISC_CTL_CLOCK_OE
,
469 },{ /* Activates video std autodetection for all standards */
470 TVP5150_AUTOSW_MSK
, 0x0
471 },{ /* Default format: 0x47. For 4:2:2: 0x40 */
472 TVP5150_DATA_RATE_SEL
, 0x47
474 TVP5150_CHROMA_PROC_CTL_1
, 0x0c
476 TVP5150_CHROMA_PROC_CTL_2
, 0x54
477 },{ /* Non documented, but initialized on WinTV USB2 */
484 struct tvp5150_vbi_type
{
485 unsigned int vbi_type
;
486 unsigned int ini_line
;
487 unsigned int end_line
;
488 unsigned int by_field
:1;
491 struct i2c_vbi_ram_value
{
493 struct tvp5150_vbi_type type
;
494 unsigned char values
[16];
497 /* This struct have the values for each supported VBI Standard
499 tvp5150_vbi_types should follow the same order as vbi_ram_default
500 * value 0 means rom position 0x10, value 1 means rom position 0x30
501 * and so on. There are 16 possible locations from 0 to 15.
504 static struct i2c_vbi_ram_value vbi_ram_default
[] =
506 /* FIXME: Current api doesn't handle all VBI types, those not
507 yet supported are placed under #if 0 */
509 {0x010, /* Teletext, SECAM, WST System A */
510 {V4L2_SLICED_TELETEXT_SECAM
,6,23,1},
511 { 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x26,
512 0xe6, 0xb4, 0x0e, 0x00, 0x00, 0x00, 0x10, 0x00 }
515 {0x030, /* Teletext, PAL, WST System B */
516 {V4L2_SLICED_TELETEXT_B
,6,22,1},
517 { 0xaa, 0xaa, 0xff, 0xff, 0x27, 0x2e, 0x20, 0x2b,
518 0xa6, 0x72, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00 }
521 {0x050, /* Teletext, PAL, WST System C */
522 {V4L2_SLICED_TELETEXT_PAL_C
,6,22,1},
523 { 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x22,
524 0xa6, 0x98, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
526 {0x070, /* Teletext, NTSC, WST System B */
527 {V4L2_SLICED_TELETEXT_NTSC_B
,10,21,1},
528 { 0xaa, 0xaa, 0xff, 0xff, 0x27, 0x2e, 0x20, 0x23,
529 0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
531 {0x090, /* Tetetext, NTSC NABTS System C */
532 {V4L2_SLICED_TELETEXT_NTSC_C
,10,21,1},
533 { 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x22,
534 0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x15, 0x00 }
536 {0x0b0, /* Teletext, NTSC-J, NABTS System D */
537 {V4L2_SLICED_TELETEXT_NTSC_D
,10,21,1},
538 { 0xaa, 0xaa, 0xff, 0xff, 0xa7, 0x2e, 0x20, 0x23,
539 0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
541 {0x0d0, /* Closed Caption, PAL/SECAM */
542 {V4L2_SLICED_CAPTION_625
,22,22,1},
543 { 0xaa, 0x2a, 0xff, 0x3f, 0x04, 0x51, 0x6e, 0x02,
544 0xa6, 0x7b, 0x09, 0x00, 0x00, 0x00, 0x27, 0x00 }
547 {0x0f0, /* Closed Caption, NTSC */
548 {V4L2_SLICED_CAPTION_525
,21,21,1},
549 { 0xaa, 0x2a, 0xff, 0x3f, 0x04, 0x51, 0x6e, 0x02,
550 0x69, 0x8c, 0x09, 0x00, 0x00, 0x00, 0x27, 0x00 }
552 {0x110, /* Wide Screen Signal, PAL/SECAM */
553 {V4L2_SLICED_WSS_625
,23,23,1},
554 { 0x5b, 0x55, 0xc5, 0xff, 0x00, 0x71, 0x6e, 0x42,
555 0xa6, 0xcd, 0x0f, 0x00, 0x00, 0x00, 0x3a, 0x00 }
558 {0x130, /* Wide Screen Signal, NTSC C */
559 {V4L2_SLICED_WSS_525
,20,20,1},
560 { 0x38, 0x00, 0x3f, 0x00, 0x00, 0x71, 0x6e, 0x43,
561 0x69, 0x7c, 0x08, 0x00, 0x00, 0x00, 0x39, 0x00 }
563 {0x150, /* Vertical Interval Timecode (VITC), PAL/SECAM */
564 {V4l2_SLICED_VITC_625
,6,22,0},
565 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x6d, 0x49,
566 0xa6, 0x85, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00 }
568 {0x170, /* Vertical Interval Timecode (VITC), NTSC */
569 {V4l2_SLICED_VITC_525
,10,20,0},
570 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x6d, 0x49,
571 0x69, 0x94, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00 }
574 {0x190, /* Video Program System (VPS), PAL */
575 {V4L2_SLICED_VPS
,16,16,0},
576 { 0xaa, 0xaa, 0xff, 0xff, 0xba, 0xce, 0x2b, 0x0d,
577 0xa6, 0xda, 0x0b, 0x00, 0x00, 0x00, 0x60, 0x00 }
579 /* 0x1d0 User programmable */
585 static int tvp5150_write_inittab(struct v4l2_subdev
*sd
,
586 const struct i2c_reg_value
*regs
)
588 while (regs
->reg
!= 0xff) {
589 tvp5150_write(sd
, regs
->reg
, regs
->value
);
595 static int tvp5150_vdp_init(struct v4l2_subdev
*sd
,
596 const struct i2c_vbi_ram_value
*regs
)
600 /* Disable Full Field */
601 tvp5150_write(sd
, TVP5150_FULL_FIELD_ENA
, 0);
603 /* Before programming, Line mode should be at 0xff */
604 for (i
= TVP5150_LINE_MODE_INI
; i
<= TVP5150_LINE_MODE_END
; i
++)
605 tvp5150_write(sd
, i
, 0xff);
608 while (regs
->reg
!= (u16
)-1) {
609 tvp5150_write(sd
, TVP5150_CONF_RAM_ADDR_HIGH
, regs
->reg
>> 8);
610 tvp5150_write(sd
, TVP5150_CONF_RAM_ADDR_LOW
, regs
->reg
);
612 for (i
= 0; i
< 16; i
++)
613 tvp5150_write(sd
, TVP5150_VDP_CONF_RAM_DATA
, regs
->values
[i
]);
620 /* Fills VBI capabilities based on i2c_vbi_ram_value struct */
621 static int tvp5150_g_sliced_vbi_cap(struct v4l2_subdev
*sd
,
622 struct v4l2_sliced_vbi_cap
*cap
)
624 const struct i2c_vbi_ram_value
*regs
= vbi_ram_default
;
627 dev_dbg_lvl(sd
->dev
, 1, debug
, "g_sliced_vbi_cap\n");
628 memset(cap
, 0, sizeof *cap
);
630 while (regs
->reg
!= (u16
)-1 ) {
631 for (line
=regs
->type
.ini_line
;line
<=regs
->type
.end_line
;line
++) {
632 cap
->service_lines
[0][line
] |= regs
->type
.vbi_type
;
634 cap
->service_set
|= regs
->type
.vbi_type
;
641 /* Set vbi processing
642 * type - one of tvp5150_vbi_types
643 * line - line to gather data
644 * fields: bit 0 field1, bit 1, field2
645 * flags (default=0xf0) is a bitmask, were set means:
646 * bit 7: enable filtering null bytes on CC
647 * bit 6: send data also to FIFO
648 * bit 5: don't allow data with errors on FIFO
649 * bit 4: enable ECC when possible
650 * pix_align = pix alignment:
654 static int tvp5150_set_vbi(struct v4l2_subdev
*sd
,
655 const struct i2c_vbi_ram_value
*regs
,
656 unsigned int type
,u8 flags
, int line
,
659 struct tvp5150
*decoder
= to_tvp5150(sd
);
660 v4l2_std_id std
= decoder
->norm
;
664 if (std
== V4L2_STD_ALL
) {
665 dev_err(sd
->dev
, "VBI can't be configured without knowing number of lines\n");
667 } else if (std
& V4L2_STD_625_50
) {
668 /* Don't follow NTSC Line number convension */
675 while (regs
->reg
!= (u16
)-1 ) {
676 if ((type
& regs
->type
.vbi_type
) &&
677 (line
>=regs
->type
.ini_line
) &&
678 (line
<=regs
->type
.end_line
)) {
679 type
=regs
->type
.vbi_type
;
686 if (regs
->reg
== (u16
)-1)
689 type
=pos
| (flags
& 0xf0);
690 reg
=((line
-6)<<1)+TVP5150_LINE_MODE_INI
;
693 tvp5150_write(sd
, reg
, type
);
697 tvp5150_write(sd
, reg
+1, type
);
703 static int tvp5150_get_vbi(struct v4l2_subdev
*sd
,
704 const struct i2c_vbi_ram_value
*regs
, int line
)
706 struct tvp5150
*decoder
= to_tvp5150(sd
);
707 v4l2_std_id std
= decoder
->norm
;
712 if (std
== V4L2_STD_ALL
) {
713 dev_err(sd
->dev
, "VBI can't be configured without knowing number of lines\n");
715 } else if (std
& V4L2_STD_625_50
) {
716 /* Don't follow NTSC Line number convension */
720 if (line
< 6 || line
> 27)
723 reg
= ((line
- 6) << 1) + TVP5150_LINE_MODE_INI
;
725 for (i
= 0; i
<= 1; i
++) {
726 ret
= tvp5150_read(sd
, reg
+ i
);
728 dev_err(sd
->dev
, "%s: failed with error = %d\n",
734 type
|= regs
[pos
].type
.vbi_type
;
740 static int tvp5150_set_std(struct v4l2_subdev
*sd
, v4l2_std_id std
)
742 struct tvp5150
*decoder
= to_tvp5150(sd
);
747 /* First tests should be against specific std */
749 if (std
== V4L2_STD_NTSC_443
) {
750 fmt
= VIDEO_STD_NTSC_4_43_BIT
;
751 } else if (std
== V4L2_STD_PAL_M
) {
752 fmt
= VIDEO_STD_PAL_M_BIT
;
753 } else if (std
== V4L2_STD_PAL_N
|| std
== V4L2_STD_PAL_Nc
) {
754 fmt
= VIDEO_STD_PAL_COMBINATION_N_BIT
;
756 /* Then, test against generic ones */
757 if (std
& V4L2_STD_NTSC
)
758 fmt
= VIDEO_STD_NTSC_MJ_BIT
;
759 else if (std
& V4L2_STD_PAL
)
760 fmt
= VIDEO_STD_PAL_BDGHIN_BIT
;
761 else if (std
& V4L2_STD_SECAM
)
762 fmt
= VIDEO_STD_SECAM_BIT
;
765 dev_dbg_lvl(sd
->dev
, 1, debug
, "Set video std register to %d.\n", fmt
);
766 tvp5150_write(sd
, TVP5150_VIDEO_STD
, fmt
);
770 static int tvp5150_s_std(struct v4l2_subdev
*sd
, v4l2_std_id std
)
772 struct tvp5150
*decoder
= to_tvp5150(sd
);
774 if (decoder
->norm
== std
)
777 /* Change cropping height limits */
778 if (std
& V4L2_STD_525_60
)
779 decoder
->rect
.height
= TVP5150_V_MAX_525_60
;
781 decoder
->rect
.height
= TVP5150_V_MAX_OTHERS
;
784 return tvp5150_set_std(sd
, std
);
787 static int tvp5150_reset(struct v4l2_subdev
*sd
, u32 val
)
789 struct tvp5150
*decoder
= to_tvp5150(sd
);
791 /* Initializes TVP5150 to its default values */
792 tvp5150_write_inittab(sd
, tvp5150_init_default
);
794 /* Initializes VDP registers */
795 tvp5150_vdp_init(sd
, vbi_ram_default
);
797 /* Selects decoder input */
800 /* Initializes TVP5150 to stream enabled values */
801 tvp5150_write_inittab(sd
, tvp5150_init_enable
);
803 /* Initialize image preferences */
804 v4l2_ctrl_handler_setup(&decoder
->hdl
);
806 tvp5150_set_std(sd
, decoder
->norm
);
808 if (decoder
->mbus_type
== V4L2_MBUS_PARALLEL
)
809 tvp5150_write(sd
, TVP5150_DATA_RATE_SEL
, 0x40);
814 static int tvp5150_s_ctrl(struct v4l2_ctrl
*ctrl
)
816 struct v4l2_subdev
*sd
= to_sd(ctrl
);
817 struct tvp5150
*decoder
= to_tvp5150(sd
);
820 case V4L2_CID_BRIGHTNESS
:
821 tvp5150_write(sd
, TVP5150_BRIGHT_CTL
, ctrl
->val
);
823 case V4L2_CID_CONTRAST
:
824 tvp5150_write(sd
, TVP5150_CONTRAST_CTL
, ctrl
->val
);
826 case V4L2_CID_SATURATION
:
827 tvp5150_write(sd
, TVP5150_SATURATION_CTL
, ctrl
->val
);
830 tvp5150_write(sd
, TVP5150_HUE_CTL
, ctrl
->val
);
832 case V4L2_CID_TEST_PATTERN
:
833 decoder
->enable
= ctrl
->val
? false : true;
840 static v4l2_std_id
tvp5150_read_std(struct v4l2_subdev
*sd
)
842 int val
= tvp5150_read(sd
, TVP5150_STATUS_REG_5
);
844 switch (val
& 0x0F) {
846 return V4L2_STD_NTSC
;
850 return V4L2_STD_PAL_M
;
852 return V4L2_STD_PAL_N
| V4L2_STD_PAL_Nc
;
854 return V4L2_STD_NTSC_443
;
856 return V4L2_STD_SECAM
;
858 return V4L2_STD_UNKNOWN
;
862 static int tvp5150_fill_fmt(struct v4l2_subdev
*sd
,
863 struct v4l2_subdev_pad_config
*cfg
,
864 struct v4l2_subdev_format
*format
)
866 struct v4l2_mbus_framefmt
*f
;
867 struct tvp5150
*decoder
= to_tvp5150(sd
);
869 if (!format
|| (format
->pad
!= DEMOD_PAD_VID_OUT
))
874 f
->width
= decoder
->rect
.width
;
875 f
->height
= decoder
->rect
.height
;
877 f
->code
= MEDIA_BUS_FMT_UYVY8_2X8
;
878 f
->field
= V4L2_FIELD_ALTERNATE
;
879 f
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
881 dev_dbg_lvl(sd
->dev
, 1, debug
, "width = %d, height = %d\n", f
->width
,
886 static int tvp5150_set_selection(struct v4l2_subdev
*sd
,
887 struct v4l2_subdev_pad_config
*cfg
,
888 struct v4l2_subdev_selection
*sel
)
890 struct tvp5150
*decoder
= to_tvp5150(sd
);
891 struct v4l2_rect rect
= sel
->r
;
895 if (sel
->which
!= V4L2_SUBDEV_FORMAT_ACTIVE
||
896 sel
->target
!= V4L2_SEL_TGT_CROP
)
899 dev_dbg_lvl(sd
->dev
, 1, debug
, "%s left=%d, top=%d, width=%d, height=%d\n",
900 __func__
, rect
.left
, rect
.top
, rect
.width
, rect
.height
);
902 /* tvp5150 has some special limits */
903 rect
.left
= clamp(rect
.left
, 0, TVP5150_MAX_CROP_LEFT
);
904 rect
.width
= clamp_t(unsigned int, rect
.width
,
905 TVP5150_H_MAX
- TVP5150_MAX_CROP_LEFT
- rect
.left
,
906 TVP5150_H_MAX
- rect
.left
);
907 rect
.top
= clamp(rect
.top
, 0, TVP5150_MAX_CROP_TOP
);
909 /* Calculate height based on current standard */
910 if (decoder
->norm
== V4L2_STD_ALL
)
911 std
= tvp5150_read_std(sd
);
915 if (std
& V4L2_STD_525_60
)
916 hmax
= TVP5150_V_MAX_525_60
;
918 hmax
= TVP5150_V_MAX_OTHERS
;
920 rect
.height
= clamp_t(unsigned int, rect
.height
,
921 hmax
- TVP5150_MAX_CROP_TOP
- rect
.top
,
924 tvp5150_write(sd
, TVP5150_VERT_BLANKING_START
, rect
.top
);
925 tvp5150_write(sd
, TVP5150_VERT_BLANKING_STOP
,
926 rect
.top
+ rect
.height
- hmax
);
927 tvp5150_write(sd
, TVP5150_ACT_VD_CROP_ST_MSB
,
928 rect
.left
>> TVP5150_CROP_SHIFT
);
929 tvp5150_write(sd
, TVP5150_ACT_VD_CROP_ST_LSB
,
930 rect
.left
| (1 << TVP5150_CROP_SHIFT
));
931 tvp5150_write(sd
, TVP5150_ACT_VD_CROP_STP_MSB
,
932 (rect
.left
+ rect
.width
- TVP5150_MAX_CROP_LEFT
) >>
934 tvp5150_write(sd
, TVP5150_ACT_VD_CROP_STP_LSB
,
935 rect
.left
+ rect
.width
- TVP5150_MAX_CROP_LEFT
);
937 decoder
->rect
= rect
;
942 static int tvp5150_get_selection(struct v4l2_subdev
*sd
,
943 struct v4l2_subdev_pad_config
*cfg
,
944 struct v4l2_subdev_selection
*sel
)
946 struct tvp5150
*decoder
= container_of(sd
, struct tvp5150
, sd
);
949 if (sel
->which
!= V4L2_SUBDEV_FORMAT_ACTIVE
)
952 switch (sel
->target
) {
953 case V4L2_SEL_TGT_CROP_BOUNDS
:
954 case V4L2_SEL_TGT_CROP_DEFAULT
:
957 sel
->r
.width
= TVP5150_H_MAX
;
959 /* Calculate height based on current standard */
960 if (decoder
->norm
== V4L2_STD_ALL
)
961 std
= tvp5150_read_std(sd
);
964 if (std
& V4L2_STD_525_60
)
965 sel
->r
.height
= TVP5150_V_MAX_525_60
;
967 sel
->r
.height
= TVP5150_V_MAX_OTHERS
;
969 case V4L2_SEL_TGT_CROP
:
970 sel
->r
= decoder
->rect
;
977 static int tvp5150_g_mbus_config(struct v4l2_subdev
*sd
,
978 struct v4l2_mbus_config
*cfg
)
980 struct tvp5150
*decoder
= to_tvp5150(sd
);
982 cfg
->type
= decoder
->mbus_type
;
983 cfg
->flags
= V4L2_MBUS_MASTER
| V4L2_MBUS_PCLK_SAMPLE_RISING
984 | V4L2_MBUS_FIELD_EVEN_LOW
| V4L2_MBUS_DATA_ACTIVE_HIGH
;
989 /****************************************************************************
991 ****************************************************************************/
992 static int tvp5150_enum_mbus_code(struct v4l2_subdev
*sd
,
993 struct v4l2_subdev_pad_config
*cfg
,
994 struct v4l2_subdev_mbus_code_enum
*code
)
996 if (code
->pad
|| code
->index
)
999 code
->code
= MEDIA_BUS_FMT_UYVY8_2X8
;
1003 static int tvp5150_enum_frame_size(struct v4l2_subdev
*sd
,
1004 struct v4l2_subdev_pad_config
*cfg
,
1005 struct v4l2_subdev_frame_size_enum
*fse
)
1007 struct tvp5150
*decoder
= to_tvp5150(sd
);
1009 if (fse
->index
>= 8 || fse
->code
!= MEDIA_BUS_FMT_UYVY8_2X8
)
1012 fse
->code
= MEDIA_BUS_FMT_UYVY8_2X8
;
1013 fse
->min_width
= decoder
->rect
.width
;
1014 fse
->max_width
= decoder
->rect
.width
;
1015 fse
->min_height
= decoder
->rect
.height
/ 2;
1016 fse
->max_height
= decoder
->rect
.height
/ 2;
1021 /****************************************************************************
1023 ****************************************************************************/
1025 #ifdef CONFIG_MEDIA_CONTROLLER
1026 static int tvp5150_link_setup(struct media_entity
*entity
,
1027 const struct media_pad
*local
,
1028 const struct media_pad
*remote
, u32 flags
)
1030 struct v4l2_subdev
*sd
= media_entity_to_v4l2_subdev(entity
);
1031 struct tvp5150
*decoder
= to_tvp5150(sd
);
1034 for (i
= 0; i
< TVP5150_INPUT_NUM
; i
++) {
1035 if (remote
->entity
== &decoder
->input_ent
[i
])
1039 /* Do nothing for entities that are not input connectors */
1040 if (i
== TVP5150_INPUT_NUM
)
1050 static const struct media_entity_operations tvp5150_sd_media_ops
= {
1051 .link_setup
= tvp5150_link_setup
,
1055 /****************************************************************************
1057 ****************************************************************************/
1059 static int tvp5150_s_stream(struct v4l2_subdev
*sd
, int enable
)
1061 struct tvp5150
*decoder
= to_tvp5150(sd
);
1064 /* Enable or disable the video output signals. */
1065 val
= tvp5150_read(sd
, TVP5150_MISC_CTL
);
1069 val
&= ~(TVP5150_MISC_CTL_YCBCR_OE
| TVP5150_MISC_CTL_SYNC_OE
|
1070 TVP5150_MISC_CTL_CLOCK_OE
);
1074 * Enable the YCbCr and clock outputs. In discrete sync mode
1075 * (non-BT.656) additionally enable the the sync outputs.
1077 val
|= TVP5150_MISC_CTL_YCBCR_OE
| TVP5150_MISC_CTL_CLOCK_OE
;
1078 if (decoder
->mbus_type
== V4L2_MBUS_PARALLEL
)
1079 val
|= TVP5150_MISC_CTL_SYNC_OE
;
1082 tvp5150_write(sd
, TVP5150_MISC_CTL
, val
);
1087 static int tvp5150_s_routing(struct v4l2_subdev
*sd
,
1088 u32 input
, u32 output
, u32 config
)
1090 struct tvp5150
*decoder
= to_tvp5150(sd
);
1092 decoder
->input
= input
;
1093 decoder
->output
= output
;
1095 if (output
== TVP5150_BLACK_SCREEN
)
1096 decoder
->enable
= false;
1098 decoder
->enable
= true;
1104 static int tvp5150_s_raw_fmt(struct v4l2_subdev
*sd
, struct v4l2_vbi_format
*fmt
)
1106 /* this is for capturing 36 raw vbi lines
1107 if there's a way to cut off the beginning 2 vbi lines
1108 with the tvp5150 then the vbi line count could be lowered
1109 to 17 lines/field again, although I couldn't find a register
1110 which could do that cropping */
1111 if (fmt
->sample_format
== V4L2_PIX_FMT_GREY
)
1112 tvp5150_write(sd
, TVP5150_LUMA_PROC_CTL_1
, 0x70);
1113 if (fmt
->count
[0] == 18 && fmt
->count
[1] == 18) {
1114 tvp5150_write(sd
, TVP5150_VERT_BLANKING_START
, 0x00);
1115 tvp5150_write(sd
, TVP5150_VERT_BLANKING_STOP
, 0x01);
1120 static int tvp5150_s_sliced_fmt(struct v4l2_subdev
*sd
, struct v4l2_sliced_vbi_format
*svbi
)
1124 if (svbi
->service_set
!= 0) {
1125 for (i
= 0; i
<= 23; i
++) {
1126 svbi
->service_lines
[1][i
] = 0;
1127 svbi
->service_lines
[0][i
] =
1128 tvp5150_set_vbi(sd
, vbi_ram_default
,
1129 svbi
->service_lines
[0][i
], 0xf0, i
, 3);
1132 tvp5150_write(sd
, TVP5150_FIFO_OUT_CTRL
, 1);
1135 tvp5150_write(sd
, TVP5150_FIFO_OUT_CTRL
, 0);
1137 /* Disable Full Field */
1138 tvp5150_write(sd
, TVP5150_FULL_FIELD_ENA
, 0);
1140 /* Disable Line modes */
1141 for (i
= TVP5150_LINE_MODE_INI
; i
<= TVP5150_LINE_MODE_END
; i
++)
1142 tvp5150_write(sd
, i
, 0xff);
1147 static int tvp5150_g_sliced_fmt(struct v4l2_subdev
*sd
, struct v4l2_sliced_vbi_format
*svbi
)
1151 memset(svbi
->service_lines
, 0, sizeof(svbi
->service_lines
));
1153 for (i
= 0; i
<= 23; i
++) {
1154 svbi
->service_lines
[0][i
] =
1155 tvp5150_get_vbi(sd
, vbi_ram_default
, i
);
1156 mask
|= svbi
->service_lines
[0][i
];
1158 svbi
->service_set
= mask
;
1162 #ifdef CONFIG_VIDEO_ADV_DEBUG
1163 static int tvp5150_g_register(struct v4l2_subdev
*sd
, struct v4l2_dbg_register
*reg
)
1167 res
= tvp5150_read(sd
, reg
->reg
& 0xff);
1169 dev_err(sd
->dev
, "%s: failed with error = %d\n", __func__
, res
);
1178 static int tvp5150_s_register(struct v4l2_subdev
*sd
, const struct v4l2_dbg_register
*reg
)
1180 return tvp5150_write(sd
, reg
->reg
& 0xff, reg
->val
& 0xff);
1184 static int tvp5150_g_tuner(struct v4l2_subdev
*sd
, struct v4l2_tuner
*vt
)
1186 int status
= tvp5150_read(sd
, 0x88);
1188 vt
->signal
= ((status
& 0x04) && (status
& 0x02)) ? 0xffff : 0x0;
1192 static int tvp5150_registered(struct v4l2_subdev
*sd
)
1194 #ifdef CONFIG_MEDIA_CONTROLLER
1195 struct tvp5150
*decoder
= to_tvp5150(sd
);
1199 for (i
= 0; i
< TVP5150_INPUT_NUM
; i
++) {
1200 struct media_entity
*input
= &decoder
->input_ent
[i
];
1201 struct media_pad
*pad
= &decoder
->input_pad
[i
];
1206 decoder
->input_pad
[i
].flags
= MEDIA_PAD_FL_SOURCE
;
1208 ret
= media_entity_pads_init(input
, 1, pad
);
1212 ret
= media_device_register_entity(sd
->v4l2_dev
->mdev
, input
);
1216 ret
= media_create_pad_link(input
, 0, &sd
->entity
,
1217 DEMOD_PAD_IF_INPUT
, 0);
1219 media_device_unregister_entity(input
);
1228 /* ----------------------------------------------------------------------- */
1230 static const struct v4l2_ctrl_ops tvp5150_ctrl_ops
= {
1231 .s_ctrl
= tvp5150_s_ctrl
,
1234 static const struct v4l2_subdev_core_ops tvp5150_core_ops
= {
1235 .log_status
= tvp5150_log_status
,
1236 .reset
= tvp5150_reset
,
1237 #ifdef CONFIG_VIDEO_ADV_DEBUG
1238 .g_register
= tvp5150_g_register
,
1239 .s_register
= tvp5150_s_register
,
1243 static const struct v4l2_subdev_tuner_ops tvp5150_tuner_ops
= {
1244 .g_tuner
= tvp5150_g_tuner
,
1247 static const struct v4l2_subdev_video_ops tvp5150_video_ops
= {
1248 .s_std
= tvp5150_s_std
,
1249 .s_stream
= tvp5150_s_stream
,
1250 .s_routing
= tvp5150_s_routing
,
1251 .g_mbus_config
= tvp5150_g_mbus_config
,
1254 static const struct v4l2_subdev_vbi_ops tvp5150_vbi_ops
= {
1255 .g_sliced_vbi_cap
= tvp5150_g_sliced_vbi_cap
,
1256 .g_sliced_fmt
= tvp5150_g_sliced_fmt
,
1257 .s_sliced_fmt
= tvp5150_s_sliced_fmt
,
1258 .s_raw_fmt
= tvp5150_s_raw_fmt
,
1261 static const struct v4l2_subdev_pad_ops tvp5150_pad_ops
= {
1262 .enum_mbus_code
= tvp5150_enum_mbus_code
,
1263 .enum_frame_size
= tvp5150_enum_frame_size
,
1264 .set_fmt
= tvp5150_fill_fmt
,
1265 .get_fmt
= tvp5150_fill_fmt
,
1266 .get_selection
= tvp5150_get_selection
,
1267 .set_selection
= tvp5150_set_selection
,
1270 static const struct v4l2_subdev_ops tvp5150_ops
= {
1271 .core
= &tvp5150_core_ops
,
1272 .tuner
= &tvp5150_tuner_ops
,
1273 .video
= &tvp5150_video_ops
,
1274 .vbi
= &tvp5150_vbi_ops
,
1275 .pad
= &tvp5150_pad_ops
,
1278 static const struct v4l2_subdev_internal_ops tvp5150_internal_ops
= {
1279 .registered
= tvp5150_registered
,
1283 /****************************************************************************
1285 ****************************************************************************/
1287 static int tvp5150_detect_version(struct tvp5150
*core
)
1289 struct v4l2_subdev
*sd
= &core
->sd
;
1290 struct i2c_client
*c
= v4l2_get_subdevdata(sd
);
1296 * Read consequent registers - TVP5150_MSB_DEV_ID, TVP5150_LSB_DEV_ID,
1297 * TVP5150_ROM_MAJOR_VER, TVP5150_ROM_MINOR_VER
1299 for (i
= 0; i
< 4; i
++) {
1300 res
= tvp5150_read(sd
, TVP5150_MSB_DEV_ID
+ i
);
1306 core
->dev_id
= (regs
[0] << 8) | regs
[1];
1307 core
->rom_ver
= (regs
[2] << 8) | regs
[3];
1309 dev_info(sd
->dev
, "tvp%04x (%u.%u) chip found @ 0x%02x (%s)\n",
1310 core
->dev_id
, regs
[2], regs
[3], c
->addr
<< 1,
1313 if (core
->dev_id
== 0x5150 && core
->rom_ver
== 0x0321) {
1314 dev_info(sd
->dev
, "tvp5150a detected.\n");
1315 } else if (core
->dev_id
== 0x5150 && core
->rom_ver
== 0x0400) {
1316 dev_info(sd
->dev
, "tvp5150am1 detected.\n");
1318 /* ITU-T BT.656.4 timing */
1319 tvp5150_write(sd
, TVP5150_REV_SELECT
, 0);
1320 } else if (core
->dev_id
== 0x5151 && core
->rom_ver
== 0x0100) {
1321 dev_info(sd
->dev
, "tvp5151 detected.\n");
1323 dev_info(sd
->dev
, "*** unknown tvp%04x chip detected.\n",
1330 static int tvp5150_init(struct i2c_client
*c
)
1332 struct gpio_desc
*pdn_gpio
;
1333 struct gpio_desc
*reset_gpio
;
1335 pdn_gpio
= devm_gpiod_get_optional(&c
->dev
, "pdn", GPIOD_OUT_HIGH
);
1336 if (IS_ERR(pdn_gpio
))
1337 return PTR_ERR(pdn_gpio
);
1340 gpiod_set_value_cansleep(pdn_gpio
, 0);
1341 /* Delay time between power supplies active and reset */
1345 reset_gpio
= devm_gpiod_get_optional(&c
->dev
, "reset", GPIOD_OUT_HIGH
);
1346 if (IS_ERR(reset_gpio
))
1347 return PTR_ERR(reset_gpio
);
1350 /* RESETB pulse duration */
1352 gpiod_set_value_cansleep(reset_gpio
, 0);
1353 /* Delay time between end of reset to I2C active */
1354 usleep_range(200, 250);
1360 static int tvp5150_parse_dt(struct tvp5150
*decoder
, struct device_node
*np
)
1362 struct v4l2_fwnode_endpoint bus_cfg
;
1363 struct device_node
*ep
;
1364 #ifdef CONFIG_MEDIA_CONTROLLER
1365 struct device_node
*connectors
, *child
;
1366 struct media_entity
*input
;
1373 ep
= of_graph_get_next_endpoint(np
, NULL
);
1377 ret
= v4l2_fwnode_endpoint_parse(of_fwnode_handle(ep
), &bus_cfg
);
1381 flags
= bus_cfg
.bus
.parallel
.flags
;
1383 if (bus_cfg
.bus_type
== V4L2_MBUS_PARALLEL
&&
1384 !(flags
& V4L2_MBUS_HSYNC_ACTIVE_HIGH
&&
1385 flags
& V4L2_MBUS_VSYNC_ACTIVE_HIGH
&&
1386 flags
& V4L2_MBUS_FIELD_EVEN_LOW
)) {
1391 decoder
->mbus_type
= bus_cfg
.bus_type
;
1393 #ifdef CONFIG_MEDIA_CONTROLLER
1394 connectors
= of_get_child_by_name(np
, "connectors");
1399 for_each_available_child_of_node(connectors
, child
) {
1400 ret
= of_property_read_u32(child
, "input", &input_type
);
1402 dev_err(decoder
->sd
.dev
,
1403 "missing type property in node %s\n",
1408 if (input_type
>= TVP5150_INPUT_NUM
) {
1413 input
= &decoder
->input_ent
[input_type
];
1415 /* Each input connector can only be defined once */
1417 dev_err(decoder
->sd
.dev
,
1418 "input %s with same type already exists\n",
1424 switch (input_type
) {
1425 case TVP5150_COMPOSITE0
:
1426 case TVP5150_COMPOSITE1
:
1427 input
->function
= MEDIA_ENT_F_CONN_COMPOSITE
;
1429 case TVP5150_SVIDEO
:
1430 input
->function
= MEDIA_ENT_F_CONN_SVIDEO
;
1434 input
->flags
= MEDIA_ENT_FL_CONNECTOR
;
1436 ret
= of_property_read_string(child
, "label", &name
);
1438 dev_err(decoder
->sd
.dev
,
1439 "missing label property in node %s\n",
1448 of_node_put(connectors
);
1455 static const char * const tvp5150_test_patterns
[2] = {
1460 static int tvp5150_probe(struct i2c_client
*c
,
1461 const struct i2c_device_id
*id
)
1463 struct tvp5150
*core
;
1464 struct v4l2_subdev
*sd
;
1465 struct device_node
*np
= c
->dev
.of_node
;
1468 /* Check if the adapter supports the needed features */
1469 if (!i2c_check_functionality(c
->adapter
,
1470 I2C_FUNC_SMBUS_READ_BYTE
| I2C_FUNC_SMBUS_WRITE_BYTE_DATA
))
1473 res
= tvp5150_init(c
);
1477 core
= devm_kzalloc(&c
->dev
, sizeof(*core
), GFP_KERNEL
);
1483 if (IS_ENABLED(CONFIG_OF
) && np
) {
1484 res
= tvp5150_parse_dt(core
, np
);
1486 dev_err(sd
->dev
, "DT parsing error: %d\n", res
);
1490 /* Default to BT.656 embedded sync */
1491 core
->mbus_type
= V4L2_MBUS_BT656
;
1494 v4l2_i2c_subdev_init(sd
, c
, &tvp5150_ops
);
1495 sd
->internal_ops
= &tvp5150_internal_ops
;
1496 sd
->flags
|= V4L2_SUBDEV_FL_HAS_DEVNODE
;
1498 #if defined(CONFIG_MEDIA_CONTROLLER)
1499 core
->pads
[DEMOD_PAD_IF_INPUT
].flags
= MEDIA_PAD_FL_SINK
;
1500 core
->pads
[DEMOD_PAD_VID_OUT
].flags
= MEDIA_PAD_FL_SOURCE
;
1501 core
->pads
[DEMOD_PAD_VBI_OUT
].flags
= MEDIA_PAD_FL_SOURCE
;
1503 sd
->entity
.function
= MEDIA_ENT_F_ATV_DECODER
;
1505 res
= media_entity_pads_init(&sd
->entity
, DEMOD_NUM_PADS
, core
->pads
);
1509 sd
->entity
.ops
= &tvp5150_sd_media_ops
;
1512 res
= tvp5150_detect_version(core
);
1516 core
->norm
= V4L2_STD_ALL
; /* Default is autodetect */
1517 core
->input
= TVP5150_COMPOSITE1
;
1518 core
->enable
= true;
1520 v4l2_ctrl_handler_init(&core
->hdl
, 5);
1521 v4l2_ctrl_new_std(&core
->hdl
, &tvp5150_ctrl_ops
,
1522 V4L2_CID_BRIGHTNESS
, 0, 255, 1, 128);
1523 v4l2_ctrl_new_std(&core
->hdl
, &tvp5150_ctrl_ops
,
1524 V4L2_CID_CONTRAST
, 0, 255, 1, 128);
1525 v4l2_ctrl_new_std(&core
->hdl
, &tvp5150_ctrl_ops
,
1526 V4L2_CID_SATURATION
, 0, 255, 1, 128);
1527 v4l2_ctrl_new_std(&core
->hdl
, &tvp5150_ctrl_ops
,
1528 V4L2_CID_HUE
, -128, 127, 1, 0);
1529 v4l2_ctrl_new_std(&core
->hdl
, &tvp5150_ctrl_ops
,
1530 V4L2_CID_PIXEL_RATE
, 27000000,
1531 27000000, 1, 27000000);
1532 v4l2_ctrl_new_std_menu_items(&core
->hdl
, &tvp5150_ctrl_ops
,
1533 V4L2_CID_TEST_PATTERN
,
1534 ARRAY_SIZE(tvp5150_test_patterns
),
1535 0, 0, tvp5150_test_patterns
);
1536 sd
->ctrl_handler
= &core
->hdl
;
1537 if (core
->hdl
.error
) {
1538 res
= core
->hdl
.error
;
1542 /* Default is no cropping */
1544 if (tvp5150_read_std(sd
) & V4L2_STD_525_60
)
1545 core
->rect
.height
= TVP5150_V_MAX_525_60
;
1547 core
->rect
.height
= TVP5150_V_MAX_OTHERS
;
1548 core
->rect
.left
= 0;
1549 core
->rect
.width
= TVP5150_H_MAX
;
1551 tvp5150_reset(sd
, 0); /* Calls v4l2_ctrl_handler_setup() */
1553 res
= v4l2_async_register_subdev(sd
);
1558 tvp5150_log_status(sd
);
1562 v4l2_ctrl_handler_free(&core
->hdl
);
1566 static int tvp5150_remove(struct i2c_client
*c
)
1568 struct v4l2_subdev
*sd
= i2c_get_clientdata(c
);
1569 struct tvp5150
*decoder
= to_tvp5150(sd
);
1571 dev_dbg_lvl(sd
->dev
, 1, debug
,
1572 "tvp5150.c: removing tvp5150 adapter on address 0x%x\n",
1575 v4l2_async_unregister_subdev(sd
);
1576 v4l2_ctrl_handler_free(&decoder
->hdl
);
1580 /* ----------------------------------------------------------------------- */
1582 static const struct i2c_device_id tvp5150_id
[] = {
1586 MODULE_DEVICE_TABLE(i2c
, tvp5150_id
);
1588 #if IS_ENABLED(CONFIG_OF)
1589 static const struct of_device_id tvp5150_of_match
[] = {
1590 { .compatible
= "ti,tvp5150", },
1593 MODULE_DEVICE_TABLE(of
, tvp5150_of_match
);
1596 static struct i2c_driver tvp5150_driver
= {
1598 .of_match_table
= of_match_ptr(tvp5150_of_match
),
1601 .probe
= tvp5150_probe
,
1602 .remove
= tvp5150_remove
,
1603 .id_table
= tvp5150_id
,
1606 module_i2c_driver(tvp5150_driver
);