linux/drivers/media/dvb-frontends/mb86a16.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3        Fujitsu MB86A16 DVB-S/DSS DC Receiver driver
   4
   5        Copyright (C) Manu Abraham (abraham.manu@gmail.com)
   6
   7*/
   8
   9#include <linux/init.h>
  10#include <linux/kernel.h>
  11#include <linux/module.h>
  12#include <linux/moduleparam.h>
  13#include <linux/slab.h>
  14
  15#include <media/dvb_frontend.h>
  16#include "mb86a16.h"
  17#include "mb86a16_priv.h"
  18
  19static unsigned int verbose = 5;
  20module_param(verbose, int, 0644);
  21
  22struct mb86a16_state {
  23        struct i2c_adapter              *i2c_adap;
  24        const struct mb86a16_config     *config;
  25        struct dvb_frontend             frontend;
  26
  27        /* tuning parameters */
  28        int                             frequency;
  29        int                             srate;
  30
  31        /* Internal stuff */
  32        int                             master_clk;
  33        int                             deci;
  34        int                             csel;
  35        int                             rsel;
  36};
  37
  38#define MB86A16_ERROR           0
  39#define MB86A16_NOTICE          1
  40#define MB86A16_INFO            2
  41#define MB86A16_DEBUG           3
  42
  43#define dprintk(x, y, z, format, arg...) do {                                           \
  44        if (z) {                                                                        \
  45                if      ((x > MB86A16_ERROR) && (x > y))                                \
  46                        printk(KERN_ERR "%s: " format "\n", __func__, ##arg);           \
  47                else if ((x > MB86A16_NOTICE) && (x > y))                               \
  48                        printk(KERN_NOTICE "%s: " format "\n", __func__, ##arg);        \
  49                else if ((x > MB86A16_INFO) && (x > y))                                 \
  50                        printk(KERN_INFO "%s: " format "\n", __func__, ##arg);          \
  51                else if ((x > MB86A16_DEBUG) && (x > y))                                \
  52                        printk(KERN_DEBUG "%s: " format "\n", __func__, ##arg);         \
  53        } else {                                                                        \
  54                if (x > y)                                                              \
  55                        printk(format, ##arg);                                          \
  56        }                                                                               \
  57} while (0)
  58
  59#define TRACE_IN        dprintk(verbose, MB86A16_DEBUG, 1, "-->()")
  60#define TRACE_OUT       dprintk(verbose, MB86A16_DEBUG, 1, "()-->")
  61
  62static int mb86a16_write(struct mb86a16_state *state, u8 reg, u8 val)
  63{
  64        int ret;
  65        u8 buf[] = { reg, val };
  66
  67        struct i2c_msg msg = {
  68                .addr = state->config->demod_address,
  69                .flags = 0,
  70                .buf = buf,
  71                .len = 2
  72        };
  73
  74        dprintk(verbose, MB86A16_DEBUG, 1,
  75                "writing to [0x%02x],Reg[0x%02x],Data[0x%02x]",
  76                state->config->demod_address, buf[0], buf[1]);
  77
  78        ret = i2c_transfer(state->i2c_adap, &msg, 1);
  79
  80        return (ret != 1) ? -EREMOTEIO : 0;
  81}
  82
  83static int mb86a16_read(struct mb86a16_state *state, u8 reg, u8 *val)
  84{
  85        int ret;
  86        u8 b0[] = { reg };
  87        u8 b1[] = { 0 };
  88
  89        struct i2c_msg msg[] = {
  90                {
  91                        .addr = state->config->demod_address,
  92                        .flags = 0,
  93                        .buf = b0,
  94                        .len = 1
  95                }, {
  96                        .addr = state->config->demod_address,
  97                        .flags = I2C_M_RD,
  98                        .buf = b1,
  99                        .len = 1
 100                }
 101        };
 102        ret = i2c_transfer(state->i2c_adap, msg, 2);
 103        if (ret != 2) {
 104                dprintk(verbose, MB86A16_ERROR, 1, "read error(reg=0x%02x, ret=%i)",
 105                        reg, ret);
 106
 107                if (ret < 0)
 108                        return ret;
 109                return -EREMOTEIO;
 110        }
 111        *val = b1[0];
 112
 113        return ret;
 114}
 115
 116static int CNTM_set(struct mb86a16_state *state,
 117                    unsigned char timint1,
 118                    unsigned char timint2,
 119                    unsigned char cnext)
 120{
 121        unsigned char val;
 122
 123        val = (timint1 << 4) | (timint2 << 2) | cnext;
 124        if (mb86a16_write(state, MB86A16_CNTMR, val) < 0)
 125                goto err;
 126
 127        return 0;
 128
 129err:
 130        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 131        return -EREMOTEIO;
 132}
 133
 134static int smrt_set(struct mb86a16_state *state, int rate)
 135{
 136        int tmp ;
 137        int m ;
 138        unsigned char STOFS0, STOFS1;
 139
 140        m = 1 << state->deci;
 141        tmp = (8192 * state->master_clk - 2 * m * rate * 8192 + state->master_clk / 2) / state->master_clk;
 142
 143        STOFS0 = tmp & 0x0ff;
 144        STOFS1 = (tmp & 0xf00) >> 8;
 145
 146        if (mb86a16_write(state, MB86A16_SRATE1, (state->deci << 2) |
 147                                       (state->csel << 1) |
 148                                        state->rsel) < 0)
 149                goto err;
 150        if (mb86a16_write(state, MB86A16_SRATE2, STOFS0) < 0)
 151                goto err;
 152        if (mb86a16_write(state, MB86A16_SRATE3, STOFS1) < 0)
 153                goto err;
 154
 155        return 0;
 156err:
 157        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 158        return -1;
 159}
 160
 161static int srst(struct mb86a16_state *state)
 162{
 163        if (mb86a16_write(state, MB86A16_RESET, 0x04) < 0)
 164                goto err;
 165
 166        return 0;
 167err:
 168        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 169        return -EREMOTEIO;
 170
 171}
 172
 173static int afcex_data_set(struct mb86a16_state *state,
 174                          unsigned char AFCEX_L,
 175                          unsigned char AFCEX_H)
 176{
 177        if (mb86a16_write(state, MB86A16_AFCEXL, AFCEX_L) < 0)
 178                goto err;
 179        if (mb86a16_write(state, MB86A16_AFCEXH, AFCEX_H) < 0)
 180                goto err;
 181
 182        return 0;
 183err:
 184        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 185
 186        return -1;
 187}
 188
 189static int afcofs_data_set(struct mb86a16_state *state,
 190                           unsigned char AFCEX_L,
 191                           unsigned char AFCEX_H)
 192{
 193        if (mb86a16_write(state, 0x58, AFCEX_L) < 0)
 194                goto err;
 195        if (mb86a16_write(state, 0x59, AFCEX_H) < 0)
 196                goto err;
 197
 198        return 0;
 199err:
 200        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 201        return -EREMOTEIO;
 202}
 203
 204static int stlp_set(struct mb86a16_state *state,
 205                    unsigned char STRAS,
 206                    unsigned char STRBS)
 207{
 208        if (mb86a16_write(state, MB86A16_STRFILTCOEF1, (STRBS << 3) | (STRAS)) < 0)
 209                goto err;
 210
 211        return 0;
 212err:
 213        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 214        return -EREMOTEIO;
 215}
 216
 217static int Vi_set(struct mb86a16_state *state, unsigned char ETH, unsigned char VIA)
 218{
 219        if (mb86a16_write(state, MB86A16_VISET2, 0x04) < 0)
 220                goto err;
 221        if (mb86a16_write(state, MB86A16_VISET3, 0xf5) < 0)
 222                goto err;
 223
 224        return 0;
 225err:
 226        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 227        return -EREMOTEIO;
 228}
 229
 230static int initial_set(struct mb86a16_state *state)
 231{
 232        if (stlp_set(state, 5, 7))
 233                goto err;
 234
 235        udelay(100);
 236        if (afcex_data_set(state, 0, 0))
 237                goto err;
 238
 239        udelay(100);
 240        if (afcofs_data_set(state, 0, 0))
 241                goto err;
 242
 243        udelay(100);
 244        if (mb86a16_write(state, MB86A16_CRLFILTCOEF1, 0x16) < 0)
 245                goto err;
 246        if (mb86a16_write(state, 0x2f, 0x21) < 0)
 247                goto err;
 248        if (mb86a16_write(state, MB86A16_VIMAG, 0x38) < 0)
 249                goto err;
 250        if (mb86a16_write(state, MB86A16_FAGCS1, 0x00) < 0)
 251                goto err;
 252        if (mb86a16_write(state, MB86A16_FAGCS2, 0x1c) < 0)
 253                goto err;
 254        if (mb86a16_write(state, MB86A16_FAGCS3, 0x20) < 0)
 255                goto err;
 256        if (mb86a16_write(state, MB86A16_FAGCS4, 0x1e) < 0)
 257                goto err;
 258        if (mb86a16_write(state, MB86A16_FAGCS5, 0x23) < 0)
 259                goto err;
 260        if (mb86a16_write(state, 0x54, 0xff) < 0)
 261                goto err;
 262        if (mb86a16_write(state, MB86A16_TSOUT, 0x00) < 0)
 263                goto err;
 264
 265        return 0;
 266
 267err:
 268        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 269        return -EREMOTEIO;
 270}
 271
 272static int S01T_set(struct mb86a16_state *state,
 273                    unsigned char s1t,
 274                    unsigned s0t)
 275{
 276        if (mb86a16_write(state, 0x33, (s1t << 3) | s0t) < 0)
 277                goto err;
 278
 279        return 0;
 280err:
 281        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 282        return -EREMOTEIO;
 283}
 284
 285
 286static int EN_set(struct mb86a16_state *state,
 287                  int cren,
 288                  int afcen)
 289{
 290        unsigned char val;
 291
 292        val = 0x7a | (cren << 7) | (afcen << 2);
 293        if (mb86a16_write(state, 0x49, val) < 0)
 294                goto err;
 295
 296        return 0;
 297err:
 298        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 299        return -EREMOTEIO;
 300}
 301
 302static int AFCEXEN_set(struct mb86a16_state *state,
 303                       int afcexen,
 304                       int smrt)
 305{
 306        unsigned char AFCA ;
 307
 308        if (smrt > 18875)
 309                AFCA = 4;
 310        else if (smrt > 9375)
 311                AFCA = 3;
 312        else if (smrt > 2250)
 313                AFCA = 2;
 314        else
 315                AFCA = 1;
 316
 317        if (mb86a16_write(state, 0x2a, 0x02 | (afcexen << 5) | (AFCA << 2)) < 0)
 318                goto err;
 319
 320        return 0;
 321
 322err:
 323        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 324        return -EREMOTEIO;
 325}
 326
 327static int DAGC_data_set(struct mb86a16_state *state,
 328                         unsigned char DAGCA,
 329                         unsigned char DAGCW)
 330{
 331        if (mb86a16_write(state, 0x2d, (DAGCA << 3) | DAGCW) < 0)
 332                goto err;
 333
 334        return 0;
 335
 336err:
 337        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 338        return -EREMOTEIO;
 339}
 340
 341static void smrt_info_get(struct mb86a16_state *state, int rate)
 342{
 343        if (rate >= 37501) {
 344                state->deci = 0; state->csel = 0; state->rsel = 0;
 345        } else if (rate >= 30001) {
 346                state->deci = 0; state->csel = 0; state->rsel = 1;
 347        } else if (rate >= 26251) {
 348                state->deci = 0; state->csel = 1; state->rsel = 0;
 349        } else if (rate >= 22501) {
 350                state->deci = 0; state->csel = 1; state->rsel = 1;
 351        } else if (rate >= 18751) {
 352                state->deci = 1; state->csel = 0; state->rsel = 0;
 353        } else if (rate >= 15001) {
 354                state->deci = 1; state->csel = 0; state->rsel = 1;
 355        } else if (rate >= 13126) {
 356                state->deci = 1; state->csel = 1; state->rsel = 0;
 357        } else if (rate >= 11251) {
 358                state->deci = 1; state->csel = 1; state->rsel = 1;
 359        } else if (rate >= 9376) {
 360                state->deci = 2; state->csel = 0; state->rsel = 0;
 361        } else if (rate >= 7501) {
 362                state->deci = 2; state->csel = 0; state->rsel = 1;
 363        } else if (rate >= 6563) {
 364                state->deci = 2; state->csel = 1; state->rsel = 0;
 365        } else if (rate >= 5626) {
 366                state->deci = 2; state->csel = 1; state->rsel = 1;
 367        } else if (rate >= 4688) {
 368                state->deci = 3; state->csel = 0; state->rsel = 0;
 369        } else if (rate >= 3751) {
 370                state->deci = 3; state->csel = 0; state->rsel = 1;
 371        } else if (rate >= 3282) {
 372                state->deci = 3; state->csel = 1; state->rsel = 0;
 373        } else if (rate >= 2814) {
 374                state->deci = 3; state->csel = 1; state->rsel = 1;
 375        } else if (rate >= 2344) {
 376                state->deci = 4; state->csel = 0; state->rsel = 0;
 377        } else if (rate >= 1876) {
 378                state->deci = 4; state->csel = 0; state->rsel = 1;
 379        } else if (rate >= 1641) {
 380                state->deci = 4; state->csel = 1; state->rsel = 0;
 381        } else if (rate >= 1407) {
 382                state->deci = 4; state->csel = 1; state->rsel = 1;
 383        } else if (rate >= 1172) {
 384                state->deci = 5; state->csel = 0; state->rsel = 0;
 385        } else if (rate >=  939) {
 386                state->deci = 5; state->csel = 0; state->rsel = 1;
 387        } else if (rate >=  821) {
 388                state->deci = 5; state->csel = 1; state->rsel = 0;
 389        } else {
 390                state->deci = 5; state->csel = 1; state->rsel = 1;
 391        }
 392
 393        if (state->csel == 0)
 394                state->master_clk = 92000;
 395        else
 396                state->master_clk = 61333;
 397
 398}
 399
 400static int signal_det(struct mb86a16_state *state,
 401                      int smrt,
 402                      unsigned char *SIG)
 403{
 404        int ret;
 405        int smrtd;
 406        unsigned char S[3];
 407        int i;
 408
 409        if (*SIG > 45) {
 410                if (CNTM_set(state, 2, 1, 2) < 0) {
 411                        dprintk(verbose, MB86A16_ERROR, 1, "CNTM set Error");
 412                        return -1;
 413                }
 414        } else {
 415                if (CNTM_set(state, 3, 1, 2) < 0) {
 416                        dprintk(verbose, MB86A16_ERROR, 1, "CNTM set Error");
 417                        return -1;
 418                }
 419        }
 420        for (i = 0; i < 3; i++) {
 421                if (i == 0)
 422                        smrtd = smrt * 98 / 100;
 423                else if (i == 1)
 424                        smrtd = smrt;
 425                else
 426                        smrtd = smrt * 102 / 100;
 427                smrt_info_get(state, smrtd);
 428                smrt_set(state, smrtd);
 429                srst(state);
 430                msleep_interruptible(10);
 431                if (mb86a16_read(state, 0x37, &(S[i])) != 2) {
 432                        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 433                        return -EREMOTEIO;
 434                }
 435        }
 436        if ((S[1] > S[0] * 112 / 100) && (S[1] > S[2] * 112 / 100))
 437                ret = 1;
 438        else
 439                ret = 0;
 440
 441        *SIG = S[1];
 442
 443        if (CNTM_set(state, 0, 1, 2) < 0) {
 444                dprintk(verbose, MB86A16_ERROR, 1, "CNTM set Error");
 445                return -1;
 446        }
 447
 448        return ret;
 449}
 450
 451static int rf_val_set(struct mb86a16_state *state,
 452                      int f,
 453                      int smrt,
 454                      unsigned char R)
 455{
 456        unsigned char C, F, B;
 457        int M;
 458        unsigned char rf_val[5];
 459        int ack = -1;
 460
 461        if (smrt > 37750)
 462                C = 1;
 463        else if (smrt > 18875)
 464                C = 2;
 465        else if (smrt > 5500)
 466                C = 3;
 467        else
 468                C = 4;
 469
 470        if (smrt > 30500)
 471                F = 3;
 472        else if (smrt > 9375)
 473                F = 1;
 474        else if (smrt > 4625)
 475                F = 0;
 476        else
 477                F = 2;
 478
 479        if (f < 1060)
 480                B = 0;
 481        else if (f < 1175)
 482                B = 1;
 483        else if (f < 1305)
 484                B = 2;
 485        else if (f < 1435)
 486                B = 3;
 487        else if (f < 1570)
 488                B = 4;
 489        else if (f < 1715)
 490                B = 5;
 491        else if (f < 1845)
 492                B = 6;
 493        else if (f < 1980)
 494                B = 7;
 495        else if (f < 2080)
 496                B = 8;
 497        else
 498                B = 9;
 499
 500        M = f * (1 << R) / 2;
 501
 502        rf_val[0] = 0x01 | (C << 3) | (F << 1);
 503        rf_val[1] = (R << 5) | ((M & 0x1f000) >> 12);
 504        rf_val[2] = (M & 0x00ff0) >> 4;
 505        rf_val[3] = ((M & 0x0000f) << 4) | B;
 506
 507        /* Frequency Set */
 508        if (mb86a16_write(state, 0x21, rf_val[0]) < 0)
 509                ack = 0;
 510        if (mb86a16_write(state, 0x22, rf_val[1]) < 0)
 511                ack = 0;
 512        if (mb86a16_write(state, 0x23, rf_val[2]) < 0)
 513                ack = 0;
 514        if (mb86a16_write(state, 0x24, rf_val[3]) < 0)
 515                ack = 0;
 516        if (mb86a16_write(state, 0x25, 0x01) < 0)
 517                ack = 0;
 518        if (ack == 0) {
 519                dprintk(verbose, MB86A16_ERROR, 1, "RF Setup - I2C transfer error");
 520                return -EREMOTEIO;
 521        }
 522
 523        return 0;
 524}
 525
 526static int afcerr_chk(struct mb86a16_state *state)
 527{
 528        unsigned char AFCM_L, AFCM_H ;
 529        int AFCM ;
 530        int afcm, afcerr ;
 531
 532        if (mb86a16_read(state, 0x0e, &AFCM_L) != 2)
 533                goto err;
 534        if (mb86a16_read(state, 0x0f, &AFCM_H) != 2)
 535                goto err;
 536
 537        AFCM = (AFCM_H << 8) + AFCM_L;
 538
 539        if (AFCM > 2048)
 540                afcm = AFCM - 4096;
 541        else
 542                afcm = AFCM;
 543        afcerr = afcm * state->master_clk / 8192;
 544
 545        return afcerr;
 546
 547err:
 548        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 549        return -EREMOTEIO;
 550}
 551
 552static int dagcm_val_get(struct mb86a16_state *state)
 553{
 554        int DAGCM;
 555        unsigned char DAGCM_H, DAGCM_L;
 556
 557        if (mb86a16_read(state, 0x45, &DAGCM_L) != 2)
 558                goto err;
 559        if (mb86a16_read(state, 0x46, &DAGCM_H) != 2)
 560                goto err;
 561
 562        DAGCM = (DAGCM_H << 8) + DAGCM_L;
 563
 564        return DAGCM;
 565
 566err:
 567        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 568        return -EREMOTEIO;
 569}
 570
 571static int mb86a16_read_status(struct dvb_frontend *fe, enum fe_status *status)
 572{
 573        u8 stat, stat2;
 574        struct mb86a16_state *state = fe->demodulator_priv;
 575
 576        *status = 0;
 577
 578        if (mb86a16_read(state, MB86A16_SIG1, &stat) != 2)
 579                goto err;
 580        if (mb86a16_read(state, MB86A16_SIG2, &stat2) != 2)
 581                goto err;
 582        if ((stat > 25) && (stat2 > 25))
 583                *status |= FE_HAS_SIGNAL;
 584        if ((stat > 45) && (stat2 > 45))
 585                *status |= FE_HAS_CARRIER;
 586
 587        if (mb86a16_read(state, MB86A16_STATUS, &stat) != 2)
 588                goto err;
 589
 590        if (stat & 0x01)
 591                *status |= FE_HAS_SYNC;
 592        if (stat & 0x01)
 593                *status |= FE_HAS_VITERBI;
 594
 595        if (mb86a16_read(state, MB86A16_FRAMESYNC, &stat) != 2)
 596                goto err;
 597
 598        if ((stat & 0x0f) && (*status & FE_HAS_VITERBI))
 599                *status |= FE_HAS_LOCK;
 600
 601        return 0;
 602
 603err:
 604        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 605        return -EREMOTEIO;
 606}
 607
 608static int sync_chk(struct mb86a16_state *state,
 609                    unsigned char *VIRM)
 610{
 611        unsigned char val;
 612        int sync;
 613
 614        if (mb86a16_read(state, 0x0d, &val) != 2)
 615                goto err;
 616
 617        dprintk(verbose, MB86A16_INFO, 1, "Status = %02x,", val);
 618        sync = val & 0x01;
 619        *VIRM = (val & 0x1c) >> 2;
 620
 621        return sync;
 622err:
 623        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 624        *VIRM = 0;
 625        return -EREMOTEIO;
 626
 627}
 628
 629static int freqerr_chk(struct mb86a16_state *state,
 630                       int fTP,
 631                       int smrt,
 632                       int unit)
 633{
 634        unsigned char CRM, AFCML, AFCMH;
 635        unsigned char temp1, temp2, temp3;
 636        int crm, afcm, AFCM;
 637        int crrerr, afcerr;             /* kHz */
 638        int frqerr;                     /* MHz */
 639        int afcen, afcexen = 0;
 640        int R, M, fOSC, fOSC_OFS;
 641
 642        if (mb86a16_read(state, 0x43, &CRM) != 2)
 643                goto err;
 644
 645        if (CRM > 127)
 646                crm = CRM - 256;
 647        else
 648                crm = CRM;
 649
 650        crrerr = smrt * crm / 256;
 651        if (mb86a16_read(state, 0x49, &temp1) != 2)
 652                goto err;
 653
 654        afcen = (temp1 & 0x04) >> 2;
 655        if (afcen == 0) {
 656                if (mb86a16_read(state, 0x2a, &temp1) != 2)
 657                        goto err;
 658                afcexen = (temp1 & 0x20) >> 5;
 659        }
 660
 661        if (afcen == 1) {
 662                if (mb86a16_read(state, 0x0e, &AFCML) != 2)
 663                        goto err;
 664                if (mb86a16_read(state, 0x0f, &AFCMH) != 2)
 665                        goto err;
 666        } else if (afcexen == 1) {
 667                if (mb86a16_read(state, 0x2b, &AFCML) != 2)
 668                        goto err;
 669                if (mb86a16_read(state, 0x2c, &AFCMH) != 2)
 670                        goto err;
 671        }
 672        if ((afcen == 1) || (afcexen == 1)) {
 673                smrt_info_get(state, smrt);
 674                AFCM = ((AFCMH & 0x01) << 8) + AFCML;
 675                if (AFCM > 255)
 676                        afcm = AFCM - 512;
 677                else
 678                        afcm = AFCM;
 679
 680                afcerr = afcm * state->master_clk / 8192;
 681        } else
 682                afcerr = 0;
 683
 684        if (mb86a16_read(state, 0x22, &temp1) != 2)
 685                goto err;
 686        if (mb86a16_read(state, 0x23, &temp2) != 2)
 687                goto err;
 688        if (mb86a16_read(state, 0x24, &temp3) != 2)
 689                goto err;
 690
 691        R = (temp1 & 0xe0) >> 5;
 692        M = ((temp1 & 0x1f) << 12) + (temp2 << 4) + (temp3 >> 4);
 693        if (R == 0)
 694                fOSC = 2 * M;
 695        else
 696                fOSC = M;
 697
 698        fOSC_OFS = fOSC - fTP;
 699
 700        if (unit == 0) {        /* MHz */
 701                if (crrerr + afcerr + fOSC_OFS * 1000 >= 0)
 702                        frqerr = (crrerr + afcerr + fOSC_OFS * 1000 + 500) / 1000;
 703                else
 704                        frqerr = (crrerr + afcerr + fOSC_OFS * 1000 - 500) / 1000;
 705        } else {        /* kHz */
 706                frqerr = crrerr + afcerr + fOSC_OFS * 1000;
 707        }
 708
 709        return frqerr;
 710err:
 711        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 712        return -EREMOTEIO;
 713}
 714
 715static unsigned char vco_dev_get(struct mb86a16_state *state, int smrt)
 716{
 717        unsigned char R;
 718
 719        if (smrt > 9375)
 720                R = 0;
 721        else
 722                R = 1;
 723
 724        return R;
 725}
 726
 727static void swp_info_get(struct mb86a16_state *state,
 728                         int fOSC_start,
 729                         int smrt,
 730                         int v, int R,
 731                         int swp_ofs,
 732                         int *fOSC,
 733                         int *afcex_freq,
 734                         unsigned char *AFCEX_L,
 735                         unsigned char *AFCEX_H)
 736{
 737        int AFCEX ;
 738        int crnt_swp_freq ;
 739
 740        crnt_swp_freq = fOSC_start * 1000 + v * swp_ofs;
 741
 742        if (R == 0)
 743                *fOSC = (crnt_swp_freq + 1000) / 2000 * 2;
 744        else
 745                *fOSC = (crnt_swp_freq + 500) / 1000;
 746
 747        if (*fOSC >= crnt_swp_freq)
 748                *afcex_freq = *fOSC * 1000 - crnt_swp_freq;
 749        else
 750                *afcex_freq = crnt_swp_freq - *fOSC * 1000;
 751
 752        AFCEX = *afcex_freq * 8192 / state->master_clk;
 753        *AFCEX_L =  AFCEX & 0x00ff;
 754        *AFCEX_H = (AFCEX & 0x0f00) >> 8;
 755}
 756
 757
 758static int swp_freq_calcuation(struct mb86a16_state *state, int i, int v, int *V,  int vmax, int vmin,
 759                               int SIGMIN, int fOSC, int afcex_freq, int swp_ofs, unsigned char *SIG1)
 760{
 761        int swp_freq ;
 762
 763        if ((i % 2 == 1) && (v <= vmax)) {
 764                /* positive v (case 1) */
 765                if ((v - 1 == vmin)                             &&
 766                    (*(V + 30 + v) >= 0)                        &&
 767                    (*(V + 30 + v - 1) >= 0)                    &&
 768                    (*(V + 30 + v - 1) > *(V + 30 + v))         &&
 769                    (*(V + 30 + v - 1) > SIGMIN)) {
 770
 771                        swp_freq = fOSC * 1000 + afcex_freq - swp_ofs;
 772                        *SIG1 = *(V + 30 + v - 1);
 773                } else if ((v == vmax)                          &&
 774                           (*(V + 30 + v) >= 0)                 &&
 775                           (*(V + 30 + v - 1) >= 0)             &&
 776                           (*(V + 30 + v) > *(V + 30 + v - 1))  &&
 777                           (*(V + 30 + v) > SIGMIN)) {
 778                        /* (case 2) */
 779                        swp_freq = fOSC * 1000 + afcex_freq;
 780                        *SIG1 = *(V + 30 + v);
 781                } else if ((*(V + 30 + v) > 0)                  &&
 782                           (*(V + 30 + v - 1) > 0)              &&
 783                           (*(V + 30 + v - 2) > 0)              &&
 784                           (*(V + 30 + v - 3) > 0)              &&
 785                           (*(V + 30 + v - 1) > *(V + 30 + v))  &&
 786                           (*(V + 30 + v - 2) > *(V + 30 + v - 3)) &&
 787                           ((*(V + 30 + v - 1) > SIGMIN)        ||
 788                           (*(V + 30 + v - 2) > SIGMIN))) {
 789                        /* (case 3) */
 790                        if (*(V + 30 + v - 1) >= *(V + 30 + v - 2)) {
 791                                swp_freq = fOSC * 1000 + afcex_freq - swp_ofs;
 792                                *SIG1 = *(V + 30 + v - 1);
 793                        } else {
 794                                swp_freq = fOSC * 1000 + afcex_freq - swp_ofs * 2;
 795                                *SIG1 = *(V + 30 + v - 2);
 796                        }
 797                } else if ((v == vmax)                          &&
 798                           (*(V + 30 + v) >= 0)                 &&
 799                           (*(V + 30 + v - 1) >= 0)             &&
 800                           (*(V + 30 + v - 2) >= 0)             &&
 801                           (*(V + 30 + v) > *(V + 30 + v - 2))  &&
 802                           (*(V + 30 + v - 1) > *(V + 30 + v - 2)) &&
 803                           ((*(V + 30 + v) > SIGMIN)            ||
 804                           (*(V + 30 + v - 1) > SIGMIN))) {
 805                        /* (case 4) */
 806                        if (*(V + 30 + v) >= *(V + 30 + v - 1)) {
 807                                swp_freq = fOSC * 1000 + afcex_freq;
 808                                *SIG1 = *(V + 30 + v);
 809                        } else {
 810                                swp_freq = fOSC * 1000 + afcex_freq - swp_ofs;
 811                                *SIG1 = *(V + 30 + v - 1);
 812                        }
 813                } else  {
 814                        swp_freq = -1 ;
 815                }
 816        } else if ((i % 2 == 0) && (v >= vmin)) {
 817                /* Negative v (case 1) */
 818                if ((*(V + 30 + v) > 0)                         &&
 819                    (*(V + 30 + v + 1) > 0)                     &&
 820                    (*(V + 30 + v + 2) > 0)                     &&
 821                    (*(V + 30 + v + 1) > *(V + 30 + v))         &&
 822                    (*(V + 30 + v + 1) > *(V + 30 + v + 2))     &&
 823                    (*(V + 30 + v + 1) > SIGMIN)) {
 824
 825                        swp_freq = fOSC * 1000 + afcex_freq + swp_ofs;
 826                        *SIG1 = *(V + 30 + v + 1);
 827                } else if ((v + 1 == vmax)                      &&
 828                           (*(V + 30 + v) >= 0)                 &&
 829                           (*(V + 30 + v + 1) >= 0)             &&
 830                           (*(V + 30 + v + 1) > *(V + 30 + v))  &&
 831                           (*(V + 30 + v + 1) > SIGMIN)) {
 832                        /* (case 2) */
 833                        swp_freq = fOSC * 1000 + afcex_freq + swp_ofs;
 834                        *SIG1 = *(V + 30 + v);
 835                } else if ((v == vmin)                          &&
 836                           (*(V + 30 + v) > 0)                  &&
 837                           (*(V + 30 + v + 1) > 0)              &&
 838                           (*(V + 30 + v + 2) > 0)              &&
 839                           (*(V + 30 + v) > *(V + 30 + v + 1))  &&
 840                           (*(V + 30 + v) > *(V + 30 + v + 2))  &&
 841                           (*(V + 30 + v) > SIGMIN)) {
 842                        /* (case 3) */
 843                        swp_freq = fOSC * 1000 + afcex_freq;
 844                        *SIG1 = *(V + 30 + v);
 845                } else if ((*(V + 30 + v) >= 0)                 &&
 846                           (*(V + 30 + v + 1) >= 0)             &&
 847                           (*(V + 30 + v + 2) >= 0)             &&
 848                           (*(V + 30 + v + 3) >= 0)             &&
 849                           (*(V + 30 + v + 1) > *(V + 30 + v))  &&
 850                           (*(V + 30 + v + 2) > *(V + 30 + v + 3)) &&
 851                           ((*(V + 30 + v + 1) > SIGMIN)        ||
 852                            (*(V + 30 + v + 2) > SIGMIN))) {
 853                        /* (case 4) */
 854                        if (*(V + 30 + v + 1) >= *(V + 30 + v + 2)) {
 855                                swp_freq = fOSC * 1000 + afcex_freq + swp_ofs;
 856                                *SIG1 = *(V + 30 + v + 1);
 857                        } else {
 858                                swp_freq = fOSC * 1000 + afcex_freq + swp_ofs * 2;
 859                                *SIG1 = *(V + 30 + v + 2);
 860                        }
 861                } else if ((*(V + 30 + v) >= 0)                 &&
 862                           (*(V + 30 + v + 1) >= 0)             &&
 863                           (*(V + 30 + v + 2) >= 0)             &&
 864                           (*(V + 30 + v + 3) >= 0)             &&
 865                           (*(V + 30 + v) > *(V + 30 + v + 2))  &&
 866                           (*(V + 30 + v + 1) > *(V + 30 + v + 2)) &&
 867                           (*(V + 30 + v) > *(V + 30 + v + 3))  &&
 868                           (*(V + 30 + v + 1) > *(V + 30 + v + 3)) &&
 869                           ((*(V + 30 + v) > SIGMIN)            ||
 870                            (*(V + 30 + v + 1) > SIGMIN))) {
 871                        /* (case 5) */
 872                        if (*(V + 30 + v) >= *(V + 30 + v + 1)) {
 873                                swp_freq = fOSC * 1000 + afcex_freq;
 874                                *SIG1 = *(V + 30 + v);
 875                        } else {
 876                                swp_freq = fOSC * 1000 + afcex_freq + swp_ofs;
 877                                *SIG1 = *(V + 30 + v + 1);
 878                        }
 879                } else if ((v + 2 == vmin)                      &&
 880                           (*(V + 30 + v) >= 0)                 &&
 881                           (*(V + 30 + v + 1) >= 0)             &&
 882                           (*(V + 30 + v + 2) >= 0)             &&
 883                           (*(V + 30 + v + 1) > *(V + 30 + v))  &&
 884                           (*(V + 30 + v + 2) > *(V + 30 + v))  &&
 885                           ((*(V + 30 + v + 1) > SIGMIN)        ||
 886                            (*(V + 30 + v + 2) > SIGMIN))) {
 887                        /* (case 6) */
 888                        if (*(V + 30 + v + 1) >= *(V + 30 + v + 2)) {
 889                                swp_freq = fOSC * 1000 + afcex_freq + swp_ofs;
 890                                *SIG1 = *(V + 30 + v + 1);
 891                        } else {
 892                                swp_freq = fOSC * 1000 + afcex_freq + swp_ofs * 2;
 893                                *SIG1 = *(V + 30 + v + 2);
 894                        }
 895                } else if ((vmax == 0) && (vmin == 0) && (*(V + 30 + v) > SIGMIN)) {
 896                        swp_freq = fOSC * 1000;
 897                        *SIG1 = *(V + 30 + v);
 898                } else
 899                        swp_freq = -1;
 900        } else
 901                swp_freq = -1;
 902
 903        return swp_freq;
 904}
 905
 906static void swp_info_get2(struct mb86a16_state *state,
 907                          int smrt,
 908                          int R,
 909                          int swp_freq,
 910                          int *afcex_freq,
 911                          int *fOSC,
 912                          unsigned char *AFCEX_L,
 913                          unsigned char *AFCEX_H)
 914{
 915        int AFCEX ;
 916
 917        if (R == 0)
 918                *fOSC = (swp_freq + 1000) / 2000 * 2;
 919        else
 920                *fOSC = (swp_freq + 500) / 1000;
 921
 922        if (*fOSC >= swp_freq)
 923                *afcex_freq = *fOSC * 1000 - swp_freq;
 924        else
 925                *afcex_freq = swp_freq - *fOSC * 1000;
 926
 927        AFCEX = *afcex_freq * 8192 / state->master_clk;
 928        *AFCEX_L =  AFCEX & 0x00ff;
 929        *AFCEX_H = (AFCEX & 0x0f00) >> 8;
 930}
 931
 932static void afcex_info_get(struct mb86a16_state *state,
 933                           int afcex_freq,
 934                           unsigned char *AFCEX_L,
 935                           unsigned char *AFCEX_H)
 936{
 937        int AFCEX ;
 938
 939        AFCEX = afcex_freq * 8192 / state->master_clk;
 940        *AFCEX_L =  AFCEX & 0x00ff;
 941        *AFCEX_H = (AFCEX & 0x0f00) >> 8;
 942}
 943
 944static int SEQ_set(struct mb86a16_state *state, unsigned char loop)
 945{
 946        /* SLOCK0 = 0 */
 947        if (mb86a16_write(state, 0x32, 0x02 | (loop << 2)) < 0) {
 948                dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 949                return -EREMOTEIO;
 950        }
 951
 952        return 0;
 953}
 954
 955static int iq_vt_set(struct mb86a16_state *state, unsigned char IQINV)
 956{
 957        /* Viterbi Rate, IQ Settings */
 958        if (mb86a16_write(state, 0x06, 0xdf | (IQINV << 5)) < 0) {
 959                dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 960                return -EREMOTEIO;
 961        }
 962
 963        return 0;
 964}
 965
 966static int FEC_srst(struct mb86a16_state *state)
 967{
 968        if (mb86a16_write(state, MB86A16_RESET, 0x02) < 0) {
 969                dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 970                return -EREMOTEIO;
 971        }
 972
 973        return 0;
 974}
 975
 976static int S2T_set(struct mb86a16_state *state, unsigned char S2T)
 977{
 978        if (mb86a16_write(state, 0x34, 0x70 | S2T) < 0) {
 979                dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 980                return -EREMOTEIO;
 981        }
 982
 983        return 0;
 984}
 985
 986static int S45T_set(struct mb86a16_state *state, unsigned char S4T, unsigned char S5T)
 987{
 988        if (mb86a16_write(state, 0x35, 0x00 | (S5T << 4) | S4T) < 0) {
 989                dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
 990                return -EREMOTEIO;
 991        }
 992
 993        return 0;
 994}
 995
 996
 997static int mb86a16_set_fe(struct mb86a16_state *state)
 998{
 999        u8 agcval, cnmval;
1000
1001        int i, j;
1002        int fOSC = 0;
1003        int fOSC_start = 0;
1004        int wait_t;
1005        int fcp;
1006        int swp_ofs;
1007        int V[60];
1008        u8 SIG1MIN;
1009
1010        unsigned char CREN, AFCEN, AFCEXEN;
1011        unsigned char SIG1;
1012        unsigned char TIMINT1, TIMINT2, TIMEXT;
1013        unsigned char S0T, S1T;
1014        unsigned char S2T;
1015/*      unsigned char S2T, S3T; */
1016        unsigned char S4T, S5T;
1017        unsigned char AFCEX_L, AFCEX_H;
1018        unsigned char R;
1019        unsigned char VIRM;
1020        unsigned char ETH, VIA;
1021        unsigned char junk;
1022
1023        int loop;
1024        int ftemp;
1025        int v, vmax, vmin;
1026        int vmax_his, vmin_his;
1027        int swp_freq, prev_swp_freq[20];
1028        int prev_freq_num;
1029        int signal_dupl;
1030        int afcex_freq;
1031        int signal;
1032        int afcerr;
1033        int temp_freq, delta_freq;
1034        int dagcm[4];
1035        int smrt_d;
1036/*      int freq_err; */
1037        int n;
1038        int ret = -1;
1039        int sync;
1040
1041        dprintk(verbose, MB86A16_INFO, 1, "freq=%d Mhz, symbrt=%d Ksps", state->frequency, state->srate);
1042
1043        fcp = 3000;
1044        swp_ofs = state->srate / 4;
1045
1046        for (i = 0; i < 60; i++)
1047                V[i] = -1;
1048
1049        for (i = 0; i < 20; i++)
1050                prev_swp_freq[i] = 0;
1051
1052        SIG1MIN = 25;
1053
1054        for (n = 0; ((n < 3) && (ret == -1)); n++) {
1055                SEQ_set(state, 0);
1056                iq_vt_set(state, 0);
1057
1058                CREN = 0;
1059                AFCEN = 0;
1060                AFCEXEN = 1;
1061                TIMINT1 = 0;
1062                TIMINT2 = 1;
1063                TIMEXT = 2;
1064                S1T = 0;
1065                S0T = 0;
1066
1067                if (initial_set(state) < 0) {
1068                        dprintk(verbose, MB86A16_ERROR, 1, "initial set failed");
1069                        return -1;
1070                }
1071                if (DAGC_data_set(state, 3, 2) < 0) {
1072                        dprintk(verbose, MB86A16_ERROR, 1, "DAGC data set error");
1073                        return -1;
1074                }
1075                if (EN_set(state, CREN, AFCEN) < 0) {
1076                        dprintk(verbose, MB86A16_ERROR, 1, "EN set error");
1077                        return -1; /* (0, 0) */
1078                }
1079                if (AFCEXEN_set(state, AFCEXEN, state->srate) < 0) {
1080                        dprintk(verbose, MB86A16_ERROR, 1, "AFCEXEN set error");
1081                        return -1; /* (1, smrt) = (1, symbolrate) */
1082                }
1083                if (CNTM_set(state, TIMINT1, TIMINT2, TIMEXT) < 0) {
1084                        dprintk(verbose, MB86A16_ERROR, 1, "CNTM set error");
1085                        return -1; /* (0, 1, 2) */
1086                }
1087                if (S01T_set(state, S1T, S0T) < 0) {
1088                        dprintk(verbose, MB86A16_ERROR, 1, "S01T set error");
1089                        return -1; /* (0, 0) */
1090                }
1091                smrt_info_get(state, state->srate);
1092                if (smrt_set(state, state->srate) < 0) {
1093                        dprintk(verbose, MB86A16_ERROR, 1, "smrt info get error");
1094                        return -1;
1095                }
1096
1097                R = vco_dev_get(state, state->srate);
1098                if (R == 1)
1099                        fOSC_start = state->frequency;
1100
1101                else if (R == 0) {
1102                        if (state->frequency % 2 == 0) {
1103                                fOSC_start = state->frequency;
1104                        } else {
1105                                fOSC_start = state->frequency + 1;
1106                                if (fOSC_start > 2150)
1107                                        fOSC_start = state->frequency - 1;
1108                        }
1109                }
1110                loop = 1;
1111                ftemp = fOSC_start * 1000;
1112                vmax = 0 ;
1113                while (loop == 1) {
1114                        ftemp = ftemp + swp_ofs;
1115                        vmax++;
1116
1117                        /* Upper bound */
1118                        if (ftemp > 2150000) {
1119                                loop = 0;
1120                                vmax--;
1121                        } else {
1122                                if ((ftemp == 2150000) ||
1123                                    (ftemp - state->frequency * 1000 >= fcp + state->srate / 4))
1124                                        loop = 0;
1125                        }
1126                }
1127
1128                loop = 1;
1129                ftemp = fOSC_start * 1000;
1130                vmin = 0 ;
1131                while (loop == 1) {
1132                        ftemp = ftemp - swp_ofs;
1133                        vmin--;
1134
1135                        /* Lower bound */
1136                        if (ftemp < 950000) {
1137                                loop = 0;
1138                                vmin++;
1139                        } else {
1140                                if ((ftemp == 950000) ||
1141                                    (state->frequency * 1000 - ftemp >= fcp + state->srate / 4))
1142                                        loop = 0;
1143                        }
1144                }
1145
1146                wait_t = (8000 + state->srate / 2) / state->srate;
1147                if (wait_t == 0)
1148                        wait_t = 1;
1149
1150                i = 0;
1151                j = 0;
1152                prev_freq_num = 0;
1153                loop = 1;
1154                signal = 0;
1155                vmax_his = 0;
1156                vmin_his = 0;
1157                v = 0;
1158
1159                while (loop == 1) {
1160                        swp_info_get(state, fOSC_start, state->srate,
1161                                     v, R, swp_ofs, &fOSC,
1162                                     &afcex_freq, &AFCEX_L, &AFCEX_H);
1163
1164                        udelay(100);
1165                        if (rf_val_set(state, fOSC, state->srate, R) < 0) {
1166                                dprintk(verbose, MB86A16_ERROR, 1, "rf val set error");
1167                                return -1;
1168                        }
1169                        udelay(100);
1170                        if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1171                                dprintk(verbose, MB86A16_ERROR, 1, "afcex data set error");
1172                                return -1;
1173                        }
1174                        if (srst(state) < 0) {
1175                                dprintk(verbose, MB86A16_ERROR, 1, "srst error");
1176                                return -1;
1177                        }
1178                        msleep_interruptible(wait_t);
1179
1180                        if (mb86a16_read(state, 0x37, &SIG1) != 2) {
1181                                dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1182                                return -1;
1183                        }
1184                        V[30 + v] = SIG1 ;
1185                        swp_freq = swp_freq_calcuation(state, i, v, V, vmax, vmin,
1186                                                      SIG1MIN, fOSC, afcex_freq,
1187                                                      swp_ofs, &SIG1);  /* changed */
1188
1189                        signal_dupl = 0;
1190                        for (j = 0; j < prev_freq_num; j++) {
1191                                if ((abs(prev_swp_freq[j] - swp_freq)) < (swp_ofs * 3 / 2)) {
1192                                        signal_dupl = 1;
1193                                        dprintk(verbose, MB86A16_INFO, 1, "Probably Duplicate Signal, j = %d", j);
1194                                }
1195                        }
1196                        if ((signal_dupl == 0) && (swp_freq > 0) && (abs(swp_freq - state->frequency * 1000) < fcp + state->srate / 6)) {
1197                                dprintk(verbose, MB86A16_DEBUG, 1, "------ Signal detect ------ [swp_freq=[%07d, srate=%05d]]", swp_freq, state->srate);
1198                                prev_swp_freq[prev_freq_num] = swp_freq;
1199                                prev_freq_num++;
1200                                swp_info_get2(state, state->srate, R, swp_freq,
1201                                              &afcex_freq, &fOSC,
1202                                              &AFCEX_L, &AFCEX_H);
1203
1204                                if (rf_val_set(state, fOSC, state->srate, R) < 0) {
1205                                        dprintk(verbose, MB86A16_ERROR, 1, "rf val set error");
1206                                        return -1;
1207                                }
1208                                if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1209                                        dprintk(verbose, MB86A16_ERROR, 1, "afcex data set error");
1210                                        return -1;
1211                                }
1212                                signal = signal_det(state, state->srate, &SIG1);
1213                                if (signal == 1) {
1214                                        dprintk(verbose, MB86A16_ERROR, 1, "***** Signal Found *****");
1215                                        loop = 0;
1216                                } else {
1217                                        dprintk(verbose, MB86A16_ERROR, 1, "!!!!! No signal !!!!!, try again...");
1218                                        smrt_info_get(state, state->srate);
1219                                        if (smrt_set(state, state->srate) < 0) {
1220                                                dprintk(verbose, MB86A16_ERROR, 1, "smrt set error");
1221                                                return -1;
1222                                        }
1223                                }
1224                        }
1225                        if (v > vmax)
1226                                vmax_his = 1 ;
1227                        if (v < vmin)
1228                                vmin_his = 1 ;
1229                        i++;
1230
1231                        if ((i % 2 == 1) && (vmax_his == 1))
1232                                i++;
1233                        if ((i % 2 == 0) && (vmin_his == 1))
1234                                i++;
1235
1236                        if (i % 2 == 1)
1237                                v = (i + 1) / 2;
1238                        else
1239                                v = -i / 2;
1240
1241                        if ((vmax_his == 1) && (vmin_his == 1))
1242                                loop = 0 ;
1243                }
1244
1245                if (signal == 1) {
1246                        dprintk(verbose, MB86A16_INFO, 1, " Start Freq Error Check");
1247                        S1T = 7 ;
1248                        S0T = 1 ;
1249                        CREN = 0 ;
1250                        AFCEN = 1 ;
1251                        AFCEXEN = 0 ;
1252
1253                        if (S01T_set(state, S1T, S0T) < 0) {
1254                                dprintk(verbose, MB86A16_ERROR, 1, "S01T set error");
1255                                return -1;
1256                        }
1257                        smrt_info_get(state, state->srate);
1258                        if (smrt_set(state, state->srate) < 0) {
1259                                dprintk(verbose, MB86A16_ERROR, 1, "smrt set error");
1260                                return -1;
1261                        }
1262                        if (EN_set(state, CREN, AFCEN) < 0) {
1263                                dprintk(verbose, MB86A16_ERROR, 1, "EN set error");
1264                                return -1;
1265                        }
1266                        if (AFCEXEN_set(state, AFCEXEN, state->srate) < 0) {
1267                                dprintk(verbose, MB86A16_ERROR, 1, "AFCEXEN set error");
1268                                return -1;
1269                        }
1270                        afcex_info_get(state, afcex_freq, &AFCEX_L, &AFCEX_H);
1271                        if (afcofs_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1272                                dprintk(verbose, MB86A16_ERROR, 1, "AFCOFS data set error");
1273                                return -1;
1274                        }
1275                        if (srst(state) < 0) {
1276                                dprintk(verbose, MB86A16_ERROR, 1, "srst error");
1277                                return -1;
1278                        }
1279                        /* delay 4~200 */
1280                        wait_t = 200000 / state->master_clk + 200000 / state->srate;
1281                        msleep(wait_t);
1282                        afcerr = afcerr_chk(state);
1283                        if (afcerr == -1)
1284                                return -1;
1285
1286                        swp_freq = fOSC * 1000 + afcerr ;
1287                        AFCEXEN = 1 ;
1288                        if (state->srate >= 1500)
1289                                smrt_d = state->srate / 3;
1290                        else
1291                                smrt_d = state->srate / 2;
1292                        smrt_info_get(state, smrt_d);
1293                        if (smrt_set(state, smrt_d) < 0) {
1294                                dprintk(verbose, MB86A16_ERROR, 1, "smrt set error");
1295                                return -1;
1296                        }
1297                        if (AFCEXEN_set(state, AFCEXEN, smrt_d) < 0) {
1298                                dprintk(verbose, MB86A16_ERROR, 1, "AFCEXEN set error");
1299                                return -1;
1300                        }
1301                        R = vco_dev_get(state, smrt_d);
1302                        if (DAGC_data_set(state, 2, 0) < 0) {
1303                                dprintk(verbose, MB86A16_ERROR, 1, "DAGC data set error");
1304                                return -1;
1305                        }
1306                        for (i = 0; i < 3; i++) {
1307                                temp_freq = swp_freq + (i - 1) * state->srate / 8;
1308                                swp_info_get2(state, smrt_d, R, temp_freq, &afcex_freq, &fOSC, &AFCEX_L, &AFCEX_H);
1309                                if (rf_val_set(state, fOSC, smrt_d, R) < 0) {
1310                                        dprintk(verbose, MB86A16_ERROR, 1, "rf val set error");
1311                                        return -1;
1312                                }
1313                                if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1314                                        dprintk(verbose, MB86A16_ERROR, 1, "afcex data set error");
1315                                        return -1;
1316                                }
1317                                wait_t = 200000 / state->master_clk + 40000 / smrt_d;
1318                                msleep(wait_t);
1319                                dagcm[i] = dagcm_val_get(state);
1320                        }
1321                        if ((dagcm[0] > dagcm[1]) &&
1322                            (dagcm[0] > dagcm[2]) &&
1323                            (dagcm[0] - dagcm[1] > 2 * (dagcm[2] - dagcm[1]))) {
1324
1325                                temp_freq = swp_freq - 2 * state->srate / 8;
1326                                swp_info_get2(state, smrt_d, R, temp_freq, &afcex_freq, &fOSC, &AFCEX_L, &AFCEX_H);
1327                                if (rf_val_set(state, fOSC, smrt_d, R) < 0) {
1328                                        dprintk(verbose, MB86A16_ERROR, 1, "rf val set error");
1329                                        return -1;
1330                                }
1331                                if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1332                                        dprintk(verbose, MB86A16_ERROR, 1, "afcex data set");
1333                                        return -1;
1334                                }
1335                                wait_t = 200000 / state->master_clk + 40000 / smrt_d;
1336                                msleep(wait_t);
1337                                dagcm[3] = dagcm_val_get(state);
1338                                if (dagcm[3] > dagcm[1])
1339                                        delta_freq = (dagcm[2] - dagcm[0] + dagcm[1] - dagcm[3]) * state->srate / 300;
1340                                else
1341                                        delta_freq = 0;
1342                        } else if ((dagcm[2] > dagcm[1]) &&
1343                                   (dagcm[2] > dagcm[0]) &&
1344                                   (dagcm[2] - dagcm[1] > 2 * (dagcm[0] - dagcm[1]))) {
1345
1346                                temp_freq = swp_freq + 2 * state->srate / 8;
1347                                swp_info_get2(state, smrt_d, R, temp_freq, &afcex_freq, &fOSC, &AFCEX_L, &AFCEX_H);
1348                                if (rf_val_set(state, fOSC, smrt_d, R) < 0) {
1349                                        dprintk(verbose, MB86A16_ERROR, 1, "rf val set");
1350                                        return -1;
1351                                }
1352                                if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1353                                        dprintk(verbose, MB86A16_ERROR, 1, "afcex data set");
1354                                        return -1;
1355                                }
1356                                wait_t = 200000 / state->master_clk + 40000 / smrt_d;
1357                                msleep(wait_t);
1358                                dagcm[3] = dagcm_val_get(state);
1359                                if (dagcm[3] > dagcm[1])
1360                                        delta_freq = (dagcm[2] - dagcm[0] + dagcm[3] - dagcm[1]) * state->srate / 300;
1361                                else
1362                                        delta_freq = 0 ;
1363
1364                        } else {
1365                                delta_freq = 0 ;
1366                        }
1367                        dprintk(verbose, MB86A16_INFO, 1, "SWEEP Frequency = %d", swp_freq);
1368                        swp_freq += delta_freq;
1369                        dprintk(verbose, MB86A16_INFO, 1, "Adjusting .., DELTA Freq = %d, SWEEP Freq=%d", delta_freq, swp_freq);
1370                        if (abs(state->frequency * 1000 - swp_freq) > 3800) {
1371                                dprintk(verbose, MB86A16_INFO, 1, "NO  --  SIGNAL !");
1372                        } else {
1373
1374                                S1T = 0;
1375                                S0T = 3;
1376                                CREN = 1;
1377                                AFCEN = 0;
1378                                AFCEXEN = 1;
1379
1380                                if (S01T_set(state, S1T, S0T) < 0) {
1381                                        dprintk(verbose, MB86A16_ERROR, 1, "S01T set error");
1382                                        return -1;
1383                                }
1384                                if (DAGC_data_set(state, 0, 0) < 0) {
1385                                        dprintk(verbose, MB86A16_ERROR, 1, "DAGC data set error");
1386                                        return -1;
1387                                }
1388                                R = vco_dev_get(state, state->srate);
1389                                smrt_info_get(state, state->srate);
1390                                if (smrt_set(state, state->srate) < 0) {
1391                                        dprintk(verbose, MB86A16_ERROR, 1, "smrt set error");
1392                                        return -1;
1393                                }
1394                                if (EN_set(state, CREN, AFCEN) < 0) {
1395                                        dprintk(verbose, MB86A16_ERROR, 1, "EN set error");
1396                                        return -1;
1397                                }
1398                                if (AFCEXEN_set(state, AFCEXEN, state->srate) < 0) {
1399                                        dprintk(verbose, MB86A16_ERROR, 1, "AFCEXEN set error");
1400                                        return -1;
1401                                }
1402                                swp_info_get2(state, state->srate, R, swp_freq, &afcex_freq, &fOSC, &AFCEX_L, &AFCEX_H);
1403                                if (rf_val_set(state, fOSC, state->srate, R) < 0) {
1404                                        dprintk(verbose, MB86A16_ERROR, 1, "rf val set error");
1405                                        return -1;
1406                                }
1407                                if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1408                                        dprintk(verbose, MB86A16_ERROR, 1, "afcex data set error");
1409                                        return -1;
1410                                }
1411                                if (srst(state) < 0) {
1412                                        dprintk(verbose, MB86A16_ERROR, 1, "srst error");
1413                                        return -1;
1414                                }
1415                                wait_t = 7 + (10000 + state->srate / 2) / state->srate;
1416                                if (wait_t == 0)
1417                                        wait_t = 1;
1418                                msleep_interruptible(wait_t);
1419                                if (mb86a16_read(state, 0x37, &SIG1) != 2) {
1420                                        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1421                                        return -EREMOTEIO;
1422                                }
1423
1424                                if (SIG1 > 110) {
1425                                        S2T = 4; S4T = 1; S5T = 6; ETH = 4; VIA = 6;
1426                                        wait_t = 7 + (917504 + state->srate / 2) / state->srate;
1427                                } else if (SIG1 > 105) {
1428                                        S2T = 4; S4T = 2; S5T = 8; ETH = 7; VIA = 2;
1429                                        wait_t = 7 + (1048576 + state->srate / 2) / state->srate;
1430                                } else if (SIG1 > 85) {
1431                                        S2T = 5; S4T = 2; S5T = 8; ETH = 7; VIA = 2;
1432                                        wait_t = 7 + (1310720 + state->srate / 2) / state->srate;
1433                                } else if (SIG1 > 65) {
1434                                        S2T = 6; S4T = 2; S5T = 8; ETH = 7; VIA = 2;
1435                                        wait_t = 7 + (1572864 + state->srate / 2) / state->srate;
1436                                } else {
1437                                        S2T = 7; S4T = 2; S5T = 8; ETH = 7; VIA = 2;
1438                                        wait_t = 7 + (2097152 + state->srate / 2) / state->srate;
1439                                }
1440                                wait_t *= 2; /* FOS */
1441                                S2T_set(state, S2T);
1442                                S45T_set(state, S4T, S5T);
1443                                Vi_set(state, ETH, VIA);
1444                                srst(state);
1445                                msleep_interruptible(wait_t);
1446                                sync = sync_chk(state, &VIRM);
1447                                dprintk(verbose, MB86A16_INFO, 1, "-------- Viterbi=[%d] SYNC=[%d] ---------", VIRM, sync);
1448                                if (VIRM) {
1449                                        if (VIRM == 4) {
1450                                                /* 5/6 */
1451                                                if (SIG1 > 110)
1452                                                        wait_t = (786432 + state->srate / 2) / state->srate;
1453                                                else
1454                                                        wait_t = (1572864 + state->srate / 2) / state->srate;
1455                                                if (state->srate < 5000)
1456                                                        /* FIXME ! , should be a long wait ! */
1457                                                        msleep_interruptible(wait_t);
1458                                                else
1459                                                        msleep_interruptible(wait_t);
1460
1461                                                if (sync_chk(state, &junk) == 0) {
1462                                                        iq_vt_set(state, 1);
1463                                                        FEC_srst(state);
1464                                                }
1465                                        }
1466                                        /* 1/2, 2/3, 3/4, 7/8 */
1467                                        if (SIG1 > 110)
1468                                                wait_t = (786432 + state->srate / 2) / state->srate;
1469                                        else
1470                                                wait_t = (1572864 + state->srate / 2) / state->srate;
1471                                        msleep_interruptible(wait_t);
1472                                        SEQ_set(state, 1);
1473                                } else {
1474                                        dprintk(verbose, MB86A16_INFO, 1, "NO  -- SYNC");
1475                                        SEQ_set(state, 1);
1476                                        ret = -1;
1477                                }
1478                        }
1479                } else {
1480                        dprintk(verbose, MB86A16_INFO, 1, "NO  -- SIGNAL");
1481                        ret = -1;
1482                }
1483
1484                sync = sync_chk(state, &junk);
1485                if (sync) {
1486                        dprintk(verbose, MB86A16_INFO, 1, "******* SYNC *******");
1487                        freqerr_chk(state, state->frequency, state->srate, 1);
1488                        ret = 0;
1489                        break;
1490                }
1491        }
1492
1493        mb86a16_read(state, 0x15, &agcval);
1494        mb86a16_read(state, 0x26, &cnmval);
1495        dprintk(verbose, MB86A16_INFO, 1, "AGC = %02x CNM = %02x", agcval, cnmval);
1496
1497        return ret;
1498}
1499
1500static int mb86a16_send_diseqc_msg(struct dvb_frontend *fe,
1501                                   struct dvb_diseqc_master_cmd *cmd)
1502{
1503        struct mb86a16_state *state = fe->demodulator_priv;
1504        int i;
1505        u8 regs;
1506
1507        if (mb86a16_write(state, MB86A16_DCC1, MB86A16_DCC1_DISTA) < 0)
1508                goto err;
1509        if (mb86a16_write(state, MB86A16_DCCOUT, 0x00) < 0)
1510                goto err;
1511        if (mb86a16_write(state, MB86A16_TONEOUT2, 0x04) < 0)
1512                goto err;
1513
1514        regs = 0x18;
1515
1516        if (cmd->msg_len > 5 || cmd->msg_len < 4)
1517                return -EINVAL;
1518
1519        for (i = 0; i < cmd->msg_len; i++) {
1520                if (mb86a16_write(state, regs, cmd->msg[i]) < 0)
1521                        goto err;
1522
1523                regs++;
1524        }
1525        i += 0x90;
1526
1527        msleep_interruptible(10);
1528
1529        if (mb86a16_write(state, MB86A16_DCC1, i) < 0)
1530                goto err;
1531        if (mb86a16_write(state, MB86A16_DCCOUT, MB86A16_DCCOUT_DISEN) < 0)
1532                goto err;
1533
1534        return 0;
1535
1536err:
1537        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1538        return -EREMOTEIO;
1539}
1540
1541static int mb86a16_send_diseqc_burst(struct dvb_frontend *fe,
1542                                     enum fe_sec_mini_cmd burst)
1543{
1544        struct mb86a16_state *state = fe->demodulator_priv;
1545
1546        switch (burst) {
1547        case SEC_MINI_A:
1548                if (mb86a16_write(state, MB86A16_DCC1, MB86A16_DCC1_DISTA |
1549                                                       MB86A16_DCC1_TBEN  |
1550                                                       MB86A16_DCC1_TBO) < 0)
1551                        goto err;
1552                if (mb86a16_write(state, MB86A16_DCCOUT, MB86A16_DCCOUT_DISEN) < 0)
1553                        goto err;
1554                break;
1555        case SEC_MINI_B:
1556                if (mb86a16_write(state, MB86A16_DCC1, MB86A16_DCC1_DISTA |
1557                                                       MB86A16_DCC1_TBEN) < 0)
1558                        goto err;
1559                if (mb86a16_write(state, MB86A16_DCCOUT, MB86A16_DCCOUT_DISEN) < 0)
1560                        goto err;
1561                break;
1562        }
1563
1564        return 0;
1565err:
1566        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1567        return -EREMOTEIO;
1568}
1569
1570static int mb86a16_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone)
1571{
1572        struct mb86a16_state *state = fe->demodulator_priv;
1573
1574        switch (tone) {
1575        case SEC_TONE_ON:
1576                if (mb86a16_write(state, MB86A16_TONEOUT2, 0x00) < 0)
1577                        goto err;
1578                if (mb86a16_write(state, MB86A16_DCC1, MB86A16_DCC1_DISTA |
1579                                                       MB86A16_DCC1_CTOE) < 0)
1580
1581                        goto err;
1582                if (mb86a16_write(state, MB86A16_DCCOUT, MB86A16_DCCOUT_DISEN) < 0)
1583                        goto err;
1584                break;
1585        case SEC_TONE_OFF:
1586                if (mb86a16_write(state, MB86A16_TONEOUT2, 0x04) < 0)
1587                        goto err;
1588                if (mb86a16_write(state, MB86A16_DCC1, MB86A16_DCC1_DISTA) < 0)
1589                        goto err;
1590                if (mb86a16_write(state, MB86A16_DCCOUT, 0x00) < 0)
1591                        goto err;
1592                break;
1593        default:
1594                return -EINVAL;
1595        }
1596        return 0;
1597
1598err:
1599        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1600        return -EREMOTEIO;
1601}
1602
1603static enum dvbfe_search mb86a16_search(struct dvb_frontend *fe)
1604{
1605        struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1606        struct mb86a16_state *state = fe->demodulator_priv;
1607
1608        state->frequency = p->frequency / 1000;
1609        state->srate = p->symbol_rate / 1000;
1610
1611        if (!mb86a16_set_fe(state)) {
1612                dprintk(verbose, MB86A16_ERROR, 1, "Successfully acquired LOCK");
1613                return DVBFE_ALGO_SEARCH_SUCCESS;
1614        }
1615
1616        dprintk(verbose, MB86A16_ERROR, 1, "Lock acquisition failed!");
1617        return DVBFE_ALGO_SEARCH_FAILED;
1618}
1619
1620static void mb86a16_release(struct dvb_frontend *fe)
1621{
1622        struct mb86a16_state *state = fe->demodulator_priv;
1623        kfree(state);
1624}
1625
1626static int mb86a16_init(struct dvb_frontend *fe)
1627{
1628        return 0;
1629}
1630
1631static int mb86a16_sleep(struct dvb_frontend *fe)
1632{
1633        return 0;
1634}
1635
1636static int mb86a16_read_ber(struct dvb_frontend *fe, u32 *ber)
1637{
1638        u8 ber_mon, ber_tab, ber_lsb, ber_mid, ber_msb, ber_tim, ber_rst;
1639        u32 timer;
1640
1641        struct mb86a16_state *state = fe->demodulator_priv;
1642
1643        *ber = 0;
1644        if (mb86a16_read(state, MB86A16_BERMON, &ber_mon) != 2)
1645                goto err;
1646        if (mb86a16_read(state, MB86A16_BERTAB, &ber_tab) != 2)
1647                goto err;
1648        if (mb86a16_read(state, MB86A16_BERLSB, &ber_lsb) != 2)
1649                goto err;
1650        if (mb86a16_read(state, MB86A16_BERMID, &ber_mid) != 2)
1651                goto err;
1652        if (mb86a16_read(state, MB86A16_BERMSB, &ber_msb) != 2)
1653                goto err;
1654        /* BER monitor invalid when BER_EN = 0  */
1655        if (ber_mon & 0x04) {
1656                /* coarse, fast calculation     */
1657                *ber = ber_tab & 0x1f;
1658                dprintk(verbose, MB86A16_DEBUG, 1, "BER coarse=[0x%02x]", *ber);
1659                if (ber_mon & 0x01) {
1660                        /*
1661                         * BER_SEL = 1, The monitored BER is the estimated
1662                         * value with a Reed-Solomon decoder error amount at
1663                         * the deinterleaver output.
1664                         * monitored BER is expressed as a 20 bit output in total
1665                         */
1666                        ber_rst = (ber_mon >> 3) & 0x03;
1667                        *ber = (((ber_msb << 8) | ber_mid) << 8) | ber_lsb;
1668                        if (ber_rst == 0)
1669                                timer =  12500000;
1670                        else if (ber_rst == 1)
1671                                timer =  25000000;
1672                        else if (ber_rst == 2)
1673                                timer =  50000000;
1674                        else /* ber_rst == 3 */
1675                                timer = 100000000;
1676
1677                        *ber /= timer;
1678                        dprintk(verbose, MB86A16_DEBUG, 1, "BER fine=[0x%02x]", *ber);
1679                } else {
1680                        /*
1681                         * BER_SEL = 0, The monitored BER is the estimated
1682                         * value with a Viterbi decoder error amount at the
1683                         * QPSK demodulator output.
1684                         * monitored BER is expressed as a 24 bit output in total
1685                         */
1686                        ber_tim = (ber_mon >> 1) & 0x01;
1687                        *ber = (((ber_msb << 8) | ber_mid) << 8) | ber_lsb;
1688                        if (ber_tim == 0)
1689                                timer = 16;
1690                        else /* ber_tim == 1 */
1691                                timer = 24;
1692
1693                        *ber /= 2 ^ timer;
1694                        dprintk(verbose, MB86A16_DEBUG, 1, "BER fine=[0x%02x]", *ber);
1695                }
1696        }
1697        return 0;
1698err:
1699        dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1700        return -EREMOTEIO;
1701}
1702
1703static int mb86a16_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
1704{
1705        u8 agcm = 0;
1706        struct mb86a16_state *state = fe->demodulator_priv;
1707
1708        *strength = 0;
1709        if (mb86a16_read(state, MB86A16_AGCM, &agcm) != 2) {
1710                dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1711                return -EREMOTEIO;
1712        }
1713
1714        *strength = ((0xff - agcm) * 100) / 256;
1715        dprintk(verbose, MB86A16_DEBUG, 1, "Signal strength=[%d %%]", (u8) *strength);
1716        *strength = (0xffff - 0xff) + agcm;
1717
1718        return 0;
1719}
1720
1721struct cnr {
1722        u8 cn_reg;
1723        u8 cn_val;
1724};
1725
1726static const struct cnr cnr_tab[] = {
1727        {  35,  2 },
1728        {  40,  3 },
1729        {  50,  4 },
1730        {  60,  5 },
1731        {  70,  6 },
1732        {  80,  7 },
1733        {  92,  8 },
1734        { 103,  9 },
1735        { 115, 10 },
1736        { 138, 12 },
1737        { 162, 15 },
1738        { 180, 18 },
1739        { 185, 19 },
1740        { 189, 20 },
1741        { 195, 22 },
1742        { 199, 24 },
1743        { 201, 25 },
1744        { 202, 26 },
1745        { 203, 27 },
1746        { 205, 28 },
1747        { 208, 30 }
1748};
1749
1750static int mb86a16_read_snr(struct dvb_frontend *fe, u16 *snr)
1751{
1752        struct mb86a16_state *state = fe->demodulator_priv;
1753        int i = 0;
1754        int low_tide = 2, high_tide = 30, q_level;
1755        u8  cn;
1756
1757        *snr = 0;
1758        if (mb86a16_read(state, 0x26, &cn) != 2) {
1759                dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1760                return -EREMOTEIO;
1761        }
1762
1763        for (i = 0; i < ARRAY_SIZE(cnr_tab); i++) {
1764                if (cn < cnr_tab[i].cn_reg) {
1765                        *snr = cnr_tab[i].cn_val;
1766                        break;
1767                }
1768        }
1769        q_level = (*snr * 100) / (high_tide - low_tide);
1770        dprintk(verbose, MB86A16_ERROR, 1, "SNR (Quality) = [%d dB], Level=%d %%", *snr, q_level);
1771        *snr = (0xffff - 0xff) + *snr;
1772
1773        return 0;
1774}
1775
1776static int mb86a16_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1777{
1778        u8 dist;
1779        struct mb86a16_state *state = fe->demodulator_priv;
1780
1781        if (mb86a16_read(state, MB86A16_DISTMON, &dist) != 2) {
1782                dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1783                return -EREMOTEIO;
1784        }
1785        *ucblocks = dist;
1786
1787        return 0;
1788}
1789
1790static enum dvbfe_algo mb86a16_frontend_algo(struct dvb_frontend *fe)
1791{
1792        return DVBFE_ALGO_CUSTOM;
1793}
1794
1795static const struct dvb_frontend_ops mb86a16_ops = {
1796        .delsys = { SYS_DVBS },
1797        .info = {
1798                .name                   = "Fujitsu MB86A16 DVB-S",
1799                .frequency_min_hz       =  950 * MHz,
1800                .frequency_max_hz       = 2150 * MHz,
1801                .frequency_stepsize_hz  =    3 * MHz,
1802                .symbol_rate_min        = 1000000,
1803                .symbol_rate_max        = 45000000,
1804                .symbol_rate_tolerance  = 500,
1805                .caps                   = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
1806                                          FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 |
1807                                          FE_CAN_FEC_7_8 | FE_CAN_QPSK    |
1808                                          FE_CAN_FEC_AUTO
1809        },
1810        .release                        = mb86a16_release,
1811
1812        .get_frontend_algo              = mb86a16_frontend_algo,
1813        .search                         = mb86a16_search,
1814        .init                           = mb86a16_init,
1815        .sleep                          = mb86a16_sleep,
1816        .read_status                    = mb86a16_read_status,
1817
1818        .read_ber                       = mb86a16_read_ber,
1819        .read_signal_strength           = mb86a16_read_signal_strength,
1820        .read_snr                       = mb86a16_read_snr,
1821        .read_ucblocks                  = mb86a16_read_ucblocks,
1822
1823        .diseqc_send_master_cmd         = mb86a16_send_diseqc_msg,
1824        .diseqc_send_burst              = mb86a16_send_diseqc_burst,
1825        .set_tone                       = mb86a16_set_tone,
1826};
1827
1828struct dvb_frontend *mb86a16_attach(const struct mb86a16_config *config,
1829                                    struct i2c_adapter *i2c_adap)
1830{
1831        u8 dev_id = 0;
1832        struct mb86a16_state *state = NULL;
1833
1834        state = kmalloc(sizeof(struct mb86a16_state), GFP_KERNEL);
1835        if (state == NULL)
1836                goto error;
1837
1838        state->config = config;
1839        state->i2c_adap = i2c_adap;
1840
1841        mb86a16_read(state, 0x7f, &dev_id);
1842        if (dev_id != 0xfe)
1843                goto error;
1844
1845        memcpy(&state->frontend.ops, &mb86a16_ops, sizeof(struct dvb_frontend_ops));
1846        state->frontend.demodulator_priv = state;
1847        state->frontend.ops.set_voltage = state->config->set_voltage;
1848
1849        return &state->frontend;
1850error:
1851        kfree(state);
1852        return NULL;
1853}
1854EXPORT_SYMBOL(mb86a16_attach);
1855MODULE_LICENSE("GPL");
1856MODULE_AUTHOR("Manu Abraham");
1857