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

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