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