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