1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44#include <acpi/acpi.h>
45#include "accommon.h"
46#include "acnamesp.h"
47
48#define _COMPONENT ACPI_UTILITIES
49ACPI_MODULE_NAME("utobject")
50
51
52static acpi_status
53acpi_ut_get_simple_object_size(union acpi_operand_object *obj,
54 acpi_size * obj_length);
55
56static acpi_status
57acpi_ut_get_package_object_size(union acpi_operand_object *obj,
58 acpi_size * obj_length);
59
60static acpi_status
61acpi_ut_get_element_length(u8 object_type,
62 union acpi_operand_object *source_object,
63 union acpi_generic_state *state, void *context);
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86union acpi_operand_object *acpi_ut_create_internal_object_dbg(const char
87 *module_name,
88 u32 line_number,
89 u32 component_id,
90 acpi_object_type
91 type)
92{
93 union acpi_operand_object *object;
94 union acpi_operand_object *second_object;
95
96 ACPI_FUNCTION_TRACE_STR(ut_create_internal_object_dbg,
97 acpi_ut_get_type_name(type));
98
99
100
101 object =
102 acpi_ut_allocate_object_desc_dbg(module_name, line_number,
103 component_id);
104 if (!object) {
105 return_PTR(NULL);
106 }
107
108 switch (type) {
109 case ACPI_TYPE_REGION:
110 case ACPI_TYPE_BUFFER_FIELD:
111 case ACPI_TYPE_LOCAL_BANK_FIELD:
112
113
114
115 second_object = acpi_ut_allocate_object_desc_dbg(module_name,
116 line_number,
117 component_id);
118 if (!second_object) {
119 acpi_ut_delete_object_desc(object);
120 return_PTR(NULL);
121 }
122
123 second_object->common.type = ACPI_TYPE_LOCAL_EXTRA;
124 second_object->common.reference_count = 1;
125
126
127
128 object->common.next_object = second_object;
129 break;
130
131 default:
132
133 break;
134 }
135
136
137
138 object->common.type = (u8) type;
139
140
141
142 object->common.reference_count = 1;
143
144
145
146 return_PTR(object);
147}
148
149
150
151
152
153
154
155
156
157
158
159
160
161union acpi_operand_object *acpi_ut_create_package_object(u32 count)
162{
163 union acpi_operand_object *package_desc;
164 union acpi_operand_object **package_elements;
165
166 ACPI_FUNCTION_TRACE_U32(ut_create_package_object, count);
167
168
169
170 package_desc = acpi_ut_create_internal_object(ACPI_TYPE_PACKAGE);
171 if (!package_desc) {
172 return_PTR(NULL);
173 }
174
175
176
177
178
179 package_elements = ACPI_ALLOCATE_ZEROED(((acpi_size) count +
180 1) * sizeof(void *));
181 if (!package_elements) {
182 acpi_ut_remove_reference(package_desc);
183 return_PTR(NULL);
184 }
185
186 package_desc->package.count = count;
187 package_desc->package.elements = package_elements;
188 return_PTR(package_desc);
189}
190
191
192
193
194
195
196
197
198
199
200
201
202
203union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size)
204{
205 union acpi_operand_object *buffer_desc;
206 u8 *buffer = NULL;
207
208 ACPI_FUNCTION_TRACE_U32(ut_create_buffer_object, buffer_size);
209
210
211
212 buffer_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER);
213 if (!buffer_desc) {
214 return_PTR(NULL);
215 }
216
217
218
219 if (buffer_size > 0) {
220
221
222
223 buffer = ACPI_ALLOCATE_ZEROED(buffer_size);
224 if (!buffer) {
225 ACPI_ERROR((AE_INFO, "Could not allocate size %X",
226 (u32) buffer_size));
227 acpi_ut_remove_reference(buffer_desc);
228 return_PTR(NULL);
229 }
230 }
231
232
233
234 buffer_desc->buffer.flags |= AOPOBJ_DATA_VALID;
235 buffer_desc->buffer.pointer = buffer;
236 buffer_desc->buffer.length = (u32) buffer_size;
237
238
239
240 return_PTR(buffer_desc);
241}
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size)
258{
259 union acpi_operand_object *string_desc;
260 char *string;
261
262 ACPI_FUNCTION_TRACE_U32(ut_create_string_object, string_size);
263
264
265
266 string_desc = acpi_ut_create_internal_object(ACPI_TYPE_STRING);
267 if (!string_desc) {
268 return_PTR(NULL);
269 }
270
271
272
273
274
275 string = ACPI_ALLOCATE_ZEROED(string_size + 1);
276 if (!string) {
277 ACPI_ERROR((AE_INFO, "Could not allocate size %X",
278 (u32) string_size));
279 acpi_ut_remove_reference(string_desc);
280 return_PTR(NULL);
281 }
282
283
284
285 string_desc->string.pointer = string;
286 string_desc->string.length = (u32) string_size;
287
288
289
290 return_PTR(string_desc);
291}
292
293
294
295
296
297
298
299
300
301
302
303
304
305u8 acpi_ut_valid_internal_object(void *object)
306{
307
308 ACPI_FUNCTION_NAME(ut_valid_internal_object);
309
310
311
312 if (!object) {
313 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "**** Null Object Ptr\n"));
314 return (FALSE);
315 }
316
317
318
319 switch (ACPI_GET_DESCRIPTOR_TYPE(object)) {
320 case ACPI_DESC_TYPE_OPERAND:
321
322
323
324 return (TRUE);
325
326 default:
327 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
328 "%p is not not an ACPI operand obj [%s]\n",
329 object, acpi_ut_get_descriptor_name(object)));
330 break;
331 }
332
333 return (FALSE);
334}
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351void *acpi_ut_allocate_object_desc_dbg(const char *module_name,
352 u32 line_number, u32 component_id)
353{
354 union acpi_operand_object *object;
355
356 ACPI_FUNCTION_TRACE(ut_allocate_object_desc_dbg);
357
358 object = acpi_os_acquire_object(acpi_gbl_operand_cache);
359 if (!object) {
360 ACPI_ERROR((module_name, line_number,
361 "Could not allocate an object descriptor"));
362
363 return_PTR(NULL);
364 }
365
366
367
368 memset(object, 0, sizeof(union acpi_operand_object));
369 ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_OPERAND);
370
371 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
372 object, (u32) sizeof(union acpi_operand_object)));
373
374 return_PTR(object);
375}
376
377
378
379
380
381
382
383
384
385
386
387
388
389void acpi_ut_delete_object_desc(union acpi_operand_object *object)
390{
391 ACPI_FUNCTION_TRACE_PTR(ut_delete_object_desc, object);
392
393
394
395 if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
396 ACPI_ERROR((AE_INFO,
397 "%p is not an ACPI Operand object [%s]", object,
398 acpi_ut_get_descriptor_name(object)));
399 return_VOID;
400 }
401
402 (void)acpi_os_release_object(acpi_gbl_operand_cache, object);
403 return_VOID;
404}
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423static acpi_status
424acpi_ut_get_simple_object_size(union acpi_operand_object *internal_object,
425 acpi_size * obj_length)
426{
427 acpi_size length;
428 acpi_size size;
429 acpi_status status = AE_OK;
430
431 ACPI_FUNCTION_TRACE_PTR(ut_get_simple_object_size, internal_object);
432
433
434
435
436
437 if (!internal_object) {
438 *obj_length = sizeof(union acpi_object);
439 return_ACPI_STATUS(AE_OK);
440 }
441
442
443
444 length = sizeof(union acpi_object);
445
446 if (ACPI_GET_DESCRIPTOR_TYPE(internal_object) == ACPI_DESC_TYPE_NAMED) {
447
448
449
450 *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
451 return_ACPI_STATUS(status);
452 }
453
454
455
456
457
458
459
460 switch (internal_object->common.type) {
461 case ACPI_TYPE_STRING:
462
463 length += (acpi_size) internal_object->string.length + 1;
464 break;
465
466 case ACPI_TYPE_BUFFER:
467
468 length += (acpi_size) internal_object->buffer.length;
469 break;
470
471 case ACPI_TYPE_INTEGER:
472 case ACPI_TYPE_PROCESSOR:
473 case ACPI_TYPE_POWER:
474
475
476
477 break;
478
479 case ACPI_TYPE_LOCAL_REFERENCE:
480
481 switch (internal_object->reference.class) {
482 case ACPI_REFCLASS_NAME:
483
484
485
486
487
488 size =
489 acpi_ns_get_pathname_length(internal_object->
490 reference.node);
491 if (!size) {
492 return_ACPI_STATUS(AE_BAD_PARAMETER);
493 }
494
495 length += ACPI_ROUND_UP_TO_NATIVE_WORD(size);
496 break;
497
498 default:
499
500
501
502
503
504
505 ACPI_ERROR((AE_INFO,
506 "Cannot convert to external object - "
507 "unsupported Reference Class [%s] %X in object %p",
508 acpi_ut_get_reference_name(internal_object),
509 internal_object->reference.class,
510 internal_object));
511 status = AE_TYPE;
512 break;
513 }
514 break;
515
516 default:
517
518 ACPI_ERROR((AE_INFO, "Cannot convert to external object - "
519 "unsupported type [%s] %X in object %p",
520 acpi_ut_get_object_type_name(internal_object),
521 internal_object->common.type, internal_object));
522 status = AE_TYPE;
523 break;
524 }
525
526
527
528
529
530
531
532 *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
533 return_ACPI_STATUS(status);
534}
535
536
537
538
539
540
541
542
543
544
545
546
547
548static acpi_status
549acpi_ut_get_element_length(u8 object_type,
550 union acpi_operand_object *source_object,
551 union acpi_generic_state *state, void *context)
552{
553 acpi_status status = AE_OK;
554 struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
555 acpi_size object_space;
556
557 switch (object_type) {
558 case ACPI_COPY_TYPE_SIMPLE:
559
560
561
562
563
564 status =
565 acpi_ut_get_simple_object_size(source_object,
566 &object_space);
567 if (ACPI_FAILURE(status)) {
568 return (status);
569 }
570
571 info->length += object_space;
572 break;
573
574 case ACPI_COPY_TYPE_PACKAGE:
575
576
577
578 info->num_packages++;
579 state->pkg.this_target_obj = NULL;
580 break;
581
582 default:
583
584
585
586 return (AE_BAD_PARAMETER);
587 }
588
589 return (status);
590}
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609static acpi_status
610acpi_ut_get_package_object_size(union acpi_operand_object *internal_object,
611 acpi_size * obj_length)
612{
613 acpi_status status;
614 struct acpi_pkg_info info;
615
616 ACPI_FUNCTION_TRACE_PTR(ut_get_package_object_size, internal_object);
617
618 info.length = 0;
619 info.object_space = 0;
620 info.num_packages = 1;
621
622 status = acpi_ut_walk_package_tree(internal_object, NULL,
623 acpi_ut_get_element_length, &info);
624 if (ACPI_FAILURE(status)) {
625 return_ACPI_STATUS(status);
626 }
627
628
629
630
631
632
633 info.length += ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object)) *
634 (acpi_size) info.num_packages;
635
636
637
638 *obj_length = info.length;
639 return_ACPI_STATUS(status);
640}
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656acpi_status
657acpi_ut_get_object_size(union acpi_operand_object *internal_object,
658 acpi_size * obj_length)
659{
660 acpi_status status;
661
662 ACPI_FUNCTION_ENTRY();
663
664 if ((ACPI_GET_DESCRIPTOR_TYPE(internal_object) ==
665 ACPI_DESC_TYPE_OPERAND)
666 && (internal_object->common.type == ACPI_TYPE_PACKAGE)) {
667 status =
668 acpi_ut_get_package_object_size(internal_object,
669 obj_length);
670 } else {
671 status =
672 acpi_ut_get_simple_object_size(internal_object, obj_length);
673 }
674
675 return (status);
676}
677