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 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                 pos->standby = 1;
 542                 if (*radio == NULL && mode_mask == T_RADIO)
 543                         *radio = pos;
 544                 /* Note: currently TDA9887 is the only demod-only
 545                    device. If other devices appear then we need to
 546                    make this test more general. */
 547                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
 548                          (pos->mode_mask & T_ANALOG_TV))
 549                         *tv = pos;
 550         }
 551 }
 552
 553 /**
 554  *tuner_probe - Probes the existing tuners on an I2C bus
 555  *
 556  * @client:     i2c_client descriptor
 557  * @id:         not used
 558  *
 559  * This routine probes for tuners at the expected I2C addresses. On most
 560  * cases, if a device answers to a given I2C address, it assumes that the
 561  * device is a tuner. On a few cases, however, an additional logic is needed
 562  * to double check if the device is really a tuner, or to identify the tuner
 563  * type, like on tea5767/5761 devices.
 564  *
 565  * During client attach, set_type is called by adapter's attach_inform callback.
 566  * set_type must then be completed by tuner_probe.
 567  */
 568 static int tuner_probe(struct i2c_client *client,
 569                        const struct i2c_device_id *id)
 570 {
 571         struct tuner *t;
 572         struct tuner *radio;
 573         struct tuner *tv;
 574
 575         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
 576         if (NULL == t)
 577                 return -ENOMEM;
 578         v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
 579         t->i2c = client;
 580         t->name = "(tuner unset)";
 581         t->type = UNSET;
 582         t->audmode = V4L2_TUNER_MODE_STEREO;
 583         t->standby = 1;
 584         t->radio_freq = 87.5 * 16000;   /* Initial freq range */
 585         t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
 586
 587         if (show_i2c) {
 588                 unsigned char buffer[16];
 589                 int i, rc;
 590
 591                 memset(buffer, 0, sizeof(buffer));
 592                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
 593                 tuner_info("I2C RECV = ");
 594                 for (i = 0; i < rc; i++)
 595                         printk(KERN_CONT "%02x ", buffer[i]);
 596                 printk("\n");
 597         }
 598
 599         /* autodetection code based on the i2c addr */
 600         if (!no_autodetect) {
 601                 switch (client->addr) {
 602                 case 0x10:
 603                         if (tuner_symbol_probe(tea5761_autodetection,
 604                                                t->i2c->adapter,
 605                                                t->i2c->addr) >= 0) {
 606                                 t->type = TUNER_TEA5761;
 607                                 t->mode_mask = T_RADIO;
 608                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
 609                                 if (tv)
 610                                         tv->mode_mask &= ~T_RADIO;
 611
 612                                 goto register_client;
 613                         }
 614                         kfree(t);
 615                         return -ENODEV;
 616                 case 0x42:
 617                 case 0x43:
 618                 case 0x4a:
 619                 case 0x4b:
 620                         /* If chip is not tda8290, don't register.
 621                            since it can be tda9887*/
 622                         if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
 623                                                t->i2c->addr) >= 0) {
 624                                 tuner_dbg("tda829x detected\n");
 625                         } else {
 626                                 /* Default is being tda9887 */
 627                                 t->type = TUNER_TDA9887;
 628                                 t->mode_mask = T_RADIO | T_ANALOG_TV;
 629                                 goto register_client;
 630                         }
 631                         break;
 632                 case 0x60:
 633                         if (tuner_symbol_probe(tea5767_autodetection,
 634                                                t->i2c->adapter, t->i2c->addr)
 635                                         >= 0) {
 636                                 t->type = TUNER_TEA5767;
 637                                 t->mode_mask = T_RADIO;
 638                                 /* Sets freq to FM range */
 639                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
 640                                 if (tv)
 641                                         tv->mode_mask &= ~T_RADIO;
 642
 643                                 goto register_client;
 644                         }
 645                         break;
 646                 }
 647         }
 648
 649         /* Initializes only the first TV tuner on this adapter. Why only the
 650            first? Because there are some devices (notably the ones with TI
 651            tuners) that have more than one i2c address for the *same* device.
 652            Experience shows that, except for just one case, the first
 653            address is the right one. The exception is a Russian tuner
 654            (ACORP_Y878F). So, the desired behavior is just to enable the
 655            first found TV tuner. */
 656         tuner_lookup(t->i2c->adapter, &radio, &tv);
 657         if (tv == NULL) {
 658                 t->mode_mask = T_ANALOG_TV;
 659                 if (radio == NULL)
 660                         t->mode_mask |= T_RADIO;
 661                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
 662         }
 663
 664         /* Should be just before return */
 665 register_client:
 666         /* Sets a default mode */
 667         if (t->mode_mask & T_ANALOG_TV)
 668                 t->mode = V4L2_TUNER_ANALOG_TV;
 669         else
 670                 t->mode = V4L2_TUNER_RADIO;
 671         set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
 672         list_add_tail(&t->list, &tuner_list);
 673
 674         tuner_info("Tuner %d found with type(s)%s%s.\n",
 675                    t->type,
 676                    t->mode_mask & T_RADIO ? " Radio" : "",
 677                    t->mode_mask & T_ANALOG_TV ? " TV" : "");
 678         return 0;
 679 }
 680
 681 /**
 682  * tuner_remove - detaches a tuner
 683  *
 684  * @client:     i2c_client descriptor
 685  */
 686
 687 static int tuner_remove(struct i2c_client *client)
 688 {
 689         struct tuner *t = to_tuner(i2c_get_clientdata(client));
 690
 691         v4l2_device_unregister_subdev(&t->sd);
 692         tuner_detach(&t->fe);
 693         t->fe.analog_demod_priv = NULL;
 694
 695         list_del(&t->list);
 696         kfree(t);
 697         return 0;
 698 }
 699
 700 /*
 701  * Functions that are specific for TV mode
 702  */
 703
 704 /**
 705  * set_tv_freq - Set tuner frequency,  freq in Units of 62.5 kHz = 1/16MHz
 706  *
 707  * @c:  i2c_client descriptor
 708  * @freq: frequency
 709  */
 710 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
 711 {
 712         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 713         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 714
 715         struct analog_parameters params = {
 716                 .mode      = t->mode,
 717                 .audmode   = t->audmode,
 718                 .std       = t->std
 719         };
 720
 721         if (t->type == UNSET) {
 722                 tuner_warn("tuner type not set\n");
 723                 return;
 724         }
 725         if (NULL == analog_ops->set_params) {
 726                 tuner_warn("Tuner has no way to set tv freq\n");
 727                 return;
 728         }
 729         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
 730                 tuner_dbg("TV freq (%d.%02d) out of range (%d-%d)\n",
 731                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
 732                            tv_range[1]);
 733                 /* V4L2 spec: if the freq is not possible then the closest
 734                    possible value should be selected */
 735                 if (freq < tv_range[0] * 16)
 736                         freq = tv_range[0] * 16;
 737                 else
 738                         freq = tv_range[1] * 16;
 739         }
 740         params.frequency = freq;
 741         tuner_dbg("tv freq set to %d.%02d\n",
 742                         freq / 16, freq % 16 * 100 / 16);
 743         t->tv_freq = freq;
 744         t->standby = false;
 745
 746         analog_ops->set_params(&t->fe, &params);
 747 }
 748
 749 /**
 750  * tuner_fixup_std - force a given video standard variant
 751  *
 752  * @t:  tuner internal struct
 753  *
 754  * A few devices or drivers have problem to detect some standard variations.
 755  * On other operational systems, the drivers generally have a per-country
 756  * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
 757  * such hacks. Instead, it relies on a proper video standard selection from
 758  * the userspace application. However, as some apps are buggy, not allowing
 759  * to distinguish all video standard variations, a modprobe parameter can
 760  * be used to force a video standard match.
 761  */
 762 static int tuner_fixup_std(struct tuner *t)
 763 {
 764         if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 765                 switch (pal[0]) {
 766                 case '6':
 767                         tuner_dbg("insmod fixup: PAL => PAL-60\n");
 768                         t->std = V4L2_STD_PAL_60;
 769                         break;
 770                 case 'b':
 771                 case 'B':
 772                 case 'g':
 773                 case 'G':
 774                         tuner_dbg("insmod fixup: PAL => PAL-BG\n");
 775                         t->std = V4L2_STD_PAL_BG;
 776                         break;
 777                 case 'i':
 778                 case 'I':
 779                         tuner_dbg("insmod fixup: PAL => PAL-I\n");
 780                         t->std = V4L2_STD_PAL_I;
 781                         break;
 782                 case 'd':
 783                 case 'D':
 784                 case 'k':
 785                 case 'K':
 786                         tuner_dbg("insmod fixup: PAL => PAL-DK\n");
 787                         t->std = V4L2_STD_PAL_DK;
 788                         break;
 789                 case 'M':
 790                 case 'm':
 791                         tuner_dbg("insmod fixup: PAL => PAL-M\n");
 792                         t->std = V4L2_STD_PAL_M;
 793                         break;
 794                 case 'N':
 795                 case 'n':
 796                         if (pal[1] == 'c' || pal[1] == 'C') {
 797                                 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
 798                                 t->std = V4L2_STD_PAL_Nc;
 799                         } else {
 800                                 tuner_dbg("insmod fixup: PAL => PAL-N\n");
 801                                 t->std = V4L2_STD_PAL_N;
 802                         }
 803                         break;
 804                 case '-':
 805                         /* default parameter, do nothing */
 806                         break;
 807                 default:
 808                         tuner_warn("pal= argument not recognised\n");
 809                         break;
 810                 }
 811         }
 812         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 813                 switch (secam[0]) {
 814                 case 'b':
 815                 case 'B':
 816                 case 'g':
 817                 case 'G':
 818                 case 'h':
 819                 case 'H':
 820                         tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
 821                         t->std = V4L2_STD_SECAM_B |
 822                                  V4L2_STD_SECAM_G |
 823                                  V4L2_STD_SECAM_H;
 824                         break;
 825                 case 'd':
 826                 case 'D':
 827                 case 'k':
 828                 case 'K':
 829                         tuner_dbg("insmod fixup: SECAM => SECAM-DK\n");
 830                         t->std = V4L2_STD_SECAM_DK;
 831                         break;
 832                 case 'l':
 833                 case 'L':
 834                         if ((secam[1] == 'C') || (secam[1] == 'c')) {
 835                                 tuner_dbg("insmod fixup: SECAM => SECAM-L'\n");
 836                                 t->std = V4L2_STD_SECAM_LC;
 837                         } else {
 838                                 tuner_dbg("insmod fixup: SECAM => SECAM-L\n");
 839                                 t->std = V4L2_STD_SECAM_L;
 840                         }
 841                         break;
 842                 case '-':
 843                         /* default parameter, do nothing */
 844                         break;
 845                 default:
 846                         tuner_warn("secam= argument not recognised\n");
 847                         break;
 848                 }
 849         }
 850
 851         if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 852                 switch (ntsc[0]) {
 853                 case 'm':
 854                 case 'M':
 855                         tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
 856                         t->std = V4L2_STD_NTSC_M;
 857                         break;
 858                 case 'j':
 859                 case 'J':
 860                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
 861                         t->std = V4L2_STD_NTSC_M_JP;
 862                         break;
 863                 case 'k':
 864                 case 'K':
 865                         tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
 866                         t->std = V4L2_STD_NTSC_M_KR;
 867                         break;
 868                 case '-':
 869                         /* default parameter, do nothing */
 870                         break;
 871                 default:
 872                         tuner_info("ntsc= argument not recognised\n");
 873                         break;
 874                 }
 875         }
 876         return 0;
 877 }
 878
 879 /*
 880  * Functions that are specific for Radio mode
 881  */
 882
 883 /**
 884  * set_radio_freq - Set tuner frequency,  freq in Units of 62.5 Hz  = 1/16kHz
 885  *
 886  * @c:  i2c_client descriptor
 887  * @freq: frequency
 888  */
 889 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
 890 {
 891         struct tuner *t = to_tuner(i2c_get_clientdata(c));
 892         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 893
 894         struct analog_parameters params = {
 895                 .mode      = t->mode,
 896                 .audmode   = t->audmode,
 897                 .std       = t->std
 898         };
 899
 900         if (t->type == UNSET) {
 901                 tuner_warn("tuner type not set\n");
 902                 return;
 903         }
 904         if (NULL == analog_ops->set_params) {
 905                 tuner_warn("tuner has no way to set radio frequency\n");
 906                 return;
 907         }
 908         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
 909                 tuner_dbg("radio freq (%d.%02d) out of range (%d-%d)\n",
 910                            freq / 16000, freq % 16000 * 100 / 16000,
 911                            radio_range[0], radio_range[1]);
 912                 /* V4L2 spec: if the freq is not possible then the closest
 913                    possible value should be selected */
 914                 if (freq < radio_range[0] * 16000)
 915                         freq = radio_range[0] * 16000;
 916                 else
 917                         freq = radio_range[1] * 16000;
 918         }
 919         params.frequency = freq;
 920         tuner_dbg("radio freq set to %d.%02d\n",
 921                         freq / 16000, freq % 16000 * 100 / 16000);
 922         t->radio_freq = freq;
 923         t->standby = false;
 924
 925         analog_ops->set_params(&t->fe, &params);
 926 }
 927
 928 /**
 929  * check_mode - Verify if tuner supports the requested mode
 930  * @t: a pointer to the module's internal struct_tuner
 931  *
 932  * This function checks if the tuner is capable of tuning analog TV,
 933  * digital TV or radio, depending on what the caller wants. If the
 934  * tuner can't support that mode, it returns -EINVAL. Otherwise, it
 935  * returns 0.
 936  * This function is needed for boards that have a separate tuner for
 937  * radio (like devices with tea5767).
 938  */
 939 static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
 940 {
 941         if ((1 << mode & t->mode_mask) == 0)
 942                 return -EINVAL;
 943
 944         return 0;
 945 }
 946
 947 /**
 948  * set_mode_freq - Switch tuner to other mode.
 949  * @client:     struct i2c_client pointer
 950  * @t:          a pointer to the module's internal struct_tuner
 951  * @mode:       enum v4l2_type (radio or TV)
 952  * @freq:       frequency to set (0 means to use the previous one)
 953  *
 954  * If tuner doesn't support the needed mode (radio or TV), prints a
 955  * debug message and returns -EINVAL, changing internal state to T_STANDBY.
 956  * Otherwise, changes the state and sets frequency to the last value, if
 957  * the tuner can sleep or if it supports both Radio and TV.
 958  */
 959 static int set_mode_freq(struct i2c_client *client, struct tuner *t,
 960                          enum v4l2_tuner_type mode, unsigned int freq)
 961 {
 962         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 963
 964         if (mode != t->mode) {
 965                 if (check_mode(t, mode) == -EINVAL) {
 966                         tuner_dbg("Tuner doesn't support mode %d. "
 967                                   "Putting tuner to sleep\n", mode);
 968                         t->standby = true;
 969                         if (analog_ops->standby)
 970                                 analog_ops->standby(&t->fe);
 971                         return -EINVAL;
 972                 }
 973                 t->mode = mode;
 974                 tuner_dbg("Changing to mode %d\n", mode);
 975         }
 976         if (t->mode == V4L2_TUNER_RADIO) {
 977                 if (freq)
 978                         t->radio_freq = freq;
 979                 set_radio_freq(client, t->radio_freq);
 980         } else {
 981                 if (freq)
 982                         t->tv_freq = freq;
 983                 set_tv_freq(client, t->tv_freq);
 984         }
 985
 986         return 0;
 987 }
 988
 989 /**
 990  * tuner_status - Dumps the current tuner status at dmesg
 991  * @fe: pointer to struct dvb_frontend
 992  *
 993  * This callback is used only for driver debug purposes, answering to
 994  * VIDIOC_LOG_STATUS. No changes should happen on this call.
 995  */
 996 static void tuner_status(struct dvb_frontend *fe)
 997 {
 998         struct tuner *t = fe->analog_demod_priv;
 999         unsigned long freq, freq_fraction;
1000         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
1001         struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
1002         const char *p;
1003
1004         switch (t->mode) {
1005         case V4L2_TUNER_RADIO:
1006                 p = "radio";
1007                 break;
1008         case V4L2_TUNER_DIGITAL_TV:
1009                 p = "digital TV";
1010                 break;
1011         case V4L2_TUNER_ANALOG_TV:
1012         default:
1013                 p = "analog TV";
1014                 break;
1015         }
1016         if (t->mode == V4L2_TUNER_RADIO) {
1017                 freq = t->radio_freq / 16000;
1018                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
1019         } else {
1020                 freq = t->tv_freq / 16;
1021                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
1022         }
1023         tuner_info("Tuner mode:      %s%s\n", p,
1024                    t->standby ? " on standby mode" : "");
1025         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
1026         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
1027         if (t->mode != V4L2_TUNER_RADIO)
1028                 return;
1029         if (fe_tuner_ops->get_status) {
1030                 u32 tuner_status;
1031
1032                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1033                 if (tuner_status & TUNER_STATUS_LOCKED)
1034                         tuner_info("Tuner is locked.\n");
1035                 if (tuner_status & TUNER_STATUS_STEREO)
1036                         tuner_info("Stereo:          yes\n");
1037         }
1038         if (analog_ops->has_signal)
1039                 tuner_info("Signal strength: %d\n",
1040                            analog_ops->has_signal(fe));
1041 }
1042
1043 /**
1044  * tuner_s_power - controls the power state of the tuner
1045  * @sd: pointer to struct v4l2_subdev
1046  * @on: a zero value puts the tuner to sleep
1047  */
1048 static int tuner_s_power(struct v4l2_subdev *sd, int on)
1049 {
1050         struct tuner *t = to_tuner(sd);
1051         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1052
1053         /* FIXME: Why this function don't wake the tuner if on != 0 ? */
1054         if (on)
1055                 return 0;
1056
1057         tuner_dbg("Putting tuner to sleep\n");
1058         t->standby = true;
1059         if (analog_ops->standby)
1060                 analog_ops->standby(&t->fe);
1061         return 0;
1062 }
1063
1064 /*
1065  * Function to splicitly change mode to radio. Probably not needed anymore
1066  */
1067
1068 static int tuner_s_radio(struct v4l2_subdev *sd)
1069 {
1070         struct tuner *t = to_tuner(sd);
1071         struct i2c_client *client = v4l2_get_subdevdata(sd);
1072
1073         if (set_mode_freq(client, t, V4L2_TUNER_RADIO, 0) == -EINVAL)
1074                 return 0;
1075         return 0;
1076 }
1077
1078 /*
1079  * Tuner callbacks to handle userspace ioctl's
1080  */
1081
1082 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1083 {
1084         struct tuner *t = to_tuner(sd);
1085         struct i2c_client *client = v4l2_get_subdevdata(sd);
1086
1087         if (set_mode_freq(client, t, V4L2_TUNER_ANALOG_TV, 0) == -EINVAL)
1088                 return 0;
1089
1090         t->std = std;
1091         tuner_fixup_std(t);
1092
1093         return 0;
1094 }
1095
1096 static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1097 {
1098         struct tuner *t = to_tuner(sd);
1099         struct i2c_client *client = v4l2_get_subdevdata(sd);
1100
1101         if (set_mode_freq(client, t, f->type, f->frequency) == -EINVAL)
1102                 return 0;
1103
1104         return 0;
1105 }
1106
1107 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1108 {
1109         struct tuner *t = to_tuner(sd);
1110         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1111
1112         if (check_mode(t, f->type) == -EINVAL)
1113                 return 0;
1114         f->type = t->mode;
1115         if (fe_tuner_ops->get_frequency && !t->standby) {
1116                 u32 abs_freq;
1117
1118                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1119                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1120                         DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1121                         DIV_ROUND_CLOSEST(abs_freq, 62500);
1122         } else {
1123                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1124                         t->radio_freq : t->tv_freq;
1125         }
1126         return 0;
1127 }
1128
1129 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1130 {
1131         struct tuner *t = to_tuner(sd);
1132         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1133         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1134
1135         if (check_mode(t, vt->type) == -EINVAL)
1136                 return 0;
1137         vt->type = t->mode;
1138         if (analog_ops->get_afc)
1139                 vt->afc = analog_ops->get_afc(&t->fe);
1140         if (t->mode == V4L2_TUNER_ANALOG_TV)
1141                 vt->capability |= V4L2_TUNER_CAP_NORM;
1142         if (t->mode != V4L2_TUNER_RADIO) {
1143                 vt->rangelow = tv_range[0] * 16;
1144                 vt->rangehigh = tv_range[1] * 16;
1145                 return 0;
1146         }
1147
1148         /* radio mode */
1149         vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1150         if (fe_tuner_ops->get_status) {
1151                 u32 tuner_status;
1152
1153                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1154                 vt->rxsubchans =
1155                         (tuner_status & TUNER_STATUS_STEREO) ?
1156                         V4L2_TUNER_SUB_STEREO :
1157                         V4L2_TUNER_SUB_MONO;
1158         }
1159         if (analog_ops->has_signal)
1160                 vt->signal = analog_ops->has_signal(&t->fe);
1161         vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1162         vt->audmode = t->audmode;
1163         vt->rangelow = radio_range[0] * 16000;
1164         vt->rangehigh = radio_range[1] * 16000;
1165
1166         return 0;
1167 }
1168
1169 static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1170 {
1171         struct tuner *t = to_tuner(sd);
1172         struct i2c_client *client = v4l2_get_subdevdata(sd);
1173
1174         if (set_mode_freq(client, t, vt->type, 0) == -EINVAL)
1175                 return 0;
1176
1177         if (t->mode == V4L2_TUNER_RADIO)
1178                 t->audmode = vt->audmode;
1179
1180         return 0;
1181 }
1182
1183 static int tuner_log_status(struct v4l2_subdev *sd)
1184 {
1185         struct tuner *t = to_tuner(sd);
1186         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1187
1188         if (analog_ops->tuner_status)
1189                 analog_ops->tuner_status(&t->fe);
1190         return 0;
1191 }
1192
1193 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1194 {
1195         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1196         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1197
1198         tuner_dbg("suspend\n");
1199
1200         if (!t->standby && analog_ops->standby)
1201                 analog_ops->standby(&t->fe);
1202
1203         return 0;
1204 }
1205
1206 static int tuner_resume(struct i2c_client *c)
1207 {
1208         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1209
1210         tuner_dbg("resume\n");
1211
1212         if (!t->standby)
1213                 set_mode_freq(c, t, t->type, 0);
1214
1215         return 0;
1216 }
1217
1218 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1219 {
1220         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1221
1222         /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1223            to handle it here.
1224            There must be a better way of doing this... */
1225         switch (cmd) {
1226         case TUNER_SET_CONFIG:
1227                 return tuner_s_config(sd, arg);
1228         }
1229         return -ENOIOCTLCMD;
1230 }
1231
1232 /*
1233  * Callback structs
1234  */
1235
1236 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1237         .log_status = tuner_log_status,
1238         .s_std = tuner_s_std,
1239         .s_power = tuner_s_power,
1240 };
1241
1242 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1243         .s_radio = tuner_s_radio,
1244         .g_tuner = tuner_g_tuner,
1245         .s_tuner = tuner_s_tuner,
1246         .s_frequency = tuner_s_frequency,
1247         .g_frequency = tuner_g_frequency,
1248         .s_type_addr = tuner_s_type_addr,
1249         .s_config = tuner_s_config,
1250 };
1251
1252 static const struct v4l2_subdev_ops tuner_ops = {
1253         .core = &tuner_core_ops,
1254         .tuner = &tuner_tuner_ops,
1255 };
1256
1257 /*
1258  * I2C structs and module init functions
1259  */
1260
1261 static const struct i2c_device_id tuner_id[] = {
1262         { "tuner", }, /* autodetect */
1263         { }
1264 };
1265 MODULE_DEVICE_TABLE(i2c, tuner_id);
1266
1267 static struct i2c_driver tuner_driver = {
1268         .driver = {
1269                 .owner  = THIS_MODULE,
1270                 .name   = "tuner",
1271         },
1272         .probe          = tuner_probe,
1273         .remove         = tuner_remove,
1274         .command        = tuner_command,
1275         .suspend        = tuner_suspend,
1276         .resume         = tuner_resume,
1277         .id_table       = tuner_id,
1278 };
1279
1280 static __init int init_tuner(void)
1281 {
1282         return i2c_add_driver(&tuner_driver);
1283 }
1284
1285 static __exit void exit_tuner(void)
1286 {
1287         i2c_del_driver(&tuner_driver);
1288 }
1289
1290 module_init(init_tuner);
1291 module_exit(exit_tuner);
1292
1293 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1294 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1295 MODULE_LICENSE("GPL");