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