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         } else { \
  44                 printk(KERN_ERR "TUNER: Unable to find " \
  45                                 "symbol "#FUNCTION"()\n"); \
  46         } \
  47         symbol_put(FUNCTION); \
  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 void attach_tda829x(struct tuner *t)
 344 {
 345         struct tda829x_config cfg = {
 346                 .lna_cfg        = t->config,
 347                 .tuner_callback = t->tuner_callback,
 348         };
 349         dvb_attach(tda829x_attach,
 350                    &t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
 351 }
 352
 353 static struct xc5000_config xc5000_cfg;
 354
 355 static void set_type(struct i2c_client *c, unsigned int type,
 356                      unsigned int new_mode_mask, unsigned int new_config,
 357                      int (*tuner_callback) (void *dev, int command,int arg))
 358 {
 359         struct tuner *t = i2c_get_clientdata(c);
 360         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 361         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 362         unsigned char buffer[4];
 363
 364         if (type == UNSET || type == TUNER_ABSENT) {
 365                 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
 366                 return;
 367         }
 368
 369         t->type = type;
 370         t->config = new_config;
 371         if (tuner_callback != NULL) {
 372                 tuner_dbg("defining GPIO callback\n");
 373                 t->tuner_callback = tuner_callback;
 374         }
 375
 376         if (t->mode == T_UNINITIALIZED) {
 377                 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
 378
 379                 return;
 380         }
 381
 382         /* discard private data, in case set_type() was previously called */
 383         tuner_detach(&t->fe);
 384         t->fe.analog_demod_priv = NULL;
 385
 386         switch (t->type) {
 387         case TUNER_MT2032:
 388                 dvb_attach(microtune_attach,
 389                            &t->fe, t->i2c->adapter, t->i2c->addr);
 390                 break;
 391         case TUNER_PHILIPS_TDA8290:
 392         {
 393                 attach_tda829x(t);
 394                 break;
 395         }
 396         case TUNER_TEA5767:
 397                 if (!dvb_attach(tea5767_attach, &t->fe,
 398                                 t->i2c->adapter, t->i2c->addr))
 399                         goto attach_failed;
 400                 t->mode_mask = T_RADIO;
 401                 break;
 402         case TUNER_TEA5761:
 403                 if (!dvb_attach(tea5761_attach, &t->fe,
 404                                 t->i2c->adapter, t->i2c->addr))
 405                         goto attach_failed;
 406                 t->mode_mask = T_RADIO;
 407                 break;
 408         case TUNER_PHILIPS_FMD1216ME_MK3:
 409                 buffer[0] = 0x0b;
 410                 buffer[1] = 0xdc;
 411                 buffer[2] = 0x9c;
 412                 buffer[3] = 0x60;
 413                 i2c_master_send(c, buffer, 4);
 414                 mdelay(1);
 415                 buffer[2] = 0x86;
 416                 buffer[3] = 0x54;
 417                 i2c_master_send(c, buffer, 4);
 418                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 419                                 t->i2c->adapter, t->i2c->addr, t->type))
 420                         goto attach_failed;
 421                 break;
 422         case TUNER_PHILIPS_TD1316:
 423                 buffer[0] = 0x0b;
 424                 buffer[1] = 0xdc;
 425                 buffer[2] = 0x86;
 426                 buffer[3] = 0xa4;
 427                 i2c_master_send(c, buffer, 4);
 428                 if (!dvb_attach(simple_tuner_attach, &t->fe,
 429                                 t->i2c->adapter, t->i2c->addr, t->type))
 430                         goto attach_failed;
 431                 break;
 432         case TUNER_XC2028:
 433         {
 434                 struct xc2028_config cfg = {
 435                         .i2c_adap  = t->i2c->adapter,
 436                         .i2c_addr  = t->i2c->addr,
 437                         .callback  = t->tuner_callback,
 438                 };
 439                 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
 440                         goto attach_failed;
 441                 break;
 442         }
 443         case TUNER_TDA9887:
 444                 dvb_attach(tda9887_attach,
 445                            &t->fe, t->i2c->adapter, t->i2c->addr);
 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.priv           = c->adapter->algo_data;
 454                 xc5000_cfg.tuner_callback = t->tuner_callback;
 455                 if (!dvb_attach(xc5000_attach,
 456                                 &t->fe, t->i2c->adapter, &xc5000_cfg))
 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                 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
 476                         sizeof(t->i2c->name));
 477
 478                 t->fe.analog_demod_priv = t;
 479                 memcpy(analog_ops, &tuner_core_ops,
 480                        sizeof(struct analog_demod_ops));
 481
 482         } else {
 483                 strlcpy(t->i2c->name, analog_ops->info.name,
 484                         sizeof(t->i2c->name));
 485         }
 486
 487         tuner_dbg("type set to %s\n", t->i2c->name);
 488
 489         if (t->mode_mask == T_UNINITIALIZED)
 490                 t->mode_mask = new_mode_mask;
 491
 492         /* xc2028/3028 and xc5000 requires a firmware to be set-up later
 493            trying to set a frequency here will just fail
 494            FIXME: better to move set_freq to the tuner code. This is needed
 495            on analog tuners for PLL to properly work
 496          */
 497         if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
 498                 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
 499                             t->radio_freq : t->tv_freq);
 500
 501         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
 502                   c->adapter->name, c->driver->driver.name, c->addr << 1, type,
 503                   t->mode_mask);
 504         tuner_i2c_address_check(t);
 505         return;
 506
 507 attach_failed:
 508         tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
 509         t->type = TUNER_ABSENT;
 510         t->mode_mask = T_UNINITIALIZED;
 511
 512         return;
 513 }
 514
 515 /*
 516  * This function apply tuner config to tuner specified
 517  * by tun_setup structure. I addr is unset, then admin status
 518  * and tun addr status is more precise then current status,
 519  * it's applied. Otherwise status and type are applied only to
 520  * tuner with exactly the same addr.
 521 */
 522
 523 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 524 {
 525         struct tuner *t = i2c_get_clientdata(c);
 526
 527         if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
 528                 (t->mode_mask & tun_setup->mode_mask))) ||
 529                 (tun_setup->addr == c->addr)) {
 530                         set_type(c, tun_setup->type, tun_setup->mode_mask,
 531                                  tun_setup->config, tun_setup->tuner_callback);
 532         } else
 533                 tuner_dbg("set addr discarded for type %i, mask %x. "
 534                           "Asked to change tuner at addr 0x%02x, with mask %x\n",
 535                           t->type, t->mode_mask,
 536                           tun_setup->addr, tun_setup->mode_mask);
 537 }
 538
 539 static inline int check_mode(struct tuner *t, char *cmd)
 540 {
 541         if ((1 << t->mode & t->mode_mask) == 0) {
 542                 return EINVAL;
 543         }
 544
 545         switch (t->mode) {
 546         case V4L2_TUNER_RADIO:
 547                 tuner_dbg("Cmd %s accepted for radio\n", cmd);
 548                 break;
 549         case V4L2_TUNER_ANALOG_TV:
 550                 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
 551                 break;
 552         case V4L2_TUNER_DIGITAL_TV:
 553                 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
 554                 break;
 555         }
 556         return 0;
 557 }
 558
 559 /* get more precise norm info from insmod option */
 560 static int tuner_fixup_std(struct tuner *t)
 561 {
 562         if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
 563                 switch (pal[0]) {
 564                 case '6':
 565                         tuner_dbg ("insmod fixup: PAL => PAL-60\n");
 566                         t->std = V4L2_STD_PAL_60;
 567                         break;
 568                 case 'b':
 569                 case 'B':
 570                 case 'g':
 571                 case 'G':
 572                         tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
 573                         t->std = V4L2_STD_PAL_BG;
 574                         break;
 575                 case 'i':
 576                 case 'I':
 577                         tuner_dbg ("insmod fixup: PAL => PAL-I\n");
 578                         t->std = V4L2_STD_PAL_I;
 579                         break;
 580                 case 'd':
 581                 case 'D':
 582                 case 'k':
 583                 case 'K':
 584                         tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
 585                         t->std = V4L2_STD_PAL_DK;
 586                         break;
 587                 case 'M':
 588                 case 'm':
 589                         tuner_dbg ("insmod fixup: PAL => PAL-M\n");
 590                         t->std = V4L2_STD_PAL_M;
 591                         break;
 592                 case 'N':
 593                 case 'n':
 594                         if (pal[1] == 'c' || pal[1] == 'C') {
 595                                 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
 596                                 t->std = V4L2_STD_PAL_Nc;
 597                         } else {
 598                                 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
 599                                 t->std = V4L2_STD_PAL_N;
 600                         }
 601                         break;
 602                 case '-':
 603                         /* default parameter, do nothing */
 604                         break;
 605                 default:
 606                         tuner_warn ("pal= argument not recognised\n");
 607                         break;
 608                 }
 609         }
 610         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 611                 switch (secam[0]) {
 612                 case 'b':
 613                 case 'B':
 614                 case 'g':
 615                 case 'G':
 616                 case 'h':
 617                 case 'H':
 618                         tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
 619                         t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 620                         break;
 621                 case 'd':
 622                 case 'D':
 623                 case 'k':
 624                 case 'K':
 625                         tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
 626                         t->std = V4L2_STD_SECAM_DK;
 627                         break;
 628                 case 'l':
 629                 case 'L':
 630                         if ((secam[1]=='C')||(secam[1]=='c')) {
 631                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
 632                                 t->std = V4L2_STD_SECAM_LC;
 633                         } else {
 634                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
 635                                 t->std = V4L2_STD_SECAM_L;
 636                         }
 637                         break;
 638                 case '-':
 639                         /* default parameter, do nothing */
 640                         break;
 641                 default:
 642                         tuner_warn ("secam= argument not recognised\n");
 643                         break;
 644                 }
 645         }
 646
 647         if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 648                 switch (ntsc[0]) {
 649                 case 'm':
 650                 case 'M':
 651                         tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
 652                         t->std = V4L2_STD_NTSC_M;
 653                         break;
 654                 case 'j':
 655                 case 'J':
 656                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
 657                         t->std = V4L2_STD_NTSC_M_JP;
 658                         break;
 659                 case 'k':
 660                 case 'K':
 661                         tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
 662                         t->std = V4L2_STD_NTSC_M_KR;
 663                         break;
 664                 case '-':
 665                         /* default parameter, do nothing */
 666                         break;
 667                 default:
 668                         tuner_info("ntsc= argument not recognised\n");
 669                         break;
 670                 }
 671         }
 672         return 0;
 673 }
 674
 675 static void tuner_status(struct dvb_frontend *fe)
 676 {
 677         struct tuner *t = fe->analog_demod_priv;
 678         unsigned long freq, freq_fraction;
 679         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
 680         struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
 681         const char *p;
 682
 683         switch (t->mode) {
 684                 case V4L2_TUNER_RADIO:      p = "radio"; break;
 685                 case V4L2_TUNER_ANALOG_TV:  p = "analog TV"; break;
 686                 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
 687                 default: p = "undefined"; break;
 688         }
 689         if (t->mode == V4L2_TUNER_RADIO) {
 690                 freq = t->radio_freq / 16000;
 691                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
 692         } else {
 693                 freq = t->tv_freq / 16;
 694                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
 695         }
 696         tuner_info("Tuner mode:      %s\n", p);
 697         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
 698         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
 699         if (t->mode != V4L2_TUNER_RADIO)
 700                return;
 701         if (fe_tuner_ops->get_status) {
 702                 u32 tuner_status;
 703
 704                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
 705                 if (tuner_status & TUNER_STATUS_LOCKED)
 706                         tuner_info("Tuner is locked.\n");
 707                 if (tuner_status & TUNER_STATUS_STEREO)
 708                         tuner_info("Stereo:          yes\n");
 709         }
 710         if (analog_ops->has_signal)
 711                 tuner_info("Signal strength: %d\n",
 712                            analog_ops->has_signal(fe));
 713         if (analog_ops->is_stereo)
 714                 tuner_info("Stereo:          %s\n",
 715                            analog_ops->is_stereo(fe) ? "yes" : "no");
 716 }
 717
 718 /* ---------------------------------------------------------------------- */
 719
 720 /*
 721  * Switch tuner to other mode. If tuner support both tv and radio,
 722  * set another frequency to some value (This is needed for some pal
 723  * tuners to avoid locking). Otherwise, just put second tuner in
 724  * standby mode.
 725  */
 726
 727 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 728 {
 729         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 730
 731         if (mode == t->mode)
 732                 return 0;
 733
 734         t->mode = mode;
 735
 736         if (check_mode(t, cmd) == EINVAL) {
 737                 t->mode = T_STANDBY;
 738                 if (analog_ops->standby)
 739                         analog_ops->standby(&t->fe);
 740                 return EINVAL;
 741         }
 742         return 0;
 743 }
 744
 745 #define switch_v4l2()   if (!t->using_v4l2) \
 746                             tuner_dbg("switching to v4l2\n"); \
 747                         t->using_v4l2 = 1;
 748
 749 static inline int check_v4l2(struct tuner *t)
 750 {
 751         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 752            TV, v4l1 for radio), until that is fixed this code is disabled.
 753            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 754            first. */
 755         return 0;
 756 }
 757
 758 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
 759 {
 760         struct tuner *t = i2c_get_clientdata(client);
 761         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 762         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
 763
 764         if (tuner_debug > 1) {
 765                 v4l_i2c_print_ioctl(client,cmd);
 766                 printk("\n");
 767         }
 768
 769         switch (cmd) {
 770         /* --- configuration --- */
 771         case TUNER_SET_TYPE_ADDR:
 772                 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 773                                 ((struct tuner_setup *)arg)->type,
 774                                 ((struct tuner_setup *)arg)->addr,
 775                                 ((struct tuner_setup *)arg)->mode_mask,
 776                                 ((struct tuner_setup *)arg)->config);
 777
 778                 set_addr(client, (struct tuner_setup *)arg);
 779                 break;
 780         case AUDC_SET_RADIO:
 781                 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 782                                 == EINVAL)
 783                         return 0;
 784                 if (t->radio_freq)
 785                         set_freq(client, t->radio_freq);
 786                 break;
 787         case TUNER_SET_STANDBY:
 788                 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
 789                         return 0;
 790                 t->mode = T_STANDBY;
 791                 if (analog_ops->standby)
 792                         analog_ops->standby(&t->fe);
 793                 break;
 794 #ifdef CONFIG_VIDEO_ALLOW_V4L1
 795         case VIDIOCSAUDIO:
 796                 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
 797                         return 0;
 798                 if (check_v4l2(t) == EINVAL)
 799                         return 0;
 800
 801                 /* Should be implemented, since bttv calls it */
 802                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 803                 break;
 804         case VIDIOCSCHAN:
 805                 {
 806                         static const v4l2_std_id map[] = {
 807                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 808                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 809                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 810                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 811                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 812                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 813                         };
 814                         struct video_channel *vc = arg;
 815
 816                         if (check_v4l2(t) == EINVAL)
 817                                 return 0;
 818
 819                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
 820                                 return 0;
 821
 822                         if (vc->norm < ARRAY_SIZE(map))
 823                                 t->std = map[vc->norm];
 824                         tuner_fixup_std(t);
 825                         if (t->tv_freq)
 826                                 set_tv_freq(client, t->tv_freq);
 827                         return 0;
 828                 }
 829         case VIDIOCSFREQ:
 830                 {
 831                         unsigned long *v = arg;
 832
 833                         if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
 834                                 return 0;
 835                         if (check_v4l2(t) == EINVAL)
 836                                 return 0;
 837
 838                         set_freq(client, *v);
 839                         return 0;
 840                 }
 841         case VIDIOCGTUNER:
 842                 {
 843                         struct video_tuner *vt = arg;
 844
 845                         if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
 846                                 return 0;
 847                         if (check_v4l2(t) == EINVAL)
 848                                 return 0;
 849
 850                         if (V4L2_TUNER_RADIO == t->mode) {
 851                                 if (fe_tuner_ops->get_status) {
 852                                         u32 tuner_status;
 853
 854                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 855                                         if (tuner_status & TUNER_STATUS_STEREO)
 856                                                 vt->flags |= VIDEO_TUNER_STEREO_ON;
 857                                         else
 858                                                 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
 859                                 } else {
 860                                         if (analog_ops->is_stereo) {
 861                                                 if (analog_ops->is_stereo(&t->fe))
 862                                                         vt->flags |=
 863                                                                 VIDEO_TUNER_STEREO_ON;
 864                                                 else
 865                                                         vt->flags &=
 866                                                                 ~VIDEO_TUNER_STEREO_ON;
 867                                         }
 868                                 }
 869                                 if (analog_ops->has_signal)
 870                                         vt->signal =
 871                                                 analog_ops->has_signal(&t->fe);
 872
 873                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 874
 875                                 vt->rangelow = radio_range[0] * 16000;
 876                                 vt->rangehigh = radio_range[1] * 16000;
 877
 878                         } else {
 879                                 vt->rangelow = tv_range[0] * 16;
 880                                 vt->rangehigh = tv_range[1] * 16;
 881                         }
 882
 883                         return 0;
 884                 }
 885         case VIDIOCGAUDIO:
 886                 {
 887                         struct video_audio *va = arg;
 888
 889                         if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
 890                                 return 0;
 891                         if (check_v4l2(t) == EINVAL)
 892                                 return 0;
 893
 894                         if (V4L2_TUNER_RADIO == t->mode) {
 895                                 if (fe_tuner_ops->get_status) {
 896                                         u32 tuner_status;
 897
 898                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 899                                         va->mode = (tuner_status & TUNER_STATUS_STEREO)
 900                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 901                                 } else if (analog_ops->is_stereo)
 902                                         va->mode = analog_ops->is_stereo(&t->fe)
 903                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 904                         }
 905                         return 0;
 906                 }
 907 #endif
 908         case TUNER_SET_CONFIG:
 909         {
 910                 struct v4l2_priv_tun_config *cfg = arg;
 911
 912                 if (t->type != cfg->tuner)
 913                         break;
 914
 915                 if (analog_ops->set_config) {
 916                         analog_ops->set_config(&t->fe, cfg->priv);
 917                         break;
 918                 }
 919
 920                 tuner_dbg("Tuner frontend module has no way to set config\n");
 921                 break;
 922         }
 923         /* --- v4l ioctls --- */
 924         /* take care: bttv does userspace copying, we'll get a
 925            kernel pointer here... */
 926         case VIDIOC_S_STD:
 927                 {
 928                         v4l2_std_id *id = arg;
 929
 930                         if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 931                                         == EINVAL)
 932                                 return 0;
 933
 934                         switch_v4l2();
 935
 936                         t->std = *id;
 937                         tuner_fixup_std(t);
 938                         if (t->tv_freq)
 939                                 set_freq(client, t->tv_freq);
 940                         break;
 941                 }
 942         case VIDIOC_S_FREQUENCY:
 943                 {
 944                         struct v4l2_frequency *f = arg;
 945
 946                         if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
 947                                         == EINVAL)
 948                                 return 0;
 949                         switch_v4l2();
 950                         set_freq(client,f->frequency);
 951
 952                         break;
 953                 }
 954         case VIDIOC_G_FREQUENCY:
 955                 {
 956                         struct v4l2_frequency *f = arg;
 957
 958                         if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
 959                                 return 0;
 960                         switch_v4l2();
 961                         f->type = t->mode;
 962                         if (fe_tuner_ops->get_frequency) {
 963                                 u32 abs_freq;
 964
 965                                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 966                                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 967                                         (abs_freq * 2 + 125/2) / 125 :
 968                                         (abs_freq + 62500/2) / 62500;
 969                                 break;
 970                         }
 971                         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 972                                 t->radio_freq : t->tv_freq;
 973                         break;
 974                 }
 975         case VIDIOC_G_TUNER:
 976                 {
 977                         struct v4l2_tuner *tuner = arg;
 978
 979                         if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
 980                                 return 0;
 981                         switch_v4l2();
 982
 983                         tuner->type = t->mode;
 984                         if (analog_ops->get_afc)
 985                                 tuner->afc = analog_ops->get_afc(&t->fe);
 986                         if (t->mode == V4L2_TUNER_ANALOG_TV)
 987                                 tuner->capability |= V4L2_TUNER_CAP_NORM;
 988                         if (t->mode != V4L2_TUNER_RADIO) {
 989                                 tuner->rangelow = tv_range[0] * 16;
 990                                 tuner->rangehigh = tv_range[1] * 16;
 991                                 break;
 992                         }
 993
 994                         /* radio mode */
 995                         tuner->rxsubchans =
 996                                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 997                         if (fe_tuner_ops->get_status) {
 998                                 u32 tuner_status;
 999
1000                                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1001                                 tuner->rxsubchans =
1002                                         (tuner_status & TUNER_STATUS_STEREO) ?
1003                                         V4L2_TUNER_SUB_STEREO :
1004                                         V4L2_TUNER_SUB_MONO;
1005                         } else {
1006                                 if (analog_ops->is_stereo) {
1007                                         tuner->rxsubchans =
1008                                                 analog_ops->is_stereo(&t->fe) ?
1009                                                 V4L2_TUNER_SUB_STEREO :
1010                                                 V4L2_TUNER_SUB_MONO;
1011                                 }
1012                         }
1013                         if (analog_ops->has_signal)
1014                                 tuner->signal = analog_ops->has_signal(&t->fe);
1015                         tuner->capability |=
1016                             V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1017                         tuner->audmode = t->audmode;
1018                         tuner->rangelow = radio_range[0] * 16000;
1019                         tuner->rangehigh = radio_range[1] * 16000;
1020                         break;
1021                 }
1022         case VIDIOC_S_TUNER:
1023                 {
1024                         struct v4l2_tuner *tuner = arg;
1025
1026                         if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
1027                                 return 0;
1028
1029                         switch_v4l2();
1030
1031                         /* do nothing unless we're a radio tuner */
1032                         if (t->mode != V4L2_TUNER_RADIO)
1033                                 break;
1034                         t->audmode = tuner->audmode;
1035                         set_radio_freq(client, t->radio_freq);
1036                         break;
1037                 }
1038         case VIDIOC_LOG_STATUS:
1039                 if (analog_ops->tuner_status)
1040                         analog_ops->tuner_status(&t->fe);
1041                 break;
1042         }
1043
1044         return 0;
1045 }
1046
1047 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1048 {
1049         struct tuner *t = i2c_get_clientdata(c);
1050
1051         tuner_dbg("suspend\n");
1052         /* FIXME: power down ??? */
1053         return 0;
1054 }
1055
1056 static int tuner_resume(struct i2c_client *c)
1057 {
1058         struct tuner *t = i2c_get_clientdata(c);
1059
1060         tuner_dbg("resume\n");
1061         if (V4L2_TUNER_RADIO == t->mode) {
1062                 if (t->radio_freq)
1063                         set_freq(c, t->radio_freq);
1064         } else {
1065                 if (t->tv_freq)
1066                         set_freq(c, t->tv_freq);
1067         }
1068         return 0;
1069 }
1070
1071 /* ---------------------------------------------------------------------- */
1072
1073 static LIST_HEAD(tuner_list);
1074
1075 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1076    Note that when this function is called from tuner_probe you can be
1077    certain no other devices will be added/deleted at the same time, I2C
1078    core protects against that. */
1079 static void tuner_lookup(struct i2c_adapter *adap,
1080                 struct tuner **radio, struct tuner **tv)
1081 {
1082         struct tuner *pos;
1083
1084         *radio = NULL;
1085         *tv = NULL;
1086
1087         list_for_each_entry(pos, &tuner_list, list) {
1088                 int mode_mask;
1089
1090                 if (pos->i2c->adapter != adap ||
1091                     pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1092                         continue;
1093
1094                 mode_mask = pos->mode_mask & ~T_STANDBY;
1095                 if (*radio == NULL && mode_mask == T_RADIO)
1096                         *radio = pos;
1097                 /* Note: currently TDA9887 is the only demod-only
1098                    device. If other devices appear then we need to
1099                    make this test more general. */
1100                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1101                          (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1102                         *tv = pos;
1103         }
1104 }
1105
1106 /* During client attach, set_type is called by adapter's attach_inform callback.
1107    set_type must then be completed by tuner_probe.
1108  */
1109 static int tuner_probe(struct i2c_client *client,
1110                        const struct i2c_device_id *id)
1111 {
1112         struct tuner *t;
1113         struct tuner *radio;
1114         struct tuner *tv;
1115
1116         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1117         if (NULL == t)
1118                 return -ENOMEM;
1119         t->i2c = client;
1120         strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1121         i2c_set_clientdata(client, t);
1122         t->type = UNSET;
1123         t->audmode = V4L2_TUNER_MODE_STEREO;
1124         t->mode_mask = T_UNINITIALIZED;
1125
1126         if (show_i2c) {
1127                 unsigned char buffer[16];
1128                 int i, rc;
1129
1130                 memset(buffer, 0, sizeof(buffer));
1131                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1132                 tuner_info("I2C RECV = ");
1133                 for (i = 0; i < rc; i++)
1134                         printk(KERN_CONT "%02x ", buffer[i]);
1135                 printk("\n");
1136         }
1137         /* HACK: This test was added to avoid tuner to probe tda9840 and
1138            tea6415c on the MXB card */
1139         if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1140                 kfree(t);
1141                 return -ENODEV;
1142         }
1143
1144         /* autodetection code based on the i2c addr */
1145         if (!no_autodetect) {
1146                 switch (client->addr) {
1147                 case 0x10:
1148                         if (tuner_symbol_probe(tea5761_autodetection,
1149                                                t->i2c->adapter,
1150                                                t->i2c->addr) >= 0) {
1151                                 t->type = TUNER_TEA5761;
1152                                 t->mode_mask = T_RADIO;
1153                                 t->mode = T_STANDBY;
1154                                 /* Sets freq to FM range */
1155                                 t->radio_freq = 87.5 * 16000;
1156                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1157                                 if (tv)
1158                                         tv->mode_mask &= ~T_RADIO;
1159
1160                                 goto register_client;
1161                         }
1162                         return -ENODEV;
1163                 case 0x42:
1164                 case 0x43:
1165                 case 0x4a:
1166                 case 0x4b:
1167                         /* If chip is not tda8290, don't register.
1168                            since it can be tda9887*/
1169                         if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1170                                                t->i2c->addr) == 0) {
1171                                 tuner_dbg("tda829x detected\n");
1172                         } else {
1173                                 /* Default is being tda9887 */
1174                                 t->type = TUNER_TDA9887;
1175                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1176                                                T_DIGITAL_TV;
1177                                 t->mode = T_STANDBY;
1178                                 goto register_client;
1179                         }
1180                         break;
1181                 case 0x60:
1182                         if (tuner_symbol_probe(tea5767_autodetection,
1183                                                t->i2c->adapter, t->i2c->addr)
1184                                         != EINVAL) {
1185                                 t->type = TUNER_TEA5767;
1186                                 t->mode_mask = T_RADIO;
1187                                 t->mode = T_STANDBY;
1188                                 /* Sets freq to FM range */
1189                                 t->radio_freq = 87.5 * 16000;
1190                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1191                                 if (tv)
1192                                         tv->mode_mask &= ~T_RADIO;
1193
1194                                 goto register_client;
1195                         }
1196                         break;
1197                 }
1198         }
1199
1200         /* Initializes only the first TV tuner on this adapter. Why only the
1201            first? Because there are some devices (notably the ones with TI
1202            tuners) that have more than one i2c address for the *same* device.
1203            Experience shows that, except for just one case, the first
1204            address is the right one. The exception is a Russian tuner
1205            (ACORP_Y878F). So, the desired behavior is just to enable the
1206            first found TV tuner. */
1207         tuner_lookup(t->i2c->adapter, &radio, &tv);
1208         if (tv == NULL) {
1209                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1210                 if (radio == NULL)
1211                         t->mode_mask |= T_RADIO;
1212                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1213                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1214                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1215         }
1216
1217         /* Should be just before return */
1218 register_client:
1219         tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1220                        client->adapter->name);
1221
1222         /* Sets a default mode */
1223         if (t->mode_mask & T_ANALOG_TV) {
1224                 t->mode = V4L2_TUNER_ANALOG_TV;
1225         } else  if (t->mode_mask & T_RADIO) {
1226                 t->mode = V4L2_TUNER_RADIO;
1227         } else {
1228                 t->mode = V4L2_TUNER_DIGITAL_TV;
1229         }
1230         set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1231         list_add_tail(&t->list, &tuner_list);
1232         return 0;
1233 }
1234
1235 static int tuner_legacy_probe(struct i2c_adapter *adap)
1236 {
1237         if (0 != addr) {
1238                 normal_i2c[0] = addr;
1239                 normal_i2c[1] = I2C_CLIENT_END;
1240         }
1241
1242         if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1243                 return 0;
1244
1245         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1246          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1247          * and an RTC at 0x6f which can get corrupted if probed.
1248          */
1249         if ((adap->id == I2C_HW_B_CX2388x) ||
1250             (adap->id == I2C_HW_B_CX23885)) {
1251                 unsigned int i = 0;
1252
1253                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1254                         i += 2;
1255                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1256                         ignore[i+0] = adap->nr;
1257                         ignore[i+1] = 0x6b;
1258                         ignore[i+2] = adap->nr;
1259                         ignore[i+3] = 0x6f;
1260                         ignore[i+4] = I2C_CLIENT_END;
1261                 } else
1262                         printk(KERN_WARNING "tuner: "
1263                                "too many options specified "
1264                                "in i2c probe ignore list!\n");
1265         }
1266         return 1;
1267 }
1268
1269 static int tuner_remove(struct i2c_client *client)
1270 {
1271         struct tuner *t = i2c_get_clientdata(client);
1272
1273         tuner_detach(&t->fe);
1274         t->fe.analog_demod_priv = NULL;
1275
1276         list_del(&t->list);
1277         kfree(t);
1278         return 0;
1279 }
1280
1281 /* ----------------------------------------------------------------------- */
1282
1283 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1284         .name = "tuner",
1285         .driverid = I2C_DRIVERID_TUNER,
1286         .command = tuner_command,
1287         .probe = tuner_probe,
1288         .remove = tuner_remove,
1289         .suspend = tuner_suspend,
1290         .resume = tuner_resume,
1291         .legacy_probe = tuner_legacy_probe,
1292 };
1293
1294
1295 /*
1296  * Overrides for Emacs so that we follow Linus's tabbing style.
1297  * ---------------------------------------------------------------------------
1298  * Local variables:
1299  * c-basic-offset: 8
1300  * End:
1301  */