1 /*
2  * NXP TDA10071 + Conexant CX24118A DVB-S/S2 demodulator + tuner 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  *    You should have received a copy of the GNU General Public License along
17  *    with this program; if not, write to the Free Software Foundation, Inc.,
18  *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19  */
20 
21 #include "tda10071_priv.h"
22 
23 static const struct dvb_frontend_ops tda10071_ops;
24 
25 /*
26  * XXX: regmap_update_bits() does not fit our needs as it does not support
27  * partially volatile registers. Also it performs register read even mask is as
28  * wide as register value.
29  */
30 /* write single register with mask */
31 static int tda10071_wr_reg_mask(struct tda10071_dev *dev,
32 				u8 reg, u8 val, u8 mask)
33 {
34 	int ret;
35 	u8 tmp;
36 
37 	/* no need for read if whole reg is written */
38 	if (mask != 0xff) {
39 		ret = regmap_bulk_read(dev->regmap, reg, &tmp, 1);
40 		if (ret)
41 			return ret;
42 
43 		val &= mask;
44 		tmp &= ~mask;
45 		val |= tmp;
46 	}
47 
48 	return regmap_bulk_write(dev->regmap, reg, &val, 1);
49 }
50 
51 /* execute firmware command */
52 static int tda10071_cmd_execute(struct tda10071_dev *dev,
53 	struct tda10071_cmd *cmd)
54 {
55 	struct i2c_client *client = dev->client;
56 	int ret, i;
57 	unsigned int uitmp;
58 
59 	if (!dev->warm) {
60 		ret = -EFAULT;
61 		goto error;
62 	}
63 
64 	mutex_lock(&dev->cmd_execute_mutex);
65 
66 	/* write cmd and args for firmware */
67 	ret = regmap_bulk_write(dev->regmap, 0x00, cmd->args, cmd->len);
68 	if (ret)
69 		goto error_mutex_unlock;
70 
71 	/* start cmd execution */
72 	ret = regmap_write(dev->regmap, 0x1f, 1);
73 	if (ret)
74 		goto error_mutex_unlock;
75 
76 	/* wait cmd execution terminate */
77 	for (i = 1000, uitmp = 1; i && uitmp; i--) {
78 		ret = regmap_read(dev->regmap, 0x1f, &uitmp);
79 		if (ret)
80 			goto error_mutex_unlock;
81 
82 		usleep_range(200, 5000);
83 	}
84 
85 	mutex_unlock(&dev->cmd_execute_mutex);
86 	dev_dbg(&client->dev, "loop=%d\n", i);
87 
88 	if (i == 0) {
89 		ret = -ETIMEDOUT;
90 		goto error;
91 	}
92 
93 	return ret;
94 error_mutex_unlock:
95 	mutex_unlock(&dev->cmd_execute_mutex);
96 error:
97 	dev_dbg(&client->dev, "failed=%d\n", ret);
98 	return ret;
99 }
100 
101 static int tda10071_set_tone(struct dvb_frontend *fe,
102 	enum fe_sec_tone_mode fe_sec_tone_mode)
103 {
104 	struct tda10071_dev *dev = fe->demodulator_priv;
105 	struct i2c_client *client = dev->client;
106 	struct tda10071_cmd cmd;
107 	int ret;
108 	u8 tone;
109 
110 	if (!dev->warm) {
111 		ret = -EFAULT;
112 		goto error;
113 	}
114 
115 	dev_dbg(&client->dev, "tone_mode=%d\n", fe_sec_tone_mode);
116 
117 	switch (fe_sec_tone_mode) {
118 	case SEC_TONE_ON:
119 		tone = 1;
120 		break;
121 	case SEC_TONE_OFF:
122 		tone = 0;
123 		break;
124 	default:
125 		dev_dbg(&client->dev, "invalid fe_sec_tone_mode\n");
126 		ret = -EINVAL;
127 		goto error;
128 	}
129 
130 	cmd.args[0] = CMD_LNB_PCB_CONFIG;
131 	cmd.args[1] = 0;
132 	cmd.args[2] = 0x00;
133 	cmd.args[3] = 0x00;
134 	cmd.args[4] = tone;
135 	cmd.len = 5;
136 	ret = tda10071_cmd_execute(dev, &cmd);
137 	if (ret)
138 		goto error;
139 
140 	return ret;
141 error:
142 	dev_dbg(&client->dev, "failed=%d\n", ret);
143 	return ret;
144 }
145 
146 static int tda10071_set_voltage(struct dvb_frontend *fe,
147 	enum fe_sec_voltage fe_sec_voltage)
148 {
149 	struct tda10071_dev *dev = fe->demodulator_priv;
150 	struct i2c_client *client = dev->client;
151 	struct tda10071_cmd cmd;
152 	int ret;
153 	u8 voltage;
154 
155 	if (!dev->warm) {
156 		ret = -EFAULT;
157 		goto error;
158 	}
159 
160 	dev_dbg(&client->dev, "voltage=%d\n", fe_sec_voltage);
161 
162 	switch (fe_sec_voltage) {
163 	case SEC_VOLTAGE_13:
164 		voltage = 0;
165 		break;
166 	case SEC_VOLTAGE_18:
167 		voltage = 1;
168 		break;
169 	case SEC_VOLTAGE_OFF:
170 		voltage = 0;
171 		break;
172 	default:
173 		dev_dbg(&client->dev, "invalid fe_sec_voltage\n");
174 		ret = -EINVAL;
175 		goto error;
176 	}
177 
178 	cmd.args[0] = CMD_LNB_SET_DC_LEVEL;
179 	cmd.args[1] = 0;
180 	cmd.args[2] = voltage;
181 	cmd.len = 3;
182 	ret = tda10071_cmd_execute(dev, &cmd);
183 	if (ret)
184 		goto error;
185 
186 	return ret;
187 error:
188 	dev_dbg(&client->dev, "failed=%d\n", ret);
189 	return ret;
190 }
191 
192 static int tda10071_diseqc_send_master_cmd(struct dvb_frontend *fe,
193 	struct dvb_diseqc_master_cmd *diseqc_cmd)
194 {
195 	struct tda10071_dev *dev = fe->demodulator_priv;
196 	struct i2c_client *client = dev->client;
197 	struct tda10071_cmd cmd;
198 	int ret, i;
199 	unsigned int uitmp;
200 
201 	if (!dev->warm) {
202 		ret = -EFAULT;
203 		goto error;
204 	}
205 
206 	dev_dbg(&client->dev, "msg_len=%d\n", diseqc_cmd->msg_len);
207 
208 	if (diseqc_cmd->msg_len < 3 || diseqc_cmd->msg_len > 6) {
209 		ret = -EINVAL;
210 		goto error;
211 	}
212 
213 	/* wait LNB TX */
214 	for (i = 500, uitmp = 0; i && !uitmp; i--) {
215 		ret = regmap_read(dev->regmap, 0x47, &uitmp);
216 		if (ret)
217 			goto error;
218 		uitmp = (uitmp >> 0) & 1;
219 		usleep_range(10000, 20000);
220 	}
221 
222 	dev_dbg(&client->dev, "loop=%d\n", i);
223 
224 	if (i == 0) {
225 		ret = -ETIMEDOUT;
226 		goto error;
227 	}
228 
229 	ret = regmap_update_bits(dev->regmap, 0x47, 0x01, 0x00);
230 	if (ret)
231 		goto error;
232 
233 	cmd.args[0] = CMD_LNB_SEND_DISEQC;
234 	cmd.args[1] = 0;
235 	cmd.args[2] = 0;
236 	cmd.args[3] = 0;
237 	cmd.args[4] = 2;
238 	cmd.args[5] = 0;
239 	cmd.args[6] = diseqc_cmd->msg_len;
240 	memcpy(&cmd.args[7], diseqc_cmd->msg, diseqc_cmd->msg_len);
241 	cmd.len = 7 + diseqc_cmd->msg_len;
242 	ret = tda10071_cmd_execute(dev, &cmd);
243 	if (ret)
244 		goto error;
245 
246 	return ret;
247 error:
248 	dev_dbg(&client->dev, "failed=%d\n", ret);
249 	return ret;
250 }
251 
252 static int tda10071_diseqc_recv_slave_reply(struct dvb_frontend *fe,
253 	struct dvb_diseqc_slave_reply *reply)
254 {
255 	struct tda10071_dev *dev = fe->demodulator_priv;
256 	struct i2c_client *client = dev->client;
257 	struct tda10071_cmd cmd;
258 	int ret, i;
259 	unsigned int uitmp;
260 
261 	if (!dev->warm) {
262 		ret = -EFAULT;
263 		goto error;
264 	}
265 
266 	dev_dbg(&client->dev, "\n");
267 
268 	/* wait LNB RX */
269 	for (i = 500, uitmp = 0; i && !uitmp; i--) {
270 		ret = regmap_read(dev->regmap, 0x47, &uitmp);
271 		if (ret)
272 			goto error;
273 		uitmp = (uitmp >> 1) & 1;
274 		usleep_range(10000, 20000);
275 	}
276 
277 	dev_dbg(&client->dev, "loop=%d\n", i);
278 
279 	if (i == 0) {
280 		ret = -ETIMEDOUT;
281 		goto error;
282 	}
283 
284 	/* reply len */
285 	ret = regmap_read(dev->regmap, 0x46, &uitmp);
286 	if (ret)
287 		goto error;
288 
289 	reply->msg_len = uitmp & 0x1f; /* [4:0] */
290 	if (reply->msg_len > sizeof(reply->msg))
291 		reply->msg_len = sizeof(reply->msg); /* truncate API max */
292 
293 	/* read reply */
294 	cmd.args[0] = CMD_LNB_UPDATE_REPLY;
295 	cmd.args[1] = 0;
296 	cmd.len = 2;
297 	ret = tda10071_cmd_execute(dev, &cmd);
298 	if (ret)
299 		goto error;
300 
301 	ret = regmap_bulk_read(dev->regmap, cmd.len, reply->msg,
302 			       reply->msg_len);
303 	if (ret)
304 		goto error;
305 
306 	return ret;
307 error:
308 	dev_dbg(&client->dev, "failed=%d\n", ret);
309 	return ret;
310 }
311 
312 static int tda10071_diseqc_send_burst(struct dvb_frontend *fe,
313 	enum fe_sec_mini_cmd fe_sec_mini_cmd)
314 {
315 	struct tda10071_dev *dev = fe->demodulator_priv;
316 	struct i2c_client *client = dev->client;
317 	struct tda10071_cmd cmd;
318 	int ret, i;
319 	unsigned int uitmp;
320 	u8 burst;
321 
322 	if (!dev->warm) {
323 		ret = -EFAULT;
324 		goto error;
325 	}
326 
327 	dev_dbg(&client->dev, "fe_sec_mini_cmd=%d\n", fe_sec_mini_cmd);
328 
329 	switch (fe_sec_mini_cmd) {
330 	case SEC_MINI_A:
331 		burst = 0;
332 		break;
333 	case SEC_MINI_B:
334 		burst = 1;
335 		break;
336 	default:
337 		dev_dbg(&client->dev, "invalid fe_sec_mini_cmd\n");
338 		ret = -EINVAL;
339 		goto error;
340 	}
341 
342 	/* wait LNB TX */
343 	for (i = 500, uitmp = 0; i && !uitmp; i--) {
344 		ret = regmap_read(dev->regmap, 0x47, &uitmp);
345 		if (ret)
346 			goto error;
347 		uitmp = (uitmp >> 0) & 1;
348 		usleep_range(10000, 20000);
349 	}
350 
351 	dev_dbg(&client->dev, "loop=%d\n", i);
352 
353 	if (i == 0) {
354 		ret = -ETIMEDOUT;
355 		goto error;
356 	}
357 
358 	ret = regmap_update_bits(dev->regmap, 0x47, 0x01, 0x00);
359 	if (ret)
360 		goto error;
361 
362 	cmd.args[0] = CMD_LNB_SEND_TONEBURST;
363 	cmd.args[1] = 0;
364 	cmd.args[2] = burst;
365 	cmd.len = 3;
366 	ret = tda10071_cmd_execute(dev, &cmd);
367 	if (ret)
368 		goto error;
369 
370 	return ret;
371 error:
372 	dev_dbg(&client->dev, "failed=%d\n", ret);
373 	return ret;
374 }
375 
376 static int tda10071_read_status(struct dvb_frontend *fe, enum fe_status *status)
377 {
378 	struct tda10071_dev *dev = fe->demodulator_priv;
379 	struct i2c_client *client = dev->client;
380 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
381 	struct tda10071_cmd cmd;
382 	int ret;
383 	unsigned int uitmp;
384 	u8 buf[8];
385 
386 	*status = 0;
387 
388 	if (!dev->warm) {
389 		ret = 0;
390 		goto error;
391 	}
392 
393 	ret = regmap_read(dev->regmap, 0x39, &uitmp);
394 	if (ret)
395 		goto error;
396 
397 	/* 0x39[0] tuner PLL */
398 	if (uitmp & 0x02) /* demod PLL */
399 		*status |= FE_HAS_SIGNAL | FE_HAS_CARRIER;
400 	if (uitmp & 0x04) /* viterbi or LDPC*/
401 		*status |= FE_HAS_VITERBI;
402 	if (uitmp & 0x08) /* RS or BCH */
403 		*status |= FE_HAS_SYNC | FE_HAS_LOCK;
404 
405 	dev->fe_status = *status;
406 
407 	/* signal strength */
408 	if (dev->fe_status & FE_HAS_SIGNAL) {
409 		cmd.args[0] = CMD_GET_AGCACC;
410 		cmd.args[1] = 0;
411 		cmd.len = 2;
412 		ret = tda10071_cmd_execute(dev, &cmd);
413 		if (ret)
414 			goto error;
415 
416 		/* input power estimate dBm */
417 		ret = regmap_read(dev->regmap, 0x50, &uitmp);
418 		if (ret)
419 			goto error;
420 
421 		c->strength.stat[0].scale = FE_SCALE_DECIBEL;
422 		c->strength.stat[0].svalue = (int) (uitmp - 256) * 1000;
423 	} else {
424 		c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
425 	}
426 
427 	/* CNR */
428 	if (dev->fe_status & FE_HAS_VITERBI) {
429 		/* Es/No */
430 		ret = regmap_bulk_read(dev->regmap, 0x3a, buf, 2);
431 		if (ret)
432 			goto error;
433 
434 		c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
435 		c->cnr.stat[0].svalue = (buf[0] << 8 | buf[1] << 0) * 100;
436 	} else {
437 		c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
438 	}
439 
440 	/* UCB/PER/BER */
441 	if (dev->fe_status & FE_HAS_LOCK) {
442 		/* TODO: report total bits/packets */
443 		u8 delivery_system, reg, len;
444 
445 		switch (dev->delivery_system) {
446 		case SYS_DVBS:
447 			reg = 0x4c;
448 			len = 8;
449 			delivery_system = 1;
450 			break;
451 		case SYS_DVBS2:
452 			reg = 0x4d;
453 			len = 4;
454 			delivery_system = 0;
455 			break;
456 		default:
457 			ret = -EINVAL;
458 			goto error;
459 		}
460 
461 		ret = regmap_read(dev->regmap, reg, &uitmp);
462 		if (ret)
463 			goto error;
464 
465 		if (dev->meas_count == uitmp) {
466 			dev_dbg(&client->dev, "meas not ready=%02x\n", uitmp);
467 			ret = 0;
468 			goto error;
469 		} else {
470 			dev->meas_count = uitmp;
471 		}
472 
473 		cmd.args[0] = CMD_BER_UPDATE_COUNTERS;
474 		cmd.args[1] = 0;
475 		cmd.args[2] = delivery_system;
476 		cmd.len = 3;
477 		ret = tda10071_cmd_execute(dev, &cmd);
478 		if (ret)
479 			goto error;
480 
481 		ret = regmap_bulk_read(dev->regmap, cmd.len, buf, len);
482 		if (ret)
483 			goto error;
484 
485 		if (dev->delivery_system == SYS_DVBS) {
486 			dev->dvbv3_ber = buf[0] << 24 | buf[1] << 16 |
487 					 buf[2] << 8 | buf[3] << 0;
488 			dev->post_bit_error += buf[0] << 24 | buf[1] << 16 |
489 					       buf[2] << 8 | buf[3] << 0;
490 			c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
491 			c->post_bit_error.stat[0].uvalue = dev->post_bit_error;
492 			dev->block_error += buf[4] << 8 | buf[5] << 0;
493 			c->block_error.stat[0].scale = FE_SCALE_COUNTER;
494 			c->block_error.stat[0].uvalue = dev->block_error;
495 		} else {
496 			dev->dvbv3_ber = buf[0] << 8 | buf[1] << 0;
497 			dev->post_bit_error += buf[0] << 8 | buf[1] << 0;
498 			c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
499 			c->post_bit_error.stat[0].uvalue = dev->post_bit_error;
500 			c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
501 		}
502 	} else {
503 		c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
504 		c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
505 	}
506 
507 	return ret;
508 error:
509 	dev_dbg(&client->dev, "failed=%d\n", ret);
510 	return ret;
511 }
512 
513 static int tda10071_read_snr(struct dvb_frontend *fe, u16 *snr)
514 {
515 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
516 
517 	if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
518 		*snr = div_s64(c->cnr.stat[0].svalue, 100);
519 	else
520 		*snr = 0;
521 	return 0;
522 }
523 
524 static int tda10071_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
525 {
526 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
527 	unsigned int uitmp;
528 
529 	if (c->strength.stat[0].scale == FE_SCALE_DECIBEL) {
530 		uitmp = div_s64(c->strength.stat[0].svalue, 1000) + 256;
531 		uitmp = clamp(uitmp, 181U, 236U); /* -75dBm - -20dBm */
532 		/* scale value to 0x0000-0xffff */
533 		*strength = (uitmp-181) * 0xffff / (236-181);
534 	} else {
535 		*strength = 0;
536 	}
537 	return 0;
538 }
539 
540 static int tda10071_read_ber(struct dvb_frontend *fe, u32 *ber)
541 {
542 	struct tda10071_dev *dev = fe->demodulator_priv;
543 
544 	*ber = dev->dvbv3_ber;
545 	return 0;
546 }
547 
548 static int tda10071_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
549 {
550 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
551 
552 	if (c->block_error.stat[0].scale == FE_SCALE_COUNTER)
553 		*ucblocks = c->block_error.stat[0].uvalue;
554 	else
555 		*ucblocks = 0;
556 	return 0;
557 }
558 
559 static int tda10071_set_frontend(struct dvb_frontend *fe)
560 {
561 	struct tda10071_dev *dev = fe->demodulator_priv;
562 	struct i2c_client *client = dev->client;
563 	struct tda10071_cmd cmd;
564 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
565 	int ret, i;
566 	u8 mode, rolloff, pilot, inversion, div;
567 	enum fe_modulation modulation;
568 
569 	dev_dbg(&client->dev,
570 		"delivery_system=%d modulation=%d frequency=%u symbol_rate=%d inversion=%d pilot=%d rolloff=%d\n",
571 		c->delivery_system, c->modulation, c->frequency, c->symbol_rate,
572 		c->inversion, c->pilot, c->rolloff);
573 
574 	dev->delivery_system = SYS_UNDEFINED;
575 
576 	if (!dev->warm) {
577 		ret = -EFAULT;
578 		goto error;
579 	}
580 
581 	switch (c->inversion) {
582 	case INVERSION_OFF:
583 		inversion = 1;
584 		break;
585 	case INVERSION_ON:
586 		inversion = 0;
587 		break;
588 	case INVERSION_AUTO:
589 		/* 2 = auto; try first on then off
590 		 * 3 = auto; try first off then on */
591 		inversion = 3;
592 		break;
593 	default:
594 		dev_dbg(&client->dev, "invalid inversion\n");
595 		ret = -EINVAL;
596 		goto error;
597 	}
598 
599 	switch (c->delivery_system) {
600 	case SYS_DVBS:
601 		modulation = QPSK;
602 		rolloff = 0;
603 		pilot = 2;
604 		break;
605 	case SYS_DVBS2:
606 		modulation = c->modulation;
607 
608 		switch (c->rolloff) {
609 		case ROLLOFF_20:
610 			rolloff = 2;
611 			break;
612 		case ROLLOFF_25:
613 			rolloff = 1;
614 			break;
615 		case ROLLOFF_35:
616 			rolloff = 0;
617 			break;
618 		case ROLLOFF_AUTO:
619 		default:
620 			dev_dbg(&client->dev, "invalid rolloff\n");
621 			ret = -EINVAL;
622 			goto error;
623 		}
624 
625 		switch (c->pilot) {
626 		case PILOT_OFF:
627 			pilot = 0;
628 			break;
629 		case PILOT_ON:
630 			pilot = 1;
631 			break;
632 		case PILOT_AUTO:
633 			pilot = 2;
634 			break;
635 		default:
636 			dev_dbg(&client->dev, "invalid pilot\n");
637 			ret = -EINVAL;
638 			goto error;
639 		}
640 		break;
641 	default:
642 		dev_dbg(&client->dev, "invalid delivery_system\n");
643 		ret = -EINVAL;
644 		goto error;
645 	}
646 
647 	for (i = 0, mode = 0xff; i < ARRAY_SIZE(TDA10071_MODCOD); i++) {
648 		if (c->delivery_system == TDA10071_MODCOD[i].delivery_system &&
649 			modulation == TDA10071_MODCOD[i].modulation &&
650 			c->fec_inner == TDA10071_MODCOD[i].fec) {
651 			mode = TDA10071_MODCOD[i].val;
652 			dev_dbg(&client->dev, "mode found=%02x\n", mode);
653 			break;
654 		}
655 	}
656 
657 	if (mode == 0xff) {
658 		dev_dbg(&client->dev, "invalid parameter combination\n");
659 		ret = -EINVAL;
660 		goto error;
661 	}
662 
663 	if (c->symbol_rate <= 5000000)
664 		div = 14;
665 	else
666 		div = 4;
667 
668 	ret = regmap_write(dev->regmap, 0x81, div);
669 	if (ret)
670 		goto error;
671 
672 	ret = regmap_write(dev->regmap, 0xe3, div);
673 	if (ret)
674 		goto error;
675 
676 	cmd.args[0] = CMD_CHANGE_CHANNEL;
677 	cmd.args[1] = 0;
678 	cmd.args[2] = mode;
679 	cmd.args[3] = (c->frequency >> 16) & 0xff;
680 	cmd.args[4] = (c->frequency >>  8) & 0xff;
681 	cmd.args[5] = (c->frequency >>  0) & 0xff;
682 	cmd.args[6] = ((c->symbol_rate / 1000) >> 8) & 0xff;
683 	cmd.args[7] = ((c->symbol_rate / 1000) >> 0) & 0xff;
684 	cmd.args[8] = (tda10071_ops.info.frequency_tolerance >> 8) & 0xff;
685 	cmd.args[9] = (tda10071_ops.info.frequency_tolerance >> 0) & 0xff;
686 	cmd.args[10] = rolloff;
687 	cmd.args[11] = inversion;
688 	cmd.args[12] = pilot;
689 	cmd.args[13] = 0x00;
690 	cmd.args[14] = 0x00;
691 	cmd.len = 15;
692 	ret = tda10071_cmd_execute(dev, &cmd);
693 	if (ret)
694 		goto error;
695 
696 	dev->delivery_system = c->delivery_system;
697 
698 	return ret;
699 error:
700 	dev_dbg(&client->dev, "failed=%d\n", ret);
701 	return ret;
702 }
703 
704 static int tda10071_get_frontend(struct dvb_frontend *fe,
705 				 struct dtv_frontend_properties *c)
706 {
707 	struct tda10071_dev *dev = fe->demodulator_priv;
708 	struct i2c_client *client = dev->client;
709 	int ret, i;
710 	u8 buf[5], tmp;
711 
712 	if (!dev->warm || !(dev->fe_status & FE_HAS_LOCK)) {
713 		ret = 0;
714 		goto error;
715 	}
716 
717 	ret = regmap_bulk_read(dev->regmap, 0x30, buf, 5);
718 	if (ret)
719 		goto error;
720 
721 	tmp = buf[0] & 0x3f;
722 	for (i = 0; i < ARRAY_SIZE(TDA10071_MODCOD); i++) {
723 		if (tmp == TDA10071_MODCOD[i].val) {
724 			c->modulation = TDA10071_MODCOD[i].modulation;
725 			c->fec_inner = TDA10071_MODCOD[i].fec;
726 			c->delivery_system = TDA10071_MODCOD[i].delivery_system;
727 		}
728 	}
729 
730 	switch ((buf[1] >> 0) & 0x01) {
731 	case 0:
732 		c->inversion = INVERSION_ON;
733 		break;
734 	case 1:
735 		c->inversion = INVERSION_OFF;
736 		break;
737 	}
738 
739 	switch ((buf[1] >> 7) & 0x01) {
740 	case 0:
741 		c->pilot = PILOT_OFF;
742 		break;
743 	case 1:
744 		c->pilot = PILOT_ON;
745 		break;
746 	}
747 
748 	c->frequency = (buf[2] << 16) | (buf[3] << 8) | (buf[4] << 0);
749 
750 	ret = regmap_bulk_read(dev->regmap, 0x52, buf, 3);
751 	if (ret)
752 		goto error;
753 
754 	c->symbol_rate = ((buf[0] << 16) | (buf[1] << 8) | (buf[2] << 0)) * 1000;
755 
756 	return ret;
757 error:
758 	dev_dbg(&client->dev, "failed=%d\n", ret);
759 	return ret;
760 }
761 
762 static int tda10071_init(struct dvb_frontend *fe)
763 {
764 	struct tda10071_dev *dev = fe->demodulator_priv;
765 	struct i2c_client *client = dev->client;
766 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
767 	struct tda10071_cmd cmd;
768 	int ret, i, len, remaining, fw_size;
769 	unsigned int uitmp;
770 	const struct firmware *fw;
771 	u8 *fw_file = TDA10071_FIRMWARE;
772 	u8 tmp, buf[4];
773 	struct tda10071_reg_val_mask tab[] = {
774 		{ 0xcd, 0x00, 0x07 },
775 		{ 0x80, 0x00, 0x02 },
776 		{ 0xcd, 0x00, 0xc0 },
777 		{ 0xce, 0x00, 0x1b },
778 		{ 0x9d, 0x00, 0x01 },
779 		{ 0x9d, 0x00, 0x02 },
780 		{ 0x9e, 0x00, 0x01 },
781 		{ 0x87, 0x00, 0x80 },
782 		{ 0xce, 0x00, 0x08 },
783 		{ 0xce, 0x00, 0x10 },
784 	};
785 	struct tda10071_reg_val_mask tab2[] = {
786 		{ 0xf1, 0x70, 0xff },
787 		{ 0x88, dev->pll_multiplier, 0x3f },
788 		{ 0x89, 0x00, 0x10 },
789 		{ 0x89, 0x10, 0x10 },
790 		{ 0xc0, 0x01, 0x01 },
791 		{ 0xc0, 0x00, 0x01 },
792 		{ 0xe0, 0xff, 0xff },
793 		{ 0xe0, 0x00, 0xff },
794 		{ 0x96, 0x1e, 0x7e },
795 		{ 0x8b, 0x08, 0x08 },
796 		{ 0x8b, 0x00, 0x08 },
797 		{ 0x8f, 0x1a, 0x7e },
798 		{ 0x8c, 0x68, 0xff },
799 		{ 0x8d, 0x08, 0xff },
800 		{ 0x8e, 0x4c, 0xff },
801 		{ 0x8f, 0x01, 0x01 },
802 		{ 0x8b, 0x04, 0x04 },
803 		{ 0x8b, 0x00, 0x04 },
804 		{ 0x87, 0x05, 0x07 },
805 		{ 0x80, 0x00, 0x20 },
806 		{ 0xc8, 0x01, 0xff },
807 		{ 0xb4, 0x47, 0xff },
808 		{ 0xb5, 0x9c, 0xff },
809 		{ 0xb6, 0x7d, 0xff },
810 		{ 0xba, 0x00, 0x03 },
811 		{ 0xb7, 0x47, 0xff },
812 		{ 0xb8, 0x9c, 0xff },
813 		{ 0xb9, 0x7d, 0xff },
814 		{ 0xba, 0x00, 0x0c },
815 		{ 0xc8, 0x00, 0xff },
816 		{ 0xcd, 0x00, 0x04 },
817 		{ 0xcd, 0x00, 0x20 },
818 		{ 0xe8, 0x02, 0xff },
819 		{ 0xcf, 0x20, 0xff },
820 		{ 0x9b, 0xd7, 0xff },
821 		{ 0x9a, 0x01, 0x03 },
822 		{ 0xa8, 0x05, 0x0f },
823 		{ 0xa8, 0x65, 0xf0 },
824 		{ 0xa6, 0xa0, 0xf0 },
825 		{ 0x9d, 0x50, 0xfc },
826 		{ 0x9e, 0x20, 0xe0 },
827 		{ 0xa3, 0x1c, 0x7c },
828 		{ 0xd5, 0x03, 0x03 },
829 	};
830 
831 	if (dev->warm) {
832 		/* warm state - wake up device from sleep */
833 
834 		for (i = 0; i < ARRAY_SIZE(tab); i++) {
835 			ret = tda10071_wr_reg_mask(dev, tab[i].reg,
836 				tab[i].val, tab[i].mask);
837 			if (ret)
838 				goto error;
839 		}
840 
841 		cmd.args[0] = CMD_SET_SLEEP_MODE;
842 		cmd.args[1] = 0;
843 		cmd.args[2] = 0;
844 		cmd.len = 3;
845 		ret = tda10071_cmd_execute(dev, &cmd);
846 		if (ret)
847 			goto error;
848 	} else {
849 		/* cold state - try to download firmware */
850 
851 		/* request the firmware, this will block and timeout */
852 		ret = request_firmware(&fw, fw_file, &client->dev);
853 		if (ret) {
854 			dev_err(&client->dev,
855 				"did not find the firmware file. (%s) Please see linux/Documentation/dvb/ for more details on firmware-problems. (%d)\n",
856 				fw_file, ret);
857 			goto error;
858 		}
859 
860 		/* init */
861 		for (i = 0; i < ARRAY_SIZE(tab2); i++) {
862 			ret = tda10071_wr_reg_mask(dev, tab2[i].reg,
863 				tab2[i].val, tab2[i].mask);
864 			if (ret)
865 				goto error_release_firmware;
866 		}
867 
868 		/*  download firmware */
869 		ret = regmap_write(dev->regmap, 0xe0, 0x7f);
870 		if (ret)
871 			goto error_release_firmware;
872 
873 		ret = regmap_write(dev->regmap, 0xf7, 0x81);
874 		if (ret)
875 			goto error_release_firmware;
876 
877 		ret = regmap_write(dev->regmap, 0xf8, 0x00);
878 		if (ret)
879 			goto error_release_firmware;
880 
881 		ret = regmap_write(dev->regmap, 0xf9, 0x00);
882 		if (ret)
883 			goto error_release_firmware;
884 
885 		dev_info(&client->dev,
886 			 "found a '%s' in cold state, will try to load a firmware\n",
887 			 tda10071_ops.info.name);
888 		dev_info(&client->dev, "downloading firmware from file '%s'\n",
889 			 fw_file);
890 
891 		/* do not download last byte */
892 		fw_size = fw->size - 1;
893 
894 		for (remaining = fw_size; remaining > 0;
895 			remaining -= (dev->i2c_wr_max - 1)) {
896 			len = remaining;
897 			if (len > (dev->i2c_wr_max - 1))
898 				len = (dev->i2c_wr_max - 1);
899 
900 			ret = regmap_bulk_write(dev->regmap, 0xfa,
901 				(u8 *) &fw->data[fw_size - remaining], len);
902 			if (ret) {
903 				dev_err(&client->dev,
904 					"firmware download failed=%d\n", ret);
905 				goto error_release_firmware;
906 			}
907 		}
908 		release_firmware(fw);
909 
910 		ret = regmap_write(dev->regmap, 0xf7, 0x0c);
911 		if (ret)
912 			goto error;
913 
914 		ret = regmap_write(dev->regmap, 0xe0, 0x00);
915 		if (ret)
916 			goto error;
917 
918 		/* wait firmware start */
919 		msleep(250);
920 
921 		/* firmware status */
922 		ret = regmap_read(dev->regmap, 0x51, &uitmp);
923 		if (ret)
924 			goto error;
925 
926 		if (uitmp) {
927 			dev_info(&client->dev, "firmware did not run\n");
928 			ret = -EFAULT;
929 			goto error;
930 		} else {
931 			dev->warm = true;
932 		}
933 
934 		cmd.args[0] = CMD_GET_FW_VERSION;
935 		cmd.len = 1;
936 		ret = tda10071_cmd_execute(dev, &cmd);
937 		if (ret)
938 			goto error;
939 
940 		ret = regmap_bulk_read(dev->regmap, cmd.len, buf, 4);
941 		if (ret)
942 			goto error;
943 
944 		dev_info(&client->dev, "firmware version %d.%d.%d.%d\n",
945 			 buf[0], buf[1], buf[2], buf[3]);
946 		dev_info(&client->dev, "found a '%s' in warm state\n",
947 			 tda10071_ops.info.name);
948 
949 		ret = regmap_bulk_read(dev->regmap, 0x81, buf, 2);
950 		if (ret)
951 			goto error;
952 
953 		cmd.args[0] = CMD_DEMOD_INIT;
954 		cmd.args[1] = ((dev->clk / 1000) >> 8) & 0xff;
955 		cmd.args[2] = ((dev->clk / 1000) >> 0) & 0xff;
956 		cmd.args[3] = buf[0];
957 		cmd.args[4] = buf[1];
958 		cmd.args[5] = dev->pll_multiplier;
959 		cmd.args[6] = dev->spec_inv;
960 		cmd.args[7] = 0x00;
961 		cmd.len = 8;
962 		ret = tda10071_cmd_execute(dev, &cmd);
963 		if (ret)
964 			goto error;
965 
966 		if (dev->tuner_i2c_addr)
967 			tmp = dev->tuner_i2c_addr;
968 		else
969 			tmp = 0x14;
970 
971 		cmd.args[0] = CMD_TUNER_INIT;
972 		cmd.args[1] = 0x00;
973 		cmd.args[2] = 0x00;
974 		cmd.args[3] = 0x00;
975 		cmd.args[4] = 0x00;
976 		cmd.args[5] = tmp;
977 		cmd.args[6] = 0x00;
978 		cmd.args[7] = 0x03;
979 		cmd.args[8] = 0x02;
980 		cmd.args[9] = 0x02;
981 		cmd.args[10] = 0x00;
982 		cmd.args[11] = 0x00;
983 		cmd.args[12] = 0x00;
984 		cmd.args[13] = 0x00;
985 		cmd.args[14] = 0x00;
986 		cmd.len = 15;
987 		ret = tda10071_cmd_execute(dev, &cmd);
988 		if (ret)
989 			goto error;
990 
991 		cmd.args[0] = CMD_MPEG_CONFIG;
992 		cmd.args[1] = 0;
993 		cmd.args[2] = dev->ts_mode;
994 		cmd.args[3] = 0x00;
995 		cmd.args[4] = 0x04;
996 		cmd.args[5] = 0x00;
997 		cmd.len = 6;
998 		ret = tda10071_cmd_execute(dev, &cmd);
999 		if (ret)
1000 			goto error;
1001 
1002 		ret = regmap_update_bits(dev->regmap, 0xf0, 0x01, 0x01);
1003 		if (ret)
1004 			goto error;
1005 
1006 		cmd.args[0] = CMD_LNB_CONFIG;
1007 		cmd.args[1] = 0;
1008 		cmd.args[2] = 150;
1009 		cmd.args[3] = 3;
1010 		cmd.args[4] = 22;
1011 		cmd.args[5] = 1;
1012 		cmd.args[6] = 1;
1013 		cmd.args[7] = 30;
1014 		cmd.args[8] = 30;
1015 		cmd.args[9] = 30;
1016 		cmd.args[10] = 30;
1017 		cmd.len = 11;
1018 		ret = tda10071_cmd_execute(dev, &cmd);
1019 		if (ret)
1020 			goto error;
1021 
1022 		cmd.args[0] = CMD_BER_CONTROL;
1023 		cmd.args[1] = 0;
1024 		cmd.args[2] = 14;
1025 		cmd.args[3] = 14;
1026 		cmd.len = 4;
1027 		ret = tda10071_cmd_execute(dev, &cmd);
1028 		if (ret)
1029 			goto error;
1030 	}
1031 
1032 	/* init stats here in order signal app which stats are supported */
1033 	c->strength.len = 1;
1034 	c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1035 	c->cnr.len = 1;
1036 	c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1037 	c->post_bit_error.len = 1;
1038 	c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1039 	c->block_error.len = 1;
1040 	c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1041 
1042 	return ret;
1043 error_release_firmware:
1044 	release_firmware(fw);
1045 error:
1046 	dev_dbg(&client->dev, "failed=%d\n", ret);
1047 	return ret;
1048 }
1049 
1050 static int tda10071_sleep(struct dvb_frontend *fe)
1051 {
1052 	struct tda10071_dev *dev = fe->demodulator_priv;
1053 	struct i2c_client *client = dev->client;
1054 	struct tda10071_cmd cmd;
1055 	int ret, i;
1056 	struct tda10071_reg_val_mask tab[] = {
1057 		{ 0xcd, 0x07, 0x07 },
1058 		{ 0x80, 0x02, 0x02 },
1059 		{ 0xcd, 0xc0, 0xc0 },
1060 		{ 0xce, 0x1b, 0x1b },
1061 		{ 0x9d, 0x01, 0x01 },
1062 		{ 0x9d, 0x02, 0x02 },
1063 		{ 0x9e, 0x01, 0x01 },
1064 		{ 0x87, 0x80, 0x80 },
1065 		{ 0xce, 0x08, 0x08 },
1066 		{ 0xce, 0x10, 0x10 },
1067 	};
1068 
1069 	if (!dev->warm) {
1070 		ret = -EFAULT;
1071 		goto error;
1072 	}
1073 
1074 	cmd.args[0] = CMD_SET_SLEEP_MODE;
1075 	cmd.args[1] = 0;
1076 	cmd.args[2] = 1;
1077 	cmd.len = 3;
1078 	ret = tda10071_cmd_execute(dev, &cmd);
1079 	if (ret)
1080 		goto error;
1081 
1082 	for (i = 0; i < ARRAY_SIZE(tab); i++) {
1083 		ret = tda10071_wr_reg_mask(dev, tab[i].reg, tab[i].val,
1084 			tab[i].mask);
1085 		if (ret)
1086 			goto error;
1087 	}
1088 
1089 	return ret;
1090 error:
1091 	dev_dbg(&client->dev, "failed=%d\n", ret);
1092 	return ret;
1093 }
1094 
1095 static int tda10071_get_tune_settings(struct dvb_frontend *fe,
1096 	struct dvb_frontend_tune_settings *s)
1097 {
1098 	s->min_delay_ms = 8000;
1099 	s->step_size = 0;
1100 	s->max_drift = 0;
1101 
1102 	return 0;
1103 }
1104 
1105 static const struct dvb_frontend_ops tda10071_ops = {
1106 	.delsys = { SYS_DVBS, SYS_DVBS2 },
1107 	.info = {
1108 		.name = "NXP TDA10071",
1109 		.frequency_min = 950000,
1110 		.frequency_max = 2150000,
1111 		.frequency_tolerance = 5000,
1112 		.symbol_rate_min = 1000000,
1113 		.symbol_rate_max = 45000000,
1114 		.caps = FE_CAN_INVERSION_AUTO |
1115 			FE_CAN_FEC_1_2 |
1116 			FE_CAN_FEC_2_3 |
1117 			FE_CAN_FEC_3_4 |
1118 			FE_CAN_FEC_4_5 |
1119 			FE_CAN_FEC_5_6 |
1120 			FE_CAN_FEC_6_7 |
1121 			FE_CAN_FEC_7_8 |
1122 			FE_CAN_FEC_8_9 |
1123 			FE_CAN_FEC_AUTO |
1124 			FE_CAN_QPSK |
1125 			FE_CAN_RECOVER |
1126 			FE_CAN_2G_MODULATION
1127 	},
1128 
1129 	.get_tune_settings = tda10071_get_tune_settings,
1130 
1131 	.init = tda10071_init,
1132 	.sleep = tda10071_sleep,
1133 
1134 	.set_frontend = tda10071_set_frontend,
1135 	.get_frontend = tda10071_get_frontend,
1136 
1137 	.read_status = tda10071_read_status,
1138 	.read_snr = tda10071_read_snr,
1139 	.read_signal_strength = tda10071_read_signal_strength,
1140 	.read_ber = tda10071_read_ber,
1141 	.read_ucblocks = tda10071_read_ucblocks,
1142 
1143 	.diseqc_send_master_cmd = tda10071_diseqc_send_master_cmd,
1144 	.diseqc_recv_slave_reply = tda10071_diseqc_recv_slave_reply,
1145 	.diseqc_send_burst = tda10071_diseqc_send_burst,
1146 
1147 	.set_tone = tda10071_set_tone,
1148 	.set_voltage = tda10071_set_voltage,
1149 };
1150 
1151 static struct dvb_frontend *tda10071_get_dvb_frontend(struct i2c_client *client)
1152 {
1153 	struct tda10071_dev *dev = i2c_get_clientdata(client);
1154 
1155 	dev_dbg(&client->dev, "\n");
1156 
1157 	return &dev->fe;
1158 }
1159 
1160 static int tda10071_probe(struct i2c_client *client,
1161 			const struct i2c_device_id *id)
1162 {
1163 	struct tda10071_dev *dev;
1164 	struct tda10071_platform_data *pdata = client->dev.platform_data;
1165 	int ret;
1166 	unsigned int uitmp;
1167 	static const struct regmap_config regmap_config = {
1168 		.reg_bits = 8,
1169 		.val_bits = 8,
1170 	};
1171 
1172 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1173 	if (!dev) {
1174 		ret = -ENOMEM;
1175 		goto err;
1176 	}
1177 
1178 	dev->client = client;
1179 	mutex_init(&dev->cmd_execute_mutex);
1180 	dev->clk = pdata->clk;
1181 	dev->i2c_wr_max = pdata->i2c_wr_max;
1182 	dev->ts_mode = pdata->ts_mode;
1183 	dev->spec_inv = pdata->spec_inv;
1184 	dev->pll_multiplier = pdata->pll_multiplier;
1185 	dev->tuner_i2c_addr = pdata->tuner_i2c_addr;
1186 	dev->regmap = devm_regmap_init_i2c(client, &regmap_config);
1187 	if (IS_ERR(dev->regmap)) {
1188 		ret = PTR_ERR(dev->regmap);
1189 		goto err_kfree;
1190 	}
1191 
1192 	/* chip ID */
1193 	ret = regmap_read(dev->regmap, 0xff, &uitmp);
1194 	if (ret)
1195 		goto err_kfree;
1196 	if (uitmp != 0x0f) {
1197 		ret = -ENODEV;
1198 		goto err_kfree;
1199 	}
1200 
1201 	/* chip type */
1202 	ret = regmap_read(dev->regmap, 0xdd, &uitmp);
1203 	if (ret)
1204 		goto err_kfree;
1205 	if (uitmp != 0x00) {
1206 		ret = -ENODEV;
1207 		goto err_kfree;
1208 	}
1209 
1210 	/* chip version */
1211 	ret = regmap_read(dev->regmap, 0xfe, &uitmp);
1212 	if (ret)
1213 		goto err_kfree;
1214 	if (uitmp != 0x01) {
1215 		ret = -ENODEV;
1216 		goto err_kfree;
1217 	}
1218 
1219 	/* create dvb_frontend */
1220 	memcpy(&dev->fe.ops, &tda10071_ops, sizeof(struct dvb_frontend_ops));
1221 	dev->fe.demodulator_priv = dev;
1222 	i2c_set_clientdata(client, dev);
1223 
1224 	/* setup callbacks */
1225 	pdata->get_dvb_frontend = tda10071_get_dvb_frontend;
1226 
1227 	dev_info(&client->dev, "NXP TDA10071 successfully identified\n");
1228 	return 0;
1229 err_kfree:
1230 	kfree(dev);
1231 err:
1232 	dev_dbg(&client->dev, "failed=%d\n", ret);
1233 	return ret;
1234 }
1235 
1236 static int tda10071_remove(struct i2c_client *client)
1237 {
1238 	struct tda10071_dev *dev = i2c_get_clientdata(client);
1239 
1240 	dev_dbg(&client->dev, "\n");
1241 
1242 	kfree(dev);
1243 	return 0;
1244 }
1245 
1246 static const struct i2c_device_id tda10071_id_table[] = {
1247 	{"tda10071_cx24118", 0},
1248 	{}
1249 };
1250 MODULE_DEVICE_TABLE(i2c, tda10071_id_table);
1251 
1252 static struct i2c_driver tda10071_driver = {
1253 	.driver = {
1254 		.name	= "tda10071",
1255 		.suppress_bind_attrs = true,
1256 	},
1257 	.probe		= tda10071_probe,
1258 	.remove		= tda10071_remove,
1259 	.id_table	= tda10071_id_table,
1260 };
1261 
1262 module_i2c_driver(tda10071_driver);
1263 
1264 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1265 MODULE_DESCRIPTION("NXP TDA10071 DVB-S/S2 demodulator driver");
1266 MODULE_LICENSE("GPL");
1267 MODULE_FIRMWARE(TDA10071_FIRMWARE);
1268