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