drivers/media/pci/ttpci/av7110.c

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