[media] wl128x: Remove unused NO_OF_ENTRIES_IN_ARRAY macro
[linux-2.6.git] / drivers / media / radio / radio-zoltrix.c
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