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
25struct mxl301rf_state {
26 struct mxl301rf_config cfg;
27 struct i2c_client *i2c;
28};
29
30static struct mxl301rf_state *cfg_to_state(struct mxl301rf_config *c)
31{
32 return container_of(c, struct mxl301rf_state, cfg);
33}
34
35static 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
45static 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
52static 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 % */
68static 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 *rssi;
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 */
110struct 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
117static 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
137struct reg_val {
138 u8 reg;
139 u8 val;
140} __attribute__ ((__packed__));
141
142static 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
153static 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
223failed:
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
229static const struct reg_val standby_data[] = {
230 { 0x01, 0x00 },
231 { 0x13, 0x00 }
232};
233
234static 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 */
252static 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
270static 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
286static 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
309static 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
319static const struct i2c_device_id mxl301rf_id[] = {
320 {"mxl301rf", 0},
321 {}
322};
323MODULE_DEVICE_TABLE(i2c, mxl301rf_id);
324
325static 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
334module_i2c_driver(mxl301rf_driver);
335
336MODULE_DESCRIPTION("MaxLinear MXL301RF tuner");
337MODULE_AUTHOR("Akihiro TSUKADA");
338MODULE_LICENSE("GPL");
339

source code of linux/drivers/media/tuners/mxl301rf.c