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