?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] dvb: budget-ci: add support for TT DVB-C CI card
[linux-2.6/libata-dev.git] / drivers / media / dvb / ttpci / av7110.c
blob48e8097d843093074907e901066a312f57a1b47e
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
76 int av7110_debug;
77
78 static int vidmode = CVBS_RGB_OUT;
79 static int pids_off;
80 static int adac = DVB_ADAC_TI;
81 static int hw_sections;
82 static int rgb_on;
83 static int volume = 255;
84 static int budgetpatch = 0;
85
86 module_param_named(debug, av7110_debug, int, 0644);
87 MODULE_PARM_DESC(debug, "debug level (bitmask, default 0)");
88 module_param(vidmode, int, 0444);
89 MODULE_PARM_DESC(vidmode,"analog video out: 0 off, 1 CVBS+RGB (default), 2 CVBS+YC, 3 YC");
90 module_param(pids_off, int, 0444);
91 MODULE_PARM_DESC(pids_off,"clear video/audio/PCR PID filters when demux is closed");
92 module_param(adac, int, 0444);
93 MODULE_PARM_DESC(adac,"audio DAC type: 0 TI, 1 CRYSTAL, 2 MSP (use if autodetection fails)");
94 module_param(hw_sections, int, 0444);
95 MODULE_PARM_DESC(hw_sections, "0 use software section filter, 1 use hardware");
96 module_param(rgb_on, int, 0444);
97 MODULE_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");
99 module_param(volume, int, 0444);
100 MODULE_PARM_DESC(volume, "initial volume: default 255 (range 0-255)");
101 module_param(budgetpatch, int, 0444);
102 MODULE_PARM_DESC(budgetpatch, "use budget-patch hardware modification: default 0 (0 no, 1 autodetect, 2 always)");
103
104 static void restart_feeds(struct av7110 *av7110);
105
106 static 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
117 static void init_av7110_av(struct av7110 *av7110)
118 {
119 int ret;
120 struct saa7146_dev *dev = av7110->dev;
121
122 /* set internal volume control to maximum */
123 av7110->adac_type = DVB_ADAC_TI;
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);
127
128 ret = av7710_set_video_mode(av7110, vidmode);
129 if (ret < 0)
130 printk("dvb-ttpci:cannot set video mode:%d\n",ret);
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",
138 av7110->dvb_adapter.num);
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",
153 av7110->dvb_adapter.num);
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",
159 av7110->dvb_adapter.num, av7110->adac_type);
160 }
161
162 if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP) {
163 // switch DVB SCART on
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);
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
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);
183 }
184
185 static 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
195 static 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
204 static 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
213 static 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",
247 av7110->dvb_adapter.num);
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 */
274 int av7110_setup_irc_config(struct av7110 *av7110, u32 ir_config)
275 {
276 int ret = 0;
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) {
287 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
288 av7110->ir_config = ir_config;
289 }
290 return ret;
291 }
292
293 static void (*irc_handler)(u32);
294
295 void av7110_register_irc_handler(void (*func)(u32))
296 {
297 dprintk(4, "registering %p\n", func);
298 irc_handler = func;
299 }
300
301 void av7110_unregister_irc_handler(void (*func)(u32))
302 {
303 dprintk(4, "unregistering %p\n", func);
304 irc_handler = NULL;
305 }
306
307 static void run_handlers(unsigned long ircom)
308 {
309 if (irc_handler != NULL)
310 (*irc_handler)((u32) ircom);
311 }
312
313 static DECLARE_TASKLET(irtask, run_handlers, 0);
314
315 static 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
326 static 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
376 static 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
387 static 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
406 static 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 }
508 debi_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 */
517 static 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
731 static 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
748 static 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
755 static 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
765 static 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
783 int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
784 u16 subpid, u16 pcrpid)
785 {
786 int ret = 0;
787 dprintk(4, "%p\n", av7110);
788
789 if (down_interruptible(&av7110->pid_mutex))
790 return -ERESTARTSYS;
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];
805 ret = SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
806 }
807
808 up(&av7110->pid_mutex);
809 return ret;
810 }
811
812
813 /******************************************************************************
814 * hardware filter functions
815 ******************************************************************************/
816
817 static 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 "
852 "ret %d handle %04x\n",
853 __FUNCTION__, buf[0], buf[1], buf[2], buf[3],
854 ret, handle);
855 dvbdmxfilter->hw_handle = 0xffff;
856 if (!ret)
857 ret = -1;
858 return ret;
859 }
860
861 av7110->handle2filter[handle] = dvbdmxfilter;
862 dvbdmxfilter->hw_handle = handle;
863
864 return ret;
865 }
866
867 static 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);
881 return -EINVAL;
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);
895 if (!ret)
896 ret = -1;
897 }
898 return ret;
899 }
900
901
902 static int dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
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;
908 int ret = 0;
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;
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;
926 }
927
928 if (dvbdmxfeed->pes_type < 2 && npids[0])
929 if (av7110->fe_synced)
930 {
931 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
932 if (ret)
933 return ret;
934 }
935
936 if ((dvbdmxfeed->ts_type & TS_PACKET)) {
937 if (dvbdmxfeed->pes_type == 0 && !(dvbdmx->pids[0] & 0x8000))
938 ret = av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed);
939 if (dvbdmxfeed->pes_type == 1 && !(dvbdmx->pids[1] & 0x8000))
940 ret = av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed);
941 }
942 return ret;
943 }
944
945 static int dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
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
952 int ret = 0;
953
954 dprintk(4, "%p\n", av7110);
955
956 if (dvbdmxfeed->pes_type <= 1) {
957 ret = av7110_av_stop(av7110, dvbdmxfeed->pes_type ? RP_VIDEO : RP_AUDIO);
958 if (ret)
959 return ret;
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)
970 ret = StopHWFilter(dvbdmxfeed->filter);
971 npids[2] = 0;
972 break;
973 case 0:
974 case 1:
975 case 4:
976 if (!pids_off)
977 return 0;
978 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
979 break;
980 }
981 if (!ret)
982 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
983 return ret;
984 }
985
986 static int av7110_start_feed(struct dvb_demux_feed *feed)
987 {
988 struct dvb_demux *demux = feed->demux;
989 struct av7110 *av7110 = demux->priv;
990 int ret = 0;
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);
1011 ret = av7110_av_start_play(av7110,RP_AV);
1012 if (!ret)
1013 demux->playing = 1;
1014 }
1015 break;
1016 default:
1017 ret = dvb_feed_start_pid(feed);
1018 break;
1019 }
1020 } else if ((feed->ts_type & TS_PACKET) &&
1021 (demux->dmx.frontend->source != DMX_MEMORY_FE)) {
1022 ret = StartHWFilter(feed->filter);
1023 }
1024 }
1025
1026 else if (feed->type == DMX_TYPE_SEC) {
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;
1037 if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
1038 ret = StartHWFilter(&demux->filter[i]);
1039 if (ret)
1040 break;
1041 }
1042 }
1043 }
1044
1045 return ret;
1046 }
1047
1048
1049 static int av7110_stop_feed(struct dvb_demux_feed *feed)
1050 {
1051 struct dvb_demux *demux = feed->demux;
1052 struct av7110 *av7110 = demux->priv;
1053 int i, rc, ret = 0;
1054 dprintk(4, "%p\n", av7110);
1055
1056 if (feed->type == DMX_TYPE_TS) {
1057 if (feed->ts_type & TS_DECODER) {
1058 if (feed->pes_type >= DMX_TS_PES_OTHER ||
1059 !demux->pesfilter[feed->pes_type])
1060 return -EINVAL;
1061 demux->pids[feed->pes_type] |= 0x8000;
1062 demux->pesfilter[feed->pes_type] = NULL;
1063 }
1064 if (feed->ts_type & TS_DECODER &&
1065 feed->pes_type < DMX_TS_PES_OTHER) {
1066 ret = dvb_feed_stop_pid(feed);
1067 } else
1068 if ((feed->ts_type & TS_PACKET) &&
1069 (demux->dmx.frontend->source != DMX_MEMORY_FE))
1070 ret = StopHWFilter(feed->filter);
1071 }
1072
1073 if (!ret && feed->type == DMX_TYPE_SEC) {
1074 for (i = 0; i<demux->filternum; i++) {
1075 if (demux->filter[i].state == DMX_STATE_GO &&
1076 demux->filter[i].filter.parent == &feed->feed.sec) {
1077 demux->filter[i].state = DMX_STATE_READY;
1078 if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
1079 rc = StopHWFilter(&demux->filter[i]);
1080 if (!ret)
1081 ret = rc;
1082 /* keep going, stop as many filters as possible */
1083 }
1084 }
1085 }
1086 }
1087
1088 return ret;
1089 }
1090
1091
1092 static void restart_feeds(struct av7110 *av7110)
1093 {
1094 struct dvb_demux *dvbdmx = &av7110->demux;
1095 struct dvb_demux_feed *feed;
1096 int mode;
1097 int i;
1098
1099 dprintk(4, "%p\n", av7110);
1100
1101 mode = av7110->playing;
1102 av7110->playing = 0;
1103 av7110->rec_mode = 0;
1104
1105 for (i = 0; i < dvbdmx->filternum; i++) {
1106 feed = &dvbdmx->feed[i];
1107 if (feed->state == DMX_STATE_GO)
1108 av7110_start_feed(feed);
1109 }
1110
1111 if (mode)
1112 av7110_av_start_play(av7110, mode);
1113 }
1114
1115 static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
1116 uint64_t *stc, unsigned int *base)
1117 {
1118 int ret;
1119 u16 fwstc[4];
1120 u16 tag = ((COMTYPE_REQUEST << 8) + ReqSTC);
1121 struct dvb_demux *dvbdemux;
1122 struct av7110 *av7110;
1123
1124 /* pointer casting paranoia... */
1125 if (!demux)
1126 BUG();
1127 dvbdemux = (struct dvb_demux *) demux->priv;
1128 if (!dvbdemux)
1129 BUG();
1130 av7110 = (struct av7110 *) dvbdemux->priv;
1131
1132 dprintk(4, "%p\n", av7110);
1133
1134 if (num != 0)
1135 return -EINVAL;
1136
1137 ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4);
1138 if (ret) {
1139 printk(KERN_ERR "%s: av7110_fw_request error\n", __FUNCTION__);
1140 return ret;
1141 }
1142 dprintk(2, "fwstc = %04hx %04hx %04hx %04hx\n",
1143 fwstc[0], fwstc[1], fwstc[2], fwstc[3]);
1144
1145 *stc = (((uint64_t) ((fwstc[3] & 0x8000) >> 15)) << 32) |
1146 (((uint64_t) fwstc[1]) << 16) | ((uint64_t) fwstc[0]);
1147 *base = 1;
1148
1149 dprintk(4, "stc = %lu\n", (unsigned long)*stc);
1150
1151 return 0;
1152 }
1153
1154
1155 /******************************************************************************
1156 * SEC device file operations
1157 ******************************************************************************/
1158
1159
1160 static int av7110_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
1161 {
1162 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1163
1164 switch (tone) {
1165 case SEC_TONE_ON:
1166 return Set22K(av7110, 1);
1167
1168 case SEC_TONE_OFF:
1169 return Set22K(av7110, 0);
1170
1171 default:
1172 return -EINVAL;
1173 }
1174 }
1175
1176 static int av7110_diseqc_send_master_cmd(struct dvb_frontend* fe,
1177 struct dvb_diseqc_master_cmd* cmd)
1178 {
1179 struct av7110* av7110 = fe->dvb->priv;
1180
1181 return av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1);
1182 }
1183
1184 static int av7110_diseqc_send_burst(struct dvb_frontend* fe,
1185 fe_sec_mini_cmd_t minicmd)
1186 {
1187 struct av7110* av7110 = fe->dvb->priv;
1188
1189 return av7110_diseqc_send(av7110, 0, NULL, minicmd);
1190 }
1191
1192 /* simplified code from budget-core.c */
1193 static int stop_ts_capture(struct av7110 *budget)
1194 {
1195 dprintk(2, "budget: %p\n", budget);
1196
1197 if (--budget->feeding1)
1198 return budget->feeding1;
1199 saa7146_write(budget->dev, MC1, MASK_20); /* DMA3 off */
1200 SAA7146_IER_DISABLE(budget->dev, MASK_10);
1201 SAA7146_ISR_CLEAR(budget->dev, MASK_10);
1202 return 0;
1203 }
1204
1205 static int start_ts_capture(struct av7110 *budget)
1206 {
1207 dprintk(2, "budget: %p\n", budget);
1208
1209 if (budget->feeding1)
1210 return ++budget->feeding1;
1211 memset(budget->grabbing, 0x00, TS_HEIGHT * TS_WIDTH);
1212 budget->tsf = 0xff;
1213 budget->ttbp = 0;
1214 SAA7146_IER_ENABLE(budget->dev, MASK_10); /* VPE */
1215 saa7146_write(budget->dev, MC1, (MASK_04 | MASK_20)); /* DMA3 on */
1216 return ++budget->feeding1;
1217 }
1218
1219 static int budget_start_feed(struct dvb_demux_feed *feed)
1220 {
1221 struct dvb_demux *demux = feed->demux;
1222 struct av7110 *budget = (struct av7110 *) demux->priv;
1223 int status;
1224
1225 dprintk(2, "av7110: %p\n", budget);
1226
1227 spin_lock(&budget->feedlock1);
1228 feed->pusi_seen = 0; /* have a clean section start */
1229 status = start_ts_capture(budget);
1230 spin_unlock(&budget->feedlock1);
1231 return status;
1232 }
1233
1234 static int budget_stop_feed(struct dvb_demux_feed *feed)
1235 {
1236 struct dvb_demux *demux = feed->demux;
1237 struct av7110 *budget = (struct av7110 *) demux->priv;
1238 int status;
1239
1240 dprintk(2, "budget: %p\n", budget);
1241
1242 spin_lock(&budget->feedlock1);
1243 status = stop_ts_capture(budget);
1244 spin_unlock(&budget->feedlock1);
1245 return status;
1246 }
1247
1248 static void vpeirq(unsigned long data)
1249 {
1250 struct av7110 *budget = (struct av7110 *) data;
1251 u8 *mem = (u8 *) (budget->grabbing);
1252 u32 olddma = budget->ttbp;
1253 u32 newdma = saa7146_read(budget->dev, PCI_VDP3);
1254
1255 if (!budgetpatch) {
1256 printk("av7110.c: vpeirq() called while budgetpatch disabled!"
1257 " check saa7146 IER register\n");
1258 BUG();
1259 }
1260 /* nearest lower position divisible by 188 */
1261 newdma -= newdma % 188;
1262
1263 if (newdma >= TS_BUFLEN)
1264 return;
1265
1266 budget->ttbp = newdma;
1267
1268 if (!budget->feeding1 || (newdma == olddma))
1269 return;
1270
1271 #if 0
1272 /* track rps1 activity */
1273 printk("vpeirq: %02x Event Counter 1 0x%04x\n",
1274 mem[olddma],
1275 saa7146_read(budget->dev, EC1R) & 0x3fff);
1276 #endif
1277
1278 if (newdma > olddma)
1279 /* no wraparound, dump olddma..newdma */
1280 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (newdma - olddma) / 188);
1281 else {
1282 /* wraparound, dump olddma..buflen and 0..newdma */
1283 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (TS_BUFLEN - olddma) / 188);
1284 dvb_dmx_swfilter_packets(&budget->demux1, mem, newdma / 188);
1285 }
1286 }
1287
1288 static int av7110_register(struct av7110 *av7110)
1289 {
1290 int ret, i;
1291 struct dvb_demux *dvbdemux = &av7110->demux;
1292 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1293
1294 dprintk(4, "%p\n", av7110);
1295
1296 if (av7110->registered)
1297 return -1;
1298
1299 av7110->registered = 1;
1300
1301 dvbdemux->priv = (void *) av7110;
1302
1303 for (i = 0; i < 32; i++)
1304 av7110->handle2filter[i] = NULL;
1305
1306 dvbdemux->filternum = 32;
1307 dvbdemux->feednum = 32;
1308 dvbdemux->start_feed = av7110_start_feed;
1309 dvbdemux->stop_feed = av7110_stop_feed;
1310 dvbdemux->write_to_decoder = av7110_write_to_decoder;
1311 dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1312 DMX_MEMORY_BASED_FILTERING);
1313
1314 dvb_dmx_init(&av7110->demux);
1315 av7110->demux.dmx.get_stc = dvb_get_stc;
1316
1317 av7110->dmxdev.filternum = 32;
1318 av7110->dmxdev.demux = &dvbdemux->dmx;
1319 av7110->dmxdev.capabilities = 0;
1320
1321 dvb_dmxdev_init(&av7110->dmxdev, &av7110->dvb_adapter);
1322
1323 av7110->hw_frontend.source = DMX_FRONTEND_0;
1324
1325 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1326
1327 if (ret < 0)
1328 return ret;
1329
1330 av7110->mem_frontend.source = DMX_MEMORY_FE;
1331
1332 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1333
1334 if (ret < 0)
1335 return ret;
1336
1337 ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1338 &av7110->hw_frontend);
1339 if (ret < 0)
1340 return ret;
1341
1342 av7110_av_register(av7110);
1343 av7110_ca_register(av7110);
1344
1345 #ifdef CONFIG_DVB_AV7110_OSD
1346 dvb_register_device(&av7110->dvb_adapter, &av7110->osd_dev,
1347 &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1348 #endif
1349
1350 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1351
1352 if (budgetpatch) {
1353 /* initialize software demux1 without its own frontend
1354 * demux1 hardware is connected to frontend0 of demux0
1355 */
1356 dvbdemux1->priv = (void *) av7110;
1357
1358 dvbdemux1->filternum = 256;
1359 dvbdemux1->feednum = 256;
1360 dvbdemux1->start_feed = budget_start_feed;
1361 dvbdemux1->stop_feed = budget_stop_feed;
1362 dvbdemux1->write_to_decoder = NULL;
1363
1364 dvbdemux1->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1365 DMX_MEMORY_BASED_FILTERING);
1366
1367 dvb_dmx_init(&av7110->demux1);
1368
1369 av7110->dmxdev1.filternum = 256;
1370 av7110->dmxdev1.demux = &dvbdemux1->dmx;
1371 av7110->dmxdev1.capabilities = 0;
1372
1373 dvb_dmxdev_init(&av7110->dmxdev1, &av7110->dvb_adapter);
1374
1375 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net1, &dvbdemux1->dmx);
1376 printk("dvb-ttpci: additional demux1 for budget-patch registered\n");
1377 }
1378 return 0;
1379 }
1380
1381
1382 static void dvb_unregister(struct av7110 *av7110)
1383 {
1384 struct dvb_demux *dvbdemux = &av7110->demux;
1385 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1386
1387 dprintk(4, "%p\n", av7110);
1388
1389 if (!av7110->registered)
1390 return;
1391
1392 if (budgetpatch) {
1393 dvb_net_release(&av7110->dvb_net1);
1394 dvbdemux->dmx.close(&dvbdemux1->dmx);
1395 dvb_dmxdev_release(&av7110->dmxdev1);
1396 dvb_dmx_release(&av7110->demux1);
1397 }
1398
1399 dvb_net_release(&av7110->dvb_net);
1400
1401 dvbdemux->dmx.close(&dvbdemux->dmx);
1402 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1403 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1404
1405 dvb_dmxdev_release(&av7110->dmxdev);
1406 dvb_dmx_release(&av7110->demux);
1407
1408 if (av7110->fe != NULL)
1409 dvb_unregister_frontend(av7110->fe);
1410 dvb_unregister_device(av7110->osd_dev);
1411 av7110_av_unregister(av7110);
1412 av7110_ca_unregister(av7110);
1413 }
1414
1415
1416 /****************************************************************************
1417 * I2C client commands
1418 ****************************************************************************/
1419
1420 int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1421 {
1422 u8 msg[2] = { reg, val };
1423 struct i2c_msg msgs;
1424
1425 msgs.flags = 0;
1426 msgs.addr = id / 2;
1427 msgs.len = 2;
1428 msgs.buf = msg;
1429 return i2c_transfer(&av7110->i2c_adap, &msgs, 1);
1430 }
1431
1432 #if 0
1433 u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1434 {
1435 u8 mm1[] = {0x00};
1436 u8 mm2[] = {0x00};
1437 struct i2c_msg msgs[2];
1438
1439 msgs[0].flags = 0;
1440 msgs[1].flags = I2C_M_RD;
1441 msgs[0].addr = msgs[1].addr = id / 2;
1442 mm1[0] = reg;
1443 msgs[0].len = 1; msgs[1].len = 1;
1444 msgs[0].buf = mm1; msgs[1].buf = mm2;
1445 i2c_transfer(&av7110->i2c_adap, msgs, 2);
1446
1447 return mm2[0];
1448 }
1449 #endif
1450
1451 /****************************************************************************
1452 * INITIALIZATION
1453 ****************************************************************************/
1454
1455
1456 static int check_firmware(struct av7110* av7110)
1457 {
1458 u32 crc = 0, len = 0;
1459 unsigned char *ptr;
1460
1461 /* check for firmware magic */
1462 ptr = av7110->bin_fw;
1463 if (ptr[0] != 'A' || ptr[1] != 'V' ||
1464 ptr[2] != 'F' || ptr[3] != 'W') {
1465 printk("dvb-ttpci: this is not an av7110 firmware\n");
1466 return -EINVAL;
1467 }
1468 ptr += 4;
1469
1470 /* check dpram file */
1471 crc = ntohl(*(u32*) ptr);
1472 ptr += 4;
1473 len = ntohl(*(u32*) ptr);
1474 ptr += 4;
1475 if (len >= 512) {
1476 printk("dvb-ttpci: dpram file is way to big.\n");
1477 return -EINVAL;
1478 }
1479 if (crc != crc32_le(0, ptr, len)) {
1480 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1481 return -EINVAL;
1482 }
1483 av7110->bin_dpram = ptr;
1484 av7110->size_dpram = len;
1485 ptr += len;
1486
1487 /* check root file */
1488 crc = ntohl(*(u32*) ptr);
1489 ptr += 4;
1490 len = ntohl(*(u32*) ptr);
1491 ptr += 4;
1492
1493 if (len <= 200000 || len >= 300000 ||
1494 len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1495 printk("dvb-ttpci: root file has strange size (%d). aborting.\n", len);
1496 return -EINVAL;
1497 }
1498 if( crc != crc32_le(0, ptr, len)) {
1499 printk("dvb-ttpci: crc32 of root file does not match.\n");
1500 return -EINVAL;
1501 }
1502 av7110->bin_root = ptr;
1503 av7110->size_root = len;
1504 return 0;
1505 }
1506
1507 #ifdef CONFIG_DVB_AV7110_FIRMWARE_FILE
1508 #include "av7110_firm.h"
1509 static void put_firmware(struct av7110* av7110)
1510 {
1511 av7110->bin_fw = NULL;
1512 }
1513
1514 static inline int get_firmware(struct av7110* av7110)
1515 {
1516 av7110->bin_fw = dvb_ttpci_fw;
1517 av7110->size_fw = sizeof(dvb_ttpci_fw);
1518 return check_firmware(av7110);
1519 }
1520 #else
1521 static void put_firmware(struct av7110* av7110)
1522 {
1523 vfree(av7110->bin_fw);
1524 }
1525
1526 static int get_firmware(struct av7110* av7110)
1527 {
1528 int ret;
1529 const struct firmware *fw;
1530
1531 /* request the av7110 firmware, this will block until someone uploads it */
1532 ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev);
1533 if (ret) {
1534 if (ret == -ENOENT) {
1535 printk(KERN_ERR "dvb-ttpci: could not load firmware,"
1536 " file not found: dvb-ttpci-01.fw\n");
1537 printk(KERN_ERR "dvb-ttpci: usually this should be in"
1538 " /usr/lib/hotplug/firmware\n");
1539 printk(KERN_ERR "dvb-ttpci: and can be downloaded here"
1540 " http://www.linuxtv.org/download/dvb/firmware/\n");
1541 } else
1542 printk(KERN_ERR "dvb-ttpci: cannot request firmware"
1543 " (error %i)\n", ret);
1544 return -EINVAL;
1545 }
1546
1547 if (fw->size <= 200000) {
1548 printk("dvb-ttpci: this firmware is way too small.\n");
1549 release_firmware(fw);
1550 return -EINVAL;
1551 }
1552
1553 /* check if the firmware is available */
1554 av7110->bin_fw = (unsigned char *) vmalloc(fw->size);
1555 if (NULL == av7110->bin_fw) {
1556 dprintk(1, "out of memory\n");
1557 release_firmware(fw);
1558 return -ENOMEM;
1559 }
1560
1561 memcpy(av7110->bin_fw, fw->data, fw->size);
1562 av7110->size_fw = fw->size;
1563 if ((ret = check_firmware(av7110)))
1564 vfree(av7110->bin_fw);
1565
1566 release_firmware(fw);
1567 return ret;
1568 }
1569 #endif
1570
1571
1572 static int alps_bsrv2_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1573 {
1574 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1575 u8 pwr = 0;
1576 u8 buf[4];
1577 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) };
1578 u32 div = (params->frequency + 479500) / 125;
1579
1580 if (params->frequency > 2000000) pwr = 3;
1581 else if (params->frequency > 1800000) pwr = 2;
1582 else if (params->frequency > 1600000) pwr = 1;
1583 else if (params->frequency > 1200000) pwr = 0;
1584 else if (params->frequency >= 1100000) pwr = 1;
1585 else pwr = 2;
1586
1587 buf[0] = (div >> 8) & 0x7f;
1588 buf[1] = div & 0xff;
1589 buf[2] = ((div & 0x18000) >> 10) | 0x95;
1590 buf[3] = (pwr << 6) | 0x30;
1591
1592 // NOTE: since we're using a prescaler of 2, we set the
1593 // divisor frequency to 62.5kHz and divide by 125 above
1594
1595 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1596 return -EIO;
1597 return 0;
1598 }
1599
1600 static struct ves1x93_config alps_bsrv2_config = {
1601 .demod_address = 0x08,
1602 .xin = 90100000UL,
1603 .invert_pwm = 0,
1604 .pll_set = alps_bsrv2_pll_set,
1605 };
1606
1607
1608 static u8 alps_bsru6_inittab[] = {
1609 0x01, 0x15,
1610 0x02, 0x30,
1611 0x03, 0x00,
1612 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1613 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */
1614 0x06, 0x40, /* DAC not used, set to high impendance mode */
1615 0x07, 0x00, /* DAC LSB */
1616 0x08, 0x40, /* DiSEqC off, LNB power on OP2/LOCK pin on */
1617 0x09, 0x00, /* FIFO */
1618 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1619 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */
1620 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */
1621 0x10, 0x3f, // AGC2 0x3d
1622 0x11, 0x84,
1623 0x12, 0xb5, // Lock detect: -64 Carrier freq detect:on
1624 0x15, 0xc9, // lock detector threshold
1625 0x16, 0x00,
1626 0x17, 0x00,
1627 0x18, 0x00,
1628 0x19, 0x00,
1629 0x1a, 0x00,
1630 0x1f, 0x50,
1631 0x20, 0x00,
1632 0x21, 0x00,
1633 0x22, 0x00,
1634 0x23, 0x00,
1635 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0
1636 0x29, 0x1e, // 1/2 threshold
1637 0x2a, 0x14, // 2/3 threshold
1638 0x2b, 0x0f, // 3/4 threshold
1639 0x2c, 0x09, // 5/6 threshold
1640 0x2d, 0x05, // 7/8 threshold
1641 0x2e, 0x01,
1642 0x31, 0x1f, // test all FECs
1643 0x32, 0x19, // viterbi and synchro search
1644 0x33, 0xfc, // rs control
1645 0x34, 0x93, // error control
1646 0x0f, 0x52,
1647 0xff, 0xff
1648 };
1649
1650 static int alps_bsru6_set_symbol_rate(struct dvb_frontend* fe, u32 srate, u32 ratio)
1651 {
1652 u8 aclk = 0;
1653 u8 bclk = 0;
1654
1655 if (srate < 1500000) { aclk = 0xb7; bclk = 0x47; }
1656 else if (srate < 3000000) { aclk = 0xb7; bclk = 0x4b; }
1657 else if (srate < 7000000) { aclk = 0xb7; bclk = 0x4f; }
1658 else if (srate < 14000000) { aclk = 0xb7; bclk = 0x53; }
1659 else if (srate < 30000000) { aclk = 0xb6; bclk = 0x53; }
1660 else if (srate < 45000000) { aclk = 0xb4; bclk = 0x51; }
1661
1662 stv0299_writereg(fe, 0x13, aclk);
1663 stv0299_writereg(fe, 0x14, bclk);
1664 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
1665 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
1666 stv0299_writereg(fe, 0x21, (ratio ) & 0xf0);
1667
1668 return 0;
1669 }
1670
1671 static int alps_bsru6_pll_set(struct dvb_frontend* fe, struct i2c_adapter *i2c, struct dvb_frontend_parameters* params)
1672 {
1673 int ret;
1674 u8 data[4];
1675 u32 div;
1676 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1677
1678 if ((params->frequency < 950000) || (params->frequency > 2150000))
1679 return -EINVAL;
1680
1681 div = (params->frequency + (125 - 1)) / 125; // round correctly
1682 data[0] = (div >> 8) & 0x7f;
1683 data[1] = div & 0xff;
1684 data[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
1685 data[3] = 0xC4;
1686
1687 if (params->frequency > 1530000) data[3] = 0xc0;
1688
1689 ret = i2c_transfer(i2c, &msg, 1);
1690 if (ret != 1)
1691 return -EIO;
1692 return 0;
1693 }
1694
1695 static struct stv0299_config alps_bsru6_config = {
1696
1697 .demod_address = 0x68,
1698 .inittab = alps_bsru6_inittab,
1699 .mclk = 88000000UL,
1700 .invert = 1,
1701 .enhanced_tuning = 0,
1702 .skip_reinit = 0,
1703 .lock_output = STV0229_LOCKOUTPUT_1,
1704 .volt13_op0_op1 = STV0299_VOLT13_OP1,
1705 .min_delay_ms = 100,
1706 .set_symbol_rate = alps_bsru6_set_symbol_rate,
1707 .pll_set = alps_bsru6_pll_set,
1708 };
1709
1710
1711 static u8 alps_bsbe1_inittab[] = {
1712 0x01, 0x15,
1713 0x02, 0x30,
1714 0x03, 0x00,
1715 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1716 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */
1717 0x06, 0x40, /* DAC not used, set to high impendance mode */
1718 0x07, 0x00, /* DAC LSB */
1719 0x08, 0x40, /* DiSEqC off, LNB power on OP2/LOCK pin on */
1720 0x09, 0x00, /* FIFO */
1721 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1722 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */
1723 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */
1724 0x10, 0x3f, // AGC2 0x3d
1725 0x11, 0x84,
1726 0x12, 0xb5, // Lock detect: -64 Carrier freq detect:on
1727 0x15, 0xc9, // lock detector threshold
1728 0x16, 0x00,
1729 0x17, 0x00,
1730 0x18, 0x00,
1731 0x19, 0x00,
1732 0x1a, 0x00,
1733 0x1f, 0x50,
1734 0x20, 0x00,
1735 0x21, 0x00,
1736 0x22, 0x00,
1737 0x23, 0x00,
1738 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0
1739 0x29, 0x1e, // 1/2 threshold
1740 0x2a, 0x14, // 2/3 threshold
1741 0x2b, 0x0f, // 3/4 threshold
1742 0x2c, 0x09, // 5/6 threshold
1743 0x2d, 0x05, // 7/8 threshold
1744 0x2e, 0x01,
1745 0x31, 0x1f, // test all FECs
1746 0x32, 0x19, // viterbi and synchro search
1747 0x33, 0xfc, // rs control
1748 0x34, 0x93, // error control
1749 0x0f, 0x92,
1750 0xff, 0xff
1751 };
1752
1753 static int alps_bsbe1_pll_set(struct dvb_frontend* fe, struct i2c_adapter *i2c, struct dvb_frontend_parameters* params)
1754 {
1755 int ret;
1756 u8 data[4];
1757 u32 div;
1758 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1759
1760 if ((params->frequency < 950000) || (params->frequency > 2150000))
1761 return -EINVAL;
1762
1763 div = (params->frequency + (125 - 1)) / 125; // round correctly
1764 data[0] = (div >> 8) & 0x7f;
1765 data[1] = div & 0xff;
1766 data[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
1767 data[3] = (params->frequency > 1530000) ? 0xE0 : 0xE4;
1768
1769 ret = i2c_transfer(i2c, &msg, 1);
1770 return (ret != 1) ? -EIO : 0;
1771 }
1772
1773 static struct stv0299_config alps_bsbe1_config = {
1774 .demod_address = 0x68,
1775 .inittab = alps_bsbe1_inittab,
1776 .mclk = 88000000UL,
1777 .invert = 1,
1778 .enhanced_tuning = 0,
1779 .skip_reinit = 0,
1780 .min_delay_ms = 100,
1781 .set_symbol_rate = alps_bsru6_set_symbol_rate,
1782 .pll_set = alps_bsbe1_pll_set,
1783 };
1784
1785 static int lnbp21_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
1786 {
1787 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1788 int ret;
1789 u8 data[1];
1790 struct i2c_msg msg = { .addr = 0x08, .flags = 0, .buf = data, .len = sizeof(data) };
1791
1792 switch(voltage) {
1793 case SEC_VOLTAGE_OFF:
1794 data[0] = 0x00;
1795 break;
1796 case SEC_VOLTAGE_13:
1797 data[0] = 0x44;
1798 break;
1799 case SEC_VOLTAGE_18:
1800 data[0] = 0x4c;
1801 break;
1802 default:
1803 return -EINVAL;
1804 };
1805
1806 ret = i2c_transfer(&av7110->i2c_adap, &msg, 1);
1807 return (ret != 1) ? -EIO : 0;
1808 }
1809
1810
1811 static int alps_tdbe2_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1812 {
1813 struct av7110* av7110 = fe->dvb->priv;
1814 u32 div;
1815 u8 data[4];
1816 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1817
1818 div = (params->frequency + 35937500 + 31250) / 62500;
1819
1820 data[0] = (div >> 8) & 0x7f;
1821 data[1] = div & 0xff;
1822 data[2] = 0x85 | ((div >> 10) & 0x60);
1823 data[3] = (params->frequency < 174000000 ? 0x88 : params->frequency < 470000000 ? 0x84 : 0x81);
1824
1825 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1826 return -EIO;
1827 return 0;
1828 }
1829
1830 static struct ves1820_config alps_tdbe2_config = {
1831 .demod_address = 0x09,
1832 .xin = 57840000UL,
1833 .invert = 1,
1834 .selagc = VES1820_SELAGC_SIGNAMPERR,
1835 .pll_set = alps_tdbe2_pll_set,
1836 };
1837
1838
1839
1840
1841 static int grundig_29504_451_pll_set(struct dvb_frontend* fe,
1842 struct dvb_frontend_parameters* params)
1843 {
1844 struct av7110* av7110 = fe->dvb->priv;
1845 u32 div;
1846 u8 data[4];
1847 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1848
1849 div = params->frequency / 125;
1850 data[0] = (div >> 8) & 0x7f;
1851 data[1] = div & 0xff;
1852 data[2] = 0x8e;
1853 data[3] = 0x00;
1854
1855 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1856 return -EIO;
1857 return 0;
1858 }
1859
1860 static struct tda8083_config grundig_29504_451_config = {
1861 .demod_address = 0x68,
1862 .pll_set = grundig_29504_451_pll_set,
1863 };
1864
1865
1866
1867 static int philips_cd1516_pll_set(struct dvb_frontend* fe,
1868 struct dvb_frontend_parameters* params)
1869 {
1870 struct av7110* av7110 = fe->dvb->priv;
1871 u32 div;
1872 u32 f = params->frequency;
1873 u8 data[4];
1874 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1875
1876 div = (f + 36125000 + 31250) / 62500;
1877
1878 data[0] = (div >> 8) & 0x7f;
1879 data[1] = div & 0xff;
1880 data[2] = 0x8e;
1881 data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1882
1883 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1884 return -EIO;
1885 return 0;
1886 }
1887
1888 static struct ves1820_config philips_cd1516_config = {
1889 .demod_address = 0x09,
1890 .xin = 57840000UL,
1891 .invert = 1,
1892 .selagc = VES1820_SELAGC_SIGNAMPERR,
1893 .pll_set = philips_cd1516_pll_set,
1894 };
1895
1896
1897
1898 static int alps_tdlb7_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1899 {
1900 struct av7110* av7110 = fe->dvb->priv;
1901 u32 div, pwr;
1902 u8 data[4];
1903 struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1904
1905 div = (params->frequency + 36200000) / 166666;
1906
1907 if (params->frequency <= 782000000)
1908 pwr = 1;
1909 else
1910 pwr = 2;
1911
1912 data[0] = (div >> 8) & 0x7f;
1913 data[1] = div & 0xff;
1914 data[2] = 0x85;
1915 data[3] = pwr << 6;
1916
1917 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1918 return -EIO;
1919 return 0;
1920 }
1921
1922 static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1923 {
1924 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1925
1926 return request_firmware(fw, name, &av7110->dev->pci->dev);
1927 }
1928
1929 static struct sp8870_config alps_tdlb7_config = {
1930
1931 .demod_address = 0x71,
1932 .pll_set = alps_tdlb7_pll_set,
1933 .request_firmware = alps_tdlb7_request_firmware,
1934 };
1935
1936
1937 static u8 nexusca_stv0297_inittab[] = {
1938 0x80, 0x01,
1939 0x80, 0x00,
1940 0x81, 0x01,
1941 0x81, 0x00,
1942 0x00, 0x09,
1943 0x01, 0x69,
1944 0x03, 0x00,
1945 0x04, 0x00,
1946 0x07, 0x00,
1947 0x08, 0x00,
1948 0x20, 0x00,
1949 0x21, 0x40,
1950 0x22, 0x00,
1951 0x23, 0x00,
1952 0x24, 0x40,
1953 0x25, 0x88,
1954 0x30, 0xff,
1955 0x31, 0x00,
1956 0x32, 0xff,
1957 0x33, 0x00,
1958 0x34, 0x50,
1959 0x35, 0x7f,
1960 0x36, 0x00,
1961 0x37, 0x20,
1962 0x38, 0x00,
1963 0x40, 0x1c,
1964 0x41, 0xff,
1965 0x42, 0x29,
1966 0x43, 0x00,
1967 0x44, 0xff,
1968 0x45, 0x00,
1969 0x46, 0x00,
1970 0x49, 0x04,
1971 0x4a, 0x00,
1972 0x4b, 0x7b,
1973 0x52, 0x30,
1974 0x55, 0xae,
1975 0x56, 0x47,
1976 0x57, 0xe1,
1977 0x58, 0x3a,
1978 0x5a, 0x1e,
1979 0x5b, 0x34,
1980 0x60, 0x00,
1981 0x63, 0x00,
1982 0x64, 0x00,
1983 0x65, 0x00,
1984 0x66, 0x00,
1985 0x67, 0x00,
1986 0x68, 0x00,
1987 0x69, 0x00,
1988 0x6a, 0x02,
1989 0x6b, 0x00,
1990 0x70, 0xff,
1991 0x71, 0x00,
1992 0x72, 0x00,
1993 0x73, 0x00,
1994 0x74, 0x0c,
1995 0x80, 0x00,
1996 0x81, 0x00,
1997 0x82, 0x00,
1998 0x83, 0x00,
1999 0x84, 0x04,
2000 0x85, 0x80,
2001 0x86, 0x24,
2002 0x87, 0x78,
2003 0x88, 0x10,
2004 0x89, 0x00,
2005 0x90, 0x01,
2006 0x91, 0x01,
2007 0xa0, 0x04,
2008 0xa1, 0x00,
2009 0xa2, 0x00,
2010 0xb0, 0x91,
2011 0xb1, 0x0b,
2012 0xc0, 0x53,
2013 0xc1, 0x70,
2014 0xc2, 0x12,
2015 0xd0, 0x00,
2016 0xd1, 0x00,
2017 0xd2, 0x00,
2018 0xd3, 0x00,
2019 0xd4, 0x00,
2020 0xd5, 0x00,
2021 0xde, 0x00,
2022 0xdf, 0x00,
2023 0x61, 0x49,
2024 0x62, 0x0b,
2025 0x53, 0x08,
2026 0x59, 0x08,
2027 0xff, 0xff,
2028 };
2029
2030 static int nexusca_stv0297_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
2031 {
2032 struct av7110* av7110 = fe->dvb->priv;
2033 u32 div;
2034 u8 data[4];
2035 struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
2036 struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
2037 int i;
2038
2039 div = (params->frequency + 36150000 + 31250) / 62500;
2040
2041 data[0] = (div >> 8) & 0x7f;
2042 data[1] = div & 0xff;
2043 data[2] = 0xce;
2044
2045 if (params->frequency < 45000000)
2046 return -EINVAL;
2047 else if (params->frequency < 137000000)
2048 data[3] = 0x01;
2049 else if (params->frequency < 403000000)
2050 data[3] = 0x02;
2051 else if (params->frequency < 860000000)
2052 data[3] = 0x04;
2053 else
2054 return -EINVAL;
2055
2056 stv0297_enable_plli2c(fe);
2057 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) {
2058 printk("nexusca: pll transfer failed!\n");
2059 return -EIO;
2060 }
2061
2062 // wait for PLL lock
2063 for(i = 0; i < 20; i++) {
2064
2065 stv0297_enable_plli2c(fe);
2066 if (i2c_transfer(&av7110->i2c_adap, &readmsg, 1) == 1)
2067 if (data[0] & 0x40) break;
2068 msleep(10);
2069 }
2070
2071 return 0;
2072 }
2073
2074 static struct stv0297_config nexusca_stv0297_config = {
2075
2076 .demod_address = 0x1C,
2077 .inittab = nexusca_stv0297_inittab,
2078 .invert = 1,
2079 .pll_set = nexusca_stv0297_pll_set,
2080 };
2081
2082
2083
2084 static int grundig_29504_401_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
2085 {
2086 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
2087 u32 div;
2088 u8 cfg, cpump, band_select;
2089 u8 data[4];
2090 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
2091
2092 div = (36125000 + params->frequency) / 166666;
2093
2094 cfg = 0x88;
2095
2096 if (params->frequency < 175000000) cpump = 2;
2097 else if (params->frequency < 390000000) cpump = 1;
2098 else if (params->frequency < 470000000) cpump = 2;
2099 else if (params->frequency < 750000000) cpump = 1;
2100 else cpump = 3;
2101
2102 if (params->frequency < 175000000) band_select = 0x0e;
2103 else if (params->frequency < 470000000) band_select = 0x05;
2104 else band_select = 0x03;
2105
2106 data[0] = (div >> 8) & 0x7f;
2107 data[1] = div & 0xff;
2108 data[2] = ((div >> 10) & 0x60) | cfg;
2109 data[3] = (cpump << 6) | band_select;
2110
2111 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) return -EIO;
2112 return 0;
2113 }
2114
2115 static struct l64781_config grundig_29504_401_config = {
2116 .demod_address = 0x55,
2117 .pll_set = grundig_29504_401_pll_set,
2118 };
2119
2120
2121
2122 static int av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
2123 {
2124 int ret = 0;
2125 int synced = (status & FE_HAS_LOCK) ? 1 : 0;
2126
2127 av7110->fe_status = status;
2128
2129 if (av7110->fe_synced == synced)
2130 return 0;
2131
2132 if (av7110->playing)
2133 return 0;
2134
2135 if (down_interruptible(&av7110->pid_mutex))
2136 return -ERESTARTSYS;
2137
2138 if (synced) {
2139 ret = SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
2140 av7110->pids[DMX_PES_AUDIO],
2141 av7110->pids[DMX_PES_TELETEXT], 0,
2142 av7110->pids[DMX_PES_PCR]);
2143 if (!ret)
2144 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
2145 } else {
2146 ret = SetPIDs(av7110, 0, 0, 0, 0, 0);
2147 if (!ret) {
2148 ret = av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
2149 if (!ret)
2150 ret = av7110_wait_msgstate(av7110, GPMQBusy);
2151 }
2152 }
2153
2154 if (!ret)
2155 av7110->fe_synced = synced;
2156
2157 up(&av7110->pid_mutex);
2158 return ret;
2159 }
2160
2161 static int av7110_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
2162 {
2163 struct av7110* av7110 = fe->dvb->priv;
2164
2165 int ret = av7110_fe_lock_fix(av7110, 0);
2166 if (!ret)
2167 ret = av7110->fe_set_frontend(fe, params);
2168 return ret;
2169 }
2170
2171 static int av7110_fe_init(struct dvb_frontend* fe)
2172 {
2173 struct av7110* av7110 = fe->dvb->priv;
2174
2175 int ret = av7110_fe_lock_fix(av7110, 0);
2176 if (!ret)
2177 ret = av7110->fe_init(fe);
2178 return ret;
2179 }
2180
2181 static int av7110_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
2182 {
2183 struct av7110* av7110 = fe->dvb->priv;
2184
2185 /* call the real implementation */
2186 int ret = av7110->fe_read_status(fe, status);
2187 if (!ret)
2188 if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK))
2189 ret = av7110_fe_lock_fix(av7110, *status);
2190 return ret;
2191 }
2192
2193 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
2194 {
2195 struct av7110* av7110 = fe->dvb->priv;
2196
2197 int ret = av7110_fe_lock_fix(av7110, 0);
2198 if (!ret)
2199 ret = av7110->fe_diseqc_reset_overload(fe);
2200 return ret;
2201 }
2202
2203 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
2204 struct dvb_diseqc_master_cmd* cmd)
2205 {
2206 struct av7110* av7110 = fe->dvb->priv;
2207
2208 int ret = av7110_fe_lock_fix(av7110, 0);
2209 if (!ret)
2210 ret = av7110->fe_diseqc_send_master_cmd(fe, cmd);
2211 return ret;
2212 }
2213
2214 static int av7110_fe_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t minicmd)
2215 {
2216 struct av7110* av7110 = fe->dvb->priv;
2217
2218 int ret = av7110_fe_lock_fix(av7110, 0);
2219 if (!ret)
2220 ret = av7110->fe_diseqc_send_burst(fe, minicmd);
2221 return ret;
2222 }
2223
2224 static int av7110_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
2225 {
2226 struct av7110* av7110 = fe->dvb->priv;
2227
2228 int ret = av7110_fe_lock_fix(av7110, 0);
2229 if (!ret)
2230 ret = av7110->fe_set_tone(fe, tone);
2231 return ret;
2232 }
2233
2234 static int av7110_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
2235 {
2236 struct av7110* av7110 = fe->dvb->priv;
2237
2238 int ret = av7110_fe_lock_fix(av7110, 0);
2239 if (!ret)
2240 ret = av7110->fe_set_voltage(fe, voltage);
2241 return ret;
2242 }
2243
2244 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned int cmd)
2245 {
2246 struct av7110* av7110 = fe->dvb->priv;
2247
2248 int ret = av7110_fe_lock_fix(av7110, 0);
2249 if (!ret)
2250 ret = av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
2251 return ret;
2252 }
2253
2254 static u8 read_pwm(struct av7110* av7110)
2255 {
2256 u8 b = 0xff;
2257 u8 pwm;
2258 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
2259 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
2260
2261 if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
2262 pwm = 0x48;
2263
2264 return pwm;
2265 }
2266
2267 static int frontend_init(struct av7110 *av7110)
2268 {
2269 int ret;
2270
2271 if (av7110->dev->pci->subsystem_vendor == 0x110a) {
2272 switch(av7110->dev->pci->subsystem_device) {
2273 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
2274 av7110->fe = ves1820_attach(&philips_cd1516_config,
2275 &av7110->i2c_adap, read_pwm(av7110));
2276 break;
2277 }
2278
2279 } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
2280 switch(av7110->dev->pci->subsystem_device) {
2281 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
2282 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
2283 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
2284
2285 // try the ALPS BSRV2 first of all
2286 av7110->fe = ves1x93_attach(&alps_bsrv2_config, &av7110->i2c_adap);
2287 if (av7110->fe) {
2288 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2289 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
2290 av7110->fe->ops->set_tone = av7110_set_tone;
2291 break;
2292 }
2293
2294 // try the ALPS BSRU6 now
2295 av7110->fe = stv0299_attach(&alps_bsru6_config, &av7110->i2c_adap);
2296 if (av7110->fe) {
2297 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2298 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
2299 av7110->fe->ops->set_tone = av7110_set_tone;
2300 break;
2301 }
2302
2303 // Try the grundig 29504-451
2304 av7110->fe = tda8083_attach(&grundig_29504_451_config, &av7110->i2c_adap);
2305 if (av7110->fe) {
2306 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2307 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
2308 av7110->fe->ops->set_tone = av7110_set_tone;
2309 break;
2310 }
2311
2312 /* Try DVB-C cards */
2313 switch(av7110->dev->pci->subsystem_device) {
2314 case 0x0000:
2315 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
2316 av7110->fe = ves1820_attach(&philips_cd1516_config, &av7110->i2c_adap,
2317 read_pwm(av7110));
2318 break;
2319 case 0x0003:
2320 /* Haupauge DVB-C 2.1 VES1820/ALPS TDBE2 */
2321 av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap,
2322 read_pwm(av7110));
2323 break;
2324 }
2325 break;
2326
2327 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
2328
2329 // ALPS TDLB7
2330 av7110->fe = sp8870_attach(&alps_tdlb7_config, &av7110->i2c_adap);
2331 break;
2332
2333 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
2334
2335 av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
2336 break;
2337
2338 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
2339 /* Grundig 29504-451 */
2340 av7110->fe = tda8083_attach(&grundig_29504_451_config, &av7110->i2c_adap);
2341 if (av7110->fe) {
2342 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2343 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
2344 av7110->fe->ops->set_tone = av7110_set_tone;
2345 }
2346 break;
2347
2348 case 0x0008: // Hauppauge/TT DVB-T
2349
2350 av7110->fe = l64781_attach(&grundig_29504_401_config, &av7110->i2c_adap);
2351 break;
2352
2353 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
2354
2355 av7110->fe = stv0297_attach(&nexusca_stv0297_config, &av7110->i2c_adap);
2356 if (av7110->fe) {
2357 /* set TDA9819 into DVB mode */
2358 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9198 pin9(STD)
2359 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9198 pin30(VIF)
2360
2361 /* tuner on this needs a slower i2c bus speed */
2362 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
2363 break;
2364 }
2365 break;
2366
2367 case 0x000E: /* Hauppauge/TT Nexus-S rev 2.3 */
2368 /* ALPS BSBE1 */
2369 av7110->fe = stv0299_attach(&alps_bsbe1_config, &av7110->i2c_adap);
2370 if (av7110->fe)
2371 av7110->fe->ops->set_voltage = lnbp21_set_voltage;
2372 break;
2373 }
2374 }
2375
2376 if (!av7110->fe) {
2377 /* FIXME: propagate the failure code from the lower layers */
2378 ret = -ENOMEM;
2379 printk("dvb-ttpci: A frontend driver was not found for device %04x/%04x subsystem %04x/%04x\n",
2380 av7110->dev->pci->vendor,
2381 av7110->dev->pci->device,
2382 av7110->dev->pci->subsystem_vendor,
2383 av7110->dev->pci->subsystem_device);
2384 } else {
2385 FE_FUNC_OVERRIDE(av7110->fe->ops->init, av7110->fe_init, av7110_fe_init);
2386 FE_FUNC_OVERRIDE(av7110->fe->ops->read_status, av7110->fe_read_status, av7110_fe_read_status);
2387 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
2388 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
2389 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
2390 FE_FUNC_OVERRIDE(av7110->fe->ops->set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
2391 FE_FUNC_OVERRIDE(av7110->fe->ops->set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage;)
2392 FE_FUNC_OVERRIDE(av7110->fe->ops->dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
2393 FE_FUNC_OVERRIDE(av7110->fe->ops->set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
2394
2395 ret = dvb_register_frontend(&av7110->dvb_adapter, av7110->fe);
2396 if (ret < 0) {
2397 printk("av7110: Frontend registration failed!\n");
2398 if (av7110->fe->ops->release)
2399 av7110->fe->ops->release(av7110->fe);
2400 av7110->fe = NULL;
2401 }
2402 }
2403 return ret;
2404 }
2405
2406 /* Budgetpatch note:
2407 * Original hardware design by Roberto Deza:
2408 * There is a DVB_Wiki at
2409 * http://212.227.36.83/linuxtv/wiki/index.php/Main_Page
2410 * where is described this 'DVB TT Budget Patch', on Card Modding:
2411 * http://212.227.36.83/linuxtv/wiki/index.php/DVB_TT_Budget_Patch
2412 * On the short description there is also a link to a external file,
2413 * with more details:
2414 * http://perso.wanadoo.es/jesussolano/Ttf_tsc1.zip
2415 *
2416 * New software triggering design by Emard that works on
2417 * original Roberto Deza's hardware:
2418 *
2419 * rps1 code for budgetpatch will copy internal HS event to GPIO3 pin.
2420 * GPIO3 is in budget-patch hardware connectd to port B VSYNC
2421 * HS is an internal event of 7146, accessible with RPS
2422 * and temporarily raised high every n lines
2423 * (n in defined in the RPS_THRESH1 counter threshold)
2424 * I think HS is raised high on the beginning of the n-th line
2425 * and remains high until this n-th line that triggered
2426 * it is completely received. When the receiption of n-th line
2427 * ends, HS is lowered.
2428 *
2429 * To transmit data over DMA, 7146 needs changing state at
2430 * port B VSYNC pin. Any changing of port B VSYNC will
2431 * cause some DMA data transfer, with more or less packets loss.
2432 * It depends on the phase and frequency of VSYNC and
2433 * the way of 7146 is instructed to trigger on port B (defined
2434 * in DD1_INIT register, 3rd nibble from the right valid
2435 * numbers are 0-7, see datasheet)
2436 *
2437 * The correct triggering can minimize packet loss,
2438 * dvbtraffic should give this stable bandwidths:
2439 * 22k transponder = 33814 kbit/s
2440 * 27.5k transponder = 38045 kbit/s
2441 * by experiment it is found that the best results
2442 * (stable bandwidths and almost no packet loss)
2443 * are obtained using DD1_INIT triggering number 2
2444 * (Va at rising edge of VS Fa = HS x VS-failing forced toggle)
2445 * and a VSYNC phase that occurs in the middle of DMA transfer
2446 * (about byte 188*512=96256 in the DMA window).
2447 *
2448 * Phase of HS is still not clear to me how to control,
2449 * It just happens to be so. It can be seen if one enables
2450 * RPS_IRQ and print Event Counter 1 in vpeirq(). Every
2451 * time RPS_INTERRUPT is called, the Event Counter 1 will
2452 * increment. That's how the 7146 is programmed to do event
2453 * counting in this budget-patch.c
2454 * I *think* HPS setting has something to do with the phase
2455 * of HS but I cant be 100% sure in that.
2456 *
2457 * hardware debug note: a working budget card (including budget patch)
2458 * with vpeirq() interrupt setup in mode "0x90" (every 64K) will
2459 * generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes
2460 * and that means 3*25=75 Hz of interrupt freqency, as seen by
2461 * watch cat /proc/interrupts
2462 *
2463 * If this frequency is 3x lower (and data received in the DMA
2464 * buffer don't start with 0x47, but in the middle of packets,
2465 * whose lengths appear to be like 188 292 188 104 etc.
2466 * this means VSYNC line is not connected in the hardware.
2467 * (check soldering pcb and pins)
2468 * The same behaviour of missing VSYNC can be duplicated on budget
2469 * cards, by seting DD1_INIT trigger mode 7 in 3rd nibble.
2470 */
2471 static int av7110_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_data *pci_ext)
2472 {
2473 const int length = TS_WIDTH * TS_HEIGHT;
2474 struct pci_dev *pdev = dev->pci;
2475 struct av7110 *av7110;
2476 int ret, count = 0;
2477
2478 dprintk(4, "dev: %p\n", dev);
2479
2480 /* Set RPS_IRQ to 1 to track rps1 activity.
2481 * Enabling this won't send any interrupt to PC CPU.
2482 */
2483 #define RPS_IRQ 0
2484
2485 if (budgetpatch == 1) {
2486 budgetpatch = 0;
2487 /* autodetect the presence of budget patch
2488 * this only works if saa7146 has been recently
2489 * reset with with MASK_31 to MC1
2490 *
2491 * will wait for VBI_B event (vertical blank at port B)
2492 * and will reset GPIO3 after VBI_B is detected.
2493 * (GPIO3 should be raised high by CPU to
2494 * test if GPIO3 will generate vertical blank signal
2495 * in budget patch GPIO3 is connected to VSYNC_B
2496 */
2497
2498 /* RESET SAA7146 */
2499 saa7146_write(dev, MC1, MASK_31);
2500 /* autodetection success seems to be time-dependend after reset */
2501
2502 /* Fix VSYNC level */
2503 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2504 /* set vsync_b triggering */
2505 saa7146_write(dev, DD1_STREAM_B, 0);
2506 /* port B VSYNC at rising edge */
2507 saa7146_write(dev, DD1_INIT, 0x00000200);
2508 saa7146_write(dev, BRS_CTRL, 0x00000000); // VBI
2509 saa7146_write(dev, MC2,
2510 1 * (MASK_08 | MASK_24) | // BRS control
2511 0 * (MASK_09 | MASK_25) | // a
2512 1 * (MASK_10 | MASK_26) | // b
2513 0 * (MASK_06 | MASK_22) | // HPS_CTRL1
2514 0 * (MASK_05 | MASK_21) | // HPS_CTRL2
2515 0 * (MASK_01 | MASK_15) // DEBI
2516 );
2517
2518 /* start writing RPS1 code from beginning */
2519 count = 0;
2520 /* Disable RPS1 */
2521 saa7146_write(dev, MC1, MASK_29);
2522 /* RPS1 timeout disable */
2523 saa7146_write(dev, RPS_TOV1, 0);
2524 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_VBI_B));
2525 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2526 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2527 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTLO<<24));
2528 #if RPS_IRQ
2529 /* issue RPS1 interrupt to increment counter */
2530 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2531 #endif
2532 WRITE_RPS1(cpu_to_le32(CMD_STOP));
2533 /* Jump to begin of RPS program as safety measure (p37) */
2534 WRITE_RPS1(cpu_to_le32(CMD_JUMP));
2535 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle));
2536
2537 #if RPS_IRQ
2538 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2539 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2540 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2541 */
2542 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2543 /* set event counter 1 treshold to maximum allowed value (rEC p55) */
2544 saa7146_write(dev, ECT1R, 0x3fff );
2545 #endif
2546 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2547 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2548 /* Enable RPS1, (rFC p33) */
2549 saa7146_write(dev, MC1, (MASK_13 | MASK_29 ));
2550
2551 mdelay(10);
2552 /* now send VSYNC_B to rps1 by rising GPIO3 */
2553 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI);
2554 mdelay(10);
2555 /* if rps1 responded by lowering the GPIO3,
2556 * then we have budgetpatch hardware
2557 */
2558 if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) {
2559 budgetpatch = 1;
2560 printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2561 }
2562 /* Disable RPS1 */
2563 saa7146_write(dev, MC1, ( MASK_29 ));
2564 #if RPS_IRQ
2565 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff );
2566 #endif
2567 }
2568
2569 /* prepare the av7110 device struct */
2570 av7110 = kmalloc(sizeof(struct av7110), GFP_KERNEL);
2571 if (!av7110) {
2572 dprintk(1, "out of memory\n");
2573 return -ENOMEM;
2574 }
2575
2576 memset(av7110, 0, sizeof(struct av7110));
2577
2578 av7110->card_name = (char*) pci_ext->ext_priv;
2579 av7110->dev = dev;
2580 dev->ext_priv = av7110;
2581
2582 ret = get_firmware(av7110);
2583 if (ret < 0)
2584 goto err_kfree_0;
2585
2586 ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name,
2587 THIS_MODULE);
2588 if (ret < 0)
2589 goto err_put_firmware_1;
2590
2591 /* the Siemens DVB needs this if you want to have the i2c chips
2592 get recognized before the main driver is fully loaded */
2593 saa7146_write(dev, GPIO_CTRL, 0x500000);
2594
2595 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
2596 av7110->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL;
2597 #else
2598 av7110->i2c_adap.class = I2C_CLASS_TV_DIGITAL;
2599 #endif
2600 strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
2601
2602 saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
2603
2604 ret = i2c_add_adapter(&av7110->i2c_adap);
2605 if (ret < 0)
2606 goto err_dvb_unregister_adapter_2;
2607
2608 ttpci_eeprom_parse_mac(&av7110->i2c_adap,
2609 av7110->dvb_adapter.proposed_mac);
2610 ret = -ENOMEM;
2611
2612 if (budgetpatch) {
2613 spin_lock_init(&av7110->feedlock1);
2614 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2615 &av7110->pt);
2616 if (!av7110->grabbing)
2617 goto err_i2c_del_3;
2618
2619 saa7146_write(dev, PCI_BT_V1, 0x1c1f101f);
2620 saa7146_write(dev, BCS_CTRL, 0x80400040);
2621 /* set dd1 stream a & b */
2622 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2623 saa7146_write(dev, DD1_INIT, 0x03000200);
2624 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2625 saa7146_write(dev, BRS_CTRL, 0x60000000);
2626 saa7146_write(dev, BASE_ODD3, 0);
2627 saa7146_write(dev, BASE_EVEN3, 0);
2628 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2629 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2630
2631 saa7146_write(dev, PITCH3, TS_WIDTH);
2632 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2633
2634 /* upload all */
2635 saa7146_write(dev, MC2, 0x077c077c);
2636 saa7146_write(dev, GPIO_CTRL, 0x000000);
2637 #if RPS_IRQ
2638 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2639 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2640 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2641 */
2642 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2643 /* set event counter 1 treshold to maximum allowed value (rEC p55) */
2644 saa7146_write(dev, ECT1R, 0x3fff );
2645 #endif
2646 /* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */
2647 count = 0;
2648
2649 /* Wait Source Line Counter Threshold (p36) */
2650 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_HS));
2651 /* Set GPIO3=1 (p42) */
2652 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2653 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2654 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTHI<<24));
2655 #if RPS_IRQ
2656 /* issue RPS1 interrupt */
2657 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2658 #endif
2659 /* Wait reset Source Line Counter Threshold (p36) */
2660 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | RPS_INV | EVT_HS));
2661 /* Set GPIO3=0 (p42) */
2662 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2663 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2664 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTLO<<24));
2665 #if RPS_IRQ
2666 /* issue RPS1 interrupt */
2667 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2668 #endif
2669 /* Jump to begin of RPS program (p37) */
2670 WRITE_RPS1(cpu_to_le32(CMD_JUMP));
2671 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle));
2672
2673 /* Fix VSYNC level */
2674 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2675 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2676 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2677 /* Set Source Line Counter Threshold, using BRS (rCC p43)
2678 * It generates HS event every TS_HEIGHT lines
2679 * this is related to TS_WIDTH set in register
2680 * NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits
2681 * are set to TS_WIDTH bytes (TS_WIDTH=2*188),
2682 * then RPS_THRESH1 should be set to trigger
2683 * every TS_HEIGHT (512) lines.
2684 */
2685 saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 );
2686
2687 /* Enable RPS1 (rFC p33) */
2688 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
2689
2690 /* end of budgetpatch register initialization */
2691 tasklet_init (&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2692 } else {
2693 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
2694 saa7146_write(dev, BCS_CTRL, 0x80400040);
2695
2696 /* set dd1 stream a & b */
2697 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2698 saa7146_write(dev, DD1_INIT, 0x03000000);
2699 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2700
2701 /* upload all */
2702 saa7146_write(dev, MC2, 0x077c077c);
2703 saa7146_write(dev, GPIO_CTRL, 0x000000);
2704 }
2705
2706 tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2707 tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2708
2709 sema_init(&av7110->pid_mutex, 1);
2710
2711 /* locks for data transfers from/to AV7110 */
2712 spin_lock_init(&av7110->debilock);
2713 sema_init(&av7110->dcomlock, 1);
2714 av7110->debitype = -1;
2715
2716 /* default OSD window */
2717 av7110->osdwin = 1;
2718 sema_init(&av7110->osd_sema, 1);
2719
2720 /* ARM "watchdog" */
2721 init_waitqueue_head(&av7110->arm_wait);
2722 av7110->arm_thread = NULL;
2723
2724 /* allocate and init buffers */
2725 av7110->debi_virt = pci_alloc_consistent(pdev, 8192, &av7110->debi_bus);
2726 if (!av7110->debi_virt)
2727 goto err_saa71466_vfree_4;
2728
2729
2730 av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2731 if (!av7110->iobuf)
2732 goto err_pci_free_5;
2733
2734 ret = av7110_av_init(av7110);
2735 if (ret < 0)
2736 goto err_iobuf_vfree_6;
2737
2738 /* init BMP buffer */
2739 av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN;
2740 init_waitqueue_head(&av7110->bmpq);
2741
2742 ret = av7110_ca_init(av7110);
2743 if (ret < 0)
2744 goto err_av7110_av_exit_7;
2745
2746 /* load firmware into AV7110 cards */
2747 ret = av7110_bootarm(av7110);
2748 if (ret < 0)
2749 goto err_av7110_ca_exit_8;
2750
2751 ret = av7110_firmversion(av7110);
2752 if (ret < 0)
2753 goto err_stop_arm_9;
2754
2755 if (FW_VERSION(av7110->arm_app)<0x2501)
2756 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2757 "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2758
2759 ret = kernel_thread(arm_thread, (void *) av7110, 0);
2760 if (ret < 0)
2761 goto err_stop_arm_9;
2762
2763 /* set initial volume in mixer struct */
2764 av7110->mixer.volume_left = volume;
2765 av7110->mixer.volume_right = volume;
2766
2767 init_av7110_av(av7110);
2768
2769 ret = av7110_register(av7110);
2770 if (ret < 0)
2771 goto err_arm_thread_stop_10;
2772
2773 /* special case DVB-C: these cards have an analog tuner
2774 plus need some special handling, so we have separate
2775 saa7146_ext_vv data for these... */
2776 ret = av7110_init_v4l(av7110);
2777 if (ret < 0)
2778 goto err_av7110_unregister_11;
2779
2780 av7110->dvb_adapter.priv = av7110;
2781 ret = frontend_init(av7110);
2782 if (ret < 0)
2783 goto err_av7110_exit_v4l_12;
2784
2785 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2786 av7110_ir_init();
2787 #endif
2788 printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2789 av7110_num++;
2790 out:
2791 return ret;
2792
2793 err_av7110_exit_v4l_12:
2794 av7110_exit_v4l(av7110);
2795 err_av7110_unregister_11:
2796 dvb_unregister(av7110);
2797 err_arm_thread_stop_10:
2798 av7110_arm_sync(av7110);
2799 err_stop_arm_9:
2800 /* Nothing to do. Rejoice. */
2801 err_av7110_ca_exit_8:
2802 av7110_ca_exit(av7110);
2803 err_av7110_av_exit_7:
2804 av7110_av_exit(av7110);
2805 err_iobuf_vfree_6:
2806 vfree(av7110->iobuf);
2807 err_pci_free_5:
2808 pci_free_consistent(pdev, 8192, av7110->debi_virt, av7110->debi_bus);
2809 err_saa71466_vfree_4:
2810 if (!av7110->grabbing)
2811 saa7146_pgtable_free(pdev, &av7110->pt);
2812 err_i2c_del_3:
2813 i2c_del_adapter(&av7110->i2c_adap);
2814 err_dvb_unregister_adapter_2:
2815 dvb_unregister_adapter(&av7110->dvb_adapter);
2816 err_put_firmware_1:
2817 put_firmware(av7110);
2818 err_kfree_0:
2819 kfree(av7110);
2820 goto out;
2821 }
2822
2823 static int av7110_detach(struct saa7146_dev* saa)
2824 {
2825 struct av7110 *av7110 = saa->ext_priv;
2826 dprintk(4, "%p\n", av7110);
2827
2828 if (budgetpatch) {
2829 /* Disable RPS1 */
2830 saa7146_write(saa, MC1, MASK_29);
2831 /* VSYNC LOW (inactive) */
2832 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
2833 saa7146_write(saa, MC1, MASK_20); /* DMA3 off */
2834 SAA7146_IER_DISABLE(saa, MASK_10);
2835 SAA7146_ISR_CLEAR(saa, MASK_10);
2836 msleep(50);
2837 tasklet_kill(&av7110->vpe_tasklet);
2838 saa7146_pgtable_free(saa->pci, &av7110->pt);
2839 }
2840 av7110_exit_v4l(av7110);
2841
2842 av7110_arm_sync(av7110);
2843
2844 tasklet_kill(&av7110->debi_tasklet);
2845 tasklet_kill(&av7110->gpio_tasklet);
2846
2847 dvb_unregister(av7110);
2848
2849 SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2850 SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2851
2852 av7110_ca_exit(av7110);
2853 av7110_av_exit(av7110);
2854
2855 vfree(av7110->iobuf);
2856 pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2857 av7110->debi_bus);
2858
2859 i2c_del_adapter(&av7110->i2c_adap);
2860
2861 dvb_unregister_adapter (&av7110->dvb_adapter);
2862
2863 av7110_num--;
2864
2865 put_firmware(av7110);
2866
2867 kfree(av7110);
2868
2869 saa->ext_priv = NULL;
2870
2871 return 0;
2872 }
2873
2874
2875 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2876 {
2877 struct av7110 *av7110 = dev->ext_priv;
2878
2879 //print_time("av7110_irq");
2880
2881 /* Note: Don't try to handle the DEBI error irq (MASK_18), in
2882 * intel mode the timeout is asserted all the time...
2883 */
2884
2885 if (*isr & MASK_19) {
2886 //printk("av7110_irq: DEBI\n");
2887 /* Note 1: The DEBI irq is level triggered: We must enable it
2888 * only after we started a DMA xfer, and disable it here
2889 * immediately, or it will be signalled all the time while
2890 * DEBI is idle.
2891 * Note 2: You would think that an irq which is masked is
2892 * not signalled by the hardware. Not so for the SAA7146:
2893 * An irq is signalled as long as the corresponding bit
2894 * in the ISR is set, and disabling irqs just prevents the
2895 * hardware from setting the ISR bit. This means a) that we
2896 * must clear the ISR *after* disabling the irq (which is why
2897 * we must do it here even though saa7146_core did it already),
2898 * and b) that if we were to disable an edge triggered irq
2899 * (like the gpio irqs sadly are) temporarily we would likely
2900 * loose some. This sucks :-(
2901 */
2902 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
2903 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
2904 tasklet_schedule(&av7110->debi_tasklet);
2905 }
2906
2907 if (*isr & MASK_03) {
2908 //printk("av7110_irq: GPIO\n");
2909 tasklet_schedule(&av7110->gpio_tasklet);
2910 }
2911
2912 if ((*isr & MASK_10) && budgetpatch)
2913 tasklet_schedule(&av7110->vpe_tasklet);
2914 }
2915
2916
2917 static struct saa7146_extension av7110_extension;
2918
2919 #define MAKE_AV7110_INFO(x_var,x_name) \
2920 static struct saa7146_pci_extension_data x_var = { \
2921 .ext_priv = x_name, \
2922 .ext = &av7110_extension }
2923
2924 MAKE_AV7110_INFO(tts_1_X, "Technotrend/Hauppauge WinTV DVB-S rev1.X");
2925 MAKE_AV7110_INFO(ttt_1_X, "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2926 MAKE_AV7110_INFO(ttc_1_X, "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2927 MAKE_AV7110_INFO(ttc_2_X, "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2928 MAKE_AV7110_INFO(tts_2_X, "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2929 MAKE_AV7110_INFO(tts_2_3, "Technotrend/Hauppauge WinTV Nexus-S rev2.3");
2930 MAKE_AV7110_INFO(tts_1_3se, "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2931 MAKE_AV7110_INFO(ttt, "Technotrend/Hauppauge DVB-T");
2932 MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C");
2933 MAKE_AV7110_INFO(fss, "Fujitsu Siemens DVB-S rev1.6");
2934
2935 static struct pci_device_id pci_tbl[] = {
2936 MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000),
2937 MAKE_EXTENSION_PCI(tts_1_X, 0x13c2, 0x0000),
2938 MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001),
2939 MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002),
2940 MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003),
2941 MAKE_EXTENSION_PCI(fss, 0x13c2, 0x0006),
2942 MAKE_EXTENSION_PCI(ttt, 0x13c2, 0x0008),
2943 MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a),
2944 MAKE_EXTENSION_PCI(tts_2_3, 0x13c2, 0x000e),
2945 MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002),
2946
2947 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0004), UNDEFINED CARD */ // Galaxis DVB PC-Sat-Carte
2948 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2949 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2950
2951 {
2952 .vendor = 0,
2953 }
2954 };
2955
2956 MODULE_DEVICE_TABLE(pci, pci_tbl);
2957
2958
2959 static struct saa7146_extension av7110_extension = {
2960 .name = "dvb\0",
2961 .flags = SAA7146_I2C_SHORT_DELAY,
2962
2963 .module = THIS_MODULE,
2964 .pci_tbl = &pci_tbl[0],
2965 .attach = av7110_attach,
2966 .detach = av7110_detach,
2967
2968 .irq_mask = MASK_19 | MASK_03 | MASK_10,
2969 .irq_func = av7110_irq,
2970 };
2971
2972
2973 static int __init av7110_init(void)
2974 {
2975 int retval;
2976 retval = saa7146_register_extension(&av7110_extension);
2977 return retval;
2978 }
2979
2980
2981 static void __exit av7110_exit(void)
2982 {
2983 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2984 av7110_ir_exit();
2985 #endif
2986 saa7146_unregister_extension(&av7110_extension);
2987 }
2988
2989 module_init(av7110_init);
2990 module_exit(av7110_exit);
2991
2992 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2993 "Siemens, Technotrend, Hauppauge");
2994 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2995 MODULE_LICENSE("GPL");
Linux 2.6 libata-dev (mirror)