OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [acpi/] [utilities/] [utglobal.c] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/******************************************************************************
2
 *
3
 * Module Name: utglobal - Global variables for the ACPI subsystem
4
 *
5
 *****************************************************************************/
6
 
7
/*
8
 * Copyright (C) 2000 - 2007, R. Byron Moore
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
#define DEFINE_ACPI_GLOBALS
45
 
46
#include <acpi/acpi.h>
47
#include <acpi/acnamesp.h>
48
 
49
ACPI_EXPORT_SYMBOL(acpi_gbl_FADT)
50
#define _COMPONENT          ACPI_UTILITIES
51
    ACPI_MODULE_NAME("utglobal")
52
 
53
/*******************************************************************************
54
 *
55
 * Static global variable initialization.
56
 *
57
 ******************************************************************************/
58
/*
59
 * We want the debug switches statically initialized so they
60
 * are already set when the debugger is entered.
61
 */
62
/* Debug switch - level and trace mask */
63
u32 acpi_dbg_level = ACPI_DEBUG_DEFAULT;
64
 
65
/* Debug switch - layer (component) mask */
66
 
67
u32 acpi_dbg_layer = ACPI_COMPONENT_DEFAULT | ACPI_ALL_DRIVERS;
68
u32 acpi_gbl_nesting_level = 0;
69
 
70
/* Debugger globals */
71
 
72
u8 acpi_gbl_db_terminate_threads = FALSE;
73
u8 acpi_gbl_abort_method = FALSE;
74
u8 acpi_gbl_method_executing = FALSE;
75
 
76
/* System flags */
77
 
78
u32 acpi_gbl_startup_flags = 0;
79
 
80
/* System starts uninitialized */
81
 
82
u8 acpi_gbl_shutdown = TRUE;
83
 
84
const char *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT] = {
85
        "\\_S0_",
86
        "\\_S1_",
87
        "\\_S2_",
88
        "\\_S3_",
89
        "\\_S4_",
90
        "\\_S5_"
91
};
92
 
93
const char *acpi_gbl_highest_dstate_names[4] = {
94
        "_S1D",
95
        "_S2D",
96
        "_S3D",
97
        "_S4D"
98
};
99
 
100
/*******************************************************************************
101
 *
102
 * FUNCTION:    acpi_format_exception
103
 *
104
 * PARAMETERS:  Status       - The acpi_status code to be formatted
105
 *
106
 * RETURN:      A string containing the exception text. A valid pointer is
107
 *              always returned.
108
 *
109
 * DESCRIPTION: This function translates an ACPI exception into an ASCII string
110
 *              It is here instead of utxface.c so it is always present.
111
 *
112
 ******************************************************************************/
113
 
114
const char *acpi_format_exception(acpi_status status)
115
{
116
        const char *exception = NULL;
117
 
118
        ACPI_FUNCTION_ENTRY();
119
 
120
        exception = acpi_ut_validate_exception(status);
121
        if (!exception) {
122
 
123
                /* Exception code was not recognized */
124
 
125
                ACPI_ERROR((AE_INFO,
126
                            "Unknown exception code: 0x%8.8X", status));
127
 
128
                exception = "UNKNOWN_STATUS_CODE";
129
                dump_stack();
130
        }
131
 
132
        return (ACPI_CAST_PTR(const char, exception));
133
}
134
 
135
ACPI_EXPORT_SYMBOL(acpi_format_exception)
136
 
137
/*******************************************************************************
138
 *
139
 * Namespace globals
140
 *
141
 ******************************************************************************/
142
/*
143
 * Predefined ACPI Names (Built-in to the Interpreter)
144
 *
145
 * NOTES:
146
 * 1) _SB_ is defined to be a device to allow \_SB_._INI to be run
147
 *    during the initialization sequence.
148
 * 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to
149
 *    perform a Notify() operation on it.
150
 */
