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