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