drivers/media/radio/radio-sf16fmi.c

   1 /* 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
  15  *
  16  */
  17
  18 #include <linux/kernel.h>       /* __setup                      */
  19 #include <linux/module.h>       /* Modules                      */
  20 #include <linux/init.h>         /* Initdata                     */
  21 #include <linux/ioport.h>       /* check_region, request_region */
  22 #include <linux/delay.h>        /* udelay                       */
  23 #include <linux/videodev.h>     /* kernel radio structs         */
  24 #include <linux/isapnp.h>
  25 #include <asm/io.h>             /* outb, outb_p                 */
  26 #include <asm/uaccess.h>        /* copy to/from user            */
  27 #include <asm/semaphore.h>
  28
  29 struct fmi_device
  30 {
  31         int port;
  32         int curvol; /* 1 or 0 */
  33         unsigned long curfreq; /* freq in kHz */
  34         __u32 flags;
  35 };
  36
  37 static int io = -1;
  38 static int radio_nr = -1;
  39 static struct pnp_dev *dev = NULL;
  40 static struct semaphore lock;
  41
  42 /* freq is in 1/16 kHz to internal number, hw precision is 50 kHz */
  43 /* It is only useful to give freq in intervall of 800 (=0.05Mhz),
  44  * other bits will be truncated, e.g 92.7400016 -> 92.7, but
  45  * 92.7400017 -> 92.75
  46  */
  47 #define RSF16_ENCODE(x) ((x)/800+214)
  48 #define RSF16_MINFREQ 87*16000
  49 #define RSF16_MAXFREQ 108*16000
  50
  51 static void outbits(int bits, unsigned int data, int port)
  52 {
  53         while(bits--) {
  54                 if(data & 1) {
  55                         outb(5, port);
  56                         udelay(6);
  57                         outb(7, port);
  58                         udelay(6);
  59                 } else {
  60                         outb(1, port);
  61                         udelay(6);
  62                         outb(3, port);
  63                         udelay(6);
  64                 }
  65                 data>>=1;
  66         }
  67 }
  68
  69 static inline void fmi_mute(int port)
  70 {
  71         down(&lock);
  72         outb(0x00, port);
  73         up(&lock);
  74 }
  75
  76 static inline void fmi_unmute(int port)
  77 {
  78         down(&lock);
  79         outb(0x08, port);
  80         up(&lock);
  81 }
  82
  83 static inline int fmi_setfreq(struct fmi_device *dev)
  84 {
  85         int myport = dev->port;
  86         unsigned long freq = dev->curfreq;
  87
  88         down(&lock);
  89
  90         outbits(16, RSF16_ENCODE(freq), myport);
  91         outbits(8, 0xC0, myport);
  92         current->state = TASK_UNINTERRUPTIBLE;
  93         schedule_timeout(HZ/7);
  94         up(&lock);
  95         if (dev->curvol) fmi_unmute(myport);
  96         return 0;
  97 }
  98
  99 static inline int fmi_getsigstr(struct fmi_device *dev)
 100 {
 101         int val;
 102         int res;
 103         int myport = dev->port;
 104
 105
 106         down(&lock);
 107         val = dev->curvol ? 0x08 : 0x00;        /* unmute/mute */
 108         outb(val, myport);
 109         outb(val | 0x10, myport);
 110         set_current_state(TASK_UNINTERRUPTIBLE);
 111         schedule_timeout(HZ/7);
 112         res = (int)inb(myport+1);
 113         outb(val, myport);
 114
 115         up(&lock);
 116         return (res & 2) ? 0 : 0xFFFF;
 117 }
 118
 119 static int fmi_do_ioctl(struct inode *inode, struct file *file,
 120                         unsigned int cmd, void *arg)
 121 {
 122         struct video_device *dev = video_devdata(file);
 123         struct fmi_device *fmi=dev->priv;
 124
 125         switch(cmd)
 126         {
 127                 case VIDIOCGCAP:
 128                 {
 129                         struct video_capability *v = arg;
 130                         memset(v,0,sizeof(*v));
 131                         strcpy(v->name, "SF16-FMx radio");
 132                         v->type=VID_TYPE_TUNER;
 133                         v->channels=1;
 134                         v->audios=1;
 135                         return 0;
 136                 }
 137                 case VIDIOCGTUNER:
 138                 {
 139                         struct video_tuner *v = arg;
 140                         int mult;
 141
 142                         if(v->tuner)    /* Only 1 tuner */
 143                                 return -EINVAL;
 144                         strcpy(v->name, "FM");
 145                         mult = (fmi->flags & VIDEO_TUNER_LOW) ? 1 : 1000;
 146                         v->rangelow = RSF16_MINFREQ/mult;
 147                         v->rangehigh = RSF16_MAXFREQ/mult;
 148                         v->flags=fmi->flags;
 149                         v->mode=VIDEO_MODE_AUTO;
 150                         v->signal = fmi_getsigstr(fmi);
 151                         return 0;
 152                 }
 153                 case VIDIOCSTUNER:
 154                 {
 155                         struct video_tuner *v = arg;
 156                         if(v->tuner!=0)
 157                                 return -EINVAL;
 158                         fmi->flags = v->flags & VIDEO_TUNER_LOW;
 159                         /* Only 1 tuner so no setting needed ! */
 160                         return 0;
 161                 }
 162                 case VIDIOCGFREQ:
 163                 {
 164                         unsigned long *freq = arg;
 165                         *freq = fmi->curfreq;
 166                         if (!(fmi->flags & VIDEO_TUNER_LOW))
 167                             *freq /= 1000;
 168                         return 0;
 169                 }
 170                 case VIDIOCSFREQ:
 171                 {
 172                         unsigned long *freq = arg;
 173                         if (!(fmi->flags & VIDEO_TUNER_LOW))
 174                                 *freq *= 1000;
 175                         if (*freq < RSF16_MINFREQ || *freq > RSF16_MAXFREQ )
 176                                 return -EINVAL;
 177                         /*rounding in steps of 800 to match th freq
 178                           that will be used */
 179                         fmi->curfreq = (*freq/800)*800;
 180                         fmi_setfreq(fmi);
 181                         return 0;
 182                 }
 183                 case VIDIOCGAUDIO:
 184                 {
 185                         struct video_audio *v = arg;
 186                         memset(v,0,sizeof(*v));
 187                         v->flags=( (!fmi->curvol)*VIDEO_AUDIO_MUTE | VIDEO_AUDIO_MUTABLE);
 188                         strcpy(v->name, "Radio");
 189                         v->mode=VIDEO_SOUND_STEREO;
 190                         return 0;
 191                 }
 192                 case VIDIOCSAUDIO:
 193                 {
 194                         struct video_audio *v = arg;
 195                         if(v->audio)
 196                                 return -EINVAL;
 197                         fmi->curvol= v->flags&VIDEO_AUDIO_MUTE ? 0 : 1;
 198                         fmi->curvol ?
 199                                 fmi_unmute(fmi->port) : fmi_mute(fmi->port);
 200                         return 0;
 201                 }
 202                 case VIDIOCGUNIT:
 203                 {
 204                         struct video_unit *v = arg;
 205                         v->video=VIDEO_NO_UNIT;
 206                         v->vbi=VIDEO_NO_UNIT;
 207                         v->radio=dev->minor;
 208                         v->audio=0; /* How do we find out this??? */
 209                         v->teletext=VIDEO_NO_UNIT;
 210                         return 0;
 211                 }
 212                 default:
 213                         return -ENOIOCTLCMD;
 214         }
 215 }
 216
 217 static int fmi_ioctl(struct inode *inode, struct file *file,
 218                      unsigned int cmd, unsigned long arg)
 219 {
 220         return video_usercopy(inode, file, cmd, arg, fmi_do_ioctl);
 221 }
 222
 223 static struct fmi_device fmi_unit;
 224
 225 static struct file_operations fmi_fops = {
 226         .owner          = THIS_MODULE,
 227         .open           = video_exclusive_open,
 228         .release        = video_exclusive_release,
 229         .ioctl          = fmi_ioctl,
 230         .llseek         = no_llseek,
 231 };
 232
 233 static struct video_device fmi_radio=
 234 {
 235         .owner          = THIS_MODULE,
 236         .name           = "SF16FMx radio",
 237         .type           = VID_TYPE_TUNER,
 238         .hardware       = VID_HARDWARE_SF16MI,
 239         .fops           = &fmi_fops,
 240 };
 241
 242 /* ladis: this is my card. does any other types exist? */
 243 static struct isapnp_device_id id_table[] __devinitdata = {
 244         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
 245                 ISAPNP_VENDOR('M','F','R'), ISAPNP_FUNCTION(0xad10), 0},
 246         {       ISAPNP_CARD_END, },
 247 };
 248
 249 MODULE_DEVICE_TABLE(isapnp, id_table);
 250
 251 static int isapnp_fmi_probe(void)
 252 {
 253         int i = 0;
 254
 255         while (id_table[i].card_vendor != 0 && dev == NULL) {
 256                 dev = pnp_find_dev(NULL, id_table[i].vendor,
 257                                    id_table[i].function, NULL);
 258                 i++;
 259         }
 260
 261         if (!dev)
 262                 return -ENODEV;
 263         if (pnp_device_attach(dev) < 0)
 264                 return -EAGAIN;
 265         if (pnp_activate_dev(dev) < 0) {
 266                 printk ("radio-sf16fmi: PnP configure failed (out of resources?)\n");
 267                 pnp_device_detach(dev);
 268                 return -ENOMEM;
 269         }
 270         if (!pnp_port_valid(dev, 0)) {
 271                 pnp_device_detach(dev);
 272                 return -ENODEV;
 273         }
 274
 275         i = pnp_port_start(dev, 0);
 276         printk ("radio-sf16fmi: PnP reports card at %#x\n", i);
 277
 278         return i;
 279 }
 280
 281 static int __init fmi_init(void)
 282 {
 283         if (io < 0)
 284                 io = isapnp_fmi_probe();
 285         if (io < 0) {
 286                 printk(KERN_ERR "radio-sf16fmi: No PnP card found.\n");
 287                 return io;
 288         }
 289         if (!request_region(io, 2, "radio-sf16fmi")) {
 290                 printk(KERN_ERR "radio-sf16fmi: port 0x%x already in use\n", io);
 291                 return -EBUSY;
 292         }
 293
 294         fmi_unit.port = io;
 295         fmi_unit.curvol = 0;
 296         fmi_unit.curfreq = 0;
 297         fmi_unit.flags = VIDEO_TUNER_LOW;
 298         fmi_radio.priv = &fmi_unit;
 299
 300         init_MUTEX(&lock);
 301
 302         if (video_register_device(&fmi_radio, VFL_TYPE_RADIO, radio_nr) == -1) {
 303                 release_region(io, 2);
 304                 return -EINVAL;
 305         }
 306
 307         printk(KERN_INFO "SF16FMx radio card driver at 0x%x\n", io);
 308         /* mute card - prevents noisy bootups */
 309         fmi_mute(io);
 310         return 0;
 311 }
 312
 313 MODULE_AUTHOR("Petr Vandrovec, vandrove@vc.cvut.cz and M. Kirkwood");
 314 MODULE_DESCRIPTION("A driver for the SF16MI radio.");
 315 MODULE_LICENSE("GPL");
 316
 317 MODULE_PARM(io, "i");
 318 MODULE_PARM_DESC(io, "I/O address of the SF16MI card (0x284 or 0x384)");
 319 MODULE_PARM(radio_nr, "i");
 320
 321 static void __exit fmi_cleanup_module(void)
 322 {
 323         video_unregister_device(&fmi_radio);
 324         release_region(io, 2);
 325         if (dev)
 326                 pnp_device_detach(dev);
 327 }
 328
 329 module_init(fmi_init);
 330 module_exit(fmi_cleanup_module);
 331
 332 #ifndef MODULE
 333 static int __init fmi_setup_io(char *str)
 334 {
 335         get_option(&str, &io);
 336         return 1;
 337 }
 338
 339 __setup("sf16fm=", fmi_setup_io);
 340 #endif