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