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