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