lkml.org 
[lkml]   [2023]   [Aug]   [23]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v5 08/11] firmware: imx: enable trng
    Date
    Enabled trng on imx93 platform through enclave fw.

    Signed-off-by: Gaurav Jain <gaurav.jain@nxp.com>
    Signed-off-by: Pankaj Gupta <pankaj.gupta@nxp.com>
    ---
    drivers/firmware/imx/Kconfig | 9 +++
    drivers/firmware/imx/Makefile | 3 +-
    drivers/firmware/imx/ele_base_msg.c | 88 +++++++++++++++++++++++
    drivers/firmware/imx/ele_common.c | 44 +++++++++++-
    drivers/firmware/imx/ele_common.h | 2 +
    drivers/firmware/imx/ele_fw_api.c | 54 ++++++++++++++
    drivers/firmware/imx/ele_trng.c | 48 +++++++++++++
    drivers/firmware/imx/se_fw.c | 23 +++++-
    include/linux/firmware/imx/ele_base_msg.h | 11 +++
    include/linux/firmware/imx/ele_fw_api.h | 5 ++
    10 files changed, 283 insertions(+), 4 deletions(-)
    create mode 100644 drivers/firmware/imx/ele_trng.c

    diff --git a/drivers/firmware/imx/Kconfig b/drivers/firmware/imx/Kconfig
    index 2822e5d4b24c..ffc02593293c 100644
    --- a/drivers/firmware/imx/Kconfig
    +++ b/drivers/firmware/imx/Kconfig
    @@ -40,3 +40,12 @@ config IMX_SEC_ENCLAVE
    like base, HSM, V2X & SHE using the SAB protocol via the shared Messaging
    Unit. This driver exposes these interfaces via a set of file descriptors
    allowing to configure shared memory, send and receive messages.
    +
    +config IMX_ELE_TRNG
    + tristate "i.MX ELE True Random Number Generator"
    + default y
    + select CRYPTO_RNG
    + select HW_RANDOM
    + help
    + This driver provides kernel-side support for the Random Number generation,
    + through NXP hardware IP for secure-enclave called EdgeLock Enclave.
    diff --git a/drivers/firmware/imx/Makefile b/drivers/firmware/imx/Makefile
    index bc6ed5514a19..e46f3053707f 100644
    --- a/drivers/firmware/imx/Makefile
    +++ b/drivers/firmware/imx/Makefile
    @@ -2,5 +2,6 @@
    obj-$(CONFIG_IMX_DSP) += imx-dsp.o
    obj-$(CONFIG_IMX_SCU) += imx-scu.o misc.o imx-scu-irq.o rm.o imx-scu-soc.o
    obj-$(CONFIG_IMX_SCU_PD) += scu-pd.o
    -sec_enclave-objs = se_fw.o ele_common.o ele_base_msg.o ele_fw_api.o
    +sec_enclave-objs = ele_common.o se_fw.o ele_base_msg.o ele_fw_api.o
    obj-${CONFIG_IMX_SEC_ENCLAVE} += sec_enclave.o
    +sec_enclave-${CONFIG_IMX_ELE_TRNG} += ele_trng.o
    diff --git a/drivers/firmware/imx/ele_base_msg.c b/drivers/firmware/imx/ele_base_msg.c
    index 2eb675a1b389..c42e29e14662 100644
    --- a/drivers/firmware/imx/ele_base_msg.c
    +++ b/drivers/firmware/imx/ele_base_msg.c
    @@ -60,3 +60,91 @@ int ele_get_info(struct device *dev, phys_addr_t addr, u32 data_size)

    return -EINVAL;
    }
    +
    +/*
    + * ele_get_trng_state() - prepare and send the command to read
    + * crypto lib and TRNG state
    + * TRNG state
    + * 0x1 TRNG is in program mode
    + * 0x2 TRNG is still generating entropy
    + * 0x3 TRNG entropy is valid and ready to be read
    + * 0x4 TRNG encounter an error while generating entropy
    + *
    + * CSAL state
    + * 0x0 Crypto Lib random context initialization is not done yet
    + * 0x1 Crypto Lib random context initialization is on-going
    + * 0x2 Crypto Lib random context initialization succeed
    + * 0x3 Crypto Lib random context initialization failed
    + *
    + * returns: csal and trng state.
    + *
    + */
    +int ele_get_trng_state(struct device *dev)
    +{
    + struct ele_mu_priv *priv = dev_get_drvdata(dev);
    + int ret;
    + unsigned int tag, command, size, ver, status;
    +
    + ret = plat_fill_cmd_msg_hdr(priv,
    + (struct mu_hdr *)&priv->tx_msg.header,
    + ELE_GET_TRNG_STATE_REQ, 4);
    + if (ret)
    + return ret;
    +
    + ret = imx_ele_msg_send_rcv(priv);
    + if (ret < 0)
    + return ret;
    +
    + tag = MSG_TAG(priv->rx_msg.header);
    + command = MSG_COMMAND(priv->rx_msg.header);
    + size = MSG_SIZE(priv->rx_msg.header);
    + ver = MSG_VER(priv->rx_msg.header);
    + status = RES_STATUS(priv->rx_msg.data[0]);
    + if (tag == priv->rsp_tag &&
    + command == ELE_GET_TRNG_STATE_REQ &&
    + size == ELE_GET_TRNG_STATE_REQ_MSG_SZ &&
    + ver == ELE_BASE_API_VERSION &&
    + status == priv->success_tag) {
    + return (priv->rx_msg.data[1] & CSAL_TRNG_STATE_MASK);
    + }
    +
    + return -EINVAL;
    +}
    +
    +/*
    + * ele_start_rng() - prepare and send the command to start
    + * initialization of the ELE RNG context
    + *
    + * returns: 0 on success.
    + */
    +int ele_start_rng(struct device *dev)
    +{
    + struct ele_mu_priv *priv = dev_get_drvdata(dev);
    + int ret;
    + unsigned int tag, command, size, ver, status;
    +
    + ret = plat_fill_cmd_msg_hdr(priv,
    + (struct mu_hdr *)&priv->tx_msg.header,
    + ELE_START_RNG_REQ, 4);
    + if (ret)
    + return ret;
    +
    + ret = imx_ele_msg_send_rcv(priv);
    + if (ret < 0)
    + return ret;
    +
    + tag = MSG_TAG(priv->rx_msg.header);
    + command = MSG_COMMAND(priv->rx_msg.header);
    + size = MSG_SIZE(priv->rx_msg.header);
    + ver = MSG_VER(priv->rx_msg.header);
    + status = RES_STATUS(priv->rx_msg.data[0]);
    + if (tag == priv->rsp_tag &&
    + command == ELE_START_RNG_REQ &&
    + size == ELE_START_RNG_REQ_MSG_SZ &&
    + ver == ELE_BASE_API_VERSION &&
    + status == priv->success_tag) {
    + return 0;
    + }
    +
    + return -EINVAL;
    +}
    diff --git a/drivers/firmware/imx/ele_common.c b/drivers/firmware/imx/ele_common.c
    index 08adc7200ceb..f01e5e3255f9 100644
    --- a/drivers/firmware/imx/ele_common.c
    +++ b/drivers/firmware/imx/ele_common.c
    @@ -1,9 +1,13 @@
    // SPDX-License-Identifier: GPL-2.0+
    /*
    - * Copyright 2021-2023 NXP
    + * Copyright 2023 NXP
    */

    -#include "se_fw.h"
    +#include <linux/delay.h>
    +#include <linux/device.h>
    +#include <linux/firmware/imx/ele_base_msg.h>
    +
    +#include "ele_common.h"

    int imx_ele_msg_send_rcv(struct ele_mu_priv *priv)
    {
    @@ -32,3 +36,39 @@ int imx_ele_msg_send_rcv(struct ele_mu_priv *priv)
    return err;
    }

    +int ele_do_start_rng(struct device *dev)
    +{
    + int ret;
    + int count = ELE_GET_TRNG_STATE_RETRY_COUNT;
    +
    + ret = ele_get_trng_state(dev);
    + if (ret < 0) {
    + dev_err(dev, "Failed to get trng state\n");
    + return ret;
    + } else if (ret != ELE_TRNG_STATE_OK) {
    + /* call start rng */
    + ret = ele_start_rng(dev);
    + if (ret) {
    + dev_err(dev, "Failed to start rng\n");
    + return ret;
    + }
    +
    + /* poll get trng state API, ELE_GET_TRNG_STATE_RETRY_COUNT times
    + * or while trng state != 0x203
    + */
    + do {
    + msleep(10);
    + ret = ele_get_trng_state(dev);
    + if (ret < 0) {
    + dev_err(dev, "Failed to get trng state\n");
    + return ret;
    + }
    + count--;
    + } while ((ret != ELE_TRNG_STATE_OK) && count);
    + if (ret != ELE_TRNG_STATE_OK)
    + return -EIO;
    + }
    +
    + return 0;
    +}
    +
    diff --git a/drivers/firmware/imx/ele_common.h b/drivers/firmware/imx/ele_common.h
    index 6af0296b76fd..ed68e5cf9638 100644
    --- a/drivers/firmware/imx/ele_common.h
    +++ b/drivers/firmware/imx/ele_common.h
    @@ -18,4 +18,6 @@ static inline int ele_trng_init(struct device *dev)
    return 0;
    }
    #endif
    +
    +int ele_do_start_rng(struct device *dev);
    #endif
    diff --git a/drivers/firmware/imx/ele_fw_api.c b/drivers/firmware/imx/ele_fw_api.c
    index 1df1fbcb6d9e..8e0b331531a2 100644
    --- a/drivers/firmware/imx/ele_fw_api.c
    +++ b/drivers/firmware/imx/ele_fw_api.c
    @@ -54,3 +54,57 @@ int ele_init_fw(struct device *dev)

    return -EINVAL;
    }
    +
    +/*
    + * ele_get_random() - prepare and send the command to proceed
    + * with a random number generation operation
    + *
    + * returns: size of the rondom number generated
    + */
    +int ele_get_random(struct device *dev,
    + void *data, size_t len)
    +{
    + struct ele_mu_priv *priv = dev_get_drvdata(dev);
    + unsigned int tag, command, size, ver, status;
    + dma_addr_t dst_dma;
    + u8 *buf;
    + int ret;
    +
    + buf = dmam_alloc_coherent(priv->dev, len, &dst_dma, GFP_KERNEL);
    + if (!buf) {
    + dev_err(priv->dev, "Failed to map destination buffer memory\n");
    + return -ENOMEM;
    + }
    +
    + ret = plat_fill_cmd_msg_hdr(priv,
    + (struct mu_hdr *)&priv->tx_msg.header,
    + ELE_GET_RANDOM_REQ, 16);
    + if (ret)
    + goto exit;
    +
    + priv->tx_msg.data[0] = 0x0;
    + priv->tx_msg.data[1] = dst_dma;
    + priv->tx_msg.data[2] = len;
    + ret = imx_ele_msg_send_rcv(priv);
    + if (ret < 0)
    + goto exit;
    +
    + tag = MSG_TAG(priv->rx_msg.header);
    + command = MSG_COMMAND(priv->rx_msg.header);
    + size = MSG_SIZE(priv->rx_msg.header);
    + ver = MSG_VER(priv->rx_msg.header);
    + status = RES_STATUS(priv->rx_msg.data[0]);
    + if (tag == priv->rsp_tag
    + && command == ELE_GET_RANDOM_REQ
    + && size == ELE_GET_RANDOM_REQ_SZ
    + && ver == MESSAGING_VERSION_7
    + && status == priv->success_tag) {
    + memcpy(data, buf, len);
    + ret = len;
    + } else
    + ret = -EINVAL;
    +
    +exit:
    + dmam_free_coherent(priv->dev, len, buf, dst_dma);
    + return ret;
    +}
    diff --git a/drivers/firmware/imx/ele_trng.c b/drivers/firmware/imx/ele_trng.c
    new file mode 100644
    index 000000000000..23d5891f9569
    --- /dev/null
    +++ b/drivers/firmware/imx/ele_trng.c
    @@ -0,0 +1,48 @@
    +// SPDX-License-Identifier: GPL-2.0-or-later
    +/*
    + * ELE Random Number Generator Driver NXP's Platforms
    + *
    + * Copyright 2023 NXP
    + */
    +
    +#include <linux/firmware/imx/ele_fw_api.h>
    +
    +#include "ele_common.h"
    +
    +struct ele_trng {
    + struct hwrng rng;
    + struct device *dev;
    +};
    +
    +int ele_trng_init(struct device *dev)
    +{
    + struct ele_trng *trng;
    + int ret;
    +
    + trng = devm_kzalloc(dev, sizeof(*trng), GFP_KERNEL);
    + if (!trng)
    + return -ENOMEM;
    +
    + trng->dev = dev;
    + trng->rng.name = "ele-trng";
    + trng->rng.read = ele_get_hwrng;
    + trng->rng.priv = (unsigned long)trng;
    + trng->rng.quality = 1024;
    +
    + dev_dbg(dev, "registering ele-trng\n");
    +
    + ret = devm_hwrng_register(dev, &trng->rng);
    + if (ret)
    + return ret;
    +
    + dev_info(dev, "Successfully registered ele-trng\n");
    + return 0;
    +}
    +
    +int ele_get_hwrng(struct hwrng *rng,
    + void *data, size_t len, bool wait)
    +{
    + struct ele_trng *trng = (struct ele_trng *)rng->priv;
    +
    + return ele_get_random(trng->dev, data, len);
    +}
    diff --git a/drivers/firmware/imx/se_fw.c b/drivers/firmware/imx/se_fw.c
    index 88300c41d62b..6083c42dcda3 100644
    --- a/drivers/firmware/imx/se_fw.c
    +++ b/drivers/firmware/imx/se_fw.c
    @@ -21,10 +21,10 @@
    #include <linux/of_reserved_mem.h>
    #include <linux/platform_device.h>
    #include <linux/slab.h>
    -#include <linux/delay.h>
    #include <linux/sys_soc.h>

    #include "se_fw.h"
    +#include "ele_common.h"

    #define SOC_ID_OF_IMX8ULP 0x084D
    #define SOC_ID_OF_IMX93 0x9300
    @@ -43,6 +43,9 @@ struct imx_info {
    uint8_t *pool_name;
    bool reserved_dma_ranges;
    bool init_fw;
    + /* platform specific flag to enable/disable the ELE True RNG */
    + bool start_rng;
    + bool enable_ele_trng;
    };

    static LIST_HEAD(priv_data_list);
    @@ -58,6 +61,8 @@ static const struct imx_info imx8ulp_info = {
    .pool_name = "sram-pool",
    .reserved_dma_ranges = true,
    .init_fw = false,
    + .start_rng = true,
    + .enable_ele_trng = false,
    };

    static const struct imx_info imx93_info = {
    @@ -71,6 +76,8 @@ static const struct imx_info imx93_info = {
    .pool_name = NULL,
    .reserved_dma_ranges = true,
    .init_fw = true,
    + .start_rng = true,
    + .enable_ele_trng = true,
    };

    static const struct of_device_id se_fw_match[] = {
    @@ -1140,9 +1147,23 @@ static int se_fw_probe(struct platform_device *pdev)
    }
    }

    + /* start ele rng */
    + if (info->start_rng) {
    + ret = ele_do_start_rng(dev);
    + if (ret)
    + dev_err(dev, "Failed to start ele rng\n");
    + }
    +
    + if (!ret && info->enable_ele_trng) {
    + ret = ele_trng_init(dev);
    + if (ret)
    + dev_err(dev, "Failed to init ele-trng\n");
    + }
    +
    pr_info("i.MX secure-enclave: %s's mu#%d interface to firmware, configured.\n",
    info->se_name,
    priv->ele_mu_id);
    +
    return devm_of_platform_populate(dev);

    exit:
    diff --git a/include/linux/firmware/imx/ele_base_msg.h b/include/linux/firmware/imx/ele_base_msg.h
    index 9c05936ba813..8a5c385210fc 100644
    --- a/include/linux/firmware/imx/ele_base_msg.h
    +++ b/include/linux/firmware/imx/ele_base_msg.h
    @@ -28,10 +28,21 @@
    #define ELE_GET_INFO_REQ 0xDA
    #define ELE_GET_INFO_REQ_MSG_SZ 0x02

    +#define ELE_START_RNG_REQ 0xA3
    +#define ELE_START_RNG_REQ_MSG_SZ 0x02
    +
    +#define ELE_GET_TRNG_STATE_REQ 0xA4
    +#define ELE_GET_TRNG_STATE_REQ_MSG_SZ 0x03
    +#define ELE_TRNG_STATE_OK 0x203
    +#define ELE_GET_TRNG_STATE_RETRY_COUNT 0x5
    +#define CSAL_TRNG_STATE_MASK 0x0000ffff
    +
    #define ELE_BASE_API_VERSION 0x6
    #define ELE_SUCCESS_IND 0xD6
    #define ELE_FAILURE_IND 0x29

    int ele_get_info(struct device *dev, phys_addr_t addr, u32 data_size);
    +int ele_start_rng(struct device *dev);
    +int ele_get_trng_state(struct device *dev);

    #endif
    diff --git a/include/linux/firmware/imx/ele_fw_api.h b/include/linux/firmware/imx/ele_fw_api.h
    index 36c3f743cb38..5e640148e211 100644
    --- a/include/linux/firmware/imx/ele_fw_api.h
    +++ b/include/linux/firmware/imx/ele_fw_api.h
    @@ -13,7 +13,12 @@
    #define ELE_INIT_FW_REQ 0x17
    #define ELE_INIT_FW_RSP_SZ 0x2

    +#define ELE_GET_RANDOM_REQ 0xCD
    +#define ELE_GET_RANDOM_REQ_SZ 0x2
    +

    int ele_init_fw(struct device *dev);
    +int ele_get_random(struct device *dev, void *data, size_t len);
    +int ele_get_hwrng(struct hwrng *rng, void *data, size_t len, bool wait);

    #endif /* ELE_FW_API_H */
    --
    2.34.1
    \
     
     \ /
      Last update: 2023-08-23 09:37    [W:4.347 / U:0.312 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site