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/moduleparam.h>
45 #include <linux/sched.h>
46 #include <linux/types.h>
47 #include <linux/fcntl.h>
48 #include <linux/interrupt.h>
49 #include <linux/string.h>
50 #include <linux/pci.h>
51 #include <linux/vmalloc.h>
52 #include <linux/firmware.h>
53 #include <linux/crc32.h>
54 #include <linux/i2c.h>
56 #include <asm/system.h>
57 #include <asm/semaphore.h>
59 #include <linux/dvb/frontend.h>
61 #include "dvb_frontend.h"
63 #include "ttpci-eeprom.h"
65 #include "av7110_hw.h"
66 #include "av7110_av.h"
67 #include "av7110_ca.h"
68 #include "av7110_ipack.h"
72 static int vidmode=CVBS_RGB_OUT;
74 static int adac=DVB_ADAC_TI;
75 static int hw_sections;
77 static int volume = 255;
79 module_param_named(debug, av7110_debug, int, 0644);
80 MODULE_PARM_DESC(debug, "debug level (bitmask, default 0)");
81 module_param(vidmode, int, 0444);
82 MODULE_PARM_DESC(vidmode,"analog video out: 0 off, 1 CVBS+RGB (default), 2 CVBS+YC, 3 YC");
83 module_param(pids_off, int, 0444);
84 MODULE_PARM_DESC(pids_off,"clear video/audio/PCR PID filters when demux is closed");
85 module_param(adac, int, 0444);
86 MODULE_PARM_DESC(adac,"audio DAC type: 0 TI, 1 CRYSTAL, 2 MSP (use if autodetection fails)");
87 module_param(hw_sections, int, 0444);
88 MODULE_PARM_DESC(hw_sections, "0 use software section filter, 1 use hardware");
89 module_param(rgb_on, int, 0444);
90 MODULE_PARM_DESC(rgb_on, "For Siemens DVB-C cards only: Enable RGB control"
91 " signal on SCART pin 16 to switch SCART video mode from CVBS to RGB");
92 module_param(volume, int, 0444);
93 MODULE_PARM_DESC(volume, "initial volume: default 255 (range 0-255)");
95 static void restart_feeds(struct av7110 *av7110);
97 static int av7110_num = 0;
99 #define FE_FUNC_OVERRIDE(fe_func, av7110_copy, av7110_func) \
101 if (fe_func != NULL) { \
102 av7110_copy = fe_func; \
103 fe_func = av7110_func; \
108 static void init_av7110_av(struct av7110 *av7110)
110 struct saa7146_dev *dev=av7110->dev;
112 /* set internal volume control to maximum */
113 av7110->adac_type = DVB_ADAC_TI;
114 av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
116 av7710_set_video_mode(av7110, vidmode);
118 /* handle different card types */
119 /* remaining inits according to card and frontend type */
120 av7110->analog_tuner_flags = 0;
121 av7110->current_input = 0;
122 if (i2c_writereg(av7110, 0x20, 0x00, 0x00) == 1) {
123 printk ("dvb-ttpci: Crystal audio DAC @ card %d detected\n",
124 av7110->dvb_adapter->num);
125 av7110->adac_type = DVB_ADAC_CRYSTAL;
126 i2c_writereg(av7110, 0x20, 0x01, 0xd2);
127 i2c_writereg(av7110, 0x20, 0x02, 0x49);
128 i2c_writereg(av7110, 0x20, 0x03, 0x00);
129 i2c_writereg(av7110, 0x20, 0x04, 0x00);
132 * some special handling for the Siemens DVB-C cards...
134 } else if (0 == av7110_init_analog_module(av7110)) {
137 else if (dev->pci->subsystem_vendor == 0x110a) {
138 printk("dvb-ttpci: DVB-C w/o analog module @ card %d detected\n",
139 av7110->dvb_adapter->num);
140 av7110->adac_type = DVB_ADAC_NONE;
143 av7110->adac_type = adac;
144 printk("dvb-ttpci: adac type set to %d @ card %d\n",
145 av7110->dvb_adapter->num, av7110->adac_type);
148 if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP) {
149 // switch DVB SCART on
150 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0);
151 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1);
153 (av7110->dev->pci->subsystem_vendor == 0x110a) && (av7110->dev->pci->subsystem_device == 0x0000)) {
154 saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16
155 //saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // SCARTpin 8
159 av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
160 av7110_setup_irc_config(av7110, 0);
163 static void recover_arm(struct av7110 *av7110)
165 dprintk(4, "%p\n",av7110);
167 av7110_bootarm(av7110);
169 restart_feeds(av7110);
170 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, av7110->ir_config);
173 static void arm_error(struct av7110 *av7110)
175 dprintk(4, "%p\n",av7110);
177 av7110->arm_errors++;
182 static int arm_thread(void *data)
184 struct av7110 *av7110 = data;
188 dprintk(4, "%p\n",av7110);
191 daemonize ("arm_mon");
192 sigfillset (¤t->blocked);
195 av7110->arm_thread = current;
198 timeout = wait_event_interruptible_timeout(av7110->arm_wait,
199 av7110->arm_rmmod, 5 * HZ);
200 if (-ERESTARTSYS == timeout || av7110->arm_rmmod) {
201 /* got signal or told to quit*/
205 if (!av7110->arm_ready)
208 if (down_interruptible(&av7110->dcomlock))
211 newloops=rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
212 up(&av7110->dcomlock);
214 if (newloops==av7110->arm_loops) {
215 printk(KERN_ERR "dvb-ttpci: ARM crashed @ card %d\n",
216 av7110->dvb_adapter->num);
219 av7710_set_video_mode(av7110, vidmode);
221 init_av7110_av(av7110);
223 if (down_interruptible(&av7110->dcomlock))
226 newloops=rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2)-1;
227 up(&av7110->dcomlock);
229 av7110->arm_loops=newloops;
232 av7110->arm_thread = NULL;
238 * Hack! we save the last av7110 ptr. This should be ok, since
239 * you rarely will use more then one IR control.
241 * If we want to support multiple controls we would have to do much more...
243 void av7110_setup_irc_config (struct av7110 *av7110, u32 ir_config)
245 static struct av7110 *last;
247 dprintk(4, "%p\n",av7110);
255 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
256 av7110->ir_config = ir_config;
260 static void (*irc_handler)(u32);
262 void av7110_register_irc_handler(void (*func)(u32))
264 dprintk(4, "registering %p\n", func);
268 void av7110_unregister_irc_handler(void (*func)(u32))
270 dprintk(4, "unregistering %p\n", func);
274 static void run_handlers(unsigned long ircom)
276 if (irc_handler != NULL)
277 (*irc_handler)((u32) ircom);
280 static DECLARE_TASKLET(irtask, run_handlers, 0);
282 static void IR_handle(struct av7110 *av7110, u32 ircom)
284 dprintk(4, "ircommand = %08x\n", ircom);
285 irtask.data = (unsigned long) ircom;
286 tasklet_schedule(&irtask);
289 /****************************************************************************
291 ****************************************************************************/
293 static int DvbDmxFilterCallback(u8 *buffer1, size_t buffer1_len,
294 u8 * buffer2, size_t buffer2_len,
295 struct dvb_demux_filter *dvbdmxfilter,
296 enum dmx_success success,
297 struct av7110 *av7110)
299 if (!dvbdmxfilter->feed->demux->dmx.frontend)
301 if (dvbdmxfilter->feed->demux->dmx.frontend->source==DMX_MEMORY_FE)
304 switch(dvbdmxfilter->type) {
306 if ((((buffer1[1]<<8)|buffer1[2])&0xfff)+3!=buffer1_len)
308 if (dvbdmxfilter->doneq) {
309 struct dmx_section_filter *filter=&dvbdmxfilter->filter;
313 for (i=0; i<DVB_DEMUX_MASK_MAX; i++) {
314 xor=filter->filter_value[i]^buffer1[i];
315 neq|=dvbdmxfilter->maskandnotmode[i]&xor;
320 return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len,
321 buffer2, buffer2_len,
322 &dvbdmxfilter->filter,
325 if (!(dvbdmxfilter->feed->ts_type & TS_PACKET))
327 if (dvbdmxfilter->feed->ts_type & TS_PAYLOAD_ONLY)
328 return dvbdmxfilter->feed->cb.ts(buffer1, buffer1_len,
329 buffer2, buffer2_len,
330 &dvbdmxfilter->feed->feed.ts,
333 av7110_p2t_write(buffer1, buffer1_len,
334 dvbdmxfilter->feed->pid,
335 &av7110->p2t_filter[dvbdmxfilter->index]);
342 //#define DEBUG_TIMING
343 static inline void print_time(char *s)
347 do_gettimeofday(&tv);
348 printk("%s: %d.%d\n", s, (int)tv.tv_sec, (int)tv.tv_usec);
352 static void debiirq (unsigned long data)
354 struct av7110 *av7110 = (struct av7110*) data;
355 int type=av7110->debitype;
356 int handle=(type>>8)&0x1f;
358 // dprintk(4, "%p\n",av7110);
361 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
362 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
365 printk("DEBI irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
366 jiffies, saa7146_read(av7110->dev, PSR),
367 saa7146_read(av7110->dev, SSR));
368 spin_lock(&av7110->debilock);
369 ARM_ClearMailBox(av7110);
370 ARM_ClearIrq(av7110);
371 spin_unlock(&av7110->debilock);
379 dvb_dmx_swfilter_packets(&av7110->demux,
380 (const u8 *)av7110->debi_virt,
381 av7110->debilen/188);
382 spin_lock(&av7110->debilock);
383 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
384 ARM_ClearMailBox(av7110);
385 spin_unlock(&av7110->debilock);
388 case DATA_PES_RECORD:
389 if (av7110->demux.recording)
390 av7110_record_cb(&av7110->p2t[handle],
391 (u8 *)av7110->debi_virt,
393 spin_lock(&av7110->debilock);
394 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
395 ARM_ClearMailBox(av7110);
396 spin_unlock(&av7110->debilock);
402 if (av7110->handle2filter[handle])
403 DvbDmxFilterCallback((u8 *)av7110->debi_virt,
404 av7110->debilen, NULL, 0,
405 av7110->handle2filter[handle],
407 spin_lock(&av7110->debilock);
408 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
409 ARM_ClearMailBox(av7110);
410 spin_unlock(&av7110->debilock);
415 u8 *data=av7110->debi_virt;
417 if ((data[0]<2) && data[2]==0xff) {
420 flags|=CA_CI_MODULE_PRESENT;
422 flags|=CA_CI_MODULE_READY;
423 av7110->ci_slot[data[0]].flags=flags;
425 ci_get_data(&av7110->ci_rbuffer,
428 spin_lock(&av7110->debilock);
429 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
430 ARM_ClearMailBox(av7110);
431 spin_unlock(&av7110->debilock);
435 case DATA_COMMON_INTERFACE:
436 CI_handle(av7110, (u8 *)av7110->debi_virt, av7110->debilen);
441 printk("av7110%d: ", av7110->num);
442 printk("%02x ", *(u8 *)av7110->debi_virt);
443 printk("%02x ", *(1+(u8 *)av7110->debi_virt));
444 for (i=2; i<av7110->debilen; i++)
445 printk("%02x ", (*(i+(unsigned char *)av7110->debi_virt)));
446 for (i=2; i<av7110->debilen; i++)
447 printk("%c", chtrans(*(i+(unsigned char *)av7110->debi_virt)));
452 spin_lock(&av7110->debilock);
453 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
454 ARM_ClearMailBox(av7110);
455 spin_unlock(&av7110->debilock);
458 case DATA_DEBUG_MESSAGE:
459 ((s8*)av7110->debi_virt)[Reserved_SIZE-1]=0;
460 printk("%s\n", (s8 *)av7110->debi_virt);
461 spin_lock(&av7110->debilock);
462 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
463 ARM_ClearMailBox(av7110);
464 spin_unlock(&av7110->debilock);
470 spin_lock(&av7110->debilock);
471 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
472 ARM_ClearMailBox(av7110);
473 spin_unlock(&av7110->debilock);
478 spin_lock(&av7110->debilock);
479 ARM_ClearMailBox(av7110);
480 spin_unlock(&av7110->debilock);
483 static void gpioirq (unsigned long data)
485 struct av7110 *av7110 = (struct av7110*) data;
489 if (av7110->debitype !=-1)
490 printk("dvb-ttpci: GPIO0 irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
491 jiffies, saa7146_read(av7110->dev, PSR),
492 saa7146_read(av7110->dev, SSR));
494 spin_lock(&av7110->debilock);
496 ARM_ClearIrq(av7110);
498 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
499 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
501 av7110->debitype = irdebi(av7110, DEBINOSWAP, IRQ_STATE, 0, 2);
502 av7110->debilen = irdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
503 rxbuf=irdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
504 txbuf=irdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
505 len = (av7110->debilen + 3) & ~3;
507 // dprintk(8, "GPIO0 irq %d %d\n", av7110->debitype, av7110->debilen);
510 // dprintk(8, "GPIO0 irq %02x\n", av7110->debitype&0xff);
511 switch (av7110->debitype&0xff) {
517 case DATA_MPEG_VIDEO_EVENT:
520 struct video_event event;
522 av7110->video_size.w = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_WIDTH, 0, 2);
523 h_ar = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_HEIGHT_AR, 0, 2);
525 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
526 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
528 av7110->video_size.h = h_ar & 0xfff;
529 dprintk(8, "GPIO0 irq: DATA_MPEG_VIDEO_EVENT: w/h/ar = %u/%u/%u\n",
530 av7110->video_size.w,
531 av7110->video_size.h,
532 av7110->video_size.aspect_ratio);
534 event.type = VIDEO_EVENT_SIZE_CHANGED;
535 event.u.size.w = av7110->video_size.w;
536 event.u.size.h = av7110->video_size.h;
537 switch ((h_ar >> 12) & 0xf)
540 av7110->video_size.aspect_ratio = VIDEO_FORMAT_16_9;
541 event.u.size.aspect_ratio = VIDEO_FORMAT_16_9;
542 av7110->videostate.video_format = VIDEO_FORMAT_16_9;
545 av7110->video_size.aspect_ratio = VIDEO_FORMAT_221_1;
546 event.u.size.aspect_ratio = VIDEO_FORMAT_221_1;
547 av7110->videostate.video_format = VIDEO_FORMAT_221_1;
550 av7110->video_size.aspect_ratio = VIDEO_FORMAT_4_3;
551 event.u.size.aspect_ratio = VIDEO_FORMAT_4_3;
552 av7110->videostate.video_format = VIDEO_FORMAT_4_3;
554 dvb_video_add_event(av7110, &event);
561 struct dvb_ringbuffer *cibuf=&av7110->ci_wbuffer;
563 avail=dvb_ringbuffer_avail(cibuf);
565 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
566 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
567 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
570 len= DVB_RINGBUFFER_PEEK(cibuf,0)<<8;
571 len|=DVB_RINGBUFFER_PEEK(cibuf,1);
573 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
574 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
575 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
578 DVB_RINGBUFFER_SKIP(cibuf,2);
580 dvb_ringbuffer_read(cibuf,av7110->debi_virt,len,0);
582 wake_up(&cibuf->queue);
583 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
584 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
585 saa7146_wait_for_debi_done(av7110->dev, 0);
586 saa7146_write(av7110->dev, IER,
587 saa7146_read(av7110->dev, IER) | MASK_19 );
589 len = 5; /* we want a real DEBI DMA */
590 iwdebi(av7110, DEBISWAB, DPRAM_BASE+txbuf, 0, (len+3)&~3);
591 spin_unlock(&av7110->debilock);
596 if (!av7110->playing) {
597 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
598 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
599 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
603 if (av7110->debitype&0x100) {
604 spin_lock(&av7110->aout.lock);
605 len=av7110_pes_play(av7110->debi_virt, &av7110->aout, 2048);
606 spin_unlock(&av7110->aout.lock);
608 if (len<=0 && (av7110->debitype&0x200)
609 &&av7110->videostate.play_state!=VIDEO_FREEZED) {
610 spin_lock(&av7110->avout.lock);
611 len=av7110_pes_play(av7110->debi_virt, &av7110->avout, 2048);
612 spin_unlock(&av7110->avout.lock);
615 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
616 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
617 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
620 dprintk(8, "GPIO0 PES_PLAY len=%04x\n", len);
621 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
622 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
623 saa7146_wait_for_debi_done(av7110->dev, 0);
624 saa7146_write(av7110->dev, IER,
625 saa7146_read(av7110->dev, IER) | MASK_19 );
627 iwdebi(av7110, DEBISWAB, DPRAM_BASE+txbuf, 0, (len+3)&~3);
628 spin_unlock(&av7110->debilock);
634 av7110->bmp_state=BMP_LOADED;
635 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
636 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
637 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
638 wake_up(&av7110->bmpq);
641 if (len>av7110->bmplen)
645 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
646 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
647 memcpy(av7110->debi_virt, av7110->bmpbuf+av7110->bmpp, len);
650 saa7146_wait_for_debi_done(av7110->dev, 0);
651 saa7146_write(av7110->dev, IER,
652 saa7146_read(av7110->dev, IER) | MASK_19 );
654 len = 5; /* we want a real DEBI DMA */
655 iwdebi(av7110, DEBISWAB, DPRAM_BASE+txbuf, 0, (len+3)&~3);
656 spin_unlock(&av7110->debilock);
660 case DATA_COMMON_INTERFACE:
664 if (!len || len>4*1024) {
665 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
671 case DATA_PES_RECORD:
672 saa7146_wait_for_debi_done(av7110->dev, 0);
673 saa7146_write(av7110->dev, IER,
674 saa7146_read(av7110->dev, IER) | MASK_19);
675 irdebi(av7110, DEBISWAB, DPRAM_BASE+rxbuf, 0, len);
676 spin_unlock(&av7110->debilock);
679 case DATA_DEBUG_MESSAGE:
680 saa7146_wait_for_debi_done(av7110->dev, 0);
681 if (!len || len>0xff) {
682 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
685 saa7146_write(av7110->dev, IER,
686 saa7146_read(av7110->dev, IER) | MASK_19);
687 irdebi(av7110, DEBISWAB, Reserved, 0, len);
688 spin_unlock(&av7110->debilock);
693 swahw32(irdebi(av7110, DEBINOSWAP, Reserved, 0, 4)));
694 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
698 printk("dvb-ttpci: gpioirq unknown type=%d len=%d\n",
699 av7110->debitype, av7110->debilen);
702 ARM_ClearMailBox(av7110);
704 spin_unlock(&av7110->debilock);
708 #ifdef CONFIG_DVB_AV7110_OSD
709 static int dvb_osd_ioctl(struct inode *inode, struct file *file,
710 unsigned int cmd, void *parg)
712 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
713 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
715 dprintk(4, "%p\n", av7110);
717 if (cmd == OSD_SEND_CMD)
718 return av7110_osd_cmd(av7110, (osd_cmd_t *) parg);
719 if (cmd == OSD_GET_CAPABILITY)
720 return av7110_osd_capability(av7110, (osd_cap_t *) parg);
726 static struct file_operations dvb_osd_fops = {
727 .owner = THIS_MODULE,
728 .ioctl = dvb_generic_ioctl,
729 .open = dvb_generic_open,
730 .release = dvb_generic_release,
733 static struct dvb_device dvbdev_osd = {
737 .fops = &dvb_osd_fops,
738 .kernel_ioctl = dvb_osd_ioctl,
740 #endif /* CONFIG_DVB_AV7110_OSD */
743 static inline int SetPIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
744 u16 subpid, u16 pcrpid)
746 dprintk(4, "%p\n", av7110);
748 if (vpid == 0x1fff || apid == 0x1fff ||
749 ttpid == 0x1fff || subpid == 0x1fff || pcrpid == 0x1fff) {
750 vpid = apid = ttpid = subpid = pcrpid = 0;
751 av7110->pids[DMX_PES_VIDEO] = 0;
752 av7110->pids[DMX_PES_AUDIO] = 0;
753 av7110->pids[DMX_PES_TELETEXT] = 0;
754 av7110->pids[DMX_PES_PCR] = 0;
757 return av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, MultiPID, 5,
758 pcrpid, vpid, apid, ttpid, subpid);
761 void ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
762 u16 subpid, u16 pcrpid)
764 dprintk(4, "%p\n", av7110);
766 if (down_interruptible(&av7110->pid_mutex))
769 if (!(vpid & 0x8000))
770 av7110->pids[DMX_PES_VIDEO] = vpid;
771 if (!(apid & 0x8000))
772 av7110->pids[DMX_PES_AUDIO] = apid;
773 if (!(ttpid & 0x8000))
774 av7110->pids[DMX_PES_TELETEXT] = ttpid;
775 if (!(pcrpid & 0x8000))
776 av7110->pids[DMX_PES_PCR] = pcrpid;
778 av7110->pids[DMX_PES_SUBTITLE] = 0;
780 if (av7110->fe_synced) {
781 pcrpid = av7110->pids[DMX_PES_PCR];
782 SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
785 up(&av7110->pid_mutex);
789 /******************************************************************************
790 * hardware filter functions
791 ******************************************************************************/
793 static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter)
795 struct dvb_demux_feed *dvbdmxfeed = dvbdmxfilter->feed;
796 struct av7110 *av7110 = (struct av7110 *) dvbdmxfeed->demux->priv;
803 dprintk(4, "%p\n", av7110);
805 if (dvbdmxfilter->type == DMX_TYPE_SEC) {
807 buf[4] = (dvbdmxfilter->filter.filter_value[0] << 8) |
808 dvbdmxfilter->maskandmode[0];
809 for (i = 3; i < 18; i++)
811 (dvbdmxfilter->filter.filter_value[i] << 8) |
812 dvbdmxfilter->maskandmode[i];
815 } else if ((dvbdmxfeed->ts_type & TS_PACKET) &&
816 !(dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)) {
817 av7110_p2t_init(&av7110->p2t_filter[dvbdmxfilter->index], dvbdmxfeed);
820 buf[0] = (COMTYPE_PID_FILTER << 8) + AddPIDFilter;
822 buf[2] = dvbdmxfeed->pid;
825 ret = av7110_fw_request(av7110, buf, 20, &handle, 1);
826 if (ret != 0 || handle >= 32) {
827 printk("dvb-ttpci: %s error buf %04x %04x %04x %04x "
828 "ret %x handle %04x\n",
829 __FUNCTION__, buf[0], buf[1], buf[2], buf[3],
831 dvbdmxfilter->hw_handle = 0xffff;
835 av7110->handle2filter[handle] = dvbdmxfilter;
836 dvbdmxfilter->hw_handle = handle;
841 static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
843 struct av7110 *av7110 = (struct av7110 *) dvbdmxfilter->feed->demux->priv;
849 dprintk(4, "%p\n", av7110);
851 handle = dvbdmxfilter->hw_handle;
853 printk("%s tried to stop invalid filter %04x, filter type = %x\n",
854 __FUNCTION__, handle, dvbdmxfilter->type);
858 av7110->handle2filter[handle] = NULL;
860 buf[0] = (COMTYPE_PID_FILTER << 8) + DelPIDFilter;
863 ret = av7110_fw_request(av7110, buf, 3, answ, 2);
864 if (ret != 0 || answ[1] != handle) {
865 printk("dvb-ttpci: %s error cmd %04x %04x %04x ret %x "
866 "resp %04x %04x pid %d\n",
867 __FUNCTION__, buf[0], buf[1], buf[2], ret,
868 answ[0], answ[1], dvbdmxfilter->feed->pid);
875 static void dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
877 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
878 struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
879 u16 *pid = dvbdmx->pids, npids[5];
882 dprintk(4, "%p\n", av7110);
884 npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
885 i = dvbdmxfeed->pes_type;
886 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
887 if ((i == 2) && npids[i] && (dvbdmxfeed->ts_type & TS_PACKET)) {
889 ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
890 StartHWFilter(dvbdmxfeed->filter);
893 if (dvbdmxfeed->pes_type <= 2 || dvbdmxfeed->pes_type == 4)
894 ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
896 if (dvbdmxfeed->pes_type < 2 && npids[0])
897 if (av7110->fe_synced)
898 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
900 if ((dvbdmxfeed->ts_type & TS_PACKET)) {
901 if (dvbdmxfeed->pes_type == 0 && !(dvbdmx->pids[0] & 0x8000))
902 av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed);
903 if (dvbdmxfeed->pes_type == 1 && !(dvbdmx->pids[1] & 0x8000))
904 av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed);
908 static void dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
910 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
911 struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
912 u16 *pid = dvbdmx->pids, npids[5];
915 dprintk(4, "%p\n", av7110);
917 if (dvbdmxfeed->pes_type <= 1) {
918 av7110_av_stop(av7110, dvbdmxfeed->pes_type ? RP_VIDEO : RP_AUDIO);
919 if (!av7110->rec_mode)
920 dvbdmx->recording = 0;
921 if (!av7110->playing)
924 npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
925 i = dvbdmxfeed->pes_type;
928 if (dvbdmxfeed->ts_type & TS_PACKET)
929 StopHWFilter(dvbdmxfeed->filter);
937 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
940 ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
943 static int av7110_start_feed(struct dvb_demux_feed *feed)
945 struct dvb_demux *demux = feed->demux;
946 struct av7110 *av7110 = demux->priv;
948 dprintk(4, "%p\n", av7110);
950 if (!demux->dmx.frontend)
953 if (feed->pid > 0x1fff)
956 if (feed->type == DMX_TYPE_TS) {
957 if ((feed->ts_type & TS_DECODER) &&
958 (feed->pes_type < DMX_TS_PES_OTHER)) {
959 switch (demux->dmx.frontend->source) {
961 if (feed->ts_type & TS_DECODER)
962 if (feed->pes_type < 2 &&
963 !(demux->pids[0] & 0x8000) &&
964 !(demux->pids[1] & 0x8000)) {
965 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
966 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
967 av7110_av_start_play(av7110,RP_AV);
972 dvb_feed_start_pid(feed);
975 } else if ((feed->ts_type & TS_PACKET) &&
976 (demux->dmx.frontend->source != DMX_MEMORY_FE)) {
977 StartHWFilter(feed->filter);
981 if (feed->type == DMX_TYPE_SEC) {
984 for (i = 0; i < demux->filternum; i++) {
985 if (demux->filter[i].state != DMX_STATE_READY)
987 if (demux->filter[i].type != DMX_TYPE_SEC)
989 if (demux->filter[i].filter.parent != &feed->feed.sec)
991 demux->filter[i].state = DMX_STATE_GO;
992 if (demux->dmx.frontend->source != DMX_MEMORY_FE)
993 StartHWFilter(&demux->filter[i]);
1001 static int av7110_stop_feed(struct dvb_demux_feed *feed)
1003 struct dvb_demux *demux = feed->demux;
1004 struct av7110 *av7110 = demux->priv;
1006 dprintk(4, "%p\n", av7110);
1008 if (feed->type == DMX_TYPE_TS) {
1009 if (feed->ts_type & TS_DECODER) {
1010 if (feed->pes_type >= DMX_TS_PES_OTHER ||
1011 !demux->pesfilter[feed->pes_type])
1013 demux->pids[feed->pes_type] |= 0x8000;
1014 demux->pesfilter[feed->pes_type] = NULL;
1016 if (feed->ts_type & TS_DECODER &&
1017 feed->pes_type < DMX_TS_PES_OTHER) {
1018 dvb_feed_stop_pid(feed);
1020 if ((feed->ts_type & TS_PACKET) &&
1021 (demux->dmx.frontend->source != DMX_MEMORY_FE))
1022 StopHWFilter(feed->filter);
1025 if (feed->type == DMX_TYPE_SEC) {
1028 for (i=0; i<demux->filternum; i++)
1029 if (demux->filter[i].state == DMX_STATE_GO &&
1030 demux->filter[i].filter.parent == &feed->feed.sec) {
1031 demux->filter[i].state = DMX_STATE_READY;
1032 if (demux->dmx.frontend->source != DMX_MEMORY_FE)
1033 StopHWFilter(&demux->filter[i]);
1041 static void restart_feeds(struct av7110 *av7110)
1043 struct dvb_demux *dvbdmx = &av7110->demux;
1044 struct dvb_demux_feed *feed;
1048 dprintk(4, "%p\n", av7110);
1050 mode = av7110->playing;
1051 av7110->playing = 0;
1052 av7110->rec_mode = 0;
1054 for (i = 0; i < dvbdmx->filternum; i++) {
1055 feed = &dvbdmx->feed[i];
1056 if (feed->state == DMX_STATE_GO)
1057 av7110_start_feed(feed);
1061 av7110_av_start_play(av7110, mode);
1064 static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
1065 uint64_t *stc, unsigned int *base)
1069 u16 tag = ((COMTYPE_REQUEST << 8) + ReqSTC);
1070 struct dvb_demux *dvbdemux;
1071 struct av7110 *av7110;
1073 /* pointer casting paranoia... */
1076 dvbdemux = (struct dvb_demux *) demux->priv;
1079 av7110 = (struct av7110 *) dvbdemux->priv;
1081 dprintk(4, "%p\n", av7110);
1086 ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4);
1088 printk(KERN_ERR "%s: av7110_fw_request error\n", __FUNCTION__);
1091 dprintk(2, "fwstc = %04hx %04hx %04hx %04hx\n",
1092 fwstc[0], fwstc[1], fwstc[2], fwstc[3]);
1094 *stc = (((uint64_t) ((fwstc[3] & 0x8000) >> 15)) << 32) |
1095 (((uint64_t) fwstc[1]) << 16) | ((uint64_t) fwstc[0]);
1098 dprintk(4, "stc = %lu\n", (unsigned long)*stc);
1104 /******************************************************************************
1105 * SEC device file operations
1106 ******************************************************************************/
1109 static int av7110_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
1111 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1128 static int av7110_diseqc_send_master_cmd(struct dvb_frontend* fe,
1129 struct dvb_diseqc_master_cmd* cmd)
1131 struct av7110* av7110 = fe->dvb->priv;
1133 av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1);
1138 static int av7110_diseqc_send_burst(struct dvb_frontend* fe,
1139 fe_sec_mini_cmd_t minicmd)
1141 struct av7110* av7110 = fe->dvb->priv;
1143 av7110_diseqc_send(av7110, 0, NULL, minicmd);
1149 static int av7110_register(struct av7110 *av7110)
1152 struct dvb_demux *dvbdemux=&av7110->demux;
1154 dprintk(4, "%p\n", av7110);
1156 if (av7110->registered)
1159 av7110->registered=1;
1161 dvbdemux->priv = (void *) av7110;
1163 for (i=0; i<32; i++)
1164 av7110->handle2filter[i]=NULL;
1166 dvbdemux->filternum = 32;
1167 dvbdemux->feednum = 32;
1168 dvbdemux->start_feed = av7110_start_feed;
1169 dvbdemux->stop_feed = av7110_stop_feed;
1170 dvbdemux->write_to_decoder = av7110_write_to_decoder;
1171 dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1172 DMX_MEMORY_BASED_FILTERING);
1174 dvb_dmx_init(&av7110->demux);
1175 av7110->demux.dmx.get_stc = dvb_get_stc;
1177 av7110->dmxdev.filternum = 32;
1178 av7110->dmxdev.demux = &dvbdemux->dmx;
1179 av7110->dmxdev.capabilities = 0;
1181 dvb_dmxdev_init(&av7110->dmxdev, av7110->dvb_adapter);
1183 av7110->hw_frontend.source = DMX_FRONTEND_0;
1185 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1190 av7110->mem_frontend.source = DMX_MEMORY_FE;
1192 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1197 ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1198 &av7110->hw_frontend);
1202 av7110_av_register(av7110);
1203 av7110_ca_register(av7110);
1205 #ifdef CONFIG_DVB_AV7110_OSD
1206 dvb_register_device(av7110->dvb_adapter, &av7110->osd_dev,
1207 &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1210 dvb_net_init(av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1216 static void dvb_unregister(struct av7110 *av7110)
1218 struct dvb_demux *dvbdemux=&av7110->demux;
1220 dprintk(4, "%p\n", av7110);
1222 if (!av7110->registered)
1225 dvb_net_release(&av7110->dvb_net);
1227 dvbdemux->dmx.close(&dvbdemux->dmx);
1228 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1229 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1231 dvb_dmxdev_release(&av7110->dmxdev);
1232 dvb_dmx_release(&av7110->demux);
1234 if (av7110->fe != NULL)
1235 dvb_unregister_frontend(av7110->fe);
1236 dvb_unregister_device(av7110->osd_dev);
1237 av7110_av_unregister(av7110);
1238 av7110_ca_unregister(av7110);
1242 /****************************************************************************
1243 * I2C client commands
1244 ****************************************************************************/
1246 int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1248 u8 msg[2] = { reg, val };
1249 struct i2c_msg msgs;
1255 return i2c_transfer(&av7110->i2c_adap, &msgs, 1);
1259 u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1263 struct i2c_msg msgs[2];
1266 msgs[1].flags = I2C_M_RD;
1267 msgs[0].addr = msgs[1].addr = id / 2;
1269 msgs[0].len = 1; msgs[1].len = 1;
1270 msgs[0].buf = mm1; msgs[1].buf = mm2;
1271 i2c_transfer(&av7110->i2c_adap, msgs, 2);
1277 /****************************************************************************
1279 ****************************************************************************/
1282 static int check_firmware(struct av7110* av7110)
1284 u32 crc = 0, len = 0;
1287 /* check for firmware magic */
1288 ptr = av7110->bin_fw;
1289 if (ptr[0] != 'A' || ptr[1] != 'V' ||
1290 ptr[2] != 'F' || ptr[3] != 'W') {
1291 printk("dvb-ttpci: this is not an av7110 firmware\n");
1296 /* check dpram file */
1297 crc = ntohl(*(u32*)ptr);
1299 len = ntohl(*(u32*)ptr);
1302 printk("dvb-ttpci: dpram file is way to big.\n");
1305 if( crc != crc32_le(0,ptr,len)) {
1306 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1309 av7110->bin_dpram = ptr;
1310 av7110->size_dpram = len;
1313 /* check root file */
1314 crc = ntohl(*(u32*)ptr);
1316 len = ntohl(*(u32*)ptr);
1319 if (len <= 200000 || len >= 300000 ||
1320 len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1321 printk("dvb-ttpci: root file has strange size (%d). aborting.\n",len);
1324 if( crc != crc32_le(0,ptr,len)) {
1325 printk("dvb-ttpci: crc32 of root file does not match.\n");
1328 av7110->bin_root = ptr;
1329 av7110->size_root = len;
1333 #ifdef CONFIG_DVB_AV7110_FIRMWARE_FILE
1334 #include "av7110_firm.h"
1335 static inline int get_firmware(struct av7110* av7110)
1337 av7110->bin_fw = dvb_ttpci_fw;
1338 av7110->size_fw = sizeof(dvb_ttpci_fw);
1339 return check_firmware(av7110);
1342 static int get_firmware(struct av7110* av7110)
1345 const struct firmware *fw;
1347 /* request the av7110 firmware, this will block until someone uploads it */
1348 ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev);
1350 if (ret == -ENOENT) {
1351 printk(KERN_ERR "dvb-ttpci: could not load firmware,"
1352 " file not found: dvb-ttpci-01.fw\n");
1353 printk(KERN_ERR "dvb-ttpci: usually this should be in"
1354 " /usr/lib/hotplug/firmware\n");
1355 printk(KERN_ERR "dvb-ttpci: and can be downloaded here"
1356 " http://www.linuxtv.org/download/dvb/firmware/\n");
1358 printk(KERN_ERR "dvb-ttpci: cannot request firmware"
1359 " (error %i)\n", ret);
1363 if (fw->size <= 200000) {
1364 printk("dvb-ttpci: this firmware is way too small.\n");
1365 release_firmware(fw);
1369 /* check if the firmware is available */
1370 av7110->bin_fw = (unsigned char*) vmalloc(fw->size);
1371 if (NULL == av7110->bin_fw) {
1372 dprintk(1, "out of memory\n");
1373 release_firmware(fw);
1377 memcpy(av7110->bin_fw, fw->data, fw->size);
1378 av7110->size_fw = fw->size;
1379 if ((ret = check_firmware(av7110)))
1380 vfree(av7110->bin_fw);
1382 release_firmware(fw);
1388 static int alps_bsrv2_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1390 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1393 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) };
1394 u32 div = (params->frequency + 479500) / 125;
1396 if (params->frequency > 2000000) pwr = 3;
1397 else if (params->frequency > 1800000) pwr = 2;
1398 else if (params->frequency > 1600000) pwr = 1;
1399 else if (params->frequency > 1200000) pwr = 0;
1400 else if (params->frequency >= 1100000) pwr = 1;
1403 buf[0] = (div >> 8) & 0x7f;
1404 buf[1] = div & 0xff;
1405 buf[2] = ((div & 0x18000) >> 10) | 0x95;
1406 buf[3] = (pwr << 6) | 0x30;
1408 // NOTE: since we're using a prescaler of 2, we set the
1409 // divisor frequency to 62.5kHz and divide by 125 above
1411 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1416 static struct ves1x93_config alps_bsrv2_config = {
1417 .demod_address = 0x08,
1420 .pll_set = alps_bsrv2_pll_set,
1424 static u8 alps_bsru6_inittab[] = {
1428 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1429 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */
1430 0x06, 0x40, /* DAC not used, set to high impendance mode */
1431 0x07, 0x00, /* DAC LSB */
1432 0x08, 0x40, /* DiSEqC off, LNB power on OP2/LOCK pin on */
1433 0x09, 0x00, /* FIFO */
1434 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1435 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */
1436 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */
1437 0x10, 0x3f, // AGC2 0x3d
1439 0x12, 0xb5, // Lock detect: -64 Carrier freq detect:on
1440 0x15, 0xc9, // lock detector threshold
1451 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0
1452 0x29, 0x1e, // 1/2 threshold
1453 0x2a, 0x14, // 2/3 threshold
1454 0x2b, 0x0f, // 3/4 threshold
1455 0x2c, 0x09, // 5/6 threshold
1456 0x2d, 0x05, // 7/8 threshold
1458 0x31, 0x1f, // test all FECs
1459 0x32, 0x19, // viterbi and synchro search
1460 0x33, 0xfc, // rs control
1461 0x34, 0x93, // error control
1466 static int alps_bsru6_set_symbol_rate(struct dvb_frontend* fe, u32 srate, u32 ratio)
1471 if (srate < 1500000) { aclk = 0xb7; bclk = 0x47; }
1472 else if (srate < 3000000) { aclk = 0xb7; bclk = 0x4b; }
1473 else if (srate < 7000000) { aclk = 0xb7; bclk = 0x4f; }
1474 else if (srate < 14000000) { aclk = 0xb7; bclk = 0x53; }
1475 else if (srate < 30000000) { aclk = 0xb6; bclk = 0x53; }
1476 else if (srate < 45000000) { aclk = 0xb4; bclk = 0x51; }
1478 stv0299_writereg (fe, 0x13, aclk);
1479 stv0299_writereg (fe, 0x14, bclk);
1480 stv0299_writereg (fe, 0x1f, (ratio >> 16) & 0xff);
1481 stv0299_writereg (fe, 0x20, (ratio >> 8) & 0xff);
1482 stv0299_writereg (fe, 0x21, (ratio ) & 0xf0);
1487 static int alps_bsru6_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1489 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1493 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1495 if ((params->frequency < 950000) || (params->frequency > 2150000))
1498 div = (params->frequency + (125 - 1)) / 125; // round correctly
1499 data[0] = (div >> 8) & 0x7f;
1500 data[1] = div & 0xff;
1501 data[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
1504 if (params->frequency > 1530000) data[3] = 0xc0;
1506 ret = i2c_transfer (&av7110->i2c_adap, &msg, 1);
1512 static struct stv0299_config alps_bsru6_config = {
1514 .demod_address = 0x68,
1515 .inittab = alps_bsru6_inittab,
1518 .enhanced_tuning = 0,
1520 .lock_output = STV0229_LOCKOUTPUT_1,
1521 .volt13_op0_op1 = STV0299_VOLT13_OP1,
1522 .min_delay_ms = 100,
1523 .set_symbol_rate = alps_bsru6_set_symbol_rate,
1524 .pll_set = alps_bsru6_pll_set,
1529 static int alps_tdbe2_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1531 struct av7110* av7110 = fe->dvb->priv;
1534 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1536 div = (params->frequency + 35937500 + 31250) / 62500;
1538 data[0] = (div >> 8) & 0x7f;
1539 data[1] = div & 0xff;
1540 data[2] = 0x85 | ((div >> 10) & 0x60);
1541 data[3] = (params->frequency < 174000000 ? 0x88 : params->frequency < 470000000 ? 0x84 : 0x81);
1543 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1548 static struct ves1820_config alps_tdbe2_config = {
1549 .demod_address = 0x09,
1552 .selagc = VES1820_SELAGC_SIGNAMPERR,
1553 .pll_set = alps_tdbe2_pll_set,
1559 static int grundig_29504_451_pll_set(struct dvb_frontend* fe,
1560 struct dvb_frontend_parameters* params)
1562 struct av7110* av7110 = fe->dvb->priv;
1565 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1567 div = params->frequency / 125;
1568 data[0] = (div >> 8) & 0x7f;
1569 data[1] = div & 0xff;
1573 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1578 static struct tda8083_config grundig_29504_451_config = {
1579 .demod_address = 0x68,
1580 .pll_set = grundig_29504_451_pll_set,
1585 static int philips_cd1516_pll_set(struct dvb_frontend* fe,
1586 struct dvb_frontend_parameters* params)
1588 struct av7110* av7110 = fe->dvb->priv;
1590 u32 f = params->frequency;
1592 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1594 div = (f + 36125000 + 31250) / 62500;
1596 data[0] = (div >> 8) & 0x7f;
1597 data[1] = div & 0xff;
1599 data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1601 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1606 static struct ves1820_config philips_cd1516_config = {
1607 .demod_address = 0x09,
1610 .selagc = VES1820_SELAGC_SIGNAMPERR,
1611 .pll_set = philips_cd1516_pll_set,
1616 static int alps_tdlb7_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1618 struct av7110* av7110 = fe->dvb->priv;
1621 struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1623 div = (params->frequency + 36200000) / 166666;
1625 if (params->frequency <= 782000000)
1630 data[0] = (div >> 8) & 0x7f;
1631 data[1] = div & 0xff;
1635 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1640 static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1642 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1644 return request_firmware(fw, name, &av7110->dev->pci->dev);
1647 static struct sp8870_config alps_tdlb7_config = {
1649 .demod_address = 0x71,
1650 .pll_set = alps_tdlb7_pll_set,
1651 .request_firmware = alps_tdlb7_request_firmware,
1656 static int nexusca_stv0297_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1658 struct av7110* av7110 = fe->dvb->priv;
1661 struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
1662 struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
1665 div = (params->frequency + 36150000 + 31250) / 62500;
1667 data[0] = (div >> 8) & 0x7f;
1668 data[1] = div & 0xff;
1671 if (params->frequency < 45000000)
1673 else if (params->frequency < 137000000)
1675 else if (params->frequency < 403000000)
1677 else if (params->frequency < 860000000)
1682 stv0297_enable_plli2c(fe);
1683 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) {
1684 printk("nexusca: pll transfer failed!\n");
1688 // wait for PLL lock
1689 for(i=0; i< 20; i++) {
1691 stv0297_enable_plli2c(fe);
1692 if (i2c_transfer (&av7110->i2c_adap, &readmsg, 1) == 1)
1693 if (data[0] & 0x40) break;
1700 static struct stv0297_config nexusca_stv0297_config = {
1702 .demod_address = 0x1C,
1703 .pll_set = nexusca_stv0297_pll_set,
1707 static void av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
1709 int synced = (status & FE_HAS_LOCK) ? 1 : 0;
1711 av7110->fe_status = status;
1713 if (av7110->fe_synced == synced)
1716 av7110->fe_synced = synced;
1718 if (av7110->playing)
1721 if (down_interruptible(&av7110->pid_mutex))
1724 if (av7110->fe_synced) {
1725 SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
1726 av7110->pids[DMX_PES_AUDIO],
1727 av7110->pids[DMX_PES_TELETEXT], 0,
1728 av7110->pids[DMX_PES_PCR]);
1729 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
1731 SetPIDs(av7110, 0, 0, 0, 0, 0);
1732 av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
1733 av7110_wait_msgstate(av7110, GPMQBusy);
1736 up(&av7110->pid_mutex);
1739 static int av7110_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1741 struct av7110* av7110 = fe->dvb->priv;
1742 av7110_fe_lock_fix(av7110, 0);
1743 return av7110->fe_set_frontend(fe, params);
1746 static int av7110_fe_init(struct dvb_frontend* fe)
1748 struct av7110* av7110 = fe->dvb->priv;
1750 av7110_fe_lock_fix(av7110, 0);
1751 return av7110->fe_init(fe);
1754 static int av7110_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
1756 struct av7110* av7110 = fe->dvb->priv;
1759 /* call the real implementation */
1760 ret = av7110->fe_read_status(fe, status);
1764 if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK)) {
1765 av7110_fe_lock_fix(av7110, *status);
1771 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
1773 struct av7110* av7110 = fe->dvb->priv;
1775 av7110_fe_lock_fix(av7110, 0);
1776 return av7110->fe_diseqc_reset_overload(fe);
1779 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
1780 struct dvb_diseqc_master_cmd* cmd)
1782 struct av7110* av7110 = fe->dvb->priv;
1784 av7110_fe_lock_fix(av7110, 0);
1785 return av7110->fe_diseqc_send_master_cmd(fe, cmd);
1788 static int av7110_fe_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t minicmd)
1790 struct av7110* av7110 = fe->dvb->priv;
1792 av7110_fe_lock_fix(av7110, 0);
1793 return av7110->fe_diseqc_send_burst(fe, minicmd);
1796 static int av7110_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
1798 struct av7110* av7110 = fe->dvb->priv;
1800 av7110_fe_lock_fix(av7110, 0);
1801 return av7110->fe_set_tone(fe, tone);
1804 static int av7110_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
1806 struct av7110* av7110 = fe->dvb->priv;
1808 av7110_fe_lock_fix(av7110, 0);
1809 return av7110->fe_set_voltage(fe, voltage);
1812 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned int cmd)
1814 struct av7110* av7110 = fe->dvb->priv;
1816 av7110_fe_lock_fix(av7110, 0);
1817 return av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
1820 static u8 read_pwm(struct av7110* av7110)
1824 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
1825 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
1827 if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
1833 static void frontend_init(struct av7110 *av7110)
1835 if (av7110->dev->pci->subsystem_vendor == 0x110a) {
1836 switch(av7110->dev->pci->subsystem_device) {
1837 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
1838 av7110->fe = ves1820_attach(&philips_cd1516_config,
1839 &av7110->i2c_adap, read_pwm(av7110));
1843 } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
1844 switch(av7110->dev->pci->subsystem_device) {
1845 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
1846 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
1847 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
1849 // try the ALPS BSRV2 first of all
1850 av7110->fe = ves1x93_attach(&alps_bsrv2_config, &av7110->i2c_adap);
1852 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
1853 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
1854 av7110->fe->ops->set_tone = av7110_set_tone;
1858 // try the ALPS BSRU6 now
1859 av7110->fe = stv0299_attach(&alps_bsru6_config, &av7110->i2c_adap);
1861 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
1862 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
1863 av7110->fe->ops->set_tone = av7110_set_tone;
1867 // Try the grundig 29504-451
1868 av7110->fe = tda8083_attach(&grundig_29504_451_config, &av7110->i2c_adap);
1870 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
1871 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
1872 av7110->fe->ops->set_tone = av7110_set_tone;
1876 /* Try DVB-C cards */
1877 switch(av7110->dev->pci->subsystem_device) {
1879 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
1880 av7110->fe = ves1820_attach(&philips_cd1516_config, &av7110->i2c_adap,
1884 /* Haupauge DVB-C 2.1 VES1820/ALPS TDBE2 */
1885 av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap,
1891 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
1894 av7110->fe = sp8870_attach(&alps_tdlb7_config, &av7110->i2c_adap);
1897 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
1899 av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
1902 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
1904 av7110->fe = stv0297_attach(&nexusca_stv0297_config, &av7110->i2c_adap, 0x7b);
1906 /* set TDA9819 into DVB mode */
1907 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTHI); // TDA9198 pin9(STD)
1908 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9198 pin30(VIF)
1910 /* tuner on this needs a slower i2c bus speed */
1911 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
1917 if (av7110->fe == NULL) {
1918 printk("dvb-ttpci: A frontend driver was not found for device %04x/%04x subsystem %04x/%04x\n",
1919 av7110->dev->pci->vendor,
1920 av7110->dev->pci->device,
1921 av7110->dev->pci->subsystem_vendor,
1922 av7110->dev->pci->subsystem_device);
1924 FE_FUNC_OVERRIDE(av7110->fe->ops->init, av7110->fe_init, av7110_fe_init);
1925 FE_FUNC_OVERRIDE(av7110->fe->ops->read_status, av7110->fe_read_status, av7110_fe_read_status);
1926 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
1927 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
1928 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
1929 FE_FUNC_OVERRIDE(av7110->fe->ops->set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
1930 FE_FUNC_OVERRIDE(av7110->fe->ops->set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage;)
1931 FE_FUNC_OVERRIDE(av7110->fe->ops->dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
1932 FE_FUNC_OVERRIDE(av7110->fe->ops->set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
1934 if (dvb_register_frontend(av7110->dvb_adapter, av7110->fe)) {
1935 printk("av7110: Frontend registration failed!\n");
1936 if (av7110->fe->ops->release)
1937 av7110->fe->ops->release(av7110->fe);
1943 static int av7110_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_data *pci_ext)
1945 struct av7110 *av7110 = NULL;
1948 dprintk(4, "dev: %p\n", dev);
1950 /* prepare the av7110 device struct */
1951 if (!(av7110 = kmalloc (sizeof (struct av7110), GFP_KERNEL))) {
1952 dprintk(1, "out of memory\n");
1956 memset(av7110, 0, sizeof(struct av7110));
1958 av7110->card_name = (char*)pci_ext->ext_priv;
1960 dev->ext_priv = av7110;
1962 if ((ret = get_firmware(av7110))) {
1967 dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name, THIS_MODULE);
1969 /* the Siemens DVB needs this if you want to have the i2c chips
1970 get recognized before the main driver is fully loaded */
1971 saa7146_write(dev, GPIO_CTRL, 0x500000);
1973 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
1974 av7110->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL;
1976 av7110->i2c_adap.class = I2C_CLASS_TV_DIGITAL;
1978 strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
1980 saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
1982 if (i2c_add_adapter(&av7110->i2c_adap) < 0) {
1983 dvb_unregister_adapter (av7110->dvb_adapter);
1988 ttpci_eeprom_parse_mac(&av7110->i2c_adap, av7110->dvb_adapter->proposed_mac);
1990 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
1991 saa7146_write(dev, BCS_CTRL, 0x80400040);
1993 /* set dd1 stream a & b */
1994 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
1995 saa7146_write(dev, DD1_INIT, 0x03000000);
1996 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
1999 saa7146_write(dev, MC2, 0x077c077c);
2000 saa7146_write(dev, GPIO_CTRL, 0x000000);
2002 tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2003 tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2005 sema_init(&av7110->pid_mutex, 1);
2007 /* locks for data transfers from/to AV7110 */
2008 spin_lock_init (&av7110->debilock);
2009 sema_init(&av7110->dcomlock, 1);
2010 av7110->debitype=-1;
2012 /* default OSD window */
2014 sema_init(&av7110->osd_sema, 1);
2016 /* ARM "watchdog" */
2017 init_waitqueue_head(&av7110->arm_wait);
2018 av7110->arm_thread=NULL;
2020 /* allocate and init buffers */
2021 av7110->debi_virt = pci_alloc_consistent(dev->pci, 8192,
2023 if (!av7110->debi_virt) {
2028 av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2029 if (!av7110->iobuf) {
2034 av7110_av_init(av7110);
2036 /* init BMP buffer */
2037 av7110->bmpbuf=av7110->iobuf+AVOUTLEN+AOUTLEN;
2038 init_waitqueue_head(&av7110->bmpq);
2040 av7110_ca_init(av7110);
2042 /* load firmware into AV7110 cards */
2043 av7110_bootarm(av7110);
2044 if (av7110_firmversion(av7110)) {
2049 if (FW_VERSION(av7110->arm_app)<0x2501)
2050 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2051 "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2053 if (kernel_thread(arm_thread, (void *) av7110, 0) < 0) {
2054 printk("dvb-ttpci: failed to start arm_mon kernel thread @ card %d\n",
2055 av7110->dvb_adapter->num);
2059 /* set initial volume in mixer struct */
2060 av7110->mixer.volume_left = volume;
2061 av7110->mixer.volume_right = volume;
2063 init_av7110_av(av7110);
2065 av7110_register(av7110);
2067 /* special case DVB-C: these cards have an analog tuner
2068 plus need some special handling, so we have separate
2069 saa7146_ext_vv data for these... */
2070 ret = av7110_init_v4l(av7110);
2075 av7110->dvb_adapter->priv = av7110;
2076 frontend_init(av7110);
2078 printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2079 av7110->device_initialized = 1;
2084 av7110->arm_rmmod = 1;
2085 wake_up_interruptible(&av7110->arm_wait);
2086 while (av7110->arm_thread)
2089 av7110_ca_exit(av7110);
2090 av7110_av_exit(av7110);
2092 i2c_del_adapter(&av7110->i2c_adap);
2094 dvb_unregister_adapter (av7110->dvb_adapter);
2096 if (NULL != av7110->debi_virt)
2097 pci_free_consistent(dev->pci, 8192, av7110->debi_virt, av7110->debi_bus);
2098 if (NULL != av7110->iobuf)
2099 vfree(av7110->iobuf);
2100 if (NULL != av7110 ) {
2107 static int av7110_detach (struct saa7146_dev* saa)
2109 struct av7110 *av7110 = (struct av7110*)saa->ext_priv;
2110 dprintk(4, "%p\n", av7110);
2112 if( 0 == av7110->device_initialized ) {
2116 av7110_exit_v4l(av7110);
2118 av7110->arm_rmmod=1;
2119 wake_up_interruptible(&av7110->arm_wait);
2121 while (av7110->arm_thread)
2124 dvb_unregister(av7110);
2126 SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2127 SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2129 av7110_ca_exit(av7110);
2130 av7110_av_exit(av7110);
2132 vfree(av7110->iobuf);
2133 pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2136 i2c_del_adapter(&av7110->i2c_adap);
2138 dvb_unregister_adapter (av7110->dvb_adapter);
2141 #ifndef CONFIG_DVB_AV7110_FIRMWARE_FILE
2143 vfree(av7110->bin_fw);
2146 saa->ext_priv = NULL;
2152 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2154 struct av7110 *av7110 = dev->ext_priv;
2157 tasklet_schedule (&av7110->debi_tasklet);
2160 tasklet_schedule (&av7110->gpio_tasklet);
2164 static struct saa7146_extension av7110_extension;
2166 #define MAKE_AV7110_INFO(x_var,x_name) \
2167 static struct saa7146_pci_extension_data x_var = { \
2168 .ext_priv = x_name, \
2169 .ext = &av7110_extension }
2171 MAKE_AV7110_INFO(tts_1_X, "Technotrend/Hauppauge WinTV DVB-S rev1.X");
2172 MAKE_AV7110_INFO(ttt_1_X, "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2173 MAKE_AV7110_INFO(ttc_1_X, "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2174 MAKE_AV7110_INFO(ttc_2_X, "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2175 MAKE_AV7110_INFO(tts_2_X, "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2176 MAKE_AV7110_INFO(tts_1_3se, "Technotrend/Hauppauge WinTV Nexus-S rev1.3");
2177 MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C");
2179 static struct pci_device_id pci_tbl[] = {
2180 MAKE_EXTENSION_PCI(tts_1_X, 0x13c2, 0x0000),
2181 MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001),
2182 MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002),
2183 MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003),
2184 MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002),
2185 MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000),
2186 MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a),
2188 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0004), UNDEFINED CARD */ // Galaxis DVB PC-Sat-Carte
2189 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2190 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0006), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-S v????
2191 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0008), UNDEFINED CARD */ // TT/Hauppauge WinTV DVB-T v????
2192 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2199 MODULE_DEVICE_TABLE(pci, pci_tbl);
2202 static struct saa7146_extension av7110_extension = {
2204 .flags = SAA7146_I2C_SHORT_DELAY,
2206 .module = THIS_MODULE,
2207 .pci_tbl = &pci_tbl[0],
2208 .attach = av7110_attach,
2209 .detach = av7110_detach,
2211 .irq_mask = MASK_19|MASK_03,
2212 .irq_func = av7110_irq,
2216 static int __init av7110_init(void)
2219 retval = saa7146_register_extension(&av7110_extension);
2220 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2222 goto failed_saa7146_register;
2224 retval = av7110_ir_init();
2226 goto failed_av7110_ir_init;
2228 failed_av7110_ir_init:
2229 saa7146_unregister_extension(&av7110_extension);
2230 failed_saa7146_register:
2236 static void __exit av7110_exit(void)
2238 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2241 saa7146_unregister_extension(&av7110_extension);
2244 module_init(av7110_init);
2245 module_exit(av7110_exit);
2247 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2248 "Siemens, Technotrend, Hauppauge");
2249 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2250 MODULE_LICENSE("GPL");