| // SPDX-License-Identifier: GPL-2.0+ | |
| /* | |
| * Copyright 2018 NXP | |
| * Author: Dong Aisheng <aisheng.dong@nxp.com> | |
| * | |
| * Implementation of the SCU IPC functions using MUs (client side). | |
| * | |
| */ | |
| #include <linux/err.h> | |
| #include <linux/firmware/imx/ipc.h> | |
| #include <linux/firmware/imx/sci.h> | |
| #include <linux/interrupt.h> | |
| #include <linux/irq.h> | |
| #include <linux/kernel.h> | |
| #include <linux/mailbox_client.h> | |
| #include <linux/module.h> | |
| #include <linux/mutex.h> | |
| #include <linux/of.h> | |
| #include <linux/of_platform.h> | |
| #include <linux/platform_device.h> | |
| #define SCU_MU_CHAN_NUM 8 | |
| #define MAX_RX_TIMEOUT (msecs_to_jiffies(3000)) | |
| struct imx_sc_chan { | |
| struct imx_sc_ipc *sc_ipc; | |
| struct mbox_client cl; | |
| struct mbox_chan *ch; | |
| int idx; | |
| struct completion tx_done; | |
| }; | |
| struct imx_sc_ipc { | |
| /* SCU uses 4 Tx and 4 Rx channels */ | |
| struct imx_sc_chan chans[SCU_MU_CHAN_NUM]; | |
| struct device *dev; | |
| struct mutex lock; | |
| struct completion done; | |
| bool fast_ipc; | |
| /* temporarily store the SCU msg */ | |
| u32 *msg; | |
| u8 rx_size; | |
| u8 count; | |
| }; | |
| /* | |
| * This type is used to indicate error response for most functions. | |
| */ | |
| enum imx_sc_error_codes { | |
| IMX_SC_ERR_NONE = 0, /* Success */ | |
| IMX_SC_ERR_VERSION = 1, /* Incompatible API version */ | |
| IMX_SC_ERR_CONFIG = 2, /* Configuration error */ | |
| IMX_SC_ERR_PARM = 3, /* Bad parameter */ | |
| IMX_SC_ERR_NOACCESS = 4, /* Permission error (no access) */ | |
| IMX_SC_ERR_LOCKED = 5, /* Permission error (locked) */ | |
| IMX_SC_ERR_UNAVAILABLE = 6, /* Unavailable (out of resources) */ | |
| IMX_SC_ERR_NOTFOUND = 7, /* Not found */ | |
| IMX_SC_ERR_NOPOWER = 8, /* No power */ | |
| IMX_SC_ERR_IPC = 9, /* Generic IPC error */ | |
| IMX_SC_ERR_BUSY = 10, /* Resource is currently busy/active */ | |
| IMX_SC_ERR_FAIL = 11, /* General I/O failure */ | |
| IMX_SC_ERR_LAST | |
| }; | |
| static int imx_sc_linux_errmap[IMX_SC_ERR_LAST] = { | |
| 0, /* IMX_SC_ERR_NONE */ | |
| -EINVAL, /* IMX_SC_ERR_VERSION */ | |
| -EINVAL, /* IMX_SC_ERR_CONFIG */ | |
| -EINVAL, /* IMX_SC_ERR_PARM */ | |
| -EACCES, /* IMX_SC_ERR_NOACCESS */ | |
| -EACCES, /* IMX_SC_ERR_LOCKED */ | |
| -ERANGE, /* IMX_SC_ERR_UNAVAILABLE */ | |
| -ENOENT, /* IMX_SC_ERR_NOTFOUND */ | |
| -ENODEV, /* IMX_SC_ERR_NOPOWER */ | |
| -ECOMM, /* IMX_SC_ERR_IPC */ | |
| -EBUSY, /* IMX_SC_ERR_BUSY */ | |
| -EIO, /* IMX_SC_ERR_FAIL */ | |
| }; | |
| static struct imx_sc_ipc *imx_sc_ipc_handle; | |
| static void imx_scu_free_mbox_chan(void *data) | |
| { | |
| mbox_free_channel(data); | |
| } | |
| static void imx_scu_clear_handle(void *data) | |
| { | |
| if (imx_sc_ipc_handle == data) | |
| imx_sc_ipc_handle = NULL; | |
| } | |
| static inline int imx_sc_to_linux_errno(int errno) | |
| { | |
| if (errno >= IMX_SC_ERR_NONE && errno < IMX_SC_ERR_LAST) | |
| return imx_sc_linux_errmap[errno]; | |
| return -EIO; | |
| } | |
| /* | |
| * Get the default handle used by SCU | |
| */ | |
| int imx_scu_get_handle(struct imx_sc_ipc **ipc) | |
| { | |
| if (!imx_sc_ipc_handle) | |
| return -EPROBE_DEFER; | |
| *ipc = imx_sc_ipc_handle; | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(imx_scu_get_handle); | |
| /* Callback called when the word of a message is ack-ed, eg read by SCU */ | |
| static void imx_scu_tx_done(struct mbox_client *cl, void *mssg, int r) | |
| { | |
| struct imx_sc_chan *sc_chan = container_of(cl, struct imx_sc_chan, cl); | |
| complete(&sc_chan->tx_done); | |
| } | |
| static void imx_scu_rx_callback(struct mbox_client *c, void *msg) | |
| { | |
| struct imx_sc_chan *sc_chan = container_of(c, struct imx_sc_chan, cl); | |
| struct imx_sc_ipc *sc_ipc = sc_chan->sc_ipc; | |
| struct imx_sc_rpc_msg *hdr; | |
| u32 *data = msg; | |
| int i; | |
| if (!sc_ipc->msg) { | |
| dev_warn(sc_ipc->dev, "unexpected rx idx %d 0x%08x, ignore!\n", | |
| sc_chan->idx, *data); | |
| return; | |
| } | |
| if (sc_ipc->fast_ipc) { | |
| hdr = msg; | |
| sc_ipc->rx_size = hdr->size; | |
| sc_ipc->msg[0] = *data++; | |
| for (i = 1; i < sc_ipc->rx_size; i++) | |
| sc_ipc->msg[i] = *data++; | |
| complete(&sc_ipc->done); | |
| return; | |
| } | |
| if (sc_chan->idx == 0) { | |
| hdr = msg; | |
| sc_ipc->rx_size = hdr->size; | |
| dev_dbg(sc_ipc->dev, "msg rx size %u\n", sc_ipc->rx_size); | |
| if (sc_ipc->rx_size > 4) | |
| dev_warn(sc_ipc->dev, "RPC does not support receiving over 4 words: %u\n", | |
| sc_ipc->rx_size); | |
| } | |
| sc_ipc->msg[sc_chan->idx] = *data; | |
| sc_ipc->count++; | |
| dev_dbg(sc_ipc->dev, "mu %u msg %u 0x%x\n", sc_chan->idx, | |
| sc_ipc->count, *data); | |
| if ((sc_ipc->rx_size != 0) && (sc_ipc->count == sc_ipc->rx_size)) | |
| complete(&sc_ipc->done); | |
| } | |
| static int imx_scu_ipc_write(struct imx_sc_ipc *sc_ipc, void *msg) | |
| { | |
| struct imx_sc_rpc_msg hdr = *(struct imx_sc_rpc_msg *)msg; | |
| struct imx_sc_chan *sc_chan; | |
| u32 *data = msg; | |
| int ret; | |
| int size; | |
| int i; | |
| /* Check size */ | |
| if (hdr.size > IMX_SC_RPC_MAX_MSG) | |
| return -EINVAL; | |
| dev_dbg(sc_ipc->dev, "RPC SVC %u FUNC %u SIZE %u\n", hdr.svc, | |
| hdr.func, hdr.size); | |
| size = sc_ipc->fast_ipc ? 1 : hdr.size; | |
| for (i = 0; i < size; i++) { | |
| sc_chan = &sc_ipc->chans[i % 4]; | |
| /* | |
| * SCU requires that all messages words are written | |
| * sequentially but linux MU driver implements multiple | |
| * independent channels for each register so ordering between | |
| * different channels must be ensured by SCU API interface. | |
| * | |
| * Wait for tx_done before every send to ensure that no | |
| * queueing happens at the mailbox channel level. | |
| */ | |
| if (!sc_ipc->fast_ipc) { | |
| wait_for_completion(&sc_chan->tx_done); | |
| reinit_completion(&sc_chan->tx_done); | |
| } | |
| ret = mbox_send_message(sc_chan->ch, &data[i]); | |
| if (ret < 0) | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| /* | |
| * RPC command/response | |
| */ | |
| int imx_scu_call_rpc(struct imx_sc_ipc *sc_ipc, void *msg, bool have_resp) | |
| { | |
| uint8_t saved_svc, saved_func; | |
| struct imx_sc_rpc_msg *hdr; | |
| int ret; | |
| if (WARN_ON(!sc_ipc || !msg)) | |
| return -EINVAL; | |
| mutex_lock(&sc_ipc->lock); | |
| reinit_completion(&sc_ipc->done); | |
| if (have_resp) { | |
| sc_ipc->msg = msg; | |
| saved_svc = ((struct imx_sc_rpc_msg *)msg)->svc; | |
| saved_func = ((struct imx_sc_rpc_msg *)msg)->func; | |
| } | |
| sc_ipc->count = 0; | |
| ret = imx_scu_ipc_write(sc_ipc, msg); | |
| if (ret < 0) { | |
| dev_err(sc_ipc->dev, "RPC send msg failed: %d\n", ret); | |
| goto out; | |
| } | |
| if (have_resp) { | |
| if (!wait_for_completion_timeout(&sc_ipc->done, | |
| MAX_RX_TIMEOUT)) { | |
| dev_err(sc_ipc->dev, "RPC send msg timeout\n"); | |
| mutex_unlock(&sc_ipc->lock); | |
| return -ETIMEDOUT; | |
| } | |
| /* response status is stored in hdr->func field */ | |
| hdr = msg; | |
| ret = hdr->func; | |
| /* | |
| * Some special SCU firmware APIs do NOT have return value | |
| * in hdr->func, but they do have response data, those special | |
| * APIs are defined as void function in SCU firmware, so they | |
| * should be treated as return success always. | |
| */ | |
| if ((saved_svc == IMX_SC_RPC_SVC_MISC) && | |
| (saved_func == IMX_SC_MISC_FUNC_UNIQUE_ID || | |
| saved_func == IMX_SC_MISC_FUNC_GET_BUTTON_STATUS)) | |
| ret = 0; | |
| } | |
| out: | |
| sc_ipc->msg = NULL; | |
| mutex_unlock(&sc_ipc->lock); | |
| dev_dbg(sc_ipc->dev, "RPC SVC done\n"); | |
| return imx_sc_to_linux_errno(ret); | |
| } | |
| EXPORT_SYMBOL(imx_scu_call_rpc); | |
| static int imx_scu_probe(struct platform_device *pdev) | |
| { | |
| struct device *dev = &pdev->dev; | |
| struct imx_sc_ipc *sc_ipc; | |
| struct imx_sc_chan *sc_chan; | |
| struct mbox_client *cl; | |
| char *chan_name; | |
| struct of_phandle_args args; | |
| int num_channel; | |
| int ret; | |
| int i; | |
| sc_ipc = devm_kzalloc(dev, sizeof(*sc_ipc), GFP_KERNEL); | |
| if (!sc_ipc) | |
| return -ENOMEM; | |
| ret = of_parse_phandle_with_args(pdev->dev.of_node, "mboxes", | |
| "#mbox-cells", 0, &args); | |
| if (ret) | |
| return ret; | |
| sc_ipc->fast_ipc = of_device_is_compatible(args.np, "fsl,imx8-mu-scu"); | |
| of_node_put(args.np); | |
| num_channel = sc_ipc->fast_ipc ? 2 : SCU_MU_CHAN_NUM; | |
| for (i = 0; i < num_channel; i++) { | |
| if (i < num_channel / 2) | |
| chan_name = kasprintf(GFP_KERNEL, "tx%d", i); | |
| else | |
| chan_name = kasprintf(GFP_KERNEL, "rx%d", | |
| i - num_channel / 2); | |
| if (!chan_name) | |
| return -ENOMEM; | |
| sc_chan = &sc_ipc->chans[i]; | |
| cl = &sc_chan->cl; | |
| cl->dev = dev; | |
| cl->tx_block = false; | |
| cl->knows_txdone = true; | |
| cl->rx_callback = imx_scu_rx_callback; | |
| if (!sc_ipc->fast_ipc) { | |
| /* Initial tx_done completion as "done" */ | |
| cl->tx_done = imx_scu_tx_done; | |
| init_completion(&sc_chan->tx_done); | |
| complete(&sc_chan->tx_done); | |
| } | |
| sc_chan->sc_ipc = sc_ipc; | |
| sc_chan->idx = i % (num_channel / 2); | |
| sc_chan->ch = mbox_request_channel_byname(cl, chan_name); | |
| if (IS_ERR(sc_chan->ch)) { | |
| ret = PTR_ERR(sc_chan->ch); | |
| dev_err_probe(dev, ret, "Failed to request mbox chan %s\n", | |
| chan_name); | |
| kfree(chan_name); | |
| return ret; | |
| } | |
| dev_dbg(dev, "request mbox chan %s\n", chan_name); | |
| /* chan_name is not used anymore by framework */ | |
| kfree(chan_name); | |
| ret = devm_add_action_or_reset(dev, imx_scu_free_mbox_chan, | |
| sc_chan->ch); | |
| if (ret) | |
| return ret; | |
| } | |
| sc_ipc->dev = dev; | |
| ret = devm_mutex_init(dev, &sc_ipc->lock); | |
| if (ret) | |
| return ret; | |
| init_completion(&sc_ipc->done); | |
| imx_sc_ipc_handle = sc_ipc; | |
| ret = devm_add_action_or_reset(dev, imx_scu_clear_handle, sc_ipc); | |
| if (ret) | |
| return ret; | |
| ret = imx_scu_soc_init(dev); | |
| if (ret) | |
| dev_warn(dev, "failed to initialize SoC info: %d\n", ret); | |
| ret = imx_scu_enable_general_irq_channel(dev); | |
| if (ret) | |
| dev_warn(dev, | |
| "failed to enable general irq channel: %d\n", ret); | |
| dev_info(dev, "NXP i.MX SCU Initialized\n"); | |
| ret = devm_of_platform_populate(dev); | |
| if (ret) | |
| of_platform_depopulate(dev); | |
| return ret; | |
| } | |
| static const struct of_device_id imx_scu_match[] = { | |
| { .compatible = "fsl,imx-scu", }, | |
| { /* Sentinel */ } | |
| }; | |
| static struct platform_driver imx_scu_driver = { | |
| .driver = { | |
| .name = "imx-scu", | |
| .of_match_table = imx_scu_match, | |
| .suppress_bind_attrs = true, | |
| }, | |
| .probe = imx_scu_probe, | |
| }; | |
| static int __init imx_scu_driver_init(void) | |
| { | |
| return platform_driver_register(&imx_scu_driver); | |
| } | |
| subsys_initcall_sync(imx_scu_driver_init); | |
| MODULE_AUTHOR("Dong Aisheng <aisheng.dong@nxp.com>"); | |
| MODULE_DESCRIPTION("IMX SCU firmware protocol driver"); | |
| MODULE_LICENSE("GPL v2"); |