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