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