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