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