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

Subversion Repositories test_project

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

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/*******************************************************************************
2
 *
3
 * Module Name: utmisc - common utility procedures
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
#include <linux/module.h>
45
 
46
#include <acpi/acpi.h>
47
#include <acpi/acnamesp.h>
48
 
49
#define _COMPONENT          ACPI_UTILITIES
50
ACPI_MODULE_NAME("utmisc")
51
 
52
/*******************************************************************************
53
 *
54
 * FUNCTION:    acpi_ut_validate_exception
55
 *
56
 * PARAMETERS:  Status       - The acpi_status code to be formatted
57
 *
58
 * RETURN:      A string containing the exception text. NULL if exception is
59
 *              not valid.
60
 *
61
 * DESCRIPTION: This function validates and translates an ACPI exception into
62
 *              an ASCII string.
63
 *
64
 ******************************************************************************/
65
const char *acpi_ut_validate_exception(acpi_status status)
66
{
67
        acpi_status sub_status;
68
        const char *exception = NULL;
69
 
70
        ACPI_FUNCTION_ENTRY();
71
 
72
        /*
73
         * Status is composed of two parts, a "type" and an actual code
74
         */
75
        sub_status = (status & ~AE_CODE_MASK);
76
 
77
        switch (status & AE_CODE_MASK) {
78
        case AE_CODE_ENVIRONMENTAL:
79
 
80
                if (sub_status <= AE_CODE_ENV_MAX) {
81
                        exception = acpi_gbl_exception_names_env[sub_status];
82
                }
83
                break;
84
 
85
        case AE_CODE_PROGRAMMER:
86
 
87
                if (sub_status <= AE_CODE_PGM_MAX) {
88
                        exception =
89
                            acpi_gbl_exception_names_pgm[sub_status - 1];
90
                }
91
                break;
92
 
93
        case AE_CODE_ACPI_TABLES:
94
 
95
                if (sub_status <= AE_CODE_TBL_MAX) {
96
                        exception =
97
                            acpi_gbl_exception_names_tbl[sub_status - 1];
98
                }
99
                break;
100
 
101
        case AE_CODE_AML:
102
 
103
                if (sub_status <= AE_CODE_AML_MAX) {
104
                        exception =
105
                            acpi_gbl_exception_names_aml[sub_status - 1];
106
                }
107
                break;
108
 
109
        case AE_CODE_CONTROL:
110
 
111
                if (sub_status <= AE_CODE_CTRL_MAX) {
112
                        exception =
113
                            acpi_gbl_exception_names_ctrl[sub_status - 1];
114
                }
115
                break;
116
 
117
        default:
118
                break;
119
        }
120
 
121
        return (ACPI_CAST_PTR(const char, exception));
122
}
123
 
124
/*******************************************************************************
125
 *
126
 * FUNCTION:    acpi_ut_is_aml_table
127
 *
128
 * PARAMETERS:  Table               - An ACPI table
129
 *
130
 * RETURN:      TRUE if table contains executable AML; FALSE otherwise
131
 *
132
 * DESCRIPTION: Check ACPI Signature for a table that contains AML code.
133
 *              Currently, these are DSDT,SSDT,PSDT. All other table types are
134
 *              data tables that do not contain AML code.
135
 *
136
 ******************************************************************************/
137
 
138
u8 acpi_ut_is_aml_table(struct acpi_table_header *table)
139
{
140
 
141
        /* These are the only tables that contain executable AML */
142
 
143
        if (ACPI_COMPARE_NAME(table->signature, ACPI_SIG_DSDT) ||
144
            ACPI_COMPARE_NAME(table->signature, ACPI_SIG_PSDT) ||
145
            ACPI_COMPARE_NAME(table->signature, ACPI_SIG_SSDT)) {
146
                return (TRUE);
147
        }
148
 
149
        return (FALSE);
150
}
151
 
152
/*******************************************************************************
153
 *
154
 * FUNCTION:    acpi_ut_allocate_owner_id
155
 *
156
 * PARAMETERS:  owner_id        - Where the new owner ID is returned
157
 *
158
 * RETURN:      Status
159
 *
160
 * DESCRIPTION: Allocate a table or method owner ID. The owner ID is used to
161
 *              track objects created by the table or method, to be deleted
162
 *              when the method exits or the table is unloaded.
163
 *
164
 ******************************************************************************/
165
 
