2 * NXP TDA10071 + Conexant CX24118A DVB-S/S2 demodulator + tuner driver
4 * Copyright (C) 2011 Antti Palosaari <crope@iki.fi>
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.
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.
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.
21 #include "tda10071_priv.h"
23 static struct dvb_frontend_ops tda10071_ops;
25 /* write multiple registers */
26 static int tda10071_wr_regs(struct tda10071_priv *priv, u8 reg, u8 *val,
31 struct i2c_msg msg[1] = {
33 .addr = priv->cfg.i2c_address,
41 memcpy(&buf[1], val, len);
43 ret = i2c_transfer(priv->i2c, msg, 1);
47 dev_warn(&priv->i2c->dev, "%s: i2c wr failed=%d reg=%02x " \
48 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
54 /* read multiple registers */
55 static int tda10071_rd_regs(struct tda10071_priv *priv, u8 reg, u8 *val,
60 struct i2c_msg msg[2] = {
62 .addr = priv->cfg.i2c_address,
67 .addr = priv->cfg.i2c_address,
74 ret = i2c_transfer(priv->i2c, msg, 2);
76 memcpy(val, buf, len);
79 dev_warn(&priv->i2c->dev, "%s: i2c rd failed=%d reg=%02x " \
80 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
86 /* write single register */
87 static int tda10071_wr_reg(struct tda10071_priv *priv, u8 reg, u8 val)
89 return tda10071_wr_regs(priv, reg, &val, 1);
92 /* read single register */
93 static int tda10071_rd_reg(struct tda10071_priv *priv, u8 reg, u8 *val)
95 return tda10071_rd_regs(priv, reg, val, 1);
98 /* write single register with mask */
99 static int tda10071_wr_reg_mask(struct tda10071_priv *priv,
100 u8 reg, u8 val, u8 mask)
105 /* no need for read if whole reg is written */
107 ret = tda10071_rd_regs(priv, reg, &tmp, 1);
116 return tda10071_wr_regs(priv, reg, &val, 1);
119 /* read single register with mask */
120 static int tda10071_rd_reg_mask(struct tda10071_priv *priv,
121 u8 reg, u8 *val, u8 mask)
126 ret = tda10071_rd_regs(priv, reg, &tmp, 1);
132 /* find position of the first bit */
133 for (i = 0; i < 8; i++) {
134 if ((mask >> i) & 0x01)
142 /* execute firmware command */
143 static int tda10071_cmd_execute(struct tda10071_priv *priv,
144 struct tda10071_cmd *cmd)
154 /* write cmd and args for firmware */
155 ret = tda10071_wr_regs(priv, 0x00, cmd->args, cmd->len);
159 /* start cmd execution */
160 ret = tda10071_wr_reg(priv, 0x1f, 1);
164 /* wait cmd execution terminate */
165 for (i = 1000, tmp = 1; i && tmp; i--) {
166 ret = tda10071_rd_reg(priv, 0x1f, &tmp);
170 usleep_range(200, 5000);
173 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i);
182 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
186 static int tda10071_set_tone(struct dvb_frontend *fe,
187 fe_sec_tone_mode_t fe_sec_tone_mode)
189 struct tda10071_priv *priv = fe->demodulator_priv;
190 struct tda10071_cmd cmd;
199 dev_dbg(&priv->i2c->dev, "%s: tone_mode=%d\n", __func__,
202 switch (fe_sec_tone_mode) {
210 dev_dbg(&priv->i2c->dev, "%s: invalid fe_sec_tone_mode\n",
216 cmd.args[0] = CMD_LNB_PCB_CONFIG;
222 ret = tda10071_cmd_execute(priv, &cmd);
228 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
232 static int tda10071_set_voltage(struct dvb_frontend *fe,
233 fe_sec_voltage_t fe_sec_voltage)
235 struct tda10071_priv *priv = fe->demodulator_priv;
236 struct tda10071_cmd cmd;
245 dev_dbg(&priv->i2c->dev, "%s: voltage=%d\n", __func__, fe_sec_voltage);
247 switch (fe_sec_voltage) {
254 case SEC_VOLTAGE_OFF:
258 dev_dbg(&priv->i2c->dev, "%s: invalid fe_sec_voltage\n",
264 cmd.args[0] = CMD_LNB_SET_DC_LEVEL;
266 cmd.args[2] = voltage;
268 ret = tda10071_cmd_execute(priv, &cmd);
274 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
278 static int tda10071_diseqc_send_master_cmd(struct dvb_frontend *fe,
279 struct dvb_diseqc_master_cmd *diseqc_cmd)
281 struct tda10071_priv *priv = fe->demodulator_priv;
282 struct tda10071_cmd cmd;
291 dev_dbg(&priv->i2c->dev, "%s: msg_len=%d\n", __func__,
292 diseqc_cmd->msg_len);
294 if (diseqc_cmd->msg_len < 3 || diseqc_cmd->msg_len > 6) {
300 for (i = 500, tmp = 0; i && !tmp; i--) {
301 ret = tda10071_rd_reg_mask(priv, 0x47, &tmp, 0x01);
305 usleep_range(10000, 20000);
308 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i);
315 ret = tda10071_wr_reg_mask(priv, 0x47, 0x00, 0x01);
319 cmd.args[0] = CMD_LNB_SEND_DISEQC;
325 cmd.args[6] = diseqc_cmd->msg_len;
326 memcpy(&cmd.args[7], diseqc_cmd->msg, diseqc_cmd->msg_len);
327 cmd.len = 7 + diseqc_cmd->msg_len;
328 ret = tda10071_cmd_execute(priv, &cmd);
334 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
338 static int tda10071_diseqc_recv_slave_reply(struct dvb_frontend *fe,
339 struct dvb_diseqc_slave_reply *reply)
341 struct tda10071_priv *priv = fe->demodulator_priv;
342 struct tda10071_cmd cmd;
351 dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
354 for (i = 500, tmp = 0; i && !tmp; i--) {
355 ret = tda10071_rd_reg_mask(priv, 0x47, &tmp, 0x02);
359 usleep_range(10000, 20000);
362 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i);
370 ret = tda10071_rd_reg(priv, 0x46, &tmp);
374 reply->msg_len = tmp & 0x1f; /* [4:0] */
375 if (reply->msg_len > sizeof(reply->msg))
376 reply->msg_len = sizeof(reply->msg); /* truncate API max */
379 cmd.args[0] = CMD_LNB_UPDATE_REPLY;
382 ret = tda10071_cmd_execute(priv, &cmd);
386 ret = tda10071_rd_regs(priv, cmd.len, reply->msg, reply->msg_len);
392 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
396 static int tda10071_diseqc_send_burst(struct dvb_frontend *fe,
397 fe_sec_mini_cmd_t fe_sec_mini_cmd)
399 struct tda10071_priv *priv = fe->demodulator_priv;
400 struct tda10071_cmd cmd;
409 dev_dbg(&priv->i2c->dev, "%s: fe_sec_mini_cmd=%d\n", __func__,
412 switch (fe_sec_mini_cmd) {
420 dev_dbg(&priv->i2c->dev, "%s: invalid fe_sec_mini_cmd\n",
427 for (i = 500, tmp = 0; i && !tmp; i--) {
428 ret = tda10071_rd_reg_mask(priv, 0x47, &tmp, 0x01);
432 usleep_range(10000, 20000);
435 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i);
442 ret = tda10071_wr_reg_mask(priv, 0x47, 0x00, 0x01);
446 cmd.args[0] = CMD_LNB_SEND_TONEBURST;
450 ret = tda10071_cmd_execute(priv, &cmd);
456 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
460 static int tda10071_read_status(struct dvb_frontend *fe, fe_status_t *status)
462 struct tda10071_priv *priv = fe->demodulator_priv;
473 ret = tda10071_rd_reg(priv, 0x39, &tmp);
477 if (tmp & 0x01) /* tuner PLL */
478 *status |= FE_HAS_SIGNAL;
479 if (tmp & 0x02) /* demod PLL */
480 *status |= FE_HAS_CARRIER;
481 if (tmp & 0x04) /* viterbi or LDPC*/
482 *status |= FE_HAS_VITERBI;
483 if (tmp & 0x08) /* RS or BCH */
484 *status |= FE_HAS_SYNC | FE_HAS_LOCK;
486 priv->fe_status = *status;
490 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
494 static int tda10071_read_snr(struct dvb_frontend *fe, u16 *snr)
496 struct tda10071_priv *priv = fe->demodulator_priv;
500 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) {
506 ret = tda10071_rd_regs(priv, 0x3a, buf, 2);
511 *snr = buf[0] << 8 | buf[1];
515 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
519 static int tda10071_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
521 struct tda10071_priv *priv = fe->demodulator_priv;
522 struct tda10071_cmd cmd;
526 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) {
532 cmd.args[0] = CMD_GET_AGCACC;
535 ret = tda10071_cmd_execute(priv, &cmd);
539 /* input power estimate dBm */
540 ret = tda10071_rd_reg(priv, 0x50, &tmp);
545 tmp = 181; /* -75 dBm */
547 tmp = 236; /* -20 dBm */
549 /* scale value to 0x0000-0xffff */
550 *strength = (tmp-181) * 0xffff / (236-181);
554 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
558 static int tda10071_read_ber(struct dvb_frontend *fe, u32 *ber)
560 struct tda10071_priv *priv = fe->demodulator_priv;
561 struct tda10071_cmd cmd;
565 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) {
566 *ber = priv->ber = 0;
571 switch (priv->delivery_system) {
583 *ber = priv->ber = 0;
587 ret = tda10071_rd_reg(priv, reg, &tmp);
591 if (priv->meas_count[i] == tmp) {
592 dev_dbg(&priv->i2c->dev, "%s: meas not ready=%02x\n", __func__,
597 priv->meas_count[i] = tmp;
600 cmd.args[0] = CMD_BER_UPDATE_COUNTERS;
604 ret = tda10071_cmd_execute(priv, &cmd);
608 ret = tda10071_rd_regs(priv, cmd.len, buf, len);
612 if (priv->delivery_system == SYS_DVBS) {
613 *ber = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
614 priv->ucb += (buf[4] << 8) | buf[5];
616 *ber = (buf[0] << 8) | buf[1];
622 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
626 static int tda10071_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
628 struct tda10071_priv *priv = fe->demodulator_priv;
631 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) {
636 /* UCB is updated when BER is read. Assume BER is read anyway. */
638 *ucblocks = priv->ucb;
642 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
646 static int tda10071_set_frontend(struct dvb_frontend *fe)
648 struct tda10071_priv *priv = fe->demodulator_priv;
649 struct tda10071_cmd cmd;
650 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
652 u8 mode, rolloff, pilot, inversion, div;
654 dev_dbg(&priv->i2c->dev, "%s: delivery_system=%d modulation=%d " \
655 "frequency=%d symbol_rate=%d inversion=%d pilot=%d " \
656 "rolloff=%d\n", __func__, c->delivery_system, c->modulation,
657 c->frequency, c->symbol_rate, c->inversion, c->pilot,
660 priv->delivery_system = SYS_UNDEFINED;
667 switch (c->inversion) {
675 /* 2 = auto; try first on then off
676 * 3 = auto; try first off then on */
680 dev_dbg(&priv->i2c->dev, "%s: invalid inversion\n", __func__);
685 switch (c->delivery_system) {
691 switch (c->rolloff) {
703 dev_dbg(&priv->i2c->dev, "%s: invalid rolloff\n",
720 dev_dbg(&priv->i2c->dev, "%s: invalid pilot\n",
727 dev_dbg(&priv->i2c->dev, "%s: invalid delivery_system\n",
733 for (i = 0, mode = 0xff; i < ARRAY_SIZE(TDA10071_MODCOD); i++) {
734 if (c->delivery_system == TDA10071_MODCOD[i].delivery_system &&
735 c->modulation == TDA10071_MODCOD[i].modulation &&
736 c->fec_inner == TDA10071_MODCOD[i].fec) {
737 mode = TDA10071_MODCOD[i].val;
738 dev_dbg(&priv->i2c->dev, "%s: mode found=%02x\n",
745 dev_dbg(&priv->i2c->dev, "%s: invalid parameter combination\n",
751 if (c->symbol_rate <= 5000000)
756 ret = tda10071_wr_reg(priv, 0x81, div);
760 ret = tda10071_wr_reg(priv, 0xe3, div);
764 cmd.args[0] = CMD_CHANGE_CHANNEL;
767 cmd.args[3] = (c->frequency >> 16) & 0xff;
768 cmd.args[4] = (c->frequency >> 8) & 0xff;
769 cmd.args[5] = (c->frequency >> 0) & 0xff;
770 cmd.args[6] = ((c->symbol_rate / 1000) >> 8) & 0xff;
771 cmd.args[7] = ((c->symbol_rate / 1000) >> 0) & 0xff;
772 cmd.args[8] = (tda10071_ops.info.frequency_tolerance >> 8) & 0xff;
773 cmd.args[9] = (tda10071_ops.info.frequency_tolerance >> 0) & 0xff;
774 cmd.args[10] = rolloff;
775 cmd.args[11] = inversion;
776 cmd.args[12] = pilot;
780 ret = tda10071_cmd_execute(priv, &cmd);
784 priv->delivery_system = c->delivery_system;
788 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
792 static int tda10071_get_frontend(struct dvb_frontend *fe)
794 struct tda10071_priv *priv = fe->demodulator_priv;
795 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
799 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) {
804 ret = tda10071_rd_regs(priv, 0x30, buf, 5);
809 for (i = 0; i < ARRAY_SIZE(TDA10071_MODCOD); i++) {
810 if (tmp == TDA10071_MODCOD[i].val) {
811 c->modulation = TDA10071_MODCOD[i].modulation;
812 c->fec_inner = TDA10071_MODCOD[i].fec;
813 c->delivery_system = TDA10071_MODCOD[i].delivery_system;
817 switch ((buf[1] >> 0) & 0x01) {
819 c->inversion = INVERSION_OFF;
822 c->inversion = INVERSION_ON;
826 switch ((buf[1] >> 7) & 0x01) {
828 c->pilot = PILOT_OFF;
835 c->frequency = (buf[2] << 16) | (buf[3] << 8) | (buf[4] << 0);
837 ret = tda10071_rd_regs(priv, 0x52, buf, 3);
841 c->symbol_rate = (buf[0] << 16) | (buf[1] << 8) | (buf[2] << 0);
845 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
849 static int tda10071_init(struct dvb_frontend *fe)
851 struct tda10071_priv *priv = fe->demodulator_priv;
852 struct tda10071_cmd cmd;
853 int ret, i, len, remaining, fw_size;
854 const struct firmware *fw;
855 u8 *fw_file = TDA10071_FIRMWARE;
857 struct tda10071_reg_val_mask tab[] = {
858 { 0xcd, 0x00, 0x07 },
859 { 0x80, 0x00, 0x02 },
860 { 0xcd, 0x00, 0xc0 },
861 { 0xce, 0x00, 0x1b },
862 { 0x9d, 0x00, 0x01 },
863 { 0x9d, 0x00, 0x02 },
864 { 0x9e, 0x00, 0x01 },
865 { 0x87, 0x00, 0x80 },
866 { 0xce, 0x00, 0x08 },
867 { 0xce, 0x00, 0x10 },
869 struct tda10071_reg_val_mask tab2[] = {
870 { 0xf1, 0x70, 0xff },
871 { 0x88, priv->cfg.pll_multiplier, 0x3f },
872 { 0x89, 0x00, 0x10 },
873 { 0x89, 0x10, 0x10 },
874 { 0xc0, 0x01, 0x01 },
875 { 0xc0, 0x00, 0x01 },
876 { 0xe0, 0xff, 0xff },
877 { 0xe0, 0x00, 0xff },
878 { 0x96, 0x1e, 0x7e },
879 { 0x8b, 0x08, 0x08 },
880 { 0x8b, 0x00, 0x08 },
881 { 0x8f, 0x1a, 0x7e },
882 { 0x8c, 0x68, 0xff },
883 { 0x8d, 0x08, 0xff },
884 { 0x8e, 0x4c, 0xff },
885 { 0x8f, 0x01, 0x01 },
886 { 0x8b, 0x04, 0x04 },
887 { 0x8b, 0x00, 0x04 },
888 { 0x87, 0x05, 0x07 },
889 { 0x80, 0x00, 0x20 },
890 { 0xc8, 0x01, 0xff },
891 { 0xb4, 0x47, 0xff },
892 { 0xb5, 0x9c, 0xff },
893 { 0xb6, 0x7d, 0xff },
894 { 0xba, 0x00, 0x03 },
895 { 0xb7, 0x47, 0xff },
896 { 0xb8, 0x9c, 0xff },
897 { 0xb9, 0x7d, 0xff },
898 { 0xba, 0x00, 0x0c },
899 { 0xc8, 0x00, 0xff },
900 { 0xcd, 0x00, 0x04 },
901 { 0xcd, 0x00, 0x20 },
902 { 0xe8, 0x02, 0xff },
903 { 0xcf, 0x20, 0xff },
904 { 0x9b, 0xd7, 0xff },
905 { 0x9a, 0x01, 0x03 },
906 { 0xa8, 0x05, 0x0f },
907 { 0xa8, 0x65, 0xf0 },
908 { 0xa6, 0xa0, 0xf0 },
909 { 0x9d, 0x50, 0xfc },
910 { 0x9e, 0x20, 0xe0 },
911 { 0xa3, 0x1c, 0x7c },
912 { 0xd5, 0x03, 0x03 },
915 /* firmware status */
916 ret = tda10071_rd_reg(priv, 0x51, &tmp);
921 /* warm state - wake up device from sleep */
924 for (i = 0; i < ARRAY_SIZE(tab); i++) {
925 ret = tda10071_wr_reg_mask(priv, tab[i].reg,
926 tab[i].val, tab[i].mask);
931 cmd.args[0] = CMD_SET_SLEEP_MODE;
935 ret = tda10071_cmd_execute(priv, &cmd);
939 /* cold state - try to download firmware */
942 /* request the firmware, this will block and timeout */
943 ret = request_firmware(&fw, fw_file, priv->i2c->dev.parent);
945 dev_err(&priv->i2c->dev, "%s: did not find the " \
946 "firmware file. (%s) Please see " \
947 "linux/Documentation/dvb/ for more " \
948 "details on firmware-problems. (%d)\n",
949 KBUILD_MODNAME, fw_file, ret);
954 for (i = 0; i < ARRAY_SIZE(tab2); i++) {
955 ret = tda10071_wr_reg_mask(priv, tab2[i].reg,
956 tab2[i].val, tab2[i].mask);
958 goto error_release_firmware;
961 /* download firmware */
962 ret = tda10071_wr_reg(priv, 0xe0, 0x7f);
964 goto error_release_firmware;
966 ret = tda10071_wr_reg(priv, 0xf7, 0x81);
968 goto error_release_firmware;
970 ret = tda10071_wr_reg(priv, 0xf8, 0x00);
972 goto error_release_firmware;
974 ret = tda10071_wr_reg(priv, 0xf9, 0x00);
976 goto error_release_firmware;
978 dev_info(&priv->i2c->dev, "%s: found a '%s' in cold state, " \
979 "will try to load a firmware\n", KBUILD_MODNAME,
980 tda10071_ops.info.name);
981 dev_info(&priv->i2c->dev, "%s: downloading firmware from " \
982 "file '%s'\n", KBUILD_MODNAME, fw_file);
984 /* do not download last byte */
985 fw_size = fw->size - 1;
987 for (remaining = fw_size; remaining > 0;
988 remaining -= (priv->cfg.i2c_wr_max - 1)) {
990 if (len > (priv->cfg.i2c_wr_max - 1))
991 len = (priv->cfg.i2c_wr_max - 1);
993 ret = tda10071_wr_regs(priv, 0xfa,
994 (u8 *) &fw->data[fw_size - remaining], len);
996 dev_err(&priv->i2c->dev, "%s: firmware " \
997 "download failed=%d\n",
998 KBUILD_MODNAME, ret);
1000 goto error_release_firmware;
1003 release_firmware(fw);
1005 ret = tda10071_wr_reg(priv, 0xf7, 0x0c);
1009 ret = tda10071_wr_reg(priv, 0xe0, 0x00);
1013 /* wait firmware start */
1016 /* firmware status */
1017 ret = tda10071_rd_reg(priv, 0x51, &tmp);
1022 dev_info(&priv->i2c->dev, "%s: firmware did not run\n",
1030 cmd.args[0] = CMD_GET_FW_VERSION;
1032 ret = tda10071_cmd_execute(priv, &cmd);
1036 ret = tda10071_rd_regs(priv, cmd.len, buf, 4);
1040 dev_info(&priv->i2c->dev, "%s: firmware version %d.%d.%d.%d\n",
1041 KBUILD_MODNAME, buf[0], buf[1], buf[2], buf[3]);
1042 dev_info(&priv->i2c->dev, "%s: found a '%s' in warm state\n",
1043 KBUILD_MODNAME, tda10071_ops.info.name);
1045 ret = tda10071_rd_regs(priv, 0x81, buf, 2);
1049 cmd.args[0] = CMD_DEMOD_INIT;
1050 cmd.args[1] = ((priv->cfg.xtal / 1000) >> 8) & 0xff;
1051 cmd.args[2] = ((priv->cfg.xtal / 1000) >> 0) & 0xff;
1052 cmd.args[3] = buf[0];
1053 cmd.args[4] = buf[1];
1054 cmd.args[5] = priv->cfg.pll_multiplier;
1055 cmd.args[6] = priv->cfg.spec_inv;
1058 ret = tda10071_cmd_execute(priv, &cmd);
1062 cmd.args[0] = CMD_TUNER_INIT;
1072 cmd.args[10] = 0x00;
1073 cmd.args[11] = 0x00;
1074 cmd.args[12] = 0x00;
1075 cmd.args[13] = 0x00;
1076 cmd.args[14] = 0x00;
1078 ret = tda10071_cmd_execute(priv, &cmd);
1082 cmd.args[0] = CMD_MPEG_CONFIG;
1084 cmd.args[2] = priv->cfg.ts_mode;
1089 ret = tda10071_cmd_execute(priv, &cmd);
1093 ret = tda10071_wr_reg_mask(priv, 0xf0, 0x01, 0x01);
1097 cmd.args[0] = CMD_LNB_CONFIG;
1109 ret = tda10071_cmd_execute(priv, &cmd);
1113 cmd.args[0] = CMD_BER_CONTROL;
1118 ret = tda10071_cmd_execute(priv, &cmd);
1124 error_release_firmware:
1125 release_firmware(fw);
1127 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
1131 static int tda10071_sleep(struct dvb_frontend *fe)
1133 struct tda10071_priv *priv = fe->demodulator_priv;
1134 struct tda10071_cmd cmd;
1136 struct tda10071_reg_val_mask tab[] = {
1137 { 0xcd, 0x07, 0x07 },
1138 { 0x80, 0x02, 0x02 },
1139 { 0xcd, 0xc0, 0xc0 },
1140 { 0xce, 0x1b, 0x1b },
1141 { 0x9d, 0x01, 0x01 },
1142 { 0x9d, 0x02, 0x02 },
1143 { 0x9e, 0x01, 0x01 },
1144 { 0x87, 0x80, 0x80 },
1145 { 0xce, 0x08, 0x08 },
1146 { 0xce, 0x10, 0x10 },
1154 cmd.args[0] = CMD_SET_SLEEP_MODE;
1158 ret = tda10071_cmd_execute(priv, &cmd);
1162 for (i = 0; i < ARRAY_SIZE(tab); i++) {
1163 ret = tda10071_wr_reg_mask(priv, tab[i].reg, tab[i].val,
1171 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
1175 static int tda10071_get_tune_settings(struct dvb_frontend *fe,
1176 struct dvb_frontend_tune_settings *s)
1178 s->min_delay_ms = 8000;
1185 static void tda10071_release(struct dvb_frontend *fe)
1187 struct tda10071_priv *priv = fe->demodulator_priv;
1191 struct dvb_frontend *tda10071_attach(const struct tda10071_config *config,
1192 struct i2c_adapter *i2c)
1195 struct tda10071_priv *priv = NULL;
1198 /* allocate memory for the internal priv */
1199 priv = kzalloc(sizeof(struct tda10071_priv), GFP_KERNEL);
1205 /* setup the priv */
1207 memcpy(&priv->cfg, config, sizeof(struct tda10071_config));
1210 ret = tda10071_rd_reg(priv, 0xff, &tmp);
1211 if (ret || tmp != 0x0f)
1215 ret = tda10071_rd_reg(priv, 0xdd, &tmp);
1216 if (ret || tmp != 0x00)
1220 ret = tda10071_rd_reg(priv, 0xfe, &tmp);
1221 if (ret || tmp != 0x01)
1224 /* create dvb_frontend */
1225 memcpy(&priv->fe.ops, &tda10071_ops, sizeof(struct dvb_frontend_ops));
1226 priv->fe.demodulator_priv = priv;
1230 dev_dbg(&i2c->dev, "%s: failed=%d\n", __func__, ret);
1234 EXPORT_SYMBOL(tda10071_attach);
1236 static struct dvb_frontend_ops tda10071_ops = {
1237 .delsys = { SYS_DVBS, SYS_DVBS2 },
1239 .name = "NXP TDA10071",
1240 .frequency_min = 950000,
1241 .frequency_max = 2150000,
1242 .frequency_tolerance = 5000,
1243 .symbol_rate_min = 1000000,
1244 .symbol_rate_max = 45000000,
1245 .caps = FE_CAN_INVERSION_AUTO |
1257 FE_CAN_2G_MODULATION
1260 .release = tda10071_release,
1262 .get_tune_settings = tda10071_get_tune_settings,
1264 .init = tda10071_init,
1265 .sleep = tda10071_sleep,
1267 .set_frontend = tda10071_set_frontend,
1268 .get_frontend = tda10071_get_frontend,
1270 .read_status = tda10071_read_status,
1271 .read_snr = tda10071_read_snr,
1272 .read_signal_strength = tda10071_read_signal_strength,
1273 .read_ber = tda10071_read_ber,
1274 .read_ucblocks = tda10071_read_ucblocks,
1276 .diseqc_send_master_cmd = tda10071_diseqc_send_master_cmd,
1277 .diseqc_recv_slave_reply = tda10071_diseqc_recv_slave_reply,
1278 .diseqc_send_burst = tda10071_diseqc_send_burst,
1280 .set_tone = tda10071_set_tone,
1281 .set_voltage = tda10071_set_voltage,
1284 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1285 MODULE_DESCRIPTION("NXP TDA10071 DVB-S/S2 demodulator driver");
1286 MODULE_LICENSE("GPL");
1287 MODULE_FIRMWARE(TDA10071_FIRMWARE);