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