drivers/media/video/tuner-core.c

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