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"
27 /* Max transfer size done by I2C transfer functions */
28 #define MAX_XFER_SIZE 64
31 struct i2c_adapter *i2c;
32 struct dvb_frontend fe;
33 struct af9013_config config;
35 /* tuner/demod RF and IF AGC limits used for signal strength calc */
36 u8 signal_strength_en, rf_50, rf_80, if_50, if_80;
42 fe_status_t fe_status;
43 unsigned long set_frontend_jiffies;
44 unsigned long read_status_jiffies;
47 unsigned int statistics_step:3;
48 struct delayed_work statistics_work;
51 /* write multiple registers */
52 static int af9013_wr_regs_i2c(struct af9013_state *priv, u8 mbox, u16 reg,
53 const u8 *val, int len)
56 u8 buf[MAX_XFER_SIZE];
57 struct i2c_msg msg[1] = {
59 .addr = priv->config.i2c_addr,
66 if (3 + len > sizeof(buf)) {
67 dev_warn(&priv->i2c->dev,
68 "%s: i2c wr reg=%04x: len=%d is too big!\n",
69 KBUILD_MODNAME, reg, len);
73 buf[0] = (reg >> 8) & 0xff;
74 buf[1] = (reg >> 0) & 0xff;
76 memcpy(&buf[3], val, len);
78 ret = i2c_transfer(priv->i2c, msg, 1);
82 dev_warn(&priv->i2c->dev, "%s: i2c wr failed=%d reg=%04x " \
83 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
89 /* read multiple registers */
90 static int af9013_rd_regs_i2c(struct af9013_state *priv, u8 mbox, u16 reg,
95 struct i2c_msg msg[2] = {
97 .addr = priv->config.i2c_addr,
102 .addr = priv->config.i2c_addr,
109 buf[0] = (reg >> 8) & 0xff;
110 buf[1] = (reg >> 0) & 0xff;
113 ret = i2c_transfer(priv->i2c, msg, 2);
117 dev_warn(&priv->i2c->dev, "%s: i2c rd failed=%d reg=%04x " \
118 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
124 /* write multiple registers */
125 static int af9013_wr_regs(struct af9013_state *priv, u16 reg, const u8 *val,
129 u8 mbox = (0 << 7)|(0 << 6)|(1 << 1)|(1 << 0);
131 if ((priv->config.ts_mode == AF9013_TS_USB) &&
132 ((reg & 0xff00) != 0xff00) && ((reg & 0xff00) != 0xae00)) {
133 mbox |= ((len - 1) << 2);
134 ret = af9013_wr_regs_i2c(priv, mbox, reg, val, len);
136 for (i = 0; i < len; i++) {
137 ret = af9013_wr_regs_i2c(priv, mbox, reg+i, val+i, 1);
147 /* read multiple registers */
148 static int af9013_rd_regs(struct af9013_state *priv, u16 reg, u8 *val, int len)
151 u8 mbox = (0 << 7)|(0 << 6)|(1 << 1)|(0 << 0);
153 if ((priv->config.ts_mode == AF9013_TS_USB) &&
154 ((reg & 0xff00) != 0xff00) && ((reg & 0xff00) != 0xae00)) {
155 mbox |= ((len - 1) << 2);
156 ret = af9013_rd_regs_i2c(priv, mbox, reg, val, len);
158 for (i = 0; i < len; i++) {
159 ret = af9013_rd_regs_i2c(priv, mbox, reg+i, val+i, 1);
169 /* write single register */
170 static int af9013_wr_reg(struct af9013_state *priv, u16 reg, u8 val)
172 return af9013_wr_regs(priv, reg, &val, 1);
175 /* read single register */
176 static int af9013_rd_reg(struct af9013_state *priv, u16 reg, u8 *val)
178 return af9013_rd_regs(priv, reg, val, 1);
181 static int af9013_write_ofsm_regs(struct af9013_state *state, u16 reg, u8 *val,
184 u8 mbox = (1 << 7)|(1 << 6)|((len - 1) << 2)|(1 << 1)|(1 << 0);
185 return af9013_wr_regs_i2c(state, mbox, reg, val, len);
188 static int af9013_wr_reg_bits(struct af9013_state *state, u16 reg, int pos,
194 /* no need for read if whole reg is written */
196 ret = af9013_rd_reg(state, reg, &tmp);
200 mask = (0xff >> (8 - len)) << pos;
206 return af9013_wr_reg(state, reg, val);
209 static int af9013_rd_reg_bits(struct af9013_state *state, u16 reg, int pos,
215 ret = af9013_rd_reg(state, reg, &tmp);
220 *val &= (0xff >> (8 - len));
225 static int af9013_set_gpio(struct af9013_state *state, u8 gpio, u8 gpioval)
231 dev_dbg(&state->i2c->dev, "%s: gpio=%d gpioval=%02x\n",
232 __func__, gpio, gpioval);
235 * GPIO0 & GPIO1 0xd735
236 * GPIO2 & GPIO3 0xd736
250 dev_err(&state->i2c->dev, "%s: invalid gpio=%d\n",
251 KBUILD_MODNAME, gpio);
268 ret = af9013_wr_reg_bits(state, addr, pos, 4, gpioval);
274 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
278 static u32 af9013_div(struct af9013_state *state, u32 a, u32 b, u32 x)
282 dev_dbg(&state->i2c->dev, "%s: a=%d b=%d x=%d\n", __func__, a, b, x);
289 for (i = 0; i < x; i++) {
297 r = (c << (u32)x) + r;
299 dev_dbg(&state->i2c->dev, "%s: a=%d b=%d x=%d r=%d r=%x\n",
300 __func__, a, b, x, r, r);
305 static int af9013_power_ctrl(struct af9013_state *state, u8 onoff)
310 dev_dbg(&state->i2c->dev, "%s: onoff=%d\n", __func__, onoff);
313 ret = af9013_wr_reg_bits(state, 0xd417, 4, 1, 1);
317 /* start reset mechanism */
318 ret = af9013_wr_reg(state, 0xaeff, 1);
322 /* wait reset performs */
323 for (i = 0; i < 150; i++) {
324 ret = af9013_rd_reg_bits(state, 0xd417, 1, 1, &tmp);
329 break; /* reset done */
331 usleep_range(5000, 25000);
339 ret = af9013_wr_reg_bits(state, 0xd417, 1, 1, 0);
344 ret = af9013_wr_reg_bits(state, 0xd417, 4, 1, 0);
347 ret = af9013_wr_reg_bits(state, 0xd73a, 3, 1, 0);
350 ret = af9013_wr_reg_bits(state, 0xd73a, 3, 1, 1);
355 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
359 static int af9013_statistics_ber_unc_start(struct dvb_frontend *fe)
361 struct af9013_state *state = fe->demodulator_priv;
364 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
366 /* reset and start BER counter */
367 ret = af9013_wr_reg_bits(state, 0xd391, 4, 1, 1);
373 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
377 static int af9013_statistics_ber_unc_result(struct dvb_frontend *fe)
379 struct af9013_state *state = fe->demodulator_priv;
383 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
385 /* check if error bit count is ready */
386 ret = af9013_rd_reg_bits(state, 0xd391, 4, 1, &buf[0]);
391 dev_dbg(&state->i2c->dev, "%s: not ready\n", __func__);
395 ret = af9013_rd_regs(state, 0xd387, buf, 5);
399 state->ber = (buf[2] << 16) | (buf[1] << 8) | buf[0];
400 state->ucblocks += (buf[4] << 8) | buf[3];
404 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
408 static int af9013_statistics_snr_start(struct dvb_frontend *fe)
410 struct af9013_state *state = fe->demodulator_priv;
413 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
416 ret = af9013_wr_reg_bits(state, 0xd2e1, 3, 1, 1);
422 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
426 static int af9013_statistics_snr_result(struct dvb_frontend *fe)
428 struct af9013_state *state = fe->demodulator_priv;
432 const struct af9013_snr *uninitialized_var(snr_lut);
434 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
436 /* check if SNR ready */
437 ret = af9013_rd_reg_bits(state, 0xd2e1, 3, 1, &tmp);
442 dev_dbg(&state->i2c->dev, "%s: not ready\n", __func__);
447 ret = af9013_rd_regs(state, 0xd2e3, buf, 3);
451 snr_val = (buf[2] << 16) | (buf[1] << 8) | buf[0];
453 /* read current modulation */
454 ret = af9013_rd_reg(state, 0xd3c1, &tmp);
458 switch ((tmp >> 6) & 3) {
460 len = ARRAY_SIZE(qpsk_snr_lut);
461 snr_lut = qpsk_snr_lut;
464 len = ARRAY_SIZE(qam16_snr_lut);
465 snr_lut = qam16_snr_lut;
468 len = ARRAY_SIZE(qam64_snr_lut);
469 snr_lut = qam64_snr_lut;
476 for (i = 0; i < len; i++) {
477 tmp = snr_lut[i].snr;
479 if (snr_val < snr_lut[i].val)
482 state->snr = tmp * 10; /* dB/10 */
486 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
490 static int af9013_statistics_signal_strength(struct dvb_frontend *fe)
492 struct af9013_state *state = fe->demodulator_priv;
494 u8 buf[2], rf_gain, if_gain;
497 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
499 if (!state->signal_strength_en)
502 ret = af9013_rd_regs(state, 0xd07c, buf, 2);
509 signal_strength = (0xffff / \
510 (9 * (state->rf_50 + state->if_50) - \
511 11 * (state->rf_80 + state->if_80))) * \
512 (10 * (rf_gain + if_gain) - \
513 11 * (state->rf_80 + state->if_80));
514 if (signal_strength < 0)
516 else if (signal_strength > 0xffff)
517 signal_strength = 0xffff;
519 state->signal_strength = signal_strength;
523 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
527 static void af9013_statistics_work(struct work_struct *work)
529 struct af9013_state *state = container_of(work,
530 struct af9013_state, statistics_work.work);
531 unsigned int next_msec;
533 /* update only signal strength when demod is not locked */
534 if (!(state->fe_status & FE_HAS_LOCK)) {
535 state->statistics_step = 0;
540 switch (state->statistics_step) {
542 state->statistics_step = 0;
544 af9013_statistics_signal_strength(&state->fe);
545 state->statistics_step++;
549 af9013_statistics_snr_start(&state->fe);
550 state->statistics_step++;
554 af9013_statistics_ber_unc_start(&state->fe);
555 state->statistics_step++;
559 af9013_statistics_snr_result(&state->fe);
560 state->statistics_step++;
564 af9013_statistics_ber_unc_result(&state->fe);
565 state->statistics_step++;
570 schedule_delayed_work(&state->statistics_work,
571 msecs_to_jiffies(next_msec));
574 static int af9013_get_tune_settings(struct dvb_frontend *fe,
575 struct dvb_frontend_tune_settings *fesettings)
577 fesettings->min_delay_ms = 800;
578 fesettings->step_size = 0;
579 fesettings->max_drift = 0;
584 static int af9013_set_frontend(struct dvb_frontend *fe)
586 struct af9013_state *state = fe->demodulator_priv;
587 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
588 int ret, i, sampling_freq;
589 bool auto_mode, spec_inv;
591 u32 if_frequency, freq_cw;
593 dev_dbg(&state->i2c->dev, "%s: frequency=%d bandwidth_hz=%d\n",
594 __func__, c->frequency, c->bandwidth_hz);
597 if (fe->ops.tuner_ops.set_params)
598 fe->ops.tuner_ops.set_params(fe);
600 /* program CFOE coefficients */
601 if (c->bandwidth_hz != state->bandwidth_hz) {
602 for (i = 0; i < ARRAY_SIZE(coeff_lut); i++) {
603 if (coeff_lut[i].clock == state->config.clock &&
604 coeff_lut[i].bandwidth_hz == c->bandwidth_hz) {
609 ret = af9013_wr_regs(state, 0xae00, coeff_lut[i].val,
610 sizeof(coeff_lut[i].val));
613 /* program frequency control */
614 if (c->bandwidth_hz != state->bandwidth_hz || state->first_tune) {
615 /* get used IF frequency */
616 if (fe->ops.tuner_ops.get_if_frequency)
617 fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency);
619 if_frequency = state->config.if_frequency;
621 dev_dbg(&state->i2c->dev, "%s: if_frequency=%d\n",
622 __func__, if_frequency);
624 sampling_freq = if_frequency;
626 while (sampling_freq > (state->config.clock / 2))
627 sampling_freq -= state->config.clock;
629 if (sampling_freq < 0) {
631 spec_inv = state->config.spec_inv;
633 spec_inv = !state->config.spec_inv;
636 freq_cw = af9013_div(state, sampling_freq, state->config.clock,
640 freq_cw = 0x800000 - freq_cw;
642 buf[0] = (freq_cw >> 0) & 0xff;
643 buf[1] = (freq_cw >> 8) & 0xff;
644 buf[2] = (freq_cw >> 16) & 0x7f;
646 freq_cw = 0x800000 - freq_cw;
648 buf[3] = (freq_cw >> 0) & 0xff;
649 buf[4] = (freq_cw >> 8) & 0xff;
650 buf[5] = (freq_cw >> 16) & 0x7f;
652 ret = af9013_wr_regs(state, 0xd140, buf, 3);
656 ret = af9013_wr_regs(state, 0x9be7, buf, 6);
661 /* clear TPS lock flag */
662 ret = af9013_wr_reg_bits(state, 0xd330, 3, 1, 1);
666 /* clear MPEG2 lock flag */
667 ret = af9013_wr_reg_bits(state, 0xd507, 6, 1, 0);
671 /* empty channel function */
672 ret = af9013_wr_reg_bits(state, 0x9bfe, 0, 1, 0);
676 /* empty DVB-T channel function */
677 ret = af9013_wr_reg_bits(state, 0x9bc2, 0, 1, 0);
681 /* transmission parameters */
685 switch (c->transmission_mode) {
686 case TRANSMISSION_MODE_AUTO:
689 case TRANSMISSION_MODE_2K:
691 case TRANSMISSION_MODE_8K:
695 dev_dbg(&state->i2c->dev, "%s: invalid transmission_mode\n",
700 switch (c->guard_interval) {
701 case GUARD_INTERVAL_AUTO:
704 case GUARD_INTERVAL_1_32:
706 case GUARD_INTERVAL_1_16:
709 case GUARD_INTERVAL_1_8:
712 case GUARD_INTERVAL_1_4:
716 dev_dbg(&state->i2c->dev, "%s: invalid guard_interval\n",
721 switch (c->hierarchy) {
737 dev_dbg(&state->i2c->dev, "%s: invalid hierarchy\n", __func__);
741 switch (c->modulation) {
754 dev_dbg(&state->i2c->dev, "%s: invalid modulation\n", __func__);
758 /* Use HP. How and which case we can switch to LP? */
761 switch (c->code_rate_HP) {
780 dev_dbg(&state->i2c->dev, "%s: invalid code_rate_HP\n",
785 switch (c->code_rate_LP) {
806 dev_dbg(&state->i2c->dev, "%s: invalid code_rate_LP\n",
811 switch (c->bandwidth_hz) {
821 dev_dbg(&state->i2c->dev, "%s: invalid bandwidth_hz\n",
827 ret = af9013_wr_regs(state, 0xd3c0, buf, 3);
832 /* clear easy mode flag */
833 ret = af9013_wr_reg(state, 0xaefd, 0);
837 dev_dbg(&state->i2c->dev, "%s: auto params\n", __func__);
839 /* set easy mode flag */
840 ret = af9013_wr_reg(state, 0xaefd, 1);
844 ret = af9013_wr_reg(state, 0xaefe, 0);
848 dev_dbg(&state->i2c->dev, "%s: manual params\n", __func__);
852 ret = af9013_wr_reg(state, 0xffff, 0);
856 state->bandwidth_hz = c->bandwidth_hz;
857 state->set_frontend_jiffies = jiffies;
858 state->first_tune = false;
862 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
866 static int af9013_get_frontend(struct dvb_frontend *fe)
868 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
869 struct af9013_state *state = fe->demodulator_priv;
873 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
875 ret = af9013_rd_regs(state, 0xd3c0, buf, 3);
879 switch ((buf[1] >> 6) & 3) {
881 c->modulation = QPSK;
884 c->modulation = QAM_16;
887 c->modulation = QAM_64;
891 switch ((buf[0] >> 0) & 3) {
893 c->transmission_mode = TRANSMISSION_MODE_2K;
896 c->transmission_mode = TRANSMISSION_MODE_8K;
899 switch ((buf[0] >> 2) & 3) {
901 c->guard_interval = GUARD_INTERVAL_1_32;
904 c->guard_interval = GUARD_INTERVAL_1_16;
907 c->guard_interval = GUARD_INTERVAL_1_8;
910 c->guard_interval = GUARD_INTERVAL_1_4;
914 switch ((buf[0] >> 4) & 7) {
916 c->hierarchy = HIERARCHY_NONE;
919 c->hierarchy = HIERARCHY_1;
922 c->hierarchy = HIERARCHY_2;
925 c->hierarchy = HIERARCHY_4;
929 switch ((buf[2] >> 0) & 7) {
931 c->code_rate_HP = FEC_1_2;
934 c->code_rate_HP = FEC_2_3;
937 c->code_rate_HP = FEC_3_4;
940 c->code_rate_HP = FEC_5_6;
943 c->code_rate_HP = FEC_7_8;
947 switch ((buf[2] >> 3) & 7) {
949 c->code_rate_LP = FEC_1_2;
952 c->code_rate_LP = FEC_2_3;
955 c->code_rate_LP = FEC_3_4;
958 c->code_rate_LP = FEC_5_6;
961 c->code_rate_LP = FEC_7_8;
965 switch ((buf[1] >> 2) & 3) {
967 c->bandwidth_hz = 6000000;
970 c->bandwidth_hz = 7000000;
973 c->bandwidth_hz = 8000000;
979 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
983 static int af9013_read_status(struct dvb_frontend *fe, fe_status_t *status)
985 struct af9013_state *state = fe->demodulator_priv;
990 * Return status from the cache if it is younger than 2000ms with the
991 * exception of last tune is done during 4000ms.
993 if (time_is_after_jiffies(
994 state->read_status_jiffies + msecs_to_jiffies(2000)) &&
995 time_is_before_jiffies(
996 state->set_frontend_jiffies + msecs_to_jiffies(4000))
998 *status = state->fe_status;
1005 ret = af9013_rd_reg_bits(state, 0xd507, 6, 1, &tmp);
1010 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI |
1011 FE_HAS_SYNC | FE_HAS_LOCK;
1015 ret = af9013_rd_reg_bits(state, 0xd330, 3, 1, &tmp);
1020 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
1024 state->fe_status = *status;
1025 state->read_status_jiffies = jiffies;
1029 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
1033 static int af9013_read_snr(struct dvb_frontend *fe, u16 *snr)
1035 struct af9013_state *state = fe->demodulator_priv;
1040 static int af9013_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
1042 struct af9013_state *state = fe->demodulator_priv;
1043 *strength = state->signal_strength;
1047 static int af9013_read_ber(struct dvb_frontend *fe, u32 *ber)
1049 struct af9013_state *state = fe->demodulator_priv;
1054 static int af9013_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1056 struct af9013_state *state = fe->demodulator_priv;
1057 *ucblocks = state->ucblocks;
1061 static int af9013_init(struct dvb_frontend *fe)
1063 struct af9013_state *state = fe->demodulator_priv;
1067 const struct af9013_reg_bit *init;
1069 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
1072 ret = af9013_power_ctrl(state, 1);
1077 ret = af9013_wr_reg(state, 0xd73a, 0xa4);
1081 /* write API version to firmware */
1082 ret = af9013_wr_regs(state, 0x9bf2, state->config.api_version, 4);
1086 /* program ADC control */
1087 switch (state->config.clock) {
1088 case 28800000: /* 28.800 MHz */
1091 case 20480000: /* 20.480 MHz */
1094 case 28000000: /* 28.000 MHz */
1097 case 25000000: /* 25.000 MHz */
1101 dev_err(&state->i2c->dev, "%s: invalid clock\n",
1106 adc_cw = af9013_div(state, state->config.clock, 1000000ul, 19);
1107 buf[0] = (adc_cw >> 0) & 0xff;
1108 buf[1] = (adc_cw >> 8) & 0xff;
1109 buf[2] = (adc_cw >> 16) & 0xff;
1111 ret = af9013_wr_regs(state, 0xd180, buf, 3);
1115 ret = af9013_wr_reg_bits(state, 0x9bd2, 0, 4, tmp);
1119 /* set I2C master clock */
1120 ret = af9013_wr_reg(state, 0xd416, 0x14);
1125 ret = af9013_wr_reg_bits(state, 0xd700, 1, 1, 1);
1129 /* set no trigger */
1130 ret = af9013_wr_reg_bits(state, 0xd700, 2, 1, 0);
1134 /* set read-update bit for constellation */
1135 ret = af9013_wr_reg_bits(state, 0xd371, 1, 1, 1);
1139 /* settings for mp2if */
1140 if (state->config.ts_mode == AF9013_TS_USB) {
1141 /* AF9015 split PSB to 1.5k + 0.5k */
1142 ret = af9013_wr_reg_bits(state, 0xd50b, 2, 1, 1);
1146 /* AF9013 change the output bit to data7 */
1147 ret = af9013_wr_reg_bits(state, 0xd500, 3, 1, 1);
1151 /* AF9013 set mpeg to full speed */
1152 ret = af9013_wr_reg_bits(state, 0xd502, 4, 1, 1);
1157 ret = af9013_wr_reg_bits(state, 0xd520, 4, 1, 1);
1161 /* load OFSM settings */
1162 dev_dbg(&state->i2c->dev, "%s: load ofsm settings\n", __func__);
1163 len = ARRAY_SIZE(ofsm_init);
1165 for (i = 0; i < len; i++) {
1166 ret = af9013_wr_reg_bits(state, init[i].addr, init[i].pos,
1167 init[i].len, init[i].val);
1172 /* load tuner specific settings */
1173 dev_dbg(&state->i2c->dev, "%s: load tuner specific settings\n",
1175 switch (state->config.tuner) {
1176 case AF9013_TUNER_MXL5003D:
1177 len = ARRAY_SIZE(tuner_init_mxl5003d);
1178 init = tuner_init_mxl5003d;
1180 case AF9013_TUNER_MXL5005D:
1181 case AF9013_TUNER_MXL5005R:
1182 case AF9013_TUNER_MXL5007T:
1183 len = ARRAY_SIZE(tuner_init_mxl5005);
1184 init = tuner_init_mxl5005;
1186 case AF9013_TUNER_ENV77H11D5:
1187 len = ARRAY_SIZE(tuner_init_env77h11d5);
1188 init = tuner_init_env77h11d5;
1190 case AF9013_TUNER_MT2060:
1191 len = ARRAY_SIZE(tuner_init_mt2060);
1192 init = tuner_init_mt2060;
1194 case AF9013_TUNER_MC44S803:
1195 len = ARRAY_SIZE(tuner_init_mc44s803);
1196 init = tuner_init_mc44s803;
1198 case AF9013_TUNER_QT1010:
1199 case AF9013_TUNER_QT1010A:
1200 len = ARRAY_SIZE(tuner_init_qt1010);
1201 init = tuner_init_qt1010;
1203 case AF9013_TUNER_MT2060_2:
1204 len = ARRAY_SIZE(tuner_init_mt2060_2);
1205 init = tuner_init_mt2060_2;
1207 case AF9013_TUNER_TDA18271:
1208 case AF9013_TUNER_TDA18218:
1209 len = ARRAY_SIZE(tuner_init_tda18271);
1210 init = tuner_init_tda18271;
1212 case AF9013_TUNER_UNKNOWN:
1214 len = ARRAY_SIZE(tuner_init_unknown);
1215 init = tuner_init_unknown;
1219 for (i = 0; i < len; i++) {
1220 ret = af9013_wr_reg_bits(state, init[i].addr, init[i].pos,
1221 init[i].len, init[i].val);
1227 ret = af9013_wr_reg_bits(state, 0xd500, 1, 2, state->config.ts_mode);
1231 /* enable lock led */
1232 ret = af9013_wr_reg_bits(state, 0xd730, 0, 1, 1);
1236 /* check if we support signal strength */
1237 if (!state->signal_strength_en) {
1238 ret = af9013_rd_reg_bits(state, 0x9bee, 0, 1,
1239 &state->signal_strength_en);
1244 /* read values needed for signal strength calculation */
1245 if (state->signal_strength_en && !state->rf_50) {
1246 ret = af9013_rd_reg(state, 0x9bbd, &state->rf_50);
1250 ret = af9013_rd_reg(state, 0x9bd0, &state->rf_80);
1254 ret = af9013_rd_reg(state, 0x9be2, &state->if_50);
1258 ret = af9013_rd_reg(state, 0x9be4, &state->if_80);
1264 ret = af9013_wr_reg(state, 0xd2e2, 1);
1269 buf[0] = (10000 >> 0) & 0xff;
1270 buf[1] = (10000 >> 8) & 0xff;
1271 ret = af9013_wr_regs(state, 0xd385, buf, 2);
1275 /* enable FEC monitor */
1276 ret = af9013_wr_reg_bits(state, 0xd392, 1, 1, 1);
1280 state->first_tune = true;
1281 schedule_delayed_work(&state->statistics_work, msecs_to_jiffies(400));
1285 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
1289 static int af9013_sleep(struct dvb_frontend *fe)
1291 struct af9013_state *state = fe->demodulator_priv;
1294 dev_dbg(&state->i2c->dev, "%s:\n", __func__);
1296 /* stop statistics polling */
1297 cancel_delayed_work_sync(&state->statistics_work);
1299 /* disable lock led */
1300 ret = af9013_wr_reg_bits(state, 0xd730, 0, 1, 0);
1305 ret = af9013_power_ctrl(state, 0);
1311 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
1315 static int af9013_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
1318 struct af9013_state *state = fe->demodulator_priv;
1320 dev_dbg(&state->i2c->dev, "%s: enable=%d\n", __func__, enable);
1322 /* gate already open or close */
1323 if (state->i2c_gate_state == enable)
1326 if (state->config.ts_mode == AF9013_TS_USB)
1327 ret = af9013_wr_reg_bits(state, 0xd417, 3, 1, enable);
1329 ret = af9013_wr_reg_bits(state, 0xd607, 2, 1, enable);
1333 state->i2c_gate_state = enable;
1337 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
1341 static void af9013_release(struct dvb_frontend *fe)
1343 struct af9013_state *state = fe->demodulator_priv;
1347 static struct dvb_frontend_ops af9013_ops;
1349 static int af9013_download_firmware(struct af9013_state *state)
1351 int i, len, remaining, ret;
1352 const struct firmware *fw;
1356 u8 *fw_file = AF9013_FIRMWARE;
1359 /* check whether firmware is already running */
1360 ret = af9013_rd_reg(state, 0x98be, &val);
1364 dev_dbg(&state->i2c->dev, "%s: firmware status=%02x\n",
1367 if (val == 0x0c) /* fw is running, no need for download */
1370 dev_info(&state->i2c->dev, "%s: found a '%s' in cold state, will try " \
1371 "to load a firmware\n",
1372 KBUILD_MODNAME, af9013_ops.info.name);
1374 /* request the firmware, this will block and timeout */
1375 ret = request_firmware(&fw, fw_file, state->i2c->dev.parent);
1377 dev_info(&state->i2c->dev, "%s: did not find the firmware " \
1378 "file. (%s) Please see linux/Documentation/dvb/ for " \
1379 "more details on firmware-problems. (%d)\n",
1380 KBUILD_MODNAME, fw_file, ret);
1384 dev_info(&state->i2c->dev, "%s: downloading firmware from file '%s'\n",
1385 KBUILD_MODNAME, fw_file);
1388 for (i = 0; i < fw->size; i++)
1389 checksum += fw->data[i];
1391 fw_params[0] = checksum >> 8;
1392 fw_params[1] = checksum & 0xff;
1393 fw_params[2] = fw->size >> 8;
1394 fw_params[3] = fw->size & 0xff;
1396 /* write fw checksum & size */
1397 ret = af9013_write_ofsm_regs(state, 0x50fc,
1398 fw_params, sizeof(fw_params));
1402 #define FW_ADDR 0x5100 /* firmware start address */
1403 #define LEN_MAX 16 /* max packet size */
1404 for (remaining = fw->size; remaining > 0; remaining -= LEN_MAX) {
1409 ret = af9013_write_ofsm_regs(state,
1410 FW_ADDR + fw->size - remaining,
1411 (u8 *) &fw->data[fw->size - remaining], len);
1413 dev_err(&state->i2c->dev,
1414 "%s: firmware download failed=%d\n",
1415 KBUILD_MODNAME, ret);
1420 /* request boot firmware */
1421 ret = af9013_wr_reg(state, 0xe205, 1);
1425 for (i = 0; i < 15; i++) {
1428 /* check firmware status */
1429 ret = af9013_rd_reg(state, 0x98be, &val);
1433 dev_dbg(&state->i2c->dev, "%s: firmware status=%02x\n",
1436 if (val == 0x0c || val == 0x04) /* success or fail */
1441 dev_err(&state->i2c->dev, "%s: firmware did not run\n",
1444 } else if (val != 0x0c) {
1445 dev_err(&state->i2c->dev, "%s: firmware boot timeout\n",
1451 release_firmware(fw);
1455 dev_info(&state->i2c->dev, "%s: found a '%s' in warm state\n",
1456 KBUILD_MODNAME, af9013_ops.info.name);
1460 struct dvb_frontend *af9013_attach(const struct af9013_config *config,
1461 struct i2c_adapter *i2c)
1464 struct af9013_state *state = NULL;
1467 /* allocate memory for the internal state */
1468 state = kzalloc(sizeof(struct af9013_state), GFP_KERNEL);
1472 /* setup the state */
1474 memcpy(&state->config, config, sizeof(struct af9013_config));
1476 /* download firmware */
1477 if (state->config.ts_mode != AF9013_TS_USB) {
1478 ret = af9013_download_firmware(state);
1483 /* firmware version */
1484 ret = af9013_rd_regs(state, 0x5103, buf, 4);
1488 dev_info(&state->i2c->dev, "%s: firmware version %d.%d.%d.%d\n",
1489 KBUILD_MODNAME, buf[0], buf[1], buf[2], buf[3]);
1492 for (i = 0; i < sizeof(state->config.gpio); i++) {
1493 ret = af9013_set_gpio(state, i, state->config.gpio[i]);
1498 /* create dvb_frontend */
1499 memcpy(&state->fe.ops, &af9013_ops,
1500 sizeof(struct dvb_frontend_ops));
1501 state->fe.demodulator_priv = state;
1503 INIT_DELAYED_WORK(&state->statistics_work, af9013_statistics_work);
1510 EXPORT_SYMBOL(af9013_attach);
1512 static struct dvb_frontend_ops af9013_ops = {
1513 .delsys = { SYS_DVBT },
1515 .name = "Afatech AF9013",
1516 .frequency_min = 174000000,
1517 .frequency_max = 862000000,
1518 .frequency_stepsize = 250000,
1519 .frequency_tolerance = 0,
1520 .caps = FE_CAN_FEC_1_2 |
1530 FE_CAN_TRANSMISSION_MODE_AUTO |
1531 FE_CAN_GUARD_INTERVAL_AUTO |
1532 FE_CAN_HIERARCHY_AUTO |
1537 .release = af9013_release,
1539 .init = af9013_init,
1540 .sleep = af9013_sleep,
1542 .get_tune_settings = af9013_get_tune_settings,
1543 .set_frontend = af9013_set_frontend,
1544 .get_frontend = af9013_get_frontend,
1546 .read_status = af9013_read_status,
1547 .read_snr = af9013_read_snr,
1548 .read_signal_strength = af9013_read_signal_strength,
1549 .read_ber = af9013_read_ber,
1550 .read_ucblocks = af9013_read_ucblocks,
1552 .i2c_gate_ctrl = af9013_i2c_gate_ctrl,
1555 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1556 MODULE_DESCRIPTION("Afatech AF9013 DVB-T demodulator driver");
1557 MODULE_LICENSE("GPL");
1558 MODULE_FIRMWARE(AF9013_FIRMWARE);