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