2 files changed, 397 insertions, 0 deletions

diff --git a/drivers/media/radio/radio-si4713.c b/drivers/media/radio/radio-si4713.c
new file mode 100644
index 000000000000..65c14b704586
--- /dev/null
+++ b/drivers/media/radio/radio-si4713.c
@@ -0,0 +1,367 @@
+/*
+ * drivers/media/radio/radio-si4713.c
+ *
+ * Platform Driver for Silicon Labs Si4713 FM Radio Transmitter:
+ *
+ * Copyright (c) 2008 Instituto Nokia de Tecnologia - INdT
+ * Contact: Eduardo Valentin <eduardo.valentin@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/version.h>
+#include <linux/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/videodev2.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-ioctl.h>
+#include <media/radio-si4713.h>
+
+/* module parameters */
+static int radio_nr = -1;       /* radio device minor (-1 ==> auto assign) */
+module_param(radio_nr, int, 0);
+MODULE_PARM_DESC(radio_nr,
+                 "Minor number for radio device (-1 ==> auto assign)");
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Eduardo Valentin <eduardo.valentin@nokia.com>");
+MODULE_DESCRIPTION("Platform driver for Si4713 FM Radio Transmitter");
+MODULE_VERSION("0.0.1");
+
+/* Driver state struct */
+struct radio_si4713_device {
+        struct v4l2_device              v4l2_dev;
+        struct video_device             *radio_dev;
+};
+
+/* radio_si4713_fops - file operations interface */
+static const struct v4l2_file_operations radio_si4713_fops = {
+        .owner          = THIS_MODULE,
+        .ioctl          = video_ioctl2,
+};
+
+/* Video4Linux Interface */
+static int radio_si4713_fill_audout(struct v4l2_audioout *vao)
+{
+        /* TODO: check presence of audio output */
+        strlcpy(vao->name, "FM Modulator Audio Out", 32);
+
+        return 0;
+}
+
+static int radio_si4713_enumaudout(struct file *file, void *priv,
+                                                struct v4l2_audioout *vao)
+{
+        return radio_si4713_fill_audout(vao);
+}
+
+static int radio_si4713_g_audout(struct file *file, void *priv,
+                                        struct v4l2_audioout *vao)
+{
+        int rval = radio_si4713_fill_audout(vao);
+
+        vao->index = 0;
+
+        return rval;
+}
+
+static int radio_si4713_s_audout(struct file *file, void *priv,
+                                        struct v4l2_audioout *vao)
+{
+        return vao->index ? -EINVAL : 0;
+}
+
+/* radio_si4713_querycap - query device capabilities */
+static int radio_si4713_querycap(struct file *file, void *priv,
+                                        struct v4l2_capability *capability)
+{
+        struct radio_si4713_device *rsdev;
+
+        rsdev = video_get_drvdata(video_devdata(file));
+
+        strlcpy(capability->driver, "radio-si4713", sizeof(capability->driver));
+        strlcpy(capability->card, "Silicon Labs Si4713 Modulator",
+                                sizeof(capability->card));
+        capability->capabilities = V4L2_CAP_MODULATOR | V4L2_CAP_RDS_OUTPUT;
+
+        return 0;
+}
+
+/* radio_si4713_queryctrl - enumerate control items */
+static int radio_si4713_queryctrl(struct file *file, void *priv,
+                                                struct v4l2_queryctrl *qc)
+{
+        /* Must be sorted from low to high control ID! */
+        static const u32 user_ctrls[] = {
+                V4L2_CID_USER_CLASS,
+                V4L2_CID_AUDIO_MUTE,
+                0
+        };
+
+        /* Must be sorted from low to high control ID! */
+        static const u32 fmtx_ctrls[] = {
+                V4L2_CID_FM_TX_CLASS,
+                V4L2_CID_RDS_TX_DEVIATION,
+                V4L2_CID_RDS_TX_PI,
+                V4L2_CID_RDS_TX_PTY,
+                V4L2_CID_RDS_TX_PS_NAME,
+                V4L2_CID_RDS_TX_RADIO_TEXT,
+                V4L2_CID_AUDIO_LIMITER_ENABLED,
+                V4L2_CID_AUDIO_LIMITER_RELEASE_TIME,
+                V4L2_CID_AUDIO_LIMITER_DEVIATION,
+                V4L2_CID_AUDIO_COMPRESSION_ENABLED,
+                V4L2_CID_AUDIO_COMPRESSION_GAIN,
+                V4L2_CID_AUDIO_COMPRESSION_THRESHOLD,
+                V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME,
+                V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME,
+                V4L2_CID_PILOT_TONE_ENABLED,
+                V4L2_CID_PILOT_TONE_DEVIATION,
+                V4L2_CID_PILOT_TONE_FREQUENCY,
+                V4L2_CID_TUNE_PREEMPHASIS,
+                V4L2_CID_TUNE_POWER_LEVEL,
+                V4L2_CID_TUNE_ANTENNA_CAPACITOR,
+                0
+        };
+        static const u32 *ctrl_classes[] = {
+                user_ctrls,
+                fmtx_ctrls,
+                NULL
+        };
+        struct radio_si4713_device *rsdev;
+
+        rsdev = video_get_drvdata(video_devdata(file));
+
+        qc->id = v4l2_ctrl_next(ctrl_classes, qc->id);
+        if (qc->id == 0)
+                return -EINVAL;
+
+        if (qc->id == V4L2_CID_USER_CLASS || qc->id == V4L2_CID_FM_TX_CLASS)
+                return v4l2_ctrl_query_fill(qc, 0, 0, 0, 0);
+
+        return v4l2_device_call_until_err(&rsdev->v4l2_dev, 0, core,
+                                                queryctrl, qc);
+}
+
+/*
+ * v4l2 ioctl call backs.
+ * we are just a wrapper for v4l2_sub_devs.
+ */
+static inline struct v4l2_device *get_v4l2_dev(struct file *file)
+{
+        return &((struct radio_si4713_device *)video_drvdata(file))->v4l2_dev;
+}
+
+static int radio_si4713_g_ext_ctrls(struct file *file, void *p,
+                                                struct v4l2_ext_controls *vecs)
+{
+        return v4l2_device_call_until_err(get_v4l2_dev(file), 0, core,
+                                                        g_ext_ctrls, vecs);
+}
+
+static int radio_si4713_s_ext_ctrls(struct file *file, void *p,
+                                                struct v4l2_ext_controls *vecs)
+{
+        return v4l2_device_call_until_err(get_v4l2_dev(file), 0, core,
+                                                        s_ext_ctrls, vecs);
+}
+
+static int radio_si4713_g_ctrl(struct file *file, void *p,
+                                                struct v4l2_control *vc)
+{
+        return v4l2_device_call_until_err(get_v4l2_dev(file), 0, core,
+                                                        g_ctrl, vc);
+}
+
+static int radio_si4713_s_ctrl(struct file *file, void *p,
+                                                struct v4l2_control *vc)
+{
+        return v4l2_device_call_until_err(get_v4l2_dev(file), 0, core,
+                                                        s_ctrl, vc);
+}
+
+static int radio_si4713_g_modulator(struct file *file, void *p,
+                                                struct v4l2_modulator *vm)
+{
+        return v4l2_device_call_until_err(get_v4l2_dev(file), 0, tuner,
+                                                        g_modulator, vm);
+}
+
+static int radio_si4713_s_modulator(struct file *file, void *p,
+                                                struct v4l2_modulator *vm)
+{
+        return v4l2_device_call_until_err(get_v4l2_dev(file), 0, tuner,
+                                                        s_modulator, vm);
+}
+
+static int radio_si4713_g_frequency(struct file *file, void *p,
+                                                struct v4l2_frequency *vf)
+{
+        return v4l2_device_call_until_err(get_v4l2_dev(file), 0, tuner,
+                                                        g_frequency, vf);
+}
+
+static int radio_si4713_s_frequency(struct file *file, void *p,
+                                                struct v4l2_frequency *vf)
+{
+        return v4l2_device_call_until_err(get_v4l2_dev(file), 0, tuner,
+                                                        s_frequency, vf);
+}
+
+static long radio_si4713_default(struct file *file, void *p, int cmd, void *arg)
+{
+        return v4l2_device_call_until_err(get_v4l2_dev(file), 0, core,
+                                                        ioctl, cmd, arg);
+}
+
+static struct v4l2_ioctl_ops radio_si4713_ioctl_ops = {
+        .vidioc_enumaudout      = radio_si4713_enumaudout,
+        .vidioc_g_audout        = radio_si4713_g_audout,
+        .vidioc_s_audout        = radio_si4713_s_audout,
+        .vidioc_querycap        = radio_si4713_querycap,
+        .vidioc_queryctrl       = radio_si4713_queryctrl,
+        .vidioc_g_ext_ctrls     = radio_si4713_g_ext_ctrls,
+        .vidioc_s_ext_ctrls     = radio_si4713_s_ext_ctrls,
+        .vidioc_g_ctrl          = radio_si4713_g_ctrl,
+        .vidioc_s_ctrl          = radio_si4713_s_ctrl,
+        .vidioc_g_modulator     = radio_si4713_g_modulator,
+        .vidioc_s_modulator     = radio_si4713_s_modulator,
+        .vidioc_g_frequency     = radio_si4713_g_frequency,
+        .vidioc_s_frequency     = radio_si4713_s_frequency,
+        .vidioc_default         = radio_si4713_default,
+};
+
+/* radio_si4713_vdev_template - video device interface */
+static struct video_device radio_si4713_vdev_template = {
+        .fops                   = &radio_si4713_fops,
+        .name                   = "radio-si4713",
+        .release                = video_device_release,
+        .ioctl_ops              = &radio_si4713_ioctl_ops,
+};
+
+/* Platform driver interface */
+/* radio_si4713_pdriver_probe - probe for the device */
+static int radio_si4713_pdriver_probe(struct platform_device *pdev)
+{
+        struct radio_si4713_platform_data *pdata = pdev->dev.platform_data;
+        struct radio_si4713_device *rsdev;
+        struct i2c_adapter *adapter;
+        struct v4l2_subdev *sd;
+        int rval = 0;
+
+        if (!pdata) {
+                dev_err(&pdev->dev, "Cannot proceed without platform data.\n");
+                rval = -EINVAL;
+                goto exit;
+        }
+
+        rsdev = kzalloc(sizeof *rsdev, GFP_KERNEL);
+        if (!rsdev) {
+                dev_err(&pdev->dev, "Failed to alloc video device.\n");
+                rval = -ENOMEM;
+                goto exit;
+        }
+
+        rval = v4l2_device_register(&pdev->dev, &rsdev->v4l2_dev);
+        if (rval) {
+                dev_err(&pdev->dev, "Failed to register v4l2 device.\n");
+                goto free_rsdev;
+        }
+
+        adapter = i2c_get_adapter(pdata->i2c_bus);
+        if (!adapter) {
+                dev_err(&pdev->dev, "Cannot get i2c adapter %d\n",
+                                                        pdata->i2c_bus);
+                rval = -ENODEV;
+                goto unregister_v4l2_dev;
+        }
+
+        sd = v4l2_i2c_new_subdev_board(&rsdev->v4l2_dev, adapter, "si4713_i2c",
+                                        pdata->subdev_board_info, NULL);
+        if (!sd) {
+                dev_err(&pdev->dev, "Cannot get v4l2 subdevice\n");
+                rval = -ENODEV;
+                goto unregister_v4l2_dev;
+        }
+
+        rsdev->radio_dev = video_device_alloc();
+        if (!rsdev->radio_dev) {
+                dev_err(&pdev->dev, "Failed to alloc video device.\n");
+                rval = -ENOMEM;
+                goto unregister_v4l2_dev;
+        }
+
+        memcpy(rsdev->radio_dev, &radio_si4713_vdev_template,
+                        sizeof(radio_si4713_vdev_template));
+        video_set_drvdata(rsdev->radio_dev, rsdev);
+        if (video_register_device(rsdev->radio_dev, VFL_TYPE_RADIO, radio_nr)) {
+                dev_err(&pdev->dev, "Could not register video device.\n");
+                rval = -EIO;
+                goto free_vdev;
+        }
+        dev_info(&pdev->dev, "New device successfully probed\n");
+
+        goto exit;
+
+free_vdev:
+        video_device_release(rsdev->radio_dev);
+unregister_v4l2_dev:
+        v4l2_device_unregister(&rsdev->v4l2_dev);
+free_rsdev:
+        kfree(rsdev);
+exit:
+        return rval;
+}
+
+/* radio_si4713_pdriver_remove - remove the device */
+static int __exit radio_si4713_pdriver_remove(struct platform_device *pdev)
+{
+        struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
+        struct radio_si4713_device *rsdev = container_of(v4l2_dev,
+                                                struct radio_si4713_device,
+                                                v4l2_dev);
+
+        video_unregister_device(rsdev->radio_dev);
+        v4l2_device_unregister(&rsdev->v4l2_dev);
+        kfree(rsdev);
+
+        return 0;
+}
+
+static struct platform_driver radio_si4713_pdriver = {
+        .driver         = {
+                .name   = "radio-si4713",
+        },
+        .probe          = radio_si4713_pdriver_probe,
+        .remove         = __exit_p(radio_si4713_pdriver_remove),
+};
+
+/* Module Interface */
+static int __init radio_si4713_module_init(void)
+{
+        return platform_driver_register(&radio_si4713_pdriver);
+}
+
+static void __exit radio_si4713_module_exit(void)
+{
+        platform_driver_unregister(&radio_si4713_pdriver);
+}
+
+module_init(radio_si4713_module_init);
+module_exit(radio_si4713_module_exit);
+
diff --git a/include/media/radio-si4713.h b/include/media/radio-si4713.h
new file mode 100644
index 000000000000..f6aae29c7741
--- /dev/null
+++ b/include/media/radio-si4713.h
@@ -0,0 +1,30 @@
+/*
+ * include/media/radio-si4713.h
+ *
+ * Board related data definitions for Si4713 radio transmitter chip.
+ *
+ * Copyright (c) 2009 Nokia Corporation
+ * Contact: Eduardo Valentin <eduardo.valentin@nokia.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ *
+ */
+
+#ifndef RADIO_SI4713_H
+#define RADIO_SI4713_H
+
+#include <linux/i2c.h>
+
+#define SI4713_NAME "radio-si4713"
+
+/*
+ * Platform dependent definition
+ */
+struct radio_si4713_platform_data {
+        int i2c_bus;
+        struct i2c_board_info *subdev_board_info;
+};
+
+#endif /* ifndef RADIO_SI4713_H*/