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: rsaddr - Address resource descriptors (16/32/64)
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
#define __RSADDR_C__
117
 
118
#include "acpi.h"
119
#include "accommon.h"
120
#include "acresrc.h"
121
 
122
#define _COMPONENT          ACPI_RESOURCES
123
        ACPI_MODULE_NAME    ("rsaddr")
124
 
125
 
126
/*******************************************************************************
127
 *
128
 * AcpiRsConvertAddress16 - All WORD (16-bit) address resources
129
 *
130
 ******************************************************************************/
131
 
132
ACPI_RSCONVERT_INFO     AcpiRsConvertAddress16[5] =
133
{
134
    {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_ADDRESS16,
135
                        ACPI_RS_SIZE (ACPI_RESOURCE_ADDRESS16),
136
                        ACPI_RSC_TABLE_SIZE (AcpiRsConvertAddress16)},
137
 
138
    {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_ADDRESS16,
139
                        sizeof (AML_RESOURCE_ADDRESS16),
140
                        0},
141
 
142
    /* Resource Type, General Flags, and Type-Specific Flags */
143
 
144
    {ACPI_RSC_ADDRESS,  0, 0, 0},
145
 
146
    /*
147
     * These fields are contiguous in both the source and destination:
148
     * Address Granularity
149
     * Address Range Minimum
150
     * Address Range Maximum
151
     * Address Translation Offset
152
     * Address Length
153
     */
154
    {ACPI_RSC_MOVE16,   ACPI_RS_OFFSET (Data.Address16.Granularity),
155
                        AML_OFFSET (Address16.Granularity),
156
                        5},
157
 
158
    /* Optional ResourceSource (Index and String) */
159
 
160
    {ACPI_RSC_SOURCE,   ACPI_RS_OFFSET (Data.Address16.ResourceSource),
161
                        0,
162
                        sizeof (AML_RESOURCE_ADDRESS16)}
163
};
164
 
165
 
166
/*******************************************************************************
167
 *
168
 * AcpiRsConvertAddress32 - All DWORD (32-bit) address resources
169
 *
170
 ******************************************************************************/
171
 
172
ACPI_RSCONVERT_INFO     AcpiRsConvertAddress32[5] =
173
{
174
    {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_ADDRESS32,
175
                        ACPI_RS_SIZE (ACPI_RESOURCE_ADDRESS32),
176
                        ACPI_RSC_TABLE_SIZE (AcpiRsConvertAddress32)},
177
 
178
    {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_ADDRESS32,
179
                        sizeof (AML_RESOURCE_ADDRESS32),
180
                        0},
181
 
182
    /* Resource Type, General Flags, and Type-Specific Flags */
183
 
184
    {ACPI_RSC_ADDRESS,  0, 0, 0},
185
 
186
    /*
187
     * These fields are contiguous in both the source and destination:
188
     * Address Granularity
189
     * Address Range Minimum
190
     * Address Range Maximum
191
     * Address Translation Offset
192
     * Address Length
193
     */
194
    {ACPI_RSC_MOVE32,   ACPI_RS_OFFSET (Data.Address32.Granularity),
195
                        AML_OFFSET (Address32.Granularity),
196
                        5},
197
 
198
    /* Optional ResourceSource (Index and String) */
199
 
200
    {ACPI_RSC_SOURCE,   ACPI_RS_OFFSET (Data.Address32.ResourceSource),
201
                        0,
202
                        sizeof (AML_RESOURCE_ADDRESS32)}
203
};
204
 
205
 
206
/*******************************************************************************
207
 *
208
 * AcpiRsConvertAddress64 - All QWORD (64-bit) address resources
209
 *
210
 ******************************************************************************/
211
 
212
ACPI_RSCONVERT_INFO     AcpiRsConvertAddress64[5] =
213
{
214
    {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_ADDRESS64,
215
                        ACPI_RS_SIZE (ACPI_RESOURCE_ADDRESS64),
216
                        ACPI_RSC_TABLE_SIZE (AcpiRsConvertAddress64)},
217
 
218
    {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_ADDRESS64,
219
                        sizeof (AML_RESOURCE_ADDRESS64),
220
                        0},
221
 
222
    /* Resource Type, General Flags, and Type-Specific Flags */
223
 
224
    {ACPI_RSC_ADDRESS,  0, 0, 0},
225
 
226
    /*
227
     * These fields are contiguous in both the source and destination:
228
     * Address Granularity
229
     * Address Range Minimum
230
     * Address Range Maximum
231
     * Address Translation Offset
232
     * Address Length
233
     */
234
    {ACPI_RSC_MOVE64,   ACPI_RS_OFFSET (Data.Address64.Granularity),
235
                        AML_OFFSET (Address64.Granularity),
236
                        5},
237
 
238
    /* Optional ResourceSource (Index and String) */
239
 
240
    {ACPI_RSC_SOURCE,   ACPI_RS_OFFSET (Data.Address64.ResourceSource),
241
                        0,
242
                        sizeof (AML_RESOURCE_ADDRESS64)}
243
};
244
 
