← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/acpi/acpica/acutils.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/acpi/acpica/acutils.h
 
1
/******************************************************************************
 
2
 *
 
3
 * Name: acutils.h -- prototypes for the common (subsystem-wide) procedures
 
4
 *
 
5
 *****************************************************************************/
 
6
 
 
7
/*
 
8
 * Copyright (C) 2000 - 2011, Intel Corp.
 
9
 * All rights reserved.
 
10
 *
 
11
 * Redistribution and use in source and binary forms, with or without
 
12
 * modification, are permitted provided that the following conditions
 
13
 * are met:
 
14
 * 1. Redistributions of source code must retain the above copyright
 
15
 *    notice, this list of conditions, and the following disclaimer,
 
16
 *    without modification.
 
17
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 
18
 *    substantially similar to the "NO WARRANTY" disclaimer below
 
19
 *    ("Disclaimer") and any redistribution must be conditioned upon
 
20
 *    including a substantially similar Disclaimer requirement for further
 
21
 *    binary redistribution.
 
22
 * 3. Neither the names of the above-listed copyright holders nor the names
 
23
 *    of any contributors may be used to endorse or promote products derived
 
24
 *    from this software without specific prior written permission.
 
25
 *
 
26
 * Alternatively, this software may be distributed under the terms of the
 
27
 * GNU General Public License ("GPL") version 2 as published by the Free
 
28
 * Software Foundation.
 
29
 *
 
30
 * NO WARRANTY
 
31
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
32
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
33
 * LIMITED TO, THE IMPLIED WARRANTIES OF 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
#ifndef _ACUTILS_H
 
45
#define _ACUTILS_H
 
46
 
 
47
extern const u8 acpi_gbl_resource_aml_sizes[];
 
48
 
 
49
/* Strings used by the disassembler and debugger resource dump routines */
 
50
 
 
51
#if defined(ACPI_DISASSEMBLER) || defined (ACPI_DEBUGGER)
 
52
 
 
53
extern const char *acpi_gbl_bm_decode[];
 
54
extern const char *acpi_gbl_config_decode[];
 
55
extern const char *acpi_gbl_consume_decode[];
 
56
extern const char *acpi_gbl_dec_decode[];
 
57
extern const char *acpi_gbl_he_decode[];
 
58
extern const char *acpi_gbl_io_decode[];
 
59
extern const char *acpi_gbl_ll_decode[];
 
60
extern const char *acpi_gbl_max_decode[];
 
61
extern const char *acpi_gbl_mem_decode[];
 
62
extern const char *acpi_gbl_min_decode[];
 
63
extern const char *acpi_gbl_mtp_decode[];
 
64
extern const char *acpi_gbl_rng_decode[];
 
65
extern const char *acpi_gbl_rw_decode[];
 
66
extern const char *acpi_gbl_shr_decode[];
 
67
extern const char *acpi_gbl_siz_decode[];
 
68
extern const char *acpi_gbl_trs_decode[];
 
69
extern const char *acpi_gbl_ttp_decode[];
 
70
extern const char *acpi_gbl_typ_decode[];
 
71
#endif
 
72
 
 
73
/* Types for Resource descriptor entries */
 
74
 
 
75
#define ACPI_INVALID_RESOURCE           0
 
76
#define ACPI_FIXED_LENGTH               1
 
77
#define ACPI_VARIABLE_LENGTH            2
 
78
#define ACPI_SMALL_VARIABLE_LENGTH      3
 
79
 
 
80
typedef
 
81
acpi_status(*acpi_walk_aml_callback) (u8 * aml,
 
82
                                      u32 length,
 
83
                                      u32 offset,
 
84
                                      u8 resource_index, void **context);
 
85
 
 
86
typedef
 
87
acpi_status(*acpi_pkg_callback) (u8 object_type,
 
88
                                 union acpi_operand_object * source_object,
 
89
                                 union acpi_generic_state * state,
 
90
                                 void *context);
 
91
 
 
92
struct acpi_pkg_info {
 
93
        u8 *free_space;
 
94
        acpi_size length;
 
95
        u32 object_space;
 
96
        u32 num_packages;
 
97
};
 
98
 
 
99
#define REF_INCREMENT       (u16) 0
 
100
#define REF_DECREMENT       (u16) 1
 
101
#define REF_FORCE_DELETE    (u16) 2
 
102
 
 
103
/* acpi_ut_dump_buffer */
 
104
 
 
105
#define DB_BYTE_DISPLAY     1
 
