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  * @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 void 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 }
 793
 794 /*
 795  * Functions to switch between Radio and TV
 796  *
 797  * A few cards have a separate I2C tuner for radio. Those routines
 798  * take care of switching between TV/Radio mode, filtering only the
 799  * commands that apply to the Radio or TV tuner.
 800  */
 801
 802 /**
 803  * check_mode - Verify if tuner supports the requested mode
 804  * @t: a pointer to the module's internal struct_tuner
 805  * @mode: mode of the tuner, as defined by &enum v4l2_tuner_type.
 806  *
 807  * This function checks if the tuner is capable of tuning analog TV,
 808  * digital TV or radio, depending on what the caller wants. If the
 809  * tuner can't support that mode, it returns -EINVAL. Otherwise, it
 810  * returns 0.
 811  * This function is needed for boards that have a separate tuner for
 812  * radio (like devices with tea5767).
 813  *
 814  * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to
 815  *       select a TV frequency. So, t_mode = T_ANALOG_TV could actually
 816  *       be used to represent a Digital TV too.
 817  */
 818 static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
 819 {
 820         int t_mode;
 821         if (mode == V4L2_TUNER_RADIO)
 822                 t_mode = T_RADIO;
 823         else
 824                 t_mode = T_ANALOG_TV;
 825
 826         if ((t_mode & t->mode_mask) == 0)
 827                 return -EINVAL;
 828
 829         return 0;
 830 }
 831
 832 /**
 833  * set_mode - Switch tuner to other mode.
 834  * @t:          a pointer to the module's internal struct_tuner
 835  * @mode:       enum v4l2_type (radio or TV)
 836  *
 837  * If tuner doesn't support the needed mode (radio or TV), prints a
 838  * debug message and returns -EINVAL, changing its state to standby.
 839  * Otherwise, changes the mode and returns 0.
 840  */
 841 static int set_mode(struct tuner *t, enum v4l2_tuner_type mode)
 842 {
 843         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 844
 845         if (mode != t->mode) {
 846                 if (check_mode(t, mode) == -EINVAL) {
 847                         dprintk("Tuner doesn't support mode %d. Putting tuner to sleep\n",
 848                                   mode);
 849                         t->standby = true;
 850                         if (analog_ops->standby)
 851                                 analog_ops->standby(&t->fe);
 852                         return -EINVAL;
 853                 }
 854                 t->mode = mode;
 855                 dprintk("Changing to mode %d\n", mode);
 856         }
 857         return 0;
 858 }
 859
 860 /**
 861  * set_freq - Set the tuner to the desired frequency.
 862  * @t:          a pointer to the module's internal struct_tuner
 863  * @freq:       frequency to set (0 means to use the current frequency)
 864  */
 865 static void set_freq(struct tuner *t, unsigned int freq)
 866 {
 867         struct i2c_client *client = v4l2_get_subdevdata(&t->sd);
 868
 869         if (t->mode == V4L2_TUNER_RADIO) {
 870                 if (!freq)
 871                         freq = t->radio_freq;
 872                 set_radio_freq(client, freq);
 873         } else {
 874                 if (!freq)
 875                         freq = t->tv_freq;
 876                 set_tv_freq(client, freq);
 877         }
 878 }
 879
 880 /*
 881  * Functions that are specific for TV mode
 882  */
 883
 884 /**
 885  * set_tv_freq - Set tuner frequency,  freq in Units of 62.5 kHz = 1/16MHz
 886  *
 887  * @c:  i2c_client descriptor
 888  * @freq: frequency
 889  */
 890 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
 891 {
 892         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 893         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 894
 895         struct analog_parameters params = {
 896                 .mode      = t->mode,
 897                 .audmode   = t->audmode,
 898                 .std       = t->std
 899         };
 900
 901         if (t->type == UNSET) {
 902                 pr_warn("tuner type not set\n");
 903                 return;
 904         }
 905         if (NULL == analog_ops->set_params) {
 906                 pr_warn("Tuner has no way to set tv freq\n");
 907                 return;
 908         }
 909         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
 910                 dprintk("TV freq (%d.%02d) out of range (%d-%d)\n",
 911                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
 912                            tv_range[1]);
 913                 /* V4L2 spec: if the freq is not possible then the closest
 914                    possible value should be selected */
 915                 if (freq < tv_range[0] * 16)
 916                         freq = tv_range[0] * 16;
 917                 else
 918                         freq = tv_range[1] * 16;
 919         }
 920         params.frequency = freq;
 921         dprintk("tv freq set to %d.%02d\n",
 922                         freq / 16, freq % 16 * 100 / 16);
 923         t->tv_freq = freq;
 924         t->standby = false;
 925
 926         analog_ops->set_params(&t->fe, &params);
 927 }
 928
 929 /**
 930  * tuner_fixup_std - force a given video standard variant
 931  *
 932  * @t: tuner internal struct
 933  * @std:        TV standard
 934  *
 935  * A few devices or drivers have problem to detect some standard variations.
 936  * On other operational systems, the drivers generally have a per-country
 937  * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
 938  * such hacks. Instead, it relies on a proper video standard selection from
 939  * the userspace application. However, as some apps are buggy, not allowing
 940  * to distinguish all video standard variations, a modprobe parameter can
 941  * be used to force a video standard match.
 942  */
 943 static v4l2_std_id tuner_fixup_std(struct tuner *t, v4l2_std_id std)
 944 {
 945         if (pal[0] != '-' && (std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 946                 switch (pal[0]) {
 947                 case '6':
 948                         return V4L2_STD_PAL_60;
 949                 case 'b':
 950                 case 'B':
 951                 case 'g':
 952                 case 'G':
 953                         return V4L2_STD_PAL_BG;
 954                 case 'i':
 955                 case 'I':
 956                         return V4L2_STD_PAL_I;
 957                 case 'd':
 958                 case 'D':
 959                 case 'k':
 960                 case 'K':
 961                         return V4L2_STD_PAL_DK;
 962                 case 'M':
 963                 case 'm':
 964                         return V4L2_STD_PAL_M;
 965                 case 'N':
 966                 case 'n':
 967                         if (pal[1] == 'c' || pal[1] == 'C')
 968                                 return V4L2_STD_PAL_Nc;
 969                         return V4L2_STD_PAL_N;
 970                 default:
 971                         pr_warn("pal= argument not recognised\n");
 972                         break;
 973                 }
 974         }
 975         if (secam[0] != '-' && (std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 976                 switch (secam[0]) {
 977                 case 'b':
 978                 case 'B':
 979                 case 'g':
 980                 case 'G':
 981                 case 'h':
 982                 case 'H':
 983                         return V4L2_STD_SECAM_B |
 984                                V4L2_STD_SECAM_G |
 985                                V4L2_STD_SECAM_H;
 986                 case 'd':
 987                 case 'D':
 988                 case 'k':
 989                 case 'K':
 990                         return V4L2_STD_SECAM_DK;
 991                 case 'l':
 992                 case 'L':
 993                         if ((secam[1] == 'C') || (secam[1] == 'c'))
 994                                 return V4L2_STD_SECAM_LC;
 995                         return V4L2_STD_SECAM_L;
 996                 default:
 997                         pr_warn("secam= argument not recognised\n");
 998                         break;
 999                 }
1000         }
1001
1002         if (ntsc[0] != '-' && (std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
1003                 switch (ntsc[0]) {
1004                 case 'm':
1005                 case 'M':
1006                         return V4L2_STD_NTSC_M;
1007                 case 'j':
1008                 case 'J':
1009                         return V4L2_STD_NTSC_M_JP;
1010                 case 'k':
1011                 case 'K':
1012                         return V4L2_STD_NTSC_M_KR;
1013                 default:
1014                         pr_info("ntsc= argument not recognised\n");
1015                         break;
1016                 }
1017         }
1018         return std;
1019 }
1020
1021 /*
1022  * Functions that are specific for Radio mode
1023  */
1024
1025 /**
1026  * set_radio_freq - Set tuner frequency,  freq in Units of 62.5 Hz  = 1/16kHz
1027  *
1028  * @c:  i2c_client descriptor
1029  * @freq: frequency
1030  */
1031 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
1032 {
1033         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1034         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1035
1036         struct analog_parameters params = {
1037                 .mode      = t->mode,
1038                 .audmode   = t->audmode,
1039                 .std       = t->std
1040         };
1041
1042         if (t->type == UNSET) {
1043                 pr_warn("tuner type not set\n");
1044                 return;
1045         }
1046         if (NULL == analog_ops->set_params) {
1047                 pr_warn("tuner has no way to set radio frequency\n");
1048                 return;
1049         }
1050         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
1051                 dprintk("radio freq (%d.%02d) out of range (%d-%d)\n",
1052                            freq / 16000, freq % 16000 * 100 / 16000,
1053                            radio_range[0], radio_range[1]);
1054                 /* V4L2 spec: if the freq is not possible then the closest
1055                    possible value should be selected */
1056                 if (freq < radio_range[0] * 16000)
1057                         freq = radio_range[0] * 16000;
1058                 else
1059                         freq = radio_range[1] * 16000;
1060         }
1061         params.frequency = freq;
1062         dprintk("radio freq set to %d.%02d\n",
1063                         freq / 16000, freq % 16000 * 100 / 16000);
1064         t->radio_freq = freq;
1065         t->standby = false;
1066
1067         analog_ops->set_params(&t->fe, &params);
1068         /*
1069          * The tuner driver might decide to change the audmode if it only
1070          * supports stereo, so update t->audmode.
1071          */
1072         t->audmode = params.audmode;
1073 }
1074
1075 /*
1076  * Debug function for reporting tuner status to userspace
1077  */
1078
1079 /**
1080  * tuner_status - Dumps the current tuner status at dmesg
1081  * @fe: pointer to struct dvb_frontend
1082  *
1083  * This callback is used only for driver debug purposes, answering to
1084  * VIDIOC_LOG_STATUS. No changes should happen on this call.
1085  */
1086 static void tuner_status(struct dvb_frontend *fe)
1087 {
1088         struct tuner *t = fe->analog_demod_priv;
1089         unsigned long freq, freq_fraction;
1090         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
1091         struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
1092         const char *p;
1093
1094         switch (t->mode) {
1095         case V4L2_TUNER_RADIO:
1096                 p = "radio";
1097                 break;
1098         case V4L2_TUNER_DIGITAL_TV: /* Used by mt20xx */
1099                 p = "digital TV";
1100                 break;
1101         case V4L2_TUNER_ANALOG_TV:
1102         default:
1103                 p = "analog TV";
1104                 break;
1105         }
1106         if (t->mode == V4L2_TUNER_RADIO) {
1107                 freq = t->radio_freq / 16000;
1108                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
1109         } else {
1110                 freq = t->tv_freq / 16;
1111                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
1112         }
1113         pr_info("Tuner mode:      %s%s\n", p,
1114                    t->standby ? " on standby mode" : "");
1115         pr_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
1116         pr_info("Standard:        0x%08lx\n", (unsigned long)t->std);
1117         if (t->mode != V4L2_TUNER_RADIO)
1118                 return;
1119         if (fe_tuner_ops->get_status) {
1120                 u32 tuner_status = 0;
1121
1122                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1123                 if (tuner_status & TUNER_STATUS_LOCKED)
1124                         pr_info("Tuner is locked.\n");
1125                 if (tuner_status & TUNER_STATUS_STEREO)
1126                         pr_info("Stereo:          yes\n");
1127         }
1128         if (analog_ops->has_signal) {
1129                 u16 signal;
1130
1131                 if (!analog_ops->has_signal(fe, &signal))
1132                         pr_info("Signal strength: %hu\n", signal);
1133         }
1134 }
1135
1136 /*
1137  * Function to splicitly change mode to radio. Probably not needed anymore
1138  */
1139
1140 static int tuner_s_radio(struct v4l2_subdev *sd)
1141 {
1142         struct tuner *t = to_tuner(sd);
1143
1144         if (set_mode(t, V4L2_TUNER_RADIO) == 0)
1145                 set_freq(t, 0);
1146         return 0;
1147 }
1148
1149 /*
1150  * Tuner callbacks to handle userspace ioctl's
1151  */
1152
1153 /**
1154  * tuner_standby - places the tuner in standby mode
1155  * @sd: pointer to struct v4l2_subdev
1156  */
1157 static int tuner_standby(struct v4l2_subdev *sd)
1158 {
1159         struct tuner *t = to_tuner(sd);
1160         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1161
1162         dprintk("Putting tuner to sleep\n");
1163         t->standby = true;
1164         if (analog_ops->standby)
1165                 analog_ops->standby(&t->fe);
1166         return 0;
1167 }
1168
1169 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1170 {
1171         struct tuner *t = to_tuner(sd);
1172
1173         if (set_mode(t, V4L2_TUNER_ANALOG_TV))
1174                 return 0;
1175
1176         t->std = tuner_fixup_std(t, std);
1177         if (t->std != std)
1178                 dprintk("Fixup standard %llx to %llx\n", std, t->std);
1179         set_freq(t, 0);
1180         return 0;
1181 }
1182
1183 static int tuner_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f)
1184 {
1185         struct tuner *t = to_tuner(sd);
1186
1187         if (set_mode(t, f->type) == 0)
1188                 set_freq(t, f->frequency);
1189         return 0;
1190 }
1191
1192 /**
1193  * tuner_g_frequency - Get the tuned frequency for the tuner
1194  * @sd: pointer to struct v4l2_subdev
1195  * @f: pointer to struct v4l2_frequency
1196  *
1197  * At return, the structure f will be filled with tuner frequency
1198  * if the tuner matches the f->type.
1199  * Note: f->type should be initialized before calling it.
1200  * This is done by either video_ioctl2 or by the bridge driver.
1201  */
1202 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1203 {
1204         struct tuner *t = to_tuner(sd);
1205         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1206
1207         if (check_mode(t, f->type) == -EINVAL)
1208                 return 0;
1209         if (f->type == t->mode && fe_tuner_ops->get_frequency && !t->standby) {
1210                 u32 abs_freq;
1211
1212                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1213                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1214                         DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1215                         DIV_ROUND_CLOSEST(abs_freq, 62500);
1216         } else {
1217                 f->frequency = (V4L2_TUNER_RADIO == f->type) ?
1218                         t->radio_freq : t->tv_freq;
1219         }
1220         return 0;
1221 }
1222
1223 /**
1224  * tuner_g_tuner - Fill in tuner information
1225  * @sd: pointer to struct v4l2_subdev
1226  * @vt: pointer to struct v4l2_tuner
1227  *
1228  * At return, the structure vt will be filled with tuner information
1229  * if the tuner matches vt->type.
1230  * Note: vt->type should be initialized before calling it.
1231  * This is done by either video_ioctl2 or by the bridge driver.
1232  */
1233 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1234 {
1235         struct tuner *t = to_tuner(sd);
1236         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1237         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1238
1239         if (check_mode(t, vt->type) == -EINVAL)
1240                 return 0;
1241         if (vt->type == t->mode && analog_ops->get_afc)
1242                 analog_ops->get_afc(&t->fe, &vt->afc);
1243         if (vt->type == t->mode && analog_ops->has_signal) {
1244                 u16 signal = (u16)vt->signal;
1245
1246                 if (!analog_ops->has_signal(&t->fe, &signal))
1247                         vt->signal = signal;
1248         }
1249         if (vt->type != V4L2_TUNER_RADIO) {
1250                 vt->capability |= V4L2_TUNER_CAP_NORM;
1251                 vt->rangelow = tv_range[0] * 16;
1252                 vt->rangehigh = tv_range[1] * 16;
1253                 return 0;
1254         }
1255
1256         /* radio mode */
1257         if (vt->type == t->mode) {
1258                 vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1259                 if (fe_tuner_ops->get_status) {
1260                         u32 tuner_status = 0;
1261
1262                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
1263                         vt->rxsubchans =
1264                                 (tuner_status & TUNER_STATUS_STEREO) ?
1265                                 V4L2_TUNER_SUB_STEREO :
1266                                 V4L2_TUNER_SUB_MONO;
1267                 }
1268                 vt->audmode = t->audmode;
1269         }
1270         vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1271         vt->rangelow = radio_range[0] * 16000;
1272         vt->rangehigh = radio_range[1] * 16000;
1273
1274         return 0;
1275 }
1276
1277 /**
1278  * tuner_s_tuner - Set the tuner's audio mode
1279  * @sd: pointer to struct v4l2_subdev
1280  * @vt: pointer to struct v4l2_tuner
1281  *
1282  * Sets the audio mode if the tuner matches vt->type.
1283  * Note: vt->type should be initialized before calling it.
1284  * This is done by either video_ioctl2 or by the bridge driver.
1285  */
1286 static int tuner_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt)
1287 {
1288         struct tuner *t = to_tuner(sd);
1289
1290         if (set_mode(t, vt->type))
1291                 return 0;
1292
1293         if (t->mode == V4L2_TUNER_RADIO) {
1294                 t->audmode = vt->audmode;
1295                 /*
1296                  * For radio audmode can only be mono or stereo. Map any
1297                  * other values to stereo. The actual tuner driver that is
1298                  * called in set_radio_freq can decide to limit the audmode to
1299                  * mono if only mono is supported.
1300                  */
1301                 if (t->audmode != V4L2_TUNER_MODE_MONO &&
1302                     t->audmode != V4L2_TUNER_MODE_STEREO)
1303                         t->audmode = V4L2_TUNER_MODE_STEREO;
1304         }
1305         set_freq(t, 0);
1306
1307         return 0;
1308 }
1309
1310 static int tuner_log_status(struct v4l2_subdev *sd)
1311 {
1312         struct tuner *t = to_tuner(sd);
1313         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1314
1315         if (analog_ops->tuner_status)
1316                 analog_ops->tuner_status(&t->fe);
1317         return 0;
1318 }
1319
1320 #ifdef CONFIG_PM_SLEEP
1321 static int tuner_suspend(struct device *dev)
1322 {
1323         struct i2c_client *c = to_i2c_client(dev);
1324         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1325         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1326
1327         dprintk("suspend\n");
1328
1329         if (t->fe.ops.tuner_ops.suspend)
1330                 t->fe.ops.tuner_ops.suspend(&t->fe);
1331         else if (!t->standby && analog_ops->standby)
1332                 analog_ops->standby(&t->fe);
1333
1334         return 0;
1335 }
1336
1337 static int tuner_resume(struct device *dev)
1338 {
1339         struct i2c_client *c = to_i2c_client(dev);
1340         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1341
1342         dprintk("resume\n");
1343
1344         if (t->fe.ops.tuner_ops.resume)
1345                 t->fe.ops.tuner_ops.resume(&t->fe);
1346         else if (!t->standby)
1347                 if (set_mode(t, t->mode) == 0)
1348                         set_freq(t, 0);
1349
1350         return 0;
1351 }
1352 #endif
1353
1354 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1355 {
1356         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1357
1358         /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1359            to handle it here.
1360            There must be a better way of doing this... */
1361         switch (cmd) {
1362         case TUNER_SET_CONFIG:
1363                 return tuner_s_config(sd, arg);
1364         }
1365         return -ENOIOCTLCMD;
1366 }
1367
1368 /*
1369  * Callback structs
1370  */
1371
1372 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1373         .log_status = tuner_log_status,
1374 };
1375
1376 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1377         .standby = tuner_standby,
1378         .s_radio = tuner_s_radio,
1379         .g_tuner = tuner_g_tuner,
1380         .s_tuner = tuner_s_tuner,
1381         .s_frequency = tuner_s_frequency,
1382         .g_frequency = tuner_g_frequency,
1383         .s_type_addr = tuner_s_type_addr,
1384         .s_config = tuner_s_config,
1385 };
1386
1387 static const struct v4l2_subdev_video_ops tuner_video_ops = {
1388         .s_std = tuner_s_std,
1389 };
1390
1391 static const struct v4l2_subdev_ops tuner_ops = {
1392         .core = &tuner_core_ops,
1393         .tuner = &tuner_tuner_ops,
1394         .video = &tuner_video_ops,
1395 };
1396
1397 /*
1398  * I2C structs and module init functions
1399  */
1400
1401 static const struct dev_pm_ops tuner_pm_ops = {
1402         SET_SYSTEM_SLEEP_PM_OPS(tuner_suspend, tuner_resume)
1403 };
1404
1405 static const struct i2c_device_id tuner_id[] = {
1406         { "tuner", }, /* autodetect */
1407         { }
1408 };
1409 MODULE_DEVICE_TABLE(i2c, tuner_id);
1410
1411 static struct i2c_driver tuner_driver = {
1412         .driver = {
1413                 .name   = "tuner",
1414                 .pm     = &tuner_pm_ops,
1415         },
1416         .probe          = tuner_probe,
1417         .remove         = tuner_remove,
1418         .command        = tuner_command,
1419         .id_table       = tuner_id,
1420 };
1421
1422 module_i2c_driver(tuner_driver);
1423
1424 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1425 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1426 MODULE_LICENSE("GPL");