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