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