1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/module.h>
19#include <linux/init.h>
20#include <linux/ioport.h>
21#include <linux/delay.h>
22#include <linux/videodev2.h>
23#include <linux/io.h>
24#include <linux/slab.h>
25#include <media/v4l2-device.h>
26#include <media/v4l2-ioctl.h>
27#include <media/v4l2-fh.h>
28#include <media/v4l2-ctrls.h>
29#include <media/v4l2-event.h>
30
31#include "radio-isa.h"
32
33MODULE_AUTHOR("Hans Verkuil");
34MODULE_DESCRIPTION("A framework for ISA radio drivers.");
35MODULE_LICENSE("GPL");
36
37#define FREQ_LOW (87U * 16000U)
38#define FREQ_HIGH (108U * 16000U)
39
40static int radio_isa_querycap(struct file *file, void *priv,
41 struct v4l2_capability *v)
42{
43 struct radio_isa_card *isa = video_drvdata(file);
44
45 strlcpy(v->driver, isa->drv->driver.driver.name, sizeof(v->driver));
46 strlcpy(v->card, isa->drv->card, sizeof(v->card));
47 snprintf(v->bus_info, sizeof(v->bus_info), "ISA:%s", isa->v4l2_dev.name);
48
49 v->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
50 v->capabilities = v->device_caps | V4L2_CAP_DEVICE_CAPS;
51 return 0;
52}
53
54static int radio_isa_g_tuner(struct file *file, void *priv,
55 struct v4l2_tuner *v)
56{
57 struct radio_isa_card *isa = video_drvdata(file);
58 const struct radio_isa_ops *ops = isa->drv->ops;
59
60 if (v->index > 0)
61 return -EINVAL;
62
63 strlcpy(v->name, "FM", sizeof(v->name));
64 v->type = V4L2_TUNER_RADIO;
65 v->rangelow = FREQ_LOW;
66 v->rangehigh = FREQ_HIGH;
67 v->capability = V4L2_TUNER_CAP_LOW;
68 if (isa->drv->has_stereo)
69 v->capability |= V4L2_TUNER_CAP_STEREO;
70
71 if (ops->g_rxsubchans)
72 v->rxsubchans = ops->g_rxsubchans(isa);
73 else
74 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
75 v->audmode = isa->stereo ? V4L2_TUNER_MODE_STEREO : V4L2_TUNER_MODE_MONO;
76 if (ops->g_signal)
77 v->signal = ops->g_signal(isa);
78 else
79 v->signal = (v->rxsubchans & V4L2_TUNER_SUB_STEREO) ?
80 0xffff : 0;
81 return 0;
82}
83
84static int radio_isa_s_tuner(struct file *file, void *priv,
85 const struct v4l2_tuner *v)
86{
87 struct radio_isa_card *isa = video_drvdata(file);
88 const struct radio_isa_ops *ops = isa->drv->ops;
89
90 if (v->index)
91 return -EINVAL;
92 if (ops->s_stereo) {
93 isa->stereo = (v->audmode == V4L2_TUNER_MODE_STEREO);
94 return ops->s_stereo(isa, isa->stereo);
95 }
96 return 0;
97}
98
99static int radio_isa_s_frequency(struct file *file, void *priv,
100 const struct v4l2_frequency *f)
101{
102 struct radio_isa_card *isa = video_drvdata(file);
103 u32 freq = f->frequency;
104 int res;
105
106 if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
107 return -EINVAL;
108 freq = clamp(freq, FREQ_LOW, FREQ_HIGH);
109 res = isa->drv->ops->s_frequency(isa, freq);
110 if (res == 0)
111 isa->freq = freq;
112 return res;
113}
114
115static int radio_isa_g_frequency(struct file *file, void *priv,
116 struct v4l2_frequency *f)
117{
118 struct radio_isa_card *isa = video_drvdata(file);
119
120 if (f->tuner != 0)
121 return -EINVAL;
122 f->type = V4L2_TUNER_RADIO;
123 f->frequency = isa->freq;
124 return 0;
125}
126
127static int radio_isa_s_ctrl(struct v4l2_ctrl *ctrl)
128{
129 struct radio_isa_card *isa =
130 container_of(ctrl->handler, struct radio_isa_card, hdl);
131
132 switch (ctrl->id) {
133 case V4L2_CID_AUDIO_MUTE:
134 return isa->drv->ops->s_mute_volume(isa, ctrl->val,
135 isa->volume ? isa->volume->val : 0);
136 }
137 return -EINVAL;
138}
139
140static int radio_isa_log_status(struct file *file, void *priv)
141{
142 struct radio_isa_card *isa = video_drvdata(file);
143
144 v4l2_info(&isa->v4l2_dev, "I/O Port = 0x%03x\n", isa->io);
145 v4l2_ctrl_handler_log_status(&isa->hdl, isa->v4l2_dev.name);
146 return 0;
147}
148
149static const struct v4l2_ctrl_ops radio_isa_ctrl_ops = {
150 .s_ctrl = radio_isa_s_ctrl,
151};
152
153static const struct v4l2_file_operations radio_isa_fops = {
154 .owner = THIS_MODULE,
155 .open = v4l2_fh_open,
156 .release = v4l2_fh_release,
157 .poll = v4l2_ctrl_poll,
158 .unlocked_ioctl = video_ioctl2,
159};
160
161static const struct v4l2_ioctl_ops radio_isa_ioctl_ops = {
162 .vidioc_querycap = radio_isa_querycap,
163 .vidioc_g_tuner = radio_isa_g_tuner,
164 .vidioc_s_tuner = radio_isa_s_tuner,
165 .vidioc_g_frequency = radio_isa_g_frequency,
166 .vidioc_s_frequency = radio_isa_s_frequency,
167 .vidioc_log_status = radio_isa_log_status,
168 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
169 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
170};
171
172int radio_isa_match(struct device *pdev, unsigned int dev)
173{
174 struct radio_isa_driver *drv = pdev->platform_data;
175
176 return drv->probe || drv->io_params[dev] >= 0;
177}
178EXPORT_SYMBOL_GPL(radio_isa_match);
179
180static bool radio_isa_valid_io(const struct radio_isa_driver *drv, int io)
181{
182 int i;
183
184 for (i = 0; i < drv->num_of_io_ports; i++)
185 if (drv->io_ports[i] == io)
186 return true;
187 return false;
188}
189
190static struct radio_isa_card *radio_isa_alloc(struct radio_isa_driver *drv,
191 struct device *pdev)
192{
193 struct v4l2_device *v4l2_dev;
194 struct radio_isa_card *isa = drv->ops->alloc();
195 if (!isa)
196 return NULL;
197
198 dev_set_drvdata(pdev, isa);
199 isa->drv = drv;
200 v4l2_dev = &isa->v4l2_dev;
201 strlcpy(v4l2_dev->name, dev_name(pdev), sizeof(v4l2_dev->name));
202
203 return isa;
204}
205
206static int radio_isa_common_probe(struct radio_isa_card *isa,
207 struct device *pdev,
208 int radio_nr, unsigned region_size)
209{
210 const struct radio_isa_driver *drv = isa->drv;
211 const struct radio_isa_ops *ops = drv->ops;
212 struct v4l2_device *v4l2_dev = &isa->v4l2_dev;
213 int res;
214
215 if (!request_region(isa->io, region_size, v4l2_dev->name)) {
216 v4l2_err(v4l2_dev, "port 0x%x already in use\n", isa->io);
217 kfree(isa);
218 return -EBUSY;
219 }
220
221 res = v4l2_device_register(pdev, v4l2_dev);
222 if (res < 0) {
223 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
224 goto err_dev_reg;
225 }
226
227 v4l2_ctrl_handler_init(&isa->hdl, 1);
228 isa->mute = v4l2_ctrl_new_std(&isa->hdl, &radio_isa_ctrl_ops,
229 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
230 if (drv->max_volume)
231 isa->volume = v4l2_ctrl_new_std(&isa->hdl, &radio_isa_ctrl_ops,
232 V4L2_CID_AUDIO_VOLUME, 0, drv->max_volume, 1,
233 drv->max_volume);
234 v4l2_dev->ctrl_handler = &isa->hdl;
235 if (isa->hdl.error) {
236 res = isa->hdl.error;
237 v4l2_err(v4l2_dev, "Could not register controls\n");
238 goto err_hdl;
239 }
240 if (drv->max_volume)
241 v4l2_ctrl_cluster(2, &isa->mute);
242 v4l2_dev->ctrl_handler = &isa->hdl;
243
244 mutex_init(&isa->lock);
245 isa->vdev.lock = &isa->lock;
246 strlcpy(isa->vdev.name, v4l2_dev->name, sizeof(isa->vdev.name));
247 isa->vdev.v4l2_dev = v4l2_dev;
248 isa->vdev.fops = &radio_isa_fops;
249 isa->vdev.ioctl_ops = &radio_isa_ioctl_ops;
250 isa->vdev.release = video_device_release_empty;
251 video_set_drvdata(&isa->vdev, isa);
252 isa->freq = FREQ_LOW;
253 isa->stereo = drv->has_stereo;
254
255 if (ops->init)
256 res = ops->init(isa);
257 if (!res)
258 res = v4l2_ctrl_handler_setup(&isa->hdl);
259 if (!res)
260 res = ops->s_frequency(isa, isa->freq);
261 if (!res && ops->s_stereo)
262 res = ops->s_stereo(isa, isa->stereo);
263 if (res < 0) {
264 v4l2_err(v4l2_dev, "Could not setup card\n");
265 goto err_hdl;
266 }
267 res = video_register_device(&isa->vdev, VFL_TYPE_RADIO, radio_nr);
268
269 if (res < 0) {
270 v4l2_err(v4l2_dev, "Could not register device node\n");
271 goto err_hdl;
272 }
273
274 v4l2_info(v4l2_dev, "Initialized radio card %s on port 0x%03x\n",
275 drv->card, isa->io);
276 return 0;
277
278err_hdl:
279 v4l2_ctrl_handler_free(&isa->hdl);
280err_dev_reg:
281 release_region(isa->io, region_size);
282 kfree(isa);
283 return res;
284}
285
286static int radio_isa_common_remove(struct radio_isa_card *isa,
287 unsigned region_size)
288{
289 const struct radio_isa_ops *ops = isa->drv->ops;
290
291 ops->s_mute_volume(isa, true, isa->volume ? isa->volume->cur.val : 0);
292 video_unregister_device(&isa->vdev);
293 v4l2_ctrl_handler_free(&isa->hdl);
294 v4l2_device_unregister(&isa->v4l2_dev);
295 release_region(isa->io, region_size);
296 v4l2_info(&isa->v4l2_dev, "Removed radio card %s\n", isa->drv->card);
297 kfree(isa);
298 return 0;
299}
300
301int radio_isa_probe(struct device *pdev, unsigned int dev)
302{
303 struct radio_isa_driver *drv = pdev->platform_data;
304 const struct radio_isa_ops *ops = drv->ops;
305 struct v4l2_device *v4l2_dev;
306 struct radio_isa_card *isa;
307
308 isa = radio_isa_alloc(drv, pdev);
309 if (!isa)
310 return -ENOMEM;
311 isa->io = drv->io_params[dev];
312 v4l2_dev = &isa->v4l2_dev;
313
314 if (drv->probe && ops->probe) {
315 int i;
316
317 for (i = 0; i < drv->num_of_io_ports; ++i) {
318 int io = drv->io_ports[i];
319
320 if (request_region(io, drv->region_size, v4l2_dev->name)) {
321 bool found = ops->probe(isa, io);
322
323 release_region(io, drv->region_size);
324 if (found) {
325 isa->io = io;
326 break;
327 }
328 }
329 }
330 }
331
332 if (!radio_isa_valid_io(drv, isa->io)) {
333 int i;
334
335 if (isa->io < 0)
336 return -ENODEV;
337 v4l2_err(v4l2_dev, "you must set an I/O address with io=0x%03x",
338 drv->io_ports[0]);
339 for (i = 1; i < drv->num_of_io_ports; i++)
340 printk(KERN_CONT "/0x%03x", drv->io_ports[i]);
341 printk(KERN_CONT ".\n");
342 kfree(isa);
343 return -EINVAL;
344 }
345
346 return radio_isa_common_probe(isa, pdev, drv->radio_nr_params[dev],
347 drv->region_size);
348}
349EXPORT_SYMBOL_GPL(radio_isa_probe);
350
351int radio_isa_remove(struct device *pdev, unsigned int dev)
352{
353 struct radio_isa_card *isa = dev_get_drvdata(pdev);
354
355 return radio_isa_common_remove(isa, isa->drv->region_size);
356}
357EXPORT_SYMBOL_GPL(radio_isa_remove);
358
359#ifdef CONFIG_PNP
360int radio_isa_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
361{
362 struct pnp_driver *pnp_drv = to_pnp_driver(dev->dev.driver);
363 struct radio_isa_driver *drv = container_of(pnp_drv,
364 struct radio_isa_driver, pnp_driver);
365 struct radio_isa_card *isa;
366
367 if (!pnp_port_valid(dev, 0))
368 return -ENODEV;
369
370 isa = radio_isa_alloc(drv, &dev->dev);
371 if (!isa)
372 return -ENOMEM;
373
374 isa->io = pnp_port_start(dev, 0);
375
376 return radio_isa_common_probe(isa, &dev->dev, drv->radio_nr_params[0],
377 pnp_port_len(dev, 0));
378}
379EXPORT_SYMBOL_GPL(radio_isa_pnp_probe);
380
381void radio_isa_pnp_remove(struct pnp_dev *dev)
382{
383 struct radio_isa_card *isa = dev_get_drvdata(&dev->dev);
384
385 radio_isa_common_remove(isa, pnp_port_len(dev, 0));
386}
387EXPORT_SYMBOL_GPL(radio_isa_pnp_remove);
388#endif
389
