ACPI: ACPICA 20060608
[sfrench/cifs-2.6.git] / drivers / acpi / utilities / utmutex.c
1 /*******************************************************************************
2  *
3  * Module Name: utmutex - local mutex support
4  *
5  ******************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2006, 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 <acpi/acpi.h>
45
46 #define _COMPONENT          ACPI_UTILITIES
47 ACPI_MODULE_NAME("utmutex")
48
49 /* Local prototypes */
50 static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id);
51
52 static acpi_status acpi_ut_delete_mutex(acpi_mutex_handle mutex_id);
53
54 /*******************************************************************************
55  *
56  * FUNCTION:    acpi_ut_mutex_initialize
57  *
58  * PARAMETERS:  None.
59  *
60  * RETURN:      Status
61  *
62  * DESCRIPTION: Create the system mutex objects.
63  *
64  ******************************************************************************/
65
66 acpi_status acpi_ut_mutex_initialize(void)
67 {
68         u32 i;
69         acpi_status status;
70
71         ACPI_FUNCTION_TRACE(ut_mutex_initialize);
72
73         /*
74          * Create each of the predefined mutex objects
75          */
76         for (i = 0; i < ACPI_NUM_MUTEX; i++) {
77                 status = acpi_ut_create_mutex(i);
78                 if (ACPI_FAILURE(status)) {
79                         return_ACPI_STATUS(status);
80                 }
81         }
82
83         /* Create the spinlocks for use at interrupt level */
84
85         status = acpi_os_create_lock(&acpi_gbl_gpe_lock);
86         if (ACPI_FAILURE(status)) {
87                 return_ACPI_STATUS(status);
88         }
89
90         status = acpi_os_create_lock(&acpi_gbl_hardware_lock);
91         return_ACPI_STATUS(status);
92 }
93
94 /*******************************************************************************
95  *
96  * FUNCTION:    acpi_ut_mutex_terminate
97  *
98  * PARAMETERS:  None.
99  *
100  * RETURN:      None.
101  *
102  * DESCRIPTION: Delete all of the system mutex objects.
103  *
104  ******************************************************************************/
105
106 void acpi_ut_mutex_terminate(void)
107 {
108         u32 i;
109
110         ACPI_FUNCTION_TRACE(ut_mutex_terminate);
111
112         /*
113          * Delete each predefined mutex object
114          */
115         for (i = 0; i < ACPI_NUM_MUTEX; i++) {
116                 (void)acpi_ut_delete_mutex(i);
117         }
118
119         /* Delete the spinlocks */
120
121         acpi_os_delete_lock(acpi_gbl_gpe_lock);
122         acpi_os_delete_lock(acpi_gbl_hardware_lock);
123         return_VOID;
124 }
125
126 /*******************************************************************************
127  *
128  * FUNCTION:    acpi_ut_create_mutex
129  *
130  * PARAMETERS:  mutex_iD        - ID of the mutex to be created
131  *
132  * RETURN:      Status
133  *
134  * DESCRIPTION: Create a mutex object.
135  *
136  ******************************************************************************/
137
138 static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id)
139 {
140         acpi_status status = AE_OK;
141
142         ACPI_FUNCTION_TRACE_U32(ut_create_mutex, mutex_id);
143
144         if (mutex_id > ACPI_MAX_MUTEX) {
145                 return_ACPI_STATUS(AE_BAD_PARAMETER);
146         }
147
148         if (!acpi_gbl_mutex_info[mutex_id].mutex) {
149                 status = acpi_os_create_semaphore(1, 1,
150                                                   &acpi_gbl_mutex_info
151                                                   [mutex_id].mutex);
152                 acpi_gbl_mutex_info[mutex_id].thread_id =
153                     ACPI_MUTEX_NOT_ACQUIRED;
154                 acpi_gbl_mutex_info[mutex_id].use_count = 0;
155         }
156
157         return_ACPI_STATUS(status);
158 }
159
160 /*******************************************************************************
161  *
162  * FUNCTION:    acpi_ut_delete_mutex
163  *
164  * PARAMETERS:  mutex_iD        - ID of the mutex to be deleted
165  *
166  * RETURN:      Status
167  *
168  * DESCRIPTION: Delete a mutex object.
169  *
170  ******************************************************************************/
171
172 static acpi_status acpi_ut_delete_mutex(acpi_mutex_handle mutex_id)
173 {
174         acpi_status status;
175
176         ACPI_FUNCTION_TRACE_U32(ut_delete_mutex, mutex_id);
177
178         if (mutex_id > ACPI_MAX_MUTEX) {
179                 return_ACPI_STATUS(AE_BAD_PARAMETER);
180         }
181
182         status = acpi_os_delete_semaphore(acpi_gbl_mutex_info[mutex_id].mutex);
183
184         acpi_gbl_mutex_info[mutex_id].mutex = NULL;
185         acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
186
187         return_ACPI_STATUS(status);
188 }
189
190 /*******************************************************************************
191  *
192  * FUNCTION:    acpi_ut_acquire_mutex
193  *
194  * PARAMETERS:  mutex_iD        - ID of the mutex to be acquired
195  *
196  * RETURN:      Status
197  *
198  * DESCRIPTION: Acquire a mutex object.
199  *
200  ******************************************************************************/
201
202 acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
203 {
204         acpi_status status;
205         acpi_thread_id this_thread_id;
206
207         ACPI_FUNCTION_NAME(ut_acquire_mutex);
208
209         if (mutex_id > ACPI_MAX_MUTEX) {
210                 return (AE_BAD_PARAMETER);
211         }
212
213         this_thread_id = acpi_os_get_thread_id();
214
215 #ifdef ACPI_MUTEX_DEBUG
216         {
217                 u32 i;
218                 /*
219                  * Mutex debug code, for internal debugging only.
220                  *
221                  * Deadlock prevention.  Check if this thread owns any mutexes of value
222                  * greater than or equal to this one.  If so, the thread has violated
223                  * the mutex ordering rule.  This indicates a coding error somewhere in
224                  * the ACPI subsystem code.
225                  */
226                 for (i = mutex_id; i < ACPI_MAX_MUTEX; i++) {
227                         if (acpi_gbl_mutex_info[i].thread_id == this_thread_id) {
228                                 if (i == mutex_id) {
229                                         ACPI_ERROR((AE_INFO,
230                                                     "Mutex [%s] already acquired by this thread [%X]",
231                                                     acpi_ut_get_mutex_name
232                                                     (mutex_id),
233                                                     this_thread_id));
234
235                                         return (AE_ALREADY_ACQUIRED);
236                                 }
237
238                                 ACPI_ERROR((AE_INFO,
239                                             "Invalid acquire order: Thread %X owns [%s], wants [%s]",
240                                             this_thread_id,
241                                             acpi_ut_get_mutex_name(i),
242                                             acpi_ut_get_mutex_name(mutex_id)));
243
244                                 return (AE_ACQUIRE_DEADLOCK);
245                         }
246                 }
247         }
248 #endif
249
250         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
251                           "Thread %X attempting to acquire Mutex [%s]\n",
252                           this_thread_id, acpi_ut_get_mutex_name(mutex_id)));
253
254         status = acpi_os_wait_semaphore(acpi_gbl_mutex_info[mutex_id].mutex,
255                                         1, ACPI_WAIT_FOREVER);
256         if (ACPI_SUCCESS(status)) {
257                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
258                                   "Thread %X acquired Mutex [%s]\n",
259                                   this_thread_id,
260                                   acpi_ut_get_mutex_name(mutex_id)));
261
262                 acpi_gbl_mutex_info[mutex_id].use_count++;
263                 acpi_gbl_mutex_info[mutex_id].thread_id = this_thread_id;
264         } else {
265                 ACPI_EXCEPTION((AE_INFO, status,
266                                 "Thread %X could not acquire Mutex [%X]",
267                                 this_thread_id, mutex_id));
268         }
269
270         return (status);
271 }
272
273 /*******************************************************************************
274  *
275  * FUNCTION:    acpi_ut_release_mutex
276  *
277  * PARAMETERS:  mutex_iD        - ID of the mutex to be released
278  *
279  * RETURN:      Status
280  *
281  * DESCRIPTION: Release a mutex object.
282  *
283  ******************************************************************************/
284
285 acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
286 {
287         acpi_status status;
288         acpi_thread_id this_thread_id;
289
290         ACPI_FUNCTION_NAME(ut_release_mutex);
291
292         this_thread_id = acpi_os_get_thread_id();
293         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
294                           "Thread %X releasing Mutex [%s]\n", this_thread_id,
295                           acpi_ut_get_mutex_name(mutex_id)));
296
297         if (mutex_id > ACPI_MAX_MUTEX) {
298                 return (AE_BAD_PARAMETER);
299         }
300
301         /*
302          * Mutex must be acquired in order to release it!
303          */
304         if (acpi_gbl_mutex_info[mutex_id].thread_id == ACPI_MUTEX_NOT_ACQUIRED) {
305                 ACPI_ERROR((AE_INFO,
306                             "Mutex [%X] is not acquired, cannot release",
307                             mutex_id));
308
309                 return (AE_NOT_ACQUIRED);
310         }
311 #ifdef ACPI_MUTEX_DEBUG
312         {
313                 u32 i;
314                 /*
315                  * Mutex debug code, for internal debugging only.
316                  *
317                  * Deadlock prevention.  Check if this thread owns any mutexes of value
318                  * greater than this one.  If so, the thread has violated the mutex
319                  * ordering rule.  This indicates a coding error somewhere in
320                  * the ACPI subsystem code.
321                  */
322                 for (i = mutex_id; i < ACPI_MAX_MUTEX; i++) {
323                         if (acpi_gbl_mutex_info[i].thread_id == this_thread_id) {
324                                 if (i == mutex_id) {
325                                         continue;
326                                 }
327
328                                 ACPI_ERROR((AE_INFO,
329                                             "Invalid release order: owns [%s], releasing [%s]",
330                                             acpi_ut_get_mutex_name(i),
331                                             acpi_ut_get_mutex_name(mutex_id)));
332
333                                 return (AE_RELEASE_DEADLOCK);
334                         }
335                 }
336         }
337 #endif
338
339         /* Mark unlocked FIRST */
340
341         acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
342
343         status =
344             acpi_os_signal_semaphore(acpi_gbl_mutex_info[mutex_id].mutex, 1);
345
346         if (ACPI_FAILURE(status)) {
347                 ACPI_EXCEPTION((AE_INFO, status,
348                                 "Thread %X could not release Mutex [%X]",
349                                 this_thread_id, mutex_id));
350         } else {
351                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
352                                   "Thread %X released Mutex [%s]\n",
353                                   this_thread_id,
354                                   acpi_ut_get_mutex_name(mutex_id)));
355         }
356
357         return (status);
358 }