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 = kzalloc(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
233 /* enable i2c-port pins */
234 saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26));
235
236 saa7146_write(dev, DD1_INIT, 0x01000100);
237 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
238 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
239
240 hexium->i2c_adapter = (struct i2c_adapter) {
241 .class = I2C_CLASS_TV_ANALOG,
242 .name = "hexium orion",
243 };
244 saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
245 if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
246 DEB_S(("cannot register i2c-device. skipping.\n"));
247 kfree(hexium);
248 return -EFAULT;
249 }
250
251 /* set SAA7110 control GPIO 0 */
252 saa7146_setgpio(dev, 0, SAA7146_GPIO_OUTHI);
253 /* set HWControl GPIO number 2 */
254 saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI);
255
256 mdelay(10);
257
258 /* detect newer Hexium Orion cards by subsystem ids */
259 if (0x17c8 == dev->pci->subsystem_vendor && 0x0101 == dev->pci->subsystem_device) {
260 printk("hexium_orion: device is a Hexium Orion w/ 1 SVHS + 3 BNC inputs.\n");
261 /* we store the pointer in our private data field */
262 dev->ext_priv = hexium;
263 hexium->type = HEXIUM_ORION_1SVHS_3BNC;
264 return 0;
265 }
266
267 if (0x17c8 == dev->pci->subsystem_vendor && 0x2101 == dev->pci->subsystem_device) {
268 printk("hexium_orion: device is a Hexium Orion w/ 4 BNC inputs.\n");
269 /* we store the pointer in our private data field */
270 dev->ext_priv = hexium;
271 hexium->type = HEXIUM_ORION_4BNC;
272 return 0;
273 }
274
275 /* check if this is an old hexium Orion card by looking at
276 a saa7110 at address 0x4e */
277 if (0 == (err = i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_READ, 0x00, I2C_SMBUS_BYTE_DATA, &data))) {
278 printk("hexium_orion: device is a Hexium HV-PCI6/Orion (old).\n");
279 /* we store the pointer in our private data field */
280 dev->ext_priv = hexium;
281 hexium->type = HEXIUM_HV_PCI6_ORION;
282 return 0;
283 }
284
285 i2c_del_adapter(&hexium->i2c_adapter);
286 kfree(hexium);
287 return -EFAULT;
288 }
289
290 /* bring hardware to a sane state. this has to be done, just in case someone
291 wants to capture from this device before it has been properly initialized.
292 the capture engine would badly fail, because no valid signal arrives on the
293 saa7146, thus leading to timeouts and stuff. */
294 static int hexium_init_done(struct saa7146_dev *dev)
295 {
296 struct hexium *hexium = (struct hexium *) dev->ext_priv;
297 union i2c_smbus_data data;
298 int i = 0;
299
300 DEB_D(("hexium_init_done called.\n"));
301
302 /* initialize the helper ics to useful values */
303 for (i = 0; i < sizeof(hexium_saa7110); i++) {
304 data.byte = hexium_saa7110[i];
305 if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_WRITE, i, I2C_SMBUS_BYTE_DATA, &data)) {
306 printk("hexium_orion: failed for address 0x%02x\n", i);
307 }
308 }
309
310 return 0;
311 }
312
313 static int hexium_set_input(struct hexium *hexium, int input)
314 {
315 union i2c_smbus_data data;
316 int i = 0;
317
318 DEB_D((".\n"));
319
320 for (i = 0; i < 8; i++) {
321 int adr = hexium_input_select[input].data[i].adr;
322 data.byte = hexium_input_select[input].data[i].byte;
323 if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_WRITE, adr, I2C_SMBUS_BYTE_DATA, &data)) {
324 return -1;
325 }
326 printk("%d: 0x%02x => 0x%02x\n",input, adr,data.byte);
327 }
328
329 return 0;
330 }
331
332 static struct saa7146_ext_vv vv_data;
333
334 /* this function only gets called when the probing was successful */
335 static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
336 {
337 struct hexium *hexium = (struct hexium *) dev->ext_priv;
338
339 DEB_EE((".\n"));
340
341 saa7146_vv_init(dev, &vv_data);
342 if (0 != saa7146_register_device(&hexium->video_dev, dev, "hexium orion", VFL_TYPE_GRABBER)) {
343 printk("hexium_orion: cannot register capture v4l2 device. skipping.\n");
344 return -1;
345 }
346
347 printk("hexium_orion: found 'hexium orion' frame grabber-%d.\n", hexium_num);
348 hexium_num++;
349
350 /* the rest */
351 hexium->cur_input = 0;
352 hexium_init_done(dev);
353
354 return 0;
355 }
356
357 static int hexium_detach(struct saa7146_dev *dev)
358 {
359 struct hexium *hexium = (struct hexium *) dev->ext_priv;
360
361 DEB_EE(("dev:%p\n", dev));
362
363 saa7146_unregister_device(&hexium->video_dev, dev);
364 saa7146_vv_release(dev);
365
366 hexium_num--;
367
368 i2c_del_adapter(&hexium->i2c_adapter);
369 kfree(hexium);
370 return 0;
371 }
372
373 static int hexium_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
374 {
375 struct saa7146_dev *dev = fh->dev;
376 struct hexium *hexium = (struct hexium *) dev->ext_priv;
377 /*
378 struct saa7146_vv *vv = dev->vv_data;
379 */
380 switch (cmd) {
381 case VIDIOC_ENUMINPUT:
382 {
383 struct v4l2_input *i = arg;
384 DEB_EE(("VIDIOC_ENUMINPUT %d.\n", i->index));
385
386 if (i->index < 0 || i->index >= HEXIUM_INPUTS) {
387 return -EINVAL;
388 }
389
390 memcpy(i, &hexium_inputs[i->index], sizeof(struct v4l2_input));
391
392 DEB_D(("v4l2_ioctl: VIDIOC_ENUMINPUT %d.\n", i->index));
393 return 0;
394 }
395 case VIDIOC_G_INPUT:
396 {
397 int *input = (int *) arg;
398 *input = hexium->cur_input;
399
400 DEB_D(("VIDIOC_G_INPUT: %d\n", *input));
401 return 0;
402 }
403 case VIDIOC_S_INPUT:
404 {
405 int input = *(int *) arg;
406
407 if (input < 0 || input >= HEXIUM_INPUTS) {
408 return -EINVAL;
409 }
410
411 hexium->cur_input = input;
412 hexium_set_input(hexium, input);
413
414 return 0;
415 }
416 default:
417 /*
418 DEB_D(("hexium_ioctl() does not handle this ioctl.\n"));
419 */
420 return -ENOIOCTLCMD;
421 }
422 return 0;
423 }
424
425 static int std_callback(struct saa7146_dev *dev, struct saa7146_standard *std)
426 {
427 return 0;
428 }
429
430 static struct saa7146_extension extension;
431
432 static struct saa7146_pci_extension_data hexium_hv_pci6 = {
433 .ext_priv = "Hexium HV-PCI6 / Orion",
434 .ext = &extension,
435 };
436
437 static struct saa7146_pci_extension_data hexium_orion_1svhs_3bnc = {
438 .ext_priv = "Hexium HV-PCI6 / Orion (1 SVHS/3 BNC)",
439 .ext = &extension,
440 };
441
442 static struct saa7146_pci_extension_data hexium_orion_4bnc = {
443 .ext_priv = "Hexium HV-PCI6 / Orion (4 BNC)",
444 .ext = &extension,
445 };
446
447 static struct pci_device_id pci_tbl[] = {
448 {
449 .vendor = PCI_VENDOR_ID_PHILIPS,
450 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
451 .subvendor = 0x0000,
452 .subdevice = 0x0000,
453 .driver_data = (unsigned long) &hexium_hv_pci6,
454 },
455 {
456 .vendor = PCI_VENDOR_ID_PHILIPS,
457 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
458 .subvendor = 0x17c8,
459 .subdevice = 0x0101,
460 .driver_data = (unsigned long) &hexium_orion_1svhs_3bnc,
461 },
462 {
463 .vendor = PCI_VENDOR_ID_PHILIPS,
464 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
465 .subvendor = 0x17c8,
466 .subdevice = 0x2101,
467 .driver_data = (unsigned long) &hexium_orion_4bnc,
468 },
469 {
470 .vendor = 0,
471 }
472 };
473
474 MODULE_DEVICE_TABLE(pci, pci_tbl);
475
476 static struct saa7146_ext_vv vv_data = {
477 .inputs = HEXIUM_INPUTS,
478 .capabilities = 0,
479 .stds = &hexium_standards[0],
480 .num_stds = sizeof(hexium_standards) / sizeof(struct saa7146_standard),
481 .std_callback = &std_callback,
482 .ioctls = &ioctls[0],
483 .ioctl = hexium_ioctl,
484 };
485
486 static struct saa7146_extension extension = {
487 .name = "hexium HV-PCI6 Orion",
488 .flags = 0, // SAA7146_USE_I2C_IRQ,
489
490 .pci_tbl = &pci_tbl[0],
491 .module = THIS_MODULE,
492
493 .probe = hexium_probe,
494 .attach = hexium_attach,
495 .detach = hexium_detach,
496
497 .irq_mask = 0,
498 .irq_func = NULL,
499 };
500
501 static int __init hexium_init_module(void)
502 {
503 if (0 != saa7146_register_extension(&extension)) {
504 DEB_S(("failed to register extension.\n"));
505 return -ENODEV;
506 }
507
508 return 0;
509 }
510
511 static void __exit hexium_cleanup_module(void)
512 {
513 saa7146_unregister_extension(&extension);
514 }
515
516 module_init(hexium_init_module);
517 module_exit(hexium_cleanup_module);
518
519 MODULE_DESCRIPTION("video4linux-2 driver for Hexium Orion frame grabber cards");
520 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
521 MODULE_LICENSE("GPL");
522
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.