soc: qcom: Introduce WCNSS_CTRL SMD client

The WCNSS_CTRL SMD client is used for among other things upload nv
firmware to a newly booted WCNSS chip.

Signed-off-by: Bjorn Andersson <bjorn.andersson@sonymobile.com>
Signed-off-by: Andy Gross <agross@codeaurora.org>

3 files changed, 280 insertions, 0 deletions

diff --git a/drivers/soc/qcom/Kconfig b/drivers/soc/qcom/Kconfig
index 4c98ffe968c7..461b387d03cc 100644
--- a/drivers/soc/qcom/Kconfig
+++ b/drivers/soc/qcom/Kconfig
@@ -69,3 +69,10 @@ config QCOM_SMSM
         help
           Say yes here to support the Qualcomm Shared Memory State Machine.
           The state machine is represented by bits in shared memory.
+
+config QCOM_WCNSS_CTRL
+        tristate "Qualcomm WCNSS control driver"
+        depends on QCOM_SMD
+        help
+          Client driver for the WCNSS_CTRL SMD channel, used to download nv
+          firmware to a newly booted WCNSS chip.
diff --git a/drivers/soc/qcom/Makefile b/drivers/soc/qcom/Makefile
index 69886e0f7ef8..fdd664edf0bd 100644
--- a/drivers/soc/qcom/Makefile
+++ b/drivers/soc/qcom/Makefile
@@ -6,3 +6,4 @@ obj-$(CONFIG_QCOM_SMEM) +=	smem.o
 obj-$(CONFIG_QCOM_SMEM_STATE) += smem_state.o
 obj-$(CONFIG_QCOM_SMP2P)        += smp2p.o
 obj-$(CONFIG_QCOM_SMSM) += smsm.o
