SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/tuner-core.c

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