radio-zoltrix.c (e4da3fbfbd1de56d2367653e3823e6445e49f8a9) radio-zoltrix.c (6b39246cf9a4614cd3e449f5a36b39d50357fc98)
1/* zoltrix radio plus driver for Linux radio support
2 * (c) 1998 C. van Schaik <carl@leg.uct.ac.za>
1/*
2 * Zoltrix Radio Plus driver
3 * Copyright 1998 C. van Schaik <carl@leg.uct.ac.za>
3 *
4 * BUGS
5 * Due to the inconsistency in reading from the signal flags
6 * it is difficult to get an accurate tuned signal.
7 *
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.

--- 11 unchanged lines hidden (view full) ---

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
27 *
28 * 2006-07-24 - Converted to V4L2 API
29 * by Mauro Carvalho Chehab <mchehab@infradead.org>
4 *
5 * BUGS
6 * Due to the inconsistency in reading from the signal flags
7 * it is difficult to get an accurate tuned signal.
8 *
9 * It seems that the card is not linear to 0 volume. It cuts off
10 * at a low volume, and it is not possible (at least I have not found)
11 * to get fine volume control over the low volume range.

--- 11 unchanged lines hidden (view full) ---

23 * (can explicitly force mono on the card)
24 * (can detect if station is in stereo)
25 * - Added unmute function
26 * - Reworked ioctl functions
27 * 2002-07-15 - Fix Stereo typo
28 *
29 * 2006-07-24 - Converted to V4L2 API
30 * by Mauro Carvalho Chehab <mchehab@infradead.org>
31 *
32 * Converted to the radio-isa framework by Hans Verkuil <hans.verkuil@cisco.com>
33 *
34 * Note that this is the driver for the Zoltrix Radio Plus.
35 * This driver does not work for the Zoltrix Radio Plus 108 or the
36 * Zoltrix Radio Plus for Windows.
37 *
38 * Fully tested with the Keene USB FM Transmitter and the v4l2-compliance tool.
30 */
31
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/io.h> /* outb, outb_p */
39#include <media/v4l2-device.h>
40#include <media/v4l2-ioctl.h>
39 */
40
41#include <linux/module.h> /* Modules */
42#include <linux/init.h> /* Initdata */
43#include <linux/ioport.h> /* request_region */
44#include <linux/delay.h> /* udelay, msleep */
45#include <linux/videodev2.h> /* kernel radio structs */
46#include <linux/mutex.h>
47#include <linux/io.h> /* outb, outb_p */
48#include <media/v4l2-device.h>
49#include <media/v4l2-ioctl.h>
50#include "radio-isa.h"
41
51
42MODULE_AUTHOR("C.van Schaik");
52MODULE_AUTHOR("C. van Schaik");
43MODULE_DESCRIPTION("A driver for the Zoltrix Radio Plus.");
44MODULE_LICENSE("GPL");
53MODULE_DESCRIPTION("A driver for the Zoltrix Radio Plus.");
54MODULE_LICENSE("GPL");
45MODULE_VERSION("0.0.3");
55MODULE_VERSION("0.1.99");
46
47#ifndef CONFIG_RADIO_ZOLTRIX_PORT
48#define CONFIG_RADIO_ZOLTRIX_PORT -1
49#endif
50
56
57#ifndef CONFIG_RADIO_ZOLTRIX_PORT
58#define CONFIG_RADIO_ZOLTRIX_PORT -1
59#endif
60
51static int io = CONFIG_RADIO_ZOLTRIX_PORT;
52static int radio_nr = -1;
61#define ZOLTRIX_MAX 2
53
62
54module_param(io, int, 0);
55MODULE_PARM_DESC(io, "I/O address of the Zoltrix Radio Plus (0x20c or 0x30c)");
56module_param(radio_nr, int, 0);
63static int io[ZOLTRIX_MAX] = { [0] = CONFIG_RADIO_ZOLTRIX_PORT,
64 [1 ... (ZOLTRIX_MAX - 1)] = -1 };
65static int radio_nr[ZOLTRIX_MAX] = { [0 ... (ZOLTRIX_MAX - 1)] = -1 };
57
66
67module_param_array(io, int, NULL, 0444);
68MODULE_PARM_DESC(io, "I/O addresses of the Zoltrix Radio Plus card (0x20c or 0x30c)");
69module_param_array(radio_nr, int, NULL, 0444);
70MODULE_PARM_DESC(radio_nr, "Radio device numbers");
71
58struct zoltrix {
72struct zoltrix {
59 struct v4l2_device v4l2_dev;
60 struct video_device vdev;
61 int io;
73 struct radio_isa_card isa;
62 int curvol;
74 int curvol;
63 unsigned long curfreq;
64 int muted;
65 unsigned int stereo;
66 struct mutex lock;
75 bool muted;
67};
68
76};
77
69static struct zoltrix zoltrix_card;
78static struct radio_isa_card *zoltrix_alloc(void)
79{
80 struct zoltrix *zol = kzalloc(sizeof(*zol), GFP_KERNEL);
70
81
71static int zol_setvol(struct zoltrix *zol, int vol)
82 return zol ? &zol->isa : NULL;
83}
84
85static int zoltrix_s_mute_volume(struct radio_isa_card *isa, bool mute, int vol)
72{
86{
87 struct zoltrix *zol = container_of(isa, struct zoltrix, isa);
88
73 zol->curvol = vol;
89 zol->curvol = vol;
74 if (zol->muted)
90 zol->muted = mute;
91 if (mute || vol == 0) {
92 outb(0, isa->io);
93 outb(0, isa->io);
94 inb(isa->io + 3); /* Zoltrix needs to be read to confirm */
75 return 0;
95 return 0;
76
77 mutex_lock(&zol->lock);
78 if (vol == 0) {
79 outb(0, zol->io);
80 outb(0, zol->io);
81 inb(zol->io + 3); /* Zoltrix needs to be read to confirm */
82 mutex_unlock(&zol->lock);
83 return 0;
84 }
85
96 }
97
86 outb(zol->curvol-1, zol->io);
98 outb(vol - 1, isa->io);
87 msleep(10);
99 msleep(10);
88 inb(zol->io + 2);
89 mutex_unlock(&zol->lock);
100 inb(isa->io + 2);
90 return 0;
91}
92
101 return 0;
102}
103
93static void zol_mute(struct zoltrix *zol)
104/* tunes the radio to the desired frequency */
105static int zoltrix_s_frequency(struct radio_isa_card *isa, u32 freq)
94{
106{
95 zol->muted = 1;
96 mutex_lock(&zol->lock);
97 outb(0, zol->io);
98 outb(0, zol->io);
99 inb(zol->io + 3); /* Zoltrix needs to be read to confirm */
100 mutex_unlock(&zol->lock);
101}
102
103static void zol_unmute(struct zoltrix *zol)
104{
105 zol->muted = 0;
106 zol_setvol(zol, zol->curvol);
107}
108
109static int zol_setfreq(struct zoltrix *zol, unsigned long freq)
110{
111 /* tunes the radio to the desired frequency */
112 struct v4l2_device *v4l2_dev = &zol->v4l2_dev;
107 struct zoltrix *zol = container_of(isa, struct zoltrix, isa);
108 struct v4l2_device *v4l2_dev = &isa->v4l2_dev;
113 unsigned long long bitmask, f, m;
109 unsigned long long bitmask, f, m;
114 unsigned int stereo = zol->stereo;
110 bool stereo = isa->stereo;
115 int i;
116
117 if (freq == 0) {
118 v4l2_warn(v4l2_dev, "cannot set a frequency of 0.\n");
119 return -EINVAL;
120 }
121
122 m = (freq / 160 - 8800) * 2;
123 f = (unsigned long long)m + 0x4d1c;
124
125 bitmask = 0xc480402c10080000ull;
126 i = 45;
127
111 int i;
112
113 if (freq == 0) {
114 v4l2_warn(v4l2_dev, "cannot set a frequency of 0.\n");
115 return -EINVAL;
116 }
117
118 m = (freq / 160 - 8800) * 2;
119 f = (unsigned long long)m + 0x4d1c;
120
121 bitmask = 0xc480402c10080000ull;
122 i = 45;
123
128 mutex_lock(&zol->lock);
124 outb(0, isa->io);
125 outb(0, isa->io);
126 inb(isa->io + 3); /* Zoltrix needs to be read to confirm */
129
127
130 zol->curfreq = freq;
128 outb(0x40, isa->io);
129 outb(0xc0, isa->io);
131
130
132 outb(0, zol->io);
133 outb(0, zol->io);
134 inb(zol->io + 3); /* Zoltrix needs to be read to confirm */
135
136 outb(0x40, zol->io);
137 outb(0xc0, zol->io);
138
139 bitmask = (bitmask ^ ((f & 0xff) << 47) ^ ((f & 0xff00) << 30) ^ (stereo << 31));
140 while (i--) {
141 if ((bitmask & 0x8000000000000000ull) != 0) {
131 bitmask = (bitmask ^ ((f & 0xff) << 47) ^ ((f & 0xff00) << 30) ^ (stereo << 31));
132 while (i--) {
133 if ((bitmask & 0x8000000000000000ull) != 0) {
142 outb(0x80, zol->io);
134 outb(0x80, isa->io);
143 udelay(50);
135 udelay(50);
144 outb(0x00, zol->io);
136 outb(0x00, isa->io);
145 udelay(50);
137 udelay(50);
146 outb(0x80, zol->io);
138 outb(0x80, isa->io);
147 udelay(50);
148 } else {
139 udelay(50);
140 } else {
149 outb(0xc0, zol->io);
141 outb(0xc0, isa->io);
150 udelay(50);
142 udelay(50);
151 outb(0x40, zol->io);
143 outb(0x40, isa->io);
152 udelay(50);
144 udelay(50);
153 outb(0xc0, zol->io);
145 outb(0xc0, isa->io);
154 udelay(50);
155 }
156 bitmask *= 2;
157 }
158 /* termination sequence */
146 udelay(50);
147 }
148 bitmask *= 2;
149 }
150 /* termination sequence */
159 outb(0x80, zol->io);
160 outb(0xc0, zol->io);
161 outb(0x40, zol->io);
151 outb(0x80, isa->io);
152 outb(0xc0, isa->io);
153 outb(0x40, isa->io);
162 udelay(1000);
154 udelay(1000);
163 inb(zol->io + 2);
164
155 inb(isa->io + 2);
165 udelay(1000);
166
156 udelay(1000);
157
167 if (zol->muted) {
168 outb(0, zol->io);
169 outb(0, zol->io);
170 inb(zol->io + 3);
171 udelay(1000);
172 }
173
174 mutex_unlock(&zol->lock);
175
176 if (!zol->muted)
177 zol_setvol(zol, zol->curvol);
178 return 0;
158 return zoltrix_s_mute_volume(isa, zol->muted, zol->curvol);
179}
180
181/* Get signal strength */
159}
160
161/* Get signal strength */
182static int zol_getsigstr(struct zoltrix *zol)
162static u32 zoltrix_g_rxsubchans(struct radio_isa_card *isa)
183{
163{
164 struct zoltrix *zol = container_of(isa, struct zoltrix, isa);
184 int a, b;
185
165 int a, b;
166
186 mutex_lock(&zol->lock);
187 outb(0x00, zol->io); /* This stuff I found to do nothing */
188 outb(zol->curvol, zol->io);
167 outb(0x00, isa->io); /* This stuff I found to do nothing */
168 outb(zol->curvol, isa->io);
189 msleep(20);
190
169 msleep(20);
170
191 a = inb(zol->io);
171 a = inb(isa->io);
192 msleep(10);
172 msleep(10);
193 b = inb(zol->io);
173 b = inb(isa->io);
194
174
195 mutex_unlock(&zol->lock);
196
197 if (a != b)
198 return 0;
199
200 /* I found this out by playing with a binary scanner on the card io */
201 return a == 0xcf || a == 0xdf || a == 0xef;
175 return (a == b && a == 0xcf) ?
176 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
202}
203
177}
178
204static int zol_is_stereo(struct zoltrix *zol)
179static u32 zoltrix_g_signal(struct radio_isa_card *isa)
205{
180{
206 int x1, x2;
181 struct zoltrix *zol = container_of(isa, struct zoltrix, isa);
182 int a, b;
207
183
208 mutex_lock(&zol->lock);
209
210 outb(0x00, zol->io);
211 outb(zol->curvol, zol->io);
184 outb(0x00, isa->io); /* This stuff I found to do nothing */
185 outb(zol->curvol, isa->io);
212 msleep(20);
213
186 msleep(20);
187
214 x1 = inb(zol->io);
188 a = inb(isa->io);
215 msleep(10);
189 msleep(10);
216 x2 = inb(zol->io);
190 b = inb(isa->io);
217
191
218 mutex_unlock(&zol->lock);
219
220 return x1 == x2 && x1 == 0xcf;
221}
222
223static int vidioc_querycap(struct file *file, void *priv,
224 struct v4l2_capability *v)
225{
226 strlcpy(v->driver, "radio-zoltrix", sizeof(v->driver));
227 strlcpy(v->card, "Zoltrix Radio", sizeof(v->card));
228 strlcpy(v->bus_info, "ISA", sizeof(v->bus_info));
229 v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
230 return 0;
231}
232
233static int vidioc_g_tuner(struct file *file, void *priv,
234 struct v4l2_tuner *v)
235{
236 struct zoltrix *zol = video_drvdata(file);
237
238 if (v->index > 0)
239 return -EINVAL;
240
241 strlcpy(v->name, "FM", sizeof(v->name));
242 v->type = V4L2_TUNER_RADIO;
243 v->rangelow = 88 * 16000;
244 v->rangehigh = 108 * 16000;
245 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
246 v->capability = V4L2_TUNER_CAP_LOW;
247 if (zol_is_stereo(zol))
248 v->audmode = V4L2_TUNER_MODE_STEREO;
249 else
250 v->audmode = V4L2_TUNER_MODE_MONO;
251 v->signal = 0xFFFF * zol_getsigstr(zol);
252 return 0;
253}
254
255static int vidioc_s_tuner(struct file *file, void *priv,
256 struct v4l2_tuner *v)
257{
258 return v->index ? -EINVAL : 0;
259}
260
261static int vidioc_s_frequency(struct file *file, void *priv,
262 struct v4l2_frequency *f)
263{
264 struct zoltrix *zol = video_drvdata(file);
265
266 if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
267 return -EINVAL;
268 if (zol_setfreq(zol, f->frequency) != 0)
269 return -EINVAL;
270 return 0;
271}
272
273static int vidioc_g_frequency(struct file *file, void *priv,
274 struct v4l2_frequency *f)
275{
276 struct zoltrix *zol = video_drvdata(file);
277
278 if (f->tuner != 0)
279 return -EINVAL;
280 f->type = V4L2_TUNER_RADIO;
281 f->frequency = zol->curfreq;
282 return 0;
283}
284
285static int vidioc_queryctrl(struct file *file, void *priv,
286 struct v4l2_queryctrl *qc)
287{
288 switch (qc->id) {
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);
293 }
294 return -EINVAL;
295}
296
297static int vidioc_g_ctrl(struct file *file, void *priv,
298 struct v4l2_control *ctrl)
299{
300 struct zoltrix *zol = video_drvdata(file);
301
302 switch (ctrl->id) {
303 case V4L2_CID_AUDIO_MUTE:
304 ctrl->value = zol->muted;
192 if (a != b)
305 return 0;
193 return 0;
306 case V4L2_CID_AUDIO_VOLUME:
307 ctrl->value = zol->curvol * 4096;
308 return 0;
309 }
310 return -EINVAL;
311}
312
194
313static int vidioc_s_ctrl(struct file *file, void *priv,
314 struct v4l2_control *ctrl)
315{
316 struct zoltrix *zol = video_drvdata(file);
317
318 switch (ctrl->id) {
319 case V4L2_CID_AUDIO_MUTE:
320 if (ctrl->value)
321 zol_mute(zol);
322 else {
323 zol_unmute(zol);
324 zol_setvol(zol, zol->curvol);
325 }
326 return 0;
327 case V4L2_CID_AUDIO_VOLUME:
328 zol_setvol(zol, ctrl->value / 4096);
329 return 0;
330 }
331 zol->stereo = 1;
332 if (zol_setfreq(zol, zol->curfreq) != 0)
333 return -EINVAL;
334#if 0
335/* FIXME: Implement stereo/mono switch on V4L2 */
336 if (v->mode & VIDEO_SOUND_STEREO) {
337 zol->stereo = 1;
338 zol_setfreq(zol, zol->curfreq);
339 }
340 if (v->mode & VIDEO_SOUND_MONO) {
341 zol->stereo = 0;
342 zol_setfreq(zol, zol->curfreq);
343 }
344#endif
345 return -EINVAL;
195 /* I found this out by playing with a binary scanner on the card io */
196 return (a == 0xcf || a == 0xdf || a == 0xef) ? 0xffff : 0;
346}
347
197}
198
348static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
199static int zoltrix_s_stereo(struct radio_isa_card *isa, bool stereo)
349{
200{
350 *i = 0;
351 return 0;
201 return zoltrix_s_frequency(isa, isa->freq);
352}
353
202}
203
354static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
355{
356 return i ? -EINVAL : 0;
357}
204static const struct radio_isa_ops zoltrix_ops = {
205 .alloc = zoltrix_alloc,
206 .s_mute_volume = zoltrix_s_mute_volume,
207 .s_frequency = zoltrix_s_frequency,
208 .s_stereo = zoltrix_s_stereo,
209 .g_rxsubchans = zoltrix_g_rxsubchans,
210 .g_signal = zoltrix_g_signal,
211};
358
212
359static int vidioc_g_audio(struct file *file, void *priv,
360 struct v4l2_audio *a)
361{
362 a->index = 0;
363 strlcpy(a->name, "Radio", sizeof(a->name));
364 a->capability = V4L2_AUDCAP_STEREO;
365 return 0;
366}
213static const int zoltrix_ioports[] = { 0x20c, 0x30c };
367
214
368static int vidioc_s_audio(struct file *file, void *priv,
369 struct v4l2_audio *a)
370{
371 return a->index ? -EINVAL : 0;
372}
373
374static const struct v4l2_file_operations zoltrix_fops =
375{
376 .owner = THIS_MODULE,
377 .unlocked_ioctl = video_ioctl2,
215static struct radio_isa_driver zoltrix_driver = {
216 .driver = {
217 .match = radio_isa_match,
218 .probe = radio_isa_probe,
219 .remove = radio_isa_remove,
220 .driver = {
221 .name = "radio-zoltrix",
222 },
223 },
224 .io_params = io,
225 .radio_nr_params = radio_nr,
226 .io_ports = zoltrix_ioports,
227 .num_of_io_ports = ARRAY_SIZE(zoltrix_ioports),
228 .region_size = 2,
229 .card = "Zoltrix Radio Plus",
230 .ops = &zoltrix_ops,
231 .has_stereo = true,
232 .max_volume = 15,
378};
379
233};
234
380static const struct v4l2_ioctl_ops zoltrix_ioctl_ops = {
381 .vidioc_querycap = vidioc_querycap,
382 .vidioc_g_tuner = vidioc_g_tuner,
383 .vidioc_s_tuner = vidioc_s_tuner,
384 .vidioc_g_audio = vidioc_g_audio,
385 .vidioc_s_audio = vidioc_s_audio,
386 .vidioc_g_input = vidioc_g_input,
387 .vidioc_s_input = vidioc_s_input,
388 .vidioc_g_frequency = vidioc_g_frequency,
389 .vidioc_s_frequency = vidioc_s_frequency,
390 .vidioc_queryctrl = vidioc_queryctrl,
391 .vidioc_g_ctrl = vidioc_g_ctrl,
392 .vidioc_s_ctrl = vidioc_s_ctrl,
393};
394
395static int __init zoltrix_init(void)
396{
235static int __init zoltrix_init(void)
236{
397 struct zoltrix *zol = &zoltrix_card;
398 struct v4l2_device *v4l2_dev = &zol->v4l2_dev;
399 int res;
400
401 strlcpy(v4l2_dev->name, "zoltrix", sizeof(v4l2_dev->name));
402 zol->io = io;
403 if (zol->io == -1) {
404 v4l2_err(v4l2_dev, "You must set an I/O address with io=0x20c or 0x30c\n");
405 return -EINVAL;
406 }
407 if (zol->io != 0x20c && zol->io != 0x30c) {
408 v4l2_err(v4l2_dev, "invalid port, try 0x20c or 0x30c\n");
409 return -ENXIO;
410 }
411
412 if (!request_region(zol->io, 2, "zoltrix")) {
413 v4l2_err(v4l2_dev, "port 0x%x already in use\n", zol->io);
414 return -EBUSY;
415 }
416
417 res = v4l2_device_register(NULL, v4l2_dev);
418 if (res < 0) {
419 release_region(zol->io, 2);
420 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
421 return res;
422 }
423
424 mutex_init(&zol->lock);
425
426 /* mute card - prevents noisy bootups */
427
428 /* this ensures that the volume is all the way down */
429
430 outb(0, zol->io);
431 outb(0, zol->io);
432 msleep(20);
433 inb(zol->io + 3);
434
435 zol->curvol = 0;
436 zol->stereo = 1;
437
438 strlcpy(zol->vdev.name, v4l2_dev->name, sizeof(zol->vdev.name));
439 zol->vdev.v4l2_dev = v4l2_dev;
440 zol->vdev.fops = &zoltrix_fops;
441 zol->vdev.ioctl_ops = &zoltrix_ioctl_ops;
442 zol->vdev.release = video_device_release_empty;
443 video_set_drvdata(&zol->vdev, zol);
444
445 if (video_register_device(&zol->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
446 v4l2_device_unregister(v4l2_dev);
447 release_region(zol->io, 2);
448 return -EINVAL;
449 }
450 v4l2_info(v4l2_dev, "Zoltrix Radio Plus card driver.\n");
451
452 return 0;
237 return isa_register_driver(&zoltrix_driver.driver, ZOLTRIX_MAX);
453}
454
455static void __exit zoltrix_exit(void)
456{
238}
239
240static void __exit zoltrix_exit(void)
241{
457 struct zoltrix *zol = &zoltrix_card;
458
459 video_unregister_device(&zol->vdev);
460 v4l2_device_unregister(&zol->v4l2_dev);
461 release_region(zol->io, 2);
242 isa_unregister_driver(&zoltrix_driver.driver);
462}
463
464module_init(zoltrix_init);
465module_exit(zoltrix_exit);
466
243}
244
245module_init(zoltrix_init);
246module_exit(zoltrix_exit);
247