+obj-$(CONFIG_QCOM_WCNSS_CTRL) += wcnss_ctrl.o
diff --git a/drivers/soc/qcom/wcnss_ctrl.c b/drivers/soc/qcom/wcnss_ctrl.c
new file mode 100644
index 000000000000..7a986f881d5c
--- /dev/null
+++ b/drivers/soc/qcom/wcnss_ctrl.c
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) 2015, Sony Mobile Communications Inc.
+ *
+ * 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/firmware.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/soc/qcom/smd.h>
+
+#define WCNSS_REQUEST_TIMEOUT   (5 * HZ)
+
+#define NV_FRAGMENT_SIZE        3072
+#define NVBIN_FILE              "wlan/prima/WCNSS_qcom_wlan_nv.bin"
+
+/**
+ * struct wcnss_ctrl - driver context
+ * @dev:        device handle
+ * @channel:    SMD channel handle
+ * @ack:        completion for outstanding requests
+ * @ack_status: status of the outstanding request
+ * @download_nv_work: worker for uploading nv binary
+ */
+struct wcnss_ctrl {
+        struct device *dev;
+        struct qcom_smd_channel *channel;
+
+        struct completion ack;
+        int ack_status;
+
+        struct work_struct download_nv_work;
+};
+
+/* message types */
+enum {
+        WCNSS_VERSION_REQ = 0x01000000,
+        WCNSS_VERSION_RESP,
+        WCNSS_DOWNLOAD_NV_REQ,
+        WCNSS_DOWNLOAD_NV_RESP,
+        WCNSS_UPLOAD_CAL_REQ,
+        WCNSS_UPLOAD_CAL_RESP,
+        WCNSS_DOWNLOAD_CAL_REQ,
+        WCNSS_DOWNLOAD_CAL_RESP,
+};
+
+/**
+ * struct wcnss_msg_hdr - common packet header for requests and responses
+ * @type:       packet message type
+ * @len:        total length of the packet, including this header
+ */
+struct wcnss_msg_hdr {
+        u32 type;
+        u32 len;
+} __packed;
+
+/**
+ * struct wcnss_version_resp - version request response
+ * @hdr:        common packet wcnss_msg_hdr header
+ */
+struct wcnss_version_resp {
+        struct wcnss_msg_hdr hdr;
+        u8 major;
+        u8 minor;
+        u8 version;
+        u8 revision;
+} __packed;
+
+/**
+ * struct wcnss_download_nv_req - firmware fragment request
+ * @hdr:        common packet wcnss_msg_hdr header
+ * @seq:        sequence number of this fragment
+ * @last:       boolean indicator of this being the last fragment of the binary
+ * @frag_size:  length of this fragment
+ * @fragment:   fragment data
+ */
+struct wcnss_download_nv_req {
+        struct wcnss_msg_hdr hdr;
+        u16 seq;
+        u16 last;
+        u32 frag_size;
+        u8 fragment[];
+} __packed;
+
+/**
+ * struct wcnss_download_nv_resp - firmware download response
+ * @hdr:        common packet wcnss_msg_hdr header
+ * @status:     boolean to indicate success of the download
+ */
+struct wcnss_download_nv_resp {
+        struct wcnss_msg_hdr hdr;
+        u8 status;
+} __packed;
+
+/**
+ * wcnss_ctrl_smd_callback() - handler from SMD responses
+ * @qsdev:      smd device handle
+ * @data:       pointer to the incoming data packet
+ * @count:      size of the incoming data packet
+ *
+ * Handles any incoming packets from the remote WCNSS_CTRL service.
+ */
+static int wcnss_ctrl_smd_callback(struct qcom_smd_device *qsdev,
+                                   const void *data,
+                                   size_t count)
+{
+        struct wcnss_ctrl *wcnss = dev_get_drvdata(&qsdev->dev);
+        const struct wcnss_download_nv_resp *nvresp;
+        const struct wcnss_version_resp *version;
+        const struct wcnss_msg_hdr *hdr = data;
+
+        switch (hdr->type) {
+        case WCNSS_VERSION_RESP:
+                if (count != sizeof(*version)) {
+                        dev_err(wcnss->dev,
+                                "invalid size of version response\n");
+                        break;
+                }
+
+                version = data;
+                dev_info(wcnss->dev, "WCNSS Version %d.%d %d.%d\n",
+                         version->major, version->minor,
+                         version->version, version->revision);
+
+                schedule_work(&wcnss->download_nv_work);
+                break;
+        case WCNSS_DOWNLOAD_NV_RESP:
+                if (count != sizeof(*nvresp)) {
+                        dev_err(wcnss->dev,
+                                "invalid size of download response\n");
+                        break;
+                }
+
+                nvresp = data;
+                wcnss->ack_status = nvresp->status;
+                complete(&wcnss->ack);
+                break;
+        default:
+                dev_info(wcnss->dev, "unknown message type %d\n", hdr->type);
+                break;
+        }
+
+        return 0;
+}
+
+/**
+ * wcnss_request_version() - send a version request to WCNSS
+ * @wcnss:      wcnss ctrl driver context
+ */
+static int wcnss_request_version(struct wcnss_ctrl *wcnss)
+{
+        struct wcnss_msg_hdr msg;
+
+        msg.type = WCNSS_VERSION_REQ;
+        msg.len = sizeof(msg);
+
+        return qcom_smd_send(wcnss->channel, &msg, sizeof(msg));
+}
+
+/**
+ * wcnss_download_nv() - send nv binary to WCNSS
+ * @work:       work struct to acquire wcnss context
+ */
+static void wcnss_download_nv(struct work_struct *work)
+{
+        struct wcnss_ctrl *wcnss = container_of(work, struct wcnss_ctrl, download_nv_work);
+        struct wcnss_download_nv_req *req;
+        const struct firmware *fw;
+        const void *data;
+        ssize_t left;
+        int ret;
+
+        req = kzalloc(sizeof(*req) + NV_FRAGMENT_SIZE, GFP_KERNEL);
+        if (!req)
+                return;
+
+        ret = request_firmware(&fw, NVBIN_FILE, wcnss->dev);
+        if (ret) {
+                dev_err(wcnss->dev, "Failed to load nv file %s: %d\n",
+                        NVBIN_FILE, ret);
+                goto free_req;
+        }
+
+        data = fw->data;
+        left = fw->size;
+
+        req->hdr.type = WCNSS_DOWNLOAD_NV_REQ;
+        req->hdr.len = sizeof(*req) + NV_FRAGMENT_SIZE;
+
+        req->last = 0;
+        req->frag_size = NV_FRAGMENT_SIZE;
+
+        req->seq = 0;
+        do {
+                if (left <= NV_FRAGMENT_SIZE) {
+                        req->last = 1;
+                        req->frag_size = left;
+                        req->hdr.len = sizeof(*req) + left;
+                }
+
+                memcpy(req->fragment, data, req->frag_size);
+
+                ret = qcom_smd_send(wcnss->channel, req, req->hdr.len);
+                if (ret) {
+                        dev_err(wcnss->dev, "failed to send smd packet\n");
+                        goto release_fw;
+                }
+
+                /* Increment for next fragment */
+                req->seq++;
+
+                data += req->hdr.len;
+                left -= NV_FRAGMENT_SIZE;
+        } while (left > 0);
+
+        ret = wait_for_completion_timeout(&wcnss->ack, WCNSS_REQUEST_TIMEOUT);
+        if (!ret)
+                dev_err(wcnss->dev, "timeout waiting for nv upload ack\n");
+        else if (wcnss->ack_status != 1)
+                dev_err(wcnss->dev, "nv upload response failed err: %d\n",
+                        wcnss->ack_status);
+
+release_fw:
+        release_firmware(fw);
+free_req:
+        kfree(req);
+}
+
+static int wcnss_ctrl_probe(struct qcom_smd_device *sdev)
+{
+        struct wcnss_ctrl *wcnss;
+
+        wcnss = devm_kzalloc(&sdev->dev, sizeof(*wcnss), GFP_KERNEL);
+        if (!wcnss)
+                return -ENOMEM;
+
+        wcnss->dev = &sdev->dev;
+        wcnss->channel = sdev->channel;
+
+        init_completion(&wcnss->ack);
+        INIT_WORK(&wcnss->download_nv_work, wcnss_download_nv);
+
+        dev_set_drvdata(&sdev->dev, wcnss);
+
+        return wcnss_request_version(wcnss);
+}
+
+static const struct qcom_smd_id wcnss_ctrl_smd_match[] = {
+        { .name = "WCNSS_CTRL" },
+        {}
+};
+
+static struct qcom_smd_driver wcnss_ctrl_driver = {
+        .probe = wcnss_ctrl_probe,
+        .callback = wcnss_ctrl_smd_callback,
+        .smd_match_table = wcnss_ctrl_smd_match,
+        .driver  = {
+                .name  = "qcom_wcnss_ctrl",
+                .owner = THIS_MODULE,
+        },
+};
+
+module_qcom_smd_driver(wcnss_ctrl_driver);
+
+MODULE_DESCRIPTION("Qualcomm WCNSS control driver");
+MODULE_LICENSE("GPL v2");