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 <media/v4l2-ctrls.h>
  21 #include <media/v4l2-fh.h>
  22 #include <media/v4l2-event.h>
  23 #include <sound/aci.h>
  24
  25 static int radio_nr = -1;
  26 module_param(radio_nr, int, 0);
  27 MODULE_PARM_DESC(radio_nr, "Set radio device number (/dev/radioX).  Default: -1 (autodetect)");
  28
  29 struct pcm20 {
  30         struct v4l2_device v4l2_dev;
  31         struct video_device vdev;
  32         struct v4l2_ctrl_handler ctrl_handler;
  33         unsigned long freq;
  34         u32 audmode;
  35         struct snd_miro_aci *aci;
  36         struct mutex lock;
  37 };
  38
  39 static struct pcm20 pcm20_card = {
  40         .freq = 87 * 16000,
  41         .audmode = V4L2_TUNER_MODE_STEREO,
  42 };
  43
  44 static int pcm20_setfreq(struct pcm20 *dev, unsigned long freq)
  45 {
  46         unsigned char freql;
  47         unsigned char freqh;
  48         struct snd_miro_aci *aci = dev->aci;
  49
  50         freq /= 160;
  51         if (!(aci->aci_version == 0x07 || aci->aci_version >= 0xb0))
  52                 freq /= 10;  /* I don't know exactly which version
  53                               * needs this hack */
  54         freql = freq & 0xff;
  55         freqh = freq >> 8;
  56
  57         return snd_aci_cmd(aci, ACI_WRITE_TUNE, freql, freqh);
  58 }
  59
  60 static const struct v4l2_file_operations pcm20_fops = {
  61         .owner          = THIS_MODULE,
  62         .open           = v4l2_fh_open,
  63         .poll           = v4l2_ctrl_poll,
  64         .release        = v4l2_fh_release,
  65         .unlocked_ioctl = video_ioctl2,
  66 };
  67
  68 static int vidioc_querycap(struct file *file, void *priv,
  69                                 struct v4l2_capability *v)
  70 {
  71         struct pcm20 *dev = video_drvdata(file);
  72
  73         strlcpy(v->driver, "Miro PCM20", sizeof(v->driver));
  74         strlcpy(v->card, "Miro PCM20", sizeof(v->card));
  75         snprintf(v->bus_info, sizeof(v->bus_info), "ISA:%s", dev->v4l2_dev.name);
  76         v->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
  77         v->capabilities = v->device_caps | V4L2_CAP_DEVICE_CAPS;
  78         return 0;
  79 }
  80
  81 static int vidioc_g_tuner(struct file *file, void *priv,
  82                                 struct v4l2_tuner *v)
  83 {
  84         struct pcm20 *dev = video_drvdata(file);
  85         int res;
  86
  87         if (v->index)
  88                 return -EINVAL;
  89         strlcpy(v->name, "FM", sizeof(v->name));
  90         v->type = V4L2_TUNER_RADIO;
  91         v->rangelow = 87*16000;
  92         v->rangehigh = 108*16000;
  93         res = snd_aci_cmd(dev->aci, ACI_READ_TUNERSTATION, -1, -1);
  94         v->signal = (res & 0x80) ? 0 : 0xffff;
  95         /* Note: stereo detection does not work if the audio is muted,
  96            it will default to mono in that case. */
  97         res = snd_aci_cmd(dev->aci, ACI_READ_TUNERSTEREO, -1, -1);
  98         v->rxsubchans = (res & 0x40) ? V4L2_TUNER_SUB_MONO :
  99                                         V4L2_TUNER_SUB_STEREO;
 100         v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
 101         v->audmode = dev->audmode;
 102         return 0;
 103 }
 104
 105 static int vidioc_s_tuner(struct file *file, void *priv,
 106                                 const struct v4l2_tuner *v)
 107 {
 108         struct pcm20 *dev = video_drvdata(file);
 109
 110         if (v->index)
 111                 return -EINVAL;
 112         if (v->audmode > V4L2_TUNER_MODE_STEREO)
 113                 dev->audmode = V4L2_TUNER_MODE_STEREO;
 114         else
 115                 dev->audmode = v->audmode;
 116         snd_aci_cmd(dev->aci, ACI_SET_TUNERMONO,
 117                         dev->audmode == V4L2_TUNER_MODE_MONO, -1);
 118         return 0;
 119 }
 120
 121 static int vidioc_g_frequency(struct file *file, void *priv,
 122                                 struct v4l2_frequency *f)
 123 {
 124         struct pcm20 *dev = video_drvdata(file);
 125
 126         if (f->tuner != 0)
 127                 return -EINVAL;
 128
 129         f->type = V4L2_TUNER_RADIO;
 130         f->frequency = dev->freq;
 131         return 0;
 132 }
 133
 134
 135 static int vidioc_s_frequency(struct file *file, void *priv,
 136                                 const struct v4l2_frequency *f)
 137 {
 138         struct pcm20 *dev = video_drvdata(file);
 139
 140         if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
 141                 return -EINVAL;
 142
 143         dev->freq = clamp_t(u32, f->frequency, 87 * 16000U, 108 * 16000U);
 144         pcm20_setfreq(dev, dev->freq);
 145         return 0;
 146 }
 147
 148 static int pcm20_s_ctrl(struct v4l2_ctrl *ctrl)
 149 {
 150         struct pcm20 *dev = container_of(ctrl->handler, struct pcm20, ctrl_handler);
 151
 152         switch (ctrl->id) {
 153         case V4L2_CID_AUDIO_MUTE:
 154                 snd_aci_cmd(dev->aci, ACI_SET_TUNERMUTE, ctrl->val, -1);
 155                 return 0;
 156         }
 157         return -EINVAL;
 158 }
 159
 160 static const struct v4l2_ioctl_ops pcm20_ioctl_ops = {
 161         .vidioc_querycap    = vidioc_querycap,
 162         .vidioc_g_tuner     = vidioc_g_tuner,
 163         .vidioc_s_tuner     = vidioc_s_tuner,
 164         .vidioc_g_frequency = vidioc_g_frequency,
 165         .vidioc_s_frequency = vidioc_s_frequency,
 166         .vidioc_log_status  = v4l2_ctrl_log_status,
 167         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
 168         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 169 };
 170
 171 static const struct v4l2_ctrl_ops pcm20_ctrl_ops = {
 172         .s_ctrl = pcm20_s_ctrl,
 173 };
 174
 175 static int __init pcm20_init(void)
 176 {
 177         struct pcm20 *dev = &pcm20_card;
 178         struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
 179         struct v4l2_ctrl_handler *hdl;
 180         int res;
 181
 182         dev->aci = snd_aci_get_aci();
 183         if (dev->aci == NULL) {
 184                 v4l2_err(v4l2_dev,
 185                          "you must load the snd-miro driver first!\n");
 186                 return -ENODEV;
 187         }
 188         strlcpy(v4l2_dev->name, "radio-miropcm20", sizeof(v4l2_dev->name));
 189         mutex_init(&dev->lock);
 190
 191         res = v4l2_device_register(NULL, v4l2_dev);
 192         if (res < 0) {
 193                 v4l2_err(v4l2_dev, "could not register v4l2_device\n");
 194                 return -EINVAL;
 195         }
 196
 197         hdl = &dev->ctrl_handler;
 198         v4l2_ctrl_handler_init(hdl, 1);
 199         v4l2_ctrl_new_std(hdl, &pcm20_ctrl_ops,
 200                         V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
 201         v4l2_dev->ctrl_handler = hdl;
 202         if (hdl->error) {
 203                 res = hdl->error;
 204                 v4l2_err(v4l2_dev, "Could not register control\n");
 205                 goto err_hdl;
 206         }
 207         strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
 208         dev->vdev.v4l2_dev = v4l2_dev;
 209         dev->vdev.fops = &pcm20_fops;
 210         dev->vdev.ioctl_ops = &pcm20_ioctl_ops;
 211         dev->vdev.release = video_device_release_empty;
 212         dev->vdev.lock = &dev->lock;
 213         set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev.flags);
 214         video_set_drvdata(&dev->vdev, dev);
 215         snd_aci_cmd(dev->aci, ACI_SET_TUNERMONO,
 216                         dev->audmode == V4L2_TUNER_MODE_MONO, -1);
 217         pcm20_setfreq(dev, dev->freq);
 218
 219         if (video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr) < 0)
 220                 goto err_hdl;
 221
 222         v4l2_info(v4l2_dev, "Mirosound PCM20 Radio tuner\n");
 223         return 0;
 224 err_hdl:
 225         v4l2_ctrl_handler_free(hdl);
 226         v4l2_device_unregister(v4l2_dev);
 227         return -EINVAL;
 228 }
 229
 230 MODULE_AUTHOR("Ruurd Reitsma, Krzysztof Helt");
 231 MODULE_DESCRIPTION("A driver for the Miro PCM20 radio card.");
 232 MODULE_LICENSE("GPL");
 233
 234 static void __exit pcm20_cleanup(void)
 235 {
 236         struct pcm20 *dev = &pcm20_card;
 237
 238         video_unregister_device(&dev->vdev);
 239         snd_aci_cmd(dev->aci, ACI_SET_TUNERMUTE, 1, -1);
 240         v4l2_ctrl_handler_free(&dev->ctrl_handler);
 241         v4l2_device_unregister(&dev->v4l2_dev);
 242 }
 243
 244 module_init(pcm20_init);
 245 module_exit(pcm20_cleanup);