?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[NETFILTER]: nf_conntrack: export hash allocation/destruction functions
[linux-2.6/verdex.git] / drivers / media / dvb / ttpci / av7110.c
blobef1108c0bf11005167eb6b6b225ac4a890465369
1 /*
2 * driver for the SAA7146 based AV110 cards (like the Fujitsu-Siemens DVB)
3 * av7110.c: initialization and demux stuff
4 *
5 * Copyright (C) 1999-2002 Ralph Metzler
6 * & Marcus Metzler for convergence integrated media GmbH
7 *
8 * originally based on code by:
9 * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version 2
14 * of the License, or (at your option) any later version.
15 *
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
27 *
28 *
29 * the project's page is at http://www.linuxtv.org/dvb/
30 */
31
32
33 #include <linux/module.h>
34 #include <linux/kmod.h>
35 #include <linux/delay.h>
36 #include <linux/fs.h>
37 #include <linux/timer.h>
38 #include <linux/poll.h>
39 #include <linux/byteorder/swabb.h>
40 #include <linux/smp_lock.h>
41
42 #include <linux/kernel.h>
43 #include <linux/moduleparam.h>
44 #include <linux/sched.h>
45 #include <linux/types.h>
46 #include <linux/fcntl.h>
47 #include <linux/interrupt.h>
48 #include <linux/string.h>
49 #include <linux/pci.h>
50 #include <linux/vmalloc.h>
51 #include <linux/firmware.h>
52 #include <linux/crc32.h>
53 #include <linux/i2c.h>
54 #include <linux/kthread.h>
55
56 #include <asm/system.h>
57
58 #include <linux/dvb/frontend.h>
59
60 #include "dvb_frontend.h"
61
62 #include "ttpci-eeprom.h"
63 #include "av7110.h"
64 #include "av7110_hw.h"
65 #include "av7110_av.h"
66 #include "av7110_ca.h"
67 #include "av7110_ipack.h"
68
69 #include "bsbe1.h"
70 #include "lnbp21.h"
71 #include "bsru6.h"
72
73 #define TS_WIDTH 376
74 #define TS_HEIGHT 512
75 #define TS_BUFLEN (TS_WIDTH*TS_HEIGHT)
76 #define TS_MAX_PACKETS (TS_BUFLEN/TS_SIZE)
77
78
79 int av7110_debug;
80
81 static int vidmode = CVBS_RGB_OUT;
82 static int pids_off;
83 static int adac = DVB_ADAC_TI;
84 static int hw_sections;
85 static int rgb_on;
86 static int volume = 255;
87 static int budgetpatch;
88 static int wss_cfg_4_3 = 0x4008;
89 static int wss_cfg_16_9 = 0x0007;
90 static int tv_standard;
91
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(wss_cfg_4_3, int, 0444);
110 MODULE_PARM_DESC(wss_cfg_4_3, "WSS 4:3 - default 0x4008 - bit 15: disable, 14: burst mode, 13..0: wss data");
111 module_param(wss_cfg_16_9, int, 0444);
112 MODULE_PARM_DESC(wss_cfg_16_9, "WSS 16:9 - default 0x0007 - bit 15: disable, 14: burst mode, 13..0: wss data");
113 module_param(tv_standard, int, 0444);
114 MODULE_PARM_DESC(tv_standard, "TV standard: 0 PAL (default), 1 NTSC");
115
116 static void restart_feeds(struct av7110 *av7110);
117
118 static int av7110_num;
119
120 #define FE_FUNC_OVERRIDE(fe_func, av7110_copy, av7110_func) \
121 {\
122 if (fe_func != NULL) { \
123 av7110_copy = fe_func; \
124 fe_func = av7110_func; \
125 } \
126 }
127
128
129 static void init_av7110_av(struct av7110 *av7110)
130 {
131 int ret;
132 struct saa7146_dev *dev = av7110->dev;
133
134 /* set internal volume control to maximum */
135 av7110->adac_type = DVB_ADAC_TI;
136 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
137 if (ret < 0)
138 printk("dvb-ttpci:cannot set internal volume to maximum:%d\n",ret);
139
140 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 2, wss_cfg_4_3);
141 if (ret < 0)
142 printk("dvb-ttpci: unable to configure 4:3 wss\n");
143 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 3, wss_cfg_16_9);
144 if (ret < 0)
145 printk("dvb-ttpci: unable to configure 16:9 wss\n");
146
147 ret = av7710_set_video_mode(av7110, vidmode);
148 if (ret < 0)
149 printk("dvb-ttpci:cannot set video mode:%d\n",ret);
150
151 /* handle different card types */
152 /* remaining inits according to card and frontend type */
153 av7110->analog_tuner_flags = 0;
154 av7110->current_input = 0;
155 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000a)
156 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 0); // SPDIF on
157 if (i2c_writereg(av7110, 0x20, 0x00, 0x00) == 1) {
158 printk ("dvb-ttpci: Crystal audio DAC @ card %d detected\n",
159 av7110->dvb_adapter.num);
160 av7110->adac_type = DVB_ADAC_CRYSTAL;
161 i2c_writereg(av7110, 0x20, 0x01, 0xd2);
162 i2c_writereg(av7110, 0x20, 0x02, 0x49);
163 i2c_writereg(av7110, 0x20, 0x03, 0x00);
164 i2c_writereg(av7110, 0x20, 0x04, 0x00);
165
166 /**
167 * some special handling for the Siemens DVB-C cards...
168 */
169 } else if (0 == av7110_init_analog_module(av7110)) {
170 /* done. */
171 }
172 else if (dev->pci->subsystem_vendor == 0x110a) {
173 printk("dvb-ttpci: DVB-C w/o analog module @ card %d detected\n",
174 av7110->dvb_adapter.num);
175 av7110->adac_type = DVB_ADAC_NONE;
176 }
177 else {
178 av7110->adac_type = adac;
179 printk("dvb-ttpci: adac type set to %d @ card %d\n",
180 av7110->adac_type, av7110->dvb_adapter.num);
181 }
182
183 if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP34x0) {
184 // switch DVB SCART on
185 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0);
186 if (ret < 0)
187 printk("dvb-ttpci:cannot switch on SCART(Main):%d\n",ret);
188 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1);
189 if (ret < 0)
190 printk("dvb-ttpci:cannot switch on SCART(AD):%d\n",ret);
191 if (rgb_on &&
192 ((av7110->dev->pci->subsystem_vendor == 0x110a) ||
193 (av7110->dev->pci->subsystem_vendor == 0x13c2)) &&
194 (av7110->dev->pci->subsystem_device == 0x0000)) {
195 saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16
196 //saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // SCARTpin 8
197 }
198 }
199
200 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000e)
201 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, SpdifSwitch, 1, 0); // SPDIF on
202
203 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
204 if (ret < 0)
205 printk("dvb-ttpci:cannot set volume :%d\n",ret);
206 }
207
208 static void recover_arm(struct av7110 *av7110)
209 {
210 dprintk(4, "%p\n",av7110);
211
212 av7110_bootarm(av7110);
213 msleep(100);
214
215 init_av7110_av(av7110);
216
217 /* card-specific recovery */
218 if (av7110->recover)
219 av7110->recover(av7110);
220
221 restart_feeds(av7110);
222
223 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
224 av7110_check_ir_config(av7110, true);
225 #endif
226 }
227
228 static void av7110_arm_sync(struct av7110 *av7110)
229 {
230 if (av7110->arm_thread)
231 kthread_stop(av7110->arm_thread);
232
233 av7110->arm_thread = NULL;
234 }
235
236 static int arm_thread(void *data)
237 {
238 struct av7110 *av7110 = data;
239 u16 newloops = 0;
240 int timeout;
241
242 dprintk(4, "%p\n",av7110);
243
244 for (;;) {
245 timeout = wait_event_interruptible_timeout(av7110->arm_wait,
246 kthread_should_stop(), 5 * HZ);
247
248 if (-ERESTARTSYS == timeout || kthread_should_stop()) {
249 /* got signal or told to quit*/
250 break;
251 }
252
253 if (!av7110->arm_ready)
254 continue;
255
256 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
257 av7110_check_ir_config(av7110, false);
258 #endif
259
260 if (mutex_lock_interruptible(&av7110->dcomlock))
261 break;
262 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
263 mutex_unlock(&av7110->dcomlock);
264
265 if (newloops == av7110->arm_loops || av7110->arm_errors > 3) {
266 printk(KERN_ERR "dvb-ttpci: ARM crashed @ card %d\n",
267 av7110->dvb_adapter.num);
268
269 recover_arm(av7110);
270
271 if (mutex_lock_interruptible(&av7110->dcomlock))
272 break;
273 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2) - 1;
274 mutex_unlock(&av7110->dcomlock);
275 }
276 av7110->arm_loops = newloops;
277 av7110->arm_errors = 0;
278 }
279
280 return 0;
281 }
282
283
284 /****************************************************************************
285 * IRQ handling
286 ****************************************************************************/
287
288 static int DvbDmxFilterCallback(u8 *buffer1, size_t buffer1_len,
289 u8 *buffer2, size_t buffer2_len,
290 struct dvb_demux_filter *dvbdmxfilter,
291 enum dmx_success success,
292 struct av7110 *av7110)
293 {
294 if (!dvbdmxfilter->feed->demux->dmx.frontend)
295 return 0;
296 if (dvbdmxfilter->feed->demux->dmx.frontend->source == DMX_MEMORY_FE)
297 return 0;
298
299 switch (dvbdmxfilter->type) {
300 case DMX_TYPE_SEC:
301 if ((((buffer1[1] << 8) | buffer1[2]) & 0xfff) + 3 != buffer1_len)
302 return 0;
303 if (dvbdmxfilter->doneq) {
304 struct dmx_section_filter *filter = &dvbdmxfilter->filter;
305 int i;
306 u8 xor, neq = 0;
307
308 for (i = 0; i < DVB_DEMUX_MASK_MAX; i++) {
309 xor = filter->filter_value[i] ^ buffer1[i];
310 neq |= dvbdmxfilter->maskandnotmode[i] & xor;
311 }
312 if (!neq)
313 return 0;
314 }
315 return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len,
316 buffer2, buffer2_len,
317 &dvbdmxfilter->filter,
318 DMX_OK);
319 case DMX_TYPE_TS:
320 if (!(dvbdmxfilter->feed->ts_type & TS_PACKET))
321 return 0;
322 if (dvbdmxfilter->feed->ts_type & TS_PAYLOAD_ONLY)
323 return dvbdmxfilter->feed->cb.ts(buffer1, buffer1_len,
324 buffer2, buffer2_len,
325 &dvbdmxfilter->feed->feed.ts,
326 DMX_OK);
327 else
328 av7110_p2t_write(buffer1, buffer1_len,
329 dvbdmxfilter->feed->pid,
330 &av7110->p2t_filter[dvbdmxfilter->index]);
331 default:
332 return 0;
333 }
334 }
335
336
337 //#define DEBUG_TIMING
338 static inline void print_time(char *s)
339 {
340 #ifdef DEBUG_TIMING
341 struct timeval tv;
342 do_gettimeofday(&tv);
343 printk("%s: %d.%d\n", s, (int)tv.tv_sec, (int)tv.tv_usec);
344 #endif
345 }
346
347 #define DEBI_READ 0
348 #define DEBI_WRITE 1
349 static inline void start_debi_dma(struct av7110 *av7110, int dir,
350 unsigned long addr, unsigned int len)
351 {
352 dprintk(8, "%c %08lx %u\n", dir == DEBI_READ ? 'R' : 'W', addr, len);
353 if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
354 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __FUNCTION__);
355 return;
356 }
357
358 SAA7146_ISR_CLEAR(av7110->dev, MASK_19); /* for good measure */
359 SAA7146_IER_ENABLE(av7110->dev, MASK_19);
360 if (len < 5)
361 len = 5; /* we want a real DEBI DMA */
362 if (dir == DEBI_WRITE)
363 iwdebi(av7110, DEBISWAB, addr, 0, (len + 3) & ~3);
364 else
365 irdebi(av7110, DEBISWAB, addr, 0, len);
366 }
367
368 static void debiirq(unsigned long data)
369 {
370 struct av7110 *av7110 = (struct av7110 *) data;
371 int type = av7110->debitype;
372 int handle = (type >> 8) & 0x1f;
373 unsigned int xfer = 0;
374
375 print_time("debi");
376 dprintk(4, "type 0x%04x\n", type);
377
378 if (type == -1) {
379 printk("DEBI irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
380 jiffies, saa7146_read(av7110->dev, PSR),
381 saa7146_read(av7110->dev, SSR));
382 goto debi_done;
383 }
384 av7110->debitype = -1;
385
386 switch (type & 0xff) {
387
388 case DATA_TS_RECORD:
389 dvb_dmx_swfilter_packets(&av7110->demux,
390 (const u8 *) av7110->debi_virt,
391 av7110->debilen / 188);
392 xfer = RX_BUFF;
393 break;
394
395 case DATA_PES_RECORD:
396 if (av7110->demux.recording)
397 av7110_record_cb(&av7110->p2t[handle],
398 (u8 *) av7110->debi_virt,
399 av7110->debilen);
400 xfer = RX_BUFF;
401 break;
402
403 case DATA_IPMPE:
404 case DATA_FSECTION:
405 case DATA_PIPING:
406 if (av7110->handle2filter[handle])
407 DvbDmxFilterCallback((u8 *)av7110->debi_virt,
408 av7110->debilen, NULL, 0,
409 av7110->handle2filter[handle],
410 DMX_OK, av7110);
411 xfer = RX_BUFF;
412 break;
413
414 case DATA_CI_GET:
415 {
416 u8 *data = av7110->debi_virt;
417
418 if ((data[0] < 2) && data[2] == 0xff) {
419 int flags = 0;
420 if (data[5] > 0)
421 flags |= CA_CI_MODULE_PRESENT;
422 if (data[5] > 5)
423 flags |= CA_CI_MODULE_READY;
424 av7110->ci_slot[data[0]].flags = flags;
425 } else
426 ci_get_data(&av7110->ci_rbuffer,
427 av7110->debi_virt,
428 av7110->debilen);
429 xfer = RX_BUFF;
430 break;
431 }
432
433 case DATA_COMMON_INTERFACE:
434 CI_handle(av7110, (u8 *)av7110->debi_virt, av7110->debilen);
435 #if 0
436 {
437 int i;
438
439 printk("av7110%d: ", av7110->num);
440 printk("%02x ", *(u8 *)av7110->debi_virt);
441 printk("%02x ", *(1+(u8 *)av7110->debi_virt));
442 for (i = 2; i < av7110->debilen; i++)
443 printk("%02x ", (*(i+(unsigned char *)av7110->debi_virt)));
444 for (i = 2; i < av7110->debilen; i++)
445 printk("%c", chtrans(*(i+(unsigned char *)av7110->debi_virt)));
446
447 printk("\n");
448 }
449 #endif
450 xfer = RX_BUFF;
451 break;
452
453 case DATA_DEBUG_MESSAGE:
454 ((s8*)av7110->debi_virt)[Reserved_SIZE - 1] = 0;
455 printk("%s\n", (s8 *) av7110->debi_virt);
456 xfer = RX_BUFF;
457 break;
458
459 case DATA_CI_PUT:
460 dprintk(4, "debi DATA_CI_PUT\n");
461 case DATA_MPEG_PLAY:
462 dprintk(4, "debi DATA_MPEG_PLAY\n");
463 case DATA_BMP_LOAD:
464 dprintk(4, "debi DATA_BMP_LOAD\n");
465 xfer = TX_BUFF;
466 break;
467 default:
468 break;
469 }
470 debi_done:
471 spin_lock(&av7110->debilock);
472 if (xfer)
473 iwdebi(av7110, DEBINOSWAP, xfer, 0, 2);
474 ARM_ClearMailBox(av7110);
475 spin_unlock(&av7110->debilock);
476 }
477
478 /* irq from av7110 firmware writing the mailbox register in the DPRAM */
479 static void gpioirq(unsigned long data)
480 {
481 struct av7110 *av7110 = (struct av7110 *) data;
482 u32 rxbuf, txbuf;
483 int len;
484
485 if (av7110->debitype != -1)
486 /* we shouldn't get any irq while a debi xfer is running */
487 printk("dvb-ttpci: GPIO0 irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
488 jiffies, saa7146_read(av7110->dev, PSR),
489 saa7146_read(av7110->dev, SSR));
490
491 if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
492 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __FUNCTION__);
493 BUG(); /* maybe we should try resetting the debi? */
494 }
495
496 spin_lock(&av7110->debilock);
497 ARM_ClearIrq(av7110);
498
499 /* see what the av7110 wants */
500 av7110->debitype = irdebi(av7110, DEBINOSWAP, IRQ_STATE, 0, 2);
501 av7110->debilen = irdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
502 rxbuf = irdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
503 txbuf = irdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
504 len = (av7110->debilen + 3) & ~3;
505
506 print_time("gpio");
507 dprintk(8, "GPIO0 irq 0x%04x %d\n", av7110->debitype, av7110->debilen);
508
509 switch (av7110->debitype & 0xff) {
510
511 case DATA_TS_PLAY:
512 case DATA_PES_PLAY:
513 break;
514
515 case DATA_MPEG_VIDEO_EVENT:
516 {
517 u32 h_ar;
518 struct video_event event;
519
520 av7110->video_size.w = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_WIDTH, 0, 2);
521 h_ar = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_HEIGHT_AR, 0, 2);
522
523 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
524 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
525
526 av7110->video_size.h = h_ar & 0xfff;
527
528 event.type = VIDEO_EVENT_SIZE_CHANGED;
529 event.u.size.w = av7110->video_size.w;
530 event.u.size.h = av7110->video_size.h;
531 switch ((h_ar >> 12) & 0xf)
532 {
533 case 3:
534 av7110->video_size.aspect_ratio = VIDEO_FORMAT_16_9;
535 event.u.size.aspect_ratio = VIDEO_FORMAT_16_9;
536 av7110->videostate.video_format = VIDEO_FORMAT_16_9;
537 break;
538 case 4:
539 av7110->video_size.aspect_ratio = VIDEO_FORMAT_221_1;
540 event.u.size.aspect_ratio = VIDEO_FORMAT_221_1;
541 av7110->videostate.video_format = VIDEO_FORMAT_221_1;
542 break;
543 default:
544 av7110->video_size.aspect_ratio = VIDEO_FORMAT_4_3;
545 event.u.size.aspect_ratio = VIDEO_FORMAT_4_3;
546 av7110->videostate.video_format = VIDEO_FORMAT_4_3;
547 }
548
549 dprintk(8, "GPIO0 irq: DATA_MPEG_VIDEO_EVENT: w/h/ar = %u/%u/%u\n",
550 av7110->video_size.w, av7110->video_size.h,
551 av7110->video_size.aspect_ratio);
552
553 dvb_video_add_event(av7110, &event);
554 break;
555 }
556
557 case DATA_CI_PUT:
558 {
559 int avail;
560 struct dvb_ringbuffer *cibuf = &av7110->ci_wbuffer;
561
562 avail = dvb_ringbuffer_avail(cibuf);
563 if (avail <= 2) {
564 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
565 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
566 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
567 break;
568 }
569 len = DVB_RINGBUFFER_PEEK(cibuf, 0) << 8;
570 len |= DVB_RINGBUFFER_PEEK(cibuf, 1);
571 if (avail < len + 2) {
572 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
573 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
574 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
575 break;
576 }
577 DVB_RINGBUFFER_SKIP(cibuf, 2);
578
579 dvb_ringbuffer_read(cibuf, av7110->debi_virt, len, 0);
580
581 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
582 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
583 dprintk(8, "DMA: CI\n");
584 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
585 spin_unlock(&av7110->debilock);
586 wake_up(&cibuf->queue);
587 return;
588 }
589
590 case DATA_MPEG_PLAY:
591 if (!av7110->playing) {
592 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
593 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
594 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
595 break;
596 }
597 len = 0;
598 if (av7110->debitype & 0x100) {
599 spin_lock(&av7110->aout.lock);
600 len = av7110_pes_play(av7110->debi_virt, &av7110->aout, 2048);
601 spin_unlock(&av7110->aout.lock);
602 }
603 if (len <= 0 && (av7110->debitype & 0x200)
604 &&av7110->videostate.play_state != VIDEO_FREEZED) {
605 spin_lock(&av7110->avout.lock);
606 len = av7110_pes_play(av7110->debi_virt, &av7110->avout, 2048);
607 spin_unlock(&av7110->avout.lock);
608 }
609 if (len <= 0) {
610 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
611 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
612 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
613 break;
614 }
615 dprintk(8, "GPIO0 PES_PLAY len=%04x\n", len);
616 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
617 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
618 dprintk(8, "DMA: MPEG_PLAY\n");
619 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
620 spin_unlock(&av7110->debilock);
621 return;
622
623 case DATA_BMP_LOAD:
624 len = av7110->debilen;
625 dprintk(8, "gpio DATA_BMP_LOAD len %d\n", len);
626 if (!len) {
627 av7110->bmp_state = BMP_LOADED;
628 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
629 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
630 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
631 wake_up(&av7110->bmpq);
632 dprintk(8, "gpio DATA_BMP_LOAD done\n");
633 break;
634 }
635 if (len > av7110->bmplen)
636 len = av7110->bmplen;
637 if (len > 2 * 1024)
638 len = 2 * 1024;
639 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
640 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
641 memcpy(av7110->debi_virt, av7110->bmpbuf+av7110->bmpp, len);
642 av7110->bmpp += len;
643 av7110->bmplen -= len;
644 dprintk(8, "gpio DATA_BMP_LOAD DMA len %d\n", len);
645 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE+txbuf, len);
646 spin_unlock(&av7110->debilock);
647 return;
648
649 case DATA_CI_GET:
650 case DATA_COMMON_INTERFACE:
651 case DATA_FSECTION:
652 case DATA_IPMPE:
653 case DATA_PIPING:
654 if (!len || len > 4 * 1024) {
655 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
656 break;
657 }
658 /* fall through */
659
660 case DATA_TS_RECORD:
661 case DATA_PES_RECORD:
662 dprintk(8, "DMA: TS_REC etc.\n");
663 start_debi_dma(av7110, DEBI_READ, DPRAM_BASE+rxbuf, len);
664 spin_unlock(&av7110->debilock);
665 return;
666
667 case DATA_DEBUG_MESSAGE:
668 if (!len || len > 0xff) {
669 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
670 break;
671 }
672 start_debi_dma(av7110, DEBI_READ, Reserved, len);
673 spin_unlock(&av7110->debilock);
674 return;
675
676 case DATA_IRCOMMAND:
677 if (av7110->ir.ir_handler)
678 av7110->ir.ir_handler(av7110,
679 swahw32(irdebi(av7110, DEBINOSWAP, Reserved, 0, 4)));
680 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
681 break;
682
683 default:
684 printk("dvb-ttpci: gpioirq unknown type=%d len=%d\n",
685 av7110->debitype, av7110->debilen);
686 break;
687 }
688 av7110->debitype = -1;
689 ARM_ClearMailBox(av7110);
690 spin_unlock(&av7110->debilock);
691 }
692
693
694 #ifdef CONFIG_DVB_AV7110_OSD
695 static int dvb_osd_ioctl(struct inode *inode, struct file *file,
696 unsigned int cmd, void *parg)
697 {
698 struct dvb_device *dvbdev = file->private_data;
699 struct av7110 *av7110 = dvbdev->priv;
700
701 dprintk(4, "%p\n", av7110);
702
703 if (cmd == OSD_SEND_CMD)
704 return av7110_osd_cmd(av7110, (osd_cmd_t *) parg);
705 if (cmd == OSD_GET_CAPABILITY)
706 return av7110_osd_capability(av7110, (osd_cap_t *) parg);
707
708 return -EINVAL;
709 }
710
711
712 static struct file_operations dvb_osd_fops = {
713 .owner = THIS_MODULE,
714 .ioctl = dvb_generic_ioctl,
715 .open = dvb_generic_open,
716 .release = dvb_generic_release,
717 };
718
719 static struct dvb_device dvbdev_osd = {
720 .priv = NULL,
721 .users = 1,
722 .writers = 1,
723 .fops = &dvb_osd_fops,
724 .kernel_ioctl = dvb_osd_ioctl,
725 };
726 #endif /* CONFIG_DVB_AV7110_OSD */
727
728
729 static inline int SetPIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
730 u16 subpid, u16 pcrpid)
731 {
732 u16 aflags = 0;
733
734 dprintk(4, "%p\n", av7110);
735
736 if (vpid == 0x1fff || apid == 0x1fff ||
737 ttpid == 0x1fff || subpid == 0x1fff || pcrpid == 0x1fff) {
738 vpid = apid = ttpid = subpid = pcrpid = 0;
739 av7110->pids[DMX_PES_VIDEO] = 0;
740 av7110->pids[DMX_PES_AUDIO] = 0;
741 av7110->pids[DMX_PES_TELETEXT] = 0;
742 av7110->pids[DMX_PES_PCR] = 0;
743 }
744
745 if (av7110->audiostate.bypass_mode)
746 aflags |= 0x8000;
747
748 return av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, MultiPID, 6,
749 pcrpid, vpid, apid, ttpid, subpid, aflags);
750 }
751
752 int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
753 u16 subpid, u16 pcrpid)
754 {
755 int ret = 0;
756 dprintk(4, "%p\n", av7110);
757
758 if (mutex_lock_interruptible(&av7110->pid_mutex))
759 return -ERESTARTSYS;
760
761 if (!(vpid & 0x8000))
762 av7110->pids[DMX_PES_VIDEO] = vpid;
763 if (!(apid & 0x8000))
764 av7110->pids[DMX_PES_AUDIO] = apid;
765 if (!(ttpid & 0x8000))
766 av7110->pids[DMX_PES_TELETEXT] = ttpid;
767 if (!(pcrpid & 0x8000))
768 av7110->pids[DMX_PES_PCR] = pcrpid;
769
770 av7110->pids[DMX_PES_SUBTITLE] = 0;
771
772 if (av7110->fe_synced) {
773 pcrpid = av7110->pids[DMX_PES_PCR];
774 ret = SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
775 }
776
777 mutex_unlock(&av7110->pid_mutex);
778 return ret;
779 }
780
781
782 /******************************************************************************
783 * hardware filter functions
784 ******************************************************************************/
785
786 static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter)
787 {
788 struct dvb_demux_feed *dvbdmxfeed = dvbdmxfilter->feed;
789 struct av7110 *av7110 = dvbdmxfeed->demux->priv;
790 u16 buf[20];
791 int ret, i;
792 u16 handle;
793 // u16 mode = 0x0320;
794 u16 mode = 0xb96a;
795
796 dprintk(4, "%p\n", av7110);
797
798 if (dvbdmxfilter->type == DMX_TYPE_SEC) {
799 if (hw_sections) {
800 buf[4] = (dvbdmxfilter->filter.filter_value[0] << 8) |
801 dvbdmxfilter->maskandmode[0];
802 for (i = 3; i < 18; i++)
803 buf[i + 4 - 2] =
804 (dvbdmxfilter->filter.filter_value[i] << 8) |
805 dvbdmxfilter->maskandmode[i];
806 mode = 4;
807 }
808 } else if ((dvbdmxfeed->ts_type & TS_PACKET) &&
809 !(dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)) {
810 av7110_p2t_init(&av7110->p2t_filter[dvbdmxfilter->index], dvbdmxfeed);
811 }
812
813 buf[0] = (COMTYPE_PID_FILTER << 8) + AddPIDFilter;
814 buf[1] = 16;
815 buf[2] = dvbdmxfeed->pid;
816 buf[3] = mode;
817
818 ret = av7110_fw_request(av7110, buf, 20, &handle, 1);
819 if (ret != 0 || handle >= 32) {
820 printk("dvb-ttpci: %s error buf %04x %04x %04x %04x "
821 "ret %d handle %04x\n",
822 __FUNCTION__, buf[0], buf[1], buf[2], buf[3],
823 ret, handle);
824 dvbdmxfilter->hw_handle = 0xffff;
825 if (!ret)
826 ret = -1;
827 return ret;
828 }
829
830 av7110->handle2filter[handle] = dvbdmxfilter;
831 dvbdmxfilter->hw_handle = handle;
832
833 return ret;
834 }
835
836 static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
837 {
838 struct av7110 *av7110 = dvbdmxfilter->feed->demux->priv;
839 u16 buf[3];
840 u16 answ[2];
841 int ret;
842 u16 handle;
843
844 dprintk(4, "%p\n", av7110);
845
846 handle = dvbdmxfilter->hw_handle;
847 if (handle >= 32) {
848 printk("%s tried to stop invalid filter %04x, filter type = %x\n",
849 __FUNCTION__, handle, dvbdmxfilter->type);
850 return -EINVAL;
851 }
852
853 av7110->handle2filter[handle] = NULL;
854
855 buf[0] = (COMTYPE_PID_FILTER << 8) + DelPIDFilter;
856 buf[1] = 1;
857 buf[2] = handle;
858 ret = av7110_fw_request(av7110, buf, 3, answ, 2);
859 if (ret != 0 || answ[1] != handle) {
860 printk("dvb-ttpci: %s error cmd %04x %04x %04x ret %x "
861 "resp %04x %04x pid %d\n",
862 __FUNCTION__, buf[0], buf[1], buf[2], ret,
863 answ[0], answ[1], dvbdmxfilter->feed->pid);
864 if (!ret)
865 ret = -1;
866 }
867 return ret;
868 }
869
870
871 static int dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
872 {
873 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
874 struct av7110 *av7110 = dvbdmx->priv;
875 u16 *pid = dvbdmx->pids, npids[5];
876 int i;
877 int ret = 0;
878
879 dprintk(4, "%p\n", av7110);
880
881 npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
882 i = dvbdmxfeed->pes_type;
883 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
884 if ((i == 2) && npids[i] && (dvbdmxfeed->ts_type & TS_PACKET)) {
885 npids[i] = 0;
886 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
887 if (!ret)
888 ret = StartHWFilter(dvbdmxfeed->filter);
889 return ret;
890 }
891 if (dvbdmxfeed->pes_type <= 2 || dvbdmxfeed->pes_type == 4) {
892 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
893 if (ret)
894 return ret;
895 }
896
897 if (dvbdmxfeed->pes_type < 2 && npids[0])
898 if (av7110->fe_synced)
899 {
900 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
901 if (ret)
902 return ret;
903 }
904
905 if ((dvbdmxfeed->ts_type & TS_PACKET)) {
906 if (dvbdmxfeed->pes_type == 0 && !(dvbdmx->pids[0] & 0x8000))
907 ret = av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed);
908 if (dvbdmxfeed->pes_type == 1 && !(dvbdmx->pids[1] & 0x8000))
909 ret = av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed);
910 }
911 return ret;
912 }
913
914 static int dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
915 {
916 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
917 struct av7110 *av7110 = dvbdmx->priv;
918 u16 *pid = dvbdmx->pids, npids[5];
919 int i;
920
921 int ret = 0;
922
923 dprintk(4, "%p\n", av7110);
924
925 if (dvbdmxfeed->pes_type <= 1) {
926 ret = av7110_av_stop(av7110, dvbdmxfeed->pes_type ? RP_VIDEO : RP_AUDIO);
927 if (ret)
928 return ret;
929 if (!av7110->rec_mode)
930 dvbdmx->recording = 0;
931 if (!av7110->playing)
932 dvbdmx->playing = 0;
933 }
934 npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
935 i = dvbdmxfeed->pes_type;
936 switch (i) {
937 case 2: //teletext
938 if (dvbdmxfeed->ts_type & TS_PACKET)
939 ret = StopHWFilter(dvbdmxfeed->filter);
940 npids[2] = 0;
941 break;
942 case 0:
943 case 1:
944 case 4:
945 if (!pids_off)
946 return 0;
947 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
948 break;
949 }
950 if (!ret)
951 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
952 return ret;
953 }
954
955 static int av7110_start_feed(struct dvb_demux_feed *feed)
956 {
957 struct dvb_demux *demux = feed->demux;
958 struct av7110 *av7110 = demux->priv;
959 int ret = 0;
960
961 dprintk(4, "%p\n", av7110);
962
963 if (!demux->dmx.frontend)
964 return -EINVAL;
965
966 if (feed->pid > 0x1fff)
967 return -EINVAL;
968
969 if (feed->type == DMX_TYPE_TS) {
970 if ((feed->ts_type & TS_DECODER) &&
971 (feed->pes_type < DMX_TS_PES_OTHER)) {
972 switch (demux->dmx.frontend->source) {
973 case DMX_MEMORY_FE:
974 if (feed->ts_type & TS_DECODER)
975 if (feed->pes_type < 2 &&
976 !(demux->pids[0] & 0x8000) &&
977 !(demux->pids[1] & 0x8000)) {
978 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
979 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
980 ret = av7110_av_start_play(av7110,RP_AV);
981 if (!ret)
982 demux->playing = 1;
983 }
984 break;
985 default:
986 ret = dvb_feed_start_pid(feed);
987 break;
988 }
989 } else if ((feed->ts_type & TS_PACKET) &&
990 (demux->dmx.frontend->source != DMX_MEMORY_FE)) {
991 ret = StartHWFilter(feed->filter);
992 }
993 }
994
995 else if (feed->type == DMX_TYPE_SEC) {
996 int i;
997
998 for (i = 0; i < demux->filternum; i++) {
999 if (demux->filter[i].state != DMX_STATE_READY)
1000 continue;
1001 if (demux->filter[i].type != DMX_TYPE_SEC)
1002 continue;
1003 if (demux->filter[i].filter.parent != &feed->feed.sec)
1004 continue;
1005 demux->filter[i].state = DMX_STATE_GO;
1006 if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
1007 ret = StartHWFilter(&demux->filter[i]);
1008 if (ret)
1009 break;
1010 }
1011 }
1012 }
1013
1014 return ret;
1015 }
1016
1017
1018 static int av7110_stop_feed(struct dvb_demux_feed *feed)
1019 {
1020 struct dvb_demux *demux = feed->demux;
1021 struct av7110 *av7110 = demux->priv;
1022 int i, rc, ret = 0;
1023 dprintk(4, "%p\n", av7110);
1024
1025 if (feed->type == DMX_TYPE_TS) {
1026 if (feed->ts_type & TS_DECODER) {
1027 if (feed->pes_type >= DMX_TS_PES_OTHER ||
1028 !demux->pesfilter[feed->pes_type])
1029 return -EINVAL;
1030 demux->pids[feed->pes_type] |= 0x8000;
1031 demux->pesfilter[feed->pes_type] = NULL;
1032 }
1033 if (feed->ts_type & TS_DECODER &&
1034 feed->pes_type < DMX_TS_PES_OTHER) {
1035 ret = dvb_feed_stop_pid(feed);
1036 } else
1037 if ((feed->ts_type & TS_PACKET) &&
1038 (demux->dmx.frontend->source != DMX_MEMORY_FE))
1039 ret = StopHWFilter(feed->filter);
1040 }
1041
1042 if (!ret && feed->type == DMX_TYPE_SEC) {
1043 for (i = 0; i<demux->filternum; i++) {
1044 if (demux->filter[i].state == DMX_STATE_GO &&
1045 demux->filter[i].filter.parent == &feed->feed.sec) {
1046 demux->filter[i].state = DMX_STATE_READY;
1047 if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
1048 rc = StopHWFilter(&demux->filter[i]);
1049 if (!ret)
1050 ret = rc;
1051 /* keep going, stop as many filters as possible */
1052 }
1053 }
1054 }
1055 }
1056
1057 return ret;
1058 }
1059
1060
1061 static void restart_feeds(struct av7110 *av7110)
1062 {
1063 struct dvb_demux *dvbdmx = &av7110->demux;
1064 struct dvb_demux_feed *feed;
1065 int mode;
1066 int i, j;
1067
1068 dprintk(4, "%p\n", av7110);
1069
1070 mode = av7110->playing;
1071 av7110->playing = 0;
1072 av7110->rec_mode = 0;
1073
1074 for (i = 0; i < dvbdmx->feednum; i++) {
1075 feed = &dvbdmx->feed[i];
1076 if (feed->state == DMX_STATE_GO) {
1077 if (feed->type == DMX_TYPE_SEC) {
1078 for (j = 0; j < dvbdmx->filternum; j++) {
1079 if (dvbdmx->filter[j].type != DMX_TYPE_SEC)
1080 continue;
1081 if (dvbdmx->filter[j].filter.parent != &feed->feed.sec)
1082 continue;
1083 if (dvbdmx->filter[j].state == DMX_STATE_GO)
1084 dvbdmx->filter[j].state = DMX_STATE_READY;
1085 }
1086 }
1087 av7110_start_feed(feed);
1088 }
1089 }
1090
1091 if (mode)
1092 av7110_av_start_play(av7110, mode);
1093 }
1094
1095 static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
1096 uint64_t *stc, unsigned int *base)
1097 {
1098 int ret;
1099 u16 fwstc[4];
1100 u16 tag = ((COMTYPE_REQUEST << 8) + ReqSTC);
1101 struct dvb_demux *dvbdemux;
1102 struct av7110 *av7110;
1103
1104 /* pointer casting paranoia... */
1105 BUG_ON(!demux);
1106 dvbdemux = demux->priv;
1107 BUG_ON(!dvbdemux);
1108 av7110 = dvbdemux->priv;
1109
1110 dprintk(4, "%p\n", av7110);
1111
1112 if (num != 0)
1113 return -EINVAL;
1114
1115 ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4);
1116 if (ret) {
1117 printk(KERN_ERR "%s: av7110_fw_request error\n", __FUNCTION__);
1118 return ret;
1119 }
1120 dprintk(2, "fwstc = %04hx %04hx %04hx %04hx\n",
1121 fwstc[0], fwstc[1], fwstc[2], fwstc[3]);
1122
1123 *stc = (((uint64_t) ((fwstc[3] & 0x8000) >> 15)) << 32) |
1124 (((uint64_t) fwstc[1]) << 16) | ((uint64_t) fwstc[0]);
1125 *base = 1;
1126
1127 dprintk(4, "stc = %lu\n", (unsigned long)*stc);
1128
1129 return 0;
1130 }
1131
1132
1133 /******************************************************************************
1134 * SEC device file operations
1135 ******************************************************************************/
1136
1137
1138 static int av7110_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
1139 {
1140 struct av7110* av7110 = fe->dvb->priv;
1141
1142 switch (tone) {
1143 case SEC_TONE_ON:
1144 return Set22K(av7110, 1);
1145
1146 case SEC_TONE_OFF:
1147 return Set22K(av7110, 0);
1148
1149 default:
1150 return -EINVAL;
1151 }
1152 }
1153
1154 static int av7110_diseqc_send_master_cmd(struct dvb_frontend* fe,
1155 struct dvb_diseqc_master_cmd* cmd)
1156 {
1157 struct av7110* av7110 = fe->dvb->priv;
1158
1159 return av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1);
1160 }
1161
1162 static int av7110_diseqc_send_burst(struct dvb_frontend* fe,
1163 fe_sec_mini_cmd_t minicmd)
1164 {
1165 struct av7110* av7110 = fe->dvb->priv;
1166
1167 return av7110_diseqc_send(av7110, 0, NULL, minicmd);
1168 }
1169
1170 /* simplified code from budget-core.c */
1171 static int stop_ts_capture(struct av7110 *budget)
1172 {
1173 dprintk(2, "budget: %p\n", budget);
1174
1175 if (--budget->feeding1)
1176 return budget->feeding1;
1177 saa7146_write(budget->dev, MC1, MASK_20); /* DMA3 off */
1178 SAA7146_IER_DISABLE(budget->dev, MASK_10);
1179 SAA7146_ISR_CLEAR(budget->dev, MASK_10);
1180 return 0;
1181 }
1182
1183 static int start_ts_capture(struct av7110 *budget)
1184 {
1185 dprintk(2, "budget: %p\n", budget);
1186
1187 if (budget->feeding1)
1188 return ++budget->feeding1;
1189 memset(budget->grabbing, 0x00, TS_HEIGHT * TS_WIDTH);
1190 budget->tsf = 0xff;
1191 budget->ttbp = 0;
1192 SAA7146_IER_ENABLE(budget->dev, MASK_10); /* VPE */
1193 saa7146_write(budget->dev, MC1, (MASK_04 | MASK_20)); /* DMA3 on */
1194 return ++budget->feeding1;
1195 }
1196
1197 static int budget_start_feed(struct dvb_demux_feed *feed)
1198 {
1199 struct dvb_demux *demux = feed->demux;
1200 struct av7110 *budget = demux->priv;
1201 int status;
1202
1203 dprintk(2, "av7110: %p\n", budget);
1204
1205 spin_lock(&budget->feedlock1);
1206 feed->pusi_seen = 0; /* have a clean section start */
1207 status = start_ts_capture(budget);
1208 spin_unlock(&budget->feedlock1);
1209 return status;
1210 }
1211
1212 static int budget_stop_feed(struct dvb_demux_feed *feed)
1213 {
1214 struct dvb_demux *demux = feed->demux;
1215 struct av7110 *budget = demux->priv;
1216 int status;
1217
1218 dprintk(2, "budget: %p\n", budget);
1219
1220 spin_lock(&budget->feedlock1);
1221 status = stop_ts_capture(budget);
1222 spin_unlock(&budget->feedlock1);
1223 return status;
1224 }
1225
1226 static void vpeirq(unsigned long data)
1227 {
1228 struct av7110 *budget = (struct av7110 *) data;
1229 u8 *mem = (u8 *) (budget->grabbing);
1230 u32 olddma = budget->ttbp;
1231 u32 newdma = saa7146_read(budget->dev, PCI_VDP3);
1232
1233 if (!budgetpatch) {
1234 printk("av7110.c: vpeirq() called while budgetpatch disabled!"
1235 " check saa7146 IER register\n");
1236 BUG();
1237 }
1238 /* nearest lower position divisible by 188 */
1239 newdma -= newdma % 188;
1240
1241 if (newdma >= TS_BUFLEN)
1242 return;
1243
1244 budget->ttbp = newdma;
1245
1246 if (!budget->feeding1 || (newdma == olddma))
1247 return;
1248
1249 /* Ensure streamed PCI data is synced to CPU */
1250 pci_dma_sync_sg_for_cpu(budget->dev->pci, budget->pt.slist, budget->pt.nents, PCI_DMA_FROMDEVICE);
1251
1252 #if 0
1253 /* track rps1 activity */
1254 printk("vpeirq: %02x Event Counter 1 0x%04x\n",
1255 mem[olddma],
1256 saa7146_read(budget->dev, EC1R) & 0x3fff);
1257 #endif
1258
1259 if (newdma > olddma)
1260 /* no wraparound, dump olddma..newdma */
1261 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (newdma - olddma) / 188);
1262 else {
1263 /* wraparound, dump olddma..buflen and 0..newdma */
1264 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (TS_BUFLEN - olddma) / 188);
1265 dvb_dmx_swfilter_packets(&budget->demux1, mem, newdma / 188);
1266 }
1267 }
1268
1269 static int av7110_register(struct av7110 *av7110)
1270 {
1271 int ret, i;
1272 struct dvb_demux *dvbdemux = &av7110->demux;
1273 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1274
1275 dprintk(4, "%p\n", av7110);
1276
1277 if (av7110->registered)
1278 return -1;
1279
1280 av7110->registered = 1;
1281
1282 dvbdemux->priv = (void *) av7110;
1283
1284 for (i = 0; i < 32; i++)
1285 av7110->handle2filter[i] = NULL;
1286
1287 dvbdemux->filternum = 32;
1288 dvbdemux->feednum = 32;
1289 dvbdemux->start_feed = av7110_start_feed;
1290 dvbdemux->stop_feed = av7110_stop_feed;
1291 dvbdemux->write_to_decoder = av7110_write_to_decoder;
1292 dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1293 DMX_MEMORY_BASED_FILTERING);
1294
1295 dvb_dmx_init(&av7110->demux);
1296 av7110->demux.dmx.get_stc = dvb_get_stc;
1297
1298 av7110->dmxdev.filternum = 32;
1299 av7110->dmxdev.demux = &dvbdemux->dmx;
1300 av7110->dmxdev.capabilities = 0;
1301
1302 dvb_dmxdev_init(&av7110->dmxdev, &av7110->dvb_adapter);
1303
1304 av7110->hw_frontend.source = DMX_FRONTEND_0;
1305
1306 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1307
1308 if (ret < 0)
1309 return ret;
1310
1311 av7110->mem_frontend.source = DMX_MEMORY_FE;
1312
1313 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1314
1315 if (ret < 0)
1316 return ret;
1317
1318 ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1319 &av7110->hw_frontend);
1320 if (ret < 0)
1321 return ret;
1322
1323 av7110_av_register(av7110);
1324 av7110_ca_register(av7110);
1325
1326 #ifdef CONFIG_DVB_AV7110_OSD
1327 dvb_register_device(&av7110->dvb_adapter, &av7110->osd_dev,
1328 &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1329 #endif
1330
1331 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1332
1333 if (budgetpatch) {
1334 /* initialize software demux1 without its own frontend
1335 * demux1 hardware is connected to frontend0 of demux0
1336 */
1337 dvbdemux1->priv = (void *) av7110;
1338
1339 dvbdemux1->filternum = 256;
1340 dvbdemux1->feednum = 256;
1341 dvbdemux1->start_feed = budget_start_feed;
1342 dvbdemux1->stop_feed = budget_stop_feed;
1343 dvbdemux1->write_to_decoder = NULL;
1344
1345 dvbdemux1->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1346 DMX_MEMORY_BASED_FILTERING);
1347
1348 dvb_dmx_init(&av7110->demux1);
1349
1350 av7110->dmxdev1.filternum = 256;
1351 av7110->dmxdev1.demux = &dvbdemux1->dmx;
1352 av7110->dmxdev1.capabilities = 0;
1353
1354 dvb_dmxdev_init(&av7110->dmxdev1, &av7110->dvb_adapter);
1355
1356 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net1, &dvbdemux1->dmx);
1357 printk("dvb-ttpci: additional demux1 for budget-patch registered\n");
1358 }
1359 return 0;
1360 }
1361
1362
1363 static void dvb_unregister(struct av7110 *av7110)
1364 {
1365 struct dvb_demux *dvbdemux = &av7110->demux;
1366 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1367
1368 dprintk(4, "%p\n", av7110);
1369
1370 if (!av7110->registered)
1371 return;
1372
1373 if (budgetpatch) {
1374 dvb_net_release(&av7110->dvb_net1);
1375 dvbdemux->dmx.close(&dvbdemux1->dmx);
1376 dvb_dmxdev_release(&av7110->dmxdev1);
1377 dvb_dmx_release(&av7110->demux1);
1378 }
1379
1380 dvb_net_release(&av7110->dvb_net);
1381
1382 dvbdemux->dmx.close(&dvbdemux->dmx);
1383 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1384 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1385
1386 dvb_dmxdev_release(&av7110->dmxdev);
1387 dvb_dmx_release(&av7110->demux);
1388
1389 if (av7110->fe != NULL) {
1390 dvb_unregister_frontend(av7110->fe);
1391 dvb_frontend_detach(av7110->fe);
1392 }
1393 dvb_unregister_device(av7110->osd_dev);
1394 av7110_av_unregister(av7110);
1395 av7110_ca_unregister(av7110);
1396 }
1397
1398
1399 /****************************************************************************
1400 * I2C client commands
1401 ****************************************************************************/
1402
1403 int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1404 {
1405 u8 msg[2] = { reg, val };
1406 struct i2c_msg msgs;
1407
1408 msgs.flags = 0;
1409 msgs.addr = id / 2;
1410 msgs.len = 2;
1411 msgs.buf = msg;
1412 return i2c_transfer(&av7110->i2c_adap, &msgs, 1);
1413 }
1414
1415 #if 0
1416 u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1417 {
1418 u8 mm1[] = {0x00};
1419 u8 mm2[] = {0x00};
1420 struct i2c_msg msgs[2];
1421
1422 msgs[0].flags = 0;
1423 msgs[1].flags = I2C_M_RD;
1424 msgs[0].addr = msgs[1].addr = id / 2;
1425 mm1[0] = reg;
1426 msgs[0].len = 1; msgs[1].len = 1;
1427 msgs[0].buf = mm1; msgs[1].buf = mm2;
1428 i2c_transfer(&av7110->i2c_adap, msgs, 2);
1429
1430 return mm2[0];
1431 }
1432 #endif
1433
1434 /****************************************************************************
1435 * INITIALIZATION
1436 ****************************************************************************/
1437
1438
1439 static int check_firmware(struct av7110* av7110)
1440 {
1441 u32 crc = 0, len = 0;
1442 unsigned char *ptr;
1443
1444 /* check for firmware magic */
1445 ptr = av7110->bin_fw;
1446 if (ptr[0] != 'A' || ptr[1] != 'V' ||
1447 ptr[2] != 'F' || ptr[3] != 'W') {
1448 printk("dvb-ttpci: this is not an av7110 firmware\n");
1449 return -EINVAL;
1450 }
1451 ptr += 4;
1452
1453 /* check dpram file */
1454 crc = ntohl(*(u32*) ptr);
1455 ptr += 4;
1456 len = ntohl(*(u32*) ptr);
1457 ptr += 4;
1458 if (len >= 512) {
1459 printk("dvb-ttpci: dpram file is way too big.\n");
1460 return -EINVAL;
1461 }
1462 if (crc != crc32_le(0, ptr, len)) {
1463 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1464 return -EINVAL;
1465 }
1466 av7110->bin_dpram = ptr;
1467 av7110->size_dpram = len;
1468 ptr += len;
1469
1470 /* check root file */
1471 crc = ntohl(*(u32*) ptr);
1472 ptr += 4;
1473 len = ntohl(*(u32*) ptr);
1474 ptr += 4;
1475
1476 if (len <= 200000 || len >= 300000 ||
1477 len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1478 printk("dvb-ttpci: root file has strange size (%d). aborting.\n", len);
1479 return -EINVAL;
1480 }
1481 if( crc != crc32_le(0, ptr, len)) {
1482 printk("dvb-ttpci: crc32 of root file does not match.\n");
1483 return -EINVAL;
1484 }
1485 av7110->bin_root = ptr;
1486 av7110->size_root = len;
1487 return 0;
1488 }
1489
1490 #ifdef CONFIG_DVB_AV7110_FIRMWARE_FILE
1491 #include "av7110_firm.h"
1492 static void put_firmware(struct av7110* av7110)
1493 {
1494 av7110->bin_fw = NULL;
1495 }
1496
1497 static inline int get_firmware(struct av7110* av7110)
1498 {
1499 av7110->bin_fw = dvb_ttpci_fw;
1500 av7110->size_fw = sizeof(dvb_ttpci_fw);
1501 return check_firmware(av7110);
1502 }
1503 #else
1504 static void put_firmware(struct av7110* av7110)
1505 {
1506 vfree(av7110->bin_fw);
1507 }
1508
1509 static int get_firmware(struct av7110* av7110)
1510 {
1511 int ret;
1512 const struct firmware *fw;
1513
1514 /* request the av7110 firmware, this will block until someone uploads it */
1515 ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev);
1516 if (ret) {
1517 if (ret == -ENOENT) {
1518 printk(KERN_ERR "dvb-ttpci: could not load firmware,"
1519 " file not found: dvb-ttpci-01.fw\n");
1520 printk(KERN_ERR "dvb-ttpci: usually this should be in "
1521 "/usr/lib/hotplug/firmware or /lib/firmware\n");
1522 printk(KERN_ERR "dvb-ttpci: and can be downloaded from"
1523 " http://www.linuxtv.org/download/dvb/firmware/\n");
1524 } else
1525 printk(KERN_ERR "dvb-ttpci: cannot request firmware"
1526 " (error %i)\n", ret);
1527 return -EINVAL;
1528 }
1529
1530 if (fw->size <= 200000) {
1531 printk("dvb-ttpci: this firmware is way too small.\n");
1532 release_firmware(fw);
1533 return -EINVAL;
1534 }
1535
1536 /* check if the firmware is available */
1537 av7110->bin_fw = (unsigned char *) vmalloc(fw->size);
1538 if (NULL == av7110->bin_fw) {
1539 dprintk(1, "out of memory\n");
1540 release_firmware(fw);
1541 return -ENOMEM;
1542 }
1543
1544 memcpy(av7110->bin_fw, fw->data, fw->size);
1545 av7110->size_fw = fw->size;
1546 if ((ret = check_firmware(av7110)))
1547 vfree(av7110->bin_fw);
1548
1549 release_firmware(fw);
1550 return ret;
1551 }
1552 #endif
1553
1554
1555 static int alps_bsrv2_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1556 {
1557 struct av7110* av7110 = fe->dvb->priv;
1558 u8 pwr = 0;
1559 u8 buf[4];
1560 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) };
1561 u32 div = (params->frequency + 479500) / 125;
1562
1563 if (params->frequency > 2000000) pwr = 3;
1564 else if (params->frequency > 1800000) pwr = 2;
1565 else if (params->frequency > 1600000) pwr = 1;
1566 else if (params->frequency > 1200000) pwr = 0;
1567 else if (params->frequency >= 1100000) pwr = 1;
1568 else pwr = 2;
1569
1570 buf[0] = (div >> 8) & 0x7f;
1571 buf[1] = div & 0xff;
1572 buf[2] = ((div & 0x18000) >> 10) | 0x95;
1573 buf[3] = (pwr << 6) | 0x30;
1574
1575 // NOTE: since we're using a prescaler of 2, we set the
1576 // divisor frequency to 62.5kHz and divide by 125 above
1577
1578 if (fe->ops.i2c_gate_ctrl)
1579 fe->ops.i2c_gate_ctrl(fe, 1);
1580 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1581 return -EIO;
1582 return 0;
1583 }
1584
1585 static struct ves1x93_config alps_bsrv2_config = {
1586 .demod_address = 0x08,
1587 .xin = 90100000UL,
1588 .invert_pwm = 0,
1589 };
1590
1591 static int alps_tdbe2_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1592 {
1593 struct av7110* av7110 = fe->dvb->priv;
1594 u32 div;
1595 u8 data[4];
1596 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1597
1598 div = (params->frequency + 35937500 + 31250) / 62500;
1599
1600 data[0] = (div >> 8) & 0x7f;
1601 data[1] = div & 0xff;
1602 data[2] = 0x85 | ((div >> 10) & 0x60);
1603 data[3] = (params->frequency < 174000000 ? 0x88 : params->frequency < 470000000 ? 0x84 : 0x81);
1604
1605 if (fe->ops.i2c_gate_ctrl)
1606 fe->ops.i2c_gate_ctrl(fe, 1);
1607 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1608 return -EIO;
1609 return 0;
1610 }
1611
1612 static struct ves1820_config alps_tdbe2_config = {
1613 .demod_address = 0x09,
1614 .xin = 57840000UL,
1615 .invert = 1,
1616 .selagc = VES1820_SELAGC_SIGNAMPERR,
1617 };
1618
1619
1620
1621
1622 static int grundig_29504_451_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1623 {
1624 struct av7110* av7110 = fe->dvb->priv;
1625 u32 div;
1626 u8 data[4];
1627 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1628
1629 div = params->frequency / 125;
1630 data[0] = (div >> 8) & 0x7f;
1631 data[1] = div & 0xff;
1632 data[2] = 0x8e;
1633 data[3] = 0x00;
1634
1635 if (fe->ops.i2c_gate_ctrl)
1636 fe->ops.i2c_gate_ctrl(fe, 1);
1637 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1638 return -EIO;
1639 return 0;
1640 }
1641
1642 static struct tda8083_config grundig_29504_451_config = {
1643 .demod_address = 0x68,
1644 };
1645
1646
1647
1648 static int philips_cd1516_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1649 {
1650 struct av7110* av7110 = fe->dvb->priv;
1651 u32 div;
1652 u32 f = params->frequency;
1653 u8 data[4];
1654 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1655
1656 div = (f + 36125000 + 31250) / 62500;
1657
1658 data[0] = (div >> 8) & 0x7f;
1659 data[1] = div & 0xff;
1660 data[2] = 0x8e;
1661 data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1662
1663 if (fe->ops.i2c_gate_ctrl)
1664 fe->ops.i2c_gate_ctrl(fe, 1);
1665 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1666 return -EIO;
1667 return 0;
1668 }
1669
1670 static struct ves1820_config philips_cd1516_config = {
1671 .demod_address = 0x09,
1672 .xin = 57840000UL,
1673 .invert = 1,
1674 .selagc = VES1820_SELAGC_SIGNAMPERR,
1675 };
1676
1677
1678
1679 static int alps_tdlb7_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1680 {
1681 struct av7110* av7110 = fe->dvb->priv;
1682 u32 div, pwr;
1683 u8 data[4];
1684 struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1685
1686 div = (params->frequency + 36200000) / 166666;
1687
1688 if (params->frequency <= 782000000)
1689 pwr = 1;
1690 else
1691 pwr = 2;
1692
1693 data[0] = (div >> 8) & 0x7f;
1694 data[1] = div & 0xff;
1695 data[2] = 0x85;
1696 data[3] = pwr << 6;
1697
1698 if (fe->ops.i2c_gate_ctrl)
1699 fe->ops.i2c_gate_ctrl(fe, 1);
1700 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1701 return -EIO;
1702 return 0;
1703 }
1704
1705 static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1706 {
1707 #if defined(CONFIG_DVB_SP8870) || defined(CONFIG_DVB_SP8870_MODULE)
1708 struct av7110* av7110 = fe->dvb->priv;
1709
1710 return request_firmware(fw, name, &av7110->dev->pci->dev);
1711 #else
1712 return -EINVAL;
1713 #endif
1714 }
1715
1716 static struct sp8870_config alps_tdlb7_config = {
1717
1718 .demod_address = 0x71,
1719 .request_firmware = alps_tdlb7_request_firmware,
1720 };
1721
1722
1723 static u8 nexusca_stv0297_inittab[] = {
1724 0x80, 0x01,
1725 0x80, 0x00,
1726 0x81, 0x01,
1727 0x81, 0x00,
1728 0x00, 0x09,
1729 0x01, 0x69,
1730 0x03, 0x00,
1731 0x04, 0x00,
1732 0x07, 0x00,
1733 0x08, 0x00,
1734 0x20, 0x00,
1735 0x21, 0x40,
1736 0x22, 0x00,
1737 0x23, 0x00,
1738 0x24, 0x40,
1739 0x25, 0x88,
1740 0x30, 0xff,
1741 0x31, 0x00,
1742 0x32, 0xff,
1743 0x33, 0x00,
1744 0x34, 0x50,
1745 0x35, 0x7f,
1746 0x36, 0x00,
1747 0x37, 0x20,
1748 0x38, 0x00,
1749 0x40, 0x1c,
1750 0x41, 0xff,
1751 0x42, 0x29,
1752 0x43, 0x00,
1753 0x44, 0xff,
1754 0x45, 0x00,
1755 0x46, 0x00,
1756 0x49, 0x04,
1757 0x4a, 0x00,
1758 0x4b, 0x7b,
1759 0x52, 0x30,
1760 0x55, 0xae,
1761 0x56, 0x47,
1762 0x57, 0xe1,
1763 0x58, 0x3a,
1764 0x5a, 0x1e,
1765 0x5b, 0x34,
1766 0x60, 0x00,
1767 0x63, 0x00,
1768 0x64, 0x00,
1769 0x65, 0x00,
1770 0x66, 0x00,
1771 0x67, 0x00,
1772 0x68, 0x00,
1773 0x69, 0x00,
1774 0x6a, 0x02,
1775 0x6b, 0x00,
1776 0x70, 0xff,
1777 0x71, 0x00,
1778 0x72, 0x00,
1779 0x73, 0x00,
1780 0x74, 0x0c,
1781 0x80, 0x00,
1782 0x81, 0x00,
1783 0x82, 0x00,
1784 0x83, 0x00,
1785 0x84, 0x04,
1786 0x85, 0x80,
1787 0x86, 0x24,
1788 0x87, 0x78,
1789 0x88, 0x10,
1790 0x89, 0x00,
1791 0x90, 0x01,
1792 0x91, 0x01,
1793 0xa0, 0x04,
1794 0xa1, 0x00,
1795 0xa2, 0x00,
1796 0xb0, 0x91,
1797 0xb1, 0x0b,
1798 0xc0, 0x53,
1799 0xc1, 0x70,
1800 0xc2, 0x12,
1801 0xd0, 0x00,
1802 0xd1, 0x00,
1803 0xd2, 0x00,
1804 0xd3, 0x00,
1805 0xd4, 0x00,
1806 0xd5, 0x00,
1807 0xde, 0x00,
1808 0xdf, 0x00,
1809 0x61, 0x49,
1810 0x62, 0x0b,
1811 0x53, 0x08,
1812 0x59, 0x08,
1813 0xff, 0xff,
1814 };
1815
1816 static int nexusca_stv0297_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1817 {
1818 struct av7110* av7110 = fe->dvb->priv;
1819 u32 div;
1820 u8 data[4];
1821 struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
1822 struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
1823 int i;
1824
1825 div = (params->frequency + 36150000 + 31250) / 62500;
1826
1827 data[0] = (div >> 8) & 0x7f;
1828 data[1] = div & 0xff;
1829 data[2] = 0xce;
1830
1831 if (params->frequency < 45000000)
1832 return -EINVAL;
1833 else if (params->frequency < 137000000)
1834 data[3] = 0x01;
1835 else if (params->frequency < 403000000)
1836 data[3] = 0x02;
1837 else if (params->frequency < 860000000)
1838 data[3] = 0x04;
1839 else
1840 return -EINVAL;
1841
1842 if (fe->ops.i2c_gate_ctrl)
1843 fe->ops.i2c_gate_ctrl(fe, 1);
1844 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) {
1845 printk("nexusca: pll transfer failed!\n");
1846 return -EIO;
1847 }
1848
1849 // wait for PLL lock
1850 for(i = 0; i < 20; i++) {
1851 if (fe->ops.i2c_gate_ctrl)
1852 fe->ops.i2c_gate_ctrl(fe, 1);
1853 if (i2c_transfer(&av7110->i2c_adap, &readmsg, 1) == 1)
1854 if (data[0] & 0x40) break;
1855 msleep(10);
1856 }
1857
1858 return 0;
1859 }
1860
1861 static struct stv0297_config nexusca_stv0297_config = {
1862
1863 .demod_address = 0x1C,
1864 .inittab = nexusca_stv0297_inittab,
1865 .invert = 1,
1866 .stop_during_read = 1,
1867 };
1868
1869
1870
1871 static int grundig_29504_401_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1872 {
1873 struct av7110* av7110 = fe->dvb->priv;
1874 u32 div;
1875 u8 cfg, cpump, band_select;
1876 u8 data[4];
1877 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1878
1879 div = (36125000 + params->frequency) / 166666;
1880
1881 cfg = 0x88;
1882
1883 if (params->frequency < 175000000) cpump = 2;
1884 else if (params->frequency < 390000000) cpump = 1;
1885 else if (params->frequency < 470000000) cpump = 2;
1886 else if (params->frequency < 750000000) cpump = 1;
1887 else cpump = 3;
1888
1889 if (params->frequency < 175000000) band_select = 0x0e;
1890 else if (params->frequency < 470000000) band_select = 0x05;
1891 else band_select = 0x03;
1892
1893 data[0] = (div >> 8) & 0x7f;
1894 data[1] = div & 0xff;
1895 data[2] = ((div >> 10) & 0x60) | cfg;
1896 data[3] = (cpump << 6) | band_select;
1897
1898 if (fe->ops.i2c_gate_ctrl)
1899 fe->ops.i2c_gate_ctrl(fe, 1);
1900 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) return -EIO;
1901 return 0;
1902 }
1903
1904 static struct l64781_config grundig_29504_401_config = {
1905 .demod_address = 0x55,
1906 };
1907
1908
1909
1910 static int av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
1911 {
1912 int ret = 0;
1913 int synced = (status & FE_HAS_LOCK) ? 1 : 0;
1914
1915 av7110->fe_status = status;
1916
1917 if (av7110->fe_synced == synced)
1918 return 0;
1919
1920 if (av7110->playing) {
1921 av7110->fe_synced = synced;
1922 return 0;
1923 }
1924
1925 if (mutex_lock_interruptible(&av7110->pid_mutex))
1926 return -ERESTARTSYS;
1927
1928 if (synced) {
1929 ret = SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
1930 av7110->pids[DMX_PES_AUDIO],
1931 av7110->pids[DMX_PES_TELETEXT], 0,
1932 av7110->pids[DMX_PES_PCR]);
1933 if (!ret)
1934 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
1935 } else {
1936 ret = SetPIDs(av7110, 0, 0, 0, 0, 0);
1937 if (!ret) {
1938 ret = av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
1939 if (!ret)
1940 ret = av7110_wait_msgstate(av7110, GPMQBusy);
1941 }
1942 }
1943
1944 if (!ret)
1945 av7110->fe_synced = synced;
1946
1947 mutex_unlock(&av7110->pid_mutex);
1948 return ret;
1949 }
1950
1951 static int av7110_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1952 {
1953 struct av7110* av7110 = fe->dvb->priv;
1954
1955 int ret = av7110_fe_lock_fix(av7110, 0);
1956 if (!ret) {
1957 av7110->saved_fe_params = *params;
1958 ret = av7110->fe_set_frontend(fe, params);
1959 }
1960 return ret;
1961 }
1962
1963 static int av7110_fe_init(struct dvb_frontend* fe)
1964 {
1965 struct av7110* av7110 = fe->dvb->priv;
1966
1967 int ret = av7110_fe_lock_fix(av7110, 0);
1968 if (!ret)
1969 ret = av7110->fe_init(fe);
1970 return ret;
1971 }
1972
1973 static int av7110_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
1974 {
1975 struct av7110* av7110 = fe->dvb->priv;
1976
1977 /* call the real implementation */
1978 int ret = av7110->fe_read_status(fe, status);
1979 if (!ret)
1980 if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK))
1981 ret = av7110_fe_lock_fix(av7110, *status);
1982 return ret;
1983 }
1984
1985 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
1986 {
1987 struct av7110* av7110 = fe->dvb->priv;
1988
1989 int ret = av7110_fe_lock_fix(av7110, 0);
1990 if (!ret)
1991 ret = av7110->fe_diseqc_reset_overload(fe);
1992 return ret;
1993 }
1994
1995 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
1996 struct dvb_diseqc_master_cmd* cmd)
1997 {
1998 struct av7110* av7110 = fe->dvb->priv;
1999
2000 int ret = av7110_fe_lock_fix(av7110, 0);
2001 if (!ret) {
2002 av7110->saved_master_cmd = *cmd;
2003 ret = av7110->fe_diseqc_send_master_cmd(fe, cmd);
2004 }
2005 return ret;
2006 }
2007
2008 static int av7110_fe_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t minicmd)
2009 {
2010 struct av7110* av7110 = fe->dvb->priv;
2011
2012 int ret = av7110_fe_lock_fix(av7110, 0);
2013 if (!ret) {
2014 av7110->saved_minicmd = minicmd;
2015 ret = av7110->fe_diseqc_send_burst(fe, minicmd);
2016 }
2017 return ret;
2018 }
2019
2020 static int av7110_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
2021 {
2022 struct av7110* av7110 = fe->dvb->priv;
2023
2024 int ret = av7110_fe_lock_fix(av7110, 0);
2025 if (!ret) {
2026 av7110->saved_tone = tone;
2027 ret = av7110->fe_set_tone(fe, tone);
2028 }
2029 return ret;
2030 }
2031
2032 static int av7110_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
2033 {
2034 struct av7110* av7110 = fe->dvb->priv;
2035
2036 int ret = av7110_fe_lock_fix(av7110, 0);
2037 if (!ret) {
2038 av7110->saved_voltage = voltage;
2039 ret = av7110->fe_set_voltage(fe, voltage);
2040 }
2041 return ret;
2042 }
2043
2044 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned long cmd)
2045 {
2046 struct av7110* av7110 = fe->dvb->priv;
2047
2048 int ret = av7110_fe_lock_fix(av7110, 0);
2049 if (!ret)
2050 ret = av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
2051 return ret;
2052 }
2053
2054 static void dvb_s_recover(struct av7110* av7110)
2055 {
2056 av7110_fe_init(av7110->fe);
2057
2058 av7110_fe_set_voltage(av7110->fe, av7110->saved_voltage);
2059 if (av7110->saved_master_cmd.msg_len) {
2060 msleep(20);
2061 av7110_fe_diseqc_send_master_cmd(av7110->fe, &av7110->saved_master_cmd);
2062 }
2063 msleep(20);
2064 av7110_fe_diseqc_send_burst(av7110->fe, av7110->saved_minicmd);
2065 msleep(20);
2066 av7110_fe_set_tone(av7110->fe, av7110->saved_tone);
2067
2068 av7110_fe_set_frontend(av7110->fe, &av7110->saved_fe_params);
2069 }
2070
2071 static u8 read_pwm(struct av7110* av7110)
2072 {
2073 u8 b = 0xff;
2074 u8 pwm;
2075 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
2076 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
2077
2078 if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
2079 pwm = 0x48;
2080
2081 return pwm;
2082 }
2083
2084 static int frontend_init(struct av7110 *av7110)
2085 {
2086 int ret;
2087
2088 if (av7110->dev->pci->subsystem_vendor == 0x110a) {
2089 switch(av7110->dev->pci->subsystem_device) {
2090 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
2091 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config,
2092 &av7110->i2c_adap, read_pwm(av7110));
2093 if (av7110->fe) {
2094 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2095 }
2096 break;
2097 }
2098
2099 } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
2100 switch(av7110->dev->pci->subsystem_device) {
2101 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
2102 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
2103 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
2104
2105 // try the ALPS BSRV2 first of all
2106 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2107 if (av7110->fe) {
2108 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2109 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2110 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2111 av7110->fe->ops.set_tone = av7110_set_tone;
2112 av7110->recover = dvb_s_recover;
2113 break;
2114 }
2115
2116 // try the ALPS BSRU6 now
2117 av7110->fe = dvb_attach(stv0299_attach, &alps_bsru6_config, &av7110->i2c_adap);
2118 if (av7110->fe) {
2119 av7110->fe->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
2120 av7110->fe->tuner_priv = &av7110->i2c_adap;
2121
2122 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2123 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2124 av7110->fe->ops.set_tone = av7110_set_tone;
2125 av7110->recover = dvb_s_recover;
2126 break;
2127 }
2128
2129 // Try the grundig 29504-451
2130 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2131 if (av7110->fe) {
2132 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2133 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2134 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2135 av7110->fe->ops.set_tone = av7110_set_tone;
2136 av7110->recover = dvb_s_recover;
2137 break;
2138 }
2139
2140 /* Try DVB-C cards */
2141 switch(av7110->dev->pci->subsystem_device) {
2142 case 0x0000:
2143 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
2144 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config, &av7110->i2c_adap,
2145 read_pwm(av7110));
2146 if (av7110->fe) {
2147 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2148 }
2149 break;
2150 case 0x0003:
2151 /* Hauppauge DVB-C 2.1 VES1820/ALPS TDBE2 */
2152 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap,
2153 read_pwm(av7110));
2154 if (av7110->fe) {
2155 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2156 }
2157 break;
2158 }
2159 break;
2160
2161 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
2162 // try ALPS TDLB7 first, then Grundig 29504-401
2163 av7110->fe = dvb_attach(sp8870_attach, &alps_tdlb7_config, &av7110->i2c_adap);
2164 if (av7110->fe) {
2165 av7110->fe->ops.tuner_ops.set_params = alps_tdlb7_tuner_set_params;
2166 break;
2167 }
2168 /* fall-thru */
2169
2170 case 0x0008: // Hauppauge/TT DVB-T
2171 // Grundig 29504-401
2172 av7110->fe = dvb_attach(l64781_attach, &grundig_29504_401_config, &av7110->i2c_adap);
2173 if (av7110->fe)
2174 av7110->fe->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params;
2175 break;
2176
2177 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
2178
2179 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
2180 if (av7110->fe) {
2181 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2182 }
2183 break;
2184
2185 case 0x0004: // Galaxis DVB-S rev1.3
2186 /* ALPS BSRV2 */
2187 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2188 if (av7110->fe) {
2189 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2190 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2191 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2192 av7110->fe->ops.set_tone = av7110_set_tone;
2193 av7110->recover = dvb_s_recover;
2194 }
2195 break;
2196
2197 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
2198 /* Grundig 29504-451 */
2199 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2200 if (av7110->fe) {
2201 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2202 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2203 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2204 av7110->fe->ops.set_tone = av7110_set_tone;
2205 av7110->recover = dvb_s_recover;
2206 }
2207 break;
2208
2209 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
2210
2211 av7110->fe = dvb_attach(stv0297_attach, &nexusca_stv0297_config, &av7110->i2c_adap);
2212 if (av7110->fe) {
2213 av7110->fe->ops.tuner_ops.set_params = nexusca_stv0297_tuner_set_params;
2214
2215 /* set TDA9819 into DVB mode */
2216 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
2217 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
2218
2219 /* tuner on this needs a slower i2c bus speed */
2220 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
2221 break;
2222 }
2223 break;
2224
2225 case 0x000E: /* Hauppauge/TT Nexus-S rev 2.3 */
2226 /* ALPS BSBE1 */
2227 av7110->fe = dvb_attach(stv0299_attach, &alps_bsbe1_config, &av7110->i2c_adap);
2228 if (av7110->fe) {
2229 av7110->fe->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
2230 av7110->fe->tuner_priv = &av7110->i2c_adap;
2231
2232 if (dvb_attach(lnbp21_attach, av7110->fe, &av7110->i2c_adap, 0, 0) == NULL) {
2233 printk("dvb-ttpci: LNBP21 not found!\n");
2234 if (av7110->fe->ops.release)
2235 av7110->fe->ops.release(av7110->fe);
2236 av7110->fe = NULL;
2237 } else {
2238 av7110->fe->ops.dishnetwork_send_legacy_command = NULL;
2239 av7110->recover = dvb_s_recover;
2240 }
2241 }
2242 break;
2243 }
2244 }
2245
2246 if (!av7110->fe) {
2247 /* FIXME: propagate the failure code from the lower layers */
2248 ret = -ENOMEM;
2249 printk("dvb-ttpci: A frontend driver was not found for device %04x/%04x subsystem %04x/%04x\n",
2250 av7110->dev->pci->vendor,
2251 av7110->dev->pci->device,
2252 av7110->dev->pci->subsystem_vendor,
2253 av7110->dev->pci->subsystem_device);
2254 } else {
2255 FE_FUNC_OVERRIDE(av7110->fe->ops.init, av7110->fe_init, av7110_fe_init);
2256 FE_FUNC_OVERRIDE(av7110->fe->ops.read_status, av7110->fe_read_status, av7110_fe_read_status);
2257 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
2258 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
2259 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
2260 FE_FUNC_OVERRIDE(av7110->fe->ops.set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
2261 FE_FUNC_OVERRIDE(av7110->fe->ops.set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage;)
2262 FE_FUNC_OVERRIDE(av7110->fe->ops.dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
2263 FE_FUNC_OVERRIDE(av7110->fe->ops.set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
2264
2265 ret = dvb_register_frontend(&av7110->dvb_adapter, av7110->fe);
2266 if (ret < 0) {
2267 printk("av7110: Frontend registration failed!\n");
2268 dvb_frontend_detach(av7110->fe);
2269 av7110->fe = NULL;
2270 }
2271 }
2272 return ret;
2273 }
2274
2275 /* Budgetpatch note:
2276 * Original hardware design by Roberto Deza:
2277 * There is a DVB_Wiki at
2278 * http://212.227.36.83/linuxtv/wiki/index.php/Main_Page
2279 * where is described this 'DVB TT Budget Patch', on Card Modding:
2280 * http://212.227.36.83/linuxtv/wiki/index.php/DVB_TT_Budget_Patch
2281 * On the short description there is also a link to a external file,
2282 * with more details:
2283 * http://perso.wanadoo.es/jesussolano/Ttf_tsc1.zip
2284 *
2285 * New software triggering design by Emard that works on
2286 * original Roberto Deza's hardware:
2287 *
2288 * rps1 code for budgetpatch will copy internal HS event to GPIO3 pin.
2289 * GPIO3 is in budget-patch hardware connectd to port B VSYNC
2290 * HS is an internal event of 7146, accessible with RPS
2291 * and temporarily raised high every n lines
2292 * (n in defined in the RPS_THRESH1 counter threshold)
2293 * I think HS is raised high on the beginning of the n-th line
2294 * and remains high until this n-th line that triggered
2295 * it is completely received. When the receiption of n-th line
2296 * ends, HS is lowered.
2297 *
2298 * To transmit data over DMA, 7146 needs changing state at
2299 * port B VSYNC pin. Any changing of port B VSYNC will
2300 * cause some DMA data transfer, with more or less packets loss.
2301 * It depends on the phase and frequency of VSYNC and
2302 * the way of 7146 is instructed to trigger on port B (defined
2303 * in DD1_INIT register, 3rd nibble from the right valid
2304 * numbers are 0-7, see datasheet)
2305 *
2306 * The correct triggering can minimize packet loss,
2307 * dvbtraffic should give this stable bandwidths:
2308 * 22k transponder = 33814 kbit/s
2309 * 27.5k transponder = 38045 kbit/s
2310 * by experiment it is found that the best results
2311 * (stable bandwidths and almost no packet loss)
2312 * are obtained using DD1_INIT triggering number 2
2313 * (Va at rising edge of VS Fa = HS x VS-failing forced toggle)
2314 * and a VSYNC phase that occurs in the middle of DMA transfer
2315 * (about byte 188*512=96256 in the DMA window).
2316 *
2317 * Phase of HS is still not clear to me how to control,
2318 * It just happens to be so. It can be seen if one enables
2319 * RPS_IRQ and print Event Counter 1 in vpeirq(). Every
2320 * time RPS_INTERRUPT is called, the Event Counter 1 will
2321 * increment. That's how the 7146 is programmed to do event
2322 * counting in this budget-patch.c
2323 * I *think* HPS setting has something to do with the phase
2324 * of HS but I cant be 100% sure in that.
2325 *
2326 * hardware debug note: a working budget card (including budget patch)
2327 * with vpeirq() interrupt setup in mode "0x90" (every 64K) will
2328 * generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes
2329 * and that means 3*25=75 Hz of interrupt freqency, as seen by
2330 * watch cat /proc/interrupts
2331 *
2332 * If this frequency is 3x lower (and data received in the DMA
2333 * buffer don't start with 0x47, but in the middle of packets,
2334 * whose lengths appear to be like 188 292 188 104 etc.
2335 * this means VSYNC line is not connected in the hardware.
2336 * (check soldering pcb and pins)
2337 * The same behaviour of missing VSYNC can be duplicated on budget
2338 * cards, by seting DD1_INIT trigger mode 7 in 3rd nibble.
2339 */
2340 static int __devinit av7110_attach(struct saa7146_dev* dev,
2341 struct saa7146_pci_extension_data *pci_ext)
2342 {
2343 const int length = TS_WIDTH * TS_HEIGHT;
2344 struct pci_dev *pdev = dev->pci;
2345 struct av7110 *av7110;
2346 struct task_struct *thread;
2347 int ret, count = 0;
2348
2349 dprintk(4, "dev: %p\n", dev);
2350
2351 /* Set RPS_IRQ to 1 to track rps1 activity.
2352 * Enabling this won't send any interrupt to PC CPU.
2353 */
2354 #define RPS_IRQ 0
2355
2356 if (budgetpatch == 1) {
2357 budgetpatch = 0;
2358 /* autodetect the presence of budget patch
2359 * this only works if saa7146 has been recently
2360 * reset with with MASK_31 to MC1
2361 *
2362 * will wait for VBI_B event (vertical blank at port B)
2363 * and will reset GPIO3 after VBI_B is detected.
2364 * (GPIO3 should be raised high by CPU to
2365 * test if GPIO3 will generate vertical blank signal
2366 * in budget patch GPIO3 is connected to VSYNC_B
2367 */
2368
2369 /* RESET SAA7146 */
2370 saa7146_write(dev, MC1, MASK_31);
2371 /* autodetection success seems to be time-dependend after reset */
2372
2373 /* Fix VSYNC level */
2374 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2375 /* set vsync_b triggering */
2376 saa7146_write(dev, DD1_STREAM_B, 0);
2377 /* port B VSYNC at rising edge */
2378 saa7146_write(dev, DD1_INIT, 0x00000200);
2379 saa7146_write(dev, BRS_CTRL, 0x00000000); // VBI
2380 saa7146_write(dev, MC2,
2381 1 * (MASK_08 | MASK_24) | // BRS control
2382 0 * (MASK_09 | MASK_25) | // a
2383 1 * (MASK_10 | MASK_26) | // b
2384 0 * (MASK_06 | MASK_22) | // HPS_CTRL1
2385 0 * (MASK_05 | MASK_21) | // HPS_CTRL2
2386 0 * (MASK_01 | MASK_15) // DEBI
2387 );
2388
2389 /* start writing RPS1 code from beginning */
2390 count = 0;
2391 /* Disable RPS1 */
2392 saa7146_write(dev, MC1, MASK_29);
2393 /* RPS1 timeout disable */
2394 saa7146_write(dev, RPS_TOV1, 0);
2395 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_VBI_B));
2396 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2397 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2398 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTLO<<24));
2399 #if RPS_IRQ
2400 /* issue RPS1 interrupt to increment counter */
2401 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2402 #endif
2403 WRITE_RPS1(cpu_to_le32(CMD_STOP));
2404 /* Jump to begin of RPS program as safety measure (p37) */
2405 WRITE_RPS1(cpu_to_le32(CMD_JUMP));
2406 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle));
2407
2408 #if RPS_IRQ
2409 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2410 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2411 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2412 */
2413 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2414 /* set event counter 1 treshold to maximum allowed value (rEC p55) */
2415 saa7146_write(dev, ECT1R, 0x3fff );
2416 #endif
2417 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2418 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2419 /* Enable RPS1, (rFC p33) */
2420 saa7146_write(dev, MC1, (MASK_13 | MASK_29 ));
2421
2422 mdelay(10);
2423 /* now send VSYNC_B to rps1 by rising GPIO3 */
2424 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI);
2425 mdelay(10);
2426 /* if rps1 responded by lowering the GPIO3,
2427 * then we have budgetpatch hardware
2428 */
2429 if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) {
2430 budgetpatch = 1;
2431 printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2432 }
2433 /* Disable RPS1 */
2434 saa7146_write(dev, MC1, ( MASK_29 ));
2435 #if RPS_IRQ
2436 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff );
2437 #endif
2438 }
2439
2440 /* prepare the av7110 device struct */
2441 av7110 = kzalloc(sizeof(struct av7110), GFP_KERNEL);
2442 if (!av7110) {
2443 dprintk(1, "out of memory\n");
2444 return -ENOMEM;
2445 }
2446
2447 av7110->card_name = (char*) pci_ext->ext_priv;
2448 av7110->dev = dev;
2449 dev->ext_priv = av7110;
2450
2451 ret = get_firmware(av7110);
2452 if (ret < 0)
2453 goto err_kfree_0;
2454
2455 ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name,
2456 THIS_MODULE, &dev->pci->dev);
2457 if (ret < 0)
2458 goto err_put_firmware_1;
2459
2460 /* the Siemens DVB needs this if you want to have the i2c chips
2461 get recognized before the main driver is fully loaded */
2462 saa7146_write(dev, GPIO_CTRL, 0x500000);
2463
2464 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
2465 av7110->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL;
2466 #else
2467 av7110->i2c_adap.class = I2C_CLASS_TV_DIGITAL;
2468 #endif
2469 strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
2470
2471 saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
2472
2473 ret = i2c_add_adapter(&av7110->i2c_adap);
2474 if (ret < 0)
2475 goto err_dvb_unregister_adapter_2;
2476
2477 ttpci_eeprom_parse_mac(&av7110->i2c_adap,
2478 av7110->dvb_adapter.proposed_mac);
2479 ret = -ENOMEM;
2480
2481 if (budgetpatch) {
2482 spin_lock_init(&av7110->feedlock1);
2483 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2484 &av7110->pt);
2485 if (!av7110->grabbing)
2486 goto err_i2c_del_3;
2487
2488 saa7146_write(dev, PCI_BT_V1, 0x1c1f101f);
2489 saa7146_write(dev, BCS_CTRL, 0x80400040);
2490 /* set dd1 stream a & b */
2491 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2492 saa7146_write(dev, DD1_INIT, 0x03000200);
2493 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2494 saa7146_write(dev, BRS_CTRL, 0x60000000);
2495 saa7146_write(dev, BASE_ODD3, 0);
2496 saa7146_write(dev, BASE_EVEN3, 0);
2497 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2498 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2499
2500 saa7146_write(dev, PITCH3, TS_WIDTH);
2501 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2502
2503 /* upload all */
2504 saa7146_write(dev, MC2, 0x077c077c);
2505 saa7146_write(dev, GPIO_CTRL, 0x000000);
2506 #if RPS_IRQ
2507 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2508 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2509 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2510 */
2511 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2512 /* set event counter 1 treshold to maximum allowed value (rEC p55) */
2513 saa7146_write(dev, ECT1R, 0x3fff );
2514 #endif
2515 /* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */
2516 count = 0;
2517
2518 /* Wait Source Line Counter Threshold (p36) */
2519 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_HS));
2520 /* Set GPIO3=1 (p42) */
2521 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2522 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2523 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTHI<<24));
2524 #if RPS_IRQ
2525 /* issue RPS1 interrupt */
2526 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2527 #endif
2528 /* Wait reset Source Line Counter Threshold (p36) */
2529 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | RPS_INV | EVT_HS));
2530 /* Set GPIO3=0 (p42) */
2531 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2532 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2533 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTLO<<24));
2534 #if RPS_IRQ
2535 /* issue RPS1 interrupt */
2536 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2537 #endif
2538 /* Jump to begin of RPS program (p37) */
2539 WRITE_RPS1(cpu_to_le32(CMD_JUMP));
2540 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle));
2541
2542 /* Fix VSYNC level */
2543 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2544 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2545 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2546 /* Set Source Line Counter Threshold, using BRS (rCC p43)
2547 * It generates HS event every TS_HEIGHT lines
2548 * this is related to TS_WIDTH set in register
2549 * NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits
2550 * are set to TS_WIDTH bytes (TS_WIDTH=2*188),
2551 * then RPS_THRESH1 should be set to trigger
2552 * every TS_HEIGHT (512) lines.
2553 */
2554 saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 );
2555
2556 /* Enable RPS1 (rFC p33) */
2557 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
2558
2559 /* end of budgetpatch register initialization */
2560 tasklet_init (&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2561 } else {
2562 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
2563 saa7146_write(dev, BCS_CTRL, 0x80400040);
2564
2565 /* set dd1 stream a & b */
2566 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2567 saa7146_write(dev, DD1_INIT, 0x03000000);
2568 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2569
2570 /* upload all */
2571 saa7146_write(dev, MC2, 0x077c077c);
2572 saa7146_write(dev, GPIO_CTRL, 0x000000);
2573 }
2574
2575 tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2576 tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2577
2578 mutex_init(&av7110->pid_mutex);
2579
2580 /* locks for data transfers from/to AV7110 */
2581 spin_lock_init(&av7110->debilock);
2582 mutex_init(&av7110->dcomlock);
2583 av7110->debitype = -1;
2584
2585 /* default OSD window */
2586 av7110->osdwin = 1;
2587 mutex_init(&av7110->osd_mutex);
2588
2589 /* TV standard */
2590 av7110->vidmode = tv_standard == 1 ? VIDEO_MODE_NTSC : VIDEO_MODE_PAL;
2591
2592 /* ARM "watchdog" */
2593 init_waitqueue_head(&av7110->arm_wait);
2594 av7110->arm_thread = NULL;
2595
2596 /* allocate and init buffers */
2597 av7110->debi_virt = pci_alloc_consistent(pdev, 8192, &av7110->debi_bus);
2598 if (!av7110->debi_virt)
2599 goto err_saa71466_vfree_4;
2600
2601
2602 av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2603 if (!av7110->iobuf)
2604 goto err_pci_free_5;
2605
2606 ret = av7110_av_init(av7110);
2607 if (ret < 0)
2608 goto err_iobuf_vfree_6;
2609
2610 /* init BMP buffer */
2611 av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN;
2612 init_waitqueue_head(&av7110->bmpq);
2613
2614 ret = av7110_ca_init(av7110);
2615 if (ret < 0)
2616 goto err_av7110_av_exit_7;
2617
2618 /* load firmware into AV7110 cards */
2619 ret = av7110_bootarm(av7110);
2620 if (ret < 0)
2621 goto err_av7110_ca_exit_8;
2622
2623 ret = av7110_firmversion(av7110);
2624 if (ret < 0)
2625 goto err_stop_arm_9;
2626
2627 if (FW_VERSION(av7110->arm_app)<0x2501)
2628 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2629 "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2630
2631 thread = kthread_run(arm_thread, (void *) av7110, "arm_mon");
2632 if (IS_ERR(thread)) {
2633 ret = PTR_ERR(thread);
2634 goto err_stop_arm_9;
2635 }
2636 av7110->arm_thread = thread;
2637
2638 /* set initial volume in mixer struct */
2639 av7110->mixer.volume_left = volume;
2640 av7110->mixer.volume_right = volume;
2641
2642 init_av7110_av(av7110);
2643
2644 ret = av7110_register(av7110);
2645 if (ret < 0)
2646 goto err_arm_thread_stop_10;
2647
2648 /* special case DVB-C: these cards have an analog tuner
2649 plus need some special handling, so we have separate
2650 saa7146_ext_vv data for these... */
2651 ret = av7110_init_v4l(av7110);
2652 if (ret < 0)
2653 goto err_av7110_unregister_11;
2654
2655 av7110->dvb_adapter.priv = av7110;
2656 ret = frontend_init(av7110);
2657 if (ret < 0)
2658 goto err_av7110_exit_v4l_12;
2659
2660 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2661 av7110_ir_init(av7110);
2662 #endif
2663 printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2664 av7110_num++;
2665 out:
2666 return ret;
2667
2668 err_av7110_exit_v4l_12:
2669 av7110_exit_v4l(av7110);
2670 err_av7110_unregister_11:
2671 dvb_unregister(av7110);
2672 err_arm_thread_stop_10:
2673 av7110_arm_sync(av7110);
2674 err_stop_arm_9:
2675 /* Nothing to do. Rejoice. */
2676 err_av7110_ca_exit_8:
2677 av7110_ca_exit(av7110);
2678 err_av7110_av_exit_7:
2679 av7110_av_exit(av7110);
2680 err_iobuf_vfree_6:
2681 vfree(av7110->iobuf);
2682 err_pci_free_5:
2683 pci_free_consistent(pdev, 8192, av7110->debi_virt, av7110->debi_bus);
2684 err_saa71466_vfree_4:
2685 if (av7110->grabbing)
2686 saa7146_vfree_destroy_pgtable(pdev, av7110->grabbing, &av7110->pt);
2687 err_i2c_del_3:
2688 i2c_del_adapter(&av7110->i2c_adap);
2689 err_dvb_unregister_adapter_2:
2690 dvb_unregister_adapter(&av7110->dvb_adapter);
2691 err_put_firmware_1:
2692 put_firmware(av7110);
2693 err_kfree_0:
2694 kfree(av7110);
2695 goto out;
2696 }
2697
2698 static int __devexit av7110_detach(struct saa7146_dev* saa)
2699 {
2700 struct av7110 *av7110 = saa->ext_priv;
2701 dprintk(4, "%p\n", av7110);
2702
2703 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2704 av7110_ir_exit(av7110);
2705 #endif
2706 if (budgetpatch) {
2707 /* Disable RPS1 */
2708 saa7146_write(saa, MC1, MASK_29);
2709 /* VSYNC LOW (inactive) */
2710 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
2711 saa7146_write(saa, MC1, MASK_20); /* DMA3 off */
2712 SAA7146_IER_DISABLE(saa, MASK_10);
2713 SAA7146_ISR_CLEAR(saa, MASK_10);
2714 msleep(50);
2715 tasklet_kill(&av7110->vpe_tasklet);
2716 saa7146_vfree_destroy_pgtable(saa->pci, av7110->grabbing, &av7110->pt);
2717 }
2718 av7110_exit_v4l(av7110);
2719
2720 av7110_arm_sync(av7110);
2721
2722 tasklet_kill(&av7110->debi_tasklet);
2723 tasklet_kill(&av7110->gpio_tasklet);
2724
2725 dvb_unregister(av7110);
2726
2727 SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2728 SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2729
2730 av7110_ca_exit(av7110);
2731 av7110_av_exit(av7110);
2732
2733 vfree(av7110->iobuf);
2734 pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2735 av7110->debi_bus);
2736
2737 i2c_del_adapter(&av7110->i2c_adap);
2738
2739 dvb_unregister_adapter (&av7110->dvb_adapter);
2740
2741 av7110_num--;
2742
2743 put_firmware(av7110);
2744
2745 kfree(av7110);
2746
2747 saa->ext_priv = NULL;
2748
2749 return 0;
2750 }
2751
2752
2753 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2754 {
2755 struct av7110 *av7110 = dev->ext_priv;
2756
2757 //print_time("av7110_irq");
2758
2759 /* Note: Don't try to handle the DEBI error irq (MASK_18), in
2760 * intel mode the timeout is asserted all the time...
2761 */
2762
2763 if (*isr & MASK_19) {
2764 //printk("av7110_irq: DEBI\n");
2765 /* Note 1: The DEBI irq is level triggered: We must enable it
2766 * only after we started a DMA xfer, and disable it here
2767 * immediately, or it will be signalled all the time while
2768 * DEBI is idle.
2769 * Note 2: You would think that an irq which is masked is
2770 * not signalled by the hardware. Not so for the SAA7146:
2771 * An irq is signalled as long as the corresponding bit
2772 * in the ISR is set, and disabling irqs just prevents the
2773 * hardware from setting the ISR bit. This means a) that we
2774 * must clear the ISR *after* disabling the irq (which is why
2775 * we must do it here even though saa7146_core did it already),
2776 * and b) that if we were to disable an edge triggered irq
2777 * (like the gpio irqs sadly are) temporarily we would likely
2778 * loose some. This sucks :-(
2779 */
2780 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
2781 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
2782 tasklet_schedule(&av7110->debi_tasklet);
2783 }
2784
2785 if (*isr & MASK_03) {
2786 //printk("av7110_irq: GPIO\n");
2787 tasklet_schedule(&av7110->gpio_tasklet);
2788 }
2789
2790 if ((*isr & MASK_10) && budgetpatch)
2791 tasklet_schedule(&av7110->vpe_tasklet);
2792 }
2793
2794
2795 static struct saa7146_extension av7110_extension;
2796
2797 #define MAKE_AV7110_INFO(x_var,x_name) \
2798 static struct saa7146_pci_extension_data x_var = { \
2799 .ext_priv = x_name, \
2800 .ext = &av7110_extension }
2801
2802 MAKE_AV7110_INFO(tts_1_X_fsc,"Technotrend/Hauppauge WinTV DVB-S rev1.X or Fujitsu Siemens DVB-C");
2803 MAKE_AV7110_INFO(ttt_1_X, "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2804 MAKE_AV7110_INFO(ttc_1_X, "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2805 MAKE_AV7110_INFO(ttc_2_X, "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2806 MAKE_AV7110_INFO(tts_2_X, "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2807 MAKE_AV7110_INFO(tts_2_3, "Technotrend/Hauppauge WinTV Nexus-S rev2.3");
2808 MAKE_AV7110_INFO(tts_1_3se, "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2809 MAKE_AV7110_INFO(ttt, "Technotrend/Hauppauge DVB-T");
2810 MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C");
2811 MAKE_AV7110_INFO(fss, "Fujitsu Siemens DVB-S rev1.6");
2812 MAKE_AV7110_INFO(gxs_1_3, "Galaxis DVB-S rev1.3");
2813
2814 static struct pci_device_id pci_tbl[] = {
2815 MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000),
2816 MAKE_EXTENSION_PCI(tts_1_X_fsc, 0x13c2, 0x0000),
2817 MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001),
2818 MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002),
2819 MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003),
2820 MAKE_EXTENSION_PCI(gxs_1_3, 0x13c2, 0x0004),
2821 MAKE_EXTENSION_PCI(fss, 0x13c2, 0x0006),
2822 MAKE_EXTENSION_PCI(ttt, 0x13c2, 0x0008),
2823 MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a),
2824 MAKE_EXTENSION_PCI(tts_2_3, 0x13c2, 0x000e),
2825 MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002),
2826
2827 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2828 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2829
2830 {
2831 .vendor = 0,
2832 }
2833 };
2834
2835 MODULE_DEVICE_TABLE(pci, pci_tbl);
2836
2837
2838 static struct saa7146_extension av7110_extension = {
2839 .name = "dvb",
2840 .flags = SAA7146_USE_I2C_IRQ,
2841
2842 .module = THIS_MODULE,
2843 .pci_tbl = &pci_tbl[0],
2844 .attach = av7110_attach,
2845 .detach = __devexit_p(av7110_detach),
2846
2847 .irq_mask = MASK_19 | MASK_03 | MASK_10,
2848 .irq_func = av7110_irq,
2849 };
2850
2851
2852 static int __init av7110_init(void)
2853 {
2854 int retval;
2855 retval = saa7146_register_extension(&av7110_extension);
2856 return retval;
2857 }
2858
2859
2860 static void __exit av7110_exit(void)
2861 {
2862 saa7146_unregister_extension(&av7110_extension);
2863 }
2864
2865 module_init(av7110_init);
2866 module_exit(av7110_exit);
2867
2868 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2869 "Siemens, Technotrend, Hauppauge");
2870 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2871 MODULE_LICENSE("GPL");
Verdex Pro support