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