/*      $NetBSD: aml_evalobj.c,v 1.4 2024/07/31 20:15:33 andvar 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_evalobj.c,v 1.27 2000/08/16 18:14:53 iwasaki Exp 
 *      $FreeBSD: src/usr.sbin/acpi/amldb/aml/aml_evalobj.c,v 1.4 2000/11/09 06:24:45 iwasaki Exp $
 */
#include <sys/cdefs.h>
__RCSID("$NetBSD: aml_evalobj.c,v 1.4 2024/07/31 20:15:33 andvar Exp $");

#include <sys/param.h>

#include <acpi_common.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_parse.h>
#include <aml/aml_region.h>
#include <aml/aml_status.h>
#include <aml/aml_store.h>

#ifndef _KERNEL
#include <sys/param.h>
#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>

#include "debug.h"
#else /* _KERNEL */
#include <sys/systm.h>
#endif /* !_KERNEL */

static union aml_object *aml_eval_fieldobject(struct aml_environ *env,
                                              struct aml_name *name);

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) {
                printf("????\n");
                env->stat = aml_stat_panic;
                return (NULL);
        }
        field = &name->property->field;
        oname = env->curname;
        if (field->bitlen > 32) {
                env->tempobject.type = aml_t_regfield;
        } else {
                env->tempobject.type = aml_t_num;
        }
        env->curname = name;
        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("Inappropriate Type\n");
                        env->stat = aml_stat_panic;
                        env->curname = oname;
                        return (NULL);
                }
                or = &wname->property->opregion;
                if (env->tempobject.type == aml_t_regfield) {
                        env->tempobject.regfield.space = or->space;
                        env->tempobject.regfield.flags = field->flags;
                        env->tempobject.regfield.offset = or->offset;
                        env->tempobject.regfield.bitoffset = field->bitoffset;
                        env->tempobject.regfield.bitlen = field->bitlen;
                } else {
                        env->tempobject.type = aml_t_num;
                        env->tempobject.num.number = aml_region_read(env,
                            or->space, field->flags, or->offset,
                            field->bitoffset, field->bitlen);
                        AML_DEBUGPRINT("[read(%d, 0x%x)->0x%x]",
                            or->space, or->offset + field->bitoffset / 8,
                            env->tempobject.num.number);
                }
        } 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);
                wname = aml_search_name(env, field->f.ifld.dataname);
                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);
}

union aml_object *
aml_eval_objref(struct aml_environ *env, union aml_object *obj)
{
        int     offset;
        union   aml_object num1;
        union   aml_object *ref, *ret;

        ret = obj;
        if (obj->objref.deref == 1) {
                num1.type = aml_t_num;
                offset = obj->objref.offset;
                ref = obj->objref.ref;
                if (ref == NULL) {
                        goto out;
                }
                switch (ref->type) {
                case aml_t_package:
                        if (ref->package.elements > offset) {
                                ret = ref->package.objects[offset];
                        } else {
                                num1.num.number = 0;
                                env->tempobject = num1;
                                ret = &env->tempobject;
                        }
                        break;
                case aml_t_buffer:
                        if (ref->buffer.size > offset) {
                                num1.num.number = ref->buffer.data[offset] & 0xff;
                        } else {
                                num1.num.number = 0;
                        }
                        env->tempobject = num1;
                        ret = &env->tempobject;
                        break;
                default:
                        break;
                }
        }
        if (obj->objref.alias == 1) {
                ret = aml_eval_name(env, obj->objref.nameref);
                goto out;
        }
out:
        return (ret);
}

/*
 * Eval named object.
 */
union aml_object *
aml_eval_name(struct aml_environ *env, struct aml_name *aname)
{
        int     argnum, i;
        int     num;
        struct  aml_name *tmp;
        struct  aml_environ *copy;
        struct  aml_local_stack *stack;
        union   aml_object *obj, *ret;
        union   aml_object *src;

        ret = NULL;
        if (aname == NULL || aname->property == NULL) {
                return (NULL);
        }
        if (env->stat == aml_stat_panic) {
                return (NULL);
        }
        copy = memman_alloc(aml_memman, memid_aml_environ);
        if (copy == NULL) {
                return (NULL);
        }
        ret = aname->property;
        i = 0;
reevaluate:
        if (i > 10) {
                env->stat = aml_stat_panic;
                printf("TOO MANY LOOP\n");
                ret = NULL;
                goto out;
        }
        switch (aname->property->type) {
        case aml_t_namestr:
                tmp = aname;
                aname = aml_search_name(env, aname->property->nstr.dp);
                if (aname == NULL) {
                        aname = tmp;
                }
                i++;
                goto reevaluate;
        case aml_t_objref:
                ret = aml_eval_objref(env, aname->property);
                goto out;
        case aml_t_num:
        case aml_t_string:
        case aml_t_buffer:
        case aml_t_package:
        case aml_t_debug:
                ret = aname->property;
                goto out;
        case aml_t_field:
                aml_free_objectcontent(&env->tempobject);
                ret = aml_eval_fieldobject(env, aname);
                goto out;
        case aml_t_method:
                aml_free_objectcontent(&env->tempobject);
                argnum = aname->property->meth.argnum & 7;
                *copy = *env;
                copy->curname = aname;
                copy->dp = aname->property->meth.from;
                copy->end = aname->property->meth.to;
                copy->stat = aml_stat_none;
                stack = aml_local_stack_create();
                AML_DEBUGPRINT("(");
                for (i = 0; i < argnum; i++) {
                        aml_local_stack_getArgX(stack, i)->property =
                            aml_copy_object(env,
                                aml_eval_name(env,
                                    aml_parse_termobj(env, 0)));
                        if (i < argnum - 1)
                                AML_DEBUGPRINT(", ");
                }
                AML_DEBUGPRINT(")\n");
                aml_local_stack_push(stack);
                if (env->stat == aml_stat_step) {
                        AML_DEBUGGER(env, copy);
                }
                tmp = aml_execute_method(copy);
                obj = aml_eval_name(env, tmp);
                if (copy->stat == aml_stat_panic) {
                        AML_DEBUGPRINT("PANIC OCCURRED IN METHOD");
                        env->stat = aml_stat_panic;
                        ret = NULL;
                        aml_local_stack_delete(aml_local_stack_pop());
                        goto out;
                }
                if (aml_debug) {
                        aml_showobject(obj);
                }

                if (tmp)
                        tmp->property = NULL;
                aml_local_stack_delete(aml_local_stack_pop());
                if (obj) {
                        aml_create_local_object()->property = obj;
                        ret = obj;
                } else {
                        env->tempobject.type = aml_t_num;
                        env->tempobject.num.number = 0;
                }

                goto out;
        case aml_t_bufferfield:
                aml_free_objectcontent(&env->tempobject);
                if (aname->property->bfld.bitlen > 32) {
                        ret = aname->property;
                } else {
                        src = aname->property;
                        num = aml_bufferfield_read(src->bfld.origin,
                            src->bfld.bitoffset, src->bfld.bitlen);
                        env->tempobject.type = aml_t_num;
                        env->tempobject.num.number = num;
                        ret = &env->tempobject;
                }
                goto out;
        default:
                AML_DEBUGPRINT("I eval the object that I should not eval, %s%d",
                    aname->name, aname->property->type);
                AML_SYSABORT();
                ret = NULL;
                goto out;
        }
out:
        memman_free(aml_memman, memid_aml_environ, copy);
        return (ret);
}

