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