106
#define DB_WORD_DISPLAY     2
 
107
#define DB_DWORD_DISPLAY    4
 
108
#define DB_QWORD_DISPLAY    8
 
109
 
 
110
/*
 
111
 * utglobal - Global data structures and procedures
 
112
 */
 
113
acpi_status acpi_ut_init_globals(void);
 
114
 
 
115
#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
 
116
 
 
117
char *acpi_ut_get_mutex_name(u32 mutex_id);
 
118
 
 
119
const char *acpi_ut_get_notify_name(u32 notify_value);
 
120
 
 
121
#endif
 
122
 
 
123
char *acpi_ut_get_type_name(acpi_object_type type);
 
124
 
 
125
char *acpi_ut_get_node_name(void *object);
 
126
 
 
127
char *acpi_ut_get_descriptor_name(void *object);
 
128
 
 
129
const char *acpi_ut_get_reference_name(union acpi_operand_object *object);
 
130
 
 
131
char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc);
 
132
 
 
133
char *acpi_ut_get_region_name(u8 space_id);
 
134
 
 
135
char *acpi_ut_get_event_name(u32 event_id);
 
136
 
 
137
char acpi_ut_hex_to_ascii_char(u64 integer, u32 position);
 
138
 
 
139
u8 acpi_ut_valid_object_type(acpi_object_type type);
 
140
 
 
141
/*
 
142
 * utinit - miscellaneous initialization and shutdown
 
143
 */
 
144
acpi_status acpi_ut_hardware_initialize(void);
 
145
 
 
146
void acpi_ut_subsystem_shutdown(void);
 
147
 
 
148
/*
 
149
 * utclib - Local implementations of C library functions
 
150
 */
 
151
#ifndef ACPI_USE_SYSTEM_CLIBRARY
 
152
 
 
153
acpi_size acpi_ut_strlen(const char *string);
 
154
 
 
155
char *acpi_ut_strcpy(char *dst_string, const char *src_string);
 
156
 
 
157
char *acpi_ut_strncpy(char *dst_string,
 
158
                      const char *src_string, acpi_size count);
 
159
 
 
160
int acpi_ut_memcmp(const char *buffer1, const char *buffer2, acpi_size count);
 
161
 
 
162
int acpi_ut_strncmp(const char *string1, const char *string2, acpi_size count);
 
163
 
 
164
int acpi_ut_strcmp(const char *string1, const char *string2);
 
165
 
 
166
char *acpi_ut_strcat(char *dst_string, const char *src_string);
 
167
 
 
168
char *acpi_ut_strncat(char *dst_string,
 
169
                      const char *src_string, acpi_size count);
 
170
 
 
171
u32 acpi_ut_strtoul(const char *string, char **terminator, u32 base);
 
172
 
 
173
char *acpi_ut_strstr(char *string1, char *string2);
 
174
 
 
175
void *acpi_ut_memcpy(void *dest, const void *src, acpi_size count);
 
176
 
 
177
void *acpi_ut_memset(void *dest, u8 value, acpi_size count);
 
178
 
 
179
int acpi_ut_to_upper(int c);
 
180
 
 
181
int acpi_ut_to_lower(int c);
 
182
 
 
183
extern const u8 _acpi_ctype[];
 
184
 
 
185
#define _ACPI_XA     0x00       /* extra alphabetic - not supported */
 
186
#define _ACPI_XS     0x40       /* extra space */
 
187
#define _ACPI_BB     0x00       /* BEL, BS, etc. - not supported */
 
188
#define _ACPI_CN     0x20       /* CR, FF, HT, NL, VT */
 
189
#define _ACPI_DI     0x04       /* '0'-'9' */
 
190
#define _ACPI_LO     0x02       /* 'a'-'z' */
 
191
#define _ACPI_PU     0x10       /* punctuation */
 
192
#define _ACPI_SP     0x08       /* space */
 
193
#define _ACPI_UP     0x01       /* 'A'-'Z' */
 
194
#define _ACPI_XD     0x80       /* '0'-'9', 'A'-'F', 'a'-'f' */
 
195
 
 
196
#define ACPI_IS_DIGIT(c)  (_acpi_ctype[(unsigned char)(c)] & (_ACPI_DI))
 
197
#define ACPI_IS_SPACE(c)  (_acpi_ctype[(unsigned char)(c)] & (_ACPI_SP))
 
198
#define ACPI_IS_XDIGIT(c) (_acpi_ctype[(unsigned char)(c)] & (_ACPI_XD))
 
