err.no Git - linux-2.6/blob - drivers/media/video/tuner-core.c

   1 /*
   2  *
   3  * i2c tv tuner chip device driver
   4  * core core, i.e. kernel interfaces, registering and so on
   5  */
   6
   7 #include <linux/module.h>
   8 #include <linux/kernel.h>
   9 #include <linux/string.h>
  10 #include <linux/timer.h>
  11 #include <linux/delay.h>
  12 #include <linux/errno.h>
  13 #include <linux/slab.h>
  14 #include <linux/poll.h>
  15 #include <linux/i2c.h>
  16 #include <linux/types.h>
  17 #include <linux/init.h>
  18 #include <linux/videodev.h>
  19 #include <media/tuner.h>
  20 #include <media/tuner-types.h>
  21 #include <media/v4l2-common.h>
  22 #include <media/v4l2-i2c-drv-legacy.h>
  23 #include "tuner-driver.h"
  24 #include "mt20xx.h"
  25 #include "tda8290.h"
  26 #include "tea5761.h"
  27 #include "tea5767.h"
  28 #include "tuner-xc2028.h"
  29 #include "tuner-simple.h"
  30 #include "tda9887.h"
  31
  32 #define UNSET (-1U)
  33
  34 #define PREFIX t->i2c->driver->driver.name
  35
  36 /* standard i2c insmod options */
  37 static unsigned short normal_i2c[] = {
  38 #if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
  39         0x10,
  40 #endif
  41         0x42, 0x43, 0x4a, 0x4b,                 /* tda8290 */
  42         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
  43         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
  44         I2C_CLIENT_END
  45 };
  46
  47 I2C_CLIENT_INSMOD;
  48
  49 /* insmod options used at init time => read/only */
  50 static unsigned int addr = 0;
  51 static unsigned int no_autodetect = 0;
  52 static unsigned int show_i2c = 0;
  53
  54 /* insmod options used at runtime => read/write */
  55 static int tuner_debug;
  56
  57 #define tuner_warn(fmt, arg...) do {                    \
  58         printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
  59                i2c_adapter_id(t->i2c->adapter),         \
  60                t->i2c->addr, ##arg);                    \
  61          } while (0)
  62
  63 #define tuner_info(fmt, arg...) do {                    \
  64         printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX,    \
  65                i2c_adapter_id(t->i2c->adapter),         \
  66                t->i2c->addr, ##arg);                    \
  67          } while (0)
  68
  69 #define tuner_err(fmt, arg...) do {                     \
  70         printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX,     \
  71                i2c_adapter_id(t->i2c->adapter),         \
  72                t->i2c->addr, ##arg);                    \
  73          } while (0)
  74
  75 #define tuner_dbg(fmt, arg...) do {                             \
  76         if (tuner_debug)                                        \
  77                 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX,   \
  78                        i2c_adapter_id(t->i2c->adapter),         \
  79                        t->i2c->addr, ##arg);                    \
  80          } while (0)
  81
  82 /* ------------------------------------------------------------------------ */
  83
  84 static unsigned int tv_range[2] = { 44, 958 };
  85 static unsigned int radio_range[2] = { 65, 108 };
  86
  87 static char pal[] = "--";
  88 static char secam[] = "--";
  89 static char ntsc[] = "-";
  90
  91
  92 module_param(addr, int, 0444);
  93 module_param(no_autodetect, int, 0444);
  94 module_param(show_i2c, int, 0444);
  95 module_param_named(debug,tuner_debug, int, 0644);
  96 module_param_string(pal, pal, sizeof(pal), 0644);
  97 module_param_string(secam, secam, sizeof(secam), 0644);
  98 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
  99 module_param_array(tv_range, int, NULL, 0644);
 100 module_param_array(radio_range, int, NULL, 0644);
 101
 102 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
 103 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
 104 MODULE_LICENSE("GPL");
 105
 106 /* ---------------------------------------------------------------------- */
 107
 108 static void fe_set_params(struct dvb_frontend *fe,
 109                           struct analog_parameters *params)
 110 {
 111         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 112         struct tuner *t = fe->analog_demod_priv;
 113
 114         if (NULL == fe_tuner_ops->set_analog_params) {
 115                 tuner_warn("Tuner frontend module has no way to set freq\n");
 116                 return;
 117         }
 118         fe_tuner_ops->set_analog_params(fe, params);
 119 }
 120
 121 static void fe_release(struct dvb_frontend *fe)
 122 {
 123         if (fe->ops.tuner_ops.release)
 124                 fe->ops.tuner_ops.release(fe);
 125
 126         fe->ops.analog_demod_ops = NULL;
 127
 128         /* DO NOT kfree(fe->analog_demod_priv)
 129          *
 130          * If we are in this function, analog_demod_priv contains a pointer
 131          * to struct tuner *t.  This will be kfree'd in tuner_detach().
 132          *
 133          * Otherwise, fe->ops.analog_demod_ops->release will
 134          * handle the cleanup for analog demodulator modules.
 135          */
 136         fe->analog_demod_priv = NULL;
 137 }
 138
 139 static void fe_standby(struct dvb_frontend *fe)
 140 {
 141         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 142
 143         if (fe_tuner_ops->sleep)
 144                 fe_tuner_ops->sleep(fe);
 145 }
 146
 147 static int fe_has_signal(struct dvb_frontend *fe)
 148 {
 149         u16 strength = 0;
 150
 151         if (fe->ops.tuner_ops.get_rf_strength)
 152                 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
 153
 154         return strength;
 155 }
 156
 157 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
 158 {
 159         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 160         struct tuner *t = fe->analog_demod_priv;
 161
 162         if (fe_tuner_ops->set_config)
 163                 return fe_tuner_ops->set_config(fe, priv_cfg);
 164
 165         tuner_warn("Tuner frontend module has no way to set config\n");
 166
 167         return 0;
 168 }
 169
 170 static void tuner_status(struct dvb_frontend *fe);
 171
 172 static struct analog_tuner_ops tuner_core_ops = {
 173         .set_params     = fe_set_params,
 174         .standby        = fe_standby,
 175         .release        = fe_release,
 176         .has_signal     = fe_has_signal,
 177         .set_config     = fe_set_config,
 178         .tuner_status   = tuner_status
 179 };
 180
 181 /* Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz */
 182 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
 183 {
 184         struct tuner *t = i2c_get_clientdata(c);
 185         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 186
 187         struct analog_parameters params = {
 188                 .mode      = t->mode,
 189                 .audmode   = t->audmode,
 190                 .std       = t->std
 191         };
 192
 193         if (t->type == UNSET) {
 194                 tuner_warn ("tuner type not set\n");
 195                 return;
 196         }
 197         if ((NULL == ops) || (NULL == ops->set_params)) {
 198                 tuner_warn ("Tuner has no way to set tv freq\n");
 199                 return;
 200         }
 201         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
 202                 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
 203                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
 204                            tv_range[1]);
 205                 /* V4L2 spec: if the freq is not possible then the closest
 206                    possible value should be selected */
 207                 if (freq < tv_range[0] * 16)
 208                         freq = tv_range[0] * 16;
 209                 else
 210                         freq = tv_range[1] * 16;
 211         }
 212         params.frequency = freq;
 213
 214         ops->set_params(&t->fe, &params);
 215 }
 216
 217 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
 218 {
 219         struct tuner *t = i2c_get_clientdata(c);
 220         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 221
 222         struct analog_parameters params = {
 223                 .mode      = t->mode,
 224                 .audmode   = t->audmode,
 225                 .std       = t->std
 226         };
 227
 228         if (t->type == UNSET) {
 229                 tuner_warn ("tuner type not set\n");
 230                 return;
 231         }
 232         if ((NULL == ops) || (NULL == ops->set_params)) {
 233                 tuner_warn ("tuner has no way to set radio frequency\n");
 234                 return;
 235         }
 236         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
 237                 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
 238                            freq / 16000, freq % 16000 * 100 / 16000,
 239                            radio_range[0], radio_range[1]);
 240                 /* V4L2 spec: if the freq is not possible then the closest
 241                    possible value should be selected */
 242                 if (freq < radio_range[0] * 16000)
 243                         freq = radio_range[0] * 16000;
 244                 else
 245                         freq = radio_range[1] * 16000;
 246         }
 247         params.frequency = freq;
 248
 249         ops->set_params(&t->fe, &params);
 250 }
 251
 252 static void set_freq(struct i2c_client *c, unsigned long freq)
 253 {
 254         struct tuner *t = i2c_get_clientdata(c);
 255
 256         switch (t->mode) {
 257         case V4L2_TUNER_RADIO:
 258                 tuner_dbg("radio freq set to %lu.%02lu\n",
 259                           freq / 16000, freq % 16000 * 100 / 16000);
 260                 set_radio_freq(c, freq);
 261                 t->radio_freq = freq;
 262                 break;
 263         case V4L2_TUNER_ANALOG_TV:
 264         case V4L2_TUNER_DIGITAL_TV:
 265                 tuner_dbg("tv freq set to %lu.%02lu\n",
 266                           freq / 16, freq % 16 * 100 / 16);
 267                 set_tv_freq(c, freq);
 268                 t->tv_freq = freq;
 269                 break;
 270         default:
 271                 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
 272         }
 273 }
 274
 275 static void tuner_i2c_address_check(struct tuner *t)
 276 {
 277         if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
 278             ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
 279                 return;
 280
 281         tuner_warn("====================== WARNING! ======================\n");
 282         tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
 283         tuner_warn("will soon be dropped. This message indicates that your\n");
 284         tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
 285                    t->i2c->name, t->i2c->addr);
 286         tuner_warn("To ensure continued support for your device, please\n");
 287         tuner_warn("send a copy of this message, along with full dmesg\n");
 288         tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
 289         tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
 290         tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
 291                    t->i2c->adapter->name, t->i2c->addr, t->type,
 292                    tuners[t->type].name);
 293         tuner_warn("====================== WARNING! ======================\n");
 294 }
 295
 296 static void attach_simple_tuner(struct tuner *t)
 297 {
 298         struct simple_tuner_config cfg = {
 299                 .type = t->type,
 300                 .tun  = &tuners[t->type]
 301         };
 302         simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
 303 }
 304
 305 static void attach_tda829x(struct tuner *t)
 306 {
 307         struct tda829x_config cfg = {
 308                 .lna_cfg        = &t->config,
 309                 .tuner_callback = t->tuner_callback,
 310         };
 311         tda829x_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
 312 }
 313
 314 static void set_type(struct i2c_client *c, unsigned int type,
 315                      unsigned int new_mode_mask, unsigned int new_config,
 316                      int (*tuner_callback) (void *dev, int command,int arg))
 317 {
 318         struct tuner *t = i2c_get_clientdata(c);
 319         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 320         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 321         unsigned char buffer[4];
 322
 323         if (type == UNSET || type == TUNER_ABSENT) {
 324                 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
 325                 return;
 326         }
 327
 328         if (type >= tuner_count) {
 329                 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
 330                 return;
 331         }
 332
 333         t->type = type;
 334         t->config = new_config;
 335         if (tuner_callback != NULL) {
 336                 tuner_dbg("defining GPIO callback\n");
 337                 t->tuner_callback = tuner_callback;
 338         }
 339
 340         if (t->mode == T_UNINITIALIZED) {
 341                 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
 342
 343                 return;
 344         }
 345
 346         /* discard private data, in case set_type() was previously called */
 347         if (ops && ops->release)
 348                 ops->release(&t->fe);
 349
 350         switch (t->type) {
 351         case TUNER_MT2032:
 352                 microtune_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
 353                 break;
 354         case TUNER_PHILIPS_TDA8290:
 355         {
 356                 attach_tda829x(t);
 357                 break;
 358         }
 359         case TUNER_TEA5767:
 360                 if (tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
 361                         t->type = TUNER_ABSENT;
 362                         t->mode_mask = T_UNINITIALIZED;
 363                         return;
 364                 }
 365                 t->mode_mask = T_RADIO;
 366                 break;
 367         case TUNER_TEA5761:
 368                 if (tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
 369                         t->type = TUNER_ABSENT;
 370                         t->mode_mask = T_UNINITIALIZED;
 371                         return;
 372                 }
 373                 t->mode_mask = T_RADIO;
 374                 break;
 375         case TUNER_PHILIPS_FMD1216ME_MK3:
 376                 buffer[0] = 0x0b;
 377                 buffer[1] = 0xdc;
 378                 buffer[2] = 0x9c;
 379                 buffer[3] = 0x60;
 380                 i2c_master_send(c, buffer, 4);
 381                 mdelay(1);
 382                 buffer[2] = 0x86;
 383                 buffer[3] = 0x54;
 384                 i2c_master_send(c, buffer, 4);
 385                 attach_simple_tuner(t);
 386                 break;
 387         case TUNER_PHILIPS_TD1316:
 388                 buffer[0] = 0x0b;
 389                 buffer[1] = 0xdc;
 390                 buffer[2] = 0x86;
 391                 buffer[3] = 0xa4;
 392                 i2c_master_send(c,buffer,4);
 393                 attach_simple_tuner(t);
 394                 break;
 395         case TUNER_XC2028:
 396         {
 397                 struct xc2028_config cfg = {
 398                         .i2c_adap  = t->i2c->adapter,
 399                         .i2c_addr  = t->i2c->addr,
 400                         .video_dev = c->adapter->algo_data,
 401                         .callback  = t->tuner_callback,
 402                 };
 403                 if (!xc2028_attach(&t->fe, &cfg)) {
 404                         t->type = TUNER_ABSENT;
 405                         t->mode_mask = T_UNINITIALIZED;
 406                         return;
 407                 }
 408                 break;
 409         }
 410         case TUNER_TDA9887:
 411                 tda9887_attach(t);
 412                 break;
 413         default:
 414                 attach_simple_tuner(t);
 415                 break;
 416         }
 417
 418         ops = t->fe.ops.analog_demod_ops;
 419
 420         if (((NULL == ops) || (NULL == ops->set_params)) &&
 421             (fe_tuner_ops->set_analog_params)) {
 422                 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
 423                         sizeof(t->i2c->name));
 424
 425                 t->fe.ops.analog_demod_ops = &tuner_core_ops;
 426                 t->fe.analog_demod_priv = t;
 427         } else {
 428                 strlcpy(t->i2c->name, ops->info.name,
 429                         sizeof(t->i2c->name));
 430         }
 431
 432         tuner_dbg("type set to %s\n", t->i2c->name);
 433
 434         if (t->mode_mask == T_UNINITIALIZED)
 435                 t->mode_mask = new_mode_mask;
 436
 437         set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
 438         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 439                   c->adapter->name, c->driver->driver.name, c->addr << 1, type,
 440                   t->mode_mask);
 441         tuner_i2c_address_check(t);
 442 }
 443
 444 /*
 445  * This function apply tuner config to tuner specified
 446  * by tun_setup structure. I addr is unset, then admin status
 447  * and tun addr status is more precise then current status,
 448  * it's applied. Otherwise status and type are applied only to
 449  * tuner with exactly the same addr.
 450 */
 451
 452 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 453 {
 454         struct tuner *t = i2c_get_clientdata(c);
 455
 456         tuner_dbg("set addr for type %i\n", t->type);
 457
 458         if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
 459                 (t->mode_mask & tun_setup->mode_mask))) ||
 460                 (tun_setup->addr == c->addr)) {
 461                         set_type(c, tun_setup->type, tun_setup->mode_mask,
 462                                  tun_setup->config, tun_setup->tuner_callback);
 463         }
 464 }
 465
 466 static inline int check_mode(struct tuner *t, char *cmd)
 467 {
 468         if ((1 << t->mode & t->mode_mask) == 0) {
 469                 return EINVAL;
 470         }
 471
 472         switch (t->mode) {
 473         case V4L2_TUNER_RADIO:
 474                 tuner_dbg("Cmd %s accepted for radio\n", cmd);
 475                 break;
 476         case V4L2_TUNER_ANALOG_TV:
 477                 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
 478                 break;
 479         case V4L2_TUNER_DIGITAL_TV:
 480                 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
 481                 break;
 482         }
 483         return 0;
 484 }
 485
 486 /* get more precise norm info from insmod option */
 487 static int tuner_fixup_std(struct tuner *t)
 488 {
 489         if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 490                 switch (pal[0]) {
 491                 case '6':
 492                         tuner_dbg ("insmod fixup: PAL => PAL-60\n");
 493                         t->std = V4L2_STD_PAL_60;
 494                         break;
 495                 case 'b':
 496                 case 'B':
 497                 case 'g':
 498                 case 'G':
 499                         tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
 500                         t->std = V4L2_STD_PAL_BG;
 501                         break;
 502                 case 'i':
 503                 case 'I':
 504                         tuner_dbg ("insmod fixup: PAL => PAL-I\n");
 505                         t->std = V4L2_STD_PAL_I;
 506                         break;
 507                 case 'd':
 508                 case 'D':
 509                 case 'k':
 510                 case 'K':
 511                         tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
 512                         t->std = V4L2_STD_PAL_DK;
 513                         break;
 514                 case 'M':
 515                 case 'm':
 516                         tuner_dbg ("insmod fixup: PAL => PAL-M\n");
 517                         t->std = V4L2_STD_PAL_M;
 518                         break;
 519                 case 'N':
 520                 case 'n':
 521                         if (pal[1] == 'c' || pal[1] == 'C') {
 522                                 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
 523                                 t->std = V4L2_STD_PAL_Nc;
 524                         } else {
 525                                 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
 526                                 t->std = V4L2_STD_PAL_N;
 527                         }
 528                         break;
 529                 case '-':
 530                         /* default parameter, do nothing */
 531                         break;
 532                 default:
 533                         tuner_warn ("pal= argument not recognised\n");
 534                         break;
 535                 }
 536         }
 537         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 538                 switch (secam[0]) {
 539                 case 'b':
 540                 case 'B':
 541                 case 'g':
 542                 case 'G':
 543                 case 'h':
 544                 case 'H':
 545                         tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
 546                         t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 547                         break;
 548                 case 'd':
 549                 case 'D':
 550                 case 'k':
 551                 case 'K':
 552                         tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
 553                         t->std = V4L2_STD_SECAM_DK;
 554                         break;
 555                 case 'l':
 556                 case 'L':
 557                         if ((secam[1]=='C')||(secam[1]=='c')) {
 558                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
 559                                 t->std = V4L2_STD_SECAM_LC;
 560                         } else {
 561                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
 562                                 t->std = V4L2_STD_SECAM_L;
 563                         }
 564                         break;
 565                 case '-':
 566                         /* default parameter, do nothing */
 567                         break;
 568                 default:
 569                         tuner_warn ("secam= argument not recognised\n");
 570                         break;
 571                 }
 572         }
 573
 574         if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 575                 switch (ntsc[0]) {
 576                 case 'm':
 577                 case 'M':
 578                         tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
 579                         t->std = V4L2_STD_NTSC_M;
 580                         break;
 581                 case 'j':
 582                 case 'J':
 583                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
 584                         t->std = V4L2_STD_NTSC_M_JP;
 585                         break;
 586                 case 'k':
 587                 case 'K':
 588                         tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
 589                         t->std = V4L2_STD_NTSC_M_KR;
 590                         break;
 591                 case '-':
 592                         /* default parameter, do nothing */
 593                         break;
 594                 default:
 595                         tuner_info("ntsc= argument not recognised\n");
 596                         break;
 597                 }
 598         }
 599         return 0;
 600 }
 601
 602 static void tuner_status(struct dvb_frontend *fe)
 603 {
 604         struct tuner *t = fe->analog_demod_priv;
 605         unsigned long freq, freq_fraction;
 606         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 607         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 608         const char *p;
 609
 610         switch (t->mode) {
 611                 case V4L2_TUNER_RADIO:      p = "radio"; break;
 612                 case V4L2_TUNER_ANALOG_TV:  p = "analog TV"; break;
 613                 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
 614                 default: p = "undefined"; break;
 615         }
 616         if (t->mode == V4L2_TUNER_RADIO) {
 617                 freq = t->radio_freq / 16000;
 618                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
 619         } else {
 620                 freq = t->tv_freq / 16;
 621                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
 622         }
 623         tuner_info("Tuner mode:      %s\n", p);
 624         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
 625         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
 626         if (t->mode != V4L2_TUNER_RADIO)
 627                return;
 628         if (fe_tuner_ops->get_status) {
 629                 u32 tuner_status;
 630
 631                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 632                 if (tuner_status & TUNER_STATUS_LOCKED)
 633                         tuner_info("Tuner is locked.\n");
 634                 if (tuner_status & TUNER_STATUS_STEREO)
 635                         tuner_info("Stereo:          yes\n");
 636         }
 637         if (ops) {
 638                 if (ops->has_signal)
 639                         tuner_info("Signal strength: %d\n",
 640                                    ops->has_signal(fe));
 641                 if (ops->is_stereo)
 642                         tuner_info("Stereo:          %s\n",
 643                                    ops->is_stereo(fe) ? "yes" : "no");
 644         }
 645 }
 646
 647 /* ---------------------------------------------------------------------- */
 648
 649 /*
 650  * Switch tuner to other mode. If tuner support both tv and radio,
 651  * set another frequency to some value (This is needed for some pal
 652  * tuners to avoid locking). Otherwise, just put second tuner in
 653  * standby mode.
 654  */
 655
 656 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 657 {
 658         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 659
 660         if (mode == t->mode)
 661                 return 0;
 662
 663         t->mode = mode;
 664
 665         if (check_mode(t, cmd) == EINVAL) {
 666                 t->mode = T_STANDBY;
 667                 if (ops && ops->standby)
 668                         ops->standby(&t->fe);
 669                 return EINVAL;
 670         }
 671         return 0;
 672 }
 673
 674 #define switch_v4l2()   if (!t->using_v4l2) \
 675                             tuner_dbg("switching to v4l2\n"); \
 676                         t->using_v4l2 = 1;
 677
 678 static inline int check_v4l2(struct tuner *t)
 679 {
 680         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 681            TV, v4l1 for radio), until that is fixed this code is disabled.
 682            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 683            first. */
 684         return 0;
 685 }
 686
 687 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
 688 {
 689         struct tuner *t = i2c_get_clientdata(client);
 690         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 691         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 692
 693         if (tuner_debug>1)
 694                 v4l_i2c_print_ioctl(client,cmd);
 695
 696         switch (cmd) {
 697         /* --- configuration --- */
 698         case TUNER_SET_TYPE_ADDR:
 699                 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 700                                 ((struct tuner_setup *)arg)->type,
 701                                 ((struct tuner_setup *)arg)->addr,
 702                                 ((struct tuner_setup *)arg)->mode_mask,
 703                                 ((struct tuner_setup *)arg)->config);
 704
 705                 set_addr(client, (struct tuner_setup *)arg);
 706                 break;
 707         case AUDC_SET_RADIO:
 708                 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 709                                 == EINVAL)
 710                         return 0;
 711                 if (t->radio_freq)
 712                         set_freq(client, t->radio_freq);
 713                 break;
 714         case TUNER_SET_STANDBY:
 715                 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
 716                         return 0;
 717                 t->mode = T_STANDBY;
 718                 if (ops && ops->standby)
 719                         ops->standby(&t->fe);
 720                 break;
 721 #ifdef CONFIG_VIDEO_V4L1
 722         case VIDIOCSAUDIO:
 723                 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
 724                         return 0;
 725                 if (check_v4l2(t) == EINVAL)
 726                         return 0;
 727
 728                 /* Should be implemented, since bttv calls it */
 729                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 730                 break;
 731         case VIDIOCSCHAN:
 732                 {
 733                         static const v4l2_std_id map[] = {
 734                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 735                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 736                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 737                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 738                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 739                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 740                         };
 741                         struct video_channel *vc = arg;
 742
 743                         if (check_v4l2(t) == EINVAL)
 744                                 return 0;
 745
 746                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
 747                                 return 0;
 748
 749                         if (vc->norm < ARRAY_SIZE(map))
 750                                 t->std = map[vc->norm];
 751                         tuner_fixup_std(t);
 752                         if (t->tv_freq)
 753                                 set_tv_freq(client, t->tv_freq);
 754                         return 0;
 755                 }
 756         case VIDIOCSFREQ:
 757                 {
 758                         unsigned long *v = arg;
 759
 760                         if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
 761                                 return 0;
 762                         if (check_v4l2(t) == EINVAL)
 763                                 return 0;
 764
 765                         set_freq(client, *v);
 766                         return 0;
 767                 }
 768         case VIDIOCGTUNER:
 769                 {
 770                         struct video_tuner *vt = arg;
 771
 772                         if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
 773                                 return 0;
 774                         if (check_v4l2(t) == EINVAL)
 775                                 return 0;
 776
 777                         if (V4L2_TUNER_RADIO == t->mode) {
 778                                 if (fe_tuner_ops->get_status) {
 779                                         u32 tuner_status;
 780
 781                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 782                                         if (tuner_status & TUNER_STATUS_STEREO)
 783                                                 vt->flags |= VIDEO_TUNER_STEREO_ON;
 784                                         else
 785                                                 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
 786                                 } else {
 787                                         if (ops && ops->is_stereo) {
 788                                                 if (ops->is_stereo(&t->fe))
 789                                                         vt->flags |=
 790                                                                 VIDEO_TUNER_STEREO_ON;
 791                                                 else
 792                                                         vt->flags &=
 793                                                                 ~VIDEO_TUNER_STEREO_ON;
 794                                         }
 795                                 }
 796                                 if (ops && ops->has_signal)
 797                                         vt->signal = ops->has_signal(&t->fe);
 798
 799                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 800
 801                                 vt->rangelow = radio_range[0] * 16000;
 802                                 vt->rangehigh = radio_range[1] * 16000;
 803
 804                         } else {
 805                                 vt->rangelow = tv_range[0] * 16;
 806                                 vt->rangehigh = tv_range[1] * 16;
 807                         }
 808
 809                         return 0;
 810                 }
 811         case VIDIOCGAUDIO:
 812                 {
 813                         struct video_audio *va = arg;
 814
 815                         if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
 816                                 return 0;
 817                         if (check_v4l2(t) == EINVAL)
 818                                 return 0;
 819
 820                         if (V4L2_TUNER_RADIO == t->mode) {
 821                                 if (fe_tuner_ops->get_status) {
 822                                         u32 tuner_status;
 823
 824                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 825                                         va->mode = (tuner_status & TUNER_STATUS_STEREO)
 826                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 827                                 } else if (ops && ops->is_stereo)
 828                                         va->mode = ops->is_stereo(&t->fe)
 829                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 830                         }
 831                         return 0;
 832                 }
 833 #endif
 834         case TUNER_SET_CONFIG:
 835         {
 836                 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 837                 struct v4l2_priv_tun_config *cfg = arg;
 838
 839                 if (t->type != cfg->tuner)
 840                         break;
 841
 842                 if (t->type == TUNER_TDA9887) {
 843                         t->tda9887_config = *(unsigned int *)cfg->priv;
 844                         set_freq(client, t->tv_freq);
 845                         break;
 846                 }
 847
 848                 if (NULL == fe_tuner_ops->set_config) {
 849                         tuner_warn("Tuner frontend module has no way to "
 850                                    "set config\n");
 851                         break;
 852                 }
 853                 fe_tuner_ops->set_config(&t->fe, cfg->priv);
 854
 855                 break;
 856         }
 857         /* --- v4l ioctls --- */
 858         /* take care: bttv does userspace copying, we'll get a
 859            kernel pointer here... */
 860         case VIDIOC_S_STD:
 861                 {
 862                         v4l2_std_id *id = arg;
 863
 864                         if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 865                                         == EINVAL)
 866                                 return 0;
 867
 868                         switch_v4l2();
 869
 870                         t->std = *id;
 871                         tuner_fixup_std(t);
 872                         if (t->tv_freq)
 873                                 set_freq(client, t->tv_freq);
 874                         break;
 875                 }
 876         case VIDIOC_S_FREQUENCY:
 877                 {
 878                         struct v4l2_frequency *f = arg;
 879
 880                         if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
 881                                         == EINVAL)
 882                                 return 0;
 883                         switch_v4l2();
 884                         set_freq(client,f->frequency);
 885
 886                         break;
 887                 }
 888         case VIDIOC_G_FREQUENCY:
 889                 {
 890                         struct v4l2_frequency *f = arg;
 891
 892                         if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
 893                                 return 0;
 894                         switch_v4l2();
 895                         f->type = t->mode;
 896                         if (fe_tuner_ops->get_frequency) {
 897                                 u32 abs_freq;
 898
 899                                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 900                                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 901                                         (abs_freq * 2 + 125/2) / 125 :
 902                                         (abs_freq + 62500/2) / 62500;
 903                                 break;
 904                         }
 905                         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 906                                 t->radio_freq : t->tv_freq;
 907                         break;
 908                 }
 909         case VIDIOC_G_TUNER:
 910                 {
 911                         struct v4l2_tuner *tuner = arg;
 912
 913                         if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
 914                                 return 0;
 915                         switch_v4l2();
 916
 917                         tuner->type = t->mode;
 918                         if (ops && ops->get_afc)
 919                                 tuner->afc = ops->get_afc(&t->fe);
 920                         if (t->mode == V4L2_TUNER_ANALOG_TV)
 921                                 tuner->capability |= V4L2_TUNER_CAP_NORM;
 922                         if (t->mode != V4L2_TUNER_RADIO) {
 923                                 tuner->rangelow = tv_range[0] * 16;
 924                                 tuner->rangehigh = tv_range[1] * 16;
 925                                 break;
 926                         }
 927
 928                         /* radio mode */
 929                         tuner->rxsubchans =
 930                                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 931                         if (fe_tuner_ops->get_status) {
 932                                 u32 tuner_status;
 933
 934                                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 935                                 tuner->rxsubchans =
 936                                         (tuner_status & TUNER_STATUS_STEREO) ?
 937                                         V4L2_TUNER_SUB_STEREO :
 938                                         V4L2_TUNER_SUB_MONO;
 939                         } else {
 940                                 if (ops && ops->is_stereo) {
 941                                         tuner->rxsubchans =
 942                                                 ops->is_stereo(&t->fe) ?
 943                                                 V4L2_TUNER_SUB_STEREO :
 944                                                 V4L2_TUNER_SUB_MONO;
 945                                 }
 946                         }
 947                         if (ops && ops->has_signal)
 948                                 tuner->signal = ops->has_signal(&t->fe);
 949                         tuner->capability |=
 950                             V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
 951                         tuner->audmode = t->audmode;
 952                         tuner->rangelow = radio_range[0] * 16000;
 953                         tuner->rangehigh = radio_range[1] * 16000;
 954                         break;
 955                 }
 956         case VIDIOC_S_TUNER:
 957                 {
 958                         struct v4l2_tuner *tuner = arg;
 959
 960                         if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
 961                                 return 0;
 962
 963                         switch_v4l2();
 964
 965                         /* do nothing unless we're a radio tuner */
 966                         if (t->mode != V4L2_TUNER_RADIO)
 967                                 break;
 968                         t->audmode = tuner->audmode;
 969                         set_radio_freq(client, t->radio_freq);
 970                         break;
 971                 }
 972         case VIDIOC_LOG_STATUS:
 973                 if (ops && ops->tuner_status)
 974                         ops->tuner_status(&t->fe);
 975                 break;
 976         }
 977
 978         return 0;
 979 }
 980
 981 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
 982 {
 983         struct tuner *t = i2c_get_clientdata(c);
 984
 985         tuner_dbg("suspend\n");
 986         /* FIXME: power down ??? */
 987         return 0;
 988 }
 989
 990 static int tuner_resume(struct i2c_client *c)
 991 {
 992         struct tuner *t = i2c_get_clientdata(c);
 993
 994         tuner_dbg("resume\n");
 995         if (V4L2_TUNER_RADIO == t->mode) {
 996                 if (t->radio_freq)
 997                         set_freq(c, t->radio_freq);
 998         } else {
 999                 if (t->tv_freq)
1000                         set_freq(c, t->tv_freq);
1001         }
1002         return 0;
1003 }
1004
1005 /* ---------------------------------------------------------------------- */
1006
1007 LIST_HEAD(tuner_list);
1008
1009 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1010    Note that when this function is called from tuner_probe you can be
1011    certain no other devices will be added/deleted at the same time, I2C
1012    core protects against that. */
1013 static void tuner_lookup(struct i2c_adapter *adap,
1014                 struct tuner **radio, struct tuner **tv)
1015 {
1016         struct tuner *pos;
1017
1018         *radio = NULL;
1019         *tv = NULL;
1020
1021         list_for_each_entry(pos, &tuner_list, list) {
1022                 int mode_mask;
1023
1024                 if (pos->i2c->adapter != adap ||
1025                     pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1026                         continue;
1027
1028                 mode_mask = pos->mode_mask & ~T_STANDBY;
1029                 if (*radio == NULL && mode_mask == T_RADIO)
1030                         *radio = pos;
1031                 /* Note: currently TDA9887 is the only demod-only
1032                    device. If other devices appear then we need to
1033                    make this test more general. */
1034                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1035                          (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1036                         *tv = pos;
1037         }
1038 }
1039
1040 /* During client attach, set_type is called by adapter's attach_inform callback.
1041    set_type must then be completed by tuner_probe.
1042  */
1043 static int tuner_probe(struct i2c_client *client)
1044 {
1045         struct tuner *t;
1046         struct tuner *radio;
1047         struct tuner *tv;
1048
1049         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1050         if (NULL == t)
1051                 return -ENOMEM;
1052         t->i2c = client;
1053         strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1054         i2c_set_clientdata(client, t);
1055         t->type = UNSET;
1056         t->audmode = V4L2_TUNER_MODE_STEREO;
1057         t->mode_mask = T_UNINITIALIZED;
1058
1059         if (show_i2c) {
1060                 unsigned char buffer[16];
1061                 int i, rc;
1062
1063                 memset(buffer, 0, sizeof(buffer));
1064                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1065                 tuner_info("I2C RECV = ");
1066                 for (i = 0; i < rc; i++)
1067                         printk(KERN_CONT "%02x ", buffer[i]);
1068                 printk("\n");
1069         }
1070         /* HACK: This test was added to avoid tuner to probe tda9840 and
1071            tea6415c on the MXB card */
1072         if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1073                 kfree(t);
1074                 return -ENODEV;
1075         }
1076
1077         /* autodetection code based on the i2c addr */
1078         if (!no_autodetect) {
1079                 switch (client->addr) {
1080                 case 0x10:
1081                         if (tea5761_autodetection(t->i2c->adapter, t->i2c->addr)
1082                                         != EINVAL) {
1083                                 t->type = TUNER_TEA5761;
1084                                 t->mode_mask = T_RADIO;
1085                                 t->mode = T_STANDBY;
1086                                 /* Sets freq to FM range */
1087                                 t->radio_freq = 87.5 * 16000;
1088                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1089                                 if (tv)
1090                                         tv->mode_mask &= ~T_RADIO;
1091
1092                                 goto register_client;
1093                         }
1094                         break;
1095                 case 0x42:
1096                 case 0x43:
1097                 case 0x4a:
1098                 case 0x4b:
1099                         /* If chip is not tda8290, don't register.
1100                            since it can be tda9887*/
1101                         if (tda829x_probe(t->i2c->adapter,
1102                                           t->i2c->addr) == 0) {
1103                                 tuner_dbg("tda829x detected\n");
1104                         } else {
1105                                 /* Default is being tda9887 */
1106                                 t->type = TUNER_TDA9887;
1107                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1108                                                T_DIGITAL_TV;
1109                                 t->mode = T_STANDBY;
1110                                 goto register_client;
1111                         }
1112                         break;
1113                 case 0x60:
1114                         if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1115                                         != EINVAL) {
1116                                 t->type = TUNER_TEA5767;
1117                                 t->mode_mask = T_RADIO;
1118                                 t->mode = T_STANDBY;
1119                                 /* Sets freq to FM range */
1120                                 t->radio_freq = 87.5 * 16000;
1121                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1122                                 if (tv)
1123                                         tv->mode_mask &= ~T_RADIO;
1124
1125                                 goto register_client;
1126                         }
1127                         break;
1128                 }
1129         }
1130
1131         /* Initializes only the first TV tuner on this adapter. Why only the
1132            first? Because there are some devices (notably the ones with TI
1133            tuners) that have more than one i2c address for the *same* device.
1134            Experience shows that, except for just one case, the first
1135            address is the right one. The exception is a Russian tuner
1136            (ACORP_Y878F). So, the desired behavior is just to enable the
1137            first found TV tuner. */
1138         tuner_lookup(t->i2c->adapter, &radio, &tv);
1139         if (tv == NULL) {
1140                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1141                 if (radio == NULL)
1142                         t->mode_mask |= T_RADIO;
1143                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1144                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1145                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1146         }
1147
1148         /* Should be just before return */
1149 register_client:
1150         tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1151                        client->adapter->name);
1152
1153         /* Sets a default mode */
1154         if (t->mode_mask & T_ANALOG_TV) {
1155                 t->mode = V4L2_TUNER_ANALOG_TV;
1156         } else  if (t->mode_mask & T_RADIO) {
1157                 t->mode = V4L2_TUNER_RADIO;
1158         } else {
1159                 t->mode = V4L2_TUNER_DIGITAL_TV;
1160         }
1161         set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1162         list_add_tail(&t->list, &tuner_list);
1163         return 0;
1164 }
1165
1166 static int tuner_legacy_probe(struct i2c_adapter *adap)
1167 {
1168         if (0 != addr) {
1169                 normal_i2c[0] = addr;
1170                 normal_i2c[1] = I2C_CLIENT_END;
1171         }
1172
1173         if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1174                 return 0;
1175
1176         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1177          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1178          * and an RTC at 0x6f which can get corrupted if probed.
1179          */
1180         if ((adap->id == I2C_HW_B_CX2388x) ||
1181             (adap->id == I2C_HW_B_CX23885)) {
1182                 unsigned int i = 0;
1183
1184                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1185                         i += 2;
1186                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1187                         ignore[i+0] = adap->nr;
1188                         ignore[i+1] = 0x6b;
1189                         ignore[i+2] = adap->nr;
1190                         ignore[i+3] = 0x6f;
1191                         ignore[i+4] = I2C_CLIENT_END;
1192                 } else
1193                         printk(KERN_WARNING "tuner: "
1194                                "too many options specified "
1195                                "in i2c probe ignore list!\n");
1196         }
1197         return 1;
1198 }
1199
1200 static int tuner_remove(struct i2c_client *client)
1201 {
1202         struct tuner *t = i2c_get_clientdata(client);
1203         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
1204
1205         if (ops && ops->release)
1206                 ops->release(&t->fe);
1207
1208         list_del(&t->list);
1209         kfree(t);
1210         return 0;
1211 }
1212
1213 /* ----------------------------------------------------------------------- */
1214
1215 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1216         .name = "tuner",
1217         .driverid = I2C_DRIVERID_TUNER,
1218         .command = tuner_command,
1219         .probe = tuner_probe,
1220         .remove = tuner_remove,
1221         .suspend = tuner_suspend,
1222         .resume = tuner_resume,
1223         .legacy_probe = tuner_legacy_probe,
1224 };
1225
1226
1227 /*
1228  * Overrides for Emacs so that we follow Linus's tabbing style.
1229  * ---------------------------------------------------------------------------
1230  * Local variables:
1231  * c-basic-offset: 8
1232  * End:
1233  */