Commit 5a0deeed authored May 03, 2011 by Olivier Grenie Committed by Mauro Carvalho Chehab May 20, 2011

[media] DiBxxxx: get rid of DMA buffer on stack

This patch removes the remaining on-stack buffer for USB DMA transfer.
This patch also reduces the stack memory usage.

Cc: stable@kernel.org
Cc: Florian Mickler <florian@mickler.org>
Signed-off-by: Olivier Grenie <olivier.grenie@dibcom.fr>
Signed-off-by: Patrick Boettcher <patrick.boettcher@dibcom.fr>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

parent 027e99ab

drivers/media/dvb/frontends/dib0070.c

+30 −10

Original line number	Diff line number	Diff line
		@@ -73,27 +73,47 @@ struct dib0070_state {

		u8 wbd_gain_current;
		u16 wbd_offset_3_3[2];

		/* for the I2C transfer */
		struct i2c_msg msg[2];
		u8 i2c_write_buffer[3];
		u8 i2c_read_buffer[2];
		};

		static uint16_t dib0070_read_reg(struct dib0070_state *state, u8 reg)
		{
		u8 b[2];
		struct i2c_msg msg[2] = {
		{ .addr = state->cfg->i2c_address, .flags = 0, .buf = &reg, .len = 1 },
		{ .addr = state->cfg->i2c_address, .flags = I2C_M_RD, .buf = b, .len = 2 },
		};
		if (i2c_transfer(state->i2c, msg, 2) != 2) {
		state->i2c_write_buffer[0] = reg;

		memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
		state->msg[0].addr = state->cfg->i2c_address;
		state->msg[0].flags = 0;
		state->msg[0].buf = state->i2c_write_buffer;
		state->msg[0].len = 1;
		state->msg[1].addr = state->cfg->i2c_address;
		state->msg[1].flags = I2C_M_RD;
		state->msg[1].buf = state->i2c_read_buffer;
		state->msg[1].len = 2;

		if (i2c_transfer(state->i2c, state->msg, 2) != 2) {
		printk(KERN_WARNING "DiB0070 I2C read failed\n");
		return 0;
		}
		return (b[0] << 8) \| b[1];
		return (state->i2c_read_buffer[0] << 8) \| state->i2c_read_buffer[1];
		}

		static int dib0070_write_reg(struct dib0070_state *state, u8 reg, u16 val)
		{
		u8 b[3] = { reg, val >> 8, val & 0xff };
		struct i2c_msg msg = { .addr = state->cfg->i2c_address, .flags = 0, .buf = b, .len = 3 };
		if (i2c_transfer(state->i2c, &msg, 1) != 1) {
		state->i2c_write_buffer[0] = reg;
		state->i2c_write_buffer[1] = val >> 8;
		state->i2c_write_buffer[2] = val & 0xff;

		memset(state->msg, 0, sizeof(struct i2c_msg));
		state->msg[0].addr = state->cfg->i2c_address;
		state->msg[0].flags = 0;
		state->msg[0].buf = state->i2c_write_buffer;
		state->msg[0].len = 3;

		if (i2c_transfer(state->i2c, state->msg, 1) != 1) {
		printk(KERN_WARNING "DiB0070 I2C write failed\n");
		return -EREMOTEIO;
		}

drivers/media/dvb/frontends/dib0090.c

+54 −17

Original line number	Diff line number	Diff line
		@@ -191,6 +191,11 @@ struct dib0090_state {
		u8 wbd_calibration_gain;
		const struct dib0090_wbd_slope *current_wbd_table;
		u16 wbdmux;

		/* for the I2C transfer */
		struct i2c_msg msg[2];
		u8 i2c_write_buffer[3];
		u8 i2c_read_buffer[2];
		};

		struct dib0090_fw_state {
		@@ -198,27 +203,48 @@ struct dib0090_fw_state {
		struct dvb_frontend *fe;
		struct dib0090_identity identity;
		const struct dib0090_config *config;

		/* for the I2C transfer */
		struct i2c_msg msg;
		u8 i2c_write_buffer[2];
		u8 i2c_read_buffer[2];
		};

		static u16 dib0090_read_reg(struct dib0090_state *state, u8 reg)
		{
		u8 b[2];
		struct i2c_msg msg[2] = {
		{.addr = state->config->i2c_address, .flags = 0, .buf = &reg, .len = 1},
		{.addr = state->config->i2c_address, .flags = I2C_M_RD, .buf = b, .len = 2},
		};
		if (i2c_transfer(state->i2c, msg, 2) != 2) {
		state->i2c_write_buffer[0] = reg;

		memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
		state->msg[0].addr = state->config->i2c_address;
		state->msg[0].flags = 0;
		state->msg[0].buf = state->i2c_write_buffer;
		state->msg[0].len = 1;
		state->msg[1].addr = state->config->i2c_address;
		state->msg[1].flags = I2C_M_RD;
		state->msg[1].buf = state->i2c_read_buffer;
		state->msg[1].len = 2;

		if (i2c_transfer(state->i2c, state->msg, 2) != 2) {
		printk(KERN_WARNING "DiB0090 I2C read failed\n");
		return 0;
		}
		return (b[0] << 8) \| b[1];

		return (state->i2c_read_buffer[0] << 8) \| state->i2c_read_buffer[1];
		}

		static int dib0090_write_reg(struct dib0090_state *state, u32 reg, u16 val)
		{
		u8 b[3] = { reg & 0xff, val >> 8, val & 0xff };
		struct i2c_msg msg = {.addr = state->config->i2c_address, .flags = 0, .buf = b, .len = 3 };
		if (i2c_transfer(state->i2c, &msg, 1) != 1) {
		state->i2c_write_buffer[0] = reg & 0xff;
		state->i2c_write_buffer[1] = val >> 8;
		state->i2c_write_buffer[2] = val & 0xff;

		memset(state->msg, 0, sizeof(struct i2c_msg));
		state->msg[0].addr = state->config->i2c_address;
		state->msg[0].flags = 0;
		state->msg[0].buf = state->i2c_write_buffer;
		state->msg[0].len = 3;

		if (i2c_transfer(state->i2c, state->msg, 1) != 1) {
		printk(KERN_WARNING "DiB0090 I2C write failed\n");
		return -EREMOTEIO;
		}
		@@ -227,20 +253,31 @@ static int dib0090_write_reg(struct dib0090_state *state, u32 reg, u16 val)

		static u16 dib0090_fw_read_reg(struct dib0090_fw_state *state, u8 reg)
		{
		u8 b[2];
		struct i2c_msg msg = {.addr = reg, .flags = I2C_M_RD, .buf = b, .len = 2 };
		if (i2c_transfer(state->i2c, &msg, 1) != 1) {
		state->i2c_write_buffer[0] = reg;

		memset(&state->msg, 0, sizeof(struct i2c_msg));
		state->msg.addr = reg;
		state->msg.flags = I2C_M_RD;
		state->msg.buf = state->i2c_read_buffer;
		state->msg.len = 2;
		if (i2c_transfer(state->i2c, &state->msg, 1) != 1) {
		printk(KERN_WARNING "DiB0090 I2C read failed\n");
		return 0;
		}
		return (b[0] << 8) \| b[1];
		return (state->i2c_read_buffer[0] << 8) \| state->i2c_read_buffer[1];
		}

		static int dib0090_fw_write_reg(struct dib0090_fw_state *state, u8 reg, u16 val)
		{
		u8 b[2] = { val >> 8, val & 0xff };
		struct i2c_msg msg = {.addr = reg, .flags = 0, .buf = b, .len = 2 };
		if (i2c_transfer(state->i2c, &msg, 1) != 1) {
		state->i2c_write_buffer[0] = val >> 8;
		state->i2c_write_buffer[1] = val & 0xff;

		memset(&state->msg, 0, sizeof(struct i2c_msg));
		state->msg.addr = reg;
		state->msg.flags = 0;
		state->msg.buf = state->i2c_write_buffer;
		state->msg.len = 2;
		if (i2c_transfer(state->i2c, &state->msg, 1) != 1) {
		printk(KERN_WARNING "DiB0090 I2C write failed\n");
		return -EREMOTEIO;
		}

drivers/media/dvb/frontends/dib7000m.c

+32 −17

Original line number	Diff line number	Diff line
		@@ -50,6 +50,11 @@ struct dib7000m_state {
		u16 revision;

		u8 agc_state;

		/* for the I2C transfer */
		struct i2c_msg msg[2];
		u8 i2c_write_buffer[4];
		u8 i2c_read_buffer[2];
		};

		enum dib7000m_power_mode {
		@@ -64,29 +69,39 @@ enum dib7000m_power_mode {

		static u16 dib7000m_read_word(struct dib7000m_state *state, u16 reg)
		{
		u8 wb[2] = { (reg >> 8) \| 0x80, reg & 0xff };
		u8 rb[2];
		struct i2c_msg msg[2] = {
		{ .addr = state->i2c_addr >> 1, .flags = 0, .buf = wb, .len = 2 },
		{ .addr = state->i2c_addr >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2 },
		};

		if (i2c_transfer(state->i2c_adap, msg, 2) != 2)
		state->i2c_write_buffer[0] = (reg >> 8) \| 0x80;
		state->i2c_write_buffer[1] = reg & 0xff;

		memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
		state->msg[0].addr = state->i2c_addr >> 1;
		state->msg[0].flags = 0;
		state->msg[0].buf = state->i2c_write_buffer;
		state->msg[0].len = 2;
		state->msg[1].addr = state->i2c_addr >> 1;
		state->msg[1].flags = I2C_M_RD;
		state->msg[1].buf = state->i2c_read_buffer;
		state->msg[1].len = 2;

		if (i2c_transfer(state->i2c_adap, state->msg, 2) != 2)
		dprintk("i2c read error on %d",reg);

		return (rb[0] << 8) \| rb[1];
		return (state->i2c_read_buffer[0] << 8) \| state->i2c_read_buffer[1];
		}

		static int dib7000m_write_word(struct dib7000m_state *state, u16 reg, u16 val)
		{
		u8 b[4] = {
		(reg >> 8) & 0xff, reg & 0xff,
		(val >> 8) & 0xff, val & 0xff,
		};
		struct i2c_msg msg = {
		.addr = state->i2c_addr >> 1, .flags = 0, .buf = b, .len = 4
		};
		return i2c_transfer(state->i2c_adap, &msg, 1) != 1 ? -EREMOTEIO : 0;
		state->i2c_write_buffer[0] = (reg >> 8) & 0xff;
		state->i2c_write_buffer[1] = reg & 0xff;
		state->i2c_write_buffer[2] = (val >> 8) & 0xff;
		state->i2c_write_buffer[3] = val & 0xff;

		memset(&state->msg[0], 0, sizeof(struct i2c_msg));
		state->msg[0].addr = state->i2c_addr >> 1;
		state->msg[0].flags = 0;
		state->msg[0].buf = state->i2c_write_buffer;
		state->msg[0].len = 4;

		return i2c_transfer(state->i2c_adap, state->msg, 1) != 1 ? -EREMOTEIO : 0;
		}
		static void dib7000m_write_tab(struct dib7000m_state state, u16 buf)
		{

drivers/media/dvb/frontends/dib7000p.c

+52 −20

Original line number	Diff line number	Diff line
		@@ -63,6 +63,11 @@ struct dib7000p_state {

		u16 tuner_enable;
		struct i2c_adapter dib7090_tuner_adap;

		/* for the I2C transfer */
		struct i2c_msg msg[2];
		u8 i2c_write_buffer[4];
		u8 i2c_read_buffer[2];
		};

		enum dib7000p_power_mode {
		@@ -76,29 +81,39 @@ static int dib7090_set_diversity_in(struct dvb_frontend *fe, int onoff);

		static u16 dib7000p_read_word(struct dib7000p_state *state, u16 reg)
		{
		u8 wb[2] = { reg >> 8, reg & 0xff };
		u8 rb[2];
		struct i2c_msg msg[2] = {
		{.addr = state->i2c_addr >> 1, .flags = 0, .buf = wb, .len = 2},
		{.addr = state->i2c_addr >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
		};
		state->i2c_write_buffer[0] = reg >> 8;
		state->i2c_write_buffer[1] = reg & 0xff;

		memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
		state->msg[0].addr = state->i2c_addr >> 1;
		state->msg[0].flags = 0;
		state->msg[0].buf = state->i2c_write_buffer;
		state->msg[0].len = 2;
		state->msg[1].addr = state->i2c_addr >> 1;
		state->msg[1].flags = I2C_M_RD;
		state->msg[1].buf = state->i2c_read_buffer;
		state->msg[1].len = 2;

		if (i2c_transfer(state->i2c_adap, msg, 2) != 2)
		if (i2c_transfer(state->i2c_adap, state->msg, 2) != 2)
		dprintk("i2c read error on %d", reg);

		return (rb[0] << 8) \| rb[1];
		return (state->i2c_read_buffer[0] << 8) \| state->i2c_read_buffer[1];
		}

		static int dib7000p_write_word(struct dib7000p_state *state, u16 reg, u16 val)
		{
		u8 b[4] = {
		(reg >> 8) & 0xff, reg & 0xff,
		(val >> 8) & 0xff, val & 0xff,
		};
		struct i2c_msg msg = {
		.addr = state->i2c_addr >> 1, .flags = 0, .buf = b, .len = 4
		};
		return i2c_transfer(state->i2c_adap, &msg, 1) != 1 ? -EREMOTEIO : 0;
		state->i2c_write_buffer[0] = (reg >> 8) & 0xff;
		state->i2c_write_buffer[1] = reg & 0xff;
		state->i2c_write_buffer[2] = (val >> 8) & 0xff;
		state->i2c_write_buffer[3] = val & 0xff;

		memset(&state->msg[0], 0, sizeof(struct i2c_msg));
		state->msg[0].addr = state->i2c_addr >> 1;
		state->msg[0].flags = 0;
		state->msg[0].buf = state->i2c_write_buffer;
		state->msg[0].len = 4;

		return i2c_transfer(state->i2c_adap, state->msg, 1) != 1 ? -EREMOTEIO : 0;
		}

		static void dib7000p_write_tab(struct dib7000p_state state, u16 buf)
		@@ -1550,11 +1565,24 @@ static void dib7000p_release(struct dvb_frontend *demod)

		int dib7000pc_detection(struct i2c_adapter *i2c_adap)
		{
		u8 tx[2], rx[2];
		u8 tx, rx;
		struct i2c_msg msg[2] = {
		{.addr = 18 >> 1, .flags = 0, .buf = tx, .len = 2},
		{.addr = 18 >> 1, .flags = I2C_M_RD, .buf = rx, .len = 2},
		{.addr = 18 >> 1, .flags = 0, .len = 2},
		{.addr = 18 >> 1, .flags = I2C_M_RD, .len = 2},
		};
		int ret = 0;

		tx = kzalloc(2*sizeof(u8), GFP_KERNEL);
		if (!tx)
		return -ENOMEM;
		rx = kzalloc(2*sizeof(u8), GFP_KERNEL);
		if (!rx) {
		goto rx_memory_error;
		ret = -ENOMEM;
		}

		msg[0].buf = tx;
		msg[1].buf = rx;

		tx[0] = 0x03;
		tx[1] = 0x00;
		@@ -1574,7 +1602,11 @@ int dib7000pc_detection(struct i2c_adapter *i2c_adap)
		}

		dprintk("-D- DiB7000PC not detected");
		return 0;

		kfree(rx);
		rx_memory_error:
		kfree(tx);
		return ret;
		}
		EXPORT_SYMBOL(dib7000pc_detection);

drivers/media/dvb/frontends/dib8000.c

+94 −32

Original line number	Diff line number	Diff line
		@@ -35,6 +35,8 @@ MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
		struct i2c_device {
		struct i2c_adapter *adap;
		u8 addr;
		u8 *i2c_write_buffer;
		u8 *i2c_read_buffer;
		};

		struct dib8000_state {
		@@ -70,6 +72,11 @@ struct dib8000_state {
		u32 status;

		struct dvb_frontend *fe[MAX_NUMBER_OF_FRONTENDS];

		/* for the I2C transfer */
		struct i2c_msg msg[2];
		u8 i2c_write_buffer[4];
		u8 i2c_read_buffer[2];
		};

		enum dib8000_power_mode {
		@@ -79,22 +86,41 @@ enum dib8000_power_mode {

		static u16 dib8000_i2c_read16(struct i2c_device *i2c, u16 reg)
		{
		u8 wb[2] = { reg >> 8, reg & 0xff };
		u8 rb[2];
		struct i2c_msg msg[2] = {
		{.addr = i2c->addr >> 1,.flags = 0,.buf = wb,.len = 2},
		{.addr = i2c->addr >> 1,.flags = I2C_M_RD,.buf = rb,.len = 2},
		{.addr = i2c->addr >> 1, .flags = 0,
		.buf = i2c->i2c_write_buffer, .len = 2},
		{.addr = i2c->addr >> 1, .flags = I2C_M_RD,
		.buf = i2c->i2c_read_buffer, .len = 2},
		};

		msg[0].buf[0] = reg >> 8;
		msg[0].buf[1] = reg & 0xff;

		if (i2c_transfer(i2c->adap, msg, 2) != 2)
		dprintk("i2c read error on %d", reg);

		return (rb[0] << 8) \| rb[1];
		return (msg[1].buf[0] << 8) \| msg[1].buf[1];
		}

		static u16 dib8000_read_word(struct dib8000_state *state, u16 reg)
		{
		return dib8000_i2c_read16(&state->i2c, reg);
		state->i2c_write_buffer[0] = reg >> 8;
		state->i2c_write_buffer[1] = reg & 0xff;

		memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
		state->msg[0].addr = state->i2c.addr >> 1;
		state->msg[0].flags = 0;
		state->msg[0].buf = state->i2c_write_buffer;
		state->msg[0].len = 2;
		state->msg[1].addr = state->i2c.addr >> 1;
		state->msg[1].flags = I2C_M_RD;
		state->msg[1].buf = state->i2c_read_buffer;
		state->msg[1].len = 2;

		if (i2c_transfer(state->i2c.adap, state->msg, 2) != 2)
		dprintk("i2c read error on %d", reg);

		return (state->i2c_read_buffer[0] << 8) \| state->i2c_read_buffer[1];
		}

		static u32 dib8000_read32(struct dib8000_state *state, u16 reg)
		@@ -109,19 +135,34 @@ static u32 dib8000_read32(struct dib8000_state *state, u16 reg)

		static int dib8000_i2c_write16(struct i2c_device *i2c, u16 reg, u16 val)
		{
		u8 b[4] = {
		(reg >> 8) & 0xff, reg & 0xff,
		(val >> 8) & 0xff, val & 0xff,
		};
		struct i2c_msg msg = {
		.addr = i2c->addr >> 1,.flags = 0,.buf = b,.len = 4
		};
		return i2c_transfer(i2c->adap, &msg, 1) != 1 ? -EREMOTEIO : 0;
		struct i2c_msg msg = {.addr = i2c->addr >> 1, .flags = 0,
		.buf = i2c->i2c_write_buffer, .len = 4};
		int ret = 0;

		msg.buf[0] = (reg >> 8) & 0xff;
		msg.buf[1] = reg & 0xff;
		msg.buf[2] = (val >> 8) & 0xff;
		msg.buf[3] = val & 0xff;

		ret = i2c_transfer(i2c->adap, &msg, 1) != 1 ? -EREMOTEIO : 0;

		return ret;
		}

		static int dib8000_write_word(struct dib8000_state *state, u16 reg, u16 val)
		{
		return dib8000_i2c_write16(&state->i2c, reg, val);
		state->i2c_write_buffer[0] = (reg >> 8) & 0xff;
		state->i2c_write_buffer[1] = reg & 0xff;
		state->i2c_write_buffer[2] = (val >> 8) & 0xff;
		state->i2c_write_buffer[3] = val & 0xff;

		memset(&state->msg[0], 0, sizeof(struct i2c_msg));
		state->msg[0].addr = state->i2c.addr >> 1;
		state->msg[0].flags = 0;
		state->msg[0].buf = state->i2c_write_buffer;
		state->msg[0].len = 4;

		return i2c_transfer(state->i2c.adap, state->msg, 1) != 1 ? -EREMOTEIO : 0;
		}

		static const s16 coeff_2k_sb_1seg_dqpsk[8] = {
		@@ -980,18 +1021,7 @@ static void dib8000_update_timf(struct dib8000_state *state)
		dprintk("Updated timing frequency: %d (default: %d)", state->timf, state->timf_default);
		}

		static void dib8000_set_channel(struct dib8000_state *state, u8 seq, u8 autosearching)
		{
		u16 mode, max_constellation, seg_diff_mask = 0, nbseg_diff = 0;
		u8 guard, crate, constellation, timeI;
		u8 permu_seg[] = { 6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 11, 0, 12 };
		u16 i, coeff[4], P_cfr_left_edge = 0, P_cfr_right_edge = 0, seg_mask13 = 0x1fff; // All 13 segments enabled
		const s16 ncoeff = NULL, ana_fe;
		u16 tmcc_pow = 0;
		u16 coff_pow = 0x2800;
		u16 init_prbs = 0xfff;
		u16 ana_gain = 0;
		u16 adc_target_16dB[11] = {
		static const u16 adc_target_16dB[11] = {
		(1 << 13) - 825 - 117,
		(1 << 13) - 837 - 117,
		(1 << 13) - 811 - 117,
		@@ -1004,6 +1034,18 @@ static void dib8000_set_channel(struct dib8000_state *state, u8 seq, u8 autosear
		(1 << 13) - 531 - 117,
		(1 << 13) - 501 - 117
		};
		static const u8 permu_seg[] = { 6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 11, 0, 12 };

		static void dib8000_set_channel(struct dib8000_state *state, u8 seq, u8 autosearching)
		{
		u16 mode, max_constellation, seg_diff_mask = 0, nbseg_diff = 0;
		u8 guard, crate, constellation, timeI;
		u16 i, coeff[4], P_cfr_left_edge = 0, P_cfr_right_edge = 0, seg_mask13 = 0x1fff; // All 13 segments enabled
		const s16 ncoeff = NULL, ana_fe;
		u16 tmcc_pow = 0;
		u16 coff_pow = 0x2800;
		u16 init_prbs = 0xfff;
		u16 ana_gain = 0;

		if (state->ber_monitored_layer != LAYER_ALL)
		dib8000_write_word(state, 285, (dib8000_read_word(state, 285) & 0x60) \| state->ber_monitored_layer);
		@@ -2379,10 +2421,22 @@ EXPORT_SYMBOL(dib8000_get_slave_frontend);

		int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods, u8 default_addr, u8 first_addr)
		{
		int k = 0;
		int k = 0, ret = 0;
		u8 new_addr = 0;
		struct i2c_device client = {.adap = host };

		client.i2c_write_buffer = kzalloc(4 * sizeof(u8), GFP_KERNEL);
		if (!client.i2c_write_buffer) {
		dprintk("%s: not enough memory", __func__);
		return -ENOMEM;
		}
		client.i2c_read_buffer = kzalloc(4 * sizeof(u8), GFP_KERNEL);
		if (!client.i2c_read_buffer) {
		dprintk("%s: not enough memory", __func__);
		ret = -ENOMEM;
		goto error_memory;
		}

		for (k = no_of_demods - 1; k >= 0; k--) {
		/* designated i2c address */
		new_addr = first_addr + (k << 1);
		@@ -2394,7 +2448,8 @@ int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods, u8 defau
		client.addr = default_addr;
		if (dib8000_identify(&client) == 0) {
		dprintk("#%d: not identified", k);
		return -EINVAL;
		ret = -EINVAL;
		goto error;
		}
		}

		@@ -2420,7 +2475,12 @@ int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods, u8 defau
		dib8000_i2c_write16(&client, 1286, 0);
		}

		return 0;
		error:
		kfree(client.i2c_read_buffer);
		error_memory:
		kfree(client.i2c_write_buffer);

		return ret;
		}

		EXPORT_SYMBOL(dib8000_i2c_enumeration);
		@@ -2519,6 +2579,8 @@ struct dvb_frontend dib8000_attach(struct i2c_adapter i2c_adap, u8 i2c_addr, s
		memcpy(&state->cfg, cfg, sizeof(struct dib8000_config));
		state->i2c.adap = i2c_adap;
		state->i2c.addr = i2c_addr;
		state->i2c.i2c_write_buffer = state->i2c_write_buffer;
		state->i2c.i2c_read_buffer = state->i2c_read_buffer;
		state->gpio_val = cfg->gpio_val;
		state->gpio_dir = cfg->gpio_dir;