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