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

   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 "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  *
 618  * This routine probes for tuners at the expected I2C addresses. On most
 619  * cases, if a device answers to a given I2C address, it assumes that the
 620  * device is a tuner. On a few cases, however, an additional logic is needed
 621  * to double check if the device is really a tuner, or to identify the tuner
 622  * 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  */
 627 static int tuner_probe(struct i2c_client *client)
 628 {
 629         struct tuner *t;
 630         struct tuner *radio;
 631         struct tuner *tv;
 632 #ifdef CONFIG_MEDIA_CONTROLLER
 633         int ret;
 634 #endif
 635
 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 the
 709            first? Because there are some devices (notably the ones with TI
 710            tuners) that have more than one i2c address for the *same* device.
 711            Experience shows that, except for just one case, the first
 712            address is the right one. The exception is a Russian tuner
 713            (ACORP_Y878F). So, the desired behavior is just to enable the
 714            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 */
 724 register_client:
 725 #if defined(CONFIG_MEDIA_CONTROLLER)
 726         t->sd.entity.name = t->name;
 727         /*
 728          * Handle the special case where the tuner has actually
 729          * two stages: the PLL to tune into a frequency and the
 730          * 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 #endif
 759         /* Sets a default mode */
 760         if (t->mode_mask & T_ANALOG_TV)
 761                 t->mode = V4L2_TUNER_ANALOG_TV;
 762         else
 763                 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 tuner
 776  *
 777  * @client:     i2c_client descriptor
 778  */
 779
 780 static 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 TV
 794  *
 795  * A few cards have a separate I2C tuner for radio. Those routines
 796  * take care of switching between TV/Radio mode, filtering only the
 797  * commands that apply to the Radio or TV tuner.
 798  */
 799
 800 /**
 801  * check_mode - Verify if tuner supports the requested mode
 802  * @t: a pointer to the module's internal struct_tuner
 803  * @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 the
 807  * tuner can't support that mode, it returns -EINVAL. Otherwise, it
 808  * returns 0.
 809  * This function is needed for boards that have a separate tuner for
 810  * radio (like devices with tea5767).
 811  *
 812  * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to
 813  *       select a TV frequency. So, t_mode = T_ANALOG_TV could actually
 814  *       be used to represent a Digital TV too.
 815  */
 816 static 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         else
 822                 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_tuner
 833  * @mode:       enum v4l2_type (radio or TV)
 834  *
 835  * If tuner doesn't support the needed mode (radio or TV), prints a
 836  * debug message and returns -EINVAL, changing its state to standby.
 837  * Otherwise, changes the mode and returns 0.
 838  */
 839 static 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_tuner
 861  * @freq:       frequency to set (0 means to use the current frequency)
 862  */
 863 static 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 mode
 880  */
 881
 882 /**
 883  * set_tv_freq - Set tuner frequency,  freq in Units of 62.5 kHz = 1/16MHz
 884  *
 885  * @c:  i2c_client descriptor
 886  * @freq: frequency
 887  */
 888 static 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->std
 897         };
 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 closest
 912                    possible value should be selected */
 913                 if (freq < tv_range[0] * 16)
 914                         freq = tv_range[0] * 16;
 915                 else
 916                         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, &params);
 925 }
 926
 927 /**
 928  * tuner_fixup_std - force a given video standard variant
 929  *
 930  * @t: tuner internal struct
 931  * @std:        TV standard
 932  *
 933  * A few devices or drivers have problem to detect some standard variations.
 934  * On other operational systems, the drivers generally have a per-country
 935  * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
 936  * such hacks. Instead, it relies on a proper video standard selection from
 937  * the userspace application. However, as some apps are buggy, not allowing
 938  * to distinguish all video standard variations, a modprobe parameter can
 939  * be used to force a video standard match.
 940  */
 941 static 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 mode
1021  */
1022
1023 /**
1024  * set_radio_freq - Set tuner frequency,  freq in Units of 62.5 Hz  = 1/16kHz
1025  *
1026  * @c:  i2c_client descriptor
1027  * @freq: frequency
1028  */
1029 static 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->std
1038         };
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 closest
1053                    possible value should be selected */
1054                 if (freq < radio_range[0] * 16000)
1055                         freq = radio_range[0] * 16000;
1056                 else
1057                         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, &params);
1066         /*
1067          * The tuner driver might decide to change the audmode if it only
1068          * supports stereo, so update t->audmode.
1069          */
1070         t->audmode = params.audmode;
1071 }
1072
1073 /*
1074  * Debug function for reporting tuner status to userspace
1075  */
1076
1077 /**
1078  * tuner_status - Dumps the current tuner status at dmesg
1079  * @fe: pointer to struct dvb_frontend
1080  *
1081  * This callback is used only for driver debug purposes, answering to
1082  * VIDIOC_LOG_STATUS. No changes should happen on this call.
1083  */
1084 static 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 anymore
1136  */
1137
1138 static 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's
1149  */
1150
1151 /**
1152  * tuner_standby - places the tuner in standby mode
1153  * @sd: pointer to struct v4l2_subdev
1154  */
1155 static 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
1167 static 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
1181 static 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 tuner
1192  * @sd: pointer to struct v4l2_subdev
1193  * @f: pointer to struct v4l2_frequency
1194  *
1195  * At return, the structure f will be filled with tuner frequency
1196  * 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  */
1200 static 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 information
1223  * @sd: pointer to struct v4l2_subdev
1224  * @vt: pointer to struct v4l2_tuner
1225  *
1226  * At return, the structure vt will be filled with tuner information
1227  * 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  */
1231 static 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 mode
1277  * @sd: pointer to struct v4l2_subdev
1278  * @vt: pointer to struct v4l2_tuner
1279  *
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  */
1284 static 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 any
1295                  * other values to stereo. The actual tuner driver that is
1296                  * called in set_radio_freq can decide to limit the audmode to
1297                  * 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
1308 static 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_SLEEP
1319 static 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
1335 static 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 #endif
1351
1352 static 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 have
1357            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 structs
1368  */
1369
1370 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1371         .log_status = tuner_log_status,
1372 };
1373
1374 static 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
1385 static const struct v4l2_subdev_video_ops tuner_video_ops = {
1386         .s_std = tuner_s_std,
1387 };
1388
1389 static 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 functions
1397  */
1398
1399 static const struct dev_pm_ops tuner_pm_ops = {
1400         SET_SYSTEM_SLEEP_PM_OPS(tuner_suspend, tuner_resume)
1401 };
1402
1403 static const struct i2c_device_id tuner_id[] = {
1404         { "tuner", }, /* autodetect */
1405         { }
1406 };
1407 MODULE_DEVICE_TABLE(i2c, tuner_id);
1408
1409 static 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
1420 module_i2c_driver(tuner_driver);
1421
1422 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1423 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1424 MODULE_LICENSE("GPL");