Subversion Repositories Kolibri OS

Rev

Rev 1498 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1498 serge 1
/*******************************************************************************
2
 *
3
 * Module Name: rsutils - Utilities for the resource manager
4
 *
5
 ******************************************************************************/
6
 
7
/******************************************************************************
8
 *
9
 * 1. Copyright Notice
10
 *
2216 Serge 11
 * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
1498 serge 12
 * All rights reserved.
13
 *
14
 * 2. License
15
 *
16
 * 2.1. This is your license from Intel Corp. under its intellectual property
17
 * rights.  You may have additional license terms from the party that provided
18
 * you this software, covering your right to use that party's intellectual
19
 * property rights.
20
 *
21
 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22
 * copy of the source code appearing in this file ("Covered Code") an
23
 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24
 * base code distributed originally by Intel ("Original Intel Code") to copy,
25
 * make derivatives, distribute, use and display any portion of the Covered
26
 * Code in any form, with the right to sublicense such rights; and
27
 *
28
 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29
 * license (with the right to sublicense), under only those claims of Intel
30
 * patents that are infringed by the Original Intel Code, to make, use, sell,
31
 * offer to sell, and import the Covered Code and derivative works thereof
32
 * solely to the minimum extent necessary to exercise the above copyright
33
 * license, and in no event shall the patent license extend to any additions
34
 * to or modifications of the Original Intel Code.  No other license or right
35
 * is granted directly or by implication, estoppel or otherwise;
36
 *
37
 * The above copyright and patent license is granted only if the following
38
 * conditions are met:
39
 *
40
 * 3. Conditions
41
 *
42
 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43
 * Redistribution of source code of any substantial portion of the Covered
44
 * Code or modification with rights to further distribute source must include
45
 * the above Copyright Notice, the above License, this list of Conditions,
46
 * and the following Disclaimer and Export Compliance provision.  In addition,
47
 * Licensee must cause all Covered Code to which Licensee contributes to
48
 * contain a file documenting the changes Licensee made to create that Covered
49
 * Code and the date of any change.  Licensee must include in that file the
50
 * documentation of any changes made by any predecessor Licensee.  Licensee
51
 * must include a prominent statement that the modification is derived,
52
 * directly or indirectly, from Original Intel Code.
53
 *
54
 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55
 * Redistribution of source code of any substantial portion of the Covered
56
 * Code or modification without rights to further distribute source must
57
 * include the following Disclaimer and Export Compliance provision in the
58
 * documentation and/or other materials provided with distribution.  In
59
 * addition, Licensee may not authorize further sublicense of source of any
60
 * portion of the Covered Code, and must include terms to the effect that the
61
 * license from Licensee to its licensee is limited to the intellectual
62
 * property embodied in the software Licensee provides to its licensee, and
63
 * not to intellectual property embodied in modifications its licensee may
64
 * make.
65
 *
66
 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67
 * substantial portion of the Covered Code or modification must reproduce the
68
 * above Copyright Notice, and the following Disclaimer and Export Compliance
69
 * provision in the documentation and/or other materials provided with the
70
 * distribution.
71
 *
72
 * 3.4. Intel retains all right, title, and interest in and to the Original
73
 * Intel Code.
74
 *
75
 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76
 * Intel shall be used in advertising or otherwise to promote the sale, use or
77
 * other dealings in products derived from or relating to the Covered Code
78
 * without prior written authorization from Intel.
79
 *
80
 * 4. Disclaimer and Export Compliance
81
 *
82
 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83
 * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84
 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
85
 * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
86
 * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
87
 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88
 * PARTICULAR PURPOSE.
89
 *
90
 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91
 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92
 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93
 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94
 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95
 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
96
 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97
 * LIMITED REMEDY.
98
 *
99
 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100
 * software or system incorporating such software without first obtaining any
101
 * required license or other approval from the U. S. Department of Commerce or
102
 * any other agency or department of the United States Government.  In the
103
 * event Licensee exports any such software from the United States or
104
 * re-exports any such software from a foreign destination, Licensee shall
105
 * ensure that the distribution and export/re-export of the software is in
106
 * compliance with all laws, regulations, orders, or other restrictions of the
107
 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108
 * any of its subsidiaries will export/re-export any technical data, process,
109
 * software, or service, directly or indirectly, to any country for which the
110
 * United States government or any agency thereof requires an export license,
111
 * other governmental approval, or letter of assurance, without first obtaining
112
 * such license, approval or letter.
113
 *
114
 *****************************************************************************/
