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/sched.h>
  45 #include <linux/types.h>
  46 #include <linux/fcntl.h>
  47 #include <linux/interrupt.h>
  48 #include <linux/string.h>
  49 #include <linux/pci.h>
  50 #include <linux/vmalloc.h>
  51 #include <linux/firmware.h>
  52 #include <linux/crc32.h>
  53
  54 #include <asm/system.h>
  55 #include <asm/semaphore.h>
  56
  57 #include <linux/dvb/frontend.h>
  58
  59 #include "dvb_i2c.h"
  60 #include "dvb_frontend.h"
  61 #include "dvb_functions.h"
  62
  63
  64         #define DEBUG_VARIABLE av7110_debug
  65
  66 #include "ttpci-eeprom.h"
  67 #include "av7110.h"
  68 #include "av7110_hw.h"
  69 #include "av7110_av.h"
  70 #include "av7110_ca.h"
  71 #include "av7110_ipack.h"
  72
  73
  74 static void restart_feeds(struct av7110 *av7110);
  75
  76 int av7110_debug = 0;
  77
  78 static int vidmode=CVBS_RGB_OUT;
  79 static int pids_off;
  80 static int adac=DVB_ADAC_TI;
  81 static int hw_sections = 0;
  82 static int rgb_on = 0;
  83
  84 int av7110_num = 0;
  85
  86
  87 static void recover_arm(struct av7110 *av7110)
  88 {
  89         DEB_EE(("av7110: %p\n",av7110));
  90
  91         av7110_bootarm(av7110);
  92         dvb_delay(100);
  93         restart_feeds(av7110);
  94         av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, av7110->ir_config);
  95 }
  96
  97 static void arm_error(struct av7110 *av7110)
  98 {
  99         DEB_EE(("av7110: %p\n",av7110));
 100
 101         av7110->arm_errors++;
 102         av7110->arm_ready=0;
 103         recover_arm(av7110);
 104 }
 105
 106 static int arm_thread(void *data)
 107 {
 108         struct av7110 *av7110 = data;
 109         unsigned long timeout;
 110         u16 newloops = 0;
 111
 112         DEB_EE(("av7110: %p\n",av7110));
 113
 114         dvb_kernel_thread_setup ("arm_mon");
 115         av7110->arm_thread = current;
 116
 117         while (1) {
 118                 timeout = wait_event_interruptible_timeout(av7110->arm_wait,0 != av7110->arm_rmmod, 5*HZ);
 119                 if (-ERESTARTSYS == timeout || 0 != av7110->arm_rmmod) {
 120                         /* got signal or told to quit*/
 121                         break;
 122                 }
 123
 124                 if (!av7110->arm_ready)
 125                         continue;
 126
 127                 if (down_interruptible(&av7110->dcomlock))
 128                         break;
 129
 130                 newloops=rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
 131                 up(&av7110->dcomlock);
 132
 133                 if (newloops==av7110->arm_loops) {
 134                         printk(KERN_ERR "av7110%d: ARM crashed!\n",
 135                                 av7110->dvb_adapter->num);
 136
 137                         arm_error(av7110);
 138
 139                         if (down_interruptible(&av7110->dcomlock))
 140                                 break;
 141
 142                         newloops=rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2)-1;
 143                         up(&av7110->dcomlock);
 144                 }
 145                 av7110->arm_loops=newloops;
 146         }
 147
 148         av7110->arm_thread = NULL;
 149         return 0;
 150 }
 151
 152
 153 /**
 154  *  Hack! we save the last av7110 ptr. This should be ok, since
 155  *  you rarely will use more then one IR control.
 156  *
 157  *  If we want to support multiple controls we would have to do much more...
 158  */
 159 void av7110_setup_irc_config (struct av7110 *av7110, u32 ir_config)
 160 {
 161         static struct av7110 *last;
 162
 163         DEB_EE(("av7110: %p\n",av7110));
 164
 165         if (!av7110)
 166                 av7110 = last;
 167         else
 168                 last = av7110;
 169
 170         if (av7110) {
 171                 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
 172                 av7110->ir_config = ir_config;
 173         }
 174 }
 175
 176 static void (*irc_handler)(u32);
 177
 178 void av7110_register_irc_handler(void (*func)(u32))
 179 {
 180         DEB_EE(("registering %p\n", func));
 181         irc_handler = func;
 182 }
 183
 184 void av7110_unregister_irc_handler(void (*func)(u32))
 185 {
 186         DEB_EE(("unregistering %p\n", func));
 187         irc_handler = NULL;
 188 }
 189
 190 void run_handlers(unsigned long ircom)
 191 {
 192         if (irc_handler != NULL)
 193                 (*irc_handler)((u32) ircom);
 194 }
 195
 196 DECLARE_TASKLET(irtask,run_handlers,0);
 197
 198 void IR_handle(struct av7110 *av7110, u32 ircom)
 199 {
 200         DEB_S(("av7110: ircommand = %08x\n", ircom));
 201         irtask.data = (unsigned long) ircom;
 202         tasklet_schedule(&irtask);
 203 }
 204
 205 /****************************************************************************
 206  * IRQ handling
 207  ****************************************************************************/
 208
 209 static inline int DvbDmxFilterCallback(u8 * buffer1, size_t buffer1_len,
 210                      u8 * buffer2, size_t buffer2_len,
 211                      struct dvb_demux_filter *dvbdmxfilter,
 212                      enum dmx_success success,
 213                      struct av7110 *av7110)
 214 {
 215         DEB_INT(("av7110: %p\n",av7110));
 216
 217         if (!dvbdmxfilter->feed->demux->dmx.frontend)
 218                 return 0;
 219         if (dvbdmxfilter->feed->demux->dmx.frontend->source==DMX_MEMORY_FE)
 220                 return 0;
 221
 222         switch(dvbdmxfilter->type) {
 223         case DMX_TYPE_SEC:
 224                 if ((((buffer1[1]<<8)|buffer1[2])&0xfff)+3!=buffer1_len)
 225                         return 0;
 226                 if (dvbdmxfilter->doneq) {
 227                         struct dmx_section_filter *filter=&dvbdmxfilter->filter;
 228                         int i;
 229                         u8 xor, neq=0;
 230
 231                         for (i=0; i<DVB_DEMUX_MASK_MAX; i++) {
 232                                 xor=filter->filter_value[i]^buffer1[i];
 233                                 neq|=dvbdmxfilter->maskandnotmode[i]&xor;
 234                         }
 235                         if (!neq)
 236                                 return 0;
 237                 }
 238                 return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len,
 239                                                   buffer2, buffer2_len,
 240                                                   &dvbdmxfilter->filter,
 241                                                   DMX_OK);
 242         case DMX_TYPE_TS:
 243                 if (!(dvbdmxfilter->feed->ts_type & TS_PACKET))
 244                         return 0;
 245                 if (dvbdmxfilter->feed->ts_type & TS_PAYLOAD_ONLY)
 246                         return dvbdmxfilter->feed->cb.ts(buffer1, buffer1_len,
 247                                                          buffer2, buffer2_len,
 248                                                          &dvbdmxfilter->feed->feed.ts,
 249                                                          DMX_OK);
 250                 else
 251                         av7110_p2t_write(buffer1, buffer1_len,
 252                                   dvbdmxfilter->feed->pid,
 253                                   &av7110->p2t_filter[dvbdmxfilter->index]);
 254         default:
 255                 return 0;
 256         }
 257 }
 258
 259
 260 //#define DEBUG_TIMING
 261 static inline void print_time(char *s)
 262 {
 263 #ifdef DEBUG_TIMING
 264         struct timeval tv;
 265         do_gettimeofday(&tv);
 266         printk("%s: %d.%d\n", s, (int)tv.tv_sec, (int)tv.tv_usec);
 267 #endif
 268 }
 269
 270 static void debiirq (unsigned long data)
 271 {
 272         struct av7110 *av7110 = (struct av7110*) data;
 273         int type=av7110->debitype;
 274         int handle=(type>>8)&0x1f;
 275
 276 //      DEB_EE(("av7110: %p\n",av7110));
 277
 278         print_time("debi");
 279         saa7146_write(av7110->dev, IER,
 280                       saa7146_read(av7110->dev, IER) & ~MASK_19 );
 281         saa7146_write(av7110->dev, ISR, MASK_19 );
 282
 283         if (type==-1) {
 284                 printk("DEBI irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
 285                        jiffies, saa7146_read(av7110->dev, PSR),
 286                        saa7146_read(av7110->dev, SSR));
 287                 spin_lock(&av7110->debilock);
 288                 ARM_ClearMailBox(av7110);
 289                 ARM_ClearIrq(av7110);
 290                 spin_unlock(&av7110->debilock);
 291                 return;
 292         }
 293         av7110->debitype=-1;
 294
 295         switch (type&0xff) {
 296
 297         case DATA_TS_RECORD:
 298                 dvb_dmx_swfilter_packets(&av7110->demux,
 299                                       (const u8 *)av7110->debi_virt,
 300                                       av7110->debilen/188);
 301                 spin_lock(&av7110->debilock);
 302                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 303                 ARM_ClearMailBox(av7110);
 304                 spin_unlock(&av7110->debilock);
 305                 return;
 306
 307         case DATA_PES_RECORD:
 308                 if (av7110->demux.recording)
 309                         av7110_record_cb(&av7110->p2t[handle],
 310                                   (u8 *)av7110->debi_virt,
 311                                   av7110->debilen);
 312                 spin_lock(&av7110->debilock);
 313                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 314                 ARM_ClearMailBox(av7110);
 315                 spin_unlock(&av7110->debilock);
 316                 return;
 317
 318         case DATA_IPMPE:
 319         case DATA_FSECTION:
 320         case DATA_PIPING:
 321                 if (av7110->handle2filter[handle])
 322                         DvbDmxFilterCallback((u8 *)av7110->debi_virt,
 323                                              av7110->debilen, 0, 0,
 324                                              av7110->handle2filter[handle],
 325                                              DMX_OK, av7110);
 326                 spin_lock(&av7110->debilock);
 327                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 328                 ARM_ClearMailBox(av7110);
 329                 spin_unlock(&av7110->debilock);
 330                 return;
 331
 332         case DATA_CI_GET:
 333         {
 334                 u8 *data=av7110->debi_virt;
 335
 336                 if ((data[0]<2) && data[2]==0xff) {
 337                         int flags=0;
 338                         if (data[5]>0)
 339                                 flags|=CA_CI_MODULE_PRESENT;
 340                         if (data[5]>5)
 341                                 flags|=CA_CI_MODULE_READY;
 342                         av7110->ci_slot[data[0]].flags=flags;
 343                 } else
 344                         ci_get_data(&av7110->ci_rbuffer,
 345                                     av7110->debi_virt,
 346                                     av7110->debilen);
 347                 spin_lock(&av7110->debilock);
 348                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 349                 ARM_ClearMailBox(av7110);
 350                 spin_unlock(&av7110->debilock);
 351                 return;
 352         }
 353
 354         case DATA_COMMON_INTERFACE:
 355                 CI_handle(av7110, (u8 *)av7110->debi_virt, av7110->debilen);
 356 #if 0
 357         {
 358                 int i;
 359
 360                 printk("av7110%d: ", av7110->num);
 361                 printk("%02x ", *(u8 *)av7110->debi_virt);
 362                 printk("%02x ", *(1+(u8 *)av7110->debi_virt));
 363                 for (i=2; i<av7110->debilen; i++)
 364                   printk("%02x ", (*(i+(unsigned char *)av7110->debi_virt)));
 365                 for (i=2; i<av7110->debilen; i++)
 366                   printk("%c", chtrans(*(i+(unsigned char *)av7110->debi_virt)));
 367
 368                 printk("\n");
 369         }
 370 #endif
 371                 spin_lock(&av7110->debilock);
 372                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 373                 ARM_ClearMailBox(av7110);
 374                 spin_unlock(&av7110->debilock);
 375                 return;
 376
 377         case DATA_DEBUG_MESSAGE:
 378                 ((s8*)av7110->debi_virt)[Reserved_SIZE-1]=0;
 379                 printk("%s\n", (s8 *)av7110->debi_virt);
 380                 spin_lock(&av7110->debilock);
 381                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 382                 ARM_ClearMailBox(av7110);
 383                 spin_unlock(&av7110->debilock);
 384                 return;
 385
 386         case DATA_CI_PUT:
 387         case DATA_MPEG_PLAY:
 388         case DATA_BMP_LOAD:
 389                 spin_lock(&av7110->debilock);
 390                 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 391                 ARM_ClearMailBox(av7110);
 392                 spin_unlock(&av7110->debilock);
 393                 return;
 394         default:
 395                 break;
 396         }
 397         spin_lock(&av7110->debilock);
 398         ARM_ClearMailBox(av7110);
 399         spin_unlock(&av7110->debilock);
 400 }
 401
 402 static void gpioirq (unsigned long data)
 403 {
 404         struct av7110 *av7110 = (struct av7110*) data;
 405         u32 rxbuf, txbuf;
 406         int len;
 407
 408         //printk("GPIO0 irq\n");
 409
 410         if (av7110->debitype !=-1)
 411                 printk("GPIO0 irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
 412                        jiffies, saa7146_read(av7110->dev, PSR),
 413                        saa7146_read(av7110->dev, SSR));
 414
 415         spin_lock(&av7110->debilock);
 416
 417         ARM_ClearIrq(av7110);
 418
 419         saa7146_write(av7110->dev, IER,
 420                       saa7146_read(av7110->dev, IER) & ~MASK_19 );
 421         saa7146_write(av7110->dev, ISR, MASK_19 );
 422
 423         av7110->debitype = irdebi(av7110, DEBINOSWAP, IRQ_STATE, 0, 2);
 424         av7110->debilen  = irdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 425         rxbuf=irdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 426         txbuf=irdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 427         len = (av7110->debilen + 3) & ~3;
 428
 429 //        DEB_D(("GPIO0 irq %d %d\n", av7110->debitype, av7110->debilen));
 430         print_time("gpio");
 431
 432 //       DEB_D(("GPIO0 irq %02x\n", av7110->debitype&0xff));
 433         switch (av7110->debitype&0xff) {
 434
 435         case DATA_TS_PLAY:
 436         case DATA_PES_PLAY:
 437                 break;
 438
 439         case DATA_MPEG_VIDEO_EVENT:
 440         {
 441                 u32 h_ar;
 442                 struct video_event event;
 443
 444                 av7110->video_size.w = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_WIDTH, 0, 2);
 445                 h_ar = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_HEIGHT_AR, 0, 2);
 446
 447                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 448                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 449
 450                 av7110->video_size.h = h_ar & 0xfff;
 451                 DEB_D(("GPIO0 irq: DATA_MPEG_VIDEO_EVENT: w/h/ar = %u/%u/%u\n",
 452                                 av7110->video_size.w,
 453                                 av7110->video_size.h,
 454                                 av7110->video_size.aspect_ratio));
 455
 456                 event.type = VIDEO_EVENT_SIZE_CHANGED;
 457                 event.u.size.w = av7110->video_size.w;
 458                 event.u.size.h = av7110->video_size.h;
 459                 switch ((h_ar >> 12) & 0xf)
 460                 {
 461                 case 3:
 462                         av7110->video_size.aspect_ratio = VIDEO_FORMAT_16_9;
 463                         event.u.size.aspect_ratio = VIDEO_FORMAT_16_9;
 464                         av7110->videostate.video_format = VIDEO_FORMAT_16_9;
 465                         break;
 466                 case 4:
 467                         av7110->video_size.aspect_ratio = VIDEO_FORMAT_221_1;
 468                         event.u.size.aspect_ratio = VIDEO_FORMAT_221_1;
 469                         av7110->videostate.video_format = VIDEO_FORMAT_221_1;
 470                         break;
 471                 default:
 472                         av7110->video_size.aspect_ratio = VIDEO_FORMAT_4_3;
 473                         event.u.size.aspect_ratio = VIDEO_FORMAT_4_3;
 474                         av7110->videostate.video_format = VIDEO_FORMAT_4_3;
 475                 }
 476                 dvb_video_add_event(av7110, &event);
 477                 break;
 478         }
 479
 480         case DATA_CI_PUT:
 481         {
 482                 int avail;
 483                 struct dvb_ringbuffer *cibuf=&av7110->ci_wbuffer;
 484
 485                 avail=dvb_ringbuffer_avail(cibuf);
 486                 if (avail<=2) {
 487                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 488                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 489                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 490                         break;
 491                 }
 492                 len= DVB_RINGBUFFER_PEEK(cibuf,0)<<8;
 493                 len|=DVB_RINGBUFFER_PEEK(cibuf,1);
 494                 if (avail<len+2) {
 495                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 496                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 497                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 498                         break;
 499                 }
 500                 DVB_RINGBUFFER_SKIP(cibuf,2);
 501
 502                 dvb_ringbuffer_read(cibuf,av7110->debi_virt,len,0);
 503
 504                 wake_up(&cibuf->queue);
 505                 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
 506                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
 507                 saa7146_wait_for_debi_done(av7110->dev);
 508                 saa7146_write(av7110->dev, IER,
 509                               saa7146_read(av7110->dev, IER) | MASK_19 );
 510                 if (len < 5)
 511                         len = 5; /* we want a real DEBI DMA */
 512                 iwdebi(av7110, DEBISWAB, DPRAM_BASE+txbuf, 0, (len+3)&~3);
 513                 spin_unlock(&av7110->debilock);
 514                 return;
 515         }
 516
 517         case DATA_MPEG_PLAY:
 518                 if (!av7110->playing) {
 519                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 520                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 521                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 522                         break;
 523                 }
 524                 len=0;
 525                 if (av7110->debitype&0x100) {
 526                         spin_lock(&av7110->aout.lock);
 527                         len=av7110_pes_play(av7110->debi_virt, &av7110->aout, 2048);
 528                         spin_unlock(&av7110->aout.lock);
 529                 }
 530                 if (len<=0 && (av7110->debitype&0x200)
 531                         &&av7110->videostate.play_state!=VIDEO_FREEZED) {
 532                         spin_lock(&av7110->avout.lock);
 533                         len=av7110_pes_play(av7110->debi_virt, &av7110->avout, 2048);
 534                         spin_unlock(&av7110->avout.lock);
 535                 }
 536                 if (len<=0) {
 537                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 538                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 539                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 540                         break;
 541                 }
 542                 DEB_D(("GPIO0 PES_PLAY len=%04x\n", len));
 543                 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
 544                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
 545                 saa7146_wait_for_debi_done(av7110->dev);
 546                 saa7146_write(av7110->dev, IER,
 547                               saa7146_read(av7110->dev, IER) | MASK_19 );
 548
 549                 iwdebi(av7110, DEBISWAB, DPRAM_BASE+txbuf, 0, (len+3)&~3);
 550                 spin_unlock(&av7110->debilock);
 551                 return;
 552
 553         case DATA_BMP_LOAD:
 554                 len=av7110->debilen;
 555                 if (!len) {
 556                         av7110->bmp_state=BMP_LOADED;
 557                         iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
 558                         iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
 559                         iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
 560                         wake_up(&av7110->bmpq);
 561                         break;
 562                 }
 563                 if (len>av7110->bmplen)
 564                         len=av7110->bmplen;
 565                 if (len>2*1024)
 566                         len=2*1024;
 567                 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
 568                 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
 569                 memcpy(av7110->debi_virt, av7110->bmpbuf+av7110->bmpp, len);
 570                 av7110->bmpp+=len;
 571                 av7110->bmplen-=len;
 572                 saa7146_wait_for_debi_done(av7110->dev);
 573                 saa7146_write(av7110->dev, IER,
 574                               saa7146_read(av7110->dev, IER) | MASK_19 );
 575                 if (len < 5)
 576                         len = 5; /* we want a real DEBI DMA */
 577                 iwdebi(av7110, DEBISWAB, DPRAM_BASE+txbuf, 0, (len+3)&~3);
 578                 spin_unlock(&av7110->debilock);
 579                 return;
 580
 581         case DATA_CI_GET:
 582         case DATA_COMMON_INTERFACE:
 583         case DATA_FSECTION:
 584         case DATA_IPMPE:
 585         case DATA_PIPING:
 586                 if (!len || len>4*1024) {
 587                         iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 588                         break;
 589                 }
 590                 /* fall through */
 591
 592         case DATA_TS_RECORD:
 593         case DATA_PES_RECORD:
 594                 saa7146_wait_for_debi_done(av7110->dev);
 595                 saa7146_write(av7110->dev, IER,
 596                               saa7146_read(av7110->dev, IER) | MASK_19);
 597                 irdebi(av7110, DEBISWAB, DPRAM_BASE+rxbuf, 0, len);
 598                 spin_unlock(&av7110->debilock);
 599                 return;
 600
 601         case DATA_DEBUG_MESSAGE:
 602                 saa7146_wait_for_debi_done(av7110->dev);
 603                 if (!len || len>0xff) {
 604                         iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 605                         break;
 606                 }
 607                 saa7146_write(av7110->dev, IER,
 608                               saa7146_read(av7110->dev, IER) | MASK_19);
 609                 irdebi(av7110, DEBISWAB, Reserved, 0, len);
 610                 spin_unlock(&av7110->debilock);
 611                 return;
 612
 613         case DATA_IRCOMMAND:
 614                 IR_handle(av7110,
 615                           swahw32(irdebi(av7110, DEBINOSWAP, Reserved, 0, 4)));
 616                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
 617                 break;
 618
 619         default:
 620                 printk("gpioirq unknown type=%d len=%d\n",
 621                        av7110->debitype, av7110->debilen);
 622                 break;
 623         }
 624         ARM_ClearMailBox(av7110);
 625         av7110->debitype=-1;
 626         spin_unlock(&av7110->debilock);
 627 }
 628
 629
 630 #ifdef CONFIG_DVB_AV7110_OSD
 631 static int dvb_osd_ioctl(struct inode *inode, struct file *file,
 632                          unsigned int cmd, void *parg)
 633 {
 634         struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
 635         struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
 636
 637         DEB_EE(("av7110: %p\n", av7110));
 638
 639         if (cmd == OSD_SEND_CMD)
 640                 return av7110_osd_cmd(av7110, (osd_cmd_t *) parg);
 641
 642         return -EINVAL;
 643         }
 644
 645
 646 static struct file_operations dvb_osd_fops = {
 647         .owner          = THIS_MODULE,
 648         .ioctl          = dvb_generic_ioctl,
 649         .open           = dvb_generic_open,
 650         .release        = dvb_generic_release,
 651 };
 652
 653 static struct dvb_device dvbdev_osd = {
 654         .priv           = 0,
 655         .users          = 1,
 656         .writers        = 1,
 657         .fops           = &dvb_osd_fops,
 658         .kernel_ioctl   = dvb_osd_ioctl,
 659 };
 660 #endif /* CONFIG_DVB_AV7110_OSD */
 661
 662
 663 static inline int SetPIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
 664                           u16 subpid, u16 pcrpid)
 665         {
 666         DEB_EE(("av7110: %p\n", av7110));
 667
 668         if (vpid == 0x1fff || apid == 0x1fff ||
 669             ttpid == 0x1fff || subpid == 0x1fff || pcrpid == 0x1fff) {
 670                 vpid = apid = ttpid = subpid = pcrpid = 0;
 671                 av7110->pids[DMX_PES_VIDEO] = 0;
 672                 av7110->pids[DMX_PES_AUDIO] = 0;
 673                 av7110->pids[DMX_PES_TELETEXT] = 0;
 674                 av7110->pids[DMX_PES_PCR] = 0;
 675         }
 676
 677         return av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, MultiPID, 5,
 678                              pcrpid, vpid, apid, ttpid, subpid);
 679 }
 680
 681 void ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
 682                 u16 subpid, u16 pcrpid)
 683 {
 684         DEB_EE(("av7110: %p\n", av7110));
 685
 686         if (down_interruptible(&av7110->pid_mutex))
 687                 return;
 688
 689         if (!(vpid & 0x8000))
 690                 av7110->pids[DMX_PES_VIDEO] = vpid;
 691         if (!(apid & 0x8000))
 692                 av7110->pids[DMX_PES_AUDIO] = apid;
 693         if (!(ttpid & 0x8000))
 694                 av7110->pids[DMX_PES_TELETEXT] = ttpid;
 695         if (!(pcrpid & 0x8000))
 696                 av7110->pids[DMX_PES_PCR] = pcrpid;
 697
 698         av7110->pids[DMX_PES_SUBTITLE] = 0;
 699
 700         if (av7110->fe_synced) {
 701                 pcrpid = av7110->pids[DMX_PES_PCR];
 702                 SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
 703         }
 704
 705         up(&av7110->pid_mutex);
 706 }
 707
 708
 709 /******************************************************************************
 710  * hardware filter functions
 711  ******************************************************************************/
 712
 713 static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter)
 714 {
 715         struct dvb_demux_feed *dvbdmxfeed = dvbdmxfilter->feed;
 716         struct av7110 *av7110 = (struct av7110 *) dvbdmxfeed->demux->priv;
 717         u16 buf[20];
 718         int ret, i;
 719         u16 handle;
 720 //      u16 mode=0x0320;
 721         u16 mode=0xb96a;
 722
 723         DEB_EE(("av7110: %p\n",av7110));
 724
 725         if (dvbdmxfilter->type == DMX_TYPE_SEC) {
 726                 if (hw_sections) {
 727                         buf[4] = (dvbdmxfilter->filter.filter_value[0] << 8) |
 728                                 dvbdmxfilter->maskandmode[0];
 729                         for (i = 3; i < 18; i++)
 730                                 buf[i + 4 - 2] =
 731                                         (dvbdmxfilter->filter.filter_value[i] << 8) |
 732                                         dvbdmxfilter->maskandmode[i];
 733                         mode = 4;
 734                 }
 735         } else if ((dvbdmxfeed->ts_type & TS_PACKET) &&
 736                    !(dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)) {
 737                 av7110_p2t_init(&av7110->p2t_filter[dvbdmxfilter->index], dvbdmxfeed);
 738         }
 739
 740         buf[0] = (COMTYPE_PID_FILTER << 8) + AddPIDFilter;
 741         buf[1] = 16;
 742         buf[2] = dvbdmxfeed->pid;
 743         buf[3] = mode;
 744
 745         ret = av7110_fw_request(av7110, buf, 20, &handle, 1);
 746         if (ret < 0) {
 747                 printk("StartHWFilter error\n");
 748                 return ret;
 749         }
 750
 751         av7110->handle2filter[handle] = dvbdmxfilter;
 752         dvbdmxfilter->hw_handle = handle;
 753
 754         return ret;
 755                 }
 756
 757 static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
 758 {
 759         struct av7110 *av7110 = (struct av7110 *) dvbdmxfilter->feed->demux->priv;
 760         u16 buf[3];
 761         u16 answ[2];
 762         int ret;
 763         u16 handle;
 764
 765         DEB_EE(("av7110: %p\n", av7110));
 766
 767         handle = dvbdmxfilter->hw_handle;
 768         if (handle > 32) {
 769                 DEB_S(("dvb: StopHWFilter tried to stop invalid filter %d.\n",
 770                        handle));
 771                 DEB_S(("dvb: filter type = %d\n", dvbdmxfilter->type));
 772                 return 0;
 773                 }
 774
 775         av7110->handle2filter[handle] = NULL;
 776
 777         buf[0] = (COMTYPE_PID_FILTER << 8) + DelPIDFilter;
 778         buf[1] = 1;
 779         buf[2] = handle;
 780         ret = av7110_fw_request(av7110, buf, 3, answ, 2);
 781         if (ret)
 782                 printk("StopHWFilter error\n");
 783
 784         if (answ[1] != handle) {
 785                 DEB_S(("dvb: filter %d shutdown error :%d\n", handle, answ[1]));
 786                 ret = -1;
 787         }
 788         return ret;
 789 }
 790
 791
 792 static void dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
 793 {
 794         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
 795         struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
 796         u16 *pid = dvbdmx->pids, npids[5];
 797         int i;
 798
 799         DEB_EE(("av7110: %p\n",av7110));
 800
 801         npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
 802         i = dvbdmxfeed->pes_type;
 803         npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
 804         if ((i == 2) && npids[i] && (dvbdmxfeed->ts_type & TS_PACKET)) {
 805                 npids[i] = 0;
 806                 ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
 807                 StartHWFilter(dvbdmxfeed->filter);
 808                 return;
 809         }
 810         if (dvbdmxfeed->pes_type <= 2 || dvbdmxfeed->pes_type == 4)
 811                 ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
 812
 813         if (dvbdmxfeed->pes_type < 2 && npids[0])
 814                 if (av7110->fe_synced)
 815                         av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
 816
 817         if ((dvbdmxfeed->ts_type & TS_PACKET)) {
 818                 if (dvbdmxfeed->pes_type == 0 && !(dvbdmx->pids[0] & 0x8000))
 819                         av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed);
 820                 if (dvbdmxfeed->pes_type == 1 && !(dvbdmx->pids[1] & 0x8000))
 821                         av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed);
 822         }
 823 }
 824
 825 static void dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
 826 {
 827         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
 828         struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
 829         u16 *pid = dvbdmx->pids, npids[5];
 830         int i;
 831
 832         DEB_EE(("av7110: %p\n", av7110));
 833
 834         if (dvbdmxfeed->pes_type <= 1) {
 835                 av7110_av_stop(av7110, dvbdmxfeed->pes_type ?  RP_VIDEO : RP_AUDIO);
 836                 if (!av7110->rec_mode)
 837                         dvbdmx->recording = 0;
 838                 if (!av7110->playing)
 839                         dvbdmx->playing = 0;
 840         }
 841         npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
 842         i = dvbdmxfeed->pes_type;
 843         switch (i) {
 844         case 2: //teletext
 845                 if (dvbdmxfeed->ts_type & TS_PACKET)
 846                         StopHWFilter(dvbdmxfeed->filter);
 847                 npids[2] = 0;
 848                 break;
 849         case 0:
 850         case 1:
 851         case 4:
 852                 if (!pids_off)
 853                         return;
 854                 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
 855                 break;
 856         }
 857         ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
 858 }
 859
 860 static int av7110_start_feed(struct dvb_demux_feed *feed)
 861 {
 862         struct dvb_demux *demux = feed->demux;
 863         struct av7110 *av7110 = (struct av7110 *) demux->priv;
 864
 865         DEB_EE(("av7110: %p\n", av7110));
 866
 867         if (!demux->dmx.frontend)
 868                 return -EINVAL;
 869
 870         if (feed->pid > 0x1fff)
 871                 return -EINVAL;
 872
 873         if (feed->type == DMX_TYPE_TS) {
 874                 if ((feed->ts_type & TS_DECODER) &&
 875                     (feed->pes_type < DMX_TS_PES_OTHER)) {
 876                         switch (demux->dmx.frontend->source) {
 877                         case DMX_MEMORY_FE:
 878                                 if (feed->ts_type & TS_DECODER)
 879                                        if (feed->pes_type < 2 &&
 880                                            !(demux->pids[0] & 0x8000) &&
 881                                            !(demux->pids[1] & 0x8000)) {
 882                                                dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
 883                                                dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
 884                                                av7110_av_start_play(av7110,RP_AV);
 885                                                demux->playing = 1;
 886                                         }
 887                         break;
 888                 default:
 889                                 dvb_feed_start_pid(feed);
 890                         break;
 891                 }
 892                 } else if ((feed->ts_type & TS_PACKET) &&
 893                            (demux->dmx.frontend->source != DMX_MEMORY_FE)) {
 894                         StartHWFilter(feed->filter);
 895                 }
 896         }
 897
 898         if (feed->type == DMX_TYPE_SEC) {
 899                 int i;
 900
 901                 for (i = 0; i < demux->filternum; i++) {
 902                         if (demux->filter[i].state != DMX_STATE_READY)
 903                                 continue;
 904                         if (demux->filter[i].type != DMX_TYPE_SEC)
 905                                 continue;
 906                         if (demux->filter[i].filter.parent != &feed->feed.sec)
 907                                 continue;
 908                         demux->filter[i].state = DMX_STATE_GO;
 909                         if (demux->dmx.frontend->source != DMX_MEMORY_FE)
 910                                 StartHWFilter(&demux->filter[i]);
 911         }
 912         }
 913
 914         return 0;
 915 }
 916
 917
 918 static int av7110_stop_feed(struct dvb_demux_feed *feed)
 919 {
 920         struct dvb_demux *demux = feed->demux;
 921         struct av7110 *av7110 = (struct av7110 *) demux->priv;
 922
 923         DEB_EE(("av7110: %p\n",av7110));
 924
 925         if (feed->type == DMX_TYPE_TS) {
 926                 if (feed->ts_type & TS_DECODER) {
 927                         if (feed->pes_type >= DMX_TS_PES_OTHER ||
 928                             !demux->pesfilter[feed->pes_type])
 929                                 return -EINVAL;
 930                         demux->pids[feed->pes_type] |= 0x8000;
 931                         demux->pesfilter[feed->pes_type] = 0;
 932                 }
 933                 if (feed->ts_type & TS_DECODER &&
 934                     feed->pes_type < DMX_TS_PES_OTHER) {
 935                         dvb_feed_stop_pid(feed);
 936                 } else
 937                         if ((feed->ts_type & TS_PACKET) &&
 938                             (demux->dmx.frontend->source != DMX_MEMORY_FE))
 939                                 StopHWFilter(feed->filter);
 940         }
 941
 942         if (feed->type == DMX_TYPE_SEC) {
 943                 int i;
 944
 945                 for (i=0; i<demux->filternum; i++)
 946                         if (demux->filter[i].state == DMX_STATE_GO &&
 947                             demux->filter[i].filter.parent == &feed->feed.sec) {
 948                                 demux->filter[i].state = DMX_STATE_READY;
 949                                 if (demux->dmx.frontend->source != DMX_MEMORY_FE)
 950                                         StopHWFilter(&demux->filter[i]);
 951                 }
 952         }
 953
 954         return 0;
 955 }
 956
 957
 958 static void restart_feeds(struct av7110 *av7110)
 959 {
 960         struct dvb_demux *dvbdmx = &av7110->demux;
 961         struct dvb_demux_feed *feed;
 962         int mode;
 963         int i;
 964
 965         DEB_EE(("av7110: %p\n",av7110));
 966
 967         mode = av7110->playing;
 968         av7110->playing = 0;
 969         av7110->rec_mode = 0;
 970
 971         for (i = 0; i < dvbdmx->filternum; i++) {
 972                 feed = &dvbdmx->feed[i];
 973                 if (feed->state == DMX_STATE_GO)
 974                         av7110_start_feed(feed);
 975         }
 976
 977         if (mode)
 978                 av7110_av_start_play(av7110, mode);
 979 }
 980
 981 static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
 982                        uint64_t *stc, unsigned int *base)
 983 {
 984         int ret;
 985         u16 fwstc[4];
 986         u16 tag = ((COMTYPE_REQUEST << 8) + ReqSTC);
 987         struct dvb_demux *dvbdemux;
 988         struct av7110 *av7110;
 989
 990         /* pointer casting paranoia... */
 991         if (!demux)
 992                 BUG();
 993         dvbdemux = (struct dvb_demux *) demux->priv;
 994         if (!dvbdemux)
 995                 BUG();
 996         av7110 = (struct av7110 *) dvbdemux->priv;
 997
 998         DEB_EE(("av7110: %p\n",av7110));
 999
1000         if (num != 0)
1001                 return -EINVAL;
1002
1003         ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4);
1004         if (ret) {
1005                 printk(KERN_ERR "%s: av7110_fw_request error\n", __FUNCTION__);
1006                 return -EIO;
1007 }
1008         DEB_EE(("av7110: fwstc = %04hx %04hx %04hx %04hx\n",
1009                 fwstc[0], fwstc[1], fwstc[2], fwstc[3]));
1010
1011         *stc =  (((uint64_t) ((fwstc[3] & 0x8000) >> 15)) << 32) |
1012                 (((uint64_t)  fwstc[1]) << 16) | ((uint64_t) fwstc[0]);
1013         *base = 1;
1014
1015         DEB_EE(("av7110: stc = %lu\n", (unsigned long)*stc));
1016
1017         return 0;
1018 }
1019
1020
1021 /******************************************************************************
1022  * SEC device file operations
1023  ******************************************************************************/
1024
1025 static int av7110_diseqc_ioctl(struct dvb_frontend *fe, unsigned int cmd, void *arg)
1026 {
1027         struct av7110 *av7110 = fe->before_after_data;
1028
1029         DEB_EE(("av7110: %p\n", av7110));
1030
1031         switch (cmd) {
1032         case FE_SET_TONE:
1033                 switch ((fe_sec_tone_mode_t) arg) {
1034                 case SEC_TONE_ON:
1035                         Set22K(av7110, 1);
1036                         break;
1037                 case SEC_TONE_OFF:
1038                         Set22K(av7110, 0);
1039                         break;
1040                 default:
1041                         return -EINVAL;
1042 };
1043                 break;
1044
1045         case FE_DISEQC_SEND_MASTER_CMD:
1046         {
1047                 struct dvb_diseqc_master_cmd *cmd = arg;
1048                 av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1);
1049                 break;
1050         }
1051
1052         case FE_DISEQC_SEND_BURST:
1053                 av7110_diseqc_send(av7110, 0, NULL, (unsigned long) arg);
1054                 break;
1055
1056         default:
1057                 return -EOPNOTSUPP;
1058 };
1059
1060         return 0;
1061 }
1062
1063
1064 static void av7110_before_after_tune (fe_status_t s, void *data)
1065 {
1066         struct av7110 *av7110 = data;
1067
1068         DEB_EE(("av7110: %p\n",av7110));
1069
1070         av7110->fe_synced = (s & FE_HAS_LOCK) ? 1 : 0;
1071
1072         if (av7110->playing)
1073                 return;
1074
1075         if (down_interruptible(&av7110->pid_mutex))
1076                 return;
1077
1078         if (av7110->fe_synced) {
1079                 SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
1080                         av7110->pids[DMX_PES_AUDIO],
1081                         av7110->pids[DMX_PES_TELETEXT], 0,
1082                         av7110->pids[DMX_PES_PCR]);
1083                 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
1084         } else {
1085                 SetPIDs(av7110, 0, 0, 0, 0, 0);
1086                 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, FlushTSQueue, 0);
1087         }
1088
1089         up(&av7110->pid_mutex);
1090 }
1091
1092
1093 static int av7110_register(struct av7110 *av7110)
1094 {
1095         int ret, i;
1096         struct dvb_demux *dvbdemux=&av7110->demux;
1097
1098         DEB_EE(("av7110: %p\n",av7110));
1099
1100         if (av7110->registered)
1101                 return -1;
1102
1103         av7110->registered=1;
1104
1105         dvb_add_frontend_notifier (av7110->dvb_adapter,
1106                                    av7110_before_after_tune, av7110);
1107
1108         /**
1109          *   init DiSEqC stuff
1110          */
1111         dvb_add_frontend_ioctls (av7110->dvb_adapter,
1112                                  av7110_diseqc_ioctl, NULL, av7110);
1113
1114         dvbdemux->priv = (void *) av7110;
1115
1116         for (i=0; i<32; i++)
1117                 av7110->handle2filter[i]=NULL;
1118
1119         dvbdemux->filternum = 32;
1120         dvbdemux->feednum = 32;
1121         dvbdemux->start_feed = av7110_start_feed;
1122         dvbdemux->stop_feed = av7110_stop_feed;
1123         dvbdemux->write_to_decoder = av7110_write_to_decoder;
1124         dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1125                                       DMX_MEMORY_BASED_FILTERING);
1126
1127         dvb_dmx_init(&av7110->demux);
1128         av7110->demux.dmx.get_stc = dvb_get_stc;
1129
1130         av7110->dmxdev.filternum = 32;
1131         av7110->dmxdev.demux = &dvbdemux->dmx;
1132         av7110->dmxdev.capabilities = 0;
1133
1134         dvb_dmxdev_init(&av7110->dmxdev, av7110->dvb_adapter);
1135
1136         av7110->hw_frontend.source = DMX_FRONTEND_0;
1137
1138         ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1139
1140         if (ret < 0)
1141                 return ret;
1142
1143         av7110->mem_frontend.source = DMX_MEMORY_FE;
1144
1145         ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1146
1147         if (ret < 0)
1148                 return ret;
1149
1150         ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1151                                              &av7110->hw_frontend);
1152         if (ret < 0)
1153                 return ret;
1154
1155         av7110_av_register(av7110);
1156         av7110_ca_register(av7110);
1157
1158 #ifdef CONFIG_DVB_AV7110_OSD
1159         dvb_register_device(av7110->dvb_adapter, &av7110->osd_dev,
1160                             &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1161 #endif
1162
1163         dvb_net_init(av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1164
1165         return 0;
1166 }
1167
1168
1169 static void dvb_unregister(struct av7110 *av7110)
1170 {
1171         struct dvb_demux *dvbdemux=&av7110->demux;
1172
1173         DEB_EE(("av7110: %p\n",av7110));
1174
1175         if (!av7110->registered)
1176                 return;
1177
1178         dvb_net_release(&av7110->dvb_net);
1179
1180         dvbdemux->dmx.close(&dvbdemux->dmx);
1181         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1182         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1183
1184         dvb_dmxdev_release(&av7110->dmxdev);
1185         dvb_dmx_release(&av7110->demux);
1186
1187         dvb_remove_frontend_notifier (av7110->dvb_adapter,
1188                                       av7110_before_after_tune);
1189
1190         dvb_remove_frontend_ioctls (av7110->dvb_adapter,
1191                                     av7110_diseqc_ioctl, NULL);
1192
1193         dvb_unregister_device(av7110->osd_dev);
1194         av7110_av_unregister(av7110);
1195         av7110_ca_unregister(av7110);
1196 }
1197
1198
1199 /****************************************************************************
1200  * I2C client commands
1201  ****************************************************************************/
1202
1203 int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1204 {
1205         u8 msg[2] = { reg, val };
1206         struct dvb_i2c_bus *i2c = av7110->i2c_bus;
1207         struct i2c_msg msgs;
1208
1209         msgs.flags = 0;
1210         msgs.addr = id / 2;
1211         msgs.len = 2;
1212         msgs.buf = msg;
1213         return i2c->xfer(i2c, &msgs, 1);
1214 }
1215
1216 u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1217 {
1218         struct dvb_i2c_bus *i2c = av7110->i2c_bus;
1219         u8 mm1[] = {0x00};
1220         u8 mm2[] = {0x00};
1221         struct i2c_msg msgs[2];
1222
1223         msgs[0].flags = 0;
1224         msgs[1].flags = I2C_M_RD;
1225         msgs[0].addr = msgs[1].addr = id / 2;
1226         mm1[0] = reg;
1227         msgs[0].len = 1; msgs[1].len = 1;
1228         msgs[0].buf = mm1; msgs[1].buf = mm2;
1229         i2c->xfer(i2c, msgs, 2);
1230
1231         return mm2[0];
1232 }
1233
1234 static int master_xfer(struct dvb_i2c_bus *i2c, const struct i2c_msg msgs[], int num)
1235 {
1236         struct saa7146_dev *dev = i2c->data;
1237         return saa7146_i2c_transfer(dev, msgs, num, 6);
1238 }
1239
1240 /****************************************************************************
1241  * INITIALIZATION
1242  ****************************************************************************/
1243
1244
1245 static int check_firmware(struct av7110* av7110)
1246 {
1247         u32 crc = 0, len = 0;
1248         unsigned char *ptr;
1249
1250         /* check for firmware magic */
1251         ptr = av7110->bin_fw;
1252         if (ptr[0] != 'A' || ptr[1] != 'V' ||
1253             ptr[2] != 'F' || ptr[3] != 'W') {
1254                 printk("dvb-ttpci: this is not an av7110 firmware\n");
1255                 return -EINVAL;
1256         }
1257         ptr += 4;
1258
1259         /* check dpram file */
1260         crc = ntohl(*(u32*)ptr);
1261         ptr += 4;
1262         len = ntohl(*(u32*)ptr);
1263         ptr += 4;
1264         if (len >= 512) {
1265                 printk("dvb-ttpci: dpram file is way to big.\n");
1266                 return -EINVAL;
1267         }
1268         if( crc != crc32_le(0,ptr,len)) {
1269                 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1270                 return -EINVAL;
1271         }
1272         av7110->bin_dpram = ptr;
1273         av7110->size_dpram = len;
1274         ptr += len;
1275
1276         /* check root file */
1277         crc = ntohl(*(u32*)ptr);
1278         ptr += 4;
1279         len = ntohl(*(u32*)ptr);
1280         ptr += 4;
1281
1282         if (len <= 200000 || len >= 300000 ||
1283             len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1284                 printk("dvb-ttpci: root file has strange size (%d). aborting.\n",len);
1285                 return -EINVAL;
1286         }
1287         if( crc != crc32_le(0,ptr,len)) {
1288                 printk("dvb-ttpci: crc32 of root file does not match.\n");
1289                 return -EINVAL;
1290         }
1291         av7110->bin_root = ptr;
1292         av7110->size_root = len;
1293         return 0;
1294 }
1295
1296 #ifdef CONFIG_DVB_AV7110_FIRMWARE_FILE
1297 #include "av7110_firm.h"
1298 static inline int get_firmware(struct av7110* av7110)
1299 {
1300         av7110->bin_fw = dvb_ttpci_fw;
1301         av7110->size_fw = sizeof(dvb_ttpci_fw);
1302         return check_firmware(av7110);
1303 }
1304 #else
1305 static int get_firmware(struct av7110* av7110)
1306 {
1307         int ret;
1308         const struct firmware *fw;
1309
1310         /* request the av7110 firmware, this will block until someone uploads it */
1311         ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev);
1312         if (ret) {
1313                 printk("dvb-ttpci: cannot request firmware!\n");
1314                 return -EINVAL;
1315         }
1316         if (fw->size <= 200000) {
1317                 printk("dvb-ttpci: this firmware is way too small.\n");
1318                 return -EINVAL;
1319         }
1320         /* check if the firmware is available */
1321         av7110->bin_fw = (unsigned char*) vmalloc(fw->size);
1322         if (NULL == av7110->bin_fw) {
1323                 DEB_D(("out of memory\n"));
1324                 return -ENOMEM;
1325         }
1326         memcpy(av7110->bin_fw, fw->data, fw->size);
1327         av7110->size_fw = fw->size;
1328         if ((ret = check_firmware(av7110)))
1329                 vfree(av7110->bin_fw);
1330         return ret;
1331 }
1332 #endif
1333
1334 static int av7110_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_data *pci_ext)
1335 {
1336         struct av7110 *av7110 = NULL;
1337         int ret = 0;
1338
1339         DEB_EE(("dev: %p\n", dev));
1340
1341         /* prepare the av7110 device struct */
1342         if (!(av7110 = kmalloc (sizeof (struct av7110), GFP_KERNEL))) {
1343                 printk ("%s: out of memory!\n", __FUNCTION__);
1344                 return -ENOMEM;
1345         }
1346         DEB_EE(("av7110: %p\n", av7110));
1347         memset(av7110, 0, sizeof(struct av7110));
1348
1349         av7110->card_name = (char*)pci_ext->ext_priv;
1350         av7110->dev=(struct saa7146_dev *)dev;
1351         dev->ext_priv = av7110;
1352
1353         if ((ret = get_firmware(av7110))) {
1354                 kfree(av7110);
1355                 return ret;
1356         }
1357
1358         dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name, THIS_MODULE);
1359
1360         /* the Siemens DVB needs this if you want to have the i2c chips
1361            get recognized before the main driver is fully loaded */
1362         saa7146_write(dev, GPIO_CTRL, 0x500000);
1363
1364         saa7146_i2c_adapter_prepare(dev, NULL, 0, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
1365
1366         av7110->i2c_bus = dvb_register_i2c_bus (master_xfer, dev,
1367                                                 av7110->dvb_adapter, 0);
1368
1369         if (!av7110->i2c_bus) {
1370                 dvb_unregister_adapter (av7110->dvb_adapter);
1371                 kfree(av7110);
1372                 return -ENOMEM;
1373         }
1374
1375         ttpci_eeprom_parse_mac(av7110->i2c_bus);
1376
1377         saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
1378         saa7146_write(dev, BCS_CTRL, 0x80400040);
1379
1380         /* set dd1 stream a & b */
1381         saa7146_write(dev, DD1_STREAM_B, 0x00000000);
1382         saa7146_write(dev, DD1_INIT, 0x03000000);
1383         saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
1384
1385         /* upload all */
1386         saa7146_write(dev, MC2, 0x077c077c);
1387         saa7146_write(dev, GPIO_CTRL, 0x000000);
1388
1389         tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
1390         tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
1391
1392         sema_init(&av7110->pid_mutex, 1);
1393
1394         /* locks for data transfers from/to AV7110 */
1395         spin_lock_init (&av7110->debilock);
1396         sema_init(&av7110->dcomlock, 1);
1397         av7110->debilock=SPIN_LOCK_UNLOCKED;
1398         av7110->debitype=-1;
1399
1400         /* default OSD window */
1401         av7110->osdwin=1;
1402
1403         /* ARM "watchdog" */
1404         init_waitqueue_head(&av7110->arm_wait);
1405         av7110->arm_thread=0;
1406
1407         /* allocate and init buffers */
1408         av7110->debi_virt = pci_alloc_consistent(dev->pci, 8192,
1409                                                  &av7110->debi_bus);
1410         if (!av7110->debi_virt) {
1411                 ret = -ENOMEM;
1412                 goto err;
1413         }
1414
1415         av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
1416         if (!av7110->iobuf) {
1417                 ret = -ENOMEM;
1418                 goto err;
1419         }
1420
1421         av7110_av_init(av7110);
1422
1423         /* init BMP buffer */
1424         av7110->bmpbuf=av7110->iobuf+AVOUTLEN+AOUTLEN;
1425         init_waitqueue_head(&av7110->bmpq);
1426
1427         av7110_ca_init(av7110);
1428
1429         /* load firmware into AV7110 cards */
1430         av7110_bootarm(av7110);
1431         if (av7110_firmversion(av7110)) {
1432                 ret = -EIO;
1433                 goto err2;
1434         }
1435
1436         if (FW_VERSION(av7110->arm_app)<0x2501)
1437                 printk ("av7110: Warning, firmware version 0x%04x is too old. "
1438                         "System might be unstable!\n", FW_VERSION(av7110->arm_app));
1439
1440         if (kernel_thread(arm_thread, (void *) av7110, 0) < 0) {
1441                 printk(KERN_ERR "av7110(%d): faile to start arm_mon kernel thread\n",
1442                        av7110->dvb_adapter->num);
1443                 goto err2;
1444         }
1445
1446         /* set internal volume control to maximum */
1447         av7110->adac_type = DVB_ADAC_TI;
1448         av7110_set_volume(av7110, 0xff, 0xff);
1449
1450         av7710_set_video_mode(av7110, vidmode);
1451
1452         /* handle different card types */
1453         /* remaining inits according to card and frontend type */
1454         av7110->has_analog_tuner = 0;
1455         av7110->current_input = 0;
1456         if (i2c_writereg(av7110, 0x20, 0x00, 0x00)==1) {
1457                 printk ("av7110(%d): Crystal audio DAC detected\n",
1458                         av7110->dvb_adapter->num);
1459                 av7110->adac_type = DVB_ADAC_CRYSTAL;
1460                 i2c_writereg(av7110, 0x20, 0x01, 0xd2);
1461                 i2c_writereg(av7110, 0x20, 0x02, 0x49);
1462                 i2c_writereg(av7110, 0x20, 0x03, 0x00);
1463                 i2c_writereg(av7110, 0x20, 0x04, 0x00);
1464
1465         /**
1466          * some special handling for the Siemens DVB-C cards...
1467          */
1468         } else if (0 == av7110_init_analog_module(av7110)) {
1469                 /* done. */
1470         }
1471         else if (dev->pci->subsystem_vendor == 0x110a) {
1472                 printk("av7110(%d): DVB-C w/o analog module detected\n",
1473                         av7110->dvb_adapter->num);
1474                 av7110->adac_type = DVB_ADAC_NONE;
1475         }
1476         else {
1477                 av7110->adac_type = adac;
1478                 printk("av7110(%d): adac type set to %d\n",
1479                         av7110->dvb_adapter->num, av7110->adac_type);
1480                 }
1481
1482         if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP) {
1483                 // switch DVB SCART on
1484                 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0);
1485                 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1);
1486                 if (rgb_on)
1487                         saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16
1488                 //saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // SCARTpin 8
1489         }
1490
1491         av7110_set_volume(av7110, 0xff, 0xff);
1492
1493         av7110_setup_irc_config (av7110, 0);
1494         av7110_register(av7110);
1495
1496         /* special case DVB-C: these cards have an analog tuner
1497            plus need some special handling, so we have separate
1498            saa7146_ext_vv data for these... */
1499         ret = av7110_init_v4l(av7110);
1500
1501         if (ret)
1502                 goto err3;
1503
1504         printk(KERN_INFO "av7110: found av7110-%d.\n",av7110_num);
1505         av7110->device_initialized = 1;
1506         av7110_num++;
1507         return 0;
1508
1509 err3:
1510         av7110->arm_rmmod = 1;
1511         wake_up_interruptible(&av7110->arm_wait);
1512         while (av7110->arm_thread)
1513                 dvb_delay(1);
1514 err2:
1515         av7110_ca_exit(av7110);
1516         av7110_av_exit(av7110);
1517 err:
1518         dvb_unregister_i2c_bus (master_xfer,av7110->i2c_bus->adapter,
1519                                 av7110->i2c_bus->id);
1520
1521         dvb_unregister_adapter (av7110->dvb_adapter);
1522
1523         if (NULL != av7110->debi_virt)
1524                 pci_free_consistent(dev->pci, 8192, av7110->debi_virt, av7110->debi_bus);
1525         if (NULL != av7110->iobuf)
1526                 vfree(av7110->iobuf);
1527         if (NULL != av7110 ) {
1528                 kfree(av7110);
1529         }
1530
1531         return ret;
1532 }
1533
1534 static int av7110_detach (struct saa7146_dev* saa)
1535 {
1536         struct av7110 *av7110 = (struct av7110*)saa->ext_priv;
1537         DEB_EE(("av7110: %p\n",av7110));
1538
1539         if( 0 == av7110->device_initialized ) {
1540                 return 0;
1541         }
1542
1543         av7110_exit_v4l(av7110);
1544
1545         av7110->arm_rmmod=1;
1546         wake_up_interruptible(&av7110->arm_wait);
1547
1548         while (av7110->arm_thread)
1549                 dvb_delay(1);
1550
1551         dvb_unregister(av7110);
1552
1553         IER_DISABLE(saa, (MASK_19 | MASK_03));
1554 //      saa7146_write (av7110->dev, IER,
1555 //                   saa7146_read(av7110->dev, IER) & ~(MASK_19 | MASK_03));
1556
1557         saa7146_write(av7110->dev, ISR,(MASK_19 | MASK_03));
1558
1559         av7110_ca_exit(av7110);
1560         av7110_av_exit(av7110);
1561
1562         vfree(av7110->iobuf);
1563         pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
1564                             av7110->debi_bus);
1565
1566         dvb_unregister_i2c_bus (master_xfer,av7110->i2c_bus->adapter, av7110->i2c_bus->id);
1567         dvb_unregister_adapter (av7110->dvb_adapter);
1568
1569         av7110_num--;
1570 #ifndef CONFIG_DVB_AV7110_FIRMWARE_FILE
1571         if (av7110->bin_fw)
1572                 vfree(av7110->bin_fw);
1573 #endif
1574         kfree (av7110);
1575         saa->ext_priv = NULL;
1576
1577         return 0;
1578 }
1579
1580
1581 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
1582 {
1583         struct av7110 *av7110 = (struct av7110*)dev->ext_priv;
1584
1585 //      DEB_INT(("dev: %p, av7110: %p\n",dev,av7110));
1586
1587         if (*isr & MASK_19)
1588                 tasklet_schedule (&av7110->debi_tasklet);
1589
1590         if (*isr & MASK_03)
1591                 tasklet_schedule (&av7110->gpio_tasklet);
1592 }
1593
1594
1595 static struct saa7146_extension av7110_extension;
1596
1597 #define MAKE_AV7110_INFO(x_var,x_name) \
1598 static struct saa7146_pci_extension_data x_var = { \
1599         .ext_priv = x_name, \
1600         .ext = &av7110_extension }
1601
1602 MAKE_AV7110_INFO(fs_1_5, "Siemens cable card PCI rev1.5");
1603 MAKE_AV7110_INFO(fs_1_3, "Siemens/Technotrend/Hauppauge PCI rev1.3");
1604 MAKE_AV7110_INFO(tt_1_6, "Technotrend/Hauppauge PCI rev1.3 or 1.6");
1605 MAKE_AV7110_INFO(tt_2_1, "Technotrend/Hauppauge PCI rev2.1");
1606 MAKE_AV7110_INFO(tt_t,   "Technotrend/Hauppauge PCI DVB-T");
1607 MAKE_AV7110_INFO(unkwn0, "Technotrend/Hauppauge PCI rev?(unknown0)?");
1608 MAKE_AV7110_INFO(unkwn1, "Technotrend/Hauppauge PCI rev?(unknown1)?");
1609 MAKE_AV7110_INFO(unkwn2, "Technotrend/Hauppauge PCI rev?(unknown2)?");
1610 MAKE_AV7110_INFO(nexus,  "Technotrend/Hauppauge Nexus PCI DVB-S");
1611 MAKE_AV7110_INFO(dvboc11,"Octal/Technotrend DVB-C for iTV");
1612
1613 static struct pci_device_id pci_tbl[] = {
1614         MAKE_EXTENSION_PCI(fs_1_5, 0x110a, 0xffff),
1615         MAKE_EXTENSION_PCI(fs_1_5, 0x110a, 0x0000),
1616         MAKE_EXTENSION_PCI(fs_1_3, 0x13c2, 0x0000),
1617         MAKE_EXTENSION_PCI(unkwn0, 0x13c2, 0x1002),
1618         MAKE_EXTENSION_PCI(tt_1_6, 0x13c2, 0x0001),
1619         MAKE_EXTENSION_PCI(tt_2_1, 0x13c2, 0x0002),
1620         MAKE_EXTENSION_PCI(tt_2_1, 0x13c2, 0x0003),
1621         MAKE_EXTENSION_PCI(tt_2_1, 0x13c2, 0x0004),
1622         MAKE_EXTENSION_PCI(tt_1_6, 0x13c2, 0x0006),
1623         MAKE_EXTENSION_PCI(tt_t,   0x13c2, 0x0008),
1624         MAKE_EXTENSION_PCI(tt_2_1, 0x13c2, 0x1102),
1625         MAKE_EXTENSION_PCI(unkwn1, 0xffc2, 0x0000),
1626         MAKE_EXTENSION_PCI(unkwn2, 0x00a1, 0x00a1),
1627         MAKE_EXTENSION_PCI(nexus,  0x00a1, 0xa1a0),
1628         MAKE_EXTENSION_PCI(dvboc11,0x13c2, 0x000a),
1629         {
1630                 .vendor    = 0,
1631         }
1632 };
1633
1634 MODULE_DEVICE_TABLE(pci, pci_tbl);
1635
1636
1637 static struct saa7146_extension av7110_extension = {
1638         .name           = "dvb\0",
1639         .flags          = SAA7146_I2C_SHORT_DELAY,
1640
1641         .module         = THIS_MODULE,
1642         .pci_tbl        = &pci_tbl[0],
1643         .attach         = av7110_attach,
1644         .detach         = av7110_detach,
1645
1646         .irq_mask       = MASK_19|MASK_03,
1647         .irq_func       = av7110_irq,
1648 };
1649
1650
1651 static int __init av7110_init(void)
1652 {
1653         int retval;
1654         retval = saa7146_register_extension(&av7110_extension);
1655 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
1656         if (retval)
1657                 goto failed_saa7146_register;
1658
1659         retval = av7110_ir_init();
1660         if (retval)
1661                 goto failed_av7110_ir_init;
1662         return 0;
1663 failed_av7110_ir_init:
1664         saa7146_unregister_extension(&av7110_extension);
1665 failed_saa7146_register:
1666 #endif
1667         return retval;
1668 }
1669
1670
1671 static void __exit av7110_exit(void)
1672 {
1673 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
1674         av7110_ir_exit();
1675 #endif
1676         saa7146_unregister_extension(&av7110_extension);
1677 }
1678
1679 module_init(av7110_init);
1680 module_exit(av7110_exit);
1681
1682 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
1683                    "Siemens, Technotrend, Hauppauge");
1684 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
1685 MODULE_LICENSE("GPL");
1686
1687 MODULE_PARM(av7110_debug,"i");
1688 MODULE_PARM(vidmode,"i");
1689 MODULE_PARM_DESC(vidmode,"analog video out: 0 off, 1 CVBS+RGB (default), 2 CVBS+YC, 3 YC");
1690 MODULE_PARM(pids_off,"i");
1691 MODULE_PARM_DESC(pids_off,"clear video/audio/PCR PID filters when demux is closed");
1692 MODULE_PARM(adac,"i");
1693 MODULE_PARM_DESC(adac,"audio DAC type: 0 TI, 1 CRYSTAL, 2 MSP (use if autodetection fails)");
1694 MODULE_PARM(hw_sections, "i");
1695 MODULE_PARM_DESC(hw_sections, "0 use software section filter, 1 use hardware");
1696 MODULE_PARM(rgb_on, "i");
1697 MODULE_PARM_DESC(rgb_on, "For Siemens DVB-C cards only: Enable RGB control"
1698                 " signal on SCART pin 16 to switch SCART video mode from CVBS to RGB");