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