drivers/media/video/saa7134/saa7134-core.c

   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  */