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