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