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