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 #define PREFIX (t->i2c->dev.driver->name)
  47
  48 /*
  49  * Driver modprobe parameters
  50  */
  51
  52 /* insmod options used at init time => read/only */
  53 static unsigned int addr;
  54 static unsigned int no_autodetect;
  55 static unsigned int show_i2c;
  56
  57 module_param(addr, int, 0444);
  58 module_param(no_autodetect, int, 0444);
  59 module_param(show_i2c, int, 0444);
  60
  61 /* insmod options used at runtime => read/write */
  62 static int tuner_debug;
  63 static unsigned int tv_range[2] = { 44, 958 };
  64 static unsigned int radio_range[2] = { 65, 108 };
  65 static char pal[] = "--";
  66 static char secam[] = "--";
  67 static char ntsc[] = "-";
  68
  69 module_param_named(debug, tuner_debug, int, 0644);
  70 module_param_array(tv_range, int, NULL, 0644);
  71 module_param_array(radio_range, int, NULL, 0644);
  72 module_param_string(pal, pal, sizeof(pal), 0644);
  73 module_param_string(secam, secam, sizeof(secam), 0644);
  74 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
  75
  76 /*
  77  * Static vars
  78  */
  79
  80 static LIST_HEAD(tuner_list);
  81 static const struct v4l2_subdev_ops tuner_ops;
  82
  83 /*
  84  * Debug macros
  85  */
  86
  87 #define tuner_warn(fmt, arg...) do {                    \
  88         printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
  89                i2c_adapter_id(t->i2c->adapter),         \
  90                t->i2c->addr, ##arg);                    \
  91          } while (0)
  92
  93 #define tuner_info(fmt, arg...) do {                    \
  94         printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX,    \
  95                i2c_adapter_id(t->i2c->adapter),         \
  96                t->i2c->addr, ##arg);                    \
  97          } while (0)
  98
  99 #define tuner_err(fmt, arg...) do {                     \
 100         printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX,     \
 101                i2c_adapter_id(t->i2c->adapter),         \
 102                t->i2c->addr, ##arg);                    \
 103          } while (0)
 104
 105 #define tuner_dbg(fmt, arg...) do {                             \
 106         if (tuner_debug)                                        \
 107                 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX,   \
 108                        i2c_adapter_id(t->i2c->adapter),         \
 109                        t->i2c->addr, ##arg);                    \
 110          } while (0)
 111
 112 /*
 113  * Internal struct used inside the driver
 114  */
 115
 116 struct tuner {
 117         /* device */
 118         struct dvb_frontend fe;
 119         struct i2c_client   *i2c;
 120         struct v4l2_subdev  sd;
 121         struct list_head    list;
 122
 123         /* keep track of the current settings */
 124         v4l2_std_id         std;
 125         unsigned int        tv_freq;
 126         unsigned int        radio_freq;
 127         unsigned int        audmode;
 128
 129         enum v4l2_tuner_type mode;
 130         unsigned int        mode_mask; /* Combination of allowable modes */
 131
 132         bool                standby;    /* Standby mode */
 133
 134         unsigned int        type; /* chip type id */
 135         void                *config;
 136         const char          *name;
 137
 138 #if defined(CONFIG_MEDIA_CONTROLLER)
 139         struct media_pad        pad[TUNER_NUM_PADS];
 140 #endif
 141 };
 142
 143 /*
 144  * Function prototypes
 145  */
 146
 147 static void set_tv_freq(struct i2c_client *c, unsigned int freq);
 148 static void set_radio_freq(struct i2c_client *c, unsigned int freq);
 149
 150 /*
 151  * tuner attach/detach logic
 152  */
 153
 154 /* This macro allows us to probe dynamically, avoiding static links */
 155 #ifdef CONFIG_MEDIA_ATTACH
 156 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
 157         int __r = -EINVAL; \
 158         typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
 159         if (__a) { \
 160                 __r = (int) __a(ARGS); \
 161                 symbol_put(FUNCTION); \
 162         } else { \
 163                 printk(KERN_ERR "TUNER: Unable to find " \
 164                                 "symbol "#FUNCTION"()\n"); \
 165         } \
 166         __r; \
 167 })
 168
 169 static void tuner_detach(struct dvb_frontend *fe)
 170 {
 171         if (fe->ops.tuner_ops.release) {
 172                 fe->ops.tuner_ops.release(fe);
 173                 symbol_put_addr(fe->ops.tuner_ops.release);
 174         }
 175         if (fe->ops.analog_ops.release) {
 176                 fe->ops.analog_ops.release(fe);
 177                 symbol_put_addr(fe->ops.analog_ops.release);
 178         }
 179 }
 180 #else
 181 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
 182         FUNCTION(ARGS); \
 183 })
 184
 185 static void tuner_detach(struct dvb_frontend *fe)
 186 {
 187         if (fe->ops.tuner_ops.release)
 188                 fe->ops.tuner_ops.release(fe);
 189         if (fe->ops.analog_ops.release)
 190                 fe->ops.analog_ops.release(fe);
 191 }
 192 #endif
 193
 194
 195 static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
 196 {
 197         return container_of(sd, struct tuner, sd);
 198 }
 199
 200 /*
 201  * struct analog_demod_ops callbacks
 202  */
 203
 204 static void fe_set_params(struct dvb_frontend *fe,
 205                           struct analog_parameters *params)
 206 {
 207         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 208         struct tuner *t = fe->analog_demod_priv;
 209
 210         if (NULL == fe_tuner_ops->set_analog_params) {
 211                 tuner_warn("Tuner frontend module has no way to set freq\n");
 212                 return;
 213         }
 214         fe_tuner_ops->set_analog_params(fe, params);
 215 }
 216
 217 static void fe_standby(struct dvb_frontend *fe)
 218 {
 219         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 220
 221         if (fe_tuner_ops->sleep)
 222                 fe_tuner_ops->sleep(fe);
 223 }
 224
 225 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
 226 {
 227         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 228         struct tuner *t = fe->analog_demod_priv;
 229
 230         if (fe_tuner_ops->set_config)
 231                 return fe_tuner_ops->set_config(fe, priv_cfg);
 232
 233         tuner_warn("Tuner frontend module has no way to set config\n");
 234
 235         return 0;
 236 }
 237
 238 static void tuner_status(struct dvb_frontend *fe);
 239
 240 static const struct analog_demod_ops tuner_analog_ops = {
 241         .set_params     = fe_set_params,
 242         .standby        = fe_standby,
 243         .set_config     = fe_set_config,
 244         .tuner_status   = tuner_status
 245 };
 246
 247 /*
 248  * Functions to select between radio and TV and tuner probe/remove functions
 249  */
 250
 251 /**
 252  * set_type - Sets the tuner type for a given device
 253  *
 254  * @c:                  i2c_client descriptor
 255  * @type:               type of the tuner (e. g. tuner number)
 256  * @new_mode_mask:      Indicates if tuner supports TV and/or Radio
 257  * @new_config:         an optional parameter used by a few tuners to adjust
 258                         internal parameters, like LNA mode
 259  * @tuner_callback:     an optional function to be called when switching
 260  *                      to analog mode
 261  *
 262  * This function applys the tuner config to tuner specified
 263  * by tun_setup structure. It contains several per-tuner initialization "magic"
 264  */
 265 static void set_type(struct i2c_client *c, unsigned int type,
 266                      unsigned int new_mode_mask, void *new_config,
 267                      int (*tuner_callback) (void *dev, int component, int cmd, int arg))
 268 {
 269         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 270         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 271         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 272         unsigned char buffer[4];
 273         int tune_now = 1;
 274
 275         if (type == UNSET || type == TUNER_ABSENT) {
 276                 tuner_dbg("tuner 0x%02x: Tuner type absent\n", c->addr);
 277                 return;
 278         }
 279
 280         t->type = type;
 281         t->config = new_config;
 282         if (tuner_callback != NULL) {
 283                 tuner_dbg("defining GPIO callback\n");
 284                 t->fe.callback = tuner_callback;
 285         }
 286
 287         /* discard private data, in case set_type() was previously called */
 288         tuner_detach(&t->fe);
 289         t->fe.analog_demod_priv = NULL;
 290
 291         switch (t->type) {
 292         case TUNER_MT2032:
 293                 if (!dvb_attach(microtune_attach,
 294                            &t->fe, t->i2c->adapter, t->i2c->addr))
 295                         goto attach_failed;
 296                 break;
 297         case TUNER_PHILIPS_TDA8290:
 298         {
 299                 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
 300                                 t->i2c->addr, t->config))
 301                         goto attach_failed;
 302                 break;
 303         }
 304         case TUNER_TEA5767:
 305                 if (!dvb_attach(tea5767_attach, &t->fe,
 306                                 t->i2c->adapter, t->i2c->addr))
 307                         goto attach_failed;
 308                 t->mode_mask = T_RADIO;
 309                 break;
 310         case TUNER_TEA5761:
 311                 if (!dvb_attach(tea5761_attach, &t->fe,
 312                                 t->i2c->adapter, t->i2c->addr))
 313                         goto attach_failed;
 314                 t->mode_mask = T_RADIO;
 315                 break;
 316         case TUNER_PHILIPS_FMD1216ME_MK3:
 317         case TUNER_PHILIPS_FMD1216MEX_MK3:
 318                 buffer[0] = 0x0b;
 319                 buffer[1] = 0xdc;
 320                 buffer[2] = 0x9c;
 321                 buffer[3] = 0x60;
 322                 i2c_master_send(c, buffer, 4);
 323                 mdelay(1);
 324                 buffer[2] = 0x86;
 325                 buffer[3] = 0x54;
 326                 i2c_master_send(c, buffer, 4);
 327                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 328                                 t->i2c->adapter, t->i2c->addr, t->type))
 329                         goto attach_failed;
 330                 break;
 331         case TUNER_PHILIPS_TD1316:
 332                 buffer[0] = 0x0b;
 333                 buffer[1] = 0xdc;
 334                 buffer[2] = 0x86;
 335                 buffer[3] = 0xa4;
 336                 i2c_master_send(c, buffer, 4);
 337                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 338                                 t->i2c->adapter, t->i2c->addr, t->type))
 339                         goto attach_failed;
 340                 break;
 341         case TUNER_XC2028:
 342         {
 343                 struct xc2028_config cfg = {
 344                         .i2c_adap  = t->i2c->adapter,
 345                         .i2c_addr  = t->i2c->addr,
 346                 };
 347                 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
 348                         goto attach_failed;
 349                 tune_now = 0;
 350                 break;
 351         }
 352         case TUNER_TDA9887:
 353                 if (!dvb_attach(tda9887_attach,
 354                            &t->fe, t->i2c->adapter, t->i2c->addr))
 355                         goto attach_failed;
 356                 break;
 357         case TUNER_XC5000:
 358         {
 359                 struct xc5000_config xc5000_cfg = {
 360                         .i2c_address = t->i2c->addr,
 361                         /* if_khz will be set at dvb_attach() */
 362                         .if_khz   = 0,
 363                 };
 364
 365                 if (!dvb_attach(xc5000_attach,
 366                                 &t->fe, t->i2c->adapter, &xc5000_cfg))
 367                         goto attach_failed;
 368                 tune_now = 0;
 369                 break;
 370         }
 371         case TUNER_XC5000C:
 372         {
 373                 struct xc5000_config xc5000c_cfg = {
 374                         .i2c_address = t->i2c->addr,
 375                         /* if_khz will be set at dvb_attach() */
 376                         .if_khz   = 0,
 377                         .chip_id  = XC5000C,
 378                 };
 379
 380                 if (!dvb_attach(xc5000_attach,
 381                                 &t->fe, t->i2c->adapter, &xc5000c_cfg))
 382                         goto attach_failed;
 383                 tune_now = 0;
 384                 break;
 385         }
 386         case TUNER_NXP_TDA18271:
 387         {
 388                 struct tda18271_config cfg = {
 389                         .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
 390                 };
 391
 392                 if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr,
 393                                 t->i2c->adapter, &cfg))
 394                         goto attach_failed;
 395                 tune_now = 0;
 396                 break;
 397         }
 398         case TUNER_XC4000:
 399         {
 400                 struct xc4000_config xc4000_cfg = {
 401                         .i2c_address      = t->i2c->addr,
 402                         /* FIXME: the correct parameters will be set */
 403                         /* only when the digital dvb_attach() occurs */
 404                         .default_pm       = 0,
 405                         .dvb_amplitude    = 0,
 406                         .set_smoothedcvbs = 0,
 407                         .if_khz           = 0
 408                 };
 409                 if (!dvb_attach(xc4000_attach,
 410                                 &t->fe, t->i2c->adapter, &xc4000_cfg))
 411                         goto attach_failed;
 412                 tune_now = 0;
 413                 break;
 414         }
 415         default:
 416                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 417                                 t->i2c->adapter, t->i2c->addr, t->type))
 418                         goto attach_failed;
 419
 420                 break;
 421         }
 422
 423         if ((NULL == analog_ops->set_params) &&
 424             (fe_tuner_ops->set_analog_params)) {
 425
 426                 t->name = fe_tuner_ops->info.name;
 427
 428                 t->fe.analog_demod_priv = t;
 429                 memcpy(analog_ops, &tuner_analog_ops,
 430                        sizeof(struct analog_demod_ops));
 431
 432                 if (fe_tuner_ops->get_rf_strength)
 433                         analog_ops->has_signal = fe_tuner_ops->get_rf_strength;
 434                 if (fe_tuner_ops->get_afc)
 435                         analog_ops->get_afc = fe_tuner_ops->get_afc;
 436
 437         } else {
 438                 t->name = analog_ops->info.name;
 439         }
 440
 441 #ifdef CONFIG_MEDIA_CONTROLLER
 442         t->sd.entity.name = t->name;
 443 #endif
 444
 445         tuner_dbg("type set to %s\n", t->name);
 446
 447         t->mode_mask = new_mode_mask;
 448
 449         /* Some tuners require more initialization setup before use,
 450            such as firmware download or device calibration.
 451            trying to set a frequency here will just fail
 452            FIXME: better to move set_freq to the tuner code. This is needed
 453            on analog tuners for PLL to properly work
 454          */
 455         if (tune_now) {
 456                 if (V4L2_TUNER_RADIO == t->mode)
 457                         set_radio_freq(c, t->radio_freq);
 458                 else
 459                         set_tv_freq(c, t->tv_freq);
 460         }
 461
 462         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 463                   c->adapter->name, c->dev.driver->name, c->addr << 1, type,
 464                   t->mode_mask);
 465         return;
 466
 467 attach_failed:
 468         tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
 469         t->type = TUNER_ABSENT;
 470
 471         return;
 472 }
 473
 474 /**
 475  * tuner_s_type_addr - Sets the tuner type for a device
 476  *
 477  * @sd:         subdev descriptor
 478  * @tun_setup:  type to be associated to a given tuner i2c address
 479  *
 480  * This function applys the tuner config to tuner specified
 481  * by tun_setup structure.
 482  * If tuner I2C address is UNSET, then it will only set the device
 483  * if the tuner supports the mode specified in the call.
 484  * If the address is specified, the change will be applied only if
 485  * tuner I2C address matches.
 486  * The call can change the tuner number and the tuner mode.
 487  */
 488 static int tuner_s_type_addr(struct v4l2_subdev *sd,
 489                              struct tuner_setup *tun_setup)
 490 {
 491         struct tuner *t = to_tuner(sd);
 492         struct i2c_client *c = v4l2_get_subdevdata(sd);
 493
 494         tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=%p\n",
 495                         tun_setup->type,
 496                         tun_setup->addr,
 497                         tun_setup->mode_mask,
 498                         tun_setup->config);
 499
 500         if ((t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
 501             (t->mode_mask & tun_setup->mode_mask))) ||
 502             (tun_setup->addr == c->addr)) {
 503                 set_type(c, tun_setup->type, tun_setup->mode_mask,
 504                          tun_setup->config, tun_setup->tuner_callback);
 505         } else
 506                 tuner_dbg("set addr discarded for type %i, mask %x. "
 507                           "Asked to change tuner at addr 0x%02x, with mask %x\n",
 508                           t->type, t->mode_mask,
 509                           tun_setup->addr, tun_setup->mode_mask);
 510
 511         return 0;
 512 }
 513
 514 /**
 515  * tuner_s_config - Sets tuner configuration
 516  *
 517  * @sd:         subdev descriptor
 518  * @cfg:        tuner configuration
 519  *
 520  * Calls tuner set_config() private function to set some tuner-internal
 521  * parameters
 522  */
 523 static int tuner_s_config(struct v4l2_subdev *sd,
 524                           const struct v4l2_priv_tun_config *cfg)
 525 {
 526         struct tuner *t = to_tuner(sd);
 527         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 528
 529         if (t->type != cfg->tuner)
 530                 return 0;
 531
 532         if (analog_ops->set_config) {
 533                 analog_ops->set_config(&t->fe, cfg->priv);
 534                 return 0;
 535         }
 536
 537         tuner_dbg("Tuner frontend module has no way to set config\n");
 538         return 0;
 539 }
 540
 541 /**
 542  * tuner_lookup - Seek for tuner adapters
 543  *
 544  * @adap:       i2c_adapter struct
 545  * @radio:      pointer to be filled if the adapter is radio
 546  * @tv:         pointer to be filled if the adapter is TV
 547  *
 548  * Search for existing radio and/or TV tuners on the given I2C adapter,
 549  * discarding demod-only adapters (tda9887).
 550  *
 551  * Note that when this function is called from tuner_probe you can be
 552  * certain no other devices will be added/deleted at the same time, I2C
 553  * core protects against that.
 554  */
 555 static void tuner_lookup(struct i2c_adapter *adap,
 556                 struct tuner **radio, struct tuner **tv)
 557 {
 558         struct tuner *pos;
 559
 560         *radio = NULL;
 561         *tv = NULL;
 562
 563         list_for_each_entry(pos, &tuner_list, list) {
 564                 int mode_mask;
 565
 566                 if (pos->i2c->adapter != adap ||
 567                     strcmp(pos->i2c->dev.driver->name, "tuner"))
 568                         continue;
 569
 570                 mode_mask = pos->mode_mask;
 571                 if (*radio == NULL && mode_mask == T_RADIO)
 572                         *radio = pos;
 573                 /* Note: currently TDA9887 is the only demod-only
 574                    device. If other devices appear then we need to
 575                    make this test more general. */
 576                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
 577                          (pos->mode_mask & T_ANALOG_TV))
 578                         *tv = pos;
 579         }
 580 }
 581
 582 /**
 583  *tuner_probe - Probes the existing tuners on an I2C bus
 584  *
 585  * @client:     i2c_client descriptor
 586  * @id:         not used
 587  *
 588  * This routine probes for tuners at the expected I2C addresses. On most
 589  * cases, if a device answers to a given I2C address, it assumes that the
 590  * device is a tuner. On a few cases, however, an additional logic is needed
 591  * to double check if the device is really a tuner, or to identify the tuner
 592  * type, like on tea5767/5761 devices.
 593  *
 594  * During client attach, set_type is called by adapter's attach_inform callback.
 595  * set_type must then be completed by tuner_probe.
 596  */
 597 static int tuner_probe(struct i2c_client *client,
 598                        const struct i2c_device_id *id)
 599 {
 600         struct tuner *t;
 601         struct tuner *radio;
 602         struct tuner *tv;
 603 #ifdef CONFIG_MEDIA_CONTROLLER
 604         int ret;
 605 #endif
 606
 607         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
 608         if (NULL == t)
 609                 return -ENOMEM;
 610         v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
 611         t->i2c = client;
 612         t->name = "(tuner unset)";
 613         t->type = UNSET;
 614         t->audmode = V4L2_TUNER_MODE_STEREO;
 615         t->standby = true;
 616         t->radio_freq = 87.5 * 16000;   /* Initial freq range */
 617         t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
 618
 619         if (show_i2c) {
 620                 unsigned char buffer[16];
 621                 int i, rc;
 622
 623                 memset(buffer, 0, sizeof(buffer));
 624                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
 625                 tuner_info("I2C RECV = ");
 626                 for (i = 0; i < rc; i++)
 627                         printk(KERN_CONT "%02x ", buffer[i]);
 628                 printk("\n");
 629         }
 630
 631         /* autodetection code based on the i2c addr */
 632         if (!no_autodetect) {
 633                 switch (client->addr) {
 634                 case 0x10:
 635                         if (tuner_symbol_probe(tea5761_autodetection,
 636                                                t->i2c->adapter,
 637                                                t->i2c->addr) >= 0) {
 638                                 t->type = TUNER_TEA5761;
 639                                 t->mode_mask = T_RADIO;
 640                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
 641                                 if (tv)
 642                                         tv->mode_mask &= ~T_RADIO;
 643
 644                                 goto register_client;
 645                         }
 646                         kfree(t);
 647                         return -ENODEV;
 648                 case 0x42:
 649                 case 0x43:
 650                 case 0x4a:
 651                 case 0x4b:
 652                         /* If chip is not tda8290, don't register.
 653                            since it can be tda9887*/
 654                         if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
 655                                                t->i2c->addr) >= 0) {
 656                                 tuner_dbg("tda829x detected\n");
 657                         } else {
 658                                 /* Default is being tda9887 */
 659                                 t->type = TUNER_TDA9887;
 660                                 t->mode_mask = T_RADIO | T_ANALOG_TV;
 661                                 goto register_client;
 662                         }
 663                         break;
 664                 case 0x60:
 665                         if (tuner_symbol_probe(tea5767_autodetection,
 666                                                t->i2c->adapter, t->i2c->addr)
 667                                         >= 0) {
 668                                 t->type = TUNER_TEA5767;
 669                                 t->mode_mask = T_RADIO;
 670                                 /* Sets freq to FM range */
 671                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
 672                                 if (tv)
 673                                         tv->mode_mask &= ~T_RADIO;
 674
 675                                 goto register_client;
 676                         }
 677                         break;
 678                 }
 679         }
 680
 681         /* Initializes only the first TV tuner on this adapter. Why only the
 682            first? Because there are some devices (notably the ones with TI
 683            tuners) that have more than one i2c address for the *same* device.
 684            Experience shows that, except for just one case, the first
 685            address is the right one. The exception is a Russian tuner
 686            (ACORP_Y878F). So, the desired behavior is just to enable the
 687            first found TV tuner. */
 688         tuner_lookup(t->i2c->adapter, &radio, &tv);
 689         if (tv == NULL) {
 690                 t->mode_mask = T_ANALOG_TV;
 691                 if (radio == NULL)
 692                         t->mode_mask |= T_RADIO;
 693                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
 694         }
 695
 696         /* Should be just before return */
 697 register_client:
 698 #if defined(CONFIG_MEDIA_CONTROLLER)
 699         t->sd.entity.name = t->name;
 700         /*
 701          * Handle the special case where the tuner has actually
 702          * two stages: the PLL to tune into a frequency and the
 703          * IF-PLL demodulator (tda988x).
 704          */
 705         if (t->type == TUNER_TDA9887) {
 706                 t->pad[IF_VID_DEC_PAD_IF_INPUT].flags = MEDIA_PAD_FL_SINK;
 707                 t->pad[IF_VID_DEC_PAD_OUT].flags = MEDIA_PAD_FL_SOURCE;
 708                 ret = media_entity_pads_init(&t->sd.entity,
 709                                              IF_VID_DEC_PAD_NUM_PADS,
 710                                              &t->pad[0]);
 711                 t->sd.entity.function = MEDIA_ENT_F_IF_VID_DECODER;
 712         } else {
 713                 t->pad[TUNER_PAD_RF_INPUT].flags = MEDIA_PAD_FL_SINK;
 714                 t->pad[TUNER_PAD_OUTPUT].flags = MEDIA_PAD_FL_SOURCE;
 715                 t->pad[TUNER_PAD_AUD_OUT].flags = MEDIA_PAD_FL_SOURCE;
 716                 ret = media_entity_pads_init(&t->sd.entity, TUNER_NUM_PADS,
 717                                              &t->pad[0]);
 718                 t->sd.entity.function = MEDIA_ENT_F_TUNER;
 719         }
 720
 721         if (ret < 0) {
 722                 tuner_err("failed to initialize media entity!\n");
 723                 kfree(t);
 724                 return ret;
 725         }
 726 #endif
 727         /* Sets a default mode */
 728         if (t->mode_mask & T_ANALOG_TV)
 729                 t->mode = V4L2_TUNER_ANALOG_TV;
 730         else
 731                 t->mode = V4L2_TUNER_RADIO;
 732         set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
 733         list_add_tail(&t->list, &tuner_list);
 734
 735         tuner_info("Tuner %d found with type(s)%s%s.\n",
 736                    t->type,
 737                    t->mode_mask & T_RADIO ? " Radio" : "",
 738                    t->mode_mask & T_ANALOG_TV ? " TV" : "");
 739         return 0;
 740 }
 741
 742 /**
 743  * tuner_remove - detaches a tuner
 744  *
 745  * @client:     i2c_client descriptor
 746  */
 747
 748 static int tuner_remove(struct i2c_client *client)
 749 {
 750         struct tuner *t = to_tuner(i2c_get_clientdata(client));
 751
 752         v4l2_device_unregister_subdev(&t->sd);
 753         tuner_detach(&t->fe);
 754         t->fe.analog_demod_priv = NULL;
 755
 756         list_del(&t->list);
 757         kfree(t);
 758         return 0;
 759 }
 760
 761 /*
 762  * Functions to switch between Radio and TV
 763  *
 764  * A few cards have a separate I2C tuner for radio. Those routines
 765  * take care of switching between TV/Radio mode, filtering only the
 766  * commands that apply to the Radio or TV tuner.
 767  */
 768
 769 /**
 770  * check_mode - Verify if tuner supports the requested mode
 771  * @t: a pointer to the module's internal struct_tuner
 772  *
 773  * This function checks if the tuner is capable of tuning analog TV,
 774  * digital TV or radio, depending on what the caller wants. If the
 775  * tuner can't support that mode, it returns -EINVAL. Otherwise, it
 776  * returns 0.
 777  * This function is needed for boards that have a separate tuner for
 778  * radio (like devices with tea5767).
 779  * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to
 780  *       select a TV frequency. So, t_mode = T_ANALOG_TV could actually
 781  *       be used to represent a Digital TV too.
 782  */
 783 static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
 784 {
 785         int t_mode;
 786         if (mode == V4L2_TUNER_RADIO)
 787                 t_mode = T_RADIO;
 788         else
 789                 t_mode = T_ANALOG_TV;
 790
 791         if ((t_mode & t->mode_mask) == 0)
 792                 return -EINVAL;
 793
 794         return 0;
 795 }
 796
 797 /**
 798  * set_mode - Switch tuner to other mode.
 799  * @t:          a pointer to the module's internal struct_tuner
 800  * @mode:       enum v4l2_type (radio or TV)
 801  *
 802  * If tuner doesn't support the needed mode (radio or TV), prints a
 803  * debug message and returns -EINVAL, changing its state to standby.
 804  * Otherwise, changes the mode and returns 0.
 805  */
 806 static int set_mode(struct tuner *t, enum v4l2_tuner_type mode)
 807 {
 808         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 809
 810         if (mode != t->mode) {
 811                 if (check_mode(t, mode) == -EINVAL) {
 812                         tuner_dbg("Tuner doesn't support mode %d. "
 813                                   "Putting tuner to sleep\n", mode);
 814                         t->standby = true;
 815                         if (analog_ops->standby)
 816                                 analog_ops->standby(&t->fe);
 817                         return -EINVAL;
 818                 }
 819                 t->mode = mode;
 820                 tuner_dbg("Changing to mode %d\n", mode);
 821         }
 822         return 0;
 823 }
 824
 825 /**
 826  * set_freq - Set the tuner to the desired frequency.
 827  * @t:          a pointer to the module's internal struct_tuner
 828  * @freq:       frequency to set (0 means to use the current frequency)
 829  */
 830 static void set_freq(struct tuner *t, unsigned int freq)
 831 {
 832         struct i2c_client *client = v4l2_get_subdevdata(&t->sd);
 833
 834         if (t->mode == V4L2_TUNER_RADIO) {
 835                 if (!freq)
 836                         freq = t->radio_freq;
 837                 set_radio_freq(client, freq);
 838         } else {
 839                 if (!freq)
 840                         freq = t->tv_freq;
 841                 set_tv_freq(client, freq);
 842         }
 843 }
 844
 845 /*
 846  * Functions that are specific for TV mode
 847  */
 848
 849 /**
 850  * set_tv_freq - Set tuner frequency,  freq in Units of 62.5 kHz = 1/16MHz
 851  *
 852  * @c:  i2c_client descriptor
 853  * @freq: frequency
 854  */
 855 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
 856 {
 857         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 858         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 859
 860         struct analog_parameters params = {
 861                 .mode      = t->mode,
 862                 .audmode   = t->audmode,
 863                 .std       = t->std
 864         };
 865
 866         if (t->type == UNSET) {
 867                 tuner_warn("tuner type not set\n");
 868                 return;
 869         }
 870         if (NULL == analog_ops->set_params) {
 871                 tuner_warn("Tuner has no way to set tv freq\n");
 872                 return;
 873         }
 874         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
 875                 tuner_dbg("TV freq (%d.%02d) out of range (%d-%d)\n",
 876                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
 877                            tv_range[1]);
 878                 /* V4L2 spec: if the freq is not possible then the closest
 879                    possible value should be selected */
 880                 if (freq < tv_range[0] * 16)
 881                         freq = tv_range[0] * 16;
 882                 else
 883                         freq = tv_range[1] * 16;
 884         }
 885         params.frequency = freq;
 886         tuner_dbg("tv freq set to %d.%02d\n",
 887                         freq / 16, freq % 16 * 100 / 16);
 888         t->tv_freq = freq;
 889         t->standby = false;
 890
 891         analog_ops->set_params(&t->fe, &params);
 892 }
 893
 894 /**
 895  * tuner_fixup_std - force a given video standard variant
 896  *
 897  * @t: tuner internal struct
 898  * @std:        TV standard
 899  *
 900  * A few devices or drivers have problem to detect some standard variations.
 901  * On other operational systems, the drivers generally have a per-country
 902  * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
 903  * such hacks. Instead, it relies on a proper video standard selection from
 904  * the userspace application. However, as some apps are buggy, not allowing
 905  * to distinguish all video standard variations, a modprobe parameter can
 906  * be used to force a video standard match.
 907  */
 908 static v4l2_std_id tuner_fixup_std(struct tuner *t, v4l2_std_id std)
 909 {
 910         if (pal[0] != '-' && (std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 911                 switch (pal[0]) {
 912                 case '6':
 913                         return V4L2_STD_PAL_60;
 914                 case 'b':
 915                 case 'B':
 916                 case 'g':
 917                 case 'G':
 918                         return V4L2_STD_PAL_BG;
 919                 case 'i':
 920                 case 'I':
 921                         return V4L2_STD_PAL_I;
 922                 case 'd':
 923                 case 'D':
 924                 case 'k':
 925                 case 'K':
 926                         return V4L2_STD_PAL_DK;
 927                 case 'M':
 928                 case 'm':
 929                         return V4L2_STD_PAL_M;
 930                 case 'N':
 931                 case 'n':
 932                         if (pal[1] == 'c' || pal[1] == 'C')
 933                                 return V4L2_STD_PAL_Nc;
 934                         return V4L2_STD_PAL_N;
 935                 default:
 936                         tuner_warn("pal= argument not recognised\n");
 937                         break;
 938                 }
 939         }
 940         if (secam[0] != '-' && (std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 941                 switch (secam[0]) {
 942                 case 'b':
 943                 case 'B':
 944                 case 'g':
 945                 case 'G':
 946                 case 'h':
 947                 case 'H':
 948                         return V4L2_STD_SECAM_B |
 949                                V4L2_STD_SECAM_G |
 950                                V4L2_STD_SECAM_H;
 951                 case 'd':
 952                 case 'D':
 953                 case 'k':
 954                 case 'K':
 955                         return V4L2_STD_SECAM_DK;
 956                 case 'l':
 957                 case 'L':
 958                         if ((secam[1] == 'C') || (secam[1] == 'c'))
 959                                 return V4L2_STD_SECAM_LC;
 960                         return V4L2_STD_SECAM_L;
 961                 default:
 962                         tuner_warn("secam= argument not recognised\n");
 963                         break;
 964                 }
 965         }
 966
 967         if (ntsc[0] != '-' && (std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 968                 switch (ntsc[0]) {
 969                 case 'm':
 970                 case 'M':
 971                         return V4L2_STD_NTSC_M;
 972                 case 'j':
 973                 case 'J':
 974                         return V4L2_STD_NTSC_M_JP;
 975                 case 'k':
 976                 case 'K':
 977                         return V4L2_STD_NTSC_M_KR;
 978                 default:
 979                         tuner_info("ntsc= argument not recognised\n");
 980                         break;
 981                 }
 982         }
 983         return std;
 984 }
 985
 986 /*
 987  * Functions that are specific for Radio mode
 988  */
 989
 990 /**
 991  * set_radio_freq - Set tuner frequency,  freq in Units of 62.5 Hz  = 1/16kHz
 992  *
 993  * @c:  i2c_client descriptor
 994  * @freq: frequency
 995  */
 996 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
 997 {
 998         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 999         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1000
1001         struct analog_parameters params = {
1002                 .mode      = t->mode,
1003                 .audmode   = t->audmode,
1004                 .std       = t->std
1005         };
1006
1007         if (t->type == UNSET) {
1008                 tuner_warn("tuner type not set\n");
1009                 return;
1010         }
1011         if (NULL == analog_ops->set_params) {
1012                 tuner_warn("tuner has no way to set radio frequency\n");
1013                 return;
1014         }
1015         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
1016                 tuner_dbg("radio freq (%d.%02d) out of range (%d-%d)\n",
1017                            freq / 16000, freq % 16000 * 100 / 16000,
1018                            radio_range[0], radio_range[1]);
1019                 /* V4L2 spec: if the freq is not possible then the closest
1020                    possible value should be selected */
1021                 if (freq < radio_range[0] * 16000)
1022                         freq = radio_range[0] * 16000;
1023                 else
1024                         freq = radio_range[1] * 16000;
1025         }
1026         params.frequency = freq;
1027         tuner_dbg("radio freq set to %d.%02d\n",
1028                         freq / 16000, freq % 16000 * 100 / 16000);
1029         t->radio_freq = freq;
1030         t->standby = false;
1031
1032         analog_ops->set_params(&t->fe, &params);
1033         /*
1034          * The tuner driver might decide to change the audmode if it only
1035          * supports stereo, so update t->audmode.
1036          */
1037         t->audmode = params.audmode;
1038 }
1039
1040 /*
1041  * Debug function for reporting tuner status to userspace
1042  */
1043
1044 /**
1045  * tuner_status - Dumps the current tuner status at dmesg
1046  * @fe: pointer to struct dvb_frontend
1047  *
1048  * This callback is used only for driver debug purposes, answering to
1049  * VIDIOC_LOG_STATUS. No changes should happen on this call.
1050  */
1051 static void tuner_status(struct dvb_frontend *fe)
1052 {
1053         struct tuner *t = fe->analog_demod_priv;
1054         unsigned long freq, freq_fraction;
1055         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
1056         struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
1057         const char *p;
1058
1059         switch (t->mode) {
1060         case V4L2_TUNER_RADIO:
1061                 p = "radio";
1062                 break;
1063         case V4L2_TUNER_DIGITAL_TV: /* Used by mt20xx */
1064                 p = "digital TV";
1065                 break;
1066         case V4L2_TUNER_ANALOG_TV:
1067         default:
1068                 p = "analog TV";
1069                 break;
1070         }
1071         if (t->mode == V4L2_TUNER_RADIO) {
1072                 freq = t->radio_freq / 16000;
1073                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
1074         } else {
1075                 freq = t->tv_freq / 16;
1076                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
1077         }
1078         tuner_info("Tuner mode:      %s%s\n", p,
1079                    t->standby ? " on standby mode" : "");
1080         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
1081         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
1082         if (t->mode != V4L2_TUNER_RADIO)
1083                 return;
1084         if (fe_tuner_ops->get_status) {
1085                 u32 tuner_status;
1086
1087                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1088                 if (tuner_status & TUNER_STATUS_LOCKED)
1089                         tuner_info("Tuner is locked.\n");
1090                 if (tuner_status & TUNER_STATUS_STEREO)
1091                         tuner_info("Stereo:          yes\n");
1092         }
1093         if (analog_ops->has_signal) {
1094                 u16 signal;
1095
1096                 if (!analog_ops->has_signal(fe, &signal))
1097                         tuner_info("Signal strength: %hu\n", signal);
1098         }
1099 }
1100
1101 /*
1102  * Function to splicitly change mode to radio. Probably not needed anymore
1103  */
1104
1105 static int tuner_s_radio(struct v4l2_subdev *sd)
1106 {
1107         struct tuner *t = to_tuner(sd);
1108
1109         if (set_mode(t, V4L2_TUNER_RADIO) == 0)
1110                 set_freq(t, 0);
1111         return 0;
1112 }
1113
1114 /*
1115  * Tuner callbacks to handle userspace ioctl's
1116  */
1117
1118 /**
1119  * tuner_s_power - controls the power state of the tuner
1120  * @sd: pointer to struct v4l2_subdev
1121  * @on: a zero value puts the tuner to sleep, non-zero wakes it up
1122  */
1123 static int tuner_s_power(struct v4l2_subdev *sd, int on)
1124 {
1125         struct tuner *t = to_tuner(sd);
1126         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1127
1128         if (on) {
1129                 if (t->standby && set_mode(t, t->mode) == 0) {
1130                         tuner_dbg("Waking up tuner\n");
1131                         set_freq(t, 0);
1132                 }
1133                 return 0;
1134         }
1135
1136         tuner_dbg("Putting tuner to sleep\n");
1137         t->standby = true;
1138         if (analog_ops->standby)
1139                 analog_ops->standby(&t->fe);
1140         return 0;
1141 }
1142
1143 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1144 {
1145         struct tuner *t = to_tuner(sd);
1146
1147         if (set_mode(t, V4L2_TUNER_ANALOG_TV))
1148                 return 0;
1149
1150         t->std = tuner_fixup_std(t, std);
1151         if (t->std != std)
1152                 tuner_dbg("Fixup standard %llx to %llx\n", std, t->std);
1153         set_freq(t, 0);
1154         return 0;
1155 }
1156
1157 static int tuner_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f)
1158 {
1159         struct tuner *t = to_tuner(sd);
1160
1161         if (set_mode(t, f->type) == 0)
1162                 set_freq(t, f->frequency);
1163         return 0;
1164 }
1165
1166 /**
1167  * tuner_g_frequency - Get the tuned frequency for the tuner
1168  * @sd: pointer to struct v4l2_subdev
1169  * @f: pointer to struct v4l2_frequency
1170  *
1171  * At return, the structure f will be filled with tuner frequency
1172  * if the tuner matches the f->type.
1173  * Note: f->type should be initialized before calling it.
1174  * This is done by either video_ioctl2 or by the bridge driver.
1175  */
1176 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1177 {
1178         struct tuner *t = to_tuner(sd);
1179         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1180
1181         if (check_mode(t, f->type) == -EINVAL)
1182                 return 0;
1183         if (f->type == t->mode && fe_tuner_ops->get_frequency && !t->standby) {
1184                 u32 abs_freq;
1185
1186                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1187                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1188                         DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1189                         DIV_ROUND_CLOSEST(abs_freq, 62500);
1190         } else {
1191                 f->frequency = (V4L2_TUNER_RADIO == f->type) ?
1192                         t->radio_freq : t->tv_freq;
1193         }
1194         return 0;
1195 }
1196
1197 /**
1198  * tuner_g_tuner - Fill in tuner information
1199  * @sd: pointer to struct v4l2_subdev
1200  * @vt: pointer to struct v4l2_tuner
1201  *
1202  * At return, the structure vt will be filled with tuner information
1203  * if the tuner matches vt->type.
1204  * Note: vt->type should be initialized before calling it.
1205  * This is done by either video_ioctl2 or by the bridge driver.
1206  */
1207 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1208 {
1209         struct tuner *t = to_tuner(sd);
1210         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1211         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1212
1213         if (check_mode(t, vt->type) == -EINVAL)
1214                 return 0;
1215         if (vt->type == t->mode && analog_ops->get_afc)
1216                 analog_ops->get_afc(&t->fe, &vt->afc);
1217         if (vt->type == t->mode && analog_ops->has_signal) {
1218                 u16 signal = (u16)vt->signal;
1219
1220                 if (!analog_ops->has_signal(&t->fe, &signal))
1221                         vt->signal = signal;
1222         }
1223         if (vt->type != V4L2_TUNER_RADIO) {
1224                 vt->capability |= V4L2_TUNER_CAP_NORM;
1225                 vt->rangelow = tv_range[0] * 16;
1226                 vt->rangehigh = tv_range[1] * 16;
1227                 return 0;
1228         }
1229
1230         /* radio mode */
1231         if (vt->type == t->mode) {
1232                 vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1233                 if (fe_tuner_ops->get_status) {
1234                         u32 tuner_status;
1235
1236                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
1237                         vt->rxsubchans =
1238                                 (tuner_status & TUNER_STATUS_STEREO) ?
1239                                 V4L2_TUNER_SUB_STEREO :
1240                                 V4L2_TUNER_SUB_MONO;
1241                 }
1242                 vt->audmode = t->audmode;
1243         }
1244         vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1245         vt->rangelow = radio_range[0] * 16000;
1246         vt->rangehigh = radio_range[1] * 16000;
1247
1248         return 0;
1249 }
1250
1251 /**
1252  * tuner_s_tuner - Set the tuner's audio mode
1253  * @sd: pointer to struct v4l2_subdev
1254  * @vt: pointer to struct v4l2_tuner
1255  *
1256  * Sets the audio mode if the tuner matches vt->type.
1257  * Note: vt->type should be initialized before calling it.
1258  * This is done by either video_ioctl2 or by the bridge driver.
1259  */
1260 static int tuner_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt)
1261 {
1262         struct tuner *t = to_tuner(sd);
1263
1264         if (set_mode(t, vt->type))
1265                 return 0;
1266
1267         if (t->mode == V4L2_TUNER_RADIO) {
1268                 t->audmode = vt->audmode;
1269                 /*
1270                  * For radio audmode can only be mono or stereo. Map any
1271                  * other values to stereo. The actual tuner driver that is
1272                  * called in set_radio_freq can decide to limit the audmode to
1273                  * mono if only mono is supported.
1274                  */
1275                 if (t->audmode != V4L2_TUNER_MODE_MONO &&
1276                     t->audmode != V4L2_TUNER_MODE_STEREO)
1277                         t->audmode = V4L2_TUNER_MODE_STEREO;
1278         }
1279         set_freq(t, 0);
1280
1281         return 0;
1282 }
1283
1284 static int tuner_log_status(struct v4l2_subdev *sd)
1285 {
1286         struct tuner *t = to_tuner(sd);
1287         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1288
1289         if (analog_ops->tuner_status)
1290                 analog_ops->tuner_status(&t->fe);
1291         return 0;
1292 }
1293
1294 #ifdef CONFIG_PM_SLEEP
1295 static int tuner_suspend(struct device *dev)
1296 {
1297         struct i2c_client *c = to_i2c_client(dev);
1298         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1299         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1300
1301         tuner_dbg("suspend\n");
1302
1303         if (t->fe.ops.tuner_ops.suspend)
1304                 t->fe.ops.tuner_ops.suspend(&t->fe);
1305         else if (!t->standby && analog_ops->standby)
1306                 analog_ops->standby(&t->fe);
1307
1308         return 0;
1309 }
1310
1311 static int tuner_resume(struct device *dev)
1312 {
1313         struct i2c_client *c = to_i2c_client(dev);
1314         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1315
1316         tuner_dbg("resume\n");
1317
1318         if (t->fe.ops.tuner_ops.resume)
1319                 t->fe.ops.tuner_ops.resume(&t->fe);
1320         else if (!t->standby)
1321                 if (set_mode(t, t->mode) == 0)
1322                         set_freq(t, 0);
1323
1324         return 0;
1325 }
1326 #endif
1327
1328 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1329 {
1330         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1331
1332         /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1333            to handle it here.
1334            There must be a better way of doing this... */
1335         switch (cmd) {
1336         case TUNER_SET_CONFIG:
1337                 return tuner_s_config(sd, arg);
1338         }
1339         return -ENOIOCTLCMD;
1340 }
1341
1342 /*
1343  * Callback structs
1344  */
1345
1346 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1347         .log_status = tuner_log_status,
1348         .s_power = tuner_s_power,
1349 };
1350
1351 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1352         .s_radio = tuner_s_radio,
1353         .g_tuner = tuner_g_tuner,
1354         .s_tuner = tuner_s_tuner,
1355         .s_frequency = tuner_s_frequency,
1356         .g_frequency = tuner_g_frequency,
1357         .s_type_addr = tuner_s_type_addr,
1358         .s_config = tuner_s_config,
1359 };
1360
1361 static const struct v4l2_subdev_video_ops tuner_video_ops = {
1362         .s_std = tuner_s_std,
1363 };
1364
1365 static const struct v4l2_subdev_ops tuner_ops = {
1366         .core = &tuner_core_ops,
1367         .tuner = &tuner_tuner_ops,
1368         .video = &tuner_video_ops,
1369 };
1370
1371 /*
1372  * I2C structs and module init functions
1373  */
1374
1375 static const struct dev_pm_ops tuner_pm_ops = {
1376         SET_SYSTEM_SLEEP_PM_OPS(tuner_suspend, tuner_resume)
1377 };
1378
1379 static const struct i2c_device_id tuner_id[] = {
1380         { "tuner", }, /* autodetect */
1381         { }
1382 };
1383 MODULE_DEVICE_TABLE(i2c, tuner_id);
1384
1385 static struct i2c_driver tuner_driver = {
1386         .driver = {
1387                 .name   = "tuner",
1388                 .pm     = &tuner_pm_ops,
1389         },
1390         .probe          = tuner_probe,
1391         .remove         = tuner_remove,
1392         .command        = tuner_command,
1393         .id_table       = tuner_id,
1394 };
1395
1396 module_i2c_driver(tuner_driver);
1397
1398 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1399 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1400 MODULE_LICENSE("GPL");