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