199
#define ACPI_IS_UPPER(c)  (_acpi_ctype[(unsigned char)(c)] & (_ACPI_UP))
 
200
#define ACPI_IS_LOWER(c)  (_acpi_ctype[(unsigned char)(c)] & (_ACPI_LO))
 
201
#define ACPI_IS_PRINT(c)  (_acpi_ctype[(unsigned char)(c)] & (_ACPI_LO | _ACPI_UP | _ACPI_DI | _ACPI_SP | _ACPI_PU))
 
202
#define ACPI_IS_ALPHA(c)  (_acpi_ctype[(unsigned char)(c)] & (_ACPI_LO | _ACPI_UP))
 
203
 
 
204
#endif                          /* ACPI_USE_SYSTEM_CLIBRARY */
 
205
 
 
206
/*
 
207
 * utcopy - Object construction and conversion interfaces
 
208
 */
 
209
acpi_status
 
210
acpi_ut_build_simple_object(union acpi_operand_object *obj,
 
211
                            union acpi_object *user_obj,
 
212
                            u8 * data_space, u32 * buffer_space_used);
 
213
 
 
214
acpi_status
 
215
acpi_ut_build_package_object(union acpi_operand_object *obj,
 
216
                             u8 * buffer, u32 * space_used);
 
217
 
 
218
acpi_status
 
219
acpi_ut_copy_iobject_to_eobject(union acpi_operand_object *obj,
 
220
                                struct acpi_buffer *ret_buffer);
 
221
 
 
222
acpi_status
 
223
acpi_ut_copy_eobject_to_iobject(union acpi_object *obj,
 
224
                                union acpi_operand_object **internal_obj);
 
225
 
 
226
acpi_status
 
227
acpi_ut_copy_isimple_to_isimple(union acpi_operand_object *source_obj,
 
228
                                union acpi_operand_object *dest_obj);
 
229
 
 
230
acpi_status
 
231
acpi_ut_copy_iobject_to_iobject(union acpi_operand_object *source_desc,
 
232
                                union acpi_operand_object **dest_desc,
 
233
                                struct acpi_walk_state *walk_state);
 
234
 
 
235
/*
 
236
 * utcreate - Object creation
 
237
 */
 
238
acpi_status
 
239
acpi_ut_update_object_reference(union acpi_operand_object *object, u16 action);
 
240
 
 
241
/*
 
242
 * utdebug - Debug interfaces
 
243
 */
 
244
void acpi_ut_init_stack_ptr_trace(void);
 
245
 
 
246
void acpi_ut_track_stack_ptr(void);
 
247
 
 
248
void
 
249
acpi_ut_trace(u32 line_number,
 
250
              const char *function_name,
 
251
              const char *module_name, u32 component_id);
 
252
 
 
253
void
 
254
acpi_ut_trace_ptr(u32 line_number,
 
255
                  const char *function_name,
 
256
                  const char *module_name, u32 component_id, void *pointer);
 
257
 
 
258
void
 
259
acpi_ut_trace_u32(u32 line_number,
 
260
                  const char *function_name,
 
261
                  const char *module_name, u32 component_id, u32 integer);
 
262
 
 
263
void
 
264
acpi_ut_trace_str(u32 line_number,
 
265
                  const char *function_name,
 
266
                  const char *module_name, u32 component_id, char *string);
 
267
 
 
268
void
 
269
acpi_ut_exit(u32 line_number,
 
270
             const char *function_name,
 
271
             const char *module_name, u32 component_id);
 
272
 
 
273
void
 
274
acpi_ut_status_exit(u32 line_number,
 
275
                    const char *function_name,
 
276
                    const char *module_name,
 
277
                    u32 component_id, acpi_status status);
 
278
 
 
279
void
 
280
acpi_ut_value_exit(u32 line_number,
 
281
                   const char *function_name,
 
282
                   const char *module_name, u32 component_id, u64 value);
 
283
 
 
284
void
 
285
acpi_ut_ptr_exit(u32 line_number,
 
286
                 const char *function_name,
 
287
                 const char *module_name, u32 component_id, u8 *ptr);
 
288
 
 
289
void acpi_ut_dump_buffer(u8 * buffer, u32 count, u32 display, u32 component_id);
 
290
 
 
291
void acpi_ut_dump_buffer2(u8 * buffer, u32 count, u32 display);
 
292
 
 
293
void acpi_ut_report_error(char *module_name, u32 line_number);
 
