]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/media/dvb/ttpci/av7110.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Linux-2.6.12-rc2
[mirror_ubuntu-artful-kernel.git] / drivers / media / dvb / ttpci / av7110.c
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
1677 static int alps_tdbe2_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1678 {
1679 struct av7110* av7110 = fe->dvb->priv;
1680 u32 div;
1681 u8 data[4];
1682 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1683
1684 div = (params->frequency + 35937500 + 31250) / 62500;
1685
1686 data[0] = (div >> 8) & 0x7f;
1687 data[1] = div & 0xff;
1688 data[2] = 0x85 | ((div >> 10) & 0x60);
1689 data[3] = (params->frequency < 174000000 ? 0x88 : params->frequency < 470000000 ? 0x84 : 0x81);
1690
1691 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1692 return -EIO;
1693 return 0;
1694 }
1695
1696 static struct ves1820_config alps_tdbe2_config = {
1697 .demod_address = 0x09,
1698 .xin = 57840000UL,
1699 .invert = 1,
1700 .selagc = VES1820_SELAGC_SIGNAMPERR,
1701 .pll_set = alps_tdbe2_pll_set,
1702 };
1703
1704
1705
1706
1707 static int grundig_29504_451_pll_set(struct dvb_frontend* fe,
1708 struct dvb_frontend_parameters* params)
1709 {
1710 struct av7110* av7110 = fe->dvb->priv;
1711 u32 div;
1712 u8 data[4];
1713 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1714
1715 div = params->frequency / 125;
1716 data[0] = (div >> 8) & 0x7f;
1717 data[1] = div & 0xff;
1718 data[2] = 0x8e;
1719 data[3] = 0x00;
1720
1721 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1722 return -EIO;
1723 return 0;
1724 }
1725
1726 static struct tda8083_config grundig_29504_451_config = {
1727 .demod_address = 0x68,
1728 .pll_set = grundig_29504_451_pll_set,
1729 };
1730
1731
1732
1733 static int philips_cd1516_pll_set(struct dvb_frontend* fe,
1734 struct dvb_frontend_parameters* params)
1735 {
1736 struct av7110* av7110 = fe->dvb->priv;
1737 u32 div;
1738 u32 f = params->frequency;
1739 u8 data[4];
1740 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1741
1742 div = (f + 36125000 + 31250) / 62500;
1743
1744 data[0] = (div >> 8) & 0x7f;
1745 data[1] = div & 0xff;
1746 data[2] = 0x8e;
1747 data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1748
1749 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1750 return -EIO;
1751 return 0;
1752 }
1753
1754 static struct ves1820_config philips_cd1516_config = {
1755 .demod_address = 0x09,
1756 .xin = 57840000UL,
1757 .invert = 1,
1758 .selagc = VES1820_SELAGC_SIGNAMPERR,
1759 .pll_set = philips_cd1516_pll_set,
1760 };
1761
1762
1763
1764 static int alps_tdlb7_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1765 {
1766 struct av7110* av7110 = fe->dvb->priv;
1767 u32 div, pwr;
1768 u8 data[4];
1769 struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1770
1771 div = (params->frequency + 36200000) / 166666;
1772
1773 if (params->frequency <= 782000000)
1774 pwr = 1;
1775 else
1776 pwr = 2;
1777
1778 data[0] = (div >> 8) & 0x7f;
1779 data[1] = div & 0xff;
1780 data[2] = 0x85;
1781 data[3] = pwr << 6;
1782
1783 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1784 return -EIO;
1785 return 0;
1786 }
1787
1788 static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1789 {
1790 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1791
1792 return request_firmware(fw, name, &av7110->dev->pci->dev);
1793 }
1794
1795 static struct sp8870_config alps_tdlb7_config = {
1796
1797 .demod_address = 0x71,
1798 .pll_set = alps_tdlb7_pll_set,
1799 .request_firmware = alps_tdlb7_request_firmware,
1800 };
1801
1802
1803
1804 static int nexusca_stv0297_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1805 {
1806 struct av7110* av7110 = fe->dvb->priv;
1807 u32 div;
1808 u8 data[4];
1809 struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
1810 struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
1811 int i;
1812
1813 div = (params->frequency + 36150000 + 31250) / 62500;
1814
1815 data[0] = (div >> 8) & 0x7f;
1816 data[1] = div & 0xff;
1817 data[2] = 0xce;
1818
1819 if (params->frequency < 45000000)
1820 return -EINVAL;
1821 else if (params->frequency < 137000000)
1822 data[3] = 0x01;
1823 else if (params->frequency < 403000000)
1824 data[3] = 0x02;
1825 else if (params->frequency < 860000000)
1826 data[3] = 0x04;
1827 else
1828 return -EINVAL;
1829
1830 stv0297_enable_plli2c(fe);
1831 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) {
1832 printk("nexusca: pll transfer failed!\n");
1833 return -EIO;
1834 }
1835
1836 // wait for PLL lock
1837 for(i = 0; i < 20; i++) {
1838
1839 stv0297_enable_plli2c(fe);
1840 if (i2c_transfer(&av7110->i2c_adap, &readmsg, 1) == 1)
1841 if (data[0] & 0x40) break;
1842 msleep(10);
1843 }
1844
1845 return 0;
1846 }
1847
1848 static struct stv0297_config nexusca_stv0297_config = {
1849
1850 .demod_address = 0x1C,
1851 .invert = 1,
1852 .pll_set = nexusca_stv0297_pll_set,
1853 };
1854
1855
1856
1857 static int grundig_29504_401_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1858 {
1859 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1860 u32 div;
1861 u8 cfg, cpump, band_select;
1862 u8 data[4];
1863 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1864
1865 div = (36125000 + params->frequency) / 166666;
1866
1867 cfg = 0x88;
1868
1869 if (params->frequency < 175000000) cpump = 2;
1870 else if (params->frequency < 390000000) cpump = 1;
1871 else if (params->frequency < 470000000) cpump = 2;
1872 else if (params->frequency < 750000000) cpump = 1;
1873 else cpump = 3;
1874
1875 if (params->frequency < 175000000) band_select = 0x0e;
1876 else if (params->frequency < 470000000) band_select = 0x05;
1877 else band_select = 0x03;
1878
1879 data[0] = (div >> 8) & 0x7f;
1880 data[1] = div & 0xff;
1881 data[2] = ((div >> 10) & 0x60) | cfg;
1882 data[3] = (cpump << 6) | band_select;
1883
1884 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) return -EIO;
1885 return 0;
1886 }
1887
1888 static struct l64781_config grundig_29504_401_config = {
1889 .demod_address = 0x55,
1890 .pll_set = grundig_29504_401_pll_set,
1891 };
1892
1893
1894
1895 static void av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
1896 {
1897 int synced = (status & FE_HAS_LOCK) ? 1 : 0;
1898
1899 av7110->fe_status = status;
1900
1901 if (av7110->fe_synced == synced)
1902 return;
1903
1904 av7110->fe_synced = synced;
1905
1906 if (av7110->playing)
1907 return;
1908
1909 if (down_interruptible(&av7110->pid_mutex))
1910 return;
1911
1912 if (av7110->fe_synced) {
1913 SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
1914 av7110->pids[DMX_PES_AUDIO],
1915 av7110->pids[DMX_PES_TELETEXT], 0,
1916 av7110->pids[DMX_PES_PCR]);
1917 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
1918 } else {
1919 SetPIDs(av7110, 0, 0, 0, 0, 0);
1920 av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
1921 av7110_wait_msgstate(av7110, GPMQBusy);
1922 }
1923
1924 up(&av7110->pid_mutex);
1925 }
1926
1927 static int av7110_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1928 {
1929 struct av7110* av7110 = fe->dvb->priv;
1930 av7110_fe_lock_fix(av7110, 0);
1931 return av7110->fe_set_frontend(fe, params);
1932 }
1933
1934 static int av7110_fe_init(struct dvb_frontend* fe)
1935 {
1936 struct av7110* av7110 = fe->dvb->priv;
1937
1938 av7110_fe_lock_fix(av7110, 0);
1939 return av7110->fe_init(fe);
1940 }
1941
1942 static int av7110_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
1943 {
1944 struct av7110* av7110 = fe->dvb->priv;
1945 int ret;
1946
1947 /* call the real implementation */
1948 ret = av7110->fe_read_status(fe, status);
1949 if (ret)
1950 return ret;
1951
1952 if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK)) {
1953 av7110_fe_lock_fix(av7110, *status);
1954 }
1955
1956 return 0;
1957 }
1958
1959 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
1960 {
1961 struct av7110* av7110 = fe->dvb->priv;
1962
1963 av7110_fe_lock_fix(av7110, 0);
1964 return av7110->fe_diseqc_reset_overload(fe);
1965 }
1966
1967 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
1968 struct dvb_diseqc_master_cmd* cmd)
1969 {
1970 struct av7110* av7110 = fe->dvb->priv;
1971
1972 av7110_fe_lock_fix(av7110, 0);
1973 return av7110->fe_diseqc_send_master_cmd(fe, cmd);
1974 }
1975
1976 static int av7110_fe_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t minicmd)
1977 {
1978 struct av7110* av7110 = fe->dvb->priv;
1979
1980 av7110_fe_lock_fix(av7110, 0);
1981 return av7110->fe_diseqc_send_burst(fe, minicmd);
1982 }
1983
1984 static int av7110_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
1985 {
1986 struct av7110* av7110 = fe->dvb->priv;
1987
1988 av7110_fe_lock_fix(av7110, 0);
1989 return av7110->fe_set_tone(fe, tone);
1990 }
1991
1992 static int av7110_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
1993 {
1994 struct av7110* av7110 = fe->dvb->priv;
1995
1996 av7110_fe_lock_fix(av7110, 0);
1997 return av7110->fe_set_voltage(fe, voltage);
1998 }
1999
2000 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned int cmd)
2001 {
2002 struct av7110* av7110 = fe->dvb->priv;
2003
2004 av7110_fe_lock_fix(av7110, 0);
2005 return av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
2006 }
2007
2008 static u8 read_pwm(struct av7110* av7110)
2009 {
2010 u8 b = 0xff;
2011 u8 pwm;
2012 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
2013 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
2014
2015 if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
2016 pwm = 0x48;
2017
2018 return pwm;
2019 }
2020
2021 static int frontend_init(struct av7110 *av7110)
2022 {
2023 int ret;
2024
2025 if (av7110->dev->pci->subsystem_vendor == 0x110a) {
2026 switch(av7110->dev->pci->subsystem_device) {
2027 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
2028 av7110->fe = ves1820_attach(&philips_cd1516_config,
2029 &av7110->i2c_adap, read_pwm(av7110));
2030 break;
2031 }
2032
2033 } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
2034 switch(av7110->dev->pci->subsystem_device) {
2035 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
2036 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
2037 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
2038
2039 // try the ALPS BSRV2 first of all
2040 av7110->fe = ves1x93_attach(&alps_bsrv2_config, &av7110->i2c_adap);
2041 if (av7110->fe) {
2042 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2043 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
2044 av7110->fe->ops->set_tone = av7110_set_tone;
2045 break;
2046 }
2047
2048 // try the ALPS BSRU6 now
2049 av7110->fe = stv0299_attach(&alps_bsru6_config, &av7110->i2c_adap);
2050 if (av7110->fe) {
2051 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2052 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
2053 av7110->fe->ops->set_tone = av7110_set_tone;
2054 break;
2055 }
2056
2057 // Try the grundig 29504-451
2058 av7110->fe = tda8083_attach(&grundig_29504_451_config, &av7110->i2c_adap);
2059 if (av7110->fe) {
2060 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2061 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
2062 av7110->fe->ops->set_tone = av7110_set_tone;
2063 break;
2064 }
2065
2066 /* Try DVB-C cards */
2067 switch(av7110->dev->pci->subsystem_device) {
2068 case 0x0000:
2069 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
2070 av7110->fe = ves1820_attach(&philips_cd1516_config, &av7110->i2c_adap,
2071 read_pwm(av7110));
2072 break;
2073 case 0x0003:
2074 /* Haupauge DVB-C 2.1 VES1820/ALPS TDBE2 */
2075 av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap,
2076 read_pwm(av7110));
2077 break;
2078 }
2079 break;
2080
2081 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
2082
2083 // ALPS TDLB7
2084 av7110->fe = sp8870_attach(&alps_tdlb7_config, &av7110->i2c_adap);
2085 break;
2086
2087 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
2088
2089 av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
2090 break;
2091
2092 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
2093 /* Grundig 29504-451 */
2094 av7110->fe = tda8083_attach(&grundig_29504_451_config, &av7110->i2c_adap);
2095 if (av7110->fe) {
2096 av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2097 av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
2098 av7110->fe->ops->set_tone = av7110_set_tone;
2099 }
2100 break;
2101
2102 case 0x0008: // Hauppauge/TT DVB-T
2103
2104 av7110->fe = l64781_attach(&grundig_29504_401_config, &av7110->i2c_adap);
2105 break;
2106
2107 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
2108
2109 av7110->fe = stv0297_attach(&nexusca_stv0297_config, &av7110->i2c_adap, 0x7b);
2110 if (av7110->fe) {
2111 /* set TDA9819 into DVB mode */
2112 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9198 pin9(STD)
2113 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9198 pin30(VIF)
2114
2115 /* tuner on this needs a slower i2c bus speed */
2116 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
2117 break;
2118 }
2119 }
2120 }
2121
2122 if (!av7110->fe) {
2123 /* FIXME: propagate the failure code from the lower layers */
2124 ret = -ENOMEM;
2125 printk("dvb-ttpci: A frontend driver was not found for device %04x/%04x subsystem %04x/%04x\n",
2126 av7110->dev->pci->vendor,
2127 av7110->dev->pci->device,
2128 av7110->dev->pci->subsystem_vendor,
2129 av7110->dev->pci->subsystem_device);
2130 } else {
2131 FE_FUNC_OVERRIDE(av7110->fe->ops->init, av7110->fe_init, av7110_fe_init);
2132 FE_FUNC_OVERRIDE(av7110->fe->ops->read_status, av7110->fe_read_status, av7110_fe_read_status);
2133 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
2134 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
2135 FE_FUNC_OVERRIDE(av7110->fe->ops->diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
2136 FE_FUNC_OVERRIDE(av7110->fe->ops->set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
2137 FE_FUNC_OVERRIDE(av7110->fe->ops->set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage;)
2138 FE_FUNC_OVERRIDE(av7110->fe->ops->dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
2139 FE_FUNC_OVERRIDE(av7110->fe->ops->set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
2140
2141 ret = dvb_register_frontend(av7110->dvb_adapter, av7110->fe);
2142 if (ret < 0) {
2143 printk("av7110: Frontend registration failed!\n");
2144 if (av7110->fe->ops->release)
2145 av7110->fe->ops->release(av7110->fe);
2146 av7110->fe = NULL;
2147 }
2148 }
2149 return ret;
2150 }
2151
2152 /* Budgetpatch note:
2153 * Original hardware design by Roberto Deza:
2154 * There is a DVB_Wiki at
2155 * http://212.227.36.83/linuxtv/wiki/index.php/Main_Page
2156 * where is described this 'DVB TT Budget Patch', on Card Modding:
2157 * http://212.227.36.83/linuxtv/wiki/index.php/DVB_TT_Budget_Patch
2158 * On the short description there is also a link to a external file,
2159 * with more details:
2160 * http://perso.wanadoo.es/jesussolano/Ttf_tsc1.zip
2161 *
2162 * New software triggering design by Emard that works on
2163 * original Roberto Deza's hardware:
2164 *
2165 * rps1 code for budgetpatch will copy internal HS event to GPIO3 pin.
2166 * GPIO3 is in budget-patch hardware connectd to port B VSYNC
2167 * HS is an internal event of 7146, accessible with RPS
2168 * and temporarily raised high every n lines
2169 * (n in defined in the RPS_THRESH1 counter threshold)
2170 * I think HS is raised high on the beginning of the n-th line
2171 * and remains high until this n-th line that triggered
2172 * it is completely received. When the receiption of n-th line
2173 * ends, HS is lowered.
2174 *
2175 * To transmit data over DMA, 7146 needs changing state at
2176 * port B VSYNC pin. Any changing of port B VSYNC will
2177 * cause some DMA data transfer, with more or less packets loss.
2178 * It depends on the phase and frequency of VSYNC and
2179 * the way of 7146 is instructed to trigger on port B (defined
2180 * in DD1_INIT register, 3rd nibble from the right valid
2181 * numbers are 0-7, see datasheet)
2182 *
2183 * The correct triggering can minimize packet loss,
2184 * dvbtraffic should give this stable bandwidths:
2185 * 22k transponder = 33814 kbit/s
2186 * 27.5k transponder = 38045 kbit/s
2187 * by experiment it is found that the best results
2188 * (stable bandwidths and almost no packet loss)
2189 * are obtained using DD1_INIT triggering number 2
2190 * (Va at rising edge of VS Fa = HS x VS-failing forced toggle)
2191 * and a VSYNC phase that occurs in the middle of DMA transfer
2192 * (about byte 188*512=96256 in the DMA window).
2193 *
2194 * Phase of HS is still not clear to me how to control,
2195 * It just happens to be so. It can be seen if one enables
2196 * RPS_IRQ and print Event Counter 1 in vpeirq(). Every
2197 * time RPS_INTERRUPT is called, the Event Counter 1 will
2198 * increment. That's how the 7146 is programmed to do event
2199 * counting in this budget-patch.c
2200 * I *think* HPS setting has something to do with the phase
2201 * of HS but I cant be 100% sure in that.
2202 *
2203 * hardware debug note: a working budget card (including budget patch)
2204 * with vpeirq() interrupt setup in mode "0x90" (every 64K) will
2205 * generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes
2206 * and that means 3*25=75 Hz of interrupt freqency, as seen by
2207 * watch cat /proc/interrupts
2208 *
2209 * If this frequency is 3x lower (and data received in the DMA
2210 * buffer don't start with 0x47, but in the middle of packets,
2211 * whose lengths appear to be like 188 292 188 104 etc.
2212 * this means VSYNC line is not connected in the hardware.
2213 * (check soldering pcb and pins)
2214 * The same behaviour of missing VSYNC can be duplicated on budget
2215 * cards, by seting DD1_INIT trigger mode 7 in 3rd nibble.
2216 */
2217 static int av7110_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_data *pci_ext)
2218 {
2219 const int length = TS_WIDTH * TS_HEIGHT;
2220 struct pci_dev *pdev = dev->pci;
2221 struct av7110 *av7110;
2222 int ret, count = 0;
2223
2224 dprintk(4, "dev: %p\n", dev);
2225
2226 /* Set RPS_IRQ to 1 to track rps1 activity.
2227 * Enabling this won't send any interrupt to PC CPU.
2228 */
2229 #define RPS_IRQ 0
2230
2231 if (budgetpatch == 1) {
2232 budgetpatch = 0;
2233 /* autodetect the presence of budget patch
2234 * this only works if saa7146 has been recently
2235 * reset with with MASK_31 to MC1
2236 *
2237 * will wait for VBI_B event (vertical blank at port B)
2238 * and will reset GPIO3 after VBI_B is detected.
2239 * (GPIO3 should be raised high by CPU to
2240 * test if GPIO3 will generate vertical blank signal
2241 * in budget patch GPIO3 is connected to VSYNC_B
2242 */
2243
2244 /* RESET SAA7146 */
2245 saa7146_write(dev, MC1, MASK_31);
2246 /* autodetection success seems to be time-dependend after reset */
2247
2248 /* Fix VSYNC level */
2249 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2250 /* set vsync_b triggering */
2251 saa7146_write(dev, DD1_STREAM_B, 0);
2252 /* port B VSYNC at rising edge */
2253 saa7146_write(dev, DD1_INIT, 0x00000200);
2254 saa7146_write(dev, BRS_CTRL, 0x00000000); // VBI
2255 saa7146_write(dev, MC2,
2256 1 * (MASK_08 | MASK_24) | // BRS control
2257 0 * (MASK_09 | MASK_25) | // a
2258 1 * (MASK_10 | MASK_26) | // b
2259 0 * (MASK_06 | MASK_22) | // HPS_CTRL1
2260 0 * (MASK_05 | MASK_21) | // HPS_CTRL2
2261 0 * (MASK_01 | MASK_15) // DEBI
2262 );
2263
2264 /* start writing RPS1 code from beginning */
2265 count = 0;
2266 /* Disable RPS1 */
2267 saa7146_write(dev, MC1, MASK_29);
2268 /* RPS1 timeout disable */
2269 saa7146_write(dev, RPS_TOV1, 0);
2270 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_VBI_B));
2271 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2272 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2273 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTLO<<24));
2274 #if RPS_IRQ
2275 /* issue RPS1 interrupt to increment counter */
2276 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2277 #endif
2278 WRITE_RPS1(cpu_to_le32(CMD_STOP));
2279 /* Jump to begin of RPS program as safety measure (p37) */
2280 WRITE_RPS1(cpu_to_le32(CMD_JUMP));
2281 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle));
2282
2283 #if RPS_IRQ
2284 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2285 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2286 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2287 */
2288 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2289 /* set event counter 1 treshold to maximum allowed value (rEC p55) */
2290 saa7146_write(dev, ECT1R, 0x3fff );
2291 #endif
2292 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2293 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2294 /* Enable RPS1, (rFC p33) */
2295 saa7146_write(dev, MC1, (MASK_13 | MASK_29 ));
2296
2297 mdelay(10);
2298 /* now send VSYNC_B to rps1 by rising GPIO3 */
2299 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI);
2300 mdelay(10);
2301 /* if rps1 responded by lowering the GPIO3,
2302 * then we have budgetpatch hardware
2303 */
2304 if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) {
2305 budgetpatch = 1;
2306 printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2307 }
2308 /* Disable RPS1 */
2309 saa7146_write(dev, MC1, ( MASK_29 ));
2310 #if RPS_IRQ
2311 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff );
2312 #endif
2313 }
2314
2315 /* prepare the av7110 device struct */
2316 av7110 = kmalloc(sizeof(struct av7110), GFP_KERNEL);
2317 if (!av7110) {
2318 dprintk(1, "out of memory\n");
2319 return -ENOMEM;
2320 }
2321
2322 memset(av7110, 0, sizeof(struct av7110));
2323
2324 av7110->card_name = (char*) pci_ext->ext_priv;
2325 av7110->dev = dev;
2326 dev->ext_priv = av7110;
2327
2328 ret = get_firmware(av7110);
2329 if (ret < 0)
2330 goto err_kfree_0;
2331
2332 ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name,
2333 THIS_MODULE);
2334 if (ret < 0)
2335 goto err_put_firmware_1;
2336
2337 /* the Siemens DVB needs this if you want to have the i2c chips
2338 get recognized before the main driver is fully loaded */
2339 saa7146_write(dev, GPIO_CTRL, 0x500000);
2340
2341 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
2342 av7110->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL;
2343 #else
2344 av7110->i2c_adap.class = I2C_CLASS_TV_DIGITAL;
2345 #endif
2346 strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
2347
2348 saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
2349
2350 ret = i2c_add_adapter(&av7110->i2c_adap);
2351 if (ret < 0)
2352 goto err_dvb_unregister_adapter_2;
2353
2354 ttpci_eeprom_parse_mac(&av7110->i2c_adap,
2355 av7110->dvb_adapter->proposed_mac);
2356 ret = -ENOMEM;
2357
2358 if (budgetpatch) {
2359 spin_lock_init(&av7110->feedlock1);
2360 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2361 &av7110->pt);
2362 if (!av7110->grabbing)
2363 goto err_i2c_del_3;
2364
2365 saa7146_write(dev, PCI_BT_V1, 0x1c1f101f);
2366 saa7146_write(dev, BCS_CTRL, 0x80400040);
2367 /* set dd1 stream a & b */
2368 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2369 saa7146_write(dev, DD1_INIT, 0x03000200);
2370 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2371 saa7146_write(dev, BRS_CTRL, 0x60000000);
2372 saa7146_write(dev, BASE_ODD3, 0);
2373 saa7146_write(dev, BASE_EVEN3, 0);
2374 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2375 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2376
2377 saa7146_write(dev, PITCH3, TS_WIDTH);
2378 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2379
2380 /* upload all */
2381 saa7146_write(dev, MC2, 0x077c077c);
2382 saa7146_write(dev, GPIO_CTRL, 0x000000);
2383 #if RPS_IRQ
2384 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2385 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2386 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2387 */
2388 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2389 /* set event counter 1 treshold to maximum allowed value (rEC p55) */
2390 saa7146_write(dev, ECT1R, 0x3fff );
2391 #endif
2392 /* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */
2393 count = 0;
2394
2395 /* Wait Source Line Counter Threshold (p36) */
2396 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_HS));
2397 /* Set GPIO3=1 (p42) */
2398 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2399 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2400 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTHI<<24));
2401 #if RPS_IRQ
2402 /* issue RPS1 interrupt */
2403 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2404 #endif
2405 /* Wait reset Source Line Counter Threshold (p36) */
2406 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | RPS_INV | EVT_HS));
2407 /* Set GPIO3=0 (p42) */
2408 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2)));
2409 WRITE_RPS1(cpu_to_le32(GPIO3_MSK));
2410 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTLO<<24));
2411 #if RPS_IRQ
2412 /* issue RPS1 interrupt */
2413 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT));
2414 #endif
2415 /* Jump to begin of RPS program (p37) */
2416 WRITE_RPS1(cpu_to_le32(CMD_JUMP));
2417 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle));
2418
2419 /* Fix VSYNC level */
2420 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2421 /* Set RPS1 Address register to point to RPS code (r108 p42) */
2422 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2423 /* Set Source Line Counter Threshold, using BRS (rCC p43)
2424 * It generates HS event every TS_HEIGHT lines
2425 * this is related to TS_WIDTH set in register
2426 * NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits
2427 * are set to TS_WIDTH bytes (TS_WIDTH=2*188),
2428 * then RPS_THRESH1 should be set to trigger
2429 * every TS_HEIGHT (512) lines.
2430 */
2431 saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 );
2432
2433 /* Enable RPS1 (rFC p33) */
2434 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
2435
2436 /* end of budgetpatch register initialization */
2437 tasklet_init (&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2438 } else {
2439 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
2440 saa7146_write(dev, BCS_CTRL, 0x80400040);
2441
2442 /* set dd1 stream a & b */
2443 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2444 saa7146_write(dev, DD1_INIT, 0x03000000);
2445 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2446
2447 /* upload all */
2448 saa7146_write(dev, MC2, 0x077c077c);
2449 saa7146_write(dev, GPIO_CTRL, 0x000000);
2450 }
2451
2452 tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2453 tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2454
2455 sema_init(&av7110->pid_mutex, 1);
2456
2457 /* locks for data transfers from/to AV7110 */
2458 spin_lock_init(&av7110->debilock);
2459 sema_init(&av7110->dcomlock, 1);
2460 av7110->debitype = -1;
2461
2462 /* default OSD window */
2463 av7110->osdwin = 1;
2464 sema_init(&av7110->osd_sema, 1);
2465
2466 /* ARM "watchdog" */
2467 init_waitqueue_head(&av7110->arm_wait);
2468 av7110->arm_thread = NULL;
2469
2470 /* allocate and init buffers */
2471 av7110->debi_virt = pci_alloc_consistent(pdev, 8192, &av7110->debi_bus);
2472 if (!av7110->debi_virt)
2473 goto err_saa71466_vfree_4;
2474
2475
2476 av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2477 if (!av7110->iobuf)
2478 goto err_pci_free_5;
2479
2480 ret = av7110_av_init(av7110);
2481 if (ret < 0)
2482 goto err_iobuf_vfree_6;
2483
2484 /* init BMP buffer */
2485 av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN;
2486 init_waitqueue_head(&av7110->bmpq);
2487
2488 ret = av7110_ca_init(av7110);
2489 if (ret < 0)
2490 goto err_av7110_av_exit_7;
2491
2492 /* load firmware into AV7110 cards */
2493 ret = av7110_bootarm(av7110);
2494 if (ret < 0)
2495 goto err_av7110_ca_exit_8;
2496
2497 ret = av7110_firmversion(av7110);
2498 if (ret < 0)
2499 goto err_stop_arm_9;
2500
2501 if (FW_VERSION(av7110->arm_app)<0x2501)
2502 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2503 "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2504
2505 ret = kernel_thread(arm_thread, (void *) av7110, 0);
2506 if (ret < 0)
2507 goto err_stop_arm_9;
2508
2509 /* set initial volume in mixer struct */
2510 av7110->mixer.volume_left = volume;
2511 av7110->mixer.volume_right = volume;
2512
2513 init_av7110_av(av7110);
2514
2515 ret = av7110_register(av7110);
2516 if (ret < 0)
2517 goto err_arm_thread_stop_10;
2518
2519 /* special case DVB-C: these cards have an analog tuner
2520 plus need some special handling, so we have separate
2521 saa7146_ext_vv data for these... */
2522 ret = av7110_init_v4l(av7110);
2523 if (ret < 0)
2524 goto err_av7110_unregister_11;
2525
2526 av7110->dvb_adapter->priv = av7110;
2527 ret = frontend_init(av7110);
2528 if (ret < 0)
2529 goto err_av7110_exit_v4l_12;
2530
2531 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2532 av7110_ir_init();
2533 #endif
2534 printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2535 av7110_num++;
2536 out:
2537 return ret;
2538
2539 err_av7110_exit_v4l_12:
2540 av7110_exit_v4l(av7110);
2541 err_av7110_unregister_11:
2542 dvb_unregister(av7110);
2543 err_arm_thread_stop_10:
2544 av7110_arm_sync(av7110);
2545 err_stop_arm_9:
2546 /* Nothing to do. Rejoice. */
2547 err_av7110_ca_exit_8:
2548 av7110_ca_exit(av7110);
2549 err_av7110_av_exit_7:
2550 av7110_av_exit(av7110);
2551 err_iobuf_vfree_6:
2552 vfree(av7110->iobuf);
2553 err_pci_free_5:
2554 pci_free_consistent(pdev, 8192, av7110->debi_virt, av7110->debi_bus);
2555 err_saa71466_vfree_4:
2556 if (!av7110->grabbing)
2557 saa7146_pgtable_free(pdev, &av7110->pt);
2558 err_i2c_del_3:
2559 i2c_del_adapter(&av7110->i2c_adap);
2560 err_dvb_unregister_adapter_2:
2561 dvb_unregister_adapter(av7110->dvb_adapter);
2562 err_put_firmware_1:
2563 put_firmware(av7110);
2564 err_kfree_0:
2565 kfree(av7110);
2566 goto out;
2567 }
2568
2569 static int av7110_detach(struct saa7146_dev* saa)
2570 {
2571 struct av7110 *av7110 = saa->ext_priv;
2572 dprintk(4, "%p\n", av7110);
2573
2574 if (budgetpatch) {
2575 /* Disable RPS1 */
2576 saa7146_write(saa, MC1, MASK_29);
2577 /* VSYNC LOW (inactive) */
2578 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
2579 saa7146_write(saa, MC1, MASK_20); /* DMA3 off */
2580 SAA7146_IER_DISABLE(saa, MASK_10);
2581 SAA7146_ISR_CLEAR(saa, MASK_10);
2582 msleep(50);
2583 tasklet_kill(&av7110->vpe_tasklet);
2584 saa7146_pgtable_free(saa->pci, &av7110->pt);
2585 }
2586 av7110_exit_v4l(av7110);
2587
2588 av7110_arm_sync(av7110);
2589
2590 tasklet_kill(&av7110->debi_tasklet);
2591 tasklet_kill(&av7110->gpio_tasklet);
2592
2593 dvb_unregister(av7110);
2594
2595 SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2596 SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2597
2598 av7110_ca_exit(av7110);
2599 av7110_av_exit(av7110);
2600
2601 vfree(av7110->iobuf);
2602 pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2603 av7110->debi_bus);
2604
2605 i2c_del_adapter(&av7110->i2c_adap);
2606
2607 dvb_unregister_adapter (av7110->dvb_adapter);
2608
2609 av7110_num--;
2610
2611 put_firmware(av7110);
2612
2613 kfree(av7110);
2614
2615 saa->ext_priv = NULL;
2616
2617 return 0;
2618 }
2619
2620
2621 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2622 {
2623 struct av7110 *av7110 = dev->ext_priv;
2624
2625 //print_time("av7110_irq");
2626
2627 /* Note: Don't try to handle the DEBI error irq (MASK_18), in
2628 * intel mode the timeout is asserted all the time...
2629 */
2630
2631 if (*isr & MASK_19) {
2632 //printk("av7110_irq: DEBI\n");
2633 /* Note 1: The DEBI irq is level triggered: We must enable it
2634 * only after we started a DMA xfer, and disable it here
2635 * immediately, or it will be signalled all the time while
2636 * DEBI is idle.
2637 * Note 2: You would think that an irq which is masked is
2638 * not signalled by the hardware. Not so for the SAA7146:
2639 * An irq is signalled as long as the corresponding bit
2640 * in the ISR is set, and disabling irqs just prevents the
2641 * hardware from setting the ISR bit. This means a) that we
2642 * must clear the ISR *after* disabling the irq (which is why
2643 * we must do it here even though saa7146_core did it already),
2644 * and b) that if we were to disable an edge triggered irq
2645 * (like the gpio irqs sadly are) temporarily we would likely
2646 * loose some. This sucks :-(
2647 */
2648 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
2649 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
2650 tasklet_schedule(&av7110->debi_tasklet);
2651 }
2652
2653 if (*isr & MASK_03) {
2654 //printk("av7110_irq: GPIO\n");
2655 tasklet_schedule(&av7110->gpio_tasklet);
2656 }
2657
2658 if ((*isr & MASK_10) && budgetpatch)
2659 tasklet_schedule(&av7110->vpe_tasklet);
2660 }
2661
2662
2663 static struct saa7146_extension av7110_extension;
2664
2665 #define MAKE_AV7110_INFO(x_var,x_name) \
2666 static struct saa7146_pci_extension_data x_var = { \
2667 .ext_priv = x_name, \
2668 .ext = &av7110_extension }
2669
2670 MAKE_AV7110_INFO(tts_1_X, "Technotrend/Hauppauge WinTV DVB-S rev1.X");
2671 MAKE_AV7110_INFO(ttt_1_X, "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2672 MAKE_AV7110_INFO(ttc_1_X, "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2673 MAKE_AV7110_INFO(ttc_2_X, "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2674 MAKE_AV7110_INFO(tts_2_X, "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2675 MAKE_AV7110_INFO(tts_1_3se, "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2676 MAKE_AV7110_INFO(ttt, "Technotrend/Hauppauge DVB-T");
2677 MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C");
2678 MAKE_AV7110_INFO(fss, "Fujitsu Siemens DVB-S rev1.6");
2679
2680 static struct pci_device_id pci_tbl[] = {
2681 MAKE_EXTENSION_PCI(tts_1_X, 0x13c2, 0x0000),
2682 MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001),
2683 MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002),
2684 MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003),
2685 MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002),
2686 MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000),
2687 MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a),
2688 MAKE_EXTENSION_PCI(fss, 0x13c2, 0x0006),
2689 MAKE_EXTENSION_PCI(ttt, 0x13c2, 0x0008),
2690
2691 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0004), UNDEFINED CARD */ // Galaxis DVB PC-Sat-Carte
2692 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2693 /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2694
2695 {
2696 .vendor = 0,
2697 }
2698 };
2699
2700 MODULE_DEVICE_TABLE(pci, pci_tbl);
2701
2702
2703 static struct saa7146_extension av7110_extension = {
2704 .name = "dvb\0",
2705 .flags = SAA7146_I2C_SHORT_DELAY,
2706
2707 .module = THIS_MODULE,
2708 .pci_tbl = &pci_tbl[0],
2709 .attach = av7110_attach,
2710 .detach = av7110_detach,
2711
2712 .irq_mask = MASK_19 | MASK_03 | MASK_10,
2713 .irq_func = av7110_irq,
2714 };
2715
2716
2717 static int __init av7110_init(void)
2718 {
2719 int retval;
2720 retval = saa7146_register_extension(&av7110_extension);
2721 return retval;
2722 }
2723
2724
2725 static void __exit av7110_exit(void)
2726 {
2727 #if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
2728 av7110_ir_exit();
2729 #endif
2730 saa7146_unregister_extension(&av7110_extension);
2731 }
2732
2733 module_init(av7110_init);
2734 module_exit(av7110_exit);
2735
2736 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2737 "Siemens, Technotrend, Hauppauge");
2738 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2739 MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror