?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19-rc7
[linux-2.6/btrfs-unstable.git] / drivers / media / dvb-frontends / tda10071.c
blob097c42d3f8c2661c72e909580419c8ef4a8648a1
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_hz / 1000) >> 8) & 0xff;
685 cmd.args[9] = ((tda10071_ops.info.frequency_tolerance_hz / 1000) >> 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' (status %d). You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware\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_hz = 950 * MHz,
1110 .frequency_max_hz = 2150 * MHz,
1111 .frequency_tolerance_hz = 5 * MHz,
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);
(deprecated) Btrfs devel tree