sys/contrib/dev/acpica/source/compiler/aslrestype1i.c

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