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 #if 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 #if 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 #if 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 #if 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                 printk(KERN_WARNING "%s/irq: looping -- clearing enable bits\n",dev->name);
 611                 /* disable all irqs */
 612                 saa_writel(SAA7134_IRQ1,0);
 613                 saa_writel(SAA7134_IRQ2,0);
 614         }
 615
 616  out:
 617         return IRQ_RETVAL(handled);
 618 }
 619
 620 /* ------------------------------------------------------------------ */
 621
 622 /* early init (no i2c, no irq) */
 623 static int saa7134_hwinit1(struct saa7134_dev *dev)
 624 {
 625         dprintk("hwinit1\n");
 626
 627         saa_writel(SAA7134_IRQ1, 0);
 628         saa_writel(SAA7134_IRQ2, 0);
 629         init_MUTEX(&dev->lock);
 630         dev->slock = SPIN_LOCK_UNLOCKED;
 631
 632         saa7134_track_gpio(dev,"pre-init");
 633         saa7134_video_init1(dev);
 634         saa7134_vbi_init1(dev);
 635         if (card_has_ts(dev))
 636                 saa7134_ts_init1(dev);
 637         saa7134_input_init1(dev);
 638
 639         switch (dev->pci->device) {
 640         case PCI_DEVICE_ID_PHILIPS_SAA7134:
 641         case PCI_DEVICE_ID_PHILIPS_SAA7133:
 642         case PCI_DEVICE_ID_PHILIPS_SAA7135:
 643                 saa7134_oss_init1(dev);
 644                 break;
 645         }
 646
 647         /* RAM FIFO config */
 648         saa_writel(SAA7134_FIFO_SIZE, 0x08070503);
 649         saa_writel(SAA7134_THRESHOULD,0x02020202);
 650
 651         /* enable audio + video processing */
 652         saa_writel(SAA7134_MAIN_CTRL,
 653                    SAA7134_MAIN_CTRL_VPLLE |
 654                    SAA7134_MAIN_CTRL_APLLE |
 655                    SAA7134_MAIN_CTRL_EXOSC |
 656                    SAA7134_MAIN_CTRL_EVFE1 |
 657                    SAA7134_MAIN_CTRL_EVFE2 |
 658                    SAA7134_MAIN_CTRL_ESFE  |
 659                    SAA7134_MAIN_CTRL_EBADC |
 660                    SAA7134_MAIN_CTRL_EBDAC);
 661
 662         /* enable peripheral devices */
 663         saa_writeb(SAA7134_SPECIAL_MODE, 0x01);
 664
 665         /* set vertical line numbering start (vbi needs this) */
 666         saa_writeb(SAA7134_SOURCE_TIMING2, 0x20);
 667
 668         return 0;
 669 }
 670
 671 /* late init (with i2c + irq) */
 672 static int saa7134_hwinit2(struct saa7134_dev *dev)
 673 {
 674         dprintk("hwinit2\n");
 675
 676         saa7134_video_init2(dev);
 677         saa7134_tvaudio_init2(dev);
 678
 679         /* enable IRQ's */
 680         saa_writel(SAA7134_IRQ1, 0);
 681         saa_writel(SAA7134_IRQ2,
 682                    SAA7134_IRQ2_INTE_GPIO18  |
 683                    SAA7134_IRQ2_INTE_GPIO18A |
 684                    SAA7134_IRQ2_INTE_GPIO16  |
 685                    SAA7134_IRQ2_INTE_SC2     |
 686                    SAA7134_IRQ2_INTE_SC1     |
 687                    SAA7134_IRQ2_INTE_SC0     |
 688                    /* SAA7134_IRQ2_INTE_DEC5    |  FIXME: TRIG_ERR ??? */
 689                    SAA7134_IRQ2_INTE_DEC3    |
 690                    SAA7134_IRQ2_INTE_DEC2    |
 691                    /* SAA7134_IRQ2_INTE_DEC1    | */
 692                    SAA7134_IRQ2_INTE_DEC0    |
 693                    SAA7134_IRQ2_INTE_PE      |
 694                    SAA7134_IRQ2_INTE_AR);
 695
 696         return 0;
 697 }
 698
 699 /* shutdown */
 700 static int saa7134_hwfini(struct saa7134_dev *dev)
 701 {
 702         dprintk("hwfini\n");
 703
 704         switch (dev->pci->device) {
 705         case PCI_DEVICE_ID_PHILIPS_SAA7134:
 706         case PCI_DEVICE_ID_PHILIPS_SAA7133:
 707         case PCI_DEVICE_ID_PHILIPS_SAA7135:
 708                 saa7134_oss_fini(dev);
 709                 break;
 710         }
 711         if (card_has_ts(dev))
 712                 saa7134_ts_fini(dev);
 713         saa7134_input_fini(dev);
 714         saa7134_vbi_fini(dev);
 715         saa7134_video_fini(dev);
 716         saa7134_tvaudio_fini(dev);
 717         return 0;
 718 }
 719
 720 static void __devinit must_configure_manually(void)
 721 {
 722         unsigned int i,p;
 723
 724         printk(KERN_WARNING
 725                "saa7134: <rant>\n"
 726                "saa7134:  Congratulations!  Your TV card vendor saved a few\n"
 727                "saa7134:  cents for a eeprom, thus your pci board has no\n"
 728                "saa7134:  subsystem ID and I can't identify it automatically\n"
 729                "saa7134: </rant>\n"
 730                "saa7134: I feel better now.  Ok, here are the good news:\n"
 731                "saa7134: You can use the card=<nr> insmod option to specify\n"
 732                "saa7134: which board do you have.  The list:\n");
 733         for (i = 0; i < saa7134_bcount; i++) {
 734                 printk(KERN_WARNING "saa7134:   card=%d -> %-40.40s",
 735                        i,saa7134_boards[i].name);
 736                 for (p = 0; saa7134_pci_tbl[p].driver_data; p++) {
 737                         if (saa7134_pci_tbl[p].driver_data != i)
 738                                 continue;
 739                         printk(" %04x:%04x",
 740                                saa7134_pci_tbl[p].subvendor,
 741                                saa7134_pci_tbl[p].subdevice);
 742                 }
 743                 printk("\n");
 744         }
 745 }
 746
 747 static struct video_device *vdev_init(struct saa7134_dev *dev,
 748                                       struct video_device *template,
 749                                       char *type)
 750 {
 751         struct video_device *vfd;
 752
 753         vfd = video_device_alloc();
 754         if (NULL == vfd)
 755                 return NULL;
 756         *vfd = *template;
 757         vfd->minor   = -1;
 758         vfd->dev     = &dev->pci->dev;
 759         vfd->release = video_device_release;
 760         snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)",
 761                  dev->name, type, saa7134_boards[dev->board].name);
 762         return vfd;
 763 }
 764
 765 static void saa7134_unregister_video(struct saa7134_dev *dev)
 766 {
 767         if (dev->video_dev) {
 768                 if (-1 != dev->video_dev->minor)
 769                         video_unregister_device(dev->video_dev);
 770                 else
 771                         video_device_release(dev->video_dev);
 772                 dev->video_dev = NULL;
 773         }
 774         if (dev->ts_dev) {
 775                 if (-1 != dev->ts_dev->minor)
 776                         video_unregister_device(dev->ts_dev);
 777                 else
 778                         video_device_release(dev->ts_dev);
 779                 dev->ts_dev = NULL;
 780         }
 781         if (dev->vbi_dev) {
 782                 if (-1 != dev->vbi_dev->minor)
 783                         video_unregister_device(dev->vbi_dev);
 784                 else
 785                         video_device_release(dev->vbi_dev);
 786                 dev->vbi_dev = NULL;
 787         }
 788         if (dev->radio_dev) {
 789                 if (-1 != dev->radio_dev->minor)
 790                         video_unregister_device(dev->radio_dev);
 791                 else
 792                         video_device_release(dev->radio_dev);
 793                 dev->radio_dev = NULL;
 794         }
 795 }
 796
 797 static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
 798                                      const struct pci_device_id *pci_id)
 799 {
 800         struct saa7134_dev *dev;
 801         int err;
 802
 803         dev = kmalloc(sizeof(*dev),GFP_KERNEL);
 804         if (NULL == dev)
 805                 return -ENOMEM;
 806         memset(dev,0,sizeof(*dev));
 807
 808         /* pci init */
 809         dev->pci = pci_dev;
 810         if (pci_enable_device(pci_dev)) {
 811                 err = -EIO;
 812                 goto fail1;
 813         }
 814         sprintf(dev->name,"saa%x[%d]",pci_dev->device,saa7134_devcount);
 815
 816         /* pci quirks */
 817         if (pci_pci_problems) {
 818                 if (pci_pci_problems & PCIPCI_TRITON)
 819                         printk(KERN_INFO "%s: quirk: PCIPCI_TRITON\n", dev->name);
 820                 if (pci_pci_problems & PCIPCI_NATOMA)
 821                         printk(KERN_INFO "%s: quirk: PCIPCI_NATOMA\n", dev->name);
 822                 if (pci_pci_problems & PCIPCI_VIAETBF)
 823                         printk(KERN_INFO "%s: quirk: PCIPCI_VIAETBF\n", dev->name);
 824                 if (pci_pci_problems & PCIPCI_VSFX)
 825                         printk(KERN_INFO "%s: quirk: PCIPCI_VSFX\n",dev->name);
 826 #ifdef PCIPCI_ALIMAGIK
 827                 if (pci_pci_problems & PCIPCI_ALIMAGIK) {
 828                         printk(KERN_INFO "%s: quirk: PCIPCI_ALIMAGIK -- latency fixup\n",
 829                                dev->name);
 830                         latency = 0x0A;
 831                 }
 832 #endif
 833         }
 834         if (UNSET != latency) {
 835                 printk(KERN_INFO "%s: setting pci latency timer to %d\n",
 836                        dev->name,latency);
 837                 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
 838         }
 839
 840         /* print pci info */
 841         pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
 842         pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER,  &dev->pci_lat);
 843         printk(KERN_INFO "%s: found at %s, rev: %d, irq: %d, "
 844                "latency: %d, mmio: 0x%lx\n", dev->name,
 845                pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
 846                dev->pci_lat,pci_resource_start(pci_dev,0));
 847         pci_set_master(pci_dev);
 848         if (!pci_dma_supported(pci_dev,0xffffffff)) {
 849                 printk("%s: Oops: no 32bit PCI DMA ???\n",dev->name);
 850                 err = -EIO;
 851                 goto fail1;
 852         }
 853
 854         /* board config */
 855         dev->board = pci_id->driver_data;
 856         if (card[saa7134_devcount] >= 0 &&
 857             card[saa7134_devcount] < saa7134_bcount)
 858                 dev->board = card[saa7134_devcount];
 859         if (SAA7134_BOARD_NOAUTO == dev->board) {
 860                 must_configure_manually();
 861                 dev->board = SAA7134_BOARD_UNKNOWN;
 862         }
 863         dev->tuner_type = saa7134_boards[dev->board].tuner_type;
 864         if (UNSET != tuner[saa7134_devcount])
 865                 dev->tuner_type = tuner[saa7134_devcount];
 866         printk(KERN_INFO "%s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
 867                dev->name,pci_dev->subsystem_vendor,
 868                pci_dev->subsystem_device,saa7134_boards[dev->board].name,
 869                dev->board, card[saa7134_devcount] == dev->board ?
 870                "insmod option" : "autodetected");
 871
 872         /* get mmio */
 873         if (!request_mem_region(pci_resource_start(pci_dev,0),
 874                                 pci_resource_len(pci_dev,0),
 875                                 dev->name)) {
 876                 err = -EBUSY;
 877                 printk(KERN_ERR "%s: can't get MMIO memory @ 0x%lx\n",
 878                        dev->name,pci_resource_start(pci_dev,0));
 879                 goto fail1;
 880         }
 881         dev->lmmio = ioremap(pci_resource_start(pci_dev,0), 0x1000);
 882         dev->bmmio = (__u8*)dev->lmmio;
 883         if (NULL == dev->lmmio) {
 884                 err = -EIO;
 885                 printk(KERN_ERR "%s: can't ioremap() MMIO memory\n",
 886                        dev->name);
 887                 goto fail2;
 888         }
 889
 890         /* initialize hardware #1 */
 891         saa7134_board_init(dev);
 892         saa7134_hwinit1(dev);
 893
 894         /* get irq */
 895         err = request_irq(pci_dev->irq, saa7134_irq,
 896                           SA_SHIRQ | SA_INTERRUPT, dev->name, dev);
 897         if (err < 0) {
 898                 printk(KERN_ERR "%s: can't get IRQ %d\n",
 899                        dev->name,pci_dev->irq);
 900                 goto fail3;
 901         }
 902
 903         /* wait a bit, register i2c bus */
 904         set_current_state(TASK_INTERRUPTIBLE);
 905         schedule_timeout(HZ/10);
 906         saa7134_i2c_register(dev);
 907
 908         /* initialize hardware #2 */
 909         saa7134_hwinit2(dev);
 910
 911         /* load i2c helpers */
 912         if (TUNER_ABSENT != dev->tuner_type)
 913                 request_module("tuner");
 914         if (saa7134_boards[dev->board].need_tda9887)
 915                 request_module("tda9887");
 916         if (card_has_ts(dev))
 917                 request_module("saa6752hs");
 918
 919 #ifdef VIDIOC_G_PRIORITY
 920         v4l2_prio_init(&dev->prio);
 921 #endif
 922
 923         /* register v4l devices */
 924         dev->video_dev = vdev_init(dev,&saa7134_video_template,"video");
 925         err = video_register_device(dev->video_dev,VFL_TYPE_GRABBER,
 926                                     video_nr[saa7134_devcount]);
 927         if (err < 0) {
 928                 printk(KERN_INFO "%s: can't register video device\n",
 929                        dev->name);
 930                 goto fail4;
 931         }
 932         printk(KERN_INFO "%s: registered device video%d [v4l2]\n",
 933                dev->name,dev->video_dev->minor & 0x1f);
 934
 935         if (card_has_ts(dev)) {
 936                 dev->ts_dev = vdev_init(dev,&saa7134_ts_template,"ts");
 937                 err = video_register_device(dev->ts_dev,VFL_TYPE_GRABBER,
 938                                             ts_nr[saa7134_devcount]);
 939                 if (err < 0) {
 940                         printk(KERN_INFO "%s: can't register video device\n",
 941                                dev->name);
 942                         goto fail4;
 943                 }
 944                 printk(KERN_INFO "%s: registered device video%d [ts]\n",
 945                        dev->name,dev->ts_dev->minor & 0x1f);
 946         }
 947
 948         dev->vbi_dev = vdev_init(dev,&saa7134_vbi_template,"vbi");
 949         err = video_register_device(dev->vbi_dev,VFL_TYPE_VBI,
 950                                     vbi_nr[saa7134_devcount]);
 951         if (err < 0)
 952                 goto fail4;
 953         printk(KERN_INFO "%s: registered device vbi%d\n",
 954                dev->name,dev->vbi_dev->minor & 0x1f);
 955
 956         if (card_has_radio(dev)) {
 957                 dev->radio_dev = vdev_init(dev,&saa7134_radio_template,"radio");
 958                 err = video_register_device(dev->radio_dev,VFL_TYPE_RADIO,
 959                                             radio_nr[saa7134_devcount]);
 960                 if (err < 0)
 961                         goto fail4;
 962                 printk(KERN_INFO "%s: registered device radio%d\n",
 963                        dev->name,dev->radio_dev->minor & 0x1f);
 964         }
 965
 966         /* register oss devices */
 967         switch (dev->pci->device) {
 968         case PCI_DEVICE_ID_PHILIPS_SAA7134:
 969         case PCI_DEVICE_ID_PHILIPS_SAA7133:
 970         case PCI_DEVICE_ID_PHILIPS_SAA7135:
 971                 if (oss) {
 972                         err = dev->oss.minor_dsp =
 973                                 register_sound_dsp(&saa7134_dsp_fops,
 974                                                    dsp_nr[saa7134_devcount]);
 975                         if (err < 0) {
 976                                 goto fail4;
 977                         }
 978                         printk(KERN_INFO "%s: registered device dsp%d\n",
 979                                dev->name,dev->oss.minor_dsp >> 4);
 980
 981                         err = dev->oss.minor_mixer =
 982                                 register_sound_mixer(&saa7134_mixer_fops,
 983                                                      mixer_nr[saa7134_devcount]);
 984                         if (err < 0)
 985                                 goto fail5;
 986                         printk(KERN_INFO "%s: registered device mixer%d\n",
 987                                dev->name,dev->oss.minor_mixer >> 4);
 988                 }
 989                 break;
 990         }
 991
 992         /* everything worked */
 993         list_add_tail(&dev->devlist,&saa7134_devlist);
 994         pci_set_drvdata(pci_dev,dev);
 995         saa7134_devcount++;
 996         return 0;
 997
 998  fail5:
 999         switch (dev->pci->device) {
1000         case PCI_DEVICE_ID_PHILIPS_SAA7134:
1001         case PCI_DEVICE_ID_PHILIPS_SAA7133:
1002         case PCI_DEVICE_ID_PHILIPS_SAA7135:
1003                 if (oss)
1004                         unregister_sound_dsp(dev->oss.minor_dsp);
1005                 break;
1006         }
1007  fail4:
1008         saa7134_unregister_video(dev);
1009         saa7134_i2c_unregister(dev);
1010         free_irq(pci_dev->irq, dev);
1011  fail3:
1012         saa7134_hwfini(dev);
1013         iounmap(dev->lmmio);
1014  fail2:
1015         release_mem_region(pci_resource_start(pci_dev,0),
1016                            pci_resource_len(pci_dev,0));
1017  fail1:
1018         kfree(dev);
1019         return err;
1020 }
1021
1022 static void __devexit saa7134_finidev(struct pci_dev *pci_dev)
1023 {
1024         struct saa7134_dev *dev = pci_get_drvdata(pci_dev);
1025
1026         /* debugging ... */
1027         if (irq_debug) {
1028                 u32 report = saa_readl(SAA7134_IRQ_REPORT);
1029                 u32 status = saa_readl(SAA7134_IRQ_STATUS);
1030                 print_irqstatus(dev,42,report,status);
1031         }
1032
1033         /* disable peripheral devices */
1034         saa_writeb(SAA7134_SPECIAL_MODE,0);
1035
1036         /* shutdown hardware */
1037         saa_writel(SAA7134_IRQ1,0);
1038         saa_writel(SAA7134_IRQ2,0);
1039         saa_writel(SAA7134_MAIN_CTRL,0);
1040
1041         /* shutdown subsystems */
1042         saa7134_hwfini(dev);
1043
1044         /* unregister */
1045         saa7134_i2c_unregister(dev);
1046         switch (dev->pci->device) {
1047         case PCI_DEVICE_ID_PHILIPS_SAA7134:
1048         case PCI_DEVICE_ID_PHILIPS_SAA7133:
1049         case PCI_DEVICE_ID_PHILIPS_SAA7135:
1050                 if (oss) {
1051                         unregister_sound_mixer(dev->oss.minor_mixer);
1052                         unregister_sound_dsp(dev->oss.minor_dsp);
1053                 }
1054                 break;
1055         }
1056         saa7134_unregister_video(dev);
1057
1058         /* release ressources */
1059         free_irq(pci_dev->irq, dev);
1060         iounmap(dev->lmmio);
1061         release_mem_region(pci_resource_start(pci_dev,0),
1062                            pci_resource_len(pci_dev,0));
1063
1064 #if 0  /* causes some trouble when reinserting the driver ... */
1065         pci_disable_device(pci_dev);
1066 #endif
1067         pci_set_drvdata(pci_dev, NULL);
1068
1069         /* free memory */
1070         list_del(&dev->devlist);
1071         saa7134_devcount--;
1072         kfree(dev);
1073 }
1074
1075 static struct pci_driver saa7134_pci_driver = {
1076         .name     = "saa7134",
1077         .id_table = saa7134_pci_tbl,
1078         .probe    = saa7134_initdev,
1079         .remove   = saa7134_finidev,
1080 };
1081
1082 static int saa7134_init(void)
1083 {
1084         INIT_LIST_HEAD(&saa7134_devlist);
1085         printk(KERN_INFO "saa7130/34: v4l2 driver version %d.%d.%d loaded\n",
1086                (SAA7134_VERSION_CODE >> 16) & 0xff,
1087                (SAA7134_VERSION_CODE >>  8) & 0xff,
1088                SAA7134_VERSION_CODE & 0xff);
1089 #ifdef SNAPSHOT
1090         printk(KERN_INFO "saa7130/34: snapshot date %04d-%02d-%02d\n",
1091                SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
1092 #endif
1093         return pci_module_init(&saa7134_pci_driver);
1094 }
1095
1096 static void saa7134_fini(void)
1097 {
1098         pci_unregister_driver(&saa7134_pci_driver);
1099 }
1100
1101 module_init(saa7134_init);
1102 module_exit(saa7134_fini);
1103
1104 /* ----------------------------------------------------------- */
1105 /*
1106  * Local variables:
1107  * c-basic-offset: 8
1108  * End:
1109  */