/*      $NetBSD: aml_common.c,v 1.5 2021/12/12 08:49:58 andvar Exp $    */

/*-
* Copyright (c) 1999 Takanori Watanabe
* Copyright (c) 1999, 2000 Mitsuru IWASAKI <[email protected]>
* 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_common.c,v 1.9 2000/08/09 14:47:43 iwasaki Exp
*      $FreeBSD: src/usr.sbin/acpi/amldb/aml/aml_common.c,v 1.6 2000/11/09 06:24:45 iwasaki Exp $
*/
#include <sys/cdefs.h>
__RCSID("$NetBSD: aml_common.c,v 1.5 2021/12/12 08:49:58 andvar Exp $");

#include <sys/param.h>

#ifndef _KERNEL
#include <assert.h>
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#else /* _KERNEL */
#include "opt_acpi.h"
#include <sys/kernel.h>
#include <sys/sysctl.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>
#ifndef ACPI_NO_OSDFUNC_INLINE
#include <machine/acpica_osd.h>
#endif /* !ACPI_NO_OSDFUNC_INLINE */
#endif /* !_KERNEL */

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

/* for debugging */
#ifdef AML_DEBUG
int     aml_debug = 1;
#else   /* !AML_DEBUG */
int     aml_debug = 0;
#endif  /* AML_DEBUG */
#ifdef _KERNEL
SYSCTL_INT(_debug, OID_AUTO, aml_debug, CTLFLAG_RW, &aml_debug, 1, "");
#endif /* _KERNEL */

static void      aml_print_nameseg(u_int8_t *dp);

static void
aml_print_nameseg(u_int8_t *dp)
{

       if (dp[3] != '_') {
               AML_DEBUGPRINT("%c%c%c%c", dp[0], dp[1], dp[2], dp[3]);
       } else if (dp[2] != '_') {
               AML_DEBUGPRINT("%c%c%c_", dp[0], dp[1], dp[2]);
       } else if (dp[1] != '_') {
               AML_DEBUGPRINT("%c%c__", dp[0], dp[1]);
       } else if (dp[0] != '_') {
               AML_DEBUGPRINT("%c___", dp[0]);
       }
}

void
aml_print_namestring(u_int8_t *dp)
{
       int     segcount;
       int     i;

       if (dp[0] == '\\') {
               AML_DEBUGPRINT("%c", dp[0]);
               dp++;
       } else if (dp[0] == '^') {
               while (dp[0] == '^') {
                       AML_DEBUGPRINT("%c", dp[0]);
                       dp++;
               }
       }
       if (dp[0] == 0x00) {    /* NullName */
               /* AML_DEBUGPRINT("<null>"); */
               dp++;
       } else if (dp[0] == 0x2e) {     /* DualNamePrefix */
               aml_print_nameseg(dp + 1);
               AML_DEBUGPRINT("%c", '.');
               aml_print_nameseg(dp + 5);
       } else if (dp[0] == 0x2f) {     /* MultiNamePrefix */
               segcount = dp[1];
               for (i = 0, dp += 2; i < segcount; i++, dp += 4) {
                       if (i > 0) {
                               AML_DEBUGPRINT("%c", '.');
                       }
                       aml_print_nameseg(dp);
               }
       } else                  /* NameSeg */
               aml_print_nameseg(dp);
}

int
aml_print_curname(struct aml_name *name)
{
       struct  aml_name *root;

       root = aml_get_rootname();
       if (name == root) {
               AML_DEBUGPRINT("\\");
               return (0);
       } else {
               aml_print_curname(name->parent);
       }
       aml_print_nameseg((unsigned char *)name->name);
       AML_DEBUGPRINT(".");
       return (0);
}

void
aml_print_indent(int indent)
{
       int     i;

       for (i = 0; i < indent; i++)
               AML_DEBUGPRINT("    ");
}

