V4L/DVB (3278): convert diagnostics over to the new v4l2-common.h macros.
[linux-2.6.git] / drivers / media / video / saa7127.c
1 /*
2  * saa7127 - Philips SAA7127/SAA7129 video encoder driver
3  *
4  * Copyright (C) 2003 Roy Bulter <rbulter@hetnet.nl>
5  *
6  * Based on SAA7126 video encoder driver by Gillem & Andreas Oberritter
7  *
8  * Copyright (C) 2000-2001 Gillem <htoa@gmx.net>
9  * Copyright (C) 2002 Andreas Oberritter <obi@saftware.de>
10  *
11  * Based on Stadis 4:2:2 MPEG-2 Decoder Driver by Nathan Laredo
12  *
13  * Copyright (C) 1999 Nathan Laredo <laredo@gnu.org>
14  *
15  * This driver is designed for the Hauppauge 250/350 Linux driver
16  * from the ivtv Project
17  *
18  * Copyright (C) 2003 Kevin Thayer <nufan_wfk@yahoo.com>
19  *
20  * Dual output support:
21  * Copyright (C) 2004 Eric Varsanyi
22  *
23  * NTSC Tuning and 7.5 IRE Setup
24  * Copyright (C) 2004  Chris Kennedy <c@groovy.org>
25  *
26  * VBI additions & cleanup:
27  * Copyright (C) 2004, 2005 Hans Verkuil <hverkuil@xs4all.nl>
28  *
29  * Note: the saa7126 is identical to the saa7127, and the saa7128 is
30  * identical to the saa7129, except that the saa7126 and saa7128 have
31  * macrovision anti-taping support. This driver will almost certainly
32  * work find for those chips, except of course for the missing anti-taping
33  * support.
34  *
35  * This program is free software; you can redistribute it and/or modify
36  * it under the terms of the GNU General Public License as published by
37  * the Free Software Foundation; either version 2 of the License, or
38  * (at your option) any later version.
39  *
40  * This program is distributed in the hope that it will be useful,
41  * but WITHOUT ANY WARRANTY; without even the implied warranty of
42  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
43  * GNU General Public License for more details.
44  *
45  * You should have received a copy of the GNU General Public License
46  * along with this program; if not, write to the Free Software
47  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
48  */
49
50
51 #include <linux/kernel.h>
52 #include <linux/module.h>
53 #include <linux/slab.h>
54 #include <linux/i2c.h>
55 #include <linux/videodev2.h>
56 #include <media/v4l2-common.h>
57
58 static int debug = 0;
59 static int test_image = 0;
60
61 MODULE_DESCRIPTION("Philips SAA7127/9 video encoder driver");
62 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
63 MODULE_LICENSE("GPL");
64 module_param(debug, int, 0644);
65 module_param(test_image, int, 0644);
66 MODULE_PARM_DESC(debug, "debug level (0-2)");
67 MODULE_PARM_DESC(test_image, "test_image (0-1)");
68
69 static unsigned short normal_i2c[] = { 0x88 >> 1, I2C_CLIENT_END };
70
71
72 I2C_CLIENT_INSMOD;
73
74 /*
75  * SAA7127 registers
76  */
77
78 #define SAA7127_REG_STATUS                           0x00
79 #define SAA7127_REG_WIDESCREEN_CONFIG                0x26
80 #define SAA7127_REG_WIDESCREEN_ENABLE                0x27
81 #define SAA7127_REG_BURST_START                      0x28
82 #define SAA7127_REG_BURST_END                        0x29
83 #define SAA7127_REG_COPYGEN_0                        0x2a
84 #define SAA7127_REG_COPYGEN_1                        0x2b
85 #define SAA7127_REG_COPYGEN_2                        0x2c
86 #define SAA7127_REG_OUTPUT_PORT_CONTROL              0x2d
87 #define SAA7127_REG_GAIN_LUMINANCE_RGB               0x38
88 #define SAA7127_REG_GAIN_COLORDIFF_RGB               0x39
89 #define SAA7127_REG_INPUT_PORT_CONTROL_1             0x3a
90 #define SAA7129_REG_FADE_KEY_COL2                    0x4f
91 #define SAA7127_REG_CHROMA_PHASE                     0x5a
92 #define SAA7127_REG_GAINU                            0x5b
93 #define SAA7127_REG_GAINV                            0x5c
94 #define SAA7127_REG_BLACK_LEVEL                      0x5d
95 #define SAA7127_REG_BLANKING_LEVEL                   0x5e
96 #define SAA7127_REG_VBI_BLANKING                     0x5f
97 #define SAA7127_REG_DAC_CONTROL                      0x61
98 #define SAA7127_REG_BURST_AMP                        0x62
99 #define SAA7127_REG_SUBC3                            0x63
100 #define SAA7127_REG_SUBC2                            0x64
101 #define SAA7127_REG_SUBC1                            0x65
102 #define SAA7127_REG_SUBC0                            0x66
103 #define SAA7127_REG_LINE_21_ODD_0                    0x67
104 #define SAA7127_REG_LINE_21_ODD_1                    0x68
105 #define SAA7127_REG_LINE_21_EVEN_0                   0x69
106 #define SAA7127_REG_LINE_21_EVEN_1                   0x6a
107 #define SAA7127_REG_RCV_PORT_CONTROL                 0x6b
108 #define SAA7127_REG_VTRIG                            0x6c
109 #define SAA7127_REG_HTRIG_HI                         0x6d
110 #define SAA7127_REG_MULTI                            0x6e
111 #define SAA7127_REG_CLOSED_CAPTION                   0x6f
112 #define SAA7127_REG_RCV2_OUTPUT_START                0x70
113 #define SAA7127_REG_RCV2_OUTPUT_END                  0x71
114 #define SAA7127_REG_RCV2_OUTPUT_MSBS                 0x72
115 #define SAA7127_REG_TTX_REQUEST_H_START              0x73
116 #define SAA7127_REG_TTX_REQUEST_H_DELAY_LENGTH       0x74
117 #define SAA7127_REG_CSYNC_ADVANCE_VSYNC_SHIFT        0x75
118 #define SAA7127_REG_TTX_ODD_REQ_VERT_START           0x76
119 #define SAA7127_REG_TTX_ODD_REQ_VERT_END             0x77
120 #define SAA7127_REG_TTX_EVEN_REQ_VERT_START          0x78
121 #define SAA7127_REG_TTX_EVEN_REQ_VERT_END            0x79
122 #define SAA7127_REG_FIRST_ACTIVE                     0x7a
123 #define SAA7127_REG_LAST_ACTIVE                      0x7b
124 #define SAA7127_REG_MSB_VERTICAL                     0x7c
125 #define SAA7127_REG_DISABLE_TTX_LINE_LO_0            0x7e
126 #define SAA7127_REG_DISABLE_TTX_LINE_LO_1            0x7f
127
128 /*
129  **********************************************************************
130  *
131  *  Arrays with configuration parameters for the SAA7127
132  *
133  **********************************************************************
134  */
135
136 struct i2c_reg_value {
137         unsigned char reg;
138         unsigned char value;
139 };
140
141 static const struct i2c_reg_value saa7129_init_config_extra[] = {
142         { SAA7127_REG_OUTPUT_PORT_CONTROL,              0x38 },
143         { SAA7127_REG_VTRIG,                            0xfa },
144 };
145
146 static const struct i2c_reg_value saa7127_init_config_common[] = {
147         { SAA7127_REG_WIDESCREEN_CONFIG,                0x0d },
148         { SAA7127_REG_WIDESCREEN_ENABLE,                0x00 },
149         { SAA7127_REG_COPYGEN_0,                        0x77 },
150         { SAA7127_REG_COPYGEN_1,                        0x41 },
151         { SAA7127_REG_COPYGEN_2,                        0x00 }, /* Macrovision enable/disable */
152         { SAA7127_REG_OUTPUT_PORT_CONTROL,              0x9e },
153         { SAA7127_REG_GAIN_LUMINANCE_RGB,               0x00 },
154         { SAA7127_REG_GAIN_COLORDIFF_RGB,               0x00 },
155         { SAA7127_REG_INPUT_PORT_CONTROL_1,             0x80 }, /* for color bars */
156         { SAA7127_REG_LINE_21_ODD_0,                    0x77 },
157         { SAA7127_REG_LINE_21_ODD_1,                    0x41 },
158         { SAA7127_REG_LINE_21_EVEN_0,                   0x88 },
159         { SAA7127_REG_LINE_21_EVEN_1,                   0x41 },
160         { SAA7127_REG_RCV_PORT_CONTROL,                 0x12 },
161         { SAA7127_REG_VTRIG,                            0xf9 },
162         { SAA7127_REG_HTRIG_HI,                         0x00 },
163         { SAA7127_REG_RCV2_OUTPUT_START,                0x41 },
164         { SAA7127_REG_RCV2_OUTPUT_END,                  0xc3 },
165         { SAA7127_REG_RCV2_OUTPUT_MSBS,                 0x00 },
166         { SAA7127_REG_TTX_REQUEST_H_START,              0x3e },
167         { SAA7127_REG_TTX_REQUEST_H_DELAY_LENGTH,       0xb8 },
168         { SAA7127_REG_CSYNC_ADVANCE_VSYNC_SHIFT,        0x03 },
169         { SAA7127_REG_TTX_ODD_REQ_VERT_START,           0x15 },
170         { SAA7127_REG_TTX_ODD_REQ_VERT_END,             0x16 },
171         { SAA7127_REG_TTX_EVEN_REQ_VERT_START,          0x15 },
172         { SAA7127_REG_TTX_EVEN_REQ_VERT_END,            0x16 },
173         { SAA7127_REG_FIRST_ACTIVE,                     0x1a },
174         { SAA7127_REG_LAST_ACTIVE,                      0x01 },
175         { SAA7127_REG_MSB_VERTICAL,                     0xc0 },
176         { SAA7127_REG_DISABLE_TTX_LINE_LO_0,            0x00 },
177         { SAA7127_REG_DISABLE_TTX_LINE_LO_1,            0x00 },
178         { 0, 0 }
179 };
180
181 #define SAA7127_60HZ_DAC_CONTROL 0x15
182 static const struct i2c_reg_value saa7127_init_config_60hz[] = {
183         { SAA7127_REG_BURST_START,                      0x19 },
184         /* BURST_END is also used as a chip ID in saa7127_detect_client */
185         { SAA7127_REG_BURST_END,                        0x1d },
186         { SAA7127_REG_CHROMA_PHASE,                     0xa3 },
187         { SAA7127_REG_GAINU,                            0x98 },
188         { SAA7127_REG_GAINV,                            0xd3 },
189         { SAA7127_REG_BLACK_LEVEL,                      0x39 },
190         { SAA7127_REG_BLANKING_LEVEL,                   0x2e },
191         { SAA7127_REG_VBI_BLANKING,                     0x2e },
192         { SAA7127_REG_DAC_CONTROL,                      0x15 },
193         { SAA7127_REG_BURST_AMP,                        0x4d },
194         { SAA7127_REG_SUBC3,                            0x1f },
195         { SAA7127_REG_SUBC2,                            0x7c },
196         { SAA7127_REG_SUBC1,                            0xf0 },
197         { SAA7127_REG_SUBC0,                            0x21 },
198         { SAA7127_REG_MULTI,                            0x90 },
199         { SAA7127_REG_CLOSED_CAPTION,                   0x11 },
200         { 0, 0 }
201 };
202
203 #define SAA7127_50HZ_DAC_CONTROL 0x02
204 static struct i2c_reg_value saa7127_init_config_50hz[] = {
205         { SAA7127_REG_BURST_START,                      0x21 },
206         /* BURST_END is also used as a chip ID in saa7127_detect_client */
207         { SAA7127_REG_BURST_END,                        0x1d },
208         { SAA7127_REG_CHROMA_PHASE,                     0x3f },
209         { SAA7127_REG_GAINU,                            0x7d },
210         { SAA7127_REG_GAINV,                            0xaf },
211         { SAA7127_REG_BLACK_LEVEL,                      0x33 },
212         { SAA7127_REG_BLANKING_LEVEL,                   0x35 },
213         { SAA7127_REG_VBI_BLANKING,                     0x35 },
214         { SAA7127_REG_DAC_CONTROL,                      0x02 },
215         { SAA7127_REG_BURST_AMP,                        0x2f },
216         { SAA7127_REG_SUBC3,                            0xcb },
217         { SAA7127_REG_SUBC2,                            0x8a },
218         { SAA7127_REG_SUBC1,                            0x09 },
219         { SAA7127_REG_SUBC0,                            0x2a },
220         { SAA7127_REG_MULTI,                            0xa0 },
221         { SAA7127_REG_CLOSED_CAPTION,                   0x00 },
222         { 0, 0 }
223 };
224
225 /* Enumeration for the Supported input types */
226 enum saa7127_input_type {
227         SAA7127_INPUT_TYPE_NORMAL,
228         SAA7127_INPUT_TYPE_TEST_IMAGE
229 };
230
231 /* Enumeration for the Supported Output signal types */
232 enum saa7127_output_type {
233         SAA7127_OUTPUT_TYPE_BOTH,
234         SAA7127_OUTPUT_TYPE_COMPOSITE,
235         SAA7127_OUTPUT_TYPE_SVIDEO,
236         SAA7127_OUTPUT_TYPE_RGB,
237         SAA7127_OUTPUT_TYPE_YUV_C,
238         SAA7127_OUTPUT_TYPE_YUV_V
239 };
240
241 /*
242  **********************************************************************
243  *
244  *  Encoder Struct, holds the configuration state of the encoder
245  *
246  **********************************************************************
247  */
248
249 struct saa7127_state {
250         v4l2_std_id std;
251         enum v4l2_chip_ident ident;
252         enum saa7127_input_type input_type;
253         enum saa7127_output_type output_type;
254         int video_enable;
255         int wss_enable;
256         u16 wss_mode;
257         int cc_enable;
258         u16 cc_data;
259         int xds_enable;
260         u16 xds_data;
261         int vps_enable;
262         u8 vps_data[5];
263         u8 reg_2d;
264         u8 reg_3a;
265         u8 reg_3a_cb;   /* colorbar bit */
266         u8 reg_61;
267 };
268
269 static const char * const output_strs[] =
270 {
271         "S-Video + Composite",
272         "Composite",
273         "S-Video",
274         "RGB",
275         "YUV C",
276         "YUV V"
277 };
278
279 static const char * const wss_strs[] = {
280         "invalid",
281         "letterbox 14:9 center",
282         "letterbox 14:9 top",
283         "invalid",
284         "letterbox 16:9 top",
285         "invalid",
286         "invalid",
287         "16:9 full format anamorphic"
288         "4:3 full format",
289         "invalid",
290         "invalid",
291         "letterbox 16:9 center",
292         "invalid",
293         "letterbox >16:9 center",
294         "14:9 full format center",
295         "invalid",
296 };
297
298 /* ----------------------------------------------------------------------- */
299
300 static int saa7127_read(struct i2c_client *client, u8 reg)
301 {
302         return i2c_smbus_read_byte_data(client, reg);
303 }
304
305 /* ----------------------------------------------------------------------- */
306
307 static int saa7127_write(struct i2c_client *client, u8 reg, u8 val)
308 {
309         int i;
310
311         for (i = 0; i < 3; i++) {
312                 if (i2c_smbus_write_byte_data(client, reg, val) == 0)
313                         return 0;
314         }
315         v4l_err(client, "I2C Write Problem\n");
316         return -1;
317 }
318
319 /* ----------------------------------------------------------------------- */
320
321 static int saa7127_write_inittab(struct i2c_client *client,
322                                  const struct i2c_reg_value *regs)
323 {
324         while (regs->reg != 0) {
325                 saa7127_write(client, regs->reg, regs->value);
326                 regs++;
327         }
328         return 0;
329 }
330
331 /* ----------------------------------------------------------------------- */
332
333 static int saa7127_set_vps(struct i2c_client *client, struct v4l2_sliced_vbi_data *data)
334 {
335         struct saa7127_state *state = i2c_get_clientdata(client);
336         int enable = (data->line != 0);
337
338         if (enable && (data->field != 0 || data->line != 16))
339                 return -EINVAL;
340         if (state->vps_enable != enable) {
341                 v4l_dbg(1, client, "Turn VPS Signal %s\n", enable ? "on" : "off");
342                 saa7127_write(client, 0x54, enable << 7);
343                 state->vps_enable = enable;
344         }
345         if (!enable)
346                 return 0;
347
348         state->vps_data[0] = data->data[4];
349         state->vps_data[1] = data->data[10];
350         state->vps_data[2] = data->data[11];
351         state->vps_data[3] = data->data[12];
352         state->vps_data[4] = data->data[13];
353         v4l_dbg(1, client, "Set VPS data %02x %02x %02x %02x %02x\n",
354                 state->vps_data[0], state->vps_data[1],
355                 state->vps_data[2], state->vps_data[3],
356                 state->vps_data[4]);
357         saa7127_write(client, 0x55, state->vps_data[0]);
358         saa7127_write(client, 0x56, state->vps_data[1]);
359         saa7127_write(client, 0x57, state->vps_data[2]);
360         saa7127_write(client, 0x58, state->vps_data[3]);
361         saa7127_write(client, 0x59, state->vps_data[4]);
362         return 0;
363 }
364
365 /* ----------------------------------------------------------------------- */
366
367 static int saa7127_set_cc(struct i2c_client *client, struct v4l2_sliced_vbi_data *data)
368 {
369         struct saa7127_state *state = i2c_get_clientdata(client);
370         u16 cc = data->data[1] << 8 | data->data[0];
371         int enable = (data->line != 0);
372
373         if (enable && (data->field != 0 || data->line != 21))
374                 return -EINVAL;
375         if (state->cc_enable != enable) {
376                 v4l_dbg(1, client, "Turn CC %s\n", enable ? "on" : "off");
377                 saa7127_write(client, SAA7127_REG_CLOSED_CAPTION,
378                                 (state->xds_enable << 7) | (enable << 6) | 0x11);
379                 state->cc_enable = enable;
380         }
381         if (!enable)
382                 return 0;
383
384         v4l_dbg(2, client, "CC data: %04x\n", cc);
385         saa7127_write(client, SAA7127_REG_LINE_21_ODD_0, cc & 0xff);
386         saa7127_write(client, SAA7127_REG_LINE_21_ODD_1, cc >> 8);
387         state->cc_data = cc;
388         return 0;
389 }
390
391 /* ----------------------------------------------------------------------- */
392
393 static int saa7127_set_xds(struct i2c_client *client, struct v4l2_sliced_vbi_data *data)
394 {
395         struct saa7127_state *state = i2c_get_clientdata(client);
396         u16 xds = data->data[1] << 8 | data->data[0];
397         int enable = (data->line != 0);
398
399         if (enable && (data->field != 1 || data->line != 21))
400                 return -EINVAL;
401         if (state->xds_enable != enable) {
402                 v4l_dbg(1, client, "Turn XDS %s\n", enable ? "on" : "off");
403                 saa7127_write(client, SAA7127_REG_CLOSED_CAPTION,
404                                 (enable << 7) | (state->cc_enable << 6) | 0x11);
405                 state->xds_enable = enable;
406         }
407         if (!enable)
408                 return 0;
409
410         v4l_dbg(2, client, "XDS data: %04x\n", xds);
411         saa7127_write(client, SAA7127_REG_LINE_21_EVEN_0, xds & 0xff);
412         saa7127_write(client, SAA7127_REG_LINE_21_EVEN_1, xds >> 8);
413         state->xds_data = xds;
414         return 0;
415 }
416
417 /* ----------------------------------------------------------------------- */
418
419 static int saa7127_set_wss(struct i2c_client *client, struct v4l2_sliced_vbi_data *data)
420 {
421         struct saa7127_state *state = i2c_get_clientdata(client);
422         int enable = (data->line != 0);
423
424         if (enable && (data->field != 0 || data->line != 23))
425                 return -EINVAL;
426         if (state->wss_enable != enable) {
427                 v4l_dbg(1, client, "Turn WSS %s\n", enable ? "on" : "off");
428                 saa7127_write(client, 0x27, enable << 7);
429                 state->wss_enable = enable;
430         }
431         if (!enable)
432                 return 0;
433
434         saa7127_write(client, 0x26, data->data[0]);
435         saa7127_write(client, 0x27, 0x80 | (data->data[1] & 0x3f));
436         v4l_dbg(1, client, "WSS mode: %s\n", wss_strs[data->data[0] & 0xf]);
437         state->wss_mode = (data->data[1] & 0x3f) << 8 | data->data[0];
438         return 0;
439 }
440
441 /* ----------------------------------------------------------------------- */
442
443 static int saa7127_set_video_enable(struct i2c_client *client, int enable)
444 {
445         struct saa7127_state *state = i2c_get_clientdata(client);
446
447         if (enable) {
448                 v4l_dbg(1, client, "Enable Video Output\n");
449                 saa7127_write(client, 0x2d, state->reg_2d);
450                 saa7127_write(client, 0x61, state->reg_61);
451         } else {
452                 v4l_dbg(1, client, "Disable Video Output\n");
453                 saa7127_write(client, 0x2d, (state->reg_2d & 0xf0));
454                 saa7127_write(client, 0x61, (state->reg_61 | 0xc0));
455         }
456         state->video_enable = enable;
457         return 0;
458 }
459
460 /* ----------------------------------------------------------------------- */
461
462 static int saa7127_set_std(struct i2c_client *client, v4l2_std_id std)
463 {
464         struct saa7127_state *state = i2c_get_clientdata(client);
465         const struct i2c_reg_value *inittab;
466
467         if (std & V4L2_STD_525_60) {
468                 v4l_dbg(1, client, "Selecting 60 Hz video Standard\n");
469                 inittab = saa7127_init_config_60hz;
470                 state->reg_61 = SAA7127_60HZ_DAC_CONTROL;
471         } else {
472                 v4l_dbg(1, client, "Selecting 50 Hz video Standard\n");
473                 inittab = saa7127_init_config_50hz;
474                 state->reg_61 = SAA7127_50HZ_DAC_CONTROL;
475         }
476
477         /* Write Table */
478         saa7127_write_inittab(client, inittab);
479         state->std = std;
480         return 0;
481 }
482
483 /* ----------------------------------------------------------------------- */
484
485 static int saa7127_set_output_type(struct i2c_client *client, int output)
486 {
487         struct saa7127_state *state = i2c_get_clientdata(client);
488
489         switch (output) {
490         case SAA7127_OUTPUT_TYPE_RGB:
491                 state->reg_2d = 0x0f;   /* RGB + CVBS (for sync) */
492                 state->reg_3a = 0x13;   /* by default switch YUV to RGB-matrix on */
493                 break;
494
495         case SAA7127_OUTPUT_TYPE_COMPOSITE:
496                 state->reg_2d = 0x08;   /* 00001000 CVBS only, RGB DAC's off (high impedance mode) */
497                 state->reg_3a = 0x13;   /* by default switch YUV to RGB-matrix on */
498                 break;
499
500         case SAA7127_OUTPUT_TYPE_SVIDEO:
501                 state->reg_2d = 0xff;   /* 11111111  croma -> R, luma -> CVBS + G + B */
502                 state->reg_3a = 0x13;   /* by default switch YUV to RGB-matrix on */
503                 break;
504
505         case SAA7127_OUTPUT_TYPE_YUV_V:
506                 state->reg_2d = 0x4f;   /* reg 2D = 01001111, all DAC's on, RGB + VBS */
507                 state->reg_3a = 0x0b;   /* reg 3A = 00001011, bypass RGB-matrix */
508                 break;
509
510         case SAA7127_OUTPUT_TYPE_YUV_C:
511                 state->reg_2d = 0x0f;   /* reg 2D = 00001111, all DAC's on, RGB + CVBS */
512                 state->reg_3a = 0x0b;   /* reg 3A = 00001011, bypass RGB-matrix */
513                 break;
514
515         case SAA7127_OUTPUT_TYPE_BOTH:
516                 state->reg_2d = 0xbf;
517                 state->reg_3a = 0x13;   /* by default switch YUV to RGB-matrix on */
518                 break;
519
520         default:
521                 return -EINVAL;
522         }
523         v4l_dbg(1, client, "Selecting %s output type\n", output_strs[output]);
524
525         /* Configure Encoder */
526         saa7127_write(client, 0x2d, state->reg_2d);
527         saa7127_write(client, 0x3a, state->reg_3a | state->reg_3a_cb);
528         state->output_type = output;
529         return 0;
530 }
531
532 /* ----------------------------------------------------------------------- */
533
534 static int saa7127_set_input_type(struct i2c_client *client, int input)
535 {
536         struct saa7127_state *state = i2c_get_clientdata(client);
537
538         switch (input) {
539         case SAA7127_INPUT_TYPE_NORMAL: /* avia */
540                 v4l_dbg(1, client, "Selecting Normal Encoder Input\n");
541                 state->reg_3a_cb = 0;
542                 break;
543
544         case SAA7127_INPUT_TYPE_TEST_IMAGE:     /* color bar */
545                 v4l_dbg(1, client, "Selecting Color Bar generator\n");
546                 state->reg_3a_cb = 0x80;
547                 break;
548
549         default:
550                 return -EINVAL;
551         }
552         saa7127_write(client, 0x3a, state->reg_3a | state->reg_3a_cb);
553         state->input_type = input;
554         return 0;
555 }
556
557 /* ----------------------------------------------------------------------- */
558
559 static int saa7127_command(struct i2c_client *client,
560                            unsigned int cmd, void *arg)
561 {
562         struct saa7127_state *state = i2c_get_clientdata(client);
563         struct v4l2_format *fmt = arg;
564         int *iarg = arg;
565
566         switch (cmd) {
567         case VIDIOC_S_STD:
568                 if (state->std == *(v4l2_std_id *)arg)
569                         break;
570                 return saa7127_set_std(client, *(v4l2_std_id *)arg);
571
572         case VIDIOC_G_STD:
573                 *(v4l2_std_id *)arg = state->std;
574                 break;
575
576         case VIDIOC_S_INPUT:
577                 if (state->input_type == *iarg)
578                         break;
579                 return saa7127_set_input_type(client, *iarg);
580
581         case VIDIOC_S_OUTPUT:
582                 if (state->output_type == *iarg)
583                         break;
584                 return saa7127_set_output_type(client, *iarg);
585
586         case VIDIOC_STREAMON:
587         case VIDIOC_STREAMOFF:
588                 if (state->video_enable == (cmd == VIDIOC_STREAMON))
589                         break;
590                 return saa7127_set_video_enable(client, cmd == VIDIOC_STREAMON);
591
592         case VIDIOC_G_FMT:
593                 if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
594                         return -EINVAL;
595
596                 memset(&fmt->fmt.sliced, 0, sizeof(fmt->fmt.sliced));
597                 if (state->vps_enable)
598                         fmt->fmt.sliced.service_lines[0][16] = V4L2_SLICED_VPS;
599                 if (state->wss_enable)
600                         fmt->fmt.sliced.service_lines[0][23] = V4L2_SLICED_WSS_625;
601                 if (state->cc_enable) {
602                         fmt->fmt.sliced.service_lines[0][21] = V4L2_SLICED_CAPTION_525;
603                         fmt->fmt.sliced.service_lines[1][21] = V4L2_SLICED_CAPTION_525;
604                 }
605                 fmt->fmt.sliced.service_set =
606                         (state->vps_enable ? V4L2_SLICED_VPS : 0) |
607                         (state->wss_enable ? V4L2_SLICED_WSS_625 : 0) |
608                         (state->cc_enable ? V4L2_SLICED_CAPTION_525 : 0);
609                 break;
610
611         case VIDIOC_LOG_STATUS:
612                 v4l_info(client, "Standard: %s\n", (state->std & V4L2_STD_525_60) ? "60 Hz" : "50 Hz");
613                 v4l_info(client, "Input:    %s\n", state->input_type ?  "color bars" : "normal");
614                 v4l_info(client, "Output:   %s\n", state->video_enable ?
615                         output_strs[state->output_type] : "disabled");
616                 v4l_info(client, "WSS:      %s\n", state->wss_enable ?
617                         wss_strs[state->wss_mode] : "disabled");
618                 v4l_info(client, "VPS:      %s\n", state->vps_enable ? "enabled" : "disabled");
619                 v4l_info(client, "CC:       %s\n", state->cc_enable ? "enabled" : "disabled");
620                 break;
621
622 #ifdef CONFIG_VIDEO_ADV_DEBUG
623         case VIDIOC_INT_G_REGISTER:
624         {
625                 struct v4l2_register *reg = arg;
626
627                 if (reg->i2c_id != I2C_DRIVERID_SAA7127)
628                         return -EINVAL;
629                 reg->val = saa7127_read(client, reg->reg & 0xff);
630                 break;
631         }
632
633         case VIDIOC_INT_S_REGISTER:
634         {
635                 struct v4l2_register *reg = arg;
636
637                 if (reg->i2c_id != I2C_DRIVERID_SAA7127)
638                         return -EINVAL;
639                 if (!capable(CAP_SYS_ADMIN))
640                         return -EPERM;
641                 saa7127_write(client, reg->reg & 0xff, reg->val & 0xff);
642                 break;
643         }
644 #endif
645
646         case VIDIOC_INT_S_VBI_DATA:
647         {
648                 struct v4l2_sliced_vbi_data *data = arg;
649
650                 switch (data->id) {
651                         case V4L2_SLICED_WSS_625:
652                                 return saa7127_set_wss(client, data);
653                         case V4L2_SLICED_VPS:
654                                 return saa7127_set_vps(client, data);
655                         case V4L2_SLICED_CAPTION_525:
656                                 if (data->field == 0)
657                                         return saa7127_set_cc(client, data);
658                                 return saa7127_set_xds(client, data);
659                         default:
660                                 return -EINVAL;
661                 }
662                 break;
663         }
664
665         case VIDIOC_INT_G_CHIP_IDENT:
666                 *(enum v4l2_chip_ident *)arg = state->ident;
667                 break;
668
669         default:
670                 return -EINVAL;
671         }
672         return 0;
673 }
674
675 /* ----------------------------------------------------------------------- */
676
677 static struct i2c_driver i2c_driver_saa7127;
678
679 /* ----------------------------------------------------------------------- */
680
681 static int saa7127_attach(struct i2c_adapter *adapter, int address, int kind)
682 {
683         struct i2c_client *client;
684         struct saa7127_state *state;
685         struct v4l2_sliced_vbi_data vbi = { 0, 0, 0, 0 };  /* set to disabled */
686         int read_result = 0;
687
688         /* Check if the adapter supports the needed features */
689         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
690                 return 0;
691
692         client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
693         if (client == 0)
694                 return -ENOMEM;
695
696         memset(client, 0, sizeof(struct i2c_client));
697         client->addr = address;
698         client->adapter = adapter;
699         client->driver = &i2c_driver_saa7127;
700         snprintf(client->name, sizeof(client->name) - 1, "saa7127");
701
702         v4l_dbg(1, client, "detecting saa7127 client on address 0x%x\n", address << 1);
703
704         /* First test register 0: Bits 5-7 are a version ID (should be 0),
705            and bit 2 should also be 0.
706            This is rather general, so the second test is more specific and
707            looks at the 'ending point of burst in clock cycles' which is
708            0x1d after a reset and not expected to ever change. */
709         if ((saa7127_read(client, 0) & 0xe4) != 0 ||
710                         (saa7127_read(client, 0x29) & 0x3f) != 0x1d) {
711                 v4l_dbg(1, client, "saa7127 not found\n");
712                 kfree(client);
713                 return 0;
714         }
715         state = kmalloc(sizeof(struct saa7127_state), GFP_KERNEL);
716
717         if (state == NULL) {
718                 kfree(client);
719                 return (-ENOMEM);
720         }
721
722         i2c_set_clientdata(client, state);
723         memset(state, 0, sizeof(struct saa7127_state));
724
725         /* Configure Encoder */
726
727         v4l_dbg(1, client, "Configuring encoder\n");
728         saa7127_write_inittab(client, saa7127_init_config_common);
729         saa7127_set_std(client, V4L2_STD_NTSC);
730         saa7127_set_output_type(client, SAA7127_OUTPUT_TYPE_BOTH);
731         saa7127_set_vps(client, &vbi);
732         saa7127_set_wss(client, &vbi);
733         saa7127_set_cc(client, &vbi);
734         saa7127_set_xds(client, &vbi);
735         if (test_image == 1) {
736                 /* The Encoder has an internal Colorbar generator */
737                 /* This can be used for debugging */
738                 saa7127_set_input_type(client, SAA7127_INPUT_TYPE_TEST_IMAGE);
739         } else {
740                 saa7127_set_input_type(client, SAA7127_INPUT_TYPE_NORMAL);
741         }
742         saa7127_set_video_enable(client, 1);
743
744         /* Detect if it's an saa7129 */
745         read_result = saa7127_read(client, SAA7129_REG_FADE_KEY_COL2);
746         saa7127_write(client, SAA7129_REG_FADE_KEY_COL2, 0xaa);
747         if (saa7127_read(client, SAA7129_REG_FADE_KEY_COL2) == 0xaa) {
748                 v4l_info(client, "saa7129 found @ 0x%x (%s)\n", address << 1, adapter->name);
749                 saa7127_write(client, SAA7129_REG_FADE_KEY_COL2, read_result);
750                 saa7127_write_inittab(client, saa7129_init_config_extra);
751                 state->ident = V4L2_IDENT_SAA7129;
752         } else {
753                 v4l_info(client, "saa7127 found @ 0x%x (%s)\n", address << 1, adapter->name);
754                 state->ident = V4L2_IDENT_SAA7127;
755         }
756
757         i2c_attach_client(client);
758
759         return 0;
760 }
761
762 /* ----------------------------------------------------------------------- */
763
764 static int saa7127_probe(struct i2c_adapter *adapter)
765 {
766         if (adapter->class & I2C_CLASS_TV_ANALOG)
767                 return i2c_probe(adapter, &addr_data, saa7127_attach);
768         return 0;
769 }
770
771 /* ----------------------------------------------------------------------- */
772
773 static int saa7127_detach(struct i2c_client *client)
774 {
775         struct saa7127_state *state = i2c_get_clientdata(client);
776         int err;
777
778         /* Turn off TV output */
779         saa7127_set_video_enable(client, 0);
780
781         err = i2c_detach_client(client);
782
783         if (err) {
784                 return err;
785         }
786
787         kfree(state);
788         kfree(client);
789         return 0;
790 }
791
792 /* ----------------------------------------------------------------------- */
793
794 static struct i2c_driver i2c_driver_saa7127 = {
795         .driver = {
796                 .name = "saa7127",
797         },
798         .id = I2C_DRIVERID_SAA7127,
799         .attach_adapter = saa7127_probe,
800         .detach_client = saa7127_detach,
801         .command = saa7127_command,
802 };
803
804
805 /* ----------------------------------------------------------------------- */
806
807 static int __init saa7127_init_module(void)
808 {
809         return i2c_add_driver(&i2c_driver_saa7127);
810 }
811
812 /* ----------------------------------------------------------------------- */
813
814 static void __exit saa7127_cleanup_module(void)
815 {
816         i2c_del_driver(&i2c_driver_saa7127);
817 }
818
819 /* ----------------------------------------------------------------------- */
820
821 module_init(saa7127_init_module);
822 module_exit(saa7127_cleanup_module);