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