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

   1 /*
   2  *
   3  * device driver for Conexant 2388x based TV cards
   4  * driver core
   5  *
   6  * (c) 2003 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
   7  *
   8  * (c) 2005-2006 Mauro Carvalho Chehab <mchehab@infradead.org>
   9  *     - Multituner support
  10  *     - video_ioctl2 conversion
  11  *     - PAL/M fixes
  12  *
  13  *  This program is free software; you can redistribute it and/or modify
  14  *  it under the terms of the GNU General Public License as published by
  15  *  the Free Software Foundation; either version 2 of the License, or
  16  *  (at your option) any later version.
  17  *
  18  *  This program is distributed in the hope that it will be useful,
  19  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *  GNU General Public License for more details.
  22  *
  23  *  You should have received a copy of the GNU General Public License
  24  *  along with this program; if not, write to the Free Software
  25  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  */
  27
  28 #include <linux/init.h>
  29 #include <linux/list.h>
  30 #include <linux/module.h>
  31 #include <linux/kernel.h>
  32 #include <linux/slab.h>
  33 #include <linux/kmod.h>
  34 #include <linux/sound.h>
  35 #include <linux/interrupt.h>
  36 #include <linux/pci.h>
  37 #include <linux/delay.h>
  38 #include <linux/videodev2.h>
  39 #include <linux/mutex.h>
  40
  41 #include "cx88.h"
  42 #include <media/v4l2-common.h>
  43 #include <media/v4l2-ioctl.h>
  44
  45 MODULE_DESCRIPTION("v4l2 driver module for cx2388x based TV cards");
  46 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
  47 MODULE_LICENSE("GPL");
  48
  49 /* ------------------------------------------------------------------ */
  50
  51 static unsigned int core_debug;
  52 module_param(core_debug,int,0644);
  53 MODULE_PARM_DESC(core_debug,"enable debug messages [core]");
  54
  55 static unsigned int nicam;
  56 module_param(nicam,int,0644);
  57 MODULE_PARM_DESC(nicam,"tv audio is nicam");
  58
  59 static unsigned int nocomb;
  60 module_param(nocomb,int,0644);
  61 MODULE_PARM_DESC(nocomb,"disable comb filter");
  62
  63 #define dprintk(level,fmt, arg...)      if (core_debug >= level)        \
  64         printk(KERN_DEBUG "%s: " fmt, core->name , ## arg)
  65
  66 static unsigned int cx88_devcount;
  67 static LIST_HEAD(cx88_devlist);
  68 static DEFINE_MUTEX(devlist);
  69
  70 #define NO_SYNC_LINE (-1U)
  71
  72 /* @lpi: lines per IRQ, or 0 to not generate irqs. Note: IRQ to be
  73          generated _after_ lpi lines are transferred. */
  74 static __le32* cx88_risc_field(__le32 *rp, struct scatterlist *sglist,
  75                             unsigned int offset, u32 sync_line,
  76                             unsigned int bpl, unsigned int padding,
  77                             unsigned int lines, unsigned int lpi)
  78 {
  79         struct scatterlist *sg;
  80         unsigned int line,todo,sol;
  81
  82         /* sync instruction */
  83         if (sync_line != NO_SYNC_LINE)
  84                 *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
  85
  86         /* scan lines */
  87         sg = sglist;
  88         for (line = 0; line < lines; line++) {
  89                 while (offset && offset >= sg_dma_len(sg)) {
  90                         offset -= sg_dma_len(sg);
  91                         sg++;
  92                 }
  93                 if (lpi && line>0 && !(line % lpi))
  94                         sol = RISC_SOL | RISC_IRQ1 | RISC_CNT_INC;
  95                 else
  96                         sol = RISC_SOL;
  97                 if (bpl <= sg_dma_len(sg)-offset) {
  98                         /* fits into current chunk */
  99                         *(rp++)=cpu_to_le32(RISC_WRITE|sol|RISC_EOL|bpl);
 100                         *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset);
 101                         offset+=bpl;
 102                 } else {
 103                         /* scanline needs to be split */
 104                         todo = bpl;
 105                         *(rp++)=cpu_to_le32(RISC_WRITE|sol|
 106                                             (sg_dma_len(sg)-offset));
 107                         *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset);
 108                         todo -= (sg_dma_len(sg)-offset);
 109                         offset = 0;
 110                         sg++;
 111                         while (todo > sg_dma_len(sg)) {
 112                                 *(rp++)=cpu_to_le32(RISC_WRITE|
 113                                                     sg_dma_len(sg));
 114                                 *(rp++)=cpu_to_le32(sg_dma_address(sg));
 115                                 todo -= sg_dma_len(sg);
 116                                 sg++;
 117                         }
 118                         *(rp++)=cpu_to_le32(RISC_WRITE|RISC_EOL|todo);
 119                         *(rp++)=cpu_to_le32(sg_dma_address(sg));
 120                         offset += todo;
 121                 }
 122                 offset += padding;
 123         }
 124
 125         return rp;
 126 }
 127
 128 int cx88_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
 129                      struct scatterlist *sglist,
 130                      unsigned int top_offset, unsigned int bottom_offset,
 131                      unsigned int bpl, unsigned int padding, unsigned int lines)
 132 {
 133         u32 instructions,fields;
 134         __le32 *rp;
 135         int rc;
 136
 137         fields = 0;
 138         if (UNSET != top_offset)
 139                 fields++;
 140         if (UNSET != bottom_offset)
 141                 fields++;
 142
 143         /* estimate risc mem: worst case is one write per page border +
 144            one write per scan line + syncs + jump (all 2 dwords).  Padding
 145            can cause next bpl to start close to a page border.  First DMA
 146            region may be smaller than PAGE_SIZE */
 147         instructions  = fields * (1 + ((bpl + padding) * lines) / PAGE_SIZE + lines);
 148         instructions += 2;
 149         if ((rc = btcx_riscmem_alloc(pci,risc,instructions*8)) < 0)
 150                 return rc;
 151
 152         /* write risc instructions */
 153         rp = risc->cpu;
 154         if (UNSET != top_offset)
 155                 rp = cx88_risc_field(rp, sglist, top_offset, 0,
 156                                      bpl, padding, lines, 0);
 157         if (UNSET != bottom_offset)
 158                 rp = cx88_risc_field(rp, sglist, bottom_offset, 0x200,
 159                                      bpl, padding, lines, 0);
 160
 161         /* save pointer to jmp instruction address */
 162         risc->jmp = rp;
 163         BUG_ON((risc->jmp - risc->cpu + 2) * sizeof (*risc->cpu) > risc->size);
 164         return 0;
 165 }
 166
 167 int cx88_risc_databuffer(struct pci_dev *pci, struct btcx_riscmem *risc,
 168                          struct scatterlist *sglist, unsigned int bpl,
 169                          unsigned int lines, unsigned int lpi)
 170 {
 171         u32 instructions;
 172         __le32 *rp;
 173         int rc;
 174
 175         /* estimate risc mem: worst case is one write per page border +
 176            one write per scan line + syncs + jump (all 2 dwords).  Here
 177            there is no padding and no sync.  First DMA region may be smaller
 178            than PAGE_SIZE */
 179         instructions  = 1 + (bpl * lines) / PAGE_SIZE + lines;
 180         instructions += 1;
 181         if ((rc = btcx_riscmem_alloc(pci,risc,instructions*8)) < 0)
 182                 return rc;
 183
 184         /* write risc instructions */
 185         rp = risc->cpu;
 186         rp = cx88_risc_field(rp, sglist, 0, NO_SYNC_LINE, bpl, 0, lines, lpi);
 187
 188         /* save pointer to jmp instruction address */
 189         risc->jmp = rp;
 190         BUG_ON((risc->jmp - risc->cpu + 2) * sizeof (*risc->cpu) > risc->size);
 191         return 0;
 192 }
 193
 194 int cx88_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
 195                       u32 reg, u32 mask, u32 value)
 196 {
 197         __le32 *rp;
 198         int rc;
 199
 200         if ((rc = btcx_riscmem_alloc(pci, risc, 4*16)) < 0)
 201                 return rc;
 202
 203         /* write risc instructions */
 204         rp = risc->cpu;
 205         *(rp++) = cpu_to_le32(RISC_WRITECR  | RISC_IRQ2 | RISC_IMM);
 206         *(rp++) = cpu_to_le32(reg);
 207         *(rp++) = cpu_to_le32(value);
 208         *(rp++) = cpu_to_le32(mask);
 209         *(rp++) = cpu_to_le32(RISC_JUMP);
 210         *(rp++) = cpu_to_le32(risc->dma);
 211         return 0;
 212 }
 213
 214 void
 215 cx88_free_buffer(struct videobuf_queue *q, struct cx88_buffer *buf)
 216 {
 217         struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
 218
 219         BUG_ON(in_interrupt());
 220         videobuf_waiton(&buf->vb,0,0);
 221         videobuf_dma_unmap(q, dma);
 222         videobuf_dma_free(dma);
 223         btcx_riscmem_free(to_pci_dev(q->dev), &buf->risc);
 224         buf->vb.state = VIDEOBUF_NEEDS_INIT;
 225 }
 226
 227 /* ------------------------------------------------------------------ */
 228 /* our SRAM memory layout                                             */
 229
 230 /* we are going to put all thr risc programs into host memory, so we
 231  * can use the whole SDRAM for the DMA fifos.  To simplify things, we
 232  * use a static memory layout.  That surely will waste memory in case
 233  * we don't use all DMA channels at the same time (which will be the
 234  * case most of the time).  But that still gives us enougth FIFO space
 235  * to be able to deal with insane long pci latencies ...
 236  *
 237  * FIFO space allocations:
 238  *    channel  21    (y video)  - 10.0k
 239  *    channel  22    (u video)  -  2.0k
 240  *    channel  23    (v video)  -  2.0k
 241  *    channel  24    (vbi)      -  4.0k
 242  *    channels 25+26 (audio)    -  4.0k
 243  *    channel  28    (mpeg)     -  4.0k
 244  *    TOTAL                     = 29.0k
 245  *
 246  * Every channel has 160 bytes control data (64 bytes instruction
 247  * queue and 6 CDT entries), which is close to 2k total.
 248  *
 249  * Address layout:
 250  *    0x0000 - 0x03ff    CMDs / reserved
 251  *    0x0400 - 0x0bff    instruction queues + CDs
 252  *    0x0c00 -           FIFOs
 253  */
 254
 255 struct sram_channel cx88_sram_channels[] = {
 256         [SRAM_CH21] = {
 257                 .name       = "video y / packed",
 258                 .cmds_start = 0x180040,
 259                 .ctrl_start = 0x180400,
 260                 .cdt        = 0x180400 + 64,
 261                 .fifo_start = 0x180c00,
 262                 .fifo_size  = 0x002800,
 263                 .ptr1_reg   = MO_DMA21_PTR1,
 264                 .ptr2_reg   = MO_DMA21_PTR2,
 265                 .cnt1_reg   = MO_DMA21_CNT1,
 266                 .cnt2_reg   = MO_DMA21_CNT2,
 267         },
 268         [SRAM_CH22] = {
 269                 .name       = "video u",
 270                 .cmds_start = 0x180080,
 271                 .ctrl_start = 0x1804a0,
 272                 .cdt        = 0x1804a0 + 64,
 273                 .fifo_start = 0x183400,
 274                 .fifo_size  = 0x000800,
 275                 .ptr1_reg   = MO_DMA22_PTR1,
 276                 .ptr2_reg   = MO_DMA22_PTR2,
 277                 .cnt1_reg   = MO_DMA22_CNT1,
 278                 .cnt2_reg   = MO_DMA22_CNT2,
 279         },
 280         [SRAM_CH23] = {
 281                 .name       = "video v",
 282                 .cmds_start = 0x1800c0,
 283                 .ctrl_start = 0x180540,
 284                 .cdt        = 0x180540 + 64,
 285                 .fifo_start = 0x183c00,
 286                 .fifo_size  = 0x000800,
 287                 .ptr1_reg   = MO_DMA23_PTR1,
 288                 .ptr2_reg   = MO_DMA23_PTR2,
 289                 .cnt1_reg   = MO_DMA23_CNT1,
 290                 .cnt2_reg   = MO_DMA23_CNT2,
 291         },
 292         [SRAM_CH24] = {
 293                 .name       = "vbi",
 294                 .cmds_start = 0x180100,
 295                 .ctrl_start = 0x1805e0,
 296                 .cdt        = 0x1805e0 + 64,
 297                 .fifo_start = 0x184400,
 298                 .fifo_size  = 0x001000,
 299                 .ptr1_reg   = MO_DMA24_PTR1,
 300                 .ptr2_reg   = MO_DMA24_PTR2,
 301                 .cnt1_reg   = MO_DMA24_CNT1,
 302                 .cnt2_reg   = MO_DMA24_CNT2,
 303         },
 304         [SRAM_CH25] = {
 305                 .name       = "audio from",
 306                 .cmds_start = 0x180140,
 307                 .ctrl_start = 0x180680,
 308                 .cdt        = 0x180680 + 64,
 309                 .fifo_start = 0x185400,
 310                 .fifo_size  = 0x001000,
 311                 .ptr1_reg   = MO_DMA25_PTR1,
 312                 .ptr2_reg   = MO_DMA25_PTR2,
 313                 .cnt1_reg   = MO_DMA25_CNT1,
 314                 .cnt2_reg   = MO_DMA25_CNT2,
 315         },
 316         [SRAM_CH26] = {
 317                 .name       = "audio to",
 318                 .cmds_start = 0x180180,
 319                 .ctrl_start = 0x180720,
 320                 .cdt        = 0x180680 + 64,  /* same as audio IN */
 321                 .fifo_start = 0x185400,       /* same as audio IN */
 322                 .fifo_size  = 0x001000,       /* same as audio IN */
 323                 .ptr1_reg   = MO_DMA26_PTR1,
 324                 .ptr2_reg   = MO_DMA26_PTR2,
 325                 .cnt1_reg   = MO_DMA26_CNT1,
 326                 .cnt2_reg   = MO_DMA26_CNT2,
 327         },
 328         [SRAM_CH28] = {
 329                 .name       = "mpeg",
 330                 .cmds_start = 0x180200,
 331                 .ctrl_start = 0x1807C0,
 332                 .cdt        = 0x1807C0 + 64,
 333                 .fifo_start = 0x186400,
 334                 .fifo_size  = 0x001000,
 335                 .ptr1_reg   = MO_DMA28_PTR1,
 336                 .ptr2_reg   = MO_DMA28_PTR2,
 337                 .cnt1_reg   = MO_DMA28_CNT1,
 338                 .cnt2_reg   = MO_DMA28_CNT2,
 339         },
 340 };
 341
 342 int cx88_sram_channel_setup(struct cx88_core *core,
 343                             struct sram_channel *ch,
 344                             unsigned int bpl, u32 risc)
 345 {
 346         unsigned int i,lines;
 347         u32 cdt;
 348
 349         bpl   = (bpl + 7) & ~7; /* alignment */
 350         cdt   = ch->cdt;
 351         lines = ch->fifo_size / bpl;
 352         if (lines > 6)
 353                 lines = 6;
 354         BUG_ON(lines < 2);
 355
 356         /* write CDT */
 357         for (i = 0; i < lines; i++)
 358                 cx_write(cdt + 16*i, ch->fifo_start + bpl*i);
 359
 360         /* write CMDS */
 361         cx_write(ch->cmds_start +  0, risc);
 362         cx_write(ch->cmds_start +  4, cdt);
 363         cx_write(ch->cmds_start +  8, (lines*16) >> 3);
 364         cx_write(ch->cmds_start + 12, ch->ctrl_start);
 365         cx_write(ch->cmds_start + 16, 64 >> 2);
 366         for (i = 20; i < 64; i += 4)
 367                 cx_write(ch->cmds_start + i, 0);
 368
 369         /* fill registers */
 370         cx_write(ch->ptr1_reg, ch->fifo_start);
 371         cx_write(ch->ptr2_reg, cdt);
 372         cx_write(ch->cnt1_reg, (bpl >> 3) -1);
 373         cx_write(ch->cnt2_reg, (lines*16) >> 3);
 374
 375         dprintk(2,"sram setup %s: bpl=%d lines=%d\n", ch->name, bpl, lines);
 376         return 0;
 377 }
 378
 379 /* ------------------------------------------------------------------ */
 380 /* debug helper code                                                  */
 381
 382 static int cx88_risc_decode(u32 risc)
 383 {
 384         static char *instr[16] = {
 385                 [ RISC_SYNC    >> 28 ] = "sync",
 386                 [ RISC_WRITE   >> 28 ] = "write",
 387                 [ RISC_WRITEC  >> 28 ] = "writec",
 388                 [ RISC_READ    >> 28 ] = "read",
 389                 [ RISC_READC   >> 28 ] = "readc",
 390                 [ RISC_JUMP    >> 28 ] = "jump",
 391                 [ RISC_SKIP    >> 28 ] = "skip",
 392                 [ RISC_WRITERM >> 28 ] = "writerm",
 393                 [ RISC_WRITECM >> 28 ] = "writecm",
 394                 [ RISC_WRITECR >> 28 ] = "writecr",
 395         };
 396         static int incr[16] = {
 397                 [ RISC_WRITE   >> 28 ] = 2,
 398                 [ RISC_JUMP    >> 28 ] = 2,
 399                 [ RISC_WRITERM >> 28 ] = 3,
 400                 [ RISC_WRITECM >> 28 ] = 3,
 401                 [ RISC_WRITECR >> 28 ] = 4,
 402         };
 403         static char *bits[] = {
 404                 "12",   "13",   "14",   "resync",
 405                 "cnt0", "cnt1", "18",   "19",
 406                 "20",   "21",   "22",   "23",
 407                 "irq1", "irq2", "eol",  "sol",
 408         };
 409         int i;
 410
 411         printk("0x%08x [ %s", risc,
 412                instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
 413         for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
 414                 if (risc & (1 << (i + 12)))
 415                         printk(" %s",bits[i]);
 416         printk(" count=%d ]\n", risc & 0xfff);
 417         return incr[risc >> 28] ? incr[risc >> 28] : 1;
 418 }
 419
 420
 421 void cx88_sram_channel_dump(struct cx88_core *core,
 422                             struct sram_channel *ch)
 423 {
 424         static char *name[] = {
 425                 "initial risc",
 426                 "cdt base",
 427                 "cdt size",
 428                 "iq base",
 429                 "iq size",
 430                 "risc pc",
 431                 "iq wr ptr",
 432                 "iq rd ptr",
 433                 "cdt current",
 434                 "pci target",
 435                 "line / byte",
 436         };
 437         u32 risc;
 438         unsigned int i,j,n;
 439
 440         printk("%s: %s - dma channel status dump\n",
 441                core->name,ch->name);
 442         for (i = 0; i < ARRAY_SIZE(name); i++)
 443                 printk("%s:   cmds: %-12s: 0x%08x\n",
 444                        core->name,name[i],
 445                        cx_read(ch->cmds_start + 4*i));
 446         for (n = 1, i = 0; i < 4; i++) {
 447                 risc = cx_read(ch->cmds_start + 4 * (i+11));
 448                 printk("%s:   risc%d: ", core->name, i);
 449                 if (--n)
 450                         printk("0x%08x [ arg #%d ]\n", risc, n);
 451                 else
 452                         n = cx88_risc_decode(risc);
 453         }
 454         for (i = 0; i < 16; i += n) {
 455                 risc = cx_read(ch->ctrl_start + 4 * i);
 456                 printk("%s:   iq %x: ", core->name, i);
 457                 n = cx88_risc_decode(risc);
 458                 for (j = 1; j < n; j++) {
 459                         risc = cx_read(ch->ctrl_start + 4 * (i+j));
 460                         printk("%s:   iq %x: 0x%08x [ arg #%d ]\n",
 461                                core->name, i+j, risc, j);
 462                 }
 463         }
 464
 465         printk("%s: fifo: 0x%08x -> 0x%x\n",
 466                core->name, ch->fifo_start, ch->fifo_start+ch->fifo_size);
 467         printk("%s: ctrl: 0x%08x -> 0x%x\n",
 468                core->name, ch->ctrl_start, ch->ctrl_start+6*16);
 469         printk("%s:   ptr1_reg: 0x%08x\n",
 470                core->name,cx_read(ch->ptr1_reg));
 471         printk("%s:   ptr2_reg: 0x%08x\n",
 472                core->name,cx_read(ch->ptr2_reg));
 473         printk("%s:   cnt1_reg: 0x%08x\n",
 474                core->name,cx_read(ch->cnt1_reg));
 475         printk("%s:   cnt2_reg: 0x%08x\n",
 476                core->name,cx_read(ch->cnt2_reg));
 477 }
 478
 479 static char *cx88_pci_irqs[32] = {
 480         "vid", "aud", "ts", "vip", "hst", "5", "6", "tm1",
 481         "src_dma", "dst_dma", "risc_rd_err", "risc_wr_err",
 482         "brdg_err", "src_dma_err", "dst_dma_err", "ipb_dma_err",
 483         "i2c", "i2c_rack", "ir_smp", "gpio0", "gpio1"
 484 };
 485
 486 void cx88_print_irqbits(char *name, char *tag, char **strings,
 487                         int len, u32 bits, u32 mask)
 488 {
 489         unsigned int i;
 490
 491         printk(KERN_DEBUG "%s: %s [0x%x]", name, tag, bits);
 492         for (i = 0; i < len; i++) {
 493                 if (!(bits & (1 << i)))
 494                         continue;
 495                 if (strings[i])
 496                         printk(" %s", strings[i]);
 497                 else
 498                         printk(" %d", i);
 499                 if (!(mask & (1 << i)))
 500                         continue;
 501                 printk("*");
 502         }
 503         printk("\n");
 504 }
 505
 506 /* ------------------------------------------------------------------ */
 507
 508 int cx88_core_irq(struct cx88_core *core, u32 status)
 509 {
 510         int handled = 0;
 511
 512         if (status & PCI_INT_IR_SMPINT) {
 513                 cx88_ir_irq(core);
 514                 handled++;
 515         }
 516         if (!handled)
 517                 cx88_print_irqbits(core->name, "irq pci",
 518                                    cx88_pci_irqs, ARRAY_SIZE(cx88_pci_irqs),
 519                                    status, core->pci_irqmask);
 520         return handled;
 521 }
 522
 523 void cx88_wakeup(struct cx88_core *core,
 524                  struct cx88_dmaqueue *q, u32 count)
 525 {
 526         struct cx88_buffer *buf;
 527         int bc;
 528
 529         for (bc = 0;; bc++) {
 530                 if (list_empty(&q->active))
 531                         break;
 532                 buf = list_entry(q->active.next,
 533                                  struct cx88_buffer, vb.queue);
 534                 /* count comes from the hw and is is 16bit wide --
 535                  * this trick handles wrap-arounds correctly for
 536                  * up to 32767 buffers in flight... */
 537                 if ((s16) (count - buf->count) < 0)
 538                         break;
 539                 do_gettimeofday(&buf->vb.ts);
 540                 dprintk(2,"[%p/%d] wakeup reg=%d buf=%d\n",buf,buf->vb.i,
 541                         count, buf->count);
 542                 buf->vb.state = VIDEOBUF_DONE;
 543                 list_del(&buf->vb.queue);
 544                 wake_up(&buf->vb.done);
 545         }
 546         if (list_empty(&q->active)) {
 547                 del_timer(&q->timeout);
 548         } else {
 549                 mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 550         }
 551         if (bc != 1)
 552                 dprintk(2, "%s: %d buffers handled (should be 1)\n",
 553                         __func__, bc);
 554 }
 555
 556 void cx88_shutdown(struct cx88_core *core)
 557 {
 558         /* disable RISC controller + IRQs */
 559         cx_write(MO_DEV_CNTRL2, 0);
 560
 561         /* stop dma transfers */
 562         cx_write(MO_VID_DMACNTRL, 0x0);
 563         cx_write(MO_AUD_DMACNTRL, 0x0);
 564         cx_write(MO_TS_DMACNTRL, 0x0);
 565         cx_write(MO_VIP_DMACNTRL, 0x0);
 566         cx_write(MO_GPHST_DMACNTRL, 0x0);
 567
 568         /* stop interrupts */
 569         cx_write(MO_PCI_INTMSK, 0x0);
 570         cx_write(MO_VID_INTMSK, 0x0);
 571         cx_write(MO_AUD_INTMSK, 0x0);
 572         cx_write(MO_TS_INTMSK, 0x0);
 573         cx_write(MO_VIP_INTMSK, 0x0);
 574         cx_write(MO_GPHST_INTMSK, 0x0);
 575
 576         /* stop capturing */
 577         cx_write(VID_CAPTURE_CONTROL, 0);
 578 }
 579
 580 int cx88_reset(struct cx88_core *core)
 581 {
 582         dprintk(1,"%s\n",__func__);
 583         cx88_shutdown(core);
 584
 585         /* clear irq status */
 586         cx_write(MO_VID_INTSTAT, 0xFFFFFFFF); // Clear PIV int
 587         cx_write(MO_PCI_INTSTAT, 0xFFFFFFFF); // Clear PCI int
 588         cx_write(MO_INT1_STAT,   0xFFFFFFFF); // Clear RISC int
 589
 590         /* wait a bit */
 591         msleep(100);
 592
 593         /* init sram */
 594         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH21], 720*4, 0);
 595         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH22], 128, 0);
 596         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH23], 128, 0);
 597         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH24], 128, 0);
 598         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH25], 128, 0);
 599         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH26], 128, 0);
 600         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH28], 188*4, 0);
 601
 602         /* misc init ... */
 603         cx_write(MO_INPUT_FORMAT, ((1 << 13) |   // agc enable
 604                                    (1 << 12) |   // agc gain
 605                                    (1 << 11) |   // adaptibe agc
 606                                    (0 << 10) |   // chroma agc
 607                                    (0 <<  9) |   // ckillen
 608                                    (7)));
 609
 610         /* setup image format */
 611         cx_andor(MO_COLOR_CTRL, 0x4000, 0x4000);
 612
 613         /* setup FIFO Threshholds */
 614         cx_write(MO_PDMA_STHRSH,   0x0807);
 615         cx_write(MO_PDMA_DTHRSH,   0x0807);
 616
 617         /* fixes flashing of image */
 618         cx_write(MO_AGC_SYNC_TIP1, 0x0380000F);
 619         cx_write(MO_AGC_BACK_VBI,  0x00E00555);
 620
 621         cx_write(MO_VID_INTSTAT,   0xFFFFFFFF); // Clear PIV int
 622         cx_write(MO_PCI_INTSTAT,   0xFFFFFFFF); // Clear PCI int
 623         cx_write(MO_INT1_STAT,     0xFFFFFFFF); // Clear RISC int
 624
 625         /* Reset on-board parts */
 626         cx_write(MO_SRST_IO, 0);
 627         msleep(10);
 628         cx_write(MO_SRST_IO, 1);
 629
 630         return 0;
 631 }
 632
 633 /* ------------------------------------------------------------------ */
 634
 635 static unsigned int inline norm_swidth(v4l2_std_id norm)
 636 {
 637         return (norm & (V4L2_STD_MN & ~V4L2_STD_PAL_Nc)) ? 754 : 922;
 638 }
 639
 640 static unsigned int inline norm_hdelay(v4l2_std_id norm)
 641 {
 642         return (norm & (V4L2_STD_MN & ~V4L2_STD_PAL_Nc)) ? 135 : 186;
 643 }
 644
 645 static unsigned int inline norm_vdelay(v4l2_std_id norm)
 646 {
 647         return (norm & V4L2_STD_625_50) ? 0x24 : 0x18;
 648 }
 649
 650 static unsigned int inline norm_fsc8(v4l2_std_id norm)
 651 {
 652         if (norm & V4L2_STD_PAL_M)
 653                 return 28604892;      // 3.575611 MHz
 654
 655         if (norm & (V4L2_STD_PAL_Nc))
 656                 return 28656448;      // 3.582056 MHz
 657
 658         if (norm & V4L2_STD_NTSC) // All NTSC/M and variants
 659                 return 28636360;      // 3.57954545 MHz +/- 10 Hz
 660
 661         /* SECAM have also different sub carrier for chroma,
 662            but step_db and step_dr, at cx88_set_tvnorm already handles that.
 663
 664            The same FSC applies to PAL/BGDKIH, PAL/60, NTSC/4.43 and PAL/N
 665          */
 666
 667         return 35468950;      // 4.43361875 MHz +/- 5 Hz
 668 }
 669
 670 static unsigned int inline norm_htotal(v4l2_std_id norm)
 671 {
 672
 673         unsigned int fsc4=norm_fsc8(norm)/2;
 674
 675         /* returns 4*FSC / vtotal / frames per seconds */
 676         return (norm & V4L2_STD_625_50) ?
 677                                 ((fsc4+312)/625+12)/25 :
 678                                 ((fsc4+262)/525*1001+15000)/30000;
 679 }
 680
 681 static unsigned int inline norm_vbipack(v4l2_std_id norm)
 682 {
 683         return (norm & V4L2_STD_625_50) ? 511 : 400;
 684 }
 685
 686 int cx88_set_scale(struct cx88_core *core, unsigned int width, unsigned int height,
 687                    enum v4l2_field field)
 688 {
 689         unsigned int swidth  = norm_swidth(core->tvnorm);
 690         unsigned int sheight = norm_maxh(core->tvnorm);
 691         u32 value;
 692
 693         dprintk(1,"set_scale: %dx%d [%s%s,%s]\n", width, height,
 694                 V4L2_FIELD_HAS_TOP(field)    ? "T" : "",
 695                 V4L2_FIELD_HAS_BOTTOM(field) ? "B" : "",
 696                 v4l2_norm_to_name(core->tvnorm));
 697         if (!V4L2_FIELD_HAS_BOTH(field))
 698                 height *= 2;
 699
 700         // recalc H delay and scale registers
 701         value = (width * norm_hdelay(core->tvnorm)) / swidth;
 702         value &= 0x3fe;
 703         cx_write(MO_HDELAY_EVEN,  value);
 704         cx_write(MO_HDELAY_ODD,   value);
 705         dprintk(1,"set_scale: hdelay  0x%04x (width %d)\n", value,swidth);
 706
 707         value = (swidth * 4096 / width) - 4096;
 708         cx_write(MO_HSCALE_EVEN,  value);
 709         cx_write(MO_HSCALE_ODD,   value);
 710         dprintk(1,"set_scale: hscale  0x%04x\n", value);
 711
 712         cx_write(MO_HACTIVE_EVEN, width);
 713         cx_write(MO_HACTIVE_ODD,  width);
 714         dprintk(1,"set_scale: hactive 0x%04x\n", width);
 715
 716         // recalc V scale Register (delay is constant)
 717         cx_write(MO_VDELAY_EVEN, norm_vdelay(core->tvnorm));
 718         cx_write(MO_VDELAY_ODD,  norm_vdelay(core->tvnorm));
 719         dprintk(1,"set_scale: vdelay  0x%04x\n", norm_vdelay(core->tvnorm));
 720
 721         value = (0x10000 - (sheight * 512 / height - 512)) & 0x1fff;
 722         cx_write(MO_VSCALE_EVEN,  value);
 723         cx_write(MO_VSCALE_ODD,   value);
 724         dprintk(1,"set_scale: vscale  0x%04x\n", value);
 725
 726         cx_write(MO_VACTIVE_EVEN, sheight);
 727         cx_write(MO_VACTIVE_ODD,  sheight);
 728         dprintk(1,"set_scale: vactive 0x%04x\n", sheight);
 729
 730         // setup filters
 731         value = 0;
 732         value |= (1 << 19);        // CFILT (default)
 733         if (core->tvnorm & V4L2_STD_SECAM) {
 734                 value |= (1 << 15);
 735                 value |= (1 << 16);
 736         }
 737         if (INPUT(core->input).type == CX88_VMUX_SVIDEO)
 738                 value |= (1 << 13) | (1 << 5);
 739         if (V4L2_FIELD_INTERLACED == field)
 740                 value |= (1 << 3); // VINT (interlaced vertical scaling)
 741         if (width < 385)
 742                 value |= (1 << 0); // 3-tap interpolation
 743         if (width < 193)
 744                 value |= (1 << 1); // 5-tap interpolation
 745         if (nocomb)
 746                 value |= (3 << 5); // disable comb filter
 747
 748         cx_write(MO_FILTER_EVEN,  value);
 749         cx_write(MO_FILTER_ODD,   value);
 750         dprintk(1,"set_scale: filter  0x%04x\n", value);
 751
 752         return 0;
 753 }
 754
 755 static const u32 xtal = 28636363;
 756
 757 static int set_pll(struct cx88_core *core, int prescale, u32 ofreq)
 758 {
 759         static u32 pre[] = { 0, 0, 0, 3, 2, 1 };
 760         u64 pll;
 761         u32 reg;
 762         int i;
 763
 764         if (prescale < 2)
 765                 prescale = 2;
 766         if (prescale > 5)
 767                 prescale = 5;
 768
 769         pll = ofreq * 8 * prescale * (u64)(1 << 20);
 770         do_div(pll,xtal);
 771         reg = (pll & 0x3ffffff) | (pre[prescale] << 26);
 772         if (((reg >> 20) & 0x3f) < 14) {
 773                 printk("%s/0: pll out of range\n",core->name);
 774                 return -1;
 775         }
 776
 777         dprintk(1,"set_pll:    MO_PLL_REG       0x%08x [old=0x%08x,freq=%d]\n",
 778                 reg, cx_read(MO_PLL_REG), ofreq);
 779         cx_write(MO_PLL_REG, reg);
 780         for (i = 0; i < 100; i++) {
 781                 reg = cx_read(MO_DEVICE_STATUS);
 782                 if (reg & (1<<2)) {
 783                         dprintk(1,"pll locked [pre=%d,ofreq=%d]\n",
 784                                 prescale,ofreq);
 785                         return 0;
 786                 }
 787                 dprintk(1,"pll not locked yet, waiting ...\n");
 788                 msleep(10);
 789         }
 790         dprintk(1,"pll NOT locked [pre=%d,ofreq=%d]\n",prescale,ofreq);
 791         return -1;
 792 }
 793
 794 int cx88_start_audio_dma(struct cx88_core *core)
 795 {
 796         /* constant 128 made buzz in analog Nicam-stereo for bigger fifo_size */
 797         int bpl = cx88_sram_channels[SRAM_CH25].fifo_size/4;
 798
 799         /* If downstream RISC is enabled, bail out; ALSA is managing DMA */
 800         if (cx_read(MO_AUD_DMACNTRL) & 0x10)
 801                 return 0;
 802
 803         /* setup fifo + format */
 804         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH25], bpl, 0);
 805         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH26], bpl, 0);
 806
 807         cx_write(MO_AUDD_LNGTH, bpl); /* fifo bpl size */
 808         cx_write(MO_AUDR_LNGTH, bpl); /* fifo bpl size */
 809
 810         /* start dma */
 811         cx_write(MO_AUD_DMACNTRL, 0x0003); /* Up and Down fifo enable */
 812
 813         return 0;
 814 }
 815
 816 int cx88_stop_audio_dma(struct cx88_core *core)
 817 {
 818         /* If downstream RISC is enabled, bail out; ALSA is managing DMA */
 819         if (cx_read(MO_AUD_DMACNTRL) & 0x10)
 820                 return 0;
 821
 822         /* stop dma */
 823         cx_write(MO_AUD_DMACNTRL, 0x0000);
 824
 825         return 0;
 826 }
 827
 828 static int set_tvaudio(struct cx88_core *core)
 829 {
 830         v4l2_std_id norm = core->tvnorm;
 831
 832         if (CX88_VMUX_TELEVISION != INPUT(core->input).type)
 833                 return 0;
 834
 835         if (V4L2_STD_PAL_BG & norm) {
 836                 core->tvaudio = WW_BG;
 837
 838         } else if (V4L2_STD_PAL_DK & norm) {
 839                 core->tvaudio = WW_DK;
 840
 841         } else if (V4L2_STD_PAL_I & norm) {
 842                 core->tvaudio = WW_I;
 843
 844         } else if (V4L2_STD_SECAM_L & norm) {
 845                 core->tvaudio = WW_L;
 846
 847         } else if ((V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H) & norm) {
 848                 core->tvaudio = WW_BG;
 849
 850         } else if (V4L2_STD_SECAM_DK & norm) {
 851                 core->tvaudio = WW_DK;
 852
 853         } else if ((V4L2_STD_NTSC_M & norm) ||
 854                    (V4L2_STD_PAL_M  & norm)) {
 855                 core->tvaudio = WW_BTSC;
 856
 857         } else if (V4L2_STD_NTSC_M_JP & norm) {
 858                 core->tvaudio = WW_EIAJ;
 859
 860         } else {
 861                 printk("%s/0: tvaudio support needs work for this tv norm [%s], sorry\n",
 862                        core->name, v4l2_norm_to_name(core->tvnorm));
 863                 core->tvaudio = 0;
 864                 return 0;
 865         }
 866
 867         cx_andor(MO_AFECFG_IO, 0x1f, 0x0);
 868         cx88_set_tvaudio(core);
 869         /* cx88_set_stereo(dev,V4L2_TUNER_MODE_STEREO); */
 870
 871 /*
 872    This should be needed only on cx88-alsa. It seems that some cx88 chips have
 873    bugs and does require DMA enabled for it to work.
 874  */
 875         cx88_start_audio_dma(core);
 876         return 0;
 877 }
 878
 879
 880
 881 int cx88_set_tvnorm(struct cx88_core *core, v4l2_std_id norm)
 882 {
 883         u32 fsc8;
 884         u32 adc_clock;
 885         u32 vdec_clock;
 886         u32 step_db,step_dr;
 887         u64 tmp64;
 888         u32 bdelay,agcdelay,htotal;
 889         u32 cxiformat, cxoformat;
 890
 891         core->tvnorm = norm;
 892         fsc8       = norm_fsc8(norm);
 893         adc_clock  = xtal;
 894         vdec_clock = fsc8;
 895         step_db    = fsc8;
 896         step_dr    = fsc8;
 897
 898         if (norm & V4L2_STD_NTSC_M_JP) {
 899                 cxiformat = VideoFormatNTSCJapan;
 900                 cxoformat = 0x181f0008;
 901         } else if (norm & V4L2_STD_NTSC_443) {
 902                 cxiformat = VideoFormatNTSC443;
 903                 cxoformat = 0x181f0008;
 904         } else if (norm & V4L2_STD_PAL_M) {
 905                 cxiformat = VideoFormatPALM;
 906                 cxoformat = 0x1c1f0008;
 907         } else if (norm & V4L2_STD_PAL_N) {
 908                 cxiformat = VideoFormatPALN;
 909                 cxoformat = 0x1c1f0008;
 910         } else if (norm & V4L2_STD_PAL_Nc) {
 911                 cxiformat = VideoFormatPALNC;
 912                 cxoformat = 0x1c1f0008;
 913         } else if (norm & V4L2_STD_PAL_60) {
 914                 cxiformat = VideoFormatPAL60;
 915                 cxoformat = 0x181f0008;
 916         } else if (norm & V4L2_STD_NTSC) {
 917                 cxiformat = VideoFormatNTSC;
 918                 cxoformat = 0x181f0008;
 919         } else if (norm & V4L2_STD_SECAM) {
 920                 step_db = 4250000 * 8;
 921                 step_dr = 4406250 * 8;
 922
 923                 cxiformat = VideoFormatSECAM;
 924                 cxoformat = 0x181f0008;
 925         } else { /* PAL */
 926                 cxiformat = VideoFormatPAL;
 927                 cxoformat = 0x181f0008;
 928         }
 929
 930         dprintk(1,"set_tvnorm: \"%s\" fsc8=%d adc=%d vdec=%d db/dr=%d/%d\n",
 931                 v4l2_norm_to_name(core->tvnorm), fsc8, adc_clock, vdec_clock,
 932                 step_db, step_dr);
 933         set_pll(core,2,vdec_clock);
 934
 935         dprintk(1,"set_tvnorm: MO_INPUT_FORMAT  0x%08x [old=0x%08x]\n",
 936                 cxiformat, cx_read(MO_INPUT_FORMAT) & 0x0f);
 937         /* Chroma AGC must be disabled if SECAM is used, we enable it
 938            by default on PAL and NTSC */
 939         cx_andor(MO_INPUT_FORMAT, 0x40f,
 940                  norm & V4L2_STD_SECAM ? cxiformat : cxiformat | 0x400);
 941
 942         // FIXME: as-is from DScaler
 943         dprintk(1,"set_tvnorm: MO_OUTPUT_FORMAT 0x%08x [old=0x%08x]\n",
 944                 cxoformat, cx_read(MO_OUTPUT_FORMAT));
 945         cx_write(MO_OUTPUT_FORMAT, cxoformat);
 946
 947         // MO_SCONV_REG = adc clock / video dec clock * 2^17
 948         tmp64  = adc_clock * (u64)(1 << 17);
 949         do_div(tmp64, vdec_clock);
 950         dprintk(1,"set_tvnorm: MO_SCONV_REG     0x%08x [old=0x%08x]\n",
 951                 (u32)tmp64, cx_read(MO_SCONV_REG));
 952         cx_write(MO_SCONV_REG, (u32)tmp64);
 953
 954         // MO_SUB_STEP = 8 * fsc / video dec clock * 2^22
 955         tmp64  = step_db * (u64)(1 << 22);
 956         do_div(tmp64, vdec_clock);
 957         dprintk(1,"set_tvnorm: MO_SUB_STEP      0x%08x [old=0x%08x]\n",
 958                 (u32)tmp64, cx_read(MO_SUB_STEP));
 959         cx_write(MO_SUB_STEP, (u32)tmp64);
 960
 961         // MO_SUB_STEP_DR = 8 * 4406250 / video dec clock * 2^22
 962         tmp64  = step_dr * (u64)(1 << 22);
 963         do_div(tmp64, vdec_clock);
 964         dprintk(1,"set_tvnorm: MO_SUB_STEP_DR   0x%08x [old=0x%08x]\n",
 965                 (u32)tmp64, cx_read(MO_SUB_STEP_DR));
 966         cx_write(MO_SUB_STEP_DR, (u32)tmp64);
 967
 968         // bdelay + agcdelay
 969         bdelay   = vdec_clock * 65 / 20000000 + 21;
 970         agcdelay = vdec_clock * 68 / 20000000 + 15;
 971         dprintk(1,"set_tvnorm: MO_AGC_BURST     0x%08x [old=0x%08x,bdelay=%d,agcdelay=%d]\n",
 972                 (bdelay << 8) | agcdelay, cx_read(MO_AGC_BURST), bdelay, agcdelay);
 973         cx_write(MO_AGC_BURST, (bdelay << 8) | agcdelay);
 974
 975         // htotal
 976         tmp64 = norm_htotal(norm) * (u64)vdec_clock;
 977         do_div(tmp64, fsc8);
 978         htotal = (u32)tmp64 | (HLNotchFilter4xFsc << 11);
 979         dprintk(1,"set_tvnorm: MO_HTOTAL        0x%08x [old=0x%08x,htotal=%d]\n",
 980                 htotal, cx_read(MO_HTOTAL), (u32)tmp64);
 981         cx_write(MO_HTOTAL, htotal);
 982
 983         // vbi stuff, set vbi offset to 10 (for 20 Clk*2 pixels), this makes
 984         // the effective vbi offset ~244 samples, the same as the Bt8x8
 985         cx_write(MO_VBI_PACKET, (10<<11) | norm_vbipack(norm));
 986
 987         // this is needed as well to set all tvnorm parameter
 988         cx88_set_scale(core, 320, 240, V4L2_FIELD_INTERLACED);
 989
 990         // audio
 991         set_tvaudio(core);
 992
 993         // tell i2c chips
 994         call_all(core, tuner, s_std, norm);
 995
 996         // done
 997         return 0;
 998 }
 999