151
const struct acpi_predefined_names acpi_gbl_pre_defined_names[] = {
152
        {"_GPE", ACPI_TYPE_LOCAL_SCOPE, NULL},
153
        {"_PR_", ACPI_TYPE_LOCAL_SCOPE, NULL},
154
        {"_SB_", ACPI_TYPE_DEVICE, NULL},
155
        {"_SI_", ACPI_TYPE_LOCAL_SCOPE, NULL},
156
        {"_TZ_", ACPI_TYPE_THERMAL, NULL},
157
        {"_REV", ACPI_TYPE_INTEGER, (char *)ACPI_CA_SUPPORT_LEVEL},
158
        {"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME},
159
        {"_GL_", ACPI_TYPE_MUTEX, (char *)1},
160
 
161
#if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)
162
        {"_OSI", ACPI_TYPE_METHOD, (char *)1},
163
#endif
164
 
165
        /* Table terminator */
166
 
167
        {NULL, ACPI_TYPE_ANY, NULL}
168
};
169
 
170
/*
171
 * Properties of the ACPI Object Types, both internal and external.
172
 * The table is indexed by values of acpi_object_type
173
 */
174
const u8 acpi_gbl_ns_properties[] = {
175
        ACPI_NS_NORMAL,         /* 00 Any              */
176
        ACPI_NS_NORMAL,         /* 01 Number           */
177
        ACPI_NS_NORMAL,         /* 02 String           */
178
        ACPI_NS_NORMAL,         /* 03 Buffer           */
179
        ACPI_NS_NORMAL,         /* 04 Package          */
180
        ACPI_NS_NORMAL,         /* 05 field_unit       */
181
        ACPI_NS_NEWSCOPE,       /* 06 Device           */
182
        ACPI_NS_NORMAL,         /* 07 Event            */
183
        ACPI_NS_NEWSCOPE,       /* 08 Method           */
184
        ACPI_NS_NORMAL,         /* 09 Mutex            */
185
        ACPI_NS_NORMAL,         /* 10 Region           */
186
        ACPI_NS_NEWSCOPE,       /* 11 Power            */
187
        ACPI_NS_NEWSCOPE,       /* 12 Processor        */
188
        ACPI_NS_NEWSCOPE,       /* 13 Thermal          */
189
        ACPI_NS_NORMAL,         /* 14 buffer_field     */
190
        ACPI_NS_NORMAL,         /* 15 ddb_handle       */
191
        ACPI_NS_NORMAL,         /* 16 Debug Object     */
192
        ACPI_NS_NORMAL,         /* 17 def_field        */
193
        ACPI_NS_NORMAL,         /* 18 bank_field       */
194
        ACPI_NS_NORMAL,         /* 19 index_field      */
195
        ACPI_NS_NORMAL,         /* 20 Reference        */
196
        ACPI_NS_NORMAL,         /* 21 Alias            */
197
        ACPI_NS_NORMAL,         /* 22 method_alias     */
198
        ACPI_NS_NORMAL,         /* 23 Notify           */
199
        ACPI_NS_NORMAL,         /* 24 Address Handler  */
200
        ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,       /* 25 Resource Desc    */
201
        ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,       /* 26 Resource Field   */
202
        ACPI_NS_NEWSCOPE,       /* 27 Scope            */
203
        ACPI_NS_NORMAL,         /* 28 Extra            */
204
        ACPI_NS_NORMAL,         /* 29 Data             */
205
        ACPI_NS_NORMAL          /* 30 Invalid          */
206
};
207
 
208
/* Hex to ASCII conversion table */
209
 
210
static const char acpi_gbl_hex_to_ascii[] = {
211
        '0', '1', '2', '3', '4', '5', '6', '7',
212
        '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
213
};
214
 
215
/*******************************************************************************
216
 *
217
 * FUNCTION:    acpi_ut_hex_to_ascii_char
218
 *
219
 * PARAMETERS:  Integer             - Contains the hex digit
220
 *              Position            - bit position of the digit within the
221
 *                                    integer (multiple of 4)
222
 *
223
 * RETURN:      The converted Ascii character
224
 *
225
 * DESCRIPTION: Convert a hex digit to an Ascii character
226
 *
227
 ******************************************************************************/
228
 
229
char acpi_ut_hex_to_ascii_char(acpi_integer integer, u32 position)
230
{
231
 
232
        return (acpi_gbl_hex_to_ascii[(integer >> position) & 0xF]);
233
}
234
 
235
/******************************************************************************
236
 *
237
 * Event and Hardware globals
238
 *
239
 ******************************************************************************/
240
 
241
struct acpi_bit_register_info acpi_gbl_bit_register_info[ACPI_NUM_BITREG] = {
242
        /* Name                                     Parent Register             Register Bit Position                   Register Bit Mask       */
243
 
244
        /* ACPI_BITREG_TIMER_STATUS         */ {ACPI_REGISTER_PM1_STATUS,
245
                                                ACPI_BITPOSITION_TIMER_STATUS,
246
                                                ACPI_BITMASK_TIMER_STATUS},
247
        /* ACPI_BITREG_BUS_MASTER_STATUS    */ {ACPI_REGISTER_PM1_STATUS,
248
                                                ACPI_BITPOSITION_BUS_MASTER_STATUS,
249
                                                ACPI_BITMASK_BUS_MASTER_STATUS},
250
        /* ACPI_BITREG_GLOBAL_LOCK_STATUS   */ {ACPI_REGISTER_PM1_STATUS,
251
                                                ACPI_BITPOSITION_GLOBAL_LOCK_STATUS,
252
                                                ACPI_BITMASK_GLOBAL_LOCK_STATUS},
253
        /* ACPI_BITREG_POWER_BUTTON_STATUS  */ {ACPI_REGISTER_PM1_STATUS,
254
                                                ACPI_BITPOSITION_POWER_BUTTON_STATUS,
255
                                                ACPI_BITMASK_POWER_BUTTON_STATUS},
256
        /* ACPI_BITREG_SLEEP_BUTTON_STATUS  */ {ACPI_REGISTER_PM1_STATUS,
257
                                                ACPI_BITPOSITION_SLEEP_BUTTON_STATUS,
258
                                                ACPI_BITMASK_SLEEP_BUTTON_STATUS},
259
        /* ACPI_BITREG_RT_CLOCK_STATUS      */ {ACPI_REGISTER_PM1_STATUS,
260
                                                ACPI_BITPOSITION_RT_CLOCK_STATUS,
261
                                                ACPI_BITMASK_RT_CLOCK_STATUS},
262
        /* ACPI_BITREG_WAKE_STATUS          */ {ACPI_REGISTER_PM1_STATUS,
263
                                                ACPI_BITPOSITION_WAKE_STATUS,
264
                                                ACPI_BITMASK_WAKE_STATUS},
265
        /* ACPI_BITREG_PCIEXP_WAKE_STATUS   */ {ACPI_REGISTER_PM1_STATUS,
266
                                                ACPI_BITPOSITION_PCIEXP_WAKE_STATUS,
267
                                                ACPI_BITMASK_PCIEXP_WAKE_STATUS},
268
 
269
        /* ACPI_BITREG_TIMER_ENABLE         */ {ACPI_REGISTER_PM1_ENABLE,
270
                                                ACPI_BITPOSITION_TIMER_ENABLE,
271
                                                ACPI_BITMASK_TIMER_ENABLE},
272
        /* ACPI_BITREG_GLOBAL_LOCK_ENABLE   */ {ACPI_REGISTER_PM1_ENABLE,
273
                                                ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE,
274
                                                ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
275
        /* ACPI_BITREG_POWER_BUTTON_ENABLE  */ {ACPI_REGISTER_PM1_ENABLE,
276
                                                ACPI_BITPOSITION_POWER_BUTTON_ENABLE,
277
                                                ACPI_BITMASK_POWER_BUTTON_ENABLE},
278
        /* ACPI_BITREG_SLEEP_BUTTON_ENABLE  */ {ACPI_REGISTER_PM1_ENABLE,
279
                                                ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE,
280
                                                ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
281
        /* ACPI_BITREG_RT_CLOCK_ENABLE      */ {ACPI_REGISTER_PM1_ENABLE,
282
                                                ACPI_BITPOSITION_RT_CLOCK_ENABLE,
283
                                                ACPI_BITMASK_RT_CLOCK_ENABLE},
284
        /* ACPI_BITREG_WAKE_ENABLE          */ {ACPI_REGISTER_PM1_ENABLE, 0, 0},
285
        /* ACPI_BITREG_PCIEXP_WAKE_DISABLE  */ {ACPI_REGISTER_PM1_ENABLE,
286
                                                ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE,
287
                                                ACPI_BITMASK_PCIEXP_WAKE_DISABLE},
288
 
289
        /* ACPI_BITREG_SCI_ENABLE           */ {ACPI_REGISTER_PM1_CONTROL,
290
                                                ACPI_BITPOSITION_SCI_ENABLE,
291
                                                ACPI_BITMASK_SCI_ENABLE},
292
        /* ACPI_BITREG_BUS_MASTER_RLD       */ {ACPI_REGISTER_PM1_CONTROL,
293
                                                ACPI_BITPOSITION_BUS_MASTER_RLD,
294
                                                ACPI_BITMASK_BUS_MASTER_RLD},
295
        /* ACPI_BITREG_GLOBAL_LOCK_RELEASE  */ {ACPI_REGISTER_PM1_CONTROL,
296
                                                ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE,
297
                                                ACPI_BITMASK_GLOBAL_LOCK_RELEASE},
298
        /* ACPI_BITREG_SLEEP_TYPE_A         */ {ACPI_REGISTER_PM1_CONTROL,
299
                                                ACPI_BITPOSITION_SLEEP_TYPE_X,
300
                                                ACPI_BITMASK_SLEEP_TYPE_X},
301
        /* ACPI_BITREG_SLEEP_TYPE_B         */ {ACPI_REGISTER_PM1_CONTROL,
302
                                                ACPI_BITPOSITION_SLEEP_TYPE_X,
303
                                                ACPI_BITMASK_SLEEP_TYPE_X},
304
        /* ACPI_BITREG_SLEEP_ENABLE         */ {ACPI_REGISTER_PM1_CONTROL,
305
                                                ACPI_BITPOSITION_SLEEP_ENABLE,
306
                                                ACPI_BITMASK_SLEEP_ENABLE},
307
 
308
        /* ACPI_BITREG_ARB_DIS              */ {ACPI_REGISTER_PM2_CONTROL,
309
                                                ACPI_BITPOSITION_ARB_DISABLE,
310
                                                ACPI_BITMASK_ARB_DISABLE}
311
};
312
 
313
struct acpi_fixed_event_info acpi_gbl_fixed_event_info[ACPI_NUM_FIXED_EVENTS] = {
314
        /* ACPI_EVENT_PMTIMER       */ {ACPI_BITREG_TIMER_STATUS,
315
                                        ACPI_BITREG_TIMER_ENABLE,
316
                                        ACPI_BITMASK_TIMER_STATUS,
317
                                        ACPI_BITMASK_TIMER_ENABLE},
318
        /* ACPI_EVENT_GLOBAL        */ {ACPI_BITREG_GLOBAL_LOCK_STATUS,
319
                                        ACPI_BITREG_GLOBAL_LOCK_ENABLE,
320
                                        ACPI_BITMASK_GLOBAL_LOCK_STATUS,
321
                                        ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
322
        /* ACPI_EVENT_POWER_BUTTON  */ {ACPI_BITREG_POWER_BUTTON_STATUS,
323
                                        ACPI_BITREG_POWER_BUTTON_ENABLE,
324
                                        ACPI_BITMASK_POWER_BUTTON_STATUS,
325
                                        ACPI_BITMASK_POWER_BUTTON_ENABLE},
326
        /* ACPI_EVENT_SLEEP_BUTTON  */ {ACPI_BITREG_SLEEP_BUTTON_STATUS,
327
                                        ACPI_BITREG_SLEEP_BUTTON_ENABLE,
328
                                        ACPI_BITMASK_SLEEP_BUTTON_STATUS,
329
                                        ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
330
        /* ACPI_EVENT_RTC           */ {ACPI_BITREG_RT_CLOCK_STATUS,
331
                                        ACPI_BITREG_RT_CLOCK_ENABLE,
332
                                        ACPI_BITMASK_RT_CLOCK_STATUS,
333
                                        ACPI_BITMASK_RT_CLOCK_ENABLE},
334
};
335
 
336
/*******************************************************************************
337
 *
338
 * FUNCTION:    acpi_ut_get_region_name
339
 *
340
 * PARAMETERS:  None.
341
 *
342
 * RETURN:      Status
343
 *
344
 * DESCRIPTION: Translate a Space ID into a name string (Debug only)
345
 *
346
 ******************************************************************************/
347
 
348
/* Region type decoding */
349
 
350
const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] = {
351
        "SystemMemory",
352
        "SystemIO",
353
        "PCI_Config",
354
        "EmbeddedControl",
355
        "SMBus",
356
        "CMOS",
357
        "PCIBARTarget",
358
        "DataTable"
359
};
360
 
361
char *acpi_ut_get_region_name(u8 space_id)
362
{
363
 
364
        if (space_id >= ACPI_USER_REGION_BEGIN) {
365
                return ("UserDefinedRegion");
366
        } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
367
                return ("InvalidSpaceId");
368
        }
369
 
370
        return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id]));
371
}
372
 
