Merge remote-tracking branch 'cogent/v2.23.1' into sandbox/kingfisher_v2.23.1.20180427

Signed-off-by: Harunobu Kurokawa <harunobu.kurokawa.dn@renesas.com>

 Conflicts:
	meta-rcar-gen3-adas/conf/layer.conf
	meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/ulcb.cfg
	meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas_4.9.bbappend
	meta-rcar-gen3-adas/recipes-multimedia/pulseaudio/pulseaudio_8.0.bbappend

Change-Id: Ib0345634b8bec6a85357152138355d8f932bafc0

1 files changed, 450 insertions, 0 deletions

diff --git a/meta-rcar-gen3-adas/recipes-kernel/kernel-module-uio-isp/files/uio_isp.c b/meta-rcar-gen3-adas/recipes-kernel/kernel-module-uio-isp/files/uio_isp.c
new file mode 100644
index 0000000..5898b01
--- /dev/null
+++ b/meta-rcar-gen3-adas/recipes-kernel/kernel-module-uio-isp/files/uio_isp.c
@@ -0,0 +1,450 @@
+/**
+ * This driver module supports both the ISP itself and the ISP Wrapper
+ * by providing the user with two separate UIO devices in /dev, one for the
+ * ISP and one for the ISP Wrapper. The struct uio_isp_platform_data contains
+ * the uio_info for the ISP as well as the ISP Wrapper.
+ * The ISP has to be defined in the Device Tree using the following structure
+    isp0: isp@fec00000 {
+        compatible = "renesas,isp-r8a7797";
+        reg = <0 0xfec00000 0 0x20000>, <0 0xfed00000 0 0x10000>;
+        interrupts = <GIC_SPI 26 IRQ_TYPE_LEVEL_HIGH>, <GIC_SPI 25 IRQ_TYPE_LEVEL_HIGH>;
+        clocks = <&cpg CPG_MOD 817>;
+        power-domains = <&sysc R8A7797_PD_ALWAYS_ON>;
+    };
+ * The first reg entry is the base and size of the ISP memory area.
+ * The second reg entry is the base and size of the ISP Wrapper memory area.
+ * The first interrupt entry is for the ISP.
+ * The second interrupt entry is for the ISP Wrapper
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/clk.h>
+#include <linux/dma-mapping.h>
+#include <linux/platform_device.h>
+#include <linux/uio_driver.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/irqdomain.h>
+#include <linux/pm_runtime.h>
+
+#include <linux/of.h>
+#include <linux/of_irq.h>
+
+
+/* ISP internals */
+#define ISP_INTERNAL_REG_SIZE    0X20000
+#define ISP_INT_FRAME_START_MASK    0x84
+#define ISP_INT_FRAME_START_STATUS    0x88
+#define ISP_INT_FRAME_START_CLEAR    0x8c
+#define ISP_INT_FRAME_END_MASK        0x98
+#define ISP_INT_FRAME_END_STATUS    0x9c
+#define ISP_INT_FRAME_END_CLEAR        0xa0
+#define ISP_INT_STATS_MASK        0xb0
+#define ISP_INT_STATS_STATUS        0xb4
+#define ISP_INT_STATS_CLEAR        0xb8
+
+/* ISP Wrapper internals */
+#define ISPVCR                0x00
+#define ISPINT_STATUS            0x40
+#define ISPINT_ENABLE            0x60
+#define ISPERR0_ENABLE            0x64
+
+/* ISP uio driver name */
+#define DRIVER_NAME "uio_isp"
+#define DRIVER_VERSION "0.1"
+
+/* Platform data for ISP and ISP Wrapper */
+struct uio_isp_platform_data
+{
+    struct platform_device    *pdev;
+    struct uio_info        *uio_info[2];    /* [0]: ISP [1]: ISP Wrapper */
+    struct clk        *isp_clock;
+    spinlock_t        isp_lock;
+    spinlock_t        wrapper_lock;
+    unsigned long        isp_flags;
+    unsigned long        wrapper_flags;
+    void __iomem        *base_addr;
+    void __iomem        *wrapper_addr;
+};
+
+/* ISP Wrapper function prototypes */
+static int isp_wrapper_probe(struct platform_device *pdev, struct uio_isp_platform_data * const priv);
+static int isp_wrapper_open(struct uio_info *uio_info, struct inode *inode);
+static int isp_wrapper_close(struct uio_info *uio_info, struct inode *inode);
+static irqreturn_t isp_wrapper_irq_handler(int irq, struct uio_info *uio_info);
+
+/* ISP function prototypes */
+static int isp_probe(struct platform_device *pdev, struct uio_isp_platform_data * const priv);
+static int isp_open(struct uio_info *uio_info, struct inode *inode);
+static int isp_close(struct uio_info *uio_info, struct inode *inode);
+static irqreturn_t isp_irq_handler(int irq, struct uio_info *uio_info);
+
+/* Common functions for ISP and ISP Wrapper */
+static int irq_control(struct uio_info *uio_info, s32 irq_on);
+
+static inline u32 read_reg(void * const base, const u32 offset)
+{
+    return ioread32((u8 *)base + offset);
+}
+
+static inline void write_reg(void * const base, const u32 offset, const u32 val)
+{
+    iowrite32(val, (u8 *)base + offset);
+}
+
+/* Function definitions */
+static int isp_wrapper_probe(struct platform_device *pdev, struct uio_isp_platform_data * const priv)
+{
+    struct uio_info    *uio_info;
+    struct uio_mem *uio_mem;
+    struct resource *res;
+    char *wrapper_name;
+    int err;
+    struct device *dev = &pdev->dev;
+
+    /* Construct the uio_info structure */
+    uio_info = devm_kzalloc(dev, sizeof(*uio_info), GFP_KERNEL);
+    wrapper_name = devm_kmalloc(dev, strlen(pdev->name) + strlen("_wrapper") + 1, GFP_KERNEL);
+    if (!uio_info || !wrapper_name)
+        return -ENOMEM;
+    sprintf(wrapper_name, "%s_wrapper", pdev->name);
+    uio_info->version = DRIVER_VERSION;
+    uio_info->open = isp_wrapper_open;
+    uio_info->release = isp_wrapper_close;
+    uio_info->name = wrapper_name;
+
+    /* Set up memory resource */
+    uio_mem = &uio_info->mem[0];
+    res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+    if (!res) {
+        dev_err(dev, "failed to get ISP Wrapper memory\n");
+        return -EINVAL;
+    }
+    uio_mem->memtype = UIO_MEM_PHYS;
+    uio_mem->addr = res->start;
+    uio_mem->size = resource_size(res);
+    uio_mem->name = res->name;
+    if (!devm_request_mem_region(dev, res->start, resource_size(res), uio_info->name)) {
+        dev_err(dev, "failed to reserve ISP Wrapper memory\n");
+        return -ENOMEM;
+    }
+    priv->wrapper_addr = devm_ioremap_nocache(dev, res->start, resource_size(res));
+    if (!priv->wrapper_addr) {
+        dev_err(dev, "failed to map ISP Wrapper memory\n");
+        return -EIO;
+    }
+
+    /* Set up interrupt */
+    write_reg(priv->wrapper_addr, ISPINT_ENABLE, 0);
+    write_reg(priv->wrapper_addr, ISPERR0_ENABLE, 0);
+    uio_info->irq = irq_of_parse_and_map(pdev->dev.of_node, 1);
+    if (uio_info->irq == -ENXIO) {
+        dev_err(dev, "failed to parse ISP Wrapper interrupt\n");
+        return -EINVAL;
+    }
+    uio_info->handler = isp_wrapper_irq_handler;
+    uio_info->irqcontrol = irq_control;
+
+    /* Register the UIO device */
+    if ((err = uio_register_device(dev, uio_info))) {
+        dev_err(dev, "failed to register UIO device for ISP Wrapper\n");
+        return err;
+    }
+
+    /* Register this uio_info with the platform data */
+    uio_info->priv = priv;
+    priv->uio_info[1] = uio_info;
+    spin_lock_init(&priv->wrapper_lock);
+    priv->wrapper_flags = 1;    /* The ISP Wrapper interrupt is active */
+
+    /* Print some information */
+    dev_dbg(dev, "ISP Wrapper irq %ld\n", uio_info->irq);
+
+    return 0;
+}
+
+static int isp_wrapper_open(struct uio_info *uio_info, struct inode *inode)
+{
+    struct uio_isp_platform_data *priv = uio_info->priv;
+
+    dev_dbg(&priv->pdev->dev, "isp wrapper open\n");
+
+    return 0;
+}
+
+static int isp_wrapper_close(struct uio_info *uio_info, struct inode *inode)
+{
+    struct uio_isp_platform_data *priv = uio_info->priv;
+
+    dev_dbg(&priv->pdev->dev, "isp wrapper close\n");
+
+    return 0;
+}
+
+static irqreturn_t isp_wrapper_irq_handler(int irq, struct uio_info *uio_info)
+{
+    struct uio_isp_platform_data *priv = uio_info->priv;
+    u32 ispint_status = read_reg(priv->wrapper_addr, ISPINT_STATUS);
+
+    /* Mask all interrupts */
+    write_reg(priv->wrapper_addr, ISPINT_ENABLE, 0);
+
+    if (!ispint_status)
+        return IRQ_NONE;
+
+    return IRQ_HANDLED;
+}
+
+static int isp_probe(struct platform_device *pdev, struct uio_isp_platform_data * const priv)
+{
+    struct uio_info    *uio_info;
+    struct uio_mem *uio_mem;
+    struct resource *res;
+    int err;
+    struct device *dev = &pdev->dev;
+
+    /* Construct the uio_info structure */
+    uio_info = devm_kzalloc(dev, sizeof(*uio_info), GFP_KERNEL);
+    if (!uio_info)
+        return -ENOMEM;
+    uio_info->version = DRIVER_VERSION;
+    uio_info->open = isp_open;
+    uio_info->release = isp_close;
+    uio_info->name = pdev->name;
+
+    /* Set up memory resource */
+    uio_mem = &uio_info->mem[0];
+    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+    if (!res) {
+        dev_err(dev, "failed to get ISP memory\n");
+        return -EINVAL;
+    }
+    uio_mem->memtype = UIO_MEM_PHYS;
+    uio_mem->addr = res->start;
+    uio_mem->size = resource_size(res);
+    uio_mem->name = res->name;
+    if (!devm_request_mem_region(dev, res->start, resource_size(res), uio_info->name)) {
+        dev_err(dev, "failed to reserve ISP memory\n");
+        return -ENOMEM;
+    }
+    priv->base_addr = devm_ioremap_nocache(dev, res->start, resource_size(res));
+    if (!priv->base_addr) {
+        dev_err(dev, "failed to map ISP memory\n");
+        return -EIO;
+    }
+
+    /* Set up interrupt */
+    write_reg(priv->base_addr, ISP_INT_FRAME_START_MASK, 0);
+    write_reg(priv->base_addr, ISP_INT_FRAME_END_MASK, 0);
+    write_reg(priv->base_addr, ISP_INT_STATS_MASK, 0);
+    uio_info->irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
+    if (uio_info->irq == -ENXIO) {
+        dev_err(dev, "failed to parse ISP interrupt\n");
+        return -EINVAL;
+    }
+    uio_info->handler = isp_irq_handler;
+    uio_info->irqcontrol = irq_control;
+
+    /* Set up clock */
+    priv->isp_clock = devm_clk_get(dev, NULL);
+    if (IS_ERR(priv->isp_clock)) {
+        dev_err(dev, "failed to get ISP clock info\n");
+        return -ENODEV;
+    }
+
+    /* Register the UIO device */
+    if ((err = uio_register_device(dev, uio_info))) {
+        dev_err(dev, "failed to register UIO device for ISP\n");
+        return err;
+    }
+
+    /* Register the uio_info with the platform data */
+    uio_info->priv = priv;
+    priv->uio_info[0] = uio_info;
+    spin_lock_init(&priv->isp_lock);
+    priv->isp_flags = 1;        /* ISP interrupt is active */
+
+    /* Register the UIO device with the PM framework */
+    pm_runtime_enable(dev);
+
+    /* Enable clocks */
+    if ((err = clk_prepare_enable(priv->isp_clock))) {
+        dev_err(dev, "failed to enable clock\n");
+        return -EBUSY;
+    }
+
+    /* Print some information */
+    dev_dbg(dev, "ISP irq %ld clock %ld Hz\n", uio_info->irq, clk_get_rate(priv->isp_clock));
+
+    return 0;
+}
+
+static int isp_open(struct uio_info *uio_info, __attribute__((unused)) struct inode *inode)
+{
+    struct uio_isp_platform_data *priv = uio_info->priv;
+
+    dev_dbg(&priv->pdev->dev, "isp open\n");
+    /* Wait until the PM has woken up the device */
+    pm_runtime_get_sync(&priv->pdev->dev);
+
+    if (!test_and_set_bit(0, &priv->isp_flags))
+        enable_irq((unsigned int)uio_info->irq);
+
+    return 0;
+}
+
+static int isp_close(struct uio_info *uio_info, __attribute__((unused)) struct inode *inode)
+{
+    struct uio_isp_platform_data *priv = uio_info->priv;
+
+    dev_dbg(&priv->pdev->dev, "isp close\n");
+    /* Tell the PM that the device has become idle */
+    pm_runtime_put_sync(&priv->pdev->dev);
+
+    if (test_and_clear_bit(0, &priv->isp_flags))
+        disable_irq((unsigned int)uio_info->irq);
+
+    return 0;
+}
+
+static irqreturn_t isp_irq_handler(int irq, struct uio_info *uio_info)
+{
+    struct uio_isp_platform_data *priv = uio_info->priv;
+    u32 fstart_status;
+    u32 fend_status;
+    u32 stats_status;
+
+    /* Mask all interrupts, umask by user process */
+    write_reg(priv->base_addr, ISP_INT_FRAME_START_MASK, 0);
+    write_reg(priv->base_addr, ISP_INT_FRAME_END_MASK, 0);
+    write_reg(priv->base_addr, ISP_INT_STATS_MASK, 0);
+
+    fstart_status = read_reg(priv->base_addr, ISP_INT_FRAME_START_STATUS);
+    fend_status = read_reg(priv->base_addr, ISP_INT_FRAME_END_STATUS);
+    stats_status = read_reg(priv->base_addr, ISP_INT_STATS_STATUS);
+
+    if (!(fstart_status | fend_status | stats_status)) {
+        return IRQ_NONE;
+    }
+
+    return IRQ_HANDLED;
+}
+
+static int irq_control(struct uio_info *uio_info, s32 irq_on)
+{
+    struct uio_isp_platform_data *const priv = uio_info->priv;
+    unsigned long flag;
+
+    if (uio_info == priv->uio_info[0]) {
+        dev_dbg(&priv->pdev->dev, "ISP irq_control\n");
+        /* This is the ISP */
+        spin_lock_irqsave(&priv->isp_lock, flag);
+        if (irq_on) {
+            if (!test_and_set_bit(0, &priv->isp_flags))    {
+                enable_irq((unsigned int)uio_info->irq);
+            }
+        }
+        else {
+            if (test_and_clear_bit(0, &priv->isp_flags)) {
+                disable_irq((unsigned int)uio_info->irq);
+            }
+        }
+        spin_unlock_irqrestore(&priv->isp_lock, flag);
+    } else {
+        dev_dbg(&priv->pdev->dev, "ISP Wrapper irq_control\n");
+        /* This is the ISP Wrapper */
+        spin_lock_irqsave(&priv->wrapper_lock, flag);
+        if (irq_on) {
+            if (!test_and_set_bit(0, &priv->wrapper_flags))    {
+                enable_irq((unsigned int)uio_info->irq);
+            }
+        }
+        else {
+            if (test_and_clear_bit(0, &priv->wrapper_flags)) {
+                disable_irq((unsigned int)uio_info->irq);
+            }
+        }
+        spin_unlock_irqrestore(&priv->wrapper_lock, flag);
+    }
+
+    return 0;
+}
+
+static int uio_isp_probe(struct platform_device *pdev)
+{
+    struct uio_isp_platform_data *priv;
+    int err;
+
+    /* Allocate memory for the common housekeeping structure */
+    priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+    if (!priv)
+        return -ENOMEM;
+    priv->pdev = pdev;
+
+    if ((err = isp_wrapper_probe(pdev, priv)))
+        return err;
+    if ((err = isp_probe(pdev, priv)))
+        return err;
+
+    platform_set_drvdata(pdev, priv);
+
+    return 0;
+}
+
+static int uio_isp_remove(struct platform_device *pdev)
+{
+    struct uio_isp_platform_data *priv = platform_get_drvdata(pdev);
+
+    uio_unregister_device(priv->uio_info[0]);
+    uio_unregister_device(priv->uio_info[1]);
+
+    clk_disable_unprepare(priv->isp_clock);
+    pm_runtime_disable(&priv->pdev->dev);
+
+    platform_set_drvdata(pdev, NULL);
+
+    return 0;
+}
+
+/* Power management */
+static int uio_runtime_isp_nop(__attribute__((unused)) struct device *dev)
+{
+    return 0;
+};
+
+static const struct dev_pm_ops uio_dev_pm_isp_ops =
+{
+    .runtime_suspend = &uio_runtime_isp_nop,
+    .runtime_resume = &uio_runtime_isp_nop,
+};
+
+/* Compatible table */
+static const struct of_device_id rcar_isp_dt_ids[] =
+{
+    { .compatible = "renesas,isp-r8a7797", .data = 0 },
+    { .compatible = "renesas,isp-r8a7798", .data = 0 },
+    {},
+};
+MODULE_DEVICE_TABLE(of, rcar_isp_dt_ids);
+
+/* Platform driver structure */
+static struct platform_driver uio_isp_platform_driver =
+{
+    .probe = &uio_isp_probe,
+    .remove = &uio_isp_remove,
+    .driver =
+    {
+        .name = DRIVER_NAME,
+        .owner = THIS_MODULE,
+        .pm = &uio_dev_pm_isp_ops,
+        .of_match_table = of_match_ptr(rcar_isp_dt_ids)
+    }
+};
+module_platform_driver(uio_isp_platform_driver);
+
+MODULE_AUTHOR("Renesas Electronics Corporation");
+MODULE_DESCRIPTION("Userspace I/O driver for ISP");
+MODULE_LICENSE("Dual MIT/GPL");
+MODULE_ALIAS("platform:" DRIVER_NAME);