1 /******************************************************************************
2 *
3 * Module Name: aslrestype1i - Small I/O-related resource descriptors
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2023, 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 MERCHANTABILITY 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 *
RsDoDmaDescriptor(ASL_RESOURCE_INFO * Info)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 =
92 ACPI_RESOURCE_NAME_DMA | 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 *
RsDoFixedDmaDescriptor(ASL_RESOURCE_INFO * Info)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 *
RsDoFixedIoDescriptor(ASL_RESOURCE_INFO * Info)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 =
286 ACPI_RESOURCE_NAME_FIXED_IO | 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 *
RsDoIoDescriptor(ASL_RESOURCE_INFO * Info)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 =
369 ACPI_RESOURCE_NAME_IO | 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 *
RsDoIrqDescriptor(ASL_RESOURCE_INFO * Info)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 =
480 ACPI_RESOURCE_NAME_IRQ | (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 *
RsDoIrqNoFlagsDescriptor(ASL_RESOURCE_INFO * Info)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 =
600 ACPI_RESOURCE_NAME_IRQ | 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