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