drivers/media/pci/ttpci/av7110.c

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