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