[media] BKL: trivial BKL removal from V4L2 radio drivers
[linux-2.6.git] / drivers / media / radio / radio-aztech.c
1 /* radio-aztech.c - Aztech radio card driver for Linux 2.2
2  *
3  * Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
4  * Adapted to support the Video for Linux API by
5  * Russell Kroll <rkroll@exploits.org>.  Based on original tuner code by:
6  *
7  * Quay Ly
8  * Donald Song
9  * Jason Lewis      (jlewis@twilight.vtc.vsc.edu)
10  * Scott McGrath    (smcgrath@twilight.vtc.vsc.edu)
11  * William McGrath  (wmcgrath@twilight.vtc.vsc.edu)
12  *
13  * The basis for this code may be found at http://bigbang.vtc.vsc.edu/fmradio/
14  * along with more information on the card itself.
15  *
16  * History:
17  * 1999-02-24   Russell Kroll <rkroll@exploits.org>
18  *              Fine tuning/VIDEO_TUNER_LOW
19  *              Range expanded to 87-108 MHz (from 87.9-107.8)
20  *
21  * Notable changes from the original source:
22  * - includes stripped down to the essentials
23  * - for loops used as delays replaced with udelay()
24  * - #defines removed, changed to static values
25  * - tuning structure changed - no more character arrays, other changes
26 */
27
28 #include <linux/module.h>       /* Modules                      */
29 #include <linux/init.h>         /* Initdata                     */
30 #include <linux/ioport.h>       /* request_region               */
31 #include <linux/delay.h>        /* udelay                       */
32 #include <linux/videodev2.h>    /* kernel radio structs         */
33 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
34 #include <linux/io.h>           /* outb, outb_p                 */
35 #include <media/v4l2-device.h>
36 #include <media/v4l2-ioctl.h>
37
38 MODULE_AUTHOR("Russell Kroll, Quay Lu, Donald Song, Jason Lewis, Scott McGrath, William McGrath");
39 MODULE_DESCRIPTION("A driver for the Aztech radio card.");
40 MODULE_LICENSE("GPL");
41
42 /* acceptable ports: 0x350 (JP3 shorted), 0x358 (JP3 open) */
43
44 #ifndef CONFIG_RADIO_AZTECH_PORT
45 #define CONFIG_RADIO_AZTECH_PORT -1
46 #endif
47
48 static int io = CONFIG_RADIO_AZTECH_PORT;
49 static int radio_nr = -1;
50 static int radio_wait_time = 1000;
51
52 module_param(io, int, 0);
53 module_param(radio_nr, int, 0);
54 MODULE_PARM_DESC(io, "I/O address of the Aztech card (0x350 or 0x358)");
55
56 #define RADIO_VERSION KERNEL_VERSION(0, 0, 2)
57
58 struct aztech
59 {
60         struct v4l2_device v4l2_dev;
61         struct video_device vdev;
62         int io;
63         int curvol;
64         unsigned long curfreq;
65         int stereo;
66         struct mutex lock;
67 };
68
69 static struct aztech aztech_card;
70
71 static int volconvert(int level)
72 {
73         level >>= 14;           /* Map 16bits down to 2 bit */
74         level &= 3;
75
76         /* convert to card-friendly values */
77         switch (level) {
78         case 0:
79                 return 0;
80         case 1:
81                 return 1;
82         case 2:
83                 return 4;
84         case 3:
85                 return 5;
86         }
87         return 0;       /* Quieten gcc */
88 }
89
90 static void send_0_byte(struct aztech *az)
91 {
92         udelay(radio_wait_time);
93         outb_p(2 + volconvert(az->curvol), az->io);
94         outb_p(64 + 2 + volconvert(az->curvol), az->io);
95 }
96
97 static void send_1_byte(struct aztech *az)
98 {
99         udelay (radio_wait_time);
100         outb_p(128 + 2 + volconvert(az->curvol), az->io);
101         outb_p(128 + 64 + 2 + volconvert(az->curvol), az->io);
102 }
103
104 static int az_setvol(struct aztech *az, int vol)
105 {
106         mutex_lock(&az->lock);
107         outb(volconvert(vol), az->io);
108         mutex_unlock(&az->lock);
109         return 0;
110 }
111
112 /* thanks to Michael Dwyer for giving me a dose of clues in
113  * the signal strength department..
114  *
115  * This card has a stereo bit - bit 0 set = mono, not set = stereo
116  * It also has a "signal" bit - bit 1 set = bad signal, not set = good
117  *
118  */
119
120 static int az_getsigstr(struct aztech *az)
121 {
122         int sig = 1;
123
124         mutex_lock(&az->lock);
125         if (inb(az->io) & 2)    /* bit set = no signal present */
126                 sig = 0;
127         mutex_unlock(&az->lock);
128         return sig;
129 }
130
131 static int az_getstereo(struct aztech *az)
132 {
133         int stereo = 1;
134
135         mutex_lock(&az->lock);
136         if (inb(az->io) & 1)    /* bit set = mono */
137                 stereo = 0;
138         mutex_unlock(&az->lock);
139         return stereo;
140 }
141
142 static int az_setfreq(struct aztech *az, unsigned long frequency)
143 {
144         int  i;
145
146         mutex_lock(&az->lock);
147
148         az->curfreq = frequency;
149         frequency += 171200;            /* Add 10.7 MHz IF              */
150         frequency /= 800;               /* Convert to 50 kHz units      */
151
152         send_0_byte(az);                /*  0: LSB of frequency       */
153
154         for (i = 0; i < 13; i++)        /*   : frequency bits (1-13)  */
155                 if (frequency & (1 << i))
156                         send_1_byte(az);
157                 else
158                         send_0_byte(az);
159
160         send_0_byte(az);                /* 14: test bit - always 0    */
161         send_0_byte(az);                /* 15: test bit - always 0    */
162         send_0_byte(az);                /* 16: band data 0 - always 0 */
163         if (az->stereo)         /* 17: stereo (1 to enable)   */
164                 send_1_byte(az);
165         else
166                 send_0_byte(az);
167
168         send_1_byte(az);                /* 18: band data 1 - unknown  */
169         send_0_byte(az);                /* 19: time base - always 0   */
170         send_0_byte(az);                /* 20: spacing (0 = 25 kHz)   */
171         send_1_byte(az);                /* 21: spacing (1 = 25 kHz)   */
172         send_0_byte(az);                /* 22: spacing (0 = 25 kHz)   */
173         send_1_byte(az);                /* 23: AM/FM (FM = 1, always) */
174
175         /* latch frequency */
176
177         udelay(radio_wait_time);
178         outb_p(128 + 64 + volconvert(az->curvol), az->io);
179
180         mutex_unlock(&az->lock);
181
182         return 0;
183 }
184
185 static int vidioc_querycap(struct file *file, void  *priv,
186                                         struct v4l2_capability *v)
187 {
188         strlcpy(v->driver, "radio-aztech", sizeof(v->driver));
189         strlcpy(v->card, "Aztech Radio", sizeof(v->card));
190         strlcpy(v->bus_info, "ISA", sizeof(v->bus_info));
191         v->version = RADIO_VERSION;
192         v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
193         return 0;
194 }
195
196 static int vidioc_g_tuner(struct file *file, void *priv,
197                                 struct v4l2_tuner *v)
198 {
199         struct aztech *az = video_drvdata(file);
200
201         if (v->index > 0)
202                 return -EINVAL;
203
204         strlcpy(v->name, "FM", sizeof(v->name));
205         v->type = V4L2_TUNER_RADIO;
206
207         v->rangelow = 87 * 16000;
208         v->rangehigh = 108 * 16000;
209         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
210         v->capability = V4L2_TUNER_CAP_LOW;
211         if (az_getstereo(az))
212                 v->audmode = V4L2_TUNER_MODE_STEREO;
213         else
214                 v->audmode = V4L2_TUNER_MODE_MONO;
215         v->signal = 0xFFFF * az_getsigstr(az);
216
217         return 0;
218 }
219
220 static int vidioc_s_tuner(struct file *file, void *priv,
221                                 struct v4l2_tuner *v)
222 {
223         return v->index ? -EINVAL : 0;
224 }
225
226 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
227 {
228         *i = 0;
229         return 0;
230 }
231
232 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
233 {
234         return i ? -EINVAL : 0;
235 }
236
237 static int vidioc_g_audio(struct file *file, void *priv,
238                            struct v4l2_audio *a)
239 {
240         a->index = 0;
241         strlcpy(a->name, "Radio", sizeof(a->name));
242         a->capability = V4L2_AUDCAP_STEREO;
243         return 0;
244 }
245
246 static int vidioc_s_audio(struct file *file, void *priv,
247                            struct v4l2_audio *a)
248 {
249         return a->index ? -EINVAL : 0;
250 }
251
252 static int vidioc_s_frequency(struct file *file, void *priv,
253                                 struct v4l2_frequency *f)
254 {
255         struct aztech *az = video_drvdata(file);
256
257         if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
258                 return -EINVAL;
259         az_setfreq(az, f->frequency);
260         return 0;
261 }
262
263 static int vidioc_g_frequency(struct file *file, void *priv,
264                                 struct v4l2_frequency *f)
265 {
266         struct aztech *az = video_drvdata(file);
267
268         if (f->tuner != 0)
269                 return -EINVAL;
270         f->type = V4L2_TUNER_RADIO;
271         f->frequency = az->curfreq;
272         return 0;
273 }
274
275 static int vidioc_queryctrl(struct file *file, void *priv,
276                             struct v4l2_queryctrl *qc)
277 {
278         switch (qc->id) {
279         case V4L2_CID_AUDIO_MUTE:
280                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
281         case V4L2_CID_AUDIO_VOLUME:
282                 return v4l2_ctrl_query_fill(qc, 0, 0xff, 1, 0xff);
283         }
284         return -EINVAL;
285 }
286
287 static int vidioc_g_ctrl(struct file *file, void *priv,
288                             struct v4l2_control *ctrl)
289 {
290         struct aztech *az = video_drvdata(file);
291
292         switch (ctrl->id) {
293         case V4L2_CID_AUDIO_MUTE:
294                 if (az->curvol == 0)
295                         ctrl->value = 1;
296                 else
297                         ctrl->value = 0;
298                 return 0;
299         case V4L2_CID_AUDIO_VOLUME:
300                 ctrl->value = az->curvol * 6554;
301                 return 0;
302         }
303         return -EINVAL;
304 }
305
306 static int vidioc_s_ctrl(struct file *file, void *priv,
307                             struct v4l2_control *ctrl)
308 {
309         struct aztech *az = video_drvdata(file);
310
311         switch (ctrl->id) {
312         case V4L2_CID_AUDIO_MUTE:
313                 if (ctrl->value)
314                         az_setvol(az, 0);
315                 else
316                         az_setvol(az, az->curvol);
317                 return 0;
318         case V4L2_CID_AUDIO_VOLUME:
319                 az_setvol(az, ctrl->value);
320                 return 0;
321         }
322         return -EINVAL;
323 }
324
325 static const struct v4l2_file_operations aztech_fops = {
326         .owner          = THIS_MODULE,
327         .unlocked_ioctl = video_ioctl2,
328 };
329
330 static const struct v4l2_ioctl_ops aztech_ioctl_ops = {
331         .vidioc_querycap    = vidioc_querycap,
332         .vidioc_g_tuner     = vidioc_g_tuner,
333         .vidioc_s_tuner     = vidioc_s_tuner,
334         .vidioc_g_audio     = vidioc_g_audio,
335         .vidioc_s_audio     = vidioc_s_audio,
336         .vidioc_g_input     = vidioc_g_input,
337         .vidioc_s_input     = vidioc_s_input,
338         .vidioc_g_frequency = vidioc_g_frequency,
339         .vidioc_s_frequency = vidioc_s_frequency,
340         .vidioc_queryctrl   = vidioc_queryctrl,
341         .vidioc_g_ctrl      = vidioc_g_ctrl,
342         .vidioc_s_ctrl      = vidioc_s_ctrl,
343 };
344
345 static int __init aztech_init(void)
346 {
347         struct aztech *az = &aztech_card;
348         struct v4l2_device *v4l2_dev = &az->v4l2_dev;
349         int res;
350
351         strlcpy(v4l2_dev->name, "aztech", sizeof(v4l2_dev->name));
352         az->io = io;
353
354         if (az->io == -1) {
355                 v4l2_err(v4l2_dev, "you must set an I/O address with io=0x350 or 0x358\n");
356                 return -EINVAL;
357         }
358
359         if (!request_region(az->io, 2, "aztech")) {
360                 v4l2_err(v4l2_dev, "port 0x%x already in use\n", az->io);
361                 return -EBUSY;
362         }
363
364         res = v4l2_device_register(NULL, v4l2_dev);
365         if (res < 0) {
366                 release_region(az->io, 2);
367                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
368                 return res;
369         }
370
371         mutex_init(&az->lock);
372         strlcpy(az->vdev.name, v4l2_dev->name, sizeof(az->vdev.name));
373         az->vdev.v4l2_dev = v4l2_dev;
374         az->vdev.fops = &aztech_fops;
375         az->vdev.ioctl_ops = &aztech_ioctl_ops;
376         az->vdev.release = video_device_release_empty;
377         video_set_drvdata(&az->vdev, az);
378         /* mute card - prevents noisy bootups */
379         outb(0, az->io);
380
381         if (video_register_device(&az->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
382                 v4l2_device_unregister(v4l2_dev);
383                 release_region(az->io, 2);
384                 return -EINVAL;
385         }
386
387         v4l2_info(v4l2_dev, "Aztech radio card driver v1.00/19990224 rkroll@exploits.org\n");
388         return 0;
389 }
390
391 static void __exit aztech_exit(void)
392 {
393         struct aztech *az = &aztech_card;
394
395         video_unregister_device(&az->vdev);
396         v4l2_device_unregister(&az->v4l2_dev);
397         release_region(az->io, 2);
398 }
399
400 module_init(aztech_init);
401 module_exit(aztech_exit);