?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-btrfs-devel.git] / drivers / media / dvb / ttpci / av7110.c
blob3d20719fce1a114d7c630560235ce53b1e022b4b
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_OTHER)) {
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, struct dvb_frontend_parameters *params)
1572 {
1573 struct av7110* av7110 = fe->dvb->priv;
1574 u8 pwr = 0;
1575 u8 buf[4];
1576 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) };
1577 u32 div = (params->frequency + 479500) / 125;
1578
1579 if (params->frequency > 2000000) pwr = 3;
1580 else if (params->frequency > 1800000) pwr = 2;
1581 else if (params->frequency > 1600000) pwr = 1;
1582 else if (params->frequency > 1200000) pwr = 0;
1583 else if (params->frequency >= 1100000) pwr = 1;
1584 else pwr = 2;
1585
1586 buf[0] = (div >> 8) & 0x7f;
1587 buf[1] = div & 0xff;
1588 buf[2] = ((div & 0x18000) >> 10) | 0x95;
1589 buf[3] = (pwr << 6) | 0x30;
1590
1591 // NOTE: since we're using a prescaler of 2, we set the
1592 // divisor frequency to 62.5kHz and divide by 125 above
1593
1594 if (fe->ops.i2c_gate_ctrl)
1595 fe->ops.i2c_gate_ctrl(fe, 1);
1596 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1597 return -EIO;
1598 return 0;
1599 }
1600
1601 static struct ves1x93_config alps_bsrv2_config = {
1602 .demod_address = 0x08,
1603 .xin = 90100000UL,
1604 .invert_pwm = 0,
1605 };
1606
1607 static int alps_tdbe2_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1608 {
1609 struct av7110* av7110 = fe->dvb->priv;
1610 u32 div;
1611 u8 data[4];
1612 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1613
1614 div = (params->frequency + 35937500 + 31250) / 62500;
1615
1616 data[0] = (div >> 8) & 0x7f;
1617 data[1] = div & 0xff;
1618 data[2] = 0x85 | ((div >> 10) & 0x60);
1619 data[3] = (params->frequency < 174000000 ? 0x88 : params->frequency < 470000000 ? 0x84 : 0x81);
1620
1621 if (fe->ops.i2c_gate_ctrl)
1622 fe->ops.i2c_gate_ctrl(fe, 1);
1623 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1624 return -EIO;
1625 return 0;
1626 }
1627
1628 static struct ves1820_config alps_tdbe2_config = {
1629 .demod_address = 0x09,
1630 .xin = 57840000UL,
1631 .invert = 1,
1632 .selagc = VES1820_SELAGC_SIGNAMPERR,
1633 };
1634
1635
1636
1637
1638 static int grundig_29504_451_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1639 {
1640 struct av7110* av7110 = fe->dvb->priv;
1641 u32 div;
1642 u8 data[4];
1643 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1644
1645 div = params->frequency / 125;
1646 data[0] = (div >> 8) & 0x7f;
1647 data[1] = div & 0xff;
1648 data[2] = 0x8e;
1649 data[3] = 0x00;
1650
1651 if (fe->ops.i2c_gate_ctrl)
1652 fe->ops.i2c_gate_ctrl(fe, 1);
1653 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1654 return -EIO;
1655 return 0;
1656 }
1657
1658 static struct tda8083_config grundig_29504_451_config = {
1659 .demod_address = 0x68,
1660 };
1661
1662
1663
1664 static int philips_cd1516_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1665 {
1666 struct av7110* av7110 = fe->dvb->priv;
1667 u32 div;
1668 u32 f = params->frequency;
1669 u8 data[4];
1670 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1671
1672 div = (f + 36125000 + 31250) / 62500;
1673
1674 data[0] = (div >> 8) & 0x7f;
1675 data[1] = div & 0xff;
1676 data[2] = 0x8e;
1677 data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1678
1679 if (fe->ops.i2c_gate_ctrl)
1680 fe->ops.i2c_gate_ctrl(fe, 1);
1681 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1682 return -EIO;
1683 return 0;
1684 }
1685
1686 static struct ves1820_config philips_cd1516_config = {
1687 .demod_address = 0x09,
1688 .xin = 57840000UL,
1689 .invert = 1,
1690 .selagc = VES1820_SELAGC_SIGNAMPERR,
1691 };
1692
1693
1694
1695 static int alps_tdlb7_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1696 {
1697 struct av7110* av7110 = fe->dvb->priv;
1698 u32 div, pwr;
1699 u8 data[4];
1700 struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1701
1702 div = (params->frequency + 36200000) / 166666;
1703
1704 if (params->frequency <= 782000000)
1705 pwr = 1;
1706 else
1707 pwr = 2;
1708
1709 data[0] = (div >> 8) & 0x7f;
1710 data[1] = div & 0xff;
1711 data[2] = 0x85;
1712 data[3] = pwr << 6;
1713
1714 if (fe->ops.i2c_gate_ctrl)
1715 fe->ops.i2c_gate_ctrl(fe, 1);
1716 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1717 return -EIO;
1718 return 0;
1719 }
1720
1721 static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1722 {
1723 #if defined(CONFIG_DVB_SP8870) || defined(CONFIG_DVB_SP8870_MODULE)
1724 struct av7110* av7110 = fe->dvb->priv;
1725
1726 return request_firmware(fw, name, &av7110->dev->pci->dev);
1727 #else
1728 return -EINVAL;
1729 #endif
1730 }
1731
1732 static struct sp8870_config alps_tdlb7_config = {
1733
1734 .demod_address = 0x71,
1735 .request_firmware = alps_tdlb7_request_firmware,
1736 };
1737
1738
1739 static u8 nexusca_stv0297_inittab[] = {
1740 0x80, 0x01,
1741 0x80, 0x00,
1742 0x81, 0x01,
1743 0x81, 0x00,
1744 0x00, 0x09,
1745 0x01, 0x69,
1746 0x03, 0x00,
1747 0x04, 0x00,
1748 0x07, 0x00,
1749 0x08, 0x00,
1750 0x20, 0x00,
1751 0x21, 0x40,
1752 0x22, 0x00,
1753 0x23, 0x00,
1754 0x24, 0x40,
1755 0x25, 0x88,
1756 0x30, 0xff,
1757 0x31, 0x00,
1758 0x32, 0xff,
1759 0x33, 0x00,
1760 0x34, 0x50,
1761 0x35, 0x7f,
1762 0x36, 0x00,
1763 0x37, 0x20,
1764 0x38, 0x00,
1765 0x40, 0x1c,
1766 0x41, 0xff,
1767 0x42, 0x29,
1768 0x43, 0x00,
1769 0x44, 0xff,
1770 0x45, 0x00,
1771 0x46, 0x00,
1772 0x49, 0x04,
1773 0x4a, 0x00,
1774 0x4b, 0x7b,
1775 0x52, 0x30,
1776 0x55, 0xae,
1777 0x56, 0x47,
1778 0x57, 0xe1,
1779 0x58, 0x3a,
1780 0x5a, 0x1e,
1781 0x5b, 0x34,
1782 0x60, 0x00,
1783 0x63, 0x00,
1784 0x64, 0x00,
1785 0x65, 0x00,
1786 0x66, 0x00,
1787 0x67, 0x00,
1788 0x68, 0x00,
1789 0x69, 0x00,
1790 0x6a, 0x02,
1791 0x6b, 0x00,
1792 0x70, 0xff,
1793 0x71, 0x00,
1794 0x72, 0x00,
1795 0x73, 0x00,
1796 0x74, 0x0c,
1797 0x80, 0x00,
1798 0x81, 0x00,
1799 0x82, 0x00,
1800 0x83, 0x00,
1801 0x84, 0x04,
1802 0x85, 0x80,
1803 0x86, 0x24,
1804 0x87, 0x78,
1805 0x88, 0x10,
1806 0x89, 0x00,
1807 0x90, 0x01,
1808 0x91, 0x01,
1809 0xa0, 0x04,
1810 0xa1, 0x00,
1811 0xa2, 0x00,
1812 0xb0, 0x91,
1813 0xb1, 0x0b,
1814 0xc0, 0x53,
1815 0xc1, 0x70,
1816 0xc2, 0x12,
1817 0xd0, 0x00,
1818 0xd1, 0x00,
1819 0xd2, 0x00,
1820 0xd3, 0x00,
1821 0xd4, 0x00,
1822 0xd5, 0x00,
1823 0xde, 0x00,
1824 0xdf, 0x00,
1825 0x61, 0x49,
1826 0x62, 0x0b,
1827 0x53, 0x08,
1828 0x59, 0x08,
1829 0xff, 0xff,
1830 };
1831
1832 static int nexusca_stv0297_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1833 {
1834 struct av7110* av7110 = fe->dvb->priv;
1835 u32 div;
1836 u8 data[4];
1837 struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
1838 struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
1839 int i;
1840
1841 div = (params->frequency + 36150000 + 31250) / 62500;
1842
1843 data[0] = (div >> 8) & 0x7f;
1844 data[1] = div & 0xff;
1845 data[2] = 0xce;
1846
1847 if (params->frequency < 45000000)
1848 return -EINVAL;
1849 else if (params->frequency < 137000000)
1850 data[3] = 0x01;
1851 else if (params->frequency < 403000000)
1852 data[3] = 0x02;
1853 else if (params->frequency < 860000000)
1854 data[3] = 0x04;
1855 else
1856 return -EINVAL;
1857
1858 if (fe->ops.i2c_gate_ctrl)
1859 fe->ops.i2c_gate_ctrl(fe, 1);
1860 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) {
1861 printk("nexusca: pll transfer failed!\n");
1862 return -EIO;
1863 }
1864
1865 // wait for PLL lock
1866 for(i = 0; i < 20; i++) {
1867 if (fe->ops.i2c_gate_ctrl)
1868 fe->ops.i2c_gate_ctrl(fe, 1);
1869 if (i2c_transfer(&av7110->i2c_adap, &readmsg, 1) == 1)
1870 if (data[0] & 0x40) break;
1871 msleep(10);
1872 }
1873
1874 return 0;
1875 }
1876
1877 static struct stv0297_config nexusca_stv0297_config = {
1878
1879 .demod_address = 0x1C,
1880 .inittab = nexusca_stv0297_inittab,
1881 .invert = 1,
1882 .stop_during_read = 1,
1883 };
1884
1885
1886
1887 static int grundig_29504_401_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params)
1888 {
1889 struct av7110* av7110 = fe->dvb->priv;
1890 u32 div;
1891 u8 cfg, cpump, band_select;
1892 u8 data[4];
1893 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1894
1895 div = (36125000 + params->frequency) / 166666;
1896
1897 cfg = 0x88;
1898
1899 if (params->frequency < 175000000) cpump = 2;
1900 else if (params->frequency < 390000000) cpump = 1;
1901 else if (params->frequency < 470000000) cpump = 2;
1902 else if (params->frequency < 750000000) cpump = 1;
1903 else cpump = 3;
1904
1905 if (params->frequency < 175000000) band_select = 0x0e;
1906 else if (params->frequency < 470000000) band_select = 0x05;
1907 else band_select = 0x03;
1908
1909 data[0] = (div >> 8) & 0x7f;
1910 data[1] = div & 0xff;
1911 data[2] = ((div >> 10) & 0x60) | cfg;
1912 data[3] = (cpump << 6) | band_select;
1913
1914 if (fe->ops.i2c_gate_ctrl)
1915 fe->ops.i2c_gate_ctrl(fe, 1);
1916 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) return -EIO;
1917 return 0;
1918 }
1919
1920 static struct l64781_config grundig_29504_401_config = {
1921 .demod_address = 0x55,
1922 };
1923
1924
1925
1926 static int av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
1927 {
1928 int ret = 0;
1929 int synced = (status & FE_HAS_LOCK) ? 1 : 0;
1930
1931 av7110->fe_status = status;
1932
1933 if (av7110->fe_synced == synced)
1934 return 0;
1935
1936 if (av7110->playing) {
1937 av7110->fe_synced = synced;
1938 return 0;
1939 }
1940
1941 if (mutex_lock_interruptible(&av7110->pid_mutex))
1942 return -ERESTARTSYS;
1943
1944 if (synced) {
1945 ret = SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
1946 av7110->pids[DMX_PES_AUDIO],
1947 av7110->pids[DMX_PES_TELETEXT], 0,
1948 av7110->pids[DMX_PES_PCR]);
1949 if (!ret)
1950 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
1951 } else {
1952 ret = SetPIDs(av7110, 0, 0, 0, 0, 0);
1953 if (!ret) {
1954 ret = av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
1955 if (!ret)
1956 ret = av7110_wait_msgstate(av7110, GPMQBusy);
1957 }
1958 }
1959
1960 if (!ret)
1961 av7110->fe_synced = synced;
1962
1963 mutex_unlock(&av7110->pid_mutex);
1964 return ret;
1965 }
1966
1967 static int av7110_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1968 {
1969 struct av7110* av7110 = fe->dvb->priv;
1970
1971 int ret = av7110_fe_lock_fix(av7110, 0);
1972 if (!ret) {
1973 av7110->saved_fe_params = *params;
1974 ret = av7110->fe_set_frontend(fe, params);
1975 }
1976 return ret;
1977 }
1978
1979 static int av7110_fe_init(struct dvb_frontend* fe)
1980 {
1981 struct av7110* av7110 = fe->dvb->priv;
1982
1983 int ret = av7110_fe_lock_fix(av7110, 0);
1984 if (!ret)
1985 ret = av7110->fe_init(fe);
1986 return ret;
1987 }
1988
1989 static int av7110_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
1990 {
1991 struct av7110* av7110 = fe->dvb->priv;
1992
1993 /* call the real implementation */
1994 int ret = av7110->fe_read_status(fe, status);
1995 if (!ret)
1996 if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK))
1997 ret = av7110_fe_lock_fix(av7110, *status);
1998 return ret;
1999 }
2000
2001 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
2002 {
2003 struct av7110* av7110 = fe->dvb->priv;
2004
2005 int ret = av7110_fe_lock_fix(av7110, 0);
2006 if (!ret)
2007 ret = av7110->fe_diseqc_reset_overload(fe);
2008 return ret;
2009 }
2010
2011 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
2012 struct dvb_diseqc_master_cmd* cmd)
2013 {
2014 struct av7110* av7110 = fe->dvb->priv;
2015
2016 int ret = av7110_fe_lock_fix(av7110, 0);
2017 if (!ret) {
2018 av7110->saved_master_cmd = *cmd;
2019 ret = av7110->fe_diseqc_send_master_cmd(fe, cmd);
2020 }
2021 return ret;
2022 }
2023
2024 static int av7110_fe_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t minicmd)
2025 {
2026 struct av7110* av7110 = fe->dvb->priv;
2027
2028 int ret = av7110_fe_lock_fix(av7110, 0);
2029 if (!ret) {
2030 av7110->saved_minicmd = minicmd;
2031 ret = av7110->fe_diseqc_send_burst(fe, minicmd);
2032 }
2033 return ret;
2034 }
2035
2036 static int av7110_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
2037 {
2038 struct av7110* av7110 = fe->dvb->priv;
2039
2040 int ret = av7110_fe_lock_fix(av7110, 0);
2041 if (!ret) {
2042 av7110->saved_tone = tone;
2043 ret = av7110->fe_set_tone(fe, tone);
2044 }
2045 return ret;
2046 }
2047
2048 static int av7110_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
2049 {
2050 struct av7110* av7110 = fe->dvb->priv;
2051
2052 int ret = av7110_fe_lock_fix(av7110, 0);
2053 if (!ret) {
2054 av7110->saved_voltage = voltage;
2055 ret = av7110->fe_set_voltage(fe, voltage);
2056 }
2057 return ret;
2058 }
2059
2060 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned long cmd)
2061 {
2062 struct av7110* av7110 = fe->dvb->priv;
2063
2064 int ret = av7110_fe_lock_fix(av7110, 0);
2065 if (!ret)
2066 ret = av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
2067 return ret;
2068 }
2069
2070 static void dvb_s_recover(struct av7110* av7110)
2071 {
2072 av7110_fe_init(av7110->fe);
2073
2074 av7110_fe_set_voltage(av7110->fe, av7110->saved_voltage);
2075 if (av7110->saved_master_cmd.msg_len) {
2076 msleep(20);
2077 av7110_fe_diseqc_send_master_cmd(av7110->fe, &av7110->saved_master_cmd);
2078 }
2079 msleep(20);
2080 av7110_fe_diseqc_send_burst(av7110->fe, av7110->saved_minicmd);
2081 msleep(20);
2082 av7110_fe_set_tone(av7110->fe, av7110->saved_tone);
2083
2084 av7110_fe_set_frontend(av7110->fe, &av7110->saved_fe_params);
2085 }
2086
2087 static u8 read_pwm(struct av7110* av7110)
2088 {
2089 u8 b = 0xff;
2090 u8 pwm;
2091 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
2092 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
2093
2094 if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
2095 pwm = 0x48;
2096
2097 return pwm;
2098 }
2099
2100 static int frontend_init(struct av7110 *av7110)
2101 {
2102 int ret;
2103
2104 if (av7110->dev->pci->subsystem_vendor == 0x110a) {
2105 switch(av7110->dev->pci->subsystem_device) {
2106 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
2107 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config,
2108 &av7110->i2c_adap, read_pwm(av7110));
2109 if (av7110->fe) {
2110 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2111 }
2112 break;
2113 }
2114
2115 } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
2116 switch(av7110->dev->pci->subsystem_device) {
2117 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
2118 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
2119 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
2120
2121 // try the ALPS BSRV2 first of all
2122 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2123 if (av7110->fe) {
2124 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2125 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2126 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2127 av7110->fe->ops.set_tone = av7110_set_tone;
2128 av7110->recover = dvb_s_recover;
2129 break;
2130 }
2131
2132 // try the ALPS BSRU6 now
2133 av7110->fe = dvb_attach(stv0299_attach, &alps_bsru6_config, &av7110->i2c_adap);
2134 if (av7110->fe) {
2135 av7110->fe->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
2136 av7110->fe->tuner_priv = &av7110->i2c_adap;
2137
2138 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2139 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2140 av7110->fe->ops.set_tone = av7110_set_tone;
2141 av7110->recover = dvb_s_recover;
2142 break;
2143 }
2144
2145 // Try the grundig 29504-451
2146 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2147 if (av7110->fe) {
2148 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2149 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2150 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2151 av7110->fe->ops.set_tone = av7110_set_tone;
2152 av7110->recover = dvb_s_recover;
2153 break;
2154 }
2155
2156 /* Try DVB-C cards */
2157 switch(av7110->dev->pci->subsystem_device) {
2158 case 0x0000:
2159 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
2160 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config, &av7110->i2c_adap,
2161 read_pwm(av7110));
2162 if (av7110->fe) {
2163 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2164 }
2165 break;
2166 case 0x0003:
2167 /* Hauppauge DVB-C 2.1 VES1820/ALPS TDBE2 */
2168 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap,
2169 read_pwm(av7110));
2170 if (av7110->fe) {
2171 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2172 }
2173 break;
2174 }
2175 break;
2176
2177 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
2178 // try ALPS TDLB7 first, then Grundig 29504-401
2179 av7110->fe = dvb_attach(sp8870_attach, &alps_tdlb7_config, &av7110->i2c_adap);
2180 if (av7110->fe) {
2181 av7110->fe->ops.tuner_ops.set_params = alps_tdlb7_tuner_set_params;
2182 break;
2183 }
2184 /* fall-thru */
2185
2186 case 0x0008: // Hauppauge/TT DVB-T
2187 // Grundig 29504-401
2188 av7110->fe = dvb_attach(l64781_attach, &grundig_29504_401_config, &av7110->i2c_adap);
2189 if (av7110->fe)
2190 av7110->fe->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params;
2191 break;
2192
2193 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
2194
2195 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
2196 if (av7110->fe) {
2197 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2198 }
2199 break;
2200
2201 case 0x0004: // Galaxis DVB-S rev1.3
2202 /* ALPS BSRV2 */
2203 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2204 if (av7110->fe) {
2205 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2206 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2207 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2208 av7110->fe->ops.set_tone = av7110_set_tone;
2209 av7110->recover = dvb_s_recover;
2210 }
2211 break;
2212
2213 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
2214 /* Grundig 29504-451 */
2215 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2216 if (av7110->fe) {
2217 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2218 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2219 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2220 av7110->fe->ops.set_tone = av7110_set_tone;
2221 av7110->recover = dvb_s_recover;
2222 }
2223 break;
2224
2225 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
2226
2227 av7110->fe = dvb_attach(stv0297_attach, &nexusca_stv0297_config, &av7110->i2c_adap);
2228 if (av7110->fe) {
2229 av7110->fe->ops.tuner_ops.set_params = nexusca_stv0297_tuner_set_params;
2230
2231 /* set TDA9819 into DVB mode */
2232 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
2233 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
2234
2235 /* tuner on this needs a slower i2c bus speed */
2236 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
2237 break;
2238 }
2239 break;
2240
2241 case 0x000E: /* Hauppauge/TT Nexus-S rev 2.3 */
2242 /* ALPS BSBE1 */
2243 av7110->fe = dvb_attach(stv0299_attach, &alps_bsbe1_config, &av7110->i2c_adap);
2244 if (av7110->fe) {
2245 av7110->fe->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
2246 av7110->fe->tuner_priv = &av7110->i2c_adap;
2247
2248 if (dvb_attach(lnbp21_attach, av7110->fe, &av7110->i2c_adap, 0, 0) == NULL) {
2249 printk("dvb-ttpci: LNBP21 not found!\n");
2250 if (av7110->fe->ops.release)
2251 av7110->fe->ops.release(av7110->fe);
2252 av7110->fe = NULL;
2253 } else {
2254 av7110->fe->ops.dishnetwork_send_legacy_command = NULL;
2255 av7110->recover = dvb_s_recover;
2256 }
2257 }
2258 break;
2259 }
2260 }
2261
2262 if (!av7110->fe) {
2263 /* FIXME: propagate the failure code from the lower layers */
2264 ret = -ENOMEM;
2265 printk("dvb-ttpci: A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
2266 av7110->dev->pci->vendor,
2267 av7110->dev->pci->device,
2268 av7110->dev->pci->subsystem_vendor,
2269 av7110->dev->pci->subsystem_device);
2270 } else {
2271 FE_FUNC_OVERRIDE(av7110->fe->ops.init, av7110->fe_init, av7110_fe_init);
2272 FE_FUNC_OVERRIDE(av7110->fe->ops.read_status, av7110->fe_read_status, av7110_fe_read_status);
2273 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
2274 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
2275 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
2276 FE_FUNC_OVERRIDE(av7110->fe->ops.set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
2277 FE_FUNC_OVERRIDE(av7110->fe->ops.set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage);
2278 FE_FUNC_OVERRIDE(av7110->fe->ops.dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
2279 FE_FUNC_OVERRIDE(av7110->fe->ops.set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
2280
2281 ret = dvb_register_frontend(&av7110->dvb_adapter, av7110->fe);
2282 if (ret < 0) {
2283 printk("av7110: Frontend registration failed!\n");
2284 dvb_frontend_detach(av7110->fe);
2285 av7110->fe = NULL;
2286 }
2287 }
2288 return ret;
2289 }
2290
2291 /* Budgetpatch note:
2292 * Original hardware design by Roberto Deza:
2293 * There is a DVB_Wiki at
2294 * http://www.linuxtv.org/
2295 *
2296 * New software triggering design by Emard that works on
2297 * original Roberto Deza's hardware:
2298 *
2299 * rps1 code for budgetpatch will copy internal HS event to GPIO3 pin.
2300 * GPIO3 is in budget-patch hardware connectd to port B VSYNC
2301 * HS is an internal event of 7146, accessible with RPS
2302 * and temporarily raised high every n lines
2303 * (n in defined in the RPS_THRESH1 counter threshold)
2304 * I think HS is raised high on the beginning of the n-th line
2305 * and remains high until this n-th line that triggered
2306 * it is completely received. When the receiption of n-th line
2307 * ends, HS is lowered.
2308 *
2309 * To transmit data over DMA, 7146 needs changing state at
2310 * port B VSYNC pin. Any changing of port B VSYNC will
2311 * cause some DMA data transfer, with more or less packets loss.
2312 * It depends on the phase and frequency of VSYNC and
2313 * the way of 7146 is instructed to trigger on port B (defined
2314 * in DD1_INIT register, 3rd nibble from the right valid
2315 * numbers are 0-7, see datasheet)
2316 *
2317 * The correct triggering can minimize packet loss,
2318 * dvbtraffic should give this stable bandwidths:
2319 * 22k transponder = 33814 kbit/s
2320 * 27.5k transponder = 38045 kbit/s
2321 * by experiment it is found that the best results
2322 * (stable bandwidths and almost no packet loss)
2323 * are obtained using DD1_INIT triggering number 2
2324 * (Va at rising edge of VS Fa = HS x VS-failing forced toggle)
2325 * and a VSYNC phase that occurs in the middle of DMA transfer
2326 * (about byte 188*512=96256 in the DMA window).
2327 *
2328 * Phase of HS is still not clear to me how to control,
2329 * It just happens to be so. It can be seen if one enables
2330 * RPS_IRQ and print Event Counter 1 in vpeirq(). Every
2331 * time RPS_INTERRUPT is called, the Event Counter 1 will
2332 * increment. That's how the 7146 is programmed to do event
2333 * counting in this budget-patch.c
2334 * I *think* HPS setting has something to do with the phase
2335 * of HS but I can't be 100% sure in that.
2336 *
2337 * hardware debug note: a working budget card (including budget patch)
2338 * with vpeirq() interrupt setup in mode "0x90" (every 64K) will
2339 * generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes
2340 * and that means 3*25=75 Hz of interrupt freqency, as seen by
2341 * watch cat /proc/interrupts
2342 *
2343 * If this frequency is 3x lower (and data received in the DMA
2344 * buffer don't start with 0x47, but in the middle of packets,
2345 * whose lengths appear to be like 188 292 188 104 etc.
2346 * this means VSYNC line is not connected in the hardware.
2347 * (check soldering pcb and pins)
2348 * The same behaviour of missing VSYNC can be duplicated on budget
2349 * cards, by seting DD1_INIT trigger mode 7 in 3rd nibble.
2350 */
2351 static int __devinit av7110_attach(struct saa7146_dev* dev,
2352 struct saa7146_pci_extension_data *pci_ext)
2353 {
2354 const int length = TS_WIDTH * TS_HEIGHT;
2355 struct pci_dev *pdev = dev->pci;
2356 struct av7110 *av7110;
2357 struct task_struct *thread;
2358 int ret, count = 0;
2359
2360 dprintk(4, "dev: %p\n", dev);
2361
2362 /* Set RPS_IRQ to 1 to track rps1 activity.
2363 * Enabling this won't send any interrupt to PC CPU.
2364 */
2365 #define RPS_IRQ 0
2366
2367 if (budgetpatch == 1) {
2368 budgetpatch = 0;
2369 /* autodetect the presence of budget patch
2370 * this only works if saa7146 has been recently
2371 * reset with with MASK_31 to MC1
2372 *
2373 * will wait for VBI_B event (vertical blank at port B)
2374 * and will reset GPIO3 after VBI_B is detected.
2375 * (GPIO3 should be raised high by CPU to
2376 * test if GPIO3 will generate vertical blank signal
2377 * in budget patch GPIO3 is connected to VSYNC_B
2378 */
2379
2380 /* RESET SAA7146 */
2381 saa7146_write(dev, MC1, MASK_31);
2382 /* autodetection success seems to be time-dependend after reset */
2383
2384 /* Fix VSYNC level */
2385 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2386 /* set vsync_b triggering */
2387 saa7146_write(dev, DD1_STREAM_B, 0);
2388 /* port B VSYNC at rising edge */
2389 saa7146_write(dev, DD1_INIT, 0x00000200);
2390 saa7146_write(dev, BRS_CTRL, 0x00000000); // VBI
2391 saa7146_write(dev, MC2,
2392 1 * (MASK_08 | MASK_24) | // BRS control
2393 0 * (MASK_09 | MASK_25) | // a
2394 1 * (MASK_10 | MASK_26) | // b
2395 0 * (MASK_06 | MASK_22) | // HPS_CTRL1
2396 0 * (MASK_05 | MASK_21) | // HPS_CTRL2
2397 0 * (MASK_01 | MASK_15) // DEBI
2398 );
2399
2400 /* start writing RPS1 code from beginning */
2401 count = 0;
2402 /* Disable RPS1 */
2403 saa7146_write(dev, MC1, MASK_29);
2404 /* RPS1 timeout disable */
2405 saa7146_write(dev, RPS_TOV1, 0);
2406 WRITE_RPS1(CMD_PAUSE | EVT_VBI_B);
2407 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2408 WRITE_RPS1(GPIO3_MSK);
2409 WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2410 #if RPS_IRQ
2411 /* issue RPS1 interrupt to increment counter */
2412 WRITE_RPS1(CMD_INTERRUPT);
2413 #endif
2414 WRITE_RPS1(CMD_STOP);
2415 /* Jump to begin of RPS program as safety measure (p37) */
2416 WRITE_RPS1(CMD_JUMP);
2417 WRITE_RPS1(dev->d_rps1.dma_handle);
2418
2419 #if RPS_IRQ
2420 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2421 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2422 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2423 */
2424 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2425 /* set event counter 1 threshold to maximum allowed value (rEC p55) */
2426 saa7146_write(dev, ECT1R, 0x3fff );
2427 #endif
2428 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2429 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2430 /* Enable RPS1, (rFC p33) */
2431 saa7146_write(dev, MC1, (MASK_13 | MASK_29 ));
2432
2433 mdelay(10);
2434 /* now send VSYNC_B to rps1 by rising GPIO3 */
2435 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI);
2436 mdelay(10);
2437 /* if rps1 responded by lowering the GPIO3,
2438 * then we have budgetpatch hardware
2439 */
2440 if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) {
2441 budgetpatch = 1;
2442 printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2443 }
2444 /* Disable RPS1 */
2445 saa7146_write(dev, MC1, ( MASK_29 ));
2446 #if RPS_IRQ
2447 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff );
2448 #endif
2449 }
2450
2451 /* prepare the av7110 device struct */
2452 av7110 = kzalloc(sizeof(struct av7110), GFP_KERNEL);
2453 if (!av7110) {
2454 dprintk(1, "out of memory\n");
2455 return -ENOMEM;
2456 }
2457
2458 av7110->card_name = (char*) pci_ext->ext_priv;
2459 av7110->dev = dev;
2460 dev->ext_priv = av7110;
2461
2462 ret = get_firmware(av7110);
2463 if (ret < 0)
2464 goto err_kfree_0;
2465
2466 ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name,
2467 THIS_MODULE, &dev->pci->dev, adapter_nr);
2468 if (ret < 0)
2469 goto err_put_firmware_1;
2470
2471 /* the Siemens DVB needs this if you want to have the i2c chips
2472 get recognized before the main driver is fully loaded */
2473 saa7146_write(dev, GPIO_CTRL, 0x500000);
2474
2475 strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
2476
2477 saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
2478
2479 ret = i2c_add_adapter(&av7110->i2c_adap);
2480 if (ret < 0)
2481 goto err_dvb_unregister_adapter_2;
2482
2483 ttpci_eeprom_parse_mac(&av7110->i2c_adap,
2484 av7110->dvb_adapter.proposed_mac);
2485 ret = -ENOMEM;
2486
2487 /* full-ts mod? */
2488 if (full_ts)
2489 av7110->full_ts = true;
2490
2491 /* check for full-ts flag in eeprom */
2492 if (i2c_readreg(av7110, 0xaa, 0) == 0x4f && i2c_readreg(av7110, 0xaa, 1) == 0x45) {
2493 u8 flags = i2c_readreg(av7110, 0xaa, 2);
2494 if (flags != 0xff && (flags & 0x01))
2495 av7110->full_ts = true;
2496 }
2497
2498 if (av7110->full_ts) {
2499 printk(KERN_INFO "dvb-ttpci: full-ts mode enabled for saa7146 port B\n");
2500 spin_lock_init(&av7110->feedlock1);
2501 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2502 &av7110->pt);
2503 if (!av7110->grabbing)
2504 goto err_i2c_del_3;
2505
2506 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2507 saa7146_write(dev, MC2, (MASK_10 | MASK_26));
2508
2509 saa7146_write(dev, DD1_INIT, 0x00000600);
2510 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2511
2512 saa7146_write(dev, BRS_CTRL, 0x60000000);
2513 saa7146_write(dev, MC2, MASK_08 | MASK_24);
2514
2515 /* dma3 */
2516 saa7146_write(dev, PCI_BT_V1, 0x001c0000 | (saa7146_read(dev, PCI_BT_V1) & ~0x001f0000));
2517 saa7146_write(dev, BASE_ODD3, 0);
2518 saa7146_write(dev, BASE_EVEN3, 0);
2519 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2520 saa7146_write(dev, PITCH3, TS_WIDTH);
2521 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2522 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2523 saa7146_write(dev, MC2, MASK_04 | MASK_20);
2524
2525 tasklet_init(&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2526
2527 } else if (budgetpatch) {
2528 spin_lock_init(&av7110->feedlock1);
2529 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2530 &av7110->pt);
2531 if (!av7110->grabbing)
2532 goto err_i2c_del_3;
2533
2534 saa7146_write(dev, PCI_BT_V1, 0x1c1f101f);
2535 saa7146_write(dev, BCS_CTRL, 0x80400040);
2536 /* set dd1 stream a & b */
2537 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2538 saa7146_write(dev, DD1_INIT, 0x03000200);
2539 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2540 saa7146_write(dev, BRS_CTRL, 0x60000000);
2541 saa7146_write(dev, BASE_ODD3, 0);
2542 saa7146_write(dev, BASE_EVEN3, 0);
2543 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2544 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2545
2546 saa7146_write(dev, PITCH3, TS_WIDTH);
2547 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2548
2549 /* upload all */
2550 saa7146_write(dev, MC2, 0x077c077c);
2551 saa7146_write(dev, GPIO_CTRL, 0x000000);
2552 #if RPS_IRQ
2553 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2554 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2555 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2556 */
2557 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2558 /* set event counter 1 threshold to maximum allowed value (rEC p55) */
2559 saa7146_write(dev, ECT1R, 0x3fff );
2560 #endif
2561 /* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */
2562 count = 0;
2563
2564 /* Wait Source Line Counter Threshold (p36) */
2565 WRITE_RPS1(CMD_PAUSE | EVT_HS);
2566 /* Set GPIO3=1 (p42) */
2567 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2568 WRITE_RPS1(GPIO3_MSK);
2569 WRITE_RPS1(SAA7146_GPIO_OUTHI<<24);
2570 #if RPS_IRQ
2571 /* issue RPS1 interrupt */
2572 WRITE_RPS1(CMD_INTERRUPT);
2573 #endif
2574 /* Wait reset Source Line Counter Threshold (p36) */
2575 WRITE_RPS1(CMD_PAUSE | RPS_INV | EVT_HS);
2576 /* Set GPIO3=0 (p42) */
2577 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2578 WRITE_RPS1(GPIO3_MSK);
2579 WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2580 #if RPS_IRQ
2581 /* issue RPS1 interrupt */
2582 WRITE_RPS1(CMD_INTERRUPT);
2583 #endif
2584 /* Jump to begin of RPS program (p37) */
2585 WRITE_RPS1(CMD_JUMP);
2586 WRITE_RPS1(dev->d_rps1.dma_handle);
2587
2588 /* Fix VSYNC level */
2589 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2590 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2591 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2592 /* Set Source Line Counter Threshold, using BRS (rCC p43)
2593 * It generates HS event every TS_HEIGHT lines
2594 * this is related to TS_WIDTH set in register
2595 * NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits
2596 * are set to TS_WIDTH bytes (TS_WIDTH=2*188),
2597 * then RPS_THRESH1 should be set to trigger
2598 * every TS_HEIGHT (512) lines.
2599 */
2600 saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 );
2601
2602 /* Enable RPS1 (rFC p33) */
2603 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
2604
2605 /* end of budgetpatch register initialization */
2606 tasklet_init (&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2607 } else {
2608 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
2609 saa7146_write(dev, BCS_CTRL, 0x80400040);
2610
2611 /* set dd1 stream a & b */
2612 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2613 saa7146_write(dev, DD1_INIT, 0x03000000);
2614 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2615
2616 /* upload all */
2617 saa7146_write(dev, MC2, 0x077c077c);
2618 saa7146_write(dev, GPIO_CTRL, 0x000000);
2619 }
2620
2621 tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2622 tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2623
2624 mutex_init(&av7110->pid_mutex);
2625
2626 /* locks for data transfers from/to AV7110 */
2627 spin_lock_init(&av7110->debilock);
2628 mutex_init(&av7110->dcomlock);
2629 av7110->debitype = -1;
2630
2631 /* default OSD window */
2632 av7110->osdwin = 1;
2633 mutex_init(&av7110->osd_mutex);
2634
2635 /* TV standard */
2636 av7110->vidmode = tv_standard == 1 ? AV7110_VIDEO_MODE_NTSC
2637 : AV7110_VIDEO_MODE_PAL;
2638
2639 /* ARM "watchdog" */
2640 init_waitqueue_head(&av7110->arm_wait);
2641 av7110->arm_thread = NULL;
2642
2643 /* allocate and init buffers */
2644 av7110->debi_virt = pci_alloc_consistent(pdev, 8192, &av7110->debi_bus);
2645 if (!av7110->debi_virt)
2646 goto err_saa71466_vfree_4;
2647
2648
2649 av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2650 if (!av7110->iobuf)
2651 goto err_pci_free_5;
2652
2653 ret = av7110_av_init(av7110);
2654 if (ret < 0)
2655 goto err_iobuf_vfree_6;
2656
2657 /* init BMP buffer */
2658 av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN;
2659 init_waitqueue_head(&av7110->bmpq);
2660
2661 ret = av7110_ca_init(av7110);
2662 if (ret < 0)
2663 goto err_av7110_av_exit_7;
2664
2665 /* load firmware into AV7110 cards */
2666 ret = av7110_bootarm(av7110);
2667 if (ret < 0)
2668 goto err_av7110_ca_exit_8;
2669
2670 ret = av7110_firmversion(av7110);
2671 if (ret < 0)
2672 goto err_stop_arm_9;
2673
2674 if (FW_VERSION(av7110->arm_app)<0x2501)
2675 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2676 "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2677
2678 thread = kthread_run(arm_thread, (void *) av7110, "arm_mon");
2679 if (IS_ERR(thread)) {
2680 ret = PTR_ERR(thread);
2681 goto err_stop_arm_9;
2682 }
2683 av7110->arm_thread = thread;
2684
2685 /* set initial volume in mixer struct */
2686 av7110->mixer.volume_left = volume;
2687 av7110->mixer.volume_right = volume;
2688
2689 ret = av7110_register(av7110);
2690 if (ret < 0)
2691 goto err_arm_thread_stop_10;
2692
2693 init_av7110_av(av7110);
2694
2695 /* special case DVB-C: these cards have an analog tuner
2696 plus need some special handling, so we have separate
2697 saa7146_ext_vv data for these... */
2698 ret = av7110_init_v4l(av7110);
2699 if (ret < 0)
2700 goto err_av7110_unregister_11;
2701
2702 av7110->dvb_adapter.priv = av7110;
2703 ret = frontend_init(av7110);
2704 if (ret < 0)
2705 goto err_av7110_exit_v4l_12;
2706
2707 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2708 av7110_ir_init(av7110);
2709 #endif
2710 printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2711 av7110_num++;
2712 out:
2713 return ret;
2714
2715 err_av7110_exit_v4l_12:
2716 av7110_exit_v4l(av7110);
2717 err_av7110_unregister_11:
2718 dvb_unregister(av7110);
2719 err_arm_thread_stop_10:
2720 av7110_arm_sync(av7110);
2721 err_stop_arm_9:
2722 /* Nothing to do. Rejoice. */
2723 err_av7110_ca_exit_8:
2724 av7110_ca_exit(av7110);
2725 err_av7110_av_exit_7:
2726 av7110_av_exit(av7110);
2727 err_iobuf_vfree_6:
2728 vfree(av7110->iobuf);
2729 err_pci_free_5:
2730 pci_free_consistent(pdev, 8192, av7110->debi_virt, av7110->debi_bus);
2731 err_saa71466_vfree_4:
2732 if (av7110->grabbing)
2733 saa7146_vfree_destroy_pgtable(pdev, av7110->grabbing, &av7110->pt);
2734 err_i2c_del_3:
2735 i2c_del_adapter(&av7110->i2c_adap);
2736 err_dvb_unregister_adapter_2:
2737 dvb_unregister_adapter(&av7110->dvb_adapter);
2738 err_put_firmware_1:
2739 put_firmware(av7110);
2740 err_kfree_0:
2741 kfree(av7110);
2742 goto out;
2743 }
2744
2745 static int __devexit av7110_detach(struct saa7146_dev* saa)
2746 {
2747 struct av7110 *av7110 = saa->ext_priv;
2748 dprintk(4, "%p\n", av7110);
2749
2750 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2751 av7110_ir_exit(av7110);
2752 #endif
2753 if (budgetpatch || av7110->full_ts) {
2754 if (budgetpatch) {
2755 /* Disable RPS1 */
2756 saa7146_write(saa, MC1, MASK_29);
2757 /* VSYNC LOW (inactive) */
2758 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
2759 }
2760 saa7146_write(saa, MC1, MASK_20); /* DMA3 off */
2761 SAA7146_IER_DISABLE(saa, MASK_10);
2762 SAA7146_ISR_CLEAR(saa, MASK_10);
2763 msleep(50);
2764 tasklet_kill(&av7110->vpe_tasklet);
2765 saa7146_vfree_destroy_pgtable(saa->pci, av7110->grabbing, &av7110->pt);
2766 }
2767 av7110_exit_v4l(av7110);
2768
2769 av7110_arm_sync(av7110);
2770
2771 tasklet_kill(&av7110->debi_tasklet);
2772 tasklet_kill(&av7110->gpio_tasklet);
2773
2774 dvb_unregister(av7110);
2775
2776 SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2777 SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2778
2779 av7110_ca_exit(av7110);
2780 av7110_av_exit(av7110);
2781
2782 vfree(av7110->iobuf);
2783 pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2784 av7110->debi_bus);
2785
2786 i2c_del_adapter(&av7110->i2c_adap);
2787
2788 dvb_unregister_adapter (&av7110->dvb_adapter);
2789
2790 av7110_num--;
2791
2792 put_firmware(av7110);
2793
2794 kfree(av7110);
2795
2796 saa->ext_priv = NULL;
2797
2798 return 0;
2799 }
2800
2801
2802 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2803 {
2804 struct av7110 *av7110 = dev->ext_priv;
2805
2806 //print_time("av7110_irq");
2807
2808 /* Note: Don't try to handle the DEBI error irq (MASK_18), in
2809 * intel mode the timeout is asserted all the time...
2810 */
2811
2812 if (*isr & MASK_19) {
2813 //printk("av7110_irq: DEBI\n");
2814 /* Note 1: The DEBI irq is level triggered: We must enable it
2815 * only after we started a DMA xfer, and disable it here
2816 * immediately, or it will be signalled all the time while
2817 * DEBI is idle.
2818 * Note 2: You would think that an irq which is masked is
2819 * not signalled by the hardware. Not so for the SAA7146:
2820 * An irq is signalled as long as the corresponding bit
2821 * in the ISR is set, and disabling irqs just prevents the
2822 * hardware from setting the ISR bit. This means a) that we
2823 * must clear the ISR *after* disabling the irq (which is why
2824 * we must do it here even though saa7146_core did it already),
2825 * and b) that if we were to disable an edge triggered irq
2826 * (like the gpio irqs sadly are) temporarily we would likely
2827 * loose some. This sucks :-(
2828 */
2829 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
2830 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
2831 tasklet_schedule(&av7110->debi_tasklet);
2832 }
2833
2834 if (*isr & MASK_03) {
2835 //printk("av7110_irq: GPIO\n");
2836 tasklet_schedule(&av7110->gpio_tasklet);
2837 }
2838
2839 if (*isr & MASK_10)
2840 tasklet_schedule(&av7110->vpe_tasklet);
2841 }
2842
2843
2844 static struct saa7146_extension av7110_extension_driver;
2845
2846 #define MAKE_AV7110_INFO(x_var,x_name) \
2847 static struct saa7146_pci_extension_data x_var = { \
2848 .ext_priv = x_name, \
2849 .ext = &av7110_extension_driver }
2850
2851 MAKE_AV7110_INFO(tts_1_X_fsc,"Technotrend/Hauppauge WinTV DVB-S rev1.X or Fujitsu Siemens DVB-C");
2852 MAKE_AV7110_INFO(ttt_1_X, "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2853 MAKE_AV7110_INFO(ttc_1_X, "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2854 MAKE_AV7110_INFO(ttc_2_X, "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2855 MAKE_AV7110_INFO(tts_2_X, "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2856 MAKE_AV7110_INFO(tts_2_3, "Technotrend/Hauppauge WinTV Nexus-S rev2.3");
2857 MAKE_AV7110_INFO(tts_1_3se, "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2858 MAKE_AV7110_INFO(ttt, "Technotrend/Hauppauge DVB-T");
2859 MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C");
2860 MAKE_AV7110_INFO(fss, "Fujitsu Siemens DVB-S rev1.6");
2861 MAKE_AV7110_INFO(gxs_1_3, "Galaxis DVB-S rev1.3");
2862
2863 static struct pci_device_id pci_tbl[] = {
2864 MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000),
2865 MAKE_EXTENSION_PCI(tts_1_X_fsc, 0x13c2, 0x0000),
2866 MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001),
2867 MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002),
2868 MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003),
2869 MAKE_EXTENSION_PCI(gxs_1_3, 0x13c2, 0x0004),
2870 MAKE_EXTENSION_PCI(fss, 0x13c2, 0x0006),
2871 MAKE_EXTENSION_PCI(ttt, 0x13c2, 0x0008),
2872 MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a),
2873 MAKE_EXTENSION_PCI(tts_2_3, 0x13c2, 0x000e),
2874 MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002),
2875
2876 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2877 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2878
2879 {
2880 .vendor = 0,
2881 }
2882 };
2883
2884 MODULE_DEVICE_TABLE(pci, pci_tbl);
2885
2886
2887 static struct saa7146_extension av7110_extension_driver = {
2888 .name = "av7110",
2889 .flags = SAA7146_USE_I2C_IRQ,
2890
2891 .module = THIS_MODULE,
2892 .pci_tbl = &pci_tbl[0],
2893 .attach = av7110_attach,
2894 .detach = __devexit_p(av7110_detach),
2895
2896 .irq_mask = MASK_19 | MASK_03 | MASK_10,
2897 .irq_func = av7110_irq,
2898 };
2899
2900
2901 static int __init av7110_init(void)
2902 {
2903 int retval;
2904 retval = saa7146_register_extension(&av7110_extension_driver);
2905 return retval;
2906 }
2907
2908
2909 static void __exit av7110_exit(void)
2910 {
2911 saa7146_unregister_extension(&av7110_extension_driver);
2912 }
2913
2914 module_init(av7110_init);
2915 module_exit(av7110_exit);
2916
2917 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2918 "Siemens, Technotrend, Hauppauge");
2919 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2920 MODULE_LICENSE("GPL");
Linux Btrfs Development