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