166
acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id)
167
{
168
        acpi_native_uint i;
169
        acpi_native_uint j;
170
        acpi_native_uint k;
171
        acpi_status status;
172
 
173
        ACPI_FUNCTION_TRACE(ut_allocate_owner_id);
174
 
175
        /* Guard against multiple allocations of ID to the same location */
176
 
177
        if (*owner_id) {
178
                ACPI_ERROR((AE_INFO, "Owner ID [%2.2X] already exists",
179
                            *owner_id));
180
                return_ACPI_STATUS(AE_ALREADY_EXISTS);
181
        }
182
 
183
        /* Mutex for the global ID mask */
184
 
185
        status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES);
186
        if (ACPI_FAILURE(status)) {
187
                return_ACPI_STATUS(status);
188
        }
189
 
190
        /*
191
         * Find a free owner ID, cycle through all possible IDs on repeated
192
         * allocations. (ACPI_NUM_OWNERID_MASKS + 1) because first index may have
193
         * to be scanned twice.
194
         */
195
        for (i = 0, j = acpi_gbl_last_owner_id_index;
196
             i < (ACPI_NUM_OWNERID_MASKS + 1); i++, j++) {
197
                if (j >= ACPI_NUM_OWNERID_MASKS) {
198
                        j = 0;   /* Wraparound to start of mask array */
199
                }
200
 
201
                for (k = acpi_gbl_next_owner_id_offset; k < 32; k++) {
202
                        if (acpi_gbl_owner_id_mask[j] == ACPI_UINT32_MAX) {
203
 
204
                                /* There are no free IDs in this mask */
205
 
206
                                break;
207
                        }
208
 
209
                        if (!(acpi_gbl_owner_id_mask[j] & (1 << k))) {
210
                                /*
211
                                 * Found a free ID. The actual ID is the bit index plus one,
212
                                 * making zero an invalid Owner ID. Save this as the last ID
213
                                 * allocated and update the global ID mask.
214
                                 */
215
                                acpi_gbl_owner_id_mask[j] |= (1 << k);
216
 
217
                                acpi_gbl_last_owner_id_index = (u8) j;
218
                                acpi_gbl_next_owner_id_offset = (u8) (k + 1);
219
 
220
                                /*
221
                                 * Construct encoded ID from the index and bit position
222
                                 *
223
                                 * Note: Last [j].k (bit 255) is never used and is marked
224
                                 * permanently allocated (prevents +1 overflow)
225
                                 */
226
                                *owner_id =
227
                                    (acpi_owner_id) ((k + 1) + ACPI_MUL_32(j));
228
 
229
                                ACPI_DEBUG_PRINT((ACPI_DB_VALUES,
230
                                                  "Allocated OwnerId: %2.2X\n",
231
                                                  (unsigned int)*owner_id));
232
                                goto exit;
233
                        }
234
                }
235
 
236
                acpi_gbl_next_owner_id_offset = 0;
237
        }
238
 
239
        /*
240
         * All owner_ids have been allocated. This typically should
241
         * not happen since the IDs are reused after deallocation. The IDs are
242
         * allocated upon table load (one per table) and method execution, and
243
         * they are released when a table is unloaded or a method completes
244
         * execution.
245
         *
246
         * If this error happens, there may be very deep nesting of invoked control
247
         * methods, or there may be a bug where the IDs are not released.
248
         */
249
        status = AE_OWNER_ID_LIMIT;
250
        ACPI_ERROR((AE_INFO,
251
                    "Could not allocate new OwnerId (255 max), AE_OWNER_ID_LIMIT"));
252
 
253
      exit:
254
        (void)acpi_ut_release_mutex(ACPI_MTX_CACHES);
255
        return_ACPI_STATUS(status);
256
}
257
 
258
/*******************************************************************************
259
 *
260
 * FUNCTION:    acpi_ut_release_owner_id
261
 *
262
 * PARAMETERS:  owner_id_ptr        - Pointer to a previously allocated owner_iD
263
 *
264
 * RETURN:      None. No error is returned because we are either exiting a
265
 *              control method or unloading a table. Either way, we would
266
 *              ignore any error anyway.
267
 *
268
 * DESCRIPTION: Release a table or method owner ID.  Valid IDs are 1 - 255
269
 *
270
 ******************************************************************************/
271
 
