err.no Git - linux-2.6/blob - drivers/media/video/tuner-core.c

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