115
 
116
 
117
#define __RSUTILS_C__
118
 
119
#include "acpi.h"
120
#include "accommon.h"
121
#include "acnamesp.h"
122
#include "acresrc.h"
123
 
124
 
125
#define _COMPONENT          ACPI_RESOURCES
126
        ACPI_MODULE_NAME    ("rsutils")
127
 
128
 
129
/*******************************************************************************
130
 *
131
 * FUNCTION:    AcpiRsDecodeBitmask
132
 *
133
 * PARAMETERS:  Mask            - Bitmask to decode
134
 *              List            - Where the converted list is returned
135
 *
136
 * RETURN:      Count of bits set (length of list)
137
 *
138
 * DESCRIPTION: Convert a bit mask into a list of values
139
 *
140
 ******************************************************************************/
141
 
142
UINT8
143
AcpiRsDecodeBitmask (
144
    UINT16                  Mask,
145
    UINT8                   *List)
146
{
147
    UINT8                   i;
148
    UINT8                   BitCount;
149
 
150
 
151
    ACPI_FUNCTION_ENTRY ();
152
 
153
 
154
    /* Decode the mask bits */
155
 
156
    for (i = 0, BitCount = 0; Mask; i++)
157
    {
158
        if (Mask & 0x0001)
159
        {
160
            List[BitCount] = i;
161
            BitCount++;
162
        }
163
 
164
        Mask >>= 1;
165
    }
166
 
167
    return (BitCount);
168
}
169
 
170
 
171
/*******************************************************************************
172
 *
173
 * FUNCTION:    AcpiRsEncodeBitmask
174
 *
175
 * PARAMETERS:  List            - List of values to encode
176
 *              Count           - Length of list
177
 *
178
 * RETURN:      Encoded bitmask
179
 *
180
 * DESCRIPTION: Convert a list of values to an encoded bitmask
181
 *
182
 ******************************************************************************/
183
 
184
UINT16
185
AcpiRsEncodeBitmask (
186
    UINT8                   *List,
187
    UINT8                   Count)
188
{
189
    UINT32                  i;
190
    UINT16                  Mask;
191
 
192
 
193
    ACPI_FUNCTION_ENTRY ();
194
 
195
 
196
    /* Encode the list into a single bitmask */
197
 
198
    for (i = 0, Mask = 0; i < Count; i++)
199
    {
200
        Mask |= (0x1 << List[i]);
201
    }
202
 
203
    return (Mask);
204
}
205
 
206
 
207
/*******************************************************************************
208
 *
209
 * FUNCTION:    AcpiRsMoveData
210
 *
211
 * PARAMETERS:  Destination         - Pointer to the destination descriptor
212
 *              Source              - Pointer to the source descriptor
213
 *              ItemCount           - How many items to move
214
 *              MoveType            - Byte width
215
 *
216
 * RETURN:      None
217
 *
218
 * DESCRIPTION: Move multiple data items from one descriptor to another. Handles
219
 *              alignment issues and endian issues if necessary, as configured
220
 *              via the ACPI_MOVE_* macros. (This is why a memcpy is not used)
221
 *
222
 ******************************************************************************/
223
 
224
void
225
AcpiRsMoveData (
226
    void                    *Destination,
227
    void                    *Source,
228
    UINT16                  ItemCount,
229
    UINT8                   MoveType)
230
{
231
    UINT32                  i;
232
 
233
 
234
    ACPI_FUNCTION_ENTRY ();
235
 
236
 
237
    /* One move per item */
238
 
239
    for (i = 0; i < ItemCount; i++)
240
    {
241
        switch (MoveType)
242
        {
243
        /*
244
         * For the 8-bit case, we can perform the move all at once
245
         * since there are no alignment or endian issues
246
         */
247
        case ACPI_RSC_MOVE8:
248
            ACPI_MEMCPY (Destination, Source, ItemCount);
249
            return;
250
 
251
        /*
252
         * 16-, 32-, and 64-bit cases must use the move macros that perform
253
         * endian conversion and/or accomodate hardware that cannot perform
254
         * misaligned memory transfers
255
         */
256
        case ACPI_RSC_MOVE16:
257
            ACPI_MOVE_16_TO_16 (&ACPI_CAST_PTR (UINT16, Destination)[i],
258
                                &ACPI_CAST_PTR (UINT16, Source)[i]);
259
            break;
260
 
261
        case ACPI_RSC_MOVE32:
262
            ACPI_MOVE_32_TO_32 (&ACPI_CAST_PTR (UINT32, Destination)[i],
263
                                &ACPI_CAST_PTR (UINT32, Source)[i]);
264
            break;
265
 
266
        case ACPI_RSC_MOVE64:
267
            ACPI_MOVE_64_TO_64 (&ACPI_CAST_PTR (UINT64, Destination)[i],
268
                                &ACPI_CAST_PTR (UINT64, Source)[i]);
269
            break;
270
 
271
        default:
272
            return;
273
        }
274
    }
275
}
276
 
