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         if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
 171                 return -EINVAL;
 172         rt_setfreq(rt, f->frequency);
 173         return 0;
 174 }
 175
 176 static int vidioc_g_frequency(struct file *file, void *priv,
 177                                 struct v4l2_frequency *f)
 178 {
 179         struct rtrack2 *rt = video_drvdata(file);
 180
 181         if (f->tuner != 0)
 182                 return -EINVAL;
 183         f->type = V4L2_TUNER_RADIO;
 184         f->frequency = rt->curfreq;
 185         return 0;
 186 }
 187
 188 static int vidioc_queryctrl(struct file *file, void *priv,
 189                                 struct v4l2_queryctrl *qc)
 190 {
 191         switch (qc->id) {
 192         case V4L2_CID_AUDIO_MUTE:
 193                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
 194         case V4L2_CID_AUDIO_VOLUME:
 195                 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535, 65535);
 196         }
 197         return -EINVAL;
 198 }
 199
 200 static int vidioc_g_ctrl(struct file *file, void *priv,
 201                                 struct v4l2_control *ctrl)
 202 {
 203         struct rtrack2 *rt = video_drvdata(file);
 204
 205         switch (ctrl->id) {
 206         case V4L2_CID_AUDIO_MUTE:
 207                 ctrl->value = rt->muted;
 208                 return 0;
 209         case V4L2_CID_AUDIO_VOLUME:
 210                 if (rt->muted)
 211                         ctrl->value = 0;
 212                 else
 213                         ctrl->value = 65535;
 214                 return 0;
 215         }
 216         return -EINVAL;
 217 }
 218
 219 static int vidioc_s_ctrl(struct file *file, void *priv,
 220                                 struct v4l2_control *ctrl)
 221 {
 222         struct rtrack2 *rt = video_drvdata(file);
 223
 224         switch (ctrl->id) {
 225         case V4L2_CID_AUDIO_MUTE:
 226                 if (ctrl->value)
 227                         rt_mute(rt);
 228                 else
 229                         rt_unmute(rt);
 230                 return 0;
 231         case V4L2_CID_AUDIO_VOLUME:
 232                 if (ctrl->value)
 233                         rt_unmute(rt);
 234                 else
 235                         rt_mute(rt);
 236                 return 0;
 237         }
 238         return -EINVAL;
 239 }
 240
 241 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 242 {
 243         *i = 0;
 244         return 0;
 245 }
 246
 247 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 248 {
 249         return i ? -EINVAL : 0;
 250 }
 251
 252 static int vidioc_g_audio(struct file *file, void *priv,
 253                                 struct v4l2_audio *a)
 254 {
 255         a->index = 0;
 256         strlcpy(a->name, "Radio", sizeof(a->name));
 257         a->capability = V4L2_AUDCAP_STEREO;
 258         return 0;
 259 }
 260
 261 static int vidioc_s_audio(struct file *file, void *priv,
 262                                 struct v4l2_audio *a)
 263 {
 264         return a->index ? -EINVAL : 0;
 265 }
 266
 267 static const struct v4l2_file_operations rtrack2_fops = {
 268         .owner          = THIS_MODULE,
 269         .unlocked_ioctl = video_ioctl2,
 270 };
 271
 272 static const struct v4l2_ioctl_ops rtrack2_ioctl_ops = {
 273         .vidioc_querycap    = vidioc_querycap,
 274         .vidioc_g_tuner     = vidioc_g_tuner,
 275         .vidioc_s_tuner     = vidioc_s_tuner,
 276         .vidioc_g_frequency = vidioc_g_frequency,
 277         .vidioc_s_frequency = vidioc_s_frequency,
 278         .vidioc_queryctrl   = vidioc_queryctrl,
 279         .vidioc_g_ctrl      = vidioc_g_ctrl,
 280         .vidioc_s_ctrl      = vidioc_s_ctrl,
 281         .vidioc_g_audio     = vidioc_g_audio,
 282         .vidioc_s_audio     = vidioc_s_audio,
 283         .vidioc_g_input     = vidioc_g_input,
 284         .vidioc_s_input     = vidioc_s_input,
 285 };
 286
 287 static int __init rtrack2_init(void)
 288 {
 289         struct rtrack2 *dev = &rtrack2_card;
 290         struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
 291         int res;
 292
 293         strlcpy(v4l2_dev->name, "rtrack2", sizeof(v4l2_dev->name));
 294         dev->io = io;
 295         if (dev->io == -1) {
 296                 v4l2_err(v4l2_dev, "You must set an I/O address with io=0x20c or io=0x30c\n");
 297                 return -EINVAL;
 298         }
 299         if (!request_region(dev->io, 4, "rtrack2")) {
 300                 v4l2_err(v4l2_dev, "port 0x%x already in use\n", dev->io);
 301                 return -EBUSY;
 302         }
 303
 304         res = v4l2_device_register(NULL, v4l2_dev);
 305         if (res < 0) {
 306                 release_region(dev->io, 4);
 307                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
 308                 return res;
 309         }
 310
 311         strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
 312         dev->vdev.v4l2_dev = v4l2_dev;
 313         dev->vdev.fops = &rtrack2_fops;
 314         dev->vdev.ioctl_ops = &rtrack2_ioctl_ops;
 315         dev->vdev.release = video_device_release_empty;
 316         video_set_drvdata(&dev->vdev, dev);
 317
 318         /* mute card - prevents noisy bootups */
 319         outb(1, dev->io);
 320         dev->muted = 1;
 321
 322         mutex_init(&dev->lock);
 323         if (video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
 324                 v4l2_device_unregister(v4l2_dev);
 325                 release_region(dev->io, 4);
 326                 return -EINVAL;
 327         }
 328
 329         v4l2_info(v4l2_dev, "AIMSlab Radiotrack II card driver.\n");
 330
 331         return 0;
 332 }
 333
 334 static void __exit rtrack2_exit(void)
 335 {
 336         struct rtrack2 *dev = &rtrack2_card;
 337
 338         video_unregister_device(&dev->vdev);
 339         v4l2_device_unregister(&dev->v4l2_dev);
 340         release_region(dev->io, 4);
 341 }
 342
 343 module_init(rtrack2_init);
 344 module_exit(rtrack2_exit);