1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * budget-ci.ko: driver for the SAA7146 based Budget DVB cards 4 * with CI (but without analog video input) 5 * 6 * Compiled from various sources by Michael Hunold <michael@mihu.de> 7 * 8 * msp430 IR support contributed by Jack Thomasson <jkt@Helius.COM> 9 * partially based on the Siemens DVB driver by Ralph+Marcus Metzler 10 * 11 * CI interface support (c) 2004 Andrew de Quincey <adq_dvb@lidskialf.net> 12 * 13 * the project's page is at https://linuxtv.org 14 */ 15 16 #include <linux/module.h> 17 #include <linux/errno.h> 18 #include <linux/slab.h> 19 #include <linux/interrupt.h> 20 #include <linux/spinlock.h> 21 #include <linux/workqueue.h> 22 #include <media/rc-core.h> 23 24 #include "budget.h" 25 26 #include <media/dvb_ca_en50221.h> 27 #include "stv0299.h" 28 #include "stv0297.h" 29 #include "tda1004x.h" 30 #include "stb0899_drv.h" 31 #include "stb0899_reg.h" 32 #include "stb0899_cfg.h" 33 #include "stb6100.h" 34 #include "stb6100_cfg.h" 35 #include "lnbp21.h" 36 #include "bsbe1.h" 37 #include "bsru6.h" 38 #include "tda1002x.h" 39 #include "tda827x.h" 40 #include "bsbe1-d01a.h" 41 42 #define MODULE_NAME "budget_ci" 43 44 /* 45 * Regarding DEBIADDR_IR: 46 * Some CI modules hang if random addresses are read. 47 * Using address 0x4000 for the IR read means that we 48 * use the same address as for CI version, which should 49 * be a safe default. 50 */ 51 #define DEBIADDR_IR 0x4000 52 #define DEBIADDR_CICONTROL 0x0000 53 #define DEBIADDR_CIVERSION 0x4000 54 #define DEBIADDR_IO 0x1000 55 #define DEBIADDR_ATTR 0x3000 56 57 #define CICONTROL_RESET 0x01 58 #define CICONTROL_ENABLETS 0x02 59 #define CICONTROL_CAMDETECT 0x08 60 61 #define DEBICICTL 0x00420000 62 #define DEBICICAM 0x02420000 63 64 #define SLOTSTATUS_NONE 1 65 #define SLOTSTATUS_PRESENT 2 66 #define SLOTSTATUS_RESET 4 67 #define SLOTSTATUS_READY 8 68 #define SLOTSTATUS_OCCUPIED (SLOTSTATUS_PRESENT|SLOTSTATUS_RESET|SLOTSTATUS_READY) 69 70 /* RC5 device wildcard */ 71 #define IR_DEVICE_ANY 255 72 73 static int rc5_device = -1; 74 module_param(rc5_device, int, 0644); 75 MODULE_PARM_DESC(rc5_device, "only IR commands to given RC5 device (device = 0 - 31, any device = 255, default: autodetect)"); 76 77 static int ir_debug; 78 module_param(ir_debug, int, 0644); 79 MODULE_PARM_DESC(ir_debug, "enable debugging information for IR decoding"); 80 81 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 82 83 struct budget_ci_ir { 84 struct rc_dev *dev; 85 struct work_struct msp430_irq_bh_work; 86 char name[72]; /* 40 + 32 for (struct saa7146_dev).name */ 87 char phys[32]; 88 int rc5_device; 89 u32 ir_key; 90 bool have_command; 91 bool full_rc5; /* Outputs a full RC5 code */ 92 }; 93 94 struct budget_ci { 95 struct budget budget; 96 struct work_struct ciintf_irq_bh_work; 97 int slot_status; 98 int ci_irq; 99 struct dvb_ca_en50221 ca; 100 struct budget_ci_ir ir; 101 u8 tuner_pll_address; /* used for philips_tdm1316l configs */ 102 }; 103 104 static void msp430_ir_interrupt(struct work_struct *t) 105 { 106 struct budget_ci_ir *ir = from_work(ir, t, msp430_irq_bh_work); 107 struct budget_ci *budget_ci = container_of(ir, typeof(*budget_ci), ir); 108 struct rc_dev *dev = budget_ci->ir.dev; 109 u32 command = ttpci_budget_debiread(&budget_ci->budget, DEBINOSWAP, DEBIADDR_IR, 2, 1, 0) >> 8; 110 111 /* 112 * The msp430 chip can generate two different bytes, command and device 113 * 114 * type1: X1CCCCCC, C = command bits (0 - 63) 115 * type2: X0TDDDDD, D = device bits (0 - 31), T = RC5 toggle bit 116 * 117 * Each signal from the remote control can generate one or more command 118 * bytes and one or more device bytes. For the repeated bytes, the 119 * highest bit (X) is set. The first command byte is always generated 120 * before the first device byte. Other than that, no specific order 121 * seems to apply. To make life interesting, bytes can also be lost. 122 * 123 * Only when we have a command and device byte, a keypress is 124 * generated. 125 */ 126 127 if (ir_debug) 128 pr_info("received byte 0x%02x\n", command); 129 130 /* Remove repeat bit, we use every command */ 131 command = command & 0x7f; 132 133 /* Is this a RC5 command byte? */ 134 if (command & 0x40) { 135 budget_ci->ir.have_command = true; 136 budget_ci->ir.ir_key = command & 0x3f; 137 return; 138 } 139 140 /* It's a RC5 device byte */ 141 if (!budget_ci->ir.have_command) 142 return; 143 budget_ci->ir.have_command = false; 144 145 if (budget_ci->ir.rc5_device != IR_DEVICE_ANY && 146 budget_ci->ir.rc5_device != (command & 0x1f)) 147 return; 148 149 if (budget_ci->ir.full_rc5) { 150 rc_keydown(dev, RC_PROTO_RC5, 151 RC_SCANCODE_RC5(budget_ci->ir.rc5_device, budget_ci->ir.ir_key), 152 !!(command & 0x20)); 153 return; 154 } 155 156 /* FIXME: We should generate complete scancodes for all devices */ 157 rc_keydown(dev, RC_PROTO_UNKNOWN, budget_ci->ir.ir_key, 158 !!(command & 0x20)); 159 } 160 161 static int msp430_ir_init(struct budget_ci *budget_ci) 162 { 163 struct saa7146_dev *saa = budget_ci->budget.dev; 164 struct rc_dev *dev; 165 int error; 166 167 dev = rc_allocate_device(RC_DRIVER_SCANCODE); 168 if (!dev) { 169 pr_err("IR interface initialisation failed\n"); 170 return -ENOMEM; 171 } 172 173 snprintf(budget_ci->ir.name, sizeof(budget_ci->ir.name), 174 "Budget-CI dvb ir receiver %s", saa->name); 175 snprintf(budget_ci->ir.phys, sizeof(budget_ci->ir.phys), 176 "pci-%s/ir0", pci_name(saa->pci)); 177 178 dev->driver_name = MODULE_NAME; 179 dev->device_name = budget_ci->ir.name; 180 dev->input_phys = budget_ci->ir.phys; 181 dev->input_id.bustype = BUS_PCI; 182 dev->input_id.version = 1; 183 if (saa->pci->subsystem_vendor) { 184 dev->input_id.vendor = saa->pci->subsystem_vendor; 185 dev->input_id.product = saa->pci->subsystem_device; 186 } else { 187 dev->input_id.vendor = saa->pci->vendor; 188 dev->input_id.product = saa->pci->device; 189 } 190 dev->dev.parent = &saa->pci->dev; 191 192 if (rc5_device < 0) 193 budget_ci->ir.rc5_device = IR_DEVICE_ANY; 194 else 195 budget_ci->ir.rc5_device = rc5_device; 196 197 /* Select keymap and address */ 198 switch (budget_ci->budget.dev->pci->subsystem_device) { 199 case 0x100c: 200 case 0x100f: 201 case 0x1011: 202 case 0x1012: 203 /* The hauppauge keymap is a superset of these remotes */ 204 dev->map_name = RC_MAP_HAUPPAUGE; 205 budget_ci->ir.full_rc5 = true; 206 207 if (rc5_device < 0) 208 budget_ci->ir.rc5_device = 0x1f; 209 break; 210 case 0x1010: 211 case 0x1017: 212 case 0x1019: 213 case 0x101a: 214 case 0x101b: 215 /* for the Technotrend 1500 bundled remote */ 216 dev->map_name = RC_MAP_TT_1500; 217 break; 218 default: 219 /* unknown remote */ 220 dev->map_name = RC_MAP_BUDGET_CI_OLD; 221 break; 222 } 223 if (!budget_ci->ir.full_rc5) 224 dev->scancode_mask = 0xff; 225 226 error = rc_register_device(dev); 227 if (error) { 228 pr_err("could not init driver for IR device (code %d)\n", error); 229 rc_free_device(dev); 230 return error; 231 } 232 233 budget_ci->ir.dev = dev; 234 235 INIT_WORK(&budget_ci->ir.msp430_irq_bh_work, msp430_ir_interrupt); 236 237 SAA7146_IER_ENABLE(saa, MASK_06); 238 saa7146_setgpio(saa, 3, SAA7146_GPIO_IRQHI); 239 240 return 0; 241 } 242 243 static void msp430_ir_deinit(struct budget_ci *budget_ci) 244 { 245 struct saa7146_dev *saa = budget_ci->budget.dev; 246 247 SAA7146_IER_DISABLE(saa, MASK_06); 248 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT); 249 cancel_work_sync(&budget_ci->ir.msp430_irq_bh_work); 250 251 rc_unregister_device(budget_ci->ir.dev); 252 } 253 254 static int ciintf_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address) 255 { 256 struct budget_ci *budget_ci = ca->data; 257 258 if (slot != 0) 259 return -EINVAL; 260 261 return ttpci_budget_debiread(&budget_ci->budget, DEBICICAM, 262 DEBIADDR_ATTR | (address & 0xfff), 1, 1, 0); 263 } 264 265 static int ciintf_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value) 266 { 267 struct budget_ci *budget_ci = ca->data; 268 269 if (slot != 0) 270 return -EINVAL; 271 272 return ttpci_budget_debiwrite(&budget_ci->budget, DEBICICAM, 273 DEBIADDR_ATTR | (address & 0xfff), 1, value, 1, 0); 274 } 275 276 static int ciintf_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address) 277 { 278 struct budget_ci *budget_ci = ca->data; 279 280 if (slot != 0) 281 return -EINVAL; 282 283 return ttpci_budget_debiread(&budget_ci->budget, DEBICICAM, 284 DEBIADDR_IO | (address & 3), 1, 1, 0); 285 } 286 287 static int ciintf_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value) 288 { 289 struct budget_ci *budget_ci = ca->data; 290 291 if (slot != 0) 292 return -EINVAL; 293 294 return ttpci_budget_debiwrite(&budget_ci->budget, DEBICICAM, 295 DEBIADDR_IO | (address & 3), 1, value, 1, 0); 296 } 297 298 static int ciintf_slot_reset(struct dvb_ca_en50221 *ca, int slot) 299 { 300 struct budget_ci *budget_ci = ca->data; 301 struct saa7146_dev *saa = budget_ci->budget.dev; 302 303 if (slot != 0) 304 return -EINVAL; 305 306 if (budget_ci->ci_irq) { 307 // trigger on RISING edge during reset so we know when READY is re-asserted 308 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI); 309 } 310 budget_ci->slot_status = SLOTSTATUS_RESET; 311 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 0, 1, 0); 312 msleep(1); 313 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 314 CICONTROL_RESET, 1, 0); 315 316 saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTHI); 317 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB); 318 return 0; 319 } 320 321 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot) 322 { 323 struct budget_ci *budget_ci = ca->data; 324 struct saa7146_dev *saa = budget_ci->budget.dev; 325 326 if (slot != 0) 327 return -EINVAL; 328 329 saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTHI); 330 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB); 331 return 0; 332 } 333 334 static int ciintf_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot) 335 { 336 struct budget_ci *budget_ci = ca->data; 337 struct saa7146_dev *saa = budget_ci->budget.dev; 338 int tmp; 339 340 if (slot != 0) 341 return -EINVAL; 342 343 saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTLO); 344 345 tmp = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0); 346 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 347 tmp | CICONTROL_ENABLETS, 1, 0); 348 349 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTA); 350 return 0; 351 } 352 353 static void ciintf_interrupt(struct work_struct *t) 354 { 355 struct budget_ci *budget_ci = from_work(budget_ci, t, 356 ciintf_irq_bh_work); 357 struct saa7146_dev *saa = budget_ci->budget.dev; 358 unsigned int flags; 359 360 // ensure we don't get spurious IRQs during initialisation 361 if (!budget_ci->budget.ci_present) 362 return; 363 364 // read the CAM status 365 flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0); 366 if (flags & CICONTROL_CAMDETECT) { 367 368 // GPIO should be set to trigger on falling edge if a CAM is present 369 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQLO); 370 371 if (budget_ci->slot_status & SLOTSTATUS_NONE) { 372 // CAM insertion IRQ 373 budget_ci->slot_status = SLOTSTATUS_PRESENT; 374 dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0, 375 DVB_CA_EN50221_CAMCHANGE_INSERTED); 376 377 } else if (budget_ci->slot_status & SLOTSTATUS_RESET) { 378 // CAM ready (reset completed) 379 budget_ci->slot_status = SLOTSTATUS_READY; 380 dvb_ca_en50221_camready_irq(&budget_ci->ca, 0); 381 382 } else if (budget_ci->slot_status & SLOTSTATUS_READY) { 383 // FR/DA IRQ 384 dvb_ca_en50221_frda_irq(&budget_ci->ca, 0); 385 } 386 } else { 387 388 // trigger on rising edge if a CAM is not present - when a CAM is inserted, we 389 // only want to get the IRQ when it sets READY. If we trigger on the falling edge, 390 // the CAM might not actually be ready yet. 391 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI); 392 393 // generate a CAM removal IRQ if we haven't already 394 if (budget_ci->slot_status & SLOTSTATUS_OCCUPIED) { 395 // CAM removal IRQ 396 budget_ci->slot_status = SLOTSTATUS_NONE; 397 dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0, 398 DVB_CA_EN50221_CAMCHANGE_REMOVED); 399 } 400 } 401 } 402 403 static int ciintf_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open) 404 { 405 struct budget_ci *budget_ci = ca->data; 406 unsigned int flags; 407 408 // ensure we don't get spurious IRQs during initialisation 409 if (!budget_ci->budget.ci_present) 410 return -EINVAL; 411 412 // read the CAM status 413 flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0); 414 if (flags & CICONTROL_CAMDETECT) { 415 // mark it as present if it wasn't before 416 if (budget_ci->slot_status & SLOTSTATUS_NONE) 417 budget_ci->slot_status = SLOTSTATUS_PRESENT; 418 419 // during a RESET, we check if we can read from IO memory to see when CAM is ready 420 if (budget_ci->slot_status & SLOTSTATUS_RESET) { 421 if (ciintf_read_attribute_mem(ca, slot, 0) == 0x1d) 422 budget_ci->slot_status = SLOTSTATUS_READY; 423 } 424 } else { 425 budget_ci->slot_status = SLOTSTATUS_NONE; 426 } 427 428 if (budget_ci->slot_status != SLOTSTATUS_NONE) { 429 if (budget_ci->slot_status & SLOTSTATUS_READY) 430 return DVB_CA_EN50221_POLL_CAM_PRESENT | DVB_CA_EN50221_POLL_CAM_READY; 431 return DVB_CA_EN50221_POLL_CAM_PRESENT; 432 } 433 434 return 0; 435 } 436 437 static int ciintf_init(struct budget_ci *budget_ci) 438 { 439 struct saa7146_dev *saa = budget_ci->budget.dev; 440 int flags; 441 int result; 442 int ci_version; 443 int ca_flags; 444 445 memset(&budget_ci->ca, 0, sizeof(struct dvb_ca_en50221)); 446 447 // enable DEBI pins 448 saa7146_write(saa, MC1, MASK_27 | MASK_11); 449 450 // test if it is there 451 ci_version = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CIVERSION, 1, 1, 0); 452 if ((ci_version & 0xa0) != 0xa0) { 453 result = -ENODEV; 454 goto error; 455 } 456 457 // determine whether a CAM is present or not 458 flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0); 459 budget_ci->slot_status = SLOTSTATUS_NONE; 460 if (flags & CICONTROL_CAMDETECT) 461 budget_ci->slot_status = SLOTSTATUS_PRESENT; 462 463 // version 0xa2 of the CI firmware doesn't generate interrupts 464 if (ci_version == 0xa2) { 465 ca_flags = 0; 466 budget_ci->ci_irq = 0; 467 } else { 468 ca_flags = DVB_CA_EN50221_FLAG_IRQ_CAMCHANGE | 469 DVB_CA_EN50221_FLAG_IRQ_FR | 470 DVB_CA_EN50221_FLAG_IRQ_DA; 471 budget_ci->ci_irq = 1; 472 } 473 474 // register CI interface 475 budget_ci->ca.owner = THIS_MODULE; 476 budget_ci->ca.read_attribute_mem = ciintf_read_attribute_mem; 477 budget_ci->ca.write_attribute_mem = ciintf_write_attribute_mem; 478 budget_ci->ca.read_cam_control = ciintf_read_cam_control; 479 budget_ci->ca.write_cam_control = ciintf_write_cam_control; 480 budget_ci->ca.slot_reset = ciintf_slot_reset; 481 budget_ci->ca.slot_shutdown = ciintf_slot_shutdown; 482 budget_ci->ca.slot_ts_enable = ciintf_slot_ts_enable; 483 budget_ci->ca.poll_slot_status = ciintf_poll_slot_status; 484 budget_ci->ca.data = budget_ci; 485 486 result = dvb_ca_en50221_init(&budget_ci->budget.dvb_adapter, 487 &budget_ci->ca, ca_flags, 1); 488 if (result != 0) { 489 pr_err("CI interface detected, but initialisation failed.\n"); 490 goto error; 491 } 492 493 // Setup CI slot IRQ 494 if (budget_ci->ci_irq) { 495 INIT_WORK(&budget_ci->ciintf_irq_bh_work, ciintf_interrupt); 496 if (budget_ci->slot_status != SLOTSTATUS_NONE) 497 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQLO); 498 else 499 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI); 500 SAA7146_IER_ENABLE(saa, MASK_03); 501 } 502 503 // enable interface 504 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 505 CICONTROL_RESET, 1, 0); 506 507 // success! 508 pr_info("CI interface initialised\n"); 509 budget_ci->budget.ci_present = 1; 510 511 // forge a fake CI IRQ so the CAM state is setup correctly 512 if (budget_ci->ci_irq) { 513 flags = DVB_CA_EN50221_CAMCHANGE_REMOVED; 514 if (budget_ci->slot_status != SLOTSTATUS_NONE) 515 flags = DVB_CA_EN50221_CAMCHANGE_INSERTED; 516 dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0, flags); 517 } 518 519 return 0; 520 521 error: 522 saa7146_write(saa, MC1, MASK_27); 523 return result; 524 } 525 526 static void ciintf_deinit(struct budget_ci *budget_ci) 527 { 528 struct saa7146_dev *saa = budget_ci->budget.dev; 529 530 // disable CI interrupts 531 if (budget_ci->ci_irq) { 532 SAA7146_IER_DISABLE(saa, MASK_03); 533 saa7146_setgpio(saa, 0, SAA7146_GPIO_INPUT); 534 cancel_work_sync(&budget_ci->ciintf_irq_bh_work); 535 } 536 537 // reset interface 538 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 0, 1, 0); 539 msleep(1); 540 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 541 CICONTROL_RESET, 1, 0); 542 543 // disable TS data stream to CI interface 544 saa7146_setgpio(saa, 1, SAA7146_GPIO_INPUT); 545 546 // release the CA device 547 dvb_ca_en50221_release(&budget_ci->ca); 548 549 // disable DEBI pins 550 saa7146_write(saa, MC1, MASK_27); 551 } 552 553 static void budget_ci_irq(struct saa7146_dev *dev, u32 *isr) 554 { 555 struct budget_ci *budget_ci = dev->ext_priv; 556 557 dprintk(8, "dev: %p, budget_ci: %p\n", dev, budget_ci); 558 559 if (*isr & MASK_06) 560 queue_work(system_bh_wq, &budget_ci->ir.msp430_irq_bh_work); 561 562 if (*isr & MASK_10) 563 ttpci_budget_irq10_handler(dev, isr); 564 565 if ((*isr & MASK_03) && (budget_ci->budget.ci_present) && (budget_ci->ci_irq)) 566 queue_work(system_bh_wq, &budget_ci->ciintf_irq_bh_work); 567 } 568 569 static u8 philips_su1278_tt_inittab[] = { 570 0x01, 0x0f, 571 0x02, 0x30, 572 0x03, 0x00, 573 0x04, 0x5b, 574 0x05, 0x85, 575 0x06, 0x02, 576 0x07, 0x00, 577 0x08, 0x02, 578 0x09, 0x00, 579 0x0C, 0x01, 580 0x0D, 0x81, 581 0x0E, 0x44, 582 0x0f, 0x14, 583 0x10, 0x3c, 584 0x11, 0x84, 585 0x12, 0xda, 586 0x13, 0x97, 587 0x14, 0x95, 588 0x15, 0xc9, 589 0x16, 0x19, 590 0x17, 0x8c, 591 0x18, 0x59, 592 0x19, 0xf8, 593 0x1a, 0xfe, 594 0x1c, 0x7f, 595 0x1d, 0x00, 596 0x1e, 0x00, 597 0x1f, 0x50, 598 0x20, 0x00, 599 0x21, 0x00, 600 0x22, 0x00, 601 0x23, 0x00, 602 0x28, 0x00, 603 0x29, 0x28, 604 0x2a, 0x14, 605 0x2b, 0x0f, 606 0x2c, 0x09, 607 0x2d, 0x09, 608 0x31, 0x1f, 609 0x32, 0x19, 610 0x33, 0xfc, 611 0x34, 0x93, 612 0xff, 0xff 613 }; 614 615 static int philips_su1278_tt_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio) 616 { 617 stv0299_writereg(fe, 0x0e, 0x44); 618 if (srate >= 10000000) { 619 stv0299_writereg(fe, 0x13, 0x97); 620 stv0299_writereg(fe, 0x14, 0x95); 621 stv0299_writereg(fe, 0x15, 0xc9); 622 stv0299_writereg(fe, 0x17, 0x8c); 623 stv0299_writereg(fe, 0x1a, 0xfe); 624 stv0299_writereg(fe, 0x1c, 0x7f); 625 stv0299_writereg(fe, 0x2d, 0x09); 626 } else { 627 stv0299_writereg(fe, 0x13, 0x99); 628 stv0299_writereg(fe, 0x14, 0x8d); 629 stv0299_writereg(fe, 0x15, 0xce); 630 stv0299_writereg(fe, 0x17, 0x43); 631 stv0299_writereg(fe, 0x1a, 0x1d); 632 stv0299_writereg(fe, 0x1c, 0x12); 633 stv0299_writereg(fe, 0x2d, 0x05); 634 } 635 stv0299_writereg(fe, 0x0e, 0x23); 636 stv0299_writereg(fe, 0x0f, 0x94); 637 stv0299_writereg(fe, 0x10, 0x39); 638 stv0299_writereg(fe, 0x15, 0xc9); 639 640 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff); 641 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff); 642 stv0299_writereg(fe, 0x21, (ratio) & 0xf0); 643 644 return 0; 645 } 646 647 static int philips_su1278_tt_tuner_set_params(struct dvb_frontend *fe) 648 { 649 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 650 struct budget_ci *budget_ci = fe->dvb->priv; 651 u32 div; 652 u8 buf[4]; 653 struct i2c_msg msg = {.addr = 0x60, .flags = 0, .buf = buf, .len = sizeof(buf) }; 654 655 if ((p->frequency < 950000) || (p->frequency > 2150000)) 656 return -EINVAL; 657 658 div = (p->frequency + (500 - 1)) / 500; /* round correctly */ 659 buf[0] = (div >> 8) & 0x7f; 660 buf[1] = div & 0xff; 661 buf[2] = 0x80 | ((div & 0x18000) >> 10) | 2; 662 buf[3] = 0x20; 663 664 if (p->symbol_rate < 4000000) 665 buf[3] |= 1; 666 667 if (p->frequency < 1250000) 668 buf[3] |= 0; 669 else if (p->frequency < 1550000) 670 buf[3] |= 0x40; 671 else if (p->frequency < 2050000) 672 buf[3] |= 0x80; 673 else if (p->frequency < 2150000) 674 buf[3] |= 0xC0; 675 676 if (fe->ops.i2c_gate_ctrl) 677 fe->ops.i2c_gate_ctrl(fe, 1); 678 if (i2c_transfer(&budget_ci->budget.i2c_adap, &msg, 1) != 1) 679 return -EIO; 680 return 0; 681 } 682 683 static const struct stv0299_config philips_su1278_tt_config = { 684 685 .demod_address = 0x68, 686 .inittab = philips_su1278_tt_inittab, 687 .mclk = 64000000UL, 688 .invert = 0, 689 .skip_reinit = 1, 690 .lock_output = STV0299_LOCKOUTPUT_1, 691 .volt13_op0_op1 = STV0299_VOLT13_OP1, 692 .min_delay_ms = 50, 693 .set_symbol_rate = philips_su1278_tt_set_symbol_rate, 694 }; 695 696 697 698 static int philips_tdm1316l_tuner_init(struct dvb_frontend *fe) 699 { 700 struct budget_ci *budget_ci = fe->dvb->priv; 701 static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab }; 702 static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 }; 703 struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address, .flags = 0, .buf = td1316_init, .len = 704 sizeof(td1316_init) }; 705 706 // setup PLL configuration 707 if (fe->ops.i2c_gate_ctrl) 708 fe->ops.i2c_gate_ctrl(fe, 1); 709 if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1) 710 return -EIO; 711 msleep(1); 712 713 // disable the mc44BC374c (do not check for errors) 714 tuner_msg.addr = 0x65; 715 tuner_msg.buf = disable_mc44BC374c; 716 tuner_msg.len = sizeof(disable_mc44BC374c); 717 if (fe->ops.i2c_gate_ctrl) 718 fe->ops.i2c_gate_ctrl(fe, 1); 719 if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1) { 720 if (fe->ops.i2c_gate_ctrl) 721 fe->ops.i2c_gate_ctrl(fe, 1); 722 i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1); 723 } 724 725 return 0; 726 } 727 728 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe) 729 { 730 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 731 struct budget_ci *budget_ci = fe->dvb->priv; 732 u8 tuner_buf[4]; 733 struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address, .flags = 0, .buf = tuner_buf, .len = sizeof(tuner_buf) }; 734 int tuner_frequency = 0; 735 u8 band, cp, filter; 736 737 // determine charge pump 738 tuner_frequency = p->frequency + 36130000; 739 if (tuner_frequency < 87000000) 740 return -EINVAL; 741 else if (tuner_frequency < 130000000) 742 cp = 3; 743 else if (tuner_frequency < 160000000) 744 cp = 5; 745 else if (tuner_frequency < 200000000) 746 cp = 6; 747 else if (tuner_frequency < 290000000) 748 cp = 3; 749 else if (tuner_frequency < 420000000) 750 cp = 5; 751 else if (tuner_frequency < 480000000) 752 cp = 6; 753 else if (tuner_frequency < 620000000) 754 cp = 3; 755 else if (tuner_frequency < 830000000) 756 cp = 5; 757 else if (tuner_frequency < 895000000) 758 cp = 7; 759 else 760 return -EINVAL; 761 762 // determine band 763 if (p->frequency < 49000000) 764 return -EINVAL; 765 else if (p->frequency < 159000000) 766 band = 1; 767 else if (p->frequency < 444000000) 768 band = 2; 769 else if (p->frequency < 861000000) 770 band = 4; 771 else 772 return -EINVAL; 773 774 // setup PLL filter and TDA9889 775 switch (p->bandwidth_hz) { 776 case 6000000: 777 tda1004x_writereg(fe, 0x0C, 0x14); 778 filter = 0; 779 break; 780 781 case 7000000: 782 tda1004x_writereg(fe, 0x0C, 0x80); 783 filter = 0; 784 break; 785 786 case 8000000: 787 tda1004x_writereg(fe, 0x0C, 0x14); 788 filter = 1; 789 break; 790 791 default: 792 return -EINVAL; 793 } 794 795 // calculate divisor 796 // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6) 797 tuner_frequency = (((p->frequency / 1000) * 6) + 217280) / 1000; 798 799 // setup tuner buffer 800 tuner_buf[0] = tuner_frequency >> 8; 801 tuner_buf[1] = tuner_frequency & 0xff; 802 tuner_buf[2] = 0xca; 803 tuner_buf[3] = (cp << 5) | (filter << 3) | band; 804 805 if (fe->ops.i2c_gate_ctrl) 806 fe->ops.i2c_gate_ctrl(fe, 1); 807 if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1) 808 return -EIO; 809 810 msleep(1); 811 return 0; 812 } 813 814 static int philips_tdm1316l_request_firmware(struct dvb_frontend *fe, 815 const struct firmware **fw, char *name) 816 { 817 struct budget_ci *budget_ci = fe->dvb->priv; 818 819 return request_firmware(fw, name, &budget_ci->budget.dev->pci->dev); 820 } 821 822 static struct tda1004x_config philips_tdm1316l_config = { 823 824 .demod_address = 0x8, 825 .invert = 0, 826 .invert_oclk = 0, 827 .xtal_freq = TDA10046_XTAL_4M, 828 .agc_config = TDA10046_AGC_DEFAULT, 829 .if_freq = TDA10046_FREQ_3617, 830 .request_firmware = philips_tdm1316l_request_firmware, 831 }; 832 833 static struct tda1004x_config philips_tdm1316l_config_invert = { 834 835 .demod_address = 0x8, 836 .invert = 1, 837 .invert_oclk = 0, 838 .xtal_freq = TDA10046_XTAL_4M, 839 .agc_config = TDA10046_AGC_DEFAULT, 840 .if_freq = TDA10046_FREQ_3617, 841 .request_firmware = philips_tdm1316l_request_firmware, 842 }; 843 844 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe) 845 { 846 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 847 struct budget_ci *budget_ci = fe->dvb->priv; 848 u8 tuner_buf[5]; 849 struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address, 850 .flags = 0, 851 .buf = tuner_buf, 852 .len = sizeof(tuner_buf) }; 853 int tuner_frequency = 0; 854 u8 band, cp, filter; 855 856 // determine charge pump 857 tuner_frequency = p->frequency + 36125000; 858 if (tuner_frequency < 87000000) { 859 return -EINVAL; 860 } else if (tuner_frequency < 130000000) { 861 cp = 3; 862 band = 1; 863 } else if (tuner_frequency < 160000000) { 864 cp = 5; 865 band = 1; 866 } else if (tuner_frequency < 200000000) { 867 cp = 6; 868 band = 1; 869 } else if (tuner_frequency < 290000000) { 870 cp = 3; 871 band = 2; 872 } else if (tuner_frequency < 420000000) { 873 cp = 5; 874 band = 2; 875 } else if (tuner_frequency < 480000000) { 876 cp = 6; 877 band = 2; 878 } else if (tuner_frequency < 620000000) { 879 cp = 3; 880 band = 4; 881 } else if (tuner_frequency < 830000000) { 882 cp = 5; 883 band = 4; 884 } else if (tuner_frequency < 895000000) { 885 cp = 7; 886 band = 4; 887 } else { 888 return -EINVAL; 889 } 890 891 // assume PLL filter should always be 8MHz for the moment. 892 filter = 1; 893 894 // calculate divisor 895 tuner_frequency = (p->frequency + 36125000 + (62500/2)) / 62500; 896 897 // setup tuner buffer 898 tuner_buf[0] = tuner_frequency >> 8; 899 tuner_buf[1] = tuner_frequency & 0xff; 900 tuner_buf[2] = 0xc8; 901 tuner_buf[3] = (cp << 5) | (filter << 3) | band; 902 tuner_buf[4] = 0x80; 903 904 if (fe->ops.i2c_gate_ctrl) 905 fe->ops.i2c_gate_ctrl(fe, 1); 906 if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1) 907 return -EIO; 908 909 msleep(50); 910 911 if (fe->ops.i2c_gate_ctrl) 912 fe->ops.i2c_gate_ctrl(fe, 1); 913 if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1) 914 return -EIO; 915 916 msleep(1); 917 918 return 0; 919 } 920 921 static u8 dvbc_philips_tdm1316l_inittab[] = { 922 0x80, 0x01, 923 0x80, 0x00, 924 0x81, 0x01, 925 0x81, 0x00, 926 0x00, 0x09, 927 0x01, 0x69, 928 0x03, 0x00, 929 0x04, 0x00, 930 0x07, 0x00, 931 0x08, 0x00, 932 0x20, 0x00, 933 0x21, 0x40, 934 0x22, 0x00, 935 0x23, 0x00, 936 0x24, 0x40, 937 0x25, 0x88, 938 0x30, 0xff, 939 0x31, 0x00, 940 0x32, 0xff, 941 0x33, 0x00, 942 0x34, 0x50, 943 0x35, 0x7f, 944 0x36, 0x00, 945 0x37, 0x20, 946 0x38, 0x00, 947 0x40, 0x1c, 948 0x41, 0xff, 949 0x42, 0x29, 950 0x43, 0x20, 951 0x44, 0xff, 952 0x45, 0x00, 953 0x46, 0x00, 954 0x49, 0x04, 955 0x4a, 0x00, 956 0x4b, 0x7b, 957 0x52, 0x30, 958 0x55, 0xae, 959 0x56, 0x47, 960 0x57, 0xe1, 961 0x58, 0x3a, 962 0x5a, 0x1e, 963 0x5b, 0x34, 964 0x60, 0x00, 965 0x63, 0x00, 966 0x64, 0x00, 967 0x65, 0x00, 968 0x66, 0x00, 969 0x67, 0x00, 970 0x68, 0x00, 971 0x69, 0x00, 972 0x6a, 0x02, 973 0x6b, 0x00, 974 0x70, 0xff, 975 0x71, 0x00, 976 0x72, 0x00, 977 0x73, 0x00, 978 0x74, 0x0c, 979 0x80, 0x00, 980 0x81, 0x00, 981 0x82, 0x00, 982 0x83, 0x00, 983 0x84, 0x04, 984 0x85, 0x80, 985 0x86, 0x24, 986 0x87, 0x78, 987 0x88, 0x10, 988 0x89, 0x00, 989 0x90, 0x01, 990 0x91, 0x01, 991 0xa0, 0x04, 992 0xa1, 0x00, 993 0xa2, 0x00, 994 0xb0, 0x91, 995 0xb1, 0x0b, 996 0xc0, 0x53, 997 0xc1, 0x70, 998 0xc2, 0x12, 999 0xd0, 0x00, 1000 0xd1, 0x00, 1001 0xd2, 0x00, 1002 0xd3, 0x00, 1003 0xd4, 0x00, 1004 0xd5, 0x00, 1005 0xde, 0x00, 1006 0xdf, 0x00, 1007 0x61, 0x38, 1008 0x62, 0x0a, 1009 0x53, 0x13, 1010 0x59, 0x08, 1011 0xff, 0xff, 1012 }; 1013 1014 static struct stv0297_config dvbc_philips_tdm1316l_config = { 1015 .demod_address = 0x1c, 1016 .inittab = dvbc_philips_tdm1316l_inittab, 1017 .invert = 0, 1018 .stop_during_read = 1, 1019 }; 1020 1021 static struct tda10023_config tda10023_config = { 1022 .demod_address = 0xc, 1023 .invert = 0, 1024 .xtal = 16000000, 1025 .pll_m = 11, 1026 .pll_p = 3, 1027 .pll_n = 1, 1028 .deltaf = 0xa511, 1029 }; 1030 1031 static struct tda827x_config tda827x_config = { 1032 .config = 0, 1033 }; 1034 1035 /* TT S2-3200 DVB-S (STB0899) Inittab */ 1036 static const struct stb0899_s1_reg tt3200_stb0899_s1_init_1[] = { 1037 1038 { STB0899_DEV_ID, 0x81 }, 1039 { STB0899_DISCNTRL1, 0x32 }, 1040 { STB0899_DISCNTRL2, 0x80 }, 1041 { STB0899_DISRX_ST0, 0x04 }, 1042 { STB0899_DISRX_ST1, 0x00 }, 1043 { STB0899_DISPARITY, 0x00 }, 1044 { STB0899_DISSTATUS, 0x20 }, 1045 { STB0899_DISF22, 0x8c }, 1046 { STB0899_DISF22RX, 0x9a }, 1047 { STB0899_SYSREG, 0x0b }, 1048 { STB0899_ACRPRESC, 0x11 }, 1049 { STB0899_ACRDIV1, 0x0a }, 1050 { STB0899_ACRDIV2, 0x05 }, 1051 { STB0899_DACR1, 0x00 }, 1052 { STB0899_DACR2, 0x00 }, 1053 { STB0899_OUTCFG, 0x00 }, 1054 { STB0899_MODECFG, 0x00 }, 1055 { STB0899_IRQSTATUS_3, 0x30 }, 1056 { STB0899_IRQSTATUS_2, 0x00 }, 1057 { STB0899_IRQSTATUS_1, 0x00 }, 1058 { STB0899_IRQSTATUS_0, 0x00 }, 1059 { STB0899_IRQMSK_3, 0xf3 }, 1060 { STB0899_IRQMSK_2, 0xfc }, 1061 { STB0899_IRQMSK_1, 0xff }, 1062 { STB0899_IRQMSK_0, 0xff }, 1063 { STB0899_IRQCFG, 0x00 }, 1064 { STB0899_I2CCFG, 0x88 }, 1065 { STB0899_I2CRPT, 0x48 }, /* 12k Pullup, Repeater=16, Stop=disabled */ 1066 { STB0899_IOPVALUE5, 0x00 }, 1067 { STB0899_IOPVALUE4, 0x20 }, 1068 { STB0899_IOPVALUE3, 0xc9 }, 1069 { STB0899_IOPVALUE2, 0x90 }, 1070 { STB0899_IOPVALUE1, 0x40 }, 1071 { STB0899_IOPVALUE0, 0x00 }, 1072 { STB0899_GPIO00CFG, 0x82 }, 1073 { STB0899_GPIO01CFG, 0x82 }, 1074 { STB0899_GPIO02CFG, 0x82 }, 1075 { STB0899_GPIO03CFG, 0x82 }, 1076 { STB0899_GPIO04CFG, 0x82 }, 1077 { STB0899_GPIO05CFG, 0x82 }, 1078 { STB0899_GPIO06CFG, 0x82 }, 1079 { STB0899_GPIO07CFG, 0x82 }, 1080 { STB0899_GPIO08CFG, 0x82 }, 1081 { STB0899_GPIO09CFG, 0x82 }, 1082 { STB0899_GPIO10CFG, 0x82 }, 1083 { STB0899_GPIO11CFG, 0x82 }, 1084 { STB0899_GPIO12CFG, 0x82 }, 1085 { STB0899_GPIO13CFG, 0x82 }, 1086 { STB0899_GPIO14CFG, 0x82 }, 1087 { STB0899_GPIO15CFG, 0x82 }, 1088 { STB0899_GPIO16CFG, 0x82 }, 1089 { STB0899_GPIO17CFG, 0x82 }, 1090 { STB0899_GPIO18CFG, 0x82 }, 1091 { STB0899_GPIO19CFG, 0x82 }, 1092 { STB0899_GPIO20CFG, 0x82 }, 1093 { STB0899_SDATCFG, 0xb8 }, 1094 { STB0899_SCLTCFG, 0xba }, 1095 { STB0899_AGCRFCFG, 0x1c }, /* 0x11 */ 1096 { STB0899_GPIO22, 0x82 }, /* AGCBB2CFG */ 1097 { STB0899_GPIO21, 0x91 }, /* AGCBB1CFG */ 1098 { STB0899_DIRCLKCFG, 0x82 }, 1099 { STB0899_CLKOUT27CFG, 0x7e }, 1100 { STB0899_STDBYCFG, 0x82 }, 1101 { STB0899_CS0CFG, 0x82 }, 1102 { STB0899_CS1CFG, 0x82 }, 1103 { STB0899_DISEQCOCFG, 0x20 }, 1104 { STB0899_GPIO32CFG, 0x82 }, 1105 { STB0899_GPIO33CFG, 0x82 }, 1106 { STB0899_GPIO34CFG, 0x82 }, 1107 { STB0899_GPIO35CFG, 0x82 }, 1108 { STB0899_GPIO36CFG, 0x82 }, 1109 { STB0899_GPIO37CFG, 0x82 }, 1110 { STB0899_GPIO38CFG, 0x82 }, 1111 { STB0899_GPIO39CFG, 0x82 }, 1112 { STB0899_NCOARSE, 0x15 }, /* 0x15 = 27 Mhz Clock, F/3 = 198MHz, F/6 = 99MHz */ 1113 { STB0899_SYNTCTRL, 0x02 }, /* 0x00 = CLK from CLKI, 0x02 = CLK from XTALI */ 1114 { STB0899_FILTCTRL, 0x00 }, 1115 { STB0899_SYSCTRL, 0x00 }, 1116 { STB0899_STOPCLK1, 0x20 }, 1117 { STB0899_STOPCLK2, 0x00 }, 1118 { STB0899_INTBUFSTATUS, 0x00 }, 1119 { STB0899_INTBUFCTRL, 0x0a }, 1120 { 0xffff, 0xff }, 1121 }; 1122 1123 static const struct stb0899_s1_reg tt3200_stb0899_s1_init_3[] = { 1124 { STB0899_DEMOD, 0x00 }, 1125 { STB0899_RCOMPC, 0xc9 }, 1126 { STB0899_AGC1CN, 0x41 }, 1127 { STB0899_AGC1REF, 0x10 }, 1128 { STB0899_RTC, 0x7a }, 1129 { STB0899_TMGCFG, 0x4e }, 1130 { STB0899_AGC2REF, 0x34 }, 1131 { STB0899_TLSR, 0x84 }, 1132 { STB0899_CFD, 0xc7 }, 1133 { STB0899_ACLC, 0x87 }, 1134 { STB0899_BCLC, 0x94 }, 1135 { STB0899_EQON, 0x41 }, 1136 { STB0899_LDT, 0xdd }, 1137 { STB0899_LDT2, 0xc9 }, 1138 { STB0899_EQUALREF, 0xb4 }, 1139 { STB0899_TMGRAMP, 0x10 }, 1140 { STB0899_TMGTHD, 0x30 }, 1141 { STB0899_IDCCOMP, 0xfb }, 1142 { STB0899_QDCCOMP, 0x03 }, 1143 { STB0899_POWERI, 0x3b }, 1144 { STB0899_POWERQ, 0x3d }, 1145 { STB0899_RCOMP, 0x81 }, 1146 { STB0899_AGCIQIN, 0x80 }, 1147 { STB0899_AGC2I1, 0x04 }, 1148 { STB0899_AGC2I2, 0xf5 }, 1149 { STB0899_TLIR, 0x25 }, 1150 { STB0899_RTF, 0x80 }, 1151 { STB0899_DSTATUS, 0x00 }, 1152 { STB0899_LDI, 0xca }, 1153 { STB0899_CFRM, 0xf1 }, 1154 { STB0899_CFRL, 0xf3 }, 1155 { STB0899_NIRM, 0x2a }, 1156 { STB0899_NIRL, 0x05 }, 1157 { STB0899_ISYMB, 0x17 }, 1158 { STB0899_QSYMB, 0xfa }, 1159 { STB0899_SFRH, 0x2f }, 1160 { STB0899_SFRM, 0x68 }, 1161 { STB0899_SFRL, 0x40 }, 1162 { STB0899_SFRUPH, 0x2f }, 1163 { STB0899_SFRUPM, 0x68 }, 1164 { STB0899_SFRUPL, 0x40 }, 1165 { STB0899_EQUAI1, 0xfd }, 1166 { STB0899_EQUAQ1, 0x04 }, 1167 { STB0899_EQUAI2, 0x0f }, 1168 { STB0899_EQUAQ2, 0xff }, 1169 { STB0899_EQUAI3, 0xdf }, 1170 { STB0899_EQUAQ3, 0xfa }, 1171 { STB0899_EQUAI4, 0x37 }, 1172 { STB0899_EQUAQ4, 0x0d }, 1173 { STB0899_EQUAI5, 0xbd }, 1174 { STB0899_EQUAQ5, 0xf7 }, 1175 { STB0899_DSTATUS2, 0x00 }, 1176 { STB0899_VSTATUS, 0x00 }, 1177 { STB0899_VERROR, 0xff }, 1178 { STB0899_IQSWAP, 0x2a }, 1179 { STB0899_ECNT1M, 0x00 }, 1180 { STB0899_ECNT1L, 0x00 }, 1181 { STB0899_ECNT2M, 0x00 }, 1182 { STB0899_ECNT2L, 0x00 }, 1183 { STB0899_ECNT3M, 0x00 }, 1184 { STB0899_ECNT3L, 0x00 }, 1185 { STB0899_FECAUTO1, 0x06 }, 1186 { STB0899_FECM, 0x01 }, 1187 { STB0899_VTH12, 0xf0 }, 1188 { STB0899_VTH23, 0xa0 }, 1189 { STB0899_VTH34, 0x78 }, 1190 { STB0899_VTH56, 0x4e }, 1191 { STB0899_VTH67, 0x48 }, 1192 { STB0899_VTH78, 0x38 }, 1193 { STB0899_PRVIT, 0xff }, 1194 { STB0899_VITSYNC, 0x19 }, 1195 { STB0899_RSULC, 0xb1 }, /* DVB = 0xb1, DSS = 0xa1 */ 1196 { STB0899_TSULC, 0x42 }, 1197 { STB0899_RSLLC, 0x40 }, 1198 { STB0899_TSLPL, 0x12 }, 1199 { STB0899_TSCFGH, 0x0c }, 1200 { STB0899_TSCFGM, 0x00 }, 1201 { STB0899_TSCFGL, 0x0c }, 1202 { STB0899_TSOUT, 0x4d }, /* 0x0d for CAM */ 1203 { STB0899_RSSYNCDEL, 0x00 }, 1204 { STB0899_TSINHDELH, 0x02 }, 1205 { STB0899_TSINHDELM, 0x00 }, 1206 { STB0899_TSINHDELL, 0x00 }, 1207 { STB0899_TSLLSTKM, 0x00 }, 1208 { STB0899_TSLLSTKL, 0x00 }, 1209 { STB0899_TSULSTKM, 0x00 }, 1210 { STB0899_TSULSTKL, 0xab }, 1211 { STB0899_PCKLENUL, 0x00 }, 1212 { STB0899_PCKLENLL, 0xcc }, 1213 { STB0899_RSPCKLEN, 0xcc }, 1214 { STB0899_TSSTATUS, 0x80 }, 1215 { STB0899_ERRCTRL1, 0xb6 }, 1216 { STB0899_ERRCTRL2, 0x96 }, 1217 { STB0899_ERRCTRL3, 0x89 }, 1218 { STB0899_DMONMSK1, 0x27 }, 1219 { STB0899_DMONMSK0, 0x03 }, 1220 { STB0899_DEMAPVIT, 0x5c }, 1221 { STB0899_PLPARM, 0x1f }, 1222 { STB0899_PDELCTRL, 0x48 }, 1223 { STB0899_PDELCTRL2, 0x00 }, 1224 { STB0899_BBHCTRL1, 0x00 }, 1225 { STB0899_BBHCTRL2, 0x00 }, 1226 { STB0899_HYSTTHRESH, 0x77 }, 1227 { STB0899_MATCSTM, 0x00 }, 1228 { STB0899_MATCSTL, 0x00 }, 1229 { STB0899_UPLCSTM, 0x00 }, 1230 { STB0899_UPLCSTL, 0x00 }, 1231 { STB0899_DFLCSTM, 0x00 }, 1232 { STB0899_DFLCSTL, 0x00 }, 1233 { STB0899_SYNCCST, 0x00 }, 1234 { STB0899_SYNCDCSTM, 0x00 }, 1235 { STB0899_SYNCDCSTL, 0x00 }, 1236 { STB0899_ISI_ENTRY, 0x00 }, 1237 { STB0899_ISI_BIT_EN, 0x00 }, 1238 { STB0899_MATSTRM, 0x00 }, 1239 { STB0899_MATSTRL, 0x00 }, 1240 { STB0899_UPLSTRM, 0x00 }, 1241 { STB0899_UPLSTRL, 0x00 }, 1242 { STB0899_DFLSTRM, 0x00 }, 1243 { STB0899_DFLSTRL, 0x00 }, 1244 { STB0899_SYNCSTR, 0x00 }, 1245 { STB0899_SYNCDSTRM, 0x00 }, 1246 { STB0899_SYNCDSTRL, 0x00 }, 1247 { STB0899_CFGPDELSTATUS1, 0x10 }, 1248 { STB0899_CFGPDELSTATUS2, 0x00 }, 1249 { STB0899_BBFERRORM, 0x00 }, 1250 { STB0899_BBFERRORL, 0x00 }, 1251 { STB0899_UPKTERRORM, 0x00 }, 1252 { STB0899_UPKTERRORL, 0x00 }, 1253 { 0xffff, 0xff }, 1254 }; 1255 1256 static struct stb0899_config tt3200_config = { 1257 .init_dev = tt3200_stb0899_s1_init_1, 1258 .init_s2_demod = stb0899_s2_init_2, 1259 .init_s1_demod = tt3200_stb0899_s1_init_3, 1260 .init_s2_fec = stb0899_s2_init_4, 1261 .init_tst = stb0899_s1_init_5, 1262 1263 .postproc = NULL, 1264 1265 .demod_address = 0x68, 1266 1267 .xtal_freq = 27000000, 1268 .inversion = IQ_SWAP_ON, 1269 1270 .lo_clk = 76500000, 1271 .hi_clk = 99000000, 1272 1273 .esno_ave = STB0899_DVBS2_ESNO_AVE, 1274 .esno_quant = STB0899_DVBS2_ESNO_QUANT, 1275 .avframes_coarse = STB0899_DVBS2_AVFRAMES_COARSE, 1276 .avframes_fine = STB0899_DVBS2_AVFRAMES_FINE, 1277 .miss_threshold = STB0899_DVBS2_MISS_THRESHOLD, 1278 .uwp_threshold_acq = STB0899_DVBS2_UWP_THRESHOLD_ACQ, 1279 .uwp_threshold_track = STB0899_DVBS2_UWP_THRESHOLD_TRACK, 1280 .uwp_threshold_sof = STB0899_DVBS2_UWP_THRESHOLD_SOF, 1281 .sof_search_timeout = STB0899_DVBS2_SOF_SEARCH_TIMEOUT, 1282 1283 .btr_nco_bits = STB0899_DVBS2_BTR_NCO_BITS, 1284 .btr_gain_shift_offset = STB0899_DVBS2_BTR_GAIN_SHIFT_OFFSET, 1285 .crl_nco_bits = STB0899_DVBS2_CRL_NCO_BITS, 1286 .ldpc_max_iter = STB0899_DVBS2_LDPC_MAX_ITER, 1287 1288 .tuner_get_frequency = stb6100_get_frequency, 1289 .tuner_set_frequency = stb6100_set_frequency, 1290 .tuner_set_bandwidth = stb6100_set_bandwidth, 1291 .tuner_get_bandwidth = stb6100_get_bandwidth, 1292 .tuner_set_rfsiggain = NULL 1293 }; 1294 1295 static struct stb6100_config tt3200_stb6100_config = { 1296 .tuner_address = 0x60, 1297 .refclock = 27000000, 1298 }; 1299 1300 static void frontend_init(struct budget_ci *budget_ci) 1301 { 1302 switch (budget_ci->budget.dev->pci->subsystem_device) { 1303 case 0x100c: // Hauppauge/TT Nova-CI budget (stv0299/ALPS BSRU6(tsa5059)) 1304 budget_ci->budget.dvb_frontend = 1305 dvb_attach(stv0299_attach, &alps_bsru6_config, &budget_ci->budget.i2c_adap); 1306 if (budget_ci->budget.dvb_frontend) { 1307 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params; 1308 budget_ci->budget.dvb_frontend->tuner_priv = &budget_ci->budget.i2c_adap; 1309 break; 1310 } 1311 break; 1312 1313 case 0x100f: // Hauppauge/TT Nova-CI budget (stv0299b/Philips su1278(tsa5059)) 1314 budget_ci->budget.dvb_frontend = 1315 dvb_attach(stv0299_attach, &philips_su1278_tt_config, &budget_ci->budget.i2c_adap); 1316 if (budget_ci->budget.dvb_frontend) { 1317 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_su1278_tt_tuner_set_params; 1318 break; 1319 } 1320 break; 1321 1322 case 0x1010: // TT DVB-C CI budget (stv0297/Philips tdm1316l(tda6651tt)) 1323 budget_ci->tuner_pll_address = 0x61; 1324 budget_ci->budget.dvb_frontend = 1325 dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &budget_ci->budget.i2c_adap); 1326 if (budget_ci->budget.dvb_frontend) { 1327 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params; 1328 break; 1329 } 1330 break; 1331 1332 case 0x1011: // Hauppauge/TT Nova-T budget (tda10045/Philips tdm1316l(tda6651tt) + TDA9889) 1333 budget_ci->tuner_pll_address = 0x63; 1334 budget_ci->budget.dvb_frontend = 1335 dvb_attach(tda10045_attach, &philips_tdm1316l_config, &budget_ci->budget.i2c_adap); 1336 if (budget_ci->budget.dvb_frontend) { 1337 budget_ci->budget.dvb_frontend->ops.tuner_ops.init = philips_tdm1316l_tuner_init; 1338 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params; 1339 break; 1340 } 1341 break; 1342 1343 case 0x1012: // TT DVB-T CI budget (tda10046/Philips tdm1316l(tda6651tt)) 1344 budget_ci->tuner_pll_address = 0x60; 1345 budget_ci->budget.dvb_frontend = 1346 dvb_attach(tda10046_attach, &philips_tdm1316l_config_invert, &budget_ci->budget.i2c_adap); 1347 if (budget_ci->budget.dvb_frontend) { 1348 budget_ci->budget.dvb_frontend->ops.tuner_ops.init = philips_tdm1316l_tuner_init; 1349 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params; 1350 break; 1351 } 1352 break; 1353 1354 case 0x1017: // TT S-1500 PCI 1355 budget_ci->budget.dvb_frontend = dvb_attach(stv0299_attach, &alps_bsbe1_config, &budget_ci->budget.i2c_adap); 1356 if (budget_ci->budget.dvb_frontend) { 1357 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params; 1358 budget_ci->budget.dvb_frontend->tuner_priv = &budget_ci->budget.i2c_adap; 1359 1360 budget_ci->budget.dvb_frontend->ops.dishnetwork_send_legacy_command = NULL; 1361 if (dvb_attach(lnbp21_attach, budget_ci->budget.dvb_frontend, &budget_ci->budget.i2c_adap, LNBP21_LLC, 0) == NULL) { 1362 pr_err("%s(): No LNBP21 found!\n", __func__); 1363 dvb_frontend_detach(budget_ci->budget.dvb_frontend); 1364 budget_ci->budget.dvb_frontend = NULL; 1365 } 1366 } 1367 break; 1368 1369 case 0x101a: /* TT Budget-C-1501 (philips tda10023/philips tda8274A) */ 1370 budget_ci->budget.dvb_frontend = dvb_attach(tda10023_attach, &tda10023_config, &budget_ci->budget.i2c_adap, 0x48); 1371 if (budget_ci->budget.dvb_frontend) { 1372 if (dvb_attach(tda827x_attach, budget_ci->budget.dvb_frontend, 0x61, &budget_ci->budget.i2c_adap, &tda827x_config) == NULL) { 1373 pr_err("%s(): No tda827x found!\n", __func__); 1374 dvb_frontend_detach(budget_ci->budget.dvb_frontend); 1375 budget_ci->budget.dvb_frontend = NULL; 1376 } 1377 } 1378 break; 1379 1380 case 0x101b: /* TT S-1500B (BSBE1-D01A - STV0288/STB6000/LNBP21) */ 1381 budget_ci->budget.dvb_frontend = dvb_attach(stv0288_attach, &stv0288_bsbe1_d01a_config, &budget_ci->budget.i2c_adap); 1382 if (budget_ci->budget.dvb_frontend) { 1383 if (dvb_attach(stb6000_attach, budget_ci->budget.dvb_frontend, 0x63, &budget_ci->budget.i2c_adap)) { 1384 if (!dvb_attach(lnbp21_attach, budget_ci->budget.dvb_frontend, &budget_ci->budget.i2c_adap, 0, 0)) { 1385 pr_err("%s(): No LNBP21 found!\n", __func__); 1386 dvb_frontend_detach(budget_ci->budget.dvb_frontend); 1387 budget_ci->budget.dvb_frontend = NULL; 1388 } 1389 } else { 1390 pr_err("%s(): No STB6000 found!\n", __func__); 1391 dvb_frontend_detach(budget_ci->budget.dvb_frontend); 1392 budget_ci->budget.dvb_frontend = NULL; 1393 } 1394 } 1395 break; 1396 1397 case 0x1019: // TT S2-3200 PCI 1398 /* 1399 * NOTE! on some STB0899 versions, the internal PLL takes a longer time 1400 * to settle, aka LOCK. On the older revisions of the chip, we don't see 1401 * this, as a result on the newer chips the entire clock tree, will not 1402 * be stable after a freshly POWER 'ed up situation. 1403 * In this case, we should RESET the STB0899 (Active LOW) and wait for 1404 * PLL stabilization. 1405 * 1406 * On the TT S2 3200 and clones, the STB0899 demodulator's RESETB is 1407 * connected to the SAA7146 GPIO, GPIO2, Pin 142 1408 */ 1409 /* Reset Demodulator */ 1410 saa7146_setgpio(budget_ci->budget.dev, 2, SAA7146_GPIO_OUTLO); 1411 /* Wait for everything to die */ 1412 msleep(50); 1413 /* Pull it up out of Reset state */ 1414 saa7146_setgpio(budget_ci->budget.dev, 2, SAA7146_GPIO_OUTHI); 1415 /* Wait for PLL to stabilize */ 1416 msleep(250); 1417 /* 1418 * PLL state should be stable now. Ideally, we should check 1419 * for PLL LOCK status. But well, never mind! 1420 */ 1421 budget_ci->budget.dvb_frontend = dvb_attach(stb0899_attach, &tt3200_config, &budget_ci->budget.i2c_adap); 1422 if (budget_ci->budget.dvb_frontend) { 1423 if (dvb_attach(stb6100_attach, budget_ci->budget.dvb_frontend, &tt3200_stb6100_config, &budget_ci->budget.i2c_adap)) { 1424 if (!dvb_attach(lnbp21_attach, budget_ci->budget.dvb_frontend, &budget_ci->budget.i2c_adap, 0, 0)) { 1425 pr_err("%s(): No LNBP21 found!\n", __func__); 1426 dvb_frontend_detach(budget_ci->budget.dvb_frontend); 1427 budget_ci->budget.dvb_frontend = NULL; 1428 } 1429 } else { 1430 dvb_frontend_detach(budget_ci->budget.dvb_frontend); 1431 budget_ci->budget.dvb_frontend = NULL; 1432 } 1433 } 1434 break; 1435 1436 } 1437 1438 if (budget_ci->budget.dvb_frontend == NULL) { 1439 pr_err("A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n", 1440 budget_ci->budget.dev->pci->vendor, 1441 budget_ci->budget.dev->pci->device, 1442 budget_ci->budget.dev->pci->subsystem_vendor, 1443 budget_ci->budget.dev->pci->subsystem_device); 1444 } else { 1445 if (dvb_register_frontend 1446 (&budget_ci->budget.dvb_adapter, budget_ci->budget.dvb_frontend)) { 1447 pr_err("Frontend registration failed!\n"); 1448 dvb_frontend_detach(budget_ci->budget.dvb_frontend); 1449 budget_ci->budget.dvb_frontend = NULL; 1450 } 1451 } 1452 } 1453 1454 static int budget_ci_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info) 1455 { 1456 struct budget_ci *budget_ci; 1457 int err; 1458 1459 budget_ci = kzalloc(sizeof(struct budget_ci), GFP_KERNEL); 1460 if (!budget_ci) { 1461 err = -ENOMEM; 1462 goto out1; 1463 } 1464 1465 dprintk(2, "budget_ci: %p\n", budget_ci); 1466 1467 dev->ext_priv = budget_ci; 1468 1469 err = ttpci_budget_init(&budget_ci->budget, dev, info, THIS_MODULE, 1470 adapter_nr); 1471 if (err) 1472 goto out2; 1473 1474 err = msp430_ir_init(budget_ci); 1475 if (err) 1476 goto out3; 1477 1478 ciintf_init(budget_ci); 1479 1480 budget_ci->budget.dvb_adapter.priv = budget_ci; 1481 frontend_init(budget_ci); 1482 1483 ttpci_budget_init_hooks(&budget_ci->budget); 1484 1485 return 0; 1486 1487 out3: 1488 ttpci_budget_deinit(&budget_ci->budget); 1489 out2: 1490 kfree(budget_ci); 1491 out1: 1492 return err; 1493 } 1494 1495 static int budget_ci_detach(struct saa7146_dev *dev) 1496 { 1497 struct budget_ci *budget_ci = dev->ext_priv; 1498 struct saa7146_dev *saa = budget_ci->budget.dev; 1499 int err; 1500 1501 if (budget_ci->budget.ci_present) 1502 ciintf_deinit(budget_ci); 1503 msp430_ir_deinit(budget_ci); 1504 if (budget_ci->budget.dvb_frontend) { 1505 dvb_unregister_frontend(budget_ci->budget.dvb_frontend); 1506 dvb_frontend_detach(budget_ci->budget.dvb_frontend); 1507 } 1508 err = ttpci_budget_deinit(&budget_ci->budget); 1509 1510 // disable frontend and CI interface 1511 saa7146_setgpio(saa, 2, SAA7146_GPIO_INPUT); 1512 1513 kfree(budget_ci); 1514 1515 return err; 1516 } 1517 1518 static struct saa7146_extension budget_extension; 1519 1520 MAKE_BUDGET_INFO(ttbs2, "TT-Budget/S-1500 PCI", BUDGET_TT); 1521 MAKE_BUDGET_INFO(ttbci, "TT-Budget/WinTV-NOVA-CI PCI", BUDGET_TT_HW_DISEQC); 1522 MAKE_BUDGET_INFO(ttbt2, "TT-Budget/WinTV-NOVA-T PCI", BUDGET_TT); 1523 MAKE_BUDGET_INFO(ttbtci, "TT-Budget-T-CI PCI", BUDGET_TT); 1524 MAKE_BUDGET_INFO(ttbcci, "TT-Budget-C-CI PCI", BUDGET_TT); 1525 MAKE_BUDGET_INFO(ttc1501, "TT-Budget C-1501 PCI", BUDGET_TT); 1526 MAKE_BUDGET_INFO(tt3200, "TT-Budget S2-3200 PCI", BUDGET_TT); 1527 MAKE_BUDGET_INFO(ttbs1500b, "TT-Budget S-1500B PCI", BUDGET_TT); 1528 1529 static const struct pci_device_id pci_tbl[] = { 1530 MAKE_EXTENSION_PCI(ttbci, 0x13c2, 0x100c), 1531 MAKE_EXTENSION_PCI(ttbci, 0x13c2, 0x100f), 1532 MAKE_EXTENSION_PCI(ttbcci, 0x13c2, 0x1010), 1533 MAKE_EXTENSION_PCI(ttbt2, 0x13c2, 0x1011), 1534 MAKE_EXTENSION_PCI(ttbtci, 0x13c2, 0x1012), 1535 MAKE_EXTENSION_PCI(ttbs2, 0x13c2, 0x1017), 1536 MAKE_EXTENSION_PCI(ttc1501, 0x13c2, 0x101a), 1537 MAKE_EXTENSION_PCI(tt3200, 0x13c2, 0x1019), 1538 MAKE_EXTENSION_PCI(ttbs1500b, 0x13c2, 0x101b), 1539 { 1540 .vendor = 0, 1541 } 1542 }; 1543 1544 MODULE_DEVICE_TABLE(pci, pci_tbl); 1545 1546 static struct saa7146_extension budget_extension = { 1547 .name = "budget_ci dvb", 1548 .flags = SAA7146_USE_I2C_IRQ, 1549 1550 .module = THIS_MODULE, 1551 .pci_tbl = &pci_tbl[0], 1552 .attach = budget_ci_attach, 1553 .detach = budget_ci_detach, 1554 1555 .irq_mask = MASK_03 | MASK_06 | MASK_10, 1556 .irq_func = budget_ci_irq, 1557 }; 1558 1559 static int __init budget_ci_init(void) 1560 { 1561 return saa7146_register_extension(&budget_extension); 1562 } 1563 1564 static void __exit budget_ci_exit(void) 1565 { 1566 saa7146_unregister_extension(&budget_extension); 1567 } 1568 1569 module_init(budget_ci_init); 1570 module_exit(budget_ci_exit); 1571 1572 MODULE_LICENSE("GPL"); 1573 MODULE_AUTHOR("Michael Hunold, Jack Thomasson, Andrew de Quincey, others"); 1574 MODULE_DESCRIPTION("driver for the SAA7146 based so-called budget PCI DVB cards w/ CI-module produced by Siemens, Technotrend, Hauppauge"); 1575