Merge branch 'x15-audio-fixes' into omap-for-v4.4/fixes

[firefly-linux-kernel-4.4.55.git] / drivers / soc / qcom / smd-rpm.c

diff --git a/drivers/soc/qcom/smd-rpm.c b/drivers/soc/qcom/smd-rpm.c
index 1392ccf14a201b2ba01c76fdebc356c90cc99c4f..2969321e1b095fa6869e23e95a6825748d8ed58d 100644 (file)
--- a/drivers/soc/qcom/smd-rpm.c
+++ b/drivers/soc/qcom/smd-rpm.c
@@ -17,6 +17,7 @@
 #include <linux/of_platform.h>
 #include <linux/io.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 
 #include <linux/soc/qcom/smd.h>
 #include <linux/soc/qcom/smd-rpm.h>
@@ -44,8 +45,8 @@ struct qcom_smd_rpm {
  * @length:            length of the payload
  */
 struct qcom_rpm_header {
-       u32 service_type;
-       u32 length;
+       __le32 service_type;
+       __le32 length;
 };
 
 /**
@@ -57,11 +58,11 @@ struct qcom_rpm_header {
  * @data_len:  length of the payload following this header
  */
 struct qcom_rpm_request {
-       u32 msg_id;
-       u32 flags;
-       u32 type;
-       u32 id;
-       u32 data_len;
+       __le32 msg_id;
+       __le32 flags;
+       __le32 type;
+       __le32 id;
+       __le32 data_len;
 };
 
 /**
@@ -74,10 +75,10 @@ struct qcom_rpm_request {
  * Multiple of these messages can be stacked in an rpm message.
  */
 struct qcom_rpm_message {
-       u32 msg_type;
-       u32 length;
+       __le32 msg_type;
+       __le32 length;
        union {
-               u32 msg_id;
+               __le32 msg_id;
                u8 message[0];
        };
 };
@@ -104,30 +105,34 @@ int qcom_rpm_smd_write(struct qcom_smd_rpm *rpm,
        static unsigned msg_id = 1;
        int left;
        int ret;
-
        struct {
                struct qcom_rpm_header hdr;
                struct qcom_rpm_request req;
-               u8 payload[count];
-       } pkt;
+               u8 payload[];
+       } *pkt;
+       size_t size = sizeof(*pkt) + count;
 
        /* SMD packets to the RPM may not exceed 256 bytes */
-       if (WARN_ON(sizeof(pkt) >= 256))
+       if (WARN_ON(size >= 256))
                return -EINVAL;
 
+       pkt = kmalloc(size, GFP_KERNEL);
+       if (!pkt)
+               return -ENOMEM;
+
        mutex_lock(&rpm->lock);
 
-       pkt.hdr.service_type = RPM_SERVICE_TYPE_REQUEST;
-       pkt.hdr.length = sizeof(struct qcom_rpm_request) + count;
+       pkt->hdr.service_type = cpu_to_le32(RPM_SERVICE_TYPE_REQUEST);
+       pkt->hdr.length = cpu_to_le32(sizeof(struct qcom_rpm_request) + count);
 
-       pkt.req.msg_id = msg_id++;
-       pkt.req.flags = BIT(state);
-       pkt.req.type = type;
-       pkt.req.id = id;
-       pkt.req.data_len = count;
-       memcpy(pkt.payload, buf, count);
+       pkt->req.msg_id = cpu_to_le32(msg_id++);
+       pkt->req.flags = cpu_to_le32(state);
+       pkt->req.type = cpu_to_le32(type);
+       pkt->req.id = cpu_to_le32(id);
+       pkt->req.data_len = cpu_to_le32(count);
+       memcpy(pkt->payload, buf, count);
 
-       ret = qcom_smd_send(rpm->rpm_channel, &pkt, sizeof(pkt));
+       ret = qcom_smd_send(rpm->rpm_channel, pkt, size);
        if (ret)
                goto out;
 
@@ -138,6 +143,7 @@ int qcom_rpm_smd_write(struct qcom_smd_rpm *rpm,
                ret = rpm->ack_status;
 
 out:
+       kfree(pkt);
        mutex_unlock(&rpm->lock);
        return ret;
 }
@@ -148,27 +154,29 @@ static int qcom_smd_rpm_callback(struct qcom_smd_device *qsdev,
                                 size_t count)
 {
        const struct qcom_rpm_header *hdr = data;
+       size_t hdr_length = le32_to_cpu(hdr->length);
        const struct qcom_rpm_message *msg;
        struct qcom_smd_rpm *rpm = dev_get_drvdata(&qsdev->dev);
        const u8 *buf = data + sizeof(struct qcom_rpm_header);
-       const u8 *end = buf + hdr->length;
+       const u8 *end = buf + hdr_length;
        char msgbuf[32];
        int status = 0;
-       u32 len;
+       u32 len, msg_length;
 
-       if (hdr->service_type != RPM_SERVICE_TYPE_REQUEST ||
-           hdr->length < sizeof(struct qcom_rpm_message)) {
+       if (le32_to_cpu(hdr->service_type) != RPM_SERVICE_TYPE_REQUEST ||
+           hdr_length < sizeof(struct qcom_rpm_message)) {
                dev_err(&qsdev->dev, "invalid request\n");
                return 0;
        }
 
        while (buf < end) {
                msg = (struct qcom_rpm_message *)buf;
-               switch (msg->msg_type) {
+               msg_length = le32_to_cpu(msg->length);
+               switch (le32_to_cpu(msg->msg_type)) {
                case RPM_MSG_TYPE_MSG_ID:
                        break;
                case RPM_MSG_TYPE_ERR:
-                       len = min_t(u32, ALIGN(msg->length, 4), sizeof(msgbuf));
+                       len = min_t(u32, ALIGN(msg_length, 4), sizeof(msgbuf));
                        memcpy_fromio(msgbuf, msg->message, len);
                        msgbuf[len - 1] = 0;
 
@@ -179,7 +187,7 @@ static int qcom_smd_rpm_callback(struct qcom_smd_device *qsdev,
                        break;
                }
 
-               buf = PTR_ALIGN(buf + 2 * sizeof(u32) + msg->length, 4);
+               buf = PTR_ALIGN(buf + 2 * sizeof(u32) + msg_length, 4);
        }
 
        rpm->ack_status = status;