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