From owner-acpi-jp@jp.freebsd.org  Wed Sep 13 18:34:30 2000
Received: (from daemon@localhost)
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) id SAA17292;
	Wed, 13 Sep 2000 18:34:30 +0900 (JST)
	(envelope-from owner-acpi-jp@jp.FreeBSD.org)
Received: from tasogare.imasy.or.jp (daemon@tasogare.imasy.or.jp [202.227.24.5])
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) with ESMTP id SAA17287
	for <acpi-jp@jp.freebsd.org>; Wed, 13 Sep 2000 18:34:29 +0900 (JST)
	(envelope-from iwasaki@jp.freebsd.org)
Received: from localhost (iwasaki.imasy.or.jp [202.227.24.92])
	by tasogare.imasy.or.jp (8.10.2+3.3W/3.7W-tasogare/smtpfeed 1.07) with ESMTP id e8D9YOr24535
	for <acpi-jp@jp.freebsd.org>; Wed, 13 Sep 2000 18:34:24 +0900 (JST)
	(envelope-from iwasaki@jp.freebsd.org)
To: acpi-jp@jp.freebsd.org
In-Reply-To: <20000912104907H.iwasaki@jp.freebsd.org>
References: <20000908220335L.iwasaki@jp.freebsd.org>
	<20000912092720B.iwasaki@jp.freebsd.org>
	<20000912104907H.iwasaki@jp.freebsd.org>
X-Mailer: Mew version 1.94.1 on Emacs 19.34 / Mule 2.3 (SUETSUMUHANA)
Mime-Version: 1.0
Content-Type: Text/Plain; charset=iso-2022-jp
Content-Transfer-Encoding: 7bit
Message-Id: <20000913183421Z.iwasaki@jp.freebsd.org>
Date: Wed, 13 Sep 2000 18:34:21 +0900
From: Mitsuru IWASAKI <iwasaki@jp.freebsd.org>
X-Dispatcher: imput version 20000228(IM140)
Lines: 1025
Reply-To: acpi-jp@jp.freebsd.org
Precedence: list
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+000315
X-Sequence: acpi-jp 632
Subject: [acpi-jp 632] Re: zzz and ACPI (was: Re: acpi_send_pm_event())
Errors-To: owner-acpi-jp@jp.freebsd.org
Sender: owner-acpi-jp@jp.freebsd.org
X-Originator: iwasaki@jp.freebsd.org

