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