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