kernel/drivers/media/v4l2-core/tuner-core.c

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