1000 /* ------------------------------------------------------------------ */
1001
1002 struct video_device *cx88_vdev_init(struct cx88_core *core,
1003                                     struct pci_dev *pci,
1004                                     struct video_device *template,
1005                                     char *type)
1006 {
1007         struct video_device *vfd;
1008
1009         vfd = video_device_alloc();
1010         if (NULL == vfd)
1011                 return NULL;
1012         *vfd = *template;
1013         vfd->minor   = -1;
1014         vfd->v4l2_dev = &core->v4l2_dev;
1015         vfd->parent = &pci->dev;
1016         vfd->release = video_device_release;
1017         snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)",
1018                  core->name, type, core->board.name);
1019         return vfd;
1020 }
1021
1022 struct cx88_core* cx88_core_get(struct pci_dev *pci)
1023 {
1024         struct cx88_core *core;
1025
1026         mutex_lock(&devlist);
1027         list_for_each_entry(core, &cx88_devlist, devlist) {
1028                 if (pci->bus->number != core->pci_bus)
1029                         continue;
1030                 if (PCI_SLOT(pci->devfn) != core->pci_slot)
1031                         continue;
1032
1033                 if (0 != cx88_get_resources(core, pci)) {
1034                         mutex_unlock(&devlist);
1035                         return NULL;
1036                 }
1037                 atomic_inc(&core->refcount);
1038                 mutex_unlock(&devlist);
1039                 return core;
1040         }
1041
1042         core = cx88_core_create(pci, cx88_devcount);
1043         if (NULL != core) {
1044                 cx88_devcount++;
1045                 list_add_tail(&core->devlist, &cx88_devlist);
1046         }
1047
1048         mutex_unlock(&devlist);
1049         return core;
1050 }
1051
1052 void cx88_core_put(struct cx88_core *core, struct pci_dev *pci)
1053 {
1054         release_mem_region(pci_resource_start(pci,0),
1055                            pci_resource_len(pci,0));
1056
1057         if (!atomic_dec_and_test(&core->refcount))
1058                 return;
1059
1060         mutex_lock(&devlist);
1061         cx88_ir_fini(core);
1062         if (0 == core->i2c_rc) {
1063                 if (core->i2c_rtc)
1064                         i2c_unregister_device(core->i2c_rtc);
1065                 i2c_del_adapter(&core->i2c_adap);
1066         }
1067         list_del(&core->devlist);
1068         iounmap(core->lmmio);
1069         cx88_devcount--;
1070         mutex_unlock(&devlist);
1071         v4l2_device_unregister(&core->v4l2_dev);
1072         kfree(core);
1073 }
1074
1075 /* ------------------------------------------------------------------ */
1076
1077 EXPORT_SYMBOL(cx88_print_irqbits);
1078
1079 EXPORT_SYMBOL(cx88_core_irq);
1080 EXPORT_SYMBOL(cx88_wakeup);
1081 EXPORT_SYMBOL(cx88_reset);
1082 EXPORT_SYMBOL(cx88_shutdown);
1083
1084 EXPORT_SYMBOL(cx88_risc_buffer);
1085 EXPORT_SYMBOL(cx88_risc_databuffer);
1086 EXPORT_SYMBOL(cx88_risc_stopper);
1087 EXPORT_SYMBOL(cx88_free_buffer);
1088
1089 EXPORT_SYMBOL(cx88_sram_channels);
1090 EXPORT_SYMBOL(cx88_sram_channel_setup);
1091 EXPORT_SYMBOL(cx88_sram_channel_dump);
1092
1093 EXPORT_SYMBOL(cx88_set_tvnorm);
1094 EXPORT_SYMBOL(cx88_set_scale);
1095
1096 EXPORT_SYMBOL(cx88_vdev_init);
1097 EXPORT_SYMBOL(cx88_core_get);
1098 EXPORT_SYMBOL(cx88_core_put);
1099
1100 EXPORT_SYMBOL(cx88_ir_start);
1101 EXPORT_SYMBOL(cx88_ir_stop);
1102
1103 /*
1104  * Local variables:
1105  * c-basic-offset: 8
1106  * End:
1107  * 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
1108  */