1 /*
2  * Realtek RTL2830 DVB-T demodulator driver
3  *
4  * Copyright (C) 2011 Antti Palosaari <crope@iki.fi>
5  *
6  *    This program is free software; you can redistribute it and/or modify
7  *    it under the terms of the GNU General Public License as published by
8  *    the Free Software Foundation; either version 2 of the License, or
9  *    (at your option) any later version.
10  *
11  *    This program is distributed in the hope that it will be useful,
12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *    GNU General Public License for more details.
15  *
16  */
17 
18 #include "rtl2830_priv.h"
19 
20 /* Our regmap is bypassing I2C adapter lock, thus we do it! */
21 static int rtl2830_bulk_write(struct i2c_client *client, unsigned int reg,
22 			      const void *val, size_t val_count)
23 {
24 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
25 	int ret;
26 
27 	i2c_lock_adapter(client->adapter);
28 	ret = regmap_bulk_write(dev->regmap, reg, val, val_count);
29 	i2c_unlock_adapter(client->adapter);
30 	return ret;
31 }
32 
33 static int rtl2830_update_bits(struct i2c_client *client, unsigned int reg,
34 			       unsigned int mask, unsigned int val)
35 {
36 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
37 	int ret;
38 
39 	i2c_lock_adapter(client->adapter);
40 	ret = regmap_update_bits(dev->regmap, reg, mask, val);
41 	i2c_unlock_adapter(client->adapter);
42 	return ret;
43 }
44 
45 static int rtl2830_bulk_read(struct i2c_client *client, unsigned int reg,
46 			     void *val, size_t val_count)
47 {
48 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
49 	int ret;
50 
51 	i2c_lock_adapter(client->adapter);
52 	ret = regmap_bulk_read(dev->regmap, reg, val, val_count);
53 	i2c_unlock_adapter(client->adapter);
54 	return ret;
55 }
56 
57 static int rtl2830_init(struct dvb_frontend *fe)
58 {
59 	struct i2c_client *client = fe->demodulator_priv;
60 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
61 	struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
62 	int ret, i;
63 	struct rtl2830_reg_val_mask tab[] = {
64 		{0x00d, 0x01, 0x03},
65 		{0x00d, 0x10, 0x10},
66 		{0x104, 0x00, 0x1e},
67 		{0x105, 0x80, 0x80},
68 		{0x110, 0x02, 0x03},
69 		{0x110, 0x08, 0x0c},
70 		{0x17b, 0x00, 0x40},
71 		{0x17d, 0x05, 0x0f},
72 		{0x17d, 0x50, 0xf0},
73 		{0x18c, 0x08, 0x0f},
74 		{0x18d, 0x00, 0xc0},
75 		{0x188, 0x05, 0x0f},
76 		{0x189, 0x00, 0xfc},
77 		{0x2d5, 0x02, 0x02},
78 		{0x2f1, 0x02, 0x06},
79 		{0x2f1, 0x20, 0xf8},
80 		{0x16d, 0x00, 0x01},
81 		{0x1a6, 0x00, 0x80},
82 		{0x106, dev->pdata->vtop, 0x3f},
83 		{0x107, dev->pdata->krf, 0x3f},
84 		{0x112, 0x28, 0xff},
85 		{0x103, dev->pdata->agc_targ_val, 0xff},
86 		{0x00a, 0x02, 0x07},
87 		{0x140, 0x0c, 0x3c},
88 		{0x140, 0x40, 0xc0},
89 		{0x15b, 0x05, 0x07},
90 		{0x15b, 0x28, 0x38},
91 		{0x15c, 0x05, 0x07},
92 		{0x15c, 0x28, 0x38},
93 		{0x115, dev->pdata->spec_inv, 0x01},
94 		{0x16f, 0x01, 0x07},
95 		{0x170, 0x18, 0x38},
96 		{0x172, 0x0f, 0x0f},
97 		{0x173, 0x08, 0x38},
98 		{0x175, 0x01, 0x07},
99 		{0x176, 0x00, 0xc0},
100 	};
101 
102 	for (i = 0; i < ARRAY_SIZE(tab); i++) {
103 		ret = rtl2830_update_bits(client, tab[i].reg, tab[i].mask,
104 					  tab[i].val);
105 		if (ret)
106 			goto err;
107 	}
108 
109 	ret = rtl2830_bulk_write(client, 0x18f, "\x28\x00", 2);
110 	if (ret)
111 		goto err;
112 
113 	ret = rtl2830_bulk_write(client, 0x195,
114 				 "\x04\x06\x0a\x12\x0a\x12\x1e\x28", 8);
115 	if (ret)
116 		goto err;
117 
118 	/* TODO: spec init */
119 
120 	/* soft reset */
121 	ret = rtl2830_update_bits(client, 0x101, 0x04, 0x04);
122 	if (ret)
123 		goto err;
124 
125 	ret = rtl2830_update_bits(client, 0x101, 0x04, 0x00);
126 	if (ret)
127 		goto err;
128 
129 	/* init stats here in order signal app which stats are supported */
130 	c->strength.len = 1;
131 	c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
132 	c->cnr.len = 1;
133 	c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
134 	c->post_bit_error.len = 1;
135 	c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
136 	c->post_bit_count.len = 1;
137 	c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
138 
139 	dev->sleeping = false;
140 
141 	return ret;
142 err:
143 	dev_dbg(&client->dev, "failed=%d\n", ret);
144 	return ret;
145 }
146 
147 static int rtl2830_sleep(struct dvb_frontend *fe)
148 {
149 	struct i2c_client *client = fe->demodulator_priv;
150 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
151 
152 	dev->sleeping = true;
153 	dev->fe_status = 0;
154 
155 	return 0;
156 }
157 
158 static int rtl2830_get_tune_settings(struct dvb_frontend *fe,
159 				     struct dvb_frontend_tune_settings *s)
160 {
161 	s->min_delay_ms = 500;
162 	s->step_size = fe->ops.info.frequency_stepsize * 2;
163 	s->max_drift = (fe->ops.info.frequency_stepsize * 2) + 1;
164 
165 	return 0;
166 }
167 
168 static int rtl2830_set_frontend(struct dvb_frontend *fe)
169 {
170 	struct i2c_client *client = fe->demodulator_priv;
171 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
172 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
173 	int ret, i;
174 	u64 num;
175 	u8 buf[3], u8tmp;
176 	u32 if_ctl, if_frequency;
177 	static const u8 bw_params1[3][34] = {
178 		{
179 		0x1f, 0xf0, 0x1f, 0xf0, 0x1f, 0xfa, 0x00, 0x17, 0x00, 0x41,
180 		0x00, 0x64, 0x00, 0x67, 0x00, 0x38, 0x1f, 0xde, 0x1f, 0x7a,
181 		0x1f, 0x47, 0x1f, 0x7c, 0x00, 0x30, 0x01, 0x4b, 0x02, 0x82,
182 		0x03, 0x73, 0x03, 0xcf, /* 6 MHz */
183 		}, {
184 		0x1f, 0xfa, 0x1f, 0xda, 0x1f, 0xc1, 0x1f, 0xb3, 0x1f, 0xca,
185 		0x00, 0x07, 0x00, 0x4d, 0x00, 0x6d, 0x00, 0x40, 0x1f, 0xca,
186 		0x1f, 0x4d, 0x1f, 0x2a, 0x1f, 0xb2, 0x00, 0xec, 0x02, 0x7e,
187 		0x03, 0xd0, 0x04, 0x53, /* 7 MHz */
188 		}, {
189 		0x00, 0x10, 0x00, 0x0e, 0x1f, 0xf7, 0x1f, 0xc9, 0x1f, 0xa0,
190 		0x1f, 0xa6, 0x1f, 0xec, 0x00, 0x4e, 0x00, 0x7d, 0x00, 0x3a,
191 		0x1f, 0x98, 0x1f, 0x10, 0x1f, 0x40, 0x00, 0x75, 0x02, 0x5f,
192 		0x04, 0x24, 0x04, 0xdb, /* 8 MHz */
193 		},
194 	};
195 	static const u8 bw_params2[3][6] = {
196 		{0xc3, 0x0c, 0x44, 0x33, 0x33, 0x30}, /* 6 MHz */
197 		{0xb8, 0xe3, 0x93, 0x99, 0x99, 0x98}, /* 7 MHz */
198 		{0xae, 0xba, 0xf3, 0x26, 0x66, 0x64}, /* 8 MHz */
199 	};
200 
201 	dev_dbg(&client->dev, "frequency=%u bandwidth_hz=%u inversion=%u\n",
202 		c->frequency, c->bandwidth_hz, c->inversion);
203 
204 	/* program tuner */
205 	if (fe->ops.tuner_ops.set_params)
206 		fe->ops.tuner_ops.set_params(fe);
207 
208 	switch (c->bandwidth_hz) {
209 	case 6000000:
210 		i = 0;
211 		break;
212 	case 7000000:
213 		i = 1;
214 		break;
215 	case 8000000:
216 		i = 2;
217 		break;
218 	default:
219 		dev_err(&client->dev, "invalid bandwidth_hz %u\n",
220 			c->bandwidth_hz);
221 		return -EINVAL;
222 	}
223 
224 	ret = rtl2830_update_bits(client, 0x008, 0x06, i << 1);
225 	if (ret)
226 		goto err;
227 
228 	/* program if frequency */
229 	if (fe->ops.tuner_ops.get_if_frequency)
230 		ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency);
231 	else
232 		ret = -EINVAL;
233 	if (ret)
234 		goto err;
235 
236 	num = if_frequency % dev->pdata->clk;
237 	num *= 0x400000;
238 	num = div_u64(num, dev->pdata->clk);
239 	num = -num;
240 	if_ctl = num & 0x3fffff;
241 	dev_dbg(&client->dev, "if_frequency=%d if_ctl=%08x\n",
242 		if_frequency, if_ctl);
243 
244 	buf[0] = (if_ctl >> 16) & 0x3f;
245 	buf[1] = (if_ctl >>  8) & 0xff;
246 	buf[2] = (if_ctl >>  0) & 0xff;
247 
248 	ret = rtl2830_bulk_read(client, 0x119, &u8tmp, 1);
249 	if (ret)
250 		goto err;
251 
252 	buf[0] |= u8tmp & 0xc0;  /* [7:6] */
253 
254 	ret = rtl2830_bulk_write(client, 0x119, buf, 3);
255 	if (ret)
256 		goto err;
257 
258 	/* 1/2 split I2C write */
259 	ret = rtl2830_bulk_write(client, 0x11c, &bw_params1[i][0], 17);
260 	if (ret)
261 		goto err;
262 
263 	/* 2/2 split I2C write */
264 	ret = rtl2830_bulk_write(client, 0x12d, &bw_params1[i][17], 17);
265 	if (ret)
266 		goto err;
267 
268 	ret = rtl2830_bulk_write(client, 0x19d, bw_params2[i], 6);
269 	if (ret)
270 		goto err;
271 
272 	return ret;
273 err:
274 	dev_dbg(&client->dev, "failed=%d\n", ret);
275 	return ret;
276 }
277 
278 static int rtl2830_get_frontend(struct dvb_frontend *fe,
279 				struct dtv_frontend_properties *c)
280 {
281 	struct i2c_client *client = fe->demodulator_priv;
282 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
283 	int ret;
284 	u8 buf[3];
285 
286 	if (dev->sleeping)
287 		return 0;
288 
289 	ret = rtl2830_bulk_read(client, 0x33c, buf, 2);
290 	if (ret)
291 		goto err;
292 
293 	ret = rtl2830_bulk_read(client, 0x351, &buf[2], 1);
294 	if (ret)
295 		goto err;
296 
297 	dev_dbg(&client->dev, "TPS=%*ph\n", 3, buf);
298 
299 	switch ((buf[0] >> 2) & 3) {
300 	case 0:
301 		c->modulation = QPSK;
302 		break;
303 	case 1:
304 		c->modulation = QAM_16;
305 		break;
306 	case 2:
307 		c->modulation = QAM_64;
308 		break;
309 	}
310 
311 	switch ((buf[2] >> 2) & 1) {
312 	case 0:
313 		c->transmission_mode = TRANSMISSION_MODE_2K;
314 		break;
315 	case 1:
316 		c->transmission_mode = TRANSMISSION_MODE_8K;
317 	}
318 
319 	switch ((buf[2] >> 0) & 3) {
320 	case 0:
321 		c->guard_interval = GUARD_INTERVAL_1_32;
322 		break;
323 	case 1:
324 		c->guard_interval = GUARD_INTERVAL_1_16;
325 		break;
326 	case 2:
327 		c->guard_interval = GUARD_INTERVAL_1_8;
328 		break;
329 	case 3:
330 		c->guard_interval = GUARD_INTERVAL_1_4;
331 		break;
332 	}
333 
334 	switch ((buf[0] >> 4) & 7) {
335 	case 0:
336 		c->hierarchy = HIERARCHY_NONE;
337 		break;
338 	case 1:
339 		c->hierarchy = HIERARCHY_1;
340 		break;
341 	case 2:
342 		c->hierarchy = HIERARCHY_2;
343 		break;
344 	case 3:
345 		c->hierarchy = HIERARCHY_4;
346 		break;
347 	}
348 
349 	switch ((buf[1] >> 3) & 7) {
350 	case 0:
351 		c->code_rate_HP = FEC_1_2;
352 		break;
353 	case 1:
354 		c->code_rate_HP = FEC_2_3;
355 		break;
356 	case 2:
357 		c->code_rate_HP = FEC_3_4;
358 		break;
359 	case 3:
360 		c->code_rate_HP = FEC_5_6;
361 		break;
362 	case 4:
363 		c->code_rate_HP = FEC_7_8;
364 		break;
365 	}
366 
367 	switch ((buf[1] >> 0) & 7) {
368 	case 0:
369 		c->code_rate_LP = FEC_1_2;
370 		break;
371 	case 1:
372 		c->code_rate_LP = FEC_2_3;
373 		break;
374 	case 2:
375 		c->code_rate_LP = FEC_3_4;
376 		break;
377 	case 3:
378 		c->code_rate_LP = FEC_5_6;
379 		break;
380 	case 4:
381 		c->code_rate_LP = FEC_7_8;
382 		break;
383 	}
384 
385 	return 0;
386 err:
387 	dev_dbg(&client->dev, "failed=%d\n", ret);
388 	return ret;
389 }
390 
391 static int rtl2830_read_status(struct dvb_frontend *fe, enum fe_status *status)
392 {
393 	struct i2c_client *client = fe->demodulator_priv;
394 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
395 	struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
396 	int ret, stmp;
397 	unsigned int utmp;
398 	u8 u8tmp, buf[2];
399 
400 	*status = 0;
401 
402 	if (dev->sleeping)
403 		return 0;
404 
405 	ret = rtl2830_bulk_read(client, 0x351, &u8tmp, 1);
406 	if (ret)
407 		goto err;
408 
409 	u8tmp = (u8tmp >> 3) & 0x0f; /* [6:3] */
410 	if (u8tmp == 11) {
411 		*status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
412 			FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
413 	} else if (u8tmp == 10) {
414 		*status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
415 			FE_HAS_VITERBI;
416 	}
417 
418 	dev->fe_status = *status;
419 
420 	/* Signal strength */
421 	if (dev->fe_status & FE_HAS_SIGNAL) {
422 		/* Read IF AGC */
423 		ret = rtl2830_bulk_read(client, 0x359, buf, 2);
424 		if (ret)
425 			goto err;
426 
427 		stmp = buf[0] << 8 | buf[1] << 0;
428 		stmp = sign_extend32(stmp, 13);
429 		utmp = clamp_val(-4 * stmp + 32767, 0x0000, 0xffff);
430 
431 		dev_dbg(&client->dev, "IF AGC=%d\n", stmp);
432 
433 		c->strength.stat[0].scale = FE_SCALE_RELATIVE;
434 		c->strength.stat[0].uvalue = utmp;
435 	} else {
436 		c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
437 	}
438 
439 	/* CNR */
440 	if (dev->fe_status & FE_HAS_VITERBI) {
441 		unsigned int hierarchy, constellation;
442 		#define CONSTELLATION_NUM 3
443 		#define HIERARCHY_NUM 4
444 		static const u32 constant[CONSTELLATION_NUM][HIERARCHY_NUM] = {
445 			{70705899, 70705899, 70705899, 70705899},
446 			{82433173, 82433173, 87483115, 94445660},
447 			{92888734, 92888734, 95487525, 99770748},
448 		};
449 
450 		ret = rtl2830_bulk_read(client, 0x33c, &u8tmp, 1);
451 		if (ret)
452 			goto err;
453 
454 		constellation = (u8tmp >> 2) & 0x03; /* [3:2] */
455 		if (constellation > CONSTELLATION_NUM - 1)
456 			goto err;
457 
458 		hierarchy = (u8tmp >> 4) & 0x07; /* [6:4] */
459 		if (hierarchy > HIERARCHY_NUM - 1)
460 			goto err;
461 
462 		ret = rtl2830_bulk_read(client, 0x40c, buf, 2);
463 		if (ret)
464 			goto err;
465 
466 		utmp = buf[0] << 8 | buf[1] << 0;
467 		if (utmp)
468 			stmp = (constant[constellation][hierarchy] -
469 			       intlog10(utmp)) / ((1 << 24) / 10000);
470 		else
471 			stmp = 0;
472 
473 		dev_dbg(&client->dev, "CNR raw=%u\n", utmp);
474 
475 		c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
476 		c->cnr.stat[0].svalue = stmp;
477 	} else {
478 		c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
479 	}
480 
481 	/* BER */
482 	if (dev->fe_status & FE_HAS_LOCK) {
483 		ret = rtl2830_bulk_read(client, 0x34e, buf, 2);
484 		if (ret)
485 			goto err;
486 
487 		utmp = buf[0] << 8 | buf[1] << 0;
488 		dev->post_bit_error += utmp;
489 		dev->post_bit_count += 1000000;
490 
491 		dev_dbg(&client->dev, "BER errors=%u total=1000000\n", utmp);
492 
493 		c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
494 		c->post_bit_error.stat[0].uvalue = dev->post_bit_error;
495 		c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
496 		c->post_bit_count.stat[0].uvalue = dev->post_bit_count;
497 	} else {
498 		c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
499 		c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
500 	}
501 
502 
503 	return ret;
504 err:
505 	dev_dbg(&client->dev, "failed=%d\n", ret);
506 	return ret;
507 }
508 
509 static int rtl2830_read_snr(struct dvb_frontend *fe, u16 *snr)
510 {
511 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
512 
513 	if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
514 		*snr = div_s64(c->cnr.stat[0].svalue, 100);
515 	else
516 		*snr = 0;
517 
518 	return 0;
519 }
520 
521 static int rtl2830_read_ber(struct dvb_frontend *fe, u32 *ber)
522 {
523 	struct i2c_client *client = fe->demodulator_priv;
524 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
525 
526 	*ber = (dev->post_bit_error - dev->post_bit_error_prev);
527 	dev->post_bit_error_prev = dev->post_bit_error;
528 
529 	return 0;
530 }
531 
532 static int rtl2830_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
533 {
534 	*ucblocks = 0;
535 
536 	return 0;
537 }
538 
539 static int rtl2830_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
540 {
541 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
542 
543 	if (c->strength.stat[0].scale == FE_SCALE_RELATIVE)
544 		*strength = c->strength.stat[0].uvalue;
545 	else
546 		*strength = 0;
547 
548 	return 0;
549 }
550 
551 static const struct dvb_frontend_ops rtl2830_ops = {
552 	.delsys = {SYS_DVBT},
553 	.info = {
554 		.name = "Realtek RTL2830 (DVB-T)",
555 		.caps = FE_CAN_FEC_1_2 |
556 			FE_CAN_FEC_2_3 |
557 			FE_CAN_FEC_3_4 |
558 			FE_CAN_FEC_5_6 |
559 			FE_CAN_FEC_7_8 |
560 			FE_CAN_FEC_AUTO |
561 			FE_CAN_QPSK |
562 			FE_CAN_QAM_16 |
563 			FE_CAN_QAM_64 |
564 			FE_CAN_QAM_AUTO |
565 			FE_CAN_TRANSMISSION_MODE_AUTO |
566 			FE_CAN_GUARD_INTERVAL_AUTO |
567 			FE_CAN_HIERARCHY_AUTO |
568 			FE_CAN_RECOVER |
569 			FE_CAN_MUTE_TS
570 	},
571 
572 	.init = rtl2830_init,
573 	.sleep = rtl2830_sleep,
574 
575 	.get_tune_settings = rtl2830_get_tune_settings,
576 
577 	.set_frontend = rtl2830_set_frontend,
578 	.get_frontend = rtl2830_get_frontend,
579 
580 	.read_status = rtl2830_read_status,
581 	.read_snr = rtl2830_read_snr,
582 	.read_ber = rtl2830_read_ber,
583 	.read_ucblocks = rtl2830_read_ucblocks,
584 	.read_signal_strength = rtl2830_read_signal_strength,
585 };
586 
587 static int rtl2830_pid_filter_ctrl(struct dvb_frontend *fe, int onoff)
588 {
589 	struct i2c_client *client = fe->demodulator_priv;
590 	int ret;
591 	u8 u8tmp;
592 
593 	dev_dbg(&client->dev, "onoff=%d\n", onoff);
594 
595 	/* enable / disable PID filter */
596 	if (onoff)
597 		u8tmp = 0x80;
598 	else
599 		u8tmp = 0x00;
600 
601 	ret = rtl2830_update_bits(client, 0x061, 0x80, u8tmp);
602 	if (ret)
603 		goto err;
604 
605 	return 0;
606 err:
607 	dev_dbg(&client->dev, "failed=%d\n", ret);
608 	return ret;
609 }
610 
611 static int rtl2830_pid_filter(struct dvb_frontend *fe, u8 index, u16 pid, int onoff)
612 {
613 	struct i2c_client *client = fe->demodulator_priv;
614 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
615 	int ret;
616 	u8 buf[4];
617 
618 	dev_dbg(&client->dev, "index=%d pid=%04x onoff=%d\n",
619 		index, pid, onoff);
620 
621 	/* skip invalid PIDs (0x2000) */
622 	if (pid > 0x1fff || index > 32)
623 		return 0;
624 
625 	if (onoff)
626 		set_bit(index, &dev->filters);
627 	else
628 		clear_bit(index, &dev->filters);
629 
630 	/* enable / disable PIDs */
631 	buf[0] = (dev->filters >>  0) & 0xff;
632 	buf[1] = (dev->filters >>  8) & 0xff;
633 	buf[2] = (dev->filters >> 16) & 0xff;
634 	buf[3] = (dev->filters >> 24) & 0xff;
635 	ret = rtl2830_bulk_write(client, 0x062, buf, 4);
636 	if (ret)
637 		goto err;
638 
639 	/* add PID */
640 	buf[0] = (pid >> 8) & 0xff;
641 	buf[1] = (pid >> 0) & 0xff;
642 	ret = rtl2830_bulk_write(client, 0x066 + 2 * index, buf, 2);
643 	if (ret)
644 		goto err;
645 
646 	return 0;
647 err:
648 	dev_dbg(&client->dev, "failed=%d\n", ret);
649 	return ret;
650 }
651 
652 /*
653  * I2C gate/mux/repeater logic
654  * We must use unlocked __i2c_transfer() here (through regmap) because of I2C
655  * adapter lock is already taken by tuner driver.
656  * Gate is closed automatically after single I2C transfer.
657  */
658 static int rtl2830_select(struct i2c_mux_core *muxc, u32 chan_id)
659 {
660 	struct i2c_client *client = i2c_mux_priv(muxc);
661 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
662 	int ret;
663 
664 	dev_dbg(&client->dev, "\n");
665 
666 	/* open I2C repeater for 1 transfer, closes automatically */
667 	/* XXX: regmap_update_bits() does not lock I2C adapter */
668 	ret = regmap_update_bits(dev->regmap, 0x101, 0x08, 0x08);
669 	if (ret)
670 		goto err;
671 
672 	return 0;
673 err:
674 	dev_dbg(&client->dev, "failed=%d\n", ret);
675 	return ret;
676 }
677 
678 static struct dvb_frontend *rtl2830_get_dvb_frontend(struct i2c_client *client)
679 {
680 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
681 
682 	dev_dbg(&client->dev, "\n");
683 
684 	return &dev->fe;
685 }
686 
687 static struct i2c_adapter *rtl2830_get_i2c_adapter(struct i2c_client *client)
688 {
689 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
690 
691 	dev_dbg(&client->dev, "\n");
692 
693 	return dev->muxc->adapter[0];
694 }
695 
696 /*
697  * We implement own I2C access routines for regmap in order to get manual access
698  * to I2C adapter lock, which is needed for I2C mux adapter.
699  */
700 static int rtl2830_regmap_read(void *context, const void *reg_buf,
701 			       size_t reg_size, void *val_buf, size_t val_size)
702 {
703 	struct i2c_client *client = context;
704 	int ret;
705 	struct i2c_msg msg[2] = {
706 		{
707 			.addr = client->addr,
708 			.flags = 0,
709 			.len = reg_size,
710 			.buf = (u8 *)reg_buf,
711 		}, {
712 			.addr = client->addr,
713 			.flags = I2C_M_RD,
714 			.len = val_size,
715 			.buf = val_buf,
716 		}
717 	};
718 
719 	ret = __i2c_transfer(client->adapter, msg, 2);
720 	if (ret != 2) {
721 		dev_warn(&client->dev, "i2c reg read failed %d\n", ret);
722 		if (ret >= 0)
723 			ret = -EREMOTEIO;
724 		return ret;
725 	}
726 	return 0;
727 }
728 
729 static int rtl2830_regmap_write(void *context, const void *data, size_t count)
730 {
731 	struct i2c_client *client = context;
732 	int ret;
733 	struct i2c_msg msg[1] = {
734 		{
735 			.addr = client->addr,
736 			.flags = 0,
737 			.len = count,
738 			.buf = (u8 *)data,
739 		}
740 	};
741 
742 	ret = __i2c_transfer(client->adapter, msg, 1);
743 	if (ret != 1) {
744 		dev_warn(&client->dev, "i2c reg write failed %d\n", ret);
745 		if (ret >= 0)
746 			ret = -EREMOTEIO;
747 		return ret;
748 	}
749 	return 0;
750 }
751 
752 static int rtl2830_regmap_gather_write(void *context, const void *reg,
753 				       size_t reg_len, const void *val,
754 				       size_t val_len)
755 {
756 	struct i2c_client *client = context;
757 	int ret;
758 	u8 buf[256];
759 	struct i2c_msg msg[1] = {
760 		{
761 			.addr = client->addr,
762 			.flags = 0,
763 			.len = 1 + val_len,
764 			.buf = buf,
765 		}
766 	};
767 
768 	buf[0] = *(u8 const *)reg;
769 	memcpy(&buf[1], val, val_len);
770 
771 	ret = __i2c_transfer(client->adapter, msg, 1);
772 	if (ret != 1) {
773 		dev_warn(&client->dev, "i2c reg write failed %d\n", ret);
774 		if (ret >= 0)
775 			ret = -EREMOTEIO;
776 		return ret;
777 	}
778 	return 0;
779 }
780 
781 static int rtl2830_probe(struct i2c_client *client,
782 			 const struct i2c_device_id *id)
783 {
784 	struct rtl2830_platform_data *pdata = client->dev.platform_data;
785 	struct rtl2830_dev *dev;
786 	int ret;
787 	u8 u8tmp;
788 	static const struct regmap_bus regmap_bus = {
789 		.read = rtl2830_regmap_read,
790 		.write = rtl2830_regmap_write,
791 		.gather_write = rtl2830_regmap_gather_write,
792 		.val_format_endian_default = REGMAP_ENDIAN_NATIVE,
793 	};
794 	static const struct regmap_range_cfg regmap_range_cfg[] = {
795 		{
796 			.selector_reg     = 0x00,
797 			.selector_mask    = 0xff,
798 			.selector_shift   = 0,
799 			.window_start     = 0,
800 			.window_len       = 0x100,
801 			.range_min        = 0 * 0x100,
802 			.range_max        = 5 * 0x100,
803 		},
804 	};
805 	static const struct regmap_config regmap_config = {
806 		.reg_bits    =  8,
807 		.val_bits    =  8,
808 		.max_register = 5 * 0x100,
809 		.ranges = regmap_range_cfg,
810 		.num_ranges = ARRAY_SIZE(regmap_range_cfg),
811 	};
812 
813 	dev_dbg(&client->dev, "\n");
814 
815 	if (pdata == NULL) {
816 		ret = -EINVAL;
817 		goto err;
818 	}
819 
820 	/* allocate memory for the internal state */
821 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
822 	if (dev == NULL) {
823 		ret = -ENOMEM;
824 		goto err;
825 	}
826 
827 	/* setup the state */
828 	i2c_set_clientdata(client, dev);
829 	dev->client = client;
830 	dev->pdata = client->dev.platform_data;
831 	dev->sleeping = true;
832 	dev->regmap = regmap_init(&client->dev, &regmap_bus, client,
833 				  &regmap_config);
834 	if (IS_ERR(dev->regmap)) {
835 		ret = PTR_ERR(dev->regmap);
836 		goto err_kfree;
837 	}
838 
839 	/* check if the demod is there */
840 	ret = rtl2830_bulk_read(client, 0x000, &u8tmp, 1);
841 	if (ret)
842 		goto err_regmap_exit;
843 
844 	/* create muxed i2c adapter for tuner */
845 	dev->muxc = i2c_mux_alloc(client->adapter, &client->dev, 1, 0, 0,
846 				  rtl2830_select, NULL);
847 	if (!dev->muxc) {
848 		ret = -ENOMEM;
849 		goto err_regmap_exit;
850 	}
851 	dev->muxc->priv = client;
852 	ret = i2c_mux_add_adapter(dev->muxc, 0, 0, 0);
853 	if (ret)
854 		goto err_regmap_exit;
855 
856 	/* create dvb frontend */
857 	memcpy(&dev->fe.ops, &rtl2830_ops, sizeof(dev->fe.ops));
858 	dev->fe.demodulator_priv = client;
859 
860 	/* setup callbacks */
861 	pdata->get_dvb_frontend = rtl2830_get_dvb_frontend;
862 	pdata->get_i2c_adapter = rtl2830_get_i2c_adapter;
863 	pdata->pid_filter = rtl2830_pid_filter;
864 	pdata->pid_filter_ctrl = rtl2830_pid_filter_ctrl;
865 
866 	dev_info(&client->dev, "Realtek RTL2830 successfully attached\n");
867 
868 	return 0;
869 err_regmap_exit:
870 	regmap_exit(dev->regmap);
871 err_kfree:
872 	kfree(dev);
873 err:
874 	dev_dbg(&client->dev, "failed=%d\n", ret);
875 	return ret;
876 }
877 
878 static int rtl2830_remove(struct i2c_client *client)
879 {
880 	struct rtl2830_dev *dev = i2c_get_clientdata(client);
881 
882 	dev_dbg(&client->dev, "\n");
883 
884 	i2c_mux_del_adapters(dev->muxc);
885 	regmap_exit(dev->regmap);
886 	kfree(dev);
887 
888 	return 0;
889 }
890 
891 static const struct i2c_device_id rtl2830_id_table[] = {
892 	{"rtl2830", 0},
893 	{}
894 };
895 MODULE_DEVICE_TABLE(i2c, rtl2830_id_table);
896 
897 static struct i2c_driver rtl2830_driver = {
898 	.driver = {
899 		.name			= "rtl2830",
900 		.suppress_bind_attrs	= true,
901 	},
902 	.probe		= rtl2830_probe,
903 	.remove		= rtl2830_remove,
904 	.id_table	= rtl2830_id_table,
905 };
906 
907 module_i2c_driver(rtl2830_driver);
908 
909 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
910 MODULE_DESCRIPTION("Realtek RTL2830 DVB-T demodulator driver");
911 MODULE_LICENSE("GPL");
912