linux/drivers/media/radio/radio-miropcm20.c
<<
>>
Prefs
   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
  22static int radio_nr = -1;
  23module_param(radio_nr, int, 0);
  24MODULE_PARM_DESC(radio_nr, "Set radio device number (/dev/radioX).  Default: -1 (autodetect)");
  25
  26static bool mono;
  27module_param(mono, bool, 0);
  28MODULE_PARM_DESC(mono, "Force tuner into mono mode.");
  29
  30struct 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
  39static struct pcm20 pcm20_card = {
  40        .freq   = 87*16000,
  41        .muted  = 1,
  42};
  43
  44static 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
  50static int pcm20_stereo(struct pcm20 *dev, unsigned char stereo)
  51{
  52        return snd_aci_cmd(dev->aci, ACI_SET_TUNERMONO, !stereo, -1);
  53}
  54
  55static 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
  74static const struct v4l2_file_operations pcm20_fops = {
  75        .owner          = THIS_MODULE,
  76        .unlocked_ioctl = video_ioctl2,
  77};
  78
  79static int vidioc_querycap(struct file *file, void *priv,
  80                                struct v4l2_capability *v)
  81{
  82        strlcpy(v->driver, "Miro PCM20", sizeof(v->driver));
  83        strlcpy(v->card, "Miro PCM20", sizeof(v->card));
  84        strlcpy(v->bus_info, "ISA", sizeof(v->bus_info));
  85        v->version = 0x1;
  86        v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
  87        return 0;
  88}
  89
  90static int vidioc_g_tuner(struct file *file, void *priv,
  91                                struct v4l2_tuner *v)
  92{
  93        if (v->index)   /* Only 1 tuner */
  94                return -EINVAL;
  95        strlcpy(v->name, "FM", sizeof(v->name));
  96        v->type = V4L2_TUNER_RADIO;
  97        v->rangelow = 87*16000;
  98        v->rangehigh = 108*16000;
  99        v->signal = 0xffff;
 100        v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 101        v->capability = V4L2_TUNER_CAP_LOW;
 102        v->audmode = V4L2_TUNER_MODE_MONO;
 103        return 0;
 104}
 105
 106static int vidioc_s_tuner(struct file *file, void *priv,
 107                                struct v4l2_tuner *v)
 108{
 109        return v->index ? -EINVAL : 0;
 110}
 111
 112static int vidioc_g_frequency(struct file *file, void *priv,
 113                                struct v4l2_frequency *f)
 114{
 115        struct pcm20 *dev = video_drvdata(file);
 116
 117        if (f->tuner != 0)
 118                return -EINVAL;
 119
 120        f->type = V4L2_TUNER_RADIO;
 121        f->frequency = dev->freq;
 122        return 0;
 123}
 124
 125
 126static int vidioc_s_frequency(struct file *file, void *priv,
 127                                struct v4l2_frequency *f)
 128{
 129        struct pcm20 *dev = video_drvdata(file);
 130
 131        if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
 132                return -EINVAL;
 133
 134        dev->freq = f->frequency;
 135        pcm20_setfreq(dev, f->frequency);
 136        return 0;
 137}
 138
 139static int vidioc_queryctrl(struct file *file, void *priv,
 140                                struct v4l2_queryctrl *qc)
 141{
 142        switch (qc->id) {
 143        case V4L2_CID_AUDIO_MUTE:
 144                return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
 145        }
 146        return -EINVAL;
 147}
 148
 149static int vidioc_g_ctrl(struct file *file, void *priv,
 150                                struct v4l2_control *ctrl)
 151{
 152        struct pcm20 *dev = video_drvdata(file);
 153
 154        switch (ctrl->id) {
 155        case V4L2_CID_AUDIO_MUTE:
 156                ctrl->value = dev->muted;
 157                break;
 158        default:
 159                return -EINVAL;
 160        }
 161        return 0;
 162}
 163
 164static int vidioc_s_ctrl(struct file *file, void *priv,
 165                                struct v4l2_control *ctrl)
 166{
 167        struct pcm20 *dev = video_drvdata(file);
 168
 169        switch (ctrl->id) {
 170        case V4L2_CID_AUDIO_MUTE:
 171                pcm20_mute(dev, ctrl->value);
 172                break;
 173        default:
 174                return -EINVAL;
 175        }
 176        return 0;
 177}
 178
 179static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 180{
 181        *i = 0;
 182        return 0;
 183}
 184
 185static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 186{
 187        return i ? -EINVAL : 0;
 188}
 189
 190static int vidioc_g_audio(struct file *file, void *priv,
 191                                struct v4l2_audio *a)
 192{
 193        a->index = 0;
 194        strlcpy(a->name, "Radio", sizeof(a->name));
 195        a->capability = V4L2_AUDCAP_STEREO;
 196        return 0;
 197}
 198
 199static int vidioc_s_audio(struct file *file, void *priv,
 200                                struct v4l2_audio *a)
 201{
 202        return a->index ? -EINVAL : 0;
 203}
 204
 205static const struct v4l2_ioctl_ops pcm20_ioctl_ops = {
 206        .vidioc_querycap    = vidioc_querycap,
 207        .vidioc_g_tuner     = vidioc_g_tuner,
 208        .vidioc_s_tuner     = vidioc_s_tuner,
 209        .vidioc_g_frequency = vidioc_g_frequency,
 210        .vidioc_s_frequency = vidioc_s_frequency,
 211        .vidioc_queryctrl   = vidioc_queryctrl,
 212        .vidioc_g_ctrl      = vidioc_g_ctrl,
 213        .vidioc_s_ctrl      = vidioc_s_ctrl,
 214        .vidioc_g_audio     = vidioc_g_audio,
 215        .vidioc_s_audio     = vidioc_s_audio,
 216        .vidioc_g_input     = vidioc_g_input,
 217        .vidioc_s_input     = vidioc_s_input,
 218};
 219
 220static int __init pcm20_init(void)
 221{
 222        struct pcm20 *dev = &pcm20_card;
 223        struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
 224        int res;
 225
 226        dev->aci = snd_aci_get_aci();
 227        if (dev->aci == NULL) {
 228                v4l2_err(v4l2_dev,
 229                         "you must load the snd-miro driver first!\n");
 230                return -ENODEV;
 231        }
 232        strlcpy(v4l2_dev->name, "miropcm20", sizeof(v4l2_dev->name));
 233        mutex_init(&dev->lock);
 234
 235        res = v4l2_device_register(NULL, v4l2_dev);
 236        if (res < 0) {
 237                v4l2_err(v4l2_dev, "could not register v4l2_device\n");
 238                return -EINVAL;
 239        }
 240
 241        strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
 242        dev->vdev.v4l2_dev = v4l2_dev;
 243        dev->vdev.fops = &pcm20_fops;
 244        dev->vdev.ioctl_ops = &pcm20_ioctl_ops;
 245        dev->vdev.release = video_device_release_empty;
 246        dev->vdev.lock = &dev->lock;
 247        video_set_drvdata(&dev->vdev, dev);
 248
 249        if (video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr) < 0)
 250                goto fail;
 251
 252        v4l2_info(v4l2_dev, "Mirosound PCM20 Radio tuner\n");
 253        return 0;
 254fail:
 255        v4l2_device_unregister(v4l2_dev);
 256        return -EINVAL;
 257}
 258
 259MODULE_AUTHOR("Ruurd Reitsma, Krzysztof Helt");
 260MODULE_DESCRIPTION("A driver for the Miro PCM20 radio card.");
 261MODULE_LICENSE("GPL");
 262
 263static void __exit pcm20_cleanup(void)
 264{
 265        struct pcm20 *dev = &pcm20_card;
 266
 267        video_unregister_device(&dev->vdev);
 268        v4l2_device_unregister(&dev->v4l2_dev);
 269}
 270
 271module_init(pcm20_init);
 272module_exit(pcm20_cleanup);
 273