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