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