V4L/DVB (11391): pci-isa radios: remove open and release functions
[linux-2.6.git] / drivers / media / radio / radio-rtrack2.c
1 /* RadioTrack II driver for Linux radio support (C) 1998 Ben Pfaff
2  *
3  * Based on RadioTrack I/RadioReveal (C) 1997 M. Kirkwood
4  * Converted to new API by Alan Cox <alan@lxorguk.ukuu.org.uk>
5  * Various bugfixes and enhancements by Russell Kroll <rkroll@exploits.org>
6  *
7  * TODO: Allow for more than one of these foolish entities :-)
8  *
9  * Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
10  */
11
12 #include <linux/module.h>       /* Modules                      */
13 #include <linux/init.h>         /* Initdata                     */
14 #include <linux/ioport.h>       /* request_region               */
15 #include <linux/delay.h>        /* udelay                       */
16 #include <linux/videodev2.h>    /* kernel radio structs         */
17 #include <linux/mutex.h>
18 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
19 #include <linux/io.h>           /* outb, outb_p                 */
20 #include <media/v4l2-device.h>
21 #include <media/v4l2-ioctl.h>
22
23 MODULE_AUTHOR("Ben Pfaff");
24 MODULE_DESCRIPTION("A driver for the RadioTrack II radio card.");
25 MODULE_LICENSE("GPL");
26
27 #ifndef CONFIG_RADIO_RTRACK2_PORT
28 #define CONFIG_RADIO_RTRACK2_PORT -1
29 #endif
30
31 static int io = CONFIG_RADIO_RTRACK2_PORT;
32 static int radio_nr = -1;
33
34 module_param(io, int, 0);
35 MODULE_PARM_DESC(io, "I/O address of the RadioTrack card (0x20c or 0x30c)");
36 module_param(radio_nr, int, 0);
37
38 #define RADIO_VERSION KERNEL_VERSION(0, 0, 2)
39
40 struct rtrack2
41 {
42         struct v4l2_device v4l2_dev;
43         struct video_device vdev;
44         int io;
45         unsigned long curfreq;
46         int muted;
47         struct mutex lock;
48 };
49
50 static struct rtrack2 rtrack2_card;
51
52
53 /* local things */
54
55 static void rt_mute(struct rtrack2 *dev)
56 {
57         if (dev->muted)
58                 return;
59         mutex_lock(&dev->lock);
60         outb(1, dev->io);
61         mutex_unlock(&dev->lock);
62         dev->muted = 1;
63 }
64
65 static void rt_unmute(struct rtrack2 *dev)
66 {
67         if(dev->muted == 0)
68                 return;
69         mutex_lock(&dev->lock);
70         outb(0, dev->io);
71         mutex_unlock(&dev->lock);
72         dev->muted = 0;
73 }
74
75 static void zero(struct rtrack2 *dev)
76 {
77         outb_p(1, dev->io);
78         outb_p(3, dev->io);
79         outb_p(1, dev->io);
80 }
81
82 static void one(struct rtrack2 *dev)
83 {
84         outb_p(5, dev->io);
85         outb_p(7, dev->io);
86         outb_p(5, dev->io);
87 }
88
89 static int rt_setfreq(struct rtrack2 *dev, unsigned long freq)
90 {
91         int i;
92
93         mutex_lock(&dev->lock);
94         dev->curfreq = freq;
95         freq = freq / 200 + 856;
96
97         outb_p(0xc8, dev->io);
98         outb_p(0xc9, dev->io);
99         outb_p(0xc9, dev->io);
100
101         for (i = 0; i < 10; i++)
102                 zero(dev);
103
104         for (i = 14; i >= 0; i--)
105                 if (freq & (1 << i))
106                         one(dev);
107                 else
108                         zero(dev);
109
110         outb_p(0xc8, dev->io);
111         if (!dev->muted)
112                 outb_p(0, dev->io);
113
114         mutex_unlock(&dev->lock);
115         return 0;
116 }
117
118 static int vidioc_querycap(struct file *file, void *priv,
119                                 struct v4l2_capability *v)
120 {
121         strlcpy(v->driver, "radio-rtrack2", sizeof(v->driver));
122         strlcpy(v->card, "RadioTrack II", sizeof(v->card));
123         strlcpy(v->bus_info, "ISA", sizeof(v->bus_info));
124         v->version = RADIO_VERSION;
125         v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
126         return 0;
127 }
128
129 static int vidioc_s_tuner(struct file *file, void *priv,
130                                 struct v4l2_tuner *v)
131 {
132         return v->index ? -EINVAL : 0;
133 }
134
135 static int rt_getsigstr(struct rtrack2 *dev)
136 {
137         int sig = 1;
138
139         mutex_lock(&dev->lock);
140         if (inb(dev->io) & 2)   /* bit set = no signal present  */
141                 sig = 0;
142         mutex_unlock(&dev->lock);
143         return sig;
144 }
145
146 static int vidioc_g_tuner(struct file *file, void *priv,
147                                 struct v4l2_tuner *v)
148 {
149         struct rtrack2 *rt = video_drvdata(file);
150
151         if (v->index > 0)
152                 return -EINVAL;
153
154         strlcpy(v->name, "FM", sizeof(v->name));
155         v->type = V4L2_TUNER_RADIO;
156         v->rangelow = 88 * 16000;
157         v->rangehigh = 108 * 16000;
158         v->rxsubchans = V4L2_TUNER_SUB_MONO;
159         v->capability = V4L2_TUNER_CAP_LOW;
160         v->audmode = V4L2_TUNER_MODE_MONO;
161         v->signal = 0xFFFF * rt_getsigstr(rt);
162         return 0;
163 }
164
165 static int vidioc_s_frequency(struct file *file, void *priv,
166                                 struct v4l2_frequency *f)
167 {
168         struct rtrack2 *rt = video_drvdata(file);
169
170         rt_setfreq(rt, f->frequency);
171         return 0;
172 }
173
174 static int vidioc_g_frequency(struct file *file, void *priv,
175                                 struct v4l2_frequency *f)
176 {
177         struct rtrack2 *rt = video_drvdata(file);
178
179         f->type = V4L2_TUNER_RADIO;
180         f->frequency = rt->curfreq;
181         return 0;
182 }
183
184 static int vidioc_queryctrl(struct file *file, void *priv,
185                                 struct v4l2_queryctrl *qc)
186 {
187         switch (qc->id) {
188         case V4L2_CID_AUDIO_MUTE:
189                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
190         case V4L2_CID_AUDIO_VOLUME:
191                 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535, 65535);
192         }
193         return -EINVAL;
194 }
195
196 static int vidioc_g_ctrl(struct file *file, void *priv,
197                                 struct v4l2_control *ctrl)
198 {
199         struct rtrack2 *rt = video_drvdata(file);
200
201         switch (ctrl->id) {
202         case V4L2_CID_AUDIO_MUTE:
203                 ctrl->value = rt->muted;
204                 return 0;
205         case V4L2_CID_AUDIO_VOLUME:
206                 if (rt->muted)
207                         ctrl->value = 0;
208                 else
209                         ctrl->value = 65535;
210                 return 0;
211         }
212         return -EINVAL;
213 }
214
215 static int vidioc_s_ctrl(struct file *file, void *priv,
216                                 struct v4l2_control *ctrl)
217 {
218         struct rtrack2 *rt = video_drvdata(file);
219
220         switch (ctrl->id) {
221         case V4L2_CID_AUDIO_MUTE:
222                 if (ctrl->value)
223                         rt_mute(rt);
224                 else
225                         rt_unmute(rt);
226                 return 0;
227         case V4L2_CID_AUDIO_VOLUME:
228                 if (ctrl->value)
229                         rt_unmute(rt);
230                 else
231                         rt_mute(rt);
232                 return 0;
233         }
234         return -EINVAL;
235 }
236
237 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
238 {
239         *i = 0;
240         return 0;
241 }
242
243 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
244 {
245         return i ? -EINVAL : 0;
246 }
247
248 static int vidioc_g_audio(struct file *file, void *priv,
249                                 struct v4l2_audio *a)
250 {
251         a->index = 0;
252         strlcpy(a->name, "Radio", sizeof(a->name));
253         a->capability = V4L2_AUDCAP_STEREO;
254         return 0;
255 }
256
257 static int vidioc_s_audio(struct file *file, void *priv,
258                                 struct v4l2_audio *a)
259 {
260         return a->index ? -EINVAL : 0;
261 }
262
263 static const struct v4l2_file_operations rtrack2_fops = {
264         .owner          = THIS_MODULE,
265         .ioctl          = video_ioctl2,
266 };
267
268 static const struct v4l2_ioctl_ops rtrack2_ioctl_ops = {
269         .vidioc_querycap    = vidioc_querycap,
270         .vidioc_g_tuner     = vidioc_g_tuner,
271         .vidioc_s_tuner     = vidioc_s_tuner,
272         .vidioc_g_frequency = vidioc_g_frequency,
273         .vidioc_s_frequency = vidioc_s_frequency,
274         .vidioc_queryctrl   = vidioc_queryctrl,
275         .vidioc_g_ctrl      = vidioc_g_ctrl,
276         .vidioc_s_ctrl      = vidioc_s_ctrl,
277         .vidioc_g_audio     = vidioc_g_audio,
278         .vidioc_s_audio     = vidioc_s_audio,
279         .vidioc_g_input     = vidioc_g_input,
280         .vidioc_s_input     = vidioc_s_input,
281 };
282
283 static int __init rtrack2_init(void)
284 {
285         struct rtrack2 *dev = &rtrack2_card;
286         struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
287         int res;
288
289         strlcpy(v4l2_dev->name, "rtrack2", sizeof(v4l2_dev->name));
290         dev->io = io;
291         if (dev->io == -1) {
292                 v4l2_err(v4l2_dev, "You must set an I/O address with io=0x20c or io=0x30c\n");
293                 return -EINVAL;
294         }
295         if (!request_region(dev->io, 4, "rtrack2")) {
296                 v4l2_err(v4l2_dev, "port 0x%x already in use\n", dev->io);
297                 return -EBUSY;
298         }
299
300         res = v4l2_device_register(NULL, v4l2_dev);
301         if (res < 0) {
302                 release_region(dev->io, 4);
303                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
304                 return res;
305         }
306
307         strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
308         dev->vdev.v4l2_dev = v4l2_dev;
309         dev->vdev.fops = &rtrack2_fops;
310         dev->vdev.ioctl_ops = &rtrack2_ioctl_ops;
311         dev->vdev.release = video_device_release_empty;
312         video_set_drvdata(&dev->vdev, dev);
313
314         mutex_init(&dev->lock);
315         if (video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
316                 v4l2_device_unregister(v4l2_dev);
317                 release_region(dev->io, 4);
318                 return -EINVAL;
319         }
320
321         v4l2_info(v4l2_dev, "AIMSlab Radiotrack II card driver.\n");
322
323         /* mute card - prevents noisy bootups */
324         outb(1, dev->io);
325         dev->muted = 1;
326
327         return 0;
328 }
329
330 static void __exit rtrack2_exit(void)
331 {
332         struct rtrack2 *dev = &rtrack2_card;
333
334         video_unregister_device(&dev->vdev);
335         v4l2_device_unregister(&dev->v4l2_dev);
336         release_region(dev->io, 4);
337 }
338
339 module_init(rtrack2_init);
340 module_exit(rtrack2_exit);