1 /*
2  * Realtek RTL2832 DVB-T demodulator driver
3  *
4  * Copyright (C) 2012 Thomas Mair <thomas.mair86@gmail.com>
5  * Copyright (C) 2012-2014 Antti Palosaari <crope@iki.fi>
6  *
7  *	This program is free software; you can redistribute it and/or modify
8  *	it under the terms of the GNU General Public License as published by
9  *	the Free Software Foundation; either version 2 of the License, or
10  *	(at your option) any later version.
11  *
12  *	This program is distributed in the hope that it will be useful,
13  *	but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *	GNU General Public License for more details.
16  *
17  *	You should have received a copy of the GNU General Public License along
18  *	with this program; if not, write to the Free Software Foundation, Inc.,
19  *	51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21 
22 #include "rtl2832_priv.h"
23 
24 #define REG_MASK(b) (BIT(b + 1) - 1)
25 
26 static const struct rtl2832_reg_entry registers[] = {
27 	[DVBT_SOFT_RST]		= {0x101,  2, 2},
28 	[DVBT_IIC_REPEAT]	= {0x101,  3, 3},
29 	[DVBT_TR_WAIT_MIN_8K]	= {0x188, 11, 2},
30 	[DVBT_RSD_BER_FAIL_VAL]	= {0x18f, 15, 0},
31 	[DVBT_EN_BK_TRK]	= {0x1a6,  7, 7},
32 	[DVBT_AD_EN_REG]	= {0x008,  7, 7},
33 	[DVBT_AD_EN_REG1]	= {0x008,  6, 6},
34 	[DVBT_EN_BBIN]		= {0x1b1,  0, 0},
35 	[DVBT_MGD_THD0]		= {0x195,  7, 0},
36 	[DVBT_MGD_THD1]		= {0x196,  7, 0},
37 	[DVBT_MGD_THD2]		= {0x197,  7, 0},
38 	[DVBT_MGD_THD3]		= {0x198,  7, 0},
39 	[DVBT_MGD_THD4]		= {0x199,  7, 0},
40 	[DVBT_MGD_THD5]		= {0x19a,  7, 0},
41 	[DVBT_MGD_THD6]		= {0x19b,  7, 0},
42 	[DVBT_MGD_THD7]		= {0x19c,  7, 0},
43 	[DVBT_EN_CACQ_NOTCH]	= {0x161,  4, 4},
44 	[DVBT_AD_AV_REF]	= {0x009,  6, 0},
45 	[DVBT_REG_PI]		= {0x00a,  2, 0},
46 	[DVBT_PIP_ON]		= {0x021,  3, 3},
47 	[DVBT_SCALE1_B92]	= {0x292,  7, 0},
48 	[DVBT_SCALE1_B93]	= {0x293,  7, 0},
49 	[DVBT_SCALE1_BA7]	= {0x2a7,  7, 0},
50 	[DVBT_SCALE1_BA9]	= {0x2a9,  7, 0},
51 	[DVBT_SCALE1_BAA]	= {0x2aa,  7, 0},
52 	[DVBT_SCALE1_BAB]	= {0x2ab,  7, 0},
53 	[DVBT_SCALE1_BAC]	= {0x2ac,  7, 0},
54 	[DVBT_SCALE1_BB0]	= {0x2b0,  7, 0},
55 	[DVBT_SCALE1_BB1]	= {0x2b1,  7, 0},
56 	[DVBT_KB_P1]		= {0x164,  3, 1},
57 	[DVBT_KB_P2]		= {0x164,  6, 4},
58 	[DVBT_KB_P3]		= {0x165,  2, 0},
59 	[DVBT_OPT_ADC_IQ]	= {0x006,  5, 4},
60 	[DVBT_AD_AVI]		= {0x009,  1, 0},
61 	[DVBT_AD_AVQ]		= {0x009,  3, 2},
62 	[DVBT_K1_CR_STEP12]	= {0x2ad,  9, 4},
63 	[DVBT_TRK_KS_P2]	= {0x16f,  2, 0},
64 	[DVBT_TRK_KS_I2]	= {0x170,  5, 3},
65 	[DVBT_TR_THD_SET2]	= {0x172,  3, 0},
66 	[DVBT_TRK_KC_P2]	= {0x173,  5, 3},
67 	[DVBT_TRK_KC_I2]	= {0x175,  2, 0},
68 	[DVBT_CR_THD_SET2]	= {0x176,  7, 6},
69 	[DVBT_PSET_IFFREQ]	= {0x119, 21, 0},
70 	[DVBT_SPEC_INV]		= {0x115,  0, 0},
71 	[DVBT_RSAMP_RATIO]	= {0x19f, 27, 2},
72 	[DVBT_CFREQ_OFF_RATIO]	= {0x19d, 23, 4},
73 	[DVBT_FSM_STAGE]	= {0x351,  6, 3},
74 	[DVBT_RX_CONSTEL]	= {0x33c,  3, 2},
75 	[DVBT_RX_HIER]		= {0x33c,  6, 4},
76 	[DVBT_RX_C_RATE_LP]	= {0x33d,  2, 0},
77 	[DVBT_RX_C_RATE_HP]	= {0x33d,  5, 3},
78 	[DVBT_GI_IDX]		= {0x351,  1, 0},
79 	[DVBT_FFT_MODE_IDX]	= {0x351,  2, 2},
80 	[DVBT_RSD_BER_EST]	= {0x34e, 15, 0},
81 	[DVBT_CE_EST_EVM]	= {0x40c, 15, 0},
82 	[DVBT_RF_AGC_VAL]	= {0x35b, 13, 0},
83 	[DVBT_IF_AGC_VAL]	= {0x359, 13, 0},
84 	[DVBT_DAGC_VAL]		= {0x305,  7, 0},
85 	[DVBT_SFREQ_OFF]	= {0x318, 13, 0},
86 	[DVBT_CFREQ_OFF]	= {0x35f, 17, 0},
87 	[DVBT_POLAR_RF_AGC]	= {0x00e,  1, 1},
88 	[DVBT_POLAR_IF_AGC]	= {0x00e,  0, 0},
89 	[DVBT_AAGC_HOLD]	= {0x104,  5, 5},
90 	[DVBT_EN_RF_AGC]	= {0x104,  6, 6},
91 	[DVBT_EN_IF_AGC]	= {0x104,  7, 7},
92 	[DVBT_IF_AGC_MIN]	= {0x108,  7, 0},
93 	[DVBT_IF_AGC_MAX]	= {0x109,  7, 0},
94 	[DVBT_RF_AGC_MIN]	= {0x10a,  7, 0},
95 	[DVBT_RF_AGC_MAX]	= {0x10b,  7, 0},
96 	[DVBT_IF_AGC_MAN]	= {0x10c,  6, 6},
97 	[DVBT_IF_AGC_MAN_VAL]	= {0x10c, 13, 0},
98 	[DVBT_RF_AGC_MAN]	= {0x10e,  6, 6},
99 	[DVBT_RF_AGC_MAN_VAL]	= {0x10e, 13, 0},
100 	[DVBT_DAGC_TRG_VAL]	= {0x112,  7, 0},
101 	[DVBT_AGC_TARG_VAL_0]	= {0x102,  0, 0},
102 	[DVBT_AGC_TARG_VAL_8_1]	= {0x103,  7, 0},
103 	[DVBT_AAGC_LOOP_GAIN]	= {0x1c7,  5, 1},
104 	[DVBT_LOOP_GAIN2_3_0]	= {0x104,  4, 1},
105 	[DVBT_LOOP_GAIN2_4]	= {0x105,  7, 7},
106 	[DVBT_LOOP_GAIN3]	= {0x1c8,  4, 0},
107 	[DVBT_VTOP1]		= {0x106,  5, 0},
108 	[DVBT_VTOP2]		= {0x1c9,  5, 0},
109 	[DVBT_VTOP3]		= {0x1ca,  5, 0},
110 	[DVBT_KRF1]		= {0x1cb,  7, 0},
111 	[DVBT_KRF2]		= {0x107,  7, 0},
112 	[DVBT_KRF3]		= {0x1cd,  7, 0},
113 	[DVBT_KRF4]		= {0x1ce,  7, 0},
114 	[DVBT_EN_GI_PGA]	= {0x1e5,  0, 0},
115 	[DVBT_THD_LOCK_UP]	= {0x1d9,  8, 0},
116 	[DVBT_THD_LOCK_DW]	= {0x1db,  8, 0},
117 	[DVBT_THD_UP1]		= {0x1dd,  7, 0},
118 	[DVBT_THD_DW1]		= {0x1de,  7, 0},
119 	[DVBT_INTER_CNT_LEN]	= {0x1d8,  3, 0},
120 	[DVBT_GI_PGA_STATE]	= {0x1e6,  3, 3},
121 	[DVBT_EN_AGC_PGA]	= {0x1d7,  0, 0},
122 	[DVBT_CKOUTPAR]		= {0x17b,  5, 5},
123 	[DVBT_CKOUT_PWR]	= {0x17b,  6, 6},
124 	[DVBT_SYNC_DUR]		= {0x17b,  7, 7},
125 	[DVBT_ERR_DUR]		= {0x17c,  0, 0},
126 	[DVBT_SYNC_LVL]		= {0x17c,  1, 1},
127 	[DVBT_ERR_LVL]		= {0x17c,  2, 2},
128 	[DVBT_VAL_LVL]		= {0x17c,  3, 3},
129 	[DVBT_SERIAL]		= {0x17c,  4, 4},
130 	[DVBT_SER_LSB]		= {0x17c,  5, 5},
131 	[DVBT_CDIV_PH0]		= {0x17d,  3, 0},
132 	[DVBT_CDIV_PH1]		= {0x17d,  7, 4},
133 	[DVBT_MPEG_IO_OPT_2_2]	= {0x006,  7, 7},
134 	[DVBT_MPEG_IO_OPT_1_0]	= {0x007,  7, 6},
135 	[DVBT_CKOUTPAR_PIP]	= {0x0b7,  4, 4},
136 	[DVBT_CKOUT_PWR_PIP]	= {0x0b7,  3, 3},
137 	[DVBT_SYNC_LVL_PIP]	= {0x0b7,  2, 2},
138 	[DVBT_ERR_LVL_PIP]	= {0x0b7,  1, 1},
139 	[DVBT_VAL_LVL_PIP]	= {0x0b7,  0, 0},
140 	[DVBT_CKOUTPAR_PID]	= {0x0b9,  4, 4},
141 	[DVBT_CKOUT_PWR_PID]	= {0x0b9,  3, 3},
142 	[DVBT_SYNC_LVL_PID]	= {0x0b9,  2, 2},
143 	[DVBT_ERR_LVL_PID]	= {0x0b9,  1, 1},
144 	[DVBT_VAL_LVL_PID]	= {0x0b9,  0, 0},
145 	[DVBT_SM_PASS]		= {0x193, 11, 0},
146 	[DVBT_AD7_SETTING]	= {0x011, 15, 0},
147 	[DVBT_RSSI_R]		= {0x301,  6, 0},
148 	[DVBT_ACI_DET_IND]	= {0x312,  0, 0},
149 	[DVBT_REG_MON]		= {0x00d,  1, 0},
150 	[DVBT_REG_MONSEL]	= {0x00d,  2, 2},
151 	[DVBT_REG_GPE]		= {0x00d,  7, 7},
152 	[DVBT_REG_GPO]		= {0x010,  0, 0},
153 	[DVBT_REG_4MSEL]	= {0x013,  0, 0},
154 };
155 
156 static int rtl2832_rd_demod_reg(struct rtl2832_dev *dev, int reg, u32 *val)
157 {
158 	struct i2c_client *client = dev->client;
159 	int ret, i;
160 	u16 reg_start_addr;
161 	u8 msb, lsb, reading[4], len;
162 	u32 reading_tmp, mask;
163 
164 	reg_start_addr = registers[reg].start_address;
165 	msb = registers[reg].msb;
166 	lsb = registers[reg].lsb;
167 	len = (msb >> 3) + 1;
168 	mask = REG_MASK(msb - lsb);
169 
170 	ret = regmap_bulk_read(dev->regmap, reg_start_addr, reading, len);
171 	if (ret)
172 		goto err;
173 
174 	reading_tmp = 0;
175 	for (i = 0; i < len; i++)
176 		reading_tmp |= reading[i] << ((len - 1 - i) * 8);
177 
178 	*val = (reading_tmp >> lsb) & mask;
179 
180 	return 0;
181 err:
182 	dev_dbg(&client->dev, "failed=%d\n", ret);
183 	return ret;
184 }
185 
186 static int rtl2832_wr_demod_reg(struct rtl2832_dev *dev, int reg, u32 val)
187 {
188 	struct i2c_client *client = dev->client;
189 	int ret, i;
190 	u16 reg_start_addr;
191 	u8 msb, lsb, reading[4], writing[4], len;
192 	u32 reading_tmp, writing_tmp, mask;
193 
194 	reg_start_addr = registers[reg].start_address;
195 	msb = registers[reg].msb;
196 	lsb = registers[reg].lsb;
197 	len = (msb >> 3) + 1;
198 	mask = REG_MASK(msb - lsb);
199 
200 	ret = regmap_bulk_read(dev->regmap, reg_start_addr, reading, len);
201 	if (ret)
202 		goto err;
203 
204 	reading_tmp = 0;
205 	for (i = 0; i < len; i++)
206 		reading_tmp |= reading[i] << ((len - 1 - i) * 8);
207 
208 	writing_tmp = reading_tmp & ~(mask << lsb);
209 	writing_tmp |= ((val & mask) << lsb);
210 
211 	for (i = 0; i < len; i++)
212 		writing[i] = (writing_tmp >> ((len - 1 - i) * 8)) & 0xff;
213 
214 	ret = regmap_bulk_write(dev->regmap, reg_start_addr, writing, len);
215 	if (ret)
216 		goto err;
217 
218 	return 0;
219 err:
220 	dev_dbg(&client->dev, "failed=%d\n", ret);
221 	return ret;
222 }
223 
224 static int rtl2832_set_if(struct dvb_frontend *fe, u32 if_freq)
225 {
226 	struct rtl2832_dev *dev = fe->demodulator_priv;
227 	struct i2c_client *client = dev->client;
228 	int ret;
229 	u64 pset_iffreq;
230 	u8 en_bbin = (if_freq == 0 ? 0x1 : 0x0);
231 
232 	/*
233 	* PSET_IFFREQ = - floor((IfFreqHz % CrystalFreqHz) * pow(2, 22)
234 	*		/ CrystalFreqHz)
235 	*/
236 	pset_iffreq = if_freq % dev->pdata->clk;
237 	pset_iffreq *= 0x400000;
238 	pset_iffreq = div_u64(pset_iffreq, dev->pdata->clk);
239 	pset_iffreq = -pset_iffreq;
240 	pset_iffreq = pset_iffreq & 0x3fffff;
241 	dev_dbg(&client->dev, "if_frequency=%d pset_iffreq=%08x\n",
242 		if_freq, (unsigned)pset_iffreq);
243 
244 	ret = rtl2832_wr_demod_reg(dev, DVBT_EN_BBIN, en_bbin);
245 	if (ret)
246 		goto err;
247 
248 	ret = rtl2832_wr_demod_reg(dev, DVBT_PSET_IFFREQ, pset_iffreq);
249 	if (ret)
250 		goto err;
251 
252 	return 0;
253 err:
254 	dev_dbg(&client->dev, "failed=%d\n", ret);
255 	return ret;
256 }
257 
258 static int rtl2832_init(struct dvb_frontend *fe)
259 {
260 	struct rtl2832_dev *dev = fe->demodulator_priv;
261 	struct i2c_client *client = dev->client;
262 	struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
263 	const struct rtl2832_reg_value *init;
264 	int i, ret, len;
265 	/* initialization values for the demodulator registers */
266 	struct rtl2832_reg_value rtl2832_initial_regs[] = {
267 		{DVBT_AD_EN_REG,		0x1},
268 		{DVBT_AD_EN_REG1,		0x1},
269 		{DVBT_RSD_BER_FAIL_VAL,		0x2800},
270 		{DVBT_MGD_THD0,			0x10},
271 		{DVBT_MGD_THD1,			0x20},
272 		{DVBT_MGD_THD2,			0x20},
273 		{DVBT_MGD_THD3,			0x40},
274 		{DVBT_MGD_THD4,			0x22},
275 		{DVBT_MGD_THD5,			0x32},
276 		{DVBT_MGD_THD6,			0x37},
277 		{DVBT_MGD_THD7,			0x39},
278 		{DVBT_EN_BK_TRK,		0x0},
279 		{DVBT_EN_CACQ_NOTCH,		0x0},
280 		{DVBT_AD_AV_REF,		0x2a},
281 		{DVBT_REG_PI,			0x6},
282 		{DVBT_PIP_ON,			0x0},
283 		{DVBT_CDIV_PH0,			0x8},
284 		{DVBT_CDIV_PH1,			0x8},
285 		{DVBT_SCALE1_B92,		0x4},
286 		{DVBT_SCALE1_B93,		0xb0},
287 		{DVBT_SCALE1_BA7,		0x78},
288 		{DVBT_SCALE1_BA9,		0x28},
289 		{DVBT_SCALE1_BAA,		0x59},
290 		{DVBT_SCALE1_BAB,		0x83},
291 		{DVBT_SCALE1_BAC,		0xd4},
292 		{DVBT_SCALE1_BB0,		0x65},
293 		{DVBT_SCALE1_BB1,		0x43},
294 		{DVBT_KB_P1,			0x1},
295 		{DVBT_KB_P2,			0x4},
296 		{DVBT_KB_P3,			0x7},
297 		{DVBT_K1_CR_STEP12,		0xa},
298 		{DVBT_REG_GPE,			0x1},
299 		{DVBT_SERIAL,			0x0},
300 		{DVBT_CDIV_PH0,			0x9},
301 		{DVBT_CDIV_PH1,			0x9},
302 		{DVBT_MPEG_IO_OPT_2_2,		0x0},
303 		{DVBT_MPEG_IO_OPT_1_0,		0x0},
304 		{DVBT_TRK_KS_P2,		0x4},
305 		{DVBT_TRK_KS_I2,		0x7},
306 		{DVBT_TR_THD_SET2,		0x6},
307 		{DVBT_TRK_KC_I2,		0x5},
308 		{DVBT_CR_THD_SET2,		0x1},
309 	};
310 
311 	dev_dbg(&client->dev, "\n");
312 
313 	ret = rtl2832_wr_demod_reg(dev, DVBT_SOFT_RST, 0x0);
314 	if (ret)
315 		goto err;
316 
317 	for (i = 0; i < ARRAY_SIZE(rtl2832_initial_regs); i++) {
318 		ret = rtl2832_wr_demod_reg(dev, rtl2832_initial_regs[i].reg,
319 			rtl2832_initial_regs[i].value);
320 		if (ret)
321 			goto err;
322 	}
323 
324 	/* load tuner specific settings */
325 	dev_dbg(&client->dev, "load settings for tuner=%02x\n",
326 		dev->pdata->tuner);
327 	switch (dev->pdata->tuner) {
328 	case RTL2832_TUNER_FC2580:
329 		len = ARRAY_SIZE(rtl2832_tuner_init_fc2580);
330 		init = rtl2832_tuner_init_fc2580;
331 		break;
332 	case RTL2832_TUNER_FC0012:
333 	case RTL2832_TUNER_FC0013:
334 		len = ARRAY_SIZE(rtl2832_tuner_init_fc0012);
335 		init = rtl2832_tuner_init_fc0012;
336 		break;
337 	case RTL2832_TUNER_TUA9001:
338 		len = ARRAY_SIZE(rtl2832_tuner_init_tua9001);
339 		init = rtl2832_tuner_init_tua9001;
340 		break;
341 	case RTL2832_TUNER_E4000:
342 		len = ARRAY_SIZE(rtl2832_tuner_init_e4000);
343 		init = rtl2832_tuner_init_e4000;
344 		break;
345 	case RTL2832_TUNER_R820T:
346 	case RTL2832_TUNER_R828D:
347 		len = ARRAY_SIZE(rtl2832_tuner_init_r820t);
348 		init = rtl2832_tuner_init_r820t;
349 		break;
350 	case RTL2832_TUNER_SI2157:
351 		len = ARRAY_SIZE(rtl2832_tuner_init_si2157);
352 		init = rtl2832_tuner_init_si2157;
353 		break;
354 	default:
355 		ret = -EINVAL;
356 		goto err;
357 	}
358 
359 	for (i = 0; i < len; i++) {
360 		ret = rtl2832_wr_demod_reg(dev, init[i].reg, init[i].value);
361 		if (ret)
362 			goto err;
363 	}
364 
365 	/* init stats here in order signal app which stats are supported */
366 	c->strength.len = 1;
367 	c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
368 	c->cnr.len = 1;
369 	c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
370 	c->post_bit_error.len = 1;
371 	c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
372 	c->post_bit_count.len = 1;
373 	c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
374 	dev->sleeping = false;
375 
376 	return 0;
377 err:
378 	dev_dbg(&client->dev, "failed=%d\n", ret);
379 	return ret;
380 }
381 
382 static int rtl2832_sleep(struct dvb_frontend *fe)
383 {
384 	struct rtl2832_dev *dev = fe->demodulator_priv;
385 	struct i2c_client *client = dev->client;
386 	int ret;
387 
388 	dev_dbg(&client->dev, "\n");
389 
390 	dev->sleeping = true;
391 	dev->fe_status = 0;
392 
393 	ret = rtl2832_wr_demod_reg(dev, DVBT_SOFT_RST, 0x1);
394 	if (ret)
395 		goto err;
396 
397 	return 0;
398 err:
399 	dev_dbg(&client->dev, "failed=%d\n", ret);
400 	return ret;
401 }
402 
403 static int rtl2832_get_tune_settings(struct dvb_frontend *fe,
404 	struct dvb_frontend_tune_settings *s)
405 {
406 	struct rtl2832_dev *dev = fe->demodulator_priv;
407 	struct i2c_client *client = dev->client;
408 
409 	dev_dbg(&client->dev, "\n");
410 	s->min_delay_ms = 1000;
411 	s->step_size = fe->ops.info.frequency_stepsize_hz * 2;
412 	s->max_drift = (fe->ops.info.frequency_stepsize_hz * 2) + 1;
413 	return 0;
414 }
415 
416 static int rtl2832_set_frontend(struct dvb_frontend *fe)
417 {
418 	struct rtl2832_dev *dev = fe->demodulator_priv;
419 	struct i2c_client *client = dev->client;
420 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
421 	int ret, i, j;
422 	u64 bw_mode, num, num2;
423 	u32 resamp_ratio, cfreq_off_ratio;
424 	static u8 bw_params[3][32] = {
425 	/* 6 MHz bandwidth */
426 		{
427 		0xf5, 0xff, 0x15, 0x38, 0x5d, 0x6d, 0x52, 0x07, 0xfa, 0x2f,
428 		0x53, 0xf5, 0x3f, 0xca, 0x0b, 0x91, 0xea, 0x30, 0x63, 0xb2,
429 		0x13, 0xda, 0x0b, 0xc4, 0x18, 0x7e, 0x16, 0x66, 0x08, 0x67,
430 		0x19, 0xe0,
431 		},
432 
433 	/*  7 MHz bandwidth */
434 		{
435 		0xe7, 0xcc, 0xb5, 0xba, 0xe8, 0x2f, 0x67, 0x61, 0x00, 0xaf,
436 		0x86, 0xf2, 0xbf, 0x59, 0x04, 0x11, 0xb6, 0x33, 0xa4, 0x30,
437 		0x15, 0x10, 0x0a, 0x42, 0x18, 0xf8, 0x17, 0xd9, 0x07, 0x22,
438 		0x19, 0x10,
439 		},
440 
441 	/*  8 MHz bandwidth */
442 		{
443 		0x09, 0xf6, 0xd2, 0xa7, 0x9a, 0xc9, 0x27, 0x77, 0x06, 0xbf,
444 		0xec, 0xf4, 0x4f, 0x0b, 0xfc, 0x01, 0x63, 0x35, 0x54, 0xa7,
445 		0x16, 0x66, 0x08, 0xb4, 0x19, 0x6e, 0x19, 0x65, 0x05, 0xc8,
446 		0x19, 0xe0,
447 		},
448 	};
449 
450 	dev_dbg(&client->dev, "frequency=%u bandwidth_hz=%u inversion=%u\n",
451 		c->frequency, c->bandwidth_hz, c->inversion);
452 
453 	/* program tuner */
454 	if (fe->ops.tuner_ops.set_params)
455 		fe->ops.tuner_ops.set_params(fe);
456 
457 	/* If the frontend has get_if_frequency(), use it */
458 	if (fe->ops.tuner_ops.get_if_frequency) {
459 		u32 if_freq;
460 
461 		ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_freq);
462 		if (ret)
463 			goto err;
464 
465 		ret = rtl2832_set_if(fe, if_freq);
466 		if (ret)
467 			goto err;
468 	}
469 
470 	switch (c->bandwidth_hz) {
471 	case 6000000:
472 		i = 0;
473 		bw_mode = 48000000;
474 		break;
475 	case 7000000:
476 		i = 1;
477 		bw_mode = 56000000;
478 		break;
479 	case 8000000:
480 		i = 2;
481 		bw_mode = 64000000;
482 		break;
483 	default:
484 		dev_err(&client->dev, "invalid bandwidth_hz %u\n",
485 			c->bandwidth_hz);
486 		ret = -EINVAL;
487 		goto err;
488 	}
489 
490 	for (j = 0; j < sizeof(bw_params[0]); j++) {
491 		ret = regmap_bulk_write(dev->regmap,
492 					0x11c + j, &bw_params[i][j], 1);
493 		if (ret)
494 			goto err;
495 	}
496 
497 	/* calculate and set resample ratio
498 	* RSAMP_RATIO = floor(CrystalFreqHz * 7 * pow(2, 22)
499 	*	/ ConstWithBandwidthMode)
500 	*/
501 	num = dev->pdata->clk * 7ULL;
502 	num *= 0x400000;
503 	num = div_u64(num, bw_mode);
504 	resamp_ratio =  num & 0x3ffffff;
505 	ret = rtl2832_wr_demod_reg(dev, DVBT_RSAMP_RATIO, resamp_ratio);
506 	if (ret)
507 		goto err;
508 
509 	/* calculate and set cfreq off ratio
510 	* CFREQ_OFF_RATIO = - floor(ConstWithBandwidthMode * pow(2, 20)
511 	*	/ (CrystalFreqHz * 7))
512 	*/
513 	num = bw_mode << 20;
514 	num2 = dev->pdata->clk * 7ULL;
515 	num = div_u64(num, num2);
516 	num = -num;
517 	cfreq_off_ratio = num & 0xfffff;
518 	ret = rtl2832_wr_demod_reg(dev, DVBT_CFREQ_OFF_RATIO, cfreq_off_ratio);
519 	if (ret)
520 		goto err;
521 
522 	/* soft reset */
523 	ret = rtl2832_wr_demod_reg(dev, DVBT_SOFT_RST, 0x1);
524 	if (ret)
525 		goto err;
526 
527 	ret = rtl2832_wr_demod_reg(dev, DVBT_SOFT_RST, 0x0);
528 	if (ret)
529 		goto err;
530 
531 	return 0;
532 err:
533 	dev_dbg(&client->dev, "failed=%d\n", ret);
534 	return ret;
535 }
536 
537 static int rtl2832_get_frontend(struct dvb_frontend *fe,
538 				struct dtv_frontend_properties *c)
539 {
540 	struct rtl2832_dev *dev = fe->demodulator_priv;
541 	struct i2c_client *client = dev->client;
542 	int ret;
543 	u8 buf[3];
544 
545 	if (dev->sleeping)
546 		return 0;
547 
548 	ret = regmap_bulk_read(dev->regmap, 0x33c, buf, 2);
549 	if (ret)
550 		goto err;
551 
552 	ret = regmap_bulk_read(dev->regmap, 0x351, &buf[2], 1);
553 	if (ret)
554 		goto err;
555 
556 	dev_dbg(&client->dev, "TPS=%*ph\n", 3, buf);
557 
558 	switch ((buf[0] >> 2) & 3) {
559 	case 0:
560 		c->modulation = QPSK;
561 		break;
562 	case 1:
563 		c->modulation = QAM_16;
564 		break;
565 	case 2:
566 		c->modulation = QAM_64;
567 		break;
568 	}
569 
570 	switch ((buf[2] >> 2) & 1) {
571 	case 0:
572 		c->transmission_mode = TRANSMISSION_MODE_2K;
573 		break;
574 	case 1:
575 		c->transmission_mode = TRANSMISSION_MODE_8K;
576 	}
577 
578 	switch ((buf[2] >> 0) & 3) {
579 	case 0:
580 		c->guard_interval = GUARD_INTERVAL_1_32;
581 		break;
582 	case 1:
583 		c->guard_interval = GUARD_INTERVAL_1_16;
584 		break;
585 	case 2:
586 		c->guard_interval = GUARD_INTERVAL_1_8;
587 		break;
588 	case 3:
589 		c->guard_interval = GUARD_INTERVAL_1_4;
590 		break;
591 	}
592 
593 	switch ((buf[0] >> 4) & 7) {
594 	case 0:
595 		c->hierarchy = HIERARCHY_NONE;
596 		break;
597 	case 1:
598 		c->hierarchy = HIERARCHY_1;
599 		break;
600 	case 2:
601 		c->hierarchy = HIERARCHY_2;
602 		break;
603 	case 3:
604 		c->hierarchy = HIERARCHY_4;
605 		break;
606 	}
607 
608 	switch ((buf[1] >> 3) & 7) {
609 	case 0:
610 		c->code_rate_HP = FEC_1_2;
611 		break;
612 	case 1:
613 		c->code_rate_HP = FEC_2_3;
614 		break;
615 	case 2:
616 		c->code_rate_HP = FEC_3_4;
617 		break;
618 	case 3:
619 		c->code_rate_HP = FEC_5_6;
620 		break;
621 	case 4:
622 		c->code_rate_HP = FEC_7_8;
623 		break;
624 	}
625 
626 	switch ((buf[1] >> 0) & 7) {
627 	case 0:
628 		c->code_rate_LP = FEC_1_2;
629 		break;
630 	case 1:
631 		c->code_rate_LP = FEC_2_3;
632 		break;
633 	case 2:
634 		c->code_rate_LP = FEC_3_4;
635 		break;
636 	case 3:
637 		c->code_rate_LP = FEC_5_6;
638 		break;
639 	case 4:
640 		c->code_rate_LP = FEC_7_8;
641 		break;
642 	}
643 
644 	return 0;
645 err:
646 	dev_dbg(&client->dev, "failed=%d\n", ret);
647 	return ret;
648 }
649 
650 static int rtl2832_read_status(struct dvb_frontend *fe, enum fe_status *status)
651 {
652 	struct rtl2832_dev *dev = fe->demodulator_priv;
653 	struct i2c_client *client = dev->client;
654 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
655 	int ret;
656 	u32 uninitialized_var(tmp);
657 	u8 u8tmp, buf[2];
658 	u16 u16tmp;
659 
660 	dev_dbg(&client->dev, "\n");
661 
662 	*status = 0;
663 	if (dev->sleeping)
664 		return 0;
665 
666 	ret = rtl2832_rd_demod_reg(dev, DVBT_FSM_STAGE, &tmp);
667 	if (ret)
668 		goto err;
669 
670 	if (tmp == 11) {
671 		*status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
672 				FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
673 	} else if (tmp == 10) {
674 		*status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
675 				FE_HAS_VITERBI;
676 	}
677 
678 	dev->fe_status = *status;
679 
680 	/* signal strength */
681 	if (dev->fe_status & FE_HAS_SIGNAL) {
682 		/* read digital AGC */
683 		ret = regmap_bulk_read(dev->regmap, 0x305, &u8tmp, 1);
684 		if (ret)
685 			goto err;
686 
687 		dev_dbg(&client->dev, "digital agc=%02x", u8tmp);
688 
689 		u8tmp = ~u8tmp;
690 		u16tmp = u8tmp << 8 | u8tmp << 0;
691 
692 		c->strength.stat[0].scale = FE_SCALE_RELATIVE;
693 		c->strength.stat[0].uvalue = u16tmp;
694 	} else {
695 		c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
696 	}
697 
698 	/* CNR */
699 	if (dev->fe_status & FE_HAS_VITERBI) {
700 		unsigned hierarchy, constellation;
701 		#define CONSTELLATION_NUM 3
702 		#define HIERARCHY_NUM 4
703 		static const u32 constant[CONSTELLATION_NUM][HIERARCHY_NUM] = {
704 			{85387325, 85387325, 85387325, 85387325},
705 			{86676178, 86676178, 87167949, 87795660},
706 			{87659938, 87659938, 87885178, 88241743},
707 		};
708 
709 		ret = regmap_bulk_read(dev->regmap, 0x33c, &u8tmp, 1);
710 		if (ret)
711 			goto err;
712 
713 		constellation = (u8tmp >> 2) & 0x03; /* [3:2] */
714 		if (constellation > CONSTELLATION_NUM - 1)
715 			goto err;
716 
717 		hierarchy = (u8tmp >> 4) & 0x07; /* [6:4] */
718 		if (hierarchy > HIERARCHY_NUM - 1)
719 			goto err;
720 
721 		ret = regmap_bulk_read(dev->regmap, 0x40c, buf, 2);
722 		if (ret)
723 			goto err;
724 
725 		u16tmp = buf[0] << 8 | buf[1] << 0;
726 		if (u16tmp)
727 			tmp = (constant[constellation][hierarchy] -
728 			       intlog10(u16tmp)) / ((1 << 24) / 10000);
729 		else
730 			tmp = 0;
731 
732 		dev_dbg(&client->dev, "cnr raw=%u\n", u16tmp);
733 
734 		c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
735 		c->cnr.stat[0].svalue = tmp;
736 	} else {
737 		c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
738 	}
739 
740 	/* BER */
741 	if (dev->fe_status & FE_HAS_LOCK) {
742 		ret = regmap_bulk_read(dev->regmap, 0x34e, buf, 2);
743 		if (ret)
744 			goto err;
745 
746 		u16tmp = buf[0] << 8 | buf[1] << 0;
747 		dev->post_bit_error += u16tmp;
748 		dev->post_bit_count += 1000000;
749 
750 		dev_dbg(&client->dev, "ber errors=%u total=1000000\n", u16tmp);
751 
752 		c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
753 		c->post_bit_error.stat[0].uvalue = dev->post_bit_error;
754 		c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
755 		c->post_bit_count.stat[0].uvalue = dev->post_bit_count;
756 	} else {
757 		c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
758 		c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
759 	}
760 
761 	return 0;
762 err:
763 	dev_dbg(&client->dev, "failed=%d\n", ret);
764 	return ret;
765 }
766 
767 static int rtl2832_read_snr(struct dvb_frontend *fe, u16 *snr)
768 {
769 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
770 
771 	/* report SNR in resolution of 0.1 dB */
772 	if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
773 		*snr = div_s64(c->cnr.stat[0].svalue, 100);
774 	else
775 		*snr = 0;
776 
777 	return 0;
778 }
779 
780 static int rtl2832_read_ber(struct dvb_frontend *fe, u32 *ber)
781 {
782 	struct rtl2832_dev *dev = fe->demodulator_priv;
783 
784 	*ber = (dev->post_bit_error - dev->post_bit_error_prev);
785 	dev->post_bit_error_prev = dev->post_bit_error;
786 
787 	return 0;
788 }
789 
790 /*
791  * I2C gate/mux/repeater logic
792  * There is delay mechanism to avoid unneeded I2C gate open / close. Gate close
793  * is delayed here a little bit in order to see if there is sequence of I2C
794  * messages sent to same I2C bus.
795  */
796 static void rtl2832_i2c_gate_work(struct work_struct *work)
797 {
798 	struct rtl2832_dev *dev = container_of(work, struct rtl2832_dev, i2c_gate_work.work);
799 	struct i2c_client *client = dev->client;
800 	int ret;
801 
802 	/* close gate */
803 	ret = regmap_update_bits(dev->regmap, 0x101, 0x08, 0x00);
804 	if (ret)
805 		goto err;
806 
807 	return;
808 err:
809 	dev_dbg(&client->dev, "failed=%d\n", ret);
810 }
811 
812 static int rtl2832_select(struct i2c_mux_core *muxc, u32 chan_id)
813 {
814 	struct rtl2832_dev *dev = i2c_mux_priv(muxc);
815 	struct i2c_client *client = dev->client;
816 	int ret;
817 
818 	/* terminate possible gate closing */
819 	cancel_delayed_work(&dev->i2c_gate_work);
820 
821 	/* open gate */
822 	ret = regmap_update_bits(dev->regmap, 0x101, 0x08, 0x08);
823 	if (ret)
824 		goto err;
825 
826 	return 0;
827 err:
828 	dev_dbg(&client->dev, "failed=%d\n", ret);
829 	return ret;
830 }
831 
832 static int rtl2832_deselect(struct i2c_mux_core *muxc, u32 chan_id)
833 {
834 	struct rtl2832_dev *dev = i2c_mux_priv(muxc);
835 
836 	schedule_delayed_work(&dev->i2c_gate_work, usecs_to_jiffies(100));
837 	return 0;
838 }
839 
840 static const struct dvb_frontend_ops rtl2832_ops = {
841 	.delsys = { SYS_DVBT },
842 	.info = {
843 		.name = "Realtek RTL2832 (DVB-T)",
844 		.frequency_min_hz	= 174 * MHz,
845 		.frequency_max_hz	= 862 * MHz,
846 		.frequency_stepsize_hz	= 166667,
847 		.caps = FE_CAN_FEC_1_2 |
848 			FE_CAN_FEC_2_3 |
849 			FE_CAN_FEC_3_4 |
850 			FE_CAN_FEC_5_6 |
851 			FE_CAN_FEC_7_8 |
852 			FE_CAN_FEC_AUTO |
853 			FE_CAN_QPSK |
854 			FE_CAN_QAM_16 |
855 			FE_CAN_QAM_64 |
856 			FE_CAN_QAM_AUTO |
857 			FE_CAN_TRANSMISSION_MODE_AUTO |
858 			FE_CAN_GUARD_INTERVAL_AUTO |
859 			FE_CAN_HIERARCHY_AUTO |
860 			FE_CAN_RECOVER |
861 			FE_CAN_MUTE_TS
862 	 },
863 
864 	.init = rtl2832_init,
865 	.sleep = rtl2832_sleep,
866 
867 	.get_tune_settings = rtl2832_get_tune_settings,
868 
869 	.set_frontend = rtl2832_set_frontend,
870 	.get_frontend = rtl2832_get_frontend,
871 
872 	.read_status = rtl2832_read_status,
873 	.read_snr = rtl2832_read_snr,
874 	.read_ber = rtl2832_read_ber,
875 };
876 
877 static bool rtl2832_volatile_reg(struct device *dev, unsigned int reg)
878 {
879 	switch (reg) {
880 	case 0x305:
881 	case 0x33c:
882 	case 0x34e:
883 	case 0x351:
884 	case 0x40c ... 0x40d:
885 		return true;
886 	default:
887 		break;
888 	}
889 
890 	return false;
891 }
892 
893 static struct dvb_frontend *rtl2832_get_dvb_frontend(struct i2c_client *client)
894 {
895 	struct rtl2832_dev *dev = i2c_get_clientdata(client);
896 
897 	dev_dbg(&client->dev, "\n");
898 	return &dev->fe;
899 }
900 
901 static struct i2c_adapter *rtl2832_get_i2c_adapter(struct i2c_client *client)
902 {
903 	struct rtl2832_dev *dev = i2c_get_clientdata(client);
904 
905 	dev_dbg(&client->dev, "\n");
906 	return dev->muxc->adapter[0];
907 }
908 
909 static int rtl2832_slave_ts_ctrl(struct i2c_client *client, bool enable)
910 {
911 	struct rtl2832_dev *dev = i2c_get_clientdata(client);
912 	int ret;
913 
914 	dev_dbg(&client->dev, "enable=%d\n", enable);
915 
916 	if (enable) {
917 		ret = rtl2832_wr_demod_reg(dev, DVBT_SOFT_RST, 0x0);
918 		if (ret)
919 			goto err;
920 		ret = regmap_bulk_write(dev->regmap, 0x10c, "\x5f\xff", 2);
921 		if (ret)
922 			goto err;
923 		ret = rtl2832_wr_demod_reg(dev, DVBT_PIP_ON, 0x1);
924 		if (ret)
925 			goto err;
926 		ret = regmap_bulk_write(dev->regmap, 0x0bc, "\x18", 1);
927 		if (ret)
928 			goto err;
929 		ret = regmap_bulk_write(dev->regmap, 0x192, "\x7f\xf7\xff", 3);
930 		if (ret)
931 			goto err;
932 	} else {
933 		ret = regmap_bulk_write(dev->regmap, 0x192, "\x00\x0f\xff", 3);
934 		if (ret)
935 			goto err;
936 		ret = regmap_bulk_write(dev->regmap, 0x0bc, "\x08", 1);
937 		if (ret)
938 			goto err;
939 		ret = rtl2832_wr_demod_reg(dev, DVBT_PIP_ON, 0x0);
940 		if (ret)
941 			goto err;
942 		ret = regmap_bulk_write(dev->regmap, 0x10c, "\x00\x00", 2);
943 		if (ret)
944 			goto err;
945 		ret = rtl2832_wr_demod_reg(dev, DVBT_SOFT_RST, 0x1);
946 		if (ret)
947 			goto err;
948 	}
949 
950 	dev->slave_ts = enable;
951 
952 	return 0;
953 err:
954 	dev_dbg(&client->dev, "failed=%d\n", ret);
955 	return ret;
956 }
957 
958 static int rtl2832_pid_filter_ctrl(struct dvb_frontend *fe, int onoff)
959 {
960 	struct rtl2832_dev *dev = fe->demodulator_priv;
961 	struct i2c_client *client = dev->client;
962 	int ret;
963 	u8 u8tmp;
964 
965 	dev_dbg(&client->dev, "onoff=%d, slave_ts=%d\n", onoff, dev->slave_ts);
966 
967 	/* enable / disable PID filter */
968 	if (onoff)
969 		u8tmp = 0x80;
970 	else
971 		u8tmp = 0x00;
972 
973 	if (dev->slave_ts)
974 		ret = regmap_update_bits(dev->regmap, 0x021, 0xc0, u8tmp);
975 	else
976 		ret = regmap_update_bits(dev->regmap, 0x061, 0xc0, u8tmp);
977 	if (ret)
978 		goto err;
979 
980 	return 0;
981 err:
982 	dev_dbg(&client->dev, "failed=%d\n", ret);
983 	return ret;
984 }
985 
986 static int rtl2832_pid_filter(struct dvb_frontend *fe, u8 index, u16 pid,
987 			      int onoff)
988 {
989 	struct rtl2832_dev *dev = fe->demodulator_priv;
990 	struct i2c_client *client = dev->client;
991 	int ret;
992 	u8 buf[4];
993 
994 	dev_dbg(&client->dev, "index=%d pid=%04x onoff=%d slave_ts=%d\n",
995 		index, pid, onoff, dev->slave_ts);
996 
997 	/* skip invalid PIDs (0x2000) */
998 	if (pid > 0x1fff || index > 32)
999 		return 0;
1000 
1001 	if (onoff)
1002 		set_bit(index, &dev->filters);
1003 	else
1004 		clear_bit(index, &dev->filters);
1005 
1006 	/* enable / disable PIDs */
1007 	buf[0] = (dev->filters >>  0) & 0xff;
1008 	buf[1] = (dev->filters >>  8) & 0xff;
1009 	buf[2] = (dev->filters >> 16) & 0xff;
1010 	buf[3] = (dev->filters >> 24) & 0xff;
1011 
1012 	if (dev->slave_ts)
1013 		ret = regmap_bulk_write(dev->regmap, 0x022, buf, 4);
1014 	else
1015 		ret = regmap_bulk_write(dev->regmap, 0x062, buf, 4);
1016 	if (ret)
1017 		goto err;
1018 
1019 	/* add PID */
1020 	buf[0] = (pid >> 8) & 0xff;
1021 	buf[1] = (pid >> 0) & 0xff;
1022 
1023 	if (dev->slave_ts)
1024 		ret = regmap_bulk_write(dev->regmap, 0x026 + 2 * index, buf, 2);
1025 	else
1026 		ret = regmap_bulk_write(dev->regmap, 0x066 + 2 * index, buf, 2);
1027 	if (ret)
1028 		goto err;
1029 
1030 	return 0;
1031 err:
1032 	dev_dbg(&client->dev, "failed=%d\n", ret);
1033 	return ret;
1034 }
1035 
1036 static int rtl2832_probe(struct i2c_client *client,
1037 		const struct i2c_device_id *id)
1038 {
1039 	struct rtl2832_platform_data *pdata = client->dev.platform_data;
1040 	struct i2c_adapter *i2c = client->adapter;
1041 	struct rtl2832_dev *dev;
1042 	int ret;
1043 	u8 tmp;
1044 	static const struct regmap_range_cfg regmap_range_cfg[] = {
1045 		{
1046 			.selector_reg     = 0x00,
1047 			.selector_mask    = 0xff,
1048 			.selector_shift   = 0,
1049 			.window_start     = 0,
1050 			.window_len       = 0x100,
1051 			.range_min        = 0 * 0x100,
1052 			.range_max        = 5 * 0x100,
1053 		},
1054 	};
1055 
1056 	dev_dbg(&client->dev, "\n");
1057 
1058 	/* allocate memory for the internal state */
1059 	dev = kzalloc(sizeof(struct rtl2832_dev), GFP_KERNEL);
1060 	if (dev == NULL) {
1061 		ret = -ENOMEM;
1062 		goto err;
1063 	}
1064 
1065 	/* setup the state */
1066 	i2c_set_clientdata(client, dev);
1067 	dev->client = client;
1068 	dev->pdata = client->dev.platform_data;
1069 	dev->sleeping = true;
1070 	INIT_DELAYED_WORK(&dev->i2c_gate_work, rtl2832_i2c_gate_work);
1071 	/* create regmap */
1072 	dev->regmap_config.reg_bits =  8,
1073 	dev->regmap_config.val_bits =  8,
1074 	dev->regmap_config.volatile_reg = rtl2832_volatile_reg,
1075 	dev->regmap_config.max_register = 5 * 0x100,
1076 	dev->regmap_config.ranges = regmap_range_cfg,
1077 	dev->regmap_config.num_ranges = ARRAY_SIZE(regmap_range_cfg),
1078 	dev->regmap_config.cache_type = REGCACHE_NONE,
1079 	dev->regmap = regmap_init_i2c(client, &dev->regmap_config);
1080 	if (IS_ERR(dev->regmap)) {
1081 		ret = PTR_ERR(dev->regmap);
1082 		goto err_kfree;
1083 	}
1084 
1085 	/* check if the demod is there */
1086 	ret = regmap_bulk_read(dev->regmap, 0x000, &tmp, 1);
1087 	if (ret)
1088 		goto err_regmap_exit;
1089 
1090 	/* create muxed i2c adapter for demod tuner bus */
1091 	dev->muxc = i2c_mux_alloc(i2c, &i2c->dev, 1, 0, I2C_MUX_LOCKED,
1092 				  rtl2832_select, rtl2832_deselect);
1093 	if (!dev->muxc) {
1094 		ret = -ENOMEM;
1095 		goto err_regmap_exit;
1096 	}
1097 	dev->muxc->priv = dev;
1098 	ret = i2c_mux_add_adapter(dev->muxc, 0, 0, 0);
1099 	if (ret)
1100 		goto err_regmap_exit;
1101 
1102 	/* create dvb_frontend */
1103 	memcpy(&dev->fe.ops, &rtl2832_ops, sizeof(struct dvb_frontend_ops));
1104 	dev->fe.demodulator_priv = dev;
1105 
1106 	/* setup callbacks */
1107 	pdata->get_dvb_frontend = rtl2832_get_dvb_frontend;
1108 	pdata->get_i2c_adapter = rtl2832_get_i2c_adapter;
1109 	pdata->slave_ts_ctrl = rtl2832_slave_ts_ctrl;
1110 	pdata->pid_filter = rtl2832_pid_filter;
1111 	pdata->pid_filter_ctrl = rtl2832_pid_filter_ctrl;
1112 	pdata->regmap = dev->regmap;
1113 
1114 	dev_info(&client->dev, "Realtek RTL2832 successfully attached\n");
1115 	return 0;
1116 err_regmap_exit:
1117 	regmap_exit(dev->regmap);
1118 err_kfree:
1119 	kfree(dev);
1120 err:
1121 	dev_dbg(&client->dev, "failed=%d\n", ret);
1122 	return ret;
1123 }
1124 
1125 static int rtl2832_remove(struct i2c_client *client)
1126 {
1127 	struct rtl2832_dev *dev = i2c_get_clientdata(client);
1128 
1129 	dev_dbg(&client->dev, "\n");
1130 
1131 	cancel_delayed_work_sync(&dev->i2c_gate_work);
1132 
1133 	i2c_mux_del_adapters(dev->muxc);
1134 
1135 	regmap_exit(dev->regmap);
1136 
1137 	kfree(dev);
1138 
1139 	return 0;
1140 }
1141 
1142 static const struct i2c_device_id rtl2832_id_table[] = {
1143 	{"rtl2832", 0},
1144 	{}
1145 };
1146 MODULE_DEVICE_TABLE(i2c, rtl2832_id_table);
1147 
1148 static struct i2c_driver rtl2832_driver = {
1149 	.driver = {
1150 		.name	= "rtl2832",
1151 		.suppress_bind_attrs	= true,
1152 	},
1153 	.probe		= rtl2832_probe,
1154 	.remove		= rtl2832_remove,
1155 	.id_table	= rtl2832_id_table,
1156 };
1157 
1158 module_i2c_driver(rtl2832_driver);
1159 
1160 MODULE_AUTHOR("Thomas Mair <mair.thomas86@gmail.com>");
1161 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1162 MODULE_DESCRIPTION("Realtek RTL2832 DVB-T demodulator driver");
1163 MODULE_LICENSE("GPL");
1164