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