[PATCH 29/52] mips: octeon: Add cvmx-global-resource.c
Stefan Roese
sr at denx.de
Wed Mar 30 12:07:05 CEST 2022
From: Aaron Williams <awilliams at marvell.com>
Import cvmx-global-resource.c from 2013 U-Boot. It will be used by the later
added drivers to support networking on the MIPS Octeon II / III
platforms.
Signed-off-by: Aaron Williams <awilliams at marvell.com>
Signed-off-by: Stefan Roese <sr at denx.de>
---
arch/mips/mach-octeon/cvmx-global-resources.c | 639 ++++++++++++++++++
1 file changed, 639 insertions(+)
create mode 100644 arch/mips/mach-octeon/cvmx-global-resources.c
diff --git a/arch/mips/mach-octeon/cvmx-global-resources.c b/arch/mips/mach-octeon/cvmx-global-resources.c
new file mode 100644
index 000000000000..14a2ed524714
--- /dev/null
+++ b/arch/mips/mach-octeon/cvmx-global-resources.c
@@ -0,0 +1,639 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2018-2022 Marvell International Ltd.
+ *
+ */
+
+#include <log.h>
+#include <time.h>
+#include <linux/delay.h>
+
+#include <mach/cvmx-regs.h>
+#include <mach/cvmx-csr.h>
+#include <mach/cvmx-bootmem.h>
+#include <mach/octeon-model.h>
+#include <mach/cvmx-fuse.h>
+#include <mach/octeon-feature.h>
+#include <mach/cvmx-qlm.h>
+#include <mach/octeon_qlm.h>
+#include <mach/cvmx-pcie.h>
+#include <mach/cvmx-coremask.h>
+#include <mach/cvmx-range.h>
+
+#include <mach/cvmx-global-resources.h>
+#include <mach/cvmx-bootmem.h>
+
+#include <mach/cvmx-pki.h>
+#include <mach/cvmx-helper.h>
+#include <mach/cvmx-helper-board.h>
+#include <mach/cvmx-helper-cfg.h>
+
+#define CVMX_MAX_GLOBAL_RESOURCES 128
+#define CVMX_RESOURCES_ENTRIES_SIZE \
+ (sizeof(struct cvmx_global_resource_entry) * CVMX_MAX_GLOBAL_RESOURCES)
+
+/**
+ * This macro returns a member of the data
+ * structure. The argument "field" is the member name of the
+ * structure to read. The return type is a u64.
+ */
+#define CVMX_GLOBAL_RESOURCES_GET_FIELD(field) \
+ __cvmx_struct_get_unsigned_field( \
+ __cvmx_global_resources_addr, \
+ offsetof(struct cvmx_global_resources, field), \
+ SIZEOF_FIELD(struct cvmx_global_resources, field))
+
+/**
+ * This macro writes a member of the struct cvmx_global_resourcest
+ * structure. The argument "field" is the member name of the
+ * struct cvmx_global_resources to write.
+ */
+#define CVMX_GLOBAL_RESOURCES_SET_FIELD(field, value) \
+ __cvmx_struct_set_unsigned_field( \
+ __cvmx_global_resources_addr, \
+ offsetof(struct cvmx_global_resources, field), \
+ SIZEOF_FIELD(struct cvmx_global_resources, field), value)
+
+/**
+ * This macro returns a member of the struct cvmx_global_resource_entry.
+ * The argument "field" is the member name of this structure.
+ * the return type is a u64. The "addr" parameter is the physical
+ * address of the structure.
+ */
+#define CVMX_RESOURCE_ENTRY_GET_FIELD(addr, field) \
+ __cvmx_struct_get_unsigned_field( \
+ addr, offsetof(struct cvmx_global_resource_entry, field), \
+ SIZEOF_FIELD(struct cvmx_global_resource_entry, field))
+
+/**
+ * This macro writes a member of the struct cvmx_global_resource_entry
+ * structure. The argument "field" is the member name of the
+ * struct cvmx_global_resource_entry to write. The "addr" parameter
+ * is the physical address of the structure.
+ */
+#define CVMX_RESOURCE_ENTRY_SET_FIELD(addr, field, value) \
+ __cvmx_struct_set_unsigned_field( \
+ addr, offsetof(struct cvmx_global_resource_entry, field), \
+ SIZEOF_FIELD(struct cvmx_global_resource_entry, field), value)
+
+#define CVMX_GET_RESOURCE_ENTRY(count) \
+ (__cvmx_global_resources_addr + \
+ offsetof(struct cvmx_global_resources, resource_entry) + \
+ (count * sizeof(struct cvmx_global_resource_entry)))
+
+#define CVMX_RESOURCE_TAG_SET_FIELD(addr, field, value) \
+ __cvmx_struct_set_unsigned_field( \
+ addr, offsetof(struct global_resource_tag, field), \
+ SIZEOF_FIELD(struct global_resource_tag, field), value)
+
+#define CVMX_RESOURCE_TAG_GET_FIELD(addr, field) \
+ __cvmx_struct_get_unsigned_field( \
+ addr, offsetof(struct global_resource_tag, field), \
+ SIZEOF_FIELD(struct global_resource_tag, field))
+
+#define MAX_RESOURCE_TAG_LEN 16
+#define CVMX_GLOBAL_RESOURCE_NO_LOCKING (1)
+
+struct cvmx_global_resource_entry {
+ struct global_resource_tag tag;
+ u64 phys_addr;
+ u64 size;
+};
+
+struct cvmx_global_resources {
+ u32 pad;
+ u32 rlock;
+ u64 entry_cnt;
+ struct cvmx_global_resource_entry resource_entry[];
+};
+
+/* Not the right place, putting it here for now */
+int cvmx_enable_helper_flag;
+u64 cvmx_app_id;
+
+/*
+ * Global named memory can be accessed anywhere even in 32-bit mode
+ */
+static u64 __cvmx_global_resources_addr;
+
+/**
+ * This macro returns the size of a member of a structure.
+ */
+#define SIZEOF_FIELD(s, field) sizeof(((s *)NULL)->field)
+
+/**
+ * This function is the implementation of the get macros defined
+ * for individual structure members. The argument are generated
+ * by the macros inorder to read only the needed memory.
+ *
+ * @param base 64bit physical address of the complete structure
+ * @param offset from the beginning of the structure to the member being
+ * accessed.
+ * @param size Size of the structure member.
+ *
+ * @return Value of the structure member promoted into a u64.
+ */
+static inline u64 __cvmx_struct_get_unsigned_field(u64 base, int offset,
+ int size)
+{
+ base = (1ull << 63) | (base + offset);
+ switch (size) {
+ case 4:
+ return cvmx_read64_uint32(base);
+ case 8:
+ return cvmx_read64_uint64(base);
+ default:
+ return 0;
+ }
+}
+
+/**
+ * This function is the implementation of the set macros defined
+ * for individual structure members. The argument are generated
+ * by the macros in order to write only the needed memory.
+ *
+ * @param base 64bit physical address of the complete structure
+ * @param offset from the beginning of the structure to the member being
+ * accessed.
+ * @param size Size of the structure member.
+ * @param value Value to write into the structure
+ */
+static inline void __cvmx_struct_set_unsigned_field(u64 base, int offset,
+ int size, u64 value)
+{
+ base = (1ull << 63) | (base + offset);
+ switch (size) {
+ case 4:
+ cvmx_write64_uint32(base, value);
+ break;
+ case 8:
+ cvmx_write64_uint64(base, value);
+ break;
+ default:
+ break;
+ }
+}
+
+/* Get the global resource lock. */
+static inline void __cvmx_global_resource_lock(void)
+{
+ u64 lock_addr =
+ (1ull << 63) | (__cvmx_global_resources_addr +
+ offsetof(struct cvmx_global_resources, rlock));
+ unsigned int tmp;
+
+ __asm__ __volatile__(".set noreorder\n"
+ "1: ll %[tmp], 0(%[addr])\n"
+ " bnez %[tmp], 1b\n"
+ " li %[tmp], 1\n"
+ " sc %[tmp], 0(%[addr])\n"
+ " beqz %[tmp], 1b\n"
+ " nop\n"
+ ".set reorder\n"
+ : [tmp] "=&r"(tmp)
+ : [addr] "r"(lock_addr)
+ : "memory");
+}
+
+/* Release the global resource lock. */
+static inline void __cvmx_global_resource_unlock(void)
+{
+ u64 lock_addr =
+ (1ull << 63) | (__cvmx_global_resources_addr +
+ offsetof(struct cvmx_global_resources, rlock));
+ CVMX_SYNCW;
+ __asm__ __volatile__("sw $0, 0(%[addr])\n"
+ :
+ : [addr] "r"(lock_addr)
+ : "memory");
+ CVMX_SYNCW;
+}
+
+static u64 __cvmx_alloc_bootmem_for_global_resources(int sz)
+{
+ void *tmp;
+
+ tmp = cvmx_bootmem_alloc_range(sz, CVMX_CACHE_LINE_SIZE, 0, 0);
+ return cvmx_ptr_to_phys(tmp);
+}
+
+static inline void __cvmx_get_tagname(struct global_resource_tag *rtag,
+ char *tagname)
+{
+ int i, j, k;
+
+ j = 0;
+ k = 8;
+ for (i = 7; i >= 0; i--, j++, k++) {
+ tagname[j] = (rtag->lo >> (i * 8)) & 0xff;
+ tagname[k] = (rtag->hi >> (i * 8)) & 0xff;
+ }
+}
+
+static u64 __cvmx_global_resources_init(void)
+{
+ struct cvmx_bootmem_named_block_desc *block_desc;
+ int sz = sizeof(struct cvmx_global_resources) +
+ CVMX_RESOURCES_ENTRIES_SIZE;
+ s64 tmp_phys;
+ int count = 0;
+ u64 base = 0;
+
+ cvmx_bootmem_lock();
+
+ block_desc = (struct cvmx_bootmem_named_block_desc *)
+ __cvmx_bootmem_find_named_block_flags(
+ CVMX_GLOBAL_RESOURCES_DATA_NAME,
+ CVMX_BOOTMEM_FLAG_NO_LOCKING);
+ if (!block_desc) {
+ debug("%s: allocating global resources\n", __func__);
+
+ tmp_phys = cvmx_bootmem_phy_named_block_alloc(
+ sz, 0, 0, CVMX_CACHE_LINE_SIZE,
+ CVMX_GLOBAL_RESOURCES_DATA_NAME,
+ CVMX_BOOTMEM_FLAG_NO_LOCKING);
+ if (tmp_phys < 0) {
+ cvmx_printf(
+ "ERROR: %s: failed to allocate global resource name block. sz=%d\n",
+ __func__, sz);
+ goto end;
+ }
+ __cvmx_global_resources_addr = (u64)tmp_phys;
+
+ debug("%s: memset global resources %llu\n", __func__,
+ CAST_ULL(__cvmx_global_resources_addr));
+
+ base = (1ull << 63) | __cvmx_global_resources_addr;
+ for (count = 0; count < (sz / 8); count++) {
+ cvmx_write64_uint64(base, 0);
+ base += 8;
+ }
+ } else {
+ debug("%s:found global resource\n", __func__);
+ __cvmx_global_resources_addr = block_desc->base_addr;
+ }
+end:
+ cvmx_bootmem_unlock();
+ debug("__cvmx_global_resources_addr=%llu sz=%d\n",
+ CAST_ULL(__cvmx_global_resources_addr), sz);
+ return __cvmx_global_resources_addr;
+}
+
+u64 cvmx_get_global_resource(struct global_resource_tag tag, int no_lock)
+{
+ u64 entry_cnt = 0;
+ u64 resource_entry_addr = 0;
+ int count = 0;
+ u64 rphys_addr = 0;
+ u64 tag_lo = 0, tag_hi = 0;
+
+ if (__cvmx_global_resources_addr == 0)
+ __cvmx_global_resources_init();
+ if (!no_lock)
+ __cvmx_global_resource_lock();
+
+ entry_cnt = CVMX_GLOBAL_RESOURCES_GET_FIELD(entry_cnt);
+ while (entry_cnt > 0) {
+ resource_entry_addr = CVMX_GET_RESOURCE_ENTRY(count);
+ tag_lo = CVMX_RESOURCE_TAG_GET_FIELD(resource_entry_addr, lo);
+ tag_hi = CVMX_RESOURCE_TAG_GET_FIELD(resource_entry_addr, hi);
+
+ if (tag_lo == tag.lo && tag_hi == tag.hi) {
+ debug("%s: Found global resource entry\n", __func__);
+ break;
+ }
+ entry_cnt--;
+ count++;
+ }
+
+ if (entry_cnt == 0) {
+ debug("%s: no matching global resource entry found\n",
+ __func__);
+ if (!no_lock)
+ __cvmx_global_resource_unlock();
+ return 0;
+ }
+ rphys_addr =
+ CVMX_RESOURCE_ENTRY_GET_FIELD(resource_entry_addr, phys_addr);
+ if (!no_lock)
+ __cvmx_global_resource_unlock();
+
+ return rphys_addr;
+}
+
+u64 cvmx_create_global_resource(struct global_resource_tag tag, u64 size,
+ int no_lock, int *_new_)
+{
+ u64 entry_count = 0;
+ u64 resource_entry_addr = 0;
+ u64 phys_addr;
+
+ if (__cvmx_global_resources_addr == 0)
+ __cvmx_global_resources_init();
+
+ if (!no_lock)
+ __cvmx_global_resource_lock();
+
+ phys_addr =
+ cvmx_get_global_resource(tag, CVMX_GLOBAL_RESOURCE_NO_LOCKING);
+ if (phys_addr != 0) {
+ /* we already have the resource, return it */
+ *_new_ = 0;
+ goto end;
+ }
+
+ *_new_ = 1;
+ entry_count = CVMX_GLOBAL_RESOURCES_GET_FIELD(entry_cnt);
+ if (entry_count >= CVMX_MAX_GLOBAL_RESOURCES) {
+ char tagname[MAX_RESOURCE_TAG_LEN + 1];
+
+ __cvmx_get_tagname(&tag, tagname);
+ cvmx_printf(
+ "ERROR: %s: reached global resources limit for %s\n",
+ __func__, tagname);
+ phys_addr = 0;
+ goto end;
+ }
+
+ /* Allocate bootmem for the resource*/
+ phys_addr = __cvmx_alloc_bootmem_for_global_resources(size);
+ if (!phys_addr) {
+ char tagname[MAX_RESOURCE_TAG_LEN + 1];
+
+ __cvmx_get_tagname(&tag, tagname);
+ debug("ERROR: %s: out of memory %s, size=%d\n", __func__,
+ tagname, (int)size);
+ goto end;
+ }
+
+ resource_entry_addr = CVMX_GET_RESOURCE_ENTRY(entry_count);
+ CVMX_RESOURCE_ENTRY_SET_FIELD(resource_entry_addr, phys_addr,
+ phys_addr);
+ CVMX_RESOURCE_ENTRY_SET_FIELD(resource_entry_addr, size, size);
+ CVMX_RESOURCE_TAG_SET_FIELD(resource_entry_addr, lo, tag.lo);
+ CVMX_RESOURCE_TAG_SET_FIELD(resource_entry_addr, hi, tag.hi);
+ /* update entry_cnt */
+ entry_count += 1;
+ CVMX_GLOBAL_RESOURCES_SET_FIELD(entry_cnt, entry_count);
+
+end:
+ if (!no_lock)
+ __cvmx_global_resource_unlock();
+
+ return phys_addr;
+}
+
+int cvmx_create_global_resource_range(struct global_resource_tag tag,
+ int nelements)
+{
+ int sz = cvmx_range_memory_size(nelements);
+ int _new_;
+ u64 addr;
+ int rv = 0;
+
+ if (__cvmx_global_resources_addr == 0)
+ __cvmx_global_resources_init();
+
+ __cvmx_global_resource_lock();
+ addr = cvmx_create_global_resource(tag, sz, 1, &_new_);
+ if (!addr) {
+ __cvmx_global_resource_unlock();
+ return -1;
+ }
+ if (_new_)
+ rv = cvmx_range_init(addr, nelements);
+ __cvmx_global_resource_unlock();
+ return rv;
+}
+
+int cvmx_allocate_global_resource_range(struct global_resource_tag tag,
+ u64 owner, int nelements, int alignment)
+{
+ u64 addr = cvmx_get_global_resource(tag, 1);
+ int base;
+
+ if (addr == 0) {
+ char tagname[256];
+
+ __cvmx_get_tagname(&tag, tagname);
+ cvmx_printf("ERROR: %s: cannot find resource %s\n", __func__,
+ tagname);
+ return -1;
+ }
+ __cvmx_global_resource_lock();
+ base = cvmx_range_alloc(addr, owner, nelements, alignment);
+ __cvmx_global_resource_unlock();
+ return base;
+}
+
+int cvmx_resource_alloc_many(struct global_resource_tag tag, u64 owner,
+ int nelements, int allocated_elements[])
+{
+ u64 addr = cvmx_get_global_resource(tag, 1);
+ int rv;
+
+ if (addr == 0) {
+ char tagname[256];
+
+ __cvmx_get_tagname(&tag, tagname);
+ debug("ERROR: cannot find resource %s\n", tagname);
+ return -1;
+ }
+ __cvmx_global_resource_lock();
+ rv = cvmx_range_alloc_non_contiguos(addr, owner, nelements,
+ allocated_elements);
+ __cvmx_global_resource_unlock();
+ return rv;
+}
+
+int cvmx_resource_alloc_reverse(struct global_resource_tag tag, u64 owner)
+{
+ u64 addr = cvmx_get_global_resource(tag, 1);
+ int rv;
+
+ if (addr == 0) {
+ char tagname[256];
+
+ __cvmx_get_tagname(&tag, tagname);
+ debug("ERROR: cannot find resource %s\n", tagname);
+ return -1;
+ }
+ __cvmx_global_resource_lock();
+ rv = cvmx_range_alloc_ordered(addr, owner, 1, 1, 1);
+ __cvmx_global_resource_unlock();
+ return rv;
+}
+
+int cvmx_reserve_global_resource_range(struct global_resource_tag tag,
+ u64 owner, int base, int nelements)
+{
+ u64 addr = cvmx_get_global_resource(tag, 1);
+ int start;
+
+ __cvmx_global_resource_lock();
+ start = cvmx_range_reserve(addr, owner, base, nelements);
+ __cvmx_global_resource_unlock();
+ return start;
+}
+
+int cvmx_free_global_resource_range_with_base(struct global_resource_tag tag,
+ int base, int nelements)
+{
+ u64 addr = cvmx_get_global_resource(tag, 1);
+ int rv;
+
+ /* Resource was not created, nothing to release */
+ if (addr == 0)
+ return 0;
+
+ __cvmx_global_resource_lock();
+ rv = cvmx_range_free_with_base(addr, base, nelements);
+ __cvmx_global_resource_unlock();
+ return rv;
+}
+
+int cvmx_free_global_resource_range_multiple(struct global_resource_tag tag,
+ int bases[], int nelements)
+{
+ u64 addr = cvmx_get_global_resource(tag, 1);
+ int rv;
+
+ /* Resource was not created, nothing to release */
+ if (addr == 0)
+ return 0;
+
+ __cvmx_global_resource_lock();
+ rv = cvmx_range_free_mutiple(addr, bases, nelements);
+ __cvmx_global_resource_unlock();
+ return rv;
+}
+
+int cvmx_free_global_resource_range_with_owner(struct global_resource_tag tag,
+ int owner)
+{
+ u64 addr = cvmx_get_global_resource(tag, 1);
+ int rv;
+
+ /* Resource was not created, nothing to release */
+ if (addr == 0)
+ return 0;
+
+ __cvmx_global_resource_lock();
+ rv = cvmx_range_free_with_owner(addr, owner);
+ __cvmx_global_resource_unlock();
+ return rv;
+}
+
+void cvmx_show_global_resource_range(struct global_resource_tag tag)
+{
+ u64 addr = cvmx_get_global_resource(tag, 1);
+
+ cvmx_range_show(addr);
+}
+
+int free_global_resources(void)
+{
+ int rc;
+ int i, entry_cnt;
+ u64 resource_entry_addr, phys_addr, size;
+
+ if (__cvmx_global_resources_addr == 0)
+ __cvmx_global_resources_init();
+
+ __cvmx_global_resource_lock();
+
+ entry_cnt = CVMX_GLOBAL_RESOURCES_GET_FIELD(entry_cnt);
+
+ /* get and free all the global resources */
+ for (i = 0; i < entry_cnt; i++) {
+ resource_entry_addr = CVMX_GET_RESOURCE_ENTRY(i);
+ phys_addr = CVMX_RESOURCE_ENTRY_GET_FIELD(resource_entry_addr,
+ phys_addr);
+ size = CVMX_RESOURCE_ENTRY_GET_FIELD(resource_entry_addr, size);
+ /* free the resource */
+ rc = __cvmx_bootmem_phy_free(phys_addr, size, 0);
+ if (!rc) {
+ debug("ERROR: %s: could not free memory to bootmem\n",
+ __func__);
+ }
+ }
+
+ __cvmx_global_resource_unlock();
+
+ rc = cvmx_bootmem_free_named(CVMX_GLOBAL_RESOURCES_DATA_NAME);
+ debug("freed global resources named block rc=%d\n", rc);
+
+ __cvmx_global_resources_addr = 0;
+
+ return 0;
+}
+
+u64 cvmx_get_global_resource_owner(struct global_resource_tag tag, int base)
+{
+ u64 addr = cvmx_get_global_resource(tag, 1);
+
+ /* Resource was not created, return "available" special owner code */
+ if (addr == 0)
+ return -88LL;
+
+ return cvmx_range_get_owner(addr, base);
+}
+
+void cvmx_global_resources_show(void)
+{
+ u64 entry_cnt;
+ u64 p;
+ char tagname[MAX_RESOURCE_TAG_LEN + 1];
+ struct global_resource_tag rtag;
+ u64 count;
+ u64 phys_addr;
+
+ if (__cvmx_global_resources_addr == 0)
+ __cvmx_global_resources_init();
+
+ __cvmx_global_resource_lock();
+
+ entry_cnt = CVMX_GLOBAL_RESOURCES_GET_FIELD(entry_cnt);
+ memset(tagname, 0, MAX_RESOURCE_TAG_LEN + 1);
+
+ for (count = 0; count < entry_cnt; count++) {
+ p = CVMX_GET_RESOURCE_ENTRY(count);
+ phys_addr = CVMX_RESOURCE_ENTRY_GET_FIELD(p, phys_addr);
+ rtag.lo = CVMX_RESOURCE_TAG_GET_FIELD(p, lo);
+ rtag.hi = CVMX_RESOURCE_TAG_GET_FIELD(p, hi);
+ __cvmx_get_tagname(&rtag, tagname);
+ debug("Global Resource tag name: %s Resource Address: %llx\n",
+ tagname, CAST_ULL(phys_addr));
+ }
+ debug("<End of Global Resources>\n");
+ __cvmx_global_resource_unlock();
+}
+
+void cvmx_app_id_init(void *bootmem)
+{
+ u64 *p = (u64 *)bootmem;
+
+ *p = 0;
+}
+
+u64 cvmx_allocate_app_id(void)
+{
+ u64 *vptr;
+
+ vptr = (u64 *)cvmx_bootmem_alloc_named_range_once(sizeof(cvmx_app_id),
+ 0, 1 << 31, 128,
+ "cvmx_app_id",
+ cvmx_app_id_init);
+
+ cvmx_app_id = __atomic_add_fetch(vptr, 1, __ATOMIC_SEQ_CST);
+
+ debug("CVMX_APP_ID = %lx\n", (unsigned long)cvmx_app_id);
+ return cvmx_app_id;
+}
+
+u64 cvmx_get_app_id(void)
+{
+ if (cvmx_app_id == 0)
+ cvmx_allocate_app_id();
+ return cvmx_app_id;
+}
--
2.35.1
More information about the U-Boot
mailing list