drivers/media/radio/radio-miropcm20.c

   1 /* Miro PCM20 radio driver for Linux radio support
   2  * (c) 1998 Ruurd Reitsma <R.A.Reitsma@wbmt.tudelft.nl>
   3  * Thanks to Norberto Pellici for the ACI device interface specification
   4  * The API part is based on the radiotrack driver by M. Kirkwood
   5  * This driver relies on the aci mixer provided by the snd-miro
   6  * ALSA driver.
   7  * Look there for further info...
   8  */
   9
  10 /* What ever you think about the ACI, version 0x07 is not very well!
  11  * I can't get frequency, 'tuner status', 'tuner flags' or mute/mono
  12  * conditions...                Robert
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/videodev2.h>
  18 #include <media/v4l2-device.h>
  19 #include <media/v4l2-ioctl.h>
  20 #include <sound/aci.h>
  21
  22 static int radio_nr = -1;
  23 module_param(radio_nr, int, 0);
  24 MODULE_PARM_DESC(radio_nr, "Set radio device number (/dev/radioX).  Default: -1 (autodetect)");
  25
  26 static bool mono;
  27 module_param(mono, bool, 0);
  28 MODULE_PARM_DESC(mono, "Force tuner into mono mode.");
  29
  30 struct pcm20 {
  31         struct v4l2_device v4l2_dev;
  32         struct video_device vdev;
  33         unsigned long freq;
  34         int muted;
  35         struct snd_miro_aci *aci;
  36         struct mutex lock;
  37 };
  38
  39 static struct pcm20 pcm20_card = {
  40         .freq   = 87*16000,
  41         .muted  = 1,
  42 };
  43
  44 static int pcm20_mute(struct pcm20 *dev, unsigned char mute)
  45 {
  46         dev->muted = mute;
  47         return snd_aci_cmd(dev->aci, ACI_SET_TUNERMUTE, mute, -1);
  48 }
  49
  50 static int pcm20_stereo(struct pcm20 *dev, unsigned char stereo)
  51 {
  52         return snd_aci_cmd(dev->aci, ACI_SET_TUNERMONO, !stereo, -1);
  53 }
  54
  55 static int pcm20_setfreq(struct pcm20 *dev, unsigned long freq)
  56 {
  57         unsigned char freql;
  58         unsigned char freqh;
  59         struct snd_miro_aci *aci = dev->aci;
  60
  61         dev->freq = freq;
  62
  63         freq /= 160;
  64         if (!(aci->aci_version == 0x07 || aci->aci_version >= 0xb0))
  65                 freq /= 10;  /* I don't know exactly which version
  66                               * needs this hack */
  67         freql = freq & 0xff;
  68         freqh = freq >> 8;
  69
  70         pcm20_stereo(dev, !mono);
  71         return snd_aci_cmd(aci, ACI_WRITE_TUNE, freql, freqh);
  72 }
  73
  74 static const struct v4l2_file_operations pcm20_fops = {
  75         .owner          = THIS_MODULE,
  76         .unlocked_ioctl = video_ioctl2,
  77 };
  78
  79 static int vidioc_querycap(struct file *file, void *priv,
  80                                 struct v4l2_capability *v)
  81 {
  82         struct pcm20 *dev = video_drvdata(file);
  83
  84         strlcpy(v->driver, "Miro PCM20", sizeof(v->driver));
  85         strlcpy(v->card, "Miro PCM20", sizeof(v->card));
  86         snprintf(v->bus_info, sizeof(v->bus_info), "ISA:%s", dev->v4l2_dev.name);
  87         v->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
  88         v->capabilities = v->device_caps | V4L2_CAP_DEVICE_CAPS;
  89         return 0;
  90 }
  91
  92 static int vidioc_g_tuner(struct file *file, void *priv,
  93                                 struct v4l2_tuner *v)
  94 {
  95         if (v->index)   /* Only 1 tuner */
  96                 return -EINVAL;
  97         strlcpy(v->name, "FM", sizeof(v->name));
  98         v->type = V4L2_TUNER_RADIO;
  99         v->rangelow = 87*16000;
 100         v->rangehigh = 108*16000;
 101         v->signal = 0xffff;
 102         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 103         v->capability = V4L2_TUNER_CAP_LOW;
 104         v->audmode = V4L2_TUNER_MODE_MONO;
 105         return 0;
 106 }
 107
 108 static int vidioc_s_tuner(struct file *file, void *priv,
 109                                 struct v4l2_tuner *v)
 110 {
 111         return v->index ? -EINVAL : 0;
 112 }
 113
 114 static int vidioc_g_frequency(struct file *file, void *priv,
 115                                 struct v4l2_frequency *f)
 116 {
 117         struct pcm20 *dev = video_drvdata(file);
 118
 119         if (f->tuner != 0)
 120                 return -EINVAL;
 121
 122         f->type = V4L2_TUNER_RADIO;
 123         f->frequency = dev->freq;
 124         return 0;
 125 }
 126
 127
 128 static int vidioc_s_frequency(struct file *file, void *priv,
 129                                 struct v4l2_frequency *f)
 130 {
 131         struct pcm20 *dev = video_drvdata(file);
 132
 133         if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
 134                 return -EINVAL;
 135
 136         dev->freq = f->frequency;
 137         pcm20_setfreq(dev, f->frequency);
 138         return 0;
 139 }
 140
 141 static int vidioc_queryctrl(struct file *file, void *priv,
 142                                 struct v4l2_queryctrl *qc)
 143 {
 144         switch (qc->id) {
 145         case V4L2_CID_AUDIO_MUTE:
 146                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
 147         }
 148         return -EINVAL;
 149 }
 150
 151 static int vidioc_g_ctrl(struct file *file, void *priv,
 152                                 struct v4l2_control *ctrl)
 153 {
 154         struct pcm20 *dev = video_drvdata(file);
 155
 156         switch (ctrl->id) {
 157         case V4L2_CID_AUDIO_MUTE:
 158                 ctrl->value = dev->muted;
 159                 break;
 160         default:
 161                 return -EINVAL;
 162         }
 163         return 0;
 164 }
 165
 166 static int vidioc_s_ctrl(struct file *file, void *priv,
 167                                 struct v4l2_control *ctrl)
 168 {
 169         struct pcm20 *dev = video_drvdata(file);
 170
 171         switch (ctrl->id) {
 172         case V4L2_CID_AUDIO_MUTE:
 173                 pcm20_mute(dev, ctrl->value);
 174                 break;
 175         default:
 176                 return -EINVAL;
 177         }
 178         return 0;
 179 }
 180
 181 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 182 {
 183         *i = 0;
 184         return 0;
 185 }
 186
 187 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 188 {
 189         return i ? -EINVAL : 0;
 190 }
 191
 192 static int vidioc_g_audio(struct file *file, void *priv,
 193                                 struct v4l2_audio *a)
 194 {
 195         a->index = 0;
 196         strlcpy(a->name, "Radio", sizeof(a->name));
 197         a->capability = V4L2_AUDCAP_STEREO;
 198         return 0;
 199 }
 200
 201 static int vidioc_s_audio(struct file *file, void *priv,
 202                                 const struct v4l2_audio *a)
 203 {
 204         return a->index ? -EINVAL : 0;
 205 }
 206
 207 static const struct v4l2_ioctl_ops pcm20_ioctl_ops = {
 208         .vidioc_querycap    = vidioc_querycap,
 209         .vidioc_g_tuner     = vidioc_g_tuner,
 210         .vidioc_s_tuner     = vidioc_s_tuner,
 211         .vidioc_g_frequency = vidioc_g_frequency,
 212         .vidioc_s_frequency = vidioc_s_frequency,
 213         .vidioc_queryctrl   = vidioc_queryctrl,
 214         .vidioc_g_ctrl      = vidioc_g_ctrl,
 215         .vidioc_s_ctrl      = vidioc_s_ctrl,
 216         .vidioc_g_audio     = vidioc_g_audio,
 217         .vidioc_s_audio     = vidioc_s_audio,
 218         .vidioc_g_input     = vidioc_g_input,
 219         .vidioc_s_input     = vidioc_s_input,
 220 };
 221
 222 static int __init pcm20_init(void)
 223 {
 224         struct pcm20 *dev = &pcm20_card;
 225         struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
 226         int res;
 227
 228         dev->aci = snd_aci_get_aci();
 229         if (dev->aci == NULL) {
 230                 v4l2_err(v4l2_dev,
 231                          "you must load the snd-miro driver first!\n");
 232                 return -ENODEV;
 233         }
 234         strlcpy(v4l2_dev->name, "radio-miropcm20", sizeof(v4l2_dev->name));
 235         mutex_init(&dev->lock);
 236
 237         res = v4l2_device_register(NULL, v4l2_dev);
 238         if (res < 0) {
 239                 v4l2_err(v4l2_dev, "could not register v4l2_device\n");
 240                 return -EINVAL;
 241         }
 242
 243         strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
 244         dev->vdev.v4l2_dev = v4l2_dev;
 245         dev->vdev.fops = &pcm20_fops;
 246         dev->vdev.ioctl_ops = &pcm20_ioctl_ops;
 247         dev->vdev.release = video_device_release_empty;
 248         dev->vdev.lock = &dev->lock;
 249         video_set_drvdata(&dev->vdev, dev);
 250
 251         if (video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr) < 0)
 252                 goto fail;
 253
 254         v4l2_info(v4l2_dev, "Mirosound PCM20 Radio tuner\n");
 255         return 0;
 256 fail:
 257         v4l2_device_unregister(v4l2_dev);
 258         return -EINVAL;
 259 }
 260
 261 MODULE_AUTHOR("Ruurd Reitsma, Krzysztof Helt");
 262 MODULE_DESCRIPTION("A driver for the Miro PCM20 radio card.");
 263 MODULE_LICENSE("GPL");
 264
 265 static void __exit pcm20_cleanup(void)
 266 {
 267         struct pcm20 *dev = &pcm20_card;
 268
 269         video_unregister_device(&dev->vdev);
 270         v4l2_device_unregister(&dev->v4l2_dev);
 271 }
 272
 273 module_init(pcm20_init);
 274 module_exit(pcm20_cleanup);