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