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