> $B$3$l$r;HMQ$7$?(B IndexField $B$X$N(B StoreOp $B4XO"$N(B Fix $B$r$^$H$a$^$7$?!#(B
> # region $B4X78$b$d$i$J$-$c$G$9$M$'(B...

$B$^$@J70O5$$@$1$G$9$,!"(Bregion $B4X78$bCe<j$7$^$7$?!#B?J,!"2?$r$7$?$$$+(B
$B$0$i$$$ODO$a$k$H;W$$$^$9$N$G!"$H$j$"$($:N.$7$F$*$-$^$9!#(B
$BA4A3IT40A4$@$H;W$&$H$3$m$O(B XXX $B$G%^!<%/$7$F$$$^$9$N$G!"$$$$9M$($,(B
$B$"$C$?$i65$($F$/$@$5$$$^$;!#(B

Index: sys/dev/acpi/aml/aml_common.c
===================================================================
RCS file: /home/ncvs/src/sys/dev/acpi/aml/aml_common.c,v
retrieving revision 1.1
diff -u -r1.1 aml_common.c
--- sys/dev/acpi/aml/aml_common.c	2000/08/24 09:33:08	1.1
+++ sys/dev/acpi/aml/aml_common.c	2000/09/13 09:19:11
@@ -42,6 +42,7 @@
 #include <sys/kernel.h>
 #include <sys/sysctl.h>
 #include <sys/systm.h>
+#include <machine/acpica_osd.h>
 #endif /* !_KERNEL */
 
 #include <dev/acpi/aml/aml_common.h>
@@ -304,6 +305,31 @@
 	byteoffset = bitoffset / 8;
 	bytelen = bitlen / 8 + ((bitlen % 8) ? 1 : 0);
 	addr = origin + byteoffset;
+
+	/* simple I/O ? */
+	if (bitlen <= 8 || bitlen == 16 || bitlen == 32) {
+		bcopy(addr, &readval, bytelen);
+		AML_DEBUGPRINT("\n\t[bufferfield:0x%x@%p:%d,%d]",
+		    readval, addr, bitoffset % 8, bitlen);
+		switch (io) {
+		case AML_BUFFER_INPUT:
+			value = aml_adjust_readvalue(AML_FIELDFLAGS_ACCESS_ANYACC, 
+			    bitoffset % 8, bitlen, readval);
+			*valuep = value;
+			AML_DEBUGPRINT("\n[read(bufferfield, %p)&mask:0x%x]\n",
+			    addr, value);
+			break;
+		case AML_BUFFER_OUTPUT:
+			value = aml_adjust_updatevalue(AML_FIELDFLAGS_ACCESS_ANYACC, 
+			    bitoffset % 8, bitlen, readval, value);
+			bcopy(&value, addr, bytelen);
+			AML_DEBUGPRINT("->[bufferfield:0x%x@%p:%d,%d]",
+			    value, addr, bitoffset % 8, bitlen);
+			break;
+		}
+		goto out;
+	}
+ 
 	offsetlow = bitoffset % 8;
 	if (bytelen > 1) {
 		offsethigh = (bitlen - (8 - offsetlow)) % 8;
@@ -378,7 +404,7 @@
 			*addr = tmp;
 		}
 	}
-
+out:
 	return (0);
 }
 
@@ -404,3 +430,230 @@
 	    origin, bitoffset, bitlen);
 	return (status);
 }
+
+u_int32_t
+aml_adjust_readvalue(u_int32_t flags, u_int32_t bitoffset, u_int32_t bitlen,
+    u_int32_t orgval)
+{
+	u_int32_t	retval;
+	u_int64_t	bitmask;
+
+	switch (flags & AML_FIELDFLAGS_ACCESS_MASK) {
+	case AML_FIELDFLAGS_ACCESS_ANYACC:	/* XXX */
+		if (bitlen <= 8) {
+			bitmask = 0x000000ff;
+			break;
+		}
+		if (bitlen <= 16) {
+			bitmask = 0x0000ffff;
+			break;
+		}
+		bitmask = 0xffffffff;
+		break;
+	case AML_FIELDFLAGS_ACCESS_BYTEACC:
+		bitmask = 0x000000ff;
+		break;
+	case AML_FIELDFLAGS_ACCESS_WORDACC:
+		bitmask = 0x0000ffff;
+		break;
+	case AML_FIELDFLAGS_ACCESS_DWORDACC:
+	default:
+		bitmask = 0xffffffff;
+		break;
+	}
+
+	retval = (orgval >> bitoffset) & (~(bitmask << bitlen)) & bitmask;
+
+	return (retval);
+}
+
+u_int32_t
+aml_adjust_updatevalue(u_int32_t flags, u_int32_t bitoffset, u_int32_t bitlen,
+    u_int32_t orgval, u_int32_t value)
+{
+	u_int32_t	retval;
+	u_int64_t	bitmask;
+
+	switch (flags & AML_FIELDFLAGS_ACCESS_MASK) {
+	case AML_FIELDFLAGS_ACCESS_ANYACC:	/* XXX */
+		if (bitlen <= 8) {
+			bitmask = 0x000000ff;
+			break;
+		}
+		if (bitlen <= 16) {
+			bitmask = 0x0000ffff;
+			break;
+		}
+		bitmask = 0xffffffff;
+		break;
+	case AML_FIELDFLAGS_ACCESS_BYTEACC:
+		bitmask = 0x000000ff;
+		break;
+	case AML_FIELDFLAGS_ACCESS_WORDACC:
+		bitmask = 0x0000ffff;
+		break;
+	case AML_FIELDFLAGS_ACCESS_DWORDACC:
+	default:
+		bitmask = 0xffffffff;
+		break;
+	}
+
+	retval = orgval;
+	switch (flags & AML_FIELDFLAGS_UPDATE_MASK) {
+	case AML_FIELDFLAGS_UPDATE_PRESERVE:
+		retval &= (~(((u_int64_t)1 << bitlen) - 1) << bitoffset) |
+			  (~(bitmask << bitoffset));
+		break;
+	case AML_FIELDFLAGS_UPDATE_WRITEASONES:
+		retval =  (~(((u_int64_t)1 << bitlen) - 1) << bitoffset) |
+			  (~(bitmask << bitoffset));
+		break;
+	case AML_FIELDFLAGS_UPDATE_WRITEASZEROS:
+		retval = 0;
+		break;
+	default:
+		printf("illegal update rule: %d\n", flags);
+		return (orgval);
+	}
+
+	retval |= (value << (bitoffset & bitmask));
+
+	return (retval);
+}
+
+int
+aml_region_handle_alloc(struct aml_environ *env, int regtype, u_int32_t flags,
+    u_int32_t baseaddr, u_int32_t bitoffset, u_int32_t bitlen,
+    struct aml_region_handle *handle)
+{
+	int	state;
+	struct	aml_name *pci_info;
+
+	handle->env = env;
+	handle->regtype = regtype;
+	handle->flags = flags;
+	handle->baseaddr = baseaddr;
+	handle->bitoffset = bitoffset;
+	handle->bitlen = bitlen;
+
+	/* XXX
+	 * need to evaluate field flags
+	 */
+	handle->addr = baseaddr + (bitoffset / 8);
+	handle->bytelen = bitlen / 8 + (bitlen % 8) ? 1 : 0;
+
+	state = 0;
+	pci_info = NULL;
+#ifdef _KERNEL
+	switch (handle->regtype) {
+	case AML_REGION_SYSMEM:
+		OsdMapMemory((void *)handle->addr, handle->bytelen,
+		    (void **)&handle->vaddr);
+		break;
+
+	case AML_REGION_PCICFG:
+		/* Obtain PCI bus number */
+		pci_info = aml_search_name(env, "_BBN");
+		if (pci_info == NULL || pci_info->property->type != aml_t_num) {
+			AML_DEBUGPRINT("Cannot locate _BBN. Using default 0\n");
+			handle->pci_bus = 0;
+		} else {
+			AML_DEBUGPRINT("found _BBN: %d\n",
+			    pci_info->property->num.number);
+			handle->pci_bus = pci_info->property->num.number & 0xff;
+		}
+
+		/* Obtain device & function number */
+		pci_info = aml_search_name(env, "_ADR");
+		if (pci_info == NULL || pci_info->property->type != aml_t_num) {
+			printf("Cannot locate: _ADR\n");
+			state = -1;
+			goto out;
+		}
+		handle->pci_devfunc = pci_info->property->num.number;
+
+		AML_DEBUGPRINT("[pci%d.%d]", handle->pci_bus, handle->pci_devfunc);
+		break;
+
+	default:
+		break;
+	}
+
+out:
+#endif	/* _KERNEL */
+	return (state);
+}
+
+void
+aml_region_handle_free(struct aml_region_handle *handle)
+{
+#ifdef _KERNEL
+	switch (handle->regtype) {
+	case AML_REGION_SYSMEM:
+		OsdUnMapMemory((void *)handle->vaddr, handle->bytelen);
+		break;
+
+	default:
+		break;
+	}
+#endif	/* _KERNEL */
+}
+
+int
+aml_region_io_simple(struct aml_environ *env, int io, int regtype,
+    u_int32_t flags, u_int32_t *valuep, u_int32_t baseaddr,
+    u_int32_t bitoffset, u_int32_t bitlen)
+{
+	int		state;
+	u_int32_t	value, readval;
+	struct		aml_region_handle handle;
+
+	state = aml_region_handle_alloc(env, regtype, flags,
+            baseaddr, bitoffset, bitlen, &handle);
+	if (state == -1) {
+		goto out;
+	}
+
+	if (io == AML_REGION_INPUT || (bitoffset % 8) || (bitlen % 8)) {
+		state = aml_region_read_simple(&handle, &readval);
+		if (state == -1) {
+			goto out;
+		}
+		AML_DEBUGPRINT("\t[%d:0x%x@%x:%d,%d]",
+		    regtype, readval, handle.addr, bitoffset % 8, bitlen);
+	}
+
+	switch (io) {
+	case AML_REGION_INPUT:
+		AML_DEBUGPRINT("\n");
+		readval = aml_adjust_readvalue(flags, bitoffset % 8,
+		    bitlen, readval);
+		value = readval;
+		value = aml_region_prompt_read(&handle, value);
+		state = aml_region_prompt_update_value(readval, value, &handle);
+		if (state == -1) {
+			goto out;
+		}
+
+		*valuep = value;
+		break;
+	case AML_REGION_OUTPUT:
+		value = *valuep;
+		if ((bitoffset % 8) || (bitlen % 8)) {
+			value = aml_adjust_updatevalue(flags, bitoffset % 8,
+			    bitlen, readval, value);
+		} else {
+			AML_DEBUGPRINT("\t");
+		}
+		value = aml_region_prompt_write(&handle, value);
+		printf("->[%d:0x%x@0x%x:%d,%d]\n", regtype, value,
+		    handle.addr, bitoffset % 8, bitlen);
+		state = aml_region_write_simple(&handle, value);
+		break;
+	}
+
+	aml_region_handle_free(&handle);
+out:
+	return (state);
+}
+
Index: sys/dev/acpi/aml/aml_common.h
===================================================================
RCS file: /home/ncvs/src/sys/dev/acpi/aml/aml_common.h,v
retrieving revision 1.1
diff -u -r1.1 aml_common.h
--- sys/dev/acpi/aml/aml_common.h	2000/08/24 09:33:08	1.1
+++ sys/dev/acpi/aml/aml_common.h	2000/09/13 07:34:08
@@ -62,6 +62,52 @@
 	}								\
 } while(0)
 