void
aml_showobject(union aml_object * obj)
{
       int     debug;
       int     i;

       if (obj == NULL) {
               printf("NO object\n");
               return;
       }
       debug = aml_debug;
       aml_debug = 1;
       switch (obj->type) {
       case aml_t_num:
               printf("Num:0x%x\n", obj->num.number);
               break;
       case aml_t_processor:
               printf("Processor:No %d,Port 0x%x length 0x%x\n",
                   obj->proc.id, obj->proc.addr, obj->proc.len);
               break;
       case aml_t_mutex:
               printf("Mutex:Level %d\n", obj->mutex.level);
               break;
       case aml_t_powerres:
               printf("PowerResource:Level %d Order %d\n",
                   obj->pres.level, obj->pres.order);
               break;
       case aml_t_opregion:
               printf("OperationRegion:Busspace%d, Offset 0x%x Length 0x%x\n",
                   obj->opregion.space, obj->opregion.offset,
                   obj->opregion.length);
               break;
       case aml_t_field:
               printf("Fieldelement:flag 0x%x offset 0x%x len 0x%x {",
                   obj->field.flags, obj->field.bitoffset,
                   obj->field.bitlen);
               switch (obj->field.f.ftype) {
               case f_t_field:
                       aml_print_namestring(obj->field.f.fld.regname);
                       break;
               case f_t_index:
                       aml_print_namestring(obj->field.f.ifld.indexname);
                       printf(" ");
                       aml_print_namestring(obj->field.f.ifld.dataname);
                       break;
               case f_t_bank:
                       aml_print_namestring(obj->field.f.bfld.regname);
                       printf(" ");
                       aml_print_namestring(obj->field.f.bfld.bankname);
                       printf("0x%x", obj->field.f.bfld.bankvalue);
                       break;
               }
               printf("}\n");
               break;
       case aml_t_method:
               printf("Method: Arg %d From %p To %p\n", obj->meth.argnum,
                   obj->meth.from, obj->meth.to);
               break;
       case aml_t_buffer:
               printf("Buffer: size:0x%x Data %p\n", obj->buffer.size,
                   obj->buffer.data);
               break;
       case aml_t_device:
               printf("Device\n");
               break;
       case aml_t_bufferfield:
               printf("Bufferfield:offset 0x%x len 0x%x Origin %p\n",
                   obj->bfld.bitoffset, obj->bfld.bitlen, obj->bfld.origin);
               break;
       case aml_t_string:
               printf("String:%s\n", obj->str.string);
               break;
       case aml_t_package:
               printf("Package:elements %d \n", obj->package.elements);
               for (i = 0; i < obj->package.elements; i++) {
                       if (obj->package.objects[i] == NULL) {
                               break;
                       }
                       if (obj->package.objects[i]->type < 0) {
                               continue;
                       }
                       printf("        ");
                       aml_showobject(obj->package.objects[i]);
               }
               break;
       case aml_t_therm:
               printf("Thermalzone\n");
               break;
       case aml_t_event:
               printf("Event\n");
               break;
       case aml_t_ddbhandle:
               printf("DDBHANDLE\n");
               break;
       case aml_t_objref:
               if (obj->objref.alias == 1) {
                       printf("Alias");
               } else {
                       printf("Object reference");
                       if (obj->objref.offset >= 0) {
                               printf(" (offset 0x%x)", obj->objref.offset);
                       }
               }
               printf(" of ");
               aml_showobject(obj->objref.ref);
               break;
       default:
               printf("UNK ID=%d\n", obj->type);
       }

       aml_debug = debug;
}

void
aml_showtree(struct aml_name * aname, int lev)
{
       int     i;
       struct  aml_name *ptr;
       char    name[5];

       for (i = 0; i < lev; i++) {
               printf("  ");
       }
       strncpy(name, aname->name, 4);
       name[4] = 0;
       printf("%s  ", name);
       if (aname->property != NULL) {
               aml_showobject(aname->property);
       } else {
               printf("\n");
       }
       for (ptr = aname->child; ptr; ptr = ptr->brother)
               aml_showtree(ptr, lev + 1);
}

/*
* Common Region I/O Stuff
*/

