drivers/media/video/cx88/cx88-mpeg.c

   1 /*
   2  *
   3  *  Support for the mpeg transport stream transfers
   4  *  PCI function #2 of the cx2388x.
   5  *
   6  *    (c) 2004 Jelle Foks <jelle@foks.us>
   7  *    (c) 2004 Chris Pascoe <c.pascoe@itee.uq.edu.au>
   8  *    (c) 2004 Gerd Knorr <kraxel@bytesex.org>
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/slab.h>
  27 #include <linux/init.h>
  28 #include <linux/device.h>
  29 #include <linux/dma-mapping.h>
  30 #include <linux/interrupt.h>
  31 #include <asm/delay.h>
  32
  33 #include "cx88.h"
  34
  35 /* ------------------------------------------------------------------ */
  36
  37 MODULE_DESCRIPTION("mpeg driver for cx2388x based TV cards");
  38 MODULE_AUTHOR("Jelle Foks <jelle@foks.us>");
  39 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
  40 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
  41 MODULE_LICENSE("GPL");
  42
  43 static unsigned int debug;
  44 module_param(debug,int,0644);
  45 MODULE_PARM_DESC(debug,"enable debug messages [mpeg]");
  46
  47 #define dprintk(level,fmt, arg...)      if (debug >= level) \
  48         printk(KERN_DEBUG "%s/2-mpeg: " fmt, dev->core->name, ## arg)
  49
  50 #define mpeg_dbg(level,fmt, arg...)     if (debug >= level) \
  51         printk(KERN_DEBUG "%s/2-mpeg: " fmt, core->name, ## arg)
  52
  53 #if defined(CONFIG_MODULES) && defined(MODULE)
  54 static void request_module_async(struct work_struct *work)
  55 {
  56         struct cx8802_dev *dev=container_of(work, struct cx8802_dev, request_module_wk);
  57
  58         if (dev->core->board.mpeg & CX88_MPEG_DVB)
  59                 request_module("cx88-dvb");
  60         if (dev->core->board.mpeg & CX88_MPEG_BLACKBIRD)
  61                 request_module("cx88-blackbird");
  62 }
  63
  64 static void request_modules(struct cx8802_dev *dev)
  65 {
  66         INIT_WORK(&dev->request_module_wk, request_module_async);
  67         schedule_work(&dev->request_module_wk);
  68 }
  69 #else
  70 #define request_modules(dev)
  71 #endif /* CONFIG_MODULES */
  72
  73
  74 static LIST_HEAD(cx8802_devlist);
  75 /* ------------------------------------------------------------------ */
  76
  77 static int cx8802_start_dma(struct cx8802_dev    *dev,
  78                             struct cx88_dmaqueue *q,
  79                             struct cx88_buffer   *buf)
  80 {
  81         struct cx88_core *core = dev->core;
  82
  83         dprintk(1, "cx8802_start_dma w: %d, h: %d, f: %d\n",
  84                 buf->vb.width, buf->vb.height, buf->vb.field);
  85
  86         /* setup fifo + format */
  87         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH28],
  88                                 dev->ts_packet_size, buf->risc.dma);
  89
  90         /* write TS length to chip */
  91         cx_write(MO_TS_LNGTH, buf->vb.width);
  92
  93         /* FIXME: this needs a review.
  94          * also: move to cx88-blackbird + cx88-dvb source files? */
  95
  96         dprintk( 1, "core->active_type_id = 0x%08x\n", core->active_type_id);
  97
  98         if ( (core->active_type_id == CX88_MPEG_DVB) &&
  99                 (core->board.mpeg & CX88_MPEG_DVB) ) {
 100
 101                 dprintk( 1, "cx8802_start_dma doing .dvb\n");
 102                 /* negedge driven & software reset */
 103                 cx_write(TS_GEN_CNTRL, 0x0040 | dev->ts_gen_cntrl);
 104                 udelay(100);
 105                 cx_write(MO_PINMUX_IO, 0x00);
 106                 cx_write(TS_HW_SOP_CNTRL, 0x47<<16|188<<4|0x01);
 107                 switch (core->boardnr) {
 108                 case CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_Q:
 109                 case CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_T:
 110                 case CX88_BOARD_DVICO_FUSIONHDTV_5_GOLD:
 111                 case CX88_BOARD_PCHDTV_HD5500:
 112                         cx_write(TS_SOP_STAT, 1<<13);
 113                         break;
 114                 case CX88_BOARD_SAMSUNG_SMT_7020:
 115                         cx_write(TS_SOP_STAT, 0x00);
 116                         break;
 117                 case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1:
 118                 case CX88_BOARD_HAUPPAUGE_NOVASE2_S1:
 119                         cx_write(MO_PINMUX_IO, 0x88); /* Enable MPEG parallel IO and video signal pins */
 120                         udelay(100);
 121                         break;
 122                 case CX88_BOARD_HAUPPAUGE_HVR1300:
 123                         /* Enable MPEG parallel IO and video signal pins */
 124                         cx_write(MO_PINMUX_IO, 0x88);
 125                         cx_write(TS_SOP_STAT, 0);
 126                         cx_write(TS_VALERR_CNTRL, 0);
 127                         break;
 128                 case CX88_BOARD_PINNACLE_PCTV_HD_800i:
 129                         /* Enable MPEG parallel IO and video signal pins */
 130                         cx_write(MO_PINMUX_IO, 0x88);
 131                         cx_write(TS_HW_SOP_CNTRL, (0x47 << 16) | (188 << 4));
 132                         dev->ts_gen_cntrl = 5;
 133                         cx_write(TS_SOP_STAT, 0);
 134                         cx_write(TS_VALERR_CNTRL, 0);
 135                         udelay(100);
 136                         break;
 137                 default:
 138                         cx_write(TS_SOP_STAT, 0x00);
 139                         break;
 140                 }
 141                 cx_write(TS_GEN_CNTRL, dev->ts_gen_cntrl);
 142                 udelay(100);
 143         } else if ( (core->active_type_id == CX88_MPEG_BLACKBIRD) &&
 144                 (core->board.mpeg & CX88_MPEG_BLACKBIRD) ) {
 145                 dprintk( 1, "cx8802_start_dma doing .blackbird\n");
 146                 cx_write(MO_PINMUX_IO, 0x88); /* enable MPEG parallel IO */
 147
 148                 cx_write(TS_GEN_CNTRL, 0x46); /* punctured clock TS & posedge driven & software reset */
 149                 udelay(100);
 150
 151                 cx_write(TS_HW_SOP_CNTRL, 0x408); /* mpeg start byte */
 152                 cx_write(TS_VALERR_CNTRL, 0x2000);
 153
 154                 cx_write(TS_GEN_CNTRL, 0x06); /* punctured clock TS & posedge driven */
 155                 udelay(100);
 156         } else {
 157                 printk( "%s() Failed. Unsupported value in .mpeg (0x%08x)\n", __func__,
 158                         core->board.mpeg );
 159                 return -EINVAL;
 160         }
 161
 162         /* reset counter */
 163         cx_write(MO_TS_GPCNTRL, GP_COUNT_CONTROL_RESET);
 164         q->count = 1;
 165
 166         /* enable irqs */
 167         dprintk( 1, "setting the interrupt mask\n" );
 168         cx_set(MO_PCI_INTMSK, core->pci_irqmask | PCI_INT_TSINT);
 169         cx_set(MO_TS_INTMSK,  0x1f0011);
 170
 171         /* start dma */
 172         cx_set(MO_DEV_CNTRL2, (1<<5));
 173         cx_set(MO_TS_DMACNTRL, 0x11);
 174         return 0;
 175 }
 176
 177 static int cx8802_stop_dma(struct cx8802_dev *dev)
 178 {
 179         struct cx88_core *core = dev->core;
 180         dprintk( 1, "cx8802_stop_dma\n" );
 181
 182         /* stop dma */
 183         cx_clear(MO_TS_DMACNTRL, 0x11);
 184
 185         /* disable irqs */
 186         cx_clear(MO_PCI_INTMSK, PCI_INT_TSINT);
 187         cx_clear(MO_TS_INTMSK, 0x1f0011);
 188
 189         /* Reset the controller */
 190         cx_write(TS_GEN_CNTRL, 0xcd);
 191         return 0;
 192 }
 193
 194 static int cx8802_restart_queue(struct cx8802_dev    *dev,
 195                                 struct cx88_dmaqueue *q)
 196 {
 197         struct cx88_buffer *buf;
 198
 199         dprintk( 1, "cx8802_restart_queue\n" );
 200         if (list_empty(&q->active))
 201         {
 202                 struct cx88_buffer *prev;
 203                 prev = NULL;
 204
 205                 dprintk(1, "cx8802_restart_queue: queue is empty\n" );
 206
 207                 for (;;) {
 208                         if (list_empty(&q->queued))
 209                                 return 0;
 210                         buf = list_entry(q->queued.next, struct cx88_buffer, vb.queue);
 211                         if (NULL == prev) {
 212                                 list_del(&buf->vb.queue);
 213                                 list_add_tail(&buf->vb.queue,&q->active);
 214                                 cx8802_start_dma(dev, q, buf);
 215                                 buf->vb.state = VIDEOBUF_ACTIVE;
 216                                 buf->count    = q->count++;
 217                                 mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 218                                 dprintk(1,"[%p/%d] restart_queue - first active\n",
 219                                         buf,buf->vb.i);
 220
 221                         } else if (prev->vb.width  == buf->vb.width  &&
 222                                    prev->vb.height == buf->vb.height &&
 223                                    prev->fmt       == buf->fmt) {
 224                                 list_del(&buf->vb.queue);
 225                                 list_add_tail(&buf->vb.queue,&q->active);
 226                                 buf->vb.state = VIDEOBUF_ACTIVE;
 227                                 buf->count    = q->count++;
 228                                 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
 229                                 dprintk(1,"[%p/%d] restart_queue - move to active\n",
 230                                         buf,buf->vb.i);
 231                         } else {
 232                                 return 0;
 233                         }
 234                         prev = buf;
 235                 }
 236                 return 0;
 237         }
 238
 239         buf = list_entry(q->active.next, struct cx88_buffer, vb.queue);
 240         dprintk(2,"restart_queue [%p/%d]: restart dma\n",
 241                 buf, buf->vb.i);
 242         cx8802_start_dma(dev, q, buf);
 243         list_for_each_entry(buf, &q->active, vb.queue)
 244                 buf->count = q->count++;
 245         mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 246         return 0;
 247 }
 248
 249 /* ------------------------------------------------------------------ */
 250
 251 int cx8802_buf_prepare(struct videobuf_queue *q, struct cx8802_dev *dev,
 252                         struct cx88_buffer *buf, enum v4l2_field field)
 253 {
 254         int size = dev->ts_packet_size * dev->ts_packet_count;
 255         struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
 256         int rc;
 257
 258         dprintk(1, "%s: %p\n", __func__, buf);
 259         if (0 != buf->vb.baddr  &&  buf->vb.bsize < size)
 260                 return -EINVAL;
 261
 262         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
 263                 buf->vb.width  = dev->ts_packet_size;
 264                 buf->vb.height = dev->ts_packet_count;
 265                 buf->vb.size   = size;
 266                 buf->vb.field  = field /*V4L2_FIELD_TOP*/;
 267
 268                 if (0 != (rc = videobuf_iolock(q,&buf->vb,NULL)))
 269                         goto fail;
 270                 cx88_risc_databuffer(dev->pci, &buf->risc,
 271                                      dma->sglist,
 272                                      buf->vb.width, buf->vb.height, 0);
 273         }
 274         buf->vb.state = VIDEOBUF_PREPARED;
 275         return 0;
 276
 277  fail:
 278         cx88_free_buffer(q,buf);
 279         return rc;
 280 }
 281
 282 void cx8802_buf_queue(struct cx8802_dev *dev, struct cx88_buffer *buf)
 283 {
 284         struct cx88_buffer    *prev;
 285         struct cx88_dmaqueue  *cx88q = &dev->mpegq;
 286
 287         dprintk( 1, "cx8802_buf_queue\n" );
 288         /* add jump to stopper */
 289         buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
 290         buf->risc.jmp[1] = cpu_to_le32(cx88q->stopper.dma);
 291
 292         if (list_empty(&cx88q->active)) {
 293                 dprintk( 1, "queue is empty - first active\n" );
 294                 list_add_tail(&buf->vb.queue,&cx88q->active);
 295                 cx8802_start_dma(dev, cx88q, buf);
 296                 buf->vb.state = VIDEOBUF_ACTIVE;
 297                 buf->count    = cx88q->count++;
 298                 mod_timer(&cx88q->timeout, jiffies+BUFFER_TIMEOUT);
 299                 dprintk(1,"[%p/%d] %s - first active\n",
 300                         buf, buf->vb.i, __func__);
 301
 302         } else {
 303                 dprintk( 1, "queue is not empty - append to active\n" );
 304                 prev = list_entry(cx88q->active.prev, struct cx88_buffer, vb.queue);
 305                 list_add_tail(&buf->vb.queue,&cx88q->active);
 306                 buf->vb.state = VIDEOBUF_ACTIVE;
 307                 buf->count    = cx88q->count++;
 308                 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
 309                 dprintk( 1, "[%p/%d] %s - append to active\n",
 310                         buf, buf->vb.i, __func__);
 311         }
 312 }
 313
 314 /* ----------------------------------------------------------- */
 315
 316 static void do_cancel_buffers(struct cx8802_dev *dev, const char *reason, int restart)
 317 {
 318         struct cx88_dmaqueue *q = &dev->mpegq;
 319         struct cx88_buffer *buf;
 320         unsigned long flags;
 321
 322         spin_lock_irqsave(&dev->slock,flags);
 323         while (!list_empty(&q->active)) {
 324                 buf = list_entry(q->active.next, struct cx88_buffer, vb.queue);
 325                 list_del(&buf->vb.queue);
 326                 buf->vb.state = VIDEOBUF_ERROR;
 327                 wake_up(&buf->vb.done);
 328                 dprintk(1,"[%p/%d] %s - dma=0x%08lx\n",
 329                         buf, buf->vb.i, reason, (unsigned long)buf->risc.dma);
 330         }
 331         if (restart)
 332         {
 333                 dprintk(1, "restarting queue\n" );
 334                 cx8802_restart_queue(dev,q);
 335         }
 336         spin_unlock_irqrestore(&dev->slock,flags);
 337 }
 338
 339 void cx8802_cancel_buffers(struct cx8802_dev *dev)
 340 {
 341         struct cx88_dmaqueue *q = &dev->mpegq;
 342
 343         dprintk( 1, "cx8802_cancel_buffers" );
 344         del_timer_sync(&q->timeout);
 345         cx8802_stop_dma(dev);
 346         do_cancel_buffers(dev,"cancel",0);
 347 }
 348
 349 static void cx8802_timeout(unsigned long data)
 350 {
 351         struct cx8802_dev *dev = (struct cx8802_dev*)data;
 352
 353         dprintk(1, "%s\n",__func__);
 354
 355         if (debug)
 356                 cx88_sram_channel_dump(dev->core, &cx88_sram_channels[SRAM_CH28]);
 357         cx8802_stop_dma(dev);
 358         do_cancel_buffers(dev,"timeout",1);
 359 }
 360
 361 static const char * cx88_mpeg_irqs[32] = {
 362         "ts_risci1", NULL, NULL, NULL,
 363         "ts_risci2", NULL, NULL, NULL,
 364         "ts_oflow",  NULL, NULL, NULL,
 365         "ts_sync",   NULL, NULL, NULL,
 366         "opc_err", "par_err", "rip_err", "pci_abort",
 367         "ts_err?",
 368 };
 369
 370 static void cx8802_mpeg_irq(struct cx8802_dev *dev)
 371 {
 372         struct cx88_core *core = dev->core;
 373         u32 status, mask, count;
 374
 375         dprintk( 1, "cx8802_mpeg_irq\n" );
 376         status = cx_read(MO_TS_INTSTAT);
 377         mask   = cx_read(MO_TS_INTMSK);
 378         if (0 == (status & mask))
 379                 return;
 380
 381         cx_write(MO_TS_INTSTAT, status);
 382
 383         if (debug || (status & mask & ~0xff))
 384                 cx88_print_irqbits(core->name, "irq mpeg ",
 385                                    cx88_mpeg_irqs, ARRAY_SIZE(cx88_mpeg_irqs),
 386                                    status, mask);
 387
 388         /* risc op code error */
 389         if (status & (1 << 16)) {
 390                 printk(KERN_WARNING "%s: mpeg risc op code error\n",core->name);
 391                 cx_clear(MO_TS_DMACNTRL, 0x11);
 392                 cx88_sram_channel_dump(dev->core, &cx88_sram_channels[SRAM_CH28]);
 393         }
 394
 395         /* risc1 y */
 396         if (status & 0x01) {
 397                 dprintk( 1, "wake up\n" );
 398                 spin_lock(&dev->slock);
 399                 count = cx_read(MO_TS_GPCNT);
 400                 cx88_wakeup(dev->core, &dev->mpegq, count);
 401                 spin_unlock(&dev->slock);
 402         }
 403
 404         /* risc2 y */
 405         if (status & 0x10) {
 406                 spin_lock(&dev->slock);
 407                 cx8802_restart_queue(dev,&dev->mpegq);
 408                 spin_unlock(&dev->slock);
 409         }
 410
 411         /* other general errors */
 412         if (status & 0x1f0100) {
 413                 dprintk( 0, "general errors: 0x%08x\n", status & 0x1f0100 );
 414                 spin_lock(&dev->slock);
 415                 cx8802_stop_dma(dev);
 416                 cx8802_restart_queue(dev,&dev->mpegq);
 417                 spin_unlock(&dev->slock);
 418         }
 419 }
 420
 421 #define MAX_IRQ_LOOP 10
 422
 423 static irqreturn_t cx8802_irq(int irq, void *dev_id)
 424 {
 425         struct cx8802_dev *dev = dev_id;
 426         struct cx88_core *core = dev->core;
 427         u32 status;
 428         int loop, handled = 0;
 429
 430         for (loop = 0; loop < MAX_IRQ_LOOP; loop++) {
 431                 status = cx_read(MO_PCI_INTSTAT) &
 432                         (core->pci_irqmask | PCI_INT_TSINT);
 433                 if (0 == status)
 434                         goto out;
 435                 dprintk( 1, "cx8802_irq\n" );
 436                 dprintk( 1, "    loop: %d/%d\n", loop, MAX_IRQ_LOOP );
 437                 dprintk( 1, "    status: %d\n", status );
 438                 handled = 1;
 439                 cx_write(MO_PCI_INTSTAT, status);
 440
 441                 if (status & core->pci_irqmask)
 442                         cx88_core_irq(core,status);
 443                 if (status & PCI_INT_TSINT)
 444                         cx8802_mpeg_irq(dev);
 445         };
 446         if (MAX_IRQ_LOOP == loop) {
 447                 dprintk( 0, "clearing mask\n" );
 448                 printk(KERN_WARNING "%s/0: irq loop -- clearing mask\n",
 449                        core->name);
 450                 cx_write(MO_PCI_INTMSK,0);
 451         }
 452
 453  out:
 454         return IRQ_RETVAL(handled);
 455 }
 456
 457 static int cx8802_init_common(struct cx8802_dev *dev)
 458 {
 459         struct cx88_core *core = dev->core;
 460         int err;
 461
 462         /* pci init */
 463         if (pci_enable_device(dev->pci))
 464                 return -EIO;
 465         pci_set_master(dev->pci);
 466         if (!pci_dma_supported(dev->pci,DMA_BIT_MASK(32))) {
 467                 printk("%s/2: Oops: no 32bit PCI DMA ???\n",dev->core->name);
 468                 return -EIO;
 469         }
 470
 471         pci_read_config_byte(dev->pci, PCI_CLASS_REVISION, &dev->pci_rev);
 472         pci_read_config_byte(dev->pci, PCI_LATENCY_TIMER,  &dev->pci_lat);
 473         printk(KERN_INFO "%s/2: found at %s, rev: %d, irq: %d, "
 474                "latency: %d, mmio: 0x%llx\n", dev->core->name,
 475                pci_name(dev->pci), dev->pci_rev, dev->pci->irq,
 476                dev->pci_lat,(unsigned long long)pci_resource_start(dev->pci,0));
 477
 478         /* initialize driver struct */
 479         spin_lock_init(&dev->slock);
 480
 481         /* init dma queue */
 482         INIT_LIST_HEAD(&dev->mpegq.active);
 483         INIT_LIST_HEAD(&dev->mpegq.queued);
 484         dev->mpegq.timeout.function = cx8802_timeout;
 485         dev->mpegq.timeout.data     = (unsigned long)dev;
 486         init_timer(&dev->mpegq.timeout);
 487         cx88_risc_stopper(dev->pci,&dev->mpegq.stopper,
 488                           MO_TS_DMACNTRL,0x11,0x00);
 489
 490         /* get irq */
 491         err = request_irq(dev->pci->irq, cx8802_irq,
 492                           IRQF_SHARED | IRQF_DISABLED, dev->core->name, dev);
 493         if (err < 0) {
 494                 printk(KERN_ERR "%s: can't get IRQ %d\n",
 495                        dev->core->name, dev->pci->irq);
 496                 return err;
 497         }
 498         cx_set(MO_PCI_INTMSK, core->pci_irqmask);
 499
 500         /* everything worked */
 501         pci_set_drvdata(dev->pci,dev);
 502         return 0;
 503 }
 504
 505 static void cx8802_fini_common(struct cx8802_dev *dev)
 506 {
 507         dprintk( 2, "cx8802_fini_common\n" );
 508         cx8802_stop_dma(dev);
 509         pci_disable_device(dev->pci);
 510
 511         /* unregister stuff */
 512         free_irq(dev->pci->irq, dev);
 513         pci_set_drvdata(dev->pci, NULL);
 514
 515         /* free memory */
 516         btcx_riscmem_free(dev->pci,&dev->mpegq.stopper);
 517 }
 518
 519 /* ----------------------------------------------------------- */
 520
 521 static int cx8802_suspend_common(struct pci_dev *pci_dev, pm_message_t state)
 522 {
 523         struct cx8802_dev *dev = pci_get_drvdata(pci_dev);
 524         struct cx88_core *core = dev->core;
 525
 526         /* stop mpeg dma */
 527         spin_lock(&dev->slock);
 528         if (!list_empty(&dev->mpegq.active)) {
 529                 dprintk( 2, "suspend\n" );
 530                 printk("%s: suspend mpeg\n", core->name);
 531                 cx8802_stop_dma(dev);
 532                 del_timer(&dev->mpegq.timeout);
 533         }
 534         spin_unlock(&dev->slock);
 535
 536         /* FIXME -- shutdown device */
 537         cx88_shutdown(dev->core);
 538
 539         pci_save_state(pci_dev);
 540         if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
 541                 pci_disable_device(pci_dev);
 542                 dev->state.disabled = 1;
 543         }
 544         return 0;
 545 }
 546
 547 static int cx8802_resume_common(struct pci_dev *pci_dev)
 548 {
 549         struct cx8802_dev *dev = pci_get_drvdata(pci_dev);
 550         struct cx88_core *core = dev->core;
 551         int err;
 552
 553         if (dev->state.disabled) {
 554                 err=pci_enable_device(pci_dev);
 555                 if (err) {
 556                         printk(KERN_ERR "%s: can't enable device\n",
 557                                                dev->core->name);
 558                         return err;
 559                 }
 560                 dev->state.disabled = 0;
 561         }
 562         err=pci_set_power_state(pci_dev, PCI_D0);
 563         if (err) {
 564                 printk(KERN_ERR "%s: can't enable device\n",
 565                                                dev->core->name);
 566                 pci_disable_device(pci_dev);
 567                 dev->state.disabled = 1;
 568
 569                 return err;
 570         }
 571         pci_restore_state(pci_dev);
 572
 573         /* FIXME: re-initialize hardware */
 574         cx88_reset(dev->core);
 575
 576         /* restart video+vbi capture */
 577         spin_lock(&dev->slock);
 578         if (!list_empty(&dev->mpegq.active)) {
 579                 printk("%s: resume mpeg\n", core->name);
 580                 cx8802_restart_queue(dev,&dev->mpegq);
 581         }
 582         spin_unlock(&dev->slock);
 583
 584         return 0;
 585 }
 586
 587 struct cx8802_driver * cx8802_get_driver(struct cx8802_dev *dev, enum cx88_board_type btype)
 588 {
 589         struct cx8802_driver *d;
 590
 591         list_for_each_entry(d, &dev->drvlist, drvlist)
 592                 if (d->type_id == btype)
 593                         return d;
 594
 595         return NULL;
 596 }
 597
 598 /* Driver asked for hardware access. */
 599 static int cx8802_request_acquire(struct cx8802_driver *drv)
 600 {
 601         struct cx88_core *core = drv->core;
 602         unsigned int    i;
 603
 604         /* Fail a request for hardware if the device is busy. */
 605         if (core->active_type_id != CX88_BOARD_NONE &&
 606             core->active_type_id != drv->type_id)
 607                 return -EBUSY;
 608
 609         core->input = 0;
 610         for (i = 0;
 611              i < (sizeof(core->board.input) / sizeof(struct cx88_input));
 612              i++) {
 613                 if (core->board.input[i].type == CX88_VMUX_DVB) {
 614                         core->input = i;
 615                         break;
 616                 }
 617         }
 618
 619         if (drv->advise_acquire)
 620         {
 621                 mutex_lock(&drv->core->lock);
 622                 core->active_ref++;
 623                 if (core->active_type_id == CX88_BOARD_NONE) {
 624                         core->active_type_id = drv->type_id;
 625                         drv->advise_acquire(drv);
 626                 }
 627                 mutex_unlock(&drv->core->lock);
 628
 629                 mpeg_dbg(1,"%s() Post acquire GPIO=%x\n", __func__, cx_read(MO_GP0_IO));
 630         }
 631
 632         return 0;
 633 }
 634
 635 /* Driver asked to release hardware. */
 636 static int cx8802_request_release(struct cx8802_driver *drv)
 637 {
 638         struct cx88_core *core = drv->core;
 639
 640         mutex_lock(&drv->core->lock);
 641         if (drv->advise_release && --core->active_ref == 0)
 642         {
 643                 drv->advise_release(drv);
 644                 core->active_type_id = CX88_BOARD_NONE;
 645                 mpeg_dbg(1,"%s() Post release GPIO=%x\n", __func__, cx_read(MO_GP0_IO));
 646         }
 647         mutex_unlock(&drv->core->lock);
 648
 649         return 0;
 650 }
 651
 652 static int cx8802_check_driver(struct cx8802_driver *drv)
 653 {
 654         if (drv == NULL)
 655                 return -ENODEV;
 656
 657         if ((drv->type_id != CX88_MPEG_DVB) &&
 658                 (drv->type_id != CX88_MPEG_BLACKBIRD))
 659                 return -EINVAL;
 660
 661         if ((drv->hw_access != CX8802_DRVCTL_SHARED) &&
 662                 (drv->hw_access != CX8802_DRVCTL_EXCLUSIVE))
 663                 return -EINVAL;
 664
 665         if ((drv->probe == NULL) ||
 666                 (drv->remove == NULL) ||
 667                 (drv->advise_acquire == NULL) ||
 668                 (drv->advise_release == NULL))
 669                 return -EINVAL;
 670
 671         return 0;
 672 }
 673
 674 int cx8802_register_driver(struct cx8802_driver *drv)
 675 {
 676         struct cx8802_dev *dev;
 677         struct cx8802_driver *driver;
 678         int err, i = 0;
 679
 680         printk(KERN_INFO
 681                "cx88/2: registering cx8802 driver, type: %s access: %s\n",
 682                drv->type_id == CX88_MPEG_DVB ? "dvb" : "blackbird",
 683                drv->hw_access == CX8802_DRVCTL_SHARED ? "shared" : "exclusive");
 684
 685         if ((err = cx8802_check_driver(drv)) != 0) {
 686                 printk(KERN_ERR "cx88/2: cx8802_driver is invalid\n");
 687                 return err;
 688         }
 689
 690         list_for_each_entry(dev, &cx8802_devlist, devlist) {
 691                 printk(KERN_INFO
 692                        "%s/2: subsystem: %04x:%04x, board: %s [card=%d]\n",
 693                        dev->core->name, dev->pci->subsystem_vendor,
 694                        dev->pci->subsystem_device, dev->core->board.name,
 695                        dev->core->boardnr);
 696
 697                 /* Bring up a new struct for each driver instance */
 698                 driver = kzalloc(sizeof(*drv),GFP_KERNEL);
 699                 if (driver == NULL)
 700                         return -ENOMEM;
 701
 702                 /* Snapshot of the driver registration data */
 703                 drv->core = dev->core;
 704                 drv->suspend = cx8802_suspend_common;
 705                 drv->resume = cx8802_resume_common;
 706                 drv->request_acquire = cx8802_request_acquire;
 707                 drv->request_release = cx8802_request_release;
 708                 memcpy(driver, drv, sizeof(*driver));
 709
 710                 err = drv->probe(driver);
 711                 if (err == 0) {
 712                         i++;
 713                         mutex_lock(&drv->core->lock);
 714                         list_add_tail(&driver->drvlist, &dev->drvlist);
 715                         mutex_unlock(&drv->core->lock);
 716                 } else {
 717                         printk(KERN_ERR
 718                                "%s/2: cx8802 probe failed, err = %d\n",
 719                                dev->core->name, err);
 720                 }
 721
 722         }
 723
 724         return i ? 0 : -ENODEV;
 725 }
 726
 727 int cx8802_unregister_driver(struct cx8802_driver *drv)
 728 {
 729         struct cx8802_dev *dev;
 730         struct cx8802_driver *d, *dtmp;
 731         int err = 0;
 732
 733         printk(KERN_INFO
 734                "cx88/2: unregistering cx8802 driver, type: %s access: %s\n",
 735                drv->type_id == CX88_MPEG_DVB ? "dvb" : "blackbird",
 736                drv->hw_access == CX8802_DRVCTL_SHARED ? "shared" : "exclusive");
 737
 738         list_for_each_entry(dev, &cx8802_devlist, devlist) {
 739                 printk(KERN_INFO
 740                        "%s/2: subsystem: %04x:%04x, board: %s [card=%d]\n",
 741                        dev->core->name, dev->pci->subsystem_vendor,
 742                        dev->pci->subsystem_device, dev->core->board.name,
 743                        dev->core->boardnr);
 744
 745                 list_for_each_entry_safe(d, dtmp, &dev->drvlist, drvlist) {
 746                         /* only unregister the correct driver type */
 747                         if (d->type_id != drv->type_id)
 748                                 continue;
 749
 750                         err = d->remove(d);
 751                         if (err == 0) {
 752                                 mutex_lock(&drv->core->lock);
 753                                 list_del(&d->drvlist);
 754                                 mutex_unlock(&drv->core->lock);
 755                                 kfree(d);
 756                         } else
 757                                 printk(KERN_ERR "%s/2: cx8802 driver remove "
 758                                        "failed (%d)\n", dev->core->name, err);
 759                 }
 760
 761         }
 762
 763         return err;
 764 }
 765
 766 /* ----------------------------------------------------------- */
 767 static int __devinit cx8802_probe(struct pci_dev *pci_dev,
 768                                const struct pci_device_id *pci_id)
 769 {
 770         struct cx8802_dev *dev;
 771         struct cx88_core  *core;
 772         int err;
 773
 774         /* general setup */
 775         core = cx88_core_get(pci_dev);
 776         if (NULL == core)
 777                 return -EINVAL;
 778
 779         printk("%s/2: cx2388x 8802 Driver Manager\n", core->name);
 780
 781         err = -ENODEV;
 782         if (!core->board.mpeg)
 783                 goto fail_core;
 784
 785         err = -ENOMEM;
 786         dev = kzalloc(sizeof(*dev),GFP_KERNEL);
 787         if (NULL == dev)
 788                 goto fail_core;
 789         dev->pci = pci_dev;
 790         dev->core = core;
 791
 792         /* Maintain a reference so cx88-video can query the 8802 device. */
 793         core->dvbdev = dev;
 794
 795         err = cx8802_init_common(dev);
 796         if (err != 0)
 797                 goto fail_free;
 798
 799         INIT_LIST_HEAD(&dev->drvlist);
 800         list_add_tail(&dev->devlist,&cx8802_devlist);
 801
 802         /* now autoload cx88-dvb or cx88-blackbird */
 803         request_modules(dev);
 804         return 0;
 805
 806  fail_free:
 807         kfree(dev);
 808  fail_core:
 809         core->dvbdev = NULL;
 810         cx88_core_put(core,pci_dev);
 811         return err;
 812 }
 813
 814 static void __devexit cx8802_remove(struct pci_dev *pci_dev)
 815 {
 816         struct cx8802_dev *dev;
 817
 818         dev = pci_get_drvdata(pci_dev);
 819
 820         dprintk( 1, "%s\n", __func__);
 821
 822         if (!list_empty(&dev->drvlist)) {
 823                 struct cx8802_driver *drv, *tmp;
 824                 int err;
 825
 826                 printk(KERN_WARNING "%s/2: Trying to remove cx8802 driver "
 827                        "while cx8802 sub-drivers still loaded?!\n",
 828                        dev->core->name);
 829
 830                 list_for_each_entry_safe(drv, tmp, &dev->drvlist, drvlist) {
 831                         err = drv->remove(drv);
 832                         if (err == 0) {
 833                                 mutex_lock(&drv->core->lock);
 834                                 list_del(&drv->drvlist);
 835                                 mutex_unlock(&drv->core->lock);
 836                         } else
 837                                 printk(KERN_ERR "%s/2: cx8802 driver remove "
 838                                        "failed (%d)\n", dev->core->name, err);
 839                         kfree(drv);
 840                 }
 841         }
 842
 843         /* Destroy any 8802 reference. */
 844         dev->core->dvbdev = NULL;
 845
 846         /* common */
 847         cx8802_fini_common(dev);
 848         cx88_core_put(dev->core,dev->pci);
 849         kfree(dev);
 850 }
 851
 852 static const struct pci_device_id cx8802_pci_tbl[] = {
 853         {
 854                 .vendor       = 0x14f1,
 855                 .device       = 0x8802,
 856                 .subvendor    = PCI_ANY_ID,
 857                 .subdevice    = PCI_ANY_ID,
 858         },{
 859                 /* --- end of list --- */
 860         }
 861 };
 862 MODULE_DEVICE_TABLE(pci, cx8802_pci_tbl);
 863
 864 static struct pci_driver cx8802_pci_driver = {
 865         .name     = "cx88-mpeg driver manager",
 866         .id_table = cx8802_pci_tbl,
 867         .probe    = cx8802_probe,
 868         .remove   = __devexit_p(cx8802_remove),
 869 };
 870
 871 static int __init cx8802_init(void)
 872 {
 873         printk(KERN_INFO "cx88/2: cx2388x MPEG-TS Driver Manager version %d.%d.%d loaded\n",
 874                (CX88_VERSION_CODE >> 16) & 0xff,
 875                (CX88_VERSION_CODE >>  8) & 0xff,
 876                CX88_VERSION_CODE & 0xff);
 877 #ifdef SNAPSHOT
 878         printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",
 879                SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
 880 #endif
 881         return pci_register_driver(&cx8802_pci_driver);
 882 }
 883
 884 static void __exit cx8802_fini(void)
 885 {
 886         pci_unregister_driver(&cx8802_pci_driver);
 887 }
 888
 889 module_init(cx8802_init);
 890 module_exit(cx8802_fini);
 891 EXPORT_SYMBOL(cx8802_buf_prepare);
 892 EXPORT_SYMBOL(cx8802_buf_queue);
 893 EXPORT_SYMBOL(cx8802_cancel_buffers);
 894
 895 EXPORT_SYMBOL(cx8802_register_driver);
 896 EXPORT_SYMBOL(cx8802_unregister_driver);
 897 EXPORT_SYMBOL(cx8802_get_driver);
 898 /* ----------------------------------------------------------- */
 899 /*
 900  * Local variables:
 901  * c-basic-offset: 8
 902  * End:
 903  * kate: eol "unix"; indent-width 3; remove-trailing-space on; replace-trailing-space-save on; tab-width 8; replace-tabs off; space-indent off; mixed-indent off
 904  */