shmem.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  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#define SCMI_SHMEM_LAYOUT_OVERHEAD	24
 20
 21/*
 22 * SCMI specification requires all parameters, message headers, return
 23 * arguments or any protocol data to be expressed in little endian
 24 * format only.
 25 */
 26struct scmi_shared_mem {
 27	__le32 reserved;
 28	__le32 channel_status;
 29#define SCMI_SHMEM_CHAN_STAT_CHANNEL_ERROR	BIT(1)
 30#define SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE	BIT(0)
 31	__le32 reserved1[2];
 32	__le32 flags;
 33#define SCMI_SHMEM_FLAG_INTR_ENABLED	BIT(0)
 34	__le32 length;
 35	__le32 msg_header;
 36	u8 msg_payload[];
 37};
 38
 39static inline void shmem_memcpy_fromio32(void *to,
 40					 const void __iomem *from,
 41					 size_t count)
 42{
 43	WARN_ON(!IS_ALIGNED((unsigned long)from, 4) ||
 44		!IS_ALIGNED((unsigned long)to, 4) ||
 45		count % 4);
 46
 47	__ioread32_copy(to, from, count / 4);
 48}
 49
 50static inline void shmem_memcpy_toio32(void __iomem *to,
 51				       const void *from,
 52				       size_t count)
 53{
 54	WARN_ON(!IS_ALIGNED((unsigned long)to, 4) ||
 55		!IS_ALIGNED((unsigned long)from, 4) ||
 56		count % 4);
 57
 58	__iowrite32_copy(to, from, count / 4);
 59}
 60
 61static struct scmi_shmem_io_ops shmem_io_ops32 = {
 62	.fromio	= shmem_memcpy_fromio32,
 63	.toio	= shmem_memcpy_toio32,
 64};
 65
 66/* Wrappers are needed for proper memcpy_{from,to}_io expansion by the
 67 * pre-processor.
 68 */
 69static inline void shmem_memcpy_fromio(void *to,
 70				       const void __iomem *from,
 71				       size_t count)
 72{
 73	memcpy_fromio(to, from, count);
 74}
 75
 76static inline void shmem_memcpy_toio(void __iomem *to,
 77				     const void *from,
 78				     size_t count)
 79{
 80	memcpy_toio(to, from, count);
 81}
 82
 83static struct scmi_shmem_io_ops shmem_io_ops_default = {
 84	.fromio = shmem_memcpy_fromio,
 85	.toio	= shmem_memcpy_toio,
 86};
 87
 88static void shmem_tx_prepare(struct scmi_shared_mem __iomem *shmem,
 89			     struct scmi_xfer *xfer,
 90			     struct scmi_chan_info *cinfo,
 91			     shmem_copy_toio_t copy_toio)
 92{
 93	ktime_t stop;
 94
 95	/*
 96	 * Ideally channel must be free by now unless OS timeout last
 97	 * request and platform continued to process the same, wait
 98	 * until it releases the shared memory, otherwise we may endup
 99	 * overwriting its response with new message payload or vice-versa.
100	 * Giving up anyway after twice the expected channel timeout so as
101	 * not to bail-out on intermittent issues where the platform is
102	 * occasionally a bit slower to answer.
103	 *
104	 * Note that after a timeout is detected we bail-out and carry on but
105	 * the transport functionality is probably permanently compromised:
106	 * this is just to ease debugging and avoid complete hangs on boot
107	 * due to a misbehaving SCMI firmware.
108	 */
109	stop = ktime_add_ms(ktime_get(), 2 * cinfo->rx_timeout_ms);
110	spin_until_cond((ioread32(&shmem->channel_status) &
111			 SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE) ||
112			 ktime_after(ktime_get(), stop));
113	if (!(ioread32(&shmem->channel_status) &
114	      SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE)) {
115		WARN_ON_ONCE(1);
116		dev_err(cinfo->dev,
117			"Timeout waiting for a free TX channel !\n");
118		return;
119	}
120
121	/* Mark channel busy + clear error */
122	iowrite32(0x0, &shmem->channel_status);
123	iowrite32(xfer->hdr.poll_completion ? 0 : SCMI_SHMEM_FLAG_INTR_ENABLED,
124		  &shmem->flags);
125	iowrite32(sizeof(shmem->msg_header) + xfer->tx.len, &shmem->length);
126	iowrite32(pack_scmi_header(&xfer->hdr), &shmem->msg_header);
127	if (xfer->tx.buf)
128		copy_toio(shmem->msg_payload, xfer->tx.buf, xfer->tx.len);
129}
130
131static u32 shmem_read_header(struct scmi_shared_mem __iomem *shmem)
132{
133	return ioread32(&shmem->msg_header);
134}
135
136static void shmem_fetch_response(struct scmi_shared_mem __iomem *shmem,
137				 struct scmi_xfer *xfer,
138				 shmem_copy_fromio_t copy_fromio)
139{
140	size_t len = ioread32(&shmem->length);
141
142	xfer->hdr.status = ioread32(shmem->msg_payload);
143	/* Skip the length of header and status in shmem area i.e 8 bytes */
144	xfer->rx.len = min_t(size_t, xfer->rx.len, len > 8 ? len - 8 : 0);
145
146	/* Take a copy to the rx buffer.. */
147	copy_fromio(xfer->rx.buf, shmem->msg_payload + 4, xfer->rx.len);
148}
149
150static void shmem_fetch_notification(struct scmi_shared_mem __iomem *shmem,
151				     size_t max_len, struct scmi_xfer *xfer,
152				     shmem_copy_fromio_t copy_fromio)
153{
154	size_t len = ioread32(&shmem->length);
155
156	/* Skip only the length of header in shmem area i.e 4 bytes */
157	xfer->rx.len = min_t(size_t, max_len, len > 4 ? len - 4 : 0);
158
159	/* Take a copy to the rx buffer.. */
160	copy_fromio(xfer->rx.buf, shmem->msg_payload, xfer->rx.len);
161}
162
163static void shmem_clear_channel(struct scmi_shared_mem __iomem *shmem)
164{
165	iowrite32(SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE, &shmem->channel_status);
166}
167
168static bool shmem_poll_done(struct scmi_shared_mem __iomem *shmem,
169			    struct scmi_xfer *xfer)
170{
171	u16 xfer_id;
172
173	xfer_id = MSG_XTRACT_TOKEN(ioread32(&shmem->msg_header));
174
175	if (xfer->hdr.seq != xfer_id)
176		return false;
177
178	return ioread32(&shmem->channel_status) &
179		(SCMI_SHMEM_CHAN_STAT_CHANNEL_ERROR |
180		 SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE);
181}
182
183static bool shmem_channel_free(struct scmi_shared_mem __iomem *shmem)
184{
185	return (ioread32(&shmem->channel_status) &
186			SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE);
187}
188
189static bool shmem_channel_intr_enabled(struct scmi_shared_mem __iomem *shmem)
190{
191	return ioread32(&shmem->flags) & SCMI_SHMEM_FLAG_INTR_ENABLED;
192}
193
194static void __iomem *shmem_setup_iomap(struct scmi_chan_info *cinfo,
195				       struct device *dev, bool tx,
196				       struct resource *res,
197				       struct scmi_shmem_io_ops **ops)
198{
199	struct device_node *shmem __free(device_node);
200	const char *desc = tx ? "Tx" : "Rx";
201	int ret, idx = tx ? 0 : 1;
202	struct device *cdev = cinfo->dev;
203	struct resource lres = {};
204	resource_size_t size;
205	void __iomem *addr;
206	u32 reg_io_width;
207
208	shmem = of_parse_phandle(cdev->of_node, "shmem", idx);
209	if (!shmem)
210		return IOMEM_ERR_PTR(-ENODEV);
211
212	if (!of_device_is_compatible(shmem, "arm,scmi-shmem"))
213		return IOMEM_ERR_PTR(-ENXIO);
214
215	/* Use a local on-stack as a working area when not provided */
216	if (!res)
217		res = &lres;
218
219	ret = of_address_to_resource(shmem, 0, res);
220	if (ret) {
221		dev_err(cdev, "failed to get SCMI %s shared memory\n", desc);
222		return IOMEM_ERR_PTR(ret);
223	}
224
225	size = resource_size(res);
226	if (cinfo->max_msg_size + SCMI_SHMEM_LAYOUT_OVERHEAD > size) {
227		dev_err(dev, "misconfigured SCMI shared memory\n");
228		return IOMEM_ERR_PTR(-ENOSPC);
229	}
230
231	addr = devm_ioremap(dev, res->start, size);
232	if (!addr) {
233		dev_err(dev, "failed to ioremap SCMI %s shared memory\n", desc);
234		return IOMEM_ERR_PTR(-EADDRNOTAVAIL);
235	}
236
237	of_property_read_u32(shmem, "reg-io-width", &reg_io_width);
238	switch (reg_io_width) {
239	case 4:
240		*ops = &shmem_io_ops32;
241		break;
242	default:
243		*ops = &shmem_io_ops_default;
244		break;
245	}
246
247	return addr;
248}
249
250static const struct scmi_shared_mem_operations scmi_shmem_ops = {
251	.tx_prepare = shmem_tx_prepare,
252	.read_header = shmem_read_header,
253	.fetch_response = shmem_fetch_response,
254	.fetch_notification = shmem_fetch_notification,
255	.clear_channel = shmem_clear_channel,
256	.poll_done = shmem_poll_done,
257	.channel_free = shmem_channel_free,
258	.channel_intr_enabled = shmem_channel_intr_enabled,
259	.setup_iomap = shmem_setup_iomap,
260};
261
262const struct scmi_shared_mem_operations *scmi_shared_mem_operations_get(void)
263{
264	return &scmi_shmem_ops;
265}