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