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