373
/*******************************************************************************
374
 *
375
 * FUNCTION:    acpi_ut_get_event_name
376
 *
377
 * PARAMETERS:  None.
378
 *
379
 * RETURN:      Status
380
 *
381
 * DESCRIPTION: Translate a Event ID into a name string (Debug only)
382
 *
383
 ******************************************************************************/
384
 
385
/* Event type decoding */
386
 
387
static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
388
        "PM_Timer",
389
        "GlobalLock",
390
        "PowerButton",
391
        "SleepButton",
392
        "RealTimeClock",
393
};
394
 
395
char *acpi_ut_get_event_name(u32 event_id)
396
{
397
 
398
        if (event_id > ACPI_EVENT_MAX) {
399
                return ("InvalidEventID");
400
        }
401
 
402
        return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id]));
403
}
404
 
405
/*******************************************************************************
406
 *
407
 * FUNCTION:    acpi_ut_get_type_name
408
 *
409
 * PARAMETERS:  None.
410
 *
411
 * RETURN:      Status
412
 *
413
 * DESCRIPTION: Translate a Type ID into a name string (Debug only)
414
 *
415
 ******************************************************************************/
416
 
417
/*
418
 * Elements of acpi_gbl_ns_type_names below must match
419
 * one-to-one with values of acpi_object_type
420
 *
421
 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
422
 * when stored in a table it really means that we have thus far seen no
423
 * evidence to indicate what type is actually going to be stored for this entry.
424
 */