+/*
+ * Field Flags
+ */
+/* bit 0 -3:	AccessType */
+#define AML_FIELDFLAGS_ACCESS_ANYACC		0x00
+#define AML_FIELDFLAGS_ACCESS_BYTEACC		0x01
+#define AML_FIELDFLAGS_ACCESS_WORDACC		0x02
+#define AML_FIELDFLAGS_ACCESS_DWORDACC		0x03
+#define AML_FIELDFLAGS_ACCESS_BLOCKACC		0x04
+#define AML_FIELDFLAGS_ACCESS_SMBSENDRECVACC	0x05
+#define AML_FIELDFLAGS_ACCESS_SMBQUICKACC	0x06
+#define AML_FIELDFLAGS_ACCESS_MASK		0x0f
+/* bit 4:	LockRule */
+#define AML_FIELDFLAGS_LOCK_NOLOCK		0x00
+#define AML_FIELDFLAGS_LOCK_LOCK		0x10
+#define AML_FIELDFLAGS_LOCK_MASK		0x10
+/* bit 5 - 6:	UpdateRule */
+#define AML_FIELDFLAGS_UPDATE_PRESERVE		0x00
+#define AML_FIELDFLAGS_UPDATE_WRITEASONES	0x20
+#define AML_FIELDFLAGS_UPDATE_WRITEASZEROS	0x40
+#define AML_FIELDFLAGS_UPDATE_MASK		0x60
+/* bit 7:	reserved (must be 0) */
+
+#define AML_REGION_INPUT	0
+#define AML_REGION_OUTPUT	1
+
+#define AML_REGION_SYSMEM	0
+#define AML_REGION_SYSIO	1
+#define AML_REGION_PCICFG	2
+#define AML_REGION_EMBCTL	3
+#define AML_REGION_SMBUS	4
+
+struct aml_region_handle {
+	struct		aml_environ *env;
+	int		regtype;
+	u_int32_t	flags;
+	u_int32_t	baseaddr;
+	u_int32_t	bitoffset;
+	u_int32_t	bitlen;
+
+	vm_offset_t	addr, bytelen;
+
+	vm_offset_t	vaddr;			/* SystemMemory */
+	u_int32_t	pci_bus, pci_devfunc;	/* PCI_Config */
+};
+
 void		 aml_showobject(union aml_object *);
 void		 aml_showtree(struct aml_name *, int);
 int		 aml_print_curname(struct aml_name *);
