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