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