272
void acpi_ut_release_owner_id(acpi_owner_id * owner_id_ptr)
273
{
274
        acpi_owner_id owner_id = *owner_id_ptr;
275
        acpi_status status;
276
        acpi_native_uint index;
277
        u32 bit;
278
 
279
        ACPI_FUNCTION_TRACE_U32(ut_release_owner_id, owner_id);
280
 
281
        /* Always clear the input owner_id (zero is an invalid ID) */
282
 
283
        *owner_id_ptr = 0;
284
 
285
        /* Zero is not a valid owner_iD */
286
 
287
        if (owner_id == 0) {
288
                ACPI_ERROR((AE_INFO, "Invalid OwnerId: %2.2X", owner_id));
289
                return_VOID;
290
        }
291
 
292
        /* Mutex for the global ID mask */
293
 
294
        status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES);
295
        if (ACPI_FAILURE(status)) {
296
                return_VOID;
297
        }
298
 
299
        /* Normalize the ID to zero */
300
 
301
        owner_id--;
302
 
303
        /* Decode ID to index/offset pair */
304
 
305
        index = ACPI_DIV_32(owner_id);
306
        bit = 1 << ACPI_MOD_32(owner_id);
307
 
308
        /* Free the owner ID only if it is valid */
309
 
310
        if (acpi_gbl_owner_id_mask[index] & bit) {
311
                acpi_gbl_owner_id_mask[index] ^= bit;
312
        } else {
313
                ACPI_ERROR((AE_INFO,
314
                            "Release of non-allocated OwnerId: %2.2X",
315
                            owner_id + 1));
316
        }
317
 
318
        (void)acpi_ut_release_mutex(ACPI_MTX_CACHES);
319
        return_VOID;
320
}
321
 
322
/*******************************************************************************
323
 *
324
 * FUNCTION:    acpi_ut_strupr (strupr)
325
 *
326
 * PARAMETERS:  src_string      - The source string to convert
327
 *
328
 * RETURN:      None
329
 *
330
 * DESCRIPTION: Convert string to uppercase
331
 *
332
 * NOTE: This is not a POSIX function, so it appears here, not in utclib.c
333
 *
334
 ******************************************************************************/
335
 
336
void acpi_ut_strupr(char *src_string)
337
{
338
        char *string;
339
 
340
        ACPI_FUNCTION_ENTRY();
341
 
342
        if (!src_string) {
343
                return;
344
        }
345
 
346
        /* Walk entire string, uppercasing the letters */
347
 
348
        for (string = src_string; *string; string++) {
349
                *string = (char)ACPI_TOUPPER(*string);
350
        }
351
 
352
        return;
353
}
354
 
355
/*******************************************************************************
356
 *
357
 * FUNCTION:    acpi_ut_print_string
358
 *
359
 * PARAMETERS:  String          - Null terminated ASCII string
360
 *              max_length      - Maximum output length
361
 *
362
 * RETURN:      None
363
 *
364
 * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape
365
 *              sequences.
366
 *
367
 ******************************************************************************/
368
 
369
void acpi_ut_print_string(char *string, u8 max_length)
370
{
371
        u32 i;
372
 
373
        if (!string) {
374
                acpi_os_printf("<\"NULL STRING PTR\">");
375
                return;
376
        }
377
 
378
        acpi_os_printf("\"");
379
        for (i = 0; string[i] && (i < max_length); i++) {
380
 
381
                /* Escape sequences */
382
 
383
                switch (string[i]) {
384
                case 0x07:
385
                        acpi_os_printf("\\a");  /* BELL */
386
                        break;
387
 
388
                case 0x08:
389
                        acpi_os_printf("\\b");  /* BACKSPACE */
390
                        break;
391
 
392
                case 0x0C:
393
                        acpi_os_printf("\\f");  /* FORMFEED */
394
                        break;
395
 
396
                case 0x0A:
397
                        acpi_os_printf("\\n");  /* LINEFEED */
398
                        break;
399
 
400
                case 0x0D:
401
                        acpi_os_printf("\\r");  /* CARRIAGE RETURN */
402
                        break;
403
 
404
                case 0x09:
405
                        acpi_os_printf("\\t");  /* HORIZONTAL TAB */
406
                        break;
407
 
408
                case 0x0B:
409
                        acpi_os_printf("\\v");  /* VERTICAL TAB */
410
                        break;
411
 
412
                case '\'':      /* Single Quote */
413
                case '\"':      /* Double Quote */
414
                case '\\':      /* Backslash */
415
                        acpi_os_printf("\\%c", (int)string[i]);
416
                        break;
417
 
418
                default:
419
 
420
                        /* Check for printable character or hex escape */
421
 
422
                        if (ACPI_IS_PRINT(string[i])) {
423
                                /* This is a normal character */
424
 
425
                                acpi_os_printf("%c", (int)string[i]);
426
                        } else {
427
                                /* All others will be Hex escapes */
428
 
429
                                acpi_os_printf("\\x%2.2X", (s32) string[i]);
430
                        }
431
                        break;
432
                }
433
        }
434
        acpi_os_printf("\"");
435
 
436
        if (i == max_length && string[i]) {
437
                acpi_os_printf("...");
438
        }
439
}
440
 
