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