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