1
2
3
4
5
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
27
28
29#define TEA575X_BIT_SEARCH (1<<24)
30#define TEA575X_BIT_UPDOWN (1<<23)
31#define TEA575X_BIT_MONO (1<<22)
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)
38#define TEA575X_BIT_PORT_1 (1<<18)
39#define TEA575X_BIT_SEARCH_MASK (3<<16)
40#define TEA575X_BIT_SEARCH_5_28 (0<<16)
41#define TEA575X_BIT_SEARCH_10_40 (1<<16)
42#define TEA575X_BIT_SEARCH_30_63 (2<<16)
43#define TEA575X_BIT_SEARCH_150_1000 (3<<16)
44#define TEA575X_BIT_DUMMY (1<<15)
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
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;
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;
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
152 freq *= 125;
153 freq /= 10;
154
155 freq -= TEA575X_FMIF;
156 break;
157 case BAND_FM_JAPAN:
158
159 freq *= 125;
160 freq /= 10;
161
162 freq += TEA575X_FMIF;
163 break;
164 case BAND_AM:
165
166 freq -= TEA575X_AMIF;
167 break;
168 }
169
170 return clamp(freq * 16, bands[tea->band].rangelow,
171 bands[tea->band].rangehigh);
172}
173
174static u32 snd_tea575x_get_freq(struct snd_tea575x *tea)
175{
176 return snd_tea575x_val_to_freq(tea, snd_tea575x_read(tea));
177}
178
179void snd_tea575x_set_freq(struct snd_tea575x *tea)
180{
181 u32 freq = tea->freq / 16;
182 u32 band = 0;
183
184 switch (tea->band) {
185 case BAND_FM:
186 band = TEA575X_BIT_BAND_FM;
187
188 freq += TEA575X_FMIF;
189
190 freq *= 10;
191 freq /= 125;
192 break;
193 case BAND_FM_JAPAN:
194 band = TEA575X_BIT_BAND_FM;
195
196 freq -= TEA575X_FMIF;
197
198 freq *= 10;
199 freq /= 125;
200 break;
201 case BAND_AM:
202 band = TEA575X_BIT_BAND_MW;
203
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, tea->val);
212 tea->freq = snd_tea575x_val_to_freq(tea, tea->val);
213}
214EXPORT_SYMBOL(snd_tea575x_set_freq);
215
216
217
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(v->card, tea->tea5759 ? " TEA5759" : " TEA5757", 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
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;
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;
391
392
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, tea->val);
400 timeout = jiffies + msecs_to_jiffies(10000);
401 for (;;) {
402 if (time_after(jiffies, timeout))
403 break;
404 if (schedule_timeout_interruptible(msecs_to_jiffies(10))) {
405
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
414 for (i = 0; i < 100; i++) {
415 msleep(10);
416 freq = snd_tea575x_get_freq(tea);
417 if (freq)
418 break;
419 }
420 if (freq == 0)
421 break;
422
423
424
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, 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
500
501 if (!tea->cannot_read_data) {
502 snd_tea575x_write(tea, 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;
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(&tea->vd, 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
535 if (tea->cannot_read_data)
536 v4l2_disable_ioctl(&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(&tea->ctrl_handler, &tea575x_ctrl_ops,
542 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 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(&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(&tea->ctrl_handler);
554 return retval;
555 }
556 }
557
558 v4l2_ctrl_handler_setup(&tea->ctrl_handler);
559 }
560
561 retval = video_register_device(&tea->vd, VFL_TYPE_RADIO, tea->radio_nr);
562 if (retval) {
563 v4l2_err(tea->v4l2_dev, "can't register video device!\n");
564 v4l2_ctrl_handler_free(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(&tea->vd);
575 v4l2_ctrl_handler_free(tea->vd.ctrl_handler);
576}
577EXPORT_SYMBOL(snd_tea575x_exit);
578
