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