Hi Pierre,
On Apr 24, 2014, at 11:30 AM, Pierre Aubert wrote:
> This patch adds functions for read, write and authentication
> key programming for the Replay Protected Memory Block partition
> in the eMMC.
>
> Signed-off-by: Pierre Aubert <p.aub...@staubli.com>
> CC: Pantelis Antoniou <pa...@antoniou-consulting.com>
> ---
> Changes in V5:
> - move changelog to the right place
> - change lib/Makefile for adding sha256 when CONFIG_SUPPORT_EMMC_RPMB is
> defined
>
> V3, V4: no changes
>
> Changes in V2:
> - use ALLOC_CACHE_ALIGN_BUFFER in rpmb.c instead of a static buffer for the
> RPMB frames.
>
> drivers/mmc/Makefile | 1 +
> drivers/mmc/rpmb.c | 323 ++++++++++++++++++++++++++++++++++++++++++++++++++
> include/mmc.h | 10 ++-
> lib/Makefile | 1 +
> 4 files changed, 334 insertions(+), 1 deletions(-)
> create mode 100644 drivers/mmc/rpmb.c
>
> diff --git a/drivers/mmc/Makefile b/drivers/mmc/Makefile
> index 931922b..4c6ab9e 100644
> --- a/drivers/mmc/Makefile
> +++ b/drivers/mmc/Makefile
> @@ -30,6 +30,7 @@ obj-$(CONFIG_DWMMC) += dw_mmc.o
> obj-$(CONFIG_EXYNOS_DWMMC) += exynos_dw_mmc.o
> obj-$(CONFIG_ZYNQ_SDHCI) += zynq_sdhci.o
> obj-$(CONFIG_SOCFPGA_DWMMC) += socfpga_dw_mmc.o
> +obj-$(CONFIG_SUPPORT_EMMC_RPMB) += rpmb.o
> ifdef CONFIG_SPL_BUILD
> obj-$(CONFIG_SPL_MMC_BOOT) += fsl_esdhc_spl.o
> else
> diff --git a/drivers/mmc/rpmb.c b/drivers/mmc/rpmb.c
> new file mode 100644
> index 0000000..05936f5
> --- /dev/null
> +++ b/drivers/mmc/rpmb.c
> @@ -0,0 +1,323 @@
> +/*
> + * Copyright 2014, Staubli Faverges
> + * Pierre Aubert
> + *
> + * eMMC- Replay Protected Memory Block
> + * According to JEDEC Standard No. 84-A441
> + *
> + * SPDX-License-Identifier: GPL-2.0+
> + */
> +
> +#include <config.h>
> +#include <common.h>
> +#include <mmc.h>
> +#include <sha256.h>
> +#include "mmc_private.h"
> +
> +/* Request codes */
> +#define RPMB_REQ_KEY 1
> +#define RPMB_REQ_WCOUNTER 2
> +#define RPMB_REQ_WRITE_DATA 3
> +#define RPMB_REQ_READ_DATA 4
> +#define RPMB_REQ_STATUS 5
> +
> +/* Response code */
> +#define RPMB_RESP_KEY 0x0100
> +#define RPMB_RESP_WCOUNTER 0x0200
> +#define RPMB_RESP_WRITE_DATA 0x0300
> +#define RPMB_RESP_READ_DATA 0x0400
> +
> +/* Error codes */
> +#define RPMB_OK 0
> +#define RPMB_ERR_GENERAL 1
> +#define RPMB_ERR_AUTH 2
> +#define RPMB_ERR_COUNTER 3
> +#define RPMB_ERR_ADDRESS 4
> +#define RPMB_ERR_WRITE 5
> +#define RPMB_ERR_READ 6
> +#define RPMB_ERR_KEY 7
> +#define RPMB_ERR_CNT_EXPIRED 0x80
> +#define RPMB_ERR_MSK 0x7
> +
> +/* Sizes of RPMB data frame */
> +#define RPMB_SZ_STUFF 196
> +#define RPMB_SZ_MAC 32
> +#define RPMB_SZ_DATA 256
> +#define RPMB_SZ_NONCE 16
> +
> +#define SHA256_BLOCK_SIZE 64
> +
> +/* Error messages */
> +static const char * const rpmb_err_msg[] = {
> + "",
> + "General failure",
> + "Authentication failure",
> + "Counter failure",
> + "Address failure",
> + "Write failure",
> + "Read failure",
> + "Authentication key not yet programmed",
> +};
> +
> +
> +/* Structure of RPMB data frame. */
> +struct s_rpmb {
> + unsigned char stuff[RPMB_SZ_STUFF];
> + unsigned char mac[RPMB_SZ_MAC];
> + unsigned char data[RPMB_SZ_DATA];
> + unsigned char nonce[RPMB_SZ_NONCE];
> + unsigned long write_counter;
> + unsigned short address;
> + unsigned short block_count;
> + unsigned short result;
> + unsigned short request;
> +};
> +
> +static int mmc_set_blockcount(struct mmc *mmc, unsigned int blockcount,
> + bool is_rel_write)
> +{
> + struct mmc_cmd cmd = {0};
> +
> + cmd.cmdidx = MMC_CMD_SET_BLOCK_COUNT;
> + cmd.cmdarg = blockcount & 0x0000FFFF;
> + if (is_rel_write)
> + cmd.cmdarg |= 1 << 31;
> + cmd.resp_type = MMC_RSP_R1;
> +
> + return mmc_send_cmd(mmc, &cmd, NULL);
> +}
> +static int mmc_rpmb_request(struct mmc *mmc, const struct s_rpmb *s,
> + unsigned int count, bool is_rel_write)
> +{
> + struct mmc_cmd cmd = {0};
> + struct mmc_data data;
> + int ret;
> +
> + ret = mmc_set_blockcount(mmc, count, is_rel_write);
> + if (ret) {
> +#ifdef CONFIG_MMC_RPMB_TRACE
> + printf("%s:mmc_set_blockcount-> %d\n", __func__, ret);
> +#endif
> + return 1;
> + }
> +
> + cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
> + cmd.cmdarg = 0;
> + cmd.resp_type = MMC_RSP_R1b;
> +
> + data.src = (const char *)s;
> + data.blocks = 1;
> + data.blocksize = MMC_MAX_BLOCK_LEN;
> + data.flags = MMC_DATA_WRITE;
> +
> + ret = mmc_send_cmd(mmc, &cmd, &data);
> + if (ret) {
> +#ifdef CONFIG_MMC_RPMB_TRACE
> + printf("%s:mmc_send_cmd-> %d\n", __func__, ret);
> +#endif
> + return 1;
> + }
> + return 0;
> +}
> +static int mmc_rpmb_response(struct mmc *mmc, struct s_rpmb *s,
> + unsigned short expected)
> +{
> + struct mmc_cmd cmd = {0};
> + struct mmc_data data;
> + int ret;
> +
> + ret = mmc_set_blockcount(mmc, 1, false);
> + if (ret) {
> +#ifdef CONFIG_MMC_RPMB_TRACE
> + printf("%s:mmc_set_blockcount-> %d\n", __func__, ret);
> +#endif
> + return -1;
> + }
> + cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK;
> + cmd.cmdarg = 0;
> + cmd.resp_type = MMC_RSP_R1;
> +
> + data.dest = (char *)s;
> + data.blocks = 1;
> + data.blocksize = MMC_MAX_BLOCK_LEN;
> + data.flags = MMC_DATA_READ;
> +
> + ret = mmc_send_cmd(mmc, &cmd, &data);
> + if (ret) {
> +#ifdef CONFIG_MMC_RPMB_TRACE
> + printf("%s:mmc_send_cmd-> %d\n", __func__, ret);
> +#endif
> + return -1;
> + }
> + /* Check the response and the status */
> + if (be16_to_cpu(s->request) != expected) {
> +#ifdef CONFIG_MMC_RPMB_TRACE
> + printf("%s:response= %x\n", __func__,
> + be16_to_cpu(s->request));
> +#endif
> + return -1;
> + }
> + ret = be16_to_cpu(s->result);
> + if (ret) {
> + printf("%s %s\n", rpmb_err_msg[ret & RPMB_ERR_MSK],
> + (ret & RPMB_ERR_CNT_EXPIRED) ?
> + "Write counter has expired" : "");
> + }
> +
> + /* Return the status of the command */
> + return ret;
> +}
> +static int mmc_rpmb_status(struct mmc *mmc, unsigned short expected)
> +{
> + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1);
> +
> + memset(rpmb_frame, 0, sizeof(struct s_rpmb));
> + rpmb_frame->request = cpu_to_be16(RPMB_REQ_STATUS);
> + if (mmc_rpmb_request(mmc, rpmb_frame, 1, false))
> + return -1;
> +
> + /* Read the result */
> + return mmc_rpmb_response(mmc, rpmb_frame, expected);
> +}
> +static void rpmb_hmac(unsigned char *key, unsigned char *buff, int len,
> + unsigned char *output)
> +{
> + sha256_context ctx;
> + int i;
> + unsigned char k_ipad[SHA256_BLOCK_SIZE];
> + unsigned char k_opad[SHA256_BLOCK_SIZE];
> +
> + sha256_starts(&ctx);
> +
> + /* According to RFC 4634, the HMAC transform looks like:
> + SHA(K XOR opad, SHA(K XOR ipad, text))
> +
> + where K is an n byte key.
> + ipad is the byte 0x36 repeated blocksize times
> + opad is the byte 0x5c repeated blocksize times
> + and text is the data being protected.
> + */
> +
> + for (i = 0; i < RPMB_SZ_MAC; i++) {
> + k_ipad[i] = key[i] ^ 0x36;
> + k_opad[i] = key[i] ^ 0x5c;
> + }
> + /* remaining pad bytes are '\0' XOR'd with ipad and opad values */
> + for ( ; i < SHA256_BLOCK_SIZE; i++) {
> + k_ipad[i] = 0x36;
> + k_opad[i] = 0x5c;
> + }
> + sha256_update(&ctx, k_ipad, SHA256_BLOCK_SIZE);
> + sha256_update(&ctx, buff, len);
> + sha256_finish(&ctx, output);
> +
> + /* Init context for second pass */
> + sha256_starts(&ctx);
> +
> + /* start with outer pad */
> + sha256_update(&ctx, k_opad, SHA256_BLOCK_SIZE);
> +
> + /* then results of 1st hash */
> + sha256_update(&ctx, output, RPMB_SZ_MAC);
> +
> + /* finish up 2nd pass */
> + sha256_finish(&ctx, output);
> +}
> +int mmc_rpmb_get_counter(struct mmc *mmc, unsigned long *pcounter)
> +{
> + int ret;
> + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1);
> +
> + /* Fill the request */
> + memset(rpmb_frame, 0, sizeof(struct s_rpmb));
> + rpmb_frame->request = cpu_to_be16(RPMB_REQ_WCOUNTER);
> + if (mmc_rpmb_request(mmc, rpmb_frame, 1, false))
> + return -1;
> +
> + /* Read the result */
> + ret = mmc_rpmb_response(mmc, rpmb_frame, RPMB_RESP_WCOUNTER);
> + if (ret)
> + return ret;
> +
> + *pcounter = be32_to_cpu(rpmb_frame->write_counter);
> + return 0;
> +}
> +int mmc_rpmb_set_key(struct mmc *mmc, void *key)
> +{
> + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1);
> + /* Fill the request */
> + memset(rpmb_frame, 0, sizeof(struct s_rpmb));
> + rpmb_frame->request = cpu_to_be16(RPMB_REQ_KEY);
> + memcpy(rpmb_frame->mac, key, RPMB_SZ_MAC);
> +
> + if (mmc_rpmb_request(mmc, rpmb_frame, 1, true))
> + return -1;
> +
> + /* read the operation status */
> + return mmc_rpmb_status(mmc, RPMB_RESP_KEY);
> +}
> +int mmc_rpmb_read(struct mmc *mmc, void *addr, unsigned short blk,
> + unsigned short cnt, unsigned char *key)
> +{
> + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1);
> + int i;
> +
> + for (i = 0; i < cnt; i++) {
> + /* Fill the request */
> + memset(rpmb_frame, 0, sizeof(struct s_rpmb));
> + rpmb_frame->address = cpu_to_be16(blk + i);
> + rpmb_frame->request = cpu_to_be16(RPMB_REQ_READ_DATA);
> + if (mmc_rpmb_request(mmc, rpmb_frame, 1, false))
> + break;
> +
> + /* Read the result */
> + if (mmc_rpmb_response(mmc, rpmb_frame, RPMB_RESP_READ_DATA))
> + break;
> +
> + /* Check the HMAC if key is provided */
> + if (key) {
> + unsigned char ret_hmac[RPMB_SZ_MAC];
> +
> + rpmb_hmac(key, rpmb_frame->data, 284, ret_hmac);
> + if (memcmp(ret_hmac, rpmb_frame->mac, RPMB_SZ_MAC)) {
> + printf("MAC error on block #%d\n", i);
> + break;
> + }
> + }
> + /* Copy data */
> + memcpy(addr + i * RPMB_SZ_DATA, rpmb_frame->data, RPMB_SZ_DATA);
> + }
> + return i;
> +}
> +int mmc_rpmb_write(struct mmc *mmc, void *addr, unsigned short blk,
> + unsigned short cnt, unsigned char *key)
> +{
> + ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1);
> + unsigned long wcount;
> + int i;
> +
> + for (i = 0; i < cnt; i++) {
> + if (mmc_rpmb_get_counter(mmc, &wcount)) {
> + printf("Cannot read RPMB write counter\n");
> + break;
> + }
> +
> + /* Fill the request */
> + memset(rpmb_frame, 0, sizeof(struct s_rpmb));
> + memcpy(rpmb_frame->data, addr + i * RPMB_SZ_DATA, RPMB_SZ_DATA);
> + rpmb_frame->address = cpu_to_be16(blk + i);
> + rpmb_frame->block_count = cpu_to_be16(1);
> + rpmb_frame->write_counter = cpu_to_be32(wcount);
> + rpmb_frame->request = cpu_to_be16(RPMB_REQ_WRITE_DATA);
> + /* Computes HMAC */
> + rpmb_hmac(key, rpmb_frame->data, 284, rpmb_frame->mac);
> +
> + if (mmc_rpmb_request(mmc, rpmb_frame, 1, true))
> + break;
> +
> + /* Get status */
> + if (mmc_rpmb_status(mmc, RPMB_RESP_WRITE_DATA))
> + break;
> + }
> + return i;
> +}
> diff --git a/include/mmc.h b/include/mmc.h
> index 42d0125..14d296c 100644
> --- a/include/mmc.h
> +++ b/include/mmc.h
> @@ -69,6 +69,7 @@
> #define MMC_CMD_SET_BLOCKLEN 16
> #define MMC_CMD_READ_SINGLE_BLOCK 17
> #define MMC_CMD_READ_MULTIPLE_BLOCK 18
> +#define MMC_CMD_SET_BLOCK_COUNT 23
> #define MMC_CMD_WRITE_SINGLE_BLOCK 24
> #define MMC_CMD_WRITE_MULTIPLE_BLOCK 25
> #define MMC_CMD_ERASE_GROUP_START 35
> @@ -224,6 +225,7 @@
> * boot partitions (2), general purpose partitions (4) in MMC v4.4.
> */
> #define MMC_NUM_BOOT_PARTITION 2
> +#define MMC_PART_RPMB 3 /* RPMB partition number */
>
> struct mmc_cid {
> unsigned long psn;
> @@ -335,7 +337,13 @@ int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8
> part_num, u8 access);
> int mmc_set_boot_bus_width(struct mmc *mmc, u8 width, u8 reset, u8 mode);
> /* Function to modify the RST_n_FUNCTION field of EXT_CSD */
> int mmc_set_rst_n_function(struct mmc *mmc, u8 enable);
> -
> +/* Functions to read / write the RPMB partition */
> +int mmc_rpmb_set_key(struct mmc *mmc, void *key);
> +int mmc_rpmb_get_counter(struct mmc *mmc, unsigned long *counter);
> +int mmc_rpmb_read(struct mmc *mmc, void *addr, unsigned short blk,
> + unsigned short cnt, unsigned char *key);
> +int mmc_rpmb_write(struct mmc *mmc, void *addr, unsigned short blk,
> + unsigned short cnt, unsigned char *key);
> /**
> * Start device initialization and return immediately; it does not block on
> * polling OCR (operation condition register) status. Then you should call
> diff --git a/lib/Makefile b/lib/Makefile
> index 27e4f78..377ab13 100644
> --- a/lib/Makefile
> +++ b/lib/Makefile
> @@ -35,6 +35,7 @@ obj-y += net_utils.o
> obj-$(CONFIG_PHYSMEM) += physmem.o
> obj-y += qsort.o
> obj-$(CONFIG_SHA1) += sha1.o
> +obj-$(CONFIG_SUPPORT_EMMC_RPMB) += sha256.o
> obj-$(CONFIG_SHA256) += sha256.o
> obj-y += strmhz.o
> obj-$(CONFIG_TPM) += tpm.o
> --
> 1.7.6.5
>
Looks good.
Applied
Thanks
-- Pantelis
Acked-by: Pantelis Antoniou <pa...@antoniou-consulting.com>
> _______________________________________________
> U-Boot mailing list
> U-Boot@lists.denx.de
> http://lists.denx.de/mailman/listinfo/u-boot
_______________________________________________
U-Boot mailing list
U-Boot@lists.denx.de
http://lists.denx.de/mailman/listinfo/u-boot
