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 };
  96
  97 /* standard i2c insmod options */
  98 static unsigned short normal_i2c[] = {
  99 #if defined(CONFIG_MEDIA_TUNER_TEA5761) || (defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE) && defined(MODULE))
 100         0x10,
 101 #endif
 102         0x42, 0x43, 0x4a, 0x4b,                 /* tda8290 */
 103         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 104         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 105         I2C_CLIENT_END
 106 };
 107
 108 I2C_CLIENT_INSMOD;
 109
 110 /* insmod options used at init time => read/only */
 111 static unsigned int addr;
 112 static unsigned int no_autodetect;
 113 static unsigned int show_i2c;
 114
 115 /* insmod options used at runtime => read/write */
 116 static int tuner_debug;
 117
 118 #define tuner_warn(fmt, arg...) do {                    \
 119         printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
 120                i2c_adapter_id(t->i2c->adapter),         \
 121                t->i2c->addr, ##arg);                    \
 122          } while (0)
 123
 124 #define tuner_info(fmt, arg...) do {                    \
 125         printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX,    \
 126                i2c_adapter_id(t->i2c->adapter),         \
 127                t->i2c->addr, ##arg);                    \
 128          } while (0)
 129
 130 #define tuner_err(fmt, arg...) do {                     \
 131         printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX,     \
 132                i2c_adapter_id(t->i2c->adapter),         \
 133                t->i2c->addr, ##arg);                    \
 134          } while (0)
 135
 136 #define tuner_dbg(fmt, arg...) do {                             \
 137         if (tuner_debug)                                        \
 138                 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX,   \
 139                        i2c_adapter_id(t->i2c->adapter),         \
 140                        t->i2c->addr, ##arg);                    \
 141          } while (0)
 142
 143 /* ------------------------------------------------------------------------ */
 144
 145 static unsigned int tv_range[2] = { 44, 958 };
 146 static unsigned int radio_range[2] = { 65, 108 };
 147
 148 static char pal[] = "--";
 149 static char secam[] = "--";
 150 static char ntsc[] = "-";
 151
 152
 153 module_param(addr, int, 0444);
 154 module_param(no_autodetect, int, 0444);
 155 module_param(show_i2c, int, 0444);
 156 module_param_named(debug,tuner_debug, int, 0644);
 157 module_param_string(pal, pal, sizeof(pal), 0644);
 158 module_param_string(secam, secam, sizeof(secam), 0644);
 159 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
 160 module_param_array(tv_range, int, NULL, 0644);
 161 module_param_array(radio_range, int, NULL, 0644);
 162
 163 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
 164 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
 165 MODULE_LICENSE("GPL");
 166
 167 /* ---------------------------------------------------------------------- */
 168
 169 static void fe_set_params(struct dvb_frontend *fe,
 170                           struct analog_parameters *params)
 171 {
 172         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 173         struct tuner *t = fe->analog_demod_priv;
 174
 175         if (NULL == fe_tuner_ops->set_analog_params) {
 176                 tuner_warn("Tuner frontend module has no way to set freq\n");
 177                 return;
 178         }
 179         fe_tuner_ops->set_analog_params(fe, params);
 180 }
 181
 182 static void fe_standby(struct dvb_frontend *fe)
 183 {
 184         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 185
 186         if (fe_tuner_ops->sleep)
 187                 fe_tuner_ops->sleep(fe);
 188 }
 189
 190 static int fe_has_signal(struct dvb_frontend *fe)
 191 {
 192         u16 strength = 0;
 193
 194         if (fe->ops.tuner_ops.get_rf_strength)
 195                 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
 196
 197         return strength;
 198 }
 199
 200 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
 201 {
 202         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 203         struct tuner *t = fe->analog_demod_priv;
 204
 205         if (fe_tuner_ops->set_config)
 206                 return fe_tuner_ops->set_config(fe, priv_cfg);
 207
 208         tuner_warn("Tuner frontend module has no way to set config\n");
 209
 210         return 0;
 211 }
 212
 213 static void tuner_status(struct dvb_frontend *fe);
 214
 215 static struct analog_demod_ops tuner_core_ops = {
 216         .set_params     = fe_set_params,
 217         .standby        = fe_standby,
 218         .has_signal     = fe_has_signal,
 219         .set_config     = fe_set_config,
 220         .tuner_status   = tuner_status
 221 };
 222
 223 /* Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz */
 224 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
 225 {
 226         struct tuner *t = i2c_get_clientdata(c);
 227         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 228
 229         struct analog_parameters params = {
 230                 .mode      = t->mode,
 231                 .audmode   = t->audmode,
 232                 .std       = t->std
 233         };
 234
 235         if (t->type == UNSET) {
 236                 tuner_warn ("tuner type not set\n");
 237                 return;
 238         }
 239         if (NULL == analog_ops->set_params) {
 240                 tuner_warn ("Tuner has no way to set tv freq\n");
 241                 return;
 242         }
 243         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
 244                 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
 245                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
 246                            tv_range[1]);
 247                 /* V4L2 spec: if the freq is not possible then the closest
 248                    possible value should be selected */
 249                 if (freq < tv_range[0] * 16)
 250                         freq = tv_range[0] * 16;
 251                 else
 252                         freq = tv_range[1] * 16;
 253         }
 254         params.frequency = freq;
 255
 256         analog_ops->set_params(&t->fe, &params);
 257 }
 258
 259 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
 260 {
 261         struct tuner *t = i2c_get_clientdata(c);
 262         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 263
 264         struct analog_parameters params = {
 265                 .mode      = t->mode,
 266                 .audmode   = t->audmode,
 267                 .std       = t->std
 268         };
 269
 270         if (t->type == UNSET) {
 271                 tuner_warn ("tuner type not set\n");
 272                 return;
 273         }
 274         if (NULL == analog_ops->set_params) {
 275                 tuner_warn ("tuner has no way to set radio frequency\n");
 276                 return;
 277         }
 278         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
 279                 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
 280                            freq / 16000, freq % 16000 * 100 / 16000,
 281                            radio_range[0], radio_range[1]);
 282                 /* V4L2 spec: if the freq is not possible then the closest
 283                    possible value should be selected */
 284                 if (freq < radio_range[0] * 16000)
 285                         freq = radio_range[0] * 16000;
 286                 else
 287                         freq = radio_range[1] * 16000;
 288         }
 289         params.frequency = freq;
 290
 291         analog_ops->set_params(&t->fe, &params);
 292 }
 293
 294 static void set_freq(struct i2c_client *c, unsigned long freq)
 295 {
 296         struct tuner *t = i2c_get_clientdata(c);
 297
 298         switch (t->mode) {
 299         case V4L2_TUNER_RADIO:
 300                 tuner_dbg("radio freq set to %lu.%02lu\n",
 301                           freq / 16000, freq % 16000 * 100 / 16000);
 302                 set_radio_freq(c, freq);
 303                 t->radio_freq = freq;
 304                 break;
 305         case V4L2_TUNER_ANALOG_TV:
 306         case V4L2_TUNER_DIGITAL_TV:
 307                 tuner_dbg("tv freq set to %lu.%02lu\n",
 308                           freq / 16, freq % 16 * 100 / 16);
 309                 set_tv_freq(c, freq);
 310                 t->tv_freq = freq;
 311                 break;
 312         default:
 313                 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
 314         }
 315 }
 316
 317 static void tuner_i2c_address_check(struct tuner *t)
 318 {
 319         if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
 320             ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
 321                 return;
 322
 323         /* We already know that the XC5000 can only be located at
 324          * i2c address 0x61, 0x62, 0x63 or 0x64 */
 325         if ((t->type == TUNER_XC5000) &&
 326             ((t->i2c->addr <= 0x64)) && (t->i2c->addr >= 0x61))
 327                 return;
 328
 329         tuner_warn("====================== WARNING! ======================\n");
 330         tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
 331         tuner_warn("will soon be dropped. This message indicates that your\n");
 332         tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
 333                    t->i2c->name, t->i2c->addr);
 334         tuner_warn("To ensure continued support for your device, please\n");
 335         tuner_warn("send a copy of this message, along with full dmesg\n");
 336         tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
 337         tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
 338         tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
 339                    t->i2c->adapter->name, t->i2c->addr, t->type, t->i2c->name);
 340         tuner_warn("====================== WARNING! ======================\n");
 341 }
 342
 343 static struct xc5000_config xc5000_cfg;
 344
 345 static void set_type(struct i2c_client *c, unsigned int type,
 346                      unsigned int new_mode_mask, unsigned int new_config,
 347                      int (*tuner_callback) (void *dev, int command,int arg))
 348 {
 349         struct tuner *t = i2c_get_clientdata(c);
 350         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 351         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 352         unsigned char buffer[4];
 353
 354         if (type == UNSET || type == TUNER_ABSENT) {
 355                 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
 356                 return;
 357         }
 358
 359         t->type = type;
 360         t->config = new_config;
 361         if (tuner_callback != NULL) {
 362                 tuner_dbg("defining GPIO callback\n");
 363                 t->tuner_callback = tuner_callback;
 364         }
 365
 366         if (t->mode == T_UNINITIALIZED) {
 367                 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
 368
 369                 return;
 370         }
 371
 372         /* discard private data, in case set_type() was previously called */
 373         tuner_detach(&t->fe);
 374         t->fe.analog_demod_priv = NULL;
 375
 376         switch (t->type) {
 377         case TUNER_MT2032:
 378                 if (!dvb_attach(microtune_attach,
 379                            &t->fe, t->i2c->adapter, t->i2c->addr))
 380                         goto attach_failed;
 381                 break;
 382         case TUNER_PHILIPS_TDA8290:
 383         {
 384                 struct tda829x_config cfg = {
 385                         .lna_cfg        = t->config,
 386                         .tuner_callback = t->tuner_callback,
 387                 };
 388                 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
 389                                 t->i2c->addr, &cfg))
 390                         goto attach_failed;
 391                 break;
 392         }
 393         case TUNER_TEA5767:
 394                 if (!dvb_attach(tea5767_attach, &t->fe,
 395                                 t->i2c->adapter, t->i2c->addr))
 396                         goto attach_failed;
 397                 t->mode_mask = T_RADIO;
 398                 break;
 399         case TUNER_TEA5761:
 400                 if (!dvb_attach(tea5761_attach, &t->fe,
 401                                 t->i2c->adapter, t->i2c->addr))
 402                         goto attach_failed;
 403                 t->mode_mask = T_RADIO;
 404                 break;
 405         case TUNER_PHILIPS_FMD1216ME_MK3:
 406                 buffer[0] = 0x0b;
 407                 buffer[1] = 0xdc;
 408                 buffer[2] = 0x9c;
 409                 buffer[3] = 0x60;
 410                 i2c_master_send(c, buffer, 4);
 411                 mdelay(1);
 412                 buffer[2] = 0x86;
 413                 buffer[3] = 0x54;
 414                 i2c_master_send(c, buffer, 4);
 415                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 416                                 t->i2c->adapter, t->i2c->addr, t->type))
 417                         goto attach_failed;
 418                 break;
 419         case TUNER_PHILIPS_TD1316:
 420                 buffer[0] = 0x0b;
 421                 buffer[1] = 0xdc;
 422                 buffer[2] = 0x86;
 423                 buffer[3] = 0xa4;
 424                 i2c_master_send(c, buffer, 4);
 425                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 426                                 t->i2c->adapter, t->i2c->addr, t->type))
 427                         goto attach_failed;
 428                 break;
 429         case TUNER_XC2028:
 430         {
 431                 struct xc2028_config cfg = {
 432                         .i2c_adap  = t->i2c->adapter,
 433                         .i2c_addr  = t->i2c->addr,
 434                         .callback  = t->tuner_callback,
 435                 };
 436                 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
 437                         goto attach_failed;
 438                 break;
 439         }
 440         case TUNER_TDA9887:
 441                 if (!dvb_attach(tda9887_attach,
 442                            &t->fe, t->i2c->adapter, t->i2c->addr))
 443                         goto attach_failed;
 444                 break;
 445         case TUNER_XC5000:
 446         {
 447                 struct dvb_tuner_ops *xc_tuner_ops;
 448
 449                 xc5000_cfg.i2c_address    = t->i2c->addr;
 450                 xc5000_cfg.if_khz         = 5380;
 451                 xc5000_cfg.tuner_callback = t->tuner_callback;
 452                 if (!dvb_attach(xc5000_attach,
 453                                 &t->fe, t->i2c->adapter, &xc5000_cfg,
 454                                 c->adapter->algo_data))
 455                         goto attach_failed;
 456
 457                 xc_tuner_ops = &t->fe.ops.tuner_ops;
 458                 if (xc_tuner_ops->init)
 459                         xc_tuner_ops->init(&t->fe);
 460                 break;
 461         }
 462         default:
 463                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 464                                 t->i2c->adapter, t->i2c->addr, t->type))
 465                         goto attach_failed;
 466
 467                 break;
 468         }
 469
 470         if ((NULL == analog_ops->set_params) &&
 471             (fe_tuner_ops->set_analog_params)) {
 472
 473                 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
 474                         sizeof(t->i2c->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                 strlcpy(t->i2c->name, analog_ops->info.name,
 482                         sizeof(t->i2c->name));
 483         }
 484
 485         tuner_dbg("type set to %s\n", t->i2c->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         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
1276         /* The probing code has overwritten the device name, restore it so
1277            that reloading the driver will work. Ideally the device name
1278            should not be overwritten in the first place, but for now that
1279            will do. */
1280         strlcpy(client->name, "tuner", I2C_NAME_SIZE);
1281         return 0;
1282 }
1283
1284 /* ----------------------------------------------------------------------- */
1285
1286 /* This driver supports many devices and the idea is to let the driver
1287    detect which device is present. So rather than listing all supported
1288    devices here, we pretend to support a single, fake device type. */
1289 static const struct i2c_device_id tuner_id[] = {
1290         { "tuner", }, /* autodetect */
1291         { }
1292 };
1293 MODULE_DEVICE_TABLE(i2c, tuner_id);
1294
1295 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1296         .name = "tuner",
1297         .driverid = I2C_DRIVERID_TUNER,
1298         .command = tuner_command,
1299         .probe = tuner_probe,
1300         .remove = tuner_remove,
1301         .suspend = tuner_suspend,
1302         .resume = tuner_resume,
1303         .legacy_probe = tuner_legacy_probe,
1304         .id_table = tuner_id,
1305 };
1306
1307
1308 /*
1309  * Overrides for Emacs so that we follow Linus's tabbing style.
1310  * ---------------------------------------------------------------------------
1311  * Local variables:
1312  * c-basic-offset: 8
1313  * End:
1314  */