tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/******************************************************************************
2 *
3 * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2008, 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 <acpi/acpi.h>
45#include <acpi/acevents.h>
46#include <acpi/acnamesp.h>
47#include <acpi/actables.h>
48
49#define _COMPONENT ACPI_EVENTS
50ACPI_MODULE_NAME("evxfevnt")
51
52/*******************************************************************************
53 *
54 * FUNCTION: acpi_enable
55 *
56 * PARAMETERS: None
57 *
58 * RETURN: Status
59 *
60 * DESCRIPTION: Transfers the system into ACPI mode.
61 *
62 ******************************************************************************/
63acpi_status acpi_enable(void)
64{
65 acpi_status status = AE_OK;
66
67 ACPI_FUNCTION_TRACE(acpi_enable);
68
69 /* ACPI tables must be present */
70
71 if (!acpi_tb_tables_loaded()) {
72 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
73 }
74
75 /* Check current mode */
76
77 if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) {
78 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
79 "System is already in ACPI mode\n"));
80 } else {
81 /* Transition to ACPI mode */
82
83 status = acpi_hw_set_mode(ACPI_SYS_MODE_ACPI);
84 if (ACPI_FAILURE(status)) {
85 ACPI_ERROR((AE_INFO,
86 "Could not transition to ACPI mode"));
87 return_ACPI_STATUS(status);
88 }
89
90 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
91 "Transition to ACPI mode successful\n"));
92 }
93
94 return_ACPI_STATUS(status);
95}
96
97ACPI_EXPORT_SYMBOL(acpi_enable)
98
99/*******************************************************************************
100 *
101 * FUNCTION: acpi_disable
102 *
103 * PARAMETERS: None
104 *
105 * RETURN: Status
106 *
107 * DESCRIPTION: Transfers the system into LEGACY (non-ACPI) mode.
108 *
109 ******************************************************************************/
110acpi_status acpi_disable(void)
111{
112 acpi_status status = AE_OK;
113
114 ACPI_FUNCTION_TRACE(acpi_disable);
115
116 if (acpi_hw_get_mode() == ACPI_SYS_MODE_LEGACY) {
117 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
118 "System is already in legacy (non-ACPI) mode\n"));
119 } else {
120 /* Transition to LEGACY mode */
121
122 status = acpi_hw_set_mode(ACPI_SYS_MODE_LEGACY);
123
124 if (ACPI_FAILURE(status)) {
125 ACPI_ERROR((AE_INFO,
126 "Could not exit ACPI mode to legacy mode"));
127 return_ACPI_STATUS(status);
128 }
129
130 ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI mode disabled\n"));
131 }
132
133 return_ACPI_STATUS(status);
134}
135
136ACPI_EXPORT_SYMBOL(acpi_disable)
137
138/*******************************************************************************
139 *
140 * FUNCTION: acpi_enable_event
141 *
142 * PARAMETERS: Event - The fixed eventto be enabled
143 * Flags - Reserved
144 *
145 * RETURN: Status
146 *
147 * DESCRIPTION: Enable an ACPI event (fixed)
148 *
149 ******************************************************************************/
150acpi_status acpi_enable_event(u32 event, u32 flags)
151{
152 acpi_status status = AE_OK;
153 u32 value;
154
155 ACPI_FUNCTION_TRACE(acpi_enable_event);
156
157 /* Decode the Fixed Event */
158
159 if (event > ACPI_EVENT_MAX) {
160 return_ACPI_STATUS(AE_BAD_PARAMETER);
161 }
162
163 /*
164 * Enable the requested fixed event (by writing a one to the
165 * enable register bit)
166 */
167 status =
168 acpi_set_register(acpi_gbl_fixed_event_info[event].
169 enable_register_id, 1);
170 if (ACPI_FAILURE(status)) {
171 return_ACPI_STATUS(status);
172 }
173
174 /* Make sure that the hardware responded */
175
176 status =
177 acpi_get_register(acpi_gbl_fixed_event_info[event].
178 enable_register_id, &value);
179 if (ACPI_FAILURE(status)) {
180 return_ACPI_STATUS(status);
181 }
182
183 if (value != 1) {
184 ACPI_ERROR((AE_INFO,
185 "Could not enable %s event",
186 acpi_ut_get_event_name(event)));
187 return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
188 }
189
190 return_ACPI_STATUS(status);
191}
192
193ACPI_EXPORT_SYMBOL(acpi_enable_event)
194
195/*******************************************************************************
196 *
197 * FUNCTION: acpi_set_gpe_type
198 *
199 * PARAMETERS: gpe_device - Parent GPE Device
200 * gpe_number - GPE level within the GPE block
201 * Type - New GPE type
202 *
203 * RETURN: Status
204 *
205 * DESCRIPTION: Set the type of an individual GPE
206 *
207 ******************************************************************************/
208acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type)
209{
210 acpi_status status = AE_OK;
211 struct acpi_gpe_event_info *gpe_event_info;
212
213 ACPI_FUNCTION_TRACE(acpi_set_gpe_type);
214
215 /* Ensure that we have a valid GPE number */
216
217 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
218 if (!gpe_event_info) {
219 status = AE_BAD_PARAMETER;
220 goto unlock_and_exit;
221 }
222
223 if ((gpe_event_info->flags & ACPI_GPE_TYPE_MASK) == type) {
224 return_ACPI_STATUS(AE_OK);
225 }
226
227 /* Set the new type (will disable GPE if currently enabled) */
228
229 status = acpi_ev_set_gpe_type(gpe_event_info, type);
230
231 unlock_and_exit:
232 return_ACPI_STATUS(status);
233}
234
235ACPI_EXPORT_SYMBOL(acpi_set_gpe_type)
236
237/*******************************************************************************
238 *
239 * FUNCTION: acpi_enable_gpe
240 *
241 * PARAMETERS: gpe_device - Parent GPE Device
242 * gpe_number - GPE level within the GPE block
243 * Flags - Just enable, or also wake enable?
244 * Called from ISR or not
245 *
246 * RETURN: Status
247 *
248 * DESCRIPTION: Enable an ACPI event (general purpose)
249 *
250 ******************************************************************************/
251acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
252{
253 acpi_status status = AE_OK;
254 acpi_cpu_flags flags;
255 struct acpi_gpe_event_info *gpe_event_info;
256
257 ACPI_FUNCTION_TRACE(acpi_enable_gpe);
258
259 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
260
261 /* Ensure that we have a valid GPE number */
262
263 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
264 if (!gpe_event_info) {
265 status = AE_BAD_PARAMETER;
266 goto unlock_and_exit;
267 }
268
269 /* Perform the enable */
270
271 status = acpi_ev_enable_gpe(gpe_event_info, TRUE);
272
273 unlock_and_exit:
274 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
275 return_ACPI_STATUS(status);
276}
277
278ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
279
280/*******************************************************************************
281 *
282 * FUNCTION: acpi_disable_gpe
283 *
284 * PARAMETERS: gpe_device - Parent GPE Device
285 * gpe_number - GPE level within the GPE block
286 * Flags - Just disable, or also wake disable?
287 * Called from ISR or not
288 *
289 * RETURN: Status
290 *
291 * DESCRIPTION: Disable an ACPI event (general purpose)
292 *
293 ******************************************************************************/
294acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
295{
296 acpi_status status = AE_OK;
297 acpi_cpu_flags flags;
298 struct acpi_gpe_event_info *gpe_event_info;
299
300 ACPI_FUNCTION_TRACE(acpi_disable_gpe);
301
302 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
303 /* Ensure that we have a valid GPE number */
304
305 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
306 if (!gpe_event_info) {
307 status = AE_BAD_PARAMETER;
308 goto unlock_and_exit;
309 }
310
311 status = acpi_ev_disable_gpe(gpe_event_info);
312
313unlock_and_exit:
314 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
315 return_ACPI_STATUS(status);
316}
317
318ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
319
320/*******************************************************************************
321 *
322 * FUNCTION: acpi_disable_event
323 *
324 * PARAMETERS: Event - The fixed eventto be enabled
325 * Flags - Reserved
326 *
327 * RETURN: Status
328 *
329 * DESCRIPTION: Disable an ACPI event (fixed)
330 *
331 ******************************************************************************/
332acpi_status acpi_disable_event(u32 event, u32 flags)
333{
334 acpi_status status = AE_OK;
335 u32 value;
336
337 ACPI_FUNCTION_TRACE(acpi_disable_event);
338
339 /* Decode the Fixed Event */
340
341 if (event > ACPI_EVENT_MAX) {
342 return_ACPI_STATUS(AE_BAD_PARAMETER);
343 }
344
345 /*
346 * Disable the requested fixed event (by writing a zero to the
347 * enable register bit)
348 */
349 status =
350 acpi_set_register(acpi_gbl_fixed_event_info[event].
351 enable_register_id, 0);
352 if (ACPI_FAILURE(status)) {
353 return_ACPI_STATUS(status);
354 }
355
356 status =
357 acpi_get_register(acpi_gbl_fixed_event_info[event].
358 enable_register_id, &value);
359 if (ACPI_FAILURE(status)) {
360 return_ACPI_STATUS(status);
361 }
362
363 if (value != 0) {
364 ACPI_ERROR((AE_INFO,
365 "Could not disable %s events",
366 acpi_ut_get_event_name(event)));
367 return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
368 }
369
370 return_ACPI_STATUS(status);
371}
372
373ACPI_EXPORT_SYMBOL(acpi_disable_event)
374
375/*******************************************************************************
376 *
377 * FUNCTION: acpi_clear_event
378 *
379 * PARAMETERS: Event - The fixed event to be cleared
380 *
381 * RETURN: Status
382 *
383 * DESCRIPTION: Clear an ACPI event (fixed)
384 *
385 ******************************************************************************/
386acpi_status acpi_clear_event(u32 event)
387{
388 acpi_status status = AE_OK;
389
390 ACPI_FUNCTION_TRACE(acpi_clear_event);
391
392 /* Decode the Fixed Event */
393
394 if (event > ACPI_EVENT_MAX) {
395 return_ACPI_STATUS(AE_BAD_PARAMETER);
396 }
397
398 /*
399 * Clear the requested fixed event (By writing a one to the
400 * status register bit)
401 */
402 status =
403 acpi_set_register(acpi_gbl_fixed_event_info[event].
404 status_register_id, 1);
405
406 return_ACPI_STATUS(status);
407}
408
409ACPI_EXPORT_SYMBOL(acpi_clear_event)
410
411/*******************************************************************************
412 *
413 * FUNCTION: acpi_clear_gpe
414 *
415 * PARAMETERS: gpe_device - Parent GPE Device
416 * gpe_number - GPE level within the GPE block
417 * Flags - Called from an ISR or not
418 *
419 * RETURN: Status
420 *
421 * DESCRIPTION: Clear an ACPI event (general purpose)
422 *
423 ******************************************************************************/
424acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
425{
426 acpi_status status = AE_OK;
427 struct acpi_gpe_event_info *gpe_event_info;
428
429 ACPI_FUNCTION_TRACE(acpi_clear_gpe);
430
431 /* Use semaphore lock if not executing at interrupt level */
432
433 if (flags & ACPI_NOT_ISR) {
434 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
435 if (ACPI_FAILURE(status)) {
436 return_ACPI_STATUS(status);
437 }
438 }
439
440 /* Ensure that we have a valid GPE number */
441
442 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
443 if (!gpe_event_info) {
444 status = AE_BAD_PARAMETER;
445 goto unlock_and_exit;
446 }
447
448 status = acpi_hw_clear_gpe(gpe_event_info);
449
450 unlock_and_exit:
451 if (flags & ACPI_NOT_ISR) {
452 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
453 }
454 return_ACPI_STATUS(status);
455}
456
457ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
458/*******************************************************************************
459 *
460 * FUNCTION: acpi_get_event_status
461 *
462 * PARAMETERS: Event - The fixed event
463 * event_status - Where the current status of the event will
464 * be returned
465 *
466 * RETURN: Status
467 *
468 * DESCRIPTION: Obtains and returns the current status of the event
469 *
470 ******************************************************************************/
471acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
472{
473 acpi_status status = AE_OK;
474 u32 value;
475
476 ACPI_FUNCTION_TRACE(acpi_get_event_status);
477
478 if (!event_status) {
479 return_ACPI_STATUS(AE_BAD_PARAMETER);
480 }
481
482 /* Decode the Fixed Event */
483
484 if (event > ACPI_EVENT_MAX) {
485 return_ACPI_STATUS(AE_BAD_PARAMETER);
486 }
487
488 /* Get the status of the requested fixed event */
489
490 status =
491 acpi_get_register(acpi_gbl_fixed_event_info[event].
492 enable_register_id, &value);
493 if (ACPI_FAILURE(status))
494 return_ACPI_STATUS(status);
495
496 *event_status = value;
497
498 status =
499 acpi_get_register(acpi_gbl_fixed_event_info[event].
500 status_register_id, &value);
501 if (ACPI_FAILURE(status))
502 return_ACPI_STATUS(status);
503
504 if (value)
505 *event_status |= ACPI_EVENT_FLAG_SET;
506
507 if (acpi_gbl_fixed_event_handlers[event].handler)
508 *event_status |= ACPI_EVENT_FLAG_HANDLE;
509
510 return_ACPI_STATUS(status);
511}
512
513ACPI_EXPORT_SYMBOL(acpi_get_event_status)
514
515/*******************************************************************************
516 *
517 * FUNCTION: acpi_get_gpe_status
518 *
519 * PARAMETERS: gpe_device - Parent GPE Device
520 * gpe_number - GPE level within the GPE block
521 * Flags - Called from an ISR or not
522 * event_status - Where the current status of the event will
523 * be returned
524 *
525 * RETURN: Status
526 *
527 * DESCRIPTION: Get status of an event (general purpose)
528 *
529 ******************************************************************************/
530acpi_status
531acpi_get_gpe_status(acpi_handle gpe_device,
532 u32 gpe_number, u32 flags, acpi_event_status * event_status)
533{
534 acpi_status status = AE_OK;
535 struct acpi_gpe_event_info *gpe_event_info;
536
537 ACPI_FUNCTION_TRACE(acpi_get_gpe_status);
538
539 /* Use semaphore lock if not executing at interrupt level */
540
541 if (flags & ACPI_NOT_ISR) {
542 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
543 if (ACPI_FAILURE(status)) {
544 return_ACPI_STATUS(status);
545 }
546 }
547
548 /* Ensure that we have a valid GPE number */
549
550 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
551 if (!gpe_event_info) {
552 status = AE_BAD_PARAMETER;
553 goto unlock_and_exit;
554 }
555
556 /* Obtain status on the requested GPE number */
557
558 status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
559
560 if (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)
561 *event_status |= ACPI_EVENT_FLAG_HANDLE;
562
563 unlock_and_exit:
564 if (flags & ACPI_NOT_ISR) {
565 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
566 }
567 return_ACPI_STATUS(status);
568}
569
570ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)
571/*******************************************************************************
572 *
573 * FUNCTION: acpi_install_gpe_block
574 *
575 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
576 * gpe_block_address - Address and space_iD
577 * register_count - Number of GPE register pairs in the block
578 * interrupt_number - H/W interrupt for the block
579 *
580 * RETURN: Status
581 *
582 * DESCRIPTION: Create and Install a block of GPE registers
583 *
584 ******************************************************************************/
585acpi_status
586acpi_install_gpe_block(acpi_handle gpe_device,
587 struct acpi_generic_address *gpe_block_address,
588 u32 register_count, u32 interrupt_number)
589{
590 acpi_status status;
591 union acpi_operand_object *obj_desc;
592 struct acpi_namespace_node *node;
593 struct acpi_gpe_block_info *gpe_block;
594
595 ACPI_FUNCTION_TRACE(acpi_install_gpe_block);
596
597 if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
598 return_ACPI_STATUS(AE_BAD_PARAMETER);
599 }
600
601 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
602 if (ACPI_FAILURE(status)) {
603 return (status);
604 }
605
606 node = acpi_ns_map_handle_to_node(gpe_device);
607 if (!node) {
608 status = AE_BAD_PARAMETER;
609 goto unlock_and_exit;
610 }
611
612 /*
613 * For user-installed GPE Block Devices, the gpe_block_base_number
614 * is always zero
615 */
616 status =
617 acpi_ev_create_gpe_block(node, gpe_block_address, register_count, 0,
618 interrupt_number, &gpe_block);
619 if (ACPI_FAILURE(status)) {
620 goto unlock_and_exit;
621 }
622
623 /* Run the _PRW methods and enable the GPEs */
624
625 status = acpi_ev_initialize_gpe_block(node, gpe_block);
626 if (ACPI_FAILURE(status)) {
627 goto unlock_and_exit;
628 }
629
630 /* Get the device_object attached to the node */
631
632 obj_desc = acpi_ns_get_attached_object(node);
633 if (!obj_desc) {
634
635 /* No object, create a new one */
636
637 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
638 if (!obj_desc) {
639 status = AE_NO_MEMORY;
640 goto unlock_and_exit;
641 }
642
643 status =
644 acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);
645
646 /* Remove local reference to the object */
647
648 acpi_ut_remove_reference(obj_desc);
649
650 if (ACPI_FAILURE(status)) {
651 goto unlock_and_exit;
652 }
653 }
654
655 /* Install the GPE block in the device_object */
656
657 obj_desc->device.gpe_block = gpe_block;
658
659 unlock_and_exit:
660 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
661 return_ACPI_STATUS(status);
662}
663
664ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)
665
666/*******************************************************************************
667 *
668 * FUNCTION: acpi_remove_gpe_block
669 *
670 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
671 *
672 * RETURN: Status
673 *
674 * DESCRIPTION: Remove a previously installed block of GPE registers
675 *
676 ******************************************************************************/
677acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
678{
679 union acpi_operand_object *obj_desc;
680 acpi_status status;
681 struct acpi_namespace_node *node;
682
683 ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);
684
685 if (!gpe_device) {
686 return_ACPI_STATUS(AE_BAD_PARAMETER);
687 }
688
689 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
690 if (ACPI_FAILURE(status)) {
691 return (status);
692 }
693
694 node = acpi_ns_map_handle_to_node(gpe_device);
695 if (!node) {
696 status = AE_BAD_PARAMETER;
697 goto unlock_and_exit;
698 }
699
700 /* Get the device_object attached to the node */
701
702 obj_desc = acpi_ns_get_attached_object(node);
703 if (!obj_desc || !obj_desc->device.gpe_block) {
704 return_ACPI_STATUS(AE_NULL_OBJECT);
705 }
706
707 /* Delete the GPE block (but not the device_object) */
708
709 status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
710 if (ACPI_SUCCESS(status)) {
711 obj_desc->device.gpe_block = NULL;
712 }
713
714 unlock_and_exit:
715 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
716 return_ACPI_STATUS(status);
717}
718
719ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)