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