277
 
278
/*******************************************************************************
279
 *
280
 * FUNCTION:    AcpiRsSetResourceLength
281
 *
282
 * PARAMETERS:  TotalLength         - Length of the AML descriptor, including
283
 *                                    the header and length fields.
284
 *              Aml                 - Pointer to the raw AML descriptor
285
 *
286
 * RETURN:      None
287
 *
288
 * DESCRIPTION: Set the ResourceLength field of an AML
289
 *              resource descriptor, both Large and Small descriptors are
290
 *              supported automatically. Note: Descriptor Type field must
291
 *              be valid.
292
 *
293
 ******************************************************************************/
294
 
295
void
296
AcpiRsSetResourceLength (
297
    ACPI_RSDESC_SIZE        TotalLength,
298
    AML_RESOURCE            *Aml)
299
{
300
    ACPI_RS_LENGTH          ResourceLength;
301
 
302
 
303
    ACPI_FUNCTION_ENTRY ();
304
 
305
 
306
    /* Length is the total descriptor length minus the header length */
307
 
308
    ResourceLength = (ACPI_RS_LENGTH)
309
        (TotalLength - AcpiUtGetResourceHeaderLength (Aml));
310
 
311
    /* Length is stored differently for large and small descriptors */
312
 
313
    if (Aml->SmallHeader.DescriptorType & ACPI_RESOURCE_NAME_LARGE)
314
    {
315
        /* Large descriptor -- bytes 1-2 contain the 16-bit length */
316
 
317
        ACPI_MOVE_16_TO_16 (&Aml->LargeHeader.ResourceLength, &ResourceLength);
318
    }
319
    else
320
    {
321
        /* Small descriptor -- bits 2:0 of byte 0 contain the length */
322
 
323
        Aml->SmallHeader.DescriptorType = (UINT8)
324
 
325
            /* Clear any existing length, preserving descriptor type bits */
326
 
327
            ((Aml->SmallHeader.DescriptorType & ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK)
328
 
329
            | ResourceLength);
330
    }
331
}
332
 
333
 
334
/*******************************************************************************
335
 *
336
 * FUNCTION:    AcpiRsSetResourceHeader
337
 *
338
 * PARAMETERS:  DescriptorType      - Byte to be inserted as the type
339
 *              TotalLength         - Length of the AML descriptor, including
340
 *                                    the header and length fields.
341
 *              Aml                 - Pointer to the raw AML descriptor
342
 *
343
 * RETURN:      None
344
 *
345
 * DESCRIPTION: Set the DescriptorType and ResourceLength fields of an AML
346
 *              resource descriptor, both Large and Small descriptors are
347
 *              supported automatically
348
 *
349
 ******************************************************************************/
350
 
351
void
352
AcpiRsSetResourceHeader (
353
    UINT8                   DescriptorType,
354
    ACPI_RSDESC_SIZE        TotalLength,
355
    AML_RESOURCE            *Aml)
356
{
357
    ACPI_FUNCTION_ENTRY ();
358
 
359
 
360
    /* Set the Resource Type */
361
 
362
    Aml->SmallHeader.DescriptorType = DescriptorType;
363
 
364
    /* Set the Resource Length */
365
 
366
    AcpiRsSetResourceLength (TotalLength, Aml);
367
}
368
 
369
 
370
/*******************************************************************************
371
 *
372
 * FUNCTION:    AcpiRsStrcpy
373
 *
374
 * PARAMETERS:  Destination         - Pointer to the destination string
375
 *              Source              - Pointer to the source string
376
 *
377
 * RETURN:      String length, including NULL terminator
378
 *
379
 * DESCRIPTION: Local string copy that returns the string length, saving a
380
 *              strcpy followed by a strlen.
381
 *
382
 ******************************************************************************/
