?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (4480): Remove null chars from dvb names
[linux-2.6/x86.git] / drivers / media / dvb / ttpci / av7110.c
blob57a101414307def1718e65b2b3ae923d2ead9821
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
55 #include <asm/system.h>
56
57 #include <linux/dvb/frontend.h>
58
59 #include "dvb_frontend.h"
60
61 #include "ttpci-eeprom.h"
62 #include "av7110.h"
63 #include "av7110_hw.h"
64 #include "av7110_av.h"
65 #include "av7110_ca.h"
66 #include "av7110_ipack.h"
67
68 #include "bsbe1.h"
69 #include "lnbp21.h"
70 #include "bsru6.h"
71
72 #define TS_WIDTH 376
73 #define TS_HEIGHT 512
74 #define TS_BUFLEN (TS_WIDTH*TS_HEIGHT)
75 #define TS_MAX_PACKETS (TS_BUFLEN/TS_SIZE)
76
77
78 int av7110_debug;
79
80 static int vidmode = CVBS_RGB_OUT;
81 static int pids_off;
82 static int adac = DVB_ADAC_TI;
83 static int hw_sections;
84 static int rgb_on;
85 static int volume = 255;
86 static int budgetpatch;
87 static int wss_cfg_4_3 = 0x4008;
88 static int wss_cfg_16_9 = 0x0007;
89 static int tv_standard;
90
91 module_param_named(debug, av7110_debug, int, 0644);
92 MODULE_PARM_DESC(debug, "debug level (bitmask, default 0)");
93 module_param(vidmode, int, 0444);
94 MODULE_PARM_DESC(vidmode,"analog video out: 0 off, 1 CVBS+RGB (default), 2 CVBS+YC, 3 YC");
95 module_param(pids_off, int, 0444);
96 MODULE_PARM_DESC(pids_off,"clear video/audio/PCR PID filters when demux is closed");
97 module_param(adac, int, 0444);
98 MODULE_PARM_DESC(adac,"audio DAC type: 0 TI, 1 CRYSTAL, 2 MSP (use if autodetection fails)");
99 module_param(hw_sections, int, 0444);
100 MODULE_PARM_DESC(hw_sections, "0 use software section filter, 1 use hardware");
101 module_param(rgb_on, int, 0444);
102 MODULE_PARM_DESC(rgb_on, "For Siemens DVB-C cards only: Enable RGB control"
103 " signal on SCART pin 16 to switch SCART video mode from CVBS to RGB");
104 module_param(volume, int, 0444);
105 MODULE_PARM_DESC(volume, "initial volume: default 255 (range 0-255)");
106 module_param(budgetpatch, int, 0444);
107 MODULE_PARM_DESC(budgetpatch, "use budget-patch hardware modification: default 0 (0 no, 1 autodetect, 2 always)");
108 module_param(wss_cfg_4_3, int, 0444);
109 MODULE_PARM_DESC(wss_cfg_4_3, "WSS 4:3 - default 0x4008 - bit 15: disable, 14: burst mode, 13..0: wss data");
110 module_param(wss_cfg_16_9, int, 0444);
111 MODULE_PARM_DESC(wss_cfg_16_9, "WSS 16:9 - default 0x0007 - bit 15: disable, 14: burst mode, 13..0: wss data");
112 module_param(tv_standard, int, 0444);
113 MODULE_PARM_DESC(tv_standard, "TV standard: 0 PAL (default), 1 NTSC");
114
115 static void restart_feeds(struct av7110 *av7110);
116
117 static int av7110_num;
118
119 #define FE_FUNC_OVERRIDE(fe_func, av7110_copy, av7110_func) \
120 {\
121 if (fe_func != NULL) { \
122 av7110_copy = fe_func; \
123 fe_func = av7110_func; \
124 } \
125 }
126
127
128 static void init_av7110_av(struct av7110 *av7110)
129 {
130 int ret;
131 struct saa7146_dev *dev = av7110->dev;
132
133 /* set internal volume control to maximum */
134 av7110->adac_type = DVB_ADAC_TI;
135 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
136 if (ret < 0)
137 printk("dvb-ttpci:cannot set internal volume to maximum:%d\n",ret);
138
139 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 2, wss_cfg_4_3);
140 if (ret < 0)
141 printk("dvb-ttpci: unable to configure 4:3 wss\n");
142 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 3, wss_cfg_16_9);
143 if (ret < 0)
144 printk("dvb-ttpci: unable to configure 16:9 wss\n");
145
146 ret = av7710_set_video_mode(av7110, vidmode);
147 if (ret < 0)
148 printk("dvb-ttpci:cannot set video mode:%d\n",ret);
149
150 /* handle different card types */
151 /* remaining inits according to card and frontend type */
152 av7110->analog_tuner_flags = 0;
153 av7110->current_input = 0;
154 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000a)
155 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 0); // SPDIF on
156 if (i2c_writereg(av7110, 0x20, 0x00, 0x00) == 1) {
157 printk ("dvb-ttpci: Crystal audio DAC @ card %d detected\n",
158 av7110->dvb_adapter.num);
159 av7110->adac_type = DVB_ADAC_CRYSTAL;
160 i2c_writereg(av7110, 0x20, 0x01, 0xd2);
161 i2c_writereg(av7110, 0x20, 0x02, 0x49);
162 i2c_writereg(av7110, 0x20, 0x03, 0x00);
163 i2c_writereg(av7110, 0x20, 0x04, 0x00);
164
165 /**
166 * some special handling for the Siemens DVB-C cards...
167 */
168 } else if (0 == av7110_init_analog_module(av7110)) {
169 /* done. */
170 }
171 else if (dev->pci->subsystem_vendor == 0x110a) {
172 printk("dvb-ttpci: DVB-C w/o analog module @ card %d detected\n",
173 av7110->dvb_adapter.num);
174 av7110->adac_type = DVB_ADAC_NONE;
175 }
176 else {
177 av7110->adac_type = adac;
178 printk("dvb-ttpci: adac type set to %d @ card %d\n",
179 av7110->adac_type, av7110->dvb_adapter.num);
180 }
181
182 if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP34x0) {
183 // switch DVB SCART on
184 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0);
185 if (ret < 0)
186 printk("dvb-ttpci:cannot switch on SCART(Main):%d\n",ret);
187 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1);
188 if (ret < 0)
189 printk("dvb-ttpci:cannot switch on SCART(AD):%d\n",ret);
190 if (rgb_on &&
191 ((av7110->dev->pci->subsystem_vendor == 0x110a) ||
192 (av7110->dev->pci->subsystem_vendor == 0x13c2)) &&
193 (av7110->dev->pci->subsystem_device == 0x0000)) {
194 saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16
195 //saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // SCARTpin 8
196 }
197 }
198
199 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000e)
200 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, SpdifSwitch, 1, 0); // SPDIF on
201
202 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
203 if (ret < 0)
204 printk("dvb-ttpci:cannot set volume :%d\n",ret);
205 }
206
207 static void recover_arm(struct av7110 *av7110)
208 {
209 dprintk(4, "%p\n",av7110);
210
211 av7110_bootarm(av7110);
212 msleep(100);
213
214 init_av7110_av(av7110);
215
216 /* card-specific recovery */
217 if (av7110->recover)
218 av7110->recover(av7110);
219
220 restart_feeds(av7110);
221 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, av7110->ir_config);
222 }
223
224 static void av7110_arm_sync(struct av7110 *av7110)
225 {
226 av7110->arm_rmmod = 1;
227 wake_up_interruptible(&av7110->arm_wait);
228
229 while (av7110->arm_thread)
230 msleep(1);
231 }
232
233 static int arm_thread(void *data)
234 {
235 struct av7110 *av7110 = data;
236 u16 newloops = 0;
237 int timeout;
238
239 dprintk(4, "%p\n",av7110);
240
241 lock_kernel();
242 daemonize("arm_mon");
243 sigfillset(&current->blocked);
244 unlock_kernel();
245
246 av7110->arm_thread = current;
247
248 for (;;) {
249 timeout = wait_event_interruptible_timeout(av7110->arm_wait,
250 av7110->arm_rmmod, 5 * HZ);
251 if (-ERESTARTSYS == timeout || av7110->arm_rmmod) {
252 /* got signal or told to quit*/
253 break;
254 }
255
256 if (!av7110->arm_ready)
257 continue;
258
259 if (mutex_lock_interruptible(&av7110->dcomlock))
260 break;
261 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
262 mutex_unlock(&av7110->dcomlock);
263
264 if (newloops == av7110->arm_loops || av7110->arm_errors > 3) {
265 printk(KERN_ERR "dvb-ttpci: ARM crashed @ card %d\n",
266 av7110->dvb_adapter.num);
267
268 recover_arm(av7110);
269
270 if (mutex_lock_interruptible(&av7110->dcomlock))
271 break;
272 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2) - 1;
273 mutex_unlock(&av7110->dcomlock);
274 }
275 av7110->arm_loops = newloops;
276 av7110->arm_errors = 0;
277 }
278
279 av7110->arm_thread = NULL;
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_handler)
678 av7110->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 = (struct dvb_device *) file->private_data;
699 struct av7110 *av7110 = (struct 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 = (struct 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 = (struct 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 = (struct 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 = (struct 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 = (struct dvb_demux *) demux->priv;
1107 BUG_ON(!dvbdemux);
1108 av7110 = (struct 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 = (struct 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 = (struct av7110 *) 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 = (struct av7110 *) 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 #if 0
1250 /* track rps1 activity */
1251 printk("vpeirq: %02x Event Counter 1 0x%04x\n",
1252 mem[olddma],
1253 saa7146_read(budget->dev, EC1R) & 0x3fff);
1254 #endif
1255
1256 if (newdma > olddma)
1257 /* no wraparound, dump olddma..newdma */
1258 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (newdma - olddma) / 188);
1259 else {
1260 /* wraparound, dump olddma..buflen and 0..newdma */
1261 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (TS_BUFLEN - olddma) / 188);
1262 dvb_dmx_swfilter_packets(&budget->demux1, mem, newdma / 188);
1263 }
1264 }
1265
1266 static int av7110_register(struct av7110 *av7110)
1267 {
1268 int ret, i;
1269 struct dvb_demux *dvbdemux = &av7110->demux;
1270 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1271
1272 dprintk(4, "%p\n", av7110);
1273
1274 if (av7110->registered)
1275 return -1;
1276
1277 av7110->registered = 1;
1278
1279 dvbdemux->priv = (void *) av7110;
1280
1281 for (i = 0; i < 32; i++)
1282 av7110->handle2filter[i] = NULL;
1283
1284 dvbdemux->filternum = 32;
1285 dvbdemux->feednum = 32;
1286 dvbdemux->start_feed = av7110_start_feed;
1287 dvbdemux->stop_feed = av7110_stop_feed;
1288 dvbdemux->write_to_decoder = av7110_write_to_decoder;
1289 dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1290 DMX_MEMORY_BASED_FILTERING);
1291
1292 dvb_dmx_init(&av7110->demux);
1293 av7110->demux.dmx.get_stc = dvb_get_stc;
1294
1295 av7110->dmxdev.filternum = 32;
1296 av7110->dmxdev.demux = &dvbdemux->dmx;
1297 av7110->dmxdev.capabilities = 0;
1298
1299 dvb_dmxdev_init(&av7110->dmxdev, &av7110->dvb_adapter);
1300
1301 av7110->hw_frontend.source = DMX_FRONTEND_0;
1302
1303 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1304
1305 if (ret < 0)
1306 return ret;
1307
1308 av7110->mem_frontend.source = DMX_MEMORY_FE;
1309
1310 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1311
1312 if (ret < 0)
1313 return ret;
1314
1315 ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1316 &av7110->hw_frontend);
1317 if (ret < 0)
1318 return ret;
1319
1320 av7110_av_register(av7110);
1321 av7110_ca_register(av7110);
1322
1323 #ifdef CONFIG_DVB_AV7110_OSD
1324 dvb_register_device(&av7110->dvb_adapter, &av7110->osd_dev,
1325 &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1326 #endif
1327
1328 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1329
1330 if (budgetpatch) {
1331 /* initialize software demux1 without its own frontend
1332 * demux1 hardware is connected to frontend0 of demux0
1333 */
1334 dvbdemux1->priv = (void *) av7110;
1335
1336 dvbdemux1->filternum = 256;
1337 dvbdemux1->feednum = 256;
1338 dvbdemux1->start_feed = budget_start_feed;
1339 dvbdemux1->stop_feed = budget_stop_feed;
1340 dvbdemux1->write_to_decoder = NULL;
1341
1342 dvbdemux1->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1343 DMX_MEMORY_BASED_FILTERING);
1344
1345 dvb_dmx_init(&av7110->demux1);
1346
1347 av7110->dmxdev1.filternum = 256;
1348 av7110->dmxdev1.demux = &dvbdemux1->dmx;
1349 av7110->dmxdev1.capabilities = 0;
1350
1351 dvb_dmxdev_init(&av7110->dmxdev1, &av7110->dvb_adapter);
1352
1353 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net1, &dvbdemux1->dmx);
1354 printk("dvb-ttpci: additional demux1 for budget-patch registered\n");
1355 }
1356 return 0;
1357 }
1358
1359
1360 static void dvb_unregister(struct av7110 *av7110)
1361 {
1362 struct dvb_demux *dvbdemux = &av7110->demux;
1363 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1364
1365 dprintk(4, "%p\n", av7110);
1366
1367 if (!av7110->registered)
1368 return;
1369
1370 if (budgetpatch) {
1371 dvb_net_release(&av7110->dvb_net1);
1372 dvbdemux->dmx.close(&dvbdemux1->dmx);
1373 dvb_dmxdev_release(&av7110->dmxdev1);
1374 dvb_dmx_release(&av7110->demux1);
1375 }
1376
1377 dvb_net_release(&av7110->dvb_net);
1378
1379 dvbdemux->dmx.close(&dvbdemux->dmx);
1380 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1381 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1382
1383 dvb_dmxdev_release(&av7110->dmxdev);
1384 dvb_dmx_release(&av7110->demux);
1385
1386 if (av7110->fe != NULL) {
1387 dvb_unregister_frontend(av7110->fe);
1388 dvb_frontend_detach(av7110->fe);
1389 }
1390 dvb_unregister_device(av7110->osd_dev);
1391 av7110_av_unregister(av7110);
1392 av7110_ca_unregister(av7110);
1393 }
1394
1395
1396 /****************************************************************************
1397 * I2C client commands
1398 ****************************************************************************/
1399
1400 int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1401 {
1402 u8 msg[2] = { reg, val };
1403 struct i2c_msg msgs;
1404
1405 msgs.flags = 0;
1406 msgs.addr = id / 2;
1407 msgs.len = 2;
1408 msgs.buf = msg;
1409 return i2c_transfer(&av7110->i2c_adap, &msgs, 1);
1410 }
1411
1412 #if 0
1413 u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1414 {
1415 u8 mm1[] = {0x00};
1416 u8 mm2[] = {0x00};
1417 struct i2c_msg msgs[2];
1418
1419 msgs[0].flags = 0;
1420 msgs[1].flags = I2C_M_RD;
1421 msgs[0].addr = msgs[1].addr = id / 2;
1422 mm1[0] = reg;
1423 msgs[0].len = 1; msgs[1].len = 1;
1424 msgs[0].buf = mm1; msgs[1].buf = mm2;
1425 i2c_transfer(&av7110->i2c_adap, msgs, 2);
1426
1427 return mm2[0];
1428 }
1429 #endif
1430
1431 /****************************************************************************
1432 * INITIALIZATION
1433 ****************************************************************************/
1434
1435
1436 static int check_firmware(struct av7110* av7110)
1437 {
1438 u32 crc = 0, len = 0;
1439 unsigned char *ptr;
1440
1441 /* check for firmware magic */
1442 ptr = av7110->bin_fw;
1443 if (ptr[0] != 'A' || ptr[1] != 'V' ||
1444 ptr[2] != 'F' || ptr[3] != 'W') {
1445 printk("dvb-ttpci: this is not an av7110 firmware\n");
1446 return -EINVAL;
1447 }
1448 ptr += 4;
1449
1450 /* check dpram file */
1451 crc = ntohl(*(u32*) ptr);
1452 ptr += 4;
1453 len = ntohl(*(u32*) ptr);
1454 ptr += 4;
1455 if (len >= 512) {
1456 printk("dvb-ttpci: dpram file is way too big.\n");
1457 return -EINVAL;
1458 }
1459 if (crc != crc32_le(0, ptr, len)) {
1460 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1461 return -EINVAL;
1462 }
1463 av7110->bin_dpram = ptr;
1464 av7110->size_dpram = len;
1465 ptr += len;
1466
1467 /* check root file */
1468 crc = ntohl(*(u32*) ptr);
1469 ptr += 4;
1470 len = ntohl(*(u32*) ptr);
1471 ptr += 4;
1472
1473 if (len <= 200000 || len >= 300000 ||
1474 len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1475 printk("dvb-ttpci: root file has strange size (%d). aborting.\n", len);
1476 return -EINVAL;
1477 }
1478 if( crc != crc32_le(0, ptr, len)) {
1479 printk("dvb-ttpci: crc32 of root file does not match.\n");
1480 return -EINVAL;
1481 }
1482 av7110->bin_root = ptr;
1483 av7110->size_root = len;
1484 return 0;
1485 }
1486
1487 #ifdef CONFIG_DVB_AV7110_FIRMWARE_FILE
1488 #include "av7110_firm.h"
1489 static void put_firmware(struct av7110* av7110)
1490 {
1491 av7110->bin_fw = NULL;
1492 }
1493
1494 static inline int get_firmware(struct av7110* av7110)
1495 {
1496 av7110->bin_fw = dvb_ttpci_fw;
1497 av7110->size_fw = sizeof(dvb_ttpci_fw);
1498 return check_firmware(av7110);
1499 }
1500 #else
1501 static void put_firmware(struct av7110* av7110)
1502 {
1503 vfree(av7110->bin_fw);
1504 }
1505
1506 static int get_firmware(struct av7110* av7110)
1507 {
1508 int ret;
1509 const struct firmware *fw;
1510
1511 /* request the av7110 firmware, this will block until someone uploads it */
1512 ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev);
1513 if (ret) {
1514 if (ret == -ENOENT) {
1515 printk(KERN_ERR "dvb-ttpci: could not load firmware,"
1516 " file not found: dvb-ttpci-01.fw\n");
1517 printk(KERN_ERR "dvb-ttpci: usually this should be in "
1518 "/usr/lib/hotplug/firmware or /lib/firmware\n");
1519 printk(KERN_ERR "dvb-ttpci: and can be downloaded from"
1520 " http://www.linuxtv.org/download/dvb/firmware/\n");
1521 } else
1522 printk(KERN_ERR "dvb-ttpci: cannot request firmware"
1523 " (error %i)\n", ret);
1524 return -EINVAL;
1525 }
1526
1527 if (fw->size <= 200000) {
1528 printk("dvb-ttpci: this firmware is way too small.\n");
1529 release_firmware(fw);
1530 return -EINVAL;
1531 }
1532
1533 /* check if the firmware is available */
1534 av7110->bin_fw = (unsigned char *) vmalloc(fw->size);
1535 if (NULL == av7110->bin_fw) {
1536 dprintk(1, "out of memory\n");
1537 release_firmware(fw);
1538 return -ENOMEM;
1539 }
1540
1541 memcpy(av7110->bin_fw, fw->data, fw->size);
1542 av7110->size_fw = fw->size;
1543 if ((ret = check_firmware(av7110)))
1544 vfree(av7110->bin_fw);
1545
1546 release_firmware(fw);
1547 return ret;
1548 }
1549 #endif
1550
1551
1552 static int alps_bsrv2_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1553 {
1554 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1555 u8 pwr = 0;
1556 u8 buf[4];
1557 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) };
1558 u32 div = (params->frequency + 479500) / 125;
1559
1560 if (params->frequency > 2000000) pwr = 3;
1561 else if (params->frequency > 1800000) pwr = 2;
1562 else if (params->frequency > 1600000) pwr = 1;
1563 else if (params->frequency > 1200000) pwr = 0;
1564 else if (params->frequency >= 1100000) pwr = 1;
1565 else pwr = 2;
1566
1567 buf[0] = (div >> 8) & 0x7f;
1568 buf[1] = div & 0xff;
1569 buf[2] = ((div & 0x18000) >> 10) | 0x95;
1570 buf[3] = (pwr << 6) | 0x30;
1571
1572 // NOTE: since we're using a prescaler of 2, we set the
1573 // divisor frequency to 62.5kHz and divide by 125 above
1574
1575 if (fe->ops.i2c_gate_ctrl)
1576 fe->ops.i2c_gate_ctrl(fe, 1);
1577 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1578 return -EIO;
1579 return 0;
1580 }
1581
1582 static struct ves1x93_config alps_bsrv2_config = {
1583 .demod_address = 0x08,
1584 .xin = 90100000UL,
1585 .invert_pwm = 0,
1586 };
1587
1588 static int alps_tdbe2_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1589 {
1590 struct av7110* av7110 = fe->dvb->priv;
1591 u32 div;
1592 u8 data[4];
1593 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1594
1595 div = (params->frequency + 35937500 + 31250) / 62500;
1596
1597 data[0] = (div >> 8) & 0x7f;
1598 data[1] = div & 0xff;
1599 data[2] = 0x85 | ((div >> 10) & 0x60);
1600 data[3] = (params->frequency < 174000000 ? 0x88 : params->frequency < 470000000 ? 0x84 : 0x81);
1601
1602 if (fe->ops.i2c_gate_ctrl)
1603 fe->ops.i2c_gate_ctrl(fe, 1);
1604 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1605 return -EIO;
1606 return 0;
1607 }
1608
1609 static struct ves1820_config alps_tdbe2_config = {
1610 .demod_address = 0x09,
1611 .xin = 57840000UL,
1612 .invert = 1,
1613 .selagc = VES1820_SELAGC_SIGNAMPERR,
1614 };
1615
1616
1617
1618
1619 static int grundig_29504_451_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1620 {
1621 struct av7110* av7110 = fe->dvb->priv;
1622 u32 div;
1623 u8 data[4];
1624 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1625
1626 div = params->frequency / 125;
1627 data[0] = (div >> 8) & 0x7f;
1628 data[1] = div & 0xff;
1629 data[2] = 0x8e;
1630 data[3] = 0x00;
1631
1632 if (fe->ops.i2c_gate_ctrl)
1633 fe->ops.i2c_gate_ctrl(fe, 1);
1634 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1635 return -EIO;
1636 return 0;
1637 }
1638
1639 static struct tda8083_config grundig_29504_451_config = {
1640 .demod_address = 0x68,
1641 };
1642
1643
1644
1645 static int philips_cd1516_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1646 {
1647 struct av7110* av7110 = fe->dvb->priv;
1648 u32 div;
1649 u32 f = params->frequency;
1650 u8 data[4];
1651 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1652
1653 div = (f + 36125000 + 31250) / 62500;
1654
1655 data[0] = (div >> 8) & 0x7f;
1656 data[1] = div & 0xff;
1657 data[2] = 0x8e;
1658 data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1659
1660 if (fe->ops.i2c_gate_ctrl)
1661 fe->ops.i2c_gate_ctrl(fe, 1);
1662 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1663 return -EIO;
1664 return 0;
1665 }
1666
1667 static struct ves1820_config philips_cd1516_config = {
1668 .demod_address = 0x09,
1669 .xin = 57840000UL,
1670 .invert = 1,
1671 .selagc = VES1820_SELAGC_SIGNAMPERR,
1672 };
1673
1674
1675
1676 static int alps_tdlb7_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1677 {
1678 struct av7110* av7110 = fe->dvb->priv;
1679 u32 div, pwr;
1680 u8 data[4];
1681 struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1682
1683 div = (params->frequency + 36200000) / 166666;
1684
1685 if (params->frequency <= 782000000)
1686 pwr = 1;
1687 else
1688 pwr = 2;
1689
1690 data[0] = (div >> 8) & 0x7f;
1691 data[1] = div & 0xff;
1692 data[2] = 0x85;
1693 data[3] = pwr << 6;
1694
1695 if (fe->ops.i2c_gate_ctrl)
1696 fe->ops.i2c_gate_ctrl(fe, 1);
1697 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1698 return -EIO;
1699 return 0;
1700 }
1701
1702 static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1703 {
1704 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1705
1706 return request_firmware(fw, name, &av7110->dev->pci->dev);
1707 }
1708
1709 static struct sp8870_config alps_tdlb7_config = {
1710
1711 .demod_address = 0x71,
1712 .request_firmware = alps_tdlb7_request_firmware,
1713 };
1714
1715
1716 static u8 nexusca_stv0297_inittab[] = {
1717 0x80, 0x01,
1718 0x80, 0x00,
1719 0x81, 0x01,
1720 0x81, 0x00,
1721 0x00, 0x09,
1722 0x01, 0x69,
1723 0x03, 0x00,
1724 0x04, 0x00,
1725 0x07, 0x00,
1726 0x08, 0x00,
1727 0x20, 0x00,
1728 0x21, 0x40,
1729 0x22, 0x00,
1730 0x23, 0x00,
1731 0x24, 0x40,
1732 0x25, 0x88,
1733 0x30, 0xff,
1734 0x31, 0x00,
1735 0x32, 0xff,
1736 0x33, 0x00,
1737 0x34, 0x50,
1738 0x35, 0x7f,
1739 0x36, 0x00,
1740 0x37, 0x20,
1741 0x38, 0x00,
1742 0x40, 0x1c,
1743 0x41, 0xff,
1744 0x42, 0x29,
1745 0x43, 0x00,
1746 0x44, 0xff,
1747 0x45, 0x00,
1748 0x46, 0x00,
1749 0x49, 0x04,
1750 0x4a, 0x00,
1751 0x4b, 0x7b,
1752 0x52, 0x30,
1753 0x55, 0xae,
1754 0x56, 0x47,
1755 0x57, 0xe1,
1756 0x58, 0x3a,
1757 0x5a, 0x1e,
1758 0x5b, 0x34,
1759 0x60, 0x00,
1760 0x63, 0x00,
1761 0x64, 0x00,
1762 0x65, 0x00,
1763 0x66, 0x00,
1764 0x67, 0x00,
1765 0x68, 0x00,
1766 0x69, 0x00,
1767 0x6a, 0x02,
1768 0x6b, 0x00,
1769 0x70, 0xff,
1770 0x71, 0x00,
1771 0x72, 0x00,
1772 0x73, 0x00,
1773 0x74, 0x0c,
1774 0x80, 0x00,
1775 0x81, 0x00,
1776 0x82, 0x00,
1777 0x83, 0x00,
1778 0x84, 0x04,
1779 0x85, 0x80,
1780 0x86, 0x24,
1781 0x87, 0x78,
1782 0x88, 0x10,
1783 0x89, 0x00,
1784 0x90, 0x01,
1785 0x91, 0x01,
1786 0xa0, 0x04,
1787 0xa1, 0x00,
1788 0xa2, 0x00,
1789 0xb0, 0x91,
1790 0xb1, 0x0b,
1791 0xc0, 0x53,
1792 0xc1, 0x70,
1793 0xc2, 0x12,
1794 0xd0, 0x00,
1795 0xd1, 0x00,
1796 0xd2, 0x00,
1797 0xd3, 0x00,
1798 0xd4, 0x00,
1799 0xd5, 0x00,
1800 0xde, 0x00,
1801 0xdf, 0x00,
1802 0x61, 0x49,
1803 0x62, 0x0b,
1804 0x53, 0x08,
1805 0x59, 0x08,
1806 0xff, 0xff,
1807 };
1808
1809 static int nexusca_stv0297_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1810 {
1811 struct av7110* av7110 = fe->dvb->priv;
1812 u32 div;
1813 u8 data[4];
1814 struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
1815 struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
1816 int i;
1817
1818 div = (params->frequency + 36150000 + 31250) / 62500;
1819
1820 data[0] = (div >> 8) & 0x7f;
1821 data[1] = div & 0xff;
1822 data[2] = 0xce;
1823
1824 if (params->frequency < 45000000)
1825 return -EINVAL;
1826 else if (params->frequency < 137000000)
1827 data[3] = 0x01;
1828 else if (params->frequency < 403000000)
1829 data[3] = 0x02;
1830 else if (params->frequency < 860000000)
1831 data[3] = 0x04;
1832 else
1833 return -EINVAL;
1834
1835 if (fe->ops.i2c_gate_ctrl)
1836 fe->ops.i2c_gate_ctrl(fe, 1);
1837 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) {
1838 printk("nexusca: pll transfer failed!\n");
1839 return -EIO;
1840 }
1841
1842 // wait for PLL lock
1843 for(i = 0; i < 20; i++) {
1844 if (fe->ops.i2c_gate_ctrl)
1845 fe->ops.i2c_gate_ctrl(fe, 1);
1846 if (i2c_transfer(&av7110->i2c_adap, &readmsg, 1) == 1)
1847 if (data[0] & 0x40) break;
1848 msleep(10);
1849 }
1850
1851 return 0;
1852 }
1853
1854 static struct stv0297_config nexusca_stv0297_config = {
1855
1856 .demod_address = 0x1C,
1857 .inittab = nexusca_stv0297_inittab,
1858 .invert = 1,
1859 .stop_during_read = 1,
1860 };
1861
1862
1863
1864 static int grundig_29504_401_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1865 {
1866 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1867 u32 div;
1868 u8 cfg, cpump, band_select;
1869 u8 data[4];
1870 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1871
1872 div = (36125000 + params->frequency) / 166666;
1873
1874 cfg = 0x88;
1875
1876 if (params->frequency < 175000000) cpump = 2;
1877 else if (params->frequency < 390000000) cpump = 1;
1878 else if (params->frequency < 470000000) cpump = 2;
1879 else if (params->frequency < 750000000) cpump = 1;
1880 else cpump = 3;
1881
1882 if (params->frequency < 175000000) band_select = 0x0e;
1883 else if (params->frequency < 470000000) band_select = 0x05;
1884 else band_select = 0x03;
1885
1886 data[0] = (div >> 8) & 0x7f;
1887 data[1] = div & 0xff;
1888 data[2] = ((div >> 10) & 0x60) | cfg;
1889 data[3] = (cpump << 6) | band_select;
1890
1891 if (fe->ops.i2c_gate_ctrl)
1892 fe->ops.i2c_gate_ctrl(fe, 1);
1893 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) return -EIO;
1894 return 0;
1895 }
1896
1897 static struct l64781_config grundig_29504_401_config = {
1898 .demod_address = 0x55,
1899 };
1900
1901
1902
1903 static int av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
1904 {
1905 int ret = 0;
1906 int synced = (status & FE_HAS_LOCK) ? 1 : 0;
1907
1908 av7110->fe_status = status;
1909
1910 if (av7110->fe_synced == synced)
1911 return 0;
1912
1913 if (av7110->playing)
1914 return 0;
1915
1916 if (mutex_lock_interruptible(&av7110->pid_mutex))
1917 return -ERESTARTSYS;
1918
1919 if (synced) {
1920 ret = SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
1921 av7110->pids[DMX_PES_AUDIO],
1922 av7110->pids[DMX_PES_TELETEXT], 0,
1923 av7110->pids[DMX_PES_PCR]);
1924 if (!ret)
1925 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
1926 } else {
1927 ret = SetPIDs(av7110, 0, 0, 0, 0, 0);
1928 if (!ret) {
1929 ret = av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
1930 if (!ret)
1931 ret = av7110_wait_msgstate(av7110, GPMQBusy);
1932 }
1933 }
1934
1935 if (!ret)
1936 av7110->fe_synced = synced;
1937
1938 mutex_unlock(&av7110->pid_mutex);
1939 return ret;
1940 }
1941
1942 static int av7110_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1943 {
1944 struct av7110* av7110 = fe->dvb->priv;
1945
1946 int ret = av7110_fe_lock_fix(av7110, 0);
1947 if (!ret) {
1948 av7110->saved_fe_params = *params;
1949 ret = av7110->fe_set_frontend(fe, params);
1950 }
1951 return ret;
1952 }
1953
1954 static int av7110_fe_init(struct dvb_frontend* fe)
1955 {
1956 struct av7110* av7110 = fe->dvb->priv;
1957
1958 int ret = av7110_fe_lock_fix(av7110, 0);
1959 if (!ret)
1960 ret = av7110->fe_init(fe);
1961 return ret;
1962 }
1963
1964 static int av7110_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
1965 {
1966 struct av7110* av7110 = fe->dvb->priv;
1967
1968 /* call the real implementation */
1969 int ret = av7110->fe_read_status(fe, status);
1970 if (!ret)
1971 if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK))
1972 ret = av7110_fe_lock_fix(av7110, *status);
1973 return ret;
1974 }
1975
1976 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
1977 {
1978 struct av7110* av7110 = fe->dvb->priv;
1979
1980 int ret = av7110_fe_lock_fix(av7110, 0);
1981 if (!ret)
1982 ret = av7110->fe_diseqc_reset_overload(fe);
1983 return ret;
1984 }
1985
1986 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
1987 struct dvb_diseqc_master_cmd* cmd)
1988 {
1989 struct av7110* av7110 = fe->dvb->priv;
1990
1991 int ret = av7110_fe_lock_fix(av7110, 0);
1992 if (!ret) {
1993 av7110->saved_master_cmd = *cmd;
1994 ret = av7110->fe_diseqc_send_master_cmd(fe, cmd);
1995 }
1996 return ret;
1997 }
1998
1999 static int av7110_fe_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t minicmd)
2000 {
2001 struct av7110* av7110 = fe->dvb->priv;
2002
2003 int ret = av7110_fe_lock_fix(av7110, 0);
2004 if (!ret) {
2005 av7110->saved_minicmd = minicmd;
2006 ret = av7110->fe_diseqc_send_burst(fe, minicmd);
2007 }
2008 return ret;
2009 }
2010
2011 static int av7110_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
2012 {
2013 struct av7110* av7110 = fe->dvb->priv;
2014
2015 int ret = av7110_fe_lock_fix(av7110, 0);
2016 if (!ret) {
2017 av7110->saved_tone = tone;
2018 ret = av7110->fe_set_tone(fe, tone);
2019 }
2020 return ret;
2021 }
2022
2023 static int av7110_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
2024 {
2025 struct av7110* av7110 = fe->dvb->priv;
2026
2027 int ret = av7110_fe_lock_fix(av7110, 0);
2028 if (!ret) {
2029 av7110->saved_voltage = voltage;
2030 ret = av7110->fe_set_voltage(fe, voltage);
2031 }
2032 return ret;
2033 }
2034
2035 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned long cmd)
2036 {
2037 struct av7110* av7110 = fe->dvb->priv;
2038
2039 int ret = av7110_fe_lock_fix(av7110, 0);
2040 if (!ret)
2041 ret = av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
2042 return ret;
2043 }
2044
2045 static void dvb_s_recover(struct av7110* av7110)
2046 {
2047 av7110_fe_init(av7110->fe);
2048
2049 av7110_fe_set_voltage(av7110->fe, av7110->saved_voltage);
2050 if (av7110->saved_master_cmd.msg_len) {
2051 msleep(20);
2052 av7110_fe_diseqc_send_master_cmd(av7110->fe, &av7110->saved_master_cmd);
2053 }
2054 msleep(20);
2055 av7110_fe_diseqc_send_burst(av7110->fe, av7110->saved_minicmd);
2056 msleep(20);
2057 av7110_fe_set_tone(av7110->fe, av7110->saved_tone);
2058
2059 av7110_fe_set_frontend(av7110->fe, &av7110->saved_fe_params);
2060 }
2061
2062 static u8 read_pwm(struct av7110* av7110)
2063 {
2064 u8 b = 0xff;
2065 u8 pwm;
2066 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
2067 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
2068
2069 if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
2070 pwm = 0x48;
2071
2072 return pwm;
2073 }
2074
2075 static int frontend_init(struct av7110 *av7110)
2076 {
2077 int ret;
2078
2079 if (av7110->dev->pci->subsystem_vendor == 0x110a) {
2080 switch(av7110->dev->pci->subsystem_device) {
2081 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
2082 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config,
2083 &av7110->i2c_adap, read_pwm(av7110));
2084 if (av7110->fe) {
2085 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2086 }
2087 break;
2088 }
2089
2090 } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
2091 switch(av7110->dev->pci->subsystem_device) {
2092 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
2093 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
2094 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
2095
2096 // try the ALPS BSRV2 first of all
2097 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2098 if (av7110->fe) {
2099 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2100 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2101 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2102 av7110->fe->ops.set_tone = av7110_set_tone;
2103 av7110->recover = dvb_s_recover;
2104 break;
2105 }
2106
2107 // try the ALPS BSRU6 now
2108 av7110->fe = dvb_attach(stv0299_attach, &alps_bsru6_config, &av7110->i2c_adap);
2109 if (av7110->fe) {
2110 av7110->fe->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
2111 av7110->fe->tuner_priv = &av7110->i2c_adap;
2112
2113 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2114 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2115 av7110->fe->ops.set_tone = av7110_set_tone;
2116 av7110->recover = dvb_s_recover;
2117 break;
2118 }
2119
2120 // Try the grundig 29504-451
2121 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2122 if (av7110->fe) {
2123 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2124 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2125 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2126 av7110->fe->ops.set_tone = av7110_set_tone;
2127 av7110->recover = dvb_s_recover;
2128 break;
2129 }
2130
2131 /* Try DVB-C cards */
2132 switch(av7110->dev->pci->subsystem_device) {
2133 case 0x0000:
2134 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
2135 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config, &av7110->i2c_adap,
2136 read_pwm(av7110));
2137 if (av7110->fe) {
2138 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2139 }
2140 break;
2141 case 0x0003:
2142 /* Hauppauge DVB-C 2.1 VES1820/ALPS TDBE2 */
2143 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap,
2144 read_pwm(av7110));
2145 if (av7110->fe) {
2146 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2147 }
2148 break;
2149 }
2150 break;
2151
2152 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
2153 // try ALPS TDLB7 first, then Grundig 29504-401
2154 av7110->fe = dvb_attach(sp8870_attach, &alps_tdlb7_config, &av7110->i2c_adap);
2155 if (av7110->fe) {
2156 av7110->fe->ops.tuner_ops.set_params = alps_tdlb7_tuner_set_params;
2157 break;
2158 }
2159 /* fall-thru */
2160
2161 case 0x0008: // Hauppauge/TT DVB-T
2162 // Grundig 29504-401
2163 av7110->fe = dvb_attach(l64781_attach, &grundig_29504_401_config, &av7110->i2c_adap);
2164 if (av7110->fe)
2165 av7110->fe->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params;
2166 break;
2167
2168 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
2169
2170 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
2171 if (av7110->fe) {
2172 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2173 }
2174 break;
2175
2176 case 0x0004: // Galaxis DVB-S rev1.3
2177 /* ALPS BSRV2 */
2178 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2179 if (av7110->fe) {
2180 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2181 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2182 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2183 av7110->fe->ops.set_tone = av7110_set_tone;
2184 av7110->recover = dvb_s_recover;
2185 }
2186 break;
2187
2188 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
2189 /* Grundig 29504-451 */
2190 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2191 if (av7110->fe) {
2192 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2193 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2194 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2195 av7110->fe->ops.set_tone = av7110_set_tone;
2196 av7110->recover = dvb_s_recover;
2197 }
2198 break;
2199
2200 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
2201
2202 av7110->fe = dvb_attach(stv0297_attach, &nexusca_stv0297_config, &av7110->i2c_adap);
2203 if (av7110->fe) {
2204 av7110->fe->ops.tuner_ops.set_params = nexusca_stv0297_tuner_set_params;
2205
2206 /* set TDA9819 into DVB mode */
2207 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
2208 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
2209
2210 /* tuner on this needs a slower i2c bus speed */
2211 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
2212 break;
2213 }
2214 break;
2215
2216 case 0x000E: /* Hauppauge/TT Nexus-S rev 2.3 */
2217 /* ALPS BSBE1 */
2218 av7110->fe = dvb_attach(stv0299_attach, &alps_bsbe1_config, &av7110->i2c_adap);
2219 if (av7110->fe) {
2220 av7110->fe->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
2221 av7110->fe->tuner_priv = &av7110->i2c_adap;
2222
2223 if (dvb_attach(lnbp21_attach, av7110->fe, &av7110->i2c_adap, 0, 0) == NULL) {
2224 printk("dvb-ttpci: LNBP21 not found!\n");
2225 if (av7110->fe->ops.release)
2226 av7110->fe->ops.release(av7110->fe);
2227 av7110->fe = NULL;
2228 } else {
2229 av7110->fe->ops.dishnetwork_send_legacy_command = NULL;
2230 av7110->recover = dvb_s_recover;
2231 }
2232 }
2233 break;
2234 }
2235 }
2236
2237 if (!av7110->fe) {
2238 /* FIXME: propagate the failure code from the lower layers */
2239 ret = -ENOMEM;
2240 printk("dvb-ttpci: A frontend driver was not found for device %04x/%04x subsystem %04x/%04x\n",
2241 av7110->dev->pci->vendor,
2242 av7110->dev->pci->device,
2243 av7110->dev->pci->subsystem_vendor,
2244 av7110->dev->pci->subsystem_device);
2245 } else {
2246 FE_FUNC_OVERRIDE(av7110->fe->ops.init, av7110->fe_init, av7110_fe_init);
2247 FE_FUNC_OVERRIDE(av7110->fe->ops.read_status, av7110->fe_read_status, av7110_fe_read_status);
2248 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
2249 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
2250 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
2251 FE_FUNC_OVERRIDE(av7110->fe->ops.set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
2252 FE_FUNC_OVERRIDE(av7110->fe->ops.set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage;)
2253 FE_FUNC_OVERRIDE(av7110->fe->ops.dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
2254 FE_FUNC_OVERRIDE(av7110->fe->ops.set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
2255
2256 ret = dvb_register_frontend(&av7110->dvb_adapter, av7110->fe);
2257 if (ret < 0) {
2258 printk("av7110: Frontend registration failed!\n");
2259 dvb_frontend_detach(av7110->fe);
2260 av7110->fe = NULL;
2261 }
2262 }
2263 return ret;
2264 }
2265
2266 /* Budgetpatch note:
2267 * Original hardware design by Roberto Deza:
2268 * There is a DVB_Wiki at
2269 * http://212.227.36.83/linuxtv/wiki/index.php/Main_Page
2270 * where is described this 'DVB TT Budget Patch', on Card Modding:
2271 * http://212.227.36.83/linuxtv/wiki/index.php/DVB_TT_Budget_Patch
2272 * On the short description there is also a link to a external file,
2273 * with more details:
2274 * http://perso.wanadoo.es/jesussolano/Ttf_tsc1.zip
2275 *
2276 * New software triggering design by Emard that works on
2277 * original Roberto Deza's hardware:
2278 *
2279 * rps1 code for budgetpatch will copy internal HS event to GPIO3 pin.
2280 * GPIO3 is in budget-patch hardware connectd to port B VSYNC
2281 * HS is an internal event of 7146, accessible with RPS
2282 * and temporarily raised high every n lines
2283 * (n in defined in the RPS_THRESH1 counter threshold)
2284 * I think HS is raised high on the beginning of the n-th line
2285 * and remains high until this n-th line that triggered
2286 * it is completely received. When the receiption of n-th line
2287 * ends, HS is lowered.
2288 *
2289 * To transmit data over DMA, 7146 needs changing state at
2290 * port B VSYNC pin. Any changing of port B VSYNC will
2291 * cause some DMA data transfer, with more or less packets loss.
2292 * It depends on the phase and frequency of VSYNC and
2293 * the way of 7146 is instructed to trigger on port B (defined
2294 * in DD1_INIT register, 3rd nibble from the right valid
2295 * numbers are 0-7, see datasheet)
2296 *
2297 * The correct triggering can minimize packet loss,
2298 * dvbtraffic should give this stable bandwidths:
2299 * 22k transponder = 33814 kbit/s
2300 * 27.5k transponder = 38045 kbit/s
2301 * by experiment it is found that the best results
2302 * (stable bandwidths and almost no packet loss)
2303 * are obtained using DD1_INIT triggering number 2
2304 * (Va at rising edge of VS Fa = HS x VS-failing forced toggle)
2305 * and a VSYNC phase that occurs in the middle of DMA transfer
2306 * (about byte 188*512=96256 in the DMA window).
2307 *
2308 * Phase of HS is still not clear to me how to control,
2309 * It just happens to be so. It can be seen if one enables
2310 * RPS_IRQ and print Event Counter 1 in vpeirq(). Every
2311 * time RPS_INTERRUPT is called, the Event Counter 1 will
2312 * increment. That's how the 7146 is programmed to do event
2313 * counting in this budget-patch.c
2314 * I *think* HPS setting has something to do with the phase
2315 * of HS but I cant be 100% sure in that.
2316 *
2317 * hardware debug note: a working budget card (including budget patch)
2318 * with vpeirq() interrupt setup in mode "0x90" (every 64K) will
2319 * generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes
2320 * and that means 3*25=75 Hz of interrupt freqency, as seen by
2321 * watch cat /proc/interrupts
2322 *
2323 * If this frequency is 3x lower (and data received in the DMA
2324 * buffer don't start with 0x47, but in the middle of packets,
2325 * whose lengths appear to be like 188 292 188 104 etc.
2326 * this means VSYNC line is not connected in the hardware.
2327 * (check soldering pcb and pins)
2328 * The same behaviour of missing VSYNC can be duplicated on budget
2329 * cards, by seting DD1_INIT trigger mode 7 in 3rd nibble.
2330 */
2331 static int __devinit av7110_attach(struct saa7146_dev* dev,
2332 struct saa7146_pci_extension_data *pci_ext)
2333 {
2334 const int length = TS_WIDTH * TS_HEIGHT;
2335 struct pci_dev *pdev = dev->pci;
2336 struct av7110 *av7110;
2337 int ret, count = 0;
2338
2339 dprintk(4, "dev: %p\n", dev);
2340
2341 /* Set RPS_IRQ to 1 to track rps1 activity.
2342 * Enabling this won't send any interrupt to PC CPU.
2343 */
2344 #define RPS_IRQ 0
2345
2346 if (budgetpatch == 1) {
2347 budgetpatch = 0;
2348 /* autodetect the presence of budget patch
2349 * this only works if saa7146 has been recently
2350 * reset with with MASK_31 to MC1
2351 *
2352 * will wait for VBI_B event (vertical blank at port B)
2353 * and will reset GPIO3 after VBI_B is detected.
2354 * (GPIO3 should be raised high by CPU to
2355 * test if GPIO3 will generate vertical blank signal
2356 * in budget patch GPIO3 is connected to VSYNC_B
2357 */
2358
2359 /* RESET SAA7146 */
2360 saa7146_write(dev, MC1, MASK_31);
2361 /* autodetection success seems to be time-dependend after reset */
2362
2363 /* Fix VSYNC level */
2364 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2365 /* set vsync_b triggering */
2366 saa7146_write(dev, DD1_STREAM_B, 0);
2367 /* port B VSYNC at rising edge */
2368 saa7146_write(dev, DD1_INIT, 0x00000200);
2369 saa7146_write(dev, BRS_CTRL, 0x00000000); // VBI
2370 saa7146_write(dev, MC2,
2371 1 * (MASK_08 | MASK_24) | // BRS control
2372 0 * (MASK_09 | MASK_25) | // a
2373 1 * (MASK_10 | MASK_26) | // b
2374 0 * (MASK_06 | MASK_22) | // HPS_CTRL1
2375 0 * (MASK_05 | MASK_21) | // HPS_CTRL2
2376 0 * (MASK_01 | MASK_15) // DEBI
2377 );
2378
2379 /* start writing RPS1 code from beginning */
2380 count = 0;
2381 /* Disable RPS1 */
2382 saa7146_write(dev, MC1, MASK_29);
2383 /* RPS1 timeout disable */
2384 saa7146_write(dev, RPS_TOV1, 0);
2385 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_VBI_B));
2386 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2387 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2388 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTLO<<24));
2389 #if RPS_IRQ
2390 /* issue RPS1 interrupt to increment counter */
2391 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2392 #endif
2393 WRITE_RPS1(cpu_to_le32(CMD_STOP));
2394 /* Jump to begin of RPS program as safety measure (p37) */
2395 WRITE_RPS1(cpu_to_le32(CMD_JUMP));
2396 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle));
2397
2398 #if RPS_IRQ
2399 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2400 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2401 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2402 */
2403 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2404 /* set event counter 1 treshold to maximum allowed value (rEC p55) */
2405 saa7146_write(dev, ECT1R, 0x3fff );
2406 #endif
2407 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2408 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2409 /* Enable RPS1, (rFC p33) */
2410 saa7146_write(dev, MC1, (MASK_13 | MASK_29 ));
2411
2412 mdelay(10);
2413 /* now send VSYNC_B to rps1 by rising GPIO3 */
2414 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI);
2415 mdelay(10);
2416 /* if rps1 responded by lowering the GPIO3,
2417 * then we have budgetpatch hardware
2418 */
2419 if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) {
2420 budgetpatch = 1;
2421 printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2422 }
2423 /* Disable RPS1 */
2424 saa7146_write(dev, MC1, ( MASK_29 ));
2425 #if RPS_IRQ
2426 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff );
2427 #endif
2428 }
2429
2430 /* prepare the av7110 device struct */
2431 av7110 = kzalloc(sizeof(struct av7110), GFP_KERNEL);
2432 if (!av7110) {
2433 dprintk(1, "out of memory\n");
2434 return -ENOMEM;
2435 }
2436
2437 av7110->card_name = (char*) pci_ext->ext_priv;
2438 av7110->dev = dev;
2439 dev->ext_priv = av7110;
2440
2441 ret = get_firmware(av7110);
2442 if (ret < 0)
2443 goto err_kfree_0;
2444
2445 ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name,
2446 THIS_MODULE, &dev->pci->dev);
2447 if (ret < 0)
2448 goto err_put_firmware_1;
2449
2450 /* the Siemens DVB needs this if you want to have the i2c chips
2451 get recognized before the main driver is fully loaded */
2452 saa7146_write(dev, GPIO_CTRL, 0x500000);
2453
2454 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
2455 av7110->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL;
2456 #else
2457 av7110->i2c_adap.class = I2C_CLASS_TV_DIGITAL;
2458 #endif
2459 strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
2460
2461 saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
2462
2463 ret = i2c_add_adapter(&av7110->i2c_adap);
2464 if (ret < 0)
2465 goto err_dvb_unregister_adapter_2;
2466
2467 ttpci_eeprom_parse_mac(&av7110->i2c_adap,
2468 av7110->dvb_adapter.proposed_mac);
2469 ret = -ENOMEM;
2470
2471 if (budgetpatch) {
2472 spin_lock_init(&av7110->feedlock1);
2473 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2474 &av7110->pt);
2475 if (!av7110->grabbing)
2476 goto err_i2c_del_3;
2477
2478 saa7146_write(dev, PCI_BT_V1, 0x1c1f101f);
2479 saa7146_write(dev, BCS_CTRL, 0x80400040);
2480 /* set dd1 stream a & b */
2481 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2482 saa7146_write(dev, DD1_INIT, 0x03000200);
2483 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2484 saa7146_write(dev, BRS_CTRL, 0x60000000);
2485 saa7146_write(dev, BASE_ODD3, 0);
2486 saa7146_write(dev, BASE_EVEN3, 0);
2487 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2488 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2489
2490 saa7146_write(dev, PITCH3, TS_WIDTH);
2491 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2492
2493 /* upload all */
2494 saa7146_write(dev, MC2, 0x077c077c);
2495 saa7146_write(dev, GPIO_CTRL, 0x000000);
2496 #if RPS_IRQ
2497 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2498 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2499 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2500 */
2501 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2502 /* set event counter 1 treshold to maximum allowed value (rEC p55) */
2503 saa7146_write(dev, ECT1R, 0x3fff );
2504 #endif
2505 /* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */
2506 count = 0;
2507
2508 /* Wait Source Line Counter Threshold (p36) */
2509 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_HS));
2510 /* Set GPIO3=1 (p42) */
2511 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2512 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2513 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTHI<<24));
2514 #if RPS_IRQ
2515 /* issue RPS1 interrupt */
2516 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2517 #endif
2518 /* Wait reset Source Line Counter Threshold (p36) */
2519 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | RPS_INV | EVT_HS));
2520 /* Set GPIO3=0 (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_OUTLO<<24));
2524 #if RPS_IRQ
2525 /* issue RPS1 interrupt */
2526 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2527 #endif
2528 /* Jump to begin of RPS program (p37) */
2529 WRITE_RPS1(cpu_to_le32(CMD_JUMP));
2530 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle));
2531
2532 /* Fix VSYNC level */
2533 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2534 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2535 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2536 /* Set Source Line Counter Threshold, using BRS (rCC p43)
2537 * It generates HS event every TS_HEIGHT lines
2538 * this is related to TS_WIDTH set in register
2539 * NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits
2540 * are set to TS_WIDTH bytes (TS_WIDTH=2*188),
2541 * then RPS_THRESH1 should be set to trigger
2542 * every TS_HEIGHT (512) lines.
2543 */
2544 saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 );
2545
2546 /* Enable RPS1 (rFC p33) */
2547 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
2548
2549 /* end of budgetpatch register initialization */
2550 tasklet_init (&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2551 } else {
2552 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
2553 saa7146_write(dev, BCS_CTRL, 0x80400040);
2554
2555 /* set dd1 stream a & b */
2556 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2557 saa7146_write(dev, DD1_INIT, 0x03000000);
2558 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2559
2560 /* upload all */
2561 saa7146_write(dev, MC2, 0x077c077c);
2562 saa7146_write(dev, GPIO_CTRL, 0x000000);
2563 }
2564
2565 tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2566 tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2567
2568 mutex_init(&av7110->pid_mutex);
2569
2570 /* locks for data transfers from/to AV7110 */
2571 spin_lock_init(&av7110->debilock);
2572 mutex_init(&av7110->dcomlock);
2573 av7110->debitype = -1;
2574
2575 /* default OSD window */
2576 av7110->osdwin = 1;
2577 mutex_init(&av7110->osd_mutex);
2578
2579 /* TV standard */
2580 av7110->vidmode = tv_standard == 1 ? VIDEO_MODE_NTSC : VIDEO_MODE_PAL;
2581
2582 /* ARM "watchdog" */
2583 init_waitqueue_head(&av7110->arm_wait);
2584 av7110->arm_thread = NULL;
2585
2586 /* allocate and init buffers */
2587 av7110->debi_virt = pci_alloc_consistent(pdev, 8192, &av7110->debi_bus);
2588 if (!av7110->debi_virt)
2589 goto err_saa71466_vfree_4;
2590
2591
2592 av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2593 if (!av7110->iobuf)
2594 goto err_pci_free_5;
2595
2596 ret = av7110_av_init(av7110);
2597 if (ret < 0)
2598 goto err_iobuf_vfree_6;
2599
2600 /* init BMP buffer */
2601 av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN;
2602 init_waitqueue_head(&av7110->bmpq);
2603
2604 ret = av7110_ca_init(av7110);
2605 if (ret < 0)
2606 goto err_av7110_av_exit_7;
2607
2608 /* load firmware into AV7110 cards */
2609 ret = av7110_bootarm(av7110);
2610 if (ret < 0)
2611 goto err_av7110_ca_exit_8;
2612
2613 ret = av7110_firmversion(av7110);
2614 if (ret < 0)
2615 goto err_stop_arm_9;
2616
2617 if (FW_VERSION(av7110->arm_app)<0x2501)
2618 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2619 "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2620
2621 ret = kernel_thread(arm_thread, (void *) av7110, 0);
2622 if (ret < 0)
2623 goto err_stop_arm_9;
2624
2625 /* set initial volume in mixer struct */
2626 av7110->mixer.volume_left = volume;
2627 av7110->mixer.volume_right = volume;
2628
2629 init_av7110_av(av7110);
2630
2631 ret = av7110_register(av7110);
2632 if (ret < 0)
2633 goto err_arm_thread_stop_10;
2634
2635 /* special case DVB-C: these cards have an analog tuner
2636 plus need some special handling, so we have separate
2637 saa7146_ext_vv data for these... */
2638 ret = av7110_init_v4l(av7110);
2639 if (ret < 0)
2640 goto err_av7110_unregister_11;
2641
2642 av7110->dvb_adapter.priv = av7110;
2643 ret = frontend_init(av7110);
2644 if (ret < 0)
2645 goto err_av7110_exit_v4l_12;
2646
2647 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2648 av7110_ir_init(av7110);
2649 #endif
2650 printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2651 av7110_num++;
2652 out:
2653 return ret;
2654
2655 err_av7110_exit_v4l_12:
2656 av7110_exit_v4l(av7110);
2657 err_av7110_unregister_11:
2658 dvb_unregister(av7110);
2659 err_arm_thread_stop_10:
2660 av7110_arm_sync(av7110);
2661 err_stop_arm_9:
2662 /* Nothing to do. Rejoice. */
2663 err_av7110_ca_exit_8:
2664 av7110_ca_exit(av7110);
2665 err_av7110_av_exit_7:
2666 av7110_av_exit(av7110);
2667 err_iobuf_vfree_6:
2668 vfree(av7110->iobuf);
2669 err_pci_free_5:
2670 pci_free_consistent(pdev, 8192, av7110->debi_virt, av7110->debi_bus);
2671 err_saa71466_vfree_4:
2672 if (!av7110->grabbing)
2673 saa7146_pgtable_free(pdev, &av7110->pt);
2674 err_i2c_del_3:
2675 i2c_del_adapter(&av7110->i2c_adap);
2676 err_dvb_unregister_adapter_2:
2677 dvb_unregister_adapter(&av7110->dvb_adapter);
2678 err_put_firmware_1:
2679 put_firmware(av7110);
2680 err_kfree_0:
2681 kfree(av7110);
2682 goto out;
2683 }
2684
2685 static int __devexit av7110_detach(struct saa7146_dev* saa)
2686 {
2687 struct av7110 *av7110 = saa->ext_priv;
2688 dprintk(4, "%p\n", av7110);
2689
2690 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2691 av7110_ir_exit(av7110);
2692 #endif
2693 if (budgetpatch) {
2694 /* Disable RPS1 */
2695 saa7146_write(saa, MC1, MASK_29);
2696 /* VSYNC LOW (inactive) */
2697 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
2698 saa7146_write(saa, MC1, MASK_20); /* DMA3 off */
2699 SAA7146_IER_DISABLE(saa, MASK_10);
2700 SAA7146_ISR_CLEAR(saa, MASK_10);
2701 msleep(50);
2702 tasklet_kill(&av7110->vpe_tasklet);
2703 saa7146_pgtable_free(saa->pci, &av7110->pt);
2704 }
2705 av7110_exit_v4l(av7110);
2706
2707 av7110_arm_sync(av7110);
2708
2709 tasklet_kill(&av7110->debi_tasklet);
2710 tasklet_kill(&av7110->gpio_tasklet);
2711
2712 dvb_unregister(av7110);
2713
2714 SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2715 SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2716
2717 av7110_ca_exit(av7110);
2718 av7110_av_exit(av7110);
2719
2720 vfree(av7110->iobuf);
2721 pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2722 av7110->debi_bus);
2723
2724 i2c_del_adapter(&av7110->i2c_adap);
2725
2726 dvb_unregister_adapter (&av7110->dvb_adapter);
2727
2728 av7110_num--;
2729
2730 put_firmware(av7110);
2731
2732 kfree(av7110);
2733
2734 saa->ext_priv = NULL;
2735
2736 return 0;
2737 }
2738
2739
2740 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2741 {
2742 struct av7110 *av7110 = dev->ext_priv;
2743
2744 //print_time("av7110_irq");
2745
2746 /* Note: Don't try to handle the DEBI error irq (MASK_18), in
2747 * intel mode the timeout is asserted all the time...
2748 */
2749
2750 if (*isr & MASK_19) {
2751 //printk("av7110_irq: DEBI\n");
2752 /* Note 1: The DEBI irq is level triggered: We must enable it
2753 * only after we started a DMA xfer, and disable it here
2754 * immediately, or it will be signalled all the time while
2755 * DEBI is idle.
2756 * Note 2: You would think that an irq which is masked is
2757 * not signalled by the hardware. Not so for the SAA7146:
2758 * An irq is signalled as long as the corresponding bit
2759 * in the ISR is set, and disabling irqs just prevents the
2760 * hardware from setting the ISR bit. This means a) that we
2761 * must clear the ISR *after* disabling the irq (which is why
2762 * we must do it here even though saa7146_core did it already),
2763 * and b) that if we were to disable an edge triggered irq
2764 * (like the gpio irqs sadly are) temporarily we would likely
2765 * loose some. This sucks :-(
2766 */
2767 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
2768 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
2769 tasklet_schedule(&av7110->debi_tasklet);
2770 }
2771
2772 if (*isr & MASK_03) {
2773 //printk("av7110_irq: GPIO\n");
2774 tasklet_schedule(&av7110->gpio_tasklet);
2775 }
2776
2777 if ((*isr & MASK_10) && budgetpatch)
2778 tasklet_schedule(&av7110->vpe_tasklet);
2779 }
2780
2781
2782 static struct saa7146_extension av7110_extension;
2783
2784 #define MAKE_AV7110_INFO(x_var,x_name) \
2785 static struct saa7146_pci_extension_data x_var = { \
2786 .ext_priv = x_name, \
2787 .ext = &av7110_extension }
2788
2789 MAKE_AV7110_INFO(tts_1_X_fsc,"Technotrend/Hauppauge WinTV DVB-S rev1.X or Fujitsu Siemens DVB-C");
2790 MAKE_AV7110_INFO(ttt_1_X, "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2791 MAKE_AV7110_INFO(ttc_1_X, "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2792 MAKE_AV7110_INFO(ttc_2_X, "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2793 MAKE_AV7110_INFO(tts_2_X, "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2794 MAKE_AV7110_INFO(tts_2_3, "Technotrend/Hauppauge WinTV Nexus-S rev2.3");
2795 MAKE_AV7110_INFO(tts_1_3se, "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2796 MAKE_AV7110_INFO(ttt, "Technotrend/Hauppauge DVB-T");
2797 MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C");
2798 MAKE_AV7110_INFO(fss, "Fujitsu Siemens DVB-S rev1.6");
2799 MAKE_AV7110_INFO(gxs_1_3, "Galaxis DVB-S rev1.3");
2800
2801 static struct pci_device_id pci_tbl[] = {
2802 MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000),
2803 MAKE_EXTENSION_PCI(tts_1_X_fsc, 0x13c2, 0x0000),
2804 MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001),
2805 MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002),
2806 MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003),
2807 MAKE_EXTENSION_PCI(gxs_1_3, 0x13c2, 0x0004),
2808 MAKE_EXTENSION_PCI(fss, 0x13c2, 0x0006),
2809 MAKE_EXTENSION_PCI(ttt, 0x13c2, 0x0008),
2810 MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a),
2811 MAKE_EXTENSION_PCI(tts_2_3, 0x13c2, 0x000e),
2812 MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002),
2813
2814 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2815 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2816
2817 {
2818 .vendor = 0,
2819 }
2820 };
2821
2822 MODULE_DEVICE_TABLE(pci, pci_tbl);
2823
2824
2825 static struct saa7146_extension av7110_extension = {
2826 .name = "dvb",
2827 .flags = SAA7146_I2C_SHORT_DELAY,
2828
2829 .module = THIS_MODULE,
2830 .pci_tbl = &pci_tbl[0],
2831 .attach = av7110_attach,
2832 .detach = __devexit_p(av7110_detach),
2833
2834 .irq_mask = MASK_19 | MASK_03 | MASK_10,
2835 .irq_func = av7110_irq,
2836 };
2837
2838
2839 static int __init av7110_init(void)
2840 {
2841 int retval;
2842 retval = saa7146_register_extension(&av7110_extension);
2843 return retval;
2844 }
2845
2846
2847 static void __exit av7110_exit(void)
2848 {
2849 saa7146_unregister_extension(&av7110_extension);
2850 }
2851
2852 module_init(av7110_init);
2853 module_exit(av7110_exit);
2854
2855 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2856 "Siemens, Technotrend, Hauppauge");
2857 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2858 MODULE_LICENSE("GPL");
x86 "subsystem" repository