294
 
 
295
void acpi_ut_report_info(char *module_name, u32 line_number);
 
296
 
 
297
void acpi_ut_report_warning(char *module_name, u32 line_number);
 
298
 
 
299
/*
 
300
 * utdelete - Object deletion and reference counts
 
301
 */
 
302
void acpi_ut_add_reference(union acpi_operand_object *object);
 
303
 
 
304
void acpi_ut_remove_reference(union acpi_operand_object *object);
 
305
 
 
306
void acpi_ut_delete_internal_package_object(union acpi_operand_object *object);
 
307
 
 
308
void acpi_ut_delete_internal_simple_object(union acpi_operand_object *object);
 
309
 
 
310
void acpi_ut_delete_internal_object_list(union acpi_operand_object **obj_list);
 
311
 
 
312
/*
 
313
 * uteval - object evaluation
 
314
 */
 
315
acpi_status
 
316
acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node,
 
317
                        char *path,
 
318
                        u32 expected_return_btypes,
 
319
                        union acpi_operand_object **return_desc);
 
320
 
 
321
acpi_status
 
322
acpi_ut_evaluate_numeric_object(char *object_name,
 
323
                                struct acpi_namespace_node *device_node,
 
324
                                u64 *value);
 
325
 
 
326
acpi_status
 
327
acpi_ut_execute_STA(struct acpi_namespace_node *device_node, u32 *status_flags);
 
328
 
 
329
acpi_status
 
330
acpi_ut_execute_power_methods(struct acpi_namespace_node *device_node,
 
331
                              const char **method_names,
 
332
                              u8 method_count, u8 *out_values);
 
333
 
 
334
/*
 
335
 * utids - device ID support
 
336
 */
 
337
acpi_status
 
338
acpi_ut_execute_HID(struct acpi_namespace_node *device_node,
 
339
                    struct acpica_device_id **return_id);
 
340
 
 
341
acpi_status
 
342
acpi_ut_execute_UID(struct acpi_namespace_node *device_node,
 
343
                    struct acpica_device_id **return_id);
 
344
 
 
345
acpi_status
 
346
acpi_ut_execute_CID(struct acpi_namespace_node *device_node,
 
347
                    struct acpica_device_id_list **return_cid_list);
 
348
 
 
349
/*
 
350
 * utlock - reader/writer locks
 
351
 */
 
352
acpi_status acpi_ut_create_rw_lock(struct acpi_rw_lock *lock);
 
353
 
 
354
void acpi_ut_delete_rw_lock(struct acpi_rw_lock *lock);
 
355
 
 
356
acpi_status acpi_ut_acquire_read_lock(struct acpi_rw_lock *lock);
 
357
 
 
358
acpi_status acpi_ut_release_read_lock(struct acpi_rw_lock *lock);
 
359
 
 
360
acpi_status acpi_ut_acquire_write_lock(struct acpi_rw_lock *lock);
 
361
 
 
362
void acpi_ut_release_write_lock(struct acpi_rw_lock *lock);
 
363
 
 
364
/*
 
365
 * utobject - internal object create/delete/cache routines
 
366
 */
 
367
union acpi_operand_object *acpi_ut_create_internal_object_dbg(const char
 
368
                                                              *module_name,
 
369
                                                              u32 line_number,
 
370
                                                              u32 component_id,
 
371
                                                              acpi_object_type
 
372
                                                              type);
 
373
 
 
374
void *acpi_ut_allocate_object_desc_dbg(const char *module_name,
 
375
                                       u32 line_number, u32 component_id);
 
376
 
 
377
#define acpi_ut_create_internal_object(t) acpi_ut_create_internal_object_dbg (_acpi_module_name,__LINE__,_COMPONENT,t)
 
378
#define acpi_ut_allocate_object_desc()  acpi_ut_allocate_object_desc_dbg (_acpi_module_name,__LINE__,_COMPONENT)
 
379
 
 
380
void acpi_ut_delete_object_desc(union acpi_operand_object *object);
 
381
 
 
382
u8 acpi_ut_valid_internal_object(void *object);
 
383
 
 
384
union acpi_operand_object *acpi_ut_create_package_object(u32 count);
 
385
 
 
386
union acpi_operand_object *acpi_ut_create_integer_object(u64 value);
 
387
 
 
388
union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size);
 
389
 
 
390
union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size);
 
391
 
 
392
acpi_status
 
393
acpi_ut_get_object_size(union acpi_operand_object *obj, acpi_size * obj_length);
 
