2 * Afatech AF9013 demodulator driver
4 * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
5 * Copyright (C) 2011 Antti Palosaari <crope@iki.fi>
7 * Thanks to Afatech who kindly provided information.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include "af9013_priv.h"
28 struct i2c_adapter *i2c;
29 struct dvb_frontend fe;
30 struct af9013_config config;
32 /* tuner/demod RF and IF AGC limits used for signal strength calc */
33 u8 signal_strength_en, rf_50, rf_80, if_50, if_80;
39 fe_status_t fe_status;
40 unsigned long set_frontend_jiffies;
41 unsigned long read_status_jiffies;
44 unsigned int statistics_step:3;
45 struct delayed_work statistics_work;
48 /* write multiple registers */
49 static int af9013_wr_regs_i2c(struct af9013_state *priv, u8 mbox, u16 reg,
50 const u8 *val, int len)
54 struct i2c_msg msg[1] = {
56 .addr = priv->config.i2c_addr,
63 buf[0] = (reg >> 8) & 0xff;
64 buf[1] = (reg >> 0) & 0xff;
66 memcpy(&buf[3], val, len);
68 ret = i2c_transfer(priv->i2c, msg, 1);
72 dev_warn(&priv->i2c->dev, "%s: i2c wr failed=%d reg=%04x " \
73 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
79 /* read multiple registers */
80 static int af9013_rd_regs_i2c(struct af9013_state *priv, u8 mbox, u16 reg,
85 struct i2c_msg msg[2] = {
87 .addr = priv->config.i2c_addr,
92 .addr = priv->config.i2c_addr,
99 buf[0] = (reg >> 8) & 0xff;
100 buf[1] = (reg >> 0) & 0xff;
103 ret = i2c_transfer(priv->i2c, msg, 2);
107 dev_warn(&priv->i2c->dev, "%s: i2c rd failed=%d reg=%04x " \
108 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
114 /* write multiple registers */
115 static int af9013_wr_regs(struct af9013_state *priv, u16 reg, const u8 *val,
119 u8 mbox = (0 << 7)|(0 << 6)|(1 << 1)|(1 << 0);
121 if ((priv->config.ts_mode == AF9013_TS_USB) &&
122 ((reg & 0xff00) != 0xff00) && ((reg & 0xff00) != 0xae00)) {
123 mbox |= ((len - 1) << 2);
124 ret = af9013_wr_regs_i2c(priv, mbox, reg, val, len);
126 for (i = 0; i < len; i++) {
127 ret = af9013_wr_regs_i2c(priv, mbox, reg+i, val+i, 1);
137 /* read multiple registers */
138 static int af9013_rd_regs(struct af9013_state *priv, u16 reg, u8 *val, int len)
141 u8 mbox = (0 << 7)|(0 << 6)|(1 << 1)|(0 << 0);
143 if ((priv->config.ts_mode == AF9013_TS_USB) &&
144 ((reg & 0xff00) != 0xff00) && ((reg & 0xff00) != 0xae00)) {
145 mbox |= ((len - 1) << 2);
146 ret = af9013_rd_regs_i2c(priv, mbox, reg, val, len);
148 for (i = 0; i < len; i++) {
149 ret = af9013_rd_regs_i2c(priv, mbox, reg+i, val+i, 1);
159 /* write single register */
160 static int af9013_wr_reg(struct af9013_state *priv, u16 reg, u8 val)
162 return af9013_wr_regs(priv, reg, &val, 1);
165 /* read single register */
166 static int af9013_rd_reg(struct af9013_state *priv, u16 reg, u8 *val)
168 return af9013_rd_regs(priv, reg, val, 1);
171 static int af9013_write_ofsm_regs(struct af9013_state *state, u16 reg, u8 *val,
174 u8 mbox = (1 << 7)|(1 << 6)|((len - 1) << 2)|(1 << 1)|(1 << 0);
175 return af9013_wr_regs_i2c(state, mbox, reg, val, len);
178 static int af9013_wr_reg_bits(struct af9013_state *state, u16 reg, int pos,
184 /* no need for read if whole reg is written */
186 ret = af9013_rd_reg(state, reg, &tmp);
190 mask = (0xff >> (8 - len)) << pos;
196 return af9013_wr_reg(state, reg, val);
199 static int af9013_rd_reg_bits(struct af9013_state *state, u16 reg, int pos,
205 ret = af9013_rd_reg(state, reg, &tmp);
210 *val &= (0xff >> (8 - len));
215 static int af9013_set_gpio(struct af9013_state *state, u8 gpio, u8 gpioval)
221 dev_dbg(&state->i2c->dev, "%s: gpio=%d gpioval=%02x\n",
222 __func__, gpio, gpioval);
225 * GPIO0 & GPIO1 0xd735
226 * GPIO2 & GPIO3 0xd736
240 dev_err(&state->i2c->dev, "%s: invalid gpio=%d\n",
241 KBUILD_MODNAME, gpio);
258 ret = af9013_wr_reg_bits(state, addr, pos, 4, gpioval);
264 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
268 static u32 af9013_div(struct af9013_state *state, u32 a, u32 b, u32 x)
272 dev_dbg(&state->i2c->dev, "%s: a=%d b=%d x=%d\n", __func__, a, b, x);
279 for (i = 0; i < x; i++) {
287 r = (c << (u32)x) + r;
289 dev_dbg(&state->i2c->dev, "%s: a=%d b=%d x=%d r=%d r=%x\n",
290 __func__, a, b, x, r, r);
295 static int af9013_power_ctrl(struct af9013_state *state, u8 onoff)
300 dev_dbg(&state->i2c->dev, "%s: onoff=%d\n", __func__, onoff);
303 ret = af9013_wr_reg_bits(state, 0xd417, 4, 1, 1);
307 /* start reset mechanism */
308 ret = af9013_wr_reg(state, 0xaeff, 1);
312 /* wait reset performs */
313 for (i = 0; i < 150; i++) {
314 ret = af9013_rd_reg_bits(state, 0xd417, 1, 1, &tmp);
319 break; /* reset done */
321 usleep_range(5000, 25000);
329 ret = af9013_wr_reg_bits(state, 0xd417, 1, 1, 0);
334 ret = af9013_wr_reg_bits(state, 0xd417, 4, 1, 0);
337 ret = af9013_wr_reg_bits(state, 0xd73a, 3, 1, 0);
340 ret = af9013_wr_reg_bits(state, 0xd73a, 3, 1, 1);
345 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
349 static int af9013_statistics_ber_unc_start(struct dvb_frontend *fe)
351 struct af9013_state *state = fe->demodulator_priv;
354 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
356 /* reset and start BER counter */
357 ret = af9013_wr_reg_bits(state, 0xd391, 4, 1, 1);
363 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
367 static int af9013_statistics_ber_unc_result(struct dvb_frontend *fe)
369 struct af9013_state *state = fe->demodulator_priv;
373 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
375 /* check if error bit count is ready */
376 ret = af9013_rd_reg_bits(state, 0xd391, 4, 1, &buf[0]);
381 dev_dbg(&state->i2c->dev, "%s: not ready\n", __func__);
385 ret = af9013_rd_regs(state, 0xd387, buf, 5);
389 state->ber = (buf[2] << 16) | (buf[1] << 8) | buf[0];
390 state->ucblocks += (buf[4] << 8) | buf[3];
394 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
398 static int af9013_statistics_snr_start(struct dvb_frontend *fe)
400 struct af9013_state *state = fe->demodulator_priv;
403 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
406 ret = af9013_wr_reg_bits(state, 0xd2e1, 3, 1, 1);
412 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
416 static int af9013_statistics_snr_result(struct dvb_frontend *fe)
418 struct af9013_state *state = fe->demodulator_priv;
422 const struct af9013_snr *uninitialized_var(snr_lut);
424 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
426 /* check if SNR ready */
427 ret = af9013_rd_reg_bits(state, 0xd2e1, 3, 1, &tmp);
432 dev_dbg(&state->i2c->dev, "%s: not ready\n", __func__);
437 ret = af9013_rd_regs(state, 0xd2e3, buf, 3);
441 snr_val = (buf[2] << 16) | (buf[1] << 8) | buf[0];
443 /* read current modulation */
444 ret = af9013_rd_reg(state, 0xd3c1, &tmp);
448 switch ((tmp >> 6) & 3) {
450 len = ARRAY_SIZE(qpsk_snr_lut);
451 snr_lut = qpsk_snr_lut;
454 len = ARRAY_SIZE(qam16_snr_lut);
455 snr_lut = qam16_snr_lut;
458 len = ARRAY_SIZE(qam64_snr_lut);
459 snr_lut = qam64_snr_lut;
466 for (i = 0; i < len; i++) {
467 tmp = snr_lut[i].snr;
469 if (snr_val < snr_lut[i].val)
472 state->snr = tmp * 10; /* dB/10 */
476 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
480 static int af9013_statistics_signal_strength(struct dvb_frontend *fe)
482 struct af9013_state *state = fe->demodulator_priv;
484 u8 buf[2], rf_gain, if_gain;
487 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
489 if (!state->signal_strength_en)
492 ret = af9013_rd_regs(state, 0xd07c, buf, 2);
499 signal_strength = (0xffff / \
500 (9 * (state->rf_50 + state->if_50) - \
501 11 * (state->rf_80 + state->if_80))) * \
502 (10 * (rf_gain + if_gain) - \
503 11 * (state->rf_80 + state->if_80));
504 if (signal_strength < 0)
506 else if (signal_strength > 0xffff)
507 signal_strength = 0xffff;
509 state->signal_strength = signal_strength;
513 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
517 static void af9013_statistics_work(struct work_struct *work)
519 struct af9013_state *state = container_of(work,
520 struct af9013_state, statistics_work.work);
521 unsigned int next_msec;
523 /* update only signal strength when demod is not locked */
524 if (!(state->fe_status & FE_HAS_LOCK)) {
525 state->statistics_step = 0;
530 switch (state->statistics_step) {
532 state->statistics_step = 0;
534 af9013_statistics_signal_strength(&state->fe);
535 state->statistics_step++;
539 af9013_statistics_snr_start(&state->fe);
540 state->statistics_step++;
544 af9013_statistics_ber_unc_start(&state->fe);
545 state->statistics_step++;
549 af9013_statistics_snr_result(&state->fe);
550 state->statistics_step++;
554 af9013_statistics_ber_unc_result(&state->fe);
555 state->statistics_step++;
560 schedule_delayed_work(&state->statistics_work,
561 msecs_to_jiffies(next_msec));
564 static int af9013_get_tune_settings(struct dvb_frontend *fe,
565 struct dvb_frontend_tune_settings *fesettings)
567 fesettings->min_delay_ms = 800;
568 fesettings->step_size = 0;
569 fesettings->max_drift = 0;
574 static int af9013_set_frontend(struct dvb_frontend *fe)
576 struct af9013_state *state = fe->demodulator_priv;
577 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
578 int ret, i, sampling_freq;
579 bool auto_mode, spec_inv;
581 u32 if_frequency, freq_cw;
583 dev_dbg(&state->i2c->dev, "%s: frequency=%d bandwidth_hz=%d\n",
584 __func__, c->frequency, c->bandwidth_hz);
587 if (fe->ops.tuner_ops.set_params)
588 fe->ops.tuner_ops.set_params(fe);
590 /* program CFOE coefficients */
591 if (c->bandwidth_hz != state->bandwidth_hz) {
592 for (i = 0; i < ARRAY_SIZE(coeff_lut); i++) {
593 if (coeff_lut[i].clock == state->config.clock &&
594 coeff_lut[i].bandwidth_hz == c->bandwidth_hz) {
599 ret = af9013_wr_regs(state, 0xae00, coeff_lut[i].val,
600 sizeof(coeff_lut[i].val));
603 /* program frequency control */
604 if (c->bandwidth_hz != state->bandwidth_hz || state->first_tune) {
605 /* get used IF frequency */
606 if (fe->ops.tuner_ops.get_if_frequency)
607 fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency);
609 if_frequency = state->config.if_frequency;
611 dev_dbg(&state->i2c->dev, "%s: if_frequency=%d\n",
612 __func__, if_frequency);
614 sampling_freq = if_frequency;
616 while (sampling_freq > (state->config.clock / 2))
617 sampling_freq -= state->config.clock;
619 if (sampling_freq < 0) {
621 spec_inv = state->config.spec_inv;
623 spec_inv = !state->config.spec_inv;
626 freq_cw = af9013_div(state, sampling_freq, state->config.clock,
630 freq_cw = 0x800000 - freq_cw;
632 buf[0] = (freq_cw >> 0) & 0xff;
633 buf[1] = (freq_cw >> 8) & 0xff;
634 buf[2] = (freq_cw >> 16) & 0x7f;
636 freq_cw = 0x800000 - freq_cw;
638 buf[3] = (freq_cw >> 0) & 0xff;
639 buf[4] = (freq_cw >> 8) & 0xff;
640 buf[5] = (freq_cw >> 16) & 0x7f;
642 ret = af9013_wr_regs(state, 0xd140, buf, 3);
646 ret = af9013_wr_regs(state, 0x9be7, buf, 6);
651 /* clear TPS lock flag */
652 ret = af9013_wr_reg_bits(state, 0xd330, 3, 1, 1);
656 /* clear MPEG2 lock flag */
657 ret = af9013_wr_reg_bits(state, 0xd507, 6, 1, 0);
661 /* empty channel function */
662 ret = af9013_wr_reg_bits(state, 0x9bfe, 0, 1, 0);
666 /* empty DVB-T channel function */
667 ret = af9013_wr_reg_bits(state, 0x9bc2, 0, 1, 0);
671 /* transmission parameters */
675 switch (c->transmission_mode) {
676 case TRANSMISSION_MODE_AUTO:
679 case TRANSMISSION_MODE_2K:
681 case TRANSMISSION_MODE_8K:
685 dev_dbg(&state->i2c->dev, "%s: invalid transmission_mode\n",
690 switch (c->guard_interval) {
691 case GUARD_INTERVAL_AUTO:
694 case GUARD_INTERVAL_1_32:
696 case GUARD_INTERVAL_1_16:
699 case GUARD_INTERVAL_1_8:
702 case GUARD_INTERVAL_1_4:
706 dev_dbg(&state->i2c->dev, "%s: invalid guard_interval\n",
711 switch (c->hierarchy) {
727 dev_dbg(&state->i2c->dev, "%s: invalid hierarchy\n", __func__);
731 switch (c->modulation) {
744 dev_dbg(&state->i2c->dev, "%s: invalid modulation\n", __func__);
748 /* Use HP. How and which case we can switch to LP? */
751 switch (c->code_rate_HP) {
770 dev_dbg(&state->i2c->dev, "%s: invalid code_rate_HP\n",
775 switch (c->code_rate_LP) {
796 dev_dbg(&state->i2c->dev, "%s: invalid code_rate_LP\n",
801 switch (c->bandwidth_hz) {
811 dev_dbg(&state->i2c->dev, "%s: invalid bandwidth_hz\n",
817 ret = af9013_wr_regs(state, 0xd3c0, buf, 3);
822 /* clear easy mode flag */
823 ret = af9013_wr_reg(state, 0xaefd, 0);
827 dev_dbg(&state->i2c->dev, "%s: auto params\n", __func__);
829 /* set easy mode flag */
830 ret = af9013_wr_reg(state, 0xaefd, 1);
834 ret = af9013_wr_reg(state, 0xaefe, 0);
838 dev_dbg(&state->i2c->dev, "%s: manual params\n", __func__);
842 ret = af9013_wr_reg(state, 0xffff, 0);
846 state->bandwidth_hz = c->bandwidth_hz;
847 state->set_frontend_jiffies = jiffies;
848 state->first_tune = false;
852 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
856 static int af9013_get_frontend(struct dvb_frontend *fe)
858 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
859 struct af9013_state *state = fe->demodulator_priv;
863 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
865 ret = af9013_rd_regs(state, 0xd3c0, buf, 3);
869 switch ((buf[1] >> 6) & 3) {
871 c->modulation = QPSK;
874 c->modulation = QAM_16;
877 c->modulation = QAM_64;
881 switch ((buf[0] >> 0) & 3) {
883 c->transmission_mode = TRANSMISSION_MODE_2K;
886 c->transmission_mode = TRANSMISSION_MODE_8K;
889 switch ((buf[0] >> 2) & 3) {
891 c->guard_interval = GUARD_INTERVAL_1_32;
894 c->guard_interval = GUARD_INTERVAL_1_16;
897 c->guard_interval = GUARD_INTERVAL_1_8;
900 c->guard_interval = GUARD_INTERVAL_1_4;
904 switch ((buf[0] >> 4) & 7) {
906 c->hierarchy = HIERARCHY_NONE;
909 c->hierarchy = HIERARCHY_1;
912 c->hierarchy = HIERARCHY_2;
915 c->hierarchy = HIERARCHY_4;
919 switch ((buf[2] >> 0) & 7) {
921 c->code_rate_HP = FEC_1_2;
924 c->code_rate_HP = FEC_2_3;
927 c->code_rate_HP = FEC_3_4;
930 c->code_rate_HP = FEC_5_6;
933 c->code_rate_HP = FEC_7_8;
937 switch ((buf[2] >> 3) & 7) {
939 c->code_rate_LP = FEC_1_2;
942 c->code_rate_LP = FEC_2_3;
945 c->code_rate_LP = FEC_3_4;
948 c->code_rate_LP = FEC_5_6;
951 c->code_rate_LP = FEC_7_8;
955 switch ((buf[1] >> 2) & 3) {
957 c->bandwidth_hz = 6000000;
960 c->bandwidth_hz = 7000000;
963 c->bandwidth_hz = 8000000;
969 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
973 static int af9013_read_status(struct dvb_frontend *fe, fe_status_t *status)
975 struct af9013_state *state = fe->demodulator_priv;
980 * Return status from the cache if it is younger than 2000ms with the
981 * exception of last tune is done during 4000ms.
983 if (time_is_after_jiffies(
984 state->read_status_jiffies + msecs_to_jiffies(2000)) &&
985 time_is_before_jiffies(
986 state->set_frontend_jiffies + msecs_to_jiffies(4000))
988 *status = state->fe_status;
995 ret = af9013_rd_reg_bits(state, 0xd507, 6, 1, &tmp);
1000 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI |
1001 FE_HAS_SYNC | FE_HAS_LOCK;
1005 ret = af9013_rd_reg_bits(state, 0xd330, 3, 1, &tmp);
1010 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
1014 state->fe_status = *status;
1015 state->read_status_jiffies = jiffies;
1019 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
1023 static int af9013_read_snr(struct dvb_frontend *fe, u16 *snr)
1025 struct af9013_state *state = fe->demodulator_priv;
1030 static int af9013_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
1032 struct af9013_state *state = fe->demodulator_priv;
1033 *strength = state->signal_strength;
1037 static int af9013_read_ber(struct dvb_frontend *fe, u32 *ber)
1039 struct af9013_state *state = fe->demodulator_priv;
1044 static int af9013_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1046 struct af9013_state *state = fe->demodulator_priv;
1047 *ucblocks = state->ucblocks;
1051 static int af9013_init(struct dvb_frontend *fe)
1053 struct af9013_state *state = fe->demodulator_priv;
1057 const struct af9013_reg_bit *init;
1059 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
1062 ret = af9013_power_ctrl(state, 1);
1067 ret = af9013_wr_reg(state, 0xd73a, 0xa4);
1071 /* write API version to firmware */
1072 ret = af9013_wr_regs(state, 0x9bf2, state->config.api_version, 4);
1076 /* program ADC control */
1077 switch (state->config.clock) {
1078 case 28800000: /* 28.800 MHz */
1081 case 20480000: /* 20.480 MHz */
1084 case 28000000: /* 28.000 MHz */
1087 case 25000000: /* 25.000 MHz */
1091 dev_err(&state->i2c->dev, "%s: invalid clock\n",
1096 adc_cw = af9013_div(state, state->config.clock, 1000000ul, 19);
1097 buf[0] = (adc_cw >> 0) & 0xff;
1098 buf[1] = (adc_cw >> 8) & 0xff;
1099 buf[2] = (adc_cw >> 16) & 0xff;
1101 ret = af9013_wr_regs(state, 0xd180, buf, 3);
1105 ret = af9013_wr_reg_bits(state, 0x9bd2, 0, 4, tmp);
1109 /* set I2C master clock */
1110 ret = af9013_wr_reg(state, 0xd416, 0x14);
1115 ret = af9013_wr_reg_bits(state, 0xd700, 1, 1, 1);
1119 /* set no trigger */
1120 ret = af9013_wr_reg_bits(state, 0xd700, 2, 1, 0);
1124 /* set read-update bit for constellation */
1125 ret = af9013_wr_reg_bits(state, 0xd371, 1, 1, 1);
1129 /* settings for mp2if */
1130 if (state->config.ts_mode == AF9013_TS_USB) {
1131 /* AF9015 split PSB to 1.5k + 0.5k */
1132 ret = af9013_wr_reg_bits(state, 0xd50b, 2, 1, 1);
1136 /* AF9013 change the output bit to data7 */
1137 ret = af9013_wr_reg_bits(state, 0xd500, 3, 1, 1);
1141 /* AF9013 set mpeg to full speed */
1142 ret = af9013_wr_reg_bits(state, 0xd502, 4, 1, 1);
1147 ret = af9013_wr_reg_bits(state, 0xd520, 4, 1, 1);
1151 /* load OFSM settings */
1152 dev_dbg(&state->i2c->dev, "%s: load ofsm settings\n", __func__);
1153 len = ARRAY_SIZE(ofsm_init);
1155 for (i = 0; i < len; i++) {
1156 ret = af9013_wr_reg_bits(state, init[i].addr, init[i].pos,
1157 init[i].len, init[i].val);
1162 /* load tuner specific settings */
1163 dev_dbg(&state->i2c->dev, "%s: load tuner specific settings\n",
1165 switch (state->config.tuner) {
1166 case AF9013_TUNER_MXL5003D:
1167 len = ARRAY_SIZE(tuner_init_mxl5003d);
1168 init = tuner_init_mxl5003d;
1170 case AF9013_TUNER_MXL5005D:
1171 case AF9013_TUNER_MXL5005R:
1172 case AF9013_TUNER_MXL5007T:
1173 len = ARRAY_SIZE(tuner_init_mxl5005);
1174 init = tuner_init_mxl5005;
1176 case AF9013_TUNER_ENV77H11D5:
1177 len = ARRAY_SIZE(tuner_init_env77h11d5);
1178 init = tuner_init_env77h11d5;
1180 case AF9013_TUNER_MT2060:
1181 len = ARRAY_SIZE(tuner_init_mt2060);
1182 init = tuner_init_mt2060;
1184 case AF9013_TUNER_MC44S803:
1185 len = ARRAY_SIZE(tuner_init_mc44s803);
1186 init = tuner_init_mc44s803;
1188 case AF9013_TUNER_QT1010:
1189 case AF9013_TUNER_QT1010A:
1190 len = ARRAY_SIZE(tuner_init_qt1010);
1191 init = tuner_init_qt1010;
1193 case AF9013_TUNER_MT2060_2:
1194 len = ARRAY_SIZE(tuner_init_mt2060_2);
1195 init = tuner_init_mt2060_2;
1197 case AF9013_TUNER_TDA18271:
1198 case AF9013_TUNER_TDA18218:
1199 len = ARRAY_SIZE(tuner_init_tda18271);
1200 init = tuner_init_tda18271;
1202 case AF9013_TUNER_UNKNOWN:
1204 len = ARRAY_SIZE(tuner_init_unknown);
1205 init = tuner_init_unknown;
1209 for (i = 0; i < len; i++) {
1210 ret = af9013_wr_reg_bits(state, init[i].addr, init[i].pos,
1211 init[i].len, init[i].val);
1217 ret = af9013_wr_reg_bits(state, 0xd500, 1, 2, state->config.ts_mode);
1221 /* enable lock led */
1222 ret = af9013_wr_reg_bits(state, 0xd730, 0, 1, 1);
1226 /* check if we support signal strength */
1227 if (!state->signal_strength_en) {
1228 ret = af9013_rd_reg_bits(state, 0x9bee, 0, 1,
1229 &state->signal_strength_en);
1234 /* read values needed for signal strength calculation */
1235 if (state->signal_strength_en && !state->rf_50) {
1236 ret = af9013_rd_reg(state, 0x9bbd, &state->rf_50);
1240 ret = af9013_rd_reg(state, 0x9bd0, &state->rf_80);
1244 ret = af9013_rd_reg(state, 0x9be2, &state->if_50);
1248 ret = af9013_rd_reg(state, 0x9be4, &state->if_80);
1254 ret = af9013_wr_reg(state, 0xd2e2, 1);
1259 buf[0] = (10000 >> 0) & 0xff;
1260 buf[1] = (10000 >> 8) & 0xff;
1261 ret = af9013_wr_regs(state, 0xd385, buf, 2);
1265 /* enable FEC monitor */
1266 ret = af9013_wr_reg_bits(state, 0xd392, 1, 1, 1);
1270 state->first_tune = true;
1271 schedule_delayed_work(&state->statistics_work, msecs_to_jiffies(400));
1275 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
1279 static int af9013_sleep(struct dvb_frontend *fe)
1281 struct af9013_state *state = fe->demodulator_priv;
1284 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
1286 /* stop statistics polling */
1287 cancel_delayed_work_sync(&state->statistics_work);
1289 /* disable lock led */
1290 ret = af9013_wr_reg_bits(state, 0xd730, 0, 1, 0);
1295 ret = af9013_power_ctrl(state, 0);
1301 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
1305 static int af9013_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
1308 struct af9013_state *state = fe->demodulator_priv;
1310 dev_dbg(&state->i2c->dev, "%s: enable=%d\n", __func__, enable);
1312 /* gate already open or close */
1313 if (state->i2c_gate_state == enable)
1316 if (state->config.ts_mode == AF9013_TS_USB)
1317 ret = af9013_wr_reg_bits(state, 0xd417, 3, 1, enable);
1319 ret = af9013_wr_reg_bits(state, 0xd607, 2, 1, enable);
1323 state->i2c_gate_state = enable;
1327 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
1331 static void af9013_release(struct dvb_frontend *fe)
1333 struct af9013_state *state = fe->demodulator_priv;
1337 static struct dvb_frontend_ops af9013_ops;
1339 static int af9013_download_firmware(struct af9013_state *state)
1341 int i, len, remaining, ret;
1342 const struct firmware *fw;
1346 u8 *fw_file = AF9013_FIRMWARE;
1349 /* check whether firmware is already running */
1350 ret = af9013_rd_reg(state, 0x98be, &val);
1354 dev_dbg(&state->i2c->dev, "%s: firmware status=%02x\n",
1357 if (val == 0x0c) /* fw is running, no need for download */
1360 dev_info(&state->i2c->dev, "%s: found a '%s' in cold state, will try " \
1361 "to load a firmware\n",
1362 KBUILD_MODNAME, af9013_ops.info.name);
1364 /* request the firmware, this will block and timeout */
1365 ret = request_firmware(&fw, fw_file, state->i2c->dev.parent);
1367 dev_info(&state->i2c->dev, "%s: did not find the firmware " \
1368 "file. (%s) Please see linux/Documentation/dvb/ for " \
1369 "more details on firmware-problems. (%d)\n",
1370 KBUILD_MODNAME, fw_file, ret);
1374 dev_info(&state->i2c->dev, "%s: downloading firmware from file '%s'\n",
1375 KBUILD_MODNAME, fw_file);
1378 for (i = 0; i < fw->size; i++)
1379 checksum += fw->data[i];
1381 fw_params[0] = checksum >> 8;
1382 fw_params[1] = checksum & 0xff;
1383 fw_params[2] = fw->size >> 8;
1384 fw_params[3] = fw->size & 0xff;
1386 /* write fw checksum & size */
1387 ret = af9013_write_ofsm_regs(state, 0x50fc,
1388 fw_params, sizeof(fw_params));
1392 #define FW_ADDR 0x5100 /* firmware start address */
1393 #define LEN_MAX 16 /* max packet size */
1394 for (remaining = fw->size; remaining > 0; remaining -= LEN_MAX) {
1399 ret = af9013_write_ofsm_regs(state,
1400 FW_ADDR + fw->size - remaining,
1401 (u8 *) &fw->data[fw->size - remaining], len);
1403 dev_err(&state->i2c->dev,
1404 "%s: firmware download failed=%d\n",
1405 KBUILD_MODNAME, ret);
1410 /* request boot firmware */
1411 ret = af9013_wr_reg(state, 0xe205, 1);
1415 for (i = 0; i < 15; i++) {
1418 /* check firmware status */
1419 ret = af9013_rd_reg(state, 0x98be, &val);
1423 dev_dbg(&state->i2c->dev, "%s: firmware status=%02x\n",
1426 if (val == 0x0c || val == 0x04) /* success or fail */
1431 dev_err(&state->i2c->dev, "%s: firmware did not run\n",
1434 } else if (val != 0x0c) {
1435 dev_err(&state->i2c->dev, "%s: firmware boot timeout\n",
1441 release_firmware(fw);
1445 dev_info(&state->i2c->dev, "%s: found a '%s' in warm state\n",
1446 KBUILD_MODNAME, af9013_ops.info.name);
1450 struct dvb_frontend *af9013_attach(const struct af9013_config *config,
1451 struct i2c_adapter *i2c)
1454 struct af9013_state *state = NULL;
1457 /* allocate memory for the internal state */
1458 state = kzalloc(sizeof(struct af9013_state), GFP_KERNEL);
1462 /* setup the state */
1464 memcpy(&state->config, config, sizeof(struct af9013_config));
1466 /* download firmware */
1467 if (state->config.ts_mode != AF9013_TS_USB) {
1468 ret = af9013_download_firmware(state);
1473 /* firmware version */
1474 ret = af9013_rd_regs(state, 0x5103, buf, 4);
1478 dev_info(&state->i2c->dev, "%s: firmware version %d.%d.%d.%d\n",
1479 KBUILD_MODNAME, buf[0], buf[1], buf[2], buf[3]);
1482 for (i = 0; i < sizeof(state->config.gpio); i++) {
1483 ret = af9013_set_gpio(state, i, state->config.gpio[i]);
1488 /* create dvb_frontend */
1489 memcpy(&state->fe.ops, &af9013_ops,
1490 sizeof(struct dvb_frontend_ops));
1491 state->fe.demodulator_priv = state;
1493 INIT_DELAYED_WORK(&state->statistics_work, af9013_statistics_work);
1500 EXPORT_SYMBOL(af9013_attach);
1502 static struct dvb_frontend_ops af9013_ops = {
1503 .delsys = { SYS_DVBT },
1505 .name = "Afatech AF9013",
1506 .frequency_min = 174000000,
1507 .frequency_max = 862000000,
1508 .frequency_stepsize = 250000,
1509 .frequency_tolerance = 0,
1510 .caps = FE_CAN_FEC_1_2 |
1520 FE_CAN_TRANSMISSION_MODE_AUTO |
1521 FE_CAN_GUARD_INTERVAL_AUTO |
1522 FE_CAN_HIERARCHY_AUTO |
1527 .release = af9013_release,
1529 .init = af9013_init,
1530 .sleep = af9013_sleep,
1532 .get_tune_settings = af9013_get_tune_settings,
1533 .set_frontend = af9013_set_frontend,
1534 .get_frontend = af9013_get_frontend,
1536 .read_status = af9013_read_status,
1537 .read_snr = af9013_read_snr,
1538 .read_signal_strength = af9013_read_signal_strength,
1539 .read_ber = af9013_read_ber,
1540 .read_ucblocks = af9013_read_ucblocks,
1542 .i2c_gate_ctrl = af9013_i2c_gate_ctrl,
1545 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1546 MODULE_DESCRIPTION("Afatech AF9013 DVB-T demodulator driver");
1547 MODULE_LICENSE("GPL");
1548 MODULE_FIRMWARE(AF9013_FIRMWARE);