svn commit: r202052 - in stable/8/sys: conf ia64/ia64 ia64/include

Marcel Moolenaar marcel at FreeBSD.org
Sun Jan 10 23:51:03 UTC 2010


Author: marcel
Date: Sun Jan 10 23:51:02 2010
New Revision: 202052
URL: http://svn.freebsd.org/changeset/base/202052

Log:
  MFC rev 201269, 201373:
  o   Revamp bus_space access functions (201269).
  o   Change BUS_SPACE_MAXADDR from 2^32-1 to 2^64-1 (201373).

Added:
  stable/8/sys/ia64/ia64/bus_machdep.c
     - copied unchanged from r201269, head/sys/ia64/ia64/bus_machdep.c
Modified:
  stable/8/sys/conf/files.ia64
  stable/8/sys/ia64/ia64/machdep.c
  stable/8/sys/ia64/ia64/mp_machdep.c
  stable/8/sys/ia64/ia64/nexus.c
  stable/8/sys/ia64/ia64/sys_machdep.c
  stable/8/sys/ia64/include/bus.h
  stable/8/sys/ia64/include/cpufunc.h
Directory Properties:
  stable/8/sys/   (props changed)
  stable/8/sys/amd64/include/xen/   (props changed)
  stable/8/sys/cddl/contrib/opensolaris/   (props changed)
  stable/8/sys/contrib/dev/acpica/   (props changed)
  stable/8/sys/contrib/pf/   (props changed)
  stable/8/sys/dev/xen/xenpci/   (props changed)

Modified: stable/8/sys/conf/files.ia64
==============================================================================
--- stable/8/sys/conf/files.ia64	Sun Jan 10 23:37:04 2010	(r202051)
+++ stable/8/sys/conf/files.ia64	Sun Jan 10 23:51:02 2010	(r202052)
@@ -75,6 +75,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

Copied: stable/8/sys/ia64/ia64/bus_machdep.c (from r201269, head/sys/ia64/ia64/bus_machdep.c)
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ stable/8/sys/ia64/ia64/bus_machdep.c	Sun Jan 10 23:51:02 2010	(r202052, copy of r201269, head/sys/ia64/ia64/bus_machdep.c)
@@ -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: stable/8/sys/ia64/ia64/machdep.c
==============================================================================
--- stable/8/sys/ia64/ia64/machdep.c	Sun Jan 10 23:37:04 2010	(r202051)
+++ stable/8/sys/ia64/ia64/machdep.c	Sun Jan 10 23:51:02 2010	(r202052)
@@ -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: stable/8/sys/ia64/ia64/mp_machdep.c
==============================================================================
--- stable/8/sys/ia64/ia64/mp_machdep.c	Sun Jan 10 23:37:04 2010	(r202051)
+++ stable/8/sys/ia64/ia64/mp_machdep.c	Sun Jan 10 23:51:02 2010	(r202052)
@@ -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: stable/8/sys/ia64/ia64/nexus.c
==============================================================================
--- stable/8/sys/ia64/ia64/nexus.c	Sun Jan 10 23:37:04 2010	(r202051)
+++ stable/8/sys/ia64/ia64/nexus.c	Sun Jan 10 23:51:02 2010	(r202052)
@@ -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: stable/8/sys/ia64/ia64/sys_machdep.c
==============================================================================
--- stable/8/sys/ia64/ia64/sys_machdep.c	Sun Jan 10 23:37:04 2010	(r202051)
+++ stable/8/sys/ia64/ia64/sys_machdep.c	Sun Jan 10 23:51:02 2010	(r202052)
@@ -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: stable/8/sys/ia64/include/bus.h
==============================================================================
--- stable/8/sys/ia64/include/bus.h	Sun Jan 10 23:37:04 2010	(r202051)
+++ stable/8/sys/ia64/include/bus.h	Sun Jan 10 23:51:02 2010	(r202052)
@@ -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,38 +102,49 @@
 #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
 #define BUS_SPACE_MAXADDR_24BIT	0xFFFFFF
 #define BUS_SPACE_MAXADDR_32BIT 0xFFFFFFFF
-#define BUS_SPACE_MAXADDR	0xFFFFFFFF
+#define BUS_SPACE_MAXADDR	0xFFFFFFFFFFFFFFFF
 
 #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) :

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***


More information about the svn-src-stable-8 mailing list