1 /* 2 * i2c tv tuner chip device driver 3 * controls all those simple 4-control-bytes style tuners. 4 * 5 * This "tuner-simple" module was split apart from the original "tuner" module. 6 */ 7 #include <linux/delay.h> 8 #include <linux/i2c.h> 9 #include <linux/videodev2.h> 10 #include <media/tuner.h> 11 #include <media/v4l2-common.h> 12 #include <media/tuner-types.h> 13 #include "tuner-i2c.h" 14 #include "tuner-simple.h" 15 16 static int debug; 17 module_param(debug, int, 0644); 18 MODULE_PARM_DESC(debug, "enable verbose debug messages"); 19 20 #define TUNER_SIMPLE_MAX 64 21 static unsigned int simple_devcount; 22 23 static int offset; 24 module_param(offset, int, 0664); 25 MODULE_PARM_DESC(offset, "Allows to specify an offset for tuner"); 26 27 static unsigned int atv_input[TUNER_SIMPLE_MAX] = \ 28 { [0 ... (TUNER_SIMPLE_MAX-1)] = 0 }; 29 static unsigned int dtv_input[TUNER_SIMPLE_MAX] = \ 30 { [0 ... (TUNER_SIMPLE_MAX-1)] = 0 }; 31 module_param_array(atv_input, int, NULL, 0644); 32 module_param_array(dtv_input, int, NULL, 0644); 33 MODULE_PARM_DESC(atv_input, "specify atv rf input, 0 for autoselect"); 34 MODULE_PARM_DESC(dtv_input, "specify dtv rf input, 0 for autoselect"); 35 36 /* ---------------------------------------------------------------------- */ 37 38 /* tv standard selection for Temic 4046 FM5 39 this value takes the low bits of control byte 2 40 from datasheet Rev.01, Feb.00 41 standard BG I L L2 D 42 picture IF 38.9 38.9 38.9 33.95 38.9 43 sound 1 33.4 32.9 32.4 40.45 32.4 44 sound 2 33.16 45 NICAM 33.05 32.348 33.05 33.05 46 */ 47 #define TEMIC_SET_PAL_I 0x05 48 #define TEMIC_SET_PAL_DK 0x09 49 #define TEMIC_SET_PAL_L 0x0a /* SECAM ? */ 50 #define TEMIC_SET_PAL_L2 0x0b /* change IF ! */ 51 #define TEMIC_SET_PAL_BG 0x0c 52 53 /* tv tuner system standard selection for Philips FQ1216ME 54 this value takes the low bits of control byte 2 55 from datasheet "1999 Nov 16" (supersedes "1999 Mar 23") 56 standard BG DK I L L` 57 picture carrier 38.90 38.90 38.90 38.90 33.95 58 colour 34.47 34.47 34.47 34.47 38.38 59 sound 1 33.40 32.40 32.90 32.40 40.45 60 sound 2 33.16 - - - - 61 NICAM 33.05 33.05 32.35 33.05 39.80 62 */ 63 #define PHILIPS_SET_PAL_I 0x01 /* Bit 2 always zero !*/ 64 #define PHILIPS_SET_PAL_BGDK 0x09 65 #define PHILIPS_SET_PAL_L2 0x0a 66 #define PHILIPS_SET_PAL_L 0x0b 67 68 /* system switching for Philips FI1216MF MK2 69 from datasheet "1996 Jul 09", 70 standard BG L L' 71 picture carrier 38.90 38.90 33.95 72 colour 34.47 34.37 38.38 73 sound 1 33.40 32.40 40.45 74 sound 2 33.16 - - 75 NICAM 33.05 33.05 39.80 76 */ 77 #define PHILIPS_MF_SET_STD_BG 0x01 /* Bit 2 must be zero, Bit 3 is system output */ 78 #define PHILIPS_MF_SET_STD_L 0x03 /* Used on Secam France */ 79 #define PHILIPS_MF_SET_STD_LC 0x02 /* Used on SECAM L' */ 80 81 /* Control byte */ 82 83 #define TUNER_RATIO_MASK 0x06 /* Bit cb1:cb2 */ 84 #define TUNER_RATIO_SELECT_50 0x00 85 #define TUNER_RATIO_SELECT_32 0x02 86 #define TUNER_RATIO_SELECT_166 0x04 87 #define TUNER_RATIO_SELECT_62 0x06 88 89 #define TUNER_CHARGE_PUMP 0x40 /* Bit cb6 */ 90 91 /* Status byte */ 92 93 #define TUNER_POR 0x80 94 #define TUNER_FL 0x40 95 #define TUNER_MODE 0x38 96 #define TUNER_AFC 0x07 97 #define TUNER_SIGNAL 0x07 98 #define TUNER_STEREO 0x10 99 100 #define TUNER_PLL_LOCKED 0x40 101 #define TUNER_STEREO_MK3 0x04 102 103 static DEFINE_MUTEX(tuner_simple_list_mutex); 104 static LIST_HEAD(hybrid_tuner_instance_list); 105 106 struct tuner_simple_priv { 107 unsigned int nr; 108 u16 last_div; 109 110 struct tuner_i2c_props i2c_props; 111 struct list_head hybrid_tuner_instance_list; 112 113 unsigned int type; 114 struct tunertype *tun; 115 116 u32 frequency; 117 u32 bandwidth; 118 bool radio_mode; 119 }; 120 121 /* ---------------------------------------------------------------------- */ 122 123 static int tuner_read_status(struct dvb_frontend *fe) 124 { 125 struct tuner_simple_priv *priv = fe->tuner_priv; 126 unsigned char byte; 127 128 if (1 != tuner_i2c_xfer_recv(&priv->i2c_props, &byte, 1)) 129 return 0; 130 131 return byte; 132 } 133 134 static inline int tuner_signal(const int status) 135 { 136 return (status & TUNER_SIGNAL) << 13; 137 } 138 139 static inline int tuner_stereo(const int type, const int status) 140 { 141 switch (type) { 142 case TUNER_PHILIPS_FM1216ME_MK3: 143 case TUNER_PHILIPS_FM1236_MK3: 144 case TUNER_PHILIPS_FM1256_IH3: 145 case TUNER_LG_NTSC_TAPE: 146 case TUNER_TCL_MF02GIP_5N: 147 return ((status & TUNER_SIGNAL) == TUNER_STEREO_MK3); 148 case TUNER_PHILIPS_FM1216MK5: 149 return status | TUNER_STEREO; 150 default: 151 return status & TUNER_STEREO; 152 } 153 } 154 155 static inline int tuner_islocked(const int status) 156 { 157 return (status & TUNER_FL); 158 } 159 160 static inline int tuner_afcstatus(const int status) 161 { 162 return (status & TUNER_AFC) - 2; 163 } 164 165 166 static int simple_get_status(struct dvb_frontend *fe, u32 *status) 167 { 168 struct tuner_simple_priv *priv = fe->tuner_priv; 169 int tuner_status; 170 171 if (priv->i2c_props.adap == NULL) 172 return -EINVAL; 173 174 tuner_status = tuner_read_status(fe); 175 176 *status = 0; 177 178 if (tuner_islocked(tuner_status)) 179 *status = TUNER_STATUS_LOCKED; 180 if (tuner_stereo(priv->type, tuner_status)) 181 *status |= TUNER_STATUS_STEREO; 182 183 tuner_dbg("AFC Status: %d\n", tuner_afcstatus(tuner_status)); 184 185 return 0; 186 } 187 188 static int simple_get_rf_strength(struct dvb_frontend *fe, u16 *strength) 189 { 190 struct tuner_simple_priv *priv = fe->tuner_priv; 191 int signal; 192 193 if (priv->i2c_props.adap == NULL || !priv->radio_mode) 194 return -EINVAL; 195 196 signal = tuner_signal(tuner_read_status(fe)); 197 198 *strength = signal; 199 200 tuner_dbg("Signal strength: %d\n", signal); 201 202 return 0; 203 } 204 205 /* ---------------------------------------------------------------------- */ 206 207 static inline char *tuner_param_name(enum param_type type) 208 { 209 char *name; 210 211 switch (type) { 212 case TUNER_PARAM_TYPE_RADIO: 213 name = "radio"; 214 break; 215 case TUNER_PARAM_TYPE_PAL: 216 name = "pal"; 217 break; 218 case TUNER_PARAM_TYPE_SECAM: 219 name = "secam"; 220 break; 221 case TUNER_PARAM_TYPE_NTSC: 222 name = "ntsc"; 223 break; 224 case TUNER_PARAM_TYPE_DIGITAL: 225 name = "digital"; 226 break; 227 default: 228 name = "unknown"; 229 break; 230 } 231 return name; 232 } 233 234 static struct tuner_params *simple_tuner_params(struct dvb_frontend *fe, 235 enum param_type desired_type) 236 { 237 struct tuner_simple_priv *priv = fe->tuner_priv; 238 struct tunertype *tun = priv->tun; 239 int i; 240 241 for (i = 0; i < tun->count; i++) 242 if (desired_type == tun->params[i].type) 243 break; 244 245 /* use default tuner params if desired_type not available */ 246 if (i == tun->count) { 247 tuner_dbg("desired params (%s) undefined for tuner %d\n", 248 tuner_param_name(desired_type), priv->type); 249 i = 0; 250 } 251 252 tuner_dbg("using tuner params #%d (%s)\n", i, 253 tuner_param_name(tun->params[i].type)); 254 255 return &tun->params[i]; 256 } 257 258 static int simple_config_lookup(struct dvb_frontend *fe, 259 struct tuner_params *t_params, 260 unsigned *frequency, u8 *config, u8 *cb) 261 { 262 struct tuner_simple_priv *priv = fe->tuner_priv; 263 int i; 264 265 for (i = 0; i < t_params->count; i++) { 266 if (*frequency > t_params->ranges[i].limit) 267 continue; 268 break; 269 } 270 if (i == t_params->count) { 271 tuner_dbg("frequency out of range (%d > %d)\n", 272 *frequency, t_params->ranges[i - 1].limit); 273 *frequency = t_params->ranges[--i].limit; 274 } 275 *config = t_params->ranges[i].config; 276 *cb = t_params->ranges[i].cb; 277 278 tuner_dbg("freq = %d.%02d (%d), range = %d, " 279 "config = 0x%02x, cb = 0x%02x\n", 280 *frequency / 16, *frequency % 16 * 100 / 16, *frequency, 281 i, *config, *cb); 282 283 return i; 284 } 285 286 /* ---------------------------------------------------------------------- */ 287 288 static void simple_set_rf_input(struct dvb_frontend *fe, 289 u8 *config, u8 *cb, unsigned int rf) 290 { 291 struct tuner_simple_priv *priv = fe->tuner_priv; 292 293 switch (priv->type) { 294 case TUNER_PHILIPS_TUV1236D: 295 switch (rf) { 296 case 1: 297 *cb |= 0x08; 298 break; 299 default: 300 *cb &= ~0x08; 301 break; 302 } 303 break; 304 case TUNER_PHILIPS_FCV1236D: 305 switch (rf) { 306 case 1: 307 *cb |= 0x01; 308 break; 309 default: 310 *cb &= ~0x01; 311 break; 312 } 313 break; 314 default: 315 break; 316 } 317 } 318 319 static int simple_std_setup(struct dvb_frontend *fe, 320 struct analog_parameters *params, 321 u8 *config, u8 *cb) 322 { 323 struct tuner_simple_priv *priv = fe->tuner_priv; 324 int rc; 325 326 /* tv norm specific stuff for multi-norm tuners */ 327 switch (priv->type) { 328 case TUNER_PHILIPS_SECAM: /* FI1216MF */ 329 /* 0x01 -> ??? no change ??? */ 330 /* 0x02 -> PAL BDGHI / SECAM L */ 331 /* 0x04 -> ??? PAL others / SECAM others ??? */ 332 *cb &= ~0x03; 333 if (params->std & V4L2_STD_SECAM_L) 334 /* also valid for V4L2_STD_SECAM */ 335 *cb |= PHILIPS_MF_SET_STD_L; 336 else if (params->std & V4L2_STD_SECAM_LC) 337 *cb |= PHILIPS_MF_SET_STD_LC; 338 else /* V4L2_STD_B|V4L2_STD_GH */ 339 *cb |= PHILIPS_MF_SET_STD_BG; 340 break; 341 342 case TUNER_TEMIC_4046FM5: 343 *cb &= ~0x0f; 344 345 if (params->std & V4L2_STD_PAL_BG) { 346 *cb |= TEMIC_SET_PAL_BG; 347 348 } else if (params->std & V4L2_STD_PAL_I) { 349 *cb |= TEMIC_SET_PAL_I; 350 351 } else if (params->std & V4L2_STD_PAL_DK) { 352 *cb |= TEMIC_SET_PAL_DK; 353 354 } else if (params->std & V4L2_STD_SECAM_L) { 355 *cb |= TEMIC_SET_PAL_L; 356 357 } 358 break; 359 360 case TUNER_PHILIPS_FQ1216ME: 361 *cb &= ~0x0f; 362 363 if (params->std & (V4L2_STD_PAL_BG|V4L2_STD_PAL_DK)) { 364 *cb |= PHILIPS_SET_PAL_BGDK; 365 366 } else if (params->std & V4L2_STD_PAL_I) { 367 *cb |= PHILIPS_SET_PAL_I; 368 369 } else if (params->std & V4L2_STD_SECAM_L) { 370 *cb |= PHILIPS_SET_PAL_L; 371 372 } 373 break; 374 375 case TUNER_PHILIPS_FCV1236D: 376 /* 0x00 -> ATSC antenna input 1 */ 377 /* 0x01 -> ATSC antenna input 2 */ 378 /* 0x02 -> NTSC antenna input 1 */ 379 /* 0x03 -> NTSC antenna input 2 */ 380 *cb &= ~0x03; 381 if (!(params->std & V4L2_STD_ATSC)) 382 *cb |= 2; 383 break; 384 385 case TUNER_MICROTUNE_4042FI5: 386 /* Set the charge pump for fast tuning */ 387 *config |= TUNER_CHARGE_PUMP; 388 break; 389 390 case TUNER_PHILIPS_TUV1236D: 391 { 392 struct tuner_i2c_props i2c = priv->i2c_props; 393 /* 0x40 -> ATSC antenna input 1 */ 394 /* 0x48 -> ATSC antenna input 2 */ 395 /* 0x00 -> NTSC antenna input 1 */ 396 /* 0x08 -> NTSC antenna input 2 */ 397 u8 buffer[4] = { 0x14, 0x00, 0x17, 0x00}; 398 *cb &= ~0x40; 399 if (params->std & V4L2_STD_ATSC) { 400 *cb |= 0x40; 401 buffer[1] = 0x04; 402 } 403 /* set to the correct mode (analog or digital) */ 404 i2c.addr = 0x0a; 405 rc = tuner_i2c_xfer_send(&i2c, &buffer[0], 2); 406 if (2 != rc) 407 tuner_warn("i2c i/o error: rc == %d " 408 "(should be 2)\n", rc); 409 rc = tuner_i2c_xfer_send(&i2c, &buffer[2], 2); 410 if (2 != rc) 411 tuner_warn("i2c i/o error: rc == %d " 412 "(should be 2)\n", rc); 413 break; 414 } 415 } 416 if (atv_input[priv->nr]) 417 simple_set_rf_input(fe, config, cb, atv_input[priv->nr]); 418 419 return 0; 420 } 421 422 static int simple_set_aux_byte(struct dvb_frontend *fe, u8 config, u8 aux) 423 { 424 struct tuner_simple_priv *priv = fe->tuner_priv; 425 int rc; 426 u8 buffer[2]; 427 428 buffer[0] = (config & ~0x38) | 0x18; 429 buffer[1] = aux; 430 431 tuner_dbg("setting aux byte: 0x%02x 0x%02x\n", buffer[0], buffer[1]); 432 433 rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 2); 434 if (2 != rc) 435 tuner_warn("i2c i/o error: rc == %d (should be 2)\n", rc); 436 437 return rc == 2 ? 0 : rc; 438 } 439 440 static int simple_post_tune(struct dvb_frontend *fe, u8 *buffer, 441 u16 div, u8 config, u8 cb) 442 { 443 struct tuner_simple_priv *priv = fe->tuner_priv; 444 int rc; 445 446 switch (priv->type) { 447 case TUNER_LG_TDVS_H06XF: 448 simple_set_aux_byte(fe, config, 0x20); 449 break; 450 case TUNER_PHILIPS_FQ1216LME_MK3: 451 simple_set_aux_byte(fe, config, 0x60); /* External AGC */ 452 break; 453 case TUNER_MICROTUNE_4042FI5: 454 { 455 /* FIXME - this may also work for other tuners */ 456 unsigned long timeout = jiffies + msecs_to_jiffies(1); 457 u8 status_byte = 0; 458 459 /* Wait until the PLL locks */ 460 for (;;) { 461 if (time_after(jiffies, timeout)) 462 return 0; 463 rc = tuner_i2c_xfer_recv(&priv->i2c_props, 464 &status_byte, 1); 465 if (1 != rc) { 466 tuner_warn("i2c i/o read error: rc == %d " 467 "(should be 1)\n", rc); 468 break; 469 } 470 if (status_byte & TUNER_PLL_LOCKED) 471 break; 472 udelay(10); 473 } 474 475 /* Set the charge pump for optimized phase noise figure */ 476 config &= ~TUNER_CHARGE_PUMP; 477 buffer[0] = (div>>8) & 0x7f; 478 buffer[1] = div & 0xff; 479 buffer[2] = config; 480 buffer[3] = cb; 481 tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n", 482 buffer[0], buffer[1], buffer[2], buffer[3]); 483 484 rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4); 485 if (4 != rc) 486 tuner_warn("i2c i/o error: rc == %d " 487 "(should be 4)\n", rc); 488 break; 489 } 490 } 491 492 return 0; 493 } 494 495 static int simple_radio_bandswitch(struct dvb_frontend *fe, u8 *buffer) 496 { 497 struct tuner_simple_priv *priv = fe->tuner_priv; 498 499 switch (priv->type) { 500 case TUNER_TENA_9533_DI: 501 case TUNER_YMEC_TVF_5533MF: 502 tuner_dbg("This tuner doesn't have FM. " 503 "Most cards have a TEA5767 for FM\n"); 504 return 0; 505 case TUNER_PHILIPS_FM1216ME_MK3: 506 case TUNER_PHILIPS_FM1236_MK3: 507 case TUNER_PHILIPS_FMD1216ME_MK3: 508 case TUNER_PHILIPS_FMD1216MEX_MK3: 509 case TUNER_LG_NTSC_TAPE: 510 case TUNER_PHILIPS_FM1256_IH3: 511 case TUNER_TCL_MF02GIP_5N: 512 buffer[3] = 0x19; 513 break; 514 case TUNER_PHILIPS_FM1216MK5: 515 buffer[2] = 0x88; 516 buffer[3] = 0x09; 517 break; 518 case TUNER_TNF_5335MF: 519 buffer[3] = 0x11; 520 break; 521 case TUNER_LG_PAL_FM: 522 buffer[3] = 0xa5; 523 break; 524 case TUNER_THOMSON_DTT761X: 525 buffer[3] = 0x39; 526 break; 527 case TUNER_PHILIPS_FQ1216LME_MK3: 528 case TUNER_PHILIPS_FQ1236_MK5: 529 tuner_err("This tuner doesn't have FM\n"); 530 /* Set the low band for sanity, since it covers 88-108 MHz */ 531 buffer[3] = 0x01; 532 break; 533 case TUNER_MICROTUNE_4049FM5: 534 default: 535 buffer[3] = 0xa4; 536 break; 537 } 538 539 return 0; 540 } 541 542 /* ---------------------------------------------------------------------- */ 543 544 static int simple_set_tv_freq(struct dvb_frontend *fe, 545 struct analog_parameters *params) 546 { 547 struct tuner_simple_priv *priv = fe->tuner_priv; 548 u8 config, cb; 549 u16 div; 550 u8 buffer[4]; 551 int rc, IFPCoff, i; 552 enum param_type desired_type; 553 struct tuner_params *t_params; 554 555 /* IFPCoff = Video Intermediate Frequency - Vif: 556 940 =16*58.75 NTSC/J (Japan) 557 732 =16*45.75 M/N STD 558 704 =16*44 ATSC (at DVB code) 559 632 =16*39.50 I U.K. 560 622.4=16*38.90 B/G D/K I, L STD 561 592 =16*37.00 D China 562 590 =16.36.875 B Australia 563 543.2=16*33.95 L' STD 564 171.2=16*10.70 FM Radio (at set_radio_freq) 565 */ 566 567 if (params->std == V4L2_STD_NTSC_M_JP) { 568 IFPCoff = 940; 569 desired_type = TUNER_PARAM_TYPE_NTSC; 570 } else if ((params->std & V4L2_STD_MN) && 571 !(params->std & ~V4L2_STD_MN)) { 572 IFPCoff = 732; 573 desired_type = TUNER_PARAM_TYPE_NTSC; 574 } else if (params->std == V4L2_STD_SECAM_LC) { 575 IFPCoff = 543; 576 desired_type = TUNER_PARAM_TYPE_SECAM; 577 } else { 578 IFPCoff = 623; 579 desired_type = TUNER_PARAM_TYPE_PAL; 580 } 581 582 t_params = simple_tuner_params(fe, desired_type); 583 584 i = simple_config_lookup(fe, t_params, ¶ms->frequency, 585 &config, &cb); 586 587 div = params->frequency + IFPCoff + offset; 588 589 tuner_dbg("Freq= %d.%02d MHz, V_IF=%d.%02d MHz, " 590 "Offset=%d.%02d MHz, div=%0d\n", 591 params->frequency / 16, params->frequency % 16 * 100 / 16, 592 IFPCoff / 16, IFPCoff % 16 * 100 / 16, 593 offset / 16, offset % 16 * 100 / 16, div); 594 595 /* tv norm specific stuff for multi-norm tuners */ 596 simple_std_setup(fe, params, &config, &cb); 597 598 if (t_params->cb_first_if_lower_freq && div < priv->last_div) { 599 buffer[0] = config; 600 buffer[1] = cb; 601 buffer[2] = (div>>8) & 0x7f; 602 buffer[3] = div & 0xff; 603 } else { 604 buffer[0] = (div>>8) & 0x7f; 605 buffer[1] = div & 0xff; 606 buffer[2] = config; 607 buffer[3] = cb; 608 } 609 priv->last_div = div; 610 if (t_params->has_tda9887) { 611 struct v4l2_priv_tun_config tda9887_cfg; 612 int tda_config = 0; 613 int is_secam_l = (params->std & (V4L2_STD_SECAM_L | 614 V4L2_STD_SECAM_LC)) && 615 !(params->std & ~(V4L2_STD_SECAM_L | 616 V4L2_STD_SECAM_LC)); 617 618 tda9887_cfg.tuner = TUNER_TDA9887; 619 tda9887_cfg.priv = &tda_config; 620 621 if (params->std == V4L2_STD_SECAM_LC) { 622 if (t_params->port1_active ^ t_params->port1_invert_for_secam_lc) 623 tda_config |= TDA9887_PORT1_ACTIVE; 624 if (t_params->port2_active ^ t_params->port2_invert_for_secam_lc) 625 tda_config |= TDA9887_PORT2_ACTIVE; 626 } else { 627 if (t_params->port1_active) 628 tda_config |= TDA9887_PORT1_ACTIVE; 629 if (t_params->port2_active) 630 tda_config |= TDA9887_PORT2_ACTIVE; 631 } 632 if (t_params->intercarrier_mode) 633 tda_config |= TDA9887_INTERCARRIER; 634 if (is_secam_l) { 635 if (i == 0 && t_params->default_top_secam_low) 636 tda_config |= TDA9887_TOP(t_params->default_top_secam_low); 637 else if (i == 1 && t_params->default_top_secam_mid) 638 tda_config |= TDA9887_TOP(t_params->default_top_secam_mid); 639 else if (t_params->default_top_secam_high) 640 tda_config |= TDA9887_TOP(t_params->default_top_secam_high); 641 } else { 642 if (i == 0 && t_params->default_top_low) 643 tda_config |= TDA9887_TOP(t_params->default_top_low); 644 else if (i == 1 && t_params->default_top_mid) 645 tda_config |= TDA9887_TOP(t_params->default_top_mid); 646 else if (t_params->default_top_high) 647 tda_config |= TDA9887_TOP(t_params->default_top_high); 648 } 649 if (t_params->default_pll_gating_18) 650 tda_config |= TDA9887_GATING_18; 651 i2c_clients_command(priv->i2c_props.adap, TUNER_SET_CONFIG, 652 &tda9887_cfg); 653 } 654 tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n", 655 buffer[0], buffer[1], buffer[2], buffer[3]); 656 657 rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4); 658 if (4 != rc) 659 tuner_warn("i2c i/o error: rc == %d (should be 4)\n", rc); 660 661 simple_post_tune(fe, &buffer[0], div, config, cb); 662 663 return 0; 664 } 665 666 static int simple_set_radio_freq(struct dvb_frontend *fe, 667 struct analog_parameters *params) 668 { 669 struct tunertype *tun; 670 struct tuner_simple_priv *priv = fe->tuner_priv; 671 u8 buffer[4]; 672 u16 div; 673 int rc, j; 674 struct tuner_params *t_params; 675 unsigned int freq = params->frequency; 676 677 tun = priv->tun; 678 679 for (j = tun->count-1; j > 0; j--) 680 if (tun->params[j].type == TUNER_PARAM_TYPE_RADIO) 681 break; 682 /* default t_params (j=0) will be used if desired type wasn't found */ 683 t_params = &tun->params[j]; 684 685 /* Select Radio 1st IF used */ 686 switch (t_params->radio_if) { 687 case 0: /* 10.7 MHz */ 688 freq += (unsigned int)(10.7*16000); 689 break; 690 case 1: /* 33.3 MHz */ 691 freq += (unsigned int)(33.3*16000); 692 break; 693 case 2: /* 41.3 MHz */ 694 freq += (unsigned int)(41.3*16000); 695 break; 696 default: 697 tuner_warn("Unsupported radio_if value %d\n", 698 t_params->radio_if); 699 return 0; 700 } 701 702 buffer[2] = (t_params->ranges[0].config & ~TUNER_RATIO_MASK) | 703 TUNER_RATIO_SELECT_50; /* 50 kHz step */ 704 705 /* Bandswitch byte */ 706 simple_radio_bandswitch(fe, &buffer[0]); 707 708 /* Convert from 1/16 kHz V4L steps to 1/20 MHz (=50 kHz) PLL steps 709 freq * (1 Mhz / 16000 V4L steps) * (20 PLL steps / 1 MHz) = 710 freq * (1/800) */ 711 div = (freq + 400) / 800; 712 713 if (t_params->cb_first_if_lower_freq && div < priv->last_div) { 714 buffer[0] = buffer[2]; 715 buffer[1] = buffer[3]; 716 buffer[2] = (div>>8) & 0x7f; 717 buffer[3] = div & 0xff; 718 } else { 719 buffer[0] = (div>>8) & 0x7f; 720 buffer[1] = div & 0xff; 721 } 722 723 tuner_dbg("radio 0x%02x 0x%02x 0x%02x 0x%02x\n", 724 buffer[0], buffer[1], buffer[2], buffer[3]); 725 priv->last_div = div; 726 727 if (t_params->has_tda9887) { 728 int config = 0; 729 struct v4l2_priv_tun_config tda9887_cfg; 730 731 tda9887_cfg.tuner = TUNER_TDA9887; 732 tda9887_cfg.priv = &config; 733 734 if (t_params->port1_active && 735 !t_params->port1_fm_high_sensitivity) 736 config |= TDA9887_PORT1_ACTIVE; 737 if (t_params->port2_active && 738 !t_params->port2_fm_high_sensitivity) 739 config |= TDA9887_PORT2_ACTIVE; 740 if (t_params->intercarrier_mode) 741 config |= TDA9887_INTERCARRIER; 742 /* if (t_params->port1_set_for_fm_mono) 743 config &= ~TDA9887_PORT1_ACTIVE;*/ 744 if (t_params->fm_gain_normal) 745 config |= TDA9887_GAIN_NORMAL; 746 if (t_params->radio_if == 2) 747 config |= TDA9887_RIF_41_3; 748 i2c_clients_command(priv->i2c_props.adap, TUNER_SET_CONFIG, 749 &tda9887_cfg); 750 } 751 rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4); 752 if (4 != rc) 753 tuner_warn("i2c i/o error: rc == %d (should be 4)\n", rc); 754 755 /* Write AUX byte */ 756 switch (priv->type) { 757 case TUNER_PHILIPS_FM1216ME_MK3: 758 buffer[2] = 0x98; 759 buffer[3] = 0x20; /* set TOP AGC */ 760 rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4); 761 if (4 != rc) 762 tuner_warn("i2c i/o error: rc == %d (should be 4)\n", rc); 763 break; 764 } 765 766 return 0; 767 } 768 769 static int simple_set_params(struct dvb_frontend *fe, 770 struct analog_parameters *params) 771 { 772 struct tuner_simple_priv *priv = fe->tuner_priv; 773 int ret = -EINVAL; 774 775 if (priv->i2c_props.adap == NULL) 776 return -EINVAL; 777 778 switch (params->mode) { 779 case V4L2_TUNER_RADIO: 780 priv->radio_mode = true; 781 ret = simple_set_radio_freq(fe, params); 782 priv->frequency = params->frequency * 125 / 2; 783 break; 784 case V4L2_TUNER_ANALOG_TV: 785 case V4L2_TUNER_DIGITAL_TV: 786 priv->radio_mode = false; 787 ret = simple_set_tv_freq(fe, params); 788 priv->frequency = params->frequency * 62500; 789 break; 790 } 791 priv->bandwidth = 0; 792 793 return ret; 794 } 795 796 static void simple_set_dvb(struct dvb_frontend *fe, u8 *buf, 797 const u32 delsys, 798 const u32 frequency, 799 const u32 bandwidth) 800 { 801 struct tuner_simple_priv *priv = fe->tuner_priv; 802 803 switch (priv->type) { 804 case TUNER_PHILIPS_FMD1216ME_MK3: 805 case TUNER_PHILIPS_FMD1216MEX_MK3: 806 if (bandwidth == 8000000 && 807 frequency >= 158870000) 808 buf[3] |= 0x08; 809 break; 810 case TUNER_PHILIPS_TD1316: 811 /* determine band */ 812 buf[3] |= (frequency < 161000000) ? 1 : 813 (frequency < 444000000) ? 2 : 4; 814 815 /* setup PLL filter */ 816 if (bandwidth == 8000000) 817 buf[3] |= 1 << 3; 818 break; 819 case TUNER_PHILIPS_TUV1236D: 820 case TUNER_PHILIPS_FCV1236D: 821 { 822 unsigned int new_rf; 823 824 if (dtv_input[priv->nr]) 825 new_rf = dtv_input[priv->nr]; 826 else 827 switch (delsys) { 828 case SYS_DVBC_ANNEX_B: 829 new_rf = 1; 830 break; 831 case SYS_ATSC: 832 default: 833 new_rf = 0; 834 break; 835 } 836 simple_set_rf_input(fe, &buf[2], &buf[3], new_rf); 837 break; 838 } 839 default: 840 break; 841 } 842 } 843 844 static u32 simple_dvb_configure(struct dvb_frontend *fe, u8 *buf, 845 const u32 delsys, 846 const u32 freq, 847 const u32 bw) 848 { 849 /* This function returns the tuned frequency on success, 0 on error */ 850 struct tuner_simple_priv *priv = fe->tuner_priv; 851 struct tunertype *tun = priv->tun; 852 static struct tuner_params *t_params; 853 u8 config, cb; 854 u32 div; 855 int ret; 856 u32 frequency = freq / 62500; 857 858 if (!tun->stepsize) { 859 /* tuner-core was loaded before the digital tuner was 860 * configured and somehow picked the wrong tuner type */ 861 tuner_err("attempt to treat tuner %d (%s) as digital tuner " 862 "without stepsize defined.\n", 863 priv->type, priv->tun->name); 864 return 0; /* failure */ 865 } 866 867 t_params = simple_tuner_params(fe, TUNER_PARAM_TYPE_DIGITAL); 868 ret = simple_config_lookup(fe, t_params, &frequency, &config, &cb); 869 if (ret < 0) 870 return 0; /* failure */ 871 872 div = ((frequency + t_params->iffreq) * 62500 + offset + 873 tun->stepsize/2) / tun->stepsize; 874 875 buf[0] = div >> 8; 876 buf[1] = div & 0xff; 877 buf[2] = config; 878 buf[3] = cb; 879 880 simple_set_dvb(fe, buf, delsys, freq, bw); 881 882 tuner_dbg("%s: div=%d | buf=0x%02x,0x%02x,0x%02x,0x%02x\n", 883 tun->name, div, buf[0], buf[1], buf[2], buf[3]); 884 885 /* calculate the frequency we set it to */ 886 return (div * tun->stepsize) - t_params->iffreq; 887 } 888 889 static int simple_dvb_calc_regs(struct dvb_frontend *fe, 890 u8 *buf, int buf_len) 891 { 892 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 893 u32 delsys = c->delivery_system; 894 u32 bw = c->bandwidth_hz; 895 struct tuner_simple_priv *priv = fe->tuner_priv; 896 u32 frequency; 897 898 if (buf_len < 5) 899 return -EINVAL; 900 901 frequency = simple_dvb_configure(fe, buf+1, delsys, c->frequency, bw); 902 if (frequency == 0) 903 return -EINVAL; 904 905 buf[0] = priv->i2c_props.addr; 906 907 priv->frequency = frequency; 908 priv->bandwidth = c->bandwidth_hz; 909 910 return 5; 911 } 912 913 static int simple_dvb_set_params(struct dvb_frontend *fe) 914 { 915 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 916 u32 delsys = c->delivery_system; 917 u32 bw = c->bandwidth_hz; 918 u32 freq = c->frequency; 919 struct tuner_simple_priv *priv = fe->tuner_priv; 920 u32 frequency; 921 u32 prev_freq, prev_bw; 922 int ret; 923 u8 buf[5]; 924 925 if (priv->i2c_props.adap == NULL) 926 return -EINVAL; 927 928 prev_freq = priv->frequency; 929 prev_bw = priv->bandwidth; 930 931 frequency = simple_dvb_configure(fe, buf+1, delsys, freq, bw); 932 if (frequency == 0) 933 return -EINVAL; 934 935 buf[0] = priv->i2c_props.addr; 936 937 priv->frequency = frequency; 938 priv->bandwidth = bw; 939 940 /* put analog demod in standby when tuning digital */ 941 if (fe->ops.analog_ops.standby) 942 fe->ops.analog_ops.standby(fe); 943 944 if (fe->ops.i2c_gate_ctrl) 945 fe->ops.i2c_gate_ctrl(fe, 1); 946 947 /* buf[0] contains the i2c address, but * 948 * we already have it in i2c_props.addr */ 949 ret = tuner_i2c_xfer_send(&priv->i2c_props, buf+1, 4); 950 if (ret != 4) 951 goto fail; 952 953 return 0; 954 fail: 955 /* calc_regs sets frequency and bandwidth. if we failed, unset them */ 956 priv->frequency = prev_freq; 957 priv->bandwidth = prev_bw; 958 959 return ret; 960 } 961 962 static int simple_init(struct dvb_frontend *fe) 963 { 964 struct tuner_simple_priv *priv = fe->tuner_priv; 965 966 if (priv->i2c_props.adap == NULL) 967 return -EINVAL; 968 969 if (priv->tun->initdata) { 970 int ret; 971 972 if (fe->ops.i2c_gate_ctrl) 973 fe->ops.i2c_gate_ctrl(fe, 1); 974 975 ret = tuner_i2c_xfer_send(&priv->i2c_props, 976 priv->tun->initdata + 1, 977 priv->tun->initdata[0]); 978 if (ret != priv->tun->initdata[0]) 979 return ret; 980 } 981 982 return 0; 983 } 984 985 static int simple_sleep(struct dvb_frontend *fe) 986 { 987 struct tuner_simple_priv *priv = fe->tuner_priv; 988 989 if (priv->i2c_props.adap == NULL) 990 return -EINVAL; 991 992 if (priv->tun->sleepdata) { 993 int ret; 994 995 if (fe->ops.i2c_gate_ctrl) 996 fe->ops.i2c_gate_ctrl(fe, 1); 997 998 ret = tuner_i2c_xfer_send(&priv->i2c_props, 999 priv->tun->sleepdata + 1, 1000 priv->tun->sleepdata[0]); 1001 if (ret != priv->tun->sleepdata[0]) 1002 return ret; 1003 } 1004 1005 return 0; 1006 } 1007 1008 static int simple_release(struct dvb_frontend *fe) 1009 { 1010 struct tuner_simple_priv *priv = fe->tuner_priv; 1011 1012 mutex_lock(&tuner_simple_list_mutex); 1013 1014 if (priv) 1015 hybrid_tuner_release_state(priv); 1016 1017 mutex_unlock(&tuner_simple_list_mutex); 1018 1019 fe->tuner_priv = NULL; 1020 1021 return 0; 1022 } 1023 1024 static int simple_get_frequency(struct dvb_frontend *fe, u32 *frequency) 1025 { 1026 struct tuner_simple_priv *priv = fe->tuner_priv; 1027 *frequency = priv->frequency; 1028 return 0; 1029 } 1030 1031 static int simple_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth) 1032 { 1033 struct tuner_simple_priv *priv = fe->tuner_priv; 1034 *bandwidth = priv->bandwidth; 1035 return 0; 1036 } 1037 1038 static struct dvb_tuner_ops simple_tuner_ops = { 1039 .init = simple_init, 1040 .sleep = simple_sleep, 1041 .set_analog_params = simple_set_params, 1042 .set_params = simple_dvb_set_params, 1043 .calc_regs = simple_dvb_calc_regs, 1044 .release = simple_release, 1045 .get_frequency = simple_get_frequency, 1046 .get_bandwidth = simple_get_bandwidth, 1047 .get_status = simple_get_status, 1048 .get_rf_strength = simple_get_rf_strength, 1049 }; 1050 1051 struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe, 1052 struct i2c_adapter *i2c_adap, 1053 u8 i2c_addr, 1054 unsigned int type) 1055 { 1056 struct tuner_simple_priv *priv = NULL; 1057 int instance; 1058 1059 if (type >= tuner_count) { 1060 printk(KERN_WARNING "%s: invalid tuner type: %d (max: %d)\n", 1061 __func__, type, tuner_count-1); 1062 return NULL; 1063 } 1064 1065 /* If i2c_adap is set, check that the tuner is at the correct address. 1066 * Otherwise, if i2c_adap is NULL, the tuner will be programmed directly 1067 * by the digital demod via calc_regs. 1068 */ 1069 if (i2c_adap != NULL) { 1070 u8 b[1]; 1071 struct i2c_msg msg = { 1072 .addr = i2c_addr, .flags = I2C_M_RD, 1073 .buf = b, .len = 1, 1074 }; 1075 1076 if (fe->ops.i2c_gate_ctrl) 1077 fe->ops.i2c_gate_ctrl(fe, 1); 1078 1079 if (1 != i2c_transfer(i2c_adap, &msg, 1)) 1080 printk(KERN_WARNING "tuner-simple %d-%04x: " 1081 "unable to probe %s, proceeding anyway.", 1082 i2c_adapter_id(i2c_adap), i2c_addr, 1083 tuners[type].name); 1084 1085 if (fe->ops.i2c_gate_ctrl) 1086 fe->ops.i2c_gate_ctrl(fe, 0); 1087 } 1088 1089 mutex_lock(&tuner_simple_list_mutex); 1090 1091 instance = hybrid_tuner_request_state(struct tuner_simple_priv, priv, 1092 hybrid_tuner_instance_list, 1093 i2c_adap, i2c_addr, 1094 "tuner-simple"); 1095 switch (instance) { 1096 case 0: 1097 mutex_unlock(&tuner_simple_list_mutex); 1098 return NULL; 1099 case 1: 1100 fe->tuner_priv = priv; 1101 1102 priv->type = type; 1103 priv->tun = &tuners[type]; 1104 priv->nr = simple_devcount++; 1105 break; 1106 default: 1107 fe->tuner_priv = priv; 1108 break; 1109 } 1110 1111 mutex_unlock(&tuner_simple_list_mutex); 1112 1113 memcpy(&fe->ops.tuner_ops, &simple_tuner_ops, 1114 sizeof(struct dvb_tuner_ops)); 1115 1116 if (type != priv->type) 1117 tuner_warn("couldn't set type to %d. Using %d (%s) instead\n", 1118 type, priv->type, priv->tun->name); 1119 else 1120 tuner_info("type set to %d (%s)\n", 1121 priv->type, priv->tun->name); 1122 1123 if ((debug) || ((atv_input[priv->nr] > 0) || 1124 (dtv_input[priv->nr] > 0))) { 1125 if (0 == atv_input[priv->nr]) 1126 tuner_info("tuner %d atv rf input will be " 1127 "autoselected\n", priv->nr); 1128 else 1129 tuner_info("tuner %d atv rf input will be " 1130 "set to input %d (insmod option)\n", 1131 priv->nr, atv_input[priv->nr]); 1132 if (0 == dtv_input[priv->nr]) 1133 tuner_info("tuner %d dtv rf input will be " 1134 "autoselected\n", priv->nr); 1135 else 1136 tuner_info("tuner %d dtv rf input will be " 1137 "set to input %d (insmod option)\n", 1138 priv->nr, dtv_input[priv->nr]); 1139 } 1140 1141 strlcpy(fe->ops.tuner_ops.info.name, priv->tun->name, 1142 sizeof(fe->ops.tuner_ops.info.name)); 1143 1144 return fe; 1145 } 1146 EXPORT_SYMBOL_GPL(simple_tuner_attach); 1147 1148 MODULE_DESCRIPTION("Simple 4-control-bytes style tuner driver"); 1149 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer"); 1150 MODULE_LICENSE("GPL"); 1151