@@ -72,4 +118,26 @@
 int		 aml_bufferfield_write(u_int32_t, u_int8_t *,
 				       u_int32_t, u_int32_t);
 
+u_int32_t	 aml_adjust_readvalue(u_int32_t, u_int32_t, u_int32_t,
+				      u_int32_t);
+u_int32_t	 aml_adjust_updatevalue(u_int32_t, u_int32_t, u_int32_t,
+					u_int32_t, u_int32_t);
+
+int		 aml_region_handle_alloc(struct aml_environ *, int, u_int32_t,
+					 u_int32_t, u_int32_t, u_int32_t,
+					 struct aml_region_handle *);
+void		 aml_region_handle_free(struct aml_region_handle *);
+int		 aml_region_io_simple(struct aml_environ *, int, int,
+				      u_int32_t, u_int32_t *, u_int32_t,
+				      u_int32_t, u_int32_t);
+extern int	 aml_region_read_simple(struct aml_region_handle *,
+					u_int32_t *);
+extern int	 aml_region_write_simple(struct aml_region_handle *,
+					 u_int32_t);
+extern u_int32_t aml_region_prompt_read(struct aml_region_handle *,
+					u_int32_t);
+extern u_int32_t aml_region_prompt_write(struct aml_region_handle *,
+					 u_int32_t);
+extern int	 aml_region_prompt_update_value(u_int32_t, u_int32_t,
+					        struct aml_region_handle *);
 #endif /* !_AML_COMMON_H_ */
