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