treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / media / usb / dvb-usb-v2 / mxl111sf-tuner.c
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 */
13 static int mxl111sf_tuner_debug;
14 module_param_named(debug, mxl111sf_tuner_debug, int, 0644);
15 MODULE_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
23 struct 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
34 static 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
42 static 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
50 static 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
58 static 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
68 static 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
78 static 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
124 static 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;
182 fail:
183         return ret;
184 }
185
186 static 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);
227 fail:
228         return ret;
229 }
230
231 static 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;
247 fail:
248         return ret;
249 }
250
251 #if 0
252 static 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
262 static 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;
306 fail:
307         return ret;
308 }
309
310 /* ------------------------------------------------------------------------ */
311
312 #if 0
313 static 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
323 static 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
336 static 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;
351 fail:
352         return ret;
353 }
354
355 static 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);
374 fail:
375         ret = mxl111sf_tuner_write_reg(state, 0x00, 0x00);
376         mxl_fail(ret);
377
378         return ret;
379 }
380
381 /* ------------------------------------------------------------------------ */
382
383 static 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
390 static 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
397 static 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
445 static 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
455 static 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
477 struct 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 }
498 EXPORT_SYMBOL_GPL(mxl111sf_tuner_attach);
499
500 MODULE_DESCRIPTION("MaxLinear MxL111SF CMOS tuner driver");
501 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
502 MODULE_LICENSE("GPL");
503 MODULE_VERSION("0.1");