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);