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