1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31#include <linux/export.h>
32
33#include "fmdrv.h"
34#include "fmdrv_v4l2.h"
35#include "fmdrv_common.h"
36#include "fmdrv_rx.h"
37#include "fmdrv_tx.h"
38
39static struct video_device *gradio_dev;
40static u8 radio_disconnected;
41
42
43
44
45static ssize_t fm_v4l2_fops_read(struct file *file, char __user * buf,
46 size_t count, loff_t *ppos)
47{
48 u8 rds_mode;
49 int ret;
50 struct fmdev *fmdev;
51
52 fmdev = video_drvdata(file);
53
54 if (!radio_disconnected) {
55 fmerr("FM device is already disconnected\n");
56 return -EIO;
57 }
58
59 if (mutex_lock_interruptible(&fmdev->mutex))
60 return -ERESTARTSYS;
61
62
63 ret = fm_rx_get_rds_mode(fmdev, &rds_mode);
64 if (ret < 0) {
65 fmerr("Unable to read current rds mode\n");
66 goto read_unlock;
67 }
68
69 if (rds_mode == FM_RDS_DISABLE) {
70 ret = fmc_set_rds_mode(fmdev, FM_RDS_ENABLE);
71 if (ret < 0) {
72 fmerr("Failed to enable rds mode\n");
73 goto read_unlock;
74 }
75 }
76
77
78 ret = fmc_transfer_rds_from_internal_buff(fmdev, file, buf, count);
79read_unlock:
80 mutex_unlock(&fmdev->mutex);
81 return ret;
82}
83
84
85static ssize_t fm_v4l2_fops_write(struct file *file, const char __user * buf,
86 size_t count, loff_t *ppos)
87{
88 struct tx_rds rds;
89 int ret;
90 struct fmdev *fmdev;
91
92 ret = copy_from_user(&rds, buf, sizeof(rds));
93 rds.text[sizeof(rds.text) - 1] = '\0';
94 fmdbg("(%d)type: %d, text %s, af %d\n",
95 ret, rds.text_type, rds.text, rds.af_freq);
96 if (ret)
97 return -EFAULT;
98
99 fmdev = video_drvdata(file);
100 if (mutex_lock_interruptible(&fmdev->mutex))
101 return -ERESTARTSYS;
102 fm_tx_set_radio_text(fmdev, rds.text, rds.text_type);
103 fm_tx_set_af(fmdev, rds.af_freq);
104 mutex_unlock(&fmdev->mutex);
105
106 return sizeof(rds);
107}
108
109static u32 fm_v4l2_fops_poll(struct file *file, struct poll_table_struct *pts)
110{
111 int ret;
112 struct fmdev *fmdev;
113
114 fmdev = video_drvdata(file);
115 mutex_lock(&fmdev->mutex);
116 ret = fmc_is_rds_data_available(fmdev, file, pts);
117 mutex_unlock(&fmdev->mutex);
118 if (ret < 0)
119 return POLLIN | POLLRDNORM;
120
121 return 0;
122}
123
124
125
126
127
128static int fm_v4l2_fops_open(struct file *file)
129{
130 int ret;
131 struct fmdev *fmdev = NULL;
132
133
134 if (radio_disconnected) {
135 fmerr("FM device is already opened\n");
136 return -EBUSY;
137 }
138
139 fmdev = video_drvdata(file);
140
141 if (mutex_lock_interruptible(&fmdev->mutex))
142 return -ERESTARTSYS;
143 ret = fmc_prepare(fmdev);
144 if (ret < 0) {
145 fmerr("Unable to prepare FM CORE\n");
146 goto open_unlock;
147 }
148
149 fmdbg("Load FM RX firmware..\n");
150
151 ret = fmc_set_mode(fmdev, FM_MODE_RX);
152 if (ret < 0) {
153 fmerr("Unable to load FM RX firmware\n");
154 goto open_unlock;
155 }
156 radio_disconnected = 1;
157
158open_unlock:
159 mutex_unlock(&fmdev->mutex);
160 return ret;
161}
162
163static int fm_v4l2_fops_release(struct file *file)
164{
165 int ret;
166 struct fmdev *fmdev;
167
168 fmdev = video_drvdata(file);
169 if (!radio_disconnected) {
170 fmdbg("FM device is already closed\n");
171 return 0;
172 }
173
174 mutex_lock(&fmdev->mutex);
175 ret = fmc_set_mode(fmdev, FM_MODE_OFF);
176 if (ret < 0) {
177 fmerr("Unable to turn off the chip\n");
178 goto release_unlock;
179 }
180
181 ret = fmc_release(fmdev);
182 if (ret < 0) {
183 fmerr("FM CORE release failed\n");
184 goto release_unlock;
185 }
186 radio_disconnected = 0;
187
188release_unlock:
189 mutex_unlock(&fmdev->mutex);
190 return ret;
191}
192
193
194static int fm_v4l2_vidioc_querycap(struct file *file, void *priv,
195 struct v4l2_capability *capability)
196{
197 strlcpy(capability->driver, FM_DRV_NAME, sizeof(capability->driver));
198 strlcpy(capability->card, FM_DRV_CARD_SHORT_NAME,
199 sizeof(capability->card));
200 sprintf(capability->bus_info, "UART");
201 capability->capabilities = V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
202 V4L2_CAP_RADIO | V4L2_CAP_MODULATOR |
203 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE |
204 V4L2_CAP_RDS_CAPTURE;
205
206 return 0;
207}
208
209static int fm_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
210{
211 struct fmdev *fmdev = container_of(ctrl->handler,
212 struct fmdev, ctrl_handler);
213
214 switch (ctrl->id) {
215 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
216 ctrl->val = fm_tx_get_tune_cap_val(fmdev);
217 break;
218 default:
219 fmwarn("%s: Unknown IOCTL: %d\n", __func__, ctrl->id);
220 break;
221 }
222
223 return 0;
224}
225
226static int fm_v4l2_s_ctrl(struct v4l2_ctrl *ctrl)
227{
228 struct fmdev *fmdev = container_of(ctrl->handler,
229 struct fmdev, ctrl_handler);
230
231 switch (ctrl->id) {
232 case V4L2_CID_AUDIO_VOLUME:
233 return fm_rx_set_volume(fmdev, (u16)ctrl->val);
234
235 case V4L2_CID_AUDIO_MUTE:
236 return fmc_set_mute_mode(fmdev, (u8)ctrl->val);
237
238 case V4L2_CID_TUNE_POWER_LEVEL:
239
240 return fm_tx_set_pwr_lvl(fmdev, (u8)ctrl->val);
241
242 case V4L2_CID_TUNE_PREEMPHASIS:
243 return fm_tx_set_preemph_filter(fmdev, (u8) ctrl->val);
244
245 default:
246 return -EINVAL;
247 }
248}
249
250static int fm_v4l2_vidioc_g_audio(struct file *file, void *priv,
251 struct v4l2_audio *audio)
252{
253 memset(audio, 0, sizeof(*audio));
254 strcpy(audio->name, "Radio");
255 audio->capability = V4L2_AUDCAP_STEREO;
256
257 return 0;
258}
259
260static int fm_v4l2_vidioc_s_audio(struct file *file, void *priv,
261 const struct v4l2_audio *audio)
262{
263 if (audio->index != 0)
264 return -EINVAL;
265
266 return 0;
267}
268
269
270static int fm_v4l2_vidioc_g_tuner(struct file *file, void *priv,
271 struct v4l2_tuner *tuner)
272{
273 struct fmdev *fmdev = video_drvdata(file);
274 u32 bottom_freq;
275 u32 top_freq;
276 u16 stereo_mono_mode;
277 u16 rssilvl;
278 int ret;
279
280 if (tuner->index != 0)
281 return -EINVAL;
282
283 if (fmdev->curr_fmmode != FM_MODE_RX)
284 return -EPERM;
285
286 ret = fm_rx_get_band_freq_range(fmdev, &bottom_freq, &top_freq);
287 if (ret != 0)
288 return ret;
289
290 ret = fm_rx_get_stereo_mono(fmdev, &stereo_mono_mode);
291 if (ret != 0)
292 return ret;
293
294 ret = fm_rx_get_rssi_level(fmdev, &rssilvl);
295 if (ret != 0)
296 return ret;
297
298 strcpy(tuner->name, "FM");
299 tuner->type = V4L2_TUNER_RADIO;
300
301 tuner->rangelow = bottom_freq * 16;
302 tuner->rangehigh = top_freq * 16;
303 tuner->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO |
304 ((fmdev->rx.rds.flag == FM_RDS_ENABLE) ? V4L2_TUNER_SUB_RDS : 0);
305 tuner->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS |
306 V4L2_TUNER_CAP_LOW |
307 V4L2_TUNER_CAP_HWSEEK_BOUNDED |
308 V4L2_TUNER_CAP_HWSEEK_WRAP;
309 tuner->audmode = (stereo_mono_mode ?
310 V4L2_TUNER_MODE_MONO : V4L2_TUNER_MODE_STEREO);
311
312
313
314
315
316 rssilvl += 128;
317
318
319
320
321
322 tuner->signal = rssilvl * 257;
323 tuner->afc = 0;
324
325 return ret;
326}
327
328
329
330
331
332
333static int fm_v4l2_vidioc_s_tuner(struct file *file, void *priv,
334 const struct v4l2_tuner *tuner)
335{
336 struct fmdev *fmdev = video_drvdata(file);
337 u16 aud_mode;
338 u8 rds_mode;
339 int ret;
340
341 if (tuner->index != 0)
342 return -EINVAL;
343
344 aud_mode = (tuner->audmode == V4L2_TUNER_MODE_STEREO) ?
345 FM_STEREO_MODE : FM_MONO_MODE;
346 rds_mode = (tuner->rxsubchans & V4L2_TUNER_SUB_RDS) ?
347 FM_RDS_ENABLE : FM_RDS_DISABLE;
348
349 if (fmdev->curr_fmmode != FM_MODE_RX) {
350 ret = fmc_set_mode(fmdev, FM_MODE_RX);
351 if (ret < 0) {
352 fmerr("Failed to set RX mode\n");
353 return ret;
354 }
355 }
356
357 ret = fmc_set_stereo_mono(fmdev, aud_mode);
358 if (ret < 0) {
359 fmerr("Failed to set RX stereo/mono mode\n");
360 return ret;
361 }
362
363 ret = fmc_set_rds_mode(fmdev, rds_mode);
364 if (ret < 0)
365 fmerr("Failed to set RX RDS mode\n");
366
367 return ret;
368}
369
370
371static int fm_v4l2_vidioc_g_freq(struct file *file, void *priv,
372 struct v4l2_frequency *freq)
373{
374 struct fmdev *fmdev = video_drvdata(file);
375 int ret;
376
377 ret = fmc_get_freq(fmdev, &freq->frequency);
378 if (ret < 0) {
379 fmerr("Failed to get frequency\n");
380 return ret;
381 }
382
383
384 freq->frequency = (u32) freq->frequency * 16;
385
386 return 0;
387}
388
389
390static int fm_v4l2_vidioc_s_freq(struct file *file, void *priv,
391 const struct v4l2_frequency *freq)
392{
393 struct fmdev *fmdev = video_drvdata(file);
394
395
396
397
398
399 return fmc_set_freq(fmdev, freq->frequency / 16);
400}
401
402
403static int fm_v4l2_vidioc_s_hw_freq_seek(struct file *file, void *priv,
404 const struct v4l2_hw_freq_seek *seek)
405{
406 struct fmdev *fmdev = video_drvdata(file);
407 int ret;
408
409 if (file->f_flags & O_NONBLOCK)
410 return -EWOULDBLOCK;
411
412 if (fmdev->curr_fmmode != FM_MODE_RX) {
413 ret = fmc_set_mode(fmdev, FM_MODE_RX);
414 if (ret != 0) {
415 fmerr("Failed to set RX mode\n");
416 return ret;
417 }
418 }
419
420 ret = fm_rx_seek(fmdev, seek->seek_upward, seek->wrap_around,
421 seek->spacing);
422 if (ret < 0)
423 fmerr("RX seek failed - %d\n", ret);
424
425 return ret;
426}
427
428static int fm_v4l2_vidioc_g_modulator(struct file *file, void *priv,
429 struct v4l2_modulator *mod)
430{
431 struct fmdev *fmdev = video_drvdata(file);
432
433 if (mod->index != 0)
434 return -EINVAL;
435
436 if (fmdev->curr_fmmode != FM_MODE_TX)
437 return -EPERM;
438
439 mod->txsubchans = ((fmdev->tx_data.aud_mode == FM_STEREO_MODE) ?
440 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO) |
441 ((fmdev->tx_data.rds.flag == FM_RDS_ENABLE) ?
442 V4L2_TUNER_SUB_RDS : 0);
443
444 mod->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS |
445 V4L2_TUNER_CAP_LOW;
446
447 return 0;
448}
449
450
451static int fm_v4l2_vidioc_s_modulator(struct file *file, void *priv,
452 const struct v4l2_modulator *mod)
453{
454 struct fmdev *fmdev = video_drvdata(file);
455 u8 rds_mode;
456 u16 aud_mode;
457 int ret;
458
459 if (mod->index != 0)
460 return -EINVAL;
461
462 if (fmdev->curr_fmmode != FM_MODE_TX) {
463 ret = fmc_set_mode(fmdev, FM_MODE_TX);
464 if (ret != 0) {
465 fmerr("Failed to set TX mode\n");
466 return ret;
467 }
468 }
469
470 aud_mode = (mod->txsubchans & V4L2_TUNER_SUB_STEREO) ?
471 FM_STEREO_MODE : FM_MONO_MODE;
472 rds_mode = (mod->txsubchans & V4L2_TUNER_SUB_RDS) ?
473 FM_RDS_ENABLE : FM_RDS_DISABLE;
474 ret = fm_tx_set_stereo_mono(fmdev, aud_mode);
475 if (ret < 0) {
476 fmerr("Failed to set mono/stereo mode for TX\n");
477 return ret;
478 }
479 ret = fm_tx_set_rds_mode(fmdev, rds_mode);
480 if (ret < 0)
481 fmerr("Failed to set rds mode for TX\n");
482
483 return ret;
484}
485
486static const struct v4l2_file_operations fm_drv_fops = {
487 .owner = THIS_MODULE,
488 .read = fm_v4l2_fops_read,
489 .write = fm_v4l2_fops_write,
490 .poll = fm_v4l2_fops_poll,
491 .unlocked_ioctl = video_ioctl2,
492 .open = fm_v4l2_fops_open,
493 .release = fm_v4l2_fops_release,
494};
495
496static const struct v4l2_ctrl_ops fm_ctrl_ops = {
497 .s_ctrl = fm_v4l2_s_ctrl,
498 .g_volatile_ctrl = fm_g_volatile_ctrl,
499};
500static const struct v4l2_ioctl_ops fm_drv_ioctl_ops = {
501 .vidioc_querycap = fm_v4l2_vidioc_querycap,
502 .vidioc_g_audio = fm_v4l2_vidioc_g_audio,
503 .vidioc_s_audio = fm_v4l2_vidioc_s_audio,
504 .vidioc_g_tuner = fm_v4l2_vidioc_g_tuner,
505 .vidioc_s_tuner = fm_v4l2_vidioc_s_tuner,
506 .vidioc_g_frequency = fm_v4l2_vidioc_g_freq,
507 .vidioc_s_frequency = fm_v4l2_vidioc_s_freq,
508 .vidioc_s_hw_freq_seek = fm_v4l2_vidioc_s_hw_freq_seek,
509 .vidioc_g_modulator = fm_v4l2_vidioc_g_modulator,
510 .vidioc_s_modulator = fm_v4l2_vidioc_s_modulator
511};
512
513
514static struct video_device fm_viddev_template = {
515 .fops = &fm_drv_fops,
516 .ioctl_ops = &fm_drv_ioctl_ops,
517 .name = FM_DRV_NAME,
518 .release = video_device_release,
519
520
521
522
523
524
525
526
527
528 .vfl_dir = VFL_DIR_M2M,
529};
530
531int fm_v4l2_init_video_device(struct fmdev *fmdev, int radio_nr)
532{
533 struct v4l2_ctrl *ctrl;
534 int ret;
535
536 strlcpy(fmdev->v4l2_dev.name, FM_DRV_NAME, sizeof(fmdev->v4l2_dev.name));
537 ret = v4l2_device_register(NULL, &fmdev->v4l2_dev);
538 if (ret < 0)
539 return ret;
540
541
542 mutex_init(&fmdev->mutex);
543
544
545 gradio_dev = video_device_alloc();
546 if (NULL == gradio_dev) {
547 fmerr("Can't allocate video device\n");
548 return -ENOMEM;
549 }
550
551
552 memcpy(gradio_dev, &fm_viddev_template, sizeof(fm_viddev_template));
553
554 video_set_drvdata(gradio_dev, fmdev);
555
556 gradio_dev->lock = &fmdev->mutex;
557 gradio_dev->v4l2_dev = &fmdev->v4l2_dev;
558
559
560 if (video_register_device(gradio_dev, VFL_TYPE_RADIO, radio_nr)) {
561 video_device_release(gradio_dev);
562 fmerr("Could not register video device\n");
563 return -ENOMEM;
564 }
565
566 fmdev->radio_dev = gradio_dev;
567
568
569 fmdev->radio_dev->ctrl_handler = &fmdev->ctrl_handler;
570
571 ret = v4l2_ctrl_handler_init(&fmdev->ctrl_handler, 5);
572 if (ret < 0) {
573 fmerr("(fmdev): Can't init ctrl handler\n");
574 v4l2_ctrl_handler_free(&fmdev->ctrl_handler);
575 return -EBUSY;
576 }
577
578
579
580
581
582 v4l2_ctrl_new_std(&fmdev->ctrl_handler, &fm_ctrl_ops,
583 V4L2_CID_AUDIO_VOLUME, FM_RX_VOLUME_MIN,
584 FM_RX_VOLUME_MAX, 1, FM_RX_VOLUME_MAX);
585
586 v4l2_ctrl_new_std(&fmdev->ctrl_handler, &fm_ctrl_ops,
587 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
588
589 v4l2_ctrl_new_std_menu(&fmdev->ctrl_handler, &fm_ctrl_ops,
590 V4L2_CID_TUNE_PREEMPHASIS, V4L2_PREEMPHASIS_75_uS,
591 0, V4L2_PREEMPHASIS_75_uS);
592
593 v4l2_ctrl_new_std(&fmdev->ctrl_handler, &fm_ctrl_ops,
594 V4L2_CID_TUNE_POWER_LEVEL, FM_PWR_LVL_LOW,
595 FM_PWR_LVL_HIGH, 1, FM_PWR_LVL_HIGH);
596
597 ctrl = v4l2_ctrl_new_std(&fmdev->ctrl_handler, &fm_ctrl_ops,
598 V4L2_CID_TUNE_ANTENNA_CAPACITOR, 0,
599 255, 1, 255);
600
601 if (ctrl)
602 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
603
604 return 0;
605}
606
607void *fm_v4l2_deinit_video_device(void)
608{
609 struct fmdev *fmdev;
610
611
612 fmdev = video_get_drvdata(gradio_dev);
613
614
615 v4l2_ctrl_handler_free(&fmdev->ctrl_handler);
616
617
618 video_unregister_device(gradio_dev);
619
620 v4l2_device_unregister(&fmdev->v4l2_dev);
621
622 return fmdev;
623}
624