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 '6':
 271                         tuner_dbg ("insmod fixup: PAL => PAL-60\n");
 272                         t->std = V4L2_STD_PAL_60;
 273                         break;
 274                 case 'b':
 275                 case 'B':
 276                 case 'g':
 277                 case 'G':
 278                         tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
 279                         t->std = V4L2_STD_PAL_BG;
 280                         break;
 281                 case 'i':
 282                 case 'I':
 283                         tuner_dbg ("insmod fixup: PAL => PAL-I\n");
 284                         t->std = V4L2_STD_PAL_I;
 285                         break;
 286                 case 'd':
 287                 case 'D':
 288                 case 'k':
 289                 case 'K':
 290                         tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
 291                         t->std = V4L2_STD_PAL_DK;
 292                         break;
 293                 case 'M':
 294                 case 'm':
 295                         tuner_dbg ("insmod fixup: PAL => PAL-M\n");
 296                         t->std = V4L2_STD_PAL_M;
 297                         break;
 298                 case 'N':
 299                 case 'n':
 300                         if (pal[1] == 'c' || pal[1] == 'C') {
 301                                 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
 302                                 t->std = V4L2_STD_PAL_Nc;
 303                         } else {
 304                                 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
 305                                 t->std = V4L2_STD_PAL_N;
 306                         }
 307                         break;
 308                 case '-':
 309                         /* default parameter, do nothing */
 310                         break;
 311                 default:
 312                         tuner_warn ("pal= argument not recognised\n");
 313                         break;
 314                 }
 315         }
 316         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
 317                 switch (secam[0]) {
 318                 case 'b':
 319                 case 'B':
 320                 case 'g':
 321                 case 'G':
 322                 case 'h':
 323                 case 'H':
 324                         tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
 325                         t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 326                         break;
 327                 case 'd':
 328                 case 'D':
 329                 case 'k':
 330                 case 'K':
 331                         tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
 332                         t->std = V4L2_STD_SECAM_DK;
 333                         break;
 334                 case 'l':
 335                 case 'L':
 336                         if ((secam[1]=='C')||(secam[1]=='c')) {
 337                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
 338                                 t->std = V4L2_STD_SECAM_LC;
 339                         } else {
 340                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
 341                                 t->std = V4L2_STD_SECAM_L;
 342                         }
 343                         break;
 344                 case '-':
 345                         /* default parameter, do nothing */
 346                         break;
 347                 default:
 348                         tuner_warn ("secam= argument not recognised\n");
 349                         break;
 350                 }
 351         }
 352
 353         if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
 354                 switch (ntsc[0]) {
 355                 case 'm':
 356                 case 'M':
 357                         tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
 358                         t->std = V4L2_STD_NTSC_M;
 359                         break;
 360                 case 'j':
 361                 case 'J':
 362                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
 363                         t->std = V4L2_STD_NTSC_M_JP;
 364                         break;
 365                 case 'k':
 366                 case 'K':
 367                         tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
 368                         t->std = V4L2_STD_NTSC_M_KR;
 369                         break;
 370                 case '-':
 371                         /* default parameter, do nothing */
 372                         break;
 373                 default:
 374                         tuner_info("ntsc= argument not recognised\n");
 375                         break;
 376                 }
 377         }
 378         return 0;
 379 }
 380
 381 static void tuner_status(struct i2c_client *client)
 382 {
 383         struct tuner *t = i2c_get_clientdata(client);
 384         unsigned long freq, freq_fraction;
 385         const char *p;
 386
 387         switch (t->mode) {
 388                 case V4L2_TUNER_RADIO:      p = "radio"; break;
 389                 case V4L2_TUNER_ANALOG_TV:  p = "analog TV"; break;
 390                 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
 391                 default: p = "undefined"; break;
 392         }
 393         if (t->mode == V4L2_TUNER_RADIO) {
 394                 freq = t->radio_freq / 16000;
 395                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
 396         } else {
 397                 freq = t->tv_freq / 16;
 398                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
 399         }
 400         tuner_info("Tuner mode:      %s\n", p);
 401         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
 402         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
 403         if (t->mode != V4L2_TUNER_RADIO)
 404                return;
 405         if (t->has_signal) {
 406                 tuner_info("Signal strength: %d\n", t->has_signal(client));
 407         }
 408         if (t->is_stereo) {
 409                 tuner_info("Stereo:          %s\n", t->is_stereo(client) ? "yes" : "no");
 410         }
 411 }
 412
 413 /* ---------------------------------------------------------------------- */
 414
 415 /* static vars: used only in tuner_attach and tuner_probe */
 416 static unsigned default_mode_mask;
 417
 418 /* During client attach, set_type is called by adapter's attach_inform callback.
 419    set_type must then be completed by tuner_attach.
 420  */
 421 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
 422 {
 423         struct tuner *t;
 424
 425         client_template.adapter = adap;
 426         client_template.addr = addr;
 427
 428         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
 429         if (NULL == t)
 430                 return -ENOMEM;
 431         memcpy(&t->i2c, &client_template, sizeof(struct i2c_client));
 432         i2c_set_clientdata(&t->i2c, t);
 433         t->type = UNSET;
 434         t->radio_if2 = 10700 * 1000;    /* 10.7MHz - FM radio */
 435         t->audmode = V4L2_TUNER_MODE_STEREO;
 436         t->mode_mask = T_UNINITIALIZED;
 437         t->tuner_status = tuner_status;
 438
 439         if (show_i2c) {
 440                 unsigned char buffer[16];
 441                 int i,rc;
 442
 443                 memset(buffer, 0, sizeof(buffer));
 444                 rc = i2c_master_recv(&t->i2c, buffer, sizeof(buffer));
 445                 tuner_info("I2C RECV = ");
 446                 for (i=0;i<rc;i++)
 447                         printk("%02x ",buffer[i]);
 448                 printk("\n");
 449         }
 450         /* HACK: This test were added to avoid tuner to probe tda9840 and tea6415c on the MXB card */
 451         if (adap->id == I2C_HW_SAA7146 && addr < 0x4a)
 452                 return -ENODEV;
 453
 454         /* autodetection code based on the i2c addr */
 455         if (!no_autodetect) {
 456                 switch (addr) {
 457                 case 0x42:
 458                 case 0x43:
 459                 case 0x4a:
 460                 case 0x4b:
 461                         /* If chip is not tda8290, don't register.
 462                            since it can be tda9887*/
 463                         if (tda8290_probe(&t->i2c) == 0) {
 464                                 tuner_dbg("chip at addr %x is a tda8290\n", addr);
 465                         } else {
 466                                 /* Default is being tda9887 */
 467                                 t->type = TUNER_TDA9887;
 468                                 t->mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
 469                                 t->mode = T_STANDBY;
 470                                 goto register_client;
 471                         }
 472                         break;
 473                 case 0x60:
 474                         if (tea5767_autodetection(&t->i2c) != EINVAL) {
 475                                 t->type = TUNER_TEA5767;
 476                                 t->mode_mask = T_RADIO;
 477                                 t->mode = T_STANDBY;
 478                                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
 479                                 default_mode_mask &= ~T_RADIO;
 480
 481                                 goto register_client;
 482                         }
 483                         break;
 484                 }
 485         }
 486
 487         /* Initializes only the first adapter found */
 488         if (default_mode_mask != T_UNINITIALIZED) {
 489                 tuner_dbg ("Setting mode_mask to 0x%02x\n", default_mode_mask);
 490                 t->mode_mask = default_mode_mask;
 491                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
 492                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
 493                 default_mode_mask = T_UNINITIALIZED;
 494         }
 495
 496         /* Should be just before return */
 497 register_client:
 498         tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
 499         i2c_attach_client (&t->i2c);
 500         set_type (&t->i2c,t->type, t->mode_mask);
 501         return 0;
 502 }
 503
 504 static int tuner_probe(struct i2c_adapter *adap)
 505 {
 506         if (0 != addr) {
 507                 normal_i2c[0] = addr;
 508                 normal_i2c[1] = I2C_CLIENT_END;
 509         }
 510
 511         default_mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
 512
 513         if (adap->class & I2C_CLASS_TV_ANALOG)
 514                 return i2c_probe(adap, &addr_data, tuner_attach);
 515         return 0;
 516 }
 517
 518 static int tuner_detach(struct i2c_client *client)
 519 {
 520         struct tuner *t = i2c_get_clientdata(client);
 521         int err;
 522
 523         err = i2c_detach_client(&t->i2c);
 524         if (err) {
 525                 tuner_warn
 526                     ("Client deregistration failed, client not detached.\n");
 527                 return err;
 528         }
 529
 530         kfree(t);
 531         return 0;
 532 }
 533
 534 /*
 535  * Switch tuner to other mode. If tuner support both tv and radio,
 536  * set another frequency to some value (This is needed for some pal
 537  * tuners to avoid locking). Otherwise, just put second tuner in
 538  * standby mode.
 539  */
 540
 541 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
 542 {
 543         if (mode == t->mode)
 544                 return 0;
 545
 546         t->mode = mode;
 547
 548         if (check_mode(t, cmd) == EINVAL) {
 549                 t->mode = T_STANDBY;
 550                 if (t->standby)
 551                         t->standby (client);
 552                 return EINVAL;
 553         }
 554         return 0;
 555 }
 556
 557 #define switch_v4l2()   if (!t->using_v4l2) \
 558                             tuner_dbg("switching to v4l2\n"); \
 559                         t->using_v4l2 = 1;
 560
 561 static inline int check_v4l2(struct tuner *t)
 562 {
 563         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
 564            TV, v4l1 for radio), until that is fixed this code is disabled.
 565            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
 566            first. */
 567         return 0;
 568 }
 569
 570 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
 571 {
 572         struct tuner *t = i2c_get_clientdata(client);
 573
 574         if (tuner_debug>1)
 575                 v4l_i2c_print_ioctl(&(t->i2c),cmd);
 576
 577         switch (cmd) {
 578         /* --- configuration --- */
 579         case TUNER_SET_TYPE_ADDR:
 580                 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x\n",
 581                                 ((struct tuner_setup *)arg)->type,
 582                                 ((struct tuner_setup *)arg)->addr,
 583                                 ((struct tuner_setup *)arg)->mode_mask);
 584
 585                 set_addr(client, (struct tuner_setup *)arg);
 586                 break;
 587         case AUDC_SET_RADIO:
 588                 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
 589                                 == EINVAL)
 590                         return 0;
 591                 if (t->radio_freq)
 592                         set_freq(client, t->radio_freq);
 593                 break;
 594         case TUNER_SET_STANDBY:
 595                 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
 596                         return 0;
 597                 t->mode = T_STANDBY;
 598                 if (t->standby)
 599                         t->standby (client);
 600                 break;
 601 #ifdef CONFIG_VIDEO_V4L1
 602         case VIDIOCSAUDIO:
 603                 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
 604                         return 0;
 605                 if (check_v4l2(t) == EINVAL)
 606                         return 0;
 607
 608                 /* Should be implemented, since bttv calls it */
 609                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
 610                 break;
 611         case VIDIOCSCHAN:
 612                 {
 613                         static const v4l2_std_id map[] = {
 614                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
 615                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
 616                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
 617                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
 618                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
 619                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
 620                         };
 621                         struct video_channel *vc = arg;
 622
 623                         if (check_v4l2(t) == EINVAL)
 624                                 return 0;
 625
 626                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
 627                                 return 0;
 628
 629                         if (vc->norm < ARRAY_SIZE(map))
 630                                 t->std = map[vc->norm];
 631                         tuner_fixup_std(t);
 632                         if (t->tv_freq)
 633                                 set_tv_freq(client, t->tv_freq);
 634                         return 0;
 635                 }
 636         case VIDIOCSFREQ:
 637                 {
 638                         unsigned long *v = arg;
 639
 640                         if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
 641                                 return 0;
 642                         if (check_v4l2(t) == EINVAL)
 643                                 return 0;
 644
 645                         set_freq(client, *v);
 646                         return 0;
 647                 }
 648         case VIDIOCGTUNER:
 649                 {
 650                         struct video_tuner *vt = arg;
 651
 652                         if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
 653                                 return 0;
 654                         if (check_v4l2(t) == EINVAL)
 655                                 return 0;
 656
 657                         if (V4L2_TUNER_RADIO == t->mode) {
 658                                 if (t->has_signal)
 659                                         vt->signal = t->has_signal(client);
 660                                 if (t->is_stereo) {
 661                                         if (t->is_stereo(client))
 662                                                 vt->flags |=
 663                                                     VIDEO_TUNER_STEREO_ON;
 664                                         else
 665                                                 vt->flags &=
 666                                                     ~VIDEO_TUNER_STEREO_ON;
 667                                 }
 668                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
 669
 670                                 vt->rangelow = radio_range[0] * 16000;
 671                                 vt->rangehigh = radio_range[1] * 16000;
 672
 673                         } else {
 674                                 vt->rangelow = tv_range[0] * 16;
 675                                 vt->rangehigh = tv_range[1] * 16;
 676                         }
 677
 678                         return 0;
 679                 }
 680         case VIDIOCGAUDIO:
 681                 {
 682                         struct video_audio *va = arg;
 683
 684                         if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
 685                                 return 0;
 686                         if (check_v4l2(t) == EINVAL)
 687                                 return 0;
 688
 689                         if (V4L2_TUNER_RADIO == t->mode && t->is_stereo)
 690                                 va->mode = t->is_stereo(client)
 691                                     ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
 692                         return 0;
 693                 }
 694 #endif
 695         case TDA9887_SET_CONFIG:
 696                 if (t->type == TUNER_TDA9887) {
 697                         int *i = arg;
 698
 699                         t->tda9887_config = *i;
 700                         set_freq(client, t->tv_freq);
 701                 }
 702                 break;
 703         /* --- v4l ioctls --- */
 704         /* take care: bttv does userspace copying, we'll get a
 705            kernel pointer here... */
 706         case VIDIOC_S_STD:
 707                 {
 708                         v4l2_std_id *id = arg;
 709
 710                         if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
 711                                         == EINVAL)
 712                                 return 0;
 713
 714                         switch_v4l2();
 715
 716                         t->std = *id;
 717                         tuner_fixup_std(t);
 718                         if (t->tv_freq)
 719                                 set_freq(client, t->tv_freq);
 720                         break;
 721                 }
 722         case VIDIOC_S_FREQUENCY:
 723                 {
 724                         struct v4l2_frequency *f = arg;
 725
 726                         if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
 727                                         == EINVAL)
 728                                 return 0;
 729                         switch_v4l2();
 730                         set_freq(client,f->frequency);
 731
 732                         break;
 733                 }
 734         case VIDIOC_G_FREQUENCY:
 735                 {
 736                         struct v4l2_frequency *f = arg;
 737
 738                         if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
 739                                 return 0;
 740                         switch_v4l2();
 741                         f->type = t->mode;
 742                         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
 743                                 t->radio_freq : t->tv_freq;
 744                         break;
 745                 }
 746         case VIDIOC_G_TUNER:
 747                 {
 748                         struct v4l2_tuner *tuner = arg;
 749
 750                         if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
 751                                 return 0;
 752                         switch_v4l2();
 753
 754                         tuner->type = t->mode;
 755                         if (t->get_afc)
 756                                 tuner->afc=t->get_afc(client);
 757                         if (t->mode == V4L2_TUNER_ANALOG_TV)
 758                                 tuner->capability |= V4L2_TUNER_CAP_NORM;
 759                         if (t->mode != V4L2_TUNER_RADIO) {
 760                                 tuner->rangelow = tv_range[0] * 16;
 761                                 tuner->rangehigh = tv_range[1] * 16;
 762                                 break;
 763                         }
 764
 765                         /* radio mode */
 766                         if (t->has_signal)
 767                                 tuner->signal = t->has_signal(client);
 768
 769                         tuner->rxsubchans =
 770                                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 771                         if (t->is_stereo) {
 772                                 tuner->rxsubchans = t->is_stereo(client) ?
 773                                         V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
 774                         }
 775
 776                         tuner->capability |=
 777                             V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
 778                         tuner->audmode = t->audmode;
 779                         tuner->rangelow = radio_range[0] * 16000;
 780                         tuner->rangehigh = radio_range[1] * 16000;
 781                         break;
 782                 }
 783         case VIDIOC_S_TUNER:
 784                 {
 785                         struct v4l2_tuner *tuner = arg;
 786
 787                         if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
 788                                 return 0;
 789
 790                         switch_v4l2();
 791
 792                         /* do nothing unless we're a radio tuner */
 793                         if (t->mode != V4L2_TUNER_RADIO)
 794                                 break;
 795                         t->audmode = tuner->audmode;
 796                         set_radio_freq(client, t->radio_freq);
 797                         break;
 798                 }
 799         case VIDIOC_LOG_STATUS:
 800                 if (t->tuner_status)
 801                         t->tuner_status(client);
 802                 break;
 803         }
 804
 805         return 0;
 806 }
 807
 808 static int tuner_suspend(struct device *dev, pm_message_t state)
 809 {
 810         struct i2c_client *c = container_of (dev, struct i2c_client, dev);
 811         struct tuner *t = i2c_get_clientdata (c);
 812
 813         tuner_dbg ("suspend\n");
 814         /* FIXME: power down ??? */
 815         return 0;
 816 }
 817
 818 static int tuner_resume(struct device *dev)
 819 {
 820         struct i2c_client *c = container_of (dev, struct i2c_client, dev);
 821         struct tuner *t = i2c_get_clientdata (c);
 822
 823         tuner_dbg ("resume\n");
 824         if (V4L2_TUNER_RADIO == t->mode) {
 825                 if (t->radio_freq)
 826                         set_freq(c, t->radio_freq);
 827         } else {
 828                 if (t->tv_freq)
 829                         set_freq(c, t->tv_freq);
 830         }
 831         return 0;
 832 }
 833
 834 /* ----------------------------------------------------------------------- */
 835
 836 static struct i2c_driver driver = {
 837         .id = I2C_DRIVERID_TUNER,
 838         .attach_adapter = tuner_probe,
 839         .detach_client = tuner_detach,
 840         .command = tuner_command,
 841         .driver = {
 842                 .name    = "tuner",
 843                 .suspend = tuner_suspend,
 844                 .resume  = tuner_resume,
 845         },
 846 };
 847 static struct i2c_client client_template = {
 848         .name = "(tuner unset)",
 849         .driver = &driver,
 850 };
 851
 852 static int __init tuner_init_module(void)
 853 {
 854         return i2c_add_driver(&driver);
 855 }
 856
 857 static void __exit tuner_cleanup_module(void)
 858 {
 859         i2c_del_driver(&driver);
 860 }
 861
 862 module_init(tuner_init_module);
 863 module_exit(tuner_cleanup_module);
 864
 865 /*
 866  * Overrides for Emacs so that we follow Linus's tabbing style.
 867  * ---------------------------------------------------------------------------
 868  * Local variables:
 869  * c-basic-offset: 8
 870  * End:
 871  */