?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make HZ_TO_STD macro name lowercase.
[linux-2.6/linux-mips.git] / drivers / acpi / common / cmdelete.c
blobfc32e3cec83f557c3c5c49b4c9763e796e821c77
1
2 /******************************************************************************
3 *
4 * Module Name: cmdelete - object deletion and reference count utilities
5 *
6 *****************************************************************************/
7
8 /*
9 * Copyright (C) 2000 R. Byron Moore
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */
25
26
27 #include "acpi.h"
28 #include "interp.h"
29 #include "namesp.h"
30 #include "tables.h"
31 #include "parser.h"
32
33 #define _COMPONENT MISCELLANEOUS
34 MODULE_NAME ("cmdelete");
35
36
37 /******************************************************************************
38 *
39 * FUNCTION: Acpi_cm_delete_internal_obj
40 *
41 * PARAMETERS: *Object - Pointer to the list to be deleted
42 *
43 * RETURN: None
44 *
45 * DESCRIPTION: Low level object deletion, after reference counts have been
46 * updated (All reference counts, including sub-objects!)
47 *
48 ******************************************************************************/
49
50 void
51 acpi_cm_delete_internal_obj (
52 ACPI_OBJECT_INTERNAL *object)
53 {
54 void *obj_pointer = NULL;
55
56
57 if (!object) {
58 return;
59 }
60
61 /*
62 * Must delete or free any pointers within the object that are not
63 * actual ACPI objects (for example, a raw buffer pointer).
64 */
65
66 switch (object->common.type)
67 {
68
69 case ACPI_TYPE_STRING:
70
71 /* Free the actual string buffer */
72
73 obj_pointer = object->string.pointer;
74 break;
75
76
77 case ACPI_TYPE_BUFFER:
78
79 /* Free the actual buffer */
80
81 obj_pointer = object->buffer.pointer;
82 break;
83
84
85 case ACPI_TYPE_PACKAGE:
86
87 /*
88 * Elements of the package are not handled here, they are deleted
89 * separately
90 */
91
92 /* Free the (variable length) element pointer array */
93
94 obj_pointer = object->package.elements;
95 break;
96
97
98 case ACPI_TYPE_MUTEX:
99
100 acpi_os_delete_semaphore (object->mutex.semaphore);
101 break;
102
103
104 case ACPI_TYPE_EVENT:
105
106 acpi_os_delete_semaphore (object->event.semaphore);
107 object->event.semaphore = NULL;
108 break;
109
110
111 case ACPI_TYPE_METHOD:
112
113 /* Delete parse tree if it exists */
114
115 if (object->method.parser_op) {
116 acpi_ps_delete_parse_tree (object->method.parser_op);
117 object->method.parser_op = NULL;
118 }
119
120 /* Delete semaphore if it exists */
121
122 if (object->method.semaphore) {
123 acpi_os_delete_semaphore (object->method.semaphore);
124 object->method.semaphore = NULL;
125 }
126
127 break;
128
129
130 default:
131 break;
132 }
133
134
135 /*
136 * Delete any allocated memory found above
137 */
138
139 if (obj_pointer) {
140 if (!acpi_tb_system_table_pointer (obj_pointer)) {
141 acpi_cm_free (obj_pointer);
142 }
143 }
144
145
146 /* Only delete the object if it was dynamically allocated */
147
148
149 if (!(object->common.flags & AO_STATIC_ALLOCATION)) {
150 acpi_cm_delete_object_desc (object);
151
152 }
153
154 return;
155 }
156
157
158 /******************************************************************************
159 *
160 * FUNCTION: Acpi_cm_delete_internal_object_list
161 *
162 * PARAMETERS: *Obj_list - Pointer to the list to be deleted
163 *
164 * RETURN: Status - the status of the call
165 *
166 * DESCRIPTION: This function deletes an internal object list, including both
167 * simple objects and package objects
168 *
169 ******************************************************************************/
170
171 ACPI_STATUS
172 acpi_cm_delete_internal_object_list (
173 ACPI_OBJECT_INTERNAL **obj_list)
174 {
175 ACPI_OBJECT_INTERNAL **internal_obj;
176
177
178 /* Walk the null-terminated internal list */
179
180 for (internal_obj = obj_list; *internal_obj; internal_obj++) {
181 /*
182 * Check for a package
183 * Simple objects are simply stored in the array and do not
184 * need to be deleted separately.
185 */
186
187 if (IS_THIS_OBJECT_TYPE ((*internal_obj), ACPI_TYPE_PACKAGE)) {
188 /* Delete the package */
189
190 /*
191 * TBD: [Investigate] This might not be the right thing to do,
192 * depending on how the internal package object was allocated!!!
193 */
194 acpi_cm_delete_internal_obj (*internal_obj);
195 }
196
197 }
198
199 /* Free the combined parameter pointer list and object array */
200
201 acpi_cm_free (obj_list);
202
203 return (AE_OK);
204 }
205
206
207 /******************************************************************************
208 *
209 * FUNCTION: Acpi_cm_update_ref_count
210 *
211 * PARAMETERS: *Object - Object whose ref count is to be updated
212 * Count - Current ref count
213 * Action - What to do
214 *
215 * RETURN: New ref count
216 *
217 * DESCRIPTION: Modify the ref count and return it.
218 *
219 ******************************************************************************/
220
221 void
222 acpi_cm_update_ref_count (
223 ACPI_OBJECT_INTERNAL *object,
224 s32 action)
225 {
226 u16 count;
227 u16 new_count;
228
229
230 if (!object) {
231 return;
232 }
233
234
235 count = object->common.reference_count;
236 new_count = count;
237
238 /*
239 * Reference count action (increment, decrement, or force delete)
240 */
241
242 switch (action)
243 {
244
245 case REF_INCREMENT:
246
247 new_count++;
248 object->common.reference_count = new_count;
249
250 break;
251
252
253 case REF_DECREMENT:
254
255 if (count < 1) {
256 new_count = 0;
257 }
258
259 else {
260 new_count--;
261
262 }
263
264
265 object->common.reference_count = new_count;
266 if (new_count == 0) {
267 acpi_cm_delete_internal_obj (object);
268 }
269
270 break;
271
272
273 case REF_FORCE_DELETE:
274
275 new_count = 0;
276 object->common.reference_count = new_count;
277 acpi_cm_delete_internal_obj (object);
278 break;
279
280
281 default:
282
283 break;
284 }
285
286
287 /*
288 * Sanity check the reference count, for debug purposes only.
289 * (A deleted object will have a huge reference count)
290 */
291
292
293 return;
294 }
295
296
297 /******************************************************************************
298 *
299 * FUNCTION: Acpi_cm_update_object_reference
300 *
301 * PARAMETERS: *Object - Increment ref count for this object
302 * and all sub-objects
303 * Action - Either REF_INCREMENT or REF_DECREMENT or
304 * REF_FORCE_DELETE
305 *
306 * RETURN: Status
307 *
308 * DESCRIPTION: Increment the object reference count
309 *
310 * Object references are incremented when:
311 * 1) An object is added as a value in an Name Table Entry (NTE)
312 * 2) An object is copied (all subobjects must be incremented)
313 *
314 * Object references are decremented when:
315 * 1) An object is removed from an NTE
316 *
317 ******************************************************************************/
318
319 ACPI_STATUS
320 acpi_cm_update_object_reference (
321 ACPI_OBJECT_INTERNAL *object,
322 u16 action)
323 {
324 ACPI_STATUS status;
325 u32 i;
326 ACPI_OBJECT_INTERNAL *next;
327 ACPI_OBJECT_INTERNAL *new;
328 ACPI_GENERIC_STATE *state_list = NULL;
329 ACPI_GENERIC_STATE *state;
330
331
332 /* Ignore a null object ptr */
333
334 if (!object) {
335 return (AE_OK);
336 }
337
338
339 /*
340 * Make sure that this isn't a namespace handle or an AML pointer
341 */
342
343 if (VALID_DESCRIPTOR_TYPE (object, ACPI_DESC_TYPE_NAMED)) {
344 return (AE_OK);
345 }
346
347 if (acpi_tb_system_table_pointer (object)) {
348 return (AE_OK);
349 }
350
351
352 state = acpi_cm_create_update_state (object, action);
353
354 while (state) {
355
356 object = state->update.object;
357 action = state->update.value;
358 acpi_cm_delete_generic_state (state);
359
360 /*
361 * All sub-objects must have their reference count incremented also.
362 * Different object types have different subobjects.
363 */
364 switch (object->common.type)
365 {
366
367 case ACPI_TYPE_DEVICE:
368
369 status = acpi_cm_create_update_state_and_push (object->device.addr_handler,
370 action, &state_list);
371 if (ACPI_FAILURE (status)) {
372 return (status);
373 }
374
375 acpi_cm_update_ref_count (object->device.sys_handler, action);
376 acpi_cm_update_ref_count (object->device.drv_handler, action);
377 break;
378
379
380 case INTERNAL_TYPE_ADDRESS_HANDLER:
381
382 /* Must walk list of address handlers */
383
384 next = object->addr_handler.link;
385 while (next) {
386 new = next->addr_handler.link;
387 acpi_cm_update_ref_count (next, action);
388
389 next = new;
390 }
391 break;
392
393
394 case ACPI_TYPE_PACKAGE:
395
396 /*
397 * We must update all the sub-objects of the package
398 * (Each of whom may have their own sub-objects, etc.
399 */
400 for (i = 0; i < object->package.count; i++) {
401 /*
402 * Push each element onto the stack for later processing.
403 * Note: There can be null elements within the package,
404 * these are simply ignored
405 */
406
407 status =
408 acpi_cm_create_update_state_and_push (object->package.elements[i],
409 action, &state_list);
410 if (ACPI_FAILURE (status)) {
411 return (status);
412 }
413 }
414 break;
415
416
417 case ACPI_TYPE_FIELD_UNIT:
418
419 status =
420 acpi_cm_create_update_state_and_push (object->field_unit.container,
421 action, &state_list);
422 if (ACPI_FAILURE (status)) {
423 return (status);
424 }
425 break;
426
427
428 case INTERNAL_TYPE_DEF_FIELD:
429
430 status =
431 acpi_cm_create_update_state_and_push (object->field.container,
432 action, &state_list);
433 if (ACPI_FAILURE (status)) {
434 return (status);
435 }
436 break;
437
438
439 case INTERNAL_TYPE_BANK_FIELD:
440
441 status =
442 acpi_cm_create_update_state_and_push (object->bank_field.bank_select,
443 action, &state_list);
444 if (ACPI_FAILURE (status)) {
445 return (status);
446 }
447
448 status =
449 acpi_cm_create_update_state_and_push (object->bank_field.container,
450 action, &state_list);
451 if (ACPI_FAILURE (status)) {
452 return (status);
453 }
454 break;
455
456
457 case ACPI_TYPE_REGION:
458
459 acpi_cm_update_ref_count (object->region.method, action);
460
461 /* TBD: [Investigate]
462 Acpi_cm_update_ref_count (Object->Region.Addr_handler, Action);
463 */
464 /*
465 Status =
466 Acpi_cm_create_update_state_and_push (Object->Region.Addr_handler,
467 Action, &State_list);
468 if (ACPI_FAILURE (Status)) {
469 return (Status);
470 }
471 */
472 break;
473
474
475 case INTERNAL_TYPE_REFERENCE:
476
477 break;
478 }
479
480
481 /*
482 * Now we can update the count in the main object. This can only
483 * happen after we update the sub-objects in case this causes the
484 * main object to be deleted.
485 */
486
487 acpi_cm_update_ref_count (object, action);
488
489
490 /* Move on to the next object to be updated */
491
492 state = acpi_cm_pop_generic_state (&state_list);
493 }
494
495
496 return (AE_OK);
497 }
498
499
500 /******************************************************************************
501 *
502 * FUNCTION: Acpi_cm_add_reference
503 *
504 * PARAMETERS: *Object - Object whose reference count is to be
505 * incremented
506 *
507 * RETURN: None
508 *
509 * DESCRIPTION: Add one reference to an ACPI object
510 *
511 ******************************************************************************/
512
513 void
514 acpi_cm_add_reference (
515 ACPI_OBJECT_INTERNAL *object)
516 {
517
518
519 /*
520 * Ensure that we have a valid object
521 */
522
523 if (!acpi_cm_valid_internal_object (object)) {
524 return;
525 }
526
527
528 /*
529 * We have a valid ACPI internal object, now increment the reference count
530 */
531
532 acpi_cm_update_object_reference (object, REF_INCREMENT);
533
534 return;
535 }
536
537
538 /******************************************************************************
539 *
540 * FUNCTION: Acpi_cm_remove_reference
541 *
542 * PARAMETERS: *Object - Object whose ref count will be decremented
543 *
544 * RETURN: None
545 *
546 * DESCRIPTION: Decrement the reference count of an ACPI internal object
547 *
548 ******************************************************************************/
549
550 void
551 acpi_cm_remove_reference (
552 ACPI_OBJECT_INTERNAL *object)
553 {
554
555
556 /*
557 * Ensure that we have a valid object
558 */
559
560 if (!acpi_cm_valid_internal_object (object)) {
561 return;
562 }
563
564 /*
565 * Decrement the reference count, and only actually delete the object
566 * if the reference count becomes 0. (Must also decrement the ref count
567 * of all subobjects!)
568 */
569
570 acpi_cm_update_object_reference (object, REF_DECREMENT);
571
572 /*
573 * If the reference count has reached zero,
574 * delete the object and all sub-objects contained within it
575 */
576 /*
577 if (Object->Common.Reference_count == 0) {
578 Acpi_cm_delete_internal_obj (Object);
579 }
580 */
581 return;
582 }
583
584
Mirror of the linux-mips.org kernel tree