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