245
 
246
/*******************************************************************************
247
 *
248
 * AcpiRsConvertExtAddress64 - All Extended (64-bit) address resources
249
 *
250
 ******************************************************************************/
251
 
252
ACPI_RSCONVERT_INFO     AcpiRsConvertExtAddress64[5] =
253
{
254
    {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64,
255
                        ACPI_RS_SIZE (ACPI_RESOURCE_EXTENDED_ADDRESS64),
256
                        ACPI_RSC_TABLE_SIZE (AcpiRsConvertExtAddress64)},
257
 
258
    {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64,
259
                        sizeof (AML_RESOURCE_EXTENDED_ADDRESS64),
260
                        0},
261
 
262
    /* Resource Type, General Flags, and Type-Specific Flags */
263
 
264
    {ACPI_RSC_ADDRESS,  0, 0, 0},
265
 
266
    /* Revision ID */
267
 
268
    {ACPI_RSC_MOVE8,    ACPI_RS_OFFSET (Data.ExtAddress64.RevisionID),
269
                        AML_OFFSET (ExtAddress64.RevisionID),
270
                        1},
271
    /*
272
     * These fields are contiguous in both the source and destination:
273
     * Address Granularity
274
     * Address Range Minimum
275
     * Address Range Maximum
276
     * Address Translation Offset
277
     * Address Length
278
     * Type-Specific Attribute
279
     */
280
    {ACPI_RSC_MOVE64,   ACPI_RS_OFFSET (Data.ExtAddress64.Granularity),
281
                        AML_OFFSET (ExtAddress64.Granularity),
282
                        6}
283
};
284
 
285
 
286
/*******************************************************************************
287
 *
288
 * AcpiRsConvertGeneralFlags - Flags common to all address descriptors
289
 *
290
 ******************************************************************************/
291
 
292
static ACPI_RSCONVERT_INFO  AcpiRsConvertGeneralFlags[6] =
293
{
294
    {ACPI_RSC_FLAGINIT, 0, AML_OFFSET (Address.Flags),
295
                        ACPI_RSC_TABLE_SIZE (AcpiRsConvertGeneralFlags)},
296
 
297
    /* Resource Type (Memory, Io, BusNumber, etc.) */
298
 
299
    {ACPI_RSC_MOVE8,    ACPI_RS_OFFSET (Data.Address.ResourceType),
300
                        AML_OFFSET (Address.ResourceType),
301
                        1},
302
 
303
    /* General Flags - Consume, Decode, MinFixed, MaxFixed */
304
 
305
    {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.ProducerConsumer),
306
                        AML_OFFSET (Address.Flags),
307
                        0},
308
 
309
    {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Decode),
310
                        AML_OFFSET (Address.Flags),
311
                        1},
312
 
313
    {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.MinAddressFixed),
314
                        AML_OFFSET (Address.Flags),
315
                        2},
316
 
317
    {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.MaxAddressFixed),
318
                        AML_OFFSET (Address.Flags),
319
                        3}
320
};
321
 
322
 
323
/*******************************************************************************
324
 *
325
 * AcpiRsConvertMemFlags - Flags common to Memory address descriptors
326
 *
327
 ******************************************************************************/
328
 
329
static ACPI_RSCONVERT_INFO  AcpiRsConvertMemFlags[5] =
330
{
331
    {ACPI_RSC_FLAGINIT, 0, AML_OFFSET (Address.SpecificFlags),
332
                        ACPI_RSC_TABLE_SIZE (AcpiRsConvertMemFlags)},
333
 
334
    /* Memory-specific flags */
335
 
336
    {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.WriteProtect),
337
                        AML_OFFSET (Address.SpecificFlags),
338
                        0},
339
 
340
    {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.Caching),
341
                        AML_OFFSET (Address.SpecificFlags),
342
                        1},
343
 
344
    {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.RangeType),
345
                        AML_OFFSET (Address.SpecificFlags),
346
                        3},
347
 
348
    {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.Translation),
349
                        AML_OFFSET (Address.SpecificFlags),
350
                        5}
351
};
352
 
353
 
354
/*******************************************************************************
355
 *
356
 * AcpiRsConvertIoFlags - Flags common to I/O address descriptors
357
 *
358
 ******************************************************************************/
359
 
360
static ACPI_RSCONVERT_INFO  AcpiRsConvertIoFlags[4] =
361
{
362
    {ACPI_RSC_FLAGINIT, 0, AML_OFFSET (Address.SpecificFlags),
363
                        ACPI_RSC_TABLE_SIZE (AcpiRsConvertIoFlags)},
364
 
365
    /* I/O-specific flags */
366
 
367
    {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Io.RangeType),
368
                        AML_OFFSET (Address.SpecificFlags),
369
                        0},
370
 
371
    {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Io.Translation),
372
                        AML_OFFSET (Address.SpecificFlags),
373
                        4},
374
 
375
    {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Io.TranslationType),
376
                        AML_OFFSET (Address.SpecificFlags),
377
                        5}
378
};
379
 
380
 
381
/*******************************************************************************
382
 *
383
 * FUNCTION:    AcpiRsGetAddressCommon
384
 *
385
 * PARAMETERS:  Resource            - Pointer to the internal resource struct
386
 *              Aml                 - Pointer to the AML resource descriptor
387
 *
388
 * RETURN:      TRUE if the ResourceType field is OK, FALSE otherwise
389
 *
390
 * DESCRIPTION: Convert common flag fields from a raw AML resource descriptor
391
 *              to an internal resource descriptor
392
 *
393
 ******************************************************************************/
394
 
395
BOOLEAN
396
AcpiRsGetAddressCommon (
397
    ACPI_RESOURCE           *Resource,
398
    AML_RESOURCE            *Aml)
399
{
400
    ACPI_FUNCTION_ENTRY ();
401
 
402
 
403
    /* Validate the Resource Type */
404
 
405
    if ((Aml->Address.ResourceType > 2) && (Aml->Address.ResourceType < 0xC0))
406
    {
407
        return (FALSE);
408
    }
409
 
410
    /* Get the Resource Type and General Flags */
411
 
412
    (void) AcpiRsConvertAmlToResource (Resource, Aml, AcpiRsConvertGeneralFlags);
413
 
414
    /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
415
 
416
    if (Resource->Data.Address.ResourceType == ACPI_MEMORY_RANGE)
417
    {
418
        (void) AcpiRsConvertAmlToResource (Resource, Aml, AcpiRsConvertMemFlags);
419
    }
420
    else if (Resource->Data.Address.ResourceType == ACPI_IO_RANGE)
421
    {
422
        (void) AcpiRsConvertAmlToResource (Resource, Aml, AcpiRsConvertIoFlags);
423
    }
424
    else
425
    {
426
        /* Generic resource type, just grab the TypeSpecific byte */
427
 
428
        Resource->Data.Address.Info.TypeSpecific = Aml->Address.SpecificFlags;
429
    }
430
 
431
    return (TRUE);
432
}
433
 
434
 
435
/*******************************************************************************
436
 *
437
 * FUNCTION:    AcpiRsSetAddressCommon
438
 *
439
 * PARAMETERS:  Aml                 - Pointer to the AML resource descriptor
440
 *              Resource            - Pointer to the internal resource struct
441
 *
442
 * RETURN:      None
443
 *
444
 * DESCRIPTION: Convert common flag fields from a resource descriptor to an
445
 *              AML descriptor
446
 *
447
 ******************************************************************************/
448
 
449
void
450
AcpiRsSetAddressCommon (
451
    AML_RESOURCE            *Aml,
452
    ACPI_RESOURCE           *Resource)
453
{
454
    ACPI_FUNCTION_ENTRY ();
455
 
456
 
457
    /* Set the Resource Type and General Flags */
458
 
459
    (void) AcpiRsConvertResourceToAml (Resource, Aml, AcpiRsConvertGeneralFlags);
460
 
461
    /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
462
 
463
    if (Resource->Data.Address.ResourceType == ACPI_MEMORY_RANGE)
464
    {
465
        (void) AcpiRsConvertResourceToAml (Resource, Aml, AcpiRsConvertMemFlags);
466
    }
467
    else if (Resource->Data.Address.ResourceType == ACPI_IO_RANGE)
468
    {
469
        (void) AcpiRsConvertResourceToAml (Resource, Aml, AcpiRsConvertIoFlags);
470
    }
471
    else
472
    {
473
        /* Generic resource type, just copy the TypeSpecific byte */
474
 
475
        Aml->Address.SpecificFlags = Resource->Data.Address.Info.TypeSpecific;
476
    }
477
}
478