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