1
2
3
4
5
6
7
8#include "mxl111sf-tuner.h"
9#include "mxl111sf-phy.h"
10#include "mxl111sf-reg.h"
11
12
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},
70
71 {0x1e, 0xff, 0x00},
72 {0x1f, 0xff, 0x00},
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
84 switch (bw) {
85 case 0:
86 filt_bw = 25;
87 break;
88 case 1:
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
106 freq /= 1000000;
107
108 freq *= 64;
109#if 0
110
111 freq += 0.5;
112#endif
113
114 mxl_phy_tune_rf[0].data = filt_bw;
115
116
117 mxl_phy_tune_rf[1].data = (freq & 0xff);
118 mxl_phy_tune_rf[2].data = (freq >> 8) & 0xff;
119
120
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
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
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
196 ret = mxl111sf_tuner_write_reg(state, START_TUNE_REG, 0);
197 if (mxl_fail(ret))
198 goto fail;
199
200
201 ret = mxl111sf_tuner_read_reg(state, MXL_MODE_REG, &mxl_mode);
202 if (mxl_fail(ret))
203 goto fail;
204
205
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
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;
276 break;
277 case SYS_DVBC_ANNEX_B:
278 bw = 1;
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
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
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:
406 *frequency = 4000000;
407 break;
408 case MXL_IF_4_5:
409 *frequency = 4500000;
410 break;
411 case MXL_IF_4_57:
412 *frequency = 4570000;
413 break;
414 case MXL_IF_5_0:
415 *frequency = 5000000;
416 break;
417 case MXL_IF_5_38:
418 *frequency = 5380000;
419 break;
420 case MXL_IF_6_0:
421 *frequency = 6000000;
422 break;
423 case MXL_IF_6_28:
424 *frequency = 6280000;
425 break;
426 case MXL_IF_7_2:
427 *frequency = 7200000;
428 break;
429 case MXL_IF_35_25:
430 *frequency = 35250000;
431 break;
432 case MXL_IF_36:
433 *frequency = 36000000;
434 break;
435 case MXL_IF_36_15:
436 *frequency = 36150000;
437 break;
438 case MXL_IF_44:
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
