git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/cx23885/cx23885-core.c

   1 /*
   2  *  Driver for the Conexant CX23885 PCIe bridge
   3  *
   4  *  Copyright (c) 2006 Steven Toth <stoth@hauppauge.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <linux/init.h>
  23 #include <linux/list.h>
  24 #include <linux/module.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/kmod.h>
  27 #include <linux/kernel.h>
  28 #include <linux/slab.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/delay.h>
  31 #include <asm/div64.h>
  32
  33 #include "cx23885.h"
  34
  35 MODULE_DESCRIPTION("Driver for cx23885 based TV cards");
  36 MODULE_AUTHOR("Steven Toth <stoth@hauppauge.com>");
  37 MODULE_LICENSE("GPL");
  38
  39 static unsigned int debug;
  40 module_param(debug,int,0644);
  41 MODULE_PARM_DESC(debug,"enable debug messages");
  42
  43 static unsigned int card[]  = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
  44 module_param_array(card,  int, NULL, 0444);
  45 MODULE_PARM_DESC(card,"card type");
  46
  47 #define dprintk(level, fmt, arg...)\
  48         do { if (debug >= level)\
  49                 printk(KERN_DEBUG "%s/0: " fmt, dev->name, ## arg);\
  50         } while (0)
  51
  52 static unsigned int cx23885_devcount;
  53
  54 static DEFINE_MUTEX(devlist);
  55 LIST_HEAD(cx23885_devlist);
  56
  57 #define NO_SYNC_LINE (-1U)
  58
  59 /* FIXME, these allocations will change when
  60  * analog arrives. The be reviewed.
  61  * CX23887 Assumptions
  62  * 1 line = 16 bytes of CDT
  63  * cmds size = 80
  64  * cdt size = 16 * linesize
  65  * iqsize = 64
  66  * maxlines = 6
  67  *
  68  * Address Space:
  69  * 0x00000000 0x00008fff FIFO clusters
  70  * 0x00010000 0x000104af Channel Management Data Structures
  71  * 0x000104b0 0x000104ff Free
  72  * 0x00010500 0x000108bf 15 channels * iqsize
  73  * 0x000108c0 0x000108ff Free
  74  * 0x00010900 0x00010e9f IQ's + Cluster Descriptor Tables
  75  *                       15 channels * (iqsize + (maxlines * linesize))
  76  * 0x00010ea0 0x00010xxx Free
  77  */
  78
  79 static struct sram_channel cx23887_sram_channels[] = {
  80         [SRAM_CH01] = {
  81                 .name           = "VID A",
  82                 .cmds_start     = 0x10000,
  83                 .ctrl_start     = 0x105b0,
  84                 .cdt            = 0x107b0,
  85                 .fifo_start     = 0x40,
  86                 .fifo_size      = 0x2800,
  87                 .ptr1_reg       = DMA1_PTR1,
  88                 .ptr2_reg       = DMA1_PTR2,
  89                 .cnt1_reg       = DMA1_CNT1,
  90                 .cnt2_reg       = DMA1_CNT2,
  91         },
  92         [SRAM_CH02] = {
  93                 .name           = "ch2",
  94                 .cmds_start     = 0x0,
  95                 .ctrl_start     = 0x0,
  96                 .cdt            = 0x0,
  97                 .fifo_start     = 0x0,
  98                 .fifo_size      = 0x0,
  99                 .ptr1_reg       = DMA2_PTR1,
 100                 .ptr2_reg       = DMA2_PTR2,
 101                 .cnt1_reg       = DMA2_CNT1,
 102                 .cnt2_reg       = DMA2_CNT2,
 103         },
 104         [SRAM_CH03] = {
 105                 .name           = "TS1 B",
 106                 .cmds_start     = 0x100A0,
 107                 .ctrl_start     = 0x10780,
 108                 .cdt            = 0x10400,
 109                 .fifo_start     = 0x5000,
 110                 .fifo_size      = 0x1000,
 111                 .ptr1_reg       = DMA3_PTR1,
 112                 .ptr2_reg       = DMA3_PTR2,
 113                 .cnt1_reg       = DMA3_CNT1,
 114                 .cnt2_reg       = DMA3_CNT2,
 115         },
 116         [SRAM_CH04] = {
 117                 .name           = "ch4",
 118                 .cmds_start     = 0x0,
 119                 .ctrl_start     = 0x0,
 120                 .cdt            = 0x0,
 121                 .fifo_start     = 0x0,
 122                 .fifo_size      = 0x0,
 123                 .ptr1_reg       = DMA4_PTR1,
 124                 .ptr2_reg       = DMA4_PTR2,
 125                 .cnt1_reg       = DMA4_CNT1,
 126                 .cnt2_reg       = DMA4_CNT2,
 127         },
 128         [SRAM_CH05] = {
 129                 .name           = "ch5",
 130                 .cmds_start     = 0x0,
 131                 .ctrl_start     = 0x0,
 132                 .cdt            = 0x0,
 133                 .fifo_start     = 0x0,
 134                 .fifo_size      = 0x0,
 135                 .ptr1_reg       = DMA5_PTR1,
 136                 .ptr2_reg       = DMA5_PTR2,
 137                 .cnt1_reg       = DMA5_CNT1,
 138                 .cnt2_reg       = DMA5_CNT2,
 139         },
 140         [SRAM_CH06] = {
 141                 .name           = "TS2 C",
 142                 .cmds_start     = 0x10140,
 143                 .ctrl_start     = 0x10680,
 144                 .cdt            = 0x108d0,
 145                 .fifo_start     = 0x6000,
 146                 .fifo_size      = 0x1000,
 147                 .ptr1_reg       = DMA5_PTR1,
 148                 .ptr2_reg       = DMA5_PTR2,
 149                 .cnt1_reg       = DMA5_CNT1,
 150                 .cnt2_reg       = DMA5_CNT2,
 151         },
 152         [SRAM_CH07] = {
 153                 .name           = "ch7",
 154                 .cmds_start     = 0x0,
 155                 .ctrl_start     = 0x0,
 156                 .cdt            = 0x0,
 157                 .fifo_start     = 0x0,
 158                 .fifo_size      = 0x0,
 159                 .ptr1_reg       = DMA6_PTR1,
 160                 .ptr2_reg       = DMA6_PTR2,
 161                 .cnt1_reg       = DMA6_CNT1,
 162                 .cnt2_reg       = DMA6_CNT2,
 163         },
 164         [SRAM_CH08] = {
 165                 .name           = "ch8",
 166                 .cmds_start     = 0x0,
 167                 .ctrl_start     = 0x0,
 168                 .cdt            = 0x0,
 169                 .fifo_start     = 0x0,
 170                 .fifo_size      = 0x0,
 171                 .ptr1_reg       = DMA7_PTR1,
 172                 .ptr2_reg       = DMA7_PTR2,
 173                 .cnt1_reg       = DMA7_CNT1,
 174                 .cnt2_reg       = DMA7_CNT2,
 175         },
 176         [SRAM_CH09] = {
 177                 .name           = "ch9",
 178                 .cmds_start     = 0x0,
 179                 .ctrl_start     = 0x0,
 180                 .cdt            = 0x0,
 181                 .fifo_start     = 0x0,
 182                 .fifo_size      = 0x0,
 183                 .ptr1_reg       = DMA8_PTR1,
 184                 .ptr2_reg       = DMA8_PTR2,
 185                 .cnt1_reg       = DMA8_CNT1,
 186                 .cnt2_reg       = DMA8_CNT2,
 187         },
 188 };
 189
 190 static int cx23885_risc_decode(u32 risc)
 191 {
 192         static char *instr[16] = {
 193                 [RISC_SYNC    >> 28] = "sync",
 194                 [RISC_WRITE   >> 28] = "write",
 195                 [RISC_WRITEC  >> 28] = "writec",
 196                 [RISC_READ    >> 28] = "read",
 197                 [RISC_READC   >> 28] = "readc",
 198                 [RISC_JUMP    >> 28] = "jump",
 199                 [RISC_SKIP    >> 28] = "skip",
 200                 [RISC_WRITERM >> 28] = "writerm",
 201                 [RISC_WRITECM >> 28] = "writecm",
 202                 [RISC_WRITECR >> 28] = "writecr",
 203         };
 204         static int incr[16] = {
 205                 [RISC_WRITE   >> 28] = 3,
 206                 [RISC_JUMP    >> 28] = 3,
 207                 [RISC_SKIP    >> 28] = 1,
 208                 [RISC_SYNC    >> 28] = 1,
 209                 [RISC_WRITERM >> 28] = 3,
 210                 [RISC_WRITECM >> 28] = 3,
 211                 [RISC_WRITECR >> 28] = 4,
 212         };
 213         static char *bits[] = {
 214                 "12",   "13",   "14",   "resync",
 215                 "cnt0", "cnt1", "18",   "19",
 216                 "20",   "21",   "22",   "23",
 217                 "irq1", "irq2", "eol",  "sol",
 218         };
 219         int i;
 220
 221         printk("0x%08x [ %s", risc,
 222                instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
 223         for (i = ARRAY_SIZE(bits) - 1; i >= 0; i--)
 224                 if (risc & (1 << (i + 12)))
 225                         printk(" %s", bits[i]);
 226         printk(" count=%d ]\n", risc & 0xfff);
 227         return incr[risc >> 28] ? incr[risc >> 28] : 1;
 228 }
 229
 230 void cx23885_wakeup(struct cx23885_tsport *port,
 231                            struct cx23885_dmaqueue *q, u32 count)
 232 {
 233         struct cx23885_dev *dev = port->dev;
 234         struct cx23885_buffer *buf;
 235         int bc;
 236
 237         for (bc = 0;; bc++) {
 238                 if (list_empty(&q->active))
 239                         break;
 240                 buf = list_entry(q->active.next,
 241                                  struct cx23885_buffer, vb.queue);
 242
 243                 /* count comes from the hw and is is 16bit wide --
 244                  * this trick handles wrap-arounds correctly for
 245                  * up to 32767 buffers in flight... */
 246                 if ((s16) (count - buf->count) < 0)
 247                         break;
 248
 249                 do_gettimeofday(&buf->vb.ts);
 250                 dprintk(2, "[%p/%d] wakeup reg=%d buf=%d\n", buf, buf->vb.i,
 251                         count, buf->count);
 252                 buf->vb.state = VIDEOBUF_DONE;
 253                 list_del(&buf->vb.queue);
 254                 wake_up(&buf->vb.done);
 255         }
 256         if (list_empty(&q->active)) {
 257                 del_timer(&q->timeout);
 258         } else {
 259                 mod_timer(&q->timeout, jiffies + BUFFER_TIMEOUT);
 260         }
 261         if (bc != 1)
 262                 printk("%s: %d buffers handled (should be 1)\n",
 263                        __func__, bc);
 264 }
 265
 266 int cx23885_sram_channel_setup(struct cx23885_dev *dev,
 267                                       struct sram_channel *ch,
 268                                       unsigned int bpl, u32 risc)
 269 {
 270         unsigned int i, lines;
 271         u32 cdt;
 272
 273         if (ch->cmds_start == 0)
 274         {
 275                 dprintk(1, "%s() Erasing channel [%s]\n", __func__,
 276                         ch->name);
 277                 cx_write(ch->ptr1_reg, 0);
 278                 cx_write(ch->ptr2_reg, 0);
 279                 cx_write(ch->cnt2_reg, 0);
 280                 cx_write(ch->cnt1_reg, 0);
 281                 return 0;
 282         } else {
 283                 dprintk(1, "%s() Configuring channel [%s]\n", __func__,
 284                         ch->name);
 285         }
 286
 287         bpl   = (bpl + 7) & ~7; /* alignment */
 288         cdt   = ch->cdt;
 289         lines = ch->fifo_size / bpl;
 290         if (lines > 6)
 291                 lines = 6;
 292         BUG_ON(lines < 2);
 293
 294         cx_write(8 + 0, cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC) );
 295         cx_write(8 + 4, cpu_to_le32(8) );
 296         cx_write(8 + 8, cpu_to_le32(0) );
 297
 298         /* write CDT */
 299         for (i = 0; i < lines; i++) {
 300                 dprintk(2, "%s() 0x%08x <- 0x%08x\n", __func__, cdt + 16*i,
 301                         ch->fifo_start + bpl*i);
 302                 cx_write(cdt + 16*i, ch->fifo_start + bpl*i);
 303                 cx_write(cdt + 16*i +  4, 0);
 304                 cx_write(cdt + 16*i +  8, 0);
 305                 cx_write(cdt + 16*i + 12, 0);
 306         }
 307
 308         /* write CMDS */
 309         if (ch->jumponly)
 310                 cx_write(ch->cmds_start +  0, 8);
 311         else
 312                 cx_write(ch->cmds_start +  0, risc);
 313         cx_write(ch->cmds_start +  4, 0); /* 64 bits 63-32 */
 314         cx_write(ch->cmds_start +  8, cdt);
 315         cx_write(ch->cmds_start + 12, (lines*16) >> 3);
 316         cx_write(ch->cmds_start + 16, ch->ctrl_start);
 317         if (ch->jumponly)
 318                 cx_write(ch->cmds_start + 20, 0x80000000 | (64 >> 2) );
 319         else
 320                 cx_write(ch->cmds_start + 20, 64 >> 2);
 321         for (i = 24; i < 80; i += 4)
 322                 cx_write(ch->cmds_start + i, 0);
 323
 324         /* fill registers */
 325         cx_write(ch->ptr1_reg, ch->fifo_start);
 326         cx_write(ch->ptr2_reg, cdt);
 327         cx_write(ch->cnt2_reg, (lines*16) >> 3);
 328         cx_write(ch->cnt1_reg, (bpl >> 3) -1);
 329
 330         dprintk(2,"[bridge %d] sram setup %s: bpl=%d lines=%d\n",
 331                 dev->bridge,
 332                 ch->name,
 333                 bpl,
 334                 lines);
 335
 336         return 0;
 337 }
 338
 339 void cx23885_sram_channel_dump(struct cx23885_dev *dev,
 340                                       struct sram_channel *ch)
 341 {
 342         static char *name[] = {
 343                 "init risc lo",
 344                 "init risc hi",
 345                 "cdt base",
 346                 "cdt size",
 347                 "iq base",
 348                 "iq size",
 349                 "risc pc lo",
 350                 "risc pc hi",
 351                 "iq wr ptr",
 352                 "iq rd ptr",
 353                 "cdt current",
 354                 "pci target lo",
 355                 "pci target hi",
 356                 "line / byte",
 357         };
 358         u32 risc;
 359         unsigned int i, j, n;
 360
 361         printk("%s: %s - dma channel status dump\n",
 362                dev->name, ch->name);
 363         for (i = 0; i < ARRAY_SIZE(name); i++)
 364                 printk("%s:   cmds: %-15s: 0x%08x\n",
 365                        dev->name, name[i],
 366                        cx_read(ch->cmds_start + 4*i));
 367
 368         for (i = 0; i < 4; i++) {
 369                 risc = cx_read(ch->cmds_start + 4 * (i + 14));
 370                 printk("%s:   risc%d: ", dev->name, i);
 371                 cx23885_risc_decode(risc);
 372         }
 373         for (i = 0; i < (64 >> 2); i += n) {
 374                 risc = cx_read(ch->ctrl_start + 4 * i);
 375                 /* No consideration for bits 63-32 */
 376
 377                 printk("%s:   (0x%08x) iq %x: ", dev->name,
 378                        ch->ctrl_start + 4 * i, i);
 379                 n = cx23885_risc_decode(risc);
 380                 for (j = 1; j < n; j++) {
 381                         risc = cx_read(ch->ctrl_start + 4 * (i + j));
 382                         printk("%s:   iq %x: 0x%08x [ arg #%d ]\n",
 383                                dev->name, i+j, risc, j);
 384                 }
 385         }
 386
 387         printk("%s: fifo: 0x%08x -> 0x%x\n",
 388                dev->name, ch->fifo_start, ch->fifo_start+ch->fifo_size);
 389         printk("%s: ctrl: 0x%08x -> 0x%x\n",
 390                dev->name, ch->ctrl_start, ch->ctrl_start + 6*16);
 391         printk("%s:   ptr1_reg: 0x%08x\n",
 392                dev->name, cx_read(ch->ptr1_reg));
 393         printk("%s:   ptr2_reg: 0x%08x\n",
 394                dev->name, cx_read(ch->ptr2_reg));
 395         printk("%s:   cnt1_reg: 0x%08x\n",
 396                dev->name, cx_read(ch->cnt1_reg));
 397         printk("%s:   cnt2_reg: 0x%08x\n",
 398                dev->name, cx_read(ch->cnt2_reg));
 399 }
 400
 401 static void cx23885_risc_disasm(struct cx23885_tsport *port,
 402                                 struct btcx_riscmem *risc)
 403 {
 404         struct cx23885_dev *dev = port->dev;
 405         unsigned int i, j, n;
 406
 407         printk("%s: risc disasm: %p [dma=0x%08lx]\n",
 408                dev->name, risc->cpu, (unsigned long)risc->dma);
 409         for (i = 0; i < (risc->size >> 2); i += n) {
 410                 printk("%s:   %04d: ", dev->name, i);
 411                 n = cx23885_risc_decode(risc->cpu[i]);
 412                 for (j = 1; j < n; j++)
 413                         printk("%s:   %04d: 0x%08x [ arg #%d ]\n",
 414                                dev->name, i + j, risc->cpu[i + j], j);
 415                 if (risc->cpu[i] == RISC_JUMP)
 416                         break;
 417         }
 418 }
 419
 420 static void cx23885_shutdown(struct cx23885_dev *dev)
 421 {
 422         /* disable RISC controller */
 423         cx_write(DEV_CNTRL2, 0);
 424
 425         /* Disable all IR activity */
 426         cx_write(IR_CNTRL_REG, 0);
 427
 428         /* Disable Video A/B activity */
 429         cx_write(VID_A_DMA_CTL, 0);
 430         cx_write(VID_B_DMA_CTL, 0);
 431         cx_write(VID_C_DMA_CTL, 0);
 432
 433         /* Disable Audio activity */
 434         cx_write(AUD_INT_DMA_CTL, 0);
 435         cx_write(AUD_EXT_DMA_CTL, 0);
 436
 437         /* Disable Serial port */
 438         cx_write(UART_CTL, 0);
 439
 440         /* Disable Interrupts */
 441         cx_write(PCI_INT_MSK, 0);
 442         cx_write(VID_A_INT_MSK, 0);
 443         cx_write(VID_B_INT_MSK, 0);
 444         cx_write(VID_C_INT_MSK, 0);
 445         cx_write(AUDIO_INT_INT_MSK, 0);
 446         cx_write(AUDIO_EXT_INT_MSK, 0);
 447
 448 }
 449
 450 static void cx23885_reset(struct cx23885_dev *dev)
 451 {
 452         dprintk(1, "%s()\n", __func__);
 453
 454         cx23885_shutdown(dev);
 455
 456         cx_write(PCI_INT_STAT, 0xffffffff);
 457         cx_write(VID_A_INT_STAT, 0xffffffff);
 458         cx_write(VID_B_INT_STAT, 0xffffffff);
 459         cx_write(VID_C_INT_STAT, 0xffffffff);
 460         cx_write(AUDIO_INT_INT_STAT, 0xffffffff);
 461         cx_write(AUDIO_EXT_INT_STAT, 0xffffffff);
 462         cx_write(CLK_DELAY, cx_read(CLK_DELAY) & 0x80000000);
 463
 464         mdelay(100);
 465
 466         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH01],
 467                 720*4, 0);
 468         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH02], 128, 0);
 469         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH03],
 470                 188*4, 0);
 471         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH04], 128, 0);
 472         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH05], 128, 0);
 473         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH06],
 474                 188*4, 0);
 475         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH07], 128, 0);
 476         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH08], 128, 0);
 477         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH09], 128, 0);
 478
 479         cx23885_gpio_setup(dev);
 480 }
 481
 482
 483 static int cx23885_pci_quirks(struct cx23885_dev *dev)
 484 {
 485         dprintk(1, "%s()\n", __func__);
 486
 487         /* The cx23885 bridge has a weird bug which causes NMI to be asserted
 488          * when DMA begins if RDR_TLCTL0 bit4 is not cleared. It does not
 489          * occur on the cx23887 bridge.
 490          */
 491         if(dev->bridge == CX23885_BRIDGE_885)
 492                 cx_clear(RDR_TLCTL0, 1 << 4);
 493
 494         return 0;
 495 }
 496
 497 static int get_resources(struct cx23885_dev *dev)
 498 {
 499         if (request_mem_region(pci_resource_start(dev->pci,0),
 500                                pci_resource_len(dev->pci,0),
 501                                dev->name))
 502                 return 0;
 503
 504         printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx\n",
 505                 dev->name, (unsigned long long)pci_resource_start(dev->pci,0));
 506
 507         return -EBUSY;
 508 }
 509
 510 static void cx23885_timeout(unsigned long data);
 511 int cx23885_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
 512                                 u32 reg, u32 mask, u32 value);
 513
 514 static int cx23885_init_tsport(struct cx23885_dev *dev, struct cx23885_tsport *port, int portno)
 515 {
 516         dprintk(1, "%s(portno=%d)\n", __func__, portno);
 517
 518         /* Transport bus init dma queue  - Common settings */
 519         port->dma_ctl_val        = 0x11; /* Enable RISC controller and Fifo */
 520         port->ts_int_msk_val     = 0x1111; /* TS port bits for RISC */
 521         port->vld_misc_val       = 0x0;
 522         port->hw_sop_ctrl_val    = (0x47 << 16 | 188 << 4);
 523
 524         spin_lock_init(&port->slock);
 525         port->dev = dev;
 526         port->nr = portno;
 527
 528         INIT_LIST_HEAD(&port->mpegq.active);
 529         INIT_LIST_HEAD(&port->mpegq.queued);
 530         port->mpegq.timeout.function = cx23885_timeout;
 531         port->mpegq.timeout.data = (unsigned long)port;
 532         init_timer(&port->mpegq.timeout);
 533
 534         switch(portno) {
 535         case 1:
 536                 port->reg_gpcnt          = VID_B_GPCNT;
 537                 port->reg_gpcnt_ctl      = VID_B_GPCNT_CTL;
 538                 port->reg_dma_ctl        = VID_B_DMA_CTL;
 539                 port->reg_lngth          = VID_B_LNGTH;
 540                 port->reg_hw_sop_ctrl    = VID_B_HW_SOP_CTL;
 541                 port->reg_gen_ctrl       = VID_B_GEN_CTL;
 542                 port->reg_bd_pkt_status  = VID_B_BD_PKT_STATUS;
 543                 port->reg_sop_status     = VID_B_SOP_STATUS;
 544                 port->reg_fifo_ovfl_stat = VID_B_FIFO_OVFL_STAT;
 545                 port->reg_vld_misc       = VID_B_VLD_MISC;
 546                 port->reg_ts_clk_en      = VID_B_TS_CLK_EN;
 547                 port->reg_src_sel        = VID_B_SRC_SEL;
 548                 port->reg_ts_int_msk     = VID_B_INT_MSK;
 549                 port->reg_ts_int_stat    = VID_B_INT_STAT;
 550                 port->sram_chno          = SRAM_CH03; /* VID_B */
 551                 port->pci_irqmask        = 0x02; /* VID_B bit1 */
 552                 break;
 553         case 2:
 554                 port->reg_gpcnt          = VID_C_GPCNT;
 555                 port->reg_gpcnt_ctl      = VID_C_GPCNT_CTL;
 556                 port->reg_dma_ctl        = VID_C_DMA_CTL;
 557                 port->reg_lngth          = VID_C_LNGTH;
 558                 port->reg_hw_sop_ctrl    = VID_C_HW_SOP_CTL;
 559                 port->reg_gen_ctrl       = VID_C_GEN_CTL;
 560                 port->reg_bd_pkt_status  = VID_C_BD_PKT_STATUS;
 561                 port->reg_sop_status     = VID_C_SOP_STATUS;
 562                 port->reg_fifo_ovfl_stat = VID_C_FIFO_OVFL_STAT;
 563                 port->reg_vld_misc       = VID_C_VLD_MISC;
 564                 port->reg_ts_clk_en      = VID_C_TS_CLK_EN;
 565                 port->reg_src_sel        = 0;
 566                 port->reg_ts_int_msk     = VID_C_INT_MSK;
 567                 port->reg_ts_int_stat    = VID_C_INT_STAT;
 568                 port->sram_chno          = SRAM_CH06; /* VID_C */
 569                 port->pci_irqmask        = 0x04; /* VID_C bit2 */
 570                 break;
 571         default:
 572                 BUG();
 573         }
 574
 575         cx23885_risc_stopper(dev->pci, &port->mpegq.stopper,
 576                      port->reg_dma_ctl, port->dma_ctl_val, 0x00);
 577
 578         return 0;
 579 }
 580
 581 static void cx23885_dev_checkrevision(struct cx23885_dev *dev)
 582 {
 583         switch (cx_read(RDR_CFG2) & 0xff) {
 584         case 0x00:
 585                 /* cx23885 */
 586                 dev->hwrevision = 0xa0;
 587                 break;
 588         case 0x01:
 589                 /* CX23885-12Z */
 590                 dev->hwrevision = 0xa1;
 591                 break;
 592         case 0x02:
 593                 /* CX23885-13Z */
 594                 dev->hwrevision = 0xb0;
 595                 break;
 596         case 0x03:
 597                 /* CX23888-22Z */
 598                 dev->hwrevision = 0xc0;
 599                 break;
 600         case 0x0e:
 601                 /* CX23887-15Z */
 602                 dev->hwrevision = 0xc0;
 603         case 0x0f:
 604                 /* CX23887-14Z */
 605                 dev->hwrevision = 0xb1;
 606                 break;
 607         default:
 608                 printk(KERN_ERR "%s() New hardware revision found 0x%x\n",
 609                         __func__, dev->hwrevision);
 610         }
 611         if (dev->hwrevision)
 612                 printk(KERN_INFO "%s() Hardware revision = 0x%02x\n",
 613                         __func__, dev->hwrevision);
 614         else
 615                 printk(KERN_ERR "%s() Hardware revision unknown 0x%x\n",
 616                         __func__, dev->hwrevision);
 617 }
 618
 619 static int cx23885_dev_setup(struct cx23885_dev *dev)
 620 {
 621         int i;
 622
 623         mutex_init(&dev->lock);
 624
 625         atomic_inc(&dev->refcount);
 626
 627         dev->nr = cx23885_devcount++;
 628         dev->sram_channels = cx23887_sram_channels;
 629         sprintf(dev->name, "cx23885[%d]", dev->nr);
 630
 631         mutex_lock(&devlist);
 632         list_add_tail(&dev->devlist, &cx23885_devlist);
 633         mutex_unlock(&devlist);
 634
 635         /* Configure the internal memory */
 636         if(dev->pci->device == 0x8880) {
 637                 dev->bridge = CX23885_BRIDGE_887;
 638                 /* Apply a sensible clock frequency for the PCIe bridge */
 639                 dev->clk_freq = 25000000;
 640         } else
 641         if(dev->pci->device == 0x8852) {
 642                 dev->bridge = CX23885_BRIDGE_885;
 643                 /* Apply a sensible clock frequency for the PCIe bridge */
 644                 dev->clk_freq = 28000000;
 645         } else
 646                 BUG();
 647
 648         dprintk(1, "%s() Memory configured for PCIe bridge type %d\n",
 649                 __func__, dev->bridge);
 650
 651         /* board config */
 652         dev->board = UNSET;
 653         if (card[dev->nr] < cx23885_bcount)
 654                 dev->board = card[dev->nr];
 655         for (i = 0; UNSET == dev->board  &&  i < cx23885_idcount; i++)
 656                 if (dev->pci->subsystem_vendor == cx23885_subids[i].subvendor &&
 657                     dev->pci->subsystem_device == cx23885_subids[i].subdevice)
 658                         dev->board = cx23885_subids[i].card;
 659         if (UNSET == dev->board) {
 660                 dev->board = CX23885_BOARD_UNKNOWN;
 661                 cx23885_card_list(dev);
 662         }
 663
 664         /* If the user specific a clk freq override, apply it */
 665         if (cx23885_boards[dev->board].clk_freq > 0)
 666                 dev->clk_freq = cx23885_boards[dev->board].clk_freq;
 667
 668         dev->pci_bus  = dev->pci->bus->number;
 669         dev->pci_slot = PCI_SLOT(dev->pci->devfn);
 670         dev->pci_irqmask = 0x001f00;
 671
 672         /* External Master 1 Bus */
 673         dev->i2c_bus[0].nr = 0;
 674         dev->i2c_bus[0].dev = dev;
 675         dev->i2c_bus[0].reg_stat  = I2C1_STAT;
 676         dev->i2c_bus[0].reg_ctrl  = I2C1_CTRL;
 677         dev->i2c_bus[0].reg_addr  = I2C1_ADDR;
 678         dev->i2c_bus[0].reg_rdata = I2C1_RDATA;
 679         dev->i2c_bus[0].reg_wdata = I2C1_WDATA;
 680         dev->i2c_bus[0].i2c_period = (0x9d << 24); /* 100kHz */
 681
 682         /* External Master 2 Bus */
 683         dev->i2c_bus[1].nr = 1;
 684         dev->i2c_bus[1].dev = dev;
 685         dev->i2c_bus[1].reg_stat  = I2C2_STAT;
 686         dev->i2c_bus[1].reg_ctrl  = I2C2_CTRL;
 687         dev->i2c_bus[1].reg_addr  = I2C2_ADDR;
 688         dev->i2c_bus[1].reg_rdata = I2C2_RDATA;
 689         dev->i2c_bus[1].reg_wdata = I2C2_WDATA;
 690         dev->i2c_bus[1].i2c_period = (0x9d << 24); /* 100kHz */
 691
 692         /* Internal Master 3 Bus */
 693         dev->i2c_bus[2].nr = 2;
 694         dev->i2c_bus[2].dev = dev;
 695         dev->i2c_bus[2].reg_stat  = I2C3_STAT;
 696         dev->i2c_bus[2].reg_ctrl  = I2C3_CTRL;
 697         dev->i2c_bus[2].reg_addr  = I2C3_ADDR;
 698         dev->i2c_bus[2].reg_rdata = I2C3_RDATA;
 699         dev->i2c_bus[2].reg_wdata = I2C3_WDATA;
 700         dev->i2c_bus[2].i2c_period = (0x07 << 24); /* 1.95MHz */
 701
 702         if ((cx23885_boards[dev->board].portb == CX23885_MPEG_DVB) ||
 703                 (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER))
 704                 cx23885_init_tsport(dev, &dev->ts1, 1);
 705
 706         if ((cx23885_boards[dev->board].portc == CX23885_MPEG_DVB) ||
 707                 (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER))
 708                 cx23885_init_tsport(dev, &dev->ts2, 2);
 709
 710         if (get_resources(dev) < 0) {
 711                 printk(KERN_ERR "CORE %s No more PCIe resources for "
 712                        "subsystem: %04x:%04x\n",
 713                        dev->name, dev->pci->subsystem_vendor,
 714                        dev->pci->subsystem_device);
 715
 716                 cx23885_devcount--;
 717                 return -ENODEV;
 718         }
 719
 720         /* PCIe stuff */
 721         dev->lmmio = ioremap(pci_resource_start(dev->pci,0),
 722                              pci_resource_len(dev->pci,0));
 723
 724         dev->bmmio = (u8 __iomem *)dev->lmmio;
 725
 726         printk(KERN_INFO "CORE %s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
 727                dev->name, dev->pci->subsystem_vendor,
 728                dev->pci->subsystem_device, cx23885_boards[dev->board].name,
 729                dev->board, card[dev->nr] == dev->board ?
 730                "insmod option" : "autodetected");
 731
 732         cx23885_pci_quirks(dev);
 733
 734         /* Assume some sensible defaults */
 735         dev->tuner_type = cx23885_boards[dev->board].tuner_type;
 736         dev->tuner_addr = cx23885_boards[dev->board].tuner_addr;
 737         dev->radio_type = cx23885_boards[dev->board].radio_type;
 738         dev->radio_addr = cx23885_boards[dev->board].radio_addr;
 739
 740         dprintk(1, "%s() tuner_type = 0x%x tuner_addr = 0x%x\n",
 741                 __func__, dev->tuner_type, dev->tuner_addr);
 742         dprintk(1, "%s() radio_type = 0x%x radio_addr = 0x%x\n",
 743                 __func__, dev->radio_type, dev->radio_addr);
 744
 745         /* init hardware */
 746         cx23885_reset(dev);
 747
 748         cx23885_i2c_register(&dev->i2c_bus[0]);
 749         cx23885_i2c_register(&dev->i2c_bus[1]);
 750         cx23885_i2c_register(&dev->i2c_bus[2]);
 751         cx23885_card_setup(dev);
 752         cx23885_call_i2c_clients (&dev->i2c_bus[0], TUNER_SET_STANDBY, NULL);
 753         cx23885_ir_init(dev);
 754
 755         if (cx23885_boards[dev->board].porta == CX23885_ANALOG_VIDEO) {
 756                 if (cx23885_video_register(dev) < 0) {
 757                         printk(KERN_ERR "%s() Failed to register analog "
 758                                 "video adapters on VID_A\n", __func__);
 759                 }
 760         }
 761
 762         if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB) {
 763                 if (cx23885_dvb_register(&dev->ts1) < 0) {
 764                         printk(KERN_ERR "%s() Failed to register dvb adapters on VID_B\n",
 765                                __func__);
 766                 }
 767         } else
 768         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) {
 769                 if (cx23885_417_register(dev) < 0) {
 770                         printk(KERN_ERR
 771                                 "%s() Failed to register 417 on VID_B\n",
 772                                __func__);
 773                 }
 774         }
 775
 776         if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB) {
 777                 if (cx23885_dvb_register(&dev->ts2) < 0) {
 778                         printk(KERN_ERR
 779                                 "%s() Failed to register dvb on VID_C\n",
 780                                __func__);
 781                 }
 782         } else
 783         if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER) {
 784                 if (cx23885_417_register(dev) < 0) {
 785                         printk(KERN_ERR
 786                                 "%s() Failed to register 417 on VID_C\n",
 787                                __func__);
 788                 }
 789         }
 790
 791         cx23885_dev_checkrevision(dev);
 792
 793         return 0;
 794 }
 795
 796 static void cx23885_dev_unregister(struct cx23885_dev *dev)
 797 {
 798         release_mem_region(pci_resource_start(dev->pci,0),
 799                            pci_resource_len(dev->pci,0));
 800
 801         if (!atomic_dec_and_test(&dev->refcount))
 802                 return;
 803
 804         if (cx23885_boards[dev->board].porta == CX23885_ANALOG_VIDEO)
 805                 cx23885_video_unregister(dev);
 806
 807         if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB)
 808                 cx23885_dvb_unregister(&dev->ts1);
 809
 810         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
 811                 cx23885_417_unregister(dev);
 812
 813         if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB)
 814                 cx23885_dvb_unregister(&dev->ts2);
 815
 816         if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER)
 817                 cx23885_417_unregister(dev);
 818
 819         cx23885_i2c_unregister(&dev->i2c_bus[2]);
 820         cx23885_i2c_unregister(&dev->i2c_bus[1]);
 821         cx23885_i2c_unregister(&dev->i2c_bus[0]);
 822
 823         iounmap(dev->lmmio);
 824 }
 825
 826 static __le32* cx23885_risc_field(__le32 *rp, struct scatterlist *sglist,
 827                                unsigned int offset, u32 sync_line,
 828                                unsigned int bpl, unsigned int padding,
 829                                unsigned int lines)
 830 {
 831         struct scatterlist *sg;
 832         unsigned int line, todo;
 833
 834         /* sync instruction */
 835         if (sync_line != NO_SYNC_LINE)
 836                 *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
 837
 838         /* scan lines */
 839         sg = sglist;
 840         for (line = 0; line < lines; line++) {
 841                 while (offset && offset >= sg_dma_len(sg)) {
 842                         offset -= sg_dma_len(sg);
 843                         sg++;
 844                 }
 845                 if (bpl <= sg_dma_len(sg)-offset) {
 846                         /* fits into current chunk */
 847                         *(rp++)=cpu_to_le32(RISC_WRITE|RISC_SOL|RISC_EOL|bpl);
 848                         *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset);
 849                         *(rp++)=cpu_to_le32(0); /* bits 63-32 */
 850                         offset+=bpl;
 851                 } else {
 852                         /* scanline needs to be split */
 853                         todo = bpl;
 854                         *(rp++)=cpu_to_le32(RISC_WRITE|RISC_SOL|
 855                                             (sg_dma_len(sg)-offset));
 856                         *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset);
 857                         *(rp++)=cpu_to_le32(0); /* bits 63-32 */
 858                         todo -= (sg_dma_len(sg)-offset);
 859                         offset = 0;
 860                         sg++;
 861                         while (todo > sg_dma_len(sg)) {
 862                                 *(rp++)=cpu_to_le32(RISC_WRITE|
 863                                                     sg_dma_len(sg));
 864                                 *(rp++)=cpu_to_le32(sg_dma_address(sg));
 865                                 *(rp++)=cpu_to_le32(0); /* bits 63-32 */
 866                                 todo -= sg_dma_len(sg);
 867                                 sg++;
 868                         }
 869                         *(rp++)=cpu_to_le32(RISC_WRITE|RISC_EOL|todo);
 870                         *(rp++)=cpu_to_le32(sg_dma_address(sg));
 871                         *(rp++)=cpu_to_le32(0); /* bits 63-32 */
 872                         offset += todo;
 873                 }
 874                 offset += padding;
 875         }
 876
 877         return rp;
 878 }
 879
 880 int cx23885_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
 881                         struct scatterlist *sglist, unsigned int top_offset,
 882                         unsigned int bottom_offset, unsigned int bpl,
 883                         unsigned int padding, unsigned int lines)
 884 {
 885         u32 instructions, fields;
 886         __le32 *rp;
 887         int rc;
 888
 889         fields = 0;
 890         if (UNSET != top_offset)
 891                 fields++;
 892         if (UNSET != bottom_offset)
 893                 fields++;
 894
 895         /* estimate risc mem: worst case is one write per page border +
 896            one write per scan line + syncs + jump (all 2 dwords).  Padding
 897            can cause next bpl to start close to a page border.  First DMA
 898            region may be smaller than PAGE_SIZE */
 899         /* write and jump need and extra dword */
 900         instructions  = fields * (1 + ((bpl + padding) * lines) / PAGE_SIZE + lines);
 901         instructions += 2;
 902         if ((rc = btcx_riscmem_alloc(pci,risc,instructions*12)) < 0)
 903                 return rc;
 904
 905         /* write risc instructions */
 906         rp = risc->cpu;
 907         if (UNSET != top_offset)
 908                 rp = cx23885_risc_field(rp, sglist, top_offset, 0,
 909                                         bpl, padding, lines);
 910         if (UNSET != bottom_offset)
 911                 rp = cx23885_risc_field(rp, sglist, bottom_offset, 0x200,
 912                                         bpl, padding, lines);
 913
 914         /* save pointer to jmp instruction address */
 915         risc->jmp = rp;
 916         BUG_ON((risc->jmp - risc->cpu + 2) * sizeof (*risc->cpu) > risc->size);
 917         return 0;
 918 }
 919
 920 static int cx23885_risc_databuffer(struct pci_dev *pci,
 921                                    struct btcx_riscmem *risc,
 922                                    struct scatterlist *sglist,
 923                                    unsigned int bpl,
 924                                    unsigned int lines)
 925 {
 926         u32 instructions;
 927         __le32 *rp;
 928         int rc;
 929
 930         /* estimate risc mem: worst case is one write per page border +
 931            one write per scan line + syncs + jump (all 2 dwords).  Here
 932            there is no padding and no sync.  First DMA region may be smaller
 933            than PAGE_SIZE */
 934         /* Jump and write need an extra dword */
 935         instructions  = 1 + (bpl * lines) / PAGE_SIZE + lines;
 936         instructions += 1;
 937
 938         if ((rc = btcx_riscmem_alloc(pci,risc,instructions*12)) < 0)
 939                 return rc;
 940
 941         /* write risc instructions */
 942         rp = risc->cpu;
 943         rp = cx23885_risc_field(rp, sglist, 0, NO_SYNC_LINE, bpl, 0, lines);
 944
 945         /* save pointer to jmp instruction address */
 946         risc->jmp = rp;
 947         BUG_ON((risc->jmp - risc->cpu + 2) * sizeof (*risc->cpu) > risc->size);
 948         return 0;
 949 }
 950
 951 int cx23885_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
 952                                 u32 reg, u32 mask, u32 value)
 953 {
 954         __le32 *rp;
 955         int rc;
 956
 957         if ((rc = btcx_riscmem_alloc(pci, risc, 4*16)) < 0)
 958                 return rc;
 959
 960         /* write risc instructions */
 961         rp = risc->cpu;
 962         *(rp++) = cpu_to_le32(RISC_WRITECR  | RISC_IRQ2);
 963         *(rp++) = cpu_to_le32(reg);
 964         *(rp++) = cpu_to_le32(value);
 965         *(rp++) = cpu_to_le32(mask);
 966         *(rp++) = cpu_to_le32(RISC_JUMP);
 967         *(rp++) = cpu_to_le32(risc->dma);
 968         *(rp++) = cpu_to_le32(0); /* bits 63-32 */
 969         return 0;
 970 }
 971
 972 void cx23885_free_buffer(struct videobuf_queue *q, struct cx23885_buffer *buf)
 973 {
 974         struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
 975
 976         BUG_ON(in_interrupt());
 977         videobuf_waiton(&buf->vb, 0, 0);
 978         videobuf_dma_unmap(q, dma);
 979         videobuf_dma_free(dma);
 980         btcx_riscmem_free(to_pci_dev(q->dev), &buf->risc);
 981         buf->vb.state = VIDEOBUF_NEEDS_INIT;
 982 }
 983
 984 static void cx23885_tsport_reg_dump(struct cx23885_tsport *port)
 985 {
 986         struct cx23885_dev *dev = port->dev;
 987
 988         dprintk(1, "%s() Register Dump\n", __func__);
 989         dprintk(1, "%s() DEV_CNTRL2               0x%08X\n", __func__,
 990                 cx_read(DEV_CNTRL2));
 991         dprintk(1, "%s() PCI_INT_MSK              0x%08X\n", __func__,
 992                 cx_read(PCI_INT_MSK));
 993         dprintk(1, "%s() AUD_INT_INT_MSK          0x%08X\n", __func__,
 994                 cx_read(AUDIO_INT_INT_MSK));
 995         dprintk(1, "%s() AUD_INT_DMA_CTL          0x%08X\n", __func__,
 996                 cx_read(AUD_INT_DMA_CTL));
 997         dprintk(1, "%s() AUD_EXT_INT_MSK          0x%08X\n", __func__,
 998                 cx_read(AUDIO_EXT_INT_MSK));
 999         dprintk(1, "%s() AUD_EXT_DMA_CTL          0x%08X\n", __func__,
1000                 cx_read(AUD_EXT_DMA_CTL));
1001         dprintk(1, "%s() PAD_CTRL                 0x%08X\n", __func__,
1002                 cx_read(PAD_CTRL));
1003         dprintk(1, "%s() ALT_PIN_OUT_SEL          0x%08X\n", __func__,
1004                 cx_read(ALT_PIN_OUT_SEL));
1005         dprintk(1, "%s() GPIO2                    0x%08X\n", __func__,
1006                 cx_read(GPIO2));
1007         dprintk(1, "%s() gpcnt(0x%08X)          0x%08X\n", __func__,
1008                 port->reg_gpcnt, cx_read(port->reg_gpcnt));
1009         dprintk(1, "%s() gpcnt_ctl(0x%08X)      0x%08x\n", __func__,
1010                 port->reg_gpcnt_ctl, cx_read(port->reg_gpcnt_ctl));
1011         dprintk(1, "%s() dma_ctl(0x%08X)        0x%08x\n", __func__,
1012                 port->reg_dma_ctl, cx_read(port->reg_dma_ctl));
1013         dprintk(1, "%s() src_sel(0x%08X)        0x%08x\n", __func__,
1014                 port->reg_src_sel, cx_read(port->reg_src_sel));
1015         dprintk(1, "%s() lngth(0x%08X)          0x%08x\n", __func__,
1016                 port->reg_lngth, cx_read(port->reg_lngth));
1017         dprintk(1, "%s() hw_sop_ctrl(0x%08X)    0x%08x\n", __func__,
1018                 port->reg_hw_sop_ctrl, cx_read(port->reg_hw_sop_ctrl));
1019         dprintk(1, "%s() gen_ctrl(0x%08X)       0x%08x\n", __func__,
1020                 port->reg_gen_ctrl, cx_read(port->reg_gen_ctrl));
1021         dprintk(1, "%s() bd_pkt_status(0x%08X)  0x%08x\n", __func__,
1022                 port->reg_bd_pkt_status, cx_read(port->reg_bd_pkt_status));
1023         dprintk(1, "%s() sop_status(0x%08X)     0x%08x\n", __func__,
1024                 port->reg_sop_status, cx_read(port->reg_sop_status));
1025         dprintk(1, "%s() fifo_ovfl_stat(0x%08X) 0x%08x\n", __func__,
1026                 port->reg_fifo_ovfl_stat, cx_read(port->reg_fifo_ovfl_stat));
1027         dprintk(1, "%s() vld_misc(0x%08X)       0x%08x\n", __func__,
1028                 port->reg_vld_misc, cx_read(port->reg_vld_misc));
1029         dprintk(1, "%s() ts_clk_en(0x%08X)      0x%08x\n", __func__,
1030                 port->reg_ts_clk_en, cx_read(port->reg_ts_clk_en));
1031         dprintk(1, "%s() ts_int_msk(0x%08X)     0x%08x\n", __func__,
1032                 port->reg_ts_int_msk, cx_read(port->reg_ts_int_msk));
1033 }
1034
1035 static int cx23885_start_dma(struct cx23885_tsport *port,
1036                              struct cx23885_dmaqueue *q,
1037                              struct cx23885_buffer   *buf)
1038 {
1039         struct cx23885_dev *dev = port->dev;
1040         u32 reg;
1041
1042         dprintk(1, "%s() w: %d, h: %d, f: %d\n", __func__,
1043                 buf->vb.width, buf->vb.height, buf->vb.field);
1044
1045         /* setup fifo + format */
1046         cx23885_sram_channel_setup(dev,
1047                                    &dev->sram_channels[ port->sram_chno ],
1048                                    port->ts_packet_size, buf->risc.dma);
1049         if(debug > 5) {
1050                 cx23885_sram_channel_dump(dev, &dev->sram_channels[ port->sram_chno ] );
1051                 cx23885_risc_disasm(port, &buf->risc);
1052         }
1053
1054         /* write TS length to chip */
1055         cx_write(port->reg_lngth, buf->vb.width);
1056
1057         if ( (!(cx23885_boards[dev->board].portb & CX23885_MPEG_DVB)) &&
1058                 (!(cx23885_boards[dev->board].portc & CX23885_MPEG_DVB)) ) {
1059                 printk( "%s() Failed. Unsupported value in .portb/c (0x%08x)/(0x%08x)\n",
1060                         __func__,
1061                         cx23885_boards[dev->board].portb,
1062                         cx23885_boards[dev->board].portc );
1063                 return -EINVAL;
1064         }
1065
1066         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1067                 cx23885_av_clk(dev, 0);
1068
1069         udelay(100);
1070
1071         /* If the port supports SRC SELECT, configure it */
1072         if(port->reg_src_sel)
1073                 cx_write(port->reg_src_sel, port->src_sel_val);
1074
1075         cx_write(port->reg_hw_sop_ctrl, port->hw_sop_ctrl_val);
1076         cx_write(port->reg_ts_clk_en, port->ts_clk_en_val);
1077         cx_write(port->reg_vld_misc, port->vld_misc_val);
1078         cx_write(port->reg_gen_ctrl, port->gen_ctrl_val);
1079         udelay(100);
1080
1081         // NOTE: this is 2 (reserved) for portb, does it matter?
1082         /* reset counter to zero */
1083         cx_write(port->reg_gpcnt_ctl, 3);
1084         q->count = 1;
1085
1086         if (cx23885_boards[dev->board].portb & CX23885_MPEG_ENCODER) {
1087
1088                 reg = cx_read(PAD_CTRL);
1089                 reg = reg & ~0x1;    /* Clear TS1_OE */
1090
1091                 /* FIXME, bit 2 writing here is questionable */
1092                 /* set TS1_SOP_OE and TS1_OE_HI */
1093                 reg = reg | 0xa;
1094                 cx_write(PAD_CTRL, reg);
1095
1096                 /* FIXME and these two registers should be documented. */
1097                 cx_write(CLK_DELAY, cx_read(CLK_DELAY) | 0x80000011);
1098                 cx_write(ALT_PIN_OUT_SEL, 0x10100045);
1099         }
1100
1101         switch(dev->bridge) {
1102         case CX23885_BRIDGE_885:
1103         case CX23885_BRIDGE_887:
1104                 /* enable irqs */
1105                 dprintk(1, "%s() enabling TS int's and DMA\n", __func__ );
1106                 cx_set(port->reg_ts_int_msk,  port->ts_int_msk_val);
1107                 cx_set(port->reg_dma_ctl, port->dma_ctl_val);
1108                 cx_set(PCI_INT_MSK, dev->pci_irqmask | port->pci_irqmask);
1109                 break;
1110         default:
1111                 BUG();
1112         }
1113
1114         cx_set(DEV_CNTRL2, (1<<5)); /* Enable RISC controller */
1115
1116         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1117                 cx23885_av_clk(dev, 1);
1118
1119         if (debug > 4)
1120                 cx23885_tsport_reg_dump(port);
1121
1122         return 0;
1123 }
1124
1125 static int cx23885_stop_dma(struct cx23885_tsport *port)
1126 {
1127         struct cx23885_dev *dev = port->dev;
1128         u32 reg;
1129
1130         dprintk(1, "%s()\n", __func__);
1131
1132         /* Stop interrupts and DMA */
1133         cx_clear(port->reg_ts_int_msk, port->ts_int_msk_val);
1134         cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1135
1136         if (cx23885_boards[dev->board].portb & CX23885_MPEG_ENCODER) {
1137
1138                 reg = cx_read(PAD_CTRL);
1139
1140                 /* Set TS1_OE */
1141                 reg = reg | 0x1;
1142
1143                 /* clear TS1_SOP_OE and TS1_OE_HI */
1144                 reg = reg & ~0xa;
1145                 cx_write(PAD_CTRL, reg);
1146                 cx_write(port->reg_src_sel, 0);
1147                 cx_write(port->reg_gen_ctrl, 8);
1148
1149         }
1150
1151         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1152                 cx23885_av_clk(dev, 0);
1153
1154         return 0;
1155 }
1156
1157 int cx23885_restart_queue(struct cx23885_tsport *port,
1158                                 struct cx23885_dmaqueue *q)
1159 {
1160         struct cx23885_dev *dev = port->dev;
1161         struct cx23885_buffer *buf;
1162
1163         dprintk(5, "%s()\n", __func__);
1164         if (list_empty(&q->active))
1165         {
1166                 struct cx23885_buffer *prev;
1167                 prev = NULL;
1168
1169                 dprintk(5, "%s() queue is empty\n", __func__);
1170
1171                 for (;;) {
1172                         if (list_empty(&q->queued))
1173                                 return 0;
1174                         buf = list_entry(q->queued.next, struct cx23885_buffer,
1175                                          vb.queue);
1176                         if (NULL == prev) {
1177                                 list_del(&buf->vb.queue);
1178                                 list_add_tail(&buf->vb.queue, &q->active);
1179                                 cx23885_start_dma(port, q, buf);
1180                                 buf->vb.state = VIDEOBUF_ACTIVE;
1181                                 buf->count    = q->count++;
1182                                 mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
1183                                 dprintk(5, "[%p/%d] restart_queue - first active\n",
1184                                         buf, buf->vb.i);
1185
1186                         } else if (prev->vb.width  == buf->vb.width  &&
1187                                    prev->vb.height == buf->vb.height &&
1188                                    prev->fmt       == buf->fmt) {
1189                                 list_del(&buf->vb.queue);
1190                                 list_add_tail(&buf->vb.queue, &q->active);
1191                                 buf->vb.state = VIDEOBUF_ACTIVE;
1192                                 buf->count    = q->count++;
1193                                 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
1194                                 prev->risc.jmp[2] = cpu_to_le32(0); /* 64 bit bits 63-32 */
1195                                 dprintk(5,"[%p/%d] restart_queue - move to active\n",
1196                                         buf, buf->vb.i);
1197                         } else {
1198                                 return 0;
1199                         }
1200                         prev = buf;
1201                 }
1202                 return 0;
1203         }
1204
1205         buf = list_entry(q->active.next, struct cx23885_buffer, vb.queue);
1206         dprintk(2, "restart_queue [%p/%d]: restart dma\n",
1207                 buf, buf->vb.i);
1208         cx23885_start_dma(port, q, buf);
1209         list_for_each_entry(buf, &q->active, vb.queue)
1210                 buf->count = q->count++;
1211         mod_timer(&q->timeout, jiffies + BUFFER_TIMEOUT);
1212         return 0;
1213 }
1214
1215 /* ------------------------------------------------------------------ */
1216
1217 int cx23885_buf_prepare(struct videobuf_queue *q, struct cx23885_tsport *port,
1218                         struct cx23885_buffer *buf, enum v4l2_field field)
1219 {
1220         struct cx23885_dev *dev = port->dev;
1221         int size = port->ts_packet_size * port->ts_packet_count;
1222         int rc;
1223
1224         dprintk(1, "%s: %p\n", __func__, buf);
1225         if (0 != buf->vb.baddr  &&  buf->vb.bsize < size)
1226                 return -EINVAL;
1227
1228         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1229                 buf->vb.width  = port->ts_packet_size;
1230                 buf->vb.height = port->ts_packet_count;
1231                 buf->vb.size   = size;
1232                 buf->vb.field  = field /*V4L2_FIELD_TOP*/;
1233
1234                 if (0 != (rc = videobuf_iolock(q, &buf->vb, NULL)))
1235                         goto fail;
1236                 cx23885_risc_databuffer(dev->pci, &buf->risc,
1237                                         videobuf_to_dma(&buf->vb)->sglist,
1238                                         buf->vb.width, buf->vb.height);
1239         }
1240         buf->vb.state = VIDEOBUF_PREPARED;
1241         return 0;
1242
1243  fail:
1244         cx23885_free_buffer(q, buf);
1245         return rc;
1246 }
1247
1248 void cx23885_buf_queue(struct cx23885_tsport *port, struct cx23885_buffer *buf)
1249 {
1250         struct cx23885_buffer    *prev;
1251         struct cx23885_dev *dev = port->dev;
1252         struct cx23885_dmaqueue  *cx88q = &port->mpegq;
1253
1254         /* add jump to stopper */
1255         buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
1256         buf->risc.jmp[1] = cpu_to_le32(cx88q->stopper.dma);
1257         buf->risc.jmp[2] = cpu_to_le32(0); /* bits 63-32 */
1258
1259         if (list_empty(&cx88q->active)) {
1260                 dprintk( 1, "queue is empty - first active\n" );
1261                 list_add_tail(&buf->vb.queue, &cx88q->active);
1262                 cx23885_start_dma(port, cx88q, buf);
1263                 buf->vb.state = VIDEOBUF_ACTIVE;
1264                 buf->count    = cx88q->count++;
1265                 mod_timer(&cx88q->timeout, jiffies + BUFFER_TIMEOUT);
1266                 dprintk(1, "[%p/%d] %s - first active\n",
1267                         buf, buf->vb.i, __func__);
1268         } else {
1269                 dprintk( 1, "queue is not empty - append to active\n" );
1270                 prev = list_entry(cx88q->active.prev, struct cx23885_buffer,
1271                                   vb.queue);
1272                 list_add_tail(&buf->vb.queue, &cx88q->active);
1273                 buf->vb.state = VIDEOBUF_ACTIVE;
1274                 buf->count    = cx88q->count++;
1275                 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
1276                 prev->risc.jmp[2] = cpu_to_le32(0); /* 64 bit bits 63-32 */
1277                 dprintk( 1, "[%p/%d] %s - append to active\n",
1278                          buf, buf->vb.i, __func__);
1279         }
1280 }
1281
1282 /* ----------------------------------------------------------- */
1283
1284 static void do_cancel_buffers(struct cx23885_tsport *port, char *reason,
1285                               int restart)
1286 {
1287         struct cx23885_dev *dev = port->dev;
1288         struct cx23885_dmaqueue *q = &port->mpegq;
1289         struct cx23885_buffer *buf;
1290         unsigned long flags;
1291
1292         spin_lock_irqsave(&port->slock, flags);
1293         while (!list_empty(&q->active)) {
1294                 buf = list_entry(q->active.next, struct cx23885_buffer,
1295                                  vb.queue);
1296                 list_del(&buf->vb.queue);
1297                 buf->vb.state = VIDEOBUF_ERROR;
1298                 wake_up(&buf->vb.done);
1299                 dprintk(1, "[%p/%d] %s - dma=0x%08lx\n",
1300                         buf, buf->vb.i, reason, (unsigned long)buf->risc.dma);
1301         }
1302         if (restart) {
1303                 dprintk(1, "restarting queue\n" );
1304                 cx23885_restart_queue(port, q);
1305         }
1306         spin_unlock_irqrestore(&port->slock, flags);
1307 }
1308
1309 void cx23885_cancel_buffers(struct cx23885_tsport *port)
1310 {
1311         struct cx23885_dev *dev = port->dev;
1312         struct cx23885_dmaqueue *q = &port->mpegq;
1313
1314         dprintk(1, "%s()\n", __FUNCTION__);
1315         del_timer_sync(&q->timeout);
1316         cx23885_stop_dma(port);
1317         do_cancel_buffers(port, "cancel", 0);
1318 }
1319
1320 static void cx23885_timeout(unsigned long data)
1321 {
1322         struct cx23885_tsport *port = (struct cx23885_tsport *)data;
1323         struct cx23885_dev *dev = port->dev;
1324
1325         dprintk(1, "%s()\n",__func__);
1326
1327         if (debug > 5)
1328                 cx23885_sram_channel_dump(dev, &dev->sram_channels[ port->sram_chno ]);
1329
1330         cx23885_stop_dma(port);
1331         do_cancel_buffers(port, "timeout", 1);
1332 }
1333
1334 int cx23885_irq_417(struct cx23885_dev *dev, u32 status)
1335 {
1336         /* FIXME: port1 assumption here. */
1337         struct cx23885_tsport *port = &dev->ts1;
1338         int count = 0;
1339         int handled = 0;
1340
1341         if (status == 0)
1342                 return handled;
1343
1344         count = cx_read(port->reg_gpcnt);
1345         dprintk(7, "status: 0x%08x  mask: 0x%08x count: 0x%x\n",
1346                 status, cx_read(port->reg_ts_int_msk), count);
1347
1348         if ((status & VID_B_MSK_BAD_PKT)         ||
1349                 (status & VID_B_MSK_OPC_ERR)     ||
1350                 (status & VID_B_MSK_VBI_OPC_ERR) ||
1351                 (status & VID_B_MSK_SYNC)        ||
1352                 (status & VID_B_MSK_VBI_SYNC)    ||
1353                 (status & VID_B_MSK_OF)          ||
1354                 (status & VID_B_MSK_VBI_OF)) {
1355                 printk(KERN_ERR "%s: V4L mpeg risc op code error, status "
1356                         "= 0x%x\n", dev->name, status);
1357                 if (status & VID_B_MSK_BAD_PKT)
1358                         dprintk(1, "        VID_B_MSK_BAD_PKT\n");
1359                 if (status & VID_B_MSK_OPC_ERR)
1360                         dprintk(1, "        VID_B_MSK_OPC_ERR\n");
1361                 if (status & VID_B_MSK_VBI_OPC_ERR)
1362                         dprintk(1, "        VID_B_MSK_VBI_OPC_ERR\n");
1363                 if (status & VID_B_MSK_SYNC)
1364                         dprintk(1, "        VID_B_MSK_SYNC\n");
1365                 if (status & VID_B_MSK_VBI_SYNC)
1366                         dprintk(1, "        VID_B_MSK_VBI_SYNC\n");
1367                 if (status & VID_B_MSK_OF)
1368                         dprintk(1, "        VID_B_MSK_OF\n");
1369                 if (status & VID_B_MSK_VBI_OF)
1370                         dprintk(1, "        VID_B_MSK_VBI_OF\n");
1371
1372                 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1373                 cx23885_sram_channel_dump(dev,
1374                         &dev->sram_channels[port->sram_chno]);
1375                 cx23885_417_check_encoder(dev);
1376         } else if (status & VID_B_MSK_RISCI1) {
1377                 dprintk(7, "        VID_B_MSK_RISCI1\n");
1378                 spin_lock(&port->slock);
1379                 cx23885_wakeup(port, &port->mpegq, count);
1380                 spin_unlock(&port->slock);
1381         } else if (status & VID_B_MSK_RISCI2) {
1382                 dprintk(7, "        VID_B_MSK_RISCI2\n");
1383                 spin_lock(&port->slock);
1384                 cx23885_restart_queue(port, &port->mpegq);
1385                 spin_unlock(&port->slock);
1386         }
1387         if (status) {
1388                 cx_write(port->reg_ts_int_stat, status);
1389                 handled = 1;
1390         }
1391
1392         return handled;
1393 }
1394
1395 static int cx23885_irq_ts(struct cx23885_tsport *port, u32 status)
1396 {
1397         struct cx23885_dev *dev = port->dev;
1398         int handled = 0;
1399         u32 count;
1400
1401         if ((status & VID_BC_MSK_OPC_ERR) ||
1402                 (status & VID_BC_MSK_BAD_PKT) ||
1403                 (status & VID_BC_MSK_SYNC) ||
1404                 (status & VID_BC_MSK_OF))
1405         {
1406                 if (status & VID_BC_MSK_OPC_ERR)
1407                         dprintk(7, " (VID_BC_MSK_OPC_ERR 0x%08x)\n", VID_BC_MSK_OPC_ERR);
1408                 if (status & VID_BC_MSK_BAD_PKT)
1409                         dprintk(7, " (VID_BC_MSK_BAD_PKT 0x%08x)\n", VID_BC_MSK_BAD_PKT);
1410                 if (status & VID_BC_MSK_SYNC)
1411                         dprintk(7, " (VID_BC_MSK_SYNC    0x%08x)\n", VID_BC_MSK_SYNC);
1412                 if (status & VID_BC_MSK_OF)
1413                         dprintk(7, " (VID_BC_MSK_OF      0x%08x)\n", VID_BC_MSK_OF);
1414
1415                 printk(KERN_ERR "%s: mpeg risc op code error\n", dev->name);
1416
1417                 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1418                 cx23885_sram_channel_dump(dev,
1419                         &dev->sram_channels[port->sram_chno]);
1420
1421         } else if (status & VID_BC_MSK_RISCI1) {
1422
1423                 dprintk(7, " (RISCI1            0x%08x)\n", VID_BC_MSK_RISCI1);
1424
1425                 spin_lock(&port->slock);
1426                 count = cx_read(port->reg_gpcnt);
1427                 cx23885_wakeup(port, &port->mpegq, count);
1428                 spin_unlock(&port->slock);
1429
1430         } else if (status & VID_BC_MSK_RISCI2) {
1431
1432                 dprintk(7, " (RISCI2            0x%08x)\n", VID_BC_MSK_RISCI2);
1433
1434                 spin_lock(&port->slock);
1435                 cx23885_restart_queue(port, &port->mpegq);
1436                 spin_unlock(&port->slock);
1437
1438         }
1439         if (status) {
1440                 cx_write(port->reg_ts_int_stat, status);
1441                 handled = 1;
1442         }
1443
1444         return handled;
1445 }
1446
1447 static irqreturn_t cx23885_irq(int irq, void *dev_id)
1448 {
1449         struct cx23885_dev *dev = dev_id;
1450         struct cx23885_tsport *ts1 = &dev->ts1;
1451         struct cx23885_tsport *ts2 = &dev->ts2;
1452         u32 pci_status, pci_mask;
1453         u32 vida_status, vida_mask;
1454         u32 ts1_status, ts1_mask;
1455         u32 ts2_status, ts2_mask;
1456         int vida_count = 0, ts1_count = 0, ts2_count = 0, handled = 0;
1457
1458         pci_status = cx_read(PCI_INT_STAT);
1459         pci_mask = cx_read(PCI_INT_MSK);
1460         vida_status = cx_read(VID_A_INT_STAT);
1461         vida_mask = cx_read(VID_A_INT_MSK);
1462         ts1_status = cx_read(VID_B_INT_STAT);
1463         ts1_mask = cx_read(VID_B_INT_MSK);
1464         ts2_status = cx_read(VID_C_INT_STAT);
1465         ts2_mask = cx_read(VID_C_INT_MSK);
1466
1467         if ( (pci_status == 0) && (ts2_status == 0) && (ts1_status == 0) )
1468                 goto out;
1469
1470         vida_count = cx_read(VID_A_GPCNT);
1471         ts1_count = cx_read(ts1->reg_gpcnt);
1472         ts2_count = cx_read(ts2->reg_gpcnt);
1473         dprintk(7, "pci_status: 0x%08x  pci_mask: 0x%08x\n",
1474                 pci_status, pci_mask);
1475         dprintk(7, "vida_status: 0x%08x vida_mask: 0x%08x count: 0x%x\n",
1476                 vida_status, vida_mask, vida_count);
1477         dprintk(7, "ts1_status: 0x%08x  ts1_mask: 0x%08x count: 0x%x\n",
1478                 ts1_status, ts1_mask, ts1_count);
1479         dprintk(7, "ts2_status: 0x%08x  ts2_mask: 0x%08x count: 0x%x\n",
1480                 ts2_status, ts2_mask, ts2_count);
1481
1482         if ( (pci_status & PCI_MSK_RISC_RD) ||
1483              (pci_status & PCI_MSK_RISC_WR) ||
1484              (pci_status & PCI_MSK_AL_RD) ||
1485              (pci_status & PCI_MSK_AL_WR) ||
1486              (pci_status & PCI_MSK_APB_DMA) ||
1487              (pci_status & PCI_MSK_VID_C) ||
1488              (pci_status & PCI_MSK_VID_B) ||
1489              (pci_status & PCI_MSK_VID_A) ||
1490              (pci_status & PCI_MSK_AUD_INT) ||
1491              (pci_status & PCI_MSK_AUD_EXT) )
1492         {
1493
1494                 if (pci_status & PCI_MSK_RISC_RD)
1495                         dprintk(7, " (PCI_MSK_RISC_RD   0x%08x)\n", PCI_MSK_RISC_RD);
1496                 if (pci_status & PCI_MSK_RISC_WR)
1497                         dprintk(7, " (PCI_MSK_RISC_WR   0x%08x)\n", PCI_MSK_RISC_WR);
1498                 if (pci_status & PCI_MSK_AL_RD)
1499                         dprintk(7, " (PCI_MSK_AL_RD     0x%08x)\n", PCI_MSK_AL_RD);
1500                 if (pci_status & PCI_MSK_AL_WR)
1501                         dprintk(7, " (PCI_MSK_AL_WR     0x%08x)\n", PCI_MSK_AL_WR);
1502                 if (pci_status & PCI_MSK_APB_DMA)
1503                         dprintk(7, " (PCI_MSK_APB_DMA   0x%08x)\n", PCI_MSK_APB_DMA);
1504                 if (pci_status & PCI_MSK_VID_C)
1505                         dprintk(7, " (PCI_MSK_VID_C     0x%08x)\n", PCI_MSK_VID_C);
1506                 if (pci_status & PCI_MSK_VID_B)
1507                         dprintk(7, " (PCI_MSK_VID_B     0x%08x)\n", PCI_MSK_VID_B);
1508                 if (pci_status & PCI_MSK_VID_A)
1509                         dprintk(7, " (PCI_MSK_VID_A     0x%08x)\n", PCI_MSK_VID_A);
1510                 if (pci_status & PCI_MSK_AUD_INT)
1511                         dprintk(7, " (PCI_MSK_AUD_INT   0x%08x)\n", PCI_MSK_AUD_INT);
1512                 if (pci_status & PCI_MSK_AUD_EXT)
1513                         dprintk(7, " (PCI_MSK_AUD_EXT   0x%08x)\n", PCI_MSK_AUD_EXT);
1514
1515         }
1516
1517         if (ts1_status) {
1518                 if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB)
1519                         handled += cx23885_irq_ts(ts1, ts1_status);
1520                 else
1521                 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1522                         handled += cx23885_irq_417(dev, ts1_status);
1523         }
1524
1525         if (ts2_status) {
1526                 if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB)
1527                         handled += cx23885_irq_ts(ts2, ts2_status);
1528                 else
1529                 if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER)
1530                         handled += cx23885_irq_417(dev, ts2_status);
1531         }
1532
1533         if (vida_status)
1534                 handled += cx23885_video_irq(dev, vida_status);
1535
1536         if (handled)
1537                 cx_write(PCI_INT_STAT, pci_status);
1538 out:
1539         return IRQ_RETVAL(handled);
1540 }
1541
1542 static int __devinit cx23885_initdev(struct pci_dev *pci_dev,
1543                                      const struct pci_device_id *pci_id)
1544 {
1545         struct cx23885_dev *dev;
1546         int err;
1547
1548         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1549         if (NULL == dev)
1550                 return -ENOMEM;
1551
1552         /* pci init */
1553         dev->pci = pci_dev;
1554         if (pci_enable_device(pci_dev)) {
1555                 err = -EIO;
1556                 goto fail_free;
1557         }
1558
1559         if (cx23885_dev_setup(dev) < 0) {
1560                 err = -EINVAL;
1561                 goto fail_free;
1562         }
1563
1564         /* print pci info */
1565         pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
1566         pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER,  &dev->pci_lat);
1567         printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, "
1568                "latency: %d, mmio: 0x%llx\n", dev->name,
1569                pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
1570                dev->pci_lat,
1571                 (unsigned long long)pci_resource_start(pci_dev, 0));
1572
1573         pci_set_master(pci_dev);
1574         if (!pci_dma_supported(pci_dev, 0xffffffff)) {
1575                 printk("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name);
1576                 err = -EIO;
1577                 goto fail_irq;
1578         }
1579
1580         err = request_irq(pci_dev->irq, cx23885_irq,
1581                           IRQF_SHARED | IRQF_DISABLED, dev->name, dev);
1582         if (err < 0) {
1583                 printk(KERN_ERR "%s: can't get IRQ %d\n",
1584                        dev->name, pci_dev->irq);
1585                 goto fail_irq;
1586         }
1587
1588         pci_set_drvdata(pci_dev, dev);
1589         return 0;
1590
1591 fail_irq:
1592         cx23885_dev_unregister(dev);
1593 fail_free:
1594         kfree(dev);
1595         return err;
1596 }
1597
1598 static void __devexit cx23885_finidev(struct pci_dev *pci_dev)
1599 {
1600         struct cx23885_dev *dev = pci_get_drvdata(pci_dev);
1601
1602         cx23885_shutdown(dev);
1603
1604         pci_disable_device(pci_dev);
1605
1606         /* unregister stuff */
1607         free_irq(pci_dev->irq, dev);
1608         pci_set_drvdata(pci_dev, NULL);
1609
1610         mutex_lock(&devlist);
1611         list_del(&dev->devlist);
1612         mutex_unlock(&devlist);
1613
1614         cx23885_dev_unregister(dev);
1615         kfree(dev);
1616 }
1617
1618 static struct pci_device_id cx23885_pci_tbl[] = {
1619         {
1620                 /* CX23885 */
1621                 .vendor       = 0x14f1,
1622                 .device       = 0x8852,
1623                 .subvendor    = PCI_ANY_ID,
1624                 .subdevice    = PCI_ANY_ID,
1625         },{
1626                 /* CX23887 Rev 2 */
1627                 .vendor       = 0x14f1,
1628                 .device       = 0x8880,
1629                 .subvendor    = PCI_ANY_ID,
1630                 .subdevice    = PCI_ANY_ID,
1631         },{
1632                 /* --- end of list --- */
1633         }
1634 };
1635 MODULE_DEVICE_TABLE(pci, cx23885_pci_tbl);
1636
1637 static struct pci_driver cx23885_pci_driver = {
1638         .name     = "cx23885",
1639         .id_table = cx23885_pci_tbl,
1640         .probe    = cx23885_initdev,
1641         .remove   = __devexit_p(cx23885_finidev),
1642         /* TODO */
1643         .suspend  = NULL,
1644         .resume   = NULL,
1645 };
1646
1647 static int cx23885_init(void)
1648 {
1649         printk(KERN_INFO "cx23885 driver version %d.%d.%d loaded\n",
1650                (CX23885_VERSION_CODE >> 16) & 0xff,
1651                (CX23885_VERSION_CODE >>  8) & 0xff,
1652                CX23885_VERSION_CODE & 0xff);
1653 #ifdef SNAPSHOT
1654         printk(KERN_INFO "cx23885: snapshot date %04d-%02d-%02d\n",
1655                SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
1656 #endif
1657         return pci_register_driver(&cx23885_pci_driver);
1658 }
1659
1660 static void cx23885_fini(void)
1661 {
1662         pci_unregister_driver(&cx23885_pci_driver);
1663 }
1664
1665 module_init(cx23885_init);
1666 module_exit(cx23885_fini);
1667
1668 /* ----------------------------------------------------------- */
1669 /*
1670  * Local variables:
1671  * c-basic-offset: 8
1672  * End:
1673  * 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
1674  */