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