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

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