drivers/media/video/tuner-core.c

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