1 /*
2 hexium_orion.c - v4l2 driver for the Hexium Orion frame grabber cards
3
4 Visit http://www.mihu.de/linux/saa7146/ and follow the link
5 to "hexium" for further details about this card.
6
7 Copyright (C) 2003 Michael Hunold <michael@mihu.de>
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
28 static int debug = 0;
29 module_param(debug, int, 0);
30 MODULE_PARM_DESC(debug, "debug verbosity");
31
32 /* global variables */
33 static int hexium_num = 0;
34
35 #define HEXIUM_HV_PCI6_ORION 1
36 #define HEXIUM_ORION_1SVHS_3BNC 2
37 #define HEXIUM_ORION_4BNC 3
38
39 #define HEXIUM_INPUTS 9
40 static struct v4l2_input hexium_inputs[HEXIUM_INPUTS] = {
41 { 0, "CVBS 1", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
42 { 1, "CVBS 2", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
43 { 2, "CVBS 3", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
44 { 3, "CVBS 4", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
45 { 4, "CVBS 5", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
46 { 5, "CVBS 6", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
47 { 6, "Y/C 1", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
48 { 7, "Y/C 2", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
49 { 8, "Y/C 3", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
50 };
51
52 #define HEXIUM_AUDIOS 0
53
54 struct hexium_data
55 {
56 s8 adr;
57 u8 byte;
58 };
59
60 static struct saa7146_extension_ioctls ioctls[] = {
61 { VIDIOC_G_INPUT, SAA7146_EXCLUSIVE },
62 { VIDIOC_S_INPUT, SAA7146_EXCLUSIVE },
63 { VIDIOC_ENUMINPUT, SAA7146_EXCLUSIVE },
64 { VIDIOC_S_STD, SAA7146_AFTER },
65 { 0, 0 }
66 };
67
68 struct hexium
69 {
70 int type;
71 struct video_device *video_dev;
72 struct i2c_adapter i2c_adapter;
73
74 int cur_input; /* current input */
75 };
76
77 /* Philips SAA7110 decoder default registers */
78 static u8 hexium_saa7110[53]={
79 /*00*/ 0x4C,0x3C,0x0D,0xEF,0xBD,0xF0,0x00,0x00,
80 /*08*/ 0xF8,0xF8,0x60,0x60,0x40,0x86,0x18,0x90,
81 /*10*/ 0x00,0x2C,0x40,0x46,0x42,0x1A,0xFF,0xDA,
82 /*18*/ 0xF0,0x8B,0x00,0x00,0x00,0x00,0x00,0x00,
83 /*20*/ 0xD9,0x17,0x40,0x41,0x80,0x41,0x80,0x4F,
84 /*28*/ 0xFE,0x01,0x0F,0x0F,0x03,0x01,0x81,0x03,
85 /*30*/ 0x44,0x75,0x01,0x8C,0x03
86 };
87
88 static struct {
89 struct hexium_data data[8];
90 } hexium_input_select[] = {
91 {
92 { /* cvbs 1 */
93 { 0x06, 0x00 },
94 { 0x20, 0xD9 },
95 { 0x21, 0x17 }, // 0x16,
96 { 0x22, 0x40 },
97 { 0x2C, 0x03 },
98 { 0x30, 0x44 },
99 { 0x31, 0x75 }, // ??
100 { 0x21, 0x16 }, // 0x03,
101 }
102 }, {
103 { /* cvbs 2 */
104 { 0x06, 0x00 },
105 { 0x20, 0x78 },
106 { 0x21, 0x07 }, // 0x03,
107 { 0x22, 0xD2 },
108 { 0x2C, 0x83 },
109 { 0x30, 0x60 },
110 { 0x31, 0xB5 }, // ?
111 { 0x21, 0x03 },
112 }
113 }, {
114 { /* cvbs 3 */
115 { 0x06, 0x00 },
116 { 0x20, 0xBA },
117 { 0x21, 0x07 }, // 0x05,
118 { 0x22, 0x91 },
119 { 0x2C, 0x03 },
120 { 0x30, 0x60 },
121 { 0x31, 0xB5 }, // ??
122 { 0x21, 0x05 }, // 0x03,
123 }
124 }, {
125 { /* cvbs 4 */
126 { 0x06, 0x00 },
127 { 0x20, 0xD8 },
128 { 0x21, 0x17 }, // 0x16,
129 { 0x22, 0x40 },
130 { 0x2C, 0x03 },
131 { 0x30, 0x44 },
132 { 0x31, 0x75 }, // ??
133 { 0x21, 0x16 }, // 0x03,
134 }
135 }, {
136 { /* cvbs 5 */
137 { 0x06, 0x00 },
138 { 0x20, 0xB8 },
139 { 0x21, 0x07 }, // 0x05,
140 { 0x22, 0x91 },
141 { 0x2C, 0x03 },
142 { 0x30, 0x60 },
143 { 0x31, 0xB5 }, // ??
144 { 0x21, 0x05 }, // 0x03,
145 }
146 }, {
147 { /* cvbs 6 */
148 { 0x06, 0x00 },
149 { 0x20, 0x7C },
150 { 0x21, 0x07 }, // 0x03
151 { 0x22, 0xD2 },
152 { 0x2C, 0x83 },
153 { 0x30, 0x60 },
154 { 0x31, 0xB5 }, // ??
155 { 0x21, 0x03 },
156 }
157 }, {
158 { /* y/c 1 */
159 { 0x06, 0x80 },
160 { 0x20, 0x59 },
161 { 0x21, 0x17 },
162 { 0x22, 0x42 },
163 { 0x2C, 0xA3 },
164 { 0x30, 0x44 },
165 { 0x31, 0x75 },
166 { 0x21, 0x12 },
167 }
168 }, {
169 { /* y/c 2 */
170 { 0x06, 0x80 },
171 { 0x20, 0x9A },
172 { 0x21, 0x17 },
173 { 0x22, 0xB1 },
174 { 0x2C, 0x13 },
175 { 0x30, 0x60 },
176 { 0x31, 0xB5 },
177 { 0x21, 0x14 },
178 }
179 }, {
180 { /* y/c 3 */
181 { 0x06, 0x80 },
182 { 0x20, 0x3C },
183 { 0x21, 0x27 },
184 { 0x22, 0xC1 },
185 { 0x2C, 0x23 },
186 { 0x30, 0x44 },
187 { 0x31, 0x75 },
188 { 0x21, 0x21 },
189 }
190 }
191 };
192
193 static struct saa7146_standard hexium_standards[] = {
194 {
195 .name = "PAL", .id = V4L2_STD_PAL,
196 .v_offset = 16, .v_field = 288,
197 .h_offset = 1, .h_pixels = 680,
198 .v_max_out = 576, .h_max_out = 768,
199 }, {
200 .name = "NTSC", .id = V4L2_STD_NTSC,
201 .v_offset = 16, .v_field = 240,
202 .h_offset = 1, .h_pixels = 640,
203 .v_max_out = 480, .h_max_out = 640,
204 }, {
205 .name = "SECAM", .id = V4L2_STD_SECAM,
206 .v_offset = 16, .v_field = 288,
207 .h_offset = 1, .h_pixels = 720,
208 .v_max_out = 576, .h_max_out = 768,
209 }
210 };
211
212 /* this is only called for old HV-PCI6/Orion cards
213 without eeprom */
214 static int hexium_probe(struct saa7146_dev *dev)
215 {
216 struct hexium *hexium = NULL;
217 union i2c_smbus_data data;
218 int err = 0;
219
220 DEB_EE((".\n"));
221
222 /* there are no hexium orion cards with revision 0 saa7146s */
223 if (0 == dev->revision) {
224 return -EFAULT;
225 }
226
227 hexium = (struct hexium *) kmalloc(sizeof(struct hexium), GFP_KERNEL);
228 if (NULL == hexium) {
229 printk("hexium_orion: hexium_probe: not enough kernel memory.\n");
230 return -ENOMEM;
231 }
232 memset(hexium, 0x0, sizeof(struct hexium));
233
234 /* enable i2c-port pins */
235 saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26));
236
237 saa7146_write(dev, DD1_INIT, 0x01000100);
238 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
239 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
240
241 hexium->i2c_adapter = (struct i2c_adapter) {
242 .class = I2C_CLASS_TV_ANALOG,
243 .name = "hexium orion",
244 };
245 saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
246 if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
247 DEB_S(("cannot register i2c-device. skipping.\n"));
248 kfree(hexium);
249 return -EFAULT;
250 }
251
252 /* set SAA7110 control GPIO 0 */
253 saa7146_setgpio(dev, 0, SAA7146_GPIO_OUTHI);
254 /* set HWControl GPIO number 2 */
255 saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI);
256
257 mdelay(10);
258
259 /* detect newer Hexium Orion cards by subsystem ids */
260 if (0x17c8 == dev->pci->subsystem_vendor && 0x0101 == dev->pci->subsystem_device) {
261 printk("hexium_orion: device is a Hexium Orion w/ 1 SVHS + 3 BNC inputs.\n");
262 /* we store the pointer in our private data field */
263 dev->ext_priv = hexium;
264 hexium->type = HEXIUM_ORION_1SVHS_3BNC;
265 return 0;
266 }
267
268 if (0x17c8 == dev->pci->subsystem_vendor && 0x2101 == dev->pci->subsystem_device) {
269 printk("hexium_orion: device is a Hexium Orion w/ 4 BNC inputs.\n");
270 /* we store the pointer in our private data field */
271 dev->ext_priv = hexium;
272 hexium->type = HEXIUM_ORION_4BNC;
273 return 0;
274 }
275
276 /* check if this is an old hexium Orion card by looking at
277 a saa7110 at address 0x4e */
278 if (0 == (err = i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_READ, 0x00, I2C_SMBUS_BYTE_DATA, &data))) {
279 printk("hexium_orion: device is a Hexium HV-PCI6/Orion (old).\n");
280 /* we store the pointer in our private data field */
281 dev->ext_priv = hexium;
282 hexium->type = HEXIUM_HV_PCI6_ORION;
283 return 0;
284 }
285
286 i2c_del_adapter(&hexium->i2c_adapter);
287 kfree(hexium);
288 return -EFAULT;
289 }
290
291 /* bring hardware to a sane state. this has to be done, just in case someone
292 wants to capture from this device before it has been properly initialized.
293 the capture engine would badly fail, because no valid signal arrives on the
294 saa7146, thus leading to timeouts and stuff. */
295 static int hexium_init_done(struct saa7146_dev *dev)
296 {
297 struct hexium *hexium = (struct hexium *) dev->ext_priv;
298 union i2c_smbus_data data;
299 int i = 0;
300
301 DEB_D(("hexium_init_done called.\n"));
302
303 /* initialize the helper ics to useful values */
304 for (i = 0; i < sizeof(hexium_saa7110); i++) {
305 data.byte = hexium_saa7110[i];
306 if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_WRITE, i, I2C_SMBUS_BYTE_DATA, &data)) {
307 printk("hexium_orion: failed for address 0x%02x\n", i);
308 }
309 }
310
311 return 0;
312 }
313
314 static int hexium_set_input(struct hexium *hexium, int input)
315 {
316 union i2c_smbus_data data;
317 int i = 0;
318
319 DEB_D((".\n"));
320
321 for (i = 0; i < 8; i++) {
322 int adr = hexium_input_select[input].data[i].adr;
323 data.byte = hexium_input_select[input].data[i].byte;
324 if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_WRITE, adr, I2C_SMBUS_BYTE_DATA, &data)) {
325 return -1;
326 }
327 printk("%d: 0x%02x => 0x%02x\n",input, adr,data.byte);
328 }
329
330 return 0;
331 }
332
333 static struct saa7146_ext_vv vv_data;
334
335 /* this function only gets called when the probing was successful */
336 static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
337 {
338 struct hexium *hexium = (struct hexium *) dev->ext_priv;
339
340 DEB_EE((".\n"));
341
342 saa7146_vv_init(dev, &vv_data);
343 if (0 != saa7146_register_device(&hexium->video_dev, dev, "hexium orion", VFL_TYPE_GRABBER)) {
344 printk("hexium_orion: cannot register capture v4l2 device. skipping.\n");
345 return -1;
346 }
347
348 printk("hexium_orion: found 'hexium orion' frame grabber-%d.\n", hexium_num);
349 hexium_num++;
350
351 /* the rest */
352 hexium->cur_input = 0;
353 hexium_init_done(dev);
354
355 return 0;
356 }
357
358 static int hexium_detach(struct saa7146_dev *dev)
359 {
360 struct hexium *hexium = (struct hexium *) dev->ext_priv;
361
362 DEB_EE(("dev:%p\n", dev));
363
364 saa7146_unregister_device(&hexium->video_dev, dev);
365 saa7146_vv_release(dev);
366
367 hexium_num--;
368
369 i2c_del_adapter(&hexium->i2c_adapter);
370 kfree(hexium);
371 return 0;
372 }
373
374 static int hexium_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
375 {
376 struct saa7146_dev *dev = fh->dev;
377 struct hexium *hexium = (struct hexium *) dev->ext_priv;
378 /*
379 struct saa7146_vv *vv = dev->vv_data;
380 */
381 switch (cmd) {
382 case VIDIOC_ENUMINPUT:
383 {
384 struct v4l2_input *i = arg;
385 DEB_EE(("VIDIOC_ENUMINPUT %d.\n", i->index));
386
387 if (i->index < 0 || i->index >= HEXIUM_INPUTS) {
388 return -EINVAL;
389 }
390
391 memcpy(i, &hexium_inputs[i->index], sizeof(struct v4l2_input));
392
393 DEB_D(("v4l2_ioctl: VIDIOC_ENUMINPUT %d.\n", i->index));
394 return 0;
395 }
396 case VIDIOC_G_INPUT:
397 {
398 int *input = (int *) arg;
399 *input = hexium->cur_input;
400
401 DEB_D(("VIDIOC_G_INPUT: %d\n", *input));
402 return 0;
403 }
404 case VIDIOC_S_INPUT:
405 {
406 int input = *(int *) arg;
407
408 if (input < 0 || input >= HEXIUM_INPUTS) {
409 return -EINVAL;
410 }
411
412 hexium->cur_input = input;
413 hexium_set_input(hexium, input);
414
415 return 0;
416 }
417 default:
418 /*
419 DEB_D(("hexium_ioctl() does not handle this ioctl.\n"));
420 */
421 return -ENOIOCTLCMD;
422 }
423 return 0;
424 }
425
426 static int std_callback(struct saa7146_dev *dev, struct saa7146_standard *std)
427 {
428 return 0;
429 }
430
431 static struct saa7146_extension extension;
432
433 static struct saa7146_pci_extension_data hexium_hv_pci6 = {
434 .ext_priv = "Hexium HV-PCI6 / Orion",
435 .ext = &extension,
436 };
437
438 static struct saa7146_pci_extension_data hexium_orion_1svhs_3bnc = {
439 .ext_priv = "Hexium HV-PCI6 / Orion (1 SVHS/3 BNC)",
440 .ext = &extension,
441 };
442
443 static struct saa7146_pci_extension_data hexium_orion_4bnc = {
444 .ext_priv = "Hexium HV-PCI6 / Orion (4 BNC)",
445 .ext = &extension,
446 };
447
448 static struct pci_device_id pci_tbl[] = {
449 {
450 .vendor = PCI_VENDOR_ID_PHILIPS,
451 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
452 .subvendor = 0x0000,
453 .subdevice = 0x0000,
454 .driver_data = (unsigned long) &hexium_hv_pci6,
455 },
456 {
457 .vendor = PCI_VENDOR_ID_PHILIPS,
458 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
459 .subvendor = 0x17c8,
460 .subdevice = 0x0101,
461 .driver_data = (unsigned long) &hexium_orion_1svhs_3bnc,
462 },
463 {
464 .vendor = PCI_VENDOR_ID_PHILIPS,
465 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
466 .subvendor = 0x17c8,
467 .subdevice = 0x2101,
468 .driver_data = (unsigned long) &hexium_orion_4bnc,
469 },
470 {
471 .vendor = 0,
472 }
473 };
474
475 MODULE_DEVICE_TABLE(pci, pci_tbl);
476
477 static struct saa7146_ext_vv vv_data = {
478 .inputs = HEXIUM_INPUTS,
479 .capabilities = 0,
480 .stds = &hexium_standards[0],
481 .num_stds = sizeof(hexium_standards) / sizeof(struct saa7146_standard),
482 .std_callback = &std_callback,
483 .ioctls = &ioctls[0],
484 .ioctl = hexium_ioctl,
485 };
486
487 static struct saa7146_extension extension = {
488 .name = "hexium HV-PCI6/Orion",
489 .flags = 0, // SAA7146_USE_I2C_IRQ,
490
491 .pci_tbl = &pci_tbl[0],
492 .module = THIS_MODULE,
493
494 .probe = hexium_probe,
495 .attach = hexium_attach,
496 .detach = hexium_detach,
497
498 .irq_mask = 0,
499 .irq_func = NULL,
500 };
501
502 static int __init hexium_init_module(void)
503 {
504 if (0 != saa7146_register_extension(&extension)) {
505 DEB_S(("failed to register extension.\n"));
506 return -ENODEV;
507 }
508
509 return 0;
510 }
511
512 static void __exit hexium_cleanup_module(void)
513 {
514 saa7146_unregister_extension(&extension);
515 }
516
517 module_init(hexium_init_module);
518 module_exit(hexium_cleanup_module);
519
520 MODULE_DESCRIPTION("video4linux-2 driver for Hexium Orion frame grabber cards");
521 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
522 MODULE_LICENSE("GPL");
523
|
This page was automatically generated by the
LXR engine.
|