root/drivers/media/v4l2-core/tuner-core.c

DEFINITIONS

1. tuner_detach
2. tuner_detach
3. to_tuner
4. fe_set_params
5. fe_standby
6. fe_set_config
7. set_type
8. tuner_s_type_addr
9. tuner_s_config
10. tuner_lookup
11. tuner_probe
12. tuner_remove
13. check_mode
14. set_mode
15. set_freq
16. set_tv_freq
17. tuner_fixup_std
18. set_radio_freq
19. tuner_status
20. tuner_s_radio
21. tuner_standby
22. tuner_s_std
23. tuner_s_frequency
24. tuner_g_frequency
25. tuner_g_tuner
26. tuner_s_tuner
27. tuner_log_status
28. tuner_suspend
29. tuner_resume
30. tuner_command

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * i2c tv tuner chip device driver
   4  * core core, i.e. kernel interfaces, registering and so on
   5  *
   6  * Copyright(c) by Ralph Metzler, Gerd Knorr, Gunther Mayer
   7  *
   8  * Copyright(c) 2005-2011 by Mauro Carvalho Chehab
   9  *      - Added support for a separate Radio tuner
  10  *      - Major rework and cleanups at the code
  11  *
  12  * This driver supports many devices and the idea is to let the driver
  13  * detect which device is present. So rather than listing all supported
  14  * devices here, we pretend to support a single, fake device type that will
  15  * 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 "tuner-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 parameters
  49  */
  50 
  51 /* insmod options used at init time => read/only */
  52 static unsigned int addr;
  53 static unsigned int no_autodetect;
  54 static unsigned int show_i2c;
  55 
  56 module_param(addr, int, 0444);
  57 module_param(no_autodetect, int, 0444);
  58 module_param(show_i2c, int, 0444);
  59 
  60 /* insmod options used at runtime => read/write */
  61 static int tuner_debug;
  62 static unsigned int tv_range[2] = { 44, 958 };
  63 static unsigned int radio_range[2] = { 65, 108 };
  64 static char pal[] = "--";
  65 static char secam[] = "--";
  66 static char ntsc[] = "-";
  67 
  68 module_param_named(debug, tuner_debug, int, 0644);
  69 module_param_array(tv_range, int, NULL, 0644);
  70 module_param_array(radio_range, int, NULL, 0644);
  71 module_param_string(pal, pal, sizeof(pal), 0644);
  72 module_param_string(secam, secam, sizeof(secam), 0644);
  73 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
  74 
  75 /*
  76  * Static vars
  77  */
  78 
  79 static LIST_HEAD(tuner_list);
  80 static const struct v4l2_subdev_ops tuner_ops;
  81 
  82 /*
  83  * Debug macros
  84  */
  85 
  86 #undef pr_fmt
  87 
  88 #define pr_fmt(fmt) KBUILD_MODNAME ": %d-%04x: " fmt,           \
  89         i2c_adapter_id(t->i2c->adapter), t->i2c->addr
  90 
  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 driver
  99  */
 100 
 101 /**
 102  * enum tuner_pad_index - tuner pad index for MEDIA_ENT_F_TUNER
 103  *
 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 chrominance
 108  *      and luminance or the hole bandwidth of the signal converted to
 109  *      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 TV
 112  *      signals have an extra pad for audio output. Old tuners use an
 113  *      analog stage with a saw filter for the audio IF frequency. The
 114  *      output of the pad is, in this case, the audio IF, with should be
 115  *      decoded either by the bridge chipset (that's the case of cx2388x
 116  *      chipsets) or may require an external IF sound processor, like
 117  *      msp34xx. On modern silicon tuners, the audio IF decoder is usually
 118  *      incorporated at the tuner. On such case, the output of this pad
 119  *      is an audio sampled data.
 120  * @TUNER_NUM_PADS:
 121  *      Number of pads of the tuner.
 122  */
 123 enum tuner_pad_index {
 124         TUNER_PAD_RF_INPUT,
 125         TUNER_PAD_OUTPUT,
 126         TUNER_PAD_AUD_OUT,
 127         TUNER_NUM_PADS
 128 };
 129 
 130 /**
 131  * enum if_vid_dec_pad_index - video IF-PLL pad index
 132  *      for MEDIA_ENT_F_IF_VID_DECODER
 133  *
 134  * @IF_VID_DEC_PAD_IF_INPUT:
 135  *      video Intermediate Frequency (IF) sink pad
 136  * @IF_VID_DEC_PAD_OUT:
 137  *      IF-PLL video output source pad. Contains the video chrominance
 138  *      and luminance IF signals.
 139  * @IF_VID_DEC_PAD_NUM_PADS:
 140  *      Number of pads of the video IF-PLL.
 141  */
 142 enum if_vid_dec_pad_index {
 143         IF_VID_DEC_PAD_IF_INPUT,
 144         IF_VID_DEC_PAD_OUT,
 145         IF_VID_DEC_PAD_NUM_PADS
 146 };
 147 
 148 struct 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 #endif
 173 };
 174 
 175 /*
 176  * Function prototypes
 177  */
 178 
 179 static void set_tv_freq(struct i2c_client *c, unsigned int freq);
 180 static void set_radio_freq(struct i2c_client *c, unsigned int freq);
 181 
 182 /*
 183  * tuner attach/detach logic
 184  */
 185 
 186 /* This macro allows us to probe dynamically, avoiding static links */
 187 #ifdef CONFIG_MEDIA_ATTACH
 188 #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 
 201 static 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 #else
 213 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
 214         FUNCTION(ARGS); \
 215 })
 216 
 217 static 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 #endif
 225 
 226 
 227 static 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 callbacks
 234  */
 235 
 236 static 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 
 249 static 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 
 257 static 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 
 270 static void tuner_status(struct dvb_frontend *fe);
 271 
 272 static 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_status
 277 };
 278 
 279 /*
 280  * Functions to select between radio and TV and tuner probe/remove functions
 281  */
 282 
 283 /**
 284  * set_type - Sets the tuner type for a given device
 285  *
 286  * @c:                  i2c_client descriptor
 287  * @type:               type of the tuner (e. g. tuner number)
 288  * @new_mode_mask:      Indicates if tuner supports TV and/or Radio
 289  * @new_config:         an optional parameter used by a few tuners to adjust
 290  *                      internal parameters, like LNA mode
 291  * @tuner_callback:     an optional function to be called when switching
 292  *                      to analog mode
 293  *
 294  * This function applies the tuner config to tuner specified
 295  * by tun_setup structure. It contains several per-tuner initialization "magic"
 296  */
 297 static 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           = 0
 440                 };
 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_CONTROLLER
 474         t->sd.entity.name = t->name;
 475 #endif
 476 
 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 fail
 484            FIXME: better to move set_freq to the tuner code. This is needed
 485            on analog tuners for PLL to properly work
 486          */
 487         if (tune_now) {
 488                 if (V4L2_TUNER_RADIO == t->mode)
 489                         set_radio_freq(c, t->radio_freq);
 490                 else
 491                         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 
 499 attach_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 device
 508  *
 509  * @sd:         subdev descriptor
 510  * @tun_setup:  type to be associated to a given tuner i2c address
 511  *
 512  * This function applies the tuner config to tuner specified
 513  * by tun_setup structure.
 514  * If tuner I2C address is UNSET, then it will only set the device
 515  * if the tuner supports the mode specified in the call.
 516  * If the address is specified, the change will be applied only if
 517  * tuner I2C address matches.
 518  * The call can change the tuner number and the tuner mode.
 519  */
 520 static 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         } else
 538                 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 configuration
 547  *
 548  * @sd:         subdev descriptor
 549  * @cfg:        tuner configuration
 550  *
 551  * Calls tuner set_config() private function to set some tuner-internal
 552  * parameters
 553  */
 554 static 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 adapters
 574  *
 575  * @adap:       i2c_adapter struct
 576  * @radio:      pointer to be filled if the adapter is radio
 577  * @tv:         pointer to be filled if the adapter is TV
 578  *
 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 be
 583  * certain no other devices will be added/deleted at the same time, I2C
 584  * core protects against that.
 585  */
 586 static 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-only
 605                    device. If other devices appear then we need to
 606                    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 bus
 615  *
 616  * @client:     i2c_client descriptor
 617  * @id:         not used
 618  *
 619  * This routine probes for tuners at the expected I2C addresses. On most
 620  * cases, if a device answers to a given I2C address, it assumes that the
 621  * device is a tuner. On a few cases, however, an additional logic is needed
 622  * to double check if the device is really a tuner, or to identify the tuner
 623  * type, like on tea5767/5761 devices.
 624  *
 625  * During client attach, set_type is called by adapter's attach_inform callback.
 626  * set_type must then be completed by tuner_probe.
 627  */
 628 static int tuner_probe(struct i2c_client *client,
 629                        const struct i2c_device_id *id)
 630 {
 631         struct tuner *t;
 632         struct tuner *radio;
 633         struct tuner *tv;
 634 #ifdef CONFIG_MEDIA_CONTROLLER
 635         int ret;
 636 #endif
 637 
 638         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
 639         if (NULL == t)
 640                 return -ENOMEM;
 641         v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
 642         t->i2c = client;
 643         t->name = "(tuner unset)";
 644         t->type = UNSET;
 645         t->audmode = V4L2_TUNER_MODE_STEREO;
 646         t->standby = true;
 647         t->radio_freq = 87.5 * 16000;   /* Initial freq range */
 648         t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
 649 
 650         if (show_i2c) {
 651                 unsigned char buffer[16];
 652                 int rc;
 653 
 654                 memset(buffer, 0, sizeof(buffer));
 655                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
 656                 if (rc >= 0)
 657                         pr_info("I2C RECV = %*ph\n", rc, buffer);
 658         }
 659 
 660         /* autodetection code based on the i2c addr */
 661         if (!no_autodetect) {
 662                 switch (client->addr) {
 663                 case 0x10:
 664                         if (tuner_symbol_probe(tea5761_autodetection,
 665                                                t->i2c->adapter,
 666                                                t->i2c->addr) >= 0) {
 667                                 t->type = TUNER_TEA5761;
 668                                 t->mode_mask = T_RADIO;
 669                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
 670                                 if (tv)
 671                                         tv->mode_mask &= ~T_RADIO;
 672 
 673                                 goto register_client;
 674                         }
 675                         kfree(t);
 676                         return -ENODEV;
 677                 case 0x42:
 678                 case 0x43:
 679                 case 0x4a:
 680                 case 0x4b:
 681                         /* If chip is not tda8290, don't register.
 682                            since it can be tda9887*/
 683                         if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
 684                                                t->i2c->addr) >= 0) {
 685                                 dprintk("tda829x detected\n");
 686                         } else {
 687                                 /* Default is being tda9887 */
 688                                 t->type = TUNER_TDA9887;
 689                                 t->mode_mask = T_RADIO | T_ANALOG_TV;
 690                                 goto register_client;
 691                         }
 692                         break;
 693                 case 0x60:
 694                         if (tuner_symbol_probe(tea5767_autodetection,
 695                                                t->i2c->adapter, t->i2c->addr)
 696                                         >= 0) {
 697                                 t->type = TUNER_TEA5767;
 698                                 t->mode_mask = T_RADIO;
 699                                 /* Sets freq to FM range */
 700                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
 701                                 if (tv)
 702                                         tv->mode_mask &= ~T_RADIO;
 703 
 704                                 goto register_client;
 705                         }
 706                         break;
 707                 }
 708         }
 709 
 710         /* Initializes only the first TV tuner on this adapter. Why only the
 711            first? Because there are some devices (notably the ones with TI
 712            tuners) that have more than one i2c address for the *same* device.
 713            Experience shows that, except for just one case, the first
 714            address is the right one. The exception is a Russian tuner
 715            (ACORP_Y878F). So, the desired behavior is just to enable the
 716            first found TV tuner. */
 717         tuner_lookup(t->i2c->adapter, &radio, &tv);
 718         if (tv == NULL) {
 719                 t->mode_mask = T_ANALOG_TV;
 720                 if (radio == NULL)
 721                         t->mode_mask |= T_RADIO;
 722                 dprintk("Setting mode_mask to 0x%02x\n", t->mode_mask);
 723         }
 724 
 725         /* Should be just before return */
 726 register_client:
 727 #if defined(CONFIG_MEDIA_CONTROLLER)
 728         t->sd.entity.name = t->name;
 729         /*
 730          * Handle the special case where the tuner has actually
 731          * two stages: the PLL to tune into a frequency and the
 732          * IF-PLL demodulator (tda988x).
 733          */
 734         if (t->type == TUNER_TDA9887) {
 735                 t->pad[IF_VID_DEC_PAD_IF_INPUT].flags = MEDIA_PAD_FL_SINK;
 736                 t->pad[IF_VID_DEC_PAD_IF_INPUT].sig_type = PAD_SIGNAL_ANALOG;
 737                 t->pad[IF_VID_DEC_PAD_OUT].flags = MEDIA_PAD_FL_SOURCE;
 738                 t->pad[IF_VID_DEC_PAD_OUT].sig_type = PAD_SIGNAL_ANALOG;
 739                 ret = media_entity_pads_init(&t->sd.entity,
 740                                              IF_VID_DEC_PAD_NUM_PADS,
 741                                              &t->pad[0]);
 742                 t->sd.entity.function = MEDIA_ENT_F_IF_VID_DECODER;
 743         } else {
 744                 t->pad[TUNER_PAD_RF_INPUT].flags = MEDIA_PAD_FL_SINK;
 745                 t->pad[TUNER_PAD_RF_INPUT].sig_type = PAD_SIGNAL_ANALOG;
 746                 t->pad[TUNER_PAD_OUTPUT].flags = MEDIA_PAD_FL_SOURCE;
 747                 t->pad[TUNER_PAD_OUTPUT].sig_type = PAD_SIGNAL_ANALOG;
 748                 t->pad[TUNER_PAD_AUD_OUT].flags = MEDIA_PAD_FL_SOURCE;
 749                 t->pad[TUNER_PAD_AUD_OUT].sig_type = PAD_SIGNAL_AUDIO;
 750                 ret = media_entity_pads_init(&t->sd.entity, TUNER_NUM_PADS,
 751                                              &t->pad[0]);
 752                 t->sd.entity.function = MEDIA_ENT_F_TUNER;
 753         }
 754 
 755         if (ret < 0) {
 756                 pr_err("failed to initialize media entity!\n");
 757                 kfree(t);
 758                 return ret;
 759         }
 760 #endif
 761         /* Sets a default mode */
 762         if (t->mode_mask & T_ANALOG_TV)
 763                 t->mode = V4L2_TUNER_ANALOG_TV;
 764         else
 765                 t->mode = V4L2_TUNER_RADIO;
 766         set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
 767         list_add_tail(&t->list, &tuner_list);
 768 
 769         pr_info("Tuner %d found with type(s)%s%s.\n",
 770                    t->type,
 771                    t->mode_mask & T_RADIO ? " Radio" : "",
 772                    t->mode_mask & T_ANALOG_TV ? " TV" : "");
 773         return 0;
 774 }
 775 
 776 /**
 777  * tuner_remove - detaches a tuner
 778  *
 779  * @client:     i2c_client descriptor
 780  */
 781 
 782 static int tuner_remove(struct i2c_client *client)
 783 {
 784         struct tuner *t = to_tuner(i2c_get_clientdata(client));
 785 
 786         v4l2_device_unregister_subdev(&t->sd);
 787         tuner_detach(&t->fe);
 788         t->fe.analog_demod_priv = NULL;
 789 
 790         list_del(&t->list);
 791         kfree(t);
 792         return 0;
 793 }
 794 
 795 /*
 796  * Functions to switch between Radio and TV
 797  *
 798  * A few cards have a separate I2C tuner for radio. Those routines
 799  * take care of switching between TV/Radio mode, filtering only the
 800  * commands that apply to the Radio or TV tuner.
 801  */
 802 
 803 /**
 804  * check_mode - Verify if tuner supports the requested mode
 805  * @t: a pointer to the module's internal struct_tuner
 806  * @mode: mode of the tuner, as defined by &enum v4l2_tuner_type.
 807  *
 808  * This function checks if the tuner is capable of tuning analog TV,
 809  * digital TV or radio, depending on what the caller wants. If the
 810  * tuner can't support that mode, it returns -EINVAL. Otherwise, it
 811  * returns 0.
 812  * This function is needed for boards that have a separate tuner for
 813  * radio (like devices with tea5767).
 814  *
 815  * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to
 816  *       select a TV frequency. So, t_mode = T_ANALOG_TV could actually
 817  *       be used to represent a Digital TV too.
 818  */
 819 static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
 820 {
 821         int t_mode;
 822         if (mode == V4L2_TUNER_RADIO)
 823                 t_mode = T_RADIO;
 824         else
 825                 t_mode = T_ANALOG_TV;
 826 
 827         if ((t_mode & t->mode_mask) == 0)
 828                 return -EINVAL;
 829 
 830         return 0;
 831 }
 832 
 833 /**
 834  * set_mode - Switch tuner to other mode.
 835  * @t:          a pointer to the module's internal struct_tuner
 836  * @mode:       enum v4l2_type (radio or TV)
 837  *
 838  * If tuner doesn't support the needed mode (radio or TV), prints a
 839  * debug message and returns -EINVAL, changing its state to standby.
 840  * Otherwise, changes the mode and returns 0.
 841  */
 842 static int set_mode(struct tuner *t, enum v4l2_tuner_type mode)
 843 {
 844         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 845 
 846         if (mode != t->mode) {
 847                 if (check_mode(t, mode) == -EINVAL) {
 848                         dprintk("Tuner doesn't support mode %d. Putting tuner to sleep\n",
 849                                   mode);
 850                         t->standby = true;
 851                         if (analog_ops->standby)
 852                                 analog_ops->standby(&t->fe);
 853                         return -EINVAL;
 854                 }
 855                 t->mode = mode;
 856                 dprintk("Changing to mode %d\n", mode);
 857         }
 858         return 0;
 859 }
 860 
 861 /**
 862  * set_freq - Set the tuner to the desired frequency.
 863  * @t:          a pointer to the module's internal struct_tuner
 864  * @freq:       frequency to set (0 means to use the current frequency)
 865  */
 866 static void set_freq(struct tuner *t, unsigned int freq)
 867 {
 868         struct i2c_client *client = v4l2_get_subdevdata(&t->sd);
 869 
 870         if (t->mode == V4L2_TUNER_RADIO) {
 871                 if (!freq)
 872                         freq = t->radio_freq;
 873                 set_radio_freq(client, freq);
 874         } else {
 875                 if (!freq)
 876                         freq = t->tv_freq;
 877                 set_tv_freq(client, freq);
 878         }
 879 }
 880 
 881 /*
 882  * Functions that are specific for TV mode
 883  */
 884 
 885 /**
 886  * set_tv_freq - Set tuner frequency,  freq in Units of 62.5 kHz = 1/16MHz
 887  *
 888  * @c:  i2c_client descriptor
 889  * @freq: frequency
 890  */
 891 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
 892 {
 893         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 894         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 895 
 896         struct analog_parameters params = {
 897                 .mode      = t->mode,
 898                 .audmode   = t->audmode,
 899                 .std       = t->std
 900         };
 901 
 902         if (t->type == UNSET) {
 903                 pr_warn("tuner type not set\n");
 904                 return;
 905         }
 906         if (NULL == analog_ops->set_params) {
 907                 pr_warn("Tuner has no way to set tv freq\n");
 908                 return;
 909         }
 910         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
 911                 dprintk("TV freq (%d.%02d) out of range (%d-%d)\n",
 912                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
 913                            tv_range[1]);
 914                 /* V4L2 spec: if the freq is not possible then the closest
 915                    possible value should be selected */
 916                 if (freq < tv_range[0] * 16)
 917                         freq = tv_range[0] * 16;
 918                 else
 919                         freq = tv_range[1] * 16;
 920         }
 921         params.frequency = freq;
 922         dprintk("tv freq set to %d.%02d\n",
 923                         freq / 16, freq % 16 * 100 / 16);
 924         t->tv_freq = freq;
 925         t->standby = false;
 926 
 927         analog_ops->set_params(&t->fe, &params);
 928 }
 929 
 930 /**
 931  * tuner_fixup_std - force a given video standard variant
 932  *
 933  * @t: tuner internal struct
 934  * @std:        TV standard
 935  *
 936  * A few devices or drivers have problem to detect some standard variations.
 937  * On other operational systems, the drivers generally have a per-country
 938  * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
 939  * such hacks. Instead, it relies on a proper video standard selection from
 940  * the userspace application. However, as some apps are buggy, not allowing
 941  * to distinguish all video standard variations, a modprobe parameter can
 942  * be used to force a video standard match.
 943  */
 944 static v4l2_std_id tuner_fixup_std(struct tuner *t, v4l2_std_id std)
 945 {
 946         if (pal[0] != '-' && (std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 947                 switch (pal[0]) {
 948                 case '6':
 949                         return V4L2_STD_PAL_60;
 950                 case 'b':
 951                 case 'B':
 952                 case 'g':
 953                 case 'G':
 954                         return V4L2_STD_PAL_BG;
 955                 case 'i':
 956                 case 'I':
 957                         return V4L2_STD_PAL_I;
 958                 case 'd':
 959                 case 'D':
 960                 case 'k':
 961                 case 'K':
 962                         return V4L2_STD_PAL_DK;
 963                 case 'M':
 964                 case 'm':
 965                         return V4L2_STD_PAL_M;
 966                 case 'N':
 967                 case 'n':
 968                         if (pal[1] == 'c' || pal[1] == 'C')
 969                                 return V4L2_STD_PAL_Nc;
 970                         return V4L2_STD_PAL_N;
 971                 default:
 972                         pr_warn("pal= argument not recognised\n");
 973                         break;
 974                 }
 975         }
 976         if (secam[0] != '-' && (std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 977                 switch (secam[0]) {
 978                 case 'b':
 979                 case 'B':
 980                 case 'g':
 981                 case 'G':
 982                 case 'h':
 983                 case 'H':
 984                         return V4L2_STD_SECAM_B |
 985                                V4L2_STD_SECAM_G |
 986                                V4L2_STD_SECAM_H;
 987                 case 'd':
 988                 case 'D':
 989                 case 'k':
 990                 case 'K':
 991                         return V4L2_STD_SECAM_DK;
 992                 case 'l':
 993                 case 'L':
 994                         if ((secam[1] == 'C') || (secam[1] == 'c'))
 995                                 return V4L2_STD_SECAM_LC;
 996                         return V4L2_STD_SECAM_L;
 997                 default:
 998                         pr_warn("secam= argument not recognised\n");
 999                         break;
1000                 }
1001         }
1002 
1003         if (ntsc[0] != '-' && (std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
1004                 switch (ntsc[0]) {
1005                 case 'm':
1006                 case 'M':
1007                         return V4L2_STD_NTSC_M;
1008                 case 'j':
1009                 case 'J':
1010                         return V4L2_STD_NTSC_M_JP;
1011                 case 'k':
1012                 case 'K':
1013                         return V4L2_STD_NTSC_M_KR;
1014                 default:
1015                         pr_info("ntsc= argument not recognised\n");
1016                         break;
1017                 }
1018         }
1019         return std;
1020 }
1021 
1022 /*
1023  * Functions that are specific for Radio mode
1024  */
1025 
1026 /**
1027  * set_radio_freq - Set tuner frequency,  freq in Units of 62.5 Hz  = 1/16kHz
1028  *
1029  * @c:  i2c_client descriptor
1030  * @freq: frequency
1031  */
1032 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
1033 {
1034         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1035         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1036 
1037         struct analog_parameters params = {
1038                 .mode      = t->mode,
1039                 .audmode   = t->audmode,
1040                 .std       = t->std
1041         };
1042 
1043         if (t->type == UNSET) {
1044                 pr_warn("tuner type not set\n");
1045                 return;
1046         }
1047         if (NULL == analog_ops->set_params) {
1048                 pr_warn("tuner has no way to set radio frequency\n");
1049                 return;
1050         }
1051         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
1052                 dprintk("radio freq (%d.%02d) out of range (%d-%d)\n",
1053                            freq / 16000, freq % 16000 * 100 / 16000,
1054                            radio_range[0], radio_range[1]);
1055                 /* V4L2 spec: if the freq is not possible then the closest
1056                    possible value should be selected */
1057                 if (freq < radio_range[0] * 16000)
1058                         freq = radio_range[0] * 16000;
1059                 else
1060                         freq = radio_range[1] * 16000;
1061         }
1062         params.frequency = freq;
1063         dprintk("radio freq set to %d.%02d\n",
1064                         freq / 16000, freq % 16000 * 100 / 16000);
1065         t->radio_freq = freq;
1066         t->standby = false;
1067 
1068         analog_ops->set_params(&t->fe, &params);
1069         /*
1070          * The tuner driver might decide to change the audmode if it only
1071          * supports stereo, so update t->audmode.
1072          */
1073         t->audmode = params.audmode;
1074 }
1075 
1076 /*
1077  * Debug function for reporting tuner status to userspace
1078  */
1079 
1080 /**
1081  * tuner_status - Dumps the current tuner status at dmesg
1082  * @fe: pointer to struct dvb_frontend
1083  *
1084  * This callback is used only for driver debug purposes, answering to
1085  * VIDIOC_LOG_STATUS. No changes should happen on this call.
1086  */
1087 static void tuner_status(struct dvb_frontend *fe)
1088 {
1089         struct tuner *t = fe->analog_demod_priv;
1090         unsigned long freq, freq_fraction;
1091         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
1092         struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
1093         const char *p;
1094 
1095         switch (t->mode) {
1096         case V4L2_TUNER_RADIO:
1097                 p = "radio";
1098                 break;
1099         case V4L2_TUNER_DIGITAL_TV: /* Used by mt20xx */
1100                 p = "digital TV";
1101                 break;
1102         case V4L2_TUNER_ANALOG_TV:
1103         default:
1104                 p = "analog TV";
1105                 break;
1106         }
1107         if (t->mode == V4L2_TUNER_RADIO) {
1108                 freq = t->radio_freq / 16000;
1109                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
1110         } else {
1111                 freq = t->tv_freq / 16;
1112                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
1113         }
1114         pr_info("Tuner mode:      %s%s\n", p,
1115                    t->standby ? " on standby mode" : "");
1116         pr_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
1117         pr_info("Standard:        0x%08lx\n", (unsigned long)t->std);
1118         if (t->mode != V4L2_TUNER_RADIO)
1119                 return;
1120         if (fe_tuner_ops->get_status) {
1121                 u32 tuner_status;
1122 
1123                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1124                 if (tuner_status & TUNER_STATUS_LOCKED)
1125                         pr_info("Tuner is locked.\n");
1126                 if (tuner_status & TUNER_STATUS_STEREO)
1127                         pr_info("Stereo:          yes\n");
1128         }
1129         if (analog_ops->has_signal) {
1130                 u16 signal;
1131 
1132                 if (!analog_ops->has_signal(fe, &signal))
1133                         pr_info("Signal strength: %hu\n", signal);
1134         }
1135 }
1136 
1137 /*
1138  * Function to splicitly change mode to radio. Probably not needed anymore
1139  */
1140 
1141 static int tuner_s_radio(struct v4l2_subdev *sd)
1142 {
1143         struct tuner *t = to_tuner(sd);
1144 
1145         if (set_mode(t, V4L2_TUNER_RADIO) == 0)
1146                 set_freq(t, 0);
1147         return 0;
1148 }
1149 
1150 /*
1151  * Tuner callbacks to handle userspace ioctl's
1152  */
1153 
1154 /**
1155  * tuner_standby - places the tuner in standby mode
1156  * @sd: pointer to struct v4l2_subdev
1157  */
1158 static int tuner_standby(struct v4l2_subdev *sd)
1159 {
1160         struct tuner *t = to_tuner(sd);
1161         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1162 
1163         dprintk("Putting tuner to sleep\n");
1164         t->standby = true;
1165         if (analog_ops->standby)
1166                 analog_ops->standby(&t->fe);
1167         return 0;
1168 }
1169 
1170 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1171 {
1172         struct tuner *t = to_tuner(sd);
1173 
1174         if (set_mode(t, V4L2_TUNER_ANALOG_TV))
1175                 return 0;
1176 
1177         t->std = tuner_fixup_std(t, std);
1178         if (t->std != std)
1179                 dprintk("Fixup standard %llx to %llx\n", std, t->std);
1180         set_freq(t, 0);
1181         return 0;
1182 }
1183 
1184 static int tuner_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f)
1185 {
1186         struct tuner *t = to_tuner(sd);
1187 
1188         if (set_mode(t, f->type) == 0)
1189                 set_freq(t, f->frequency);
1190         return 0;
1191 }
1192 
1193 /**
1194  * tuner_g_frequency - Get the tuned frequency for the tuner
1195  * @sd: pointer to struct v4l2_subdev
1196  * @f: pointer to struct v4l2_frequency
1197  *
1198  * At return, the structure f will be filled with tuner frequency
1199  * if the tuner matches the f->type.
1200  * Note: f->type should be initialized before calling it.
1201  * This is done by either video_ioctl2 or by the bridge driver.
1202  */
1203 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1204 {
1205         struct tuner *t = to_tuner(sd);
1206         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1207 
1208         if (check_mode(t, f->type) == -EINVAL)
1209                 return 0;
1210         if (f->type == t->mode && fe_tuner_ops->get_frequency && !t->standby) {
1211                 u32 abs_freq;
1212 
1213                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1214                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1215                         DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1216                         DIV_ROUND_CLOSEST(abs_freq, 62500);
1217         } else {
1218                 f->frequency = (V4L2_TUNER_RADIO == f->type) ?
1219                         t->radio_freq : t->tv_freq;
1220         }
1221         return 0;
1222 }
1223 
1224 /**
1225  * tuner_g_tuner - Fill in tuner information
1226  * @sd: pointer to struct v4l2_subdev
1227  * @vt: pointer to struct v4l2_tuner
1228  *
1229  * At return, the structure vt will be filled with tuner information
1230  * if the tuner matches vt->type.
1231  * Note: vt->type should be initialized before calling it.
1232  * This is done by either video_ioctl2 or by the bridge driver.
1233  */
1234 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1235 {
1236         struct tuner *t = to_tuner(sd);
1237         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1238         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1239 
1240         if (check_mode(t, vt->type) == -EINVAL)
1241                 return 0;
1242         if (vt->type == t->mode && analog_ops->get_afc)
1243                 analog_ops->get_afc(&t->fe, &vt->afc);
1244         if (vt->type == t->mode && analog_ops->has_signal) {
1245                 u16 signal = (u16)vt->signal;
1246 
1247                 if (!analog_ops->has_signal(&t->fe, &signal))
1248                         vt->signal = signal;
1249         }
1250         if (vt->type != V4L2_TUNER_RADIO) {
1251                 vt->capability |= V4L2_TUNER_CAP_NORM;
1252                 vt->rangelow = tv_range[0] * 16;
1253                 vt->rangehigh = tv_range[1] * 16;
1254                 return 0;
1255         }
1256 
1257         /* radio mode */
1258         if (vt->type == t->mode) {
1259                 vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1260                 if (fe_tuner_ops->get_status) {
1261                         u32 tuner_status;
1262 
1263                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
1264                         vt->rxsubchans =
1265                                 (tuner_status & TUNER_STATUS_STEREO) ?
1266                                 V4L2_TUNER_SUB_STEREO :
1267                                 V4L2_TUNER_SUB_MONO;
1268                 }
1269                 vt->audmode = t->audmode;
1270         }
1271         vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1272         vt->rangelow = radio_range[0] * 16000;
1273         vt->rangehigh = radio_range[1] * 16000;
1274 
1275         return 0;
1276 }
1277 
1278 /**
1279  * tuner_s_tuner - Set the tuner's audio mode
1280  * @sd: pointer to struct v4l2_subdev
1281  * @vt: pointer to struct v4l2_tuner
1282  *
1283  * Sets the audio mode if the tuner matches vt->type.
1284  * Note: vt->type should be initialized before calling it.
1285  * This is done by either video_ioctl2 or by the bridge driver.
1286  */
1287 static int tuner_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt)
1288 {
1289         struct tuner *t = to_tuner(sd);
1290 
1291         if (set_mode(t, vt->type))
1292                 return 0;
1293 
1294         if (t->mode == V4L2_TUNER_RADIO) {
1295                 t->audmode = vt->audmode;
1296                 /*
1297                  * For radio audmode can only be mono or stereo. Map any
1298                  * other values to stereo. The actual tuner driver that is
1299                  * called in set_radio_freq can decide to limit the audmode to
1300                  * mono if only mono is supported.
1301                  */
1302                 if (t->audmode != V4L2_TUNER_MODE_MONO &&
1303                     t->audmode != V4L2_TUNER_MODE_STEREO)
1304                         t->audmode = V4L2_TUNER_MODE_STEREO;
1305         }
1306         set_freq(t, 0);
1307 
1308         return 0;
1309 }
1310 
1311 static int tuner_log_status(struct v4l2_subdev *sd)
1312 {
1313         struct tuner *t = to_tuner(sd);
1314         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1315 
1316         if (analog_ops->tuner_status)
1317                 analog_ops->tuner_status(&t->fe);
1318         return 0;
1319 }
1320 
1321 #ifdef CONFIG_PM_SLEEP
1322 static int tuner_suspend(struct device *dev)
1323 {
1324         struct i2c_client *c = to_i2c_client(dev);
1325         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1326         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1327 
1328         dprintk("suspend\n");
1329 
1330         if (t->fe.ops.tuner_ops.suspend)
1331                 t->fe.ops.tuner_ops.suspend(&t->fe);
1332         else if (!t->standby && analog_ops->standby)
1333                 analog_ops->standby(&t->fe);
1334 
1335         return 0;
1336 }
1337 
1338 static int tuner_resume(struct device *dev)
1339 {
1340         struct i2c_client *c = to_i2c_client(dev);
1341         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1342 
1343         dprintk("resume\n");
1344 
1345         if (t->fe.ops.tuner_ops.resume)
1346                 t->fe.ops.tuner_ops.resume(&t->fe);
1347         else if (!t->standby)
1348                 if (set_mode(t, t->mode) == 0)
1349                         set_freq(t, 0);
1350 
1351         return 0;
1352 }
1353 #endif
1354 
1355 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1356 {
1357         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1358 
1359         /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1360            to handle it here.
1361            There must be a better way of doing this... */
1362         switch (cmd) {
1363         case TUNER_SET_CONFIG:
1364                 return tuner_s_config(sd, arg);
1365         }
1366         return -ENOIOCTLCMD;
1367 }
1368 
1369 /*
1370  * Callback structs
1371  */
1372 
1373 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1374         .log_status = tuner_log_status,
1375 };
1376 
1377 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1378         .standby = tuner_standby,
1379         .s_radio = tuner_s_radio,
1380         .g_tuner = tuner_g_tuner,
1381         .s_tuner = tuner_s_tuner,
1382         .s_frequency = tuner_s_frequency,
1383         .g_frequency = tuner_g_frequency,
1384         .s_type_addr = tuner_s_type_addr,
1385         .s_config = tuner_s_config,
1386 };
1387 
1388 static const struct v4l2_subdev_video_ops tuner_video_ops = {
1389         .s_std = tuner_s_std,
1390 };
1391 
1392 static const struct v4l2_subdev_ops tuner_ops = {
1393         .core = &tuner_core_ops,
1394         .tuner = &tuner_tuner_ops,
1395         .video = &tuner_video_ops,
1396 };
1397 
1398 /*
1399  * I2C structs and module init functions
1400  */
1401 
1402 static const struct dev_pm_ops tuner_pm_ops = {
1403         SET_SYSTEM_SLEEP_PM_OPS(tuner_suspend, tuner_resume)
1404 };
1405 
1406 static const struct i2c_device_id tuner_id[] = {
1407         { "tuner", }, /* autodetect */
1408         { }
1409 };
1410 MODULE_DEVICE_TABLE(i2c, tuner_id);
1411 
1412 static struct i2c_driver tuner_driver = {
1413         .driver = {
1414                 .name   = "tuner",
1415                 .pm     = &tuner_pm_ops,
1416         },
1417         .probe          = tuner_probe,
1418         .remove         = tuner_remove,
1419         .command        = tuner_command,
1420         .id_table       = tuner_id,
1421 };
1422 
1423 module_i2c_driver(tuner_driver);
1424 
1425 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1426 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1427 MODULE_LICENSE("GPL");