1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33#include <linux/module.h>
34#include <linux/kmod.h>
35#include <linux/delay.h>
36#include <linux/fs.h>
37#include <linux/timer.h>
38#include <linux/poll.h>
39
40#include <linux/kernel.h>
41#include <linux/sched.h>
42#include <linux/types.h>
43#include <linux/fcntl.h>
44#include <linux/interrupt.h>
45#include <linux/string.h>
46#include <linux/pci.h>
47#include <linux/vmalloc.h>
48#include <linux/firmware.h>
49#include <linux/crc32.h>
50#include <linux/i2c.h>
51#include <linux/kthread.h>
52#include <linux/slab.h>
53#include <asm/unaligned.h>
54#include <asm/byteorder.h>
55
56
57#include <linux/dvb/frontend.h>
58
59#include "dvb_frontend.h"
60
61#include "ttpci-eeprom.h"
62#include "av7110.h"
63#include "av7110_hw.h"
64#include "av7110_av.h"
65#include "av7110_ca.h"
66#include "av7110_ipack.h"
67
68#include "bsbe1.h"
69#include "lnbp21.h"
70#include "bsru6.h"
71
72#define TS_WIDTH 376
73#define TS_HEIGHT 512
74#define TS_BUFLEN (TS_WIDTH*TS_HEIGHT)
75#define TS_MAX_PACKETS (TS_BUFLEN/TS_SIZE)
76
77
78int av7110_debug;
79
80static int vidmode = CVBS_RGB_OUT;
81static int pids_off;
82static int adac = DVB_ADAC_TI;
83static int hw_sections;
84static int rgb_on;
85static int volume = 255;
86static int budgetpatch;
87static int wss_cfg_4_3 = 0x4008;
88static int wss_cfg_16_9 = 0x0007;
89static int tv_standard;
90static int full_ts;
91
92module_param_named(debug, av7110_debug, int, 0644);
93MODULE_PARM_DESC(debug, "debug level (bitmask, default 0)");
94module_param(vidmode, int, 0444);
95MODULE_PARM_DESC(vidmode,"analog video out: 0 off, 1 CVBS+RGB (default), 2 CVBS+YC, 3 YC");
96module_param(pids_off, int, 0444);
97MODULE_PARM_DESC(pids_off,"clear video/audio/PCR PID filters when demux is closed");
98module_param(adac, int, 0444);
99MODULE_PARM_DESC(adac,"audio DAC type: 0 TI, 1 CRYSTAL, 2 MSP (use if autodetection fails)");
100module_param(hw_sections, int, 0444);
101MODULE_PARM_DESC(hw_sections, "0 use software section filter, 1 use hardware");
102module_param(rgb_on, int, 0444);
103MODULE_PARM_DESC(rgb_on, "For Siemens DVB-C cards only: Enable RGB control"
104 " signal on SCART pin 16 to switch SCART video mode from CVBS to RGB");
105module_param(volume, int, 0444);
106MODULE_PARM_DESC(volume, "initial volume: default 255 (range 0-255)");
107module_param(budgetpatch, int, 0444);
108MODULE_PARM_DESC(budgetpatch, "use budget-patch hardware modification: default 0 (0 no, 1 autodetect, 2 always)");
109module_param(full_ts, int, 0444);
110MODULE_PARM_DESC(full_ts, "enable code for full-ts hardware modification: 0 disable (default), 1 enable");
111module_param(wss_cfg_4_3, int, 0444);
112MODULE_PARM_DESC(wss_cfg_4_3, "WSS 4:3 - default 0x4008 - bit 15: disable, 14: burst mode, 13..0: wss data");
113module_param(wss_cfg_16_9, int, 0444);
114MODULE_PARM_DESC(wss_cfg_16_9, "WSS 16:9 - default 0x0007 - bit 15: disable, 14: burst mode, 13..0: wss data");
115module_param(tv_standard, int, 0444);
116MODULE_PARM_DESC(tv_standard, "TV standard: 0 PAL (default), 1 NTSC");
117
118DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
119
120static void restart_feeds(struct av7110 *av7110);
121static int budget_start_feed(struct dvb_demux_feed *feed);
122static int budget_stop_feed(struct dvb_demux_feed *feed);
123
124static int av7110_num;
125
126#define FE_FUNC_OVERRIDE(fe_func, av7110_copy, av7110_func) \
127{\
128 if (fe_func != NULL) { \
129 av7110_copy = fe_func; \
130 fe_func = av7110_func; \
131 } \
132}
133
134
135static void init_av7110_av(struct av7110 *av7110)
136{
137 int ret;
138 struct saa7146_dev *dev = av7110->dev;
139
140
141 av7110->adac_type = DVB_ADAC_TI;
142 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
143 if (ret < 0)
144 printk("dvb-ttpci:cannot set internal volume to maximum:%d\n",ret);
145
146 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetMonitorType,
147 1, (u16) av7110->display_ar);
148 if (ret < 0)
149 printk("dvb-ttpci: unable to set aspect ratio\n");
150 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetPanScanType,
151 1, av7110->display_panscan);
152 if (ret < 0)
153 printk("dvb-ttpci: unable to set pan scan\n");
154
155 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 2, wss_cfg_4_3);
156 if (ret < 0)
157 printk("dvb-ttpci: unable to configure 4:3 wss\n");
158 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetWSSConfig, 2, 3, wss_cfg_16_9);
159 if (ret < 0)
160 printk("dvb-ttpci: unable to configure 16:9 wss\n");
161
162 ret = av7710_set_video_mode(av7110, vidmode);
163 if (ret < 0)
164 printk("dvb-ttpci:cannot set video mode:%d\n",ret);
165
166
167
168 av7110->analog_tuner_flags = 0;
169 av7110->current_input = 0;
170 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000a)
171 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 0);
172 if (i2c_writereg(av7110, 0x20, 0x00, 0x00) == 1) {
173 printk ("dvb-ttpci: Crystal audio DAC @ card %d detected\n",
174 av7110->dvb_adapter.num);
175 av7110->adac_type = DVB_ADAC_CRYSTAL;
176 i2c_writereg(av7110, 0x20, 0x01, 0xd2);
177 i2c_writereg(av7110, 0x20, 0x02, 0x49);
178 i2c_writereg(av7110, 0x20, 0x03, 0x00);
179 i2c_writereg(av7110, 0x20, 0x04, 0x00);
180
181
182
183
184 } else if (0 == av7110_init_analog_module(av7110)) {
185
186 }
187 else if (dev->pci->subsystem_vendor == 0x110a) {
188 printk("dvb-ttpci: DVB-C w/o analog module @ card %d detected\n",
189 av7110->dvb_adapter.num);
190 av7110->adac_type = DVB_ADAC_NONE;
191 }
192 else {
193 av7110->adac_type = adac;
194 printk("dvb-ttpci: adac type set to %d @ card %d\n",
195 av7110->adac_type, av7110->dvb_adapter.num);
196 }
197
198 if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP34x0) {
199
200 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0);
201 if (ret < 0)
202 printk("dvb-ttpci:cannot switch on SCART(Main):%d\n",ret);
203 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1);
204 if (ret < 0)
205 printk("dvb-ttpci:cannot switch on SCART(AD):%d\n",ret);
206 if (rgb_on &&
207 ((av7110->dev->pci->subsystem_vendor == 0x110a) ||
208 (av7110->dev->pci->subsystem_vendor == 0x13c2)) &&
209 (av7110->dev->pci->subsystem_device == 0x0000)) {
210 saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI);
211
212 }
213 }
214
215 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000e)
216 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, SpdifSwitch, 1, 0);
217
218 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
219 if (ret < 0)
220 printk("dvb-ttpci:cannot set volume :%d\n",ret);
221}
222
223static void recover_arm(struct av7110 *av7110)
224{
225 dprintk(4, "%p\n",av7110);
226
227 av7110_bootarm(av7110);
228 msleep(100);
229
230 init_av7110_av(av7110);
231
232
233 if (av7110->recover)
234 av7110->recover(av7110);
235
236 restart_feeds(av7110);
237
238#if IS_ENABLED(CONFIG_DVB_AV7110_IR)
239 av7110_check_ir_config(av7110, true);
240#endif
241}
242
243static void av7110_arm_sync(struct av7110 *av7110)
244{
245 if (av7110->arm_thread)
246 kthread_stop(av7110->arm_thread);
247
248 av7110->arm_thread = NULL;
249}
250
251static int arm_thread(void *data)
252{
253 struct av7110 *av7110 = data;
254 u16 newloops = 0;
255 int timeout;
256
257 dprintk(4, "%p\n",av7110);
258
259 for (;;) {
260 timeout = wait_event_interruptible_timeout(av7110->arm_wait,
261 kthread_should_stop(), 5 * HZ);
262
263 if (-ERESTARTSYS == timeout || kthread_should_stop()) {
264
265 break;
266 }
267
268 if (!av7110->arm_ready)
269 continue;
270
271#if IS_ENABLED(CONFIG_DVB_AV7110_IR)
272 av7110_check_ir_config(av7110, false);
273#endif
274
275 if (mutex_lock_interruptible(&av7110->dcomlock))
276 break;
277 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
278 mutex_unlock(&av7110->dcomlock);
279
280 if (newloops == av7110->arm_loops || av7110->arm_errors > 3) {
281 printk(KERN_ERR "dvb-ttpci: ARM crashed @ card %d\n",
282 av7110->dvb_adapter.num);
283
284 recover_arm(av7110);
285
286 if (mutex_lock_interruptible(&av7110->dcomlock))
287 break;
288 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2) - 1;
289 mutex_unlock(&av7110->dcomlock);
290 }
291 av7110->arm_loops = newloops;
292 av7110->arm_errors = 0;
293 }
294
295 return 0;
296}
297
298
299
300
301
302
303static int DvbDmxFilterCallback(u8 *buffer1, size_t buffer1_len,
304 u8 *buffer2, size_t buffer2_len,
305 struct dvb_demux_filter *dvbdmxfilter,
306 enum dmx_success success,
307 struct av7110 *av7110)
308{
309 if (!dvbdmxfilter->feed->demux->dmx.frontend)
310 return 0;
311 if (dvbdmxfilter->feed->demux->dmx.frontend->source == DMX_MEMORY_FE)
312 return 0;
313
314 switch (dvbdmxfilter->type) {
315 case DMX_TYPE_SEC:
316 if ((((buffer1[1] << 8) | buffer1[2]) & 0xfff) + 3 != buffer1_len)
317 return 0;
318 if (dvbdmxfilter->doneq) {
319 struct dmx_section_filter *filter = &dvbdmxfilter->filter;
320 int i;
321 u8 xor, neq = 0;
322
323 for (i = 0; i < DVB_DEMUX_MASK_MAX; i++) {
324 xor = filter->filter_value[i] ^ buffer1[i];
325 neq |= dvbdmxfilter->maskandnotmode[i] & xor;
326 }
327 if (!neq)
328 return 0;
329 }
330 return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len,
331 buffer2, buffer2_len,
332 &dvbdmxfilter->filter,
333 DMX_OK);
334 case DMX_TYPE_TS:
335 if (!(dvbdmxfilter->feed->ts_type & TS_PACKET))
336 return 0;
337 if (dvbdmxfilter->feed->ts_type & TS_PAYLOAD_ONLY)
338 return dvbdmxfilter->feed->cb.ts(buffer1, buffer1_len,
339 buffer2, buffer2_len,
340 &dvbdmxfilter->feed->feed.ts,
341 DMX_OK);
342 else
343 av7110_p2t_write(buffer1, buffer1_len,
344 dvbdmxfilter->feed->pid,
345 &av7110->p2t_filter[dvbdmxfilter->index]);
346 default:
347 return 0;
348 }
349}
350
351
352
353static inline void print_time(char *s)
354{
355#ifdef DEBUG_TIMING
356 struct timeval tv;
357 do_gettimeofday(&tv);
358 printk("%s: %d.%d\n", s, (int)tv.tv_sec, (int)tv.tv_usec);
359#endif
360}
361
362#define DEBI_READ 0
363#define DEBI_WRITE 1
364static inline void start_debi_dma(struct av7110 *av7110, int dir,
365 unsigned long addr, unsigned int len)
366{
367 dprintk(8, "%c %08lx %u\n", dir == DEBI_READ ? 'R' : 'W', addr, len);
368 if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
369 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __func__);
370 return;
371 }
372
373 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
374 SAA7146_IER_ENABLE(av7110->dev, MASK_19);
375 if (len < 5)
376 len = 5;
377 if (dir == DEBI_WRITE)
378 iwdebi(av7110, DEBISWAB, addr, 0, (len + 3) & ~3);
379 else
380 irdebi(av7110, DEBISWAB, addr, 0, len);
381}
382
383static void debiirq(unsigned long cookie)
384{
385 struct av7110 *av7110 = (struct av7110 *)cookie;
386 int type = av7110->debitype;
387 int handle = (type >> 8) & 0x1f;
388 unsigned int xfer = 0;
389
390 print_time("debi");
391 dprintk(4, "type 0x%04x\n", type);
392
393 if (type == -1) {
394 printk("DEBI irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
395 jiffies, saa7146_read(av7110->dev, PSR),
396 saa7146_read(av7110->dev, SSR));
397 goto debi_done;
398 }
399 av7110->debitype = -1;
400
401 switch (type & 0xff) {
402
403 case DATA_TS_RECORD:
404 dvb_dmx_swfilter_packets(&av7110->demux,
405 (const u8 *) av7110->debi_virt,
406 av7110->debilen / 188);
407 xfer = RX_BUFF;
408 break;
409
410 case DATA_PES_RECORD:
411 if (av7110->demux.recording)
412 av7110_record_cb(&av7110->p2t[handle],
413 (u8 *) av7110->debi_virt,
414 av7110->debilen);
415 xfer = RX_BUFF;
416 break;
417
418 case DATA_IPMPE:
419 case DATA_FSECTION:
420 case DATA_PIPING:
421 if (av7110->handle2filter[handle])
422 DvbDmxFilterCallback((u8 *)av7110->debi_virt,
423 av7110->debilen, NULL, 0,
424 av7110->handle2filter[handle],
425 DMX_OK, av7110);
426 xfer = RX_BUFF;
427 break;
428
429 case DATA_CI_GET:
430 {
431 u8 *data = av7110->debi_virt;
432
433 if ((data[0] < 2) && data[2] == 0xff) {
434 int flags = 0;
435 if (data[5] > 0)
436 flags |= CA_CI_MODULE_PRESENT;
437 if (data[5] > 5)
438 flags |= CA_CI_MODULE_READY;
439 av7110->ci_slot[data[0]].flags = flags;
440 } else
441 ci_get_data(&av7110->ci_rbuffer,
442 av7110->debi_virt,
443 av7110->debilen);
444 xfer = RX_BUFF;
445 break;
446 }
447
448 case DATA_COMMON_INTERFACE:
449 CI_handle(av7110, (u8 *)av7110->debi_virt, av7110->debilen);
450#if 0
451 {
452 int i;
453
454 printk("av7110%d: ", av7110->num);
455 printk("%02x ", *(u8 *)av7110->debi_virt);
456 printk("%02x ", *(1+(u8 *)av7110->debi_virt));
457 for (i = 2; i < av7110->debilen; i++)
458 printk("%02x ", (*(i+(unsigned char *)av7110->debi_virt)));
459 for (i = 2; i < av7110->debilen; i++)
460 printk("%c", chtrans(*(i+(unsigned char *)av7110->debi_virt)));
461
462 printk("\n");
463 }
464#endif
465 xfer = RX_BUFF;
466 break;
467
468 case DATA_DEBUG_MESSAGE:
469 ((s8*)av7110->debi_virt)[Reserved_SIZE - 1] = 0;
470 printk("%s\n", (s8 *) av7110->debi_virt);
471 xfer = RX_BUFF;
472 break;
473
474 case DATA_CI_PUT:
475 dprintk(4, "debi DATA_CI_PUT\n");
476 case DATA_MPEG_PLAY:
477 dprintk(4, "debi DATA_MPEG_PLAY\n");
478 case DATA_BMP_LOAD:
479 dprintk(4, "debi DATA_BMP_LOAD\n");
480 xfer = TX_BUFF;
481 break;
482 default:
483 break;
484 }
485debi_done:
486 spin_lock(&av7110->debilock);
487 if (xfer)
488 iwdebi(av7110, DEBINOSWAP, xfer, 0, 2);
489 ARM_ClearMailBox(av7110);
490 spin_unlock(&av7110->debilock);
491}
492
493
494static void gpioirq(unsigned long cookie)
495{
496 struct av7110 *av7110 = (struct av7110 *)cookie;
497 u32 rxbuf, txbuf;
498 int len;
499
500 if (av7110->debitype != -1)
501
502 printk("dvb-ttpci: GPIO0 irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
503 jiffies, saa7146_read(av7110->dev, PSR),
504 saa7146_read(av7110->dev, SSR));
505
506 if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
507 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __func__);
508 BUG();
509 }
510
511 spin_lock(&av7110->debilock);
512 ARM_ClearIrq(av7110);
513
514
515 av7110->debitype = irdebi(av7110, DEBINOSWAP, IRQ_STATE, 0, 2);
516 av7110->debilen = irdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
517 rxbuf = irdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
518 txbuf = irdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
519 len = (av7110->debilen + 3) & ~3;
520
521 print_time("gpio");
522 dprintk(8, "GPIO0 irq 0x%04x %d\n", av7110->debitype, av7110->debilen);
523
524 switch (av7110->debitype & 0xff) {
525
526 case DATA_TS_PLAY:
527 case DATA_PES_PLAY:
528 break;
529
530 case DATA_MPEG_VIDEO_EVENT:
531 {
532 u32 h_ar;
533 struct video_event event;
534
535 av7110->video_size.w = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_WIDTH, 0, 2);
536 h_ar = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_HEIGHT_AR, 0, 2);
537
538 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
539 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
540
541 av7110->video_size.h = h_ar & 0xfff;
542
543 event.type = VIDEO_EVENT_SIZE_CHANGED;
544 event.u.size.w = av7110->video_size.w;
545 event.u.size.h = av7110->video_size.h;
546 switch ((h_ar >> 12) & 0xf)
547 {
548 case 3:
549 av7110->video_size.aspect_ratio = VIDEO_FORMAT_16_9;
550 event.u.size.aspect_ratio = VIDEO_FORMAT_16_9;
551 av7110->videostate.video_format = VIDEO_FORMAT_16_9;
552 break;
553 case 4:
554 av7110->video_size.aspect_ratio = VIDEO_FORMAT_221_1;
555 event.u.size.aspect_ratio = VIDEO_FORMAT_221_1;
556 av7110->videostate.video_format = VIDEO_FORMAT_221_1;
557 break;
558 default:
559 av7110->video_size.aspect_ratio = VIDEO_FORMAT_4_3;
560 event.u.size.aspect_ratio = VIDEO_FORMAT_4_3;
561 av7110->videostate.video_format = VIDEO_FORMAT_4_3;
562 }
563
564 dprintk(8, "GPIO0 irq: DATA_MPEG_VIDEO_EVENT: w/h/ar = %u/%u/%u\n",
565 av7110->video_size.w, av7110->video_size.h,
566 av7110->video_size.aspect_ratio);
567
568 dvb_video_add_event(av7110, &event);
569 break;
570 }
571
572 case DATA_CI_PUT:
573 {
574 int avail;
575 struct dvb_ringbuffer *cibuf = &av7110->ci_wbuffer;
576
577 avail = dvb_ringbuffer_avail(cibuf);
578 if (avail <= 2) {
579 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
580 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
581 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
582 break;
583 }
584 len = DVB_RINGBUFFER_PEEK(cibuf, 0) << 8;
585 len |= DVB_RINGBUFFER_PEEK(cibuf, 1);
586 if (avail < len + 2) {
587 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
588 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
589 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
590 break;
591 }
592 DVB_RINGBUFFER_SKIP(cibuf, 2);
593
594 dvb_ringbuffer_read(cibuf, av7110->debi_virt, len);
595
596 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
597 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
598 dprintk(8, "DMA: CI\n");
599 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
600 spin_unlock(&av7110->debilock);
601 wake_up(&cibuf->queue);
602 return;
603 }
604
605 case DATA_MPEG_PLAY:
606 if (!av7110->playing) {
607 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
608 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
609 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
610 break;
611 }
612 len = 0;
613 if (av7110->debitype & 0x100) {
614 spin_lock(&av7110->aout.lock);
615 len = av7110_pes_play(av7110->debi_virt, &av7110->aout, 2048);
616 spin_unlock(&av7110->aout.lock);
617 }
618 if (len <= 0 && (av7110->debitype & 0x200)
619 &&av7110->videostate.play_state != VIDEO_FREEZED) {
620 spin_lock(&av7110->avout.lock);
621 len = av7110_pes_play(av7110->debi_virt, &av7110->avout, 2048);
622 spin_unlock(&av7110->avout.lock);
623 }
624 if (len <= 0) {
625 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
626 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
627 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
628 break;
629 }
630 dprintk(8, "GPIO0 PES_PLAY len=%04x\n", len);
631 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
632 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
633 dprintk(8, "DMA: MPEG_PLAY\n");
634 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
635 spin_unlock(&av7110->debilock);
636 return;
637
638 case DATA_BMP_LOAD:
639 len = av7110->debilen;
640 dprintk(8, "gpio DATA_BMP_LOAD len %d\n", len);
641 if (!len) {
642 av7110->bmp_state = BMP_LOADED;
643 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
644 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
645 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
646 wake_up(&av7110->bmpq);
647 dprintk(8, "gpio DATA_BMP_LOAD done\n");
648 break;
649 }
650 if (len > av7110->bmplen)
651 len = av7110->bmplen;
652 if (len > 2 * 1024)
653 len = 2 * 1024;
654 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
655 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
656 memcpy(av7110->debi_virt, av7110->bmpbuf+av7110->bmpp, len);
657 av7110->bmpp += len;
658 av7110->bmplen -= len;
659 dprintk(8, "gpio DATA_BMP_LOAD DMA len %d\n", len);
660 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE+txbuf, len);
661 spin_unlock(&av7110->debilock);
662 return;
663
664 case DATA_CI_GET:
665 case DATA_COMMON_INTERFACE:
666 case DATA_FSECTION:
667 case DATA_IPMPE:
668 case DATA_PIPING:
669 if (!len || len > 4 * 1024) {
670 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
671 break;
672 }
673
674
675 case DATA_TS_RECORD:
676 case DATA_PES_RECORD:
677 dprintk(8, "DMA: TS_REC etc.\n");
678 start_debi_dma(av7110, DEBI_READ, DPRAM_BASE+rxbuf, len);
679 spin_unlock(&av7110->debilock);
680 return;
681
682 case DATA_DEBUG_MESSAGE:
683 if (!len || len > 0xff) {
684 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
685 break;
686 }
687 start_debi_dma(av7110, DEBI_READ, Reserved, len);
688 spin_unlock(&av7110->debilock);
689 return;
690
691 case DATA_IRCOMMAND:
692 if (av7110->ir.ir_handler)
693 av7110->ir.ir_handler(av7110,
694 swahw32(irdebi(av7110, DEBINOSWAP, Reserved, 0, 4)));
695 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
696 break;
697
698 default:
699 printk("dvb-ttpci: gpioirq unknown type=%d len=%d\n",
700 av7110->debitype, av7110->debilen);
701 break;
702 }
703 av7110->debitype = -1;
704 ARM_ClearMailBox(av7110);
705 spin_unlock(&av7110->debilock);
706}
707
708
709#ifdef CONFIG_DVB_AV7110_OSD
710static int dvb_osd_ioctl(struct file *file,
711 unsigned int cmd, void *parg)
712{
713 struct dvb_device *dvbdev = file->private_data;
714 struct av7110 *av7110 = dvbdev->priv;
715
716 dprintk(4, "%p\n", av7110);
717
718 if (cmd == OSD_SEND_CMD)
719 return av7110_osd_cmd(av7110, (osd_cmd_t *) parg);
720 if (cmd == OSD_GET_CAPABILITY)
721 return av7110_osd_capability(av7110, (osd_cap_t *) parg);
722
723 return -EINVAL;
724}
725
726
727static const struct file_operations dvb_osd_fops = {
728 .owner = THIS_MODULE,
729 .unlocked_ioctl = dvb_generic_ioctl,
730 .open = dvb_generic_open,
731 .release = dvb_generic_release,
732 .llseek = noop_llseek,
733};
734
735static 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
743
744
745static 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
768int 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
800
801
802static 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
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
855static 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
893static 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
936static 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:
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
977static 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_PES_PCR)) {
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
1045static 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_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_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
1084 }
1085 }
1086 }
1087 }
1088
1089 return ret;
1090}
1091
1092
1093static 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;
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;
1127
1128 if (mode)
1129 av7110_av_start_play(av7110, mode);
1130}
1131
1132static 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
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
1172
1173
1174
1175static 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
1191static 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
1199static 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
1208static 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);
1215 SAA7146_IER_DISABLE(budget->dev, MASK_10);
1216 SAA7146_ISR_CLEAR(budget->dev, MASK_10);
1217 return 0;
1218}
1219
1220static int start_ts_capture(struct av7110 *budget)
1221{
1222 unsigned y;
1223
1224 dprintk(2, "budget: %p\n", budget);
1225
1226 if (budget->feeding1)
1227 return ++budget->feeding1;
1228 for (y = 0; y < TS_HEIGHT; y++)
1229 memset(budget->grabbing + y * TS_WIDTH, 0x00, TS_WIDTH);
1230 budget->ttbp = 0;
1231 SAA7146_ISR_CLEAR(budget->dev, MASK_10);
1232 SAA7146_IER_ENABLE(budget->dev, MASK_10);
1233 saa7146_write(budget->dev, MC1, (MASK_04 | MASK_20));
1234 return ++budget->feeding1;
1235}
1236
1237static int budget_start_feed(struct dvb_demux_feed *feed)
1238{
1239 struct dvb_demux *demux = feed->demux;
1240 struct av7110 *budget = demux->priv;
1241 int status;
1242
1243 dprintk(2, "av7110: %p\n", budget);
1244
1245 spin_lock(&budget->feedlock1);
1246 feed->pusi_seen = 0;
1247 status = start_ts_capture(budget);
1248 spin_unlock(&budget->feedlock1);
1249 return status;
1250}
1251
1252static int budget_stop_feed(struct dvb_demux_feed *feed)
1253{
1254 struct dvb_demux *demux = feed->demux;
1255 struct av7110 *budget = demux->priv;
1256 int status;
1257
1258 dprintk(2, "budget: %p\n", budget);
1259
1260 spin_lock(&budget->feedlock1);
1261 status = stop_ts_capture(budget);
1262 spin_unlock(&budget->feedlock1);
1263 return status;
1264}
1265
1266static void vpeirq(unsigned long cookie)
1267{
1268 struct av7110 *budget = (struct av7110 *)cookie;
1269 u8 *mem = (u8 *) (budget->grabbing);
1270 u32 olddma = budget->ttbp;
1271 u32 newdma = saa7146_read(budget->dev, PCI_VDP3);
1272 struct dvb_demux *demux = budget->full_ts ? &budget->demux : &budget->demux1;
1273
1274
1275 newdma -= newdma % 188;
1276
1277 if (newdma >= TS_BUFLEN)
1278 return;
1279
1280 budget->ttbp = newdma;
1281
1282 if (!budget->feeding1 || (newdma == olddma))
1283 return;
1284
1285
1286 pci_dma_sync_sg_for_cpu(budget->dev->pci, budget->pt.slist, budget->pt.nents, PCI_DMA_FROMDEVICE);
1287
1288#if 0
1289
1290 printk("vpeirq: %02x Event Counter 1 0x%04x\n",
1291 mem[olddma],
1292 saa7146_read(budget->dev, EC1R) & 0x3fff);
1293#endif
1294
1295 if (newdma > olddma)
1296
1297 dvb_dmx_swfilter_packets(demux, mem + olddma, (newdma - olddma) / 188);
1298 else {
1299
1300 dvb_dmx_swfilter_packets(demux, mem + olddma, (TS_BUFLEN - olddma) / 188);
1301 dvb_dmx_swfilter_packets(demux, mem, newdma / 188);
1302 }
1303}
1304
1305static int av7110_register(struct av7110 *av7110)
1306{
1307 int ret, i;
1308 struct dvb_demux *dvbdemux = &av7110->demux;
1309 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1310
1311 dprintk(4, "%p\n", av7110);
1312
1313 if (av7110->registered)
1314 return -1;
1315
1316 av7110->registered = 1;
1317
1318 dvbdemux->priv = (void *) av7110;
1319
1320 for (i = 0; i < 32; i++)
1321 av7110->handle2filter[i] = NULL;
1322
1323 dvbdemux->filternum = (av7110->full_ts) ? 256 : 32;
1324 dvbdemux->feednum = (av7110->full_ts) ? 256 : 32;
1325 dvbdemux->start_feed = av7110_start_feed;
1326 dvbdemux->stop_feed = av7110_stop_feed;
1327 dvbdemux->write_to_decoder = av7110_write_to_decoder;
1328 dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1329 DMX_MEMORY_BASED_FILTERING);
1330
1331 dvb_dmx_init(&av7110->demux);
1332 av7110->demux.dmx.get_stc = dvb_get_stc;
1333
1334 av7110->dmxdev.filternum = (av7110->full_ts) ? 256 : 32;
1335 av7110->dmxdev.demux = &dvbdemux->dmx;
1336 av7110->dmxdev.capabilities = 0;
1337
1338 dvb_dmxdev_init(&av7110->dmxdev, &av7110->dvb_adapter);
1339
1340 av7110->hw_frontend.source = DMX_FRONTEND_0;
1341
1342 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1343
1344 if (ret < 0)
1345 return ret;
1346
1347 av7110->mem_frontend.source = DMX_MEMORY_FE;
1348
1349 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1350
1351 if (ret < 0)
1352 return ret;
1353
1354 ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1355 &av7110->hw_frontend);
1356 if (ret < 0)
1357 return ret;
1358
1359 av7110_av_register(av7110);
1360 av7110_ca_register(av7110);
1361
1362#ifdef CONFIG_DVB_AV7110_OSD
1363 dvb_register_device(&av7110->dvb_adapter, &av7110->osd_dev,
1364 &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1365#endif
1366
1367 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1368
1369 if (budgetpatch) {
1370
1371
1372
1373 dvbdemux1->priv = (void *) av7110;
1374
1375 dvbdemux1->filternum = 256;
1376 dvbdemux1->feednum = 256;
1377 dvbdemux1->start_feed = budget_start_feed;
1378 dvbdemux1->stop_feed = budget_stop_feed;
1379 dvbdemux1->write_to_decoder = NULL;
1380
1381 dvbdemux1->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1382 DMX_MEMORY_BASED_FILTERING);
1383
1384 dvb_dmx_init(&av7110->demux1);
1385
1386 av7110->dmxdev1.filternum = 256;
1387 av7110->dmxdev1.demux = &dvbdemux1->dmx;
1388 av7110->dmxdev1.capabilities = 0;
1389
1390 dvb_dmxdev_init(&av7110->dmxdev1, &av7110->dvb_adapter);
1391
1392 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net1, &dvbdemux1->dmx);
1393 printk("dvb-ttpci: additional demux1 for budget-patch registered\n");
1394 }
1395 return 0;
1396}
1397
1398
1399static void dvb_unregister(struct av7110 *av7110)
1400{
1401 struct dvb_demux *dvbdemux = &av7110->demux;
1402 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1403
1404 dprintk(4, "%p\n", av7110);
1405
1406 if (!av7110->registered)
1407 return;
1408
1409 if (budgetpatch) {
1410 dvb_net_release(&av7110->dvb_net1);
1411 dvbdemux->dmx.close(&dvbdemux1->dmx);
1412 dvb_dmxdev_release(&av7110->dmxdev1);
1413 dvb_dmx_release(&av7110->demux1);
1414 }
1415
1416 dvb_net_release(&av7110->dvb_net);
1417
1418 dvbdemux->dmx.close(&dvbdemux->dmx);
1419 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1420 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1421
1422 dvb_dmxdev_release(&av7110->dmxdev);
1423 dvb_dmx_release(&av7110->demux);
1424
1425 if (av7110->fe != NULL) {
1426 dvb_unregister_frontend(av7110->fe);
1427 dvb_frontend_detach(av7110->fe);
1428 }
1429 dvb_unregister_device(av7110->osd_dev);
1430 av7110_av_unregister(av7110);
1431 av7110_ca_unregister(av7110);
1432}
1433
1434
1435
1436
1437
1438
1439int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1440{
1441 u8 msg[2] = { reg, val };
1442 struct i2c_msg msgs;
1443
1444 msgs.flags = 0;
1445 msgs.addr = id / 2;
1446 msgs.len = 2;
1447 msgs.buf = msg;
1448 return i2c_transfer(&av7110->i2c_adap, &msgs, 1);
1449}
1450
1451u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1452{
1453 u8 mm1[] = {0x00};
1454 u8 mm2[] = {0x00};
1455 struct i2c_msg msgs[2];
1456
1457 msgs[0].flags = 0;
1458 msgs[1].flags = I2C_M_RD;
1459 msgs[0].addr = msgs[1].addr = id / 2;
1460 mm1[0] = reg;
1461 msgs[0].len = 1; msgs[1].len = 1;
1462 msgs[0].buf = mm1; msgs[1].buf = mm2;
1463 i2c_transfer(&av7110->i2c_adap, msgs, 2);
1464
1465 return mm2[0];
1466}
1467
1468
1469
1470
1471
1472
1473static int check_firmware(struct av7110* av7110)
1474{
1475 u32 crc = 0, len = 0;
1476 unsigned char *ptr;
1477
1478
1479 ptr = av7110->bin_fw;
1480 if (ptr[0] != 'A' || ptr[1] != 'V' ||
1481 ptr[2] != 'F' || ptr[3] != 'W') {
1482 printk("dvb-ttpci: this is not an av7110 firmware\n");
1483 return -EINVAL;
1484 }
1485 ptr += 4;
1486
1487
1488 crc = get_unaligned_be32(ptr);
1489 ptr += 4;
1490 len = get_unaligned_be32(ptr);
1491 ptr += 4;
1492 if (len >= 512) {
1493 printk("dvb-ttpci: dpram file is way too big.\n");
1494 return -EINVAL;
1495 }
1496 if (crc != crc32_le(0, ptr, len)) {
1497 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1498 return -EINVAL;
1499 }
1500 av7110->bin_dpram = ptr;
1501 av7110->size_dpram = len;
1502 ptr += len;
1503
1504
1505 crc = get_unaligned_be32(ptr);
1506 ptr += 4;
1507 len = get_unaligned_be32(ptr);
1508 ptr += 4;
1509
1510 if (len <= 200000 || len >= 300000 ||
1511 len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1512 printk("dvb-ttpci: root file has strange size (%d). aborting.\n", len);
1513 return -EINVAL;
1514 }
1515 if( crc != crc32_le(0, ptr, len)) {
1516 printk("dvb-ttpci: crc32 of root file does not match.\n");
1517 return -EINVAL;
1518 }
1519 av7110->bin_root = ptr;
1520 av7110->size_root = len;
1521 return 0;
1522}
1523
1524static void put_firmware(struct av7110* av7110)
1525{
1526 vfree(av7110->bin_fw);
1527}
1528
1529static int get_firmware(struct av7110* av7110)
1530{
1531 int ret;
1532 const struct firmware *fw;
1533
1534
1535 ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev);
1536 if (ret) {
1537 if (ret == -ENOENT) {
1538 printk(KERN_ERR "dvb-ttpci: could not load firmware,"
1539 " file not found: dvb-ttpci-01.fw\n");
1540 printk(KERN_ERR "dvb-ttpci: usually this should be in "
1541 "/usr/lib/hotplug/firmware or /lib/firmware\n");
1542 printk(KERN_ERR "dvb-ttpci: and can be downloaded from"
1543 " http://www.linuxtv.org/download/dvb/firmware/\n");
1544 } else
1545 printk(KERN_ERR "dvb-ttpci: cannot request firmware"
1546 " (error %i)\n", ret);
1547 return -EINVAL;
1548 }
1549
1550 if (fw->size <= 200000) {
1551 printk("dvb-ttpci: this firmware is way too small.\n");
1552 release_firmware(fw);
1553 return -EINVAL;
1554 }
1555
1556
1557 av7110->bin_fw = vmalloc(fw->size);
1558 if (NULL == av7110->bin_fw) {
1559 dprintk(1, "out of memory\n");
1560 release_firmware(fw);
1561 return -ENOMEM;
1562 }
1563
1564 memcpy(av7110->bin_fw, fw->data, fw->size);
1565 av7110->size_fw = fw->size;
1566 if ((ret = check_firmware(av7110)))
1567 vfree(av7110->bin_fw);
1568
1569 release_firmware(fw);
1570 return ret;
1571}
1572
1573static int alps_bsrv2_tuner_set_params(struct dvb_frontend *fe)
1574{
1575 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1576 struct av7110* av7110 = fe->dvb->priv;
1577 u8 pwr = 0;
1578 u8 buf[4];
1579 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) };
1580 u32 div = (p->frequency + 479500) / 125;
1581
1582 if (p->frequency > 2000000)
1583 pwr = 3;
1584 else if (p->frequency > 1800000)
1585 pwr = 2;
1586 else if (p->frequency > 1600000)
1587 pwr = 1;
1588 else if (p->frequency > 1200000)
1589 pwr = 0;
1590 else if (p->frequency >= 1100000)
1591 pwr = 1;
1592 else
1593 pwr = 2;
1594
1595 buf[0] = (div >> 8) & 0x7f;
1596 buf[1] = div & 0xff;
1597 buf[2] = ((div & 0x18000) >> 10) | 0x95;
1598 buf[3] = (pwr << 6) | 0x30;
1599
1600
1601
1602
1603 if (fe->ops.i2c_gate_ctrl)
1604 fe->ops.i2c_gate_ctrl(fe, 1);
1605 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1606 return -EIO;
1607 return 0;
1608}
1609
1610static struct ves1x93_config alps_bsrv2_config = {
1611 .demod_address = 0x08,
1612 .xin = 90100000UL,
1613 .invert_pwm = 0,
1614};
1615
1616static int alps_tdbe2_tuner_set_params(struct dvb_frontend *fe)
1617{
1618 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1619 struct av7110* av7110 = fe->dvb->priv;
1620 u32 div;
1621 u8 data[4];
1622 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1623
1624 div = (p->frequency + 35937500 + 31250) / 62500;
1625
1626 data[0] = (div >> 8) & 0x7f;
1627 data[1] = div & 0xff;
1628 data[2] = 0x85 | ((div >> 10) & 0x60);
1629 data[3] = (p->frequency < 174000000 ? 0x88 : p->frequency < 470000000 ? 0x84 : 0x81);
1630
1631 if (fe->ops.i2c_gate_ctrl)
1632 fe->ops.i2c_gate_ctrl(fe, 1);
1633 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1634 return -EIO;
1635 return 0;
1636}
1637
1638static struct ves1820_config alps_tdbe2_config = {
1639 .demod_address = 0x09,
1640 .xin = 57840000UL,
1641 .invert = 1,
1642 .selagc = VES1820_SELAGC_SIGNAMPERR,
1643};
1644
1645
1646
1647
1648static int grundig_29504_451_tuner_set_params(struct dvb_frontend *fe)
1649{
1650 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1651 struct av7110* av7110 = fe->dvb->priv;
1652 u32 div;
1653 u8 data[4];
1654 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1655
1656 div = p->frequency / 125;
1657 data[0] = (div >> 8) & 0x7f;
1658 data[1] = div & 0xff;
1659 data[2] = 0x8e;
1660 data[3] = 0x00;
1661
1662 if (fe->ops.i2c_gate_ctrl)
1663 fe->ops.i2c_gate_ctrl(fe, 1);
1664 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1665 return -EIO;
1666 return 0;
1667}
1668
1669static struct tda8083_config grundig_29504_451_config = {
1670 .demod_address = 0x68,
1671};
1672
1673
1674
1675static int philips_cd1516_tuner_set_params(struct dvb_frontend *fe)
1676{
1677 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1678 struct av7110* av7110 = fe->dvb->priv;
1679 u32 div;
1680 u32 f = p->frequency;
1681 u8 data[4];
1682 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1683
1684 div = (f + 36125000 + 31250) / 62500;
1685
1686 data[0] = (div >> 8) & 0x7f;
1687 data[1] = div & 0xff;
1688 data[2] = 0x8e;
1689 data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1690
1691 if (fe->ops.i2c_gate_ctrl)
1692 fe->ops.i2c_gate_ctrl(fe, 1);
1693 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1694 return -EIO;
1695 return 0;
1696}
1697
1698static struct ves1820_config philips_cd1516_config = {
1699 .demod_address = 0x09,
1700 .xin = 57840000UL,
1701 .invert = 1,
1702 .selagc = VES1820_SELAGC_SIGNAMPERR,
1703};
1704
1705
1706
1707static int alps_tdlb7_tuner_set_params(struct dvb_frontend *fe)
1708{
1709 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1710 struct av7110* av7110 = fe->dvb->priv;
1711 u32 div, pwr;
1712 u8 data[4];
1713 struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1714
1715 div = (p->frequency + 36200000) / 166666;
1716
1717 if (p->frequency <= 782000000)
1718 pwr = 1;
1719 else
1720 pwr = 2;
1721
1722 data[0] = (div >> 8) & 0x7f;
1723 data[1] = div & 0xff;
1724 data[2] = 0x85;
1725 data[3] = pwr << 6;
1726
1727 if (fe->ops.i2c_gate_ctrl)
1728 fe->ops.i2c_gate_ctrl(fe, 1);
1729 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1730 return -EIO;
1731 return 0;
1732}
1733
1734static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1735{
1736#if IS_ENABLED(CONFIG_DVB_SP8870)
1737 struct av7110* av7110 = fe->dvb->priv;
1738
1739 return request_firmware(fw, name, &av7110->dev->pci->dev);
1740#else
1741 return -EINVAL;
1742#endif
1743}
1744
1745static struct sp8870_config alps_tdlb7_config = {
1746
1747 .demod_address = 0x71,
1748 .request_firmware = alps_tdlb7_request_firmware,
1749};
1750
1751
1752static u8 nexusca_stv0297_inittab[] = {
1753 0x80, 0x01,
1754 0x80, 0x00,
1755 0x81, 0x01,
1756 0x81, 0x00,
1757 0x00, 0x09,
1758 0x01, 0x69,
1759 0x03, 0x00,
1760 0x04, 0x00,
1761 0x07, 0x00,
1762 0x08, 0x00,
1763 0x20, 0x00,
1764 0x21, 0x40,
1765 0x22, 0x00,
1766 0x23, 0x00,
1767 0x24, 0x40,
1768 0x25, 0x88,
1769 0x30, 0xff,
1770 0x31, 0x00,
1771 0x32, 0xff,
1772 0x33, 0x00,
1773 0x34, 0x50,
1774 0x35, 0x7f,
1775 0x36, 0x00,
1776 0x37, 0x20,
1777 0x38, 0x00,
1778 0x40, 0x1c,
1779 0x41, 0xff,
1780 0x42, 0x29,
1781 0x43, 0x00,
1782 0x44, 0xff,
1783 0x45, 0x00,
1784 0x46, 0x00,
1785 0x49, 0x04,
1786 0x4a, 0x00,
1787 0x4b, 0x7b,
1788 0x52, 0x30,
1789 0x55, 0xae,
1790 0x56, 0x47,
1791 0x57, 0xe1,
1792 0x58, 0x3a,
1793 0x5a, 0x1e,
1794 0x5b, 0x34,
1795 0x60, 0x00,
1796 0x63, 0x00,
1797 0x64, 0x00,
1798 0x65, 0x00,
1799 0x66, 0x00,
1800 0x67, 0x00,
1801 0x68, 0x00,
1802 0x69, 0x00,
1803 0x6a, 0x02,
1804 0x6b, 0x00,
1805 0x70, 0xff,
1806 0x71, 0x00,
1807 0x72, 0x00,
1808 0x73, 0x00,
1809 0x74, 0x0c,
1810 0x80, 0x00,
1811 0x81, 0x00,
1812 0x82, 0x00,
1813 0x83, 0x00,
1814 0x84, 0x04,
1815 0x85, 0x80,
1816 0x86, 0x24,
1817 0x87, 0x78,
1818 0x88, 0x10,
1819 0x89, 0x00,
1820 0x90, 0x01,
1821 0x91, 0x01,
1822 0xa0, 0x04,
1823 0xa1, 0x00,
1824 0xa2, 0x00,
1825 0xb0, 0x91,
1826 0xb1, 0x0b,
1827 0xc0, 0x53,
1828 0xc1, 0x70,
1829 0xc2, 0x12,
1830 0xd0, 0x00,
1831 0xd1, 0x00,
1832 0xd2, 0x00,
1833 0xd3, 0x00,
1834 0xd4, 0x00,
1835 0xd5, 0x00,
1836 0xde, 0x00,
1837 0xdf, 0x00,
1838 0x61, 0x49,
1839 0x62, 0x0b,
1840 0x53, 0x08,
1841 0x59, 0x08,
1842 0xff, 0xff,
1843};
1844
1845static int nexusca_stv0297_tuner_set_params(struct dvb_frontend *fe)
1846{
1847 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1848 struct av7110* av7110 = fe->dvb->priv;
1849 u32 div;
1850 u8 data[4];
1851 struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
1852 struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
1853 int i;
1854
1855 div = (p->frequency + 36150000 + 31250) / 62500;
1856
1857 data[0] = (div >> 8) & 0x7f;
1858 data[1] = div & 0xff;
1859 data[2] = 0xce;
1860
1861 if (p->frequency < 45000000)
1862 return -EINVAL;
1863 else if (p->frequency < 137000000)
1864 data[3] = 0x01;
1865 else if (p->frequency < 403000000)
1866 data[3] = 0x02;
1867 else if (p->frequency < 860000000)
1868 data[3] = 0x04;
1869 else
1870 return -EINVAL;
1871
1872 if (fe->ops.i2c_gate_ctrl)
1873 fe->ops.i2c_gate_ctrl(fe, 1);
1874 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) {
1875 printk("nexusca: pll transfer failed!\n");
1876 return -EIO;
1877 }
1878
1879
1880 for(i = 0; i < 20; i++) {
1881 if (fe->ops.i2c_gate_ctrl)
1882 fe->ops.i2c_gate_ctrl(fe, 1);
1883 if (i2c_transfer(&av7110->i2c_adap, &readmsg, 1) == 1)
1884 if (data[0] & 0x40) break;
1885 msleep(10);
1886 }
1887
1888 return 0;
1889}
1890
1891static struct stv0297_config nexusca_stv0297_config = {
1892
1893 .demod_address = 0x1C,
1894 .inittab = nexusca_stv0297_inittab,
1895 .invert = 1,
1896 .stop_during_read = 1,
1897};
1898
1899
1900
1901static int grundig_29504_401_tuner_set_params(struct dvb_frontend *fe)
1902{
1903 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
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 + p->frequency) / 166666;
1911
1912 cfg = 0x88;
1913
1914 if (p->frequency < 175000000)
1915 cpump = 2;
1916 else if (p->frequency < 390000000)
1917 cpump = 1;
1918 else if (p->frequency < 470000000)
1919 cpump = 2;
1920 else if (p->frequency < 750000000)
1921 cpump = 1;
1922 else
1923 cpump = 3;
1924
1925 if (p->frequency < 175000000)
1926 band_select = 0x0e;
1927 else if (p->frequency < 470000000)
1928 band_select = 0x05;
1929 else
1930 band_select = 0x03;
1931
1932 data[0] = (div >> 8) & 0x7f;
1933 data[1] = div & 0xff;
1934 data[2] = ((div >> 10) & 0x60) | cfg;
1935 data[3] = (cpump << 6) | band_select;
1936
1937 if (fe->ops.i2c_gate_ctrl)
1938 fe->ops.i2c_gate_ctrl(fe, 1);
1939 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) return -EIO;
1940 return 0;
1941}
1942
1943static struct l64781_config grundig_29504_401_config = {
1944 .demod_address = 0x55,
1945};
1946
1947
1948
1949static int av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
1950{
1951 int ret = 0;
1952 int synced = (status & FE_HAS_LOCK) ? 1 : 0;
1953
1954 av7110->fe_status = status;
1955
1956 if (av7110->fe_synced == synced)
1957 return 0;
1958
1959 if (av7110->playing) {
1960 av7110->fe_synced = synced;
1961 return 0;
1962 }
1963
1964 if (mutex_lock_interruptible(&av7110->pid_mutex))
1965 return -ERESTARTSYS;
1966
1967 if (synced) {
1968 ret = SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
1969 av7110->pids[DMX_PES_AUDIO],
1970 av7110->pids[DMX_PES_TELETEXT], 0,
1971 av7110->pids[DMX_PES_PCR]);
1972 if (!ret)
1973 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
1974 } else {
1975 ret = SetPIDs(av7110, 0, 0, 0, 0, 0);
1976 if (!ret) {
1977 ret = av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
1978 if (!ret)
1979 ret = av7110_wait_msgstate(av7110, GPMQBusy);
1980 }
1981 }
1982
1983 if (!ret)
1984 av7110->fe_synced = synced;
1985
1986 mutex_unlock(&av7110->pid_mutex);
1987 return ret;
1988}
1989
1990static int av7110_fe_set_frontend(struct dvb_frontend *fe)
1991{
1992 struct av7110* av7110 = fe->dvb->priv;
1993
1994 int ret = av7110_fe_lock_fix(av7110, 0);
1995 if (!ret)
1996 ret = av7110->fe_set_frontend(fe);
1997
1998 return ret;
1999}
2000
2001static int av7110_fe_init(struct dvb_frontend* fe)
2002{
2003 struct av7110* av7110 = fe->dvb->priv;
2004
2005 int ret = av7110_fe_lock_fix(av7110, 0);
2006 if (!ret)
2007 ret = av7110->fe_init(fe);
2008 return ret;
2009}
2010
2011static int av7110_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
2012{
2013 struct av7110* av7110 = fe->dvb->priv;
2014
2015
2016 int ret = av7110->fe_read_status(fe, status);
2017 if (!ret)
2018 if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK))
2019 ret = av7110_fe_lock_fix(av7110, *status);
2020 return ret;
2021}
2022
2023static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
2024{
2025 struct av7110* av7110 = fe->dvb->priv;
2026
2027 int ret = av7110_fe_lock_fix(av7110, 0);
2028 if (!ret)
2029 ret = av7110->fe_diseqc_reset_overload(fe);
2030 return ret;
2031}
2032
2033static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
2034 struct dvb_diseqc_master_cmd* cmd)
2035{
2036 struct av7110* av7110 = fe->dvb->priv;
2037
2038 int ret = av7110_fe_lock_fix(av7110, 0);
2039 if (!ret) {
2040 av7110->saved_master_cmd = *cmd;
2041 ret = av7110->fe_diseqc_send_master_cmd(fe, cmd);
2042 }
2043 return ret;
2044}
2045
2046static int av7110_fe_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t minicmd)
2047{
2048 struct av7110* av7110 = fe->dvb->priv;
2049
2050 int ret = av7110_fe_lock_fix(av7110, 0);
2051 if (!ret) {
2052 av7110->saved_minicmd = minicmd;
2053 ret = av7110->fe_diseqc_send_burst(fe, minicmd);
2054 }
2055 return ret;
2056}
2057
2058static int av7110_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
2059{
2060 struct av7110* av7110 = fe->dvb->priv;
2061
2062 int ret = av7110_fe_lock_fix(av7110, 0);
2063 if (!ret) {
2064 av7110->saved_tone = tone;
2065 ret = av7110->fe_set_tone(fe, tone);
2066 }
2067 return ret;
2068}
2069
2070static int av7110_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
2071{
2072 struct av7110* av7110 = fe->dvb->priv;
2073
2074 int ret = av7110_fe_lock_fix(av7110, 0);
2075 if (!ret) {
2076 av7110->saved_voltage = voltage;
2077 ret = av7110->fe_set_voltage(fe, voltage);
2078 }
2079 return ret;
2080}
2081
2082static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned long cmd)
2083{
2084 struct av7110* av7110 = fe->dvb->priv;
2085
2086 int ret = av7110_fe_lock_fix(av7110, 0);
2087 if (!ret)
2088 ret = av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
2089 return ret;
2090}
2091
2092static void dvb_s_recover(struct av7110* av7110)
2093{
2094 av7110_fe_init(av7110->fe);
2095
2096 av7110_fe_set_voltage(av7110->fe, av7110->saved_voltage);
2097 if (av7110->saved_master_cmd.msg_len) {
2098 msleep(20);
2099 av7110_fe_diseqc_send_master_cmd(av7110->fe, &av7110->saved_master_cmd);
2100 }
2101 msleep(20);
2102 av7110_fe_diseqc_send_burst(av7110->fe, av7110->saved_minicmd);
2103 msleep(20);
2104 av7110_fe_set_tone(av7110->fe, av7110->saved_tone);
2105
2106 av7110_fe_set_frontend(av7110->fe);
2107}
2108
2109static u8 read_pwm(struct av7110* av7110)
2110{
2111 u8 b = 0xff;
2112 u8 pwm;
2113 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
2114 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
2115
2116 if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
2117 pwm = 0x48;
2118
2119 return pwm;
2120}
2121
2122static int frontend_init(struct av7110 *av7110)
2123{
2124 int ret;
2125
2126 if (av7110->dev->pci->subsystem_vendor == 0x110a) {
2127 switch(av7110->dev->pci->subsystem_device) {
2128 case 0x0000:
2129 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config,
2130 &av7110->i2c_adap, read_pwm(av7110));
2131 if (av7110->fe) {
2132 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2133 }
2134 break;
2135 }
2136
2137 } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
2138 switch(av7110->dev->pci->subsystem_device) {
2139 case 0x0000:
2140 case 0x0003:
2141 case 0x1002:
2142
2143
2144 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2145 if (av7110->fe) {
2146 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2147 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2148 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2149 av7110->fe->ops.set_tone = av7110_set_tone;
2150 av7110->recover = dvb_s_recover;
2151 break;
2152 }
2153
2154
2155 av7110->fe = dvb_attach(stv0299_attach, &alps_bsru6_config, &av7110->i2c_adap);
2156 if (av7110->fe) {
2157 av7110->fe->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
2158 av7110->fe->tuner_priv = &av7110->i2c_adap;
2159
2160 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2161 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2162 av7110->fe->ops.set_tone = av7110_set_tone;
2163 av7110->recover = dvb_s_recover;
2164 break;
2165 }
2166
2167
2168 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2169 if (av7110->fe) {
2170 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2171 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2172 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2173 av7110->fe->ops.set_tone = av7110_set_tone;
2174 av7110->recover = dvb_s_recover;
2175 break;
2176 }
2177
2178
2179 switch(av7110->dev->pci->subsystem_device) {
2180 case 0x0000:
2181
2182 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config, &av7110->i2c_adap,
2183 read_pwm(av7110));
2184 if (av7110->fe) {
2185 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2186 }
2187 break;
2188 case 0x0003:
2189
2190 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap,
2191 read_pwm(av7110));
2192 if (av7110->fe) {
2193 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2194 }
2195 break;
2196 }
2197 break;
2198
2199 case 0x0001:
2200
2201 av7110->fe = dvb_attach(sp8870_attach, &alps_tdlb7_config, &av7110->i2c_adap);
2202 if (av7110->fe) {
2203 av7110->fe->ops.tuner_ops.set_params = alps_tdlb7_tuner_set_params;
2204 break;
2205 }
2206
2207
2208 case 0x0008:
2209
2210 av7110->fe = dvb_attach(l64781_attach, &grundig_29504_401_config, &av7110->i2c_adap);
2211 if (av7110->fe)
2212 av7110->fe->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params;
2213 break;
2214
2215 case 0x0002:
2216
2217 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
2218 if (av7110->fe) {
2219 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2220 }
2221 break;
2222
2223 case 0x0004:
2224
2225 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2226 if (av7110->fe) {
2227 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2228 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2229 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2230 av7110->fe->ops.set_tone = av7110_set_tone;
2231 av7110->recover = dvb_s_recover;
2232 }
2233 break;
2234
2235 case 0x0006:
2236
2237 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2238 if (av7110->fe) {
2239 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2240 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2241 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2242 av7110->fe->ops.set_tone = av7110_set_tone;
2243 av7110->recover = dvb_s_recover;
2244 }
2245 break;
2246
2247 case 0x000A:
2248
2249 av7110->fe = dvb_attach(stv0297_attach, &nexusca_stv0297_config, &av7110->i2c_adap);
2250 if (av7110->fe) {
2251 av7110->fe->ops.tuner_ops.set_params = nexusca_stv0297_tuner_set_params;
2252
2253
2254 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO);
2255 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO);
2256
2257
2258 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
2259 break;
2260 }
2261 break;
2262
2263 case 0x000E:
2264
2265 av7110->fe = dvb_attach(stv0299_attach, &alps_bsbe1_config, &av7110->i2c_adap);
2266 if (av7110->fe) {
2267 av7110->fe->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
2268 av7110->fe->tuner_priv = &av7110->i2c_adap;
2269
2270 if (dvb_attach(lnbp21_attach, av7110->fe, &av7110->i2c_adap, 0, 0) == NULL) {
2271 printk("dvb-ttpci: LNBP21 not found!\n");
2272 if (av7110->fe->ops.release)
2273 av7110->fe->ops.release(av7110->fe);
2274 av7110->fe = NULL;
2275 } else {
2276 av7110->fe->ops.dishnetwork_send_legacy_command = NULL;
2277 av7110->recover = dvb_s_recover;
2278 }
2279 }
2280 break;
2281 }
2282 }
2283
2284 if (!av7110->fe) {
2285
2286 ret = -ENOMEM;
2287 printk("dvb-ttpci: A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
2288 av7110->dev->pci->vendor,
2289 av7110->dev->pci->device,
2290 av7110->dev->pci->subsystem_vendor,
2291 av7110->dev->pci->subsystem_device);
2292 } else {
2293 FE_FUNC_OVERRIDE(av7110->fe->ops.init, av7110->fe_init, av7110_fe_init);
2294 FE_FUNC_OVERRIDE(av7110->fe->ops.read_status, av7110->fe_read_status, av7110_fe_read_status);
2295 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
2296 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
2297 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
2298 FE_FUNC_OVERRIDE(av7110->fe->ops.set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
2299 FE_FUNC_OVERRIDE(av7110->fe->ops.set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage);
2300 FE_FUNC_OVERRIDE(av7110->fe->ops.dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
2301 FE_FUNC_OVERRIDE(av7110->fe->ops.set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
2302
2303 ret = dvb_register_frontend(&av7110->dvb_adapter, av7110->fe);
2304 if (ret < 0) {
2305 printk("av7110: Frontend registration failed!\n");
2306 dvb_frontend_detach(av7110->fe);
2307 av7110->fe = NULL;
2308 }
2309 }
2310 return ret;
2311}
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373static int av7110_attach(struct saa7146_dev* dev,
2374 struct saa7146_pci_extension_data *pci_ext)
2375{
2376 const int length = TS_WIDTH * TS_HEIGHT;
2377 struct pci_dev *pdev = dev->pci;
2378 struct av7110 *av7110;
2379 struct task_struct *thread;
2380 int ret, count = 0;
2381
2382 dprintk(4, "dev: %p\n", dev);
2383
2384
2385
2386
2387#define RPS_IRQ 0
2388
2389 if (budgetpatch == 1) {
2390 budgetpatch = 0;
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403 saa7146_write(dev, MC1, MASK_31);
2404
2405
2406
2407 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2408
2409 saa7146_write(dev, DD1_STREAM_B, 0);
2410
2411 saa7146_write(dev, DD1_INIT, 0x00000200);
2412 saa7146_write(dev, BRS_CTRL, 0x00000000);
2413 saa7146_write(dev, MC2,
2414 1 * (MASK_08 | MASK_24) |
2415 0 * (MASK_09 | MASK_25) |
2416 1 * (MASK_10 | MASK_26) |
2417 0 * (MASK_06 | MASK_22) |
2418 0 * (MASK_05 | MASK_21) |
2419 0 * (MASK_01 | MASK_15)
2420 );
2421
2422
2423 count = 0;
2424
2425 saa7146_write(dev, MC1, MASK_29);
2426
2427 saa7146_write(dev, RPS_TOV1, 0);
2428 WRITE_RPS1(CMD_PAUSE | EVT_VBI_B);
2429 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2430 WRITE_RPS1(GPIO3_MSK);
2431 WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2432#if RPS_IRQ
2433
2434 WRITE_RPS1(CMD_INTERRUPT);
2435#endif
2436 WRITE_RPS1(CMD_STOP);
2437
2438 WRITE_RPS1(CMD_JUMP);
2439 WRITE_RPS1(dev->d_rps1.dma_handle);
2440
2441#if RPS_IRQ
2442
2443
2444
2445
2446 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2447
2448 saa7146_write(dev, ECT1R, 0x3fff );
2449#endif
2450
2451 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2452
2453 saa7146_write(dev, MC1, (MASK_13 | MASK_29 ));
2454
2455 mdelay(10);
2456
2457 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI);
2458 mdelay(10);
2459
2460
2461
2462 if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) {
2463 budgetpatch = 1;
2464 printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2465 }
2466
2467 saa7146_write(dev, MC1, ( MASK_29 ));
2468#if RPS_IRQ
2469 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff );
2470#endif
2471 }
2472
2473
2474 av7110 = kzalloc(sizeof(struct av7110), GFP_KERNEL);
2475 if (!av7110) {
2476 dprintk(1, "out of memory\n");
2477 return -ENOMEM;
2478 }
2479
2480 av7110->card_name = (char*) pci_ext->ext_priv;
2481 av7110->dev = dev;
2482 dev->ext_priv = av7110;
2483
2484 ret = get_firmware(av7110);
2485 if (ret < 0)
2486 goto err_kfree_0;
2487
2488 ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name,
2489 THIS_MODULE, &dev->pci->dev, adapter_nr);
2490 if (ret < 0)
2491 goto err_put_firmware_1;
2492
2493
2494
2495 saa7146_write(dev, GPIO_CTRL, 0x500000);
2496
2497 strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
2498
2499 saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120);
2500
2501 ret = i2c_add_adapter(&av7110->i2c_adap);
2502 if (ret < 0)
2503 goto err_dvb_unregister_adapter_2;
2504
2505 ttpci_eeprom_parse_mac(&av7110->i2c_adap,
2506 av7110->dvb_adapter.proposed_mac);
2507 ret = -ENOMEM;
2508
2509
2510 if (full_ts)
2511 av7110->full_ts = true;
2512
2513
2514 if (i2c_readreg(av7110, 0xaa, 0) == 0x4f && i2c_readreg(av7110, 0xaa, 1) == 0x45) {
2515 u8 flags = i2c_readreg(av7110, 0xaa, 2);
2516 if (flags != 0xff && (flags & 0x01))
2517 av7110->full_ts = true;
2518 }
2519
2520 if (av7110->full_ts) {
2521 printk(KERN_INFO "dvb-ttpci: full-ts mode enabled for saa7146 port B\n");
2522 spin_lock_init(&av7110->feedlock1);
2523 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2524 &av7110->pt);
2525 if (!av7110->grabbing)
2526 goto err_i2c_del_3;
2527
2528 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2529 saa7146_write(dev, MC2, (MASK_10 | MASK_26));
2530
2531 saa7146_write(dev, DD1_INIT, 0x00000600);
2532 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2533
2534 saa7146_write(dev, BRS_CTRL, 0x60000000);
2535 saa7146_write(dev, MC2, MASK_08 | MASK_24);
2536
2537
2538 saa7146_write(dev, PCI_BT_V1, 0x001c0000 | (saa7146_read(dev, PCI_BT_V1) & ~0x001f0000));
2539 saa7146_write(dev, BASE_ODD3, 0);
2540 saa7146_write(dev, BASE_EVEN3, 0);
2541 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2542 saa7146_write(dev, PITCH3, TS_WIDTH);
2543 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2544 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2545 saa7146_write(dev, MC2, MASK_04 | MASK_20);
2546
2547 tasklet_init(&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2548
2549 } else if (budgetpatch) {
2550 spin_lock_init(&av7110->feedlock1);
2551 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2552 &av7110->pt);
2553 if (!av7110->grabbing)
2554 goto err_i2c_del_3;
2555
2556 saa7146_write(dev, PCI_BT_V1, 0x1c1f101f);
2557 saa7146_write(dev, BCS_CTRL, 0x80400040);
2558
2559 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2560 saa7146_write(dev, DD1_INIT, 0x03000200);
2561 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2562 saa7146_write(dev, BRS_CTRL, 0x60000000);
2563 saa7146_write(dev, BASE_ODD3, 0);
2564 saa7146_write(dev, BASE_EVEN3, 0);
2565 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2566 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2567
2568 saa7146_write(dev, PITCH3, TS_WIDTH);
2569 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2570
2571
2572 saa7146_write(dev, MC2, 0x077c077c);
2573 saa7146_write(dev, GPIO_CTRL, 0x000000);
2574#if RPS_IRQ
2575
2576
2577
2578
2579 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2580
2581 saa7146_write(dev, ECT1R, 0x3fff );
2582#endif
2583
2584 count = 0;
2585
2586
2587 WRITE_RPS1(CMD_PAUSE | EVT_HS);
2588
2589 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2590 WRITE_RPS1(GPIO3_MSK);
2591 WRITE_RPS1(SAA7146_GPIO_OUTHI<<24);
2592#if RPS_IRQ
2593
2594 WRITE_RPS1(CMD_INTERRUPT);
2595#endif
2596
2597 WRITE_RPS1(CMD_PAUSE | RPS_INV | EVT_HS);
2598
2599 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2600 WRITE_RPS1(GPIO3_MSK);
2601 WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2602#if RPS_IRQ
2603
2604 WRITE_RPS1(CMD_INTERRUPT);
2605#endif
2606
2607 WRITE_RPS1(CMD_JUMP);
2608 WRITE_RPS1(dev->d_rps1.dma_handle);
2609
2610
2611 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2612
2613 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2614
2615
2616
2617
2618
2619
2620
2621
2622 saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 );
2623
2624
2625 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
2626
2627
2628 tasklet_init (&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2629 } else {
2630 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
2631 saa7146_write(dev, BCS_CTRL, 0x80400040);
2632
2633
2634 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2635 saa7146_write(dev, DD1_INIT, 0x03000000);
2636 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2637
2638
2639 saa7146_write(dev, MC2, 0x077c077c);
2640 saa7146_write(dev, GPIO_CTRL, 0x000000);
2641 }
2642
2643 tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2644 tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2645
2646 mutex_init(&av7110->pid_mutex);
2647
2648
2649 spin_lock_init(&av7110->debilock);
2650 mutex_init(&av7110->dcomlock);
2651 av7110->debitype = -1;
2652
2653
2654 av7110->osdwin = 1;
2655 mutex_init(&av7110->osd_mutex);
2656
2657
2658 av7110->vidmode = tv_standard == 1 ? AV7110_VIDEO_MODE_NTSC
2659 : AV7110_VIDEO_MODE_PAL;
2660
2661
2662 init_waitqueue_head(&av7110->arm_wait);
2663 av7110->arm_thread = NULL;
2664
2665
2666 av7110->debi_virt = pci_alloc_consistent(pdev, 8192, &av7110->debi_bus);
2667 if (!av7110->debi_virt)
2668 goto err_saa71466_vfree_4;
2669
2670
2671 av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2672 if (!av7110->iobuf)
2673 goto err_pci_free_5;
2674
2675 ret = av7110_av_init(av7110);
2676 if (ret < 0)
2677 goto err_iobuf_vfree_6;
2678
2679
2680 av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN;
2681 init_waitqueue_head(&av7110->bmpq);
2682
2683 ret = av7110_ca_init(av7110);
2684 if (ret < 0)
2685 goto err_av7110_av_exit_7;
2686
2687
2688 ret = av7110_bootarm(av7110);
2689 if (ret < 0)
2690 goto err_av7110_ca_exit_8;
2691
2692 ret = av7110_firmversion(av7110);
2693 if (ret < 0)
2694 goto err_stop_arm_9;
2695
2696 if (FW_VERSION(av7110->arm_app)<0x2501)
2697 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2698 "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2699
2700 thread = kthread_run(arm_thread, (void *) av7110, "arm_mon");
2701 if (IS_ERR(thread)) {
2702 ret = PTR_ERR(thread);
2703 goto err_stop_arm_9;
2704 }
2705 av7110->arm_thread = thread;
2706
2707
2708 av7110->mixer.volume_left = volume;
2709 av7110->mixer.volume_right = volume;
2710
2711 ret = av7110_register(av7110);
2712 if (ret < 0)
2713 goto err_arm_thread_stop_10;
2714
2715 init_av7110_av(av7110);
2716
2717
2718
2719
2720 ret = av7110_init_v4l(av7110);
2721 if (ret < 0)
2722 goto err_av7110_unregister_11;
2723
2724 av7110->dvb_adapter.priv = av7110;
2725 ret = frontend_init(av7110);
2726 if (ret < 0)
2727 goto err_av7110_exit_v4l_12;
2728
2729 mutex_init(&av7110->ioctl_mutex);
2730
2731#if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2732 av7110_ir_init(av7110);
2733#endif
2734 printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2735 av7110_num++;
2736out:
2737 return ret;
2738
2739err_av7110_exit_v4l_12:
2740 av7110_exit_v4l(av7110);
2741err_av7110_unregister_11:
2742 dvb_unregister(av7110);
2743err_arm_thread_stop_10:
2744 av7110_arm_sync(av7110);
2745err_stop_arm_9:
2746
2747err_av7110_ca_exit_8:
2748 av7110_ca_exit(av7110);
2749err_av7110_av_exit_7:
2750 av7110_av_exit(av7110);
2751err_iobuf_vfree_6:
2752 vfree(av7110->iobuf);
2753err_pci_free_5:
2754 pci_free_consistent(pdev, 8192, av7110->debi_virt, av7110->debi_bus);
2755err_saa71466_vfree_4:
2756 if (av7110->grabbing)
2757 saa7146_vfree_destroy_pgtable(pdev, av7110->grabbing, &av7110->pt);
2758err_i2c_del_3:
2759 i2c_del_adapter(&av7110->i2c_adap);
2760err_dvb_unregister_adapter_2:
2761 dvb_unregister_adapter(&av7110->dvb_adapter);
2762err_put_firmware_1:
2763 put_firmware(av7110);
2764err_kfree_0:
2765 kfree(av7110);
2766 goto out;
2767}
2768
2769static int av7110_detach(struct saa7146_dev* saa)
2770{
2771 struct av7110 *av7110 = saa->ext_priv;
2772 dprintk(4, "%p\n", av7110);
2773
2774#if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2775 av7110_ir_exit(av7110);
2776#endif
2777 if (budgetpatch || av7110->full_ts) {
2778 if (budgetpatch) {
2779
2780 saa7146_write(saa, MC1, MASK_29);
2781
2782 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
2783 }
2784 saa7146_write(saa, MC1, MASK_20);
2785 SAA7146_IER_DISABLE(saa, MASK_10);
2786 SAA7146_ISR_CLEAR(saa, MASK_10);
2787 msleep(50);
2788 tasklet_kill(&av7110->vpe_tasklet);
2789 saa7146_vfree_destroy_pgtable(saa->pci, av7110->grabbing, &av7110->pt);
2790 }
2791 av7110_exit_v4l(av7110);
2792
2793 av7110_arm_sync(av7110);
2794
2795 tasklet_kill(&av7110->debi_tasklet);
2796 tasklet_kill(&av7110->gpio_tasklet);
2797
2798 dvb_unregister(av7110);
2799
2800 SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2801 SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2802
2803 av7110_ca_exit(av7110);
2804 av7110_av_exit(av7110);
2805
2806 vfree(av7110->iobuf);
2807 pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2808 av7110->debi_bus);
2809
2810 i2c_del_adapter(&av7110->i2c_adap);
2811
2812 dvb_unregister_adapter (&av7110->dvb_adapter);
2813
2814 av7110_num--;
2815
2816 put_firmware(av7110);
2817
2818 kfree(av7110);
2819
2820 saa->ext_priv = NULL;
2821
2822 return 0;
2823}
2824
2825
2826static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2827{
2828 struct av7110 *av7110 = dev->ext_priv;
2829
2830
2831
2832
2833
2834
2835
2836 if (*isr & MASK_19) {
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
2854 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
2855 tasklet_schedule(&av7110->debi_tasklet);
2856 }
2857
2858 if (*isr & MASK_03) {
2859
2860 tasklet_schedule(&av7110->gpio_tasklet);
2861 }
2862
2863 if (*isr & MASK_10)
2864 tasklet_schedule(&av7110->vpe_tasklet);
2865}
2866
2867
2868static struct saa7146_extension av7110_extension_driver;
2869
2870#define MAKE_AV7110_INFO(x_var,x_name) \
2871static struct saa7146_pci_extension_data x_var = { \
2872 .ext_priv = x_name, \
2873 .ext = &av7110_extension_driver }
2874
2875MAKE_AV7110_INFO(tts_1_X_fsc,"Technotrend/Hauppauge WinTV DVB-S rev1.X or Fujitsu Siemens DVB-C");
2876MAKE_AV7110_INFO(ttt_1_X, "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2877MAKE_AV7110_INFO(ttc_1_X, "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2878MAKE_AV7110_INFO(ttc_2_X, "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2879MAKE_AV7110_INFO(tts_2_X, "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2880MAKE_AV7110_INFO(tts_2_3, "Technotrend/Hauppauge WinTV Nexus-S rev2.3");
2881MAKE_AV7110_INFO(tts_1_3se, "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2882MAKE_AV7110_INFO(ttt, "Technotrend/Hauppauge DVB-T");
2883MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C");
2884MAKE_AV7110_INFO(fss, "Fujitsu Siemens DVB-S rev1.6");
2885MAKE_AV7110_INFO(gxs_1_3, "Galaxis DVB-S rev1.3");
2886
2887static struct pci_device_id pci_tbl[] = {
2888 MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000),
2889 MAKE_EXTENSION_PCI(tts_1_X_fsc, 0x13c2, 0x0000),
2890 MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001),
2891 MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002),
2892 MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003),
2893 MAKE_EXTENSION_PCI(gxs_1_3, 0x13c2, 0x0004),
2894 MAKE_EXTENSION_PCI(fss, 0x13c2, 0x0006),
2895 MAKE_EXTENSION_PCI(ttt, 0x13c2, 0x0008),
2896 MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a),
2897 MAKE_EXTENSION_PCI(tts_2_3, 0x13c2, 0x000e),
2898 MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002),
2899
2900
2901
2902
2903 {
2904 .vendor = 0,
2905 }
2906};
2907
2908MODULE_DEVICE_TABLE(pci, pci_tbl);
2909
2910
2911static struct saa7146_extension av7110_extension_driver = {
2912 .name = "av7110",
2913 .flags = SAA7146_USE_I2C_IRQ,
2914
2915 .module = THIS_MODULE,
2916 .pci_tbl = &pci_tbl[0],
2917 .attach = av7110_attach,
2918 .detach = av7110_detach,
2919
2920 .irq_mask = MASK_19 | MASK_03 | MASK_10,
2921 .irq_func = av7110_irq,
2922};
2923
2924
2925static int __init av7110_init(void)
2926{
2927 int retval;
2928 retval = saa7146_register_extension(&av7110_extension_driver);
2929 return retval;
2930}
2931
2932
2933static void __exit av7110_exit(void)
2934{
2935 saa7146_unregister_extension(&av7110_extension_driver);
2936}
2937
2938module_init(av7110_init);
2939module_exit(av7110_exit);
2940
2941MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2942 "Siemens, Technotrend, Hauppauge");
2943MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2944MODULE_LICENSE("GPL");
2945