425
static const char acpi_gbl_bad_type[] = "UNDEFINED";
426
 
427
/* Printable names of the ACPI object types */
428
 
429
static const char *acpi_gbl_ns_type_names[] = {
430
        /* 00 */ "Untyped",
431
        /* 01 */ "Integer",
432
        /* 02 */ "String",
433
        /* 03 */ "Buffer",
434
        /* 04 */ "Package",
435
        /* 05 */ "FieldUnit",
436
        /* 06 */ "Device",
437
        /* 07 */ "Event",
438
        /* 08 */ "Method",
439
        /* 09 */ "Mutex",
440
        /* 10 */ "Region",
441
        /* 11 */ "Power",
442
        /* 12 */ "Processor",
443
        /* 13 */ "Thermal",
444
        /* 14 */ "BufferField",
445
        /* 15 */ "DdbHandle",
446
        /* 16 */ "DebugObject",
447
        /* 17 */ "RegionField",
448
        /* 18 */ "BankField",
449
        /* 19 */ "IndexField",
450
        /* 20 */ "Reference",
451
        /* 21 */ "Alias",
452
        /* 22 */ "MethodAlias",
453
        /* 23 */ "Notify",
454
        /* 24 */ "AddrHandler",
455
        /* 25 */ "ResourceDesc",
456
        /* 26 */ "ResourceFld",
457
        /* 27 */ "Scope",
458
        /* 28 */ "Extra",
459
        /* 29 */ "Data",
460
        /* 30 */ "Invalid"
461
};
462
 