383
 
384
static UINT16
385
AcpiRsStrcpy (
386
    char                    *Destination,
387
    char                    *Source)
388
{
389
    UINT16                  i;
390
 
391
 
392
    ACPI_FUNCTION_ENTRY ();
393
 
394
 
395
    for (i = 0; Source[i]; i++)
396
    {
397
        Destination[i] = Source[i];
398
    }
399
 
400
    Destination[i] = 0;
401
 
402
    /* Return string length including the NULL terminator */
403
 
404
    return ((UINT16) (i + 1));
405
}
406
 
407
 
408
/*******************************************************************************
409
 *
410
 * FUNCTION:    AcpiRsGetResourceSource
411
 *
412
 * PARAMETERS:  ResourceLength      - Length field of the descriptor
413
 *              MinimumLength       - Minimum length of the descriptor (minus
414
 *                                    any optional fields)
415
 *              ResourceSource      - Where the ResourceSource is returned
416
 *              Aml                 - Pointer to the raw AML descriptor
417
 *              StringPtr           - (optional) where to store the actual
418
 *                                    ResourceSource string
419
 *
420
 * RETURN:      Length of the string plus NULL terminator, rounded up to native
421
 *              word boundary
422
 *
423
 * DESCRIPTION: Copy the optional ResourceSource data from a raw AML descriptor
424
 *              to an internal resource descriptor
425
 *
426
 ******************************************************************************/
427
 
428
ACPI_RS_LENGTH
429
AcpiRsGetResourceSource (
430
    ACPI_RS_LENGTH          ResourceLength,
431
    ACPI_RS_LENGTH          MinimumLength,
432
    ACPI_RESOURCE_SOURCE    *ResourceSource,
433
    AML_RESOURCE            *Aml,
434
    char                    *StringPtr)
435
{
436
    ACPI_RSDESC_SIZE        TotalLength;
437
    UINT8                   *AmlResourceSource;
438
 
439
 
440
    ACPI_FUNCTION_ENTRY ();
441
 
442
 
443
    TotalLength = ResourceLength + sizeof (AML_RESOURCE_LARGE_HEADER);
444
    AmlResourceSource = ACPI_ADD_PTR (UINT8, Aml, MinimumLength);
445
 
446
    /*
447
     * ResourceSource is present if the length of the descriptor is longer than
448
     * the minimum length.
449
     *
450
     * Note: Some resource descriptors will have an additional null, so
451
     * we add 1 to the minimum length.
452
     */
453
    if (TotalLength > (ACPI_RSDESC_SIZE) (MinimumLength + 1))
454
    {
455
        /* Get the ResourceSourceIndex */
456
 
457
        ResourceSource->Index = AmlResourceSource[0];
458
 
459
        ResourceSource->StringPtr = StringPtr;
460
        if (!StringPtr)
461
        {
462
            /*
463
             * String destination pointer is not specified; Set the String
464
             * pointer to the end of the current ResourceSource structure.
465
             */
466
            ResourceSource->StringPtr = ACPI_ADD_PTR (char, ResourceSource,
467
                sizeof (ACPI_RESOURCE_SOURCE));
468
        }
469
 
470
        /*
471
         * In order for the Resource length to be a multiple of the native
472
         * word, calculate the length of the string (+1 for NULL terminator)
473
         * and expand to the next word multiple.
474
         *
475
         * Zero the entire area of the buffer.
476
         */
477
        TotalLength = (UINT32) ACPI_STRLEN (
478
            ACPI_CAST_PTR (char, &AmlResourceSource[1])) + 1;
479
        TotalLength = (UINT32) ACPI_ROUND_UP_TO_NATIVE_WORD (TotalLength);
480
 
481
        ACPI_MEMSET (ResourceSource->StringPtr, 0, TotalLength);
482
 
483
        /* Copy the ResourceSource string to the destination */
484
 
485
        ResourceSource->StringLength = AcpiRsStrcpy (ResourceSource->StringPtr,
486
            ACPI_CAST_PTR (char, &AmlResourceSource[1]));
487
 
488
        return ((ACPI_RS_LENGTH) TotalLength);
489
    }
490
 
491
    /* ResourceSource is not present */
492
 
493
    ResourceSource->Index = 0;
494
    ResourceSource->StringLength = 0;
495
    ResourceSource->StringPtr = NULL;
496
    return (0);
497
}
498
 
