4 files changed, 449 insertions, 0 deletions

diff --git a/drivers/media/radio/Kconfig b/drivers/media/radio/Kconfig
index 48747df59453..e291e0e2669f 100644
--- a/drivers/media/radio/Kconfig
+++ b/drivers/media/radio/Kconfig
@@ -177,6 +177,10 @@ menuconfig V4L_RADIO_ISA_DRIVERS
 
 if V4L_RADIO_ISA_DRIVERS
 
+config RADIO_ISA
+        depends on ISA
+        tristate
+
 config RADIO_CADET
         tristate "ADS Cadet AM/FM Tuner"
         depends on ISA && VIDEO_V4L2
diff --git a/drivers/media/radio/Makefile b/drivers/media/radio/Makefile
index aec5f6fa592f..ca8c7d134b95 100644
--- a/drivers/media/radio/Makefile
+++ b/drivers/media/radio/Makefile
@@ -2,6 +2,7 @@
 # Makefile for the kernel character device drivers.
 #
 
+obj-$(CONFIG_RADIO_ISA) += radio-isa.o
 obj-$(CONFIG_RADIO_AZTECH) += radio-aztech.o
 obj-$(CONFIG_RADIO_RTRACK2) += radio-rtrack2.o
 obj-$(CONFIG_RADIO_SF16FMI) += radio-sf16fmi.o
