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