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/
33 #include <linux/module.h>
34 #include <linux/kmod.h>
35 #include <linux/delay.h>
37 #include <linux/timer.h>
38 #include <linux/poll.h>
40 #include <linux/kernel.h>
41 #include <linux/sched.h>
42 #include <linux/types.h>
43 #include <linux/fcntl.h>
44 #include <linux/interrupt.h>
45 #include <linux/string.h>
46 #include <linux/pci.h>
47 #include <linux/vmalloc.h>
48 #include <linux/firmware.h>
49 #include <linux/crc32.h>
50 #include <linux/i2c.h>
51 #include <linux/kthread.h>
52 #include <linux/slab.h>
53 #include <asm/unaligned.h>
54 #include <asm/byteorder.h>
57 #include <linux/dvb/frontend.h>
59 #include "dvb_frontend.h"
61 #include "ttpci-eeprom.h"
63 #include "av7110_hw.h"
64 #include "av7110_av.h"
65 #include "av7110_ca.h"
66 #include "av7110_ipack.h"
74 #define TS_BUFLEN (TS_WIDTH*TS_HEIGHT)
75 #define TS_MAX_PACKETS (TS_BUFLEN/TS_SIZE)
80 static int vidmode = CVBS_RGB_OUT;
82 static int adac = DVB_ADAC_TI;
83 static int hw_sections;
85 static int volume = 255;
86 static int budgetpatch;
87 static int wss_cfg_4_3 = 0x4008;
88 static int wss_cfg_16_9 = 0x0007;
89 static int tv_standard;
92 module_param_named(debug, av7110_debug, int, 0644);
93 MODULE_PARM_DESC(debug, "debug level (bitmask, default 0)");
94 module_param(vidmode, int, 0444);
95 MODULE_PARM_DESC(vidmode,"analog video out: 0 off, 1 CVBS+RGB (default), 2 CVBS+YC, 3 YC");
96 module_param(pids_off, int, 0444);
97 MODULE_PARM_DESC(pids_off,"clear video/audio/PCR PID filters when demux is closed");
98 module_param(adac, int, 0444);
99 MODULE_PARM_DESC(adac,"audio DAC type: 0 TI, 1 CRYSTAL, 2 MSP (use if autodetection fails)");
100 module_param(hw_sections, int, 0444);
101 MODULE_PARM_DESC(hw_sections, "0 use software section filter, 1 use hardware");
102 module_param(rgb_on, int, 0444);
103 MODULE_PARM_DESC(rgb_on, "For Siemens DVB-C cards only: Enable RGB control"
104 " signal on SCART pin 16 to switch SCART video mode from CVBS to RGB");
105 module_param(volume, int, 0444);
106 MODULE_PARM_DESC(volume, "initial volume: default 255 (range 0-255)");
107 module_param(budgetpatch, int, 0444);
108 MODULE_PARM_DESC(budgetpatch, "use budget-patch hardware modification: default 0 (0 no, 1 autodetect, 2 always)");
109 module_param(full_ts, int, 0444);
110 MODULE_PARM_DESC(full_ts, "enable code for full-ts hardware modification: 0 disable (default), 1 enable");
111 module_param(wss_cfg_4_3, int, 0444);
112 MODULE_PARM_DESC(wss_cfg_4_3, "WSS 4:3 - default 0x4008 - bit 15: disable, 14: burst mode, 13..0: wss data");
113 module_param(wss_cfg_16_9, int, 0444);
114 MODULE_PARM_DESC(wss_cfg_16_9, "WSS 16:9 - default 0x0007 - bit 15: disable, 14: burst mode, 13..0: wss data");
115 module_param(tv_standard, int, 0444);
116 MODULE_PARM_DESC(tv_standard, "TV standard: 0 PAL (default), 1 NTSC");
118 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
120 static void restart_feeds(struct av7110 *av7110);
121 static int budget_start_feed(struct dvb_demux_feed *feed);
122 static int budget_stop_feed(struct dvb_demux_feed *feed);
124 static int av7110_num;
126 #define FE_FUNC_OVERRIDE(fe_func, av7110_copy, av7110_func) \
128 if (fe_func != NULL) { \
129 av7110_copy = fe_func; \
130 fe_func = av7110_func; \
135 static void init_av7110_av(struct av7110 *av7110)
138 struct saa7146_dev *dev = av7110->dev;
140 /* set internal volume control to maximum */
141 av7110->adac_type = DVB_ADAC_TI;
142 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
144 printk("dvb-ttpci:cannot set internal volume to maximum:%d\n",ret);
146 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetMonitorType,
147 1, (u16) av7110->display_ar);
149 printk("dvb-ttpci: unable to set aspect ratio\n");
150 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetPanScanType,
151 1, av7110->display_panscan);
153 printk("dvb-ttpci: unable to set pan scan\n");
155 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 2, wss_cfg_4_3);
157 printk("dvb-ttpci: unable to configure 4:3 wss\n");
158 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 3, wss_cfg_16_9);
160 printk("dvb-ttpci: unable to configure 16:9 wss\n");
162 ret = av7710_set_video_mode(av7110, vidmode);
164 printk("dvb-ttpci:cannot set video mode:%d\n",ret);
166 /* handle different card types */
167 /* remaining inits according to card and frontend type */
168 av7110->analog_tuner_flags = 0;
169 av7110->current_input = 0;
170 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000a)
171 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 0); // SPDIF on
172 if (i2c_writereg(av7110, 0x20, 0x00, 0x00) == 1) {
173 printk ("dvb-ttpci: Crystal audio DAC @ card %d detected\n",
174 av7110->dvb_adapter.num);
175 av7110->adac_type = DVB_ADAC_CRYSTAL;
176 i2c_writereg(av7110, 0x20, 0x01, 0xd2);
177 i2c_writereg(av7110, 0x20, 0x02, 0x49);
178 i2c_writereg(av7110, 0x20, 0x03, 0x00);
179 i2c_writereg(av7110, 0x20, 0x04, 0x00);
182 * some special handling for the Siemens DVB-C cards...
184 } else if (0 == av7110_init_analog_module(av7110)) {
187 else if (dev->pci->subsystem_vendor == 0x110a) {
188 printk("dvb-ttpci: DVB-C w/o analog module @ card %d detected\n",
189 av7110->dvb_adapter.num);
190 av7110->adac_type = DVB_ADAC_NONE;
193 av7110->adac_type = adac;
194 printk("dvb-ttpci: adac type set to %d @ card %d\n",
195 av7110->adac_type, av7110->dvb_adapter.num);
198 if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP34x0) {
199 // switch DVB SCART on
200 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0);
202 printk("dvb-ttpci:cannot switch on SCART(Main):%d\n",ret);
203 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1);
205 printk("dvb-ttpci:cannot switch on SCART(AD):%d\n",ret);
207 ((av7110->dev->pci->subsystem_vendor == 0x110a) ||
208 (av7110->dev->pci->subsystem_vendor == 0x13c2)) &&
209 (av7110->dev->pci->subsystem_device == 0x0000)) {
210 saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16
211 //saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // SCARTpin 8
215 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000e)
216 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, SpdifSwitch, 1, 0); // SPDIF on
218 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
220 printk("dvb-ttpci:cannot set volume :%d\n",ret);
223 static void recover_arm(struct av7110 *av7110)
225 dprintk(4, "%p\n",av7110);
227 av7110_bootarm(av7110);
230 init_av7110_av(av7110);
232 /* card-specific recovery */
234 av7110->recover(av7110);
236 restart_feeds(av7110);
238 #if IS_ENABLED(CONFIG_DVB_AV7110_IR)
239 av7110_check_ir_config(av7110, true);
243 static void av7110_arm_sync(struct av7110 *av7110)
245 if (av7110->arm_thread)
246 kthread_stop(av7110->arm_thread);
248 av7110->arm_thread = NULL;
251 static int arm_thread(void *data)
253 struct av7110 *av7110 = data;
257 dprintk(4, "%p\n",av7110);
260 timeout = wait_event_interruptible_timeout(av7110->arm_wait,
261 kthread_should_stop(), 5 * HZ);
263 if (-ERESTARTSYS == timeout || kthread_should_stop()) {
264 /* got signal or told to quit*/
268 if (!av7110->arm_ready)
271 #if IS_ENABLED(CONFIG_DVB_AV7110_IR)
272 av7110_check_ir_config(av7110, false);
275 if (mutex_lock_interruptible(&av7110->dcomlock))
277 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
278 mutex_unlock(&av7110->dcomlock);
280 if (newloops == av7110->arm_loops || av7110->arm_errors > 3) {
281 printk(KERN_ERR "dvb-ttpci: ARM crashed @ card %d\n",
282 av7110->dvb_adapter.num);
286 if (mutex_lock_interruptible(&av7110->dcomlock))
288 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2) - 1;
289 mutex_unlock(&av7110->dcomlock);
291 av7110->arm_loops = newloops;
292 av7110->arm_errors = 0;
299 /****************************************************************************
301 ****************************************************************************/
303 static int DvbDmxFilterCallback(u8 *buffer1, size_t buffer1_len,
304 u8 *buffer2, size_t buffer2_len,
305 struct dvb_demux_filter *dvbdmxfilter,
306 enum dmx_success success,
307 struct av7110 *av7110)
309 if (!dvbdmxfilter->feed->demux->dmx.frontend)
311 if (dvbdmxfilter->feed->demux->dmx.frontend->source == DMX_MEMORY_FE)
314 switch (dvbdmxfilter->type) {
316 if ((((buffer1[1] << 8) | buffer1[2]) & 0xfff) + 3 != buffer1_len)
318 if (dvbdmxfilter->doneq) {
319 struct dmx_section_filter *filter = &dvbdmxfilter->filter;
323 for (i = 0; i < DVB_DEMUX_MASK_MAX; i++) {
324 xor = filter->filter_value[i] ^ buffer1[i];
325 neq |= dvbdmxfilter->maskandnotmode[i] & xor;
330 return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len,
331 buffer2, buffer2_len,
332 &dvbdmxfilter->filter,
335 if (!(dvbdmxfilter->feed->ts_type & TS_PACKET))
337 if (dvbdmxfilter->feed->ts_type & TS_PAYLOAD_ONLY)
338 return dvbdmxfilter->feed->cb.ts(buffer1, buffer1_len,
339 buffer2, buffer2_len,
340 &dvbdmxfilter->feed->feed.ts,
343 av7110_p2t_write(buffer1, buffer1_len,
344 dvbdmxfilter->feed->pid,
345 &av7110->p2t_filter[dvbdmxfilter->index]);
352 //#define DEBUG_TIMING
353 static inline void print_time(char *s)
357 do_gettimeofday(&tv);
358 printk("%s: %d.%d\n", s, (int)tv.tv_sec, (int)tv.tv_usec);
364 static inline void start_debi_dma(struct av7110 *av7110, int dir,
365 unsigned long addr, unsigned int len)
367 dprintk(8, "%c %08lx %u\n", dir == DEBI_READ ? 'R' : 'W', addr, len);
368 if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
369 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __func__);
373 SAA7146_ISR_CLEAR(av7110->dev, MASK_19); /* for good measure */
374 SAA7146_IER_ENABLE(av7110->dev, MASK_19);
376 len = 5; /* we want a real DEBI DMA */
377 if (dir == DEBI_WRITE)
378 iwdebi(av7110, DEBISWAB, addr, 0, (len + 3) & ~3);
380 irdebi(av7110, DEBISWAB, addr, 0, len);
383 static void debiirq(unsigned long cookie)
385 struct av7110 *av7110 = (struct av7110 *)cookie;
386 int type = av7110->debitype;
387 int handle = (type >> 8) & 0x1f;
388 unsigned int xfer = 0;
391 dprintk(4, "type 0x%04x\n", type);
394 printk("DEBI irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
395 jiffies, saa7146_read(av7110->dev, PSR),
396 saa7146_read(av7110->dev, SSR));
399 av7110->debitype = -1;
401 switch (type & 0xff) {
404 dvb_dmx_swfilter_packets(&av7110->demux,
405 (const u8 *) av7110->debi_virt,
406 av7110->debilen / 188);
410 case DATA_PES_RECORD:
411 if (av7110->demux.recording)
412 av7110_record_cb(&av7110->p2t[handle],
413 (u8 *) av7110->debi_virt,
421 if (av7110->handle2filter[handle])
422 DvbDmxFilterCallback((u8 *)av7110->debi_virt,
423 av7110->debilen, NULL, 0,
424 av7110->handle2filter[handle],
431 u8 *data = av7110->debi_virt;
433 if ((data[0] < 2) && data[2] == 0xff) {
436 flags |= CA_CI_MODULE_PRESENT;
438 flags |= CA_CI_MODULE_READY;
439 av7110->ci_slot[data[0]].flags = flags;
441 ci_get_data(&av7110->ci_rbuffer,
448 case DATA_COMMON_INTERFACE:
449 CI_handle(av7110, (u8 *)av7110->debi_virt, av7110->debilen);
454 printk("av7110%d: ", av7110->num);
455 printk("%02x ", *(u8 *)av7110->debi_virt);
456 printk("%02x ", *(1+(u8 *)av7110->debi_virt));
457 for (i = 2; i < av7110->debilen; i++)
458 printk("%02x ", (*(i+(unsigned char *)av7110->debi_virt)));
459 for (i = 2; i < av7110->debilen; i++)
460 printk("%c", chtrans(*(i+(unsigned char *)av7110->debi_virt)));
468 case DATA_DEBUG_MESSAGE:
469 ((s8*)av7110->debi_virt)[Reserved_SIZE - 1] = 0;
470 printk("%s\n", (s8 *) av7110->debi_virt);
475 dprintk(4, "debi DATA_CI_PUT\n");
477 dprintk(4, "debi DATA_MPEG_PLAY\n");
479 dprintk(4, "debi DATA_BMP_LOAD\n");
486 spin_lock(&av7110->debilock);
488 iwdebi(av7110, DEBINOSWAP, xfer, 0, 2);
489 ARM_ClearMailBox(av7110);
490 spin_unlock(&av7110->debilock);
493 /* irq from av7110 firmware writing the mailbox register in the DPRAM */
494 static void gpioirq(unsigned long cookie)
496 struct av7110 *av7110 = (struct av7110 *)cookie;
500 if (av7110->debitype != -1)
501 /* we shouldn't get any irq while a debi xfer is running */
502 printk("dvb-ttpci: GPIO0 irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
503 jiffies, saa7146_read(av7110->dev, PSR),
504 saa7146_read(av7110->dev, SSR));
506 if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
507 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __func__);
508 BUG(); /* maybe we should try resetting the debi? */
511 spin_lock(&av7110->debilock);
512 ARM_ClearIrq(av7110);
514 /* see what the av7110 wants */
515 av7110->debitype = irdebi(av7110, DEBINOSWAP, IRQ_STATE, 0, 2);
516 av7110->debilen = irdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
517 rxbuf = irdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
518 txbuf = irdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
519 len = (av7110->debilen + 3) & ~3;
522 dprintk(8, "GPIO0 irq 0x%04x %d\n", av7110->debitype, av7110->debilen);
524 switch (av7110->debitype & 0xff) {
530 case DATA_MPEG_VIDEO_EVENT:
533 struct video_event event;
535 av7110->video_size.w = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_WIDTH, 0, 2);
536 h_ar = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_HEIGHT_AR, 0, 2);
538 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
539 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
541 av7110->video_size.h = h_ar & 0xfff;
543 event.type = VIDEO_EVENT_SIZE_CHANGED;
544 event.u.size.w = av7110->video_size.w;
545 event.u.size.h = av7110->video_size.h;
546 switch ((h_ar >> 12) & 0xf)
549 av7110->video_size.aspect_ratio = VIDEO_FORMAT_16_9;
550 event.u.size.aspect_ratio = VIDEO_FORMAT_16_9;
551 av7110->videostate.video_format = VIDEO_FORMAT_16_9;
554 av7110->video_size.aspect_ratio = VIDEO_FORMAT_221_1;
555 event.u.size.aspect_ratio = VIDEO_FORMAT_221_1;
556 av7110->videostate.video_format = VIDEO_FORMAT_221_1;
559 av7110->video_size.aspect_ratio = VIDEO_FORMAT_4_3;
560 event.u.size.aspect_ratio = VIDEO_FORMAT_4_3;
561 av7110->videostate.video_format = VIDEO_FORMAT_4_3;
564 dprintk(8, "GPIO0 irq: DATA_MPEG_VIDEO_EVENT: w/h/ar = %u/%u/%u\n",
565 av7110->video_size.w, av7110->video_size.h,
566 av7110->video_size.aspect_ratio);
568 dvb_video_add_event(av7110, &event);
575 struct dvb_ringbuffer *cibuf = &av7110->ci_wbuffer;
577 avail = dvb_ringbuffer_avail(cibuf);
579 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
580 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
581 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
584 len = DVB_RINGBUFFER_PEEK(cibuf, 0) << 8;
585 len |= DVB_RINGBUFFER_PEEK(cibuf, 1);
586 if (avail < len + 2) {
587 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
588 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
589 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
592 DVB_RINGBUFFER_SKIP(cibuf, 2);
594 dvb_ringbuffer_read(cibuf, av7110->debi_virt, len);
596 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
597 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
598 dprintk(8, "DMA: CI\n");
599 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
600 spin_unlock(&av7110->debilock);
601 wake_up(&cibuf->queue);
606 if (!av7110->playing) {
607 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
608 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
609 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
613 if (av7110->debitype & 0x100) {
614 spin_lock(&av7110->aout.lock);
615 len = av7110_pes_play(av7110->debi_virt, &av7110->aout, 2048);
616 spin_unlock(&av7110->aout.lock);
618 if (len <= 0 && (av7110->debitype & 0x200)
619 &&av7110->videostate.play_state != VIDEO_FREEZED) {
620 spin_lock(&av7110->avout.lock);
621 len = av7110_pes_play(av7110->debi_virt, &av7110->avout, 2048);
622 spin_unlock(&av7110->avout.lock);
625 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
626 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
627 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
630 dprintk(8, "GPIO0 PES_PLAY len=%04x\n", len);
631 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
632 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
633 dprintk(8, "DMA: MPEG_PLAY\n");
634 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
635 spin_unlock(&av7110->debilock);
639 len = av7110->debilen;
640 dprintk(8, "gpio DATA_BMP_LOAD len %d\n", len);
642 av7110->bmp_state = BMP_LOADED;
643 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
644 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
645 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
646 wake_up(&av7110->bmpq);
647 dprintk(8, "gpio DATA_BMP_LOAD done\n");
650 if (len > av7110->bmplen)
651 len = av7110->bmplen;
654 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
655 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
656 memcpy(av7110->debi_virt, av7110->bmpbuf+av7110->bmpp, len);
658 av7110->bmplen -= len;
659 dprintk(8, "gpio DATA_BMP_LOAD DMA len %d\n", len);
660 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE+txbuf, len);
661 spin_unlock(&av7110->debilock);
665 case DATA_COMMON_INTERFACE:
669 if (!len || len > 4 * 1024) {
670 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
676 case DATA_PES_RECORD:
677 dprintk(8, "DMA: TS_REC etc.\n");
678 start_debi_dma(av7110, DEBI_READ, DPRAM_BASE+rxbuf, len);
679 spin_unlock(&av7110->debilock);
682 case DATA_DEBUG_MESSAGE:
683 if (!len || len > 0xff) {
684 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
687 start_debi_dma(av7110, DEBI_READ, Reserved, len);
688 spin_unlock(&av7110->debilock);
692 if (av7110->ir.ir_handler)
693 av7110->ir.ir_handler(av7110,
694 swahw32(irdebi(av7110, DEBINOSWAP, Reserved, 0, 4)));
695 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
699 printk("dvb-ttpci: gpioirq unknown type=%d len=%d\n",
700 av7110->debitype, av7110->debilen);
703 av7110->debitype = -1;
704 ARM_ClearMailBox(av7110);
705 spin_unlock(&av7110->debilock);
709 #ifdef CONFIG_DVB_AV7110_OSD
710 static int dvb_osd_ioctl(struct file *file,
711 unsigned int cmd, void *parg)
713 struct dvb_device *dvbdev = file->private_data;
714 struct av7110 *av7110 = dvbdev->priv;
716 dprintk(4, "%p\n", av7110);
718 if (cmd == OSD_SEND_CMD)
719 return av7110_osd_cmd(av7110, (osd_cmd_t *) parg);
720 if (cmd == OSD_GET_CAPABILITY)
721 return av7110_osd_capability(av7110, (osd_cap_t *) parg);
727 static const struct file_operations dvb_osd_fops = {
728 .owner = THIS_MODULE,
729 .unlocked_ioctl = dvb_generic_ioctl,
730 .open = dvb_generic_open,
731 .release = dvb_generic_release,
732 .llseek = noop_llseek,
735 static struct dvb_device dvbdev_osd = {
739 .fops = &dvb_osd_fops,
740 .kernel_ioctl = dvb_osd_ioctl,
742 #endif /* CONFIG_DVB_AV7110_OSD */
745 static inline int SetPIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
746 u16 subpid, u16 pcrpid)
750 dprintk(4, "%p\n", av7110);
752 if (vpid == 0x1fff || apid == 0x1fff ||
753 ttpid == 0x1fff || subpid == 0x1fff || pcrpid == 0x1fff) {
754 vpid = apid = ttpid = subpid = pcrpid = 0;
755 av7110->pids[DMX_PES_VIDEO] = 0;
756 av7110->pids[DMX_PES_AUDIO] = 0;
757 av7110->pids[DMX_PES_TELETEXT] = 0;
758 av7110->pids[DMX_PES_PCR] = 0;
761 if (av7110->audiostate.bypass_mode)
764 return av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, MultiPID, 6,
765 pcrpid, vpid, apid, ttpid, subpid, aflags);
768 int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
769 u16 subpid, u16 pcrpid)
772 dprintk(4, "%p\n", av7110);
774 if (mutex_lock_interruptible(&av7110->pid_mutex))
777 if (!(vpid & 0x8000))
778 av7110->pids[DMX_PES_VIDEO] = vpid;
779 if (!(apid & 0x8000))
780 av7110->pids[DMX_PES_AUDIO] = apid;
781 if (!(ttpid & 0x8000))
782 av7110->pids[DMX_PES_TELETEXT] = ttpid;
783 if (!(pcrpid & 0x8000))
784 av7110->pids[DMX_PES_PCR] = pcrpid;
786 av7110->pids[DMX_PES_SUBTITLE] = 0;
788 if (av7110->fe_synced) {
789 pcrpid = av7110->pids[DMX_PES_PCR];
790 ret = SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
793 mutex_unlock(&av7110->pid_mutex);
798 /******************************************************************************
799 * hardware filter functions
800 ******************************************************************************/
802 static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter)
804 struct dvb_demux_feed *dvbdmxfeed = dvbdmxfilter->feed;
805 struct av7110 *av7110 = dvbdmxfeed->demux->priv;
809 // u16 mode = 0x0320;
812 dprintk(4, "%p\n", av7110);
817 if (dvbdmxfilter->type == DMX_TYPE_SEC) {
819 buf[4] = (dvbdmxfilter->filter.filter_value[0] << 8) |
820 dvbdmxfilter->maskandmode[0];
821 for (i = 3; i < 18; i++)
823 (dvbdmxfilter->filter.filter_value[i] << 8) |
824 dvbdmxfilter->maskandmode[i];
827 } else if ((dvbdmxfeed->ts_type & TS_PACKET) &&
828 !(dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)) {
829 av7110_p2t_init(&av7110->p2t_filter[dvbdmxfilter->index], dvbdmxfeed);
832 buf[0] = (COMTYPE_PID_FILTER << 8) + AddPIDFilter;
834 buf[2] = dvbdmxfeed->pid;
837 ret = av7110_fw_request(av7110, buf, 20, &handle, 1);
838 if (ret != 0 || handle >= 32) {
839 printk("dvb-ttpci: %s error buf %04x %04x %04x %04x "
840 "ret %d handle %04x\n",
841 __func__, buf[0], buf[1], buf[2], buf[3],
843 dvbdmxfilter->hw_handle = 0xffff;
849 av7110->handle2filter[handle] = dvbdmxfilter;
850 dvbdmxfilter->hw_handle = handle;
855 static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
857 struct av7110 *av7110 = dvbdmxfilter->feed->demux->priv;
863 dprintk(4, "%p\n", av7110);
868 handle = dvbdmxfilter->hw_handle;
870 printk("%s tried to stop invalid filter %04x, filter type = %x\n",
871 __func__, handle, dvbdmxfilter->type);
875 av7110->handle2filter[handle] = NULL;
877 buf[0] = (COMTYPE_PID_FILTER << 8) + DelPIDFilter;
880 ret = av7110_fw_request(av7110, buf, 3, answ, 2);
881 if (ret != 0 || answ[1] != handle) {
882 printk("dvb-ttpci: %s error cmd %04x %04x %04x ret %x "
883 "resp %04x %04x pid %d\n",
884 __func__, buf[0], buf[1], buf[2], ret,
885 answ[0], answ[1], dvbdmxfilter->feed->pid);
893 static int dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
895 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
896 struct av7110 *av7110 = dvbdmx->priv;
897 u16 *pid = dvbdmx->pids, npids[5];
901 dprintk(4, "%p\n", av7110);
903 npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
904 i = dvbdmxfeed->pes_type;
905 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
906 if ((i == 2) && npids[i] && (dvbdmxfeed->ts_type & TS_PACKET)) {
908 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
910 ret = StartHWFilter(dvbdmxfeed->filter);
913 if (dvbdmxfeed->pes_type <= 2 || dvbdmxfeed->pes_type == 4) {
914 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
919 if (dvbdmxfeed->pes_type < 2 && npids[0])
920 if (av7110->fe_synced)
922 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
927 if ((dvbdmxfeed->ts_type & TS_PACKET) && !av7110->full_ts) {
928 if (dvbdmxfeed->pes_type == 0 && !(dvbdmx->pids[0] & 0x8000))
929 ret = av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed);
930 if (dvbdmxfeed->pes_type == 1 && !(dvbdmx->pids[1] & 0x8000))
931 ret = av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed);
936 static int dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
938 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
939 struct av7110 *av7110 = dvbdmx->priv;
940 u16 *pid = dvbdmx->pids, npids[5];
945 dprintk(4, "%p\n", av7110);
947 if (dvbdmxfeed->pes_type <= 1) {
948 ret = av7110_av_stop(av7110, dvbdmxfeed->pes_type ? RP_VIDEO : RP_AUDIO);
951 if (!av7110->rec_mode)
952 dvbdmx->recording = 0;
953 if (!av7110->playing)
956 npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
957 i = dvbdmxfeed->pes_type;
960 if (dvbdmxfeed->ts_type & TS_PACKET)
961 ret = StopHWFilter(dvbdmxfeed->filter);
969 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
973 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
977 static int av7110_start_feed(struct dvb_demux_feed *feed)
979 struct dvb_demux *demux = feed->demux;
980 struct av7110 *av7110 = demux->priv;
983 dprintk(4, "%p\n", av7110);
985 if (!demux->dmx.frontend)
988 if (!av7110->full_ts && feed->pid > 0x1fff)
991 if (feed->type == DMX_TYPE_TS) {
992 if ((feed->ts_type & TS_DECODER) &&
993 (feed->pes_type <= DMX_PES_PCR)) {
994 switch (demux->dmx.frontend->source) {
996 if (feed->ts_type & TS_DECODER)
997 if (feed->pes_type < 2 &&
998 !(demux->pids[0] & 0x8000) &&
999 !(demux->pids[1] & 0x8000)) {
1000 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
1001 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
1002 ret = av7110_av_start_play(av7110,RP_AV);
1008 ret = dvb_feed_start_pid(feed);
1011 } else if ((feed->ts_type & TS_PACKET) &&
1012 (demux->dmx.frontend->source != DMX_MEMORY_FE)) {
1013 ret = StartHWFilter(feed->filter);
1017 if (av7110->full_ts) {
1018 budget_start_feed(feed);
1022 if (feed->type == DMX_TYPE_SEC) {
1025 for (i = 0; i < demux->filternum; i++) {
1026 if (demux->filter[i].state != DMX_STATE_READY)
1028 if (demux->filter[i].type != DMX_TYPE_SEC)
1030 if (demux->filter[i].filter.parent != &feed->feed.sec)
1032 demux->filter[i].state = DMX_STATE_GO;
1033 if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
1034 ret = StartHWFilter(&demux->filter[i]);
1045 static int av7110_stop_feed(struct dvb_demux_feed *feed)
1047 struct dvb_demux *demux = feed->demux;
1048 struct av7110 *av7110 = demux->priv;
1050 dprintk(4, "%p\n", av7110);
1052 if (feed->type == DMX_TYPE_TS) {
1053 if (feed->ts_type & TS_DECODER) {
1054 if (feed->pes_type >= DMX_PES_OTHER ||
1055 !demux->pesfilter[feed->pes_type])
1057 demux->pids[feed->pes_type] |= 0x8000;
1058 demux->pesfilter[feed->pes_type] = NULL;
1060 if (feed->ts_type & TS_DECODER &&
1061 feed->pes_type < DMX_PES_OTHER) {
1062 ret = dvb_feed_stop_pid(feed);
1064 if ((feed->ts_type & TS_PACKET) &&
1065 (demux->dmx.frontend->source != DMX_MEMORY_FE))
1066 ret = StopHWFilter(feed->filter);
1069 if (av7110->full_ts) {
1070 budget_stop_feed(feed);
1074 if (feed->type == DMX_TYPE_SEC) {
1075 for (i = 0; i<demux->filternum; i++) {
1076 if (demux->filter[i].state == DMX_STATE_GO &&
1077 demux->filter[i].filter.parent == &feed->feed.sec) {
1078 demux->filter[i].state = DMX_STATE_READY;
1079 if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
1080 rc = StopHWFilter(&demux->filter[i]);
1083 /* keep going, stop as many filters as possible */
1093 static void restart_feeds(struct av7110 *av7110)
1095 struct dvb_demux *dvbdmx = &av7110->demux;
1096 struct dvb_demux_feed *feed;
1101 dprintk(4, "%p\n", av7110);
1103 mode = av7110->playing;
1104 av7110->playing = 0;
1105 av7110->rec_mode = 0;
1107 feeding = av7110->feeding1; /* full_ts mod */
1109 for (i = 0; i < dvbdmx->feednum; i++) {
1110 feed = &dvbdmx->feed[i];
1111 if (feed->state == DMX_STATE_GO) {
1112 if (feed->type == DMX_TYPE_SEC) {
1113 for (j = 0; j < dvbdmx->filternum; j++) {
1114 if (dvbdmx->filter[j].type != DMX_TYPE_SEC)
1116 if (dvbdmx->filter[j].filter.parent != &feed->feed.sec)
1118 if (dvbdmx->filter[j].state == DMX_STATE_GO)
1119 dvbdmx->filter[j].state = DMX_STATE_READY;
1122 av7110_start_feed(feed);
1126 av7110->feeding1 = feeding; /* full_ts mod */
1129 av7110_av_start_play(av7110, mode);
1132 static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
1133 uint64_t *stc, unsigned int *base)
1137 u16 tag = ((COMTYPE_REQUEST << 8) + ReqSTC);
1138 struct dvb_demux *dvbdemux;
1139 struct av7110 *av7110;
1141 /* pointer casting paranoia... */
1143 dvbdemux = demux->priv;
1145 av7110 = dvbdemux->priv;
1147 dprintk(4, "%p\n", av7110);
1152 ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4);
1154 printk(KERN_ERR "%s: av7110_fw_request error\n", __func__);
1157 dprintk(2, "fwstc = %04hx %04hx %04hx %04hx\n",
1158 fwstc[0], fwstc[1], fwstc[2], fwstc[3]);
1160 *stc = (((uint64_t) ((fwstc[3] & 0x8000) >> 15)) << 32) |
1161 (((uint64_t) fwstc[1]) << 16) | ((uint64_t) fwstc[0]);
1164 dprintk(4, "stc = %lu\n", (unsigned long)*stc);
1170 /******************************************************************************
1171 * SEC device file operations
1172 ******************************************************************************/
1175 static int av7110_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone)
1177 struct av7110* av7110 = fe->dvb->priv;
1181 return Set22K(av7110, 1);
1184 return Set22K(av7110, 0);
1191 static int av7110_diseqc_send_master_cmd(struct dvb_frontend* fe,
1192 struct dvb_diseqc_master_cmd* cmd)
1194 struct av7110* av7110 = fe->dvb->priv;
1196 return av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1);
1199 static int av7110_diseqc_send_burst(struct dvb_frontend* fe,
1200 enum fe_sec_mini_cmd minicmd)
1202 struct av7110* av7110 = fe->dvb->priv;
1204 return av7110_diseqc_send(av7110, 0, NULL, minicmd);
1207 /* simplified code from budget-core.c */
1208 static int stop_ts_capture(struct av7110 *budget)
1210 dprintk(2, "budget: %p\n", budget);
1212 if (--budget->feeding1)
1213 return budget->feeding1;
1214 saa7146_write(budget->dev, MC1, MASK_20); /* DMA3 off */
1215 SAA7146_IER_DISABLE(budget->dev, MASK_10);
1216 SAA7146_ISR_CLEAR(budget->dev, MASK_10);
1220 static int start_ts_capture(struct av7110 *budget)
1224 dprintk(2, "budget: %p\n", budget);
1226 if (budget->feeding1)
1227 return ++budget->feeding1;
1228 for (y = 0; y < TS_HEIGHT; y++)
1229 memset(budget->grabbing + y * TS_WIDTH, 0x00, TS_WIDTH);
1231 SAA7146_ISR_CLEAR(budget->dev, MASK_10); /* VPE */
1232 SAA7146_IER_ENABLE(budget->dev, MASK_10); /* VPE */
1233 saa7146_write(budget->dev, MC1, (MASK_04 | MASK_20)); /* DMA3 on */
1234 return ++budget->feeding1;
1237 static int budget_start_feed(struct dvb_demux_feed *feed)
1239 struct dvb_demux *demux = feed->demux;
1240 struct av7110 *budget = demux->priv;
1243 dprintk(2, "av7110: %p\n", budget);
1245 spin_lock(&budget->feedlock1);
1246 feed->pusi_seen = 0; /* have a clean section start */
1247 status = start_ts_capture(budget);
1248 spin_unlock(&budget->feedlock1);
1252 static int budget_stop_feed(struct dvb_demux_feed *feed)
1254 struct dvb_demux *demux = feed->demux;
1255 struct av7110 *budget = demux->priv;
1258 dprintk(2, "budget: %p\n", budget);
1260 spin_lock(&budget->feedlock1);
1261 status = stop_ts_capture(budget);
1262 spin_unlock(&budget->feedlock1);
1266 static void vpeirq(unsigned long cookie)
1268 struct av7110 *budget = (struct av7110 *)cookie;
1269 u8 *mem = (u8 *) (budget->grabbing);
1270 u32 olddma = budget->ttbp;
1271 u32 newdma = saa7146_read(budget->dev, PCI_VDP3);
1272 struct dvb_demux *demux = budget->full_ts ? &budget->demux : &budget->demux1;
1274 /* nearest lower position divisible by 188 */
1275 newdma -= newdma % 188;
1277 if (newdma >= TS_BUFLEN)
1280 budget->ttbp = newdma;
1282 if (!budget->feeding1 || (newdma == olddma))
1285 /* Ensure streamed PCI data is synced to CPU */
1286 pci_dma_sync_sg_for_cpu(budget->dev->pci, budget->pt.slist, budget->pt.nents, PCI_DMA_FROMDEVICE);
1289 /* track rps1 activity */
1290 printk("vpeirq: %02x Event Counter 1 0x%04x\n",
1292 saa7146_read(budget->dev, EC1R) & 0x3fff);
1295 if (newdma > olddma)
1296 /* no wraparound, dump olddma..newdma */
1297 dvb_dmx_swfilter_packets(demux, mem + olddma, (newdma - olddma) / 188);
1299 /* wraparound, dump olddma..buflen and 0..newdma */
1300 dvb_dmx_swfilter_packets(demux, mem + olddma, (TS_BUFLEN - olddma) / 188);
1301 dvb_dmx_swfilter_packets(demux, mem, newdma / 188);
1305 static int av7110_register(struct av7110 *av7110)
1308 struct dvb_demux *dvbdemux = &av7110->demux;
1309 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1311 dprintk(4, "%p\n", av7110);
1313 if (av7110->registered)
1316 av7110->registered = 1;
1318 dvbdemux->priv = (void *) av7110;
1320 for (i = 0; i < 32; i++)
1321 av7110->handle2filter[i] = NULL;
1323 dvbdemux->filternum = (av7110->full_ts) ? 256 : 32;
1324 dvbdemux->feednum = (av7110->full_ts) ? 256 : 32;
1325 dvbdemux->start_feed = av7110_start_feed;
1326 dvbdemux->stop_feed = av7110_stop_feed;
1327 dvbdemux->write_to_decoder = av7110_write_to_decoder;
1328 dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1329 DMX_MEMORY_BASED_FILTERING);
1331 dvb_dmx_init(&av7110->demux);
1332 av7110->demux.dmx.get_stc = dvb_get_stc;
1334 av7110->dmxdev.filternum = (av7110->full_ts) ? 256 : 32;
1335 av7110->dmxdev.demux = &dvbdemux->dmx;
1336 av7110->dmxdev.capabilities = 0;
1338 dvb_dmxdev_init(&av7110->dmxdev, &av7110->dvb_adapter);
1340 av7110->hw_frontend.source = DMX_FRONTEND_0;
1342 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1347 av7110->mem_frontend.source = DMX_MEMORY_FE;
1349 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1354 ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1355 &av7110->hw_frontend);
1359 av7110_av_register(av7110);
1360 av7110_ca_register(av7110);
1362 #ifdef CONFIG_DVB_AV7110_OSD
1363 dvb_register_device(&av7110->dvb_adapter, &av7110->osd_dev,
1364 &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1367 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1370 /* initialize software demux1 without its own frontend
1371 * demux1 hardware is connected to frontend0 of demux0
1373 dvbdemux1->priv = (void *) av7110;
1375 dvbdemux1->filternum = 256;
1376 dvbdemux1->feednum = 256;
1377 dvbdemux1->start_feed = budget_start_feed;
1378 dvbdemux1->stop_feed = budget_stop_feed;
1379 dvbdemux1->write_to_decoder = NULL;
1381 dvbdemux1->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1382 DMX_MEMORY_BASED_FILTERING);
1384 dvb_dmx_init(&av7110->demux1);
1386 av7110->dmxdev1.filternum = 256;
1387 av7110->dmxdev1.demux = &dvbdemux1->dmx;
1388 av7110->dmxdev1.capabilities = 0;
1390 dvb_dmxdev_init(&av7110->dmxdev1, &av7110->dvb_adapter);
1392 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net1, &dvbdemux1->dmx);
1393 printk("dvb-ttpci: additional demux1 for budget-patch registered\n");
1399 static void dvb_unregister(struct av7110 *av7110)
1401 struct dvb_demux *dvbdemux = &av7110->demux;
1402 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1404 dprintk(4, "%p\n", av7110);
1406 if (!av7110->registered)
1410 dvb_net_release(&av7110->dvb_net1);
1411 dvbdemux->dmx.close(&dvbdemux1->dmx);
1412 dvb_dmxdev_release(&av7110->dmxdev1);
1413 dvb_dmx_release(&av7110->demux1);
1416 dvb_net_release(&av7110->dvb_net);
1418 dvbdemux->dmx.close(&dvbdemux->dmx);
1419 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1420 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1422 dvb_dmxdev_release(&av7110->dmxdev);
1423 dvb_dmx_release(&av7110->demux);
1425 if (av7110->fe != NULL) {
1426 dvb_unregister_frontend(av7110->fe);
1427 dvb_frontend_detach(av7110->fe);
1429 dvb_unregister_device(av7110->osd_dev);
1430 av7110_av_unregister(av7110);
1431 av7110_ca_unregister(av7110);
1435 /****************************************************************************
1436 * I2C client commands
1437 ****************************************************************************/
1439 int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1441 u8 msg[2] = { reg, val };
1442 struct i2c_msg msgs;
1448 return i2c_transfer(&av7110->i2c_adap, &msgs, 1);
1451 u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1455 struct i2c_msg msgs[2];
1458 msgs[1].flags = I2C_M_RD;
1459 msgs[0].addr = msgs[1].addr = id / 2;
1461 msgs[0].len = 1; msgs[1].len = 1;
1462 msgs[0].buf = mm1; msgs[1].buf = mm2;
1463 i2c_transfer(&av7110->i2c_adap, msgs, 2);
1468 /****************************************************************************
1470 ****************************************************************************/
1473 static int check_firmware(struct av7110* av7110)
1475 u32 crc = 0, len = 0;
1478 /* check for firmware magic */
1479 ptr = av7110->bin_fw;
1480 if (ptr[0] != 'A' || ptr[1] != 'V' ||
1481 ptr[2] != 'F' || ptr[3] != 'W') {
1482 printk("dvb-ttpci: this is not an av7110 firmware\n");
1487 /* check dpram file */
1488 crc = get_unaligned_be32(ptr);
1490 len = get_unaligned_be32(ptr);
1493 printk("dvb-ttpci: dpram file is way too big.\n");
1496 if (crc != crc32_le(0, ptr, len)) {
1497 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1500 av7110->bin_dpram = ptr;
1501 av7110->size_dpram = len;
1504 /* check root file */
1505 crc = get_unaligned_be32(ptr);
1507 len = get_unaligned_be32(ptr);
1510 if (len <= 200000 || len >= 300000 ||
1511 len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1512 printk("dvb-ttpci: root file has strange size (%d). aborting.\n", len);
1515 if( crc != crc32_le(0, ptr, len)) {
1516 printk("dvb-ttpci: crc32 of root file does not match.\n");
1519 av7110->bin_root = ptr;
1520 av7110->size_root = len;
1524 static void put_firmware(struct av7110* av7110)
1526 vfree(av7110->bin_fw);
1529 static int get_firmware(struct av7110* av7110)
1532 const struct firmware *fw;
1534 /* request the av7110 firmware, this will block until someone uploads it */
1535 ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev);
1537 if (ret == -ENOENT) {
1538 printk(KERN_ERR "dvb-ttpci: could not load firmware,"
1539 " file not found: dvb-ttpci-01.fw\n");
1540 printk(KERN_ERR "dvb-ttpci: usually this should be in "
1541 "/usr/lib/hotplug/firmware or /lib/firmware\n");
1542 printk(KERN_ERR "dvb-ttpci: and can be downloaded from"
1543 " http://www.linuxtv.org/download/dvb/firmware/\n");
1545 printk(KERN_ERR "dvb-ttpci: cannot request firmware"
1546 " (error %i)\n", ret);
1550 if (fw->size <= 200000) {
1551 printk("dvb-ttpci: this firmware is way too small.\n");
1552 release_firmware(fw);
1556 /* check if the firmware is available */
1557 av7110->bin_fw = vmalloc(fw->size);
1558 if (NULL == av7110->bin_fw) {
1559 dprintk(1, "out of memory\n");
1560 release_firmware(fw);
1564 memcpy(av7110->bin_fw, fw->data, fw->size);
1565 av7110->size_fw = fw->size;
1566 if ((ret = check_firmware(av7110)))
1567 vfree(av7110->bin_fw);
1569 release_firmware(fw);
1573 static int alps_bsrv2_tuner_set_params(struct dvb_frontend *fe)
1575 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1576 struct av7110* av7110 = fe->dvb->priv;
1579 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) };
1580 u32 div = (p->frequency + 479500) / 125;
1582 if (p->frequency > 2000000)
1584 else if (p->frequency > 1800000)
1586 else if (p->frequency > 1600000)
1588 else if (p->frequency > 1200000)
1590 else if (p->frequency >= 1100000)
1595 buf[0] = (div >> 8) & 0x7f;
1596 buf[1] = div & 0xff;
1597 buf[2] = ((div & 0x18000) >> 10) | 0x95;
1598 buf[3] = (pwr << 6) | 0x30;
1600 // NOTE: since we're using a prescaler of 2, we set the
1601 // divisor frequency to 62.5kHz and divide by 125 above
1603 if (fe->ops.i2c_gate_ctrl)
1604 fe->ops.i2c_gate_ctrl(fe, 1);
1605 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1610 static struct ves1x93_config alps_bsrv2_config = {
1611 .demod_address = 0x08,
1616 static int alps_tdbe2_tuner_set_params(struct dvb_frontend *fe)
1618 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1619 struct av7110* av7110 = fe->dvb->priv;
1622 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1624 div = (p->frequency + 35937500 + 31250) / 62500;
1626 data[0] = (div >> 8) & 0x7f;
1627 data[1] = div & 0xff;
1628 data[2] = 0x85 | ((div >> 10) & 0x60);
1629 data[3] = (p->frequency < 174000000 ? 0x88 : p->frequency < 470000000 ? 0x84 : 0x81);
1631 if (fe->ops.i2c_gate_ctrl)
1632 fe->ops.i2c_gate_ctrl(fe, 1);
1633 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1638 static struct ves1820_config alps_tdbe2_config = {
1639 .demod_address = 0x09,
1642 .selagc = VES1820_SELAGC_SIGNAMPERR,
1648 static int grundig_29504_451_tuner_set_params(struct dvb_frontend *fe)
1650 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1651 struct av7110* av7110 = fe->dvb->priv;
1654 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1656 div = p->frequency / 125;
1657 data[0] = (div >> 8) & 0x7f;
1658 data[1] = div & 0xff;
1662 if (fe->ops.i2c_gate_ctrl)
1663 fe->ops.i2c_gate_ctrl(fe, 1);
1664 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1669 static struct tda8083_config grundig_29504_451_config = {
1670 .demod_address = 0x68,
1675 static int philips_cd1516_tuner_set_params(struct dvb_frontend *fe)
1677 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1678 struct av7110* av7110 = fe->dvb->priv;
1680 u32 f = p->frequency;
1682 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1684 div = (f + 36125000 + 31250) / 62500;
1686 data[0] = (div >> 8) & 0x7f;
1687 data[1] = div & 0xff;
1689 data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1691 if (fe->ops.i2c_gate_ctrl)
1692 fe->ops.i2c_gate_ctrl(fe, 1);
1693 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1698 static struct ves1820_config philips_cd1516_config = {
1699 .demod_address = 0x09,
1702 .selagc = VES1820_SELAGC_SIGNAMPERR,
1707 static int alps_tdlb7_tuner_set_params(struct dvb_frontend *fe)
1709 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1710 struct av7110* av7110 = fe->dvb->priv;
1713 struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1715 div = (p->frequency + 36200000) / 166666;
1717 if (p->frequency <= 782000000)
1722 data[0] = (div >> 8) & 0x7f;
1723 data[1] = div & 0xff;
1727 if (fe->ops.i2c_gate_ctrl)
1728 fe->ops.i2c_gate_ctrl(fe, 1);
1729 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1734 static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1736 #if IS_ENABLED(CONFIG_DVB_SP8870)
1737 struct av7110* av7110 = fe->dvb->priv;
1739 return request_firmware(fw, name, &av7110->dev->pci->dev);
1745 static struct sp8870_config alps_tdlb7_config = {
1747 .demod_address = 0x71,
1748 .request_firmware = alps_tdlb7_request_firmware,
1752 static u8 nexusca_stv0297_inittab[] = {
1845 static int nexusca_stv0297_tuner_set_params(struct dvb_frontend *fe)
1847 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1848 struct av7110* av7110 = fe->dvb->priv;
1851 struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
1852 struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
1855 div = (p->frequency + 36150000 + 31250) / 62500;
1857 data[0] = (div >> 8) & 0x7f;
1858 data[1] = div & 0xff;
1861 if (p->frequency < 45000000)
1863 else if (p->frequency < 137000000)
1865 else if (p->frequency < 403000000)
1867 else if (p->frequency < 860000000)
1872 if (fe->ops.i2c_gate_ctrl)
1873 fe->ops.i2c_gate_ctrl(fe, 1);
1874 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) {
1875 printk("nexusca: pll transfer failed!\n");
1879 // wait for PLL lock
1880 for(i = 0; i < 20; i++) {
1881 if (fe->ops.i2c_gate_ctrl)
1882 fe->ops.i2c_gate_ctrl(fe, 1);
1883 if (i2c_transfer(&av7110->i2c_adap, &readmsg, 1) == 1)
1884 if (data[0] & 0x40) break;
1891 static struct stv0297_config nexusca_stv0297_config = {
1893 .demod_address = 0x1C,
1894 .inittab = nexusca_stv0297_inittab,
1896 .stop_during_read = 1,
1901 static int grundig_29504_401_tuner_set_params(struct dvb_frontend *fe)
1903 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1904 struct av7110* av7110 = fe->dvb->priv;
1906 u8 cfg, cpump, band_select;
1908 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1910 div = (36125000 + p->frequency) / 166666;
1914 if (p->frequency < 175000000)
1916 else if (p->frequency < 390000000)
1918 else if (p->frequency < 470000000)
1920 else if (p->frequency < 750000000)
1925 if (p->frequency < 175000000)
1927 else if (p->frequency < 470000000)
1932 data[0] = (div >> 8) & 0x7f;
1933 data[1] = div & 0xff;
1934 data[2] = ((div >> 10) & 0x60) | cfg;
1935 data[3] = (cpump << 6) | band_select;
1937 if (fe->ops.i2c_gate_ctrl)
1938 fe->ops.i2c_gate_ctrl(fe, 1);
1939 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) return -EIO;
1943 static struct l64781_config grundig_29504_401_config = {
1944 .demod_address = 0x55,
1949 static int av7110_fe_lock_fix(struct av7110 *av7110, enum fe_status status)
1952 int synced = (status & FE_HAS_LOCK) ? 1 : 0;
1954 av7110->fe_status = status;
1956 if (av7110->fe_synced == synced)
1959 if (av7110->playing) {
1960 av7110->fe_synced = synced;
1964 if (mutex_lock_interruptible(&av7110->pid_mutex))
1965 return -ERESTARTSYS;
1968 ret = SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
1969 av7110->pids[DMX_PES_AUDIO],
1970 av7110->pids[DMX_PES_TELETEXT], 0,
1971 av7110->pids[DMX_PES_PCR]);
1973 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
1975 ret = SetPIDs(av7110, 0, 0, 0, 0, 0);
1977 ret = av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
1979 ret = av7110_wait_msgstate(av7110, GPMQBusy);
1984 av7110->fe_synced = synced;
1986 mutex_unlock(&av7110->pid_mutex);
1990 static int av7110_fe_set_frontend(struct dvb_frontend *fe)
1992 struct av7110* av7110 = fe->dvb->priv;
1994 int ret = av7110_fe_lock_fix(av7110, 0);
1996 ret = av7110->fe_set_frontend(fe);
2001 static int av7110_fe_init(struct dvb_frontend* fe)
2003 struct av7110* av7110 = fe->dvb->priv;
2005 int ret = av7110_fe_lock_fix(av7110, 0);
2007 ret = av7110->fe_init(fe);
2011 static int av7110_fe_read_status(struct dvb_frontend *fe,
2012 enum fe_status *status)
2014 struct av7110* av7110 = fe->dvb->priv;
2016 /* call the real implementation */
2017 int ret = av7110->fe_read_status(fe, status);
2019 if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK))
2020 ret = av7110_fe_lock_fix(av7110, *status);
2024 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
2026 struct av7110* av7110 = fe->dvb->priv;
2028 int ret = av7110_fe_lock_fix(av7110, 0);
2030 ret = av7110->fe_diseqc_reset_overload(fe);
2034 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
2035 struct dvb_diseqc_master_cmd* cmd)
2037 struct av7110* av7110 = fe->dvb->priv;
2039 int ret = av7110_fe_lock_fix(av7110, 0);
2041 av7110->saved_master_cmd = *cmd;
2042 ret = av7110->fe_diseqc_send_master_cmd(fe, cmd);
2047 static int av7110_fe_diseqc_send_burst(struct dvb_frontend *fe,
2048 enum fe_sec_mini_cmd minicmd)
2050 struct av7110* av7110 = fe->dvb->priv;
2052 int ret = av7110_fe_lock_fix(av7110, 0);
2054 av7110->saved_minicmd = minicmd;
2055 ret = av7110->fe_diseqc_send_burst(fe, minicmd);
2060 static int av7110_fe_set_tone(struct dvb_frontend *fe,
2061 enum fe_sec_tone_mode tone)
2063 struct av7110* av7110 = fe->dvb->priv;
2065 int ret = av7110_fe_lock_fix(av7110, 0);
2067 av7110->saved_tone = tone;
2068 ret = av7110->fe_set_tone(fe, tone);
2073 static int av7110_fe_set_voltage(struct dvb_frontend *fe,
2074 enum fe_sec_voltage voltage)
2076 struct av7110* av7110 = fe->dvb->priv;
2078 int ret = av7110_fe_lock_fix(av7110, 0);
2080 av7110->saved_voltage = voltage;
2081 ret = av7110->fe_set_voltage(fe, voltage);
2086 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned long cmd)
2088 struct av7110* av7110 = fe->dvb->priv;
2090 int ret = av7110_fe_lock_fix(av7110, 0);
2092 ret = av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
2096 static void dvb_s_recover(struct av7110* av7110)
2098 av7110_fe_init(av7110->fe);
2100 av7110_fe_set_voltage(av7110->fe, av7110->saved_voltage);
2101 if (av7110->saved_master_cmd.msg_len) {
2103 av7110_fe_diseqc_send_master_cmd(av7110->fe, &av7110->saved_master_cmd);
2106 av7110_fe_diseqc_send_burst(av7110->fe, av7110->saved_minicmd);
2108 av7110_fe_set_tone(av7110->fe, av7110->saved_tone);
2110 av7110_fe_set_frontend(av7110->fe);
2113 static u8 read_pwm(struct av7110* av7110)
2117 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
2118 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
2120 if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
2126 static int frontend_init(struct av7110 *av7110)
2130 if (av7110->dev->pci->subsystem_vendor == 0x110a) {
2131 switch(av7110->dev->pci->subsystem_device) {
2132 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
2133 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config,
2134 &av7110->i2c_adap, read_pwm(av7110));
2136 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2141 } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
2142 switch(av7110->dev->pci->subsystem_device) {
2143 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
2144 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
2145 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
2147 // try the ALPS BSRV2 first of all
2148 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2150 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2151 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2152 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2153 av7110->fe->ops.set_tone = av7110_set_tone;
2154 av7110->recover = dvb_s_recover;
2158 // try the ALPS BSRU6 now
2159 av7110->fe = dvb_attach(stv0299_attach, &alps_bsru6_config, &av7110->i2c_adap);
2161 av7110->fe->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
2162 av7110->fe->tuner_priv = &av7110->i2c_adap;
2164 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2165 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2166 av7110->fe->ops.set_tone = av7110_set_tone;
2167 av7110->recover = dvb_s_recover;
2171 // Try the grundig 29504-451
2172 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2174 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2175 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2176 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2177 av7110->fe->ops.set_tone = av7110_set_tone;
2178 av7110->recover = dvb_s_recover;
2182 /* Try DVB-C cards */
2183 switch(av7110->dev->pci->subsystem_device) {
2185 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
2186 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config, &av7110->i2c_adap,
2189 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2193 /* Hauppauge DVB-C 2.1 VES1820/ALPS TDBE2 */
2194 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap,
2197 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2203 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
2204 // try ALPS TDLB7 first, then Grundig 29504-401
2205 av7110->fe = dvb_attach(sp8870_attach, &alps_tdlb7_config, &av7110->i2c_adap);
2207 av7110->fe->ops.tuner_ops.set_params = alps_tdlb7_tuner_set_params;
2212 case 0x0008: // Hauppauge/TT DVB-T
2213 // Grundig 29504-401
2214 av7110->fe = dvb_attach(l64781_attach, &grundig_29504_401_config, &av7110->i2c_adap);
2216 av7110->fe->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params;
2219 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
2221 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
2223 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2227 case 0x0004: // Galaxis DVB-S rev1.3
2229 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2231 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2232 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2233 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2234 av7110->fe->ops.set_tone = av7110_set_tone;
2235 av7110->recover = dvb_s_recover;
2239 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
2240 /* Grundig 29504-451 */
2241 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2243 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2244 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2245 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2246 av7110->fe->ops.set_tone = av7110_set_tone;
2247 av7110->recover = dvb_s_recover;
2251 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
2253 av7110->fe = dvb_attach(stv0297_attach, &nexusca_stv0297_config, &av7110->i2c_adap);
2255 av7110->fe->ops.tuner_ops.set_params = nexusca_stv0297_tuner_set_params;
2257 /* set TDA9819 into DVB mode */
2258 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
2259 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
2261 /* tuner on this needs a slower i2c bus speed */
2262 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
2267 case 0x000E: /* Hauppauge/TT Nexus-S rev 2.3 */
2269 av7110->fe = dvb_attach(stv0299_attach, &alps_bsbe1_config, &av7110->i2c_adap);
2271 av7110->fe->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
2272 av7110->fe->tuner_priv = &av7110->i2c_adap;
2274 if (dvb_attach(lnbp21_attach, av7110->fe, &av7110->i2c_adap, 0, 0) == NULL) {
2275 printk("dvb-ttpci: LNBP21 not found!\n");
2276 if (av7110->fe->ops.release)
2277 av7110->fe->ops.release(av7110->fe);
2280 av7110->fe->ops.dishnetwork_send_legacy_command = NULL;
2281 av7110->recover = dvb_s_recover;
2289 /* FIXME: propagate the failure code from the lower layers */
2291 printk("dvb-ttpci: A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
2292 av7110->dev->pci->vendor,
2293 av7110->dev->pci->device,
2294 av7110->dev->pci->subsystem_vendor,
2295 av7110->dev->pci->subsystem_device);
2297 FE_FUNC_OVERRIDE(av7110->fe->ops.init, av7110->fe_init, av7110_fe_init);
2298 FE_FUNC_OVERRIDE(av7110->fe->ops.read_status, av7110->fe_read_status, av7110_fe_read_status);
2299 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
2300 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
2301 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
2302 FE_FUNC_OVERRIDE(av7110->fe->ops.set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
2303 FE_FUNC_OVERRIDE(av7110->fe->ops.set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage);
2304 FE_FUNC_OVERRIDE(av7110->fe->ops.dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
2305 FE_FUNC_OVERRIDE(av7110->fe->ops.set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
2307 ret = dvb_register_frontend(&av7110->dvb_adapter, av7110->fe);
2309 printk("av7110: Frontend registration failed!\n");
2310 dvb_frontend_detach(av7110->fe);
2317 /* Budgetpatch note:
2318 * Original hardware design by Roberto Deza:
2319 * There is a DVB_Wiki at
2320 * http://www.linuxtv.org/
2322 * New software triggering design by Emard that works on
2323 * original Roberto Deza's hardware:
2325 * rps1 code for budgetpatch will copy internal HS event to GPIO3 pin.
2326 * GPIO3 is in budget-patch hardware connectd to port B VSYNC
2327 * HS is an internal event of 7146, accessible with RPS
2328 * and temporarily raised high every n lines
2329 * (n in defined in the RPS_THRESH1 counter threshold)
2330 * I think HS is raised high on the beginning of the n-th line
2331 * and remains high until this n-th line that triggered
2332 * it is completely received. When the receiption of n-th line
2333 * ends, HS is lowered.
2335 * To transmit data over DMA, 7146 needs changing state at
2336 * port B VSYNC pin. Any changing of port B VSYNC will
2337 * cause some DMA data transfer, with more or less packets loss.
2338 * It depends on the phase and frequency of VSYNC and
2339 * the way of 7146 is instructed to trigger on port B (defined
2340 * in DD1_INIT register, 3rd nibble from the right valid
2341 * numbers are 0-7, see datasheet)
2343 * The correct triggering can minimize packet loss,
2344 * dvbtraffic should give this stable bandwidths:
2345 * 22k transponder = 33814 kbit/s
2346 * 27.5k transponder = 38045 kbit/s
2347 * by experiment it is found that the best results
2348 * (stable bandwidths and almost no packet loss)
2349 * are obtained using DD1_INIT triggering number 2
2350 * (Va at rising edge of VS Fa = HS x VS-failing forced toggle)
2351 * and a VSYNC phase that occurs in the middle of DMA transfer
2352 * (about byte 188*512=96256 in the DMA window).
2354 * Phase of HS is still not clear to me how to control,
2355 * It just happens to be so. It can be seen if one enables
2356 * RPS_IRQ and print Event Counter 1 in vpeirq(). Every
2357 * time RPS_INTERRUPT is called, the Event Counter 1 will
2358 * increment. That's how the 7146 is programmed to do event
2359 * counting in this budget-patch.c
2360 * I *think* HPS setting has something to do with the phase
2361 * of HS but I can't be 100% sure in that.
2363 * hardware debug note: a working budget card (including budget patch)
2364 * with vpeirq() interrupt setup in mode "0x90" (every 64K) will
2365 * generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes
2366 * and that means 3*25=75 Hz of interrupt freqency, as seen by
2367 * watch cat /proc/interrupts
2369 * If this frequency is 3x lower (and data received in the DMA
2370 * buffer don't start with 0x47, but in the middle of packets,
2371 * whose lengths appear to be like 188 292 188 104 etc.
2372 * this means VSYNC line is not connected in the hardware.
2373 * (check soldering pcb and pins)
2374 * The same behaviour of missing VSYNC can be duplicated on budget
2375 * cards, by seting DD1_INIT trigger mode 7 in 3rd nibble.
2377 static int av7110_attach(struct saa7146_dev* dev,
2378 struct saa7146_pci_extension_data *pci_ext)
2380 const int length = TS_WIDTH * TS_HEIGHT;
2381 struct pci_dev *pdev = dev->pci;
2382 struct av7110 *av7110;
2383 struct task_struct *thread;
2386 dprintk(4, "dev: %p\n", dev);
2388 /* Set RPS_IRQ to 1 to track rps1 activity.
2389 * Enabling this won't send any interrupt to PC CPU.
2393 if (budgetpatch == 1) {
2395 /* autodetect the presence of budget patch
2396 * this only works if saa7146 has been recently
2397 * reset with with MASK_31 to MC1
2399 * will wait for VBI_B event (vertical blank at port B)
2400 * and will reset GPIO3 after VBI_B is detected.
2401 * (GPIO3 should be raised high by CPU to
2402 * test if GPIO3 will generate vertical blank signal
2403 * in budget patch GPIO3 is connected to VSYNC_B
2407 saa7146_write(dev, MC1, MASK_31);
2408 /* autodetection success seems to be time-dependend after reset */
2410 /* Fix VSYNC level */
2411 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2412 /* set vsync_b triggering */
2413 saa7146_write(dev, DD1_STREAM_B, 0);
2414 /* port B VSYNC at rising edge */
2415 saa7146_write(dev, DD1_INIT, 0x00000200);
2416 saa7146_write(dev, BRS_CTRL, 0x00000000); // VBI
2417 saa7146_write(dev, MC2,
2418 1 * (MASK_08 | MASK_24) | // BRS control
2419 0 * (MASK_09 | MASK_25) | // a
2420 1 * (MASK_10 | MASK_26) | // b
2421 0 * (MASK_06 | MASK_22) | // HPS_CTRL1
2422 0 * (MASK_05 | MASK_21) | // HPS_CTRL2
2423 0 * (MASK_01 | MASK_15) // DEBI
2426 /* start writing RPS1 code from beginning */
2429 saa7146_write(dev, MC1, MASK_29);
2430 /* RPS1 timeout disable */
2431 saa7146_write(dev, RPS_TOV1, 0);
2432 WRITE_RPS1(CMD_PAUSE | EVT_VBI_B);
2433 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2434 WRITE_RPS1(GPIO3_MSK);
2435 WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2437 /* issue RPS1 interrupt to increment counter */
2438 WRITE_RPS1(CMD_INTERRUPT);
2440 WRITE_RPS1(CMD_STOP);
2441 /* Jump to begin of RPS program as safety measure (p37) */
2442 WRITE_RPS1(CMD_JUMP);
2443 WRITE_RPS1(dev->d_rps1.dma_handle);
2446 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2447 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2448 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2450 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2451 /* set event counter 1 threshold to maximum allowed value (rEC p55) */
2452 saa7146_write(dev, ECT1R, 0x3fff );
2454 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2455 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2456 /* Enable RPS1, (rFC p33) */
2457 saa7146_write(dev, MC1, (MASK_13 | MASK_29 ));
2460 /* now send VSYNC_B to rps1 by rising GPIO3 */
2461 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI);
2463 /* if rps1 responded by lowering the GPIO3,
2464 * then we have budgetpatch hardware
2466 if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) {
2468 printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2471 saa7146_write(dev, MC1, ( MASK_29 ));
2473 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff );
2477 /* prepare the av7110 device struct */
2478 av7110 = kzalloc(sizeof(struct av7110), GFP_KERNEL);
2480 dprintk(1, "out of memory\n");
2484 av7110->card_name = (char*) pci_ext->ext_priv;
2486 dev->ext_priv = av7110;
2488 ret = get_firmware(av7110);
2492 ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name,
2493 THIS_MODULE, &dev->pci->dev, adapter_nr);
2495 goto err_put_firmware_1;
2497 /* the Siemens DVB needs this if you want to have the i2c chips
2498 get recognized before the main driver is fully loaded */
2499 saa7146_write(dev, GPIO_CTRL, 0x500000);
2501 strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
2503 saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
2505 ret = i2c_add_adapter(&av7110->i2c_adap);
2507 goto err_dvb_unregister_adapter_2;
2509 ttpci_eeprom_parse_mac(&av7110->i2c_adap,
2510 av7110->dvb_adapter.proposed_mac);
2515 av7110->full_ts = true;
2517 /* check for full-ts flag in eeprom */
2518 if (i2c_readreg(av7110, 0xaa, 0) == 0x4f && i2c_readreg(av7110, 0xaa, 1) == 0x45) {
2519 u8 flags = i2c_readreg(av7110, 0xaa, 2);
2520 if (flags != 0xff && (flags & 0x01))
2521 av7110->full_ts = true;
2524 if (av7110->full_ts) {
2525 printk(KERN_INFO "dvb-ttpci: full-ts mode enabled for saa7146 port B\n");
2526 spin_lock_init(&av7110->feedlock1);
2527 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2529 if (!av7110->grabbing)
2532 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2533 saa7146_write(dev, MC2, (MASK_10 | MASK_26));
2535 saa7146_write(dev, DD1_INIT, 0x00000600);
2536 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2538 saa7146_write(dev, BRS_CTRL, 0x60000000);
2539 saa7146_write(dev, MC2, MASK_08 | MASK_24);
2542 saa7146_write(dev, PCI_BT_V1, 0x001c0000 | (saa7146_read(dev, PCI_BT_V1) & ~0x001f0000));
2543 saa7146_write(dev, BASE_ODD3, 0);
2544 saa7146_write(dev, BASE_EVEN3, 0);
2545 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2546 saa7146_write(dev, PITCH3, TS_WIDTH);
2547 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2548 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2549 saa7146_write(dev, MC2, MASK_04 | MASK_20);
2551 tasklet_init(&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2553 } else if (budgetpatch) {
2554 spin_lock_init(&av7110->feedlock1);
2555 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2557 if (!av7110->grabbing)
2560 saa7146_write(dev, PCI_BT_V1, 0x1c1f101f);
2561 saa7146_write(dev, BCS_CTRL, 0x80400040);
2562 /* set dd1 stream a & b */
2563 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2564 saa7146_write(dev, DD1_INIT, 0x03000200);
2565 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2566 saa7146_write(dev, BRS_CTRL, 0x60000000);
2567 saa7146_write(dev, BASE_ODD3, 0);
2568 saa7146_write(dev, BASE_EVEN3, 0);
2569 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2570 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2572 saa7146_write(dev, PITCH3, TS_WIDTH);
2573 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2576 saa7146_write(dev, MC2, 0x077c077c);
2577 saa7146_write(dev, GPIO_CTRL, 0x000000);
2579 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2580 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2581 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2583 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2584 /* set event counter 1 threshold to maximum allowed value (rEC p55) */
2585 saa7146_write(dev, ECT1R, 0x3fff );
2587 /* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */
2590 /* Wait Source Line Counter Threshold (p36) */
2591 WRITE_RPS1(CMD_PAUSE | EVT_HS);
2592 /* Set GPIO3=1 (p42) */
2593 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2594 WRITE_RPS1(GPIO3_MSK);
2595 WRITE_RPS1(SAA7146_GPIO_OUTHI<<24);
2597 /* issue RPS1 interrupt */
2598 WRITE_RPS1(CMD_INTERRUPT);
2600 /* Wait reset Source Line Counter Threshold (p36) */
2601 WRITE_RPS1(CMD_PAUSE | RPS_INV | EVT_HS);
2602 /* Set GPIO3=0 (p42) */
2603 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2604 WRITE_RPS1(GPIO3_MSK);
2605 WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2607 /* issue RPS1 interrupt */
2608 WRITE_RPS1(CMD_INTERRUPT);
2610 /* Jump to begin of RPS program (p37) */
2611 WRITE_RPS1(CMD_JUMP);
2612 WRITE_RPS1(dev->d_rps1.dma_handle);
2614 /* Fix VSYNC level */
2615 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2616 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2617 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2618 /* Set Source Line Counter Threshold, using BRS (rCC p43)
2619 * It generates HS event every TS_HEIGHT lines
2620 * this is related to TS_WIDTH set in register
2621 * NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits
2622 * are set to TS_WIDTH bytes (TS_WIDTH=2*188),
2623 * then RPS_THRESH1 should be set to trigger
2624 * every TS_HEIGHT (512) lines.
2626 saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 );
2628 /* Enable RPS1 (rFC p33) */
2629 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
2631 /* end of budgetpatch register initialization */
2632 tasklet_init (&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2634 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
2635 saa7146_write(dev, BCS_CTRL, 0x80400040);
2637 /* set dd1 stream a & b */
2638 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2639 saa7146_write(dev, DD1_INIT, 0x03000000);
2640 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2643 saa7146_write(dev, MC2, 0x077c077c);
2644 saa7146_write(dev, GPIO_CTRL, 0x000000);
2647 tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2648 tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2650 mutex_init(&av7110->pid_mutex);
2652 /* locks for data transfers from/to AV7110 */
2653 spin_lock_init(&av7110->debilock);
2654 mutex_init(&av7110->dcomlock);
2655 av7110->debitype = -1;
2657 /* default OSD window */
2659 mutex_init(&av7110->osd_mutex);
2662 av7110->vidmode = tv_standard == 1 ? AV7110_VIDEO_MODE_NTSC
2663 : AV7110_VIDEO_MODE_PAL;
2665 /* ARM "watchdog" */
2666 init_waitqueue_head(&av7110->arm_wait);
2667 av7110->arm_thread = NULL;
2669 /* allocate and init buffers */
2670 av7110->debi_virt = pci_alloc_consistent(pdev, 8192, &av7110->debi_bus);
2671 if (!av7110->debi_virt)
2672 goto err_saa71466_vfree_4;
2675 av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2677 goto err_pci_free_5;
2679 ret = av7110_av_init(av7110);
2681 goto err_iobuf_vfree_6;
2683 /* init BMP buffer */
2684 av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN;
2685 init_waitqueue_head(&av7110->bmpq);
2687 ret = av7110_ca_init(av7110);
2689 goto err_av7110_av_exit_7;
2691 /* load firmware into AV7110 cards */
2692 ret = av7110_bootarm(av7110);
2694 goto err_av7110_ca_exit_8;
2696 ret = av7110_firmversion(av7110);
2698 goto err_stop_arm_9;
2700 if (FW_VERSION(av7110->arm_app)<0x2501)
2701 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2702 "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2704 thread = kthread_run(arm_thread, (void *) av7110, "arm_mon");
2705 if (IS_ERR(thread)) {
2706 ret = PTR_ERR(thread);
2707 goto err_stop_arm_9;
2709 av7110->arm_thread = thread;
2711 /* set initial volume in mixer struct */
2712 av7110->mixer.volume_left = volume;
2713 av7110->mixer.volume_right = volume;
2715 ret = av7110_register(av7110);
2717 goto err_arm_thread_stop_10;
2719 init_av7110_av(av7110);
2721 /* special case DVB-C: these cards have an analog tuner
2722 plus need some special handling, so we have separate
2723 saa7146_ext_vv data for these... */
2724 ret = av7110_init_v4l(av7110);
2726 goto err_av7110_unregister_11;
2728 av7110->dvb_adapter.priv = av7110;
2729 ret = frontend_init(av7110);
2731 goto err_av7110_exit_v4l_12;
2733 mutex_init(&av7110->ioctl_mutex);
2735 #if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2736 av7110_ir_init(av7110);
2738 printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2743 err_av7110_exit_v4l_12:
2744 av7110_exit_v4l(av7110);
2745 err_av7110_unregister_11:
2746 dvb_unregister(av7110);
2747 err_arm_thread_stop_10:
2748 av7110_arm_sync(av7110);
2750 /* Nothing to do. Rejoice. */
2751 err_av7110_ca_exit_8:
2752 av7110_ca_exit(av7110);
2753 err_av7110_av_exit_7:
2754 av7110_av_exit(av7110);
2756 vfree(av7110->iobuf);
2758 pci_free_consistent(pdev, 8192, av7110->debi_virt, av7110->debi_bus);
2759 err_saa71466_vfree_4:
2760 if (av7110->grabbing)
2761 saa7146_vfree_destroy_pgtable(pdev, av7110->grabbing, &av7110->pt);
2763 i2c_del_adapter(&av7110->i2c_adap);
2764 err_dvb_unregister_adapter_2:
2765 dvb_unregister_adapter(&av7110->dvb_adapter);
2767 put_firmware(av7110);
2773 static int av7110_detach(struct saa7146_dev* saa)
2775 struct av7110 *av7110 = saa->ext_priv;
2776 dprintk(4, "%p\n", av7110);
2778 #if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2779 av7110_ir_exit(av7110);
2781 if (budgetpatch || av7110->full_ts) {
2784 saa7146_write(saa, MC1, MASK_29);
2785 /* VSYNC LOW (inactive) */
2786 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
2788 saa7146_write(saa, MC1, MASK_20); /* DMA3 off */
2789 SAA7146_IER_DISABLE(saa, MASK_10);
2790 SAA7146_ISR_CLEAR(saa, MASK_10);
2792 tasklet_kill(&av7110->vpe_tasklet);
2793 saa7146_vfree_destroy_pgtable(saa->pci, av7110->grabbing, &av7110->pt);
2795 av7110_exit_v4l(av7110);
2797 av7110_arm_sync(av7110);
2799 tasklet_kill(&av7110->debi_tasklet);
2800 tasklet_kill(&av7110->gpio_tasklet);
2802 dvb_unregister(av7110);
2804 SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2805 SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2807 av7110_ca_exit(av7110);
2808 av7110_av_exit(av7110);
2810 vfree(av7110->iobuf);
2811 pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2814 i2c_del_adapter(&av7110->i2c_adap);
2816 dvb_unregister_adapter (&av7110->dvb_adapter);
2820 put_firmware(av7110);
2824 saa->ext_priv = NULL;
2830 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2832 struct av7110 *av7110 = dev->ext_priv;
2834 //print_time("av7110_irq");
2836 /* Note: Don't try to handle the DEBI error irq (MASK_18), in
2837 * intel mode the timeout is asserted all the time...
2840 if (*isr & MASK_19) {
2841 //printk("av7110_irq: DEBI\n");
2842 /* Note 1: The DEBI irq is level triggered: We must enable it
2843 * only after we started a DMA xfer, and disable it here
2844 * immediately, or it will be signalled all the time while
2846 * Note 2: You would think that an irq which is masked is
2847 * not signalled by the hardware. Not so for the SAA7146:
2848 * An irq is signalled as long as the corresponding bit
2849 * in the ISR is set, and disabling irqs just prevents the
2850 * hardware from setting the ISR bit. This means a) that we
2851 * must clear the ISR *after* disabling the irq (which is why
2852 * we must do it here even though saa7146_core did it already),
2853 * and b) that if we were to disable an edge triggered irq
2854 * (like the gpio irqs sadly are) temporarily we would likely
2855 * loose some. This sucks :-(
2857 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
2858 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
2859 tasklet_schedule(&av7110->debi_tasklet);
2862 if (*isr & MASK_03) {
2863 //printk("av7110_irq: GPIO\n");
2864 tasklet_schedule(&av7110->gpio_tasklet);
2868 tasklet_schedule(&av7110->vpe_tasklet);
2872 static struct saa7146_extension av7110_extension_driver;
2874 #define MAKE_AV7110_INFO(x_var,x_name) \
2875 static struct saa7146_pci_extension_data x_var = { \
2876 .ext_priv = x_name, \
2877 .ext = &av7110_extension_driver }
2879 MAKE_AV7110_INFO(tts_1_X_fsc,"Technotrend/Hauppauge WinTV DVB-S rev1.X or Fujitsu Siemens DVB-C");
2880 MAKE_AV7110_INFO(ttt_1_X, "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2881 MAKE_AV7110_INFO(ttc_1_X, "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2882 MAKE_AV7110_INFO(ttc_2_X, "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2883 MAKE_AV7110_INFO(tts_2_X, "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2884 MAKE_AV7110_INFO(tts_2_3, "Technotrend/Hauppauge WinTV Nexus-S rev2.3");
2885 MAKE_AV7110_INFO(tts_1_3se, "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2886 MAKE_AV7110_INFO(ttt, "Technotrend/Hauppauge DVB-T");
2887 MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C");
2888 MAKE_AV7110_INFO(fss, "Fujitsu Siemens DVB-S rev1.6");
2889 MAKE_AV7110_INFO(gxs_1_3, "Galaxis DVB-S rev1.3");
2891 static struct pci_device_id pci_tbl[] = {
2892 MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000),
2893 MAKE_EXTENSION_PCI(tts_1_X_fsc, 0x13c2, 0x0000),
2894 MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001),
2895 MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002),
2896 MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003),
2897 MAKE_EXTENSION_PCI(gxs_1_3, 0x13c2, 0x0004),
2898 MAKE_EXTENSION_PCI(fss, 0x13c2, 0x0006),
2899 MAKE_EXTENSION_PCI(ttt, 0x13c2, 0x0008),
2900 MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a),
2901 MAKE_EXTENSION_PCI(tts_2_3, 0x13c2, 0x000e),
2902 MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002),
2904 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2905 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2912 MODULE_DEVICE_TABLE(pci, pci_tbl);
2915 static struct saa7146_extension av7110_extension_driver = {
2917 .flags = SAA7146_USE_I2C_IRQ,
2919 .module = THIS_MODULE,
2920 .pci_tbl = &pci_tbl[0],
2921 .attach = av7110_attach,
2922 .detach = av7110_detach,
2924 .irq_mask = MASK_19 | MASK_03 | MASK_10,
2925 .irq_func = av7110_irq,
2929 static int __init av7110_init(void)
2932 retval = saa7146_register_extension(&av7110_extension_driver);
2937 static void __exit av7110_exit(void)
2939 saa7146_unregister_extension(&av7110_extension_driver);
2942 module_init(av7110_init);
2943 module_exit(av7110_exit);
2945 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2946 "Siemens, Technotrend, Hauppauge");
2947 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2948 MODULE_LICENSE("GPL");