441
/*******************************************************************************
442
 *
443
 * FUNCTION:    acpi_ut_dword_byte_swap
444
 *
445
 * PARAMETERS:  Value           - Value to be converted
446
 *
447
 * RETURN:      u32 integer with bytes swapped
448
 *
449
 * DESCRIPTION: Convert a 32-bit value to big-endian (swap the bytes)
450
 *
451
 ******************************************************************************/
452
 
453
u32 acpi_ut_dword_byte_swap(u32 value)
454
{
455
        union {
456
                u32 value;
457
                u8 bytes[4];
458
        } out;
459
        union {
460
                u32 value;
461
                u8 bytes[4];
462
        } in;
463
 
464
        ACPI_FUNCTION_ENTRY();
465
 
466
        in.value = value;
467
 
468
        out.bytes[0] = in.bytes[3];
469
        out.bytes[1] = in.bytes[2];
470
        out.bytes[2] = in.bytes[1];
471
        out.bytes[3] = in.bytes[0];
472
 
473
        return (out.value);
474
}
475
 
476
/*******************************************************************************
477
 *
478
 * FUNCTION:    acpi_ut_set_integer_width
479
 *
480
 * PARAMETERS:  Revision            From DSDT header
481
 *
482
 * RETURN:      None
483
 *
484
 * DESCRIPTION: Set the global integer bit width based upon the revision
485
 *              of the DSDT.  For Revision 1 and 0, Integers are 32 bits.
486
 *              For Revision 2 and above, Integers are 64 bits.  Yes, this
487
 *              makes a difference.
488
 *
489
 ******************************************************************************/
490
 
491
void acpi_ut_set_integer_width(u8 revision)
492
{
493
 
494
        if (revision < 2) {
495
 
496
                /* 32-bit case */
497
 
498
                acpi_gbl_integer_bit_width = 32;
499
                acpi_gbl_integer_nybble_width = 8;
500
                acpi_gbl_integer_byte_width = 4;
501
        } else {
502
                /* 64-bit case (ACPI 2.0+) */
503
 
504
                acpi_gbl_integer_bit_width = 64;
505
                acpi_gbl_integer_nybble_width = 16;
506
                acpi_gbl_integer_byte_width = 8;
507
        }
508
}
509
 
510
#ifdef ACPI_DEBUG_OUTPUT
511
/*******************************************************************************
512
 *
513
 * FUNCTION:    acpi_ut_display_init_pathname
514
 *
515
 * PARAMETERS:  Type                - Object type of the node
516
 *              obj_handle          - Handle whose pathname will be displayed
517
 *              Path                - Additional path string to be appended.
518
 *                                      (NULL if no extra path)
519
 *
520
 * RETURN:      acpi_status
521
 *
522
 * DESCRIPTION: Display full pathname of an object, DEBUG ONLY
523
 *
524
 ******************************************************************************/
525
 
526
void
527
acpi_ut_display_init_pathname(u8 type,
528
                              struct acpi_namespace_node *obj_handle,
529
                              char *path)
530
{
531
        acpi_status status;
532
        struct acpi_buffer buffer;
533
 
534
        ACPI_FUNCTION_ENTRY();
535
 
536
        /* Only print the path if the appropriate debug level is enabled */
537
 
538
        if (!(acpi_dbg_level & ACPI_LV_INIT_NAMES)) {
539
                return;
540
        }
541
 
542
        /* Get the full pathname to the node */
543
 
544
        buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
545
        status = acpi_ns_handle_to_pathname(obj_handle, &buffer);
546
        if (ACPI_FAILURE(status)) {
547
                return;
548
        }
549
 
550
        /* Print what we're doing */
551
 
552
        switch (type) {
553
        case ACPI_TYPE_METHOD:
554
                acpi_os_printf("Executing  ");
555
                break;
556
 
557
        default:
558
                acpi_os_printf("Initializing ");
559
                break;
560
        }
561
 
562
        /* Print the object type and pathname */
563
 
564
        acpi_os_printf("%-12s %s",
565
                       acpi_ut_get_type_name(type), (char *)buffer.pointer);
566
 
567
        /* Extra path is used to append names like _STA, _INI, etc. */
568
 
569
        if (path) {
570
                acpi_os_printf(".%s", path);
571
        }
572
        acpi_os_printf("\n");
573
 
574
        ACPI_FREE(buffer.pointer);
575
}
576
#endif
577
 
