2 * driver for the SAA7146 based AV110 cards (like the Fujitsu-Siemens DVB)
3 * av7110.c: initialization and demux stuff
5 * Copyright (C) 1999-2002 Ralph Metzler
6 * & Marcus Metzler for convergence integrated media GmbH
8 * originally based on code by:
9 * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
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.
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.
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
29 * the project's page is at http://www.linuxtv.org/dvb/
33 #include <linux/config.h>
34 #include <linux/module.h>
35 #include <linux/kmod.h>
36 #include <linux/delay.h>
38 #include <linux/timer.h>
39 #include <linux/poll.h>
40 #include <linux/byteorder/swabb.h>
41 #include <linux/smp_lock.h>
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>
54 #include <asm/system.h>
55 #include <asm/semaphore.h>
57 #include <linux/dvb/frontend.h>
60 #include "dvb_frontend.h"
61 #include "dvb_functions.h"
64 #define DEBUG_VARIABLE av7110_debug
66 #include "ttpci-eeprom.h"
68 #include "av7110_hw.h"
69 #include "av7110_av.h"
70 #include "av7110_ca.h"
71 #include "av7110_ipack.h"
74 static void restart_feeds(struct av7110 *av7110);
78 static int vidmode=CVBS_RGB_OUT;
80 static int adac=DVB_ADAC_TI;
81 static int hw_sections = 0;
82 static int rgb_on = 0;
87 static void recover_arm(struct av7110 *av7110)
89 DEB_EE(("av7110: %p\n",av7110));
91 av7110_bootarm(av7110);
93 restart_feeds(av7110);
94 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, av7110->ir_config);
97 static void arm_error(struct av7110 *av7110)
99 DEB_EE(("av7110: %p\n",av7110));
101 av7110->arm_errors++;
106 static int arm_thread(void *data)
108 struct av7110 *av7110 = data;
109 unsigned long timeout;
112 DEB_EE(("av7110: %p\n",av7110));
114 dvb_kernel_thread_setup ("arm_mon");
115 av7110->arm_thread = current;
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*/
124 if (!av7110->arm_ready)
127 if (down_interruptible(&av7110->dcomlock))
130 newloops=rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
131 up(&av7110->dcomlock);
133 if (newloops==av7110->arm_loops) {
134 printk(KERN_ERR "av7110%d: ARM crashed!\n",
135 av7110->dvb_adapter->num);
139 if (down_interruptible(&av7110->dcomlock))
142 newloops=rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2)-1;
143 up(&av7110->dcomlock);
145 av7110->arm_loops=newloops;
148 av7110->arm_thread = NULL;
154 * Hack! we save the last av7110 ptr. This should be ok, since
155 * you rarely will use more then one IR control.
157 * If we want to support multiple controls we would have to do much more...
159 void av7110_setup_irc_config (struct av7110 *av7110, u32 ir_config)
161 static struct av7110 *last;
163 DEB_EE(("av7110: %p\n",av7110));
171 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
172 av7110->ir_config = ir_config;
176 static void (*irc_handler)(u32);
178 void av7110_register_irc_handler(void (*func)(u32))
180 DEB_EE(("registering %p\n", func));
184 void av7110_unregister_irc_handler(void (*func)(u32))
186 DEB_EE(("unregistering %p\n", func));
190 void run_handlers(unsigned long ircom)
192 if (irc_handler != NULL)
193 (*irc_handler)((u32) ircom);
196 DECLARE_TASKLET(irtask,run_handlers,0);
198 void IR_handle(struct av7110 *av7110, u32 ircom)
200 DEB_S(("av7110: ircommand = %08x\n", ircom));
201 irtask.data = (unsigned long) ircom;
202 tasklet_schedule(&irtask);
205 /****************************************************************************
207 ****************************************************************************/
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)
215 DEB_INT(("av7110: %p\n",av7110));
217 if (!dvbdmxfilter->feed->demux->dmx.frontend)
219 if (dvbdmxfilter->feed->demux->dmx.frontend->source==DMX_MEMORY_FE)
222 switch(dvbdmxfilter->type) {
224 if ((((buffer1[1]<<8)|buffer1[2])&0xfff)+3!=buffer1_len)
226 if (dvbdmxfilter->doneq) {
227 struct dmx_section_filter *filter=&dvbdmxfilter->filter;
231 for (i=0; i<DVB_DEMUX_MASK_MAX; i++) {
232 xor=filter->filter_value[i]^buffer1[i];
233 neq|=dvbdmxfilter->maskandnotmode[i]&xor;
238 return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len,
239 buffer2, buffer2_len,
240 &dvbdmxfilter->filter,
243 if (!(dvbdmxfilter->feed->ts_type & TS_PACKET))
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,
251 av7110_p2t_write(buffer1, buffer1_len,
252 dvbdmxfilter->feed->pid,
253 &av7110->p2t_filter[dvbdmxfilter->index]);
260 //#define DEBUG_TIMING
261 static inline void print_time(char *s)
265 do_gettimeofday(&tv);
266 printk("%s: %d.%d\n", s, (int)tv.tv_sec, (int)tv.tv_usec);
270 static void debiirq (unsigned long data)
272 struct av7110 *av7110 = (struct av7110*) data;
273 int type=av7110->debitype;
274 int handle=(type>>8)&0x1f;
276 // DEB_EE(("av7110: %p\n",av7110));
279 saa7146_write(av7110->dev, IER,
280 saa7146_read(av7110->dev, IER) & ~MASK_19 );
281 saa7146_write(av7110->dev, ISR, MASK_19 );
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);
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);
307 case DATA_PES_RECORD:
308 if (av7110->demux.recording)
309 av7110_record_cb(&av7110->p2t[handle],
310 (u8 *)av7110->debi_virt,
312 spin_lock(&av7110->debilock);
313 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
314 ARM_ClearMailBox(av7110);
315 spin_unlock(&av7110->debilock);
321 if (av7110->handle2filter[handle])
322 DvbDmxFilterCallback((u8 *)av7110->debi_virt,
323 av7110->debilen, NULL, 0,
324 av7110->handle2filter[handle],
326 spin_lock(&av7110->debilock);
327 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
328 ARM_ClearMailBox(av7110);
329 spin_unlock(&av7110->debilock);
334 u8 *data=av7110->debi_virt;
336 if ((data[0]<2) && data[2]==0xff) {
339 flags|=CA_CI_MODULE_PRESENT;
341 flags|=CA_CI_MODULE_READY;
342 av7110->ci_slot[data[0]].flags=flags;
344 ci_get_data(&av7110->ci_rbuffer,
347 spin_lock(&av7110->debilock);
348 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
349 ARM_ClearMailBox(av7110);
350 spin_unlock(&av7110->debilock);
354 case DATA_COMMON_INTERFACE:
355 CI_handle(av7110, (u8 *)av7110->debi_virt, av7110->debilen);
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)));
371 spin_lock(&av7110->debilock);
372 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
373 ARM_ClearMailBox(av7110);
374 spin_unlock(&av7110->debilock);
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);
389 spin_lock(&av7110->debilock);
390 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
391 ARM_ClearMailBox(av7110);
392 spin_unlock(&av7110->debilock);
397 spin_lock(&av7110->debilock);
398 ARM_ClearMailBox(av7110);
399 spin_unlock(&av7110->debilock);
402 static void gpioirq (unsigned long data)
404 struct av7110 *av7110 = (struct av7110*) data;
408 //printk("GPIO0 irq\n");
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));
415 spin_lock(&av7110->debilock);
417 ARM_ClearIrq(av7110);
419 saa7146_write(av7110->dev, IER,
420 saa7146_read(av7110->dev, IER) & ~MASK_19 );
421 saa7146_write(av7110->dev, ISR, MASK_19 );
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;
429 // DEB_D(("GPIO0 irq %d %d\n", av7110->debitype, av7110->debilen));
432 // DEB_D(("GPIO0 irq %02x\n", av7110->debitype&0xff));
433 switch (av7110->debitype&0xff) {
439 case DATA_MPEG_VIDEO_EVENT:
442 struct video_event event;
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);
447 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
448 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
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));
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)
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;
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;
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;
476 dvb_video_add_event(av7110, &event);
483 struct dvb_ringbuffer *cibuf=&av7110->ci_wbuffer;
485 avail=dvb_ringbuffer_avail(cibuf);
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);
492 len= DVB_RINGBUFFER_PEEK(cibuf,0)<<8;
493 len|=DVB_RINGBUFFER_PEEK(cibuf,1);
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);
500 DVB_RINGBUFFER_SKIP(cibuf,2);
502 dvb_ringbuffer_read(cibuf,av7110->debi_virt,len,0);
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 );
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);
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);
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);
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);
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);
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 );
549 iwdebi(av7110, DEBISWAB, DPRAM_BASE+txbuf, 0, (len+3)&~3);
550 spin_unlock(&av7110->debilock);
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);
563 if (len>av7110->bmplen)
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);
572 saa7146_wait_for_debi_done(av7110->dev);
573 saa7146_write(av7110->dev, IER,
574 saa7146_read(av7110->dev, IER) | MASK_19 );
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);
582 case DATA_COMMON_INTERFACE:
586 if (!len || len>4*1024) {
587 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
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);
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);
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);
615 swahw32(irdebi(av7110, DEBINOSWAP, Reserved, 0, 4)));
616 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
620 printk("gpioirq unknown type=%d len=%d\n",
621 av7110->debitype, av7110->debilen);
624 ARM_ClearMailBox(av7110);
626 spin_unlock(&av7110->debilock);
630 #ifdef CONFIG_DVB_AV7110_OSD
631 static int dvb_osd_ioctl(struct inode *inode, struct file *file,
632 unsigned int cmd, void *parg)
634 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
635 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
637 DEB_EE(("av7110: %p\n", av7110));
639 if (cmd == OSD_SEND_CMD)
640 return av7110_osd_cmd(av7110, (osd_cmd_t *) parg);
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,
653 static struct dvb_device dvbdev_osd = {
657 .fops = &dvb_osd_fops,
658 .kernel_ioctl = dvb_osd_ioctl,
660 #endif /* CONFIG_DVB_AV7110_OSD */
663 static inline int SetPIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
664 u16 subpid, u16 pcrpid)
666 DEB_EE(("av7110: %p\n", av7110));
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;
677 return av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, MultiPID, 5,
678 pcrpid, vpid, apid, ttpid, subpid);
681 void ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
682 u16 subpid, u16 pcrpid)
684 DEB_EE(("av7110: %p\n", av7110));
686 if (down_interruptible(&av7110->pid_mutex))
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;
698 av7110->pids[DMX_PES_SUBTITLE] = 0;
700 if (av7110->fe_synced) {
701 pcrpid = av7110->pids[DMX_PES_PCR];
702 SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
705 up(&av7110->pid_mutex);
709 /******************************************************************************
710 * hardware filter functions
711 ******************************************************************************/
713 static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter)
715 struct dvb_demux_feed *dvbdmxfeed = dvbdmxfilter->feed;
716 struct av7110 *av7110 = (struct av7110 *) dvbdmxfeed->demux->priv;
723 DEB_EE(("av7110: %p\n",av7110));
725 if (dvbdmxfilter->type == DMX_TYPE_SEC) {
727 buf[4] = (dvbdmxfilter->filter.filter_value[0] << 8) |
728 dvbdmxfilter->maskandmode[0];
729 for (i = 3; i < 18; i++)
731 (dvbdmxfilter->filter.filter_value[i] << 8) |
732 dvbdmxfilter->maskandmode[i];
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);
740 buf[0] = (COMTYPE_PID_FILTER << 8) + AddPIDFilter;
742 buf[2] = dvbdmxfeed->pid;
745 ret = av7110_fw_request(av7110, buf, 20, &handle, 1);
747 printk("StartHWFilter error\n");
751 av7110->handle2filter[handle] = dvbdmxfilter;
752 dvbdmxfilter->hw_handle = handle;
757 static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
759 struct av7110 *av7110 = (struct av7110 *) dvbdmxfilter->feed->demux->priv;
765 DEB_EE(("av7110: %p\n", av7110));
767 handle = dvbdmxfilter->hw_handle;
769 DEB_S(("dvb: StopHWFilter tried to stop invalid filter %d.\n",
771 DEB_S(("dvb: filter type = %d\n", dvbdmxfilter->type));
775 av7110->handle2filter[handle] = NULL;
777 buf[0] = (COMTYPE_PID_FILTER << 8) + DelPIDFilter;
780 ret = av7110_fw_request(av7110, buf, 3, answ, 2);
782 printk("StopHWFilter error\n");
784 if (answ[1] != handle) {
785 DEB_S(("dvb: filter %d shutdown error :%d\n", handle, answ[1]));
792 static void dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
794 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
795 struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
796 u16 *pid = dvbdmx->pids, npids[5];
799 DEB_EE(("av7110: %p\n",av7110));
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)) {
806 ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
807 StartHWFilter(dvbdmxfeed->filter);
810 if (dvbdmxfeed->pes_type <= 2 || dvbdmxfeed->pes_type == 4)
811 ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
813 if (dvbdmxfeed->pes_type < 2 && npids[0])
814 if (av7110->fe_synced)
815 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
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);
825 static void dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
827 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
828 struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
829 u16 *pid = dvbdmx->pids, npids[5];
832 DEB_EE(("av7110: %p\n", av7110));
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)
841 npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
842 i = dvbdmxfeed->pes_type;
845 if (dvbdmxfeed->ts_type & TS_PACKET)
846 StopHWFilter(dvbdmxfeed->filter);
854 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
857 ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
860 static int av7110_start_feed(struct dvb_demux_feed *feed)
862 struct dvb_demux *demux = feed->demux;
863 struct av7110 *av7110 = (struct av7110 *) demux->priv;
865 DEB_EE(("av7110: %p\n", av7110));
867 if (!demux->dmx.frontend)
870 if (feed->pid > 0x1fff)
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) {
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);
889 dvb_feed_start_pid(feed);
892 } else if ((feed->ts_type & TS_PACKET) &&
893 (demux->dmx.frontend->source != DMX_MEMORY_FE)) {
894 StartHWFilter(feed->filter);
898 if (feed->type == DMX_TYPE_SEC) {
901 for (i = 0; i < demux->filternum; i++) {
902 if (demux->filter[i].state != DMX_STATE_READY)
904 if (demux->filter[i].type != DMX_TYPE_SEC)
906 if (demux->filter[i].filter.parent != &feed->feed.sec)
908 demux->filter[i].state = DMX_STATE_GO;
909 if (demux->dmx.frontend->source != DMX_MEMORY_FE)
910 StartHWFilter(&demux->filter[i]);
918 static int av7110_stop_feed(struct dvb_demux_feed *feed)
920 struct dvb_demux *demux = feed->demux;
921 struct av7110 *av7110 = (struct av7110 *) demux->priv;
923 DEB_EE(("av7110: %p\n",av7110));
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])
930 demux->pids[feed->pes_type] |= 0x8000;
931 demux->pesfilter[feed->pes_type] = NULL;
933 if (feed->ts_type & TS_DECODER &&
934 feed->pes_type < DMX_TS_PES_OTHER) {
935 dvb_feed_stop_pid(feed);
937 if ((feed->ts_type & TS_PACKET) &&
938 (demux->dmx.frontend->source != DMX_MEMORY_FE))
939 StopHWFilter(feed->filter);
942 if (feed->type == DMX_TYPE_SEC) {
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]);
958 static void restart_feeds(struct av7110 *av7110)
960 struct dvb_demux *dvbdmx = &av7110->demux;
961 struct dvb_demux_feed *feed;
965 DEB_EE(("av7110: %p\n",av7110));
967 mode = av7110->playing;
969 av7110->rec_mode = 0;
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);
978 av7110_av_start_play(av7110, mode);
981 static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
982 uint64_t *stc, unsigned int *base)
986 u16 tag = ((COMTYPE_REQUEST << 8) + ReqSTC);
987 struct dvb_demux *dvbdemux;
988 struct av7110 *av7110;
990 /* pointer casting paranoia... */
993 dvbdemux = (struct dvb_demux *) demux->priv;
996 av7110 = (struct av7110 *) dvbdemux->priv;
998 DEB_EE(("av7110: %p\n",av7110));
1003 ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4);
1005 printk(KERN_ERR "%s: av7110_fw_request error\n", __FUNCTION__);
1008 DEB_EE(("av7110: fwstc = %04hx %04hx %04hx %04hx\n",
1009 fwstc[0], fwstc[1], fwstc[2], fwstc[3]));
1011 *stc = (((uint64_t) ((fwstc[3] & 0x8000) >> 15)) << 32) |
1012 (((uint64_t) fwstc[1]) << 16) | ((uint64_t) fwstc[0]);
1015 DEB_EE(("av7110: stc = %lu\n", (unsigned long)*stc));
1021 /******************************************************************************
1022 * SEC device file operations
1023 ******************************************************************************/
1025 static int av7110_diseqc_ioctl(struct dvb_frontend *fe, unsigned int cmd, void *arg)
1027 struct av7110 *av7110 = fe->before_after_data;
1029 DEB_EE(("av7110: %p\n", av7110));
1033 switch ((fe_sec_tone_mode_t) arg) {
1045 case FE_DISEQC_SEND_MASTER_CMD:
1047 struct dvb_diseqc_master_cmd *cmd = arg;
1048 av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1);
1052 case FE_DISEQC_SEND_BURST:
1053 av7110_diseqc_send(av7110, 0, NULL, (unsigned long) arg);
1064 static void av7110_before_after_tune (fe_status_t s, void *data)
1066 struct av7110 *av7110 = data;
1068 DEB_EE(("av7110: %p\n",av7110));
1070 av7110->fe_synced = (s & FE_HAS_LOCK) ? 1 : 0;
1072 if (av7110->playing)
1075 if (down_interruptible(&av7110->pid_mutex))
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);
1085 SetPIDs(av7110, 0, 0, 0, 0, 0);
1086 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, FlushTSQueue, 0);
1089 up(&av7110->pid_mutex);
1093 static int av7110_register(struct av7110 *av7110)
1096 struct dvb_demux *dvbdemux=&av7110->demux;
1098 DEB_EE(("av7110: %p\n",av7110));
1100 if (av7110->registered)
1103 av7110->registered=1;
1105 dvb_add_frontend_notifier (av7110->dvb_adapter,
1106 av7110_before_after_tune, av7110);
1111 dvb_add_frontend_ioctls (av7110->dvb_adapter,
1112 av7110_diseqc_ioctl, NULL, av7110);
1114 dvbdemux->priv = (void *) av7110;
1116 for (i=0; i<32; i++)
1117 av7110->handle2filter[i]=NULL;
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);
1127 dvb_dmx_init(&av7110->demux);
1128 av7110->demux.dmx.get_stc = dvb_get_stc;
1130 av7110->dmxdev.filternum = 32;
1131 av7110->dmxdev.demux = &dvbdemux->dmx;
1132 av7110->dmxdev.capabilities = 0;
1134 dvb_dmxdev_init(&av7110->dmxdev, av7110->dvb_adapter);
1136 av7110->hw_frontend.source = DMX_FRONTEND_0;
1138 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1143 av7110->mem_frontend.source = DMX_MEMORY_FE;
1145 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1150 ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1151 &av7110->hw_frontend);
1155 av7110_av_register(av7110);
1156 av7110_ca_register(av7110);
1158 #ifdef CONFIG_DVB_AV7110_OSD
1159 dvb_register_device(av7110->dvb_adapter, &av7110->osd_dev,
1160 &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1163 dvb_net_init(av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1169 static void dvb_unregister(struct av7110 *av7110)
1171 struct dvb_demux *dvbdemux=&av7110->demux;
1173 DEB_EE(("av7110: %p\n",av7110));
1175 if (!av7110->registered)
1178 dvb_net_release(&av7110->dvb_net);
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);
1184 dvb_dmxdev_release(&av7110->dmxdev);
1185 dvb_dmx_release(&av7110->demux);
1187 dvb_remove_frontend_notifier (av7110->dvb_adapter,
1188 av7110_before_after_tune);
1190 dvb_remove_frontend_ioctls (av7110->dvb_adapter,
1191 av7110_diseqc_ioctl, NULL);
1193 dvb_unregister_device(av7110->osd_dev);
1194 av7110_av_unregister(av7110);
1195 av7110_ca_unregister(av7110);
1199 /****************************************************************************
1200 * I2C client commands
1201 ****************************************************************************/
1203 int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1205 u8 msg[2] = { reg, val };
1206 struct dvb_i2c_bus *i2c = av7110->i2c_bus;
1207 struct i2c_msg msgs;
1213 return i2c->xfer(i2c, &msgs, 1);
1216 u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1218 struct dvb_i2c_bus *i2c = av7110->i2c_bus;
1221 struct i2c_msg msgs[2];
1224 msgs[1].flags = I2C_M_RD;
1225 msgs[0].addr = msgs[1].addr = id / 2;
1227 msgs[0].len = 1; msgs[1].len = 1;
1228 msgs[0].buf = mm1; msgs[1].buf = mm2;
1229 i2c->xfer(i2c, msgs, 2);
1234 static int master_xfer(struct dvb_i2c_bus *i2c, const struct i2c_msg msgs[], int num)
1236 struct saa7146_dev *dev = i2c->data;
1237 return saa7146_i2c_transfer(dev, msgs, num, 6);
1240 /****************************************************************************
1242 ****************************************************************************/
1245 static int check_firmware(struct av7110* av7110)
1247 u32 crc = 0, len = 0;
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");
1259 /* check dpram file */
1260 crc = ntohl(*(u32*)ptr);
1262 len = ntohl(*(u32*)ptr);
1265 printk("dvb-ttpci: dpram file is way to big.\n");
1268 if( crc != crc32_le(0,ptr,len)) {
1269 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1272 av7110->bin_dpram = ptr;
1273 av7110->size_dpram = len;
1276 /* check root file */
1277 crc = ntohl(*(u32*)ptr);
1279 len = ntohl(*(u32*)ptr);
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);
1287 if( crc != crc32_le(0,ptr,len)) {
1288 printk("dvb-ttpci: crc32 of root file does not match.\n");
1291 av7110->bin_root = ptr;
1292 av7110->size_root = len;
1296 #ifdef CONFIG_DVB_AV7110_FIRMWARE_FILE
1297 #include "av7110_firm.h"
1298 static inline int get_firmware(struct av7110* av7110)
1300 av7110->bin_fw = dvb_ttpci_fw;
1301 av7110->size_fw = sizeof(dvb_ttpci_fw);
1302 return check_firmware(av7110);
1305 static int get_firmware(struct av7110* av7110)
1308 const struct firmware *fw;
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);
1313 printk("dvb-ttpci: cannot request firmware!\n");
1316 if (fw->size <= 200000) {
1317 printk("dvb-ttpci: this firmware is way too small.\n");
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"));
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);
1334 static int av7110_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_data *pci_ext)
1336 struct av7110 *av7110 = NULL;
1339 DEB_EE(("dev: %p\n", dev));
1341 /* prepare the av7110 device struct */
1342 if (!(av7110 = kmalloc (sizeof (struct av7110), GFP_KERNEL))) {
1343 printk ("%s: out of memory!\n", __FUNCTION__);
1346 DEB_EE(("av7110: %p\n", av7110));
1347 memset(av7110, 0, sizeof(struct av7110));
1349 av7110->card_name = (char*)pci_ext->ext_priv;
1350 av7110->dev=(struct saa7146_dev *)dev;
1351 dev->ext_priv = av7110;
1353 if ((ret = get_firmware(av7110))) {
1358 dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name, THIS_MODULE);
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);
1364 saa7146_i2c_adapter_prepare(dev, NULL, 0, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
1366 av7110->i2c_bus = dvb_register_i2c_bus (master_xfer, dev,
1367 av7110->dvb_adapter, 0);
1369 if (!av7110->i2c_bus) {
1370 dvb_unregister_adapter (av7110->dvb_adapter);
1375 ttpci_eeprom_parse_mac(av7110->i2c_bus);
1377 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
1378 saa7146_write(dev, BCS_CTRL, 0x80400040);
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));
1386 saa7146_write(dev, MC2, 0x077c077c);
1387 saa7146_write(dev, GPIO_CTRL, 0x000000);
1389 tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
1390 tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
1392 sema_init(&av7110->pid_mutex, 1);
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;
1400 /* default OSD window */
1403 /* ARM "watchdog" */
1404 init_waitqueue_head(&av7110->arm_wait);
1405 av7110->arm_thread=NULL;
1407 /* allocate and init buffers */
1408 av7110->debi_virt = pci_alloc_consistent(dev->pci, 8192,
1410 if (!av7110->debi_virt) {
1415 av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
1416 if (!av7110->iobuf) {
1421 av7110_av_init(av7110);
1423 /* init BMP buffer */
1424 av7110->bmpbuf=av7110->iobuf+AVOUTLEN+AOUTLEN;
1425 init_waitqueue_head(&av7110->bmpq);
1427 av7110_ca_init(av7110);
1429 /* load firmware into AV7110 cards */
1430 av7110_bootarm(av7110);
1431 if (av7110_firmversion(av7110)) {
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));
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);
1446 /* set internal volume control to maximum */
1447 av7110->adac_type = DVB_ADAC_TI;
1448 av7110_set_volume(av7110, 0xff, 0xff);
1450 av7710_set_video_mode(av7110, vidmode);
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);
1466 * some special handling for the Siemens DVB-C cards...
1468 } else if (0 == av7110_init_analog_module(av7110)) {
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;
1477 av7110->adac_type = adac;
1478 printk("av7110(%d): adac type set to %d\n",
1479 av7110->dvb_adapter->num, av7110->adac_type);
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);
1487 saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16
1488 //saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // SCARTpin 8
1491 av7110_set_volume(av7110, 0xff, 0xff);
1493 av7110_setup_irc_config (av7110, 0);
1494 av7110_register(av7110);
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);
1504 printk(KERN_INFO "av7110: found av7110-%d.\n",av7110_num);
1505 av7110->device_initialized = 1;
1510 av7110->arm_rmmod = 1;
1511 wake_up_interruptible(&av7110->arm_wait);
1512 while (av7110->arm_thread)
1515 av7110_ca_exit(av7110);
1516 av7110_av_exit(av7110);
1518 dvb_unregister_i2c_bus (master_xfer,av7110->i2c_bus->adapter,
1519 av7110->i2c_bus->id);
1521 dvb_unregister_adapter (av7110->dvb_adapter);
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 ) {
1534 static int av7110_detach (struct saa7146_dev* saa)
1536 struct av7110 *av7110 = (struct av7110*)saa->ext_priv;
1537 DEB_EE(("av7110: %p\n",av7110));
1539 if( 0 == av7110->device_initialized ) {
1543 av7110_exit_v4l(av7110);
1545 av7110->arm_rmmod=1;
1546 wake_up_interruptible(&av7110->arm_wait);
1548 while (av7110->arm_thread)
1551 dvb_unregister(av7110);
1553 IER_DISABLE(saa, (MASK_19 | MASK_03));
1554 // saa7146_write (av7110->dev, IER,
1555 // saa7146_read(av7110->dev, IER) & ~(MASK_19 | MASK_03));
1557 saa7146_write(av7110->dev, ISR,(MASK_19 | MASK_03));
1559 av7110_ca_exit(av7110);
1560 av7110_av_exit(av7110);
1562 vfree(av7110->iobuf);
1563 pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
1566 dvb_unregister_i2c_bus (master_xfer,av7110->i2c_bus->adapter, av7110->i2c_bus->id);
1567 dvb_unregister_adapter (av7110->dvb_adapter);
1570 #ifndef CONFIG_DVB_AV7110_FIRMWARE_FILE
1572 vfree(av7110->bin_fw);
1575 saa->ext_priv = NULL;
1581 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
1583 struct av7110 *av7110 = (struct av7110*)dev->ext_priv;
1585 // DEB_INT(("dev: %p, av7110: %p\n",dev,av7110));
1588 tasklet_schedule (&av7110->debi_tasklet);
1591 tasklet_schedule (&av7110->gpio_tasklet);
1595 static struct saa7146_extension av7110_extension;
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 }
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");
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),
1634 MODULE_DEVICE_TABLE(pci, pci_tbl);
1637 static struct saa7146_extension av7110_extension = {
1639 .flags = SAA7146_I2C_SHORT_DELAY,
1641 .module = THIS_MODULE,
1642 .pci_tbl = &pci_tbl[0],
1643 .attach = av7110_attach,
1644 .detach = av7110_detach,
1646 .irq_mask = MASK_19|MASK_03,
1647 .irq_func = av7110_irq,
1651 static int __init av7110_init(void)
1654 retval = saa7146_register_extension(&av7110_extension);
1655 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
1657 goto failed_saa7146_register;
1659 retval = av7110_ir_init();
1661 goto failed_av7110_ir_init;
1663 failed_av7110_ir_init:
1664 saa7146_unregister_extension(&av7110_extension);
1665 failed_saa7146_register:
1671 static void __exit av7110_exit(void)
1673 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
1676 saa7146_unregister_extension(&av7110_extension);
1679 module_init(av7110_init);
1680 module_exit(av7110_exit);
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");
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");