armv8: cavium: Add an implementation of ATF calling functions

This commit adds functions issuing calls to the product-specific ATF
services

Signed-off-by: Sergey Temerkhanov <s.temerkhanov@gmail.com>
Signed-off-by: Radha Mohan Chintakuntla <rchintakuntla@cavium.com>

diff --git a/board/cavium/thunderx/Makefile b/board/cavium/thunderx/Makefile
index 306044a64abaa94c276c2df8b58555a78aab84c0..c78c414cdfc8182a7a4f530795bc2f95ffcc7ed0 100644 (file)
--- a/board/cavium/thunderx/Makefile
+++ b/board/cavium/thunderx/Makefile
@@ -5,4 +5,4 @@
 # SPDX-License-Identifier:     GPL-2.0+
 #
 
-obj-y  := thunderx.o
+obj-y  := thunderx.o atf.o

diff --git a/board/cavium/thunderx/atf.c b/board/cavium/thunderx/atf.c
new file mode 100644 (file)
index 0000000..6ab9de9
--- /dev/null
+++ b/board/cavium/thunderx/atf.c
@@ -0,0 +1,312 @@
+/**
+ * (C) Copyright 2014, Cavium Inc.
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+**/
+
+#include <common.h>
+#include <asm/io.h>
+
+#include <asm/system.h>
+#include <cavium/thunderx_svc.h>
+#include <cavium/atf.h>
+#include <cavium/atf_part.h>
+
+#include <asm/psci.h>
+
+#include <malloc.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+ssize_t atf_read_mmc(uintptr_t offset, void *buffer, size_t size)
+{
+       struct pt_regs regs;
+       regs.regs[0] = THUNDERX_MMC_READ;
+       regs.regs[1] = offset;
+       regs.regs[2] = size;
+       regs.regs[3] = (uintptr_t)buffer;
+
+       smc_call(&regs);
+
+       return regs.regs[0];
+}
+
+ssize_t atf_read_nor(uintptr_t offset, void *buffer, size_t size)
+{
+       struct pt_regs regs;
+       regs.regs[0] = THUNDERX_NOR_READ;
+       regs.regs[1] = offset;
+       regs.regs[2] = size;
+       regs.regs[3] = (uintptr_t)buffer;
+
+       smc_call(&regs);
+
+       return regs.regs[0];
+}
+
+ssize_t atf_get_pcount(void)
+{
+       struct pt_regs regs;
+       regs.regs[0] = THUNDERX_PART_COUNT;
+
+       smc_call(&regs);
+
+       return regs.regs[0];
+}
+
+ssize_t atf_get_part(struct storage_partition *part, unsigned int index)
+{
+       struct pt_regs regs;
+       regs.regs[0] = THUNDERX_GET_PART;
+       regs.regs[1] = (uintptr_t)part;
+       regs.regs[2] = index;
+
+       smc_call(&regs);
+
+       return regs.regs[0];
+}
+
+ssize_t atf_erase_nor(uintptr_t offset, size_t size)
+{
+       struct pt_regs regs;
+
+       regs.regs[0] = THUNDERX_NOR_ERASE;
+       regs.regs[1] = offset;
+
+       smc_call(&regs);
+
+       return regs.regs[0];
+}
+
+ssize_t atf_write_nor(uintptr_t offset, const void *buffer, size_t size)
+{
+       struct pt_regs regs;
+
+       regs.regs[0] = THUNDERX_NOR_WRITE;
+       regs.regs[1] = offset;
+       regs.regs[2] = size;
+       regs.regs[3] = (uintptr_t)buffer;
+
+       smc_call(&regs);
+
+       return regs.regs[0];
+}
+
+ssize_t atf_write_mmc(uintptr_t offset, const void *buffer, size_t size)
+{
+       struct pt_regs regs;
+
+       regs.regs[0] = THUNDERX_MMC_WRITE;
+       regs.regs[1] = offset;
+       regs.regs[2] = size;
+       regs.regs[3] = (uintptr_t)buffer;
+
+       smc_call(&regs);
+
+       return regs.regs[0];
+}
+
+ssize_t atf_dram_size(unsigned int node)
+{
+       struct pt_regs regs;
+       regs.regs[0] = THUNDERX_DRAM_SIZE;
+       regs.regs[1] = node;
+
+       smc_call(&regs);
+
+       return regs.regs[0];
+}
+
+ssize_t atf_node_count(void)
+{
+       struct pt_regs regs;
+       regs.regs[0] = THUNDERX_NODE_COUNT;
+
+       smc_call(&regs);
+
+       return regs.regs[0];
+}
+
+ssize_t atf_env_count(void)
+{
+       struct pt_regs regs;
+       regs.regs[0] = THUNDERX_ENV_COUNT;
+
+       smc_call(&regs);
+
+       return regs.regs[0];
+}
+
+ssize_t atf_env_string(size_t index, char *str)
+{
+       uint64_t *buf = (void *)str;
+       struct pt_regs regs;
+       regs.regs[0] = THUNDERX_ENV_STRING;
+       regs.regs[1] = index;
+
+       smc_call(&regs);
+
+       if (regs.regs > 0) {
+               buf[0] = regs.regs[0];
+               buf[1] = regs.regs[1];
+               buf[2] = regs.regs[2];
+               buf[3] = regs.regs[3];
+
+               return 1;
+       } else {
+               return regs.regs[0];
+       }
+}
+
+#ifdef CONFIG_CMD_ATF
+
+static void atf_print_ver(void)
+{
+       struct pt_regs regs;
+       regs.regs[0] = ARM_STD_SVC_VERSION;
+
+       smc_call(&regs);
+
+       printf("ARM Std FW version: %ld.%ld\n", regs.regs[0], regs.regs[1]);
+
+       regs.regs[0] = THUNDERX_SVC_VERSION;
+
+       smc_call(&regs);
+
+       printf("ThunderX OEM ver: %ld.%ld\n", regs.regs[0], regs.regs[1]);
+}
+
+static void atf_print_uid(void)
+{
+}
+
+static void atf_print_part_table(void)
+{
+       size_t pcount;
+       unsigned long i;
+       int ret;
+       char *ptype;
+
+       struct storage_partition *part = (void *)CONFIG_SYS_LOWMEM_BASE;
+
+       pcount = atf_get_pcount();
+
+       printf("Partition count: %lu\n\n", pcount);
+       printf("%10s %10s %10s\n", "Type", "Size", "Offset");
+
+       for (i = 0; i < pcount; i++) {
+               ret = atf_get_part(part, i);
+
+               if (ret < 0) {
+                       printf("Uknown error while reading partition: %d\n",
+                              ret);
+                       return;
+               }
+
+               switch (part->type) {
+               case PARTITION_NBL1FW_REST:
+                       ptype = "NBL1FW";
+                       break;
+               case PARTITION_BL2_BL31:
+                       ptype = "BL2_BL31";
+                       break;
+               case PARTITION_UBOOT:
+                       ptype = "BOOTLDR";
+                       break;
+               case PARTITION_KERNEL:
+                       ptype = "KERNEL";
+                       break;
+               case PARTITION_DEVICE_TREE:
+                       ptype = "DEVTREE";
+                       break;
+               default:
+                       ptype = "UNKNOWN";
+               }
+               printf("%10s %10d %10lx\n", ptype, part->size, part->offset);
+       }
+}
+
+int do_atf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+       ssize_t ret;
+       size_t size, offset;
+       void *buffer = 0;
+       unsigned int index, node;
+       char str[4 * sizeof(uint64_t)];
+
+       if ((argc == 5) && !strcmp(argv[1], "readmmc")) {
+               buffer = (void *)simple_strtoul(argv[2], NULL, 16);
+               offset = simple_strtoul(argv[3], NULL, 10);
+               size = simple_strtoul(argv[4], NULL, 10);
+
+               ret = atf_read_mmc(offset, buffer, size);
+       } else if ((argc == 5) && !strcmp(argv[1], "readnor")) {
+               buffer = (void *)simple_strtoul(argv[2], NULL, 16);
+               offset = simple_strtoul(argv[3], NULL, 10);
+               size = simple_strtoul(argv[4], NULL, 10);
+
+               ret = atf_read_nor(offset, buffer, size);
+       } else if ((argc == 5) && !strcmp(argv[1], "writemmc")) {
+               buffer = (void *)simple_strtoul(argv[2], NULL, 16);
+               offset = simple_strtoul(argv[3], NULL, 10);
+               size = simple_strtoul(argv[4], NULL, 10);
+
+               ret = atf_write_mmc(offset, buffer, size);
+       } else if ((argc == 5) && !strcmp(argv[1], "writenor")) {
+               buffer = (void *)simple_strtoul(argv[2], NULL, 16);
+               offset = simple_strtoul(argv[3], NULL, 10);
+               size = simple_strtoul(argv[4], NULL, 10);
+
+               ret = atf_write_nor(offset, buffer, size);
+       } else if ((argc == 2) && !strcmp(argv[1], "part")) {
+               atf_print_part_table();
+       } else if ((argc == 4) && !strcmp(argv[1], "erasenor")) {
+               offset = simple_strtoul(argv[2], NULL, 10);
+               size = simple_strtoul(argv[3], NULL, 10);
+
+               ret = atf_erase_nor(offset, size);
+       } else if ((argc == 2) && !strcmp(argv[1], "envcount")) {
+               ret = atf_env_count();
+               printf("Number of environment strings: %zd\n", ret);
+       } else if ((argc == 3) && !strcmp(argv[1], "envstring")) {
+               index = simple_strtoul(argv[2], NULL, 10);
+               ret = atf_env_string(index, str);
+               if (ret > 0)
+                       printf("Environment string %d: %s\n", index, str);
+               else
+                       printf("Return code: %zd\n", ret);
+       } else if ((argc == 3) && !strcmp(argv[1], "dramsize")) {
+               node = simple_strtoul(argv[2], NULL, 10);
+               ret = atf_dram_size(node);
+               printf("DRAM size: %zd Mbytes\n", ret >> 20);
+       } else if ((argc == 2) && !strcmp(argv[1], "nodes")) {
+               ret = atf_node_count();
+               printf("Nodes count: %zd\n", ret);
+       } else if ((argc == 2) && !strcmp(argv[1], "ver")) {
+               atf_print_ver();
+       } else if ((argc == 2) && !strcmp(argv[1], "uid")) {
+               atf_print_uid();
+       } else {
+               return CMD_RET_USAGE;
+       }
+
+       return 0;
+}
+
+U_BOOT_CMD(
+       atf,   10,   1,     do_atf,
+       "issue calls to ATF",
+       "\t readmmc addr offset size - read MMC card\n"
+       "\t readnor addr offset size - read NOR flash\n"
+       "\t writemmc addr offset size - write MMC card\n"
+       "\t writenor addr offset size - write NOR flash\n"
+       "\t erasenor offset size - erase NOR flash\n"
+       "\t nodes - number of nodes\n"
+       "\t dramsize node - size of DRAM attached to node\n"
+       "\t envcount - number of environment strings\n"
+       "\t envstring index - print the environment string\n"
+       "\t part - print MMC partition table\n"
+       "\t ver - print ATF call set versions\n"
+);
+
+#endif

