drivers/media/pci/ttpci/av7110.c

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