rpmsg: Introduce Qualcomm SMD backend

This introduces a new rpmsg backend for the Qualcomm SMD system,
allowing communication with various remote processors found in Qualcomm
platforms. The implementation is based on, and intends to replace,
drivers/soc/qcom/smd.c with the necessary adaptions for fitting with the
rpmsg core.

Based on original work by Sricharan R <sricharan@codeaurora.org>

Cc: Sricharan R <sricharan@codeaurora.org>
Signed-off-by: Bjorn Andersson <bjorn.andersson@linaro.org>

3 files changed, 1445 insertions, 0 deletions

diff --git a/drivers/rpmsg/Kconfig b/drivers/rpmsg/Kconfig
index 40614be88c97..9ba5a2e5c930 100644
--- a/drivers/rpmsg/Kconfig
+++ b/drivers/rpmsg/Kconfig
@@ -4,6 +4,16 @@ menu "Rpmsg drivers"
 config RPMSG
         tristate
 
+config RPMSG_QCOM_SMD
+        tristate "Qualcomm Shared Memory Driver (SMD)"
+        depends on QCOM_SMEM
+        depends on !QCOM_SMD
+        select RPMSG
+        help
+          Say y here to enable support for the Qualcomm Shared Memory Driver
+          providing communication channels to remote processors in Qualcomm
+          platforms.
+
 config RPMSG_VIRTIO
         tristate
         select RPMSG
diff --git a/drivers/rpmsg/Makefile b/drivers/rpmsg/Makefile
index c48ea55ad380..ae9c9132cf76 100644
--- a/drivers/rpmsg/Makefile
+++ b/drivers/rpmsg/Makefile
@@ -1,2 +1,3 @@
 obj-$(CONFIG_RPMSG)             += rpmsg_core.o
+obj-$(CONFIG_RPMSG_QCOM_SMD)    += qcom_smd.o
 obj-$(CONFIG_RPMSG_VIRTIO)      += virtio_rpmsg_bus.o
