SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/tuner-core.c

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