struct dvb_frontend_parameters *p)
 {
        int ret;
-       struct at76c651_state* state = (struct at76c651_state*) fe->demodulator_priv;
+       struct at76c651_state* state = fe->demodulator_priv;
 
        at76c651_writereg(state, 0x0c, 0xc3);
        state->config->pll_set(fe, p);
 
 static int at76c651_set_defaults(struct dvb_frontend* fe)
 {
-       struct at76c651_state* state = (struct at76c651_state*) fe->demodulator_priv;
+       struct at76c651_state* state = fe->demodulator_priv;
 
        at76c651_set_symbol_rate(state, 6900000);
        at76c651_set_qam(state, QAM_64);
 
 static int at76c651_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct at76c651_state* state = (struct at76c651_state*) fe->demodulator_priv;
+       struct at76c651_state* state = fe->demodulator_priv;
        u8 sync;
 
        /*
 
 static int at76c651_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct at76c651_state* state = (struct at76c651_state*) fe->demodulator_priv;
+       struct at76c651_state* state = fe->demodulator_priv;
 
        *ber = (at76c651_readreg(state, 0x81) & 0x0F) << 16;
        *ber |= at76c651_readreg(state, 0x82) << 8;
 
 static int at76c651_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 {
-       struct at76c651_state* state = (struct at76c651_state*) fe->demodulator_priv;
+       struct at76c651_state* state = fe->demodulator_priv;
 
        u8 gain = ~at76c651_readreg(state, 0x91);
        *strength = (gain << 8) | gain;
 
 static int at76c651_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct at76c651_state* state = (struct at76c651_state*) fe->demodulator_priv;
+       struct at76c651_state* state = fe->demodulator_priv;
 
        *snr = 0xFFFF -
            ((at76c651_readreg(state, 0x8F) << 8) |
 
 static int at76c651_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-       struct at76c651_state* state = (struct at76c651_state*) fe->demodulator_priv;
+       struct at76c651_state* state = fe->demodulator_priv;
 
        *ucblocks = at76c651_readreg(state, 0x82);
 
 
 static void at76c651_release(struct dvb_frontend* fe)
 {
-       struct at76c651_state* state = (struct at76c651_state*) fe->demodulator_priv;
+       struct at76c651_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        struct at76c651_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct at76c651_state*) kmalloc(sizeof(struct at76c651_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct at76c651_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 
 static int cx22700_init (struct dvb_frontend* fe)
 
-{      struct cx22700_state* state = (struct cx22700_state*) fe->demodulator_priv;
+{      struct cx22700_state* state = fe->demodulator_priv;
        int i;
 
        dprintk("cx22700_init: init chip\n");
 
 static int cx22700_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct cx22700_state* state = (struct cx22700_state*) fe->demodulator_priv;
+       struct cx22700_state* state = fe->demodulator_priv;
 
        u16 rs_ber = (cx22700_readreg (state, 0x0d) << 9)
                   | (cx22700_readreg (state, 0x0e) << 1);
 
 static int cx22700_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct cx22700_state* state = (struct cx22700_state*) fe->demodulator_priv;
+       struct cx22700_state* state = fe->demodulator_priv;
 
        *ber = cx22700_readreg (state, 0x0c) & 0x7f;
        cx22700_writereg (state, 0x0c, 0x00);
 
 static int cx22700_read_signal_strength(struct dvb_frontend* fe, u16* signal_strength)
 {
-       struct cx22700_state* state = (struct cx22700_state*) fe->demodulator_priv;
+       struct cx22700_state* state = fe->demodulator_priv;
 
        u16 rs_ber = (cx22700_readreg (state, 0x0d) << 9)
                   | (cx22700_readreg (state, 0x0e) << 1);
 
 static int cx22700_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct cx22700_state* state = (struct cx22700_state*) fe->demodulator_priv;
+       struct cx22700_state* state = fe->demodulator_priv;
 
        u16 rs_ber = (cx22700_readreg (state, 0x0d) << 9)
                   | (cx22700_readreg (state, 0x0e) << 1);
 
 static int cx22700_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-       struct cx22700_state* state = (struct cx22700_state*) fe->demodulator_priv;
+       struct cx22700_state* state = fe->demodulator_priv;
 
        *ucblocks = cx22700_readreg (state, 0x0f);
        cx22700_writereg (state, 0x0f, 0x00);
 
 static int cx22700_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct cx22700_state* state = (struct cx22700_state*) fe->demodulator_priv;
+       struct cx22700_state* state = fe->demodulator_priv;
 
        cx22700_writereg (state, 0x00, 0x02); /* XXX CHECKME: soft reset*/
        cx22700_writereg (state, 0x00, 0x00);
 
 static int cx22700_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct cx22700_state* state = (struct cx22700_state*) fe->demodulator_priv;
+       struct cx22700_state* state = fe->demodulator_priv;
        u8 reg09 = cx22700_readreg (state, 0x09);
 
        p->inversion = reg09 & 0x1 ? INVERSION_ON : INVERSION_OFF;
 
 static void cx22700_release(struct dvb_frontend* fe)
 {
-       struct cx22700_state* state = (struct cx22700_state*) fe->demodulator_priv;
+       struct cx22700_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        struct cx22700_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct cx22700_state*) kmalloc(sizeof(struct cx22700_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct cx22700_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 static int cx22702_set_tps (struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
        u8 val;
-       struct cx22702_state* state = (struct cx22702_state*) fe->demodulator_priv;
+       struct cx22702_state* state = fe->demodulator_priv;
 
        /* set PLL */
         cx22702_writereg (state, 0x0D, cx22702_readreg(state,0x0D) &0xfe);
 static int cx22702_init (struct dvb_frontend* fe)
 {
        int i;
-       struct cx22702_state* state = (struct cx22702_state*) fe->demodulator_priv;
+       struct cx22702_state* state = fe->demodulator_priv;
 
        cx22702_writereg (state, 0x00, 0x02);
 
 
 static int cx22702_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct cx22702_state* state = (struct cx22702_state*) fe->demodulator_priv;
+       struct cx22702_state* state = fe->demodulator_priv;
        u8 reg0A;
        u8 reg23;
 
 
 static int cx22702_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct cx22702_state* state = (struct cx22702_state*) fe->demodulator_priv;
+       struct cx22702_state* state = fe->demodulator_priv;
 
        if(cx22702_readreg (state, 0xE4) & 0x02) {
                /* Realtime statistics */
 
 static int cx22702_read_signal_strength(struct dvb_frontend* fe, u16* signal_strength)
 {
-       struct cx22702_state* state = (struct cx22702_state*) fe->demodulator_priv;
+       struct cx22702_state* state = fe->demodulator_priv;
 
        *signal_strength = cx22702_readreg (state, 0x23);
 
 
 static int cx22702_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct cx22702_state* state = (struct cx22702_state*) fe->demodulator_priv;
+       struct cx22702_state* state = fe->demodulator_priv;
 
        u16 rs_ber=0;
        if(cx22702_readreg (state, 0xE4) & 0x02) {
 
 static int cx22702_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-       struct cx22702_state* state = (struct cx22702_state*) fe->demodulator_priv;
+       struct cx22702_state* state = fe->demodulator_priv;
 
        u8 _ucblocks;
 
 
 static int cx22702_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct cx22702_state* state = (struct cx22702_state*) fe->demodulator_priv;
+       struct cx22702_state* state = fe->demodulator_priv;
 
        u8 reg0C = cx22702_readreg (state, 0x0C);
 
 
 static void cx22702_release(struct dvb_frontend* fe)
 {
-       struct cx22702_state* state = (struct cx22702_state*) fe->demodulator_priv;
+       struct cx22702_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        struct cx22702_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct cx22702_state*) kmalloc(sizeof(struct cx22702_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct cx22702_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 
 int cx24110_pll_write (struct dvb_frontend* fe, u32 data)
 {
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
 
 /* tuner data is 21 bits long, must be left-aligned in data */
 /* tuner cx24108 is written through a dedicated 3wire interface on the demod chip */
 
 static int cx24110_initfe(struct dvb_frontend* fe)
 {
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
 /* fixme (low): error handling */
         int i;
 
 
 static int cx24110_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t voltage)
 {
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
 
        switch (voltage) {
        case SEC_VOLTAGE_13:
        };
 }
 
-static int cx24110_diseqc_send_burst(struct dvb_frontend* fe,
-                       fe_sec_mini_cmd_t burst)
+static int cx24110_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t burst)
 {
        int rv, bit, i;
        struct cx24110_state *state = fe->demodulator_priv;
                                   struct dvb_diseqc_master_cmd *cmd)
 {
        int i, rv;
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
 
        for (i = 0; i < cmd->msg_len; i++)
                cx24110_writereg(state, 0x79 + i, cmd->msg[i]);
 
 static int cx24110_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
 
        int sync = cx24110_readreg (state, 0x55);
 
 
 static int cx24110_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
 
        /* fixme (maybe): value range is 16 bit. Scale? */
        if(cx24110_readreg(state,0x24)&0x10) {
 
 static int cx24110_read_signal_strength(struct dvb_frontend* fe, u16* signal_strength)
 {
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
 
 /* no provision in hardware. Read the frontend AGC accumulator. No idea how to scale this, but I know it is 2s complement */
        u8 signal = cx24110_readreg (state, 0x27)+128;
 
 static int cx24110_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
 
        /* no provision in hardware. Can be computed from the Es/N0 estimator, but I don't know how. */
        if(cx24110_readreg(state,0x6a)&0x80) {
 
 static int cx24110_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
        u32 lastbyer;
 
        if(cx24110_readreg(state,0x10)&0x40) {
 
 static int cx24110_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
 
        state->config->pll_set(fe, p);
        cx24110_set_inversion (state, p->inversion);
 
 static int cx24110_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
        s32 afc; unsigned sclk;
 
 /* cannot read back tuner settings (freq). Need to have some private storage */
 
 static int cx24110_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
 {
-       struct cx24110_state *state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state *state = fe->demodulator_priv;
 
        return cx24110_writereg(state,0x76,(cx24110_readreg(state,0x76)&~0x10)|(((tone==SEC_TONE_ON))?0x10:0));
 }
 
 static void cx24110_release(struct dvb_frontend* fe)
 {
-       struct cx24110_state* state = (struct cx24110_state*) fe->demodulator_priv;
+       struct cx24110_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        int ret;
 
        /* allocate memory for the internal state */
-       state = (struct cx24110_state*) kmalloc(sizeof(struct cx24110_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct cx24110_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 static int dib3000mb_set_frontend(struct dvb_frontend* fe,
                                  struct dvb_frontend_parameters *fep, int tuner)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
        struct dvb_ofdm_parameters *ofdm = &fep->u.ofdm;
        fe_code_rate_t fe_cr = FEC_NONE;
        int search_state, seq;
 
 static int dib3000mb_fe_init(struct dvb_frontend* fe, int mobile_mode)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
 
        deb_info("dib3000mb is getting up.\n");
        wr(DIB3000MB_REG_POWER_CONTROL, DIB3000MB_POWER_UP);
 static int dib3000mb_get_frontend(struct dvb_frontend* fe,
                                  struct dvb_frontend_parameters *fep)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
        struct dvb_ofdm_parameters *ofdm = &fep->u.ofdm;
        fe_code_rate_t *cr;
        u16 tps_val;
 
 static int dib3000mb_read_status(struct dvb_frontend* fe, fe_status_t *stat)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
 
        *stat = 0;
 
 
 static int dib3000mb_read_ber(struct dvb_frontend* fe, u32 *ber)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
 
        *ber = ((rd(DIB3000MB_REG_BER_MSB) << 16) | rd(DIB3000MB_REG_BER_LSB));
        return 0;
 /* see dib3000-watch dvb-apps for exact calcuations of signal_strength and snr */
 static int dib3000mb_read_signal_strength(struct dvb_frontend* fe, u16 *strength)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
 
        *strength = rd(DIB3000MB_REG_SIGNAL_POWER) * 0xffff / 0x170;
        return 0;
 
 static int dib3000mb_read_snr(struct dvb_frontend* fe, u16 *snr)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
        short sigpow = rd(DIB3000MB_REG_SIGNAL_POWER);
        int icipow = ((rd(DIB3000MB_REG_NOISE_POWER_MSB) & 0xff) << 16) |
                rd(DIB3000MB_REG_NOISE_POWER_LSB);
 
 static int dib3000mb_read_unc_blocks(struct dvb_frontend* fe, u32 *unc)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
 
        *unc = rd(DIB3000MB_REG_UNC);
        return 0;
 
 static int dib3000mb_sleep(struct dvb_frontend* fe)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
        deb_info("dib3000mb is going to bed.\n");
        wr(DIB3000MB_REG_POWER_CONTROL, DIB3000MB_POWER_DOWN);
        return 0;
 
 static void dib3000mb_release(struct dvb_frontend* fe)
 {
-       struct dib3000_state *state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state *state = fe->demodulator_priv;
        kfree(state);
 }
 
 
 static int dib3000mb_fifo_control(struct dvb_frontend *fe, int onoff)
 {
-       struct dib3000_state *state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state *state = fe->demodulator_priv;
 
        deb_xfer("%s fifo\n",onoff ? "enabling" : "disabling");
        if (onoff) {
 
 static int dib3000mb_tuner_pass_ctrl(struct dvb_frontend *fe, int onoff, u8 pll_addr)
 {
-       struct dib3000_state *state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state *state = fe->demodulator_priv;
        if (onoff) {
                wr(DIB3000MB_REG_TUNER, DIB3000_TUNER_WRITE_ENABLE(pll_addr));
        } else {
        struct dib3000_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct dib3000_state*) kmalloc(sizeof(struct dib3000_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct dib3000_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
        memset(state,0,sizeof(struct dib3000_state));
 
 static int dib3000mc_get_frontend(struct dvb_frontend* fe,
                                  struct dvb_frontend_parameters *fep)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
        struct dvb_ofdm_parameters *ofdm = &fep->u.ofdm;
        fe_code_rate_t *cr;
        u16 tps_val,cr_val;
 static int dib3000mc_set_frontend(struct dvb_frontend* fe,
                                  struct dvb_frontend_parameters *fep, int tuner)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
        struct dvb_ofdm_parameters *ofdm = &fep->u.ofdm;
        int search_state,auto_val;
        u16 val;
 }
 static int dib3000mc_read_status(struct dvb_frontend* fe, fe_status_t *stat)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
        u16 lock = rd(DIB3000MC_REG_LOCKING);
 
        *stat = 0;
 
 static int dib3000mc_read_ber(struct dvb_frontend* fe, u32 *ber)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
        *ber = ((rd(DIB3000MC_REG_BER_MSB) << 16) | rd(DIB3000MC_REG_BER_LSB));
        return 0;
 }
 
 static int dib3000mc_read_unc_blocks(struct dvb_frontend* fe, u32 *unc)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
 
        *unc = rd(DIB3000MC_REG_PACKET_ERROR_COUNT);
        return 0;
 /* see dib3000mb.c for calculation comments */
 static int dib3000mc_read_signal_strength(struct dvb_frontend* fe, u16 *strength)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
        u16 val = rd(DIB3000MC_REG_SIGNAL_NOISE_LSB);
        *strength = (((val >> 6) & 0xff) << 8) + (val & 0x3f);
 
 /* see dib3000mb.c for calculation comments */
 static int dib3000mc_read_snr(struct dvb_frontend* fe, u16 *snr)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
        u16 val = rd(DIB3000MC_REG_SIGNAL_NOISE_LSB),
                val2 = rd(DIB3000MC_REG_SIGNAL_NOISE_MSB);
        u16 sig,noise;
 
 static int dib3000mc_sleep(struct dvb_frontend* fe)
 {
-       struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state* state = fe->demodulator_priv;
 
        set_or(DIB3000MC_REG_CLK_CFG_7,DIB3000MC_CLK_CFG_7_PWR_DOWN);
        wr(DIB3000MC_REG_CLK_CFG_1,DIB3000MC_CLK_CFG_1_POWER_DOWN);
 
 static void dib3000mc_release(struct dvb_frontend* fe)
 {
-       struct dib3000_state *state = (struct dib3000_state *) fe->demodulator_priv;
+       struct dib3000_state *state = fe->demodulator_priv;
        kfree(state);
 }
 
 
 static int dib3000mc_fifo_control(struct dvb_frontend *fe, int onoff)
 {
-       struct dib3000_state *state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state *state = fe->demodulator_priv;
        u16 tmp = rd(DIB3000MC_REG_SMO_MODE);
 
        deb_xfer("%s fifo\n",onoff ? "enabling" : "disabling");
 
 static int dib3000mc_tuner_pass_ctrl(struct dvb_frontend *fe, int onoff, u8 pll_addr)
 {
-       struct dib3000_state *state = (struct dib3000_state*) fe->demodulator_priv;
+       struct dib3000_state *state = fe->demodulator_priv;
        if (onoff) {
                wr(DIB3000MC_REG_TUNER, DIB3000_TUNER_WRITE_ENABLE(pll_addr));
        } else {
        u16 devid;
 
        /* allocate memory for the internal state */
-       state = (struct dib3000_state*) kmalloc(sizeof(struct dib3000_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct dib3000_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
        memset(state,0,sizeof(struct dib3000_state));
 
 
 static void dvb_dummy_fe_release(struct dvb_frontend* fe)
 {
-       struct dvb_dummy_fe_state* state = (struct dvb_dummy_fe_state*) fe->demodulator_priv;
+       struct dvb_dummy_fe_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        struct dvb_dummy_fe_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct dvb_dummy_fe_state*) kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
        struct dvb_dummy_fe_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct dvb_dummy_fe_state*) kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
        struct dvb_dummy_fe_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct dvb_dummy_fe_state*) kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 
 static int apply_frontend_param (struct dvb_frontend* fe, struct dvb_frontend_parameters *param)
 {
-       struct l64781_state* state = (struct l64781_state*) fe->demodulator_priv;
+       struct l64781_state* state = fe->demodulator_priv;
        /* The coderates for FEC_NONE, FEC_4_5 and FEC_FEC_6_7 are arbitrary */
        static const u8 fec_tab[] = { 7, 0, 1, 2, 9, 3, 10, 4 };
        /* QPSK, QAM_16, QAM_64 */
 
 static int get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters* param)
 {
-       struct l64781_state* state = (struct l64781_state*) fe->demodulator_priv;
+       struct l64781_state* state = fe->demodulator_priv;
        int tmp;
 
 
 
 static int l64781_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct l64781_state* state = (struct l64781_state*) fe->demodulator_priv;
+       struct l64781_state* state = fe->demodulator_priv;
        int sync = l64781_readreg (state, 0x32);
        int gain = l64781_readreg (state, 0x0e);
 
 
 static int l64781_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct l64781_state* state = (struct l64781_state*) fe->demodulator_priv;
+       struct l64781_state* state = fe->demodulator_priv;
 
        /*   XXX FIXME: set up counting period (reg 0x26...0x28)
         */
 
 static int l64781_read_signal_strength(struct dvb_frontend* fe, u16* signal_strength)
 {
-       struct l64781_state* state = (struct l64781_state*) fe->demodulator_priv;
+       struct l64781_state* state = fe->demodulator_priv;
 
        u8 gain = l64781_readreg (state, 0x0e);
        *signal_strength = (gain << 8) | gain;
 
 static int l64781_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct l64781_state* state = (struct l64781_state*) fe->demodulator_priv;
+       struct l64781_state* state = fe->demodulator_priv;
 
        u8 avg_quality = 0xff - l64781_readreg (state, 0x33);
        *snr = (avg_quality << 8) | avg_quality; /* not exact, but...*/
 
 static int l64781_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-       struct l64781_state* state = (struct l64781_state*) fe->demodulator_priv;
+       struct l64781_state* state = fe->demodulator_priv;
 
        *ucblocks = l64781_readreg (state, 0x37)
           | (l64781_readreg (state, 0x38) << 8);
 
 static int l64781_sleep(struct dvb_frontend* fe)
 {
-       struct l64781_state* state = (struct l64781_state*) fe->demodulator_priv;
+       struct l64781_state* state = fe->demodulator_priv;
 
        /* Power down */
        return l64781_writereg (state, 0x3e, 0x5a);
 
 static int l64781_init(struct dvb_frontend* fe)
 {
-       struct l64781_state* state = (struct l64781_state*) fe->demodulator_priv;
+       struct l64781_state* state = fe->demodulator_priv;
 
         reset_and_configure (state);
 
 
 static void l64781_release(struct dvb_frontend* fe)
 {
-       struct l64781_state* state = (struct l64781_state*) fe->demodulator_priv;
+       struct l64781_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
                           { .addr = config->demod_address, .flags = I2C_M_RD, .buf = b1, .len = 1 } };
 
        /* allocate memory for the internal state */
-       state = (struct l64781_state*) kmalloc(sizeof(struct l64781_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct l64781_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 
 static int mt312_initfe(struct dvb_frontend* fe)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        int ret;
        u8 buf[2];
 
 static int mt312_send_master_cmd(struct dvb_frontend* fe,
                                 struct dvb_diseqc_master_cmd *c)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        int ret;
        u8 diseqc_mode;
 
 
 static int mt312_send_burst(struct dvb_frontend* fe, const fe_sec_mini_cmd_t c)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        const u8 mini_tab[2] = { 0x02, 0x03 };
 
        int ret;
 
 static int mt312_set_tone(struct dvb_frontend* fe, const fe_sec_tone_mode_t t)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        const u8 tone_tab[2] = { 0x01, 0x00 };
 
        int ret;
 
 static int mt312_set_voltage(struct dvb_frontend* fe, const fe_sec_voltage_t v)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        const u8 volt_tab[3] = { 0x00, 0x40, 0x00 };
 
        if (v > SEC_VOLTAGE_OFF)
 
 static int mt312_read_status(struct dvb_frontend* fe, fe_status_t *s)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        int ret;
        u8 status[3];
 
 
 static int mt312_read_ber(struct dvb_frontend* fe, u32 *ber)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        int ret;
        u8 buf[3];
 
 
 static int mt312_read_signal_strength(struct dvb_frontend* fe, u16 *signal_strength)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        int ret;
        u8 buf[3];
        u16 agc;
 
 static int mt312_read_snr(struct dvb_frontend* fe, u16 *snr)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        int ret;
        u8 buf[2];
 
 
 static int mt312_read_ucblocks(struct dvb_frontend* fe, u32 *ubc)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        int ret;
        u8 buf[2];
 
 static int mt312_set_frontend(struct dvb_frontend* fe,
                              struct dvb_frontend_parameters *p)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        int ret;
        u8 buf[5], config_val;
        u16 sr;
 static int mt312_get_frontend(struct dvb_frontend* fe,
                              struct dvb_frontend_parameters *p)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        int ret;
 
        if ((ret = mt312_get_inversion(state, &p->inversion)) < 0)
 
 static int mt312_sleep(struct dvb_frontend* fe)
 {
-       struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state *state = fe->demodulator_priv;
        int ret;
        u8 config;
 
 
 static void mt312_release(struct dvb_frontend* fe)
 {
-       struct mt312_state* state = (struct mt312_state*) fe->demodulator_priv;
+       struct mt312_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        struct mt312_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct mt312_state*) kmalloc(sizeof(struct mt312_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct mt312_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
 
        struct mt312_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct mt312_state*) kmalloc(sizeof(struct mt312_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct mt312_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
 
 
 static int nxt2002_load_firmware (struct dvb_frontend* fe, const struct firmware *fw)
 {
 
-       struct nxt2002_state* state = (struct nxt2002_state*) fe->demodulator_priv;
+       struct nxt2002_state* state = fe->demodulator_priv;
        u8 buf[256],written = 0,chunkpos = 0;
        u16 rambase,position,crc = 0;
 
 static int nxt2002_setup_frontend_parameters (struct dvb_frontend* fe,
                                             struct dvb_frontend_parameters *p)
 {
-       struct nxt2002_state* state = (struct nxt2002_state*) fe->demodulator_priv;
+       struct nxt2002_state* state = fe->demodulator_priv;
        u32 freq = 0;
        u16 tunerfreq = 0;
        u8 buf[4];
 
 static int nxt2002_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct nxt2002_state* state = (struct nxt2002_state*) fe->demodulator_priv;
+       struct nxt2002_state* state = fe->demodulator_priv;
        u8 lock;
        i2c_readbytes(state,0x31,&lock,1);
 
 
 static int nxt2002_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct nxt2002_state* state = (struct nxt2002_state*) fe->demodulator_priv;
+       struct nxt2002_state* state = fe->demodulator_priv;
        u8 b[3];
 
        nxt2002_readreg_multibyte(state,0xE6,b,3);
 
 static int nxt2002_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 {
-       struct nxt2002_state* state = (struct nxt2002_state*) fe->demodulator_priv;
+       struct nxt2002_state* state = fe->demodulator_priv;
        u8 b[2];
        u16 temp = 0;
 
 static int nxt2002_read_snr(struct dvb_frontend* fe, u16* snr)
 {
 
-       struct nxt2002_state* state = (struct nxt2002_state*) fe->demodulator_priv;
+       struct nxt2002_state* state = fe->demodulator_priv;
        u8 b[2];
        u16 temp = 0, temp2;
        u32 snrdb = 0;
 
 static int nxt2002_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-       struct nxt2002_state* state = (struct nxt2002_state*) fe->demodulator_priv;
+       struct nxt2002_state* state = fe->demodulator_priv;
        u8 b[3];
 
        nxt2002_readreg_multibyte(state,0xE6,b,3);
 
 static int nxt2002_init(struct dvb_frontend* fe)
 {
-       struct nxt2002_state* state = (struct nxt2002_state*) fe->demodulator_priv;
+       struct nxt2002_state* state = fe->demodulator_priv;
        const struct firmware *fw;
        int ret;
        u8 buf[2];
 
 static void nxt2002_release(struct dvb_frontend* fe)
 {
-       struct nxt2002_state* state = (struct nxt2002_state*) fe->demodulator_priv;
+       struct nxt2002_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        u8 buf [] = {0,0,0,0,0};
 
        /* allocate memory for the internal state */
-       state = (struct nxt2002_state*) kmalloc(sizeof(struct nxt2002_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct nxt2002_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 
 static void nxt6000_setup(struct dvb_frontend* fe)
 {
-       struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
+       struct nxt6000_state* state = fe->demodulator_priv;
 
        nxt6000_writereg(state, RS_COR_SYNC_PARAM, SYNC_PARAM);
        nxt6000_writereg(state, BER_CTRL, /*(1 << 2) | */ (0x01 << 1) | 0x01);
 static int nxt6000_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
        u8 core_status;
-       struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
+       struct nxt6000_state* state = fe->demodulator_priv;
 
        *status = 0;
 
 
 static int nxt6000_init(struct dvb_frontend* fe)
 {
-       struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
+       struct nxt6000_state* state = fe->demodulator_priv;
 
        nxt6000_reset(state);
        nxt6000_setup(fe);
 
 static int nxt6000_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *param)
 {
-       struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
+       struct nxt6000_state* state = fe->demodulator_priv;
        int result;
 
        nxt6000_writereg(state, ENABLE_TUNER_IIC, 0x01);        /* open i2c bus switch */
 
 static void nxt6000_release(struct dvb_frontend* fe)
 {
-       struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
+       struct nxt6000_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
 static int nxt6000_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
+       struct nxt6000_state* state = fe->demodulator_priv;
 
        *snr = nxt6000_readreg( state, OFDM_CHC_SNR) / 8;
 
 
 static int nxt6000_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
+       struct nxt6000_state* state = fe->demodulator_priv;
 
        nxt6000_writereg( state, VIT_COR_INTSTAT, 0x18 );
 
 
 static int nxt6000_read_signal_strength(struct dvb_frontend* fe, u16* signal_strength)
 {
-       struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
+       struct nxt6000_state* state = fe->demodulator_priv;
 
        *signal_strength = (short) (511 -
                (nxt6000_readreg(state, AGC_GAIN_1) +
        struct nxt6000_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct nxt6000_state*) kmalloc(sizeof(struct nxt6000_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct nxt6000_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 
 static int or51132_load_firmware (struct dvb_frontend* fe, const struct firmware *fw)
 {
-       struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
+       struct or51132_state* state = fe->demodulator_priv;
        static u8 run_buf[] = {0x7F,0x01};
        static u8 get_ver_buf[] = {0x04,0x00,0x30,0x00,0x00};
        u8 rec_buf[14];
 
 static int or51132_setmode(struct dvb_frontend* fe)
 {
-       struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
+       struct or51132_state* state = fe->demodulator_priv;
        unsigned char cmd_buf[4];
 
        dprintk("setmode %d\n",(int)state->current_modulation);
 {
        int ret;
        u8 buf[4];
-       struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
+       struct or51132_state* state = fe->demodulator_priv;
        const struct firmware *fw;
 
        /* Change only if we are actually changing the modulation */
 
 static int or51132_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
+       struct or51132_state* state = fe->demodulator_priv;
        unsigned char rec_buf[2];
        unsigned char snd_buf[2];
        *status = 0;
 
 static int or51132_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 {
-       struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
+       struct or51132_state* state = fe->demodulator_priv;
        unsigned char rec_buf[2];
        unsigned char snd_buf[2];
        u8 rcvr_stat;
 
 static int or51132_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
+       struct or51132_state* state = fe->demodulator_priv;
        unsigned char rec_buf[2];
        unsigned char snd_buf[2];
        u16 snr_equ;
 
 static void or51132_release(struct dvb_frontend* fe)
 {
-       struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
+       struct or51132_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
 
 static int sp8870_set_frontend_parameters (struct dvb_frontend* fe,
                                           struct dvb_frontend_parameters *p)
 {
-       struct sp8870_state* state = (struct sp8870_state*) fe->demodulator_priv;
+       struct sp8870_state* state = fe->demodulator_priv;
        int  err;
        u16 reg0xc05;
 
 
 static int sp8870_init (struct dvb_frontend* fe)
 {
-       struct sp8870_state* state = (struct sp8870_state*) fe->demodulator_priv;
+       struct sp8870_state* state = fe->demodulator_priv;
         const struct firmware *fw = NULL;
 
        sp8870_wake_up(state);
 
 static int sp8870_read_status (struct dvb_frontend* fe, fe_status_t * fe_status)
 {
-       struct sp8870_state* state = (struct sp8870_state*) fe->demodulator_priv;
+       struct sp8870_state* state = fe->demodulator_priv;
        int status;
        int signal;
 
 
 static int sp8870_read_ber (struct dvb_frontend* fe, u32 * ber)
 {
-       struct sp8870_state* state = (struct sp8870_state*) fe->demodulator_priv;
+       struct sp8870_state* state = fe->demodulator_priv;
        int ret;
        u32 tmp;
 
 
 static int sp8870_read_signal_strength(struct dvb_frontend* fe,  u16 * signal)
 {
-       struct sp8870_state* state = (struct sp8870_state*) fe->demodulator_priv;
+       struct sp8870_state* state = fe->demodulator_priv;
        int ret;
        u16 tmp;
 
 
 static int sp8870_read_uncorrected_blocks (struct dvb_frontend* fe, u32* ublocks)
 {
-       struct sp8870_state* state = (struct sp8870_state*) fe->demodulator_priv;
+       struct sp8870_state* state = fe->demodulator_priv;
        int ret;
 
        *ublocks = 0;
 
 static int sp8870_set_frontend (struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct sp8870_state* state = (struct sp8870_state*) fe->demodulator_priv;
+       struct sp8870_state* state = fe->demodulator_priv;
 
        /*
            The firmware of the sp8870 sometimes locks up after setting frontend parameters.
 
 static int sp8870_sleep(struct dvb_frontend* fe)
 {
-       struct sp8870_state* state = (struct sp8870_state*) fe->demodulator_priv;
+       struct sp8870_state* state = fe->demodulator_priv;
 
        // tristate TS output and disable interface pins
        return sp8870_writereg(state, 0xC18, 0x000);
 
 static void sp8870_release(struct dvb_frontend* fe)
 {
-       struct sp8870_state* state = (struct sp8870_state*) fe->demodulator_priv;
+       struct sp8870_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        struct sp8870_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct sp8870_state*) kmalloc(sizeof(struct sp8870_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct sp8870_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
  */
 static int sp887x_initial_setup (struct dvb_frontend* fe, const struct firmware *fw)
 {
-       struct sp887x_state* state = (struct sp887x_state*) fe->demodulator_priv;
+       struct sp887x_state* state = fe->demodulator_priv;
        u8 buf [BLOCKSIZE+2];
        int i;
        int fw_size = fw->size;
 static int sp887x_setup_frontend_parameters (struct dvb_frontend* fe,
                                             struct dvb_frontend_parameters *p)
 {
-       struct sp887x_state* state = (struct sp887x_state*) fe->demodulator_priv;
+       struct sp887x_state* state = fe->demodulator_priv;
        int actual_freq, err;
        u16 val, reg0xc05;
 
 
 static int sp887x_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct sp887x_state* state = (struct sp887x_state*) fe->demodulator_priv;
+       struct sp887x_state* state = fe->demodulator_priv;
        u16 snr12 = sp887x_readreg(state, 0xf16);
        u16 sync0x200 = sp887x_readreg(state, 0x200);
        u16 sync0xf17 = sp887x_readreg(state, 0xf17);
 
 static int sp887x_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct sp887x_state* state = (struct sp887x_state*) fe->demodulator_priv;
+       struct sp887x_state* state = fe->demodulator_priv;
 
        *ber = (sp887x_readreg(state, 0xc08) & 0x3f) |
               (sp887x_readreg(state, 0xc07) << 6);
 
 static int sp887x_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 {
-       struct sp887x_state* state = (struct sp887x_state*) fe->demodulator_priv;
+       struct sp887x_state* state = fe->demodulator_priv;
 
        u16 snr12 = sp887x_readreg(state, 0xf16);
        u32 signal = 3 * (snr12 << 4);
 
 static int sp887x_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct sp887x_state* state = (struct sp887x_state*) fe->demodulator_priv;
+       struct sp887x_state* state = fe->demodulator_priv;
 
        u16 snr12 = sp887x_readreg(state, 0xf16);
        *snr = (snr12 << 4) | (snr12 >> 8);
 
 static int sp887x_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-       struct sp887x_state* state = (struct sp887x_state*) fe->demodulator_priv;
+       struct sp887x_state* state = fe->demodulator_priv;
 
        *ucblocks = sp887x_readreg(state, 0xc0c);
        if (*ucblocks == 0xfff)
 
 static int sp887x_sleep(struct dvb_frontend* fe)
 {
-       struct sp887x_state* state = (struct sp887x_state*) fe->demodulator_priv;
+       struct sp887x_state* state = fe->demodulator_priv;
 
        /* tristate TS output and disable interface pins */
        sp887x_writereg(state, 0xc18, 0x000);
 
 static int sp887x_init(struct dvb_frontend* fe)
 {
-       struct sp887x_state* state = (struct sp887x_state*) fe->demodulator_priv;
+       struct sp887x_state* state = fe->demodulator_priv;
         const struct firmware *fw = NULL;
        int ret;
 
 
 static void sp887x_release(struct dvb_frontend* fe)
 {
-       struct sp887x_state* state = (struct sp887x_state*) fe->demodulator_priv;
+       struct sp887x_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        struct sp887x_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct sp887x_state*) kmalloc(sizeof(struct sp887x_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct sp887x_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 
 int stv0297_enable_plli2c(struct dvb_frontend *fe)
 {
-       struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
+       struct stv0297_state *state = fe->demodulator_priv;
 
        stv0297_writereg(state, 0x87, 0x78);
        stv0297_writereg(state, 0x86, 0xc8);
 
 static int stv0297_init(struct dvb_frontend *fe)
 {
-       struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
+       struct stv0297_state *state = fe->demodulator_priv;
        int i;
 
        /* soft reset */
 
 static int stv0297_sleep(struct dvb_frontend *fe)
 {
-       struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
+       struct stv0297_state *state = fe->demodulator_priv;
 
        stv0297_writereg_mask(state, 0x80, 1, 1);
 
 
 static int stv0297_read_status(struct dvb_frontend *fe, fe_status_t * status)
 {
-       struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
+       struct stv0297_state *state = fe->demodulator_priv;
 
        u8 sync = stv0297_readreg(state, 0xDF);
 
 
 static int stv0297_read_ber(struct dvb_frontend *fe, u32 * ber)
 {
-       struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
+       struct stv0297_state *state = fe->demodulator_priv;
        u8 BER[3];
 
        stv0297_writereg(state, 0xA0, 0x80);    // Start Counting bit errors for 4096 Bytes
 
 static int stv0297_read_signal_strength(struct dvb_frontend *fe, u16 * strength)
 {
-       struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
+       struct stv0297_state *state = fe->demodulator_priv;
        u8 STRENGTH[2];
 
        stv0297_readregs(state, 0x41, STRENGTH, 2);
 
 static int stv0297_read_snr(struct dvb_frontend *fe, u16 * snr)
 {
-       struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
+       struct stv0297_state *state = fe->demodulator_priv;
        u8 SNR[2];
 
        stv0297_readregs(state, 0x07, SNR, 2);
 
 static int stv0297_read_ucblocks(struct dvb_frontend *fe, u32 * ucblocks)
 {
-       struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
+       struct stv0297_state *state = fe->demodulator_priv;
 
        *ucblocks = (stv0297_readreg(state, 0xD5) << 8)
                | stv0297_readreg(state, 0xD4);
 
 static int stv0297_set_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *p)
 {
-       struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
+       struct stv0297_state *state = fe->demodulator_priv;
        int u_threshold;
        int initial_u;
        int blind_u;
 
 static int stv0297_get_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *p)
 {
-       struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
+       struct stv0297_state *state = fe->demodulator_priv;
        int reg_00, reg_83;
 
        reg_00 = stv0297_readreg(state, 0x00);
 
 static void stv0297_release(struct dvb_frontend *fe)
 {
-       struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
+       struct stv0297_state *state = fe->demodulator_priv;
        kfree(state);
 }
 
        struct stv0297_state *state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct stv0297_state *) kmalloc(sizeof(struct stv0297_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct stv0297_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
 
 
 
 int stv0299_writereg (struct dvb_frontend* fe, u8 reg, u8 data)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
 
        return stv0299_writeregI(state, reg, data);
 }
 
 static int stv0299_set_symbolrate (struct dvb_frontend* fe, u32 srate)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
        u64 big = srate;
        u32 ratio;
 
 static int stv0299_send_diseqc_msg (struct dvb_frontend* fe,
                                    struct dvb_diseqc_master_cmd *m)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
        u8 val;
        int i;
 
 
 static int stv0299_send_diseqc_burst (struct dvb_frontend* fe, fe_sec_mini_cmd_t burst)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
        u8 val;
 
        dprintk ("%s\n", __FUNCTION__);
 
 static int stv0299_set_tone (struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
        u8 val;
 
        if (stv0299_wait_diseqc_idle (state, 100) < 0)
 
 static int stv0299_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t voltage)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
        u8 reg0x08;
        u8 reg0x0c;
 
 
 static int stv0299_init (struct dvb_frontend* fe)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
        int i;
 
        dprintk("stv0299: init chip\n");
 
 static int stv0299_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
 
        u8 signal = 0xff - stv0299_readreg (state, 0x18);
        u8 sync = stv0299_readreg (state, 0x1b);
 
 static int stv0299_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
 
        if (state->errmode != STATUS_BER) return 0;
        *ber = (stv0299_readreg (state, 0x1d) << 8) | stv0299_readreg (state, 0x1e);
 
 static int stv0299_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
 
        s32 signal =  0xffff - ((stv0299_readreg (state, 0x18) << 8)
                               | stv0299_readreg (state, 0x19));
 
 static int stv0299_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
 
        s32 xsnr = 0xffff - ((stv0299_readreg (state, 0x24) << 8)
                           | stv0299_readreg (state, 0x25));
 
 static int stv0299_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
 
        if (state->errmode != STATUS_UCBLOCKS) *ucblocks = 0;
        else *ucblocks = (stv0299_readreg (state, 0x1d) << 8) | stv0299_readreg (state, 0x1e);
 
 static int stv0299_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters * p)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
        int invval = 0;
 
        dprintk ("%s : FE_SET_FRONTEND\n", __FUNCTION__);
 
 static int stv0299_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters * p)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
        s32 derot_freq;
        int invval;
 
 
 static int stv0299_sleep(struct dvb_frontend* fe)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
 
        stv0299_writeregI(state, 0x02, 0x80);
        state->initialised = 0;
 
 static int stv0299_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fesettings)
 {
-        struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+        struct stv0299_state* state = fe->demodulator_priv;
 
        fesettings->min_delay_ms = state->config->min_delay_ms;
        if (fesettings->parameters.u.qpsk.symbol_rate < 10000000) {
 
 static void stv0299_release(struct dvb_frontend* fe)
 {
-       struct stv0299_state* state = (struct stv0299_state*) fe->demodulator_priv;
+       struct stv0299_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        int id;
 
        /* allocate memory for the internal state */
-       state = (struct stv0299_state*) kmalloc(sizeof(struct stv0299_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct stv0299_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 
 static int tda10021_init (struct dvb_frontend *fe)
 {
-       struct tda10021_state* state = (struct tda10021_state*) fe->demodulator_priv;
+       struct tda10021_state* state = fe->demodulator_priv;
        int i;
 
        dprintk("DVB: TDA10021(%d): init chip\n", fe->adapter->num);
 static int tda10021_set_parameters (struct dvb_frontend *fe,
                            struct dvb_frontend_parameters *p)
 {
-       struct tda10021_state* state = (struct tda10021_state*) fe->demodulator_priv;
+       struct tda10021_state* state = fe->demodulator_priv;
 
        //table for QAM4-QAM256 ready  QAM4  QAM16 QAM32 QAM64 QAM128 QAM256
        //CONF
 
 static int tda10021_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct tda10021_state* state = (struct tda10021_state*) fe->demodulator_priv;
+       struct tda10021_state* state = fe->demodulator_priv;
        int sync;
 
        *status = 0;
 
 static int tda10021_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct tda10021_state* state = (struct tda10021_state*) fe->demodulator_priv;
+       struct tda10021_state* state = fe->demodulator_priv;
 
        u32 _ber = tda10021_readreg(state, 0x14) |
                (tda10021_readreg(state, 0x15) << 8) |
 
 static int tda10021_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 {
-       struct tda10021_state* state = (struct tda10021_state*) fe->demodulator_priv;
+       struct tda10021_state* state = fe->demodulator_priv;
 
        u8 gain = tda10021_readreg(state, 0x17);
        *strength = (gain << 8) | gain;
 
 static int tda10021_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct tda10021_state* state = (struct tda10021_state*) fe->demodulator_priv;
+       struct tda10021_state* state = fe->demodulator_priv;
 
        u8 quality = ~tda10021_readreg(state, 0x18);
        *snr = (quality << 8) | quality;
 
 static int tda10021_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-       struct tda10021_state* state = (struct tda10021_state*) fe->demodulator_priv;
+       struct tda10021_state* state = fe->demodulator_priv;
 
        *ucblocks = tda10021_readreg (state, 0x13) & 0x7f;
        if (*ucblocks == 0x7f)
 
 static int tda10021_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct tda10021_state* state = (struct tda10021_state*) fe->demodulator_priv;
+       struct tda10021_state* state = fe->demodulator_priv;
        int sync;
        s8 afc = 0;
 
 
 static int tda10021_sleep(struct dvb_frontend* fe)
 {
-       struct tda10021_state* state = (struct tda10021_state*) fe->demodulator_priv;
+       struct tda10021_state* state = fe->demodulator_priv;
 
        tda10021_writereg (state, 0x1b, 0x02);  /* pdown ADC */
        tda10021_writereg (state, 0x00, 0x80);  /* standby */
 
 static void tda10021_release(struct dvb_frontend* fe)
 {
-       struct tda10021_state* state = (struct tda10021_state*) fe->demodulator_priv;
+       struct tda10021_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        struct tda10021_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct tda10021_state*) kmalloc(sizeof(struct tda10021_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct tda10021_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 static int tda8083_send_diseqc_msg (struct dvb_frontend* fe,
                                    struct dvb_diseqc_master_cmd *m)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
        int i;
 
        tda8083_writereg (state, 0x29, (m->msg_len - 3) | (1 << 2)); /* enable */
 
 static int tda8083_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
 
        u8 signal = ~tda8083_readreg (state, 0x01);
        u8 sync = tda8083_readreg (state, 0x02);
 
 static int tda8083_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
 
        u8 signal = ~tda8083_readreg (state, 0x01);
        *strength = (signal << 8) | signal;
 
 static int tda8083_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
 
        u8 _snr = tda8083_readreg (state, 0x08);
        *snr = (_snr << 8) | _snr;
 
 static int tda8083_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
 
        state->config->pll_set(fe, p);
        tda8083_set_inversion (state, p->inversion);
 
 static int tda8083_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
 
        /*  FIXME: get symbolrate & frequency offset...*/
        /*p->frequency = ???;*/
 
 static int tda8083_sleep(struct dvb_frontend* fe)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
 
        tda8083_writereg (state, 0x00, 0x02);
        return 0;
 
 static int tda8083_init(struct dvb_frontend* fe)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
        int i;
 
        for (i=0; i<44; i++)
 
 static int tda8083_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t burst)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
 
        tda8083_send_diseqc_burst (state, burst);
        tda8083_writereg (state, 0x00, 0x3c);
 
 static int tda8083_diseqc_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
 
        tda8083_set_tone (state, tone);
        tda8083_writereg (state, 0x00, 0x3c);
 
 static int tda8083_diseqc_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
 
        tda8083_set_voltage (state, voltage);
        tda8083_writereg (state, 0x00, 0x3c);
 
 static void tda8083_release(struct dvb_frontend* fe)
 {
-       struct tda8083_state* state = (struct tda8083_state*) fe->demodulator_priv;
+       struct tda8083_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        struct tda8083_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct tda8083_state*) kmalloc(sizeof(struct tda8083_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct tda8083_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 
 static int tda8044_init(struct dvb_frontend* fe)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
        int ret;
 
        /*
 
 static int tda8083_init(struct dvb_frontend* fe)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        tda80xx_write(state, 0x00, tda8083_inittab, sizeof(tda8083_inittab));
 
 
 static int tda80xx_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        switch (voltage) {
        case SEC_VOLTAGE_13:
 
 static int tda80xx_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        switch (tone) {
        case SEC_TONE_OFF:
 
 static int tda80xx_send_diseqc_msg(struct dvb_frontend* fe, struct dvb_diseqc_master_cmd *cmd)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        if (cmd->msg_len > 6)
                return -EINVAL;
 
 static int tda80xx_send_diseqc_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t cmd)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        switch (cmd) {
        case SEC_MINI_A:
 
 static int tda80xx_sleep(struct dvb_frontend* fe)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        tda80xx_writereg(state, 0x00, 0x02);    /* enter standby */
 
 
 static int tda80xx_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        tda80xx_writereg(state, 0x1c, 0x80);
        state->config->pll_set(fe, p);
 
 static int tda80xx_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        if (!state->config->irq)
                tda80xx_read_status_int(state);
 
 static int tda80xx_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        if (!state->config->irq)
                tda80xx_read_status_int(state);
 
 static int tda80xx_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
        int ret;
        u8 buf[3];
 
 
 static int tda80xx_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        u8 gain = ~tda80xx_readreg(state, 0x01);
        *strength = (gain << 8) | gain;
 
 static int tda80xx_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        u8 quality = tda80xx_readreg(state, 0x08);
        *snr = (quality << 8) | quality;
 
 static int tda80xx_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        *ucblocks = tda80xx_readreg(state, 0x0f);
        if (*ucblocks == 0xff)
 
 static int tda80xx_init(struct dvb_frontend* fe)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        switch(state->id) {
        case ID_TDA8044:
 
 static void tda80xx_release(struct dvb_frontend* fe)
 {
-       struct tda80xx_state* state = (struct tda80xx_state*) fe->demodulator_priv;
+       struct tda80xx_state* state = fe->demodulator_priv;
 
        if (state->config->irq)
                free_irq(state->config->irq, &state->worklet);
        int ret;
 
        /* allocate memory for the internal state */
-       state = (struct tda80xx_state*) kmalloc(sizeof(struct tda80xx_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct tda80xx_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */
 
 
 static int ves1820_init(struct dvb_frontend* fe)
 {
-       struct ves1820_state* state = (struct ves1820_state*) fe->demodulator_priv;
+       struct ves1820_state* state = fe->demodulator_priv;
        int i;
        int val;
 
 
 static int ves1820_set_parameters(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct ves1820_state* state = (struct ves1820_state*) fe->demodulator_priv;
+       struct ves1820_state* state = fe->demodulator_priv;
        static const u8 reg0x00[] = { 0x00, 0x04, 0x08, 0x0c, 0x10 };
        static const u8 reg0x01[] = { 140, 140, 106, 100, 92 };
        static const u8 reg0x05[] = { 135, 100, 70, 54, 38 };
 
 static int ves1820_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct ves1820_state* state = (struct ves1820_state*) fe->demodulator_priv;
+       struct ves1820_state* state = fe->demodulator_priv;
        int sync;
 
        *status = 0;
 
 static int ves1820_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct ves1820_state* state = (struct ves1820_state*) fe->demodulator_priv;
+       struct ves1820_state* state = fe->demodulator_priv;
 
        u32 _ber = ves1820_readreg(state, 0x14) |
                        (ves1820_readreg(state, 0x15) << 8) |
 
 static int ves1820_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 {
-       struct ves1820_state* state = (struct ves1820_state*) fe->demodulator_priv;
+       struct ves1820_state* state = fe->demodulator_priv;
 
        u8 gain = ves1820_readreg(state, 0x17);
        *strength = (gain << 8) | gain;
 
 static int ves1820_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct ves1820_state* state = (struct ves1820_state*) fe->demodulator_priv;
+       struct ves1820_state* state = fe->demodulator_priv;
 
        u8 quality = ~ves1820_readreg(state, 0x18);
        *snr = (quality << 8) | quality;
 
 static int ves1820_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-       struct ves1820_state* state = (struct ves1820_state*) fe->demodulator_priv;
+       struct ves1820_state* state = fe->demodulator_priv;
 
        *ucblocks = ves1820_readreg(state, 0x13) & 0x7f;
        if (*ucblocks == 0x7f)
 
 static int ves1820_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct ves1820_state* state = (struct ves1820_state*) fe->demodulator_priv;
+       struct ves1820_state* state = fe->demodulator_priv;
        int sync;
        s8 afc = 0;
 
 
 static int ves1820_sleep(struct dvb_frontend* fe)
 {
-       struct ves1820_state* state = (struct ves1820_state*) fe->demodulator_priv;
+       struct ves1820_state* state = fe->demodulator_priv;
 
        ves1820_writereg(state, 0x1b, 0x02);    /* pdown ADC */
        ves1820_writereg(state, 0x00, 0x80);    /* standby */
 
 static void ves1820_release(struct dvb_frontend* fe)
 {
-       struct ves1820_state* state = (struct ves1820_state*) fe->demodulator_priv;
+       struct ves1820_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        struct ves1820_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct ves1820_state*) kmalloc(sizeof(struct ves1820_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct ves1820_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
 
 
 
 static int ves1x93_init (struct dvb_frontend* fe)
 {
-       struct ves1x93_state* state = (struct ves1x93_state*) fe->demodulator_priv;
+       struct ves1x93_state* state = fe->demodulator_priv;
        int i;
        int val;
 
 
 static int ves1x93_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t voltage)
 {
-       struct ves1x93_state* state = (struct ves1x93_state*) fe->demodulator_priv;
+       struct ves1x93_state* state = fe->demodulator_priv;
 
        switch (voltage) {
        case SEC_VOLTAGE_13:
 
 static int ves1x93_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
-       struct ves1x93_state* state = (struct ves1x93_state*) fe->demodulator_priv;
+       struct ves1x93_state* state = fe->demodulator_priv;
 
        u8 sync = ves1x93_readreg (state, 0x0e);
 
 
 static int ves1x93_read_ber(struct dvb_frontend* fe, u32* ber)
 {
-       struct ves1x93_state* state = (struct ves1x93_state*) fe->demodulator_priv;
+       struct ves1x93_state* state = fe->demodulator_priv;
 
        *ber = ves1x93_readreg (state, 0x15);
        *ber |= (ves1x93_readreg (state, 0x16) << 8);
 
 static int ves1x93_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 {
-       struct ves1x93_state* state = (struct ves1x93_state*) fe->demodulator_priv;
+       struct ves1x93_state* state = fe->demodulator_priv;
 
        u8 signal = ~ves1x93_readreg (state, 0x0b);
        *strength = (signal << 8) | signal;
 
 static int ves1x93_read_snr(struct dvb_frontend* fe, u16* snr)
 {
-       struct ves1x93_state* state = (struct ves1x93_state*) fe->demodulator_priv;
+       struct ves1x93_state* state = fe->demodulator_priv;
 
        u8 _snr = ~ves1x93_readreg (state, 0x1c);
        *snr = (_snr << 8) | _snr;
 
 static int ves1x93_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
-       struct ves1x93_state* state = (struct ves1x93_state*) fe->demodulator_priv;
+       struct ves1x93_state* state = fe->demodulator_priv;
 
        *ucblocks = ves1x93_readreg (state, 0x18) & 0x7f;
 
 
 static int ves1x93_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct ves1x93_state* state = (struct ves1x93_state*) fe->demodulator_priv;
+       struct ves1x93_state* state = fe->demodulator_priv;
 
        ves1x93_writereg(state, 0x00, 0x11);
        state->config->pll_set(fe, p);
 
 static int ves1x93_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
-       struct ves1x93_state* state = (struct ves1x93_state*) fe->demodulator_priv;
+       struct ves1x93_state* state = fe->demodulator_priv;
        int afc;
 
        afc = ((int)((char)(ves1x93_readreg (state, 0x0a) << 1)))/2;
 
 static int ves1x93_sleep(struct dvb_frontend* fe)
 {
-       struct ves1x93_state* state = (struct ves1x93_state*) fe->demodulator_priv;
+       struct ves1x93_state* state = fe->demodulator_priv;
 
        return ves1x93_writereg (state, 0x00, 0x08);
 }
 
 static void ves1x93_release(struct dvb_frontend* fe)
 {
-       struct ves1x93_state* state = (struct ves1x93_state*) fe->demodulator_priv;
+       struct ves1x93_state* state = fe->demodulator_priv;
        kfree(state);
 }
 
        u8 identity;
 
        /* allocate memory for the internal state */
-       state = (struct ves1x93_state*) kmalloc(sizeof(struct ves1x93_state), GFP_KERNEL);
+       state = kmalloc(sizeof(struct ves1x93_state), GFP_KERNEL);
        if (state == NULL) goto error;
 
        /* setup the state */