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