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