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