1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Afatech AF9013 demodulator driver
4  *
5  * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
6  * Copyright (C) 2011 Antti Palosaari <crope@iki.fi>
7  *
8  * Thanks to Afatech who kindly provided information.
9  */
10 
11 #include "af9013_priv.h"
12 
13 struct af9013_state {
14 	struct i2c_client *client;
15 	struct regmap *regmap;
16 	struct i2c_mux_core *muxc;
17 	struct dvb_frontend fe;
18 	u32 clk;
19 	u8 tuner;
20 	u32 if_frequency;
21 	u8 ts_mode;
22 	u8 ts_output_pin;
23 	bool spec_inv;
24 	u8 api_version[4];
25 	u8 gpio[4];
26 
27 	u32 bandwidth_hz;
28 	enum fe_status fe_status;
29 	/* RF and IF AGC limits used for signal strength calc */
30 	u8 strength_en, rf_agc_50, rf_agc_80, if_agc_50, if_agc_80;
31 	unsigned long set_frontend_jiffies;
32 	unsigned long read_status_jiffies;
33 	unsigned long strength_jiffies;
34 	unsigned long cnr_jiffies;
35 	unsigned long ber_ucb_jiffies;
36 	u16 dvbv3_snr;
37 	u16 dvbv3_strength;
38 	u32 dvbv3_ber;
39 	u32 dvbv3_ucblocks;
40 	bool first_tune;
41 };
42 
43 static int af9013_set_gpio(struct af9013_state *state, u8 gpio, u8 gpioval)
44 {
45 	struct i2c_client *client = state->client;
46 	int ret;
47 	u8 pos;
48 	u16 addr;
49 
50 	dev_dbg(&client->dev, "gpio %u, gpioval %02x\n", gpio, gpioval);
51 
52 	/*
53 	 * GPIO0 & GPIO1 0xd735
54 	 * GPIO2 & GPIO3 0xd736
55 	 */
56 
57 	switch (gpio) {
58 	case 0:
59 	case 1:
60 		addr = 0xd735;
61 		break;
62 	case 2:
63 	case 3:
64 		addr = 0xd736;
65 		break;
66 
67 	default:
68 		ret = -EINVAL;
69 		goto err;
70 	}
71 
72 	switch (gpio) {
73 	case 0:
74 	case 2:
75 		pos = 0;
76 		break;
77 	case 1:
78 	case 3:
79 	default:
80 		pos = 4;
81 		break;
82 	}
83 
84 	ret = regmap_update_bits(state->regmap, addr, 0x0f << pos,
85 				 gpioval << pos);
86 	if (ret)
87 		goto err;
88 
89 	return 0;
90 err:
91 	dev_dbg(&client->dev, "failed %d\n", ret);
92 	return ret;
93 }
94 
95 static int af9013_get_tune_settings(struct dvb_frontend *fe,
96 	struct dvb_frontend_tune_settings *fesettings)
97 {
98 	fesettings->min_delay_ms = 800;
99 	fesettings->step_size = 0;
100 	fesettings->max_drift = 0;
101 
102 	return 0;
103 }
104 
105 static int af9013_set_frontend(struct dvb_frontend *fe)
106 {
107 	struct af9013_state *state = fe->demodulator_priv;
108 	struct i2c_client *client = state->client;
109 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
110 	int ret, i, sampling_freq;
111 	bool auto_mode, spec_inv;
112 	u8 buf[6];
113 	u32 if_frequency, freq_cw;
114 
115 	dev_dbg(&client->dev, "frequency %u, bandwidth_hz %u\n",
116 		c->frequency, c->bandwidth_hz);
117 
118 	/* program tuner */
119 	if (fe->ops.tuner_ops.set_params) {
120 		ret = fe->ops.tuner_ops.set_params(fe);
121 		if (ret)
122 			goto err;
123 	}
124 
125 	/* program CFOE coefficients */
126 	if (c->bandwidth_hz != state->bandwidth_hz) {
127 		for (i = 0; i < ARRAY_SIZE(coeff_lut); i++) {
128 			if (coeff_lut[i].clock == state->clk &&
129 				coeff_lut[i].bandwidth_hz == c->bandwidth_hz) {
130 				break;
131 			}
132 		}
133 
134 		/* Return an error if can't find bandwidth or the right clock */
135 		if (i == ARRAY_SIZE(coeff_lut)) {
136 			ret = -EINVAL;
137 			goto err;
138 		}
139 
140 		ret = regmap_bulk_write(state->regmap, 0xae00, coeff_lut[i].val,
141 					sizeof(coeff_lut[i].val));
142 		if (ret)
143 			goto err;
144 	}
145 
146 	/* program frequency control */
147 	if (c->bandwidth_hz != state->bandwidth_hz || state->first_tune) {
148 		/* get used IF frequency */
149 		if (fe->ops.tuner_ops.get_if_frequency) {
150 			ret = fe->ops.tuner_ops.get_if_frequency(fe,
151 								 &if_frequency);
152 			if (ret)
153 				goto err;
154 		} else {
155 			if_frequency = state->if_frequency;
156 		}
157 
158 		dev_dbg(&client->dev, "if_frequency %u\n", if_frequency);
159 
160 		sampling_freq = if_frequency;
161 
162 		while (sampling_freq > (state->clk / 2))
163 			sampling_freq -= state->clk;
164 
165 		if (sampling_freq < 0) {
166 			sampling_freq *= -1;
167 			spec_inv = state->spec_inv;
168 		} else {
169 			spec_inv = !state->spec_inv;
170 		}
171 
172 		freq_cw = DIV_ROUND_CLOSEST_ULL((u64)sampling_freq * 0x800000,
173 						state->clk);
174 
175 		if (spec_inv)
176 			freq_cw = 0x800000 - freq_cw;
177 
178 		buf[0] = (freq_cw >>  0) & 0xff;
179 		buf[1] = (freq_cw >>  8) & 0xff;
180 		buf[2] = (freq_cw >> 16) & 0x7f;
181 
182 		freq_cw = 0x800000 - freq_cw;
183 
184 		buf[3] = (freq_cw >>  0) & 0xff;
185 		buf[4] = (freq_cw >>  8) & 0xff;
186 		buf[5] = (freq_cw >> 16) & 0x7f;
187 
188 		ret = regmap_bulk_write(state->regmap, 0xd140, buf, 3);
189 		if (ret)
190 			goto err;
191 
192 		ret = regmap_bulk_write(state->regmap, 0x9be7, buf, 6);
193 		if (ret)
194 			goto err;
195 	}
196 
197 	/* clear TPS lock flag */
198 	ret = regmap_update_bits(state->regmap, 0xd330, 0x08, 0x08);
199 	if (ret)
200 		goto err;
201 
202 	/* clear MPEG2 lock flag */
203 	ret = regmap_update_bits(state->regmap, 0xd507, 0x40, 0x00);
204 	if (ret)
205 		goto err;
206 
207 	/* empty channel function */
208 	ret = regmap_update_bits(state->regmap, 0x9bfe, 0x01, 0x00);
209 	if (ret)
210 		goto err;
211 
212 	/* empty DVB-T channel function */
213 	ret = regmap_update_bits(state->regmap, 0x9bc2, 0x01, 0x00);
214 	if (ret)
215 		goto err;
216 
217 	/* transmission parameters */
218 	auto_mode = false;
219 	memset(buf, 0, 3);
220 
221 	switch (c->transmission_mode) {
222 	case TRANSMISSION_MODE_AUTO:
223 		auto_mode = true;
224 		break;
225 	case TRANSMISSION_MODE_2K:
226 		break;
227 	case TRANSMISSION_MODE_8K:
228 		buf[0] |= (1 << 0);
229 		break;
230 	default:
231 		dev_dbg(&client->dev, "invalid transmission_mode\n");
232 		auto_mode = true;
233 	}
234 
235 	switch (c->guard_interval) {
236 	case GUARD_INTERVAL_AUTO:
237 		auto_mode = true;
238 		break;
239 	case GUARD_INTERVAL_1_32:
240 		break;
241 	case GUARD_INTERVAL_1_16:
242 		buf[0] |= (1 << 2);
243 		break;
244 	case GUARD_INTERVAL_1_8:
245 		buf[0] |= (2 << 2);
246 		break;
247 	case GUARD_INTERVAL_1_4:
248 		buf[0] |= (3 << 2);
249 		break;
250 	default:
251 		dev_dbg(&client->dev, "invalid guard_interval\n");
252 		auto_mode = true;
253 	}
254 
255 	switch (c->hierarchy) {
256 	case HIERARCHY_AUTO:
257 		auto_mode = true;
258 		break;
259 	case HIERARCHY_NONE:
260 		break;
261 	case HIERARCHY_1:
262 		buf[0] |= (1 << 4);
263 		break;
264 	case HIERARCHY_2:
265 		buf[0] |= (2 << 4);
266 		break;
267 	case HIERARCHY_4:
268 		buf[0] |= (3 << 4);
269 		break;
270 	default:
271 		dev_dbg(&client->dev, "invalid hierarchy\n");
272 		auto_mode = true;
273 	}
274 
275 	switch (c->modulation) {
276 	case QAM_AUTO:
277 		auto_mode = true;
278 		break;
279 	case QPSK:
280 		break;
281 	case QAM_16:
282 		buf[1] |= (1 << 6);
283 		break;
284 	case QAM_64:
285 		buf[1] |= (2 << 6);
286 		break;
287 	default:
288 		dev_dbg(&client->dev, "invalid modulation\n");
289 		auto_mode = true;
290 	}
291 
292 	/* Use HP. How and which case we can switch to LP? */
293 	buf[1] |= (1 << 4);
294 
295 	switch (c->code_rate_HP) {
296 	case FEC_AUTO:
297 		auto_mode = true;
298 		break;
299 	case FEC_1_2:
300 		break;
301 	case FEC_2_3:
302 		buf[2] |= (1 << 0);
303 		break;
304 	case FEC_3_4:
305 		buf[2] |= (2 << 0);
306 		break;
307 	case FEC_5_6:
308 		buf[2] |= (3 << 0);
309 		break;
310 	case FEC_7_8:
311 		buf[2] |= (4 << 0);
312 		break;
313 	default:
314 		dev_dbg(&client->dev, "invalid code_rate_HP\n");
315 		auto_mode = true;
316 	}
317 
318 	switch (c->code_rate_LP) {
319 	case FEC_AUTO:
320 		auto_mode = true;
321 		break;
322 	case FEC_1_2:
323 		break;
324 	case FEC_2_3:
325 		buf[2] |= (1 << 3);
326 		break;
327 	case FEC_3_4:
328 		buf[2] |= (2 << 3);
329 		break;
330 	case FEC_5_6:
331 		buf[2] |= (3 << 3);
332 		break;
333 	case FEC_7_8:
334 		buf[2] |= (4 << 3);
335 		break;
336 	case FEC_NONE:
337 		break;
338 	default:
339 		dev_dbg(&client->dev, "invalid code_rate_LP\n");
340 		auto_mode = true;
341 	}
342 
343 	switch (c->bandwidth_hz) {
344 	case 6000000:
345 		break;
346 	case 7000000:
347 		buf[1] |= (1 << 2);
348 		break;
349 	case 8000000:
350 		buf[1] |= (2 << 2);
351 		break;
352 	default:
353 		dev_dbg(&client->dev, "invalid bandwidth_hz\n");
354 		ret = -EINVAL;
355 		goto err;
356 	}
357 
358 	ret = regmap_bulk_write(state->regmap, 0xd3c0, buf, 3);
359 	if (ret)
360 		goto err;
361 
362 	if (auto_mode) {
363 		/* clear easy mode flag */
364 		ret = regmap_write(state->regmap, 0xaefd, 0x00);
365 		if (ret)
366 			goto err;
367 
368 		dev_dbg(&client->dev, "auto params\n");
369 	} else {
370 		/* set easy mode flag */
371 		ret = regmap_write(state->regmap, 0xaefd, 0x01);
372 		if (ret)
373 			goto err;
374 
375 		ret = regmap_write(state->regmap, 0xaefe, 0x00);
376 		if (ret)
377 			goto err;
378 
379 		dev_dbg(&client->dev, "manual params\n");
380 	}
381 
382 	/* Reset FSM */
383 	ret = regmap_write(state->regmap, 0xffff, 0x00);
384 	if (ret)
385 		goto err;
386 
387 	state->bandwidth_hz = c->bandwidth_hz;
388 	state->set_frontend_jiffies = jiffies;
389 	state->first_tune = false;
390 
391 	return 0;
392 err:
393 	dev_dbg(&client->dev, "failed %d\n", ret);
394 	return ret;
395 }
396 
397 static int af9013_get_frontend(struct dvb_frontend *fe,
398 			       struct dtv_frontend_properties *c)
399 {
400 	struct af9013_state *state = fe->demodulator_priv;
401 	struct i2c_client *client = state->client;
402 	int ret;
403 	u8 buf[3];
404 
405 	dev_dbg(&client->dev, "\n");
406 
407 	ret = regmap_bulk_read(state->regmap, 0xd3c0, buf, 3);
408 	if (ret)
409 		goto err;
410 
411 	switch ((buf[1] >> 6) & 3) {
412 	case 0:
413 		c->modulation = QPSK;
414 		break;
415 	case 1:
416 		c->modulation = QAM_16;
417 		break;
418 	case 2:
419 		c->modulation = QAM_64;
420 		break;
421 	}
422 
423 	switch ((buf[0] >> 0) & 3) {
424 	case 0:
425 		c->transmission_mode = TRANSMISSION_MODE_2K;
426 		break;
427 	case 1:
428 		c->transmission_mode = TRANSMISSION_MODE_8K;
429 	}
430 
431 	switch ((buf[0] >> 2) & 3) {
432 	case 0:
433 		c->guard_interval = GUARD_INTERVAL_1_32;
434 		break;
435 	case 1:
436 		c->guard_interval = GUARD_INTERVAL_1_16;
437 		break;
438 	case 2:
439 		c->guard_interval = GUARD_INTERVAL_1_8;
440 		break;
441 	case 3:
442 		c->guard_interval = GUARD_INTERVAL_1_4;
443 		break;
444 	}
445 
446 	switch ((buf[0] >> 4) & 7) {
447 	case 0:
448 		c->hierarchy = HIERARCHY_NONE;
449 		break;
450 	case 1:
451 		c->hierarchy = HIERARCHY_1;
452 		break;
453 	case 2:
454 		c->hierarchy = HIERARCHY_2;
455 		break;
456 	case 3:
457 		c->hierarchy = HIERARCHY_4;
458 		break;
459 	}
460 
461 	switch ((buf[2] >> 0) & 7) {
462 	case 0:
463 		c->code_rate_HP = FEC_1_2;
464 		break;
465 	case 1:
466 		c->code_rate_HP = FEC_2_3;
467 		break;
468 	case 2:
469 		c->code_rate_HP = FEC_3_4;
470 		break;
471 	case 3:
472 		c->code_rate_HP = FEC_5_6;
473 		break;
474 	case 4:
475 		c->code_rate_HP = FEC_7_8;
476 		break;
477 	}
478 
479 	switch ((buf[2] >> 3) & 7) {
480 	case 0:
481 		c->code_rate_LP = FEC_1_2;
482 		break;
483 	case 1:
484 		c->code_rate_LP = FEC_2_3;
485 		break;
486 	case 2:
487 		c->code_rate_LP = FEC_3_4;
488 		break;
489 	case 3:
490 		c->code_rate_LP = FEC_5_6;
491 		break;
492 	case 4:
493 		c->code_rate_LP = FEC_7_8;
494 		break;
495 	}
496 
497 	switch ((buf[1] >> 2) & 3) {
498 	case 0:
499 		c->bandwidth_hz = 6000000;
500 		break;
501 	case 1:
502 		c->bandwidth_hz = 7000000;
503 		break;
504 	case 2:
505 		c->bandwidth_hz = 8000000;
506 		break;
507 	}
508 
509 	return 0;
510 err:
511 	dev_dbg(&client->dev, "failed %d\n", ret);
512 	return ret;
513 }
514 
515 static int af9013_read_status(struct dvb_frontend *fe, enum fe_status *status)
516 {
517 	struct af9013_state *state = fe->demodulator_priv;
518 	struct i2c_client *client = state->client;
519 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
520 	int ret, stmp1;
521 	unsigned int utmp, utmp1, utmp2, utmp3, utmp4;
522 	u8 buf[7];
523 
524 	dev_dbg(&client->dev, "\n");
525 
526 	/*
527 	 * Return status from the cache if it is younger than 2000ms with the
528 	 * exception of last tune is done during 4000ms.
529 	 */
530 	if (time_is_after_jiffies(state->read_status_jiffies + msecs_to_jiffies(2000)) &&
531 	    time_is_before_jiffies(state->set_frontend_jiffies + msecs_to_jiffies(4000))) {
532 		*status = state->fe_status;
533 	} else {
534 		/* MPEG2 lock */
535 		ret = regmap_read(state->regmap, 0xd507, &utmp);
536 		if (ret)
537 			goto err;
538 
539 		if ((utmp >> 6) & 0x01) {
540 			utmp1 = FE_HAS_SIGNAL | FE_HAS_CARRIER |
541 				FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
542 		} else {
543 			/* TPS lock */
544 			ret = regmap_read(state->regmap, 0xd330, &utmp);
545 			if (ret)
546 				goto err;
547 
548 			if ((utmp >> 3) & 0x01)
549 				utmp1 = FE_HAS_SIGNAL | FE_HAS_CARRIER |
550 					FE_HAS_VITERBI;
551 			else
552 				utmp1 = 0;
553 		}
554 
555 		dev_dbg(&client->dev, "fe_status %02x\n", utmp1);
556 
557 		state->read_status_jiffies = jiffies;
558 
559 		state->fe_status = utmp1;
560 		*status = utmp1;
561 	}
562 
563 	/* Signal strength */
564 	switch (state->strength_en) {
565 	case 0:
566 		/* Check if we support signal strength */
567 		ret = regmap_read(state->regmap, 0x9bee, &utmp);
568 		if (ret)
569 			goto err;
570 
571 		if ((utmp >> 0) & 0x01) {
572 			/* Read agc values for signal strength estimation */
573 			ret = regmap_read(state->regmap, 0x9bbd, &utmp1);
574 			if (ret)
575 				goto err;
576 			ret = regmap_read(state->regmap, 0x9bd0, &utmp2);
577 			if (ret)
578 				goto err;
579 			ret = regmap_read(state->regmap, 0x9be2, &utmp3);
580 			if (ret)
581 				goto err;
582 			ret = regmap_read(state->regmap, 0x9be4, &utmp4);
583 			if (ret)
584 				goto err;
585 
586 			state->rf_agc_50 = utmp1;
587 			state->rf_agc_80 = utmp2;
588 			state->if_agc_50 = utmp3;
589 			state->if_agc_80 = utmp4;
590 			dev_dbg(&client->dev,
591 				"rf_agc_50 %u, rf_agc_80 %u, if_agc_50 %u, if_agc_80 %u\n",
592 				utmp1, utmp2, utmp3, utmp4);
593 
594 			state->strength_en = 1;
595 		} else {
596 			/* Signal strength is not supported */
597 			state->strength_en = 2;
598 			break;
599 		}
600 		fallthrough;
601 	case 1:
602 		if (time_is_after_jiffies(state->strength_jiffies + msecs_to_jiffies(2000)))
603 			break;
604 
605 		/* Read value */
606 		ret = regmap_bulk_read(state->regmap, 0xd07c, buf, 2);
607 		if (ret)
608 			goto err;
609 
610 		/*
611 		 * Construct line equation from tuner dependent -80/-50 dBm agc
612 		 * limits and use it to map current agc value to dBm estimate
613 		 */
614 		#define agc_gain (buf[0] + buf[1])
615 		#define agc_gain_50dbm (state->rf_agc_50 + state->if_agc_50)
616 		#define agc_gain_80dbm (state->rf_agc_80 + state->if_agc_80)
617 		stmp1 = 30000 * (agc_gain - agc_gain_80dbm) /
618 			(agc_gain_50dbm - agc_gain_80dbm) - 80000;
619 
620 		dev_dbg(&client->dev,
621 			"strength %d, agc_gain %d, agc_gain_50dbm %d, agc_gain_80dbm %d\n",
622 			stmp1, agc_gain, agc_gain_50dbm, agc_gain_80dbm);
623 
624 		state->strength_jiffies = jiffies;
625 		/* Convert [-90, -30] dBm to [0x0000, 0xffff] for dvbv3 */
626 		utmp1 = clamp(stmp1 + 90000, 0, 60000);
627 		state->dvbv3_strength = div_u64((u64)utmp1 * 0xffff, 60000);
628 
629 		c->strength.stat[0].scale = FE_SCALE_DECIBEL;
630 		c->strength.stat[0].svalue = stmp1;
631 		break;
632 	default:
633 		c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
634 		break;
635 	}
636 
637 	/* CNR */
638 	switch (state->fe_status & FE_HAS_VITERBI) {
639 	case FE_HAS_VITERBI:
640 		if (time_is_after_jiffies(state->cnr_jiffies + msecs_to_jiffies(2000)))
641 			break;
642 
643 		/* Check if cnr ready */
644 		ret = regmap_read(state->regmap, 0xd2e1, &utmp);
645 		if (ret)
646 			goto err;
647 
648 		if (!((utmp >> 3) & 0x01)) {
649 			dev_dbg(&client->dev, "cnr not ready\n");
650 			break;
651 		}
652 
653 		/* Read value */
654 		ret = regmap_bulk_read(state->regmap, 0xd2e3, buf, 3);
655 		if (ret)
656 			goto err;
657 
658 		utmp1 = buf[2] << 16 | buf[1] << 8 | buf[0] << 0;
659 
660 		/* Read current modulation */
661 		ret = regmap_read(state->regmap, 0xd3c1, &utmp);
662 		if (ret)
663 			goto err;
664 
665 		switch ((utmp >> 6) & 3) {
666 		case 0:
667 			/*
668 			 * QPSK
669 			 * CNR[dB] 13 * -log10((1690000 - value) / value) + 2.6
670 			 * value [653799, 1689999], 2.6 / 13 = 3355443
671 			 */
672 			utmp1 = clamp(utmp1, 653799U, 1689999U);
673 			utmp1 = ((u64)(intlog10(utmp1)
674 				- intlog10(1690000 - utmp1)
675 				+ 3355443) * 13 * 1000) >> 24;
676 			break;
677 		case 1:
678 			/*
679 			 * QAM-16
680 			 * CNR[dB] 6 * log10((value - 370000) / (828000 - value)) + 15.7
681 			 * value [371105, 827999], 15.7 / 6 = 43900382
682 			 */
683 			utmp1 = clamp(utmp1, 371105U, 827999U);
684 			utmp1 = ((u64)(intlog10(utmp1 - 370000)
685 				- intlog10(828000 - utmp1)
686 				+ 43900382) * 6 * 1000) >> 24;
687 			break;
688 		case 2:
689 			/*
690 			 * QAM-64
691 			 * CNR[dB] 8 * log10((value - 193000) / (425000 - value)) + 23.8
692 			 * value [193246, 424999], 23.8 / 8 = 49912218
693 			 */
694 			utmp1 = clamp(utmp1, 193246U, 424999U);
695 			utmp1 = ((u64)(intlog10(utmp1 - 193000)
696 				- intlog10(425000 - utmp1)
697 				+ 49912218) * 8 * 1000) >> 24;
698 			break;
699 		default:
700 			dev_dbg(&client->dev, "invalid modulation %u\n",
701 				(utmp >> 6) & 3);
702 			utmp1 = 0;
703 			break;
704 		}
705 
706 		dev_dbg(&client->dev, "cnr %u\n", utmp1);
707 
708 		state->cnr_jiffies = jiffies;
709 		state->dvbv3_snr = utmp1 / 100;
710 
711 		c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
712 		c->cnr.stat[0].svalue = utmp1;
713 		break;
714 	default:
715 		c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
716 		break;
717 	}
718 
719 	/* BER / PER */
720 	switch (state->fe_status & FE_HAS_SYNC) {
721 	case FE_HAS_SYNC:
722 		if (time_is_after_jiffies(state->ber_ucb_jiffies + msecs_to_jiffies(2000)))
723 			break;
724 
725 		/* Check if ber / ucb is ready */
726 		ret = regmap_read(state->regmap, 0xd391, &utmp);
727 		if (ret)
728 			goto err;
729 
730 		if (!((utmp >> 4) & 0x01)) {
731 			dev_dbg(&client->dev, "ber not ready\n");
732 			break;
733 		}
734 
735 		/* Read value */
736 		ret = regmap_bulk_read(state->regmap, 0xd385, buf, 7);
737 		if (ret)
738 			goto err;
739 
740 		utmp1 = buf[4] << 16 | buf[3] << 8 | buf[2] << 0;
741 		utmp2 = (buf[1] << 8 | buf[0] << 0) * 204 * 8;
742 		utmp3 = buf[6] << 8 | buf[5] << 0;
743 		utmp4 = buf[1] << 8 | buf[0] << 0;
744 
745 		/* Use 10000 TS packets for measure */
746 		if (utmp4 != 10000) {
747 			buf[0] = (10000 >> 0) & 0xff;
748 			buf[1] = (10000 >> 8) & 0xff;
749 			ret = regmap_bulk_write(state->regmap, 0xd385, buf, 2);
750 			if (ret)
751 				goto err;
752 		}
753 
754 		/* Reset ber / ucb counter */
755 		ret = regmap_update_bits(state->regmap, 0xd391, 0x20, 0x20);
756 		if (ret)
757 			goto err;
758 
759 		dev_dbg(&client->dev, "post_bit_error %u, post_bit_count %u\n",
760 			utmp1, utmp2);
761 		dev_dbg(&client->dev, "block_error %u, block_count %u\n",
762 			utmp3, utmp4);
763 
764 		state->ber_ucb_jiffies = jiffies;
765 		state->dvbv3_ber = utmp1;
766 		state->dvbv3_ucblocks += utmp3;
767 
768 		c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
769 		c->post_bit_error.stat[0].uvalue += utmp1;
770 		c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
771 		c->post_bit_count.stat[0].uvalue += utmp2;
772 
773 		c->block_error.stat[0].scale = FE_SCALE_COUNTER;
774 		c->block_error.stat[0].uvalue += utmp3;
775 		c->block_count.stat[0].scale = FE_SCALE_COUNTER;
776 		c->block_count.stat[0].uvalue += utmp4;
777 		break;
778 	default:
779 		c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
780 		c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
781 
782 		c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
783 		c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
784 		break;
785 	}
786 
787 	return 0;
788 err:
789 	dev_dbg(&client->dev, "failed %d\n", ret);
790 	return ret;
791 }
792 
793 static int af9013_read_snr(struct dvb_frontend *fe, u16 *snr)
794 {
795 	struct af9013_state *state = fe->demodulator_priv;
796 
797 	*snr = state->dvbv3_snr;
798 
799 	return 0;
800 }
801 
802 static int af9013_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
803 {
804 	struct af9013_state *state = fe->demodulator_priv;
805 
806 	*strength = state->dvbv3_strength;
807 
808 	return 0;
809 }
810 
811 static int af9013_read_ber(struct dvb_frontend *fe, u32 *ber)
812 {
813 	struct af9013_state *state = fe->demodulator_priv;
814 
815 	*ber = state->dvbv3_ber;
816 
817 	return 0;
818 }
819 
820 static int af9013_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
821 {
822 	struct af9013_state *state = fe->demodulator_priv;
823 
824 	*ucblocks = state->dvbv3_ucblocks;
825 
826 	return 0;
827 }
828 
829 static int af9013_init(struct dvb_frontend *fe)
830 {
831 	struct af9013_state *state = fe->demodulator_priv;
832 	struct i2c_client *client = state->client;
833 	int ret, i, len;
834 	unsigned int utmp;
835 	u8 buf[3];
836 	const struct af9013_reg_mask_val *tab;
837 
838 	dev_dbg(&client->dev, "\n");
839 
840 	/* ADC on */
841 	ret = regmap_update_bits(state->regmap, 0xd73a, 0x08, 0x00);
842 	if (ret)
843 		goto err;
844 
845 	/* Clear reset */
846 	ret = regmap_update_bits(state->regmap, 0xd417, 0x02, 0x00);
847 	if (ret)
848 		goto err;
849 
850 	/* Disable reset */
851 	ret = regmap_update_bits(state->regmap, 0xd417, 0x10, 0x00);
852 	if (ret)
853 		goto err;
854 
855 	/* write API version to firmware */
856 	ret = regmap_bulk_write(state->regmap, 0x9bf2, state->api_version, 4);
857 	if (ret)
858 		goto err;
859 
860 	/* program ADC control */
861 	switch (state->clk) {
862 	case 28800000: /* 28.800 MHz */
863 		utmp = 0;
864 		break;
865 	case 20480000: /* 20.480 MHz */
866 		utmp = 1;
867 		break;
868 	case 28000000: /* 28.000 MHz */
869 		utmp = 2;
870 		break;
871 	case 25000000: /* 25.000 MHz */
872 		utmp = 3;
873 		break;
874 	default:
875 		ret = -EINVAL;
876 		goto err;
877 	}
878 
879 	ret = regmap_update_bits(state->regmap, 0x9bd2, 0x0f, utmp);
880 	if (ret)
881 		goto err;
882 
883 	utmp = div_u64((u64)state->clk * 0x80000, 1000000);
884 	buf[0] = (utmp >>  0) & 0xff;
885 	buf[1] = (utmp >>  8) & 0xff;
886 	buf[2] = (utmp >> 16) & 0xff;
887 	ret = regmap_bulk_write(state->regmap, 0xd180, buf, 3);
888 	if (ret)
889 		goto err;
890 
891 	/* Demod core settings */
892 	dev_dbg(&client->dev, "load demod core settings\n");
893 	len = ARRAY_SIZE(demod_init_tab);
894 	tab = demod_init_tab;
895 	for (i = 0; i < len; i++) {
896 		ret = regmap_update_bits(state->regmap, tab[i].reg, tab[i].mask,
897 					 tab[i].val);
898 		if (ret)
899 			goto err;
900 	}
901 
902 	/* Demod tuner specific settings */
903 	dev_dbg(&client->dev, "load tuner specific settings\n");
904 	switch (state->tuner) {
905 	case AF9013_TUNER_MXL5003D:
906 		len = ARRAY_SIZE(tuner_init_tab_mxl5003d);
907 		tab = tuner_init_tab_mxl5003d;
908 		break;
909 	case AF9013_TUNER_MXL5005D:
910 	case AF9013_TUNER_MXL5005R:
911 	case AF9013_TUNER_MXL5007T:
912 		len = ARRAY_SIZE(tuner_init_tab_mxl5005);
913 		tab = tuner_init_tab_mxl5005;
914 		break;
915 	case AF9013_TUNER_ENV77H11D5:
916 		len = ARRAY_SIZE(tuner_init_tab_env77h11d5);
917 		tab = tuner_init_tab_env77h11d5;
918 		break;
919 	case AF9013_TUNER_MT2060:
920 		len = ARRAY_SIZE(tuner_init_tab_mt2060);
921 		tab = tuner_init_tab_mt2060;
922 		break;
923 	case AF9013_TUNER_MC44S803:
924 		len = ARRAY_SIZE(tuner_init_tab_mc44s803);
925 		tab = tuner_init_tab_mc44s803;
926 		break;
927 	case AF9013_TUNER_QT1010:
928 	case AF9013_TUNER_QT1010A:
929 		len = ARRAY_SIZE(tuner_init_tab_qt1010);
930 		tab = tuner_init_tab_qt1010;
931 		break;
932 	case AF9013_TUNER_MT2060_2:
933 		len = ARRAY_SIZE(tuner_init_tab_mt2060_2);
934 		tab = tuner_init_tab_mt2060_2;
935 		break;
936 	case AF9013_TUNER_TDA18271:
937 	case AF9013_TUNER_TDA18218:
938 		len = ARRAY_SIZE(tuner_init_tab_tda18271);
939 		tab = tuner_init_tab_tda18271;
940 		break;
941 	case AF9013_TUNER_UNKNOWN:
942 	default:
943 		len = ARRAY_SIZE(tuner_init_tab_unknown);
944 		tab = tuner_init_tab_unknown;
945 		break;
946 	}
947 
948 	for (i = 0; i < len; i++) {
949 		ret = regmap_update_bits(state->regmap, tab[i].reg, tab[i].mask,
950 					 tab[i].val);
951 		if (ret)
952 			goto err;
953 	}
954 
955 	/* TS interface */
956 	if (state->ts_output_pin == 7)
957 		utmp = 1 << 3 | state->ts_mode << 1;
958 	else
959 		utmp = 0 << 3 | state->ts_mode << 1;
960 	ret = regmap_update_bits(state->regmap, 0xd500, 0x0e, utmp);
961 	if (ret)
962 		goto err;
963 
964 	/* enable lock led */
965 	ret = regmap_update_bits(state->regmap, 0xd730, 0x01, 0x01);
966 	if (ret)
967 		goto err;
968 
969 	state->first_tune = true;
970 
971 	return 0;
972 err:
973 	dev_dbg(&client->dev, "failed %d\n", ret);
974 	return ret;
975 }
976 
977 static int af9013_sleep(struct dvb_frontend *fe)
978 {
979 	struct af9013_state *state = fe->demodulator_priv;
980 	struct i2c_client *client = state->client;
981 	int ret;
982 	unsigned int utmp;
983 
984 	dev_dbg(&client->dev, "\n");
985 
986 	/* disable lock led */
987 	ret = regmap_update_bits(state->regmap, 0xd730, 0x01, 0x00);
988 	if (ret)
989 		goto err;
990 
991 	/* Enable reset */
992 	ret = regmap_update_bits(state->regmap, 0xd417, 0x10, 0x10);
993 	if (ret)
994 		goto err;
995 
996 	/* Start reset execution */
997 	ret = regmap_write(state->regmap, 0xaeff, 0x01);
998 	if (ret)
999 		goto err;
1000 
1001 	/* Wait reset performs */
1002 	ret = regmap_read_poll_timeout(state->regmap, 0xd417, utmp,
1003 				       (utmp >> 1) & 0x01, 5000, 1000000);
1004 	if (ret)
1005 		goto err;
1006 
1007 	if (!((utmp >> 1) & 0x01)) {
1008 		ret = -ETIMEDOUT;
1009 		goto err;
1010 	}
1011 
1012 	/* ADC off */
1013 	ret = regmap_update_bits(state->regmap, 0xd73a, 0x08, 0x08);
1014 	if (ret)
1015 		goto err;
1016 
1017 	return 0;
1018 err:
1019 	dev_dbg(&client->dev, "failed %d\n", ret);
1020 	return ret;
1021 }
1022 
1023 static const struct dvb_frontend_ops af9013_ops;
1024 
1025 static int af9013_download_firmware(struct af9013_state *state)
1026 {
1027 	struct i2c_client *client = state->client;
1028 	int ret, i, len, rem;
1029 	unsigned int utmp;
1030 	u8 buf[4];
1031 	u16 checksum = 0;
1032 	const struct firmware *firmware;
1033 	const char *name = AF9013_FIRMWARE;
1034 
1035 	dev_dbg(&client->dev, "\n");
1036 
1037 	/* Check whether firmware is already running */
1038 	ret = regmap_read(state->regmap, 0x98be, &utmp);
1039 	if (ret)
1040 		goto err;
1041 
1042 	dev_dbg(&client->dev, "firmware status %02x\n", utmp);
1043 
1044 	if (utmp == 0x0c)
1045 		return 0;
1046 
1047 	dev_info(&client->dev, "found a '%s' in cold state, will try to load a firmware\n",
1048 		 af9013_ops.info.name);
1049 
1050 	/* Request the firmware, will block and timeout */
1051 	ret = request_firmware(&firmware, name, &client->dev);
1052 	if (ret) {
1053 		dev_info(&client->dev, "firmware file '%s' not found %d\n",
1054 			 name, ret);
1055 		goto err;
1056 	}
1057 
1058 	dev_info(&client->dev, "downloading firmware from file '%s'\n",
1059 		 name);
1060 
1061 	/* Write firmware checksum & size */
1062 	for (i = 0; i < firmware->size; i++)
1063 		checksum += firmware->data[i];
1064 
1065 	buf[0] = (checksum >> 8) & 0xff;
1066 	buf[1] = (checksum >> 0) & 0xff;
1067 	buf[2] = (firmware->size >> 8) & 0xff;
1068 	buf[3] = (firmware->size >> 0) & 0xff;
1069 	ret = regmap_bulk_write(state->regmap, 0x50fc, buf, 4);
1070 	if (ret)
1071 		goto err_release_firmware;
1072 
1073 	/* Download firmware */
1074 	#define LEN_MAX 16
1075 	for (rem = firmware->size; rem > 0; rem -= LEN_MAX) {
1076 		len = min(LEN_MAX, rem);
1077 		ret = regmap_bulk_write(state->regmap,
1078 					0x5100 + firmware->size - rem,
1079 					&firmware->data[firmware->size - rem],
1080 					len);
1081 		if (ret) {
1082 			dev_err(&client->dev, "firmware download failed %d\n",
1083 				ret);
1084 			goto err_release_firmware;
1085 		}
1086 	}
1087 
1088 	release_firmware(firmware);
1089 
1090 	/* Boot firmware */
1091 	ret = regmap_write(state->regmap, 0xe205, 0x01);
1092 	if (ret)
1093 		goto err;
1094 
1095 	/* Check firmware status. 0c=OK, 04=fail */
1096 	ret = regmap_read_poll_timeout(state->regmap, 0x98be, utmp,
1097 				       (utmp == 0x0c || utmp == 0x04),
1098 				       5000, 1000000);
1099 	if (ret)
1100 		goto err;
1101 
1102 	dev_dbg(&client->dev, "firmware status %02x\n", utmp);
1103 
1104 	if (utmp == 0x04) {
1105 		ret = -ENODEV;
1106 		dev_err(&client->dev, "firmware did not run\n");
1107 		goto err;
1108 	} else if (utmp != 0x0c) {
1109 		ret = -ENODEV;
1110 		dev_err(&client->dev, "firmware boot timeout\n");
1111 		goto err;
1112 	}
1113 
1114 	dev_info(&client->dev, "found a '%s' in warm state\n",
1115 		 af9013_ops.info.name);
1116 
1117 	return 0;
1118 err_release_firmware:
1119 	release_firmware(firmware);
1120 err:
1121 	dev_dbg(&client->dev, "failed %d\n", ret);
1122 	return ret;
1123 }
1124 
1125 static const struct dvb_frontend_ops af9013_ops = {
1126 	.delsys = { SYS_DVBT },
1127 	.info = {
1128 		.name = "Afatech AF9013",
1129 		.frequency_min_hz = 174 * MHz,
1130 		.frequency_max_hz = 862 * MHz,
1131 		.frequency_stepsize_hz = 250 * kHz,
1132 		.caps =	FE_CAN_FEC_1_2 |
1133 			FE_CAN_FEC_2_3 |
1134 			FE_CAN_FEC_3_4 |
1135 			FE_CAN_FEC_5_6 |
1136 			FE_CAN_FEC_7_8 |
1137 			FE_CAN_FEC_AUTO |
1138 			FE_CAN_QPSK |
1139 			FE_CAN_QAM_16 |
1140 			FE_CAN_QAM_64 |
1141 			FE_CAN_QAM_AUTO |
1142 			FE_CAN_TRANSMISSION_MODE_AUTO |
1143 			FE_CAN_GUARD_INTERVAL_AUTO |
1144 			FE_CAN_HIERARCHY_AUTO |
1145 			FE_CAN_RECOVER |
1146 			FE_CAN_MUTE_TS
1147 	},
1148 
1149 	.init = af9013_init,
1150 	.sleep = af9013_sleep,
1151 
1152 	.get_tune_settings = af9013_get_tune_settings,
1153 	.set_frontend = af9013_set_frontend,
1154 	.get_frontend = af9013_get_frontend,
1155 
1156 	.read_status = af9013_read_status,
1157 	.read_snr = af9013_read_snr,
1158 	.read_signal_strength = af9013_read_signal_strength,
1159 	.read_ber = af9013_read_ber,
1160 	.read_ucblocks = af9013_read_ucblocks,
1161 };
1162 
1163 static int af9013_pid_filter_ctrl(struct dvb_frontend *fe, int onoff)
1164 {
1165 	struct af9013_state *state = fe->demodulator_priv;
1166 	struct i2c_client *client = state->client;
1167 	int ret;
1168 
1169 	dev_dbg(&client->dev, "onoff %d\n", onoff);
1170 
1171 	ret = regmap_update_bits(state->regmap, 0xd503, 0x01, onoff);
1172 	if (ret)
1173 		goto err;
1174 
1175 	return 0;
1176 err:
1177 	dev_dbg(&client->dev, "failed %d\n", ret);
1178 	return ret;
1179 }
1180 
1181 static int af9013_pid_filter(struct dvb_frontend *fe, u8 index, u16 pid,
1182 			     int onoff)
1183 {
1184 	struct af9013_state *state = fe->demodulator_priv;
1185 	struct i2c_client *client = state->client;
1186 	int ret;
1187 	u8 buf[2];
1188 
1189 	dev_dbg(&client->dev, "index %d, pid %04x, onoff %d\n",
1190 		index, pid, onoff);
1191 
1192 	if (pid > 0x1fff) {
1193 		/* 0x2000 is kernel virtual pid for whole ts (all pids) */
1194 		ret = 0;
1195 		goto err;
1196 	}
1197 
1198 	buf[0] = (pid >> 0) & 0xff;
1199 	buf[1] = (pid >> 8) & 0xff;
1200 	ret = regmap_bulk_write(state->regmap, 0xd505, buf, 2);
1201 	if (ret)
1202 		goto err;
1203 	ret = regmap_write(state->regmap, 0xd504, onoff << 5 | index << 0);
1204 	if (ret)
1205 		goto err;
1206 
1207 	return 0;
1208 err:
1209 	dev_dbg(&client->dev, "failed %d\n", ret);
1210 	return ret;
1211 }
1212 
1213 static struct dvb_frontend *af9013_get_dvb_frontend(struct i2c_client *client)
1214 {
1215 	struct af9013_state *state = i2c_get_clientdata(client);
1216 
1217 	dev_dbg(&client->dev, "\n");
1218 
1219 	return &state->fe;
1220 }
1221 
1222 static struct i2c_adapter *af9013_get_i2c_adapter(struct i2c_client *client)
1223 {
1224 	struct af9013_state *state = i2c_get_clientdata(client);
1225 
1226 	dev_dbg(&client->dev, "\n");
1227 
1228 	return state->muxc->adapter[0];
1229 }
1230 
1231 /*
1232  * XXX: Hackish solution. We use virtual register, reg bit 16, to carry info
1233  * about i2c adapter locking. Own locking is needed because i2c mux call has
1234  * already locked i2c adapter.
1235  */
1236 static int af9013_select(struct i2c_mux_core *muxc, u32 chan)
1237 {
1238 	struct af9013_state *state = i2c_mux_priv(muxc);
1239 	struct i2c_client *client = state->client;
1240 	int ret;
1241 
1242 	dev_dbg(&client->dev, "\n");
1243 
1244 	if (state->ts_mode == AF9013_TS_MODE_USB)
1245 		ret = regmap_update_bits(state->regmap, 0x1d417, 0x08, 0x08);
1246 	else
1247 		ret = regmap_update_bits(state->regmap, 0x1d607, 0x04, 0x04);
1248 	if (ret)
1249 		goto err;
1250 
1251 	return 0;
1252 err:
1253 	dev_dbg(&client->dev, "failed %d\n", ret);
1254 	return ret;
1255 }
1256 
1257 static int af9013_deselect(struct i2c_mux_core *muxc, u32 chan)
1258 {
1259 	struct af9013_state *state = i2c_mux_priv(muxc);
1260 	struct i2c_client *client = state->client;
1261 	int ret;
1262 
1263 	dev_dbg(&client->dev, "\n");
1264 
1265 	if (state->ts_mode == AF9013_TS_MODE_USB)
1266 		ret = regmap_update_bits(state->regmap, 0x1d417, 0x08, 0x00);
1267 	else
1268 		ret = regmap_update_bits(state->regmap, 0x1d607, 0x04, 0x00);
1269 	if (ret)
1270 		goto err;
1271 
1272 	return 0;
1273 err:
1274 	dev_dbg(&client->dev, "failed %d\n", ret);
1275 	return ret;
1276 }
1277 
1278 /* Own I2C access routines needed for regmap as chip uses extra command byte */
1279 static int af9013_wregs(struct i2c_client *client, u8 cmd, u16 reg,
1280 			const u8 *val, int len, u8 lock)
1281 {
1282 	int ret;
1283 	u8 buf[21];
1284 	struct i2c_msg msg[1] = {
1285 		{
1286 			.addr = client->addr,
1287 			.flags = 0,
1288 			.len = 3 + len,
1289 			.buf = buf,
1290 		}
1291 	};
1292 
1293 	if (3 + len > sizeof(buf)) {
1294 		ret = -EINVAL;
1295 		goto err;
1296 	}
1297 
1298 	buf[0] = (reg >> 8) & 0xff;
1299 	buf[1] = (reg >> 0) & 0xff;
1300 	buf[2] = cmd;
1301 	memcpy(&buf[3], val, len);
1302 
1303 	if (lock)
1304 		i2c_lock_bus(client->adapter, I2C_LOCK_SEGMENT);
1305 	ret = __i2c_transfer(client->adapter, msg, 1);
1306 	if (lock)
1307 		i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT);
1308 	if (ret < 0) {
1309 		goto err;
1310 	} else if (ret != 1) {
1311 		ret = -EREMOTEIO;
1312 		goto err;
1313 	}
1314 
1315 	return 0;
1316 err:
1317 	dev_dbg(&client->dev, "failed %d\n", ret);
1318 	return ret;
1319 }
1320 
1321 static int af9013_rregs(struct i2c_client *client, u8 cmd, u16 reg,
1322 			u8 *val, int len, u8 lock)
1323 {
1324 	int ret;
1325 	u8 buf[3];
1326 	struct i2c_msg msg[2] = {
1327 		{
1328 			.addr = client->addr,
1329 			.flags = 0,
1330 			.len = 3,
1331 			.buf = buf,
1332 		}, {
1333 			.addr = client->addr,
1334 			.flags = I2C_M_RD,
1335 			.len = len,
1336 			.buf = val,
1337 		}
1338 	};
1339 
1340 	buf[0] = (reg >> 8) & 0xff;
1341 	buf[1] = (reg >> 0) & 0xff;
1342 	buf[2] = cmd;
1343 
1344 	if (lock)
1345 		i2c_lock_bus(client->adapter, I2C_LOCK_SEGMENT);
1346 	ret = __i2c_transfer(client->adapter, msg, 2);
1347 	if (lock)
1348 		i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT);
1349 	if (ret < 0) {
1350 		goto err;
1351 	} else if (ret != 2) {
1352 		ret = -EREMOTEIO;
1353 		goto err;
1354 	}
1355 
1356 	return 0;
1357 err:
1358 	dev_dbg(&client->dev, "failed %d\n", ret);
1359 	return ret;
1360 }
1361 
1362 static int af9013_regmap_write(void *context, const void *data, size_t count)
1363 {
1364 	struct i2c_client *client = context;
1365 	struct af9013_state *state = i2c_get_clientdata(client);
1366 	int ret, i;
1367 	u8 cmd;
1368 	u8 lock = !((u8 *)data)[0];
1369 	u16 reg = ((u8 *)data)[1] << 8 | ((u8 *)data)[2] << 0;
1370 	u8 *val = &((u8 *)data)[3];
1371 	const unsigned int len = count - 3;
1372 
1373 	if (state->ts_mode == AF9013_TS_MODE_USB && (reg & 0xff00) != 0xae00) {
1374 		cmd = 0 << 7|0 << 6|(len - 1) << 2|1 << 1|1 << 0;
1375 		ret = af9013_wregs(client, cmd, reg, val, len, lock);
1376 		if (ret)
1377 			goto err;
1378 	} else if (reg >= 0x5100 && reg < 0x8fff) {
1379 		/* Firmware download */
1380 		cmd = 1 << 7|1 << 6|(len - 1) << 2|1 << 1|1 << 0;
1381 		ret = af9013_wregs(client, cmd, reg, val, len, lock);
1382 		if (ret)
1383 			goto err;
1384 	} else {
1385 		cmd = 0 << 7|0 << 6|(1 - 1) << 2|1 << 1|1 << 0;
1386 		for (i = 0; i < len; i++) {
1387 			ret = af9013_wregs(client, cmd, reg + i, val + i, 1,
1388 					   lock);
1389 			if (ret)
1390 				goto err;
1391 		}
1392 	}
1393 
1394 	return 0;
1395 err:
1396 	dev_dbg(&client->dev, "failed %d\n", ret);
1397 	return ret;
1398 }
1399 
1400 static int af9013_regmap_read(void *context, const void *reg_buf,
1401 			      size_t reg_size, void *val_buf, size_t val_size)
1402 {
1403 	struct i2c_client *client = context;
1404 	struct af9013_state *state = i2c_get_clientdata(client);
1405 	int ret, i;
1406 	u8 cmd;
1407 	u8 lock = !((u8 *)reg_buf)[0];
1408 	u16 reg = ((u8 *)reg_buf)[1] << 8 | ((u8 *)reg_buf)[2] << 0;
1409 	u8 *val = &((u8 *)val_buf)[0];
1410 	const unsigned int len = val_size;
1411 
1412 	if (state->ts_mode == AF9013_TS_MODE_USB && (reg & 0xff00) != 0xae00) {
1413 		cmd = 0 << 7|0 << 6|(len - 1) << 2|1 << 1|0 << 0;
1414 		ret = af9013_rregs(client, cmd, reg, val_buf, len, lock);
1415 		if (ret)
1416 			goto err;
1417 	} else {
1418 		cmd = 0 << 7|0 << 6|(1 - 1) << 2|1 << 1|0 << 0;
1419 		for (i = 0; i < len; i++) {
1420 			ret = af9013_rregs(client, cmd, reg + i, val + i, 1,
1421 					   lock);
1422 			if (ret)
1423 				goto err;
1424 		}
1425 	}
1426 
1427 	return 0;
1428 err:
1429 	dev_dbg(&client->dev, "failed %d\n", ret);
1430 	return ret;
1431 }
1432 
1433 static int af9013_probe(struct i2c_client *client,
1434 			const struct i2c_device_id *id)
1435 {
1436 	struct af9013_state *state;
1437 	struct af9013_platform_data *pdata = client->dev.platform_data;
1438 	struct dtv_frontend_properties *c;
1439 	int ret, i;
1440 	u8 firmware_version[4];
1441 	static const struct regmap_bus regmap_bus = {
1442 		.read = af9013_regmap_read,
1443 		.write = af9013_regmap_write,
1444 	};
1445 	static const struct regmap_config regmap_config = {
1446 		/* Actual reg is 16 bits, see i2c adapter lock */
1447 		.reg_bits = 24,
1448 		.val_bits = 8,
1449 	};
1450 
1451 	state = kzalloc(sizeof(*state), GFP_KERNEL);
1452 	if (!state) {
1453 		ret = -ENOMEM;
1454 		goto err;
1455 	}
1456 
1457 	dev_dbg(&client->dev, "\n");
1458 
1459 	/* Setup the state */
1460 	state->client = client;
1461 	i2c_set_clientdata(client, state);
1462 	state->clk = pdata->clk;
1463 	state->tuner = pdata->tuner;
1464 	state->if_frequency = pdata->if_frequency;
1465 	state->ts_mode = pdata->ts_mode;
1466 	state->ts_output_pin = pdata->ts_output_pin;
1467 	state->spec_inv = pdata->spec_inv;
1468 	memcpy(&state->api_version, pdata->api_version, sizeof(state->api_version));
1469 	memcpy(&state->gpio, pdata->gpio, sizeof(state->gpio));
1470 	state->regmap = regmap_init(&client->dev, &regmap_bus, client,
1471 				  &regmap_config);
1472 	if (IS_ERR(state->regmap)) {
1473 		ret = PTR_ERR(state->regmap);
1474 		goto err_kfree;
1475 	}
1476 	/* Create mux i2c adapter */
1477 	state->muxc = i2c_mux_alloc(client->adapter, &client->dev, 1, 0, 0,
1478 				    af9013_select, af9013_deselect);
1479 	if (!state->muxc) {
1480 		ret = -ENOMEM;
1481 		goto err_regmap_exit;
1482 	}
1483 	state->muxc->priv = state;
1484 	ret = i2c_mux_add_adapter(state->muxc, 0, 0, 0);
1485 	if (ret)
1486 		goto err_regmap_exit;
1487 
1488 	/* Download firmware */
1489 	if (state->ts_mode != AF9013_TS_MODE_USB) {
1490 		ret = af9013_download_firmware(state);
1491 		if (ret)
1492 			goto err_i2c_mux_del_adapters;
1493 	}
1494 
1495 	/* Firmware version */
1496 	ret = regmap_bulk_read(state->regmap, 0x5103, firmware_version,
1497 			       sizeof(firmware_version));
1498 	if (ret)
1499 		goto err_i2c_mux_del_adapters;
1500 
1501 	/* Set GPIOs */
1502 	for (i = 0; i < sizeof(state->gpio); i++) {
1503 		ret = af9013_set_gpio(state, i, state->gpio[i]);
1504 		if (ret)
1505 			goto err_i2c_mux_del_adapters;
1506 	}
1507 
1508 	/* Create dvb frontend */
1509 	memcpy(&state->fe.ops, &af9013_ops, sizeof(state->fe.ops));
1510 	state->fe.demodulator_priv = state;
1511 
1512 	/* Setup callbacks */
1513 	pdata->get_dvb_frontend = af9013_get_dvb_frontend;
1514 	pdata->get_i2c_adapter = af9013_get_i2c_adapter;
1515 	pdata->pid_filter = af9013_pid_filter;
1516 	pdata->pid_filter_ctrl = af9013_pid_filter_ctrl;
1517 
1518 	/* Init stats to indicate which stats are supported */
1519 	c = &state->fe.dtv_property_cache;
1520 	c->strength.len = 1;
1521 	c->cnr.len = 1;
1522 	c->post_bit_error.len = 1;
1523 	c->post_bit_count.len = 1;
1524 	c->block_error.len = 1;
1525 	c->block_count.len = 1;
1526 
1527 	dev_info(&client->dev, "Afatech AF9013 successfully attached\n");
1528 	dev_info(&client->dev, "firmware version: %d.%d.%d.%d\n",
1529 		 firmware_version[0], firmware_version[1],
1530 		 firmware_version[2], firmware_version[3]);
1531 	return 0;
1532 err_i2c_mux_del_adapters:
1533 	i2c_mux_del_adapters(state->muxc);
1534 err_regmap_exit:
1535 	regmap_exit(state->regmap);
1536 err_kfree:
1537 	kfree(state);
1538 err:
1539 	dev_dbg(&client->dev, "failed %d\n", ret);
1540 	return ret;
1541 }
1542 
1543 static void af9013_remove(struct i2c_client *client)
1544 {
1545 	struct af9013_state *state = i2c_get_clientdata(client);
1546 
1547 	dev_dbg(&client->dev, "\n");
1548 
1549 	i2c_mux_del_adapters(state->muxc);
1550 
1551 	regmap_exit(state->regmap);
1552 
1553 	kfree(state);
1554 }
1555 
1556 static const struct i2c_device_id af9013_id_table[] = {
1557 	{"af9013", 0},
1558 	{}
1559 };
1560 MODULE_DEVICE_TABLE(i2c, af9013_id_table);
1561 
1562 static struct i2c_driver af9013_driver = {
1563 	.driver = {
1564 		.name	= "af9013",
1565 		.suppress_bind_attrs = true,
1566 	},
1567 	.probe		= af9013_probe,
1568 	.remove		= af9013_remove,
1569 	.id_table	= af9013_id_table,
1570 };
1571 
1572 module_i2c_driver(af9013_driver);
1573 
1574 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1575 MODULE_DESCRIPTION("Afatech AF9013 DVB-T demodulator driver");
1576 MODULE_LICENSE("GPL");
1577 MODULE_FIRMWARE(AF9013_FIRMWARE);
1578