1/* 2 * i2c tv tuner chip device driver 3 * core core, i.e. kernel interfaces, registering and so on 4 * 5 * Copyright(c) by Ralph Metzler, Gerd Knorr, Gunther Mayer 6 * 7 * Copyright(c) 2005-2011 by Mauro Carvalho Chehab 8 * - Added support for a separate Radio tuner 9 * - Major rework and cleanups at the code 10 * 11 * This driver supports many devices and the idea is to let the driver 12 * detect which device is present. So rather than listing all supported 13 * devices here, we pretend to support a single, fake device type that will 14 * handle both radio and analog TV tuning. 15 */ 16 17#include <linux/module.h> 18#include <linux/kernel.h> 19#include <linux/string.h> 20#include <linux/timer.h> 21#include <linux/delay.h> 22#include <linux/errno.h> 23#include <linux/slab.h> 24#include <linux/poll.h> 25#include <linux/i2c.h> 26#include <linux/types.h> 27#include <linux/init.h> 28#include <linux/videodev2.h> 29#include <media/tuner.h> 30#include <media/tuner-types.h> 31#include <media/v4l2-device.h> 32#include <media/v4l2-ioctl.h> 33#include "mt20xx.h" 34#include "tda8290.h" 35#include "tea5761.h" 36#include "tea5767.h" 37#include "tuner-xc2028.h" 38#include "tuner-simple.h" 39#include "tda9887.h" 40#include "xc5000.h" 41#include "tda18271.h" 42#include "xc4000.h" 43 44#define UNSET (-1U) 45 46#define PREFIX (t->i2c->dev.driver->name) 47 48/* 49 * Driver modprobe parameters 50 */ 51 52/* insmod options used at init time => read/only */ 53static unsigned int addr; 54static unsigned int no_autodetect; 55static unsigned int show_i2c; 56 57module_param(addr, int, 0444); 58module_param(no_autodetect, int, 0444); 59module_param(show_i2c, int, 0444); 60 61/* insmod options used at runtime => read/write */ 62static int tuner_debug; 63static unsigned int tv_range[2] = { 44, 958 }; 64static unsigned int radio_range[2] = { 65, 108 }; 65static char pal[] = "--"; 66static char secam[] = "--"; 67static char ntsc[] = "-"; 68 69module_param_named(debug, tuner_debug, int, 0644); 70module_param_array(tv_range, int, NULL, 0644); 71module_param_array(radio_range, int, NULL, 0644); 72module_param_string(pal, pal, sizeof(pal), 0644); 73module_param_string(secam, secam, sizeof(secam), 0644); 74module_param_string(ntsc, ntsc, sizeof(ntsc), 0644); 75 76/* 77 * Static vars 78 */ 79 80static LIST_HEAD(tuner_list); 81static const struct v4l2_subdev_ops tuner_ops; 82 83/* 84 * Debug macros 85 */ 86 87#define tuner_warn(fmt, arg...) do { \ 88 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \ 89 i2c_adapter_id(t->i2c->adapter), \ 90 t->i2c->addr, ##arg); \ 91 } while (0) 92 93#define tuner_info(fmt, arg...) do { \ 94 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \ 95 i2c_adapter_id(t->i2c->adapter), \ 96 t->i2c->addr, ##arg); \ 97 } while (0) 98 99#define tuner_err(fmt, arg...) do { \ 100 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \ 101 i2c_adapter_id(t->i2c->adapter), \ 102 t->i2c->addr, ##arg); \ 103 } while (0) 104 105#define tuner_dbg(fmt, arg...) do { \ 106 if (tuner_debug) \ 107 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \ 108 i2c_adapter_id(t->i2c->adapter), \ 109 t->i2c->addr, ##arg); \ 110 } while (0) 111 112/* 113 * Internal struct used inside the driver 114 */ 115 116struct tuner { 117 /* device */ 118 struct dvb_frontend fe; 119 struct i2c_client *i2c; 120 struct v4l2_subdev sd; 121 struct list_head list; 122 123 /* keep track of the current settings */ 124 v4l2_std_id std; 125 unsigned int tv_freq; 126 unsigned int radio_freq; 127 unsigned int audmode; 128 129 enum v4l2_tuner_type mode; 130 unsigned int mode_mask; /* Combination of allowable modes */ 131 132 bool standby; /* Standby mode */ 133 134 unsigned int type; /* chip type id */ 135 void *config; 136 const char *name; 137#if defined(CONFIG_MEDIA_CONTROLLER) 138 struct media_pad pad; 139#endif 140}; 141 142/* 143 * Function prototypes 144 */ 145 146static void set_tv_freq(struct i2c_client *c, unsigned int freq); 147static void set_radio_freq(struct i2c_client *c, unsigned int freq); 148 149/* 150 * tuner attach/detach logic 151 */ 152 153/* This macro allows us to probe dynamically, avoiding static links */ 154#ifdef CONFIG_MEDIA_ATTACH 155#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \ 156 int __r = -EINVAL; \ 157 typeof(&FUNCTION) __a = symbol_request(FUNCTION); \ 158 if (__a) { \ 159 __r = (int) __a(ARGS); \ 160 symbol_put(FUNCTION); \ 161 } else { \ 162 printk(KERN_ERR "TUNER: Unable to find " \ 163 "symbol "#FUNCTION"()\n"); \ 164 } \ 165 __r; \ 166}) 167 168static void tuner_detach(struct dvb_frontend *fe) 169{ 170 if (fe->ops.tuner_ops.release) { 171 fe->ops.tuner_ops.release(fe); 172 symbol_put_addr(fe->ops.tuner_ops.release); 173 } 174 if (fe->ops.analog_ops.release) { 175 fe->ops.analog_ops.release(fe); 176 symbol_put_addr(fe->ops.analog_ops.release); 177 } 178} 179#else 180#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \ 181 FUNCTION(ARGS); \ 182}) 183 184static void tuner_detach(struct dvb_frontend *fe) 185{ 186 if (fe->ops.tuner_ops.release) 187 fe->ops.tuner_ops.release(fe); 188 if (fe->ops.analog_ops.release) 189 fe->ops.analog_ops.release(fe); 190} 191#endif 192 193 194static inline struct tuner *to_tuner(struct v4l2_subdev *sd) 195{ 196 return container_of(sd, struct tuner, sd); 197} 198 199/* 200 * struct analog_demod_ops callbacks 201 */ 202 203static void fe_set_params(struct dvb_frontend *fe, 204 struct analog_parameters *params) 205{ 206 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops; 207 struct tuner *t = fe->analog_demod_priv; 208 209 if (NULL == fe_tuner_ops->set_analog_params) { 210 tuner_warn("Tuner frontend module has no way to set freq\n"); 211 return; 212 } 213 fe_tuner_ops->set_analog_params(fe, params); 214} 215 216static void fe_standby(struct dvb_frontend *fe) 217{ 218 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops; 219 220 if (fe_tuner_ops->sleep) 221 fe_tuner_ops->sleep(fe); 222} 223 224static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg) 225{ 226 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops; 227 struct tuner *t = fe->analog_demod_priv; 228 229 if (fe_tuner_ops->set_config) 230 return fe_tuner_ops->set_config(fe, priv_cfg); 231 232 tuner_warn("Tuner frontend module has no way to set config\n"); 233 234 return 0; 235} 236 237static void tuner_status(struct dvb_frontend *fe); 238 239static const struct analog_demod_ops tuner_analog_ops = { 240 .set_params = fe_set_params, 241 .standby = fe_standby, 242 .set_config = fe_set_config, 243 .tuner_status = tuner_status 244}; 245 246/* 247 * Functions to select between radio and TV and tuner probe/remove functions 248 */ 249 250/** 251 * set_type - Sets the tuner type for a given device 252 * 253 * @c: i2c_client descriptor 254 * @type: type of the tuner (e. g. tuner number) 255 * @new_mode_mask: Indicates if tuner supports TV and/or Radio 256 * @new_config: an optional parameter used by a few tuners to adjust 257 internal parameters, like LNA mode 258 * @tuner_callback: an optional function to be called when switching 259 * to analog mode 260 * 261 * This function applys the tuner config to tuner specified 262 * by tun_setup structure. It contains several per-tuner initialization "magic" 263 */ 264static void set_type(struct i2c_client *c, unsigned int type, 265 unsigned int new_mode_mask, void *new_config, 266 int (*tuner_callback) (void *dev, int component, int cmd, int arg)) 267{ 268 struct tuner *t = to_tuner(i2c_get_clientdata(c)); 269 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops; 270 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops; 271 unsigned char buffer[4]; 272 int tune_now = 1; 273 274 if (type == UNSET || type == TUNER_ABSENT) { 275 tuner_dbg("tuner 0x%02x: Tuner type absent\n", c->addr); 276 return; 277 } 278 279 t->type = type; 280 t->config = new_config; 281 if (tuner_callback != NULL) { 282 tuner_dbg("defining GPIO callback\n"); 283 t->fe.callback = tuner_callback; 284 } 285 286 /* discard private data, in case set_type() was previously called */ 287 tuner_detach(&t->fe); 288 t->fe.analog_demod_priv = NULL; 289 290 switch (t->type) { 291 case TUNER_MT2032: 292 if (!dvb_attach(microtune_attach, 293 &t->fe, t->i2c->adapter, t->i2c->addr)) 294 goto attach_failed; 295 break; 296 case TUNER_PHILIPS_TDA8290: 297 { 298 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter, 299 t->i2c->addr, t->config)) 300 goto attach_failed; 301 break; 302 } 303 case TUNER_TEA5767: 304 if (!dvb_attach(tea5767_attach, &t->fe, 305 t->i2c->adapter, t->i2c->addr)) 306 goto attach_failed; 307 t->mode_mask = T_RADIO; 308 break; 309 case TUNER_TEA5761: 310 if (!dvb_attach(tea5761_attach, &t->fe, 311 t->i2c->adapter, t->i2c->addr)) 312 goto attach_failed; 313 t->mode_mask = T_RADIO; 314 break; 315 case TUNER_PHILIPS_FMD1216ME_MK3: 316 case TUNER_PHILIPS_FMD1216MEX_MK3: 317 buffer[0] = 0x0b; 318 buffer[1] = 0xdc; 319 buffer[2] = 0x9c; 320 buffer[3] = 0x60; 321 i2c_master_send(c, buffer, 4); 322 mdelay(1); 323 buffer[2] = 0x86; 324 buffer[3] = 0x54; 325 i2c_master_send(c, buffer, 4); 326 if (!dvb_attach(simple_tuner_attach, &t->fe, 327 t->i2c->adapter, t->i2c->addr, t->type)) 328 goto attach_failed; 329 break; 330 case TUNER_PHILIPS_TD1316: 331 buffer[0] = 0x0b; 332 buffer[1] = 0xdc; 333 buffer[2] = 0x86; 334 buffer[3] = 0xa4; 335 i2c_master_send(c, buffer, 4); 336 if (!dvb_attach(simple_tuner_attach, &t->fe, 337 t->i2c->adapter, t->i2c->addr, t->type)) 338 goto attach_failed; 339 break; 340 case TUNER_XC2028: 341 { 342 struct xc2028_config cfg = { 343 .i2c_adap = t->i2c->adapter, 344 .i2c_addr = t->i2c->addr, 345 }; 346 if (!dvb_attach(xc2028_attach, &t->fe, &cfg)) 347 goto attach_failed; 348 tune_now = 0; 349 break; 350 } 351 case TUNER_TDA9887: 352 if (!dvb_attach(tda9887_attach, 353 &t->fe, t->i2c->adapter, t->i2c->addr)) 354 goto attach_failed; 355 break; 356 case TUNER_XC5000: 357 { 358 struct xc5000_config xc5000_cfg = { 359 .i2c_address = t->i2c->addr, 360 /* if_khz will be set at dvb_attach() */ 361 .if_khz = 0, 362 }; 363 364 if (!dvb_attach(xc5000_attach, 365 &t->fe, t->i2c->adapter, &xc5000_cfg)) 366 goto attach_failed; 367 tune_now = 0; 368 break; 369 } 370 case TUNER_XC5000C: 371 { 372 struct xc5000_config xc5000c_cfg = { 373 .i2c_address = t->i2c->addr, 374 /* if_khz will be set at dvb_attach() */ 375 .if_khz = 0, 376 .chip_id = XC5000C, 377 }; 378 379 if (!dvb_attach(xc5000_attach, 380 &t->fe, t->i2c->adapter, &xc5000c_cfg)) 381 goto attach_failed; 382 tune_now = 0; 383 break; 384 } 385 case TUNER_NXP_TDA18271: 386 { 387 struct tda18271_config cfg = { 388 .small_i2c = TDA18271_03_BYTE_CHUNK_INIT, 389 }; 390 391 if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr, 392 t->i2c->adapter, &cfg)) 393 goto attach_failed; 394 tune_now = 0; 395 break; 396 } 397 case TUNER_XC4000: 398 { 399 struct xc4000_config xc4000_cfg = { 400 .i2c_address = t->i2c->addr, 401 /* FIXME: the correct parameters will be set */ 402 /* only when the digital dvb_attach() occurs */ 403 .default_pm = 0, 404 .dvb_amplitude = 0, 405 .set_smoothedcvbs = 0, 406 .if_khz = 0 407 }; 408 if (!dvb_attach(xc4000_attach, 409 &t->fe, t->i2c->adapter, &xc4000_cfg)) 410 goto attach_failed; 411 tune_now = 0; 412 break; 413 } 414 default: 415 if (!dvb_attach(simple_tuner_attach, &t->fe, 416 t->i2c->adapter, t->i2c->addr, t->type)) 417 goto attach_failed; 418 419 break; 420 } 421 422 if ((NULL == analog_ops->set_params) && 423 (fe_tuner_ops->set_analog_params)) { 424 425 t->name = fe_tuner_ops->info.name; 426 427 t->fe.analog_demod_priv = t; 428 memcpy(analog_ops, &tuner_analog_ops, 429 sizeof(struct analog_demod_ops)); 430 431 if (fe_tuner_ops->get_rf_strength) 432 analog_ops->has_signal = fe_tuner_ops->get_rf_strength; 433 if (fe_tuner_ops->get_afc) 434 analog_ops->get_afc = fe_tuner_ops->get_afc; 435 436 } else { 437 t->name = analog_ops->info.name; 438 } 439 440#ifdef CONFIG_MEDIA_CONTROLLER 441 t->sd.entity.name = t->name; 442#endif 443 444 tuner_dbg("type set to %s\n", t->name); 445 446 t->mode_mask = new_mode_mask; 447 448 /* Some tuners require more initialization setup before use, 449 such as firmware download or device calibration. 450 trying to set a frequency here will just fail 451 FIXME: better to move set_freq to the tuner code. This is needed 452 on analog tuners for PLL to properly work 453 */ 454 if (tune_now) { 455 if (V4L2_TUNER_RADIO == t->mode) 456 set_radio_freq(c, t->radio_freq); 457 else 458 set_tv_freq(c, t->tv_freq); 459 } 460 461 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n", 462 c->adapter->name, c->dev.driver->name, c->addr << 1, type, 463 t->mode_mask); 464 return; 465 466attach_failed: 467 tuner_dbg("Tuner attach for type = %d failed.\n", t->type); 468 t->type = TUNER_ABSENT; 469 470 return; 471} 472 473/** 474 * tuner_s_type_addr - Sets the tuner type for a device 475 * 476 * @sd: subdev descriptor 477 * @tun_setup: type to be associated to a given tuner i2c address 478 * 479 * This function applys the tuner config to tuner specified 480 * by tun_setup structure. 481 * If tuner I2C address is UNSET, then it will only set the device 482 * if the tuner supports the mode specified in the call. 483 * If the address is specified, the change will be applied only if 484 * tuner I2C address matches. 485 * The call can change the tuner number and the tuner mode. 486 */ 487static int tuner_s_type_addr(struct v4l2_subdev *sd, 488 struct tuner_setup *tun_setup) 489{ 490 struct tuner *t = to_tuner(sd); 491 struct i2c_client *c = v4l2_get_subdevdata(sd); 492 493 tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=%p\n", 494 tun_setup->type, 495 tun_setup->addr, 496 tun_setup->mode_mask, 497 tun_setup->config); 498 499 if ((t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) && 500 (t->mode_mask & tun_setup->mode_mask))) || 501 (tun_setup->addr == c->addr)) { 502 set_type(c, tun_setup->type, tun_setup->mode_mask, 503 tun_setup->config, tun_setup->tuner_callback); 504 } else 505 tuner_dbg("set addr discarded for type %i, mask %x. " 506 "Asked to change tuner at addr 0x%02x, with mask %x\n", 507 t->type, t->mode_mask, 508 tun_setup->addr, tun_setup->mode_mask); 509 510 return 0; 511} 512 513/** 514 * tuner_s_config - Sets tuner configuration 515 * 516 * @sd: subdev descriptor 517 * @cfg: tuner configuration 518 * 519 * Calls tuner set_config() private function to set some tuner-internal 520 * parameters 521 */ 522static int tuner_s_config(struct v4l2_subdev *sd, 523 const struct v4l2_priv_tun_config *cfg) 524{ 525 struct tuner *t = to_tuner(sd); 526 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops; 527 528 if (t->type != cfg->tuner) 529 return 0; 530 531 if (analog_ops->set_config) { 532 analog_ops->set_config(&t->fe, cfg->priv); 533 return 0; 534 } 535 536 tuner_dbg("Tuner frontend module has no way to set config\n"); 537 return 0; 538} 539 540/** 541 * tuner_lookup - Seek for tuner adapters 542 * 543 * @adap: i2c_adapter struct 544 * @radio: pointer to be filled if the adapter is radio 545 * @tv: pointer to be filled if the adapter is TV 546 * 547 * Search for existing radio and/or TV tuners on the given I2C adapter, 548 * discarding demod-only adapters (tda9887). 549 * 550 * Note that when this function is called from tuner_probe you can be 551 * certain no other devices will be added/deleted at the same time, I2C 552 * core protects against that. 553 */ 554static void tuner_lookup(struct i2c_adapter *adap, 555 struct tuner **radio, struct tuner **tv) 556{ 557 struct tuner *pos; 558 559 *radio = NULL; 560 *tv = NULL; 561 562 list_for_each_entry(pos, &tuner_list, list) { 563 int mode_mask; 564 565 if (pos->i2c->adapter != adap || 566 strcmp(pos->i2c->dev.driver->name, "tuner")) 567 continue; 568 569 mode_mask = pos->mode_mask; 570 if (*radio == NULL && mode_mask == T_RADIO) 571 *radio = pos; 572 /* Note: currently TDA9887 is the only demod-only 573 device. If other devices appear then we need to 574 make this test more general. */ 575 else if (*tv == NULL && pos->type != TUNER_TDA9887 && 576 (pos->mode_mask & T_ANALOG_TV)) 577 *tv = pos; 578 } 579} 580 581/** 582 *tuner_probe - Probes the existing tuners on an I2C bus 583 * 584 * @client: i2c_client descriptor 585 * @id: not used 586 * 587 * This routine probes for tuners at the expected I2C addresses. On most 588 * cases, if a device answers to a given I2C address, it assumes that the 589 * device is a tuner. On a few cases, however, an additional logic is needed 590 * to double check if the device is really a tuner, or to identify the tuner 591 * type, like on tea5767/5761 devices. 592 * 593 * During client attach, set_type is called by adapter's attach_inform callback. 594 * set_type must then be completed by tuner_probe. 595 */ 596static int tuner_probe(struct i2c_client *client, 597 const struct i2c_device_id *id) 598{ 599 struct tuner *t; 600 struct tuner *radio; 601 struct tuner *tv; 602#ifdef CONFIG_MEDIA_CONTROLLER 603 int ret; 604#endif 605 606 t = kzalloc(sizeof(struct tuner), GFP_KERNEL); 607 if (NULL == t) 608 return -ENOMEM; 609 v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops); 610 t->i2c = client; 611 t->name = "(tuner unset)"; 612 t->type = UNSET; 613 t->audmode = V4L2_TUNER_MODE_STEREO; 614 t->standby = true; 615 t->radio_freq = 87.5 * 16000; /* Initial freq range */ 616 t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */ 617 618 if (show_i2c) { 619 unsigned char buffer[16]; 620 int i, rc; 621 622 memset(buffer, 0, sizeof(buffer)); 623 rc = i2c_master_recv(client, buffer, sizeof(buffer)); 624 tuner_info("I2C RECV = "); 625 for (i = 0; i < rc; i++) 626 printk(KERN_CONT "%02x ", buffer[i]); 627 printk("\n"); 628 } 629 630 /* autodetection code based on the i2c addr */ 631 if (!no_autodetect) { 632 switch (client->addr) { 633 case 0x10: 634 if (tuner_symbol_probe(tea5761_autodetection, 635 t->i2c->adapter, 636 t->i2c->addr) >= 0) { 637 t->type = TUNER_TEA5761; 638 t->mode_mask = T_RADIO; 639 tuner_lookup(t->i2c->adapter, &radio, &tv); 640 if (tv) 641 tv->mode_mask &= ~T_RADIO; 642 643 goto register_client; 644 } 645 kfree(t); 646 return -ENODEV; 647 case 0x42: 648 case 0x43: 649 case 0x4a: 650 case 0x4b: 651 /* If chip is not tda8290, don't register. 652 since it can be tda9887*/ 653 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter, 654 t->i2c->addr) >= 0) { 655 tuner_dbg("tda829x detected\n"); 656 } else { 657 /* Default is being tda9887 */ 658 t->type = TUNER_TDA9887; 659 t->mode_mask = T_RADIO | T_ANALOG_TV; 660 goto register_client; 661 } 662 break; 663 case 0x60: 664 if (tuner_symbol_probe(tea5767_autodetection, 665 t->i2c->adapter, t->i2c->addr) 666 >= 0) { 667 t->type = TUNER_TEA5767; 668 t->mode_mask = T_RADIO; 669 /* Sets freq to FM range */ 670 tuner_lookup(t->i2c->adapter, &radio, &tv); 671 if (tv) 672 tv->mode_mask &= ~T_RADIO; 673 674 goto register_client; 675 } 676 break; 677 } 678 } 679 680 /* Initializes only the first TV tuner on this adapter. Why only the 681 first? Because there are some devices (notably the ones with TI 682 tuners) that have more than one i2c address for the *same* device. 683 Experience shows that, except for just one case, the first 684 address is the right one. The exception is a Russian tuner 685 (ACORP_Y878F). So, the desired behavior is just to enable the 686 first found TV tuner. */ 687 tuner_lookup(t->i2c->adapter, &radio, &tv); 688 if (tv == NULL) { 689 t->mode_mask = T_ANALOG_TV; 690 if (radio == NULL) 691 t->mode_mask |= T_RADIO; 692 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask); 693 } 694 695 /* Should be just before return */ 696register_client: 697#if defined(CONFIG_MEDIA_CONTROLLER) 698 t->pad.flags = MEDIA_PAD_FL_SOURCE; 699 t->sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_TUNER; 700 t->sd.entity.name = t->name; 701 702 ret = media_entity_init(&t->sd.entity, 1, &t->pad, 0); 703 if (ret < 0) { 704 tuner_err("failed to initialize media entity!\n"); 705 kfree(t); 706 return -ENODEV; 707 } 708#endif 709 /* Sets a default mode */ 710 if (t->mode_mask & T_ANALOG_TV) 711 t->mode = V4L2_TUNER_ANALOG_TV; 712 else 713 t->mode = V4L2_TUNER_RADIO; 714 set_type(client, t->type, t->mode_mask, t->config, t->fe.callback); 715 list_add_tail(&t->list, &tuner_list); 716 717 tuner_info("Tuner %d found with type(s)%s%s.\n", 718 t->type, 719 t->mode_mask & T_RADIO ? " Radio" : "", 720 t->mode_mask & T_ANALOG_TV ? " TV" : ""); 721 return 0; 722} 723 724/** 725 * tuner_remove - detaches a tuner 726 * 727 * @client: i2c_client descriptor 728 */ 729 730static int tuner_remove(struct i2c_client *client) 731{ 732 struct tuner *t = to_tuner(i2c_get_clientdata(client)); 733 734 v4l2_device_unregister_subdev(&t->sd); 735 tuner_detach(&t->fe); 736 t->fe.analog_demod_priv = NULL; 737 738 list_del(&t->list); 739 kfree(t); 740 return 0; 741} 742 743/* 744 * Functions to switch between Radio and TV 745 * 746 * A few cards have a separate I2C tuner for radio. Those routines 747 * take care of switching between TV/Radio mode, filtering only the 748 * commands that apply to the Radio or TV tuner. 749 */ 750 751/** 752 * check_mode - Verify if tuner supports the requested mode 753 * @t: a pointer to the module's internal struct_tuner 754 * 755 * This function checks if the tuner is capable of tuning analog TV, 756 * digital TV or radio, depending on what the caller wants. If the 757 * tuner can't support that mode, it returns -EINVAL. Otherwise, it 758 * returns 0. 759 * This function is needed for boards that have a separate tuner for 760 * radio (like devices with tea5767). 761 * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to 762 * select a TV frequency. So, t_mode = T_ANALOG_TV could actually 763 * be used to represent a Digital TV too. 764 */ 765static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode) 766{ 767 int t_mode; 768 if (mode == V4L2_TUNER_RADIO) 769 t_mode = T_RADIO; 770 else 771 t_mode = T_ANALOG_TV; 772 773 if ((t_mode & t->mode_mask) == 0) 774 return -EINVAL; 775 776 return 0; 777} 778 779/** 780 * set_mode - Switch tuner to other mode. 781 * @t: a pointer to the module's internal struct_tuner 782 * @mode: enum v4l2_type (radio or TV) 783 * 784 * If tuner doesn't support the needed mode (radio or TV), prints a 785 * debug message and returns -EINVAL, changing its state to standby. 786 * Otherwise, changes the mode and returns 0. 787 */ 788static int set_mode(struct tuner *t, enum v4l2_tuner_type mode) 789{ 790 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops; 791 792 if (mode != t->mode) { 793 if (check_mode(t, mode) == -EINVAL) { 794 tuner_dbg("Tuner doesn't support mode %d. " 795 "Putting tuner to sleep\n", mode); 796 t->standby = true; 797 if (analog_ops->standby) 798 analog_ops->standby(&t->fe); 799 return -EINVAL; 800 } 801 t->mode = mode; 802 tuner_dbg("Changing to mode %d\n", mode); 803 } 804 return 0; 805} 806 807/** 808 * set_freq - Set the tuner to the desired frequency. 809 * @t: a pointer to the module's internal struct_tuner 810 * @freq: frequency to set (0 means to use the current frequency) 811 */ 812static void set_freq(struct tuner *t, unsigned int freq) 813{ 814 struct i2c_client *client = v4l2_get_subdevdata(&t->sd); 815 816 if (t->mode == V4L2_TUNER_RADIO) { 817 if (!freq) 818 freq = t->radio_freq; 819 set_radio_freq(client, freq); 820 } else { 821 if (!freq) 822 freq = t->tv_freq; 823 set_tv_freq(client, freq); 824 } 825} 826 827/* 828 * Functions that are specific for TV mode 829 */ 830 831/** 832 * set_tv_freq - Set tuner frequency, freq in Units of 62.5 kHz = 1/16MHz 833 * 834 * @c: i2c_client descriptor 835 * @freq: frequency 836 */ 837static void set_tv_freq(struct i2c_client *c, unsigned int freq) 838{ 839 struct tuner *t = to_tuner(i2c_get_clientdata(c)); 840 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops; 841 842 struct analog_parameters params = { 843 .mode = t->mode, 844 .audmode = t->audmode, 845 .std = t->std 846 }; 847 848 if (t->type == UNSET) { 849 tuner_warn("tuner type not set\n"); 850 return; 851 } 852 if (NULL == analog_ops->set_params) { 853 tuner_warn("Tuner has no way to set tv freq\n"); 854 return; 855 } 856 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) { 857 tuner_dbg("TV freq (%d.%02d) out of range (%d-%d)\n", 858 freq / 16, freq % 16 * 100 / 16, tv_range[0], 859 tv_range[1]); 860 /* V4L2 spec: if the freq is not possible then the closest 861 possible value should be selected */ 862 if (freq < tv_range[0] * 16) 863 freq = tv_range[0] * 16; 864 else 865 freq = tv_range[1] * 16; 866 } 867 params.frequency = freq; 868 tuner_dbg("tv freq set to %d.%02d\n", 869 freq / 16, freq % 16 * 100 / 16); 870 t->tv_freq = freq; 871 t->standby = false; 872 873 analog_ops->set_params(&t->fe, ¶ms); 874} 875 876/** 877 * tuner_fixup_std - force a given video standard variant 878 * 879 * @t: tuner internal struct 880 * @std: TV standard 881 * 882 * A few devices or drivers have problem to detect some standard variations. 883 * On other operational systems, the drivers generally have a per-country 884 * code, and some logic to apply per-country hacks. V4L2 API doesn't provide 885 * such hacks. Instead, it relies on a proper video standard selection from 886 * the userspace application. However, as some apps are buggy, not allowing 887 * to distinguish all video standard variations, a modprobe parameter can 888 * be used to force a video standard match. 889 */ 890static v4l2_std_id tuner_fixup_std(struct tuner *t, v4l2_std_id std) 891{ 892 if (pal[0] != '-' && (std & V4L2_STD_PAL) == V4L2_STD_PAL) { 893 switch (pal[0]) { 894 case '6': 895 return V4L2_STD_PAL_60; 896 case 'b': 897 case 'B': 898 case 'g': 899 case 'G': 900 return V4L2_STD_PAL_BG; 901 case 'i': 902 case 'I': 903 return V4L2_STD_PAL_I; 904 case 'd': 905 case 'D': 906 case 'k': 907 case 'K': 908 return V4L2_STD_PAL_DK; 909 case 'M': 910 case 'm': 911 return V4L2_STD_PAL_M; 912 case 'N': 913 case 'n': 914 if (pal[1] == 'c' || pal[1] == 'C') 915 return V4L2_STD_PAL_Nc; 916 return V4L2_STD_PAL_N; 917 default: 918 tuner_warn("pal= argument not recognised\n"); 919 break; 920 } 921 } 922 if (secam[0] != '-' && (std & V4L2_STD_SECAM) == V4L2_STD_SECAM) { 923 switch (secam[0]) { 924 case 'b': 925 case 'B': 926 case 'g': 927 case 'G': 928 case 'h': 929 case 'H': 930 return V4L2_STD_SECAM_B | 931 V4L2_STD_SECAM_G | 932 V4L2_STD_SECAM_H; 933 case 'd': 934 case 'D': 935 case 'k': 936 case 'K': 937 return V4L2_STD_SECAM_DK; 938 case 'l': 939 case 'L': 940 if ((secam[1] == 'C') || (secam[1] == 'c')) 941 return V4L2_STD_SECAM_LC; 942 return V4L2_STD_SECAM_L; 943 default: 944 tuner_warn("secam= argument not recognised\n"); 945 break; 946 } 947 } 948 949 if (ntsc[0] != '-' && (std & V4L2_STD_NTSC) == V4L2_STD_NTSC) { 950 switch (ntsc[0]) { 951 case 'm': 952 case 'M': 953 return V4L2_STD_NTSC_M; 954 case 'j': 955 case 'J': 956 return V4L2_STD_NTSC_M_JP; 957 case 'k': 958 case 'K': 959 return V4L2_STD_NTSC_M_KR; 960 default: 961 tuner_info("ntsc= argument not recognised\n"); 962 break; 963 } 964 } 965 return std; 966} 967 968/* 969 * Functions that are specific for Radio mode 970 */ 971 972/** 973 * set_radio_freq - Set tuner frequency, freq in Units of 62.5 Hz = 1/16kHz 974 * 975 * @c: i2c_client descriptor 976 * @freq: frequency 977 */ 978static void set_radio_freq(struct i2c_client *c, unsigned int freq) 979{ 980 struct tuner *t = to_tuner(i2c_get_clientdata(c)); 981 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops; 982 983 struct analog_parameters params = { 984 .mode = t->mode, 985 .audmode = t->audmode, 986 .std = t->std 987 }; 988 989 if (t->type == UNSET) { 990 tuner_warn("tuner type not set\n"); 991 return; 992 } 993 if (NULL == analog_ops->set_params) { 994 tuner_warn("tuner has no way to set radio frequency\n"); 995 return; 996 } 997 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) { 998 tuner_dbg("radio freq (%d.%02d) out of range (%d-%d)\n", 999 freq / 16000, freq % 16000 * 100 / 16000, 1000 radio_range[0], radio_range[1]); 1001 /* V4L2 spec: if the freq is not possible then the closest 1002 possible value should be selected */ 1003 if (freq < radio_range[0] * 16000) 1004 freq = radio_range[0] * 16000; 1005 else 1006 freq = radio_range[1] * 16000; 1007 } 1008 params.frequency = freq; 1009 tuner_dbg("radio freq set to %d.%02d\n", 1010 freq / 16000, freq % 16000 * 100 / 16000); 1011 t->radio_freq = freq; 1012 t->standby = false; 1013 1014 analog_ops->set_params(&t->fe, ¶ms); 1015 /* 1016 * The tuner driver might decide to change the audmode if it only 1017 * supports stereo, so update t->audmode. 1018 */ 1019 t->audmode = params.audmode; 1020} 1021 1022/* 1023 * Debug function for reporting tuner status to userspace 1024 */ 1025 1026/** 1027 * tuner_status - Dumps the current tuner status at dmesg 1028 * @fe: pointer to struct dvb_frontend 1029 * 1030 * This callback is used only for driver debug purposes, answering to 1031 * VIDIOC_LOG_STATUS. No changes should happen on this call. 1032 */ 1033static void tuner_status(struct dvb_frontend *fe) 1034{ 1035 struct tuner *t = fe->analog_demod_priv; 1036 unsigned long freq, freq_fraction; 1037 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops; 1038 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops; 1039 const char *p; 1040 1041 switch (t->mode) { 1042 case V4L2_TUNER_RADIO: 1043 p = "radio"; 1044 break; 1045 case V4L2_TUNER_DIGITAL_TV: /* Used by mt20xx */ 1046 p = "digital TV"; 1047 break; 1048 case V4L2_TUNER_ANALOG_TV: 1049 default: 1050 p = "analog TV"; 1051 break; 1052 } 1053 if (t->mode == V4L2_TUNER_RADIO) { 1054 freq = t->radio_freq / 16000; 1055 freq_fraction = (t->radio_freq % 16000) * 100 / 16000; 1056 } else { 1057 freq = t->tv_freq / 16; 1058 freq_fraction = (t->tv_freq % 16) * 100 / 16; 1059 } 1060 tuner_info("Tuner mode: %s%s\n", p, 1061 t->standby ? " on standby mode" : ""); 1062 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction); 1063 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std); 1064 if (t->mode != V4L2_TUNER_RADIO) 1065 return; 1066 if (fe_tuner_ops->get_status) { 1067 u32 tuner_status; 1068 1069 fe_tuner_ops->get_status(&t->fe, &tuner_status); 1070 if (tuner_status & TUNER_STATUS_LOCKED) 1071 tuner_info("Tuner is locked.\n"); 1072 if (tuner_status & TUNER_STATUS_STEREO) 1073 tuner_info("Stereo: yes\n"); 1074 } 1075 if (analog_ops->has_signal) { 1076 u16 signal; 1077 1078 if (!analog_ops->has_signal(fe, &signal)) 1079 tuner_info("Signal strength: %hu\n", signal); 1080 } 1081} 1082 1083/* 1084 * Function to splicitly change mode to radio. Probably not needed anymore 1085 */ 1086 1087static int tuner_s_radio(struct v4l2_subdev *sd) 1088{ 1089 struct tuner *t = to_tuner(sd); 1090 1091 if (set_mode(t, V4L2_TUNER_RADIO) == 0) 1092 set_freq(t, 0); 1093 return 0; 1094} 1095 1096/* 1097 * Tuner callbacks to handle userspace ioctl's 1098 */ 1099 1100/** 1101 * tuner_s_power - controls the power state of the tuner 1102 * @sd: pointer to struct v4l2_subdev 1103 * @on: a zero value puts the tuner to sleep, non-zero wakes it up 1104 */ 1105static int tuner_s_power(struct v4l2_subdev *sd, int on) 1106{ 1107 struct tuner *t = to_tuner(sd); 1108 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops; 1109 1110 if (on) { 1111 if (t->standby && set_mode(t, t->mode) == 0) { 1112 tuner_dbg("Waking up tuner\n"); 1113 set_freq(t, 0); 1114 } 1115 return 0; 1116 } 1117 1118 tuner_dbg("Putting tuner to sleep\n"); 1119 t->standby = true; 1120 if (analog_ops->standby) 1121 analog_ops->standby(&t->fe); 1122 return 0; 1123} 1124 1125static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std) 1126{ 1127 struct tuner *t = to_tuner(sd); 1128 1129 if (set_mode(t, V4L2_TUNER_ANALOG_TV)) 1130 return 0; 1131 1132 t->std = tuner_fixup_std(t, std); 1133 if (t->std != std) 1134 tuner_dbg("Fixup standard %llx to %llx\n", std, t->std); 1135 set_freq(t, 0); 1136 return 0; 1137} 1138 1139static int tuner_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f) 1140{ 1141 struct tuner *t = to_tuner(sd); 1142 1143 if (set_mode(t, f->type) == 0) 1144 set_freq(t, f->frequency); 1145 return 0; 1146} 1147 1148/** 1149 * tuner_g_frequency - Get the tuned frequency for the tuner 1150 * @sd: pointer to struct v4l2_subdev 1151 * @f: pointer to struct v4l2_frequency 1152 * 1153 * At return, the structure f will be filled with tuner frequency 1154 * if the tuner matches the f->type. 1155 * Note: f->type should be initialized before calling it. 1156 * This is done by either video_ioctl2 or by the bridge driver. 1157 */ 1158static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f) 1159{ 1160 struct tuner *t = to_tuner(sd); 1161 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops; 1162 1163 if (check_mode(t, f->type) == -EINVAL) 1164 return 0; 1165 if (f->type == t->mode && fe_tuner_ops->get_frequency && !t->standby) { 1166 u32 abs_freq; 1167 1168 fe_tuner_ops->get_frequency(&t->fe, &abs_freq); 1169 f->frequency = (V4L2_TUNER_RADIO == t->mode) ? 1170 DIV_ROUND_CLOSEST(abs_freq * 2, 125) : 1171 DIV_ROUND_CLOSEST(abs_freq, 62500); 1172 } else { 1173 f->frequency = (V4L2_TUNER_RADIO == f->type) ? 1174 t->radio_freq : t->tv_freq; 1175 } 1176 return 0; 1177} 1178 1179/** 1180 * tuner_g_tuner - Fill in tuner information 1181 * @sd: pointer to struct v4l2_subdev 1182 * @vt: pointer to struct v4l2_tuner 1183 * 1184 * At return, the structure vt will be filled with tuner information 1185 * if the tuner matches vt->type. 1186 * Note: vt->type should be initialized before calling it. 1187 * This is done by either video_ioctl2 or by the bridge driver. 1188 */ 1189static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt) 1190{ 1191 struct tuner *t = to_tuner(sd); 1192 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops; 1193 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops; 1194 1195 if (check_mode(t, vt->type) == -EINVAL) 1196 return 0; 1197 if (vt->type == t->mode && analog_ops->get_afc) 1198 analog_ops->get_afc(&t->fe, &vt->afc); 1199 if (vt->type == t->mode && analog_ops->has_signal) { 1200 u16 signal = (u16)vt->signal; 1201 1202 if (!analog_ops->has_signal(&t->fe, &signal)) 1203 vt->signal = signal; 1204 } 1205 if (vt->type != V4L2_TUNER_RADIO) { 1206 vt->capability |= V4L2_TUNER_CAP_NORM; 1207 vt->rangelow = tv_range[0] * 16; 1208 vt->rangehigh = tv_range[1] * 16; 1209 return 0; 1210 } 1211 1212 /* radio mode */ 1213 if (vt->type == t->mode) { 1214 vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO; 1215 if (fe_tuner_ops->get_status) { 1216 u32 tuner_status; 1217 1218 fe_tuner_ops->get_status(&t->fe, &tuner_status); 1219 vt->rxsubchans = 1220 (tuner_status & TUNER_STATUS_STEREO) ? 1221 V4L2_TUNER_SUB_STEREO : 1222 V4L2_TUNER_SUB_MONO; 1223 } 1224 vt->audmode = t->audmode; 1225 } 1226 vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO; 1227 vt->rangelow = radio_range[0] * 16000; 1228 vt->rangehigh = radio_range[1] * 16000; 1229 1230 return 0; 1231} 1232 1233/** 1234 * tuner_s_tuner - Set the tuner's audio mode 1235 * @sd: pointer to struct v4l2_subdev 1236 * @vt: pointer to struct v4l2_tuner 1237 * 1238 * Sets the audio mode if the tuner matches vt->type. 1239 * Note: vt->type should be initialized before calling it. 1240 * This is done by either video_ioctl2 or by the bridge driver. 1241 */ 1242static int tuner_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt) 1243{ 1244 struct tuner *t = to_tuner(sd); 1245 1246 if (set_mode(t, vt->type)) 1247 return 0; 1248 1249 if (t->mode == V4L2_TUNER_RADIO) { 1250 t->audmode = vt->audmode; 1251 /* 1252 * For radio audmode can only be mono or stereo. Map any 1253 * other values to stereo. The actual tuner driver that is 1254 * called in set_radio_freq can decide to limit the audmode to 1255 * mono if only mono is supported. 1256 */ 1257 if (t->audmode != V4L2_TUNER_MODE_MONO && 1258 t->audmode != V4L2_TUNER_MODE_STEREO) 1259 t->audmode = V4L2_TUNER_MODE_STEREO; 1260 } 1261 set_freq(t, 0); 1262 1263 return 0; 1264} 1265 1266static int tuner_log_status(struct v4l2_subdev *sd) 1267{ 1268 struct tuner *t = to_tuner(sd); 1269 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops; 1270 1271 if (analog_ops->tuner_status) 1272 analog_ops->tuner_status(&t->fe); 1273 return 0; 1274} 1275 1276#ifdef CONFIG_PM_SLEEP 1277static int tuner_suspend(struct device *dev) 1278{ 1279 struct i2c_client *c = to_i2c_client(dev); 1280 struct tuner *t = to_tuner(i2c_get_clientdata(c)); 1281 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops; 1282 1283 tuner_dbg("suspend\n"); 1284 1285 if (t->fe.ops.tuner_ops.suspend) 1286 t->fe.ops.tuner_ops.suspend(&t->fe); 1287 else if (!t->standby && analog_ops->standby) 1288 analog_ops->standby(&t->fe); 1289 1290 return 0; 1291} 1292 1293static int tuner_resume(struct device *dev) 1294{ 1295 struct i2c_client *c = to_i2c_client(dev); 1296 struct tuner *t = to_tuner(i2c_get_clientdata(c)); 1297 1298 tuner_dbg("resume\n"); 1299 1300 if (t->fe.ops.tuner_ops.resume) 1301 t->fe.ops.tuner_ops.resume(&t->fe); 1302 else if (!t->standby) 1303 if (set_mode(t, t->mode) == 0) 1304 set_freq(t, 0); 1305 1306 return 0; 1307} 1308#endif 1309 1310static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg) 1311{ 1312 struct v4l2_subdev *sd = i2c_get_clientdata(client); 1313 1314 /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have 1315 to handle it here. 1316 There must be a better way of doing this... */ 1317 switch (cmd) { 1318 case TUNER_SET_CONFIG: 1319 return tuner_s_config(sd, arg); 1320 } 1321 return -ENOIOCTLCMD; 1322} 1323 1324/* 1325 * Callback structs 1326 */ 1327 1328static const struct v4l2_subdev_core_ops tuner_core_ops = { 1329 .log_status = tuner_log_status, 1330 .s_power = tuner_s_power, 1331}; 1332 1333static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = { 1334 .s_radio = tuner_s_radio, 1335 .g_tuner = tuner_g_tuner, 1336 .s_tuner = tuner_s_tuner, 1337 .s_frequency = tuner_s_frequency, 1338 .g_frequency = tuner_g_frequency, 1339 .s_type_addr = tuner_s_type_addr, 1340 .s_config = tuner_s_config, 1341}; 1342 1343static const struct v4l2_subdev_video_ops tuner_video_ops = { 1344 .s_std = tuner_s_std, 1345}; 1346 1347static const struct v4l2_subdev_ops tuner_ops = { 1348 .core = &tuner_core_ops, 1349 .tuner = &tuner_tuner_ops, 1350 .video = &tuner_video_ops, 1351}; 1352 1353/* 1354 * I2C structs and module init functions 1355 */ 1356 1357static const struct dev_pm_ops tuner_pm_ops = { 1358 SET_SYSTEM_SLEEP_PM_OPS(tuner_suspend, tuner_resume) 1359}; 1360 1361static const struct i2c_device_id tuner_id[] = { 1362 { "tuner", }, /* autodetect */ 1363 { } 1364}; 1365MODULE_DEVICE_TABLE(i2c, tuner_id); 1366 1367static struct i2c_driver tuner_driver = { 1368 .driver = { 1369 .owner = THIS_MODULE, 1370 .name = "tuner", 1371 .pm = &tuner_pm_ops, 1372 }, 1373 .probe = tuner_probe, 1374 .remove = tuner_remove, 1375 .command = tuner_command, 1376 .id_table = tuner_id, 1377}; 1378 1379module_i2c_driver(tuner_driver); 1380 1381MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners"); 1382MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer"); 1383MODULE_LICENSE("GPL"); 1384