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 alsa = 0;
  57 module_param(alsa, int, 0644);
  58 MODULE_PARM_DESC(alsa,"enable ALSA DMA sound [dmasound]");
  59
  60 static unsigned int oss = 0;
  61 module_param(oss, int, 0644);
  62 MODULE_PARM_DESC(oss,"enable OSS DMA sound [dmasound]");
  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 tuner[]    = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
  72 static unsigned int card[]     = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
  73
  74 module_param_array(video_nr, int, NULL, 0444);
  75 module_param_array(vbi_nr,   int, NULL, 0444);
  76 module_param_array(radio_nr, int, NULL, 0444);
  77 module_param_array(tuner,    int, NULL, 0444);
  78 module_param_array(card,     int, NULL, 0444);
  79
  80 MODULE_PARM_DESC(video_nr, "video device number");
  81 MODULE_PARM_DESC(vbi_nr,   "vbi device number");
  82 MODULE_PARM_DESC(radio_nr, "radio device number");
  83 MODULE_PARM_DESC(tuner,    "tuner type");
  84 MODULE_PARM_DESC(card,     "card type");
  85
  86 static DECLARE_MUTEX(devlist_lock);
  87 LIST_HEAD(saa7134_devlist);
  88 static LIST_HEAD(mops_list);
  89 static unsigned int saa7134_devcount;
  90
  91 int (*dmasound_init)(struct saa7134_dev *dev);
  92 int (*dmasound_exit)(struct saa7134_dev *dev);
  93
  94 #define dprintk(fmt, arg...)    if (core_debug) \
  95         printk(KERN_DEBUG "%s/core: " fmt, dev->name , ## arg)
  96
  97 /* ------------------------------------------------------------------ */
  98 /* debug help functions                                               */
  99
 100 static const char *v4l1_ioctls[] = {
 101         "0", "GCAP", "GCHAN", "SCHAN", "GTUNER", "STUNER", "GPICT", "SPICT",
 102         "CCAPTURE", "GWIN", "SWIN", "GFBUF", "SFBUF", "KEY", "GFREQ",
 103         "SFREQ", "GAUDIO", "SAUDIO", "SYNC", "MCAPTURE", "GMBUF", "GUNIT",
 104         "GCAPTURE", "SCAPTURE", "SPLAYMODE", "SWRITEMODE", "GPLAYINFO",
 105         "SMICROCODE", "GVBIFMT", "SVBIFMT" };
 106 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
 107
 108 static const char *v4l2_ioctls[] = {
 109         "QUERYCAP", "1", "ENUM_PIXFMT", "ENUM_FBUFFMT", "G_FMT", "S_FMT",
 110         "G_COMP", "S_COMP", "REQBUFS", "QUERYBUF", "G_FBUF", "S_FBUF",
 111         "G_WIN", "S_WIN", "PREVIEW", "QBUF", "16", "DQBUF", "STREAMON",
 112         "STREAMOFF", "G_PERF", "G_PARM", "S_PARM", "G_STD", "S_STD",
 113         "ENUMSTD", "ENUMINPUT", "G_CTRL", "S_CTRL", "G_TUNER", "S_TUNER",
 114         "G_FREQ", "S_FREQ", "G_AUDIO", "S_AUDIO", "35", "QUERYCTRL",
 115         "QUERYMENU", "G_INPUT", "S_INPUT", "ENUMCVT", "41", "42", "43",
 116         "44", "45",  "G_OUTPUT", "S_OUTPUT", "ENUMOUTPUT", "G_AUDOUT",
 117         "S_AUDOUT", "ENUMFX", "G_EFFECT", "S_EFFECT", "G_MODULATOR",
 118         "S_MODULATOR"
 119 };
 120 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
 121
 122 static const char *osspcm_ioctls[] = {
 123         "RESET", "SYNC", "SPEED", "STEREO", "GETBLKSIZE", "SETFMT",
 124         "CHANNELS", "?", "POST", "SUBDIVIDE", "SETFRAGMENT", "GETFMTS",
 125         "GETOSPACE", "GETISPACE", "NONBLOCK", "GETCAPS", "GET/SETTRIGGER",
 126         "GETIPTR", "GETOPTR", "MAPINBUF", "MAPOUTBUF", "SETSYNCRO",
 127         "SETDUPLEX", "GETODELAY"
 128 };
 129 #define OSSPCM_IOCTLS ARRAY_SIZE(v4l2_ioctls)
 130
 131 void saa7134_print_ioctl(char *name, unsigned int cmd)
 132 {
 133         char *dir;
 134
 135         switch (_IOC_DIR(cmd)) {
 136         case _IOC_NONE:              dir = "--"; break;
 137         case _IOC_READ:              dir = "r-"; break;
 138         case _IOC_WRITE:             dir = "-w"; break;
 139         case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
 140         default:                     dir = "??"; break;
 141         }
 142         switch (_IOC_TYPE(cmd)) {
 143         case 'v':
 144                 printk(KERN_DEBUG "%s: ioctl 0x%08x (v4l1, %s, VIDIOC%s)\n",
 145                        name, cmd, dir, (_IOC_NR(cmd) < V4L1_IOCTLS) ?
 146                        v4l1_ioctls[_IOC_NR(cmd)] : "???");
 147                 break;
 148         case 'V':
 149                 printk(KERN_DEBUG "%s: ioctl 0x%08x (v4l2, %s, VIDIOC_%s)\n",
 150                        name, cmd, dir, (_IOC_NR(cmd) < V4L2_IOCTLS) ?
 151                        v4l2_ioctls[_IOC_NR(cmd)] : "???");
 152                 break;
 153         case 'P':
 154                 printk(KERN_DEBUG "%s: ioctl 0x%08x (oss dsp, %s, SNDCTL_DSP_%s)\n",
 155                        name, cmd, dir, (_IOC_NR(cmd) < OSSPCM_IOCTLS) ?
 156                        osspcm_ioctls[_IOC_NR(cmd)] : "???");
 157                 break;
 158         case 'M':
 159                 printk(KERN_DEBUG "%s: ioctl 0x%08x (oss mixer, %s, #%d)\n",
 160                        name, cmd, dir, _IOC_NR(cmd));
 161                 break;
 162         default:
 163                 printk(KERN_DEBUG "%s: ioctl 0x%08x (???, %s, #%d)\n",
 164                        name, cmd, dir, _IOC_NR(cmd));
 165         }
 166 }
 167
 168 void saa7134_track_gpio(struct saa7134_dev *dev, char *msg)
 169 {
 170         unsigned long mode,status;
 171
 172         if (!gpio_tracking)
 173                 return;
 174         /* rising SAA7134_GPIO_GPRESCAN reads the status */
 175         saa_andorb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN,0);
 176         saa_andorb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN,SAA7134_GPIO_GPRESCAN);
 177         mode   = saa_readl(SAA7134_GPIO_GPMODE0   >> 2) & 0xfffffff;
 178         status = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2) & 0xfffffff;
 179         printk(KERN_DEBUG
 180                "%s: gpio: mode=0x%07lx in=0x%07lx out=0x%07lx [%s]\n",
 181                dev->name, mode, (~mode) & status, mode & status, msg);
 182 }
 183
 184 /* ------------------------------------------------------------------ */
 185
 186
 187 /* ----------------------------------------------------------- */
 188 /* delayed request_module                                      */
 189
 190 #if defined(CONFIG_MODULES) && defined(MODULE)
 191 static int need_empress;
 192 static int need_dvb;
 193 static int need_alsa;
 194 static int need_oss;
 195
 196 static int pending_call(struct notifier_block *self, unsigned long state,
 197                         void *module)
 198 {
 199         if (module != THIS_MODULE || state != MODULE_STATE_LIVE)
 200                 return NOTIFY_DONE;
 201
 202         if (need_empress)
 203                 request_module("saa7134-empress");
 204         if (need_dvb)
 205                 request_module("saa7134-dvb");
 206         if (need_alsa)
 207                 request_module("saa7134-alsa");
 208         if (need_oss)
 209                 request_module("saa7134-oss");
 210         return NOTIFY_DONE;
 211 }
 212
 213 static int pending_registered;
 214 static struct notifier_block pending_notifier = {
 215         .notifier_call = pending_call,
 216 };
 217
 218 static void request_module_depend(char *name, int *flag)
 219 {
 220         int err;
 221         switch (THIS_MODULE->state) {
 222         case MODULE_STATE_COMING:
 223                 if (!pending_registered) {
 224                         err = 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 #define request_module_depend(name,flag)
 240 #endif /* CONFIG_MODULES */
 241
 242 /* ------------------------------------------------------------------ */
 243
 244 /* nr of (saa7134-)pages for the given buffer size */
 245 static int saa7134_buffer_pages(int size)
 246 {
 247         size  = PAGE_ALIGN(size);
 248         size += PAGE_SIZE; /* for non-page-aligned buffers */
 249         size /= 4096;
 250         return size;
 251 }
 252
 253 /* calc max # of buffers from size (must not exceed the 4MB virtual
 254  * address space per DMA channel) */
 255 int saa7134_buffer_count(unsigned int size, unsigned int count)
 256 {
 257         unsigned int maxcount;
 258
 259         maxcount = 1024 / saa7134_buffer_pages(size);
 260         if (count > maxcount)
 261                 count = maxcount;
 262         return count;
 263 }
 264
 265 int saa7134_buffer_startpage(struct saa7134_buf *buf)
 266 {
 267         return saa7134_buffer_pages(buf->vb.bsize) * buf->vb.i;
 268 }
 269
 270 unsigned long saa7134_buffer_base(struct saa7134_buf *buf)
 271 {
 272         unsigned long base;
 273
 274         base  = saa7134_buffer_startpage(buf) * 4096;
 275         base += buf->vb.dma.sglist[0].offset;
 276         return base;
 277 }
 278
 279 /* ------------------------------------------------------------------ */
 280
 281 int saa7134_pgtable_alloc(struct pci_dev *pci, struct saa7134_pgtable *pt)
 282 {
 283         __le32       *cpu;
 284         dma_addr_t   dma_addr;
 285
 286         cpu = pci_alloc_consistent(pci, SAA7134_PGTABLE_SIZE, &dma_addr);
 287         if (NULL == cpu)
 288                 return -ENOMEM;
 289         pt->size = SAA7134_PGTABLE_SIZE;
 290         pt->cpu  = cpu;
 291         pt->dma  = dma_addr;
 292         return 0;
 293 }
 294
 295 int saa7134_pgtable_build(struct pci_dev *pci, struct saa7134_pgtable *pt,
 296                           struct scatterlist *list, unsigned int length,
 297                           unsigned int startpage)
 298 {
 299         __le32        *ptr;
 300         unsigned int  i,p;
 301
 302         BUG_ON(NULL == pt || NULL == pt->cpu);
 303
 304         ptr = pt->cpu + startpage;
 305         for (i = 0; i < length; i++, list++)
 306                 for (p = 0; p * 4096 < list->length; p++, ptr++)
 307                         *ptr = cpu_to_le32(sg_dma_address(list) - list->offset);
 308         return 0;
 309 }
 310
 311 void saa7134_pgtable_free(struct pci_dev *pci, struct saa7134_pgtable *pt)
 312 {
 313         if (NULL == pt->cpu)
 314                 return;
 315         pci_free_consistent(pci, pt->size, pt->cpu, pt->dma);
 316         pt->cpu = NULL;
 317 }
 318
 319 /* ------------------------------------------------------------------ */
 320
 321 void saa7134_dma_free(struct saa7134_dev *dev,struct saa7134_buf *buf)
 322 {
 323         if (in_interrupt())
 324                 BUG();
 325
 326         videobuf_waiton(&buf->vb,0,0);
 327         videobuf_dma_pci_unmap(dev->pci, &buf->vb.dma);
 328         videobuf_dma_free(&buf->vb.dma);
 329         buf->vb.state = STATE_NEEDS_INIT;
 330 }
 331
 332 /* ------------------------------------------------------------------ */
 333
 334 int saa7134_buffer_queue(struct saa7134_dev *dev,
 335                          struct saa7134_dmaqueue *q,
 336                          struct saa7134_buf *buf)
 337 {
 338         struct saa7134_buf *next = NULL;
 339
 340         assert_spin_locked(&dev->slock);
 341         dprintk("buffer_queue %p\n",buf);
 342         if (NULL == q->curr) {
 343                 if (!q->need_two) {
 344                         q->curr = buf;
 345                         buf->activate(dev,buf,NULL);
 346                 } else if (list_empty(&q->queue)) {
 347                         list_add_tail(&buf->vb.queue,&q->queue);
 348                         buf->vb.state = STATE_QUEUED;
 349                 } else {
 350                         next = list_entry(q->queue.next,struct saa7134_buf,
 351                                           vb.queue);
 352                         q->curr = buf;
 353                         buf->activate(dev,buf,next);
 354                 }
 355         } else {
 356                 list_add_tail(&buf->vb.queue,&q->queue);
 357                 buf->vb.state = STATE_QUEUED;
 358         }
 359         return 0;
 360 }
 361
 362 void saa7134_buffer_finish(struct saa7134_dev *dev,
 363                            struct saa7134_dmaqueue *q,
 364                            unsigned int state)
 365 {
 366         assert_spin_locked(&dev->slock);
 367         dprintk("buffer_finish %p\n",q->curr);
 368
 369         /* finish current buffer */
 370         q->curr->vb.state = state;
 371         do_gettimeofday(&q->curr->vb.ts);
 372         wake_up(&q->curr->vb.done);
 373         q->curr = NULL;
 374 }
 375
 376 void saa7134_buffer_next(struct saa7134_dev *dev,
 377                          struct saa7134_dmaqueue *q)
 378 {
 379         struct saa7134_buf *buf,*next = NULL;
 380
 381         assert_spin_locked(&dev->slock);
 382         BUG_ON(NULL != q->curr);
 383
 384         if (!list_empty(&q->queue)) {
 385                 /* activate next one from queue */
 386                 buf = list_entry(q->queue.next,struct saa7134_buf,vb.queue);
 387                 dprintk("buffer_next %p [prev=%p/next=%p]\n",
 388                         buf,q->queue.prev,q->queue.next);
 389                 list_del(&buf->vb.queue);
 390                 if (!list_empty(&q->queue))
 391                         next = list_entry(q->queue.next,struct saa7134_buf,
 392                                           vb.queue);
 393                 q->curr = buf;
 394                 buf->activate(dev,buf,next);
 395                 dprintk("buffer_next #2 prev=%p/next=%p\n",
 396                         q->queue.prev,q->queue.next);
 397         } else {
 398                 /* nothing to do -- just stop DMA */
 399                 dprintk("buffer_next %p\n",NULL);
 400                 saa7134_set_dmabits(dev);
 401                 del_timer(&q->timeout);
 402         }
 403 }
 404
 405 void saa7134_buffer_timeout(unsigned long data)
 406 {
 407         struct saa7134_dmaqueue *q = (struct saa7134_dmaqueue*)data;
 408         struct saa7134_dev *dev = q->dev;
 409         unsigned long flags;
 410
 411         spin_lock_irqsave(&dev->slock,flags);
 412
 413         /* try to reset the hardware (SWRST) */
 414         saa_writeb(SAA7134_REGION_ENABLE, 0x00);
 415         saa_writeb(SAA7134_REGION_ENABLE, 0x80);
 416         saa_writeb(SAA7134_REGION_ENABLE, 0x00);
 417
 418         /* flag current buffer as failed,
 419            try to start over with the next one. */
 420         if (q->curr) {
 421                 dprintk("timeout on %p\n",q->curr);
 422                 saa7134_buffer_finish(dev,q,STATE_ERROR);
 423         }
 424         saa7134_buffer_next(dev,q);
 425         spin_unlock_irqrestore(&dev->slock,flags);
 426 }
 427
 428 /* ------------------------------------------------------------------ */
 429
 430 int saa7134_set_dmabits(struct saa7134_dev *dev)
 431 {
 432         u32 split, task=0, ctrl=0, irq=0;
 433         enum v4l2_field cap = V4L2_FIELD_ANY;
 434         enum v4l2_field ov  = V4L2_FIELD_ANY;
 435
 436         assert_spin_locked(&dev->slock);
 437
 438         /* video capture -- dma 0 + video task A */
 439         if (dev->video_q.curr) {
 440                 task |= 0x01;
 441                 ctrl |= SAA7134_MAIN_CTRL_TE0;
 442                 irq  |= SAA7134_IRQ1_INTE_RA0_1 |
 443                         SAA7134_IRQ1_INTE_RA0_0;
 444                 cap = dev->video_q.curr->vb.field;
 445         }
 446
 447         /* video capture -- dma 1+2 (planar modes) */
 448         if (dev->video_q.curr &&
 449             dev->video_q.curr->fmt->planar) {
 450                 ctrl |= SAA7134_MAIN_CTRL_TE4 |
 451                         SAA7134_MAIN_CTRL_TE5;
 452         }
 453
 454         /* screen overlay -- dma 0 + video task B */
 455         if (dev->ovenable) {
 456                 task |= 0x10;
 457                 ctrl |= SAA7134_MAIN_CTRL_TE1;
 458                 ov = dev->ovfield;
 459         }
 460
 461         /* vbi capture -- dma 0 + vbi task A+B */
 462         if (dev->vbi_q.curr) {
 463                 task |= 0x22;
 464                 ctrl |= SAA7134_MAIN_CTRL_TE2 |
 465                         SAA7134_MAIN_CTRL_TE3;
 466                 irq  |= SAA7134_IRQ1_INTE_RA0_7 |
 467                         SAA7134_IRQ1_INTE_RA0_6 |
 468                         SAA7134_IRQ1_INTE_RA0_5 |
 469                         SAA7134_IRQ1_INTE_RA0_4;
 470         }
 471
 472         /* audio capture -- dma 3 */
 473         if (dev->dmasound.dma_running) {
 474                 ctrl |= SAA7134_MAIN_CTRL_TE6;
 475                 irq  |= SAA7134_IRQ1_INTE_RA3_1 |
 476                         SAA7134_IRQ1_INTE_RA3_0;
 477         }
 478
 479         /* TS capture -- dma 5 */
 480         if (dev->ts_q.curr) {
 481                 ctrl |= SAA7134_MAIN_CTRL_TE5;
 482                 irq  |= SAA7134_IRQ1_INTE_RA2_3 |
 483                         SAA7134_IRQ1_INTE_RA2_2 |
 484                         SAA7134_IRQ1_INTE_RA2_1 |
 485                         SAA7134_IRQ1_INTE_RA2_0;
 486         }
 487
 488         /* set task conditions + field handling */
 489         if (V4L2_FIELD_HAS_BOTH(cap) || V4L2_FIELD_HAS_BOTH(ov) || cap == ov) {
 490                 /* default config -- use full frames */
 491                 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_A), 0x0d);
 492                 saa_writeb(SAA7134_TASK_CONDITIONS(TASK_B), 0x0d);
 493                 saa_writeb(SAA7134_FIELD_HANDLING(TASK_A),  0x02);
 494                 saa_writeb(SAA7134_FIELD_HANDLING(TASK_B),  0x02);
 495                 split = 0;
 496         } else {
 497                 /* split fields between tasks */
 498                 if (V4L2_FIELD_TOP == cap) {
 499                         /* odd A, even B, repeat */
 500                         saa_writeb(SAA7134_TASK_CONDITIONS(TASK_A), 0x0d);
 501                         saa_writeb(SAA7134_TASK_CONDITIONS(TASK_B), 0x0e);
 502                 } else {
 503                         /* odd B, even A, repeat */
 504                         saa_writeb(SAA7134_TASK_CONDITIONS(TASK_A), 0x0e);
 505                         saa_writeb(SAA7134_TASK_CONDITIONS(TASK_B), 0x0d);
 506                 }
 507                 saa_writeb(SAA7134_FIELD_HANDLING(TASK_A),  0x01);
 508                 saa_writeb(SAA7134_FIELD_HANDLING(TASK_B),  0x01);
 509                 split = 1;
 510         }
 511
 512         /* irqs */
 513         saa_writeb(SAA7134_REGION_ENABLE, task);
 514         saa_writel(SAA7134_IRQ1,          irq);
 515         saa_andorl(SAA7134_MAIN_CTRL,
 516                    SAA7134_MAIN_CTRL_TE0 |
 517                    SAA7134_MAIN_CTRL_TE1 |
 518                    SAA7134_MAIN_CTRL_TE2 |
 519                    SAA7134_MAIN_CTRL_TE3 |
 520                    SAA7134_MAIN_CTRL_TE4 |
 521                    SAA7134_MAIN_CTRL_TE5 |
 522                    SAA7134_MAIN_CTRL_TE6,
 523                    ctrl);
 524         dprintk("dmabits: task=0x%02x ctrl=0x%02x irq=0x%x split=%s\n",
 525                 task, ctrl, irq, split ? "no" : "yes");
 526
 527         return 0;
 528 }
 529
 530 /* ------------------------------------------------------------------ */
 531 /* IRQ handler + helpers                                              */
 532
 533 static char *irqbits[] = {
 534         "DONE_RA0", "DONE_RA1", "DONE_RA2", "DONE_RA3",
 535         "AR", "PE", "PWR_ON", "RDCAP", "INTL", "FIDT", "MMC",
 536         "TRIG_ERR", "CONF_ERR", "LOAD_ERR",
 537         "GPIO16?", "GPIO18", "GPIO22", "GPIO23"
 538 };
 539 #define IRQBITS ARRAY_SIZE(irqbits)
 540
 541 static void print_irqstatus(struct saa7134_dev *dev, int loop,
 542                             unsigned long report, unsigned long status)
 543 {
 544         unsigned int i;
 545
 546         printk(KERN_DEBUG "%s/irq[%d,%ld]: r=0x%lx s=0x%02lx",
 547                dev->name,loop,jiffies,report,status);
 548         for (i = 0; i < IRQBITS; i++) {
 549                 if (!(report & (1 << i)))
 550                         continue;
 551                 printk(" %s",irqbits[i]);
 552         }
 553         if (report & SAA7134_IRQ_REPORT_DONE_RA0) {
 554                 printk(" | RA0=%s,%s,%s,%ld",
 555                        (status & 0x40) ? "vbi"  : "video",
 556                        (status & 0x20) ? "b"    : "a",
 557                        (status & 0x10) ? "odd"  : "even",
 558                        (status & 0x0f));
 559         }
 560         printk("\n");
 561 }
 562
 563 static irqreturn_t saa7134_irq(int irq, void *dev_id, struct pt_regs *regs)
 564 {
 565         struct saa7134_dev *dev = (struct saa7134_dev*) dev_id;
 566         unsigned long report,status;
 567         int loop, handled = 0;
 568
 569         for (loop = 0; loop < 10; loop++) {
 570                 report = saa_readl(SAA7134_IRQ_REPORT);
 571                 status = saa_readl(SAA7134_IRQ_STATUS);
 572                 if (0 == report) {
 573                         if (irq_debug > 1)
 574                                 printk(KERN_DEBUG "%s/irq: no (more) work\n",
 575                                        dev->name);
 576                         goto out;
 577                 }
 578
 579                 /* If dmasound support is active and we get a sound report, exit
 580                    and let the saa7134-alsa/oss module deal with it */
 581
 582                 if ((report & SAA7134_IRQ_REPORT_DONE_RA3) &&
 583                         (dev->dmasound.priv_data != NULL) )
 584                 {
 585                         if (irq_debug > 1)
 586                                 printk(KERN_DEBUG "%s/irq: ignoring interrupt for DMA sound\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_GPIO16 |
 613                                SAA7134_IRQ_REPORT_GPIO18)) &&
 614                     dev->remote)
 615                         saa7134_input_irq(dev);
 616
 617         }
 618
 619         if (10 == loop) {
 620                 print_irqstatus(dev,loop,report,status);
 621                 if (report & SAA7134_IRQ_REPORT_PE) {
 622                         /* disable all parity error */
 623                         printk(KERN_WARNING "%s/irq: looping -- "
 624                                "clearing PE (parity error!) enable bit\n",dev->name);
 625                         saa_clearl(SAA7134_IRQ2,SAA7134_IRQ2_INTE_PE);
 626                 } else if (report & (SAA7134_IRQ_REPORT_GPIO16 |
 627                                      SAA7134_IRQ_REPORT_GPIO18)) {
 628                         /* disable gpio IRQs */
 629                         printk(KERN_WARNING "%s/irq: looping -- "
 630                                "clearing GPIO enable bits\n",dev->name);
 631                         saa_clearl(SAA7134_IRQ2, (SAA7134_IRQ2_INTE_GPIO16 |
 632                                                   SAA7134_IRQ2_INTE_GPIO18));
 633                 } else {
 634                         /* disable all irqs */
 635                         printk(KERN_WARNING "%s/irq: looping -- "
 636                                "clearing all enable bits\n",dev->name);
 637                         saa_writel(SAA7134_IRQ1,0);
 638                         saa_writel(SAA7134_IRQ2,0);
 639                 }
 640         }
 641
 642  out:
 643         return IRQ_RETVAL(handled);
 644 }
 645
 646 /* ------------------------------------------------------------------ */
 647
 648 /* early init (no i2c, no irq) */
 649 static int saa7134_hwinit1(struct saa7134_dev *dev)
 650 {
 651         dprintk("hwinit1\n");
 652
 653         saa_writel(SAA7134_IRQ1, 0);
 654         saa_writel(SAA7134_IRQ2, 0);
 655         init_MUTEX(&dev->lock);
 656         spin_lock_init(&dev->slock);
 657
 658         saa7134_track_gpio(dev,"pre-init");
 659         saa7134_video_init1(dev);
 660         saa7134_vbi_init1(dev);
 661         if (card_has_mpeg(dev))
 662                 saa7134_ts_init1(dev);
 663         saa7134_input_init1(dev);
 664
 665         /* RAM FIFO config */
 666         saa_writel(SAA7134_FIFO_SIZE, 0x08070503);
 667         saa_writel(SAA7134_THRESHOULD,0x02020202);
 668
 669         /* enable audio + video processing */
 670         saa_writel(SAA7134_MAIN_CTRL,
 671                    SAA7134_MAIN_CTRL_VPLLE |
 672                    SAA7134_MAIN_CTRL_APLLE |
 673                    SAA7134_MAIN_CTRL_EXOSC |
 674                    SAA7134_MAIN_CTRL_EVFE1 |
 675                    SAA7134_MAIN_CTRL_EVFE2 |
 676                    SAA7134_MAIN_CTRL_ESFE  |
 677                    SAA7134_MAIN_CTRL_EBDAC);
 678
 679         /*
 680          * Initialize OSS _after_ enabling audio clock PLL and audio processing.
 681          * OSS initialization writes to registers via the audio DSP; these
 682          * writes will fail unless the audio clock has been started.  At worst,
 683          * audio will not work.
 684          */
 685
 686         /* enable peripheral devices */
 687         saa_writeb(SAA7134_SPECIAL_MODE, 0x01);
 688
 689         /* set vertical line numbering start (vbi needs this) */
 690         saa_writeb(SAA7134_SOURCE_TIMING2, 0x20);
 691
 692         return 0;
 693 }
 694
 695 /* late init (with i2c + irq) */
 696 static int saa7134_hwinit2(struct saa7134_dev *dev)
 697 {
 698         unsigned int irq2_mask;
 699         dprintk("hwinit2\n");
 700
 701         saa7134_video_init2(dev);
 702         saa7134_tvaudio_init2(dev);
 703
 704         /* enable IRQ's */
 705         irq2_mask =
 706                 SAA7134_IRQ2_INTE_DEC3    |
 707                 SAA7134_IRQ2_INTE_DEC2    |
 708                 SAA7134_IRQ2_INTE_DEC1    |
 709                 SAA7134_IRQ2_INTE_DEC0    |
 710                 SAA7134_IRQ2_INTE_PE      |
 711                 SAA7134_IRQ2_INTE_AR;
 712
 713         if (dev->has_remote == SAA7134_REMOTE_GPIO)
 714                 irq2_mask |= (SAA7134_IRQ2_INTE_GPIO18  |
 715                               SAA7134_IRQ2_INTE_GPIO18A |
 716                               SAA7134_IRQ2_INTE_GPIO16  );
 717
 718         saa_writel(SAA7134_IRQ1, 0);
 719         saa_writel(SAA7134_IRQ2, irq2_mask);
 720
 721         return 0;
 722 }
 723
 724 /* shutdown */
 725 static int saa7134_hwfini(struct saa7134_dev *dev)
 726 {
 727         dprintk("hwfini\n");
 728
 729         if (card_has_mpeg(dev))
 730                 saa7134_ts_fini(dev);
 731         saa7134_input_fini(dev);
 732         saa7134_vbi_fini(dev);
 733         saa7134_video_fini(dev);
 734         saa7134_tvaudio_fini(dev);
 735         return 0;
 736 }
 737
 738 static void __devinit must_configure_manually(void)
 739 {
 740         unsigned int i,p;
 741
 742         printk(KERN_WARNING
 743                "saa7134: <rant>\n"
 744                "saa7134:  Congratulations!  Your TV card vendor saved a few\n"
 745                "saa7134:  cents for a eeprom, thus your pci board has no\n"
 746                "saa7134:  subsystem ID and I can't identify it automatically\n"
 747                "saa7134: </rant>\n"
 748                "saa7134: I feel better now.  Ok, here are the good news:\n"
 749                "saa7134: You can use the card=<nr> insmod option to specify\n"
 750                "saa7134: which board do you have.  The list:\n");
 751         for (i = 0; i < saa7134_bcount; i++) {
 752                 printk(KERN_WARNING "saa7134:   card=%d -> %-40.40s",
 753                        i,saa7134_boards[i].name);
 754                 for (p = 0; saa7134_pci_tbl[p].driver_data; p++) {
 755                         if (saa7134_pci_tbl[p].driver_data != i)
 756                                 continue;
 757                         printk(" %04x:%04x",
 758                                saa7134_pci_tbl[p].subvendor,
 759                                saa7134_pci_tbl[p].subdevice);
 760                 }
 761                 printk("\n");
 762         }
 763 }
 764
 765 static struct video_device *vdev_init(struct saa7134_dev *dev,
 766                                       struct video_device *template,
 767                                       char *type)
 768 {
 769         struct video_device *vfd;
 770
 771         vfd = video_device_alloc();
 772         if (NULL == vfd)
 773                 return NULL;
 774         *vfd = *template;
 775         vfd->minor   = -1;
 776         vfd->dev     = &dev->pci->dev;
 777         vfd->release = video_device_release;
 778         snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)",
 779                  dev->name, type, saa7134_boards[dev->board].name);
 780         return vfd;
 781 }
 782
 783 static void saa7134_unregister_video(struct saa7134_dev *dev)
 784 {
 785         if (dev->video_dev) {
 786                 if (-1 != dev->video_dev->minor)
 787                         video_unregister_device(dev->video_dev);
 788                 else
 789                         video_device_release(dev->video_dev);
 790                 dev->video_dev = NULL;
 791         }
 792         if (dev->vbi_dev) {
 793                 if (-1 != dev->vbi_dev->minor)
 794                         video_unregister_device(dev->vbi_dev);
 795                 else
 796                         video_device_release(dev->vbi_dev);
 797                 dev->vbi_dev = NULL;
 798         }
 799         if (dev->radio_dev) {
 800                 if (-1 != dev->radio_dev->minor)
 801                         video_unregister_device(dev->radio_dev);
 802                 else
 803                         video_device_release(dev->radio_dev);
 804                 dev->radio_dev = NULL;
 805         }
 806 }
 807
 808 static void mpeg_ops_attach(struct saa7134_mpeg_ops *ops,
 809                             struct saa7134_dev *dev)
 810 {
 811         int err;
 812
 813         if (NULL != dev->mops)
 814                 return;
 815         if (saa7134_boards[dev->board].mpeg != ops->type)
 816                 return;
 817         err = ops->init(dev);
 818         if (0 != err)
 819                 return;
 820         dev->mops = ops;
 821 }
 822
 823 static void mpeg_ops_detach(struct saa7134_mpeg_ops *ops,
 824                             struct saa7134_dev *dev)
 825 {
 826         if (NULL == dev->mops)
 827                 return;
 828         if (dev->mops != ops)
 829                 return;
 830         dev->mops->fini(dev);
 831         dev->mops = NULL;
 832 }
 833
 834 static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
 835                                      const struct pci_device_id *pci_id)
 836 {
 837         struct saa7134_dev *dev;
 838         struct list_head *item;
 839         struct saa7134_mpeg_ops *mops;
 840         int err;
 841
 842         dev = kmalloc(sizeof(*dev),GFP_KERNEL);
 843         if (NULL == dev)
 844                 return -ENOMEM;
 845         memset(dev,0,sizeof(*dev));
 846
 847         /* pci init */
 848         dev->pci = pci_dev;
 849         if (pci_enable_device(pci_dev)) {
 850                 err = -EIO;
 851                 goto fail1;
 852         }
 853
 854         dev->nr = saa7134_devcount;
 855         sprintf(dev->name,"saa%x[%d]",pci_dev->device,dev->nr);
 856
 857         /* pci quirks */
 858         if (pci_pci_problems) {
 859                 if (pci_pci_problems & PCIPCI_TRITON)
 860                         printk(KERN_INFO "%s: quirk: PCIPCI_TRITON\n", dev->name);
 861                 if (pci_pci_problems & PCIPCI_NATOMA)
 862                         printk(KERN_INFO "%s: quirk: PCIPCI_NATOMA\n", dev->name);
 863                 if (pci_pci_problems & PCIPCI_VIAETBF)
 864                         printk(KERN_INFO "%s: quirk: PCIPCI_VIAETBF\n", dev->name);
 865                 if (pci_pci_problems & PCIPCI_VSFX)
 866                         printk(KERN_INFO "%s: quirk: PCIPCI_VSFX\n",dev->name);
 867 #ifdef PCIPCI_ALIMAGIK
 868                 if (pci_pci_problems & PCIPCI_ALIMAGIK) {
 869                         printk(KERN_INFO "%s: quirk: PCIPCI_ALIMAGIK -- latency fixup\n",
 870                                dev->name);
 871                         latency = 0x0A;
 872                 }
 873 #endif
 874         }
 875         if (UNSET != latency) {
 876                 printk(KERN_INFO "%s: setting pci latency timer to %d\n",
 877                        dev->name,latency);
 878                 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
 879         }
 880
 881         /* print pci info */
 882         pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
 883         pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER,  &dev->pci_lat);
 884         printk(KERN_INFO "%s: found at %s, rev: %d, irq: %d, "
 885                "latency: %d, mmio: 0x%lx\n", dev->name,
 886                pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
 887                dev->pci_lat,pci_resource_start(pci_dev,0));
 888         pci_set_master(pci_dev);
 889         if (!pci_dma_supported(pci_dev,0xffffffff)) {
 890                 printk("%s: Oops: no 32bit PCI DMA ???\n",dev->name);
 891                 err = -EIO;
 892                 goto fail1;
 893         }
 894
 895         /* board config */
 896         dev->board = pci_id->driver_data;
 897         if (card[dev->nr] >= 0 &&
 898             card[dev->nr] < saa7134_bcount)
 899                 dev->board = card[dev->nr];
 900         if (SAA7134_BOARD_NOAUTO == dev->board) {
 901                 must_configure_manually();
 902                 dev->board = SAA7134_BOARD_UNKNOWN;
 903         }
 904         dev->tuner_type   = saa7134_boards[dev->board].tuner_type;
 905         dev->tda9887_conf = saa7134_boards[dev->board].tda9887_conf;
 906         if (UNSET != tuner[dev->nr])
 907                 dev->tuner_type = tuner[dev->nr];
 908         printk(KERN_INFO "%s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
 909                dev->name,pci_dev->subsystem_vendor,
 910                pci_dev->subsystem_device,saa7134_boards[dev->board].name,
 911                dev->board, card[dev->nr] == dev->board ?
 912                "insmod option" : "autodetected");
 913
 914         /* get mmio */
 915         if (!request_mem_region(pci_resource_start(pci_dev,0),
 916                                 pci_resource_len(pci_dev,0),
 917                                 dev->name)) {
 918                 err = -EBUSY;
 919                 printk(KERN_ERR "%s: can't get MMIO memory @ 0x%lx\n",
 920                        dev->name,pci_resource_start(pci_dev,0));
 921                 goto fail1;
 922         }
 923         dev->lmmio = ioremap(pci_resource_start(pci_dev,0), 0x1000);
 924         dev->bmmio = (__u8 __iomem *)dev->lmmio;
 925         if (NULL == dev->lmmio) {
 926                 err = -EIO;
 927                 printk(KERN_ERR "%s: can't ioremap() MMIO memory\n",
 928                        dev->name);
 929                 goto fail2;
 930         }
 931
 932         /* initialize hardware #1 */
 933         saa7134_board_init1(dev);
 934         saa7134_hwinit1(dev);
 935
 936         /* get irq */
 937         err = request_irq(pci_dev->irq, saa7134_irq,
 938                           SA_SHIRQ | SA_INTERRUPT, dev->name, dev);
 939         if (err < 0) {
 940                 printk(KERN_ERR "%s: can't get IRQ %d\n",
 941                        dev->name,pci_dev->irq);
 942                 goto fail3;
 943         }
 944
 945         /* wait a bit, register i2c bus */
 946         msleep(100);
 947         saa7134_i2c_register(dev);
 948
 949         /* initialize hardware #2 */
 950         saa7134_board_init2(dev);
 951         saa7134_hwinit2(dev);
 952
 953         /* load i2c helpers */
 954         if (TUNER_ABSENT != dev->tuner_type)
 955                 request_module("tuner");
 956         if (dev->tda9887_conf)
 957                 request_module("tda9887");
 958         if (card_is_empress(dev)) {
 959                 request_module("saa6752hs");
 960                 request_module_depend("saa7134-empress",&need_empress);
 961         }
 962
 963         if (card_is_dvb(dev))
 964                 request_module_depend("saa7134-dvb",&need_dvb);
 965
 966
 967         if (alsa)
 968                 request_module_depend("saa7134-alsa",&need_alsa);
 969
 970         if (oss)
 971                 request_module_depend("saa7134-oss",&need_oss);
 972
 973         v4l2_prio_init(&dev->prio);
 974
 975         /* register v4l devices */
 976         dev->video_dev = vdev_init(dev,&saa7134_video_template,"video");
 977         err = video_register_device(dev->video_dev,VFL_TYPE_GRABBER,
 978                                     video_nr[dev->nr]);
 979         if (err < 0) {
 980                 printk(KERN_INFO "%s: can't register video device\n",
 981                        dev->name);
 982                 goto fail4;
 983         }
 984         printk(KERN_INFO "%s: registered device video%d [v4l2]\n",
 985                dev->name,dev->video_dev->minor & 0x1f);
 986
 987         dev->vbi_dev = vdev_init(dev,&saa7134_vbi_template,"vbi");
 988         err = video_register_device(dev->vbi_dev,VFL_TYPE_VBI,
 989                                     vbi_nr[dev->nr]);
 990         if (err < 0)
 991                 goto fail4;
 992         printk(KERN_INFO "%s: registered device vbi%d\n",
 993                dev->name,dev->vbi_dev->minor & 0x1f);
 994
 995         if (card_has_radio(dev)) {
 996                 dev->radio_dev = vdev_init(dev,&saa7134_radio_template,"radio");
 997                 err = video_register_device(dev->radio_dev,VFL_TYPE_RADIO,
 998                                             radio_nr[dev->nr]);
 999                 if (err < 0)
1000                         goto fail4;
1001                 printk(KERN_INFO "%s: registered device radio%d\n",
1002                        dev->name,dev->radio_dev->minor & 0x1f);
1003         }
1004
1005         /* everything worked */
1006         pci_set_drvdata(pci_dev,dev);
1007         saa7134_devcount++;
1008
1009         down(&devlist_lock);
1010         list_for_each(item,&mops_list) {
1011                 mops = list_entry(item, struct saa7134_mpeg_ops, next);
1012                 mpeg_ops_attach(mops, dev);
1013         }
1014         list_add_tail(&dev->devlist,&saa7134_devlist);
1015         up(&devlist_lock);
1016
1017         /* check for signal */
1018         saa7134_irq_video_intl(dev);
1019
1020         if (dmasound_init && !dev->dmasound.priv_data) {
1021                 dmasound_init(dev);
1022         }
1023
1024         return 0;
1025
1026  fail4:
1027         saa7134_unregister_video(dev);
1028         saa7134_i2c_unregister(dev);
1029         free_irq(pci_dev->irq, dev);
1030  fail3:
1031         saa7134_hwfini(dev);
1032         iounmap(dev->lmmio);
1033  fail2:
1034         release_mem_region(pci_resource_start(pci_dev,0),
1035                            pci_resource_len(pci_dev,0));
1036  fail1:
1037         kfree(dev);
1038         return err;
1039 }
1040
1041 static void __devexit saa7134_finidev(struct pci_dev *pci_dev)
1042 {
1043         struct saa7134_dev *dev = pci_get_drvdata(pci_dev);
1044         struct list_head *item;
1045         struct saa7134_mpeg_ops *mops;
1046
1047         /* Release DMA sound modules if present */
1048         if (dmasound_exit && dev->dmasound.priv_data) {
1049                 dmasound_exit(dev);
1050         }
1051
1052         /* debugging ... */
1053         if (irq_debug) {
1054                 u32 report = saa_readl(SAA7134_IRQ_REPORT);
1055                 u32 status = saa_readl(SAA7134_IRQ_STATUS);
1056                 print_irqstatus(dev,42,report,status);
1057         }
1058
1059         /* disable peripheral devices */
1060         saa_writeb(SAA7134_SPECIAL_MODE,0);
1061
1062         /* shutdown hardware */
1063         saa_writel(SAA7134_IRQ1,0);
1064         saa_writel(SAA7134_IRQ2,0);
1065         saa_writel(SAA7134_MAIN_CTRL,0);
1066
1067         /* shutdown subsystems */
1068         saa7134_hwfini(dev);
1069
1070         /* unregister */
1071         down(&devlist_lock);
1072         list_del(&dev->devlist);
1073         list_for_each(item,&mops_list) {
1074                 mops = list_entry(item, struct saa7134_mpeg_ops, next);
1075                 mpeg_ops_detach(mops, dev);
1076         }
1077         up(&devlist_lock);
1078         saa7134_devcount--;
1079
1080         saa7134_i2c_unregister(dev);
1081         saa7134_unregister_video(dev);
1082
1083
1084         /* the DMA sound modules should be unloaded before reaching
1085            this, but just in case they are still present... */
1086         if (dev->dmasound.priv_data != NULL) {
1087                 free_irq(pci_dev->irq, &dev->dmasound);
1088                 dev->dmasound.priv_data = NULL;
1089         }
1090
1091
1092         /* release resources */
1093         free_irq(pci_dev->irq, dev);
1094         iounmap(dev->lmmio);
1095         release_mem_region(pci_resource_start(pci_dev,0),
1096                            pci_resource_len(pci_dev,0));
1097
1098         pci_set_drvdata(pci_dev, NULL);
1099
1100         /* free memory */
1101         kfree(dev);
1102 }
1103
1104 /* ----------------------------------------------------------- */
1105
1106 int saa7134_ts_register(struct saa7134_mpeg_ops *ops)
1107 {
1108         struct list_head *item;
1109         struct saa7134_dev *dev;
1110
1111         down(&devlist_lock);
1112         list_for_each(item,&saa7134_devlist) {
1113                 dev = list_entry(item, struct saa7134_dev, devlist);
1114                 mpeg_ops_attach(ops, dev);
1115         }
1116         list_add_tail(&ops->next,&mops_list);
1117         up(&devlist_lock);
1118         return 0;
1119 }
1120
1121 void saa7134_ts_unregister(struct saa7134_mpeg_ops *ops)
1122 {
1123         struct list_head *item;
1124         struct saa7134_dev *dev;
1125
1126         down(&devlist_lock);
1127         list_del(&ops->next);
1128         list_for_each(item,&saa7134_devlist) {
1129                 dev = list_entry(item, struct saa7134_dev, devlist);
1130                 mpeg_ops_detach(ops, dev);
1131         }
1132         up(&devlist_lock);
1133 }
1134
1135 EXPORT_SYMBOL(saa7134_ts_register);
1136 EXPORT_SYMBOL(saa7134_ts_unregister);
1137
1138 /* ----------------------------------------------------------- */
1139
1140 static struct pci_driver saa7134_pci_driver = {
1141         .name     = "saa7134",
1142         .id_table = saa7134_pci_tbl,
1143         .probe    = saa7134_initdev,
1144         .remove   = __devexit_p(saa7134_finidev),
1145 };
1146
1147 static int saa7134_init(void)
1148 {
1149         INIT_LIST_HEAD(&saa7134_devlist);
1150         printk(KERN_INFO "saa7130/34: v4l2 driver version %d.%d.%d loaded\n",
1151                (SAA7134_VERSION_CODE >> 16) & 0xff,
1152                (SAA7134_VERSION_CODE >>  8) & 0xff,
1153                SAA7134_VERSION_CODE & 0xff);
1154 #ifdef SNAPSHOT
1155         printk(KERN_INFO "saa7130/34: snapshot date %04d-%02d-%02d\n",
1156                SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
1157 #endif
1158         return pci_module_init(&saa7134_pci_driver);
1159 }
1160
1161 static void saa7134_fini(void)
1162 {
1163 #if defined(CONFIG_MODULES) && defined(MODULE)
1164         if (pending_registered)
1165                 unregister_module_notifier(&pending_notifier);
1166 #endif /* CONFIG_MODULES */
1167         pci_unregister_driver(&saa7134_pci_driver);
1168 }
1169
1170 module_init(saa7134_init);
1171 module_exit(saa7134_fini);
1172
1173 /* ----------------------------------------------------------- */
1174
1175 EXPORT_SYMBOL(saa7134_print_ioctl);
1176 EXPORT_SYMBOL(saa7134_i2c_call_clients);
1177 EXPORT_SYMBOL(saa7134_devlist);
1178 EXPORT_SYMBOL(saa7134_boards);
1179
1180 /* ----------------- for the DMA sound modules --------------- */
1181
1182 EXPORT_SYMBOL(dmasound_init);
1183 EXPORT_SYMBOL(dmasound_exit);
1184 EXPORT_SYMBOL(saa7134_pgtable_free);
1185 EXPORT_SYMBOL(saa7134_pgtable_build);
1186 EXPORT_SYMBOL(saa7134_pgtable_alloc);
1187 EXPORT_SYMBOL(saa7134_set_dmabits);
1188
1189 /* ----------------------------------------------------------- */
1190 /*
1191  * Local variables:
1192  * c-basic-offset: 8
1193  * End:
1194  */