drivers/staging/media/as102/as102_fe.c

   1 /*
   2  * Abilis Systems Single DVB-T Receiver
   3  * Copyright (C) 2008 Pierrick Hascoet <pierrick.hascoet@abilis.com>
   4  * Copyright (C) 2010 Devin Heitmueller <dheitmueller@kernellabs.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20 #include <linux/version.h>
  21
  22 #include "as102_drv.h"
  23 #include "as10x_types.h"
  24 #include "as10x_cmd.h"
  25
  26 extern int elna_enable;
  27
  28 #if defined(CONFIG_DVB_CORE) || defined(CONFIG_DVB_CORE_MODULE)
  29 static void as10x_fe_copy_tps_parameters(struct dvb_frontend_parameters *dst,
  30                                          struct as10x_tps *src);
  31
  32 static void as102_fe_copy_tune_parameters(struct as10x_tune_args *dst,
  33                                           struct dvb_frontend_parameters *src);
  34
  35 static void as102_fe_release(struct dvb_frontend *fe)
  36 {
  37         struct as102_dev_t *dev;
  38
  39         ENTER();
  40
  41         dev = (struct as102_dev_t *) fe->tuner_priv;
  42         if (dev == NULL)
  43                 return;
  44
  45 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19))
  46         if (mutex_lock_interruptible(&dev->bus_adap.lock))
  47                 return;
  48
  49         /* send abilis command: TURN_OFF */
  50         as10x_cmd_turn_off(&dev->bus_adap);
  51
  52         mutex_unlock(&dev->bus_adap.lock);
  53 #endif
  54
  55         /* release frontend callback ops */
  56         memset(&fe->ops, 0, sizeof(struct dvb_frontend_ops));
  57
  58         /* flush statistics */
  59         memset(&dev->demod_stats, 0, sizeof(dev->demod_stats));
  60         dev->signal_strength = 0;
  61         dev->ber = -1;
  62
  63         /* reset tuner private data */
  64 /*      fe->tuner_priv = NULL; */
  65
  66         LEAVE();
  67 }
  68
  69 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19))
  70 static int as102_fe_init(struct dvb_frontend *fe)
  71 {
  72         int ret = 0;
  73         struct as102_dev_t *dev;
  74
  75         ENTER();
  76
  77         dev = (struct as102_dev_t *) fe->tuner_priv;
  78         if (dev == NULL)
  79                 return -ENODEV;
  80
  81         if (mutex_lock_interruptible(&dev->bus_adap.lock))
  82                 return -EBUSY;
  83
  84         if (elna_enable)
  85                 ret = as10x_cmd_set_context(&dev->bus_adap, 1010, 0xC0);
  86
  87         /* send abilis command: TURN_ON */
  88         ret = as10x_cmd_turn_on(&dev->bus_adap);
  89
  90         mutex_unlock(&dev->bus_adap.lock);
  91
  92         LEAVE();
  93         return (ret < 0) ? -EINVAL : 0;
  94 }
  95 #endif
  96
  97 static int as102_fe_set_frontend(struct dvb_frontend *fe,
  98                                  struct dvb_frontend_parameters *params)
  99 {
 100         int ret = 0;
 101         struct as102_dev_t *dev;
 102         struct as10x_tune_args tune_args = { 0 };
 103
 104         ENTER();
 105
 106         dev = (struct as102_dev_t *) fe->tuner_priv;
 107         if (dev == NULL)
 108                 return -ENODEV;
 109
 110         if (mutex_lock_interruptible(&dev->bus_adap.lock))
 111                 return -EBUSY;
 112
 113         as102_fe_copy_tune_parameters(&tune_args, params);
 114
 115         /* send abilis command: SET_TUNE */
 116         ret =  as10x_cmd_set_tune(&dev->bus_adap, &tune_args);
 117         if (ret != 0)
 118                 dprintk(debug, "as10x_cmd_set_tune failed. (err = %d)\n", ret);
 119
 120         mutex_unlock(&dev->bus_adap.lock);
 121
 122         LEAVE();
 123         return (ret < 0) ? -EINVAL : 0;
 124 }
 125
 126 static int as102_fe_get_frontend(struct dvb_frontend *fe,
 127                                  struct dvb_frontend_parameters *p) {
 128         int ret = 0;
 129         struct as102_dev_t *dev;
 130         struct as10x_tps tps = { 0 };
 131
 132         ENTER();
 133
 134         dev = (struct as102_dev_t *) fe->tuner_priv;
 135         if (dev == NULL)
 136                 return -EINVAL;
 137
 138         if (mutex_lock_interruptible(&dev->bus_adap.lock))
 139                 return -EBUSY;
 140
 141         /* send abilis command: GET_TPS */
 142         ret = as10x_cmd_get_tps(&dev->bus_adap, &tps);
 143
 144         if (ret == 0)
 145                 as10x_fe_copy_tps_parameters(p, &tps);
 146
 147         mutex_unlock(&dev->bus_adap.lock);
 148
 149         LEAVE();
 150         return (ret < 0) ? -EINVAL : 0;
 151 }
 152
 153 static int as102_fe_get_tune_settings(struct dvb_frontend *fe,
 154                         struct dvb_frontend_tune_settings *settings) {
 155         ENTER();
 156
 157 #if 0
 158         dprintk(debug, "step_size    = %d\n", settings->step_size);
 159         dprintk(debug, "max_drift    = %d\n", settings->max_drift);
 160         dprintk(debug, "min_delay_ms = %d -> %d\n", settings->min_delay_ms,
 161                 1000);
 162 #endif
 163
 164         settings->min_delay_ms = 1000;
 165
 166         LEAVE();
 167         return 0;
 168 }
 169
 170
 171 static int as102_fe_read_status(struct dvb_frontend *fe, fe_status_t *status)
 172 {
 173         int ret = 0;
 174         struct as102_dev_t *dev;
 175         struct as10x_tune_status tstate = { 0 };
 176
 177         ENTER();
 178
 179         dev = (struct as102_dev_t *) fe->tuner_priv;
 180         if (dev == NULL)
 181                 return -ENODEV;
 182
 183         if (mutex_lock_interruptible(&dev->bus_adap.lock))
 184                 return -EBUSY;
 185
 186         /* send abilis command: GET_TUNE_STATUS */
 187         ret = as10x_cmd_get_tune_status(&dev->bus_adap, &tstate);
 188         if (ret < 0) {
 189                 dprintk(debug, "as10x_cmd_get_tune_status failed (err = %d)\n",
 190                         ret);
 191                 goto out;
 192         }
 193
 194         dev->signal_strength  = tstate.signal_strength;
 195         dev->ber  = tstate.BER;
 196
 197         switch (tstate.tune_state) {
 198         case TUNE_STATUS_SIGNAL_DVB_OK:
 199                 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER;
 200                 break;
 201         case TUNE_STATUS_STREAM_DETECTED:
 202                 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_SYNC;
 203                 break;
 204         case TUNE_STATUS_STREAM_TUNED:
 205                 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_SYNC |
 206                         FE_HAS_LOCK;
 207                 break;
 208         default:
 209                 *status = TUNE_STATUS_NOT_TUNED;
 210         }
 211
 212         dprintk(debug, "tuner status: 0x%02x, strength %d, per: %d, ber: %d\n",
 213                         tstate.tune_state, tstate.signal_strength,
 214                         tstate.PER, tstate.BER);
 215
 216         if (*status & FE_HAS_LOCK) {
 217                 if (as10x_cmd_get_demod_stats(&dev->bus_adap,
 218                         (struct as10x_demod_stats *) &dev->demod_stats) < 0) {
 219                         memset(&dev->demod_stats, 0, sizeof(dev->demod_stats));
 220                         dprintk(debug, "as10x_cmd_get_demod_stats failed "
 221                                 "(probably not tuned)\n");
 222                 } else {
 223                         dprintk(debug,
 224                                 "demod status: fc: 0x%08x, bad fc: 0x%08x, "
 225                                 "bytes corrected: 0x%08x , MER: 0x%04x\n",
 226                                 dev->demod_stats.frame_count,
 227                                 dev->demod_stats.bad_frame_count,
 228                                 dev->demod_stats.bytes_fixed_by_rs,
 229                                 dev->demod_stats.mer);
 230                 }
 231         } else {
 232                 memset(&dev->demod_stats, 0, sizeof(dev->demod_stats));
 233         }
 234
 235 out:
 236         mutex_unlock(&dev->bus_adap.lock);
 237         LEAVE();
 238         return ret;
 239 }
 240
 241 /*
 242  * Note:
 243  * - in AS102 SNR=MER
 244  *   - the SNR will be returned in linear terms, i.e. not in dB
 245  *   - the accuracy equals ±2dB for a SNR range from 4dB to 30dB
 246  *   - the accuracy is >2dB for SNR values outside this range
 247  */
 248 static int as102_fe_read_snr(struct dvb_frontend *fe, u16 *snr)
 249 {
 250         struct as102_dev_t *dev;
 251
 252         ENTER();
 253
 254         dev = (struct as102_dev_t *) fe->tuner_priv;
 255         if (dev == NULL)
 256                 return -ENODEV;
 257
 258         *snr = dev->demod_stats.mer;
 259
 260         LEAVE();
 261         return 0;
 262 }
 263
 264 static int as102_fe_read_ber(struct dvb_frontend *fe, u32 *ber)
 265 {
 266         struct as102_dev_t *dev;
 267
 268         ENTER();
 269
 270         dev = (struct as102_dev_t *) fe->tuner_priv;
 271         if (dev == NULL)
 272                 return -ENODEV;
 273
 274         *ber = dev->ber;
 275
 276         LEAVE();
 277         return 0;
 278 }
 279
 280 static int as102_fe_read_signal_strength(struct dvb_frontend *fe,
 281                                          u16 *strength)
 282 {
 283         struct as102_dev_t *dev;
 284
 285         ENTER();
 286
 287         dev = (struct as102_dev_t *) fe->tuner_priv;
 288         if (dev == NULL)
 289                 return -ENODEV;
 290
 291         *strength = (((0xffff * 400) * dev->signal_strength + 41000) * 2);
 292
 293         LEAVE();
 294         return 0;
 295 }
 296
 297 static int as102_fe_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
 298 {
 299         struct as102_dev_t *dev;
 300
 301         ENTER();
 302
 303         dev = (struct as102_dev_t *) fe->tuner_priv;
 304         if (dev == NULL)
 305                 return -ENODEV;
 306
 307         if (dev->demod_stats.has_started)
 308                 *ucblocks = dev->demod_stats.bad_frame_count;
 309         else
 310                 *ucblocks = 0;
 311
 312         LEAVE();
 313         return 0;
 314 }
 315
 316 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19))
 317 static int as102_fe_ts_bus_ctrl(struct dvb_frontend *fe, int acquire)
 318 {
 319         struct as102_dev_t *dev;
 320         int ret;
 321
 322         ENTER();
 323
 324         dev = (struct as102_dev_t *) fe->tuner_priv;
 325         if (dev == NULL)
 326                 return -ENODEV;
 327
 328         if (mutex_lock_interruptible(&dev->bus_adap.lock))
 329                 return -EBUSY;
 330
 331         if (acquire) {
 332                 if (elna_enable)
 333                         as10x_cmd_set_context(&dev->bus_adap, 1010, 0xC0);
 334
 335                 ret = as10x_cmd_turn_on(&dev->bus_adap);
 336         } else {
 337                 ret = as10x_cmd_turn_off(&dev->bus_adap);
 338         }
 339
 340         mutex_unlock(&dev->bus_adap.lock);
 341
 342         LEAVE();
 343         return ret;
 344 }
 345 #endif
 346
 347 static struct dvb_frontend_ops as102_fe_ops = {
 348         .info = {
 349                 .name                   = "Unknown AS102 device",
 350                 .type                   = FE_OFDM,
 351                 .frequency_min          = 174000000,
 352                 .frequency_max          = 862000000,
 353                 .frequency_stepsize     = 166667,
 354                 .caps = FE_CAN_INVERSION_AUTO
 355                         | FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4
 356                         | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO
 357                         | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QPSK
 358                         | FE_CAN_QAM_AUTO
 359                         | FE_CAN_TRANSMISSION_MODE_AUTO
 360                         | FE_CAN_GUARD_INTERVAL_AUTO
 361                         | FE_CAN_HIERARCHY_AUTO
 362                         | FE_CAN_RECOVER
 363                         | FE_CAN_MUTE_TS
 364         },
 365
 366         .set_frontend           = as102_fe_set_frontend,
 367         .get_frontend           = as102_fe_get_frontend,
 368         .get_tune_settings      = as102_fe_get_tune_settings,
 369
 370
 371         .read_status            = as102_fe_read_status,
 372         .read_snr               = as102_fe_read_snr,
 373         .read_ber               = as102_fe_read_ber,
 374         .read_signal_strength   = as102_fe_read_signal_strength,
 375         .read_ucblocks          = as102_fe_read_ucblocks,
 376
 377 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19))
 378         .ts_bus_ctrl            = as102_fe_ts_bus_ctrl,
 379 #else
 380         .release                = as102_fe_release,
 381         .init                   = as102_fe_init,
 382 #endif
 383 };
 384
 385 int as102_dvb_unregister_fe(struct dvb_frontend *fe)
 386 {
 387         /* unregister frontend */
 388         dvb_unregister_frontend(fe);
 389
 390 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19))
 391         /* detach frontend */
 392         dvb_frontend_detach(fe);
 393 #endif
 394         return 0;
 395 }
 396
 397 int as102_dvb_register_fe(struct as102_dev_t *as102_dev,
 398                           struct dvb_frontend *dvb_fe)
 399 {
 400         int errno;
 401         struct dvb_adapter *dvb_adap;
 402
 403         if (as102_dev == NULL)
 404                 return -EINVAL;
 405
 406         /* extract dvb_adapter */
 407         dvb_adap = &as102_dev->dvb_adap;
 408
 409         /* init frontend callback ops */
 410         memcpy(&dvb_fe->ops, &as102_fe_ops, sizeof(struct dvb_frontend_ops));
 411         strncpy(dvb_fe->ops.info.name, as102_dev->name,
 412                 sizeof(dvb_fe->ops.info.name));
 413
 414         /* register dbvb frontend */
 415         errno = dvb_register_frontend(dvb_adap, dvb_fe);
 416         if (errno == 0)
 417                 dvb_fe->tuner_priv = as102_dev;
 418
 419         return errno;
 420 }
 421
 422 static void as10x_fe_copy_tps_parameters(struct dvb_frontend_parameters *dst,
 423                                          struct as10x_tps *as10x_tps)
 424 {
 425
 426         struct dvb_ofdm_parameters *fe_tps = &dst->u.ofdm;
 427
 428         /* extract consteallation */
 429         switch (as10x_tps->constellation) {
 430         case CONST_QPSK:
 431                 fe_tps->constellation = QPSK;
 432                 break;
 433         case CONST_QAM16:
 434                 fe_tps->constellation = QAM_16;
 435                 break;
 436         case CONST_QAM64:
 437                 fe_tps->constellation = QAM_64;
 438                 break;
 439         }
 440
 441         /* extract hierarchy */
 442         switch (as10x_tps->hierarchy) {
 443         case HIER_NONE:
 444                 fe_tps->hierarchy_information = HIERARCHY_NONE;
 445                 break;
 446         case HIER_ALPHA_1:
 447                 fe_tps->hierarchy_information = HIERARCHY_1;
 448                 break;
 449         case HIER_ALPHA_2:
 450                 fe_tps->hierarchy_information = HIERARCHY_2;
 451                 break;
 452         case HIER_ALPHA_4:
 453                 fe_tps->hierarchy_information = HIERARCHY_4;
 454                 break;
 455         }
 456
 457         /* extract code rate HP */
 458         switch (as10x_tps->code_rate_HP) {
 459         case CODE_RATE_1_2:
 460                 fe_tps->code_rate_HP = FEC_1_2;
 461                 break;
 462         case CODE_RATE_2_3:
 463                 fe_tps->code_rate_HP = FEC_2_3;
 464                 break;
 465         case CODE_RATE_3_4:
 466                 fe_tps->code_rate_HP = FEC_3_4;
 467                 break;
 468         case CODE_RATE_5_6:
 469                 fe_tps->code_rate_HP = FEC_5_6;
 470                 break;
 471         case CODE_RATE_7_8:
 472                 fe_tps->code_rate_HP = FEC_7_8;
 473                 break;
 474         }
 475
 476         /* extract code rate LP */
 477         switch (as10x_tps->code_rate_LP) {
 478         case CODE_RATE_1_2:
 479                 fe_tps->code_rate_LP = FEC_1_2;
 480                 break;
 481         case CODE_RATE_2_3:
 482                 fe_tps->code_rate_LP = FEC_2_3;
 483                 break;
 484         case CODE_RATE_3_4:
 485                 fe_tps->code_rate_LP = FEC_3_4;
 486                 break;
 487         case CODE_RATE_5_6:
 488                 fe_tps->code_rate_LP = FEC_5_6;
 489                 break;
 490         case CODE_RATE_7_8:
 491                 fe_tps->code_rate_LP = FEC_7_8;
 492                 break;
 493         }
 494
 495         /* extract guard interval */
 496         switch (as10x_tps->guard_interval) {
 497         case GUARD_INT_1_32:
 498                 fe_tps->guard_interval = GUARD_INTERVAL_1_32;
 499                 break;
 500         case GUARD_INT_1_16:
 501                 fe_tps->guard_interval = GUARD_INTERVAL_1_16;
 502                 break;
 503         case GUARD_INT_1_8:
 504                 fe_tps->guard_interval = GUARD_INTERVAL_1_8;
 505                 break;
 506         case GUARD_INT_1_4:
 507                 fe_tps->guard_interval = GUARD_INTERVAL_1_4;
 508                 break;
 509         }
 510
 511         /* extract transmission mode */
 512         switch (as10x_tps->transmission_mode) {
 513         case TRANS_MODE_2K:
 514                 fe_tps->transmission_mode = TRANSMISSION_MODE_2K;
 515                 break;
 516         case TRANS_MODE_8K:
 517                 fe_tps->transmission_mode = TRANSMISSION_MODE_8K;
 518                 break;
 519         }
 520 }
 521
 522 static uint8_t as102_fe_get_code_rate(fe_code_rate_t arg)
 523 {
 524         uint8_t c;
 525
 526         switch (arg) {
 527         case FEC_1_2:
 528                 c = CODE_RATE_1_2;
 529                 break;
 530         case FEC_2_3:
 531                 c = CODE_RATE_2_3;
 532                 break;
 533         case FEC_3_4:
 534                 c = CODE_RATE_3_4;
 535                 break;
 536         case FEC_5_6:
 537                 c = CODE_RATE_5_6;
 538                 break;
 539         case FEC_7_8:
 540                 c = CODE_RATE_7_8;
 541                 break;
 542         default:
 543                 c = CODE_RATE_UNKNOWN;
 544                 break;
 545         }
 546
 547         return c;
 548 }
 549
 550 static void as102_fe_copy_tune_parameters(struct as10x_tune_args *tune_args,
 551                           struct dvb_frontend_parameters *params)
 552 {
 553
 554         /* set frequency */
 555         tune_args->freq = params->frequency / 1000;
 556
 557         /* fix interleaving_mode */
 558         tune_args->interleaving_mode = INTLV_NATIVE;
 559
 560         switch (params->u.ofdm.bandwidth) {
 561         case BANDWIDTH_8_MHZ:
 562                 tune_args->bandwidth = BW_8_MHZ;
 563                 break;
 564         case BANDWIDTH_7_MHZ:
 565                 tune_args->bandwidth = BW_7_MHZ;
 566                 break;
 567         case BANDWIDTH_6_MHZ:
 568                 tune_args->bandwidth = BW_6_MHZ;
 569                 break;
 570         default:
 571                 tune_args->bandwidth = BW_8_MHZ;
 572         }
 573
 574         switch (params->u.ofdm.guard_interval) {
 575         case GUARD_INTERVAL_1_32:
 576                 tune_args->guard_interval = GUARD_INT_1_32;
 577                 break;
 578         case GUARD_INTERVAL_1_16:
 579                 tune_args->guard_interval = GUARD_INT_1_16;
 580                 break;
 581         case GUARD_INTERVAL_1_8:
 582                 tune_args->guard_interval = GUARD_INT_1_8;
 583                 break;
 584         case GUARD_INTERVAL_1_4:
 585                 tune_args->guard_interval = GUARD_INT_1_4;
 586                 break;
 587         case GUARD_INTERVAL_AUTO:
 588         default:
 589                 tune_args->guard_interval = GUARD_UNKNOWN;
 590                 break;
 591         }
 592
 593         switch (params->u.ofdm.constellation) {
 594         case QPSK:
 595                 tune_args->constellation = CONST_QPSK;
 596                 break;
 597         case QAM_16:
 598                 tune_args->constellation = CONST_QAM16;
 599                 break;
 600         case QAM_64:
 601                 tune_args->constellation = CONST_QAM64;
 602                 break;
 603         default:
 604                 tune_args->constellation = CONST_UNKNOWN;
 605                 break;
 606         }
 607
 608         switch (params->u.ofdm.transmission_mode) {
 609         case TRANSMISSION_MODE_2K:
 610                 tune_args->transmission_mode = TRANS_MODE_2K;
 611                 break;
 612         case TRANSMISSION_MODE_8K:
 613                 tune_args->transmission_mode = TRANS_MODE_8K;
 614                 break;
 615         default:
 616                 tune_args->transmission_mode = TRANS_MODE_UNKNOWN;
 617         }
 618
 619         switch (params->u.ofdm.hierarchy_information) {
 620         case HIERARCHY_NONE:
 621                 tune_args->hierarchy = HIER_NONE;
 622                 break;
 623         case HIERARCHY_1:
 624                 tune_args->hierarchy = HIER_ALPHA_1;
 625                 break;
 626         case HIERARCHY_2:
 627                 tune_args->hierarchy = HIER_ALPHA_2;
 628                 break;
 629         case HIERARCHY_4:
 630                 tune_args->hierarchy = HIER_ALPHA_4;
 631                 break;
 632         case HIERARCHY_AUTO:
 633                 tune_args->hierarchy = HIER_UNKNOWN;
 634                 break;
 635         }
 636
 637         dprintk(debug, "tuner parameters: freq: %d  bw: 0x%02x  gi: 0x%02x\n",
 638                         params->frequency,
 639                         tune_args->bandwidth,
 640                         tune_args->guard_interval);
 641
 642         /*
 643          * Detect a hierarchy selection
 644          * if HP/LP are both set to FEC_NONE, HP will be selected.
 645          */
 646         if ((tune_args->hierarchy != HIER_NONE) &&
 647                        ((params->u.ofdm.code_rate_LP == FEC_NONE) ||
 648                         (params->u.ofdm.code_rate_HP == FEC_NONE))) {
 649
 650                 if (params->u.ofdm.code_rate_LP == FEC_NONE) {
 651                         tune_args->hier_select = HIER_HIGH_PRIORITY;
 652                         tune_args->code_rate =
 653                            as102_fe_get_code_rate(params->u.ofdm.code_rate_HP);
 654                 }
 655
 656                 if (params->u.ofdm.code_rate_HP == FEC_NONE) {
 657                         tune_args->hier_select = HIER_LOW_PRIORITY;
 658                         tune_args->code_rate =
 659                            as102_fe_get_code_rate(params->u.ofdm.code_rate_LP);
 660                 }
 661
 662                 dprintk(debug, "\thierarchy: 0x%02x  "
 663                                 "selected: %s  code_rate_%s: 0x%02x\n",
 664                         tune_args->hierarchy,
 665                         tune_args->hier_select == HIER_HIGH_PRIORITY ?
 666                         "HP" : "LP",
 667                         tune_args->hier_select == HIER_HIGH_PRIORITY ?
 668                         "HP" : "LP",
 669                         tune_args->code_rate);
 670         } else {
 671                 tune_args->code_rate =
 672                         as102_fe_get_code_rate(params->u.ofdm.code_rate_HP);
 673         }
 674 }
 675 #endif
 676
 677 /* EOF - vim: set textwidth=80 ts=8 sw=8 sts=8 noet: */