git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/tuner-core.c

   1 /*
   2  *
   3  * i2c tv tuner chip device driver
   4  * core core, i.e. kernel interfaces, registering and so on
   5  */
   6
   7 #include <linux/module.h>
   8 #include <linux/kernel.h>
   9 #include <linux/string.h>
  10 #include <linux/timer.h>
  11 #include <linux/delay.h>
  12 #include <linux/errno.h>
  13 #include <linux/slab.h>
  14 #include <linux/poll.h>
  15 #include <linux/i2c.h>
  16 #include <linux/types.h>
  17 #include <linux/init.h>
  18 #include <linux/videodev.h>
  19 #include <media/tuner.h>
  20 #include <media/tuner-types.h>
  21 #include <media/v4l2-common.h>
  22 #include "tuner-driver.h"
  23 #include "mt20xx.h"
  24 #include "tda8290.h"
  25 #include "tea5761.h"
  26 #include "tea5767.h"
  27 #include "tuner-xc2028.h"
  28 #include "tuner-simple.h"
  29
  30 #define UNSET (-1U)
  31
  32 /* standard i2c insmod options */
  33 static unsigned short normal_i2c[] = {
  34 #if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
  35         0x10,
  36 #endif
  37         0x42, 0x43, 0x4a, 0x4b,                 /* tda8290 */
  38         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
  39         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
  40         I2C_CLIENT_END
  41 };
  42
  43 I2C_CLIENT_INSMOD;
  44
  45 /* insmod options used at init time => read/only */
  46 static unsigned int addr = 0;
  47 static unsigned int no_autodetect = 0;
  48 static unsigned int show_i2c = 0;
  49
  50 /* insmod options used at runtime => read/write */
  51 int tuner_debug = 0;
  52
  53 static unsigned int tv_range[2] = { 44, 958 };
  54 static unsigned int radio_range[2] = { 65, 108 };
  55
  56 static char pal[] = "--";
  57 static char secam[] = "--";
  58 static char ntsc[] = "-";
  59
  60
  61 module_param(addr, int, 0444);
  62 module_param(no_autodetect, int, 0444);
  63 module_param(show_i2c, int, 0444);
  64 module_param_named(debug,tuner_debug, int, 0644);
  65 module_param_string(pal, pal, sizeof(pal), 0644);
  66 module_param_string(secam, secam, sizeof(secam), 0644);
  67 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
  68 module_param_array(tv_range, int, NULL, 0644);
  69 module_param_array(radio_range, int, NULL, 0644);
  70
  71 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
  72 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
  73 MODULE_LICENSE("GPL");
  74
  75 static struct i2c_driver driver;
  76 static struct i2c_client client_template;
  77
  78 /* ---------------------------------------------------------------------- */
  79
  80 static void fe_set_freq(struct 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         t->fe.ops.analog_demod_ops = NULL;
 106 }
 107
 108 static void fe_standby(struct tuner *t)
 109 {
 110         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 111
 112         if (fe_tuner_ops->sleep)
 113                 fe_tuner_ops->sleep(&t->fe);
 114 }
 115
 116 static int fe_has_signal(struct tuner *t)
 117 {
 118         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 119         u16 strength = 0;
 120
 121         if (fe_tuner_ops->get_rf_strength)
 122                 fe_tuner_ops->get_rf_strength(&t->fe, &strength);
 123
 124         return strength;
 125 }
 126
 127 static void tuner_status(struct tuner *t);
 128
 129 static struct analog_tuner_ops tuner_core_ops = {
 130         .set_tv_freq    = fe_set_freq,
 131         .set_radio_freq = fe_set_freq,
 132         .standby        = fe_standby,
 133         .release        = fe_release,
 134         .has_signal     = fe_has_signal,
 135         .tuner_status   = tuner_status
 136 };
 137
 138 /* Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz */
 139 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
 140 {
 141         struct tuner *t = i2c_get_clientdata(c);
 142         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 143
 144         if (t->type == UNSET) {
 145                 tuner_warn ("tuner type not set\n");
 146                 return;
 147         }
 148         if ((NULL == ops) || (NULL == ops->set_tv_freq)) {
 149                 tuner_warn ("Tuner has no way to set tv freq\n");
 150                 return;
 151         }
 152         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
 153                 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
 154                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
 155                            tv_range[1]);
 156                 /* V4L2 spec: if the freq is not possible then the closest
 157                    possible value should be selected */
 158                 if (freq < tv_range[0] * 16)
 159                         freq = tv_range[0] * 16;
 160                 else
 161                         freq = tv_range[1] * 16;
 162         }
 163         ops->set_tv_freq(t, freq);
 164 }
 165
 166 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
 167 {
 168         struct tuner *t = i2c_get_clientdata(c);
 169         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 170
 171         if (t->type == UNSET) {
 172                 tuner_warn ("tuner type not set\n");
 173                 return;
 174         }
 175         if ((NULL == ops) || (NULL == ops->set_radio_freq)) {
 176                 tuner_warn ("tuner has no way to set radio frequency\n");
 177                 return;
 178         }
 179         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
 180                 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
 181                            freq / 16000, freq % 16000 * 100 / 16000,
 182                            radio_range[0], radio_range[1]);
 183                 /* V4L2 spec: if the freq is not possible then the closest
 184                    possible value should be selected */
 185                 if (freq < radio_range[0] * 16000)
 186                         freq = radio_range[0] * 16000;
 187                 else
 188                         freq = radio_range[1] * 16000;
 189         }
 190
 191         ops->set_radio_freq(t, freq);
 192 }
 193
 194 static void set_freq(struct i2c_client *c, unsigned long freq)
 195 {
 196         struct tuner *t = i2c_get_clientdata(c);
 197
 198         switch (t->mode) {
 199         case V4L2_TUNER_RADIO:
 200                 tuner_dbg("radio freq set to %lu.%02lu\n",
 201                           freq / 16000, freq % 16000 * 100 / 16000);
 202                 set_radio_freq(c, freq);
 203                 t->radio_freq = freq;
 204                 break;
 205         case V4L2_TUNER_ANALOG_TV:
 206         case V4L2_TUNER_DIGITAL_TV:
 207                 tuner_dbg("tv freq set to %lu.%02lu\n",
 208                           freq / 16, freq % 16 * 100 / 16);
 209                 set_tv_freq(c, freq);
 210                 t->tv_freq = freq;
 211                 break;
 212         default:
 213                 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
 214         }
 215 }
 216
 217 static void tuner_i2c_address_check(struct tuner *t)
 218 {
 219         if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
 220             ((t->i2c.addr < 0x64) || (t->i2c.addr > 0x6f)))
 221                 return;
 222
 223         tuner_warn("====================== WARNING! ======================\n");
 224         tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
 225         tuner_warn("will soon be dropped. This message indicates that your\n");
 226         tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
 227                    t->i2c.name, t->i2c.addr);
 228         tuner_warn("To ensure continued support for your device, please\n");
 229         tuner_warn("send a copy of this message, along with full dmesg\n");
 230         tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
 231         tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
 232         tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
 233                    t->i2c.adapter->name, t->i2c.addr, t->type,
 234                    tuners[t->type].name);
 235         tuner_warn("====================== WARNING! ======================\n");
 236 }
 237
 238 static void attach_simple_tuner(struct tuner *t)
 239 {
 240         struct simple_tuner_config cfg = {
 241                 .type = t->type,
 242                 .tun  = &tuners[t->type]
 243         };
 244         simple_tuner_attach(&t->fe, t->i2c.adapter, t->i2c.addr, &cfg);
 245 }
 246
 247 static void set_type(struct i2c_client *c, unsigned int type,
 248                      unsigned int new_mode_mask, unsigned int new_config,
 249                      int (*tuner_callback) (void *dev, int command,int arg))
 250 {
 251         struct tuner *t = i2c_get_clientdata(c);
 252         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 253         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 254         unsigned char buffer[4];
 255
 256         if (type == UNSET || type == TUNER_ABSENT) {
 257                 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
 258                 return;
 259         }
 260
 261         if (type >= tuner_count) {
 262                 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
 263                 return;
 264         }
 265
 266         t->type = type;
 267         t->config = new_config;
 268         if (tuner_callback != NULL) {
 269                 tuner_dbg("defining GPIO callback\n");
 270                 t->tuner_callback = tuner_callback;
 271         }
 272
 273         /* This code detects calls by card attach_inform */
 274         if (NULL == t->i2c.dev.driver) {
 275                 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
 276
 277                 return;
 278         }
 279
 280         /* discard private data, in case set_type() was previously called */
 281         if ((ops) && (ops->release))
 282                 ops->release(t);
 283
 284         switch (t->type) {
 285         case TUNER_MT2032:
 286                 microtune_attach(&t->fe, t->i2c.adapter, t->i2c.addr);
 287                 break;
 288         case TUNER_PHILIPS_TDA8290:
 289         {
 290                 tda8290_attach(t);
 291                 break;
 292         }
 293         case TUNER_PHILIPS_TDA8295:
 294         {
 295                 tda8295_attach(t);
 296                 break;
 297         }
 298         case TUNER_TEA5767:
 299                 if (tea5767_attach(&t->fe, t->i2c.adapter, t->i2c.addr) == NULL) {
 300                         t->type = TUNER_ABSENT;
 301                         t->mode_mask = T_UNINITIALIZED;
 302                         return;
 303                 }
 304                 t->mode_mask = T_RADIO;
 305                 break;
 306         case TUNER_TEA5761:
 307                 if (tea5761_attach(&t->fe, t->i2c.adapter, t->i2c.addr) == NULL) {
 308                         t->type = TUNER_ABSENT;
 309                         t->mode_mask = T_UNINITIALIZED;
 310                         return;
 311                 }
 312                 t->mode_mask = T_RADIO;
 313                 break;
 314         case TUNER_PHILIPS_FMD1216ME_MK3:
 315                 buffer[0] = 0x0b;
 316                 buffer[1] = 0xdc;
 317                 buffer[2] = 0x9c;
 318                 buffer[3] = 0x60;
 319                 i2c_master_send(c, buffer, 4);
 320                 mdelay(1);
 321                 buffer[2] = 0x86;
 322                 buffer[3] = 0x54;
 323                 i2c_master_send(c, buffer, 4);
 324                 attach_simple_tuner(t);
 325                 break;
 326         case TUNER_PHILIPS_TD1316:
 327                 buffer[0] = 0x0b;
 328                 buffer[1] = 0xdc;
 329                 buffer[2] = 0x86;
 330                 buffer[3] = 0xa4;
 331                 i2c_master_send(c,buffer,4);
 332                 attach_simple_tuner(t);
 333                 break;
 334         case TUNER_XC2028:
 335         {
 336                 int rc=xc2028_attach(&t->fe, t->i2c.adapter, t->i2c.addr,
 337                                      &c->dev, c->adapter->algo_data,
 338                                      t->tuner_callback);
 339                 if (rc<0) {
 340                         t->type = TUNER_ABSENT;
 341                         t->mode_mask = T_UNINITIALIZED;
 342                         return;
 343                 }
 344                 break;
 345         }
 346         case TUNER_TDA9887:
 347                 tda9887_tuner_init(t);
 348                 break;
 349         default:
 350                 attach_simple_tuner(t);
 351                 break;
 352         }
 353
 354         ops = t->fe.ops.analog_demod_ops;
 355
 356         if (((NULL == ops) ||
 357              ((NULL == ops->set_tv_freq) && (NULL == ops->set_radio_freq))) &&
 358             (fe_tuner_ops->set_analog_params)) {
 359                 strlcpy(t->i2c.name, fe_tuner_ops->info.name, sizeof(t->i2c.name));
 360
 361                 t->fe.ops.analog_demod_ops = &tuner_core_ops;
 362         }
 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
 728         kfree(t);
 729         return 0;
 730 }
 731
 732 /*
 733  * Switch tuner to other mode. If tuner support both tv and radio,
 734  * set another frequency to some value (This is needed for some pal
 735  * tuners to avoid locking). Otherwise, just put second tuner in
 736  * standby mode.
 737  */
 738
 739 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 740 {
 741         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 742
 743         if (mode == t->mode)
 744                 return 0;
 745
 746         t->mode = mode;
 747
 748         if (check_mode(t, cmd) == EINVAL) {
 749                 t->mode = T_STANDBY;
 750                 if ((ops) && (ops->standby))
 751                         ops->standby(t);
 752                 return EINVAL;
 753         }
 754         return 0;
 755 }
 756
 757 #define switch_v4l2()   if (!t->using_v4l2) \
 758                             tuner_dbg("switching to v4l2\n"); \
 759                         t->using_v4l2 = 1;
 760
 761 static inline int check_v4l2(struct tuner *t)
 762 {
 763         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 764            TV, v4l1 for radio), until that is fixed this code is disabled.
 765            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 766            first. */
 767         return 0;
 768 }
 769
 770 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
 771 {
 772         struct tuner *t = i2c_get_clientdata(client);
 773         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 774         struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
 775
 776         if (tuner_debug>1)
 777                 v4l_i2c_print_ioctl(&(t->i2c),cmd);
 778
 779         switch (cmd) {
 780         /* --- configuration --- */
 781         case TUNER_SET_TYPE_ADDR:
 782                 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
 783                                 ((struct tuner_setup *)arg)->type,
 784                                 ((struct tuner_setup *)arg)->addr,
 785                                 ((struct tuner_setup *)arg)->mode_mask,
 786                                 ((struct tuner_setup *)arg)->config);
 787
 788                 set_addr(client, (struct tuner_setup *)arg);
 789                 break;
 790         case AUDC_SET_RADIO:
 791                 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 792                                 == EINVAL)
 793                         return 0;
 794                 if (t->radio_freq)
 795                         set_freq(client, t->radio_freq);
 796                 break;
 797         case TUNER_SET_STANDBY:
 798                 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
 799                         return 0;
 800                 t->mode = T_STANDBY;
 801                 if ((ops) && (ops->standby))
 802                         ops->standby(t);
 803                 break;
 804 #ifdef CONFIG_VIDEO_V4L1
 805         case VIDIOCSAUDIO:
 806                 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
 807                         return 0;
 808                 if (check_v4l2(t) == EINVAL)
 809                         return 0;
 810
 811                 /* Should be implemented, since bttv calls it */
 812                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 813                 break;
 814         case VIDIOCSCHAN:
 815                 {
 816                         static const v4l2_std_id map[] = {
 817                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 818                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 819                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 820                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 821                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 822                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 823                         };
 824                         struct video_channel *vc = arg;
 825
 826                         if (check_v4l2(t) == EINVAL)
 827                                 return 0;
 828
 829                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
 830                                 return 0;
 831
 832                         if (vc->norm < ARRAY_SIZE(map))
 833                                 t->std = map[vc->norm];
 834                         tuner_fixup_std(t);
 835                         if (t->tv_freq)
 836                                 set_tv_freq(client, t->tv_freq);
 837                         return 0;
 838                 }
 839         case VIDIOCSFREQ:
 840                 {
 841                         unsigned long *v = arg;
 842
 843                         if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
 844                                 return 0;
 845                         if (check_v4l2(t) == EINVAL)
 846                                 return 0;
 847
 848                         set_freq(client, *v);
 849                         return 0;
 850                 }
 851         case VIDIOCGTUNER:
 852                 {
 853                         struct video_tuner *vt = arg;
 854
 855                         if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
 856                                 return 0;
 857                         if (check_v4l2(t) == EINVAL)
 858                                 return 0;
 859
 860                         if (V4L2_TUNER_RADIO == t->mode) {
 861                                 if (fe_tuner_ops->get_status) {
 862                                         u32 tuner_status;
 863
 864                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 865                                         if (tuner_status & TUNER_STATUS_STEREO)
 866                                                 vt->flags |= VIDEO_TUNER_STEREO_ON;
 867                                         else
 868                                                 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
 869                                 } else {
 870                                         if ((ops) && (ops->is_stereo)) {
 871                                                 if (ops->is_stereo(t))
 872                                                         vt->flags |=
 873                                                                 VIDEO_TUNER_STEREO_ON;
 874                                                 else
 875                                                         vt->flags &=
 876                                                                 ~VIDEO_TUNER_STEREO_ON;
 877                                         }
 878                                 }
 879                                 if ((ops) && (ops->has_signal))
 880                                         vt->signal = ops->has_signal(t);
 881
 882                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 883
 884                                 vt->rangelow = radio_range[0] * 16000;
 885                                 vt->rangehigh = radio_range[1] * 16000;
 886
 887                         } else {
 888                                 vt->rangelow = tv_range[0] * 16;
 889                                 vt->rangehigh = tv_range[1] * 16;
 890                         }
 891
 892                         return 0;
 893                 }
 894         case VIDIOCGAUDIO:
 895                 {
 896                         struct video_audio *va = arg;
 897
 898                         if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
 899                                 return 0;
 900                         if (check_v4l2(t) == EINVAL)
 901                                 return 0;
 902
 903                         if (V4L2_TUNER_RADIO == t->mode) {
 904                                 if (fe_tuner_ops->get_status) {
 905                                         u32 tuner_status;
 906
 907                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
 908                                         va->mode = (tuner_status & TUNER_STATUS_STEREO)
 909                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 910                                 } else if ((ops) && (ops->is_stereo))
 911                                         va->mode = ops->is_stereo(t)
 912                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 913                         }
 914                         return 0;
 915                 }
 916 #endif
 917         case TUNER_SET_CONFIG:
 918         {
 919                 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
 920                 struct v4l2_priv_tun_config *cfg = arg;
 921
 922                 if (t->type != cfg->tuner)
 923                         break;
 924
 925                 if (t->type == TUNER_TDA9887) {
 926                         t->tda9887_config = *(unsigned int *)cfg->priv;
 927                         set_freq(client, t->tv_freq);
 928                         break;
 929                 }
 930
 931                 if (NULL == fe_tuner_ops->set_config) {
 932                         tuner_warn("Tuner frontend module has no way to "
 933                                    "set config\n");
 934                         break;
 935                 }
 936                 fe_tuner_ops->set_config(&t->fe, cfg->priv);
 937
 938                 break;
 939         }
 940         /* --- v4l ioctls --- */
 941         /* take care: bttv does userspace copying, we'll get a
 942            kernel pointer here... */
 943         case VIDIOC_S_STD:
 944                 {
 945                         v4l2_std_id *id = arg;
 946
 947                         if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 948                                         == EINVAL)
 949                                 return 0;
 950
 951                         switch_v4l2();
 952
 953                         t->std = *id;
 954                         tuner_fixup_std(t);
 955                         if (t->tv_freq)
 956                                 set_freq(client, t->tv_freq);
 957                         break;
 958                 }
 959         case VIDIOC_S_FREQUENCY:
 960                 {
 961                         struct v4l2_frequency *f = arg;
 962
 963                         if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
 964                                         == EINVAL)
 965                                 return 0;
 966                         switch_v4l2();
 967                         set_freq(client,f->frequency);
 968
 969                         break;
 970                 }
 971         case VIDIOC_G_FREQUENCY:
 972                 {
 973                         struct v4l2_frequency *f = arg;
 974
 975                         if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
 976                                 return 0;
 977                         switch_v4l2();
 978                         f->type = t->mode;
 979                         if (fe_tuner_ops->get_frequency) {
 980                                 u32 abs_freq;
 981
 982                                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
 983                                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 984                                         (abs_freq * 2 + 125/2) / 125 :
 985                                         (abs_freq + 62500/2) / 62500;
 986                                 break;
 987                         }
 988                         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 989                                 t->radio_freq : t->tv_freq;
 990                         break;
 991                 }
 992         case VIDIOC_G_TUNER:
 993                 {
 994                         struct v4l2_tuner *tuner = arg;
 995
 996                         if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
 997                                 return 0;
 998                         switch_v4l2();
 999
1000                         tuner->type = t->mode;
1001                         if ((ops) && (ops->get_afc))
1002                                 tuner->afc = ops->get_afc(t);
1003                         if (t->mode == V4L2_TUNER_ANALOG_TV)
1004                                 tuner->capability |= V4L2_TUNER_CAP_NORM;
1005                         if (t->mode != V4L2_TUNER_RADIO) {
1006                                 tuner->rangelow = tv_range[0] * 16;
1007                                 tuner->rangehigh = tv_range[1] * 16;
1008                                 break;
1009                         }
1010
1011                         /* radio mode */
1012                         tuner->rxsubchans =
1013                                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1014                         if (fe_tuner_ops->get_status) {
1015                                 u32 tuner_status;
1016
1017                                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1018                                 tuner->rxsubchans = (tuner_status & TUNER_STATUS_STEREO) ?
1019                                         V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
1020                         } else {
1021                                 if ((ops) && (ops->is_stereo)) {
1022                                         tuner->rxsubchans = ops->is_stereo(t) ?
1023                                                 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
1024                                 }
1025                         }
1026                         if ((ops) && (ops->has_signal))
1027                                 tuner->signal = ops->has_signal(t);
1028                         tuner->capability |=
1029                             V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1030                         tuner->audmode = t->audmode;
1031                         tuner->rangelow = radio_range[0] * 16000;
1032                         tuner->rangehigh = radio_range[1] * 16000;
1033                         break;
1034                 }
1035         case VIDIOC_S_TUNER:
1036                 {
1037                         struct v4l2_tuner *tuner = arg;
1038
1039                         if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
1040                                 return 0;
1041
1042                         switch_v4l2();
1043
1044                         /* do nothing unless we're a radio tuner */
1045                         if (t->mode != V4L2_TUNER_RADIO)
1046                                 break;
1047                         t->audmode = tuner->audmode;
1048                         set_radio_freq(client, t->radio_freq);
1049                         break;
1050                 }
1051         case VIDIOC_LOG_STATUS:
1052                 if ((ops) && (ops->tuner_status))
1053                         ops->tuner_status(t);
1054                 break;
1055         }
1056
1057         return 0;
1058 }
1059
1060 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1061 {
1062         struct tuner *t = i2c_get_clientdata (c);
1063
1064         tuner_dbg ("suspend\n");
1065         /* FIXME: power down ??? */
1066         return 0;
1067 }
1068
1069 static int tuner_resume(struct i2c_client *c)
1070 {
1071         struct tuner *t = i2c_get_clientdata (c);
1072
1073         tuner_dbg ("resume\n");
1074         if (V4L2_TUNER_RADIO == t->mode) {
1075                 if (t->radio_freq)
1076                         set_freq(c, t->radio_freq);
1077         } else {
1078                 if (t->tv_freq)
1079                         set_freq(c, t->tv_freq);
1080         }
1081         return 0;
1082 }
1083
1084 /* ----------------------------------------------------------------------- */
1085
1086 static struct i2c_driver driver = {
1087         .id = I2C_DRIVERID_TUNER,
1088         .attach_adapter = tuner_probe,
1089         .detach_client = tuner_detach,
1090         .command = tuner_command,
1091         .suspend = tuner_suspend,
1092         .resume  = tuner_resume,
1093         .driver = {
1094                 .name    = "tuner",
1095         },
1096 };
1097 static struct i2c_client client_template = {
1098         .name = "(tuner unset)",
1099         .driver = &driver,
1100 };
1101
1102 static int __init tuner_init_module(void)
1103 {
1104         return i2c_add_driver(&driver);
1105 }
1106
1107 static void __exit tuner_cleanup_module(void)
1108 {
1109         i2c_del_driver(&driver);
1110 }
1111
1112 module_init(tuner_init_module);
1113 module_exit(tuner_cleanup_module);
1114
1115 /*
1116  * Overrides for Emacs so that we follow Linus's tabbing style.
1117  * ---------------------------------------------------------------------------
1118  * Local variables:
1119  * c-basic-offset: 8
1120  * End:
1121  */