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 static int lg216x_read_fic_err_count(struct lg216x_state *state, u8 *err)
 808 {
 809         u8 fic_err;
 810         int ret;
 811
 812         *err = 0;
 813
 814         switch (state->cfg->lg_chip) {
 815         case LG2160:
 816                 ret = lg216x_read_reg(state, 0x0012, &fic_err);
 817                 break;
 818         case LG2161:
 819                 ret = lg216x_read_reg(state, 0x001e, &fic_err);
 820                 break;
 821         }
 822         if (lg_fail(ret))
 823                 goto fail;
 824
 825         *err = fic_err;
 826 fail:
 827         return ret;
 828 }
 829
 830 static int lg2160_read_crc_err_count(struct lg216x_state *state, u16 *err)
 831 {
 832         u8 crc_err1, crc_err2;
 833         int ret;
 834
 835         *err = 0;
 836
 837         ret = lg216x_read_reg(state, 0x0411, &crc_err1);
 838         if (lg_fail(ret))
 839                 goto fail;
 840
 841         ret = lg216x_read_reg(state, 0x0412, &crc_err2);
 842         if (lg_fail(ret))
 843                 goto fail;
 844
 845         *err = (u16)(((crc_err2 & 0x0f) << 8) | crc_err1);
 846 fail:
 847         return ret;
 848 }
 849
 850 static int lg2161_read_crc_err_count(struct lg216x_state *state, u16 *err)
 851 {
 852         u8 crc_err;
 853         int ret;
 854
 855         *err = 0;
 856
 857         ret = lg216x_read_reg(state, 0x0612, &crc_err);
 858         if (lg_fail(ret))
 859                 goto fail;
 860
 861         *err = (u16)crc_err;
 862 fail:
 863         return ret;
 864 }
 865
 866 static int lg216x_read_crc_err_count(struct lg216x_state *state, u16 *err)
 867 {
 868         int ret;
 869         switch (state->cfg->lg_chip) {
 870         case LG2160:
 871                 ret = lg2160_read_crc_err_count(state, err);
 872                 break;
 873         case LG2161:
 874                 ret = lg2161_read_crc_err_count(state, err);
 875                 break;
 876         default:
 877                 ret = -EINVAL;
 878                 break;
 879         }
 880         return ret;
 881 }
 882
 883 static int lg2160_read_rs_err_count(struct lg216x_state *state, u16 *err)
 884 {
 885         u8 rs_err1, rs_err2;
 886         int ret;
 887
 888         *err = 0;
 889
 890         ret = lg216x_read_reg(state, 0x0413, &rs_err1);
 891         if (lg_fail(ret))
 892                 goto fail;
 893
 894         ret = lg216x_read_reg(state, 0x0414, &rs_err2);
 895         if (lg_fail(ret))
 896                 goto fail;
 897
 898         *err = (u16)(((rs_err2 & 0x0f) << 8) | rs_err1);
 899 fail:
 900         return ret;
 901 }
 902
 903 static int lg2161_read_rs_err_count(struct lg216x_state *state, u16 *err)
 904 {
 905         u8 rs_err1, rs_err2;
 906         int ret;
 907
 908         *err = 0;
 909
 910         ret = lg216x_read_reg(state, 0x0613, &rs_err1);
 911         if (lg_fail(ret))
 912                 goto fail;
 913
 914         ret = lg216x_read_reg(state, 0x0614, &rs_err2);
 915         if (lg_fail(ret))
 916                 goto fail;
 917
 918         *err = (u16)((rs_err1 << 8) | rs_err2);
 919 fail:
 920         return ret;
 921 }
 922
 923 static int lg216x_read_rs_err_count(struct lg216x_state *state, u16 *err)
 924 {
 925         int ret;
 926         switch (state->cfg->lg_chip) {
 927         case LG2160:
 928                 ret = lg2160_read_rs_err_count(state, err);
 929                 break;
 930         case LG2161:
 931                 ret = lg2161_read_rs_err_count(state, err);
 932                 break;
 933         default:
 934                 ret = -EINVAL;
 935                 break;
 936         }
 937         return ret;
 938 }
 939
 940 /* ------------------------------------------------------------------------ */
 941
 942 static int lg216x_get_frontend(struct dvb_frontend *fe)
 943 {
 944         struct lg216x_state *state = fe->demodulator_priv;
 945         int ret;
 946
 947         lg_dbg("\n");
 948
 949         fe->dtv_property_cache.modulation = VSB_8;
 950         fe->dtv_property_cache.frequency = state->current_frequency;
 951         fe->dtv_property_cache.delivery_system = SYS_ATSCMH;
 952
 953         ret = lg216x_get_fic_version(state,
 954                                      &fe->dtv_property_cache.atscmh_fic_ver);
 955         if (lg_fail(ret))
 956                 goto fail;
 957         if (state->fic_ver != fe->dtv_property_cache.atscmh_fic_ver) {
 958                 state->fic_ver = fe->dtv_property_cache.atscmh_fic_ver;
 959
 960 #if 0
 961                 ret = lg2160_get_parade_id(state,
 962                                 &fe->dtv_property_cache.atscmh_parade_id);
 963                 if (lg_fail(ret))
 964                         goto fail;
 965 /* #else */
 966                 fe->dtv_property_cache.atscmh_parade_id = state->parade_id;
 967 #endif
 968                 ret = lg216x_get_nog(state,
 969                                      &fe->dtv_property_cache.atscmh_nog);
 970                 if (lg_fail(ret))
 971                         goto fail;
 972                 ret = lg216x_get_tnog(state,
 973                                       &fe->dtv_property_cache.atscmh_tnog);
 974                 if (lg_fail(ret))
 975                         goto fail;
 976                 ret = lg216x_get_sgn(state,
 977                                      &fe->dtv_property_cache.atscmh_sgn);
 978                 if (lg_fail(ret))
 979                         goto fail;
 980                 ret = lg216x_get_prc(state,
 981                                      &fe->dtv_property_cache.atscmh_prc);
 982                 if (lg_fail(ret))
 983                         goto fail;
 984
 985                 ret = lg216x_get_rs_frame_mode(state,
 986                         (enum atscmh_rs_frame_mode *)
 987                         &fe->dtv_property_cache.atscmh_rs_frame_mode);
 988                 if (lg_fail(ret))
 989                         goto fail;
 990                 ret = lg216x_get_rs_frame_ensemble(state,
 991                         (enum atscmh_rs_frame_ensemble *)
 992                         &fe->dtv_property_cache.atscmh_rs_frame_ensemble);
 993                 if (lg_fail(ret))
 994                         goto fail;
 995                 ret = lg216x_get_rs_code_mode(state,
 996                         (enum atscmh_rs_code_mode *)
 997                         &fe->dtv_property_cache.atscmh_rs_code_mode_pri,
 998                         (enum atscmh_rs_code_mode *)
 999                         &fe->dtv_property_cache.atscmh_rs_code_mode_sec);
1000                 if (lg_fail(ret))
1001                         goto fail;
1002                 ret = lg216x_get_sccc_block_mode(state,
1003                         (enum atscmh_sccc_block_mode *)
1004                         &fe->dtv_property_cache.atscmh_sccc_block_mode);
1005                 if (lg_fail(ret))
1006                         goto fail;
1007                 ret = lg216x_get_sccc_code_mode(state,
1008                         (enum atscmh_sccc_code_mode *)
1009                         &fe->dtv_property_cache.atscmh_sccc_code_mode_a,
1010                         (enum atscmh_sccc_code_mode *)
1011                         &fe->dtv_property_cache.atscmh_sccc_code_mode_b,
1012                         (enum atscmh_sccc_code_mode *)
1013                         &fe->dtv_property_cache.atscmh_sccc_code_mode_c,
1014                         (enum atscmh_sccc_code_mode *)
1015                         &fe->dtv_property_cache.atscmh_sccc_code_mode_d);
1016                 if (lg_fail(ret))
1017                         goto fail;
1018         }
1019         ret = lg216x_read_fic_err_count(state,
1020                                 (u8 *)&fe->dtv_property_cache.atscmh_fic_err);
1021         if (lg_fail(ret))
1022                 goto fail;
1023         ret = lg216x_read_crc_err_count(state,
1024                                 &fe->dtv_property_cache.atscmh_crc_err);
1025         if (lg_fail(ret))
1026                 goto fail;
1027         ret = lg216x_read_rs_err_count(state,
1028                                 &fe->dtv_property_cache.atscmh_rs_err);
1029         if (lg_fail(ret))
1030                 goto fail;
1031
1032         switch (state->cfg->lg_chip) {
1033         case LG2160:
1034                 if (((fe->dtv_property_cache.atscmh_rs_err >= 240) &&
1035                      (fe->dtv_property_cache.atscmh_crc_err >= 240)) &&
1036                     ((jiffies_to_msecs(jiffies) - state->last_reset) > 6000))
1037                         ret = lg216x_soft_reset(state);
1038                 break;
1039         case LG2161:
1040                 /* no fix needed here (as far as we know) */
1041                 ret = 0;
1042                 break;
1043         }
1044         lg_fail(ret);
1045 fail:
1046         return ret;
1047 }
1048
1049 static int lg216x_get_property(struct dvb_frontend *fe,
1050                                struct dtv_property *tvp)
1051 {
1052         return (DTV_ATSCMH_FIC_VER == tvp->cmd) ?
1053                 lg216x_get_frontend(fe) : 0;
1054 }
1055
1056
1057 static int lg2160_set_frontend(struct dvb_frontend *fe)
1058 {
1059         struct lg216x_state *state = fe->demodulator_priv;
1060         int ret;
1061
1062         lg_dbg("(%d)\n", fe->dtv_property_cache.frequency);
1063
1064         if (fe->ops.tuner_ops.set_params) {
1065                 ret = fe->ops.tuner_ops.set_params(fe);
1066                 if (fe->ops.i2c_gate_ctrl)
1067                         fe->ops.i2c_gate_ctrl(fe, 0);
1068                 if (lg_fail(ret))
1069                         goto fail;
1070                 state->current_frequency = fe->dtv_property_cache.frequency;
1071         }
1072
1073         ret = lg2160_agc_fix(state, 0, 0);
1074         if (lg_fail(ret))
1075                 goto fail;
1076         ret = lg2160_agc_polarity(state, 0, 0);
1077         if (lg_fail(ret))
1078                 goto fail;
1079         ret = lg2160_tuner_pwr_save_polarity(state, 1);
1080         if (lg_fail(ret))
1081                 goto fail;
1082         ret = lg216x_set_if(state);
1083         if (lg_fail(ret))
1084                 goto fail;
1085         ret = lg2160_spectrum_polarity(state, state->cfg->spectral_inversion);
1086         if (lg_fail(ret))
1087                 goto fail;
1088
1089         /* be tuned before this point */
1090         ret = lg216x_soft_reset(state);
1091         if (lg_fail(ret))
1092                 goto fail;
1093
1094         ret = lg2160_tuner_pwr_save(state, 0);
1095         if (lg_fail(ret))
1096                 goto fail;
1097
1098         switch (state->cfg->lg_chip) {
1099         case LG2160:
1100                 ret = lg2160_set_spi_clock(state);
1101                 if (lg_fail(ret))
1102                         goto fail;
1103                 break;
1104         case LG2161:
1105                 ret = lg2161_set_output_interface(state);
1106                 if (lg_fail(ret))
1107                         goto fail;
1108                 break;
1109         }
1110
1111         ret = lg216x_set_parade(state, fe->dtv_property_cache.atscmh_parade_id);
1112         if (lg_fail(ret))
1113                 goto fail;
1114
1115         ret = lg216x_set_ensemble(state,
1116                         fe->dtv_property_cache.atscmh_rs_frame_ensemble);
1117         if (lg_fail(ret))
1118                 goto fail;
1119
1120         ret = lg216x_initialize(state);
1121         if (lg_fail(ret))
1122                 goto fail;
1123
1124         ret = lg216x_enable_fic(state, 1);
1125         lg_fail(ret);
1126
1127         lg216x_get_frontend(fe);
1128 fail:
1129         return ret;
1130 }
1131
1132 /* ------------------------------------------------------------------------ */
1133
1134 static int lg2160_read_lock_status(struct lg216x_state *state,
1135                                    int *acq_lock, int *sync_lock)
1136 {
1137         u8 val;
1138         int ret;
1139
1140         *acq_lock = 0;
1141         *sync_lock = 0;
1142
1143         ret = lg216x_read_reg(state, 0x011b, &val);
1144         if (lg_fail(ret))
1145                 goto fail;
1146
1147         *sync_lock = (val & 0x20) ? 0 : 1;
1148         *acq_lock  = (val & 0x40) ? 0 : 1;
1149 fail:
1150         return ret;
1151 }
1152
1153 #ifdef USE_LG2161_LOCK_BITS
1154 static int lg2161_read_lock_status(struct lg216x_state *state,
1155                                    int *acq_lock, int *sync_lock)
1156 {
1157         u8 val;
1158         int ret;
1159
1160         *acq_lock = 0;
1161         *sync_lock = 0;
1162
1163         ret = lg216x_read_reg(state, 0x0304, &val);
1164         if (lg_fail(ret))
1165                 goto fail;
1166
1167         *sync_lock = (val & 0x80) ? 0 : 1;
1168
1169         ret = lg216x_read_reg(state, 0x011b, &val);
1170         if (lg_fail(ret))
1171                 goto fail;
1172
1173         *acq_lock  = (val & 0x40) ? 0 : 1;
1174 fail:
1175         return ret;
1176 }
1177 #endif
1178
1179 static int lg216x_read_lock_status(struct lg216x_state *state,
1180                                    int *acq_lock, int *sync_lock)
1181 {
1182 #ifdef USE_LG2161_LOCK_BITS
1183         int ret;
1184         switch (state->cfg->lg_chip) {
1185         case LG2160:
1186                 ret = lg2160_read_lock_status(state, acq_lock, sync_lock);
1187                 break;
1188         case LG2161:
1189                 ret = lg2161_read_lock_status(state, acq_lock, sync_lock);
1190                 break;
1191         default:
1192                 ret = -EINVAL;
1193                 break;
1194         }
1195         return ret;
1196 #else
1197         return lg2160_read_lock_status(state, acq_lock, sync_lock);
1198 #endif
1199 }
1200
1201 static int lg216x_read_status(struct dvb_frontend *fe, fe_status_t *status)
1202 {
1203         struct lg216x_state *state = fe->demodulator_priv;
1204         int ret, acq_lock, sync_lock;
1205
1206         *status = 0;
1207
1208         ret = lg216x_read_lock_status(state, &acq_lock, &sync_lock);
1209         if (lg_fail(ret))
1210                 goto fail;
1211
1212         lg_dbg("%s%s\n",
1213                acq_lock  ? "SIGNALEXIST " : "",
1214                sync_lock ? "SYNCLOCK"     : "");
1215
1216         if (acq_lock)
1217                 *status |= FE_HAS_SIGNAL;
1218         if (sync_lock)
1219                 *status |= FE_HAS_SYNC;
1220
1221         if (*status)
1222                 *status |= FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_LOCK;
1223
1224 fail:
1225         return ret;
1226 }
1227
1228 /* ------------------------------------------------------------------------ */
1229
1230 static int lg2160_read_snr(struct dvb_frontend *fe, u16 *snr)
1231 {
1232         struct lg216x_state *state = fe->demodulator_priv;
1233         u8 snr1, snr2;
1234         int ret;
1235
1236         *snr = 0;
1237
1238         ret = lg216x_read_reg(state, 0x0202, &snr1);
1239         if (lg_fail(ret))
1240                 goto fail;
1241
1242         ret = lg216x_read_reg(state, 0x0203, &snr2);
1243         if (lg_fail(ret))
1244                 goto fail;
1245
1246         if ((snr1 == 0xba) || (snr2 == 0xdf))
1247                 *snr = 0;
1248         else
1249 #if 1
1250         *snr =  ((snr1 >> 4) * 100) + ((snr1 & 0x0f) * 10) + (snr2 >> 4);
1251 #else /* BCD */
1252         *snr =  (snr2 | (snr1 << 8));
1253 #endif
1254 fail:
1255         return ret;
1256 }
1257
1258 static int lg2161_read_snr(struct dvb_frontend *fe, u16 *snr)
1259 {
1260         struct lg216x_state *state = fe->demodulator_priv;
1261         u8 snr1, snr2;
1262         int ret;
1263
1264         *snr = 0;
1265
1266         ret = lg216x_read_reg(state, 0x0302, &snr1);
1267         if (lg_fail(ret))
1268                 goto fail;
1269
1270         ret = lg216x_read_reg(state, 0x0303, &snr2);
1271         if (lg_fail(ret))
1272                 goto fail;
1273
1274         if ((snr1 == 0xba) || (snr2 == 0xfd))
1275                 *snr = 0;
1276         else
1277
1278         *snr =  ((snr1 >> 4) * 100) + ((snr1 & 0x0f) * 10) + (snr2 & 0x0f);
1279 fail:
1280         return ret;
1281 }
1282
1283 static int lg216x_read_signal_strength(struct dvb_frontend *fe,
1284                                        u16 *strength)
1285 {
1286 #if 0
1287         /* borrowed from lgdt330x.c
1288          *
1289          * Calculate strength from SNR up to 35dB
1290          * Even though the SNR can go higher than 35dB,
1291          * there is some comfort factor in having a range of
1292          * strong signals that can show at 100%
1293          */
1294         struct lg216x_state *state = fe->demodulator_priv;
1295         u16 snr;
1296         int ret;
1297 #endif
1298         *strength = 0;
1299 #if 0
1300         ret = fe->ops.read_snr(fe, &snr);
1301         if (lg_fail(ret))
1302                 goto fail;
1303         /* Rather than use the 8.8 value snr, use state->snr which is 8.24 */
1304         /* scale the range 0 - 35*2^24 into 0 - 65535 */
1305         if (state->snr >= 8960 * 0x10000)
1306                 *strength = 0xffff;
1307         else
1308                 *strength = state->snr / 8960;
1309 fail:
1310         return ret;
1311 #else
1312         return 0;
1313 #endif
1314 }
1315
1316 /* ------------------------------------------------------------------------ */
1317
1318 static int lg216x_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1319 {
1320         struct lg216x_state *state = fe->demodulator_priv;
1321         int ret;
1322
1323         ret = lg216x_read_rs_err_count(state,
1324                                        &fe->dtv_property_cache.atscmh_rs_err);
1325         if (lg_fail(ret))
1326                 goto fail;
1327
1328         *ucblocks = fe->dtv_property_cache.atscmh_rs_err;
1329 fail:
1330         return 0;
1331 }
1332
1333 static int lg216x_get_tune_settings(struct dvb_frontend *fe,
1334                                     struct dvb_frontend_tune_settings
1335                                     *fe_tune_settings)
1336 {
1337         fe_tune_settings->min_delay_ms = 500;
1338         lg_dbg("\n");
1339         return 0;
1340 }
1341
1342 static void lg216x_release(struct dvb_frontend *fe)
1343 {
1344         struct lg216x_state *state = fe->demodulator_priv;
1345         lg_dbg("\n");
1346         kfree(state);
1347 }
1348
1349 static struct dvb_frontend_ops lg2160_ops = {
1350         .delsys = { SYS_ATSCMH },
1351         .info = {
1352                 .name = "LG Electronics LG2160 ATSC/MH Frontend",
1353                 .frequency_min      = 54000000,
1354                 .frequency_max      = 858000000,
1355                 .frequency_stepsize = 62500,
1356         },
1357         .i2c_gate_ctrl        = lg216x_i2c_gate_ctrl,
1358 #if 0
1359         .init                 = lg216x_init,
1360         .sleep                = lg216x_sleep,
1361 #endif
1362         .get_property         = lg216x_get_property,
1363
1364         .set_frontend         = lg2160_set_frontend,
1365         .get_frontend         = lg216x_get_frontend,
1366         .get_tune_settings    = lg216x_get_tune_settings,
1367         .read_status          = lg216x_read_status,
1368 #if 0
1369         .read_ber             = lg216x_read_ber,
1370 #endif
1371         .read_signal_strength = lg216x_read_signal_strength,
1372         .read_snr             = lg2160_read_snr,
1373         .read_ucblocks        = lg216x_read_ucblocks,
1374         .release              = lg216x_release,
1375 };
1376
1377 static struct dvb_frontend_ops lg2161_ops = {
1378         .delsys = { SYS_ATSCMH },
1379         .info = {
1380                 .name = "LG Electronics LG2161 ATSC/MH Frontend",
1381                 .frequency_min      = 54000000,
1382                 .frequency_max      = 858000000,
1383                 .frequency_stepsize = 62500,
1384         },
1385         .i2c_gate_ctrl        = lg216x_i2c_gate_ctrl,
1386 #if 0
1387         .init                 = lg216x_init,
1388         .sleep                = lg216x_sleep,
1389 #endif
1390         .get_property         = lg216x_get_property,
1391
1392         .set_frontend         = lg2160_set_frontend,
1393         .get_frontend         = lg216x_get_frontend,
1394         .get_tune_settings    = lg216x_get_tune_settings,
1395         .read_status          = lg216x_read_status,
1396 #if 0
1397         .read_ber             = lg216x_read_ber,
1398 #endif
1399         .read_signal_strength = lg216x_read_signal_strength,
1400         .read_snr             = lg2161_read_snr,
1401         .read_ucblocks        = lg216x_read_ucblocks,
1402         .release              = lg216x_release,
1403 };
1404
1405 struct dvb_frontend *lg2160_attach(const struct lg2160_config *config,
1406                                    struct i2c_adapter *i2c_adap)
1407 {
1408         struct lg216x_state *state = NULL;
1409
1410         lg_dbg("(%d-%04x)\n",
1411                i2c_adap ? i2c_adapter_id(i2c_adap) : 0,
1412                config ? config->i2c_addr : 0);
1413
1414         state = kzalloc(sizeof(struct lg216x_state), GFP_KERNEL);
1415         if (state == NULL)
1416                 goto fail;
1417
1418         state->cfg = config;
1419         state->i2c_adap = i2c_adap;
1420         state->fic_ver = 0xff;
1421         state->parade_id = 0xff;
1422
1423         switch (config->lg_chip) {
1424         default:
1425                 lg_warn("invalid chip requested, defaulting to LG2160");
1426                 /* fall-thru */
1427         case LG2160:
1428                 memcpy(&state->frontend.ops, &lg2160_ops,
1429                        sizeof(struct dvb_frontend_ops));
1430                 break;
1431         case LG2161:
1432                 memcpy(&state->frontend.ops, &lg2161_ops,
1433                        sizeof(struct dvb_frontend_ops));
1434                 break;
1435         }
1436
1437         state->frontend.demodulator_priv = state;
1438         state->current_frequency = -1;
1439         /* parade 1 by default */
1440         state->frontend.dtv_property_cache.atscmh_parade_id = 1;
1441
1442         return &state->frontend;
1443 fail:
1444         lg_warn("unable to detect LG216x hardware\n");
1445         kfree(state);
1446         return NULL;
1447 }
1448 EXPORT_SYMBOL(lg2160_attach);
1449
1450 MODULE_DESCRIPTION("LG Electronics LG216x ATSC/MH Demodulator Driver");
1451 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1452 MODULE_LICENSE("GPL");
1453 MODULE_VERSION("0.3");
1454
1455 /*
1456  * Local variables:
1457  * c-basic-offset: 8
1458  * End:
1459  */