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