diff --git a/drivers/rpmsg/qcom_smd.c b/drivers/rpmsg/qcom_smd.c
new file mode 100644
index 000000000000..06fef2b4c814
--- /dev/null
+++ b/drivers/rpmsg/qcom_smd.c
@@ -0,0 +1,1434 @@
+/*
+ * Copyright (c) 2015, Sony Mobile Communications AB.
+ * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only 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.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/mfd/syscon.h>
+#include <linux/module.h>
+#include <linux/of_irq.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/soc/qcom/smem.h>
+#include <linux/wait.h>
+#include <linux/rpmsg.h>
+
+#include "rpmsg_internal.h"
+
+/*
+ * The Qualcomm Shared Memory communication solution provides point-to-point
+ * channels for clients to send and receive streaming or packet based data.
+ *
+ * Each channel consists of a control item (channel info) and a ring buffer
+ * pair. The channel info carry information related to channel state, flow
+ * control and the offsets within the ring buffer.
+ *
+ * All allocated channels are listed in an allocation table, identifying the
+ * pair of items by name, type and remote processor.
+ *
+ * Upon creating a new channel the remote processor allocates channel info and
+ * ring buffer items from the smem heap and populate the allocation table. An
+ * interrupt is sent to the other end of the channel and a scan for new
+ * channels should be done. A channel never goes away, it will only change
+ * state.
+ *
+ * The remote processor signals it intent for bring up the communication
+ * channel by setting the state of its end of the channel to "opening" and
+ * sends out an interrupt. We detect this change and register a smd device to
+ * consume the channel. Upon finding a consumer we finish the handshake and the
+ * channel is up.
+ *
+ * Upon closing a channel, the remote processor will update the state of its
+ * end of the channel and signal us, we will then unregister any attached
+ * device and close our end of the channel.
+ *
+ * Devices attached to a channel can use the qcom_smd_send function to push
+ * data to the channel, this is done by copying the data into the tx ring
+ * buffer, updating the pointers in the channel info and signaling the remote
+ * processor.
+ *
+ * The remote processor does the equivalent when it transfer data and upon
+ * receiving the interrupt we check the channel info for new data and delivers
+ * this to the attached device. If the device is not ready to receive the data
+ * we leave it in the ring buffer for now.
+ */
+
+struct smd_channel_info;
+struct smd_channel_info_pair;
+struct smd_channel_info_word;
+struct smd_channel_info_word_pair;
+
+static const struct rpmsg_endpoint_ops qcom_smd_endpoint_ops;
+
+#define SMD_ALLOC_TBL_COUNT     2
+#define SMD_ALLOC_TBL_SIZE      64
+
+/*
+ * This lists the various smem heap items relevant for the allocation table and
+ * smd channel entries.
+ */
+static const struct {
+        unsigned alloc_tbl_id;
+        unsigned info_base_id;
+        unsigned fifo_base_id;
+} smem_items[SMD_ALLOC_TBL_COUNT] = {
+        {
+                .alloc_tbl_id = 13,
+                .info_base_id = 14,
+                .fifo_base_id = 338
+        },
+        {
+                .alloc_tbl_id = 266,
+                .info_base_id = 138,
+                .fifo_base_id = 202,
+        },
+};
+
+/**
+ * struct qcom_smd_edge - representing a remote processor
+ * @of_node:            of_node handle for information related to this edge
+ * @edge_id:            identifier of this edge
+ * @remote_pid:         identifier of remote processor
+ * @irq:                interrupt for signals on this edge
+ * @ipc_regmap:         regmap handle holding the outgoing ipc register
+ * @ipc_offset:         offset within @ipc_regmap of the register for ipc
+ * @ipc_bit:            bit in the register at @ipc_offset of @ipc_regmap
+ * @channels:           list of all channels detected on this edge
+ * @channels_lock:      guard for modifications of @channels
+ * @allocated:          array of bitmaps representing already allocated channels
+ * @smem_available:     last available amount of smem triggering a channel scan
+ * @scan_work:          work item for discovering new channels
+ * @state_work:         work item for edge state changes
+ */
+struct qcom_smd_edge {
+        struct device dev;
+
+        struct device_node *of_node;
+        unsigned edge_id;
+        unsigned remote_pid;
+
+        int irq;
+
+        struct regmap *ipc_regmap;
+        int ipc_offset;
+        int ipc_bit;
+
+        struct list_head channels;
+        spinlock_t channels_lock;
+
+        DECLARE_BITMAP(allocated[SMD_ALLOC_TBL_COUNT], SMD_ALLOC_TBL_SIZE);
+
+        unsigned smem_available;
+
+        wait_queue_head_t new_channel_event;
+
+        struct work_struct scan_work;
+        struct work_struct state_work;
+};
+
+/*
+ * SMD channel states.
+ */
+enum smd_channel_state {
+        SMD_CHANNEL_CLOSED,
+        SMD_CHANNEL_OPENING,
+        SMD_CHANNEL_OPENED,
+        SMD_CHANNEL_FLUSHING,
+        SMD_CHANNEL_CLOSING,
+        SMD_CHANNEL_RESET,
+        SMD_CHANNEL_RESET_OPENING
+};
+
+struct qcom_smd_device {
+        struct rpmsg_device rpdev;
+
+        struct qcom_smd_edge *edge;
+};
+
+struct qcom_smd_endpoint {
+        struct rpmsg_endpoint ept;
+
+        struct qcom_smd_channel *qsch;
+};
+
+#define to_smd_device(_rpdev)   container_of(_rpdev, struct qcom_smd_device, rpdev)
+#define to_smd_edge(d)          container_of(d, struct qcom_smd_edge, dev)
+#define to_smd_endpoint(ept)    container_of(ept, struct qcom_smd_endpoint, ept)
+
+/**
+ * struct qcom_smd_channel - smd channel struct
+ * @edge:               qcom_smd_edge this channel is living on
+ * @qsdev:              reference to a associated smd client device
+ * @name:               name of the channel
+ * @state:              local state of the channel
+ * @remote_state:       remote state of the channel
+ * @info:               byte aligned outgoing/incoming channel info
+ * @info_word:          word aligned outgoing/incoming channel info
+ * @tx_lock:            lock to make writes to the channel mutually exclusive
+ * @fblockread_event:   wakeup event tied to tx fBLOCKREADINTR