← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/media/dvb/dvb-core/dvb_frontend.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/dvb/dvb-core/dvb_frontend.c
105
105
 
106
106
        /* thread/frontend values */
107
107
        struct dvb_device *dvbdev;
108
 
        struct dvb_frontend_parameters parameters;
 
108
        struct dvb_frontend_parameters parameters_in;
 
109
        struct dvb_frontend_parameters parameters_out;
109
110
        struct dvb_fe_events events;
110
111
        struct semaphore sem;
111
112
        struct list_head list_head;
160
161
 
161
162
        e = &events->events[events->eventw];
162
163
 
163
 
        memcpy (&e->parameters, &fepriv->parameters,
164
 
                sizeof (struct dvb_frontend_parameters));
165
 
 
166
164
        if (status & FE_HAS_LOCK)
167
165
                if (fe->ops.get_frontend)
168
 
                        fe->ops.get_frontend(fe, &e->parameters);
 
166
                        fe->ops.get_frontend(fe, &fepriv->parameters_out);
 
167
 
 
168
        e->parameters = fepriv->parameters_out;
169
169
 
170
170
        events->eventw = wp;
171
171
 
277
277
        int ready = 0;
278
278
        int fe_set_err = 0;
279
279
        struct dvb_frontend_private *fepriv = fe->frontend_priv;
280
 
        int original_inversion = fepriv->parameters.inversion;
281
 
        u32 original_frequency = fepriv->parameters.frequency;
 
280
        int original_inversion = fepriv->parameters_in.inversion;
 
281
        u32 original_frequency = fepriv->parameters_in.frequency;
282
282
 
283
283
        /* are we using autoinversion? */
284
284
        autoinversion = ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) &&
285
 
                         (fepriv->parameters.inversion == INVERSION_AUTO));
 
285
                         (fepriv->parameters_in.inversion == INVERSION_AUTO));
286
286
 
287
287
        /* setup parameters correctly */
288
288
        while(!ready) {
348
348
                fepriv->auto_step, fepriv->auto_sub_step, fepriv->started_auto_step);
349
349
 
350
350
        /* set the frontend itself */
351
 
        fepriv->parameters.frequency += fepriv->lnb_drift;
 
351
        fepriv->parameters_in.frequency += fepriv->lnb_drift;
352
352
        if (autoinversion)
353
 
                fepriv->parameters.inversion = fepriv->inversion;
 
353
                fepriv->parameters_in.inversion = fepriv->inversion;
354
354
        if (fe->ops.set_frontend)
355
 
                fe_set_err = fe->ops.set_frontend(fe, &fepriv->parameters);
 
355
                fe_set_err = fe->ops.set_frontend(fe, &fepriv->parameters_in);
 
356
        fepriv->parameters_out = fepriv->parameters_in;
356
357
        if (fe_set_err < 0) {
357
358
                fepriv->state = FESTATE_ERROR;
358
359
                return fe_set_err;
359
360
        }
360
361
 
361
 
        fepriv->parameters.frequency = original_frequency;
362
 
        fepriv->parameters.inversion = original_inversion;
 
362
        fepriv->parameters_in.frequency = original_frequency;
 
363
        fepriv->parameters_in.inversion = original_inversion;
363
364
 
364
365
        fepriv->auto_sub_step++;
365
366
        return 0;
383
384
                if (fepriv->state & FESTATE_RETUNE) {
384
385
                        if (fe->ops.set_frontend)
385
386
                                retval = fe->ops.set_frontend(fe,
386
 
                                                        &fepriv->parameters);
 
387
                                                        &fepriv->parameters_in);
 
388
                        fepriv->parameters_out = fepriv->parameters_in;
387
389
                        if (retval < 0)
388
390
                                fepriv->state = FESTATE_ERROR;
389
391
                        else
413
415
 
414
416
                /* if we're tuned, then we have determined the correct inversion */
415
417
                if ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) &&
416
 
                    (fepriv->parameters.inversion == INVERSION_AUTO)) {
417
 
                        fepriv->parameters.inversion = fepriv->inversion;
 
418
                    (fepriv->parameters_in.inversion == INVERSION_AUTO)) {
 
419
                        fepriv->parameters_in.inversion = fepriv->inversion;
418
420
                }
419
421
                return;
420
422
        }
594
596
 
595
597
                                if (fepriv->state & FESTATE_RETUNE) {
596
598
                                        dprintk("%s: Retune requested, FESTATE_RETUNE\n", __func__);
597
 
                                        params = &fepriv->parameters;
 
599
                                        params = &fepriv->parameters_in;
598
600
                                        fepriv->state = FESTATE_TUNED;
599
601
                                }
600
602
 
601
603
                                if (fe->ops.tune)
602
604
                                        fe->ops.tune(fe, params, fepriv->tune_mode_flags, &fepriv->delay, &s);
 
605
                                if (params)
 
606
                                        fepriv->parameters_out = *params;
603
607
 