499
 
500
/*******************************************************************************
501
 *
502
 * FUNCTION:    AcpiRsSetResourceSource
503
 *
504
 * PARAMETERS:  Aml                 - Pointer to the raw AML descriptor
505
 *              MinimumLength       - Minimum length of the descriptor (minus
506
 *                                    any optional fields)
507
 *              ResourceSource      - Internal ResourceSource
508
 
509
 *
510
 * RETURN:      Total length of the AML descriptor
511
 *
512
 * DESCRIPTION: Convert an optional ResourceSource from internal format to a
513
 *              raw AML resource descriptor
514
 *
515
 ******************************************************************************/
516
 
517
ACPI_RSDESC_SIZE
518
AcpiRsSetResourceSource (
519
    AML_RESOURCE            *Aml,
520
    ACPI_RS_LENGTH          MinimumLength,
521
    ACPI_RESOURCE_SOURCE    *ResourceSource)
522
{
523
    UINT8                   *AmlResourceSource;
524
    ACPI_RSDESC_SIZE        DescriptorLength;
525
 
526
 
527
    ACPI_FUNCTION_ENTRY ();
528
 
529
 
530
    DescriptorLength = MinimumLength;
531
 
532
    /* Non-zero string length indicates presence of a ResourceSource */
533
 
534
    if (ResourceSource->StringLength)
535
    {
536
        /* Point to the end of the AML descriptor */
537
 
538
        AmlResourceSource = ACPI_ADD_PTR (UINT8, Aml, MinimumLength);
539
 
540
        /* Copy the ResourceSourceIndex */
541
 
542
        AmlResourceSource[0] = (UINT8) ResourceSource->Index;
543
 
544
        /* Copy the ResourceSource string */
545
 
546
        ACPI_STRCPY (ACPI_CAST_PTR (char, &AmlResourceSource[1]),
547
            ResourceSource->StringPtr);
548
 
549
        /*
550
         * Add the length of the string (+ 1 for null terminator) to the
551
         * final descriptor length
552
         */
553
        DescriptorLength += ((ACPI_RSDESC_SIZE) ResourceSource->StringLength + 1);
554
    }
555
 
556
    /* Return the new total length of the AML descriptor */
557
 
558
    return (DescriptorLength);
559
}
560
 
561
 
562
/*******************************************************************************
563
 *
564
 * FUNCTION:    AcpiRsGetPrtMethodData
565
 *
566
 * PARAMETERS:  Node            - Device node
567
 *              RetBuffer       - Pointer to a buffer structure for the
568
 *                                results
569
 *
570
 * RETURN:      Status
571
 *
572
 * DESCRIPTION: This function is called to get the _PRT value of an object
573
 *              contained in an object specified by the handle passed in
574
 *
575
 *              If the function fails an appropriate status will be returned
576
 *              and the contents of the callers buffer is undefined.
577
 *
578
 ******************************************************************************/
579
 
580
ACPI_STATUS
581
AcpiRsGetPrtMethodData (
582
    ACPI_NAMESPACE_NODE     *Node,
583
    ACPI_BUFFER             *RetBuffer)
584
{
585
    ACPI_OPERAND_OBJECT     *ObjDesc;
586
    ACPI_STATUS             Status;
587
 
588
 
589
    ACPI_FUNCTION_TRACE (RsGetPrtMethodData);
590
 
591
 
592
    /* Parameters guaranteed valid by caller */
593
 
594
    /* Execute the method, no parameters */
595
 
596
    Status = AcpiUtEvaluateObject (Node, METHOD_NAME__PRT,
597
                ACPI_BTYPE_PACKAGE, &ObjDesc);
598
    if (ACPI_FAILURE (Status))
599
    {
600
        return_ACPI_STATUS (Status);
601
    }
602
 
603
    /*
604
     * Create a resource linked list from the byte stream buffer that comes
605
     * back from the _CRS method execution.
606
     */
607
    Status = AcpiRsCreatePciRoutingTable (ObjDesc, RetBuffer);
608
 
609
    /* On exit, we must delete the object returned by EvaluateObject */
610
 
611
    AcpiUtRemoveReference (ObjDesc);
612
    return_ACPI_STATUS (Status);
613
}
614
 
615
 