463
char *acpi_ut_get_type_name(acpi_object_type type)
464
{
465
 
466
        if (type > ACPI_TYPE_INVALID) {
467
                return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
468
        }
469
 
470
        return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type]));
471
}
472
 
473
char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
474
{
475
 
476
        if (!obj_desc) {
477
                return ("[NULL Object Descriptor]");
478
        }
479
 
480
        return (acpi_ut_get_type_name(ACPI_GET_OBJECT_TYPE(obj_desc)));
481
}
482
 
483
/*******************************************************************************
484
 *
485
 * FUNCTION:    acpi_ut_get_node_name
486
 *
487
 * PARAMETERS:  Object               - A namespace node
488
 *
489
 * RETURN:      Pointer to a string
490
 *
491
 * DESCRIPTION: Validate the node and return the node's ACPI name.
492
 *
493
 ******************************************************************************/
494
 
495
char *acpi_ut_get_node_name(void *object)
496
{
497
        struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
498
 
499
        /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
500
 
501
        if (!object) {
502
                return ("NULL");
503
        }
504
 
505
        /* Check for Root node */
506
 
507
        if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
508
                return ("\"\\\" ");
509
        }
510
 
511
        /* Descriptor must be a namespace node */
512
 
513
        if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) {
514
                return ("####");
515
        }
