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