2 * Panasonic MN88472 DVB-T/T2/C 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 "mn88472_priv.h"
19 static int mn88472_get_tune_settings(struct dvb_frontend
*fe
,
20 struct dvb_frontend_tune_settings
*s
)
22 s
->min_delay_ms
= 1000;
26 static int mn88472_read_status(struct dvb_frontend
*fe
, enum fe_status
*status
)
28 struct i2c_client
*client
= fe
->demodulator_priv
;
29 struct mn88472_dev
*dev
= i2c_get_clientdata(client
);
30 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
32 unsigned int utmp
, utmp1
;
40 switch (c
->delivery_system
) {
42 ret
= regmap_read(dev
->regmap
[0], 0x7f, &utmp
);
45 if ((utmp
& 0x0f) >= 0x09)
46 *status
= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
47 FE_HAS_VITERBI
| FE_HAS_SYNC
| FE_HAS_LOCK
;
52 ret
= regmap_read(dev
->regmap
[2], 0x92, &utmp
);
55 if ((utmp
& 0x0f) >= 0x0d)
56 *status
= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
57 FE_HAS_VITERBI
| FE_HAS_SYNC
| FE_HAS_LOCK
;
58 else if ((utmp
& 0x0f) >= 0x0a)
59 *status
= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
61 else if ((utmp
& 0x0f) >= 0x07)
62 *status
= FE_HAS_SIGNAL
| FE_HAS_CARRIER
;
66 case SYS_DVBC_ANNEX_A
:
67 ret
= regmap_read(dev
->regmap
[1], 0x84, &utmp
);
70 if ((utmp
& 0x0f) >= 0x08)
71 *status
= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
72 FE_HAS_VITERBI
| FE_HAS_SYNC
| FE_HAS_LOCK
;
82 if (*status
& FE_HAS_SIGNAL
) {
83 for (i
= 0; i
< 2; i
++) {
84 ret
= regmap_bulk_read(dev
->regmap
[2], 0x8e + i
,
90 utmp1
= buf
[0] << 8 | buf
[1] << 0 | buf
[0] >> 2;
91 dev_dbg(&client
->dev
, "strength=%u\n", utmp1
);
93 c
->strength
.stat
[0].scale
= FE_SCALE_RELATIVE
;
94 c
->strength
.stat
[0].uvalue
= utmp1
;
96 c
->strength
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
101 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
105 static int mn88472_set_frontend(struct dvb_frontend
*fe
)
107 struct i2c_client
*client
= fe
->demodulator_priv
;
108 struct mn88472_dev
*dev
= i2c_get_clientdata(client
);
109 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
113 u8 buf
[3], delivery_system_val
, bandwidth_val
, *bandwidth_vals_ptr
;
114 u8 reg_bank0_b4_val
, reg_bank0_cd_val
, reg_bank0_d4_val
;
117 dev_dbg(&client
->dev
,
118 "delivery_system=%u modulation=%u frequency=%u bandwidth_hz=%u symbol_rate=%u inversion=%d stream_id=%d\n",
119 c
->delivery_system
, c
->modulation
, c
->frequency
,
120 c
->bandwidth_hz
, c
->symbol_rate
, c
->inversion
, c
->stream_id
);
127 switch (c
->delivery_system
) {
129 delivery_system_val
= 0x02;
130 reg_bank0_b4_val
= 0x00;
131 reg_bank0_cd_val
= 0x1f;
132 reg_bank0_d4_val
= 0x0a;
133 reg_bank0_d6_val
= 0x48;
136 delivery_system_val
= 0x03;
137 reg_bank0_b4_val
= 0xf6;
138 reg_bank0_cd_val
= 0x01;
139 reg_bank0_d4_val
= 0x09;
140 reg_bank0_d6_val
= 0x46;
142 case SYS_DVBC_ANNEX_A
:
143 delivery_system_val
= 0x04;
144 reg_bank0_b4_val
= 0x00;
145 reg_bank0_cd_val
= 0x17;
146 reg_bank0_d4_val
= 0x09;
147 reg_bank0_d6_val
= 0x48;
154 switch (c
->delivery_system
) {
157 switch (c
->bandwidth_hz
) {
159 bandwidth_vals_ptr
= "\xe5\x99\x9a\x1b\xa9\x1b\xa9";
160 bandwidth_val
= 0x03;
163 bandwidth_vals_ptr
= "\xbf\x55\x55\x15\x6b\x15\x6b";
164 bandwidth_val
= 0x02;
167 bandwidth_vals_ptr
= "\xa4\x00\x00\x0f\x2c\x0f\x2c";
168 bandwidth_val
= 0x01;
171 bandwidth_vals_ptr
= "\x8f\x80\x00\x08\xee\x08\xee";
172 bandwidth_val
= 0x00;
179 case SYS_DVBC_ANNEX_A
:
180 bandwidth_vals_ptr
= NULL
;
181 bandwidth_val
= 0x00;
188 if (fe
->ops
.tuner_ops
.set_params
) {
189 ret
= fe
->ops
.tuner_ops
.set_params(fe
);
194 if (fe
->ops
.tuner_ops
.get_if_frequency
) {
195 ret
= fe
->ops
.tuner_ops
.get_if_frequency(fe
, &if_frequency
);
199 dev_dbg(&client
->dev
, "get_if_frequency=%d\n", if_frequency
);
205 ret
= regmap_write(dev
->regmap
[2], 0x00, 0x66);
208 ret
= regmap_write(dev
->regmap
[2], 0x01, 0x00);
211 ret
= regmap_write(dev
->regmap
[2], 0x02, 0x01);
214 ret
= regmap_write(dev
->regmap
[2], 0x03, delivery_system_val
);
217 ret
= regmap_write(dev
->regmap
[2], 0x04, bandwidth_val
);
222 utmp
= DIV_ROUND_CLOSEST_ULL((u64
)if_frequency
* 0x1000000, dev
->clk
);
223 buf
[0] = (utmp
>> 16) & 0xff;
224 buf
[1] = (utmp
>> 8) & 0xff;
225 buf
[2] = (utmp
>> 0) & 0xff;
226 for (i
= 0; i
< 3; i
++) {
227 ret
= regmap_write(dev
->regmap
[2], 0x10 + i
, buf
[i
]);
233 if (bandwidth_vals_ptr
) {
234 for (i
= 0; i
< 7; i
++) {
235 ret
= regmap_write(dev
->regmap
[2], 0x13 + i
,
236 bandwidth_vals_ptr
[i
]);
242 ret
= regmap_write(dev
->regmap
[0], 0xb4, reg_bank0_b4_val
);
245 ret
= regmap_write(dev
->regmap
[0], 0xcd, reg_bank0_cd_val
);
248 ret
= regmap_write(dev
->regmap
[0], 0xd4, reg_bank0_d4_val
);
251 ret
= regmap_write(dev
->regmap
[0], 0xd6, reg_bank0_d6_val
);
255 switch (c
->delivery_system
) {
257 ret
= regmap_write(dev
->regmap
[0], 0x07, 0x26);
260 ret
= regmap_write(dev
->regmap
[0], 0x00, 0xba);
263 ret
= regmap_write(dev
->regmap
[0], 0x01, 0x13);
268 ret
= regmap_write(dev
->regmap
[2], 0x2b, 0x13);
271 ret
= regmap_write(dev
->regmap
[2], 0x4f, 0x05);
274 ret
= regmap_write(dev
->regmap
[1], 0xf6, 0x05);
277 ret
= regmap_write(dev
->regmap
[2], 0x32, c
->stream_id
);
281 case SYS_DVBC_ANNEX_A
:
288 ret
= regmap_write(dev
->regmap
[2], 0xf8, 0x9f);
294 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
298 static int mn88472_init(struct dvb_frontend
*fe
)
300 struct i2c_client
*client
= fe
->demodulator_priv
;
301 struct mn88472_dev
*dev
= i2c_get_clientdata(client
);
304 const struct firmware
*firmware
;
305 const char *name
= MN88472_FIRMWARE
;
307 dev_dbg(&client
->dev
, "\n");
310 ret
= regmap_write(dev
->regmap
[2], 0x05, 0x00);
313 ret
= regmap_write(dev
->regmap
[2], 0x0b, 0x00);
316 ret
= regmap_write(dev
->regmap
[2], 0x0c, 0x00);
320 /* Check if firmware is already running */
321 ret
= regmap_read(dev
->regmap
[0], 0xf5, &utmp
);
327 ret
= request_firmware(&firmware
, name
, &client
->dev
);
329 dev_err(&client
->dev
, "firmware file '%s' not found\n", name
);
333 dev_info(&client
->dev
, "downloading firmware from file '%s'\n", name
);
335 ret
= regmap_write(dev
->regmap
[0], 0xf5, 0x03);
337 goto err_release_firmware
;
339 for (rem
= firmware
->size
; rem
> 0; rem
-= (dev
->i2c_write_max
- 1)) {
340 len
= min(dev
->i2c_write_max
- 1, rem
);
341 ret
= regmap_bulk_write(dev
->regmap
[0], 0xf6,
342 &firmware
->data
[firmware
->size
- rem
],
345 dev_err(&client
->dev
, "firmware download failed %d\n",
347 goto err_release_firmware
;
351 /* Parity check of firmware */
352 ret
= regmap_read(dev
->regmap
[0], 0xf8, &utmp
);
354 goto err_release_firmware
;
357 dev_err(&client
->dev
, "firmware did not run\n");
358 goto err_release_firmware
;
361 ret
= regmap_write(dev
->regmap
[0], 0xf5, 0x00);
363 goto err_release_firmware
;
365 release_firmware(firmware
);
368 switch (dev
->ts_mode
) {
372 case PARALLEL_TS_MODE
:
379 ret
= regmap_write(dev
->regmap
[2], 0x08, utmp
);
383 switch (dev
->ts_clk
) {
384 case VARIABLE_TS_CLOCK
:
394 ret
= regmap_write(dev
->regmap
[0], 0xd9, utmp
);
401 err_release_firmware
:
402 release_firmware(firmware
);
404 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
408 static int mn88472_sleep(struct dvb_frontend
*fe
)
410 struct i2c_client
*client
= fe
->demodulator_priv
;
411 struct mn88472_dev
*dev
= i2c_get_clientdata(client
);
414 dev_dbg(&client
->dev
, "\n");
417 ret
= regmap_write(dev
->regmap
[2], 0x0c, 0x30);
420 ret
= regmap_write(dev
->regmap
[2], 0x0b, 0x30);
423 ret
= regmap_write(dev
->regmap
[2], 0x05, 0x3e);
429 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
433 static const struct dvb_frontend_ops mn88472_ops
= {
434 .delsys
= {SYS_DVBT
, SYS_DVBT2
, SYS_DVBC_ANNEX_A
},
436 .name
= "Panasonic MN88472",
437 .symbol_rate_min
= 1000000,
438 .symbol_rate_max
= 7200000,
439 .caps
= FE_CAN_FEC_1_2
|
452 FE_CAN_TRANSMISSION_MODE_AUTO
|
453 FE_CAN_GUARD_INTERVAL_AUTO
|
454 FE_CAN_HIERARCHY_AUTO
|
456 FE_CAN_2G_MODULATION
|
460 .get_tune_settings
= mn88472_get_tune_settings
,
462 .init
= mn88472_init
,
463 .sleep
= mn88472_sleep
,
465 .set_frontend
= mn88472_set_frontend
,
467 .read_status
= mn88472_read_status
,
470 static struct dvb_frontend
*mn88472_get_dvb_frontend(struct i2c_client
*client
)
472 struct mn88472_dev
*dev
= i2c_get_clientdata(client
);
474 dev_dbg(&client
->dev
, "\n");
479 static int mn88472_probe(struct i2c_client
*client
,
480 const struct i2c_device_id
*id
)
482 struct mn88472_config
*pdata
= client
->dev
.platform_data
;
483 struct mn88472_dev
*dev
;
484 struct dtv_frontend_properties
*c
;
487 static const struct regmap_config regmap_config
= {
492 dev_dbg(&client
->dev
, "\n");
494 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
500 dev
->i2c_write_max
= pdata
->i2c_wr_max
? pdata
->i2c_wr_max
: ~0;
501 dev
->clk
= pdata
->xtal
;
502 dev
->ts_mode
= pdata
->ts_mode
;
503 dev
->ts_clk
= pdata
->ts_clock
;
504 dev
->client
[0] = client
;
505 dev
->regmap
[0] = regmap_init_i2c(dev
->client
[0], ®map_config
);
506 if (IS_ERR(dev
->regmap
[0])) {
507 ret
= PTR_ERR(dev
->regmap
[0]);
512 * Chip has three I2C addresses for different register banks. Used
513 * addresses are 0x18, 0x1a and 0x1c. We register two dummy clients,
514 * 0x1a and 0x1c, in order to get own I2C client for each register bank.
516 * Also, register bank 2 do not support sequential I/O. Only single
517 * register write or read is allowed to that bank.
519 dev
->client
[1] = i2c_new_dummy(client
->adapter
, 0x1a);
520 if (!dev
->client
[1]) {
522 dev_err(&client
->dev
, "I2C registration failed\n");
524 goto err_regmap_0_regmap_exit
;
526 dev
->regmap
[1] = regmap_init_i2c(dev
->client
[1], ®map_config
);
527 if (IS_ERR(dev
->regmap
[1])) {
528 ret
= PTR_ERR(dev
->regmap
[1]);
529 goto err_client_1_i2c_unregister_device
;
531 i2c_set_clientdata(dev
->client
[1], dev
);
533 dev
->client
[2] = i2c_new_dummy(client
->adapter
, 0x1c);
534 if (!dev
->client
[2]) {
536 dev_err(&client
->dev
, "2nd I2C registration failed\n");
538 goto err_regmap_1_regmap_exit
;
540 dev
->regmap
[2] = regmap_init_i2c(dev
->client
[2], ®map_config
);
541 if (IS_ERR(dev
->regmap
[2])) {
542 ret
= PTR_ERR(dev
->regmap
[2]);
543 goto err_client_2_i2c_unregister_device
;
545 i2c_set_clientdata(dev
->client
[2], dev
);
547 /* Check demod answers with correct chip id */
548 ret
= regmap_read(dev
->regmap
[2], 0xff, &utmp
);
550 goto err_regmap_2_regmap_exit
;
552 dev_dbg(&client
->dev
, "chip id=%02x\n", utmp
);
556 goto err_regmap_2_regmap_exit
;
559 /* Sleep because chip is active by default */
560 ret
= regmap_write(dev
->regmap
[2], 0x05, 0x3e);
562 goto err_regmap_2_regmap_exit
;
564 /* Create dvb frontend */
565 memcpy(&dev
->fe
.ops
, &mn88472_ops
, sizeof(struct dvb_frontend_ops
));
566 dev
->fe
.demodulator_priv
= client
;
567 *pdata
->fe
= &dev
->fe
;
568 i2c_set_clientdata(client
, dev
);
570 /* Init stats to indicate which stats are supported */
571 c
= &dev
->fe
.dtv_property_cache
;
574 /* Setup callbacks */
575 pdata
->get_dvb_frontend
= mn88472_get_dvb_frontend
;
577 dev_info(&client
->dev
, "Panasonic MN88472 successfully identified\n");
580 err_regmap_2_regmap_exit
:
581 regmap_exit(dev
->regmap
[2]);
582 err_client_2_i2c_unregister_device
:
583 i2c_unregister_device(dev
->client
[2]);
584 err_regmap_1_regmap_exit
:
585 regmap_exit(dev
->regmap
[1]);
586 err_client_1_i2c_unregister_device
:
587 i2c_unregister_device(dev
->client
[1]);
588 err_regmap_0_regmap_exit
:
589 regmap_exit(dev
->regmap
[0]);
593 dev_dbg(&client
->dev
, "failed=%d\n", ret
);
597 static int mn88472_remove(struct i2c_client
*client
)
599 struct mn88472_dev
*dev
= i2c_get_clientdata(client
);
601 dev_dbg(&client
->dev
, "\n");
603 regmap_exit(dev
->regmap
[2]);
604 i2c_unregister_device(dev
->client
[2]);
606 regmap_exit(dev
->regmap
[1]);
607 i2c_unregister_device(dev
->client
[1]);
609 regmap_exit(dev
->regmap
[0]);
616 static const struct i2c_device_id mn88472_id_table
[] = {
620 MODULE_DEVICE_TABLE(i2c
, mn88472_id_table
);
622 static struct i2c_driver mn88472_driver
= {
625 .suppress_bind_attrs
= true,
627 .probe
= mn88472_probe
,
628 .remove
= mn88472_remove
,
629 .id_table
= mn88472_id_table
,
632 module_i2c_driver(mn88472_driver
);
634 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
635 MODULE_DESCRIPTION("Panasonic MN88472 DVB-T/T2/C demodulator driver");
636 MODULE_LICENSE("GPL");
637 MODULE_FIRMWARE(MN88472_FIRMWARE
);