drivers/media/pci/cx23885/cx23885-core.c

   1 /*
   2  *  Driver for the Conexant CX23885 PCIe bridge
   3  *
   4  *  Copyright (c) 2006 Steven Toth <stoth@linuxtv.org>
   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
  18 #include <linux/init.h>
  19 #include <linux/list.h>
  20 #include <linux/module.h>
  21 #include <linux/moduleparam.h>
  22 #include <linux/kmod.h>
  23 #include <linux/kernel.h>
  24 #include <linux/slab.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/delay.h>
  27 #include <asm/div64.h>
  28 #include <linux/firmware.h>
  29
  30 #include "cx23885.h"
  31 #include "cimax2.h"
  32 #include "altera-ci.h"
  33 #include "cx23888-ir.h"
  34 #include "cx23885-ir.h"
  35 #include "cx23885-av.h"
  36 #include "cx23885-input.h"
  37
  38 MODULE_DESCRIPTION("Driver for cx23885 based TV cards");
  39 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
  40 MODULE_LICENSE("GPL");
  41 MODULE_VERSION(CX23885_VERSION);
  42
  43 static unsigned int debug;
  44 module_param(debug, int, 0644);
  45 MODULE_PARM_DESC(debug, "enable debug messages");
  46
  47 static unsigned int card[]  = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
  48 module_param_array(card,  int, NULL, 0444);
  49 MODULE_PARM_DESC(card, "card type");
  50
  51 #define dprintk(level, fmt, arg...)\
  52         do { if (debug >= level)\
  53                 printk(KERN_DEBUG "%s: " fmt, dev->name, ## arg);\
  54         } while (0)
  55
  56 static unsigned int cx23885_devcount;
  57
  58 #define NO_SYNC_LINE (-1U)
  59
  60 /* FIXME, these allocations will change when
  61  * analog arrives. The be reviewed.
  62  * CX23887 Assumptions
  63  * 1 line = 16 bytes of CDT
  64  * cmds size = 80
  65  * cdt size = 16 * linesize
  66  * iqsize = 64
  67  * maxlines = 6
  68  *
  69  * Address Space:
  70  * 0x00000000 0x00008fff FIFO clusters
  71  * 0x00010000 0x000104af Channel Management Data Structures
  72  * 0x000104b0 0x000104ff Free
  73  * 0x00010500 0x000108bf 15 channels * iqsize
  74  * 0x000108c0 0x000108ff Free
  75  * 0x00010900 0x00010e9f IQ's + Cluster Descriptor Tables
  76  *                       15 channels * (iqsize + (maxlines * linesize))
  77  * 0x00010ea0 0x00010xxx Free
  78  */
  79
  80 static struct sram_channel cx23885_sram_channels[] = {
  81         [SRAM_CH01] = {
  82                 .name           = "VID A",
  83                 .cmds_start     = 0x10000,
  84                 .ctrl_start     = 0x10380,
  85                 .cdt            = 0x104c0,
  86                 .fifo_start     = 0x40,
  87                 .fifo_size      = 0x2800,
  88                 .ptr1_reg       = DMA1_PTR1,
  89                 .ptr2_reg       = DMA1_PTR2,
  90                 .cnt1_reg       = DMA1_CNT1,
  91                 .cnt2_reg       = DMA1_CNT2,
  92         },
  93         [SRAM_CH02] = {
  94                 .name           = "ch2",
  95                 .cmds_start     = 0x0,
  96                 .ctrl_start     = 0x0,
  97                 .cdt            = 0x0,
  98                 .fifo_start     = 0x0,
  99                 .fifo_size      = 0x0,
 100                 .ptr1_reg       = DMA2_PTR1,
 101                 .ptr2_reg       = DMA2_PTR2,
 102                 .cnt1_reg       = DMA2_CNT1,
 103                 .cnt2_reg       = DMA2_CNT2,
 104         },
 105         [SRAM_CH03] = {
 106                 .name           = "TS1 B",
 107                 .cmds_start     = 0x100A0,
 108                 .ctrl_start     = 0x10400,
 109                 .cdt            = 0x10580,
 110                 .fifo_start     = 0x5000,
 111                 .fifo_size      = 0x1000,
 112                 .ptr1_reg       = DMA3_PTR1,
 113                 .ptr2_reg       = DMA3_PTR2,
 114                 .cnt1_reg       = DMA3_CNT1,
 115                 .cnt2_reg       = DMA3_CNT2,
 116         },
 117         [SRAM_CH04] = {
 118                 .name           = "ch4",
 119                 .cmds_start     = 0x0,
 120                 .ctrl_start     = 0x0,
 121                 .cdt            = 0x0,
 122                 .fifo_start     = 0x0,
 123                 .fifo_size      = 0x0,
 124                 .ptr1_reg       = DMA4_PTR1,
 125                 .ptr2_reg       = DMA4_PTR2,
 126                 .cnt1_reg       = DMA4_CNT1,
 127                 .cnt2_reg       = DMA4_CNT2,
 128         },
 129         [SRAM_CH05] = {
 130                 .name           = "ch5",
 131                 .cmds_start     = 0x0,
 132                 .ctrl_start     = 0x0,
 133                 .cdt            = 0x0,
 134                 .fifo_start     = 0x0,
 135                 .fifo_size      = 0x0,
 136                 .ptr1_reg       = DMA5_PTR1,
 137                 .ptr2_reg       = DMA5_PTR2,
 138                 .cnt1_reg       = DMA5_CNT1,
 139                 .cnt2_reg       = DMA5_CNT2,
 140         },
 141         [SRAM_CH06] = {
 142                 .name           = "TS2 C",
 143                 .cmds_start     = 0x10140,
 144                 .ctrl_start     = 0x10440,
 145                 .cdt            = 0x105e0,
 146                 .fifo_start     = 0x6000,
 147                 .fifo_size      = 0x1000,
 148                 .ptr1_reg       = DMA5_PTR1,
 149                 .ptr2_reg       = DMA5_PTR2,
 150                 .cnt1_reg       = DMA5_CNT1,
 151                 .cnt2_reg       = DMA5_CNT2,
 152         },
 153         [SRAM_CH07] = {
 154                 .name           = "TV Audio",
 155                 .cmds_start     = 0x10190,
 156                 .ctrl_start     = 0x10480,
 157                 .cdt            = 0x10a00,
 158                 .fifo_start     = 0x7000,
 159                 .fifo_size      = 0x1000,
 160                 .ptr1_reg       = DMA6_PTR1,
 161                 .ptr2_reg       = DMA6_PTR2,
 162                 .cnt1_reg       = DMA6_CNT1,
 163                 .cnt2_reg       = DMA6_CNT2,
 164         },
 165         [SRAM_CH08] = {
 166                 .name           = "ch8",
 167                 .cmds_start     = 0x0,
 168                 .ctrl_start     = 0x0,
 169                 .cdt            = 0x0,
 170                 .fifo_start     = 0x0,
 171                 .fifo_size      = 0x0,
 172                 .ptr1_reg       = DMA7_PTR1,
 173                 .ptr2_reg       = DMA7_PTR2,
 174                 .cnt1_reg       = DMA7_CNT1,
 175                 .cnt2_reg       = DMA7_CNT2,
 176         },
 177         [SRAM_CH09] = {
 178                 .name           = "ch9",
 179                 .cmds_start     = 0x0,
 180                 .ctrl_start     = 0x0,
 181                 .cdt            = 0x0,
 182                 .fifo_start     = 0x0,
 183                 .fifo_size      = 0x0,
 184                 .ptr1_reg       = DMA8_PTR1,
 185                 .ptr2_reg       = DMA8_PTR2,
 186                 .cnt1_reg       = DMA8_CNT1,
 187                 .cnt2_reg       = DMA8_CNT2,
 188         },
 189 };
 190
 191 static struct sram_channel cx23887_sram_channels[] = {
 192         [SRAM_CH01] = {
 193                 .name           = "VID A",
 194                 .cmds_start     = 0x10000,
 195                 .ctrl_start     = 0x105b0,
 196                 .cdt            = 0x107b0,
 197                 .fifo_start     = 0x40,
 198                 .fifo_size      = 0x2800,
 199                 .ptr1_reg       = DMA1_PTR1,
 200                 .ptr2_reg       = DMA1_PTR2,
 201                 .cnt1_reg       = DMA1_CNT1,
 202                 .cnt2_reg       = DMA1_CNT2,
 203         },
 204         [SRAM_CH02] = {
 205                 .name           = "VID A (VBI)",
 206                 .cmds_start     = 0x10050,
 207                 .ctrl_start     = 0x105F0,
 208                 .cdt            = 0x10810,
 209                 .fifo_start     = 0x3000,
 210                 .fifo_size      = 0x1000,
 211                 .ptr1_reg       = DMA2_PTR1,
 212                 .ptr2_reg       = DMA2_PTR2,
 213                 .cnt1_reg       = DMA2_CNT1,
 214                 .cnt2_reg       = DMA2_CNT2,
 215         },
 216         [SRAM_CH03] = {
 217                 .name           = "TS1 B",
 218                 .cmds_start     = 0x100A0,
 219                 .ctrl_start     = 0x10630,
 220                 .cdt            = 0x10870,
 221                 .fifo_start     = 0x5000,
 222                 .fifo_size      = 0x1000,
 223                 .ptr1_reg       = DMA3_PTR1,
 224                 .ptr2_reg       = DMA3_PTR2,
 225                 .cnt1_reg       = DMA3_CNT1,
 226                 .cnt2_reg       = DMA3_CNT2,
 227         },
 228         [SRAM_CH04] = {
 229                 .name           = "ch4",
 230                 .cmds_start     = 0x0,
 231                 .ctrl_start     = 0x0,
 232                 .cdt            = 0x0,
 233                 .fifo_start     = 0x0,
 234                 .fifo_size      = 0x0,
 235                 .ptr1_reg       = DMA4_PTR1,
 236                 .ptr2_reg       = DMA4_PTR2,
 237                 .cnt1_reg       = DMA4_CNT1,
 238                 .cnt2_reg       = DMA4_CNT2,
 239         },
 240         [SRAM_CH05] = {
 241                 .name           = "ch5",
 242                 .cmds_start     = 0x0,
 243                 .ctrl_start     = 0x0,
 244                 .cdt            = 0x0,
 245                 .fifo_start     = 0x0,
 246                 .fifo_size      = 0x0,
 247                 .ptr1_reg       = DMA5_PTR1,
 248                 .ptr2_reg       = DMA5_PTR2,
 249                 .cnt1_reg       = DMA5_CNT1,
 250                 .cnt2_reg       = DMA5_CNT2,
 251         },
 252         [SRAM_CH06] = {
 253                 .name           = "TS2 C",
 254                 .cmds_start     = 0x10140,
 255                 .ctrl_start     = 0x10670,
 256                 .cdt            = 0x108d0,
 257                 .fifo_start     = 0x6000,
 258                 .fifo_size      = 0x1000,
 259                 .ptr1_reg       = DMA5_PTR1,
 260                 .ptr2_reg       = DMA5_PTR2,
 261                 .cnt1_reg       = DMA5_CNT1,
 262                 .cnt2_reg       = DMA5_CNT2,
 263         },
 264         [SRAM_CH07] = {
 265                 .name           = "TV Audio",
 266                 .cmds_start     = 0x10190,
 267                 .ctrl_start     = 0x106B0,
 268                 .cdt            = 0x10930,
 269                 .fifo_start     = 0x7000,
 270                 .fifo_size      = 0x1000,
 271                 .ptr1_reg       = DMA6_PTR1,
 272                 .ptr2_reg       = DMA6_PTR2,
 273                 .cnt1_reg       = DMA6_CNT1,
 274                 .cnt2_reg       = DMA6_CNT2,
 275         },
 276         [SRAM_CH08] = {
 277                 .name           = "ch8",
 278                 .cmds_start     = 0x0,
 279                 .ctrl_start     = 0x0,
 280                 .cdt            = 0x0,
 281                 .fifo_start     = 0x0,
 282                 .fifo_size      = 0x0,
 283                 .ptr1_reg       = DMA7_PTR1,
 284                 .ptr2_reg       = DMA7_PTR2,
 285                 .cnt1_reg       = DMA7_CNT1,
 286                 .cnt2_reg       = DMA7_CNT2,
 287         },
 288         [SRAM_CH09] = {
 289                 .name           = "ch9",
 290                 .cmds_start     = 0x0,
 291                 .ctrl_start     = 0x0,
 292                 .cdt            = 0x0,
 293                 .fifo_start     = 0x0,
 294                 .fifo_size      = 0x0,
 295                 .ptr1_reg       = DMA8_PTR1,
 296                 .ptr2_reg       = DMA8_PTR2,
 297                 .cnt1_reg       = DMA8_CNT1,
 298                 .cnt2_reg       = DMA8_CNT2,
 299         },
 300 };
 301
 302 static void cx23885_irq_add(struct cx23885_dev *dev, u32 mask)
 303 {
 304         unsigned long flags;
 305         spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
 306
 307         dev->pci_irqmask |= mask;
 308
 309         spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
 310 }
 311
 312 void cx23885_irq_add_enable(struct cx23885_dev *dev, u32 mask)
 313 {
 314         unsigned long flags;
 315         spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
 316
 317         dev->pci_irqmask |= mask;
 318         cx_set(PCI_INT_MSK, mask);
 319
 320         spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
 321 }
 322
 323 void cx23885_irq_enable(struct cx23885_dev *dev, u32 mask)
 324 {
 325         u32 v;
 326         unsigned long flags;
 327         spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
 328
 329         v = mask & dev->pci_irqmask;
 330         if (v)
 331                 cx_set(PCI_INT_MSK, v);
 332
 333         spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
 334 }
 335
 336 static inline void cx23885_irq_enable_all(struct cx23885_dev *dev)
 337 {
 338         cx23885_irq_enable(dev, 0xffffffff);
 339 }
 340
 341 void cx23885_irq_disable(struct cx23885_dev *dev, u32 mask)
 342 {
 343         unsigned long flags;
 344         spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
 345
 346         cx_clear(PCI_INT_MSK, mask);
 347
 348         spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
 349 }
 350
 351 static inline void cx23885_irq_disable_all(struct cx23885_dev *dev)
 352 {
 353         cx23885_irq_disable(dev, 0xffffffff);
 354 }
 355
 356 void cx23885_irq_remove(struct cx23885_dev *dev, u32 mask)
 357 {
 358         unsigned long flags;
 359         spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
 360
 361         dev->pci_irqmask &= ~mask;
 362         cx_clear(PCI_INT_MSK, mask);
 363
 364         spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
 365 }
 366
 367 static u32 cx23885_irq_get_mask(struct cx23885_dev *dev)
 368 {
 369         u32 v;
 370         unsigned long flags;
 371         spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
 372
 373         v = cx_read(PCI_INT_MSK);
 374
 375         spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
 376         return v;
 377 }
 378
 379 static int cx23885_risc_decode(u32 risc)
 380 {
 381         static char *instr[16] = {
 382                 [RISC_SYNC    >> 28] = "sync",
 383                 [RISC_WRITE   >> 28] = "write",
 384                 [RISC_WRITEC  >> 28] = "writec",
 385                 [RISC_READ    >> 28] = "read",
 386                 [RISC_READC   >> 28] = "readc",
 387                 [RISC_JUMP    >> 28] = "jump",
 388                 [RISC_SKIP    >> 28] = "skip",
 389                 [RISC_WRITERM >> 28] = "writerm",
 390                 [RISC_WRITECM >> 28] = "writecm",
 391                 [RISC_WRITECR >> 28] = "writecr",
 392         };
 393         static int incr[16] = {
 394                 [RISC_WRITE   >> 28] = 3,
 395                 [RISC_JUMP    >> 28] = 3,
 396                 [RISC_SKIP    >> 28] = 1,
 397                 [RISC_SYNC    >> 28] = 1,
 398                 [RISC_WRITERM >> 28] = 3,
 399                 [RISC_WRITECM >> 28] = 3,
 400                 [RISC_WRITECR >> 28] = 4,
 401         };
 402         static char *bits[] = {
 403                 "12",   "13",   "14",   "resync",
 404                 "cnt0", "cnt1", "18",   "19",
 405                 "20",   "21",   "22",   "23",
 406                 "irq1", "irq2", "eol",  "sol",
 407         };
 408         int i;
 409
 410         printk("0x%08x [ %s", risc,
 411                instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
 412         for (i = ARRAY_SIZE(bits) - 1; i >= 0; i--)
 413                 if (risc & (1 << (i + 12)))
 414                         printk(" %s", bits[i]);
 415         printk(" count=%d ]\n", risc & 0xfff);
 416         return incr[risc >> 28] ? incr[risc >> 28] : 1;
 417 }
 418
 419 static void cx23885_wakeup(struct cx23885_tsport *port,
 420                            struct cx23885_dmaqueue *q, u32 count)
 421 {
 422         struct cx23885_dev *dev = port->dev;
 423         struct cx23885_buffer *buf;
 424
 425         if (list_empty(&q->active))
 426                 return;
 427         buf = list_entry(q->active.next,
 428                          struct cx23885_buffer, queue);
 429
 430         buf->vb.vb2_buf.timestamp = ktime_get_ns();
 431         buf->vb.sequence = q->count++;
 432         dprintk(1, "[%p/%d] wakeup reg=%d buf=%d\n", buf,
 433                 buf->vb.vb2_buf.index,
 434                 count, q->count);
 435         list_del(&buf->queue);
 436         vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
 437 }
 438
 439 int cx23885_sram_channel_setup(struct cx23885_dev *dev,
 440                                       struct sram_channel *ch,
 441                                       unsigned int bpl, u32 risc)
 442 {
 443         unsigned int i, lines;
 444         u32 cdt;
 445
 446         if (ch->cmds_start == 0) {
 447                 dprintk(1, "%s() Erasing channel [%s]\n", __func__,
 448                         ch->name);
 449                 cx_write(ch->ptr1_reg, 0);
 450                 cx_write(ch->ptr2_reg, 0);
 451                 cx_write(ch->cnt2_reg, 0);
 452                 cx_write(ch->cnt1_reg, 0);
 453                 return 0;
 454         } else {
 455                 dprintk(1, "%s() Configuring channel [%s]\n", __func__,
 456                         ch->name);
 457         }
 458
 459         bpl   = (bpl + 7) & ~7; /* alignment */
 460         cdt   = ch->cdt;
 461         lines = ch->fifo_size / bpl;
 462         if (lines > 6)
 463                 lines = 6;
 464         BUG_ON(lines < 2);
 465
 466         cx_write(8 + 0, RISC_JUMP | RISC_CNT_RESET);
 467         cx_write(8 + 4, 12);
 468         cx_write(8 + 8, 0);
 469
 470         /* write CDT */
 471         for (i = 0; i < lines; i++) {
 472                 dprintk(2, "%s() 0x%08x <- 0x%08x\n", __func__, cdt + 16*i,
 473                         ch->fifo_start + bpl*i);
 474                 cx_write(cdt + 16*i, ch->fifo_start + bpl*i);
 475                 cx_write(cdt + 16*i +  4, 0);
 476                 cx_write(cdt + 16*i +  8, 0);
 477                 cx_write(cdt + 16*i + 12, 0);
 478         }
 479
 480         /* write CMDS */
 481         if (ch->jumponly)
 482                 cx_write(ch->cmds_start + 0, 8);
 483         else
 484                 cx_write(ch->cmds_start + 0, risc);
 485         cx_write(ch->cmds_start +  4, 0); /* 64 bits 63-32 */
 486         cx_write(ch->cmds_start +  8, cdt);
 487         cx_write(ch->cmds_start + 12, (lines*16) >> 3);
 488         cx_write(ch->cmds_start + 16, ch->ctrl_start);
 489         if (ch->jumponly)
 490                 cx_write(ch->cmds_start + 20, 0x80000000 | (64 >> 2));
 491         else
 492                 cx_write(ch->cmds_start + 20, 64 >> 2);
 493         for (i = 24; i < 80; i += 4)
 494                 cx_write(ch->cmds_start + i, 0);
 495
 496         /* fill registers */
 497         cx_write(ch->ptr1_reg, ch->fifo_start);
 498         cx_write(ch->ptr2_reg, cdt);
 499         cx_write(ch->cnt2_reg, (lines*16) >> 3);
 500         cx_write(ch->cnt1_reg, (bpl >> 3) - 1);
 501
 502         dprintk(2, "[bridge %d] sram setup %s: bpl=%d lines=%d\n",
 503                 dev->bridge,
 504                 ch->name,
 505                 bpl,
 506                 lines);
 507
 508         return 0;
 509 }
 510
 511 void cx23885_sram_channel_dump(struct cx23885_dev *dev,
 512                                       struct sram_channel *ch)
 513 {
 514         static char *name[] = {
 515                 "init risc lo",
 516                 "init risc hi",
 517                 "cdt base",
 518                 "cdt size",
 519                 "iq base",
 520                 "iq size",
 521                 "risc pc lo",
 522                 "risc pc hi",
 523                 "iq wr ptr",
 524                 "iq rd ptr",
 525                 "cdt current",
 526                 "pci target lo",
 527                 "pci target hi",
 528                 "line / byte",
 529         };
 530         u32 risc;
 531         unsigned int i, j, n;
 532
 533         printk(KERN_WARNING "%s: %s - dma channel status dump\n",
 534                dev->name, ch->name);
 535         for (i = 0; i < ARRAY_SIZE(name); i++)
 536                 printk(KERN_WARNING "%s:   cmds: %-15s: 0x%08x\n",
 537                        dev->name, name[i],
 538                        cx_read(ch->cmds_start + 4*i));
 539
 540         for (i = 0; i < 4; i++) {
 541                 risc = cx_read(ch->cmds_start + 4 * (i + 14));
 542                 printk(KERN_WARNING "%s:   risc%d: ", dev->name, i);
 543                 cx23885_risc_decode(risc);
 544         }
 545         for (i = 0; i < (64 >> 2); i += n) {
 546                 risc = cx_read(ch->ctrl_start + 4 * i);
 547                 /* No consideration for bits 63-32 */
 548
 549                 printk(KERN_WARNING "%s:   (0x%08x) iq %x: ", dev->name,
 550                        ch->ctrl_start + 4 * i, i);
 551                 n = cx23885_risc_decode(risc);
 552                 for (j = 1; j < n; j++) {
 553                         risc = cx_read(ch->ctrl_start + 4 * (i + j));
 554                         printk(KERN_WARNING "%s:   iq %x: 0x%08x [ arg #%d ]\n",
 555                                dev->name, i+j, risc, j);
 556                 }
 557         }
 558
 559         printk(KERN_WARNING "%s: fifo: 0x%08x -> 0x%x\n",
 560                dev->name, ch->fifo_start, ch->fifo_start+ch->fifo_size);
 561         printk(KERN_WARNING "%s: ctrl: 0x%08x -> 0x%x\n",
 562                dev->name, ch->ctrl_start, ch->ctrl_start + 6*16);
 563         printk(KERN_WARNING "%s:   ptr1_reg: 0x%08x\n",
 564                dev->name, cx_read(ch->ptr1_reg));
 565         printk(KERN_WARNING "%s:   ptr2_reg: 0x%08x\n",
 566                dev->name, cx_read(ch->ptr2_reg));
 567         printk(KERN_WARNING "%s:   cnt1_reg: 0x%08x\n",
 568                dev->name, cx_read(ch->cnt1_reg));
 569         printk(KERN_WARNING "%s:   cnt2_reg: 0x%08x\n",
 570                dev->name, cx_read(ch->cnt2_reg));
 571 }
 572
 573 static void cx23885_risc_disasm(struct cx23885_tsport *port,
 574                                 struct cx23885_riscmem *risc)
 575 {
 576         struct cx23885_dev *dev = port->dev;
 577         unsigned int i, j, n;
 578
 579         printk(KERN_INFO "%s: risc disasm: %p [dma=0x%08lx]\n",
 580                dev->name, risc->cpu, (unsigned long)risc->dma);
 581         for (i = 0; i < (risc->size >> 2); i += n) {
 582                 printk(KERN_INFO "%s:   %04d: ", dev->name, i);
 583                 n = cx23885_risc_decode(le32_to_cpu(risc->cpu[i]));
 584                 for (j = 1; j < n; j++)
 585                         printk(KERN_INFO "%s:   %04d: 0x%08x [ arg #%d ]\n",
 586                                dev->name, i + j, risc->cpu[i + j], j);
 587                 if (risc->cpu[i] == cpu_to_le32(RISC_JUMP))
 588                         break;
 589         }
 590 }
 591
 592 static void cx23885_shutdown(struct cx23885_dev *dev)
 593 {
 594         /* disable RISC controller */
 595         cx_write(DEV_CNTRL2, 0);
 596
 597         /* Disable all IR activity */
 598         cx_write(IR_CNTRL_REG, 0);
 599
 600         /* Disable Video A/B activity */
 601         cx_write(VID_A_DMA_CTL, 0);
 602         cx_write(VID_B_DMA_CTL, 0);
 603         cx_write(VID_C_DMA_CTL, 0);
 604
 605         /* Disable Audio activity */
 606         cx_write(AUD_INT_DMA_CTL, 0);
 607         cx_write(AUD_EXT_DMA_CTL, 0);
 608
 609         /* Disable Serial port */
 610         cx_write(UART_CTL, 0);
 611
 612         /* Disable Interrupts */
 613         cx23885_irq_disable_all(dev);
 614         cx_write(VID_A_INT_MSK, 0);
 615         cx_write(VID_B_INT_MSK, 0);
 616         cx_write(VID_C_INT_MSK, 0);
 617         cx_write(AUDIO_INT_INT_MSK, 0);
 618         cx_write(AUDIO_EXT_INT_MSK, 0);
 619
 620 }
 621
 622 static void cx23885_reset(struct cx23885_dev *dev)
 623 {
 624         dprintk(1, "%s()\n", __func__);
 625
 626         cx23885_shutdown(dev);
 627
 628         cx_write(PCI_INT_STAT, 0xffffffff);
 629         cx_write(VID_A_INT_STAT, 0xffffffff);
 630         cx_write(VID_B_INT_STAT, 0xffffffff);
 631         cx_write(VID_C_INT_STAT, 0xffffffff);
 632         cx_write(AUDIO_INT_INT_STAT, 0xffffffff);
 633         cx_write(AUDIO_EXT_INT_STAT, 0xffffffff);
 634         cx_write(CLK_DELAY, cx_read(CLK_DELAY) & 0x80000000);
 635         cx_write(PAD_CTRL, 0x00500300);
 636
 637         mdelay(100);
 638
 639         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH01],
 640                 720*4, 0);
 641         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH02], 128, 0);
 642         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH03],
 643                 188*4, 0);
 644         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH04], 128, 0);
 645         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH05], 128, 0);
 646         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH06],
 647                 188*4, 0);
 648         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH07], 128, 0);
 649         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH08], 128, 0);
 650         cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH09], 128, 0);
 651
 652         cx23885_gpio_setup(dev);
 653 }
 654
 655
 656 static int cx23885_pci_quirks(struct cx23885_dev *dev)
 657 {
 658         dprintk(1, "%s()\n", __func__);
 659
 660         /* The cx23885 bridge has a weird bug which causes NMI to be asserted
 661          * when DMA begins if RDR_TLCTL0 bit4 is not cleared. It does not
 662          * occur on the cx23887 bridge.
 663          */
 664         if (dev->bridge == CX23885_BRIDGE_885)
 665                 cx_clear(RDR_TLCTL0, 1 << 4);
 666
 667         return 0;
 668 }
 669
 670 static int get_resources(struct cx23885_dev *dev)
 671 {
 672         if (request_mem_region(pci_resource_start(dev->pci, 0),
 673                                pci_resource_len(dev->pci, 0),
 674                                dev->name))
 675                 return 0;
 676
 677         printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx\n",
 678                 dev->name, (unsigned long long)pci_resource_start(dev->pci, 0));
 679
 680         return -EBUSY;
 681 }
 682
 683 static int cx23885_init_tsport(struct cx23885_dev *dev,
 684         struct cx23885_tsport *port, int portno)
 685 {
 686         dprintk(1, "%s(portno=%d)\n", __func__, portno);
 687
 688         /* Transport bus init dma queue  - Common settings */
 689         port->dma_ctl_val        = 0x11; /* Enable RISC controller and Fifo */
 690         port->ts_int_msk_val     = 0x1111; /* TS port bits for RISC */
 691         port->vld_misc_val       = 0x0;
 692         port->hw_sop_ctrl_val    = (0x47 << 16 | 188 << 4);
 693
 694         spin_lock_init(&port->slock);
 695         port->dev = dev;
 696         port->nr = portno;
 697
 698         INIT_LIST_HEAD(&port->mpegq.active);
 699         mutex_init(&port->frontends.lock);
 700         INIT_LIST_HEAD(&port->frontends.felist);
 701         port->frontends.active_fe_id = 0;
 702
 703         /* This should be hardcoded allow a single frontend
 704          * attachment to this tsport, keeping the -dvb.c
 705          * code clean and safe.
 706          */
 707         if (!port->num_frontends)
 708                 port->num_frontends = 1;
 709
 710         switch (portno) {
 711         case 1:
 712                 port->reg_gpcnt          = VID_B_GPCNT;
 713                 port->reg_gpcnt_ctl      = VID_B_GPCNT_CTL;
 714                 port->reg_dma_ctl        = VID_B_DMA_CTL;
 715                 port->reg_lngth          = VID_B_LNGTH;
 716                 port->reg_hw_sop_ctrl    = VID_B_HW_SOP_CTL;
 717                 port->reg_gen_ctrl       = VID_B_GEN_CTL;
 718                 port->reg_bd_pkt_status  = VID_B_BD_PKT_STATUS;
 719                 port->reg_sop_status     = VID_B_SOP_STATUS;
 720                 port->reg_fifo_ovfl_stat = VID_B_FIFO_OVFL_STAT;
 721                 port->reg_vld_misc       = VID_B_VLD_MISC;
 722                 port->reg_ts_clk_en      = VID_B_TS_CLK_EN;
 723                 port->reg_src_sel        = VID_B_SRC_SEL;
 724                 port->reg_ts_int_msk     = VID_B_INT_MSK;
 725                 port->reg_ts_int_stat    = VID_B_INT_STAT;
 726                 port->sram_chno          = SRAM_CH03; /* VID_B */
 727                 port->pci_irqmask        = 0x02; /* VID_B bit1 */
 728                 break;
 729         case 2:
 730                 port->reg_gpcnt          = VID_C_GPCNT;
 731                 port->reg_gpcnt_ctl      = VID_C_GPCNT_CTL;
 732                 port->reg_dma_ctl        = VID_C_DMA_CTL;
 733                 port->reg_lngth          = VID_C_LNGTH;
 734                 port->reg_hw_sop_ctrl    = VID_C_HW_SOP_CTL;
 735                 port->reg_gen_ctrl       = VID_C_GEN_CTL;
 736                 port->reg_bd_pkt_status  = VID_C_BD_PKT_STATUS;
 737                 port->reg_sop_status     = VID_C_SOP_STATUS;
 738                 port->reg_fifo_ovfl_stat = VID_C_FIFO_OVFL_STAT;
 739                 port->reg_vld_misc       = VID_C_VLD_MISC;
 740                 port->reg_ts_clk_en      = VID_C_TS_CLK_EN;
 741                 port->reg_src_sel        = 0;
 742                 port->reg_ts_int_msk     = VID_C_INT_MSK;
 743                 port->reg_ts_int_stat    = VID_C_INT_STAT;
 744                 port->sram_chno          = SRAM_CH06; /* VID_C */
 745                 port->pci_irqmask        = 0x04; /* VID_C bit2 */
 746                 break;
 747         default:
 748                 BUG();
 749         }
 750
 751         return 0;
 752 }
 753
 754 static void cx23885_dev_checkrevision(struct cx23885_dev *dev)
 755 {
 756         switch (cx_read(RDR_CFG2) & 0xff) {
 757         case 0x00:
 758                 /* cx23885 */
 759                 dev->hwrevision = 0xa0;
 760                 break;
 761         case 0x01:
 762                 /* CX23885-12Z */
 763                 dev->hwrevision = 0xa1;
 764                 break;
 765         case 0x02:
 766                 /* CX23885-13Z/14Z */
 767                 dev->hwrevision = 0xb0;
 768                 break;
 769         case 0x03:
 770                 if (dev->pci->device == 0x8880) {
 771                         /* CX23888-21Z/22Z */
 772                         dev->hwrevision = 0xc0;
 773                 } else {
 774                         /* CX23885-14Z */
 775                         dev->hwrevision = 0xa4;
 776                 }
 777                 break;
 778         case 0x04:
 779                 if (dev->pci->device == 0x8880) {
 780                         /* CX23888-31Z */
 781                         dev->hwrevision = 0xd0;
 782                 } else {
 783                         /* CX23885-15Z, CX23888-31Z */
 784                         dev->hwrevision = 0xa5;
 785                 }
 786                 break;
 787         case 0x0e:
 788                 /* CX23887-15Z */
 789                 dev->hwrevision = 0xc0;
 790                 break;
 791         case 0x0f:
 792                 /* CX23887-14Z */
 793                 dev->hwrevision = 0xb1;
 794                 break;
 795         default:
 796                 printk(KERN_ERR "%s() New hardware revision found 0x%x\n",
 797                         __func__, dev->hwrevision);
 798         }
 799         if (dev->hwrevision)
 800                 printk(KERN_INFO "%s() Hardware revision = 0x%02x\n",
 801                         __func__, dev->hwrevision);
 802         else
 803                 printk(KERN_ERR "%s() Hardware revision unknown 0x%x\n",
 804                         __func__, dev->hwrevision);
 805 }
 806
 807 /* Find the first v4l2_subdev member of the group id in hw */
 808 struct v4l2_subdev *cx23885_find_hw(struct cx23885_dev *dev, u32 hw)
 809 {
 810         struct v4l2_subdev *result = NULL;
 811         struct v4l2_subdev *sd;
 812
 813         spin_lock(&dev->v4l2_dev.lock);
 814         v4l2_device_for_each_subdev(sd, &dev->v4l2_dev) {
 815                 if (sd->grp_id == hw) {
 816                         result = sd;
 817                         break;
 818                 }
 819         }
 820         spin_unlock(&dev->v4l2_dev.lock);
 821         return result;
 822 }
 823
 824 static int cx23885_dev_setup(struct cx23885_dev *dev)
 825 {
 826         int i;
 827
 828         spin_lock_init(&dev->pci_irqmask_lock);
 829         spin_lock_init(&dev->slock);
 830
 831         mutex_init(&dev->lock);
 832         mutex_init(&dev->gpio_lock);
 833
 834         atomic_inc(&dev->refcount);
 835
 836         dev->nr = cx23885_devcount++;
 837         sprintf(dev->name, "cx23885[%d]", dev->nr);
 838
 839         /* Configure the internal memory */
 840         if (dev->pci->device == 0x8880) {
 841                 /* Could be 887 or 888, assume a default */
 842                 dev->bridge = CX23885_BRIDGE_887;
 843                 /* Apply a sensible clock frequency for the PCIe bridge */
 844                 dev->clk_freq = 25000000;
 845                 dev->sram_channels = cx23887_sram_channels;
 846         } else
 847         if (dev->pci->device == 0x8852) {
 848                 dev->bridge = CX23885_BRIDGE_885;
 849                 /* Apply a sensible clock frequency for the PCIe bridge */
 850                 dev->clk_freq = 28000000;
 851                 dev->sram_channels = cx23885_sram_channels;
 852         } else
 853                 BUG();
 854
 855         dprintk(1, "%s() Memory configured for PCIe bridge type %d\n",
 856                 __func__, dev->bridge);
 857
 858         /* board config */
 859         dev->board = UNSET;
 860         if (card[dev->nr] < cx23885_bcount)
 861                 dev->board = card[dev->nr];
 862         for (i = 0; UNSET == dev->board  &&  i < cx23885_idcount; i++)
 863                 if (dev->pci->subsystem_vendor == cx23885_subids[i].subvendor &&
 864                     dev->pci->subsystem_device == cx23885_subids[i].subdevice)
 865                         dev->board = cx23885_subids[i].card;
 866         if (UNSET == dev->board) {
 867                 dev->board = CX23885_BOARD_UNKNOWN;
 868                 cx23885_card_list(dev);
 869         }
 870
 871         /* If the user specific a clk freq override, apply it */
 872         if (cx23885_boards[dev->board].clk_freq > 0)
 873                 dev->clk_freq = cx23885_boards[dev->board].clk_freq;
 874
 875         dev->pci_bus  = dev->pci->bus->number;
 876         dev->pci_slot = PCI_SLOT(dev->pci->devfn);
 877         cx23885_irq_add(dev, 0x001f00);
 878
 879         /* External Master 1 Bus */
 880         dev->i2c_bus[0].nr = 0;
 881         dev->i2c_bus[0].dev = dev;
 882         dev->i2c_bus[0].reg_stat  = I2C1_STAT;
 883         dev->i2c_bus[0].reg_ctrl  = I2C1_CTRL;
 884         dev->i2c_bus[0].reg_addr  = I2C1_ADDR;
 885         dev->i2c_bus[0].reg_rdata = I2C1_RDATA;
 886         dev->i2c_bus[0].reg_wdata = I2C1_WDATA;
 887         dev->i2c_bus[0].i2c_period = (0x9d << 24); /* 100kHz */
 888
 889         /* External Master 2 Bus */
 890         dev->i2c_bus[1].nr = 1;
 891         dev->i2c_bus[1].dev = dev;
 892         dev->i2c_bus[1].reg_stat  = I2C2_STAT;
 893         dev->i2c_bus[1].reg_ctrl  = I2C2_CTRL;
 894         dev->i2c_bus[1].reg_addr  = I2C2_ADDR;
 895         dev->i2c_bus[1].reg_rdata = I2C2_RDATA;
 896         dev->i2c_bus[1].reg_wdata = I2C2_WDATA;
 897         dev->i2c_bus[1].i2c_period = (0x9d << 24); /* 100kHz */
 898
 899         /* Internal Master 3 Bus */
 900         dev->i2c_bus[2].nr = 2;
 901         dev->i2c_bus[2].dev = dev;
 902         dev->i2c_bus[2].reg_stat  = I2C3_STAT;
 903         dev->i2c_bus[2].reg_ctrl  = I2C3_CTRL;
 904         dev->i2c_bus[2].reg_addr  = I2C3_ADDR;
 905         dev->i2c_bus[2].reg_rdata = I2C3_RDATA;
 906         dev->i2c_bus[2].reg_wdata = I2C3_WDATA;
 907         dev->i2c_bus[2].i2c_period = (0x07 << 24); /* 1.95MHz */
 908
 909         if ((cx23885_boards[dev->board].portb == CX23885_MPEG_DVB) ||
 910                 (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER))
 911                 cx23885_init_tsport(dev, &dev->ts1, 1);
 912
 913         if ((cx23885_boards[dev->board].portc == CX23885_MPEG_DVB) ||
 914                 (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER))
 915                 cx23885_init_tsport(dev, &dev->ts2, 2);
 916
 917         if (get_resources(dev) < 0) {
 918                 printk(KERN_ERR "CORE %s No more PCIe resources for "
 919                        "subsystem: %04x:%04x\n",
 920                        dev->name, dev->pci->subsystem_vendor,
 921                        dev->pci->subsystem_device);
 922
 923                 cx23885_devcount--;
 924                 return -ENODEV;
 925         }
 926
 927         /* PCIe stuff */
 928         dev->lmmio = ioremap(pci_resource_start(dev->pci, 0),
 929                              pci_resource_len(dev->pci, 0));
 930
 931         dev->bmmio = (u8 __iomem *)dev->lmmio;
 932
 933         printk(KERN_INFO "CORE %s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
 934                dev->name, dev->pci->subsystem_vendor,
 935                dev->pci->subsystem_device, cx23885_boards[dev->board].name,
 936                dev->board, card[dev->nr] == dev->board ?
 937                "insmod option" : "autodetected");
 938
 939         cx23885_pci_quirks(dev);
 940
 941         /* Assume some sensible defaults */
 942         dev->tuner_type = cx23885_boards[dev->board].tuner_type;
 943         dev->tuner_addr = cx23885_boards[dev->board].tuner_addr;
 944         dev->tuner_bus = cx23885_boards[dev->board].tuner_bus;
 945         dev->radio_type = cx23885_boards[dev->board].radio_type;
 946         dev->radio_addr = cx23885_boards[dev->board].radio_addr;
 947
 948         dprintk(1, "%s() tuner_type = 0x%x tuner_addr = 0x%x tuner_bus = %d\n",
 949                 __func__, dev->tuner_type, dev->tuner_addr, dev->tuner_bus);
 950         dprintk(1, "%s() radio_type = 0x%x radio_addr = 0x%x\n",
 951                 __func__, dev->radio_type, dev->radio_addr);
 952
 953         /* The cx23417 encoder has GPIO's that need to be initialised
 954          * before DVB, so that demodulators and tuners are out of
 955          * reset before DVB uses them.
 956          */
 957         if ((cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) ||
 958                 (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER))
 959                         cx23885_mc417_init(dev);
 960
 961         /* init hardware */
 962         cx23885_reset(dev);
 963
 964         cx23885_i2c_register(&dev->i2c_bus[0]);
 965         cx23885_i2c_register(&dev->i2c_bus[1]);
 966         cx23885_i2c_register(&dev->i2c_bus[2]);
 967         cx23885_card_setup(dev);
 968         call_all(dev, core, s_power, 0);
 969         cx23885_ir_init(dev);
 970
 971         if (dev->board == CX23885_BOARD_VIEWCAST_460E) {
 972                 /*
 973                  * GPIOs 9/8 are input detection bits for the breakout video
 974                  * (gpio 8) and audio (gpio 9) cables. When they're attached,
 975                  * this gpios are pulled high. Make sure these GPIOs are marked
 976                  * as inputs.
 977                  */
 978                 cx23885_gpio_enable(dev, 0x300, 0);
 979         }
 980
 981         if (cx23885_boards[dev->board].porta == CX23885_ANALOG_VIDEO) {
 982                 if (cx23885_video_register(dev) < 0) {
 983                         printk(KERN_ERR "%s() Failed to register analog "
 984                                 "video adapters on VID_A\n", __func__);
 985                 }
 986         }
 987
 988         if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB) {
 989                 if (cx23885_boards[dev->board].num_fds_portb)
 990                         dev->ts1.num_frontends =
 991                                 cx23885_boards[dev->board].num_fds_portb;
 992                 if (cx23885_dvb_register(&dev->ts1) < 0) {
 993                         printk(KERN_ERR "%s() Failed to register dvb adapters on VID_B\n",
 994                                __func__);
 995                 }
 996         } else
 997         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) {
 998                 if (cx23885_417_register(dev) < 0) {
 999                         printk(KERN_ERR
1000                                 "%s() Failed to register 417 on VID_B\n",
1001                                __func__);
1002                 }
1003         }
1004
1005         if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB) {
1006                 if (cx23885_boards[dev->board].num_fds_portc)
1007                         dev->ts2.num_frontends =
1008                                 cx23885_boards[dev->board].num_fds_portc;
1009                 if (cx23885_dvb_register(&dev->ts2) < 0) {
1010                         printk(KERN_ERR
1011                                 "%s() Failed to register dvb on VID_C\n",
1012                                __func__);
1013                 }
1014         } else
1015         if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER) {
1016                 if (cx23885_417_register(dev) < 0) {
1017                         printk(KERN_ERR
1018                                 "%s() Failed to register 417 on VID_C\n",
1019                                __func__);
1020                 }
1021         }
1022
1023         cx23885_dev_checkrevision(dev);
1024
1025         /* disable MSI for NetUP cards, otherwise CI is not working */
1026         if (cx23885_boards[dev->board].ci_type > 0)
1027                 cx_clear(RDR_RDRCTL1, 1 << 8);
1028
1029         switch (dev->board) {
1030         case CX23885_BOARD_TEVII_S470:
1031         case CX23885_BOARD_TEVII_S471:
1032                 cx_clear(RDR_RDRCTL1, 1 << 8);
1033                 break;
1034         }
1035
1036         return 0;
1037 }
1038
1039 static void cx23885_dev_unregister(struct cx23885_dev *dev)
1040 {
1041         release_mem_region(pci_resource_start(dev->pci, 0),
1042                            pci_resource_len(dev->pci, 0));
1043
1044         if (!atomic_dec_and_test(&dev->refcount))
1045                 return;
1046
1047         if (cx23885_boards[dev->board].porta == CX23885_ANALOG_VIDEO)
1048                 cx23885_video_unregister(dev);
1049
1050         if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB)
1051                 cx23885_dvb_unregister(&dev->ts1);
1052
1053         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1054                 cx23885_417_unregister(dev);
1055
1056         if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB)
1057                 cx23885_dvb_unregister(&dev->ts2);
1058
1059         if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER)
1060                 cx23885_417_unregister(dev);
1061
1062         cx23885_i2c_unregister(&dev->i2c_bus[2]);
1063         cx23885_i2c_unregister(&dev->i2c_bus[1]);
1064         cx23885_i2c_unregister(&dev->i2c_bus[0]);
1065
1066         iounmap(dev->lmmio);
1067 }
1068
1069 static __le32 *cx23885_risc_field(__le32 *rp, struct scatterlist *sglist,
1070                                unsigned int offset, u32 sync_line,
1071                                unsigned int bpl, unsigned int padding,
1072                                unsigned int lines,  unsigned int lpi, bool jump)
1073 {
1074         struct scatterlist *sg;
1075         unsigned int line, todo, sol;
1076
1077
1078         if (jump) {
1079                 *(rp++) = cpu_to_le32(RISC_JUMP);
1080                 *(rp++) = cpu_to_le32(0);
1081                 *(rp++) = cpu_to_le32(0); /* bits 63-32 */
1082         }
1083
1084         /* sync instruction */
1085         if (sync_line != NO_SYNC_LINE)
1086                 *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
1087
1088         /* scan lines */
1089         sg = sglist;
1090         for (line = 0; line < lines; line++) {
1091                 while (offset && offset >= sg_dma_len(sg)) {
1092                         offset -= sg_dma_len(sg);
1093                         sg = sg_next(sg);
1094                 }
1095
1096                 if (lpi && line > 0 && !(line % lpi))
1097                         sol = RISC_SOL | RISC_IRQ1 | RISC_CNT_INC;
1098                 else
1099                         sol = RISC_SOL;
1100
1101                 if (bpl <= sg_dma_len(sg)-offset) {
1102                         /* fits into current chunk */
1103                         *(rp++) = cpu_to_le32(RISC_WRITE|sol|RISC_EOL|bpl);
1104                         *(rp++) = cpu_to_le32(sg_dma_address(sg)+offset);
1105                         *(rp++) = cpu_to_le32(0); /* bits 63-32 */
1106                         offset += bpl;
1107                 } else {
1108                         /* scanline needs to be split */
1109                         todo = bpl;
1110                         *(rp++) = cpu_to_le32(RISC_WRITE|sol|
1111                                             (sg_dma_len(sg)-offset));
1112                         *(rp++) = cpu_to_le32(sg_dma_address(sg)+offset);
1113                         *(rp++) = cpu_to_le32(0); /* bits 63-32 */
1114                         todo -= (sg_dma_len(sg)-offset);
1115                         offset = 0;
1116                         sg = sg_next(sg);
1117                         while (todo > sg_dma_len(sg)) {
1118                                 *(rp++) = cpu_to_le32(RISC_WRITE|
1119                                                     sg_dma_len(sg));
1120                                 *(rp++) = cpu_to_le32(sg_dma_address(sg));
1121                                 *(rp++) = cpu_to_le32(0); /* bits 63-32 */
1122                                 todo -= sg_dma_len(sg);
1123                                 sg = sg_next(sg);
1124                         }
1125                         *(rp++) = cpu_to_le32(RISC_WRITE|RISC_EOL|todo);
1126                         *(rp++) = cpu_to_le32(sg_dma_address(sg));
1127                         *(rp++) = cpu_to_le32(0); /* bits 63-32 */
1128                         offset += todo;
1129                 }
1130                 offset += padding;
1131         }
1132
1133         return rp;
1134 }
1135
1136 int cx23885_risc_buffer(struct pci_dev *pci, struct cx23885_riscmem *risc,
1137                         struct scatterlist *sglist, unsigned int top_offset,
1138                         unsigned int bottom_offset, unsigned int bpl,
1139                         unsigned int padding, unsigned int lines)
1140 {
1141         u32 instructions, fields;
1142         __le32 *rp;
1143
1144         fields = 0;
1145         if (UNSET != top_offset)
1146                 fields++;
1147         if (UNSET != bottom_offset)
1148                 fields++;
1149
1150         /* estimate risc mem: worst case is one write per page border +
1151            one write per scan line + syncs + jump (all 2 dwords).  Padding
1152            can cause next bpl to start close to a page border.  First DMA
1153            region may be smaller than PAGE_SIZE */
1154         /* write and jump need and extra dword */
1155         instructions  = fields * (1 + ((bpl + padding) * lines)
1156                 / PAGE_SIZE + lines);
1157         instructions += 5;
1158         risc->size = instructions * 12;
1159         risc->cpu = pci_alloc_consistent(pci, risc->size, &risc->dma);
1160         if (risc->cpu == NULL)
1161                 return -ENOMEM;
1162
1163         /* write risc instructions */
1164         rp = risc->cpu;
1165         if (UNSET != top_offset)
1166                 rp = cx23885_risc_field(rp, sglist, top_offset, 0,
1167                                         bpl, padding, lines, 0, true);
1168         if (UNSET != bottom_offset)
1169                 rp = cx23885_risc_field(rp, sglist, bottom_offset, 0x200,
1170                                         bpl, padding, lines, 0, UNSET == top_offset);
1171
1172         /* save pointer to jmp instruction address */
1173         risc->jmp = rp;
1174         BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1175         return 0;
1176 }
1177
1178 int cx23885_risc_databuffer(struct pci_dev *pci,
1179                                    struct cx23885_riscmem *risc,
1180                                    struct scatterlist *sglist,
1181                                    unsigned int bpl,
1182                                    unsigned int lines, unsigned int lpi)
1183 {
1184         u32 instructions;
1185         __le32 *rp;
1186
1187         /* estimate risc mem: worst case is one write per page border +
1188            one write per scan line + syncs + jump (all 2 dwords).  Here
1189            there is no padding and no sync.  First DMA region may be smaller
1190            than PAGE_SIZE */
1191         /* Jump and write need an extra dword */
1192         instructions  = 1 + (bpl * lines) / PAGE_SIZE + lines;
1193         instructions += 4;
1194
1195         risc->size = instructions * 12;
1196         risc->cpu = pci_alloc_consistent(pci, risc->size, &risc->dma);
1197         if (risc->cpu == NULL)
1198                 return -ENOMEM;
1199
1200         /* write risc instructions */
1201         rp = risc->cpu;
1202         rp = cx23885_risc_field(rp, sglist, 0, NO_SYNC_LINE,
1203                                 bpl, 0, lines, lpi, lpi == 0);
1204
1205         /* save pointer to jmp instruction address */
1206         risc->jmp = rp;
1207         BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1208         return 0;
1209 }
1210
1211 int cx23885_risc_vbibuffer(struct pci_dev *pci, struct cx23885_riscmem *risc,
1212                         struct scatterlist *sglist, unsigned int top_offset,
1213                         unsigned int bottom_offset, unsigned int bpl,
1214                         unsigned int padding, unsigned int lines)
1215 {
1216         u32 instructions, fields;
1217         __le32 *rp;
1218
1219         fields = 0;
1220         if (UNSET != top_offset)
1221                 fields++;
1222         if (UNSET != bottom_offset)
1223                 fields++;
1224
1225         /* estimate risc mem: worst case is one write per page border +
1226            one write per scan line + syncs + jump (all 2 dwords).  Padding
1227            can cause next bpl to start close to a page border.  First DMA
1228            region may be smaller than PAGE_SIZE */
1229         /* write and jump need and extra dword */
1230         instructions  = fields * (1 + ((bpl + padding) * lines)
1231                 / PAGE_SIZE + lines);
1232         instructions += 5;
1233         risc->size = instructions * 12;
1234         risc->cpu = pci_alloc_consistent(pci, risc->size, &risc->dma);
1235         if (risc->cpu == NULL)
1236                 return -ENOMEM;
1237         /* write risc instructions */
1238         rp = risc->cpu;
1239
1240         /* Sync to line 6, so US CC line 21 will appear in line '12'
1241          * in the userland vbi payload */
1242         if (UNSET != top_offset)
1243                 rp = cx23885_risc_field(rp, sglist, top_offset, 0,
1244                                         bpl, padding, lines, 0, true);
1245
1246         if (UNSET != bottom_offset)
1247                 rp = cx23885_risc_field(rp, sglist, bottom_offset, 0x200,
1248                                         bpl, padding, lines, 0, UNSET == top_offset);
1249
1250
1251
1252         /* save pointer to jmp instruction address */
1253         risc->jmp = rp;
1254         BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1255         return 0;
1256 }
1257
1258
1259 void cx23885_free_buffer(struct cx23885_dev *dev, struct cx23885_buffer *buf)
1260 {
1261         struct cx23885_riscmem *risc = &buf->risc;
1262
1263         BUG_ON(in_interrupt());
1264         pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma);
1265 }
1266
1267 static void cx23885_tsport_reg_dump(struct cx23885_tsport *port)
1268 {
1269         struct cx23885_dev *dev = port->dev;
1270
1271         dprintk(1, "%s() Register Dump\n", __func__);
1272         dprintk(1, "%s() DEV_CNTRL2               0x%08X\n", __func__,
1273                 cx_read(DEV_CNTRL2));
1274         dprintk(1, "%s() PCI_INT_MSK              0x%08X\n", __func__,
1275                 cx23885_irq_get_mask(dev));
1276         dprintk(1, "%s() AUD_INT_INT_MSK          0x%08X\n", __func__,
1277                 cx_read(AUDIO_INT_INT_MSK));
1278         dprintk(1, "%s() AUD_INT_DMA_CTL          0x%08X\n", __func__,
1279                 cx_read(AUD_INT_DMA_CTL));
1280         dprintk(1, "%s() AUD_EXT_INT_MSK          0x%08X\n", __func__,
1281                 cx_read(AUDIO_EXT_INT_MSK));
1282         dprintk(1, "%s() AUD_EXT_DMA_CTL          0x%08X\n", __func__,
1283                 cx_read(AUD_EXT_DMA_CTL));
1284         dprintk(1, "%s() PAD_CTRL                 0x%08X\n", __func__,
1285                 cx_read(PAD_CTRL));
1286         dprintk(1, "%s() ALT_PIN_OUT_SEL          0x%08X\n", __func__,
1287                 cx_read(ALT_PIN_OUT_SEL));
1288         dprintk(1, "%s() GPIO2                    0x%08X\n", __func__,
1289                 cx_read(GPIO2));
1290         dprintk(1, "%s() gpcnt(0x%08X)          0x%08X\n", __func__,
1291                 port->reg_gpcnt, cx_read(port->reg_gpcnt));
1292         dprintk(1, "%s() gpcnt_ctl(0x%08X)      0x%08x\n", __func__,
1293                 port->reg_gpcnt_ctl, cx_read(port->reg_gpcnt_ctl));
1294         dprintk(1, "%s() dma_ctl(0x%08X)        0x%08x\n", __func__,
1295                 port->reg_dma_ctl, cx_read(port->reg_dma_ctl));
1296         if (port->reg_src_sel)
1297                 dprintk(1, "%s() src_sel(0x%08X)        0x%08x\n", __func__,
1298                         port->reg_src_sel, cx_read(port->reg_src_sel));
1299         dprintk(1, "%s() lngth(0x%08X)          0x%08x\n", __func__,
1300                 port->reg_lngth, cx_read(port->reg_lngth));
1301         dprintk(1, "%s() hw_sop_ctrl(0x%08X)    0x%08x\n", __func__,
1302                 port->reg_hw_sop_ctrl, cx_read(port->reg_hw_sop_ctrl));
1303         dprintk(1, "%s() gen_ctrl(0x%08X)       0x%08x\n", __func__,
1304                 port->reg_gen_ctrl, cx_read(port->reg_gen_ctrl));
1305         dprintk(1, "%s() bd_pkt_status(0x%08X)  0x%08x\n", __func__,
1306                 port->reg_bd_pkt_status, cx_read(port->reg_bd_pkt_status));
1307         dprintk(1, "%s() sop_status(0x%08X)     0x%08x\n", __func__,
1308                 port->reg_sop_status, cx_read(port->reg_sop_status));
1309         dprintk(1, "%s() fifo_ovfl_stat(0x%08X) 0x%08x\n", __func__,
1310                 port->reg_fifo_ovfl_stat, cx_read(port->reg_fifo_ovfl_stat));
1311         dprintk(1, "%s() vld_misc(0x%08X)       0x%08x\n", __func__,
1312                 port->reg_vld_misc, cx_read(port->reg_vld_misc));
1313         dprintk(1, "%s() ts_clk_en(0x%08X)      0x%08x\n", __func__,
1314                 port->reg_ts_clk_en, cx_read(port->reg_ts_clk_en));
1315         dprintk(1, "%s() ts_int_msk(0x%08X)     0x%08x\n", __func__,
1316                 port->reg_ts_int_msk, cx_read(port->reg_ts_int_msk));
1317 }
1318
1319 int cx23885_start_dma(struct cx23885_tsport *port,
1320                              struct cx23885_dmaqueue *q,
1321                              struct cx23885_buffer   *buf)
1322 {
1323         struct cx23885_dev *dev = port->dev;
1324         u32 reg;
1325
1326         dprintk(1, "%s() w: %d, h: %d, f: %d\n", __func__,
1327                 dev->width, dev->height, dev->field);
1328
1329         /* Stop the fifo and risc engine for this port */
1330         cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1331
1332         /* setup fifo + format */
1333         cx23885_sram_channel_setup(dev,
1334                                    &dev->sram_channels[port->sram_chno],
1335                                    port->ts_packet_size, buf->risc.dma);
1336         if (debug > 5) {
1337                 cx23885_sram_channel_dump(dev,
1338                         &dev->sram_channels[port->sram_chno]);
1339                 cx23885_risc_disasm(port, &buf->risc);
1340         }
1341
1342         /* write TS length to chip */
1343         cx_write(port->reg_lngth, port->ts_packet_size);
1344
1345         if ((!(cx23885_boards[dev->board].portb & CX23885_MPEG_DVB)) &&
1346                 (!(cx23885_boards[dev->board].portc & CX23885_MPEG_DVB))) {
1347                 printk("%s() Unsupported .portb/c (0x%08x)/(0x%08x)\n",
1348                         __func__,
1349                         cx23885_boards[dev->board].portb,
1350                         cx23885_boards[dev->board].portc);
1351                 return -EINVAL;
1352         }
1353
1354         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1355                 cx23885_av_clk(dev, 0);
1356
1357         udelay(100);
1358
1359         /* If the port supports SRC SELECT, configure it */
1360         if (port->reg_src_sel)
1361                 cx_write(port->reg_src_sel, port->src_sel_val);
1362
1363         cx_write(port->reg_hw_sop_ctrl, port->hw_sop_ctrl_val);
1364         cx_write(port->reg_ts_clk_en, port->ts_clk_en_val);
1365         cx_write(port->reg_vld_misc, port->vld_misc_val);
1366         cx_write(port->reg_gen_ctrl, port->gen_ctrl_val);
1367         udelay(100);
1368
1369         /* NOTE: this is 2 (reserved) for portb, does it matter? */
1370         /* reset counter to zero */
1371         cx_write(port->reg_gpcnt_ctl, 3);
1372         q->count = 0;
1373
1374         /* Set VIDB pins to input */
1375         if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB) {
1376                 reg = cx_read(PAD_CTRL);
1377                 reg &= ~0x3; /* Clear TS1_OE & TS1_SOP_OE */
1378                 cx_write(PAD_CTRL, reg);
1379         }
1380
1381         /* Set VIDC pins to input */
1382         if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB) {
1383                 reg = cx_read(PAD_CTRL);
1384                 reg &= ~0x4; /* Clear TS2_SOP_OE */
1385                 cx_write(PAD_CTRL, reg);
1386         }
1387
1388         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) {
1389
1390                 reg = cx_read(PAD_CTRL);
1391                 reg = reg & ~0x1;    /* Clear TS1_OE */
1392
1393                 /* FIXME, bit 2 writing here is questionable */
1394                 /* set TS1_SOP_OE and TS1_OE_HI */
1395                 reg = reg | 0xa;
1396                 cx_write(PAD_CTRL, reg);
1397
1398                 /* FIXME and these two registers should be documented. */
1399                 cx_write(CLK_DELAY, cx_read(CLK_DELAY) | 0x80000011);
1400                 cx_write(ALT_PIN_OUT_SEL, 0x10100045);
1401         }
1402
1403         switch (dev->bridge) {
1404         case CX23885_BRIDGE_885:
1405         case CX23885_BRIDGE_887:
1406         case CX23885_BRIDGE_888:
1407                 /* enable irqs */
1408                 dprintk(1, "%s() enabling TS int's and DMA\n", __func__);
1409                 cx_set(port->reg_ts_int_msk,  port->ts_int_msk_val);
1410                 cx_set(port->reg_dma_ctl, port->dma_ctl_val);
1411                 cx23885_irq_add(dev, port->pci_irqmask);
1412                 cx23885_irq_enable_all(dev);
1413                 break;
1414         default:
1415                 BUG();
1416         }
1417
1418         cx_set(DEV_CNTRL2, (1<<5)); /* Enable RISC controller */
1419
1420         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1421                 cx23885_av_clk(dev, 1);
1422
1423         if (debug > 4)
1424                 cx23885_tsport_reg_dump(port);
1425
1426         return 0;
1427 }
1428
1429 static int cx23885_stop_dma(struct cx23885_tsport *port)
1430 {
1431         struct cx23885_dev *dev = port->dev;
1432         u32 reg;
1433
1434         dprintk(1, "%s()\n", __func__);
1435
1436         /* Stop interrupts and DMA */
1437         cx_clear(port->reg_ts_int_msk, port->ts_int_msk_val);
1438         cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1439
1440         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) {
1441
1442                 reg = cx_read(PAD_CTRL);
1443
1444                 /* Set TS1_OE */
1445                 reg = reg | 0x1;
1446
1447                 /* clear TS1_SOP_OE and TS1_OE_HI */
1448                 reg = reg & ~0xa;
1449                 cx_write(PAD_CTRL, reg);
1450                 cx_write(port->reg_src_sel, 0);
1451                 cx_write(port->reg_gen_ctrl, 8);
1452
1453         }
1454
1455         if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1456                 cx23885_av_clk(dev, 0);
1457
1458         return 0;
1459 }
1460
1461 /* ------------------------------------------------------------------ */
1462
1463 int cx23885_buf_prepare(struct cx23885_buffer *buf, struct cx23885_tsport *port)
1464 {
1465         struct cx23885_dev *dev = port->dev;
1466         int size = port->ts_packet_size * port->ts_packet_count;
1467         struct sg_table *sgt = vb2_dma_sg_plane_desc(&buf->vb.vb2_buf, 0);
1468
1469         dprintk(1, "%s: %p\n", __func__, buf);
1470         if (vb2_plane_size(&buf->vb.vb2_buf, 0) < size)
1471                 return -EINVAL;
1472         vb2_set_plane_payload(&buf->vb.vb2_buf, 0, size);
1473
1474         cx23885_risc_databuffer(dev->pci, &buf->risc,
1475                                 sgt->sgl,
1476                                 port->ts_packet_size, port->ts_packet_count, 0);
1477         return 0;
1478 }
1479
1480 /*
1481  * The risc program for each buffer works as follows: it starts with a simple
1482  * 'JUMP to addr + 12', which is effectively a NOP. Then the code to DMA the
1483  * buffer follows and at the end we have a JUMP back to the start + 12 (skipping
1484  * the initial JUMP).
1485  *
1486  * This is the risc program of the first buffer to be queued if the active list
1487  * is empty and it just keeps DMAing this buffer without generating any
1488  * interrupts.
1489  *
1490  * If a new buffer is added then the initial JUMP in the code for that buffer
1491  * will generate an interrupt which signals that the previous buffer has been
1492  * DMAed successfully and that it can be returned to userspace.
1493  *
1494  * It also sets the final jump of the previous buffer to the start of the new
1495  * buffer, thus chaining the new buffer into the DMA chain. This is a single
1496  * atomic u32 write, so there is no race condition.
1497  *
1498  * The end-result of all this that you only get an interrupt when a buffer
1499  * is ready, so the control flow is very easy.
1500  */
1501 void cx23885_buf_queue(struct cx23885_tsport *port, struct cx23885_buffer *buf)
1502 {
1503         struct cx23885_buffer    *prev;
1504         struct cx23885_dev *dev = port->dev;
1505         struct cx23885_dmaqueue  *cx88q = &port->mpegq;
1506         unsigned long flags;
1507
1508         buf->risc.cpu[1] = cpu_to_le32(buf->risc.dma + 12);
1509         buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_CNT_INC);
1510         buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma + 12);
1511         buf->risc.jmp[2] = cpu_to_le32(0); /* bits 63-32 */
1512
1513         spin_lock_irqsave(&dev->slock, flags);
1514         if (list_empty(&cx88q->active)) {
1515                 list_add_tail(&buf->queue, &cx88q->active);
1516                 dprintk(1, "[%p/%d] %s - first active\n",
1517                         buf, buf->vb.vb2_buf.index, __func__);
1518         } else {
1519                 buf->risc.cpu[0] |= cpu_to_le32(RISC_IRQ1);
1520                 prev = list_entry(cx88q->active.prev, struct cx23885_buffer,
1521                                   queue);
1522                 list_add_tail(&buf->queue, &cx88q->active);
1523                 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
1524                 dprintk(1, "[%p/%d] %s - append to active\n",
1525                          buf, buf->vb.vb2_buf.index, __func__);
1526         }
1527         spin_unlock_irqrestore(&dev->slock, flags);
1528 }
1529
1530 /* ----------------------------------------------------------- */
1531
1532 static void do_cancel_buffers(struct cx23885_tsport *port, char *reason)
1533 {
1534         struct cx23885_dev *dev = port->dev;
1535         struct cx23885_dmaqueue *q = &port->mpegq;
1536         struct cx23885_buffer *buf;
1537         unsigned long flags;
1538
1539         spin_lock_irqsave(&port->slock, flags);
1540         while (!list_empty(&q->active)) {
1541                 buf = list_entry(q->active.next, struct cx23885_buffer,
1542                                  queue);
1543                 list_del(&buf->queue);
1544                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1545                 dprintk(1, "[%p/%d] %s - dma=0x%08lx\n",
1546                         buf, buf->vb.vb2_buf.index, reason,
1547                         (unsigned long)buf->risc.dma);
1548         }
1549         spin_unlock_irqrestore(&port->slock, flags);
1550 }
1551
1552 void cx23885_cancel_buffers(struct cx23885_tsport *port)
1553 {
1554         struct cx23885_dev *dev = port->dev;
1555
1556         dprintk(1, "%s()\n", __func__);
1557         cx23885_stop_dma(port);
1558         do_cancel_buffers(port, "cancel");
1559 }
1560
1561 int cx23885_irq_417(struct cx23885_dev *dev, u32 status)
1562 {
1563         /* FIXME: port1 assumption here. */
1564         struct cx23885_tsport *port = &dev->ts1;
1565         int count = 0;
1566         int handled = 0;
1567
1568         if (status == 0)
1569                 return handled;
1570
1571         count = cx_read(port->reg_gpcnt);
1572         dprintk(7, "status: 0x%08x  mask: 0x%08x count: 0x%x\n",
1573                 status, cx_read(port->reg_ts_int_msk), count);
1574
1575         if ((status & VID_B_MSK_BAD_PKT)         ||
1576                 (status & VID_B_MSK_OPC_ERR)     ||
1577                 (status & VID_B_MSK_VBI_OPC_ERR) ||
1578                 (status & VID_B_MSK_SYNC)        ||
1579                 (status & VID_B_MSK_VBI_SYNC)    ||
1580                 (status & VID_B_MSK_OF)          ||
1581                 (status & VID_B_MSK_VBI_OF)) {
1582                 printk(KERN_ERR "%s: V4L mpeg risc op code error, status "
1583                         "= 0x%x\n", dev->name, status);
1584                 if (status & VID_B_MSK_BAD_PKT)
1585                         dprintk(1, "        VID_B_MSK_BAD_PKT\n");
1586                 if (status & VID_B_MSK_OPC_ERR)
1587                         dprintk(1, "        VID_B_MSK_OPC_ERR\n");
1588                 if (status & VID_B_MSK_VBI_OPC_ERR)
1589                         dprintk(1, "        VID_B_MSK_VBI_OPC_ERR\n");
1590                 if (status & VID_B_MSK_SYNC)
1591                         dprintk(1, "        VID_B_MSK_SYNC\n");
1592                 if (status & VID_B_MSK_VBI_SYNC)
1593                         dprintk(1, "        VID_B_MSK_VBI_SYNC\n");
1594                 if (status & VID_B_MSK_OF)
1595                         dprintk(1, "        VID_B_MSK_OF\n");
1596                 if (status & VID_B_MSK_VBI_OF)
1597                         dprintk(1, "        VID_B_MSK_VBI_OF\n");
1598
1599                 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1600                 cx23885_sram_channel_dump(dev,
1601                         &dev->sram_channels[port->sram_chno]);
1602                 cx23885_417_check_encoder(dev);
1603         } else if (status & VID_B_MSK_RISCI1) {
1604                 dprintk(7, "        VID_B_MSK_RISCI1\n");
1605                 spin_lock(&port->slock);
1606                 cx23885_wakeup(port, &port->mpegq, count);
1607                 spin_unlock(&port->slock);
1608         }
1609         if (status) {
1610                 cx_write(port->reg_ts_int_stat, status);
1611                 handled = 1;
1612         }
1613
1614         return handled;
1615 }
1616
1617 static int cx23885_irq_ts(struct cx23885_tsport *port, u32 status)
1618 {
1619         struct cx23885_dev *dev = port->dev;
1620         int handled = 0;
1621         u32 count;
1622
1623         if ((status & VID_BC_MSK_OPC_ERR) ||
1624                 (status & VID_BC_MSK_BAD_PKT) ||
1625                 (status & VID_BC_MSK_SYNC) ||
1626                 (status & VID_BC_MSK_OF)) {
1627
1628                 if (status & VID_BC_MSK_OPC_ERR)
1629                         dprintk(7, " (VID_BC_MSK_OPC_ERR 0x%08x)\n",
1630                                 VID_BC_MSK_OPC_ERR);
1631
1632                 if (status & VID_BC_MSK_BAD_PKT)
1633                         dprintk(7, " (VID_BC_MSK_BAD_PKT 0x%08x)\n",
1634                                 VID_BC_MSK_BAD_PKT);
1635
1636                 if (status & VID_BC_MSK_SYNC)
1637                         dprintk(7, " (VID_BC_MSK_SYNC    0x%08x)\n",
1638                                 VID_BC_MSK_SYNC);
1639
1640                 if (status & VID_BC_MSK_OF)
1641                         dprintk(7, " (VID_BC_MSK_OF      0x%08x)\n",
1642                                 VID_BC_MSK_OF);
1643
1644                 printk(KERN_ERR "%s: mpeg risc op code error\n", dev->name);
1645
1646                 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1647                 cx23885_sram_channel_dump(dev,
1648                         &dev->sram_channels[port->sram_chno]);
1649
1650         } else if (status & VID_BC_MSK_RISCI1) {
1651
1652                 dprintk(7, " (RISCI1            0x%08x)\n", VID_BC_MSK_RISCI1);
1653
1654                 spin_lock(&port->slock);
1655                 count = cx_read(port->reg_gpcnt);
1656                 cx23885_wakeup(port, &port->mpegq, count);
1657                 spin_unlock(&port->slock);
1658
1659         }
1660         if (status) {
1661                 cx_write(port->reg_ts_int_stat, status);
1662                 handled = 1;
1663         }
1664
1665         return handled;
1666 }
1667
1668 static irqreturn_t cx23885_irq(int irq, void *dev_id)
1669 {
1670         struct cx23885_dev *dev = dev_id;
1671         struct cx23885_tsport *ts1 = &dev->ts1;
1672         struct cx23885_tsport *ts2 = &dev->ts2;
1673         u32 pci_status, pci_mask;
1674         u32 vida_status, vida_mask;
1675         u32 audint_status, audint_mask;
1676         u32 ts1_status, ts1_mask;
1677         u32 ts2_status, ts2_mask;
1678         int vida_count = 0, ts1_count = 0, ts2_count = 0, handled = 0;
1679         int audint_count = 0;
1680         bool subdev_handled;
1681
1682         pci_status = cx_read(PCI_INT_STAT);
1683         pci_mask = cx23885_irq_get_mask(dev);
1684         vida_status = cx_read(VID_A_INT_STAT);
1685         vida_mask = cx_read(VID_A_INT_MSK);
1686         audint_status = cx_read(AUDIO_INT_INT_STAT);
1687         audint_mask = cx_read(AUDIO_INT_INT_MSK);
1688         ts1_status = cx_read(VID_B_INT_STAT);
1689         ts1_mask = cx_read(VID_B_INT_MSK);
1690         ts2_status = cx_read(VID_C_INT_STAT);
1691         ts2_mask = cx_read(VID_C_INT_MSK);
1692
1693         if ((pci_status == 0) && (ts2_status == 0) && (ts1_status == 0))
1694                 goto out;
1695
1696         vida_count = cx_read(VID_A_GPCNT);
1697         audint_count = cx_read(AUD_INT_A_GPCNT);
1698         ts1_count = cx_read(ts1->reg_gpcnt);
1699         ts2_count = cx_read(ts2->reg_gpcnt);
1700         dprintk(7, "pci_status: 0x%08x  pci_mask: 0x%08x\n",
1701                 pci_status, pci_mask);
1702         dprintk(7, "vida_status: 0x%08x vida_mask: 0x%08x count: 0x%x\n",
1703                 vida_status, vida_mask, vida_count);
1704         dprintk(7, "audint_status: 0x%08x audint_mask: 0x%08x count: 0x%x\n",
1705                 audint_status, audint_mask, audint_count);
1706         dprintk(7, "ts1_status: 0x%08x  ts1_mask: 0x%08x count: 0x%x\n",
1707                 ts1_status, ts1_mask, ts1_count);
1708         dprintk(7, "ts2_status: 0x%08x  ts2_mask: 0x%08x count: 0x%x\n",
1709                 ts2_status, ts2_mask, ts2_count);
1710
1711         if (pci_status & (PCI_MSK_RISC_RD | PCI_MSK_RISC_WR |
1712                           PCI_MSK_AL_RD   | PCI_MSK_AL_WR   | PCI_MSK_APB_DMA |
1713                           PCI_MSK_VID_C   | PCI_MSK_VID_B   | PCI_MSK_VID_A   |
1714                           PCI_MSK_AUD_INT | PCI_MSK_AUD_EXT |
1715                           PCI_MSK_GPIO0   | PCI_MSK_GPIO1   |
1716                           PCI_MSK_AV_CORE | PCI_MSK_IR)) {
1717
1718                 if (pci_status & PCI_MSK_RISC_RD)
1719                         dprintk(7, " (PCI_MSK_RISC_RD   0x%08x)\n",
1720                                 PCI_MSK_RISC_RD);
1721
1722                 if (pci_status & PCI_MSK_RISC_WR)
1723                         dprintk(7, " (PCI_MSK_RISC_WR   0x%08x)\n",
1724                                 PCI_MSK_RISC_WR);
1725
1726                 if (pci_status & PCI_MSK_AL_RD)
1727                         dprintk(7, " (PCI_MSK_AL_RD     0x%08x)\n",
1728                                 PCI_MSK_AL_RD);
1729
1730                 if (pci_status & PCI_MSK_AL_WR)
1731                         dprintk(7, " (PCI_MSK_AL_WR     0x%08x)\n",
1732                                 PCI_MSK_AL_WR);
1733
1734                 if (pci_status & PCI_MSK_APB_DMA)
1735                         dprintk(7, " (PCI_MSK_APB_DMA   0x%08x)\n",
1736                                 PCI_MSK_APB_DMA);
1737
1738                 if (pci_status & PCI_MSK_VID_C)
1739                         dprintk(7, " (PCI_MSK_VID_C     0x%08x)\n",
1740                                 PCI_MSK_VID_C);
1741
1742                 if (pci_status & PCI_MSK_VID_B)
1743                         dprintk(7, " (PCI_MSK_VID_B     0x%08x)\n",
1744                                 PCI_MSK_VID_B);
1745
1746                 if (pci_status & PCI_MSK_VID_A)
1747                         dprintk(7, " (PCI_MSK_VID_A     0x%08x)\n",
1748                                 PCI_MSK_VID_A);
1749
1750                 if (pci_status & PCI_MSK_AUD_INT)
1751                         dprintk(7, " (PCI_MSK_AUD_INT   0x%08x)\n",
1752                                 PCI_MSK_AUD_INT);
1753
1754                 if (pci_status & PCI_MSK_AUD_EXT)
1755                         dprintk(7, " (PCI_MSK_AUD_EXT   0x%08x)\n",
1756                                 PCI_MSK_AUD_EXT);
1757
1758                 if (pci_status & PCI_MSK_GPIO0)
1759                         dprintk(7, " (PCI_MSK_GPIO0     0x%08x)\n",
1760                                 PCI_MSK_GPIO0);
1761
1762                 if (pci_status & PCI_MSK_GPIO1)
1763                         dprintk(7, " (PCI_MSK_GPIO1     0x%08x)\n",
1764                                 PCI_MSK_GPIO1);
1765
1766                 if (pci_status & PCI_MSK_AV_CORE)
1767                         dprintk(7, " (PCI_MSK_AV_CORE   0x%08x)\n",
1768                                 PCI_MSK_AV_CORE);
1769
1770                 if (pci_status & PCI_MSK_IR)
1771                         dprintk(7, " (PCI_MSK_IR        0x%08x)\n",
1772                                 PCI_MSK_IR);
1773         }
1774
1775         if (cx23885_boards[dev->board].ci_type == 1 &&
1776                         (pci_status & (PCI_MSK_GPIO1 | PCI_MSK_GPIO0)))
1777                 handled += netup_ci_slot_status(dev, pci_status);
1778
1779         if (cx23885_boards[dev->board].ci_type == 2 &&
1780                         (pci_status & PCI_MSK_GPIO0))
1781                 handled += altera_ci_irq(dev);
1782
1783         if (ts1_status) {
1784                 if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB)
1785                         handled += cx23885_irq_ts(ts1, ts1_status);
1786                 else
1787                 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1788                         handled += cx23885_irq_417(dev, ts1_status);
1789         }
1790
1791         if (ts2_status) {
1792                 if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB)
1793                         handled += cx23885_irq_ts(ts2, ts2_status);
1794                 else
1795                 if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER)
1796                         handled += cx23885_irq_417(dev, ts2_status);
1797         }
1798
1799         if (vida_status)
1800                 handled += cx23885_video_irq(dev, vida_status);
1801
1802         if (audint_status)
1803                 handled += cx23885_audio_irq(dev, audint_status, audint_mask);
1804
1805         if (pci_status & PCI_MSK_IR) {
1806                 subdev_handled = false;
1807                 v4l2_subdev_call(dev->sd_ir, core, interrupt_service_routine,
1808                                  pci_status, &subdev_handled);
1809                 if (subdev_handled)
1810                         handled++;
1811         }
1812
1813         if ((pci_status & pci_mask) & PCI_MSK_AV_CORE) {
1814                 cx23885_irq_disable(dev, PCI_MSK_AV_CORE);
1815                 schedule_work(&dev->cx25840_work);
1816                 handled++;
1817         }
1818
1819         if (handled)
1820                 cx_write(PCI_INT_STAT, pci_status);
1821 out:
1822         return IRQ_RETVAL(handled);
1823 }
1824
1825 static void cx23885_v4l2_dev_notify(struct v4l2_subdev *sd,
1826                                     unsigned int notification, void *arg)
1827 {
1828         struct cx23885_dev *dev;
1829
1830         if (sd == NULL)
1831                 return;
1832
1833         dev = to_cx23885(sd->v4l2_dev);
1834
1835         switch (notification) {
1836         case V4L2_SUBDEV_IR_RX_NOTIFY: /* Possibly called in an IRQ context */
1837                 if (sd == dev->sd_ir)
1838                         cx23885_ir_rx_v4l2_dev_notify(sd, *(u32 *)arg);
1839                 break;
1840         case V4L2_SUBDEV_IR_TX_NOTIFY: /* Possibly called in an IRQ context */
1841                 if (sd == dev->sd_ir)
1842                         cx23885_ir_tx_v4l2_dev_notify(sd, *(u32 *)arg);
1843                 break;
1844         }
1845 }
1846
1847 static void cx23885_v4l2_dev_notify_init(struct cx23885_dev *dev)
1848 {
1849         INIT_WORK(&dev->cx25840_work, cx23885_av_work_handler);
1850         INIT_WORK(&dev->ir_rx_work, cx23885_ir_rx_work_handler);
1851         INIT_WORK(&dev->ir_tx_work, cx23885_ir_tx_work_handler);
1852         dev->v4l2_dev.notify = cx23885_v4l2_dev_notify;
1853 }
1854
1855 static inline int encoder_on_portb(struct cx23885_dev *dev)
1856 {
1857         return cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER;
1858 }
1859
1860 static inline int encoder_on_portc(struct cx23885_dev *dev)
1861 {
1862         return cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER;
1863 }
1864
1865 /* Mask represents 32 different GPIOs, GPIO's are split into multiple
1866  * registers depending on the board configuration (and whether the
1867  * 417 encoder (wi it's own GPIO's) are present. Each GPIO bit will
1868  * be pushed into the correct hardware register, regardless of the
1869  * physical location. Certain registers are shared so we sanity check
1870  * and report errors if we think we're tampering with a GPIo that might
1871  * be assigned to the encoder (and used for the host bus).
1872  *
1873  * GPIO  2 thru  0 - On the cx23885 bridge
1874  * GPIO 18 thru  3 - On the cx23417 host bus interface
1875  * GPIO 23 thru 19 - On the cx25840 a/v core
1876  */
1877 void cx23885_gpio_set(struct cx23885_dev *dev, u32 mask)
1878 {
1879         if (mask & 0x7)
1880                 cx_set(GP0_IO, mask & 0x7);
1881
1882         if (mask & 0x0007fff8) {
1883                 if (encoder_on_portb(dev) || encoder_on_portc(dev))
1884                         printk(KERN_ERR
1885                                 "%s: Setting GPIO on encoder ports\n",
1886                                 dev->name);
1887                 cx_set(MC417_RWD, (mask & 0x0007fff8) >> 3);
1888         }
1889
1890         /* TODO: 23-19 */
1891         if (mask & 0x00f80000)
1892                 printk(KERN_INFO "%s: Unsupported\n", dev->name);
1893 }
1894
1895 void cx23885_gpio_clear(struct cx23885_dev *dev, u32 mask)
1896 {
1897         if (mask & 0x00000007)
1898                 cx_clear(GP0_IO, mask & 0x7);
1899
1900         if (mask & 0x0007fff8) {
1901                 if (encoder_on_portb(dev) || encoder_on_portc(dev))
1902                         printk(KERN_ERR
1903                                 "%s: Clearing GPIO moving on encoder ports\n",
1904                                 dev->name);
1905                 cx_clear(MC417_RWD, (mask & 0x7fff8) >> 3);
1906         }
1907
1908         /* TODO: 23-19 */
1909         if (mask & 0x00f80000)
1910                 printk(KERN_INFO "%s: Unsupported\n", dev->name);
1911 }
1912
1913 u32 cx23885_gpio_get(struct cx23885_dev *dev, u32 mask)
1914 {
1915         if (mask & 0x00000007)
1916                 return (cx_read(GP0_IO) >> 8) & mask & 0x7;
1917
1918         if (mask & 0x0007fff8) {
1919                 if (encoder_on_portb(dev) || encoder_on_portc(dev))
1920                         printk(KERN_ERR
1921                                 "%s: Reading GPIO moving on encoder ports\n",
1922                                 dev->name);
1923                 return (cx_read(MC417_RWD) & ((mask & 0x7fff8) >> 3)) << 3;
1924         }
1925
1926         /* TODO: 23-19 */
1927         if (mask & 0x00f80000)
1928                 printk(KERN_INFO "%s: Unsupported\n", dev->name);
1929
1930         return 0;
1931 }
1932
1933 void cx23885_gpio_enable(struct cx23885_dev *dev, u32 mask, int asoutput)
1934 {
1935         if ((mask & 0x00000007) && asoutput)
1936                 cx_set(GP0_IO, (mask & 0x7) << 16);
1937         else if ((mask & 0x00000007) && !asoutput)
1938                 cx_clear(GP0_IO, (mask & 0x7) << 16);
1939
1940         if (mask & 0x0007fff8) {
1941                 if (encoder_on_portb(dev) || encoder_on_portc(dev))
1942                         printk(KERN_ERR
1943                                 "%s: Enabling GPIO on encoder ports\n",
1944                                 dev->name);
1945         }
1946
1947         /* MC417_OEN is active low for output, write 1 for an input */
1948         if ((mask & 0x0007fff8) && asoutput)
1949                 cx_clear(MC417_OEN, (mask & 0x7fff8) >> 3);
1950
1951         else if ((mask & 0x0007fff8) && !asoutput)
1952                 cx_set(MC417_OEN, (mask & 0x7fff8) >> 3);
1953
1954         /* TODO: 23-19 */
1955 }
1956
1957 static int cx23885_initdev(struct pci_dev *pci_dev,
1958                            const struct pci_device_id *pci_id)
1959 {
1960         struct cx23885_dev *dev;
1961         struct v4l2_ctrl_handler *hdl;
1962         int err;
1963
1964         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1965         if (NULL == dev)
1966                 return -ENOMEM;
1967
1968         err = v4l2_device_register(&pci_dev->dev, &dev->v4l2_dev);
1969         if (err < 0)
1970                 goto fail_free;
1971
1972         hdl = &dev->ctrl_handler;
1973         v4l2_ctrl_handler_init(hdl, 6);
1974         if (hdl->error) {
1975                 err = hdl->error;
1976                 goto fail_ctrl;
1977         }
1978         dev->v4l2_dev.ctrl_handler = hdl;
1979
1980         /* Prepare to handle notifications from subdevices */
1981         cx23885_v4l2_dev_notify_init(dev);
1982
1983         /* pci init */
1984         dev->pci = pci_dev;
1985         if (pci_enable_device(pci_dev)) {
1986                 err = -EIO;
1987                 goto fail_ctrl;
1988         }
1989
1990         if (cx23885_dev_setup(dev) < 0) {
1991                 err = -EINVAL;
1992                 goto fail_ctrl;
1993         }
1994
1995         /* print pci info */
1996         dev->pci_rev = pci_dev->revision;
1997         pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER,  &dev->pci_lat);
1998         printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, "
1999                "latency: %d, mmio: 0x%llx\n", dev->name,
2000                pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
2001                dev->pci_lat,
2002                 (unsigned long long)pci_resource_start(pci_dev, 0));
2003
2004         pci_set_master(pci_dev);
2005         err = pci_set_dma_mask(pci_dev, 0xffffffff);
2006         if (err) {
2007                 printk("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name);
2008                 goto fail_ctrl;
2009         }
2010
2011         err = request_irq(pci_dev->irq, cx23885_irq,
2012                           IRQF_SHARED, dev->name, dev);
2013         if (err < 0) {
2014                 printk(KERN_ERR "%s: can't get IRQ %d\n",
2015                        dev->name, pci_dev->irq);
2016                 goto fail_irq;
2017         }
2018
2019         switch (dev->board) {
2020         case CX23885_BOARD_NETUP_DUAL_DVBS2_CI:
2021                 cx23885_irq_add_enable(dev, PCI_MSK_GPIO1 | PCI_MSK_GPIO0);
2022                 break;
2023         case CX23885_BOARD_NETUP_DUAL_DVB_T_C_CI_RF:
2024                 cx23885_irq_add_enable(dev, PCI_MSK_GPIO0);
2025                 break;
2026         }
2027
2028         /*
2029          * The CX2388[58] IR controller can start firing interrupts when
2030          * enabled, so these have to take place after the cx23885_irq() handler
2031          * is hooked up by the call to request_irq() above.
2032          */
2033         cx23885_ir_pci_int_enable(dev);
2034         cx23885_input_init(dev);
2035
2036         return 0;
2037
2038 fail_irq:
2039         cx23885_dev_unregister(dev);
2040 fail_ctrl:
2041         v4l2_ctrl_handler_free(hdl);
2042         v4l2_device_unregister(&dev->v4l2_dev);
2043 fail_free:
2044         kfree(dev);
2045         return err;
2046 }
2047
2048 static void cx23885_finidev(struct pci_dev *pci_dev)
2049 {
2050         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
2051         struct cx23885_dev *dev = to_cx23885(v4l2_dev);
2052
2053         cx23885_input_fini(dev);
2054         cx23885_ir_fini(dev);
2055
2056         cx23885_shutdown(dev);
2057
2058         /* unregister stuff */
2059         free_irq(pci_dev->irq, dev);
2060
2061         pci_disable_device(pci_dev);
2062
2063         cx23885_dev_unregister(dev);
2064         v4l2_ctrl_handler_free(&dev->ctrl_handler);
2065         v4l2_device_unregister(v4l2_dev);
2066         kfree(dev);
2067 }
2068
2069 static struct pci_device_id cx23885_pci_tbl[] = {
2070         {
2071                 /* CX23885 */
2072                 .vendor       = 0x14f1,
2073                 .device       = 0x8852,
2074                 .subvendor    = PCI_ANY_ID,
2075                 .subdevice    = PCI_ANY_ID,
2076         }, {
2077                 /* CX23887 Rev 2 */
2078                 .vendor       = 0x14f1,
2079                 .device       = 0x8880,
2080                 .subvendor    = PCI_ANY_ID,
2081                 .subdevice    = PCI_ANY_ID,
2082         }, {
2083                 /* --- end of list --- */
2084         }
2085 };
2086 MODULE_DEVICE_TABLE(pci, cx23885_pci_tbl);
2087
2088 static struct pci_driver cx23885_pci_driver = {
2089         .name     = "cx23885",
2090         .id_table = cx23885_pci_tbl,
2091         .probe    = cx23885_initdev,
2092         .remove   = cx23885_finidev,
2093         /* TODO */
2094         .suspend  = NULL,
2095         .resume   = NULL,
2096 };
2097
2098 static int __init cx23885_init(void)
2099 {
2100         printk(KERN_INFO "cx23885 driver version %s loaded\n",
2101                 CX23885_VERSION);
2102         return pci_register_driver(&cx23885_pci_driver);
2103 }
2104
2105 static void __exit cx23885_fini(void)
2106 {
2107         pci_unregister_driver(&cx23885_pci_driver);
2108 }
2109
2110 module_init(cx23885_init);
2111 module_exit(cx23885_fini);