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
32
33
34#include <linux/module.h>
35#include <linux/init.h>
36#include <linux/ioport.h>
37#include <linux/version.h>
38#include <linux/videodev2.h>
39#include <linux/io.h>
40#include <media/v4l2-device.h>
41#include <media/v4l2-ioctl.h>
42
43MODULE_AUTHOR("Dr. Henrik Seidel");
44MODULE_DESCRIPTION("A driver for the Typhoon radio card (a.k.a. EcoRadio).");
45MODULE_LICENSE("GPL");
46
47#ifndef CONFIG_RADIO_TYPHOON_PORT
48#define CONFIG_RADIO_TYPHOON_PORT -1
49#endif
50
51#ifndef CONFIG_RADIO_TYPHOON_MUTEFREQ
52#define CONFIG_RADIO_TYPHOON_MUTEFREQ 0
53#endif
54
55static int io = CONFIG_RADIO_TYPHOON_PORT;
56static int radio_nr = -1;
57
58module_param(io, int, 0);
59MODULE_PARM_DESC(io, "I/O address of the Typhoon card (0x316 or 0x336)");
60
61module_param(radio_nr, int, 0);
62
63static unsigned long mutefreq = CONFIG_RADIO_TYPHOON_MUTEFREQ;
64module_param(mutefreq, ulong, 0);
65MODULE_PARM_DESC(mutefreq, "Frequency used when muting the card (in kHz)");
66
67#define RADIO_VERSION KERNEL_VERSION(0, 1, 1)
68
69#define BANNER "Typhoon Radio Card driver v0.1.1\n"
70
71struct typhoon {
72 struct v4l2_device v4l2_dev;
73 struct video_device vdev;
74 int io;
75 int curvol;
76 int muted;
77 unsigned long curfreq;
78 unsigned long mutefreq;
79 struct mutex lock;
80};
81
82static struct typhoon typhoon_card;
83
84static void typhoon_setvol_generic(struct typhoon *dev, int vol)
85{
86 mutex_lock(&dev->lock);
87 vol >>= 14;
88 vol &= 3;
89 outb_p(vol / 2, dev->io);
90 outb_p(vol % 2, dev->io + 2);
91 mutex_unlock(&dev->lock);
92}
93
94static int typhoon_setfreq_generic(struct typhoon *dev,
95 unsigned long frequency)
96{
97 unsigned long outval;
98 unsigned long x;
99
100
101
102
103
104
105
106
107
108
109
110
111 mutex_lock(&dev->lock);
112 x = frequency / 160;
113 outval = (x * x + 2500) / 5000;
114 outval = (outval * x + 5000) / 10000;
115 outval -= (10 * x * x + 10433) / 20866;
116 outval += 4 * x - 11505;
117
118 outb_p((outval >> 8) & 0x01, dev->io + 4);
119 outb_p(outval >> 9, dev->io + 6);
120 outb_p(outval & 0xff, dev->io + 8);
121 mutex_unlock(&dev->lock);
122
123 return 0;
124}
125
126static int typhoon_setfreq(struct typhoon *dev, unsigned long frequency)
127{
128 typhoon_setfreq_generic(dev, frequency);
129 dev->curfreq = frequency;
130 return 0;
131}
132
133static void typhoon_mute(struct typhoon *dev)
134{
135 if (dev->muted == 1)
136 return;
137 typhoon_setvol_generic(dev, 0);
138 typhoon_setfreq_generic(dev, dev->mutefreq);
139 dev->muted = 1;
140}
141
142static void typhoon_unmute(struct typhoon *dev)
143{
144 if (dev->muted == 0)
145 return;
146 typhoon_setfreq_generic(dev, dev->curfreq);
147 typhoon_setvol_generic(dev, dev->curvol);
148 dev->muted = 0;
149}
150
151static int typhoon_setvol(struct typhoon *dev, int vol)
152{
153 if (dev->muted && vol != 0) {
154 dev->curvol = vol;
155 typhoon_unmute(dev);
156 return 0;
157 }
158 if (vol == dev->curvol)
159 return 0;
160
161 if (vol == 0) {
162 typhoon_mute(dev);
163 dev->curvol = vol;
164 return 0;
165 }
166 typhoon_setvol_generic(dev, vol);
167 dev->curvol = vol;
168 return 0;
169}
170
171static int vidioc_querycap(struct file *file, void *priv,
172 struct v4l2_capability *v)
173{
174 strlcpy(v->driver, "radio-typhoon", sizeof(v->driver));
175 strlcpy(v->card, "Typhoon Radio", sizeof(v->card));
176 strlcpy(v->bus_info, "ISA", sizeof(v->bus_info));
177 v->version = RADIO_VERSION;
178 v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
179 return 0;
180}
181
182static int vidioc_g_tuner(struct file *file, void *priv,
183 struct v4l2_tuner *v)
184{
185 if (v->index > 0)
186 return -EINVAL;
187
188 strlcpy(v->name, "FM", sizeof(v->name));
189 v->type = V4L2_TUNER_RADIO;
190 v->rangelow = 87.5 * 16000;
191 v->rangehigh = 108 * 16000;
192 v->rxsubchans = V4L2_TUNER_SUB_MONO;
193 v->capability = V4L2_TUNER_CAP_LOW;
194 v->audmode = V4L2_TUNER_MODE_MONO;
195 v->signal = 0xFFFF;
196 return 0;
197}
198
199static int vidioc_s_tuner(struct file *file, void *priv,
200 struct v4l2_tuner *v)
201{
202 return v->index ? -EINVAL : 0;
203}
204
205static int vidioc_g_frequency(struct file *file, void *priv,
206 struct v4l2_frequency *f)
207{
208 struct typhoon *dev = video_drvdata(file);
209
210 f->type = V4L2_TUNER_RADIO;
211 f->frequency = dev->curfreq;
212 return 0;
213}
214
215static int vidioc_s_frequency(struct file *file, void *priv,
216 struct v4l2_frequency *f)
217{
218 struct typhoon *dev = video_drvdata(file);
219
220 dev->curfreq = f->frequency;
221 typhoon_setfreq(dev, dev->curfreq);
222 return 0;
223}
224
225static int vidioc_queryctrl(struct file *file, void *priv,
226 struct v4l2_queryctrl *qc)
227{
228 switch (qc->id) {
229 case V4L2_CID_AUDIO_MUTE:
230 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
231 case V4L2_CID_AUDIO_VOLUME:
232 return v4l2_ctrl_query_fill(qc, 0, 65535, 16384, 65535);
233 }
234 return -EINVAL;
235}
236
237static int vidioc_g_ctrl(struct file *file, void *priv,
238 struct v4l2_control *ctrl)
239{
240 struct typhoon *dev = video_drvdata(file);
241
242 switch (ctrl->id) {
243 case V4L2_CID_AUDIO_MUTE:
244 ctrl->value = dev->muted;
245 return 0;
246 case V4L2_CID_AUDIO_VOLUME:
247 ctrl->value = dev->curvol;
248 return 0;
249 }
250 return -EINVAL;
251}
252
253static int vidioc_s_ctrl (struct file *file, void *priv,
254 struct v4l2_control *ctrl)
255{
256 struct typhoon *dev = video_drvdata(file);
257
258 switch (ctrl->id) {
259 case V4L2_CID_AUDIO_MUTE:
260 if (ctrl->value)
261 typhoon_mute(dev);
262 else
263 typhoon_unmute(dev);
264 return 0;
265 case V4L2_CID_AUDIO_VOLUME:
266 typhoon_setvol(dev, ctrl->value);
267 return 0;
268 }
269 return -EINVAL;
270}
271
272static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
273{
274 *i = 0;
275 return 0;
276}
277
278static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
279{
280 return i ? -EINVAL : 0;
281}
282
283static int vidioc_g_audio(struct file *file, void *priv,
284 struct v4l2_audio *a)
285{
286 a->index = 0;
287 strlcpy(a->name, "Radio", sizeof(a->name));
288 a->capability = V4L2_AUDCAP_STEREO;
289 return 0;
290}
291
292static int vidioc_s_audio(struct file *file, void *priv,
293 struct v4l2_audio *a)
294{
295 return a->index ? -EINVAL : 0;
296}
297
298static int vidioc_log_status(struct file *file, void *priv)
299{
300 struct typhoon *dev = video_drvdata(file);
301 struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
302
303 v4l2_info(v4l2_dev, BANNER);
304#ifdef MODULE
305 v4l2_info(v4l2_dev, "Load type: Driver loaded as a module\n\n");
306#else
307 v4l2_info(v4l2_dev, "Load type: Driver compiled into kernel\n\n");
308#endif
309 v4l2_info(v4l2_dev, "frequency = %lu kHz\n", dev->curfreq >> 4);
310 v4l2_info(v4l2_dev, "volume = %d\n", dev->curvol);
311 v4l2_info(v4l2_dev, "mute = %s\n", dev->muted ? "on" : "off");
312 v4l2_info(v4l2_dev, "io = 0x%x\n", dev->io);
313 v4l2_info(v4l2_dev, "mute frequency = %lu kHz\n", dev->mutefreq >> 4);
314 return 0;
315}
316
317static const struct v4l2_file_operations typhoon_fops = {
318 .owner = THIS_MODULE,
319 .ioctl = video_ioctl2,
320};
321
322static const struct v4l2_ioctl_ops typhoon_ioctl_ops = {
323 .vidioc_log_status = vidioc_log_status,
324 .vidioc_querycap = vidioc_querycap,
325 .vidioc_g_tuner = vidioc_g_tuner,
326 .vidioc_s_tuner = vidioc_s_tuner,
327 .vidioc_g_audio = vidioc_g_audio,
328 .vidioc_s_audio = vidioc_s_audio,
329 .vidioc_g_input = vidioc_g_input,
330 .vidioc_s_input = vidioc_s_input,
331 .vidioc_g_frequency = vidioc_g_frequency,
332 .vidioc_s_frequency = vidioc_s_frequency,
333 .vidioc_queryctrl = vidioc_queryctrl,
334 .vidioc_g_ctrl = vidioc_g_ctrl,
335 .vidioc_s_ctrl = vidioc_s_ctrl,
336};
337
338static int __init typhoon_init(void)
339{
340 struct typhoon *dev = &typhoon_card;
341 struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
342 int res;
343
344 strlcpy(v4l2_dev->name, "typhoon", sizeof(v4l2_dev->name));
345 dev->io = io;
346 dev->curfreq = dev->mutefreq = mutefreq;
347
348 if (dev->io == -1) {
349 v4l2_err(v4l2_dev, "You must set an I/O address with io=0x316 or io=0x336\n");
350 return -EINVAL;
351 }
352
353 if (dev->mutefreq < 87000 || dev->mutefreq > 108500) {
354 v4l2_err(v4l2_dev, "You must set a frequency (in kHz) used when muting the card,\n");
355 v4l2_err(v4l2_dev, "e.g. with \"mutefreq=87500\" (87000 <= mutefreq <= 108500)\n");
356 return -EINVAL;
357 }
358
359 mutex_init(&dev->lock);
360 if (!request_region(dev->io, 8, "typhoon")) {
361 v4l2_err(v4l2_dev, "port 0x%x already in use\n",
362 dev->io);
363 return -EBUSY;
364 }
365
366 res = v4l2_device_register(NULL, v4l2_dev);
367 if (res < 0) {
368 release_region(dev->io, 8);
369 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
370 return res;
371 }
372 v4l2_info(v4l2_dev, BANNER);
373
374 strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
375 dev->vdev.v4l2_dev = v4l2_dev;
376 dev->vdev.fops = &typhoon_fops;
377 dev->vdev.ioctl_ops = &typhoon_ioctl_ops;
378 dev->vdev.release = video_device_release_empty;
379 video_set_drvdata(&dev->vdev, dev);
380 if (video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
381 v4l2_device_unregister(&dev->v4l2_dev);
382 release_region(dev->io, 8);
383 return -EINVAL;
384 }
385 v4l2_info(v4l2_dev, "port 0x%x.\n", dev->io);
386 v4l2_info(v4l2_dev, "mute frequency is %lu kHz.\n", dev->mutefreq);
387 dev->mutefreq <<= 4;
388
389
390 typhoon_mute(dev);
391
392 return 0;
393}
394
395static void __exit typhoon_exit(void)
396{
397 struct typhoon *dev = &typhoon_card;
398
399 video_unregister_device(&dev->vdev);
400 v4l2_device_unregister(&dev->v4l2_dev);
401 release_region(dev->io, 8);
402}
403
404module_init(typhoon_init);
405module_exit(typhoon_exit);
406
407
