aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/acpi
diff options
context:
space:
mode:
authorLen Brown <len.brown@intel.com>2008-11-11 21:17:26 -0500
committerLen Brown <len.brown@intel.com>2008-11-11 21:17:26 -0500
commitd1876ba4dead6ace7e9fbf16f83397e6486d0dfe (patch)
treeecf9a5b65c51ec3c8fd19a1ebe9cf70aac949aaa /drivers/acpi
parent547f7847472c097a54adf38e6576f95ab512e27c (diff)
parent8517934ef6aaa28d6e055b98df65b31cedbd1372 (diff)
Merge branch 'ec' into release
Diffstat (limited to 'drivers/acpi')
-rw-r--r--drivers/acpi/button.c2
-rw-r--r--drivers/acpi/ec.c94
-rw-r--r--drivers/acpi/events/evxfevnt.c35
-rw-r--r--drivers/acpi/sleep/wakeup.c8
-rw-r--r--drivers/acpi/system.c4
5 files changed, 79 insertions, 64 deletions
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index fd7ca289cb02..171fd914f435 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -478,7 +478,7 @@ static int acpi_button_add(struct acpi_device *device)
478 device->wakeup.gpe_number, 478 device->wakeup.gpe_number,
479 ACPI_GPE_TYPE_WAKE_RUN); 479 ACPI_GPE_TYPE_WAKE_RUN);
480 acpi_enable_gpe(device->wakeup.gpe_device, 480 acpi_enable_gpe(device->wakeup.gpe_device,
481 device->wakeup.gpe_number, ACPI_NOT_ISR); 481 device->wakeup.gpe_number);
482 device->wakeup.state.enabled = 1; 482 device->wakeup.state.enabled = 1;
483 } 483 }
484 484
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 523ac5b229a5..cf41f9fc24a7 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -70,7 +70,7 @@ enum ec_command {
70#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */ 70#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
71#define ACPI_EC_UDELAY 100 /* Wait 100us before polling EC again */ 71#define ACPI_EC_UDELAY 100 /* Wait 100us before polling EC again */
72 72
73#define ACPI_EC_STORM_THRESHOLD 20 /* number of false interrupts 73#define ACPI_EC_STORM_THRESHOLD 8 /* number of false interrupts
74 per one transaction */ 74 per one transaction */
75 75
76enum { 76enum {
@@ -100,8 +100,11 @@ struct transaction {
100 u8 *rdata; 100 u8 *rdata;
101 unsigned short irq_count; 101 unsigned short irq_count;
102 u8 command; 102 u8 command;
103 u8 wi;
104 u8 ri;
103 u8 wlen; 105 u8 wlen;
104 u8 rlen; 106 u8 rlen;
107 bool done;
105}; 108};
106 109
107static struct acpi_ec { 110static struct acpi_ec {
@@ -178,34 +181,45 @@ static int ec_transaction_done(struct acpi_ec *ec)
178 unsigned long flags; 181 unsigned long flags;
179 int ret = 0; 182 int ret = 0;
180 spin_lock_irqsave(&ec->curr_lock, flags); 183 spin_lock_irqsave(&ec->curr_lock, flags);
181 if (!ec->curr || (!ec->curr->wlen && !ec->curr->rlen)) 184 if (!ec->curr || ec->curr->done)
182 ret = 1; 185 ret = 1;
183 spin_unlock_irqrestore(&ec->curr_lock, flags); 186 spin_unlock_irqrestore(&ec->curr_lock, flags);
184 return ret; 187 return ret;
185} 188}
186 189
190static void start_transaction(struct acpi_ec *ec)
191{
192 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
193 ec->curr->done = false;
194 acpi_ec_write_cmd(ec, ec->curr->command);
195}
196
187static void gpe_transaction(struct acpi_ec *ec, u8 status) 197static void gpe_transaction(struct acpi_ec *ec, u8 status)
188{ 198{
189 unsigned long flags; 199 unsigned long flags;
190 spin_lock_irqsave(&ec->curr_lock, flags); 200 spin_lock_irqsave(&ec->curr_lock, flags);
191 if (!ec->curr) 201 if (!ec->curr)
192 goto unlock; 202 goto unlock;
193 if (ec->curr->wlen > 0) { 203 if (ec->curr->wlen > ec->curr->wi) {
194 if ((status & ACPI_EC_FLAG_IBF) == 0) { 204 if ((status & ACPI_EC_FLAG_IBF) == 0)
195 acpi_ec_write_data(ec, *(ec->curr->wdata++)); 205 acpi_ec_write_data(ec,
196 --ec->curr->wlen; 206 ec->curr->wdata[ec->curr->wi++]);
197 } else 207 else
198 /* false interrupt, state didn't change */ 208 goto err;
199 ++ec->curr->irq_count; 209 } else if (ec->curr->rlen > ec->curr->ri) {
200
201 } else if (ec->curr->rlen > 0) {
202 if ((status & ACPI_EC_FLAG_OBF) == 1) { 210 if ((status & ACPI_EC_FLAG_OBF) == 1) {
203 *(ec->curr->rdata++) = acpi_ec_read_data(ec); 211 ec->curr->rdata[ec->curr->ri++] = acpi_ec_read_data(ec);
204 --ec->curr->rlen; 212 if (ec->curr->rlen == ec->curr->ri)
213 ec->curr->done = true;
205 } else 214 } else
206 /* false interrupt, state didn't change */ 215 goto err;
207 ++ec->curr->irq_count; 216 } else if (ec->curr->wlen == ec->curr->wi &&
208 } 217 (status & ACPI_EC_FLAG_IBF) == 0)
218 ec->curr->done = true;
219 goto unlock;
220err:
221 /* false interrupt, state didn't change */
222 ++ec->curr->irq_count;
209unlock: 223unlock:
210 spin_unlock_irqrestore(&ec->curr_lock, flags); 224 spin_unlock_irqrestore(&ec->curr_lock, flags);
211} 225}
@@ -215,6 +229,15 @@ static int acpi_ec_wait(struct acpi_ec *ec)
215 if (wait_event_timeout(ec->wait, ec_transaction_done(ec), 229 if (wait_event_timeout(ec->wait, ec_transaction_done(ec),
216 msecs_to_jiffies(ACPI_EC_DELAY))) 230 msecs_to_jiffies(ACPI_EC_DELAY)))
217 return 0; 231 return 0;
232 /* try restart command if we get any false interrupts */
233 if (ec->curr->irq_count &&
234 (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) == 0) {
235 pr_debug(PREFIX "controller reset, restart transaction\n");
236 start_transaction(ec);
237 if (wait_event_timeout(ec->wait, ec_transaction_done(ec),
238 msecs_to_jiffies(ACPI_EC_DELAY)))
239 return 0;
240 }
218 /* missing GPEs, switch back to poll mode */ 241 /* missing GPEs, switch back to poll mode */
219 if (printk_ratelimit()) 242 if (printk_ratelimit())
220 pr_info(PREFIX "missing confirmations, " 243 pr_info(PREFIX "missing confirmations, "
@@ -239,10 +262,10 @@ static int ec_check_sci(struct acpi_ec *ec, u8 state)
239static int ec_poll(struct acpi_ec *ec) 262static int ec_poll(struct acpi_ec *ec)
240{ 263{
241 unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY); 264 unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY);
242 msleep(1); 265 udelay(ACPI_EC_UDELAY);
243 while (time_before(jiffies, delay)) { 266 while (time_before(jiffies, delay)) {
244 gpe_transaction(ec, acpi_ec_read_status(ec)); 267 gpe_transaction(ec, acpi_ec_read_status(ec));
245 msleep(1); 268 udelay(ACPI_EC_UDELAY);
246 if (ec_transaction_done(ec)) 269 if (ec_transaction_done(ec))
247 return 0; 270 return 0;
248 } 271 }
@@ -259,14 +282,13 @@ static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
259 /* disable GPE during transaction if storm is detected */ 282 /* disable GPE during transaction if storm is detected */
260 if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) { 283 if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
261 clear_bit(EC_FLAGS_GPE_MODE, &ec->flags); 284 clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
262 acpi_disable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 285 acpi_disable_gpe(NULL, ec->gpe);
263 } 286 }
264 /* start transaction */ 287 /* start transaction */
265 spin_lock_irqsave(&ec->curr_lock, tmp); 288 spin_lock_irqsave(&ec->curr_lock, tmp);
266 /* following two actions should be kept atomic */ 289 /* following two actions should be kept atomic */
267 t->irq_count = 0;
268 ec->curr = t; 290 ec->curr = t;
269 acpi_ec_write_cmd(ec, ec->curr->command); 291 start_transaction(ec);
270 if (ec->curr->command == ACPI_EC_COMMAND_QUERY) 292 if (ec->curr->command == ACPI_EC_COMMAND_QUERY)
271 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags); 293 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
272 spin_unlock_irqrestore(&ec->curr_lock, tmp); 294 spin_unlock_irqrestore(&ec->curr_lock, tmp);
@@ -283,10 +305,11 @@ static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
283 /* check if we received SCI during transaction */ 305 /* check if we received SCI during transaction */
284 ec_check_sci(ec, acpi_ec_read_status(ec)); 306 ec_check_sci(ec, acpi_ec_read_status(ec));
285 /* it is safe to enable GPE outside of transaction */ 307 /* it is safe to enable GPE outside of transaction */
286 acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 308 acpi_enable_gpe(NULL, ec->gpe);
287 } else if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags) && 309 } else if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags) &&
288 t->irq_count > ACPI_EC_STORM_THRESHOLD) { 310 t->irq_count > ACPI_EC_STORM_THRESHOLD) {
289 pr_debug(PREFIX "GPE storm detected\n"); 311 pr_info(PREFIX "GPE storm detected, "
312 "transactions will use polling mode\n");
290 set_bit(EC_FLAGS_GPE_STORM, &ec->flags); 313 set_bit(EC_FLAGS_GPE_STORM, &ec->flags);
291 } 314 }
292 return ret; 315 return ret;
@@ -558,17 +581,26 @@ static u32 acpi_ec_gpe_handler(void *data)
558 pr_debug(PREFIX "~~~> interrupt\n"); 581 pr_debug(PREFIX "~~~> interrupt\n");
559 status = acpi_ec_read_status(ec); 582 status = acpi_ec_read_status(ec);
560 583
561 gpe_transaction(ec, status); 584 if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags)) {
562 if (ec_transaction_done(ec) && (status & ACPI_EC_FLAG_IBF) == 0) 585 gpe_transaction(ec, status);
563 wake_up(&ec->wait); 586 if (ec_transaction_done(ec) &&
587 (status & ACPI_EC_FLAG_IBF) == 0)
588 wake_up(&ec->wait);
589 }
564 590
565 ec_check_sci(ec, status); 591 ec_check_sci(ec, status);
566 if (!test_bit(EC_FLAGS_GPE_MODE, &ec->flags) && 592 if (!test_bit(EC_FLAGS_GPE_MODE, &ec->flags) &&
567 !test_bit(EC_FLAGS_NO_GPE, &ec->flags)) { 593 !test_bit(EC_FLAGS_NO_GPE, &ec->flags)) {
568 /* this is non-query, must be confirmation */ 594 /* this is non-query, must be confirmation */
569 if (printk_ratelimit()) 595 if (!test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
570 pr_info(PREFIX "non-query interrupt received," 596 if (printk_ratelimit())
597 pr_info(PREFIX "non-query interrupt received,"
598 " switching to interrupt mode\n");
599 } else {
600 /* hush, STORM switches the mode every transaction */
601 pr_debug(PREFIX "non-query interrupt received,"
571 " switching to interrupt mode\n"); 602 " switching to interrupt mode\n");
603 }
572 set_bit(EC_FLAGS_GPE_MODE, &ec->flags); 604 set_bit(EC_FLAGS_GPE_MODE, &ec->flags);
573 } 605 }
574 return ACPI_INTERRUPT_HANDLED; 606 return ACPI_INTERRUPT_HANDLED;
@@ -869,7 +901,7 @@ static int ec_install_handlers(struct acpi_ec *ec)
869 if (ACPI_FAILURE(status)) 901 if (ACPI_FAILURE(status))
870 return -ENODEV; 902 return -ENODEV;
871 acpi_set_gpe_type(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME); 903 acpi_set_gpe_type(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME);
872 acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 904 acpi_enable_gpe(NULL, ec->gpe);
873 status = acpi_install_address_space_handler(ec->handle, 905 status = acpi_install_address_space_handler(ec->handle,
874 ACPI_ADR_SPACE_EC, 906 ACPI_ADR_SPACE_EC,
875 &acpi_ec_space_handler, 907 &acpi_ec_space_handler,
@@ -1008,7 +1040,7 @@ static int acpi_ec_suspend(struct acpi_device *device, pm_message_t state)
1008 /* Stop using GPE */ 1040 /* Stop using GPE */
1009 set_bit(EC_FLAGS_NO_GPE, &ec->flags); 1041 set_bit(EC_FLAGS_NO_GPE, &ec->flags);
1010 clear_bit(EC_FLAGS_GPE_MODE, &ec->flags); 1042 clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
1011 acpi_disable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 1043 acpi_disable_gpe(NULL, ec->gpe);
1012 return 0; 1044 return 0;
1013} 1045}
1014 1046
@@ -1017,7 +1049,7 @@ static int acpi_ec_resume(struct acpi_device *device)
1017 struct acpi_ec *ec = acpi_driver_data(device); 1049 struct acpi_ec *ec = acpi_driver_data(device);
1018 /* Enable use of GPE back */ 1050 /* Enable use of GPE back */
1019 clear_bit(EC_FLAGS_NO_GPE, &ec->flags); 1051 clear_bit(EC_FLAGS_NO_GPE, &ec->flags);
1020 acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 1052 acpi_enable_gpe(NULL, ec->gpe);
1021 return 0; 1053 return 0;
1022} 1054}
1023 1055
diff --git a/drivers/acpi/events/evxfevnt.c b/drivers/acpi/events/evxfevnt.c
index 211e93a90e95..41554f736b68 100644
--- a/drivers/acpi/events/evxfevnt.c
+++ b/drivers/acpi/events/evxfevnt.c
@@ -248,21 +248,15 @@ ACPI_EXPORT_SYMBOL(acpi_set_gpe_type)
248 * DESCRIPTION: Enable an ACPI event (general purpose) 248 * DESCRIPTION: Enable an ACPI event (general purpose)
249 * 249 *
250 ******************************************************************************/ 250 ******************************************************************************/
251acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags) 251acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
252{ 252{
253 acpi_status status = AE_OK; 253 acpi_status status = AE_OK;
254 acpi_cpu_flags flags;
254 struct acpi_gpe_event_info *gpe_event_info; 255 struct acpi_gpe_event_info *gpe_event_info;
255 256
256 ACPI_FUNCTION_TRACE(acpi_enable_gpe); 257 ACPI_FUNCTION_TRACE(acpi_enable_gpe);
257 258
258 /* Use semaphore lock if not executing at interrupt level */ 259 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
259
260 if (flags & ACPI_NOT_ISR) {
261 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
262 if (ACPI_FAILURE(status)) {
263 return_ACPI_STATUS(status);
264 }
265 }
266 260
267 /* Ensure that we have a valid GPE number */ 261 /* Ensure that we have a valid GPE number */
268 262
@@ -277,9 +271,7 @@ acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
277 status = acpi_ev_enable_gpe(gpe_event_info, TRUE); 271 status = acpi_ev_enable_gpe(gpe_event_info, TRUE);
278 272
279 unlock_and_exit: 273 unlock_and_exit:
280 if (flags & ACPI_NOT_ISR) { 274 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
281 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
282 }
283 return_ACPI_STATUS(status); 275 return_ACPI_STATUS(status);
284} 276}
285 277
@@ -299,22 +291,15 @@ ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
299 * DESCRIPTION: Disable an ACPI event (general purpose) 291 * DESCRIPTION: Disable an ACPI event (general purpose)
300 * 292 *
301 ******************************************************************************/ 293 ******************************************************************************/
302acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags) 294acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
303{ 295{
304 acpi_status status = AE_OK; 296 acpi_status status = AE_OK;
297 acpi_cpu_flags flags;
305 struct acpi_gpe_event_info *gpe_event_info; 298 struct acpi_gpe_event_info *gpe_event_info;
306 299
307 ACPI_FUNCTION_TRACE(acpi_disable_gpe); 300 ACPI_FUNCTION_TRACE(acpi_disable_gpe);
308 301
309 /* Use semaphore lock if not executing at interrupt level */ 302 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
310
311 if (flags & ACPI_NOT_ISR) {
312 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
313 if (ACPI_FAILURE(status)) {
314 return_ACPI_STATUS(status);
315 }
316 }
317
318 /* Ensure that we have a valid GPE number */ 303 /* Ensure that we have a valid GPE number */
319 304
320 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 305 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
@@ -325,10 +310,8 @@ acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
325 310
326 status = acpi_ev_disable_gpe(gpe_event_info); 311 status = acpi_ev_disable_gpe(gpe_event_info);
327 312
328 unlock_and_exit: 313unlock_and_exit:
329 if (flags & ACPI_NOT_ISR) { 314 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
330 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
331 }
332 return_ACPI_STATUS(status); 315 return_ACPI_STATUS(status);
333} 316}
334 317
diff --git a/drivers/acpi/sleep/wakeup.c b/drivers/acpi/sleep/wakeup.c
index 38655eb132dc..dea4c23df764 100644
--- a/drivers/acpi/sleep/wakeup.c
+++ b/drivers/acpi/sleep/wakeup.c
@@ -88,7 +88,7 @@ void acpi_enable_wakeup_device(u8 sleep_state)
88 spin_unlock(&acpi_device_lock); 88 spin_unlock(&acpi_device_lock);
89 if (!dev->wakeup.flags.run_wake) 89 if (!dev->wakeup.flags.run_wake)
90 acpi_enable_gpe(dev->wakeup.gpe_device, 90 acpi_enable_gpe(dev->wakeup.gpe_device,
91 dev->wakeup.gpe_number, ACPI_ISR); 91 dev->wakeup.gpe_number);
92 spin_lock(&acpi_device_lock); 92 spin_lock(&acpi_device_lock);
93 } 93 }
94 spin_unlock(&acpi_device_lock); 94 spin_unlock(&acpi_device_lock);
@@ -122,7 +122,7 @@ void acpi_disable_wakeup_device(u8 sleep_state)
122 ACPI_GPE_TYPE_WAKE_RUN); 122 ACPI_GPE_TYPE_WAKE_RUN);
123 /* Re-enable it, since set_gpe_type will disable it */ 123 /* Re-enable it, since set_gpe_type will disable it */
124 acpi_enable_gpe(dev->wakeup.gpe_device, 124 acpi_enable_gpe(dev->wakeup.gpe_device,
125 dev->wakeup.gpe_number, ACPI_NOT_ISR); 125 dev->wakeup.gpe_number);
126 spin_lock(&acpi_device_lock); 126 spin_lock(&acpi_device_lock);
127 } 127 }
128 continue; 128 continue;
@@ -133,7 +133,7 @@ void acpi_disable_wakeup_device(u8 sleep_state)
133 /* Never disable run-wake GPE */ 133 /* Never disable run-wake GPE */
134 if (!dev->wakeup.flags.run_wake) { 134 if (!dev->wakeup.flags.run_wake) {
135 acpi_disable_gpe(dev->wakeup.gpe_device, 135 acpi_disable_gpe(dev->wakeup.gpe_device,
136 dev->wakeup.gpe_number, ACPI_NOT_ISR); 136 dev->wakeup.gpe_number);
137 acpi_clear_gpe(dev->wakeup.gpe_device, 137 acpi_clear_gpe(dev->wakeup.gpe_device,
138 dev->wakeup.gpe_number, ACPI_NOT_ISR); 138 dev->wakeup.gpe_number, ACPI_NOT_ISR);
139 } 139 }
@@ -162,7 +162,7 @@ static int __init acpi_wakeup_device_init(void)
162 dev->wakeup.gpe_number, 162 dev->wakeup.gpe_number,
163 ACPI_GPE_TYPE_WAKE_RUN); 163 ACPI_GPE_TYPE_WAKE_RUN);
164 acpi_enable_gpe(dev->wakeup.gpe_device, 164 acpi_enable_gpe(dev->wakeup.gpe_device,
165 dev->wakeup.gpe_number, ACPI_NOT_ISR); 165 dev->wakeup.gpe_number);
166 dev->wakeup.state.enabled = 1; 166 dev->wakeup.state.enabled = 1;
167 spin_lock(&acpi_device_lock); 167 spin_lock(&acpi_device_lock);
168 } 168 }
diff --git a/drivers/acpi/system.c b/drivers/acpi/system.c
index bfc216a11fdd..6e4107f82403 100644
--- a/drivers/acpi/system.c
+++ b/drivers/acpi/system.c
@@ -398,10 +398,10 @@ static ssize_t counter_set(struct kobject *kobj,
398 if (index < num_gpes) { 398 if (index < num_gpes) {
399 if (!strcmp(buf, "disable\n") && 399 if (!strcmp(buf, "disable\n") &&
400 (status & ACPI_EVENT_FLAG_ENABLED)) 400 (status & ACPI_EVENT_FLAG_ENABLED))
401 result = acpi_disable_gpe(handle, index, ACPI_NOT_ISR); 401 result = acpi_disable_gpe(handle, index);
402 else if (!strcmp(buf, "enable\n") && 402 else if (!strcmp(buf, "enable\n") &&
403 !(status & ACPI_EVENT_FLAG_ENABLED)) 403 !(status & ACPI_EVENT_FLAG_ENABLED))
404 result = acpi_enable_gpe(handle, index, ACPI_NOT_ISR); 404 result = acpi_enable_gpe(handle, index);
405 else if (!strcmp(buf, "clear\n") && 405 else if (!strcmp(buf, "clear\n") &&
406 (status & ACPI_EVENT_FLAG_SET)) 406 (status & ACPI_EVENT_FLAG_SET))
407 result = acpi_clear_gpe(handle, index, ACPI_NOT_ISR); 407 result = acpi_clear_gpe(handle, index, ACPI_NOT_ISR);