?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] W1: w1_netlink: New init/fini netlink callbacks.
[linux-2.6/verdex.git] / drivers / media / video / saa7134 / saa7134-core.c
blob1dbe61755e9fc9e70693c99c8225d681ec37e00d
1 /*
2 * $Id: saa7134-core.c,v 1.39 2005/07/05 17:37:35 nsh Exp $
3 *
4 * device driver for philips saa7134 based TV cards
5 * driver core
6 *
7 * (c) 2001-03 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
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 #include <linux/config.h>
25 #include <linux/init.h>
26 #include <linux/list.h>
27 #include <linux/module.h>
28 #include <linux/moduleparam.h>
29 #include <linux/kernel.h>
30 #include <linux/slab.h>
31 #include <linux/kmod.h>
32 #include <linux/sound.h>
33 #include <linux/interrupt.h>
34 #include <linux/delay.h>
35
36 #include "saa7134-reg.h"
37 #include "saa7134.h"
38
39 MODULE_DESCRIPTION("v4l2 driver module for saa7130/34 based TV cards");
40 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
41 MODULE_LICENSE("GPL");
42
43 /* ------------------------------------------------------------------ */
44
45 static unsigned int irq_debug = 0;
46 module_param(irq_debug, int, 0644);
47 MODULE_PARM_DESC(irq_debug,"enable debug messages [IRQ handler]");
48
49 static unsigned int core_debug = 0;
50 module_param(core_debug, int, 0644);
51 MODULE_PARM_DESC(core_debug,"enable debug messages [core]");
52
53 static unsigned int gpio_tracking = 0;
54 module_param(gpio_tracking, int, 0644);
55 MODULE_PARM_DESC(gpio_tracking,"enable debug messages [gpio]");
56
57 static unsigned int oss = 0;
58 module_param(oss, int, 0444);
59 MODULE_PARM_DESC(oss,"register oss devices (default: no)");
60
61 static unsigned int latency = UNSET;
62 module_param(latency, int, 0444);
63 MODULE_PARM_DESC(latency,"pci latency timer");
64
65 static unsigned int video_nr[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
66 static unsigned int vbi_nr[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
67 static unsigned int radio_nr[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
68 static unsigned int dsp_nr[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
69 static unsigned int mixer_nr[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
70 static unsigned int tuner[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
71 static unsigned int card[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
72
73 module_param_array(video_nr, int, NULL, 0444);
74 module_param_array(vbi_nr, int, NULL, 0444);
75 module_param_array(radio_nr, int, NULL, 0444);
76 module_param_array(dsp_nr, int, NULL, 0444);
77 module_param_array(mixer_nr, int, NULL, 0444);
78 module_param_array(tuner, int, NULL, 0444);
79 module_param_array(card, int, NULL, 0444);
80
81 MODULE_PARM_DESC(video_nr, "video device number");
82 MODULE_PARM_DESC(vbi_nr, "vbi device number");
83 MODULE_PARM_DESC(radio_nr, "radio device number");
84 MODULE_PARM_DESC(dsp_nr, "oss dsp device number");
85 MODULE_PARM_DESC(mixer_nr, "oss mixer device number");
86 MODULE_PARM_DESC(tuner, "tuner type");
87 MODULE_PARM_DESC(card, "card type");
88
89 static DECLARE_MUTEX(devlist_lock);
90 LIST_HEAD(saa7134_devlist);
91 static LIST_HEAD(mops_list);
92 static unsigned int saa7134_devcount;
93
94 #define dprintk(fmt, arg...) if (core_debug) \
95 printk(KERN_DEBUG "%s/core: " fmt, dev->name , ## arg)
96
97 /* ------------------------------------------------------------------ */
98 /* debug help functions */
99
100 static const char *v4l1_ioctls[] = {
101 "0", "GCAP", "GCHAN", "SCHAN", "GTUNER", "STUNER", "GPICT", "SPICT",
102 "CCAPTURE", "GWIN", "SWIN", "GFBUF", "SFBUF", "KEY", "GFREQ",
103 "SFREQ", "GAUDIO", "SAUDIO", "SYNC", "MCAPTURE", "GMBUF", "GUNIT",
104 "GCAPTURE", "SCAPTURE", "SPLAYMODE", "SWRITEMODE", "GPLAYINFO",
105 "SMICROCODE", "GVBIFMT", "SVBIFMT" };
106 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
107
108 static const char *v4l2_ioctls[] = {
109 "QUERYCAP", "1", "ENUM_PIXFMT", "ENUM_FBUFFMT", "G_FMT", "S_FMT",
110 "G_COMP", "S_COMP", "REQBUFS", "QUERYBUF", "G_FBUF", "S_FBUF",
111 "G_WIN", "S_WIN", "PREVIEW", "QBUF", "16", "DQBUF", "STREAMON",
112 "STREAMOFF", "G_PERF", "G_PARM", "S_PARM", "G_STD", "S_STD",
113 "ENUMSTD", "ENUMINPUT", "G_CTRL", "S_CTRL", "G_TUNER", "S_TUNER",
114 "G_FREQ", "S_FREQ", "G_AUDIO", "S_AUDIO", "35", "QUERYCTRL",
115 "QUERYMENU", "G_INPUT", "S_INPUT", "ENUMCVT", "41", "42", "43",
116 "44", "45", "G_OUTPUT", "S_OUTPUT", "ENUMOUTPUT", "G_AUDOUT",
117 "S_AUDOUT", "ENUMFX", "G_EFFECT", "S_EFFECT", "G_MODULATOR",
118 "S_MODULATOR"
119 };
120 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
121
122 static const char *osspcm_ioctls[] = {
123 "RESET", "SYNC", "SPEED", "STEREO", "GETBLKSIZE", "SETFMT",
124 "CHANNELS", "?", "POST", "SUBDIVIDE", "SETFRAGMENT", "GETFMTS",
125 "GETOSPACE", "GETISPACE", "NONBLOCK", "GETCAPS", "GET/SETTRIGGER",
126 "GETIPTR", "GETOPTR", "MAPINBUF", "MAPOUTBUF", "SETSYNCRO",
127 "SETDUPLEX", "GETODELAY"
128 };
129 #define OSSPCM_IOCTLS ARRAY_SIZE(v4l2_ioctls)
130
131 void saa7134_print_ioctl(char *name, unsigned int cmd)
132 {
133 char *dir;
134
135 switch (_IOC_DIR(cmd)) {
136 case _IOC_NONE: dir = "--"; break;
137 case _IOC_READ: dir = "r-"; break;
138 case _IOC_WRITE: dir = "-w"; break;
139 case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
140 default: dir = "??"; break;
141 }
142 switch (_IOC_TYPE(cmd)) {
143 case 'v':
144 printk(KERN_DEBUG "%s: ioctl 0x%08x (v4l1, %s, VIDIOC%s)\n",
145 name, cmd, dir, (_IOC_NR(cmd) < V4L1_IOCTLS) ?
146 v4l1_ioctls[_IOC_NR(cmd)] : "???");
147 break;
148 case 'V':
149 printk(KERN_DEBUG "%s: ioctl 0x%08x (v4l2, %s, VIDIOC_%s)\n",
150 name, cmd, dir, (_IOC_NR(cmd) < V4L2_IOCTLS) ?
151 v4l2_ioctls[_IOC_NR(cmd)] : "???");
152 break;
153 case 'P':
154 printk(KERN_DEBUG "%s: ioctl 0x%08x (oss dsp, %s, SNDCTL_DSP_%s)\n",
155 name, cmd, dir, (_IOC_NR(cmd) < OSSPCM_IOCTLS) ?
156 osspcm_ioctls[_IOC_NR(cmd)] : "???");
157 break;
158 case 'M':
159 printk(KERN_DEBUG "%s: ioctl 0x%08x (oss mixer, %s, #%d)\n",
160 name, cmd, dir, _IOC_NR(cmd));
161 break;
162 default:
163 printk(KERN_DEBUG "%s: ioctl 0x%08x (???, %s, #%d)\n",
164 name, cmd, dir, _IOC_NR(cmd));
165 }
166 }
167
168 void saa7134_track_gpio(struct saa7134_dev *dev, char *msg)
169 {
170 unsigned long mode,status;
171
172 if (!gpio_tracking)
173 return;
174 /* rising SAA7134_GPIO_GPRESCAN reads the status */
175 saa_andorb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN,0);
176 saa_andorb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN,SAA7134_GPIO_GPRESCAN);
177 mode = saa_readl(SAA7134_GPIO_GPMODE0 >> 2) & 0xfffffff;
178 status = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2) & 0xfffffff;
179 printk(KERN_DEBUG
180 "%s: gpio: mode=0x%07lx in=0x%07lx out=0x%07lx [%s]\n",
181 dev->name, mode, (~mode) & status, mode & status, msg);
182 }
183
184 /* ------------------------------------------------------------------ */
185
186
187 /* ----------------------------------------------------------- */
188 /* delayed request_module */
189
190 #ifdef CONFIG_MODULES
191
192 static int need_empress;
193 static int need_dvb;
194
195 static int pending_call(struct notifier_block *self, unsigned long state,
196 void *module)
197 {
198 if (module != THIS_MODULE || state != MODULE_STATE_LIVE)
199 return NOTIFY_DONE;
200
201 if (need_empress)
202 request_module("saa7134-empress");
203 if (need_dvb)
204 request_module("saa7134-dvb");
205 return NOTIFY_DONE;
206 }
207
208 static int pending_registered;
209 static struct notifier_block pending_notifier = {
210 .notifier_call = pending_call,
211 };
212
213 static void request_module_depend(char *name, int *flag)
214 {
215 switch (THIS_MODULE->state) {
216 case MODULE_STATE_COMING:
217 if (!pending_registered) {
218 register_module_notifier(&pending_notifier);
219 pending_registered = 1;
220 }
221 *flag = 1;
222 break;
223 case MODULE_STATE_LIVE:
224 request_module(name);
225 break;
226 default:
227 /* nothing */;
228 break;
229 }
230 }
231
232 #else
233
234 #define request_module_depend(name,flag)
235
236 #endif /* CONFIG_MODULES */
237
238 /* ------------------------------------------------------------------ */
239
240 /* nr of (saa7134-)pages for the given buffer size */
241 static int saa7134_buffer_pages(int size)
242 {
243 size = PAGE_ALIGN(size);
244 size += PAGE_SIZE; /* for non-page-aligned buffers */
245 size /= 4096;
246 return size;
247 }
248
249 /* calc max # of buffers from size (must not exceed the 4MB virtual
250 * address space per DMA channel) */
251 int saa7134_buffer_count(unsigned int size, unsigned int count)
252 {
253 unsigned int maxcount;
254
255 maxcount = 1024 / saa7134_buffer_pages(size);
256 if (count > maxcount)
257 count = maxcount;
258 return count;
259 }
260
261 int saa7134_buffer_startpage(struct saa7134_buf *buf)
262 {
263 return saa7134_buffer_pages(buf->vb.bsize) * buf->vb.i;
264 }
265
266 unsigned long saa7134_buffer_base(struct saa7134_buf *buf)
267 {
268 unsigned long base;
269
270 base = saa7134_buffer_startpage(buf) * 4096;
271 base += buf->vb.dma.sglist[0].offset;
272 return base;
273 }
274
275 /* ------------------------------------------------------------------ */
276
277 int saa7134_pgtable_alloc(struct pci_dev *pci, struct saa7134_pgtable *pt)
278 {
279 __le32 *cpu;
280 dma_addr_t dma_addr;
281
282 cpu = pci_alloc_consistent(pci, SAA7134_PGTABLE_SIZE, &dma_addr);
283 if (NULL == cpu)
284 return -ENOMEM;
285 pt->size = SAA7134_PGTABLE_SIZE;
286 pt->cpu = cpu;
287 pt->dma = dma_addr;
288 return 0;
289 }
290
291 int saa7134_pgtable_build(struct pci_dev *pci, struct saa7134_pgtable *pt,
292 struct scatterlist *list, unsigned int length,
293 unsigned int startpage)
294 {
295 __le32 *ptr;
296 unsigned int i,p;
297
298 BUG_ON(NULL == pt || NULL == pt->cpu);
299
300 ptr = pt->cpu + startpage;
301 for (i = 0; i < length; i++, list++)
302 for (p = 0; p * 4096 < list->length; p++, ptr++)
303 *ptr = cpu_to_le32(sg_dma_address(list) - list->offset);
304 return 0;
305 }
306
307 void saa7134_pgtable_free(struct pci_dev *pci, struct saa7134_pgtable *pt)
308 {
309 if (NULL == pt->cpu)
310 return;
311 pci_free_consistent(pci, pt->size, pt->cpu, pt->dma);
312 pt->cpu = NULL;
313 }
314
315 /* ------------------------------------------------------------------ */
316
317 void saa7134_dma_free(struct saa7134_dev *dev,struct saa7134_buf *buf)
318 {
319 if (in_interrupt())
320 BUG();
321
322 videobuf_waiton(&buf->vb,0,0);
323 videobuf_dma_pci_unmap(dev->pci, &buf->vb.dma);
324 videobuf_dma_free(&buf->vb.dma);
325 buf->vb.state = STATE_NEEDS_INIT;
326 }
327
328 /* ------------------------------------------------------------------ */
329
330 int saa7134_buffer_queue(struct saa7134_dev *dev,
331 struct saa7134_dmaqueue *q,
332 struct saa7134_buf *buf)
333 {
334 struct saa7134_buf *next = NULL;
335
336 assert_spin_locked(&dev->slock);
337 dprintk("buffer_queue %p\n",buf);
338 if (NULL == q->curr) {
339 if (!q->need_two) {
340 q->curr = buf;
341 buf->activate(dev,buf,NULL);
342 } else if (list_empty(&q->queue)) {
343 list_add_tail(&buf->vb.queue,&q->queue);
344 buf->vb.state = STATE_QUEUED;
345 } else {
346 next = list_entry(q->queue.next,struct saa7134_buf,
347 vb.queue);
348 q->curr = buf;
349 buf->activate(dev,buf,next);
350 }
351 } else {
352 list_add_tail(&buf->vb.queue,&q->queue);
353 buf->vb.state = STATE_QUEUED;
354 }
355 return 0;
356 }
357
358 void saa7134_buffer_finish(struct saa7134_dev *dev,
359 struct saa7134_dmaqueue *q,
360 unsigned int state)
361 {
362 assert_spin_locked(&dev->slock);
363 dprintk("buffer_finish %p\n",q->curr);
364
365 /* finish current buffer */
366 q->curr->vb.state = state;
367 do_gettimeofday(&q->curr->vb.ts);
368 wake_up(&q->curr->vb.done);
369 q->curr = NULL;
370 }
371
372 void saa7134_buffer_next(struct saa7134_dev *dev,
373 struct saa7134_dmaqueue *q)
374 {
375 struct saa7134_buf *buf,*next = NULL;
376
377 assert_spin_locked(&dev->slock);
378 BUG_ON(NULL != q->curr);
379
380 if (!list_empty(&q->queue)) {
381 /* activate next one from queue */
382 buf = list_entry(q->queue.next,struct saa7134_buf,vb.queue);
383 dprintk("buffer_next %p [prev=%p/next=%p]\n",
384 buf,q->queue.prev,q->queue.next);
385 list_del(&buf->vb.queue);
386 if (!list_empty(&q->queue))
387 next = list_entry(q->queue.next,struct saa7134_buf,
388 vb.queue);
389 q->curr = buf;
390 buf->activate(dev,buf,next);
391 dprintk("buffer_next #2 prev=%p/next=%p\n",
392 q->queue.prev,q->queue.next);
393 } else {
394 /* nothing to do -- just stop DMA */
395 dprintk("buffer_next %p\n",NULL);
396 saa7134_set_dmabits(dev);
397 del_timer(&q->timeout);
398 }
399 }
400
401 void saa7134_buffer_timeout(unsigned long data)
402 {
403 struct saa7134_dmaqueue *q = (struct saa7134_dmaqueue*)data;
404 struct saa7134_dev *dev = q->dev;
405 unsigned long flags;
406
407 spin_lock_irqsave(&dev->slock,flags);
408
409 /* try to reset the hardware (SWRST) */
410 saa_writeb(SAA7134_REGION_ENABLE, 0x00);
411 saa_writeb(SAA7134_REGION_ENABLE, 0x80);
412 saa_writeb(SAA7134_REGION_ENABLE, 0x00);
413
414 /* flag current buffer as failed,
415 try to start over with the next one. */
416 if (q->curr) {
417 dprintk("timeout on %p\n",q->curr);
418 saa7134_buffer_finish(dev,q,STATE_ERROR);
419 }
420 saa7134_buffer_next(dev,q);
421 spin_unlock_irqrestore(&dev->slock,flags);
422 }
423
424 /* ------------------------------------------------------------------ */
425
426 int saa7134_set_dmabits(struct saa7134_dev *dev)
427 {
428 u32 split, task=0, ctrl=0, irq=0;
429 enum v4l2_field cap = V4L2_FIELD_ANY;
430 enum v4l2_field ov = V4L2_FIELD_ANY;
431
432 assert_spin_locked(&dev->slock);
433
434 /* video capture -- dma 0 + video task A */
435 if (dev->video_q.curr) {
436 task |= 0x01;
437 ctrl |= SAA7134_MAIN_CTRL_TE0;
438 irq |= SAA7134_IRQ1_INTE_RA0_1 |
439 SAA7134_IRQ1_INTE_RA0_0;
440 cap = dev->video_q.curr->vb.field;
441 }
442
443 /* video capture -- dma 1+2 (planar modes) */
444 if (dev->video_q.curr &&
445 dev->video_q.curr->fmt->planar) {
446 ctrl |= SAA7134_MAIN_CTRL_TE4 |
447 SAA7134_MAIN_CTRL_TE5;
448 }
449
450 /* screen overlay -- dma 0 + video task B */
451 if (dev->ovenable) {
452 task |= 0x10;
453 ctrl |= SAA7134_MAIN_CTRL_TE1;
454 ov = dev->ovfield;
455 }
456
457 /* vbi capture -- dma 0 + vbi task A+B */
458 if (dev->vbi_q.curr) {
459 task |= 0x22;
460 ctrl |= SAA7134_MAIN_CTRL_TE2 |
461 SAA7134_MAIN_CTRL_TE3;
462 irq |= SAA7134_IRQ1_INTE_RA0_7 |
463 SAA7134_IRQ1_INTE_RA0_6 |
464 SAA7134_IRQ1_INTE_RA0_5 |
465 SAA7134_IRQ1_INTE_RA0_4;
466 }
467
468 /* audio capture -- dma 3 */
469 if (dev->oss.dma_running) {
470 ctrl |= SAA7134_MAIN_CTRL_TE6;
471 irq |= SAA7134_IRQ1_INTE_RA3_1 |
472 SAA7134_IRQ1_INTE_RA3_0;
473 }
474
475 /* TS capture -- dma 5 */
476 if (dev->ts_q.curr) {
477 ctrl |= SAA7134_MAIN_CTRL_TE5;
478 irq |= SAA7134_IRQ1_INTE_RA2_3 |
479 SAA7134_IRQ1_INTE_RA2_2 |
480 SAA7134_IRQ1_INTE_RA2_1 |
481 SAA7134_IRQ1_INTE_RA2_0;
482 }
483
484 /* set task conditions + field handling */
485 if (V4L2_FIELD_HAS_BOTH(cap) || V4L2_FIELD_HAS_BOTH(ov) || cap == ov) {
486 /* default config -- use full frames */
487 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_A), 0x0d);
488 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_B), 0x0d);
489 saa_writeb(SAA7134_FIELD_HANDLING(TASK_A), 0x02);
490 saa_writeb(SAA7134_FIELD_HANDLING(TASK_B), 0x02);
491 split = 0;
492 } else {
493 /* split fields between tasks */
494 if (V4L2_FIELD_TOP == cap) {
495 /* odd A, even B, repeat */
496 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_A), 0x0d);
497 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_B), 0x0e);
498 } else {
499 /* odd B, even A, repeat */
500 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_A), 0x0e);
501 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_B), 0x0d);
502 }
503 saa_writeb(SAA7134_FIELD_HANDLING(TASK_A), 0x01);
504 saa_writeb(SAA7134_FIELD_HANDLING(TASK_B), 0x01);
505 split = 1;
506 }
507
508 /* irqs */
509 saa_writeb(SAA7134_REGION_ENABLE, task);
510 saa_writel(SAA7134_IRQ1, irq);
511 saa_andorl(SAA7134_MAIN_CTRL,
512 SAA7134_MAIN_CTRL_TE0 |
513 SAA7134_MAIN_CTRL_TE1 |
514 SAA7134_MAIN_CTRL_TE2 |
515 SAA7134_MAIN_CTRL_TE3 |
516 SAA7134_MAIN_CTRL_TE4 |
517 SAA7134_MAIN_CTRL_TE5 |
518 SAA7134_MAIN_CTRL_TE6,
519 ctrl);
520 dprintk("dmabits: task=0x%02x ctrl=0x%02x irq=0x%x split=%s\n",
521 task, ctrl, irq, split ? "no" : "yes");
522
523 return 0;
524 }
525
526 /* ------------------------------------------------------------------ */
527 /* IRQ handler + helpers */
528
529 static char *irqbits[] = {
530 "DONE_RA0", "DONE_RA1", "DONE_RA2", "DONE_RA3",
531 "AR", "PE", "PWR_ON", "RDCAP", "INTL", "FIDT", "MMC",
532 "TRIG_ERR", "CONF_ERR", "LOAD_ERR",
533 "GPIO16?", "GPIO18", "GPIO22", "GPIO23"
534 };
535 #define IRQBITS ARRAY_SIZE(irqbits)
536
537 static void print_irqstatus(struct saa7134_dev *dev, int loop,
538 unsigned long report, unsigned long status)
539 {
540 unsigned int i;
541
542 printk(KERN_DEBUG "%s/irq[%d,%ld]: r=0x%lx s=0x%02lx",
543 dev->name,loop,jiffies,report,status);
544 for (i = 0; i < IRQBITS; i++) {
545 if (!(report & (1 << i)))
546 continue;
547 printk(" %s",irqbits[i]);
548 }
549 if (report & SAA7134_IRQ_REPORT_DONE_RA0) {
550 printk(" | RA0=%s,%s,%s,%ld",
551 (status & 0x40) ? "vbi" : "video",
552 (status & 0x20) ? "b" : "a",
553 (status & 0x10) ? "odd" : "even",
554 (status & 0x0f));
555 }
556 printk("\n");
557 }
558
559 static irqreturn_t saa7134_irq(int irq, void *dev_id, struct pt_regs *regs)
560 {
561 struct saa7134_dev *dev = (struct saa7134_dev*) dev_id;
562 unsigned long report,status;
563 int loop, handled = 0;
564
565 for (loop = 0; loop < 10; loop++) {
566 report = saa_readl(SAA7134_IRQ_REPORT);
567 status = saa_readl(SAA7134_IRQ_STATUS);
568 if (0 == report) {
569 if (irq_debug > 1)
570 printk(KERN_DEBUG "%s/irq: no (more) work\n",
571 dev->name);
572 goto out;
573 }
574 handled = 1;
575 saa_writel(SAA7134_IRQ_REPORT,report);
576 if (irq_debug)
577 print_irqstatus(dev,loop,report,status);
578
579
580 if (report & SAA7134_IRQ_REPORT_RDCAP /* _INTL */)
581 saa7134_irq_video_intl(dev);
582
583 if ((report & SAA7134_IRQ_REPORT_DONE_RA0) &&
584 (status & 0x60) == 0)
585 saa7134_irq_video_done(dev,status);
586
587 if ((report & SAA7134_IRQ_REPORT_DONE_RA0) &&
588 (status & 0x40) == 0x40)
589 saa7134_irq_vbi_done(dev,status);
590
591 if ((report & SAA7134_IRQ_REPORT_DONE_RA2) &&
592 card_has_mpeg(dev))
593 saa7134_irq_ts_done(dev,status);
594
595 if ((report & SAA7134_IRQ_REPORT_DONE_RA3))
596 saa7134_irq_oss_done(dev,status);
597
598 if ((report & (SAA7134_IRQ_REPORT_GPIO16 |
599 SAA7134_IRQ_REPORT_GPIO18)) &&
600 dev->remote)
601 saa7134_input_irq(dev);
602 }
603
604 if (10 == loop) {
605 print_irqstatus(dev,loop,report,status);
606 if (report & SAA7134_IRQ_REPORT_PE) {
607 /* disable all parity error */
608 printk(KERN_WARNING "%s/irq: looping -- "
609 "clearing PE (parity error!) enable bit\n",dev->name);
610 saa_clearl(SAA7134_IRQ2,SAA7134_IRQ2_INTE_PE);
611 } else if (report & (SAA7134_IRQ_REPORT_GPIO16 |
612 SAA7134_IRQ_REPORT_GPIO18)) {
613 /* disable gpio IRQs */
614 printk(KERN_WARNING "%s/irq: looping -- "
615 "clearing GPIO enable bits\n",dev->name);
616 saa_clearl(SAA7134_IRQ2, (SAA7134_IRQ2_INTE_GPIO16 |
617 SAA7134_IRQ2_INTE_GPIO18));
618 } else {
619 /* disable all irqs */
620 printk(KERN_WARNING "%s/irq: looping -- "
621 "clearing all enable bits\n",dev->name);
622 saa_writel(SAA7134_IRQ1,0);
623 saa_writel(SAA7134_IRQ2,0);
624 }
625 }
626
627 out:
628 return IRQ_RETVAL(handled);
629 }
630
631 /* ------------------------------------------------------------------ */
632
633 /* early init (no i2c, no irq) */
634 static int saa7134_hwinit1(struct saa7134_dev *dev)
635 {
636 dprintk("hwinit1\n");
637
638 saa_writel(SAA7134_IRQ1, 0);
639 saa_writel(SAA7134_IRQ2, 0);
640 init_MUTEX(&dev->lock);
641 spin_lock_init(&dev->slock);
642
643 saa7134_track_gpio(dev,"pre-init");
644 saa7134_video_init1(dev);
645 saa7134_vbi_init1(dev);
646 if (card_has_mpeg(dev))
647 saa7134_ts_init1(dev);
648 saa7134_input_init1(dev);
649
650 switch (dev->pci->device) {
651 case PCI_DEVICE_ID_PHILIPS_SAA7134:
652 case PCI_DEVICE_ID_PHILIPS_SAA7133:
653 case PCI_DEVICE_ID_PHILIPS_SAA7135:
654 saa7134_oss_init1(dev);
655 break;
656 }
657
658 /* RAM FIFO config */
659 saa_writel(SAA7134_FIFO_SIZE, 0x08070503);
660 saa_writel(SAA7134_THRESHOULD,0x02020202);
661
662 /* enable audio + video processing */
663 saa_writel(SAA7134_MAIN_CTRL,
664 SAA7134_MAIN_CTRL_VPLLE |
665 SAA7134_MAIN_CTRL_APLLE |
666 SAA7134_MAIN_CTRL_EXOSC |
667 SAA7134_MAIN_CTRL_EVFE1 |
668 SAA7134_MAIN_CTRL_EVFE2 |
669 SAA7134_MAIN_CTRL_ESFE |
670 SAA7134_MAIN_CTRL_EBDAC);
671
672 /* enable peripheral devices */
673 saa_writeb(SAA7134_SPECIAL_MODE, 0x01);
674
675 /* set vertical line numbering start (vbi needs this) */
676 saa_writeb(SAA7134_SOURCE_TIMING2, 0x20);
677
678 return 0;
679 }
680
681 /* late init (with i2c + irq) */
682 static int saa7134_hwinit2(struct saa7134_dev *dev)
683 {
684 unsigned int irq2_mask;
685 dprintk("hwinit2\n");
686
687 saa7134_video_init2(dev);
688 saa7134_tvaudio_init2(dev);
689
690 /* enable IRQ's */
691 irq2_mask =
692 SAA7134_IRQ2_INTE_DEC3 |
693 SAA7134_IRQ2_INTE_DEC2 |
694 SAA7134_IRQ2_INTE_DEC1 |
695 SAA7134_IRQ2_INTE_DEC0 |
696 SAA7134_IRQ2_INTE_PE |
697 SAA7134_IRQ2_INTE_AR;
698
699 if (dev->has_remote)
700 irq2_mask |= (SAA7134_IRQ2_INTE_GPIO18 |
701 SAA7134_IRQ2_INTE_GPIO18A |
702 SAA7134_IRQ2_INTE_GPIO16 );
703
704 saa_writel(SAA7134_IRQ1, 0);
705 saa_writel(SAA7134_IRQ2, irq2_mask);
706
707 return 0;
708 }
709
710 /* shutdown */
711 static int saa7134_hwfini(struct saa7134_dev *dev)
712 {
713 dprintk("hwfini\n");
714
715 switch (dev->pci->device) {
716 case PCI_DEVICE_ID_PHILIPS_SAA7134:
717 case PCI_DEVICE_ID_PHILIPS_SAA7133:
718 case PCI_DEVICE_ID_PHILIPS_SAA7135:
719 saa7134_oss_fini(dev);
720 break;
721 }
722 if (card_has_mpeg(dev))
723 saa7134_ts_fini(dev);
724 saa7134_input_fini(dev);
725 saa7134_vbi_fini(dev);
726 saa7134_video_fini(dev);
727 saa7134_tvaudio_fini(dev);
728 return 0;
729 }
730
731 static void __devinit must_configure_manually(void)
732 {
733 unsigned int i,p;
734
735 printk(KERN_WARNING
736 "saa7134: <rant>\n"
737 "saa7134: Congratulations! Your TV card vendor saved a few\n"
738 "saa7134: cents for a eeprom, thus your pci board has no\n"
739 "saa7134: subsystem ID and I can't identify it automatically\n"
740 "saa7134: </rant>\n"
741 "saa7134: I feel better now. Ok, here are the good news:\n"
742 "saa7134: You can use the card=<nr> insmod option to specify\n"
743 "saa7134: which board do you have. The list:\n");
744 for (i = 0; i < saa7134_bcount; i++) {
745 printk(KERN_WARNING "saa7134: card=%d -> %-40.40s",
746 i,saa7134_boards[i].name);
747 for (p = 0; saa7134_pci_tbl[p].driver_data; p++) {
748 if (saa7134_pci_tbl[p].driver_data != i)
749 continue;
750 printk(" %04x:%04x",
751 saa7134_pci_tbl[p].subvendor,
752 saa7134_pci_tbl[p].subdevice);
753 }
754 printk("\n");
755 }
756 }
757
758 static struct video_device *vdev_init(struct saa7134_dev *dev,
759 struct video_device *template,
760 char *type)
761 {
762 struct video_device *vfd;
763
764 vfd = video_device_alloc();
765 if (NULL == vfd)
766 return NULL;
767 *vfd = *template;
768 vfd->minor = -1;
769 vfd->dev = &dev->pci->dev;
770 vfd->release = video_device_release;
771 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)",
772 dev->name, type, saa7134_boards[dev->board].name);
773 return vfd;
774 }
775
776 static void saa7134_unregister_video(struct saa7134_dev *dev)
777 {
778 if (dev->video_dev) {
779 if (-1 != dev->video_dev->minor)
780 video_unregister_device(dev->video_dev);
781 else
782 video_device_release(dev->video_dev);
783 dev->video_dev = NULL;
784 }
785 if (dev->vbi_dev) {
786 if (-1 != dev->vbi_dev->minor)
787 video_unregister_device(dev->vbi_dev);
788 else
789 video_device_release(dev->vbi_dev);
790 dev->vbi_dev = NULL;
791 }
792 if (dev->radio_dev) {
793 if (-1 != dev->radio_dev->minor)
794 video_unregister_device(dev->radio_dev);
795 else
796 video_device_release(dev->radio_dev);
797 dev->radio_dev = NULL;
798 }
799 }
800
801 static void mpeg_ops_attach(struct saa7134_mpeg_ops *ops,
802 struct saa7134_dev *dev)
803 {
804 int err;
805
806 if (NULL != dev->mops)
807 return;
808 if (saa7134_boards[dev->board].mpeg != ops->type)
809 return;
810 err = ops->init(dev);
811 if (0 != err)
812 return;
813 dev->mops = ops;
814 }
815
816 static void mpeg_ops_detach(struct saa7134_mpeg_ops *ops,
817 struct saa7134_dev *dev)
818 {
819 if (NULL == dev->mops)
820 return;
821 if (dev->mops != ops)
822 return;
823 dev->mops->fini(dev);
824 dev->mops = NULL;
825 }
826
827 static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
828 const struct pci_device_id *pci_id)
829 {
830 struct saa7134_dev *dev;
831 struct list_head *item;
832 struct saa7134_mpeg_ops *mops;
833 int err;
834
835 dev = kmalloc(sizeof(*dev),GFP_KERNEL);
836 if (NULL == dev)
837 return -ENOMEM;
838 memset(dev,0,sizeof(*dev));
839
840 /* pci init */
841 dev->pci = pci_dev;
842 if (pci_enable_device(pci_dev)) {
843 err = -EIO;
844 goto fail1;
845 }
846
847 dev->nr = saa7134_devcount;
848 sprintf(dev->name,"saa%x[%d]",pci_dev->device,dev->nr);
849
850 /* pci quirks */
851 if (pci_pci_problems) {
852 if (pci_pci_problems & PCIPCI_TRITON)
853 printk(KERN_INFO "%s: quirk: PCIPCI_TRITON\n", dev->name);
854 if (pci_pci_problems & PCIPCI_NATOMA)
855 printk(KERN_INFO "%s: quirk: PCIPCI_NATOMA\n", dev->name);
856 if (pci_pci_problems & PCIPCI_VIAETBF)
857 printk(KERN_INFO "%s: quirk: PCIPCI_VIAETBF\n", dev->name);
858 if (pci_pci_problems & PCIPCI_VSFX)
859 printk(KERN_INFO "%s: quirk: PCIPCI_VSFX\n",dev->name);
860 #ifdef PCIPCI_ALIMAGIK
861 if (pci_pci_problems & PCIPCI_ALIMAGIK) {
862 printk(KERN_INFO "%s: quirk: PCIPCI_ALIMAGIK -- latency fixup\n",
863 dev->name);
864 latency = 0x0A;
865 }
866 #endif
867 }
868 if (UNSET != latency) {
869 printk(KERN_INFO "%s: setting pci latency timer to %d\n",
870 dev->name,latency);
871 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
872 }
873
874 /* print pci info */
875 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
876 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &dev->pci_lat);
877 printk(KERN_INFO "%s: found at %s, rev: %d, irq: %d, "
878 "latency: %d, mmio: 0x%lx\n", dev->name,
879 pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
880 dev->pci_lat,pci_resource_start(pci_dev,0));
881 pci_set_master(pci_dev);
882 if (!pci_dma_supported(pci_dev,0xffffffff)) {
883 printk("%s: Oops: no 32bit PCI DMA ???\n",dev->name);
884 err = -EIO;
885 goto fail1;
886 }
887
888 /* board config */
889 dev->board = pci_id->driver_data;
890 if (card[dev->nr] >= 0 &&
891 card[dev->nr] < saa7134_bcount)
892 dev->board = card[dev->nr];
893 if (SAA7134_BOARD_NOAUTO == dev->board) {
894 must_configure_manually();
895 dev->board = SAA7134_BOARD_UNKNOWN;
896 }
897 dev->tuner_type = saa7134_boards[dev->board].tuner_type;
898 dev->tda9887_conf = saa7134_boards[dev->board].tda9887_conf;
899 if (UNSET != tuner[dev->nr])
900 dev->tuner_type = tuner[dev->nr];
901 printk(KERN_INFO "%s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
902 dev->name,pci_dev->subsystem_vendor,
903 pci_dev->subsystem_device,saa7134_boards[dev->board].name,
904 dev->board, card[dev->nr] == dev->board ?
905 "insmod option" : "autodetected");
906
907 /* get mmio */
908 if (!request_mem_region(pci_resource_start(pci_dev,0),
909 pci_resource_len(pci_dev,0),
910 dev->name)) {
911 err = -EBUSY;
912 printk(KERN_ERR "%s: can't get MMIO memory @ 0x%lx\n",
913 dev->name,pci_resource_start(pci_dev,0));
914 goto fail1;
915 }
916 dev->lmmio = ioremap(pci_resource_start(pci_dev,0), 0x1000);
917 dev->bmmio = (__u8 __iomem *)dev->lmmio;
918 if (NULL == dev->lmmio) {
919 err = -EIO;
920 printk(KERN_ERR "%s: can't ioremap() MMIO memory\n",
921 dev->name);
922 goto fail2;
923 }
924
925 /* initialize hardware #1 */
926 saa7134_board_init1(dev);
927 saa7134_hwinit1(dev);
928
929 /* get irq */
930 err = request_irq(pci_dev->irq, saa7134_irq,
931 SA_SHIRQ | SA_INTERRUPT, dev->name, dev);
932 if (err < 0) {
933 printk(KERN_ERR "%s: can't get IRQ %d\n",
934 dev->name,pci_dev->irq);
935 goto fail3;
936 }
937
938 /* wait a bit, register i2c bus */
939 msleep(100);
940 saa7134_i2c_register(dev);
941
942 /* initialize hardware #2 */
943 saa7134_board_init2(dev);
944 saa7134_hwinit2(dev);
945
946 /* load i2c helpers */
947 if (TUNER_ABSENT != dev->tuner_type)
948 request_module("tuner");
949 if (dev->tda9887_conf)
950 request_module("tda9887");
951 if (card_is_empress(dev)) {
952 request_module("saa6752hs");
953 request_module_depend("saa7134-empress",&need_empress);
954 }
955
956 if (card_is_dvb(dev))
957 request_module_depend("saa7134-dvb",&need_dvb);
958
959 v4l2_prio_init(&dev->prio);
960
961 /* register v4l devices */
962 dev->video_dev = vdev_init(dev,&saa7134_video_template,"video");
963 err = video_register_device(dev->video_dev,VFL_TYPE_GRABBER,
964 video_nr[dev->nr]);
965 if (err < 0) {
966 printk(KERN_INFO "%s: can't register video device\n",
967 dev->name);
968 goto fail4;
969 }
970 printk(KERN_INFO "%s: registered device video%d [v4l2]\n",
971 dev->name,dev->video_dev->minor & 0x1f);
972
973 dev->vbi_dev = vdev_init(dev,&saa7134_vbi_template,"vbi");
974 err = video_register_device(dev->vbi_dev,VFL_TYPE_VBI,
975 vbi_nr[dev->nr]);
976 if (err < 0)
977 goto fail4;
978 printk(KERN_INFO "%s: registered device vbi%d\n",
979 dev->name,dev->vbi_dev->minor & 0x1f);
980
981 if (card_has_radio(dev)) {
982 dev->radio_dev = vdev_init(dev,&saa7134_radio_template,"radio");
983 err = video_register_device(dev->radio_dev,VFL_TYPE_RADIO,
984 radio_nr[dev->nr]);
985 if (err < 0)
986 goto fail4;
987 printk(KERN_INFO "%s: registered device radio%d\n",
988 dev->name,dev->radio_dev->minor & 0x1f);
989 }
990
991 /* register oss devices */
992 switch (dev->pci->device) {
993 case PCI_DEVICE_ID_PHILIPS_SAA7134:
994 case PCI_DEVICE_ID_PHILIPS_SAA7133:
995 case PCI_DEVICE_ID_PHILIPS_SAA7135:
996 if (oss) {
997 err = dev->oss.minor_dsp =
998 register_sound_dsp(&saa7134_dsp_fops,
999 dsp_nr[dev->nr]);
1000 if (err < 0) {
1001 goto fail4;
1002 }
1003 printk(KERN_INFO "%s: registered device dsp%d\n",
1004 dev->name,dev->oss.minor_dsp >> 4);
1005
1006 err = dev->oss.minor_mixer =
1007 register_sound_mixer(&saa7134_mixer_fops,
1008 mixer_nr[dev->nr]);
1009 if (err < 0)
1010 goto fail5;
1011 printk(KERN_INFO "%s: registered device mixer%d\n",
1012 dev->name,dev->oss.minor_mixer >> 4);
1013 }
1014 break;
1015 }
1016
1017 /* everything worked */
1018 pci_set_drvdata(pci_dev,dev);
1019 saa7134_devcount++;
1020
1021 down(&devlist_lock);
1022 list_for_each(item,&mops_list) {
1023 mops = list_entry(item, struct saa7134_mpeg_ops, next);
1024 mpeg_ops_attach(mops, dev);
1025 }
1026 list_add_tail(&dev->devlist,&saa7134_devlist);
1027 up(&devlist_lock);
1028
1029 /* check for signal */
1030 saa7134_irq_video_intl(dev);
1031 return 0;
1032
1033 fail5:
1034 switch (dev->pci->device) {
1035 case PCI_DEVICE_ID_PHILIPS_SAA7134:
1036 case PCI_DEVICE_ID_PHILIPS_SAA7133:
1037 case PCI_DEVICE_ID_PHILIPS_SAA7135:
1038 if (oss)
1039 unregister_sound_dsp(dev->oss.minor_dsp);
1040 break;
1041 }
1042 fail4:
1043 saa7134_unregister_video(dev);
1044 saa7134_i2c_unregister(dev);
1045 free_irq(pci_dev->irq, dev);
1046 fail3:
1047 saa7134_hwfini(dev);
1048 iounmap(dev->lmmio);
1049 fail2:
1050 release_mem_region(pci_resource_start(pci_dev,0),
1051 pci_resource_len(pci_dev,0));
1052 fail1:
1053 kfree(dev);
1054 return err;
1055 }
1056
1057 static void __devexit saa7134_finidev(struct pci_dev *pci_dev)
1058 {
1059 struct saa7134_dev *dev = pci_get_drvdata(pci_dev);
1060 struct list_head *item;
1061 struct saa7134_mpeg_ops *mops;
1062
1063 /* debugging ... */
1064 if (irq_debug) {
1065 u32 report = saa_readl(SAA7134_IRQ_REPORT);
1066 u32 status = saa_readl(SAA7134_IRQ_STATUS);
1067 print_irqstatus(dev,42,report,status);
1068 }
1069
1070 /* disable peripheral devices */
1071 saa_writeb(SAA7134_SPECIAL_MODE,0);
1072
1073 /* shutdown hardware */
1074 saa_writel(SAA7134_IRQ1,0);
1075 saa_writel(SAA7134_IRQ2,0);
1076 saa_writel(SAA7134_MAIN_CTRL,0);
1077
1078 /* shutdown subsystems */
1079 saa7134_hwfini(dev);
1080
1081 /* unregister */
1082 down(&devlist_lock);
1083 list_del(&dev->devlist);
1084 list_for_each(item,&mops_list) {
1085 mops = list_entry(item, struct saa7134_mpeg_ops, next);
1086 mpeg_ops_detach(mops, dev);
1087 }
1088 up(&devlist_lock);
1089 saa7134_devcount--;
1090
1091 saa7134_i2c_unregister(dev);
1092 switch (dev->pci->device) {
1093 case PCI_DEVICE_ID_PHILIPS_SAA7134:
1094 case PCI_DEVICE_ID_PHILIPS_SAA7133:
1095 case PCI_DEVICE_ID_PHILIPS_SAA7135:
1096 if (oss) {
1097 unregister_sound_mixer(dev->oss.minor_mixer);
1098 unregister_sound_dsp(dev->oss.minor_dsp);
1099 }
1100 break;
1101 }
1102 saa7134_unregister_video(dev);
1103
1104 /* release ressources */
1105 free_irq(pci_dev->irq, dev);
1106 iounmap(dev->lmmio);
1107 release_mem_region(pci_resource_start(pci_dev,0),
1108 pci_resource_len(pci_dev,0));
1109
1110 pci_set_drvdata(pci_dev, NULL);
1111
1112 /* free memory */
1113 kfree(dev);
1114 }
1115
1116 /* ----------------------------------------------------------- */
1117
1118 int saa7134_ts_register(struct saa7134_mpeg_ops *ops)
1119 {
1120 struct list_head *item;
1121 struct saa7134_dev *dev;
1122
1123 down(&devlist_lock);
1124 list_for_each(item,&saa7134_devlist) {
1125 dev = list_entry(item, struct saa7134_dev, devlist);
1126 mpeg_ops_attach(ops, dev);
1127 }
1128 list_add_tail(&ops->next,&mops_list);
1129 up(&devlist_lock);
1130 return 0;
1131 }
1132
1133 void saa7134_ts_unregister(struct saa7134_mpeg_ops *ops)
1134 {
1135 struct list_head *item;
1136 struct saa7134_dev *dev;
1137
1138 down(&devlist_lock);
1139 list_del(&ops->next);
1140 list_for_each(item,&saa7134_devlist) {
1141 dev = list_entry(item, struct saa7134_dev, devlist);
1142 mpeg_ops_detach(ops, dev);
1143 }
1144 up(&devlist_lock);
1145 }
1146
1147 EXPORT_SYMBOL(saa7134_ts_register);
1148 EXPORT_SYMBOL(saa7134_ts_unregister);
1149
1150 /* ----------------------------------------------------------- */
1151
1152 static struct pci_driver saa7134_pci_driver = {
1153 .name = "saa7134",
1154 .id_table = saa7134_pci_tbl,
1155 .probe = saa7134_initdev,
1156 .remove = __devexit_p(saa7134_finidev),
1157 };
1158
1159 static int saa7134_init(void)
1160 {
1161 INIT_LIST_HEAD(&saa7134_devlist);
1162 printk(KERN_INFO "saa7130/34: v4l2 driver version %d.%d.%d loaded\n",
1163 (SAA7134_VERSION_CODE >> 16) & 0xff,
1164 (SAA7134_VERSION_CODE >> 8) & 0xff,
1165 SAA7134_VERSION_CODE & 0xff);
1166 #ifdef SNAPSHOT
1167 printk(KERN_INFO "saa7130/34: snapshot date %04d-%02d-%02d\n",
1168 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
1169 #endif
1170 return pci_module_init(&saa7134_pci_driver);
1171 }
1172
1173 static void saa7134_fini(void)
1174 {
1175 #ifdef CONFIG_MODULES
1176 if (pending_registered)
1177 unregister_module_notifier(&pending_notifier);
1178 #endif
1179 pci_unregister_driver(&saa7134_pci_driver);
1180 }
1181
1182 module_init(saa7134_init);
1183 module_exit(saa7134_fini);
1184
1185 /* ----------------------------------------------------------- */
1186
1187 EXPORT_SYMBOL(saa7134_print_ioctl);
1188 EXPORT_SYMBOL(saa7134_i2c_call_clients);
1189 EXPORT_SYMBOL(saa7134_devlist);
1190 EXPORT_SYMBOL(saa7134_boards);
1191
1192 /* ----------------------------------------------------------- */
1193 /*
1194 * Local variables:
1195 * c-basic-offset: 8
1196 * End:
1197 */
Verdex Pro support