516
 
517
        /* Name must be a valid ACPI name */
518
 
519
        if (!acpi_ut_valid_acpi_name(node->name.integer)) {
520
                node->name.integer = acpi_ut_repair_name(node->name.ascii);
521
        }
522
 
523
        /* Return the name */
524
 
525
        return (node->name.ascii);
526
}
527
 
528
/*******************************************************************************
529
 *
530
 * FUNCTION:    acpi_ut_get_descriptor_name
531
 *
532
 * PARAMETERS:  Object               - An ACPI object
533
 *
534
 * RETURN:      Pointer to a string
535
 *
536
 * DESCRIPTION: Validate object and return the descriptor type
537
 *
538
 ******************************************************************************/
539
 
540
/* Printable names of object descriptor types */
541
 
542
static const char *acpi_gbl_desc_type_names[] = {
543
        /* 00 */ "Invalid",
544
        /* 01 */ "Cached",
545
        /* 02 */ "State-Generic",
546
        /* 03 */ "State-Update",
547
        /* 04 */ "State-Package",
548
        /* 05 */ "State-Control",
549
        /* 06 */ "State-RootParseScope",
550
        /* 07 */ "State-ParseScope",
551
        /* 08 */ "State-WalkScope",
552
        /* 09 */ "State-Result",
553
        /* 10 */ "State-Notify",
554
        /* 11 */ "State-Thread",
555
        /* 12 */ "Walk",
556
        /* 13 */ "Parser",
557
        /* 14 */ "Operand",
558
        /* 15 */ "Node"
559
};
560
 
561
char *acpi_ut_get_descriptor_name(void *object)
562
{
563
 
564
        if (!object) {
565
                return ("NULL OBJECT");
566
        }
567
 
568
        if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
569
                return (ACPI_CAST_PTR(char, acpi_gbl_bad_type));
570
        }
571
 
572
        return (ACPI_CAST_PTR(char,
573
                              acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE
574
                                                       (object)]));
575
 
576
}
577
 
578
#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
579
/*
580
 * Strings and procedures used for debug only
581
 */
582
 
583
/*******************************************************************************
584
 *
585
 * FUNCTION:    acpi_ut_get_mutex_name
586
 *
587
 * PARAMETERS:  mutex_id        - The predefined ID for this mutex.
588
 *
589
 * RETURN:      String containing the name of the mutex. Always returns a valid
590
 *              pointer.
591
 *
592
 * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
593
 *
594
 ******************************************************************************/
595
 
596
char *acpi_ut_get_mutex_name(u32 mutex_id)
597
{
598
 
599
        if (mutex_id > ACPI_MAX_MUTEX) {
600
                return ("Invalid Mutex ID");
601
        }
602
 
603
        return (acpi_gbl_mutex_names[mutex_id]);
604
}
605
#endif
606
 
607
/*******************************************************************************
608
 *
609
 * FUNCTION:    acpi_ut_valid_object_type
610
 *
611
 * PARAMETERS:  Type            - Object type to be validated
612
 *
613
 * RETURN:      TRUE if valid object type, FALSE otherwise
614
 *
615
 * DESCRIPTION: Validate an object type
616
 *
617
 ******************************************************************************/
618
 
619
u8 acpi_ut_valid_object_type(acpi_object_type type)
620
{
621
 
622
        if (type > ACPI_TYPE_LOCAL_MAX) {
623
 
624
                /* Note: Assumes all TYPEs are contiguous (external/local) */
625
 
626
                return (FALSE);
627
        }
628
 
629
        return (TRUE);
630
}
631
 
