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