svn commit: r201269 - in head/sys: conf ia64/ia64 ia64/include
Marcel Moolenaar
marcel at FreeBSD.org
Wed Dec 30 18:15:26 UTC 2009
Author: marcel
Date: Wed Dec 30 18:15:25 2009
New Revision: 201269
URL: http://svn.freebsd.org/changeset/base/201269
Log:
Revamp bus_space access functions:
o Optimize for memory mapped I/O by making all I/O port acceses function
calls and marking the test for the IA64_BUS_SPACE_IO tag with
__predict_false(). Implement the I/O port access functions in a new
file, called bus_machdep.c.
o Change the bus_space_handle_t for memory mapped I/O to the virtual
address rather than the physical address. This eliminates the PA->VA
translation for every I/O access. The handle for I/O port access is
still the port number.
o Move inb(), outb(), inw(), outw(), inl(), outl(), and their string
variants from cpufunc.h and define them in bus.h. On ia64 these are
not CPU functions at all. In bus.h they are merely aliases for the
new I/O port access functions defined in bus_machdep.h.
o Handle the ACPI resource bug in nexus_set_resource(). There we can
do it once so that we don't have to worry about it whenever we need
to write to an I/O port that is really a memory mapped address.
The upshot of this change is that the KBI is better defined and that I/O
port access always involves a function call, allowing us to change the
actual implementation without breaking the KBI. For memory mapped I/O the
virtual address is abstracted, so that we can change the VA->PA mapping
in the kernel without causing an KBI breakage. The exception at this time
is for bus_space_map() and bus_space_unmap().
MFC after: 1 week.
Added:
head/sys/ia64/ia64/bus_machdep.c (contents, props changed)
Modified:
head/sys/conf/files.ia64
head/sys/ia64/ia64/machdep.c
head/sys/ia64/ia64/mp_machdep.c
head/sys/ia64/ia64/nexus.c
head/sys/ia64/ia64/sys_machdep.c
head/sys/ia64/include/bus.h
head/sys/ia64/include/cpufunc.h
Modified: head/sys/conf/files.ia64
==============================================================================
--- head/sys/conf/files.ia64 Wed Dec 30 17:55:20 2009 (r201268)
+++ head/sys/conf/files.ia64 Wed Dec 30 18:15:25 2009 (r201269)
@@ -72,6 +72,7 @@ ia64/ia32/ia32_reg.c optional compat_ia
ia64/ia32/ia32_signal.c optional compat_ia32
ia64/ia32/ia32_trap.c optional compat_ia32
ia64/ia64/autoconf.c standard
+ia64/ia64/bus_machdep.c standard
ia64/ia64/busdma_machdep.c standard
ia64/ia64/clock.c standard
ia64/ia64/context.S standard
Added: head/sys/ia64/ia64/bus_machdep.c
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/sys/ia64/ia64/bus_machdep.c Wed Dec 30 18:15:25 2009 (r201269)
@@ -0,0 +1,356 @@
+/*-
+ * Copyright (c) 2009 Marcel Moolenaar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/types.h>
+#include <machine/bus.h>
+
+extern u_long ia64_port_base;
+
+#define __PIO_ADDR(port) \
+ (void *)(ia64_port_base | (((port) & 0xfffc) << 10) | ((port) & 0xFFF))
+
+uint8_t
+bus_space_read_io_1(u_long port)
+{
+ uint8_t v;
+
+ ia64_mf();
+ v = ia64_ld1(__PIO_ADDR(port));
+ ia64_mf_a();
+ ia64_mf();
+ return (v);
+}
+
+uint16_t
+bus_space_read_io_2(u_long port)
+{
+ uint16_t v;
+
+ ia64_mf();
+ v = ia64_ld2(__PIO_ADDR(port));
+ ia64_mf_a();
+ ia64_mf();
+ return (v);
+}
+
+uint32_t
+bus_space_read_io_4(u_long port)
+{
+ uint32_t v;
+
+ ia64_mf();
+ v = ia64_ld4(__PIO_ADDR(port));
+ ia64_mf_a();
+ ia64_mf();
+ return (v);
+}
+
+#if 0
+uint64_t
+bus_space_read_io_8(u_long port)
+{
+}
+#endif
+
+void
+bus_space_write_io_1(u_long port, uint8_t val)
+{
+
+ ia64_mf();
+ ia64_st1(__PIO_ADDR(port), val);
+ ia64_mf_a();
+ ia64_mf();
+}
+
+void
+bus_space_write_io_2(u_long port, uint16_t val)
+{
+
+ ia64_mf();
+ ia64_st2(__PIO_ADDR(port), val);
+ ia64_mf_a();
+ ia64_mf();
+}
+
+void
+bus_space_write_io_4(u_long port, uint32_t val)
+{
+
+ ia64_mf();
+ ia64_st4(__PIO_ADDR(port), val);
+ ia64_mf_a();
+ ia64_mf();
+}
+
+#if 0
+void
+bus_space_write_io_8(u_long port, uint64_t val)
+{
+}
+#endif
+
+void
+bus_space_read_multi_io_1(u_long port, uint8_t *ptr, size_t count)
+{
+
+ while (count-- > 0)
+ *ptr++ = bus_space_read_io_1(port);
+}
+
+void
+bus_space_read_multi_io_2(u_long port, uint16_t *ptr, size_t count)
+{
+
+ while (count-- > 0)
+ *ptr++ = bus_space_read_io_2(port);
+}
+
+void
+bus_space_read_multi_io_4(u_long port, uint32_t *ptr, size_t count)
+{
+
+ while (count-- > 0)
+ *ptr++ = bus_space_read_io_4(port);
+}
+
+#if 0
+void
+bus_space_read_multi_io_8(u_long port, uint64_t *ptr, size_t count)
+{
+}
+#endif
+
+void
+bus_space_write_multi_io_1(u_long port, const uint8_t *ptr, size_t count)
+{
+
+ while (count-- > 0)
+ bus_space_write_io_1(port, *ptr++);
+}
+
+void
+bus_space_write_multi_io_2(u_long port, const uint16_t *ptr, size_t count)
+{
+
+ while (count-- > 0)
+ bus_space_write_io_2(port, *ptr++);
+}
+
+void
+bus_space_write_multi_io_4(u_long port, const uint32_t *ptr, size_t count)
+{
+
+ while (count-- > 0)
+ bus_space_write_io_4(port, *ptr++);
+}
+
+#if 0
+void
+bus_space_write_multi_io_8(u_long port, const uint64_t *ptr, size_t count)
+{
+}
+#endif
+
+void
+bus_space_read_region_io_1(u_long port, uint8_t *ptr, size_t count)
+{
+
+ while (count-- > 0) {
+ *ptr++ = bus_space_read_io_1(port);
+ port += 1;
+ }
+}
+
+void
+bus_space_read_region_io_2(u_long port, uint16_t *ptr, size_t count)
+{
+
+ while (count-- > 0) {
+ *ptr++ = bus_space_read_io_2(port);
+ port += 2;
+ }
+}
+
+void
+bus_space_read_region_io_4(u_long port, uint32_t *ptr, size_t count)
+{
+
+ while (count-- > 0) {
+ *ptr++ = bus_space_read_io_4(port);
+ port += 4;
+ }
+}
+
+#if 0
+void bus_space_read_region_io_8(u_long, uint64_t *, size_t);
+#endif
+
+void
+bus_space_write_region_io_1(u_long port, const uint8_t *ptr, size_t count)
+{
+
+ while (count-- > 0) {
+ bus_space_write_io_1(port, *ptr++);
+ port += 1;
+ }
+}
+
+void
+bus_space_write_region_io_2(u_long port, const uint16_t *ptr, size_t count)
+{
+
+ while (count-- > 0) {
+ bus_space_write_io_2(port, *ptr++);
+ port += 2;
+ }
+}
+
+void
+bus_space_write_region_io_4(u_long port, const uint32_t *ptr, size_t count)
+{
+
+ while (count-- > 0) {
+ bus_space_write_io_4(port, *ptr++);
+ port += 4;
+ }
+}
+
+#if 0
+void
+bus_space_write_region_io_8(u_long port, const uint64_t *ptr, size_t count)
+{
+}
+#endif
+
+void
+bus_space_set_region_io_1(u_long port, uint8_t val, size_t count)
+{
+
+ while (count-- > 0) {
+ bus_space_write_io_1(port, val);
+ port += 1;
+ }
+}
+
+void
+bus_space_set_region_io_2(u_long port, uint16_t val, size_t count)
+{
+
+ while (count-- > 0) {
+ bus_space_write_io_2(port, val);
+ port += 2;
+ }
+}
+
+void
+bus_space_set_region_io_4(u_long port, uint32_t val, size_t count)
+{
+
+ while (count-- > 0) {
+ bus_space_write_io_4(port, val);
+ port += 4;
+ }
+}
+
+#if 0
+void
+bus_space_set_region_io_8(u_long port, uint64_t val, size_t count)
+{
+}
+#endif
+
+void
+bus_space_copy_region_io_1(u_long src, u_long dst, size_t count)
+{
+ long delta;
+ uint8_t val;
+
+ if (src < dst) {
+ src += count - 1;
+ dst += count - 1;
+ delta = -1;
+ } else
+ delta = 1;
+
+ while (count-- > 0) {
+ val = bus_space_read_io_1(src);
+ bus_space_write_io_1(dst, val);
+ src += delta;
+ dst += delta;
+ }
+}
+
+void
+bus_space_copy_region_io_2(u_long src, u_long dst, size_t count)
+{
+ long delta;
+ uint16_t val;
+
+ if (src < dst) {
+ src += 2 * (count - 1);
+ dst += 2 * (count - 1);
+ delta = -2;
+ } else
+ delta = 2;
+
+ while (count-- > 0) {
+ val = bus_space_read_io_2(src);
+ bus_space_write_io_2(dst, val);
+ src += delta;
+ dst += delta;
+ }
+}
+
+void
+bus_space_copy_region_io_4(u_long src, u_long dst, size_t count)
+{
+ long delta;
+ uint32_t val;
+
+ if (src < dst) {
+ src += 4 * (count - 1);
+ dst += 4 * (count - 1);
+ delta = -4;
+ } else
+ delta = 4;
+
+ while (count-- > 0) {
+ val = bus_space_read_io_4(src);
+ bus_space_write_io_4(dst, val);
+ src += delta;
+ dst += delta;
+ }
+}
+
+#if 0
+void
+bus_space_copy_region_io_8(u_long src, u_long dst, size_t count)
+{
+}
+#endif
Modified: head/sys/ia64/ia64/machdep.c
==============================================================================
--- head/sys/ia64/ia64/machdep.c Wed Dec 30 17:55:20 2009 (r201268)
+++ head/sys/ia64/ia64/machdep.c Wed Dec 30 18:15:25 2009 (r201269)
@@ -930,16 +930,6 @@ ia64_init(void)
return (ret);
}
-void *
-ia64_ioport_address(u_int port)
-{
- uint64_t addr;
-
- addr = (port > 0xffff) ? IA64_PHYS_TO_RR6((uint64_t)port) :
- ia64_port_base | ((port & 0xfffc) << 10) | (port & 0xFFF);
- return ((void *)addr);
-}
-
uint64_t
ia64_get_hcdp(void)
{
Modified: head/sys/ia64/ia64/mp_machdep.c
==============================================================================
--- head/sys/ia64/ia64/mp_machdep.c Wed Dec 30 17:55:20 2009 (r201268)
+++ head/sys/ia64/ia64/mp_machdep.c Wed Dec 30 18:15:25 2009 (r201269)
@@ -366,7 +366,7 @@ ipi_send(struct pcpu *cpu, int ipi)
volatile uint64_t *pipi;
uint64_t vector;
- pipi = __MEMIO_ADDR(ia64_lapic_address |
+ pipi = (void *)IA64_PHYS_TO_RR6(ia64_lapic_address |
((cpu->pc_md.lid & LID_SAPIC_MASK) >> 12));
vector = (uint64_t)(ipi_vector[ipi] & 0xff);
KASSERT(vector != 0, ("IPI %d is not assigned a vector", ipi));
Modified: head/sys/ia64/ia64/nexus.c
==============================================================================
--- head/sys/ia64/ia64/nexus.c Wed Dec 30 17:55:20 2009 (r201268)
+++ head/sys/ia64/ia64/nexus.c Wed Dec 30 18:15:25 2009 (r201269)
@@ -389,26 +389,23 @@ nexus_alloc_resource(device_t bus, devic
static int
nexus_activate_resource(device_t bus, device_t child, int type, int rid,
- struct resource *r)
+ struct resource *r)
{
- vm_paddr_t paddr, psize;
+ vm_paddr_t paddr;
void *vaddr;
- /*
- * If this is a memory resource, map it into the kernel.
- */
+ paddr = rman_get_start(r);
+
switch (type) {
case SYS_RES_IOPORT:
rman_set_bustag(r, IA64_BUS_SPACE_IO);
- rman_set_bushandle(r, rman_get_start(r));
+ rman_set_bushandle(r, paddr);
break;
case SYS_RES_MEMORY:
- paddr = rman_get_start(r);
- psize = rman_get_size(r);
- vaddr = pmap_mapdev(paddr, psize);
- rman_set_virtual(r, vaddr);
+ vaddr = pmap_mapdev(paddr, rman_get_size(r));
rman_set_bustag(r, IA64_BUS_SPACE_MEM);
- rman_set_bushandle(r, (bus_space_handle_t) paddr);
+ rman_set_bushandle(r, (bus_space_handle_t) vaddr);
+ rman_set_virtual(r, vaddr);
break;
}
return (rman_activate_resource(r));
@@ -488,11 +485,27 @@ nexus_get_reslist(device_t dev, device_t
}
static int
-nexus_set_resource(device_t dev, device_t child, int type, int rid, u_long start, u_long count)
+nexus_set_resource(device_t dev, device_t child, int type, int rid,
+ u_long start, u_long count)
{
struct nexus_device *ndev = DEVTONX(child);
struct resource_list *rl = &ndev->nx_resources;
+ if (type == SYS_RES_IOPORT && start > (0x10000 - count)) {
+ /*
+ * Work around a firmware bug in the HP rx2660, where in ACPI
+ * an I/O port is really a memory mapped I/O address. The bug
+ * is in the GAS that describes the address and in particular
+ * the SpaceId field. The field should not say the address is
+ * an I/O port when it is in fact an I/O memory address.
+ */
+ if (bootverbose)
+ printf("%s: invalid port range (%#lx-%#lx); "
+ "assuming I/O memory range.\n", __func__, start,
+ start + count - 1);
+ type = SYS_RES_MEMORY;
+ }
+
/* XXX this should return a success/failure indicator */
resource_list_add(rl, type, rid, start, start + count - 1, count);
return(0);
Modified: head/sys/ia64/ia64/sys_machdep.c
==============================================================================
--- head/sys/ia64/ia64/sys_machdep.c Wed Dec 30 17:55:20 2009 (r201268)
+++ head/sys/ia64/ia64/sys_machdep.c Wed Dec 30 18:15:25 2009 (r201269)
@@ -35,6 +35,7 @@ __FBSDID("$FreeBSD$");
#include <sys/sysproto.h>
#include <sys/sysent.h>
+#include <machine/bus.h>
#include <machine/cpu.h>
#include <machine/sysarch.h>
Modified: head/sys/ia64/include/bus.h
==============================================================================
--- head/sys/ia64/include/bus.h Wed Dec 30 17:55:20 2009 (r201268)
+++ head/sys/ia64/include/bus.h Wed Dec 30 18:15:25 2009 (r201269)
@@ -1,3 +1,29 @@
+/*-
+ * Copyright (c) 2009 Marcel Moolenaar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
/* $NetBSD: bus.h,v 1.12 1997/10/01 08:25:15 fvdl Exp $ */
/*-
@@ -76,11 +102,25 @@
#include <machine/cpufunc.h>
/*
+ * I/O port reads with ia32 semantics.
+ */
+#define inb bus_space_read_io_1
+#define inw bus_space_read_io_2
+#define inl bus_space_read_io_4
+
+#define outb bus_space_write_io_1
+#define outw bus_space_write_io_2
+#define outl bus_space_write_io_4
+
+/*
* Values for the ia64 bus space tag, not to be used directly by MI code.
*/
#define IA64_BUS_SPACE_IO 0 /* space is i/o space */
#define IA64_BUS_SPACE_MEM 1 /* space is mem space */
+#define BUS_SPACE_BARRIER_READ 0x01 /* force read barrier */
+#define BUS_SPACE_BARRIER_WRITE 0x02 /* force write barrier */
+
#define BUS_SPACE_MAXSIZE_24BIT 0xFFFFFF
#define BUS_SPACE_MAXSIZE_32BIT 0xFFFFFFFF
#define BUS_SPACE_MAXSIZE 0xFFFFFFFFFFFFFFFF
@@ -90,24 +130,21 @@
#define BUS_SPACE_UNRESTRICTED (~0)
+
/*
* Map a region of device bus space into CPU virtual address space.
*/
-
-static __inline int bus_space_map(bus_space_tag_t t, bus_addr_t addr,
- bus_size_t size, int flags,
- bus_space_handle_t *bshp);
-
static __inline int
-bus_space_map(bus_space_tag_t t __unused, bus_addr_t addr,
- bus_size_t size __unused, int flags __unused,
- bus_space_handle_t *bshp)
+bus_space_map(bus_space_tag_t bst, bus_addr_t addr, bus_size_t size __unused,
+ int flags __unused, bus_space_handle_t *bshp)
{
- *bshp = addr;
+ *bshp = (__predict_false(bst == IA64_BUS_SPACE_IO))
+ ? addr : IA64_PHYS_TO_RR6(addr);
return (0);
}
+
/*
* Unmap a region of device bus space.
*/
@@ -123,7 +160,7 @@ bus_space_unmap(bus_space_tag_t bst __un
*/
static __inline int
bus_space_subregion(bus_space_tag_t bst, bus_space_handle_t bsh,
- bus_size_t ofs, bus_size_t size, bus_space_handle_t *nbshp)
+ bus_size_t ofs, bus_size_t size __unused, bus_space_handle_t *nbshp)
{
*nbshp = bsh + ofs;
return (0);
@@ -149,12 +186,9 @@ bus_space_free(bus_space_tag_t bst, bus_
/*
* Bus read/write barrier method.
*/
-#define BUS_SPACE_BARRIER_READ 0x01 /* force read barrier */
-#define BUS_SPACE_BARRIER_WRITE 0x02 /* force write barrier */
-
static __inline void
-bus_space_barrier(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs,
- bus_size_t size, int flags)
+bus_space_barrier(bus_space_tag_t bst __unused, bus_space_handle_t bsh __unused,
+ bus_size_t ofs __unused, bus_size_t size __unused, int flags __unused)
{
ia64_mf_a();
ia64_mf();
@@ -166,40 +200,53 @@ bus_space_barrier(bus_space_tag_t bst, b
* tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
* data is returned.
*/
+uint8_t bus_space_read_io_1(u_long);
+uint16_t bus_space_read_io_2(u_long);
+uint32_t bus_space_read_io_4(u_long);
+uint64_t bus_space_read_io_8(u_long);
+
static __inline uint8_t
bus_space_read_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs)
{
- uint8_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- return (ia64_ld1(bsp));
+ uint8_t val;
+
+ val = (__predict_false(bst == IA64_BUS_SPACE_IO))
+ ? bus_space_read_io_1(bsh + ofs)
+ : ia64_ld1((void *)(bsh + ofs));
+ return (val);
}
static __inline uint16_t
bus_space_read_2(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs)
{
- uint16_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- return (ia64_ld2(bsp));
+ uint16_t val;
+
+ val = (__predict_false(bst == IA64_BUS_SPACE_IO))
+ ? bus_space_read_io_2(bsh + ofs)
+ : ia64_ld2((void *)(bsh + ofs));
+ return (val);
}
static __inline uint32_t
bus_space_read_4(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs)
{
- uint32_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- return (ia64_ld4(bsp));
+ uint32_t val;
+
+ val = (__predict_false(bst == IA64_BUS_SPACE_IO))
+ ? bus_space_read_io_4(bsh + ofs)
+ : ia64_ld4((void *)(bsh + ofs));
+ return (val);
}
static __inline uint64_t
bus_space_read_8(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs)
{
- uint64_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- return (ia64_ld8(bsp));
+ uint64_t val;
+
+ val = (__predict_false(bst == IA64_BUS_SPACE_IO))
+ ? bus_space_read_io_8(bsh + ofs)
+ : ia64_ld8((void *)(bsh + ofs));
+ return (val);
}
@@ -208,44 +255,53 @@ bus_space_read_8(bus_space_tag_t bst, bu
* tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
* data is passed by value.
*/
+void bus_space_write_io_1(u_long, uint8_t);
+void bus_space_write_io_2(u_long, uint16_t);
+void bus_space_write_io_4(u_long, uint32_t);
+void bus_space_write_io_8(u_long, uint64_t);
+
static __inline void
bus_space_write_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs,
uint8_t val)
{
- uint8_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- ia64_st1(bsp, val);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_write_io_1(bsh + ofs, val);
+ else
+ ia64_st1((void *)(bsh + ofs), val);
}
static __inline void
bus_space_write_2(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs,
uint16_t val)
{
- uint16_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- ia64_st2(bsp, val);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_write_io_2(bsh + ofs, val);
+ else
+ ia64_st2((void *)(bsh + ofs), val);
}
static __inline void
bus_space_write_4(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs,
uint32_t val)
{
- uint32_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- ia64_st4(bsp, val);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_write_io_4(bsh + ofs, val);
+ else
+ ia64_st4((void *)(bsh + ofs), val);
}
static __inline void
bus_space_write_8(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs,
uint64_t val)
{
- uint64_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- ia64_st8(bsp, val);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_write_io_8(bsh + ofs, val);
+ else
+ ia64_st8((void *)(bsh + ofs), val);
}
@@ -254,48 +310,61 @@ bus_space_write_8(bus_space_tag_t bst, b
* ofs tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
* data is returned in the buffer passed by reference.
*/
+void bus_space_read_multi_io_1(u_long, uint8_t *, size_t);
+void bus_space_read_multi_io_2(u_long, uint16_t *, size_t);
+void bus_space_read_multi_io_4(u_long, uint32_t *, size_t);
+void bus_space_read_multi_io_8(u_long, uint64_t *, size_t);
+
static __inline void
bus_space_read_multi_1(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, uint8_t *bufp, size_t count)
{
- uint8_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- while (count-- > 0)
- *bufp++ = ia64_ld1(bsp);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_read_multi_io_1(bsh + ofs, bufp, count);
+ else {
+ while (count-- > 0)
+ *bufp++ = ia64_ld1((void *)(bsh + ofs));
+ }
}
static __inline void
bus_space_read_multi_2(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, uint16_t *bufp, size_t count)
{
- uint16_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- while (count-- > 0)
- *bufp++ = ia64_ld2(bsp);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_read_multi_io_2(bsh + ofs, bufp, count);
+ else {
+ while (count-- > 0)
+ *bufp++ = ia64_ld2((void *)(bsh + ofs));
+ }
}
static __inline void
bus_space_read_multi_4(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, uint32_t *bufp, size_t count)
{
- uint32_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- while (count-- > 0)
- *bufp++ = ia64_ld4(bsp);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_read_multi_io_4(bsh + ofs, bufp, count);
+ else {
+ while (count-- > 0)
+ *bufp++ = ia64_ld4((void *)(bsh + ofs));
+ }
}
static __inline void
bus_space_read_multi_8(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, uint64_t *bufp, size_t count)
{
- uint64_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- while (count-- > 0)
- *bufp++ = ia64_ld8(bsp);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_read_multi_io_8(bsh + ofs, bufp, count);
+ else {
+ while (count-- > 0)
+ *bufp++ = ia64_ld8((void *)(bsh + ofs));
+ }
}
@@ -304,48 +373,61 @@ bus_space_read_multi_8(bus_space_tag_t b
* ofs tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
* data is read from the buffer passed by reference.
*/
+void bus_space_write_multi_io_1(u_long, const uint8_t *, size_t);
+void bus_space_write_multi_io_2(u_long, const uint16_t *, size_t);
+void bus_space_write_multi_io_4(u_long, const uint32_t *, size_t);
+void bus_space_write_multi_io_8(u_long, const uint64_t *, size_t);
+
static __inline void
bus_space_write_multi_1(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, const uint8_t *bufp, size_t count)
{
- uint8_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- while (count-- > 0)
- ia64_st1(bsp, *bufp++);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_write_multi_io_1(bsh + ofs, bufp, count);
+ else {
+ while (count-- > 0)
+ ia64_st1((void *)(bsh + ofs), *bufp++);
+ }
}
static __inline void
bus_space_write_multi_2(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, const uint16_t *bufp, size_t count)
{
- uint16_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- while (count-- > 0)
- ia64_st2(bsp, *bufp++);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_write_multi_io_2(bsh + ofs, bufp, count);
+ else {
+ while (count-- > 0)
+ ia64_st2((void *)(bsh + ofs), *bufp++);
+ }
}
static __inline void
bus_space_write_multi_4(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, const uint32_t *bufp, size_t count)
{
- uint32_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- while (count-- > 0)
- ia64_st4(bsp, *bufp++);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_write_multi_io_4(bsh + ofs, bufp, count);
+ else {
+ while (count-- > 0)
+ ia64_st4((void *)(bsh + ofs), *bufp++);
+ }
}
static __inline void
bus_space_write_multi_8(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, const uint64_t *bufp, size_t count)
{
- uint64_t *bsp;
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- while (count-- > 0)
- ia64_st8(bsp, *bufp++);
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_write_multi_io_8(bsh + ofs, bufp, count);
+ else {
+ while (count-- > 0)
+ ia64_st8((void *)(bsh + ofs), *bufp++);
+ }
}
@@ -355,16 +437,22 @@ bus_space_write_multi_8(bus_space_tag_t
* data is written to the buffer passed by reference and read from successive
* bus space addresses. Access is unordered.
*/
+void bus_space_read_region_io_1(u_long, uint8_t *, size_t);
+void bus_space_read_region_io_2(u_long, uint16_t *, size_t);
+void bus_space_read_region_io_4(u_long, uint32_t *, size_t);
+void bus_space_read_region_io_8(u_long, uint64_t *, size_t);
+
static __inline void
bus_space_read_region_1(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, uint8_t *bufp, size_t count)
{
- uint8_t *bsp;
- while (count-- > 0) {
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- *bufp++ = ia64_ld1(bsp);
- ofs += 1;
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_read_region_io_1(bsh + ofs, bufp, count);
+ else {
+ uint8_t *bsp = (void *)(bsh + ofs);
+ while (count-- > 0)
+ *bufp++ = ia64_ld1(bsp++);
}
}
@@ -372,12 +460,13 @@ static __inline void
bus_space_read_region_2(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, uint16_t *bufp, size_t count)
{
- uint16_t *bsp;
- while (count-- > 0) {
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- *bufp++ = ia64_ld2(bsp);
- ofs += 2;
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_read_region_io_2(bsh + ofs, bufp, count);
+ else {
+ uint16_t *bsp = (void *)(bsh + ofs);
+ while (count-- > 0)
+ *bufp++ = ia64_ld2(bsp++);
}
}
@@ -385,12 +474,13 @@ static __inline void
bus_space_read_region_4(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, uint32_t *bufp, size_t count)
{
- uint32_t *bsp;
- while (count-- > 0) {
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- *bufp++ = ia64_ld4(bsp);
- ofs += 4;
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_read_region_io_4(bsh + ofs, bufp, count);
+ else {
+ uint32_t *bsp = (void *)(bsh + ofs);
+ while (count-- > 0)
+ *bufp++ = ia64_ld4(bsp++);
}
}
@@ -398,12 +488,13 @@ static __inline void
bus_space_read_region_8(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, uint64_t *bufp, size_t count)
{
- uint64_t *bsp;
- while (count-- > 0) {
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- *bufp++ = ia64_ld8(bsp);
- ofs += 8;
+
+ if (__predict_false(bst == IA64_BUS_SPACE_IO))
+ bus_space_read_region_io_8(bsh + ofs, bufp, count);
+ else {
+ uint64_t *bsp = (void *)(bsh + ofs);
+ while (count-- > 0)
+ *bufp++ = ia64_ld8(bsp++);
}
}
@@ -414,16 +505,22 @@ bus_space_read_region_8(bus_space_tag_t
* data is read from the buffer passed by reference and written to successive
* bus space addresses. Access is unordered.
*/
+void bus_space_write_region_io_1(u_long, const uint8_t *, size_t);
+void bus_space_write_region_io_2(u_long, const uint16_t *, size_t);
+void bus_space_write_region_io_4(u_long, const uint32_t *, size_t);
+void bus_space_write_region_io_8(u_long, const uint64_t *, size_t);
+
static __inline void
bus_space_write_region_1(bus_space_tag_t bst, bus_space_handle_t bsh,
bus_size_t ofs, const uint8_t *bufp, size_t count)
{
- uint8_t *bsp;
- while (count-- > 0) {
- bsp = (bst == IA64_BUS_SPACE_IO) ? __PIO_ADDR(bsh + ofs) :
- __MEMIO_ADDR(bsh + ofs);
- ia64_st1(bsp, *bufp++);
- ofs += 1;
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-src-head
mailing list