SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/dvb/ttpci/av7110.c

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