← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-lowlatency/quantal-proposed

« back to all changes in this revision

Viewing changes to drivers/media/dvb/frontends/drxd_hard.c

  • Committer: Package Import Robot
  • Author(s): Andy Whitcroft, Andy Whitcroft
  • Date: 2012-06-21 09:16:38 UTC
  • Revision ID: package-import@ubuntu.com-20120621091638-gubhv4nox8xez1ct
Tags: 3.5.0-1.1
[ Andy Whitcroft]

* Rebuild lowlatency against Ubuntu-3.5.0-1.1
* All new configuration system to allow configuration deltas to be
  exposed via debian.lowlatency/config-delta

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/dvb/frontends/drxd_hard.c
101
101
 
102
102
struct SNoiseCal {
103
103
        int cpOpt;
104
 
        u16 cpNexpOfs;
105
 
        u16 tdCal2k;
106
 
        u16 tdCal8k;
 
104
        short cpNexpOfs;
 
105
        short tdCal2k;
 
106
        short tdCal8k;
107
107
};
108
108
 
109
109
enum app_env {
120
120
struct drxd_state {
121
121
        struct dvb_frontend frontend;
122
122
        struct dvb_frontend_ops ops;
123
 
        struct dvb_frontend_parameters param;
 
123
        struct dtv_frontend_properties props;
124
124
 
125
125
        const struct firmware *fw;
126
126
        struct device *dev;
914
914
                return -EIO;
915
915
        }
916
916
 
917
 
        state->microcode = kmalloc(fw->size, GFP_KERNEL);
 
917
        state->microcode = kmemdup(fw->data, fw->size, GFP_KERNEL);
918
918
        if (state->microcode == NULL) {
919
919
                release_firmware(fw);
920
920
                printk(KERN_ERR "drxd: firmware load failure: no memory\n");
921
921
                return -ENOMEM;
922
922
        }
923
923
 
924
 
        memcpy(state->microcode, fw->data, fw->size);
925
924
        state->microcode_length = fw->size;
926
925
        release_firmware(fw);
927
926
        return 0;
1622
1621
                                break;
1623
1622
                }
1624
1623
 