632
/*******************************************************************************
633
 *
634
 * FUNCTION:    acpi_ut_init_globals
635
 *
636
 * PARAMETERS:  None
637
 *
638
 * RETURN:      None
639
 *
640
 * DESCRIPTION: Init library globals.  All globals that require specific
641
 *              initialization should be initialized here!
642
 *
643
 ******************************************************************************/
644
 
645
void acpi_ut_init_globals(void)
646
{
647
        acpi_status status;
648
        u32 i;
649
 
650
        ACPI_FUNCTION_TRACE(ut_init_globals);
651
 
652
        /* Create all memory caches */
653
 
654
        status = acpi_ut_create_caches();
655
        if (ACPI_FAILURE(status)) {
656
                return;
657
        }
658
 
659
        /* Mutex locked flags */
660
 
661
        for (i = 0; i < ACPI_NUM_MUTEX; i++) {
662
                acpi_gbl_mutex_info[i].mutex = NULL;
663
                acpi_gbl_mutex_info[i].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
664
                acpi_gbl_mutex_info[i].use_count = 0;
665
        }
666
 
667
        for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++) {
668
                acpi_gbl_owner_id_mask[i] = 0;
669
        }
670
        acpi_gbl_owner_id_mask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000;        /* Last ID is never valid */
671
 
672
        /* GPE support */
673
 
674
        acpi_gpe_count = 0;
675
        acpi_gbl_gpe_xrupt_list_head = NULL;
676
        acpi_gbl_gpe_fadt_blocks[0] = NULL;
677
        acpi_gbl_gpe_fadt_blocks[1] = NULL;
678
 
679
        /* Global notify handlers */
680
 
681
        acpi_gbl_system_notify.handler = NULL;
682
        acpi_gbl_device_notify.handler = NULL;
683
        acpi_gbl_exception_handler = NULL;
684
        acpi_gbl_init_handler = NULL;
685
 
686
        /* Global Lock support */
687
 
688
        acpi_gbl_global_lock_semaphore = NULL;
689
        acpi_gbl_global_lock_mutex = NULL;
690
        acpi_gbl_global_lock_acquired = FALSE;
691
        acpi_gbl_global_lock_handle = 0;
692
 
693
        /* Miscellaneous variables */
694
 
695
        acpi_gbl_cm_single_step = FALSE;
696
        acpi_gbl_db_terminate_threads = FALSE;
697
        acpi_gbl_shutdown = FALSE;
698
        acpi_gbl_ns_lookup_count = 0;
699
        acpi_gbl_ps_find_count = 0;
700
        acpi_gbl_acpi_hardware_present = TRUE;
701
        acpi_gbl_last_owner_id_index = 0;
702
        acpi_gbl_next_owner_id_offset = 0;
703
        acpi_gbl_trace_method_name = 0;
704
        acpi_gbl_trace_dbg_level = 0;
705
        acpi_gbl_trace_dbg_layer = 0;
706
        acpi_gbl_debugger_configuration = DEBUGGER_THREADING;
707
        acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT;
708
 
709
        /* Hardware oriented */
710
 
711
        acpi_gbl_events_initialized = FALSE;
712
        acpi_gbl_system_awake_and_running = TRUE;
713
 
714
        /* Namespace */
715
 
716
        acpi_gbl_root_node = NULL;
717
        acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME;
718
        acpi_gbl_root_node_struct.descriptor_type = ACPI_DESC_TYPE_NAMED;
719
        acpi_gbl_root_node_struct.type = ACPI_TYPE_DEVICE;
720
        acpi_gbl_root_node_struct.child = NULL;
721
        acpi_gbl_root_node_struct.peer = NULL;
722
        acpi_gbl_root_node_struct.object = NULL;
723
        acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST;
724
 
725
#ifdef ACPI_DEBUG_OUTPUT
726
        acpi_gbl_lowest_stack_pointer = ACPI_SIZE_MAX;
727
#endif
728
 
729
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
730
        acpi_gbl_display_final_mem_stats = FALSE;
731
#endif
732
 
733
        return_VOID;
734
}
735
 
736
ACPI_EXPORT_SYMBOL(acpi_dbg_level)
737
    ACPI_EXPORT_SYMBOL(acpi_dbg_layer)
738
    ACPI_EXPORT_SYMBOL(acpi_gpe_count)

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.