578
/*******************************************************************************
579
 *
580
 * FUNCTION:    acpi_ut_valid_acpi_char
581
 *
582
 * PARAMETERS:  Char            - The character to be examined
583
 *              Position        - Byte position (0-3)
584
 *
585
 * RETURN:      TRUE if the character is valid, FALSE otherwise
586
 *
587
 * DESCRIPTION: Check for a valid ACPI character. Must be one of:
588
 *              1) Upper case alpha
589
 *              2) numeric
590
 *              3) underscore
591
 *
592
 *              We allow a '!' as the last character because of the ASF! table
593
 *
594
 ******************************************************************************/
595
 
596
u8 acpi_ut_valid_acpi_char(char character, acpi_native_uint position)
597
{
598
 
599
        if (!((character >= 'A' && character <= 'Z') ||
600
              (character >= '0' && character <= '9') || (character == '_'))) {
601
 
602
                /* Allow a '!' in the last position */
603
 
604
                if (character == '!' && position == 3) {
605
                        return (TRUE);
606
                }
607
 
608
                return (FALSE);
609
        }
610
 
611
        return (TRUE);
612
}
613
 
614
/*******************************************************************************
615
 *
616
 * FUNCTION:    acpi_ut_valid_acpi_name
617
 *
618
 * PARAMETERS:  Name            - The name to be examined
619
 *
620
 * RETURN:      TRUE if the name is valid, FALSE otherwise
621
 *
622
 * DESCRIPTION: Check for a valid ACPI name.  Each character must be one of:
623
 *              1) Upper case alpha
624
 *              2) numeric
625
 *              3) underscore
626
 *
627
 ******************************************************************************/
628
 
629
u8 acpi_ut_valid_acpi_name(u32 name)
630
{
631
        acpi_native_uint i;
632
 
633
        ACPI_FUNCTION_ENTRY();
634
 
635
        for (i = 0; i < ACPI_NAME_SIZE; i++) {
636
                if (!acpi_ut_valid_acpi_char
637
                    ((ACPI_CAST_PTR(char, &name))[i], i)) {
638
                        return (FALSE);
639
                }
640
        }
641
 
642
        return (TRUE);
643
}
644
 
645
/*******************************************************************************
646
 *
647
 * FUNCTION:    acpi_ut_repair_name
648
 *
649
 * PARAMETERS:  Name            - The ACPI name to be repaired
650
 *
651
 * RETURN:      Repaired version of the name
652
 *
653
 * DESCRIPTION: Repair an ACPI name: Change invalid characters to '*' and
654
 *              return the new name.
655
 *
656
 ******************************************************************************/
657
 
658
acpi_name acpi_ut_repair_name(char *name)
659
{
660
        acpi_native_uint i;
661
        char new_name[ACPI_NAME_SIZE];
662
 
663
        for (i = 0; i < ACPI_NAME_SIZE; i++) {
664
                new_name[i] = name[i];
665
 
666
                /*
667
                 * Replace a bad character with something printable, yet technically
668
                 * still invalid. This prevents any collisions with existing "good"
669
                 * names in the namespace.
670
                 */
671
                if (!acpi_ut_valid_acpi_char(name[i], i)) {
672
                        new_name[i] = '*';
673
                }
674
        }
675
 
676
        return (*(u32 *) new_name);
677
}
678
 
679
/*******************************************************************************
680
 *
681
 * FUNCTION:    acpi_ut_strtoul64
682
 *
683
 * PARAMETERS:  String          - Null terminated string
684
 *              Base            - Radix of the string: 16 or ACPI_ANY_BASE;
685
 *                                ACPI_ANY_BASE means 'in behalf of to_integer'
686
 *              ret_integer     - Where the converted integer is returned
687
 *
688
 * RETURN:      Status and Converted value
689
 *
690
 * DESCRIPTION: Convert a string into an unsigned value. Performs either a
691
 *              32-bit or 64-bit conversion, depending on the current mode
692
 *              of the interpreter.
693
 *              NOTE: Does not support Octal strings, not needed.
694
 *
695
 ******************************************************************************/
