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 http://www.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);
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                                " http://www.linuxtv.org/download/dvb/firmware/\n");
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 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                         // try ALPS TDLB7 first, then Grundig 29504-401
2203                         av7110->fe = dvb_attach(sp8870_attach, &alps_tdlb7_config, &av7110->i2c_adap);
2204                         if (av7110->fe) {
2205                                 av7110->fe->ops.tuner_ops.set_params = alps_tdlb7_tuner_set_params;
2206                                 break;
2207                         }
2208                         /* fall-thru */
2209
2210                 case 0x0008: // Hauppauge/TT DVB-T
2211                         // Grundig 29504-401
2212                         av7110->fe = dvb_attach(l64781_attach, &grundig_29504_401_config, &av7110->i2c_adap);
2213                         if (av7110->fe)
2214                                 av7110->fe->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params;
2215                         break;
2216
2217                 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
2218
2219                         av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
2220                         if (av7110->fe) {
2221                                 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2222                         }
2223                         break;
2224
2225                 case 0x0004: // Galaxis DVB-S rev1.3
2226                         /* ALPS BSRV2 */
2227                         av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2228                         if (av7110->fe) {
2229                                 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2230                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2231                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2232                                 av7110->fe->ops.set_tone = av7110_set_tone;
2233                                 av7110->recover = dvb_s_recover;
2234                         }
2235                         break;
2236
2237                 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
2238                         /* Grundig 29504-451 */
2239                         av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2240                         if (av7110->fe) {
2241                                 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2242                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2243                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2244                                 av7110->fe->ops.set_tone = av7110_set_tone;
2245                                 av7110->recover = dvb_s_recover;
2246                         }
2247                         break;
2248
2249                 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
2250
2251                         av7110->fe = dvb_attach(stv0297_attach, &nexusca_stv0297_config, &av7110->i2c_adap);
2252                         if (av7110->fe) {
2253                                 av7110->fe->ops.tuner_ops.set_params = nexusca_stv0297_tuner_set_params;
2254
2255                                 /* set TDA9819 into DVB mode */
2256                                 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
2257                                 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
2258
2259                                 /* tuner on this needs a slower i2c bus speed */
2260                                 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
2261                                 break;
2262                         }
2263                         break;
2264
2265                 case 0x000E: /* Hauppauge/TT Nexus-S rev 2.3 */
2266                         /* ALPS BSBE1 */
2267                         av7110->fe = dvb_attach(stv0299_attach, &alps_bsbe1_config, &av7110->i2c_adap);
2268                         if (av7110->fe) {
2269                                 av7110->fe->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
2270                                 av7110->fe->tuner_priv = &av7110->i2c_adap;
2271
2272                                 if (dvb_attach(lnbp21_attach, av7110->fe, &av7110->i2c_adap, 0, 0) == NULL) {
2273                                         printk("dvb-ttpci: LNBP21 not found!\n");
2274                                         if (av7110->fe->ops.release)
2275                                                 av7110->fe->ops.release(av7110->fe);
2276                                         av7110->fe = NULL;
2277                                 } else {
2278                                         av7110->fe->ops.dishnetwork_send_legacy_command = NULL;
2279                                         av7110->recover = dvb_s_recover;
2280                                 }
2281                         }
2282                         break;
2283                 }
2284         }
2285
2286         if (!av7110->fe) {
2287                 /* FIXME: propagate the failure code from the lower layers */
2288                 ret = -ENOMEM;
2289                 printk("dvb-ttpci: A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
2290                        av7110->dev->pci->vendor,
2291                        av7110->dev->pci->device,
2292                        av7110->dev->pci->subsystem_vendor,
2293                        av7110->dev->pci->subsystem_device);
2294         } else {
2295                 FE_FUNC_OVERRIDE(av7110->fe->ops.init, av7110->fe_init, av7110_fe_init);
2296                 FE_FUNC_OVERRIDE(av7110->fe->ops.read_status, av7110->fe_read_status, av7110_fe_read_status);
2297                 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
2298                 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
2299                 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
2300                 FE_FUNC_OVERRIDE(av7110->fe->ops.set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
2301                 FE_FUNC_OVERRIDE(av7110->fe->ops.set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage);
2302                 FE_FUNC_OVERRIDE(av7110->fe->ops.dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
2303                 FE_FUNC_OVERRIDE(av7110->fe->ops.set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
2304
2305                 ret = dvb_register_frontend(&av7110->dvb_adapter, av7110->fe);
2306                 if (ret < 0) {
2307                         printk("av7110: Frontend registration failed!\n");
2308                         dvb_frontend_detach(av7110->fe);
2309                         av7110->fe = NULL;
2310                 }
2311         }
2312         return ret;
2313 }
2314
2315 /* Budgetpatch note:
2316  * Original hardware design by Roberto Deza:
2317  * There is a DVB_Wiki at
2318  * http://www.linuxtv.org/
2319  *
2320  * New software triggering design by Emard that works on
2321  * original Roberto Deza's hardware:
2322  *
2323  * rps1 code for budgetpatch will copy internal HS event to GPIO3 pin.
2324  * GPIO3 is in budget-patch hardware connectd to port B VSYNC
2325  * HS is an internal event of 7146, accessible with RPS
2326  * and temporarily raised high every n lines
2327  * (n in defined in the RPS_THRESH1 counter threshold)
2328  * I think HS is raised high on the beginning of the n-th line
2329  * and remains high until this n-th line that triggered
2330  * it is completely received. When the receiption of n-th line
2331  * ends, HS is lowered.
2332  *
2333  * To transmit data over DMA, 7146 needs changing state at
2334  * port B VSYNC pin. Any changing of port B VSYNC will
2335  * cause some DMA data transfer, with more or less packets loss.
2336  * It depends on the phase and frequency of VSYNC and
2337  * the way of 7146 is instructed to trigger on port B (defined
2338  * in DD1_INIT register, 3rd nibble from the right valid
2339  * numbers are 0-7, see datasheet)
2340  *
2341  * The correct triggering can minimize packet loss,
2342  * dvbtraffic should give this stable bandwidths:
2343  *   22k transponder = 33814 kbit/s
2344  * 27.5k transponder = 38045 kbit/s
2345  * by experiment it is found that the best results
2346  * (stable bandwidths and almost no packet loss)
2347  * are obtained using DD1_INIT triggering number 2
2348  * (Va at rising edge of VS Fa = HS x VS-failing forced toggle)
2349  * and a VSYNC phase that occurs in the middle of DMA transfer
2350  * (about byte 188*512=96256 in the DMA window).
2351  *
2352  * Phase of HS is still not clear to me how to control,
2353  * It just happens to be so. It can be seen if one enables
2354  * RPS_IRQ and print Event Counter 1 in vpeirq(). Every
2355  * time RPS_INTERRUPT is called, the Event Counter 1 will
2356  * increment. That's how the 7146 is programmed to do event
2357  * counting in this budget-patch.c
2358  * I *think* HPS setting has something to do with the phase
2359  * of HS but I can't be 100% sure in that.
2360  *
2361  * hardware debug note: a working budget card (including budget patch)
2362  * with vpeirq() interrupt setup in mode "0x90" (every 64K) will
2363  * generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes
2364  * and that means 3*25=75 Hz of interrupt freqency, as seen by
2365  * watch cat /proc/interrupts
2366  *
2367  * If this frequency is 3x lower (and data received in the DMA
2368  * buffer don't start with 0x47, but in the middle of packets,
2369  * whose lengths appear to be like 188 292 188 104 etc.
2370  * this means VSYNC line is not connected in the hardware.
2371  * (check soldering pcb and pins)
2372  * The same behaviour of missing VSYNC can be duplicated on budget
2373  * cards, by seting DD1_INIT trigger mode 7 in 3rd nibble.
2374  */
2375 static int av7110_attach(struct saa7146_dev* dev,
2376                          struct saa7146_pci_extension_data *pci_ext)
2377 {
2378         const int length = TS_WIDTH * TS_HEIGHT;
2379         struct pci_dev *pdev = dev->pci;
2380         struct av7110 *av7110;
2381         struct task_struct *thread;
2382         int ret, count = 0;
2383
2384         dprintk(4, "dev: %p\n", dev);
2385
2386         /* Set RPS_IRQ to 1 to track rps1 activity.
2387          * Enabling this won't send any interrupt to PC CPU.
2388          */
2389 #define RPS_IRQ 0
2390
2391         if (budgetpatch == 1) {
2392                 budgetpatch = 0;
2393                 /* autodetect the presence of budget patch
2394                  * this only works if saa7146 has been recently
2395                  * reset with with MASK_31 to MC1
2396                  *
2397                  * will wait for VBI_B event (vertical blank at port B)
2398                  * and will reset GPIO3 after VBI_B is detected.
2399                  * (GPIO3 should be raised high by CPU to
2400                  * test if GPIO3 will generate vertical blank signal
2401                  * in budget patch GPIO3 is connected to VSYNC_B
2402                  */
2403
2404                 /* RESET SAA7146 */
2405                 saa7146_write(dev, MC1, MASK_31);
2406                 /* autodetection success seems to be time-dependend after reset */
2407
2408                 /* Fix VSYNC level */
2409                 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2410                 /* set vsync_b triggering */
2411                 saa7146_write(dev, DD1_STREAM_B, 0);
2412                 /* port B VSYNC at rising edge */
2413                 saa7146_write(dev, DD1_INIT, 0x00000200);
2414                 saa7146_write(dev, BRS_CTRL, 0x00000000);  // VBI
2415                 saa7146_write(dev, MC2,
2416                               1 * (MASK_08 | MASK_24)  |   // BRS control
2417                               0 * (MASK_09 | MASK_25)  |   // a
2418                               1 * (MASK_10 | MASK_26)  |   // b
2419                               0 * (MASK_06 | MASK_22)  |   // HPS_CTRL1
2420                               0 * (MASK_05 | MASK_21)  |   // HPS_CTRL2
2421                               0 * (MASK_01 | MASK_15)      // DEBI
2422                 );
2423
2424                 /* start writing RPS1 code from beginning */
2425                 count = 0;
2426                 /* Disable RPS1 */
2427                 saa7146_write(dev, MC1, MASK_29);
2428                 /* RPS1 timeout disable */
2429                 saa7146_write(dev, RPS_TOV1, 0);
2430                 WRITE_RPS1(CMD_PAUSE | EVT_VBI_B);
2431                 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2432                 WRITE_RPS1(GPIO3_MSK);
2433                 WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2434 #if RPS_IRQ
2435                 /* issue RPS1 interrupt to increment counter */
2436                 WRITE_RPS1(CMD_INTERRUPT);
2437 #endif
2438                 WRITE_RPS1(CMD_STOP);
2439                 /* Jump to begin of RPS program as safety measure               (p37) */
2440                 WRITE_RPS1(CMD_JUMP);
2441                 WRITE_RPS1(dev->d_rps1.dma_handle);
2442
2443 #if RPS_IRQ
2444                 /* set event counter 1 source as RPS1 interrupt (0x03)          (rE4 p53)
2445                  * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2446                  * use 0x15 to track VPE  interrupts - increase by 1 every vpeirq() is called
2447                  */
2448                 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2449                 /* set event counter 1 threshold to maximum allowed value        (rEC p55) */
2450                 saa7146_write(dev, ECT1R,  0x3fff );
2451 #endif
2452                 /* Set RPS1 Address register to point to RPS code               (r108 p42) */
2453                 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2454                 /* Enable RPS1,                                                 (rFC p33) */
2455                 saa7146_write(dev, MC1, (MASK_13 | MASK_29 ));
2456
2457                 mdelay(10);
2458                 /* now send VSYNC_B to rps1 by rising GPIO3 */
2459                 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI);
2460                 mdelay(10);
2461                 /* if rps1 responded by lowering the GPIO3,
2462                  * then we have budgetpatch hardware
2463                  */
2464                 if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) {
2465                         budgetpatch = 1;
2466                         printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2467                 }
2468                 /* Disable RPS1 */
2469                 saa7146_write(dev, MC1, ( MASK_29 ));
2470 #if RPS_IRQ
2471                 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff );
2472 #endif
2473         }
2474
2475         /* prepare the av7110 device struct */
2476         av7110 = kzalloc(sizeof(struct av7110), GFP_KERNEL);
2477         if (!av7110) {
2478                 dprintk(1, "out of memory\n");
2479                 return -ENOMEM;
2480         }
2481
2482         av7110->card_name = (char*) pci_ext->ext_priv;
2483         av7110->dev = dev;
2484         dev->ext_priv = av7110;
2485
2486         ret = get_firmware(av7110);
2487         if (ret < 0)
2488                 goto err_kfree_0;
2489
2490         ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name,
2491                                    THIS_MODULE, &dev->pci->dev, adapter_nr);
2492         if (ret < 0)
2493                 goto err_put_firmware_1;
2494
2495         /* the Siemens DVB needs this if you want to have the i2c chips
2496            get recognized before the main driver is fully loaded */
2497         saa7146_write(dev, GPIO_CTRL, 0x500000);
2498
2499         strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
2500
2501         saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
2502
2503         ret = i2c_add_adapter(&av7110->i2c_adap);
2504         if (ret < 0)
2505                 goto err_dvb_unregister_adapter_2;
2506
2507         ttpci_eeprom_parse_mac(&av7110->i2c_adap,
2508                                av7110->dvb_adapter.proposed_mac);
2509         ret = -ENOMEM;
2510
2511         /* full-ts mod? */
2512         if (full_ts)
2513                 av7110->full_ts = true;
2514
2515         /* check for full-ts flag in eeprom */
2516         if (i2c_readreg(av7110, 0xaa, 0) == 0x4f && i2c_readreg(av7110, 0xaa, 1) == 0x45) {
2517                 u8 flags = i2c_readreg(av7110, 0xaa, 2);
2518                 if (flags != 0xff && (flags & 0x01))
2519                         av7110->full_ts = true;
2520         }
2521
2522         if (av7110->full_ts) {
2523                 printk(KERN_INFO "dvb-ttpci: full-ts mode enabled for saa7146 port B\n");
2524                 spin_lock_init(&av7110->feedlock1);
2525                 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2526                                                                  &av7110->pt);
2527                 if (!av7110->grabbing)
2528                         goto err_i2c_del_3;
2529
2530                 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2531                 saa7146_write(dev, MC2, (MASK_10 | MASK_26));
2532
2533                 saa7146_write(dev, DD1_INIT, 0x00000600);
2534                 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2535
2536                 saa7146_write(dev, BRS_CTRL, 0x60000000);
2537                 saa7146_write(dev, MC2, MASK_08 | MASK_24);
2538
2539                 /* dma3 */
2540                 saa7146_write(dev, PCI_BT_V1, 0x001c0000 | (saa7146_read(dev, PCI_BT_V1) & ~0x001f0000));
2541                 saa7146_write(dev, BASE_ODD3, 0);
2542                 saa7146_write(dev, BASE_EVEN3, 0);
2543                 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2544                 saa7146_write(dev, PITCH3, TS_WIDTH);
2545                 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2546                 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2547                 saa7146_write(dev, MC2, MASK_04 | MASK_20);
2548
2549                 tasklet_init(&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2550
2551         } else if (budgetpatch) {
2552                 spin_lock_init(&av7110->feedlock1);
2553                 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2554                                                                  &av7110->pt);
2555                 if (!av7110->grabbing)
2556                         goto err_i2c_del_3;
2557
2558                 saa7146_write(dev, PCI_BT_V1, 0x1c1f101f);
2559                 saa7146_write(dev, BCS_CTRL, 0x80400040);
2560                 /* set dd1 stream a & b */
2561                 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2562                 saa7146_write(dev, DD1_INIT, 0x03000200);
2563                 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2564                 saa7146_write(dev, BRS_CTRL, 0x60000000);
2565                 saa7146_write(dev, BASE_ODD3, 0);
2566                 saa7146_write(dev, BASE_EVEN3, 0);
2567                 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2568                 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2569
2570                 saa7146_write(dev, PITCH3, TS_WIDTH);
2571                 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2572
2573                 /* upload all */
2574                 saa7146_write(dev, MC2, 0x077c077c);
2575                 saa7146_write(dev, GPIO_CTRL, 0x000000);
2576 #if RPS_IRQ
2577                 /* set event counter 1 source as RPS1 interrupt (0x03)          (rE4 p53)
2578                  * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2579                  * use 0x15 to track VPE  interrupts - increase by 1 every vpeirq() is called
2580                  */
2581                 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2582                 /* set event counter 1 threshold to maximum allowed value        (rEC p55) */
2583                 saa7146_write(dev, ECT1R,  0x3fff );
2584 #endif
2585                 /* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */
2586                 count = 0;
2587
2588                 /* Wait Source Line Counter Threshold                           (p36) */
2589                 WRITE_RPS1(CMD_PAUSE | EVT_HS);
2590                 /* Set GPIO3=1                                                  (p42) */
2591                 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2592                 WRITE_RPS1(GPIO3_MSK);
2593                 WRITE_RPS1(SAA7146_GPIO_OUTHI<<24);
2594 #if RPS_IRQ
2595                 /* issue RPS1 interrupt */
2596                 WRITE_RPS1(CMD_INTERRUPT);
2597 #endif
2598                 /* Wait reset Source Line Counter Threshold                     (p36) */
2599                 WRITE_RPS1(CMD_PAUSE | RPS_INV | EVT_HS);
2600                 /* Set GPIO3=0                                                  (p42) */
2601                 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2602                 WRITE_RPS1(GPIO3_MSK);
2603                 WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2604 #if RPS_IRQ
2605                 /* issue RPS1 interrupt */
2606                 WRITE_RPS1(CMD_INTERRUPT);
2607 #endif
2608                 /* Jump to begin of RPS program                                 (p37) */
2609                 WRITE_RPS1(CMD_JUMP);
2610                 WRITE_RPS1(dev->d_rps1.dma_handle);
2611
2612                 /* Fix VSYNC level */
2613                 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2614                 /* Set RPS1 Address register to point to RPS code               (r108 p42) */
2615                 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2616                 /* Set Source Line Counter Threshold, using BRS                 (rCC p43)
2617                  * It generates HS event every TS_HEIGHT lines
2618                  * this is related to TS_WIDTH set in register
2619                  * NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits
2620                  * are set to TS_WIDTH bytes (TS_WIDTH=2*188),
2621                  * then RPS_THRESH1 should be set to trigger
2622                  * every TS_HEIGHT (512) lines.
2623                  */
2624                 saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 );
2625
2626                 /* Enable RPS1                                                  (rFC p33) */
2627                 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
2628
2629                 /* end of budgetpatch register initialization */
2630                 tasklet_init (&av7110->vpe_tasklet,  vpeirq,  (unsigned long) av7110);
2631         } else {
2632                 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
2633                 saa7146_write(dev, BCS_CTRL, 0x80400040);
2634
2635                 /* set dd1 stream a & b */
2636                 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2637                 saa7146_write(dev, DD1_INIT, 0x03000000);
2638                 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2639
2640                 /* upload all */
2641                 saa7146_write(dev, MC2, 0x077c077c);
2642                 saa7146_write(dev, GPIO_CTRL, 0x000000);
2643         }
2644
2645         tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2646         tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2647
2648         mutex_init(&av7110->pid_mutex);
2649
2650         /* locks for data transfers from/to AV7110 */
2651         spin_lock_init(&av7110->debilock);
2652         mutex_init(&av7110->dcomlock);
2653         av7110->debitype = -1;
2654
2655         /* default OSD window */
2656         av7110->osdwin = 1;
2657         mutex_init(&av7110->osd_mutex);
2658
2659         /* TV standard */
2660         av7110->vidmode = tv_standard == 1 ? AV7110_VIDEO_MODE_NTSC
2661                                            : AV7110_VIDEO_MODE_PAL;
2662
2663         /* ARM "watchdog" */
2664         init_waitqueue_head(&av7110->arm_wait);
2665         av7110->arm_thread = NULL;
2666
2667         /* allocate and init buffers */
2668         av7110->debi_virt = pci_alloc_consistent(pdev, 8192, &av7110->debi_bus);
2669         if (!av7110->debi_virt)
2670                 goto err_saa71466_vfree_4;
2671
2672
2673         av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2674         if (!av7110->iobuf)
2675                 goto err_pci_free_5;
2676
2677         ret = av7110_av_init(av7110);
2678         if (ret < 0)
2679                 goto err_iobuf_vfree_6;
2680
2681         /* init BMP buffer */
2682         av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN;
2683         init_waitqueue_head(&av7110->bmpq);
2684
2685         ret = av7110_ca_init(av7110);
2686         if (ret < 0)
2687                 goto err_av7110_av_exit_7;
2688
2689         /* load firmware into AV7110 cards */
2690         ret = av7110_bootarm(av7110);
2691         if (ret < 0)
2692                 goto err_av7110_ca_exit_8;
2693
2694         ret = av7110_firmversion(av7110);
2695         if (ret < 0)
2696                 goto err_stop_arm_9;
2697
2698         if (FW_VERSION(av7110->arm_app)<0x2501)
2699                 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2700                         "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2701
2702         thread = kthread_run(arm_thread, (void *) av7110, "arm_mon");
2703         if (IS_ERR(thread)) {
2704                 ret = PTR_ERR(thread);
2705                 goto err_stop_arm_9;
2706         }
2707         av7110->arm_thread = thread;
2708
2709         /* set initial volume in mixer struct */
2710         av7110->mixer.volume_left  = volume;
2711         av7110->mixer.volume_right = volume;
2712
2713         ret = av7110_register(av7110);
2714         if (ret < 0)
2715                 goto err_arm_thread_stop_10;
2716
2717         init_av7110_av(av7110);
2718
2719         /* special case DVB-C: these cards have an analog tuner
2720            plus need some special handling, so we have separate
2721            saa7146_ext_vv data for these... */
2722         ret = av7110_init_v4l(av7110);
2723         if (ret < 0)
2724                 goto err_av7110_unregister_11;
2725
2726         av7110->dvb_adapter.priv = av7110;
2727         ret = frontend_init(av7110);
2728         if (ret < 0)
2729                 goto err_av7110_exit_v4l_12;
2730
2731         mutex_init(&av7110->ioctl_mutex);
2732
2733 #if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2734         av7110_ir_init(av7110);
2735 #endif
2736         printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2737         av7110_num++;
2738 out:
2739         return ret;
2740
2741 err_av7110_exit_v4l_12:
2742         av7110_exit_v4l(av7110);
2743 err_av7110_unregister_11:
2744         dvb_unregister(av7110);
2745 err_arm_thread_stop_10:
2746         av7110_arm_sync(av7110);
2747 err_stop_arm_9:
2748         /* Nothing to do. Rejoice. */
2749 err_av7110_ca_exit_8:
2750         av7110_ca_exit(av7110);
2751 err_av7110_av_exit_7:
2752         av7110_av_exit(av7110);
2753 err_iobuf_vfree_6:
2754         vfree(av7110->iobuf);
2755 err_pci_free_5:
2756         pci_free_consistent(pdev, 8192, av7110->debi_virt, av7110->debi_bus);
2757 err_saa71466_vfree_4:
2758         if (av7110->grabbing)
2759                 saa7146_vfree_destroy_pgtable(pdev, av7110->grabbing, &av7110->pt);
2760 err_i2c_del_3:
2761         i2c_del_adapter(&av7110->i2c_adap);
2762 err_dvb_unregister_adapter_2:
2763         dvb_unregister_adapter(&av7110->dvb_adapter);
2764 err_put_firmware_1:
2765         put_firmware(av7110);
2766 err_kfree_0:
2767         kfree(av7110);
2768         goto out;
2769 }
2770
2771 static int av7110_detach(struct saa7146_dev* saa)
2772 {
2773         struct av7110 *av7110 = saa->ext_priv;
2774         dprintk(4, "%p\n", av7110);
2775
2776 #if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2777         av7110_ir_exit(av7110);
2778 #endif
2779         if (budgetpatch || av7110->full_ts) {
2780                 if (budgetpatch) {
2781                         /* Disable RPS1 */
2782                         saa7146_write(saa, MC1, MASK_29);
2783                         /* VSYNC LOW (inactive) */
2784                         saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
2785                 }
2786                 saa7146_write(saa, MC1, MASK_20);       /* DMA3 off */
2787                 SAA7146_IER_DISABLE(saa, MASK_10);
2788                 SAA7146_ISR_CLEAR(saa, MASK_10);
2789                 msleep(50);
2790                 tasklet_kill(&av7110->vpe_tasklet);
2791                 saa7146_vfree_destroy_pgtable(saa->pci, av7110->grabbing, &av7110->pt);
2792         }
2793         av7110_exit_v4l(av7110);
2794
2795         av7110_arm_sync(av7110);
2796
2797         tasklet_kill(&av7110->debi_tasklet);
2798         tasklet_kill(&av7110->gpio_tasklet);
2799
2800         dvb_unregister(av7110);
2801
2802         SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2803         SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2804
2805         av7110_ca_exit(av7110);
2806         av7110_av_exit(av7110);
2807
2808         vfree(av7110->iobuf);
2809         pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2810                             av7110->debi_bus);
2811
2812         i2c_del_adapter(&av7110->i2c_adap);
2813
2814         dvb_unregister_adapter (&av7110->dvb_adapter);
2815
2816         av7110_num--;
2817
2818         put_firmware(av7110);
2819
2820         kfree(av7110);
2821
2822         saa->ext_priv = NULL;
2823
2824         return 0;
2825 }
2826
2827
2828 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2829 {
2830         struct av7110 *av7110 = dev->ext_priv;
2831
2832         //print_time("av7110_irq");
2833
2834         /* Note: Don't try to handle the DEBI error irq (MASK_18), in
2835          * intel mode the timeout is asserted all the time...
2836          */
2837
2838         if (*isr & MASK_19) {
2839                 //printk("av7110_irq: DEBI\n");
2840                 /* Note 1: The DEBI irq is level triggered: We must enable it
2841                  * only after we started a DMA xfer, and disable it here
2842                  * immediately, or it will be signalled all the time while
2843                  * DEBI is idle.
2844                  * Note 2: You would think that an irq which is masked is
2845                  * not signalled by the hardware. Not so for the SAA7146:
2846                  * An irq is signalled as long as the corresponding bit
2847                  * in the ISR is set, and disabling irqs just prevents the
2848                  * hardware from setting the ISR bit. This means a) that we
2849                  * must clear the ISR *after* disabling the irq (which is why
2850                  * we must do it here even though saa7146_core did it already),
2851                  * and b) that if we were to disable an edge triggered irq
2852                  * (like the gpio irqs sadly are) temporarily we would likely
2853                  * loose some. This sucks :-(
2854                  */
2855                 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
2856                 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
2857                 tasklet_schedule(&av7110->debi_tasklet);
2858         }
2859
2860         if (*isr & MASK_03) {
2861                 //printk("av7110_irq: GPIO\n");
2862                 tasklet_schedule(&av7110->gpio_tasklet);
2863         }
2864
2865         if (*isr & MASK_10)
2866                 tasklet_schedule(&av7110->vpe_tasklet);
2867 }
2868
2869
2870 static struct saa7146_extension av7110_extension_driver;
2871
2872 #define MAKE_AV7110_INFO(x_var,x_name) \
2873 static struct saa7146_pci_extension_data x_var = { \
2874         .ext_priv = x_name, \
2875         .ext = &av7110_extension_driver }
2876
2877 MAKE_AV7110_INFO(tts_1_X_fsc,"Technotrend/Hauppauge WinTV DVB-S rev1.X or Fujitsu Siemens DVB-C");
2878 MAKE_AV7110_INFO(ttt_1_X,    "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2879 MAKE_AV7110_INFO(ttc_1_X,    "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2880 MAKE_AV7110_INFO(ttc_2_X,    "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2881 MAKE_AV7110_INFO(tts_2_X,    "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2882 MAKE_AV7110_INFO(tts_2_3,    "Technotrend/Hauppauge WinTV Nexus-S rev2.3");
2883 MAKE_AV7110_INFO(tts_1_3se,  "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2884 MAKE_AV7110_INFO(ttt,        "Technotrend/Hauppauge DVB-T");
2885 MAKE_AV7110_INFO(fsc,        "Fujitsu Siemens DVB-C");
2886 MAKE_AV7110_INFO(fss,        "Fujitsu Siemens DVB-S rev1.6");
2887 MAKE_AV7110_INFO(gxs_1_3,    "Galaxis DVB-S rev1.3");
2888
2889 static struct pci_device_id pci_tbl[] = {
2890         MAKE_EXTENSION_PCI(fsc,         0x110a, 0x0000),
2891         MAKE_EXTENSION_PCI(tts_1_X_fsc, 0x13c2, 0x0000),
2892         MAKE_EXTENSION_PCI(ttt_1_X,     0x13c2, 0x0001),
2893         MAKE_EXTENSION_PCI(ttc_2_X,     0x13c2, 0x0002),
2894         MAKE_EXTENSION_PCI(tts_2_X,     0x13c2, 0x0003),
2895         MAKE_EXTENSION_PCI(gxs_1_3,     0x13c2, 0x0004),
2896         MAKE_EXTENSION_PCI(fss,         0x13c2, 0x0006),
2897         MAKE_EXTENSION_PCI(ttt,         0x13c2, 0x0008),
2898         MAKE_EXTENSION_PCI(ttc_1_X,     0x13c2, 0x000a),
2899         MAKE_EXTENSION_PCI(tts_2_3,     0x13c2, 0x000e),
2900         MAKE_EXTENSION_PCI(tts_1_3se,   0x13c2, 0x1002),
2901
2902 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2903 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2904
2905         {
2906                 .vendor    = 0,
2907         }
2908 };
2909
2910 MODULE_DEVICE_TABLE(pci, pci_tbl);
2911
2912
2913 static struct saa7146_extension av7110_extension_driver = {
2914         .name           = "av7110",
2915         .flags          = SAA7146_USE_I2C_IRQ,
2916
2917         .module         = THIS_MODULE,
2918         .pci_tbl        = &pci_tbl[0],
2919         .attach         = av7110_attach,
2920         .detach         = av7110_detach,
2921
2922         .irq_mask       = MASK_19 | MASK_03 | MASK_10,
2923         .irq_func       = av7110_irq,
2924 };
2925
2926
2927 static int __init av7110_init(void)
2928 {
2929         int retval;
2930         retval = saa7146_register_extension(&av7110_extension_driver);
2931         return retval;
2932 }
2933
2934
2935 static void __exit av7110_exit(void)
2936 {
2937         saa7146_unregister_extension(&av7110_extension_driver);
2938 }
2939
2940 module_init(av7110_init);
2941 module_exit(av7110_exit);
2942
2943 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2944                    "Siemens, Technotrend, Hauppauge");
2945 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2946 MODULE_LICENSE("GPL");