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 /* Max transfer size done by I2C transfer functions */
24 #define MAX_XFER_SIZE 64
26 static struct dvb_frontend_ops tda10071_ops
;
28 /* write multiple registers */
29 static int tda10071_wr_regs(struct tda10071_priv
*priv
, u8 reg
, u8
*val
,
33 u8 buf
[MAX_XFER_SIZE
];
34 struct i2c_msg msg
[1] = {
36 .addr
= priv
->cfg
.demod_i2c_addr
,
43 if (1 + len
> sizeof(buf
)) {
44 dev_warn(&priv
->i2c
->dev
,
45 "%s: i2c wr reg=%04x: len=%d is too big!\n",
46 KBUILD_MODNAME
, reg
, len
);
51 memcpy(&buf
[1], val
, len
);
53 ret
= i2c_transfer(priv
->i2c
, msg
, 1);
57 dev_warn(&priv
->i2c
->dev
,
58 "%s: i2c wr failed=%d reg=%02x len=%d\n",
59 KBUILD_MODNAME
, ret
, reg
, len
);
65 /* read multiple registers */
66 static int tda10071_rd_regs(struct tda10071_priv
*priv
, u8 reg
, u8
*val
,
70 u8 buf
[MAX_XFER_SIZE
];
71 struct i2c_msg msg
[2] = {
73 .addr
= priv
->cfg
.demod_i2c_addr
,
78 .addr
= priv
->cfg
.demod_i2c_addr
,
85 if (len
> sizeof(buf
)) {
86 dev_warn(&priv
->i2c
->dev
,
87 "%s: i2c wr reg=%04x: len=%d is too big!\n",
88 KBUILD_MODNAME
, reg
, len
);
92 ret
= i2c_transfer(priv
->i2c
, msg
, 2);
94 memcpy(val
, buf
, len
);
97 dev_warn(&priv
->i2c
->dev
,
98 "%s: i2c rd failed=%d reg=%02x len=%d\n",
99 KBUILD_MODNAME
, ret
, reg
, len
);
105 /* write single register */
106 static int tda10071_wr_reg(struct tda10071_priv
*priv
, u8 reg
, u8 val
)
108 return tda10071_wr_regs(priv
, reg
, &val
, 1);
111 /* read single register */
112 static int tda10071_rd_reg(struct tda10071_priv
*priv
, u8 reg
, u8
*val
)
114 return tda10071_rd_regs(priv
, reg
, val
, 1);
117 /* write single register with mask */
118 static int tda10071_wr_reg_mask(struct tda10071_priv
*priv
,
119 u8 reg
, u8 val
, u8 mask
)
124 /* no need for read if whole reg is written */
126 ret
= tda10071_rd_regs(priv
, reg
, &tmp
, 1);
135 return tda10071_wr_regs(priv
, reg
, &val
, 1);
138 /* read single register with mask */
139 static int tda10071_rd_reg_mask(struct tda10071_priv
*priv
,
140 u8 reg
, u8
*val
, u8 mask
)
145 ret
= tda10071_rd_regs(priv
, reg
, &tmp
, 1);
151 /* find position of the first bit */
152 for (i
= 0; i
< 8; i
++) {
153 if ((mask
>> i
) & 0x01)
161 /* execute firmware command */
162 static int tda10071_cmd_execute(struct tda10071_priv
*priv
,
163 struct tda10071_cmd
*cmd
)
173 /* write cmd and args for firmware */
174 ret
= tda10071_wr_regs(priv
, 0x00, cmd
->args
, cmd
->len
);
178 /* start cmd execution */
179 ret
= tda10071_wr_reg(priv
, 0x1f, 1);
183 /* wait cmd execution terminate */
184 for (i
= 1000, tmp
= 1; i
&& tmp
; i
--) {
185 ret
= tda10071_rd_reg(priv
, 0x1f, &tmp
);
189 usleep_range(200, 5000);
192 dev_dbg(&priv
->i2c
->dev
, "%s: loop=%d\n", __func__
, i
);
201 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
205 static int tda10071_set_tone(struct dvb_frontend
*fe
,
206 fe_sec_tone_mode_t fe_sec_tone_mode
)
208 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
209 struct tda10071_cmd cmd
;
218 dev_dbg(&priv
->i2c
->dev
, "%s: tone_mode=%d\n", __func__
,
221 switch (fe_sec_tone_mode
) {
229 dev_dbg(&priv
->i2c
->dev
, "%s: invalid fe_sec_tone_mode\n",
235 cmd
.args
[0] = CMD_LNB_PCB_CONFIG
;
241 ret
= tda10071_cmd_execute(priv
, &cmd
);
247 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
251 static int tda10071_set_voltage(struct dvb_frontend
*fe
,
252 fe_sec_voltage_t fe_sec_voltage
)
254 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
255 struct tda10071_cmd cmd
;
264 dev_dbg(&priv
->i2c
->dev
, "%s: voltage=%d\n", __func__
, fe_sec_voltage
);
266 switch (fe_sec_voltage
) {
273 case SEC_VOLTAGE_OFF
:
277 dev_dbg(&priv
->i2c
->dev
, "%s: invalid fe_sec_voltage\n",
283 cmd
.args
[0] = CMD_LNB_SET_DC_LEVEL
;
285 cmd
.args
[2] = voltage
;
287 ret
= tda10071_cmd_execute(priv
, &cmd
);
293 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
297 static int tda10071_diseqc_send_master_cmd(struct dvb_frontend
*fe
,
298 struct dvb_diseqc_master_cmd
*diseqc_cmd
)
300 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
301 struct tda10071_cmd cmd
;
310 dev_dbg(&priv
->i2c
->dev
, "%s: msg_len=%d\n", __func__
,
311 diseqc_cmd
->msg_len
);
313 if (diseqc_cmd
->msg_len
< 3 || diseqc_cmd
->msg_len
> 6) {
319 for (i
= 500, tmp
= 0; i
&& !tmp
; i
--) {
320 ret
= tda10071_rd_reg_mask(priv
, 0x47, &tmp
, 0x01);
324 usleep_range(10000, 20000);
327 dev_dbg(&priv
->i2c
->dev
, "%s: loop=%d\n", __func__
, i
);
334 ret
= tda10071_wr_reg_mask(priv
, 0x47, 0x00, 0x01);
338 cmd
.args
[0] = CMD_LNB_SEND_DISEQC
;
344 cmd
.args
[6] = diseqc_cmd
->msg_len
;
345 memcpy(&cmd
.args
[7], diseqc_cmd
->msg
, diseqc_cmd
->msg_len
);
346 cmd
.len
= 7 + diseqc_cmd
->msg_len
;
347 ret
= tda10071_cmd_execute(priv
, &cmd
);
353 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
357 static int tda10071_diseqc_recv_slave_reply(struct dvb_frontend
*fe
,
358 struct dvb_diseqc_slave_reply
*reply
)
360 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
361 struct tda10071_cmd cmd
;
370 dev_dbg(&priv
->i2c
->dev
, "%s:\n", __func__
);
373 for (i
= 500, tmp
= 0; i
&& !tmp
; i
--) {
374 ret
= tda10071_rd_reg_mask(priv
, 0x47, &tmp
, 0x02);
378 usleep_range(10000, 20000);
381 dev_dbg(&priv
->i2c
->dev
, "%s: loop=%d\n", __func__
, i
);
389 ret
= tda10071_rd_reg(priv
, 0x46, &tmp
);
393 reply
->msg_len
= tmp
& 0x1f; /* [4:0] */
394 if (reply
->msg_len
> sizeof(reply
->msg
))
395 reply
->msg_len
= sizeof(reply
->msg
); /* truncate API max */
398 cmd
.args
[0] = CMD_LNB_UPDATE_REPLY
;
401 ret
= tda10071_cmd_execute(priv
, &cmd
);
405 ret
= tda10071_rd_regs(priv
, cmd
.len
, reply
->msg
, reply
->msg_len
);
411 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
415 static int tda10071_diseqc_send_burst(struct dvb_frontend
*fe
,
416 fe_sec_mini_cmd_t fe_sec_mini_cmd
)
418 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
419 struct tda10071_cmd cmd
;
428 dev_dbg(&priv
->i2c
->dev
, "%s: fe_sec_mini_cmd=%d\n", __func__
,
431 switch (fe_sec_mini_cmd
) {
439 dev_dbg(&priv
->i2c
->dev
, "%s: invalid fe_sec_mini_cmd\n",
446 for (i
= 500, tmp
= 0; i
&& !tmp
; i
--) {
447 ret
= tda10071_rd_reg_mask(priv
, 0x47, &tmp
, 0x01);
451 usleep_range(10000, 20000);
454 dev_dbg(&priv
->i2c
->dev
, "%s: loop=%d\n", __func__
, i
);
461 ret
= tda10071_wr_reg_mask(priv
, 0x47, 0x00, 0x01);
465 cmd
.args
[0] = CMD_LNB_SEND_TONEBURST
;
469 ret
= tda10071_cmd_execute(priv
, &cmd
);
475 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
479 static int tda10071_read_status(struct dvb_frontend
*fe
, fe_status_t
*status
)
481 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
492 ret
= tda10071_rd_reg(priv
, 0x39, &tmp
);
496 /* 0x39[0] tuner PLL */
497 if (tmp
& 0x02) /* demod PLL */
498 *status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
;
499 if (tmp
& 0x04) /* viterbi or LDPC*/
500 *status
|= FE_HAS_VITERBI
;
501 if (tmp
& 0x08) /* RS or BCH */
502 *status
|= FE_HAS_SYNC
| FE_HAS_LOCK
;
504 priv
->fe_status
= *status
;
508 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
512 static int tda10071_read_snr(struct dvb_frontend
*fe
, u16
*snr
)
514 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
518 if (!priv
->warm
|| !(priv
->fe_status
& FE_HAS_LOCK
)) {
524 ret
= tda10071_rd_regs(priv
, 0x3a, buf
, 2);
529 *snr
= buf
[0] << 8 | buf
[1];
533 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
537 static int tda10071_read_signal_strength(struct dvb_frontend
*fe
, u16
*strength
)
539 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
540 struct tda10071_cmd cmd
;
544 if (!priv
->warm
|| !(priv
->fe_status
& FE_HAS_LOCK
)) {
550 cmd
.args
[0] = CMD_GET_AGCACC
;
553 ret
= tda10071_cmd_execute(priv
, &cmd
);
557 /* input power estimate dBm */
558 ret
= tda10071_rd_reg(priv
, 0x50, &tmp
);
563 tmp
= 181; /* -75 dBm */
565 tmp
= 236; /* -20 dBm */
567 /* scale value to 0x0000-0xffff */
568 *strength
= (tmp
-181) * 0xffff / (236-181);
572 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
576 static int tda10071_read_ber(struct dvb_frontend
*fe
, u32
*ber
)
578 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
579 struct tda10071_cmd cmd
;
583 if (!priv
->warm
|| !(priv
->fe_status
& FE_HAS_LOCK
)) {
584 *ber
= priv
->ber
= 0;
589 switch (priv
->delivery_system
) {
601 *ber
= priv
->ber
= 0;
605 ret
= tda10071_rd_reg(priv
, reg
, &tmp
);
609 if (priv
->meas_count
[i
] == tmp
) {
610 dev_dbg(&priv
->i2c
->dev
, "%s: meas not ready=%02x\n", __func__
,
615 priv
->meas_count
[i
] = tmp
;
618 cmd
.args
[0] = CMD_BER_UPDATE_COUNTERS
;
622 ret
= tda10071_cmd_execute(priv
, &cmd
);
626 ret
= tda10071_rd_regs(priv
, cmd
.len
, buf
, len
);
630 if (priv
->delivery_system
== SYS_DVBS
) {
631 *ber
= (buf
[0] << 24) | (buf
[1] << 16) | (buf
[2] << 8) | buf
[3];
632 priv
->ucb
+= (buf
[4] << 8) | buf
[5];
634 *ber
= (buf
[0] << 8) | buf
[1];
640 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
644 static int tda10071_read_ucblocks(struct dvb_frontend
*fe
, u32
*ucblocks
)
646 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
649 if (!priv
->warm
|| !(priv
->fe_status
& FE_HAS_LOCK
)) {
654 /* UCB is updated when BER is read. Assume BER is read anyway. */
656 *ucblocks
= priv
->ucb
;
660 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
664 static int tda10071_set_frontend(struct dvb_frontend
*fe
)
666 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
667 struct tda10071_cmd cmd
;
668 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
670 u8 mode
, rolloff
, pilot
, inversion
, div
;
671 fe_modulation_t modulation
;
673 dev_dbg(&priv
->i2c
->dev
,
674 "%s: delivery_system=%d modulation=%d frequency=%d symbol_rate=%d inversion=%d pilot=%d rolloff=%d\n",
675 __func__
, c
->delivery_system
, c
->modulation
,
676 c
->frequency
, c
->symbol_rate
, c
->inversion
, c
->pilot
,
679 priv
->delivery_system
= SYS_UNDEFINED
;
686 switch (c
->inversion
) {
694 /* 2 = auto; try first on then off
695 * 3 = auto; try first off then on */
699 dev_dbg(&priv
->i2c
->dev
, "%s: invalid inversion\n", __func__
);
704 switch (c
->delivery_system
) {
711 modulation
= c
->modulation
;
713 switch (c
->rolloff
) {
725 dev_dbg(&priv
->i2c
->dev
, "%s: invalid rolloff\n",
742 dev_dbg(&priv
->i2c
->dev
, "%s: invalid pilot\n",
749 dev_dbg(&priv
->i2c
->dev
, "%s: invalid delivery_system\n",
755 for (i
= 0, mode
= 0xff; i
< ARRAY_SIZE(TDA10071_MODCOD
); i
++) {
756 if (c
->delivery_system
== TDA10071_MODCOD
[i
].delivery_system
&&
757 modulation
== TDA10071_MODCOD
[i
].modulation
&&
758 c
->fec_inner
== TDA10071_MODCOD
[i
].fec
) {
759 mode
= TDA10071_MODCOD
[i
].val
;
760 dev_dbg(&priv
->i2c
->dev
, "%s: mode found=%02x\n",
767 dev_dbg(&priv
->i2c
->dev
, "%s: invalid parameter combination\n",
773 if (c
->symbol_rate
<= 5000000)
778 ret
= tda10071_wr_reg(priv
, 0x81, div
);
782 ret
= tda10071_wr_reg(priv
, 0xe3, div
);
786 cmd
.args
[0] = CMD_CHANGE_CHANNEL
;
789 cmd
.args
[3] = (c
->frequency
>> 16) & 0xff;
790 cmd
.args
[4] = (c
->frequency
>> 8) & 0xff;
791 cmd
.args
[5] = (c
->frequency
>> 0) & 0xff;
792 cmd
.args
[6] = ((c
->symbol_rate
/ 1000) >> 8) & 0xff;
793 cmd
.args
[7] = ((c
->symbol_rate
/ 1000) >> 0) & 0xff;
794 cmd
.args
[8] = (tda10071_ops
.info
.frequency_tolerance
>> 8) & 0xff;
795 cmd
.args
[9] = (tda10071_ops
.info
.frequency_tolerance
>> 0) & 0xff;
796 cmd
.args
[10] = rolloff
;
797 cmd
.args
[11] = inversion
;
798 cmd
.args
[12] = pilot
;
802 ret
= tda10071_cmd_execute(priv
, &cmd
);
806 priv
->delivery_system
= c
->delivery_system
;
810 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
814 static int tda10071_get_frontend(struct dvb_frontend
*fe
)
816 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
817 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
821 if (!priv
->warm
|| !(priv
->fe_status
& FE_HAS_LOCK
)) {
826 ret
= tda10071_rd_regs(priv
, 0x30, buf
, 5);
831 for (i
= 0; i
< ARRAY_SIZE(TDA10071_MODCOD
); i
++) {
832 if (tmp
== TDA10071_MODCOD
[i
].val
) {
833 c
->modulation
= TDA10071_MODCOD
[i
].modulation
;
834 c
->fec_inner
= TDA10071_MODCOD
[i
].fec
;
835 c
->delivery_system
= TDA10071_MODCOD
[i
].delivery_system
;
839 switch ((buf
[1] >> 0) & 0x01) {
841 c
->inversion
= INVERSION_ON
;
844 c
->inversion
= INVERSION_OFF
;
848 switch ((buf
[1] >> 7) & 0x01) {
850 c
->pilot
= PILOT_OFF
;
857 c
->frequency
= (buf
[2] << 16) | (buf
[3] << 8) | (buf
[4] << 0);
859 ret
= tda10071_rd_regs(priv
, 0x52, buf
, 3);
863 c
->symbol_rate
= ((buf
[0] << 16) | (buf
[1] << 8) | (buf
[2] << 0)) * 1000;
867 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
871 static int tda10071_init(struct dvb_frontend
*fe
)
873 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
874 struct tda10071_cmd cmd
;
875 int ret
, i
, len
, remaining
, fw_size
;
876 const struct firmware
*fw
;
877 u8
*fw_file
= TDA10071_FIRMWARE
;
879 struct tda10071_reg_val_mask tab
[] = {
880 { 0xcd, 0x00, 0x07 },
881 { 0x80, 0x00, 0x02 },
882 { 0xcd, 0x00, 0xc0 },
883 { 0xce, 0x00, 0x1b },
884 { 0x9d, 0x00, 0x01 },
885 { 0x9d, 0x00, 0x02 },
886 { 0x9e, 0x00, 0x01 },
887 { 0x87, 0x00, 0x80 },
888 { 0xce, 0x00, 0x08 },
889 { 0xce, 0x00, 0x10 },
891 struct tda10071_reg_val_mask tab2
[] = {
892 { 0xf1, 0x70, 0xff },
893 { 0x88, priv
->cfg
.pll_multiplier
, 0x3f },
894 { 0x89, 0x00, 0x10 },
895 { 0x89, 0x10, 0x10 },
896 { 0xc0, 0x01, 0x01 },
897 { 0xc0, 0x00, 0x01 },
898 { 0xe0, 0xff, 0xff },
899 { 0xe0, 0x00, 0xff },
900 { 0x96, 0x1e, 0x7e },
901 { 0x8b, 0x08, 0x08 },
902 { 0x8b, 0x00, 0x08 },
903 { 0x8f, 0x1a, 0x7e },
904 { 0x8c, 0x68, 0xff },
905 { 0x8d, 0x08, 0xff },
906 { 0x8e, 0x4c, 0xff },
907 { 0x8f, 0x01, 0x01 },
908 { 0x8b, 0x04, 0x04 },
909 { 0x8b, 0x00, 0x04 },
910 { 0x87, 0x05, 0x07 },
911 { 0x80, 0x00, 0x20 },
912 { 0xc8, 0x01, 0xff },
913 { 0xb4, 0x47, 0xff },
914 { 0xb5, 0x9c, 0xff },
915 { 0xb6, 0x7d, 0xff },
916 { 0xba, 0x00, 0x03 },
917 { 0xb7, 0x47, 0xff },
918 { 0xb8, 0x9c, 0xff },
919 { 0xb9, 0x7d, 0xff },
920 { 0xba, 0x00, 0x0c },
921 { 0xc8, 0x00, 0xff },
922 { 0xcd, 0x00, 0x04 },
923 { 0xcd, 0x00, 0x20 },
924 { 0xe8, 0x02, 0xff },
925 { 0xcf, 0x20, 0xff },
926 { 0x9b, 0xd7, 0xff },
927 { 0x9a, 0x01, 0x03 },
928 { 0xa8, 0x05, 0x0f },
929 { 0xa8, 0x65, 0xf0 },
930 { 0xa6, 0xa0, 0xf0 },
931 { 0x9d, 0x50, 0xfc },
932 { 0x9e, 0x20, 0xe0 },
933 { 0xa3, 0x1c, 0x7c },
934 { 0xd5, 0x03, 0x03 },
938 /* warm state - wake up device from sleep */
940 for (i
= 0; i
< ARRAY_SIZE(tab
); i
++) {
941 ret
= tda10071_wr_reg_mask(priv
, tab
[i
].reg
,
942 tab
[i
].val
, tab
[i
].mask
);
947 cmd
.args
[0] = CMD_SET_SLEEP_MODE
;
951 ret
= tda10071_cmd_execute(priv
, &cmd
);
955 /* cold state - try to download firmware */
957 /* request the firmware, this will block and timeout */
958 ret
= request_firmware(&fw
, fw_file
, priv
->i2c
->dev
.parent
);
960 dev_err(&priv
->i2c
->dev
,
961 "%s: did not find the firmware file. (%s) Please see linux/Documentation/dvb/ for more details on firmware-problems. (%d)\n",
962 KBUILD_MODNAME
, fw_file
, ret
);
967 for (i
= 0; i
< ARRAY_SIZE(tab2
); i
++) {
968 ret
= tda10071_wr_reg_mask(priv
, tab2
[i
].reg
,
969 tab2
[i
].val
, tab2
[i
].mask
);
971 goto error_release_firmware
;
974 /* download firmware */
975 ret
= tda10071_wr_reg(priv
, 0xe0, 0x7f);
977 goto error_release_firmware
;
979 ret
= tda10071_wr_reg(priv
, 0xf7, 0x81);
981 goto error_release_firmware
;
983 ret
= tda10071_wr_reg(priv
, 0xf8, 0x00);
985 goto error_release_firmware
;
987 ret
= tda10071_wr_reg(priv
, 0xf9, 0x00);
989 goto error_release_firmware
;
991 dev_info(&priv
->i2c
->dev
,
992 "%s: found a '%s' in cold state, will try to load a firmware\n",
993 KBUILD_MODNAME
, tda10071_ops
.info
.name
);
994 dev_info(&priv
->i2c
->dev
,
995 "%s: downloading firmware from file '%s'\n",
996 KBUILD_MODNAME
, fw_file
);
998 /* do not download last byte */
999 fw_size
= fw
->size
- 1;
1001 for (remaining
= fw_size
; remaining
> 0;
1002 remaining
-= (priv
->cfg
.i2c_wr_max
- 1)) {
1004 if (len
> (priv
->cfg
.i2c_wr_max
- 1))
1005 len
= (priv
->cfg
.i2c_wr_max
- 1);
1007 ret
= tda10071_wr_regs(priv
, 0xfa,
1008 (u8
*) &fw
->data
[fw_size
- remaining
], len
);
1010 dev_err(&priv
->i2c
->dev
,
1011 "%s: firmware download failed=%d\n",
1012 KBUILD_MODNAME
, ret
);
1013 goto error_release_firmware
;
1016 release_firmware(fw
);
1018 ret
= tda10071_wr_reg(priv
, 0xf7, 0x0c);
1022 ret
= tda10071_wr_reg(priv
, 0xe0, 0x00);
1026 /* wait firmware start */
1029 /* firmware status */
1030 ret
= tda10071_rd_reg(priv
, 0x51, &tmp
);
1035 dev_info(&priv
->i2c
->dev
, "%s: firmware did not run\n",
1043 cmd
.args
[0] = CMD_GET_FW_VERSION
;
1045 ret
= tda10071_cmd_execute(priv
, &cmd
);
1049 ret
= tda10071_rd_regs(priv
, cmd
.len
, buf
, 4);
1053 dev_info(&priv
->i2c
->dev
, "%s: firmware version %d.%d.%d.%d\n",
1054 KBUILD_MODNAME
, buf
[0], buf
[1], buf
[2], buf
[3]);
1055 dev_info(&priv
->i2c
->dev
, "%s: found a '%s' in warm state\n",
1056 KBUILD_MODNAME
, tda10071_ops
.info
.name
);
1058 ret
= tda10071_rd_regs(priv
, 0x81, buf
, 2);
1062 cmd
.args
[0] = CMD_DEMOD_INIT
;
1063 cmd
.args
[1] = ((priv
->cfg
.xtal
/ 1000) >> 8) & 0xff;
1064 cmd
.args
[2] = ((priv
->cfg
.xtal
/ 1000) >> 0) & 0xff;
1065 cmd
.args
[3] = buf
[0];
1066 cmd
.args
[4] = buf
[1];
1067 cmd
.args
[5] = priv
->cfg
.pll_multiplier
;
1068 cmd
.args
[6] = priv
->cfg
.spec_inv
;
1071 ret
= tda10071_cmd_execute(priv
, &cmd
);
1075 if (priv
->cfg
.tuner_i2c_addr
)
1076 tmp
= priv
->cfg
.tuner_i2c_addr
;
1080 cmd
.args
[0] = CMD_TUNER_INIT
;
1090 cmd
.args
[10] = 0x00;
1091 cmd
.args
[11] = 0x00;
1092 cmd
.args
[12] = 0x00;
1093 cmd
.args
[13] = 0x00;
1094 cmd
.args
[14] = 0x00;
1096 ret
= tda10071_cmd_execute(priv
, &cmd
);
1100 cmd
.args
[0] = CMD_MPEG_CONFIG
;
1102 cmd
.args
[2] = priv
->cfg
.ts_mode
;
1107 ret
= tda10071_cmd_execute(priv
, &cmd
);
1111 ret
= tda10071_wr_reg_mask(priv
, 0xf0, 0x01, 0x01);
1115 cmd
.args
[0] = CMD_LNB_CONFIG
;
1127 ret
= tda10071_cmd_execute(priv
, &cmd
);
1131 cmd
.args
[0] = CMD_BER_CONTROL
;
1136 ret
= tda10071_cmd_execute(priv
, &cmd
);
1142 error_release_firmware
:
1143 release_firmware(fw
);
1145 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
1149 static int tda10071_sleep(struct dvb_frontend
*fe
)
1151 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
1152 struct tda10071_cmd cmd
;
1154 struct tda10071_reg_val_mask tab
[] = {
1155 { 0xcd, 0x07, 0x07 },
1156 { 0x80, 0x02, 0x02 },
1157 { 0xcd, 0xc0, 0xc0 },
1158 { 0xce, 0x1b, 0x1b },
1159 { 0x9d, 0x01, 0x01 },
1160 { 0x9d, 0x02, 0x02 },
1161 { 0x9e, 0x01, 0x01 },
1162 { 0x87, 0x80, 0x80 },
1163 { 0xce, 0x08, 0x08 },
1164 { 0xce, 0x10, 0x10 },
1172 cmd
.args
[0] = CMD_SET_SLEEP_MODE
;
1176 ret
= tda10071_cmd_execute(priv
, &cmd
);
1180 for (i
= 0; i
< ARRAY_SIZE(tab
); i
++) {
1181 ret
= tda10071_wr_reg_mask(priv
, tab
[i
].reg
, tab
[i
].val
,
1189 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
1193 static int tda10071_get_tune_settings(struct dvb_frontend
*fe
,
1194 struct dvb_frontend_tune_settings
*s
)
1196 s
->min_delay_ms
= 8000;
1203 static void tda10071_release(struct dvb_frontend
*fe
)
1205 struct tda10071_priv
*priv
= fe
->demodulator_priv
;
1209 struct dvb_frontend
*tda10071_attach(const struct tda10071_config
*config
,
1210 struct i2c_adapter
*i2c
)
1213 struct tda10071_priv
*priv
= NULL
;
1216 /* allocate memory for the internal priv */
1217 priv
= kzalloc(sizeof(struct tda10071_priv
), GFP_KERNEL
);
1223 /* make sure demod i2c address is specified */
1224 if (!config
->demod_i2c_addr
) {
1225 dev_dbg(&i2c
->dev
, "%s: invalid demod i2c address\n", __func__
);
1230 /* make sure tuner i2c address is specified */
1231 if (!config
->tuner_i2c_addr
) {
1232 dev_dbg(&i2c
->dev
, "%s: invalid tuner i2c address\n", __func__
);
1237 /* setup the priv */
1239 memcpy(&priv
->cfg
, config
, sizeof(struct tda10071_config
));
1242 ret
= tda10071_rd_reg(priv
, 0xff, &tmp
);
1243 if (ret
|| tmp
!= 0x0f)
1247 ret
= tda10071_rd_reg(priv
, 0xdd, &tmp
);
1248 if (ret
|| tmp
!= 0x00)
1252 ret
= tda10071_rd_reg(priv
, 0xfe, &tmp
);
1253 if (ret
|| tmp
!= 0x01)
1256 /* create dvb_frontend */
1257 memcpy(&priv
->fe
.ops
, &tda10071_ops
, sizeof(struct dvb_frontend_ops
));
1258 priv
->fe
.demodulator_priv
= priv
;
1262 dev_dbg(&i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
1266 EXPORT_SYMBOL(tda10071_attach
);
1268 static struct dvb_frontend_ops tda10071_ops
= {
1269 .delsys
= { SYS_DVBS
, SYS_DVBS2
},
1271 .name
= "NXP TDA10071",
1272 .frequency_min
= 950000,
1273 .frequency_max
= 2150000,
1274 .frequency_tolerance
= 5000,
1275 .symbol_rate_min
= 1000000,
1276 .symbol_rate_max
= 45000000,
1277 .caps
= FE_CAN_INVERSION_AUTO
|
1289 FE_CAN_2G_MODULATION
1292 .release
= tda10071_release
,
1294 .get_tune_settings
= tda10071_get_tune_settings
,
1296 .init
= tda10071_init
,
1297 .sleep
= tda10071_sleep
,
1299 .set_frontend
= tda10071_set_frontend
,
1300 .get_frontend
= tda10071_get_frontend
,
1302 .read_status
= tda10071_read_status
,
1303 .read_snr
= tda10071_read_snr
,
1304 .read_signal_strength
= tda10071_read_signal_strength
,
1305 .read_ber
= tda10071_read_ber
,
1306 .read_ucblocks
= tda10071_read_ucblocks
,
1308 .diseqc_send_master_cmd
= tda10071_diseqc_send_master_cmd
,
1309 .diseqc_recv_slave_reply
= tda10071_diseqc_recv_slave_reply
,
1310 .diseqc_send_burst
= tda10071_diseqc_send_burst
,
1312 .set_tone
= tda10071_set_tone
,
1313 .set_voltage
= tda10071_set_voltage
,
1316 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1317 MODULE_DESCRIPTION("NXP TDA10071 DVB-S/S2 demodulator driver");
1318 MODULE_LICENSE("GPL");
1319 MODULE_FIRMWARE(TDA10071_FIRMWARE
);