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