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