drivers/media/dvb/frontends/lg2160.c

   1 /*
   2  *    Support for LG2160 - ATSC/MH
   3  *
   4  *    Copyright (C) 2010 Michael Krufky <mkrufky@linuxtv.org>
   5  *
   6  *    This program is free software; you can redistribute it and/or modify
   7  *    it under the terms of the GNU General Public License as published by
   8  *    the Free Software Foundation; either version 2 of the License, or
   9  *    (at your option) any later version.
  10  *
  11  *    This program is distributed in the hope that it will be useful,
  12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *    GNU General Public License for more details.
  15  *
  16  *    You should have received a copy of the GNU General Public License
  17  *    along with this program; if not, write to the Free Software
  18  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  *
  20  */
  21
  22 #include <linux/jiffies.h>
  23 #include <linux/dvb/frontend.h>
  24 #include "lg2160.h"
  25
  26 static int debug;
  27 module_param(debug, int, 0644);
  28 MODULE_PARM_DESC(debug, "set debug level (info=1, reg=2 (or-able))");
  29
  30 #define DBG_INFO 1
  31 #define DBG_REG  2
  32
  33 #define lg_printk(kern, fmt, arg...)                                    \
  34         printk(kern "%s: " fmt, __func__, ##arg)
  35
  36 #define lg_info(fmt, arg...)    printk(KERN_INFO "lg2160: " fmt, ##arg)
  37 #define lg_warn(fmt, arg...)    lg_printk(KERN_WARNING,       fmt, ##arg)
  38 #define lg_err(fmt, arg...)     lg_printk(KERN_ERR,           fmt, ##arg)
  39 #define lg_dbg(fmt, arg...) if (debug & DBG_INFO)                       \
  40                                 lg_printk(KERN_DEBUG,         fmt, ##arg)
  41 #define lg_reg(fmt, arg...) if (debug & DBG_REG)                        \
  42                                 lg_printk(KERN_DEBUG,         fmt, ##arg)
  43
  44 #define lg_fail(ret)                                                    \
  45 ({                                                                      \
  46         int __ret;                                                      \
  47         __ret = (ret < 0);                                              \
  48         if (__ret)                                                      \
  49                 lg_err("error %d on line %d\n", ret, __LINE__);         \
  50         __ret;                                                          \
  51 })
  52
  53 struct lg216x_state {
  54         struct i2c_adapter *i2c_adap;
  55         const struct lg2160_config *cfg;
  56
  57         struct dvb_frontend frontend;
  58
  59         u32 current_frequency;
  60         u8 parade_id;
  61         u8 fic_ver;
  62         unsigned int last_reset;
  63 };
  64
  65 /* ------------------------------------------------------------------------ */
  66
  67 static int lg216x_write_reg(struct lg216x_state *state, u16 reg, u8 val)
  68 {
  69         int ret;
  70         u8 buf[] = { reg >> 8, reg & 0xff, val };
  71         struct i2c_msg msg = {
  72                 .addr = state->cfg->i2c_addr, .flags = 0,
  73                 .buf = buf, .len = 3,
  74         };
  75
  76         lg_reg("reg: 0x%04x, val: 0x%02x\n", reg, val);
  77
  78         ret = i2c_transfer(state->i2c_adap, &msg, 1);
  79
  80         if (ret != 1) {
  81                 lg_err("error (addr %02x %02x <- %02x, err = %i)\n",
  82                        msg.buf[0], msg.buf[1], msg.buf[2], ret);
  83                 if (ret < 0)
  84                         return ret;
  85                 else
  86                         return -EREMOTEIO;
  87         }
  88         return 0;
  89 }
  90
  91 static int lg216x_read_reg(struct lg216x_state *state, u16 reg, u8 *val)
  92 {
  93         int ret;
  94         u8 reg_buf[] = { reg >> 8, reg & 0xff };
  95         struct i2c_msg msg[] = {
  96                 { .addr = state->cfg->i2c_addr,
  97                   .flags = 0, .buf = reg_buf, .len = 2 },
  98                 { .addr = state->cfg->i2c_addr,
  99                   .flags = I2C_M_RD, .buf = val, .len = 1 },
 100         };
 101
 102         lg_reg("reg: 0x%04x\n", reg);
 103
 104         ret = i2c_transfer(state->i2c_adap, msg, 2);
 105
 106         if (ret != 2) {
 107                 lg_err("error (addr %02x reg %04x error (ret == %i)\n",
 108                        state->cfg->i2c_addr, reg, ret);
 109                 if (ret < 0)
 110                         return ret;
 111                 else
 112                         return -EREMOTEIO;
 113         }
 114         return 0;
 115 }
 116
 117 struct lg216x_reg {
 118         u16 reg;
 119         u8 val;
 120 };
 121
 122 static int lg216x_write_regs(struct lg216x_state *state,
 123                              struct lg216x_reg *regs, int len)
 124 {
 125         int i, ret;
 126
 127         lg_reg("writing %d registers...\n", len);
 128
 129         for (i = 0; i < len - 1; i++) {
 130                 ret = lg216x_write_reg(state, regs[i].reg, regs[i].val);
 131                 if (lg_fail(ret))
 132                         return ret;
 133         }
 134         return 0;
 135 }
 136
 137 static int lg216x_set_reg_bit(struct lg216x_state *state,
 138                               u16 reg, int bit, int onoff)
 139 {
 140         u8 val;
 141         int ret;
 142
 143         lg_reg("reg: 0x%04x, bit: %d, level: %d\n", reg, bit, onoff);
 144
 145         ret = lg216x_read_reg(state, reg, &val);
 146         if (lg_fail(ret))
 147                 goto fail;
 148
 149         val &= ~(1 << bit);
 150         val |= (onoff & 1) << bit;
 151
 152         ret = lg216x_write_reg(state, reg, val);
 153         lg_fail(ret);
 154 fail:
 155         return ret;
 156 }
 157
 158 /* ------------------------------------------------------------------------ */
 159
 160 static int lg216x_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
 161 {
 162         struct lg216x_state *state = fe->demodulator_priv;
 163         int ret;
 164
 165         if (state->cfg->deny_i2c_rptr)
 166                 return 0;
 167
 168         lg_dbg("(%d)\n", enable);
 169
 170         ret = lg216x_set_reg_bit(state, 0x0000, 0, enable ? 0 : 1);
 171
 172         msleep(1);
 173
 174         return ret;
 175 }
 176
 177 static int lg216x_soft_reset(struct lg216x_state *state)
 178 {
 179         int ret;
 180
 181         lg_dbg("\n");
 182
 183         ret = lg216x_write_reg(state, 0x0002, 0x00);
 184         if (lg_fail(ret))
 185                 goto fail;
 186
 187         msleep(20);
 188         ret = lg216x_write_reg(state, 0x0002, 0x01);
 189         if (lg_fail(ret))
 190                 goto fail;
 191
 192         state->last_reset = jiffies_to_msecs(jiffies);
 193 fail:
 194         return ret;
 195 }
 196
 197 static int lg216x_initialize(struct lg216x_state *state)
 198 {
 199         int ret;
 200
 201         static struct lg216x_reg lg2160_init[] = {
 202 #if 0
 203                 { .reg = 0x0015, .val = 0xe6 },
 204 #else
 205                 { .reg = 0x0015, .val = 0xf7 },
 206                 { .reg = 0x001b, .val = 0x52 },
 207                 { .reg = 0x0208, .val = 0x00 },
 208                 { .reg = 0x0209, .val = 0x82 },
 209                 { .reg = 0x0210, .val = 0xf9 },
 210                 { .reg = 0x020a, .val = 0x00 },
 211                 { .reg = 0x020b, .val = 0x82 },
 212                 { .reg = 0x020d, .val = 0x28 },
 213                 { .reg = 0x020f, .val = 0x14 },
 214 #endif
 215         };
 216
 217         static struct lg216x_reg lg2161_init[] = {
 218                 { .reg = 0x0000, .val = 0x41 },
 219                 { .reg = 0x0001, .val = 0xfb },
 220                 { .reg = 0x0216, .val = 0x00 },
 221                 { .reg = 0x0219, .val = 0x00 },
 222                 { .reg = 0x021b, .val = 0x55 },
 223                 { .reg = 0x0606, .val = 0x0a },
 224         };
 225
 226         switch (state->cfg->lg_chip) {
 227         case LG2160:
 228                 ret = lg216x_write_regs(state,
 229                                         lg2160_init, ARRAY_SIZE(lg2160_init));
 230                 break;
 231         case LG2161:
 232                 ret = lg216x_write_regs(state,
 233                                         lg2161_init, ARRAY_SIZE(lg2161_init));
 234                 break;
 235         default:
 236                 ret = -EINVAL;
 237                 break;
 238         }
 239         if (lg_fail(ret))
 240                 goto fail;
 241
 242         ret = lg216x_soft_reset(state);
 243         lg_fail(ret);
 244 fail:
 245         return ret;
 246 }
 247
 248 /* ------------------------------------------------------------------------ */
 249
 250 static int lg216x_set_if(struct lg216x_state *state)
 251 {
 252         u8 val;
 253         int ret;
 254
 255         lg_dbg("%d KHz\n", state->cfg->if_khz);
 256
 257         ret = lg216x_read_reg(state, 0x0132, &val);
 258         if (lg_fail(ret))
 259                 goto fail;
 260
 261         val &= 0xfb;
 262         val |= (0 == state->cfg->if_khz) ? 0x04 : 0x00;
 263
 264         ret = lg216x_write_reg(state, 0x0132, val);
 265         lg_fail(ret);
 266
 267         /* if NOT zero IF, 6 MHz is the default */
 268 fail:
 269         return ret;
 270 }
 271
 272 /* ------------------------------------------------------------------------ */
 273
 274 static int lg2160_agc_fix(struct lg216x_state *state,
 275                           int if_agc_fix, int rf_agc_fix)
 276 {
 277         u8 val;
 278         int ret;
 279
 280         ret = lg216x_read_reg(state, 0x0100, &val);
 281         if (lg_fail(ret))
 282                 goto fail;
 283
 284         val &= 0xf3;
 285         val |= (if_agc_fix) ? 0x08 : 0x00;
 286         val |= (rf_agc_fix) ? 0x04 : 0x00;
 287
 288         ret = lg216x_write_reg(state, 0x0100, val);
 289         lg_fail(ret);
 290 fail:
 291         return ret;
 292 }
 293
 294 #if 0
 295 static int lg2160_agc_freeze(struct lg216x_state *state,
 296                              int if_agc_freeze, int rf_agc_freeze)
 297 {
 298         u8 val;
 299         int ret;
 300
 301         ret = lg216x_read_reg(state, 0x0100, &val);
 302         if (lg_fail(ret))
 303                 goto fail;
 304
 305         val &= 0xcf;
 306         val |= (if_agc_freeze) ? 0x20 : 0x00;
 307         val |= (rf_agc_freeze) ? 0x10 : 0x00;
 308
 309         ret = lg216x_write_reg(state, 0x0100, val);
 310         lg_fail(ret);
 311 fail:
 312         return ret;
 313 }
 314 #endif
 315
 316 static int lg2160_agc_polarity(struct lg216x_state *state,
 317                                int if_agc_polarity, int rf_agc_polarity)
 318 {
 319         u8 val;
 320         int ret;
 321
 322         ret = lg216x_read_reg(state, 0x0100, &val);
 323         if (lg_fail(ret))
 324                 goto fail;
 325
 326         val &= 0xfc;
 327         val |= (if_agc_polarity) ? 0x02 : 0x00;
 328         val |= (rf_agc_polarity) ? 0x01 : 0x00;
 329
 330         ret = lg216x_write_reg(state, 0x0100, val);
 331         lg_fail(ret);
 332 fail:
 333         return ret;
 334 }
 335
 336 static int lg2160_tuner_pwr_save_polarity(struct lg216x_state *state,
 337                                           int polarity)
 338 {
 339         u8 val;
 340         int ret;
 341
 342         ret = lg216x_read_reg(state, 0x0008, &val);
 343         if (lg_fail(ret))
 344                 goto fail;
 345
 346         val &= 0xfe;
 347         val |= (polarity) ? 0x01 : 0x00;
 348
 349         ret = lg216x_write_reg(state, 0x0008, val);
 350         lg_fail(ret);
 351 fail:
 352         return ret;
 353 }
 354
 355 static int lg2160_spectrum_polarity(struct lg216x_state *state,
 356                                     int inverted)
 357 {
 358         u8 val;
 359         int ret;
 360
 361         ret = lg216x_read_reg(state, 0x0132, &val);
 362         if (lg_fail(ret))
 363                 goto fail;
 364
 365         val &= 0xfd;
 366         val |= (inverted) ? 0x02 : 0x00;
 367
 368         ret = lg216x_write_reg(state, 0x0132, val);
 369         lg_fail(ret);
 370 fail:
 371         return lg216x_soft_reset(state);
 372 }
 373
 374 static int lg2160_tuner_pwr_save(struct lg216x_state *state, int onoff)
 375 {
 376         u8 val;
 377         int ret;
 378
 379         ret = lg216x_read_reg(state, 0x0007, &val);
 380         if (lg_fail(ret))
 381                 goto fail;
 382
 383         val &= 0xbf;
 384         val |= (onoff) ? 0x40 : 0x00;
 385
 386         ret = lg216x_write_reg(state, 0x0007, val);
 387         lg_fail(ret);
 388 fail:
 389         return ret;
 390 }
 391
 392 static int lg216x_set_parade(struct lg216x_state *state, int id)
 393 {
 394         int ret;
 395
 396         ret = lg216x_write_reg(state, 0x013e, id & 0x7f);
 397         if (lg_fail(ret))
 398                 goto fail;
 399
 400         state->parade_id = id & 0x7f;
 401 fail:
 402         return ret;
 403 }
 404
 405 static int lg216x_set_ensemble(struct lg216x_state *state, int id)
 406 {
 407         int ret;
 408         u16 reg;
 409         u8 val;
 410
 411         switch (state->cfg->lg_chip) {
 412         case LG2160:
 413                 reg = 0x0400;
 414                 break;
 415         case LG2161:
 416                 reg = 0x0500;
 417                 break;
 418         }
 419
 420         ret = lg216x_read_reg(state, reg, &val);
 421         if (lg_fail(ret))
 422                 goto fail;
 423
 424         val &= 0xfe;
 425         val |= (id) ? 0x01 : 0x00;
 426
 427         ret = lg216x_write_reg(state, reg, val);
 428         lg_fail(ret);
 429 fail:
 430         return ret;
 431 }
 432
 433 static int lg2160_set_spi_clock(struct lg216x_state *state)
 434 {
 435         u8 val;
 436         int ret;
 437
 438         ret = lg216x_read_reg(state, 0x0014, &val);
 439         if (lg_fail(ret))
 440                 goto fail;
 441
 442         val &= 0xf3;
 443         val |= (state->cfg->spi_clock << 2);
 444
 445         ret = lg216x_write_reg(state, 0x0014, val);
 446         lg_fail(ret);
 447 fail:
 448         return ret;
 449 }
 450
 451 static int lg2161_set_output_interface(struct lg216x_state *state)
 452 {
 453         u8 val;
 454         int ret;
 455
 456         ret = lg216x_read_reg(state, 0x0014, &val);
 457         if (lg_fail(ret))
 458                 goto fail;
 459
 460         val &= ~0x07;
 461         val |= state->cfg->output_if; /* FIXME: needs sanity check */
 462
 463         ret = lg216x_write_reg(state, 0x0014, val);
 464         lg_fail(ret);
 465 fail:
 466         return ret;
 467 }
 468
 469 static int lg216x_enable_fic(struct lg216x_state *state, int onoff)
 470 {
 471         int ret;
 472
 473         ret = lg216x_write_reg(state, 0x0017, 0x23);
 474         if (lg_fail(ret))
 475                 goto fail;
 476
 477         ret = lg216x_write_reg(state, 0x0016, 0xfc);
 478         if (lg_fail(ret))
 479                 goto fail;
 480
 481         switch (state->cfg->lg_chip) {
 482         case LG2160:
 483                 ret = lg216x_write_reg(state, 0x0016,
 484                                        0xfc | ((onoff) ? 0x02 : 0x00));
 485                 break;
 486         case LG2161:
 487                 ret = lg216x_write_reg(state, 0x0016, (onoff) ? 0x10 : 0x00);
 488                 break;
 489         }
 490         if (lg_fail(ret))
 491                 goto fail;
 492
 493         ret = lg216x_initialize(state);
 494         if (lg_fail(ret))
 495                 goto fail;
 496
 497         if (onoff) {
 498                 ret = lg216x_write_reg(state, 0x0017, 0x03);
 499                 lg_fail(ret);
 500         }
 501 fail:
 502         return ret;
 503 }
 504
 505 /* ------------------------------------------------------------------------ */
 506
 507 static int lg216x_get_fic_version(struct lg216x_state *state, u8 *ficver)
 508 {
 509         u8 val;
 510         int ret;
 511
 512         *ficver = 0xff; /* invalid value */
 513
 514         ret = lg216x_read_reg(state, 0x0128, &val);
 515         if (lg_fail(ret))
 516                 goto fail;
 517
 518         *ficver = (val >> 3) & 0x1f;
 519 fail:
 520         return ret;
 521 }
 522
 523 #if 0
 524 static int lg2160_get_parade_id(struct lg216x_state *state, u8 *id)
 525 {
 526         u8 val;
 527         int ret;
 528
 529         *id = 0xff; /* invalid value */
 530
 531         ret = lg216x_read_reg(state, 0x0123, &val);
 532         if (lg_fail(ret))
 533                 goto fail;
 534
 535         *id = val & 0x7f;
 536 fail:
 537         return ret;
 538 }
 539 #endif
 540
 541 static int lg216x_get_nog(struct lg216x_state *state, u8 *nog)
 542 {
 543         u8 val;
 544         int ret;
 545
 546         *nog = 0xff; /* invalid value */
 547
 548         ret = lg216x_read_reg(state, 0x0124, &val);
 549         if (lg_fail(ret))
 550                 goto fail;
 551
 552         *nog = ((val >> 4) & 0x07) + 1;
 553 fail:
 554         return ret;
 555 }
 556
 557 static int lg216x_get_tnog(struct lg216x_state *state, u8 *tnog)
 558 {
 559         u8 val;
 560         int ret;
 561
 562         *tnog = 0xff; /* invalid value */
 563
 564         ret = lg216x_read_reg(state, 0x0125, &val);
 565         if (lg_fail(ret))
 566                 goto fail;
 567
 568         *tnog = val & 0x1f;
 569 fail:
 570         return ret;
 571 }
 572
 573 static int lg216x_get_sgn(struct lg216x_state *state, u8 *sgn)
 574 {
 575         u8 val;
 576         int ret;
 577
 578         *sgn = 0xff; /* invalid value */
 579
 580         ret = lg216x_read_reg(state, 0x0124, &val);
 581         if (lg_fail(ret))
 582                 goto fail;
 583
 584         *sgn = val & 0x0f;
 585 fail:
 586         return ret;
 587 }
 588
 589 static int lg216x_get_prc(struct lg216x_state *state, u8 *prc)
 590 {
 591         u8 val;
 592         int ret;
 593
 594         *prc = 0xff; /* invalid value */
 595
 596         ret = lg216x_read_reg(state, 0x0125, &val);
 597         if (lg_fail(ret))
 598                 goto fail;
 599
 600         *prc = ((val >> 5) & 0x07) + 1;
 601 fail:
 602         return ret;
 603 }
 604
 605 /* ------------------------------------------------------------------------ */
 606
 607 static int lg216x_get_rs_frame_mode(struct lg216x_state *state,
 608                                     enum atscmh_rs_frame_mode *rs_framemode)
 609 {
 610         u8 val;
 611         int ret;
 612
 613         switch (state->cfg->lg_chip) {
 614         case LG2160:
 615                 ret = lg216x_read_reg(state, 0x0410, &val);
 616                 break;
 617         case LG2161:
 618                 ret = lg216x_read_reg(state, 0x0513, &val);
 619                 break;
 620         default:
 621                 ret = -EINVAL;
 622         }
 623         if (lg_fail(ret))
 624                 goto fail;
 625
 626         switch ((val >> 4) & 0x03) {
 627 #if 1
 628         default:
 629 #endif
 630         case 0x00:
 631                 *rs_framemode = ATSCMH_RSFRAME_PRI_ONLY;
 632                 break;
 633         case 0x01:
 634                 *rs_framemode = ATSCMH_RSFRAME_PRI_SEC;
 635                 break;
 636 #if 0
 637         default:
 638                 *rs_framemode = ATSCMH_RSFRAME_RES;
 639                 break;
 640 #endif
 641         }
 642 fail:
 643         return ret;
 644 }
 645
 646 static
 647 int lg216x_get_rs_frame_ensemble(struct lg216x_state *state,
 648                                  enum atscmh_rs_frame_ensemble *rs_frame_ens)
 649 {
 650         u8 val;
 651         int ret;
 652
 653         switch (state->cfg->lg_chip) {
 654         case LG2160:
 655                 ret = lg216x_read_reg(state, 0x0400, &val);
 656                 break;
 657         case LG2161:
 658                 ret = lg216x_read_reg(state, 0x0500, &val);
 659                 break;
 660         default:
 661                 ret = -EINVAL;
 662         }
 663         if (lg_fail(ret))
 664                 goto fail;
 665
 666         val &= 0x01;
 667         *rs_frame_ens = (enum atscmh_rs_frame_ensemble) val;
 668 fail:
 669         return ret;
 670 }
 671
 672 static int lg216x_get_rs_code_mode(struct lg216x_state *state,
 673                                    enum atscmh_rs_code_mode *rs_code_pri,
 674                                    enum atscmh_rs_code_mode *rs_code_sec)
 675 {
 676         u8 val;
 677         int ret;
 678
 679         switch (state->cfg->lg_chip) {
 680         case LG2160:
 681                 ret = lg216x_read_reg(state, 0x0410, &val);
 682                 break;
 683         case LG2161:
 684                 ret = lg216x_read_reg(state, 0x0513, &val);
 685                 break;
 686         default:
 687                 ret = -EINVAL;
 688         }
 689         if (lg_fail(ret))
 690                 goto fail;
 691
 692         *rs_code_pri = (enum atscmh_rs_code_mode) ((val >> 2) & 0x03);
 693         *rs_code_sec = (enum atscmh_rs_code_mode) (val & 0x03);
 694 fail:
 695         return ret;
 696 }
 697
 698 static int lg216x_get_sccc_block_mode(struct lg216x_state *state,
 699                                       enum atscmh_sccc_block_mode *sccc_block)
 700 {
 701         u8 val;
 702         int ret;
 703
 704         switch (state->cfg->lg_chip) {
 705         case LG2160:
 706                 ret = lg216x_read_reg(state, 0x0315, &val);
 707                 break;
 708         case LG2161:
 709                 ret = lg216x_read_reg(state, 0x0511, &val);
 710                 break;
 711         default:
 712                 ret = -EINVAL;
 713         }
 714         if (lg_fail(ret))
 715                 goto fail;
 716
 717         switch (val & 0x03) {
 718         case 0x00:
 719                 *sccc_block = ATSCMH_SCCC_BLK_SEP;
 720                 break;
 721         case 0x01:
 722                 *sccc_block = ATSCMH_SCCC_BLK_COMB;
 723                 break;
 724         default:
 725                 *sccc_block = ATSCMH_SCCC_BLK_RES;
 726                 break;
 727         }
 728 fail:
 729         return ret;
 730 }
 731
 732 static int lg216x_get_sccc_code_mode(struct lg216x_state *state,
 733                                      enum atscmh_sccc_code_mode *mode_a,
 734                                      enum atscmh_sccc_code_mode *mode_b,
 735                                      enum atscmh_sccc_code_mode *mode_c,
 736                                      enum atscmh_sccc_code_mode *mode_d)
 737 {
 738         u8 val;
 739         int ret;
 740
 741         switch (state->cfg->lg_chip) {
 742         case LG2160:
 743                 ret = lg216x_read_reg(state, 0x0316, &val);
 744                 break;
 745         case LG2161:
 746                 ret = lg216x_read_reg(state, 0x0512, &val);
 747                 break;
 748         default:
 749                 ret = -EINVAL;
 750         }
 751         if (lg_fail(ret))
 752                 goto fail;
 753
 754         switch ((val >> 6) & 0x03) {
 755         case 0x00:
 756                 *mode_a = ATSCMH_SCCC_CODE_HLF;
 757                 break;
 758         case 0x01:
 759                 *mode_a = ATSCMH_SCCC_CODE_QTR;
 760                 break;
 761         default:
 762                 *mode_a = ATSCMH_SCCC_CODE_RES;
 763                 break;
 764         }
 765
 766         switch ((val >> 4) & 0x03) {
 767         case 0x00:
 768                 *mode_b = ATSCMH_SCCC_CODE_HLF;
 769                 break;
 770         case 0x01:
 771                 *mode_b = ATSCMH_SCCC_CODE_QTR;
 772                 break;
 773         default:
 774                 *mode_b = ATSCMH_SCCC_CODE_RES;
 775                 break;
 776         }
 777
 778         switch ((val >> 2) & 0x03) {
 779         case 0x00:
 780                 *mode_c = ATSCMH_SCCC_CODE_HLF;
 781                 break;
 782         case 0x01:
 783                 *mode_c = ATSCMH_SCCC_CODE_QTR;
 784                 break;
 785         default:
 786                 *mode_c = ATSCMH_SCCC_CODE_RES;
 787                 break;
 788         }
 789
 790         switch (val & 0x03) {
 791         case 0x00:
 792                 *mode_d = ATSCMH_SCCC_CODE_HLF;
 793                 break;
 794         case 0x01:
 795                 *mode_d = ATSCMH_SCCC_CODE_QTR;
 796                 break;
 797         default:
 798                 *mode_d = ATSCMH_SCCC_CODE_RES;
 799                 break;
 800         }
 801 fail:
 802         return ret;
 803 }
 804
 805 /* ------------------------------------------------------------------------ */
 806
 807 #if 0
 808 static int lg216x_read_fic_err_count(struct lg216x_state *state, u8 *err)
 809 {
 810         u8 fic_err;
 811         int ret;
 812
 813         *err = 0;
 814
 815         switch (state->cfg->lg_chip) {
 816         case LG2160:
 817                 ret = lg216x_read_reg(state, 0x0012, &fic_err);
 818                 break;
 819         case LG2161:
 820                 ret = lg216x_read_reg(state, 0x001e, &fic_err);
 821                 break;
 822         }
 823         if (lg_fail(ret))
 824                 goto fail;
 825
 826         *err = fic_err;
 827 fail:
 828         return ret;
 829 }
 830
 831 static int lg2160_read_crc_err_count(struct lg216x_state *state, u16 *err)
 832 {
 833         u8 crc_err1, crc_err2;
 834         int ret;
 835
 836         *err = 0;
 837
 838         ret = lg216x_read_reg(state, 0x0411, &crc_err1);
 839         if (lg_fail(ret))
 840                 goto fail;
 841
 842         ret = lg216x_read_reg(state, 0x0412, &crc_err2);
 843         if (lg_fail(ret))
 844                 goto fail;
 845
 846         *err = (u16)(((crc_err2 & 0x0f) << 8) | crc_err1);
 847 fail:
 848         return ret;
 849 }
 850
 851 static int lg2161_read_crc_err_count(struct lg216x_state *state, u16 *err)
 852 {
 853         u8 crc_err;
 854         int ret;
 855
 856         *err = 0;
 857
 858         ret = lg216x_read_reg(state, 0x0612, &crc_err);
 859         if (lg_fail(ret))
 860                 goto fail;
 861
 862         *err = (u16)crc_err;
 863 fail:
 864         return ret;
 865 }
 866
 867 static int lg216x_read_crc_err_count(struct lg216x_state *state, u16 *err)
 868 {
 869         int ret;
 870         switch (state->cfg->lg_chip) {
 871         case LG2160:
 872                 ret = lg2160_read_crc_err_count(state, err);
 873                 break;
 874         case LG2161:
 875                 ret = lg2161_read_crc_err_count(state, err);
 876                 break;
 877         default:
 878                 ret = -EINVAL;
 879                 break;
 880         }
 881         return ret;
 882 }
 883
 884 static int lg2160_read_rs_err_count(struct lg216x_state *state, u16 *err)
 885 {
 886         u8 rs_err1, rs_err2;
 887         int ret;
 888
 889         *err = 0;
 890
 891         ret = lg216x_read_reg(state, 0x0413, &rs_err1);
 892         if (lg_fail(ret))
 893                 goto fail;
 894
 895         ret = lg216x_read_reg(state, 0x0414, &rs_err2);
 896         if (lg_fail(ret))
 897                 goto fail;
 898
 899         *err = (u16)(((rs_err2 & 0x0f) << 8) | rs_err1);
 900 fail:
 901         return ret;
 902 }
 903
 904 static int lg2161_read_rs_err_count(struct lg216x_state *state, u16 *err)
 905 {
 906         u8 rs_err1, rs_err2;
 907         int ret;
 908
 909         *err = 0;
 910
 911         ret = lg216x_read_reg(state, 0x0613, &rs_err1);
 912         if (lg_fail(ret))
 913                 goto fail;
 914
 915         ret = lg216x_read_reg(state, 0x0614, &rs_err2);
 916         if (lg_fail(ret))
 917                 goto fail;
 918
 919         *err = (u16)((rs_err1 << 8) | rs_err2);
 920 fail:
 921         return ret;
 922 }
 923
 924 static int lg216x_read_rs_err_count(struct lg216x_state *state, u16 *err)
 925 {
 926         int ret;
 927         switch (state->cfg->lg_chip) {
 928         case LG2160:
 929                 ret = lg2160_read_rs_err_count(state, err);
 930                 break;
 931         case LG2161:
 932                 ret = lg2161_read_rs_err_count(state, err);
 933                 break;
 934         default:
 935                 ret = -EINVAL;
 936                 break;
 937         }
 938         return ret;
 939 }
 940 #endif
 941
 942 /* ------------------------------------------------------------------------ */
 943
 944 static int lg216x_get_frontend(struct dvb_frontend *fe)
 945 {
 946         struct lg216x_state *state = fe->demodulator_priv;
 947         int ret;
 948
 949         lg_dbg("\n");
 950
 951         fe->dtv_property_cache.modulation = VSB_8;
 952         fe->dtv_property_cache.frequency = state->current_frequency;
 953         fe->dtv_property_cache.delivery_system = SYS_ATSCMH;
 954
 955         ret = lg216x_get_fic_version(state,
 956                                      &fe->dtv_property_cache.atscmh_fic_ver);
 957         if (lg_fail(ret))
 958                 goto fail;
 959         if (state->fic_ver != fe->dtv_property_cache.atscmh_fic_ver) {
 960                 state->fic_ver = fe->dtv_property_cache.atscmh_fic_ver;
 961
 962 #if 0
 963                 ret = lg2160_get_parade_id(state,
 964                                 &fe->dtv_property_cache.atscmh_parade_id);
 965                 if (lg_fail(ret))
 966                         goto fail;
 967 /* #else */
 968                 fe->dtv_property_cache.atscmh_parade_id = state->parade_id;
 969 #endif
 970                 ret = lg216x_get_nog(state,
 971                                      &fe->dtv_property_cache.atscmh_nog);
 972                 if (lg_fail(ret))
 973                         goto fail;
 974                 ret = lg216x_get_tnog(state,
 975                                       &fe->dtv_property_cache.atscmh_tnog);
 976                 if (lg_fail(ret))
 977                         goto fail;
 978                 ret = lg216x_get_sgn(state,
 979                                      &fe->dtv_property_cache.atscmh_sgn);
 980                 if (lg_fail(ret))
 981                         goto fail;
 982                 ret = lg216x_get_prc(state,
 983                                      &fe->dtv_property_cache.atscmh_prc);
 984                 if (lg_fail(ret))
 985                         goto fail;
 986
 987                 ret = lg216x_get_rs_frame_mode(state,
 988                         (enum atscmh_rs_frame_mode *)
 989                         &fe->dtv_property_cache.atscmh_rs_frame_mode);
 990                 if (lg_fail(ret))
 991                         goto fail;
 992                 ret = lg216x_get_rs_frame_ensemble(state,
 993                         (enum atscmh_rs_frame_ensemble *)
 994                         &fe->dtv_property_cache.atscmh_rs_frame_ensemble);
 995                 if (lg_fail(ret))
 996                         goto fail;
 997                 ret = lg216x_get_rs_code_mode(state,
 998                         (enum atscmh_rs_code_mode *)
 999                         &fe->dtv_property_cache.atscmh_rs_code_mode_pri,
1000                         (enum atscmh_rs_code_mode *)
1001                         &fe->dtv_property_cache.atscmh_rs_code_mode_sec);
1002                 if (lg_fail(ret))
1003                         goto fail;
1004                 ret = lg216x_get_sccc_block_mode(state,
1005                         (enum atscmh_sccc_block_mode *)
1006                         &fe->dtv_property_cache.atscmh_sccc_block_mode);
1007                 if (lg_fail(ret))
1008                         goto fail;
1009                 ret = lg216x_get_sccc_code_mode(state,
1010                         (enum atscmh_sccc_code_mode *)
1011                         &fe->dtv_property_cache.atscmh_sccc_code_mode_a,
1012                         (enum atscmh_sccc_code_mode *)
1013                         &fe->dtv_property_cache.atscmh_sccc_code_mode_b,
1014                         (enum atscmh_sccc_code_mode *)
1015                         &fe->dtv_property_cache.atscmh_sccc_code_mode_c,
1016                         (enum atscmh_sccc_code_mode *)
1017                         &fe->dtv_property_cache.atscmh_sccc_code_mode_d);
1018                 if (lg_fail(ret))
1019                         goto fail;
1020         }
1021 #if 0
1022         ret = lg216x_read_fic_err_count(state,
1023                                 (u8 *)&fe->dtv_property_cache.atscmh_fic_err);
1024         if (lg_fail(ret))
1025                 goto fail;
1026         ret = lg216x_read_crc_err_count(state,
1027                                 &fe->dtv_property_cache.atscmh_crc_err);
1028         if (lg_fail(ret))
1029                 goto fail;
1030         ret = lg216x_read_rs_err_count(state,
1031                                 &fe->dtv_property_cache.atscmh_rs_err);
1032         if (lg_fail(ret))
1033                 goto fail;
1034
1035         switch (state->cfg->lg_chip) {
1036         case LG2160:
1037                 if (((fe->dtv_property_cache.atscmh_rs_err >= 240) &&
1038                      (fe->dtv_property_cache.atscmh_crc_err >= 240)) &&
1039                     ((jiffies_to_msecs(jiffies) - state->last_reset) > 6000))
1040                         ret = lg216x_soft_reset(state);
1041                 break;
1042         case LG2161:
1043                 /* no fix needed here (as far as we know) */
1044                 ret = 0;
1045                 break;
1046         }
1047         lg_fail(ret);
1048 #endif
1049 fail:
1050         return ret;
1051 }
1052
1053 static int lg216x_get_property(struct dvb_frontend *fe,
1054                                struct dtv_property *tvp)
1055 {
1056         return (DTV_ATSCMH_FIC_VER == tvp->cmd) ?
1057                 lg216x_get_frontend(fe) : 0;
1058 }
1059
1060
1061 static int lg2160_set_frontend(struct dvb_frontend *fe)
1062 {
1063         struct lg216x_state *state = fe->demodulator_priv;
1064         int ret;
1065
1066         lg_dbg("(%d)\n", fe->dtv_property_cache.frequency);
1067
1068         if (fe->ops.tuner_ops.set_params) {
1069                 ret = fe->ops.tuner_ops.set_params(fe);
1070                 if (fe->ops.i2c_gate_ctrl)
1071                         fe->ops.i2c_gate_ctrl(fe, 0);
1072                 if (lg_fail(ret))
1073                         goto fail;
1074                 state->current_frequency = fe->dtv_property_cache.frequency;
1075         }
1076
1077         ret = lg2160_agc_fix(state, 0, 0);
1078         if (lg_fail(ret))
1079                 goto fail;
1080         ret = lg2160_agc_polarity(state, 0, 0);
1081         if (lg_fail(ret))
1082                 goto fail;
1083         ret = lg2160_tuner_pwr_save_polarity(state, 1);
1084         if (lg_fail(ret))
1085                 goto fail;
1086         ret = lg216x_set_if(state);
1087         if (lg_fail(ret))
1088                 goto fail;
1089         ret = lg2160_spectrum_polarity(state, state->cfg->spectral_inversion);
1090         if (lg_fail(ret))
1091                 goto fail;
1092
1093         /* be tuned before this point */
1094         ret = lg216x_soft_reset(state);
1095         if (lg_fail(ret))
1096                 goto fail;
1097
1098         ret = lg2160_tuner_pwr_save(state, 0);
1099         if (lg_fail(ret))
1100                 goto fail;
1101
1102         switch (state->cfg->lg_chip) {
1103         case LG2160:
1104                 ret = lg2160_set_spi_clock(state);
1105                 if (lg_fail(ret))
1106                         goto fail;
1107                 break;
1108         case LG2161:
1109                 ret = lg2161_set_output_interface(state);
1110                 if (lg_fail(ret))
1111                         goto fail;
1112                 break;
1113         }
1114
1115         ret = lg216x_set_parade(state, fe->dtv_property_cache.atscmh_parade_id);
1116         if (lg_fail(ret))
1117                 goto fail;
1118
1119         ret = lg216x_set_ensemble(state,
1120                         fe->dtv_property_cache.atscmh_rs_frame_ensemble);
1121         if (lg_fail(ret))
1122                 goto fail;
1123
1124         ret = lg216x_initialize(state);
1125         if (lg_fail(ret))
1126                 goto fail;
1127
1128         ret = lg216x_enable_fic(state, 1);
1129         lg_fail(ret);
1130
1131         lg216x_get_frontend(fe);
1132 fail:
1133         return ret;
1134 }
1135
1136 /* ------------------------------------------------------------------------ */
1137
1138 static int lg2160_read_lock_status(struct lg216x_state *state,
1139                                    int *acq_lock, int *sync_lock)
1140 {
1141         u8 val;
1142         int ret;
1143
1144         *acq_lock = 0;
1145         *sync_lock = 0;
1146
1147         ret = lg216x_read_reg(state, 0x011b, &val);
1148         if (lg_fail(ret))
1149                 goto fail;
1150
1151         *sync_lock = (val & 0x20) ? 0 : 1;
1152         *acq_lock  = (val & 0x40) ? 0 : 1;
1153 fail:
1154         return ret;
1155 }
1156
1157 #ifdef USE_LG2161_LOCK_BITS
1158 static int lg2161_read_lock_status(struct lg216x_state *state,
1159                                    int *acq_lock, int *sync_lock)
1160 {
1161         u8 val;
1162         int ret;
1163
1164         *acq_lock = 0;
1165         *sync_lock = 0;
1166
1167         ret = lg216x_read_reg(state, 0x0304, &val);
1168         if (lg_fail(ret))
1169                 goto fail;
1170
1171         *sync_lock = (val & 0x80) ? 0 : 1;
1172
1173         ret = lg216x_read_reg(state, 0x011b, &val);
1174         if (lg_fail(ret))
1175                 goto fail;
1176
1177         *acq_lock  = (val & 0x40) ? 0 : 1;
1178 fail:
1179         return ret;
1180 }
1181 #endif
1182
1183 static int lg216x_read_lock_status(struct lg216x_state *state,
1184                                    int *acq_lock, int *sync_lock)
1185 {
1186 #ifdef USE_LG2161_LOCK_BITS
1187         int ret;
1188         switch (state->cfg->lg_chip) {
1189         case LG2160:
1190                 ret = lg2160_read_lock_status(state, acq_lock, sync_lock);
1191                 break;
1192         case LG2161:
1193                 ret = lg2161_read_lock_status(state, acq_lock, sync_lock);
1194                 break;
1195         default:
1196                 ret = -EINVAL;
1197                 break;
1198         }
1199         return ret;
1200 #else
1201         return lg2160_read_lock_status(state, acq_lock, sync_lock);
1202 #endif
1203 }
1204
1205 static int lg216x_read_status(struct dvb_frontend *fe, fe_status_t *status)
1206 {
1207         struct lg216x_state *state = fe->demodulator_priv;
1208         int ret, acq_lock, sync_lock;
1209
1210         *status = 0;
1211
1212         ret = lg216x_read_lock_status(state, &acq_lock, &sync_lock);
1213         if (lg_fail(ret))
1214                 goto fail;
1215
1216         lg_dbg("%s%s\n",
1217                acq_lock  ? "SIGNALEXIST " : "",
1218                sync_lock ? "SYNCLOCK"     : "");
1219
1220         if (acq_lock)
1221                 *status |= FE_HAS_SIGNAL;
1222         if (sync_lock)
1223                 *status |= FE_HAS_SYNC;
1224
1225         if (*status)
1226                 *status |= FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_LOCK;
1227
1228 fail:
1229         return ret;
1230 }
1231
1232 /* ------------------------------------------------------------------------ */
1233
1234 static int lg2160_read_snr(struct dvb_frontend *fe, u16 *snr)
1235 {
1236         struct lg216x_state *state = fe->demodulator_priv;
1237         u8 snr1, snr2;
1238         int ret;
1239
1240         *snr = 0;
1241
1242         ret = lg216x_read_reg(state, 0x0202, &snr1);
1243         if (lg_fail(ret))
1244                 goto fail;
1245
1246         ret = lg216x_read_reg(state, 0x0203, &snr2);
1247         if (lg_fail(ret))
1248                 goto fail;
1249
1250         if ((snr1 == 0xba) || (snr2 == 0xdf))
1251                 *snr = 0;
1252         else
1253 #if 1
1254         *snr =  ((snr1 >> 4) * 100) + ((snr1 & 0x0f) * 10) + (snr2 >> 4);
1255 #else /* BCD */
1256         *snr =  (snr2 | (snr1 << 8));
1257 #endif
1258 fail:
1259         return ret;
1260 }
1261
1262 static int lg2161_read_snr(struct dvb_frontend *fe, u16 *snr)
1263 {
1264         struct lg216x_state *state = fe->demodulator_priv;
1265         u8 snr1, snr2;
1266         int ret;
1267
1268         *snr = 0;
1269
1270         ret = lg216x_read_reg(state, 0x0302, &snr1);
1271         if (lg_fail(ret))
1272                 goto fail;
1273
1274         ret = lg216x_read_reg(state, 0x0303, &snr2);
1275         if (lg_fail(ret))
1276                 goto fail;
1277
1278         if ((snr1 == 0xba) || (snr2 == 0xfd))
1279                 *snr = 0;
1280         else
1281
1282         *snr =  ((snr1 >> 4) * 100) + ((snr1 & 0x0f) * 10) + (snr2 & 0x0f);
1283 fail:
1284         return ret;
1285 }
1286
1287 static int lg216x_read_signal_strength(struct dvb_frontend *fe,
1288                                        u16 *strength)
1289 {
1290 #if 0
1291         /* borrowed from lgdt330x.c
1292          *
1293          * Calculate strength from SNR up to 35dB
1294          * Even though the SNR can go higher than 35dB,
1295          * there is some comfort factor in having a range of
1296          * strong signals that can show at 100%
1297          */
1298         struct lg216x_state *state = fe->demodulator_priv;
1299         u16 snr;
1300         int ret;
1301 #endif
1302         *strength = 0;
1303 #if 0
1304         ret = fe->ops.read_snr(fe, &snr);
1305         if (lg_fail(ret))
1306                 goto fail;
1307         /* Rather than use the 8.8 value snr, use state->snr which is 8.24 */
1308         /* scale the range 0 - 35*2^24 into 0 - 65535 */
1309         if (state->snr >= 8960 * 0x10000)
1310                 *strength = 0xffff;
1311         else
1312                 *strength = state->snr / 8960;
1313 fail:
1314         return ret;
1315 #else
1316         return 0;
1317 #endif
1318 }
1319
1320 /* ------------------------------------------------------------------------ */
1321
1322 static int lg216x_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1323 {
1324         struct lg216x_state *state = fe->demodulator_priv;
1325         int ret;
1326 #if 0
1327         ret = lg216x_read_rs_err_count(state,
1328                                        &fe->dtv_property_cache.atscmh_rs_err);
1329         if (lg_fail(ret))
1330                 goto fail;
1331
1332         *ucblocks = fe->dtv_property_cache.atscmh_rs_err;
1333 #else
1334         *ucblocks = 0;
1335 #endif
1336 fail:
1337         return 0;
1338 }
1339
1340 static int lg216x_get_tune_settings(struct dvb_frontend *fe,
1341                                     struct dvb_frontend_tune_settings
1342                                     *fe_tune_settings)
1343 {
1344         fe_tune_settings->min_delay_ms = 500;
1345         lg_dbg("\n");
1346         return 0;
1347 }
1348
1349 static void lg216x_release(struct dvb_frontend *fe)
1350 {
1351         struct lg216x_state *state = fe->demodulator_priv;
1352         lg_dbg("\n");
1353         kfree(state);
1354 }
1355
1356 static struct dvb_frontend_ops lg2160_ops = {
1357         .delsys = { SYS_ATSCMH },
1358         .info = {
1359                 .name = "LG Electronics LG2160 ATSC/MH Frontend",
1360                 .frequency_min      = 54000000,
1361                 .frequency_max      = 858000000,
1362                 .frequency_stepsize = 62500,
1363         },
1364         .i2c_gate_ctrl        = lg216x_i2c_gate_ctrl,
1365 #if 0
1366         .init                 = lg216x_init,
1367         .sleep                = lg216x_sleep,
1368 #endif
1369         .get_property         = lg216x_get_property,
1370
1371         .set_frontend         = lg2160_set_frontend,
1372         .get_frontend         = lg216x_get_frontend,
1373         .get_tune_settings    = lg216x_get_tune_settings,
1374         .read_status          = lg216x_read_status,
1375 #if 0
1376         .read_ber             = lg216x_read_ber,
1377 #endif
1378         .read_signal_strength = lg216x_read_signal_strength,
1379         .read_snr             = lg2160_read_snr,
1380         .read_ucblocks        = lg216x_read_ucblocks,
1381         .release              = lg216x_release,
1382 };
1383
1384 static struct dvb_frontend_ops lg2161_ops = {
1385         .delsys = { SYS_ATSCMH },
1386         .info = {
1387                 .name = "LG Electronics LG2161 ATSC/MH Frontend",
1388                 .frequency_min      = 54000000,
1389                 .frequency_max      = 858000000,
1390                 .frequency_stepsize = 62500,
1391         },
1392         .i2c_gate_ctrl        = lg216x_i2c_gate_ctrl,
1393 #if 0
1394         .init                 = lg216x_init,
1395         .sleep                = lg216x_sleep,
1396 #endif
1397         .get_property         = lg216x_get_property,
1398
1399         .set_frontend         = lg2160_set_frontend,
1400         .get_frontend         = lg216x_get_frontend,
1401         .get_tune_settings    = lg216x_get_tune_settings,
1402         .read_status          = lg216x_read_status,
1403 #if 0
1404         .read_ber             = lg216x_read_ber,
1405 #endif
1406         .read_signal_strength = lg216x_read_signal_strength,
1407         .read_snr             = lg2161_read_snr,
1408         .read_ucblocks        = lg216x_read_ucblocks,
1409         .release              = lg216x_release,
1410 };
1411
1412 struct dvb_frontend *lg2160_attach(const struct lg2160_config *config,
1413                                    struct i2c_adapter *i2c_adap)
1414 {
1415         struct lg216x_state *state = NULL;
1416
1417         lg_dbg("(%d-%04x)\n",
1418                i2c_adap ? i2c_adapter_id(i2c_adap) : 0,
1419                config ? config->i2c_addr : 0);
1420
1421         state = kzalloc(sizeof(struct lg216x_state), GFP_KERNEL);
1422         if (state == NULL)
1423                 goto fail;
1424
1425         state->cfg = config;
1426         state->i2c_adap = i2c_adap;
1427         state->fic_ver = 0xff;
1428         state->parade_id = 0xff;
1429
1430         switch (config->lg_chip) {
1431         default:
1432                 lg_warn("invalid chip requested, defaulting to LG2160");
1433                 /* fall-thru */
1434         case LG2160:
1435                 memcpy(&state->frontend.ops, &lg2160_ops,
1436                        sizeof(struct dvb_frontend_ops));
1437                 break;
1438         case LG2161:
1439                 memcpy(&state->frontend.ops, &lg2161_ops,
1440                        sizeof(struct dvb_frontend_ops));
1441                 break;
1442         }
1443
1444         state->frontend.demodulator_priv = state;
1445         state->current_frequency = -1;
1446         /* parade 1 by default */
1447         state->frontend.dtv_property_cache.atscmh_parade_id = 1;
1448
1449         return &state->frontend;
1450 fail:
1451         lg_warn("unable to detect LG216x hardware\n");
1452         kfree(state);
1453         return NULL;
1454 }
1455 EXPORT_SYMBOL(lg2160_attach);
1456
1457 MODULE_DESCRIPTION("LG Electronics LG216x ATSC/MH Demodulator Driver");
1458 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1459 MODULE_LICENSE("GPL");
1460 MODULE_VERSION("0.3");
1461
1462 /*
1463  * Local variables:
1464  * c-basic-offset: 8
1465  * End:
1466  */