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

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