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