drivers/media/dvb/ttpci/av7110.c

   1 /*
   2  * driver for the SAA7146 based AV110 cards (like the Fujitsu-Siemens DVB)
   3  * av7110.c: initialization and demux stuff
   4  *
   5  * Copyright (C) 1999-2002 Ralph  Metzler
   6  *                       & Marcus Metzler for convergence integrated media GmbH
   7  *
   8  * originally based on code by:
   9  * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
  27  *
  28  *
  29  * the project's page is at http://www.linuxtv.org/dvb/
  30  */
  31
  32
  33 #include <linux/config.h>
  34 #include <linux/module.h>
  35 #include <linux/kmod.h>
  36 #include <linux/delay.h>
  37 #include <linux/fs.h>
  38 #include <linux/timer.h>
  39 #include <linux/poll.h>
  40 #include <linux/byteorder/swabb.h>
  41 #include <linux/smp_lock.h>
  42
  43 #include <linux/kernel.h>
  44 #include <linux/moduleparam.h>
  45 #include <linux/sched.h>
  46 #include <linux/types.h>
  47 #include <linux/fcntl.h>
  48 #include <linux/interrupt.h>
  49 #include <linux/string.h>
  50 #include <linux/pci.h>
  51 #include <linux/vmalloc.h>
  52 #include <linux/firmware.h>
  53 #include <linux/crc32.h>
  54 #include <linux/i2c.h>
  55
  56 #include <asm/system.h>
  57 #include <asm/semaphore.h>
  58
  59 #include <linux/dvb/frontend.h>
  60
  61 #include "dvb_frontend.h"
  62
  63 #include "ttpci-eeprom.h"
  64 #include "av7110.h"
  65 #include "av7110_hw.h"
  66 #include "av7110_av.h"
  67 #include "av7110_ca.h"
  68 #include "av7110_ipack.h"
  69
  70 int av7110_debug;
  71
  72 static int vidmode=CVBS_RGB_OUT;
  73 static int pids_off;
  74 static int adac=DVB_ADAC_TI;
  75 static int hw_sections;
  76 static int rgb_on;
  77 static int volume = 255;
  78
  79 module_param_named(debug, av7110_debug, int, 0644);
  80 MODULE_PARM_DESC(debug, "debug level (bitmask, default 0)");
  81 module_param(vidmode, int, 0444);
  82 MODULE_PARM_DESC(vidmode,"analog video out: 0 off, 1 CVBS+RGB (default), 2 CVBS+YC, 3 YC");
  83 module_param(pids_off, int, 0444);
  84 MODULE_PARM_DESC(pids_off,"clear video/audio/PCR PID filters when demux is closed");
  85 module_param(adac, int, 0444);
  86 MODULE_PARM_DESC(adac,"audio DAC type: 0 TI, 1 CRYSTAL, 2 MSP (use if autodetection fails)");
  87 module_param(hw_sections, int, 0444);
  88 MODULE_PARM_DESC(hw_sections, "0 use software section filter, 1 use hardware");
  89 module_param(rgb_on, int, 0444);
  90 MODULE_PARM_DESC(rgb_on, "For Siemens DVB-C cards only: Enable RGB control"
  91                 " signal on SCART pin 16 to switch SCART video mode from CVBS to RGB");
  92 module_param(volume, int, 0444);
  93 MODULE_PARM_DESC(volume, "initial volume: default 255 (range 0-255)");
  94
  95 static void restart_feeds(struct av7110 *av7110);
  96
  97 static int av7110_num = 0;
  98
  99 #define FE_FUNC_OVERRIDE(fe_func, av7110_copy, av7110_func) \
 100 {\
 101         if (fe_func != NULL) { \
 102                 av7110_copy = fe_func; \
 103                 fe_func = av7110_func; \
 104         } \
 105 }
 106
 107
 108 static void init_av7110_av(struct av7110 *av7110)
 109 {
 110         struct saa7146_dev *dev=av7110->dev;
 111
 112         /* set internal volume control to maximum */
 113         av7110->adac_type = DVB_ADAC_TI;
 114         av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
 115
 116         av7710_set_video_mode(av7110, vidmode);
 117
 118         /* handle different card types */
 119         /* remaining inits according to card and frontend type */
 120         av7110->analog_tuner_flags = 0;
 121         av7110->current_input = 0;
 122         if (i2c_writereg(av7110, 0x20, 0x00, 0x00) == 1) {
 123                 printk ("dvb-ttpci: Crystal audio DAC @ card %d detected\n",
 124                         av7110->dvb_adapter->num);
 125                 av7110->adac_type = DVB_ADAC_CRYSTAL;
 126                 i2c_writereg(av7110, 0x20, 0x01, 0xd2);
 127                 i2c_writereg(av7110, 0x20, 0x02, 0x49);
 128                 i2c_writereg(av7110, 0x20, 0x03, 0x00);
 129                 i2c_writereg(av7110, 0x20, 0x04, 0x00);
 130
 131         /**
 132          * some special handling for the Siemens DVB-C cards...
 133          */
 134         } else if (0 == av7110_init_analog_module(av7110)) {
 135                 /* done. */
 136         }
 137         else if (dev->pci->subsystem_vendor == 0x110a) {
 138                 printk("dvb-ttpci: DVB-C w/o analog module @ card %d detected\n",
 139                         av7110->dvb_adapter->num);
 140                 av7110->adac_type = DVB_ADAC_NONE;
 141         }
 142         else {
 143                 av7110->adac_type = adac;
 144                 printk("dvb-ttpci: adac type set to %d @ card %d\n",
 145                         av7110->dvb_adapter->num, av7110->adac_type);
 146         }
 147
 148         if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP) {
 149                 // switch DVB SCART on
 150                 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0);
 151                 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1);
 152                 if (rgb_on &&
 153                     (av7110->dev->pci->subsystem_vendor == 0x110a) && (av7110->dev->pci->subsystem_device == 0x0000)) {
 154                         saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16
 155                 //saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // SCARTpin 8
 156         }
 157         }
 158
 159         av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
 160         av7110_setup_irc_config(av7110, 0);
 161 }
 162
 163 static void recover_arm(struct av7110 *av7110)
 164 {
 165         dprintk(4, "%p\n",av7110);
 166
 167         av7110_bootarm(av7110);
 168         msleep(100);
 169         restart_feeds(av7110);
 170         av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, av7110->ir_config);
 171 }
 172
 173 static void arm_error(struct av7110 *av7110)
 174 {
 175         dprintk(4, "%p\n",av7110);
 176
 177         av7110->arm_errors++;
 178         av7110->arm_ready=0;
 179         recover_arm(av7110);
 180 }
 181
 182 static int arm_thread(void *data)
 183 {
 184         struct av7110 *av7110 = data;
 185         u16 newloops = 0;
 186         int timeout;
 187
 188         dprintk(4, "%p\n",av7110);
 189
 190         lock_kernel ();
 191         daemonize ("arm_mon");
 192         sigfillset (&current->blocked);
 193         unlock_kernel ();
 194
 195         av7110->arm_thread = current;
 196
 197         for (;;) {
 198                 timeout = wait_event_interruptible_timeout(av7110->arm_wait,
 199                                                            av7110->arm_rmmod, 5 * HZ);
 200                 if (-ERESTARTSYS == timeout || av7110->arm_rmmod) {
 201                         /* got signal or told to quit*/
 202                         break;
 203                 }
 204
 205                 if (!av7110->arm_ready)
 206                         continue;
 207
 208                 if (down_interruptible(&av7110->dcomlock))
 209                         break;
 210
 211                 newloops=rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
 212                 up(&av7110->dcomlock);
 213
 214                 if (newloops==av7110->arm_loops) {
 215                         printk(KERN_ERR "dvb-ttpci: ARM crashed @ card %d\n",
 216                                 av7110->dvb_adapter->num);
 217
 218                         arm_error(av7110);
 219                         av7710_set_video_mode(av7110, vidmode);
 220
 221                         init_av7110_av(av7110);
 222
 223                         if (down_interruptible(&av7110->dcomlock))
 224                                 break;
 225
 226                         newloops=rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2)-1;
 227                         up(&av7110->dcomlock);
 228                 }
 229                 av7110->arm_loops=newloops;
 230         }
 231
 232         av7110->arm_thread = NULL;
 233         return 0;
 234 }
 235
 236
 237 /**
 238  *  Hack! we save the last av7110 ptr. This should be ok, since
 239  *  you rarely will use more then one IR control.
 240  *
 241  *  If we want to support multiple controls we would have to do much more...
 242  */
 243 void av7110_setup_irc_config (struct av7110 *av7110, u32 ir_config)
 244 {
 245         static struct av7110 *last;
 246
 247         dprintk(4, "%p\n",av7110);
 248
 249         if (!av7110)
 250                 av7110 = last;
 251         else
 252                 last = av7110;
 253
 254         if (av7110) {
 255                 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
 256                 av7110->ir_config = ir_config;
 257         }
 258 }
 259
 260 static void (*irc_handler)(u32);
 261
 262 void av7110_register_irc_handler(void (*func)(u32))
 263 {
 264         dprintk(4, "registering %p\n", func);
 265         irc_handler = func;
 266 }
 267
 268 void av7110_unregister_irc_handler(void (*func)(u32))
 269 {
 270         dprintk(4, "unregistering %p\n", func);
 271         irc_handler = NULL;
 272 }
 273
 274 static void run_handlers(unsigned long ircom)
 275 {
 276         if (irc_handler != NULL)
 277                 (*irc_handler)((u32) ircom);
 278 }
 279
 280 static DECLARE_TASKLET(irtask, run_handlers, 0);
 281
 282 static void IR_handle(struct av7110 *av7110, u32 ircom)
 283 {
 284         dprintk(4, "ircommand = %08x\n", ircom);
 285         irtask.data = (unsigned long) ircom;
 286         tasklet_schedule(&irtask);
 287 }
 288
 289 /****************************************************************************
 290  * IRQ handling
 291  ****************************************************************************/
 292
 293 static int DvbDmxFilterCallback(u8 *buffer1, size_t buffer1_len,
 294                      u8 * buffer2, size_t buffer2_len,
 295                      struct dvb_demux_filter *dvbdmxfilter,
 296                      enum dmx_success success,
 297                      struct av7110 *av7110)
 298 {
 299         if (!dvbdmxfilter->feed->demux->dmx.frontend)
 300                 return 0;
 301         if (dvbdmxfilter->feed->demux->dmx.frontend->source==DMX_MEMORY_FE)
 302                 return 0;
 303
 304         switch(dvbdmxfilter->type) {
 305         case DMX_TYPE_SEC:
 306                 if ((((buffer1[1]<<8)|buffer1[2])&0xfff)+3!=buffer1_len)
 307                         return 0;
 308                 if (dvbdmxfilter->doneq) {
 309                         struct dmx_section_filter *filter=&dvbdmxfilter->filter;
 310                         int i;
 311                         u8 xor, neq=0;
 312
 313                         for (i=0; i<DVB_DEMUX_MASK_MAX; i++) {
 314                                 xor=filter->filter_value[i]^buffer1[i];
 315                                 neq|=dvbdmxfilter->maskandnotmode[i]&xor;
 316                         }
 317                         if (!neq)
 318                                 return 0;
 319                 }
 320                 return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len,
 321                                                   buffer2, buffer2_len,
 322                                                   &dvbdmxfilter->filter,
 323                                                   DMX_OK);
 324         case DMX_TYPE_TS:
 325                 if (!(dvbdmxfilter->feed->ts_type & TS_PACKET))
 326                         return 0;
 327                 if (dvbdmxfilter->feed->ts_type & TS_PAYLOAD_ONLY)
 328                         return dvbdmxfilter->feed->cb.ts(buffer1, buffer1_len,
 329                                                          buffer2, buffer2_len,
 330                                                          &dvbdmxfilter->feed->feed.ts,
 331                                                          DMX_OK);
 332                 else
 333                         av7110_p2t_write(buffer1, buffer1_len,
 334                                   dvbdmxfilter->feed->pid,
 335                                   &av7110->p2t_filter[dvbdmxfilter->index]);
 336         default:
 337                 return 0;
 338         }
 339 }
 340
 341
 342 //#define DEBUG_TIMING
 343 static inline void print_time(char *s)
 344 {
 345 #ifdef DEBUG_TIMING
 346         struct timeval tv;
 347         do_gettimeofday(&tv);
 348         printk("%s: %d.%d\n", s, (int)tv.tv_sec, (int)tv.tv_usec);
 349 #endif
 350 }
 351
 352 static void debiirq (unsigned long data)
 353 {
 354         struct av7110 *av7110 = (struct av7110*) data;
 355         int type=av7110->debitype;
 356         int handle=(type>>8)&0x1f;
 357
 358 //      dprintk(4, "%p\n",av7110);
 359
 360         print_time("debi");
 361         SAA7146_IER_DISABLE(av7110->dev, MASK_19);
 362         SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
 363
 364         if (type==-1) {
 365                 printk("DEBI irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
 366                        jiffies, saa7146_read(av7110->dev, PSR),
 367                        saa7146_read(av7110->dev, SSR));
 368                 spin_lock(&av7110->debilock);
 369                 ARM_ClearMailBox(av7110);
 370                 ARM_ClearIrq(av7110);
 371                 spin_unlock(&av7110->debilock);
 372                 return;
 373         }
 374         av7110->debitype=-1;
 375
 376         switch (type&0xff) {
 377
 378         case DATA_TS_RECORD:
 379                 dvb_dmx_swfilter_packets(&av7110->demux,
 380                                       (const u8 *)av7110->debi_virt,
 381                                       av7110->debilen/188);
 382                 spin_lock(&av7110->debilock);
 383                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 384                 ARM_ClearMailBox(av7110);
 385                 spin_unlock(&av7110->debilock);
 386                 return;
 387
 388         case DATA_PES_RECORD:
 389                 if (av7110->demux.recording)
 390                         av7110_record_cb(&av7110->p2t[handle],
 391                                   (u8 *)av7110->debi_virt,
 392                                   av7110->debilen);
 393                 spin_lock(&av7110->debilock);
 394                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 395                 ARM_ClearMailBox(av7110);
 396                 spin_unlock(&av7110->debilock);
 397                 return;
 398
 399         case DATA_IPMPE:
 400         case DATA_FSECTION:
 401         case DATA_PIPING:
 402                 if (av7110->handle2filter[handle])
 403                         DvbDmxFilterCallback((u8 *)av7110->debi_virt,
 404                                              av7110->debilen, NULL, 0,
 405                                              av7110->handle2filter[handle],
 406                                              DMX_OK, av7110);
 407                 spin_lock(&av7110->debilock);
 408                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 409                 ARM_ClearMailBox(av7110);
 410                 spin_unlock(&av7110->debilock);
 411                 return;
 412
 413         case DATA_CI_GET:
 414         {
 415                 u8 *data=av7110->debi_virt;
 416
 417                 if ((data[0]<2) && data[2]==0xff) {
 418                         int flags=0;
 419                         if (data[5]>0)
 420                                 flags|=CA_CI_MODULE_PRESENT;
 421                         if (data[5]>5)
 422                                 flags|=CA_CI_MODULE_READY;
 423                         av7110->ci_slot[data[0]].flags=flags;
 424                 } else
 425                         ci_get_data(&av7110->ci_rbuffer,
 426                                     av7110->debi_virt,
 427                                     av7110->debilen);
 428                 spin_lock(&av7110->debilock);
 429                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 430                 ARM_ClearMailBox(av7110);
 431                 spin_unlock(&av7110->debilock);
 432                 return;
 433         }
 434
 435         case DATA_COMMON_INTERFACE:
 436                 CI_handle(av7110, (u8 *)av7110->debi_virt, av7110->debilen);
 437 #if 0
 438         {
 439                 int i;
 440
 441                 printk("av7110%d: ", av7110->num);
 442                 printk("%02x ", *(u8 *)av7110->debi_virt);
 443                 printk("%02x ", *(1+(u8 *)av7110->debi_virt));
 444                 for (i=2; i<av7110->debilen; i++)
 445                   printk("%02x ", (*(i+(unsigned char *)av7110->debi_virt)));
 446                 for (i=2; i<av7110->debilen; i++)
 447                   printk("%c", chtrans(*(i+(unsigned char *)av7110->debi_virt)));
 448
 449                 printk("\n");
 450         }
 451 #endif
 452                 spin_lock(&av7110->debilock);
 453                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 454                 ARM_ClearMailBox(av7110);
 455                 spin_unlock(&av7110->debilock);
 456                 return;
 457
 458         case DATA_DEBUG_MESSAGE:
 459                 ((s8*)av7110->debi_virt)[Reserved_SIZE-1]=0;
 460                 printk("%s\n", (s8 *)av7110->debi_virt);
 461                 spin_lock(&av7110->debilock);
 462                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 463                 ARM_ClearMailBox(av7110);
 464                 spin_unlock(&av7110->debilock);
 465                 return;
 466
 467         case DATA_CI_PUT:
 468         case DATA_MPEG_PLAY:
 469         case DATA_BMP_LOAD:
 470                 spin_lock(&av7110->debilock);
 471                 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 472                 ARM_ClearMailBox(av7110);
 473                 spin_unlock(&av7110->debilock);
 474                 return;
 475         default:
 476                 break;
 477         }
 478         spin_lock(&av7110->debilock);
 479         ARM_ClearMailBox(av7110);
 480         spin_unlock(&av7110->debilock);
 481 }
 482
 483 static void gpioirq (unsigned long data)
 484 {
 485         struct av7110 *av7110 = (struct av7110*) data;
 486         u32 rxbuf, txbuf;
 487         int len;
 488
 489         if (av7110->debitype !=-1)
 490                 printk("dvb-ttpci: GPIO0 irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
 491                        jiffies, saa7146_read(av7110->dev, PSR),
 492                        saa7146_read(av7110->dev, SSR));
 493
 494         spin_lock(&av7110->debilock);
 495
 496         ARM_ClearIrq(av7110);
 497
 498         SAA7146_IER_DISABLE(av7110->dev, MASK_19);
 499         SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
 500
 501         av7110->debitype = irdebi(av7110, DEBINOSWAP, IRQ_STATE, 0, 2);
 502         av7110->debilen  = irdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 503         rxbuf=irdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 504         txbuf=irdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 505         len = (av7110->debilen + 3) & ~3;
 506
 507 //      dprintk(8, "GPIO0 irq %d %d\n", av7110->debitype, av7110->debilen);
 508         print_time("gpio");
 509
 510 //      dprintk(8, "GPIO0 irq %02x\n", av7110->debitype&0xff);
 511         switch (av7110->debitype&0xff) {
 512
 513         case DATA_TS_PLAY:
 514         case DATA_PES_PLAY:
 515                 break;
 516
 517         case DATA_MPEG_VIDEO_EVENT:
 518         {
 519                 u32 h_ar;
 520                 struct video_event event;
 521
 522                 av7110->video_size.w = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_WIDTH, 0, 2);
 523                 h_ar = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_HEIGHT_AR, 0, 2);
 524
 525                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 526                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 527
 528                 av7110->video_size.h = h_ar & 0xfff;
 529                 dprintk(8, "GPIO0 irq: DATA_MPEG_VIDEO_EVENT: w/h/ar = %u/%u/%u\n",
 530                                 av7110->video_size.w,
 531                                 av7110->video_size.h,
 532                                 av7110->video_size.aspect_ratio);
 533
 534                 event.type = VIDEO_EVENT_SIZE_CHANGED;
 535                 event.u.size.w = av7110->video_size.w;
 536                 event.u.size.h = av7110->video_size.h;
 537                 switch ((h_ar >> 12) & 0xf)
 538                 {
 539                 case 3:
 540                         av7110->video_size.aspect_ratio = VIDEO_FORMAT_16_9;
 541                         event.u.size.aspect_ratio = VIDEO_FORMAT_16_9;
 542                         av7110->videostate.video_format = VIDEO_FORMAT_16_9;
 543                         break;
 544                 case 4:
 545                         av7110->video_size.aspect_ratio = VIDEO_FORMAT_221_1;
 546                         event.u.size.aspect_ratio = VIDEO_FORMAT_221_1;
 547                         av7110->videostate.video_format = VIDEO_FORMAT_221_1;
 548                         break;
 549                 default:
 550                         av7110->video_size.aspect_ratio = VIDEO_FORMAT_4_3;
 551                         event.u.size.aspect_ratio = VIDEO_FORMAT_4_3;
 552                         av7110->videostate.video_format = VIDEO_FORMAT_4_3;
 553                 }
 554                 dvb_video_add_event(av7110, &event);
 555                 break;
 556         }
 557
 558         case DATA_CI_PUT:
 559         {
 560                 int avail;
 561                 struct dvb_ringbuffer *cibuf=&av7110->ci_wbuffer;
 562
 563                 avail=dvb_ringbuffer_avail(cibuf);
 564                 if (avail<=2) {
 565                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 566                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 567                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 568                         break;
 569                 }
 570                 len= DVB_RINGBUFFER_PEEK(cibuf,0)<<8;
 571                 len|=DVB_RINGBUFFER_PEEK(cibuf,1);
 572                 if (avail<len+2) {
 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                 DVB_RINGBUFFER_SKIP(cibuf,2);
 579
 580                 dvb_ringbuffer_read(cibuf,av7110->debi_virt,len,0);
 581
 582                 wake_up(&cibuf->queue);
 583                 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
 584                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
 585                 saa7146_wait_for_debi_done(av7110->dev, 0);
 586                 saa7146_write(av7110->dev, IER,
 587                               saa7146_read(av7110->dev, IER) | MASK_19 );
 588                 if (len < 5)
 589                         len = 5; /* we want a real DEBI DMA */
 590                 iwdebi(av7110, DEBISWAB, DPRAM_BASE+txbuf, 0, (len+3)&~3);
 591                 spin_unlock(&av7110->debilock);
 592                 return;
 593         }
 594
 595         case DATA_MPEG_PLAY:
 596                 if (!av7110->playing) {
 597                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 598                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 599                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 600                         break;
 601                 }
 602                 len=0;
 603                 if (av7110->debitype&0x100) {
 604                         spin_lock(&av7110->aout.lock);
 605                         len=av7110_pes_play(av7110->debi_virt, &av7110->aout, 2048);
 606                         spin_unlock(&av7110->aout.lock);
 607                 }
 608                 if (len<=0 && (av7110->debitype&0x200)
 609                         &&av7110->videostate.play_state!=VIDEO_FREEZED) {
 610                         spin_lock(&av7110->avout.lock);
 611                         len=av7110_pes_play(av7110->debi_virt, &av7110->avout, 2048);
 612                         spin_unlock(&av7110->avout.lock);
 613                 }
 614                 if (len<=0) {
 615                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 616                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 617                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 618                         break;
 619                 }
 620                 dprintk(8, "GPIO0 PES_PLAY len=%04x\n", len);
 621                 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
 622                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
 623                 saa7146_wait_for_debi_done(av7110->dev, 0);
 624                 saa7146_write(av7110->dev, IER,
 625                               saa7146_read(av7110->dev, IER) | MASK_19 );
 626
 627                 iwdebi(av7110, DEBISWAB, DPRAM_BASE+txbuf, 0, (len+3)&~3);
 628                 spin_unlock(&av7110->debilock);
 629                 return;
 630
 631         case DATA_BMP_LOAD:
 632                 len=av7110->debilen;
 633                 if (!len) {
 634                         av7110->bmp_state=BMP_LOADED;
 635                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 636                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 637                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 638                         wake_up(&av7110->bmpq);
 639                         break;
 640                 }
 641                 if (len>av7110->bmplen)
 642                         len=av7110->bmplen;
 643                 if (len>2*1024)
 644                         len=2*1024;
 645                 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
 646                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
 647                 memcpy(av7110->debi_virt, av7110->bmpbuf+av7110->bmpp, len);
 648                 av7110->bmpp+=len;
 649                 av7110->bmplen-=len;
 650                 saa7146_wait_for_debi_done(av7110->dev, 0);
 651                 saa7146_write(av7110->dev, IER,
 652                               saa7146_read(av7110->dev, IER) | MASK_19 );
 653                 if (len < 5)
 654                         len = 5; /* we want a real DEBI DMA */
 655                 iwdebi(av7110, DEBISWAB, DPRAM_BASE+txbuf, 0, (len+3)&~3);
 656                 spin_unlock(&av7110->debilock);
 657                 return;
 658
 659         case DATA_CI_GET:
 660         case DATA_COMMON_INTERFACE:
 661         case DATA_FSECTION:
 662         case DATA_IPMPE:
 663         case DATA_PIPING:
 664                 if (!len || len>4*1024) {
 665                         iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 666                         break;
 667                 }
 668                 /* fall through */
 669
 670         case DATA_TS_RECORD:
 671         case DATA_PES_RECORD:
 672                 saa7146_wait_for_debi_done(av7110->dev, 0);
 673                 saa7146_write(av7110->dev, IER,
 674                               saa7146_read(av7110->dev, IER) | MASK_19);
 675                 irdebi(av7110, DEBISWAB, DPRAM_BASE+rxbuf, 0, len);
 676                 spin_unlock(&av7110->debilock);
 677                 return;
 678
 679         case DATA_DEBUG_MESSAGE:
 680                 saa7146_wait_for_debi_done(av7110->dev, 0);
 681                 if (!len || len>0xff) {
 682                         iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 683                         break;
 684                 }
 685                 saa7146_write(av7110->dev, IER,
 686                               saa7146_read(av7110->dev, IER) | MASK_19);
 687                 irdebi(av7110, DEBISWAB, Reserved, 0, len);
 688                 spin_unlock(&av7110->debilock);
 689                 return;
 690
 691         case DATA_IRCOMMAND:
 692                 IR_handle(av7110,
 693                           swahw32(irdebi(av7110, DEBINOSWAP, Reserved, 0, 4)));
 694                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 695                 break;
 696
 697         default:
 698                 printk("dvb-ttpci: gpioirq unknown type=%d len=%d\n",
 699                        av7110->debitype, av7110->debilen);
 700                 break;
 701         }
 702         ARM_ClearMailBox(av7110);
 703         av7110->debitype=-1;
 704         spin_unlock(&av7110->debilock);
 705 }
 706
 707
 708 #ifdef CONFIG_DVB_AV7110_OSD
 709 static int dvb_osd_ioctl(struct inode *inode, struct file *file,
 710                          unsigned int cmd, void *parg)
 711 {
 712         struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
 713         struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
 714
 715         dprintk(4, "%p\n", av7110);
 716
 717         if (cmd == OSD_SEND_CMD)
 718                 return av7110_osd_cmd(av7110, (osd_cmd_t *) parg);
 719         if (cmd == OSD_GET_CAPABILITY)
 720                 return av7110_osd_capability(av7110, (osd_cap_t *) parg);
 721
 722         return -EINVAL;
 723         }
 724
 725
 726 static struct file_operations dvb_osd_fops = {
 727         .owner          = THIS_MODULE,
 728         .ioctl          = dvb_generic_ioctl,
 729         .open           = dvb_generic_open,
 730         .release        = dvb_generic_release,
 731 };
 732
 733 static struct dvb_device dvbdev_osd = {
 734         .priv           = NULL,
 735         .users          = 1,
 736         .writers        = 1,
 737         .fops           = &dvb_osd_fops,
 738         .kernel_ioctl   = dvb_osd_ioctl,
 739 };
 740 #endif /* CONFIG_DVB_AV7110_OSD */
 741
 742
 743 static inline int SetPIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
 744                           u16 subpid, u16 pcrpid)
 745         {
 746         dprintk(4, "%p\n", av7110);
 747
 748         if (vpid == 0x1fff || apid == 0x1fff ||
 749             ttpid == 0x1fff || subpid == 0x1fff || pcrpid == 0x1fff) {
 750                 vpid = apid = ttpid = subpid = pcrpid = 0;
 751                 av7110->pids[DMX_PES_VIDEO] = 0;
 752                 av7110->pids[DMX_PES_AUDIO] = 0;
 753                 av7110->pids[DMX_PES_TELETEXT] = 0;
 754                 av7110->pids[DMX_PES_PCR] = 0;
 755         }
 756
 757         return av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, MultiPID, 5,
 758                              pcrpid, vpid, apid, ttpid, subpid);
 759 }
 760
 761 void ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
 762                 u16 subpid, u16 pcrpid)
 763 {
 764         dprintk(4, "%p\n", av7110);
 765
 766         if (down_interruptible(&av7110->pid_mutex))
 767                 return;
 768
 769         if (!(vpid & 0x8000))
 770                 av7110->pids[DMX_PES_VIDEO] = vpid;
 771         if (!(apid & 0x8000))
 772                 av7110->pids[DMX_PES_AUDIO] = apid;
 773         if (!(ttpid & 0x8000))
 774                 av7110->pids[DMX_PES_TELETEXT] = ttpid;
 775         if (!(pcrpid & 0x8000))
 776                 av7110->pids[DMX_PES_PCR] = pcrpid;
 777
 778         av7110->pids[DMX_PES_SUBTITLE] = 0;
 779
 780         if (av7110->fe_synced) {
 781                 pcrpid = av7110->pids[DMX_PES_PCR];
 782                 SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
 783         }
 784
 785         up(&av7110->pid_mutex);
 786 }
 787
 788
 789 /******************************************************************************
 790  * hardware filter functions
 791  ******************************************************************************/
 792
 793 static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter)
 794 {
 795         struct dvb_demux_feed *dvbdmxfeed = dvbdmxfilter->feed;
 796         struct av7110 *av7110 = (struct av7110 *) dvbdmxfeed->demux->priv;
 797         u16 buf[20];
 798         int ret, i;
 799         u16 handle;
 800 //      u16 mode=0x0320;
 801         u16 mode=0xb96a;
 802
 803         dprintk(4, "%p\n", av7110);
 804
 805         if (dvbdmxfilter->type == DMX_TYPE_SEC) {
 806                 if (hw_sections) {
 807                         buf[4] = (dvbdmxfilter->filter.filter_value[0] << 8) |
 808                                 dvbdmxfilter->maskandmode[0];
 809                         for (i = 3; i < 18; i++)
 810                                 buf[i + 4 - 2] =
 811                                         (dvbdmxfilter->filter.filter_value[i] << 8) |
 812                                         dvbdmxfilter->maskandmode[i];
 813                         mode = 4;
 814                 }
 815         } else if ((dvbdmxfeed->ts_type & TS_PACKET) &&
 816                    !(dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)) {
 817                 av7110_p2t_init(&av7110->p2t_filter[dvbdmxfilter->index], dvbdmxfeed);
 818         }
 819
 820         buf[0] = (COMTYPE_PID_FILTER << 8) + AddPIDFilter;
 821         buf[1] = 16;
 822         buf[2] = dvbdmxfeed->pid;
 823         buf[3] = mode;
 824
 825         ret = av7110_fw_request(av7110, buf, 20, &handle, 1);
 826         if (ret != 0 || handle >= 32) {
 827                 printk("dvb-ttpci: %s error  buf %04x %04x %04x %04x  "
 828                                 "ret %x  handle %04x\n",
 829                                 __FUNCTION__, buf[0], buf[1], buf[2], buf[3],
 830                                 ret, handle);
 831                 dvbdmxfilter->hw_handle = 0xffff;
 832                 return -1;
 833         }
 834
 835         av7110->handle2filter[handle] = dvbdmxfilter;
 836         dvbdmxfilter->hw_handle = handle;
 837
 838         return ret;
 839                 }
 840
 841 static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
 842 {
 843         struct av7110 *av7110 = (struct av7110 *) dvbdmxfilter->feed->demux->priv;
 844         u16 buf[3];
 845         u16 answ[2];
 846         int ret;
 847         u16 handle;
 848
 849         dprintk(4, "%p\n", av7110);
 850
 851         handle = dvbdmxfilter->hw_handle;
 852         if (handle >= 32) {
 853                 printk("%s tried to stop invalid filter %04x, filter type = %x\n",
 854                                 __FUNCTION__, handle, dvbdmxfilter->type);
 855                 return 0;
 856                 }
 857
 858         av7110->handle2filter[handle] = NULL;
 859
 860         buf[0] = (COMTYPE_PID_FILTER << 8) + DelPIDFilter;
 861         buf[1] = 1;
 862         buf[2] = handle;
 863         ret = av7110_fw_request(av7110, buf, 3, answ, 2);
 864         if (ret != 0 || answ[1] != handle) {
 865                 printk("dvb-ttpci: %s error  cmd %04x %04x %04x  ret %x  "
 866                                 "resp %04x %04x  pid %d\n",
 867                                 __FUNCTION__, buf[0], buf[1], buf[2], ret,
 868                                 answ[0], answ[1], dvbdmxfilter->feed->pid);
 869                 ret = -1;
 870         }
 871         return ret;
 872 }
 873
 874
 875 static void dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
 876 {
 877         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
 878         struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
 879         u16 *pid = dvbdmx->pids, npids[5];
 880         int i;
 881
 882         dprintk(4, "%p\n", av7110);
 883
 884         npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
 885         i = dvbdmxfeed->pes_type;
 886         npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
 887         if ((i == 2) && npids[i] && (dvbdmxfeed->ts_type & TS_PACKET)) {
 888                 npids[i] = 0;
 889                 ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
 890                 StartHWFilter(dvbdmxfeed->filter);
 891                 return;
 892         }
 893         if (dvbdmxfeed->pes_type <= 2 || dvbdmxfeed->pes_type == 4)
 894                 ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
 895
 896         if (dvbdmxfeed->pes_type < 2 && npids[0])
 897                 if (av7110->fe_synced)
 898                         av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
 899
 900         if ((dvbdmxfeed->ts_type & TS_PACKET)) {
 901                 if (dvbdmxfeed->pes_type == 0 && !(dvbdmx->pids[0] & 0x8000))
 902                         av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed);
 903                 if (dvbdmxfeed->pes_type == 1 && !(dvbdmx->pids[1] & 0x8000))
 904                         av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed);
 905         }
 906 }
 907
 908 static void dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
 909 {
 910         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
 911         struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
 912         u16 *pid = dvbdmx->pids, npids[5];
 913         int i;
 914
 915         dprintk(4, "%p\n", av7110);
 916
 917         if (dvbdmxfeed->pes_type <= 1) {
 918                 av7110_av_stop(av7110, dvbdmxfeed->pes_type ?  RP_VIDEO : RP_AUDIO);
 919                 if (!av7110->rec_mode)
 920                         dvbdmx->recording = 0;
 921                 if (!av7110->playing)
 922                         dvbdmx->playing = 0;
 923         }
 924         npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
 925         i = dvbdmxfeed->pes_type;
 926         switch (i) {
 927         case 2: //teletext
 928                 if (dvbdmxfeed->ts_type & TS_PACKET)
 929                         StopHWFilter(dvbdmxfeed->filter);
 930                 npids[2] = 0;
 931                 break;
 932         case 0:
 933         case 1:
 934         case 4:
 935                 if (!pids_off)
 936                         return;
 937                 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
 938                 break;
 939         }
 940         ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
 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
 948         dprintk(4, "%p\n", av7110);
 949
 950         if (!demux->dmx.frontend)
 951                 return -EINVAL;
 952
 953         if (feed->pid > 0x1fff)
 954                 return -EINVAL;
 955
 956         if (feed->type == DMX_TYPE_TS) {
 957                 if ((feed->ts_type & TS_DECODER) &&
 958                     (feed->pes_type < DMX_TS_PES_OTHER)) {
 959                         switch (demux->dmx.frontend->source) {
 960                         case DMX_MEMORY_FE:
 961                                 if (feed->ts_type & TS_DECODER)
 962                                        if (feed->pes_type < 2 &&
 963                                            !(demux->pids[0] & 0x8000) &&
 964                                            !(demux->pids[1] & 0x8000)) {
 965                                                dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
 966                                                dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
 967                                                av7110_av_start_play(av7110,RP_AV);
 968                                                demux->playing = 1;
 969                                         }
 970                         break;
 971                 default:
 972                                 dvb_feed_start_pid(feed);
 973                         break;
 974                 }
 975                 } else if ((feed->ts_type & TS_PACKET) &&
 976                            (demux->dmx.frontend->source != DMX_MEMORY_FE)) {
 977                         StartHWFilter(feed->filter);
 978                 }
 979         }
 980
 981         if (feed->type == DMX_TYPE_SEC) {
 982                 int i;
 983
 984                 for (i = 0; i < demux->filternum; i++) {
 985                         if (demux->filter[i].state != DMX_STATE_READY)
 986                                 continue;
 987                         if (demux->filter[i].type != DMX_TYPE_SEC)
 988                                 continue;
 989                         if (demux->filter[i].filter.parent != &feed->feed.sec)
 990                                 continue;
 991                         demux->filter[i].state = DMX_STATE_GO;
 992                         if (demux->dmx.frontend->source != DMX_MEMORY_FE)
 993                                 StartHWFilter(&demux->filter[i]);
 994         }
 995         }
 996
 997         return 0;
 998 }
 999