Index: sys/dev/acpi/aml/aml_evalobj.c
===================================================================
RCS file: /home/ncvs/src/sys/dev/acpi/aml/aml_evalobj.c,v
retrieving revision 1.1
diff -u -r1.1 aml_evalobj.c
--- sys/dev/acpi/aml/aml_evalobj.c	2000/08/24 09:33:08	1.1
+++ sys/dev/acpi/aml/aml_evalobj.c	2000/09/10 03:10:29
@@ -65,11 +65,13 @@
 static union aml_object *
 aml_eval_fieldobject(struct aml_environ *env, struct aml_name *name)
 {
+	int	num;
 	struct	aml_name *oname,*wname;
 	struct	aml_field *field;
 	struct	aml_opregion *or;
 	union	aml_object tobj;
 
+	num = 0;
 	/* CANNOT OCCUR! */
 	if (name == NULL || name->property == NULL ||
 	    name->property->type != aml_t_field) {
@@ -116,7 +118,10 @@
 		tobj.num.number = field->bitoffset / 8;/* AccessType Boundary */
 		aml_store_to_name(env, &tobj, wname);
 		wname = aml_search_name(env, field->f.ifld.dataname);
-		aml_eval_name(env, wname);
+		num = aml_objtonum(env, aml_eval_name(env, wname));
+		env->tempobject.type = aml_t_num;
+		env->tempobject.num.number = (num >> (field->bitoffset & 7)) &
+		    ((1 << field->bitlen) - 1);
 	}
 	env->curname = oname;
 	return (&env->tempobject);
Index: sys/dev/acpi/aml/aml_parse.c
===================================================================
RCS file: /home/ncvs/src/sys/dev/acpi/aml/aml_parse.c,v
retrieving revision 1.1
diff -u -r1.1 aml_parse.c
--- sys/dev/acpi/aml/aml_parse.c	2000/08/24 09:33:08	1.1
+++ sys/dev/acpi/aml/aml_parse.c	2000/09/12 01:32:12
@@ -1613,6 +1613,16 @@
 		AML_DEBUGPRINT(", ");
 		destname1 = aml_parse_termobj(env, indent);
 		AML_DEBUGPRINT(")");
+		/* XXX
+		 * temporary object may change during aml_store_to_name()
+		 * operation, so we make a copy of it on stack.
+		 */
+		if (destname1 == &env->tempname &&
+		    destname1->property == &env->tempobject) {
+			destname1 = aml_create_local_object();
+			AML_COPY_OBJECT(destname1->property, env,
+			    &env->tempobject, NULL);
+		}
 		aml_store_to_name(env, tmpobj, destname1);
 		if (env->stat == aml_stat_panic) {
 			AML_DEBUGPRINT("StoreOp failed");
Index: sys/dev/acpi/aml/aml_region.c
===================================================================
RCS file: /home/ncvs/src/sys/dev/acpi/aml/aml_region.c,v
retrieving revision 1.1
diff -u -r1.1 aml_region.c
--- sys/dev/acpi/aml/aml_region.c	2000/08/24 09:33:08	1.1
+++ sys/dev/acpi/aml/aml_region.c	2000/09/13 09:13:02
@@ -44,15 +44,166 @@
 #include <machine/acpica_osd.h>
 #endif
 
-#define AML_REGION_INPUT	0
-#define AML_REGION_OUTPUT	1
+/*
+ * Dummy functions for aml_region_io_simple()
+ */
+u_int32_t
+aml_region_prompt_read(struct aml_region_handle *handle, u_int32_t value)
+{
+
+	return (value);
+}
+
+u_int32_t
+aml_region_prompt_write(struct aml_region_handle *handle, u_int32_t value)
+{
 
-#define AML_REGION_SYSMEM	0
-#define AML_REGION_SYSIO	1
-#define AML_REGION_PCICFG	2
-#define AML_REGION_EMBCTL	3
-#define AML_REGION_SMBUS	4
+	return (value);
+}
+
+int
+aml_region_prompt_update_value(u_int32_t orgval, u_int32_t value,
+    struct aml_region_handle *handle)
+{
+	return (0);
+}
+
+/*
+ * Primitive functions for aml_region_io_simple()
+ */
+int
+aml_region_read_simple(struct aml_region_handle *handle, u_int32_t *valuep)
+{
+	u_int32_t value;
 
+	/* XXX
+	 * need to evaluate field flags
+	 */
+
+	switch (handle->regtype) {
+	case AML_REGION_SYSMEM:
+		/* XXX should be MI */
+		switch (handle->bitlen) {
+		case 8:
+			value = *(volatile u_int8_t *)(handle->vaddr);
+			value &= 0xff;
+			break;
+		case 16:
+			value = *(volatile u_int16_t *)(handle->vaddr);
+			value &= 0xffff;
+			break;
+		case 32:
+			value = *(volatile u_int32_t *)(handle->vaddr);
+			break;
+		}
+		break;
+	case AML_REGION_SYSIO:
+		switch (handle->bitlen) {
+		case 8:
+			value = OsdIn8(handle->addr);
+			value &= 0xff;
+			break;
+		case 16:
+			value = OsdIn16(handle->addr);
+			value &= 0xffff;
+			break;
+		case 32:
+			value = OsdIn32(handle->addr);
+			break;
+		}
+		break;
+	case AML_REGION_PCICFG:
+		switch (handle->bitlen) {
+		case 8:
+			OsdReadPciCfgByte(handle->pci_bus, handle->pci_devfunc,
+			    handle->addr, (UINT8 *)&value);
+			value &= 0xff;
+			break;
+		case 16:
+			OsdReadPciCfgWord(handle->pci_bus, handle->pci_devfunc,
+			    handle->addr, (UINT16 *)&value);
+			value &= 0xffff;
+			break;
+		case 32:
+			OsdReadPciCfgDword(handle->pci_bus, handle->pci_devfunc,
+			    handle->addr, &value);
+			break;
+		}
+		break;
+	default:
+		printf("aml_region_io_system: not supported yet (%d)\n",
+		    handle->regtype);
+		value = 0;
+		break;
+	}
+	*valuep = value;
+	return (0);
+}
+
+int
+aml_region_write_simple(struct aml_region_handle *handle, u_int32_t value)
+{
+	/* XXX
+	 * need to evaluate field flags
+	 */
+
+	switch (handle->regtype) {
+	case AML_REGION_SYSMEM:
+		/* XXX should be MI */
+		switch (handle->bitlen) {
+		case 8:
+			value &= 0xff;
+			*(volatile u_int8_t *)(handle->vaddr) = value;
+			break;
+		case 16:
+			value &= 0xffff;
+			*(volatile u_int16_t *)(handle->vaddr) = value;
+			break;
+		case 32:
+			*(volatile u_int32_t *)(handle->vaddr) = value;
+			break;
+		}
+		break;
+	case AML_REGION_SYSIO:
+		switch (handle->bitlen) {
+		case 8:
+			value &= 0xff;
+			OsdOut8(handle->addr, value);
+			break;
+		case 16:
+			value &= 0xffff;
+			OsdOut16(handle->addr, value);
+			break;
+		case 32:
+			OsdOut32(handle->addr, value);
+			break;
+		}
+		break;
+	case AML_REGION_PCICFG:
+		switch (handle->bitlen) {
+		case 8:
+			OsdWritePciCfgByte(handle->pci_bus, handle->pci_devfunc,
+			    handle->addr, value);
+			break;
+		case 16:
+			OsdWritePciCfgWord(handle->pci_bus, handle->pci_devfunc,
+			    handle->addr, value);
+			break;
+		case 32:
+			OsdWritePciCfgDword(handle->pci_bus, handle->pci_devfunc,
+			    handle->addr, value);
+			break;
+		}
+		break;
+	default:
+		printf("aml_region_io_system: not supported yet (%d)\n",
+		    handle->regtype);
+		break;
+	}
+
+	return (0);
+}
+
 static int
 aml_region_io_system(struct aml_environ *env, boolean_t io, int regtype,
     u_int32_t flags, u_int32_t *valuep, u_int32_t baseaddr,
@@ -66,6 +217,14 @@
 	int		value, readval;
 	int		state, i;
 	int		debug;
+
+#if 0
+	/* simple I/O ? */
+	if (bitlen <= 8 || bitlen == 16 || bitlen == 32) {
+		return (aml_region_io_simple(env, io, regtype, flags,
+		    valuep, baseaddr, bitoffset, bitlen));
+	}
+#endif
 
 	/* save debug level and shut it up */
 	debug = aml_debug;
Index: sys/dev/acpi/aml/aml_store.c
===================================================================
RCS file: /home/ncvs/src/sys/dev/acpi/aml/aml_store.c,v
retrieving revision 1.1
diff -u -r1.1 aml_store.c
--- sys/dev/acpi/aml/aml_store.c	2000/08/24 09:33:08	1.1
+++ sys/dev/acpi/aml/aml_store.c	2000/09/12 00:59:29
@@ -55,13 +55,14 @@
     struct aml_name *name)
 {
 	char	*buffer;
-	struct	aml_name *wname, *oname;
+	struct	aml_name *wname, *oname, *iname;
 	struct	aml_field *field;
 	struct	aml_opregion *or;
-	union	aml_object tobj;
+	union	aml_object tobj, iobj, *tmpobj;
 
 	field = &name->property->field;
 	oname = env->curname;
+	iname = NULL;
 	env->curname = name->parent;
 	if (field->f.ftype == f_t_field) {
 		wname = aml_search_name(env, field->f.fld.regname);
@@ -113,13 +114,23 @@
 			break;
 		}
 	} else if (field->f.ftype == f_t_index) {
-		wname = aml_search_name(env, field->f.ifld.indexname);
-		tobj.type = aml_t_num;
-		tobj.num.number = field->bitoffset / 8;	/* AccessType Boundary */
-		aml_store_to_name(env, &tobj, wname);
+		iname = aml_search_name(env, field->f.ifld.indexname);
 		wname = aml_search_name(env, field->f.ifld.dataname);
+		iobj.type = aml_t_num;
+		iobj.num.number = field->bitoffset / 8;	/* AccessType Boundary */
+
+		/* read whole values of IndexField */
+		aml_store_to_name(env, &iobj, iname);
+		tmpobj = aml_eval_name(env, wname);
+
+		/* make the values to be written */
 		tobj.num = obj->num;
-		tobj.num.number = tobj.num.number << (field->bitoffset & 7);
+		tobj.num.number = aml_adjust_updatevalue(field->flags,
+		    field->bitoffset & 7, field->bitlen,
+		    tmpobj->num.number, obj->num.number);
+
+		/* write the values to IndexField */
+		aml_store_to_name(env, &iobj, iname);
 		aml_store_to_name(env, &tobj, wname);
 	}
 	env->curname = oname;
Index: usr.sbin/acpi/amldb/region.c
===================================================================
RCS file: /home/ncvs/src/usr.sbin/acpi/amldb/region.c,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 region.c
--- usr.sbin/acpi/amldb/region.c	2000/08/31 14:45:00	1.1.1.1
+++ usr.sbin/acpi/amldb/region.c	2000/09/13 07:43:41
@@ -199,19 +199,135 @@
 	fclose(fp);
 }
 
-#define ACPI_REGION_INPUT	0
-#define ACPI_REGION_OUTPUT	1
+int
+aml_region_read_simple(struct aml_region_handle *handle, u_int32_t *valuep)
+{
+	int		i, state;
+	u_int8_t	val;
+	u_int32_t	addr, bytes, value;
+
+	state = 0;
+	value = val = 0;
+	bytes = handle->bitlen / 8 + ((handle->bitlen % 8) ? 1 : 0);
+	addr = handle->baseaddr + (handle->bitoffset / 8);
+	for (i = 0; i < bytes; i++) {
+		state = aml_simulate_regcontent_read(handle->regtype, addr + i, &val);
+		if (state == -1) {
+			goto out;
+		}
+
+		value |= val << (i * 8);
+	}
+	*valuep = value;
+out:
+	return (state);
+}
+
+int
+aml_region_write_simple(struct aml_region_handle *handle, u_int32_t value)
+{
+	int		i, state;
+	u_int8_t	val;
+	u_int32_t	addr, bytes;
+
+	state = 0;
+	bytes = handle->bitlen / 8 + ((handle->bitlen % 8) ? 1 : 0);
+	addr = handle->baseaddr + (handle->bitoffset / 8);
+	for (i = 0; i < bytes; i++) {
+		val = value & 0xff;
+		state = aml_simulate_regcontent_write(handle->regtype, addr + i, &val);
+		if (state == -1) {
+			goto out;
+		}
+		value = value >> 8;
+	}
+out:
+	return (state);
+}
 
 static int
-aml_simulate_region_io(int io, int regtype, u_int32_t flags, u_int32_t *valuep,
-    u_int32_t baseaddr, u_int32_t bitoffset, u_int32_t bitlen, int prompt)
+aml_simulate_region_io(struct aml_environ *env, int io, int regtype,
+    u_int32_t flags, u_int32_t *valuep, u_int32_t baseaddr,
+    u_int32_t bitoffset, u_int32_t bitlen, int prompt);
+
+u_int32_t
+aml_region_prompt_read(struct aml_region_handle *handle, u_int32_t value)
+{
+	u_int32_t 	retval;
+	char		buf[64];
+
+	retval = value;
+	sprintf(buf, "[read(%d, 0x%x)&mask:0x%x]",
+	    handle->regtype, handle->addr, value);
+	if (aml_debug_prompt_reginput) {
+		retval = aml_simulate_prompt(buf, value);
+	} else {
+		printf("\t%s\n", buf);
+	}
+
+	return (retval);
+}
+
+u_int32_t
+aml_region_prompt_write(struct aml_region_handle *handle, u_int32_t value)
 {
+	u_int32_t 	retval;
 	char		buf[64];
+
+	retval = value;
+	if (aml_debug_prompt_regoutput) {
+		printf("\n");
+		sprintf(buf, "[write(%d, 0x%x, 0x%x)]",
+		    handle->regtype, value, handle->addr);
+		retval = aml_simulate_prompt(buf, value);
+	}
+
+	return (retval);
+}
+
+int
+aml_region_prompt_update_value(u_int32_t orgval, u_int32_t value,
+    struct aml_region_handle *handle)
+{
+	int	state;
+
+	state = 0;
+	if (orgval != value) {
+		state = aml_simulate_region_io(handle->env,
+		    AML_REGION_OUTPUT, handle->regtype, handle->flags, &value,
+		    handle->baseaddr, handle->bitoffset, handle->bitlen, 0);
+		if (state == -1) {
+			goto out;
+		}
+	}
+
+out:
+	return (state);
+}
+
+static int
+aml_simulate_region_io(struct aml_environ *env, int io, int regtype,
+    u_int32_t flags, u_int32_t *valuep, u_int32_t baseaddr,
+    u_int32_t bitoffset, u_int32_t bitlen, int prompt)
+{
 	u_int8_t	val, tmp, masklow, maskhigh;
 	u_int8_t	offsetlow, offsethigh;
 	u_int32_t	addr, byteoffset, bytelen;
 	int		value, readval;
 	int		state, i;
+	struct		aml_region_handle handle;
+
+	/* simple I/O ? */
+	if (bitlen <= 8 || bitlen == 16 || bitlen == 32) {
+		return (aml_region_io_simple(env, io, regtype, flags,
+		    valuep, baseaddr, bitoffset, bitlen));
+	}
+
+	state = aml_region_handle_alloc(env, regtype, flags,
+            baseaddr, bitoffset, bitlen, &handle);
+	if (state == -1) {
+		goto finish;
+	}
 
 	value = *valuep;
 	val = readval = 0;
@@ -248,7 +364,7 @@
 		printf("\t[%d:0x%02x@0x%x]", regtype, val, addr);
 
 		switch (io) {
-		case ACPI_REGION_INPUT:
+		case AML_REGION_INPUT:
 			tmp = val;
 			/* the lowest byte? */
 			if (i == bytelen) {
@@ -273,26 +389,16 @@
 			if (offsetlow) {
 				readval = readval >> offsetlow;
 			}
-			sprintf(buf, "[read(%d, 0x%x)&mask:0x%x]",
-			    regtype, addr, readval);
-			if (prompt) {
-				value = aml_simulate_prompt(buf, readval);
-				if (readval != value) {
-					state = aml_simulate_region_io(ACPI_REGION_OUTPUT,
-					    regtype, flags, &value, baseaddr,
-					    bitoffset, bitlen, 0);
-					if (state == -1) {
-						goto finish;
-					}
-				}
-			} else {
-				printf("\t%s\n", buf);
-				value = readval;
+			value = aml_region_prompt_read(&handle, readval);
+			state = aml_region_prompt_update_value(readval, value,
+			    &handle);
+			if (state == -1) {
+				goto finish;
 			}
 			*valuep = value;
 
 			break;
-		case ACPI_REGION_OUTPUT:
+		case AML_REGION_OUTPUT:
 			tmp = value & 0xff;
 			/* the lowest byte? */
 			if (i == bytelen) {
@@ -307,16 +413,7 @@
 				value = value >> 8;
 			}
 
-			if (prompt) {
-				printf("\n");
-				sprintf(buf, "[write(%d, 0x%02x, 0x%x)]",
-				    regtype, tmp, addr);
-				val = aml_simulate_prompt(buf, tmp);
-			} else {
-				printf("->[%d:0x%02x@0x%x]\n",
-				    regtype, tmp, addr);
-				val = tmp;
-			}
+			val = aml_region_prompt_write(&handle, tmp);
 			state = aml_simulate_regcontent_write(regtype,
 			    addr, &val);
 			if (state == -1) {
@@ -325,6 +422,7 @@
 			break;
 		}
 	}
+	aml_region_handle_free(&handle);
 finish:
 	return (state);
 }
@@ -355,7 +453,7 @@
 
 	for (i = bytelen; i > 0; i--, addr++) {
 		switch (io) {
-		case ACPI_REGION_INPUT:
+		case AML_REGION_INPUT:
 			val = 0;
 			state = aml_simulate_regcontent_read(regtype, addr, &val);
 			if (state == -1) {
@@ -363,7 +461,7 @@
 			}
 			buffer[bytelen - i] = val;
 			break;
-		case ACPI_REGION_OUTPUT:
+		case AML_REGION_OUTPUT:
 			val = buffer[bytelen - i];
 			state = aml_simulate_regcontent_write(regtype,
 			    addr, &val);
@@ -378,15 +476,15 @@
 }
 
 static u_int32_t
-aml_simulate_region_read(int regtype, u_int32_t flags, u_int32_t addr,
-    u_int32_t bitoffset, u_int32_t bitlen)
+aml_simulate_region_read(struct aml_environ *env, int regtype,
+    u_int32_t flags, u_int32_t addr, u_int32_t bitoffset, u_int32_t bitlen)
 {
 	int	value;
 	int	state;
 
 	AML_DEBUGPRINT("\n[aml_region_read(%d, %d, 0x%x, 0x%x, 0x%x)]\n",
 	    regtype, flags, addr, bitoffset, bitlen);
-	state = aml_simulate_region_io(ACPI_REGION_INPUT, regtype, flags, &value,
+	state = aml_simulate_region_io(env, AML_REGION_INPUT, regtype, flags, &value,
 	    addr, bitoffset, bitlen, aml_debug_prompt_reginput);
 	assert(state != -1);
 	return (value);
@@ -400,21 +498,22 @@
 
 	AML_DEBUGPRINT("\n[aml_region_read_into_buffer(%d, %d, 0x%x, 0x%x, 0x%x)]\n",
 	    regtype, flags, addr, bitoffset, bitlen);
-	state = aml_simulate_region_io_buffer(ACPI_REGION_INPUT, regtype, flags,
+	state = aml_simulate_region_io_buffer(AML_REGION_INPUT, regtype, flags,
 	    buffer, addr, bitoffset, bitlen);
 	assert(state != -1);
 	return (state);
 }
 
 int
-aml_simulate_region_write(int regtype, u_int32_t flags, u_int32_t value,
-    u_int32_t addr, u_int32_t bitoffset, u_int32_t bitlen)
+aml_simulate_region_write(struct aml_environ *env, int regtype,
+    u_int32_t flags, u_int32_t value, u_int32_t addr, u_int32_t bitoffset,
+    u_int32_t bitlen)
 {
 	int	state;
 
 	AML_DEBUGPRINT("\n[aml_region_write(%d, %d, 0x%x, 0x%x, 0x%x, 0x%x)]\n",
 	    regtype, flags, value, addr, bitoffset, bitlen);
-	state = aml_simulate_region_io(ACPI_REGION_OUTPUT, regtype, flags,
+	state = aml_simulate_region_io(env, AML_REGION_OUTPUT, regtype, flags,
 	    &value, addr, bitoffset, bitlen, aml_debug_prompt_regoutput);
 	assert(state != -1);
 	return (state);
@@ -428,14 +527,15 @@
 
 	AML_DEBUGPRINT("\n[aml_region_write_from_buffer(%d, %d, 0x%x, 0x%x, 0x%x)]\n",
 	    regtype, flags, addr, bitoffset, bitlen);
-	state = aml_simulate_region_io_buffer(ACPI_REGION_OUTPUT, regtype,
+	state = aml_simulate_region_io_buffer(AML_REGION_OUTPUT, regtype,
 	    flags, buffer, addr, bitoffset, bitlen);
 	assert(state != -1);
 	return (state);
 }
 
 int
-aml_simulate_region_bcopy(int regtype, u_int32_t flags, u_int32_t addr,
+aml_simulate_region_bcopy(struct aml_environ *env, int regtype,
+    u_int32_t flags, u_int32_t addr,
     u_int32_t bitoffset, u_int32_t bitlen,
     u_int32_t dflags, u_int32_t daddr,
     u_int32_t dbitoffset, u_int32_t dbitlen)
@@ -452,10 +552,10 @@
 	len = len / 8 + ((len % 8) ? 1 : 0);
 
 	for (i = 0; i < len; i++) {
-		state = aml_simulate_region_io(ACPI_REGION_INPUT, regtype,
+		state = aml_simulate_region_io(env, AML_REGION_INPUT, regtype,
 		    flags, &value, addr, bitoffset + i * 8, 8, 0);
 		assert(state != -1);
-		state = aml_simulate_region_io(ACPI_REGION_OUTPUT, regtype,
+		state = aml_simulate_region_io(env, AML_REGION_OUTPUT, regtype,
 		    dflags, &value, daddr, dbitoffset + i * 8, 8, 0);
 		assert(state != -1);
 	}
@@ -468,7 +568,7 @@
     u_int32_t addr, u_int32_t bitoffset, u_int32_t bitlen)
 {
 
-	return (aml_simulate_region_read(regtype, flags, addr,
+	return (aml_simulate_region_read(env, regtype, flags, addr,
 	    bitoffset, bitlen));
 }
 
@@ -487,7 +587,7 @@
     u_int32_t value, u_int32_t addr, u_int32_t bitoffset, u_int32_t bitlen)
 {
 
-	return (aml_simulate_region_write(regtype, flags, value, addr,
+	return (aml_simulate_region_write(env, regtype, flags, value, addr,
 	    bitoffset, bitlen));
 }
 
@@ -508,7 +608,7 @@
     u_int32_t dbitoffset, u_int32_t dbitlen)
 {
 
-	return (aml_simulate_region_bcopy(regtype, flags, addr, bitoffset,
+	return (aml_simulate_region_bcopy(env, regtype, flags, addr, bitoffset,
 	    bitlen, dflags, daddr, dbitoffset, dbitlen));
 }
 
