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
, fe_sec_tone_mode_t 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 fe_sec_mini_cmd_t 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
, fe_status_t 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
, fe_status_t
* status
)
2013 struct av7110
* av7110
= fe
->dvb
->priv
;
2015 /* call the real implementation */
2016 int ret
= av7110
->fe_read_status(fe
, status
);
2018 if (((*status
^ av7110
->fe_status
) & FE_HAS_LOCK
) && (*status
& FE_HAS_LOCK
))
2019 ret
= av7110_fe_lock_fix(av7110
, *status
);
2023 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend
* fe
)
2025 struct av7110
* av7110
= fe
->dvb
->priv
;
2027 int ret
= av7110_fe_lock_fix(av7110
, 0);
2029 ret
= av7110
->fe_diseqc_reset_overload(fe
);
2033 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend
* fe
,
2034 struct dvb_diseqc_master_cmd
* cmd
)
2036 struct av7110
* av7110
= fe
->dvb
->priv
;
2038 int ret
= av7110_fe_lock_fix(av7110
, 0);
2040 av7110
->saved_master_cmd
= *cmd
;
2041 ret
= av7110
->fe_diseqc_send_master_cmd(fe
, cmd
);
2046 static int av7110_fe_diseqc_send_burst(struct dvb_frontend
* fe
, fe_sec_mini_cmd_t minicmd
)
2048 struct av7110
* av7110
= fe
->dvb
->priv
;
2050 int ret
= av7110_fe_lock_fix(av7110
, 0);
2052 av7110
->saved_minicmd
= minicmd
;
2053 ret
= av7110
->fe_diseqc_send_burst(fe
, minicmd
);
2058 static int av7110_fe_set_tone(struct dvb_frontend
* fe
, fe_sec_tone_mode_t tone
)
2060 struct av7110
* av7110
= fe
->dvb
->priv
;
2062 int ret
= av7110_fe_lock_fix(av7110
, 0);
2064 av7110
->saved_tone
= tone
;
2065 ret
= av7110
->fe_set_tone(fe
, tone
);
2070 static int av7110_fe_set_voltage(struct dvb_frontend
* fe
, fe_sec_voltage_t voltage
)
2072 struct av7110
* av7110
= fe
->dvb
->priv
;
2074 int ret
= av7110_fe_lock_fix(av7110
, 0);
2076 av7110
->saved_voltage
= voltage
;
2077 ret
= av7110
->fe_set_voltage(fe
, voltage
);
2082 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend
* fe
, unsigned long cmd
)
2084 struct av7110
* av7110
= fe
->dvb
->priv
;
2086 int ret
= av7110_fe_lock_fix(av7110
, 0);
2088 ret
= av7110
->fe_dishnetwork_send_legacy_command(fe
, cmd
);
2092 static void dvb_s_recover(struct av7110
* av7110
)
2094 av7110_fe_init(av7110
->fe
);
2096 av7110_fe_set_voltage(av7110
->fe
, av7110
->saved_voltage
);
2097 if (av7110
->saved_master_cmd
.msg_len
) {
2099 av7110_fe_diseqc_send_master_cmd(av7110
->fe
, &av7110
->saved_master_cmd
);
2102 av7110_fe_diseqc_send_burst(av7110
->fe
, av7110
->saved_minicmd
);
2104 av7110_fe_set_tone(av7110
->fe
, av7110
->saved_tone
);
2106 av7110_fe_set_frontend(av7110
->fe
);
2109 static u8
read_pwm(struct av7110
* av7110
)
2113 struct i2c_msg msg
[] = { { .addr
= 0x50,.flags
= 0,.buf
= &b
,.len
= 1 },
2114 { .addr
= 0x50,.flags
= I2C_M_RD
,.buf
= &pwm
,.len
= 1} };
2116 if ((i2c_transfer(&av7110
->i2c_adap
, msg
, 2) != 2) || (pwm
== 0xff))
2122 static int frontend_init(struct av7110
*av7110
)
2126 if (av7110
->dev
->pci
->subsystem_vendor
== 0x110a) {
2127 switch(av7110
->dev
->pci
->subsystem_device
) {
2128 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
2129 av7110
->fe
= dvb_attach(ves1820_attach
, &philips_cd1516_config
,
2130 &av7110
->i2c_adap
, read_pwm(av7110
));
2132 av7110
->fe
->ops
.tuner_ops
.set_params
= philips_cd1516_tuner_set_params
;
2137 } else if (av7110
->dev
->pci
->subsystem_vendor
== 0x13c2) {
2138 switch(av7110
->dev
->pci
->subsystem_device
) {
2139 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
2140 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
2141 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
2143 // try the ALPS BSRV2 first of all
2144 av7110
->fe
= dvb_attach(ves1x93_attach
, &alps_bsrv2_config
, &av7110
->i2c_adap
);
2146 av7110
->fe
->ops
.tuner_ops
.set_params
= alps_bsrv2_tuner_set_params
;
2147 av7110
->fe
->ops
.diseqc_send_master_cmd
= av7110_diseqc_send_master_cmd
;
2148 av7110
->fe
->ops
.diseqc_send_burst
= av7110_diseqc_send_burst
;
2149 av7110
->fe
->ops
.set_tone
= av7110_set_tone
;
2150 av7110
->recover
= dvb_s_recover
;
2154 // try the ALPS BSRU6 now
2155 av7110
->fe
= dvb_attach(stv0299_attach
, &alps_bsru6_config
, &av7110
->i2c_adap
);
2157 av7110
->fe
->ops
.tuner_ops
.set_params
= alps_bsru6_tuner_set_params
;
2158 av7110
->fe
->tuner_priv
= &av7110
->i2c_adap
;
2160 av7110
->fe
->ops
.diseqc_send_master_cmd
= av7110_diseqc_send_master_cmd
;
2161 av7110
->fe
->ops
.diseqc_send_burst
= av7110_diseqc_send_burst
;
2162 av7110
->fe
->ops
.set_tone
= av7110_set_tone
;
2163 av7110
->recover
= dvb_s_recover
;
2167 // Try the grundig 29504-451
2168 av7110
->fe
= dvb_attach(tda8083_attach
, &grundig_29504_451_config
, &av7110
->i2c_adap
);
2170 av7110
->fe
->ops
.tuner_ops
.set_params
= grundig_29504_451_tuner_set_params
;
2171 av7110
->fe
->ops
.diseqc_send_master_cmd
= av7110_diseqc_send_master_cmd
;
2172 av7110
->fe
->ops
.diseqc_send_burst
= av7110_diseqc_send_burst
;
2173 av7110
->fe
->ops
.set_tone
= av7110_set_tone
;
2174 av7110
->recover
= dvb_s_recover
;
2178 /* Try DVB-C cards */
2179 switch(av7110
->dev
->pci
->subsystem_device
) {
2181 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
2182 av7110
->fe
= dvb_attach(ves1820_attach
, &philips_cd1516_config
, &av7110
->i2c_adap
,
2185 av7110
->fe
->ops
.tuner_ops
.set_params
= philips_cd1516_tuner_set_params
;
2189 /* Hauppauge DVB-C 2.1 VES1820/ALPS TDBE2 */
2190 av7110
->fe
= dvb_attach(ves1820_attach
, &alps_tdbe2_config
, &av7110
->i2c_adap
,
2193 av7110
->fe
->ops
.tuner_ops
.set_params
= alps_tdbe2_tuner_set_params
;
2199 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
2200 // try ALPS TDLB7 first, then Grundig 29504-401
2201 av7110
->fe
= dvb_attach(sp8870_attach
, &alps_tdlb7_config
, &av7110
->i2c_adap
);
2203 av7110
->fe
->ops
.tuner_ops
.set_params
= alps_tdlb7_tuner_set_params
;
2208 case 0x0008: // Hauppauge/TT DVB-T
2209 // Grundig 29504-401
2210 av7110
->fe
= dvb_attach(l64781_attach
, &grundig_29504_401_config
, &av7110
->i2c_adap
);
2212 av7110
->fe
->ops
.tuner_ops
.set_params
= grundig_29504_401_tuner_set_params
;
2215 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
2217 av7110
->fe
= dvb_attach(ves1820_attach
, &alps_tdbe2_config
, &av7110
->i2c_adap
, read_pwm(av7110
));
2219 av7110
->fe
->ops
.tuner_ops
.set_params
= alps_tdbe2_tuner_set_params
;
2223 case 0x0004: // Galaxis DVB-S rev1.3
2225 av7110
->fe
= dvb_attach(ves1x93_attach
, &alps_bsrv2_config
, &av7110
->i2c_adap
);
2227 av7110
->fe
->ops
.tuner_ops
.set_params
= alps_bsrv2_tuner_set_params
;
2228 av7110
->fe
->ops
.diseqc_send_master_cmd
= av7110_diseqc_send_master_cmd
;
2229 av7110
->fe
->ops
.diseqc_send_burst
= av7110_diseqc_send_burst
;
2230 av7110
->fe
->ops
.set_tone
= av7110_set_tone
;
2231 av7110
->recover
= dvb_s_recover
;
2235 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
2236 /* Grundig 29504-451 */
2237 av7110
->fe
= dvb_attach(tda8083_attach
, &grundig_29504_451_config
, &av7110
->i2c_adap
);
2239 av7110
->fe
->ops
.tuner_ops
.set_params
= grundig_29504_451_tuner_set_params
;
2240 av7110
->fe
->ops
.diseqc_send_master_cmd
= av7110_diseqc_send_master_cmd
;
2241 av7110
->fe
->ops
.diseqc_send_burst
= av7110_diseqc_send_burst
;
2242 av7110
->fe
->ops
.set_tone
= av7110_set_tone
;
2243 av7110
->recover
= dvb_s_recover
;
2247 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
2249 av7110
->fe
= dvb_attach(stv0297_attach
, &nexusca_stv0297_config
, &av7110
->i2c_adap
);
2251 av7110
->fe
->ops
.tuner_ops
.set_params
= nexusca_stv0297_tuner_set_params
;
2253 /* set TDA9819 into DVB mode */
2254 saa7146_setgpio(av7110
->dev
, 1, SAA7146_GPIO_OUTLO
); // TDA9819 pin9(STD)
2255 saa7146_setgpio(av7110
->dev
, 3, SAA7146_GPIO_OUTLO
); // TDA9819 pin30(VIF)
2257 /* tuner on this needs a slower i2c bus speed */
2258 av7110
->dev
->i2c_bitrate
= SAA7146_I2C_BUS_BIT_RATE_240
;
2263 case 0x000E: /* Hauppauge/TT Nexus-S rev 2.3 */
2265 av7110
->fe
= dvb_attach(stv0299_attach
, &alps_bsbe1_config
, &av7110
->i2c_adap
);
2267 av7110
->fe
->ops
.tuner_ops
.set_params
= alps_bsbe1_tuner_set_params
;
2268 av7110
->fe
->tuner_priv
= &av7110
->i2c_adap
;
2270 if (dvb_attach(lnbp21_attach
, av7110
->fe
, &av7110
->i2c_adap
, 0, 0) == NULL
) {
2271 printk("dvb-ttpci: LNBP21 not found!\n");
2272 if (av7110
->fe
->ops
.release
)
2273 av7110
->fe
->ops
.release(av7110
->fe
);
2276 av7110
->fe
->ops
.dishnetwork_send_legacy_command
= NULL
;
2277 av7110
->recover
= dvb_s_recover
;
2285 /* FIXME: propagate the failure code from the lower layers */
2287 printk("dvb-ttpci: A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
2288 av7110
->dev
->pci
->vendor
,
2289 av7110
->dev
->pci
->device
,
2290 av7110
->dev
->pci
->subsystem_vendor
,
2291 av7110
->dev
->pci
->subsystem_device
);
2293 FE_FUNC_OVERRIDE(av7110
->fe
->ops
.init
, av7110
->fe_init
, av7110_fe_init
);
2294 FE_FUNC_OVERRIDE(av7110
->fe
->ops
.read_status
, av7110
->fe_read_status
, av7110_fe_read_status
);
2295 FE_FUNC_OVERRIDE(av7110
->fe
->ops
.diseqc_reset_overload
, av7110
->fe_diseqc_reset_overload
, av7110_fe_diseqc_reset_overload
);
2296 FE_FUNC_OVERRIDE(av7110
->fe
->ops
.diseqc_send_master_cmd
, av7110
->fe_diseqc_send_master_cmd
, av7110_fe_diseqc_send_master_cmd
);
2297 FE_FUNC_OVERRIDE(av7110
->fe
->ops
.diseqc_send_burst
, av7110
->fe_diseqc_send_burst
, av7110_fe_diseqc_send_burst
);
2298 FE_FUNC_OVERRIDE(av7110
->fe
->ops
.set_tone
, av7110
->fe_set_tone
, av7110_fe_set_tone
);
2299 FE_FUNC_OVERRIDE(av7110
->fe
->ops
.set_voltage
, av7110
->fe_set_voltage
, av7110_fe_set_voltage
);
2300 FE_FUNC_OVERRIDE(av7110
->fe
->ops
.dishnetwork_send_legacy_command
, av7110
->fe_dishnetwork_send_legacy_command
, av7110_fe_dishnetwork_send_legacy_command
);
2301 FE_FUNC_OVERRIDE(av7110
->fe
->ops
.set_frontend
, av7110
->fe_set_frontend
, av7110_fe_set_frontend
);
2303 ret
= dvb_register_frontend(&av7110
->dvb_adapter
, av7110
->fe
);
2305 printk("av7110: Frontend registration failed!\n");
2306 dvb_frontend_detach(av7110
->fe
);
2313 /* Budgetpatch note:
2314 * Original hardware design by Roberto Deza:
2315 * There is a DVB_Wiki at
2316 * http://www.linuxtv.org/
2318 * New software triggering design by Emard that works on
2319 * original Roberto Deza's hardware:
2321 * rps1 code for budgetpatch will copy internal HS event to GPIO3 pin.
2322 * GPIO3 is in budget-patch hardware connectd to port B VSYNC
2323 * HS is an internal event of 7146, accessible with RPS
2324 * and temporarily raised high every n lines
2325 * (n in defined in the RPS_THRESH1 counter threshold)
2326 * I think HS is raised high on the beginning of the n-th line
2327 * and remains high until this n-th line that triggered
2328 * it is completely received. When the receiption of n-th line
2329 * ends, HS is lowered.
2331 * To transmit data over DMA, 7146 needs changing state at
2332 * port B VSYNC pin. Any changing of port B VSYNC will
2333 * cause some DMA data transfer, with more or less packets loss.
2334 * It depends on the phase and frequency of VSYNC and
2335 * the way of 7146 is instructed to trigger on port B (defined
2336 * in DD1_INIT register, 3rd nibble from the right valid
2337 * numbers are 0-7, see datasheet)
2339 * The correct triggering can minimize packet loss,
2340 * dvbtraffic should give this stable bandwidths:
2341 * 22k transponder = 33814 kbit/s
2342 * 27.5k transponder = 38045 kbit/s
2343 * by experiment it is found that the best results
2344 * (stable bandwidths and almost no packet loss)
2345 * are obtained using DD1_INIT triggering number 2
2346 * (Va at rising edge of VS Fa = HS x VS-failing forced toggle)
2347 * and a VSYNC phase that occurs in the middle of DMA transfer
2348 * (about byte 188*512=96256 in the DMA window).
2350 * Phase of HS is still not clear to me how to control,
2351 * It just happens to be so. It can be seen if one enables
2352 * RPS_IRQ and print Event Counter 1 in vpeirq(). Every
2353 * time RPS_INTERRUPT is called, the Event Counter 1 will
2354 * increment. That's how the 7146 is programmed to do event
2355 * counting in this budget-patch.c
2356 * I *think* HPS setting has something to do with the phase
2357 * of HS but I can't be 100% sure in that.
2359 * hardware debug note: a working budget card (including budget patch)
2360 * with vpeirq() interrupt setup in mode "0x90" (every 64K) will
2361 * generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes
2362 * and that means 3*25=75 Hz of interrupt freqency, as seen by
2363 * watch cat /proc/interrupts
2365 * If this frequency is 3x lower (and data received in the DMA
2366 * buffer don't start with 0x47, but in the middle of packets,
2367 * whose lengths appear to be like 188 292 188 104 etc.
2368 * this means VSYNC line is not connected in the hardware.
2369 * (check soldering pcb and pins)
2370 * The same behaviour of missing VSYNC can be duplicated on budget
2371 * cards, by seting DD1_INIT trigger mode 7 in 3rd nibble.
2373 static int av7110_attach(struct saa7146_dev
* dev
,
2374 struct saa7146_pci_extension_data
*pci_ext
)
2376 const int length
= TS_WIDTH
* TS_HEIGHT
;
2377 struct pci_dev
*pdev
= dev
->pci
;
2378 struct av7110
*av7110
;
2379 struct task_struct
*thread
;
2382 dprintk(4, "dev: %p\n", dev
);
2384 /* Set RPS_IRQ to 1 to track rps1 activity.
2385 * Enabling this won't send any interrupt to PC CPU.
2389 if (budgetpatch
== 1) {
2391 /* autodetect the presence of budget patch
2392 * this only works if saa7146 has been recently
2393 * reset with with MASK_31 to MC1
2395 * will wait for VBI_B event (vertical blank at port B)
2396 * and will reset GPIO3 after VBI_B is detected.
2397 * (GPIO3 should be raised high by CPU to
2398 * test if GPIO3 will generate vertical blank signal
2399 * in budget patch GPIO3 is connected to VSYNC_B
2403 saa7146_write(dev
, MC1
, MASK_31
);
2404 /* autodetection success seems to be time-dependend after reset */
2406 /* Fix VSYNC level */
2407 saa7146_setgpio(dev
, 3, SAA7146_GPIO_OUTLO
);
2408 /* set vsync_b triggering */
2409 saa7146_write(dev
, DD1_STREAM_B
, 0);
2410 /* port B VSYNC at rising edge */
2411 saa7146_write(dev
, DD1_INIT
, 0x00000200);
2412 saa7146_write(dev
, BRS_CTRL
, 0x00000000); // VBI
2413 saa7146_write(dev
, MC2
,
2414 1 * (MASK_08
| MASK_24
) | // BRS control
2415 0 * (MASK_09
| MASK_25
) | // a
2416 1 * (MASK_10
| MASK_26
) | // b
2417 0 * (MASK_06
| MASK_22
) | // HPS_CTRL1
2418 0 * (MASK_05
| MASK_21
) | // HPS_CTRL2
2419 0 * (MASK_01
| MASK_15
) // DEBI
2422 /* start writing RPS1 code from beginning */
2425 saa7146_write(dev
, MC1
, MASK_29
);
2426 /* RPS1 timeout disable */
2427 saa7146_write(dev
, RPS_TOV1
, 0);
2428 WRITE_RPS1(CMD_PAUSE
| EVT_VBI_B
);
2429 WRITE_RPS1(CMD_WR_REG_MASK
| (GPIO_CTRL
>>2));
2430 WRITE_RPS1(GPIO3_MSK
);
2431 WRITE_RPS1(SAA7146_GPIO_OUTLO
<<24);
2433 /* issue RPS1 interrupt to increment counter */
2434 WRITE_RPS1(CMD_INTERRUPT
);
2436 WRITE_RPS1(CMD_STOP
);
2437 /* Jump to begin of RPS program as safety measure (p37) */
2438 WRITE_RPS1(CMD_JUMP
);
2439 WRITE_RPS1(dev
->d_rps1
.dma_handle
);
2442 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2443 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2444 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2446 saa7146_write(dev
, EC1SSR
, (0x03<<2) | 3 );
2447 /* set event counter 1 threshold to maximum allowed value (rEC p55) */
2448 saa7146_write(dev
, ECT1R
, 0x3fff );
2450 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2451 saa7146_write(dev
, RPS_ADDR1
, dev
->d_rps1
.dma_handle
);
2452 /* Enable RPS1, (rFC p33) */
2453 saa7146_write(dev
, MC1
, (MASK_13
| MASK_29
));
2456 /* now send VSYNC_B to rps1 by rising GPIO3 */
2457 saa7146_setgpio(dev
, 3, SAA7146_GPIO_OUTHI
);
2459 /* if rps1 responded by lowering the GPIO3,
2460 * then we have budgetpatch hardware
2462 if ((saa7146_read(dev
, GPIO_CTRL
) & 0x10000000) == 0) {
2464 printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2467 saa7146_write(dev
, MC1
, ( MASK_29
));
2469 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev
, EC1R
) & 0x3fff );
2473 /* prepare the av7110 device struct */
2474 av7110
= kzalloc(sizeof(struct av7110
), GFP_KERNEL
);
2476 dprintk(1, "out of memory\n");
2480 av7110
->card_name
= (char*) pci_ext
->ext_priv
;
2482 dev
->ext_priv
= av7110
;
2484 ret
= get_firmware(av7110
);
2488 ret
= dvb_register_adapter(&av7110
->dvb_adapter
, av7110
->card_name
,
2489 THIS_MODULE
, &dev
->pci
->dev
, adapter_nr
);
2491 goto err_put_firmware_1
;
2493 /* the Siemens DVB needs this if you want to have the i2c chips
2494 get recognized before the main driver is fully loaded */
2495 saa7146_write(dev
, GPIO_CTRL
, 0x500000);
2497 strlcpy(av7110
->i2c_adap
.name
, pci_ext
->ext_priv
, sizeof(av7110
->i2c_adap
.name
));
2499 saa7146_i2c_adapter_prepare(dev
, &av7110
->i2c_adap
, SAA7146_I2C_BUS_BIT_RATE_120
); /* 275 kHz */
2501 ret
= i2c_add_adapter(&av7110
->i2c_adap
);
2503 goto err_dvb_unregister_adapter_2
;
2505 ttpci_eeprom_parse_mac(&av7110
->i2c_adap
,
2506 av7110
->dvb_adapter
.proposed_mac
);
2511 av7110
->full_ts
= true;
2513 /* check for full-ts flag in eeprom */
2514 if (i2c_readreg(av7110
, 0xaa, 0) == 0x4f && i2c_readreg(av7110
, 0xaa, 1) == 0x45) {
2515 u8 flags
= i2c_readreg(av7110
, 0xaa, 2);
2516 if (flags
!= 0xff && (flags
& 0x01))
2517 av7110
->full_ts
= true;
2520 if (av7110
->full_ts
) {
2521 printk(KERN_INFO
"dvb-ttpci: full-ts mode enabled for saa7146 port B\n");
2522 spin_lock_init(&av7110
->feedlock1
);
2523 av7110
->grabbing
= saa7146_vmalloc_build_pgtable(pdev
, length
,
2525 if (!av7110
->grabbing
)
2528 saa7146_write(dev
, DD1_STREAM_B
, 0x00000000);
2529 saa7146_write(dev
, MC2
, (MASK_10
| MASK_26
));
2531 saa7146_write(dev
, DD1_INIT
, 0x00000600);
2532 saa7146_write(dev
, MC2
, (MASK_09
| MASK_25
| MASK_10
| MASK_26
));
2534 saa7146_write(dev
, BRS_CTRL
, 0x60000000);
2535 saa7146_write(dev
, MC2
, MASK_08
| MASK_24
);
2538 saa7146_write(dev
, PCI_BT_V1
, 0x001c0000 | (saa7146_read(dev
, PCI_BT_V1
) & ~0x001f0000));
2539 saa7146_write(dev
, BASE_ODD3
, 0);
2540 saa7146_write(dev
, BASE_EVEN3
, 0);
2541 saa7146_write(dev
, PROT_ADDR3
, TS_WIDTH
* TS_HEIGHT
);
2542 saa7146_write(dev
, PITCH3
, TS_WIDTH
);
2543 saa7146_write(dev
, BASE_PAGE3
, av7110
->pt
.dma
| ME1
| 0x90);
2544 saa7146_write(dev
, NUM_LINE_BYTE3
, (TS_HEIGHT
<< 16) | TS_WIDTH
);
2545 saa7146_write(dev
, MC2
, MASK_04
| MASK_20
);
2547 tasklet_init(&av7110
->vpe_tasklet
, vpeirq
, (unsigned long) av7110
);
2549 } else if (budgetpatch
) {
2550 spin_lock_init(&av7110
->feedlock1
);
2551 av7110
->grabbing
= saa7146_vmalloc_build_pgtable(pdev
, length
,
2553 if (!av7110
->grabbing
)
2556 saa7146_write(dev
, PCI_BT_V1
, 0x1c1f101f);
2557 saa7146_write(dev
, BCS_CTRL
, 0x80400040);
2558 /* set dd1 stream a & b */
2559 saa7146_write(dev
, DD1_STREAM_B
, 0x00000000);
2560 saa7146_write(dev
, DD1_INIT
, 0x03000200);
2561 saa7146_write(dev
, MC2
, (MASK_09
| MASK_25
| MASK_10
| MASK_26
));
2562 saa7146_write(dev
, BRS_CTRL
, 0x60000000);
2563 saa7146_write(dev
, BASE_ODD3
, 0);
2564 saa7146_write(dev
, BASE_EVEN3
, 0);
2565 saa7146_write(dev
, PROT_ADDR3
, TS_WIDTH
* TS_HEIGHT
);
2566 saa7146_write(dev
, BASE_PAGE3
, av7110
->pt
.dma
| ME1
| 0x90);
2568 saa7146_write(dev
, PITCH3
, TS_WIDTH
);
2569 saa7146_write(dev
, NUM_LINE_BYTE3
, (TS_HEIGHT
<< 16) | TS_WIDTH
);
2572 saa7146_write(dev
, MC2
, 0x077c077c);
2573 saa7146_write(dev
, GPIO_CTRL
, 0x000000);
2575 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2576 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2577 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2579 saa7146_write(dev
, EC1SSR
, (0x03<<2) | 3 );
2580 /* set event counter 1 threshold to maximum allowed value (rEC p55) */
2581 saa7146_write(dev
, ECT1R
, 0x3fff );
2583 /* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */
2586 /* Wait Source Line Counter Threshold (p36) */
2587 WRITE_RPS1(CMD_PAUSE
| EVT_HS
);
2588 /* Set GPIO3=1 (p42) */
2589 WRITE_RPS1(CMD_WR_REG_MASK
| (GPIO_CTRL
>>2));
2590 WRITE_RPS1(GPIO3_MSK
);
2591 WRITE_RPS1(SAA7146_GPIO_OUTHI
<<24);
2593 /* issue RPS1 interrupt */
2594 WRITE_RPS1(CMD_INTERRUPT
);
2596 /* Wait reset Source Line Counter Threshold (p36) */
2597 WRITE_RPS1(CMD_PAUSE
| RPS_INV
| EVT_HS
);
2598 /* Set GPIO3=0 (p42) */
2599 WRITE_RPS1(CMD_WR_REG_MASK
| (GPIO_CTRL
>>2));
2600 WRITE_RPS1(GPIO3_MSK
);
2601 WRITE_RPS1(SAA7146_GPIO_OUTLO
<<24);
2603 /* issue RPS1 interrupt */
2604 WRITE_RPS1(CMD_INTERRUPT
);
2606 /* Jump to begin of RPS program (p37) */
2607 WRITE_RPS1(CMD_JUMP
);
2608 WRITE_RPS1(dev
->d_rps1
.dma_handle
);
2610 /* Fix VSYNC level */
2611 saa7146_setgpio(dev
, 3, SAA7146_GPIO_OUTLO
);
2612 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2613 saa7146_write(dev
, RPS_ADDR1
, dev
->d_rps1
.dma_handle
);
2614 /* Set Source Line Counter Threshold, using BRS (rCC p43)
2615 * It generates HS event every TS_HEIGHT lines
2616 * this is related to TS_WIDTH set in register
2617 * NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits
2618 * are set to TS_WIDTH bytes (TS_WIDTH=2*188),
2619 * then RPS_THRESH1 should be set to trigger
2620 * every TS_HEIGHT (512) lines.
2622 saa7146_write(dev
, RPS_THRESH1
, (TS_HEIGHT
*1) | MASK_12
);
2624 /* Enable RPS1 (rFC p33) */
2625 saa7146_write(dev
, MC1
, (MASK_13
| MASK_29
));
2627 /* end of budgetpatch register initialization */
2628 tasklet_init (&av7110
->vpe_tasklet
, vpeirq
, (unsigned long) av7110
);
2630 saa7146_write(dev
, PCI_BT_V1
, 0x1c00101f);
2631 saa7146_write(dev
, BCS_CTRL
, 0x80400040);
2633 /* set dd1 stream a & b */
2634 saa7146_write(dev
, DD1_STREAM_B
, 0x00000000);
2635 saa7146_write(dev
, DD1_INIT
, 0x03000000);
2636 saa7146_write(dev
, MC2
, (MASK_09
| MASK_25
| MASK_10
| MASK_26
));
2639 saa7146_write(dev
, MC2
, 0x077c077c);
2640 saa7146_write(dev
, GPIO_CTRL
, 0x000000);
2643 tasklet_init (&av7110
->debi_tasklet
, debiirq
, (unsigned long) av7110
);
2644 tasklet_init (&av7110
->gpio_tasklet
, gpioirq
, (unsigned long) av7110
);
2646 mutex_init(&av7110
->pid_mutex
);
2648 /* locks for data transfers from/to AV7110 */
2649 spin_lock_init(&av7110
->debilock
);
2650 mutex_init(&av7110
->dcomlock
);
2651 av7110
->debitype
= -1;
2653 /* default OSD window */
2655 mutex_init(&av7110
->osd_mutex
);
2658 av7110
->vidmode
= tv_standard
== 1 ? AV7110_VIDEO_MODE_NTSC
2659 : AV7110_VIDEO_MODE_PAL
;
2661 /* ARM "watchdog" */
2662 init_waitqueue_head(&av7110
->arm_wait
);
2663 av7110
->arm_thread
= NULL
;
2665 /* allocate and init buffers */
2666 av7110
->debi_virt
= pci_alloc_consistent(pdev
, 8192, &av7110
->debi_bus
);
2667 if (!av7110
->debi_virt
)
2668 goto err_saa71466_vfree_4
;
2671 av7110
->iobuf
= vmalloc(AVOUTLEN
+AOUTLEN
+BMPLEN
+4*IPACKS
);
2673 goto err_pci_free_5
;
2675 ret
= av7110_av_init(av7110
);
2677 goto err_iobuf_vfree_6
;
2679 /* init BMP buffer */
2680 av7110
->bmpbuf
= av7110
->iobuf
+AVOUTLEN
+AOUTLEN
;
2681 init_waitqueue_head(&av7110
->bmpq
);
2683 ret
= av7110_ca_init(av7110
);
2685 goto err_av7110_av_exit_7
;
2687 /* load firmware into AV7110 cards */
2688 ret
= av7110_bootarm(av7110
);
2690 goto err_av7110_ca_exit_8
;
2692 ret
= av7110_firmversion(av7110
);
2694 goto err_stop_arm_9
;
2696 if (FW_VERSION(av7110
->arm_app
)<0x2501)
2697 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2698 "System might be unstable!\n", FW_VERSION(av7110
->arm_app
));
2700 thread
= kthread_run(arm_thread
, (void *) av7110
, "arm_mon");
2701 if (IS_ERR(thread
)) {
2702 ret
= PTR_ERR(thread
);
2703 goto err_stop_arm_9
;
2705 av7110
->arm_thread
= thread
;
2707 /* set initial volume in mixer struct */
2708 av7110
->mixer
.volume_left
= volume
;
2709 av7110
->mixer
.volume_right
= volume
;
2711 ret
= av7110_register(av7110
);
2713 goto err_arm_thread_stop_10
;
2715 init_av7110_av(av7110
);
2717 /* special case DVB-C: these cards have an analog tuner
2718 plus need some special handling, so we have separate
2719 saa7146_ext_vv data for these... */
2720 ret
= av7110_init_v4l(av7110
);
2722 goto err_av7110_unregister_11
;
2724 av7110
->dvb_adapter
.priv
= av7110
;
2725 ret
= frontend_init(av7110
);
2727 goto err_av7110_exit_v4l_12
;
2729 mutex_init(&av7110
->ioctl_mutex
);
2731 #if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2732 av7110_ir_init(av7110
);
2734 printk(KERN_INFO
"dvb-ttpci: found av7110-%d.\n", av7110_num
);
2739 err_av7110_exit_v4l_12
:
2740 av7110_exit_v4l(av7110
);
2741 err_av7110_unregister_11
:
2742 dvb_unregister(av7110
);
2743 err_arm_thread_stop_10
:
2744 av7110_arm_sync(av7110
);
2746 /* Nothing to do. Rejoice. */
2747 err_av7110_ca_exit_8
:
2748 av7110_ca_exit(av7110
);
2749 err_av7110_av_exit_7
:
2750 av7110_av_exit(av7110
);
2752 vfree(av7110
->iobuf
);
2754 pci_free_consistent(pdev
, 8192, av7110
->debi_virt
, av7110
->debi_bus
);
2755 err_saa71466_vfree_4
:
2756 if (av7110
->grabbing
)
2757 saa7146_vfree_destroy_pgtable(pdev
, av7110
->grabbing
, &av7110
->pt
);
2759 i2c_del_adapter(&av7110
->i2c_adap
);
2760 err_dvb_unregister_adapter_2
:
2761 dvb_unregister_adapter(&av7110
->dvb_adapter
);
2763 put_firmware(av7110
);
2769 static int av7110_detach(struct saa7146_dev
* saa
)
2771 struct av7110
*av7110
= saa
->ext_priv
;
2772 dprintk(4, "%p\n", av7110
);
2774 #if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2775 av7110_ir_exit(av7110
);
2777 if (budgetpatch
|| av7110
->full_ts
) {
2780 saa7146_write(saa
, MC1
, MASK_29
);
2781 /* VSYNC LOW (inactive) */
2782 saa7146_setgpio(saa
, 3, SAA7146_GPIO_OUTLO
);
2784 saa7146_write(saa
, MC1
, MASK_20
); /* DMA3 off */
2785 SAA7146_IER_DISABLE(saa
, MASK_10
);
2786 SAA7146_ISR_CLEAR(saa
, MASK_10
);
2788 tasklet_kill(&av7110
->vpe_tasklet
);
2789 saa7146_vfree_destroy_pgtable(saa
->pci
, av7110
->grabbing
, &av7110
->pt
);
2791 av7110_exit_v4l(av7110
);
2793 av7110_arm_sync(av7110
);
2795 tasklet_kill(&av7110
->debi_tasklet
);
2796 tasklet_kill(&av7110
->gpio_tasklet
);
2798 dvb_unregister(av7110
);
2800 SAA7146_IER_DISABLE(saa
, MASK_19
| MASK_03
);
2801 SAA7146_ISR_CLEAR(saa
, MASK_19
| MASK_03
);
2803 av7110_ca_exit(av7110
);
2804 av7110_av_exit(av7110
);
2806 vfree(av7110
->iobuf
);
2807 pci_free_consistent(saa
->pci
, 8192, av7110
->debi_virt
,
2810 i2c_del_adapter(&av7110
->i2c_adap
);
2812 dvb_unregister_adapter (&av7110
->dvb_adapter
);
2816 put_firmware(av7110
);
2820 saa
->ext_priv
= NULL
;
2826 static void av7110_irq(struct saa7146_dev
* dev
, u32
*isr
)
2828 struct av7110
*av7110
= dev
->ext_priv
;
2830 //print_time("av7110_irq");
2832 /* Note: Don't try to handle the DEBI error irq (MASK_18), in
2833 * intel mode the timeout is asserted all the time...
2836 if (*isr
& MASK_19
) {
2837 //printk("av7110_irq: DEBI\n");
2838 /* Note 1: The DEBI irq is level triggered: We must enable it
2839 * only after we started a DMA xfer, and disable it here
2840 * immediately, or it will be signalled all the time while
2842 * Note 2: You would think that an irq which is masked is
2843 * not signalled by the hardware. Not so for the SAA7146:
2844 * An irq is signalled as long as the corresponding bit
2845 * in the ISR is set, and disabling irqs just prevents the
2846 * hardware from setting the ISR bit. This means a) that we
2847 * must clear the ISR *after* disabling the irq (which is why
2848 * we must do it here even though saa7146_core did it already),
2849 * and b) that if we were to disable an edge triggered irq
2850 * (like the gpio irqs sadly are) temporarily we would likely
2851 * loose some. This sucks :-(
2853 SAA7146_IER_DISABLE(av7110
->dev
, MASK_19
);
2854 SAA7146_ISR_CLEAR(av7110
->dev
, MASK_19
);
2855 tasklet_schedule(&av7110
->debi_tasklet
);
2858 if (*isr
& MASK_03
) {
2859 //printk("av7110_irq: GPIO\n");
2860 tasklet_schedule(&av7110
->gpio_tasklet
);
2864 tasklet_schedule(&av7110
->vpe_tasklet
);
2868 static struct saa7146_extension av7110_extension_driver
;
2870 #define MAKE_AV7110_INFO(x_var,x_name) \
2871 static struct saa7146_pci_extension_data x_var = { \
2872 .ext_priv = x_name, \
2873 .ext = &av7110_extension_driver }
2875 MAKE_AV7110_INFO(tts_1_X_fsc
,"Technotrend/Hauppauge WinTV DVB-S rev1.X or Fujitsu Siemens DVB-C");
2876 MAKE_AV7110_INFO(ttt_1_X
, "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2877 MAKE_AV7110_INFO(ttc_1_X
, "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2878 MAKE_AV7110_INFO(ttc_2_X
, "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2879 MAKE_AV7110_INFO(tts_2_X
, "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2880 MAKE_AV7110_INFO(tts_2_3
, "Technotrend/Hauppauge WinTV Nexus-S rev2.3");
2881 MAKE_AV7110_INFO(tts_1_3se
, "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2882 MAKE_AV7110_INFO(ttt
, "Technotrend/Hauppauge DVB-T");
2883 MAKE_AV7110_INFO(fsc
, "Fujitsu Siemens DVB-C");
2884 MAKE_AV7110_INFO(fss
, "Fujitsu Siemens DVB-S rev1.6");
2885 MAKE_AV7110_INFO(gxs_1_3
, "Galaxis DVB-S rev1.3");
2887 static struct pci_device_id pci_tbl
[] = {
2888 MAKE_EXTENSION_PCI(fsc
, 0x110a, 0x0000),
2889 MAKE_EXTENSION_PCI(tts_1_X_fsc
, 0x13c2, 0x0000),
2890 MAKE_EXTENSION_PCI(ttt_1_X
, 0x13c2, 0x0001),
2891 MAKE_EXTENSION_PCI(ttc_2_X
, 0x13c2, 0x0002),
2892 MAKE_EXTENSION_PCI(tts_2_X
, 0x13c2, 0x0003),
2893 MAKE_EXTENSION_PCI(gxs_1_3
, 0x13c2, 0x0004),
2894 MAKE_EXTENSION_PCI(fss
, 0x13c2, 0x0006),
2895 MAKE_EXTENSION_PCI(ttt
, 0x13c2, 0x0008),
2896 MAKE_EXTENSION_PCI(ttc_1_X
, 0x13c2, 0x000a),
2897 MAKE_EXTENSION_PCI(tts_2_3
, 0x13c2, 0x000e),
2898 MAKE_EXTENSION_PCI(tts_1_3se
, 0x13c2, 0x1002),
2900 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2901 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2908 MODULE_DEVICE_TABLE(pci
, pci_tbl
);
2911 static struct saa7146_extension av7110_extension_driver
= {
2913 .flags
= SAA7146_USE_I2C_IRQ
,
2915 .module
= THIS_MODULE
,
2916 .pci_tbl
= &pci_tbl
[0],
2917 .attach
= av7110_attach
,
2918 .detach
= av7110_detach
,
2920 .irq_mask
= MASK_19
| MASK_03
| MASK_10
,
2921 .irq_func
= av7110_irq
,
2925 static int __init
av7110_init(void)
2928 retval
= saa7146_register_extension(&av7110_extension_driver
);
2933 static void __exit
av7110_exit(void)
2935 saa7146_unregister_extension(&av7110_extension_driver
);
2938 module_init(av7110_init
);
2939 module_exit(av7110_exit
);
2941 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2942 "Siemens, Technotrend, Hauppauge");
2943 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2944 MODULE_LICENSE("GPL");