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