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