projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (3413): Typos grab bag of the month
[linux-block.git] / drivers / media / dvb / ttpci / av7110.c
CommitLineData
1da177e4
LT		 1/*
2 * driver for the SAA7146 based AV110 cards (like the Fujitsu-Siemens DVB)
3 * av7110.c: initialization and demux stuff
4 *
5 * Copyright (C) 1999-2002 Ralph Metzler
6 * & Marcus Metzler for convergence integrated media GmbH
7 *
8 * originally based on code by:
9 * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version 2
14 * of the License, or (at your option) any later version.
15 *
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
27 *
28 *
29 * the project's page is at http://www.linuxtv.org/dvb/
30 */
31
32
33#include <linux/config.h>
34#include <linux/module.h>
35#include <linux/kmod.h>
36#include <linux/delay.h>
37#include <linux/fs.h>
38#include <linux/timer.h>
39#include <linux/poll.h>
40#include <linux/byteorder/swabb.h>
41#include <linux/smp_lock.h>
42
43#include <linux/kernel.h>
44#include <linux/moduleparam.h>
45#include <linux/sched.h>
46#include <linux/types.h>
47#include <linux/fcntl.h>
48#include <linux/interrupt.h>
49#include <linux/string.h>
50#include <linux/pci.h>
51#include <linux/vmalloc.h>
52#include <linux/firmware.h>
53#include <linux/crc32.h>
54#include <linux/i2c.h>
55
56#include <asm/system.h>
1da177e4
LT		 57
58#include <linux/dvb/frontend.h>
59
60#include "dvb_frontend.h"
61
62#include "ttpci-eeprom.h"
63#include "av7110.h"
64#include "av7110_hw.h"
65#include "av7110_av.h"
66#include "av7110_ca.h"
67#include "av7110_ipack.h"
68
db5d91eb
OE		 69#include "bsbe1.h"
70#include "lnbp21.h"
71
1da177e4
LT		 72#define TS_WIDTH 376
73#define TS_HEIGHT 512
74#define TS_BUFLEN (TS_WIDTH*TS_HEIGHT)
75#define TS_MAX_PACKETS (TS_BUFLEN/TS_SIZE)
76
77
78int av7110_debug;
79
80static int vidmode = CVBS_RGB_OUT;
81static int pids_off;
82static int adac = DVB_ADAC_TI;
83static int hw_sections;
84static int rgb_on;
85static int volume = 255;
a5ed425c 86static int budgetpatch;
1da177e4
LT		 87
88module_param_named(debug, av7110_debug, int, 0644);
89MODULE_PARM_DESC(debug, "debug level (bitmask, default 0)");
90module_param(vidmode, int, 0444);
91MODULE_PARM_DESC(vidmode,"analog video out: 0 off, 1 CVBS+RGB (default), 2 CVBS+YC, 3 YC");
92module_param(pids_off, int, 0444);
93MODULE_PARM_DESC(pids_off,"clear video/audio/PCR PID filters when demux is closed");
94module_param(adac, int, 0444);
95MODULE_PARM_DESC(adac,"audio DAC type: 0 TI, 1 CRYSTAL, 2 MSP (use if autodetection fails)");
96module_param(hw_sections, int, 0444);
97MODULE_PARM_DESC(hw_sections, "0 use software section filter, 1 use hardware");
98module_param(rgb_on, int, 0444);
99MODULE_PARM_DESC(rgb_on, "For Siemens DVB-C cards only: Enable RGB control"
100 " 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)");
105
106static void restart_feeds(struct av7110 *av7110);
107
a5ed425c 108static int av7110_num;
1da177e4
LT		 109
110#define FE_FUNC_OVERRIDE(fe_func, av7110_copy, av7110_func) \
111{\
112 if (fe_func != NULL) { \
113 av7110_copy = fe_func; \
114 fe_func = av7110_func; \
115 } \
116}
117
118
119static void init_av7110_av(struct av7110 *av7110)
120{
ce18a223 121 int ret;
1da177e4
LT		 122 struct saa7146_dev *dev = av7110->dev;
123
124 /* set internal volume control to maximum */
125 av7110->adac_type = DVB_ADAC_TI;
ce18a223 126 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
7a2fa90f 127 if (ret < 0)
ce18a223 128 printk("dvb-ttpci:cannot set internal volume to maximum:%d\n",ret);
1da177e4 129
ce18a223 130 ret = av7710_set_video_mode(av7110, vidmode);
7a2fa90f 131 if (ret < 0)
ce18a223 132 printk("dvb-ttpci:cannot set video mode:%d\n",ret);
1da177e4
LT		 133
134 /* handle different card types */
135 /* remaining inits according to card and frontend type */
136 av7110->analog_tuner_flags = 0;
137 av7110->current_input = 0;
1c13b95c
MS		 138 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000a) {
139 printk("dvb-ttpci: MSP3415 audio DAC @ card %d\n",
140 av7110->dvb_adapter.num);
141 av7110->adac_type = DVB_ADAC_MSP34x5;
142 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 0); // SPDIF on
143 }
144 else if (i2c_writereg(av7110, 0x20, 0x00, 0x00) == 1) {
1da177e4 145 printk ("dvb-ttpci: Crystal audio DAC @ card %d detected\n",
fdc53a6d 146 av7110->dvb_adapter.num);
1da177e4
LT		 147 av7110->adac_type = DVB_ADAC_CRYSTAL;
148 i2c_writereg(av7110, 0x20, 0x01, 0xd2);
149 i2c_writereg(av7110, 0x20, 0x02, 0x49);
150 i2c_writereg(av7110, 0x20, 0x03, 0x00);
151 i2c_writereg(av7110, 0x20, 0x04, 0x00);
152
153 /**
154 * some special handling for the Siemens DVB-C cards...
155 */
156 } else if (0 == av7110_init_analog_module(av7110)) {
157 /* done. */
158 }
159 else if (dev->pci->subsystem_vendor == 0x110a) {
160 printk("dvb-ttpci: DVB-C w/o analog module @ card %d detected\n",
fdc53a6d 161 av7110->dvb_adapter.num);
1da177e4
LT		 162 av7110->adac_type = DVB_ADAC_NONE;
163 }
164 else {
165 av7110->adac_type = adac;
166 printk("dvb-ttpci: adac type set to %d @ card %d\n",
1c13b95c 167 av7110->adac_type, av7110->dvb_adapter.num);
1da177e4
LT		 168 }
169
1c13b95c 170 if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP34x0) {
1da177e4 171 // switch DVB SCART on
ce18a223 172 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0);
7a2fa90f 173 if (ret < 0)
ce18a223
WR		 174 printk("dvb-ttpci:cannot switch on SCART(Main):%d\n",ret);
175 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1);
7a2fa90f 176 if (ret < 0)
ce18a223 177 printk("dvb-ttpci:cannot switch on SCART(AD):%d\n",ret);
1da177e4 178 if (rgb_on &&
6af4ee10
KH		 179 ((av7110->dev->pci->subsystem_vendor == 0x110a) ||
180 (av7110->dev->pci->subsystem_vendor == 0x13c2)) &&
181 (av7110->dev->pci->subsystem_device == 0x0000)) {
1da177e4
LT		 182 saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16
183 //saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // SCARTpin 8
184 }
185 }
186
60edb137
OE		 187 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000e)
188 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, SpdifSwitch, 1, 0); // SPDIF on
189
ce18a223 190 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
7a2fa90f 191 if (ret < 0)
ce18a223 192 printk("dvb-ttpci:cannot set volume :%d\n",ret);
1da177e4
LT		 193}
194
195static void recover_arm(struct av7110 *av7110)
196{
197 dprintk(4, "%p\n",av7110);
198
199 av7110_bootarm(av7110);
200 msleep(100);
1da177e4 201
66190a27 202 init_av7110_av(av7110);
1da177e4 203
66190a27
OE		 204 /* card-specific recovery */
205 if (av7110->recover)
206 av7110->recover(av7110);
207
208 restart_feeds(av7110);
209 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, av7110->ir_config);
1da177e4
LT		 210}
211
212static void av7110_arm_sync(struct av7110 *av7110)
213{
214 av7110->arm_rmmod = 1;
215 wake_up_interruptible(&av7110->arm_wait);
216
217 while (av7110->arm_thread)
218 msleep(1);
219}
220
221static int arm_thread(void *data)
222{
223 struct av7110 *av7110 = data;
224 u16 newloops = 0;
225 int timeout;
226
227 dprintk(4, "%p\n",av7110);
228
9101e622
MCC		 229 lock_kernel();
230 daemonize("arm_mon");
231 sigfillset(&current->blocked);
232 unlock_kernel();
1da177e4
LT		 233
234 av7110->arm_thread = current;
235
236 for (;;) {
237 timeout = wait_event_interruptible_timeout(av7110->arm_wait,
238 av7110->arm_rmmod, 5 * HZ);
239 if (-ERESTARTSYS == timeout || av7110->arm_rmmod) {
240 /* got signal or told to quit*/
241 break;
242 }
243
244 if (!av7110->arm_ready)
245 continue;
246
3593cab5 247 if (mutex_lock_interruptible(&av7110->dcomlock))
1da177e4 248 break;
1da177e4 249 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
3593cab5 250 mutex_unlock(&av7110->dcomlock);
1da177e4 251
66190a27 252 if (newloops == av7110->arm_loops || av7110->arm_errors > 3) {
1da177e4 253 printk(KERN_ERR "dvb-ttpci: ARM crashed @ card %d\n",
fdc53a6d 254 av7110->dvb_adapter.num);
1da177e4 255
66190a27 256 recover_arm(av7110);
1da177e4 257
3593cab5 258 if (mutex_lock_interruptible(&av7110->dcomlock))
1da177e4 259 break;
1da177e4 260 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2) - 1;
3593cab5 261 mutex_unlock(&av7110->dcomlock);
1da177e4
LT		 262 }
263 av7110->arm_loops = newloops;
66190a27 264 av7110->arm_errors = 0;
1da177e4
LT		 265 }
266
267 av7110->arm_thread = NULL;
268 return 0;
269}
270
271
1da177e4
LT		 272/****************************************************************************
273 * IRQ handling
274 ****************************************************************************/
275
276static int DvbDmxFilterCallback(u8 *buffer1, size_t buffer1_len,
277 u8 *buffer2, size_t buffer2_len,
278 struct dvb_demux_filter *dvbdmxfilter,
279 enum dmx_success success,
280 struct av7110 *av7110)
281{
282 if (!dvbdmxfilter->feed->demux->dmx.frontend)
283 return 0;
284 if (dvbdmxfilter->feed->demux->dmx.frontend->source == DMX_MEMORY_FE)
285 return 0;
286
287 switch (dvbdmxfilter->type) {
288 case DMX_TYPE_SEC:
289 if ((((buffer1[1] << 8) | buffer1[2]) & 0xfff) + 3 != buffer1_len)
290 return 0;
291 if (dvbdmxfilter->doneq) {
292 struct dmx_section_filter *filter = &dvbdmxfilter->filter;
293 int i;
294 u8 xor, neq = 0;
295
296 for (i = 0; i < DVB_DEMUX_MASK_MAX; i++) {
297 xor = filter->filter_value[i] ^ buffer1[i];
298 neq |= dvbdmxfilter->maskandnotmode[i] & xor;
299 }
300 if (!neq)
301 return 0;
302 }
303 return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len,
304 buffer2, buffer2_len,
305 &dvbdmxfilter->filter,
306 DMX_OK);
307 case DMX_TYPE_TS:
308 if (!(dvbdmxfilter->feed->ts_type & TS_PACKET))
309 return 0;
310 if (dvbdmxfilter->feed->ts_type & TS_PAYLOAD_ONLY)
311 return dvbdmxfilter->feed->cb.ts(buffer1, buffer1_len,
312 buffer2, buffer2_len,
313 &dvbdmxfilter->feed->feed.ts,
314 DMX_OK);
315 else
316 av7110_p2t_write(buffer1, buffer1_len,
317 dvbdmxfilter->feed->pid,
318 &av7110->p2t_filter[dvbdmxfilter->index]);
319 default:
320 return 0;
321 }
322}
323
324
325//#define DEBUG_TIMING
326static inline void print_time(char *s)
327{
328#ifdef DEBUG_TIMING
329 struct timeval tv;
330 do_gettimeofday(&tv);
331 printk("%s: %d.%d\n", s, (int)tv.tv_sec, (int)tv.tv_usec);
332#endif
333}
334
335#define DEBI_READ 0
336#define DEBI_WRITE 1
337static inline void start_debi_dma(struct av7110 *av7110, int dir,
338 unsigned long addr, unsigned int len)
339{
340 dprintk(8, "%c %08lx %u\n", dir == DEBI_READ ? 'R' : 'W', addr, len);
341 if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
342 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __FUNCTION__);
343 return;
344 }
345
346 SAA7146_ISR_CLEAR(av7110->dev, MASK_19); /* for good measure */
347 SAA7146_IER_ENABLE(av7110->dev, MASK_19);
348 if (len < 5)
349 len = 5; /* we want a real DEBI DMA */
350 if (dir == DEBI_WRITE)
351 iwdebi(av7110, DEBISWAB, addr, 0, (len + 3) & ~3);
352 else
353 irdebi(av7110, DEBISWAB, addr, 0, len);
354}
355
356static void debiirq(unsigned long data)
357{
358 struct av7110 *av7110 = (struct av7110 *) data;
359 int type = av7110->debitype;
360 int handle = (type >> 8) & 0x1f;
361 unsigned int xfer = 0;
362
363 print_time("debi");
364 dprintk(4, "type 0x%04x\n", type);
365
366 if (type == -1) {
367 printk("DEBI irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
368 jiffies, saa7146_read(av7110->dev, PSR),
369 saa7146_read(av7110->dev, SSR));
370 goto debi_done;
371 }
372 av7110->debitype = -1;
373
374 switch (type & 0xff) {
375
376 case DATA_TS_RECORD:
377 dvb_dmx_swfilter_packets(&av7110->demux,
378 (const u8 *) av7110->debi_virt,
379 av7110->debilen / 188);
380 xfer = RX_BUFF;
381 break;
382
383 case DATA_PES_RECORD:
384 if (av7110->demux.recording)
385 av7110_record_cb(&av7110->p2t[handle],
386 (u8 *) av7110->debi_virt,
387 av7110->debilen);
388 xfer = RX_BUFF;
389 break;
390
391 case DATA_IPMPE:
392 case DATA_FSECTION:
393 case DATA_PIPING:
394 if (av7110->handle2filter[handle])
395 DvbDmxFilterCallback((u8 *)av7110->debi_virt,
396 av7110->debilen, NULL, 0,
397 av7110->handle2filter[handle],
398 DMX_OK, av7110);
399 xfer = RX_BUFF;
400 break;
401
402 case DATA_CI_GET:
403 {
404 u8 *data = av7110->debi_virt;
405
406 if ((data[0] < 2) && data[2] == 0xff) {
407 int flags = 0;
408 if (data[5] > 0)
409 flags |= CA_CI_MODULE_PRESENT;
410 if (data[5] > 5)
411 flags |= CA_CI_MODULE_READY;
412 av7110->ci_slot[data[0]].flags = flags;
413 } else
414 ci_get_data(&av7110->ci_rbuffer,
415 av7110->debi_virt,
416 av7110->debilen);
417 xfer = RX_BUFF;
418 break;
419 }
420
421 case DATA_COMMON_INTERFACE:
422 CI_handle(av7110, (u8 *)av7110->debi_virt, av7110->debilen);
423#if 0
424 {
425 int i;
426
427 printk("av7110%d: ", av7110->num);
428 printk("%02x ", *(u8 *)av7110->debi_virt);
429 printk("%02x ", *(1+(u8 *)av7110->debi_virt));
430 for (i = 2; i < av7110->debilen; i++)
431 printk("%02x ", (*(i+(unsigned char *)av7110->debi_virt)));
432 for (i = 2; i < av7110->debilen; i++)
433 printk("%c", chtrans(*(i+(unsigned char *)av7110->debi_virt)));
434
435 printk("\n");
436 }
437#endif
438 xfer = RX_BUFF;
439 break;
440
441 case DATA_DEBUG_MESSAGE:
442 ((s8*)av7110->debi_virt)[Reserved_SIZE - 1] = 0;
443 printk("%s\n", (s8 *) av7110->debi_virt);
444 xfer = RX_BUFF;
445 break;
446
447 case DATA_CI_PUT:
448 dprintk(4, "debi DATA_CI_PUT\n");
449 case DATA_MPEG_PLAY:
450 dprintk(4, "debi DATA_MPEG_PLAY\n");
451 case DATA_BMP_LOAD:
452 dprintk(4, "debi DATA_BMP_LOAD\n");
453 xfer = TX_BUFF;
454 break;
455 default:
456 break;
457 }
458debi_done:
459 spin_lock(&av7110->debilock);
460 if (xfer)
461 iwdebi(av7110, DEBINOSWAP, xfer, 0, 2);
462 ARM_ClearMailBox(av7110);
463 spin_unlock(&av7110->debilock);
464}
465
466/* irq from av7110 firmware writing the mailbox register in the DPRAM */
467static void gpioirq(unsigned long data)
468{
469 struct av7110 *av7110 = (struct av7110 *) data;
470 u32 rxbuf, txbuf;
471 int len;
472
473 if (av7110->debitype != -1)
474 /* we shouldn't get any irq while a debi xfer is running */
475 printk("dvb-ttpci: GPIO0 irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
476 jiffies, saa7146_read(av7110->dev, PSR),
477 saa7146_read(av7110->dev, SSR));
478
479 if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
480 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __FUNCTION__);
481 BUG(); /* maybe we should try resetting the debi? */
482 }
483
484 spin_lock(&av7110->debilock);
485 ARM_ClearIrq(av7110);
486
487 /* see what the av7110 wants */
488 av7110->debitype = irdebi(av7110, DEBINOSWAP, IRQ_STATE, 0, 2);
489 av7110->debilen = irdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
490 rxbuf = irdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
491 txbuf = irdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
492 len = (av7110->debilen + 3) & ~3;
493
494 print_time("gpio");
495 dprintk(8, "GPIO0 irq 0x%04x %d\n", av7110->debitype, av7110->debilen);
496
497 switch (av7110->debitype & 0xff) {
498
499 case DATA_TS_PLAY:
500 case DATA_PES_PLAY:
501 break;
502
503 case DATA_MPEG_VIDEO_EVENT:
504 {
505 u32 h_ar;
506 struct video_event event;
507
508 av7110->video_size.w = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_WIDTH, 0, 2);
509 h_ar = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_HEIGHT_AR, 0, 2);
510
511 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
512 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
513
514 av7110->video_size.h = h_ar & 0xfff;
1da177e4
LT		 515
516 event.type = VIDEO_EVENT_SIZE_CHANGED;
517 event.u.size.w = av7110->video_size.w;
518 event.u.size.h = av7110->video_size.h;
519 switch ((h_ar >> 12) & 0xf)
520 {
521 case 3:
522 av7110->video_size.aspect_ratio = VIDEO_FORMAT_16_9;
523 event.u.size.aspect_ratio = VIDEO_FORMAT_16_9;
524 av7110->videostate.video_format = VIDEO_FORMAT_16_9;
525 break;
526 case 4:
527 av7110->video_size.aspect_ratio = VIDEO_FORMAT_221_1;
528 event.u.size.aspect_ratio = VIDEO_FORMAT_221_1;
529 av7110->videostate.video_format = VIDEO_FORMAT_221_1;
530 break;
531 default:
532 av7110->video_size.aspect_ratio = VIDEO_FORMAT_4_3;
533 event.u.size.aspect_ratio = VIDEO_FORMAT_4_3;
534 av7110->videostate.video_format = VIDEO_FORMAT_4_3;
535 }
66190a27
OE		 536
537 dprintk(8, "GPIO0 irq: DATA_MPEG_VIDEO_EVENT: w/h/ar = %u/%u/%u\n",
538 av7110->video_size.w, av7110->video_size.h,
539 av7110->video_size.aspect_ratio);
540
1da177e4
LT		 541 dvb_video_add_event(av7110, &event);
542 break;
543 }
544
545 case DATA_CI_PUT:
546 {
547 int avail;
548 struct dvb_ringbuffer *cibuf = &av7110->ci_wbuffer;
549
550 avail = dvb_ringbuffer_avail(cibuf);
551 if (avail <= 2) {
552 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
553 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
554 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
555 break;
556 }
557 len = DVB_RINGBUFFER_PEEK(cibuf, 0) << 8;
558 len |= DVB_RINGBUFFER_PEEK(cibuf, 1);
559 if (avail < len + 2) {
560 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
561 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
562 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
563 break;
564 }
565 DVB_RINGBUFFER_SKIP(cibuf, 2);
566
567 dvb_ringbuffer_read(cibuf, av7110->debi_virt, len, 0);
568
569 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
570 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
571 dprintk(8, "DMA: CI\n");
572 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
573 spin_unlock(&av7110->debilock);
574 wake_up(&cibuf->queue);
575 return;
576 }
577
578 case DATA_MPEG_PLAY:
579 if (!av7110->playing) {
580 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
581 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
582 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
583 break;
584 }
585 len = 0;
586 if (av7110->debitype & 0x100) {
587 spin_lock(&av7110->aout.lock);
588 len = av7110_pes_play(av7110->debi_virt, &av7110->aout, 2048);
589 spin_unlock(&av7110->aout.lock);
590 }
591 if (len <= 0 && (av7110->debitype & 0x200)
592 &&av7110->videostate.play_state != VIDEO_FREEZED) {
593 spin_lock(&av7110->avout.lock);
594 len = av7110_pes_play(av7110->debi_virt, &av7110->avout, 2048);
595 spin_unlock(&av7110->avout.lock);
596 }
597 if (len <= 0) {
598 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
599 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
600 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
601 break;
602 }
603 dprintk(8, "GPIO0 PES_PLAY len=%04x\n", len);
604 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
605 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
606 dprintk(8, "DMA: MPEG_PLAY\n");
607 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
608 spin_unlock(&av7110->debilock);
609 return;
610
611 case DATA_BMP_LOAD:
612 len = av7110->debilen;
613 dprintk(8, "gpio DATA_BMP_LOAD len %d\n", len);
614 if (!len) {
615 av7110->bmp_state = BMP_LOADED;
616 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2);
617 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2);
618 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2);
619 wake_up(&av7110->bmpq);
620 dprintk(8, "gpio DATA_BMP_LOAD done\n");
621 break;
622 }
623 if (len > av7110->bmplen)
624 len = av7110->bmplen;
625 if (len > 2 * 1024)
626 len = 2 * 1024;
627 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2);
628 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2);
629 memcpy(av7110->debi_virt, av7110->bmpbuf+av7110->bmpp, len);
630 av7110->bmpp += len;
631 av7110->bmplen -= len;
632 dprintk(8, "gpio DATA_BMP_LOAD DMA len %d\n", len);
633 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE+txbuf, len);
634 spin_unlock(&av7110->debilock);
635 return;
636
637 case DATA_CI_GET:
638 case DATA_COMMON_INTERFACE:
639 case DATA_FSECTION:
640 case DATA_IPMPE:
641 case DATA_PIPING:
642 if (!len || len > 4 * 1024) {
643 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
644 break;
645 }
646 /* fall through */
647
648 case DATA_TS_RECORD:
649 case DATA_PES_RECORD:
650 dprintk(8, "DMA: TS_REC etc.\n");
651 start_debi_dma(av7110, DEBI_READ, DPRAM_BASE+rxbuf, len);
652 spin_unlock(&av7110->debilock);
653 return;
654
655 case DATA_DEBUG_MESSAGE:
656 if (!len || len > 0xff) {
657 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
658 break;
659 }
660 start_debi_dma(av7110, DEBI_READ, Reserved, len);
661 spin_unlock(&av7110->debilock);
662 return;
663
664 case DATA_IRCOMMAND:
03388ae3
OE		 665 if (av7110->ir_handler)
666 av7110->ir_handler(av7110,
667 swahw32(irdebi(av7110, DEBINOSWAP, Reserved, 0, 4)));
1da177e4
LT		 668 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
669 break;
670
671 default:
672 printk("dvb-ttpci: gpioirq unknown type=%d len=%d\n",
673 av7110->debitype, av7110->debilen);
674 break;
675 }
676 av7110->debitype = -1;
677 ARM_ClearMailBox(av7110);
678 spin_unlock(&av7110->debilock);
679}
680
681
682#ifdef CONFIG_DVB_AV7110_OSD
683static int dvb_osd_ioctl(struct inode *inode, struct file *file,
684 unsigned int cmd, void *parg)
685{
686 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
687 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
688
689 dprintk(4, "%p\n", av7110);
690
691 if (cmd == OSD_SEND_CMD)
692 return av7110_osd_cmd(av7110, (osd_cmd_t *) parg);
693 if (cmd == OSD_GET_CAPABILITY)
694 return av7110_osd_capability(av7110, (osd_cap_t *) parg);
695
696 return -EINVAL;
697}
698
699
700static struct file_operations dvb_osd_fops = {
701 .owner = THIS_MODULE,
702 .ioctl = dvb_generic_ioctl,
703 .open = dvb_generic_open,
704 .release = dvb_generic_release,
705};
706
707static struct dvb_device dvbdev_osd = {
708 .priv = NULL,
709 .users = 1,
710 .writers = 1,
711 .fops = &dvb_osd_fops,
712 .kernel_ioctl = dvb_osd_ioctl,
713};
714#endif /* CONFIG_DVB_AV7110_OSD */
715
716
717static inline int SetPIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
718 u16 subpid, u16 pcrpid)
719{
47f36920
DWF		 720 u16 aflags = 0;
721
1da177e4
LT		 722 dprintk(4, "%p\n", av7110);
723
724 if (vpid == 0x1fff || apid == 0x1fff ||
725 ttpid == 0x1fff || subpid == 0x1fff || pcrpid == 0x1fff) {
726 vpid = apid = ttpid = subpid = pcrpid = 0;
727 av7110->pids[DMX_PES_VIDEO] = 0;
728 av7110->pids[DMX_PES_AUDIO] = 0;
729 av7110->pids[DMX_PES_TELETEXT] = 0;
730 av7110->pids[DMX_PES_PCR] = 0;
731 }
732
47f36920
DWF		 733 if (av7110->audiostate.bypass_mode)
734 aflags |= 0x8000;
735
736 return av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, MultiPID, 6,
737 pcrpid, vpid, apid, ttpid, subpid, aflags);
1da177e4
LT		 738}
739
ce18a223 740int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
1da177e4
LT		 741 u16 subpid, u16 pcrpid)
742{
ce18a223 743 int ret = 0;
1da177e4
LT		 744 dprintk(4, "%p\n", av7110);
745
3593cab5 746 if (mutex_lock_interruptible(&av7110->pid_mutex))
ce18a223 747 return -ERESTARTSYS;
1da177e4
LT		 748
749 if (!(vpid & 0x8000))
750 av7110->pids[DMX_PES_VIDEO] = vpid;
751 if (!(apid & 0x8000))
752 av7110->pids[DMX_PES_AUDIO] = apid;
753 if (!(ttpid & 0x8000))
754 av7110->pids[DMX_PES_TELETEXT] = ttpid;
755 if (!(pcrpid & 0x8000))
756 av7110->pids[DMX_PES_PCR] = pcrpid;
757
758 av7110->pids[DMX_PES_SUBTITLE] = 0;
759
760 if (av7110->fe_synced) {
761 pcrpid = av7110->pids[DMX_PES_PCR];
ce18a223 762 ret = SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
1da177e4
LT		 763 }
764
3593cab5 765 mutex_unlock(&av7110->pid_mutex);
ce18a223 766 return ret;
1da177e4
LT		 767}
768
769
770/******************************************************************************
771 * hardware filter functions
772 ******************************************************************************/
773
774static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter)
775{
776 struct dvb_demux_feed *dvbdmxfeed = dvbdmxfilter->feed;
777 struct av7110 *av7110 = (struct av7110 *) dvbdmxfeed->demux->priv;
778 u16 buf[20];
779 int ret, i;
780 u16 handle;
781// u16 mode = 0x0320;
782 u16 mode = 0xb96a;
783
784 dprintk(4, "%p\n", av7110);
785
786 if (dvbdmxfilter->type == DMX_TYPE_SEC) {
787 if (hw_sections) {
788 buf[4] = (dvbdmxfilter->filter.filter_value[0] << 8) |
789 dvbdmxfilter->maskandmode[0];
790 for (i = 3; i < 18; i++)
791 buf[i + 4 - 2] =
792 (dvbdmxfilter->filter.filter_value[i] << 8) |
793 dvbdmxfilter->maskandmode[i];
794 mode = 4;
795 }
796 } else if ((dvbdmxfeed->ts_type & TS_PACKET) &&
797 !(dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)) {
798 av7110_p2t_init(&av7110->p2t_filter[dvbdmxfilter->index], dvbdmxfeed);
799 }
800
801 buf[0] = (COMTYPE_PID_FILTER << 8) + AddPIDFilter;
802 buf[1] = 16;
803 buf[2] = dvbdmxfeed->pid;
804 buf[3] = mode;
805
806 ret = av7110_fw_request(av7110, buf, 20, &handle, 1);
807 if (ret != 0 || handle >= 32) {
808 printk("dvb-ttpci: %s error buf %04x %04x %04x %04x "
ce18a223 809 "ret %d handle %04x\n",
1da177e4
LT		 810 __FUNCTION__, buf[0], buf[1], buf[2], buf[3],
811 ret, handle);
812 dvbdmxfilter->hw_handle = 0xffff;
ce18a223
WR		 813 if (!ret)
814 ret = -1;
815 return ret;
1da177e4
LT		 816 }
817
818 av7110->handle2filter[handle] = dvbdmxfilter;
819 dvbdmxfilter->hw_handle = handle;
820
821 return ret;
822}
823
824static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
825{
826 struct av7110 *av7110 = (struct av7110 *) dvbdmxfilter->feed->demux->priv;
827 u16 buf[3];
828 u16 answ[2];
829 int ret;
830 u16 handle;
831
832 dprintk(4, "%p\n", av7110);
833
834 handle = dvbdmxfilter->hw_handle;
835 if (handle >= 32) {
836 printk("%s tried to stop invalid filter %04x, filter type = %x\n",
837 __FUNCTION__, handle, dvbdmxfilter->type);
ce18a223 838 return -EINVAL;
1da177e4
LT		 839 }
840
841 av7110->handle2filter[handle] = NULL;
842
843 buf[0] = (COMTYPE_PID_FILTER << 8) + DelPIDFilter;
844 buf[1] = 1;
845 buf[2] = handle;
846 ret = av7110_fw_request(av7110, buf, 3, answ, 2);
847 if (ret != 0 || answ[1] != handle) {
848 printk("dvb-ttpci: %s error cmd %04x %04x %04x ret %x "
849 "resp %04x %04x pid %d\n",
850 __FUNCTION__, buf[0], buf[1], buf[2], ret,
851 answ[0], answ[1], dvbdmxfilter->feed->pid);
ce18a223
WR		 852 if (!ret)
853 ret = -1;
1da177e4
LT		 854 }
855 return ret;
856}
857
858
ce18a223 859static int dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
1da177e4
LT		 860{
861 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
862 struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
863 u16 *pid = dvbdmx->pids, npids[5];
864 int i;
ce18a223 865 int ret = 0;
1da177e4
LT		 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;
ce18a223
WR		 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;
1da177e4 883 }
1da177e4
LT		 884
885 if (dvbdmxfeed->pes_type < 2 && npids[0])
886 if (av7110->fe_synced)
ce18a223
WR		 887 {
888 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
889 if (ret)
890 return ret;
891 }
1da177e4
LT		 892
893 if ((dvbdmxfeed->ts_type & TS_PACKET)) {
894 if (dvbdmxfeed->pes_type == 0 && !(dvbdmx->pids[0] & 0x8000))
ce18a223 895 ret = av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed);
1da177e4 896 if (dvbdmxfeed->pes_type == 1 && !(dvbdmx->pids[1] & 0x8000))
ce18a223 897 ret = av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed);
1da177e4 898 }
ce18a223 899 return ret;
1da177e4
LT		 900}
901
ce18a223 902static int dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
1da177e4
LT		 903{
904 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
905 struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
906 u16 *pid = dvbdmx->pids, npids[5];
907 int i;
908
ce18a223
WR		 909 int ret = 0;
910
1da177e4
LT		 911 dprintk(4, "%p\n", av7110);
912
913 if (dvbdmxfeed->pes_type <= 1) {
ce18a223
WR		 914 ret = av7110_av_stop(av7110, dvbdmxfeed->pes_type ? RP_VIDEO : RP_AUDIO);
915 if (ret)
916 return ret;
1da177e4
LT		 917 if (!av7110->rec_mode)
918 dvbdmx->recording = 0;
919 if (!av7110->playing)
920 dvbdmx->playing = 0;
921 }
922 npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
923 i = dvbdmxfeed->pes_type;
924 switch (i) {
925 case 2: //teletext
926 if (dvbdmxfeed->ts_type & TS_PACKET)
ce18a223 927 ret = StopHWFilter(dvbdmxfeed->filter);
1da177e4
LT		 928 npids[2] = 0;
929 break;
930 case 0:
931 case 1:
932 case 4:
933 if (!pids_off)
ce18a223 934 return 0;
1da177e4
LT		 935 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
936 break;
937 }
ce18a223
WR		 938 if (!ret)
939 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
940 return ret;
1da177e4
LT		 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;
ce18a223 947 int ret = 0;
1da177e4
LT		 948
949 dprintk(4, "%p\n", av7110);
950
951 if (!demux->dmx.frontend)
952 return -EINVAL;
953
954 if (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_TS_PES_OTHER)) {
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);
ce18a223
WR		 968 ret = av7110_av_start_play(av7110,RP_AV);
969 if (!ret)
970 demux->playing = 1;
1da177e4
LT		 971 }
972 break;
973 default:
ce18a223 974 ret = dvb_feed_start_pid(feed);
1da177e4
LT		 975 break;
976 }
977 } else if ((feed->ts_type & TS_PACKET) &&
978 (demux->dmx.frontend->source != DMX_MEMORY_FE)) {
ce18a223 979 ret = StartHWFilter(feed->filter);
1da177e4
LT		 980 }
981 }
982
ce18a223 983 else if (feed->type == DMX_TYPE_SEC) {
1da177e4
LT		 984 int i;
985
986 for (i = 0; i < demux->filternum; i++) {
987 if (demux->filter[i].state != DMX_STATE_READY)
988 continue;
989 if (demux->filter[i].type != DMX_TYPE_SEC)
990 continue;
991 if (demux->filter[i].filter.parent != &feed->feed.sec)
992 continue;
993 demux->filter[i].state = DMX_STATE_GO;
ce18a223
WR		 994 if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
995 ret = StartHWFilter(&demux->filter[i]);
996 if (ret)
997 break;
998 }
1da177e4
LT		 999 }
1000 }
1001
ce18a223 1002 return ret;
1da177e4
LT		 1003}
1004
1005
1006static int av7110_stop_feed(struct dvb_demux_feed *feed)
1007{
1008 struct dvb_demux *demux = feed->demux;
1009 struct av7110 *av7110 = demux->priv;
12ba0504 1010 int i, rc, ret = 0;
1da177e4
LT		 1011 dprintk(4, "%p\n", av7110);
1012
1013 if (feed->type == DMX_TYPE_TS) {
1014 if (feed->ts_type & TS_DECODER) {
1015 if (feed->pes_type >= DMX_TS_PES_OTHER ||
1016 !demux->pesfilter[feed->pes_type])
1017 return -EINVAL;
1018 demux->pids[feed->pes_type] |= 0x8000;
1019 demux->pesfilter[feed->pes_type] = NULL;
1020 }
1021 if (feed->ts_type & TS_DECODER &&
1022 feed->pes_type < DMX_TS_PES_OTHER) {
ce18a223 1023 ret = dvb_feed_stop_pid(feed);
1da177e4
LT		 1024 } else
1025 if ((feed->ts_type & TS_PACKET) &&
1026 (demux->dmx.frontend->source != DMX_MEMORY_FE))
ce18a223 1027 ret = StopHWFilter(feed->filter);
1da177e4
LT		 1028 }
1029
ce18a223 1030 if (!ret && feed->type == DMX_TYPE_SEC) {
12ba0504 1031 for (i = 0; i<demux->filternum; i++) {
1da177e4
LT		 1032 if (demux->filter[i].state == DMX_STATE_GO &&
1033 demux->filter[i].filter.parent == &feed->feed.sec) {
1034 demux->filter[i].state = DMX_STATE_READY;
ce18a223 1035 if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
12ba0504
JS		 1036 rc = StopHWFilter(&demux->filter[i]);
1037 if (!ret)
1038 ret = rc;
1039 /* keep going, stop as many filters as possible */
ce18a223 1040 }
12ba0504 1041 }
1da177e4
LT		 1042 }
1043 }
1044
ce18a223 1045 return ret;
1da177e4
LT		 1046}
1047
1048
1049static void restart_feeds(struct av7110 *av7110)
1050{
1051 struct dvb_demux *dvbdmx = &av7110->demux;
1052 struct dvb_demux_feed *feed;
1053 int mode;
66190a27 1054 int i, j;
1da177e4
LT		 1055
1056 dprintk(4, "%p\n", av7110);
1057
1058 mode = av7110->playing;
1059 av7110->playing = 0;
1060 av7110->rec_mode = 0;
1061
66190a27 1062 for (i = 0; i < dvbdmx->feednum; i++) {
1da177e4 1063 feed = &dvbdmx->feed[i];
66190a27
OE		 1064 if (feed->state == DMX_STATE_GO) {
1065 if (feed->type == DMX_TYPE_SEC) {
1066 for (j = 0; j < dvbdmx->filternum; j++) {
1067 if (dvbdmx->filter[j].type != DMX_TYPE_SEC)
1068 continue;
1069 if (dvbdmx->filter[j].filter.parent != &feed->feed.sec)
1070 continue;
1071 if (dvbdmx->filter[j].state == DMX_STATE_GO)
1072 dvbdmx->filter[j].state = DMX_STATE_READY;
1073 }
1074 }
1da177e4 1075 av7110_start_feed(feed);
66190a27 1076 }
1da177e4
LT		 1077 }
1078
1079 if (mode)
1080 av7110_av_start_play(av7110, mode);
1081}
1082
1083static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
1084 uint64_t *stc, unsigned int *base)
1085{
1086 int ret;
1087 u16 fwstc[4];
1088 u16 tag = ((COMTYPE_REQUEST << 8) + ReqSTC);
1089 struct dvb_demux *dvbdemux;
1090 struct av7110 *av7110;
1091
1092 /* pointer casting paranoia... */
1093 if (!demux)
1094 BUG();
1095 dvbdemux = (struct dvb_demux *) demux->priv;
1096 if (!dvbdemux)
1097 BUG();
1098 av7110 = (struct av7110 *) dvbdemux->priv;
1099
1100 dprintk(4, "%p\n", av7110);
1101
1102 if (num != 0)
1103 return -EINVAL;
1104
1105 ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4);
1106 if (ret) {
1107 printk(KERN_ERR "%s: av7110_fw_request error\n", __FUNCTION__);
ce18a223 1108 return ret;
1da177e4
LT		 1109 }
1110 dprintk(2, "fwstc = %04hx %04hx %04hx %04hx\n",
1111 fwstc[0], fwstc[1], fwstc[2], fwstc[3]);
1112
1113 *stc = (((uint64_t) ((fwstc[3] & 0x8000) >> 15)) << 32) |
1114 (((uint64_t) fwstc[1]) << 16) | ((uint64_t) fwstc[0]);
1115 *base = 1;
1116
1117 dprintk(4, "stc = %lu\n", (unsigned long)*stc);
1118
1119 return 0;
1120}
1121
1122
1123/******************************************************************************
1124 * SEC device file operations
1125 ******************************************************************************/
1126
1127
1128static int av7110_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
1129{
1130 struct av7110* av7110 = (struct av7110*) fe->dvb->priv;
1131
1132 switch (tone) {
1133 case SEC_TONE_ON:
ce18a223 1134 return Set22K(av7110, 1);
1da177e4
LT		 1135
1136 case SEC_TONE_OFF:
ce18a223 1137 return Set22K(av7110, 0);
1da177e4
LT		 1138
1139 default:
1140 return -EINVAL;
1141 }
1da177e4
LT		 1142}
1143
1144static int av7110_diseqc_send_master_cmd(struct dvb_frontend* fe,
1145 struct dvb_diseqc_master_cmd* cmd)
1146{
1147 struct av7110* av7110 = fe->dvb->priv;
1148
ce18a223 1149 return av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1);
1da177e4
LT		 1150}
1151
1152static int av7110_diseqc_send_burst(struct dvb_frontend* fe,
1153 fe_sec_mini_cmd_t minicmd)
1154{
1155 struct av7110* av7110 = fe->dvb->priv;
1156
ce18a223 1157 return av7110_diseqc_send(av7110, 0, NULL, minicmd);
1da177e4
LT		 1158}
1159
1160/* simplified code from budget-core.c */
1161static int stop_ts_capture(struct av7110 *budget)
1162{
1163 dprintk(2, "budget: %p\n", budget);
1164
1165 if (--budget->feeding1)
1166 return budget->feeding1;
1167 saa7146_write(budget->dev, MC1, MASK_20); /* DMA3 off */
1168 SAA7146_IER_DISABLE(budget->dev, MASK_10);
1169 SAA7146_ISR_CLEAR(budget->dev, MASK_10);
1170 return 0;
1171}
1172
1173static int start_ts_capture(struct av7110 *budget)
1174{
1175 dprintk(2, "budget: %p\n", budget);
1176
1177 if (budget->feeding1)
1178 return ++budget->feeding1;
1179 memset(budget->grabbing, 0x00, TS_HEIGHT * TS_WIDTH);
1180 budget->tsf = 0xff;
1181 budget->ttbp = 0;
1182 SAA7146_IER_ENABLE(budget->dev, MASK_10); /* VPE */
1183 saa7146_write(budget->dev, MC1, (MASK_04 | MASK_20)); /* DMA3 on */
1184 return ++budget->feeding1;
1185}
1186
1187static int budget_start_feed(struct dvb_demux_feed *feed)
1188{
1189 struct dvb_demux *demux = feed->demux;
1190 struct av7110 *budget = (struct av7110 *) demux->priv;
1191 int status;
1192
1193 dprintk(2, "av7110: %p\n", budget);
1194
1195 spin_lock(&budget->feedlock1);
1196 feed->pusi_seen = 0; /* have a clean section start */
1197 status = start_ts_capture(budget);
1198 spin_unlock(&budget->feedlock1);
1199 return status;
1200}
1201
1202static int budget_stop_feed(struct dvb_demux_feed *feed)
1203{
1204 struct dvb_demux *demux = feed->demux;
1205 struct av7110 *budget = (struct av7110 *) demux->priv;
1206 int status;
1207
1208 dprintk(2, "budget: %p\n", budget);
1209
1210 spin_lock(&budget->feedlock1);
1211 status = stop_ts_capture(budget);
1212 spin_unlock(&budget->feedlock1);
1213 return status;
1214}
1215
1216static void vpeirq(unsigned long data)
1217{
1218 struct av7110 *budget = (struct av7110 *) data;
1219 u8 *mem = (u8 *) (budget->grabbing);
1220 u32 olddma = budget->ttbp;
1221 u32 newdma = saa7146_read(budget->dev, PCI_VDP3);
1222
1223 if (!budgetpatch) {
1224 printk("av7110.c: vpeirq() called while budgetpatch disabled!"
1225 " check saa7146 IER register\n");
1226 BUG();
1227 }
1228 /* nearest lower position divisible by 188 */
1229 newdma -= newdma % 188;
1230
1231 if (newdma >= TS_BUFLEN)
1232 return;
1233
1234 budget->ttbp = newdma;
1235
1236 if (!budget->feeding1 || (newdma == olddma))
1237 return;
1238
1239#if 0
1240 /* track rps1 activity */
1241 printk("vpeirq: %02x Event Counter 1 0x%04x\n",
1242 mem[olddma],
1243 saa7146_read(budget->dev, EC1R) & 0x3fff);
1244#endif
1245
1246 if (newdma > olddma)
1247 /* no wraparound, dump olddma..newdma */
1248 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (newdma - olddma) / 188);
1249 else {
1250 /* wraparound, dump olddma..buflen and 0..newdma */
1251 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (TS_BUFLEN - olddma) / 188);
1252 dvb_dmx_swfilter_packets(&budget->demux1, mem, newdma / 188);
1253 }
1254}
1255
1256static int av7110_register(struct av7110 *av7110)
1257{
1258 int ret, i;
1259 struct dvb_demux *dvbdemux = &av7110->demux;
1260 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1261
1262 dprintk(4, "%p\n", av7110);
1263
1264 if (av7110->registered)
1265 return -1;
1266
1267 av7110->registered = 1;
1268
1269 dvbdemux->priv = (void *) av7110;
1270
1271 for (i = 0; i < 32; i++)
1272 av7110->handle2filter[i] = NULL;
1273
1274 dvbdemux->filternum = 32;
1275 dvbdemux->feednum = 32;
1276 dvbdemux->start_feed = av7110_start_feed;
1277 dvbdemux->stop_feed = av7110_stop_feed;
1278 dvbdemux->write_to_decoder = av7110_write_to_decoder;
1279 dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1280 DMX_MEMORY_BASED_FILTERING);
1281
1282 dvb_dmx_init(&av7110->demux);
1283 av7110->demux.dmx.get_stc = dvb_get_stc;
1284
1285 av7110->dmxdev.filternum = 32;
1286 av7110->dmxdev.demux = &dvbdemux->dmx;
1287 av7110->dmxdev.capabilities = 0;
1288
fdc53a6d 1289 dvb_dmxdev_init(&av7110->dmxdev, &av7110->dvb_adapter);
1da177e4
LT		 1290
1291 av7110->hw_frontend.source = DMX_FRONTEND_0;
1292
1293 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1294
1295 if (ret < 0)
1296 return ret;
1297
1298 av7110->mem_frontend.source = DMX_MEMORY_FE;
1299
1300 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1301
1302 if (ret < 0)
1303 return ret;
1304
1305 ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1306 &av7110->hw_frontend);
1307 if (ret < 0)
1308 return ret;
1309
1310 av7110_av_register(av7110);
1311 av7110_ca_register(av7110);
1312
1313#ifdef CONFIG_DVB_AV7110_OSD
fdc53a6d 1314 dvb_register_device(&av7110->dvb_adapter, &av7110->osd_dev,
1da177e4
LT		 1315 &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1316#endif
1317
fdc53a6d 1318 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1da177e4
LT		 1319
1320 if (budgetpatch) {
1321 /* initialize software demux1 without its own frontend
1322 * demux1 hardware is connected to frontend0 of demux0
1323 */
1324 dvbdemux1->priv = (void *) av7110;
1325
1326 dvbdemux1->filternum = 256;
1327 dvbdemux1->feednum = 256;
1328 dvbdemux1->start_feed = budget_start_feed;
1329 dvbdemux1->stop_feed = budget_stop_feed;
1330 dvbdemux1->write_to_decoder = NULL;
1331
1332 dvbdemux1->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1333 DMX_MEMORY_BASED_FILTERING);
1334
1335 dvb_dmx_init(&av7110->demux1);
1336
1337 av7110->dmxdev1.filternum = 256;
1338 av7110->dmxdev1.demux = &dvbdemux1->dmx;
1339 av7110->dmxdev1.capabilities = 0;
1340
fdc53a6d 1341 dvb_dmxdev_init(&av7110->dmxdev1, &av7110->dvb_adapter);
1da177e4 1342
fdc53a6d 1343 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net1, &dvbdemux1->dmx);
1da177e4
LT		 1344 printk("dvb-ttpci: additional demux1 for budget-patch registered\n");
1345 }
1346 return 0;
1347}
1348
1349
1350static void dvb_unregister(struct av7110 *av7110)
1351{
1352 struct dvb_demux *dvbdemux = &av7110->demux;
1353 struct dvb_demux *dvbdemux1 = &av7110->demux1;
1354
1355 dprintk(4, "%p\n", av7110);
1356
1357 if (!av7110->registered)
1358 return;
1359
1360 if (budgetpatch) {
1361 dvb_net_release(&av7110->dvb_net1);
1362 dvbdemux->dmx.close(&dvbdemux1->dmx);
1363 dvb_dmxdev_release(&av7110->dmxdev1);
1364 dvb_dmx_release(&av7110->demux1);
1365 }
1366
1367 dvb_net_release(&av7110->dvb_net);
1368
1369 dvbdemux->dmx.close(&dvbdemux->dmx);
1370 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1371 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1372
1373 dvb_dmxdev_release(&av7110->dmxdev);
1374 dvb_dmx_release(&av7110->demux);
1375
1376 if (av7110->fe != NULL)
1377 dvb_unregister_frontend(av7110->fe);
1378 dvb_unregister_device(av7110->osd_dev);
1379 av7110_av_unregister(av7110);
1380 av7110_ca_unregister(av7110);
1381}
1382
1383
1384/****************************************************************************
1385 * I2C client commands
1386 ****************************************************************************/
1387
1388int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1389{
1390 u8 msg[2] = { reg, val };
1391 struct i2c_msg msgs;
1392
1393 msgs.flags = 0;
1394 msgs.addr = id / 2;
1395 msgs.len = 2;
1396 msgs.buf = msg;
1397 return i2c_transfer(&av7110->i2c_adap, &msgs, 1);
1398}
1399
1400#if 0
1401u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1402{
1403 u8 mm1[] = {0x00};
1404 u8 mm2[] = {0x00};
1405 struct i2c_msg msgs[2];
1406
1407 msgs[0].flags = 0;
1408 msgs[1].flags = I2C_M_RD;
1409 msgs[0].addr = msgs[1].addr = id / 2;
1410 mm1[0] = reg;
1411 msgs[0].len = 1; msgs[1].len = 1;
1412 msgs[0].buf = mm1; msgs[1].buf = mm2;
1413 i2c_transfer(&av7110->i2c_adap, msgs, 2);
1414
1415 return mm2[0];
1416}
1417#endif
1418
1419/****************************************************************************
1420 * INITIALIZATION
1421 ****************************************************************************/
1422
1423
1424static int check_firmware(struct av7110* av7110)
1425{
1426 u32 crc = 0, len = 0;
1427 unsigned char *ptr;
1428
1429 /* check for firmware magic */
1430 ptr = av7110->bin_fw;
1431 if (ptr[0] != 'A' || ptr[1] != 'V' ||
1432 ptr[2] != 'F' || ptr[3] != 'W') {
1433 printk("dvb-ttpci: this is not an av7110 firmware\n");
1434 return -EINVAL;
1435 }
1436 ptr += 4;
1437
1438 /* check dpram file */
1439 crc = ntohl(*(u32*) ptr);
1440 ptr += 4;
1441 len = ntohl(*(u32*) ptr);
1442 ptr += 4;
1443 if (len >= 512) {
be787ace 1444 printk("dvb-ttpci: dpram file is way too big.\n");
1da177e4
LT		 1445 return -EINVAL;
1446 }
1447 if (crc != crc32_le(0, ptr, len)) {
1448 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1449 return -EINVAL;
1450 }
1451 av7110->bin_dpram = ptr;
1452 av7110->size_dpram = len;
1453 ptr += len;
1454
1455 /* check root file */
1456 crc = ntohl(*(u32*) ptr);
1457 ptr += 4;
1458 len = ntohl(*(u32*) ptr);
1459 ptr += 4;
1460
1461 if (len <= 200000 || len >= 300000 ||
1462 len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1463 printk("dvb-ttpci: root file has strange size (%d). aborting.\n", len);
1464 return -EINVAL;
1465 }
1466 if( crc != crc32_le(0, ptr, len)) {
1467 printk("dvb-ttpci: crc32 of root file does not match.\n");
1468 return -EINVAL;
1469 }
1470 av7110->bin_root = ptr;
1471 av7110->size_root = len;
1472 return 0;
1473}
1474
1475#ifdef CONFIG_DVB_AV7110_FIRMWARE_FILE
1476#include "av7110_firm.h"
1477static void put_firmware(struct av7110* av7110)
1478{
1479 av7110->bin_fw = NULL;
1480}
1481
1482static inline int get_firmware(struct av7110* av7110)
1483{
1484 av7110->bin_fw = dvb_ttpci_fw;
1485 av7110->size_fw = sizeof(dvb_ttpci_fw);
1486 return check_firmware(av7110);
1487}
1488#else
1489static void put_firmware(struct av7110* av7110)
1490{
1491 vfree(av7110->bin_fw);
1492}
1493
1494static int get_firmware(struct av7110* av7110)
1495{
1496 int ret;
1497 const struct firmware *fw;
1498
1499 /* request the av7110 firmware, this will block until someone uploads it */
1500 ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev);
1501 if (ret) {
1502 if (ret == -ENOENT) {
1503 printk(KERN_ERR "dvb-ttpci: could not load firmware,"
1504 " file not found: dvb-ttpci-01.fw\n");