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