xref: /openbmc/linux/drivers/media/tuners/mxl301rf.c (revision aaeb31c0)
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 
cfg_to_state(struct mxl301rf_config * c)30 static struct mxl301rf_state *cfg_to_state(struct mxl301rf_config *c)
31 {
32 	return container_of(c, struct mxl301rf_state, cfg);
33 }
34 
raw_write(struct mxl301rf_state * state,const u8 * buf,int len)35 static int raw_write(struct mxl301rf_state *state, const u8 *buf, int len)
36 {
37 	int ret;
38 
39 	ret = i2c_master_send(state->i2c, buf, len);
40 	if (ret >= 0 && ret < len)
41 		ret = -EIO;
42 	return (ret == len) ? 0 : ret;
43 }
44 
reg_write(struct mxl301rf_state * state,u8 reg,u8 val)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, 2);
50 }
51 
reg_read(struct mxl301rf_state * state,u8 reg,u8 * val)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, wbuf, sizeof(wbuf));
58 	if (ret == 0)
59 		ret = i2c_master_recv(state->i2c, val, 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 % */
mxl301rf_get_rf_strength(struct dvb_frontend * fe,u16 * out)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 *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, 0x14, 0x01);
84 	if (ret < 0)
85 		return ret;
86 	usleep_range(1000, 2000);
87 
88 	ret = reg_read(state, 0x18, &rf_in1);
89 	if (ret == 0)
90 		ret = reg_read(state, 0x19, &rf_in2);
91 	if (ret == 0)
92 		ret = reg_read(state, 0xd6, &rf_off1);
93 	if (ret == 0)
94 		ret = reg_read(state, 0xd7, &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 
mxl301rf_set_params(struct dvb_frontend * fe)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, (u8 *) tune0, sizeof(tune0));
190 	if (ret < 0)
191 		goto failed;
192 	usleep_range(3000, 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, (u8 *) tune1, sizeof(tune1));
211 	if (ret < 0)
212 		goto failed;
213 	msleep(31);
214 
215 	ret = reg_write(state, 0x1a, 0x0d);
216 	if (ret < 0)
217 		goto failed;
218 	ret = raw_write(state, (u8 *) set_idac, 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 
mxl301rf_sleep(struct dvb_frontend * fe)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, (u8 *)standby_data, 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  */
mxl301rf_init(struct dvb_frontend * fe)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, 0x01, 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 
mxl301rf_probe(struct i2c_client * client)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(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, &state->cfg);
305 	dev_info(&client->dev, "MaxLinear MxL301RF attached.\n");
306 	return 0;
307 }
308 
mxl301rf_remove(struct i2c_client * client)309 static void mxl301rf_remove(struct i2c_client *client)
310 {
311 	struct mxl301rf_state *state;
312 
313 	state = cfg_to_state(i2c_get_clientdata(client));
314 	state->cfg.fe->tuner_priv = NULL;
315 	kfree(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