?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'io_uring-5.11-2021-01-16' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / media / tuners / msi001.c
blob78e6fd600d8ef77ec60fd1e55aa96feaaf90827f
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Mirics MSi001 silicon tuner driver
4 *
5 * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
6 * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
7 */
8
9 #include <linux/module.h>
10 #include <linux/gcd.h>
11 #include <media/v4l2-device.h>
12 #include <media/v4l2-ctrls.h>
13
14 static const struct v4l2_frequency_band bands[] = {
15 {
16 .type = V4L2_TUNER_RF,
17 .index = 0,
18 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
19 .rangelow = 49000000,
20 .rangehigh = 263000000,
21 }, {
22 .type = V4L2_TUNER_RF,
23 .index = 1,
24 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
25 .rangelow = 390000000,
26 .rangehigh = 960000000,
27 },
28 };
29
30 struct msi001_dev {
31 struct spi_device *spi;
32 struct v4l2_subdev sd;
33
34 /* Controls */
35 struct v4l2_ctrl_handler hdl;
36 struct v4l2_ctrl *bandwidth_auto;
37 struct v4l2_ctrl *bandwidth;
38 struct v4l2_ctrl *lna_gain;
39 struct v4l2_ctrl *mixer_gain;
40 struct v4l2_ctrl *if_gain;
41
42 unsigned int f_tuner;
43 };
44
45 static inline struct msi001_dev *sd_to_msi001_dev(struct v4l2_subdev *sd)
46 {
47 return container_of(sd, struct msi001_dev, sd);
48 }
49
50 static int msi001_wreg(struct msi001_dev *dev, u32 data)
51 {
52 /* Register format: 4 bits addr + 20 bits value */
53 return spi_write(dev->spi, &data, 3);
54 };
55
56 static int msi001_set_gain(struct msi001_dev *dev, int lna_gain, int mixer_gain,
57 int if_gain)
58 {
59 struct spi_device *spi = dev->spi;
60 int ret;
61 u32 reg;
62
63 dev_dbg(&spi->dev, "lna=%d mixer=%d if=%d\n",
64 lna_gain, mixer_gain, if_gain);
65
66 reg = 1 << 0;
67 reg |= (59 - if_gain) << 4;
68 reg |= 0 << 10;
69 reg |= (1 - mixer_gain) << 12;
70 reg |= (1 - lna_gain) << 13;
71 reg |= 4 << 14;
72 reg |= 0 << 17;
73 ret = msi001_wreg(dev, reg);
74 if (ret)
75 goto err;
76
77 return 0;
78 err:
79 dev_dbg(&spi->dev, "failed %d\n", ret);
80 return ret;
81 };
82
83 static int msi001_set_tuner(struct msi001_dev *dev)
84 {
85 struct spi_device *spi = dev->spi;
86 int ret, i;
87 unsigned int uitmp, div_n, k, k_thresh, k_frac, div_lo, f_if1;
88 u32 reg;
89 u64 f_vco;
90 u8 mode, filter_mode;
91
92 static const struct {
93 u32 rf;
94 u8 mode;
95 u8 div_lo;
96 } band_lut[] = {
97 { 50000000, 0xe1, 16}, /* AM_MODE2, antenna 2 */
98 {108000000, 0x42, 32}, /* VHF_MODE */
99 {330000000, 0x44, 16}, /* B3_MODE */
100 {960000000, 0x48, 4}, /* B45_MODE */
101 { ~0U, 0x50, 2}, /* BL_MODE */
102 };
103 static const struct {
104 u32 freq;
105 u8 filter_mode;
106 } if_freq_lut[] = {
107 { 0, 0x03}, /* Zero IF */
108 { 450000, 0x02}, /* 450 kHz IF */
109 {1620000, 0x01}, /* 1.62 MHz IF */
110 {2048000, 0x00}, /* 2.048 MHz IF */
111 };
112 static const struct {
113 u32 freq;
114 u8 val;
115 } bandwidth_lut[] = {
116 { 200000, 0x00}, /* 200 kHz */
117 { 300000, 0x01}, /* 300 kHz */
118 { 600000, 0x02}, /* 600 kHz */
119 {1536000, 0x03}, /* 1.536 MHz */
120 {5000000, 0x04}, /* 5 MHz */
121 {6000000, 0x05}, /* 6 MHz */
122 {7000000, 0x06}, /* 7 MHz */
123 {8000000, 0x07}, /* 8 MHz */
124 };
125
126 unsigned int f_rf = dev->f_tuner;
127
128 /*
129 * bandwidth (Hz)
130 * 200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000
131 */
132 unsigned int bandwidth;
133
134 /*
135 * intermediate frequency (Hz)
136 * 0, 450000, 1620000, 2048000
137 */
138 unsigned int f_if = 0;
139 #define F_REF 24000000
140 #define DIV_PRE_N 4
141 #define F_VCO_STEP div_lo
142
143 dev_dbg(&spi->dev, "f_rf=%d f_if=%d\n", f_rf, f_if);
144
145 for (i = 0; i < ARRAY_SIZE(band_lut); i++) {
146 if (f_rf <= band_lut[i].rf) {
147 mode = band_lut[i].mode;
148 div_lo = band_lut[i].div_lo;
149 break;
150 }
151 }
152 if (i == ARRAY_SIZE(band_lut)) {
153 ret = -EINVAL;
154 goto err;
155 }
156
157 /* AM_MODE is upconverted */
158 if ((mode >> 0) & 0x1)
159 f_if1 = 5 * F_REF;
160 else
161 f_if1 = 0;
162
163 for (i = 0; i < ARRAY_SIZE(if_freq_lut); i++) {
164 if (f_if == if_freq_lut[i].freq) {
165 filter_mode = if_freq_lut[i].filter_mode;
166 break;
167 }
168 }
169 if (i == ARRAY_SIZE(if_freq_lut)) {
170 ret = -EINVAL;
171 goto err;
172 }
173
174 /* filters */
175 bandwidth = dev->bandwidth->val;
176 bandwidth = clamp(bandwidth, 200000U, 8000000U);
177
178 for (i = 0; i < ARRAY_SIZE(bandwidth_lut); i++) {
179 if (bandwidth <= bandwidth_lut[i].freq) {
180 bandwidth = bandwidth_lut[i].val;
181 break;
182 }
183 }
184 if (i == ARRAY_SIZE(bandwidth_lut)) {
185 ret = -EINVAL;
186 goto err;
187 }
188
189 dev->bandwidth->val = bandwidth_lut[i].freq;
190
191 dev_dbg(&spi->dev, "bandwidth selected=%d\n", bandwidth_lut[i].freq);
192
193 /*
194 * Fractional-N synthesizer
195 *
196 * +---------------------------------------+
197 * v |
198 * Fref +----+ +-------+ +----+ +------+ +---+
199 * ------> | PD | --> | VCO | ------> | /4 | --> | /N.F | <-- | K |
200 * +----+ +-------+ +----+ +------+ +---+
201 * |
202 * |
203 * v
204 * +-------+ Fout
205 * | /Rout | ------>
206 * +-------+
207 */
208
209 /* Calculate PLL integer and fractional control word. */
210 f_vco = (u64) (f_rf + f_if + f_if1) * div_lo;
211 div_n = div_u64_rem(f_vco, DIV_PRE_N * F_REF, &k);
212 k_thresh = (DIV_PRE_N * F_REF) / F_VCO_STEP;
213 k_frac = div_u64((u64) k * k_thresh, (DIV_PRE_N * F_REF));
214
215 /* Find out greatest common divisor and divide to smaller. */
216 uitmp = gcd(k_thresh, k_frac);
217 k_thresh /= uitmp;
218 k_frac /= uitmp;
219
220 /* Force divide to reg max. Resolution will be reduced. */
221 uitmp = DIV_ROUND_UP(k_thresh, 4095);
222 k_thresh = DIV_ROUND_CLOSEST(k_thresh, uitmp);
223 k_frac = DIV_ROUND_CLOSEST(k_frac, uitmp);
224
225 /* Calculate real RF set. */
226 uitmp = (unsigned int) F_REF * DIV_PRE_N * div_n;
227 uitmp += (unsigned int) F_REF * DIV_PRE_N * k_frac / k_thresh;
228 uitmp /= div_lo;
229
230 dev_dbg(&spi->dev,
231 "f_rf=%u:%u f_vco=%llu div_n=%u k_thresh=%u k_frac=%u div_lo=%u\n",
232 f_rf, uitmp, f_vco, div_n, k_thresh, k_frac, div_lo);
233
234 ret = msi001_wreg(dev, 0x00000e);
235 if (ret)
236 goto err;
237
238 ret = msi001_wreg(dev, 0x000003);
239 if (ret)
240 goto err;
241
242 reg = 0 << 0;
243 reg |= mode << 4;
244 reg |= filter_mode << 12;
245 reg |= bandwidth << 14;
246 reg |= 0x02 << 17;
247 reg |= 0x00 << 20;
248 ret = msi001_wreg(dev, reg);
249 if (ret)
250 goto err;
251
252 reg = 5 << 0;
253 reg |= k_thresh << 4;
254 reg |= 1 << 19;
255 reg |= 1 << 21;
256 ret = msi001_wreg(dev, reg);
257 if (ret)
258 goto err;
259
260 reg = 2 << 0;
261 reg |= k_frac << 4;
262 reg |= div_n << 16;
263 ret = msi001_wreg(dev, reg);
264 if (ret)
265 goto err;
266
267 ret = msi001_set_gain(dev, dev->lna_gain->cur.val,
268 dev->mixer_gain->cur.val, dev->if_gain->cur.val);
269 if (ret)
270 goto err;
271
272 reg = 6 << 0;
273 reg |= 63 << 4;
274 reg |= 4095 << 10;
275 ret = msi001_wreg(dev, reg);
276 if (ret)
277 goto err;
278
279 return 0;
280 err:
281 dev_dbg(&spi->dev, "failed %d\n", ret);
282 return ret;
283 }
284
285 static int msi001_standby(struct v4l2_subdev *sd)
286 {
287 struct msi001_dev *dev = sd_to_msi001_dev(sd);
288
289 return msi001_wreg(dev, 0x000000);
290 }
291
292 static int msi001_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *v)
293 {
294 struct msi001_dev *dev = sd_to_msi001_dev(sd);
295 struct spi_device *spi = dev->spi;
296
297 dev_dbg(&spi->dev, "index=%d\n", v->index);
298
299 strscpy(v->name, "Mirics MSi001", sizeof(v->name));
300 v->type = V4L2_TUNER_RF;
301 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
302 v->rangelow = 49000000;
303 v->rangehigh = 960000000;
304
305 return 0;
306 }
307
308 static int msi001_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *v)
309 {
310 struct msi001_dev *dev = sd_to_msi001_dev(sd);
311 struct spi_device *spi = dev->spi;
312
313 dev_dbg(&spi->dev, "index=%d\n", v->index);
314 return 0;
315 }
316
317 static int msi001_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
318 {
319 struct msi001_dev *dev = sd_to_msi001_dev(sd);
320 struct spi_device *spi = dev->spi;
321
322 dev_dbg(&spi->dev, "tuner=%d\n", f->tuner);
323 f->frequency = dev->f_tuner;
324 return 0;
325 }
326
327 static int msi001_s_frequency(struct v4l2_subdev *sd,
328 const struct v4l2_frequency *f)
329 {
330 struct msi001_dev *dev = sd_to_msi001_dev(sd);
331 struct spi_device *spi = dev->spi;
332 unsigned int band;
333
334 dev_dbg(&spi->dev, "tuner=%d type=%d frequency=%u\n",
335 f->tuner, f->type, f->frequency);
336
337 if (f->frequency < ((bands[0].rangehigh + bands[1].rangelow) / 2))
338 band = 0;
339 else
340 band = 1;
341 dev->f_tuner = clamp_t(unsigned int, f->frequency,
342 bands[band].rangelow, bands[band].rangehigh);
343
344 return msi001_set_tuner(dev);
345 }
346
347 static int msi001_enum_freq_bands(struct v4l2_subdev *sd,
348 struct v4l2_frequency_band *band)
349 {
350 struct msi001_dev *dev = sd_to_msi001_dev(sd);
351 struct spi_device *spi = dev->spi;
352
353 dev_dbg(&spi->dev, "tuner=%d type=%d index=%d\n",
354 band->tuner, band->type, band->index);
355
356 if (band->index >= ARRAY_SIZE(bands))
357 return -EINVAL;
358
359 band->capability = bands[band->index].capability;
360 band->rangelow = bands[band->index].rangelow;
361 band->rangehigh = bands[band->index].rangehigh;
362
363 return 0;
364 }
365
366 static const struct v4l2_subdev_tuner_ops msi001_tuner_ops = {
367 .standby = msi001_standby,
368 .g_tuner = msi001_g_tuner,
369 .s_tuner = msi001_s_tuner,
370 .g_frequency = msi001_g_frequency,
371 .s_frequency = msi001_s_frequency,
372 .enum_freq_bands = msi001_enum_freq_bands,
373 };
374
375 static const struct v4l2_subdev_ops msi001_ops = {
376 .tuner = &msi001_tuner_ops,
377 };
378
379 static int msi001_s_ctrl(struct v4l2_ctrl *ctrl)
380 {
381 struct msi001_dev *dev = container_of(ctrl->handler, struct msi001_dev, hdl);
382 struct spi_device *spi = dev->spi;
383
384 int ret;
385
386 dev_dbg(&spi->dev, "id=%d name=%s val=%d min=%lld max=%lld step=%lld\n",
387 ctrl->id, ctrl->name, ctrl->val, ctrl->minimum, ctrl->maximum,
388 ctrl->step);
389
390 switch (ctrl->id) {
391 case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
392 case V4L2_CID_RF_TUNER_BANDWIDTH:
393 ret = msi001_set_tuner(dev);
394 break;
395 case V4L2_CID_RF_TUNER_LNA_GAIN:
396 ret = msi001_set_gain(dev, dev->lna_gain->val,
397 dev->mixer_gain->cur.val,
398 dev->if_gain->cur.val);
399 break;
400 case V4L2_CID_RF_TUNER_MIXER_GAIN:
401 ret = msi001_set_gain(dev, dev->lna_gain->cur.val,
402 dev->mixer_gain->val,
403 dev->if_gain->cur.val);
404 break;
405 case V4L2_CID_RF_TUNER_IF_GAIN:
406 ret = msi001_set_gain(dev, dev->lna_gain->cur.val,
407 dev->mixer_gain->cur.val,
408 dev->if_gain->val);
409 break;
410 default:
411 dev_dbg(&spi->dev, "unknown control %d\n", ctrl->id);
412 ret = -EINVAL;
413 }
414
415 return ret;
416 }
417
418 static const struct v4l2_ctrl_ops msi001_ctrl_ops = {
419 .s_ctrl = msi001_s_ctrl,
420 };
421
422 static int msi001_probe(struct spi_device *spi)
423 {
424 struct msi001_dev *dev;
425 int ret;
426
427 dev_dbg(&spi->dev, "\n");
428
429 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
430 if (!dev) {
431 ret = -ENOMEM;
432 goto err;
433 }
434
435 dev->spi = spi;
436 dev->f_tuner = bands[0].rangelow;
437 v4l2_spi_subdev_init(&dev->sd, spi, &msi001_ops);
438
439 /* Register controls */
440 v4l2_ctrl_handler_init(&dev->hdl, 5);
441 dev->bandwidth_auto = v4l2_ctrl_new_std(&dev->hdl, &msi001_ctrl_ops,
442 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO, 0, 1, 1, 1);
443 dev->bandwidth = v4l2_ctrl_new_std(&dev->hdl, &msi001_ctrl_ops,
444 V4L2_CID_RF_TUNER_BANDWIDTH, 200000, 8000000, 1, 200000);
445 v4l2_ctrl_auto_cluster(2, &dev->bandwidth_auto, 0, false);
446 dev->lna_gain = v4l2_ctrl_new_std(&dev->hdl, &msi001_ctrl_ops,
447 V4L2_CID_RF_TUNER_LNA_GAIN, 0, 1, 1, 1);
448 dev->mixer_gain = v4l2_ctrl_new_std(&dev->hdl, &msi001_ctrl_ops,
449 V4L2_CID_RF_TUNER_MIXER_GAIN, 0, 1, 1, 1);
450 dev->if_gain = v4l2_ctrl_new_std(&dev->hdl, &msi001_ctrl_ops,
451 V4L2_CID_RF_TUNER_IF_GAIN, 0, 59, 1, 0);
452 if (dev->hdl.error) {
453 ret = dev->hdl.error;
454 dev_err(&spi->dev, "Could not initialize controls\n");
455 /* control init failed, free handler */
456 goto err_ctrl_handler_free;
457 }
458
459 dev->sd.ctrl_handler = &dev->hdl;
460 return 0;
461 err_ctrl_handler_free:
462 v4l2_ctrl_handler_free(&dev->hdl);
463 kfree(dev);
464 err:
465 return ret;
466 }
467
468 static int msi001_remove(struct spi_device *spi)
469 {
470 struct v4l2_subdev *sd = spi_get_drvdata(spi);
471 struct msi001_dev *dev = sd_to_msi001_dev(sd);
472
473 dev_dbg(&spi->dev, "\n");
474
475 /*
476 * Registered by v4l2_spi_new_subdev() from master driver, but we must
477 * unregister it from here. Weird.
478 */
479 v4l2_device_unregister_subdev(&dev->sd);
480 v4l2_ctrl_handler_free(&dev->hdl);
481 kfree(dev);
482 return 0;
483 }
484
485 static const struct spi_device_id msi001_id_table[] = {
486 {"msi001", 0},
487 {}
488 };
489 MODULE_DEVICE_TABLE(spi, msi001_id_table);
490
491 static struct spi_driver msi001_driver = {
492 .driver = {
493 .name = "msi001",
494 .suppress_bind_attrs = true,
495 },
496 .probe = msi001_probe,
497 .remove = msi001_remove,
498 .id_table = msi001_id_table,
499 };
500 module_spi_driver(msi001_driver);
501
502 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
503 MODULE_DESCRIPTION("Mirics MSi001");
504 MODULE_LICENSE("GPL");
Linux with added FPC-III support