195 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * For transport using shared mem structure.4 *5 * Copyright (C) 2019-2024 ARM Ltd.6 */7 8#include <linux/ktime.h>9#include <linux/io.h>10#include <linux/of.h>11#include <linux/of_address.h>12#include <linux/processor.h>13#include <linux/types.h>14 15#include <linux/bug.h>16 17#include "common.h"18 19/*20 * SCMI specification requires all parameters, message headers, return21 * arguments or any protocol data to be expressed in little endian22 * format only.23 */24struct scmi_shared_mem {25 __le32 reserved;26 __le32 channel_status;27#define SCMI_SHMEM_CHAN_STAT_CHANNEL_ERROR BIT(1)28#define SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE BIT(0)29 __le32 reserved1[2];30 __le32 flags;31#define SCMI_SHMEM_FLAG_INTR_ENABLED BIT(0)32 __le32 length;33 __le32 msg_header;34 u8 msg_payload[];35};36 37static void shmem_tx_prepare(struct scmi_shared_mem __iomem *shmem,38 struct scmi_xfer *xfer,39 struct scmi_chan_info *cinfo)40{41 ktime_t stop;42 43 /*44 * Ideally channel must be free by now unless OS timeout last45 * request and platform continued to process the same, wait46 * until it releases the shared memory, otherwise we may endup47 * overwriting its response with new message payload or vice-versa.48 * Giving up anyway after twice the expected channel timeout so as49 * not to bail-out on intermittent issues where the platform is50 * occasionally a bit slower to answer.51 *52 * Note that after a timeout is detected we bail-out and carry on but53 * the transport functionality is probably permanently compromised:54 * this is just to ease debugging and avoid complete hangs on boot55 * due to a misbehaving SCMI firmware.56 */57 stop = ktime_add_ms(ktime_get(), 2 * cinfo->rx_timeout_ms);58 spin_until_cond((ioread32(&shmem->channel_status) &59 SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE) ||60 ktime_after(ktime_get(), stop));61 if (!(ioread32(&shmem->channel_status) &62 SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE)) {63 WARN_ON_ONCE(1);64 dev_err(cinfo->dev,65 "Timeout waiting for a free TX channel !\n");66 return;67 }68 69 /* Mark channel busy + clear error */70 iowrite32(0x0, &shmem->channel_status);71 iowrite32(xfer->hdr.poll_completion ? 0 : SCMI_SHMEM_FLAG_INTR_ENABLED,72 &shmem->flags);73 iowrite32(sizeof(shmem->msg_header) + xfer->tx.len, &shmem->length);74 iowrite32(pack_scmi_header(&xfer->hdr), &shmem->msg_header);75 if (xfer->tx.buf)76 memcpy_toio(shmem->msg_payload, xfer->tx.buf, xfer->tx.len);77}78 79static u32 shmem_read_header(struct scmi_shared_mem __iomem *shmem)80{81 return ioread32(&shmem->msg_header);82}83 84static void shmem_fetch_response(struct scmi_shared_mem __iomem *shmem,85 struct scmi_xfer *xfer)86{87 size_t len = ioread32(&shmem->length);88 89 xfer->hdr.status = ioread32(shmem->msg_payload);90 /* Skip the length of header and status in shmem area i.e 8 bytes */91 xfer->rx.len = min_t(size_t, xfer->rx.len, len > 8 ? len - 8 : 0);92 93 /* Take a copy to the rx buffer.. */94 memcpy_fromio(xfer->rx.buf, shmem->msg_payload + 4, xfer->rx.len);95}96 97static void shmem_fetch_notification(struct scmi_shared_mem __iomem *shmem,98 size_t max_len, struct scmi_xfer *xfer)99{100 size_t len = ioread32(&shmem->length);101 102 /* Skip only the length of header in shmem area i.e 4 bytes */103 xfer->rx.len = min_t(size_t, max_len, len > 4 ? len - 4 : 0);104 105 /* Take a copy to the rx buffer.. */106 memcpy_fromio(xfer->rx.buf, shmem->msg_payload, xfer->rx.len);107}108 109static void shmem_clear_channel(struct scmi_shared_mem __iomem *shmem)110{111 iowrite32(SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE, &shmem->channel_status);112}113 114static bool shmem_poll_done(struct scmi_shared_mem __iomem *shmem,115 struct scmi_xfer *xfer)116{117 u16 xfer_id;118 119 xfer_id = MSG_XTRACT_TOKEN(ioread32(&shmem->msg_header));120 121 if (xfer->hdr.seq != xfer_id)122 return false;123 124 return ioread32(&shmem->channel_status) &125 (SCMI_SHMEM_CHAN_STAT_CHANNEL_ERROR |126 SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE);127}128 129static bool shmem_channel_free(struct scmi_shared_mem __iomem *shmem)130{131 return (ioread32(&shmem->channel_status) &132 SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE);133}134 135static bool shmem_channel_intr_enabled(struct scmi_shared_mem __iomem *shmem)136{137 return ioread32(&shmem->flags) & SCMI_SHMEM_FLAG_INTR_ENABLED;138}139 140static void __iomem *shmem_setup_iomap(struct scmi_chan_info *cinfo,141 struct device *dev, bool tx,142 struct resource *res)143{144 struct device_node *shmem __free(device_node);145 const char *desc = tx ? "Tx" : "Rx";146 int ret, idx = tx ? 0 : 1;147 struct device *cdev = cinfo->dev;148 struct resource lres = {};149 resource_size_t size;150 void __iomem *addr;151 152 shmem = of_parse_phandle(cdev->of_node, "shmem", idx);153 if (!shmem)154 return IOMEM_ERR_PTR(-ENODEV);155 156 if (!of_device_is_compatible(shmem, "arm,scmi-shmem"))157 return IOMEM_ERR_PTR(-ENXIO);158 159 /* Use a local on-stack as a working area when not provided */160 if (!res)161 res = &lres;162 163 ret = of_address_to_resource(shmem, 0, res);164 if (ret) {165 dev_err(cdev, "failed to get SCMI %s shared memory\n", desc);166 return IOMEM_ERR_PTR(ret);167 }168 169 size = resource_size(res);170 addr = devm_ioremap(dev, res->start, size);171 if (!addr) {172 dev_err(dev, "failed to ioremap SCMI %s shared memory\n", desc);173 return IOMEM_ERR_PTR(-EADDRNOTAVAIL);174 }175 176 return addr;177}178 179static const struct scmi_shared_mem_operations scmi_shmem_ops = {180 .tx_prepare = shmem_tx_prepare,181 .read_header = shmem_read_header,182 .fetch_response = shmem_fetch_response,183 .fetch_notification = shmem_fetch_notification,184 .clear_channel = shmem_clear_channel,185 .poll_done = shmem_poll_done,186 .channel_free = shmem_channel_free,187 .channel_intr_enabled = shmem_channel_intr_enabled,188 .setup_iomap = shmem_setup_iomap,189};190 191const struct scmi_shared_mem_operations *scmi_shared_mem_operations_get(void)192{193 return &scmi_shmem_ops;194}195