696
 
697
acpi_status
698
acpi_ut_strtoul64(char *string, u32 base, acpi_integer * ret_integer)
699
{
700
        u32 this_digit = 0;
701
        acpi_integer return_value = 0;
702
        acpi_integer quotient;
703
        acpi_integer dividend;
704
        u32 to_integer_op = (base == ACPI_ANY_BASE);
705
        u32 mode32 = (acpi_gbl_integer_byte_width == 4);
706
        u8 valid_digits = 0;
707
        u8 sign_of0x = 0;
708
        u8 term = 0;
709
 
710
        ACPI_FUNCTION_TRACE_STR(ut_stroul64, string);
711
 
712
        switch (base) {
713
        case ACPI_ANY_BASE:
714
        case 16:
715
                break;
716
 
717
        default:
718
                /* Invalid Base */
719
                return_ACPI_STATUS(AE_BAD_PARAMETER);
720
        }
721
 
722
        if (!string) {
723
                goto error_exit;
724
        }
725
 
726
        /* Skip over any white space in the buffer */
727
 
728
        while ((*string) && (ACPI_IS_SPACE(*string) || *string == '\t')) {
729
                string++;
730
        }
731
 
732
        if (to_integer_op) {
733
                /*
734
                 * Base equal to ACPI_ANY_BASE means 'to_integer operation case'.
735
                 * We need to determine if it is decimal or hexadecimal.
736
                 */
737
                if ((*string == '0') && (ACPI_TOLOWER(*(string + 1)) == 'x')) {
738
                        sign_of0x = 1;
739
                        base = 16;
740
 
741
                        /* Skip over the leading '0x' */
742
                        string += 2;
743
                } else {
744
                        base = 10;
745
                }
746
        }
747
 
748
        /* Any string left? Check that '0x' is not followed by white space. */
749
 
750
        if (!(*string) || ACPI_IS_SPACE(*string) || *string == '\t') {
751
                if (to_integer_op) {
752
                        goto error_exit;
753
                } else {
754
                        goto all_done;
755
                }
756
        }
757
 
758
        /*
759
         * Perform a 32-bit or 64-bit conversion, depending upon the current
760
         * execution mode of the interpreter
761
         */
762
        dividend = (mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX;
763
 
764
        /* Main loop: convert the string to a 32- or 64-bit integer */
765
 
766
        while (*string) {
767
                if (ACPI_IS_DIGIT(*string)) {
768
 
769
                        /* Convert ASCII 0-9 to Decimal value */
770
 
771
                        this_digit = ((u8) * string) - '0';
772
                } else if (base == 10) {
773
 
774
                        /* Digit is out of range; possible in to_integer case only */
775
 
776
                        term = 1;
777
                } else {
778
                        this_digit = (u8) ACPI_TOUPPER(*string);
779
                        if (ACPI_IS_XDIGIT((char)this_digit)) {
780
 
781
                                /* Convert ASCII Hex char to value */
782
 
783
                                this_digit = this_digit - 'A' + 10;
784
                        } else {
785
                                term = 1;
786
                        }
787
                }
788
 
789
                if (term) {
790
                        if (to_integer_op) {
791
                                goto error_exit;
792
                        } else {
793
                                break;
794
                        }
795
                } else if ((valid_digits == 0) && (this_digit == 0)
796
                           && !sign_of0x) {
797
 
798
                        /* Skip zeros */
799
                        string++;
800
                        continue;
801
                }
802
 
803
                valid_digits++;
804
 
805
                if (sign_of0x && ((valid_digits > 16)
806
                                  || ((valid_digits > 8) && mode32))) {
807
                        /*
808
                         * This is to_integer operation case.
809
                         * No any restrictions for string-to-integer conversion,
810
                         * see ACPI spec.
811
                         */
812
                        goto error_exit;
813
                }
814
 
815
                /* Divide the digit into the correct position */
816
 
817
                (void)
818
                    acpi_ut_short_divide((dividend - (acpi_integer) this_digit),
819
                                         base, &quotient, NULL);
820
 
821
                if (return_value > quotient) {
822
                        if (to_integer_op) {
823
                                goto error_exit;
824
                        } else {
825
                                break;
826
                        }
827
                }
828
 
829
                return_value *= base;
830
                return_value += this_digit;
831
                string++;
832
        }
833
 
834
        /* All done, normal exit */
835
 
836
      all_done:
837
 
838
        ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
839
                          ACPI_FORMAT_UINT64(return_value)));
