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 -EINVAL; 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 if (simple_radio_bandswitch(fe, &buffer[0])) 706 return 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 && 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 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 without stepsize defined.\n", 862 priv->type, priv->tun->name); 863 return 0; /* failure */ 864 } 865 866 t_params = simple_tuner_params(fe, TUNER_PARAM_TYPE_DIGITAL); 867 ret = simple_config_lookup(fe, t_params, &frequency, &config, &cb); 868 if (ret < 0) 869 return 0; /* failure */ 870 871 div = ((frequency + t_params->iffreq) * 62500 + offset + 872 tun->stepsize/2) / tun->stepsize; 873 874 buf[0] = div >> 8; 875 buf[1] = div & 0xff; 876 buf[2] = config; 877 buf[3] = cb; 878 879 simple_set_dvb(fe, buf, delsys, freq, bw); 880 881 tuner_dbg("%s: div=%d | buf=0x%02x,0x%02x,0x%02x,0x%02x\n", 882 tun->name, div, buf[0], buf[1], buf[2], buf[3]); 883 884 /* calculate the frequency we set it to */ 885 return (div * tun->stepsize) - t_params->iffreq; 886 } 887 888 static int simple_dvb_calc_regs(struct dvb_frontend *fe, 889 u8 *buf, int buf_len) 890 { 891 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 892 u32 delsys = c->delivery_system; 893 u32 bw = c->bandwidth_hz; 894 struct tuner_simple_priv *priv = fe->tuner_priv; 895 u32 frequency; 896 897 if (buf_len < 5) 898 return -EINVAL; 899 900 frequency = simple_dvb_configure(fe, buf+1, delsys, c->frequency, bw); 901 if (frequency == 0) 902 return -EINVAL; 903 904 buf[0] = priv->i2c_props.addr; 905 906 priv->frequency = frequency; 907 priv->bandwidth = c->bandwidth_hz; 908 909 return 5; 910 } 911 912 static int simple_dvb_set_params(struct dvb_frontend *fe) 913 { 914 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 915 u32 delsys = c->delivery_system; 916 u32 bw = c->bandwidth_hz; 917 u32 freq = c->frequency; 918 struct tuner_simple_priv *priv = fe->tuner_priv; 919 u32 frequency; 920 u32 prev_freq, prev_bw; 921 int ret; 922 u8 buf[5]; 923 924 if (priv->i2c_props.adap == NULL) 925 return -EINVAL; 926 927 prev_freq = priv->frequency; 928 prev_bw = priv->bandwidth; 929 930 frequency = simple_dvb_configure(fe, buf+1, delsys, freq, bw); 931 if (frequency == 0) 932 return -EINVAL; 933 934 buf[0] = priv->i2c_props.addr; 935 936 priv->frequency = frequency; 937 priv->bandwidth = bw; 938 939 /* put analog demod in standby when tuning digital */ 940 if (fe->ops.analog_ops.standby) 941 fe->ops.analog_ops.standby(fe); 942 943 if (fe->ops.i2c_gate_ctrl) 944 fe->ops.i2c_gate_ctrl(fe, 1); 945 946 /* buf[0] contains the i2c address, but * 947 * we already have it in i2c_props.addr */ 948 ret = tuner_i2c_xfer_send(&priv->i2c_props, buf+1, 4); 949 if (ret != 4) 950 goto fail; 951 952 return 0; 953 fail: 954 /* calc_regs sets frequency and bandwidth. if we failed, unset them */ 955 priv->frequency = prev_freq; 956 priv->bandwidth = prev_bw; 957 958 return ret; 959 } 960 961 static int simple_init(struct dvb_frontend *fe) 962 { 963 struct tuner_simple_priv *priv = fe->tuner_priv; 964 965 if (priv->i2c_props.adap == NULL) 966 return -EINVAL; 967 968 if (priv->tun->initdata) { 969 int ret; 970 971 if (fe->ops.i2c_gate_ctrl) 972 fe->ops.i2c_gate_ctrl(fe, 1); 973 974 ret = tuner_i2c_xfer_send(&priv->i2c_props, 975 priv->tun->initdata + 1, 976 priv->tun->initdata[0]); 977 if (ret != priv->tun->initdata[0]) 978 return ret; 979 } 980 981 return 0; 982 } 983 984 static int simple_sleep(struct dvb_frontend *fe) 985 { 986 struct tuner_simple_priv *priv = fe->tuner_priv; 987 988 if (priv->i2c_props.adap == NULL) 989 return -EINVAL; 990 991 if (priv->tun->sleepdata) { 992 int ret; 993 994 if (fe->ops.i2c_gate_ctrl) 995 fe->ops.i2c_gate_ctrl(fe, 1); 996 997 ret = tuner_i2c_xfer_send(&priv->i2c_props, 998 priv->tun->sleepdata + 1, 999 priv->tun->sleepdata[0]); 1000 if (ret != priv->tun->sleepdata[0]) 1001 return ret; 1002 } 1003 1004 return 0; 1005 } 1006 1007 static void simple_release(struct dvb_frontend *fe) 1008 { 1009 struct tuner_simple_priv *priv = fe->tuner_priv; 1010 1011 mutex_lock(&tuner_simple_list_mutex); 1012 1013 if (priv) 1014 hybrid_tuner_release_state(priv); 1015 1016 mutex_unlock(&tuner_simple_list_mutex); 1017 1018 fe->tuner_priv = NULL; 1019 } 1020 1021 static int simple_get_frequency(struct dvb_frontend *fe, u32 *frequency) 1022 { 1023 struct tuner_simple_priv *priv = fe->tuner_priv; 1024 *frequency = priv->frequency; 1025 return 0; 1026 } 1027 1028 static int simple_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth) 1029 { 1030 struct tuner_simple_priv *priv = fe->tuner_priv; 1031 *bandwidth = priv->bandwidth; 1032 return 0; 1033 } 1034 1035 static const struct dvb_tuner_ops simple_tuner_ops = { 1036 .init = simple_init, 1037 .sleep = simple_sleep, 1038 .set_analog_params = simple_set_params, 1039 .set_params = simple_dvb_set_params, 1040 .calc_regs = simple_dvb_calc_regs, 1041 .release = simple_release, 1042 .get_frequency = simple_get_frequency, 1043 .get_bandwidth = simple_get_bandwidth, 1044 .get_status = simple_get_status, 1045 .get_rf_strength = simple_get_rf_strength, 1046 }; 1047 1048 struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe, 1049 struct i2c_adapter *i2c_adap, 1050 u8 i2c_addr, 1051 unsigned int type) 1052 { 1053 struct tuner_simple_priv *priv = NULL; 1054 int instance; 1055 1056 if (type >= tuner_count) { 1057 printk(KERN_WARNING "%s: invalid tuner type: %d (max: %d)\n", 1058 __func__, type, tuner_count-1); 1059 return NULL; 1060 } 1061 1062 /* If i2c_adap is set, check that the tuner is at the correct address. 1063 * Otherwise, if i2c_adap is NULL, the tuner will be programmed directly 1064 * by the digital demod via calc_regs. 1065 */ 1066 if (i2c_adap != NULL) { 1067 u8 b[1]; 1068 struct i2c_msg msg = { 1069 .addr = i2c_addr, .flags = I2C_M_RD, 1070 .buf = b, .len = 1, 1071 }; 1072 1073 if (fe->ops.i2c_gate_ctrl) 1074 fe->ops.i2c_gate_ctrl(fe, 1); 1075 1076 if (1 != i2c_transfer(i2c_adap, &msg, 1)) 1077 printk(KERN_WARNING "tuner-simple %d-%04x: unable to probe %s, proceeding anyway.", 1078 i2c_adapter_id(i2c_adap), i2c_addr, 1079 tuners[type].name); 1080 1081 if (fe->ops.i2c_gate_ctrl) 1082 fe->ops.i2c_gate_ctrl(fe, 0); 1083 } 1084 1085 mutex_lock(&tuner_simple_list_mutex); 1086 1087 instance = hybrid_tuner_request_state(struct tuner_simple_priv, priv, 1088 hybrid_tuner_instance_list, 1089 i2c_adap, i2c_addr, 1090 "tuner-simple"); 1091 switch (instance) { 1092 case 0: 1093 mutex_unlock(&tuner_simple_list_mutex); 1094 return NULL; 1095 case 1: 1096 fe->tuner_priv = priv; 1097 1098 priv->type = type; 1099 priv->tun = &tuners[type]; 1100 priv->nr = simple_devcount++; 1101 break; 1102 default: 1103 fe->tuner_priv = priv; 1104 break; 1105 } 1106 1107 mutex_unlock(&tuner_simple_list_mutex); 1108 1109 memcpy(&fe->ops.tuner_ops, &simple_tuner_ops, 1110 sizeof(struct dvb_tuner_ops)); 1111 1112 if (type != priv->type) 1113 tuner_warn("couldn't set type to %d. Using %d (%s) instead\n", 1114 type, priv->type, priv->tun->name); 1115 else 1116 tuner_info("type set to %d (%s)\n", 1117 priv->type, priv->tun->name); 1118 1119 if ((debug) || ((atv_input[priv->nr] > 0) || 1120 (dtv_input[priv->nr] > 0))) { 1121 if (0 == atv_input[priv->nr]) 1122 tuner_info("tuner %d atv rf input will be autoselected\n", 1123 priv->nr); 1124 else 1125 tuner_info("tuner %d atv rf input will be set to input %d (insmod option)\n", 1126 priv->nr, atv_input[priv->nr]); 1127 if (0 == dtv_input[priv->nr]) 1128 tuner_info("tuner %d dtv rf input will be autoselected\n", 1129 priv->nr); 1130 else 1131 tuner_info("tuner %d dtv rf input will be set to input %d (insmod option)\n", 1132 priv->nr, dtv_input[priv->nr]); 1133 } 1134 1135 strscpy(fe->ops.tuner_ops.info.name, priv->tun->name, 1136 sizeof(fe->ops.tuner_ops.info.name)); 1137 1138 return fe; 1139 } 1140 EXPORT_SYMBOL_GPL(simple_tuner_attach); 1141 1142 MODULE_DESCRIPTION("Simple 4-control-bytes style tuner driver"); 1143 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer"); 1144 MODULE_LICENSE("GPL"); 1145