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

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