616
/*******************************************************************************
617
 *
618
 * FUNCTION:    AcpiRsGetCrsMethodData
619
 *
620
 * PARAMETERS:  Node            - Device node
621
 *              RetBuffer       - Pointer to a buffer structure for the
622
 *                                results
623
 *
624
 * RETURN:      Status
625
 *
626
 * DESCRIPTION: This function is called to get the _CRS value of an object
627
 *              contained in an object specified by the handle passed in
628
 *
629
 *              If the function fails an appropriate status will be returned
630
 *              and the contents of the callers buffer is undefined.
631
 *
632
 ******************************************************************************/
633
 
634
ACPI_STATUS
635
AcpiRsGetCrsMethodData (
636
    ACPI_NAMESPACE_NODE     *Node,
637
    ACPI_BUFFER             *RetBuffer)
638
{
639
    ACPI_OPERAND_OBJECT     *ObjDesc;
640
    ACPI_STATUS             Status;
641
 
642
 
643
    ACPI_FUNCTION_TRACE (RsGetCrsMethodData);
644
 
645
 
646
    /* Parameters guaranteed valid by caller */
647
 
648
    /* Execute the method, no parameters */
649
 
650
    Status = AcpiUtEvaluateObject (Node, METHOD_NAME__CRS,
651
                ACPI_BTYPE_BUFFER, &ObjDesc);
652
    if (ACPI_FAILURE (Status))
653
    {
654
        return_ACPI_STATUS (Status);
655
    }
656
 
657
    /*
658
     * Make the call to create a resource linked list from the
659
     * byte stream buffer that comes back from the _CRS method
660
     * execution.
661
     */
662
    Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
663
 
664
    /* On exit, we must delete the object returned by evaluateObject */
665
 
666
    AcpiUtRemoveReference (ObjDesc);
667
    return_ACPI_STATUS (Status);
668
}
669
 
670
 
671
/*******************************************************************************
672
 *
673
 * FUNCTION:    AcpiRsGetPrsMethodData
674
 *
675
 * PARAMETERS:  Node            - Device node
676
 *              RetBuffer       - Pointer to a buffer structure for the
677
 *                                results
678
 *
679
 * RETURN:      Status
680
 *
681
 * DESCRIPTION: This function is called to get the _PRS value of an object
682
 *              contained in an object specified by the handle passed in
683
 *
684
 *              If the function fails an appropriate status will be returned
685
 *              and the contents of the callers buffer is undefined.
686
 *
687
 ******************************************************************************/
688
 
689
ACPI_STATUS
690
AcpiRsGetPrsMethodData (
691
    ACPI_NAMESPACE_NODE     *Node,
692
    ACPI_BUFFER             *RetBuffer)
693
{
694
    ACPI_OPERAND_OBJECT     *ObjDesc;
695
    ACPI_STATUS             Status;
696
 
697
 
698
    ACPI_FUNCTION_TRACE (RsGetPrsMethodData);
699
 
700
 
701
    /* Parameters guaranteed valid by caller */
702
 
703
    /* Execute the method, no parameters */
704
 
705
    Status = AcpiUtEvaluateObject (Node, METHOD_NAME__PRS,
706
                ACPI_BTYPE_BUFFER, &ObjDesc);
707
    if (ACPI_FAILURE (Status))
708
    {
709
        return_ACPI_STATUS (Status);
710
    }
711
 
712
    /*
713
     * Make the call to create a resource linked list from the
714
     * byte stream buffer that comes back from the _CRS method
715
     * execution.
716
     */
717
    Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
718
 
719
    /* On exit, we must delete the object returned by evaluateObject */
720
 
721
    AcpiUtRemoveReference (ObjDesc);
722
    return_ACPI_STATUS (Status);
723
}
724
 
725
 
726
/*******************************************************************************
727
 *
728
 * FUNCTION:    AcpiRsGetMethodData
729
 *
730
 * PARAMETERS:  Handle          - Handle to the containing object
731
 *              Path            - Path to method, relative to Handle
732
 *              RetBuffer       - Pointer to a buffer structure for the
733
 *                                results
734
 *
735
 * RETURN:      Status
736
 *
737
 * DESCRIPTION: This function is called to get the _CRS or _PRS value of an
738
 *              object contained in an object specified by the handle passed in
739
 *
740
 *              If the function fails an appropriate status will be returned
741
 *              and the contents of the callers buffer is undefined.
742
 *
743
 ******************************************************************************/
744
 
