?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[XFRM]: skb_cow_data() does not set proper owner for new skbs.
[linux-2.6/verdex.git] / drivers / media / video / saa7134 / saa7134-core.c
blobd506cafba8ffe55ca74e7d897d4ec358bb146b7f
1 /*
2 * $Id: saa7134-core.c,v 1.28 2005/02/22 09:56:29 kraxel 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 #if 0
187 static char *dec1_bits[8] = {
188 "DCSTD0", "DCSCT1", "WIPA", "GLIMB",
189 "GLIMT", "SLTCA", "HLCK"
190 };
191 static char *dec2_bits[8] = {
192 "RDCAP", "COPRO", "COLSTR", "TYPE3",
193 NULL, "FIDT", "HLVLN", "INTL"
194 };
195 static char *scale1_bits[8] = {
196 "VID_A", "VBI_A", NULL, NULL, "VID_B", "VBI_B"
197 };
198 static char *scale2_bits[8] = {
199 "TRERR", "CFERR", "LDERR", "WASRST",
200 "FIDSCI", "FIDSCO", "D6^D5", "TASK"
201 };
202
203 static void dump_statusreg(struct saa7134_dev *dev, int reg,
204 char *regname, char **bits)
205 {
206 int value,i;
207
208 value = saa_readb(reg);
209 printk(KERN_DEBUG "%s: %s:", dev->name, regname);
210 for (i = 7; i >= 0; i--) {
211 if (NULL == bits[i])
212 continue;
213 printk(" %s=%d", bits[i], (value & (1 << i)) ? 1 : 0);
214 }
215 printk("\n");
216 }
217
218 static void dump_statusregs(struct saa7134_dev *dev)
219 {
220 dump_statusreg(dev,SAA7134_STATUS_VIDEO1,"dec1",dec1_bits);
221 dump_statusreg(dev,SAA7134_STATUS_VIDEO2,"dec2",dec2_bits);
222 dump_statusreg(dev,SAA7134_SCALER_STATUS0,"scale0",scale1_bits);
223 dump_statusreg(dev,SAA7134_SCALER_STATUS1,"scale1",scale2_bits);
224 }
225 #endif
226
227 /* ----------------------------------------------------------- */
228 /* delayed request_module */
229
230 #ifdef CONFIG_MODULES
231
232 static int need_empress;
233 static int need_dvb;
234
235 static int pending_call(struct notifier_block *self, unsigned long state,
236 void *module)
237 {
238 if (module != THIS_MODULE || state != MODULE_STATE_LIVE)
239 return NOTIFY_DONE;
240
241 if (need_empress)
242 request_module("saa7134-empress");
243 if (need_dvb)
244 request_module("saa7134-dvb");
245 return NOTIFY_DONE;
246 }
247
248 static int pending_registered;
249 static struct notifier_block pending_notifier = {
250 .notifier_call = pending_call,
251 };
252
253 static void request_module_depend(char *name, int *flag)
254 {
255 switch (THIS_MODULE->state) {
256 case MODULE_STATE_COMING:
257 if (!pending_registered) {
258 register_module_notifier(&pending_notifier);
259 pending_registered = 1;
260 }
261 *flag = 1;
262 break;
263 case MODULE_STATE_LIVE:
264 request_module(name);
265 break;
266 default:
267 /* nothing */;
268 break;
269 }
270 }
271
272 #else
273
274 #define request_module_depend(name,flag)
275
276 #endif /* CONFIG_MODULES */
277
278 /* ------------------------------------------------------------------ */
279
280 /* nr of (saa7134-)pages for the given buffer size */
281 static int saa7134_buffer_pages(int size)
282 {
283 size = PAGE_ALIGN(size);
284 size += PAGE_SIZE; /* for non-page-aligned buffers */
285 size /= 4096;
286 return size;
287 }
288
289 /* calc max # of buffers from size (must not exceed the 4MB virtual
290 * address space per DMA channel) */
291 int saa7134_buffer_count(unsigned int size, unsigned int count)
292 {
293 unsigned int maxcount;
294
295 maxcount = 1024 / saa7134_buffer_pages(size);
296 if (count > maxcount)
297 count = maxcount;
298 return count;
299 }
300
301 int saa7134_buffer_startpage(struct saa7134_buf *buf)
302 {
303 return saa7134_buffer_pages(buf->vb.bsize) * buf->vb.i;
304 }
305
306 unsigned long saa7134_buffer_base(struct saa7134_buf *buf)
307 {
308 unsigned long base;
309
310 base = saa7134_buffer_startpage(buf) * 4096;
311 base += buf->vb.dma.sglist[0].offset;
312 return base;
313 }
314
315 /* ------------------------------------------------------------------ */
316
317 int saa7134_pgtable_alloc(struct pci_dev *pci, struct saa7134_pgtable *pt)
318 {
319 u32 *cpu;
320 dma_addr_t dma_addr;
321
322 cpu = pci_alloc_consistent(pci, SAA7134_PGTABLE_SIZE, &dma_addr);
323 if (NULL == cpu)
324 return -ENOMEM;
325 pt->size = SAA7134_PGTABLE_SIZE;
326 pt->cpu = cpu;
327 pt->dma = dma_addr;
328 return 0;
329 }
330
331 int saa7134_pgtable_build(struct pci_dev *pci, struct saa7134_pgtable *pt,
332 struct scatterlist *list, unsigned int length,
333 unsigned int startpage)
334 {
335 u32 *ptr;
336 unsigned int i,p;
337
338 BUG_ON(NULL == pt || NULL == pt->cpu);
339
340 ptr = pt->cpu + startpage;
341 for (i = 0; i < length; i++, list++)
342 for (p = 0; p * 4096 < list->length; p++, ptr++)
343 *ptr = sg_dma_address(list) - list->offset;
344 return 0;
345 }
346
347 void saa7134_pgtable_free(struct pci_dev *pci, struct saa7134_pgtable *pt)
348 {
349 if (NULL == pt->cpu)
350 return;
351 pci_free_consistent(pci, pt->size, pt->cpu, pt->dma);
352 pt->cpu = NULL;
353 }
354
355 /* ------------------------------------------------------------------ */
356
357 void saa7134_dma_free(struct saa7134_dev *dev,struct saa7134_buf *buf)
358 {
359 if (in_interrupt())
360 BUG();
361
362 videobuf_waiton(&buf->vb,0,0);
363 videobuf_dma_pci_unmap(dev->pci, &buf->vb.dma);
364 videobuf_dma_free(&buf->vb.dma);
365 buf->vb.state = STATE_NEEDS_INIT;
366 }
367
368 /* ------------------------------------------------------------------ */
369
370 int saa7134_buffer_queue(struct saa7134_dev *dev,
371 struct saa7134_dmaqueue *q,
372 struct saa7134_buf *buf)
373 {
374 struct saa7134_buf *next = NULL;
375
376 assert_spin_locked(&dev->slock);
377 dprintk("buffer_queue %p\n",buf);
378 if (NULL == q->curr) {
379 if (!q->need_two) {
380 q->curr = buf;
381 buf->activate(dev,buf,NULL);
382 } else if (list_empty(&q->queue)) {
383 list_add_tail(&buf->vb.queue,&q->queue);
384 buf->vb.state = STATE_QUEUED;
385 } else {
386 next = list_entry(q->queue.next,struct saa7134_buf,
387 vb.queue);
388 q->curr = buf;
389 buf->activate(dev,buf,next);
390 }
391 } else {
392 list_add_tail(&buf->vb.queue,&q->queue);
393 buf->vb.state = STATE_QUEUED;
394 }
395 return 0;
396 }
397
398 void saa7134_buffer_finish(struct saa7134_dev *dev,
399 struct saa7134_dmaqueue *q,
400 unsigned int state)
401 {
402 assert_spin_locked(&dev->slock);
403 dprintk("buffer_finish %p\n",q->curr);
404
405 /* finish current buffer */
406 q->curr->vb.state = state;
407 do_gettimeofday(&q->curr->vb.ts);
408 wake_up(&q->curr->vb.done);
409 q->curr = NULL;
410 }
411
412 void saa7134_buffer_next(struct saa7134_dev *dev,
413 struct saa7134_dmaqueue *q)
414 {
415 struct saa7134_buf *buf,*next = NULL;
416
417 assert_spin_locked(&dev->slock);
418 BUG_ON(NULL != q->curr);
419
420 if (!list_empty(&q->queue)) {
421 /* activate next one from queue */
422 buf = list_entry(q->queue.next,struct saa7134_buf,vb.queue);
423 dprintk("buffer_next %p [prev=%p/next=%p]\n",
424 buf,q->queue.prev,q->queue.next);
425 list_del(&buf->vb.queue);
426 if (!list_empty(&q->queue))
427 next = list_entry(q->queue.next,struct saa7134_buf,
428 vb.queue);
429 q->curr = buf;
430 buf->activate(dev,buf,next);
431 dprintk("buffer_next #2 prev=%p/next=%p\n",
432 q->queue.prev,q->queue.next);
433 } else {
434 /* nothing to do -- just stop DMA */
435 dprintk("buffer_next %p\n",NULL);
436 saa7134_set_dmabits(dev);
437 del_timer(&q->timeout);
438 }
439 }
440
441 void saa7134_buffer_timeout(unsigned long data)
442 {
443 struct saa7134_dmaqueue *q = (struct saa7134_dmaqueue*)data;
444 struct saa7134_dev *dev = q->dev;
445 unsigned long flags;
446
447 spin_lock_irqsave(&dev->slock,flags);
448
449 /* try to reset the hardware (SWRST) */
450 saa_writeb(SAA7134_REGION_ENABLE, 0x00);
451 saa_writeb(SAA7134_REGION_ENABLE, 0x80);
452 saa_writeb(SAA7134_REGION_ENABLE, 0x00);
453
454 /* flag current buffer as failed,
455 try to start over with the next one. */
456 if (q->curr) {
457 dprintk("timeout on %p\n",q->curr);
458 saa7134_buffer_finish(dev,q,STATE_ERROR);
459 }
460 saa7134_buffer_next(dev,q);
461 spin_unlock_irqrestore(&dev->slock,flags);
462 }
463
464 /* ------------------------------------------------------------------ */
465
466 int saa7134_set_dmabits(struct saa7134_dev *dev)
467 {
468 u32 split, task=0, ctrl=0, irq=0;
469 enum v4l2_field cap = V4L2_FIELD_ANY;
470 enum v4l2_field ov = V4L2_FIELD_ANY;
471
472 assert_spin_locked(&dev->slock);
473
474 /* video capture -- dma 0 + video task A */
475 if (dev->video_q.curr) {
476 task |= 0x01;
477 ctrl |= SAA7134_MAIN_CTRL_TE0;
478 irq |= SAA7134_IRQ1_INTE_RA0_1 |
479 SAA7134_IRQ1_INTE_RA0_0;
480 cap = dev->video_q.curr->vb.field;
481 }
482
483 /* video capture -- dma 1+2 (planar modes) */
484 if (dev->video_q.curr &&
485 dev->video_q.curr->fmt->planar) {
486 ctrl |= SAA7134_MAIN_CTRL_TE4 |
487 SAA7134_MAIN_CTRL_TE5;
488 }
489
490 /* screen overlay -- dma 0 + video task B */
491 if (dev->ovenable) {
492 task |= 0x10;
493 ctrl |= SAA7134_MAIN_CTRL_TE1;
494 ov = dev->ovfield;
495 }
496
497 /* vbi capture -- dma 0 + vbi task A+B */
498 if (dev->vbi_q.curr) {
499 task |= 0x22;
500 ctrl |= SAA7134_MAIN_CTRL_TE2 |
501 SAA7134_MAIN_CTRL_TE3;
502 irq |= SAA7134_IRQ1_INTE_RA0_7 |
503 SAA7134_IRQ1_INTE_RA0_6 |
504 SAA7134_IRQ1_INTE_RA0_5 |
505 SAA7134_IRQ1_INTE_RA0_4;
506 }
507
508 /* audio capture -- dma 3 */
509 if (dev->oss.dma_running) {
510 ctrl |= SAA7134_MAIN_CTRL_TE6;
511 irq |= SAA7134_IRQ1_INTE_RA3_1 |
512 SAA7134_IRQ1_INTE_RA3_0;
513 }
514
515 /* TS capture -- dma 5 */
516 if (dev->ts_q.curr) {
517 ctrl |= SAA7134_MAIN_CTRL_TE5;
518 irq |= SAA7134_IRQ1_INTE_RA2_3 |
519 SAA7134_IRQ1_INTE_RA2_2 |
520 SAA7134_IRQ1_INTE_RA2_1 |
521 SAA7134_IRQ1_INTE_RA2_0;
522 }
523
524 /* set task conditions + field handling */
525 if (V4L2_FIELD_HAS_BOTH(cap) || V4L2_FIELD_HAS_BOTH(ov) || cap == ov) {
526 /* default config -- use full frames */
527 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_A), 0x0d);
528 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_B), 0x0d);
529 saa_writeb(SAA7134_FIELD_HANDLING(TASK_A), 0x02);
530 saa_writeb(SAA7134_FIELD_HANDLING(TASK_B), 0x02);
531 split = 0;
532 } else {
533 /* split fields between tasks */
534 if (V4L2_FIELD_TOP == cap) {
535 /* odd A, even B, repeat */
536 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_A), 0x0d);
537 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_B), 0x0e);
538 } else {
539 /* odd B, even A, repeat */
540 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_A), 0x0e);
541 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_B), 0x0d);
542 }
543 saa_writeb(SAA7134_FIELD_HANDLING(TASK_A), 0x01);
544 saa_writeb(SAA7134_FIELD_HANDLING(TASK_B), 0x01);
545 split = 1;
546 }
547
548 /* irqs */
549 saa_writeb(SAA7134_REGION_ENABLE, task);
550 saa_writel(SAA7134_IRQ1, irq);
551 saa_andorl(SAA7134_MAIN_CTRL,
552 SAA7134_MAIN_CTRL_TE0 |
553 SAA7134_MAIN_CTRL_TE1 |
554 SAA7134_MAIN_CTRL_TE2 |
555 SAA7134_MAIN_CTRL_TE3 |
556 SAA7134_MAIN_CTRL_TE4 |
557 SAA7134_MAIN_CTRL_TE5 |
558 SAA7134_MAIN_CTRL_TE6,
559 ctrl);
560 dprintk("dmabits: task=0x%02x ctrl=0x%02x irq=0x%x split=%s\n",
561 task, ctrl, irq, split ? "no" : "yes");
562
563 return 0;
564 }
565
566 /* ------------------------------------------------------------------ */
567 /* IRQ handler + helpers */
568
569 static char *irqbits[] = {
570 "DONE_RA0", "DONE_RA1", "DONE_RA2", "DONE_RA3",
571 "AR", "PE", "PWR_ON", "RDCAP", "INTL", "FIDT", "MMC",
572 "TRIG_ERR", "CONF_ERR", "LOAD_ERR",
573 "GPIO16?", "GPIO18", "GPIO22", "GPIO23"
574 };
575 #define IRQBITS ARRAY_SIZE(irqbits)
576
577 static void print_irqstatus(struct saa7134_dev *dev, int loop,
578 unsigned long report, unsigned long status)
579 {
580 unsigned int i;
581
582 printk(KERN_DEBUG "%s/irq[%d,%ld]: r=0x%lx s=0x%02lx",
583 dev->name,loop,jiffies,report,status);
584 for (i = 0; i < IRQBITS; i++) {
585 if (!(report & (1 << i)))
586 continue;
587 printk(" %s",irqbits[i]);
588 }
589 if (report & SAA7134_IRQ_REPORT_DONE_RA0) {
590 printk(" | RA0=%s,%s,%s,%ld",
591 (status & 0x40) ? "vbi" : "video",
592 (status & 0x20) ? "b" : "a",
593 (status & 0x10) ? "odd" : "even",
594 (status & 0x0f));
595 }
596 printk("\n");
597 }
598
599 static irqreturn_t saa7134_irq(int irq, void *dev_id, struct pt_regs *regs)
600 {
601 struct saa7134_dev *dev = (struct saa7134_dev*) dev_id;
602 unsigned long report,status;
603 int loop, handled = 0;
604
605 for (loop = 0; loop < 10; loop++) {
606 report = saa_readl(SAA7134_IRQ_REPORT);
607 status = saa_readl(SAA7134_IRQ_STATUS);
608 if (0 == report) {
609 if (irq_debug > 1)
610 printk(KERN_DEBUG "%s/irq: no (more) work\n",
611 dev->name);
612 goto out;
613 }
614 handled = 1;
615 saa_writel(SAA7134_IRQ_REPORT,report);
616 if (irq_debug)
617 print_irqstatus(dev,loop,report,status);
618
619 #if 0
620 if (report & SAA7134_IRQ_REPORT_CONF_ERR)
621 dump_statusregs(dev);
622 #endif
623
624 if (report & SAA7134_IRQ_REPORT_RDCAP /* _INTL */)
625 saa7134_irq_video_intl(dev);
626
627 if ((report & SAA7134_IRQ_REPORT_DONE_RA0) &&
628 (status & 0x60) == 0)
629 saa7134_irq_video_done(dev,status);
630
631 if ((report & SAA7134_IRQ_REPORT_DONE_RA0) &&
632 (status & 0x40) == 0x40)
633 saa7134_irq_vbi_done(dev,status);
634
635 if ((report & SAA7134_IRQ_REPORT_DONE_RA2) &&
636 card_has_mpeg(dev))
637 saa7134_irq_ts_done(dev,status);
638
639 if ((report & SAA7134_IRQ_REPORT_DONE_RA3))
640 saa7134_irq_oss_done(dev,status);
641
642 if ((report & (SAA7134_IRQ_REPORT_GPIO16 |
643 SAA7134_IRQ_REPORT_GPIO18)) &&
644 dev->remote)
645 saa7134_input_irq(dev);
646 }
647
648 if (10 == loop) {
649 print_irqstatus(dev,loop,report,status);
650 if (report & SAA7134_IRQ_REPORT_PE) {
651 /* disable all parity error */
652 printk(KERN_WARNING "%s/irq: looping -- "
653 "clearing PE (parity error!) enable bit\n",dev->name);
654 saa_clearl(SAA7134_IRQ2,SAA7134_IRQ2_INTE_PE);
655 } else if (report & (SAA7134_IRQ_REPORT_GPIO16 |
656 SAA7134_IRQ_REPORT_GPIO18)) {
657 /* disable gpio IRQs */
658 printk(KERN_WARNING "%s/irq: looping -- "
659 "clearing GPIO enable bits\n",dev->name);
660 saa_clearl(SAA7134_IRQ2, (SAA7134_IRQ2_INTE_GPIO16 |
661 SAA7134_IRQ2_INTE_GPIO18));
662 } else {
663 /* disable all irqs */
664 printk(KERN_WARNING "%s/irq: looping -- "
665 "clearing all enable bits\n",dev->name);
666 saa_writel(SAA7134_IRQ1,0);
667 saa_writel(SAA7134_IRQ2,0);
668 }
669 }
670
671 out:
672 return IRQ_RETVAL(handled);
673 }
674
675 /* ------------------------------------------------------------------ */
676
677 /* early init (no i2c, no irq) */
678 static int saa7134_hwinit1(struct saa7134_dev *dev)
679 {
680 dprintk("hwinit1\n");
681
682 saa_writel(SAA7134_IRQ1, 0);
683 saa_writel(SAA7134_IRQ2, 0);
684 init_MUTEX(&dev->lock);
685 spin_lock_init(&dev->slock);
686
687 saa7134_track_gpio(dev,"pre-init");
688 saa7134_video_init1(dev);
689 saa7134_vbi_init1(dev);
690 if (card_has_mpeg(dev))
691 saa7134_ts_init1(dev);
692 saa7134_input_init1(dev);
693
694 switch (dev->pci->device) {
695 case PCI_DEVICE_ID_PHILIPS_SAA7134:
696 case PCI_DEVICE_ID_PHILIPS_SAA7133:
697 case PCI_DEVICE_ID_PHILIPS_SAA7135:
698 saa7134_oss_init1(dev);
699 break;
700 }
701
702 /* RAM FIFO config */
703 saa_writel(SAA7134_FIFO_SIZE, 0x08070503);
704 saa_writel(SAA7134_THRESHOULD,0x02020202);
705
706 /* enable audio + video processing */
707 saa_writel(SAA7134_MAIN_CTRL,
708 SAA7134_MAIN_CTRL_VPLLE |
709 SAA7134_MAIN_CTRL_APLLE |
710 SAA7134_MAIN_CTRL_EXOSC |
711 SAA7134_MAIN_CTRL_EVFE1 |
712 SAA7134_MAIN_CTRL_EVFE2 |
713 SAA7134_MAIN_CTRL_ESFE |
714 SAA7134_MAIN_CTRL_EBADC |
715 SAA7134_MAIN_CTRL_EBDAC);
716
717 /* enable peripheral devices */
718 saa_writeb(SAA7134_SPECIAL_MODE, 0x01);
719
720 /* set vertical line numbering start (vbi needs this) */
721 saa_writeb(SAA7134_SOURCE_TIMING2, 0x20);
722
723 return 0;
724 }
725
726 /* late init (with i2c + irq) */
727 static int saa7134_hwinit2(struct saa7134_dev *dev)
728 {
729 dprintk("hwinit2\n");
730
731 saa7134_video_init2(dev);
732 saa7134_tvaudio_init2(dev);
733
734 /* enable IRQ's */
735 saa_writel(SAA7134_IRQ1, 0);
736 saa_writel(SAA7134_IRQ2, dev->irq2_mask);
737
738 return 0;
739 }
740
741 /* shutdown */
742 static int saa7134_hwfini(struct saa7134_dev *dev)
743 {
744 dprintk("hwfini\n");
745
746 switch (dev->pci->device) {
747 case PCI_DEVICE_ID_PHILIPS_SAA7134:
748 case PCI_DEVICE_ID_PHILIPS_SAA7133:
749 case PCI_DEVICE_ID_PHILIPS_SAA7135:
750 saa7134_oss_fini(dev);
751 break;
752 }
753 if (card_has_mpeg(dev))
754 saa7134_ts_fini(dev);
755 saa7134_input_fini(dev);
756 saa7134_vbi_fini(dev);
757 saa7134_video_fini(dev);
758 saa7134_tvaudio_fini(dev);
759 return 0;
760 }
761
762 static void __devinit must_configure_manually(void)
763 {
764 unsigned int i,p;
765
766 printk(KERN_WARNING
767 "saa7134: <rant>\n"
768 "saa7134: Congratulations! Your TV card vendor saved a few\n"
769 "saa7134: cents for a eeprom, thus your pci board has no\n"
770 "saa7134: subsystem ID and I can't identify it automatically\n"
771 "saa7134: </rant>\n"
772 "saa7134: I feel better now. Ok, here are the good news:\n"
773 "saa7134: You can use the card=<nr> insmod option to specify\n"
774 "saa7134: which board do you have. The list:\n");
775 for (i = 0; i < saa7134_bcount; i++) {
776 printk(KERN_WARNING "saa7134: card=%d -> %-40.40s",
777 i,saa7134_boards[i].name);
778 for (p = 0; saa7134_pci_tbl[p].driver_data; p++) {
779 if (saa7134_pci_tbl[p].driver_data != i)
780 continue;
781 printk(" %04x:%04x",
782 saa7134_pci_tbl[p].subvendor,
783 saa7134_pci_tbl[p].subdevice);
784 }
785 printk("\n");
786 }
787 }
788
789 static struct video_device *vdev_init(struct saa7134_dev *dev,
790 struct video_device *template,
791 char *type)
792 {
793 struct video_device *vfd;
794
795 vfd = video_device_alloc();
796 if (NULL == vfd)
797 return NULL;
798 *vfd = *template;
799 vfd->minor = -1;
800 vfd->dev = &dev->pci->dev;
801 vfd->release = video_device_release;
802 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)",
803 dev->name, type, saa7134_boards[dev->board].name);
804 return vfd;
805 }
806
807 static void saa7134_unregister_video(struct saa7134_dev *dev)
808 {
809 if (dev->video_dev) {
810 if (-1 != dev->video_dev->minor)
811 video_unregister_device(dev->video_dev);
812 else
813 video_device_release(dev->video_dev);
814 dev->video_dev = NULL;
815 }
816 if (dev->vbi_dev) {
817 if (-1 != dev->vbi_dev->minor)
818 video_unregister_device(dev->vbi_dev);
819 else
820 video_device_release(dev->vbi_dev);
821 dev->vbi_dev = NULL;
822 }
823 if (dev->radio_dev) {
824 if (-1 != dev->radio_dev->minor)
825 video_unregister_device(dev->radio_dev);
826 else
827 video_device_release(dev->radio_dev);
828 dev->radio_dev = NULL;
829 }
830 }
831
832 static void mpeg_ops_attach(struct saa7134_mpeg_ops *ops,
833 struct saa7134_dev *dev)
834 {
835 int err;
836
837 if (NULL != dev->mops)
838 return;
839 if (saa7134_boards[dev->board].mpeg != ops->type)
840 return;
841 err = ops->init(dev);
842 if (0 != err)
843 return;
844 dev->mops = ops;
845 }
846
847 static void mpeg_ops_detach(struct saa7134_mpeg_ops *ops,
848 struct saa7134_dev *dev)
849 {
850 if (NULL == dev->mops)
851 return;
852 if (dev->mops != ops)
853 return;
854 dev->mops->fini(dev);
855 dev->mops = NULL;
856 }
857
858 static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
859 const struct pci_device_id *pci_id)
860 {
861 struct saa7134_dev *dev;
862 struct list_head *item;
863 struct saa7134_mpeg_ops *mops;
864 int err;
865
866 dev = kmalloc(sizeof(*dev),GFP_KERNEL);
867 if (NULL == dev)
868 return -ENOMEM;
869 memset(dev,0,sizeof(*dev));
870
871 /* pci init */
872 dev->pci = pci_dev;
873 if (pci_enable_device(pci_dev)) {
874 err = -EIO;
875 goto fail1;
876 }
877
878 dev->nr = saa7134_devcount;
879 sprintf(dev->name,"saa%x[%d]",pci_dev->device,dev->nr);
880
881 /* pci quirks */
882 if (pci_pci_problems) {
883 if (pci_pci_problems & PCIPCI_TRITON)
884 printk(KERN_INFO "%s: quirk: PCIPCI_TRITON\n", dev->name);
885 if (pci_pci_problems & PCIPCI_NATOMA)
886 printk(KERN_INFO "%s: quirk: PCIPCI_NATOMA\n", dev->name);
887 if (pci_pci_problems & PCIPCI_VIAETBF)
888 printk(KERN_INFO "%s: quirk: PCIPCI_VIAETBF\n", dev->name);
889 if (pci_pci_problems & PCIPCI_VSFX)
890 printk(KERN_INFO "%s: quirk: PCIPCI_VSFX\n",dev->name);
891 #ifdef PCIPCI_ALIMAGIK
892 if (pci_pci_problems & PCIPCI_ALIMAGIK) {
893 printk(KERN_INFO "%s: quirk: PCIPCI_ALIMAGIK -- latency fixup\n",
894 dev->name);
895 latency = 0x0A;
896 }
897 #endif
898 }
899 if (UNSET != latency) {
900 printk(KERN_INFO "%s: setting pci latency timer to %d\n",
901 dev->name,latency);
902 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
903 }
904
905 /* print pci info */
906 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
907 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &dev->pci_lat);
908 printk(KERN_INFO "%s: found at %s, rev: %d, irq: %d, "
909 "latency: %d, mmio: 0x%lx\n", dev->name,
910 pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
911 dev->pci_lat,pci_resource_start(pci_dev,0));
912 pci_set_master(pci_dev);
913 if (!pci_dma_supported(pci_dev,0xffffffff)) {
914 printk("%s: Oops: no 32bit PCI DMA ???\n",dev->name);
915 err = -EIO;
916 goto fail1;
917 }
918
919 /* board config */
920 dev->board = pci_id->driver_data;
921 if (card[dev->nr] >= 0 &&
922 card[dev->nr] < saa7134_bcount)
923 dev->board = card[dev->nr];
924 if (SAA7134_BOARD_NOAUTO == dev->board) {
925 must_configure_manually();
926 dev->board = SAA7134_BOARD_UNKNOWN;
927 }
928 dev->tuner_type = saa7134_boards[dev->board].tuner_type;
929 dev->tda9887_conf = saa7134_boards[dev->board].tda9887_conf;
930 if (UNSET != tuner[dev->nr])
931 dev->tuner_type = tuner[dev->nr];
932 printk(KERN_INFO "%s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
933 dev->name,pci_dev->subsystem_vendor,
934 pci_dev->subsystem_device,saa7134_boards[dev->board].name,
935 dev->board, card[dev->nr] == dev->board ?
936 "insmod option" : "autodetected");
937
938 /* get mmio */
939 if (!request_mem_region(pci_resource_start(pci_dev,0),
940 pci_resource_len(pci_dev,0),
941 dev->name)) {
942 err = -EBUSY;
943 printk(KERN_ERR "%s: can't get MMIO memory @ 0x%lx\n",
944 dev->name,pci_resource_start(pci_dev,0));
945 goto fail1;
946 }
947 dev->lmmio = ioremap(pci_resource_start(pci_dev,0), 0x1000);
948 dev->bmmio = (__u8 __iomem *)dev->lmmio;
949 if (NULL == dev->lmmio) {
950 err = -EIO;
951 printk(KERN_ERR "%s: can't ioremap() MMIO memory\n",
952 dev->name);
953 goto fail2;
954 }
955
956 /* initialize hardware #1 */
957 dev->irq2_mask =
958 SAA7134_IRQ2_INTE_DEC3 |
959 SAA7134_IRQ2_INTE_DEC2 |
960 SAA7134_IRQ2_INTE_DEC1 |
961 SAA7134_IRQ2_INTE_DEC0 |
962 SAA7134_IRQ2_INTE_PE |
963 SAA7134_IRQ2_INTE_AR;
964 saa7134_board_init1(dev);
965 saa7134_hwinit1(dev);
966
967 /* get irq */
968 err = request_irq(pci_dev->irq, saa7134_irq,
969 SA_SHIRQ | SA_INTERRUPT, dev->name, dev);
970 if (err < 0) {
971 printk(KERN_ERR "%s: can't get IRQ %d\n",
972 dev->name,pci_dev->irq);
973 goto fail3;
974 }
975
976 /* wait a bit, register i2c bus */
977 msleep(100);
978 saa7134_i2c_register(dev);
979
980 /* initialize hardware #2 */
981 saa7134_board_init2(dev);
982 saa7134_hwinit2(dev);
983
984 /* load i2c helpers */
985 if (TUNER_ABSENT != dev->tuner_type)
986 request_module("tuner");
987 if (dev->tda9887_conf)
988 request_module("tda9887");
989 if (card_is_empress(dev)) {
990 request_module("saa6752hs");
991 request_module_depend("saa7134-empress",&need_empress);
992 }
993 if (card_is_dvb(dev))
994 request_module_depend("saa7134-dvb",&need_dvb);
995
996 v4l2_prio_init(&dev->prio);
997
998 /* register v4l devices */
999 dev->video_dev = vdev_init(dev,&saa7134_video_template,"video");
1000 err = video_register_device(dev->video_dev,VFL_TYPE_GRABBER,
1001 video_nr[dev->nr]);
1002 if (err < 0) {
1003 printk(KERN_INFO "%s: can't register video device\n",
1004 dev->name);
1005 goto fail4;
1006 }
1007 printk(KERN_INFO "%s: registered device video%d [v4l2]\n",
1008 dev->name,dev->video_dev->minor & 0x1f);
1009
1010 dev->vbi_dev = vdev_init(dev,&saa7134_vbi_template,"vbi");
1011 err = video_register_device(dev->vbi_dev,VFL_TYPE_VBI,
1012 vbi_nr[dev->nr]);
1013 if (err < 0)
1014 goto fail4;
1015 printk(KERN_INFO "%s: registered device vbi%d\n",
1016 dev->name,dev->vbi_dev->minor & 0x1f);
1017
1018 if (card_has_radio(dev)) {
1019 dev->radio_dev = vdev_init(dev,&saa7134_radio_template,"radio");
1020 err = video_register_device(dev->radio_dev,VFL_TYPE_RADIO,
1021 radio_nr[dev->nr]);
1022 if (err < 0)
1023 goto fail4;
1024 printk(KERN_INFO "%s: registered device radio%d\n",
1025 dev->name,dev->radio_dev->minor & 0x1f);
1026 }
1027
1028 /* register oss devices */
1029 switch (dev->pci->device) {
1030 case PCI_DEVICE_ID_PHILIPS_SAA7134:
1031 case PCI_DEVICE_ID_PHILIPS_SAA7133:
1032 case PCI_DEVICE_ID_PHILIPS_SAA7135:
1033 if (oss) {
1034 err = dev->oss.minor_dsp =
1035 register_sound_dsp(&saa7134_dsp_fops,
1036 dsp_nr[dev->nr]);
1037 if (err < 0) {
1038 goto fail4;
1039 }
1040 printk(KERN_INFO "%s: registered device dsp%d\n",
1041 dev->name,dev->oss.minor_dsp >> 4);
1042
1043 err = dev->oss.minor_mixer =
1044 register_sound_mixer(&saa7134_mixer_fops,
1045 mixer_nr[dev->nr]);
1046 if (err < 0)
1047 goto fail5;
1048 printk(KERN_INFO "%s: registered device mixer%d\n",
1049 dev->name,dev->oss.minor_mixer >> 4);
1050 }
1051 break;
1052 }
1053
1054 /* everything worked */
1055 pci_set_drvdata(pci_dev,dev);
1056 saa7134_devcount++;
1057
1058 down(&devlist_lock);
1059 list_for_each(item,&mops_list) {
1060 mops = list_entry(item, struct saa7134_mpeg_ops, next);
1061 mpeg_ops_attach(mops, dev);
1062 }
1063 list_add_tail(&dev->devlist,&saa7134_devlist);
1064 up(&devlist_lock);
1065
1066 /* check for signal */
1067 saa7134_irq_video_intl(dev);
1068 return 0;
1069
1070 fail5:
1071 switch (dev->pci->device) {
1072 case PCI_DEVICE_ID_PHILIPS_SAA7134:
1073 case PCI_DEVICE_ID_PHILIPS_SAA7133:
1074 case PCI_DEVICE_ID_PHILIPS_SAA7135:
1075 if (oss)
1076 unregister_sound_dsp(dev->oss.minor_dsp);
1077 break;
1078 }
1079 fail4:
1080 saa7134_unregister_video(dev);
1081 saa7134_i2c_unregister(dev);
1082 free_irq(pci_dev->irq, dev);
1083 fail3:
1084 saa7134_hwfini(dev);
1085 iounmap(dev->lmmio);
1086 fail2:
1087 release_mem_region(pci_resource_start(pci_dev,0),
1088 pci_resource_len(pci_dev,0));
1089 fail1:
1090 kfree(dev);
1091 return err;
1092 }
1093
1094 static void __devexit saa7134_finidev(struct pci_dev *pci_dev)
1095 {
1096 struct saa7134_dev *dev = pci_get_drvdata(pci_dev);
1097 struct list_head *item;
1098 struct saa7134_mpeg_ops *mops;
1099
1100 /* debugging ... */
1101 if (irq_debug) {
1102 u32 report = saa_readl(SAA7134_IRQ_REPORT);
1103 u32 status = saa_readl(SAA7134_IRQ_STATUS);
1104 print_irqstatus(dev,42,report,status);
1105 }
1106
1107 /* disable peripheral devices */
1108 saa_writeb(SAA7134_SPECIAL_MODE,0);
1109
1110 /* shutdown hardware */
1111 saa_writel(SAA7134_IRQ1,0);
1112 saa_writel(SAA7134_IRQ2,0);
1113 saa_writel(SAA7134_MAIN_CTRL,0);
1114
1115 /* shutdown subsystems */
1116 saa7134_hwfini(dev);
1117
1118 /* unregister */
1119 down(&devlist_lock);
1120 list_del(&dev->devlist);
1121 list_for_each(item,&mops_list) {
1122 mops = list_entry(item, struct saa7134_mpeg_ops, next);
1123 mpeg_ops_detach(mops, dev);
1124 }
1125 up(&devlist_lock);
1126 saa7134_devcount--;
1127
1128 saa7134_i2c_unregister(dev);
1129 switch (dev->pci->device) {
1130 case PCI_DEVICE_ID_PHILIPS_SAA7134:
1131 case PCI_DEVICE_ID_PHILIPS_SAA7133:
1132 case PCI_DEVICE_ID_PHILIPS_SAA7135:
1133 if (oss) {
1134 unregister_sound_mixer(dev->oss.minor_mixer);
1135 unregister_sound_dsp(dev->oss.minor_dsp);
1136 }
1137 break;
1138 }
1139 saa7134_unregister_video(dev);
1140
1141 /* release ressources */
1142 free_irq(pci_dev->irq, dev);
1143 iounmap(dev->lmmio);
1144 release_mem_region(pci_resource_start(pci_dev,0),
1145 pci_resource_len(pci_dev,0));
1146
1147 #if 0 /* causes some trouble when reinserting the driver ... */
1148 pci_disable_device(pci_dev);
1149 #endif
1150 pci_set_drvdata(pci_dev, NULL);
1151
1152 /* free memory */
1153 kfree(dev);
1154 }
1155
1156 /* ----------------------------------------------------------- */
1157
1158 int saa7134_ts_register(struct saa7134_mpeg_ops *ops)
1159 {
1160 struct list_head *item;
1161 struct saa7134_dev *dev;
1162
1163 down(&devlist_lock);
1164 list_for_each(item,&saa7134_devlist) {
1165 dev = list_entry(item, struct saa7134_dev, devlist);
1166 mpeg_ops_attach(ops, dev);
1167 }
1168 list_add_tail(&ops->next,&mops_list);
1169 up(&devlist_lock);
1170 return 0;
1171 }
1172
1173 void saa7134_ts_unregister(struct saa7134_mpeg_ops *ops)
1174 {
1175 struct list_head *item;
1176 struct saa7134_dev *dev;
1177
1178 down(&devlist_lock);
1179 list_del(&ops->next);
1180 list_for_each(item,&saa7134_devlist) {
1181 dev = list_entry(item, struct saa7134_dev, devlist);
1182 mpeg_ops_detach(ops, dev);
1183 }
1184 up(&devlist_lock);
1185 }
1186
1187 EXPORT_SYMBOL(saa7134_ts_register);
1188 EXPORT_SYMBOL(saa7134_ts_unregister);
1189
1190 /* ----------------------------------------------------------- */
1191
1192 static struct pci_driver saa7134_pci_driver = {
1193 .name = "saa7134",
1194 .id_table = saa7134_pci_tbl,
1195 .probe = saa7134_initdev,
1196 .remove = __devexit_p(saa7134_finidev),
1197 };
1198
1199 static int saa7134_init(void)
1200 {
1201 INIT_LIST_HEAD(&saa7134_devlist);
1202 printk(KERN_INFO "saa7130/34: v4l2 driver version %d.%d.%d loaded\n",
1203 (SAA7134_VERSION_CODE >> 16) & 0xff,
1204 (SAA7134_VERSION_CODE >> 8) & 0xff,
1205 SAA7134_VERSION_CODE & 0xff);
1206 #ifdef SNAPSHOT
1207 printk(KERN_INFO "saa7130/34: snapshot date %04d-%02d-%02d\n",
1208 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
1209 #endif
1210 return pci_module_init(&saa7134_pci_driver);
1211 }
1212
1213 static void saa7134_fini(void)
1214 {
1215 #ifdef CONFIG_MODULES
1216 if (pending_registered)
1217 unregister_module_notifier(&pending_notifier);
1218 #endif
1219 pci_unregister_driver(&saa7134_pci_driver);
1220 }
1221
1222 module_init(saa7134_init);
1223 module_exit(saa7134_fini);
1224
1225 /* ----------------------------------------------------------- */
1226
1227 EXPORT_SYMBOL(saa7134_print_ioctl);
1228 EXPORT_SYMBOL(saa7134_i2c_call_clients);
1229 EXPORT_SYMBOL(saa7134_devlist);
1230 EXPORT_SYMBOL(saa7134_boards);
1231
1232 /* ----------------------------------------------------------- */
1233 /*
1234 * Local variables:
1235 * c-basic-offset: 8
1236 * End:
1237 */
Verdex Pro support