Merge branch 'topic/hda' into for-linus
[linux-2.6] / drivers / media / video / mxb.c
1 /*
2     mxb - v4l2 driver for the Multimedia eXtension Board
3
4     Copyright (C) 1998-2006 Michael Hunold <michael@mihu.de>
5
6     Visit http://www.mihu.de/linux/saa7146/mxb/
7     for further details about this card.
8
9     This program is free software; you can redistribute it and/or modify
10     it under the terms of the GNU General Public License as published by
11     the Free Software Foundation; either version 2 of the License, or
12     (at your option) any later version.
13
14     This program is distributed in the hope that it will be useful,
15     but WITHOUT ANY WARRANTY; without even the implied warranty of
16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17     GNU General Public License for more details.
18
19     You should have received a copy of the GNU General Public License
20     along with this program; if not, write to the Free Software
21     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #define DEBUG_VARIABLE debug
25
26 #include <media/saa7146_vv.h>
27 #include <media/tuner.h>
28 #include <media/v4l2-common.h>
29 #include <media/saa7115.h>
30
31 #include "mxb.h"
32 #include "tea6415c.h"
33 #include "tea6420.h"
34
35 #define I2C_SAA5246A  0x11
36 #define I2C_SAA7111A  0x24
37 #define I2C_TDA9840   0x42
38 #define I2C_TEA6415C  0x43
39 #define I2C_TEA6420_1 0x4c
40 #define I2C_TEA6420_2 0x4d
41 #define I2C_TUNER     0x60
42
43 #define MXB_BOARD_CAN_DO_VBI(dev)   (dev->revision != 0)
44
45 /* global variable */
46 static int mxb_num;
47
48 /* initial frequence the tuner will be tuned to.
49    in verden (lower saxony, germany) 4148 is a
50    channel called "phoenix" */
51 static int freq = 4148;
52 module_param(freq, int, 0644);
53 MODULE_PARM_DESC(freq, "initial frequency the tuner will be tuned to while setup");
54
55 static int debug;
56 module_param(debug, int, 0644);
57 MODULE_PARM_DESC(debug, "Turn on/off device debugging (default:off).");
58
59 #define MXB_INPUTS 4
60 enum { TUNER, AUX1, AUX3, AUX3_YC };
61
62 static struct v4l2_input mxb_inputs[MXB_INPUTS] = {
63         { TUNER,        "Tuner",                V4L2_INPUT_TYPE_TUNER,  1, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
64         { AUX1,         "AUX1",                 V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
65         { AUX3,         "AUX3 Composite",       V4L2_INPUT_TYPE_CAMERA, 4, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
66         { AUX3_YC,      "AUX3 S-Video",         V4L2_INPUT_TYPE_CAMERA, 4, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
67 };
68
69 /* this array holds the information, which port of the saa7146 each
70    input actually uses. the mxb uses port 0 for every input */
71 static struct {
72         int hps_source;
73         int hps_sync;
74 } input_port_selection[MXB_INPUTS] = {
75         { SAA7146_HPS_SOURCE_PORT_A, SAA7146_HPS_SYNC_PORT_A },
76         { SAA7146_HPS_SOURCE_PORT_A, SAA7146_HPS_SYNC_PORT_A },
77         { SAA7146_HPS_SOURCE_PORT_A, SAA7146_HPS_SYNC_PORT_A },
78         { SAA7146_HPS_SOURCE_PORT_A, SAA7146_HPS_SYNC_PORT_A },
79 };
80
81 /* this array holds the information of the audio source (mxb_audios),
82    which has to be switched corresponding to the video source (mxb_channels) */
83 static int video_audio_connect[MXB_INPUTS] =
84         { 0, 1, 3, 3 };
85
86 /* These are the necessary input-output-pins for bringing one audio source
87    (see above) to the CD-output. Note that gain is set to 0 in this table. */
88 static struct v4l2_routing TEA6420_cd[MXB_AUDIOS + 1][2] = {
89         { { 1, 1 }, { 1, 1 } }, /* Tuner */
90         { { 5, 1 }, { 6, 1 } }, /* AUX 1 */
91         { { 4, 1 }, { 6, 1 } }, /* AUX 2 */
92         { { 3, 1 }, { 6, 1 } }, /* AUX 3 */
93         { { 1, 1 }, { 3, 1 } }, /* Radio */
94         { { 1, 1 }, { 2, 1 } }, /* CD-Rom */
95         { { 6, 1 }, { 6, 1 } }  /* Mute */
96 };
97
98 /* These are the necessary input-output-pins for bringing one audio source
99    (see above) to the line-output. Note that gain is set to 0 in this table. */
100 static struct v4l2_routing TEA6420_line[MXB_AUDIOS + 1][2] = {
101         { { 2, 3 }, { 1, 2 } },
102         { { 5, 3 }, { 6, 2 } },
103         { { 4, 3 }, { 6, 2 } },
104         { { 3, 3 }, { 6, 2 } },
105         { { 2, 3 }, { 3, 2 } },
106         { { 2, 3 }, { 2, 2 } },
107         { { 6, 3 }, { 6, 2 } }  /* Mute */
108 };
109
110 #define MAXCONTROLS     1
111 static struct v4l2_queryctrl mxb_controls[] = {
112         { V4L2_CID_AUDIO_MUTE, V4L2_CTRL_TYPE_BOOLEAN, "Mute", 0, 1, 1, 0, 0 },
113 };
114
115 struct mxb
116 {
117         struct video_device     *video_dev;
118         struct video_device     *vbi_dev;
119
120         struct i2c_adapter      i2c_adapter;
121
122         struct v4l2_subdev      *saa7111a;
123         struct v4l2_subdev      *tda9840;
124         struct v4l2_subdev      *tea6415c;
125         struct v4l2_subdev      *tuner;
126         struct v4l2_subdev      *tea6420_1;
127         struct v4l2_subdev      *tea6420_2;
128
129         int     cur_mode;       /* current audio mode (mono, stereo, ...) */
130         int     cur_input;      /* current input */
131         int     cur_mute;       /* current mute status */
132         struct v4l2_frequency   cur_freq;       /* current frequency the tuner is tuned to */
133 };
134
135 #define saa7111a_call(mxb, o, f, args...) \
136         v4l2_subdev_call(mxb->saa7111a, o, f, ##args)
137 #define tea6420_1_call(mxb, o, f, args...) \
138         v4l2_subdev_call(mxb->tea6420_1, o, f, ##args)
139 #define tea6420_2_call(mxb, o, f, args...) \
140         v4l2_subdev_call(mxb->tea6420_2, o, f, ##args)
141 #define tda9840_call(mxb, o, f, args...) \
142         v4l2_subdev_call(mxb->tda9840, o, f, ##args)
143 #define tea6415c_call(mxb, o, f, args...) \
144         v4l2_subdev_call(mxb->tea6415c, o, f, ##args)
145 #define tuner_call(mxb, o, f, args...) \
146         v4l2_subdev_call(mxb->tuner, o, f, ##args)
147 #define call_all(dev, o, f, args...) \
148         v4l2_device_call_until_err(&dev->v4l2_dev, 0, o, f, ##args)
149
150 static struct saa7146_extension extension;
151
152 static int mxb_probe(struct saa7146_dev *dev)
153 {
154         struct mxb *mxb = NULL;
155
156         mxb = kzalloc(sizeof(struct mxb), GFP_KERNEL);
157         if (mxb == NULL) {
158                 DEB_D(("not enough kernel memory.\n"));
159                 return -ENOMEM;
160         }
161
162         snprintf(mxb->i2c_adapter.name, sizeof(mxb->i2c_adapter.name), "mxb%d", mxb_num);
163
164         saa7146_i2c_adapter_prepare(dev, &mxb->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
165         if (i2c_add_adapter(&mxb->i2c_adapter) < 0) {
166                 DEB_S(("cannot register i2c-device. skipping.\n"));
167                 kfree(mxb);
168                 return -EFAULT;
169         }
170
171         mxb->saa7111a = v4l2_i2c_new_subdev(&mxb->i2c_adapter, "saa7115", "saa7111", I2C_SAA7111A);
172         mxb->tea6420_1 = v4l2_i2c_new_subdev(&mxb->i2c_adapter, "tea6420", "tea6420", I2C_TEA6420_1);
173         mxb->tea6420_2 = v4l2_i2c_new_subdev(&mxb->i2c_adapter, "tea6420", "tea6420", I2C_TEA6420_2);
174         mxb->tea6415c = v4l2_i2c_new_subdev(&mxb->i2c_adapter, "tea6415c", "tea6415c", I2C_TEA6415C);
175         mxb->tda9840 = v4l2_i2c_new_subdev(&mxb->i2c_adapter, "tda9840", "tda9840", I2C_TDA9840);
176         mxb->tuner = v4l2_i2c_new_subdev(&mxb->i2c_adapter, "tuner", "tuner", I2C_TUNER);
177         if (v4l2_i2c_new_subdev(&mxb->i2c_adapter, "saa5246a", "saa5246a", I2C_SAA5246A)) {
178                 printk(KERN_INFO "mxb: found teletext decoder\n");
179         }
180
181         /* check if all devices are present */
182         if (!mxb->tea6420_1 || !mxb->tea6420_2 || !mxb->tea6415c ||
183             !mxb->tda9840 || !mxb->saa7111a || !mxb->tuner) {
184                 printk("mxb: did not find all i2c devices. aborting\n");
185                 i2c_del_adapter(&mxb->i2c_adapter);
186                 kfree(mxb);
187                 return -ENODEV;
188         }
189
190         /* all devices are present, probe was successful */
191
192         /* we store the pointer in our private data field */
193         dev->ext_priv = mxb;
194
195         return 0;
196 }
197
198 /* some init data for the saa7740, the so-called 'sound arena module'.
199    there are no specs available, so we simply use some init values */
200 static struct {
201         int     length;
202         char    data[9];
203 } mxb_saa7740_init[] = {
204         { 3, { 0x80, 0x00, 0x00 } },{ 3, { 0x80, 0x89, 0x00 } },
205         { 3, { 0x80, 0xb0, 0x0a } },{ 3, { 0x00, 0x00, 0x00 } },
206         { 3, { 0x49, 0x00, 0x00 } },{ 3, { 0x4a, 0x00, 0x00 } },
207         { 3, { 0x4b, 0x00, 0x00 } },{ 3, { 0x4c, 0x00, 0x00 } },
208         { 3, { 0x4d, 0x00, 0x00 } },{ 3, { 0x4e, 0x00, 0x00 } },
209         { 3, { 0x4f, 0x00, 0x00 } },{ 3, { 0x50, 0x00, 0x00 } },
210         { 3, { 0x51, 0x00, 0x00 } },{ 3, { 0x52, 0x00, 0x00 } },
211         { 3, { 0x53, 0x00, 0x00 } },{ 3, { 0x54, 0x00, 0x00 } },
212         { 3, { 0x55, 0x00, 0x00 } },{ 3, { 0x56, 0x00, 0x00 } },
213         { 3, { 0x57, 0x00, 0x00 } },{ 3, { 0x58, 0x00, 0x00 } },
214         { 3, { 0x59, 0x00, 0x00 } },{ 3, { 0x5a, 0x00, 0x00 } },
215         { 3, { 0x5b, 0x00, 0x00 } },{ 3, { 0x5c, 0x00, 0x00 } },
216         { 3, { 0x5d, 0x00, 0x00 } },{ 3, { 0x5e, 0x00, 0x00 } },
217         { 3, { 0x5f, 0x00, 0x00 } },{ 3, { 0x60, 0x00, 0x00 } },
218         { 3, { 0x61, 0x00, 0x00 } },{ 3, { 0x62, 0x00, 0x00 } },
219         { 3, { 0x63, 0x00, 0x00 } },{ 3, { 0x64, 0x00, 0x00 } },
220         { 3, { 0x65, 0x00, 0x00 } },{ 3, { 0x66, 0x00, 0x00 } },
221         { 3, { 0x67, 0x00, 0x00 } },{ 3, { 0x68, 0x00, 0x00 } },
222         { 3, { 0x69, 0x00, 0x00 } },{ 3, { 0x6a, 0x00, 0x00 } },
223         { 3, { 0x6b, 0x00, 0x00 } },{ 3, { 0x6c, 0x00, 0x00 } },
224         { 3, { 0x6d, 0x00, 0x00 } },{ 3, { 0x6e, 0x00, 0x00 } },
225         { 3, { 0x6f, 0x00, 0x00 } },{ 3, { 0x70, 0x00, 0x00 } },
226         { 3, { 0x71, 0x00, 0x00 } },{ 3, { 0x72, 0x00, 0x00 } },
227         { 3, { 0x73, 0x00, 0x00 } },{ 3, { 0x74, 0x00, 0x00 } },
228         { 3, { 0x75, 0x00, 0x00 } },{ 3, { 0x76, 0x00, 0x00 } },
229         { 3, { 0x77, 0x00, 0x00 } },{ 3, { 0x41, 0x00, 0x42 } },
230         { 3, { 0x42, 0x10, 0x42 } },{ 3, { 0x43, 0x20, 0x42 } },
231         { 3, { 0x44, 0x30, 0x42 } },{ 3, { 0x45, 0x00, 0x01 } },
232         { 3, { 0x46, 0x00, 0x01 } },{ 3, { 0x47, 0x00, 0x01 } },
233         { 3, { 0x48, 0x00, 0x01 } },
234         { 9, { 0x01, 0x03, 0xc5, 0x5c, 0x7a, 0x85, 0x01, 0x00, 0x54 } },
235         { 9, { 0x21, 0x03, 0xc5, 0x5c, 0x7a, 0x85, 0x01, 0x00, 0x54 } },
236         { 9, { 0x09, 0x0b, 0xb4, 0x6b, 0x74, 0x85, 0x95, 0x00, 0x34 } },
237         { 9, { 0x29, 0x0b, 0xb4, 0x6b, 0x74, 0x85, 0x95, 0x00, 0x34 } },
238         { 9, { 0x11, 0x17, 0x43, 0x62, 0x68, 0x89, 0xd1, 0xff, 0xb0 } },
239         { 9, { 0x31, 0x17, 0x43, 0x62, 0x68, 0x89, 0xd1, 0xff, 0xb0 } },
240         { 9, { 0x19, 0x20, 0x62, 0x51, 0x5a, 0x95, 0x19, 0x01, 0x50 } },
241         { 9, { 0x39, 0x20, 0x62, 0x51, 0x5a, 0x95, 0x19, 0x01, 0x50 } },
242         { 9, { 0x05, 0x3e, 0xd2, 0x69, 0x4e, 0x9a, 0x51, 0x00, 0xf0 } },
243         { 9, { 0x25, 0x3e, 0xd2, 0x69, 0x4e, 0x9a, 0x51, 0x00, 0xf0 } },
244         { 9, { 0x0d, 0x3d, 0xa1, 0x40, 0x7d, 0x9f, 0x29, 0xfe, 0x14 } },
245         { 9, { 0x2d, 0x3d, 0xa1, 0x40, 0x7d, 0x9f, 0x29, 0xfe, 0x14 } },
246         { 9, { 0x15, 0x73, 0xa1, 0x50, 0x5d, 0xa6, 0xf5, 0xfe, 0x38 } },
247         { 9, { 0x35, 0x73, 0xa1, 0x50, 0x5d, 0xa6, 0xf5, 0xfe, 0x38 } },
248         { 9, { 0x1d, 0xed, 0xd0, 0x68, 0x29, 0xb4, 0xe1, 0x00, 0xb8 } },
249         { 9, { 0x3d, 0xed, 0xd0, 0x68, 0x29, 0xb4, 0xe1, 0x00, 0xb8 } },
250         { 3, { 0x80, 0xb3, 0x0a } },
251         {-1, { 0 } }
252 };
253
254 /* bring hardware to a sane state. this has to be done, just in case someone
255    wants to capture from this device before it has been properly initialized.
256    the capture engine would badly fail, because no valid signal arrives on the
257    saa7146, thus leading to timeouts and stuff. */
258 static int mxb_init_done(struct saa7146_dev* dev)
259 {
260         struct mxb* mxb = (struct mxb*)dev->ext_priv;
261         struct i2c_msg msg;
262         struct tuner_setup tun_setup;
263         v4l2_std_id std = V4L2_STD_PAL_BG;
264         struct v4l2_routing route;
265
266         int i = 0, err = 0;
267
268         /* select video mode in saa7111a */
269         saa7111a_call(mxb, tuner, s_std, std);
270
271         /* select tuner-output on saa7111a */
272         i = 0;
273         route.input = SAA7115_COMPOSITE0;
274         route.output = SAA7111_FMT_CCIR | SAA7111_VBI_BYPASS;
275         saa7111a_call(mxb, video, s_routing, &route);
276
277         /* select a tuner type */
278         tun_setup.mode_mask = T_ANALOG_TV;
279         tun_setup.addr = ADDR_UNSET;
280         tun_setup.type = TUNER_PHILIPS_PAL;
281         tuner_call(mxb, tuner, s_type_addr, &tun_setup);
282         /* tune in some frequency on tuner */
283         mxb->cur_freq.tuner = 0;
284         mxb->cur_freq.type = V4L2_TUNER_ANALOG_TV;
285         mxb->cur_freq.frequency = freq;
286         tuner_call(mxb, tuner, s_frequency, &mxb->cur_freq);
287
288         /* set a default video standard */
289         tuner_call(mxb, tuner, s_std, std);
290
291         /* mute audio on tea6420s */
292         tea6420_1_call(mxb, audio, s_routing, &TEA6420_line[6][0]);
293         tea6420_2_call(mxb, audio, s_routing, &TEA6420_line[6][1]);
294         tea6420_1_call(mxb, audio, s_routing, &TEA6420_line[6][0]);
295         tea6420_2_call(mxb, audio, s_routing, &TEA6420_line[6][1]);
296
297         /* switch to tuner-channel on tea6415c */
298         route.input = 3;
299         route.output = 17;
300         tea6415c_call(mxb, video, s_routing, &route);
301
302         /* select tuner-output on multicable on tea6415c */
303         route.input = 3;
304         route.output = 13;
305         tea6415c_call(mxb, video, s_routing, &route);
306
307         /* the rest for mxb */
308         mxb->cur_input = 0;
309         mxb->cur_mute = 1;
310
311         mxb->cur_mode = V4L2_TUNER_MODE_STEREO;
312
313         /* check if the saa7740 (aka 'sound arena module') is present
314            on the mxb. if so, we must initialize it. due to lack of
315            informations about the saa7740, the values were reverse
316            engineered. */
317         msg.addr = 0x1b;
318         msg.flags = 0;
319         msg.len = mxb_saa7740_init[0].length;
320         msg.buf = &mxb_saa7740_init[0].data[0];
321
322         err = i2c_transfer(&mxb->i2c_adapter, &msg, 1);
323         if (err == 1) {
324                 /* the sound arena module is a pos, that's probably the reason
325                    philips refuses to hand out a datasheet for the saa7740...
326                    it seems to screw up the i2c bus, so we disable fast irq
327                    based i2c transactions here and rely on the slow and safe
328                    polling method ... */
329                 extension.flags &= ~SAA7146_USE_I2C_IRQ;
330                 for (i = 1; ; i++) {
331                         if (-1 == mxb_saa7740_init[i].length)
332                                 break;
333
334                         msg.len = mxb_saa7740_init[i].length;
335                         msg.buf = &mxb_saa7740_init[i].data[0];
336                         err = i2c_transfer(&mxb->i2c_adapter, &msg, 1);
337                         if (err != 1) {
338                                 DEB_D(("failed to initialize 'sound arena module'.\n"));
339                                 goto err;
340                         }
341                 }
342                 INFO(("'sound arena module' detected.\n"));
343         }
344 err:
345         /* the rest for saa7146: you should definitely set some basic values
346            for the input-port handling of the saa7146. */
347
348         /* ext->saa has been filled by the core driver */
349
350         /* some stuff is done via variables */
351         saa7146_set_hps_source_and_sync(dev, input_port_selection[mxb->cur_input].hps_source,
352                         input_port_selection[mxb->cur_input].hps_sync);
353
354         /* some stuff is done via direct write to the registers */
355
356         /* this is ugly, but because of the fact that this is completely
357            hardware dependend, it should be done directly... */
358         saa7146_write(dev, DD1_STREAM_B,        0x00000000);
359         saa7146_write(dev, DD1_INIT,            0x02000200);
360         saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
361
362         return 0;
363 }
364
365 /* interrupt-handler. this gets called when irq_mask is != 0.
366    it must clear the interrupt-bits in irq_mask it has handled */
367 /*
368 void mxb_irq_bh(struct saa7146_dev* dev, u32* irq_mask)
369 {
370         struct mxb* mxb = (struct mxb*)dev->ext_priv;
371 }
372 */
373
374 static int vidioc_queryctrl(struct file *file, void *fh, struct v4l2_queryctrl *qc)
375 {
376         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
377         int i;
378
379         for (i = MAXCONTROLS - 1; i >= 0; i--) {
380                 if (mxb_controls[i].id == qc->id) {
381                         *qc = mxb_controls[i];
382                         DEB_D(("VIDIOC_QUERYCTRL %d.\n", qc->id));
383                         return 0;
384                 }
385         }
386         return dev->ext_vv_data->core_ops->vidioc_queryctrl(file, fh, qc);
387 }
388
389 static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *vc)
390 {
391         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
392         struct mxb *mxb = (struct mxb *)dev->ext_priv;
393         int i;
394
395         for (i = MAXCONTROLS - 1; i >= 0; i--) {
396                 if (mxb_controls[i].id == vc->id)
397                         break;
398         }
399
400         if (i < 0)
401                 return dev->ext_vv_data->core_ops->vidioc_g_ctrl(file, fh, vc);
402
403         if (vc->id == V4L2_CID_AUDIO_MUTE) {
404                 vc->value = mxb->cur_mute;
405                 DEB_D(("VIDIOC_G_CTRL V4L2_CID_AUDIO_MUTE:%d.\n", vc->value));
406                 return 0;
407         }
408
409         DEB_EE(("VIDIOC_G_CTRL V4L2_CID_AUDIO_MUTE:%d.\n", vc->value));
410         return 0;
411 }
412
413 static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *vc)
414 {
415         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
416         struct mxb *mxb = (struct mxb *)dev->ext_priv;
417         int i = 0;
418
419         for (i = MAXCONTROLS - 1; i >= 0; i--) {
420                 if (mxb_controls[i].id == vc->id)
421                         break;
422         }
423
424         if (i < 0)
425                 return dev->ext_vv_data->core_ops->vidioc_s_ctrl(file, fh, vc);
426
427         if (vc->id == V4L2_CID_AUDIO_MUTE) {
428                 mxb->cur_mute = vc->value;
429                 if (!vc->value) {
430                         /* switch the audio-source */
431                         tea6420_1_call(mxb, audio, s_routing,
432                                         &TEA6420_line[video_audio_connect[mxb->cur_input]][0]);
433                         tea6420_2_call(mxb, audio, s_routing,
434                                         &TEA6420_line[video_audio_connect[mxb->cur_input]][1]);
435                 } else {
436                         tea6420_1_call(mxb, audio, s_routing,
437                                         &TEA6420_line[6][0]);
438                         tea6420_2_call(mxb, audio, s_routing,
439                                         &TEA6420_line[6][1]);
440                 }
441                 DEB_EE(("VIDIOC_S_CTRL, V4L2_CID_AUDIO_MUTE: %d.\n", vc->value));
442         }
443         return 0;
444 }
445
446 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
447 {
448         DEB_EE(("VIDIOC_ENUMINPUT %d.\n", i->index));
449         if (i->index < 0 || i->index >= MXB_INPUTS)
450                 return -EINVAL;
451         memcpy(i, &mxb_inputs[i->index], sizeof(struct v4l2_input));
452         return 0;
453 }
454
455 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
456 {
457         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
458         struct mxb *mxb = (struct mxb *)dev->ext_priv;
459         *i = mxb->cur_input;
460
461         DEB_EE(("VIDIOC_G_INPUT %d.\n", *i));
462         return 0;
463 }
464
465 static int vidioc_s_input(struct file *file, void *fh, unsigned int input)
466 {
467         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
468         struct mxb *mxb = (struct mxb *)dev->ext_priv;
469         struct v4l2_routing route;
470         int i = 0;
471
472         DEB_EE(("VIDIOC_S_INPUT %d.\n", input));
473
474         if (input < 0 || input >= MXB_INPUTS)
475                 return -EINVAL;
476
477         mxb->cur_input = input;
478
479         saa7146_set_hps_source_and_sync(dev, input_port_selection[input].hps_source,
480                         input_port_selection[input].hps_sync);
481
482         /* prepare switching of tea6415c and saa7111a;
483            have a look at the 'background'-file for further informations  */
484         switch (input) {
485         case TUNER:
486                 i = SAA7115_COMPOSITE0;
487                 route.input = 3;
488                 route.output = 17;
489
490                 if (tea6415c_call(mxb, video, s_routing, &route)) {
491                         printk(KERN_ERR "VIDIOC_S_INPUT: could not address tea6415c #1\n");
492                         return -EFAULT;
493                 }
494                 /* connect tuner-output always to multicable */
495                 route.input = 3;
496                 route.output = 13;
497                 break;
498         case AUX3_YC:
499                 /* nothing to be done here. aux3_yc is
500                    directly connected to the saa711a */
501                 i = SAA7115_SVIDEO1;
502                 break;
503         case AUX3:
504                 /* nothing to be done here. aux3 is
505                    directly connected to the saa711a */
506                 i = SAA7115_COMPOSITE1;
507                 break;
508         case AUX1:
509                 i = SAA7115_COMPOSITE0;
510                 route.input = 1;
511                 route.output = 17;
512                 break;
513         }
514
515         /* switch video in tea6415c only if necessary */
516         switch (input) {
517         case TUNER:
518         case AUX1:
519                 if (tea6415c_call(mxb, video, s_routing, &route)) {
520                         printk(KERN_ERR "VIDIOC_S_INPUT: could not address tea6415c #3\n");
521                         return -EFAULT;
522                 }
523                 break;
524         default:
525                 break;
526         }
527
528         /* switch video in saa7111a */
529         route.input = i;
530         route.output = 0;
531         if (saa7111a_call(mxb, video, s_routing, &route))
532                 printk(KERN_ERR "VIDIOC_S_INPUT: could not address saa7111a #1.\n");
533
534         /* switch the audio-source only if necessary */
535         if (0 == mxb->cur_mute) {
536                 tea6420_1_call(mxb, audio, s_routing,
537                                 &TEA6420_line[video_audio_connect[input]][0]);
538                 tea6420_2_call(mxb, audio, s_routing,
539                                 &TEA6420_line[video_audio_connect[input]][1]);
540         }
541
542         return 0;
543 }
544
545 static int vidioc_g_tuner(struct file *file, void *fh, struct v4l2_tuner *t)
546 {
547         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
548         struct mxb *mxb = (struct mxb *)dev->ext_priv;
549
550         if (t->index) {
551                 DEB_D(("VIDIOC_G_TUNER: channel %d does not have a tuner attached.\n", t->index));
552                 return -EINVAL;
553         }
554
555         DEB_EE(("VIDIOC_G_TUNER: %d\n", t->index));
556
557         memset(t, 0, sizeof(*t));
558         strlcpy(t->name, "TV Tuner", sizeof(t->name));
559         t->type = V4L2_TUNER_ANALOG_TV;
560         t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO |
561                         V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
562         t->audmode = mxb->cur_mode;
563         return call_all(dev, tuner, g_tuner, t);
564 }
565
566 static int vidioc_s_tuner(struct file *file, void *fh, struct v4l2_tuner *t)
567 {
568         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
569         struct mxb *mxb = (struct mxb *)dev->ext_priv;
570
571         if (t->index) {
572                 DEB_D(("VIDIOC_S_TUNER: channel %d does not have a tuner attached.\n", t->index));
573                 return -EINVAL;
574         }
575
576         mxb->cur_mode = t->audmode;
577         return call_all(dev, tuner, s_tuner, t);
578 }
579
580 static int vidioc_g_frequency(struct file *file, void *fh, struct v4l2_frequency *f)
581 {
582         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
583         struct mxb *mxb = (struct mxb *)dev->ext_priv;
584
585         if (mxb->cur_input) {
586                 DEB_D(("VIDIOC_G_FREQ: channel %d does not have a tuner!\n",
587                                         mxb->cur_input));
588                 return -EINVAL;
589         }
590
591         *f = mxb->cur_freq;
592
593         DEB_EE(("VIDIOC_G_FREQ: freq:0x%08x.\n", mxb->cur_freq.frequency));
594         return 0;
595 }
596
597 static int vidioc_s_frequency(struct file *file, void *fh, struct v4l2_frequency *f)
598 {
599         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
600         struct mxb *mxb = (struct mxb *)dev->ext_priv;
601         struct saa7146_vv *vv = dev->vv_data;
602
603         if (f->tuner)
604                 return -EINVAL;
605
606         if (V4L2_TUNER_ANALOG_TV != f->type)
607                 return -EINVAL;
608
609         if (mxb->cur_input) {
610                 DEB_D(("VIDIOC_S_FREQ: channel %d does not have a tuner!\n", mxb->cur_input));
611                 return -EINVAL;
612         }
613
614         mxb->cur_freq = *f;
615         DEB_EE(("VIDIOC_S_FREQUENCY: freq:0x%08x.\n", mxb->cur_freq.frequency));
616
617         /* tune in desired frequency */
618         tuner_call(mxb, tuner, s_frequency, &mxb->cur_freq);
619
620         /* hack: changing the frequency should invalidate the vbi-counter (=> alevt) */
621         spin_lock(&dev->slock);
622         vv->vbi_fieldcount = 0;
623         spin_unlock(&dev->slock);
624
625         return 0;
626 }
627
628 static int vidioc_g_audio(struct file *file, void *fh, struct v4l2_audio *a)
629 {
630         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
631         struct mxb *mxb = (struct mxb *)dev->ext_priv;
632
633         if (a->index < 0 || a->index > MXB_INPUTS) {
634                 DEB_D(("VIDIOC_G_AUDIO %d out of range.\n", a->index));
635                 return -EINVAL;
636         }
637
638         DEB_EE(("VIDIOC_G_AUDIO %d.\n", a->index));
639         memcpy(a, &mxb_audios[video_audio_connect[mxb->cur_input]], sizeof(struct v4l2_audio));
640         return 0;
641 }
642
643 static int vidioc_s_audio(struct file *file, void *fh, struct v4l2_audio *a)
644 {
645         DEB_D(("VIDIOC_S_AUDIO %d.\n", a->index));
646         return 0;
647 }
648
649 #ifdef CONFIG_VIDEO_ADV_DEBUG
650 static int vidioc_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
651 {
652         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
653
654         return call_all(dev, core, g_register, reg);
655 }
656
657 static int vidioc_s_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
658 {
659         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
660
661         return call_all(dev, core, s_register, reg);
662 }
663 #endif
664
665 static long vidioc_default(struct file *file, void *fh, int cmd, void *arg)
666 {
667         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
668         struct mxb *mxb = (struct mxb *)dev->ext_priv;
669
670         switch (cmd) {
671         case MXB_S_AUDIO_CD:
672         {
673                 int i = *(int *)arg;
674
675                 if (i < 0 || i >= MXB_AUDIOS) {
676                         DEB_D(("illegal argument to MXB_S_AUDIO_CD: i:%d.\n", i));
677                         return -EINVAL;
678                 }
679
680                 DEB_EE(("MXB_S_AUDIO_CD: i:%d.\n", i));
681
682                 tea6420_1_call(mxb, audio, s_routing, &TEA6420_cd[i][0]);
683                 tea6420_2_call(mxb, audio, s_routing, &TEA6420_cd[i][1]);
684
685                 return 0;
686         }
687         case MXB_S_AUDIO_LINE:
688         {
689                 int i = *(int *)arg;
690
691                 if (i < 0 || i >= MXB_AUDIOS) {
692                         DEB_D(("illegal argument to MXB_S_AUDIO_LINE: i:%d.\n", i));
693                         return -EINVAL;
694                 }
695
696                 DEB_EE(("MXB_S_AUDIO_LINE: i:%d.\n", i));
697                 tea6420_1_call(mxb, audio, s_routing, &TEA6420_line[i][0]);
698                 tea6420_2_call(mxb, audio, s_routing, &TEA6420_line[i][1]);
699
700                 return 0;
701         }
702         default:
703 /*
704                 DEB2(printk("does not handle this ioctl.\n"));
705 */
706                 return -ENOIOCTLCMD;
707         }
708         return 0;
709 }
710
711 static struct saa7146_ext_vv vv_data;
712
713 /* this function only gets called when the probing was successful */
714 static int mxb_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
715 {
716         struct mxb *mxb = (struct mxb *)dev->ext_priv;
717
718         DEB_EE(("dev:%p\n", dev));
719
720         /* checking for i2c-devices can be omitted here, because we
721            already did this in "mxb_vl42_probe" */
722
723         saa7146_vv_init(dev, &vv_data);
724         vv_data.ops.vidioc_queryctrl = vidioc_queryctrl;
725         vv_data.ops.vidioc_g_ctrl = vidioc_g_ctrl;
726         vv_data.ops.vidioc_s_ctrl = vidioc_s_ctrl;
727         vv_data.ops.vidioc_enum_input = vidioc_enum_input;
728         vv_data.ops.vidioc_g_input = vidioc_g_input;
729         vv_data.ops.vidioc_s_input = vidioc_s_input;
730         vv_data.ops.vidioc_g_tuner = vidioc_g_tuner;
731         vv_data.ops.vidioc_s_tuner = vidioc_s_tuner;
732         vv_data.ops.vidioc_g_frequency = vidioc_g_frequency;
733         vv_data.ops.vidioc_s_frequency = vidioc_s_frequency;
734         vv_data.ops.vidioc_g_audio = vidioc_g_audio;
735         vv_data.ops.vidioc_s_audio = vidioc_s_audio;
736 #ifdef CONFIG_VIDEO_ADV_DEBUG
737         vv_data.ops.vidioc_g_register = vidioc_g_register;
738         vv_data.ops.vidioc_s_register = vidioc_s_register;
739 #endif
740         vv_data.ops.vidioc_default = vidioc_default;
741         if (saa7146_register_device(&mxb->video_dev, dev, "mxb", VFL_TYPE_GRABBER)) {
742                 ERR(("cannot register capture v4l2 device. skipping.\n"));
743                 return -1;
744         }
745
746         /* initialization stuff (vbi) (only for revision > 0 and for extensions which want it)*/
747         if (MXB_BOARD_CAN_DO_VBI(dev)) {
748                 if (saa7146_register_device(&mxb->vbi_dev, dev, "mxb", VFL_TYPE_VBI)) {
749                         ERR(("cannot register vbi v4l2 device. skipping.\n"));
750                 }
751         }
752
753         printk("mxb: found Multimedia eXtension Board #%d.\n", mxb_num);
754
755         mxb_num++;
756         mxb_init_done(dev);
757         return 0;
758 }
759
760 static int mxb_detach(struct saa7146_dev *dev)
761 {
762         struct mxb *mxb = (struct mxb *)dev->ext_priv;
763
764         DEB_EE(("dev:%p\n", dev));
765
766         saa7146_unregister_device(&mxb->video_dev,dev);
767         if (MXB_BOARD_CAN_DO_VBI(dev))
768                 saa7146_unregister_device(&mxb->vbi_dev, dev);
769         saa7146_vv_release(dev);
770
771         mxb_num--;
772
773         i2c_del_adapter(&mxb->i2c_adapter);
774         kfree(mxb);
775
776         return 0;
777 }
778
779 static int std_callback(struct saa7146_dev *dev, struct saa7146_standard *standard)
780 {
781         struct mxb *mxb = (struct mxb *)dev->ext_priv;
782
783         if (V4L2_STD_PAL_I == standard->id) {
784                 v4l2_std_id std = V4L2_STD_PAL_I;
785
786                 DEB_D(("VIDIOC_S_STD: setting mxb for PAL_I.\n"));
787                 /* set the 7146 gpio register -- I don't know what this does exactly */
788                 saa7146_write(dev, GPIO_CTRL, 0x00404050);
789                 /* unset the 7111 gpio register -- I don't know what this does exactly */
790                 saa7111a_call(mxb, core, s_gpio, 0);
791                 tuner_call(mxb, tuner, s_std, std);
792         } else {
793                 v4l2_std_id std = V4L2_STD_PAL_BG;
794
795                 DEB_D(("VIDIOC_S_STD: setting mxb for PAL/NTSC/SECAM.\n"));
796                 /* set the 7146 gpio register -- I don't know what this does exactly */
797                 saa7146_write(dev, GPIO_CTRL, 0x00404050);
798                 /* set the 7111 gpio register -- I don't know what this does exactly */
799                 saa7111a_call(mxb, core, s_gpio, 1);
800                 tuner_call(mxb, tuner, s_std, std);
801         }
802         return 0;
803 }
804
805 static struct saa7146_standard standard[] = {
806         {
807                 .name   = "PAL-BG",     .id     = V4L2_STD_PAL_BG,
808                 .v_offset       = 0x17, .v_field        = 288,
809                 .h_offset       = 0x14, .h_pixels       = 680,
810                 .v_max_out      = 576,  .h_max_out      = 768,
811         }, {
812                 .name   = "PAL-I",      .id     = V4L2_STD_PAL_I,
813                 .v_offset       = 0x17, .v_field        = 288,
814                 .h_offset       = 0x14, .h_pixels       = 680,
815                 .v_max_out      = 576,  .h_max_out      = 768,
816         }, {
817                 .name   = "NTSC",       .id     = V4L2_STD_NTSC,
818                 .v_offset       = 0x16, .v_field        = 240,
819                 .h_offset       = 0x06, .h_pixels       = 708,
820                 .v_max_out      = 480,  .h_max_out      = 640,
821         }, {
822                 .name   = "SECAM",      .id     = V4L2_STD_SECAM,
823                 .v_offset       = 0x14, .v_field        = 288,
824                 .h_offset       = 0x14, .h_pixels       = 720,
825                 .v_max_out      = 576,  .h_max_out      = 768,
826         }
827 };
828
829 static struct saa7146_pci_extension_data mxb = {
830         .ext_priv = "Multimedia eXtension Board",
831         .ext = &extension,
832 };
833
834 static struct pci_device_id pci_tbl[] = {
835         {
836                 .vendor    = PCI_VENDOR_ID_PHILIPS,
837                 .device    = PCI_DEVICE_ID_PHILIPS_SAA7146,
838                 .subvendor = 0x0000,
839                 .subdevice = 0x0000,
840                 .driver_data = (unsigned long)&mxb,
841         }, {
842                 .vendor = 0,
843         }
844 };
845
846 MODULE_DEVICE_TABLE(pci, pci_tbl);
847
848 static struct saa7146_ext_vv vv_data = {
849         .inputs         = MXB_INPUTS,
850         .capabilities   = V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE,
851         .stds           = &standard[0],
852         .num_stds       = sizeof(standard)/sizeof(struct saa7146_standard),
853         .std_callback   = &std_callback,
854 };
855
856 static struct saa7146_extension extension = {
857         .name           = MXB_IDENTIFIER,
858         .flags          = SAA7146_USE_I2C_IRQ,
859
860         .pci_tbl        = &pci_tbl[0],
861         .module         = THIS_MODULE,
862
863         .probe          = mxb_probe,
864         .attach         = mxb_attach,
865         .detach         = mxb_detach,
866
867         .irq_mask       = 0,
868         .irq_func       = NULL,
869 };
870
871 static int __init mxb_init_module(void)
872 {
873         if (saa7146_register_extension(&extension)) {
874                 DEB_S(("failed to register extension.\n"));
875                 return -ENODEV;
876         }
877
878         return 0;
879 }
880
881 static void __exit mxb_cleanup_module(void)
882 {
883         saa7146_unregister_extension(&extension);
884 }
885
886 module_init(mxb_init_module);
887 module_exit(mxb_cleanup_module);
888
889 MODULE_DESCRIPTION("video4linux-2 driver for the Siemens-Nixdorf 'Multimedia eXtension board'");
890 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
891 MODULE_LICENSE("GPL");