static __inline u_int64_t
aml_adjust_bitmask(u_int32_t flags, u_int32_t bitlen)
{
       u_int64_t       bitmask;

       switch (AML_FIELDFLAGS_ACCESSTYPE(flags)) {
       case AML_FIELDFLAGS_ACCESS_ANYACC:
               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;
       }

       switch (bitlen) {
       case 16:
               bitmask |= 0x0000ffff;
               break;
       case 32:
               bitmask |= 0xffffffff;
               break;
       }

       return (bitmask);
}

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       offset, retval;
       u_int64_t       bitmask;

       offset = bitoffset;     /* XXX bitoffset may change in this function! */
       bitmask = aml_adjust_bitmask(flags, bitlen);
       retval = (orgval >> offset) & (~(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       offset, retval;
       u_int64_t       bitmask;

       offset = bitoffset;     /* XXX bitoffset may change in this function! */
       bitmask = aml_adjust_bitmask(flags, bitlen);
       retval = orgval;
       switch (AML_FIELDFLAGS_UPDATERULE(flags)) {
       case AML_FIELDFLAGS_UPDATE_PRESERVE:
               retval &= (~(((u_int64_t)1 << bitlen) - 1) << offset) |
                         (~(bitmask << offset));
               break;
       case AML_FIELDFLAGS_UPDATE_WRITEASONES:
               retval =  (~(((u_int64_t)1 << bitlen) - 1) << offset) |
                         (~(bitmask << offset));
               retval &= bitmask;      /* trim the upper bits */
               break;
       case AML_FIELDFLAGS_UPDATE_WRITEASZEROS:
               retval = 0;
               break;
       default:
               printf("illegal update rule: %d\n", flags);
               return (orgval);
       }

       retval |= (value << (offset & bitmask));
       return (retval);
}

/*
* BufferField I/O
*/

#define AML_BUFFER_INPUT        0
#define AML_BUFFER_OUTPUT       1

static int       aml_bufferfield_io(int io, u_int32_t *valuep,
                                   u_int8_t *origin, u_int32_t bitoffset,
                                   u_int32_t bitlen);

static int
aml_bufferfield_io(int io, u_int32_t *valuep, u_int8_t *origin,
   u_int32_t bitoffset, u_int32_t bitlen)
{
       u_int8_t        val, tmp, masklow, maskhigh;
       u_int8_t        offsetlow, offsethigh;
       u_int8_t        *addr;
       u_int32_t       value, readval;
       u_int32_t       byteoffset, bytelen, i;

       masklow = maskhigh = 0xff;
       val = readval = 0;
       value = *valuep;

       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_BYTEACC,
                           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_BYTEACC,
                           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;
       } else {
               offsethigh = 0;
       }

       if (offsetlow) {
               masklow = (~((1 << bitlen) - 1) << offsetlow) | ~(0xff << offsetlow);
               AML_DEBUGPRINT("\t[offsetlow = 0x%x, masklow = 0x%x, ~masklow = 0x%x]\n",
                   offsetlow, masklow, ~masklow & 0xff);
       }
       if (offsethigh) {
               maskhigh = 0xff << offsethigh;
               AML_DEBUGPRINT("\t[offsethigh = 0x%x, maskhigh = 0x%x, ~maskhigh = 0x%x]\n",
                   offsethigh, maskhigh, ~maskhigh & 0xff);
       }
       for (i = bytelen; i > 0; i--, addr++) {
               val = *addr;

               AML_DEBUGPRINT("\t[bufferfield:0x%02x@%p]", val, addr);

               switch (io) {
               case AML_BUFFER_INPUT:
                       tmp = val;
                       /* the lowest byte? */
                       if (i == bytelen) {
                               if (offsetlow) {
                                       readval = tmp & ~masklow;
                               } else {
                                       readval = tmp;
                               }
                       } else {
                               if (i == 1 && offsethigh) {
                                       tmp = tmp & ~maskhigh;
                               }
                               readval = (tmp << (8 * (bytelen - i))) | readval;
                       }

                       AML_DEBUGPRINT("\n");
                       /* goto to next byte... */
                       if (i > 1) {
                               continue;
                       }
                       /* final adjustment before finishing region access */
                       if (offsetlow) {
                               readval = readval >> offsetlow;
                       }
                       AML_DEBUGPRINT("[read(bufferfield, %p)&mask:0x%x]\n",
                           addr, readval);
                       *valuep = readval;

                       break;

               case AML_BUFFER_OUTPUT:
                       tmp = value & 0xff;
                       /* the lowest byte? */
                       if (i == bytelen) {
                               if (offsetlow) {
                                       tmp = (val & masklow) | tmp << offsetlow;
                               }
                               value = value >> (8 - offsetlow);
                       } else {
                               if (i == 1 && offsethigh) {
                                       tmp = (val & maskhigh) | tmp;
                               }
                               value = value >> 8;
                       }

                       AML_DEBUGPRINT("->[bufferfield:0x%02x@%p]\n",
                           tmp, addr);
                       *addr = tmp;
               }
       }
out:
       return (0);
}

u_int32_t
aml_bufferfield_read(u_int8_t *origin, u_int32_t bitoffset,
   u_int32_t bitlen)
{
       int     value;

       value = 0;
       aml_bufferfield_io(AML_BUFFER_INPUT, (u_int32_t *)&value, origin,
           bitoffset, bitlen);
       return (value);
}

