1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * ALSA driver for TEA5757/5759 Philips AM/FM radio tuner chips
4 *
5 * Copyright (c) 2004 Jaroslav Kysela <perex@perex.cz>
6 */
7
8#include <linux/delay.h>
9#include <linux/module.h>
10#include <linux/init.h>
11#include <linux/slab.h>
12#include <linux/sched.h>
13#include <asm/io.h>
14#include <media/v4l2-device.h>
15#include <media/v4l2-dev.h>
16#include <media/v4l2-fh.h>
17#include <media/v4l2-ioctl.h>
18#include <media/v4l2-event.h>
19#include <media/drv-intf/tea575x.h>
20
21MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
22MODULE_DESCRIPTION("Routines for control of TEA5757/5759 Philips AM/FM radio tuner chips");
23MODULE_LICENSE("GPL");
24
25/*
26 * definitions
27 */
28
29#define TEA575X_BIT_SEARCH (1<<24) /* 1 = search action, 0 = tuned */
30#define TEA575X_BIT_UPDOWN (1<<23) /* 0 = search down, 1 = search up */
31#define TEA575X_BIT_MONO (1<<22) /* 0 = stereo, 1 = mono */
32#define TEA575X_BIT_BAND_MASK (3<<20)
33#define TEA575X_BIT_BAND_FM (0<<20)
34#define TEA575X_BIT_BAND_MW (1<<20)
35#define TEA575X_BIT_BAND_LW (2<<20)
36#define TEA575X_BIT_BAND_SW (3<<20)
37#define TEA575X_BIT_PORT_0 (1<<19) /* user bit */
38#define TEA575X_BIT_PORT_1 (1<<18) /* user bit */
39#define TEA575X_BIT_SEARCH_MASK (3<<16) /* search level */
40#define TEA575X_BIT_SEARCH_5_28 (0<<16) /* FM >5uV, AM >28uV */
41#define TEA575X_BIT_SEARCH_10_40 (1<<16) /* FM >10uV, AM > 40uV */
42#define TEA575X_BIT_SEARCH_30_63 (2<<16) /* FM >30uV, AM > 63uV */
43#define TEA575X_BIT_SEARCH_150_1000 (3<<16) /* FM > 150uV, AM > 1000uV */
44#define TEA575X_BIT_DUMMY (1<<15) /* buffer */
45#define TEA575X_BIT_FREQ_MASK 0x7fff
46
47enum { BAND_FM, BAND_FM_JAPAN, BAND_AM };
48
49static const struct v4l2_frequency_band bands[] = {
50 {
51 .type = V4L2_TUNER_RADIO,
52 .index = 0,
53 .capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
54 V4L2_TUNER_CAP_FREQ_BANDS,
55 .rangelow = 87500 * 16,
56 .rangehigh = 108000 * 16,
57 .modulation = V4L2_BAND_MODULATION_FM,
58 },
59 {
60 .type = V4L2_TUNER_RADIO,
61 .index = 0,
62 .capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
63 V4L2_TUNER_CAP_FREQ_BANDS,
64 .rangelow = 76000 * 16,
65 .rangehigh = 91000 * 16,
66 .modulation = V4L2_BAND_MODULATION_FM,
67 },
68 {
69 .type = V4L2_TUNER_RADIO,
70 .index = 1,
71 .capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_FREQ_BANDS,
72 .rangelow = 530 * 16,
73 .rangehigh = 1710 * 16,
74 .modulation = V4L2_BAND_MODULATION_AM,
75 },
76};
77
78/*
79 * lowlevel part
80 */
81
82static void snd_tea575x_write(struct snd_tea575x *tea, unsigned int val)
83{
84 u16 l;
85 u8 data;
86
87 if (tea->ops->write_val)
88 return tea->ops->write_val(tea, val);
89
90 tea->ops->set_direction(tea, 1);
91 udelay(16);
92
93 for (l = 25; l > 0; l--) {
94 data = (val >> 24) & TEA575X_DATA;
95 val <<= 1; /* shift data */
96 tea->ops->set_pins(tea, data | TEA575X_WREN);
97 udelay(2);
98 tea->ops->set_pins(tea, data | TEA575X_WREN | TEA575X_CLK);
99 udelay(2);
100 tea->ops->set_pins(tea, data | TEA575X_WREN);
101 udelay(2);
102 }
103
104 if (!tea->mute)
105 tea->ops->set_pins(tea, 0);
106}
107
108static u32 snd_tea575x_read(struct snd_tea575x *tea)
109{
110 u16 l, rdata;
111 u32 data = 0;
112
113 if (tea->ops->read_val)
114 return tea->ops->read_val(tea);
115
116 tea->ops->set_direction(tea, 0);
117 tea->ops->set_pins(tea, 0);
118 udelay(16);
119
120 for (l = 24; l--;) {
121 tea->ops->set_pins(tea, TEA575X_CLK);
122 udelay(2);
123 if (!l)
124 tea->tuned = tea->ops->get_pins(tea) & TEA575X_MOST ? 0 : 1;
125 tea->ops->set_pins(tea, 0);
126 udelay(2);
127 data <<= 1; /* shift data */
128 rdata = tea->ops->get_pins(tea);
129 if (!l)
130 tea->stereo = (rdata & TEA575X_MOST) ? 0 : 1;
131 if (rdata & TEA575X_DATA)
132 data++;
133 udelay(2);
134 }
135
136 if (tea->mute)
137 tea->ops->set_pins(tea, TEA575X_WREN);
138
139 return data;
140}
141
142static u32 snd_tea575x_val_to_freq(struct snd_tea575x *tea, u32 val)
143{
144 u32 freq = val & TEA575X_BIT_FREQ_MASK;
145
146 if (freq == 0)
147 return freq;
148
149 switch (tea->band) {
150 case BAND_FM:
151 /* freq *= 12.5 */
152 freq *= 125;
153 freq /= 10;
154 /* crystal fixup */
155 freq -= TEA575X_FMIF;
156 break;
157 case BAND_FM_JAPAN:
158 /* freq *= 12.5 */
159 freq *= 125;
160 freq /= 10;
161 /* crystal fixup */
162 freq += TEA575X_FMIF;
163 break;
164 case BAND_AM:
165 /* crystal fixup */
166 freq -= TEA575X_AMIF;
167 break;
168 }
169
170 return clamp(freq * 16, bands[tea->band].rangelow,
171 bands[tea->band].rangehigh); /* from kHz */
172}
173
174static u32 snd_tea575x_get_freq(struct snd_tea575x *tea)
175{
176 return snd_tea575x_val_to_freq(tea, val: snd_tea575x_read(tea));
177}
178
179void snd_tea575x_set_freq(struct snd_tea575x *tea)
180{
181 u32 freq = tea->freq / 16; /* to kHz */
182 u32 band = 0;
183
184 switch (tea->band) {
185 case BAND_FM:
186 band = TEA575X_BIT_BAND_FM;
187 /* crystal fixup */
188 freq += TEA575X_FMIF;
189 /* freq /= 12.5 */
190 freq *= 10;
191 freq /= 125;
192 break;
193 case BAND_FM_JAPAN:
194 band = TEA575X_BIT_BAND_FM;
195 /* crystal fixup */
196 freq -= TEA575X_FMIF;
197 /* freq /= 12.5 */
198 freq *= 10;
199 freq /= 125;
200 break;
201 case BAND_AM:
202 band = TEA575X_BIT_BAND_MW;
203 /* crystal fixup */
204 freq += TEA575X_AMIF;
205 break;
206 }
207
208 tea->val &= ~(TEA575X_BIT_FREQ_MASK | TEA575X_BIT_BAND_MASK);
209 tea->val |= band;
210 tea->val |= freq & TEA575X_BIT_FREQ_MASK;
211 snd_tea575x_write(tea, val: tea->val);
212 tea->freq = snd_tea575x_val_to_freq(tea, val: tea->val);
213}
214EXPORT_SYMBOL(snd_tea575x_set_freq);
215
216/*
217 * Linux Video interface
218 */
219
220static int vidioc_querycap(struct file *file, void *priv,
221 struct v4l2_capability *v)
222{
223 struct snd_tea575x *tea = video_drvdata(file);
224
225 strscpy(v->driver, tea->v4l2_dev->name, sizeof(v->driver));
226 strscpy(v->card, tea->card, sizeof(v->card));
227 strlcat(p: v->card, q: tea->tea5759 ? " TEA5759" : " TEA5757", avail: sizeof(v->card));
228 strscpy(v->bus_info, tea->bus_info, sizeof(v->bus_info));
229 return 0;
230}
231
232int snd_tea575x_enum_freq_bands(struct snd_tea575x *tea,
233 struct v4l2_frequency_band *band)
234{
235 int index;
236
237 if (band->tuner != 0)
238 return -EINVAL;
239
240 switch (band->index) {
241 case 0:
242 if (tea->tea5759)
243 index = BAND_FM_JAPAN;
244 else
245 index = BAND_FM;
246 break;
247 case 1:
248 if (tea->has_am) {
249 index = BAND_AM;
250 break;
251 }
252 fallthrough;
253 default:
254 return -EINVAL;
255 }
256
257 *band = bands[index];
258 if (!tea->cannot_read_data)
259 band->capability |= V4L2_TUNER_CAP_HWSEEK_BOUNDED;
260
261 return 0;
262}
263EXPORT_SYMBOL(snd_tea575x_enum_freq_bands);
264
265static int vidioc_enum_freq_bands(struct file *file, void *priv,
266 struct v4l2_frequency_band *band)
267{
268 struct snd_tea575x *tea = video_drvdata(file);
269
270 return snd_tea575x_enum_freq_bands(tea, band);
271}
272
273int snd_tea575x_g_tuner(struct snd_tea575x *tea, struct v4l2_tuner *v)
274{
275 struct v4l2_frequency_band band_fm = { 0, };
276
277 if (v->index > 0)
278 return -EINVAL;
279
280 snd_tea575x_read(tea);
281 snd_tea575x_enum_freq_bands(tea, &band_fm);
282
283 memset(v, 0, sizeof(*v));
284 strscpy(v->name, tea->has_am ? "FM/AM" : "FM", sizeof(v->name));
285 v->type = V4L2_TUNER_RADIO;
286 v->capability = band_fm.capability;
287 v->rangelow = tea->has_am ? bands[BAND_AM].rangelow : band_fm.rangelow;
288 v->rangehigh = band_fm.rangehigh;
289 v->rxsubchans = tea->stereo ? V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
290 v->audmode = (tea->val & TEA575X_BIT_MONO) ?
291 V4L2_TUNER_MODE_MONO : V4L2_TUNER_MODE_STEREO;
292 v->signal = tea->tuned ? 0xffff : 0;
293 return 0;
294}
295EXPORT_SYMBOL(snd_tea575x_g_tuner);
296
297static int vidioc_g_tuner(struct file *file, void *priv,
298 struct v4l2_tuner *v)
299{
300 struct snd_tea575x *tea = video_drvdata(file);
301
302 return snd_tea575x_g_tuner(tea, v);
303}
304
305static int vidioc_s_tuner(struct file *file, void *priv,
306 const struct v4l2_tuner *v)
307{
308 struct snd_tea575x *tea = video_drvdata(file);
309 u32 orig_val = tea->val;
310
311 if (v->index)
312 return -EINVAL;
313 tea->val &= ~TEA575X_BIT_MONO;
314 if (v->audmode == V4L2_TUNER_MODE_MONO)
315 tea->val |= TEA575X_BIT_MONO;
316 /* Only apply changes if currently tuning FM */
317 if (tea->band != BAND_AM && tea->val != orig_val)
318 snd_tea575x_set_freq(tea);
319
320 return 0;
321}
322
323static int vidioc_g_frequency(struct file *file, void *priv,
324 struct v4l2_frequency *f)
325{
326 struct snd_tea575x *tea = video_drvdata(file);
327
328 if (f->tuner != 0)
329 return -EINVAL;
330 f->type = V4L2_TUNER_RADIO;
331 f->frequency = tea->freq;
332 return 0;
333}
334
335static int vidioc_s_frequency(struct file *file, void *priv,
336 const struct v4l2_frequency *f)
337{
338 struct snd_tea575x *tea = video_drvdata(file);
339
340 if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
341 return -EINVAL;
342
343 if (tea->has_am && f->frequency < (20000 * 16))
344 tea->band = BAND_AM;
345 else if (tea->tea5759)
346 tea->band = BAND_FM_JAPAN;
347 else
348 tea->band = BAND_FM;
349
350 tea->freq = clamp_t(u32, f->frequency, bands[tea->band].rangelow,
351 bands[tea->band].rangehigh);
352 snd_tea575x_set_freq(tea);
353 return 0;
354}
355
356int snd_tea575x_s_hw_freq_seek(struct file *file, struct snd_tea575x *tea,
357 const struct v4l2_hw_freq_seek *a)
358{
359 unsigned long timeout;
360 int i, spacing;
361
362 if (tea->cannot_read_data)
363 return -ENOTTY;
364 if (a->tuner || a->wrap_around)
365 return -EINVAL;
366
367 if (file->f_flags & O_NONBLOCK)
368 return -EWOULDBLOCK;
369
370 if (a->rangelow || a->rangehigh) {
371 for (i = 0; i < ARRAY_SIZE(bands); i++) {
372 if ((i == BAND_FM && tea->tea5759) ||
373 (i == BAND_FM_JAPAN && !tea->tea5759) ||
374 (i == BAND_AM && !tea->has_am))
375 continue;
376 if (bands[i].rangelow == a->rangelow &&
377 bands[i].rangehigh == a->rangehigh)
378 break;
379 }
380 if (i == ARRAY_SIZE(bands))
381 return -EINVAL; /* No matching band found */
382 if (i != tea->band) {
383 tea->band = i;
384 tea->freq = clamp(tea->freq, bands[i].rangelow,
385 bands[i].rangehigh);
386 snd_tea575x_set_freq(tea);
387 }
388 }
389
390 spacing = (tea->band == BAND_AM) ? 5 : 50; /* kHz */
391
392 /* clear the frequency, HW will fill it in */
393 tea->val &= ~TEA575X_BIT_FREQ_MASK;
394 tea->val |= TEA575X_BIT_SEARCH;
395 if (a->seek_upward)
396 tea->val |= TEA575X_BIT_UPDOWN;
397 else
398 tea->val &= ~TEA575X_BIT_UPDOWN;
399 snd_tea575x_write(tea, val: tea->val);
400 timeout = jiffies + msecs_to_jiffies(m: 10000);
401 for (;;) {
402 if (time_after(jiffies, timeout))
403 break;
404 if (schedule_timeout_interruptible(timeout: msecs_to_jiffies(m: 10))) {
405 /* some signal arrived, stop search */
406 tea->val &= ~TEA575X_BIT_SEARCH;
407 snd_tea575x_set_freq(tea);
408 return -ERESTARTSYS;
409 }
410 if (!(snd_tea575x_read(tea) & TEA575X_BIT_SEARCH)) {
411 u32 freq;
412
413 /* Found a frequency, wait until it can be read */
414 for (i = 0; i < 100; i++) {
415 msleep(msecs: 10);
416 freq = snd_tea575x_get_freq(tea);
417 if (freq) /* available */
418 break;
419 }
420 if (freq == 0) /* shouldn't happen */
421 break;
422 /*
423 * if we moved by less than the spacing, or in the
424 * wrong direction, continue seeking
425 */
426 if (abs(tea->freq - freq) < 16 * spacing ||
427 (a->seek_upward && freq < tea->freq) ||
428 (!a->seek_upward && freq > tea->freq)) {
429 snd_tea575x_write(tea, val: tea->val);
430 continue;
431 }
432 tea->freq = freq;
433 tea->val &= ~TEA575X_BIT_SEARCH;
434 return 0;
435 }
436 }
437 tea->val &= ~TEA575X_BIT_SEARCH;
438 snd_tea575x_set_freq(tea);
439 return -ENODATA;
440}
441EXPORT_SYMBOL(snd_tea575x_s_hw_freq_seek);
442
443static int vidioc_s_hw_freq_seek(struct file *file, void *fh,
444 const struct v4l2_hw_freq_seek *a)
445{
446 struct snd_tea575x *tea = video_drvdata(file);
447
448 return snd_tea575x_s_hw_freq_seek(file, tea, a);
449}
450
451static int tea575x_s_ctrl(struct v4l2_ctrl *ctrl)
452{
453 struct snd_tea575x *tea = container_of(ctrl->handler, struct snd_tea575x, ctrl_handler);
454
455 switch (ctrl->id) {
456 case V4L2_CID_AUDIO_MUTE:
457 tea->mute = ctrl->val;
458 snd_tea575x_set_freq(tea);
459 return 0;
460 }
461
462 return -EINVAL;
463}
464
465static const struct v4l2_file_operations tea575x_fops = {
466 .unlocked_ioctl = video_ioctl2,
467 .open = v4l2_fh_open,
468 .release = v4l2_fh_release,
469 .poll = v4l2_ctrl_poll,
470};
471
472static const struct v4l2_ioctl_ops tea575x_ioctl_ops = {
473 .vidioc_querycap = vidioc_querycap,
474 .vidioc_g_tuner = vidioc_g_tuner,
475 .vidioc_s_tuner = vidioc_s_tuner,
476 .vidioc_g_frequency = vidioc_g_frequency,
477 .vidioc_s_frequency = vidioc_s_frequency,
478 .vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek,
479 .vidioc_enum_freq_bands = vidioc_enum_freq_bands,
480 .vidioc_log_status = v4l2_ctrl_log_status,
481 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
482 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
483};
484
485static const struct video_device tea575x_radio = {
486 .ioctl_ops = &tea575x_ioctl_ops,
487 .release = video_device_release_empty,
488};
489
490static const struct v4l2_ctrl_ops tea575x_ctrl_ops = {
491 .s_ctrl = tea575x_s_ctrl,
492};
493
494
495int snd_tea575x_hw_init(struct snd_tea575x *tea)
496{
497 tea->mute = true;
498
499 /* Not all devices can or know how to read the data back.
500 Such devices can set cannot_read_data to true. */
501 if (!tea->cannot_read_data) {
502 snd_tea575x_write(tea, val: 0x55AA);
503 if (snd_tea575x_read(tea) != 0x55AA)
504 return -ENODEV;
505 }
506
507 tea->val = TEA575X_BIT_BAND_FM | TEA575X_BIT_SEARCH_5_28;
508 tea->freq = 90500 * 16; /* 90.5Mhz default */
509 snd_tea575x_set_freq(tea);
510
511 return 0;
512}
513EXPORT_SYMBOL(snd_tea575x_hw_init);
514
515int snd_tea575x_init(struct snd_tea575x *tea, struct module *owner)
516{
517 int retval = snd_tea575x_hw_init(tea);
518
519 if (retval)
520 return retval;
521
522 tea->vd = tea575x_radio;
523 video_set_drvdata(vdev: &tea->vd, data: tea);
524 mutex_init(&tea->mutex);
525 strscpy(tea->vd.name, tea->v4l2_dev->name, sizeof(tea->vd.name));
526 tea->vd.lock = &tea->mutex;
527 tea->vd.v4l2_dev = tea->v4l2_dev;
528 tea->vd.device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
529 if (!tea->cannot_read_data)
530 tea->vd.device_caps |= V4L2_CAP_HW_FREQ_SEEK;
531 tea->fops = tea575x_fops;
532 tea->fops.owner = owner;
533 tea->vd.fops = &tea->fops;
534 /* disable hw_freq_seek if we can't use it */
535 if (tea->cannot_read_data)
536 v4l2_disable_ioctl(vdev: &tea->vd, VIDIOC_S_HW_FREQ_SEEK);
537
538 if (!tea->cannot_mute) {
539 tea->vd.ctrl_handler = &tea->ctrl_handler;
540 v4l2_ctrl_handler_init(&tea->ctrl_handler, 1);
541 v4l2_ctrl_new_std(hdl: &tea->ctrl_handler, ops: &tea575x_ctrl_ops,
542 V4L2_CID_AUDIO_MUTE, min: 0, max: 1, step: 1, def: 1);
543 retval = tea->ctrl_handler.error;
544 if (retval) {
545 v4l2_err(tea->v4l2_dev, "can't initialize controls\n");
546 v4l2_ctrl_handler_free(hdl: &tea->ctrl_handler);
547 return retval;
548 }
549
550 if (tea->ext_init) {
551 retval = tea->ext_init(tea);
552 if (retval) {
553 v4l2_ctrl_handler_free(hdl: &tea->ctrl_handler);
554 return retval;
555 }
556 }
557
558 v4l2_ctrl_handler_setup(hdl: &tea->ctrl_handler);
559 }
560
561 retval = video_register_device(vdev: &tea->vd, type: VFL_TYPE_RADIO, nr: tea->radio_nr);
562 if (retval) {
563 v4l2_err(tea->v4l2_dev, "can't register video device!\n");
564 v4l2_ctrl_handler_free(hdl: tea->vd.ctrl_handler);
565 return retval;
566 }
567
568 return 0;
569}
570EXPORT_SYMBOL(snd_tea575x_init);
571
572void snd_tea575x_exit(struct snd_tea575x *tea)
573{
574 video_unregister_device(vdev: &tea->vd);
575 v4l2_ctrl_handler_free(hdl: tea->vd.ctrl_handler);
576}
577EXPORT_SYMBOL(snd_tea575x_exit);
578

source code of linux/drivers/media/radio/tea575x.c