]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/media/video/mxb.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Linux-2.6.12-rc2
[mirror_ubuntu-artful-kernel.git] / drivers / media / video / mxb.c
1 /*
2 mxb - v4l2 driver for the Multimedia eXtension Board
3
4 Copyright (C) 1998-2003 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
30 #include "mxb.h"
31 #include "tea6415c.h"
32 #include "tea6420.h"
33 #include "tda9840.h"
34
35 #define I2C_SAA7111 0x24
36
37 #define MXB_BOARD_CAN_DO_VBI(dev) (dev->revision != 0)
38
39 /* global variable */
40 static int mxb_num = 0;
41
42 /* initial frequence the tuner will be tuned to.
43 in verden (lower saxony, germany) 4148 is a
44 channel called "phoenix" */
45 static int freq = 4148;
46 module_param(freq, int, 0644);
47 MODULE_PARM_DESC(freq, "initial frequency the tuner will be tuned to while setup");
48
49 static int debug = 0;
50 module_param(debug, int, 0644);
51 MODULE_PARM_DESC(debug, "Turn on/off device debugging (default:off).");
52
53 #define MXB_INPUTS 4
54 enum { TUNER, AUX1, AUX3, AUX3_YC };
55
56 static struct v4l2_input mxb_inputs[MXB_INPUTS] = {
57 { TUNER, "Tuner", V4L2_INPUT_TYPE_TUNER, 1, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
58 { AUX1, "AUX1", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
59 { AUX3, "AUX3 Composite", V4L2_INPUT_TYPE_CAMERA, 4, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
60 { AUX3_YC, "AUX3 S-Video", V4L2_INPUT_TYPE_CAMERA, 4, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
61 };
62
63 /* this array holds the information, which port of the saa7146 each
64 input actually uses. the mxb uses port 0 for every input */
65 static struct {
66 int hps_source;
67 int hps_sync;
68 } input_port_selection[MXB_INPUTS] = {
69 { SAA7146_HPS_SOURCE_PORT_A, SAA7146_HPS_SYNC_PORT_A },
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 };
74
75 /* this array holds the information of the audio source (mxb_audios),
76 which has to be switched corresponding to the video source (mxb_channels) */
77 static int video_audio_connect[MXB_INPUTS] =
78 { 0, 1, 3, 3 };
79
80 /* these are the necessary input-output-pins for bringing one audio source
81 (see above) to the CD-output */
82 static struct tea6420_multiplex TEA6420_cd[MXB_AUDIOS+1][2] =
83 {
84 {{1,1,0},{1,1,0}}, /* Tuner */
85 {{5,1,0},{6,1,0}}, /* AUX 1 */
86 {{4,1,0},{6,1,0}}, /* AUX 2 */
87 {{3,1,0},{6,1,0}}, /* AUX 3 */
88 {{1,1,0},{3,1,0}}, /* Radio */
89 {{1,1,0},{2,1,0}}, /* CD-Rom */
90 {{6,1,0},{6,1,0}} /* Mute */
91 };
92
93 /* these are the necessary input-output-pins for bringing one audio source
94 (see above) to the line-output */
95 static struct tea6420_multiplex TEA6420_line[MXB_AUDIOS+1][2] =
96 {
97 {{2,3,0},{1,2,0}},
98 {{5,3,0},{6,2,0}},
99 {{4,3,0},{6,2,0}},
100 {{3,3,0},{6,2,0}},
101 {{2,3,0},{3,2,0}},
102 {{2,3,0},{2,2,0}},
103 {{6,3,0},{6,2,0}} /* Mute */
104 };
105
106 #define MAXCONTROLS 1
107 static struct v4l2_queryctrl mxb_controls[] = {
108 { V4L2_CID_AUDIO_MUTE, V4L2_CTRL_TYPE_BOOLEAN, "Mute", 0, 1, 1, 0, 0 },
109 };
110
111 static struct saa7146_extension_ioctls ioctls[] = {
112 { VIDIOC_ENUMINPUT, SAA7146_EXCLUSIVE },
113 { VIDIOC_G_INPUT, SAA7146_EXCLUSIVE },
114 { VIDIOC_S_INPUT, SAA7146_EXCLUSIVE },
115 { VIDIOC_QUERYCTRL, SAA7146_BEFORE },
116 { VIDIOC_G_CTRL, SAA7146_BEFORE },
117 { VIDIOC_S_CTRL, SAA7146_BEFORE },
118 { VIDIOC_G_TUNER, SAA7146_EXCLUSIVE },
119 { VIDIOC_S_TUNER, SAA7146_EXCLUSIVE },
120 { VIDIOC_G_FREQUENCY, SAA7146_EXCLUSIVE },
121 { VIDIOC_S_FREQUENCY, SAA7146_EXCLUSIVE },
122 { VIDIOC_G_AUDIO, SAA7146_EXCLUSIVE },
123 { VIDIOC_S_AUDIO, SAA7146_EXCLUSIVE },
124 { MXB_S_AUDIO_CD, SAA7146_EXCLUSIVE }, /* custom control */
125 { MXB_S_AUDIO_LINE, SAA7146_EXCLUSIVE }, /* custom control */
126 { 0, 0 }
127 };
128
129 struct mxb
130 {
131 struct video_device *video_dev;
132 struct video_device *vbi_dev;
133
134 struct i2c_adapter i2c_adapter;
135
136 struct i2c_client* saa7111a;
137 struct i2c_client* tda9840;
138 struct i2c_client* tea6415c;
139 struct i2c_client* tuner;
140 struct i2c_client* tea6420_1;
141 struct i2c_client* tea6420_2;
142
143 int cur_mode; /* current audio mode (mono, stereo, ...) */
144 int cur_input; /* current input */
145 int cur_freq; /* current frequency the tuner is tuned to */
146 int cur_mute; /* current mute status */
147 };
148
149 static struct saa7146_extension extension;
150
151 static int mxb_probe(struct saa7146_dev* dev)
152 {
153 struct mxb* mxb = NULL;
154 struct i2c_client *client;
155 struct list_head *item;
156 int result;
157
158 if ((result = request_module("saa7111")) < 0) {
159 printk("mxb: saa7111 i2c module not available.\n");
160 return -ENODEV;
161 }
162 if ((result = request_module("tuner")) < 0) {
163 printk("mxb: tuner i2c module not available.\n");
164 return -ENODEV;
165 }
166 if ((result = request_module("tea6420")) < 0) {
167 printk("mxb: tea6420 i2c module not available.\n");
168 return -ENODEV;
169 }
170 if ((result = request_module("tea6415c")) < 0) {
171 printk("mxb: tea6415c i2c module not available.\n");
172 return -ENODEV;
173 }
174 if ((result = request_module("tda9840")) < 0) {
175 printk("mxb: tda9840 i2c module not available.\n");
176 return -ENODEV;
177 }
178
179 mxb = (struct mxb*)kmalloc(sizeof(struct mxb), GFP_KERNEL);
180 if( NULL == mxb ) {
181 DEB_D(("not enough kernel memory.\n"));
182 return -ENOMEM;
183 }
184 memset(mxb, 0x0, sizeof(struct mxb));
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_TEA6420_1 == client->addr )
202 mxb->tea6420_1 = client;
203 if( I2C_TEA6420_2 == client->addr )
204 mxb->tea6420_2 = client;
205 if( I2C_TEA6415C_2 == client->addr )
206 mxb->tea6415c = client;
207 if( I2C_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
330 int i = 0, err = 0;
331 struct tea6415c_multiplex vm;
332
333 /* select video mode in saa7111a */
334 i = VIDEO_MODE_PAL;
335 /* fixme: currently pointless: gets overwritten by configuration below */
336 mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_NORM, &i);
337
338 /* write configuration to saa7111a */
339 init.data = mxb_saa7111_init;
340 init.len = sizeof(mxb_saa7111_init);
341 mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_INIT, &init);
342
343 /* select tuner-output on saa7111a */
344 i = 0;
345 mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_INPUT, &i);
346
347 /* enable vbi bypass */
348 i = 1;
349 mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_VBI_BYPASS, &i);
350
351 /* select a tuner type */
352 i = 5;
353 mxb->tuner->driver->command(mxb->tuner,TUNER_SET_TYPE, &i);
354
355 /* mute audio on tea6420s */
356 mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_line[6][0]);
357 mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_line[6][1]);
358 mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_cd[6][0]);
359 mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_cd[6][1]);
360
361 /* switch to tuner-channel on tea6415c*/
362 vm.out = 17;
363 vm.in = 3;
364 mxb->tea6415c->driver->command(mxb->tea6415c,TEA6415C_SWITCH, &vm);
365
366 /* select tuner-output on multicable on tea6415c*/
367 vm.in = 3;
368 vm.out = 13;
369 mxb->tea6415c->driver->command(mxb->tea6415c,TEA6415C_SWITCH, &vm);
370
371 /* tune in some frequency on tuner */
372 mxb->tuner->driver->command(mxb->tuner, VIDIOCSFREQ, &freq);
373
374 /* the rest for mxb */
375 mxb->cur_input = 0;
376 mxb->cur_freq = freq;
377 mxb->cur_mute = 1;
378
379 mxb->cur_mode = V4L2_TUNER_MODE_STEREO;
380 mxb->tda9840->driver->command(mxb->tda9840, TDA9840_SWITCH, &mxb->cur_mode);
381
382 /* check if the saa7740 (aka 'sound arena module') is present
383 on the mxb. if so, we must initialize it. due to lack of
384 informations about the saa7740, the values were reverse
385 engineered. */
386 msg.addr = 0x1b;
387 msg.flags = 0;
388 msg.len = mxb_saa7740_init[0].length;
389 msg.buf = &mxb_saa7740_init[0].data[0];
390
391 if( 1 == (err = i2c_transfer(&mxb->i2c_adapter, &msg, 1))) {
392 /* the sound arena module is a pos, that's probably the reason
393 philips refuses to hand out a datasheet for the saa7740...
394 it seems to screw up the i2c bus, so we disable fast irq
395 based i2c transactions here and rely on the slow and safe
396 polling method ... */
397 extension.flags &= ~SAA7146_USE_I2C_IRQ;
398 for(i = 1;;i++) {
399 if( -1 == mxb_saa7740_init[i].length ) {
400 break;
401 }
402
403 msg.len = mxb_saa7740_init[i].length;
404 msg.buf = &mxb_saa7740_init[i].data[0];
405 if( 1 != (err = i2c_transfer(&mxb->i2c_adapter, &msg, 1))) {
406 DEB_D(("failed to initialize 'sound arena module'.\n"));
407 goto err;
408 }
409 }
410 INFO(("'sound arena module' detected.\n"));
411 }
412 err:
413 /* the rest for saa7146: you should definitely set some basic values
414 for the input-port handling of the saa7146. */
415
416 /* ext->saa has been filled by the core driver */
417
418 /* some stuff is done via variables */
419 saa7146_set_hps_source_and_sync(dev, input_port_selection[mxb->cur_input].hps_source, input_port_selection[mxb->cur_input].hps_sync);
420
421 /* some stuff is done via direct write to the registers */
422
423 /* this is ugly, but because of the fact that this is completely
424 hardware dependend, it should be done directly... */
425 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
426 saa7146_write(dev, DD1_INIT, 0x02000200);
427 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
428
429 return 0;
430 }
431
432 /* interrupt-handler. this gets called when irq_mask is != 0.
433 it must clear the interrupt-bits in irq_mask it has handled */
434 /*
435 void mxb_irq_bh(struct saa7146_dev* dev, u32* irq_mask)
436 {
437 struct mxb* mxb = (struct mxb*)dev->ext_priv;
438 }
439 */
440
441 static struct saa7146_ext_vv vv_data;
442
443 /* this function only gets called when the probing was successful */
444 static int mxb_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_data *info)
445 {
446 struct mxb* mxb = (struct mxb*)dev->ext_priv;
447
448 DEB_EE(("dev:%p\n",dev));
449
450 /* checking for i2c-devices can be omitted here, because we
451 already did this in "mxb_vl42_probe" */
452
453 saa7146_vv_init(dev,&vv_data);
454 if( 0 != saa7146_register_device(&mxb->video_dev, dev, "mxb", VFL_TYPE_GRABBER)) {
455 ERR(("cannot register capture v4l2 device. skipping.\n"));
456 return -1;
457 }
458
459 /* initialization stuff (vbi) (only for revision > 0 and for extensions which want it)*/
460 if( 0 != MXB_BOARD_CAN_DO_VBI(dev)) {
461 if( 0 != saa7146_register_device(&mxb->vbi_dev, dev, "mxb", VFL_TYPE_VBI)) {
462 ERR(("cannot register vbi v4l2 device. skipping.\n"));
463 }
464 }
465
466 i2c_use_client(mxb->tea6420_1);
467 i2c_use_client(mxb->tea6420_2);
468 i2c_use_client(mxb->tea6415c);
469 i2c_use_client(mxb->tda9840);
470 i2c_use_client(mxb->saa7111a);
471 i2c_use_client(mxb->tuner);
472
473 printk("mxb: found 'Multimedia eXtension Board'-%d.\n",mxb_num);
474
475 mxb_num++;
476 mxb_init_done(dev);
477 return 0;
478 }
479
480 static int mxb_detach(struct saa7146_dev* dev)
481 {
482 struct mxb* mxb = (struct mxb*)dev->ext_priv;
483
484 DEB_EE(("dev:%p\n",dev));
485
486 i2c_release_client(mxb->tea6420_1);
487 i2c_release_client(mxb->tea6420_2);
488 i2c_release_client(mxb->tea6415c);
489 i2c_release_client(mxb->tda9840);
490 i2c_release_client(mxb->saa7111a);
491 i2c_release_client(mxb->tuner);
492
493 saa7146_unregister_device(&mxb->video_dev,dev);
494 if( 0 != MXB_BOARD_CAN_DO_VBI(dev)) {
495 saa7146_unregister_device(&mxb->vbi_dev,dev);
496 }
497 saa7146_vv_release(dev);
498
499 mxb_num--;
500
501 i2c_del_adapter(&mxb->i2c_adapter);
502 kfree(mxb);
503
504 return 0;
505 }
506
507 static int mxb_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
508 {
509 struct saa7146_dev *dev = fh->dev;
510 struct mxb* mxb = (struct mxb*)dev->ext_priv;
511 struct saa7146_vv *vv = dev->vv_data;
512
513 switch(cmd) {
514 case VIDIOC_ENUMINPUT:
515 {
516 struct v4l2_input *i = arg;
517
518 DEB_EE(("VIDIOC_ENUMINPUT %d.\n",i->index));
519 if( i->index < 0 || i->index >= MXB_INPUTS) {
520 return -EINVAL;
521 }
522 memcpy(i, &mxb_inputs[i->index], sizeof(struct v4l2_input));
523
524 return 0;
525 }
526 /* the saa7146 provides some controls (brightness, contrast, saturation)
527 which gets registered *after* this function. because of this we have
528 to return with a value != 0 even if the function succeded.. */
529 case VIDIOC_QUERYCTRL:
530 {
531 struct v4l2_queryctrl *qc = arg;
532 int i;
533
534 for (i = MAXCONTROLS - 1; i >= 0; i--) {
535 if (mxb_controls[i].id == qc->id) {
536 *qc = mxb_controls[i];
537 DEB_D(("VIDIOC_QUERYCTRL %d.\n",qc->id));
538 return 0;
539 }
540 }
541 return -EAGAIN;
542 }
543 case VIDIOC_G_CTRL:
544 {
545 struct v4l2_control *vc = arg;
546 int i;
547
548 for (i = MAXCONTROLS - 1; i >= 0; i--) {
549 if (mxb_controls[i].id == vc->id) {
550 break;
551 }
552 }
553
554 if( i < 0 ) {
555 return -EAGAIN;
556 }
557
558 switch (vc->id ) {
559 case V4L2_CID_AUDIO_MUTE: {
560 vc->value = mxb->cur_mute;
561 DEB_D(("VIDIOC_G_CTRL V4L2_CID_AUDIO_MUTE:%d.\n",vc->value));
562 return 0;
563 }
564 }
565
566 DEB_EE(("VIDIOC_G_CTRL V4L2_CID_AUDIO_MUTE:%d.\n",vc->value));
567 return 0;
568 }
569
570 case VIDIOC_S_CTRL:
571 {
572 struct v4l2_control *vc = arg;
573 int i = 0;
574
575 for (i = MAXCONTROLS - 1; i >= 0; i--) {
576 if (mxb_controls[i].id == vc->id) {
577 break;
578 }
579 }
580
581 if( i < 0 ) {
582 return -EAGAIN;
583 }
584
585 switch (vc->id ) {
586 case V4L2_CID_AUDIO_MUTE: {
587 mxb->cur_mute = vc->value;
588 if( 0 == vc->value ) {
589 /* switch the audio-source */
590 mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_line[video_audio_connect[mxb->cur_input]][0]);
591 mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_line[video_audio_connect[mxb->cur_input]][1]);
592 } else {
593 mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_line[6][0]);
594 mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_line[6][1]);
595 }
596 DEB_EE(("VIDIOC_S_CTRL, V4L2_CID_AUDIO_MUTE: %d.\n",vc->value));
597 break;
598 }
599 }
600 return 0;
601 }
602 case VIDIOC_G_INPUT:
603 {
604 int *input = (int *)arg;
605 *input = mxb->cur_input;
606
607 DEB_EE(("VIDIOC_G_INPUT %d.\n",*input));
608 return 0;
609 }
610 case VIDIOC_S_INPUT:
611 {
612 int input = *(int *)arg;
613 struct tea6415c_multiplex vm;
614 int i = 0;
615
616 DEB_EE(("VIDIOC_S_INPUT %d.\n",input));
617
618 if (input < 0 || input >= MXB_INPUTS) {
619 return -EINVAL;
620 }
621
622 /* fixme: locke das setzen des inputs mit hilfe des mutexes
623 down(&dev->lock);
624 video_mux(dev,*i);
625 up(&dev->lock);
626 */
627
628 /* fixme: check if streaming capture
629 if ( 0 != dev->streaming ) {
630 DEB_D(("VIDIOC_S_INPUT illegal while streaming.\n"));
631 return -EPERM;
632 }
633 */
634
635 mxb->cur_input = input;
636
637 saa7146_set_hps_source_and_sync(dev, input_port_selection[input].hps_source, input_port_selection[input].hps_sync);
638
639 /* prepare switching of tea6415c and saa7111a;
640 have a look at the 'background'-file for further informations */
641 switch( input ) {
642
643 case TUNER:
644 {
645 i = 0;
646 vm.in = 3;
647 vm.out = 17;
648
649 if ( 0 != mxb->tea6415c->driver->command(mxb->tea6415c,TEA6415C_SWITCH, &vm)) {
650 printk("VIDIOC_S_INPUT: could not address tea6415c #1\n");
651 return -EFAULT;
652 }
653 /* connect tuner-output always to multicable */
654 vm.in = 3;
655 vm.out = 13;
656 break;
657 }
658 case AUX3_YC:
659 {
660 /* nothing to be done here. aux3_yc is
661 directly connected to the saa711a */
662 i = 5;
663 break;
664 }
665 case AUX3:
666 {
667 /* nothing to be done here. aux3 is
668 directly connected to the saa711a */
669 i = 1;
670 break;
671 }
672 case AUX1:
673 {
674 i = 0;
675 vm.in = 1;
676 vm.out = 17;
677 break;
678 }
679 }
680
681 /* switch video in tea6415c only if necessary */
682 switch( input ) {
683 case TUNER:
684 case AUX1:
685 {
686 if ( 0 != mxb->tea6415c->driver->command(mxb->tea6415c,TEA6415C_SWITCH, &vm)) {
687 printk("VIDIOC_S_INPUT: could not address tea6415c #3\n");
688 return -EFAULT;
689 }
690 break;
691 }
692 default:
693 {
694 break;
695 }
696 }
697
698 /* switch video in saa7111a */
699 if ( 0 != mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_INPUT, &i)) {
700 printk("VIDIOC_S_INPUT: could not address saa7111a #1.\n");
701 }
702
703 /* switch the audio-source only if necessary */
704 if( 0 == mxb->cur_mute ) {
705 mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_line[video_audio_connect[input]][0]);
706 mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_line[video_audio_connect[input]][1]);
707 }
708
709 return 0;
710 }
711 case VIDIOC_G_TUNER:
712 {
713 struct v4l2_tuner *t = arg;
714 int byte = 0;
715
716 if( 0 != t->index ) {
717 DEB_D(("VIDIOC_G_TUNER: channel %d does not have a tuner attached.\n", t->index));
718 return -EINVAL;
719 }
720
721 DEB_EE(("VIDIOC_G_TUNER: %d\n", t->index));
722
723 memset(t,0,sizeof(*t));
724 strcpy(t->name, "Television");
725
726 t->type = V4L2_TUNER_ANALOG_TV;
727 t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
728 t->rangelow = 772; /* 48.25 MHZ / 62.5 kHz = 772, see fi1216mk2-specs, page 2 */
729 t->rangehigh = 13684; /* 855.25 MHz / 62.5 kHz = 13684 */
730 /* FIXME: add the real signal strength here */
731 t->signal = 0xffff;
732 t->afc = 0;
733
734 mxb->tda9840->driver->command(mxb->tda9840,TDA9840_DETECT, &byte);
735 t->audmode = mxb->cur_mode;
736
737 if( byte < 0 ) {
738 t->rxsubchans = V4L2_TUNER_SUB_MONO;
739 } else {
740 switch(byte) {
741 case TDA9840_MONO_DETECT: {
742 t->rxsubchans = V4L2_TUNER_SUB_MONO;
743 DEB_D(("VIDIOC_G_TUNER: V4L2_TUNER_MODE_MONO.\n"));
744 break;
745 }
746 case TDA9840_DUAL_DETECT: {
747 t->rxsubchans = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
748 DEB_D(("VIDIOC_G_TUNER: V4L2_TUNER_MODE_LANG1.\n"));
749 break;
750 }
751 case TDA9840_STEREO_DETECT: {
752 t->rxsubchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_MONO;
753 DEB_D(("VIDIOC_G_TUNER: V4L2_TUNER_MODE_STEREO.\n"));
754 break;
755 }
756 default: { /* TDA9840_INCORRECT_DETECT */
757 t->rxsubchans = V4L2_TUNER_MODE_MONO;
758 DEB_D(("VIDIOC_G_TUNER: TDA9840_INCORRECT_DETECT => V4L2_TUNER_MODE_MONO\n"));
759 break;
760 }
761 }
762 }
763
764 return 0;
765 }
766 case VIDIOC_S_TUNER:
767 {
768 struct v4l2_tuner *t = arg;
769 int result = 0;
770 int byte = 0;
771
772 if( 0 != t->index ) {
773 DEB_D(("VIDIOC_S_TUNER: channel %d does not have a tuner attached.\n",t->index));
774 return -EINVAL;
775 }
776
777 switch(t->audmode) {
778 case V4L2_TUNER_MODE_STEREO: {
779 mxb->cur_mode = V4L2_TUNER_MODE_STEREO;
780 byte = TDA9840_SET_STEREO;
781 DEB_D(("VIDIOC_S_TUNER: V4L2_TUNER_MODE_STEREO\n"));
782 break;
783 }
784 case V4L2_TUNER_MODE_LANG1: {
785 mxb->cur_mode = V4L2_TUNER_MODE_LANG1;
786 byte = TDA9840_SET_LANG1;
787 DEB_D(("VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG1\n"));
788 break;
789 }
790 case V4L2_TUNER_MODE_LANG2: {
791 mxb->cur_mode = V4L2_TUNER_MODE_LANG2;
792 byte = TDA9840_SET_LANG2;
793 DEB_D(("VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG2\n"));
794 break;
795 }
796 default: { /* case V4L2_TUNER_MODE_MONO: {*/
797 mxb->cur_mode = V4L2_TUNER_MODE_MONO;
798 byte = TDA9840_SET_MONO;
799 DEB_D(("VIDIOC_S_TUNER: TDA9840_SET_MONO\n"));
800 break;
801 }
802 }
803
804 if( 0 != (result = mxb->tda9840->driver->command(mxb->tda9840, TDA9840_SWITCH, &byte))) {
805 printk("VIDIOC_S_TUNER error. result:%d, byte:%d\n",result,byte);
806 }
807
808 return 0;
809 }
810 case VIDIOC_G_FREQUENCY:
811 {
812 struct v4l2_frequency *f = arg;
813
814 if(0 != mxb->cur_input) {
815 DEB_D(("VIDIOC_G_FREQ: channel %d does not have a tuner!\n",mxb->cur_input));
816 return -EINVAL;
817 }
818
819 memset(f,0,sizeof(*f));
820 f->type = V4L2_TUNER_ANALOG_TV;
821 f->frequency = mxb->cur_freq;
822
823 DEB_EE(("VIDIOC_G_FREQ: freq:0x%08x.\n", mxb->cur_freq));
824 return 0;
825 }
826 case VIDIOC_S_FREQUENCY:
827 {
828 struct v4l2_frequency *f = arg;
829 int t_locked = 0;
830 int v_byte = 0;
831
832 if (0 != f->tuner)
833 return -EINVAL;
834
835 if (V4L2_TUNER_ANALOG_TV != f->type)
836 return -EINVAL;
837
838 if(0 != mxb->cur_input) {
839 DEB_D(("VIDIOC_S_FREQ: channel %d does not have a tuner!\n",mxb->cur_input));
840 return -EINVAL;
841 }
842
843 DEB_EE(("VIDIOC_S_FREQUENCY: freq:0x%08x.\n",f->frequency));
844
845 mxb->cur_freq = f->frequency;
846
847 /* tune in desired frequency */
848 mxb->tuner->driver->command(mxb->tuner, VIDIOCSFREQ, &mxb->cur_freq);
849
850 /* check if pll of tuner & saa7111a is locked */
851 // mxb->tuner->driver->command(mxb->tuner,TUNER_IS_LOCKED, &t_locked);
852 mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_GET_STATUS, &v_byte);
853
854 /* not locked -- anything to do here ? */
855 if( 0 == t_locked || 0 == (v_byte & DECODER_STATUS_GOOD)) {
856 }
857
858 /* hack: changing the frequency should invalidate the vbi-counter (=> alevt) */
859 spin_lock(&dev->slock);
860 vv->vbi_fieldcount = 0;
861 spin_unlock(&dev->slock);
862
863 return 0;
864 }
865 case MXB_S_AUDIO_CD:
866 {
867 int i = *(int*)arg;
868
869 if( i < 0 || i >= MXB_AUDIOS ) {
870 DEB_D(("illegal argument to MXB_S_AUDIO_CD: i:%d.\n",i));
871 return -EINVAL;
872 }
873
874 DEB_EE(("MXB_S_AUDIO_CD: i:%d.\n",i));
875
876 mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_cd[i][0]);
877 mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_cd[i][1]);
878
879 return 0;
880 }
881 case MXB_S_AUDIO_LINE:
882 {
883 int i = *(int*)arg;
884
885 if( i < 0 || i >= MXB_AUDIOS ) {
886 DEB_D(("illegal argument to MXB_S_AUDIO_LINE: i:%d.\n",i));
887 return -EINVAL;
888 }
889
890 DEB_EE(("MXB_S_AUDIO_LINE: i:%d.\n",i));
891 mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_line[i][0]);
892 mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_line[i][1]);
893
894 return 0;
895 }
896 case VIDIOC_G_AUDIO:
897 {
898 struct v4l2_audio *a = arg;
899
900 if( a->index < 0 || a->index > MXB_INPUTS ) {
901 DEB_D(("VIDIOC_G_AUDIO %d out of range.\n",a->index));
902 return -EINVAL;
903 }
904
905 DEB_EE(("VIDIOC_G_AUDIO %d.\n",a->index));
906 memcpy(a, &mxb_audios[video_audio_connect[mxb->cur_input]], sizeof(struct v4l2_audio));
907
908 return 0;
909 }
910 case VIDIOC_S_AUDIO:
911 {
912 struct v4l2_audio *a = arg;
913 DEB_D(("VIDIOC_S_AUDIO %d.\n",a->index));
914 return 0;
915 }
916 default:
917 /*
918 DEB2(printk("does not handle this ioctl.\n"));
919 */
920 return -ENOIOCTLCMD;
921 }
922 return 0;
923 }
924
925 static int std_callback(struct saa7146_dev* dev, struct saa7146_standard *std)
926 {
927 struct mxb* mxb = (struct mxb*)dev->ext_priv;
928 int zero = 0;
929 int one = 1;
930
931 if(V4L2_STD_PAL_I == std->id ) {
932 DEB_D(("VIDIOC_S_STD: setting mxb for PAL_I.\n"));
933 /* set the 7146 gpio register -- I don't know what this does exactly */
934 saa7146_write(dev, GPIO_CTRL, 0x00404050);
935 /* unset the 7111 gpio register -- I don't know what this does exactly */
936 mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_GPIO, &zero);
937 } else {
938 DEB_D(("VIDIOC_S_STD: setting mxb for PAL/NTSC/SECAM.\n"));
939 /* set the 7146 gpio register -- I don't know what this does exactly */
940 saa7146_write(dev, GPIO_CTRL, 0x00404050);
941 /* set the 7111 gpio register -- I don't know what this does exactly */
942 mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_GPIO, &one);
943 }
944 return 0;
945 }
946
947 static struct saa7146_standard standard[] = {
948 {
949 .name = "PAL-BG", .id = V4L2_STD_PAL_BG,
950 .v_offset = 0x17, .v_field = 288,
951 .h_offset = 0x14, .h_pixels = 680,
952 .v_max_out = 576, .h_max_out = 768,
953 }, {
954 .name = "PAL-I", .id = V4L2_STD_PAL_I,
955 .v_offset = 0x17, .v_field = 288,
956 .h_offset = 0x14, .h_pixels = 680,
957 .v_max_out = 576, .h_max_out = 768,
958 }, {
959 .name = "NTSC", .id = V4L2_STD_NTSC,
960 .v_offset = 0x16, .v_field = 240,
961 .h_offset = 0x06, .h_pixels = 708,
962 .v_max_out = 480, .h_max_out = 640,
963 }, {
964 .name = "SECAM", .id = V4L2_STD_SECAM,
965 .v_offset = 0x14, .v_field = 288,
966 .h_offset = 0x14, .h_pixels = 720,
967 .v_max_out = 576, .h_max_out = 768,
968 }
969 };
970
971 static struct saa7146_pci_extension_data mxb = {
972 .ext_priv = "Multimedia eXtension Board",
973 .ext = &extension,
974 };
975
976 static struct pci_device_id pci_tbl[] = {
977 {
978 .vendor = PCI_VENDOR_ID_PHILIPS,
979 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
980 .subvendor = 0x0000,
981 .subdevice = 0x0000,
982 .driver_data = (unsigned long)&mxb,
983 }, {
984 .vendor = 0,
985 }
986 };
987
988 MODULE_DEVICE_TABLE(pci, pci_tbl);
989
990 static struct saa7146_ext_vv vv_data = {
991 .inputs = MXB_INPUTS,
992 .capabilities = V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE,
993 .stds = &standard[0],
994 .num_stds = sizeof(standard)/sizeof(struct saa7146_standard),
995 .std_callback = &std_callback,
996 .ioctls = &ioctls[0],
997 .ioctl = mxb_ioctl,
998 };
999
1000 static struct saa7146_extension extension = {
1001 .name = MXB_IDENTIFIER,
1002 .flags = SAA7146_USE_I2C_IRQ,
1003
1004 .pci_tbl = &pci_tbl[0],
1005 .module = THIS_MODULE,
1006
1007 .probe = mxb_probe,
1008 .attach = mxb_attach,
1009 .detach = mxb_detach,
1010
1011 .irq_mask = 0,
1012 .irq_func = NULL,
1013 };
1014
1015 static int __init mxb_init_module(void)
1016 {
1017 if( 0 != saa7146_register_extension(&extension)) {
1018 DEB_S(("failed to register extension.\n"));
1019 return -ENODEV;
1020 }
1021
1022 return 0;
1023 }
1024
1025 static void __exit mxb_cleanup_module(void)
1026 {
1027 saa7146_unregister_extension(&extension);
1028 }
1029
1030 module_init(mxb_init_module);
1031 module_exit(mxb_cleanup_module);
1032
1033 MODULE_DESCRIPTION("video4linux-2 driver for the Siemens-Nixdorf 'Multimedia eXtension board'");
1034 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
1035 MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror