1 /* $NetBSD: aml_parse.c,v 1.3 2011/06/21 09:36:46 mrg Exp $ */ 2 3 /*- 4 * Copyright (c) 1999 Doug Rabson 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_parse.c,v 1.32 2000/08/12 15:20:45 iwasaki Exp 30 * $FreeBSD: src/usr.sbin/acpi/amldb/aml/aml_parse.c,v 1.7 2001/10/23 14:54:15 takawata Exp $ 31 */ 32 #include <sys/cdefs.h> 33 __RCSID("$NetBSD: aml_parse.c,v 1.3 2011/06/21 09:36:46 mrg Exp $"); 34 35 #include <sys/param.h> 36 37 #include <acpi_common.h> 38 #include <aml/aml_amlmem.h> 39 #include <aml/aml_common.h> 40 #include <aml/aml_env.h> 41 #include <aml/aml_evalobj.h> 42 #include <aml/aml_name.h> 43 #include <aml/aml_obj.h> 44 #include <aml/aml_parse.h> 45 #include <aml/aml_status.h> 46 #include <aml/aml_store.h> 47 48 #ifndef _KERNEL 49 #include <sys/stat.h> 50 #include <sys/mman.h> 51 52 #include <assert.h> 53 #include <err.h> 54 #include <fcntl.h> 55 #include <stdio.h> 56 #include <stdlib.h> 57 #include <string.h> 58 #include <unistd.h> 59 60 #include "debug.h" 61 #else /* _KERNEL */ 62 #include <sys/systm.h> 63 #include <sys/bus.h> 64 #include <dev/acpi/acpireg.h> 65 #include <dev/acpi/acpivar.h> 66 #ifndef ACPI_NO_OSDFUNC_INLINE 67 #include <machine/acpica_osd.h> 68 #endif 69 #endif /* !_KERNEL */ 70 71 static int findsetleftbit(int num); 72 static int findsetrightbit(int num); 73 static int frombcd(int num); 74 static int tobcd(int num); 75 76 static u_int32_t aml_parse_pkglength(struct aml_environ *env); 77 static u_int8_t aml_parse_bytedata(struct aml_environ *env); 78 static u_int16_t aml_parse_worddata(struct aml_environ *env); 79 static u_int32_t aml_parse_dworddata(struct aml_environ *env); 80 static u_int8_t *aml_parse_namestring(struct aml_environ *env); 81 static void aml_parse_defscope(struct aml_environ *env, 82 int indent); 83 static union aml_object *aml_parse_defbuffer(struct aml_environ *env, 84 int indent); 85 static struct aml_name *aml_parse_concat_number(struct aml_environ *env, 86 int num1, int indent); 87 static struct aml_name *aml_parse_concat_buffer(struct aml_environ *env, 88 union aml_object *obj, 89 int indent); 90 static struct aml_name *aml_parse_concat_string(struct aml_environ *env, 91 union aml_object *obj, 92 int indent); 93 static struct aml_name *aml_parse_concatop(struct aml_environ *env, 94 int indent); 95 static union aml_object *aml_parse_defpackage(struct aml_environ *env, 96 int indent); 97 static void aml_parse_defmethod(struct aml_environ *env, 98 int indent); 99 static void aml_parse_defopregion(struct aml_environ *env, 100 int indent); 101 static int aml_parse_field(struct aml_environ *env, 102 struct aml_field *template); 103 static void aml_parse_fieldlist(struct aml_environ *env, 104 struct aml_field *template, 105 int indent); 106 static void aml_parse_deffield(struct aml_environ *env, 107 int indent); 108 static void aml_parse_defindexfield(struct aml_environ *env, 109 int indent); 110 static void aml_parse_defbankfield(struct aml_environ *env, 111 int indent); 112 static void aml_parse_defdevice(struct aml_environ *env, 113 int indent); 114 static void aml_parse_defprocessor(struct aml_environ *env, 115 int indent); 116 static void aml_parse_defpowerres(struct aml_environ *env, 117 int indent); 118 static void aml_parse_defthermalzone(struct aml_environ *env, 119 int indent); 120 static struct aml_name *aml_parse_defelse(struct aml_environ *env, 121 int indent, int num); 122 static struct aml_name *aml_parse_defif(struct aml_environ *env, 123 int indent); 124 static struct aml_name *aml_parse_defwhile(struct aml_environ *env, 125 int indent); 126 static void aml_parse_defmutex(struct aml_environ *env, 127 int indent); 128 static void aml_createfield_generic(struct aml_environ *env, 129 union aml_object *srcbuf, 130 int idx, int len, 131 char *newname); 132 static void aml_parse_defcreatefield(struct aml_environ *env, 133 int indent); 134 135 static int 136 findsetleftbit(int num) 137 { 138 int i, filter; 139 140 filter = 0; 141 for (i = 0; i < 32; i++) { 142 filter = filter >> 1; 143 filter |= 1 << 31; 144 if (filter & num) { 145 break; 146 } 147 } 148 i = (i == 32) ? 0 : i + 1; 149 return (i); 150 } 151 152 static int 153 findsetrightbit(int num) 154 { 155 int i, filter; 156 157 filter = 0; 158 for (i = 0; i < 32; i++) { 159 filter = filter << 1; 160 filter |= 1; 161 if (filter & num) { 162 break; 163 } 164 } 165 i = (i == 32) ? 0 : i + 1; 166 return (i); 167 } 168 169 static int 170 frombcd(int num) 171 { 172 int res, factor; 173 174 res = 0; 175 factor = 1; 176 while (num != 0) { 177 res += ((num & 0xf) * factor); 178 num = num / 16; 179 factor *= 10; 180 } 181 return (res); 182 } 183 184 static int 185 tobcd(int num) 186 { 187 int res, factor; 188 189 res = 0; 190 factor = 1; 191 while (num != 0) { 192 res += ((num % 10) * factor); 193 num = num / 10; 194 factor *= 16; 195 } 196 return (res); 197 } 198 199 static u_int32_t 200 aml_parse_pkglength(struct aml_environ *env) 201 { 202 u_int8_t *dp; 203 u_int32_t pkglength; 204 205 dp = env->dp; 206 pkglength = *dp++; 207 switch (pkglength >> 6) { 208 case 0: 209 break; 210 case 1: 211 pkglength = (pkglength & 0xf) + (dp[0] << 4); 212 dp += 1; 213 break; 214 case 2: 215 pkglength = (pkglength & 0xf) + (dp[0] << 4) + (dp[1] << 12); 216 dp += 2; 217 break; 218 case 3: 219 pkglength = (pkglength & 0xf) 220 + (dp[0] << 4) + (dp[1] << 12) + (dp[2] << 20); 221 dp += 3; 222 break; 223 } 224 225 env->dp = dp; 226 return (pkglength); 227 } 228 229 static u_int8_t 230 aml_parse_bytedata(struct aml_environ *env) 231 { 232 u_int8_t data; 233 234 data = env->dp[0]; 235 env->dp++; 236 return (data); 237 } 238 239 static u_int16_t 240 aml_parse_worddata(struct aml_environ *env) 241 { 242 u_int16_t data; 243 244 data = env->dp[0] + (env->dp[1] << 8); 245 env->dp += 2; 246 return (data); 247 } 248 249 static u_int32_t 250 aml_parse_dworddata(struct aml_environ *env) 251 { 252 u_int32_t data; 253 254 data = env->dp[0] + (env->dp[1] << 8) + 255 (env->dp[2] << 16) + (env->dp[3] << 24); 256 env->dp += 4; 257 return (data); 258 } 259 260 static u_int8_t * 261 aml_parse_namestring(struct aml_environ *env) 262 { 263 u_int8_t *name; 264 int segcount; 265 266 name = env->dp; 267 if (env->dp[0] == '\\') 268 env->dp++; 269 else if (env->dp[0] == '^') 270 while (env->dp[0] == '^') 271 env->dp++; 272 if (env->dp[0] == 0x00) /* NullName */ 273 env->dp++; 274 else if (env->dp[0] == 0x2e) /* DualNamePrefix */ 275 env->dp += 1 + 4 + 4; /* NameSeg, NameSeg */ 276 else if (env->dp[0] == 0x2f) { /* MultiNamePrefix */ 277 segcount = env->dp[1]; 278 env->dp += 1 + 1 + segcount * 4; /* segcount * NameSeg */ 279 } else 280 env->dp += 4; /* NameSeg */ 281 282 return (name); 283 } 284 285 struct aml_name * 286 aml_parse_objectlist(struct aml_environ *env, int indent) 287 { 288 union aml_object *obj; 289 290 obj = NULL; 291 while (env->dp < env->end) { 292 aml_print_indent(indent); 293 obj = aml_eval_name(env, aml_parse_termobj(env, indent)); 294 AML_DEBUGPRINT("\n"); 295 if (env->stat == aml_stat_step) { 296 AML_DEBUGGER(env, env); 297 continue; 298 } 299 if (env->stat != aml_stat_none) { 300 env->tempname.property = obj; 301 return (&env->tempname); 302 } 303 } 304 return (NULL); 305 } 306 307 #define AML_CREATE_NAME(amlname, env, namestr, ret) do { \ 308 amlname = aml_create_name(env, namestr); \ 309 if (env->stat == aml_stat_panic) \ 310 return ret; \ 311 } while(0) 312 313 #define AML_COPY_OBJECT(dest, env, src, ret) do { \ 314 dest = aml_copy_object(env, src); \ 315 if (dest == NULL) { \ 316 env->stat = aml_stat_panic; \ 317 return ret; \ 318 } \ 319 } while(0) 320 321 #define AML_ALLOC_OBJECT(dest, env, type, ret) do { \ 322 dest = aml_alloc_object(type, NULL); \ 323 if (dest == NULL) { \ 324 env->stat= aml_stat_panic; \ 325 return ret; \ 326 } \ 327 } while(0) 328 329 static void 330 aml_parse_defscope(struct aml_environ *env, int indent) 331 { 332 u_int8_t *start, *end, *oend; 333 u_int8_t *name; 334 u_int32_t pkglength; 335 struct aml_name *oname; 336 337 start = env->dp; 338 pkglength = aml_parse_pkglength(env); 339 340 AML_DEBUGPRINT("Scope("); 341 name = aml_parse_namestring(env); 342 aml_print_namestring(name); 343 AML_DEBUGPRINT(") {\n"); 344 oname = env->curname; 345 AML_CREATE_NAME(env->curname, env, name,); 346 oend = env->end; 347 env->end = end = start + pkglength; 348 aml_parse_objectlist(env, indent + 1); 349 aml_print_indent(indent); 350 AML_DEBUGPRINT("}"); 351 AML_SYSASSERT(env->dp == env->end); 352 env->dp = end; 353 env->end = oend; 354 env->curname = oname; 355 env->stat = aml_stat_none; 356 } 357 358 static union aml_object * 359 aml_parse_defbuffer(struct aml_environ *env, int indent) 360 { 361 u_int8_t *start; 362 u_int8_t *end; 363 u_int8_t *buffer; 364 u_int32_t pkglength; 365 int size1, size2, size; 366 union aml_object *obj; 367 368 start = env->dp; 369 pkglength = aml_parse_pkglength(env); 370 end = start + pkglength; 371 372 AML_DEBUGPRINT("Buffer("); 373 obj = aml_eval_name(env, aml_parse_termobj(env, indent)); 374 size1 = aml_objtonum(env, obj); 375 size2 = end - env->dp; 376 size = (size1 < size2) ? size1 : size2; 377 if (size1 > 0) { 378 buffer = memman_alloc_flexsize(aml_memman, size1); 379 if (buffer == NULL) { 380 AML_DEBUGPRINT("NO MEMORY\n"); 381 env->stat = aml_stat_panic; 382 return (NULL); 383 } 384 bzero(buffer, size1); 385 bcopy(env->dp, buffer, size); 386 } else { 387 buffer = NULL; 388 } 389 390 obj = &env->tempobject; 391 obj->type = aml_t_buffer; 392 obj->buffer.size = size1; 393 obj->buffer.data = buffer; 394 AML_DEBUGPRINT(") "); 395 env->dp = end; 396 397 return (obj); 398 } 399 400 static struct aml_name * 401 aml_parse_concat_number(struct aml_environ *env, int num1, int indent) 402 { 403 int num2; 404 struct aml_name *destname; 405 union aml_object *obj; 406 407 num2 = aml_objtonum(env, aml_eval_name(env, 408 aml_parse_termobj(env, indent))); 409 AML_DEBUGPRINT(", "); 410 destname = aml_parse_termobj(env, indent); 411 AML_DEBUGPRINT(")"); 412 obj = &env->tempobject; 413 obj->type = aml_t_buffer; 414 obj->buffer.size = 2; 415 obj->buffer.data = memman_alloc_flexsize(aml_memman, 2); 416 if (obj->buffer.data == NULL) { 417 env->stat = aml_stat_panic; 418 return (NULL); 419 } 420 obj->buffer.data[0] = num1 & 0xff; 421 obj->buffer.data[1] = num2 & 0xff; 422 aml_store_to_name(env, obj, destname); 423 return (&env->tempname); 424 } 425 426 static struct aml_name * 427 aml_parse_concat_buffer(struct aml_environ *env, union aml_object *obj, 428 int indent) 429 { 430 union aml_object *tmpobj, *tmpobj2, *resobj; 431 struct aml_name *destname; 432 433 tmpobj = aml_eval_name(env, aml_parse_termobj(env, indent)); 434 AML_DEBUGPRINT(", "); 435 if (tmpobj->type != aml_t_buffer) { 436 env->stat = aml_stat_panic; 437 return (NULL); 438 } 439 AML_COPY_OBJECT(tmpobj2, env, tmpobj, NULL); 440 destname = aml_parse_termobj(env, indent); 441 AML_DEBUGPRINT(")"); 442 resobj = &env->tempobject; 443 env->tempname.property = resobj; 444 resobj->buffer.type = aml_t_buffer; 445 resobj->buffer.size = tmpobj2->buffer.size + obj->buffer.size; 446 if (resobj->buffer.size > 0) { 447 resobj->buffer.data = memman_alloc_flexsize(aml_memman, 448 resobj->buffer.size); 449 if (resobj->buffer.data == NULL) { 450 env->stat = aml_stat_panic; 451 return (NULL); 452 } 453 bcopy(obj->buffer.data, resobj->buffer.data, obj->buffer.size); 454 bcopy(tmpobj2->buffer.data, 455 resobj->buffer.data + obj->buffer.size, 456 tmpobj2->buffer.size); 457 } else { 458 resobj->buffer.data = NULL; 459 } 460 aml_free_object(&tmpobj2); 461 aml_store_to_name(env, resobj, destname); 462 return (&env->tempname); 463 } 464 465 static struct aml_name * 466 aml_parse_concat_string(struct aml_environ *env, union aml_object *obj, 467 int indent) 468 { 469 int len; 470 union aml_object *tmpobj, *tmpobj2, *resobj; 471 struct aml_name *destname; 472 473 tmpobj = aml_eval_name(env, aml_parse_termobj(env, indent)); 474 AML_DEBUGPRINT(", "); 475 if (tmpobj->type != aml_t_string) { 476 env->stat = aml_stat_panic; 477 return (NULL); 478 } 479 AML_COPY_OBJECT(tmpobj2, env, tmpobj, NULL); 480 destname = aml_parse_termobj(env, indent); 481 AML_DEBUGPRINT(")"); 482 resobj = &env->tempobject; 483 env->tempname.property = resobj; 484 resobj->type = aml_t_buffer; 485 resobj->str.needfree = 1; 486 len = strlen((const char *)obj->str.string) + 487 strlen((const char *)tmpobj2->str.string) + 1; 488 if (len > 0) { 489 resobj->str.string = memman_alloc_flexsize(aml_memman, len); 490 if (resobj->str.string == NULL) { 491 env->stat = aml_stat_panic; 492 return (NULL); 493 } 494 strlcpy((char *)resobj->str.string, (const char *)obj->str.string, len); 495 strlcat((char *)resobj->str.string, (const char *)tmpobj->str.string, len); 496 } else { 497 resobj->str.string = NULL; 498 } 499 aml_free_object(&tmpobj2); 500 aml_store_to_name(env, resobj, destname); 501 return (&env->tempname); 502 } 503 504 static struct aml_name * 505 aml_parse_concatop(struct aml_environ *env, int indent) 506 { 507 union aml_object *obj, *tmpobj; 508 struct aml_name *aname; 509 510 AML_DEBUGPRINT("Concat("); 511 obj = aml_eval_name(env, aml_parse_termobj(env, indent)); 512 AML_DEBUGPRINT(", "); 513 switch (obj->type) { 514 case aml_t_num: 515 aname = aml_parse_concat_number(env, aml_objtonum(env, obj), indent); 516 break; 517 518 case aml_t_buffer: 519 /* obj may be temporal object */ 520 AML_COPY_OBJECT(tmpobj, env, obj, NULL); 521 aname = aml_parse_concat_buffer(env, obj, indent); 522 aml_free_object(&tmpobj); 523 break; 524 525 case aml_t_string: 526 /* obj may be temporal object */ 527 AML_COPY_OBJECT(tmpobj, env, obj, NULL); 528 aname = aml_parse_concat_string(env, obj, indent); 529 aml_free_object(&tmpobj); 530 break; 531 532 default: 533 env->stat = aml_stat_panic; 534 aname = NULL; 535 break; 536 } 537 538 AML_DEBUGPRINT("\n"); 539 return (aname); 540 } 541 542 static union aml_object * 543 aml_parse_defpackage(struct aml_environ *env, int indent) 544 { 545 u_int8_t numelements; 546 u_int8_t *start; 547 u_int32_t pkglength; 548 int i; 549 struct aml_environ *copy; 550 struct aml_name *tmpname; 551 union aml_object *obj, **objects; 552 553 start = env->dp; 554 pkglength = aml_parse_pkglength(env); 555 numelements = aml_parse_bytedata(env); 556 copy = memman_alloc(aml_memman, memid_aml_environ); 557 if (copy == NULL) { 558 env->stat = aml_stat_panic; 559 return (NULL); 560 } 561 if (numelements > 0) { 562 objects = memman_alloc_flexsize(aml_memman, 563 numelements * sizeof(union aml_object *)); 564 if (objects == NULL) { 565 env->stat = aml_stat_panic; 566 return (NULL); 567 } else { 568 bzero(objects, numelements * sizeof(union aml_object *)); 569 } 570 } else { 571 objects = NULL; 572 } 573 574 *copy = *env; 575 env->dp = copy->end = start + pkglength; 576 AML_DEBUGPRINT("Package() {\n"); 577 i = 0; 578 while ((copy->dp < copy->end) && (i < numelements)) { 579 aml_print_indent(indent + 1); 580 tmpname = aml_parse_termobj(copy, indent + 1); 581 582 if (tmpname != NULL) { 583 objects[i] = aml_copy_object(copy, tmpname->property); 584 } 585 AML_DEBUGPRINT(",\n"); 586 i++; 587 } 588 aml_free_objectcontent(©->tempobject); 589 590 aml_print_indent(indent); 591 AML_DEBUGPRINT("}"); 592 obj = &env->tempobject; 593 obj->type = aml_t_package; 594 obj->package.elements = numelements; 595 obj->package.objects = objects; 596 597 memman_free(aml_memman, memid_aml_environ, copy); 598 return (obj); 599 } 600 601 static void 602 aml_parse_defmethod(struct aml_environ *env, int indent) 603 { 604 u_int8_t flags; 605 u_int8_t *start; 606 u_int32_t pkglength; 607 char *name; 608 struct aml_environ *copy; 609 struct aml_method *meth; 610 struct aml_name *aname; 611 union aml_object *aobj; 612 613 start = env->dp; 614 pkglength = aml_parse_pkglength(env); 615 copy = memman_alloc(aml_memman, memid_aml_environ); 616 if (copy == NULL) { 617 env->stat = aml_stat_panic; 618 return; 619 } 620 AML_DEBUGPRINT("Method("); 621 name = (char *)aml_parse_namestring(env); 622 aml_print_namestring((unsigned char *)name); 623 AML_CREATE_NAME(aname, env, (unsigned char *)name,); 624 if (aname->property != NULL) { 625 env->stat = aml_stat_panic; 626 AML_DEBUGPRINT("Already Defined \n"); 627 goto out; 628 } 629 AML_ALLOC_OBJECT(aobj, env, aml_t_method,); 630 meth = &aobj->meth; 631 aname->property = aobj; 632 flags = *env->dp++; 633 634 if (flags) { 635 AML_DEBUGPRINT(", %d", flags); 636 } 637 AML_DEBUGPRINT(") {\n"); 638 *copy = *env; 639 meth->argnum = flags; 640 meth->from = env->dp; 641 meth->to = env->dp = copy->end = start + pkglength; 642 aml_print_indent(indent); 643 AML_DEBUGPRINT("}"); 644 out: 645 memman_free(aml_memman, memid_aml_environ, copy); 646 } 647 648 static void 649 aml_parse_defopregion(struct aml_environ *env, int indent) 650 { 651 u_int8_t *name; 652 struct aml_name *aname; 653 struct aml_opregion *opregion; 654 union aml_object *obj; 655 const char *regions[] = { 656 "SystemMemory", 657 "SystemIO", 658 "PCI_Config", 659 "EmbeddedControl", 660 "SMBus", 661 }; 662 663 AML_DEBUGPRINT("OperationRegion("); 664 /* Name */ 665 name = aml_parse_namestring(env); 666 aml_print_namestring(name); 667 AML_CREATE_NAME(aname, env, name,); 668 if (aname->property != NULL) { 669 env->stat = aml_stat_panic; 670 AML_DEBUGPRINT("Already Defined \n"); 671 return; 672 } 673 AML_ALLOC_OBJECT(aname->property, env, aml_t_opregion,); 674 opregion = &aname->property->opregion; 675 opregion->space = *env->dp; 676 AML_DEBUGPRINT(", %s, ", regions[*env->dp]); /* Space */ 677 env->dp++; 678 obj = aml_eval_name(env, aml_parse_termobj(env, indent)); /* Offset */ 679 opregion->offset = aml_objtonum(env, obj); 680 AML_DEBUGPRINT(", "); 681 obj = aml_eval_name(env, aml_parse_termobj(env, indent)); /* Length */ 682 opregion->length = aml_objtonum(env, obj); 683 AML_DEBUGPRINT(")"); 684 } 685 686 static const char *accessnames[] = { 687 "AnyAcc", 688 "ByteAcc", 689 "WordAcc", 690 "DWordAcc", 691 "BlockAcc", 692 "SMBSendRecvAcc", 693 "SMBQuickAcc" 694 }; 695 696 static int 697 aml_parse_field(struct aml_environ *env, struct aml_field *template) 698 { 699 u_int8_t *name; 700 u_int8_t acc, attribute; 701 u_int32_t width; 702 struct aml_name *aname; 703 struct aml_field *prop; 704 705 switch (*env->dp) { 706 case '\\': 707 case '^': 708 case 'A'...'Z': 709 case '_': 710 case '.': 711 case '/': 712 name = aml_parse_namestring(env); 713 width = aml_parse_pkglength(env); 714 template->bitlen = width; 715 aml_print_namestring(name); 716 AML_CREATE_NAME(aname, env, name, 0); 717 /* Allignment */ 718 if (width == 16) { 719 template->bitoffset += 15; 720 template->bitoffset &= (~15); 721 } 722 if (width == 32) { 723 template->bitoffset += 31; 724 template->bitoffset &= (~31); 725 } else if ((width & 7) == 0) { 726 template->bitoffset += 7; 727 template->bitoffset &= (~7); 728 } else if ((width > 32) && (width & 7) != 0) { 729 AML_DEBUGPRINT("??? Can I treat it?\n"); 730 } 731 if (aname->property != NULL) { 732 env->stat = aml_stat_panic; 733 AML_DEBUGPRINT("Already Defined \n"); 734 return (0); 735 } 736 AML_ALLOC_OBJECT(aname->property, env, aml_t_field, 0); 737 prop = &aname->property->field; 738 *prop = *template; 739 template->bitoffset += width; 740 AML_DEBUGPRINT(",\t%d", width); 741 break; 742 case 0x00: 743 env->dp++; 744 width = aml_parse_pkglength(env); 745 template->bitoffset += width; 746 AML_DEBUGPRINT("Offset(0x%x)", template->bitoffset); 747 break; 748 case 0x01: 749 acc = env->dp[1]; 750 attribute = env->dp[2]; 751 env->dp += 3; 752 AML_DEBUGPRINT("AccessAs(%s, %d)", accessnames[acc], attribute); 753 template->bitoffset = attribute; 754 template->flags = (template->flags | 0xf0) | acc; 755 break; 756 } 757 return (template->bitoffset); 758 } 759 760 static void 761 aml_parse_fieldlist(struct aml_environ *env, struct aml_field *template, 762 int indent) 763 { 764 u_int32_t offset; 765 766 offset = 0; 767 while (env->dp < env->end) { 768 aml_print_indent(indent); 769 offset = aml_parse_field(env, template); 770 if (env->dp < env->end) { 771 AML_DEBUGPRINT(",\n"); 772 } else { 773 AML_DEBUGPRINT("\n"); 774 } 775 } 776 } 777 778 static void 779 aml_parse_deffield(struct aml_environ *env, int indent) 780 { 781 u_int8_t flags; 782 u_int8_t *start, *name; 783 u_int32_t pkglength; 784 struct aml_environ *copy; 785 struct aml_field fieldtemplate; 786 static const char *lockrules[] = {"NoLock", "Lock"}; 787 static const char *updaterules[] = {"Preserve", "WriteAsOnes", 788 "WriteAsZeros", "*Error*"}; 789 790 start = env->dp; 791 pkglength = aml_parse_pkglength(env); 792 copy = memman_alloc(aml_memman, memid_aml_environ); 793 if (copy == NULL) { 794 env->stat = aml_stat_panic; 795 return; 796 } 797 AML_DEBUGPRINT("Field("); 798 aml_print_namestring(name = aml_parse_namestring(env)); 799 fieldtemplate.type = aml_t_field; 800 flags = aml_parse_bytedata(env); 801 fieldtemplate.flags = flags; 802 803 *copy = *env; 804 env->dp = copy->end = start + pkglength; 805 fieldtemplate.bitoffset = 0; 806 fieldtemplate.bitlen = 0; 807 fieldtemplate.f.ftype = f_t_field; 808 fieldtemplate.f.fld.regname = name; 809 AML_DEBUGPRINT(", %s, %s, %s) {\n", 810 accessnames[flags & 0xf], 811 lockrules[(flags >> 4) & 1], 812 updaterules[(flags >> 5) & 3]); 813 aml_parse_fieldlist(copy, &fieldtemplate, indent + 1); 814 aml_print_indent(indent); 815 AML_DEBUGPRINT("}"); 816 aml_free_objectcontent(©->tempobject); 817 818 AML_SYSASSERT(copy->dp == copy->end); 819 memman_free(aml_memman, memid_aml_environ, copy); 820 } 821 822 static void 823 aml_parse_defindexfield(struct aml_environ *env, int indent) 824 { 825 u_int8_t flags; 826 u_int8_t *start, *iname, *dname; 827 u_int32_t pkglength; 828 struct aml_environ *copy; 829 struct aml_field template; 830 static const char *lockrules[] = {"NoLock", "Lock"}; 831 static const char *updaterules[] = {"Preserve", "WriteAsOnes", 832 "WriteAsZeros", "*Error*"}; 833 834 start = env->dp; 835 pkglength = aml_parse_pkglength(env); 836 copy = memman_alloc(aml_memman, memid_aml_environ); 837 if (copy == NULL) { 838 env->stat = aml_stat_panic; 839 return; 840 } 841 AML_DEBUGPRINT("IndexField("); 842 aml_print_namestring(iname = aml_parse_namestring(env)); /* Name1 */ 843 AML_DEBUGPRINT(", "); 844 aml_print_namestring(dname = aml_parse_namestring(env)); /* Name2 */ 845 template.type = aml_t_field; 846 template.flags = flags = aml_parse_bytedata(env); 847 template.bitoffset = 0; 848 template.bitlen = 0; 849 template.f.ftype = f_t_index; 850 template.f.ifld.indexname = iname; 851 template.f.ifld.dataname = dname; 852 AML_DEBUGPRINT(", %s, %s, %s) {\n", 853 accessnames[flags & 0xf], 854 lockrules[(flags >> 4) & 1], 855 updaterules[(flags >> 5) & 3]); 856 *copy = *env; 857 env->dp = copy->end = start + pkglength; 858 aml_parse_fieldlist(copy, &template, indent + 1); 859 aml_print_indent(indent); 860 AML_DEBUGPRINT("}"); 861 aml_free_objectcontent(©->tempobject); 862 863 AML_SYSASSERT(copy->dp == copy->end); 864 memman_free(aml_memman, memid_aml_environ, copy); 865 } 866 867 static void 868 aml_parse_defbankfield(struct aml_environ *env, int indent) 869 { 870 u_int8_t flags; 871 u_int8_t *start, *rname, *bname; 872 u_int32_t pkglength, bankvalue; 873 struct aml_environ *copy; 874 struct aml_field template; 875 union aml_object *obj; 876 static const char *lockrules[] = {"NoLock", "Lock"}; 877 static const char *updaterules[] = {"Preserve", "WriteAsOnes", 878 "WriteAsZeros", "*Error*"}; 879 880 start = env->dp; 881 pkglength = aml_parse_pkglength(env); 882 copy = memman_alloc(aml_memman, memid_aml_environ); 883 if (copy == NULL) { 884 env->stat = aml_stat_panic; 885 return; 886 } 887 AML_DEBUGPRINT("BankField("); 888 aml_print_namestring(rname = aml_parse_namestring(env)); /* Name1 */ 889 AML_DEBUGPRINT(", "); 890 aml_print_namestring(bname = aml_parse_namestring(env)); /* Name2 */ 891 AML_DEBUGPRINT(", "); 892 obj = aml_eval_name(env, aml_parse_termobj(env, indent)); /* BankValue */ 893 bankvalue = aml_objtonum(env, obj); 894 template.type = aml_t_field; 895 template.flags = flags = aml_parse_bytedata(env); 896 template.bitoffset = 0; 897 template.bitlen = 0; 898 template.f.ftype = f_t_bank; 899 template.f.bfld.regname = rname; 900 template.f.bfld.bankname = bname; 901 template.f.bfld.bankvalue = bankvalue; 902 *copy = *env; 903 env->dp = copy->end = start + pkglength; 904 AML_DEBUGPRINT(", %s, %s, %s) {\n", 905 accessnames[flags & 0xf], 906 lockrules[(flags >> 4) & 1], 907 updaterules[(flags >> 5) & 3]); 908 aml_parse_fieldlist(copy, &template, indent + 1); 909 aml_print_indent(indent); 910 AML_DEBUGPRINT("}"); 911 912 aml_free_objectcontent(©->tempobject); 913 AML_SYSASSERT(copy->dp == copy->end); 914 memman_free(aml_memman, memid_aml_environ, copy); 915 } 916 917 static void 918 aml_parse_defdevice(struct aml_environ *env, int indent) 919 { 920 u_int8_t *start; 921 u_int8_t *name; 922 u_int32_t pkglength; 923 struct aml_environ *copy; 924 925 start = env->dp; 926 pkglength = aml_parse_pkglength(env); 927 copy = memman_alloc(aml_memman, memid_aml_environ); 928 if (copy == NULL) { 929 env->stat = aml_stat_panic; 930 return; 931 } 932 AML_DEBUGPRINT("Device("); 933 name = aml_parse_namestring(env); 934 aml_print_namestring(name); 935 AML_DEBUGPRINT(") {\n"); 936 *copy = *env; 937 AML_CREATE_NAME(copy->curname, env, name,); 938 if (copy->curname->property != NULL) { 939 env->stat = aml_stat_panic; 940 AML_DEBUGPRINT("Already Defined \n"); 941 goto out; 942 } 943 AML_ALLOC_OBJECT(copy->curname->property, env, aml_t_device,); 944 env->dp = copy->end = start + pkglength; 945 aml_parse_objectlist(copy, indent + 1); 946 aml_print_indent(indent); 947 AML_DEBUGPRINT("}"); 948 aml_free_objectcontent(©->tempobject); 949 950 AML_SYSASSERT(copy->dp == copy->end); 951 out: 952 memman_free(aml_memman, memid_aml_environ, copy); 953 } 954 955 static void 956 aml_parse_defprocessor(struct aml_environ *env, int indent) 957 { 958 u_int8_t *start; 959 u_int8_t *name; 960 u_int32_t pkglength; 961 struct aml_environ *copy; 962 struct aml_processor *proc; 963 union aml_object *obj; 964 965 start = env->dp; 966 pkglength = aml_parse_pkglength(env); 967 copy = memman_alloc(aml_memman, memid_aml_environ); 968 if (copy == NULL) { 969 env->stat = aml_stat_panic; 970 return; 971 } 972 AML_ALLOC_OBJECT(obj, env, aml_t_processor,); 973 proc = &obj->proc; 974 AML_DEBUGPRINT("Processor("); 975 name = aml_parse_namestring(env); 976 aml_print_namestring(name); 977 proc->id = aml_parse_bytedata(env); 978 proc->addr = aml_parse_dworddata(env); 979 proc->len = aml_parse_bytedata(env); 980 AML_DEBUGPRINT(", %d, 0x%x, 0x%x) {\n", proc->id, proc->addr, proc->len); 981 *copy = *env; 982 AML_CREATE_NAME(copy->curname, env, name,); 983 if (copy->curname->property != NULL) { 984 env->stat = aml_stat_panic; 985 AML_DEBUGPRINT("Already Defined \n"); 986 goto out; 987 } 988 copy->curname->property = obj; 989 env->dp = copy->end = start + pkglength; 990 aml_parse_objectlist(copy, indent + 1); 991 aml_print_indent(indent); 992 AML_DEBUGPRINT("}"); 993 aml_free_objectcontent(©->tempobject); 994 995 AML_SYSASSERT(copy->dp == copy->end); 996 out: 997 memman_free(aml_memman, memid_aml_environ, copy); 998 } 999 1000 static void 1001 aml_parse_defpowerres(struct aml_environ *env, int indent) 1002 { 1003 u_int8_t *start; 1004 u_int8_t *name; 1005 u_int32_t pkglength; 1006 struct aml_environ *copy; 1007 struct aml_powerres *pres; 1008 union aml_object *obj; 1009 1010 start = env->dp; 1011 pkglength = aml_parse_pkglength(env); 1012 copy = memman_alloc(aml_memman, memid_aml_environ); 1013 if (copy == NULL) { 1014 env->stat = aml_stat_panic; 1015 return; 1016 } 1017 AML_DEBUGPRINT("PowerResource("); 1018 AML_ALLOC_OBJECT(obj, env, aml_t_powerres,); 1019 name = aml_parse_namestring(env); 1020 aml_print_namestring(name); 1021 pres = &obj->pres; 1022 pres->level = aml_parse_bytedata(env); 1023 pres->order = aml_parse_worddata(env); 1024 AML_DEBUGPRINT(", %d, %d) {\n", pres->level, pres->order); 1025 *copy = *env; 1026 AML_CREATE_NAME(copy->curname, env, name,); 1027 if (copy->curname->property != NULL) { 1028 env->stat = aml_stat_panic; 1029 AML_DEBUGPRINT("Already Defined \n"); 1030 goto out; 1031 } 1032 copy->curname->property = obj; 1033 env->dp = copy->end = start + pkglength; 1034 1035 aml_parse_objectlist(copy, indent + 1); 1036 aml_print_indent(indent); 1037 AML_DEBUGPRINT("}"); 1038 aml_free_objectcontent(©->tempobject); 1039 1040 AML_SYSASSERT(copy->dp == copy->end); 1041 out: 1042 memman_free(aml_memman, memid_aml_environ, copy); 1043 } 1044 1045 static void 1046 aml_parse_defthermalzone(struct aml_environ *env, int indent) 1047 { 1048 u_int8_t *start; 1049 u_int8_t *name; 1050 u_int32_t pkglength; 1051 struct aml_environ *copy; 1052 1053 start = env->dp; 1054 pkglength = aml_parse_pkglength(env); 1055 copy = memman_alloc(aml_memman, memid_aml_environ); 1056 if (copy == NULL) { 1057 env->stat = aml_stat_panic; 1058 return; 1059 } 1060 AML_DEBUGPRINT("ThermalZone("); 1061 name = aml_parse_namestring(env); 1062 aml_print_namestring(name); 1063 AML_DEBUGPRINT(") {\n"); 1064 *copy = *env; 1065 AML_CREATE_NAME(copy->curname, env, name,); 1066 if (copy->curname->property != NULL) { 1067 env->stat = aml_stat_panic; 1068 AML_DEBUGPRINT("Already Defined \n"); 1069 goto out; 1070 } 1071 AML_ALLOC_OBJECT(copy->curname->property, env, aml_t_therm,); 1072 env->dp = copy->end = start + pkglength; 1073 aml_parse_objectlist(copy, indent + 1); 1074 aml_print_indent(indent); 1075 AML_DEBUGPRINT("}"); 1076 aml_free_objectcontent(©->tempobject); 1077 AML_SYSASSERT(copy->dp == copy->end); 1078 out: 1079 memman_free(aml_memman, memid_aml_environ, copy); 1080 } 1081 1082 static struct aml_name * 1083 aml_parse_defelse(struct aml_environ *env, int indent, int num) 1084 { 1085 u_int8_t *start, *end, *oend; 1086 u_int32_t pkglength; 1087 struct aml_name *aname; 1088 1089 start = env->dp; 1090 pkglength = aml_parse_pkglength(env); 1091 oend = env->end; 1092 env->end = end = start + pkglength; 1093 aname = NULL; 1094 1095 AML_DEBUGPRINT("Else {\n"); 1096 if (num == 0) { 1097 aname = aml_parse_objectlist(env, indent + 1); 1098 aml_print_indent(indent); 1099 } 1100 AML_DEBUGPRINT("}"); 1101 1102 env->dp = end; 1103 env->end = oend; 1104 return (aname); 1105 } 1106 1107 static struct aml_name * 1108 aml_parse_defif(struct aml_environ *env, int indent) 1109 { 1110 u_int8_t *start, *end, *oend; 1111 u_int32_t pkglength; 1112 int num; 1113 struct aml_name *aname, *aname1; 1114 1115 start = env->dp; 1116 pkglength = aml_parse_pkglength(env); 1117 aname = NULL; 1118 1119 AML_DEBUGPRINT("If("); 1120 num = aml_objtonum(env, aml_eval_name 1121 (env, aml_parse_termobj(env, indent))); 1122 oend = env->end; 1123 end = start + pkglength; 1124 AML_DEBUGPRINT(")"); 1125 if (num) { 1126 AML_DEBUGPRINT("{\n"); 1127 env->end = end; 1128 aname = aml_parse_objectlist(env, indent + 1); 1129 aml_print_indent(indent); 1130 AML_DEBUGPRINT("}"); 1131 } 1132 env->dp = end; 1133 env->end = oend; 1134 if ((end < oend) && *(env->dp) == 0xa1) { 1135 env->dp++; 1136 aname1 = aml_parse_defelse(env, indent, num); 1137 aname = (num == 0) ? aname1 : aname; 1138 } 1139 return (aname); 1140 } 1141 1142 static struct aml_name * 1143 aml_parse_defwhile(struct aml_environ *env, int indent) 1144 { 1145 u_int8_t *start, *end, *oend; 1146 u_int32_t pkglength; 1147 int num; 1148 struct aml_name *aname; 1149 1150 start = env->dp; 1151 pkglength = aml_parse_pkglength(env); 1152 oend = env->end; 1153 end = start + pkglength; 1154 aname = NULL; 1155 for (;;) { 1156 env->dp = start; 1157 aml_parse_pkglength(env); 1158 AML_DEBUGPRINT("While("); 1159 num = aml_objtonum(env, aml_eval_name 1160 (env, aml_parse_termobj(env, indent))); 1161 AML_DEBUGPRINT(")"); 1162 if (num == 0) { 1163 break; 1164 } 1165 AML_DEBUGPRINT(" {\n"); 1166 env->end = end; 1167 aname = aml_parse_objectlist(env, indent + 1); 1168 if (env->stat == aml_stat_step) { 1169 AML_DEBUGGER(env, env); 1170 continue; 1171 } 1172 if (env->stat != aml_stat_none) 1173 break; 1174 aml_print_indent(indent); 1175 AML_DEBUGPRINT("}"); 1176 } 1177 AML_DEBUGPRINT("\n"); 1178 env->dp = end; 1179 env->end = oend; 1180 if (env->stat == aml_stat_break) { 1181 env->stat = aml_stat_none; 1182 aname = NULL; 1183 } 1184 return (aname); 1185 } 1186 1187 static void 1188 aml_parse_defmutex(struct aml_environ *env, int indent) 1189 { 1190 char *name; 1191 struct aml_name *aname; 1192 struct aml_mutex *mut; 1193 1194 /* MutexOp */ 1195 AML_DEBUGPRINT("Mutex("); 1196 name = (char *)aml_parse_namestring(env); 1197 aml_print_namestring((unsigned char *)name); 1198 AML_CREATE_NAME(aname, env, (unsigned char *)name,); 1199 if (aname->property != NULL) { 1200 env->stat = aml_stat_panic; 1201 AML_DEBUGPRINT("Already Defined \n"); 1202 return; 1203 } 1204 AML_ALLOC_OBJECT(aname->property, env, aml_t_mutex,); 1205 mut = &aname->property->mutex; 1206 mut->level = *env->dp++; 1207 STAILQ_INIT(&mut->queue); 1208 AML_DEBUGPRINT(", %d)", mut->level); 1209 } 1210 1211 static void 1212 aml_createfield_generic(struct aml_environ *env, 1213 union aml_object *srcbuf, int idx, 1214 int len, char *newname) 1215 { 1216 struct aml_bufferfield *field; 1217 struct aml_name *aname; 1218 1219 if (srcbuf == NULL || srcbuf->type != aml_t_buffer) { 1220 AML_DEBUGPRINT("Not Buffer assigned,"); 1221 env->stat = aml_stat_panic; 1222 return; 1223 } 1224 AML_CREATE_NAME(aname, env, (unsigned char *)newname,); 1225 if (aname->property != NULL) { 1226 env->stat = aml_stat_panic; 1227 AML_DEBUGPRINT("Already Defined \n"); 1228 return; 1229 } 1230 AML_ALLOC_OBJECT(aname->property, env, aml_t_bufferfield,); 1231 field = &aname->property->bfld; 1232 field->bitoffset = idx; 1233 field->bitlen = len; 1234 field->origin = srcbuf->buffer.data; 1235 } 1236 1237 static void 1238 aml_parse_defcreatefield(struct aml_environ *env, int indent) 1239 { 1240 int idx, len; 1241 char *newname; 1242 union aml_object *obj, *srcbuf; 1243 1244 /* CreateFieldOp */ 1245 AML_DEBUGPRINT("CreateField("); 1246 srcbuf = aml_eval_name(env, aml_parse_termobj(env, indent)); 1247 if (srcbuf == &env->tempobject) { 1248 AML_DEBUGPRINT("NONAMED BUFFER\n"); 1249 env->stat = aml_stat_panic; 1250 return; 1251 } 1252 AML_DEBUGPRINT(", "); 1253 obj = aml_eval_name(env, aml_parse_termobj(env, indent)); 1254 idx = aml_objtonum(env, obj); 1255 AML_DEBUGPRINT(", "); 1256 obj = aml_eval_name(env, aml_parse_termobj(env, indent)); 1257 len = aml_objtonum(env, obj); 1258 AML_DEBUGPRINT(", "); 1259 newname = (char *)aml_parse_namestring(env); 1260 aml_print_namestring((unsigned char *)newname); 1261 aml_createfield_generic(env, srcbuf, idx, len, newname); 1262 AML_DEBUGPRINT(") "); 1263 } 1264 1265 /* 1266 * Returns Named object or parser buffer. The object need not be free because 1267 * it returns preallocated buffer in env or Contain of named object. If You 1268 * need to preserve object, create a copy and then store. And The object 1269 * returned from this function is not valid after another call is 1270 * shared, tempolary buffer may be shared. 1271 */ 1272 struct aml_name * 1273 aml_parse_termobj(struct aml_environ *env, int indent) 1274 { 1275 u_int8_t opcode; 1276 u_int8_t *name; 1277 int value; 1278 int num1, num2; 1279 int len; 1280 int match1, match2, i, pkgval, start; 1281 int widthindex, idx; 1282 char *newname; 1283 struct aml_name *aname; 1284 struct aml_name *destname1, *destname2; 1285 struct aml_name *tmpname, *srcname; 1286 struct aml_name *src; 1287 union aml_object *ret; 1288 union aml_object *tmpobj; 1289 union aml_object anum; 1290 union aml_object *objref; 1291 union aml_object *srcobj; 1292 union aml_object *obj; 1293 union aml_object *srcbuf; 1294 static int widthtbl[4] = {32, 16, 8, 1}; 1295 const char *opname[4] = {"CreateDWordField", "CreateWordField", 1296 "CreateByteField", "CreateBitField"}; 1297 1298 aname = &env->tempname; 1299 ret = &env->tempobject; 1300 anum.type = aml_t_num; 1301 aname->property = ret; 1302 aml_free_objectcontent(ret); 1303 if (env->stat == aml_stat_panic) { 1304 /* 1305 * If previosuly parser panic , parsing next instruction is 1306 * prohibited. 1307 */ 1308 return (NULL); 1309 } 1310 aname = NULL; 1311 opcode = *env->dp++; 1312 switch (opcode) { 1313 case '\\': 1314 case '^': 1315 case 'A' ... 'Z': 1316 case '_': 1317 case '.': 1318 case '/': 1319 env->dp--; 1320 ret->type = aml_t_namestr; 1321 ret->nstr.dp = aml_parse_namestring(env); 1322 aml_print_namestring(ret->nstr.dp); 1323 aname = &env->tempname; 1324 break; 1325 case 0x0a: /* BytePrefix */ 1326 ret->type = aml_t_num; 1327 value = aml_parse_bytedata(env); 1328 ret->num.number = value; 1329 AML_DEBUGPRINT("0x%x", value); 1330 aname = &env->tempname; 1331 break; 1332 case 0x0b: /* WordPrefix */ 1333 ret->type = aml_t_num; 1334 value = aml_parse_worddata(env); 1335 ret->num.number = value; 1336 AML_DEBUGPRINT("0x%x", value); 1337 aname = &env->tempname; 1338 break; 1339 case 0x0c: /* DWordPrefix */ 1340 ret->type = aml_t_num; 1341 value = aml_parse_dworddata(env); 1342 ret->num.number = value; 1343 AML_DEBUGPRINT("0x%x", value); 1344 aname = &env->tempname; 1345 break; 1346 case 0x0d: /* StringPrefix */ 1347 ret->type = aml_t_string; 1348 ret->str.string = env->dp; 1349 len = strlen((const char *)env->dp); 1350 ret->str.needfree = 0; 1351 AML_DEBUGPRINT("\"%s\"", (const char *)ret->str.string); 1352 env->dp += (len + 1); 1353 aname = &env->tempname; 1354 break; 1355 case 0x00: /* ZeroOp */ 1356 ret->type = aml_t_num; 1357 ret->num.number = 0; 1358 ret->num.constant = 1; 1359 AML_DEBUGPRINT("Zero"); 1360 aname = &env->tempname; 1361 break; 1362 case 0x01: /* OneOp */ 1363 ret->type = aml_t_num; 1364 ret->num.number = 1; 1365 ret->num.constant = 1; 1366 AML_DEBUGPRINT("One"); 1367 aname = &env->tempname; 1368 break; 1369 case 0xff: /* OnesOp */ 1370 ret->type = aml_t_num; 1371 ret->num.number = 0xffffffff; 1372 ret->num.constant = 1; 1373 AML_DEBUGPRINT("Ones"); 1374 aname = &env->tempname; 1375 break; 1376 case 0x06: /* AliasOp */ 1377 AML_DEBUGPRINT("Alias("); 1378 tmpname = aml_parse_termobj(env, indent); 1379 if (env->stat == aml_stat_panic) { 1380 return (NULL); 1381 } 1382 if (tmpname->property == NULL || 1383 tmpname->property->type != aml_t_namestr) { 1384 env->stat = aml_stat_panic; 1385 return (NULL); 1386 } 1387 /* 1388 * XXX if srcname is deleted after this object, what 1389 * shall I do? 1390 */ 1391 srcname = aml_search_name(env, tmpname->property->nstr.dp); 1392 AML_DEBUGPRINT(", "); 1393 name = aml_parse_namestring(env); 1394 aml_print_namestring(name); 1395 AML_CREATE_NAME(aname, env, name, 0); 1396 if (aname->property != NULL) { 1397 env->stat = aml_stat_panic; 1398 AML_DEBUGPRINT("Already Defined \n"); 1399 aml_print_curname(aname); 1400 return (NULL); 1401 } 1402 AML_ALLOC_OBJECT(aname->property, env, aml_t_objref, NULL); 1403 objref = aname->property; 1404 objref->objref.nameref = srcname; 1405 objref->objref.ref = srcname->property; 1406 objref->objref.offset = -1; 1407 objref->objref.alias = 1; /* Yes, this is an alias */ 1408 AML_DEBUGPRINT(")"); 1409 /* shut the interpreter up during the namespace initializing */ 1410 return (NULL); 1411 case 0x08: /* NameOp */ 1412 AML_DEBUGPRINT("Name("); 1413 name = aml_parse_namestring(env); 1414 aml_print_namestring(name); 1415 AML_CREATE_NAME(aname, env, name, 0); 1416 if (env->stat == aml_stat_panic) { 1417 AML_DEBUGPRINT("Already Defined \n"); 1418 aml_print_curname(aname); 1419 return (NULL); 1420 } 1421 AML_DEBUGPRINT(", "); 1422 AML_COPY_OBJECT(aname->property, env, 1423 aml_eval_name(env, 1424 aml_parse_termobj(env, indent)), 1425 NULL); 1426 AML_DEBUGPRINT(")"); 1427 break; 1428 case 0x10: /* ScopeOp */ 1429 aml_parse_defscope(env, indent); 1430 break; 1431 case 0x11: /* BufferOp */ 1432 aname = &env->tempname; 1433 aname->property = aml_parse_defbuffer(env, indent); 1434 break; 1435 case 0x12: /* PackageOp */ 1436 aname = &env->tempname; 1437 aname->property = aml_parse_defpackage(env, indent); 1438 break; 1439 case 0x14: /* MethodOp */ 1440 aml_parse_defmethod(env, indent); 1441 break; 1442 case 0x5b: /* ExtOpPrefix */ 1443 opcode = *env->dp++; 1444 switch (opcode) { 1445 case 0x01: 1446 aml_parse_defmutex(env, indent); 1447 break; 1448 case 0x02: /* EventOp */ 1449 AML_DEBUGPRINT("Event("); 1450 name = aml_parse_namestring(env); 1451 aml_print_namestring(name); 1452 AML_CREATE_NAME(aname, env, name, 0); 1453 if (aname->property != NULL) { 1454 env->stat = aml_stat_panic; 1455 AML_DEBUGPRINT("Already Defined \n"); 1456 return (NULL); 1457 } 1458 AML_ALLOC_OBJECT(aname->property, env, aml_t_event, NULL); 1459 AML_DEBUGPRINT(")"); 1460 return (NULL); 1461 break; 1462 case 0x12: /* CondRefOfOp */ 1463 AML_DEBUGPRINT("CondRefOf("); 1464 src = aml_parse_termobj(env, indent); 1465 AML_DEBUGPRINT(", "); 1466 if (src == &env->tempname || src == NULL) { 1467 aml_parse_termobj(env, indent); 1468 AML_DEBUGPRINT(")"); 1469 anum.num.number = 0xffffffff; 1470 env->tempobject.num = anum.num; 1471 aname = &env->tempname; 1472 break; 1473 } 1474 AML_ALLOC_OBJECT(objref, env, aml_t_objref, NULL); 1475 if (src->property == NULL || 1476 src->property->type != aml_t_namestr) { 1477 objref->objref.nameref = src; 1478 } else { 1479 objref->objref.nameref = aml_create_local_object(); 1480 } 1481 objref->objref.ref = src->property; 1482 objref->objref.offset = -1; /* different from IndexOp */ 1483 1484 destname1 = aml_parse_termobj(env, indent); 1485 aml_store_to_name(env, objref, destname1); 1486 anum.num.number = 0; 1487 env->tempobject.num = anum.num; 1488 aname = &env->tempname; 1489 AML_DEBUGPRINT(")"); 1490 break; 1491 case 0x13: 1492 aml_parse_defcreatefield(env, indent); 1493 break; 1494 case 0x20: /* LoadOp *//* XXX Not Impremented */ 1495 AML_DEBUGPRINT("Load("); 1496 aml_parse_termobj(env, indent); 1497 AML_DEBUGPRINT(", "); 1498 aml_parse_termobj(env, indent); 1499 AML_DEBUGPRINT(")"); 1500 break; 1501 case 0x21: /* StallOp */ 1502 AML_DEBUGPRINT("Stall("); 1503 num1 = aml_objtonum(env, aml_eval_name(env, 1504 aml_parse_termobj(env, indent))); 1505 AML_DEBUGPRINT(")"); 1506 AML_STALL(num1); 1507 break; 1508 case 0x22: /* SleepOp */ 1509 AML_DEBUGPRINT("Sleep("); 1510 num1 = aml_objtonum(env, aml_eval_name(env, 1511 aml_parse_termobj(env, indent))); 1512 AML_SLEEP(0, num1); 1513 AML_DEBUGPRINT(")"); 1514 break; 1515 case 0x23: /* AcquireOp *//* XXX Not yet */ 1516 AML_DEBUGPRINT("Acquire("); 1517 aml_parse_termobj(env, indent); 1518 AML_DEBUGPRINT(", 0x%x)", aml_parse_worddata(env)); 1519 break; 1520 case 0x24: /* SignalOp *//* XXX Not yet */ 1521 AML_DEBUGPRINT("Signal("); 1522 aml_parse_termobj(env, indent); 1523 AML_DEBUGPRINT(")"); 1524 break; 1525 case 0x25: /* WaitOp *//* XXX Not yet impremented */ 1526 AML_DEBUGPRINT("Wait("); 1527 aml_parse_termobj(env, indent); 1528 AML_DEBUGPRINT(", "); 1529 aml_parse_termobj(env, indent); 1530 AML_DEBUGPRINT(")"); 1531 break; 1532 case 0x26: /* ResetOp *//* XXX Not yet impremented */ 1533 AML_DEBUGPRINT("Reset("); 1534 aml_parse_termobj(env, indent); 1535 AML_DEBUGPRINT(")"); 1536 break; 1537 case 0x27: /* ReleaseOp *//* XXX Not yet impremented */ 1538 AML_DEBUGPRINT("Release("); 1539 aml_parse_termobj(env, indent); 1540 AML_DEBUGPRINT(")"); 1541 break; 1542 #define NUMOP2(opname, operation) do { \ 1543 AML_DEBUGPRINT(opname); \ 1544 AML_DEBUGPRINT("("); \ 1545 num1 = aml_objtonum(env, aml_eval_name(env, \ 1546 aml_parse_termobj(env, indent))); \ 1547 AML_DEBUGPRINT(", "); \ 1548 anum.num.number = operation (num1); \ 1549 destname1 = aml_parse_termobj(env, indent); \ 1550 AML_DEBUGPRINT(")"); \ 1551 aml_store_to_name(env, &anum, destname1); \ 1552 env->tempobject.num = anum.num; \ 1553 env->tempname.property = &env->tempobject; \ 1554 aname = &env->tempname; \ 1555 } while(0) 1556 1557 case 0x28: /* FromBCDOp */ 1558 NUMOP2("FromBCD", frombcd); 1559 break; 1560 case 0x29: /* ToBCDOp */ 1561 NUMOP2("ToBCD", tobcd); 1562 break; 1563 case 0x2a: /* UnloadOp *//* XXX Not yet impremented */ 1564 AML_DEBUGPRINT("Unload("); 1565 aml_parse_termobj(env, indent); 1566 AML_DEBUGPRINT(")"); 1567 break; 1568 case 0x30: 1569 env->tempobject.type = aml_t_num; 1570 env->tempobject.num.number = 0; 1571 env->tempobject.num.constant = 1; 1572 AML_DEBUGPRINT("Revision"); 1573 break; 1574 case 0x31: 1575 env->tempobject.type = aml_t_debug; 1576 aname = &env->tempname; 1577 AML_DEBUGPRINT("Debug"); 1578 break; 1579 case 0x32: /* FatalOp */ 1580 AML_DEBUGPRINT("Fatal("); 1581 AML_DEBUGPRINT("0x%x, ", aml_parse_bytedata(env)); 1582 AML_DEBUGPRINT("0x%x, ", aml_parse_dworddata(env)); 1583 aml_parse_termobj(env, indent); 1584 env->stat = aml_stat_panic; 1585 AML_DEBUGPRINT(")"); 1586 break; 1587 case 0x80: /* OpRegionOp */ 1588 aml_parse_defopregion(env, indent); 1589 break; 1590 case 0x81: /* FieldOp */ 1591 aml_parse_deffield(env, indent); 1592 break; 1593 case 0x82: /* DeviceOp */ 1594 aml_parse_defdevice(env, indent); 1595 break; 1596 case 0x83: /* ProcessorOp */ 1597 aml_parse_defprocessor(env, indent); 1598 break; 1599 case 0x84: /* PowerResOp */ 1600 aml_parse_defpowerres(env, indent); 1601 break; 1602 case 0x85: /* ThermalZoneOp */ 1603 aml_parse_defthermalzone(env, indent); 1604 break; 1605 case 0x86: /* IndexFieldOp */ 1606 aml_parse_defindexfield(env, indent); 1607 break; 1608 case 0x87: /* BankFieldOp */ 1609 aml_parse_defbankfield(env, indent); 1610 break; 1611 default: 1612 AML_SYSERRX(1, "strange opcode 0x5b, 0x%x\n", opcode); 1613 AML_SYSABORT(); 1614 } 1615 break; 1616 case 0x68 ... 0x6e: /* ArgN */ 1617 AML_DEBUGPRINT("Arg%d", opcode - 0x68); 1618 return (aml_local_stack_getArgX(NULL, opcode - 0x68)); 1619 break; 1620 case 0x60 ... 0x67: 1621 AML_DEBUGPRINT("Local%d", opcode - 0x60); 1622 return (aml_local_stack_getLocalX(opcode - 0x60)); 1623 break; 1624 case 0x70: /* StoreOp */ 1625 AML_DEBUGPRINT("Store("); 1626 aname = aml_create_local_object(); 1627 AML_COPY_OBJECT(tmpobj, env, 1628 aml_eval_name(env, aml_parse_termobj(env, indent)), NULL); 1629 aname->property = tmpobj; 1630 AML_DEBUGPRINT(", "); 1631 destname1 = aml_parse_termobj(env, indent); 1632 AML_DEBUGPRINT(")"); 1633 /* XXX 1634 * temporary object may change during aml_store_to_name() 1635 * operation, so we make a copy of it on stack. 1636 */ 1637 if (destname1 == &env->tempname && 1638 destname1->property == &env->tempobject) { 1639 destname1 = aml_create_local_object(); 1640 AML_COPY_OBJECT(destname1->property, env, 1641 &env->tempobject, NULL); 1642 } 1643 aml_store_to_name(env, tmpobj, destname1); 1644 if (env->stat == aml_stat_panic) { 1645 AML_DEBUGPRINT("StoreOp failed"); 1646 return (NULL); 1647 } 1648 aname = aml_create_local_object(); 1649 AML_COPY_OBJECT(tmpobj, env, destname1->property, NULL); 1650 aname->property = tmpobj; 1651 if (tmpobj == NULL) { 1652 printf("???"); 1653 break; 1654 } 1655 break; 1656 case 0x71: /* RefOfOp */ 1657 AML_DEBUGPRINT("RefOf("); 1658 src = aml_parse_termobj(env, indent); 1659 AML_DEBUGPRINT(")"); 1660 1661 aname = aml_create_local_object(); 1662 AML_ALLOC_OBJECT(aname->property, env, aml_t_objref, NULL); 1663 objref = aname->property; 1664 if (src->property == NULL || 1665 src->property->type != aml_t_namestr) { 1666 objref->objref.nameref = src; 1667 } else { 1668 objref->objref.nameref = aml_create_local_object(); 1669 } 1670 objref->objref.ref = src->property; 1671 objref->objref.offset = -1; /* different from IndexOp */ 1672 break; 1673 1674 #define NUMOP3_2(opname, oparation, ope2) do { \ 1675 AML_DEBUGPRINT(opname); \ 1676 AML_DEBUGPRINT("("); \ 1677 num1 = aml_objtonum(env, aml_eval_name(env, \ 1678 aml_parse_termobj(env, indent))); \ 1679 AML_DEBUGPRINT(", "); \ 1680 num2 = aml_objtonum(env, aml_eval_name(env, \ 1681 aml_parse_termobj(env, indent))); \ 1682 AML_DEBUGPRINT(", "); \ 1683 anum.num.number = ope2(num1 oparation num2); \ 1684 destname1 = aml_parse_termobj(env, indent); \ 1685 AML_DEBUGPRINT(")"); \ 1686 aml_store_to_name(env, &anum, destname1); \ 1687 env->tempobject.num = anum.num; \ 1688 env->tempname.property = &env->tempobject; \ 1689 aname = &env->tempname; \ 1690 } while(0) 1691 1692 #define NUMOP3(opname, operation) NUMOP3_2(opname, operation, ) 1693 #define NUMOPN3(opname, operation) NUMOP3_2(opname, operation, ~) 1694 1695 case 0x72: /* AddOp */ 1696 NUMOP3("Add", +); 1697 break; 1698 case 0x73: /* ConcatOp */ 1699 aname = aml_parse_concatop(env, indent); 1700 break; 1701 case 0x74: /* SubtractOp */ 1702 NUMOP3("Subtract", -); 1703 break; 1704 case 0x75: /* IncrementOp */ 1705 AML_DEBUGPRINT("Increment("); 1706 aname = aml_parse_termobj(env, indent); 1707 num1 = aml_objtonum(env, aml_eval_name(env, aname)); 1708 num1++; 1709 anum.num.number = num1; 1710 AML_DEBUGPRINT(")"); 1711 aml_store_to_name(env, &anum, aname); 1712 aname = &env->tempname; 1713 env->tempobject.num = anum.num; 1714 break; 1715 case 0x76: /* DecrementOp */ 1716 AML_DEBUGPRINT("Decrement("); 1717 aname = aml_parse_termobj(env, indent); 1718 num1 = aml_objtonum(env, aml_eval_name(env, aname)); 1719 num1--; 1720 anum.num.number = num1; 1721 AML_DEBUGPRINT(")"); 1722 aml_store_to_name(env, &anum, aname); 1723 aname = &env->tempname; 1724 env->tempobject.num = anum.num; 1725 break; 1726 case 0x77: /* MultiplyOp */ 1727 NUMOP3("Multiply", *); 1728 break; 1729 case 0x78: /* DivideOp */ 1730 AML_DEBUGPRINT("Divide("); 1731 num1 = aml_objtonum(env, aml_eval_name(env, 1732 aml_parse_termobj(env, indent))); 1733 AML_DEBUGPRINT(", "); 1734 num2 = aml_objtonum(env, aml_eval_name(env, 1735 aml_parse_termobj(env, indent))); 1736 AML_DEBUGPRINT(", "); 1737 anum.num.number = num1 % num2; 1738 destname1 = aml_parse_termobj(env, indent); 1739 aml_store_to_name(env, &anum, destname1); 1740 AML_DEBUGPRINT(", "); 1741 anum.num.number = num1 / num2; 1742 destname2 = aml_parse_termobj(env, indent); 1743 AML_DEBUGPRINT(")"); 1744 aml_store_to_name(env, &anum, destname2); 1745 env->tempobject.num = anum.num; 1746 aname = &env->tempname; 1747 break; 1748 case 0x79: /* ShiftLeftOp */ 1749 NUMOP3("ShiftLeft", <<); 1750 break; 1751 case 0x7a: /* ShiftRightOp */ 1752 NUMOP3("ShiftRight", >>); 1753 break; 1754 case 0x7b: /* AndOp */ 1755 NUMOP3("And", &); 1756 break; 1757 case 0x7c: /* NAndOp */ 1758 NUMOPN3("NAnd", &); 1759 break; 1760 case 0x7d: /* OrOp */ 1761 NUMOP3("Or", |); 1762 break; 1763 case 0x7e: /* NOrOp */ 1764 NUMOPN3("NOr", |); 1765 break; 1766 case 0x7f: /* XOrOp */ 1767 NUMOP3("XOr", ^); 1768 break; 1769 case 0x80: /* NotOp */ 1770 NUMOP2("Not", ~); 1771 break; 1772 case 0x81: /* FindSetLeftBitOp */ 1773 NUMOP2("FindSetLeftBit", findsetleftbit); 1774 break; 1775 case 0x82: /* FindSetRightBitOp */ 1776 NUMOP2("FindSetRightBit", findsetrightbit); 1777 break; 1778 case 0x83: /* DerefOp */ 1779 AML_DEBUGPRINT("DerefOf("); 1780 objref = aml_eval_name(env, aml_parse_termobj(env, indent)); 1781 AML_DEBUGPRINT(")"); 1782 1783 if (objref->objref.ref == NULL) { 1784 env->tempname.property = objref->objref.ref; 1785 aname = &env->tempname; 1786 break; 1787 } 1788 switch (objref->objref.ref->type) { 1789 case aml_t_package: 1790 case aml_t_buffer: 1791 if (objref->objref.offset < 0) { 1792 env->tempname.property = objref->objref.ref; 1793 } else { 1794 objref->objref.deref = 1; 1795 env->tempname.property = objref; 1796 } 1797 break; 1798 default: 1799 env->tempname.property = objref->objref.ref; 1800 break; 1801 } 1802 1803 aname = &env->tempname; 1804 break; 1805 case 0x86: /* NotifyOp *//* XXX Not yet impremented */ 1806 AML_DEBUGPRINT("Notify("); 1807 aml_parse_termobj(env, indent); 1808 AML_DEBUGPRINT(", "); 1809 aml_parse_termobj(env, indent); 1810 AML_DEBUGPRINT(")"); 1811 break; 1812 case 0x87: /* SizeOfOp */ 1813 AML_DEBUGPRINT("SizeOf("); 1814 aname = aml_parse_termobj(env, indent); 1815 tmpobj = aml_eval_name(env, aname); 1816 1817 AML_DEBUGPRINT(")"); 1818 num1 = 0; 1819 switch (tmpobj->type) { 1820 case aml_t_buffer: 1821 num1 = tmpobj->buffer.size; 1822 break; 1823 case aml_t_string: 1824 num1 = strlen((const char *)tmpobj->str.string); 1825 break; 1826 case aml_t_package: 1827 num1 = tmpobj->package.elements; 1828 break; 1829 default: 1830 AML_DEBUGPRINT("Args of SizeOf should be " 1831 "buffer/string/package only\n"); 1832 break; 1833 } 1834 1835 anum.num.number = num1; 1836 env->tempobject.num = anum.num; 1837 aname = &env->tempname; 1838 break; 1839 case 0x88: /* IndexOp */ 1840 AML_DEBUGPRINT("Index("); 1841 srcobj = aml_eval_name(env, aml_parse_termobj(env, indent)); 1842 AML_DEBUGPRINT(", "); 1843 num1 = aml_objtonum(env, aml_eval_name(env, 1844 aml_parse_termobj(env, indent))); 1845 AML_DEBUGPRINT(", "); 1846 destname1 = aml_parse_termobj(env, indent); 1847 AML_DEBUGPRINT(")"); 1848 aname = aml_create_local_object(); 1849 switch (srcobj->type) { 1850 case aml_t_package: 1851 case aml_t_buffer: 1852 AML_ALLOC_OBJECT(objref, env, aml_t_objref, NULL); 1853 aname->property = objref; 1854 objref->objref.ref = srcobj; 1855 objref->objref.offset = num1; 1856 objref->objref.deref = 0; 1857 break; 1858 default: 1859 AML_DEBUGPRINT("Arg0 of Index should be either " 1860 "buffer or package\n"); 1861 return (aname); 1862 } 1863 1864 aml_store_to_name(env, objref, destname1); 1865 break; 1866 case 0x89: /* MatchOp *//* XXX Not yet Impremented */ 1867 AML_DEBUGPRINT("Match("); 1868 AML_COPY_OBJECT(obj, env, aml_eval_name(env, 1869 aml_parse_termobj(env, indent)), NULL); 1870 if (obj->type != aml_t_package) { 1871 env->stat = aml_stat_panic; 1872 return (NULL); 1873 } 1874 anum.num.number = 0xffffffff; 1875 match1 = *env->dp; 1876 AML_DEBUGPRINT(", %d", *env->dp); 1877 env->dp++; 1878 num1 = aml_objtonum(env, aml_eval_name(env, 1879 aml_parse_termobj(env, indent))); 1880 match2 = *env->dp; 1881 AML_DEBUGPRINT(", %d", *env->dp); 1882 env->dp++; 1883 num2 = aml_objtonum(env, aml_eval_name(env, 1884 aml_parse_termobj(env, indent))); 1885 AML_DEBUGPRINT(", "); 1886 start = aml_objtonum(env, aml_eval_name(env, 1887 aml_parse_termobj(env, indent))); 1888 1889 #define MATCHOP(opnum, arg1, arg2) ((opnum == 0) ? (1) : \ 1890 (opnum == 1) ? ((arg1) == (arg2)) : \ 1891 (opnum == 2) ? ((arg1) <= (arg2)) : \ 1892 (opnum == 3) ? ((arg1) < (arg2)) : \ 1893 (opnum == 4) ? ((arg1) >= (arg2)) : \ 1894 (opnum == 5) ? ((arg1) > (arg2)) : 0 ) 1895 1896 for (i = start; i < obj->package.elements; i++) { 1897 pkgval = aml_objtonum(env, obj->package.objects[i]); 1898 if (MATCHOP(match1, pkgval, num1) && 1899 MATCHOP(match2, pkgval, num2)) { 1900 anum.num.number = i; 1901 break; 1902 } 1903 } 1904 AML_DEBUGPRINT(")"); 1905 aml_free_object(&obj); 1906 aname = &env->tempname; 1907 env->tempname.property = &env->tempobject; 1908 env->tempobject.num = anum.num; 1909 break; 1910 #undef MATCHOP 1911 case 0x8a ... 0x8d: /* CreateDWordFieldOp */ 1912 widthindex = *(env->dp - 1) - 0x8a; 1913 AML_DEBUGPRINT("%s(", opname[widthindex]); 1914 srcbuf = aml_eval_name(env, aml_parse_termobj(env, indent)); 1915 if (srcbuf == &env->tempobject) { 1916 AML_DEBUGPRINT("NOT NAMEDBUF\n"); 1917 env->stat = aml_stat_panic; 1918 return (NULL); 1919 } 1920 AML_DEBUGPRINT(", "); 1921 idx = aml_objtonum(env, aml_eval_name(env, 1922 aml_parse_termobj(env, indent))); 1923 if (widthindex != 3) { 1924 idx *= 8; 1925 } 1926 AML_DEBUGPRINT(", "); 1927 newname = (char *)aml_parse_namestring(env); 1928 aml_print_namestring((unsigned char *)newname); 1929 aml_createfield_generic(env, srcbuf, idx, 1930 widthtbl[widthindex], newname); 1931 AML_DEBUGPRINT(")"); 1932 break; 1933 case 0x8e: /* ObjectTypeOp */ 1934 AML_DEBUGPRINT("ObjectType("); 1935 aname = aml_parse_termobj(env, indent); 1936 if (aname == NULL) { 1937 env->tempobject.type = aml_t_num; 1938 env->tempobject.num.number = aml_t_null; 1939 } else { 1940 env->tempobject.type = aml_t_num; 1941 env->tempobject.num.number = aname->property->type; 1942 } 1943 aname = &env->tempname; 1944 AML_DEBUGPRINT(")"); 1945 break; 1946 1947 #define CMPOP(opname,operation) do { \ 1948 AML_DEBUGPRINT(opname); \ 1949 AML_DEBUGPRINT("("); \ 1950 num1 = aml_objtonum(env, aml_eval_name(env, \ 1951 aml_parse_termobj(env, indent))); \ 1952 AML_DEBUGPRINT(", "); \ 1953 num2 = aml_objtonum(env, aml_eval_name(env, \ 1954 aml_parse_termobj(env, indent))); \ 1955 aname = &env->tempname; \ 1956 env->tempobject.type = aml_t_num; \ 1957 env->tempobject.num.number = (num1 operation num2) ? 0xffffffff : 0; \ 1958 aname->property = &env->tempobject; \ 1959 AML_DEBUGPRINT(")"); \ 1960 } while(0) 1961 1962 case 0x90: 1963 CMPOP("LAnd", &&); 1964 break; 1965 case 0x91: 1966 CMPOP("LOr", ||); 1967 break; 1968 case 0x92: 1969 AML_DEBUGPRINT("LNot("); 1970 num1 = aml_objtonum(env, aml_eval_name(env, 1971 aml_parse_termobj(env, indent))); 1972 aname = &env->tempname; 1973 env->tempobject.type = aml_t_num; 1974 env->tempobject.num.number = (!num1) ? 0xffffffff : 0; 1975 aname->property = &env->tempobject; 1976 AML_DEBUGPRINT(")"); 1977 break; 1978 case 0x93: 1979 CMPOP("LEqual", ==); 1980 break; 1981 case 0x94: 1982 CMPOP("LGreater", >); 1983 break; 1984 case 0x95: 1985 CMPOP("LLess", <); 1986 break; 1987 case 0xa0: /* IfOp */ 1988 aname = aml_parse_defif(env, indent); 1989 break; 1990 #if 0 1991 1992 case 0xa1: /* ElseOp should not be treated in Main parser 1993 * But If Op */ 1994 aml_parse_defelse(env, indent); 1995 break; 1996 #endif 1997 case 0xa2: /* WhileOp */ 1998 aname = aml_parse_defwhile(env, indent); 1999 break; 2000 case 0xa3: /* NoopOp */ 2001 AML_DEBUGPRINT("Noop"); 2002 break; 2003 case 0xa5: /* BreakOp */ 2004 AML_DEBUGPRINT("Break"); 2005 env->stat = aml_stat_break; 2006 break; 2007 case 0xa4: /* ReturnOp */ 2008 AML_DEBUGPRINT("Return("); 2009 AML_COPY_OBJECT(env->tempname.property, env, aml_eval_name(env, 2010 aml_parse_termobj(env, indent)), NULL); 2011 aname = &env->tempname; 2012 env->stat = aml_stat_return; 2013 AML_DEBUGPRINT(")"); 2014 break; 2015 case 0xcc: /* BreakPointOp */ 2016 /* XXX Not Yet Impremented (Not need?) */ 2017 AML_DEBUGPRINT("BreakPoint"); 2018 break; 2019 default: 2020 AML_SYSERRX(1, "strange opcode 0x%x\n", opcode); 2021 AML_SYSABORT(); 2022 } 2023 2024 return (aname); 2025 } 2026