1625
 
                switch (state->param.u.ofdm.bandwidth) {
1626
 
                case BANDWIDTH_8_MHZ:
 
1624
                switch (state->props.bandwidth_hz) {
 
1625
                case 8000000:
1627
1626
                        bandwidth = DRXD_BANDWIDTH_8MHZ_IN_HZ;
1628
1627
                        break;
1629
 
                case BANDWIDTH_7_MHZ:
 
1628
                case 7000000:
1630
1629
                        bandwidth = DRXD_BANDWIDTH_7MHZ_IN_HZ;
1631
1630
                        break;
1632
 
                case BANDWIDTH_6_MHZ:
 
1631
                case 6000000:
1633
1632
                        bandwidth = DRXD_BANDWIDTH_6MHZ_IN_HZ;
1634
1633
                        break;
1635
1634
                default:
1804
1803
                        status = WriteTable(state, state->m_StartDiversityEnd);
1805
1804
                        if (status < 0)
1806
1805
                                break;
1807
 
                        if (state->param.u.ofdm.bandwidth == BANDWIDTH_8_MHZ) {
 
1806
                        if (state->props.bandwidth_hz == 8000000) {
1808
1807
                                status = WriteTable(state, state->m_DiversityDelay8MHZ);
1809
1808
                                if (status < 0)
1810
1809
                                        break;
1906
1905
 
1907
1906
static int DRX_Start(struct drxd_state *state, s32 off)
1908
1907
{
1909
 
        struct dvb_ofdm_parameters *p = &state->param.u.ofdm;
 
1908
        struct dtv_frontend_properties *p = &state->props;
1910
1909
        int status;
1911
1910
 
1912
1911
        u16 transmissionParams = 0;
1971
1970
                if (status < 0)
1972
1971
                        break;
1973
1972
 
1974
 
                mirrorFreqSpect = (state->param.inversion == INVERSION_ON);
 
1973
                mirrorFreqSpect = (state->props.inversion == INVERSION_ON);
1975
1974
 
1976
1975
                switch (p->transmission_mode) {
1977
1976
                default:        /* Not set, detect it automatically */
2021
2020
                        break;
2022
2021
                }
2023
2022
 
2024
 
                switch (p->hierarchy_information) {
 
2023
                switch (p->hierarchy) {
2025
2024
                case HIERARCHY_1:
2026
2025
                        transmissionParams |= SC_RA_RAM_OP_PARAM_HIER_A1;
2027
2026
                        if (state->type_A) {
2147
2146
                if (status < 0)
2148
2147
                        break;
2149
2148
 
2150
 
                switch (p->constellation) {
 
2149
                switch (p->modulation) {
2151
2150
                default:
2152
2151
                        operationMode |= SC_RA_RAM_OP_AUTO_CONST__M;
2153
2152
                        /* fall through , try first guess
2331
2330
                   by SC for fix for some 8K,1/8 guard but is restored by
2332
2331
                   InitEC and ResetEC
2333
2332
                   functions */
2334
 
                switch (p->bandwidth) {
2335
 
                case BANDWIDTH_AUTO:
2336
 
                case BANDWIDTH_8_MHZ:
 
2333
                switch (p->bandwidth_hz) {
 
2334
                case 0:
 
2335
                        p->bandwidth_hz = 8000000;
 
2336
                        /* fall through */
 
2337
                case 8000000:
2337
2338
                        /* (64/7)*(8/8)*1000000 */
2338
2339
                        bandwidth = DRXD_BANDWIDTH_8MHZ_IN_HZ;
2339
2340
 
2341
2342
                        status = Write16(state,
2342
2343
                                         FE_AG_REG_IND_DEL__A, 50, 0x0000);
2343
2344
                        break;
2344
 
                case BANDWIDTH_7_MHZ:
 
2345
                case 7000000:
2345
2346
                        /* (64/7)*(7/8)*1000000 */
2346
2347
                        bandwidth = DRXD_BANDWIDTH_7MHZ_IN_HZ;
2347
2348
                        bandwidthParam = 0x4807;        /*binary:0100 1000 0000 0111 */
2348
2349
                        status = Write16(state,
2349
2350
                                         FE_AG_REG_IND_DEL__A, 59, 0x0000);
2350
2351
                        break;
2351
 
                case BANDWIDTH_6_MHZ:
 
2352
                case 6000000:
2352
2353
                        /* (64/7)*(6/8)*1000000 */
2353
2354
                        bandwidth = DRXD_BANDWIDTH_6MHZ_IN_HZ;
2354
2355
                        bandwidthParam = 0x0F07;        /*binary: 0000 1111 0000 0111 */
2887
2888
        return 0;
2888
2889
}
2889
2890
 
2890
 
static int drxd_get_frontend(struct dvb_frontend *fe,
2891
 
                             struct dvb_frontend_parameters *param)
2892
 
{
2893
 
        return 0;
2894
 
}
2895
 
 
2896
2891
static int drxd_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
2897
2892
{
2898
2893
        return drxd_config_i2c(fe, enable);
2899
2894
}
2900
2895
 
2901
 
static int drxd_set_frontend(struct dvb_frontend *fe,
2902
 
                             struct dvb_frontend_parameters *param)
 
2896
static int drxd_set_frontend(struct dvb_frontend *fe)
2903
2897
{
 
2898
        struct dtv_frontend_properties *p = &fe->dtv_property_cache;
2904
2899
        struct drxd_state *state = fe->demodulator_priv;
2905
2900
        s32 off = 0;
2906
2901
 
2907
 
        state->param = *param;
 
2902
        state->props = *p;
2908
2903
        DRX_Stop(state);
2909
2904
 
2910
2905
        if (fe->ops.tuner_ops.set_params) {
2911
 
                fe->ops.tuner_ops.set_params(fe, param);
 
2906
                fe->ops.tuner_ops.set_params(fe);
2912
2907
                if (fe->ops.i2c_gate_ctrl)
2913
2908
                        fe->ops.i2c_gate_ctrl(fe, 0);
2914
2909
        }
2915
2910
 
2916
 
        /* FIXME: move PLL drivers */
2917
 
        if (state->config.pll_set &&
2918
 
            state->config.pll_set(state->priv, param,
2919
 
                                  state->config.pll_address,
2920
 
                                  state->config.demoda_address, &off) < 0) {
2921
 
                printk(KERN_ERR "Error in pll_set\n");
2922
 
                return -1;
2923
 
        }
2924
 
 
2925
2911
        msleep(200);
2926
2912
 
2927
2913
        return DRX_Start(state, off);
2935
2921
}
2936
2922
 
2937
2923
static struct dvb_frontend_ops drxd_ops = {
2938
 
 
 
2924
        .delsys = { SYS_DVBT},
2939
2925
        .info = {
2940
2926
                 .name = "Micronas DRXD DVB-T",
2941
 
                 .type = FE_OFDM,
2942
2927
                 .frequency_min = 47125000,
2943
2928
                 .frequency_max = 855250000,
2944
2929
                 .frequency_stepsize = 166667,
2958
2943
        .i2c_gate_ctrl = drxd_i2c_gate_ctrl,
2959
2944
 
2960
2945
        .set_frontend = drxd_set_frontend,
2961
 
        .get_frontend = drxd_get_frontend,
2962
2946
        .get_tune_settings = drxd_get_tune_settings,
2963
2947
 
2964
2948
        .read_status = drxd_read_status,