604
608
                                if (s != fepriv->status && !(fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT)) {
605
609
                                        dprintk("%s: state changed, adding current state\n", __func__);
612
616
                                dvb_frontend_swzigzag(fe);
613
617
                                break;
614
618
                        case DVBFE_ALGO_CUSTOM:
615
 
                                params = NULL; /* have we been asked to RETUNE ?        */
616
619
                                dprintk("%s: Frontend ALGO = DVBFE_ALGO_CUSTOM, state=%d\n", __func__, fepriv->state);
617
620
                                if (fepriv->state & FESTATE_RETUNE) {
618
621
                                        dprintk("%s: Retune requested, FESTAT_RETUNE\n", __func__);
619
 
                                        params = &fepriv->parameters;
620
622
                                        fepriv->state = FESTATE_TUNED;
621
623
                                }
622
624
                                /* Case where we are going to search for a carrier
625
627
                                 */
626
628
                                if (fepriv->algo_status & DVBFE_ALGO_SEARCH_AGAIN) {
627
629
                                        if (fe->ops.search) {
628
 
                                                fepriv->algo_status = fe->ops.search(fe, &fepriv->parameters);
 
630
                                                fepriv->algo_status = fe->ops.search(fe, &fepriv->parameters_in);
629
631
                                                /* We did do a search as was requested, the flags are
630
632
                                                 * now unset as well and has the flags wrt to search.
631
633
                                                 */
636
638
                                /* Track the carrier if the search was successful */
637
639
                                if (fepriv->algo_status == DVBFE_ALGO_SEARCH_SUCCESS) {
638
640
                                        if (fe->ops.track)
639
 
                                                fe->ops.track(fe, &fepriv->parameters);
 
641
                                                fe->ops.track(fe, &fepriv->parameters_in);
640
642
                                } else {
641
643
                                        fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN;
642
644
                                        fepriv->delay = HZ / 2;
643
645
                                }
 
646
                                fepriv->parameters_out = fepriv->parameters_in;
644
647
                                fe->ops.read_status(fe, &s);
645
648
                                if (s != fepriv->status) {
646
649
                                        dvb_frontend_add_event(fe, s); /* update event list */
860
863
 
861
864
static int dvb_frontend_clear_cache(struct dvb_frontend *fe)
862
865
{
 
866
        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
863
867
        int i;
864
868
 
865
 
        memset(&(fe->dtv_property_cache), 0,
866
 
                        sizeof(struct dtv_frontend_properties));
867
 
 
868
 
        fe->dtv_property_cache.state = DTV_CLEAR;
869
 
        fe->dtv_property_cache.delivery_system = SYS_UNDEFINED;
870
 
        fe->dtv_property_cache.inversion = INVERSION_AUTO;
871
 
        fe->dtv_property_cache.fec_inner = FEC_AUTO;
872
 
        fe->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_AUTO;
873
 
        fe->dtv_property_cache.bandwidth_hz = BANDWIDTH_AUTO;
874
 
        fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_AUTO;
875
 
        fe->dtv_property_cache.hierarchy = HIERARCHY_AUTO;
876
 
        fe->dtv_property_cache.symbol_rate = QAM_AUTO;
877
 
        fe->dtv_property_cache.code_rate_HP = FEC_AUTO;
878
 
        fe->dtv_property_cache.code_rate_LP = FEC_AUTO;
879
 
 
880
 
        fe->dtv_property_cache.isdbt_partial_reception = -1;
881
 
        fe->dtv_property_cache.isdbt_sb_mode = -1;
882
 
        fe->dtv_property_cache.isdbt_sb_subchannel = -1;
883
 
        fe->dtv_property_cache.isdbt_sb_segment_idx = -1;
884
 
        fe->dtv_property_cache.isdbt_sb_segment_count = -1;
885
 
        fe->dtv_property_cache.isdbt_layer_enabled = 0x7;
 
869
        memset(c, 0, sizeof(struct dtv_frontend_properties));
 
870
 
 
871
        c->state = DTV_CLEAR;
 
872
        c->delivery_system = SYS_UNDEFINED;
 
873
        c->inversion = INVERSION_AUTO;
 
874
        c->fec_inner = FEC_AUTO;
 
875
        c->transmission_mode = TRANSMISSION_MODE_AUTO;
 
876
        c->bandwidth_hz = BANDWIDTH_AUTO;
 
877
        c->guard_interval = GUARD_INTERVAL_AUTO;
 
878
        c->hierarchy = HIERARCHY_AUTO;
 
879
        c->symbol_rate = QAM_AUTO;
 
880
        c->code_rate_HP = FEC_AUTO;
 
881
        c->code_rate_LP = FEC_AUTO;
 
882
 
 
883
        c->isdbt_partial_reception = -1;
 
884
        c->isdbt_sb_mode = -1;
 
885
        c->isdbt_sb_subchannel = -1;
 
886
        c->isdbt_sb_segment_idx = -1;
 
887
        c->isdbt_sb_segment_count = -1;
 
888
        c->isdbt_layer_enabled = 0x7;
886
889
        for (i = 0; i < 3; i++) {
887
 
                fe->dtv_property_cache.layer[i].fec = FEC_AUTO;
888
 
                fe->dtv_property_cache.layer[i].modulation = QAM_AUTO;
889
 
                fe->dtv_property_cache.layer[i].interleaving = -1;
890
 
                fe->dtv_property_cache.layer[i].segment_count = -1;
 
890
                c->layer[i].fec = FEC_AUTO;
 
891
                c->layer[i].modulation = QAM_AUTO;
 
892
                c->layer[i].interleaving = -1;
 
893
                c->layer[i].segment_count = -1;
891
894
        }
892
895
 
893
896
        return 0;
1020
1023
 * it's being used for the legacy or new API, reducing code and complexity.
1021
1024
 */
1022
1025
static void dtv_property_cache_sync(struct dvb_frontend *fe,
1023
 
                                    struct dvb_frontend_parameters *p)
 
1026
                                    struct dtv_frontend_properties *c,
 
1027
                                    const struct dvb_frontend_parameters *p)
1024
1028
{
1025
 
        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1026
 
 
1027
1029
        c->frequency = p->frequency;
1028
1030
        c->inversion = p->inversion;
1029
1031
 
1074
1076
 */
1075
1077
static void dtv_property_legacy_params_sync(struct dvb_frontend *fe)
1076
1078
{
1077
 
        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 
1079
        const struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1078
1080
        struct dvb_frontend_private *fepriv = fe->frontend_priv;
1079
 
        struct dvb_frontend_parameters *p = &fepriv->parameters;
 
1081
        struct dvb_frontend_parameters *p = &fepriv->parameters_in;
1080
1082
 
1081
1083
        p->frequency = c->frequency;
1082
1084
        p->inversion = c->inversion;
1086
1088
                dprintk("%s() Preparing QPSK req\n", __func__);
1087
1089
                p->u.qpsk.symbol_rate = c->symbol_rate;
1088
1090
                p->u.qpsk.fec_inner = c->fec_inner;
1089
 
                c->delivery_system = SYS_DVBS;
1090
1091
                break;
1091
1092
        case FE_QAM:
1092
1093
                dprintk("%s() Preparing QAM req\n", __func__);
1093
1094
                p->u.qam.symbol_rate = c->symbol_rate;
1094
1095
                p->u.qam.fec_inner = c->fec_inner;
1095
1096
                p->u.qam.modulation = c->modulation;
1096
 
                c->delivery_system = SYS_DVBC_ANNEX_AC;
1097
1097
                break;
1098
1098
        case FE_OFDM:
1099
1099
                dprintk("%s() Preparing OFDM req\n", __func__);
1111
1111
                p->u.ofdm.transmission_mode = c->transmission_mode;
1112
1112
                p->u.ofdm.guard_interval = c->guard_interval;
1113
1113
                p->u.ofdm.hierarchy_information = c->hierarchy;
1114
 
                c->delivery_system = SYS_DVBT;
1115
1114
                break;
1116
1115
        case FE_ATSC:
1117
1116
                dprintk("%s() Preparing VSB req\n", __func__);
1118
1117
                p->u.vsb.modulation = c->modulation;
1119
 
                if ((c->modulation == VSB_8) || (c->modulation == VSB_16))
1120
 
                        c->delivery_system = SYS_ATSC;
1121
 
                else
1122
 
                        c->delivery_system = SYS_DVBC_ANNEX_B;
1123
1118
                break;
1124
1119
        }
1125
1120
}
1129
1124
 */
1130
1125
static void dtv_property_adv_params_sync(struct dvb_frontend *fe)
1131
1126
{
1132
 
        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 
1127
        const struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1133
1128
        struct dvb_frontend_private *fepriv = fe->frontend_priv;
1134
 
        struct dvb_frontend_parameters *p = &fepriv->parameters;
 
1129
        struct dvb_frontend_parameters *p = &fepriv->parameters_in;
1135
1130
 
1136
1131
        p->frequency = c->frequency;
1137
1132
        p->inversion = c->inversion;
1148
1143
                break;
1149
1144
        }
1150
1145
 
1151
 
        if(c->delivery_system == SYS_ISDBT) {
1152
 
                /* Fake out a generic DVB-T request so we pass validation in the ioctl */
1153
 
                p->frequency = c->frequency;
1154
 
                p->inversion = c->inversion;
 
1146
        /* Fake out a generic DVB-T request so we pass validation in the ioctl */
 
1147
        if ((c->delivery_system == SYS_ISDBT) ||
 
1148
            (c->delivery_system == SYS_DVBT2)) {
1155
1149
                p->u.ofdm.constellation = QAM_AUTO;
1156
1150
                p->u.ofdm.code_rate_HP = FEC_AUTO;
1157
1151
                p->u.ofdm.code_rate_LP = FEC_AUTO;
1171
1165
 
1172
1166
static void dtv_property_cache_submit(struct dvb_frontend *fe)
1173
1167
{
1174
 
        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 
1168
        const struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1175
1169
 
1176
1170
        /* For legacy delivery systems we don't need the delivery_system to
1177
1171
         * be specified, but we populate the older structures from the cache
1204
1198
                                    struct dtv_property *tvp,
1205
1199
                                    struct file *file)
1206
1200
{
1207
 
        int r = 0;
1208
 
 
1209
 
        /* Allow the frontend to validate incoming properties */
1210
 
        if (fe->ops.get_property)
1211
 
                r = fe->ops.get_property(fe, tvp);
1212
 
 
1213
 
        if (r < 0)
1214
 
                return r;
 
1201
        const struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 
1202
        struct dvb_frontend_private *fepriv = fe->frontend_priv;
 
1203
        struct dtv_frontend_properties cdetected;
 
1204
        int r;
 
1205
 
 
1206
        /*
 
1207
         * If the driver implements a get_frontend function, then convert
 
1208
         * detected parameters to S2API properties.
 
1209
         */
 
1210
        if (fe->ops.get_frontend) {
 
1211
                cdetected = *c;
 
1212
                dtv_property_cache_sync(fe, &cdetected, &fepriv->parameters_out);
 
1213
                c = &cdetected;
 
1214
        }
1215
1215
 
1216
1216
        switch(tvp->cmd) {
1217
1217
        case DTV_FREQUENCY:
1218
 
                tvp->u.data = fe->dtv_property_cache.frequency;
 
1218
                tvp->u.data = c->frequency;
1219
1219
                break;
1220
1220
        case DTV_MODULATION:
1221
 
                tvp->u.data = fe->dtv_property_cache.modulation;
 
1221
                tvp->u.data = c->modulation;
1222
1222
                break;
1223
1223
        case DTV_BANDWIDTH_HZ:
1224
 
                tvp->u.data = fe->dtv_property_cache.bandwidth_hz;
 
1224
                tvp->u.data = c->bandwidth_hz;
1225
1225
                break;
1226
1226
        case DTV_INVERSION:
1227
 
                tvp->u.data = fe->dtv_property_cache.inversion;
 
1227
                tvp->u.data = c->inversion;
1228
1228
                break;
1229
1229
        case DTV_SYMBOL_RATE:
1230
 
                tvp->u.data = fe->dtv_property_cache.symbol_rate;
 
1230
                tvp->u.data = c->symbol_rate;
1231
1231
                break;
1232
1232
        case DTV_INNER_FEC:
1233
 
                tvp->u.data = fe->dtv_property_cache.fec_inner;
 
1233
                tvp->u.data = c->fec_inner;
1234
1234
                break;
1235
1235
        case DTV_PILOT:
1236
 
                tvp->u.data = fe->dtv_property_cache.pilot;
 
1236
                tvp->u.data = c->pilot;
1237
1237
                break;
1238
1238
        case DTV_ROLLOFF:
1239
 
                tvp->u.data = fe->dtv_property_cache.rolloff;
 
1239
                tvp->u.data = c->rolloff;
1240
1240
                break;
1241
1241
        case DTV_DELIVERY_SYSTEM:
1242
 
                tvp->u.data = fe->dtv_property_cache.delivery_system;
 
1242
                tvp->u.data = c->delivery_system;
1243
1243
                break;
1244
1244
        case DTV_VOLTAGE:
1245
 
                tvp->u.data = fe->dtv_property_cache.voltage;
 
1245
                tvp->u.data = c->voltage;
1246
1246
                break;
1247
1247
        case DTV_TONE:
1248
 
                tvp->u.data = fe->dtv_property_cache.sectone;
 
1248
                tvp->u.data = c->sectone;
1249
1249
                break;
1250
1250
        case DTV_API_VERSION:
1251
1251
                tvp->u.data = (DVB_API_VERSION << 8) | DVB_API_VERSION_MINOR;
1252
1252
                break;
1253
1253
        case DTV_CODE_RATE_HP:
1254
 
                tvp->u.data = fe->dtv_property_cache.code_rate_HP;
 
1254
                tvp->u.data = c->code_rate_HP;
1255
1255
                break;
1256
1256
        case DTV_CODE_RATE_LP:
1257
 
                tvp->u.data = fe->dtv_property_cache.code_rate_LP;
 
1257
                tvp->u.data = c->code_rate_LP;
1258
1258
                break;
1259
1259
        case DTV_GUARD_INTERVAL:
1260
 
                tvp->u.data = fe->dtv_property_cache.guard_interval;
 
1260
                tvp->u.data = c->guard_interval;
1261
1261
                break;
1262
1262
        case DTV_TRANSMISSION_MODE:
1263
 
                tvp->u.data = fe->dtv_property_cache.transmission_mode;
 
1263
                tvp->u.data = c->transmission_mode;
1264
1264
                break;
1265
1265
        case DTV_HIERARCHY:
1266
 
                tvp->u.data = fe->dtv_property_cache.hierarchy;
 
1266
                tvp->u.data = c->hierarchy;
1267
1267
                break;
1268
1268
 
1269
1269
        /* ISDB-T Support here */
1270
1270
        case DTV_ISDBT_PARTIAL_RECEPTION:
1271
 
                tvp->u.data = fe->dtv_property_cache.isdbt_partial_reception;
 
1271
                tvp->u.data = c->isdbt_partial_reception;
1272
1272
                break;
1273
1273
        case DTV_ISDBT_SOUND_BROADCASTING:
1274
 
                tvp->u.data = fe->dtv_property_cache.isdbt_sb_mode;
 
1274
                tvp->u.data = c->isdbt_sb_mode;
1275
1275
                break;
1276
1276
        case DTV_ISDBT_SB_SUBCHANNEL_ID:
1277
 
                tvp->u.data = fe->dtv_property_cache.isdbt_sb_subchannel;
 
1277
                tvp->u.data = c->isdbt_sb_subchannel;
1278
1278
                break;
1279
1279
        case DTV_ISDBT_SB_SEGMENT_IDX:
1280
 
                tvp->u.data = fe->dtv_property_cache.isdbt_sb_segment_idx;
 
1280
                tvp->u.data = c->isdbt_sb_segment_idx;
1281
1281
                break;
1282
1282
        case DTV_ISDBT_SB_SEGMENT_COUNT:
1283
 
                tvp->u.data = fe->dtv_property_cache.isdbt_sb_segment_count;
 
1283
                tvp->u.data = c->isdbt_sb_segment_count;
1284
1284
                break;
1285
1285
        case DTV_ISDBT_LAYER_ENABLED:
1286
 
                tvp->u.data = fe->dtv_property_cache.isdbt_layer_enabled;
 
1286
                tvp->u.data = c->isdbt_layer_enabled;
1287
1287
                break;
1288
1288
        case DTV_ISDBT_LAYERA_FEC:
1289
 
                tvp->u.data = fe->dtv_property_cache.layer[0].fec;
 
1289
                tvp->u.data = c->layer[0].fec;
1290
1290
                break;
1291
1291
        case DTV_ISDBT_LAYERA_MODULATION:
1292
 
                tvp->u.data = fe->dtv_property_cache.layer[0].modulation;
 
1292
                tvp->u.data = c->layer[0].modulation;
1293
1293
                break;
1294
1294
        case DTV_ISDBT_LAYERA_SEGMENT_COUNT:
1295
 
                tvp->u.data = fe->dtv_property_cache.layer[0].segment_count;
 
1295
                tvp->u.data = c->layer[0].segment_count;
1296
1296
                break;
1297
1297
        case DTV_ISDBT_LAYERA_TIME_INTERLEAVING:
1298
 
                tvp->u.data = fe->dtv_property_cache.layer[0].interleaving;
 
1298
                tvp->u.data = c->layer[0].interleaving;
1299
1299
                break;
1300
1300
        case DTV_ISDBT_LAYERB_FEC:
1301
 
                tvp->u.data = fe->dtv_property_cache.layer[1].fec;
 
1301
                tvp->u.data = c->layer[1].fec;
1302
1302
                break;
1303
1303
        case DTV_ISDBT_LAYERB_MODULATION:
1304
 
                tvp->u.data = fe->dtv_property_cache.layer[1].modulation;
 
1304
                tvp->u.data = c->layer[1].modulation;
1305
1305
                break;
1306
1306
        case DTV_ISDBT_LAYERB_SEGMENT_COUNT:
1307
 
                tvp->u.data = fe->dtv_property_cache.layer[1].segment_count;
 
1307
                tvp->u.data = c->layer[1].segment_count;
1308
1308
                break;
1309
1309
        case DTV_ISDBT_LAYERB_TIME_INTERLEAVING:
1310
 
                tvp->u.data = fe->dtv_property_cache.layer[1].interleaving;
 
1310
                tvp->u.data = c->layer[1].interleaving;
1311
1311
                break;
1312
1312
        case DTV_ISDBT_LAYERC_FEC:
1313
 
                tvp->u.data = fe->dtv_property_cache.layer[2].fec;
 
1313
                tvp->u.data = c->layer[2].fec;
1314
1314
                break;
1315
1315
        case DTV_ISDBT_LAYERC_MODULATION:
1316
 
                tvp->u.data = fe->dtv_property_cache.layer[2].modulation;
 
1316
                tvp->u.data = c->layer[2].modulation;
1317
1317
                break;
1318
1318
        case DTV_ISDBT_LAYERC_SEGMENT_COUNT:
1319
 
                tvp->u.data = fe->dtv_property_cache.layer[2].segment_count;
 
1319
                tvp->u.data = c->layer[2].segment_count;
1320
1320
                break;
1321
1321
        case DTV_ISDBT_LAYERC_TIME_INTERLEAVING:
1322
 
                tvp->u.data = fe->dtv_property_cache.layer[2].interleaving;
 
1322
                tvp->u.data = c->layer[2].interleaving;
1323
1323
                break;
1324
1324
        case DTV_ISDBS_TS_ID:
1325
 
                tvp->u.data = fe->dtv_property_cache.isdbs_ts_id;
 
1325
                tvp->u.data = c->isdbs_ts_id;
 
1326
                break;
 
1327
        case DTV_DVBT2_PLP_ID:
 
1328
                tvp->u.data = c->dvbt2_plp_id;
1326
1329
                break;
1327
1330
        default:
1328
 
                r = -1;
 
1331
                return -EINVAL;
 
1332
        }
 
1333
 
 
1334
        /* Allow the frontend to override outgoing properties */
 
1335
        if (fe->ops.get_property) {
 
1336
                r = fe->ops.get_property(fe, tvp);
 
1337
                if (r < 0)
 
1338
                        return r;
1329
1339
        }
1330
1340
 
1331
1341
        dtv_property_dump(tvp);
1332
1342
 
1333
 
        return r;
 
1343
        return 0;
1334
1344
}
1335
1345
 
1336
1346
static int dtv_property_process_set(struct dvb_frontend *fe,
1338
1348
                                    struct file *file)
1339
1349
{
1340
1350
        int r = 0;
 
1351
        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1341
1352
        struct dvb_frontend_private *fepriv = fe->frontend_priv;
1342
1353
        dtv_property_dump(tvp);
1343
1354
 
1344
1355
        /* Allow the frontend to validate incoming properties */
1345
 
        if (fe->ops.set_property)
 
1356
        if (fe->ops.set_property) {
1346
1357
                r = fe->ops.set_property(fe, tvp);
1347
 
 
1348
 
        if (r < 0)
1349
 
                return r;
 
1358
                if (r < 0)
 
1359
                        return r;
 
1360
        }
1350
1361
 
1351
1362
        switch(tvp->cmd) {
1352
1363
        case DTV_CLEAR:
1361
1372
                 * tunerequest so we can pass validation in the FE_SET_FRONTEND
1362
1373
                 * ioctl.
1363
1374
                 */
1364
 
                fe->dtv_property_cache.state = tvp->cmd;
 
1375
                c->state = tvp->cmd;
1365
1376
                dprintk("%s() Finalised property cache\n", __func__);
1366
1377
                dtv_property_cache_submit(fe);
1367
1378
 
1368
 
                r |= dvb_frontend_ioctl_legacy(file, FE_SET_FRONTEND,
1369
 
                        &fepriv->parameters);
 
1379
                r = dvb_frontend_ioctl_legacy(file, FE_SET_FRONTEND,
 
1380
                        &fepriv->parameters_in);
1370
1381
                break;
1371
1382
        case DTV_FREQUENCY:
1372
 
                fe->dtv_property_cache.frequency = tvp->u.data;
 
1383
                c->frequency = tvp->u.data;
1373
1384
                break;
1374
1385
        case DTV_MODULATION:
1375
 
                fe->dtv_property_cache.modulation = tvp->u.data;
 
1386
                c->modulation = tvp->u.data;
1376
1387
                break;
1377
1388
        case DTV_BANDWIDTH_HZ:
1378
 
                fe->dtv_property_cache.bandwidth_hz = tvp->u.data;
 
1389
                c->bandwidth_hz = tvp->u.data;
1379
1390
                break;
1380
1391
        case DTV_INVERSION:
1381
 
                fe->dtv_property_cache.inversion = tvp->u.data;
 
1392
                c->inversion = tvp->u.data;
1382
1393
                break;
1383
1394
        case DTV_SYMBOL_RATE:
1384
 
                fe->dtv_property_cache.symbol_rate = tvp->u.data;
 
1395
                c->symbol_rate = tvp->u.data;
1385
1396
                break;
1386
1397
        case DTV_INNER_FEC:
1387
 
                fe->dtv_property_cache.fec_inner = tvp->u.data;
 
1398
                c->fec_inner = tvp->u.data;
1388
1399
                break;
1389
1400
        case DTV_PILOT:
1390
 
                fe->dtv_property_cache.pilot = tvp->u.data;
 
1401
                c->pilot = tvp->u.data;
1391
1402
                break;
1392
1403
        case DTV_ROLLOFF:
1393
 
                fe->dtv_property_cache.rolloff = tvp->u.data;
 
1404
                c->rolloff = tvp->u.data;
1394
1405
                break;
1395
1406
        case DTV_DELIVERY_SYSTEM:
1396
 
                fe->dtv_property_cache.delivery_system = tvp->u.data;
 
1407
                c->delivery_system = tvp->u.data;
1397
1408
                break;
1398
1409
        case DTV_VOLTAGE:
1399
 
                fe->dtv_property_cache.voltage = tvp->u.data;
 
1410
                c->voltage = tvp->u.data;
1400
1411
                r = dvb_frontend_ioctl_legacy(file, FE_SET_VOLTAGE,
1401
 
                        (void *)fe->dtv_property_cache.voltage);
 
1412
                        (void *)c->voltage);
1402
1413
                break;
1403
1414
        case DTV_TONE:
1404
 
                fe->dtv_property_cache.sectone = tvp->u.data;
 
1415
                c->sectone = tvp->u.data;
1405
1416
                r = dvb_frontend_ioctl_legacy(file, FE_SET_TONE,
1406
 
                        (void *)fe->dtv_property_cache.sectone);
 
1417
                        (void *)c->sectone);
1407
1418
                break;
1408
1419
        case DTV_CODE_RATE_HP:
1409
 
                fe->dtv_property_cache.code_rate_HP = tvp->u.data;
 
1420
                c->code_rate_HP = tvp->u.data;
1410
1421
                break;
1411
1422
        case DTV_CODE_RATE_LP:
1412
 
                fe->dtv_property_cache.code_rate_LP = tvp->u.data;
 
1423
                c->code_rate_LP = tvp->u.data;
1413
1424
                break;
1414
1425
        case DTV_GUARD_INTERVAL:
1415
 
                fe->dtv_property_cache.guard_interval = tvp->u.data;
 
1426
                c->guard_interval = tvp->u.data;
1416
1427
                break;
1417
1428
        case DTV_TRANSMISSION_MODE:
1418
 
                fe->dtv_property_cache.transmission_mode = tvp->u.data;
 
1429
                c->transmission_mode = tvp->u.data;
1419
1430
                break;
1420
1431
        case DTV_HIERARCHY:
1421
 
                fe->dtv_property_cache.hierarchy = tvp->u.data;
 
1432
                c->hierarchy = tvp->u.data;
1422
1433
                break;
1423
1434
 
1424
1435
        /* ISDB-T Support here */
1425
1436
        case DTV_ISDBT_PARTIAL_RECEPTION:
1426
 
                fe->dtv_property_cache.isdbt_partial_reception = tvp->u.data;
 
1437
                c->isdbt_partial_reception = tvp->u.data;
1427
1438
                break;
1428
1439
        case DTV_ISDBT_SOUND_BROADCASTING:
1429
 
                fe->dtv_property_cache.isdbt_sb_mode = tvp->u.data;
 
1440
                c->isdbt_sb_mode = tvp->u.data;
1430
1441
                break;
1431
1442
        case DTV_ISDBT_SB_SUBCHANNEL_ID:
1432
 
                fe->dtv_property_cache.isdbt_sb_subchannel = tvp->u.data;
 
1443
                c->isdbt_sb_subchannel = tvp->u.data;
1433
1444
                break;
1434
1445
        case DTV_ISDBT_SB_SEGMENT_IDX:
1435
 
                fe->dtv_property_cache.isdbt_sb_segment_idx = tvp->u.data;
 
1446
                c->isdbt_sb_segment_idx = tvp->u.data;
1436
1447
                break;
1437
1448
        case DTV_ISDBT_SB_SEGMENT_COUNT:
1438
 
                fe->dtv_property_cache.isdbt_sb_segment_count = tvp->u.data;
 
1449
                c->isdbt_sb_segment_count = tvp->u.data;
1439
1450
                break;
1440
1451
        case DTV_ISDBT_LAYER_ENABLED:
1441
 
                fe->dtv_property_cache.isdbt_layer_enabled = tvp->u.data;
 
1452
                c->isdbt_layer_enabled = tvp->u.data;
1442
1453
                break;
1443
1454
        case DTV_ISDBT_LAYERA_FEC:
1444
 
                fe->dtv_property_cache.layer[0].fec = tvp->u.data;
 
1455
                c->layer[0].fec = tvp->u.data;
1445
1456
                break;
1446
1457
        case DTV_ISDBT_LAYERA_MODULATION:
1447
 
                fe->dtv_property_cache.layer[0].modulation = tvp->u.data;
 
1458
                c->layer[0].modulation = tvp->u.data;
1448
1459
                break;
1449
1460
        case DTV_ISDBT_LAYERA_SEGMENT_COUNT:
1450
 
                fe->dtv_property_cache.layer[0].segment_count = tvp->u.data;
 
1461
                c->layer[0].segment_count = tvp->u.data;
1451
1462
                break;
1452
1463
        case DTV_ISDBT_LAYERA_TIME_INTERLEAVING:
1453
 
                fe->dtv_property_cache.layer[0].interleaving = tvp->u.data;
 
1464
                c->layer[0].interleaving = tvp->u.data;
1454
1465
                break;
1455
1466
        case DTV_ISDBT_LAYERB_FEC:
1456
 
                fe->dtv_property_cache.layer[1].fec = tvp->u.data;
 
1467
                c->layer[1].fec = tvp->u.data;
1457
1468
                break;
1458
1469
        case DTV_ISDBT_LAYERB_MODULATION:
1459
 
                fe->dtv_property_cache.layer[1].modulation = tvp->u.data;
 
1470
                c->layer[1].modulation = tvp->u.data;
1460
1471
                break;
1461
1472
        case DTV_ISDBT_LAYERB_SEGMENT_COUNT:
1462
 
                fe->dtv_property_cache.layer[1].segment_count = tvp->u.data;
 
1473
                c->layer[1].segment_count = tvp->u.data;
1463
1474
                break;
1464
1475
        case DTV_ISDBT_LAYERB_TIME_INTERLEAVING:
1465
 
                fe->dtv_property_cache.layer[1].interleaving = tvp->u.data;
 
1476
                c->layer[1].interleaving = tvp->u.data;
1466
1477
                break;
1467
1478
        case DTV_ISDBT_LAYERC_FEC:
1468
 
                fe->dtv_property_cache.layer[2].fec = tvp->u.data;
 
1479
                c->layer[2].fec = tvp->u.data;
1469
1480
                break;
1470
1481
        case DTV_ISDBT_LAYERC_MODULATION:
1471
 
                fe->dtv_property_cache.layer[2].modulation = tvp->u.data;
 
1482
                c->layer[2].modulation = tvp->u.data;
1472
1483
                break;
1473
1484
        case DTV_ISDBT_LAYERC_SEGMENT_COUNT:
1474
 
                fe->dtv_property_cache.layer[2].segment_count = tvp->u.data;
 
1485
                c->layer[2].segment_count = tvp->u.data;
1475
1486
                break;
1476
1487
        case DTV_ISDBT_LAYERC_TIME_INTERLEAVING:
1477
 
                fe->dtv_property_cache.layer[2].interleaving = tvp->u.data;
 
1488
                c->layer[2].interleaving = tvp->u.data;
1478
1489
                break;
1479
1490
        case DTV_ISDBS_TS_ID:
1480
 
                fe->dtv_property_cache.isdbs_ts_id = tvp->u.data;
 
1491
                c->isdbs_ts_id = tvp->u.data;
 
1492
                break;
 
1493
        case DTV_DVBT2_PLP_ID:
 
1494
                c->dvbt2_plp_id = tvp->u.data;
1481
1495
                break;
1482
1496
        default:
1483
 
                r = -1;
 
1497
                return -EINVAL;
1484
1498
        }
1485
1499
 
1486
1500
        return r;
1491
1505
{
1492
1506
        struct dvb_device *dvbdev = file->private_data;
1493
1507
        struct dvb_frontend *fe = dvbdev->priv;
 
1508
        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1494
1509
        struct dvb_frontend_private *fepriv = fe->frontend_priv;
1495
1510
        int err = -EOPNOTSUPP;
1496
1511
 
1510
1525
        if ((cmd == FE_SET_PROPERTY) || (cmd == FE_GET_PROPERTY))
1511
1526
                err = dvb_frontend_ioctl_properties(file, cmd, parg);
1512
1527
        else {
1513
 
                fe->dtv_property_cache.state = DTV_UNDEFINED;
 
1528
                c->state = DTV_UNDEFINED;
1514
1529
                err = dvb_frontend_ioctl_legacy(file, cmd, parg);
1515
1530
        }
1516
1531
 
1523
1538
{
1524
1539
        struct dvb_device *dvbdev = file->private_data;
1525
1540
        struct dvb_frontend *fe = dvbdev->priv;
 
1541
        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1526
1542
        int err = 0;
1527
1543
 
1528
1544
        struct dtv_properties *tvps = NULL;
1554
1570
                }
1555
1571
 
1556
1572
                for (i = 0; i < tvps->num; i++) {
1557
 
                        (tvp + i)->result = dtv_property_process_set(fe, tvp + i, file);
1558
 
                        err |= (tvp + i)->result;
 
1573
                        err = dtv_property_process_set(fe, tvp + i, file);
 
1574
                        if (err < 0)
 
1575
                                goto out;
 
1576
                        (tvp + i)->result = err;
1559
1577
                }
1560
1578
 
1561
 
                if(fe->dtv_property_cache.state == DTV_TUNE)
 
1579
                if (c->state == DTV_TUNE)
1562
1580
                        dprintk("%s() Property cache is full, tuning\n", __func__);
1563
1581
 
1564
1582
        } else
1586
1604
                }
1587
1605
 
1588
1606
                for (i = 0; i < tvps->num; i++) {
1589
 
                        (tvp + i)->result = dtv_property_process_get(fe, tvp + i, file);
1590
 
                        err |= (tvp + i)->result;
 
1607
                        err = dtv_property_process_get(fe, tvp + i, file);
 
1608
                        if (err < 0)
 
1609
                                goto out;
 
1610
                        (tvp + i)->result = err;
1591
1611
                }
1592
1612
 
1593
1613
                if (copy_to_user(tvps->props, tvp, tvps->num * sizeof(struct dtv_property))) {
1638
1658
        case FE_READ_STATUS: {
1639
1659
                fe_status_t* status = parg;
1640
1660
 
1641
 
                /* if retune was requested but hasn't occured yet, prevent
 
1661
                /* if retune was requested but hasn't occurred yet, prevent
1642
1662
                 * that user get signal state from previous tuning */
1643
1663
                if (fepriv->state == FESTATE_RETUNE ||
1644
1664
                    fepriv->state == FESTATE_ERROR) {
1729
1749
                         * Dish network legacy switches (as used by Dish500)
1730
1750
                         * are controlled by sending 9-bit command words
1731
1751
                         * spaced 8msec apart.
1732
 
                         * the actual command word is switch/port dependant
 
1752
                         * the actual command word is switch/port dependent
1733
1753
                         * so it is up to the userspace application to send
1734
1754
                         * the right command.
1735
1755
                         * The command must always start with a '0' after
1787
1807
                break;
1788
1808
 
1789
1809
        case FE_SET_FRONTEND: {
 
1810
                struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1790
1811
                struct dvb_frontend_tune_settings fetunesettings;
1791
1812
 
1792
 
                if(fe->dtv_property_cache.state == DTV_TUNE) {
1793
 
                        if (dvb_frontend_check_parameters(fe, &fepriv->parameters) < 0) {
 
1813
                if (c->state == DTV_TUNE) {
 
1814
                        if (dvb_frontend_check_parameters(fe, &fepriv->parameters_in) < 0) {
1794
1815
                                err = -EINVAL;
1795
1816
                                break;
1796
1817
                        }
1800
1821
                                break;
1801
1822
                        }
1802
1823
 
1803
 
                        memcpy (&fepriv->parameters, parg,
 
1824
                        memcpy (&fepriv->parameters_in, parg,
1804
1825
                                sizeof (struct dvb_frontend_parameters));
1805
 
                        dtv_property_cache_sync(fe, &fepriv->parameters);
 
1826
                        dtv_property_cache_sync(fe, c, &fepriv->parameters_in);
1806
1827
                }
1807
1828
 
1808
1829
                memset(&fetunesettings, 0, sizeof(struct dvb_frontend_tune_settings));
1811
1832
 
1812
1833
                /* force auto frequency inversion if requested */
1813
1834
                if (dvb_force_auto_inversion) {
1814
 
                        fepriv->parameters.inversion = INVERSION_AUTO;
 
1835
                        fepriv->parameters_in.inversion = INVERSION_AUTO;
1815
1836
                        fetunesettings.parameters.inversion = INVERSION_AUTO;
1816
1837
                }
1817
1838
                if (fe->ops.info.type == FE_OFDM) {
1818
1839
                        /* without hierarchical coding code_rate_LP is irrelevant,
1819
1840
                         * so we tolerate the otherwise invalid FEC_NONE setting */
1820
 
                        if (fepriv->parameters.u.ofdm.hierarchy_information == HIERARCHY_NONE &&
1821
 
                            fepriv->parameters.u.ofdm.code_rate_LP == FEC_NONE)
1822
 
                                fepriv->parameters.u.ofdm.code_rate_LP = FEC_AUTO;
 
1841
                        if (fepriv->parameters_in.u.ofdm.hierarchy_information == HIERARCHY_NONE &&
 
1842
                            fepriv->parameters_in.u.ofdm.code_rate_LP == FEC_NONE)
 
1843
                                fepriv->parameters_in.u.ofdm.code_rate_LP = FEC_AUTO;
1823
1844
                }
1824
1845
 
1825
1846
                /* get frontend-specific tuning settings */
1832
1853
                        switch(fe->ops.info.type) {
1833
1854
                        case FE_QPSK:
1834
1855
                                fepriv->min_delay = HZ/20;
1835
 
                                fepriv->step_size = fepriv->parameters.u.qpsk.symbol_rate / 16000;
1836
 
                                fepriv->max_drift = fepriv->parameters.u.qpsk.symbol_rate / 2000;
 
1856
                                fepriv->step_size = fepriv->parameters_in.u.qpsk.symbol_rate / 16000;
 
1857
                                fepriv->max_drift = fepriv->parameters_in.u.qpsk.symbol_rate / 2000;
1837
1858
                                break;
1838
1859
 
1839
1860
                        case FE_QAM:
1875
1896
 
1876
1897
        case FE_GET_FRONTEND:
1877
1898
                if (fe->ops.get_frontend) {
1878
 
                        memcpy (parg, &fepriv->parameters, sizeof (struct dvb_frontend_parameters));
1879
 
                        err = fe->ops.get_frontend(fe, (struct dvb_frontend_parameters*) parg);
 
1899
                        err = fe->ops.get_frontend(fe, &fepriv->parameters_out);
 
1900
                        memcpy(parg, &fepriv->parameters_out, sizeof(struct dvb_frontend_parameters));
1880
1901
                }
1881
1902
                break;
1882
1903
 
1967
1988
        if (dvbdev->users == -1 && fe->ops.ts_bus_ctrl) {
1968
1989
                if ((ret = fe->ops.ts_bus_ctrl(fe, 1)) < 0)
1969
1990
                        goto err0;
 
1991
 
 
1992
                /* If we took control of the bus, we need to force
 
1993
                   reinitialization.  This is because many ts_bus_ctrl()
 
1994
                   functions strobe the RESET pin on the demod, and if the
 
1995
                   frontend thread already exists then the dvb_init() routine
 
1996
                   won't get called (which is what usually does initial
 
1997
                   register configuration). */
 
1998
                fepriv->reinitialise = 1;
1970
1999
        }
1971
2000
 
1972
2001
        if ((ret = dvb_generic_open (inode, file)) < 0)