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