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