blob: 43524119ac1cb7620571aa73daeed718d592445f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* SF16FMI radio driver for Linux radio support
2 * heavily based on rtrack driver...
3 * (c) 1997 M. Kirkwood
4 * (c) 1998 Petr Vandrovec, vandrove@vc.cvut.cz
5 *
6 * Fitted to new interface by Alan Cox <alan.cox@linux.org>
7 * Made working and cleaned up functions <mikael.hedin@irf.se>
8 * Support for ISAPnP by Ladislav Michl <ladis@psi.cz>
9 *
10 * Notes on the hardware
11 *
12 * Frequency control is done digitally -- ie out(port,encodefreq(95.8));
13 * No volume control - only mute/unmute - you have to use line volume
14 * control on SB-part of SF16FMI
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -030015 *
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -030016 * Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
18
19#include <linux/kernel.h> /* __setup */
20#include <linux/module.h> /* Modules */
21#include <linux/init.h> /* Initdata */
Peter Osterlundfb911ee2005-09-13 01:25:15 -070022#include <linux/ioport.h> /* request_region */
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/delay.h> /* udelay */
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -030024#include <linux/videodev2.h> /* kernel radio structs */
Mauro Carvalho Chehab5e87efa2006-06-05 10:26:32 -030025#include <media/v4l2-common.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/isapnp.h>
27#include <asm/io.h> /* outb, outb_p */
28#include <asm/uaccess.h> /* copy to/from user */
Ingo Molnar3593cab2006-02-07 06:49:14 -020029#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -030031#define RADIO_VERSION KERNEL_VERSION(0,0,2)
32
33static struct v4l2_queryctrl radio_qctrl[] = {
34 {
35 .id = V4L2_CID_AUDIO_MUTE,
36 .name = "Mute",
37 .minimum = 0,
38 .maximum = 1,
39 .default_value = 1,
40 .type = V4L2_CTRL_TYPE_BOOLEAN,
41 }
42};
43
Linus Torvalds1da177e2005-04-16 15:20:36 -070044struct fmi_device
45{
46 int port;
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -030047 int curvol; /* 1 or 0 */
48 unsigned long curfreq; /* freq in kHz */
49 __u32 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -070050};
51
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -030052static int io = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053static int radio_nr = -1;
54static struct pnp_dev *dev = NULL;
Ingo Molnar3593cab2006-02-07 06:49:14 -020055static struct mutex lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
57/* freq is in 1/16 kHz to internal number, hw precision is 50 kHz */
58/* It is only useful to give freq in intervall of 800 (=0.05Mhz),
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -030059 * other bits will be truncated, e.g 92.7400016 -> 92.7, but
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 * 92.7400017 -> 92.75
61 */
62#define RSF16_ENCODE(x) ((x)/800+214)
63#define RSF16_MINFREQ 87*16000
64#define RSF16_MAXFREQ 108*16000
65
66static void outbits(int bits, unsigned int data, int port)
67{
68 while(bits--) {
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -030069 if(data & 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 outb(5, port);
71 udelay(6);
72 outb(7, port);
73 udelay(6);
74 } else {
75 outb(1, port);
76 udelay(6);
77 outb(3, port);
78 udelay(6);
79 }
80 data>>=1;
81 }
82}
83
84static inline void fmi_mute(int port)
85{
Ingo Molnar3593cab2006-02-07 06:49:14 -020086 mutex_lock(&lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 outb(0x00, port);
Ingo Molnar3593cab2006-02-07 06:49:14 -020088 mutex_unlock(&lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089}
90
91static inline void fmi_unmute(int port)
92{
Ingo Molnar3593cab2006-02-07 06:49:14 -020093 mutex_lock(&lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 outb(0x08, port);
Ingo Molnar3593cab2006-02-07 06:49:14 -020095 mutex_unlock(&lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096}
97
98static inline int fmi_setfreq(struct fmi_device *dev)
99{
100 int myport = dev->port;
101 unsigned long freq = dev->curfreq;
102
Ingo Molnar3593cab2006-02-07 06:49:14 -0200103 mutex_lock(&lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
105 outbits(16, RSF16_ENCODE(freq), myport);
106 outbits(8, 0xC0, myport);
107 msleep(143); /* was schedule_timeout(HZ/7) */
Ingo Molnar3593cab2006-02-07 06:49:14 -0200108 mutex_unlock(&lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 if (dev->curvol) fmi_unmute(myport);
110 return 0;
111}
112
113static inline int fmi_getsigstr(struct fmi_device *dev)
114{
115 int val;
116 int res;
117 int myport = dev->port;
118
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -0300119
Ingo Molnar3593cab2006-02-07 06:49:14 -0200120 mutex_lock(&lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 val = dev->curvol ? 0x08 : 0x00; /* unmute/mute */
122 outb(val, myport);
123 outb(val | 0x10, myport);
124 msleep(143); /* was schedule_timeout(HZ/7) */
125 res = (int)inb(myport+1);
126 outb(val, myport);
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -0300127
Ingo Molnar3593cab2006-02-07 06:49:14 -0200128 mutex_unlock(&lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 return (res & 2) ? 0 : 0xFFFF;
130}
131
132static int fmi_do_ioctl(struct inode *inode, struct file *file,
133 unsigned int cmd, void *arg)
134{
135 struct video_device *dev = video_devdata(file);
136 struct fmi_device *fmi=dev->priv;
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -0300137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 switch(cmd)
139 {
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300140 case VIDIOC_QUERYCAP:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 {
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300142 struct v4l2_capability *v = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 memset(v,0,sizeof(*v));
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300144 strlcpy(v->driver, "radio-sf16fmi", sizeof (v->driver));
145 strlcpy(v->card, "SF16-FMx radio", sizeof (v->card));
146 sprintf(v->bus_info,"ISA");
147 v->version = RADIO_VERSION;
148 v->capabilities = V4L2_CAP_TUNER;
149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 return 0;
151 }
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300152 case VIDIOC_G_TUNER:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 {
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300154 struct v4l2_tuner *v = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 int mult;
156
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300157 if (v->index > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 return -EINVAL;
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300159
160 memset(v,0,sizeof(*v));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 strcpy(v->name, "FM");
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300162 v->type = V4L2_TUNER_RADIO;
163
164 mult = (fmi->flags & V4L2_TUNER_CAP_LOW) ? 1 : 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 v->rangelow = RSF16_MINFREQ/mult;
166 v->rangehigh = RSF16_MAXFREQ/mult;
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300167 v->rxsubchans =V4L2_TUNER_SUB_MONO | V4L2_TUNER_MODE_STEREO;
168 v->capability=fmi->flags;
169 v->audmode = V4L2_TUNER_MODE_STEREO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 v->signal = fmi_getsigstr(fmi);
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 return 0;
173 }
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300174 case VIDIOC_S_TUNER:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 {
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300176 struct v4l2_tuner *v = arg;
177
178 if (v->index > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 return -EINVAL;
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300180
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 return 0;
182 }
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300183 case VIDIOC_S_FREQUENCY:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 {
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300185 struct v4l2_frequency *f = arg;
186
187 if (!(fmi->flags & V4L2_TUNER_CAP_LOW))
188 f->frequency *= 1000;
189 if (f->frequency < RSF16_MINFREQ ||
190 f->frequency > RSF16_MAXFREQ )
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 return -EINVAL;
192 /*rounding in steps of 800 to match th freq
193 that will be used */
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300194 fmi->curfreq = (f->frequency/800)*800;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 fmi_setfreq(fmi);
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 return 0;
198 }
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300199 case VIDIOC_G_FREQUENCY:
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -0300200 {
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300201 struct v4l2_frequency *f = arg;
202
203 f->type = V4L2_TUNER_RADIO;
204 f->frequency = fmi->curfreq;
205 if (!(fmi->flags & V4L2_TUNER_CAP_LOW))
206 f->frequency /= 1000;
207
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -0300208 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 }
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300210 case VIDIOC_QUERYCTRL:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 {
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300212 struct v4l2_queryctrl *qc = arg;
213 int i;
214
215 for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
216 if (qc->id && qc->id == radio_qctrl[i].id) {
217 memcpy(qc, &(radio_qctrl[i]),
218 sizeof(*qc));
219 return (0);
220 }
221 }
222 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 }
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300224 case VIDIOC_G_CTRL:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 {
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300226 struct v4l2_control *ctrl= arg;
227
228 switch (ctrl->id) {
229 case V4L2_CID_AUDIO_MUTE:
230 ctrl->value=fmi->curvol;
231 return (0);
232 }
233 return -EINVAL;
234 }
235 case VIDIOC_S_CTRL:
236 {
237 struct v4l2_control *ctrl= arg;
238
239 switch (ctrl->id) {
240 case V4L2_CID_AUDIO_MUTE:
241 {
242 if (ctrl->value)
243 fmi_mute(fmi->port);
244 else
245 fmi_unmute(fmi->port);
246
247 fmi->curvol=ctrl->value;
248 return (0);
249 }
250 }
251 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 }
253 default:
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300254 return v4l_compat_translate_ioctl(inode,file,cmd,arg,
255 fmi_do_ioctl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 }
257}
258
259static int fmi_ioctl(struct inode *inode, struct file *file,
260 unsigned int cmd, unsigned long arg)
261{
262 return video_usercopy(inode, file, cmd, arg, fmi_do_ioctl);
263}
264
265static struct fmi_device fmi_unit;
266
267static struct file_operations fmi_fops = {
268 .owner = THIS_MODULE,
269 .open = video_exclusive_open,
270 .release = video_exclusive_release,
271 .ioctl = fmi_ioctl,
Arnd Bergmann0d0fbf82006-01-09 15:24:57 -0200272 .compat_ioctl = v4l_compat_ioctl32,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 .llseek = no_llseek,
274};
275
276static struct video_device fmi_radio=
277{
278 .owner = THIS_MODULE,
279 .name = "SF16FMx radio",
280 .type = VID_TYPE_TUNER,
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300281 .hardware = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 .fops = &fmi_fops,
283};
284
285/* ladis: this is my card. does any other types exist? */
286static struct isapnp_device_id id_table[] __devinitdata = {
287 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
288 ISAPNP_VENDOR('M','F','R'), ISAPNP_FUNCTION(0xad10), 0},
289 { ISAPNP_CARD_END, },
290};
291
292MODULE_DEVICE_TABLE(isapnp, id_table);
293
294static int isapnp_fmi_probe(void)
295{
296 int i = 0;
297
298 while (id_table[i].card_vendor != 0 && dev == NULL) {
299 dev = pnp_find_dev(NULL, id_table[i].vendor,
300 id_table[i].function, NULL);
301 i++;
302 }
303
304 if (!dev)
305 return -ENODEV;
306 if (pnp_device_attach(dev) < 0)
307 return -EAGAIN;
308 if (pnp_activate_dev(dev) < 0) {
309 printk ("radio-sf16fmi: PnP configure failed (out of resources?)\n");
310 pnp_device_detach(dev);
311 return -ENOMEM;
312 }
313 if (!pnp_port_valid(dev, 0)) {
314 pnp_device_detach(dev);
315 return -ENODEV;
316 }
317
318 i = pnp_port_start(dev, 0);
319 printk ("radio-sf16fmi: PnP reports card at %#x\n", i);
320
321 return i;
322}
323
324static int __init fmi_init(void)
325{
326 if (io < 0)
327 io = isapnp_fmi_probe();
328 if (io < 0) {
329 printk(KERN_ERR "radio-sf16fmi: No PnP card found.\n");
330 return io;
331 }
332 if (!request_region(io, 2, "radio-sf16fmi")) {
333 printk(KERN_ERR "radio-sf16fmi: port 0x%x already in use\n", io);
334 return -EBUSY;
335 }
336
337 fmi_unit.port = io;
338 fmi_unit.curvol = 0;
339 fmi_unit.curfreq = 0;
Mauro Carvalho Chehaba2ef73a2006-08-08 09:10:02 -0300340 fmi_unit.flags = V4L2_TUNER_CAP_LOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 fmi_radio.priv = &fmi_unit;
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -0300342
Ingo Molnar3593cab2006-02-07 06:49:14 -0200343 mutex_init(&lock);
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -0300344
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 if (video_register_device(&fmi_radio, VFL_TYPE_RADIO, radio_nr) == -1) {
346 release_region(io, 2);
347 return -EINVAL;
348 }
Mauro Carvalho Chehab4286c6f2006-04-08 16:06:16 -0300349
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 printk(KERN_INFO "SF16FMx radio card driver at 0x%x\n", io);
351 /* mute card - prevents noisy bootups */
352 fmi_mute(io);
353 return 0;
354}
355
356MODULE_AUTHOR("Petr Vandrovec, vandrove@vc.cvut.cz and M. Kirkwood");
357MODULE_DESCRIPTION("A driver for the SF16MI radio.");
358MODULE_LICENSE("GPL");
359
360module_param(io, int, 0);
361MODULE_PARM_DESC(io, "I/O address of the SF16MI card (0x284 or 0x384)");
362module_param(radio_nr, int, 0);
363
364static void __exit fmi_cleanup_module(void)
365{
366 video_unregister_device(&fmi_radio);
367 release_region(io, 2);
368 if (dev)
369 pnp_device_detach(dev);
370}
371
372module_init(fmi_init);
373module_exit(fmi_cleanup_module);