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