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

   1 /*
   2  * i2c tv tuner chip device driver
   3  * core core, i.e. kernel interfaces, registering and so on
   4  *
   5  * Copyright(c) by Ralph Metzler, Gerd Knorr, Gunther Mayer
   6  *
   7  * Copyright(c) 2005-2011 by Mauro Carvalho Chehab
   8  *      - Added support for a separate Radio tuner
   9  *      - Major rework and cleanups at the code
  10  *
  11  * This driver supports many devices and the idea is to let the driver
  12  * detect which device is present. So rather than listing all supported
  13  * devices here, we pretend to support a single, fake device type that will
  14  * handle both radio and analog TV tuning.
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/kernel.h>
  19 #include <linux/string.h>
  20 #include <linux/timer.h>
  21 #include <linux/delay.h>
  22 #include <linux/errno.h>
  23 #include <linux/slab.h>
  24 #include <linux/poll.h>
  25 #include <linux/i2c.h>
  26 #include <linux/types.h>
  27 #include <linux/init.h>
  28 #include <linux/videodev2.h>
  29 #include <media/tuner.h>
  30 #include <media/tuner-types.h>
  31 #include <media/v4l2-device.h>
  32 #include <media/v4l2-ioctl.h>
  33 #include "mt20xx.h"
  34 #include "tda8290.h"
  35 #include "tea5761.h"
  36 #include "tea5767.h"
  37 #include "tuner-xc2028.h"
  38 #include "tuner-simple.h"
  39 #include "tda9887.h"
  40 #include "xc5000.h"
  41 #include "tda18271.h"
  42 #include "xc4000.h"
  43
  44 #define UNSET (-1U)
  45
  46 /*
  47  * Driver modprobe parameters
  48  */
  49
  50 /* insmod options used at init time => read/only */
  51 static unsigned int addr;
  52 static unsigned int no_autodetect;
  53 static unsigned int show_i2c;
  54
  55 module_param(addr, int, 0444);
  56 module_param(no_autodetect, int, 0444);
  57 module_param(show_i2c, int, 0444);
  58
  59 /* insmod options used at runtime => read/write */
  60 static int tuner_debug;
  61 static unsigned int tv_range[2] = { 44, 958 };
  62 static unsigned int radio_range[2] = { 65, 108 };
  63 static char pal[] = "--";
  64 static char secam[] = "--";
  65 static char ntsc[] = "-";
  66
  67 module_param_named(debug, tuner_debug, int, 0644);
  68 module_param_array(tv_range, int, NULL, 0644);
  69 module_param_array(radio_range, int, NULL, 0644);
  70 module_param_string(pal, pal, sizeof(pal), 0644);
  71 module_param_string(secam, secam, sizeof(secam), 0644);
  72 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
  73
  74 /*
  75  * Static vars
  76  */
  77
  78 static LIST_HEAD(tuner_list);
  79 static const struct v4l2_subdev_ops tuner_ops;
  80
  81 /*
  82  * Debug macros
  83  */
  84
  85 #undef pr_fmt
  86
  87 #define pr_fmt(fmt) KBUILD_MODNAME ": %d-%04x: " fmt,           \
  88         i2c_adapter_id(t->i2c->adapter), t->i2c->addr
  89
  90
  91 #define dprintk(fmt, arg...) do {                                       \
  92         if (tuner_debug)                                                \
  93                 printk(KERN_DEBUG pr_fmt("%s: " fmt), __func__, ##arg); \
  94 } while (0)
  95
  96 /*
  97  * Internal enums/struct used inside the driver
  98  */
  99
 100 /**
 101  * enum tuner_pad_index - tuner pad index for MEDIA_ENT_F_TUNER
 102  *
 103  * @TUNER_PAD_RF_INPUT:
 104  *      Radiofrequency (RF) sink pad, usually linked to a RF connector entity.
 105  * @TUNER_PAD_OUTPUT:
 106  *      tuner video output source pad. Contains the video chrominance
 107  *      and luminance or the hole bandwidth of the signal converted to
 108  *      an Intermediate Frequency (IF) or to baseband (on zero-IF tuners).
 109  * @TUNER_PAD_AUD_OUT:
 110  *      Tuner audio output source pad. Tuners used to decode analog TV
 111  *      signals have an extra pad for audio output. Old tuners use an
 112  *      analog stage with a saw filter for the audio IF frequency. The
 113  *      output of the pad is, in this case, the audio IF, with should be
 114  *      decoded either by the bridge chipset (that's the case of cx2388x
 115  *      chipsets) or may require an external IF sound processor, like
 116  *      msp34xx. On modern silicon tuners, the audio IF decoder is usually
 117  *      incorporated at the tuner. On such case, the output of this pad
 118  *      is an audio sampled data.
 119  * @TUNER_NUM_PADS:
 120  *      Number of pads of the tuner.
 121  */
 122 enum tuner_pad_index {
 123         TUNER_PAD_RF_INPUT,
 124         TUNER_PAD_OUTPUT,
 125         TUNER_PAD_AUD_OUT,
 126         TUNER_NUM_PADS
 127 };
 128
 129 /**
 130  * enum if_vid_dec_pad_index - video IF-PLL pad index
 131  *      for MEDIA_ENT_F_IF_VID_DECODER
 132  *
 133  * @IF_VID_DEC_PAD_IF_INPUT:
 134  *      video Intermediate Frequency (IF) sink pad
 135  * @IF_VID_DEC_PAD_OUT:
 136  *      IF-PLL video output source pad. Contains the video chrominance
 137  *      and luminance IF signals.
 138  * @IF_VID_DEC_PAD_NUM_PADS:
 139  *      Number of pads of the video IF-PLL.
 140  */
 141 enum if_vid_dec_pad_index {
 142         IF_VID_DEC_PAD_IF_INPUT,
 143         IF_VID_DEC_PAD_OUT,
 144         IF_VID_DEC_PAD_NUM_PADS
 145 };
 146
 147 struct tuner {
 148         /* device */
 149         struct dvb_frontend fe;
 150         struct i2c_client   *i2c;
 151         struct v4l2_subdev  sd;
 152         struct list_head    list;
 153
 154         /* keep track of the current settings */
 155         v4l2_std_id         std;
 156         unsigned int        tv_freq;
 157         unsigned int        radio_freq;
 158         unsigned int        audmode;
 159
 160         enum v4l2_tuner_type mode;
 161         unsigned int        mode_mask; /* Combination of allowable modes */
 162
 163         bool                standby;    /* Standby mode */
 164
 165         unsigned int        type; /* chip type id */
 166         void                *config;
 167         const char          *name;
 168
 169 #if defined(CONFIG_MEDIA_CONTROLLER)
 170         struct media_pad        pad[TUNER_NUM_PADS];
 171 #endif
 172 };
 173
 174 /*
 175  * Function prototypes
 176  */
 177
 178 static void set_tv_freq(struct i2c_client *c, unsigned int freq);
 179 static void set_radio_freq(struct i2c_client *c, unsigned int freq);
 180
 181 /*
 182  * tuner attach/detach logic
 183  */
 184
 185 /* This macro allows us to probe dynamically, avoiding static links */
 186 #ifdef CONFIG_MEDIA_ATTACH
 187 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
 188         int __r = -EINVAL; \
 189         typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
 190         if (__a) { \
 191                 __r = (int) __a(ARGS); \
 192                 symbol_put(FUNCTION); \
 193         } else { \
 194                 printk(KERN_ERR "TUNER: Unable to find " \
 195                                 "symbol "#FUNCTION"()\n"); \
 196         } \
 197         __r; \
 198 })
 199
 200 static void tuner_detach(struct dvb_frontend *fe)
 201 {
 202         if (fe->ops.tuner_ops.release) {
 203                 fe->ops.tuner_ops.release(fe);
 204                 symbol_put_addr(fe->ops.tuner_ops.release);
 205         }
 206         if (fe->ops.analog_ops.release) {
 207                 fe->ops.analog_ops.release(fe);
 208                 symbol_put_addr(fe->ops.analog_ops.release);
 209         }
 210 }
 211 #else
 212 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
 213         FUNCTION(ARGS); \
 214 })
 215
 216 static void tuner_detach(struct dvb_frontend *fe)
 217 {
 218         if (fe->ops.tuner_ops.release)
 219                 fe->ops.tuner_ops.release(fe);
 220         if (fe->ops.analog_ops.release)
 221                 fe->ops.analog_ops.release(fe);
 222 }
 223 #endif
 224
 225
 226 static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
 227 {
 228         return container_of(sd, struct tuner, sd);
 229 }
 230
 231 /*
 232  * struct analog_demod_ops callbacks
 233  */
 234
 235 static void fe_set_params(struct dvb_frontend *fe,
 236                           struct analog_parameters *params)
 237 {
 238         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 239         struct tuner *t = fe->analog_demod_priv;
 240
 241         if (NULL == fe_tuner_ops->set_analog_params) {
 242                 pr_warn("Tuner frontend module has no way to set freq\n");
 243                 return;
 244         }
 245         fe_tuner_ops->set_analog_params(fe, params);
 246 }
 247
 248 static void fe_standby(struct dvb_frontend *fe)
 249 {
 250         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 251
 252         if (fe_tuner_ops->sleep)
 253                 fe_tuner_ops->sleep(fe);
 254 }
 255
 256 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
 257 {
 258         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 259         struct tuner *t = fe->analog_demod_priv;
 260
 261         if (fe_tuner_ops->set_config)
 262                 return fe_tuner_ops->set_config(fe, priv_cfg);
 263
 264         pr_warn("Tuner frontend module has no way to set config\n");
 265
 266         return 0;
 267 }
 268
 269 static void tuner_status(struct dvb_frontend *fe);
 270
 271 static const struct analog_demod_ops tuner_analog_ops = {
 272         .set_params     = fe_set_params,
 273         .standby        = fe_standby,
 274         .set_config     = fe_set_config,
 275         .tuner_status   = tuner_status
 276 };
 277
 278 /*
 279  * Functions to select between radio and TV and tuner probe/remove functions
 280  */
 281
 282 /**
 283  * set_type - Sets the tuner type for a given device
 284  *
 285  * @c:                  i2c_client descriptor
 286  * @type:               type of the tuner (e. g. tuner number)
 287  * @new_mode_mask:      Indicates if tuner supports TV and/or Radio
 288  * @new_config:         an optional parameter used by a few tuners to adjust
 289  *                      internal parameters, like LNA mode
 290  * @tuner_callback:     an optional function to be called when switching
 291  *                      to analog mode
 292  *
 293  * This function applies the tuner config to tuner specified
 294  * by tun_setup structure. It contains several per-tuner initialization "magic"
 295  */
 296 static void set_type(struct i2c_client *c, unsigned int type,
 297                      unsigned int new_mode_mask, void *new_config,
 298                      int (*tuner_callback) (void *dev, int component, int cmd, int arg))
 299 {
 300         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 301         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 302         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 303         unsigned char buffer[4];
 304         int tune_now = 1;
 305
 306         if (type == UNSET || type == TUNER_ABSENT) {
 307                 dprintk("tuner 0x%02x: Tuner type absent\n", c->addr);
 308                 return;
 309         }
 310
 311         t->type = type;
 312         t->config = new_config;
 313         if (tuner_callback != NULL) {
 314                 dprintk("defining GPIO callback\n");
 315                 t->fe.callback = tuner_callback;
 316         }
 317
 318         /* discard private data, in case set_type() was previously called */
 319         tuner_detach(&t->fe);
 320         t->fe.analog_demod_priv = NULL;
 321
 322         switch (t->type) {
 323         case TUNER_MT2032:
 324                 if (!dvb_attach(microtune_attach,
 325                            &t->fe, t->i2c->adapter, t->i2c->addr))
 326                         goto attach_failed;
 327                 break;
 328         case TUNER_PHILIPS_TDA8290:
 329         {
 330                 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
 331                                 t->i2c->addr, t->config))
 332                         goto attach_failed;
 333                 break;
 334         }
 335         case TUNER_TEA5767:
 336                 if (!dvb_attach(tea5767_attach, &t->fe,
 337                                 t->i2c->adapter, t->i2c->addr))
 338                         goto attach_failed;
 339                 t->mode_mask = T_RADIO;
 340                 break;
 341         case TUNER_TEA5761:
 342                 if (!dvb_attach(tea5761_attach, &t->fe,
 343                                 t->i2c->adapter, t->i2c->addr))
 344                         goto attach_failed;
 345                 t->mode_mask = T_RADIO;
 346                 break;
 347         case TUNER_PHILIPS_FMD1216ME_MK3:
 348         case TUNER_PHILIPS_FMD1216MEX_MK3:
 349                 buffer[0] = 0x0b;
 350                 buffer[1] = 0xdc;
 351                 buffer[2] = 0x9c;
 352                 buffer[3] = 0x60;
 353                 i2c_master_send(c, buffer, 4);
 354                 mdelay(1);
 355                 buffer[2] = 0x86;
 356                 buffer[3] = 0x54;
 357                 i2c_master_send(c, buffer, 4);
 358                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 359                                 t->i2c->adapter, t->i2c->addr, t->type))
 360                         goto attach_failed;
 361                 break;
 362         case TUNER_PHILIPS_TD1316:
 363                 buffer[0] = 0x0b;
 364                 buffer[1] = 0xdc;
 365                 buffer[2] = 0x86;
 366                 buffer[3] = 0xa4;
 367                 i2c_master_send(c, buffer, 4);
 368                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 369                                 t->i2c->adapter, t->i2c->addr, t->type))
 370                         goto attach_failed;
 371                 break;
 372         case TUNER_XC2028:
 373         {
 374                 struct xc2028_config cfg = {
 375                         .i2c_adap  = t->i2c->adapter,
 376                         .i2c_addr  = t->i2c->addr,
 377                 };
 378                 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
 379                         goto attach_failed;
 380                 tune_now = 0;
 381                 break;
 382         }
 383         case TUNER_TDA9887:
 384                 if (!dvb_attach(tda9887_attach,
 385                            &t->fe, t->i2c->adapter, t->i2c->addr))
 386                         goto attach_failed;
 387                 break;
 388         case TUNER_XC5000:
 389         {
 390                 struct xc5000_config xc5000_cfg = {
 391                         .i2c_address = t->i2c->addr,
 392                         /* if_khz will be set at dvb_attach() */
 393                         .if_khz   = 0,
 394                 };
 395
 396                 if (!dvb_attach(xc5000_attach,
 397                                 &t->fe, t->i2c->adapter, &xc5000_cfg))
 398                         goto attach_failed;
 399                 tune_now = 0;
 400                 break;
 401         }
 402         case TUNER_XC5000C:
 403         {
 404                 struct xc5000_config xc5000c_cfg = {
 405                         .i2c_address = t->i2c->addr,
 406                         /* if_khz will be set at dvb_attach() */
 407                         .if_khz   = 0,
 408                         .chip_id  = XC5000C,
 409                 };
 410
 411                 if (!dvb_attach(xc5000_attach,
 412                                 &t->fe, t->i2c->adapter, &xc5000c_cfg))
 413                         goto attach_failed;
 414                 tune_now = 0;
 415                 break;
 416         }
 417         case TUNER_NXP_TDA18271:
 418         {
 419                 struct tda18271_config cfg = {
 420                         .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
 421                 };
 422
 423                 if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr,
 424                                 t->i2c->adapter, &cfg))
 425                         goto attach_failed;
 426                 tune_now = 0;
 427                 break;
 428         }
 429         case TUNER_XC4000:
 430         {
 431                 struct xc4000_config xc4000_cfg = {
 432                         .i2c_address      = t->i2c->addr,
 433                         /* FIXME: the correct parameters will be set */
 434                         /* only when the digital dvb_attach() occurs */
 435                         .default_pm       = 0,
 436                         .dvb_amplitude    = 0,
 437                         .set_smoothedcvbs = 0,
 438                         .if_khz           = 0
 439                 };
 440                 if (!dvb_attach(xc4000_attach,
 441                                 &t->fe, t->i2c->adapter, &xc4000_cfg))
 442                         goto attach_failed;
 443                 tune_now = 0;
 444                 break;
 445         }
 446         default:
 447                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 448                                 t->i2c->adapter, t->i2c->addr, t->type))
 449                         goto attach_failed;
 450
 451                 break;
 452         }
 453
 454         if ((NULL == analog_ops->set_params) &&
 455             (fe_tuner_ops->set_analog_params)) {
 456
 457                 t->name = fe_tuner_ops->info.name;
 458
 459                 t->fe.analog_demod_priv = t;
 460                 memcpy(analog_ops, &tuner_analog_ops,
 461                        sizeof(struct analog_demod_ops));
 462
 463                 if (fe_tuner_ops->get_rf_strength)
 464                         analog_ops->has_signal = fe_tuner_ops->get_rf_strength;
 465                 if (fe_tuner_ops->get_afc)
 466                         analog_ops->get_afc = fe_tuner_ops->get_afc;
 467
 468         } else {
 469                 t->name = analog_ops->info.name;
 470         }
 471
 472 #ifdef CONFIG_MEDIA_CONTROLLER
 473         t->sd.entity.name = t->name;
 474 #endif
 475
 476         dprintk("type set to %s\n", t->name);
 477
 478         t->mode_mask = new_mode_mask;
 479
 480         /* Some tuners require more initialization setup before use,
 481            such as firmware download or device calibration.
 482            trying to set a frequency here will just fail
 483            FIXME: better to move set_freq to the tuner code. This is needed
 484            on analog tuners for PLL to properly work
 485          */
 486         if (tune_now) {
 487                 if (V4L2_TUNER_RADIO == t->mode)
 488                         set_radio_freq(c, t->radio_freq);
 489                 else
 490                         set_tv_freq(c, t->tv_freq);
 491         }
 492
 493         dprintk("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 494                   c->adapter->name, c->dev.driver->name, c->addr << 1, type,
 495                   t->mode_mask);
 496         return;
 497
 498 attach_failed:
 499         dprintk("Tuner attach for type = %d failed.\n", t->type);
 500         t->type = TUNER_ABSENT;
 501
 502         return;
 503 }
 504
 505 /**
 506  * tuner_s_type_addr - Sets the tuner type for a device
 507  *
 508  * @sd:         subdev descriptor
 509  * @tun_setup:  type to be associated to a given tuner i2c address
 510  *
 511  * This function applies the tuner config to tuner specified
 512  * by tun_setup structure.
 513  * If tuner I2C address is UNSET, then it will only set the device
 514  * if the tuner supports the mode specified in the call.
 515  * If the address is specified, the change will be applied only if
 516  * tuner I2C address matches.
 517  * The call can change the tuner number and the tuner mode.
 518  */
 519 static int tuner_s_type_addr(struct v4l2_subdev *sd,
 520                              struct tuner_setup *tun_setup)
 521 {
 522         struct tuner *t = to_tuner(sd);
 523         struct i2c_client *c = v4l2_get_subdevdata(sd);
 524
 525         dprintk("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=%p\n",
 526                         tun_setup->type,
 527                         tun_setup->addr,
 528                         tun_setup->mode_mask,
 529                         tun_setup->config);
 530
 531         if ((t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
 532             (t->mode_mask & tun_setup->mode_mask))) ||
 533             (tun_setup->addr == c->addr)) {
 534                 set_type(c, tun_setup->type, tun_setup->mode_mask,
 535                          tun_setup->config, tun_setup->tuner_callback);
 536         } else
 537                 dprintk("set addr discarded for type %i, mask %x. Asked to change tuner at addr 0x%02x, with mask %x\n",
 538                           t->type, t->mode_mask,
 539                           tun_setup->addr, tun_setup->mode_mask);
 540
 541         return 0;
 542 }
 543
 544 /**
 545  * tuner_s_config - Sets tuner configuration
 546  *
 547  * @sd:         subdev descriptor
 548  * @cfg:        tuner configuration
 549  *
 550  * Calls tuner set_config() private function to set some tuner-internal
 551  * parameters
 552  */
 553 static int tuner_s_config(struct v4l2_subdev *sd,
 554                           const struct v4l2_priv_tun_config *cfg)
 555 {
 556         struct tuner *t = to_tuner(sd);
 557         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 558
 559         if (t->type != cfg->tuner)
 560                 return 0;
 561
 562         if (analog_ops->set_config) {
 563                 analog_ops->set_config(&t->fe, cfg->priv);
 564                 return 0;
 565         }
 566
 567         dprintk("Tuner frontend module has no way to set config\n");
 568         return 0;
 569 }
 570
 571 /**
 572  * tuner_lookup - Seek for tuner adapters
 573  *
 574  * @adap:       i2c_adapter struct
 575  * @radio:      pointer to be filled if the adapter is radio
 576  * @tv:         pointer to be filled if the adapter is TV
 577  *
 578  * Search for existing radio and/or TV tuners on the given I2C adapter,
 579  * discarding demod-only adapters (tda9887).
 580  *
 581  * Note that when this function is called from tuner_probe you can be
 582  * certain no other devices will be added/deleted at the same time, I2C
 583  * core protects against that.
 584  */
 585 static void tuner_lookup(struct i2c_adapter *adap,
 586                 struct tuner **radio, struct tuner **tv)
 587 {
 588         struct tuner *pos;
 589
 590         *radio = NULL;
 591         *tv = NULL;
 592
 593         list_for_each_entry(pos, &tuner_list, list) {
 594                 int mode_mask;
 595
 596                 if (pos->i2c->adapter != adap ||
 597                     strcmp(pos->i2c->dev.driver->name, "tuner"))
 598                         continue;
 599
 600                 mode_mask = pos->mode_mask;
 601                 if (*radio == NULL && mode_mask == T_RADIO)
 602                         *radio = pos;
 603                 /* Note: currently TDA9887 is the only demod-only
 604                    device. If other devices appear then we need to
 605                    make this test more general. */
 606                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
 607                          (pos->mode_mask & T_ANALOG_TV))
 608                         *tv = pos;
 609         }
 610 }
 611
 612 /**
 613  *tuner_probe - Probes the existing tuners on an I2C bus
 614  *
 615  * @client:     i2c_client descriptor
 616  * @id:         not used
 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                        const struct i2c_device_id *id)
 629 {
 630         struct tuner *t;
 631         struct tuner *radio;
 632         struct tuner *tv;
 633 #ifdef CONFIG_MEDIA_CONTROLLER
 634         int ret;
 635 #endif
 636
 637         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
 638         if (NULL == t)
 639                 return -ENOMEM;
 640         v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
 641         t->i2c = client;
 642         t->name = "(tuner unset)";
 643         t->type = UNSET;
 644         t->audmode = V4L2_TUNER_MODE_STEREO;
 645         t->standby = true;
 646         t->radio_freq = 87.5 * 16000;   /* Initial freq range */
 647         t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
 648
 649         if (show_i2c) {
 650                 unsigned char buffer[16];
 651                 int rc;
 652
 653                 memset(buffer, 0, sizeof(buffer));
 654                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
 655                 if (rc >= 0)
 656                         pr_info("I2C RECV = %*ph\n", rc, buffer);
 657         }
 658
 659         /* autodetection code based on the i2c addr */
 660         if (!no_autodetect) {
 661                 switch (client->addr) {
 662                 case 0x10:
 663                         if (tuner_symbol_probe(tea5761_autodetection,
 664                                                t->i2c->adapter,
 665                                                t->i2c->addr) >= 0) {
 666                                 t->type = TUNER_TEA5761;
 667                                 t->mode_mask = T_RADIO;
 668                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
 669                                 if (tv)
 670                                         tv->mode_mask &= ~T_RADIO;
 671
 672                                 goto register_client;
 673                         }
 674                         kfree(t);
 675                         return -ENODEV;
 676                 case 0x42:
 677                 case 0x43:
 678                 case 0x4a:
 679                 case 0x4b:
 680                         /* If chip is not tda8290, don't register.
 681                            since it can be tda9887*/
 682                         if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
 683                                                t->i2c->addr) >= 0) {
 684                                 dprintk("tda829x detected\n");
 685                         } else {
 686                                 /* Default is being tda9887 */
 687                                 t->type = TUNER_TDA9887;
 688                                 t->mode_mask = T_RADIO | T_ANALOG_TV;
 689                                 goto register_client;
 690                         }
 691                         break;
 692                 case 0x60:
 693                         if (tuner_symbol_probe(tea5767_autodetection,
 694                                                t->i2c->adapter, t->i2c->addr)
 695                                         >= 0) {
 696                                 t->type = TUNER_TEA5767;
 697                                 t->mode_mask = T_RADIO;
 698                                 /* Sets freq to FM range */
 699                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
 700                                 if (tv)
 701                                         tv->mode_mask &= ~T_RADIO;
 702
 703                                 goto register_client;
 704                         }
 705                         break;
 706                 }
 707         }
 708
 709         /* Initializes only the first TV tuner on this adapter. Why only the
 710            first? Because there are some devices (notably the ones with TI
 711            tuners) that have more than one i2c address for the *same* device.
 712            Experience shows that, except for just one case, the first
 713            address is the right one. The exception is a Russian tuner
 714            (ACORP_Y878F). So, the desired behavior is just to enable the
 715            first found TV tuner. */
 716         tuner_lookup(t->i2c->adapter, &radio, &tv);
 717         if (tv == NULL) {
 718                 t->mode_mask = T_ANALOG_TV;
 719                 if (radio == NULL)
 720                         t->mode_mask |= T_RADIO;
 721                 dprintk("Setting mode_mask to 0x%02x\n", t->mode_mask);
 722         }
 723
 724         /* Should be just before return */
 725 register_client:
 726 #if defined(CONFIG_MEDIA_CONTROLLER)
 727         t->sd.entity.name = t->name;
 728         /*
 729          * Handle the special case where the tuner has actually
 730          * two stages: the PLL to tune into a frequency and the
 731          * IF-PLL demodulator (tda988x).
 732          */
 733         if (t->type == TUNER_TDA9887) {
 734                 t->pad[IF_VID_DEC_PAD_IF_INPUT].flags = MEDIA_PAD_FL_SINK;
 735                 t->pad[IF_VID_DEC_PAD_IF_INPUT].sig_type = PAD_SIGNAL_ANALOG;
 736                 t->pad[IF_VID_DEC_PAD_OUT].flags = MEDIA_PAD_FL_SOURCE;
 737                 t->pad[IF_VID_DEC_PAD_OUT].sig_type = PAD_SIGNAL_ANALOG;
 738                 ret = media_entity_pads_init(&t->sd.entity,
 739                                              IF_VID_DEC_PAD_NUM_PADS,
 740                                              &t->pad[0]);
 741                 t->sd.entity.function = MEDIA_ENT_F_IF_VID_DECODER;
 742         } else {
 743                 t->pad[TUNER_PAD_RF_INPUT].flags = MEDIA_PAD_FL_SINK;
 744                 t->pad[TUNER_PAD_RF_INPUT].sig_type = PAD_SIGNAL_ANALOG;
 745                 t->pad[TUNER_PAD_OUTPUT].flags = MEDIA_PAD_FL_SOURCE;
 746                 t->pad[TUNER_PAD_OUTPUT].sig_type = PAD_SIGNAL_ANALOG;
 747                 t->pad[TUNER_PAD_AUD_OUT].flags = MEDIA_PAD_FL_SOURCE;
 748                 t->pad[TUNER_PAD_AUD_OUT].sig_type = PAD_SIGNAL_AUDIO;
 749                 ret = media_entity_pads_init(&t->sd.entity, TUNER_NUM_PADS,
 750                                              &t->pad[0]);
 751                 t->sd.entity.function = MEDIA_ENT_F_TUNER;
 752         }
 753
 754         if (ret < 0) {
 755                 pr_err("failed to initialize media entity!\n");
 756                 kfree(t);
 757                 return ret;
 758         }
 759 #endif
 760         /* Sets a default mode */
 761         if (t->mode_mask & T_ANALOG_TV)
 762                 t->mode = V4L2_TUNER_ANALOG_TV;
 763         else
 764                 t->mode = V4L2_TUNER_RADIO;
 765         set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
 766         list_add_tail(&t->list, &tuner_list);
 767
 768         pr_info("Tuner %d found with type(s)%s%s.\n",
 769                    t->type,
 770                    t->mode_mask & T_RADIO ? " Radio" : "",
 771                    t->mode_mask & T_ANALOG_TV ? " TV" : "");
 772         return 0;
 773 }
 774
 775 /**
 776  * tuner_remove - detaches a tuner
 777  *
 778  * @client:     i2c_client descriptor
 779  */
 780
 781 static int tuner_remove(struct i2c_client *client)
 782 {
 783         struct tuner *t = to_tuner(i2c_get_clientdata(client));
 784
 785         v4l2_device_unregister_subdev(&t->sd);
 786         tuner_detach(&t->fe);
 787         t->fe.analog_demod_priv = NULL;
 788
 789         list_del(&t->list);
 790         kfree(t);
 791         return 0;
 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;
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;
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");