diff --git a/include/cavium/atf.h b/include/cavium/atf.h
new file mode 100644 (file)
index 0000000..0a53c2f
--- /dev/null
+++ b/include/cavium/atf.h
@@ -0,0 +1,22 @@
+/**
+ * (C) Copyright 2014, Cavium Inc.
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+**/
+#ifndef __ATF_H__
+#define __ATF_H__
+#include <cavium/atf_part.h>
+
+ssize_t atf_read_mmc(uintptr_t offset, void *buffer, size_t size);
+ssize_t atf_read_nor(uintptr_t offset, void *buffer, size_t size);
+ssize_t atf_get_pcount(void);
+ssize_t atf_get_part(struct storage_partition *part, unsigned int index);
+ssize_t atf_erase_nor(uintptr_t offset, size_t size);
+ssize_t atf_write_nor(uintptr_t offset, const void *buffer, size_t size);
+ssize_t atf_write_mmc(uintptr_t offset, const void *buffer, size_t size);
+ssize_t atf_dram_size(unsigned int node);
+ssize_t atf_node_count(void);
+ssize_t atf_env_count(void);
+ssize_t atf_env_string(size_t index, char *str);
+
+#endif

diff --git a/include/cavium/atf_part.h b/include/cavium/atf_part.h
new file mode 100644 (file)
index 0000000..182f6f4
--- /dev/null
+++ b/include/cavium/atf_part.h
@@ -0,0 +1,26 @@
+/**
+ * (C) Copyright 2014, Cavium Inc.
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+**/
+
+#ifndef __ATF_PART_H__
+#define __ATF_PART_H__
+
+struct storage_partition {
+       unsigned int type;
+       unsigned int size;
+       unsigned long offset;
+};
+
+enum {
+       PARTITION_NBL1FW_REST = 0,
+       PARTITION_BL2_BL31 = 1,
+       PARTITION_UBOOT = 2,
+       PARTITION_UEFI = 2,
+       PARTITION_KERNEL = 3,
+       PARTITION_DEVICE_TREE = 4,
+       PARTITION_LAST,
+};
+
+#endif