745
ACPI_STATUS
746
AcpiRsGetMethodData (
747
    ACPI_HANDLE             Handle,
748
    char                    *Path,
749
    ACPI_BUFFER             *RetBuffer)
750
{
751
    ACPI_OPERAND_OBJECT     *ObjDesc;
752
    ACPI_STATUS             Status;
753
 
754
 
755
    ACPI_FUNCTION_TRACE (RsGetMethodData);
756
 
757
 
758
    /* Parameters guaranteed valid by caller */
759
 
760
    /* Execute the method, no parameters */
761
 
762
    Status = AcpiUtEvaluateObject (Handle, Path, ACPI_BTYPE_BUFFER, &ObjDesc);
763
    if (ACPI_FAILURE (Status))
764
    {
765
        return_ACPI_STATUS (Status);
766
    }
767
 
768
    /*
769
     * Make the call to create a resource linked list from the
770
     * byte stream buffer that comes back from the method
771
     * execution.
772
     */
773
    Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
774
 
775
    /* On exit, we must delete the object returned by EvaluateObject */
776
 
777
    AcpiUtRemoveReference (ObjDesc);
778
    return_ACPI_STATUS (Status);
779
}
780
 
781
 
782
/*******************************************************************************
783
 *
784
 * FUNCTION:    AcpiRsSetSrsMethodData
785
 *
786
 * PARAMETERS:  Node            - Device node
787
 *              InBuffer        - Pointer to a buffer structure of the
788
 *                                parameter
789
 *
790
 * RETURN:      Status
791
 *
792
 * DESCRIPTION: This function is called to set the _SRS of an object contained
793
 *              in an object specified by the handle passed in
794
 *
795
 *              If the function fails an appropriate status will be returned
796
 *              and the contents of the callers buffer is undefined.
797
 *
798
 * Note: Parameters guaranteed valid by caller
799
 *
800
 ******************************************************************************/
801
 
802
ACPI_STATUS
803
AcpiRsSetSrsMethodData (
804
    ACPI_NAMESPACE_NODE     *Node,
805
    ACPI_BUFFER             *InBuffer)
806
{
807
    ACPI_EVALUATE_INFO      *Info;
808
    ACPI_OPERAND_OBJECT     *Args[2];
809
    ACPI_STATUS             Status;
810
    ACPI_BUFFER             Buffer;
811
 
812
 
813
    ACPI_FUNCTION_TRACE (RsSetSrsMethodData);
814
 
815
 
816
    /* Allocate and initialize the evaluation information block */
817
 
818
    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
819
    if (!Info)
820
    {
821
        return_ACPI_STATUS (AE_NO_MEMORY);
822
    }
823
 
824
    Info->PrefixNode = Node;
825
    Info->Pathname = METHOD_NAME__SRS;
826
    Info->Parameters = Args;
827
    Info->Flags = ACPI_IGNORE_RETURN_VALUE;
828
 
829
    /*
830
     * The InBuffer parameter will point to a linked list of
831
     * resource parameters. It needs to be formatted into a
832
     * byte stream to be sent in as an input parameter to _SRS
833
     *
834
     * Convert the linked list into a byte stream
835
     */
836
    Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
837
    Status = AcpiRsCreateAmlResources (InBuffer->Pointer, &Buffer);
838
    if (ACPI_FAILURE (Status))
839
    {
840
        goto Cleanup;
841
    }
842
 
843
    /* Create and initialize the method parameter object */
844
 
845
    Args[0] = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER);
846
    if (!Args[0])
847
    {
848
        /*
849
         * Must free the buffer allocated above (otherwise it is freed
850
         * later)
851
         */
852
        ACPI_FREE (Buffer.Pointer);
853
        Status = AE_NO_MEMORY;
854
        goto Cleanup;
855
    }
856
 
857
    Args[0]->Buffer.Length  = (UINT32) Buffer.Length;
858
    Args[0]->Buffer.Pointer = Buffer.Pointer;
859
    Args[0]->Common.Flags   = AOPOBJ_DATA_VALID;
860
    Args[1] = NULL;
861
 
862
    /* Execute the method, no return value is expected */
863
 
864
    Status = AcpiNsEvaluate (Info);
865
 
866
    /* Clean up and return the status from AcpiNsEvaluate */
867
 
868
    AcpiUtRemoveReference (Args[0]);
869
 
870
Cleanup:
871
    ACPI_FREE (Info);
872
    return_ACPI_STATUS (Status);
873
}
874