1 /* $NetBSD: aml_common.c,v 1.1 2007/01/14 04:36:13 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 1999 Takanori Watanabe 5 * Copyright (c) 1999, 2000 Mitsuru IWASAKI <iwasaki@FreeBSD.org> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * Id: aml_common.c,v 1.9 2000/08/09 14:47:43 iwasaki Exp 30 * $FreeBSD: src/usr.sbin/acpi/amldb/aml/aml_common.c,v 1.6 2000/11/09 06:24:45 iwasaki Exp $ 31 */ 32 #include <sys/cdefs.h> 33 __RCSID("$NetBSD: aml_common.c,v 1.1 2007/01/14 04:36:13 christos Exp $"); 34 35 #include <sys/param.h> 36 37 #ifndef _KERNEL 38 #include <assert.h> 39 #include <err.h> 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <string.h> 43 #include <unistd.h> 44 #else /* _KERNEL */ 45 #include "opt_acpi.h" 46 #include <sys/kernel.h> 47 #include <sys/sysctl.h> 48 #include <sys/systm.h> 49 #include <sys/bus.h> 50 #include <machine/bus.h> 51 #include <dev/acpi/acpireg.h> 52 #include <dev/acpi/acpivar.h> 53 #ifndef ACPI_NO_OSDFUNC_INLINE 54 #include <machine/acpica_osd.h> 55 #endif /* !ACPI_NO_OSDFUNC_INLINE */ 56 #endif /* !_KERNEL */ 57 58 #include <acpi_common.h> 59 #include <aml/aml_common.h> 60 #include <aml/aml_env.h> 61 #include <aml/aml_evalobj.h> 62 #include <aml/aml_name.h> 63 #include <aml/aml_obj.h> 64 #include <aml/aml_parse.h> 65 #include <aml/aml_status.h> 66 #include <aml/aml_store.h> 67 68 /* for debugging */ 69 #ifdef AML_DEBUG 70 int aml_debug = 1; 71 #else /* !AML_DEBUG */ 72 int aml_debug = 0; 73 #endif /* AML_DEBUG */ 74 #ifdef _KERNEL 75 SYSCTL_INT(_debug, OID_AUTO, aml_debug, CTLFLAG_RW, &aml_debug, 1, ""); 76 #endif /* _KERNEL */ 77 78 static void aml_print_nameseg(u_int8_t *dp); 79 80 static void 81 aml_print_nameseg(u_int8_t *dp) 82 { 83 84 if (dp[3] != '_') { 85 AML_DEBUGPRINT("%c%c%c%c", dp[0], dp[1], dp[2], dp[3]); 86 } else if (dp[2] != '_') { 87 AML_DEBUGPRINT("%c%c%c_", dp[0], dp[1], dp[2]); 88 } else if (dp[1] != '_') { 89 AML_DEBUGPRINT("%c%c__", dp[0], dp[1]); 90 } else if (dp[0] != '_') { 91 AML_DEBUGPRINT("%c___", dp[0]); 92 } 93 } 94 95 void 96 aml_print_namestring(u_int8_t *dp) 97 { 98 int segcount; 99 int i; 100 101 if (dp[0] == '\\') { 102 AML_DEBUGPRINT("%c", dp[0]); 103 dp++; 104 } else if (dp[0] == '^') { 105 while (dp[0] == '^') { 106 AML_DEBUGPRINT("%c", dp[0]); 107 dp++; 108 } 109 } 110 if (dp[0] == 0x00) { /* NullName */ 111 /* AML_DEBUGPRINT("<null>"); */ 112 dp++; 113 } else if (dp[0] == 0x2e) { /* DualNamePrefix */ 114 aml_print_nameseg(dp + 1); 115 AML_DEBUGPRINT("%c", '.'); 116 aml_print_nameseg(dp + 5); 117 } else if (dp[0] == 0x2f) { /* MultiNamePrefix */ 118 segcount = dp[1]; 119 for (i = 0, dp += 2; i < segcount; i++, dp += 4) { 120 if (i > 0) { 121 AML_DEBUGPRINT("%c", '.'); 122 } 123 aml_print_nameseg(dp); 124 } 125 } else /* NameSeg */ 126 aml_print_nameseg(dp); 127 } 128 129 int 130 aml_print_curname(struct aml_name *name) 131 { 132 struct aml_name *root; 133 134 root = aml_get_rootname(); 135 if (name == root) { 136 AML_DEBUGPRINT("\\"); 137 return (0); 138 } else { 139 aml_print_curname(name->parent); 140 } 141 aml_print_nameseg((unsigned char *)name->name); 142 AML_DEBUGPRINT("."); 143 return (0); 144 } 145 146 void 147 aml_print_indent(int indent) 148 { 149 int i; 150 151 for (i = 0; i < indent; i++) 152 AML_DEBUGPRINT(" "); 153 } 154 155 void 156 aml_showobject(union aml_object * obj) 157 { 158 int debug; 159 int i; 160 161 if (obj == NULL) { 162 printf("NO object\n"); 163 return; 164 } 165 debug = aml_debug; 166 aml_debug = 1; 167 switch (obj->type) { 168 case aml_t_num: 169 printf("Num:0x%x\n", obj->num.number); 170 break; 171 case aml_t_processor: 172 printf("Processor:No %d,Port 0x%x length 0x%x\n", 173 obj->proc.id, obj->proc.addr, obj->proc.len); 174 break; 175 case aml_t_mutex: 176 printf("Mutex:Level %d\n", obj->mutex.level); 177 break; 178 case aml_t_powerres: 179 printf("PowerResource:Level %d Order %d\n", 180 obj->pres.level, obj->pres.order); 181 break; 182 case aml_t_opregion: 183 printf("OprationRegion:Busspace%d, Offset 0x%x Length 0x%x\n", 184 obj->opregion.space, obj->opregion.offset, 185 obj->opregion.length); 186 break; 187 case aml_t_field: 188 printf("Fieldelement:flag 0x%x offset 0x%x len 0x%x {", 189 obj->field.flags, obj->field.bitoffset, 190 obj->field.bitlen); 191 switch (obj->field.f.ftype) { 192 case f_t_field: 193 aml_print_namestring(obj->field.f.fld.regname); 194 break; 195 case f_t_index: 196 aml_print_namestring(obj->field.f.ifld.indexname); 197 printf(" "); 198 aml_print_namestring(obj->field.f.ifld.dataname); 199 break; 200 case f_t_bank: 201 aml_print_namestring(obj->field.f.bfld.regname); 202 printf(" "); 203 aml_print_namestring(obj->field.f.bfld.bankname); 204 printf("0x%x", obj->field.f.bfld.bankvalue); 205 break; 206 } 207 printf("}\n"); 208 break; 209 case aml_t_method: 210 printf("Method: Arg %d From %p To %p\n", obj->meth.argnum, 211 obj->meth.from, obj->meth.to); 212 break; 213 case aml_t_buffer: 214 printf("Buffer: size:0x%x Data %p\n", obj->buffer.size, 215 obj->buffer.data); 216 break; 217 case aml_t_device: 218 printf("Device\n"); 219 break; 220 case aml_t_bufferfield: 221 printf("Bufferfield:offset 0x%x len 0x%x Origin %p\n", 222 obj->bfld.bitoffset, obj->bfld.bitlen, obj->bfld.origin); 223 break; 224 case aml_t_string: 225 printf("String:%s\n", obj->str.string); 226 break; 227 case aml_t_package: 228 printf("Package:elements %d \n", obj->package.elements); 229 for (i = 0; i < obj->package.elements; i++) { 230 if (obj->package.objects[i] == NULL) { 231 break; 232 } 233 if (obj->package.objects[i]->type < 0) { 234 continue; 235 } 236 printf(" "); 237 aml_showobject(obj->package.objects[i]); 238 } 239 break; 240 case aml_t_therm: 241 printf("Thermalzone\n"); 242 break; 243 case aml_t_event: 244 printf("Event\n"); 245 break; 246 case aml_t_ddbhandle: 247 printf("DDBHANDLE\n"); 248 break; 249 case aml_t_objref: 250 if (obj->objref.alias == 1) { 251 printf("Alias"); 252 } else { 253 printf("Object reference"); 254 if (obj->objref.offset >= 0) { 255 printf(" (offset 0x%x)", obj->objref.offset); 256 } 257 } 258 printf(" of "); 259 aml_showobject(obj->objref.ref); 260 break; 261 default: 262 printf("UNK ID=%d\n", obj->type); 263 } 264 265 aml_debug = debug; 266 } 267 268 void 269 aml_showtree(struct aml_name * aname, int lev) 270 { 271 int i; 272 struct aml_name *ptr; 273 char name[5]; 274 275 for (i = 0; i < lev; i++) { 276 printf(" "); 277 } 278 strncpy(name, aname->name, 4); 279 name[4] = 0; 280 printf("%s ", name); 281 if (aname->property != NULL) { 282 aml_showobject(aname->property); 283 } else { 284 printf("\n"); 285 } 286 for (ptr = aname->child; ptr; ptr = ptr->brother) 287 aml_showtree(ptr, lev + 1); 288 } 289 290 /* 291 * Common Region I/O Stuff 292 */ 293 294 static __inline u_int64_t 295 aml_adjust_bitmask(u_int32_t flags, u_int32_t bitlen) 296 { 297 u_int64_t bitmask; 298 299 switch (AML_FIELDFLAGS_ACCESSTYPE(flags)) { 300 case AML_FIELDFLAGS_ACCESS_ANYACC: 301 if (bitlen <= 8) { 302 bitmask = 0x000000ff; 303 break; 304 } 305 if (bitlen <= 16) { 306 bitmask = 0x0000ffff; 307 break; 308 } 309 bitmask = 0xffffffff; 310 break; 311 case AML_FIELDFLAGS_ACCESS_BYTEACC: 312 bitmask = 0x000000ff; 313 break; 314 case AML_FIELDFLAGS_ACCESS_WORDACC: 315 bitmask = 0x0000ffff; 316 break; 317 case AML_FIELDFLAGS_ACCESS_DWORDACC: 318 default: 319 bitmask = 0xffffffff; 320 break; 321 } 322 323 switch (bitlen) { 324 case 16: 325 bitmask |= 0x0000ffff; 326 break; 327 case 32: 328 bitmask |= 0xffffffff; 329 break; 330 } 331 332 return (bitmask); 333 } 334 335 u_int32_t 336 aml_adjust_readvalue(u_int32_t flags, u_int32_t bitoffset, u_int32_t bitlen, 337 u_int32_t orgval) 338 { 339 u_int32_t offset, retval; 340 u_int64_t bitmask; 341 342 offset = bitoffset; /* XXX bitoffset may change in this function! */ 343 bitmask = aml_adjust_bitmask(flags, bitlen); 344 retval = (orgval >> offset) & (~(bitmask << bitlen)) & bitmask; 345 346 return (retval); 347 } 348 349 u_int32_t 350 aml_adjust_updatevalue(u_int32_t flags, u_int32_t bitoffset, u_int32_t bitlen, 351 u_int32_t orgval, u_int32_t value) 352 { 353 u_int32_t offset, retval; 354 u_int64_t bitmask; 355 356 offset = bitoffset; /* XXX bitoffset may change in this function! */ 357 bitmask = aml_adjust_bitmask(flags, bitlen); 358 retval = orgval; 359 switch (AML_FIELDFLAGS_UPDATERULE(flags)) { 360 case AML_FIELDFLAGS_UPDATE_PRESERVE: 361 retval &= (~(((u_int64_t)1 << bitlen) - 1) << offset) | 362 (~(bitmask << offset)); 363 break; 364 case AML_FIELDFLAGS_UPDATE_WRITEASONES: 365 retval = (~(((u_int64_t)1 << bitlen) - 1) << offset) | 366 (~(bitmask << offset)); 367 retval &= bitmask; /* trim the upper bits */ 368 break; 369 case AML_FIELDFLAGS_UPDATE_WRITEASZEROS: 370 retval = 0; 371 break; 372 default: 373 printf("illegal update rule: %d\n", flags); 374 return (orgval); 375 } 376 377 retval |= (value << (offset & bitmask)); 378 return (retval); 379 } 380 381 /* 382 * BufferField I/O 383 */ 384 385 #define AML_BUFFER_INPUT 0 386 #define AML_BUFFER_OUTPUT 1 387 388 static int aml_bufferfield_io(int io, u_int32_t *valuep, 389 u_int8_t *origin, u_int32_t bitoffset, 390 u_int32_t bitlen); 391 392 static int 393 aml_bufferfield_io(int io, u_int32_t *valuep, u_int8_t *origin, 394 u_int32_t bitoffset, u_int32_t bitlen) 395 { 396 u_int8_t val, tmp, masklow, maskhigh; 397 u_int8_t offsetlow, offsethigh; 398 u_int8_t *addr; 399 int i; 400 u_int32_t value, readval; 401 u_int32_t byteoffset, bytelen; 402 403 masklow = maskhigh = 0xff; 404 val = readval = 0; 405 value = *valuep; 406 407 byteoffset = bitoffset / 8; 408 bytelen = bitlen / 8 + ((bitlen % 8) ? 1 : 0); 409 addr = origin + byteoffset; 410 411 /* simple I/O ? */ 412 if (bitlen <= 8 || bitlen == 16 || bitlen == 32) { 413 bcopy(addr, &readval, bytelen); 414 AML_DEBUGPRINT("\n\t[bufferfield:0x%x@%p:%d,%d]", 415 readval, addr, bitoffset % 8, bitlen); 416 switch (io) { 417 case AML_BUFFER_INPUT: 418 value = aml_adjust_readvalue(AML_FIELDFLAGS_ACCESS_BYTEACC, 419 bitoffset % 8, bitlen, readval); 420 *valuep = value; 421 AML_DEBUGPRINT("\n[read(bufferfield, %p)&mask:0x%x]\n", 422 addr, value); 423 break; 424 case AML_BUFFER_OUTPUT: 425 value = aml_adjust_updatevalue(AML_FIELDFLAGS_ACCESS_BYTEACC, 426 bitoffset % 8, bitlen, readval, value); 427 bcopy(&value, addr, bytelen); 428 AML_DEBUGPRINT("->[bufferfield:0x%x@%p:%d,%d]", 429 value, addr, bitoffset % 8, bitlen); 430 break; 431 } 432 goto out; 433 } 434 435 offsetlow = bitoffset % 8; 436 if (bytelen > 1) { 437 offsethigh = (bitlen - (8 - offsetlow)) % 8; 438 } else { 439 offsethigh = 0; 440 } 441 442 if (offsetlow) { 443 masklow = (~((1 << bitlen) - 1) << offsetlow) | ~(0xff << offsetlow); 444 AML_DEBUGPRINT("\t[offsetlow = 0x%x, masklow = 0x%x, ~masklow = 0x%x]\n", 445 offsetlow, masklow, ~masklow & 0xff); 446 } 447 if (offsethigh) { 448 maskhigh = 0xff << offsethigh; 449 AML_DEBUGPRINT("\t[offsethigh = 0x%x, maskhigh = 0x%x, ~maskhigh = 0x%x]\n", 450 offsethigh, maskhigh, ~maskhigh & 0xff); 451 } 452 for (i = bytelen; i > 0; i--, addr++) { 453 val = *addr; 454 455 AML_DEBUGPRINT("\t[bufferfield:0x%02x@%p]", val, addr); 456 457 switch (io) { 458 case AML_BUFFER_INPUT: 459 tmp = val; 460 /* the lowest byte? */ 461 if (i == bytelen) { 462 if (offsetlow) { 463 readval = tmp & ~masklow; 464 } else { 465 readval = tmp; 466 } 467 } else { 468 if (i == 1 && offsethigh) { 469 tmp = tmp & ~maskhigh; 470 } 471 readval = (tmp << (8 * (bytelen - i))) | readval; 472 } 473 474 AML_DEBUGPRINT("\n"); 475 /* goto to next byte... */ 476 if (i > 1) { 477 continue; 478 } 479 /* final adjustment before finishing region access */ 480 if (offsetlow) { 481 readval = readval >> offsetlow; 482 } 483 AML_DEBUGPRINT("[read(bufferfield, %p)&mask:0x%x]\n", 484 addr, readval); 485 *valuep = readval; 486 487 break; 488 489 case AML_BUFFER_OUTPUT: 490 tmp = value & 0xff; 491 /* the lowest byte? */ 492 if (i == bytelen) { 493 if (offsetlow) { 494 tmp = (val & masklow) | tmp << offsetlow; 495 } 496 value = value >> (8 - offsetlow); 497 } else { 498 if (i == 1 && offsethigh) { 499 tmp = (val & maskhigh) | tmp; 500 } 501 value = value >> 8; 502 } 503 504 AML_DEBUGPRINT("->[bufferfield:0x%02x@%p]\n", 505 tmp, addr); 506 *addr = tmp; 507 } 508 } 509 out: 510 return (0); 511 } 512 513 u_int32_t 514 aml_bufferfield_read(u_int8_t *origin, u_int32_t bitoffset, 515 u_int32_t bitlen) 516 { 517 int value; 518 519 value = 0; 520 aml_bufferfield_io(AML_BUFFER_INPUT, (u_int32_t *)&value, origin, 521 bitoffset, bitlen); 522 return (value); 523 } 524 525 int 526 aml_bufferfield_write(u_int32_t value, u_int8_t *origin, 527 u_int32_t bitoffset, u_int32_t bitlen) 528 { 529 int status; 530 531 status = aml_bufferfield_io(AML_BUFFER_OUTPUT, &value, 532 origin, bitoffset, bitlen); 533 return (status); 534 } 535 536 int 537 aml_region_handle_alloc(struct aml_environ *env, int regtype, u_int32_t flags, 538 u_int32_t baseaddr, u_int32_t bitoffset, u_int32_t bitlen, 539 struct aml_region_handle *h) 540 { 541 int state; 542 struct aml_name *pci_info; 543 544 state = 0; 545 pci_info = NULL; 546 bzero(h, sizeof(struct aml_region_handle)); 547 548 h->env = env; 549 h->regtype = regtype; 550 h->flags = flags; 551 h->baseaddr = baseaddr; 552 h->bitoffset = bitoffset; 553 h->bitlen = bitlen; 554 555 switch (AML_FIELDFLAGS_ACCESSTYPE(flags)) { 556 case AML_FIELDFLAGS_ACCESS_ANYACC: 557 if (bitlen <= 8) { 558 h->unit = 1; 559 break; 560 } 561 if (bitlen <= 16) { 562 h->unit = 2; 563 break; 564 } 565 h->unit = 4; 566 break; 567 case AML_FIELDFLAGS_ACCESS_BYTEACC: 568 h->unit = 1; 569 break; 570 case AML_FIELDFLAGS_ACCESS_WORDACC: 571 h->unit = 2; 572 break; 573 case AML_FIELDFLAGS_ACCESS_DWORDACC: 574 h->unit = 4; 575 break; 576 default: 577 h->unit = 1; 578 break; 579 } 580 581 h->addr = baseaddr + h->unit * ((bitoffset / 8) / h->unit); 582 h->bytelen = baseaddr + ((bitoffset + bitlen) / 8) - h->addr + 583 ((bitlen % 8) ? 1 : 0); 584 585 #ifdef _KERNEL 586 switch (h->regtype) { 587 case AML_REGION_SYSMEM: 588 OsdMapMemory((void *)h->addr, h->bytelen, (void **)&h->vaddr); 589 break; 590 591 case AML_REGION_PCICFG: 592 /* Obtain PCI bus number */ 593 pci_info = aml_search_name(env, "_BBN"); 594 if (pci_info == NULL || pci_info->property->type != aml_t_num) { 595 AML_DEBUGPRINT("Cannot locate _BBN. Using default 0\n"); 596 h->pci_bus = 0; 597 } else { 598 AML_DEBUGPRINT("found _BBN: %d\n", 599 pci_info->property->num.number); 600 h->pci_bus = pci_info->property->num.number & 0xff; 601 } 602 603 /* Obtain device & function number */ 604 pci_info = aml_search_name(env, "_ADR"); 605 if (pci_info == NULL || pci_info->property->type != aml_t_num) { 606 printf("Cannot locate: _ADR\n"); 607 state = -1; 608 goto out; 609 } 610 h->pci_devfunc = pci_info->property->num.number; 611 612 AML_DEBUGPRINT("[pci%d.%d]", h->pci_bus, h->pci_devfunc); 613 break; 614 615 default: 616 break; 617 } 618 619 out: 620 #endif /* _KERNEL */ 621 return (state); 622 } 623 624 void 625 aml_region_handle_free(struct aml_region_handle *h) 626 { 627 #ifdef _KERNEL 628 switch (h->regtype) { 629 case AML_REGION_SYSMEM: 630 OsdUnMapMemory((void *)h->vaddr, h->bytelen); 631 break; 632 633 default: 634 break; 635 } 636 #endif /* _KERNEL */ 637 } 638 639 static int 640 aml_region_io_simple(struct aml_environ *env, int io, int regtype, 641 u_int32_t flags, u_int32_t *valuep, u_int32_t baseaddr, 642 u_int32_t bitoffset, u_int32_t bitlen) 643 { 644 int i, state; 645 u_int32_t readval, value, offset, bytelen; 646 struct aml_region_handle handle; 647 648 state = aml_region_handle_alloc(env, regtype, flags, 649 baseaddr, bitoffset, bitlen, &handle); 650 if (state == -1) { 651 goto out; 652 } 653 654 readval = 0; 655 offset = bitoffset % (handle.unit * 8); 656 /* limitation of 32 bits alignment */ 657 bytelen = (handle.bytelen > 4) ? 4 : handle.bytelen; 658 659 if (io == AML_REGION_INPUT || 660 AML_FIELDFLAGS_UPDATERULE(flags) == AML_FIELDFLAGS_UPDATE_PRESERVE) { 661 for (i = 0; i < bytelen; i += handle.unit) { 662 state = aml_region_read_simple(&handle, i, &value); 663 if (state == -1) { 664 goto out; 665 } 666 readval |= (value << (i * 8)); 667 } 668 AML_DEBUGPRINT("\t[%d:0x%x@0x%lx:%d,%d]", 669 regtype, readval, handle.addr, offset, bitlen); 670 } 671 672 switch (io) { 673 case AML_REGION_INPUT: 674 AML_DEBUGPRINT("\n"); 675 readval = aml_adjust_readvalue(flags, offset, bitlen, readval); 676 value = readval; 677 value = aml_region_prompt_read(&handle, value); 678 state = aml_region_prompt_update_value(readval, value, &handle); 679 if (state == -1) { 680 goto out; 681 } 682 683 *valuep = value; 684 break; 685 case AML_REGION_OUTPUT: 686 value = *valuep; 687 value = aml_adjust_updatevalue(flags, offset, 688 bitlen, readval, value); 689 value = aml_region_prompt_write(&handle, value); 690 AML_DEBUGPRINT("\t->[%d:0x%x@0x%lx:%d,%d]\n", regtype, value, 691 handle.addr, offset, bitlen); 692 for (i = 0; i < bytelen; i += handle.unit) { 693 state = aml_region_write_simple(&handle, i, value); 694 if (state == -1) { 695 goto out; 696 } 697 value = value >> (handle.unit * 8); 698 } 699 break; 700 } 701 702 aml_region_handle_free(&handle); 703 out: 704 return (state); 705 } 706 707 int 708 aml_region_io(struct aml_environ *env, int io, int regtype, 709 u_int32_t flags, u_int32_t *valuep, u_int32_t baseaddr, 710 u_int32_t bitoffset, u_int32_t bitlen) 711 { 712 u_int32_t unit, offset; 713 u_int32_t offadj, bitadj; 714 u_int32_t value, readval; 715 int state, i; 716 717 readval = 0; 718 state = 0; 719 unit = 4; /* limitation of 32 bits alignment */ 720 offset = bitoffset % (unit * 8); 721 offadj = 0; 722 bitadj = 0; 723 if (offset + bitlen > unit * 8) { 724 bitadj = bitlen - (unit * 8 - offset); 725 } 726 for (i = 0; i < offset + bitlen; i += unit * 8) { 727 value = (*valuep) >> offadj; 728 state = aml_region_io_simple(env, io, regtype, flags, 729 &value, baseaddr, bitoffset + offadj, bitlen - bitadj); 730 if (state == -1) { 731 goto out; 732 } 733 readval |= value << offadj; 734 bitadj = offadj = bitlen - bitadj; 735 } 736 *valuep = readval; 737 738 out: 739 return (state); 740 } 741