Linux 5.4-rc4
[sfrench/cifs-2.6.git] / drivers / media / dvb-frontends / ec100.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * E3C EC100 demodulator driver
4  *
5  * Copyright (C) 2009 Antti Palosaari <crope@iki.fi>
6  */
7
8 #include <media/dvb_frontend.h>
9 #include "ec100.h"
10
11 struct ec100_state {
12         struct i2c_adapter *i2c;
13         struct dvb_frontend frontend;
14         struct ec100_config config;
15
16         u16 ber;
17 };
18
19 /* write single register */
20 static int ec100_write_reg(struct ec100_state *state, u8 reg, u8 val)
21 {
22         int ret;
23         u8 buf[2] = {reg, val};
24         struct i2c_msg msg[1] = {
25                 {
26                         .addr = state->config.demod_address,
27                         .flags = 0,
28                         .len = sizeof(buf),
29                         .buf = buf,
30                 }
31         };
32
33         ret = i2c_transfer(state->i2c, msg, 1);
34         if (ret == 1) {
35                 ret = 0;
36         } else {
37                 dev_warn(&state->i2c->dev, "%s: i2c wr failed=%d reg=%02x\n",
38                                 KBUILD_MODNAME, ret, reg);
39                 ret = -EREMOTEIO;
40         }
41
42         return ret;
43 }
44
45 /* read single register */
46 static int ec100_read_reg(struct ec100_state *state, u8 reg, u8 *val)
47 {
48         int ret;
49         struct i2c_msg msg[2] = {
50                 {
51                         .addr = state->config.demod_address,
52                         .flags = 0,
53                         .len = 1,
54                         .buf = &reg
55                 }, {
56                         .addr = state->config.demod_address,
57                         .flags = I2C_M_RD,
58                         .len = 1,
59                         .buf = val
60                 }
61         };
62
63         ret = i2c_transfer(state->i2c, msg, 2);
64         if (ret == 2) {
65                 ret = 0;
66         } else {
67                 dev_warn(&state->i2c->dev, "%s: i2c rd failed=%d reg=%02x\n",
68                                 KBUILD_MODNAME, ret, reg);
69                 ret = -EREMOTEIO;
70         }
71
72         return ret;
73 }
74
75 static int ec100_set_frontend(struct dvb_frontend *fe)
76 {
77         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
78         struct ec100_state *state = fe->demodulator_priv;
79         int ret;
80         u8 tmp, tmp2;
81
82         dev_dbg(&state->i2c->dev, "%s: frequency=%d bandwidth_hz=%d\n",
83                         __func__, c->frequency, c->bandwidth_hz);
84
85         /* program tuner */
86         if (fe->ops.tuner_ops.set_params)
87                 fe->ops.tuner_ops.set_params(fe);
88
89         ret = ec100_write_reg(state, 0x04, 0x06);
90         if (ret)
91                 goto error;
92         ret = ec100_write_reg(state, 0x67, 0x58);
93         if (ret)
94                 goto error;
95         ret = ec100_write_reg(state, 0x05, 0x18);
96         if (ret)
97                 goto error;
98
99         /* reg/bw |   6  |   7  |   8
100            -------+------+------+------
101            A 0x1b | 0xa1 | 0xe7 | 0x2c
102            A 0x1c | 0x55 | 0x63 | 0x72
103            -------+------+------+------
104            B 0x1b | 0xb7 | 0x00 | 0x49
105            B 0x1c | 0x55 | 0x64 | 0x72 */
106
107         switch (c->bandwidth_hz) {
108         case 6000000:
109                 tmp = 0xb7;
110                 tmp2 = 0x55;
111                 break;
112         case 7000000:
113                 tmp = 0x00;
114                 tmp2 = 0x64;
115                 break;
116         case 8000000:
117         default:
118                 tmp = 0x49;
119                 tmp2 = 0x72;
120         }
121
122         ret = ec100_write_reg(state, 0x1b, tmp);
123         if (ret)
124                 goto error;
125         ret = ec100_write_reg(state, 0x1c, tmp2);
126         if (ret)
127                 goto error;
128
129         ret = ec100_write_reg(state, 0x0c, 0xbb); /* if freq */
130         if (ret)
131                 goto error;
132         ret = ec100_write_reg(state, 0x0d, 0x31); /* if freq */
133         if (ret)
134                 goto error;
135
136         ret = ec100_write_reg(state, 0x08, 0x24);
137         if (ret)
138                 goto error;
139
140         ret = ec100_write_reg(state, 0x00, 0x00); /* go */
141         if (ret)
142                 goto error;
143         ret = ec100_write_reg(state, 0x00, 0x20); /* go */
144         if (ret)
145                 goto error;
146
147         return ret;
148 error:
149         dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
150         return ret;
151 }
152
153 static int ec100_get_tune_settings(struct dvb_frontend *fe,
154         struct dvb_frontend_tune_settings *fesettings)
155 {
156         fesettings->min_delay_ms = 300;
157         fesettings->step_size = 0;
158         fesettings->max_drift = 0;
159
160         return 0;
161 }
162
163 static int ec100_read_status(struct dvb_frontend *fe, enum fe_status *status)
164 {
165         struct ec100_state *state = fe->demodulator_priv;
166         int ret;
167         u8 tmp;
168         *status = 0;
169
170         ret = ec100_read_reg(state, 0x42, &tmp);
171         if (ret)
172                 goto error;
173
174         if (tmp & 0x80) {
175                 /* bit7 set - have lock */
176                 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI |
177                         FE_HAS_SYNC | FE_HAS_LOCK;
178         } else {
179                 ret = ec100_read_reg(state, 0x01, &tmp);
180                 if (ret)
181                         goto error;
182
183                 if (tmp & 0x10) {
184                         /* bit4 set - have signal */
185                         *status |= FE_HAS_SIGNAL;
186                         if (!(tmp & 0x01)) {
187                                 /* bit0 clear - have ~valid signal */
188                                 *status |= FE_HAS_CARRIER |  FE_HAS_VITERBI;
189                         }
190                 }
191         }
192
193         return ret;
194 error:
195         dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
196         return ret;
197 }
198
199 static int ec100_read_ber(struct dvb_frontend *fe, u32 *ber)
200 {
201         struct ec100_state *state = fe->demodulator_priv;
202         int ret;
203         u8 tmp, tmp2;
204         u16 ber2;
205
206         *ber = 0;
207
208         ret = ec100_read_reg(state, 0x65, &tmp);
209         if (ret)
210                 goto error;
211         ret = ec100_read_reg(state, 0x66, &tmp2);
212         if (ret)
213                 goto error;
214
215         ber2 = (tmp2 << 8) | tmp;
216
217         /* if counter overflow or clear */
218         if (ber2 < state->ber)
219                 *ber = ber2;
220         else
221                 *ber = ber2 - state->ber;
222
223         state->ber = ber2;
224
225         return ret;
226 error:
227         dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
228         return ret;
229 }
230
231 static int ec100_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
232 {
233         struct ec100_state *state = fe->demodulator_priv;
234         int ret;
235         u8 tmp;
236
237         ret = ec100_read_reg(state, 0x24, &tmp);
238         if (ret) {
239                 *strength = 0;
240                 goto error;
241         }
242
243         *strength = ((tmp << 8) | tmp);
244
245         return ret;
246 error:
247         dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
248         return ret;
249 }
250
251 static int ec100_read_snr(struct dvb_frontend *fe, u16 *snr)
252 {
253         *snr = 0;
254         return 0;
255 }
256
257 static int ec100_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
258 {
259         *ucblocks = 0;
260         return 0;
261 }
262
263 static void ec100_release(struct dvb_frontend *fe)
264 {
265         struct ec100_state *state = fe->demodulator_priv;
266         kfree(state);
267 }
268
269 static const struct dvb_frontend_ops ec100_ops;
270
271 struct dvb_frontend *ec100_attach(const struct ec100_config *config,
272         struct i2c_adapter *i2c)
273 {
274         int ret;
275         struct ec100_state *state = NULL;
276         u8 tmp;
277
278         /* allocate memory for the internal state */
279         state = kzalloc(sizeof(struct ec100_state), GFP_KERNEL);
280         if (state == NULL)
281                 goto error;
282
283         /* setup the state */
284         state->i2c = i2c;
285         memcpy(&state->config, config, sizeof(struct ec100_config));
286
287         /* check if the demod is there */
288         ret = ec100_read_reg(state, 0x33, &tmp);
289         if (ret || tmp != 0x0b)
290                 goto error;
291
292         /* create dvb_frontend */
293         memcpy(&state->frontend.ops, &ec100_ops,
294                 sizeof(struct dvb_frontend_ops));
295         state->frontend.demodulator_priv = state;
296
297         return &state->frontend;
298 error:
299         kfree(state);
300         return NULL;
301 }
302 EXPORT_SYMBOL(ec100_attach);
303
304 static const struct dvb_frontend_ops ec100_ops = {
305         .delsys = { SYS_DVBT },
306         .info = {
307                 .name = "E3C EC100 DVB-T",
308                 .caps =
309                         FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
310                         FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
311                         FE_CAN_QPSK | FE_CAN_QAM_16 |
312                         FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
313                         FE_CAN_TRANSMISSION_MODE_AUTO |
314                         FE_CAN_GUARD_INTERVAL_AUTO |
315                         FE_CAN_HIERARCHY_AUTO |
316                         FE_CAN_MUTE_TS
317         },
318
319         .release = ec100_release,
320         .set_frontend = ec100_set_frontend,
321         .get_tune_settings = ec100_get_tune_settings,
322         .read_status = ec100_read_status,
323         .read_ber = ec100_read_ber,
324         .read_signal_strength = ec100_read_signal_strength,
325         .read_snr = ec100_read_snr,
326         .read_ucblocks = ec100_read_ucblocks,
327 };
328
329 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
330 MODULE_DESCRIPTION("E3C EC100 DVB-T demodulator driver");
331 MODULE_LICENSE("GPL");