271 lines
7.1 KiB
C
271 lines
7.1 KiB
C
/* $NetBSD: aml_obj.c,v 1.2 2009/01/18 09:46:59 lukem Exp $ */
|
|
|
|
/*-
|
|
* 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_obj.c,v 1.17 2000/08/12 15:20:45 iwasaki Exp
|
|
* $FreeBSD: src/usr.sbin/acpi/amldb/aml/aml_obj.c,v 1.3 2000/11/09 06:24:45 iwasaki Exp $
|
|
*/
|
|
#include <sys/cdefs.h>
|
|
__RCSID("$NetBSD: aml_obj.c,v 1.2 2009/01/18 09:46:59 lukem Exp $");
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <acpi_common.h>
|
|
#include <aml/aml_amlmem.h>
|
|
#include <aml/aml_env.h>
|
|
#include <aml/aml_name.h>
|
|
#include <aml/aml_obj.h>
|
|
#include <aml/aml_status.h>
|
|
#include <aml/aml_store.h>
|
|
|
|
#ifndef _KERNEL
|
|
#include <sys/stat.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include <assert.h>
|
|
#include <err.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#else /* _KERNEL */
|
|
#include <sys/systm.h>
|
|
#endif /* !_KERNEL */
|
|
|
|
union aml_object *
|
|
aml_copy_object(struct aml_environ *env, union aml_object *orig)
|
|
{
|
|
int i;
|
|
union aml_object *ret;
|
|
|
|
if (orig == NULL)
|
|
return (NULL);
|
|
switch (orig->type) {
|
|
case aml_t_regfield:
|
|
ret = aml_alloc_object(aml_t_buffer, 0);
|
|
ret->buffer.size = (orig->regfield.bitlen / 8) +
|
|
((orig->regfield.bitlen % 8) ? 1 : 0);
|
|
if (ret->buffer.size == 0) {
|
|
goto out;
|
|
}
|
|
ret->buffer.data = memman_alloc_flexsize(aml_memman, ret->buffer.size);
|
|
aml_store_to_object(env, orig, ret);
|
|
break;
|
|
|
|
default:
|
|
ret = aml_alloc_object(0, orig);
|
|
break;
|
|
}
|
|
|
|
if (1 || orig != &env->tempobject) { /* XXX */
|
|
if (orig->type == aml_t_buffer) {
|
|
if (orig->buffer.size == 0) {
|
|
goto out;
|
|
}
|
|
ret->buffer.data = memman_alloc_flexsize(aml_memman,
|
|
orig->buffer.size);
|
|
bcopy(orig->buffer.data, ret->buffer.data, orig->buffer.size);
|
|
} else if (orig->type == aml_t_package) {
|
|
if (ret->package.elements == 0) {
|
|
goto out;
|
|
}
|
|
ret->package.objects = memman_alloc_flexsize(aml_memman,
|
|
ret->package.elements * sizeof(union aml_object *));
|
|
for (i = 0; i < ret->package.elements; i++) {
|
|
ret->package.objects[i] = aml_copy_object(env, orig->package.objects[i]);
|
|
}
|
|
} else if (orig->type == aml_t_string && orig->str.needfree != 0) {
|
|
ret->str.string = memman_alloc_flexsize(aml_memman,
|
|
strlen((const char *)orig->str.string) + 1);
|
|
strcpy((char *)orig->str.string,
|
|
(const char *)ret->str.string);
|
|
} else if (orig->type == aml_t_num) {
|
|
ret->num.constant = 0;
|
|
}
|
|
} else {
|
|
printf("%s:%d\n", __FILE__, __LINE__);
|
|
env->tempobject.type = aml_t_null;
|
|
}
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* This function have two function: copy or allocate. if orig != NULL,
|
|
* orig is duplicated.
|
|
*/
|
|
|
|
union aml_object *
|
|
aml_alloc_object(enum aml_objtype type, union aml_object *orig)
|
|
{
|
|
unsigned int memid;
|
|
union aml_object *ret;
|
|
|
|
if (orig != NULL) {
|
|
type = orig->type;
|
|
}
|
|
switch (type) {
|
|
case aml_t_namestr:
|
|
memid = memid_aml_namestr;
|
|
break;
|
|
case aml_t_buffer:
|
|
memid = memid_aml_buffer;
|
|
break;
|
|
case aml_t_string:
|
|
memid = memid_aml_string;
|
|
break;
|
|
case aml_t_bufferfield:
|
|
memid = memid_aml_bufferfield;
|
|
break;
|
|
case aml_t_package:
|
|
memid = memid_aml_package;
|
|
break;
|
|
case aml_t_num:
|
|
memid = memid_aml_num;
|
|
break;
|
|
case aml_t_powerres:
|
|
memid = memid_aml_powerres;
|
|
break;
|
|
case aml_t_opregion:
|
|
memid = memid_aml_opregion;
|
|
break;
|
|
case aml_t_method:
|
|
memid = memid_aml_method;
|
|
break;
|
|
case aml_t_processor:
|
|
memid = memid_aml_processor;
|
|
break;
|
|
case aml_t_field:
|
|
memid = memid_aml_field;
|
|
break;
|
|
case aml_t_mutex:
|
|
memid = memid_aml_mutex;
|
|
break;
|
|
case aml_t_device:
|
|
memid = memid_aml_objtype;
|
|
break;
|
|
case aml_t_objref:
|
|
memid = memid_aml_objref;
|
|
break;
|
|
default:
|
|
memid = memid_aml_objtype;
|
|
break;
|
|
}
|
|
ret = memman_alloc(aml_memman, memid);
|
|
ret->type = type;
|
|
|
|
if (orig != NULL) {
|
|
bcopy(orig, ret, memman_memid2size(aml_memman, memid));
|
|
}
|
|
return (ret);
|
|
}
|
|
|
|
void
|
|
aml_free_objectcontent(union aml_object *obj)
|
|
{
|
|
int i;
|
|
|
|
if (obj->type == aml_t_buffer && obj->buffer.data != NULL) {
|
|
memman_free_flexsize(aml_memman, obj->buffer.data);
|
|
obj->buffer.data = NULL;
|
|
}
|
|
if (obj->type == aml_t_string && obj->str.string != NULL) {
|
|
if (obj->str.needfree != 0) {
|
|
memman_free_flexsize(aml_memman, obj->str.string);
|
|
obj->str.string = NULL;
|
|
}
|
|
}
|
|
if (obj->type == aml_t_package && obj->package.objects != NULL) {
|
|
for (i = 0; i < obj->package.elements; i++) {
|
|
aml_free_object(&obj->package.objects[i]);
|
|
}
|
|
memman_free_flexsize(aml_memman, obj->package.objects);
|
|
obj->package.objects = NULL;
|
|
}
|
|
}
|
|
|
|
void
|
|
aml_free_object(union aml_object **obj)
|
|
{
|
|
union aml_object *body;
|
|
|
|
body = *obj;
|
|
if (body == NULL) {
|
|
return;
|
|
}
|
|
aml_free_objectcontent(*obj);
|
|
memman_free(aml_memman, memid_unkown, *obj);
|
|
*obj = NULL;
|
|
}
|
|
|
|
void
|
|
aml_realloc_object(union aml_object *obj, int size)
|
|
{
|
|
int i;
|
|
enum aml_objtype type;
|
|
union aml_object tmp;
|
|
|
|
type = obj->type;
|
|
switch (type) {
|
|
case aml_t_buffer:
|
|
if (obj->buffer.size >= size) {
|
|
return;
|
|
}
|
|
tmp.buffer.size = size;
|
|
tmp.buffer.data = memman_alloc_flexsize(aml_memman, size);
|
|
bzero(tmp.buffer.data, size);
|
|
bcopy(obj->buffer.data, tmp.buffer.data, obj->buffer.size);
|
|
aml_free_objectcontent(obj);
|
|
*obj = tmp;
|
|
break;
|
|
case aml_t_string:
|
|
if ((int)strlen((const char *)obj->str.string) >= size) {
|
|
return;
|
|
}
|
|
tmp.str.string = memman_alloc_flexsize(aml_memman, size + 1);
|
|
strcpy((char *)tmp.str.string, (const char *)obj->str.string);
|
|
aml_free_objectcontent(obj);
|
|
*obj = tmp;
|
|
break;
|
|
case aml_t_package:
|
|
if (obj->package.elements >= size) {
|
|
return;
|
|
}
|
|
tmp.package.objects = memman_alloc_flexsize(aml_memman,
|
|
size * sizeof(union aml_object *));
|
|
bzero(tmp.package.objects, size * sizeof(union aml_object *));
|
|
for (i = 0; i < obj->package.elements; i++) {
|
|
tmp.package.objects[i] = obj->package.objects[i];
|
|
}
|
|
memman_free_flexsize(aml_memman, obj->package.objects);
|
|
obj->package.objects = tmp.package.objects;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|