drivers/media/pci/bt8xx/dst.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3         Frontend/Card driver for TwinHan DST Frontend
   4         Copyright (C) 2003 Jamie Honan
   5         Copyright (C) 2004, 2005 Manu Abraham (manu@kromtek.com)
   6
   7 */
   8
   9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/string.h>
  15 #include <linux/slab.h>
  16 #include <linux/vmalloc.h>
  17 #include <linux/delay.h>
  18 #include <asm/div64.h>
  19 #include <media/dvb_frontend.h>
  20 #include "dst_priv.h"
  21 #include "dst_common.h"
  22
  23 static unsigned int verbose;
  24 module_param(verbose, int, 0644);
  25 MODULE_PARM_DESC(verbose, "verbosity level (0 to 3)");
  26
  27 static unsigned int dst_addons;
  28 module_param(dst_addons, int, 0644);
  29 MODULE_PARM_DESC(dst_addons, "CA daughterboard, default is 0 (No addons)");
  30
  31 static unsigned int dst_algo;
  32 module_param(dst_algo, int, 0644);
  33 MODULE_PARM_DESC(dst_algo, "tuning algo: default is 0=(SW), 1=(HW)");
  34
  35 #define HAS_LOCK                1
  36 #define ATTEMPT_TUNE            2
  37 #define HAS_POWER               4
  38
  39 #define dprintk(level, fmt, arg...) do {                                \
  40         if (level >= verbose)                                           \
  41                 printk(KERN_DEBUG pr_fmt("%s: " fmt),                   \
  42                        __func__, ##arg);                                \
  43 } while(0)
  44
  45 static int dst_command(struct dst_state *state, u8 *data, u8 len);
  46
  47 static void dst_packsize(struct dst_state *state, int psize)
  48 {
  49         union dst_gpio_packet bits;
  50
  51         bits.psize = psize;
  52         bt878_device_control(state->bt, DST_IG_TS, &bits);
  53 }
  54
  55 static int dst_gpio_outb(struct dst_state *state, u32 mask, u32 enbb,
  56                          u32 outhigh, int delay)
  57 {
  58         union dst_gpio_packet enb;
  59         union dst_gpio_packet bits;
  60         int err;
  61
  62         enb.enb.mask = mask;
  63         enb.enb.enable = enbb;
  64
  65         dprintk(2, "mask=[%04x], enbb=[%04x], outhigh=[%04x]\n",
  66                 mask, enbb, outhigh);
  67         if ((err = bt878_device_control(state->bt, DST_IG_ENABLE, &enb)) < 0) {
  68                 dprintk(2, "dst_gpio_enb error (err == %i, mask == %02x, enb == %02x)\n",
  69                         err, mask, enbb);
  70                 return -EREMOTEIO;
  71         }
  72         udelay(1000);
  73         /* because complete disabling means no output, no need to do output packet */
  74         if (enbb == 0)
  75                 return 0;
  76         if (delay)
  77                 msleep(10);
  78         bits.outp.mask = enbb;
  79         bits.outp.highvals = outhigh;
  80         if ((err = bt878_device_control(state->bt, DST_IG_WRITE, &bits)) < 0) {
  81                 dprintk(2, "dst_gpio_outb error (err == %i, enbb == %02x, outhigh == %02x)\n",
  82                         err, enbb, outhigh);
  83                 return -EREMOTEIO;
  84         }
  85
  86         return 0;
  87 }
  88
  89 static int dst_gpio_inb(struct dst_state *state, u8 *result)
  90 {
  91         union dst_gpio_packet rd_packet;
  92         int err;
  93
  94         *result = 0;
  95         if ((err = bt878_device_control(state->bt, DST_IG_READ, &rd_packet)) < 0) {
  96                 pr_err("dst_gpio_inb error (err == %i)\n", err);
  97                 return -EREMOTEIO;
  98         }
  99         *result = (u8) rd_packet.rd.value;
 100
 101         return 0;
 102 }
 103
 104 int rdc_reset_state(struct dst_state *state)
 105 {
 106         dprintk(2, "Resetting state machine\n");
 107         if (dst_gpio_outb(state, RDC_8820_INT, RDC_8820_INT, 0, NO_DELAY) < 0) {
 108                 pr_err("dst_gpio_outb ERROR !\n");
 109                 return -1;
 110         }
 111         msleep(10);
 112         if (dst_gpio_outb(state, RDC_8820_INT, RDC_8820_INT, RDC_8820_INT, NO_DELAY) < 0) {
 113                 pr_err("dst_gpio_outb ERROR !\n");
 114                 msleep(10);
 115                 return -1;
 116         }
 117
 118         return 0;
 119 }
 120 EXPORT_SYMBOL(rdc_reset_state);
 121
 122 static int rdc_8820_reset(struct dst_state *state)
 123 {
 124         dprintk(3, "Resetting DST\n");
 125         if (dst_gpio_outb(state, RDC_8820_RESET, RDC_8820_RESET, 0, NO_DELAY) < 0) {
 126                 pr_err("dst_gpio_outb ERROR !\n");
 127                 return -1;
 128         }
 129         udelay(1000);
 130         if (dst_gpio_outb(state, RDC_8820_RESET, RDC_8820_RESET, RDC_8820_RESET, DELAY) < 0) {
 131                 pr_err("dst_gpio_outb ERROR !\n");
 132                 return -1;
 133         }
 134
 135         return 0;
 136 }
 137
 138 static int dst_pio_enable(struct dst_state *state)
 139 {
 140         if (dst_gpio_outb(state, ~0, RDC_8820_PIO_0_ENABLE, 0, NO_DELAY) < 0) {
 141                 pr_err("dst_gpio_outb ERROR !\n");
 142                 return -1;
 143         }
 144         udelay(1000);
 145
 146         return 0;
 147 }
 148
 149 int dst_pio_disable(struct dst_state *state)
 150 {
 151         if (dst_gpio_outb(state, ~0, RDC_8820_PIO_0_DISABLE, RDC_8820_PIO_0_DISABLE, NO_DELAY) < 0) {
 152                 pr_err("dst_gpio_outb ERROR !\n");
 153                 return -1;
 154         }
 155         if (state->type_flags & DST_TYPE_HAS_FW_1)
 156                 udelay(1000);
 157
 158         return 0;
 159 }
 160 EXPORT_SYMBOL(dst_pio_disable);
 161
 162 int dst_wait_dst_ready(struct dst_state *state, u8 delay_mode)
 163 {
 164         u8 reply;
 165         int i;
 166
 167         for (i = 0; i < 200; i++) {
 168                 if (dst_gpio_inb(state, &reply) < 0) {
 169                         pr_err("dst_gpio_inb ERROR !\n");
 170                         return -1;
 171                 }
 172                 if ((reply & RDC_8820_PIO_0_ENABLE) == 0) {
 173                         dprintk(2, "dst wait ready after %d\n", i);
 174                         return 1;
 175                 }
 176                 msleep(10);
 177         }
 178         dprintk(1, "dst wait NOT ready after %d\n", i);
 179
 180         return 0;
 181 }
 182 EXPORT_SYMBOL(dst_wait_dst_ready);
 183
 184 int dst_error_recovery(struct dst_state *state)
 185 {
 186         dprintk(1, "Trying to return from previous errors.\n");
 187         dst_pio_disable(state);
 188         msleep(10);
 189         dst_pio_enable(state);
 190         msleep(10);
 191
 192         return 0;
 193 }
 194 EXPORT_SYMBOL(dst_error_recovery);
 195
 196 int dst_error_bailout(struct dst_state *state)
 197 {
 198         dprintk(2, "Trying to bailout from previous error.\n");
 199         rdc_8820_reset(state);
 200         dst_pio_disable(state);
 201         msleep(10);
 202
 203         return 0;
 204 }
 205 EXPORT_SYMBOL(dst_error_bailout);
 206
 207 int dst_comm_init(struct dst_state *state)
 208 {
 209         dprintk(2, "Initializing DST.\n");
 210         if ((dst_pio_enable(state)) < 0) {
 211                 pr_err("PIO Enable Failed\n");
 212                 return -1;
 213         }
 214         if ((rdc_reset_state(state)) < 0) {
 215                 pr_err("RDC 8820 State RESET Failed.\n");
 216                 return -1;
 217         }
 218         if (state->type_flags & DST_TYPE_HAS_FW_1)
 219                 msleep(100);
 220         else
 221                 msleep(5);
 222
 223         return 0;
 224 }
 225 EXPORT_SYMBOL(dst_comm_init);
 226
 227 int write_dst(struct dst_state *state, u8 *data, u8 len)
 228 {
 229         struct i2c_msg msg = {
 230                 .addr = state->config->demod_address,
 231                 .flags = 0,
 232                 .buf = data,
 233                 .len = len
 234         };
 235
 236         int err;
 237         u8 cnt;
 238
 239         dprintk(1, "writing [ %*ph ]\n", len, data);
 240
 241         for (cnt = 0; cnt < 2; cnt++) {
 242                 if ((err = i2c_transfer(state->i2c, &msg, 1)) < 0) {
 243                         dprintk(2, "_write_dst error (err == %i, len == 0x%02x, b0 == 0x%02x)\n",
 244                                 err, len, data[0]);
 245                         dst_error_recovery(state);
 246                         continue;
 247                 } else
 248                         break;
 249         }
 250         if (cnt >= 2) {
 251                 dprintk(2, "RDC 8820 RESET\n");
 252                 dst_error_bailout(state);
 253
 254                 return -1;
 255         }
 256
 257         return 0;
 258 }
 259 EXPORT_SYMBOL(write_dst);
 260
 261 int read_dst(struct dst_state *state, u8 *ret, u8 len)
 262 {
 263         struct i2c_msg msg = {
 264                 .addr = state->config->demod_address,
 265                 .flags = I2C_M_RD,
 266                 .buf = ret,
 267                 .len = len
 268         };
 269
 270         int err;
 271         int cnt;
 272
 273         for (cnt = 0; cnt < 2; cnt++) {
 274                 if ((err = i2c_transfer(state->i2c, &msg, 1)) < 0) {
 275                         dprintk(2, "read_dst error (err == %i, len == 0x%02x, b0 == 0x%02x)\n",
 276                                 err, len, ret[0]);
 277                         dst_error_recovery(state);
 278                         continue;
 279                 } else
 280                         break;
 281         }
 282         if (cnt >= 2) {
 283                 dprintk(2, "RDC 8820 RESET\n");
 284                 dst_error_bailout(state);
 285
 286                 return -1;
 287         }
 288         dprintk(3, "reply is %*ph\n", len, ret);
 289
 290         return 0;
 291 }
 292 EXPORT_SYMBOL(read_dst);
 293
 294 static int dst_set_polarization(struct dst_state *state)
 295 {
 296         switch (state->voltage) {
 297         case SEC_VOLTAGE_13:    /*      Vertical        */
 298                 dprintk(2, "Polarization=[Vertical]\n");
 299                 state->tx_tuna[8] &= ~0x40;
 300                 break;
 301         case SEC_VOLTAGE_18:    /*      Horizontal      */
 302                 dprintk(2, "Polarization=[Horizontal]\n");
 303                 state->tx_tuna[8] |= 0x40;
 304                 break;
 305         case SEC_VOLTAGE_OFF:
 306                 break;
 307         }
 308
 309         return 0;
 310 }
 311
 312 static int dst_set_freq(struct dst_state *state, u32 freq)
 313 {
 314         state->frequency = freq;
 315         dprintk(2, "set Frequency %u\n", freq);
 316
 317         if (state->dst_type == DST_TYPE_IS_SAT) {
 318                 freq = freq / 1000;
 319                 if (freq < 950 || freq > 2150)
 320                         return -EINVAL;
 321                 state->tx_tuna[2] = (freq >> 8);
 322                 state->tx_tuna[3] = (u8) freq;
 323                 state->tx_tuna[4] = 0x01;
 324                 state->tx_tuna[8] &= ~0x04;
 325                 if (state->type_flags & DST_TYPE_HAS_OBS_REGS) {
 326                         if (freq < 1531)
 327                                 state->tx_tuna[8] |= 0x04;
 328                 }
 329         } else if (state->dst_type == DST_TYPE_IS_TERR) {
 330                 freq = freq / 1000;
 331                 if (freq < 137000 || freq > 858000)
 332                         return -EINVAL;
 333                 state->tx_tuna[2] = (freq >> 16) & 0xff;
 334                 state->tx_tuna[3] = (freq >> 8) & 0xff;
 335                 state->tx_tuna[4] = (u8) freq;
 336         } else if (state->dst_type == DST_TYPE_IS_CABLE) {
 337                 freq = freq / 1000;
 338                 state->tx_tuna[2] = (freq >> 16) & 0xff;
 339                 state->tx_tuna[3] = (freq >> 8) & 0xff;
 340                 state->tx_tuna[4] = (u8) freq;
 341         } else if (state->dst_type == DST_TYPE_IS_ATSC) {
 342                 freq = freq / 1000;
 343                 if (freq < 51000 || freq > 858000)
 344                         return -EINVAL;
 345                 state->tx_tuna[2] = (freq >> 16) & 0xff;
 346                 state->tx_tuna[3] = (freq >>  8) & 0xff;
 347                 state->tx_tuna[4] = (u8) freq;
 348                 state->tx_tuna[5] = 0x00;               /*      ATSC    */
 349                 state->tx_tuna[6] = 0x00;
 350                 if (state->dst_hw_cap & DST_TYPE_HAS_ANALOG)
 351                         state->tx_tuna[7] = 0x00;       /*      Digital */
 352         } else
 353                 return -EINVAL;
 354
 355         return 0;
 356 }
 357
 358 static int dst_set_bandwidth(struct dst_state *state, u32 bandwidth)
 359 {
 360         state->bandwidth = bandwidth;
 361
 362         if (state->dst_type != DST_TYPE_IS_TERR)
 363                 return -EOPNOTSUPP;
 364
 365         switch (bandwidth) {
 366         case 6000000:
 367                 if (state->dst_hw_cap & DST_TYPE_HAS_CA)
 368                         state->tx_tuna[7] = 0x06;
 369                 else {
 370                         state->tx_tuna[6] = 0x06;
 371                         state->tx_tuna[7] = 0x00;
 372                 }
 373                 break;
 374         case 7000000:
 375                 if (state->dst_hw_cap & DST_TYPE_HAS_CA)
 376                         state->tx_tuna[7] = 0x07;
 377                 else {
 378                         state->tx_tuna[6] = 0x07;
 379                         state->tx_tuna[7] = 0x00;
 380                 }
 381                 break;
 382         case 8000000:
 383                 if (state->dst_hw_cap & DST_TYPE_HAS_CA)
 384                         state->tx_tuna[7] = 0x08;
 385                 else {
 386                         state->tx_tuna[6] = 0x08;
 387                         state->tx_tuna[7] = 0x00;
 388                 }
 389                 break;
 390         default:
 391                 return -EINVAL;
 392         }
 393
 394         return 0;
 395 }
 396
 397 static int dst_set_inversion(struct dst_state *state,
 398                              enum fe_spectral_inversion inversion)
 399 {
 400         state->inversion = inversion;
 401         switch (inversion) {
 402         case INVERSION_OFF:     /*      Inversion = Normal      */
 403                 state->tx_tuna[8] &= ~0x80;
 404                 break;
 405         case INVERSION_ON:
 406                 state->tx_tuna[8] |= 0x80;
 407                 break;
 408         default:
 409                 return -EINVAL;
 410         }
 411
 412         return 0;
 413 }
 414
 415 static int dst_set_fec(struct dst_state *state, enum fe_code_rate fec)
 416 {
 417         state->fec = fec;
 418         return 0;
 419 }
 420
 421 static enum fe_code_rate dst_get_fec(struct dst_state *state)
 422 {
 423         return state->fec;
 424 }
 425
 426 static int dst_set_symbolrate(struct dst_state *state, u32 srate)
 427 {
 428         u32 symcalc;
 429         u64 sval;
 430
 431         state->symbol_rate = srate;
 432         if (state->dst_type == DST_TYPE_IS_TERR) {
 433                 return -EOPNOTSUPP;
 434         }
 435         dprintk(2, "set symrate %u\n", srate);
 436         srate /= 1000;
 437         if (state->dst_type == DST_TYPE_IS_SAT) {
 438                 if (state->type_flags & DST_TYPE_HAS_SYMDIV) {
 439                         sval = srate;
 440                         sval <<= 20;
 441                         do_div(sval, 88000);
 442                         symcalc = (u32) sval;
 443                         dprintk(2, "set symcalc %u\n", symcalc);
 444                         state->tx_tuna[5] = (u8) (symcalc >> 12);
 445                         state->tx_tuna[6] = (u8) (symcalc >> 4);
 446                         state->tx_tuna[7] = (u8) (symcalc << 4);
 447                 } else {
 448                         state->tx_tuna[5] = (u8) (srate >> 16) & 0x7f;
 449                         state->tx_tuna[6] = (u8) (srate >> 8);
 450                         state->tx_tuna[7] = (u8) srate;
 451                 }
 452                 state->tx_tuna[8] &= ~0x20;
 453                 if (state->type_flags & DST_TYPE_HAS_OBS_REGS) {
 454                         if (srate > 8000)
 455                                 state->tx_tuna[8] |= 0x20;
 456                 }
 457         } else if (state->dst_type == DST_TYPE_IS_CABLE) {
 458                 dprintk(3, "%s\n", state->fw_name);
 459                 if (!strncmp(state->fw_name, "DCTNEW", 6)) {
 460                         state->tx_tuna[5] = (u8) (srate >> 8);
 461                         state->tx_tuna[6] = (u8) srate;
 462                         state->tx_tuna[7] = 0x00;
 463                 } else if (!strncmp(state->fw_name, "DCT-CI", 6)) {
 464                         state->tx_tuna[5] = 0x00;
 465                         state->tx_tuna[6] = (u8) (srate >> 8);
 466                         state->tx_tuna[7] = (u8) srate;
 467                 }
 468         }
 469         return 0;
 470 }
 471
 472 static int dst_set_modulation(struct dst_state *state,
 473                               enum fe_modulation modulation)
 474 {
 475         if (state->dst_type != DST_TYPE_IS_CABLE)
 476                 return -EOPNOTSUPP;
 477
 478         state->modulation = modulation;
 479         switch (modulation) {
 480         case QAM_16:
 481                 state->tx_tuna[8] = 0x10;
 482                 break;
 483         case QAM_32:
 484                 state->tx_tuna[8] = 0x20;
 485                 break;
 486         case QAM_64:
 487                 state->tx_tuna[8] = 0x40;
 488                 break;
 489         case QAM_128:
 490                 state->tx_tuna[8] = 0x80;
 491                 break;
 492         case QAM_256:
 493                 if (!strncmp(state->fw_name, "DCTNEW", 6))
 494                         state->tx_tuna[8] = 0xff;
 495                 else if (!strncmp(state->fw_name, "DCT-CI", 6))
 496                         state->tx_tuna[8] = 0x00;
 497                 break;
 498         case QPSK:
 499         case QAM_AUTO:
 500         case VSB_8:
 501         case VSB_16:
 502         default:
 503                 return -EINVAL;
 504
 505         }
 506
 507         return 0;
 508 }
 509
 510 static enum fe_modulation dst_get_modulation(struct dst_state *state)
 511 {
 512         return state->modulation;
 513 }
 514
 515
 516 u8 dst_check_sum(u8 *buf, u32 len)
 517 {
 518         u32 i;
 519         u8 val = 0;
 520         if (!len)
 521                 return 0;
 522         for (i = 0; i < len; i++) {
 523                 val += buf[i];
 524         }
 525         return ((~val) + 1);
 526 }
 527 EXPORT_SYMBOL(dst_check_sum);
 528
 529 static void dst_type_flags_print(struct dst_state *state)
 530 {
 531         u32 type_flags = state->type_flags;
 532
 533         pr_err("DST type flags :\n");
 534         if (type_flags & DST_TYPE_HAS_TS188)
 535                 pr_err(" 0x%x newtuner\n", DST_TYPE_HAS_TS188);
 536         if (type_flags & DST_TYPE_HAS_NEWTUNE_2)
 537                 pr_err(" 0x%x newtuner 2\n", DST_TYPE_HAS_NEWTUNE_2);
 538         if (type_flags & DST_TYPE_HAS_TS204)
 539                 pr_err(" 0x%x ts204\n", DST_TYPE_HAS_TS204);
 540         if (type_flags & DST_TYPE_HAS_VLF)
 541                 pr_err(" 0x%x VLF\n", DST_TYPE_HAS_VLF);
 542         if (type_flags & DST_TYPE_HAS_SYMDIV)
 543                 pr_err(" 0x%x symdiv\n", DST_TYPE_HAS_SYMDIV);
 544         if (type_flags & DST_TYPE_HAS_FW_1)
 545                 pr_err(" 0x%x firmware version = 1\n", DST_TYPE_HAS_FW_1);
 546         if (type_flags & DST_TYPE_HAS_FW_2)
 547                 pr_err(" 0x%x firmware version = 2\n", DST_TYPE_HAS_FW_2);
 548         if (type_flags & DST_TYPE_HAS_FW_3)
 549                 pr_err(" 0x%x firmware version = 3\n", DST_TYPE_HAS_FW_3);
 550         pr_err("\n");
 551 }
 552
 553
 554 static int dst_type_print(struct dst_state *state, u8 type)
 555 {
 556         char *otype;
 557         switch (type) {
 558         case DST_TYPE_IS_SAT:
 559                 otype = "satellite";
 560                 break;
 561
 562         case DST_TYPE_IS_TERR:
 563                 otype = "terrestrial";
 564                 break;
 565
 566         case DST_TYPE_IS_CABLE:
 567                 otype = "cable";
 568                 break;
 569
 570         case DST_TYPE_IS_ATSC:
 571                 otype = "atsc";
 572                 break;
 573
 574         default:
 575                 dprintk(2, "invalid dst type %d\n", type);
 576                 return -EINVAL;
 577         }
 578         dprintk(2, "DST type: %s\n", otype);
 579
 580         return 0;
 581 }
 582
 583 static struct tuner_types tuner_list[] = {
 584         {
 585                 .tuner_type = TUNER_TYPE_L64724,
 586                 .tuner_name = "L 64724",
 587                 .board_name = "UNKNOWN",
 588                 .fw_name    = "UNKNOWN"
 589         },
 590
 591         {
 592                 .tuner_type = TUNER_TYPE_STV0299,
 593                 .tuner_name = "STV 0299",
 594                 .board_name = "VP1020",
 595                 .fw_name    = "DST-MOT"
 596         },
 597
 598         {
 599                 .tuner_type = TUNER_TYPE_STV0299,
 600                 .tuner_name = "STV 0299",
 601                 .board_name = "VP1020",
 602                 .fw_name    = "DST-03T"
 603         },
 604
 605         {
 606                 .tuner_type = TUNER_TYPE_MB86A15,
 607                 .tuner_name = "MB 86A15",
 608                 .board_name = "VP1022",
 609                 .fw_name    = "DST-03T"
 610         },
 611
 612         {
 613                 .tuner_type = TUNER_TYPE_MB86A15,
 614                 .tuner_name = "MB 86A15",
 615                 .board_name = "VP1025",
 616                 .fw_name    = "DST-03T"
 617         },
 618
 619         {
 620                 .tuner_type = TUNER_TYPE_STV0299,
 621                 .tuner_name = "STV 0299",
 622                 .board_name = "VP1030",
 623                 .fw_name    = "DST-CI"
 624         },
 625
 626         {
 627                 .tuner_type = TUNER_TYPE_STV0299,
 628                 .tuner_name = "STV 0299",
 629                 .board_name = "VP1030",
 630                 .fw_name    = "DSTMCI"
 631         },
 632
 633         {
 634                 .tuner_type = TUNER_TYPE_UNKNOWN,
 635                 .tuner_name = "UNKNOWN",
 636                 .board_name = "VP2021",
 637                 .fw_name    = "DCTNEW"
 638         },
 639
 640         {
 641                 .tuner_type = TUNER_TYPE_UNKNOWN,
 642                 .tuner_name = "UNKNOWN",
 643                 .board_name = "VP2030",
 644                 .fw_name    = "DCT-CI"
 645         },
 646
 647         {
 648                 .tuner_type = TUNER_TYPE_UNKNOWN,
 649                 .tuner_name = "UNKNOWN",
 650                 .board_name = "VP2031",
 651                 .fw_name    = "DCT-CI"
 652         },
 653
 654         {
 655                 .tuner_type = TUNER_TYPE_UNKNOWN,
 656                 .tuner_name = "UNKNOWN",
 657                 .board_name = "VP2040",
 658                 .fw_name    = "DCT-CI"
 659         },
 660
 661         {
 662                 .tuner_type = TUNER_TYPE_UNKNOWN,
 663                 .tuner_name = "UNKNOWN",
 664                 .board_name = "VP3020",
 665                 .fw_name    = "DTTFTA"
 666         },
 667
 668         {
 669                 .tuner_type = TUNER_TYPE_UNKNOWN,
 670                 .tuner_name = "UNKNOWN",
 671                 .board_name = "VP3021",
 672                 .fw_name    = "DTTFTA"
 673         },
 674
 675         {
 676                 .tuner_type = TUNER_TYPE_TDA10046,
 677                 .tuner_name = "TDA10046",
 678                 .board_name = "VP3040",
 679                 .fw_name    = "DTT-CI"
 680         },
 681
 682         {
 683                 .tuner_type = TUNER_TYPE_UNKNOWN,
 684                 .tuner_name = "UNKNOWN",
 685                 .board_name = "VP3051",
 686                 .fw_name    = "DTTNXT"
 687         },
 688
 689         {
 690                 .tuner_type = TUNER_TYPE_NXT200x,
 691                 .tuner_name = "NXT200x",
 692                 .board_name = "VP3220",
 693                 .fw_name    = "ATSCDI"
 694         },
 695
 696         {
 697                 .tuner_type = TUNER_TYPE_NXT200x,
 698                 .tuner_name = "NXT200x",
 699                 .board_name = "VP3250",
 700                 .fw_name    = "ATSCAD"
 701         },
 702 };
 703
 704 /*
 705         Known cards list
 706         Satellite
 707         -------------------
 708                   200103A
 709         VP-1020   DST-MOT       LG(old), TS=188
 710
 711         VP-1020   DST-03T       LG(new), TS=204
 712         VP-1022   DST-03T       LG(new), TS=204
 713         VP-1025   DST-03T       LG(new), TS=204
 714
 715         VP-1030   DSTMCI,       LG(new), TS=188
 716         VP-1032   DSTMCI,       LG(new), TS=188
 717
 718         Cable
 719         -------------------
 720         VP-2030   DCT-CI,       Samsung, TS=204
 721         VP-2021   DCT-CI,       Unknown, TS=204
 722         VP-2031   DCT-CI,       Philips, TS=188
 723         VP-2040   DCT-CI,       Philips, TS=188, with CA daughter board
 724         VP-2040   DCT-CI,       Philips, TS=204, without CA daughter board
 725
 726         Terrestrial
 727         -------------------
 728         VP-3050  DTTNXT                  TS=188
 729         VP-3040  DTT-CI,        Philips, TS=188
 730         VP-3040  DTT-CI,        Philips, TS=204
 731
 732         ATSC
 733         -------------------
 734         VP-3220  ATSCDI,                 TS=188
 735         VP-3250  ATSCAD,                 TS=188
 736
 737 */
 738
 739 static struct dst_types dst_tlist[] = {
 740         {
 741                 .device_id = "200103A",
 742                 .offset = 0,
 743                 .dst_type =  DST_TYPE_IS_SAT,
 744                 .type_flags = DST_TYPE_HAS_SYMDIV | DST_TYPE_HAS_FW_1 | DST_TYPE_HAS_OBS_REGS,
 745                 .dst_feature = 0,
 746                 .tuner_type = 0
 747         },      /*      obsolete        */
 748
 749         {
 750                 .device_id = "DST-020",
 751                 .offset = 0,
 752                 .dst_type =  DST_TYPE_IS_SAT,
 753                 .type_flags = DST_TYPE_HAS_SYMDIV | DST_TYPE_HAS_FW_1,
 754                 .dst_feature = 0,
 755                 .tuner_type = 0
 756         },      /*      obsolete        */
 757
 758         {
 759                 .device_id = "DST-030",
 760                 .offset =  0,
 761                 .dst_type = DST_TYPE_IS_SAT,
 762                 .type_flags = DST_TYPE_HAS_TS204 | DST_TYPE_HAS_TS188 | DST_TYPE_HAS_FW_1,
 763                 .dst_feature = 0,
 764                 .tuner_type = 0
 765         },      /*      obsolete        */
 766
 767         {
 768                 .device_id = "DST-03T",
 769                 .offset = 0,
 770                 .dst_type = DST_TYPE_IS_SAT,
 771                 .type_flags = DST_TYPE_HAS_SYMDIV | DST_TYPE_HAS_TS204 | DST_TYPE_HAS_FW_2,
 772                 .dst_feature = DST_TYPE_HAS_DISEQC3 | DST_TYPE_HAS_DISEQC4 | DST_TYPE_HAS_DISEQC5
 773                                                          | DST_TYPE_HAS_MAC | DST_TYPE_HAS_MOTO,
 774                 .tuner_type = TUNER_TYPE_MULTI
 775          },
 776
 777         {
 778                 .device_id = "DST-MOT",
 779                 .offset =  0,
 780                 .dst_type = DST_TYPE_IS_SAT,
 781                 .type_flags = DST_TYPE_HAS_SYMDIV | DST_TYPE_HAS_FW_1,
 782                 .dst_feature = 0,
 783                 .tuner_type = 0
 784         },      /*      obsolete        */
 785
 786         {
 787                 .device_id = "DST-CI",
 788                 .offset = 1,
 789                 .dst_type = DST_TYPE_IS_SAT,
 790                 .type_flags = DST_TYPE_HAS_TS204 | DST_TYPE_HAS_FW_1,
 791                 .dst_feature = DST_TYPE_HAS_CA,
 792                 .tuner_type = 0
 793         },      /*      An OEM board    */
 794
 795         {
 796                 .device_id = "DSTMCI",
 797                 .offset = 1,
 798                 .dst_type = DST_TYPE_IS_SAT,
 799                 .type_flags = DST_TYPE_HAS_TS188 | DST_TYPE_HAS_FW_2 | DST_TYPE_HAS_FW_BUILD | DST_TYPE_HAS_INC_COUNT | DST_TYPE_HAS_VLF,
 800                 .dst_feature = DST_TYPE_HAS_CA | DST_TYPE_HAS_DISEQC3 | DST_TYPE_HAS_DISEQC4
 801                                                         | DST_TYPE_HAS_MOTO | DST_TYPE_HAS_MAC,
 802                 .tuner_type = TUNER_TYPE_MULTI
 803         },
 804
 805         {
 806                 .device_id = "DSTFCI",
 807                 .offset = 1,
 808                 .dst_type = DST_TYPE_IS_SAT,
 809                 .type_flags = DST_TYPE_HAS_TS188 | DST_TYPE_HAS_FW_1,
 810                 .dst_feature = 0,
 811                 .tuner_type = 0
 812         },      /* unknown to vendor    */
 813
 814         {
 815                 .device_id = "DCT-CI",
 816                 .offset = 1,
 817                 .dst_type = DST_TYPE_IS_CABLE,
 818                 .type_flags = DST_TYPE_HAS_MULTI_FE | DST_TYPE_HAS_FW_1 | DST_TYPE_HAS_FW_2 | DST_TYPE_HAS_VLF,
 819                 .dst_feature = DST_TYPE_HAS_CA,
 820                 .tuner_type = 0
 821         },
 822
 823         {
 824                 .device_id = "DCTNEW",
 825                 .offset = 1,
 826                 .dst_type = DST_TYPE_IS_CABLE,
 827                 .type_flags = DST_TYPE_HAS_TS188 | DST_TYPE_HAS_FW_3 | DST_TYPE_HAS_FW_BUILD | DST_TYPE_HAS_MULTI_FE,
 828                 .dst_feature = 0,
 829                 .tuner_type = 0
 830         },
 831
 832         {
 833                 .device_id = "DTT-CI",
 834                 .offset = 1,
 835                 .dst_type = DST_TYPE_IS_TERR,
 836                 .type_flags = DST_TYPE_HAS_FW_2 | DST_TYPE_HAS_MULTI_FE | DST_TYPE_HAS_VLF,
 837                 .dst_feature = DST_TYPE_HAS_CA,
 838                 .tuner_type = 0
 839         },
 840
 841         {
 842                 .device_id = "DTTDIG",
 843                 .offset = 1,
 844                 .dst_type = DST_TYPE_IS_TERR,
 845                 .type_flags = DST_TYPE_HAS_FW_2,
 846                 .dst_feature = 0,
 847                 .tuner_type = 0
 848         },
 849
 850         {
 851                 .device_id = "DTTNXT",
 852                 .offset = 1,
 853                 .dst_type = DST_TYPE_IS_TERR,
 854                 .type_flags = DST_TYPE_HAS_FW_2,
 855                 .dst_feature = DST_TYPE_HAS_ANALOG,
 856                 .tuner_type = 0
 857         },
 858
 859         {
 860                 .device_id = "ATSCDI",
 861                 .offset = 1,
 862                 .dst_type = DST_TYPE_IS_ATSC,
 863                 .type_flags = DST_TYPE_HAS_FW_2,
 864                 .dst_feature = 0,
 865                 .tuner_type = 0
 866         },
 867
 868         {
 869                 .device_id = "ATSCAD",
 870                 .offset = 1,
 871                 .dst_type = DST_TYPE_IS_ATSC,
 872                 .type_flags = DST_TYPE_HAS_MULTI_FE | DST_TYPE_HAS_FW_2 | DST_TYPE_HAS_FW_BUILD,
 873                 .dst_feature = DST_TYPE_HAS_MAC | DST_TYPE_HAS_ANALOG,
 874                 .tuner_type = 0
 875         },
 876
 877         { }
 878
 879 };
 880
 881 static int dst_get_mac(struct dst_state *state)
 882 {
 883         u8 get_mac[] = { 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 884         get_mac[7] = dst_check_sum(get_mac, 7);
 885         if (dst_command(state, get_mac, 8) < 0) {
 886                 dprintk(2, "Unsupported Command\n");
 887                 return -1;
 888         }
 889         memset(&state->mac_address, '\0', 8);
 890         memcpy(&state->mac_address, &state->rxbuffer, 6);
 891         pr_err("MAC Address=[%pM]\n", state->mac_address);
 892
 893         return 0;
 894 }
 895
 896 static int dst_fw_ver(struct dst_state *state)
 897 {
 898         u8 get_ver[] = { 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 899         get_ver[7] = dst_check_sum(get_ver, 7);
 900         if (dst_command(state, get_ver, 8) < 0) {
 901                 dprintk(2, "Unsupported Command\n");
 902                 return -1;
 903         }
 904         memcpy(&state->fw_version, &state->rxbuffer, 8);
 905         pr_err("Firmware Ver = %x.%x Build = %02x, on %x:%x, %x-%x-20%02x\n",
 906                 state->fw_version[0] >> 4, state->fw_version[0] & 0x0f,
 907                 state->fw_version[1],
 908                 state->fw_version[5], state->fw_version[6],
 909                 state->fw_version[4], state->fw_version[3], state->fw_version[2]);
 910
 911         return 0;
 912 }
 913
 914 static int dst_card_type(struct dst_state *state)
 915 {
 916         int j;
 917         struct tuner_types *p_tuner_list = NULL;
 918
 919         u8 get_type[] = { 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 920         get_type[7] = dst_check_sum(get_type, 7);
 921         if (dst_command(state, get_type, 8) < 0) {
 922                 dprintk(2, "Unsupported Command\n");
 923                 return -1;
 924         }
 925         memset(&state->card_info, '\0', 8);
 926         memcpy(&state->card_info, &state->rxbuffer, 7);
 927         pr_err("Device Model=[%s]\n", &state->card_info[0]);
 928
 929         for (j = 0, p_tuner_list = tuner_list; j < ARRAY_SIZE(tuner_list); j++, p_tuner_list++) {
 930                 if (!strcmp(&state->card_info[0], p_tuner_list->board_name)) {
 931                         state->tuner_type = p_tuner_list->tuner_type;
 932                         pr_err("DST has [%s] tuner, tuner type=[%d]\n",
 933                                 p_tuner_list->tuner_name, p_tuner_list->tuner_type);
 934                 }
 935         }
 936
 937         return 0;
 938 }
 939
 940 static int dst_get_vendor(struct dst_state *state)
 941 {
 942         u8 get_vendor[] = { 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 943         get_vendor[7] = dst_check_sum(get_vendor, 7);
 944         if (dst_command(state, get_vendor, 8) < 0) {
 945                 dprintk(2, "Unsupported Command\n");
 946                 return -1;
 947         }
 948         memset(&state->vendor, '\0', 8);
 949         memcpy(&state->vendor, &state->rxbuffer, 7);
 950         pr_err("Vendor=[%s]\n", &state->vendor[0]);
 951
 952         return 0;
 953 }
 954
 955 static void debug_dst_buffer(struct dst_state *state)
 956 {
 957         dprintk(3, "%s: [ %*ph ]\n", __func__, 8, state->rxbuffer);
 958 }
 959
 960 static int dst_check_stv0299(struct dst_state *state)
 961 {
 962         u8 check_stv0299[] = { 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 963
 964         check_stv0299[7] = dst_check_sum(check_stv0299, 7);
 965         if (dst_command(state, check_stv0299, 8) < 0) {
 966                 pr_err("Cmd=[0x04] failed\n");
 967                 return -1;
 968         }
 969         debug_dst_buffer(state);
 970
 971         if (memcmp(&check_stv0299, &state->rxbuffer, 8)) {
 972                 pr_err("Found a STV0299 NIM\n");
 973                 state->tuner_type = TUNER_TYPE_STV0299;
 974                 return 0;
 975         }
 976
 977         return -1;
 978 }
 979
 980 static int dst_check_mb86a15(struct dst_state *state)
 981 {
 982         u8 check_mb86a15[] = { 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 983
 984         check_mb86a15[7] = dst_check_sum(check_mb86a15, 7);
 985         if (dst_command(state, check_mb86a15, 8) < 0) {
 986                 pr_err("Cmd=[0x10], failed\n");
 987                 return -1;
 988         }
 989         debug_dst_buffer(state);
 990
 991         if (memcmp(&check_mb86a15, &state->rxbuffer, 8) < 0) {
 992                 pr_err("Found a MB86A15 NIM\n");
 993                 state->tuner_type = TUNER_TYPE_MB86A15;
 994                 return 0;
 995         }
 996
 997         return -1;
 998 }
 999
1000 static int dst_get_tuner_info(struct dst_state *state)
1001 {
1002         u8 get_tuner_1[] = { 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1003         u8 get_tuner_2[] = { 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1004
1005         get_tuner_1[7] = dst_check_sum(get_tuner_1, 7);
1006         get_tuner_2[7] = dst_check_sum(get_tuner_2, 7);
1007         pr_err("DST TYpe = MULTI FE\n");
1008         if (state->type_flags & DST_TYPE_HAS_MULTI_FE) {
1009                 if (dst_command(state, get_tuner_1, 8) < 0) {
1010                         dprintk(2, "Cmd=[0x13], Unsupported\n");
1011                         goto force;
1012                 }
1013         } else {
1014                 if (dst_command(state, get_tuner_2, 8) < 0) {
1015                         dprintk(2, "Cmd=[0xb], Unsupported\n");
1016                         goto force;
1017                 }
1018         }
1019         memcpy(&state->board_info, &state->rxbuffer, 8);
1020         if (state->type_flags & DST_TYPE_HAS_MULTI_FE) {
1021                 pr_err("DST type has TS=188\n");
1022         }
1023         if (state->board_info[0] == 0xbc) {
1024                 if (state->dst_type != DST_TYPE_IS_ATSC)
1025                         state->type_flags |= DST_TYPE_HAS_TS188;
1026                 else
1027                         state->type_flags |= DST_TYPE_HAS_NEWTUNE_2;
1028
1029                 if (state->board_info[1] == 0x01) {
1030                         state->dst_hw_cap |= DST_TYPE_HAS_DBOARD;
1031                         pr_err("DST has Daughterboard\n");
1032                 }
1033         }
1034
1035         return 0;
1036 force:
1037         if (!strncmp(state->fw_name, "DCT-CI", 6)) {
1038                 state->type_flags |= DST_TYPE_HAS_TS204;
1039                 pr_err("Forcing [%s] to TS188\n", state->fw_name);
1040         }
1041
1042         return -1;
1043 }
1044
1045 static int dst_get_device_id(struct dst_state *state)
1046 {
1047         u8 reply;
1048
1049         int i, j;
1050         struct dst_types *p_dst_type = NULL;
1051         struct tuner_types *p_tuner_list = NULL;
1052
1053         u8 use_dst_type = 0;
1054         u32 use_type_flags = 0;
1055
1056         static u8 device_type[8] = {0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff};
1057
1058         state->tuner_type = 0;
1059         device_type[7] = dst_check_sum(device_type, 7);
1060
1061         if (write_dst(state, device_type, FIXED_COMM))
1062                 return -1;              /*      Write failed            */
1063         if ((dst_pio_disable(state)) < 0)
1064                 return -1;
1065         if (read_dst(state, &reply, GET_ACK))
1066                 return -1;              /*      Read failure            */
1067         if (reply != ACK) {
1068                 dprintk(2, "Write not Acknowledged! [Reply=0x%02x]\n", reply);
1069                 return -1;              /*      Unack'd write           */
1070         }
1071         if (!dst_wait_dst_ready(state, DEVICE_INIT))
1072                 return -1;              /*      DST not ready yet       */
1073         if (read_dst(state, state->rxbuffer, FIXED_COMM))
1074                 return -1;
1075
1076         dst_pio_disable(state);
1077         if (state->rxbuffer[7] != dst_check_sum(state->rxbuffer, 7)) {
1078                 dprintk(2, "Checksum failure!\n");
1079                 return -1;              /*      Checksum failure        */
1080         }
1081         state->rxbuffer[7] = '\0';
1082
1083         for (i = 0, p_dst_type = dst_tlist; i < ARRAY_SIZE(dst_tlist); i++, p_dst_type++) {
1084                 if (!strncmp (&state->rxbuffer[p_dst_type->offset], p_dst_type->device_id, strlen (p_dst_type->device_id))) {
1085                         use_type_flags = p_dst_type->type_flags;
1086                         use_dst_type = p_dst_type->dst_type;
1087
1088                         /*      Card capabilities       */
1089                         state->dst_hw_cap = p_dst_type->dst_feature;
1090                         pr_err("Recognise [%s]\n", p_dst_type->device_id);
1091                         strscpy(state->fw_name, p_dst_type->device_id,
1092                                 sizeof(state->fw_name));
1093                         /*      Multiple tuners         */
1094                         if (p_dst_type->tuner_type & TUNER_TYPE_MULTI) {
1095                                 switch (use_dst_type) {
1096                                 case DST_TYPE_IS_SAT:
1097                                         /*      STV0299 check   */
1098                                         if (dst_check_stv0299(state) < 0) {
1099                                                 pr_err("Unsupported\n");
1100                                                 state->tuner_type = TUNER_TYPE_MB86A15;
1101                                         }
1102                                         break;
1103                                 default:
1104                                         break;
1105                                 }
1106                                 if (dst_check_mb86a15(state) < 0)
1107                                         pr_err("Unsupported\n");
1108                         /*      Single tuner            */
1109                         } else {
1110                                 state->tuner_type = p_dst_type->tuner_type;
1111                         }
1112                         for (j = 0, p_tuner_list = tuner_list; j < ARRAY_SIZE(tuner_list); j++, p_tuner_list++) {
1113                                 if (!(strncmp(p_dst_type->device_id, p_tuner_list->fw_name, 7)) &&
1114                                         p_tuner_list->tuner_type == state->tuner_type) {
1115                                         pr_err("[%s] has a [%s]\n",
1116                                                 p_dst_type->device_id, p_tuner_list->tuner_name);
1117                                 }
1118                         }
1119                         break;
1120                 }
1121         }
1122
1123         if (i >= ARRAY_SIZE(dst_tlist)) {
1124                 pr_err("Unable to recognize %s or %s\n", &state->rxbuffer[0], &state->rxbuffer[1]);
1125                 pr_err("please email linux-dvb@linuxtv.org with this type in");
1126                 use_dst_type = DST_TYPE_IS_SAT;
1127                 use_type_flags = DST_TYPE_HAS_SYMDIV;
1128         }
1129         dst_type_print(state, use_dst_type);
1130         state->type_flags = use_type_flags;
1131         state->dst_type = use_dst_type;
1132         dst_type_flags_print(state);
1133
1134         return 0;
1135 }
1136
1137 static int dst_probe(struct dst_state *state)
1138 {
1139         mutex_init(&state->dst_mutex);
1140         if (dst_addons & DST_TYPE_HAS_CA) {
1141                 if ((rdc_8820_reset(state)) < 0) {
1142                         pr_err("RDC 8820 RESET Failed.\n");
1143                         return -1;
1144                 }
1145                 msleep(4000);
1146         } else {
1147                 msleep(100);
1148         }
1149         if ((dst_comm_init(state)) < 0) {
1150                 pr_err("DST Initialization Failed.\n");
1151                 return -1;
1152         }
1153         msleep(100);
1154         if (dst_get_device_id(state) < 0) {
1155                 pr_err("unknown device.\n");
1156                 return -1;
1157         }
1158         if (dst_get_mac(state) < 0) {
1159                 dprintk(2, "MAC: Unsupported command\n");
1160         }
1161         if ((state->type_flags & DST_TYPE_HAS_MULTI_FE) || (state->type_flags & DST_TYPE_HAS_FW_BUILD)) {
1162                 if (dst_get_tuner_info(state) < 0)
1163                         dprintk(2, "Tuner: Unsupported command\n");
1164         }
1165         if (state->type_flags & DST_TYPE_HAS_TS204) {
1166                 dst_packsize(state, 204);
1167         }
1168         if (state->type_flags & DST_TYPE_HAS_FW_BUILD) {
1169                 if (dst_fw_ver(state) < 0) {
1170                         dprintk(2, "FW: Unsupported command\n");
1171                         return 0;
1172                 }
1173                 if (dst_card_type(state) < 0) {
1174                         dprintk(2, "Card: Unsupported command\n");
1175                         return 0;
1176                 }
1177                 if (dst_get_vendor(state) < 0) {
1178                         dprintk(2, "Vendor: Unsupported command\n");
1179                         return 0;
1180                 }
1181         }
1182
1183         return 0;
1184 }
1185
1186 static int dst_command(struct dst_state *state, u8 *data, u8 len)
1187 {
1188         u8 reply;
1189
1190         mutex_lock(&state->dst_mutex);
1191         if ((dst_comm_init(state)) < 0) {
1192                 dprintk(1, "DST Communication Initialization Failed.\n");
1193                 goto error;
1194         }
1195         if (write_dst(state, data, len)) {
1196                 dprintk(2, "Trying to recover..\n");
1197                 if ((dst_error_recovery(state)) < 0) {
1198                         pr_err("Recovery Failed.\n");
1199                         goto error;
1200                 }
1201                 goto error;
1202         }
1203         if ((dst_pio_disable(state)) < 0) {
1204                 pr_err("PIO Disable Failed.\n");
1205                 goto error;
1206         }
1207         if (state->type_flags & DST_TYPE_HAS_FW_1)
1208                 mdelay(3);
1209         if (read_dst(state, &reply, GET_ACK)) {
1210                 dprintk(3, "Trying to recover..\n");
1211                 if ((dst_error_recovery(state)) < 0) {
1212                         dprintk(2, "Recovery Failed.\n");
1213                         goto error;
1214                 }
1215                 goto error;
1216         }
1217         if (reply != ACK) {
1218                 dprintk(2, "write not acknowledged 0x%02x\n", reply);
1219                 goto error;
1220         }
1221         if (len >= 2 && data[0] == 0 && (data[1] == 1 || data[1] == 3))
1222                 goto error;
1223         if (state->type_flags & DST_TYPE_HAS_FW_1)
1224                 mdelay(3);
1225         else
1226                 udelay(2000);
1227         if (!dst_wait_dst_ready(state, NO_DELAY))
1228                 goto error;
1229         if (read_dst(state, state->rxbuffer, FIXED_COMM)) {
1230                 dprintk(3, "Trying to recover..\n");
1231                 if ((dst_error_recovery(state)) < 0) {
1232                         dprintk(2, "Recovery failed.\n");
1233                         goto error;
1234                 }
1235                 goto error;
1236         }
1237         if (state->rxbuffer[7] != dst_check_sum(state->rxbuffer, 7)) {
1238                 dprintk(2, "checksum failure\n");
1239                 goto error;
1240         }
1241         mutex_unlock(&state->dst_mutex);
1242         return 0;
1243
1244 error:
1245         mutex_unlock(&state->dst_mutex);
1246         return -EIO;
1247
1248 }
1249
1250 static int dst_get_signal(struct dst_state *state)
1251 {
1252         int retval;
1253         u8 get_signal[] = { 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb };
1254         //dprintk("%s: Getting Signal strength and other parameters\n", __func__);
1255         if ((state->diseq_flags & ATTEMPT_TUNE) == 0) {
1256                 state->decode_lock = state->decode_strength = state->decode_snr = 0;
1257                 return 0;
1258         }
1259         if (0 == (state->diseq_flags & HAS_LOCK)) {
1260                 state->decode_lock = state->decode_strength = state->decode_snr = 0;
1261                 return 0;
1262         }
1263         if (time_after_eq(jiffies, state->cur_jiff + (HZ / 5))) {
1264                 retval = dst_command(state, get_signal, 8);
1265                 if (retval < 0)
1266                         return retval;
1267                 if (state->dst_type == DST_TYPE_IS_SAT) {
1268                         state->decode_lock = ((state->rxbuffer[6] & 0x10) == 0) ? 1 : 0;
1269                         state->decode_strength = state->rxbuffer[5] << 8;
1270                         state->decode_snr = state->rxbuffer[2] << 8 | state->rxbuffer[3];
1271                 } else if ((state->dst_type == DST_TYPE_IS_TERR) || (state->dst_type == DST_TYPE_IS_CABLE)) {
1272                         state->decode_lock = (state->rxbuffer[1]) ? 1 : 0;
1273                         state->decode_strength = state->rxbuffer[4] << 8;
1274                         state->decode_snr = state->rxbuffer[3] << 8;
1275                 } else if (state->dst_type == DST_TYPE_IS_ATSC) {
1276                         state->decode_lock = (state->rxbuffer[6] == 0x00) ? 1 : 0;
1277                         state->decode_strength = state->rxbuffer[4] << 8;
1278                         state->decode_snr = state->rxbuffer[2] << 8 | state->rxbuffer[3];
1279                 }
1280                 state->cur_jiff = jiffies;
1281         }
1282         return 0;
1283 }
1284
1285 static int dst_tone_power_cmd(struct dst_state *state)
1286 {
1287         u8 packet[8] = { 0x00, 0x09, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00 };
1288
1289         if (state->dst_type != DST_TYPE_IS_SAT)
1290                 return -EOPNOTSUPP;
1291         packet[4] = state->tx_tuna[4];
1292         packet[2] = state->tx_tuna[2];
1293         packet[3] = state->tx_tuna[3];
1294         packet[7] = dst_check_sum (packet, 7);
1295         return dst_command(state, packet, 8);
1296 }
1297
1298 static int dst_get_tuna(struct dst_state *state)
1299 {
1300         int retval;
1301
1302         if ((state->diseq_flags & ATTEMPT_TUNE) == 0)
1303                 return 0;
1304         state->diseq_flags &= ~(HAS_LOCK);
1305         if (!dst_wait_dst_ready(state, NO_DELAY))
1306                 return -EIO;
1307         if ((state->type_flags & DST_TYPE_HAS_VLF) &&
1308                 !(state->dst_type == DST_TYPE_IS_ATSC))
1309
1310                 retval = read_dst(state, state->rx_tuna, 10);
1311         else
1312                 retval = read_dst(state, &state->rx_tuna[2], FIXED_COMM);
1313         if (retval < 0) {
1314                 dprintk(3, "read not successful\n");
1315                 return retval;
1316         }
1317         if ((state->type_flags & DST_TYPE_HAS_VLF) &&
1318            !(state->dst_type == DST_TYPE_IS_ATSC)) {
1319
1320                 if (state->rx_tuna[9] != dst_check_sum(&state->rx_tuna[0], 9)) {
1321                         dprintk(2, "checksum failure ?\n");
1322                         return -EIO;
1323                 }
1324         } else {
1325                 if (state->rx_tuna[9] != dst_check_sum(&state->rx_tuna[2], 7)) {
1326                         dprintk(2, "checksum failure?\n");
1327                         return -EIO;
1328                 }
1329         }
1330         if (state->rx_tuna[2] == 0 && state->rx_tuna[3] == 0)
1331                 return 0;
1332         if (state->dst_type == DST_TYPE_IS_SAT) {
1333                 state->decode_freq = ((state->rx_tuna[2] & 0x7f) << 8) + state->rx_tuna[3];
1334         } else {
1335                 state->decode_freq = ((state->rx_tuna[2] & 0x7f) << 16) + (state->rx_tuna[3] << 8) + state->rx_tuna[4];
1336         }
1337         state->decode_freq = state->decode_freq * 1000;
1338         state->decode_lock = 1;
1339         state->diseq_flags |= HAS_LOCK;
1340
1341         return 1;
1342 }
1343
1344 static int dst_set_voltage(struct dvb_frontend *fe,
1345                            enum fe_sec_voltage voltage);
1346
1347 static int dst_write_tuna(struct dvb_frontend *fe)
1348 {
1349         struct dst_state *state = fe->demodulator_priv;
1350         int retval;
1351         u8 reply;
1352
1353         dprintk(2, "type_flags 0x%x\n", state->type_flags);
1354         state->decode_freq = 0;
1355         state->decode_lock = state->decode_strength = state->decode_snr = 0;
1356         if (state->dst_type == DST_TYPE_IS_SAT) {
1357                 if (!(state->diseq_flags & HAS_POWER))
1358                         dst_set_voltage(fe, SEC_VOLTAGE_13);
1359         }
1360         state->diseq_flags &= ~(HAS_LOCK | ATTEMPT_TUNE);
1361         mutex_lock(&state->dst_mutex);
1362         if ((dst_comm_init(state)) < 0) {
1363                 dprintk(3, "DST Communication initialization failed.\n");
1364                 goto error;
1365         }
1366 //      if (state->type_flags & DST_TYPE_HAS_NEWTUNE) {
1367         if ((state->type_flags & DST_TYPE_HAS_VLF) &&
1368                 (!(state->dst_type == DST_TYPE_IS_ATSC))) {
1369
1370                 state->tx_tuna[9] = dst_check_sum(&state->tx_tuna[0], 9);
1371                 retval = write_dst(state, &state->tx_tuna[0], 10);
1372         } else {
1373                 state->tx_tuna[9] = dst_check_sum(&state->tx_tuna[2], 7);
1374                 retval = write_dst(state, &state->tx_tuna[2], FIXED_COMM);
1375         }
1376         if (retval < 0) {
1377                 dst_pio_disable(state);
1378                 dprintk(3, "write not successful\n");
1379                 goto werr;
1380         }
1381         if ((dst_pio_disable(state)) < 0) {
1382                 dprintk(3, "DST PIO disable failed !\n");
1383                 goto error;
1384         }
1385         if ((read_dst(state, &reply, GET_ACK) < 0)) {
1386                 dprintk(3, "read verify not successful.\n");
1387                 goto error;
1388         }
1389         if (reply != ACK) {
1390                 dprintk(3, "write not acknowledged 0x%02x\n", reply);
1391                 goto error;
1392         }
1393         state->diseq_flags |= ATTEMPT_TUNE;
1394         retval = dst_get_tuna(state);
1395 werr:
1396         mutex_unlock(&state->dst_mutex);
1397         return retval;
1398
1399 error:
1400         mutex_unlock(&state->dst_mutex);
1401         return -EIO;
1402 }
1403
1404 /*
1405  * line22k0    0x00, 0x09, 0x00, 0xff, 0x01, 0x00, 0x00, 0x00
1406  * line22k1    0x00, 0x09, 0x01, 0xff, 0x01, 0x00, 0x00, 0x00
1407  * line22k2    0x00, 0x09, 0x02, 0xff, 0x01, 0x00, 0x00, 0x00
1408  * tone        0x00, 0x09, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00
1409  * data        0x00, 0x09, 0xff, 0x01, 0x01, 0x00, 0x00, 0x00
1410  * power_off   0x00, 0x09, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00
1411  * power_on    0x00, 0x09, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00
1412  * Diseqc 1    0x00, 0x08, 0x04, 0xe0, 0x10, 0x38, 0xf0, 0xec
1413  * Diseqc 2    0x00, 0x08, 0x04, 0xe0, 0x10, 0x38, 0xf4, 0xe8
1414  * Diseqc 3    0x00, 0x08, 0x04, 0xe0, 0x10, 0x38, 0xf8, 0xe4
1415  * Diseqc 4    0x00, 0x08, 0x04, 0xe0, 0x10, 0x38, 0xfc, 0xe0
1416  */
1417
1418 static int dst_set_diseqc(struct dvb_frontend *fe, struct dvb_diseqc_master_cmd *cmd)
1419 {
1420         struct dst_state *state = fe->demodulator_priv;
1421         u8 packet[8] = { 0x00, 0x08, 0x04, 0xe0, 0x10, 0x38, 0xf0, 0xec };
1422
1423         if (state->dst_type != DST_TYPE_IS_SAT)
1424                 return -EOPNOTSUPP;
1425         if (cmd->msg_len > 0 && cmd->msg_len < 5)
1426                 memcpy(&packet[3], cmd->msg, cmd->msg_len);
1427         else if (cmd->msg_len == 5 && state->dst_hw_cap & DST_TYPE_HAS_DISEQC5)
1428                 memcpy(&packet[2], cmd->msg, cmd->msg_len);
1429         else
1430                 return -EINVAL;
1431         packet[7] = dst_check_sum(&packet[0], 7);
1432         return dst_command(state, packet, 8);
1433 }
1434
1435 static int dst_set_voltage(struct dvb_frontend *fe, enum fe_sec_voltage voltage)
1436 {
1437         int need_cmd, retval = 0;
1438         struct dst_state *state = fe->demodulator_priv;
1439
1440         state->voltage = voltage;
1441         if (state->dst_type != DST_TYPE_IS_SAT)
1442                 return -EOPNOTSUPP;
1443
1444         need_cmd = 0;
1445
1446         switch (voltage) {
1447         case SEC_VOLTAGE_13:
1448         case SEC_VOLTAGE_18:
1449                 if ((state->diseq_flags & HAS_POWER) == 0)
1450                         need_cmd = 1;
1451                 state->diseq_flags |= HAS_POWER;
1452                 state->tx_tuna[4] = 0x01;
1453                 break;
1454         case SEC_VOLTAGE_OFF:
1455                 need_cmd = 1;
1456                 state->diseq_flags &= ~(HAS_POWER | HAS_LOCK | ATTEMPT_TUNE);
1457                 state->tx_tuna[4] = 0x00;
1458                 break;
1459         default:
1460                 return -EINVAL;
1461         }
1462
1463         if (need_cmd)
1464                 retval = dst_tone_power_cmd(state);
1465
1466         return retval;
1467 }
1468
1469 static int dst_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone)
1470 {
1471         struct dst_state *state = fe->demodulator_priv;
1472
1473         state->tone = tone;
1474         if (state->dst_type != DST_TYPE_IS_SAT)
1475                 return -EOPNOTSUPP;
1476
1477         switch (tone) {
1478         case SEC_TONE_OFF:
1479                 if (state->type_flags & DST_TYPE_HAS_OBS_REGS)
1480                     state->tx_tuna[2] = 0x00;
1481                 else
1482                     state->tx_tuna[2] = 0xff;
1483                 break;
1484
1485         case SEC_TONE_ON:
1486                 state->tx_tuna[2] = 0x02;
1487                 break;
1488         default:
1489                 return -EINVAL;
1490         }
1491         return dst_tone_power_cmd(state);
1492 }
1493
1494 static int dst_send_burst(struct dvb_frontend *fe, enum fe_sec_mini_cmd minicmd)
1495 {
1496         struct dst_state *state = fe->demodulator_priv;
1497
1498         if (state->dst_type != DST_TYPE_IS_SAT)
1499                 return -EOPNOTSUPP;
1500         state->minicmd = minicmd;
1501         switch (minicmd) {
1502         case SEC_MINI_A:
1503                 state->tx_tuna[3] = 0x02;
1504                 break;
1505         case SEC_MINI_B:
1506                 state->tx_tuna[3] = 0xff;
1507                 break;
1508         }
1509         return dst_tone_power_cmd(state);
1510 }
1511
1512
1513 static int bt8xx_dst_init(struct dvb_frontend *fe)
1514 {
1515         struct dst_state *state = fe->demodulator_priv;
1516
1517         static u8 sat_tuna_188[] = { 0x09, 0x00, 0x03, 0xb6, 0x01, 0x00, 0x73, 0x21, 0x00, 0x00 };
1518         static u8 sat_tuna_204[] = { 0x00, 0x00, 0x03, 0xb6, 0x01, 0x55, 0xbd, 0x50, 0x00, 0x00 };
1519         static u8 ter_tuna_188[] = { 0x09, 0x00, 0x03, 0xb6, 0x01, 0x07, 0x00, 0x00, 0x00, 0x00 };
1520         static u8 ter_tuna_204[] = { 0x00, 0x00, 0x03, 0xb6, 0x01, 0x07, 0x00, 0x00, 0x00, 0x00 };
1521         static u8 cab_tuna_188[] = { 0x09, 0x00, 0x03, 0xb6, 0x01, 0x07, 0x00, 0x00, 0x00, 0x00 };
1522         static u8 cab_tuna_204[] = { 0x00, 0x00, 0x03, 0xb6, 0x01, 0x07, 0x00, 0x00, 0x00, 0x00 };
1523         static u8 atsc_tuner[] = { 0x00, 0x00, 0x03, 0xb6, 0x01, 0x07, 0x00, 0x00, 0x00, 0x00 };
1524
1525         state->inversion = INVERSION_OFF;
1526         state->voltage = SEC_VOLTAGE_13;
1527         state->tone = SEC_TONE_OFF;
1528         state->diseq_flags = 0;
1529         state->k22 = 0x02;
1530         state->bandwidth = 7000000;
1531         state->cur_jiff = jiffies;
1532         if (state->dst_type == DST_TYPE_IS_SAT)
1533                 memcpy(state->tx_tuna, ((state->type_flags & DST_TYPE_HAS_VLF) ? sat_tuna_188 : sat_tuna_204), sizeof (sat_tuna_204));
1534         else if (state->dst_type == DST_TYPE_IS_TERR)
1535                 memcpy(state->tx_tuna, ((state->type_flags & DST_TYPE_HAS_VLF) ? ter_tuna_188 : ter_tuna_204), sizeof (ter_tuna_204));
1536         else if (state->dst_type == DST_TYPE_IS_CABLE)
1537                 memcpy(state->tx_tuna, ((state->type_flags & DST_TYPE_HAS_VLF) ? cab_tuna_188 : cab_tuna_204), sizeof (cab_tuna_204));
1538         else if (state->dst_type == DST_TYPE_IS_ATSC)
1539                 memcpy(state->tx_tuna, atsc_tuner, sizeof (atsc_tuner));
1540
1541         return 0;
1542 }
1543
1544 static int dst_read_status(struct dvb_frontend *fe, enum fe_status *status)
1545 {
1546         struct dst_state *state = fe->demodulator_priv;
1547
1548         *status = 0;
1549         if (state->diseq_flags & HAS_LOCK) {
1550 //              dst_get_signal(state);  // don't require(?) to ask MCU
1551                 if (state->decode_lock)
1552                         *status |= FE_HAS_LOCK | FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_SYNC | FE_HAS_VITERBI;
1553         }
1554
1555         return 0;
1556 }
1557
1558 static int dst_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
1559 {
1560         struct dst_state *state = fe->demodulator_priv;
1561
1562         int retval = dst_get_signal(state);
1563         *strength = state->decode_strength;
1564
1565         return retval;
1566 }
1567
1568 static int dst_read_snr(struct dvb_frontend *fe, u16 *snr)
1569 {
1570         struct dst_state *state = fe->demodulator_priv;
1571
1572         int retval = dst_get_signal(state);
1573         *snr = state->decode_snr;
1574
1575         return retval;
1576 }
1577
1578 static int dst_set_frontend(struct dvb_frontend *fe)
1579 {
1580         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1581         int retval = -EINVAL;
1582         struct dst_state *state = fe->demodulator_priv;
1583
1584         if (p != NULL) {
1585                 retval = dst_set_freq(state, p->frequency);
1586                 if(retval != 0)
1587                         return retval;
1588                 dprintk(3, "Set Frequency=[%d]\n", p->frequency);
1589
1590                 if (state->dst_type == DST_TYPE_IS_SAT) {
1591                         if (state->type_flags & DST_TYPE_HAS_OBS_REGS)
1592                                 dst_set_inversion(state, p->inversion);
1593                         dst_set_fec(state, p->fec_inner);
1594                         dst_set_symbolrate(state, p->symbol_rate);
1595                         dst_set_polarization(state);
1596                         dprintk(3, "Set Symbolrate=[%d]\n", p->symbol_rate);
1597
1598                 } else if (state->dst_type == DST_TYPE_IS_TERR)
1599                         dst_set_bandwidth(state, p->bandwidth_hz);
1600                 else if (state->dst_type == DST_TYPE_IS_CABLE) {
1601                         dst_set_fec(state, p->fec_inner);
1602                         dst_set_symbolrate(state, p->symbol_rate);
1603                         dst_set_modulation(state, p->modulation);
1604                 }
1605                 retval = dst_write_tuna(fe);
1606         }
1607
1608         return retval;
1609 }
1610
1611 static int dst_tune_frontend(struct dvb_frontend* fe,
1612                             bool re_tune,
1613                             unsigned int mode_flags,
1614                             unsigned int *delay,
1615                             enum fe_status *status)
1616 {
1617         struct dst_state *state = fe->demodulator_priv;
1618         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1619
1620         if (re_tune) {
1621                 dst_set_freq(state, p->frequency);
1622                 dprintk(3, "Set Frequency=[%d]\n", p->frequency);
1623
1624                 if (state->dst_type == DST_TYPE_IS_SAT) {
1625                         if (state->type_flags & DST_TYPE_HAS_OBS_REGS)
1626                                 dst_set_inversion(state, p->inversion);
1627                         dst_set_fec(state, p->fec_inner);
1628                         dst_set_symbolrate(state, p->symbol_rate);
1629                         dst_set_polarization(state);
1630                         dprintk(3, "Set Symbolrate=[%d]\n", p->symbol_rate);
1631
1632                 } else if (state->dst_type == DST_TYPE_IS_TERR)
1633                         dst_set_bandwidth(state, p->bandwidth_hz);
1634                 else if (state->dst_type == DST_TYPE_IS_CABLE) {
1635                         dst_set_fec(state, p->fec_inner);
1636                         dst_set_symbolrate(state, p->symbol_rate);
1637                         dst_set_modulation(state, p->modulation);
1638                 }
1639                 dst_write_tuna(fe);
1640         }
1641
1642         if (!(mode_flags & FE_TUNE_MODE_ONESHOT))
1643                 dst_read_status(fe, status);
1644
1645         *delay = HZ/10;
1646         return 0;
1647 }
1648
1649 static enum dvbfe_algo dst_get_tuning_algo(struct dvb_frontend *fe)
1650 {
1651         return dst_algo ? DVBFE_ALGO_HW : DVBFE_ALGO_SW;
1652 }
1653
1654 static int dst_get_frontend(struct dvb_frontend *fe,
1655                             struct dtv_frontend_properties *p)
1656 {
1657         struct dst_state *state = fe->demodulator_priv;
1658
1659         p->frequency = state->decode_freq;
1660         if (state->dst_type == DST_TYPE_IS_SAT) {
1661                 if (state->type_flags & DST_TYPE_HAS_OBS_REGS)
1662                         p->inversion = state->inversion;
1663                 p->symbol_rate = state->symbol_rate;
1664                 p->fec_inner = dst_get_fec(state);
1665         } else if (state->dst_type == DST_TYPE_IS_TERR) {
1666                 p->bandwidth_hz = state->bandwidth;
1667         } else if (state->dst_type == DST_TYPE_IS_CABLE) {
1668                 p->symbol_rate = state->symbol_rate;
1669                 p->fec_inner = dst_get_fec(state);
1670                 p->modulation = dst_get_modulation(state);
1671         }
1672
1673         return 0;
1674 }
1675
1676 static void bt8xx_dst_release(struct dvb_frontend *fe)
1677 {
1678         struct dst_state *state = fe->demodulator_priv;
1679         if (state->dst_ca) {
1680                 dvb_unregister_device(state->dst_ca);
1681 #ifdef CONFIG_MEDIA_ATTACH
1682                 symbol_put(dst_ca_attach);
1683 #endif
1684         }
1685         kfree(state);
1686 }
1687
1688 static const struct dvb_frontend_ops dst_dvbt_ops;
1689 static const struct dvb_frontend_ops dst_dvbs_ops;
1690 static const struct dvb_frontend_ops dst_dvbc_ops;
1691 static const struct dvb_frontend_ops dst_atsc_ops;
1692
1693 struct dst_state *dst_attach(struct dst_state *state, struct dvb_adapter *dvb_adapter)
1694 {
1695         /* check if the ASIC is there */
1696         if (dst_probe(state) < 0) {
1697                 kfree(state);
1698                 return NULL;
1699         }
1700         /* determine settings based on type */
1701         /* create dvb_frontend */
1702         switch (state->dst_type) {
1703         case DST_TYPE_IS_TERR:
1704                 memcpy(&state->frontend.ops, &dst_dvbt_ops, sizeof(struct dvb_frontend_ops));
1705                 break;
1706         case DST_TYPE_IS_CABLE:
1707                 memcpy(&state->frontend.ops, &dst_dvbc_ops, sizeof(struct dvb_frontend_ops));
1708                 break;
1709         case DST_TYPE_IS_SAT:
1710                 memcpy(&state->frontend.ops, &dst_dvbs_ops, sizeof(struct dvb_frontend_ops));
1711                 break;
1712         case DST_TYPE_IS_ATSC:
1713                 memcpy(&state->frontend.ops, &dst_atsc_ops, sizeof(struct dvb_frontend_ops));
1714                 break;
1715         default:
1716                 pr_err("unknown DST type. please report to the LinuxTV.org DVB mailinglist.\n");
1717                 kfree(state);
1718                 return NULL;
1719         }
1720         state->frontend.demodulator_priv = state;
1721
1722         return state;                           /*      Manu (DST is a card not a frontend)     */
1723 }
1724
1725 EXPORT_SYMBOL_GPL(dst_attach);
1726
1727 static const struct dvb_frontend_ops dst_dvbt_ops = {
1728         .delsys = { SYS_DVBT },
1729         .info = {
1730                 .name = "DST DVB-T",
1731                 .frequency_min_hz = 137 * MHz,
1732                 .frequency_max_hz = 858 * MHz,
1733                 .frequency_stepsize_hz = 166667,
1734                 .caps = FE_CAN_FEC_AUTO                 |
1735                         FE_CAN_QAM_AUTO                 |
1736                         FE_CAN_QAM_16                   |
1737                         FE_CAN_QAM_32                   |
1738                         FE_CAN_QAM_64                   |
1739                         FE_CAN_QAM_128                  |
1740                         FE_CAN_QAM_256                  |
1741                         FE_CAN_TRANSMISSION_MODE_AUTO   |
1742                         FE_CAN_GUARD_INTERVAL_AUTO
1743         },
1744
1745         .release = bt8xx_dst_release,
1746         .init = bt8xx_dst_init,
1747         .tune = dst_tune_frontend,
1748         .set_frontend = dst_set_frontend,
1749         .get_frontend = dst_get_frontend,
1750         .get_frontend_algo = dst_get_tuning_algo,
1751         .read_status = dst_read_status,
1752         .read_signal_strength = dst_read_signal_strength,
1753         .read_snr = dst_read_snr,
1754 };
1755
1756 static const struct dvb_frontend_ops dst_dvbs_ops = {
1757         .delsys = { SYS_DVBS },
1758         .info = {
1759                 .name = "DST DVB-S",
1760                 .frequency_min_hz   =  950 * MHz,
1761                 .frequency_max_hz   = 2150 * MHz,
1762                 .frequency_stepsize_hz = 1 * MHz,
1763                 .frequency_tolerance_hz = 29500 * kHz,
1764                 .symbol_rate_min = 1000000,
1765                 .symbol_rate_max = 45000000,
1766         /*     . symbol_rate_tolerance  =       ???,*/
1767                 .caps = FE_CAN_FEC_AUTO | FE_CAN_QPSK
1768         },
1769
1770         .release = bt8xx_dst_release,
1771         .init = bt8xx_dst_init,
1772         .tune = dst_tune_frontend,
1773         .set_frontend = dst_set_frontend,
1774         .get_frontend = dst_get_frontend,
1775         .get_frontend_algo = dst_get_tuning_algo,
1776         .read_status = dst_read_status,
1777         .read_signal_strength = dst_read_signal_strength,
1778         .read_snr = dst_read_snr,
1779         .diseqc_send_burst = dst_send_burst,
1780         .diseqc_send_master_cmd = dst_set_diseqc,
1781         .set_voltage = dst_set_voltage,
1782         .set_tone = dst_set_tone,
1783 };
1784
1785 static const struct dvb_frontend_ops dst_dvbc_ops = {
1786         .delsys = { SYS_DVBC_ANNEX_A },
1787         .info = {
1788                 .name = "DST DVB-C",
1789                 .frequency_min_hz =  51 * MHz,
1790                 .frequency_max_hz = 858 * MHz,
1791                 .frequency_stepsize_hz = 62500,
1792                 .symbol_rate_min = 1000000,
1793                 .symbol_rate_max = 45000000,
1794                 .caps = FE_CAN_FEC_AUTO |
1795                         FE_CAN_QAM_AUTO |
1796                         FE_CAN_QAM_16   |
1797                         FE_CAN_QAM_32   |
1798                         FE_CAN_QAM_64   |
1799                         FE_CAN_QAM_128  |
1800                         FE_CAN_QAM_256
1801         },
1802
1803         .release = bt8xx_dst_release,
1804         .init = bt8xx_dst_init,
1805         .tune = dst_tune_frontend,
1806         .set_frontend = dst_set_frontend,
1807         .get_frontend = dst_get_frontend,
1808         .get_frontend_algo = dst_get_tuning_algo,
1809         .read_status = dst_read_status,
1810         .read_signal_strength = dst_read_signal_strength,
1811         .read_snr = dst_read_snr,
1812 };
1813
1814 static const struct dvb_frontend_ops dst_atsc_ops = {
1815         .delsys = { SYS_ATSC },
1816         .info = {
1817                 .name = "DST ATSC",
1818                 .frequency_min_hz = 510 * MHz,
1819                 .frequency_max_hz = 858 * MHz,
1820                 .frequency_stepsize_hz = 62500,
1821                 .symbol_rate_min = 1000000,
1822                 .symbol_rate_max = 45000000,
1823                 .caps = FE_CAN_FEC_AUTO | FE_CAN_QAM_AUTO | FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
1824         },
1825
1826         .release = bt8xx_dst_release,
1827         .init = bt8xx_dst_init,
1828         .tune = dst_tune_frontend,
1829         .set_frontend = dst_set_frontend,
1830         .get_frontend = dst_get_frontend,
1831         .get_frontend_algo = dst_get_tuning_algo,
1832         .read_status = dst_read_status,
1833         .read_signal_strength = dst_read_signal_strength,
1834         .read_snr = dst_read_snr,
1835 };
1836
1837 MODULE_DESCRIPTION("DST DVB-S/T/C/ATSC Combo Frontend driver");
1838 MODULE_AUTHOR("Jamie Honan, Manu Abraham");
1839 MODULE_LICENSE("GPL");