1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * budget-av.c: driver for the SAA7146 based Budget DVB cards 4 * with analog video in 5 * 6 * Compiled from various sources by Michael Hunold <michael@mihu.de> 7 * 8 * CI interface support (c) 2004 Olivier Gournet <ogournet@anevia.com> & 9 * Andrew de Quincey <adq_dvb@lidskialf.net> 10 * 11 * Copyright (C) 2002 Ralph Metzler <rjkm@metzlerbros.de> 12 * 13 * Copyright (C) 1999-2002 Ralph Metzler 14 * & Marcus Metzler for convergence integrated media GmbH 15 * 16 * the project's page is at https://linuxtv.org 17 */ 18 19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 20 21 #include "budget.h" 22 #include "stv0299.h" 23 #include "stb0899_drv.h" 24 #include "stb0899_reg.h" 25 #include "stb0899_cfg.h" 26 #include "tda8261.h" 27 #include "tda8261_cfg.h" 28 #include "tda1002x.h" 29 #include "tda1004x.h" 30 #include "tua6100.h" 31 #include "dvb-pll.h" 32 #include <media/drv-intf/saa7146_vv.h> 33 #include <linux/module.h> 34 #include <linux/errno.h> 35 #include <linux/slab.h> 36 #include <linux/interrupt.h> 37 #include <linux/input.h> 38 #include <linux/spinlock.h> 39 40 #include <media/dvb_ca_en50221.h> 41 42 #define DEBICICAM 0x02420000 43 44 #define SLOTSTATUS_NONE 1 45 #define SLOTSTATUS_PRESENT 2 46 #define SLOTSTATUS_RESET 4 47 #define SLOTSTATUS_READY 8 48 #define SLOTSTATUS_OCCUPIED (SLOTSTATUS_PRESENT|SLOTSTATUS_RESET|SLOTSTATUS_READY) 49 50 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 51 52 struct budget_av { 53 struct budget budget; 54 struct video_device vd; 55 int cur_input; 56 int has_saa7113; 57 struct tasklet_struct ciintf_irq_tasklet; 58 int slot_status; 59 struct dvb_ca_en50221 ca; 60 u8 reinitialise_demod:1; 61 }; 62 63 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot); 64 65 66 /* GPIO Connections: 67 * 0 - Vcc/Reset (Reset is controlled by capacitor). Resets the frontend *AS WELL*! 68 * 1 - CI memory select 0=>IO memory, 1=>Attribute Memory 69 * 2 - CI Card Enable (Active Low) 70 * 3 - CI Card Detect 71 */ 72 73 /**************************************************************************** 74 * INITIALIZATION 75 ****************************************************************************/ 76 77 static u8 i2c_readreg(struct i2c_adapter *i2c, u8 id, u8 reg) 78 { 79 u8 mm1[] = { 0x00 }; 80 u8 mm2[] = { 0x00 }; 81 struct i2c_msg msgs[2]; 82 83 msgs[0].flags = 0; 84 msgs[1].flags = I2C_M_RD; 85 msgs[0].addr = msgs[1].addr = id / 2; 86 mm1[0] = reg; 87 msgs[0].len = 1; 88 msgs[1].len = 1; 89 msgs[0].buf = mm1; 90 msgs[1].buf = mm2; 91 92 i2c_transfer(i2c, msgs, 2); 93 94 return mm2[0]; 95 } 96 97 static int i2c_readregs(struct i2c_adapter *i2c, u8 id, u8 reg, u8 * buf, u8 len) 98 { 99 u8 mm1[] = { reg }; 100 struct i2c_msg msgs[2] = { 101 {.addr = id / 2,.flags = 0,.buf = mm1,.len = 1}, 102 {.addr = id / 2,.flags = I2C_M_RD,.buf = buf,.len = len} 103 }; 104 105 if (i2c_transfer(i2c, msgs, 2) != 2) 106 return -EIO; 107 108 return 0; 109 } 110 111 static int i2c_writereg(struct i2c_adapter *i2c, u8 id, u8 reg, u8 val) 112 { 113 u8 msg[2] = { reg, val }; 114 struct i2c_msg msgs; 115 116 msgs.flags = 0; 117 msgs.addr = id / 2; 118 msgs.len = 2; 119 msgs.buf = msg; 120 return i2c_transfer(i2c, &msgs, 1); 121 } 122 123 static int ciintf_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address) 124 { 125 struct budget_av *budget_av = (struct budget_av *) ca->data; 126 int result; 127 128 if (slot != 0) 129 return -EINVAL; 130 131 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTHI); 132 udelay(1); 133 134 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, address & 0xfff, 1, 0, 1); 135 if (result == -ETIMEDOUT) { 136 ciintf_slot_shutdown(ca, slot); 137 pr_info("cam ejected 1\n"); 138 } 139 return result; 140 } 141 142 static int ciintf_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value) 143 { 144 struct budget_av *budget_av = (struct budget_av *) ca->data; 145 int result; 146 147 if (slot != 0) 148 return -EINVAL; 149 150 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTHI); 151 udelay(1); 152 153 result = ttpci_budget_debiwrite(&budget_av->budget, DEBICICAM, address & 0xfff, 1, value, 0, 1); 154 if (result == -ETIMEDOUT) { 155 ciintf_slot_shutdown(ca, slot); 156 pr_info("cam ejected 2\n"); 157 } 158 return result; 159 } 160 161 static int ciintf_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address) 162 { 163 struct budget_av *budget_av = (struct budget_av *) ca->data; 164 int result; 165 166 if (slot != 0) 167 return -EINVAL; 168 169 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO); 170 udelay(1); 171 172 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, address & 3, 1, 0, 0); 173 if (result == -ETIMEDOUT) { 174 ciintf_slot_shutdown(ca, slot); 175 pr_info("cam ejected 3\n"); 176 return -ETIMEDOUT; 177 } 178 return result; 179 } 180 181 static int ciintf_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value) 182 { 183 struct budget_av *budget_av = (struct budget_av *) ca->data; 184 int result; 185 186 if (slot != 0) 187 return -EINVAL; 188 189 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO); 190 udelay(1); 191 192 result = ttpci_budget_debiwrite(&budget_av->budget, DEBICICAM, address & 3, 1, value, 0, 0); 193 if (result == -ETIMEDOUT) { 194 ciintf_slot_shutdown(ca, slot); 195 pr_info("cam ejected 5\n"); 196 } 197 return result; 198 } 199 200 static int ciintf_slot_reset(struct dvb_ca_en50221 *ca, int slot) 201 { 202 struct budget_av *budget_av = (struct budget_av *) ca->data; 203 struct saa7146_dev *saa = budget_av->budget.dev; 204 205 if (slot != 0) 206 return -EINVAL; 207 208 dprintk(1, "ciintf_slot_reset\n"); 209 budget_av->slot_status = SLOTSTATUS_RESET; 210 211 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTHI); /* disable card */ 212 213 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTHI); /* Vcc off */ 214 msleep(2); 215 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO); /* Vcc on */ 216 msleep(20); /* 20 ms Vcc settling time */ 217 218 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTLO); /* enable card */ 219 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB); 220 msleep(20); 221 222 /* reinitialise the frontend if necessary */ 223 if (budget_av->reinitialise_demod) 224 dvb_frontend_reinitialise(budget_av->budget.dvb_frontend); 225 226 return 0; 227 } 228 229 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot) 230 { 231 struct budget_av *budget_av = (struct budget_av *) ca->data; 232 struct saa7146_dev *saa = budget_av->budget.dev; 233 234 if (slot != 0) 235 return -EINVAL; 236 237 dprintk(1, "ciintf_slot_shutdown\n"); 238 239 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB); 240 budget_av->slot_status = SLOTSTATUS_NONE; 241 242 return 0; 243 } 244 245 static int ciintf_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot) 246 { 247 struct budget_av *budget_av = (struct budget_av *) ca->data; 248 struct saa7146_dev *saa = budget_av->budget.dev; 249 250 if (slot != 0) 251 return -EINVAL; 252 253 dprintk(1, "ciintf_slot_ts_enable: %d\n", budget_av->slot_status); 254 255 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTA); 256 257 return 0; 258 } 259 260 static int ciintf_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open) 261 { 262 struct budget_av *budget_av = (struct budget_av *) ca->data; 263 struct saa7146_dev *saa = budget_av->budget.dev; 264 int result; 265 266 if (slot != 0) 267 return -EINVAL; 268 269 /* test the card detect line - needs to be done carefully 270 * since it never goes high for some CAMs on this interface (e.g. topuptv) */ 271 if (budget_av->slot_status == SLOTSTATUS_NONE) { 272 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT); 273 udelay(1); 274 if (saa7146_read(saa, PSR) & MASK_06) { 275 if (budget_av->slot_status == SLOTSTATUS_NONE) { 276 budget_av->slot_status = SLOTSTATUS_PRESENT; 277 pr_info("cam inserted A\n"); 278 } 279 } 280 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO); 281 } 282 283 /* We also try and read from IO memory to work round the above detection bug. If 284 * there is no CAM, we will get a timeout. Only done if there is no cam 285 * present, since this test actually breaks some cams :( 286 * 287 * if the CI interface is not open, we also do the above test since we 288 * don't care if the cam has problems - we'll be resetting it on open() anyway */ 289 if ((budget_av->slot_status == SLOTSTATUS_NONE) || (!open)) { 290 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO); 291 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, 0, 1, 0, 1); 292 if ((result >= 0) && (budget_av->slot_status == SLOTSTATUS_NONE)) { 293 budget_av->slot_status = SLOTSTATUS_PRESENT; 294 pr_info("cam inserted B\n"); 295 } else if (result < 0) { 296 if (budget_av->slot_status != SLOTSTATUS_NONE) { 297 ciintf_slot_shutdown(ca, slot); 298 pr_info("cam ejected 5\n"); 299 return 0; 300 } 301 } 302 } 303 304 /* read from attribute memory in reset/ready state to know when the CAM is ready */ 305 if (budget_av->slot_status == SLOTSTATUS_RESET) { 306 result = ciintf_read_attribute_mem(ca, slot, 0); 307 if (result == 0x1d) { 308 budget_av->slot_status = SLOTSTATUS_READY; 309 } 310 } 311 312 /* work out correct return code */ 313 if (budget_av->slot_status != SLOTSTATUS_NONE) { 314 if (budget_av->slot_status & SLOTSTATUS_READY) { 315 return DVB_CA_EN50221_POLL_CAM_PRESENT | DVB_CA_EN50221_POLL_CAM_READY; 316 } 317 return DVB_CA_EN50221_POLL_CAM_PRESENT; 318 } 319 return 0; 320 } 321 322 static int ciintf_init(struct budget_av *budget_av) 323 { 324 struct saa7146_dev *saa = budget_av->budget.dev; 325 int result; 326 327 memset(&budget_av->ca, 0, sizeof(struct dvb_ca_en50221)); 328 329 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO); 330 saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTLO); 331 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTLO); 332 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO); 333 334 /* Enable DEBI pins */ 335 saa7146_write(saa, MC1, MASK_27 | MASK_11); 336 337 /* register CI interface */ 338 budget_av->ca.owner = THIS_MODULE; 339 budget_av->ca.read_attribute_mem = ciintf_read_attribute_mem; 340 budget_av->ca.write_attribute_mem = ciintf_write_attribute_mem; 341 budget_av->ca.read_cam_control = ciintf_read_cam_control; 342 budget_av->ca.write_cam_control = ciintf_write_cam_control; 343 budget_av->ca.slot_reset = ciintf_slot_reset; 344 budget_av->ca.slot_shutdown = ciintf_slot_shutdown; 345 budget_av->ca.slot_ts_enable = ciintf_slot_ts_enable; 346 budget_av->ca.poll_slot_status = ciintf_poll_slot_status; 347 budget_av->ca.data = budget_av; 348 budget_av->budget.ci_present = 1; 349 budget_av->slot_status = SLOTSTATUS_NONE; 350 351 if ((result = dvb_ca_en50221_init(&budget_av->budget.dvb_adapter, 352 &budget_av->ca, 0, 1)) != 0) { 353 pr_err("ci initialisation failed\n"); 354 goto error; 355 } 356 357 pr_info("ci interface initialised\n"); 358 return 0; 359 360 error: 361 saa7146_write(saa, MC1, MASK_27); 362 return result; 363 } 364 365 static void ciintf_deinit(struct budget_av *budget_av) 366 { 367 struct saa7146_dev *saa = budget_av->budget.dev; 368 369 saa7146_setgpio(saa, 0, SAA7146_GPIO_INPUT); 370 saa7146_setgpio(saa, 1, SAA7146_GPIO_INPUT); 371 saa7146_setgpio(saa, 2, SAA7146_GPIO_INPUT); 372 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT); 373 374 /* release the CA device */ 375 dvb_ca_en50221_release(&budget_av->ca); 376 377 /* disable DEBI pins */ 378 saa7146_write(saa, MC1, MASK_27); 379 } 380 381 382 static const u8 saa7113_tab[] = { 383 0x01, 0x08, 384 0x02, 0xc0, 385 0x03, 0x33, 386 0x04, 0x00, 387 0x05, 0x00, 388 0x06, 0xeb, 389 0x07, 0xe0, 390 0x08, 0x28, 391 0x09, 0x00, 392 0x0a, 0x80, 393 0x0b, 0x47, 394 0x0c, 0x40, 395 0x0d, 0x00, 396 0x0e, 0x01, 397 0x0f, 0x44, 398 399 0x10, 0x08, 400 0x11, 0x0c, 401 0x12, 0x7b, 402 0x13, 0x00, 403 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 404 405 0x57, 0xff, 406 0x40, 0x82, 0x58, 0x00, 0x59, 0x54, 0x5a, 0x07, 407 0x5b, 0x83, 0x5e, 0x00, 408 0xff 409 }; 410 411 static int saa7113_init(struct budget_av *budget_av) 412 { 413 struct budget *budget = &budget_av->budget; 414 struct saa7146_dev *saa = budget->dev; 415 const u8 *data = saa7113_tab; 416 417 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTHI); 418 msleep(200); 419 420 if (i2c_writereg(&budget->i2c_adap, 0x4a, 0x01, 0x08) != 1) { 421 dprintk(1, "saa7113 not found on KNC card\n"); 422 return -ENODEV; 423 } 424 425 dprintk(1, "saa7113 detected and initializing\n"); 426 427 while (*data != 0xff) { 428 i2c_writereg(&budget->i2c_adap, 0x4a, *data, *(data + 1)); 429 data += 2; 430 } 431 432 dprintk(1, "saa7113 status=%02x\n", i2c_readreg(&budget->i2c_adap, 0x4a, 0x1f)); 433 434 return 0; 435 } 436 437 static int saa7113_setinput(struct budget_av *budget_av, int input) 438 { 439 struct budget *budget = &budget_av->budget; 440 441 if (1 != budget_av->has_saa7113) 442 return -ENODEV; 443 444 if (input == 1) { 445 i2c_writereg(&budget->i2c_adap, 0x4a, 0x02, 0xc7); 446 i2c_writereg(&budget->i2c_adap, 0x4a, 0x09, 0x80); 447 } else if (input == 0) { 448 i2c_writereg(&budget->i2c_adap, 0x4a, 0x02, 0xc0); 449 i2c_writereg(&budget->i2c_adap, 0x4a, 0x09, 0x00); 450 } else 451 return -EINVAL; 452 453 budget_av->cur_input = input; 454 return 0; 455 } 456 457 458 static int philips_su1278_ty_ci_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio) 459 { 460 u8 aclk = 0; 461 u8 bclk = 0; 462 u8 m1; 463 464 aclk = 0xb5; 465 if (srate < 2000000) 466 bclk = 0x86; 467 else if (srate < 5000000) 468 bclk = 0x89; 469 else if (srate < 15000000) 470 bclk = 0x8f; 471 else if (srate < 45000000) 472 bclk = 0x95; 473 474 m1 = 0x14; 475 if (srate < 4000000) 476 m1 = 0x10; 477 478 stv0299_writereg(fe, 0x13, aclk); 479 stv0299_writereg(fe, 0x14, bclk); 480 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff); 481 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff); 482 stv0299_writereg(fe, 0x21, (ratio) & 0xf0); 483 stv0299_writereg(fe, 0x0f, 0x80 | m1); 484 485 return 0; 486 } 487 488 static int philips_su1278_ty_ci_tuner_set_params(struct dvb_frontend *fe) 489 { 490 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 491 u32 div; 492 u8 buf[4]; 493 struct budget *budget = (struct budget *) fe->dvb->priv; 494 struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) }; 495 496 if ((c->frequency < 950000) || (c->frequency > 2150000)) 497 return -EINVAL; 498 499 div = (c->frequency + (125 - 1)) / 125; /* round correctly */ 500 buf[0] = (div >> 8) & 0x7f; 501 buf[1] = div & 0xff; 502 buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4; 503 buf[3] = 0x20; 504 505 if (c->symbol_rate < 4000000) 506 buf[3] |= 1; 507 508 if (c->frequency < 1250000) 509 buf[3] |= 0; 510 else if (c->frequency < 1550000) 511 buf[3] |= 0x40; 512 else if (c->frequency < 2050000) 513 buf[3] |= 0x80; 514 else if (c->frequency < 2150000) 515 buf[3] |= 0xC0; 516 517 if (fe->ops.i2c_gate_ctrl) 518 fe->ops.i2c_gate_ctrl(fe, 1); 519 if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1) 520 return -EIO; 521 return 0; 522 } 523 524 static u8 typhoon_cinergy1200s_inittab[] = { 525 0x01, 0x15, 526 0x02, 0x30, 527 0x03, 0x00, 528 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */ 529 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */ 530 0x06, 0x40, /* DAC not used, set to high impendance mode */ 531 0x07, 0x00, /* DAC LSB */ 532 0x08, 0x40, /* DiSEqC off */ 533 0x09, 0x00, /* FIFO */ 534 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */ 535 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */ 536 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */ 537 0x10, 0x3f, // AGC2 0x3d 538 0x11, 0x84, 539 0x12, 0xb9, 540 0x15, 0xc9, // lock detector threshold 541 0x16, 0x00, 542 0x17, 0x00, 543 0x18, 0x00, 544 0x19, 0x00, 545 0x1a, 0x00, 546 0x1f, 0x50, 547 0x20, 0x00, 548 0x21, 0x00, 549 0x22, 0x00, 550 0x23, 0x00, 551 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0 552 0x29, 0x1e, // 1/2 threshold 553 0x2a, 0x14, // 2/3 threshold 554 0x2b, 0x0f, // 3/4 threshold 555 0x2c, 0x09, // 5/6 threshold 556 0x2d, 0x05, // 7/8 threshold 557 0x2e, 0x01, 558 0x31, 0x1f, // test all FECs 559 0x32, 0x19, // viterbi and synchro search 560 0x33, 0xfc, // rs control 561 0x34, 0x93, // error control 562 0x0f, 0x92, 563 0xff, 0xff 564 }; 565 566 static const struct stv0299_config typhoon_config = { 567 .demod_address = 0x68, 568 .inittab = typhoon_cinergy1200s_inittab, 569 .mclk = 88000000UL, 570 .invert = 0, 571 .skip_reinit = 0, 572 .lock_output = STV0299_LOCKOUTPUT_1, 573 .volt13_op0_op1 = STV0299_VOLT13_OP0, 574 .min_delay_ms = 100, 575 .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate, 576 }; 577 578 579 static const struct stv0299_config cinergy_1200s_config = { 580 .demod_address = 0x68, 581 .inittab = typhoon_cinergy1200s_inittab, 582 .mclk = 88000000UL, 583 .invert = 0, 584 .skip_reinit = 0, 585 .lock_output = STV0299_LOCKOUTPUT_0, 586 .volt13_op0_op1 = STV0299_VOLT13_OP0, 587 .min_delay_ms = 100, 588 .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate, 589 }; 590 591 static const struct stv0299_config cinergy_1200s_1894_0010_config = { 592 .demod_address = 0x68, 593 .inittab = typhoon_cinergy1200s_inittab, 594 .mclk = 88000000UL, 595 .invert = 1, 596 .skip_reinit = 0, 597 .lock_output = STV0299_LOCKOUTPUT_1, 598 .volt13_op0_op1 = STV0299_VOLT13_OP0, 599 .min_delay_ms = 100, 600 .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate, 601 }; 602 603 static int philips_cu1216_tuner_set_params(struct dvb_frontend *fe) 604 { 605 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 606 struct budget *budget = (struct budget *) fe->dvb->priv; 607 u8 buf[6]; 608 struct i2c_msg msg = {.addr = 0x60,.flags = 0,.buf = buf,.len = sizeof(buf) }; 609 int i; 610 611 #define CU1216_IF 36125000 612 #define TUNER_MUL 62500 613 614 u32 div = (c->frequency + CU1216_IF + TUNER_MUL / 2) / TUNER_MUL; 615 616 buf[0] = (div >> 8) & 0x7f; 617 buf[1] = div & 0xff; 618 buf[2] = 0xce; 619 buf[3] = (c->frequency < 150000000 ? 0x01 : 620 c->frequency < 445000000 ? 0x02 : 0x04); 621 buf[4] = 0xde; 622 buf[5] = 0x20; 623 624 if (fe->ops.i2c_gate_ctrl) 625 fe->ops.i2c_gate_ctrl(fe, 1); 626 if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1) 627 return -EIO; 628 629 /* wait for the pll lock */ 630 msg.flags = I2C_M_RD; 631 msg.len = 1; 632 for (i = 0; i < 20; i++) { 633 if (fe->ops.i2c_gate_ctrl) 634 fe->ops.i2c_gate_ctrl(fe, 1); 635 if (i2c_transfer(&budget->i2c_adap, &msg, 1) == 1 && (buf[0] & 0x40)) 636 break; 637 msleep(10); 638 } 639 640 /* switch the charge pump to the lower current */ 641 msg.flags = 0; 642 msg.len = 2; 643 msg.buf = &buf[2]; 644 buf[2] &= ~0x40; 645 if (fe->ops.i2c_gate_ctrl) 646 fe->ops.i2c_gate_ctrl(fe, 1); 647 if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1) 648 return -EIO; 649 650 return 0; 651 } 652 653 static struct tda1002x_config philips_cu1216_config = { 654 .demod_address = 0x0c, 655 .invert = 1, 656 }; 657 658 static struct tda1002x_config philips_cu1216_config_altaddress = { 659 .demod_address = 0x0d, 660 .invert = 0, 661 }; 662 663 static struct tda10023_config philips_cu1216_tda10023_config = { 664 .demod_address = 0x0c, 665 .invert = 1, 666 }; 667 668 static int philips_tu1216_tuner_init(struct dvb_frontend *fe) 669 { 670 struct budget *budget = (struct budget *) fe->dvb->priv; 671 static u8 tu1216_init[] = { 0x0b, 0xf5, 0x85, 0xab }; 672 struct i2c_msg tuner_msg = {.addr = 0x60,.flags = 0,.buf = tu1216_init,.len = sizeof(tu1216_init) }; 673 674 // setup PLL configuration 675 if (fe->ops.i2c_gate_ctrl) 676 fe->ops.i2c_gate_ctrl(fe, 1); 677 if (i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1) 678 return -EIO; 679 msleep(1); 680 681 return 0; 682 } 683 684 static int philips_tu1216_tuner_set_params(struct dvb_frontend *fe) 685 { 686 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 687 struct budget *budget = (struct budget *) fe->dvb->priv; 688 u8 tuner_buf[4]; 689 struct i2c_msg tuner_msg = {.addr = 0x60,.flags = 0,.buf = tuner_buf,.len = 690 sizeof(tuner_buf) }; 691 int tuner_frequency = 0; 692 u8 band, cp, filter; 693 694 // determine charge pump 695 tuner_frequency = c->frequency + 36166000; 696 if (tuner_frequency < 87000000) 697 return -EINVAL; 698 else if (tuner_frequency < 130000000) 699 cp = 3; 700 else if (tuner_frequency < 160000000) 701 cp = 5; 702 else if (tuner_frequency < 200000000) 703 cp = 6; 704 else if (tuner_frequency < 290000000) 705 cp = 3; 706 else if (tuner_frequency < 420000000) 707 cp = 5; 708 else if (tuner_frequency < 480000000) 709 cp = 6; 710 else if (tuner_frequency < 620000000) 711 cp = 3; 712 else if (tuner_frequency < 830000000) 713 cp = 5; 714 else if (tuner_frequency < 895000000) 715 cp = 7; 716 else 717 return -EINVAL; 718 719 // determine band 720 if (c->frequency < 49000000) 721 return -EINVAL; 722 else if (c->frequency < 161000000) 723 band = 1; 724 else if (c->frequency < 444000000) 725 band = 2; 726 else if (c->frequency < 861000000) 727 band = 4; 728 else 729 return -EINVAL; 730 731 // setup PLL filter 732 switch (c->bandwidth_hz) { 733 case 6000000: 734 filter = 0; 735 break; 736 737 case 7000000: 738 filter = 0; 739 break; 740 741 case 8000000: 742 filter = 1; 743 break; 744 745 default: 746 return -EINVAL; 747 } 748 749 // calculate divisor 750 // ((36166000+((1000000/6)/2)) + Finput)/(1000000/6) 751 tuner_frequency = (((c->frequency / 1000) * 6) + 217496) / 1000; 752 753 // setup tuner buffer 754 tuner_buf[0] = (tuner_frequency >> 8) & 0x7f; 755 tuner_buf[1] = tuner_frequency & 0xff; 756 tuner_buf[2] = 0xca; 757 tuner_buf[3] = (cp << 5) | (filter << 3) | band; 758 759 if (fe->ops.i2c_gate_ctrl) 760 fe->ops.i2c_gate_ctrl(fe, 1); 761 if (i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1) 762 return -EIO; 763 764 msleep(1); 765 return 0; 766 } 767 768 static int philips_tu1216_request_firmware(struct dvb_frontend *fe, 769 const struct firmware **fw, char *name) 770 { 771 struct budget *budget = (struct budget *) fe->dvb->priv; 772 773 return request_firmware(fw, name, &budget->dev->pci->dev); 774 } 775 776 static struct tda1004x_config philips_tu1216_config = { 777 778 .demod_address = 0x8, 779 .invert = 1, 780 .invert_oclk = 1, 781 .xtal_freq = TDA10046_XTAL_4M, 782 .agc_config = TDA10046_AGC_DEFAULT, 783 .if_freq = TDA10046_FREQ_3617, 784 .request_firmware = philips_tu1216_request_firmware, 785 }; 786 787 static u8 philips_sd1878_inittab[] = { 788 0x01, 0x15, 789 0x02, 0x30, 790 0x03, 0x00, 791 0x04, 0x7d, 792 0x05, 0x35, 793 0x06, 0x40, 794 0x07, 0x00, 795 0x08, 0x43, 796 0x09, 0x02, 797 0x0C, 0x51, 798 0x0D, 0x82, 799 0x0E, 0x23, 800 0x10, 0x3f, 801 0x11, 0x84, 802 0x12, 0xb9, 803 0x15, 0xc9, 804 0x16, 0x19, 805 0x17, 0x8c, 806 0x18, 0x59, 807 0x19, 0xf8, 808 0x1a, 0xfe, 809 0x1c, 0x7f, 810 0x1d, 0x00, 811 0x1e, 0x00, 812 0x1f, 0x50, 813 0x20, 0x00, 814 0x21, 0x00, 815 0x22, 0x00, 816 0x23, 0x00, 817 0x28, 0x00, 818 0x29, 0x28, 819 0x2a, 0x14, 820 0x2b, 0x0f, 821 0x2c, 0x09, 822 0x2d, 0x09, 823 0x31, 0x1f, 824 0x32, 0x19, 825 0x33, 0xfc, 826 0x34, 0x93, 827 0xff, 0xff 828 }; 829 830 static int philips_sd1878_ci_set_symbol_rate(struct dvb_frontend *fe, 831 u32 srate, u32 ratio) 832 { 833 u8 aclk = 0; 834 u8 bclk = 0; 835 u8 m1; 836 837 aclk = 0xb5; 838 if (srate < 2000000) 839 bclk = 0x86; 840 else if (srate < 5000000) 841 bclk = 0x89; 842 else if (srate < 15000000) 843 bclk = 0x8f; 844 else if (srate < 45000000) 845 bclk = 0x95; 846 847 m1 = 0x14; 848 if (srate < 4000000) 849 m1 = 0x10; 850 851 stv0299_writereg(fe, 0x0e, 0x23); 852 stv0299_writereg(fe, 0x0f, 0x94); 853 stv0299_writereg(fe, 0x10, 0x39); 854 stv0299_writereg(fe, 0x13, aclk); 855 stv0299_writereg(fe, 0x14, bclk); 856 stv0299_writereg(fe, 0x15, 0xc9); 857 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff); 858 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff); 859 stv0299_writereg(fe, 0x21, (ratio) & 0xf0); 860 stv0299_writereg(fe, 0x0f, 0x80 | m1); 861 862 return 0; 863 } 864 865 static const struct stv0299_config philips_sd1878_config = { 866 .demod_address = 0x68, 867 .inittab = philips_sd1878_inittab, 868 .mclk = 88000000UL, 869 .invert = 0, 870 .skip_reinit = 0, 871 .lock_output = STV0299_LOCKOUTPUT_1, 872 .volt13_op0_op1 = STV0299_VOLT13_OP0, 873 .min_delay_ms = 100, 874 .set_symbol_rate = philips_sd1878_ci_set_symbol_rate, 875 }; 876 877 /* KNC1 DVB-S (STB0899) Inittab */ 878 static const struct stb0899_s1_reg knc1_stb0899_s1_init_1[] = { 879 880 { STB0899_DEV_ID , 0x81 }, 881 { STB0899_DISCNTRL1 , 0x32 }, 882 { STB0899_DISCNTRL2 , 0x80 }, 883 { STB0899_DISRX_ST0 , 0x04 }, 884 { STB0899_DISRX_ST1 , 0x00 }, 885 { STB0899_DISPARITY , 0x00 }, 886 { STB0899_DISSTATUS , 0x20 }, 887 { STB0899_DISF22 , 0x8c }, 888 { STB0899_DISF22RX , 0x9a }, 889 { STB0899_SYSREG , 0x0b }, 890 { STB0899_ACRPRESC , 0x11 }, 891 { STB0899_ACRDIV1 , 0x0a }, 892 { STB0899_ACRDIV2 , 0x05 }, 893 { STB0899_DACR1 , 0x00 }, 894 { STB0899_DACR2 , 0x00 }, 895 { STB0899_OUTCFG , 0x00 }, 896 { STB0899_MODECFG , 0x00 }, 897 { STB0899_IRQSTATUS_3 , 0x30 }, 898 { STB0899_IRQSTATUS_2 , 0x00 }, 899 { STB0899_IRQSTATUS_1 , 0x00 }, 900 { STB0899_IRQSTATUS_0 , 0x00 }, 901 { STB0899_IRQMSK_3 , 0xf3 }, 902 { STB0899_IRQMSK_2 , 0xfc }, 903 { STB0899_IRQMSK_1 , 0xff }, 904 { STB0899_IRQMSK_0 , 0xff }, 905 { STB0899_IRQCFG , 0x00 }, 906 { STB0899_I2CCFG , 0x88 }, 907 { STB0899_I2CRPT , 0x58 }, /* Repeater=8, Stop=disabled */ 908 { STB0899_IOPVALUE5 , 0x00 }, 909 { STB0899_IOPVALUE4 , 0x20 }, 910 { STB0899_IOPVALUE3 , 0xc9 }, 911 { STB0899_IOPVALUE2 , 0x90 }, 912 { STB0899_IOPVALUE1 , 0x40 }, 913 { STB0899_IOPVALUE0 , 0x00 }, 914 { STB0899_GPIO00CFG , 0x82 }, 915 { STB0899_GPIO01CFG , 0x82 }, 916 { STB0899_GPIO02CFG , 0x82 }, 917 { STB0899_GPIO03CFG , 0x82 }, 918 { STB0899_GPIO04CFG , 0x82 }, 919 { STB0899_GPIO05CFG , 0x82 }, 920 { STB0899_GPIO06CFG , 0x82 }, 921 { STB0899_GPIO07CFG , 0x82 }, 922 { STB0899_GPIO08CFG , 0x82 }, 923 { STB0899_GPIO09CFG , 0x82 }, 924 { STB0899_GPIO10CFG , 0x82 }, 925 { STB0899_GPIO11CFG , 0x82 }, 926 { STB0899_GPIO12CFG , 0x82 }, 927 { STB0899_GPIO13CFG , 0x82 }, 928 { STB0899_GPIO14CFG , 0x82 }, 929 { STB0899_GPIO15CFG , 0x82 }, 930 { STB0899_GPIO16CFG , 0x82 }, 931 { STB0899_GPIO17CFG , 0x82 }, 932 { STB0899_GPIO18CFG , 0x82 }, 933 { STB0899_GPIO19CFG , 0x82 }, 934 { STB0899_GPIO20CFG , 0x82 }, 935 { STB0899_SDATCFG , 0xb8 }, 936 { STB0899_SCLTCFG , 0xba }, 937 { STB0899_AGCRFCFG , 0x08 }, /* 0x1c */ 938 { STB0899_GPIO22 , 0x82 }, /* AGCBB2CFG */ 939 { STB0899_GPIO21 , 0x91 }, /* AGCBB1CFG */ 940 { STB0899_DIRCLKCFG , 0x82 }, 941 { STB0899_CLKOUT27CFG , 0x7e }, 942 { STB0899_STDBYCFG , 0x82 }, 943 { STB0899_CS0CFG , 0x82 }, 944 { STB0899_CS1CFG , 0x82 }, 945 { STB0899_DISEQCOCFG , 0x20 }, 946 { STB0899_GPIO32CFG , 0x82 }, 947 { STB0899_GPIO33CFG , 0x82 }, 948 { STB0899_GPIO34CFG , 0x82 }, 949 { STB0899_GPIO35CFG , 0x82 }, 950 { STB0899_GPIO36CFG , 0x82 }, 951 { STB0899_GPIO37CFG , 0x82 }, 952 { STB0899_GPIO38CFG , 0x82 }, 953 { STB0899_GPIO39CFG , 0x82 }, 954 { STB0899_NCOARSE , 0x15 }, /* 0x15 = 27 Mhz Clock, F/3 = 198MHz, F/6 = 99MHz */ 955 { STB0899_SYNTCTRL , 0x02 }, /* 0x00 = CLK from CLKI, 0x02 = CLK from XTALI */ 956 { STB0899_FILTCTRL , 0x00 }, 957 { STB0899_SYSCTRL , 0x00 }, 958 { STB0899_STOPCLK1 , 0x20 }, 959 { STB0899_STOPCLK2 , 0x00 }, 960 { STB0899_INTBUFSTATUS , 0x00 }, 961 { STB0899_INTBUFCTRL , 0x0a }, 962 { 0xffff , 0xff }, 963 }; 964 965 static const struct stb0899_s1_reg knc1_stb0899_s1_init_3[] = { 966 { STB0899_DEMOD , 0x00 }, 967 { STB0899_RCOMPC , 0xc9 }, 968 { STB0899_AGC1CN , 0x41 }, 969 { STB0899_AGC1REF , 0x08 }, 970 { STB0899_RTC , 0x7a }, 971 { STB0899_TMGCFG , 0x4e }, 972 { STB0899_AGC2REF , 0x33 }, 973 { STB0899_TLSR , 0x84 }, 974 { STB0899_CFD , 0xee }, 975 { STB0899_ACLC , 0x87 }, 976 { STB0899_BCLC , 0x94 }, 977 { STB0899_EQON , 0x41 }, 978 { STB0899_LDT , 0xdd }, 979 { STB0899_LDT2 , 0xc9 }, 980 { STB0899_EQUALREF , 0xb4 }, 981 { STB0899_TMGRAMP , 0x10 }, 982 { STB0899_TMGTHD , 0x30 }, 983 { STB0899_IDCCOMP , 0xfb }, 984 { STB0899_QDCCOMP , 0x03 }, 985 { STB0899_POWERI , 0x3b }, 986 { STB0899_POWERQ , 0x3d }, 987 { STB0899_RCOMP , 0x81 }, 988 { STB0899_AGCIQIN , 0x80 }, 989 { STB0899_AGC2I1 , 0x04 }, 990 { STB0899_AGC2I2 , 0xf5 }, 991 { STB0899_TLIR , 0x25 }, 992 { STB0899_RTF , 0x80 }, 993 { STB0899_DSTATUS , 0x00 }, 994 { STB0899_LDI , 0xca }, 995 { STB0899_CFRM , 0xf1 }, 996 { STB0899_CFRL , 0xf3 }, 997 { STB0899_NIRM , 0x2a }, 998 { STB0899_NIRL , 0x05 }, 999 { STB0899_ISYMB , 0x17 }, 1000 { STB0899_QSYMB , 0xfa }, 1001 { STB0899_SFRH , 0x2f }, 1002 { STB0899_SFRM , 0x68 }, 1003 { STB0899_SFRL , 0x40 }, 1004 { STB0899_SFRUPH , 0x2f }, 1005 { STB0899_SFRUPM , 0x68 }, 1006 { STB0899_SFRUPL , 0x40 }, 1007 { STB0899_EQUAI1 , 0xfd }, 1008 { STB0899_EQUAQ1 , 0x04 }, 1009 { STB0899_EQUAI2 , 0x0f }, 1010 { STB0899_EQUAQ2 , 0xff }, 1011 { STB0899_EQUAI3 , 0xdf }, 1012 { STB0899_EQUAQ3 , 0xfa }, 1013 { STB0899_EQUAI4 , 0x37 }, 1014 { STB0899_EQUAQ4 , 0x0d }, 1015 { STB0899_EQUAI5 , 0xbd }, 1016 { STB0899_EQUAQ5 , 0xf7 }, 1017 { STB0899_DSTATUS2 , 0x00 }, 1018 { STB0899_VSTATUS , 0x00 }, 1019 { STB0899_VERROR , 0xff }, 1020 { STB0899_IQSWAP , 0x2a }, 1021 { STB0899_ECNT1M , 0x00 }, 1022 { STB0899_ECNT1L , 0x00 }, 1023 { STB0899_ECNT2M , 0x00 }, 1024 { STB0899_ECNT2L , 0x00 }, 1025 { STB0899_ECNT3M , 0x00 }, 1026 { STB0899_ECNT3L , 0x00 }, 1027 { STB0899_FECAUTO1 , 0x06 }, 1028 { STB0899_FECM , 0x01 }, 1029 { STB0899_VTH12 , 0xf0 }, 1030 { STB0899_VTH23 , 0xa0 }, 1031 { STB0899_VTH34 , 0x78 }, 1032 { STB0899_VTH56 , 0x4e }, 1033 { STB0899_VTH67 , 0x48 }, 1034 { STB0899_VTH78 , 0x38 }, 1035 { STB0899_PRVIT , 0xff }, 1036 { STB0899_VITSYNC , 0x19 }, 1037 { STB0899_RSULC , 0xb1 }, /* DVB = 0xb1, DSS = 0xa1 */ 1038 { STB0899_TSULC , 0x42 }, 1039 { STB0899_RSLLC , 0x40 }, 1040 { STB0899_TSLPL , 0x12 }, 1041 { STB0899_TSCFGH , 0x0c }, 1042 { STB0899_TSCFGM , 0x00 }, 1043 { STB0899_TSCFGL , 0x0c }, 1044 { STB0899_TSOUT , 0x4d }, /* 0x0d for CAM */ 1045 { STB0899_RSSYNCDEL , 0x00 }, 1046 { STB0899_TSINHDELH , 0x02 }, 1047 { STB0899_TSINHDELM , 0x00 }, 1048 { STB0899_TSINHDELL , 0x00 }, 1049 { STB0899_TSLLSTKM , 0x00 }, 1050 { STB0899_TSLLSTKL , 0x00 }, 1051 { STB0899_TSULSTKM , 0x00 }, 1052 { STB0899_TSULSTKL , 0xab }, 1053 { STB0899_PCKLENUL , 0x00 }, 1054 { STB0899_PCKLENLL , 0xcc }, 1055 { STB0899_RSPCKLEN , 0xcc }, 1056 { STB0899_TSSTATUS , 0x80 }, 1057 { STB0899_ERRCTRL1 , 0xb6 }, 1058 { STB0899_ERRCTRL2 , 0x96 }, 1059 { STB0899_ERRCTRL3 , 0x89 }, 1060 { STB0899_DMONMSK1 , 0x27 }, 1061 { STB0899_DMONMSK0 , 0x03 }, 1062 { STB0899_DEMAPVIT , 0x5c }, 1063 { STB0899_PLPARM , 0x1f }, 1064 { STB0899_PDELCTRL , 0x48 }, 1065 { STB0899_PDELCTRL2 , 0x00 }, 1066 { STB0899_BBHCTRL1 , 0x00 }, 1067 { STB0899_BBHCTRL2 , 0x00 }, 1068 { STB0899_HYSTTHRESH , 0x77 }, 1069 { STB0899_MATCSTM , 0x00 }, 1070 { STB0899_MATCSTL , 0x00 }, 1071 { STB0899_UPLCSTM , 0x00 }, 1072 { STB0899_UPLCSTL , 0x00 }, 1073 { STB0899_DFLCSTM , 0x00 }, 1074 { STB0899_DFLCSTL , 0x00 }, 1075 { STB0899_SYNCCST , 0x00 }, 1076 { STB0899_SYNCDCSTM , 0x00 }, 1077 { STB0899_SYNCDCSTL , 0x00 }, 1078 { STB0899_ISI_ENTRY , 0x00 }, 1079 { STB0899_ISI_BIT_EN , 0x00 }, 1080 { STB0899_MATSTRM , 0x00 }, 1081 { STB0899_MATSTRL , 0x00 }, 1082 { STB0899_UPLSTRM , 0x00 }, 1083 { STB0899_UPLSTRL , 0x00 }, 1084 { STB0899_DFLSTRM , 0x00 }, 1085 { STB0899_DFLSTRL , 0x00 }, 1086 { STB0899_SYNCSTR , 0x00 }, 1087 { STB0899_SYNCDSTRM , 0x00 }, 1088 { STB0899_SYNCDSTRL , 0x00 }, 1089 { STB0899_CFGPDELSTATUS1 , 0x10 }, 1090 { STB0899_CFGPDELSTATUS2 , 0x00 }, 1091 { STB0899_BBFERRORM , 0x00 }, 1092 { STB0899_BBFERRORL , 0x00 }, 1093 { STB0899_UPKTERRORM , 0x00 }, 1094 { STB0899_UPKTERRORL , 0x00 }, 1095 { 0xffff , 0xff }, 1096 }; 1097 1098 /* STB0899 demodulator config for the KNC1 and clones */ 1099 static struct stb0899_config knc1_dvbs2_config = { 1100 .init_dev = knc1_stb0899_s1_init_1, 1101 .init_s2_demod = stb0899_s2_init_2, 1102 .init_s1_demod = knc1_stb0899_s1_init_3, 1103 .init_s2_fec = stb0899_s2_init_4, 1104 .init_tst = stb0899_s1_init_5, 1105 1106 .postproc = NULL, 1107 1108 .demod_address = 0x68, 1109 // .ts_output_mode = STB0899_OUT_PARALLEL, /* types = SERIAL/PARALLEL */ 1110 .block_sync_mode = STB0899_SYNC_FORCED, /* DSS, SYNC_FORCED/UNSYNCED */ 1111 // .ts_pfbit_toggle = STB0899_MPEG_NORMAL, /* DirecTV, MPEG toggling seq */ 1112 1113 .xtal_freq = 27000000, 1114 .inversion = IQ_SWAP_OFF, 1115 1116 .lo_clk = 76500000, 1117 .hi_clk = 90000000, 1118 1119 .esno_ave = STB0899_DVBS2_ESNO_AVE, 1120 .esno_quant = STB0899_DVBS2_ESNO_QUANT, 1121 .avframes_coarse = STB0899_DVBS2_AVFRAMES_COARSE, 1122 .avframes_fine = STB0899_DVBS2_AVFRAMES_FINE, 1123 .miss_threshold = STB0899_DVBS2_MISS_THRESHOLD, 1124 .uwp_threshold_acq = STB0899_DVBS2_UWP_THRESHOLD_ACQ, 1125 .uwp_threshold_track = STB0899_DVBS2_UWP_THRESHOLD_TRACK, 1126 .uwp_threshold_sof = STB0899_DVBS2_UWP_THRESHOLD_SOF, 1127 .sof_search_timeout = STB0899_DVBS2_SOF_SEARCH_TIMEOUT, 1128 1129 .btr_nco_bits = STB0899_DVBS2_BTR_NCO_BITS, 1130 .btr_gain_shift_offset = STB0899_DVBS2_BTR_GAIN_SHIFT_OFFSET, 1131 .crl_nco_bits = STB0899_DVBS2_CRL_NCO_BITS, 1132 .ldpc_max_iter = STB0899_DVBS2_LDPC_MAX_ITER, 1133 1134 .tuner_get_frequency = tda8261_get_frequency, 1135 .tuner_set_frequency = tda8261_set_frequency, 1136 .tuner_set_bandwidth = NULL, 1137 .tuner_get_bandwidth = tda8261_get_bandwidth, 1138 .tuner_set_rfsiggain = NULL 1139 }; 1140 1141 /* 1142 * SD1878/SHA tuner config 1143 * 1F, Single I/P, Horizontal mount, High Sensitivity 1144 */ 1145 static const struct tda8261_config sd1878c_config = { 1146 // .name = "SD1878/SHA", 1147 .addr = 0x60, 1148 .step_size = TDA8261_STEP_1000 /* kHz */ 1149 }; 1150 1151 static u8 read_pwm(struct budget_av *budget_av) 1152 { 1153 u8 b = 0xff; 1154 u8 pwm; 1155 struct i2c_msg msg[] = { {.addr = 0x50,.flags = 0,.buf = &b,.len = 1}, 1156 {.addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} 1157 }; 1158 1159 if ((i2c_transfer(&budget_av->budget.i2c_adap, msg, 2) != 2) 1160 || (pwm == 0xff)) 1161 pwm = 0x48; 1162 1163 return pwm; 1164 } 1165 1166 #define SUBID_DVBS_KNC1 0x0010 1167 #define SUBID_DVBS_KNC1_PLUS 0x0011 1168 #define SUBID_DVBS_TYPHOON 0x4f56 1169 #define SUBID_DVBS_CINERGY1200 0x1154 1170 #define SUBID_DVBS_CYNERGY1200N 0x1155 1171 #define SUBID_DVBS_TV_STAR 0x0014 1172 #define SUBID_DVBS_TV_STAR_PLUS_X4 0x0015 1173 #define SUBID_DVBS_TV_STAR_CI 0x0016 1174 #define SUBID_DVBS2_KNC1 0x0018 1175 #define SUBID_DVBS2_KNC1_OEM 0x0019 1176 #define SUBID_DVBS_EASYWATCH_1 0x001a 1177 #define SUBID_DVBS_EASYWATCH_2 0x001b 1178 #define SUBID_DVBS2_EASYWATCH 0x001d 1179 #define SUBID_DVBS_EASYWATCH 0x001e 1180 1181 #define SUBID_DVBC_EASYWATCH 0x002a 1182 #define SUBID_DVBC_EASYWATCH_MK3 0x002c 1183 #define SUBID_DVBC_KNC1 0x0020 1184 #define SUBID_DVBC_KNC1_PLUS 0x0021 1185 #define SUBID_DVBC_KNC1_MK3 0x0022 1186 #define SUBID_DVBC_KNC1_TDA10024 0x0028 1187 #define SUBID_DVBC_KNC1_PLUS_MK3 0x0023 1188 #define SUBID_DVBC_CINERGY1200 0x1156 1189 #define SUBID_DVBC_CINERGY1200_MK3 0x1176 1190 1191 #define SUBID_DVBT_EASYWATCH 0x003a 1192 #define SUBID_DVBT_KNC1_PLUS 0x0031 1193 #define SUBID_DVBT_KNC1 0x0030 1194 #define SUBID_DVBT_CINERGY1200 0x1157 1195 1196 static void frontend_init(struct budget_av *budget_av) 1197 { 1198 struct saa7146_dev * saa = budget_av->budget.dev; 1199 struct dvb_frontend * fe = NULL; 1200 1201 /* Enable / PowerON Frontend */ 1202 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO); 1203 1204 /* Wait for PowerON */ 1205 msleep(100); 1206 1207 /* additional setup necessary for the PLUS cards */ 1208 switch (saa->pci->subsystem_device) { 1209 case SUBID_DVBS_KNC1_PLUS: 1210 case SUBID_DVBC_KNC1_PLUS: 1211 case SUBID_DVBT_KNC1_PLUS: 1212 case SUBID_DVBC_EASYWATCH: 1213 case SUBID_DVBC_KNC1_PLUS_MK3: 1214 case SUBID_DVBS2_KNC1: 1215 case SUBID_DVBS2_KNC1_OEM: 1216 case SUBID_DVBS2_EASYWATCH: 1217 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTHI); 1218 break; 1219 } 1220 1221 switch (saa->pci->subsystem_device) { 1222 1223 case SUBID_DVBS_KNC1: 1224 /* 1225 * maybe that setting is needed for other dvb-s cards as well, 1226 * but so far it has been only confirmed for this type 1227 */ 1228 budget_av->reinitialise_demod = 1; 1229 fallthrough; 1230 case SUBID_DVBS_KNC1_PLUS: 1231 case SUBID_DVBS_EASYWATCH_1: 1232 if (saa->pci->subsystem_vendor == 0x1894) { 1233 fe = dvb_attach(stv0299_attach, &cinergy_1200s_1894_0010_config, 1234 &budget_av->budget.i2c_adap); 1235 if (fe) { 1236 dvb_attach(tua6100_attach, fe, 0x60, &budget_av->budget.i2c_adap); 1237 } 1238 } else { 1239 fe = dvb_attach(stv0299_attach, &typhoon_config, 1240 &budget_av->budget.i2c_adap); 1241 if (fe) { 1242 fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params; 1243 } 1244 } 1245 break; 1246 1247 case SUBID_DVBS_TV_STAR: 1248 case SUBID_DVBS_TV_STAR_PLUS_X4: 1249 case SUBID_DVBS_TV_STAR_CI: 1250 case SUBID_DVBS_CYNERGY1200N: 1251 case SUBID_DVBS_EASYWATCH: 1252 case SUBID_DVBS_EASYWATCH_2: 1253 fe = dvb_attach(stv0299_attach, &philips_sd1878_config, 1254 &budget_av->budget.i2c_adap); 1255 if (fe) { 1256 dvb_attach(dvb_pll_attach, fe, 0x60, 1257 &budget_av->budget.i2c_adap, 1258 DVB_PLL_PHILIPS_SD1878_TDA8261); 1259 } 1260 break; 1261 1262 case SUBID_DVBS_TYPHOON: 1263 fe = dvb_attach(stv0299_attach, &typhoon_config, 1264 &budget_av->budget.i2c_adap); 1265 if (fe) { 1266 fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params; 1267 } 1268 break; 1269 case SUBID_DVBS2_KNC1: 1270 case SUBID_DVBS2_KNC1_OEM: 1271 case SUBID_DVBS2_EASYWATCH: 1272 budget_av->reinitialise_demod = 1; 1273 if ((fe = dvb_attach(stb0899_attach, &knc1_dvbs2_config, &budget_av->budget.i2c_adap))) 1274 dvb_attach(tda8261_attach, fe, &sd1878c_config, &budget_av->budget.i2c_adap); 1275 1276 break; 1277 case SUBID_DVBS_CINERGY1200: 1278 fe = dvb_attach(stv0299_attach, &cinergy_1200s_config, 1279 &budget_av->budget.i2c_adap); 1280 if (fe) { 1281 fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params; 1282 } 1283 break; 1284 1285 case SUBID_DVBC_KNC1: 1286 case SUBID_DVBC_KNC1_PLUS: 1287 case SUBID_DVBC_CINERGY1200: 1288 case SUBID_DVBC_EASYWATCH: 1289 budget_av->reinitialise_demod = 1; 1290 budget_av->budget.dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240; 1291 fe = dvb_attach(tda10021_attach, &philips_cu1216_config, 1292 &budget_av->budget.i2c_adap, 1293 read_pwm(budget_av)); 1294 if (fe == NULL) 1295 fe = dvb_attach(tda10021_attach, &philips_cu1216_config_altaddress, 1296 &budget_av->budget.i2c_adap, 1297 read_pwm(budget_av)); 1298 if (fe) { 1299 fe->ops.tuner_ops.set_params = philips_cu1216_tuner_set_params; 1300 } 1301 break; 1302 1303 case SUBID_DVBC_EASYWATCH_MK3: 1304 case SUBID_DVBC_CINERGY1200_MK3: 1305 case SUBID_DVBC_KNC1_MK3: 1306 case SUBID_DVBC_KNC1_TDA10024: 1307 case SUBID_DVBC_KNC1_PLUS_MK3: 1308 budget_av->reinitialise_demod = 1; 1309 budget_av->budget.dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240; 1310 fe = dvb_attach(tda10023_attach, 1311 &philips_cu1216_tda10023_config, 1312 &budget_av->budget.i2c_adap, 1313 read_pwm(budget_av)); 1314 if (fe) { 1315 fe->ops.tuner_ops.set_params = philips_cu1216_tuner_set_params; 1316 } 1317 break; 1318 1319 case SUBID_DVBT_EASYWATCH: 1320 case SUBID_DVBT_KNC1: 1321 case SUBID_DVBT_KNC1_PLUS: 1322 case SUBID_DVBT_CINERGY1200: 1323 budget_av->reinitialise_demod = 1; 1324 fe = dvb_attach(tda10046_attach, &philips_tu1216_config, 1325 &budget_av->budget.i2c_adap); 1326 if (fe) { 1327 fe->ops.tuner_ops.init = philips_tu1216_tuner_init; 1328 fe->ops.tuner_ops.set_params = philips_tu1216_tuner_set_params; 1329 } 1330 break; 1331 } 1332 1333 if (fe == NULL) { 1334 pr_err("A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n", 1335 saa->pci->vendor, 1336 saa->pci->device, 1337 saa->pci->subsystem_vendor, 1338 saa->pci->subsystem_device); 1339 return; 1340 } 1341 1342 budget_av->budget.dvb_frontend = fe; 1343 1344 if (dvb_register_frontend(&budget_av->budget.dvb_adapter, 1345 budget_av->budget.dvb_frontend)) { 1346 pr_err("Frontend registration failed!\n"); 1347 dvb_frontend_detach(budget_av->budget.dvb_frontend); 1348 budget_av->budget.dvb_frontend = NULL; 1349 } 1350 } 1351 1352 1353 static void budget_av_irq(struct saa7146_dev *dev, u32 * isr) 1354 { 1355 struct budget_av *budget_av = (struct budget_av *) dev->ext_priv; 1356 1357 dprintk(8, "dev: %p, budget_av: %p\n", dev, budget_av); 1358 1359 if (*isr & MASK_10) 1360 ttpci_budget_irq10_handler(dev, isr); 1361 } 1362 1363 static int budget_av_detach(struct saa7146_dev *dev) 1364 { 1365 struct budget_av *budget_av = (struct budget_av *) dev->ext_priv; 1366 int err; 1367 1368 dprintk(2, "dev: %p\n", dev); 1369 1370 if (1 == budget_av->has_saa7113) { 1371 saa7146_setgpio(dev, 0, SAA7146_GPIO_OUTLO); 1372 1373 msleep(200); 1374 1375 saa7146_unregister_device(&budget_av->vd, dev); 1376 1377 saa7146_vv_release(dev); 1378 } 1379 1380 if (budget_av->budget.ci_present) 1381 ciintf_deinit(budget_av); 1382 1383 if (budget_av->budget.dvb_frontend != NULL) { 1384 dvb_unregister_frontend(budget_av->budget.dvb_frontend); 1385 dvb_frontend_detach(budget_av->budget.dvb_frontend); 1386 } 1387 err = ttpci_budget_deinit(&budget_av->budget); 1388 1389 kfree(budget_av); 1390 1391 return err; 1392 } 1393 1394 #define KNC1_INPUTS 2 1395 static struct v4l2_input knc1_inputs[KNC1_INPUTS] = { 1396 { 0, "Composite", V4L2_INPUT_TYPE_TUNER, 1, 0, 1397 V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0, V4L2_IN_CAP_STD }, 1398 { 1, "S-Video", V4L2_INPUT_TYPE_CAMERA, 2, 0, 1399 V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0, V4L2_IN_CAP_STD }, 1400 }; 1401 1402 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i) 1403 { 1404 dprintk(1, "VIDIOC_ENUMINPUT %d\n", i->index); 1405 if (i->index >= KNC1_INPUTS) 1406 return -EINVAL; 1407 memcpy(i, &knc1_inputs[i->index], sizeof(struct v4l2_input)); 1408 return 0; 1409 } 1410 1411 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i) 1412 { 1413 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev; 1414 struct budget_av *budget_av = (struct budget_av *)dev->ext_priv; 1415 1416 *i = budget_av->cur_input; 1417 1418 dprintk(1, "VIDIOC_G_INPUT %d\n", *i); 1419 return 0; 1420 } 1421 1422 static int vidioc_s_input(struct file *file, void *fh, unsigned int input) 1423 { 1424 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev; 1425 struct budget_av *budget_av = (struct budget_av *)dev->ext_priv; 1426 1427 dprintk(1, "VIDIOC_S_INPUT %d\n", input); 1428 return saa7113_setinput(budget_av, input); 1429 } 1430 1431 static struct saa7146_ext_vv vv_data; 1432 1433 static int budget_av_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info) 1434 { 1435 struct budget_av *budget_av; 1436 u8 *mac; 1437 int err; 1438 1439 dprintk(2, "dev: %p\n", dev); 1440 1441 if (!(budget_av = kzalloc(sizeof(struct budget_av), GFP_KERNEL))) 1442 return -ENOMEM; 1443 1444 budget_av->has_saa7113 = 0; 1445 budget_av->budget.ci_present = 0; 1446 1447 dev->ext_priv = budget_av; 1448 1449 err = ttpci_budget_init(&budget_av->budget, dev, info, THIS_MODULE, 1450 adapter_nr); 1451 if (err) { 1452 kfree(budget_av); 1453 return err; 1454 } 1455 1456 /* knc1 initialization */ 1457 saa7146_write(dev, DD1_STREAM_B, 0x04000000); 1458 saa7146_write(dev, DD1_INIT, 0x07000600); 1459 saa7146_write(dev, MC2, MASK_09 | MASK_25 | MASK_10 | MASK_26); 1460 1461 if (saa7113_init(budget_av) == 0) { 1462 budget_av->has_saa7113 = 1; 1463 err = saa7146_vv_init(dev, &vv_data); 1464 if (err != 0) { 1465 /* fixme: proper cleanup here */ 1466 ERR("cannot init vv subsystem\n"); 1467 return err; 1468 } 1469 vv_data.vid_ops.vidioc_enum_input = vidioc_enum_input; 1470 vv_data.vid_ops.vidioc_g_input = vidioc_g_input; 1471 vv_data.vid_ops.vidioc_s_input = vidioc_s_input; 1472 1473 if ((err = saa7146_register_device(&budget_av->vd, dev, "knc1", VFL_TYPE_VIDEO))) { 1474 /* fixme: proper cleanup here */ 1475 ERR("cannot register capture v4l2 device\n"); 1476 saa7146_vv_release(dev); 1477 return err; 1478 } 1479 1480 /* beware: this modifies dev->vv ... */ 1481 saa7146_set_hps_source_and_sync(dev, SAA7146_HPS_SOURCE_PORT_A, 1482 SAA7146_HPS_SYNC_PORT_A); 1483 1484 saa7113_setinput(budget_av, 0); 1485 } 1486 1487 /* fixme: find some sane values here... */ 1488 saa7146_write(dev, PCI_BT_V1, 0x1c00101f); 1489 1490 mac = budget_av->budget.dvb_adapter.proposed_mac; 1491 if (i2c_readregs(&budget_av->budget.i2c_adap, 0xa0, 0x30, mac, 6)) { 1492 pr_err("KNC1-%d: Could not read MAC from KNC1 card\n", 1493 budget_av->budget.dvb_adapter.num); 1494 eth_zero_addr(mac); 1495 } else { 1496 pr_info("KNC1-%d: MAC addr = %pM\n", 1497 budget_av->budget.dvb_adapter.num, mac); 1498 } 1499 1500 budget_av->budget.dvb_adapter.priv = budget_av; 1501 frontend_init(budget_av); 1502 ciintf_init(budget_av); 1503 1504 ttpci_budget_init_hooks(&budget_av->budget); 1505 1506 return 0; 1507 } 1508 1509 static struct saa7146_standard standard[] = { 1510 {.name = "PAL",.id = V4L2_STD_PAL, 1511 .v_offset = 0x17,.v_field = 288, 1512 .h_offset = 0x14,.h_pixels = 680, 1513 .v_max_out = 576,.h_max_out = 768 }, 1514 1515 {.name = "NTSC",.id = V4L2_STD_NTSC, 1516 .v_offset = 0x16,.v_field = 240, 1517 .h_offset = 0x06,.h_pixels = 708, 1518 .v_max_out = 480,.h_max_out = 640, }, 1519 }; 1520 1521 static struct saa7146_ext_vv vv_data = { 1522 .inputs = 2, 1523 .capabilities = 0, // perhaps later: V4L2_CAP_VBI_CAPTURE, but that need tweaking with the saa7113 1524 .flags = 0, 1525 .stds = &standard[0], 1526 .num_stds = ARRAY_SIZE(standard), 1527 }; 1528 1529 static struct saa7146_extension budget_extension; 1530 1531 MAKE_BUDGET_INFO(knc1s, "KNC1 DVB-S", BUDGET_KNC1S); 1532 MAKE_BUDGET_INFO(knc1s2,"KNC1 DVB-S2", BUDGET_KNC1S2); 1533 MAKE_BUDGET_INFO(sates2,"Satelco EasyWatch DVB-S2", BUDGET_KNC1S2); 1534 MAKE_BUDGET_INFO(knc1c, "KNC1 DVB-C", BUDGET_KNC1C); 1535 MAKE_BUDGET_INFO(knc1t, "KNC1 DVB-T", BUDGET_KNC1T); 1536 MAKE_BUDGET_INFO(kncxs, "KNC TV STAR DVB-S", BUDGET_TVSTAR); 1537 MAKE_BUDGET_INFO(satewpls, "Satelco EasyWatch DVB-S light", BUDGET_TVSTAR); 1538 MAKE_BUDGET_INFO(satewpls1, "Satelco EasyWatch DVB-S light", BUDGET_KNC1S); 1539 MAKE_BUDGET_INFO(satewps, "Satelco EasyWatch DVB-S", BUDGET_KNC1S); 1540 MAKE_BUDGET_INFO(satewplc, "Satelco EasyWatch DVB-C", BUDGET_KNC1CP); 1541 MAKE_BUDGET_INFO(satewcmk3, "Satelco EasyWatch DVB-C MK3", BUDGET_KNC1C_MK3); 1542 MAKE_BUDGET_INFO(satewt, "Satelco EasyWatch DVB-T", BUDGET_KNC1T); 1543 MAKE_BUDGET_INFO(knc1sp, "KNC1 DVB-S Plus", BUDGET_KNC1SP); 1544 MAKE_BUDGET_INFO(knc1spx4, "KNC1 DVB-S Plus X4", BUDGET_KNC1SP); 1545 MAKE_BUDGET_INFO(knc1cp, "KNC1 DVB-C Plus", BUDGET_KNC1CP); 1546 MAKE_BUDGET_INFO(knc1cmk3, "KNC1 DVB-C MK3", BUDGET_KNC1C_MK3); 1547 MAKE_BUDGET_INFO(knc1ctda10024, "KNC1 DVB-C TDA10024", BUDGET_KNC1C_TDA10024); 1548 MAKE_BUDGET_INFO(knc1cpmk3, "KNC1 DVB-C Plus MK3", BUDGET_KNC1CP_MK3); 1549 MAKE_BUDGET_INFO(knc1tp, "KNC1 DVB-T Plus", BUDGET_KNC1TP); 1550 MAKE_BUDGET_INFO(cin1200s, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S); 1551 MAKE_BUDGET_INFO(cin1200sn, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S); 1552 MAKE_BUDGET_INFO(cin1200c, "Terratec Cinergy 1200 DVB-C", BUDGET_CIN1200C); 1553 MAKE_BUDGET_INFO(cin1200cmk3, "Terratec Cinergy 1200 DVB-C MK3", BUDGET_CIN1200C_MK3); 1554 MAKE_BUDGET_INFO(cin1200t, "Terratec Cinergy 1200 DVB-T", BUDGET_CIN1200T); 1555 1556 static const struct pci_device_id pci_tbl[] = { 1557 MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x4f56), 1558 MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x0010), 1559 MAKE_EXTENSION_PCI(knc1s, 0x1894, 0x0010), 1560 MAKE_EXTENSION_PCI(knc1sp, 0x1131, 0x0011), 1561 MAKE_EXTENSION_PCI(knc1sp, 0x1894, 0x0011), 1562 MAKE_EXTENSION_PCI(kncxs, 0x1894, 0x0014), 1563 MAKE_EXTENSION_PCI(knc1spx4, 0x1894, 0x0015), 1564 MAKE_EXTENSION_PCI(kncxs, 0x1894, 0x0016), 1565 MAKE_EXTENSION_PCI(knc1s2, 0x1894, 0x0018), 1566 MAKE_EXTENSION_PCI(knc1s2, 0x1894, 0x0019), 1567 MAKE_EXTENSION_PCI(sates2, 0x1894, 0x001d), 1568 MAKE_EXTENSION_PCI(satewpls, 0x1894, 0x001e), 1569 MAKE_EXTENSION_PCI(satewpls1, 0x1894, 0x001a), 1570 MAKE_EXTENSION_PCI(satewps, 0x1894, 0x001b), 1571 MAKE_EXTENSION_PCI(satewplc, 0x1894, 0x002a), 1572 MAKE_EXTENSION_PCI(satewcmk3, 0x1894, 0x002c), 1573 MAKE_EXTENSION_PCI(satewt, 0x1894, 0x003a), 1574 MAKE_EXTENSION_PCI(knc1c, 0x1894, 0x0020), 1575 MAKE_EXTENSION_PCI(knc1cp, 0x1894, 0x0021), 1576 MAKE_EXTENSION_PCI(knc1cmk3, 0x1894, 0x0022), 1577 MAKE_EXTENSION_PCI(knc1ctda10024, 0x1894, 0x0028), 1578 MAKE_EXTENSION_PCI(knc1cpmk3, 0x1894, 0x0023), 1579 MAKE_EXTENSION_PCI(knc1t, 0x1894, 0x0030), 1580 MAKE_EXTENSION_PCI(knc1tp, 0x1894, 0x0031), 1581 MAKE_EXTENSION_PCI(cin1200s, 0x153b, 0x1154), 1582 MAKE_EXTENSION_PCI(cin1200sn, 0x153b, 0x1155), 1583 MAKE_EXTENSION_PCI(cin1200c, 0x153b, 0x1156), 1584 MAKE_EXTENSION_PCI(cin1200cmk3, 0x153b, 0x1176), 1585 MAKE_EXTENSION_PCI(cin1200t, 0x153b, 0x1157), 1586 { 1587 .vendor = 0, 1588 } 1589 }; 1590 1591 MODULE_DEVICE_TABLE(pci, pci_tbl); 1592 1593 static struct saa7146_extension budget_extension = { 1594 .name = "budget_av", 1595 .flags = SAA7146_USE_I2C_IRQ, 1596 1597 .pci_tbl = pci_tbl, 1598 1599 .module = THIS_MODULE, 1600 .attach = budget_av_attach, 1601 .detach = budget_av_detach, 1602 1603 .irq_mask = MASK_10, 1604 .irq_func = budget_av_irq, 1605 }; 1606 1607 static int __init budget_av_init(void) 1608 { 1609 return saa7146_register_extension(&budget_extension); 1610 } 1611 1612 static void __exit budget_av_exit(void) 1613 { 1614 saa7146_unregister_extension(&budget_extension); 1615 } 1616 1617 module_init(budget_av_init); 1618 module_exit(budget_av_exit); 1619 1620 MODULE_LICENSE("GPL"); 1621 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, Michael Hunold, others"); 1622 MODULE_DESCRIPTION("driver for the SAA7146 based so-called budget PCI DVB w/ analog input and CI-module (e.g. the KNC cards)"); 1623