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