diff --git a/include/cavium/thunderx_svc.h b/include/cavium/thunderx_svc.h
new file mode 100644 (file)
index 0000000..416ce3c
--- /dev/null
+++ b/include/cavium/thunderx_svc.h
@@ -0,0 +1,67 @@
+/**
+ * (C) Copyright 2014, Cavium Inc.
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+**/
+
+#ifndef __THUNDERX_SVC_H__
+#define __THUNDERX_SVC_H__
+
+/* SMC function IDs for general purpose queries */
+
+#define THUNDERX_SVC_CALL_COUNT                0x4300ff00
+#define THUNDERX_SVC_UID               0x4300ff01
+
+#define THUNDERX_SVC_VERSION           0x4300ff03
+
+#define ARM_STD_SVC_VERSION            0x8400ff03
+
+/* ThunderX Service Calls version numbers */
+#define THUNDERX_VERSION_MAJOR 0x0
+#define THUNDERX_VERSION_MINOR 0x1
+
+#define THUNDERX_MMC_READ              0x43000101
+/* x1 - block address
+ * x2 - size
+ * x3 - buffer address
+ */
+#define THUNDERX_MMC_WRITE             0x43000102
+/* x1 - block address
+ * x2 - size
+ * x3 - buffer address
+ */
+
+#define THUNDERX_NOR_READ              0x43000111
+/* x1 - block address
+ * x2 - size
+ * x3 - buffer address
+ */
+#define THUNDERX_NOR_WRITE             0x43000112
+/* x1 - block address
+ * x2 - size
+ * x3 - buffer address
+ */
+#define THUNDERX_NOR_ERASE             0x43000113
+/* x1 - block address
+ */
+
+#define THUNDERX_PART_COUNT            0x43000201
+#define THUNDERX_GET_PART              0x43000202
+/* x1 - pointer to the buffer
+ * x2 - index
+ */
+
+#define THUNDERX_DRAM_SIZE             0x43000301
+/* x1 - node number
+ */
+
+#define THUNDERX_GTI_SYNC              0x43000401
+
+#define THUNDERX_ENV_COUNT             0x43000501
+#define THUNDERX_ENV_STRING            0x43000502
+/* x1 - index
+ */
+
+#define THUNDERX_NODE_COUNT            0x43000601
+
+#endif /* __THUNDERX_SVC_H__ */

diff --git a/include/configs/thunderx_88xx.h b/include/configs/thunderx_88xx.h
index 9bd26dc7aa735db8fe3597233524ef195a137d28..cece4ddbcf256d19bc1db33df68d2a32859ee896 100644 (file)
--- a/include/configs/thunderx_88xx.h
+++ b/include/configs/thunderx_88xx.h
@@ -26,6 +26,8 @@
 
 #define CONFIG_SYS_FULL_VA
 
+#define CONFIG_SYS_LOWMEM_BASE         MEM_BASE
+
 #define CONFIG_SYS_MEM_MAP             {{0x000000000000UL, 0x40000000000UL, \
                                          PTL2_MEMTYPE(MT_NORMAL) |          \
                                          PTL2_BLOCK_NON_SHARE},             \