ia64/linux-2.6.18-xen.hg

view drivers/acpi/ec.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /*
2 * acpi_ec.c - ACPI Embedded Controller Driver ($Revision: 38 $)
3 *
4 * Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7 *
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or (at
13 * your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 *
24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 */
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/types.h>
31 #include <linux/delay.h>
32 #include <linux/proc_fs.h>
33 #include <linux/seq_file.h>
34 #include <linux/interrupt.h>
35 #include <asm/io.h>
36 #include <acpi/acpi_bus.h>
37 #include <acpi/acpi_drivers.h>
38 #include <acpi/actypes.h>
40 #define _COMPONENT ACPI_EC_COMPONENT
41 ACPI_MODULE_NAME("acpi_ec")
42 #define ACPI_EC_COMPONENT 0x00100000
43 #define ACPI_EC_CLASS "embedded_controller"
44 #define ACPI_EC_HID "PNP0C09"
45 #define ACPI_EC_DRIVER_NAME "ACPI Embedded Controller Driver"
46 #define ACPI_EC_DEVICE_NAME "Embedded Controller"
47 #define ACPI_EC_FILE_INFO "info"
48 #define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
49 #define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
50 #define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
51 #define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
52 #define ACPI_EC_EVENT_OBF 0x01 /* Output buffer full */
53 #define ACPI_EC_EVENT_IBE 0x02 /* Input buffer empty */
54 #define ACPI_EC_DELAY 50 /* Wait 50ms max. during EC ops */
55 #define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
56 #define ACPI_EC_UDELAY 100 /* Poll @ 100us increments */
57 #define ACPI_EC_UDELAY_COUNT 1000 /* Wait 10ms max. during EC ops */
58 #define ACPI_EC_COMMAND_READ 0x80
59 #define ACPI_EC_COMMAND_WRITE 0x81
60 #define ACPI_EC_BURST_ENABLE 0x82
61 #define ACPI_EC_BURST_DISABLE 0x83
62 #define ACPI_EC_COMMAND_QUERY 0x84
63 #define EC_POLL 0xFF
64 #define EC_INTR 0x00
65 static int acpi_ec_remove(struct acpi_device *device, int type);
66 static int acpi_ec_start(struct acpi_device *device);
67 static int acpi_ec_stop(struct acpi_device *device, int type);
68 static int acpi_ec_intr_add(struct acpi_device *device);
69 static int acpi_ec_poll_add(struct acpi_device *device);
71 static struct acpi_driver acpi_ec_driver = {
72 .name = ACPI_EC_DRIVER_NAME,
73 .class = ACPI_EC_CLASS,
74 .ids = ACPI_EC_HID,
75 .ops = {
76 .add = acpi_ec_intr_add,
77 .remove = acpi_ec_remove,
78 .start = acpi_ec_start,
79 .stop = acpi_ec_stop,
80 },
81 };
82 union acpi_ec {
83 struct {
84 u32 mode;
85 acpi_handle handle;
86 unsigned long uid;
87 unsigned long gpe_bit;
88 struct acpi_generic_address status_addr;
89 struct acpi_generic_address command_addr;
90 struct acpi_generic_address data_addr;
91 unsigned long global_lock;
92 } common;
94 struct {
95 u32 mode;
96 acpi_handle handle;
97 unsigned long uid;
98 unsigned long gpe_bit;
99 struct acpi_generic_address status_addr;
100 struct acpi_generic_address command_addr;
101 struct acpi_generic_address data_addr;
102 unsigned long global_lock;
103 unsigned int expect_event;
104 atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort */
105 atomic_t pending_gpe;
106 struct semaphore sem;
107 wait_queue_head_t wait;
108 } intr;
110 struct {
111 u32 mode;
112 acpi_handle handle;
113 unsigned long uid;
114 unsigned long gpe_bit;
115 struct acpi_generic_address status_addr;
116 struct acpi_generic_address command_addr;
117 struct acpi_generic_address data_addr;
118 unsigned long global_lock;
119 struct semaphore sem;
120 } poll;
121 };
123 static int acpi_ec_poll_wait(union acpi_ec *ec, u8 event);
124 static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event);
125 static int acpi_ec_poll_read(union acpi_ec *ec, u8 address, u32 * data);
126 static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data);
127 static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data);
128 static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data);
129 static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data);
130 static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data);
131 static void acpi_ec_gpe_poll_query(void *ec_cxt);
132 static void acpi_ec_gpe_intr_query(void *ec_cxt);
133 static u32 acpi_ec_gpe_poll_handler(void *data);
134 static u32 acpi_ec_gpe_intr_handler(void *data);
135 static acpi_status __init
136 acpi_fake_ecdt_poll_callback(acpi_handle handle,
137 u32 Level, void *context, void **retval);
139 static acpi_status __init
140 acpi_fake_ecdt_intr_callback(acpi_handle handle,
141 u32 Level, void *context, void **retval);
143 static int __init acpi_ec_poll_get_real_ecdt(void);
144 static int __init acpi_ec_intr_get_real_ecdt(void);
145 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
146 static union acpi_ec *ec_ecdt;
148 /* External interfaces use first EC only, so remember */
149 static struct acpi_device *first_ec;
150 static int acpi_ec_poll_mode = EC_INTR;
152 /* --------------------------------------------------------------------------
153 Transaction Management
154 -------------------------------------------------------------------------- */
156 static u32 acpi_ec_read_status(union acpi_ec *ec)
157 {
158 u32 status = 0;
160 acpi_hw_low_level_read(8, &status, &ec->common.status_addr);
161 return status;
162 }
164 static int acpi_ec_wait(union acpi_ec *ec, u8 event)
165 {
166 if (acpi_ec_poll_mode)
167 return acpi_ec_poll_wait(ec, event);
168 else
169 return acpi_ec_intr_wait(ec, event);
170 }
172 static int acpi_ec_poll_wait(union acpi_ec *ec, u8 event)
173 {
174 u32 acpi_ec_status = 0;
175 u32 i = ACPI_EC_UDELAY_COUNT;
177 if (!ec)
178 return -EINVAL;
180 /* Poll the EC status register waiting for the event to occur. */
181 switch (event) {
182 case ACPI_EC_EVENT_OBF:
183 do {
184 acpi_hw_low_level_read(8, &acpi_ec_status,
185 &ec->common.status_addr);
186 if (acpi_ec_status & ACPI_EC_FLAG_OBF)
187 return 0;
188 udelay(ACPI_EC_UDELAY);
189 } while (--i > 0);
190 break;
191 case ACPI_EC_EVENT_IBE:
192 do {
193 acpi_hw_low_level_read(8, &acpi_ec_status,
194 &ec->common.status_addr);
195 if (!(acpi_ec_status & ACPI_EC_FLAG_IBF))
196 return 0;
197 udelay(ACPI_EC_UDELAY);
198 } while (--i > 0);
199 break;
200 default:
201 return -EINVAL;
202 }
204 return -ETIME;
205 }
206 static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event)
207 {
208 int result = 0;
211 ec->intr.expect_event = event;
212 smp_mb();
214 switch (event) {
215 case ACPI_EC_EVENT_IBE:
216 if (~acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) {
217 ec->intr.expect_event = 0;
218 return 0;
219 }
220 break;
221 default:
222 break;
223 }
225 result = wait_event_timeout(ec->intr.wait,
226 !ec->intr.expect_event,
227 msecs_to_jiffies(ACPI_EC_DELAY));
229 ec->intr.expect_event = 0;
230 smp_mb();
232 /*
233 * Verify that the event in question has actually happened by
234 * querying EC status. Do the check even if operation timed-out
235 * to make sure that we did not miss interrupt.
236 */
237 switch (event) {
238 case ACPI_EC_EVENT_OBF:
239 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_OBF)
240 return 0;
241 break;
243 case ACPI_EC_EVENT_IBE:
244 if (~acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF)
245 return 0;
246 break;
247 }
249 return -ETIME;
250 }
252 #ifdef ACPI_FUTURE_USAGE
253 /*
254 * Note: samsung nv5000 doesn't work with ec burst mode.
255 * http://bugzilla.kernel.org/show_bug.cgi?id=4980
256 */
257 int acpi_ec_enter_burst_mode(union acpi_ec *ec)
258 {
259 u32 tmp = 0;
260 int status = 0;
263 status = acpi_ec_read_status(ec);
264 if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) {
265 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
266 if (status)
267 goto end;
268 acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE,
269 &ec->common.command_addr);
270 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
271 acpi_hw_low_level_read(8, &tmp, &ec->common.data_addr);
272 if (tmp != 0x90) { /* Burst ACK byte */
273 return -EINVAL;
274 }
275 }
277 atomic_set(&ec->intr.leaving_burst, 0);
278 return 0;
279 end:
280 ACPI_EXCEPTION ((AE_INFO, status, "EC wait, burst mode");
281 return -1;
282 }
284 int acpi_ec_leave_burst_mode(union acpi_ec *ec)
285 {
286 int status = 0;
289 status = acpi_ec_read_status(ec);
290 if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){
291 status = acpi_ec_wait(ec, ACPI_EC_FLAG_IBF);
292 if(status)
293 goto end;
294 acpi_hw_low_level_write(8, ACPI_EC_BURST_DISABLE, &ec->common.command_addr);
295 acpi_ec_wait(ec, ACPI_EC_FLAG_IBF);
296 }
297 atomic_set(&ec->intr.leaving_burst, 1);
298 return 0;
299 end:
300 ACPI_EXCEPTION((AE_INFO, status, "EC leave burst mode");
301 return -1;
302 }
303 #endif /* ACPI_FUTURE_USAGE */
305 static int acpi_ec_read(union acpi_ec *ec, u8 address, u32 * data)
306 {
307 if (acpi_ec_poll_mode)
308 return acpi_ec_poll_read(ec, address, data);
309 else
310 return acpi_ec_intr_read(ec, address, data);
311 }
312 static int acpi_ec_write(union acpi_ec *ec, u8 address, u8 data)
313 {
314 if (acpi_ec_poll_mode)
315 return acpi_ec_poll_write(ec, address, data);
316 else
317 return acpi_ec_intr_write(ec, address, data);
318 }
319 static int acpi_ec_poll_read(union acpi_ec *ec, u8 address, u32 * data)
320 {
321 acpi_status status = AE_OK;
322 int result = 0;
323 u32 glk = 0;
326 if (!ec || !data)
327 return -EINVAL;
329 *data = 0;
331 if (ec->common.global_lock) {
332 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
333 if (ACPI_FAILURE(status))
334 return -ENODEV;
335 }
337 if (down_interruptible(&ec->poll.sem)) {
338 result = -ERESTARTSYS;
339 goto end_nosem;
340 }
342 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ,
343 &ec->common.command_addr);
344 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
345 if (result)
346 goto end;
348 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
349 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
350 if (result)
351 goto end;
353 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
355 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
356 *data, address));
358 end:
359 up(&ec->poll.sem);
360 end_nosem:
361 if (ec->common.global_lock)
362 acpi_release_global_lock(glk);
364 return result;
365 }
367 static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data)
368 {
369 int result = 0;
370 acpi_status status = AE_OK;
371 u32 glk = 0;
374 if (!ec)
375 return -EINVAL;
377 if (ec->common.global_lock) {
378 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
379 if (ACPI_FAILURE(status))
380 return -ENODEV;
381 }
383 if (down_interruptible(&ec->poll.sem)) {
384 result = -ERESTARTSYS;
385 goto end_nosem;
386 }
388 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE,
389 &ec->common.command_addr);
390 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
391 if (result)
392 goto end;
394 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
395 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
396 if (result)
397 goto end;
399 acpi_hw_low_level_write(8, data, &ec->common.data_addr);
400 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
401 if (result)
402 goto end;
404 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
405 data, address));
407 end:
408 up(&ec->poll.sem);
409 end_nosem:
410 if (ec->common.global_lock)
411 acpi_release_global_lock(glk);
413 return result;
414 }
416 static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data)
417 {
418 int status = 0;
419 u32 glk;
422 if (!ec || !data)
423 return -EINVAL;
425 *data = 0;
427 if (ec->common.global_lock) {
428 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
429 if (ACPI_FAILURE(status))
430 return -ENODEV;
431 }
433 WARN_ON(in_interrupt());
434 down(&ec->intr.sem);
436 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
437 if (status) {
438 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
439 goto end;
440 }
441 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ,
442 &ec->common.command_addr);
443 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
444 if (status) {
445 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
446 }
448 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
449 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
450 if (status) {
451 printk(KERN_DEBUG PREFIX "read EC, OB not full\n");
452 goto end;
453 }
454 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
455 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
456 *data, address));
458 end:
459 up(&ec->intr.sem);
461 if (ec->common.global_lock)
462 acpi_release_global_lock(glk);
464 return status;
465 }
467 static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data)
468 {
469 int status = 0;
470 u32 glk;
473 if (!ec)
474 return -EINVAL;
476 if (ec->common.global_lock) {
477 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
478 if (ACPI_FAILURE(status))
479 return -ENODEV;
480 }
482 WARN_ON(in_interrupt());
483 down(&ec->intr.sem);
485 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
486 if (status) {
487 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
488 }
489 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE,
490 &ec->common.command_addr);
491 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
492 if (status) {
493 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
494 }
496 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
497 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
498 if (status) {
499 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
500 }
502 acpi_hw_low_level_write(8, data, &ec->common.data_addr);
504 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
505 data, address));
507 up(&ec->intr.sem);
509 if (ec->common.global_lock)
510 acpi_release_global_lock(glk);
512 return status;
513 }
515 /*
516 * Externally callable EC access functions. For now, assume 1 EC only
517 */
518 int ec_read(u8 addr, u8 * val)
519 {
520 union acpi_ec *ec;
521 int err;
522 u32 temp_data;
524 if (!first_ec)
525 return -ENODEV;
527 ec = acpi_driver_data(first_ec);
529 err = acpi_ec_read(ec, addr, &temp_data);
531 if (!err) {
532 *val = temp_data;
533 return 0;
534 } else
535 return err;
536 }
538 EXPORT_SYMBOL(ec_read);
540 int ec_write(u8 addr, u8 val)
541 {
542 union acpi_ec *ec;
543 int err;
545 if (!first_ec)
546 return -ENODEV;
548 ec = acpi_driver_data(first_ec);
550 err = acpi_ec_write(ec, addr, val);
552 return err;
553 }
555 EXPORT_SYMBOL(ec_write);
557 static int acpi_ec_query(union acpi_ec *ec, u32 * data)
558 {
559 if (acpi_ec_poll_mode)
560 return acpi_ec_poll_query(ec, data);
561 else
562 return acpi_ec_intr_query(ec, data);
563 }
564 static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data)
565 {
566 int result = 0;
567 acpi_status status = AE_OK;
568 u32 glk = 0;
571 if (!ec || !data)
572 return -EINVAL;
574 *data = 0;
576 if (ec->common.global_lock) {
577 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
578 if (ACPI_FAILURE(status))
579 return -ENODEV;
580 }
582 /*
583 * Query the EC to find out which _Qxx method we need to evaluate.
584 * Note that successful completion of the query causes the ACPI_EC_SCI
585 * bit to be cleared (and thus clearing the interrupt source).
586 */
587 if (down_interruptible(&ec->poll.sem)) {
588 result = -ERESTARTSYS;
589 goto end_nosem;
590 }
592 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY,
593 &ec->common.command_addr);
594 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
595 if (result)
596 goto end;
598 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
599 if (!*data)
600 result = -ENODATA;
602 end:
603 up(&ec->poll.sem);
604 end_nosem:
605 if (ec->common.global_lock)
606 acpi_release_global_lock(glk);
608 return result;
609 }
610 static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data)
611 {
612 int status = 0;
613 u32 glk;
616 if (!ec || !data)
617 return -EINVAL;
618 *data = 0;
620 if (ec->common.global_lock) {
621 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
622 if (ACPI_FAILURE(status))
623 return -ENODEV;
624 }
626 down(&ec->intr.sem);
628 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
629 if (status) {
630 printk(KERN_DEBUG PREFIX "query EC, IB not empty\n");
631 goto end;
632 }
633 /*
634 * Query the EC to find out which _Qxx method we need to evaluate.
635 * Note that successful completion of the query causes the ACPI_EC_SCI
636 * bit to be cleared (and thus clearing the interrupt source).
637 */
638 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY,
639 &ec->common.command_addr);
640 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
641 if (status) {
642 printk(KERN_DEBUG PREFIX "query EC, OB not full\n");
643 goto end;
644 }
646 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
647 if (!*data)
648 status = -ENODATA;
650 end:
651 up(&ec->intr.sem);
653 if (ec->common.global_lock)
654 acpi_release_global_lock(glk);
656 return status;
657 }
659 /* --------------------------------------------------------------------------
660 Event Management
661 -------------------------------------------------------------------------- */
663 union acpi_ec_query_data {
664 acpi_handle handle;
665 u8 data;
666 };
668 static void acpi_ec_gpe_query(void *ec_cxt)
669 {
670 if (acpi_ec_poll_mode)
671 acpi_ec_gpe_poll_query(ec_cxt);
672 else
673 acpi_ec_gpe_intr_query(ec_cxt);
674 }
676 static void acpi_ec_gpe_poll_query(void *ec_cxt)
677 {
678 union acpi_ec *ec = (union acpi_ec *)ec_cxt;
679 u32 value = 0;
680 static char object_name[5] = { '_', 'Q', '0', '0', '\0' };
681 const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7',
682 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
683 };
686 if (!ec_cxt)
687 goto end;
689 if (down_interruptible (&ec->poll.sem)) {
690 return;
691 }
692 acpi_hw_low_level_read(8, &value, &ec->common.command_addr);
693 up(&ec->poll.sem);
695 /* TBD: Implement asynch events!
696 * NOTE: All we care about are EC-SCI's. Other EC events are
697 * handled via polling (yuck!). This is because some systems
698 * treat EC-SCIs as level (versus EDGE!) triggered, preventing
699 * a purely interrupt-driven approach (grumble, grumble).
700 */
701 if (!(value & ACPI_EC_FLAG_SCI))
702 goto end;
704 if (acpi_ec_query(ec, &value))
705 goto end;
707 object_name[2] = hex[((value >> 4) & 0x0F)];
708 object_name[3] = hex[(value & 0x0F)];
710 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name));
712 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
714 end:
715 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
716 }
717 static void acpi_ec_gpe_intr_query(void *ec_cxt)
718 {
719 union acpi_ec *ec = (union acpi_ec *)ec_cxt;
720 u32 value;
721 int result = -ENODATA;
722 static char object_name[5] = { '_', 'Q', '0', '0', '\0' };
723 const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7',
724 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
725 };
728 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_SCI)
729 result = acpi_ec_query(ec, &value);
731 if (result)
732 goto end;
734 object_name[2] = hex[((value >> 4) & 0x0F)];
735 object_name[3] = hex[(value & 0x0F)];
737 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name));
739 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
740 end:
741 atomic_dec(&ec->intr.pending_gpe);
742 return;
743 }
745 static u32 acpi_ec_gpe_handler(void *data)
746 {
747 if (acpi_ec_poll_mode)
748 return acpi_ec_gpe_poll_handler(data);
749 else
750 return acpi_ec_gpe_intr_handler(data);
751 }
752 static u32 acpi_ec_gpe_poll_handler(void *data)
753 {
754 acpi_status status = AE_OK;
755 union acpi_ec *ec = (union acpi_ec *)data;
757 if (!ec)
758 return ACPI_INTERRUPT_NOT_HANDLED;
760 acpi_disable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
762 status = acpi_os_execute(OSL_EC_POLL_HANDLER, acpi_ec_gpe_query, ec);
764 if (status == AE_OK)
765 return ACPI_INTERRUPT_HANDLED;
766 else
767 return ACPI_INTERRUPT_NOT_HANDLED;
768 }
769 static u32 acpi_ec_gpe_intr_handler(void *data)
770 {
771 acpi_status status = AE_OK;
772 u32 value;
773 union acpi_ec *ec = (union acpi_ec *)data;
775 if (!ec)
776 return ACPI_INTERRUPT_NOT_HANDLED;
778 acpi_clear_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
779 value = acpi_ec_read_status(ec);
781 switch (ec->intr.expect_event) {
782 case ACPI_EC_EVENT_OBF:
783 if (!(value & ACPI_EC_FLAG_OBF))
784 break;
785 ec->intr.expect_event = 0;
786 wake_up(&ec->intr.wait);
787 break;
788 case ACPI_EC_EVENT_IBE:
789 if ((value & ACPI_EC_FLAG_IBF))
790 break;
791 ec->intr.expect_event = 0;
792 wake_up(&ec->intr.wait);
793 break;
794 default:
795 break;
796 }
798 if (value & ACPI_EC_FLAG_SCI) {
799 atomic_add(1, &ec->intr.pending_gpe);
800 status = acpi_os_execute(OSL_EC_BURST_HANDLER,
801 acpi_ec_gpe_query, ec);
802 return status == AE_OK ?
803 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
804 }
805 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
806 return status == AE_OK ?
807 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
808 }
810 /* --------------------------------------------------------------------------
811 Address Space Management
812 -------------------------------------------------------------------------- */
814 static acpi_status
815 acpi_ec_space_setup(acpi_handle region_handle,
816 u32 function, void *handler_context, void **return_context)
817 {
818 /*
819 * The EC object is in the handler context and is needed
820 * when calling the acpi_ec_space_handler.
821 */
822 *return_context = (function != ACPI_REGION_DEACTIVATE) ?
823 handler_context : NULL;
825 return AE_OK;
826 }
828 static acpi_status
829 acpi_ec_space_handler(u32 function,
830 acpi_physical_address address,
831 u32 bit_width,
832 acpi_integer * value,
833 void *handler_context, void *region_context)
834 {
835 int result = 0;
836 union acpi_ec *ec = NULL;
837 u64 temp = *value;
838 acpi_integer f_v = 0;
839 int i = 0;
842 if ((address > 0xFF) || !value || !handler_context)
843 return AE_BAD_PARAMETER;
845 if (bit_width != 8 && acpi_strict) {
846 printk(KERN_WARNING PREFIX
847 "acpi_ec_space_handler: bit_width should be 8\n");
848 return AE_BAD_PARAMETER;
849 }
851 ec = (union acpi_ec *)handler_context;
853 next_byte:
854 switch (function) {
855 case ACPI_READ:
856 temp = 0;
857 result = acpi_ec_read(ec, (u8) address, (u32 *) & temp);
858 break;
859 case ACPI_WRITE:
860 result = acpi_ec_write(ec, (u8) address, (u8) temp);
861 break;
862 default:
863 result = -EINVAL;
864 goto out;
865 break;
866 }
868 bit_width -= 8;
869 if (bit_width) {
870 if (function == ACPI_READ)
871 f_v |= temp << 8 * i;
872 if (function == ACPI_WRITE)
873 temp >>= 8;
874 i++;
875 address++;
876 goto next_byte;
877 }
879 if (function == ACPI_READ) {
880 f_v |= temp << 8 * i;
881 *value = f_v;
882 }
884 out:
885 switch (result) {
886 case -EINVAL:
887 return AE_BAD_PARAMETER;
888 break;
889 case -ENODEV:
890 return AE_NOT_FOUND;
891 break;
892 case -ETIME:
893 return AE_TIME;
894 break;
895 default:
896 return AE_OK;
897 }
898 }
900 /* --------------------------------------------------------------------------
901 FS Interface (/proc)
902 -------------------------------------------------------------------------- */
904 static struct proc_dir_entry *acpi_ec_dir;
906 static int acpi_ec_read_info(struct seq_file *seq, void *offset)
907 {
908 union acpi_ec *ec = (union acpi_ec *)seq->private;
911 if (!ec)
912 goto end;
914 seq_printf(seq, "gpe bit: 0x%02x\n",
915 (u32) ec->common.gpe_bit);
916 seq_printf(seq, "ports: 0x%02x, 0x%02x\n",
917 (u32) ec->common.status_addr.address,
918 (u32) ec->common.data_addr.address);
919 seq_printf(seq, "use global lock: %s\n",
920 ec->common.global_lock ? "yes" : "no");
921 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
923 end:
924 return 0;
925 }
927 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
928 {
929 return single_open(file, acpi_ec_read_info, PDE(inode)->data);
930 }
932 static const struct file_operations acpi_ec_info_ops = {
933 .open = acpi_ec_info_open_fs,
934 .read = seq_read,
935 .llseek = seq_lseek,
936 .release = single_release,
937 .owner = THIS_MODULE,
938 };
940 static int acpi_ec_add_fs(struct acpi_device *device)
941 {
942 struct proc_dir_entry *entry = NULL;
945 if (!acpi_device_dir(device)) {
946 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
947 acpi_ec_dir);
948 if (!acpi_device_dir(device))
949 return -ENODEV;
950 }
952 entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
953 acpi_device_dir(device));
954 if (!entry)
955 return -ENODEV;
956 else {
957 entry->proc_fops = &acpi_ec_info_ops;
958 entry->data = acpi_driver_data(device);
959 entry->owner = THIS_MODULE;
960 }
962 return 0;
963 }
965 static int acpi_ec_remove_fs(struct acpi_device *device)
966 {
968 if (acpi_device_dir(device)) {
969 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
970 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir);
971 acpi_device_dir(device) = NULL;
972 }
974 return 0;
975 }
977 /* --------------------------------------------------------------------------
978 Driver Interface
979 -------------------------------------------------------------------------- */
981 static int acpi_ec_poll_add(struct acpi_device *device)
982 {
983 int result = 0;
984 acpi_status status = AE_OK;
985 union acpi_ec *ec = NULL;
988 if (!device)
989 return -EINVAL;
991 ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
992 if (!ec)
993 return -ENOMEM;
994 memset(ec, 0, sizeof(union acpi_ec));
996 ec->common.handle = device->handle;
997 ec->common.uid = -1;
998 init_MUTEX(&ec->poll.sem);
999 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1000 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1001 acpi_driver_data(device) = ec;
1003 /* Use the global lock for all EC transactions? */
1004 acpi_evaluate_integer(ec->common.handle, "_GLK", NULL,
1005 &ec->common.global_lock);
1007 /* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
1008 http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
1009 if (ec_ecdt) {
1010 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
1011 ACPI_ADR_SPACE_EC,
1012 &acpi_ec_space_handler);
1014 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1015 &acpi_ec_gpe_handler);
1017 kfree(ec_ecdt);
1020 /* Get GPE bit assignment (EC events). */
1021 /* TODO: Add support for _GPE returning a package */
1022 status =
1023 acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
1024 &ec->common.gpe_bit);
1025 if (ACPI_FAILURE(status)) {
1026 ACPI_EXCEPTION((AE_INFO, status, "Obtaining GPE bit"));
1027 result = -ENODEV;
1028 goto end;
1031 result = acpi_ec_add_fs(device);
1032 if (result)
1033 goto end;
1035 printk(KERN_INFO PREFIX "%s [%s] (gpe %d) polling mode.\n",
1036 acpi_device_name(device), acpi_device_bid(device),
1037 (u32) ec->common.gpe_bit);
1039 if (!first_ec)
1040 first_ec = device;
1042 end:
1043 if (result)
1044 kfree(ec);
1046 return result;
1048 static int acpi_ec_intr_add(struct acpi_device *device)
1050 int result = 0;
1051 acpi_status status = AE_OK;
1052 union acpi_ec *ec = NULL;
1055 if (!device)
1056 return -EINVAL;
1058 ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1059 if (!ec)
1060 return -ENOMEM;
1061 memset(ec, 0, sizeof(union acpi_ec));
1063 ec->common.handle = device->handle;
1064 ec->common.uid = -1;
1065 atomic_set(&ec->intr.pending_gpe, 0);
1066 atomic_set(&ec->intr.leaving_burst, 1);
1067 init_MUTEX(&ec->intr.sem);
1068 init_waitqueue_head(&ec->intr.wait);
1069 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1070 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1071 acpi_driver_data(device) = ec;
1073 /* Use the global lock for all EC transactions? */
1074 acpi_evaluate_integer(ec->common.handle, "_GLK", NULL,
1075 &ec->common.global_lock);
1077 /* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
1078 http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
1079 if (ec_ecdt) {
1080 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
1081 ACPI_ADR_SPACE_EC,
1082 &acpi_ec_space_handler);
1084 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1085 &acpi_ec_gpe_handler);
1087 kfree(ec_ecdt);
1090 /* Get GPE bit assignment (EC events). */
1091 /* TODO: Add support for _GPE returning a package */
1092 status =
1093 acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
1094 &ec->common.gpe_bit);
1095 if (ACPI_FAILURE(status)) {
1096 printk(KERN_ERR PREFIX "Obtaining GPE bit assignment\n");
1097 result = -ENODEV;
1098 goto end;
1101 result = acpi_ec_add_fs(device);
1102 if (result)
1103 goto end;
1105 printk(KERN_INFO PREFIX "%s [%s] (gpe %d) interrupt mode.\n",
1106 acpi_device_name(device), acpi_device_bid(device),
1107 (u32) ec->common.gpe_bit);
1109 if (!first_ec)
1110 first_ec = device;
1112 end:
1113 if (result)
1114 kfree(ec);
1116 return result;
1119 static int acpi_ec_remove(struct acpi_device *device, int type)
1121 union acpi_ec *ec = NULL;
1124 if (!device)
1125 return -EINVAL;
1127 ec = acpi_driver_data(device);
1129 acpi_ec_remove_fs(device);
1131 kfree(ec);
1133 return 0;
1136 static acpi_status
1137 acpi_ec_io_ports(struct acpi_resource *resource, void *context)
1139 union acpi_ec *ec = (union acpi_ec *)context;
1140 struct acpi_generic_address *addr;
1142 if (resource->type != ACPI_RESOURCE_TYPE_IO) {
1143 return AE_OK;
1146 /*
1147 * The first address region returned is the data port, and
1148 * the second address region returned is the status/command
1149 * port.
1150 */
1151 if (ec->common.data_addr.register_bit_width == 0) {
1152 addr = &ec->common.data_addr;
1153 } else if (ec->common.command_addr.register_bit_width == 0) {
1154 addr = &ec->common.command_addr;
1155 } else {
1156 return AE_CTRL_TERMINATE;
1159 addr->address_space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1160 addr->register_bit_width = 8;
1161 addr->register_bit_offset = 0;
1162 addr->address = resource->data.io.minimum;
1164 return AE_OK;
1167 static int acpi_ec_start(struct acpi_device *device)
1169 acpi_status status = AE_OK;
1170 union acpi_ec *ec = NULL;
1173 if (!device)
1174 return -EINVAL;
1176 ec = acpi_driver_data(device);
1178 if (!ec)
1179 return -EINVAL;
1181 /*
1182 * Get I/O port addresses. Convert to GAS format.
1183 */
1184 status = acpi_walk_resources(ec->common.handle, METHOD_NAME__CRS,
1185 acpi_ec_io_ports, ec);
1186 if (ACPI_FAILURE(status)
1187 || ec->common.command_addr.register_bit_width == 0) {
1188 printk(KERN_ERR PREFIX "Error getting I/O port addresses\n");
1189 return -ENODEV;
1192 ec->common.status_addr = ec->common.command_addr;
1194 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n",
1195 (u32) ec->common.gpe_bit,
1196 (u32) ec->common.command_addr.address,
1197 (u32) ec->common.data_addr.address));
1199 /*
1200 * Install GPE handler
1201 */
1202 status = acpi_install_gpe_handler(NULL, ec->common.gpe_bit,
1203 ACPI_GPE_EDGE_TRIGGERED,
1204 &acpi_ec_gpe_handler, ec);
1205 if (ACPI_FAILURE(status)) {
1206 return -ENODEV;
1208 acpi_set_gpe_type(NULL, ec->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1209 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
1211 status = acpi_install_address_space_handler(ec->common.handle,
1212 ACPI_ADR_SPACE_EC,
1213 &acpi_ec_space_handler,
1214 &acpi_ec_space_setup, ec);
1215 if (ACPI_FAILURE(status)) {
1216 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
1217 &acpi_ec_gpe_handler);
1218 return -ENODEV;
1221 return AE_OK;
1224 static int acpi_ec_stop(struct acpi_device *device, int type)
1226 acpi_status status = AE_OK;
1227 union acpi_ec *ec = NULL;
1230 if (!device)
1231 return -EINVAL;
1233 ec = acpi_driver_data(device);
1235 status = acpi_remove_address_space_handler(ec->common.handle,
1236 ACPI_ADR_SPACE_EC,
1237 &acpi_ec_space_handler);
1238 if (ACPI_FAILURE(status))
1239 return -ENODEV;
1241 status =
1242 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
1243 &acpi_ec_gpe_handler);
1244 if (ACPI_FAILURE(status))
1245 return -ENODEV;
1247 return 0;
1250 static acpi_status __init
1251 acpi_fake_ecdt_callback(acpi_handle handle,
1252 u32 Level, void *context, void **retval)
1255 if (acpi_ec_poll_mode)
1256 return acpi_fake_ecdt_poll_callback(handle,
1257 Level, context, retval);
1258 else
1259 return acpi_fake_ecdt_intr_callback(handle,
1260 Level, context, retval);
1263 static acpi_status __init
1264 acpi_fake_ecdt_poll_callback(acpi_handle handle,
1265 u32 Level, void *context, void **retval)
1267 acpi_status status;
1269 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1270 acpi_ec_io_ports, ec_ecdt);
1271 if (ACPI_FAILURE(status))
1272 return status;
1273 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
1275 ec_ecdt->common.uid = -1;
1276 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
1278 status =
1279 acpi_evaluate_integer(handle, "_GPE", NULL,
1280 &ec_ecdt->common.gpe_bit);
1281 if (ACPI_FAILURE(status))
1282 return status;
1283 init_MUTEX(&ec_ecdt->poll.sem);
1284 ec_ecdt->common.global_lock = TRUE;
1285 ec_ecdt->common.handle = handle;
1287 printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1288 (u32) ec_ecdt->common.gpe_bit,
1289 (u32) ec_ecdt->common.command_addr.address,
1290 (u32) ec_ecdt->common.data_addr.address);
1292 return AE_CTRL_TERMINATE;
1295 static acpi_status __init
1296 acpi_fake_ecdt_intr_callback(acpi_handle handle,
1297 u32 Level, void *context, void **retval)
1299 acpi_status status;
1301 init_MUTEX(&ec_ecdt->intr.sem);
1302 init_waitqueue_head(&ec_ecdt->intr.wait);
1303 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1304 acpi_ec_io_ports, ec_ecdt);
1305 if (ACPI_FAILURE(status))
1306 return status;
1307 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
1309 ec_ecdt->common.uid = -1;
1310 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
1312 status =
1313 acpi_evaluate_integer(handle, "_GPE", NULL,
1314 &ec_ecdt->common.gpe_bit);
1315 if (ACPI_FAILURE(status))
1316 return status;
1317 ec_ecdt->common.global_lock = TRUE;
1318 ec_ecdt->common.handle = handle;
1320 printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1321 (u32) ec_ecdt->common.gpe_bit,
1322 (u32) ec_ecdt->common.command_addr.address,
1323 (u32) ec_ecdt->common.data_addr.address);
1325 return AE_CTRL_TERMINATE;
1328 /*
1329 * Some BIOS (such as some from Gateway laptops) access EC region very early
1330 * such as in BAT0._INI or EC._INI before an EC device is found and
1331 * do not provide an ECDT. According to ACPI spec, ECDT isn't mandatorily
1332 * required, but if EC regison is accessed early, it is required.
1333 * The routine tries to workaround the BIOS bug by pre-scan EC device
1334 * It assumes that _CRS, _HID, _GPE, _UID methods of EC don't touch any
1335 * op region (since _REG isn't invoked yet). The assumption is true for
1336 * all systems found.
1337 */
1338 static int __init acpi_ec_fake_ecdt(void)
1340 acpi_status status;
1341 int ret = 0;
1343 printk(KERN_INFO PREFIX "Try to make an fake ECDT\n");
1345 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1346 if (!ec_ecdt) {
1347 ret = -ENOMEM;
1348 goto error;
1350 memset(ec_ecdt, 0, sizeof(union acpi_ec));
1352 status = acpi_get_devices(ACPI_EC_HID,
1353 acpi_fake_ecdt_callback, NULL, NULL);
1354 if (ACPI_FAILURE(status)) {
1355 kfree(ec_ecdt);
1356 ec_ecdt = NULL;
1357 ret = -ENODEV;
1358 goto error;
1360 return 0;
1361 error:
1362 printk(KERN_ERR PREFIX "Can't make an fake ECDT\n");
1363 return ret;
1366 static int __init acpi_ec_get_real_ecdt(void)
1368 if (acpi_ec_poll_mode)
1369 return acpi_ec_poll_get_real_ecdt();
1370 else
1371 return acpi_ec_intr_get_real_ecdt();
1374 static int __init acpi_ec_poll_get_real_ecdt(void)
1376 acpi_status status;
1377 struct acpi_table_ecdt *ecdt_ptr;
1379 status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
1380 (struct acpi_table_header **)
1381 &ecdt_ptr);
1382 if (ACPI_FAILURE(status))
1383 return -ENODEV;
1385 printk(KERN_INFO PREFIX "Found ECDT\n");
1387 /*
1388 * Generate a temporary ec context to use until the namespace is scanned
1389 */
1390 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1391 if (!ec_ecdt)
1392 return -ENOMEM;
1393 memset(ec_ecdt, 0, sizeof(union acpi_ec));
1395 ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1396 ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1397 ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1398 ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
1399 init_MUTEX(&ec_ecdt->poll.sem);
1400 /* use the GL just to be safe */
1401 ec_ecdt->common.global_lock = TRUE;
1402 ec_ecdt->common.uid = ecdt_ptr->uid;
1404 status =
1405 acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
1406 if (ACPI_FAILURE(status)) {
1407 goto error;
1410 return 0;
1411 error:
1412 printk(KERN_ERR PREFIX "Could not use ECDT\n");
1413 kfree(ec_ecdt);
1414 ec_ecdt = NULL;
1416 return -ENODEV;
1419 static int __init acpi_ec_intr_get_real_ecdt(void)
1421 acpi_status status;
1422 struct acpi_table_ecdt *ecdt_ptr;
1424 status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
1425 (struct acpi_table_header **)
1426 &ecdt_ptr);
1427 if (ACPI_FAILURE(status))
1428 return -ENODEV;
1430 printk(KERN_INFO PREFIX "Found ECDT\n");
1432 /*
1433 * Generate a temporary ec context to use until the namespace is scanned
1434 */
1435 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1436 if (!ec_ecdt)
1437 return -ENOMEM;
1438 memset(ec_ecdt, 0, sizeof(union acpi_ec));
1440 init_MUTEX(&ec_ecdt->intr.sem);
1441 init_waitqueue_head(&ec_ecdt->intr.wait);
1442 ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1443 ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1444 ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1445 ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
1446 /* use the GL just to be safe */
1447 ec_ecdt->common.global_lock = TRUE;
1448 ec_ecdt->common.uid = ecdt_ptr->uid;
1450 status =
1451 acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
1452 if (ACPI_FAILURE(status)) {
1453 goto error;
1456 return 0;
1457 error:
1458 printk(KERN_ERR PREFIX "Could not use ECDT\n");
1459 kfree(ec_ecdt);
1460 ec_ecdt = NULL;
1462 return -ENODEV;
1465 static int __initdata acpi_fake_ecdt_enabled;
1466 int __init acpi_ec_ecdt_probe(void)
1468 acpi_status status;
1469 int ret;
1471 ret = acpi_ec_get_real_ecdt();
1472 /* Try to make a fake ECDT */
1473 if (ret && acpi_fake_ecdt_enabled) {
1474 ret = acpi_ec_fake_ecdt();
1477 if (ret)
1478 return 0;
1480 /*
1481 * Install GPE handler
1482 */
1483 status = acpi_install_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1484 ACPI_GPE_EDGE_TRIGGERED,
1485 &acpi_ec_gpe_handler, ec_ecdt);
1486 if (ACPI_FAILURE(status)) {
1487 goto error;
1489 acpi_set_gpe_type(NULL, ec_ecdt->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1490 acpi_enable_gpe(NULL, ec_ecdt->common.gpe_bit, ACPI_NOT_ISR);
1492 status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
1493 ACPI_ADR_SPACE_EC,
1494 &acpi_ec_space_handler,
1495 &acpi_ec_space_setup,
1496 ec_ecdt);
1497 if (ACPI_FAILURE(status)) {
1498 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1499 &acpi_ec_gpe_handler);
1500 goto error;
1503 return 0;
1505 error:
1506 printk(KERN_ERR PREFIX "Could not use ECDT\n");
1507 kfree(ec_ecdt);
1508 ec_ecdt = NULL;
1510 return -ENODEV;
1513 static int __init acpi_ec_init(void)
1515 int result = 0;
1518 if (acpi_disabled)
1519 return 0;
1521 acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
1522 if (!acpi_ec_dir)
1523 return -ENODEV;
1525 /* Now register the driver for the EC */
1526 result = acpi_bus_register_driver(&acpi_ec_driver);
1527 if (result < 0) {
1528 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1529 return -ENODEV;
1532 return result;
1535 subsys_initcall(acpi_ec_init);
1537 /* EC driver currently not unloadable */
1538 #if 0
1539 static void __exit acpi_ec_exit(void)
1542 acpi_bus_unregister_driver(&acpi_ec_driver);
1544 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1546 return;
1548 #endif /* 0 */
1550 static int __init acpi_fake_ecdt_setup(char *str)
1552 acpi_fake_ecdt_enabled = 1;
1553 return 1;
1556 __setup("acpi_fake_ecdt", acpi_fake_ecdt_setup);
1557 static int __init acpi_ec_set_intr_mode(char *str)
1559 int intr;
1561 if (!get_option(&str, &intr))
1562 return 0;
1564 if (intr) {
1565 acpi_ec_poll_mode = EC_INTR;
1566 acpi_ec_driver.ops.add = acpi_ec_intr_add;
1567 } else {
1568 acpi_ec_poll_mode = EC_POLL;
1569 acpi_ec_driver.ops.add = acpi_ec_poll_add;
1571 printk(KERN_INFO PREFIX "EC %s mode.\n", intr ? "interrupt" : "polling");
1572 return 1;
1575 __setup("ec_intr=", acpi_ec_set_intr_mode);