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