1 /****************************************************************************** 2 * 3 * Module Name: aslrestype1i - Small I/O-related resource descriptors 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include "aslcompiler.h" 45 #include "aslcompiler.y.h" 46 47 #define _COMPONENT ACPI_COMPILER 48 ACPI_MODULE_NAME ("aslrestype1i") 49 50 /* 51 * This module contains the I/O-related small resource descriptors: 52 * 53 * DMA 54 * FixedDMA 55 * FixedIO 56 * IO 57 * IRQ 58 * IRQNoFlags 59 */ 60 61 /******************************************************************************* 62 * 63 * FUNCTION: RsDoDmaDescriptor 64 * 65 * PARAMETERS: Info - Parse Op and resource template offset 66 * 67 * RETURN: Completed resource node 68 * 69 * DESCRIPTION: Construct a short "DMA" descriptor 70 * 71 ******************************************************************************/ 72 73 ASL_RESOURCE_NODE * 74 RsDoDmaDescriptor ( 75 ASL_RESOURCE_INFO *Info) 76 { 77 AML_RESOURCE *Descriptor; 78 ACPI_PARSE_OBJECT *InitializerOp; 79 ASL_RESOURCE_NODE *Rnode; 80 UINT32 CurrentByteOffset; 81 UINT32 i; 82 UINT8 DmaChannelMask = 0; 83 UINT8 DmaChannels = 0; 84 85 86 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 87 CurrentByteOffset = Info->CurrentByteOffset; 88 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_DMA)); 89 90 Descriptor = Rnode->Buffer; 91 Descriptor->Dma.DescriptorType = ACPI_RESOURCE_NAME_DMA | 92 ASL_RDESC_DMA_SIZE; 93 94 /* Process all child initialization nodes */ 95 96 for (i = 0; InitializerOp; i++) 97 { 98 switch (i) 99 { 100 case 0: /* DMA type */ 101 102 RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 5, 0); 103 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_DMATYPE, 104 CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 5, 2); 105 break; 106 107 case 1: /* Bus Master */ 108 109 RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 2, 0); 110 RsCreateBitField (InitializerOp, ACPI_RESTAG_BUSMASTER, 111 CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 2); 112 break; 113 114 case 2: /* Xfer Type (transfer width) */ 115 116 RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 0, 0); 117 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_XFERTYPE, 118 CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 0, 2); 119 break; 120 121 case 3: /* Name */ 122 123 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 124 break; 125 126 default: 127 128 /* All DMA channel bytes are handled here, after flags and name */ 129 130 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 131 { 132 /* Up to 8 channels can be specified in the list */ 133 134 DmaChannels++; 135 if (DmaChannels > 8) 136 { 137 AslError (ASL_ERROR, ASL_MSG_DMA_LIST, 138 InitializerOp, NULL); 139 return (Rnode); 140 } 141 142 /* Only DMA channels 0-7 are allowed (mask is 8 bits) */ 143 144 if (InitializerOp->Asl.Value.Integer > 7) 145 { 146 AslError (ASL_ERROR, ASL_MSG_DMA_CHANNEL, 147 InitializerOp, NULL); 148 } 149 150 /* Build the mask */ 151 152 DmaChannelMask |= 153 (1 << ((UINT8) InitializerOp->Asl.Value.Integer)); 154 } 155 156 if (i == 4) /* case 4: First DMA byte */ 157 { 158 /* Check now for duplicates in list */ 159 160 RsCheckListForDuplicates (InitializerOp); 161 162 /* Create a named field at the start of the list */ 163 164 RsCreateByteField (InitializerOp, ACPI_RESTAG_DMA, 165 CurrentByteOffset + 166 ASL_RESDESC_OFFSET (Dma.DmaChannelMask)); 167 } 168 break; 169 } 170 171 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 172 } 173 174 /* Now we can set the channel mask */ 175 176 Descriptor->Dma.DmaChannelMask = DmaChannelMask; 177 return (Rnode); 178 } 179 180 181 /******************************************************************************* 182 * 183 * FUNCTION: RsDoFixedDmaDescriptor 184 * 185 * PARAMETERS: Info - Parse Op and resource template offset 186 * 187 * RETURN: Completed resource node 188 * 189 * DESCRIPTION: Construct a short "FixedDMA" descriptor 190 * 191 ******************************************************************************/ 192 193 ASL_RESOURCE_NODE * 194 RsDoFixedDmaDescriptor ( 195 ASL_RESOURCE_INFO *Info) 196 { 197 AML_RESOURCE *Descriptor; 198 ACPI_PARSE_OBJECT *InitializerOp; 199 ASL_RESOURCE_NODE *Rnode; 200 UINT32 CurrentByteOffset; 201 UINT32 i; 202 203 204 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 205 CurrentByteOffset = Info->CurrentByteOffset; 206 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_FIXED_DMA)); 207 208 Descriptor = Rnode->Buffer; 209 Descriptor->FixedDma.DescriptorType = 210 ACPI_RESOURCE_NAME_FIXED_DMA | ASL_RDESC_FIXED_DMA_SIZE; 211 212 /* Process all child initialization nodes */ 213 214 for (i = 0; InitializerOp; i++) 215 { 216 switch (i) 217 { 218 case 0: /* DMA Request Lines [WORD] (_DMA) */ 219 220 Descriptor->FixedDma.RequestLines = (UINT16) InitializerOp->Asl.Value.Integer; 221 RsCreateWordField (InitializerOp, ACPI_RESTAG_DMA, 222 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedDma.RequestLines)); 223 break; 224 225 case 1: /* DMA Channel [WORD] (_TYP) */ 226 227 Descriptor->FixedDma.Channels = (UINT16) InitializerOp->Asl.Value.Integer; 228 RsCreateWordField (InitializerOp, ACPI_RESTAG_DMATYPE, 229 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedDma.Channels)); 230 break; 231 232 case 2: /* Transfer Width [BYTE] (_SIZ) */ 233 234 Descriptor->FixedDma.Width = (UINT8) InitializerOp->Asl.Value.Integer; 235 RsCreateByteField (InitializerOp, ACPI_RESTAG_XFERTYPE, 236 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedDma.Width)); 237 break; 238 239 case 3: /* Descriptor Name (optional) */ 240 241 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 242 break; 243 244 default: /* Ignore any extra nodes */ 245 246 break; 247 } 248 249 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 250 } 251 252 return (Rnode); 253 } 254 255 256 /******************************************************************************* 257 * 258 * FUNCTION: RsDoFixedIoDescriptor 259 * 260 * PARAMETERS: Info - Parse Op and resource template offset 261 * 262 * RETURN: Completed resource node 263 * 264 * DESCRIPTION: Construct a short "FixedIO" descriptor 265 * 266 ******************************************************************************/ 267 268 ASL_RESOURCE_NODE * 269 RsDoFixedIoDescriptor ( 270 ASL_RESOURCE_INFO *Info) 271 { 272 AML_RESOURCE *Descriptor; 273 ACPI_PARSE_OBJECT *InitializerOp; 274 ACPI_PARSE_OBJECT *AddressOp = NULL; 275 ASL_RESOURCE_NODE *Rnode; 276 UINT32 CurrentByteOffset; 277 UINT32 i; 278 279 280 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 281 CurrentByteOffset = Info->CurrentByteOffset; 282 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_FIXED_IO)); 283 284 Descriptor = Rnode->Buffer; 285 Descriptor->Io.DescriptorType = ACPI_RESOURCE_NAME_FIXED_IO | 286 ASL_RDESC_FIXED_IO_SIZE; 287 288 /* Process all child initialization nodes */ 289 290 for (i = 0; InitializerOp; i++) 291 { 292 switch (i) 293 { 294 case 0: /* Base Address */ 295 296 Descriptor->FixedIo.Address = 297 (UINT16) InitializerOp->Asl.Value.Integer; 298 RsCreateWordField (InitializerOp, ACPI_RESTAG_BASEADDRESS, 299 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedIo.Address)); 300 AddressOp = InitializerOp; 301 break; 302 303 case 1: /* Length */ 304 305 Descriptor->FixedIo.AddressLength = 306 (UINT8) InitializerOp->Asl.Value.Integer; 307 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 308 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedIo.AddressLength)); 309 break; 310 311 case 2: /* Name */ 312 313 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 314 break; 315 316 default: 317 318 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 319 break; 320 } 321 322 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 323 } 324 325 /* Error checks */ 326 327 if (Descriptor->FixedIo.Address > 0x03FF) 328 { 329 AslError (ASL_WARNING, ASL_MSG_ISA_ADDRESS, AddressOp, NULL); 330 } 331 332 return (Rnode); 333 } 334 335 336 /******************************************************************************* 337 * 338 * FUNCTION: RsDoIoDescriptor 339 * 340 * PARAMETERS: Info - Parse Op and resource template offset 341 * 342 * RETURN: Completed resource node 343 * 344 * DESCRIPTION: Construct a short "IO" descriptor 345 * 346 ******************************************************************************/ 347 348 ASL_RESOURCE_NODE * 349 RsDoIoDescriptor ( 350 ASL_RESOURCE_INFO *Info) 351 { 352 AML_RESOURCE *Descriptor; 353 ACPI_PARSE_OBJECT *InitializerOp; 354 ACPI_PARSE_OBJECT *MinOp = NULL; 355 ACPI_PARSE_OBJECT *MaxOp = NULL; 356 ACPI_PARSE_OBJECT *LengthOp = NULL; 357 ACPI_PARSE_OBJECT *AlignOp = NULL; 358 ASL_RESOURCE_NODE *Rnode; 359 UINT32 CurrentByteOffset; 360 UINT32 i; 361 362 363 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 364 CurrentByteOffset = Info->CurrentByteOffset; 365 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_IO)); 366 367 Descriptor = Rnode->Buffer; 368 Descriptor->Io.DescriptorType = ACPI_RESOURCE_NAME_IO | 369 ASL_RDESC_IO_SIZE; 370 371 /* Process all child initialization nodes */ 372 373 for (i = 0; InitializerOp; i++) 374 { 375 switch (i) 376 { 377 case 0: /* Decode size */ 378 379 RsSetFlagBits (&Descriptor->Io.Flags, InitializerOp, 0, 1); 380 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 381 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Flags), 0); 382 break; 383 384 case 1: /* Min Address */ 385 386 Descriptor->Io.Minimum = 387 (UINT16) InitializerOp->Asl.Value.Integer; 388 RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR, 389 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Minimum)); 390 MinOp = InitializerOp; 391 break; 392 393 case 2: /* Max Address */ 394 395 Descriptor->Io.Maximum = 396 (UINT16) InitializerOp->Asl.Value.Integer; 397 RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR, 398 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Maximum)); 399 MaxOp = InitializerOp; 400 break; 401 402 case 3: /* Alignment */ 403 404 Descriptor->Io.Alignment = 405 (UINT8) InitializerOp->Asl.Value.Integer; 406 RsCreateByteField (InitializerOp, ACPI_RESTAG_ALIGNMENT, 407 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Alignment)); 408 AlignOp = InitializerOp; 409 break; 410 411 case 4: /* Length */ 412 413 Descriptor->Io.AddressLength = 414 (UINT8) InitializerOp->Asl.Value.Integer; 415 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 416 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.AddressLength)); 417 LengthOp = InitializerOp; 418 break; 419 420 case 5: /* Name */ 421 422 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 423 break; 424 425 default: 426 427 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 428 break; 429 } 430 431 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 432 } 433 434 /* Validate the Min/Max/Len/Align values */ 435 436 RsSmallAddressCheck (ACPI_RESOURCE_NAME_IO, 437 Descriptor->Io.Minimum, 438 Descriptor->Io.Maximum, 439 Descriptor->Io.AddressLength, 440 Descriptor->Io.Alignment, 441 MinOp, MaxOp, LengthOp, AlignOp, Info->DescriptorTypeOp); 442 443 return (Rnode); 444 } 445 446 447 /******************************************************************************* 448 * 449 * FUNCTION: RsDoIrqDescriptor 450 * 451 * PARAMETERS: Info - Parse Op and resource template offset 452 * 453 * RETURN: Completed resource node 454 * 455 * DESCRIPTION: Construct a short "IRQ" descriptor 456 * 457 ******************************************************************************/ 458 459 ASL_RESOURCE_NODE * 460 RsDoIrqDescriptor ( 461 ASL_RESOURCE_INFO *Info) 462 { 463 AML_RESOURCE *Descriptor; 464 ACPI_PARSE_OBJECT *InitializerOp; 465 ASL_RESOURCE_NODE *Rnode; 466 UINT32 Interrupts = 0; 467 UINT16 IrqMask = 0; 468 UINT32 CurrentByteOffset; 469 UINT32 i; 470 471 472 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 473 CurrentByteOffset = Info->CurrentByteOffset; 474 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_IRQ)); 475 476 /* Length = 3 (with flag byte) */ 477 478 Descriptor = Rnode->Buffer; 479 Descriptor->Irq.DescriptorType = ACPI_RESOURCE_NAME_IRQ | 480 (ASL_RDESC_IRQ_SIZE + 0x01); 481 482 /* Process all child initialization nodes */ 483 484 for (i = 0; InitializerOp; i++) 485 { 486 switch (i) 487 { 488 case 0: /* Interrupt Type (or Mode - edge/level) */ 489 490 RsSetFlagBits (&Descriptor->Irq.Flags, InitializerOp, 0, 1); 491 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTTYPE, 492 CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.Flags), 0); 493 break; 494 495 case 1: /* Interrupt Level (or Polarity - Active high/low) */ 496 497 RsSetFlagBits (&Descriptor->Irq.Flags, InitializerOp, 3, 0); 498 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTLEVEL, 499 CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.Flags), 3); 500 break; 501 502 case 2: /* Share Type - Default: exclusive (0) */ 503 504 RsSetFlagBits (&Descriptor->Irq.Flags, InitializerOp, 4, 0); 505 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE, 506 CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.Flags), 4); 507 break; 508 509 case 3: /* Name */ 510 511 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 512 break; 513 514 default: 515 516 /* All IRQ bytes are handled here, after the flags and name */ 517 518 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 519 { 520 /* Up to 16 interrupts can be specified in the list */ 521 522 Interrupts++; 523 if (Interrupts > 16) 524 { 525 AslError (ASL_ERROR, ASL_MSG_INTERRUPT_LIST, 526 InitializerOp, NULL); 527 return (Rnode); 528 } 529 530 /* Only interrupts 0-15 are allowed (mask is 16 bits) */ 531 532 if (InitializerOp->Asl.Value.Integer > 15) 533 { 534 AslError (ASL_ERROR, ASL_MSG_INTERRUPT_NUMBER, 535 InitializerOp, NULL); 536 } 537 else 538 { 539 IrqMask |= (1 << (UINT8) InitializerOp->Asl.Value.Integer); 540 } 541 } 542 543 /* Case 4: First IRQ value in list */ 544 545 if (i == 4) 546 { 547 /* Check now for duplicates in list */ 548 549 RsCheckListForDuplicates (InitializerOp); 550 551 /* Create a named field at the start of the list */ 552 553 RsCreateWordField (InitializerOp, ACPI_RESTAG_INTERRUPT, 554 CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.IrqMask)); 555 } 556 break; 557 } 558 559 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 560 } 561 562 /* Now we can set the channel mask */ 563 564 Descriptor->Irq.IrqMask = IrqMask; 565 return (Rnode); 566 } 567 568 569 /******************************************************************************* 570 * 571 * FUNCTION: RsDoIrqNoFlagsDescriptor 572 * 573 * PARAMETERS: Info - Parse Op and resource template offset 574 * 575 * RETURN: Completed resource node 576 * 577 * DESCRIPTION: Construct a short "IRQNoFlags" descriptor 578 * 579 ******************************************************************************/ 580 581 ASL_RESOURCE_NODE * 582 RsDoIrqNoFlagsDescriptor ( 583 ASL_RESOURCE_INFO *Info) 584 { 585 AML_RESOURCE *Descriptor; 586 ACPI_PARSE_OBJECT *InitializerOp; 587 ASL_RESOURCE_NODE *Rnode; 588 UINT16 IrqMask = 0; 589 UINT32 Interrupts = 0; 590 UINT32 CurrentByteOffset; 591 UINT32 i; 592 593 594 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 595 CurrentByteOffset = Info->CurrentByteOffset; 596 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_IRQ_NOFLAGS)); 597 598 Descriptor = Rnode->Buffer; 599 Descriptor->Irq.DescriptorType = ACPI_RESOURCE_NAME_IRQ | 600 ASL_RDESC_IRQ_SIZE; 601 602 /* Process all child initialization nodes */ 603 604 for (i = 0; InitializerOp; i++) 605 { 606 switch (i) 607 { 608 case 0: /* Name */ 609 610 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 611 break; 612 613 default: 614 615 /* IRQ bytes are handled here, after the flags and name */ 616 617 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 618 { 619 /* Up to 16 interrupts can be specified in the list */ 620 621 Interrupts++; 622 if (Interrupts > 16) 623 { 624 AslError (ASL_ERROR, ASL_MSG_INTERRUPT_LIST, 625 InitializerOp, NULL); 626 return (Rnode); 627 } 628 629 /* Only interrupts 0-15 are allowed (mask is 16 bits) */ 630 631 if (InitializerOp->Asl.Value.Integer > 15) 632 { 633 AslError (ASL_ERROR, ASL_MSG_INTERRUPT_NUMBER, 634 InitializerOp, NULL); 635 } 636 else 637 { 638 IrqMask |= (1 << ((UINT8) InitializerOp->Asl.Value.Integer)); 639 } 640 } 641 642 /* Case 1: First IRQ value in list */ 643 644 if (i == 1) 645 { 646 /* Check now for duplicates in list */ 647 648 RsCheckListForDuplicates (InitializerOp); 649 650 /* Create a named field at the start of the list */ 651 652 RsCreateWordField (InitializerOp, ACPI_RESTAG_INTERRUPT, 653 CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.IrqMask)); 654 } 655 break; 656 } 657 658 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 659 } 660 661 /* Now we can set the interrupt mask */ 662 663 Descriptor->Irq.IrqMask = IrqMask; 664 return (Rnode); 665 } 666