diff --git a/drivers/media/radio/radio-isa.c b/drivers/media/radio/radio-isa.c
new file mode 100644
index 000000000000..02bcead8b087
--- /dev/null
+++ b/drivers/media/radio/radio-isa.c
@@ -0,0 +1,339 @@
+/*
+ * Framework for ISA radio drivers.
+ * This takes care of all the V4L2 scaffolding, allowing the ISA drivers
+ * to concentrate on the actual hardware operation.
+ *
+ * Copyright (C) 2012 Hans Verkuil <hans.verkuil@cisco.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/ioport.h>
+#include <linux/delay.h>
+#include <linux/videodev2.h>
+#include <linux/io.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-ioctl.h>
+#include <media/v4l2-fh.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-event.h>
+
+#include "radio-isa.h"
+
+MODULE_AUTHOR("Hans Verkuil");
+MODULE_DESCRIPTION("A framework for ISA radio drivers.");
+MODULE_LICENSE("GPL");
+
+#define FREQ_LOW  (87U * 16000U)
+#define FREQ_HIGH (108U * 16000U)
+
+static int radio_isa_querycap(struct file *file, void  *priv,
+                                        struct v4l2_capability *v)
+{
+        struct radio_isa_card *isa = video_drvdata(file);
+
+        strlcpy(v->driver, isa->drv->driver.driver.name, sizeof(v->driver));
+        strlcpy(v->card, isa->drv->card, sizeof(v->card));
+        snprintf(v->bus_info, sizeof(v->bus_info), "ISA:%s", isa->v4l2_dev.name);
+
+        v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
+        v->device_caps = v->capabilities | V4L2_CAP_DEVICE_CAPS;
+        return 0;
+}
+
+static int radio_isa_g_tuner(struct file *file, void *priv,
+                                struct v4l2_tuner *v)
+{
+        struct radio_isa_card *isa = video_drvdata(file);
+        const struct radio_isa_ops *ops = isa->drv->ops;
+
+        if (v->index > 0)
+                return -EINVAL;
+
+        strlcpy(v->name, "FM", sizeof(v->name));
+        v->type = V4L2_TUNER_RADIO;
+        v->rangelow = FREQ_LOW;
+        v->rangehigh = FREQ_HIGH;
+        v->capability = V4L2_TUNER_CAP_LOW;
+        if (isa->drv->has_stereo)
+                v->capability |= V4L2_TUNER_CAP_STEREO;
+
+        if (ops->g_rxsubchans)
+                v->rxsubchans = ops->g_rxsubchans(isa);
+        else
+                v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
+        v->audmode = isa->stereo ? V4L2_TUNER_MODE_STEREO : V4L2_TUNER_MODE_MONO;
+        if (ops->g_signal)
+                v->signal = ops->g_signal(isa);
+        else
+                v->signal = (v->rxsubchans & V4L2_TUNER_SUB_STEREO) ?
+                                                                0xffff : 0;
+        return 0;
+}
+
+static int radio_isa_s_tuner(struct file *file, void *priv,
+                                struct v4l2_tuner *v)
+{
+        struct radio_isa_card *isa = video_drvdata(file);
+        const struct radio_isa_ops *ops = isa->drv->ops;
+
+        if (v->index)
+                return -EINVAL;
+        if (ops->s_stereo) {
+                isa->stereo = (v->audmode == V4L2_TUNER_MODE_STEREO);
+                return ops->s_stereo(isa, isa->stereo);
+        }
+        return 0;
+}
+
+static int radio_isa_s_frequency(struct file *file, void *priv,
+                                struct v4l2_frequency *f)
+{
+        struct radio_isa_card *isa = video_drvdata(file);
+        int res;
+
+        if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
+                return -EINVAL;
+        f->frequency = clamp(f->frequency, FREQ_LOW, FREQ_HIGH);
+        res = isa->drv->ops->s_frequency(isa, f->frequency);
+        if (res == 0)
+                isa->freq = f->frequency;
+        return res;
+}
+
+static int radio_isa_g_frequency(struct file *file, void *priv,
+                                struct v4l2_frequency *f)
+{
+        struct radio_isa_card *isa = video_drvdata(file);
+
+        if (f->tuner != 0)
+                return -EINVAL;
+        f->type = V4L2_TUNER_RADIO;
+        f->frequency = isa->freq;
+        return 0;
+}
+
+static int radio_isa_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+        struct radio_isa_card *isa =
+                container_of(ctrl->handler, struct radio_isa_card, hdl);
+
+        switch (ctrl->id) {
+        case V4L2_CID_AUDIO_MUTE:
+                return isa->drv->ops->s_mute_volume(isa, ctrl->val,
+                                isa->volume ? isa->volume->val : 0);
+        }
+        return -EINVAL;
+}
+
+static int radio_isa_log_status(struct file *file, void *priv)
+{
+        struct radio_isa_card *isa = video_drvdata(file);
+
+        v4l2_info(&isa->v4l2_dev, "I/O Port = 0x%03x\n", isa->io);
+        v4l2_ctrl_handler_log_status(&isa->hdl, isa->v4l2_dev.name);
+        return 0;
+}
+
+static int radio_isa_subscribe_event(struct v4l2_fh *fh,
+                                struct v4l2_event_subscription *sub)
+{
+        if (sub->type == V4L2_EVENT_CTRL)
+                return v4l2_event_subscribe(fh, sub, 0);
+        return -EINVAL;
+}
+
+static const struct v4l2_ctrl_ops radio_isa_ctrl_ops = {
+        .s_ctrl = radio_isa_s_ctrl,
+};
+
+static const struct v4l2_file_operations radio_isa_fops = {
+        .owner          = THIS_MODULE,
+        .open           = v4l2_fh_open,
+        .release        = v4l2_fh_release,
+        .poll           = v4l2_ctrl_poll,
+        .unlocked_ioctl = video_ioctl2,
+};
+
+static const struct v4l2_ioctl_ops radio_isa_ioctl_ops = {
+        .vidioc_querycap    = radio_isa_querycap,
+        .vidioc_g_tuner     = radio_isa_g_tuner,
+        .vidioc_s_tuner     = radio_isa_s_tuner,
+        .vidioc_g_frequency = radio_isa_g_frequency,
+        .vidioc_s_frequency = radio_isa_s_frequency,
+        .vidioc_log_status  = radio_isa_log_status,
+        .vidioc_subscribe_event   = radio_isa_subscribe_event,
+        .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
+};
+
+int radio_isa_match(struct device *pdev, unsigned int dev)
+{
+        struct radio_isa_driver *drv = pdev->platform_data;
+
+        return drv->probe || drv->io_params[dev] >= 0;
+}
+EXPORT_SYMBOL_GPL(radio_isa_match);
+
+static bool radio_isa_valid_io(const struct radio_isa_driver *drv, int io)
+{
+        int i;
+
+        for (i = 0; i < drv->num_of_io_ports; i++)
+                if (drv->io_ports[i] == io)
+                        return true;
+        return false;
+}
+
+int radio_isa_probe(struct device *pdev, unsigned int dev)
+{
+        struct radio_isa_driver *drv = pdev->platform_data;
+        const struct radio_isa_ops *ops = drv->ops;
+        struct v4l2_device *v4l2_dev;
+        struct radio_isa_card *isa;
+        int res;
+
+        isa = drv->ops->alloc();
+        if (isa == NULL)
+                return -ENOMEM;
+        dev_set_drvdata(pdev, isa);
+        isa->drv = drv;
+        isa->io = drv->io_params[dev];
+        v4l2_dev = &isa->v4l2_dev;
+        strlcpy(v4l2_dev->name, dev_name(pdev), sizeof(v4l2_dev->name));
+
+        if (drv->probe && ops->probe) {
+                int i;
+
+                for (i = 0; i < drv->num_of_io_ports; ++i) {
+                        int io = drv->io_ports[i];
+
+                        if (request_region(io, drv->region_size, v4l2_dev->name)) {
+                                bool found = ops->probe(isa, io);
+
+                                release_region(io, drv->region_size);
+                                if (found) {
+                                        isa->io = io;
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        if (!radio_isa_valid_io(drv, isa->io)) {
+                int i;
+
+                if (isa->io < 0)
+                        return -ENODEV;
+                v4l2_err(v4l2_dev, "you must set an I/O address with io=0x%03x",
+                                drv->io_ports[0]);
+                for (i = 1; i < drv->num_of_io_ports; i++)
+                        printk(KERN_CONT "/0x%03x", drv->io_ports[i]);
+                printk(KERN_CONT ".\n");
+                kfree(isa);
+                return -EINVAL;
+        }
+
+        if (!request_region(isa->io, drv->region_size, v4l2_dev->name)) {
+                v4l2_err(v4l2_dev, "port 0x%x already in use\n", isa->io);
+                kfree(isa);
+                return -EBUSY;
+        }
+
+        res = v4l2_device_register(pdev, v4l2_dev);
+        if (res < 0) {
+                v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
+                goto err_dev_reg;
+        }
+
+        v4l2_ctrl_handler_init(&isa->hdl, 1);
+        isa->mute = v4l2_ctrl_new_std(&isa->hdl, &radio_isa_ctrl_ops,
+                                V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
+        if (drv->max_volume)
+                isa->volume = v4l2_ctrl_new_std(&isa->hdl, &radio_isa_ctrl_ops,
+                        V4L2_CID_AUDIO_VOLUME, 0, drv->max_volume, 1,
+                        drv->max_volume);
+        v4l2_dev->ctrl_handler = &isa->hdl;
+        if (isa->hdl.error) {
+                res = isa->hdl.error;
+                v4l2_err(v4l2_dev, "Could not register controls\n");
+                goto err_hdl;
+        }
+        if (drv->max_volume)
+                v4l2_ctrl_cluster(2, &isa->mute);
+        v4l2_dev->ctrl_handler = &isa->hdl;
+
+        mutex_init(&isa->lock);
+        isa->vdev.lock = &isa->lock;
+        strlcpy(isa->vdev.name, v4l2_dev->name, sizeof(isa->vdev.name));
+        isa->vdev.v4l2_dev = v4l2_dev;
+        isa->vdev.fops = &radio_isa_fops;
+        isa->vdev.ioctl_ops = &radio_isa_ioctl_ops;
+        isa->vdev.release = video_device_release_empty;
+        set_bit(V4L2_FL_USE_FH_PRIO, &isa->vdev.flags);
+        video_set_drvdata(&isa->vdev, isa);
+        isa->freq = FREQ_LOW;
+        isa->stereo = drv->has_stereo;
+
+        if (ops->init)
+                res = ops->init(isa);
+        if (!res)
+                res = v4l2_ctrl_handler_setup(&isa->hdl);
+        if (!res)
+                res = ops->s_frequency(isa, isa->freq);
+        if (!res && ops->s_stereo)
+                res = ops->s_stereo(isa, isa->stereo);
+        if (res < 0) {
+                v4l2_err(v4l2_dev, "Could not setup card\n");
+                goto err_node_reg;
+        }
+        res = video_register_device(&isa->vdev, VFL_TYPE_RADIO,
+                                        drv->radio_nr_params[dev]);
+        if (res < 0) {
+                v4l2_err(v4l2_dev, "Could not register device node\n");
+                goto err_node_reg;
+        }
+
+        v4l2_info(v4l2_dev, "Initialized radio card %s on port 0x%03x\n",
+                        drv->card, isa->io);
+        return 0;
+
+err_node_reg:
+        v4l2_ctrl_handler_free(&isa->hdl);
+err_hdl:
+        v4l2_device_unregister(&isa->v4l2_dev);
+err_dev_reg:
+        release_region(isa->io, drv->region_size);
+        kfree(isa);
+        return res;
+}
+EXPORT_SYMBOL_GPL(radio_isa_probe);
+
+int radio_isa_remove(struct device *pdev, unsigned int dev)
+{
+        struct radio_isa_card *isa = dev_get_drvdata(pdev);
+        const struct radio_isa_ops *ops = isa->drv->ops;
+
+        ops->s_mute_volume(isa, true, isa->volume ? isa->volume->cur.val : 0);
+        video_unregister_device(&isa->vdev);
+        v4l2_ctrl_handler_free(&isa->hdl);
+        v4l2_device_unregister(&isa->v4l2_dev);
+        release_region(isa->io, isa->drv->region_size);
+        v4l2_info(&isa->v4l2_dev, "Removed radio card %s\n", isa->drv->card);
+        kfree(isa);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(radio_isa_remove);
diff --git a/drivers/media/radio/radio-isa.h b/drivers/media/radio/radio-isa.h
new file mode 100644
index 000000000000..8a0ea84d86de
--- /dev/null
+++ b/drivers/media/radio/radio-isa.h
@@ -0,0 +1,105 @@
+/*
+ * Framework for ISA radio drivers.
+ * This takes care of all the V4L2 scaffolding, allowing the ISA drivers
+ * to concentrate on the actual hardware operation.
+ *
+ * Copyright (C) 2012 Hans Verkuil <hans.verkuil@cisco.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#ifndef _RADIO_ISA_H_
+#define _RADIO_ISA_H_
+
+#include <linux/isa.h>
+#include <linux/videodev2.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-ctrls.h>
+
+struct radio_isa_driver;
+struct radio_isa_ops;
+
+/* Core structure for radio ISA cards */
+struct radio_isa_card {
+        const struct radio_isa_driver *drv;
+        struct v4l2_device v4l2_dev;
+        struct v4l2_ctrl_handler hdl;
+        struct video_device vdev;
+        struct mutex lock;
+        const struct radio_isa_ops *ops;
+        struct {        /* mute/volume cluster */
+                struct v4l2_ctrl *mute;
+                struct v4l2_ctrl *volume;
+        };
+        /* I/O port */
+        int io;
+
+        /* Card is in stereo audio mode */
+        bool stereo;
+        /* Current frequency */
+        u32 freq;
+};
+
+struct radio_isa_ops {
+        /* Allocate and initialize a radio_isa_card struct */
+        struct radio_isa_card *(*alloc)(void);
+        /* Probe whether a card is present at the given port */
+        bool (*probe)(struct radio_isa_card *isa, int io);
+        /* Special card initialization can be done here, this is called after
+         * the standard controls are registered, but before they are setup,
+         * thus allowing drivers to add their own controls here. */
+        int (*init)(struct radio_isa_card *isa);
+        /* Set mute and volume. */
+        int (*s_mute_volume)(struct radio_isa_card *isa, bool mute, int volume);
+        /* Set frequency */
+        int (*s_frequency)(struct radio_isa_card *isa, u32 freq);
+        /* Set stereo/mono audio mode */
+        int (*s_stereo)(struct radio_isa_card *isa, bool stereo);
+        /* Get rxsubchans value for VIDIOC_G_TUNER */
+        u32 (*g_rxsubchans)(struct radio_isa_card *isa);
+        /* Get the signal strength for VIDIOC_G_TUNER */
+        u32 (*g_signal)(struct radio_isa_card *isa);
+};
+
+/* Top level structure needed to instantiate the cards */
+struct radio_isa_driver {
+        struct isa_driver driver;
+        const struct radio_isa_ops *ops;
+        /* The module_param_array with the specified I/O ports */
+        int *io_params;
+        /* The module_param_array with the radio_nr values */
+        int *radio_nr_params;
+        /* Whether we should probe for possible cards */
+        bool probe;
+        /* The list of possible I/O ports */
+        const int *io_ports;
+        /* The size of that list */
+        int num_of_io_ports;
+        /* The region size to request */
+        unsigned region_size;
+        /* The name of the card */
+        const char *card;
+        /* Card can capture stereo audio */
+        bool has_stereo;
+        /* The maximum volume for the volume control. If 0, then there
+           is no volume control possible. */
+        int max_volume;
+};
+
+int radio_isa_match(struct device *pdev, unsigned int dev);
+int radio_isa_probe(struct device *pdev, unsigned int dev);
+int radio_isa_remove(struct device *pdev, unsigned int dev);
+
+#endif