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