1000
1001 static int av7110_stop_feed(struct dvb_demux_feed *feed)
1002 {
1003         struct dvb_demux *demux = feed->demux;
1004         struct av7110 *av7110 = demux->priv;
1005
1006         dprintk(4, "%p\n", av7110);
1007
1008         if (feed->type == DMX_TYPE_TS) {
1009                 if (feed->ts_type & TS_DECODER) {
1010                         if (feed->pes_type >= DMX_TS_PES_OTHER ||
1011                             !demux->pesfilter[feed->pes_type])
1012                                 return -EINVAL;
1013                         demux->pids[feed->pes_type] |= 0x8000;
1014                         demux->pesfilter[feed->pes_type] = NULL;
1015                 }
1016                 if (feed->ts_type & TS_DECODER &&
1017                     feed->pes_type < DMX_TS_PES_OTHER) {
1018                         dvb_feed_stop_pid(feed);
1019                 } else
1020                         if ((feed->ts_type & TS_PACKET) &&
1021                             (demux->dmx.frontend->source != DMX_MEMORY_FE))
1022                                 StopHWFilter(feed->filter);
1023         }
1024
1025         if (feed->type == DMX_TYPE_SEC) {
1026                 int i;
1027
1028                 for (i=0; i<demux->filternum; i++)
1029                         if (demux->filter[i].state == DMX_STATE_GO &&
1030                             demux->filter[i].filter.parent == &feed->feed.sec) {
1031                                 demux->filter[i].state = DMX_STATE_READY;
1032                                 if (demux->dmx.frontend->source != DMX_MEMORY_FE)
1033                                         StopHWFilter(&demux->filter[i]);
1034                 }
1035         }
1036
1037         return 0;
1038 }
1039
1040
1041 static void restart_feeds(struct av7110 *av7110)
1042 {
1043         struct dvb_demux *dvbdmx = &av7110->demux;
1044         struct dvb_demux_feed *feed;
1045         int mode;
1046         int i;
1047
1048         dprintk(4, "%p\n", av7110);
1049
1050         mode = av7110->playing;
1051         av7110->playing = 0;
1052         av7110->rec_mode = 0;
1053
1054         for (i = 0; i < dvbdmx->filternum; i++) {
1055                 feed = &dvbdmx->feed[i];
1056                 if (feed->state == DMX_STATE_GO)
1057                         av7110_start_feed(feed);
1058         }
1059
1060         if (mode)
1061                 av7110_av_start_play(av7110, mode);
1062 }
1063
1064 static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
1065                        uint64_t *stc, unsigned int *base)
1066 {
1067         int ret;
1068         u16 fwstc[4];
1069         u16 tag = ((COMTYPE_REQUEST << 8) + ReqSTC);
1070         struct dvb_demux *dvbdemux;
1071         struct av7110 *av7110;
1072
1073         /* pointer casting paranoia... */
1074         if (!demux)
1075                 BUG();
1076         dvbdemux = (struct dvb_demux *) demux->priv;
1077         if (!dvbdemux)
1078                 BUG();
1079         av7110 = (struct av7110 *) dvbdemux->priv;
1080
1081         dprintk(4, "%p\n", av7110);
1082
1083         if (num != 0)
1084                 return -EINVAL;
1085
1086         ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4);
1087         if (ret) {
1088                 printk(KERN_ERR "%s: av7110_fw_request error\n", __FUNCTION__);
1089                 return -EIO;
1090 }
1091         dprintk(2, "fwstc = %04hx %04hx %04hx %04hx\n",
1092                 fwstc[0], fwstc[1], fwstc[2], fwstc[3]);
1093
1094         *stc =  (((uint64_t) ((fwstc[3] & 0x8000) >> 15)) << 32) |
1095                 (((uint64_t)  fwstc[1]) << 16) | ((uint64_t) fwstc[0]);
1096         *base = 1;
1097
1098         dprintk(4, "stc = %lu\n", (unsigned long)*stc);
1099
1100         return 0;
1101 }
1102
1103
1104 /******************************************************************************
1105  * SEC device file operations
1106  ******************************************************************************/
1107
1108
1109 static int av7110_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
1110 {
1111         struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1112
1113         switch (tone) {
1114                 case SEC_TONE_ON:
1115                         Set22K(av7110, 1);
1116                         break;
1117                 case SEC_TONE_OFF:
1118                         Set22K(av7110, 0);
1119                         break;
1120
1121                 default:
1122                         return -EINVAL;
1123         }
1124
1125         return 0;
1126 }
1127
1128 static int av7110_diseqc_send_master_cmd(struct dvb_frontend* fe,
1129                                          struct dvb_diseqc_master_cmd* cmd)
1130 {
1131         struct av7110* av7110 = fe->dvb->priv;
1132
1133         av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1);
1134
1135         return 0;
1136 }
1137
1138 static int av7110_diseqc_send_burst(struct dvb_frontend* fe,
1139                                     fe_sec_mini_cmd_t minicmd)
1140 {
1141         struct av7110* av7110 = fe->dvb->priv;
1142
1143         av7110_diseqc_send(av7110, 0, NULL, minicmd);
1144
1145         return 0;
1146 }
1147
1148
1149 static int av7110_register(struct av7110 *av7110)
1150 {
1151         int ret, i;
1152         struct dvb_demux *dvbdemux=&av7110->demux;
1153
1154         dprintk(4, "%p\n", av7110);
1155
1156         if (av7110->registered)
1157                 return -1;
1158
1159         av7110->registered=1;
1160
1161         dvbdemux->priv = (void *) av7110;
1162
1163         for (i=0; i<32; i++)
1164                 av7110->handle2filter[i]=NULL;
1165
1166         dvbdemux->filternum = 32;
1167         dvbdemux->feednum = 32;
1168         dvbdemux->start_feed = av7110_start_feed;
1169         dvbdemux->stop_feed = av7110_stop_feed;
1170         dvbdemux->write_to_decoder = av7110_write_to_decoder;
1171         dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1172                                       DMX_MEMORY_BASED_FILTERING);
1173
1174         dvb_dmx_init(&av7110->demux);
1175         av7110->demux.dmx.get_stc = dvb_get_stc;
1176
1177         av7110->dmxdev.filternum = 32;
1178         av7110->dmxdev.demux = &dvbdemux->dmx;
1179         av7110->dmxdev.capabilities = 0;
1180
1181         dvb_dmxdev_init(&av7110->dmxdev, av7110->dvb_adapter);
1182
1183         av7110->hw_frontend.source = DMX_FRONTEND_0;
1184
1185         ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1186
1187         if (ret < 0)
1188                 return ret;
1189
1190         av7110->mem_frontend.source = DMX_MEMORY_FE;
1191
1192         ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1193
1194         if (ret < 0)
1195                 return ret;
1196
1197         ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1198                                              &av7110->hw_frontend);
1199         if (ret < 0)
1200                 return ret;
1201
1202         av7110_av_register(av7110);
1203         av7110_ca_register(av7110);
1204
1205 #ifdef CONFIG_DVB_AV7110_OSD
1206         dvb_register_device(av7110->dvb_adapter, &av7110->osd_dev,
1207                             &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1208 #endif
1209
1210         dvb_net_init(av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1211
1212         return 0;
1213 }
1214
1215
1216 static void dvb_unregister(struct av7110 *av7110)
1217 {
1218         struct dvb_demux *dvbdemux=&av7110->demux;
1219
1220         dprintk(4, "%p\n", av7110);
1221
1222         if (!av7110->registered)
1223                 return;
1224
1225         dvb_net_release(&av7110->dvb_net);
1226
1227         dvbdemux->dmx.close(&dvbdemux->dmx);
1228         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1229         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1230
1231         dvb_dmxdev_release(&av7110->dmxdev);
1232         dvb_dmx_release(&av7110->demux);
1233
1234         if (av7110->fe != NULL)
1235                 dvb_unregister_frontend(av7110->fe);
1236         dvb_unregister_device(av7110->osd_dev);
1237         av7110_av_unregister(av7110);
1238         av7110_ca_unregister(av7110);
1239 }
1240
1241
1242 /****************************************************************************
1243  * I2C client commands
1244  ****************************************************************************/
1245
1246 int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1247 {
1248         u8 msg[2] = { reg, val };
1249         struct i2c_msg msgs;
1250
1251         msgs.flags = 0;
1252         msgs.addr = id / 2;
1253         msgs.len = 2;
1254         msgs.buf = msg;
1255         return i2c_transfer(&av7110->i2c_adap, &msgs, 1);
1256 }
1257
1258 #if 0
1259 u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1260 {
1261         u8 mm1[] = {0x00};
1262         u8 mm2[] = {0x00};
1263         struct i2c_msg msgs[2];
1264
1265         msgs[0].flags = 0;
1266         msgs[1].flags = I2C_M_RD;
1267         msgs[0].addr = msgs[1].addr = id / 2;
1268         mm1[0] = reg;
1269         msgs[0].len = 1; msgs[1].len = 1;
1270         msgs[0].buf = mm1; msgs[1].buf = mm2;
1271         i2c_transfer(&av7110->i2c_adap, msgs, 2);
1272
1273         return mm2[0];
1274 }
1275 #endif
1276
1277 /****************************************************************************
1278  * INITIALIZATION
1279  ****************************************************************************/
1280
1281
1282 static int check_firmware(struct av7110* av7110)
1283 {
1284         u32 crc = 0, len = 0;
1285         unsigned char *ptr;
1286
1287         /* check for firmware magic */
1288         ptr = av7110->bin_fw;
1289         if (ptr[0] != 'A' || ptr[1] != 'V' ||
1290             ptr[2] != 'F' || ptr[3] != 'W') {
1291                 printk("dvb-ttpci: this is not an av7110 firmware\n");
1292                 return -EINVAL;
1293         }
1294         ptr += 4;
1295
1296         /* check dpram file */
1297         crc = ntohl(*(u32*)ptr);
1298         ptr += 4;
1299         len = ntohl(*(u32*)ptr);
1300         ptr += 4;
1301         if (len >= 512) {
1302                 printk("dvb-ttpci: dpram file is way to big.\n");
1303                 return -EINVAL;
1304         }
1305         if( crc != crc32_le(0,ptr,len)) {
1306                 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1307                 return -EINVAL;
1308         }
1309         av7110->bin_dpram = ptr;
1310         av7110->size_dpram = len;
1311         ptr += len;
1312
1313         /* check root file */
1314         crc = ntohl(*(u32*)ptr);
1315         ptr += 4;
1316         len = ntohl(*(u32*)ptr);
1317         ptr += 4;
1318
1319         if (len <= 200000 || len >= 300000 ||
1320             len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1321                 printk("dvb-ttpci: root file has strange size (%d). aborting.\n",len);
1322                 return -EINVAL;
1323         }
1324         if( crc != crc32_le(0,ptr,len)) {
1325                 printk("dvb-ttpci: crc32 of root file does not match.\n");
1326                 return -EINVAL;
1327         }
1328         av7110->bin_root = ptr;
1329         av7110->size_root = len;
1330         return 0;
1331 }
1332
1333 #ifdef CONFIG_DVB_AV7110_FIRMWARE_FILE
1334 #include "av7110_firm.h"
1335 static inline int get_firmware(struct av7110* av7110)
1336 {
1337         av7110->bin_fw = dvb_ttpci_fw;
1338         av7110->size_fw = sizeof(dvb_ttpci_fw);
1339         return check_firmware(av7110);
1340 }
1341 #else
1342 static int get_firmware(struct av7110* av7110)
1343 {
1344         int ret;
1345         const struct firmware *fw;
1346
1347         /* request the av7110 firmware, this will block until someone uploads it */
1348         ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev);
1349         if (ret) {
1350                 if (ret == -ENOENT) {
1351                         printk(KERN_ERR "dvb-ttpci: could not load firmware,"
1352                                " file not found: dvb-ttpci-01.fw\n");
1353                         printk(KERN_ERR "dvb-ttpci: usually this should be in"
1354                                " /usr/lib/hotplug/firmware\n");
1355                         printk(KERN_ERR "dvb-ttpci: and can be downloaded here"
1356                                " http://www.linuxtv.org/download/dvb/firmware/\n");
1357                 } else
1358                         printk(KERN_ERR "dvb-ttpci: cannot request firmware"
1359                                " (error %i)\n", ret);
1360                 return -EINVAL;
1361         }
1362
1363         if (fw->size <= 200000) {
1364                 printk("dvb-ttpci: this firmware is way too small.\n");
1365                 release_firmware(fw);
1366                 return -EINVAL;
1367         }
1368
1369         /* check if the firmware is available */
1370         av7110->bin_fw = (unsigned char*) vmalloc(fw->size);
1371         if (NULL == av7110->bin_fw) {
1372                 dprintk(1, "out of memory\n");
1373                 release_firmware(fw);
1374                 return -ENOMEM;
1375         }
1376
1377         memcpy(av7110->bin_fw, fw->data, fw->size);
1378         av7110->size_fw = fw->size;
1379         if ((ret = check_firmware(av7110)))
1380                 vfree(av7110->bin_fw);
1381
1382         release_firmware(fw);
1383         return ret;
1384 }
1385 #endif
1386
1387
1388 static int alps_bsrv2_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1389 {
1390         struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1391         u8 pwr = 0;
1392         u8 buf[4];
1393         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) };
1394         u32 div = (params->frequency + 479500) / 125;
1395
1396         if (params->frequency > 2000000) pwr = 3;
1397         else if (params->frequency > 1800000) pwr = 2;
1398         else if (params->frequency > 1600000) pwr = 1;
1399         else if (params->frequency > 1200000) pwr = 0;
1400         else if (params->frequency >= 1100000) pwr = 1;
1401         else pwr = 2;
1402
1403         buf[0] = (div >> 8) & 0x7f;
1404         buf[1] = div & 0xff;
1405         buf[2] = ((div & 0x18000) >> 10) | 0x95;
1406         buf[3] = (pwr << 6) | 0x30;
1407
1408         // NOTE: since we're using a prescaler of 2, we set the
1409         // divisor frequency to 62.5kHz and divide by 125 above
1410
1411         if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1412                 return -EIO;
1413         return 0;
1414 }
1415
1416 static struct ves1x93_config alps_bsrv2_config = {
1417         .demod_address = 0x08,
1418         .xin = 90100000UL,
1419         .invert_pwm = 0,
1420         .pll_set = alps_bsrv2_pll_set,
1421 };
1422
1423
1424 static u8 alps_bsru6_inittab[] = {
1425         0x01, 0x15,
1426         0x02, 0x30,
1427         0x03, 0x00,
1428         0x04, 0x7d,   /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1429         0x05, 0x35,   /* I2CT = 0, SCLT = 1, SDAT = 1 */
1430         0x06, 0x40,   /* DAC not used, set to high impendance mode */
1431         0x07, 0x00,   /* DAC LSB */
1432         0x08, 0x40,   /* DiSEqC off, LNB power on OP2/LOCK pin on */
1433         0x09, 0x00,   /* FIFO */
1434         0x0c, 0x51,   /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1435         0x0d, 0x82,   /* DC offset compensation = ON, beta_agc1 = 2 */
1436         0x0e, 0x23,   /* alpha_tmg = 2, beta_tmg = 3 */
1437         0x10, 0x3f,   // AGC2  0x3d
1438         0x11, 0x84,
1439         0x12, 0xb5,   // Lock detect: -64  Carrier freq detect:on
1440         0x15, 0xc9,   // lock detector threshold
1441         0x16, 0x00,
1442         0x17, 0x00,
1443         0x18, 0x00,
1444         0x19, 0x00,
1445         0x1a, 0x00,
1446         0x1f, 0x50,
1447         0x20, 0x00,
1448         0x21, 0x00,
1449         0x22, 0x00,
1450         0x23, 0x00,
1451         0x28, 0x00,  // out imp: normal  out type: parallel FEC mode:0
1452         0x29, 0x1e,  // 1/2 threshold
1453         0x2a, 0x14,  // 2/3 threshold
1454         0x2b, 0x0f,  // 3/4 threshold
1455         0x2c, 0x09,  // 5/6 threshold
1456         0x2d, 0x05,  // 7/8 threshold
1457         0x2e, 0x01,
1458         0x31, 0x1f,  // test all FECs
1459         0x32, 0x19,  // viterbi and synchro search
1460         0x33, 0xfc,  // rs control
1461         0x34, 0x93,  // error control
1462         0x0f, 0x52,
1463         0xff, 0xff
1464 };
1465
1466 static int alps_bsru6_set_symbol_rate(struct dvb_frontend* fe, u32 srate, u32 ratio)
1467 {
1468         u8 aclk = 0;
1469         u8 bclk = 0;
1470
1471         if (srate < 1500000) { aclk = 0xb7; bclk = 0x47; }
1472         else if (srate < 3000000) { aclk = 0xb7; bclk = 0x4b; }
1473         else if (srate < 7000000) { aclk = 0xb7; bclk = 0x4f; }
1474         else if (srate < 14000000) { aclk = 0xb7; bclk = 0x53; }
1475         else if (srate < 30000000) { aclk = 0xb6; bclk = 0x53; }
1476         else if (srate < 45000000) { aclk = 0xb4; bclk = 0x51; }
1477
1478         stv0299_writereg (fe, 0x13, aclk);
1479         stv0299_writereg (fe, 0x14, bclk);
1480         stv0299_writereg (fe, 0x1f, (ratio >> 16) & 0xff);
1481         stv0299_writereg (fe, 0x20, (ratio >>  8) & 0xff);
1482         stv0299_writereg (fe, 0x21, (ratio      ) & 0xf0);
1483
1484         return 0;
1485 }
1486
1487 static int alps_bsru6_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1488 {
1489         struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1490         int ret;
1491         u8 data[4];
1492         u32 div;
1493         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1494
1495         if ((params->frequency < 950000) || (params->frequency > 2150000))
1496                 return -EINVAL;
1497
1498         div = (params->frequency + (125 - 1)) / 125; // round correctly
1499         data[0] = (div >> 8) & 0x7f;
1500         data[1] = div & 0xff;
1501         data[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
1502         data[3] = 0xC4;
1503
1504         if (params->frequency > 1530000) data[3] = 0xc0;
1505
1506         ret = i2c_transfer (&av7110->i2c_adap, &msg, 1);
1507         if (ret != 1)
1508                 return -EIO;
1509         return 0;
1510 }
1511
1512 static struct stv0299_config alps_bsru6_config = {
1513
1514         .demod_address = 0x68,
1515         .inittab = alps_bsru6_inittab,
1516         .mclk = 88000000UL,
1517         .invert = 1,
1518         .enhanced_tuning = 0,
1519         .skip_reinit = 0,
1520         .lock_output = STV0229_LOCKOUTPUT_1,
1521         .volt13_op0_op1 = STV0299_VOLT13_OP1,
1522         .min_delay_ms = 100,
1523         .set_symbol_rate = alps_bsru6_set_symbol_rate,
1524         .pll_set = alps_bsru6_pll_set,
1525 };
1526
1527
1528
1529 static int alps_tdbe2_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1530 {
1531         struct av7110* av7110 = fe->dvb->priv;
1532         u32 div;
1533         u8 data[4];
1534         struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1535
1536         div = (params->frequency + 35937500 + 31250) / 62500;
1537
1538         data[0] = (div >> 8) & 0x7f;
1539         data[1] = div & 0xff;
1540         data[2] = 0x85 | ((div >> 10) & 0x60);
1541         data[3] = (params->frequency < 174000000 ? 0x88 : params->frequency < 470000000 ? 0x84 : 0x81);
1542
1543         if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1544                 return -EIO;
1545         return 0;
1546 }
1547
1548 static struct ves1820_config alps_tdbe2_config = {
1549         .demod_address = 0x09,
1550         .xin = 57840000UL,
1551         .invert = 1,
1552         .selagc = VES1820_SELAGC_SIGNAMPERR,
1553         .pll_set = alps_tdbe2_pll_set,
1554 };
1555
1556
1557
1558
1559 static int grundig_29504_451_pll_set(struct dvb_frontend* fe,
1560                                      struct dvb_frontend_parameters* params)
1561 {
1562         struct av7110* av7110 = fe->dvb->priv;
1563         u32 div;
1564         u8 data[4];
1565         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1566
1567         div = params->frequency / 125;
1568         data[0] = (div >> 8) & 0x7f;
1569         data[1] = div & 0xff;
1570         data[2] = 0x8e;
1571         data[3] = 0x00;
1572
1573         if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1574                 return -EIO;
1575         return 0;
1576 }
1577
1578 static struct tda8083_config grundig_29504_451_config = {
1579         .demod_address = 0x68,
1580         .pll_set = grundig_29504_451_pll_set,
1581 };
1582
1583
1584
1585 static int philips_cd1516_pll_set(struct dvb_frontend* fe,
1586                                   struct dvb_frontend_parameters* params)
1587 {
1588         struct av7110* av7110 = fe->dvb->priv;
1589         u32 div;
1590         u32 f = params->frequency;
1591         u8 data[4];
1592         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1593
1594         div = (f + 36125000 + 31250) / 62500;
1595
1596         data[0] = (div >> 8) & 0x7f;
1597         data[1] = div & 0xff;
1598         data[2] = 0x8e;
1599         data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1600
1601         if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1602                 return -EIO;
1603         return 0;
1604 }
1605
1606 static struct ves1820_config philips_cd1516_config = {
1607         .demod_address = 0x09,
1608         .xin = 57840000UL,
1609         .invert = 1,
1610         .selagc = VES1820_SELAGC_SIGNAMPERR,
1611         .pll_set = philips_cd1516_pll_set,
1612 };
1613
1614
1615
1616 static int alps_tdlb7_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1617 {
1618         struct av7110* av7110 = fe->dvb->priv;
1619         u32 div, pwr;
1620         u8 data[4];
1621         struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1622
1623         div = (params->frequency + 36200000) / 166666;
1624
1625         if (params->frequency <= 782000000)
1626                 pwr = 1;
1627         else
1628                 pwr = 2;
1629
1630         data[0] = (div >> 8) & 0x7f;
1631         data[1] = div & 0xff;
1632         data[2] = 0x85;
1633         data[3] = pwr << 6;
1634
1635         if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1636                 return -EIO;
1637         return 0;
1638 }
1639
1640 static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1641 {
1642         struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1643
1644         return request_firmware(fw, name, &av7110->dev->pci->dev);
1645 }
1646
1647 static struct sp8870_config alps_tdlb7_config = {
1648
1649         .demod_address = 0x71,
1650         .pll_set = alps_tdlb7_pll_set,
1651         .request_firmware = alps_tdlb7_request_firmware,
1652 };
1653
1654
1655
1656 static int nexusca_stv0297_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1657 {
1658         struct av7110* av7110 = fe->dvb->priv;
1659         u32 div;
1660         u8 data[4];
1661         struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
1662         struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
1663         int i;
1664
1665         div = (params->frequency + 36150000 + 31250) / 62500;
1666
1667         data[0] = (div >> 8) & 0x7f;
1668         data[1] = div & 0xff;
1669         data[2] = 0xce;
1670
1671         if (params->frequency < 45000000)
1672                 return -EINVAL;
1673         else if (params->frequency < 137000000)
1674                 data[3] = 0x01;
1675         else if (params->frequency < 403000000)
1676                 data[3] = 0x02;
1677         else if (params->frequency < 860000000)
1678                 data[3] = 0x04;
1679         else
1680                 return -EINVAL;
1681
1682         stv0297_enable_plli2c(fe);
1683         if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) {
1684                 printk("nexusca: pll transfer failed!\n");
1685                 return -EIO;
1686         }
1687
1688         // wait for PLL lock
1689         for(i=0; i< 20; i++) {
1690
1691                 stv0297_enable_plli2c(fe);
1692                 if (i2c_transfer (&av7110->i2c_adap, &readmsg, 1) == 1)
1693                         if (data[0] & 0x40) break;
1694                 msleep(10);
1695         }
1696
1697         return 0;
1698 }
1699
1700 static struct stv0297_config nexusca_stv0297_config = {
1701
1702         .demod_address = 0x1C,
1703         .pll_set = nexusca_stv0297_pll_set,
1704 };
1705
1706
1707 static void av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
1708 {
1709         int synced = (status & FE_HAS_LOCK) ? 1 : 0;
1710
1711         av7110->fe_status = status;
1712
1713         if (av7110->fe_synced == synced)
1714                 return;
1715
1716         av7110->fe_synced = synced;
1717
1718         if (av7110->playing)
1719                 return;
1720
1721         if (down_interruptible(&av7110->pid_mutex))
1722                 return;
1723
1724         if (av7110->fe_synced) {
1725                 SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
1726                         av7110->pids[DMX_PES_AUDIO],
1727                         av7110->pids[DMX_PES_TELETEXT], 0,
1728                         av7110->pids[DMX_PES_PCR]);
1729                         av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
1730         } else {
1731                         SetPIDs(av7110, 0, 0, 0, 0, 0);
1732                 av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
1733                 av7110_wait_msgstate(av7110, GPMQBusy);
1734         }
1735
1736         up(&av7110->pid_mutex);
1737 }
1738
1739 static int av7110_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1740 {
1741         struct av7110* av7110 = fe->dvb->priv;
1742         av7110_fe_lock_fix(av7110, 0);
1743         return av7110->fe_set_frontend(fe, params);
1744 }
1745
1746 static int av7110_fe_init(struct dvb_frontend* fe)
1747 {
1748         struct av7110* av7110 = fe->dvb->priv;
1749
1750         av7110_fe_lock_fix(av7110, 0);
1751         return av7110->fe_init(fe);
1752 }
1753
1754 static int av7110_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
1755 {
1756         struct av7110* av7110 = fe->dvb->priv;
1757         int ret;
1758
1759         /* call the real implementation */
1760         ret = av7110->fe_read_status(fe, status);
1761         if (ret)
1762                 return ret;
1763
1764         if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK)) {
1765                 av7110_fe_lock_fix(av7110, *status);
1766         }
1767
1768         return 0;
1769 }
1770
1771 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
1772 {
1773         struct av7110* av7110 = fe->dvb->priv;
1774
1775         av7110_fe_lock_fix(av7110, 0);
1776         return av7110->fe_diseqc_reset_overload(fe);
1777 }
1778
1779 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
1780                                             struct dvb_diseqc_master_cmd* cmd)
1781 {
1782         struct av7110* av7110 = fe->dvb->priv;
1783
1784         av7110_fe_lock_fix(av7110, 0);
1785         return av7110->fe_diseqc_send_master_cmd(fe, cmd);
1786 }
1787
1788 static int av7110_fe_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t minicmd)
1789 {
1790         struct av7110* av7110 = fe->dvb->priv;
1791
1792         av7110_fe_lock_fix(av7110, 0);
1793         return av7110->fe_diseqc_send_burst(fe, minicmd);
1794 }
1795
1796 static int av7110_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
1797 {
1798         struct av7110* av7110 = fe->dvb->priv;
1799
1800         av7110_fe_lock_fix(av7110, 0);
1801         return av7110->fe_set_tone(fe, tone);
1802 }
1803
1804 static int av7110_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
1805 {
1806         struct av7110* av7110 = fe->dvb->priv;
1807
1808         av7110_fe_lock_fix(av7110, 0);
1809         return av7110->fe_set_voltage(fe, voltage);
1810 }
1811
1812 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned int cmd)
1813 {
1814         struct av7110* av7110 = fe->dvb->priv;
1815
1816         av7110_fe_lock_fix(av7110, 0);
1817         return av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
1818 }
1819
1820 static u8 read_pwm(struct av7110* av7110)
1821 {
1822         u8 b = 0xff;
1823         u8 pwm;
1824         struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
1825                                  { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
1826
1827         if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
1828                 pwm = 0x48;
1829
1830         return pwm;
1831 }
1832
1833 static void frontend_init(struct av7110 *av7110)
1834 {
1835         if (av7110->dev->pci->subsystem_vendor == 0x110a) {
1836                 switch(av7110->dev->pci->subsystem_device) {
1837                 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
1838                         av7110->fe = ves1820_attach(&philips_cd1516_config,
1839                                                     &av7110->i2c_adap, read_pwm(av7110));
1840                         break;
1841                 }
1842
1843         } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
1844                 switch(av7110->dev->pci->subsystem_device) {
1845                 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
1846                 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
1847                 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
1848
1849                         // try the ALPS BSRV2 first of all
1850                         av7110->fe = ves1x93_attach(&alps_bsrv2_config, &av7110->i2c_adap);
1851                         if (av7110->fe) {
1852                                 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
1853                                 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
1854                                 av7110->fe->ops->set_tone = av7110_set_tone;
1855                                 break;
1856                         }
1857
1858                         // try the ALPS BSRU6 now
1859                         av7110->fe = stv0299_attach(&alps_bsru6_config, &av7110->i2c_adap);
1860                         if (av7110->fe) {
1861                                 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
1862                                 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
1863                                 av7110->fe->ops->set_tone = av7110_set_tone;
1864                                 break;
1865                         }
1866
1867                         // Try the grundig 29504-451
1868                         av7110->fe = tda8083_attach(&grundig_29504_451_config, &av7110->i2c_adap);
1869                         if (av7110->fe) {
1870                                 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
1871                                 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
1872                                 av7110->fe->ops->set_tone = av7110_set_tone;
1873                                 break;
1874                         }
1875
1876                         /* Try DVB-C cards */
1877                         switch(av7110->dev->pci->subsystem_device) {
1878                         case 0x0000:
1879                                 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
1880                                 av7110->fe = ves1820_attach(&philips_cd1516_config, &av7110->i2c_adap,
1881                                                         read_pwm(av7110));
1882                                 break;
1883                         case 0x0003:
1884                                 /* Haupauge DVB-C 2.1 VES1820/ALPS TDBE2 */
1885                                 av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap,
1886                                                         read_pwm(av7110));
1887                                 break;
1888                         }
1889                         break;
1890
1891                 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
1892
1893                         // ALPS TDLB7
1894                         av7110->fe = sp8870_attach(&alps_tdlb7_config, &av7110->i2c_adap);
1895                         break;
1896
1897                 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
1898
1899                         av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
1900                         break;
1901
1902                 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
1903
1904                         av7110->fe = stv0297_attach(&nexusca_stv0297_config, &av7110->i2c_adap, 0x7b);
1905                         if (av7110->fe) {
1906                                 /* set TDA9819 into DVB mode */
1907                                 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTHI); // TDA9198 pin9(STD)
1908                                 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9198 pin30(VIF)
1909
1910                                 /* tuner on this needs a slower i2c bus speed */
1911                                 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
1912                                 break;
1913                         }
1914                 }
1915         }
1916
1917         if (av7110->fe == NULL) {
1918                 printk("dvb-ttpci: A frontend driver was not found for device %04x/%04x subsystem %04x/%04x\n",
1919                        av7110->dev->pci->vendor,
1920                        av7110->dev->pci->device,
1921                        av7110->dev->pci->subsystem_vendor,
1922                        av7110->dev->pci->subsystem_device);
1923         } else {
1924                 FE_FUNC_OVERRIDE(av7110->fe->ops->init, av7110->fe_init, av7110_fe_init);
1925                 FE_FUNC_OVERRIDE(av7110->fe->ops->read_status, av7110->fe_read_status, av7110_fe_read_status);
1926                 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
1927                 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
1928                 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
1929                 FE_FUNC_OVERRIDE(av7110->fe->ops->set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
1930                 FE_FUNC_OVERRIDE(av7110->fe->ops->set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage;)
1931                 FE_FUNC_OVERRIDE(av7110->fe->ops->dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
1932                 FE_FUNC_OVERRIDE(av7110->fe->ops->set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
1933
1934                 if (dvb_register_frontend(av7110->dvb_adapter, av7110->fe)) {
1935                         printk("av7110: Frontend registration failed!\n");
1936                         if (av7110->fe->ops->release)
1937                                 av7110->fe->ops->release(av7110->fe);
1938                         av7110->fe = NULL;
1939                 }
1940         }
1941 }
1942
1943 static int av7110_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_data *pci_ext)
1944 {
1945         struct av7110 *av7110 = NULL;
1946         int ret = 0;
1947
1948         dprintk(4, "dev: %p\n", dev);
1949
1950         /* prepare the av7110 device struct */
1951         if (!(av7110 = kmalloc (sizeof (struct av7110), GFP_KERNEL))) {
1952                 dprintk(1, "out of memory\n");
1953                 return -ENOMEM;
1954         }
1955
1956         memset(av7110, 0, sizeof(struct av7110));
1957
1958         av7110->card_name = (char*)pci_ext->ext_priv;
1959         av7110->dev = dev;
1960         dev->ext_priv = av7110;
1961
1962         if ((ret = get_firmware(av7110))) {
1963                 kfree(av7110);
1964                 return ret;
1965         }
1966
1967         dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name, THIS_MODULE);
1968
1969         /* the Siemens DVB needs this if you want to have the i2c chips
1970            get recognized before the main driver is fully loaded */
1971         saa7146_write(dev, GPIO_CTRL, 0x500000);
1972
1973 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
1974         av7110->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL;
1975 #else
1976         av7110->i2c_adap.class = I2C_CLASS_TV_DIGITAL;
1977 #endif
1978         strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
1979
1980         saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
1981
1982         if (i2c_add_adapter(&av7110->i2c_adap) < 0) {
1983                 dvb_unregister_adapter (av7110->dvb_adapter);
1984                 kfree(av7110);
1985                 return -ENOMEM;
1986         }
1987
1988         ttpci_eeprom_parse_mac(&av7110->i2c_adap, av7110->dvb_adapter->proposed_mac);
1989
1990         saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
1991         saa7146_write(dev, BCS_CTRL, 0x80400040);
1992
1993         /* set dd1 stream a & b */
1994         saa7146_write(dev, DD1_STREAM_B, 0x00000000);
1995         saa7146_write(dev, DD1_INIT, 0x03000000);
1996         saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
1997
1998         /* upload all */
1999         saa7146_write(dev, MC2, 0x077c077c);
2000         saa7146_write(dev, GPIO_CTRL, 0x000000);
2001
2002         tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2003         tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2004
2005         sema_init(&av7110->pid_mutex, 1);
2006
2007         /* locks for data transfers from/to AV7110 */
2008         spin_lock_init (&av7110->debilock);
2009         sema_init(&av7110->dcomlock, 1);
2010         av7110->debitype=-1;
2011
2012         /* default OSD window */
2013         av7110->osdwin=1;
2014         sema_init(&av7110->osd_sema, 1);
2015
2016         /* ARM "watchdog" */
2017         init_waitqueue_head(&av7110->arm_wait);
2018         av7110->arm_thread=NULL;
2019
2020         /* allocate and init buffers */
2021         av7110->debi_virt = pci_alloc_consistent(dev->pci, 8192,
2022                                                  &av7110->debi_bus);
2023         if (!av7110->debi_virt) {
2024                 ret = -ENOMEM;
2025                 goto err;
2026         }
2027
2028         av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2029         if (!av7110->iobuf) {
2030                 ret = -ENOMEM;
2031                 goto err;
2032         }
2033
2034         av7110_av_init(av7110);
2035
2036         /* init BMP buffer */
2037         av7110->bmpbuf=av7110->iobuf+AVOUTLEN+AOUTLEN;
2038         init_waitqueue_head(&av7110->bmpq);
2039
2040         av7110_ca_init(av7110);
2041
2042         /* load firmware into AV7110 cards */
2043         av7110_bootarm(av7110);
2044         if (av7110_firmversion(av7110)) {
2045                 ret = -EIO;
2046                 goto err2;
2047         }
2048
2049         if (FW_VERSION(av7110->arm_app)<0x2501)
2050                 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2051                         "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2052
2053         if (kernel_thread(arm_thread, (void *) av7110, 0) < 0) {
2054                 printk("dvb-ttpci: failed to start arm_mon kernel thread @ card %d\n",
2055                        av7110->dvb_adapter->num);
2056                 goto err2;
2057         }
2058
2059         /* set initial volume in mixer struct */
2060         av7110->mixer.volume_left  = volume;
2061         av7110->mixer.volume_right = volume;
2062
2063         init_av7110_av(av7110);
2064
2065         av7110_register(av7110);
2066
2067         /* special case DVB-C: these cards have an analog tuner
2068            plus need some special handling, so we have separate
2069            saa7146_ext_vv data for these... */
2070         ret = av7110_init_v4l(av7110);
2071
2072         if (ret)
2073                 goto err3;
2074
2075         av7110->dvb_adapter->priv = av7110;
2076         frontend_init(av7110);
2077
2078         printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2079         av7110->device_initialized = 1;
2080         av7110_num++;
2081         return 0;
2082
2083 err3:
2084         av7110->arm_rmmod = 1;
2085         wake_up_interruptible(&av7110->arm_wait);
2086         while (av7110->arm_thread)
2087                 msleep(1);
2088 err2:
2089         av7110_ca_exit(av7110);
2090         av7110_av_exit(av7110);
2091 err:
2092         i2c_del_adapter(&av7110->i2c_adap);
2093
2094         dvb_unregister_adapter (av7110->dvb_adapter);
2095
2096         if (NULL != av7110->debi_virt)
2097                 pci_free_consistent(dev->pci, 8192, av7110->debi_virt, av7110->debi_bus);
2098         if (NULL != av7110->iobuf)
2099                 vfree(av7110->iobuf);
2100         if (NULL != av7110 ) {
2101                 kfree(av7110);
2102         }
2103
2104         return ret;
2105 }
2106
2107 static int av7110_detach (struct saa7146_dev* saa)
2108 {
2109         struct av7110 *av7110 = (struct av7110*)saa->ext_priv;
2110         dprintk(4, "%p\n", av7110);
2111
2112         if( 0 == av7110->device_initialized ) {
2113                 return 0;
2114         }
2115
2116         av7110_exit_v4l(av7110);
2117
2118         av7110->arm_rmmod=1;
2119         wake_up_interruptible(&av7110->arm_wait);
2120
2121         while (av7110->arm_thread)
2122                 msleep(1);
2123
2124         dvb_unregister(av7110);
2125
2126         SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2127         SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2128
2129         av7110_ca_exit(av7110);
2130         av7110_av_exit(av7110);
2131
2132         vfree(av7110->iobuf);
2133         pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2134                             av7110->debi_bus);
2135
2136         i2c_del_adapter(&av7110->i2c_adap);
2137
2138         dvb_unregister_adapter (av7110->dvb_adapter);
2139
2140         av7110_num--;
2141 #ifndef CONFIG_DVB_AV7110_FIRMWARE_FILE
2142         if (av7110->bin_fw)
2143                 vfree(av7110->bin_fw);
2144 #endif
2145         kfree (av7110);
2146         saa->ext_priv = NULL;
2147
2148         return 0;
2149 }
2150
2151
2152 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2153 {
2154         struct av7110 *av7110 = dev->ext_priv;
2155
2156         if (*isr & MASK_19)
2157                 tasklet_schedule (&av7110->debi_tasklet);
2158
2159         if (*isr & MASK_03)
2160                 tasklet_schedule (&av7110->gpio_tasklet);
2161 }
2162
2163
2164 static struct saa7146_extension av7110_extension;
2165
2166 #define MAKE_AV7110_INFO(x_var,x_name) \
2167 static struct saa7146_pci_extension_data x_var = { \
2168         .ext_priv = x_name, \
2169         .ext = &av7110_extension }
2170
2171 MAKE_AV7110_INFO(tts_1_X,    "Technotrend/Hauppauge WinTV DVB-S rev1.X");
2172 MAKE_AV7110_INFO(ttt_1_X,    "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2173 MAKE_AV7110_INFO(ttc_1_X,    "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2174 MAKE_AV7110_INFO(ttc_2_X,    "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2175 MAKE_AV7110_INFO(tts_2_X,    "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2176 MAKE_AV7110_INFO(tts_1_3se,  "Technotrend/Hauppauge WinTV Nexus-S rev1.3");
2177 MAKE_AV7110_INFO(fsc,        "Fujitsu Siemens DVB-C");
2178
2179 static struct pci_device_id pci_tbl[] = {
2180         MAKE_EXTENSION_PCI(tts_1_X,   0x13c2, 0x0000),
2181         MAKE_EXTENSION_PCI(ttt_1_X,   0x13c2, 0x0001),
2182         MAKE_EXTENSION_PCI(ttc_2_X,   0x13c2, 0x0002),
2183         MAKE_EXTENSION_PCI(tts_2_X,   0x13c2, 0x0003),
2184         MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002),
2185         MAKE_EXTENSION_PCI(fsc,       0x110a, 0x0000),
2186         MAKE_EXTENSION_PCI(ttc_1_X,   0x13c2, 0x000a),
2187
2188 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0004), UNDEFINED CARD */ // Galaxis DVB PC-Sat-Carte
2189 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2190 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0006), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-S v????
2191 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0008), UNDEFINED CARD */ // TT/Hauppauge WinTV DVB-T v????
2192 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2193
2194         {
2195                 .vendor    = 0,
2196         }
2197 };
2198
2199 MODULE_DEVICE_TABLE(pci, pci_tbl);
2200
2201
2202 static struct saa7146_extension av7110_extension = {
2203         .name           = "dvb\0",
2204         .flags          = SAA7146_I2C_SHORT_DELAY,
2205
2206         .module         = THIS_MODULE,
2207         .pci_tbl        = &pci_tbl[0],
2208         .attach         = av7110_attach,
2209         .detach         = av7110_detach,
2210
2211         .irq_mask       = MASK_19|MASK_03,
2212         .irq_func       = av7110_irq,
2213 };
2214
2215
2216 static int __init av7110_init(void)
2217 {
2218         int retval;
2219         retval = saa7146_register_extension(&av7110_extension);
2220 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2221         if (retval)
2222                 goto failed_saa7146_register;
2223
2224         retval = av7110_ir_init();
2225         if (retval)
2226                 goto failed_av7110_ir_init;
2227         return 0;
2228 failed_av7110_ir_init:
2229         saa7146_unregister_extension(&av7110_extension);
2230 failed_saa7146_register:
2231 #endif
2232         return retval;
2233 }
2234
2235
2236 static void __exit av7110_exit(void)
2237 {
2238 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2239         av7110_ir_exit();
2240 #endif
2241         saa7146_unregister_extension(&av7110_extension);
2242 }
2243
2244 module_init(av7110_init);
2245 module_exit(av7110_exit);
2246
2247 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2248                    "Siemens, Technotrend, Hauppauge");
2249 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2250 MODULE_LICENSE("GPL");
2251