1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * MaxLinear MxL301RF OFDM tuner driver |
4 | * |
5 | * Copyright (C) 2014 Akihiro Tsukada <tskd08@gmail.com> |
6 | */ |
7 | |
8 | /* |
9 | * NOTICE: |
10 | * This driver is incomplete and lacks init/config of the chips, |
11 | * as the necessary info is not disclosed. |
12 | * Other features like get_if_frequency() are missing as well. |
13 | * It assumes that users of this driver (such as a PCI bridge of |
14 | * DTV receiver cards) properly init and configure the chip |
15 | * via I2C *before* calling this driver's init() function. |
16 | * |
17 | * Currently, PT3 driver is the only one that uses this driver, |
18 | * and contains init/config code in its firmware. |
19 | * Thus some part of the code might be dependent on PT3 specific config. |
20 | */ |
21 | |
22 | #include <linux/kernel.h> |
23 | #include "mxl301rf.h" |
24 | |
25 | struct mxl301rf_state { |
26 | struct mxl301rf_config cfg; |
27 | struct i2c_client *i2c; |
28 | }; |
29 | |
30 | static struct mxl301rf_state *cfg_to_state(struct mxl301rf_config *c) |
31 | { |
32 | return container_of(c, struct mxl301rf_state, cfg); |
33 | } |
34 | |
35 | static int raw_write(struct mxl301rf_state *state, const u8 *buf, int len) |
36 | { |
37 | int ret; |
38 | |
39 | ret = i2c_master_send(client: state->i2c, buf, count: len); |
40 | if (ret >= 0 && ret < len) |
41 | ret = -EIO; |
42 | return (ret == len) ? 0 : ret; |
43 | } |
44 | |
45 | static int reg_write(struct mxl301rf_state *state, u8 reg, u8 val) |
46 | { |
47 | u8 buf[2] = { reg, val }; |
48 | |
49 | return raw_write(state, buf, len: 2); |
50 | } |
51 | |
52 | static int reg_read(struct mxl301rf_state *state, u8 reg, u8 *val) |
53 | { |
54 | u8 wbuf[2] = { 0xfb, reg }; |
55 | int ret; |
56 | |
57 | ret = raw_write(state, buf: wbuf, len: sizeof(wbuf)); |
58 | if (ret == 0) |
59 | ret = i2c_master_recv(client: state->i2c, buf: val, count: 1); |
60 | if (ret >= 0 && ret < 1) |
61 | ret = -EIO; |
62 | return (ret == 1) ? 0 : ret; |
63 | } |
64 | |
65 | /* tuner_ops */ |
66 | |
67 | /* get RSSI and update propery cache, set to *out in % */ |
68 | static int mxl301rf_get_rf_strength(struct dvb_frontend *fe, u16 *out) |
69 | { |
70 | struct mxl301rf_state *state; |
71 | int ret; |
72 | u8 rf_in1, rf_in2, rf_off1, rf_off2; |
73 | u16 rf_in, rf_off; |
74 | s64 level; |
75 | struct dtv_fe_stats *; |
76 | |
77 | rssi = &fe->dtv_property_cache.strength; |
78 | rssi->len = 1; |
79 | rssi->stat[0].scale = FE_SCALE_NOT_AVAILABLE; |
80 | *out = 0; |
81 | |
82 | state = fe->tuner_priv; |
83 | ret = reg_write(state, reg: 0x14, val: 0x01); |
84 | if (ret < 0) |
85 | return ret; |
86 | usleep_range(min: 1000, max: 2000); |
87 | |
88 | ret = reg_read(state, reg: 0x18, val: &rf_in1); |
89 | if (ret == 0) |
90 | ret = reg_read(state, reg: 0x19, val: &rf_in2); |
91 | if (ret == 0) |
92 | ret = reg_read(state, reg: 0xd6, val: &rf_off1); |
93 | if (ret == 0) |
94 | ret = reg_read(state, reg: 0xd7, val: &rf_off2); |
95 | if (ret != 0) |
96 | return ret; |
97 | |
98 | rf_in = (rf_in2 & 0x07) << 8 | rf_in1; |
99 | rf_off = (rf_off2 & 0x0f) << 5 | (rf_off1 >> 3); |
100 | level = rf_in - rf_off - (113 << 3); /* x8 dBm */ |
101 | level = level * 1000 / 8; |
102 | rssi->stat[0].svalue = level; |
103 | rssi->stat[0].scale = FE_SCALE_DECIBEL; |
104 | /* *out = (level - min) * 100 / (max - min) */ |
105 | *out = (rf_in - rf_off + (1 << 9) - 1) * 100 / ((5 << 9) - 2); |
106 | return 0; |
107 | } |
108 | |
109 | /* spur shift parameters */ |
110 | struct shf { |
111 | u32 freq; /* Channel center frequency */ |
112 | u32 ofst_th; /* Offset frequency threshold */ |
113 | u8 shf_val; /* Spur shift value */ |
114 | u8 shf_dir; /* Spur shift direction */ |
115 | }; |
116 | |
117 | static const struct shf shf_tab[] = { |
118 | { 64500, 500, 0x92, 0x07 }, |
119 | { 191500, 300, 0xe2, 0x07 }, |
120 | { 205500, 500, 0x2c, 0x04 }, |
121 | { 212500, 500, 0x1e, 0x04 }, |
122 | { 226500, 500, 0xd4, 0x07 }, |
123 | { 99143, 500, 0x9c, 0x07 }, |
124 | { 173143, 500, 0xd4, 0x07 }, |
125 | { 191143, 300, 0xd4, 0x07 }, |
126 | { 207143, 500, 0xce, 0x07 }, |
127 | { 225143, 500, 0xce, 0x07 }, |
128 | { 243143, 500, 0xd4, 0x07 }, |
129 | { 261143, 500, 0xd4, 0x07 }, |
130 | { 291143, 500, 0xd4, 0x07 }, |
131 | { 339143, 500, 0x2c, 0x04 }, |
132 | { 117143, 500, 0x7a, 0x07 }, |
133 | { 135143, 300, 0x7a, 0x07 }, |
134 | { 153143, 500, 0x01, 0x07 } |
135 | }; |
136 | |
137 | struct reg_val { |
138 | u8 reg; |
139 | u8 val; |
140 | } __attribute__ ((__packed__)); |
141 | |
142 | static const struct reg_val set_idac[] = { |
143 | { 0x0d, 0x00 }, |
144 | { 0x0c, 0x67 }, |
145 | { 0x6f, 0x89 }, |
146 | { 0x70, 0x0c }, |
147 | { 0x6f, 0x8a }, |
148 | { 0x70, 0x0e }, |
149 | { 0x6f, 0x8b }, |
150 | { 0x70, 0x1c }, |
151 | }; |
152 | |
153 | static int mxl301rf_set_params(struct dvb_frontend *fe) |
154 | { |
155 | struct reg_val tune0[] = { |
156 | { 0x13, 0x00 }, /* abort tuning */ |
157 | { 0x3b, 0xc0 }, |
158 | { 0x3b, 0x80 }, |
159 | { 0x10, 0x95 }, /* BW */ |
160 | { 0x1a, 0x05 }, |
161 | { 0x61, 0x00 }, /* spur shift value (placeholder) */ |
162 | { 0x62, 0xa0 } /* spur shift direction (placeholder) */ |
163 | }; |
164 | |
165 | struct reg_val tune1[] = { |
166 | { 0x11, 0x40 }, /* RF frequency L (placeholder) */ |
167 | { 0x12, 0x0e }, /* RF frequency H (placeholder) */ |
168 | { 0x13, 0x01 } /* start tune */ |
169 | }; |
170 | |
171 | struct mxl301rf_state *state; |
172 | u32 freq; |
173 | u16 f; |
174 | u32 tmp, div; |
175 | int i, ret; |
176 | |
177 | state = fe->tuner_priv; |
178 | freq = fe->dtv_property_cache.frequency; |
179 | |
180 | /* spur shift function (for analog) */ |
181 | for (i = 0; i < ARRAY_SIZE(shf_tab); i++) { |
182 | if (freq >= (shf_tab[i].freq - shf_tab[i].ofst_th) * 1000 && |
183 | freq <= (shf_tab[i].freq + shf_tab[i].ofst_th) * 1000) { |
184 | tune0[5].val = shf_tab[i].shf_val; |
185 | tune0[6].val = 0xa0 | shf_tab[i].shf_dir; |
186 | break; |
187 | } |
188 | } |
189 | ret = raw_write(state, buf: (u8 *) tune0, len: sizeof(tune0)); |
190 | if (ret < 0) |
191 | goto failed; |
192 | usleep_range(min: 3000, max: 4000); |
193 | |
194 | /* convert freq to 10.6 fixed point float [MHz] */ |
195 | f = freq / 1000000; |
196 | tmp = freq % 1000000; |
197 | div = 1000000; |
198 | for (i = 0; i < 6; i++) { |
199 | f <<= 1; |
200 | div >>= 1; |
201 | if (tmp > div) { |
202 | tmp -= div; |
203 | f |= 1; |
204 | } |
205 | } |
206 | if (tmp > 7812) |
207 | f++; |
208 | tune1[0].val = f & 0xff; |
209 | tune1[1].val = f >> 8; |
210 | ret = raw_write(state, buf: (u8 *) tune1, len: sizeof(tune1)); |
211 | if (ret < 0) |
212 | goto failed; |
213 | msleep(msecs: 31); |
214 | |
215 | ret = reg_write(state, reg: 0x1a, val: 0x0d); |
216 | if (ret < 0) |
217 | goto failed; |
218 | ret = raw_write(state, buf: (u8 *) set_idac, len: sizeof(set_idac)); |
219 | if (ret < 0) |
220 | goto failed; |
221 | return 0; |
222 | |
223 | failed: |
224 | dev_warn(&state->i2c->dev, "(%s) failed. [adap%d-fe%d]\n" , |
225 | __func__, fe->dvb->num, fe->id); |
226 | return ret; |
227 | } |
228 | |
229 | static const struct reg_val standby_data[] = { |
230 | { 0x01, 0x00 }, |
231 | { 0x13, 0x00 } |
232 | }; |
233 | |
234 | static int mxl301rf_sleep(struct dvb_frontend *fe) |
235 | { |
236 | struct mxl301rf_state *state; |
237 | int ret; |
238 | |
239 | state = fe->tuner_priv; |
240 | ret = raw_write(state, buf: (u8 *)standby_data, len: sizeof(standby_data)); |
241 | if (ret < 0) |
242 | dev_warn(&state->i2c->dev, "(%s) failed. [adap%d-fe%d]\n" , |
243 | __func__, fe->dvb->num, fe->id); |
244 | return ret; |
245 | } |
246 | |
247 | |
248 | /* init sequence is not public. |
249 | * the parent must have init'ed the device. |
250 | * just wake up here. |
251 | */ |
252 | static int mxl301rf_init(struct dvb_frontend *fe) |
253 | { |
254 | struct mxl301rf_state *state; |
255 | int ret; |
256 | |
257 | state = fe->tuner_priv; |
258 | |
259 | ret = reg_write(state, reg: 0x01, val: 0x01); |
260 | if (ret < 0) { |
261 | dev_warn(&state->i2c->dev, "(%s) failed. [adap%d-fe%d]\n" , |
262 | __func__, fe->dvb->num, fe->id); |
263 | return ret; |
264 | } |
265 | return 0; |
266 | } |
267 | |
268 | /* I2C driver functions */ |
269 | |
270 | static const struct dvb_tuner_ops mxl301rf_ops = { |
271 | .info = { |
272 | .name = "MaxLinear MxL301RF" , |
273 | |
274 | .frequency_min_hz = 93 * MHz, |
275 | .frequency_max_hz = 803 * MHz + 142857, |
276 | }, |
277 | |
278 | .init = mxl301rf_init, |
279 | .sleep = mxl301rf_sleep, |
280 | |
281 | .set_params = mxl301rf_set_params, |
282 | .get_rf_strength = mxl301rf_get_rf_strength, |
283 | }; |
284 | |
285 | |
286 | static int mxl301rf_probe(struct i2c_client *client) |
287 | { |
288 | struct mxl301rf_state *state; |
289 | struct mxl301rf_config *cfg; |
290 | struct dvb_frontend *fe; |
291 | |
292 | state = kzalloc(size: sizeof(*state), GFP_KERNEL); |
293 | if (!state) |
294 | return -ENOMEM; |
295 | |
296 | state->i2c = client; |
297 | cfg = client->dev.platform_data; |
298 | |
299 | memcpy(&state->cfg, cfg, sizeof(state->cfg)); |
300 | fe = cfg->fe; |
301 | fe->tuner_priv = state; |
302 | memcpy(&fe->ops.tuner_ops, &mxl301rf_ops, sizeof(mxl301rf_ops)); |
303 | |
304 | i2c_set_clientdata(client, data: &state->cfg); |
305 | dev_info(&client->dev, "MaxLinear MxL301RF attached.\n" ); |
306 | return 0; |
307 | } |
308 | |
309 | static void mxl301rf_remove(struct i2c_client *client) |
310 | { |
311 | struct mxl301rf_state *state; |
312 | |
313 | state = cfg_to_state(c: i2c_get_clientdata(client)); |
314 | state->cfg.fe->tuner_priv = NULL; |
315 | kfree(objp: state); |
316 | } |
317 | |
318 | |
319 | static const struct i2c_device_id mxl301rf_id[] = { |
320 | {"mxl301rf" , 0}, |
321 | {} |
322 | }; |
323 | MODULE_DEVICE_TABLE(i2c, mxl301rf_id); |
324 | |
325 | static struct i2c_driver mxl301rf_driver = { |
326 | .driver = { |
327 | .name = "mxl301rf" , |
328 | }, |
329 | .probe = mxl301rf_probe, |
330 | .remove = mxl301rf_remove, |
331 | .id_table = mxl301rf_id, |
332 | }; |
333 | |
334 | module_i2c_driver(mxl301rf_driver); |
335 | |
336 | MODULE_DESCRIPTION("MaxLinear MXL301RF tuner" ); |
337 | MODULE_AUTHOR("Akihiro TSUKADA" ); |
338 | MODULE_LICENSE("GPL" ); |
339 | |