840
 
841
        *ret_integer = return_value;
842
        return_ACPI_STATUS(AE_OK);
843
 
844
      error_exit:
845
        /* Base was set/validated above */
846
 
847
        if (base == 10) {
848
                return_ACPI_STATUS(AE_BAD_DECIMAL_CONSTANT);
849
        } else {
850
                return_ACPI_STATUS(AE_BAD_HEX_CONSTANT);
851
        }
852
}
853
 
854
/*******************************************************************************
855
 *
856
 * FUNCTION:    acpi_ut_create_update_state_and_push
857
 *
858
 * PARAMETERS:  Object          - Object to be added to the new state
859
 *              Action          - Increment/Decrement
860
 *              state_list      - List the state will be added to
861
 *
862
 * RETURN:      Status
863
 *
864
 * DESCRIPTION: Create a new state and push it
865
 *
866
 ******************************************************************************/
867
 
868
acpi_status
869
acpi_ut_create_update_state_and_push(union acpi_operand_object *object,
870
                                     u16 action,
871
                                     union acpi_generic_state **state_list)
872
{
873
        union acpi_generic_state *state;
874
 
875
        ACPI_FUNCTION_ENTRY();
876
 
877
        /* Ignore null objects; these are expected */
878
 
879
        if (!object) {
880
                return (AE_OK);
881
        }
882
 
883
        state = acpi_ut_create_update_state(object, action);
884
        if (!state) {
885
                return (AE_NO_MEMORY);
886
        }
887
 
888
        acpi_ut_push_generic_state(state_list, state);
889
        return (AE_OK);
890
}
891
 
892
/*******************************************************************************
893
 *
894
 * FUNCTION:    acpi_ut_walk_package_tree
895
 *
896
 * PARAMETERS:  source_object       - The package to walk
897
 *              target_object       - Target object (if package is being copied)
898
 *              walk_callback       - Called once for each package element
899
 *              Context             - Passed to the callback function
900
 *
901
 * RETURN:      Status
902
 *
903
 * DESCRIPTION: Walk through a package
904
 *
905
 ******************************************************************************/
906
 
907
acpi_status
908
acpi_ut_walk_package_tree(union acpi_operand_object * source_object,
909
                          void *target_object,
910
                          acpi_pkg_callback walk_callback, void *context)
911
{
912
        acpi_status status = AE_OK;
913
        union acpi_generic_state *state_list = NULL;
914
        union acpi_generic_state *state;
915
        u32 this_index;
916
        union acpi_operand_object *this_source_obj;
917
 
918
        ACPI_FUNCTION_TRACE(ut_walk_package_tree);
919
 
920
        state = acpi_ut_create_pkg_state(source_object, target_object, 0);
921
        if (!state) {
922
                return_ACPI_STATUS(AE_NO_MEMORY);
923
        }
924
 
925
        while (state) {
926
 
927
                /* Get one element of the package */
928
 
929
                this_index = state->pkg.index;
930
                this_source_obj = (union acpi_operand_object *)
931
                    state->pkg.source_object->package.elements[this_index];
932
 
933
                /*
934
                 * Check for:
935
                 * 1) An uninitialized package element.  It is completely
936
                 *    legal to declare a package and leave it uninitialized
937
                 * 2) Not an internal object - can be a namespace node instead
938
                 * 3) Any type other than a package.  Packages are handled in else
939
                 *    case below.
940
                 */
941
                if ((!this_source_obj) ||
942
                    (ACPI_GET_DESCRIPTOR_TYPE(this_source_obj) !=
943
                     ACPI_DESC_TYPE_OPERAND)
944
                    || (ACPI_GET_OBJECT_TYPE(this_source_obj) !=
945
                        ACPI_TYPE_PACKAGE)) {
946
                        status =
947
                            walk_callback(ACPI_COPY_TYPE_SIMPLE,
948
                                          this_source_obj, state, context);
949
                        if (ACPI_FAILURE(status)) {
950
                                return_ACPI_STATUS(status);
951
                        }
952
 
953
                        state->pkg.index++;
954
                        while (state->pkg.index >=
955
                               state->pkg.source_object->package.count) {
956
                                /*
957
                                 * We've handled all of the objects at this level,  This means
958
                                 * that we have just completed a package.  That package may
959
                                 * have contained one or more packages itself.
960
                                 *
961
                                 * Delete this state and pop the previous state (package).
962
                                 */
963
                                acpi_ut_delete_generic_state(state);
964
                                state = acpi_ut_pop_generic_state(&state_list);
965
 
966
                                /* Finished when there are no more states */
967
 
968
                                if (!state) {
969
                                        /*
970
                                         * We have handled all of the objects in the top level
971
                                         * package just add the length of the package objects
972
                                         * and exit
973
                                         */
974
                                        return_ACPI_STATUS(AE_OK);
975
                                }
976
 
977
                                /*
978
                                 * Go back up a level and move the index past the just
979
                                 * completed package object.
980
                                 */
981
                                state->pkg.index++;
982
                        }
983
                } else {
984
                        /* This is a subobject of type package */
985
 
986
                        status =
987
                            walk_callback(ACPI_COPY_TYPE_PACKAGE,
988
                                          this_source_obj, state, context);
989
                        if (ACPI_FAILURE(status)) {
990
                                return_ACPI_STATUS(status);
991
                        }
992
 
993
                        /*
994
                         * Push the current state and create a new one
995
                         * The callback above returned a new target package object.
996
                         */
997
                        acpi_ut_push_generic_state(&state_list, state);
998
                        state = acpi_ut_create_pkg_state(this_source_obj,
999
                                                         state->pkg.
1000
                                                         this_target_obj, 0);
1001
                        if (!state) {
1002
                                return_ACPI_STATUS(AE_NO_MEMORY);
1003
                        }
1004
                }
1005
        }
1006
 
1007
        /* We should never get here */
1008
 
1009
        return_ACPI_STATUS(AE_AML_INTERNAL);
1010
}
1011
 
