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