freebsd-dev/usr.sbin/acpi/amldb/aml/aml_store.c
Mitsuru IWASAKI 7a503f5ce5 Move old aml interpreter code to amldb/aml/. This will be used for our
reference and comparison with ACPICA aml interpreter's behavior.
2000-11-09 06:24:45 +00:00

350 lines
9.5 KiB
C

/*-
* Copyright (c) 1999 Takanori Watanabe
* Copyright (c) 1999, 2000 Mitsuru IWASAKI <iwasaki@FreeBSD.org>
* 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.
*
* $Id: aml_store.c,v 1.22 2000/08/09 14:47:44 iwasaki Exp $
* $FreeBSD$
*/
#include <sys/param.h>
#include <aml/aml_amlmem.h>
#include <aml/aml_common.h>
#include <aml/aml_env.h>
#include <aml/aml_evalobj.h>
#include <aml/aml_name.h>
#include <aml/aml_obj.h>
#include <aml/aml_region.h>
#include <aml/aml_status.h>
#include <aml/aml_store.h>
#ifndef _KERNEL
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include "debug.h"
#else /* _KERNEL */
#include <sys/systm.h>
#endif /* !_KERNEL */
static void
aml_store_to_fieldname(struct aml_environ *env, union aml_object *obj,
struct aml_name *name)
{
char *buffer;
struct aml_name *wname, *oname, *iname;
struct aml_field *field;
struct aml_opregion *or;
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);
if (wname == NULL ||
wname->property == NULL ||
wname->property->type != aml_t_opregion) {
AML_DEBUGPRINT("Inappropreate Type\n");
env->stat = aml_stat_panic;
env->curname = oname;
return;
}
or = &wname->property->opregion;
switch (obj->type) {
case aml_t_num:
aml_region_write(env, or->space, field->flags,
obj->num.number, or->offset,
field->bitoffset, field->bitlen);
AML_DEBUGPRINT("[write(%d, 0x%x, 0x%x)]",
or->space, obj->num.number,
or->offset + field->bitoffset / 8);
break;
case aml_t_buffer:
case aml_t_bufferfield:
if (obj->type == aml_t_buffer) {
buffer = obj->buffer.data;
} else {
buffer = obj->bfld.origin;
buffer += obj->bfld.bitoffset / 8;
}
aml_region_write_from_buffer(env, or->space,
field->flags, buffer, or->offset, field->bitoffset,
field->bitlen);
break;
case aml_t_regfield:
if (or->space != obj->regfield.space) {
AML_DEBUGPRINT("aml_store_to_fieldname: "
"Different type of space\n");
break;
}
aml_region_bcopy(env, obj->regfield.space,
obj->regfield.flags, obj->regfield.offset,
obj->regfield.bitoffset, obj->regfield.bitlen,
field->flags, or->offset, field->bitoffset,
field->bitlen);
break;
default:
AML_DEBUGPRINT("aml_store_to_fieldname: "
"Inappropreate Type of src object\n");
break;
}
} else if (field->f.ftype == f_t_index) {
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 = 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;
}
static void
aml_store_to_buffer(struct aml_environ *env, union aml_object *obj,
union aml_object *buf, int offset)
{
int size;
int bitlen;
switch (obj->type) {
case aml_t_num:
if (offset > buf->buffer.size) {
aml_realloc_object(buf, offset);
}
buf->buffer.data[offset] = obj->num.number & 0xff;
AML_DEBUGPRINT("[Store number 0x%x to buffer]",
obj->num.number & 0xff);
break;
case aml_t_string:
size = strlen(obj->str.string);
if (buf->buffer.size - offset < size) {
aml_realloc_object(buf, offset + size + 1);
}
strcpy(&buf->buffer.data[offset], obj->str.string);
AML_DEBUGPRINT("[Store string to buffer]");
break;
case aml_t_buffer:
bzero(buf->buffer.data, buf->buffer.size);
if (obj->buffer.size > buf->buffer.size) {
size = buf->buffer.size;
} else {
size = obj->buffer.size;
}
bcopy(obj->buffer.data, buf->buffer.data, size);
break;
case aml_t_regfield:
bitlen = (buf->buffer.size - offset) * 8;
if (bitlen > obj->regfield.bitlen) {
bitlen = obj->regfield.bitlen;
}
aml_region_read_into_buffer(env, obj->regfield.space,
obj->regfield.flags, obj->regfield.offset,
obj->regfield.bitoffset, bitlen,
buf->buffer.data + offset);
break;
default:
goto not_yet;
}
return;
not_yet:
AML_DEBUGPRINT("[XXX not supported yet]");
}
void
aml_store_to_object(struct aml_environ *env, union aml_object *src,
union aml_object * dest)
{
char *buffer, *srcbuf;
int offset, bitlen;
switch (dest->type) {
case aml_t_num:
if (src->type == aml_t_num) {
dest->num = src->num;
AML_DEBUGPRINT("[Store number 0x%x]", src->num.number);
} else {
env->stat = aml_stat_panic;
}
break;
case aml_t_string:
case aml_t_package:
break;
case aml_t_buffer:
aml_store_to_buffer(env, src, dest, 0);
break;
case aml_t_bufferfield:
buffer = dest->bfld.origin;
offset = dest->bfld.bitoffset;
bitlen = dest->bfld.bitlen;
switch (src->type) {
case aml_t_num:
if (aml_bufferfield_write(src->num.number, buffer, offset, bitlen)) {
AML_DEBUGPRINT("aml_bufferfield_write() failed\n");
}
break;
case aml_t_buffer:
case aml_t_bufferfield:
if (src->type == aml_t_buffer) {
srcbuf = src->buffer.data;
} else {
srcbuf = src->bfld.origin;
srcbuf += src->bfld.bitoffset / 8;
}
bcopy(srcbuf, buffer, bitlen / 8);
break;
case aml_t_regfield:
aml_region_read_into_buffer(env, src->regfield.space,
src->regfield.flags, src->regfield.offset,
src->regfield.bitoffset, src->regfield.bitlen,
buffer);
break;
default:
AML_DEBUGPRINT("not implemented yet");
break;
}
break;
case aml_t_debug:
aml_showobject(src);
break;
default:
AML_DEBUGPRINT("[Unimplemented %d]", dest->type);
break;
}
}
static void
aml_store_to_objref(struct aml_environ *env, union aml_object *obj,
union aml_object *r)
{
int offset;
union aml_object *ref;
if (r->objref.ref == NULL) {
r->objref.ref = aml_alloc_object(obj->type, NULL); /* XXX */
r->objref.nameref->property = r->objref.ref;
}
ref = r->objref.ref;
switch (ref->type) {
case aml_t_buffer:
offset = r->objref.offset;
aml_store_to_buffer(env, obj, ref, r->objref.offset);
break;
case aml_t_package:
offset = r->objref.offset;
if (r->objref.ref->package.elements < offset) {
aml_realloc_object(ref, offset);
}
if (ref->package.objects[offset] == NULL) {
ref->package.objects[offset] = aml_copy_object(env, obj);
} else {
aml_store_to_object(env, obj, ref->package.objects[offset]);
}
break;
default:
aml_store_to_object(env, obj, ref);
break;
}
}
/*
* Store to Named object
*/
void
aml_store_to_name(struct aml_environ *env, union aml_object *obj,
struct aml_name *name)
{
struct aml_name *wname;
if (env->stat == aml_stat_panic) {
return;
}
if (name == NULL || obj == NULL) {
AML_DEBUGPRINT("[Try to store no existant name ]");
return;
}
if (name->property == NULL) {
name->property = aml_copy_object(env, obj);
AML_DEBUGPRINT("[Copy number 0x%x]", obj->num.number);
return;
}
if (name->property->type == aml_t_namestr) {
wname = aml_search_name(env, name->property->nstr.dp);
name = wname;
}
if (name == NULL) {
env->stat = aml_stat_panic;
return;
}
if (name->property == NULL || name->property->type == aml_t_null) {
name->property = aml_copy_object(env, obj);
AML_DEBUGPRINT("[Copy number 0x%x]", obj->num.number);
return;
}
/* Writes to constant object are not allowed */
if (name->property != NULL && name->property->type == aml_t_num &&
name->property->num.constant == 1) {
return;
}
/* try to dereference */
if (obj->type == aml_t_objref && obj->objref.deref == 0) {
AML_DEBUGPRINT("Source object isn't dereferenced yet, "
"try to dereference anyway\n");
obj->objref.deref = 1;
obj = aml_eval_objref(env, obj);
}
switch (name->property->type) {
case aml_t_field:
aml_store_to_fieldname(env, obj, name);
break;
case aml_t_objref:
aml_store_to_objref(env, obj, name->property);
break;
case aml_t_num:
if (name == &env->tempname)
break;
default:
aml_store_to_object(env, obj, name->property);
break;
}
}