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