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