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