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