int
aml_bufferfield_write(u_int32_t value, u_int8_t *origin,
   u_int32_t bitoffset, u_int32_t bitlen)
{
       int     status;

       status = aml_bufferfield_io(AML_BUFFER_OUTPUT, &value,
           origin, bitoffset, bitlen);
       return (status);
}

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 *h)
{
       int     state;

       state = 0;
       bzero(h, sizeof(struct aml_region_handle));

       h->env = env;
       h->regtype = regtype;
       h->flags = flags;
       h->baseaddr = baseaddr;
       h->bitoffset = bitoffset;
       h->bitlen = bitlen;

       switch (AML_FIELDFLAGS_ACCESSTYPE(flags)) {
       case AML_FIELDFLAGS_ACCESS_ANYACC:
               if (bitlen <= 8) {
                       h->unit = 1;
                       break;
               }
               if (bitlen <= 16) {
                       h->unit = 2;
                       break;
               }
               h->unit = 4;
               break;
       case AML_FIELDFLAGS_ACCESS_BYTEACC:
               h->unit = 1;
               break;
       case AML_FIELDFLAGS_ACCESS_WORDACC:
               h->unit = 2;
               break;
       case AML_FIELDFLAGS_ACCESS_DWORDACC:
               h->unit = 4;
               break;
       default:
               h->unit = 1;
               break;
       }

       h->addr = baseaddr + h->unit * ((bitoffset / 8) / h->unit);
       h->bytelen = baseaddr + ((bitoffset + bitlen) / 8) - h->addr +
                    ((bitlen % 8) ? 1 : 0);

#ifdef _KERNEL
       switch (h->regtype) {
       case AML_REGION_SYSMEM:
               OsdMapMemory((void *)h->addr, h->bytelen, (void **)&h->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");
                       h->pci_bus = 0;
               } else {
                       AML_DEBUGPRINT("found _BBN: %d\n",
                           pci_info->property->num.number);
                       h->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;
               }
               h->pci_devfunc = pci_info->property->num.number;

               AML_DEBUGPRINT("[pci%d.%d]", h->pci_bus, h->pci_devfunc);
               break;

       default:
               break;
       }

out:
#endif  /* _KERNEL */
       return (state);
}

void
aml_region_handle_free(struct aml_region_handle *h)
{
#ifdef _KERNEL
       switch (h->regtype) {
       case AML_REGION_SYSMEM:
               OsdUnMapMemory((void *)h->vaddr, h->bytelen);
               break;

       default:
               break;
       }
#endif  /* _KERNEL */
}

static 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       readval, value, offset, bytelen, i;
       struct          aml_region_handle handle;

       state = aml_region_handle_alloc(env, regtype, flags,
           baseaddr, bitoffset, bitlen, &handle);
       if (state == -1) {
               goto out;
       }

       readval = 0;
       offset = bitoffset % (handle.unit * 8);
       /* limitation of 32 bits alignment */
       bytelen = (handle.bytelen > 4) ? 4 : handle.bytelen;

       if (io == AML_REGION_INPUT ||
           AML_FIELDFLAGS_UPDATERULE(flags) == AML_FIELDFLAGS_UPDATE_PRESERVE) {
               for (i = 0; i < bytelen; i += handle.unit) {
                       state = aml_region_read_simple(&handle, i, &value);
                       if (state == -1) {
                               goto out;
                       }
                       readval |= (value << (i * 8));
               }
               AML_DEBUGPRINT("\t[%d:0x%x@0x%lx:%d,%d]",
                   regtype, readval, handle.addr, offset, bitlen);
       }

       switch (io) {
       case AML_REGION_INPUT:
               AML_DEBUGPRINT("\n");
               readval = aml_adjust_readvalue(flags, offset, 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;
               value = aml_adjust_updatevalue(flags, offset,
                   bitlen, readval, value);
               value = aml_region_prompt_write(&handle, value);
               AML_DEBUGPRINT("\t->[%d:0x%x@0x%lx:%d,%d]\n", regtype, value,
                   handle.addr, offset, bitlen);
               for (i = 0; i < bytelen; i += handle.unit) {
                       state = aml_region_write_simple(&handle, i, value);
                       if (state == -1) {
                               goto out;
                       }
                       value = value >> (handle.unit * 8);
               }
               break;
       }

       aml_region_handle_free(&handle);
out:
       return (state);
}

int
aml_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)
{
       u_int32_t       unit, offset;
       u_int32_t       offadj, bitadj;
       u_int32_t       value, readval, i;
       int             state;

       readval = 0;
       state = 0;
       unit = 4;       /* limitation of 32 bits alignment */
       offset = bitoffset % (unit * 8);
       offadj = 0;
       bitadj = 0;
       if (offset + bitlen > unit * 8) {
               bitadj = bitlen  - (unit * 8 - offset);
       }
       for (i = 0; i < offset + bitlen; i += unit * 8) {
               value = (*valuep) >> offadj;
               state = aml_region_io_simple(env, io, regtype, flags,
                   &value, baseaddr, bitoffset + offadj, bitlen - bitadj);
               if (state == -1) {
                       goto out;
               }
               readval |= value << offadj;
               bitadj = offadj = bitlen - bitadj;
       }
       *valuep = readval;

out:
       return (state);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.