394
 
 
395
/*
 
396
 * utosi - Support for the _OSI predefined control method
 
397
 */
 
398
acpi_status acpi_ut_initialize_interfaces(void);
 
399
 
 
400
void acpi_ut_interface_terminate(void);
 
401
 
 
402
acpi_status acpi_ut_install_interface(acpi_string interface_name);
 
403
 
 
404
acpi_status acpi_ut_remove_interface(acpi_string interface_name);
 
405
 
 
406
struct acpi_interface_info *acpi_ut_get_interface(acpi_string interface_name);
 
407
 
 
408
acpi_status acpi_ut_osi_implementation(struct acpi_walk_state *walk_state);
 
409
 
 
410
/*
 
411
 * utstate - Generic state creation/cache routines
 
412
 */
 
413
void
 
414
acpi_ut_push_generic_state(union acpi_generic_state **list_head,
 
415
                           union acpi_generic_state *state);
 
416
 
 
417
union acpi_generic_state *acpi_ut_pop_generic_state(union acpi_generic_state
 
418
                                                    **list_head);
 
419
 
 
420
union acpi_generic_state *acpi_ut_create_generic_state(void);
 
421
 
 
422
struct acpi_thread_state *acpi_ut_create_thread_state(void);
 
423
 
 
424
union acpi_generic_state *acpi_ut_create_update_state(union acpi_operand_object
 
425
                                                      *object, u16 action);
 
426
 
 
427
union acpi_generic_state *acpi_ut_create_pkg_state(void *internal_object,
 
428
                                                   void *external_object,
 
429
                                                   u16 index);
 
430
 
 
431
acpi_status
 
432
acpi_ut_create_update_state_and_push(union acpi_operand_object *object,
 
433
                                     u16 action,
 
434
                                     union acpi_generic_state **state_list);
 
435
 
 
436
#ifdef  ACPI_FUTURE_USAGE
 
437
acpi_status
 
438
acpi_ut_create_pkg_state_and_push(void *internal_object,
 
439
                                  void *external_object,
 
440
                                  u16 index,
 
441
                                  union acpi_generic_state **state_list);
 
442
#endif                          /* ACPI_FUTURE_USAGE */
 
443
 
 
444
union acpi_generic_state *acpi_ut_create_control_state(void);
 
445
 
 
446
void acpi_ut_delete_generic_state(union acpi_generic_state *state);
 
447
 
 
448
/*
 
449
 * utmath
 
450
 */
 
451
acpi_status
 
452
acpi_ut_divide(u64 in_dividend,
 
453
               u64 in_divisor, u64 *out_quotient, u64 *out_remainder);
 
454
 
 
455
acpi_status
 
456
acpi_ut_short_divide(u64 in_dividend,
 
457
                     u32 divisor, u64 *out_quotient, u32 *out_remainder);
 
458
 
 
459
/*
 
460
 * utmisc
 
461
 */
 
462
const char *acpi_ut_validate_exception(acpi_status status);
 
463
 
 
464
u8 acpi_ut_is_pci_root_bridge(char *id);
 
465
 
 
466
u8 acpi_ut_is_aml_table(struct acpi_table_header *table);
 
467
 
 
468
acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id);
 
469
 
 
470
void acpi_ut_release_owner_id(acpi_owner_id * owner_id);
 
471
 
 
472
acpi_status
 
473
acpi_ut_walk_package_tree(union acpi_operand_object *source_object,
 
474
                          void *target_object,
 
475
                          acpi_pkg_callback walk_callback, void *context);
 
476
 
 
477
void acpi_ut_strupr(char *src_string);
 
478
 
 
479
void acpi_ut_print_string(char *string, u8 max_length);
 
480
 
 
481
u8 acpi_ut_valid_acpi_name(u32 name);
 
482
 
 
483
acpi_name acpi_ut_repair_name(char *name);
 
484
 
 
485
u8 acpi_ut_valid_acpi_char(char character, u32 position);
 
486
 
 
487
acpi_status acpi_ut_strtoul64(char *string, u32 base, u64 * ret_integer);
 
488
 
 
489
/* Values for Base above (16=Hex, 10=Decimal) */
 
490
 
 
491
#define ACPI_ANY_BASE        0
 
492
 
 
493
u32 acpi_ut_dword_byte_swap(u32 value);
 
494
 
 
495
void acpi_ut_set_integer_width(u8 revision);
 
