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