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