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