/*
 * Eval named object but env variable is not required and return
 * status of evaluation (success is zero).  This function is assumed
 * to be called by aml_apply_foreach_found_objects().
 * Note that no arguments are passed if object is a method.
 */

int
aml_eval_name_simple(struct aml_name *name, va_list ap)
{
        struct  aml_environ *env;
        union   aml_object *ret;

        if (name == NULL || name->property == NULL) {
                return (1);
        }

        env = memman_alloc(aml_memman, memid_aml_environ);
        if (env == NULL) {
                return (1);
        }
        bzero(env, sizeof(struct aml_environ));

        aml_local_stack_push(aml_local_stack_create());

        AML_DEBUGPRINT("Evaluating ");
        aml_print_curname(name);
        ret = aml_eval_name(env, name);
        if (name->property->type != aml_t_method) {
                AML_DEBUGPRINT("\n");
                if (aml_debug) {
                        aml_showobject(ret);
                }
        }

        aml_local_stack_delete(aml_local_stack_pop());

        memman_free(aml_memman, memid_aml_environ, env);
        return (0);
}

int
aml_objtonum(struct aml_environ *env, union aml_object *obj)
{

        if (obj != NULL && obj->type == aml_t_num) {
                return (obj->num.number);
        } else {
                env->stat = aml_stat_panic;
                return (-1);
        }
}

struct aml_name *
aml_execute_method(struct aml_environ *env)
{
        struct  aml_name *name;
        struct  aml_name_group *newgrp;

        newgrp = aml_new_name_group((void *)AML_NAME_GROUP_IN_METHOD);

        AML_DEBUGPRINT("[");
        aml_print_curname(env->curname);
        AML_DEBUGPRINT(" START]\n");

        name = aml_parse_objectlist(env, 0);
        AML_DEBUGPRINT("[");
        aml_print_curname(env->curname);
        AML_DEBUGPRINT(" END]\n");

        aml_delete_name_group(newgrp);
        return (name);
}

union aml_object *
aml_invoke_method(struct aml_name *name, int argc, union aml_object *argv)
{
        int     i;
        struct  aml_name *tmp;
        struct  aml_environ *env;
        struct  aml_local_stack *stack;
        union   aml_object *retval;
        union   aml_object *obj;

        retval = NULL;
        env = memman_alloc(aml_memman, memid_aml_environ);
        if (env == NULL) {
                return (NULL);
        }
        bzero(env, sizeof(struct aml_environ));

        if (name != NULL && name->property != NULL &&
            name->property->type == aml_t_method) {
                env->curname = name;
                env->dp = name->property->meth.from;
                env->end = name->property->meth.to;
                AML_DEBUGGER(env, env);
                stack = aml_local_stack_create();
                for (i = 0; i < argc; i++) {
                        aml_local_stack_getArgX(stack, i)->property =
                            aml_alloc_object(argv[i].type, &argv[i]);
                }
                aml_local_stack_push(stack);
                obj = aml_eval_name(env, tmp = aml_execute_method(env));
                if (aml_debug) {
                        aml_showtree(name, 0);
                }

                if (tmp)
                        tmp->property = NULL;
                aml_local_stack_delete(aml_local_stack_pop());
                if (obj) {
                        aml_create_local_object()->property = obj;
                        retval = obj;
                }
        }
        memman_free(aml_memman, memid_aml_environ, env);
        return (retval);
}

union aml_object *
aml_invoke_method_by_name(char *method, int argc, union aml_object *argv)
{
        struct  aml_name *name;

        name = aml_find_from_namespace(aml_get_rootname(), method);
        if (name == NULL) {
                return (NULL);
        }

        return (aml_invoke_method(name, argc, argv));
}