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  * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to
 718  *       select a TV frequency. So, t_mode = T_ANALOG_TV could actually
 719  *       be used to represent a Digital TV too.
 720  */
 721 static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
 722 {
 723         int t_mode;
 724         if (mode == V4L2_TUNER_RADIO)
 725                 t_mode = T_RADIO;
 726         else
 727                 t_mode = T_ANALOG_TV;
 728
 729         if ((t_mode & t->mode_mask) == 0)
 730                 return -EINVAL;
 731
 732         return 0;
 733 }
 734
 735 /**
 736  * set_mode - Switch tuner to other mode.
 737  * @t:          a pointer to the module's internal struct_tuner
 738  * @mode:       enum v4l2_type (radio or TV)
 739  *
 740  * If tuner doesn't support the needed mode (radio or TV), prints a
 741  * debug message and returns -EINVAL, changing its state to standby.
 742  * Otherwise, changes the mode and returns 0.
 743  */
 744 static int set_mode(struct tuner *t, enum v4l2_tuner_type mode)
 745 {
 746         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 747
 748         if (mode != t->mode) {
 749                 if (check_mode(t, mode) == -EINVAL) {
 750                         tuner_dbg("Tuner doesn't support mode %d. "
 751                                   "Putting tuner to sleep\n", mode);
 752                         t->standby = true;
 753                         if (analog_ops->standby)
 754                                 analog_ops->standby(&t->fe);
 755                         return -EINVAL;
 756                 }
 757                 t->mode = mode;
 758                 tuner_dbg("Changing to mode %d\n", mode);
 759         }
 760         return 0;
 761 }
 762
 763 /**
 764  * set_freq - Set the tuner to the desired frequency.
 765  * @t:          a pointer to the module's internal struct_tuner
 766  * @freq:       frequency to set (0 means to use the current frequency)
 767  */
 768 static void set_freq(struct tuner *t, unsigned int freq)
 769 {
 770         struct i2c_client *client = v4l2_get_subdevdata(&t->sd);
 771
 772         if (t->mode == V4L2_TUNER_RADIO) {
 773                 if (!freq)
 774                         freq = t->radio_freq;
 775                 set_radio_freq(client, freq);
 776         } else {
 777                 if (!freq)
 778                         freq = t->tv_freq;
 779                 set_tv_freq(client, freq);
 780         }
 781 }
 782
 783 /*
 784  * Functions that are specific for TV mode
 785  */
 786
 787 /**
 788  * set_tv_freq - Set tuner frequency,  freq in Units of 62.5 kHz = 1/16MHz
 789  *
 790  * @c:  i2c_client descriptor
 791  * @freq: frequency
 792  */
 793 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
 794 {
 795         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 796         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 797
 798         struct analog_parameters params = {
 799                 .mode      = t->mode,
 800                 .audmode   = t->audmode,
 801                 .std       = t->std
 802         };
 803
 804         if (t->type == UNSET) {
 805                 tuner_warn("tuner type not set\n");
 806                 return;
 807         }
 808         if (NULL == analog_ops->set_params) {
 809                 tuner_warn("Tuner has no way to set tv freq\n");
 810                 return;
 811         }
 812         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
 813                 tuner_dbg("TV freq (%d.%02d) out of range (%d-%d)\n",
 814                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
 815                            tv_range[1]);
 816                 /* V4L2 spec: if the freq is not possible then the closest
 817                    possible value should be selected */
 818                 if (freq < tv_range[0] * 16)
 819                         freq = tv_range[0] * 16;
 820                 else
 821                         freq = tv_range[1] * 16;
 822         }
 823         params.frequency = freq;
 824         tuner_dbg("tv freq set to %d.%02d\n",
 825                         freq / 16, freq % 16 * 100 / 16);
 826         t->tv_freq = freq;
 827         t->standby = false;
 828
 829         analog_ops->set_params(&t->fe, &params);
 830 }
 831
 832 /**
 833  * tuner_fixup_std - force a given video standard variant
 834  *
 835  * @t: tuner internal struct
 836  * @std:        TV standard
 837  *
 838  * A few devices or drivers have problem to detect some standard variations.
 839  * On other operational systems, the drivers generally have a per-country
 840  * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
 841  * such hacks. Instead, it relies on a proper video standard selection from
 842  * the userspace application. However, as some apps are buggy, not allowing
 843  * to distinguish all video standard variations, a modprobe parameter can
 844  * be used to force a video standard match.
 845  */
 846 static v4l2_std_id tuner_fixup_std(struct tuner *t, v4l2_std_id std)
 847 {
 848         if (pal[0] != '-' && (std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 849                 switch (pal[0]) {
 850                 case '6':
 851                         return V4L2_STD_PAL_60;
 852                 case 'b':
 853                 case 'B':
 854                 case 'g':
 855                 case 'G':
 856                         return V4L2_STD_PAL_BG;
 857                 case 'i':
 858                 case 'I':
 859                         return V4L2_STD_PAL_I;
 860                 case 'd':
 861                 case 'D':
 862                 case 'k':
 863                 case 'K':
 864                         return V4L2_STD_PAL_DK;
 865                 case 'M':
 866                 case 'm':
 867                         return V4L2_STD_PAL_M;
 868                 case 'N':
 869                 case 'n':
 870                         if (pal[1] == 'c' || pal[1] == 'C')
 871                                 return V4L2_STD_PAL_Nc;
 872                         return V4L2_STD_PAL_N;
 873                 default:
 874                         tuner_warn("pal= argument not recognised\n");
 875                         break;
 876                 }
 877         }
 878         if (secam[0] != '-' && (std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 879                 switch (secam[0]) {
 880                 case 'b':
 881                 case 'B':
 882                 case 'g':
 883                 case 'G':
 884                 case 'h':
 885                 case 'H':
 886                         return V4L2_STD_SECAM_B |
 887                                V4L2_STD_SECAM_G |
 888                                V4L2_STD_SECAM_H;
 889                 case 'd':
 890                 case 'D':
 891                 case 'k':
 892                 case 'K':
 893                         return V4L2_STD_SECAM_DK;
 894                 case 'l':
 895                 case 'L':
 896                         if ((secam[1] == 'C') || (secam[1] == 'c'))
 897                                 return V4L2_STD_SECAM_LC;
 898                         return V4L2_STD_SECAM_L;
 899                 default:
 900                         tuner_warn("secam= argument not recognised\n");
 901                         break;
 902                 }
 903         }
 904
 905         if (ntsc[0] != '-' && (std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 906                 switch (ntsc[0]) {
 907                 case 'm':
 908                 case 'M':
 909                         return V4L2_STD_NTSC_M;
 910                 case 'j':
 911                 case 'J':
 912                         return V4L2_STD_NTSC_M_JP;
 913                 case 'k':
 914                 case 'K':
 915                         return V4L2_STD_NTSC_M_KR;
 916                 default:
 917                         tuner_info("ntsc= argument not recognised\n");
 918                         break;
 919                 }
 920         }
 921         return std;
 922 }
 923
 924 /*
 925  * Functions that are specific for Radio mode
 926  */
 927
 928 /**
 929  * set_radio_freq - Set tuner frequency,  freq in Units of 62.5 Hz  = 1/16kHz
 930  *
 931  * @c:  i2c_client descriptor
 932  * @freq: frequency
 933  */
 934 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
 935 {
 936         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 937         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 938
 939         struct analog_parameters params = {
 940                 .mode      = t->mode,
 941                 .audmode   = t->audmode,
 942                 .std       = t->std
 943         };
 944
 945         if (t->type == UNSET) {
 946                 tuner_warn("tuner type not set\n");
 947                 return;
 948         }
 949         if (NULL == analog_ops->set_params) {
 950                 tuner_warn("tuner has no way to set radio frequency\n");
 951                 return;
 952         }
 953         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
 954                 tuner_dbg("radio freq (%d.%02d) out of range (%d-%d)\n",
 955                            freq / 16000, freq % 16000 * 100 / 16000,
 956                            radio_range[0], radio_range[1]);
 957                 /* V4L2 spec: if the freq is not possible then the closest
 958                    possible value should be selected */
 959                 if (freq < radio_range[0] * 16000)
 960                         freq = radio_range[0] * 16000;
 961                 else
 962                         freq = radio_range[1] * 16000;
 963         }
 964         params.frequency = freq;
 965         tuner_dbg("radio freq set to %d.%02d\n",
 966                         freq / 16000, freq % 16000 * 100 / 16000);
 967         t->radio_freq = freq;
 968         t->standby = false;
 969
 970         analog_ops->set_params(&t->fe, &params);
 971 }
 972
 973 /*
 974  * Debug function for reporting tuner status to userspace
 975  */
 976
 977 /**
 978  * tuner_status - Dumps the current tuner status at dmesg
 979  * @fe: pointer to struct dvb_frontend
 980  *
 981  * This callback is used only for driver debug purposes, answering to
 982  * VIDIOC_LOG_STATUS. No changes should happen on this call.
 983  */
 984 static void tuner_status(struct dvb_frontend *fe)
 985 {
 986         struct tuner *t = fe->analog_demod_priv;
 987         unsigned long freq, freq_fraction;
 988         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 989         struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
 990         const char *p;
 991
 992         switch (t->mode) {
 993         case V4L2_TUNER_RADIO:
 994                 p = "radio";
 995                 break;
 996         case V4L2_TUNER_DIGITAL_TV: /* Used by mt20xx */
 997                 p = "digital TV";
 998                 break;
 999         case V4L2_TUNER_ANALOG_TV:
1000         default:
1001                 p = "analog TV";
1002                 break;
1003         }
1004         if (t->mode == V4L2_TUNER_RADIO) {
1005                 freq = t->radio_freq / 16000;
1006                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
1007         } else {
1008                 freq = t->tv_freq / 16;
1009                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
1010         }
1011         tuner_info("Tuner mode:      %s%s\n", p,
1012                    t->standby ? " on standby mode" : "");
1013         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
1014         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
1015         if (t->mode != V4L2_TUNER_RADIO)
1016                 return;
1017         if (fe_tuner_ops->get_status) {
1018                 u32 tuner_status;
1019
1020                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1021                 if (tuner_status & TUNER_STATUS_LOCKED)
1022                         tuner_info("Tuner is locked.\n");
1023                 if (tuner_status & TUNER_STATUS_STEREO)
1024                         tuner_info("Stereo:          yes\n");
1025         }
1026         if (analog_ops->has_signal)
1027                 tuner_info("Signal strength: %d\n",
1028                            analog_ops->has_signal(fe));
1029 }
1030
1031 /*
1032  * Function to splicitly change mode to radio. Probably not needed anymore
1033  */
1034
1035 static int tuner_s_radio(struct v4l2_subdev *sd)
1036 {
1037         struct tuner *t = to_tuner(sd);
1038
1039         if (set_mode(t, V4L2_TUNER_RADIO) == 0)
1040                 set_freq(t, 0);
1041         return 0;
1042 }
1043
1044 /*
1045  * Tuner callbacks to handle userspace ioctl's
1046  */
1047
1048 /**
1049  * tuner_s_power - controls the power state of the tuner
1050  * @sd: pointer to struct v4l2_subdev
1051  * @on: a zero value puts the tuner to sleep, non-zero wakes it up
1052  */
1053 static int tuner_s_power(struct v4l2_subdev *sd, int on)
1054 {
1055         struct tuner *t = to_tuner(sd);
1056         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1057
1058         if (on) {
1059                 if (t->standby && set_mode(t, t->mode) == 0) {
1060                         tuner_dbg("Waking up tuner\n");
1061                         set_freq(t, 0);
1062                 }
1063                 return 0;
1064         }
1065
1066         tuner_dbg("Putting tuner to sleep\n");
1067         t->standby = true;
1068         if (analog_ops->standby)
1069                 analog_ops->standby(&t->fe);
1070         return 0;
1071 }
1072
1073 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1074 {
1075         struct tuner *t = to_tuner(sd);
1076
1077         if (set_mode(t, V4L2_TUNER_ANALOG_TV))
1078                 return 0;
1079
1080         t->std = tuner_fixup_std(t, std);
1081         if (t->std != std)
1082                 tuner_dbg("Fixup standard %llx to %llx\n", std, t->std);
1083         set_freq(t, 0);
1084         return 0;
1085 }
1086
1087 static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1088 {
1089         struct tuner *t = to_tuner(sd);
1090
1091         if (set_mode(t, f->type) == 0)
1092                 set_freq(t, f->frequency);
1093         return 0;
1094 }
1095
1096 /**
1097  * tuner_g_frequency - Get the tuned frequency for the tuner
1098  * @sd: pointer to struct v4l2_subdev
1099  * @f: pointer to struct v4l2_frequency
1100  *
1101  * At return, the structure f will be filled with tuner frequency
1102  * if the tuner matches the f->type.
1103  * Note: f->type should be initialized before calling it.
1104  * This is done by either video_ioctl2 or by the bridge driver.
1105  */
1106 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1107 {
1108         struct tuner *t = to_tuner(sd);
1109         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1110
1111         if (check_mode(t, f->type) == -EINVAL)
1112                 return 0;
1113         if (f->type == t->mode && fe_tuner_ops->get_frequency && !t->standby) {
1114                 u32 abs_freq;
1115
1116                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1117                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1118                         DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1119                         DIV_ROUND_CLOSEST(abs_freq, 62500);
1120         } else {
1121                 f->frequency = (V4L2_TUNER_RADIO == f->type) ?
1122                         t->radio_freq : t->tv_freq;
1123         }
1124         return 0;
1125 }
1126
1127 /**
1128  * tuner_g_tuner - Fill in tuner information
1129  * @sd: pointer to struct v4l2_subdev
1130  * @vt: pointer to struct v4l2_tuner
1131  *
1132  * At return, the structure vt will be filled with tuner information
1133  * if the tuner matches vt->type.
1134  * Note: vt->type should be initialized before calling it.
1135  * This is done by either video_ioctl2 or by the bridge driver.
1136  */
1137 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1138 {
1139         struct tuner *t = to_tuner(sd);
1140         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1141         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1142
1143         if (check_mode(t, vt->type) == -EINVAL)
1144                 return 0;
1145         if (vt->type == t->mode && analog_ops->get_afc)
1146                 vt->afc = analog_ops->get_afc(&t->fe);
1147         if (t->mode != V4L2_TUNER_RADIO) {
1148                 vt->capability |= V4L2_TUNER_CAP_NORM;
1149                 vt->rangelow = tv_range[0] * 16;
1150                 vt->rangehigh = tv_range[1] * 16;
1151                 return 0;
1152         }
1153
1154         /* radio mode */
1155         if (vt->type == t->mode) {
1156                 vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1157                 if (fe_tuner_ops->get_status) {
1158                         u32 tuner_status;
1159
1160                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
1161                         vt->rxsubchans =
1162                                 (tuner_status & TUNER_STATUS_STEREO) ?
1163                                 V4L2_TUNER_SUB_STEREO :
1164                                 V4L2_TUNER_SUB_MONO;
1165                 }
1166                 if (analog_ops->has_signal)
1167                         vt->signal = analog_ops->has_signal(&t->fe);
1168                 vt->audmode = t->audmode;
1169         }
1170         vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1171         vt->rangelow = radio_range[0] * 16000;
1172         vt->rangehigh = radio_range[1] * 16000;
1173
1174         return 0;
1175 }
1176
1177 /**
1178  * tuner_s_tuner - Set the tuner's audio mode
1179  * @sd: pointer to struct v4l2_subdev
1180  * @vt: pointer to struct v4l2_tuner
1181  *
1182  * Sets the audio mode if the tuner matches vt->type.
1183  * Note: vt->type should be initialized before calling it.
1184  * This is done by either video_ioctl2 or by the bridge driver.
1185  */
1186 static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1187 {
1188         struct tuner *t = to_tuner(sd);
1189
1190         if (set_mode(t, vt->type))
1191                 return 0;
1192
1193         if (t->mode == V4L2_TUNER_RADIO)
1194                 t->audmode = vt->audmode;
1195         set_freq(t, 0);
1196
1197         return 0;
1198 }
1199
1200 static int tuner_log_status(struct v4l2_subdev *sd)
1201 {
1202         struct tuner *t = to_tuner(sd);
1203         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1204
1205         if (analog_ops->tuner_status)
1206                 analog_ops->tuner_status(&t->fe);
1207         return 0;
1208 }
1209
1210 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1211 {
1212         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1213         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1214
1215         tuner_dbg("suspend\n");
1216
1217         if (!t->standby && analog_ops->standby)
1218                 analog_ops->standby(&t->fe);
1219
1220         return 0;
1221 }
1222
1223 static int tuner_resume(struct i2c_client *c)
1224 {
1225         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1226
1227         tuner_dbg("resume\n");
1228
1229         if (!t->standby)
1230                 if (set_mode(t, t->mode) == 0)
1231                         set_freq(t, 0);
1232
1233         return 0;
1234 }
1235
1236 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1237 {
1238         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1239
1240         /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1241            to handle it here.
1242            There must be a better way of doing this... */
1243         switch (cmd) {
1244         case TUNER_SET_CONFIG:
1245                 return tuner_s_config(sd, arg);
1246         }
1247         return -ENOIOCTLCMD;
1248 }
1249
1250 /*
1251  * Callback structs
1252  */
1253
1254 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1255         .log_status = tuner_log_status,
1256         .s_std = tuner_s_std,
1257         .s_power = tuner_s_power,
1258 };
1259
1260 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1261         .s_radio = tuner_s_radio,
1262         .g_tuner = tuner_g_tuner,
1263         .s_tuner = tuner_s_tuner,
1264         .s_frequency = tuner_s_frequency,
1265         .g_frequency = tuner_g_frequency,
1266         .s_type_addr = tuner_s_type_addr,
1267         .s_config = tuner_s_config,
1268 };
1269
1270 static const struct v4l2_subdev_ops tuner_ops = {
1271         .core = &tuner_core_ops,
1272         .tuner = &tuner_tuner_ops,
1273 };
1274
1275 /*
1276  * I2C structs and module init functions
1277  */
1278
1279 static const struct i2c_device_id tuner_id[] = {
1280         { "tuner", }, /* autodetect */
1281         { }
1282 };
1283 MODULE_DEVICE_TABLE(i2c, tuner_id);
1284
1285 static struct i2c_driver tuner_driver = {
1286         .driver = {
1287                 .owner  = THIS_MODULE,
1288                 .name   = "tuner",
1289         },
1290         .probe          = tuner_probe,
1291         .remove         = tuner_remove,
1292         .command        = tuner_command,
1293         .suspend        = tuner_suspend,
1294         .resume         = tuner_resume,
1295         .id_table       = tuner_id,
1296 };
1297
1298 static __init int init_tuner(void)
1299 {
1300         return i2c_add_driver(&tuner_driver);
1301 }
1302
1303 static __exit void exit_tuner(void)
1304 {
1305         i2c_del_driver(&tuner_driver);
1306 }
1307
1308 module_init(init_tuner);
1309 module_exit(exit_tuner);
1310
1311 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1312 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1313 MODULE_LICENSE("GPL");