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