1012
/*******************************************************************************
1013
 *
1014
 * FUNCTION:    acpi_ut_error, acpi_ut_warning, acpi_ut_info
1015
 *
1016
 * PARAMETERS:  module_name         - Caller's module name (for error output)
1017
 *              line_number         - Caller's line number (for error output)
1018
 *              Format              - Printf format string + additional args
1019
 *
1020
 * RETURN:      None
1021
 *
1022
 * DESCRIPTION: Print message with module/line/version info
1023
 *
1024
 ******************************************************************************/
1025
 
1026
void ACPI_INTERNAL_VAR_XFACE
1027
acpi_ut_error(char *module_name, u32 line_number, char *format, ...)
1028
{
1029
        va_list args;
1030
 
1031
        acpi_os_printf("ACPI Error (%s-%04d): ", module_name, line_number);
1032
 
1033
        va_start(args, format);
1034
        acpi_os_vprintf(format, args);
1035
        acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
1036
}
1037
 
1038
void ACPI_INTERNAL_VAR_XFACE
1039
acpi_ut_exception(char *module_name,
1040
                  u32 line_number, acpi_status status, char *format, ...)
1041
{
1042
        va_list args;
1043
 
1044
        acpi_os_printf("ACPI Exception (%s-%04d): %s, ", module_name,
1045
                       line_number, acpi_format_exception(status));
1046
 
1047
        va_start(args, format);
1048
        acpi_os_vprintf(format, args);
1049
        acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
1050
}
1051
 
1052
EXPORT_SYMBOL(acpi_ut_exception);
1053
 
1054
void ACPI_INTERNAL_VAR_XFACE
1055
acpi_ut_warning(char *module_name, u32 line_number, char *format, ...)
1056
{
1057
        va_list args;
1058
 
1059
        acpi_os_printf("ACPI Warning (%s-%04d): ", module_name, line_number);
1060
 
1061
        va_start(args, format);
1062
        acpi_os_vprintf(format, args);
1063
        acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
1064
}
1065
 
1066
void ACPI_INTERNAL_VAR_XFACE
1067
acpi_ut_info(char *module_name, u32 line_number, char *format, ...)
1068
{
1069
        va_list args;
1070
 
1071
        /*
1072
         * Removed module_name, line_number, and acpica version, not needed
1073
         * for info output
1074
         */
1075
        acpi_os_printf("ACPI: ");
1076
 
1077
        va_start(args, format);
1078
        acpi_os_vprintf(format, args);
1079
        acpi_os_printf("\n");
1080
}

powered by: WebSVN 2.1.0

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