xref: /linux/drivers/acpi/acpica/utxface.c (revision b889fcf63cb62e7fdb7816565e28f44dbe4a76a5)
1 /******************************************************************************
2  *
3  * Module Name: utxface - External interfaces, miscellaneous utility functions
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2012, 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 #include <linux/export.h>
45 #include <acpi/acpi.h>
46 #include "accommon.h"
47 #include "acevents.h"
48 #include "acnamesp.h"
49 #include "acdebug.h"
50 #include "actables.h"
51 #include "acinterp.h"
52 
53 #define _COMPONENT          ACPI_UTILITIES
54 ACPI_MODULE_NAME("utxface")
55 
56 /*******************************************************************************
57  *
58  * FUNCTION:    acpi_terminate
59  *
60  * PARAMETERS:  None
61  *
62  * RETURN:      Status
63  *
64  * DESCRIPTION: Shutdown the ACPICA subsystem and release all resources.
65  *
66  ******************************************************************************/
67 acpi_status acpi_terminate(void)
68 {
69 	acpi_status status;
70 
71 	ACPI_FUNCTION_TRACE(acpi_terminate);
72 
73 	/* Just exit if subsystem is already shutdown */
74 
75 	if (acpi_gbl_shutdown) {
76 		ACPI_ERROR((AE_INFO, "ACPI Subsystem is already terminated"));
77 		return_ACPI_STATUS(AE_OK);
78 	}
79 
80 	/* Subsystem appears active, go ahead and shut it down */
81 
82 	acpi_gbl_shutdown = TRUE;
83 	acpi_gbl_startup_flags = 0;
84 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n"));
85 
86 	/* Terminate the AML Debugger if present */
87 
88 	ACPI_DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = TRUE);
89 
90 	/* Shutdown and free all resources */
91 
92 	acpi_ut_subsystem_shutdown();
93 
94 	/* Free the mutex objects */
95 
96 	acpi_ut_mutex_terminate();
97 
98 #ifdef ACPI_DEBUGGER
99 
100 	/* Shut down the debugger */
101 
102 	acpi_db_terminate();
103 #endif
104 
105 	/* Now we can shutdown the OS-dependent layer */
106 
107 	status = acpi_os_terminate();
108 	return_ACPI_STATUS(status);
109 }
110 
111 ACPI_EXPORT_SYMBOL(acpi_terminate)
112 
113 #ifndef ACPI_ASL_COMPILER
114 #ifdef ACPI_FUTURE_USAGE
115 /*******************************************************************************
116  *
117  * FUNCTION:    acpi_subsystem_status
118  *
119  * PARAMETERS:  None
120  *
121  * RETURN:      Status of the ACPI subsystem
122  *
123  * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
124  *              before making any other calls, to ensure the subsystem
125  *              initialized successfully.
126  *
127  ******************************************************************************/
128 acpi_status acpi_subsystem_status(void)
129 {
130 
131 	if (acpi_gbl_startup_flags & ACPI_INITIALIZED_OK) {
132 		return (AE_OK);
133 	} else {
134 		return (AE_ERROR);
135 	}
136 }
137 
138 ACPI_EXPORT_SYMBOL(acpi_subsystem_status)
139 
140 /*******************************************************************************
141  *
142  * FUNCTION:    acpi_get_system_info
143  *
144  * PARAMETERS:  out_buffer      - A buffer to receive the resources for the
145  *                                device
146  *
147  * RETURN:      status          - the status of the call
148  *
149  * DESCRIPTION: This function is called to get information about the current
150  *              state of the ACPI subsystem. It will return system information
151  *              in the out_buffer.
152  *
153  *              If the function fails an appropriate status will be returned
154  *              and the value of out_buffer is undefined.
155  *
156  ******************************************************************************/
157 acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer)
158 {
159 	struct acpi_system_info *info_ptr;
160 	acpi_status status;
161 
162 	ACPI_FUNCTION_TRACE(acpi_get_system_info);
163 
164 	/* Parameter validation */
165 
166 	status = acpi_ut_validate_buffer(out_buffer);
167 	if (ACPI_FAILURE(status)) {
168 		return_ACPI_STATUS(status);
169 	}
170 
171 	/* Validate/Allocate/Clear caller buffer */
172 
173 	status =
174 	    acpi_ut_initialize_buffer(out_buffer,
175 				      sizeof(struct acpi_system_info));
176 	if (ACPI_FAILURE(status)) {
177 		return_ACPI_STATUS(status);
178 	}
179 
180 	/*
181 	 * Populate the return buffer
182 	 */
183 	info_ptr = (struct acpi_system_info *)out_buffer->pointer;
184 
185 	info_ptr->acpi_ca_version = ACPI_CA_VERSION;
186 
187 	/* System flags (ACPI capabilities) */
188 
189 	info_ptr->flags = ACPI_SYS_MODE_ACPI;
190 
191 	/* Timer resolution - 24 or 32 bits  */
192 
193 	if (acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER) {
194 		info_ptr->timer_resolution = 24;
195 	} else {
196 		info_ptr->timer_resolution = 32;
197 	}
198 
199 	/* Clear the reserved fields */
200 
201 	info_ptr->reserved1 = 0;
202 	info_ptr->reserved2 = 0;
203 
204 	/* Current debug levels */
205 
206 	info_ptr->debug_layer = acpi_dbg_layer;
207 	info_ptr->debug_level = acpi_dbg_level;
208 
209 	return_ACPI_STATUS(AE_OK);
210 }
211 
212 ACPI_EXPORT_SYMBOL(acpi_get_system_info)
213 
214 /*****************************************************************************
215  *
216  * FUNCTION:    acpi_install_initialization_handler
217  *
218  * PARAMETERS:  handler             - Callback procedure
219  *              function            - Not (currently) used, see below
220  *
221  * RETURN:      Status
222  *
223  * DESCRIPTION: Install an initialization handler
224  *
225  * TBD: When a second function is added, must save the Function also.
226  *
227  ****************************************************************************/
228 acpi_status
229 acpi_install_initialization_handler(acpi_init_handler handler, u32 function)
230 {
231 
232 	if (!handler) {
233 		return (AE_BAD_PARAMETER);
234 	}
235 
236 	if (acpi_gbl_init_handler) {
237 		return (AE_ALREADY_EXISTS);
238 	}
239 
240 	acpi_gbl_init_handler = handler;
241 	return (AE_OK);
242 }
243 
244 ACPI_EXPORT_SYMBOL(acpi_install_initialization_handler)
245 #endif				/*  ACPI_FUTURE_USAGE  */
246 
247 /*****************************************************************************
248  *
249  * FUNCTION:    acpi_purge_cached_objects
250  *
251  * PARAMETERS:  None
252  *
253  * RETURN:      Status
254  *
255  * DESCRIPTION: Empty all caches (delete the cached objects)
256  *
257  ****************************************************************************/
258 acpi_status acpi_purge_cached_objects(void)
259 {
260 	ACPI_FUNCTION_TRACE(acpi_purge_cached_objects);
261 
262 	(void)acpi_os_purge_cache(acpi_gbl_state_cache);
263 	(void)acpi_os_purge_cache(acpi_gbl_operand_cache);
264 	(void)acpi_os_purge_cache(acpi_gbl_ps_node_cache);
265 	(void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache);
266 
267 	return_ACPI_STATUS(AE_OK);
268 }
269 
270 ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects)
271 
272 /*****************************************************************************
273  *
274  * FUNCTION:    acpi_install_interface
275  *
276  * PARAMETERS:  interface_name      - The interface to install
277  *
278  * RETURN:      Status
279  *
280  * DESCRIPTION: Install an _OSI interface to the global list
281  *
282  ****************************************************************************/
283 acpi_status acpi_install_interface(acpi_string interface_name)
284 {
285 	acpi_status status;
286 	struct acpi_interface_info *interface_info;
287 
288 	/* Parameter validation */
289 
290 	if (!interface_name || (ACPI_STRLEN(interface_name) == 0)) {
291 		return (AE_BAD_PARAMETER);
292 	}
293 
294 	(void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER);
295 
296 	/* Check if the interface name is already in the global list */
297 
298 	interface_info = acpi_ut_get_interface(interface_name);
299 	if (interface_info) {
300 		/*
301 		 * The interface already exists in the list. This is OK if the
302 		 * interface has been marked invalid -- just clear the bit.
303 		 */
304 		if (interface_info->flags & ACPI_OSI_INVALID) {
305 			interface_info->flags &= ~ACPI_OSI_INVALID;
306 			status = AE_OK;
307 		} else {
308 			status = AE_ALREADY_EXISTS;
309 		}
310 	} else {
311 		/* New interface name, install into the global list */
312 
313 		status = acpi_ut_install_interface(interface_name);
314 	}
315 
316 	acpi_os_release_mutex(acpi_gbl_osi_mutex);
317 	return (status);
318 }
319 
320 ACPI_EXPORT_SYMBOL(acpi_install_interface)
321 
322 /*****************************************************************************
323  *
324  * FUNCTION:    acpi_remove_interface
325  *
326  * PARAMETERS:  interface_name      - The interface to remove
327  *
328  * RETURN:      Status
329  *
330  * DESCRIPTION: Remove an _OSI interface from the global list
331  *
332  ****************************************************************************/
333 acpi_status acpi_remove_interface(acpi_string interface_name)
334 {
335 	acpi_status status;
336 
337 	/* Parameter validation */
338 
339 	if (!interface_name || (ACPI_STRLEN(interface_name) == 0)) {
340 		return (AE_BAD_PARAMETER);
341 	}
342 
343 	(void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER);
344 
345 	status = acpi_ut_remove_interface(interface_name);
346 
347 	acpi_os_release_mutex(acpi_gbl_osi_mutex);
348 	return (status);
349 }
350 
351 ACPI_EXPORT_SYMBOL(acpi_remove_interface)
352 
353 /*****************************************************************************
354  *
355  * FUNCTION:    acpi_install_interface_handler
356  *
357  * PARAMETERS:  handler             - The _OSI interface handler to install
358  *                                    NULL means "remove existing handler"
359  *
360  * RETURN:      Status
361  *
362  * DESCRIPTION: Install a handler for the predefined _OSI ACPI method.
363  *              invoked during execution of the internal implementation of
364  *              _OSI. A NULL handler simply removes any existing handler.
365  *
366  ****************************************************************************/
367 acpi_status acpi_install_interface_handler(acpi_interface_handler handler)
368 {
369 	acpi_status status = AE_OK;
370 
371 	(void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER);
372 
373 	if (handler && acpi_gbl_interface_handler) {
374 		status = AE_ALREADY_EXISTS;
375 	} else {
376 		acpi_gbl_interface_handler = handler;
377 	}
378 
379 	acpi_os_release_mutex(acpi_gbl_osi_mutex);
380 	return (status);
381 }
382 
383 ACPI_EXPORT_SYMBOL(acpi_install_interface_handler)
384 
385 /*****************************************************************************
386  *
387  * FUNCTION:    acpi_check_address_range
388  *
389  * PARAMETERS:  space_id            - Address space ID
390  *              address             - Start address
391  *              length              - Length
392  *              warn                - TRUE if warning on overlap desired
393  *
394  * RETURN:      Count of the number of conflicts detected.
395  *
396  * DESCRIPTION: Check if the input address range overlaps any of the
397  *              ASL operation region address ranges.
398  *
399  ****************************************************************************/
400 u32
401 acpi_check_address_range(acpi_adr_space_type space_id,
402 			 acpi_physical_address address,
403 			 acpi_size length, u8 warn)
404 {
405 	u32 overlaps;
406 	acpi_status status;
407 
408 	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
409 	if (ACPI_FAILURE(status)) {
410 		return (0);
411 	}
412 
413 	overlaps = acpi_ut_check_address_range(space_id, address,
414 					       (u32)length, warn);
415 
416 	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
417 	return (overlaps);
418 }
419 
420 ACPI_EXPORT_SYMBOL(acpi_check_address_range)
421 #endif				/* !ACPI_ASL_COMPILER */
422 /*******************************************************************************
423  *
424  * FUNCTION:    acpi_decode_pld_buffer
425  *
426  * PARAMETERS:  in_buffer           - Buffer returned by _PLD method
427  *              length              - Length of the in_buffer
428  *              return_buffer       - Where the decode buffer is returned
429  *
430  * RETURN:      Status and the decoded _PLD buffer. User must deallocate
431  *              the buffer via ACPI_FREE.
432  *
433  * DESCRIPTION: Decode the bit-packed buffer returned by the _PLD method into
434  *              a local struct that is much more useful to an ACPI driver.
435  *
436  ******************************************************************************/
437 acpi_status
438 acpi_decode_pld_buffer(u8 *in_buffer,
439 		       acpi_size length, struct acpi_pld_info ** return_buffer)
440 {
441 	struct acpi_pld_info *pld_info;
442 	u32 *buffer = ACPI_CAST_PTR(u32, in_buffer);
443 	u32 dword;
444 
445 	/* Parameter validation */
446 
447 	if (!in_buffer || !return_buffer || (length < 16)) {
448 		return (AE_BAD_PARAMETER);
449 	}
450 
451 	pld_info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pld_info));
452 	if (!pld_info) {
453 		return (AE_NO_MEMORY);
454 	}
455 
456 	/* First 32-bit DWord */
457 
458 	ACPI_MOVE_32_TO_32(&dword, &buffer[0]);
459 	pld_info->revision = ACPI_PLD_GET_REVISION(&dword);
460 	pld_info->ignore_color = ACPI_PLD_GET_IGNORE_COLOR(&dword);
461 	pld_info->color = ACPI_PLD_GET_COLOR(&dword);
462 
463 	/* Second 32-bit DWord */
464 
465 	ACPI_MOVE_32_TO_32(&dword, &buffer[1]);
466 	pld_info->width = ACPI_PLD_GET_WIDTH(&dword);
467 	pld_info->height = ACPI_PLD_GET_HEIGHT(&dword);
468 
469 	/* Third 32-bit DWord */
470 
471 	ACPI_MOVE_32_TO_32(&dword, &buffer[2]);
472 	pld_info->user_visible = ACPI_PLD_GET_USER_VISIBLE(&dword);
473 	pld_info->dock = ACPI_PLD_GET_DOCK(&dword);
474 	pld_info->lid = ACPI_PLD_GET_LID(&dword);
475 	pld_info->panel = ACPI_PLD_GET_PANEL(&dword);
476 	pld_info->vertical_position = ACPI_PLD_GET_VERTICAL(&dword);
477 	pld_info->horizontal_position = ACPI_PLD_GET_HORIZONTAL(&dword);
478 	pld_info->shape = ACPI_PLD_GET_SHAPE(&dword);
479 	pld_info->group_orientation = ACPI_PLD_GET_ORIENTATION(&dword);
480 	pld_info->group_token = ACPI_PLD_GET_TOKEN(&dword);
481 	pld_info->group_position = ACPI_PLD_GET_POSITION(&dword);
482 	pld_info->bay = ACPI_PLD_GET_BAY(&dword);
483 
484 	/* Fourth 32-bit DWord */
485 
486 	ACPI_MOVE_32_TO_32(&dword, &buffer[3]);
487 	pld_info->ejectable = ACPI_PLD_GET_EJECTABLE(&dword);
488 	pld_info->ospm_eject_required = ACPI_PLD_GET_OSPM_EJECT(&dword);
489 	pld_info->cabinet_number = ACPI_PLD_GET_CABINET(&dword);
490 	pld_info->card_cage_number = ACPI_PLD_GET_CARD_CAGE(&dword);
491 	pld_info->reference = ACPI_PLD_GET_REFERENCE(&dword);
492 	pld_info->rotation = ACPI_PLD_GET_ROTATION(&dword);
493 	pld_info->order = ACPI_PLD_GET_ORDER(&dword);
494 
495 	if (length >= ACPI_PLD_BUFFER_SIZE) {
496 
497 		/* Fifth 32-bit DWord (Revision 2 of _PLD) */
498 
499 		ACPI_MOVE_32_TO_32(&dword, &buffer[4]);
500 		pld_info->vertical_offset = ACPI_PLD_GET_VERT_OFFSET(&dword);
501 		pld_info->horizontal_offset = ACPI_PLD_GET_HORIZ_OFFSET(&dword);
502 	}
503 
504 	*return_buffer = pld_info;
505 	return (AE_OK);
506 }
507 
508 ACPI_EXPORT_SYMBOL(acpi_decode_pld_buffer)
509