svn commit: r257673 - in head/sys/arm: arm include
Ian Lepore
ian at FreeBSD.org
Tue Nov 5 04:30:56 UTC 2013
Author: ian
Date: Tue Nov 5 04:30:55 2013
New Revision: 257673
URL: http://svnweb.freebsd.org/changeset/base/257673
Log:
Add new helper routines for arm static device mapping. The new code
allocates kva space from the top down for the device mappings and builds
entries in an internal table which is automatically used later by
arm_devmap_bootstrap(). The platform code just calls the new
arm_devmap_add_entry() function as many times as it needs to (up to 32
entries allowed; most platforms use 2 or 3 at most).
There is also a new arm_devmap_lastaddr() function that returns the lowest
kva address allocated; this can be used to implement initarm_lastaddr()
which is used to initialize vm_max_kernel_address.
The new code is based on a similar concept developed for the imx family
SoCs recently. They will soon be converted to use this new common code.
Modified:
head/sys/arm/arm/devmap.c
head/sys/arm/include/devmap.h
Modified: head/sys/arm/arm/devmap.c
==============================================================================
--- head/sys/arm/arm/devmap.c Tue Nov 5 04:06:29 2013 (r257672)
+++ head/sys/arm/arm/devmap.c Tue Nov 5 04:30:55 2013 (r257673)
@@ -36,9 +36,88 @@ __FBSDID("$FreeBSD$");
#include <vm/vm.h>
#include <vm/vm_extern.h>
#include <vm/pmap.h>
+#include <machine/armreg.h>
#include <machine/devmap.h>
static const struct arm_devmap_entry *devmap_table;
+static boolean_t devmap_bootstrap_done = false;
+
+/*
+ * The allocated-kva (akva) devmap table and metadata. Platforms can call
+ * arm_devmap_add_entry() to add static device mappings to this table using
+ * automatically allocated virtual addresses carved out of the top of kva space.
+ * Allocation begins immediately below the ARM_VECTORS_HIGH address.
+ */
+#define AKVA_DEVMAP_MAX_ENTRIES 32
+static struct arm_devmap_entry akva_devmap_entries[AKVA_DEVMAP_MAX_ENTRIES];
+static u_int akva_devmap_idx;
+static vm_offset_t akva_devmap_vaddr = ARM_VECTORS_HIGH;
+
+/*
+ * Return the "last" kva address used by the registered devmap table. It's
+ * actually the lowest address used by the static mappings, i.e., the address of
+ * the first unusable byte of KVA.
+ */
+vm_offset_t
+arm_devmap_lastaddr()
+{
+ const struct arm_devmap_entry *pd;
+ vm_offset_t lowaddr = ARM_VECTORS_HIGH;
+
+ if (akva_devmap_idx > 0)
+ return (akva_devmap_vaddr);
+
+ if (devmap_table == NULL)
+ panic("arm_devmap_lastaddr(): No devmap table registered.");
+
+ for (pd = devmap_table; pd->pd_size != 0; ++pd) {
+ if (lowaddr > pd->pd_va)
+ lowaddr = pd->pd_va;
+ }
+
+ return (lowaddr);
+}
+
+/*
+ * Add an entry to the internal "akva" static devmap table using the given
+ * physical address and size and a virtual address allocated from the top of
+ * kva. This automatically registers the akva table on the first call, so all a
+ * platform has to do is call this routine to install as many mappings as it
+ * needs and when initarm() calls arm_devmap_bootstrap() it will pick up all the
+ * entries in the akva table automatically.
+ */
+void
+arm_devmap_add_entry(vm_paddr_t pa, vm_size_t sz)
+{
+ struct arm_devmap_entry *m;
+
+ if (devmap_bootstrap_done)
+ panic("arm_devmap_add_entry() after arm_devmap_bootstrap()");
+
+ if (akva_devmap_idx == (AKVA_DEVMAP_MAX_ENTRIES - 1))
+ panic("AKVA_DEVMAP_MAX_ENTRIES is too small!\n");
+
+ if (akva_devmap_idx == 0)
+ arm_devmap_register_table(akva_devmap_entries);
+
+ /*
+ * Allocate virtual address space from the top of kva downwards. If the
+ * range being mapped is aligned and sized to 1MB boundaries then also
+ * align the virtual address to the next-lower 1MB boundary so that we
+ * end up with a nice efficient section mapping.
+ */
+ if ((pa & 0x000fffff) == 0 && (sz & 0x000fffff) == 0) {
+ akva_devmap_vaddr = trunc_1mpage(akva_devmap_vaddr - sz);
+ } else {
+ akva_devmap_vaddr = trunc_page(akva_devmap_vaddr - sz);
+ }
+ m = &akva_devmap_entries[akva_devmap_idx++];
+ m->pd_va = akva_devmap_vaddr;
+ m->pd_pa = pa;
+ m->pd_size = sz;
+ m->pd_prot = VM_PROT_READ | VM_PROT_WRITE;
+ m->pd_cache = PTE_DEVICE;
+}
/*
* Register the given table as the one to use in arm_devmap_bootstrap().
@@ -73,12 +152,14 @@ arm_devmap_bootstrap(vm_offset_t l1pt, c
if (table != NULL)
devmap_table = table;
else if (devmap_table == NULL)
- panic("arm_devmap_bootstrap: No devmap table registered.");
+ panic("arm_devmap_bootstrap(): No devmap table registered.");
for (pd = devmap_table; pd->pd_size != 0; ++pd) {
pmap_map_chunk(l1pt, pd->pd_va, pd->pd_pa, pd->pd_size,
pd->pd_prot,pd->pd_cache);
}
+
+ devmap_bootstrap_done = true;
}
/*
Modified: head/sys/arm/include/devmap.h
==============================================================================
--- head/sys/arm/include/devmap.h Tue Nov 5 04:06:29 2013 (r257672)
+++ head/sys/arm/include/devmap.h Tue Nov 5 04:30:55 2013 (r257673)
@@ -42,6 +42,22 @@ struct arm_devmap_entry {
};
/*
+ * Returns the lowest KVA address used in any entry in the registered devmap
+ * table. This works with whatever table is registered, including the internal
+ * table used by arm_devmap_add_entry() if that routinue was used. Platforms can
+ * implement initarm_lastaddr() by calling this if static device mappings are
+ * their only use of high KVA space.
+ */
+vm_offset_t arm_devmap_lastaddr(void);
+
+/*
+ * Routine to automatically allocate KVA (from the top of the address space
+ * downwards) and make static device mapping entries in an internal table. The
+ * internal table is automatically registered on the first call to this.
+ */
+void arm_devmap_add_entry(vm_paddr_t pa, vm_size_t sz);
+
+/*
* Register a platform-local table to be bootstrapped by the generic
* initarm() in arm/machdep.c. This is used by newer code that allocates and
* fills in its own local table but does not have its own initarm() routine.
@@ -49,9 +65,10 @@ struct arm_devmap_entry {
void arm_devmap_register_table(const struct arm_devmap_entry * _table);
/*
- * Directly process a table; called from initarm() of older platforms that don't
- * use the generic initarm() in arm/machdep.c. If the table pointer is NULL,
- * this will use the table installed previously by arm_devmap_register_table().
+ * Establish mappings for all the entries in the table. This is called
+ * automatically from the common initarm() in arm/machdep.c, and also from the
+ * custom initarm() routines in older code. If the table pointer is NULL, this
+ * will use the table installed previously by arm_devmap_register_table().
*/
void arm_devmap_bootstrap(vm_offset_t _l1pt,
const struct arm_devmap_entry *_table);
More information about the svn-src-head
mailing list