1 /* zoltrix radio plus driver for Linux radio support
2 * (c) 1998 C. van Schaik <carl@leg.uct.ac.za>
5 * Due to the inconsistency in reading from the signal flags
6 * it is difficult to get an accurate tuned signal.
8 * It seems that the card is not linear to 0 volume. It cuts off
9 * at a low volume, and it is not possible (at least I have not found)
10 * to get fine volume control over the low volume range.
12 * Some code derived from code by Romolo Manfredini
15 * 1999-05-06 - (C. van Schaik)
16 * - Make signal strength and stereo scans
17 * kinder to cpu while in delay
18 * 1999-01-05 - (C. van Schaik)
19 * - Changed tuning to 1/160Mhz accuracy
20 * - Added stereo support
21 * (card defaults to stereo)
22 * (can explicitly force mono on the card)
23 * (can detect if station is in stereo)
24 * - Added unmute function
25 * - Reworked ioctl functions
26 * 2002-07-15 - Fix Stereo typo
28 * 2006-07-24 - Converted to V4L2 API
29 * by Mauro Carvalho Chehab <mchehab@infradead.org>
32 #include <linux/module.h> /* Modules */
33 #include <linux/init.h> /* Initdata */
34 #include <linux/ioport.h> /* request_region */
35 #include <linux/delay.h> /* udelay, msleep */
36 #include <linux/videodev2.h> /* kernel radio structs */
37 #include <linux/mutex.h>
38 #include <linux/version.h> /* for KERNEL_VERSION MACRO */
39 #include <linux/io.h> /* outb, outb_p */
40 #include <linux/uaccess.h> /* copy to/from user */
41 #include <media/v4l2-device.h>
42 #include <media/v4l2-ioctl.h>
44 MODULE_AUTHOR("C.van Schaik");
45 MODULE_DESCRIPTION("A driver for the Zoltrix Radio Plus.");
46 MODULE_LICENSE("GPL");
48 #ifndef CONFIG_RADIO_ZOLTRIX_PORT
49 #define CONFIG_RADIO_ZOLTRIX_PORT -1
52 static int io = CONFIG_RADIO_ZOLTRIX_PORT;
53 static int radio_nr = -1;
55 module_param(io, int, 0);
56 MODULE_PARM_DESC(io, "I/O address of the Zoltrix Radio Plus (0x20c or 0x30c)");
57 module_param(radio_nr, int, 0);
59 #define RADIO_VERSION KERNEL_VERSION(0, 0, 2)
62 struct v4l2_device v4l2_dev;
63 struct video_device vdev;
66 unsigned long curfreq;
72 static struct zoltrix zoltrix_card;
74 static int zol_setvol(struct zoltrix *zol, int vol)
80 mutex_lock(&zol->lock);
84 inb(zol->io + 3); /* Zoltrix needs to be read to confirm */
85 mutex_unlock(&zol->lock);
89 outb(zol->curvol-1, zol->io);
92 mutex_unlock(&zol->lock);
96 static void zol_mute(struct zoltrix *zol)
99 mutex_lock(&zol->lock);
102 inb(zol->io + 3); /* Zoltrix needs to be read to confirm */
103 mutex_unlock(&zol->lock);
106 static void zol_unmute(struct zoltrix *zol)
109 zol_setvol(zol, zol->curvol);
112 static int zol_setfreq(struct zoltrix *zol, unsigned long freq)
114 /* tunes the radio to the desired frequency */
115 struct v4l2_device *v4l2_dev = &zol->v4l2_dev;
116 unsigned long long bitmask, f, m;
117 unsigned int stereo = zol->stereo;
121 v4l2_warn(v4l2_dev, "cannot set a frequency of 0.\n");
125 m = (freq / 160 - 8800) * 2;
126 f = (unsigned long long)m + 0x4d1c;
128 bitmask = 0xc480402c10080000ull;
131 mutex_lock(&zol->lock);
137 inb(zol->io + 3); /* Zoltrix needs to be read to confirm */
142 bitmask = (bitmask ^ ((f & 0xff) << 47) ^ ((f & 0xff00) << 30) ^ (stereo << 31));
144 if ((bitmask & 0x8000000000000000ull) != 0) {
161 /* termination sequence */
177 mutex_unlock(&zol->lock);
180 zol_setvol(zol, zol->curvol);
184 /* Get signal strength */
185 static int zol_getsigstr(struct zoltrix *zol)
189 mutex_lock(&zol->lock);
190 outb(0x00, zol->io); /* This stuff I found to do nothing */
191 outb(zol->curvol, zol->io);
198 mutex_unlock(&zol->lock);
203 /* I found this out by playing with a binary scanner on the card io */
204 return a == 0xcf || a == 0xdf || a == 0xef;
207 static int zol_is_stereo(struct zoltrix *zol)
211 mutex_lock(&zol->lock);
214 outb(zol->curvol, zol->io);
221 mutex_unlock(&zol->lock);
223 return x1 == x2 && x1 == 0xcf;
226 static int vidioc_querycap(struct file *file, void *priv,
227 struct v4l2_capability *v)
229 strlcpy(v->driver, "radio-zoltrix", sizeof(v->driver));
230 strlcpy(v->card, "Zoltrix Radio", sizeof(v->card));
231 strlcpy(v->bus_info, "ISA", sizeof(v->bus_info));
232 v->version = RADIO_VERSION;
233 v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
237 static int vidioc_g_tuner(struct file *file, void *priv,
238 struct v4l2_tuner *v)
240 struct zoltrix *zol = video_drvdata(file);
245 strlcpy(v->name, "FM", sizeof(v->name));
246 v->type = V4L2_TUNER_RADIO;
247 v->rangelow = 88 * 16000;
248 v->rangehigh = 108 * 16000;
249 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
250 v->capability = V4L2_TUNER_CAP_LOW;
251 if (zol_is_stereo(zol))
252 v->audmode = V4L2_TUNER_MODE_STEREO;
254 v->audmode = V4L2_TUNER_MODE_MONO;
255 v->signal = 0xFFFF * zol_getsigstr(zol);
259 static int vidioc_s_tuner(struct file *file, void *priv,
260 struct v4l2_tuner *v)
262 return v->index ? -EINVAL : 0;
265 static int vidioc_s_frequency(struct file *file, void *priv,
266 struct v4l2_frequency *f)
268 struct zoltrix *zol = video_drvdata(file);
270 if (zol_setfreq(zol, f->frequency) != 0)
275 static int vidioc_g_frequency(struct file *file, void *priv,
276 struct v4l2_frequency *f)
278 struct zoltrix *zol = video_drvdata(file);
280 f->type = V4L2_TUNER_RADIO;
281 f->frequency = zol->curfreq;
285 static int vidioc_queryctrl(struct file *file, void *priv,
286 struct v4l2_queryctrl *qc)
289 case V4L2_CID_AUDIO_MUTE:
290 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
291 case V4L2_CID_AUDIO_VOLUME:
292 return v4l2_ctrl_query_fill(qc, 0, 65535, 4096, 65535);
297 static int vidioc_g_ctrl(struct file *file, void *priv,
298 struct v4l2_control *ctrl)
300 struct zoltrix *zol = video_drvdata(file);
303 case V4L2_CID_AUDIO_MUTE:
304 ctrl->value = zol->muted;
306 case V4L2_CID_AUDIO_VOLUME:
307 ctrl->value = zol->curvol * 4096;
313 static int vidioc_s_ctrl(struct file *file, void *priv,
314 struct v4l2_control *ctrl)
316 struct zoltrix *zol = video_drvdata(file);
319 case V4L2_CID_AUDIO_MUTE:
324 zol_setvol(zol, zol->curvol);
327 case V4L2_CID_AUDIO_VOLUME:
328 zol_setvol(zol, ctrl->value / 4096);
332 if (zol_setfreq(zol, zol->curfreq) != 0)
335 /* FIXME: Implement stereo/mono switch on V4L2 */
336 if (v->mode & VIDEO_SOUND_STEREO) {
338 zol_setfreq(zol, zol->curfreq);
340 if (v->mode & VIDEO_SOUND_MONO) {
342 zol_setfreq(zol, zol->curfreq);
348 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
354 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
356 return i ? -EINVAL : 0;
359 static int vidioc_g_audio(struct file *file, void *priv,
360 struct v4l2_audio *a)
363 strlcpy(a->name, "Radio", sizeof(a->name));
364 a->capability = V4L2_AUDCAP_STEREO;
368 static int vidioc_s_audio(struct file *file, void *priv,
369 struct v4l2_audio *a)
371 return a->index ? -EINVAL : 0;
374 static int zoltrix_open(struct file *file)
379 static int zoltrix_release(struct file *file)
384 static const struct v4l2_file_operations zoltrix_fops =
386 .owner = THIS_MODULE,
387 .open = zoltrix_open,
388 .release = zoltrix_release,
389 .ioctl = video_ioctl2,
392 static const struct v4l2_ioctl_ops zoltrix_ioctl_ops = {
393 .vidioc_querycap = vidioc_querycap,
394 .vidioc_g_tuner = vidioc_g_tuner,
395 .vidioc_s_tuner = vidioc_s_tuner,
396 .vidioc_g_audio = vidioc_g_audio,
397 .vidioc_s_audio = vidioc_s_audio,
398 .vidioc_g_input = vidioc_g_input,
399 .vidioc_s_input = vidioc_s_input,
400 .vidioc_g_frequency = vidioc_g_frequency,
401 .vidioc_s_frequency = vidioc_s_frequency,
402 .vidioc_queryctrl = vidioc_queryctrl,
403 .vidioc_g_ctrl = vidioc_g_ctrl,
404 .vidioc_s_ctrl = vidioc_s_ctrl,
407 static int __init zoltrix_init(void)
409 struct zoltrix *zol = &zoltrix_card;
410 struct v4l2_device *v4l2_dev = &zol->v4l2_dev;
413 strlcpy(v4l2_dev->name, "zoltrix", sizeof(v4l2_dev->name));
416 v4l2_err(v4l2_dev, "You must set an I/O address with io=0x???\n");
419 if (zol->io != 0x20c && zol->io != 0x30c) {
420 v4l2_err(v4l2_dev, "invalid port, try 0x20c or 0x30c\n");
424 if (!request_region(zol->io, 2, "zoltrix")) {
425 v4l2_err(v4l2_dev, "port 0x%x already in use\n", zol->io);
429 res = v4l2_device_register(NULL, v4l2_dev);
431 release_region(zol->io, 2);
432 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
436 strlcpy(zol->vdev.name, v4l2_dev->name, sizeof(zol->vdev.name));
437 zol->vdev.v4l2_dev = v4l2_dev;
438 zol->vdev.fops = &zoltrix_fops;
439 zol->vdev.ioctl_ops = &zoltrix_ioctl_ops;
440 zol->vdev.release = video_device_release_empty;
441 video_set_drvdata(&zol->vdev, zol);
443 if (video_register_device(&zol->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
444 v4l2_device_unregister(v4l2_dev);
445 release_region(zol->io, 2);
448 v4l2_info(v4l2_dev, "Zoltrix Radio Plus card driver.\n");
450 mutex_init(&zol->lock);
452 /* mute card - prevents noisy bootups */
454 /* this ensures that the volume is all the way down */
467 static void __exit zoltrix_exit(void)
469 struct zoltrix *zol = &zoltrix_card;
471 video_unregister_device(&zol->vdev);
472 v4l2_device_unregister(&zol->v4l2_dev);
473 release_region(zol->io, 2);
476 module_init(zoltrix_init);
477 module_exit(zoltrix_exit);