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/module.h> 34#include <linux/kmod.h> 35#include <linux/delay.h> 36#include <linux/fs.h> 37#include <linux/timer.h> 38#include <linux/poll.h> 39#include <linux/byteorder/swabb.h> 40#include <linux/smp_lock.h> 41 42#include <linux/kernel.h> 43#include <linux/moduleparam.h> 44#include <linux/sched.h> 45#include <linux/types.h> 46#include <linux/fcntl.h> 47#include <linux/interrupt.h> 48#include <linux/string.h> 49#include <linux/pci.h> 50#include <linux/vmalloc.h> 51#include <linux/firmware.h> 52#include <linux/crc32.h> 53#include <linux/i2c.h> 54#include <linux/kthread.h> 55 56#include <asm/system.h> 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 69#include "bsbe1.h" 70#include "lnbp21.h" 71#include "bsru6.h" 72 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; 87static int budgetpatch; 88static int wss_cfg_4_3 = 0x4008; 89static int wss_cfg_16_9 = 0x0007; 90static int tv_standard; 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)"); 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"); 113module_param(tv_standard, int, 0444); 114MODULE_PARM_DESC(tv_standard, "TV standard: 0 PAL (default), 1 NTSC"); 115 116static void restart_feeds(struct av7110 *av7110); 117 118static int av7110_num; 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{ 131 int ret; 132 struct saa7146_dev *dev = av7110->dev; 133 134 /* set internal volume control to maximum */ 135 av7110->adac_type = DVB_ADAC_TI; 136 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right); 137 if (ret < 0) 138 printk("dvb-ttpci:cannot set internal volume to maximum:%d\n",ret); 139 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 147 ret = av7710_set_video_mode(av7110, vidmode); 148 if (ret < 0) 149 printk("dvb-ttpci:cannot set video mode:%d\n",ret); 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; 155 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000a) 156 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 0); // SPDIF on 157 if (i2c_writereg(av7110, 0x20, 0x00, 0x00) == 1) { 158 printk ("dvb-ttpci: Crystal audio DAC @ card %d detected\n", 159 av7110->dvb_adapter.num); 160 av7110->adac_type = DVB_ADAC_CRYSTAL; 161 i2c_writereg(av7110, 0x20, 0x01, 0xd2); 162 i2c_writereg(av7110, 0x20, 0x02, 0x49); 163 i2c_writereg(av7110, 0x20, 0x03, 0x00); 164 i2c_writereg(av7110, 0x20, 0x04, 0x00); 165 166 /** 167 * some special handling for the Siemens DVB-C cards... 168 */ 169 } else if (0 == av7110_init_analog_module(av7110)) { 170 /* done. */ 171 } 172 else if (dev->pci->subsystem_vendor == 0x110a) { 173 printk("dvb-ttpci: DVB-C w/o analog module @ card %d detected\n", 174 av7110->dvb_adapter.num); 175 av7110->adac_type = DVB_ADAC_NONE; 176 } 177 else { 178 av7110->adac_type = adac; 179 printk("dvb-ttpci: adac type set to %d @ card %d\n", 180 av7110->adac_type, av7110->dvb_adapter.num); 181 } 182 183 if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP34x0) { 184 // switch DVB SCART on 185 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0); 186 if (ret < 0) 187 printk("dvb-ttpci:cannot switch on SCART(Main):%d\n",ret); 188 ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1); 189 if (ret < 0) 190 printk("dvb-ttpci:cannot switch on SCART(AD):%d\n",ret); 191 if (rgb_on && 192 ((av7110->dev->pci->subsystem_vendor == 0x110a) || 193 (av7110->dev->pci->subsystem_vendor == 0x13c2)) && 194 (av7110->dev->pci->subsystem_device == 0x0000)) { 195 saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16 196 //saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // SCARTpin 8 197 } 198 } 199 200 if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000e) 201 av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, SpdifSwitch, 1, 0); // SPDIF on 202 203 ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right); 204 if (ret < 0) 205 printk("dvb-ttpci:cannot set volume :%d\n",ret); 206} 207 208static void recover_arm(struct av7110 *av7110) 209{ 210 dprintk(4, "%p\n",av7110); 211 212 av7110_bootarm(av7110); 213 msleep(100); 214 215 init_av7110_av(av7110); 216 217 /* card-specific recovery */ 218 if (av7110->recover) 219 av7110->recover(av7110); 220 221 restart_feeds(av7110); 222 223#if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE) 224 av7110_check_ir_config(av7110, true); 225#endif 226} 227 228static void av7110_arm_sync(struct av7110 *av7110) 229{ 230 if (av7110->arm_thread) 231 kthread_stop(av7110->arm_thread); 232 233 av7110->arm_thread = NULL; 234} 235 236static int arm_thread(void *data) 237{ 238 struct av7110 *av7110 = data; 239 u16 newloops = 0; 240 int timeout; 241 242 dprintk(4, "%p\n",av7110); 243 244 for (;;) { 245 timeout = wait_event_interruptible_timeout(av7110->arm_wait, 246 kthread_should_stop(), 5 * HZ); 247 248 if (-ERESTARTSYS == timeout || kthread_should_stop()) { 249 /* got signal or told to quit*/ 250 break; 251 } 252 253 if (!av7110->arm_ready) 254 continue; 255 256#if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE) 257 av7110_check_ir_config(av7110, false); 258#endif 259 260 if (mutex_lock_interruptible(&av7110->dcomlock)) 261 break; 262 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2); 263 mutex_unlock(&av7110->dcomlock); 264 265 if (newloops == av7110->arm_loops || av7110->arm_errors > 3) { 266 printk(KERN_ERR "dvb-ttpci: ARM crashed @ card %d\n", 267 av7110->dvb_adapter.num); 268 269 recover_arm(av7110); 270 271 if (mutex_lock_interruptible(&av7110->dcomlock)) 272 break; 273 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2) - 1; 274 mutex_unlock(&av7110->dcomlock); 275 } 276 av7110->arm_loops = newloops; 277 av7110->arm_errors = 0; 278 } 279 280 return 0; 281} 282 283 284/**************************************************************************** 285 * IRQ handling 286 ****************************************************************************/ 287 288static int DvbDmxFilterCallback(u8 *buffer1, size_t buffer1_len, 289 u8 *buffer2, size_t buffer2_len, 290 struct dvb_demux_filter *dvbdmxfilter, 291 enum dmx_success success, 292 struct av7110 *av7110) 293{ 294 if (!dvbdmxfilter->feed->demux->dmx.frontend) 295 return 0; 296 if (dvbdmxfilter->feed->demux->dmx.frontend->source == DMX_MEMORY_FE) 297 return 0; 298 299 switch (dvbdmxfilter->type) { 300 case DMX_TYPE_SEC: 301 if ((((buffer1[1] << 8) | buffer1[2]) & 0xfff) + 3 != buffer1_len) 302 return 0; 303 if (dvbdmxfilter->doneq) { 304 struct dmx_section_filter *filter = &dvbdmxfilter->filter; 305 int i; 306 u8 xor, neq = 0; 307 308 for (i = 0; i < DVB_DEMUX_MASK_MAX; i++) { 309 xor = filter->filter_value[i] ^ buffer1[i]; 310 neq |= dvbdmxfilter->maskandnotmode[i] & xor; 311 } 312 if (!neq) 313 return 0; 314 } 315 return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len, 316 buffer2, buffer2_len, 317 &dvbdmxfilter->filter, 318 DMX_OK); 319 case DMX_TYPE_TS: 320 if (!(dvbdmxfilter->feed->ts_type & TS_PACKET)) 321 return 0; 322 if (dvbdmxfilter->feed->ts_type & TS_PAYLOAD_ONLY) 323 return dvbdmxfilter->feed->cb.ts(buffer1, buffer1_len, 324 buffer2, buffer2_len, 325 &dvbdmxfilter->feed->feed.ts, 326 DMX_OK); 327 else 328 av7110_p2t_write(buffer1, buffer1_len, 329 dvbdmxfilter->feed->pid, 330 &av7110->p2t_filter[dvbdmxfilter->index]); 331 default: 332 return 0; 333 } 334} 335 336 337//#define DEBUG_TIMING 338static inline void print_time(char *s) 339{ 340#ifdef DEBUG_TIMING 341 struct timeval tv; 342 do_gettimeofday(&tv); 343 printk("%s: %d.%d\n", s, (int)tv.tv_sec, (int)tv.tv_usec); 344#endif 345} 346 347#define DEBI_READ 0 348#define DEBI_WRITE 1 349static inline void start_debi_dma(struct av7110 *av7110, int dir, 350 unsigned long addr, unsigned int len) 351{ 352 dprintk(8, "%c %08lx %u\n", dir == DEBI_READ ? 'R' : 'W', addr, len); 353 if (saa7146_wait_for_debi_done(av7110->dev, 0)) { 354 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __FUNCTION__); 355 return; 356 } 357 358 SAA7146_ISR_CLEAR(av7110->dev, MASK_19); /* for good measure */ 359 SAA7146_IER_ENABLE(av7110->dev, MASK_19); 360 if (len < 5) 361 len = 5; /* we want a real DEBI DMA */ 362 if (dir == DEBI_WRITE) 363 iwdebi(av7110, DEBISWAB, addr, 0, (len + 3) & ~3); 364 else 365 irdebi(av7110, DEBISWAB, addr, 0, len); 366} 367 368static void debiirq(unsigned long data) 369{ 370 struct av7110 *av7110 = (struct av7110 *) data; 371 int type = av7110->debitype; 372 int handle = (type >> 8) & 0x1f; 373 unsigned int xfer = 0; 374 375 print_time("debi"); 376 dprintk(4, "type 0x%04x\n", type); 377 378 if (type == -1) { 379 printk("DEBI irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n", 380 jiffies, saa7146_read(av7110->dev, PSR), 381 saa7146_read(av7110->dev, SSR)); 382 goto debi_done; 383 } 384 av7110->debitype = -1; 385 386 switch (type & 0xff) { 387 388 case DATA_TS_RECORD: 389 dvb_dmx_swfilter_packets(&av7110->demux, 390 (const u8 *) av7110->debi_virt, 391 av7110->debilen / 188); 392 xfer = RX_BUFF; 393 break; 394 395 case DATA_PES_RECORD: 396 if (av7110->demux.recording) 397 av7110_record_cb(&av7110->p2t[handle], 398 (u8 *) av7110->debi_virt, 399 av7110->debilen); 400 xfer = RX_BUFF; 401 break; 402 403 case DATA_IPMPE: 404 case DATA_FSECTION: 405 case DATA_PIPING: 406 if (av7110->handle2filter[handle]) 407 DvbDmxFilterCallback((u8 *)av7110->debi_virt, 408 av7110->debilen, NULL, 0, 409 av7110->handle2filter[handle], 410 DMX_OK, av7110); 411 xfer = RX_BUFF; 412 break; 413 414 case DATA_CI_GET: 415 { 416 u8 *data = av7110->debi_virt; 417 418 if ((data[0] < 2) && data[2] == 0xff) { 419 int flags = 0; 420 if (data[5] > 0) 421 flags |= CA_CI_MODULE_PRESENT; 422 if (data[5] > 5) 423 flags |= CA_CI_MODULE_READY; 424 av7110->ci_slot[data[0]].flags = flags; 425 } else 426 ci_get_data(&av7110->ci_rbuffer, 427 av7110->debi_virt, 428 av7110->debilen); 429 xfer = RX_BUFF; 430 break; 431 } 432 433 case DATA_COMMON_INTERFACE: 434 CI_handle(av7110, (u8 *)av7110->debi_virt, av7110->debilen); 435 xfer = RX_BUFF; 436 break; 437 438 case DATA_DEBUG_MESSAGE: 439 ((s8*)av7110->debi_virt)[Reserved_SIZE - 1] = 0; 440 printk("%s\n", (s8 *) av7110->debi_virt); 441 xfer = RX_BUFF; 442 break; 443 444 case DATA_CI_PUT: 445 dprintk(4, "debi DATA_CI_PUT\n"); 446 case DATA_MPEG_PLAY: 447 dprintk(4, "debi DATA_MPEG_PLAY\n"); 448 case DATA_BMP_LOAD: 449 dprintk(4, "debi DATA_BMP_LOAD\n"); 450 xfer = TX_BUFF; 451 break; 452 default: 453 break; 454 } 455debi_done: 456 spin_lock(&av7110->debilock); 457 if (xfer) 458 iwdebi(av7110, DEBINOSWAP, xfer, 0, 2); 459 ARM_ClearMailBox(av7110); 460 spin_unlock(&av7110->debilock); 461} 462 463/* irq from av7110 firmware writing the mailbox register in the DPRAM */ 464static void gpioirq(unsigned long data) 465{ 466 struct av7110 *av7110 = (struct av7110 *) data; 467 u32 rxbuf, txbuf; 468 int len; 469 470 if (av7110->debitype != -1) 471 /* we shouldn't get any irq while a debi xfer is running */ 472 printk("dvb-ttpci: GPIO0 irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n", 473 jiffies, saa7146_read(av7110->dev, PSR), 474 saa7146_read(av7110->dev, SSR)); 475 476 if (saa7146_wait_for_debi_done(av7110->dev, 0)) { 477 printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __FUNCTION__); 478 BUG(); /* maybe we should try resetting the debi? */ 479 } 480 481 spin_lock(&av7110->debilock); 482 ARM_ClearIrq(av7110); 483 484 /* see what the av7110 wants */ 485 av7110->debitype = irdebi(av7110, DEBINOSWAP, IRQ_STATE, 0, 2); 486 av7110->debilen = irdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2); 487 rxbuf = irdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2); 488 txbuf = irdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2); 489 len = (av7110->debilen + 3) & ~3; 490 491 print_time("gpio"); 492 dprintk(8, "GPIO0 irq 0x%04x %d\n", av7110->debitype, av7110->debilen); 493 494 switch (av7110->debitype & 0xff) { 495 496 case DATA_TS_PLAY: 497 case DATA_PES_PLAY: 498 break; 499 500 case DATA_MPEG_VIDEO_EVENT: 501 { 502 u32 h_ar; 503 struct video_event event; 504 505 av7110->video_size.w = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_WIDTH, 0, 2); 506 h_ar = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_HEIGHT_AR, 0, 2); 507 508 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2); 509 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2); 510 511 av7110->video_size.h = h_ar & 0xfff; 512 513 event.type = VIDEO_EVENT_SIZE_CHANGED; 514 event.u.size.w = av7110->video_size.w; 515 event.u.size.h = av7110->video_size.h; 516 switch ((h_ar >> 12) & 0xf) 517 { 518 case 3: 519 av7110->video_size.aspect_ratio = VIDEO_FORMAT_16_9; 520 event.u.size.aspect_ratio = VIDEO_FORMAT_16_9; 521 av7110->videostate.video_format = VIDEO_FORMAT_16_9; 522 break; 523 case 4: 524 av7110->video_size.aspect_ratio = VIDEO_FORMAT_221_1; 525 event.u.size.aspect_ratio = VIDEO_FORMAT_221_1; 526 av7110->videostate.video_format = VIDEO_FORMAT_221_1; 527 break; 528 default: 529 av7110->video_size.aspect_ratio = VIDEO_FORMAT_4_3; 530 event.u.size.aspect_ratio = VIDEO_FORMAT_4_3; 531 av7110->videostate.video_format = VIDEO_FORMAT_4_3; 532 } 533 534 dprintk(8, "GPIO0 irq: DATA_MPEG_VIDEO_EVENT: w/h/ar = %u/%u/%u\n", 535 av7110->video_size.w, av7110->video_size.h, 536 av7110->video_size.aspect_ratio); 537 538 dvb_video_add_event(av7110, &event); 539 break; 540 } 541 542 case DATA_CI_PUT: 543 { 544 int avail; 545 struct dvb_ringbuffer *cibuf = &av7110->ci_wbuffer; 546 547 avail = dvb_ringbuffer_avail(cibuf); 548 if (avail <= 2) { 549 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2); 550 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2); 551 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2); 552 break; 553 } 554 len = DVB_RINGBUFFER_PEEK(cibuf, 0) << 8; 555 len |= DVB_RINGBUFFER_PEEK(cibuf, 1); 556 if (avail < len + 2) { 557 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2); 558 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2); 559 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2); 560 break; 561 } 562 DVB_RINGBUFFER_SKIP(cibuf, 2); 563 564 dvb_ringbuffer_read(cibuf, av7110->debi_virt, len, 0); 565 566 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2); 567 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2); 568 dprintk(8, "DMA: CI\n"); 569 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len); 570 spin_unlock(&av7110->debilock); 571 wake_up(&cibuf->queue); 572 return; 573 } 574 575 case DATA_MPEG_PLAY: 576 if (!av7110->playing) { 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 len = 0; 583 if (av7110->debitype & 0x100) { 584 spin_lock(&av7110->aout.lock); 585 len = av7110_pes_play(av7110->debi_virt, &av7110->aout, 2048); 586 spin_unlock(&av7110->aout.lock); 587 } 588 if (len <= 0 && (av7110->debitype & 0x200) 589 &&av7110->videostate.play_state != VIDEO_FREEZED) { 590 spin_lock(&av7110->avout.lock); 591 len = av7110_pes_play(av7110->debi_virt, &av7110->avout, 2048); 592 spin_unlock(&av7110->avout.lock); 593 } 594 if (len <= 0) { 595 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2); 596 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2); 597 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2); 598 break; 599 } 600 dprintk(8, "GPIO0 PES_PLAY len=%04x\n", len); 601 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2); 602 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2); 603 dprintk(8, "DMA: MPEG_PLAY\n"); 604 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len); 605 spin_unlock(&av7110->debilock); 606 return; 607 608 case DATA_BMP_LOAD: 609 len = av7110->debilen; 610 dprintk(8, "gpio DATA_BMP_LOAD len %d\n", len); 611 if (!len) { 612 av7110->bmp_state = BMP_LOADED; 613 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, 0, 2); 614 iwdebi(av7110, DEBINOSWAP, TX_LEN, 0, 2); 615 iwdebi(av7110, DEBINOSWAP, TX_BUFF, 0, 2); 616 wake_up(&av7110->bmpq); 617 dprintk(8, "gpio DATA_BMP_LOAD done\n"); 618 break; 619 } 620 if (len > av7110->bmplen) 621 len = av7110->bmplen; 622 if (len > 2 * 1024) 623 len = 2 * 1024; 624 iwdebi(av7110, DEBINOSWAP, TX_LEN, len, 2); 625 iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, len, 2); 626 memcpy(av7110->debi_virt, av7110->bmpbuf+av7110->bmpp, len); 627 av7110->bmpp += len; 628 av7110->bmplen -= len; 629 dprintk(8, "gpio DATA_BMP_LOAD DMA len %d\n", len); 630 start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE+txbuf, len); 631 spin_unlock(&av7110->debilock); 632 return; 633 634 case DATA_CI_GET: 635 case DATA_COMMON_INTERFACE: 636 case DATA_FSECTION: 637 case DATA_IPMPE: 638 case DATA_PIPING: 639 if (!len || len > 4 * 1024) { 640 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2); 641 break; 642 } 643 /* fall through */ 644 645 case DATA_TS_RECORD: 646 case DATA_PES_RECORD: 647 dprintk(8, "DMA: TS_REC etc.\n"); 648 start_debi_dma(av7110, DEBI_READ, DPRAM_BASE+rxbuf, len); 649 spin_unlock(&av7110->debilock); 650 return; 651 652 case DATA_DEBUG_MESSAGE: 653 if (!len || len > 0xff) { 654 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2); 655 break; 656 } 657 start_debi_dma(av7110, DEBI_READ, Reserved, len); 658 spin_unlock(&av7110->debilock); 659 return; 660 661 case DATA_IRCOMMAND: 662 if (av7110->ir.ir_handler) 663 av7110->ir.ir_handler(av7110, 664 swahw32(irdebi(av7110, DEBINOSWAP, Reserved, 0, 4))); 665 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2); 666 break; 667 668 default: 669 printk("dvb-ttpci: gpioirq unknown type=%d len=%d\n", 670 av7110->debitype, av7110->debilen); 671 break; 672 } 673 av7110->debitype = -1; 674 ARM_ClearMailBox(av7110); 675 spin_unlock(&av7110->debilock); 676} 677 678 679#ifdef CONFIG_DVB_AV7110_OSD 680static int dvb_osd_ioctl(struct inode *inode, struct file *file, 681 unsigned int cmd, void *parg) 682{ 683 struct dvb_device *dvbdev = file->private_data; 684 struct av7110 *av7110 = dvbdev->priv; 685 686 dprintk(4, "%p\n", av7110); 687 688 if (cmd == OSD_SEND_CMD) 689 return av7110_osd_cmd(av7110, (osd_cmd_t *) parg); 690 if (cmd == OSD_GET_CAPABILITY) 691 return av7110_osd_capability(av7110, (osd_cap_t *) parg); 692 693 return -EINVAL; 694} 695 696 697static struct file_operations dvb_osd_fops = { 698 .owner = THIS_MODULE, 699 .ioctl = dvb_generic_ioctl, 700 .open = dvb_generic_open, 701 .release = dvb_generic_release, 702}; 703 704static struct dvb_device dvbdev_osd = { 705 .priv = NULL, 706 .users = 1, 707 .writers = 1, 708 .fops = &dvb_osd_fops, 709 .kernel_ioctl = dvb_osd_ioctl, 710}; 711#endif /* CONFIG_DVB_AV7110_OSD */ 712 713 714static inline int SetPIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid, 715 u16 subpid, u16 pcrpid) 716{ 717 u16 aflags = 0; 718 719 dprintk(4, "%p\n", av7110); 720 721 if (vpid == 0x1fff || apid == 0x1fff || 722 ttpid == 0x1fff || subpid == 0x1fff || pcrpid == 0x1fff) { 723 vpid = apid = ttpid = subpid = pcrpid = 0; 724 av7110->pids[DMX_PES_VIDEO] = 0; 725 av7110->pids[DMX_PES_AUDIO] = 0; 726 av7110->pids[DMX_PES_TELETEXT] = 0; 727 av7110->pids[DMX_PES_PCR] = 0; 728 } 729 730 if (av7110->audiostate.bypass_mode) 731 aflags |= 0x8000; 732 733 return av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, MultiPID, 6, 734 pcrpid, vpid, apid, ttpid, subpid, aflags); 735} 736 737int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid, 738 u16 subpid, u16 pcrpid) 739{ 740 int ret = 0; 741 dprintk(4, "%p\n", av7110); 742 743 if (mutex_lock_interruptible(&av7110->pid_mutex)) 744 return -ERESTARTSYS; 745 746 if (!(vpid & 0x8000)) 747 av7110->pids[DMX_PES_VIDEO] = vpid; 748 if (!(apid & 0x8000)) 749 av7110->pids[DMX_PES_AUDIO] = apid; 750 if (!(ttpid & 0x8000)) 751 av7110->pids[DMX_PES_TELETEXT] = ttpid; 752 if (!(pcrpid & 0x8000)) 753 av7110->pids[DMX_PES_PCR] = pcrpid; 754 755 av7110->pids[DMX_PES_SUBTITLE] = 0; 756 757 if (av7110->fe_synced) { 758 pcrpid = av7110->pids[DMX_PES_PCR]; 759 ret = SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid); 760 } 761 762 mutex_unlock(&av7110->pid_mutex); 763 return ret; 764} 765 766 767/****************************************************************************** 768 * hardware filter functions 769 ******************************************************************************/ 770 771static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter) 772{ 773 struct dvb_demux_feed *dvbdmxfeed = dvbdmxfilter->feed; 774 struct av7110 *av7110 = dvbdmxfeed->demux->priv; 775 u16 buf[20]; 776 int ret, i; 777 u16 handle; 778// u16 mode = 0x0320; 779 u16 mode = 0xb96a; 780 781 dprintk(4, "%p\n", av7110); 782 783 if (dvbdmxfilter->type == DMX_TYPE_SEC) { 784 if (hw_sections) { 785 buf[4] = (dvbdmxfilter->filter.filter_value[0] << 8) | 786 dvbdmxfilter->maskandmode[0]; 787 for (i = 3; i < 18; i++) 788 buf[i + 4 - 2] = 789 (dvbdmxfilter->filter.filter_value[i] << 8) | 790 dvbdmxfilter->maskandmode[i]; 791 mode = 4; 792 } 793 } else if ((dvbdmxfeed->ts_type & TS_PACKET) && 794 !(dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)) { 795 av7110_p2t_init(&av7110->p2t_filter[dvbdmxfilter->index], dvbdmxfeed); 796 } 797 798 buf[0] = (COMTYPE_PID_FILTER << 8) + AddPIDFilter; 799 buf[1] = 16; 800 buf[2] = dvbdmxfeed->pid; 801 buf[3] = mode; 802 803 ret = av7110_fw_request(av7110, buf, 20, &handle, 1); 804 if (ret != 0 || handle >= 32) { 805 printk("dvb-ttpci: %s error buf %04x %04x %04x %04x " 806 "ret %d handle %04x\n", 807 __FUNCTION__, buf[0], buf[1], buf[2], buf[3], 808 ret, handle); 809 dvbdmxfilter->hw_handle = 0xffff; 810 if (!ret) 811 ret = -1; 812 return ret; 813 } 814 815 av7110->handle2filter[handle] = dvbdmxfilter; 816 dvbdmxfilter->hw_handle = handle; 817 818 return ret; 819} 820 821static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter) 822{ 823 struct av7110 *av7110 = dvbdmxfilter->feed->demux->priv; 824 u16 buf[3]; 825 u16 answ[2]; 826 int ret; 827 u16 handle; 828 829 dprintk(4, "%p\n", av7110); 830 831 handle = dvbdmxfilter->hw_handle; 832 if (handle >= 32) { 833 printk("%s tried to stop invalid filter %04x, filter type = %x\n", 834 __FUNCTION__, handle, dvbdmxfilter->type); 835 return -EINVAL; 836 } 837 838 av7110->handle2filter[handle] = NULL; 839 840 buf[0] = (COMTYPE_PID_FILTER << 8) + DelPIDFilter; 841 buf[1] = 1; 842 buf[2] = handle; 843 ret = av7110_fw_request(av7110, buf, 3, answ, 2); 844 if (ret != 0 || answ[1] != handle) { 845 printk("dvb-ttpci: %s error cmd %04x %04x %04x ret %x " 846 "resp %04x %04x pid %d\n", 847 __FUNCTION__, buf[0], buf[1], buf[2], ret, 848 answ[0], answ[1], dvbdmxfilter->feed->pid); 849 if (!ret) 850 ret = -1; 851 } 852 return ret; 853} 854 855 856static int dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed) 857{ 858 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 859 struct av7110 *av7110 = dvbdmx->priv; 860 u16 *pid = dvbdmx->pids, npids[5]; 861 int i; 862 int ret = 0; 863 864 dprintk(4, "%p\n", av7110); 865 866 npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff; 867 i = dvbdmxfeed->pes_type; 868 npids[i] = (pid[i]&0x8000) ? 0 : pid[i]; 869 if ((i == 2) && npids[i] && (dvbdmxfeed->ts_type & TS_PACKET)) { 870 npids[i] = 0; 871 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]); 872 if (!ret) 873 ret = StartHWFilter(dvbdmxfeed->filter); 874 return ret; 875 } 876 if (dvbdmxfeed->pes_type <= 2 || dvbdmxfeed->pes_type == 4) { 877 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]); 878 if (ret) 879 return ret; 880 } 881 882 if (dvbdmxfeed->pes_type < 2 && npids[0]) 883 if (av7110->fe_synced) 884 { 885 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0); 886 if (ret) 887 return ret; 888 } 889 890 if ((dvbdmxfeed->ts_type & TS_PACKET)) { 891 if (dvbdmxfeed->pes_type == 0 && !(dvbdmx->pids[0] & 0x8000)) 892 ret = av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed); 893 if (dvbdmxfeed->pes_type == 1 && !(dvbdmx->pids[1] & 0x8000)) 894 ret = av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed); 895 } 896 return ret; 897} 898 899static int dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed) 900{ 901 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 902 struct av7110 *av7110 = dvbdmx->priv; 903 u16 *pid = dvbdmx->pids, npids[5]; 904 int i; 905 906 int ret = 0; 907 908 dprintk(4, "%p\n", av7110); 909 910 if (dvbdmxfeed->pes_type <= 1) { 911 ret = av7110_av_stop(av7110, dvbdmxfeed->pes_type ? RP_VIDEO : RP_AUDIO); 912 if (ret) 913 return ret; 914 if (!av7110->rec_mode) 915 dvbdmx->recording = 0; 916 if (!av7110->playing) 917 dvbdmx->playing = 0; 918 } 919 npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff; 920 i = dvbdmxfeed->pes_type; 921 switch (i) { 922 case 2: //teletext 923 if (dvbdmxfeed->ts_type & TS_PACKET) 924 ret = StopHWFilter(dvbdmxfeed->filter); 925 npids[2] = 0; 926 break; 927 case 0: 928 case 1: 929 case 4: 930 if (!pids_off) 931 return 0; 932 npids[i] = (pid[i]&0x8000) ? 0 : pid[i]; 933 break; 934 } 935 if (!ret) 936 ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]); 937 return ret; 938} 939 940static int av7110_start_feed(struct dvb_demux_feed *feed) 941{ 942 struct dvb_demux *demux = feed->demux; 943 struct av7110 *av7110 = demux->priv; 944 int ret = 0; 945 946 dprintk(4, "%p\n", av7110); 947 948 if (!demux->dmx.frontend) 949 return -EINVAL; 950 951 if (feed->pid > 0x1fff) 952 return -EINVAL; 953 954 if (feed->type == DMX_TYPE_TS) { 955 if ((feed->ts_type & TS_DECODER) && 956 (feed->pes_type < DMX_TS_PES_OTHER)) { 957 switch (demux->dmx.frontend->source) { 958 case DMX_MEMORY_FE: 959 if (feed->ts_type & TS_DECODER) 960 if (feed->pes_type < 2 && 961 !(demux->pids[0] & 0x8000) && 962 !(demux->pids[1] & 0x8000)) { 963 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout); 964 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout); 965 ret = av7110_av_start_play(av7110,RP_AV); 966 if (!ret) 967 demux->playing = 1; 968 } 969 break; 970 default: 971 ret = dvb_feed_start_pid(feed); 972 break; 973 } 974 } else if ((feed->ts_type & TS_PACKET) && 975 (demux->dmx.frontend->source != DMX_MEMORY_FE)) { 976 ret = StartHWFilter(feed->filter); 977 } 978 } 979 980 else if (feed->type == DMX_TYPE_SEC) { 981 int i; 982 983 for (i = 0; i < demux->filternum; i++) { 984 if (demux->filter[i].state != DMX_STATE_READY) 985 continue; 986 if (demux->filter[i].type != DMX_TYPE_SEC) 987 continue; 988 if (demux->filter[i].filter.parent != &feed->feed.sec) 989 continue; 990 demux->filter[i].state = DMX_STATE_GO; 991 if (demux->dmx.frontend->source != DMX_MEMORY_FE) { 992 ret = StartHWFilter(&demux->filter[i]); 993 if (ret) 994 break; 995 } 996 } 997 } 998 999 return ret; 1000} 1001 1002 1003static int av7110_stop_feed(struct dvb_demux_feed *feed) 1004{ 1005 struct dvb_demux *demux = feed->demux; 1006 struct av7110 *av7110 = demux->priv; 1007 int i, rc, ret = 0; 1008 dprintk(4, "%p\n", av7110); 1009 1010 if (feed->type == DMX_TYPE_TS) { 1011 if (feed->ts_type & TS_DECODER) { 1012 if (feed->pes_type >= DMX_TS_PES_OTHER || 1013 !demux->pesfilter[feed->pes_type]) 1014 return -EINVAL; 1015 demux->pids[feed->pes_type] |= 0x8000; 1016 demux->pesfilter[feed->pes_type] = NULL; 1017 } 1018 if (feed->ts_type & TS_DECODER && 1019 feed->pes_type < DMX_TS_PES_OTHER) { 1020 ret = dvb_feed_stop_pid(feed); 1021 } else 1022 if ((feed->ts_type & TS_PACKET) && 1023 (demux->dmx.frontend->source != DMX_MEMORY_FE)) 1024 ret = StopHWFilter(feed->filter); 1025 } 1026 1027 if (!ret && feed->type == DMX_TYPE_SEC) { 1028 for (i = 0; i<demux->filternum; i++) { 1029 if (demux->filter[i].state == DMX_STATE_GO && 1030 demux->filter[i].filter.parent == &feed->feed.sec) { 1031 demux->filter[i].state = DMX_STATE_READY; 1032 if (demux->dmx.frontend->source != DMX_MEMORY_FE) { 1033 rc = StopHWFilter(&demux->filter[i]); 1034 if (!ret) 1035 ret = rc; 1036 /* keep going, stop as many filters as possible */ 1037 } 1038 } 1039 } 1040 } 1041 1042 return ret; 1043} 1044 1045 1046static void restart_feeds(struct av7110 *av7110) 1047{ 1048 struct dvb_demux *dvbdmx = &av7110->demux; 1049 struct dvb_demux_feed *feed; 1050 int mode; 1051 int i, j; 1052 1053 dprintk(4, "%p\n", av7110); 1054 1055 mode = av7110->playing; 1056 av7110->playing = 0; 1057 av7110->rec_mode = 0; 1058 1059 for (i = 0; i < dvbdmx->feednum; i++) { 1060 feed = &dvbdmx->feed[i]; 1061 if (feed->state == DMX_STATE_GO) { 1062 if (feed->type == DMX_TYPE_SEC) { 1063 for (j = 0; j < dvbdmx->filternum; j++) { 1064 if (dvbdmx->filter[j].type != DMX_TYPE_SEC) 1065 continue; 1066 if (dvbdmx->filter[j].filter.parent != &feed->feed.sec) 1067 continue; 1068 if (dvbdmx->filter[j].state == DMX_STATE_GO) 1069 dvbdmx->filter[j].state = DMX_STATE_READY; 1070 } 1071 } 1072 av7110_start_feed(feed); 1073 } 1074 } 1075 1076 if (mode) 1077 av7110_av_start_play(av7110, mode); 1078} 1079 1080static int dvb_get_stc(struct dmx_demux *demux, unsigned int num, 1081 uint64_t *stc, unsigned int *base) 1082{ 1083 int ret; 1084 u16 fwstc[4]; 1085 u16 tag = ((COMTYPE_REQUEST << 8) + ReqSTC); 1086 struct dvb_demux *dvbdemux; 1087 struct av7110 *av7110; 1088 1089 /* pointer casting paranoia... */ 1090 BUG_ON(!demux); 1091 dvbdemux = demux->priv; 1092 BUG_ON(!dvbdemux); 1093 av7110 = dvbdemux->priv; 1094 1095 dprintk(4, "%p\n", av7110); 1096 1097 if (num != 0) 1098 return -EINVAL; 1099 1100 ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4); 1101 if (ret) { 1102 printk(KERN_ERR "%s: av7110_fw_request error\n", __FUNCTION__); 1103 return ret; 1104 } 1105 dprintk(2, "fwstc = %04hx %04hx %04hx %04hx\n", 1106 fwstc[0], fwstc[1], fwstc[2], fwstc[3]); 1107 1108 *stc = (((uint64_t) ((fwstc[3] & 0x8000) >> 15)) << 32) | 1109 (((uint64_t) fwstc[1]) << 16) | ((uint64_t) fwstc[0]); 1110 *base = 1; 1111 1112 dprintk(4, "stc = %lu\n", (unsigned long)*stc); 1113 1114 return 0; 1115} 1116 1117 1118/****************************************************************************** 1119 * SEC device file operations 1120 ******************************************************************************/ 1121 1122 1123static int av7110_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone) 1124{ 1125 struct av7110* av7110 = fe->dvb->priv; 1126 1127 switch (tone) { 1128 case SEC_TONE_ON: 1129 return Set22K(av7110, 1); 1130 1131 case SEC_TONE_OFF: 1132 return Set22K(av7110, 0); 1133 1134 default: 1135 return -EINVAL; 1136 } 1137} 1138 1139static int av7110_diseqc_send_master_cmd(struct dvb_frontend* fe, 1140 struct dvb_diseqc_master_cmd* cmd) 1141{ 1142 struct av7110* av7110 = fe->dvb->priv; 1143 1144 return av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1); 1145} 1146 1147static int av7110_diseqc_send_burst(struct dvb_frontend* fe, 1148 fe_sec_mini_cmd_t minicmd) 1149{ 1150 struct av7110* av7110 = fe->dvb->priv; 1151 1152 return av7110_diseqc_send(av7110, 0, NULL, minicmd); 1153} 1154 1155/* simplified code from budget-core.c */ 1156static int stop_ts_capture(struct av7110 *budget) 1157{ 1158 dprintk(2, "budget: %p\n", budget); 1159 1160 if (--budget->feeding1) 1161 return budget->feeding1; 1162 saa7146_write(budget->dev, MC1, MASK_20); /* DMA3 off */ 1163 SAA7146_IER_DISABLE(budget->dev, MASK_10); 1164 SAA7146_ISR_CLEAR(budget->dev, MASK_10); 1165 return 0; 1166} 1167 1168static int start_ts_capture(struct av7110 *budget) 1169{ 1170 dprintk(2, "budget: %p\n", budget); 1171 1172 if (budget->feeding1) 1173 return ++budget->feeding1; 1174 memset(budget->grabbing, 0x00, TS_HEIGHT * TS_WIDTH); 1175 budget->tsf = 0xff; 1176 budget->ttbp = 0; 1177 SAA7146_IER_ENABLE(budget->dev, MASK_10); /* VPE */ 1178 saa7146_write(budget->dev, MC1, (MASK_04 | MASK_20)); /* DMA3 on */ 1179 return ++budget->feeding1; 1180} 1181 1182static int budget_start_feed(struct dvb_demux_feed *feed) 1183{ 1184 struct dvb_demux *demux = feed->demux; 1185 struct av7110 *budget = demux->priv; 1186 int status; 1187 1188 dprintk(2, "av7110: %p\n", budget); 1189 1190 spin_lock(&budget->feedlock1); 1191 feed->pusi_seen = 0; /* have a clean section start */ 1192 status = start_ts_capture(budget); 1193 spin_unlock(&budget->feedlock1); 1194 return status; 1195} 1196 1197static int budget_stop_feed(struct dvb_demux_feed *feed) 1198{ 1199 struct dvb_demux *demux = feed->demux; 1200 struct av7110 *budget = demux->priv; 1201 int status; 1202 1203 dprintk(2, "budget: %p\n", budget); 1204 1205 spin_lock(&budget->feedlock1); 1206 status = stop_ts_capture(budget); 1207 spin_unlock(&budget->feedlock1); 1208 return status; 1209} 1210 1211static void vpeirq(unsigned long data) 1212{ 1213 struct av7110 *budget = (struct av7110 *) data; 1214 u8 *mem = (u8 *) (budget->grabbing); 1215 u32 olddma = budget->ttbp; 1216 u32 newdma = saa7146_read(budget->dev, PCI_VDP3); 1217 1218 if (!budgetpatch) { 1219 printk("av7110.c: vpeirq() called while budgetpatch disabled!" 1220 " check saa7146 IER register\n"); 1221 BUG(); 1222 } 1223 /* nearest lower position divisible by 188 */ 1224 newdma -= newdma % 188; 1225 1226 if (newdma >= TS_BUFLEN) 1227 return; 1228 1229 budget->ttbp = newdma; 1230 1231 if (!budget->feeding1 || (newdma == olddma)) 1232 return; 1233 1234 /* Ensure streamed PCI data is synced to CPU */ 1235 pci_dma_sync_sg_for_cpu(budget->dev->pci, budget->pt.slist, budget->pt.nents, PCI_DMA_FROMDEVICE); 1236 1237 1238 if (newdma > olddma) 1239 /* no wraparound, dump olddma..newdma */ 1240 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (newdma - olddma) / 188); 1241 else { 1242 /* wraparound, dump olddma..buflen and 0..newdma */ 1243 dvb_dmx_swfilter_packets(&budget->demux1, mem + olddma, (TS_BUFLEN - olddma) / 188); 1244 dvb_dmx_swfilter_packets(&budget->demux1, mem, newdma / 188); 1245 } 1246} 1247 1248static int av7110_register(struct av7110 *av7110) 1249{ 1250 int ret, i; 1251 struct dvb_demux *dvbdemux = &av7110->demux; 1252 struct dvb_demux *dvbdemux1 = &av7110->demux1; 1253 1254 dprintk(4, "%p\n", av7110); 1255 1256 if (av7110->registered) 1257 return -1; 1258 1259 av7110->registered = 1; 1260 1261 dvbdemux->priv = (void *) av7110; 1262 1263 for (i = 0; i < 32; i++) 1264 av7110->handle2filter[i] = NULL; 1265 1266 dvbdemux->filternum = 32; 1267 dvbdemux->feednum = 32; 1268 dvbdemux->start_feed = av7110_start_feed; 1269 dvbdemux->stop_feed = av7110_stop_feed; 1270 dvbdemux->write_to_decoder = av7110_write_to_decoder; 1271 dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING | 1272 DMX_MEMORY_BASED_FILTERING); 1273 1274 dvb_dmx_init(&av7110->demux); 1275 av7110->demux.dmx.get_stc = dvb_get_stc; 1276 1277 av7110->dmxdev.filternum = 32; 1278 av7110->dmxdev.demux = &dvbdemux->dmx; 1279 av7110->dmxdev.capabilities = 0; 1280 1281 dvb_dmxdev_init(&av7110->dmxdev, &av7110->dvb_adapter); 1282 1283 av7110->hw_frontend.source = DMX_FRONTEND_0; 1284 1285 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend); 1286 1287 if (ret < 0) 1288 return ret; 1289 1290 av7110->mem_frontend.source = DMX_MEMORY_FE; 1291 1292 ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend); 1293 1294 if (ret < 0) 1295 return ret; 1296 1297 ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, 1298 &av7110->hw_frontend); 1299 if (ret < 0) 1300 return ret; 1301 1302 av7110_av_register(av7110); 1303 av7110_ca_register(av7110); 1304 1305#ifdef CONFIG_DVB_AV7110_OSD 1306 dvb_register_device(&av7110->dvb_adapter, &av7110->osd_dev, 1307 &dvbdev_osd, av7110, DVB_DEVICE_OSD); 1308#endif 1309 1310 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx); 1311 1312 if (budgetpatch) { 1313 /* initialize software demux1 without its own frontend 1314 * demux1 hardware is connected to frontend0 of demux0 1315 */ 1316 dvbdemux1->priv = (void *) av7110; 1317 1318 dvbdemux1->filternum = 256; 1319 dvbdemux1->feednum = 256; 1320 dvbdemux1->start_feed = budget_start_feed; 1321 dvbdemux1->stop_feed = budget_stop_feed; 1322 dvbdemux1->write_to_decoder = NULL; 1323 1324 dvbdemux1->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING | 1325 DMX_MEMORY_BASED_FILTERING); 1326 1327 dvb_dmx_init(&av7110->demux1); 1328 1329 av7110->dmxdev1.filternum = 256; 1330 av7110->dmxdev1.demux = &dvbdemux1->dmx; 1331 av7110->dmxdev1.capabilities = 0; 1332 1333 dvb_dmxdev_init(&av7110->dmxdev1, &av7110->dvb_adapter); 1334 1335 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net1, &dvbdemux1->dmx); 1336 printk("dvb-ttpci: additional demux1 for budget-patch registered\n"); 1337 } 1338 return 0; 1339} 1340 1341 1342static void dvb_unregister(struct av7110 *av7110) 1343{ 1344 struct dvb_demux *dvbdemux = &av7110->demux; 1345 struct dvb_demux *dvbdemux1 = &av7110->demux1; 1346 1347 dprintk(4, "%p\n", av7110); 1348 1349 if (!av7110->registered) 1350 return; 1351 1352 if (budgetpatch) { 1353 dvb_net_release(&av7110->dvb_net1); 1354 dvbdemux->dmx.close(&dvbdemux1->dmx); 1355 dvb_dmxdev_release(&av7110->dmxdev1); 1356 dvb_dmx_release(&av7110->demux1); 1357 } 1358 1359 dvb_net_release(&av7110->dvb_net); 1360 1361 dvbdemux->dmx.close(&dvbdemux->dmx); 1362 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend); 1363 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend); 1364 1365 dvb_dmxdev_release(&av7110->dmxdev); 1366 dvb_dmx_release(&av7110->demux); 1367 1368 if (av7110->fe != NULL) { 1369 dvb_unregister_frontend(av7110->fe); 1370 dvb_frontend_detach(av7110->fe); 1371 } 1372 dvb_unregister_device(av7110->osd_dev); 1373 av7110_av_unregister(av7110); 1374 av7110_ca_unregister(av7110); 1375} 1376 1377 1378/**************************************************************************** 1379 * I2C client commands 1380 ****************************************************************************/ 1381 1382int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val) 1383{ 1384 u8 msg[2] = { reg, val }; 1385 struct i2c_msg msgs; 1386 1387 msgs.flags = 0; 1388 msgs.addr = id / 2; 1389 msgs.len = 2; 1390 msgs.buf = msg; 1391 return i2c_transfer(&av7110->i2c_adap, &msgs, 1); 1392} 1393 1394 1395/**************************************************************************** 1396 * INITIALIZATION 1397 ****************************************************************************/ 1398 1399 1400static int check_firmware(struct av7110* av7110) 1401{ 1402 u32 crc = 0, len = 0; 1403 unsigned char *ptr; 1404 1405 /* check for firmware magic */ 1406 ptr = av7110->bin_fw; 1407 if (ptr[0] != 'A' || ptr[1] != 'V' || 1408 ptr[2] != 'F' || ptr[3] != 'W') { 1409 printk("dvb-ttpci: this is not an av7110 firmware\n"); 1410 return -EINVAL; 1411 } 1412 ptr += 4; 1413 1414 /* check dpram file */ 1415 crc = ntohl(*(u32*) ptr); 1416 ptr += 4; 1417 len = ntohl(*(u32*) ptr); 1418 ptr += 4; 1419 if (len >= 512) { 1420 printk("dvb-ttpci: dpram file is way too big.\n"); 1421 return -EINVAL; 1422 } 1423 if (crc != crc32_le(0, ptr, len)) { 1424 printk("dvb-ttpci: crc32 of dpram file does not match.\n"); 1425 return -EINVAL; 1426 } 1427 av7110->bin_dpram = ptr; 1428 av7110->size_dpram = len; 1429 ptr += len; 1430 1431 /* check root file */ 1432 crc = ntohl(*(u32*) ptr); 1433 ptr += 4; 1434 len = ntohl(*(u32*) ptr); 1435 ptr += 4; 1436 1437 if (len <= 200000 || len >= 300000 || 1438 len > ((av7110->bin_fw + av7110->size_fw) - ptr)) { 1439 printk("dvb-ttpci: root file has strange size (%d). aborting.\n", len); 1440 return -EINVAL; 1441 } 1442 if( crc != crc32_le(0, ptr, len)) { 1443 printk("dvb-ttpci: crc32 of root file does not match.\n"); 1444 return -EINVAL; 1445 } 1446 av7110->bin_root = ptr; 1447 av7110->size_root = len; 1448 return 0; 1449} 1450 1451#ifdef CONFIG_DVB_AV7110_FIRMWARE_FILE 1452#include "av7110_firm.h" 1453static void put_firmware(struct av7110* av7110) 1454{ 1455 av7110->bin_fw = NULL; 1456} 1457 1458static inline int get_firmware(struct av7110* av7110) 1459{ 1460 av7110->bin_fw = dvb_ttpci_fw; 1461 av7110->size_fw = sizeof(dvb_ttpci_fw); 1462 return check_firmware(av7110); 1463} 1464#else 1465static void put_firmware(struct av7110* av7110) 1466{ 1467 vfree(av7110->bin_fw); 1468} 1469 1470static int get_firmware(struct av7110* av7110) 1471{ 1472 int ret; 1473 const struct firmware *fw; 1474 1475 /* request the av7110 firmware, this will block until someone uploads it */ 1476 ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev); 1477 if (ret) { 1478 if (ret == -ENOENT) { 1479 printk(KERN_ERR "dvb-ttpci: could not load firmware," 1480 " file not found: dvb-ttpci-01.fw\n"); 1481 printk(KERN_ERR "dvb-ttpci: usually this should be in " 1482 "/usr/lib/hotplug/firmware or /lib/firmware\n"); 1483 printk(KERN_ERR "dvb-ttpci: and can be downloaded from" 1484 " http://www.linuxtv.org/download/dvb/firmware/\n"); 1485 } else 1486 printk(KERN_ERR "dvb-ttpci: cannot request firmware" 1487 " (error %i)\n", ret); 1488 return -EINVAL; 1489 } 1490 1491 if (fw->size <= 200000) { 1492 printk("dvb-ttpci: this firmware is way too small.\n"); 1493 release_firmware(fw); 1494 return -EINVAL; 1495 } 1496 1497 /* check if the firmware is available */ 1498 av7110->bin_fw = (unsigned char *) vmalloc(fw->size); 1499 if (NULL == av7110->bin_fw) { 1500 dprintk(1, "out of memory\n"); 1501 release_firmware(fw); 1502 return -ENOMEM; 1503 } 1504 1505 memcpy(av7110->bin_fw, fw->data, fw->size); 1506 av7110->size_fw = fw->size; 1507 if ((ret = check_firmware(av7110))) 1508 vfree(av7110->bin_fw); 1509 1510 release_firmware(fw); 1511 return ret; 1512} 1513#endif 1514 1515 1516static int alps_bsrv2_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params) 1517{ 1518 struct av7110* av7110 = fe->dvb->priv; 1519 u8 pwr = 0; 1520 u8 buf[4]; 1521 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) }; 1522 u32 div = (params->frequency + 479500) / 125; 1523 1524 if (params->frequency > 2000000) pwr = 3; 1525 else if (params->frequency > 1800000) pwr = 2; 1526 else if (params->frequency > 1600000) pwr = 1; 1527 else if (params->frequency > 1200000) pwr = 0; 1528 else if (params->frequency >= 1100000) pwr = 1; 1529 else pwr = 2; 1530 1531 buf[0] = (div >> 8) & 0x7f; 1532 buf[1] = div & 0xff; 1533 buf[2] = ((div & 0x18000) >> 10) | 0x95; 1534 buf[3] = (pwr << 6) | 0x30; 1535 1536 // NOTE: since we're using a prescaler of 2, we set the 1537 // divisor frequency to 62.5kHz and divide by 125 above 1538 1539 if (fe->ops.i2c_gate_ctrl) 1540 fe->ops.i2c_gate_ctrl(fe, 1); 1541 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) 1542 return -EIO; 1543 return 0; 1544} 1545 1546static struct ves1x93_config alps_bsrv2_config = { 1547 .demod_address = 0x08, 1548 .xin = 90100000UL, 1549 .invert_pwm = 0, 1550}; 1551 1552static int alps_tdbe2_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params) 1553{ 1554 struct av7110* av7110 = fe->dvb->priv; 1555 u32 div; 1556 u8 data[4]; 1557 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) }; 1558 1559 div = (params->frequency + 35937500 + 31250) / 62500; 1560 1561 data[0] = (div >> 8) & 0x7f; 1562 data[1] = div & 0xff; 1563 data[2] = 0x85 | ((div >> 10) & 0x60); 1564 data[3] = (params->frequency < 174000000 ? 0x88 : params->frequency < 470000000 ? 0x84 : 0x81); 1565 1566 if (fe->ops.i2c_gate_ctrl) 1567 fe->ops.i2c_gate_ctrl(fe, 1); 1568 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) 1569 return -EIO; 1570 return 0; 1571} 1572 1573static struct ves1820_config alps_tdbe2_config = { 1574 .demod_address = 0x09, 1575 .xin = 57840000UL, 1576 .invert = 1, 1577 .selagc = VES1820_SELAGC_SIGNAMPERR, 1578}; 1579 1580 1581 1582 1583static int grundig_29504_451_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params) 1584{ 1585 struct av7110* av7110 = fe->dvb->priv; 1586 u32 div; 1587 u8 data[4]; 1588 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) }; 1589 1590 div = params->frequency / 125; 1591 data[0] = (div >> 8) & 0x7f; 1592 data[1] = div & 0xff; 1593 data[2] = 0x8e; 1594 data[3] = 0x00; 1595 1596 if (fe->ops.i2c_gate_ctrl) 1597 fe->ops.i2c_gate_ctrl(fe, 1); 1598 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) 1599 return -EIO; 1600 return 0; 1601} 1602 1603static struct tda8083_config grundig_29504_451_config = { 1604 .demod_address = 0x68, 1605}; 1606 1607 1608 1609static int philips_cd1516_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params) 1610{ 1611 struct av7110* av7110 = fe->dvb->priv; 1612 u32 div; 1613 u32 f = params->frequency; 1614 u8 data[4]; 1615 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) }; 1616 1617 div = (f + 36125000 + 31250) / 62500; 1618 1619 data[0] = (div >> 8) & 0x7f; 1620 data[1] = div & 0xff; 1621 data[2] = 0x8e; 1622 data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34); 1623 1624 if (fe->ops.i2c_gate_ctrl) 1625 fe->ops.i2c_gate_ctrl(fe, 1); 1626 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) 1627 return -EIO; 1628 return 0; 1629} 1630 1631static struct ves1820_config philips_cd1516_config = { 1632 .demod_address = 0x09, 1633 .xin = 57840000UL, 1634 .invert = 1, 1635 .selagc = VES1820_SELAGC_SIGNAMPERR, 1636}; 1637 1638 1639 1640static int alps_tdlb7_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params) 1641{ 1642 struct av7110* av7110 = fe->dvb->priv; 1643 u32 div, pwr; 1644 u8 data[4]; 1645 struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) }; 1646 1647 div = (params->frequency + 36200000) / 166666; 1648 1649 if (params->frequency <= 782000000) 1650 pwr = 1; 1651 else 1652 pwr = 2; 1653 1654 data[0] = (div >> 8) & 0x7f; 1655 data[1] = div & 0xff; 1656 data[2] = 0x85; 1657 data[3] = pwr << 6; 1658 1659 if (fe->ops.i2c_gate_ctrl) 1660 fe->ops.i2c_gate_ctrl(fe, 1); 1661 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) 1662 return -EIO; 1663 return 0; 1664} 1665 1666static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name) 1667{ 1668#if defined(CONFIG_DVB_SP8870) || defined(CONFIG_DVB_SP8870_MODULE) 1669 struct av7110* av7110 = fe->dvb->priv; 1670 1671 return request_firmware(fw, name, &av7110->dev->pci->dev); 1672#else 1673 return -EINVAL; 1674#endif 1675} 1676 1677static struct sp8870_config alps_tdlb7_config = { 1678 1679 .demod_address = 0x71, 1680 .request_firmware = alps_tdlb7_request_firmware, 1681}; 1682 1683 1684static u8 nexusca_stv0297_inittab[] = { 1685 0x80, 0x01, 1686 0x80, 0x00, 1687 0x81, 0x01, 1688 0x81, 0x00, 1689 0x00, 0x09, 1690 0x01, 0x69, 1691 0x03, 0x00, 1692 0x04, 0x00, 1693 0x07, 0x00, 1694 0x08, 0x00, 1695 0x20, 0x00, 1696 0x21, 0x40, 1697 0x22, 0x00, 1698 0x23, 0x00, 1699 0x24, 0x40, 1700 0x25, 0x88, 1701 0x30, 0xff, 1702 0x31, 0x00, 1703 0x32, 0xff, 1704 0x33, 0x00, 1705 0x34, 0x50, 1706 0x35, 0x7f, 1707 0x36, 0x00, 1708 0x37, 0x20, 1709 0x38, 0x00, 1710 0x40, 0x1c, 1711 0x41, 0xff, 1712 0x42, 0x29, 1713 0x43, 0x00, 1714 0x44, 0xff, 1715 0x45, 0x00, 1716 0x46, 0x00, 1717 0x49, 0x04, 1718 0x4a, 0x00, 1719 0x4b, 0x7b, 1720 0x52, 0x30, 1721 0x55, 0xae, 1722 0x56, 0x47, 1723 0x57, 0xe1, 1724 0x58, 0x3a, 1725 0x5a, 0x1e, 1726 0x5b, 0x34, 1727 0x60, 0x00, 1728 0x63, 0x00, 1729 0x64, 0x00, 1730 0x65, 0x00, 1731 0x66, 0x00, 1732 0x67, 0x00, 1733 0x68, 0x00, 1734 0x69, 0x00, 1735 0x6a, 0x02, 1736 0x6b, 0x00, 1737 0x70, 0xff, 1738 0x71, 0x00, 1739 0x72, 0x00, 1740 0x73, 0x00, 1741 0x74, 0x0c, 1742 0x80, 0x00, 1743 0x81, 0x00, 1744 0x82, 0x00, 1745 0x83, 0x00, 1746 0x84, 0x04, 1747 0x85, 0x80, 1748 0x86, 0x24, 1749 0x87, 0x78, 1750 0x88, 0x10, 1751 0x89, 0x00, 1752 0x90, 0x01, 1753 0x91, 0x01, 1754 0xa0, 0x04, 1755 0xa1, 0x00, 1756 0xa2, 0x00, 1757 0xb0, 0x91, 1758 0xb1, 0x0b, 1759 0xc0, 0x53, 1760 0xc1, 0x70, 1761 0xc2, 0x12, 1762 0xd0, 0x00, 1763 0xd1, 0x00, 1764 0xd2, 0x00, 1765 0xd3, 0x00, 1766 0xd4, 0x00, 1767 0xd5, 0x00, 1768 0xde, 0x00, 1769 0xdf, 0x00, 1770 0x61, 0x49, 1771 0x62, 0x0b, 1772 0x53, 0x08, 1773 0x59, 0x08, 1774 0xff, 0xff, 1775}; 1776 1777static int nexusca_stv0297_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params) 1778{ 1779 struct av7110* av7110 = fe->dvb->priv; 1780 u32 div; 1781 u8 data[4]; 1782 struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) }; 1783 struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 }; 1784 int i; 1785 1786 div = (params->frequency + 36150000 + 31250) / 62500; 1787 1788 data[0] = (div >> 8) & 0x7f; 1789 data[1] = div & 0xff; 1790 data[2] = 0xce; 1791 1792 if (params->frequency < 45000000) 1793 return -EINVAL; 1794 else if (params->frequency < 137000000) 1795 data[3] = 0x01; 1796 else if (params->frequency < 403000000) 1797 data[3] = 0x02; 1798 else if (params->frequency < 860000000) 1799 data[3] = 0x04; 1800 else 1801 return -EINVAL; 1802 1803 if (fe->ops.i2c_gate_ctrl) 1804 fe->ops.i2c_gate_ctrl(fe, 1); 1805 if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) { 1806 printk("nexusca: pll transfer failed!\n"); 1807 return -EIO; 1808 } 1809 1810 // wait for PLL lock 1811 for(i = 0; i < 20; i++) { 1812 if (fe->ops.i2c_gate_ctrl) 1813 fe->ops.i2c_gate_ctrl(fe, 1); 1814 if (i2c_transfer(&av7110->i2c_adap, &readmsg, 1) == 1) 1815 if (data[0] & 0x40) break; 1816 msleep(10); 1817 } 1818 1819 return 0; 1820} 1821 1822static struct stv0297_config nexusca_stv0297_config = { 1823 1824 .demod_address = 0x1C, 1825 .inittab = nexusca_stv0297_inittab, 1826 .invert = 1, 1827 .stop_during_read = 1, 1828}; 1829 1830 1831 1832static int grundig_29504_401_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters *params) 1833{ 1834 struct av7110* av7110 = fe->dvb->priv; 1835 u32 div; 1836 u8 cfg, cpump, band_select; 1837 u8 data[4]; 1838 struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) }; 1839 1840 div = (36125000 + params->frequency) / 166666; 1841 1842 cfg = 0x88; 1843 1844 if (params->frequency < 175000000) cpump = 2; 1845 else if (params->frequency < 390000000) cpump = 1; 1846 else if (params->frequency < 470000000) cpump = 2; 1847 else if (params->frequency < 750000000) cpump = 1; 1848 else cpump = 3; 1849 1850 if (params->frequency < 175000000) band_select = 0x0e; 1851 else if (params->frequency < 470000000) band_select = 0x05; 1852 else band_select = 0x03; 1853 1854 data[0] = (div >> 8) & 0x7f; 1855 data[1] = div & 0xff; 1856 data[2] = ((div >> 10) & 0x60) | cfg; 1857 data[3] = (cpump << 6) | band_select; 1858 1859 if (fe->ops.i2c_gate_ctrl) 1860 fe->ops.i2c_gate_ctrl(fe, 1); 1861 if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) return -EIO; 1862 return 0; 1863} 1864 1865static struct l64781_config grundig_29504_401_config = { 1866 .demod_address = 0x55, 1867}; 1868 1869 1870 1871static int av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status) 1872{ 1873 int ret = 0; 1874 int synced = (status & FE_HAS_LOCK) ? 1 : 0; 1875 1876 av7110->fe_status = status; 1877 1878 if (av7110->fe_synced == synced) 1879 return 0; 1880 1881 if (av7110->playing) { 1882 av7110->fe_synced = synced; 1883 return 0; 1884 } 1885 1886 if (mutex_lock_interruptible(&av7110->pid_mutex)) 1887 return -ERESTARTSYS; 1888 1889 if (synced) { 1890 ret = SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO], 1891 av7110->pids[DMX_PES_AUDIO], 1892 av7110->pids[DMX_PES_TELETEXT], 0, 1893 av7110->pids[DMX_PES_PCR]); 1894 if (!ret) 1895 ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0); 1896 } else { 1897 ret = SetPIDs(av7110, 0, 0, 0, 0, 0); 1898 if (!ret) { 1899 ret = av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0); 1900 if (!ret) 1901 ret = av7110_wait_msgstate(av7110, GPMQBusy); 1902 } 1903 } 1904 1905 if (!ret) 1906 av7110->fe_synced = synced; 1907 1908 mutex_unlock(&av7110->pid_mutex); 1909 return ret; 1910} 1911 1912static int av7110_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters* params) 1913{ 1914 struct av7110* av7110 = fe->dvb->priv; 1915 1916 int ret = av7110_fe_lock_fix(av7110, 0); 1917 if (!ret) { 1918 av7110->saved_fe_params = *params; 1919 ret = av7110->fe_set_frontend(fe, params); 1920 } 1921 return ret; 1922} 1923 1924static int av7110_fe_init(struct dvb_frontend* fe) 1925{ 1926 struct av7110* av7110 = fe->dvb->priv; 1927 1928 int ret = av7110_fe_lock_fix(av7110, 0); 1929 if (!ret) 1930 ret = av7110->fe_init(fe); 1931 return ret; 1932} 1933 1934static int av7110_fe_read_status(struct dvb_frontend* fe, fe_status_t* status) 1935{ 1936 struct av7110* av7110 = fe->dvb->priv; 1937 1938 /* call the real implementation */ 1939 int ret = av7110->fe_read_status(fe, status); 1940 if (!ret) 1941 if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK)) 1942 ret = av7110_fe_lock_fix(av7110, *status); 1943 return ret; 1944} 1945 1946static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe) 1947{ 1948 struct av7110* av7110 = fe->dvb->priv; 1949 1950 int ret = av7110_fe_lock_fix(av7110, 0); 1951 if (!ret) 1952 ret = av7110->fe_diseqc_reset_overload(fe); 1953 return ret; 1954} 1955 1956static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe, 1957 struct dvb_diseqc_master_cmd* cmd) 1958{ 1959 struct av7110* av7110 = fe->dvb->priv; 1960 1961 int ret = av7110_fe_lock_fix(av7110, 0); 1962 if (!ret) { 1963 av7110->saved_master_cmd = *cmd; 1964 ret = av7110->fe_diseqc_send_master_cmd(fe, cmd); 1965 } 1966 return ret; 1967} 1968 1969static int av7110_fe_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t minicmd) 1970{ 1971 struct av7110* av7110 = fe->dvb->priv; 1972 1973 int ret = av7110_fe_lock_fix(av7110, 0); 1974 if (!ret) { 1975 av7110->saved_minicmd = minicmd; 1976 ret = av7110->fe_diseqc_send_burst(fe, minicmd); 1977 } 1978 return ret; 1979} 1980 1981static int av7110_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone) 1982{ 1983 struct av7110* av7110 = fe->dvb->priv; 1984 1985 int ret = av7110_fe_lock_fix(av7110, 0); 1986 if (!ret) { 1987 av7110->saved_tone = tone; 1988 ret = av7110->fe_set_tone(fe, tone); 1989 } 1990 return ret; 1991} 1992 1993static int av7110_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage) 1994{ 1995 struct av7110* av7110 = fe->dvb->priv; 1996 1997 int ret = av7110_fe_lock_fix(av7110, 0); 1998 if (!ret) { 1999 av7110->saved_voltage = voltage; 2000 ret = av7110->fe_set_voltage(fe, voltage); 2001 } 2002 return ret; 2003} 2004 2005static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned long cmd) 2006{ 2007 struct av7110* av7110 = fe->dvb->priv; 2008 2009 int ret = av7110_fe_lock_fix(av7110, 0); 2010 if (!ret) 2011 ret = av7110->fe_dishnetwork_send_legacy_command(fe, cmd); 2012 return ret; 2013} 2014 2015static void dvb_s_recover(struct av7110* av7110) 2016{ 2017 av7110_fe_init(av7110->fe); 2018 2019 av7110_fe_set_voltage(av7110->fe, av7110->saved_voltage); 2020 if (av7110->saved_master_cmd.msg_len) { 2021 msleep(20); 2022 av7110_fe_diseqc_send_master_cmd(av7110->fe, &av7110->saved_master_cmd); 2023 } 2024 msleep(20); 2025 av7110_fe_diseqc_send_burst(av7110->fe, av7110->saved_minicmd); 2026 msleep(20); 2027 av7110_fe_set_tone(av7110->fe, av7110->saved_tone); 2028 2029 av7110_fe_set_frontend(av7110->fe, &av7110->saved_fe_params); 2030} 2031 2032static u8 read_pwm(struct av7110* av7110) 2033{ 2034 u8 b = 0xff; 2035 u8 pwm; 2036 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 }, 2037 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} }; 2038 2039 if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff)) 2040 pwm = 0x48; 2041 2042 return pwm; 2043} 2044 2045static int frontend_init(struct av7110 *av7110) 2046{ 2047 int ret; 2048 2049 if (av7110->dev->pci->subsystem_vendor == 0x110a) { 2050 switch(av7110->dev->pci->subsystem_device) { 2051 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??)) 2052 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config, 2053 &av7110->i2c_adap, read_pwm(av7110)); 2054 if (av7110->fe) { 2055 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params; 2056 } 2057 break; 2058 } 2059 2060 } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) { 2061 switch(av7110->dev->pci->subsystem_device) { 2062 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X 2063 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X 2064 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE 2065 2066 // try the ALPS BSRV2 first of all 2067 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap); 2068 if (av7110->fe) { 2069 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params; 2070 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd; 2071 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst; 2072 av7110->fe->ops.set_tone = av7110_set_tone; 2073 av7110->recover = dvb_s_recover; 2074 break; 2075 } 2076 2077 // try the ALPS BSRU6 now 2078 av7110->fe = dvb_attach(stv0299_attach, &alps_bsru6_config, &av7110->i2c_adap); 2079 if (av7110->fe) { 2080 av7110->fe->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params; 2081 av7110->fe->tuner_priv = &av7110->i2c_adap; 2082 2083 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd; 2084 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst; 2085 av7110->fe->ops.set_tone = av7110_set_tone; 2086 av7110->recover = dvb_s_recover; 2087 break; 2088 } 2089 2090 // Try the grundig 29504-451 2091 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap); 2092 if (av7110->fe) { 2093 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params; 2094 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd; 2095 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst; 2096 av7110->fe->ops.set_tone = av7110_set_tone; 2097 av7110->recover = dvb_s_recover; 2098 break; 2099 } 2100 2101 /* Try DVB-C cards */ 2102 switch(av7110->dev->pci->subsystem_device) { 2103 case 0x0000: 2104 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */ 2105 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config, &av7110->i2c_adap, 2106 read_pwm(av7110)); 2107 if (av7110->fe) { 2108 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params; 2109 } 2110 break; 2111 case 0x0003: 2112 /* Hauppauge DVB-C 2.1 VES1820/ALPS TDBE2 */ 2113 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap, 2114 read_pwm(av7110)); 2115 if (av7110->fe) { 2116 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params; 2117 } 2118 break; 2119 } 2120 break; 2121 2122 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X 2123 // try ALPS TDLB7 first, then Grundig 29504-401 2124 av7110->fe = dvb_attach(sp8870_attach, &alps_tdlb7_config, &av7110->i2c_adap); 2125 if (av7110->fe) { 2126 av7110->fe->ops.tuner_ops.set_params = alps_tdlb7_tuner_set_params; 2127 break; 2128 } 2129 /* fall-thru */ 2130 2131 case 0x0008: // Hauppauge/TT DVB-T 2132 // Grundig 29504-401 2133 av7110->fe = dvb_attach(l64781_attach, &grundig_29504_401_config, &av7110->i2c_adap); 2134 if (av7110->fe) 2135 av7110->fe->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params; 2136 break; 2137 2138 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X 2139 2140 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110)); 2141 if (av7110->fe) { 2142 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params; 2143 } 2144 break; 2145 2146 case 0x0004: // Galaxis DVB-S rev1.3 2147 /* ALPS BSRV2 */ 2148 av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap); 2149 if (av7110->fe) { 2150 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params; 2151 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd; 2152 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst; 2153 av7110->fe->ops.set_tone = av7110_set_tone; 2154 av7110->recover = dvb_s_recover; 2155 } 2156 break; 2157 2158 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */ 2159 /* Grundig 29504-451 */ 2160 av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap); 2161 if (av7110->fe) { 2162 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params; 2163 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd; 2164 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst; 2165 av7110->fe->ops.set_tone = av7110_set_tone; 2166 av7110->recover = dvb_s_recover; 2167 } 2168 break; 2169 2170 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X 2171 2172 av7110->fe = dvb_attach(stv0297_attach, &nexusca_stv0297_config, &av7110->i2c_adap); 2173 if (av7110->fe) { 2174 av7110->fe->ops.tuner_ops.set_params = nexusca_stv0297_tuner_set_params; 2175 2176 /* set TDA9819 into DVB mode */ 2177 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD) 2178 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF) 2179 2180 /* tuner on this needs a slower i2c bus speed */ 2181 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240; 2182 break; 2183 } 2184 break; 2185 2186 case 0x000E: /* Hauppauge/TT Nexus-S rev 2.3 */ 2187 /* ALPS BSBE1 */ 2188 av7110->fe = dvb_attach(stv0299_attach, &alps_bsbe1_config, &av7110->i2c_adap); 2189 if (av7110->fe) { 2190 av7110->fe->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params; 2191 av7110->fe->tuner_priv = &av7110->i2c_adap; 2192 2193 if (dvb_attach(lnbp21_attach, av7110->fe, &av7110->i2c_adap, 0, 0) == NULL) { 2194 printk("dvb-ttpci: LNBP21 not found!\n"); 2195 if (av7110->fe->ops.release) 2196 av7110->fe->ops.release(av7110->fe); 2197 av7110->fe = NULL; 2198 } else { 2199 av7110->fe->ops.dishnetwork_send_legacy_command = NULL; 2200 av7110->recover = dvb_s_recover; 2201 } 2202 } 2203 break; 2204 } 2205 } 2206 2207 if (!av7110->fe) { 2208 ret = -ENOMEM; 2209 printk("dvb-ttpci: A frontend driver was not found for device %04x/%04x subsystem %04x/%04x\n", 2210 av7110->dev->pci->vendor, 2211 av7110->dev->pci->device, 2212 av7110->dev->pci->subsystem_vendor, 2213 av7110->dev->pci->subsystem_device); 2214 } else { 2215 FE_FUNC_OVERRIDE(av7110->fe->ops.init, av7110->fe_init, av7110_fe_init); 2216 FE_FUNC_OVERRIDE(av7110->fe->ops.read_status, av7110->fe_read_status, av7110_fe_read_status); 2217 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload); 2218 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd); 2219 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst); 2220 FE_FUNC_OVERRIDE(av7110->fe->ops.set_tone, av7110->fe_set_tone, av7110_fe_set_tone); 2221 FE_FUNC_OVERRIDE(av7110->fe->ops.set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage;) 2222 FE_FUNC_OVERRIDE(av7110->fe->ops.dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command); 2223 FE_FUNC_OVERRIDE(av7110->fe->ops.set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend); 2224 2225 ret = dvb_register_frontend(&av7110->dvb_adapter, av7110->fe); 2226 if (ret < 0) { 2227 printk("av7110: Frontend registration failed!\n"); 2228 dvb_frontend_detach(av7110->fe); 2229 av7110->fe = NULL; 2230 } 2231 } 2232 return ret; 2233} 2234 2235/* Budgetpatch note: 2236 * Original hardware design by Roberto Deza: 2237 * There is a DVB_Wiki at 2238 * http://212.227.36.83/linuxtv/wiki/index.php/Main_Page 2239 * where is described this 'DVB TT Budget Patch', on Card Modding: 2240 * http://212.227.36.83/linuxtv/wiki/index.php/DVB_TT_Budget_Patch 2241 * On the short description there is also a link to a external file, 2242 * with more details: 2243 * http://perso.wanadoo.es/jesussolano/Ttf_tsc1.zip 2244 * 2245 * New software triggering design by Emard that works on 2246 * original Roberto Deza's hardware: 2247 * 2248 * rps1 code for budgetpatch will copy internal HS event to GPIO3 pin. 2249 * GPIO3 is in budget-patch hardware connectd to port B VSYNC 2250 * HS is an internal event of 7146, accessible with RPS 2251 * and temporarily raised high every n lines 2252 * (n in defined in the RPS_THRESH1 counter threshold) 2253 * I think HS is raised high on the beginning of the n-th line 2254 * and remains high until this n-th line that triggered 2255 * it is completely received. When the receiption of n-th line 2256 * ends, HS is lowered. 2257 * 2258 * To transmit data over DMA, 7146 needs changing state at 2259 * port B VSYNC pin. Any changing of port B VSYNC will 2260 * cause some DMA data transfer, with more or less packets loss. 2261 * It depends on the phase and frequency of VSYNC and 2262 * the way of 7146 is instructed to trigger on port B (defined 2263 * in DD1_INIT register, 3rd nibble from the right valid 2264 * numbers are 0-7, see datasheet) 2265 * 2266 * The correct triggering can minimize packet loss, 2267 * dvbtraffic should give this stable bandwidths: 2268 * 22k transponder = 33814 kbit/s 2269 * 27.5k transponder = 38045 kbit/s 2270 * by experiment it is found that the best results 2271 * (stable bandwidths and almost no packet loss) 2272 * are obtained using DD1_INIT triggering number 2 2273 * (Va at rising edge of VS Fa = HS x VS-failing forced toggle) 2274 * and a VSYNC phase that occurs in the middle of DMA transfer 2275 * (about byte 188*512=96256 in the DMA window). 2276 * 2277 * Phase of HS is still not clear to me how to control, 2278 * It just happens to be so. It can be seen if one enables 2279 * RPS_IRQ and print Event Counter 1 in vpeirq(). Every 2280 * time RPS_INTERRUPT is called, the Event Counter 1 will 2281 * increment. That's how the 7146 is programmed to do event 2282 * counting in this budget-patch.c 2283 * I *think* HPS setting has something to do with the phase 2284 * of HS but I cant be 100% sure in that. 2285 * 2286 * hardware debug note: a working budget card (including budget patch) 2287 * with vpeirq() interrupt setup in mode "0x90" (every 64K) will 2288 * generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes 2289 * and that means 3*25=75 Hz of interrupt freqency, as seen by 2290 * watch cat /proc/interrupts 2291 * 2292 * If this frequency is 3x lower (and data received in the DMA 2293 * buffer don't start with 0x47, but in the middle of packets, 2294 * whose lengths appear to be like 188 292 188 104 etc. 2295 * this means VSYNC line is not connected in the hardware. 2296 * (check soldering pcb and pins) 2297 * The same behaviour of missing VSYNC can be duplicated on budget 2298 * cards, by seting DD1_INIT trigger mode 7 in 3rd nibble. 2299 */ 2300static int __devinit av7110_attach(struct saa7146_dev* dev, 2301 struct saa7146_pci_extension_data *pci_ext) 2302{ 2303 const int length = TS_WIDTH * TS_HEIGHT; 2304 struct pci_dev *pdev = dev->pci; 2305 struct av7110 *av7110; 2306 struct task_struct *thread; 2307 int ret, count = 0; 2308 2309 dprintk(4, "dev: %p\n", dev); 2310 2311 /* Set RPS_IRQ to 1 to track rps1 activity. 2312 * Enabling this won't send any interrupt to PC CPU. 2313 */ 2314#define RPS_IRQ 0 2315 2316 if (budgetpatch == 1) { 2317 budgetpatch = 0; 2318 /* autodetect the presence of budget patch 2319 * this only works if saa7146 has been recently 2320 * reset with with MASK_31 to MC1 2321 * 2322 * will wait for VBI_B event (vertical blank at port B) 2323 * and will reset GPIO3 after VBI_B is detected. 2324 * (GPIO3 should be raised high by CPU to 2325 * test if GPIO3 will generate vertical blank signal 2326 * in budget patch GPIO3 is connected to VSYNC_B 2327 */ 2328 2329 /* RESET SAA7146 */ 2330 saa7146_write(dev, MC1, MASK_31); 2331 /* autodetection success seems to be time-dependend after reset */ 2332 2333 /* Fix VSYNC level */ 2334 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); 2335 /* set vsync_b triggering */ 2336 saa7146_write(dev, DD1_STREAM_B, 0); 2337 /* port B VSYNC at rising edge */ 2338 saa7146_write(dev, DD1_INIT, 0x00000200); 2339 saa7146_write(dev, BRS_CTRL, 0x00000000); // VBI 2340 saa7146_write(dev, MC2, 2341 1 * (MASK_08 | MASK_24) | // BRS control 2342 0 * (MASK_09 | MASK_25) | // a 2343 1 * (MASK_10 | MASK_26) | // b 2344 0 * (MASK_06 | MASK_22) | // HPS_CTRL1 2345 0 * (MASK_05 | MASK_21) | // HPS_CTRL2 2346 0 * (MASK_01 | MASK_15) // DEBI 2347 ); 2348 2349 /* start writing RPS1 code from beginning */ 2350 count = 0; 2351 /* Disable RPS1 */ 2352 saa7146_write(dev, MC1, MASK_29); 2353 /* RPS1 timeout disable */ 2354 saa7146_write(dev, RPS_TOV1, 0); 2355 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_VBI_B)); 2356 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2))); 2357 WRITE_RPS1(cpu_to_le32(GPIO3_MSK)); 2358 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTLO<<24)); 2359#if RPS_IRQ 2360 /* issue RPS1 interrupt to increment counter */ 2361 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT)); 2362#endif 2363 WRITE_RPS1(cpu_to_le32(CMD_STOP)); 2364 /* Jump to begin of RPS program as safety measure (p37) */ 2365 WRITE_RPS1(cpu_to_le32(CMD_JUMP)); 2366 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle)); 2367 2368#if RPS_IRQ 2369 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53) 2370 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled 2371 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called 2372 */ 2373 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 ); 2374 /* set event counter 1 treshold to maximum allowed value (rEC p55) */ 2375 saa7146_write(dev, ECT1R, 0x3fff ); 2376#endif 2377 /* Set RPS1 Address register to point to RPS code (r108 p42) */ 2378 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle); 2379 /* Enable RPS1, (rFC p33) */ 2380 saa7146_write(dev, MC1, (MASK_13 | MASK_29 )); 2381 2382 mdelay(10); 2383 /* now send VSYNC_B to rps1 by rising GPIO3 */ 2384 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI); 2385 mdelay(10); 2386 /* if rps1 responded by lowering the GPIO3, 2387 * then we have budgetpatch hardware 2388 */ 2389 if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) { 2390 budgetpatch = 1; 2391 printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n"); 2392 } 2393 /* Disable RPS1 */ 2394 saa7146_write(dev, MC1, ( MASK_29 )); 2395#if RPS_IRQ 2396 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff ); 2397#endif 2398 } 2399 2400 /* prepare the av7110 device struct */ 2401 av7110 = kzalloc(sizeof(struct av7110), GFP_KERNEL); 2402 if (!av7110) { 2403 dprintk(1, "out of memory\n"); 2404 return -ENOMEM; 2405 } 2406 2407 av7110->card_name = (char*) pci_ext->ext_priv; 2408 av7110->dev = dev; 2409 dev->ext_priv = av7110; 2410 2411 ret = get_firmware(av7110); 2412 if (ret < 0) 2413 goto err_kfree_0; 2414 2415 ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name, 2416 THIS_MODULE, &dev->pci->dev); 2417 if (ret < 0) 2418 goto err_put_firmware_1; 2419 2420 /* the Siemens DVB needs this if you want to have the i2c chips 2421 get recognized before the main driver is fully loaded */ 2422 saa7146_write(dev, GPIO_CTRL, 0x500000); 2423 2424#ifdef I2C_ADAP_CLASS_TV_DIGITAL 2425 av7110->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL; 2426#else 2427 av7110->i2c_adap.class = I2C_CLASS_TV_DIGITAL; 2428#endif 2429 strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name)); 2430 2431 saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */ 2432 2433 ret = i2c_add_adapter(&av7110->i2c_adap); 2434 if (ret < 0) 2435 goto err_dvb_unregister_adapter_2; 2436 2437 ttpci_eeprom_parse_mac(&av7110->i2c_adap, 2438 av7110->dvb_adapter.proposed_mac); 2439 ret = -ENOMEM; 2440 2441 if (budgetpatch) { 2442 spin_lock_init(&av7110->feedlock1); 2443 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length, 2444 &av7110->pt); 2445 if (!av7110->grabbing) 2446 goto err_i2c_del_3; 2447 2448 saa7146_write(dev, PCI_BT_V1, 0x1c1f101f); 2449 saa7146_write(dev, BCS_CTRL, 0x80400040); 2450 /* set dd1 stream a & b */ 2451 saa7146_write(dev, DD1_STREAM_B, 0x00000000); 2452 saa7146_write(dev, DD1_INIT, 0x03000200); 2453 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26)); 2454 saa7146_write(dev, BRS_CTRL, 0x60000000); 2455 saa7146_write(dev, BASE_ODD3, 0); 2456 saa7146_write(dev, BASE_EVEN3, 0); 2457 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT); 2458 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90); 2459 2460 saa7146_write(dev, PITCH3, TS_WIDTH); 2461 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH); 2462 2463 /* upload all */ 2464 saa7146_write(dev, MC2, 0x077c077c); 2465 saa7146_write(dev, GPIO_CTRL, 0x000000); 2466#if RPS_IRQ 2467 /* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53) 2468 * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled 2469 * use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called 2470 */ 2471 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 ); 2472 /* set event counter 1 treshold to maximum allowed value (rEC p55) */ 2473 saa7146_write(dev, ECT1R, 0x3fff ); 2474#endif 2475 /* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */ 2476 count = 0; 2477 2478 /* Wait Source Line Counter Threshold (p36) */ 2479 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | EVT_HS)); 2480 /* Set GPIO3=1 (p42) */ 2481 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2))); 2482 WRITE_RPS1(cpu_to_le32(GPIO3_MSK)); 2483 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTHI<<24)); 2484#if RPS_IRQ 2485 /* issue RPS1 interrupt */ 2486 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT)); 2487#endif 2488 /* Wait reset Source Line Counter Threshold (p36) */ 2489 WRITE_RPS1(cpu_to_le32(CMD_PAUSE | RPS_INV | EVT_HS)); 2490 /* Set GPIO3=0 (p42) */ 2491 WRITE_RPS1(cpu_to_le32(CMD_WR_REG_MASK | (GPIO_CTRL>>2))); 2492 WRITE_RPS1(cpu_to_le32(GPIO3_MSK)); 2493 WRITE_RPS1(cpu_to_le32(SAA7146_GPIO_OUTLO<<24)); 2494#if RPS_IRQ 2495 /* issue RPS1 interrupt */ 2496 WRITE_RPS1(cpu_to_le32(CMD_INTERRUPT)); 2497#endif 2498 /* Jump to begin of RPS program (p37) */ 2499 WRITE_RPS1(cpu_to_le32(CMD_JUMP)); 2500 WRITE_RPS1(cpu_to_le32(dev->d_rps1.dma_handle)); 2501 2502 /* Fix VSYNC level */ 2503 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); 2504 /* Set RPS1 Address register to point to RPS code (r108 p42) */ 2505 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle); 2506 /* Set Source Line Counter Threshold, using BRS (rCC p43) 2507 * It generates HS event every TS_HEIGHT lines 2508 * this is related to TS_WIDTH set in register 2509 * NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits 2510 * are set to TS_WIDTH bytes (TS_WIDTH=2*188), 2511 * then RPS_THRESH1 should be set to trigger 2512 * every TS_HEIGHT (512) lines. 2513 */ 2514 saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 ); 2515 2516 /* Enable RPS1 (rFC p33) */ 2517 saa7146_write(dev, MC1, (MASK_13 | MASK_29)); 2518 2519 /* end of budgetpatch register initialization */ 2520 tasklet_init (&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110); 2521 } else { 2522 saa7146_write(dev, PCI_BT_V1, 0x1c00101f); 2523 saa7146_write(dev, BCS_CTRL, 0x80400040); 2524 2525 /* set dd1 stream a & b */ 2526 saa7146_write(dev, DD1_STREAM_B, 0x00000000); 2527 saa7146_write(dev, DD1_INIT, 0x03000000); 2528 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26)); 2529 2530 /* upload all */ 2531 saa7146_write(dev, MC2, 0x077c077c); 2532 saa7146_write(dev, GPIO_CTRL, 0x000000); 2533 } 2534 2535 tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110); 2536 tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110); 2537 2538 mutex_init(&av7110->pid_mutex); 2539 2540 /* locks for data transfers from/to AV7110 */ 2541 spin_lock_init(&av7110->debilock); 2542 mutex_init(&av7110->dcomlock); 2543 av7110->debitype = -1; 2544 2545 /* default OSD window */ 2546 av7110->osdwin = 1; 2547 mutex_init(&av7110->osd_mutex); 2548 2549 /* TV standard */ 2550 av7110->vidmode = tv_standard == 1 ? VIDEO_MODE_NTSC : VIDEO_MODE_PAL; 2551 2552 /* ARM "watchdog" */ 2553 init_waitqueue_head(&av7110->arm_wait); 2554 av7110->arm_thread = NULL; 2555 2556 /* allocate and init buffers */ 2557 av7110->debi_virt = pci_alloc_consistent(pdev, 8192, &av7110->debi_bus); 2558 if (!av7110->debi_virt) 2559 goto err_saa71466_vfree_4; 2560 2561 2562 av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS); 2563 if (!av7110->iobuf) 2564 goto err_pci_free_5; 2565 2566 ret = av7110_av_init(av7110); 2567 if (ret < 0) 2568 goto err_iobuf_vfree_6; 2569 2570 /* init BMP buffer */ 2571 av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN; 2572 init_waitqueue_head(&av7110->bmpq); 2573 2574 ret = av7110_ca_init(av7110); 2575 if (ret < 0) 2576 goto err_av7110_av_exit_7; 2577 2578 /* load firmware into AV7110 cards */ 2579 ret = av7110_bootarm(av7110); 2580 if (ret < 0) 2581 goto err_av7110_ca_exit_8; 2582 2583 ret = av7110_firmversion(av7110); 2584 if (ret < 0) 2585 goto err_stop_arm_9; 2586 2587 if (FW_VERSION(av7110->arm_app)<0x2501) 2588 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. " 2589 "System might be unstable!\n", FW_VERSION(av7110->arm_app)); 2590 2591 thread = kthread_run(arm_thread, (void *) av7110, "arm_mon"); 2592 if (IS_ERR(thread)) { 2593 ret = PTR_ERR(thread); 2594 goto err_stop_arm_9; 2595 } 2596 av7110->arm_thread = thread; 2597 2598 /* set initial volume in mixer struct */ 2599 av7110->mixer.volume_left = volume; 2600 av7110->mixer.volume_right = volume; 2601 2602 init_av7110_av(av7110); 2603 2604 ret = av7110_register(av7110); 2605 if (ret < 0) 2606 goto err_arm_thread_stop_10; 2607 2608 /* special case DVB-C: these cards have an analog tuner 2609 plus need some special handling, so we have separate 2610 saa7146_ext_vv data for these... */ 2611 ret = av7110_init_v4l(av7110); 2612 if (ret < 0) 2613 goto err_av7110_unregister_11; 2614 2615 av7110->dvb_adapter.priv = av7110; 2616 ret = frontend_init(av7110); 2617 if (ret < 0) 2618 goto err_av7110_exit_v4l_12; 2619 2620#if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE) 2621 av7110_ir_init(av7110); 2622#endif 2623 printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num); 2624 av7110_num++; 2625out: 2626 return ret; 2627 2628err_av7110_exit_v4l_12: 2629 av7110_exit_v4l(av7110); 2630err_av7110_unregister_11: 2631 dvb_unregister(av7110); 2632err_arm_thread_stop_10: 2633 av7110_arm_sync(av7110); 2634err_stop_arm_9: 2635 /* Nothing to do. Rejoice. */ 2636err_av7110_ca_exit_8: 2637 av7110_ca_exit(av7110); 2638err_av7110_av_exit_7: 2639 av7110_av_exit(av7110); 2640err_iobuf_vfree_6: 2641 vfree(av7110->iobuf); 2642err_pci_free_5: 2643 pci_free_consistent(pdev, 8192, av7110->debi_virt, av7110->debi_bus); 2644err_saa71466_vfree_4: 2645 if (av7110->grabbing) 2646 saa7146_vfree_destroy_pgtable(pdev, av7110->grabbing, &av7110->pt); 2647err_i2c_del_3: 2648 i2c_del_adapter(&av7110->i2c_adap); 2649err_dvb_unregister_adapter_2: 2650 dvb_unregister_adapter(&av7110->dvb_adapter); 2651err_put_firmware_1: 2652 put_firmware(av7110); 2653err_kfree_0: 2654 kfree(av7110); 2655 goto out; 2656} 2657 2658static int __devexit av7110_detach(struct saa7146_dev* saa) 2659{ 2660 struct av7110 *av7110 = saa->ext_priv; 2661 dprintk(4, "%p\n", av7110); 2662 2663#if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE) 2664 av7110_ir_exit(av7110); 2665#endif 2666 if (budgetpatch) { 2667 /* Disable RPS1 */ 2668 saa7146_write(saa, MC1, MASK_29); 2669 /* VSYNC LOW (inactive) */ 2670 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO); 2671 saa7146_write(saa, MC1, MASK_20); /* DMA3 off */ 2672 SAA7146_IER_DISABLE(saa, MASK_10); 2673 SAA7146_ISR_CLEAR(saa, MASK_10); 2674 msleep(50); 2675 tasklet_kill(&av7110->vpe_tasklet); 2676 saa7146_vfree_destroy_pgtable(saa->pci, av7110->grabbing, &av7110->pt); 2677 } 2678 av7110_exit_v4l(av7110); 2679 2680 av7110_arm_sync(av7110); 2681 2682 tasklet_kill(&av7110->debi_tasklet); 2683 tasklet_kill(&av7110->gpio_tasklet); 2684 2685 dvb_unregister(av7110); 2686 2687 SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03); 2688 SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03); 2689 2690 av7110_ca_exit(av7110); 2691 av7110_av_exit(av7110); 2692 2693 vfree(av7110->iobuf); 2694 pci_free_consistent(saa->pci, 8192, av7110->debi_virt, 2695 av7110->debi_bus); 2696 2697 i2c_del_adapter(&av7110->i2c_adap); 2698 2699 dvb_unregister_adapter (&av7110->dvb_adapter); 2700 2701 av7110_num--; 2702 2703 put_firmware(av7110); 2704 2705 kfree(av7110); 2706 2707 saa->ext_priv = NULL; 2708 2709 return 0; 2710} 2711 2712 2713static void av7110_irq(struct saa7146_dev* dev, u32 *isr) 2714{ 2715 struct av7110 *av7110 = dev->ext_priv; 2716 2717 //print_time("av7110_irq"); 2718 2719 /* Note: Don't try to handle the DEBI error irq (MASK_18), in 2720 * intel mode the timeout is asserted all the time... 2721 */ 2722 2723 if (*isr & MASK_19) { 2724 //printk("av7110_irq: DEBI\n"); 2725 /* Note 1: The DEBI irq is level triggered: We must enable it 2726 * only after we started a DMA xfer, and disable it here 2727 * immediately, or it will be signalled all the time while 2728 * DEBI is idle. 2729 * Note 2: You would think that an irq which is masked is 2730 * not signalled by the hardware. Not so for the SAA7146: 2731 * An irq is signalled as long as the corresponding bit 2732 * in the ISR is set, and disabling irqs just prevents the 2733 * hardware from setting the ISR bit. This means a) that we 2734 * must clear the ISR *after* disabling the irq (which is why 2735 * we must do it here even though saa7146_core did it already), 2736 * and b) that if we were to disable an edge triggered irq 2737 * (like the gpio irqs sadly are) temporarily we would likely 2738 * loose some. This sucks :-( 2739 */ 2740 SAA7146_IER_DISABLE(av7110->dev, MASK_19); 2741 SAA7146_ISR_CLEAR(av7110->dev, MASK_19); 2742 tasklet_schedule(&av7110->debi_tasklet); 2743 } 2744 2745 if (*isr & MASK_03) { 2746 //printk("av7110_irq: GPIO\n"); 2747 tasklet_schedule(&av7110->gpio_tasklet); 2748 } 2749 2750 if ((*isr & MASK_10) && budgetpatch) 2751 tasklet_schedule(&av7110->vpe_tasklet); 2752} 2753 2754 2755static struct saa7146_extension av7110_extension; 2756 2757#define MAKE_AV7110_INFO(x_var,x_name) \ 2758static struct saa7146_pci_extension_data x_var = { \ 2759 .ext_priv = x_name, \ 2760 .ext = &av7110_extension } 2761 2762MAKE_AV7110_INFO(tts_1_X_fsc,"Technotrend/Hauppauge WinTV DVB-S rev1.X or Fujitsu Siemens DVB-C"); 2763MAKE_AV7110_INFO(ttt_1_X, "Technotrend/Hauppauge WinTV DVB-T rev1.X"); 2764MAKE_AV7110_INFO(ttc_1_X, "Technotrend/Hauppauge WinTV Nexus-CA rev1.X"); 2765MAKE_AV7110_INFO(ttc_2_X, "Technotrend/Hauppauge WinTV DVB-C rev2.X"); 2766MAKE_AV7110_INFO(tts_2_X, "Technotrend/Hauppauge WinTV Nexus-S rev2.X"); 2767MAKE_AV7110_INFO(tts_2_3, "Technotrend/Hauppauge WinTV Nexus-S rev2.3"); 2768MAKE_AV7110_INFO(tts_1_3se, "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE"); 2769MAKE_AV7110_INFO(ttt, "Technotrend/Hauppauge DVB-T"); 2770MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C"); 2771MAKE_AV7110_INFO(fss, "Fujitsu Siemens DVB-S rev1.6"); 2772MAKE_AV7110_INFO(gxs_1_3, "Galaxis DVB-S rev1.3"); 2773 2774static struct pci_device_id pci_tbl[] = { 2775 MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000), 2776 MAKE_EXTENSION_PCI(tts_1_X_fsc, 0x13c2, 0x0000), 2777 MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001), 2778 MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002), 2779 MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003), 2780 MAKE_EXTENSION_PCI(gxs_1_3, 0x13c2, 0x0004), 2781 MAKE_EXTENSION_PCI(fss, 0x13c2, 0x0006), 2782 MAKE_EXTENSION_PCI(ttt, 0x13c2, 0x0008), 2783 MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a), 2784 MAKE_EXTENSION_PCI(tts_2_3, 0x13c2, 0x000e), 2785 MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002), 2786 2787/* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1 2788/* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v???? 2789 2790 { 2791 .vendor = 0, 2792 } 2793}; 2794 2795MODULE_DEVICE_TABLE(pci, pci_tbl); 2796 2797 2798static struct saa7146_extension av7110_extension = { 2799 .name = "dvb", 2800 .flags = SAA7146_USE_I2C_IRQ, 2801 2802 .module = THIS_MODULE, 2803 .pci_tbl = &pci_tbl[0], 2804 .attach = av7110_attach, 2805 .detach = __devexit_p(av7110_detach), 2806 2807 .irq_mask = MASK_19 | MASK_03 | MASK_10, 2808 .irq_func = av7110_irq, 2809}; 2810 2811 2812static int __init av7110_init(void) 2813{ 2814 int retval; 2815 retval = saa7146_register_extension(&av7110_extension); 2816 return retval; 2817} 2818 2819 2820static void __exit av7110_exit(void) 2821{ 2822 saa7146_unregister_extension(&av7110_extension); 2823} 2824 2825module_init(av7110_init); 2826module_exit(av7110_exit); 2827 2828MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by " 2829 "Siemens, Technotrend, Hauppauge"); 2830MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others"); 2831MODULE_LICENSE("GPL"); 2832