1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 *  mxl111sf-tuner.c - driver for the MaxLinear MXL111SF CMOS tuner
4 *
5 *  Copyright (C) 2010-2014 Michael Krufky <mkrufky@linuxtv.org>
6 */
7
8#include "mxl111sf-tuner.h"
9#include "mxl111sf-phy.h"
10#include "mxl111sf-reg.h"
11
12/* debug */
13static int mxl111sf_tuner_debug;
14module_param_named(debug, mxl111sf_tuner_debug, int, 0644);
15MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able)).");
16
17#define mxl_dbg(fmt, arg...) \
18	if (mxl111sf_tuner_debug) \
19		mxl_printk(KERN_DEBUG, fmt, ##arg)
20
21/* ------------------------------------------------------------------------ */
22
23struct mxl111sf_tuner_state {
24	struct mxl111sf_state *mxl_state;
25
26	const struct mxl111sf_tuner_config *cfg;
27
28	enum mxl_if_freq if_freq;
29
30	u32 frequency;
31	u32 bandwidth;
32};
33
34static int mxl111sf_tuner_read_reg(struct mxl111sf_tuner_state *state,
35				   u8 addr, u8 *data)
36{
37	return (state->cfg->read_reg) ?
38		state->cfg->read_reg(state->mxl_state, addr, data) :
39		-EINVAL;
40}
41
42static int mxl111sf_tuner_write_reg(struct mxl111sf_tuner_state *state,
43				    u8 addr, u8 data)
44{
45	return (state->cfg->write_reg) ?
46		state->cfg->write_reg(state->mxl_state, addr, data) :
47		-EINVAL;
48}
49
50static int mxl111sf_tuner_program_regs(struct mxl111sf_tuner_state *state,
51			       struct mxl111sf_reg_ctrl_info *ctrl_reg_info)
52{
53	return (state->cfg->program_regs) ?
54		state->cfg->program_regs(state->mxl_state, ctrl_reg_info) :
55		-EINVAL;
56}
57
58static int mxl1x1sf_tuner_top_master_ctrl(struct mxl111sf_tuner_state *state,
59					  int onoff)
60{
61	return (state->cfg->top_master_ctrl) ?
62		state->cfg->top_master_ctrl(state->mxl_state, onoff) :
63		-EINVAL;
64}
65
66/* ------------------------------------------------------------------------ */
67
68static struct mxl111sf_reg_ctrl_info mxl_phy_tune_rf[] = {
69	{0x1d, 0x7f, 0x00}, /* channel bandwidth section 1/2/3,
70			       DIG_MODEINDEX, _A, _CSF, */
71	{0x1e, 0xff, 0x00}, /* channel frequency (lo and fractional) */
72	{0x1f, 0xff, 0x00}, /* channel frequency (hi for integer portion) */
73	{0,    0,    0}
74};
75
76/* ------------------------------------------------------------------------ */
77
78static struct mxl111sf_reg_ctrl_info *mxl111sf_calc_phy_tune_regs(u32 freq,
79								  u8 bw)
80{
81	u8 filt_bw;
82
83	/* set channel bandwidth */
84	switch (bw) {
85	case 0: /* ATSC */
86		filt_bw = 25;
87		break;
88	case 1: /* QAM */
89		filt_bw = 69;
90		break;
91	case 6:
92		filt_bw = 21;
93		break;
94	case 7:
95		filt_bw = 42;
96		break;
97	case 8:
98		filt_bw = 63;
99		break;
100	default:
101		pr_err("%s: invalid bandwidth setting!", __func__);
102		return NULL;
103	}
104
105	/* calculate RF channel */
106	freq /= 1000000;
107
108	freq *= 64;
109#if 0
110	/* do round */
111	freq += 0.5;
112#endif
113	/* set bandwidth */
114	mxl_phy_tune_rf[0].data = filt_bw;
115
116	/* set RF */
117	mxl_phy_tune_rf[1].data = (freq & 0xff);
118	mxl_phy_tune_rf[2].data = (freq >> 8) & 0xff;
119
120	/* start tune */
121	return mxl_phy_tune_rf;
122}
123
124static int mxl1x1sf_tuner_set_if_output_freq(struct mxl111sf_tuner_state *state)
125{
126	int ret;
127	u8 ctrl;
128#if 0
129	u16 iffcw;
130	u32 if_freq;
131#endif
132	mxl_dbg("(IF polarity = %d, IF freq = 0x%02x)",
133		state->cfg->invert_spectrum, state->cfg->if_freq);
134
135	/* set IF polarity */
136	ctrl = state->cfg->invert_spectrum;
137
138	ctrl |= state->cfg->if_freq;
139
140	ret = mxl111sf_tuner_write_reg(state, V6_TUNER_IF_SEL_REG, ctrl);
141	if (mxl_fail(ret))
142		goto fail;
143
144#if 0
145	if_freq /= 1000000;
146
147	/* do round */
148	if_freq += 0.5;
149
150	if (MXL_IF_LO == state->cfg->if_freq) {
151		ctrl = 0x08;
152		iffcw = (u16)(if_freq / (108 * 4096));
153	} else if (MXL_IF_HI == state->cfg->if_freq) {
154		ctrl = 0x08;
155		iffcw = (u16)(if_freq / (216 * 4096));
156	} else {
157		ctrl = 0;
158		iffcw = 0;
159	}
160
161	ctrl |= (iffcw >> 8);
162#endif
163	ret = mxl111sf_tuner_read_reg(state, V6_TUNER_IF_FCW_BYP_REG, &ctrl);
164	if (mxl_fail(ret))
165		goto fail;
166
167	ctrl &= 0xf0;
168	ctrl |= 0x90;
169
170	ret = mxl111sf_tuner_write_reg(state, V6_TUNER_IF_FCW_BYP_REG, ctrl);
171	if (mxl_fail(ret))
172		goto fail;
173
174#if 0
175	ctrl = iffcw & 0x00ff;
176#endif
177	ret = mxl111sf_tuner_write_reg(state, V6_TUNER_IF_FCW_REG, ctrl);
178	if (mxl_fail(ret))
179		goto fail;
180
181	state->if_freq = state->cfg->if_freq;
182fail:
183	return ret;
184}
185
186static int mxl1x1sf_tune_rf(struct dvb_frontend *fe, u32 freq, u8 bw)
187{
188	struct mxl111sf_tuner_state *state = fe->tuner_priv;
189	static struct mxl111sf_reg_ctrl_info *reg_ctrl_array;
190	int ret;
191	u8 mxl_mode;
192
193	mxl_dbg("(freq = %d, bw = 0x%x)", freq, bw);
194
195	/* stop tune */
196	ret = mxl111sf_tuner_write_reg(state, START_TUNE_REG, 0);
197	if (mxl_fail(ret))
198		goto fail;
199
200	/* check device mode */
201	ret = mxl111sf_tuner_read_reg(state, MXL_MODE_REG, &mxl_mode);
202	if (mxl_fail(ret))
203		goto fail;
204
205	/* Fill out registers for channel tune */
206	reg_ctrl_array = mxl111sf_calc_phy_tune_regs(freq, bw);
207	if (!reg_ctrl_array)
208		return -EINVAL;
209
210	ret = mxl111sf_tuner_program_regs(state, reg_ctrl_array);
211	if (mxl_fail(ret))
212		goto fail;
213
214	if ((mxl_mode & MXL_DEV_MODE_MASK) == MXL_TUNER_MODE) {
215		/* IF tuner mode only */
216		mxl1x1sf_tuner_top_master_ctrl(state, 0);
217		mxl1x1sf_tuner_top_master_ctrl(state, 1);
218		mxl1x1sf_tuner_set_if_output_freq(state);
219	}
220
221	ret = mxl111sf_tuner_write_reg(state, START_TUNE_REG, 1);
222	if (mxl_fail(ret))
223		goto fail;
224
225	if (state->cfg->ant_hunt)
226		state->cfg->ant_hunt(fe);
227fail:
228	return ret;
229}
230
231static int mxl1x1sf_tuner_get_lock_status(struct mxl111sf_tuner_state *state,
232					  int *rf_synth_lock,
233					  int *ref_synth_lock)
234{
235	int ret;
236	u8 data;
237
238	*rf_synth_lock = 0;
239	*ref_synth_lock = 0;
240
241	ret = mxl111sf_tuner_read_reg(state, V6_RF_LOCK_STATUS_REG, &data);
242	if (mxl_fail(ret))
243		goto fail;
244
245	*ref_synth_lock = ((data & 0x03) == 0x03) ? 1 : 0;
246	*rf_synth_lock  = ((data & 0x0c) == 0x0c) ? 1 : 0;
247fail:
248	return ret;
249}
250
251#if 0
252static int mxl1x1sf_tuner_loop_thru_ctrl(struct mxl111sf_tuner_state *state,
253					 int onoff)
254{
255	return mxl111sf_tuner_write_reg(state, V6_TUNER_LOOP_THRU_CTRL_REG,
256					onoff ? 1 : 0);
257}
258#endif
259
260/* ------------------------------------------------------------------------ */
261
262static int mxl111sf_tuner_set_params(struct dvb_frontend *fe)
263{
264	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
265	u32 delsys  = c->delivery_system;
266	struct mxl111sf_tuner_state *state = fe->tuner_priv;
267	int ret;
268	u8 bw;
269
270	mxl_dbg("()");
271
272	switch (delsys) {
273	case SYS_ATSC:
274	case SYS_ATSCMH:
275		bw = 0; /* ATSC */
276		break;
277	case SYS_DVBC_ANNEX_B:
278		bw = 1; /* US CABLE */
279		break;
280	case SYS_DVBT:
281		switch (c->bandwidth_hz) {
282		case 6000000:
283			bw = 6;
284			break;
285		case 7000000:
286			bw = 7;
287			break;
288		case 8000000:
289			bw = 8;
290			break;
291		default:
292			pr_err("%s: bandwidth not set!", __func__);
293			return -EINVAL;
294		}
295		break;
296	default:
297		pr_err("%s: modulation type not supported!", __func__);
298		return -EINVAL;
299	}
300	ret = mxl1x1sf_tune_rf(fe, c->frequency, bw);
301	if (mxl_fail(ret))
302		goto fail;
303
304	state->frequency = c->frequency;
305	state->bandwidth = c->bandwidth_hz;
306fail:
307	return ret;
308}
309
310/* ------------------------------------------------------------------------ */
311
312#if 0
313static int mxl111sf_tuner_init(struct dvb_frontend *fe)
314{
315	struct mxl111sf_tuner_state *state = fe->tuner_priv;
316	int ret;
317
318	/* wake from standby handled by usb driver */
319
320	return ret;
321}
322
323static int mxl111sf_tuner_sleep(struct dvb_frontend *fe)
324{
325	struct mxl111sf_tuner_state *state = fe->tuner_priv;
326	int ret;
327
328	/* enter standby mode handled by usb driver */
329
330	return ret;
331}
332#endif
333
334/* ------------------------------------------------------------------------ */
335
336static int mxl111sf_tuner_get_status(struct dvb_frontend *fe, u32 *status)
337{
338	struct mxl111sf_tuner_state *state = fe->tuner_priv;
339	int rf_locked, ref_locked, ret;
340
341	*status = 0;
342
343	ret = mxl1x1sf_tuner_get_lock_status(state, &rf_locked, &ref_locked);
344	if (mxl_fail(ret))
345		goto fail;
346	mxl_info("%s%s", rf_locked ? "rf locked " : "",
347		 ref_locked ? "ref locked" : "");
348
349	if ((rf_locked) || (ref_locked))
350		*status |= TUNER_STATUS_LOCKED;
351fail:
352	return ret;
353}
354
355static int mxl111sf_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
356{
357	struct mxl111sf_tuner_state *state = fe->tuner_priv;
358	u8 val1, val2;
359	int ret;
360
361	*strength = 0;
362
363	ret = mxl111sf_tuner_write_reg(state, 0x00, 0x02);
364	if (mxl_fail(ret))
365		goto fail;
366	ret = mxl111sf_tuner_read_reg(state, V6_DIG_RF_PWR_LSB_REG, &val1);
367	if (mxl_fail(ret))
368		goto fail;
369	ret = mxl111sf_tuner_read_reg(state, V6_DIG_RF_PWR_MSB_REG, &val2);
370	if (mxl_fail(ret))
371		goto fail;
372
373	*strength = val1 | ((val2 & 0x07) << 8);
374fail:
375	ret = mxl111sf_tuner_write_reg(state, 0x00, 0x00);
376	mxl_fail(ret);
377
378	return ret;
379}
380
381/* ------------------------------------------------------------------------ */
382
383static int mxl111sf_tuner_get_frequency(struct dvb_frontend *fe, u32 *frequency)
384{
385	struct mxl111sf_tuner_state *state = fe->tuner_priv;
386	*frequency = state->frequency;
387	return 0;
388}
389
390static int mxl111sf_tuner_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
391{
392	struct mxl111sf_tuner_state *state = fe->tuner_priv;
393	*bandwidth = state->bandwidth;
394	return 0;
395}
396
397static int mxl111sf_tuner_get_if_frequency(struct dvb_frontend *fe,
398					   u32 *frequency)
399{
400	struct mxl111sf_tuner_state *state = fe->tuner_priv;
401
402	*frequency = 0;
403
404	switch (state->if_freq) {
405	case MXL_IF_4_0:   /* 4.0   MHz */
406		*frequency = 4000000;
407		break;
408	case MXL_IF_4_5:   /* 4.5   MHz */
409		*frequency = 4500000;
410		break;
411	case MXL_IF_4_57:  /* 4.57  MHz */
412		*frequency = 4570000;
413		break;
414	case MXL_IF_5_0:   /* 5.0   MHz */
415		*frequency = 5000000;
416		break;
417	case MXL_IF_5_38:  /* 5.38  MHz */
418		*frequency = 5380000;
419		break;
420	case MXL_IF_6_0:   /* 6.0   MHz */
421		*frequency = 6000000;
422		break;
423	case MXL_IF_6_28:  /* 6.28  MHz */
424		*frequency = 6280000;
425		break;
426	case MXL_IF_7_2:   /* 7.2   MHz */
427		*frequency = 7200000;
428		break;
429	case MXL_IF_35_25: /* 35.25 MHz */
430		*frequency = 35250000;
431		break;
432	case MXL_IF_36:    /* 36    MHz */
433		*frequency = 36000000;
434		break;
435	case MXL_IF_36_15: /* 36.15 MHz */
436		*frequency = 36150000;
437		break;
438	case MXL_IF_44:    /* 44    MHz */
439		*frequency = 44000000;
440		break;
441	}
442	return 0;
443}
444
445static void mxl111sf_tuner_release(struct dvb_frontend *fe)
446{
447	struct mxl111sf_tuner_state *state = fe->tuner_priv;
448	mxl_dbg("()");
449	kfree(state);
450	fe->tuner_priv = NULL;
451}
452
453/* ------------------------------------------------------------------------- */
454
455static const struct dvb_tuner_ops mxl111sf_tuner_tuner_ops = {
456	.info = {
457		.name = "MaxLinear MxL111SF",
458#if 0
459		.frequency_min_hz  = ,
460		.frequency_max_hz  = ,
461		.frequency_step_hz = ,
462#endif
463	},
464#if 0
465	.init              = mxl111sf_tuner_init,
466	.sleep             = mxl111sf_tuner_sleep,
467#endif
468	.set_params        = mxl111sf_tuner_set_params,
469	.get_status        = mxl111sf_tuner_get_status,
470	.get_rf_strength   = mxl111sf_get_rf_strength,
471	.get_frequency     = mxl111sf_tuner_get_frequency,
472	.get_bandwidth     = mxl111sf_tuner_get_bandwidth,
473	.get_if_frequency  = mxl111sf_tuner_get_if_frequency,
474	.release           = mxl111sf_tuner_release,
475};
476
477struct dvb_frontend *mxl111sf_tuner_attach(struct dvb_frontend *fe,
478				struct mxl111sf_state *mxl_state,
479				const struct mxl111sf_tuner_config *cfg)
480{
481	struct mxl111sf_tuner_state *state = NULL;
482
483	mxl_dbg("()");
484
485	state = kzalloc(sizeof(struct mxl111sf_tuner_state), GFP_KERNEL);
486	if (state == NULL)
487		return NULL;
488
489	state->mxl_state = mxl_state;
490	state->cfg = cfg;
491
492	memcpy(&fe->ops.tuner_ops, &mxl111sf_tuner_tuner_ops,
493	       sizeof(struct dvb_tuner_ops));
494
495	fe->tuner_priv = state;
496	return fe;
497}
498EXPORT_SYMBOL_GPL(mxl111sf_tuner_attach);
499
500MODULE_DESCRIPTION("MaxLinear MxL111SF CMOS tuner driver");
501MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
502MODULE_LICENSE("GPL");
503MODULE_VERSION("0.1");
504