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