496
 
 
497
#ifdef ACPI_DEBUG_OUTPUT
 
498
void
 
499
acpi_ut_display_init_pathname(u8 type,
 
500
                              struct acpi_namespace_node *obj_handle,
 
501
                              char *path);
 
502
#endif
 
503
 
 
504
/*
 
505
 * utresrc
 
506
 */
 
507
acpi_status
 
508
acpi_ut_walk_aml_resources(u8 * aml,
 
509
                           acpi_size aml_length,
 
510
                           acpi_walk_aml_callback user_function,
 
511
                           void **context);
 
512
 
 
513
acpi_status acpi_ut_validate_resource(void *aml, u8 * return_index);
 
514
 
 
515
u32 acpi_ut_get_descriptor_length(void *aml);
 
516
 
 
517
u16 acpi_ut_get_resource_length(void *aml);
 
518
 
 
519
u8 acpi_ut_get_resource_header_length(void *aml);
 
520
 
 
521
u8 acpi_ut_get_resource_type(void *aml);
 
522
 
 
523
acpi_status
 
524
acpi_ut_get_resource_end_tag(union acpi_operand_object *obj_desc,
 
525
                             u8 ** end_tag);
 
526
 
 
527
/*
 
528
 * utmutex - mutex support
 
529
 */
 
530
acpi_status acpi_ut_mutex_initialize(void);
 
531
 
 
532
void acpi_ut_mutex_terminate(void);
 
533
 
 
534
acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id);
 
535
 
 
536
acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id);
 
537
 
 
538
/*
 
539
 * utalloc - memory allocation and object caching
 
540
 */
 
541
acpi_status acpi_ut_create_caches(void);
 
542
 
 
543
acpi_status acpi_ut_delete_caches(void);
 
544
 
 
545
acpi_status acpi_ut_validate_buffer(struct acpi_buffer *buffer);
 
546
 
 
547
acpi_status
 
548
acpi_ut_initialize_buffer(struct acpi_buffer *buffer,
 
549
                          acpi_size required_length);
 
550
 
 
551
void *acpi_ut_allocate(acpi_size size,
 
552
                       u32 component, const char *module, u32 line);
 
553
 
 
554
void *acpi_ut_allocate_zeroed(acpi_size size,
 
555
                              u32 component, const char *module, u32 line);
 
556
 
 
557
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
 
558
void *acpi_ut_allocate_and_track(acpi_size size,
 
559
                                 u32 component, const char *module, u32 line);
 
560
 
 
561
void *acpi_ut_allocate_zeroed_and_track(acpi_size size,
 
562
                                        u32 component,
 
563
                                        const char *module, u32 line);
 
564
 
 
565
void
 
566
acpi_ut_free_and_track(void *address,
 
567
                       u32 component, const char *module, u32 line);
 
568
 
 
569
#ifdef  ACPI_FUTURE_USAGE
 
570
void acpi_ut_dump_allocation_info(void);
 
571
#endif                          /* ACPI_FUTURE_USAGE */
 
572
 
 
573
void acpi_ut_dump_allocations(u32 component, const char *module);
 
574
 
 
575
acpi_status
 
576
acpi_ut_create_list(char *list_name,
 
577
                    u16 object_size, struct acpi_memory_list **return_cache);
 
578
 
 
579
#endif                          /* ACPI_DBG_TRACK_ALLOCATIONS */
 
580
 
 
581
/*
 
582
 * utxferror - various error/warning output functions
 
583
 */
 
584
void ACPI_INTERNAL_VAR_XFACE
 
585
acpi_ut_predefined_warning(const char *module_name,
 
586
                           u32 line_number,
 
587
                           char *pathname,
 
588
                           u8 node_flags, const char *format, ...);
 
589
 
 
590
void ACPI_INTERNAL_VAR_XFACE
 
591
acpi_ut_predefined_info(const char *module_name,
 
592
                        u32 line_number,
 
593
                        char *pathname, u8 node_flags, const char *format, ...);
 
594
 
 
595
void
 
596
acpi_ut_namespace_error(const char *module_name,
 
597
                        u32 line_number,
 
598
                        const char *internal_name, acpi_status lookup_status);
 
599
 
 
600
void
 
601
acpi_ut_method_error(const char *module_name,
 
602
                     u32 line_number,
 
603
                     const char *message,
 
604
                     struct acpi_namespace_node *node,
 
605
                     const char *path, acpi_status lookup_status);
 
606
 
 
607
#endif                          /* _ACUTILS_H */