1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/module.h>
16#include <linux/init.h>
17#include <linux/videodev2.h>
18#include <media/v4l2-device.h>
19#include <media/v4l2-ioctl.h>
20#include <media/v4l2-ctrls.h>
21#include <media/v4l2-fh.h>
22#include <media/v4l2-event.h>
23#include <sound/aci.h>
24
25static int radio_nr = -1;
26module_param(radio_nr, int, 0);
27MODULE_PARM_DESC(radio_nr, "Set radio device number (/dev/radioX). Default: -1 (autodetect)");
28
29struct pcm20 {
30 struct v4l2_device v4l2_dev;
31 struct video_device vdev;
32 struct v4l2_ctrl_handler ctrl_handler;
33 unsigned long freq;
34 u32 audmode;
35 struct snd_miro_aci *aci;
36 struct mutex lock;
37};
38
39static struct pcm20 pcm20_card = {
40 .freq = 87 * 16000,
41 .audmode = V4L2_TUNER_MODE_STEREO,
42};
43
44static int pcm20_setfreq(struct pcm20 *dev, unsigned long freq)
45{
46 unsigned char freql;
47 unsigned char freqh;
48 struct snd_miro_aci *aci = dev->aci;
49
50 freq /= 160;
51 if (!(aci->aci_version == 0x07 || aci->aci_version >= 0xb0))
52 freq /= 10;
53
54 freql = freq & 0xff;
55 freqh = freq >> 8;
56
57 return snd_aci_cmd(aci, ACI_WRITE_TUNE, freql, freqh);
58}
59
60static const struct v4l2_file_operations pcm20_fops = {
61 .owner = THIS_MODULE,
62 .open = v4l2_fh_open,
63 .poll = v4l2_ctrl_poll,
64 .release = v4l2_fh_release,
65 .unlocked_ioctl = video_ioctl2,
66};
67
68static int vidioc_querycap(struct file *file, void *priv,
69 struct v4l2_capability *v)
70{
71 struct pcm20 *dev = video_drvdata(file);
72
73 strlcpy(v->driver, "Miro PCM20", sizeof(v->driver));
74 strlcpy(v->card, "Miro PCM20", sizeof(v->card));
75 snprintf(v->bus_info, sizeof(v->bus_info), "ISA:%s", dev->v4l2_dev.name);
76 v->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
77 v->capabilities = v->device_caps | V4L2_CAP_DEVICE_CAPS;
78 return 0;
79}
80
81static int vidioc_g_tuner(struct file *file, void *priv,
82 struct v4l2_tuner *v)
83{
84 struct pcm20 *dev = video_drvdata(file);
85 int res;
86
87 if (v->index)
88 return -EINVAL;
89 strlcpy(v->name, "FM", sizeof(v->name));
90 v->type = V4L2_TUNER_RADIO;
91 v->rangelow = 87*16000;
92 v->rangehigh = 108*16000;
93 res = snd_aci_cmd(dev->aci, ACI_READ_TUNERSTATION, -1, -1);
94 v->signal = (res & 0x80) ? 0 : 0xffff;
95
96
97 res = snd_aci_cmd(dev->aci, ACI_READ_TUNERSTEREO, -1, -1);
98 v->rxsubchans = (res & 0x40) ? V4L2_TUNER_SUB_MONO :
99 V4L2_TUNER_SUB_STEREO;
100 v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
101 v->audmode = dev->audmode;
102 return 0;
103}
104
105static int vidioc_s_tuner(struct file *file, void *priv,
106 const struct v4l2_tuner *v)
107{
108 struct pcm20 *dev = video_drvdata(file);
109
110 if (v->index)
111 return -EINVAL;
112 if (v->audmode > V4L2_TUNER_MODE_STEREO)
113 dev->audmode = V4L2_TUNER_MODE_STEREO;
114 else
115 dev->audmode = v->audmode;
116 snd_aci_cmd(dev->aci, ACI_SET_TUNERMONO,
117 dev->audmode == V4L2_TUNER_MODE_MONO, -1);
118 return 0;
119}
120
121static int vidioc_g_frequency(struct file *file, void *priv,
122 struct v4l2_frequency *f)
123{
124 struct pcm20 *dev = video_drvdata(file);
125
126 if (f->tuner != 0)
127 return -EINVAL;
128
129 f->type = V4L2_TUNER_RADIO;
130 f->frequency = dev->freq;
131 return 0;
132}
133
134
135static int vidioc_s_frequency(struct file *file, void *priv,
136 const struct v4l2_frequency *f)
137{
138 struct pcm20 *dev = video_drvdata(file);
139
140 if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
141 return -EINVAL;
142
143 dev->freq = clamp_t(u32, f->frequency, 87 * 16000U, 108 * 16000U);
144 pcm20_setfreq(dev, dev->freq);
145 return 0;
146}
147
148static int pcm20_s_ctrl(struct v4l2_ctrl *ctrl)
149{
150 struct pcm20 *dev = container_of(ctrl->handler, struct pcm20, ctrl_handler);
151
152 switch (ctrl->id) {
153 case V4L2_CID_AUDIO_MUTE:
154 snd_aci_cmd(dev->aci, ACI_SET_TUNERMUTE, ctrl->val, -1);
155 return 0;
156 }
157 return -EINVAL;
158}
159
160static const struct v4l2_ioctl_ops pcm20_ioctl_ops = {
161 .vidioc_querycap = vidioc_querycap,
162 .vidioc_g_tuner = vidioc_g_tuner,
163 .vidioc_s_tuner = vidioc_s_tuner,
164 .vidioc_g_frequency = vidioc_g_frequency,
165 .vidioc_s_frequency = vidioc_s_frequency,
166 .vidioc_log_status = v4l2_ctrl_log_status,
167 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
168 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
169};
170
171static const struct v4l2_ctrl_ops pcm20_ctrl_ops = {
172 .s_ctrl = pcm20_s_ctrl,
173};
174
175static int __init pcm20_init(void)
176{
177 struct pcm20 *dev = &pcm20_card;
178 struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
179 struct v4l2_ctrl_handler *hdl;
180 int res;
181
182 dev->aci = snd_aci_get_aci();
183 if (dev->aci == NULL) {
184 v4l2_err(v4l2_dev,
185 "you must load the snd-miro driver first!\n");
186 return -ENODEV;
187 }
188 strlcpy(v4l2_dev->name, "radio-miropcm20", sizeof(v4l2_dev->name));
189 mutex_init(&dev->lock);
190
191 res = v4l2_device_register(NULL, v4l2_dev);
192 if (res < 0) {
193 v4l2_err(v4l2_dev, "could not register v4l2_device\n");
194 return -EINVAL;
195 }
196
197 hdl = &dev->ctrl_handler;
198 v4l2_ctrl_handler_init(hdl, 1);
199 v4l2_ctrl_new_std(hdl, &pcm20_ctrl_ops,
200 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
201 v4l2_dev->ctrl_handler = hdl;
202 if (hdl->error) {
203 res = hdl->error;
204 v4l2_err(v4l2_dev, "Could not register control\n");
205 goto err_hdl;
206 }
207 strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
208 dev->vdev.v4l2_dev = v4l2_dev;
209 dev->vdev.fops = &pcm20_fops;
210 dev->vdev.ioctl_ops = &pcm20_ioctl_ops;
211 dev->vdev.release = video_device_release_empty;
212 dev->vdev.lock = &dev->lock;
213 set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev.flags);
214 video_set_drvdata(&dev->vdev, dev);
215 snd_aci_cmd(dev->aci, ACI_SET_TUNERMONO,
216 dev->audmode == V4L2_TUNER_MODE_MONO, -1);
217 pcm20_setfreq(dev, dev->freq);
218
219 if (video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr) < 0)
220 goto err_hdl;
221
222 v4l2_info(v4l2_dev, "Mirosound PCM20 Radio tuner\n");
223 return 0;
224err_hdl:
225 v4l2_ctrl_handler_free(hdl);
226 v4l2_device_unregister(v4l2_dev);
227 return -EINVAL;
228}
229
230MODULE_AUTHOR("Ruurd Reitsma, Krzysztof Helt");
231MODULE_DESCRIPTION("A driver for the Miro PCM20 radio card.");
232MODULE_LICENSE("GPL");
233
234static void __exit pcm20_cleanup(void)
235{
236 struct pcm20 *dev = &pcm20_card;
237
238 video_unregister_device(&dev->vdev);
239 snd_aci_cmd(dev->aci, ACI_SET_TUNERMUTE, 1, -1);
240 v4l2_ctrl_handler_free(&dev->ctrl_handler);
241 v4l2_device_unregister(&dev->v4l2_dev);
242}
243
244module_init(pcm20_init);
245module_exit(pcm20_cleanup);
246
