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