2 * Montage Technology M88DS3103/M88RS6000 demodulator driver
4 * Copyright (C) 2013 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.
17 #include "m88ds3103_priv.h"
19 static struct dvb_frontend_ops m88ds3103_ops
;
21 /* write single register with mask */
22 static int m88ds3103_update_bits(struct m88ds3103_dev
*dev
,
23 u8 reg
, u8 mask
, u8 val
)
28 /* no need for read if whole reg is written */
30 ret
= regmap_bulk_read(dev
->regmap
, reg
, &tmp
, 1);
39 return regmap_bulk_write(dev
->regmap
, reg
, &val
, 1);
42 /* write reg val table using reg addr auto increment */
43 static int m88ds3103_wr_reg_val_tab(struct m88ds3103_dev
*dev
,
44 const struct m88ds3103_reg_val
*tab
, int tab_len
)
46 struct i2c_client
*client
= dev
->client
;
50 dev_dbg(&client
->dev
, "tab_len=%d\n", tab_len
);
57 for (i
= 0, j
= 0; i
< tab_len
; i
++, j
++) {
60 if (i
== tab_len
- 1 || tab
[i
].reg
!= tab
[i
+ 1].reg
- 1 ||
61 !((j
+ 1) % (dev
->cfg
->i2c_wr_max
- 1))) {
62 ret
= regmap_bulk_write(dev
->regmap
, tab
[i
].reg
- j
, buf
, j
+ 1);
72 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
77 * Get the demodulator AGC PWM voltage setting supplied to the tuner.
79 int m88ds3103_get_agc_pwm(struct dvb_frontend
*fe
, u8
*_agc_pwm
)
81 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
85 ret
= regmap_read(dev
->regmap
, 0x3f, &tmp
);
90 EXPORT_SYMBOL(m88ds3103_get_agc_pwm
);
92 static int m88ds3103_read_status(struct dvb_frontend
*fe
,
93 enum fe_status
*status
)
95 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
96 struct i2c_client
*client
= dev
->client
;
97 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
109 switch (c
->delivery_system
) {
111 ret
= regmap_read(dev
->regmap
, 0xd1, &utmp
);
115 if ((utmp
& 0x07) == 0x07)
116 *status
= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
117 FE_HAS_VITERBI
| FE_HAS_SYNC
|
121 ret
= regmap_read(dev
->regmap
, 0x0d, &utmp
);
125 if ((utmp
& 0x8f) == 0x8f)
126 *status
= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
127 FE_HAS_VITERBI
| FE_HAS_SYNC
|
131 dev_dbg(&client
->dev
, "invalid delivery_system\n");
136 dev
->fe_status
= *status
;
137 dev_dbg(&client
->dev
, "lock=%02x status=%02x\n", utmp
, *status
);
140 if (dev
->fe_status
& FE_HAS_VITERBI
) {
141 unsigned int cnr
, noise
, signal
, noise_tot
, signal_tot
;
144 /* more iterations for more accurate estimation */
145 #define M88DS3103_SNR_ITERATIONS 3
147 switch (c
->delivery_system
) {
151 for (i
= 0; i
< M88DS3103_SNR_ITERATIONS
; i
++) {
152 ret
= regmap_read(dev
->regmap
, 0xff, &utmp
);
159 /* use of single register limits max value to 15 dB */
160 /* SNR(X) dB = 10 * ln(X) / ln(10) dB */
161 itmp
= DIV_ROUND_CLOSEST(itmp
, 8 * M88DS3103_SNR_ITERATIONS
);
163 cnr
= div_u64((u64
) 10000 * intlog2(itmp
), intlog2(10));
169 for (i
= 0; i
< M88DS3103_SNR_ITERATIONS
; i
++) {
170 ret
= regmap_bulk_read(dev
->regmap
, 0x8c, buf
, 3);
174 noise
= buf
[1] << 6; /* [13:6] */
175 noise
|= buf
[0] & 0x3f; /* [5:0] */
177 signal
= buf
[2] * buf
[2];
181 signal_tot
+= signal
;
184 noise
= noise_tot
/ M88DS3103_SNR_ITERATIONS
;
185 signal
= signal_tot
/ M88DS3103_SNR_ITERATIONS
;
187 /* SNR(X) dB = 10 * log10(X) dB */
188 if (signal
> noise
) {
189 itmp
= signal
/ noise
;
190 cnr
= div_u64((u64
) 10000 * intlog10(itmp
), (1 << 24));
194 dev_dbg(&client
->dev
, "invalid delivery_system\n");
200 c
->cnr
.stat
[0].scale
= FE_SCALE_DECIBEL
;
201 c
->cnr
.stat
[0].svalue
= cnr
;
203 c
->cnr
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
206 c
->cnr
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
210 if (dev
->fe_status
& FE_HAS_LOCK
) {
211 unsigned int utmp
, post_bit_error
, post_bit_count
;
213 switch (c
->delivery_system
) {
215 ret
= regmap_write(dev
->regmap
, 0xf9, 0x04);
219 ret
= regmap_read(dev
->regmap
, 0xf8, &utmp
);
223 /* measurement ready? */
224 if (!(utmp
& 0x10)) {
225 ret
= regmap_bulk_read(dev
->regmap
, 0xf6, buf
, 2);
229 post_bit_error
= buf
[1] << 8 | buf
[0] << 0;
230 post_bit_count
= 0x800000;
231 dev
->post_bit_error
+= post_bit_error
;
232 dev
->post_bit_count
+= post_bit_count
;
233 dev
->dvbv3_ber
= post_bit_error
;
235 /* restart measurement */
237 ret
= regmap_write(dev
->regmap
, 0xf8, utmp
);
243 ret
= regmap_bulk_read(dev
->regmap
, 0xd5, buf
, 3);
247 utmp
= buf
[2] << 16 | buf
[1] << 8 | buf
[0] << 0;
251 ret
= regmap_bulk_read(dev
->regmap
, 0xf7, buf
, 2);
255 post_bit_error
= buf
[1] << 8 | buf
[0] << 0;
256 post_bit_count
= 32 * utmp
; /* TODO: FEC */
257 dev
->post_bit_error
+= post_bit_error
;
258 dev
->post_bit_count
+= post_bit_count
;
259 dev
->dvbv3_ber
= post_bit_error
;
261 /* restart measurement */
262 ret
= regmap_write(dev
->regmap
, 0xd1, 0x01);
266 ret
= regmap_write(dev
->regmap
, 0xf9, 0x01);
270 ret
= regmap_write(dev
->regmap
, 0xf9, 0x00);
274 ret
= regmap_write(dev
->regmap
, 0xd1, 0x00);
280 dev_dbg(&client
->dev
, "invalid delivery_system\n");
285 c
->post_bit_error
.stat
[0].scale
= FE_SCALE_COUNTER
;
286 c
->post_bit_error
.stat
[0].uvalue
= dev
->post_bit_error
;
287 c
->post_bit_count
.stat
[0].scale
= FE_SCALE_COUNTER
;
288 c
->post_bit_count
.stat
[0].uvalue
= dev
->post_bit_count
;
290 c
->post_bit_error
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
291 c
->post_bit_count
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
296 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
300 static int m88ds3103_set_frontend(struct dvb_frontend
*fe
)
302 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
303 struct i2c_client
*client
= dev
->client
;
304 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
306 const struct m88ds3103_reg_val
*init
;
307 u8 u8tmp
, u8tmp1
= 0, u8tmp2
= 0; /* silence compiler warning */
309 u16 u16tmp
, divide_ratio
= 0;
310 u32 tuner_frequency
, target_mclk
;
313 dev_dbg(&client
->dev
,
314 "delivery_system=%d modulation=%d frequency=%u symbol_rate=%d inversion=%d pilot=%d rolloff=%d\n",
315 c
->delivery_system
, c
->modulation
, c
->frequency
, c
->symbol_rate
,
316 c
->inversion
, c
->pilot
, c
->rolloff
);
324 ret
= regmap_write(dev
->regmap
, 0x07, 0x80);
328 ret
= regmap_write(dev
->regmap
, 0x07, 0x00);
332 /* Disable demod clock path */
333 if (dev
->chip_id
== M88RS6000_CHIP_ID
) {
334 ret
= regmap_write(dev
->regmap
, 0x06, 0xe0);
340 if (fe
->ops
.tuner_ops
.set_params
) {
341 ret
= fe
->ops
.tuner_ops
.set_params(fe
);
346 if (fe
->ops
.tuner_ops
.get_frequency
) {
347 ret
= fe
->ops
.tuner_ops
.get_frequency(fe
, &tuner_frequency
);
352 * Use nominal target frequency as tuner driver does not provide
353 * actual frequency used. Carrier offset calculation is not
356 tuner_frequency
= c
->frequency
;
359 /* select M88RS6000 demod main mclk and ts mclk from tuner die. */
360 if (dev
->chip_id
== M88RS6000_CHIP_ID
) {
361 if (c
->symbol_rate
> 45010000)
362 dev
->mclk_khz
= 110250;
364 dev
->mclk_khz
= 96000;
366 if (c
->delivery_system
== SYS_DVBS
)
369 target_mclk
= 144000;
371 /* Enable demod clock path */
372 ret
= regmap_write(dev
->regmap
, 0x06, 0x00);
375 usleep_range(10000, 20000);
377 /* set M88DS3103 mclk and ts mclk. */
378 dev
->mclk_khz
= 96000;
380 switch (dev
->cfg
->ts_mode
) {
381 case M88DS3103_TS_SERIAL
:
382 case M88DS3103_TS_SERIAL_D7
:
383 target_mclk
= dev
->cfg
->ts_clk
;
385 case M88DS3103_TS_PARALLEL
:
386 case M88DS3103_TS_CI
:
387 if (c
->delivery_system
== SYS_DVBS
)
390 if (c
->symbol_rate
< 18000000)
392 else if (c
->symbol_rate
< 28000000)
393 target_mclk
= 144000;
395 target_mclk
= 192000;
399 dev_dbg(&client
->dev
, "invalid ts_mode\n");
404 switch (target_mclk
) {
406 u8tmp1
= 0x02; /* 0b10 */
407 u8tmp2
= 0x01; /* 0b01 */
410 u8tmp1
= 0x00; /* 0b00 */
411 u8tmp2
= 0x01; /* 0b01 */
414 u8tmp1
= 0x03; /* 0b11 */
415 u8tmp2
= 0x00; /* 0b00 */
418 ret
= m88ds3103_update_bits(dev
, 0x22, 0xc0, u8tmp1
<< 6);
421 ret
= m88ds3103_update_bits(dev
, 0x24, 0xc0, u8tmp2
<< 6);
426 ret
= regmap_write(dev
->regmap
, 0xb2, 0x01);
430 ret
= regmap_write(dev
->regmap
, 0x00, 0x01);
434 switch (c
->delivery_system
) {
436 if (dev
->chip_id
== M88RS6000_CHIP_ID
) {
437 len
= ARRAY_SIZE(m88rs6000_dvbs_init_reg_vals
);
438 init
= m88rs6000_dvbs_init_reg_vals
;
440 len
= ARRAY_SIZE(m88ds3103_dvbs_init_reg_vals
);
441 init
= m88ds3103_dvbs_init_reg_vals
;
445 if (dev
->chip_id
== M88RS6000_CHIP_ID
) {
446 len
= ARRAY_SIZE(m88rs6000_dvbs2_init_reg_vals
);
447 init
= m88rs6000_dvbs2_init_reg_vals
;
449 len
= ARRAY_SIZE(m88ds3103_dvbs2_init_reg_vals
);
450 init
= m88ds3103_dvbs2_init_reg_vals
;
454 dev_dbg(&client
->dev
, "invalid delivery_system\n");
459 /* program init table */
460 if (c
->delivery_system
!= dev
->delivery_system
) {
461 ret
= m88ds3103_wr_reg_val_tab(dev
, init
, len
);
466 if (dev
->chip_id
== M88RS6000_CHIP_ID
) {
467 if ((c
->delivery_system
== SYS_DVBS2
)
468 && ((c
->symbol_rate
/ 1000) <= 5000)) {
469 ret
= regmap_write(dev
->regmap
, 0xc0, 0x04);
475 ret
= regmap_bulk_write(dev
->regmap
, 0x8a, buf
, 3);
479 ret
= m88ds3103_update_bits(dev
, 0x9d, 0x08, 0x08);
482 ret
= regmap_write(dev
->regmap
, 0xf1, 0x01);
485 ret
= m88ds3103_update_bits(dev
, 0x30, 0x80, 0x80);
490 switch (dev
->cfg
->ts_mode
) {
491 case M88DS3103_TS_SERIAL
:
495 case M88DS3103_TS_SERIAL_D7
:
499 case M88DS3103_TS_PARALLEL
:
502 case M88DS3103_TS_CI
:
506 dev_dbg(&client
->dev
, "invalid ts_mode\n");
511 if (dev
->cfg
->ts_clk_pol
)
515 ret
= regmap_write(dev
->regmap
, 0xfd, u8tmp
);
519 switch (dev
->cfg
->ts_mode
) {
520 case M88DS3103_TS_SERIAL
:
521 case M88DS3103_TS_SERIAL_D7
:
522 ret
= m88ds3103_update_bits(dev
, 0x29, 0x20, u8tmp1
);
529 if (dev
->cfg
->ts_clk
) {
530 divide_ratio
= DIV_ROUND_UP(target_mclk
, dev
->cfg
->ts_clk
);
531 u8tmp1
= divide_ratio
/ 2;
532 u8tmp2
= DIV_ROUND_UP(divide_ratio
, 2);
536 dev_dbg(&client
->dev
,
537 "target_mclk=%d ts_clk=%d divide_ratio=%d\n",
538 target_mclk
, dev
->cfg
->ts_clk
, divide_ratio
);
542 /* u8tmp1[5:2] => fe[3:0], u8tmp1[1:0] => ea[7:6] */
544 /* u8tmp2[5:0] => ea[5:0] */
547 ret
= regmap_bulk_read(dev
->regmap
, 0xfe, &u8tmp
, 1);
551 u8tmp
= ((u8tmp
& 0xf0) << 0) | u8tmp1
>> 2;
552 ret
= regmap_write(dev
->regmap
, 0xfe, u8tmp
);
556 u8tmp
= ((u8tmp1
& 0x03) << 6) | u8tmp2
>> 0;
557 ret
= regmap_write(dev
->regmap
, 0xea, u8tmp
);
561 if (c
->symbol_rate
<= 3000000)
563 else if (c
->symbol_rate
<= 10000000)
568 ret
= regmap_write(dev
->regmap
, 0xc3, 0x08);
572 ret
= regmap_write(dev
->regmap
, 0xc8, u8tmp
);
576 ret
= regmap_write(dev
->regmap
, 0xc4, 0x08);
580 ret
= regmap_write(dev
->regmap
, 0xc7, 0x00);
584 u16tmp
= DIV_ROUND_CLOSEST((c
->symbol_rate
/ 1000) << 15, dev
->mclk_khz
/ 2);
585 buf
[0] = (u16tmp
>> 0) & 0xff;
586 buf
[1] = (u16tmp
>> 8) & 0xff;
587 ret
= regmap_bulk_write(dev
->regmap
, 0x61, buf
, 2);
591 ret
= m88ds3103_update_bits(dev
, 0x4d, 0x02, dev
->cfg
->spec_inv
<< 1);
595 ret
= m88ds3103_update_bits(dev
, 0x30, 0x10, dev
->cfg
->agc_inv
<< 4);
599 ret
= regmap_write(dev
->regmap
, 0x33, dev
->cfg
->agc
);
603 dev_dbg(&client
->dev
, "carrier offset=%d\n",
604 (tuner_frequency
- c
->frequency
));
606 s32tmp
= 0x10000 * (tuner_frequency
- c
->frequency
);
607 s32tmp
= DIV_ROUND_CLOSEST(s32tmp
, dev
->mclk_khz
);
608 buf
[0] = (s32tmp
>> 0) & 0xff;
609 buf
[1] = (s32tmp
>> 8) & 0xff;
610 ret
= regmap_bulk_write(dev
->regmap
, 0x5e, buf
, 2);
614 ret
= regmap_write(dev
->regmap
, 0x00, 0x00);
618 ret
= regmap_write(dev
->regmap
, 0xb2, 0x00);
622 dev
->delivery_system
= c
->delivery_system
;
626 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
630 static int m88ds3103_init(struct dvb_frontend
*fe
)
632 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
633 struct i2c_client
*client
= dev
->client
;
634 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
635 int ret
, len
, remaining
;
637 const struct firmware
*fw
= NULL
;
640 dev_dbg(&client
->dev
, "\n");
642 /* set cold state by default */
645 /* wake up device from sleep */
646 ret
= m88ds3103_update_bits(dev
, 0x08, 0x01, 0x01);
649 ret
= m88ds3103_update_bits(dev
, 0x04, 0x01, 0x00);
652 ret
= m88ds3103_update_bits(dev
, 0x23, 0x10, 0x00);
656 /* firmware status */
657 ret
= regmap_read(dev
->regmap
, 0xb9, &utmp
);
661 dev_dbg(&client
->dev
, "firmware=%02x\n", utmp
);
664 goto skip_fw_download
;
666 /* global reset, global diseqc reset, golbal fec reset */
667 ret
= regmap_write(dev
->regmap
, 0x07, 0xe0);
670 ret
= regmap_write(dev
->regmap
, 0x07, 0x00);
674 /* cold state - try to download firmware */
675 dev_info(&client
->dev
, "found a '%s' in cold state\n",
676 m88ds3103_ops
.info
.name
);
678 if (dev
->chip_id
== M88RS6000_CHIP_ID
)
679 fw_file
= M88RS6000_FIRMWARE
;
681 fw_file
= M88DS3103_FIRMWARE
;
682 /* request the firmware, this will block and timeout */
683 ret
= request_firmware(&fw
, fw_file
, &client
->dev
);
685 dev_err(&client
->dev
, "firmware file '%s' not found\n", fw_file
);
689 dev_info(&client
->dev
, "downloading firmware from file '%s'\n",
692 ret
= regmap_write(dev
->regmap
, 0xb2, 0x01);
694 goto error_fw_release
;
696 for (remaining
= fw
->size
; remaining
> 0;
697 remaining
-= (dev
->cfg
->i2c_wr_max
- 1)) {
699 if (len
> (dev
->cfg
->i2c_wr_max
- 1))
700 len
= (dev
->cfg
->i2c_wr_max
- 1);
702 ret
= regmap_bulk_write(dev
->regmap
, 0xb0,
703 &fw
->data
[fw
->size
- remaining
], len
);
705 dev_err(&client
->dev
, "firmware download failed=%d\n",
707 goto error_fw_release
;
711 ret
= regmap_write(dev
->regmap
, 0xb2, 0x00);
713 goto error_fw_release
;
715 release_firmware(fw
);
718 ret
= regmap_read(dev
->regmap
, 0xb9, &utmp
);
723 dev_info(&client
->dev
, "firmware did not run\n");
728 dev_info(&client
->dev
, "found a '%s' in warm state\n",
729 m88ds3103_ops
.info
.name
);
730 dev_info(&client
->dev
, "firmware version: %X.%X\n",
731 (utmp
>> 4) & 0xf, (utmp
>> 0 & 0xf));
737 /* init stats here in order signal app which stats are supported */
739 c
->cnr
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
740 c
->post_bit_error
.len
= 1;
741 c
->post_bit_error
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
742 c
->post_bit_count
.len
= 1;
743 c
->post_bit_count
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
747 release_firmware(fw
);
749 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
753 static int m88ds3103_sleep(struct dvb_frontend
*fe
)
755 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
756 struct i2c_client
*client
= dev
->client
;
760 dev_dbg(&client
->dev
, "\n");
763 dev
->delivery_system
= SYS_UNDEFINED
;
766 if (dev
->chip_id
== M88RS6000_CHIP_ID
)
770 ret
= m88ds3103_update_bits(dev
, utmp
, 0x01, 0x00);
775 ret
= m88ds3103_update_bits(dev
, 0x08, 0x01, 0x00);
778 ret
= m88ds3103_update_bits(dev
, 0x04, 0x01, 0x01);
781 ret
= m88ds3103_update_bits(dev
, 0x23, 0x10, 0x10);
787 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
791 static int m88ds3103_get_frontend(struct dvb_frontend
*fe
,
792 struct dtv_frontend_properties
*c
)
794 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
795 struct i2c_client
*client
= dev
->client
;
799 dev_dbg(&client
->dev
, "\n");
801 if (!dev
->warm
|| !(dev
->fe_status
& FE_HAS_LOCK
)) {
806 switch (c
->delivery_system
) {
808 ret
= regmap_bulk_read(dev
->regmap
, 0xe0, &buf
[0], 1);
812 ret
= regmap_bulk_read(dev
->regmap
, 0xe6, &buf
[1], 1);
816 switch ((buf
[0] >> 2) & 0x01) {
818 c
->inversion
= INVERSION_OFF
;
821 c
->inversion
= INVERSION_ON
;
825 switch ((buf
[1] >> 5) & 0x07) {
827 c
->fec_inner
= FEC_7_8
;
830 c
->fec_inner
= FEC_5_6
;
833 c
->fec_inner
= FEC_3_4
;
836 c
->fec_inner
= FEC_2_3
;
839 c
->fec_inner
= FEC_1_2
;
842 dev_dbg(&client
->dev
, "invalid fec_inner\n");
845 c
->modulation
= QPSK
;
849 ret
= regmap_bulk_read(dev
->regmap
, 0x7e, &buf
[0], 1);
853 ret
= regmap_bulk_read(dev
->regmap
, 0x89, &buf
[1], 1);
857 ret
= regmap_bulk_read(dev
->regmap
, 0xf2, &buf
[2], 1);
861 switch ((buf
[0] >> 0) & 0x0f) {
863 c
->fec_inner
= FEC_2_5
;
866 c
->fec_inner
= FEC_1_2
;
869 c
->fec_inner
= FEC_3_5
;
872 c
->fec_inner
= FEC_2_3
;
875 c
->fec_inner
= FEC_3_4
;
878 c
->fec_inner
= FEC_4_5
;
881 c
->fec_inner
= FEC_5_6
;
884 c
->fec_inner
= FEC_8_9
;
887 c
->fec_inner
= FEC_9_10
;
890 dev_dbg(&client
->dev
, "invalid fec_inner\n");
893 switch ((buf
[0] >> 5) & 0x01) {
895 c
->pilot
= PILOT_OFF
;
902 switch ((buf
[0] >> 6) & 0x07) {
904 c
->modulation
= QPSK
;
907 c
->modulation
= PSK_8
;
910 c
->modulation
= APSK_16
;
913 c
->modulation
= APSK_32
;
916 dev_dbg(&client
->dev
, "invalid modulation\n");
919 switch ((buf
[1] >> 7) & 0x01) {
921 c
->inversion
= INVERSION_OFF
;
924 c
->inversion
= INVERSION_ON
;
928 switch ((buf
[2] >> 0) & 0x03) {
930 c
->rolloff
= ROLLOFF_35
;
933 c
->rolloff
= ROLLOFF_25
;
936 c
->rolloff
= ROLLOFF_20
;
939 dev_dbg(&client
->dev
, "invalid rolloff\n");
943 dev_dbg(&client
->dev
, "invalid delivery_system\n");
948 ret
= regmap_bulk_read(dev
->regmap
, 0x6d, buf
, 2);
952 c
->symbol_rate
= 1ull * ((buf
[1] << 8) | (buf
[0] << 0)) *
953 dev
->mclk_khz
* 1000 / 0x10000;
957 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
961 static int m88ds3103_read_snr(struct dvb_frontend
*fe
, u16
*snr
)
963 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
965 if (c
->cnr
.stat
[0].scale
== FE_SCALE_DECIBEL
)
966 *snr
= div_s64(c
->cnr
.stat
[0].svalue
, 100);
973 static int m88ds3103_read_ber(struct dvb_frontend
*fe
, u32
*ber
)
975 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
977 *ber
= dev
->dvbv3_ber
;
982 static int m88ds3103_set_tone(struct dvb_frontend
*fe
,
983 enum fe_sec_tone_mode fe_sec_tone_mode
)
985 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
986 struct i2c_client
*client
= dev
->client
;
988 unsigned int utmp
, tone
, reg_a1_mask
;
990 dev_dbg(&client
->dev
, "fe_sec_tone_mode=%d\n", fe_sec_tone_mode
);
997 switch (fe_sec_tone_mode
) {
1007 dev_dbg(&client
->dev
, "invalid fe_sec_tone_mode\n");
1012 utmp
= tone
<< 7 | dev
->cfg
->envelope_mode
<< 5;
1013 ret
= m88ds3103_update_bits(dev
, 0xa2, 0xe0, utmp
);
1018 ret
= m88ds3103_update_bits(dev
, 0xa1, reg_a1_mask
, utmp
);
1024 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
1028 static int m88ds3103_set_voltage(struct dvb_frontend
*fe
,
1029 enum fe_sec_voltage fe_sec_voltage
)
1031 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
1032 struct i2c_client
*client
= dev
->client
;
1035 bool voltage_sel
, voltage_dis
;
1037 dev_dbg(&client
->dev
, "fe_sec_voltage=%d\n", fe_sec_voltage
);
1044 switch (fe_sec_voltage
) {
1045 case SEC_VOLTAGE_18
:
1047 voltage_dis
= false;
1049 case SEC_VOLTAGE_13
:
1050 voltage_sel
= false;
1051 voltage_dis
= false;
1053 case SEC_VOLTAGE_OFF
:
1054 voltage_sel
= false;
1058 dev_dbg(&client
->dev
, "invalid fe_sec_voltage\n");
1063 /* output pin polarity */
1064 voltage_sel
^= dev
->cfg
->lnb_hv_pol
;
1065 voltage_dis
^= dev
->cfg
->lnb_en_pol
;
1067 utmp
= voltage_dis
<< 1 | voltage_sel
<< 0;
1068 ret
= m88ds3103_update_bits(dev
, 0xa2, 0x03, utmp
);
1074 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
1078 static int m88ds3103_diseqc_send_master_cmd(struct dvb_frontend
*fe
,
1079 struct dvb_diseqc_master_cmd
*diseqc_cmd
)
1081 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
1082 struct i2c_client
*client
= dev
->client
;
1085 unsigned long timeout
;
1087 dev_dbg(&client
->dev
, "msg=%*ph\n",
1088 diseqc_cmd
->msg_len
, diseqc_cmd
->msg
);
1095 if (diseqc_cmd
->msg_len
< 3 || diseqc_cmd
->msg_len
> 6) {
1100 utmp
= dev
->cfg
->envelope_mode
<< 5;
1101 ret
= m88ds3103_update_bits(dev
, 0xa2, 0xe0, utmp
);
1105 ret
= regmap_bulk_write(dev
->regmap
, 0xa3, diseqc_cmd
->msg
,
1106 diseqc_cmd
->msg_len
);
1110 ret
= regmap_write(dev
->regmap
, 0xa1,
1111 (diseqc_cmd
->msg_len
- 1) << 3 | 0x07);
1115 /* wait DiSEqC TX ready */
1116 #define SEND_MASTER_CMD_TIMEOUT 120
1117 timeout
= jiffies
+ msecs_to_jiffies(SEND_MASTER_CMD_TIMEOUT
);
1119 /* DiSEqC message period is 13.5 ms per byte */
1120 utmp
= diseqc_cmd
->msg_len
* 13500;
1121 usleep_range(utmp
- 4000, utmp
);
1123 for (utmp
= 1; !time_after(jiffies
, timeout
) && utmp
;) {
1124 ret
= regmap_read(dev
->regmap
, 0xa1, &utmp
);
1127 utmp
= (utmp
>> 6) & 0x1;
1131 dev_dbg(&client
->dev
, "diseqc tx took %u ms\n",
1132 jiffies_to_msecs(jiffies
) -
1133 (jiffies_to_msecs(timeout
) - SEND_MASTER_CMD_TIMEOUT
));
1135 dev_dbg(&client
->dev
, "diseqc tx timeout\n");
1137 ret
= m88ds3103_update_bits(dev
, 0xa1, 0xc0, 0x40);
1142 ret
= m88ds3103_update_bits(dev
, 0xa2, 0xc0, 0x80);
1153 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
1157 static int m88ds3103_diseqc_send_burst(struct dvb_frontend
*fe
,
1158 enum fe_sec_mini_cmd fe_sec_mini_cmd
)
1160 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
1161 struct i2c_client
*client
= dev
->client
;
1163 unsigned int utmp
, burst
;
1164 unsigned long timeout
;
1166 dev_dbg(&client
->dev
, "fe_sec_mini_cmd=%d\n", fe_sec_mini_cmd
);
1173 utmp
= dev
->cfg
->envelope_mode
<< 5;
1174 ret
= m88ds3103_update_bits(dev
, 0xa2, 0xe0, utmp
);
1178 switch (fe_sec_mini_cmd
) {
1186 dev_dbg(&client
->dev
, "invalid fe_sec_mini_cmd\n");
1191 ret
= regmap_write(dev
->regmap
, 0xa1, burst
);
1195 /* wait DiSEqC TX ready */
1196 #define SEND_BURST_TIMEOUT 40
1197 timeout
= jiffies
+ msecs_to_jiffies(SEND_BURST_TIMEOUT
);
1199 /* DiSEqC ToneBurst period is 12.5 ms */
1200 usleep_range(8500, 12500);
1202 for (utmp
= 1; !time_after(jiffies
, timeout
) && utmp
;) {
1203 ret
= regmap_read(dev
->regmap
, 0xa1, &utmp
);
1206 utmp
= (utmp
>> 6) & 0x1;
1210 dev_dbg(&client
->dev
, "diseqc tx took %u ms\n",
1211 jiffies_to_msecs(jiffies
) -
1212 (jiffies_to_msecs(timeout
) - SEND_BURST_TIMEOUT
));
1214 dev_dbg(&client
->dev
, "diseqc tx timeout\n");
1216 ret
= m88ds3103_update_bits(dev
, 0xa1, 0xc0, 0x40);
1221 ret
= m88ds3103_update_bits(dev
, 0xa2, 0xc0, 0x80);
1232 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
1236 static int m88ds3103_get_tune_settings(struct dvb_frontend
*fe
,
1237 struct dvb_frontend_tune_settings
*s
)
1239 s
->min_delay_ms
= 3000;
1244 static void m88ds3103_release(struct dvb_frontend
*fe
)
1246 struct m88ds3103_dev
*dev
= fe
->demodulator_priv
;
1247 struct i2c_client
*client
= dev
->client
;
1249 i2c_unregister_device(client
);
1252 static int m88ds3103_select(struct i2c_mux_core
*muxc
, u32 chan
)
1254 struct m88ds3103_dev
*dev
= i2c_mux_priv(muxc
);
1255 struct i2c_client
*client
= dev
->client
;
1257 struct i2c_msg msg
= {
1258 .addr
= client
->addr
,
1264 /* Open tuner I2C repeater for 1 xfer, closes automatically */
1265 ret
= __i2c_transfer(client
->adapter
, &msg
, 1);
1267 dev_warn(&client
->dev
, "i2c wr failed=%d\n", ret
);
1277 * XXX: That is wrapper to m88ds3103_probe() via driver core in order to provide
1278 * proper I2C client for legacy media attach binding.
1279 * New users must use I2C client binding directly!
1281 struct dvb_frontend
*m88ds3103_attach(const struct m88ds3103_config
*cfg
,
1282 struct i2c_adapter
*i2c
, struct i2c_adapter
**tuner_i2c_adapter
)
1284 struct i2c_client
*client
;
1285 struct i2c_board_info board_info
;
1286 struct m88ds3103_platform_data pdata
;
1288 pdata
.clk
= cfg
->clock
;
1289 pdata
.i2c_wr_max
= cfg
->i2c_wr_max
;
1290 pdata
.ts_mode
= cfg
->ts_mode
;
1291 pdata
.ts_clk
= cfg
->ts_clk
;
1292 pdata
.ts_clk_pol
= cfg
->ts_clk_pol
;
1293 pdata
.spec_inv
= cfg
->spec_inv
;
1294 pdata
.agc
= cfg
->agc
;
1295 pdata
.agc_inv
= cfg
->agc_inv
;
1296 pdata
.clk_out
= cfg
->clock_out
;
1297 pdata
.envelope_mode
= cfg
->envelope_mode
;
1298 pdata
.lnb_hv_pol
= cfg
->lnb_hv_pol
;
1299 pdata
.lnb_en_pol
= cfg
->lnb_en_pol
;
1300 pdata
.attach_in_use
= true;
1302 memset(&board_info
, 0, sizeof(board_info
));
1303 strlcpy(board_info
.type
, "m88ds3103", I2C_NAME_SIZE
);
1304 board_info
.addr
= cfg
->i2c_addr
;
1305 board_info
.platform_data
= &pdata
;
1306 client
= i2c_new_device(i2c
, &board_info
);
1307 if (!client
|| !client
->dev
.driver
)
1310 *tuner_i2c_adapter
= pdata
.get_i2c_adapter(client
);
1311 return pdata
.get_dvb_frontend(client
);
1313 EXPORT_SYMBOL(m88ds3103_attach
);
1315 static struct dvb_frontend_ops m88ds3103_ops
= {
1316 .delsys
= {SYS_DVBS
, SYS_DVBS2
},
1318 .name
= "Montage Technology M88DS3103",
1319 .frequency_min
= 950000,
1320 .frequency_max
= 2150000,
1321 .frequency_tolerance
= 5000,
1322 .symbol_rate_min
= 1000000,
1323 .symbol_rate_max
= 45000000,
1324 .caps
= FE_CAN_INVERSION_AUTO
|
1336 FE_CAN_2G_MODULATION
1339 .release
= m88ds3103_release
,
1341 .get_tune_settings
= m88ds3103_get_tune_settings
,
1343 .init
= m88ds3103_init
,
1344 .sleep
= m88ds3103_sleep
,
1346 .set_frontend
= m88ds3103_set_frontend
,
1347 .get_frontend
= m88ds3103_get_frontend
,
1349 .read_status
= m88ds3103_read_status
,
1350 .read_snr
= m88ds3103_read_snr
,
1351 .read_ber
= m88ds3103_read_ber
,
1353 .diseqc_send_master_cmd
= m88ds3103_diseqc_send_master_cmd
,
1354 .diseqc_send_burst
= m88ds3103_diseqc_send_burst
,
1356 .set_tone
= m88ds3103_set_tone
,
1357 .set_voltage
= m88ds3103_set_voltage
,
1360 static struct dvb_frontend
*m88ds3103_get_dvb_frontend(struct i2c_client
*client
)
1362 struct m88ds3103_dev
*dev
= i2c_get_clientdata(client
);
1364 dev_dbg(&client
->dev
, "\n");
1369 static struct i2c_adapter
*m88ds3103_get_i2c_adapter(struct i2c_client
*client
)
1371 struct m88ds3103_dev
*dev
= i2c_get_clientdata(client
);
1373 dev_dbg(&client
->dev
, "\n");
1375 return dev
->muxc
->adapter
[0];
1378 static int m88ds3103_probe(struct i2c_client
*client
,
1379 const struct i2c_device_id
*id
)
1381 struct m88ds3103_dev
*dev
;
1382 struct m88ds3103_platform_data
*pdata
= client
->dev
.platform_data
;
1386 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1392 dev
->client
= client
;
1393 dev
->config
.clock
= pdata
->clk
;
1394 dev
->config
.i2c_wr_max
= pdata
->i2c_wr_max
;
1395 dev
->config
.ts_mode
= pdata
->ts_mode
;
1396 dev
->config
.ts_clk
= pdata
->ts_clk
;
1397 dev
->config
.ts_clk_pol
= pdata
->ts_clk_pol
;
1398 dev
->config
.spec_inv
= pdata
->spec_inv
;
1399 dev
->config
.agc_inv
= pdata
->agc_inv
;
1400 dev
->config
.clock_out
= pdata
->clk_out
;
1401 dev
->config
.envelope_mode
= pdata
->envelope_mode
;
1402 dev
->config
.agc
= pdata
->agc
;
1403 dev
->config
.lnb_hv_pol
= pdata
->lnb_hv_pol
;
1404 dev
->config
.lnb_en_pol
= pdata
->lnb_en_pol
;
1405 dev
->cfg
= &dev
->config
;
1407 dev
->regmap_config
.reg_bits
= 8,
1408 dev
->regmap_config
.val_bits
= 8,
1409 dev
->regmap_config
.lock_arg
= dev
,
1410 dev
->regmap
= devm_regmap_init_i2c(client
, &dev
->regmap_config
);
1411 if (IS_ERR(dev
->regmap
)) {
1412 ret
= PTR_ERR(dev
->regmap
);
1416 /* 0x00: chip id[6:0], 0x01: chip ver[7:0], 0x02: chip ver[15:8] */
1417 ret
= regmap_read(dev
->regmap
, 0x00, &utmp
);
1421 dev
->chip_id
= utmp
>> 1;
1422 dev_dbg(&client
->dev
, "chip_id=%02x\n", dev
->chip_id
);
1424 switch (dev
->chip_id
) {
1425 case M88RS6000_CHIP_ID
:
1426 case M88DS3103_CHIP_ID
:
1432 switch (dev
->cfg
->clock_out
) {
1433 case M88DS3103_CLOCK_OUT_DISABLED
:
1436 case M88DS3103_CLOCK_OUT_ENABLED
:
1439 case M88DS3103_CLOCK_OUT_ENABLED_DIV2
:
1447 /* 0x29 register is defined differently for m88rs6000. */
1448 /* set internal tuner address to 0x21 */
1449 if (dev
->chip_id
== M88RS6000_CHIP_ID
)
1452 ret
= regmap_write(dev
->regmap
, 0x29, utmp
);
1457 ret
= m88ds3103_update_bits(dev
, 0x08, 0x01, 0x00);
1460 ret
= m88ds3103_update_bits(dev
, 0x04, 0x01, 0x01);
1463 ret
= m88ds3103_update_bits(dev
, 0x23, 0x10, 0x10);
1467 /* create mux i2c adapter for tuner */
1468 dev
->muxc
= i2c_mux_alloc(client
->adapter
, &client
->dev
, 1, 0, 0,
1469 m88ds3103_select
, NULL
);
1474 dev
->muxc
->priv
= dev
;
1475 ret
= i2c_mux_add_adapter(dev
->muxc
, 0, 0, 0);
1479 /* create dvb_frontend */
1480 memcpy(&dev
->fe
.ops
, &m88ds3103_ops
, sizeof(struct dvb_frontend_ops
));
1481 if (dev
->chip_id
== M88RS6000_CHIP_ID
)
1482 strncpy(dev
->fe
.ops
.info
.name
, "Montage Technology M88RS6000",
1483 sizeof(dev
->fe
.ops
.info
.name
));
1484 if (!pdata
->attach_in_use
)
1485 dev
->fe
.ops
.release
= NULL
;
1486 dev
->fe
.demodulator_priv
= dev
;
1487 i2c_set_clientdata(client
, dev
);
1489 /* setup callbacks */
1490 pdata
->get_dvb_frontend
= m88ds3103_get_dvb_frontend
;
1491 pdata
->get_i2c_adapter
= m88ds3103_get_i2c_adapter
;
1496 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
1500 static int m88ds3103_remove(struct i2c_client
*client
)
1502 struct m88ds3103_dev
*dev
= i2c_get_clientdata(client
);
1504 dev_dbg(&client
->dev
, "\n");
1506 i2c_mux_del_adapters(dev
->muxc
);
1512 static const struct i2c_device_id m88ds3103_id_table
[] = {
1516 MODULE_DEVICE_TABLE(i2c
, m88ds3103_id_table
);
1518 static struct i2c_driver m88ds3103_driver
= {
1520 .name
= "m88ds3103",
1521 .suppress_bind_attrs
= true,
1523 .probe
= m88ds3103_probe
,
1524 .remove
= m88ds3103_remove
,
1525 .id_table
= m88ds3103_id_table
,
1528 module_i2c_driver(m88ds3103_driver
);
1530 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1531 MODULE_DESCRIPTION("Montage Technology M88DS3103 DVB-S/S2 demodulator driver");
1532 MODULE_LICENSE("GPL");
1533 MODULE_FIRMWARE(M88DS3103_FIRMWARE
);
1534 MODULE_FIRMWARE(M88RS6000_FIRMWARE
);