SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/dvb/ttpci/av7110.c

   1 /*
   2  * driver for the SAA7146 based AV110 cards (like the Fujitsu-Siemens DVB)
   3  * av7110.c: initialization and demux stuff
   4  *
   5  * Copyright (C) 1999-2002 Ralph  Metzler
   6  *                       & Marcus Metzler for convergence integrated media GmbH
   7  *
   8  * originally based on code by:
   9  * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
  27  *
  28  *
  29  * the project's page is at http://www.linuxtv.org/dvb/
  30  */
  31
  32
  33 #include <linux/module.h>
  34 #include <linux/kmod.h>
  35 #include <linux/delay.h>
  36 #include <linux/fs.h>
  37 #include <linux/timer.h>
  38 #include <linux/poll.h>
  39 #include <linux/byteorder/swabb.h>
  40 #include <linux/smp_lock.h>
  41
  42 #include <linux/kernel.h>
  43 #include <linux/sched.h>
  44 #include <linux/types.h>
  45 #include <linux/fcntl.h>
  46 #include <linux/interrupt.h>
  47 #include <linux/string.h>
  48 #include <linux/pci.h>
  49 #include <linux/vmalloc.h>
  50 #include <linux/firmware.h>
  51 #include <linux/crc32.h>
  52 #include <linux/i2c.h>
  53 #include <linux/kthread.h>
  54
  55 #include <asm/system.h>
  56
  57 #include <linux/dvb/frontend.h>
  58
  59 #include "dvb_frontend.h"
  60
  61 #include "ttpci-eeprom.h"
  62 #include "av7110.h"
  63 #include "av7110_hw.h"
  64 #include "av7110_av.h"
  65 #include "av7110_ca.h"
  66 #include "av7110_ipack.h"
  67
  68 #include "bsbe1.h"
  69 #include "lnbp21.h"
  70 #include "bsru6.h"
  71
  72 #define TS_WIDTH  376
  73 #define TS_HEIGHT 512
  74 #define TS_BUFLEN (TS_WIDTH*TS_HEIGHT)
  75 #define TS_MAX_PACKETS (TS_BUFLEN/TS_SIZE)
  76
  77
  78 int av7110_debug;
  79
  80 static int vidmode = CVBS_RGB_OUT;
  81 static int pids_off;
  82 static int adac = DVB_ADAC_TI;
  83 static int hw_sections;
  84 static int rgb_on;
  85 static int volume = 255;
  86 static int budgetpatch;
  87 static int wss_cfg_4_3 = 0x4008;
  88 static int wss_cfg_16_9 = 0x0007;
  89 static int tv_standard;
  90
  91 module_param_named(debug, av7110_debug, int, 0644);
  92 MODULE_PARM_DESC(debug, "debug level (bitmask, default 0)");
  93 module_param(vidmode, int, 0444);
  94 MODULE_PARM_DESC(vidmode,"analog video out: 0 off, 1 CVBS+RGB (default), 2 CVBS+YC, 3 YC");
  95 module_param(pids_off, int, 0444);
  96 MODULE_PARM_DESC(pids_off,"clear video/audio/PCR PID filters when demux is closed");
  97 module_param(adac, int, 0444);
  98 MODULE_PARM_DESC(adac,"audio DAC type: 0 TI, 1 CRYSTAL, 2 MSP (use if autodetection fails)");
  99 module_param(hw_sections, int, 0444);
 100 MODULE_PARM_DESC(hw_sections, "0 use software section filter, 1 use hardware");
 101 module_param(rgb_on, int, 0444);
 102 MODULE_PARM_DESC(rgb_on, "For Siemens DVB-C cards only: Enable RGB control"
 103                 " signal on SCART pin 16 to switch SCART video mode from CVBS to RGB");
 104 module_param(volume, int, 0444);
 105 MODULE_PARM_DESC(volume, "initial volume: default 255 (range 0-255)");
 106 module_param(budgetpatch, int, 0444);
 107 MODULE_PARM_DESC(budgetpatch, "use budget-patch hardware modification: default 0 (0 no, 1 autodetect, 2 always)");
 108 module_param(wss_cfg_4_3, int, 0444);
 109 MODULE_PARM_DESC(wss_cfg_4_3, "WSS 4:3 - default 0x4008 - bit 15: disable, 14: burst mode, 13..0: wss data");
 110 module_param(wss_cfg_16_9, int, 0444);
 111 MODULE_PARM_DESC(wss_cfg_16_9, "WSS 16:9 - default 0x0007 - bit 15: disable, 14: burst mode, 13..0: wss data");
 112 module_param(tv_standard, int, 0444);
 113 MODULE_PARM_DESC(tv_standard, "TV standard: 0 PAL (default), 1 NTSC");
 114
 115 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 116
 117 static void restart_feeds(struct av7110 *av7110);
 118
 119 static int av7110_num;
 120
 121 #define FE_FUNC_OVERRIDE(fe_func, av7110_copy, av7110_func) \
 122 {\
 123         if (fe_func != NULL) { \
 124                 av7110_copy = fe_func; \
 125                 fe_func = av7110_func; \
 126         } \
 127 }
 128
 129
 130 static void init_av7110_av(struct av7110 *av7110)
 131 {
 132         int ret;
 133         struct saa7146_dev *dev = av7110->dev;
 134
 135         /* set internal volume control to maximum */
 136         av7110->adac_type = DVB_ADAC_TI;
 137         ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
 138         if (ret < 0)
 139                 printk("dvb-ttpci:cannot set internal volume to maximum:%d\n",ret);
 140
 141         ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetMonitorType,
 142                             1, (u16) av7110->display_ar);
 143         if (ret < 0)
 144                 printk("dvb-ttpci: unable to set aspect ratio\n");
 145         ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetPanScanType,
 146                             1, av7110->display_panscan);
 147         if (ret < 0)
 148                 printk("dvb-ttpci: unable to set pan scan\n");
 149
 150         ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 2, wss_cfg_4_3);
 151         if (ret < 0)
 152                 printk("dvb-ttpci: unable to configure 4:3 wss\n");
 153         ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 3, wss_cfg_16_9);
 154         if (ret < 0)
 155                 printk("dvb-ttpci: unable to configure 16:9 wss\n");
 156
 157         ret = av7710_set_video_mode(av7110, vidmode);
 158         if (ret < 0)
 159                 printk("dvb-ttpci:cannot set video mode:%d\n",ret);
 160
 161         /* handle different card types */
 162         /* remaining inits according to card and frontend type */
 163         av7110->analog_tuner_flags = 0;
 164         av7110->current_input = 0;
 165         if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000a)
 166                 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 0); // SPDIF on
 167         if (i2c_writereg(av7110, 0x20, 0x00, 0x00) == 1) {
 168                 printk ("dvb-ttpci: Crystal audio DAC @ card %d detected\n",
 169                         av7110->dvb_adapter.num);
 170                 av7110->adac_type = DVB_ADAC_CRYSTAL;
 171                 i2c_writereg(av7110, 0x20, 0x01, 0xd2);
 172                 i2c_writereg(av7110, 0x20, 0x02, 0x49);
 173                 i2c_writereg(av7110, 0x20, 0x03, 0x00);
 174                 i2c_writereg(av7110, 0x20, 0x04, 0x00);
 175
 176                 /**
 177                  * some special handling for the Siemens DVB-C cards...
 178                  */
 179         } else if (0 == av7110_init_analog_module(av7110)) {
 180                 /* done. */
 181         }
 182         else if (dev->pci->subsystem_vendor == 0x110a) {
 183                 printk("dvb-ttpci: DVB-C w/o analog module @ card %d detected\n",
 184                         av7110->dvb_adapter.num);
 185                 av7110->adac_type = DVB_ADAC_NONE;
 186         }
 187         else {
 188                 av7110->adac_type = adac;
 189                 printk("dvb-ttpci: adac type set to %d @ card %d\n",
 190                         av7110->adac_type, av7110->dvb_adapter.num);
 191         }
 192
 193         if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP34x0) {
 194                 // switch DVB SCART on
 195                 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0);
 196                 if (ret < 0)
 197                         printk("dvb-ttpci:cannot switch on SCART(Main):%d\n",ret);
 198                 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1);
 199                 if (ret < 0)
 200                         printk("dvb-ttpci:cannot switch on SCART(AD):%d\n",ret);
 201                 if (rgb_on &&
 202                     ((av7110->dev->pci->subsystem_vendor == 0x110a) ||
 203                      (av7110->dev->pci->subsystem_vendor == 0x13c2)) &&
 204                      (av7110->dev->pci->subsystem_device == 0x0000)) {
 205                         saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16
 206                         //saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // SCARTpin 8
 207                 }
 208         }
 209
 210         if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000e)
 211                 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, SpdifSwitch, 1, 0); // SPDIF on
 212
 213         ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
 214         if (ret < 0)
 215                 printk("dvb-ttpci:cannot set volume :%d\n",ret);
 216 }
 217
 218 static void recover_arm(struct av7110 *av7110)
 219 {
 220         dprintk(4, "%p\n",av7110);
 221
 222         av7110_bootarm(av7110);
 223         msleep(100);
 224
 225         init_av7110_av(av7110);
 226
 227         /* card-specific recovery */
 228         if (av7110->recover)
 229                 av7110->recover(av7110);
 230
 231         restart_feeds(av7110);
 232
 233 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
 234         av7110_check_ir_config(av7110, true);
 235 #endif
 236 }
 237
 238 static void av7110_arm_sync(struct av7110 *av7110)
 239 {
 240         if (av7110->arm_thread)
 241                 kthread_stop(av7110->arm_thread);
 242
 243         av7110->arm_thread = NULL;
 244 }
 245
 246 static int arm_thread(void *data)
 247 {
 248         struct av7110 *av7110 = data;
 249         u16 newloops = 0;
 250         int timeout;
 251
 252         dprintk(4, "%p\n",av7110);
 253
 254         for (;;) {
 255                 timeout = wait_event_interruptible_timeout(av7110->arm_wait,
 256                         kthread_should_stop(), 5 * HZ);
 257
 258                 if (-ERESTARTSYS == timeout || kthread_should_stop()) {
 259                         /* got signal or told to quit*/
 260                         break;
 261                 }
 262
 263                 if (!av7110->arm_ready)
 264                         continue;
 265
 266 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
 267                 av7110_check_ir_config(av7110, false);
 268 #endif
 269
 270                 if (mutex_lock_interruptible(&av7110->dcomlock))
 271                         break;
 272                 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
 273                 mutex_unlock(&av7110->dcomlock);
 274
 275                 if (newloops == av7110->arm_loops || av7110->arm_errors > 3) {
 276                         printk(KERN_ERR "dvb-ttpci: ARM crashed @ card %d\n",
 277                                av7110->dvb_adapter.num);
 278
 279                         recover_arm(av7110);
 280
 281                         if (mutex_lock_interruptible(&av7110->dcomlock))
 282                                 break;
 283                         newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2) - 1;
 284                         mutex_unlock(&av7110->dcomlock);
 285                 }
 286                 av7110->arm_loops = newloops;
 287                 av7110->arm_errors = 0;
 288         }
 289
 290         return 0;
 291 }
 292
 293
 294 /****************************************************************************
 295  * IRQ handling
 296  ****************************************************************************/
 297
 298 static int DvbDmxFilterCallback(u8 *buffer1, size_t buffer1_len,
 299                                 u8 *buffer2, size_t buffer2_len,
 300                                 struct dvb_demux_filter *dvbdmxfilter,
 301                                 enum dmx_success success,
 302                                 struct av7110 *av7110)
 303 {
 304         if (!dvbdmxfilter->feed->demux->dmx.frontend)
 305                 return 0;
 306         if (dvbdmxfilter->feed->demux->dmx.frontend->source == DMX_MEMORY_FE)
 307                 return 0;
 308
 309         switch (dvbdmxfilter->type) {
 310         case DMX_TYPE_SEC:
 311                 if ((((buffer1[1] << 8) | buffer1[2]) & 0xfff) + 3 != buffer1_len)
 312                         return 0;
 313                 if (dvbdmxfilter->doneq) {
 314                         struct dmx_section_filter *filter = &dvbdmxfilter->filter;
 315                         int i;
 316                         u8 xor, neq = 0;
 317
 318                         for (i = 0; i < DVB_DEMUX_MASK_MAX; i++) {
 319                                 xor = filter->filter_value[i] ^ buffer1[i];
 320                                 neq |= dvbdmxfilter->maskandnotmode[i] & xor;
 321                         }
 322                         if (!neq)
 323                                 return 0;
 324                 }
 325                 return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len,
 326                                                   buffer2, buffer2_len,
 327                                                   &dvbdmxfilter->filter,
 328                                                   DMX_OK);
 329         case DMX_TYPE_TS:
 330                 if (!(dvbdmxfilter->feed->ts_type & TS_PACKET))
 331                         return 0;
 332                 if (dvbdmxfilter->feed->ts_type & TS_PAYLOAD_ONLY)
 333                         return dvbdmxfilter->feed->cb.ts(buffer1, buffer1_len,
 334                                                          buffer2, buffer2_len,
 335                                                          &dvbdmxfilter->feed->feed.ts,
 336                                                          DMX_OK);
 337                 else
 338                         av7110_p2t_write(buffer1, buffer1_len,
 339                                          dvbdmxfilter->feed->pid,
 340                                          &av7110->p2t_filter[dvbdmxfilter->index]);
 341         default:
 342                 return 0;
 343         }
 344 }
 345
 346
 347 //#define DEBUG_TIMING
 348 static inline void print_time(char *s)
 349 {
 350 #ifdef DEBUG_TIMING
 351         struct timeval tv;
 352         do_gettimeofday(&tv);
 353         printk("%s: %d.%d\n", s, (int)tv.tv_sec, (int)tv.tv_usec);
 354 #endif
 355 }
 356
 357 #define DEBI_READ 0
 358 #define DEBI_WRITE 1
 359 static inline void start_debi_dma(struct av7110 *av7110, int dir,
 360                                   unsigned long addr, unsigned int len)
 361 {
 362         dprintk(8, "%c %08lx %u\n", dir == DEBI_READ ? 'R' : 'W', addr, len);
 363         if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
 364                 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __func__);
 365                 return;
 366         }
 367
 368         SAA7146_ISR_CLEAR(av7110->dev, MASK_19); /* for good measure */
 369         SAA7146_IER_ENABLE(av7110->dev, MASK_19);
 370         if (len < 5)
 371                 len = 5; /* we want a real DEBI DMA */
 372         if (dir == DEBI_WRITE)
 373                 iwdebi(av7110, DEBISWAB, addr, 0, (len + 3) & ~3);
 374         else
 375                 irdebi(av7110, DEBISWAB, addr, 0, len);
 376 }
 377
 378 static void debiirq(unsigned long data)
 379 {
 380         struct av7110 *av7110 = (struct av7110 *) data;
 381         int type = av7110->debitype;
 382         int handle = (type >> 8) & 0x1f;
 383         unsigned int xfer = 0;
 384
 385         print_time("debi");
 386         dprintk(4, "type 0x%04x\n", type);
 387
 388         if (type == -1) {
 389                 printk("DEBI irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
 390                        jiffies, saa7146_read(av7110->dev, PSR),
 391                        saa7146_read(av7110->dev, SSR));
 392                 goto debi_done;
 393         }
 394         av7110->debitype = -1;
 395
 396         switch (type & 0xff) {
 397
 398         case DATA_TS_RECORD:
 399                 dvb_dmx_swfilter_packets(&av7110->demux,
 400                                          (const u8 *) av7110->debi_virt,
 401                                          av7110->debilen / 188);
 402                 xfer = RX_BUFF;
 403                 break;
 404
 405         case DATA_PES_RECORD:
 406                 if (av7110->demux.recording)
 407                         av7110_record_cb(&av7110->p2t[handle],
 408                                          (u8 *) av7110->debi_virt,
 409                                          av7110->debilen);
 410                 xfer = RX_BUFF;
 411                 break;
 412
 413         case DATA_IPMPE:
 414         case DATA_FSECTION:
 415         case DATA_PIPING:
 416                 if (av7110->handle2filter[handle])
 417                         DvbDmxFilterCallback((u8 *)av7110->debi_virt,
 418                                              av7110->debilen, NULL, 0,
 419                                              av7110->handle2filter[handle],
 420                                              DMX_OK, av7110);
 421                 xfer = RX_BUFF;
 422                 break;
 423
 424         case DATA_CI_GET:
 425         {
 426                 u8 *data = av7110->debi_virt;
 427
 428                 if ((data[0] < 2) && data[2] == 0xff) {
 429                         int flags = 0;
 430                         if (data[5] > 0)
 431                                 flags |= CA_CI_MODULE_PRESENT;
 432                         if (data[5] > 5)
 433                                 flags |= CA_CI_MODULE_READY;
 434                         av7110->ci_slot[data[0]].flags = flags;
 435                 } else
 436                         ci_get_data(&av7110->ci_rbuffer,
 437                                     av7110->debi_virt,
 438                                     av7110->debilen);
 439                 xfer = RX_BUFF;
 440                 break;
 441         }
 442
 443         case DATA_COMMON_INTERFACE:
 444                 CI_handle(av7110, (u8 *)av7110->debi_virt, av7110->debilen);
 445 #if 0
 446         {
 447                 int i;
 448
 449                 printk("av7110%d: ", av7110->num);
 450                 printk("%02x ", *(u8 *)av7110->debi_virt);
 451                 printk("%02x ", *(1+(u8 *)av7110->debi_virt));
 452                 for (i = 2; i < av7110->debilen; i++)
 453                         printk("%02x ", (*(i+(unsigned char *)av7110->debi_virt)));
 454                 for (i = 2; i < av7110->debilen; i++)
 455                         printk("%c", chtrans(*(i+(unsigned char *)av7110->debi_virt)));
 456
 457                 printk("\n");
 458         }
 459 #endif
 460                 xfer = RX_BUFF;
 461                 break;
 462
 463         case DATA_DEBUG_MESSAGE:
 464                 ((s8*)av7110->debi_virt)[Reserved_SIZE - 1] = 0;
 465                 printk("%s\n", (s8 *) av7110->debi_virt);
 466                 xfer = RX_BUFF;
 467                 break;
 468
 469         case DATA_CI_PUT:
 470                 dprintk(4, "debi DATA_CI_PUT\n");
 471         case DATA_MPEG_PLAY:
 472                 dprintk(4, "debi DATA_MPEG_PLAY\n");
 473         case DATA_BMP_LOAD:
 474                 dprintk(4, "debi DATA_BMP_LOAD\n");
 475                 xfer = TX_BUFF;
 476                 break;
 477         default:
 478                 break;
 479         }
 480 debi_done:
 481         spin_lock(&av7110->debilock);
 482         if (xfer)
 483                 iwdebi(av7110, DEBINOSWAP, xfer, 0, 2);
 484         ARM_ClearMailBox(av7110);
 485         spin_unlock(&av7110->debilock);
 486 }
 487
 488 /* irq from av7110 firmware writing the mailbox register in the DPRAM */
 489 static void gpioirq(unsigned long data)
 490 {
 491         struct av7110 *av7110 = (struct av7110 *) data;
 492         u32 rxbuf, txbuf;
 493         int len;
 494
 495         if (av7110->debitype != -1)
 496                 /* we shouldn't get any irq while a debi xfer is running */
 497                 printk("dvb-ttpci: GPIO0 irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
 498                        jiffies, saa7146_read(av7110->dev, PSR),
 499                        saa7146_read(av7110->dev, SSR));
 500
 501         if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
 502                 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __func__);
 503                 BUG(); /* maybe we should try resetting the debi? */
 504         }
 505
 506         spin_lock(&av7110->debilock);
 507         ARM_ClearIrq(av7110);
 508
 509         /* see what the av7110 wants */
 510         av7110->debitype = irdebi(av7110, DEBINOSWAP, IRQ_STATE, 0, 2);
 511         av7110->debilen  = irdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 512         rxbuf = irdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 513         txbuf = irdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 514         len = (av7110->debilen + 3) & ~3;
 515
 516         print_time("gpio");
 517         dprintk(8, "GPIO0 irq 0x%04x %d\n", av7110->debitype, av7110->debilen);
 518
 519         switch (av7110->debitype & 0xff) {
 520
 521         case DATA_TS_PLAY:
 522         case DATA_PES_PLAY:
 523                 break;
 524
 525         case DATA_MPEG_VIDEO_EVENT:
 526         {
 527                 u32 h_ar;
 528                 struct video_event event;
 529
 530                 av7110->video_size.w = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_WIDTH, 0, 2);
 531                 h_ar = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_HEIGHT_AR, 0, 2);
 532
 533                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 534                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 535
 536                 av7110->video_size.h = h_ar & 0xfff;
 537
 538                 event.type = VIDEO_EVENT_SIZE_CHANGED;
 539                 event.u.size.w = av7110->video_size.w;
 540                 event.u.size.h = av7110->video_size.h;
 541                 switch ((h_ar >> 12) & 0xf)
 542                 {
 543                 case 3:
 544                         av7110->video_size.aspect_ratio = VIDEO_FORMAT_16_9;
 545                         event.u.size.aspect_ratio = VIDEO_FORMAT_16_9;
 546                         av7110->videostate.video_format = VIDEO_FORMAT_16_9;
 547                         break;
 548                 case 4:
 549                         av7110->video_size.aspect_ratio = VIDEO_FORMAT_221_1;
 550                         event.u.size.aspect_ratio = VIDEO_FORMAT_221_1;
 551                         av7110->videostate.video_format = VIDEO_FORMAT_221_1;
 552                         break;
 553                 default:
 554                         av7110->video_size.aspect_ratio = VIDEO_FORMAT_4_3;
 555                         event.u.size.aspect_ratio = VIDEO_FORMAT_4_3;
 556                         av7110->videostate.video_format = VIDEO_FORMAT_4_3;
 557                 }
 558
 559                 dprintk(8, "GPIO0 irq: DATA_MPEG_VIDEO_EVENT: w/h/ar = %u/%u/%u\n",
 560                         av7110->video_size.w, av7110->video_size.h,
 561                         av7110->video_size.aspect_ratio);
 562
 563                 dvb_video_add_event(av7110, &event);
 564                 break;
 565         }
 566
 567         case DATA_CI_PUT:
 568         {
 569                 int avail;
 570                 struct dvb_ringbuffer *cibuf = &av7110->ci_wbuffer;
 571
 572                 avail = dvb_ringbuffer_avail(cibuf);
 573                 if (avail <= 2) {
 574                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 575                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 576                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 577                         break;
 578                 }
 579                 len = DVB_RINGBUFFER_PEEK(cibuf, 0) << 8;
 580                 len |= DVB_RINGBUFFER_PEEK(cibuf, 1);
 581                 if (avail < len + 2) {
 582                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 583                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 584                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 585                         break;
 586                 }
 587                 DVB_RINGBUFFER_SKIP(cibuf, 2);
 588
 589                 dvb_ringbuffer_read(cibuf, av7110->debi_virt, len, 0);
 590
 591                 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
 592                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
 593                 dprintk(8, "DMA: CI\n");
 594                 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
 595                 spin_unlock(&av7110->debilock);
 596                 wake_up(&cibuf->queue);
 597                 return;
 598         }
 599
 600         case DATA_MPEG_PLAY:
 601                 if (!av7110->playing) {
 602                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 603                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 604                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 605                         break;
 606                 }
 607                 len = 0;
 608                 if (av7110->debitype & 0x100) {
 609                         spin_lock(&av7110->aout.lock);
 610                         len = av7110_pes_play(av7110->debi_virt, &av7110->aout, 2048);
 611                         spin_unlock(&av7110->aout.lock);
 612                 }
 613                 if (len <= 0 && (av7110->debitype & 0x200)
 614                     &&av7110->videostate.play_state != VIDEO_FREEZED) {
 615                         spin_lock(&av7110->avout.lock);
 616                         len = av7110_pes_play(av7110->debi_virt, &av7110->avout, 2048);
 617                         spin_unlock(&av7110->avout.lock);
 618                 }
 619                 if (len <= 0) {
 620                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 621                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 622                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 623                         break;
 624                 }
 625                 dprintk(8, "GPIO0 PES_PLAY len=%04x\n", len);
 626                 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
 627                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
 628                 dprintk(8, "DMA: MPEG_PLAY\n");
 629                 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
 630                 spin_unlock(&av7110->debilock);
 631                 return;
 632
 633         case DATA_BMP_LOAD:
 634                 len = av7110->debilen;
 635                 dprintk(8, "gpio DATA_BMP_LOAD len %d\n", len);
 636                 if (!len) {
 637                         av7110->bmp_state = BMP_LOADED;
 638                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 639                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 640                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 641                         wake_up(&av7110->bmpq);
 642                         dprintk(8, "gpio DATA_BMP_LOAD done\n");
 643                         break;
 644                 }
 645                 if (len > av7110->bmplen)
 646                         len = av7110->bmplen;
 647                 if (len > 2 * 1024)
 648                         len = 2 * 1024;
 649                 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
 650                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
 651                 memcpy(av7110->debi_virt, av7110->bmpbuf+av7110->bmpp, len);
 652                 av7110->bmpp += len;
 653                 av7110->bmplen -= len;
 654                 dprintk(8, "gpio DATA_BMP_LOAD DMA len %d\n", len);
 655                 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE+txbuf, len);
 656                 spin_unlock(&av7110->debilock);
 657                 return;
 658
 659         case DATA_CI_GET:
 660         case DATA_COMMON_INTERFACE:
 661         case DATA_FSECTION:
 662         case DATA_IPMPE:
 663         case DATA_PIPING:
 664                 if (!len || len > 4 * 1024) {
 665                         iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 666                         break;
 667                 }
 668                 /* fall through */
 669
 670         case DATA_TS_RECORD:
 671         case DATA_PES_RECORD:
 672                 dprintk(8, "DMA: TS_REC etc.\n");
 673                 start_debi_dma(av7110, DEBI_READ, DPRAM_BASE+rxbuf, len);
 674                 spin_unlock(&av7110->debilock);
 675                 return;
 676
 677         case DATA_DEBUG_MESSAGE:
 678                 if (!len || len > 0xff) {
 679                         iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 680                         break;
 681                 }
 682                 start_debi_dma(av7110, DEBI_READ, Reserved, len);
 683                 spin_unlock(&av7110->debilock);
 684                 return;
 685
 686         case DATA_IRCOMMAND:
 687                 if (av7110->ir.ir_handler)
 688                         av7110->ir.ir_handler(av7110,
 689                                 swahw32(irdebi(av7110, DEBINOSWAP, Reserved, 0, 4)));
 690                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 691                 break;
 692
 693         default:
 694                 printk("dvb-ttpci: gpioirq unknown type=%d len=%d\n",
 695                        av7110->debitype, av7110->debilen);
 696                 break;
 697         }
 698         av7110->debitype = -1;
 699         ARM_ClearMailBox(av7110);
 700         spin_unlock(&av7110->debilock);
 701 }
 702
 703
 704 #ifdef CONFIG_DVB_AV7110_OSD
 705 static int dvb_osd_ioctl(struct inode *inode, struct file *file,
 706                          unsigned int cmd, void *parg)
 707 {
 708         struct dvb_device *dvbdev = file->private_data;
 709         struct av7110 *av7110 = dvbdev->priv;
 710
 711         dprintk(4, "%p\n", av7110);
 712
 713         if (cmd == OSD_SEND_CMD)
 714                 return av7110_osd_cmd(av7110, (osd_cmd_t *) parg);
 715         if (cmd == OSD_GET_CAPABILITY)
 716                 return av7110_osd_capability(av7110, (osd_cap_t *) parg);
 717
 718         return -EINVAL;
 719 }
 720
 721
 722 static struct file_operations dvb_osd_fops = {
 723         .owner          = THIS_MODULE,
 724         .ioctl          = dvb_generic_ioctl,
 725         .open           = dvb_generic_open,
 726         .release        = dvb_generic_release,
 727 };
 728
 729 static struct dvb_device dvbdev_osd = {
 730         .priv           = NULL,
 731         .users          = 1,
 732         .writers        = 1,
 733         .fops           = &dvb_osd_fops,
 734         .kernel_ioctl   = dvb_osd_ioctl,
 735 };
 736 #endif /* CONFIG_DVB_AV7110_OSD */
 737
 738
 739 static inline int SetPIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
 740                           u16 subpid, u16 pcrpid)
 741 {
 742         u16 aflags = 0;
 743
 744         dprintk(4, "%p\n", av7110);
 745
 746         if (vpid == 0x1fff || apid == 0x1fff ||
 747             ttpid == 0x1fff || subpid == 0x1fff || pcrpid == 0x1fff) {
 748                 vpid = apid = ttpid = subpid = pcrpid = 0;
 749                 av7110->pids[DMX_PES_VIDEO] = 0;
 750                 av7110->pids[DMX_PES_AUDIO] = 0;
 751                 av7110->pids[DMX_PES_TELETEXT] = 0;
 752                 av7110->pids[DMX_PES_PCR] = 0;
 753         }
 754
 755         if (av7110->audiostate.bypass_mode)
 756                 aflags |= 0x8000;
 757
 758         return av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, MultiPID, 6,
 759                              pcrpid, vpid, apid, ttpid, subpid, aflags);
 760 }
 761
 762 int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
 763                 u16 subpid, u16 pcrpid)
 764 {
 765         int ret = 0;
 766         dprintk(4, "%p\n", av7110);
 767
 768         if (mutex_lock_interruptible(&av7110->pid_mutex))
 769                 return -ERESTARTSYS;
 770
 771         if (!(vpid & 0x8000))
 772                 av7110->pids[DMX_PES_VIDEO] = vpid;
 773         if (!(apid & 0x8000))
 774                 av7110->pids[DMX_PES_AUDIO] = apid;
 775         if (!(ttpid & 0x8000))
 776                 av7110->pids[DMX_PES_TELETEXT] = ttpid;
 777         if (!(pcrpid & 0x8000))
 778                 av7110->pids[DMX_PES_PCR] = pcrpid;
 779
 780         av7110->pids[DMX_PES_SUBTITLE] = 0;
 781
 782         if (av7110->fe_synced) {
 783                 pcrpid = av7110->pids[DMX_PES_PCR];
 784                 ret = SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
 785         }
 786
 787         mutex_unlock(&av7110->pid_mutex);
 788         return ret;
 789 }
 790
 791
 792 /******************************************************************************
 793  * hardware filter functions
 794  ******************************************************************************/
 795
 796 static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter)
 797 {
 798         struct dvb_demux_feed *dvbdmxfeed = dvbdmxfilter->feed;
 799         struct av7110 *av7110 = dvbdmxfeed->demux->priv;
 800         u16 buf[20];
 801         int ret, i;
 802         u16 handle;
 803 //      u16 mode = 0x0320;
 804         u16 mode = 0xb96a;
 805
 806         dprintk(4, "%p\n", av7110);
 807
 808         if (dvbdmxfilter->type == DMX_TYPE_SEC) {
 809                 if (hw_sections) {
 810                         buf[4] = (dvbdmxfilter->filter.filter_value[0] << 8) |
 811                                 dvbdmxfilter->maskandmode[0];
 812                         for (i = 3; i < 18; i++)
 813                                 buf[i + 4 - 2] =
 814                                         (dvbdmxfilter->filter.filter_value[i] << 8) |
 815                                         dvbdmxfilter->maskandmode[i];
 816                         mode = 4;
 817                 }
 818         } else if ((dvbdmxfeed->ts_type & TS_PACKET) &&
 819                    !(dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)) {
 820                 av7110_p2t_init(&av7110->p2t_filter[dvbdmxfilter->index], dvbdmxfeed);
 821         }
 822
 823         buf[0] = (COMTYPE_PID_FILTER << 8) + AddPIDFilter;
 824         buf[1] = 16;
 825         buf[2] = dvbdmxfeed->pid;
 826         buf[3] = mode;
 827
 828         ret = av7110_fw_request(av7110, buf, 20, &handle, 1);
 829         if (ret != 0 || handle >= 32) {
 830                 printk("dvb-ttpci: %s error  buf %04x %04x %04x %04x  "
 831                                 "ret %d  handle %04x\n",
 832                                 __func__, buf[0], buf[1], buf[2], buf[3],
 833                                 ret, handle);
 834                 dvbdmxfilter->hw_handle = 0xffff;
 835                 if (!ret)
 836                         ret = -1;
 837                 return ret;
 838         }
 839
 840         av7110->handle2filter[handle] = dvbdmxfilter;
 841         dvbdmxfilter->hw_handle = handle;
 842
 843         return ret;
 844 }
 845
 846 static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
 847 {
 848         struct av7110 *av7110 = dvbdmxfilter->feed->demux->priv;
 849         u16 buf[3];
 850         u16 answ[2];
 851         int ret;
 852         u16 handle;
 853
 854         dprintk(4, "%p\n", av7110);
 855
 856         handle = dvbdmxfilter->hw_handle;
 857         if (handle >= 32) {
 858                 printk("%s tried to stop invalid filter %04x, filter type = %x\n",
 859                                 __func__, handle, dvbdmxfilter->type);
 860                 return -EINVAL;
 861         }
 862
 863         av7110->handle2filter[handle] = NULL;
 864
 865         buf[0] = (COMTYPE_PID_FILTER << 8) + DelPIDFilter;
 866         buf[1] = 1;
 867         buf[2] = handle;
 868         ret = av7110_fw_request(av7110, buf, 3, answ, 2);
 869         if (ret != 0 || answ[1] != handle) {
 870                 printk("dvb-ttpci: %s error  cmd %04x %04x %04x  ret %x  "
 871                                 "resp %04x %04x  pid %d\n",
 872                                 __func__, buf[0], buf[1], buf[2], ret,
 873                                 answ[0], answ[1], dvbdmxfilter->feed->pid);
 874                 if (!ret)
 875                         ret = -1;
 876         }
 877         return ret;
 878 }
 879
 880
 881 static int dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
 882 {
 883         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
 884         struct av7110 *av7110 = dvbdmx->priv;
 885         u16 *pid = dvbdmx->pids, npids[5];
 886         int i;
 887         int ret = 0;
 888
 889         dprintk(4, "%p\n", av7110);
 890
 891         npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
 892         i = dvbdmxfeed->pes_type;
 893         npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
 894         if ((i == 2) && npids[i] && (dvbdmxfeed->ts_type & TS_PACKET)) {
 895                 npids[i] = 0;
 896                 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
 897                 if (!ret)
 898                         ret = StartHWFilter(dvbdmxfeed->filter);
 899                 return ret;
 900         }
 901         if (dvbdmxfeed->pes_type <= 2 || dvbdmxfeed->pes_type == 4) {
 902                 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
 903                 if (ret)
 904                         return ret;
 905         }
 906
 907         if (dvbdmxfeed->pes_type < 2 && npids[0])
 908                 if (av7110->fe_synced)
 909                 {
 910                         ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
 911                         if (ret)
 912                                 return ret;
 913                 }
 914
 915         if ((dvbdmxfeed->ts_type & TS_PACKET)) {
 916                 if (dvbdmxfeed->pes_type == 0 && !(dvbdmx->pids[0] & 0x8000))
 917                         ret = av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed);
 918                 if (dvbdmxfeed->pes_type == 1 && !(dvbdmx->pids[1] & 0x8000))
 919                         ret = av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed);
 920         }
 921         return ret;
 922 }
 923
 924 static int dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
 925 {
 926         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
 927         struct av7110 *av7110 = dvbdmx->priv;
 928         u16 *pid = dvbdmx->pids, npids[5];
 929         int i;
 930
 931         int ret = 0;
 932
 933         dprintk(4, "%p\n", av7110);
 934
 935         if (dvbdmxfeed->pes_type <= 1) {
 936                 ret = av7110_av_stop(av7110, dvbdmxfeed->pes_type ?  RP_VIDEO : RP_AUDIO);
 937                 if (ret)
 938                         return ret;
 939                 if (!av7110->rec_mode)
 940                         dvbdmx->recording = 0;
 941                 if (!av7110->playing)
 942                         dvbdmx->playing = 0;
 943         }
 944         npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
 945         i = dvbdmxfeed->pes_type;
 946         switch (i) {
 947         case 2: //teletext
 948                 if (dvbdmxfeed->ts_type & TS_PACKET)
 949                         ret = StopHWFilter(dvbdmxfeed->filter);
 950                 npids[2] = 0;
 951                 break;
 952         case 0:
 953         case 1:
 954         case 4:
 955                 if (!pids_off)
 956                         return 0;
 957                 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
 958                 break;
 959         }
 960         if (!ret)
 961                 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
 962         return ret;
 963 }
 964
 965 static int av7110_start_feed(struct dvb_demux_feed *feed)
 966 {
 967         struct dvb_demux *demux = feed->demux;
 968         struct av7110 *av7110 = demux->priv;
 969         int ret = 0;
 970
 971         dprintk(4, "%p\n", av7110);
 972
 973         if (!demux->dmx.frontend)
 974                 return -EINVAL;
 975
 976         if (feed->pid > 0x1fff)
 977                 return -EINVAL;
 978
 979         if (feed->type == DMX_TYPE_TS) {
 980                 if ((feed->ts_type & TS_DECODER) &&
 981                     (feed->pes_type < DMX_TS_PES_OTHER)) {
 982                         switch (demux->dmx.frontend->source) {
 983                         case DMX_MEMORY_FE:
 984                                 if (feed->ts_type & TS_DECODER)
 985                                        if (feed->pes_type < 2 &&
 986                                            !(demux->pids[0] & 0x8000) &&
 987                                            !(demux->pids[1] & 0x8000)) {
 988                                                dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
 989                                                dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
 990                                                ret = av7110_av_start_play(av7110,RP_AV);
 991                                                if (!ret)
 992                                                        demux->playing = 1;
 993                                         }
 994                                 break;
 995                         default:
 996                                 ret = dvb_feed_start_pid(feed);
 997                                 break;
 998                         }
 999                 } else if ((feed->ts_type & TS_PACKET) &&
1000                            (demux->dmx.frontend->source != DMX_MEMORY_FE)) {
1001                         ret = StartHWFilter(feed->filter);
1002                 }
1003         }
1004
1005         else if (feed->type == DMX_TYPE_SEC) {
1006                 int i;
1007
1008                 for (i = 0; i < demux->filternum; i++) {
1009                         if (demux->filter[i].state != DMX_STATE_READY)
1010                                 continue;
1011                         if (demux->filter[i].type != DMX_TYPE_SEC)
1012                                 continue;
1013                         if (demux->filter[i].filter.parent != &feed->feed.sec)
1014                                 continue;
1015                         demux->filter[i].state = DMX_STATE_GO;
1016                         if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
1017                                 ret = StartHWFilter(&demux->filter[i]);
1018                                 if (ret)
1019                                         break;
1020                         }
1021                 }
1022         }
1023
1024         return ret;
1025 }
1026
1027
1028 static int av7110_stop_feed(struct dvb_demux_feed *feed)
1029 {
1030         struct dvb_demux *demux = feed->demux;
1031         struct av7110 *av7110 = demux->priv;
1032         int i, rc, ret = 0;
1033         dprintk(4, "%p\n", av7110);
1034
1035         if (feed->type == DMX_TYPE_TS) {
1036                 if (feed->ts_type & TS_DECODER) {
1037                         if (feed->pes_type >= DMX_TS_PES_OTHER ||
1038                             !demux->pesfilter[feed->pes_type])
1039                                 return -EINVAL;
1040                         demux->pids[feed->pes_type] |= 0x8000;
1041                         demux->pesfilter[feed->pes_type] = NULL;
1042                 }
1043                 if (feed->ts_type & TS_DECODER &&
1044                     feed->pes_type < DMX_TS_PES_OTHER) {
1045                         ret = dvb_feed_stop_pid(feed);
1046                 } else
1047                         if ((feed->ts_type & TS_PACKET) &&
1048                             (demux->dmx.frontend->source != DMX_MEMORY_FE))
1049                                 ret = StopHWFilter(feed->filter);
1050         }
1051
1052         if (!ret && feed->type == DMX_TYPE_SEC) {
1053                 for (i = 0; i<demux->filternum; i++) {
1054                         if (demux->filter[i].state == DMX_STATE_GO &&
1055                             demux->filter[i].filter.parent == &feed->feed.sec) {
1056                                 demux->filter[i].state = DMX_STATE_READY;
1057                                 if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
1058                                         rc = StopHWFilter(&demux->filter[i]);
1059                                         if (!ret)
1060                                                 ret = rc;
1061                                         /* keep going, stop as many filters as possible */
1062                                 }
1063                         }
1064                 }
1065         }
1066
1067         return ret;
1068 }
1069
1070
1071 static void restart_feeds(struct av7110 *av7110)
1072 {
1073         struct dvb_demux *dvbdmx = &av7110->demux;
1074         struct dvb_demux_feed *feed;
1075         int mode;
1076         int i, j;
1077
1078         dprintk(4, "%p\n", av7110);
1079
1080         mode = av7110->playing;
1081         av7110->playing = 0;
1082         av7110->rec_mode = 0;
1083
1084         for (i = 0; i < dvbdmx->feednum; i++) {
1085                 feed = &dvbdmx->feed[i];
1086                 if (feed->state == DMX_STATE_GO) {
1087                         if (feed->type == DMX_TYPE_SEC) {
1088                                 for (j = 0; j < dvbdmx->filternum; j++) {
1089                                         if (dvbdmx->filter[j].type != DMX_TYPE_SEC)
1090                                                 continue;
1091                                         if (dvbdmx->filter[j].filter.parent != &feed->feed.sec)
1092                                                 continue;
1093                                         if (dvbdmx->filter[j].state == DMX_STATE_GO)
1094                                                 dvbdmx->filter[j].state = DMX_STATE_READY;
1095                                 }
1096                         }
1097                         av7110_start_feed(feed);
1098                 }
1099         }
1100
1101         if (mode)
1102                 av7110_av_start_play(av7110, mode);
1103 }
1104
1105 static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
1106                        uint64_t *stc, unsigned int *base)
1107 {
1108         int ret;
1109         u16 fwstc[4];
1110         u16 tag = ((COMTYPE_REQUEST << 8) + ReqSTC);
1111         struct dvb_demux *dvbdemux;
1112         struct av7110 *av7110;
1113
1114         /* pointer casting paranoia... */
1115         BUG_ON(!demux);
1116         dvbdemux = demux->priv;
1117         BUG_ON(!dvbdemux);
1118         av7110 = dvbdemux->priv;
1119
1120         dprintk(4, "%p\n", av7110);
1121
1122         if (num != 0)
1123                 return -EINVAL;
1124
1125         ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4);
1126         if (ret) {
1127                 printk(KERN_ERR "%s: av7110_fw_request error\n", __func__);
1128                 return ret;
1129         }
1130         dprintk(2, "fwstc = %04hx %04hx %04hx %04hx\n",
1131                 fwstc[0], fwstc[1], fwstc[2], fwstc[3]);
1132
1133         *stc =  (((uint64_t) ((fwstc[3] & 0x8000) >> 15)) << 32) |
1134                 (((uint64_t)  fwstc[1]) << 16) | ((uint64_t) fwstc[0]);
1135         *base = 1;
1136
1137         dprintk(4, "stc = %lu\n", (unsigned long)*stc);
1138
1139         return 0;
1140 }
1141
1142
1143 /******************************************************************************
1144  * SEC device file operations
1145  ******************************************************************************/
1146
1147
1148 static int av7110_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
1149 {
1150         struct av7110* av7110 = fe->dvb->priv;
1151
1152         switch (tone) {
1153         case SEC_TONE_ON:
1154                 return Set22K(av7110, 1);
1155
1156         case SEC_TONE_OFF:
1157                 return Set22K(av7110, 0);
1158
1159         default:
1160                 return -EINVAL;
1161         }
1162 }
1163
1164 static int av7110_diseqc_send_master_cmd(struct dvb_frontend* fe,
1165                                          struct dvb_diseqc_master_cmd* cmd)
1166 {
1167         struct av7110* av7110 = fe->dvb->priv;
1168
1169         return av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1);
1170 }
1171
1172 static int av7110_diseqc_send_burst(struct dvb_frontend* fe,
1173                                     fe_sec_mini_cmd_t minicmd)
1174 {
1175         struct av7110* av7110 = fe->dvb->priv;
1176
1177         return av7110_diseqc_send(av7110, 0, NULL, minicmd);
1178 }
1179
1180 /* simplified code from budget-core.c */
1181 static int stop_ts_capture(struct av7110 *budget)
1182 {
1183         dprintk(2, "budget: %p\n", budget);
1184
1185         if (--budget->feeding1)
1186                 return budget->feeding1;
1187         saa7146_write(budget->dev, MC1, MASK_20);       /* DMA3 off */
1188         SAA7146_IER_DISABLE(budget->dev, MASK_10);
1189         SAA7146_ISR_CLEAR(budget->dev, MASK_10);
1190         return 0;
1191 }
1192
1193 static int start_ts_capture(struct av7110 *budget)
1194 {
1195         dprintk(2, "budget: %p\n", budget);
1196
1197         if (budget->feeding1)
1198                 return ++budget->feeding1;
1199         memset(budget->grabbing, 0x00, TS_HEIGHT * TS_WIDTH);
1200         budget->tsf = 0xff;
1201         budget->ttbp = 0;
1202         SAA7146_IER_ENABLE(budget->dev, MASK_10); /* VPE */
1203         saa7146_write(budget->dev, MC1, (MASK_04 | MASK_20)); /* DMA3 on */
1204         return ++budget->feeding1;
1205 }
1206
1207 static int budget_start_feed(struct dvb_demux_feed *feed)
1208 {
1209         struct dvb_demux *demux = feed->demux;
1210         struct av7110 *budget = demux->priv;
1211         int status;
1212
1213         dprintk(2, "av7110: %p\n", budget);
1214
1215         spin_lock(&budget->feedlock1);
1216         feed->pusi_seen = 0; /* have a clean section start */
1217         status = start_ts_capture(budget);
1218         spin_unlock(&budget->feedlock1);
1219         return status;
1220 }
1221
1222 static int budget_stop_feed(struct dvb_demux_feed *feed)
1223 {
1224         struct dvb_demux *demux = feed->demux;
1225         struct av7110 *budget = demux->priv;
1226         int status;
1227
1228         dprintk(2, "budget: %p\n", budget);
1229
1230         spin_lock(&budget->feedlock1);
1231         status = stop_ts_capture(budget);
1232         spin_unlock(&budget->feedlock1);
1233         return status;
1234 }
1235
1236 static void vpeirq(unsigned long data)
1237 {
1238         struct av7110 *budget = (struct av7110 *) data;
1239         u8 *mem = (u8 *) (budget->grabbing);
1240         u32 olddma = budget->ttbp;
1241         u32 newdma = saa7146_read(budget->dev, PCI_VDP3);
1242
1243         if (!budgetpatch) {
1244                 printk("av7110.c: vpeirq() called while budgetpatch disabled!"
1245                        " check saa7146 IER register\n");
1246                 BUG();
1247         }
1248         /* nearest lower position divisible by 188 */
1249         newdma -= newdma % 188;
1250
1251         if (newdma >= TS_BUFLEN)
1252                 return;
1253
1254         budget->ttbp = newdma;
1255
1256         if (!budget->feeding1 || (newdma == olddma))
1257                 return;
1258
1259         /* Ensure streamed PCI data is synced to CPU */
1260         pci_dma_sync_sg_for_cpu(budget->dev->pci, budget->pt.slist, budget->pt.nents, PCI_DMA_FROMDEVICE);
1261
1262 #if 0
1263         /* track rps1 activity */
1264         printk("vpeirq: %02x Event Counter 1 0x%04x\n",
1265                mem[olddma],
1266                saa7146_read(budget->dev, EC1R) & 0x3fff);
1267 #endif
1268
1269         if (newdma > olddma)
1270                 /* no wraparound, dump olddma..newdma */
1271                 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (newdma - olddma) / 188);
1272         else {
1273                 /* wraparound, dump olddma..buflen and 0..newdma */
1274                 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (TS_BUFLEN - olddma) / 188);
1275                 dvb_dmx_swfilter_packets(&budget->demux1, mem, newdma / 188);
1276         }
1277 }
1278
1279 static int av7110_register(struct av7110 *av7110)
1280 {
1281         int ret, i;
1282         struct dvb_demux *dvbdemux = &av7110->demux;
1283         struct dvb_demux *dvbdemux1 = &av7110->demux1;
1284
1285         dprintk(4, "%p\n", av7110);
1286
1287         if (av7110->registered)
1288                 return -1;
1289
1290         av7110->registered = 1;
1291
1292         dvbdemux->priv = (void *) av7110;
1293
1294         for (i = 0; i < 32; i++)
1295                 av7110->handle2filter[i] = NULL;
1296
1297         dvbdemux->filternum = 32;
1298         dvbdemux->feednum = 32;
1299         dvbdemux->start_feed = av7110_start_feed;
1300         dvbdemux->stop_feed = av7110_stop_feed;
1301         dvbdemux->write_to_decoder = av7110_write_to_decoder;
1302         dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1303                                       DMX_MEMORY_BASED_FILTERING);
1304
1305         dvb_dmx_init(&av7110->demux);
1306         av7110->demux.dmx.get_stc = dvb_get_stc;
1307
1308         av7110->dmxdev.filternum = 32;
1309         av7110->dmxdev.demux = &dvbdemux->dmx;
1310         av7110->dmxdev.capabilities = 0;
1311
1312         dvb_dmxdev_init(&av7110->dmxdev, &av7110->dvb_adapter);
1313
1314         av7110->hw_frontend.source = DMX_FRONTEND_0;
1315
1316         ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1317
1318         if (ret < 0)
1319                 return ret;
1320
1321         av7110->mem_frontend.source = DMX_MEMORY_FE;
1322
1323         ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1324
1325         if (ret < 0)
1326                 return ret;
1327
1328         ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1329                                              &av7110->hw_frontend);
1330         if (ret < 0)
1331                 return ret;
1332
1333         av7110_av_register(av7110);
1334         av7110_ca_register(av7110);
1335
1336 #ifdef CONFIG_DVB_AV7110_OSD
1337         dvb_register_device(&av7110->dvb_adapter, &av7110->osd_dev,
1338                             &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1339 #endif
1340
1341         dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1342
1343         if (budgetpatch) {
1344                 /* initialize software demux1 without its own frontend
1345                  * demux1 hardware is connected to frontend0 of demux0
1346                  */
1347                 dvbdemux1->priv = (void *) av7110;
1348
1349                 dvbdemux1->filternum = 256;
1350                 dvbdemux1->feednum = 256;
1351                 dvbdemux1->start_feed = budget_start_feed;
1352                 dvbdemux1->stop_feed = budget_stop_feed;
1353                 dvbdemux1->write_to_decoder = NULL;
1354
1355                 dvbdemux1->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1356                                                DMX_MEMORY_BASED_FILTERING);
1357
1358                 dvb_dmx_init(&av7110->demux1);
1359
1360                 av7110->dmxdev1.filternum = 256;
1361                 av7110->dmxdev1.demux = &dvbdemux1->dmx;
1362                 av7110->dmxdev1.capabilities = 0;
1363
1364                 dvb_dmxdev_init(&av7110->dmxdev1, &av7110->dvb_adapter);
1365
1366                 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net1, &dvbdemux1->dmx);
1367                 printk("dvb-ttpci: additional demux1 for budget-patch registered\n");
1368         }
1369         return 0;
1370 }
1371
1372
1373 static void dvb_unregister(struct av7110 *av7110)
1374 {
1375         struct dvb_demux *dvbdemux = &av7110->demux;
1376         struct dvb_demux *dvbdemux1 = &av7110->demux1;
1377
1378         dprintk(4, "%p\n", av7110);
1379
1380         if (!av7110->registered)
1381                 return;
1382
1383         if (budgetpatch) {
1384                 dvb_net_release(&av7110->dvb_net1);
1385                 dvbdemux->dmx.close(&dvbdemux1->dmx);
1386                 dvb_dmxdev_release(&av7110->dmxdev1);
1387                 dvb_dmx_release(&av7110->demux1);
1388         }
1389
1390         dvb_net_release(&av7110->dvb_net);
1391
1392         dvbdemux->dmx.close(&dvbdemux->dmx);
1393         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1394         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1395
1396         dvb_dmxdev_release(&av7110->dmxdev);
1397         dvb_dmx_release(&av7110->demux);
1398
1399         if (av7110->fe != NULL) {
1400                 dvb_unregister_frontend(av7110->fe);
1401                 dvb_frontend_detach(av7110->fe);
1402         }
1403         dvb_unregister_device(av7110->osd_dev);
1404         av7110_av_unregister(av7110);
1405         av7110_ca_unregister(av7110);
1406 }
1407
1408
1409 /****************************************************************************
1410  * I2C client commands
1411  ****************************************************************************/
1412
1413 int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1414 {
1415         u8 msg[2] = { reg, val };
1416         struct i2c_msg msgs;
1417
1418         msgs.flags = 0;
1419         msgs.addr = id / 2;
1420         msgs.len = 2;
1421         msgs.buf = msg;
1422         return i2c_transfer(&av7110->i2c_adap, &msgs, 1);
1423 }
1424
1425 #if 0
1426 u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1427 {
1428         u8 mm1[] = {0x00};
1429         u8 mm2[] = {0x00};
1430         struct i2c_msg msgs[2];
1431
1432         msgs[0].flags = 0;
1433         msgs[1].flags = I2C_M_RD;
1434         msgs[0].addr = msgs[1].addr = id / 2;
1435         mm1[0] = reg;
1436         msgs[0].len = 1; msgs[1].len = 1;
1437         msgs[0].buf = mm1; msgs[1].buf = mm2;
1438         i2c_transfer(&av7110->i2c_adap, msgs, 2);
1439
1440         return mm2[0];
1441 }
1442 #endif
1443
1444 /****************************************************************************
1445  * INITIALIZATION
1446  ****************************************************************************/
1447
1448
1449 static int check_firmware(struct av7110* av7110)
1450 {
1451         u32 crc = 0, len = 0;
1452         unsigned char *ptr;
1453
1454         /* check for firmware magic */
1455         ptr = av7110->bin_fw;
1456         if (ptr[0] != 'A' || ptr[1] != 'V' ||
1457             ptr[2] != 'F' || ptr[3] != 'W') {
1458                 printk("dvb-ttpci: this is not an av7110 firmware\n");
1459                 return -EINVAL;
1460         }
1461         ptr += 4;
1462
1463         /* check dpram file */
1464         crc = ntohl(*(u32*) ptr);
1465         ptr += 4;
1466         len = ntohl(*(u32*) ptr);
1467         ptr += 4;
1468         if (len >= 512) {
1469                 printk("dvb-ttpci: dpram file is way too big.\n");
1470                 return -EINVAL;
1471         }
1472         if (crc != crc32_le(0, ptr, len)) {
1473                 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1474                 return -EINVAL;
1475         }
1476         av7110->bin_dpram = ptr;
1477         av7110->size_dpram = len;
1478         ptr += len;
1479
1480         /* check root file */
1481         crc = ntohl(*(u32*) ptr);
1482         ptr += 4;
1483         len = ntohl(*(u32*) ptr);
1484         ptr += 4;
1485
1486         if (len <= 200000 || len >= 300000 ||
1487             len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1488                 printk("dvb-ttpci: root file has strange size (%d). aborting.\n", len);
1489                 return -EINVAL;
1490         }
1491         if( crc != crc32_le(0, ptr, len)) {
1492                 printk("dvb-ttpci: crc32 of root file does not match.\n");
1493                 return -EINVAL;
1494         }
1495         av7110->bin_root = ptr;
1496         av7110->size_root = len;
1497         return 0;
1498 }
1499
1500 #ifdef CONFIG_DVB_AV7110_FIRMWARE_FILE
1501 #include "av7110_firm.h"
1502 static void put_firmware(struct av7110* av7110)
1503 {
1504         av7110->bin_fw = NULL;
1505 }
1506
1507 static inline int get_firmware(struct av7110* av7110)
1508 {
1509         av7110->bin_fw = dvb_ttpci_fw;
1510         av7110->size_fw = sizeof(dvb_ttpci_fw);
1511         return check_firmware(av7110);
1512 }
1513 #else
1514 static void put_firmware(struct av7110* av7110)
1515 {
1516         vfree(av7110->bin_fw);
1517 }
1518
1519 static int get_firmware(struct av7110* av7110)
1520 {
1521         int ret;
1522         const struct firmware *fw;
1523
1524         /* request the av7110 firmware, this will block until someone uploads it */
1525         ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev);
1526         if (ret) {
1527                 if (ret == -ENOENT) {
1528                         printk(KERN_ERR "dvb-ttpci: could not load firmware,"
1529                                " file not found: dvb-ttpci-01.fw\n");
1530                         printk(KERN_ERR "dvb-ttpci: usually this should be in "
1531                                "/usr/lib/hotplug/firmware or /lib/firmware\n");
1532                         printk(KERN_ERR "dvb-ttpci: and can be downloaded from"
1533                                " http://www.linuxtv.org/download/dvb/firmware/\n");
1534                 } else
1535                         printk(KERN_ERR "dvb-ttpci: cannot request firmware"
1536                                " (error %i)\n", ret);
1537                 return -EINVAL;
1538         }
1539
1540         if (fw->size <= 200000) {
1541                 printk("dvb-ttpci: this firmware is way too small.\n");
1542                 release_firmware(fw);
1543                 return -EINVAL;
1544         }
1545
1546         /* check if the firmware is available */
1547         av7110->bin_fw = vmalloc(fw->size);
1548         if (NULL == av7110->bin_fw) {
1549                 dprintk(1, "out of memory\n");
1550                 release_firmware(fw);
1551                 return -ENOMEM;
1552         }
1553
1554         memcpy(av7110->bin_fw, fw->data, fw->size);
1555         av7110->size_fw = fw->size;
1556         if ((ret = check_firmware(av7110)))
1557                 vfree(av7110->bin_fw);
1558
1559         release_firmware(fw);
1560         return ret;
1561 }
1562 #endif
1563
1564
1565 static int alps_bsrv2_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1566 {
1567         struct av7110* av7110 = fe->dvb->priv;
1568         u8 pwr = 0;
1569         u8 buf[4];
1570         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) };
1571         u32 div = (params->frequency + 479500) / 125;
1572
1573         if (params->frequency > 2000000) pwr = 3;
1574         else if (params->frequency > 1800000) pwr = 2;
1575         else if (params->frequency > 1600000) pwr = 1;
1576         else if (params->frequency > 1200000) pwr = 0;
1577         else if (params->frequency >= 1100000) pwr = 1;
1578         else pwr = 2;
1579
1580         buf[0] = (div >> 8) & 0x7f;
1581         buf[1] = div & 0xff;
1582         buf[2] = ((div & 0x18000) >> 10) | 0x95;
1583         buf[3] = (pwr << 6) | 0x30;
1584
1585         // NOTE: since we're using a prescaler of 2, we set the
1586         // divisor frequency to 62.5kHz and divide by 125 above
1587
1588         if (fe->ops.i2c_gate_ctrl)
1589                 fe->ops.i2c_gate_ctrl(fe, 1);
1590         if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1591                 return -EIO;
1592         return 0;
1593 }
1594
1595 static struct ves1x93_config alps_bsrv2_config = {
1596         .demod_address = 0x08,
1597         .xin = 90100000UL,
1598         .invert_pwm = 0,
1599 };
1600
1601 static int alps_tdbe2_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1602 {
1603         struct av7110* av7110 = fe->dvb->priv;
1604         u32 div;
1605         u8 data[4];
1606         struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1607
1608         div = (params->frequency + 35937500 + 31250) / 62500;
1609
1610         data[0] = (div >> 8) & 0x7f;
1611         data[1] = div & 0xff;
1612         data[2] = 0x85 | ((div >> 10) & 0x60);
1613         data[3] = (params->frequency < 174000000 ? 0x88 : params->frequency < 470000000 ? 0x84 : 0x81);
1614
1615         if (fe->ops.i2c_gate_ctrl)
1616                 fe->ops.i2c_gate_ctrl(fe, 1);
1617         if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1618                 return -EIO;
1619         return 0;
1620 }
1621
1622 static struct ves1820_config alps_tdbe2_config = {
1623         .demod_address = 0x09,
1624         .xin = 57840000UL,
1625         .invert = 1,
1626         .selagc = VES1820_SELAGC_SIGNAMPERR,
1627 };
1628
1629
1630
1631
1632 static int grundig_29504_451_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1633 {
1634         struct av7110* av7110 = fe->dvb->priv;
1635         u32 div;
1636         u8 data[4];
1637         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1638
1639         div = params->frequency / 125;
1640         data[0] = (div >> 8) & 0x7f;
1641         data[1] = div & 0xff;
1642         data[2] = 0x8e;
1643         data[3] = 0x00;
1644
1645         if (fe->ops.i2c_gate_ctrl)
1646                 fe->ops.i2c_gate_ctrl(fe, 1);
1647         if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1648                 return -EIO;
1649         return 0;
1650 }
1651
1652 static struct tda8083_config grundig_29504_451_config = {
1653         .demod_address = 0x68,
1654 };
1655
1656
1657
1658 static int philips_cd1516_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1659 {
1660         struct av7110* av7110 = fe->dvb->priv;
1661         u32 div;
1662         u32 f = params->frequency;
1663         u8 data[4];
1664         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1665
1666         div = (f + 36125000 + 31250) / 62500;
1667
1668         data[0] = (div >> 8) & 0x7f;
1669         data[1] = div & 0xff;
1670         data[2] = 0x8e;
1671         data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1672
1673         if (fe->ops.i2c_gate_ctrl)
1674                 fe->ops.i2c_gate_ctrl(fe, 1);
1675         if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1676                 return -EIO;
1677         return 0;
1678 }
1679
1680 static struct ves1820_config philips_cd1516_config = {
1681         .demod_address = 0x09,
1682         .xin = 57840000UL,
1683         .invert = 1,
1684         .selagc = VES1820_SELAGC_SIGNAMPERR,
1685 };
1686
1687
1688
1689 static int alps_tdlb7_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1690 {
1691         struct av7110* av7110 = fe->dvb->priv;
1692         u32 div, pwr;
1693         u8 data[4];
1694         struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1695
1696         div = (params->frequency + 36200000) / 166666;
1697
1698         if (params->frequency <= 782000000)
1699                 pwr = 1;
1700         else
1701                 pwr = 2;
1702
1703         data[0] = (div >> 8) & 0x7f;
1704         data[1] = div & 0xff;
1705         data[2] = 0x85;
1706         data[3] = pwr << 6;
1707
1708         if (fe->ops.i2c_gate_ctrl)
1709                 fe->ops.i2c_gate_ctrl(fe, 1);
1710         if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1711                 return -EIO;
1712         return 0;
1713 }
1714
1715 static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1716 {
1717 #if defined(CONFIG_DVB_SP8870) || defined(CONFIG_DVB_SP8870_MODULE)
1718         struct av7110* av7110 = fe->dvb->priv;
1719
1720         return request_firmware(fw, name, &av7110->dev->pci->dev);
1721 #else
1722         return -EINVAL;
1723 #endif
1724 }
1725
1726 static struct sp8870_config alps_tdlb7_config = {
1727
1728         .demod_address = 0x71,
1729         .request_firmware = alps_tdlb7_request_firmware,
1730 };
1731
1732
1733 static u8 nexusca_stv0297_inittab[] = {
1734         0x80, 0x01,
1735         0x80, 0x00,
1736         0x81, 0x01,
1737         0x81, 0x00,
1738         0x00, 0x09,
1739         0x01, 0x69,
1740         0x03, 0x00,
1741         0x04, 0x00,
1742         0x07, 0x00,
1743         0x08, 0x00,
1744         0x20, 0x00,
1745         0x21, 0x40,
1746         0x22, 0x00,
1747         0x23, 0x00,
1748         0x24, 0x40,
1749         0x25, 0x88,
1750         0x30, 0xff,
1751         0x31, 0x00,
1752         0x32, 0xff,
1753         0x33, 0x00,
1754         0x34, 0x50,
1755         0x35, 0x7f,
1756         0x36, 0x00,
1757         0x37, 0x20,
1758         0x38, 0x00,
1759         0x40, 0x1c,
1760         0x41, 0xff,
1761         0x42, 0x29,
1762         0x43, 0x00,
1763         0x44, 0xff,
1764         0x45, 0x00,
1765         0x46, 0x00,
1766         0x49, 0x04,
1767         0x4a, 0x00,
1768         0x4b, 0x7b,
1769         0x52, 0x30,
1770         0x55, 0xae,
1771         0x56, 0x47,
1772         0x57, 0xe1,
1773         0x58, 0x3a,
1774         0x5a, 0x1e,
1775         0x5b, 0x34,
1776         0x60, 0x00,
1777         0x63, 0x00,
1778         0x64, 0x00,
1779         0x65, 0x00,
1780         0x66, 0x00,
1781         0x67, 0x00,
1782         0x68, 0x00,
1783         0x69, 0x00,
1784         0x6a, 0x02,
1785         0x6b, 0x00,
1786         0x70, 0xff,
1787         0x71, 0x00,
1788         0x72, 0x00,
1789         0x73, 0x00,
1790         0x74, 0x0c,
1791         0x80, 0x00,
1792         0x81, 0x00,
1793         0x82, 0x00,
1794         0x83, 0x00,
1795         0x84, 0x04,
1796         0x85, 0x80,
1797         0x86, 0x24,
1798         0x87, 0x78,
1799         0x88, 0x10,
1800         0x89, 0x00,
1801         0x90, 0x01,
1802         0x91, 0x01,
1803         0xa0, 0x04,
1804         0xa1, 0x00,
1805         0xa2, 0x00,
1806         0xb0, 0x91,
1807         0xb1, 0x0b,
1808         0xc0, 0x53,
1809         0xc1, 0x70,
1810         0xc2, 0x12,
1811         0xd0, 0x00,
1812         0xd1, 0x00,
1813         0xd2, 0x00,
1814         0xd3, 0x00,
1815         0xd4, 0x00,
1816         0xd5, 0x00,
1817         0xde, 0x00,
1818         0xdf, 0x00,
1819         0x61, 0x49,
1820         0x62, 0x0b,
1821         0x53, 0x08,
1822         0x59, 0x08,
1823         0xff, 0xff,
1824 };
1825
1826 static int nexusca_stv0297_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1827 {
1828         struct av7110* av7110 = fe->dvb->priv;
1829         u32 div;
1830         u8 data[4];
1831         struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
1832         struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
1833         int i;
1834
1835         div = (params->frequency + 36150000 + 31250) / 62500;
1836
1837         data[0] = (div >> 8) & 0x7f;
1838         data[1] = div & 0xff;
1839         data[2] = 0xce;
1840
1841         if (params->frequency < 45000000)
1842                 return -EINVAL;
1843         else if (params->frequency < 137000000)
1844                 data[3] = 0x01;
1845         else if (params->frequency < 403000000)
1846                 data[3] = 0x02;
1847         else if (params->frequency < 860000000)
1848                 data[3] = 0x04;
1849         else
1850                 return -EINVAL;
1851
1852         if (fe->ops.i2c_gate_ctrl)
1853                 fe->ops.i2c_gate_ctrl(fe, 1);
1854         if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) {
1855                 printk("nexusca: pll transfer failed!\n");
1856                 return -EIO;
1857         }
1858
1859         // wait for PLL lock
1860         for(i = 0; i < 20; i++) {
1861                 if (fe->ops.i2c_gate_ctrl)
1862                         fe->ops.i2c_gate_ctrl(fe, 1);
1863                 if (i2c_transfer(&av7110->i2c_adap, &readmsg, 1) == 1)
1864                         if (data[0] & 0x40) break;
1865                 msleep(10);
1866         }
1867
1868         return 0;
1869 }
1870
1871 static struct stv0297_config nexusca_stv0297_config = {
1872
1873         .demod_address = 0x1C,
1874         .inittab = nexusca_stv0297_inittab,
1875         .invert = 1,
1876         .stop_during_read = 1,
1877 };
1878
1879
1880
1881 static int grundig_29504_401_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1882 {
1883         struct av7110* av7110 = fe->dvb->priv;
1884         u32 div;
1885         u8 cfg, cpump, band_select;
1886         u8 data[4];
1887         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1888
1889         div = (36125000 + params->frequency) / 166666;
1890
1891         cfg = 0x88;
1892
1893         if (params->frequency < 175000000) cpump = 2;
1894         else if (params->frequency < 390000000) cpump = 1;
1895         else if (params->frequency < 470000000) cpump = 2;
1896         else if (params->frequency < 750000000) cpump = 1;
1897         else cpump = 3;
1898
1899         if (params->frequency < 175000000) band_select = 0x0e;
1900         else if (params->frequency < 470000000) band_select = 0x05;
1901         else band_select = 0x03;
1902
1903         data[0] = (div >> 8) & 0x7f;
1904         data[1] = div & 0xff;
1905         data[2] = ((div >> 10) & 0x60) | cfg;
1906         data[3] = (cpump << 6) | band_select;
1907
1908         if (fe->ops.i2c_gate_ctrl)
1909                 fe->ops.i2c_gate_ctrl(fe, 1);
1910         if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) return -EIO;
1911         return 0;
1912 }
1913
1914 static struct l64781_config grundig_29504_401_config = {
1915         .demod_address = 0x55,
1916 };
1917
1918
1919
1920 static int av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
1921 {
1922         int ret = 0;
1923         int synced = (status & FE_HAS_LOCK) ? 1 : 0;
1924
1925         av7110->fe_status = status;
1926
1927         if (av7110->fe_synced == synced)
1928                 return 0;
1929
1930         if (av7110->playing) {
1931                 av7110->fe_synced = synced;
1932                 return 0;
1933         }
1934
1935         if (mutex_lock_interruptible(&av7110->pid_mutex))
1936                 return -ERESTARTSYS;
1937
1938         if (synced) {
1939                 ret = SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
1940                         av7110->pids[DMX_PES_AUDIO],
1941                         av7110->pids[DMX_PES_TELETEXT], 0,
1942                         av7110->pids[DMX_PES_PCR]);
1943                 if (!ret)
1944                         ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
1945         } else {
1946                 ret = SetPIDs(av7110, 0, 0, 0, 0, 0);
1947                 if (!ret) {
1948                         ret = av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
1949                         if (!ret)
1950                                 ret = av7110_wait_msgstate(av7110, GPMQBusy);
1951                 }
1952         }
1953
1954         if (!ret)
1955                 av7110->fe_synced = synced;
1956
1957         mutex_unlock(&av7110->pid_mutex);
1958         return ret;
1959 }
1960
1961 static int av7110_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1962 {
1963         struct av7110* av7110 = fe->dvb->priv;
1964
1965         int ret = av7110_fe_lock_fix(av7110, 0);
1966         if (!ret) {
1967                 av7110->saved_fe_params = *params;
1968                 ret = av7110->fe_set_frontend(fe, params);
1969         }
1970         return ret;
1971 }
1972
1973 static int av7110_fe_init(struct dvb_frontend* fe)
1974 {
1975         struct av7110* av7110 = fe->dvb->priv;
1976
1977         int ret = av7110_fe_lock_fix(av7110, 0);
1978         if (!ret)
1979                 ret = av7110->fe_init(fe);
1980         return ret;
1981 }
1982
1983 static int av7110_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
1984 {
1985         struct av7110* av7110 = fe->dvb->priv;
1986
1987         /* call the real implementation */
1988         int ret = av7110->fe_read_status(fe, status);
1989         if (!ret)
1990                 if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK))
1991                         ret = av7110_fe_lock_fix(av7110, *status);
1992         return ret;
1993 }
1994
1995 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
1996 {
1997         struct av7110* av7110 = fe->dvb->priv;
1998
1999         int ret = av7110_fe_lock_fix(av7110, 0);
2000         if (!ret)
2001                 ret = av7110->fe_diseqc_reset_overload(fe);
2002         return ret;
2003 }
2004
2005 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
2006                                             struct dvb_diseqc_master_cmd* cmd)
2007 {
2008         struct av7110* av7110 = fe->dvb->priv;
2009
2010         int ret = av7110_fe_lock_fix(av7110, 0);
2011         if (!ret) {
2012                 av7110->saved_master_cmd = *cmd;
2013                 ret = av7110->fe_diseqc_send_master_cmd(fe, cmd);
2014         }
2015         return ret;
2016 }
2017
2018 static int av7110_fe_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t minicmd)
2019 {
2020         struct av7110* av7110 = fe->dvb->priv;
2021
2022         int ret = av7110_fe_lock_fix(av7110, 0);
2023         if (!ret) {
2024                 av7110->saved_minicmd = minicmd;
2025                 ret = av7110->fe_diseqc_send_burst(fe, minicmd);
2026         }
2027         return ret;
2028 }
2029
2030 static int av7110_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
2031 {
2032         struct av7110* av7110 = fe->dvb->priv;
2033
2034         int ret = av7110_fe_lock_fix(av7110, 0);
2035         if (!ret) {
2036                 av7110->saved_tone = tone;
2037                 ret = av7110->fe_set_tone(fe, tone);
2038         }
2039         return ret;
2040 }
2041
2042 static int av7110_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
2043 {
2044         struct av7110* av7110 = fe->dvb->priv;
2045
2046         int ret = av7110_fe_lock_fix(av7110, 0);
2047         if (!ret) {
2048                 av7110->saved_voltage = voltage;
2049                 ret = av7110->fe_set_voltage(fe, voltage);
2050         }
2051         return ret;
2052 }
2053
2054 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned long cmd)
2055 {
2056         struct av7110* av7110 = fe->dvb->priv;
2057
2058         int ret = av7110_fe_lock_fix(av7110, 0);
2059         if (!ret)
2060                 ret = av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
2061         return ret;
2062 }
2063
2064 static void dvb_s_recover(struct av7110* av7110)
2065 {
2066         av7110_fe_init(av7110->fe);
2067
2068         av7110_fe_set_voltage(av7110->fe, av7110->saved_voltage);
2069         if (av7110->saved_master_cmd.msg_len) {
2070                 msleep(20);
2071                 av7110_fe_diseqc_send_master_cmd(av7110->fe, &av7110->saved_master_cmd);
2072         }
2073         msleep(20);
2074         av7110_fe_diseqc_send_burst(av7110->fe, av7110->saved_minicmd);
2075         msleep(20);
2076         av7110_fe_set_tone(av7110->fe, av7110->saved_tone);
2077
2078         av7110_fe_set_frontend(av7110->fe, &av7110->saved_fe_params);
2079 }
2080
2081 static u8 read_pwm(struct av7110* av7110)
2082 {
2083         u8 b = 0xff;
2084         u8 pwm;
2085         struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
2086                                  { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
2087
2088         if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
2089                 pwm = 0x48;
2090
2091         return pwm;
2092 }
2093
2094 static int frontend_init(struct av7110 *av7110)
2095 {
2096         int ret;
2097
2098         if (av7110->dev->pci->subsystem_vendor == 0x110a) {
2099                 switch(av7110->dev->pci->subsystem_device) {
2100                 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
2101                         av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config,
2102                                                     &av7110->i2c_adap, read_pwm(av7110));
2103                         if (av7110->fe) {
2104                                 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2105                         }
2106                         break;
2107                 }
2108
2109         } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
2110                 switch(av7110->dev->pci->subsystem_device) {
2111                 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
2112                 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
2113                 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
2114
2115                         // try the ALPS BSRV2 first of all
2116                         av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2117                         if (av7110->fe) {
2118                                 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2119                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2120                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2121                                 av7110->fe->ops.set_tone = av7110_set_tone;
2122                                 av7110->recover = dvb_s_recover;
2123                                 break;
2124                         }
2125
2126                         // try the ALPS BSRU6 now
2127                         av7110->fe = dvb_attach(stv0299_attach, &alps_bsru6_config, &av7110->i2c_adap);
2128                         if (av7110->fe) {
2129                                 av7110->fe->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
2130                                 av7110->fe->tuner_priv = &av7110->i2c_adap;
2131
2132                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2133                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2134                                 av7110->fe->ops.set_tone = av7110_set_tone;
2135                                 av7110->recover = dvb_s_recover;
2136                                 break;
2137                         }
2138
2139                         // Try the grundig 29504-451
2140                         av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2141                         if (av7110->fe) {
2142                                 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2143                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2144                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2145                                 av7110->fe->ops.set_tone = av7110_set_tone;
2146                                 av7110->recover = dvb_s_recover;
2147                                 break;
2148                         }
2149
2150                         /* Try DVB-C cards */
2151                         switch(av7110->dev->pci->subsystem_device) {
2152                         case 0x0000:
2153                                 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
2154                                 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config, &av7110->i2c_adap,
2155                                                         read_pwm(av7110));
2156                                 if (av7110->fe) {
2157                                         av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2158                                 }
2159                                 break;
2160                         case 0x0003:
2161                                 /* Hauppauge DVB-C 2.1 VES1820/ALPS TDBE2 */
2162                                 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap,
2163                                                         read_pwm(av7110));
2164                                 if (av7110->fe) {
2165                                         av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2166                                 }
2167                                 break;
2168                         }
2169                         break;
2170
2171                 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
2172                         // try ALPS TDLB7 first, then Grundig 29504-401
2173                         av7110->fe = dvb_attach(sp8870_attach, &alps_tdlb7_config, &av7110->i2c_adap);
2174                         if (av7110->fe) {
2175                                 av7110->fe->ops.tuner_ops.set_params = alps_tdlb7_tuner_set_params;
2176                                 break;
2177                         }
2178                         /* fall-thru */
2179
2180                 case 0x0008: // Hauppauge/TT DVB-T
2181                         // Grundig 29504-401
2182                         av7110->fe = dvb_attach(l64781_attach, &grundig_29504_401_config, &av7110->i2c_adap);
2183                         if (av7110->fe)
2184                                 av7110->fe->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params;
2185                         break;
2186
2187                 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
2188
2189                         av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
2190                         if (av7110->fe) {
2191                                 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2192                         }
2193                         break;
2194
2195                 case 0x0004: // Galaxis DVB-S rev1.3
2196                         /* ALPS BSRV2 */
2197                         av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2198                         if (av7110->fe) {
2199                                 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2200                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2201                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2202                                 av7110->fe->ops.set_tone = av7110_set_tone;
2203                                 av7110->recover = dvb_s_recover;
2204                         }
2205                         break;
2206
2207                 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
2208                         /* Grundig 29504-451 */
2209                         av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2210                         if (av7110->fe) {
2211                                 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2212                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2213                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2214                                 av7110->fe->ops.set_tone = av7110_set_tone;
2215                                 av7110->recover = dvb_s_recover;
2216                         }
2217                         break;
2218
2219                 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
2220
2221                         av7110->fe = dvb_attach(stv0297_attach, &nexusca_stv0297_config, &av7110->i2c_adap);
2222                         if (av7110->fe) {
2223                                 av7110->fe->ops.tuner_ops.set_params = nexusca_stv0297_tuner_set_params;
2224
2225                                 /* set TDA9819 into DVB mode */
2226                                 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
2227                                 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
2228
2229                                 /* tuner on this needs a slower i2c bus speed */
2230                                 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
2231                                 break;
2232                         }
2233                         break;
2234
2235                 case 0x000E: /* Hauppauge/TT Nexus-S rev 2.3 */
2236                         /* ALPS BSBE1 */
2237                         av7110->fe = dvb_attach(stv0299_attach, &alps_bsbe1_config, &av7110->i2c_adap);
2238                         if (av7110->fe) {
2239                                 av7110->fe->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
2240                                 av7110->fe->tuner_priv = &av7110->i2c_adap;
2241
2242                                 if (dvb_attach(lnbp21_attach, av7110->fe, &av7110->i2c_adap, 0, 0) == NULL) {
2243                                         printk("dvb-ttpci: LNBP21 not found!\n");
2244                                         if (av7110->fe->ops.release)
2245                                                 av7110->fe->ops.release(av7110->fe);
2246                                         av7110->fe = NULL;
2247                                 } else {
2248                                         av7110->fe->ops.dishnetwork_send_legacy_command = NULL;
2249                                         av7110->recover = dvb_s_recover;
2250                                 }
2251                         }
2252                         break;
2253                 }
2254         }
2255
2256         if (!av7110->fe) {
2257                 /* FIXME: propagate the failure code from the lower layers */
2258                 ret = -ENOMEM;
2259                 printk("dvb-ttpci: A frontend driver was not found for device %04x/%04x subsystem %04x/%04x\n",
2260                        av7110->dev->pci->vendor,
2261                        av7110->dev->pci->device,
2262                        av7110->dev->pci->subsystem_vendor,
2263                        av7110->dev->pci->subsystem_device);
2264         } else {
2265                 FE_FUNC_OVERRIDE(av7110->fe->ops.init, av7110->fe_init, av7110_fe_init);
2266                 FE_FUNC_OVERRIDE(av7110->fe->ops.read_status, av7110->fe_read_status, av7110_fe_read_status);
2267                 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
2268                 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
2269                 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
2270                 FE_FUNC_OVERRIDE(av7110->fe->ops.set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
2271                 FE_FUNC_OVERRIDE(av7110->fe->ops.set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage);
2272                 FE_FUNC_OVERRIDE(av7110->fe->ops.dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
2273                 FE_FUNC_OVERRIDE(av7110->fe->ops.set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
2274
2275                 ret = dvb_register_frontend(&av7110->dvb_adapter, av7110->fe);
2276                 if (ret < 0) {
2277                         printk("av7110: Frontend registration failed!\n");
2278                         dvb_frontend_detach(av7110->fe);
2279                         av7110->fe = NULL;
2280                 }
2281         }
2282         return ret;
2283 }
2284
2285 /* Budgetpatch note:
2286  * Original hardware design by Roberto Deza:
2287  * There is a DVB_Wiki at
2288  * http://212.227.36.83/linuxtv/wiki/index.php/Main_Page
2289  * where is described this 'DVB TT Budget Patch', on Card Modding:
2290  * http://212.227.36.83/linuxtv/wiki/index.php/DVB_TT_Budget_Patch
2291  * On the short description there is also a link to a external file,
2292  * with more details:
2293  * http://perso.wanadoo.es/jesussolano/Ttf_tsc1.zip
2294  *
2295  * New software triggering design by Emard that works on
2296  * original Roberto Deza's hardware:
2297  *
2298  * rps1 code for budgetpatch will copy internal HS event to GPIO3 pin.
2299  * GPIO3 is in budget-patch hardware connectd to port B VSYNC
2300  * HS is an internal event of 7146, accessible with RPS
2301  * and temporarily raised high every n lines
2302  * (n in defined in the RPS_THRESH1 counter threshold)
2303  * I think HS is raised high on the beginning of the n-th line
2304  * and remains high until this n-th line that triggered
2305  * it is completely received. When the receiption of n-th line
2306  * ends, HS is lowered.
2307  *
2308  * To transmit data over DMA, 7146 needs changing state at
2309  * port B VSYNC pin. Any changing of port B VSYNC will
2310  * cause some DMA data transfer, with more or less packets loss.
2311  * It depends on the phase and frequency of VSYNC and
2312  * the way of 7146 is instructed to trigger on port B (defined
2313  * in DD1_INIT register, 3rd nibble from the right valid
2314  * numbers are 0-7, see datasheet)
2315  *
2316  * The correct triggering can minimize packet loss,
2317  * dvbtraffic should give this stable bandwidths:
2318  *   22k transponder = 33814 kbit/s
2319  * 27.5k transponder = 38045 kbit/s
2320  * by experiment it is found that the best results
2321  * (stable bandwidths and almost no packet loss)
2322  * are obtained using DD1_INIT triggering number 2
2323  * (Va at rising edge of VS Fa = HS x VS-failing forced toggle)
2324  * and a VSYNC phase that occurs in the middle of DMA transfer
2325  * (about byte 188*512=96256 in the DMA window).
2326  *
2327  * Phase of HS is still not clear to me how to control,
2328  * It just happens to be so. It can be seen if one enables
2329  * RPS_IRQ and print Event Counter 1 in vpeirq(). Every
2330  * time RPS_INTERRUPT is called, the Event Counter 1 will
2331  * increment. That's how the 7146 is programmed to do event
2332  * counting in this budget-patch.c
2333  * I *think* HPS setting has something to do with the phase
2334  * of HS but I cant be 100% sure in that.
2335  *
2336  * hardware debug note: a working budget card (including budget patch)
2337  * with vpeirq() interrupt setup in mode "0x90" (every 64K) will
2338  * generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes
2339  * and that means 3*25=75 Hz of interrupt freqency, as seen by
2340  * watch cat /proc/interrupts
2341  *
2342  * If this frequency is 3x lower (and data received in the DMA
2343  * buffer don't start with 0x47, but in the middle of packets,
2344  * whose lengths appear to be like 188 292 188 104 etc.
2345  * this means VSYNC line is not connected in the hardware.
2346  * (check soldering pcb and pins)
2347  * The same behaviour of missing VSYNC can be duplicated on budget
2348  * cards, by seting DD1_INIT trigger mode 7 in 3rd nibble.
2349  */
2350 static int __devinit av7110_attach(struct saa7146_dev* dev,
2351                                    struct saa7146_pci_extension_data *pci_ext)
2352 {
2353         const int length = TS_WIDTH * TS_HEIGHT;
2354         struct pci_dev *pdev = dev->pci;
2355         struct av7110 *av7110;
2356         struct task_struct *thread;
2357         int ret, count = 0;
2358
2359         dprintk(4, "dev: %p\n", dev);
2360
2361         /* Set RPS_IRQ to 1 to track rps1 activity.
2362          * Enabling this won't send any interrupt to PC CPU.
2363          */
2364 #define RPS_IRQ 0
2365
2366         if (budgetpatch == 1) {
2367                 budgetpatch = 0;
2368                 /* autodetect the presence of budget patch
2369                  * this only works if saa7146 has been recently
2370                  * reset with with MASK_31 to MC1
2371                  *
2372                  * will wait for VBI_B event (vertical blank at port B)
2373                  * and will reset GPIO3 after VBI_B is detected.
2374                  * (GPIO3 should be raised high by CPU to
2375                  * test if GPIO3 will generate vertical blank signal
2376                  * in budget patch GPIO3 is connected to VSYNC_B
2377                  */
2378
2379                 /* RESET SAA7146 */
2380                 saa7146_write(dev, MC1, MASK_31);
2381                 /* autodetection success seems to be time-dependend after reset */
2382
2383                 /* Fix VSYNC level */
2384                 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2385                 /* set vsync_b triggering */
2386                 saa7146_write(dev, DD1_STREAM_B, 0);
2387                 /* port B VSYNC at rising edge */
2388                 saa7146_write(dev, DD1_INIT, 0x00000200);
2389                 saa7146_write(dev, BRS_CTRL, 0x00000000);  // VBI
2390                 saa7146_write(dev, MC2,
2391                               1 * (MASK_08 | MASK_24)  |   // BRS control
2392                               0 * (MASK_09 | MASK_25)  |   // a
2393                               1 * (MASK_10 | MASK_26)  |   // b
2394                               0 * (MASK_06 | MASK_22)  |   // HPS_CTRL1
2395                               0 * (MASK_05 | MASK_21)  |   // HPS_CTRL2
2396                               0 * (MASK_01 | MASK_15)      // DEBI
2397                 );
2398
2399                 /* start writing RPS1 code from beginning */
2400                 count = 0;
2401                 /* Disable RPS1 */
2402                 saa7146_write(dev, MC1, MASK_29);
2403                 /* RPS1 timeout disable */
2404                 saa7146_write(dev, RPS_TOV1, 0);
2405                 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_VBI_B));
2406                 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2407                 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2408                 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTLO<<24));
2409 #if RPS_IRQ
2410                 /* issue RPS1 interrupt to increment counter */
2411                 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2412 #endif
2413                 WRITE_RPS1(cpu_to_le32(CMD_STOP));
2414                 /* Jump to begin of RPS program as safety measure               (p37) */
2415                 WRITE_RPS1(cpu_to_le32(CMD_JUMP));
2416                 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle));
2417
2418 #if RPS_IRQ
2419                 /* set event counter 1 source as RPS1 interrupt (0x03)          (rE4 p53)
2420                  * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2421                  * use 0x15 to track VPE  interrupts - increase by 1 every vpeirq() is called
2422                  */
2423                 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2424                 /* set event counter 1 treshold to maximum allowed value        (rEC p55) */
2425                 saa7146_write(dev, ECT1R,  0x3fff );
2426 #endif
2427                 /* Set RPS1 Address register to point to RPS code               (r108 p42) */
2428                 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2429                 /* Enable RPS1,                                                 (rFC p33) */
2430                 saa7146_write(dev, MC1, (MASK_13 | MASK_29 ));
2431
2432                 mdelay(10);
2433                 /* now send VSYNC_B to rps1 by rising GPIO3 */
2434                 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI);
2435                 mdelay(10);
2436                 /* if rps1 responded by lowering the GPIO3,
2437                  * then we have budgetpatch hardware
2438                  */
2439                 if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) {
2440                         budgetpatch = 1;
2441                         printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2442                 }
2443                 /* Disable RPS1 */
2444                 saa7146_write(dev, MC1, ( MASK_29 ));
2445 #if RPS_IRQ
2446                 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff );
2447 #endif
2448         }
2449
2450         /* prepare the av7110 device struct */
2451         av7110 = kzalloc(sizeof(struct av7110), GFP_KERNEL);
2452         if (!av7110) {
2453                 dprintk(1, "out of memory\n");
2454                 return -ENOMEM;
2455         }
2456
2457         av7110->card_name = (char*) pci_ext->ext_priv;
2458         av7110->dev = dev;
2459         dev->ext_priv = av7110;
2460
2461         ret = get_firmware(av7110);
2462         if (ret < 0)
2463                 goto err_kfree_0;
2464
2465         ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name,
2466                                    THIS_MODULE, &dev->pci->dev, adapter_nr);
2467         if (ret < 0)
2468                 goto err_put_firmware_1;
2469
2470         /* the Siemens DVB needs this if you want to have the i2c chips
2471            get recognized before the main driver is fully loaded */
2472         saa7146_write(dev, GPIO_CTRL, 0x500000);
2473
2474 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
2475         av7110->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL;
2476 #else
2477         av7110->i2c_adap.class = I2C_CLASS_TV_DIGITAL;
2478 #endif
2479         strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
2480
2481         saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
2482
2483         ret = i2c_add_adapter(&av7110->i2c_adap);
2484         if (ret < 0)
2485                 goto err_dvb_unregister_adapter_2;
2486
2487         ttpci_eeprom_parse_mac(&av7110->i2c_adap,
2488                                av7110->dvb_adapter.proposed_mac);
2489         ret = -ENOMEM;
2490
2491         if (budgetpatch) {
2492                 spin_lock_init(&av7110->feedlock1);
2493                 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2494                                                                  &av7110->pt);
2495                 if (!av7110->grabbing)
2496                         goto err_i2c_del_3;
2497
2498                 saa7146_write(dev, PCI_BT_V1, 0x1c1f101f);
2499                 saa7146_write(dev, BCS_CTRL, 0x80400040);
2500                 /* set dd1 stream a & b */
2501                 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2502                 saa7146_write(dev, DD1_INIT, 0x03000200);
2503                 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2504                 saa7146_write(dev, BRS_CTRL, 0x60000000);
2505                 saa7146_write(dev, BASE_ODD3, 0);
2506                 saa7146_write(dev, BASE_EVEN3, 0);
2507                 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2508                 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2509
2510                 saa7146_write(dev, PITCH3, TS_WIDTH);
2511                 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2512
2513                 /* upload all */
2514                 saa7146_write(dev, MC2, 0x077c077c);
2515                 saa7146_write(dev, GPIO_CTRL, 0x000000);
2516 #if RPS_IRQ
2517                 /* set event counter 1 source as RPS1 interrupt (0x03)          (rE4 p53)
2518                  * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2519                  * use 0x15 to track VPE  interrupts - increase by 1 every vpeirq() is called
2520                  */
2521                 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2522                 /* set event counter 1 treshold to maximum allowed value        (rEC p55) */
2523                 saa7146_write(dev, ECT1R,  0x3fff );
2524 #endif
2525                 /* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */
2526                 count = 0;
2527
2528                 /* Wait Source Line Counter Threshold                           (p36) */
2529                 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_HS));
2530                 /* Set GPIO3=1                                                  (p42) */
2531                 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2532                 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2533                 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTHI<<24));
2534 #if RPS_IRQ
2535                 /* issue RPS1 interrupt */
2536                 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2537 #endif
2538                 /* Wait reset Source Line Counter Threshold                     (p36) */
2539                 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | RPS_INV | EVT_HS));
2540                 /* Set GPIO3=0                                                  (p42) */
2541                 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2542                 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2543                 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTLO<<24));
2544 #if RPS_IRQ
2545                 /* issue RPS1 interrupt */
2546                 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2547 #endif
2548                 /* Jump to begin of RPS program                                 (p37) */
2549                 WRITE_RPS1(cpu_to_le32(CMD_JUMP));
2550                 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle));
2551
2552                 /* Fix VSYNC level */
2553                 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2554                 /* Set RPS1 Address register to point to RPS code               (r108 p42) */
2555                 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2556                 /* Set Source Line Counter Threshold, using BRS                 (rCC p43)
2557                  * It generates HS event every TS_HEIGHT lines
2558                  * this is related to TS_WIDTH set in register
2559                  * NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits
2560                  * are set to TS_WIDTH bytes (TS_WIDTH=2*188),
2561                  * then RPS_THRESH1 should be set to trigger
2562                  * every TS_HEIGHT (512) lines.
2563                  */
2564                 saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 );
2565
2566                 /* Enable RPS1                                                  (rFC p33) */
2567                 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
2568
2569                 /* end of budgetpatch register initialization */
2570                 tasklet_init (&av7110->vpe_tasklet,  vpeirq,  (unsigned long) av7110);
2571         } else {
2572                 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
2573                 saa7146_write(dev, BCS_CTRL, 0x80400040);
2574
2575                 /* set dd1 stream a & b */
2576                 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2577                 saa7146_write(dev, DD1_INIT, 0x03000000);
2578                 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2579
2580                 /* upload all */
2581                 saa7146_write(dev, MC2, 0x077c077c);
2582                 saa7146_write(dev, GPIO_CTRL, 0x000000);
2583         }
2584
2585         tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2586         tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2587
2588         mutex_init(&av7110->pid_mutex);
2589
2590         /* locks for data transfers from/to AV7110 */
2591         spin_lock_init(&av7110->debilock);
2592         mutex_init(&av7110->dcomlock);
2593         av7110->debitype = -1;
2594
2595         /* default OSD window */
2596         av7110->osdwin = 1;
2597         mutex_init(&av7110->osd_mutex);
2598
2599         /* TV standard */
2600         av7110->vidmode = tv_standard == 1 ? AV7110_VIDEO_MODE_NTSC
2601                                            : AV7110_VIDEO_MODE_PAL;
2602
2603         /* ARM "watchdog" */
2604         init_waitqueue_head(&av7110->arm_wait);
2605         av7110->arm_thread = NULL;
2606
2607         /* allocate and init buffers */
2608         av7110->debi_virt = pci_alloc_consistent(pdev, 8192, &av7110->debi_bus);
2609         if (!av7110->debi_virt)
2610                 goto err_saa71466_vfree_4;
2611
2612
2613         av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2614         if (!av7110->iobuf)
2615                 goto err_pci_free_5;
2616
2617         ret = av7110_av_init(av7110);
2618         if (ret < 0)
2619                 goto err_iobuf_vfree_6;
2620
2621         /* init BMP buffer */
2622         av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN;
2623         init_waitqueue_head(&av7110->bmpq);
2624
2625         ret = av7110_ca_init(av7110);
2626         if (ret < 0)
2627                 goto err_av7110_av_exit_7;
2628
2629         /* load firmware into AV7110 cards */
2630         ret = av7110_bootarm(av7110);
2631         if (ret < 0)
2632                 goto err_av7110_ca_exit_8;
2633
2634         ret = av7110_firmversion(av7110);
2635         if (ret < 0)
2636                 goto err_stop_arm_9;
2637
2638         if (FW_VERSION(av7110->arm_app)<0x2501)
2639                 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2640                         "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2641
2642         thread = kthread_run(arm_thread, (void *) av7110, "arm_mon");
2643         if (IS_ERR(thread)) {
2644                 ret = PTR_ERR(thread);
2645                 goto err_stop_arm_9;
2646         }
2647         av7110->arm_thread = thread;
2648
2649         /* set initial volume in mixer struct */
2650         av7110->mixer.volume_left  = volume;
2651         av7110->mixer.volume_right = volume;
2652
2653         ret = av7110_register(av7110);
2654         if (ret < 0)
2655                 goto err_arm_thread_stop_10;
2656
2657         init_av7110_av(av7110);
2658
2659         /* special case DVB-C: these cards have an analog tuner
2660            plus need some special handling, so we have separate
2661            saa7146_ext_vv data for these... */
2662         ret = av7110_init_v4l(av7110);
2663         if (ret < 0)
2664                 goto err_av7110_unregister_11;
2665
2666         av7110->dvb_adapter.priv = av7110;
2667         ret = frontend_init(av7110);
2668         if (ret < 0)
2669                 goto err_av7110_exit_v4l_12;
2670
2671 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2672         av7110_ir_init(av7110);
2673 #endif
2674         printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2675         av7110_num++;
2676 out:
2677         return ret;
2678
2679 err_av7110_exit_v4l_12:
2680         av7110_exit_v4l(av7110);
2681 err_av7110_unregister_11:
2682         dvb_unregister(av7110);
2683 err_arm_thread_stop_10:
2684         av7110_arm_sync(av7110);
2685 err_stop_arm_9:
2686         /* Nothing to do. Rejoice. */
2687 err_av7110_ca_exit_8:
2688         av7110_ca_exit(av7110);
2689 err_av7110_av_exit_7:
2690         av7110_av_exit(av7110);
2691 err_iobuf_vfree_6:
2692         vfree(av7110->iobuf);
2693 err_pci_free_5:
2694         pci_free_consistent(pdev, 8192, av7110->debi_virt, av7110->debi_bus);
2695 err_saa71466_vfree_4:
2696         if (av7110->grabbing)
2697                 saa7146_vfree_destroy_pgtable(pdev, av7110->grabbing, &av7110->pt);
2698 err_i2c_del_3:
2699         i2c_del_adapter(&av7110->i2c_adap);
2700 err_dvb_unregister_adapter_2:
2701         dvb_unregister_adapter(&av7110->dvb_adapter);
2702 err_put_firmware_1:
2703         put_firmware(av7110);
2704 err_kfree_0:
2705         kfree(av7110);
2706         goto out;
2707 }
2708
2709 static int __devexit av7110_detach(struct saa7146_dev* saa)
2710 {
2711         struct av7110 *av7110 = saa->ext_priv;
2712         dprintk(4, "%p\n", av7110);
2713
2714 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2715         av7110_ir_exit(av7110);
2716 #endif
2717         if (budgetpatch) {
2718                 /* Disable RPS1 */
2719                 saa7146_write(saa, MC1, MASK_29);
2720                 /* VSYNC LOW (inactive) */
2721                 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
2722                 saa7146_write(saa, MC1, MASK_20);       /* DMA3 off */
2723                 SAA7146_IER_DISABLE(saa, MASK_10);
2724                 SAA7146_ISR_CLEAR(saa, MASK_10);
2725                 msleep(50);
2726                 tasklet_kill(&av7110->vpe_tasklet);
2727                 saa7146_vfree_destroy_pgtable(saa->pci, av7110->grabbing, &av7110->pt);
2728         }
2729         av7110_exit_v4l(av7110);
2730
2731         av7110_arm_sync(av7110);
2732
2733         tasklet_kill(&av7110->debi_tasklet);
2734         tasklet_kill(&av7110->gpio_tasklet);
2735
2736         dvb_unregister(av7110);
2737
2738         SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2739         SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2740
2741         av7110_ca_exit(av7110);
2742         av7110_av_exit(av7110);
2743
2744         vfree(av7110->iobuf);
2745         pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2746                             av7110->debi_bus);
2747
2748         i2c_del_adapter(&av7110->i2c_adap);
2749
2750         dvb_unregister_adapter (&av7110->dvb_adapter);
2751
2752         av7110_num--;
2753
2754         put_firmware(av7110);
2755
2756         kfree(av7110);
2757
2758         saa->ext_priv = NULL;
2759
2760         return 0;
2761 }
2762
2763
2764 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2765 {
2766         struct av7110 *av7110 = dev->ext_priv;
2767
2768         //print_time("av7110_irq");
2769
2770         /* Note: Don't try to handle the DEBI error irq (MASK_18), in
2771          * intel mode the timeout is asserted all the time...
2772          */
2773
2774         if (*isr & MASK_19) {
2775                 //printk("av7110_irq: DEBI\n");
2776                 /* Note 1: The DEBI irq is level triggered: We must enable it
2777                  * only after we started a DMA xfer, and disable it here
2778                  * immediately, or it will be signalled all the time while
2779                  * DEBI is idle.
2780                  * Note 2: You would think that an irq which is masked is
2781                  * not signalled by the hardware. Not so for the SAA7146:
2782                  * An irq is signalled as long as the corresponding bit
2783                  * in the ISR is set, and disabling irqs just prevents the
2784                  * hardware from setting the ISR bit. This means a) that we
2785                  * must clear the ISR *after* disabling the irq (which is why
2786                  * we must do it here even though saa7146_core did it already),
2787                  * and b) that if we were to disable an edge triggered irq
2788                  * (like the gpio irqs sadly are) temporarily we would likely
2789                  * loose some. This sucks :-(
2790                  */
2791                 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
2792                 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
2793                 tasklet_schedule(&av7110->debi_tasklet);
2794         }
2795
2796         if (*isr & MASK_03) {
2797                 //printk("av7110_irq: GPIO\n");
2798                 tasklet_schedule(&av7110->gpio_tasklet);
2799         }
2800
2801         if ((*isr & MASK_10) && budgetpatch)
2802                 tasklet_schedule(&av7110->vpe_tasklet);
2803 }
2804
2805
2806 static struct saa7146_extension av7110_extension_driver;
2807
2808 #define MAKE_AV7110_INFO(x_var,x_name) \
2809 static struct saa7146_pci_extension_data x_var = { \
2810         .ext_priv = x_name, \
2811         .ext = &av7110_extension_driver }
2812
2813 MAKE_AV7110_INFO(tts_1_X_fsc,"Technotrend/Hauppauge WinTV DVB-S rev1.X or Fujitsu Siemens DVB-C");
2814 MAKE_AV7110_INFO(ttt_1_X,    "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2815 MAKE_AV7110_INFO(ttc_1_X,    "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2816 MAKE_AV7110_INFO(ttc_2_X,    "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2817 MAKE_AV7110_INFO(tts_2_X,    "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2818 MAKE_AV7110_INFO(tts_2_3,    "Technotrend/Hauppauge WinTV Nexus-S rev2.3");
2819 MAKE_AV7110_INFO(tts_1_3se,  "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2820 MAKE_AV7110_INFO(ttt,        "Technotrend/Hauppauge DVB-T");
2821 MAKE_AV7110_INFO(fsc,        "Fujitsu Siemens DVB-C");
2822 MAKE_AV7110_INFO(fss,        "Fujitsu Siemens DVB-S rev1.6");
2823 MAKE_AV7110_INFO(gxs_1_3,    "Galaxis DVB-S rev1.3");
2824
2825 static struct pci_device_id pci_tbl[] = {
2826         MAKE_EXTENSION_PCI(fsc,         0x110a, 0x0000),
2827         MAKE_EXTENSION_PCI(tts_1_X_fsc, 0x13c2, 0x0000),
2828         MAKE_EXTENSION_PCI(ttt_1_X,     0x13c2, 0x0001),
2829         MAKE_EXTENSION_PCI(ttc_2_X,     0x13c2, 0x0002),
2830         MAKE_EXTENSION_PCI(tts_2_X,     0x13c2, 0x0003),
2831         MAKE_EXTENSION_PCI(gxs_1_3,     0x13c2, 0x0004),
2832         MAKE_EXTENSION_PCI(fss,         0x13c2, 0x0006),
2833         MAKE_EXTENSION_PCI(ttt,         0x13c2, 0x0008),
2834         MAKE_EXTENSION_PCI(ttc_1_X,     0x13c2, 0x000a),
2835         MAKE_EXTENSION_PCI(tts_2_3,     0x13c2, 0x000e),
2836         MAKE_EXTENSION_PCI(tts_1_3se,   0x13c2, 0x1002),
2837
2838 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2839 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2840
2841         {
2842                 .vendor    = 0,
2843         }
2844 };
2845
2846 MODULE_DEVICE_TABLE(pci, pci_tbl);
2847
2848
2849 static struct saa7146_extension av7110_extension_driver = {
2850         .name           = "dvb",
2851         .flags          = SAA7146_USE_I2C_IRQ,
2852
2853         .module         = THIS_MODULE,
2854         .pci_tbl        = &pci_tbl[0],
2855         .attach         = av7110_attach,
2856         .detach         = __devexit_p(av7110_detach),
2857
2858         .irq_mask       = MASK_19 | MASK_03 | MASK_10,
2859         .irq_func       = av7110_irq,
2860 };
2861
2862
2863 static int __init av7110_init(void)
2864 {
2865         int retval;
2866         retval = saa7146_register_extension(&av7110_extension_driver);
2867         return retval;
2868 }
2869
2870
2871 static void __exit av7110_exit(void)
2872 {
2873         saa7146_unregister_extension(&av7110_extension_driver);
2874 }
2875
2876 module_init(av7110_init);
2877 module_exit(av7110_exit);
2878
2879 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2880                    "Siemens, Technotrend, Hauppauge");
2881 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2882 MODULE_LICENSE("GPL");