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