aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/acpi
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/acpi')
-rw-r--r--drivers/acpi/Kconfig5
-rw-r--r--drivers/acpi/button.c206
-rw-r--r--drivers/acpi/dispatcher/dswload.c6
-rw-r--r--drivers/acpi/ec.c907
-rw-r--r--drivers/acpi/hotkey.c690
-rw-r--r--drivers/acpi/osl.c6
-rw-r--r--drivers/acpi/pci_irq.c85
-rw-r--r--drivers/acpi/pci_link.c127
-rw-r--r--drivers/acpi/processor_idle.c32
9 files changed, 1525 insertions, 539 deletions
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 986410e7b483..ba13896cae40 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -133,9 +133,10 @@ config ACPI_HOTKEY
133 depends on ACPI_INTERPRETER 133 depends on ACPI_INTERPRETER
134 depends on EXPERIMENTAL 134 depends on EXPERIMENTAL
135 depends on !IA64_SGI_SN 135 depends on !IA64_SGI_SN
136 default m 136 default n
137 help 137 help
138 ACPI generic hotkey 138 Experimental consolidated hotkey driver.
139 If you are unsure, say N.
139 140
140config ACPI_FAN 141config ACPI_FAN
141 tristate "Fan" 142 tristate "Fan"
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index 0f45d45f05a0..8162fd0c21a7 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -26,6 +26,9 @@
26#include <linux/kernel.h> 26#include <linux/kernel.h>
27#include <linux/module.h> 27#include <linux/module.h>
28#include <linux/init.h> 28#include <linux/init.h>
29#include <linux/types.h>
30#include <linux/proc_fs.h>
31#include <linux/seq_file.h>
29#include <acpi/acpi_bus.h> 32#include <acpi/acpi_bus.h>
30#include <acpi/acpi_drivers.h> 33#include <acpi/acpi_drivers.h>
31 34
@@ -33,6 +36,9 @@
33#define ACPI_BUTTON_COMPONENT 0x00080000 36#define ACPI_BUTTON_COMPONENT 0x00080000
34#define ACPI_BUTTON_DRIVER_NAME "ACPI Button Driver" 37#define ACPI_BUTTON_DRIVER_NAME "ACPI Button Driver"
35#define ACPI_BUTTON_CLASS "button" 38#define ACPI_BUTTON_CLASS "button"
39#define ACPI_BUTTON_FILE_INFO "info"
40#define ACPI_BUTTON_FILE_STATE "state"
41#define ACPI_BUTTON_TYPE_UNKNOWN 0x00
36#define ACPI_BUTTON_NOTIFY_STATUS 0x80 42#define ACPI_BUTTON_NOTIFY_STATUS 0x80
37 43
38#define ACPI_BUTTON_SUBCLASS_POWER "power" 44#define ACPI_BUTTON_SUBCLASS_POWER "power"
@@ -64,6 +70,8 @@ MODULE_LICENSE("GPL");
64 70
65static int acpi_button_add (struct acpi_device *device); 71static int acpi_button_add (struct acpi_device *device);
66static int acpi_button_remove (struct acpi_device *device, int type); 72static int acpi_button_remove (struct acpi_device *device, int type);
73static int acpi_button_info_open_fs(struct inode *inode, struct file *file);
74static int acpi_button_state_open_fs(struct inode *inode, struct file *file);
67 75
68static struct acpi_driver acpi_button_driver = { 76static struct acpi_driver acpi_button_driver = {
69 .name = ACPI_BUTTON_DRIVER_NAME, 77 .name = ACPI_BUTTON_DRIVER_NAME,
@@ -82,6 +90,179 @@ struct acpi_button {
82 unsigned long pushed; 90 unsigned long pushed;
83}; 91};
84 92
93static struct file_operations acpi_button_info_fops = {
94 .open = acpi_button_info_open_fs,
95 .read = seq_read,
96 .llseek = seq_lseek,
97 .release = single_release,
98};
99
100static struct file_operations acpi_button_state_fops = {
101 .open = acpi_button_state_open_fs,
102 .read = seq_read,
103 .llseek = seq_lseek,
104 .release = single_release,
105};
106/* --------------------------------------------------------------------------
107 FS Interface (/proc)
108 -------------------------------------------------------------------------- */
109
110static struct proc_dir_entry *acpi_button_dir;
111
112static int acpi_button_info_seq_show(struct seq_file *seq, void *offset)
113{
114 struct acpi_button *button = (struct acpi_button *) seq->private;
115
116 ACPI_FUNCTION_TRACE("acpi_button_info_seq_show");
117
118 if (!button || !button->device)
119 return_VALUE(0);
120
121 seq_printf(seq, "type: %s\n",
122 acpi_device_name(button->device));
123
124 return_VALUE(0);
125}
126
127static int acpi_button_info_open_fs(struct inode *inode, struct file *file)
128{
129 return single_open(file, acpi_button_info_seq_show, PDE(inode)->data);
130}
131
132static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
133{
134 struct acpi_button *button = (struct acpi_button *) seq->private;
135 acpi_status status;
136 unsigned long state;
137
138 ACPI_FUNCTION_TRACE("acpi_button_state_seq_show");
139
140 if (!button || !button->device)
141 return_VALUE(0);
142
143 status = acpi_evaluate_integer(button->handle,"_LID",NULL,&state);
144 if (ACPI_FAILURE(status)) {
145 seq_printf(seq, "state: unsupported\n");
146 }
147 else{
148 seq_printf(seq, "state: %s\n", (state ? "open" : "closed"));
149 }
150
151 return_VALUE(0);
152}
153
154static int acpi_button_state_open_fs(struct inode *inode, struct file *file)
155{
156 return single_open(file, acpi_button_state_seq_show, PDE(inode)->data);
157}
158
159static struct proc_dir_entry *acpi_power_dir;
160static struct proc_dir_entry *acpi_sleep_dir;
161static struct proc_dir_entry *acpi_lid_dir;
162
163static int
164acpi_button_add_fs (
165 struct acpi_device *device)
166{
167 struct proc_dir_entry *entry = NULL;
168 struct acpi_button *button = NULL;
169
170 ACPI_FUNCTION_TRACE("acpi_button_add_fs");
171
172 if (!device || !acpi_driver_data(device))
173 return_VALUE(-EINVAL);
174
175 button = acpi_driver_data(device);
176
177 switch (button->type) {
178 case ACPI_BUTTON_TYPE_POWER:
179 case ACPI_BUTTON_TYPE_POWERF:
180 if (!acpi_power_dir)
181 acpi_power_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_POWER,
182 acpi_button_dir);
183 entry = acpi_power_dir;
184 break;
185 case ACPI_BUTTON_TYPE_SLEEP:
186 case ACPI_BUTTON_TYPE_SLEEPF:
187 if (!acpi_sleep_dir)
188 acpi_sleep_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_SLEEP,
189 acpi_button_dir);
190 entry = acpi_sleep_dir;
191 break;
192 case ACPI_BUTTON_TYPE_LID:
193 if (!acpi_lid_dir)
194 acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID,
195 acpi_button_dir);
196 entry = acpi_lid_dir;
197 break;
198 }
199
200 if (!entry)
201 return_VALUE(-ENODEV);
202 entry->owner = THIS_MODULE;
203
204 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), entry);
205 if (!acpi_device_dir(device))
206 return_VALUE(-ENODEV);
207 acpi_device_dir(device)->owner = THIS_MODULE;
208
209 /* 'info' [R] */
210 entry = create_proc_entry(ACPI_BUTTON_FILE_INFO,
211 S_IRUGO, acpi_device_dir(device));
212 if (!entry)
213 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
214 "Unable to create '%s' fs entry\n",
215 ACPI_BUTTON_FILE_INFO));
216 else {
217 entry->proc_fops = &acpi_button_info_fops;
218 entry->data = acpi_driver_data(device);
219 entry->owner = THIS_MODULE;
220 }
221
222 /* show lid state [R] */
223 if (button->type == ACPI_BUTTON_TYPE_LID) {
224 entry = create_proc_entry(ACPI_BUTTON_FILE_STATE,
225 S_IRUGO, acpi_device_dir(device));
226 if (!entry)
227 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
228 "Unable to create '%s' fs entry\n",
229 ACPI_BUTTON_FILE_INFO));
230 else {
231 entry->proc_fops = &acpi_button_state_fops;
232 entry->data = acpi_driver_data(device);
233 entry->owner = THIS_MODULE;
234 }
235 }
236
237 return_VALUE(0);
238}
239
240
241static int
242acpi_button_remove_fs (
243 struct acpi_device *device)
244{
245 struct acpi_button *button = NULL;
246
247 ACPI_FUNCTION_TRACE("acpi_button_remove_fs");
248
249 button = acpi_driver_data(device);
250 if (acpi_device_dir(device)) {
251 if (button->type == ACPI_BUTTON_TYPE_LID)
252 remove_proc_entry(ACPI_BUTTON_FILE_STATE,
253 acpi_device_dir(device));
254 remove_proc_entry(ACPI_BUTTON_FILE_INFO,
255 acpi_device_dir(device));
256
257 remove_proc_entry(acpi_device_bid(device),
258 acpi_device_dir(device)->parent);
259 acpi_device_dir(device) = NULL;
260 }
261
262 return_VALUE(0);
263}
264
265
85/* -------------------------------------------------------------------------- 266/* --------------------------------------------------------------------------
86 Driver Interface 267 Driver Interface
87 -------------------------------------------------------------------------- */ 268 -------------------------------------------------------------------------- */
@@ -121,7 +302,8 @@ acpi_button_notify_fixed (
121 302
122 ACPI_FUNCTION_TRACE("acpi_button_notify_fixed"); 303 ACPI_FUNCTION_TRACE("acpi_button_notify_fixed");
123 304
124 BUG_ON(!button); 305 if (!button)
306 return_ACPI_STATUS(AE_BAD_PARAMETER);
125 307
126 acpi_button_notify(button->handle, ACPI_BUTTON_NOTIFY_STATUS, button); 308 acpi_button_notify(button->handle, ACPI_BUTTON_NOTIFY_STATUS, button);
127 309
@@ -197,6 +379,10 @@ acpi_button_add (
197 goto end; 379 goto end;
198 } 380 }
199 381
382 result = acpi_button_add_fs(device);
383 if (result)
384 goto end;
385
200 switch (button->type) { 386 switch (button->type) {
201 case ACPI_BUTTON_TYPE_POWERF: 387 case ACPI_BUTTON_TYPE_POWERF:
202 status = acpi_install_fixed_event_handler ( 388 status = acpi_install_fixed_event_handler (
@@ -240,6 +426,7 @@ acpi_button_add (
240 426
241end: 427end:
242 if (result) { 428 if (result) {
429 acpi_button_remove_fs(device);
243 kfree(button); 430 kfree(button);
244 } 431 }
245 432
@@ -280,6 +467,8 @@ acpi_button_remove (struct acpi_device *device, int type)
280 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 467 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
281 "Error removing notify handler\n")); 468 "Error removing notify handler\n"));
282 469
470 acpi_button_remove_fs(device);
471
283 kfree(button); 472 kfree(button);
284 473
285 return_VALUE(0); 474 return_VALUE(0);
@@ -293,14 +482,20 @@ acpi_button_init (void)
293 482
294 ACPI_FUNCTION_TRACE("acpi_button_init"); 483 ACPI_FUNCTION_TRACE("acpi_button_init");
295 484
485 acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
486 if (!acpi_button_dir)
487 return_VALUE(-ENODEV);
488 acpi_button_dir->owner = THIS_MODULE;
296 result = acpi_bus_register_driver(&acpi_button_driver); 489 result = acpi_bus_register_driver(&acpi_button_driver);
297 if (result < 0) { 490 if (result < 0) {
491 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
298 return_VALUE(-ENODEV); 492 return_VALUE(-ENODEV);
299 } 493 }
300 494
301 return_VALUE(0); 495 return_VALUE(0);
302} 496}
303 497
498
304static void __exit 499static void __exit
305acpi_button_exit (void) 500acpi_button_exit (void)
306{ 501{
@@ -308,8 +503,17 @@ acpi_button_exit (void)
308 503
309 acpi_bus_unregister_driver(&acpi_button_driver); 504 acpi_bus_unregister_driver(&acpi_button_driver);
310 505
506 if (acpi_power_dir)
507 remove_proc_entry(ACPI_BUTTON_SUBCLASS_POWER, acpi_button_dir);
508 if (acpi_sleep_dir)
509 remove_proc_entry(ACPI_BUTTON_SUBCLASS_SLEEP, acpi_button_dir);
510 if (acpi_lid_dir)
511 remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
512 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
513
311 return_VOID; 514 return_VOID;
312} 515}
313 516
517
314module_init(acpi_button_init); 518module_init(acpi_button_init);
315module_exit(acpi_button_exit); 519module_exit(acpi_button_exit);
diff --git a/drivers/acpi/dispatcher/dswload.c b/drivers/acpi/dispatcher/dswload.c
index 1ac197ccfc80..d11620018421 100644
--- a/drivers/acpi/dispatcher/dswload.c
+++ b/drivers/acpi/dispatcher/dswload.c
@@ -491,12 +491,6 @@ acpi_ds_load2_begin_op (
491 if ((!(walk_state->op_info->flags & AML_NSOPCODE) && 491 if ((!(walk_state->op_info->flags & AML_NSOPCODE) &&
492 (walk_state->opcode != AML_INT_NAMEPATH_OP)) || 492 (walk_state->opcode != AML_INT_NAMEPATH_OP)) ||
493 (!(walk_state->op_info->flags & AML_NAMED))) { 493 (!(walk_state->op_info->flags & AML_NAMED))) {
494 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
495 (walk_state->op_info->class == AML_CLASS_CONTROL)) {
496 ACPI_REPORT_WARNING ((
497 "Encountered executable code at module level, [%s]\n",
498 acpi_ps_get_opcode_name (walk_state->opcode)));
499 }
500 return_ACPI_STATUS (AE_OK); 494 return_ACPI_STATUS (AE_OK);
501 } 495 }
502 496
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index fca4140a50a9..1ac5731d45e5 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -59,76 +59,186 @@ ACPI_MODULE_NAME ("acpi_ec")
59#define ACPI_EC_DELAY 50 /* Wait 50ms max. during EC ops */ 59#define ACPI_EC_DELAY 50 /* Wait 50ms max. during EC ops */
60#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */ 60#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
61 61
62#define ACPI_EC_UDELAY 100 /* Poll @ 100us increments */
63#define ACPI_EC_UDELAY_COUNT 1000 /* Wait 10ms max. during EC ops */
64
62#define ACPI_EC_COMMAND_READ 0x80 65#define ACPI_EC_COMMAND_READ 0x80
63#define ACPI_EC_COMMAND_WRITE 0x81 66#define ACPI_EC_COMMAND_WRITE 0x81
64#define ACPI_EC_BURST_ENABLE 0x82 67#define ACPI_EC_BURST_ENABLE 0x82
65#define ACPI_EC_BURST_DISABLE 0x83 68#define ACPI_EC_BURST_DISABLE 0x83
66#define ACPI_EC_COMMAND_QUERY 0x84 69#define ACPI_EC_COMMAND_QUERY 0x84
67 70
68static int acpi_ec_add (struct acpi_device *device); 71#define EC_POLLING 0xFF
72#define EC_BURST 0x00
73
74
69static int acpi_ec_remove (struct acpi_device *device, int type); 75static int acpi_ec_remove (struct acpi_device *device, int type);
70static int acpi_ec_start (struct acpi_device *device); 76static int acpi_ec_start (struct acpi_device *device);
71static int acpi_ec_stop (struct acpi_device *device, int type); 77static int acpi_ec_stop (struct acpi_device *device, int type);
78static int acpi_ec_burst_add ( struct acpi_device *device);
79static int acpi_ec_polling_add ( struct acpi_device *device);
72 80
73static struct acpi_driver acpi_ec_driver = { 81static struct acpi_driver acpi_ec_driver = {
74 .name = ACPI_EC_DRIVER_NAME, 82 .name = ACPI_EC_DRIVER_NAME,
75 .class = ACPI_EC_CLASS, 83 .class = ACPI_EC_CLASS,
76 .ids = ACPI_EC_HID, 84 .ids = ACPI_EC_HID,
77 .ops = { 85 .ops = {
78 .add = acpi_ec_add, 86 .add = acpi_ec_polling_add,
79 .remove = acpi_ec_remove, 87 .remove = acpi_ec_remove,
80 .start = acpi_ec_start, 88 .start = acpi_ec_start,
81 .stop = acpi_ec_stop, 89 .stop = acpi_ec_stop,
82 }, 90 },
83}; 91};
84 92union acpi_ec {
85struct acpi_ec { 93 struct {
86 acpi_handle handle; 94 u32 mode;
87 unsigned long uid; 95 acpi_handle handle;
88 unsigned long gpe_bit; 96 unsigned long uid;
89 struct acpi_generic_address status_addr; 97 unsigned long gpe_bit;
90 struct acpi_generic_address command_addr; 98 struct acpi_generic_address status_addr;
91 struct acpi_generic_address data_addr; 99 struct acpi_generic_address command_addr;
92 unsigned long global_lock; 100 struct acpi_generic_address data_addr;
93 unsigned int expect_event; 101 unsigned long global_lock;
94 atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort*/ 102 } common;
95 atomic_t pending_gpe; 103
96 struct semaphore sem; 104 struct {
97 wait_queue_head_t wait; 105 u32 mode;
106 acpi_handle handle;
107 unsigned long uid;
108 unsigned long gpe_bit;
109 struct acpi_generic_address status_addr;
110 struct acpi_generic_address command_addr;
111 struct acpi_generic_address data_addr;
112 unsigned long global_lock;
113 unsigned int expect_event;
114 atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort*/
115 atomic_t pending_gpe;
116 struct semaphore sem;
117 wait_queue_head_t wait;
118 }burst;
119
120 struct {
121 u32 mode;
122 acpi_handle handle;
123 unsigned long uid;
124 unsigned long gpe_bit;
125 struct acpi_generic_address status_addr;
126 struct acpi_generic_address command_addr;
127 struct acpi_generic_address data_addr;
128 unsigned long global_lock;
129 spinlock_t lock;
130 }polling;
98}; 131};
99 132
133static int acpi_ec_polling_wait ( union acpi_ec *ec, u8 event);
134static int acpi_ec_burst_wait(union acpi_ec *ec, unsigned int event);
135static int acpi_ec_polling_read ( union acpi_ec *ec, u8 address, u32 *data);
136static int acpi_ec_burst_read( union acpi_ec *ec, u8 address, u32 *data);
137static int acpi_ec_polling_write ( union acpi_ec *ec, u8 address, u8 data);
138static int acpi_ec_burst_write ( union acpi_ec *ec, u8 address, u8 data);
139static int acpi_ec_polling_query ( union acpi_ec *ec, u32 *data);
140static int acpi_ec_burst_query ( union acpi_ec *ec, u32 *data);
141static void acpi_ec_gpe_polling_query ( void *ec_cxt);
142static void acpi_ec_gpe_burst_query ( void *ec_cxt);
143static u32 acpi_ec_gpe_polling_handler ( void *data);
144static u32 acpi_ec_gpe_burst_handler ( void *data);
145static acpi_status __init
146acpi_fake_ecdt_polling_callback (
147 acpi_handle handle,
148 u32 Level,
149 void *context,
150 void **retval);
151
152static acpi_status __init
153acpi_fake_ecdt_burst_callback (
154 acpi_handle handle,
155 u32 Level,
156 void *context,
157 void **retval);
158
159static int __init
160acpi_ec_polling_get_real_ecdt(void);
161static int __init
162acpi_ec_burst_get_real_ecdt(void);
100/* If we find an EC via the ECDT, we need to keep a ptr to its context */ 163/* If we find an EC via the ECDT, we need to keep a ptr to its context */
101static struct acpi_ec *ec_ecdt; 164static union acpi_ec *ec_ecdt;
102 165
103/* External interfaces use first EC only, so remember */ 166/* External interfaces use first EC only, so remember */
104static struct acpi_device *first_ec; 167static struct acpi_device *first_ec;
168static int acpi_ec_polling_mode = EC_POLLING;
105 169
106/* -------------------------------------------------------------------------- 170/* --------------------------------------------------------------------------
107 Transaction Management 171 Transaction Management
108 -------------------------------------------------------------------------- */ 172 -------------------------------------------------------------------------- */
109 173
110static inline u32 acpi_ec_read_status(struct acpi_ec *ec) 174static inline u32 acpi_ec_read_status(union acpi_ec *ec)
111{ 175{
112 u32 status = 0; 176 u32 status = 0;
113 177
114 acpi_hw_low_level_read(8, &status, &ec->status_addr); 178 acpi_hw_low_level_read(8, &status, &ec->common.status_addr);
115 return status; 179 return status;
116} 180}
117 181
118static int acpi_ec_wait(struct acpi_ec *ec, unsigned int event) 182static int
183acpi_ec_wait (
184 union acpi_ec *ec,
185 u8 event)
186{
187 if (acpi_ec_polling_mode)
188 return acpi_ec_polling_wait (ec, event);
189 else
190 return acpi_ec_burst_wait (ec, event);
191}
192
193static int
194acpi_ec_polling_wait (
195 union acpi_ec *ec,
196 u8 event)
197{
198 u32 acpi_ec_status = 0;
199 u32 i = ACPI_EC_UDELAY_COUNT;
200
201 if (!ec)
202 return -EINVAL;
203
204 /* Poll the EC status register waiting for the event to occur. */
205 switch (event) {
206 case ACPI_EC_EVENT_OBF:
207 do {
208 acpi_hw_low_level_read(8, &acpi_ec_status, &ec->common.status_addr);
209 if (acpi_ec_status & ACPI_EC_FLAG_OBF)
210 return 0;
211 udelay(ACPI_EC_UDELAY);
212 } while (--i>0);
213 break;
214 case ACPI_EC_EVENT_IBE:
215 do {
216 acpi_hw_low_level_read(8, &acpi_ec_status, &ec->common.status_addr);
217 if (!(acpi_ec_status & ACPI_EC_FLAG_IBF))
218 return 0;
219 udelay(ACPI_EC_UDELAY);
220 } while (--i>0);
221 break;
222 default:
223 return -EINVAL;
224 }
225
226 return -ETIME;
227}
228static int acpi_ec_burst_wait(union acpi_ec *ec, unsigned int event)
119{ 229{
120 int result = 0; 230 int result = 0;
121 231
122 ACPI_FUNCTION_TRACE("acpi_ec_wait"); 232 ACPI_FUNCTION_TRACE("acpi_ec_wait");
123 233
124 ec->expect_event = event; 234 ec->burst.expect_event = event;
125 smp_mb(); 235 smp_mb();
126 236
127 result = wait_event_interruptible_timeout(ec->wait, 237 result = wait_event_interruptible_timeout(ec->burst.wait,
128 !ec->expect_event, 238 !ec->burst.expect_event,
129 msecs_to_jiffies(ACPI_EC_DELAY)); 239 msecs_to_jiffies(ACPI_EC_DELAY));
130 240
131 ec->expect_event = 0; 241 ec->burst.expect_event = 0;
132 smp_mb(); 242 smp_mb();
133 243
134 if (result < 0){ 244 if (result < 0){
@@ -160,7 +270,7 @@ static int acpi_ec_wait(struct acpi_ec *ec, unsigned int event)
160 270
161static int 271static int
162acpi_ec_enter_burst_mode ( 272acpi_ec_enter_burst_mode (
163 struct acpi_ec *ec) 273 union acpi_ec *ec)
164{ 274{
165 u32 tmp = 0; 275 u32 tmp = 0;
166 int status = 0; 276 int status = 0;
@@ -170,43 +280,43 @@ acpi_ec_enter_burst_mode (
170 status = acpi_ec_read_status(ec); 280 status = acpi_ec_read_status(ec);
171 if (status != -EINVAL && 281 if (status != -EINVAL &&
172 !(status & ACPI_EC_FLAG_BURST)){ 282 !(status & ACPI_EC_FLAG_BURST)){
173 acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE, &ec->command_addr); 283 acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE, &ec->common.command_addr);
174 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 284 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
175 if (status){ 285 if (status){
176 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 286 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
177 return_VALUE(-EINVAL); 287 return_VALUE(-EINVAL);
178 } 288 }
179 acpi_hw_low_level_read(8, &tmp, &ec->data_addr); 289 acpi_hw_low_level_read(8, &tmp, &ec->common.data_addr);
180 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 290 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
181 if(tmp != 0x90 ) {/* Burst ACK byte*/ 291 if(tmp != 0x90 ) {/* Burst ACK byte*/
182 return_VALUE(-EINVAL); 292 return_VALUE(-EINVAL);
183 } 293 }
184 } 294 }
185 295
186 atomic_set(&ec->leaving_burst , 0); 296 atomic_set(&ec->burst.leaving_burst , 0);
187 return_VALUE(0); 297 return_VALUE(0);
188} 298}
189 299
190static int 300static int
191acpi_ec_leave_burst_mode ( 301acpi_ec_leave_burst_mode (
192 struct acpi_ec *ec) 302 union acpi_ec *ec)
193{ 303{
194 int status =0; 304 int status =0;
195 305
196 ACPI_FUNCTION_TRACE("acpi_ec_leave_burst_mode"); 306 ACPI_FUNCTION_TRACE("acpi_ec_leave_burst_mode");
197 307
198 atomic_set(&ec->leaving_burst , 1); 308 atomic_set(&ec->burst.leaving_burst , 1);
199 status = acpi_ec_read_status(ec); 309 status = acpi_ec_read_status(ec);
200 if (status != -EINVAL && 310 if (status != -EINVAL &&
201 (status & ACPI_EC_FLAG_BURST)){ 311 (status & ACPI_EC_FLAG_BURST)){
202 acpi_hw_low_level_write(8, ACPI_EC_BURST_DISABLE, &ec->command_addr); 312 acpi_hw_low_level_write(8, ACPI_EC_BURST_DISABLE, &ec->common.command_addr);
203 status = acpi_ec_wait(ec, ACPI_EC_FLAG_IBF); 313 status = acpi_ec_wait(ec, ACPI_EC_FLAG_IBF);
204 if (status){ 314 if (status){
205 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 315 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
206 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,"------->wait fail\n")); 316 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,"------->wait fail\n"));
207 return_VALUE(-EINVAL); 317 return_VALUE(-EINVAL);
208 } 318 }
209 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 319 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
210 status = acpi_ec_read_status(ec); 320 status = acpi_ec_read_status(ec);
211 } 321 }
212 322
@@ -215,7 +325,131 @@ acpi_ec_leave_burst_mode (
215 325
216static int 326static int
217acpi_ec_read ( 327acpi_ec_read (
218 struct acpi_ec *ec, 328 union acpi_ec *ec,
329 u8 address,
330 u32 *data)
331{
332 if (acpi_ec_polling_mode)
333 return acpi_ec_polling_read(ec, address, data);
334 else
335 return acpi_ec_burst_read(ec, address, data);
336}
337static int
338acpi_ec_write (
339 union acpi_ec *ec,
340 u8 address,
341 u8 data)
342{
343 if (acpi_ec_polling_mode)
344 return acpi_ec_polling_write(ec, address, data);
345 else
346 return acpi_ec_burst_write(ec, address, data);
347}
348static int
349acpi_ec_polling_read (
350 union acpi_ec *ec,
351 u8 address,
352 u32 *data)
353{
354 acpi_status status = AE_OK;
355 int result = 0;
356 unsigned long flags = 0;
357 u32 glk = 0;
358
359 ACPI_FUNCTION_TRACE("acpi_ec_read");
360
361 if (!ec || !data)
362 return_VALUE(-EINVAL);
363
364 *data = 0;
365
366 if (ec->common.global_lock) {
367 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
368 if (ACPI_FAILURE(status))
369 return_VALUE(-ENODEV);
370 }
371
372 spin_lock_irqsave(&ec->polling.lock, flags);
373
374 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ, &ec->common.command_addr);
375 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
376 if (result)
377 goto end;
378
379 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
380 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
381 if (result)
382 goto end;
383
384 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
385
386 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
387 *data, address));
388
389end:
390 spin_unlock_irqrestore(&ec->polling.lock, flags);
391
392 if (ec->common.global_lock)
393 acpi_release_global_lock(glk);
394
395 return_VALUE(result);
396}
397
398
399static int
400acpi_ec_polling_write (
401 union acpi_ec *ec,
402 u8 address,
403 u8 data)
404{
405 int result = 0;
406 acpi_status status = AE_OK;
407 unsigned long flags = 0;
408 u32 glk = 0;
409
410 ACPI_FUNCTION_TRACE("acpi_ec_write");
411
412 if (!ec)
413 return_VALUE(-EINVAL);
414
415 if (ec->common.global_lock) {
416 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
417 if (ACPI_FAILURE(status))
418 return_VALUE(-ENODEV);
419 }
420
421 spin_lock_irqsave(&ec->polling.lock, flags);
422
423 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE, &ec->common.command_addr);
424 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
425 if (result)
426 goto end;
427
428 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
429 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
430 if (result)
431 goto end;
432
433 acpi_hw_low_level_write(8, data, &ec->common.data_addr);
434 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
435 if (result)
436 goto end;
437
438 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
439 data, address));
440
441end:
442 spin_unlock_irqrestore(&ec->polling.lock, flags);
443
444 if (ec->common.global_lock)
445 acpi_release_global_lock(glk);
446
447 return_VALUE(result);
448}
449
450static int
451acpi_ec_burst_read (
452 union acpi_ec *ec,
219 u8 address, 453 u8 address,
220 u32 *data) 454 u32 *data)
221{ 455{
@@ -230,51 +464,51 @@ acpi_ec_read (
230retry: 464retry:
231 *data = 0; 465 *data = 0;
232 466
233 if (ec->global_lock) { 467 if (ec->common.global_lock) {
234 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 468 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
235 if (ACPI_FAILURE(status)) 469 if (ACPI_FAILURE(status))
236 return_VALUE(-ENODEV); 470 return_VALUE(-ENODEV);
237 } 471 }
238 472
239 WARN_ON(in_interrupt()); 473 WARN_ON(in_interrupt());
240 down(&ec->sem); 474 down(&ec->burst.sem);
241 475
242 if(acpi_ec_enter_burst_mode(ec)) 476 if(acpi_ec_enter_burst_mode(ec))
243 goto end; 477 goto end;
244 478
245 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ, &ec->command_addr); 479 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ, &ec->common.command_addr);
246 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 480 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
247 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 481 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
248 if (status) { 482 if (status) {
249 goto end; 483 goto end;
250 } 484 }
251 485
252 acpi_hw_low_level_write(8, address, &ec->data_addr); 486 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
253 status= acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 487 status= acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
254 if (status){ 488 if (status){
255 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 489 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
256 goto end; 490 goto end;
257 } 491 }
258 492
259 acpi_hw_low_level_read(8, data, &ec->data_addr); 493 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
260 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 494 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
261 495
262 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n", 496 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
263 *data, address)); 497 *data, address));
264 498
265end: 499end:
266 acpi_ec_leave_burst_mode(ec); 500 acpi_ec_leave_burst_mode(ec);
267 up(&ec->sem); 501 up(&ec->burst.sem);
268 502
269 if (ec->global_lock) 503 if (ec->common.global_lock)
270 acpi_release_global_lock(glk); 504 acpi_release_global_lock(glk);
271 505
272 if(atomic_read(&ec->leaving_burst) == 2){ 506 if(atomic_read(&ec->burst.leaving_burst) == 2){
273 ACPI_DEBUG_PRINT((ACPI_DB_INFO,"aborted, retry ...\n")); 507 ACPI_DEBUG_PRINT((ACPI_DB_INFO,"aborted, retry ...\n"));
274 while(atomic_read(&ec->pending_gpe)){ 508 while(atomic_read(&ec->burst.pending_gpe)){
275 msleep(1); 509 msleep(1);
276 } 510 }
277 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 511 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
278 goto retry; 512 goto retry;
279 } 513 }
280 514
@@ -283,8 +517,8 @@ end:
283 517
284 518
285static int 519static int
286acpi_ec_write ( 520acpi_ec_burst_write (
287 struct acpi_ec *ec, 521 union acpi_ec *ec,
288 u8 address, 522 u8 address,
289 u8 data) 523 u8 data)
290{ 524{
@@ -297,14 +531,14 @@ acpi_ec_write (
297 if (!ec) 531 if (!ec)
298 return_VALUE(-EINVAL); 532 return_VALUE(-EINVAL);
299retry: 533retry:
300 if (ec->global_lock) { 534 if (ec->common.global_lock) {
301 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 535 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
302 if (ACPI_FAILURE(status)) 536 if (ACPI_FAILURE(status))
303 return_VALUE(-ENODEV); 537 return_VALUE(-ENODEV);
304 } 538 }
305 539
306 WARN_ON(in_interrupt()); 540 WARN_ON(in_interrupt());
307 down(&ec->sem); 541 down(&ec->burst.sem);
308 542
309 if(acpi_ec_enter_burst_mode(ec)) 543 if(acpi_ec_enter_burst_mode(ec))
310 goto end; 544 goto end;
@@ -312,33 +546,33 @@ retry:
312 status = acpi_ec_read_status(ec); 546 status = acpi_ec_read_status(ec);
313 if (status != -EINVAL && 547 if (status != -EINVAL &&
314 !(status & ACPI_EC_FLAG_BURST)){ 548 !(status & ACPI_EC_FLAG_BURST)){
315 acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE, &ec->command_addr); 549 acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE, &ec->common.command_addr);
316 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 550 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
317 if (status) 551 if (status)
318 goto end; 552 goto end;
319 acpi_hw_low_level_read(8, &tmp, &ec->data_addr); 553 acpi_hw_low_level_read(8, &tmp, &ec->common.data_addr);
320 if(tmp != 0x90 ) /* Burst ACK byte*/ 554 if(tmp != 0x90 ) /* Burst ACK byte*/
321 goto end; 555 goto end;
322 } 556 }
323 /*Now we are in burst mode*/ 557 /*Now we are in burst mode*/
324 558
325 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE, &ec->command_addr); 559 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE, &ec->common.command_addr);
326 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 560 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
327 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 561 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
328 if (status){ 562 if (status){
329 goto end; 563 goto end;
330 } 564 }
331 565
332 acpi_hw_low_level_write(8, address, &ec->data_addr); 566 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
333 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 567 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
334 if (status){ 568 if (status){
335 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 569 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
336 goto end; 570 goto end;
337 } 571 }
338 572
339 acpi_hw_low_level_write(8, data, &ec->data_addr); 573 acpi_hw_low_level_write(8, data, &ec->common.data_addr);
340 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 574 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
341 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 575 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
342 if (status) 576 if (status)
343 goto end; 577 goto end;
344 578
@@ -347,17 +581,17 @@ retry:
347 581
348end: 582end:
349 acpi_ec_leave_burst_mode(ec); 583 acpi_ec_leave_burst_mode(ec);
350 up(&ec->sem); 584 up(&ec->burst.sem);
351 585
352 if (ec->global_lock) 586 if (ec->common.global_lock)
353 acpi_release_global_lock(glk); 587 acpi_release_global_lock(glk);
354 588
355 if(atomic_read(&ec->leaving_burst) == 2){ 589 if(atomic_read(&ec->burst.leaving_burst) == 2){
356 ACPI_DEBUG_PRINT((ACPI_DB_INFO,"aborted, retry ...\n")); 590 ACPI_DEBUG_PRINT((ACPI_DB_INFO,"aborted, retry ...\n"));
357 while(atomic_read(&ec->pending_gpe)){ 591 while(atomic_read(&ec->burst.pending_gpe)){
358 msleep(1); 592 msleep(1);
359 } 593 }
360 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 594 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
361 goto retry; 595 goto retry;
362 } 596 }
363 597
@@ -370,7 +604,7 @@ end:
370int 604int
371ec_read(u8 addr, u8 *val) 605ec_read(u8 addr, u8 *val)
372{ 606{
373 struct acpi_ec *ec; 607 union acpi_ec *ec;
374 int err; 608 int err;
375 u32 temp_data; 609 u32 temp_data;
376 610
@@ -393,7 +627,7 @@ EXPORT_SYMBOL(ec_read);
393int 627int
394ec_write(u8 addr, u8 val) 628ec_write(u8 addr, u8 val)
395{ 629{
396 struct acpi_ec *ec; 630 union acpi_ec *ec;
397 int err; 631 int err;
398 632
399 if (!first_ec) 633 if (!first_ec)
@@ -407,10 +641,66 @@ ec_write(u8 addr, u8 val)
407} 641}
408EXPORT_SYMBOL(ec_write); 642EXPORT_SYMBOL(ec_write);
409 643
410
411static int 644static int
412acpi_ec_query ( 645acpi_ec_query (
413 struct acpi_ec *ec, 646 union acpi_ec *ec,
647 u32 *data)
648{
649 if (acpi_ec_polling_mode)
650 return acpi_ec_polling_query(ec, data);
651 else
652 return acpi_ec_burst_query(ec, data);
653}
654static int
655acpi_ec_polling_query (
656 union acpi_ec *ec,
657 u32 *data)
658{
659 int result = 0;
660 acpi_status status = AE_OK;
661 unsigned long flags = 0;
662 u32 glk = 0;
663
664 ACPI_FUNCTION_TRACE("acpi_ec_query");
665
666 if (!ec || !data)
667 return_VALUE(-EINVAL);
668
669 *data = 0;
670
671 if (ec->common.global_lock) {
672 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
673 if (ACPI_FAILURE(status))
674 return_VALUE(-ENODEV);
675 }
676
677 /*
678 * Query the EC to find out which _Qxx method we need to evaluate.
679 * Note that successful completion of the query causes the ACPI_EC_SCI
680 * bit to be cleared (and thus clearing the interrupt source).
681 */
682 spin_lock_irqsave(&ec->polling.lock, flags);
683
684 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY, &ec->common.command_addr);
685 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
686 if (result)
687 goto end;
688
689 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
690 if (!*data)
691 result = -ENODATA;
692
693end:
694 spin_unlock_irqrestore(&ec->polling.lock, flags);
695
696 if (ec->common.global_lock)
697 acpi_release_global_lock(glk);
698
699 return_VALUE(result);
700}
701static int
702acpi_ec_burst_query (
703 union acpi_ec *ec,
414 u32 *data) 704 u32 *data)
415{ 705{
416 int status = 0; 706 int status = 0;
@@ -422,13 +712,13 @@ acpi_ec_query (
422 return_VALUE(-EINVAL); 712 return_VALUE(-EINVAL);
423 *data = 0; 713 *data = 0;
424 714
425 if (ec->global_lock) { 715 if (ec->common.global_lock) {
426 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 716 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
427 if (ACPI_FAILURE(status)) 717 if (ACPI_FAILURE(status))
428 return_VALUE(-ENODEV); 718 return_VALUE(-ENODEV);
429 } 719 }
430 720
431 down(&ec->sem); 721 down(&ec->burst.sem);
432 if(acpi_ec_enter_burst_mode(ec)) 722 if(acpi_ec_enter_burst_mode(ec))
433 goto end; 723 goto end;
434 /* 724 /*
@@ -436,28 +726,28 @@ acpi_ec_query (
436 * Note that successful completion of the query causes the ACPI_EC_SCI 726 * Note that successful completion of the query causes the ACPI_EC_SCI
437 * bit to be cleared (and thus clearing the interrupt source). 727 * bit to be cleared (and thus clearing the interrupt source).
438 */ 728 */
439 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY, &ec->command_addr); 729 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY, &ec->common.command_addr);
440 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 730 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
441 if (status){ 731 if (status){
442 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 732 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
443 goto end; 733 goto end;
444 } 734 }
445 735
446 acpi_hw_low_level_read(8, data, &ec->data_addr); 736 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
447 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 737 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
448 if (!*data) 738 if (!*data)
449 status = -ENODATA; 739 status = -ENODATA;
450 740
451end: 741end:
452 acpi_ec_leave_burst_mode(ec); 742 acpi_ec_leave_burst_mode(ec);
453 up(&ec->sem); 743 up(&ec->burst.sem);
454 744
455 if (ec->global_lock) 745 if (ec->common.global_lock)
456 acpi_release_global_lock(glk); 746 acpi_release_global_lock(glk);
457 747
458 if(atomic_read(&ec->leaving_burst) == 2){ 748 if(atomic_read(&ec->burst.leaving_burst) == 2){
459 ACPI_DEBUG_PRINT((ACPI_DB_INFO,"aborted, retry ...\n")); 749 ACPI_DEBUG_PRINT((ACPI_DB_INFO,"aborted, retry ...\n"));
460 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 750 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
461 status = -ENODATA; 751 status = -ENODATA;
462 } 752 }
463 return_VALUE(status); 753 return_VALUE(status);
@@ -468,7 +758,7 @@ end:
468 Event Management 758 Event Management
469 -------------------------------------------------------------------------- */ 759 -------------------------------------------------------------------------- */
470 760
471struct acpi_ec_query_data { 761union acpi_ec_query_data {
472 acpi_handle handle; 762 acpi_handle handle;
473 u8 data; 763 u8 data;
474}; 764};
@@ -477,7 +767,59 @@ static void
477acpi_ec_gpe_query ( 767acpi_ec_gpe_query (
478 void *ec_cxt) 768 void *ec_cxt)
479{ 769{
480 struct acpi_ec *ec = (struct acpi_ec *) ec_cxt; 770 if (acpi_ec_polling_mode)
771 acpi_ec_gpe_polling_query(ec_cxt);
772 else
773 acpi_ec_gpe_burst_query(ec_cxt);
774}
775
776static void
777acpi_ec_gpe_polling_query (
778 void *ec_cxt)
779{
780 union acpi_ec *ec = (union acpi_ec *) ec_cxt;
781 u32 value = 0;
782 unsigned long flags = 0;
783 static char object_name[5] = {'_','Q','0','0','\0'};
784 const char hex[] = {'0','1','2','3','4','5','6','7',
785 '8','9','A','B','C','D','E','F'};
786
787 ACPI_FUNCTION_TRACE("acpi_ec_gpe_query");
788
789 if (!ec_cxt)
790 goto end;
791
792 spin_lock_irqsave(&ec->polling.lock, flags);
793 acpi_hw_low_level_read(8, &value, &ec->common.command_addr);
794 spin_unlock_irqrestore(&ec->polling.lock, flags);
795
796 /* TBD: Implement asynch events!
797 * NOTE: All we care about are EC-SCI's. Other EC events are
798 * handled via polling (yuck!). This is because some systems
799 * treat EC-SCIs as level (versus EDGE!) triggered, preventing
800 * a purely interrupt-driven approach (grumble, grumble).
801 */
802 if (!(value & ACPI_EC_FLAG_SCI))
803 goto end;
804
805 if (acpi_ec_query(ec, &value))
806 goto end;
807
808 object_name[2] = hex[((value >> 4) & 0x0F)];
809 object_name[3] = hex[(value & 0x0F)];
810
811 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name));
812
813 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
814
815end:
816 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
817}
818static void
819acpi_ec_gpe_burst_query (
820 void *ec_cxt)
821{
822 union acpi_ec *ec = (union acpi_ec *) ec_cxt;
481 u32 value; 823 u32 value;
482 int result = -ENODATA; 824 int result = -ENODATA;
483 static char object_name[5] = {'_','Q','0','0','\0'}; 825 static char object_name[5] = {'_','Q','0','0','\0'};
@@ -497,9 +839,9 @@ acpi_ec_gpe_query (
497 839
498 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name)); 840 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name));
499 841
500 acpi_evaluate_object(ec->handle, object_name, NULL, NULL); 842 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
501end: 843end:
502 atomic_dec(&ec->pending_gpe); 844 atomic_dec(&ec->burst.pending_gpe);
503 return; 845 return;
504} 846}
505 847
@@ -507,48 +849,77 @@ static u32
507acpi_ec_gpe_handler ( 849acpi_ec_gpe_handler (
508 void *data) 850 void *data)
509{ 851{
852 if (acpi_ec_polling_mode)
853 return acpi_ec_gpe_polling_handler(data);
854 else
855 return acpi_ec_gpe_burst_handler(data);
856}
857static u32
858acpi_ec_gpe_polling_handler (
859 void *data)
860{
861 acpi_status status = AE_OK;
862 union acpi_ec *ec = (union acpi_ec *) data;
863
864 if (!ec)
865 return ACPI_INTERRUPT_NOT_HANDLED;
866
867 acpi_disable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
868
869 status = acpi_os_queue_for_execution(OSD_PRIORITY_GPE,
870 acpi_ec_gpe_query, ec);
871
872 if (status == AE_OK)
873 return ACPI_INTERRUPT_HANDLED;
874 else
875 return ACPI_INTERRUPT_NOT_HANDLED;
876}
877static u32
878acpi_ec_gpe_burst_handler (
879 void *data)
880{
510 acpi_status status = AE_OK; 881 acpi_status status = AE_OK;
511 u32 value; 882 u32 value;
512 struct acpi_ec *ec = (struct acpi_ec *) data; 883 union acpi_ec *ec = (union acpi_ec *) data;
513 884
514 if (!ec) 885 if (!ec)
515 return ACPI_INTERRUPT_NOT_HANDLED; 886 return ACPI_INTERRUPT_NOT_HANDLED;
516 887
517 acpi_disable_gpe(NULL, ec->gpe_bit, ACPI_ISR); 888 acpi_disable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
518 889
519 value = acpi_ec_read_status(ec); 890 value = acpi_ec_read_status(ec);
520 891
521 if((value & ACPI_EC_FLAG_IBF) && 892 if((value & ACPI_EC_FLAG_IBF) &&
522 !(value & ACPI_EC_FLAG_BURST) && 893 !(value & ACPI_EC_FLAG_BURST) &&
523 (atomic_read(&ec->leaving_burst) == 0)) { 894 (atomic_read(&ec->burst.leaving_burst) == 0)) {
524 /* 895 /*
525 * the embedded controller disables 896 * the embedded controller disables
526 * burst mode for any reason other 897 * burst mode for any reason other
527 * than the burst disable command 898 * than the burst disable command
528 * to process critical event. 899 * to process critical event.
529 */ 900 */
530 atomic_set(&ec->leaving_burst , 2); /* block current pending transaction 901 atomic_set(&ec->burst.leaving_burst , 2); /* block current pending transaction
531 and retry */ 902 and retry */
532 wake_up(&ec->wait); 903 wake_up(&ec->burst.wait);
533 }else { 904 }else {
534 if ((ec->expect_event == ACPI_EC_EVENT_OBF && 905 if ((ec->burst.expect_event == ACPI_EC_EVENT_OBF &&
535 (value & ACPI_EC_FLAG_OBF)) || 906 (value & ACPI_EC_FLAG_OBF)) ||
536 (ec->expect_event == ACPI_EC_EVENT_IBE && 907 (ec->burst.expect_event == ACPI_EC_EVENT_IBE &&
537 !(value & ACPI_EC_FLAG_IBF))) { 908 !(value & ACPI_EC_FLAG_IBF))) {
538 ec->expect_event = 0; 909 ec->burst.expect_event = 0;
539 wake_up(&ec->wait); 910 wake_up(&ec->burst.wait);
540 return ACPI_INTERRUPT_HANDLED; 911 return ACPI_INTERRUPT_HANDLED;
541 } 912 }
542 } 913 }
543 914
544 if (value & ACPI_EC_FLAG_SCI){ 915 if (value & ACPI_EC_FLAG_SCI){
545 atomic_add(1, &ec->pending_gpe) ; 916 atomic_add(1, &ec->burst.pending_gpe) ;
546 status = acpi_os_queue_for_execution(OSD_PRIORITY_GPE, 917 status = acpi_os_queue_for_execution(OSD_PRIORITY_GPE,
547 acpi_ec_gpe_query, ec); 918 acpi_ec_gpe_query, ec);
548 return status == AE_OK ? 919 return status == AE_OK ?
549 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED; 920 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
550 } 921 }
551 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_ISR); 922 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
552 return status == AE_OK ? 923 return status == AE_OK ?
553 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED; 924 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
554} 925}
@@ -585,7 +956,7 @@ acpi_ec_space_handler (
585 void *region_context) 956 void *region_context)
586{ 957{
587 int result = 0; 958 int result = 0;
588 struct acpi_ec *ec = NULL; 959 union acpi_ec *ec = NULL;
589 u64 temp = *value; 960 u64 temp = *value;
590 acpi_integer f_v = 0; 961 acpi_integer f_v = 0;
591 int i = 0; 962 int i = 0;
@@ -600,7 +971,7 @@ acpi_ec_space_handler (
600 return_VALUE(AE_BAD_PARAMETER); 971 return_VALUE(AE_BAD_PARAMETER);
601 } 972 }
602 973
603 ec = (struct acpi_ec *) handler_context; 974 ec = (union acpi_ec *) handler_context;
604 975
605next_byte: 976next_byte:
606 switch (function) { 977 switch (function) {
@@ -661,7 +1032,7 @@ static struct proc_dir_entry *acpi_ec_dir;
661static int 1032static int
662acpi_ec_read_info (struct seq_file *seq, void *offset) 1033acpi_ec_read_info (struct seq_file *seq, void *offset)
663{ 1034{
664 struct acpi_ec *ec = (struct acpi_ec *) seq->private; 1035 union acpi_ec *ec = (union acpi_ec *) seq->private;
665 1036
666 ACPI_FUNCTION_TRACE("acpi_ec_read_info"); 1037 ACPI_FUNCTION_TRACE("acpi_ec_read_info");
667 1038
@@ -669,12 +1040,12 @@ acpi_ec_read_info (struct seq_file *seq, void *offset)
669 goto end; 1040 goto end;
670 1041
671 seq_printf(seq, "gpe bit: 0x%02x\n", 1042 seq_printf(seq, "gpe bit: 0x%02x\n",
672 (u32) ec->gpe_bit); 1043 (u32) ec->common.gpe_bit);
673 seq_printf(seq, "ports: 0x%02x, 0x%02x\n", 1044 seq_printf(seq, "ports: 0x%02x, 0x%02x\n",
674 (u32) ec->status_addr.address, (u32) ec->data_addr.address); 1045 (u32) ec->common.status_addr.address, (u32) ec->common.data_addr.address);
675 seq_printf(seq, "use global lock: %s\n", 1046 seq_printf(seq, "use global lock: %s\n",
676 ec->global_lock?"yes":"no"); 1047 ec->common.global_lock?"yes":"no");
677 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR); 1048 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
678 1049
679end: 1050end:
680 return_VALUE(0); 1051 return_VALUE(0);
@@ -697,7 +1068,7 @@ static int
697acpi_ec_add_fs ( 1068acpi_ec_add_fs (
698 struct acpi_device *device) 1069 struct acpi_device *device)
699{ 1070{
700 struct proc_dir_entry *entry; 1071 struct proc_dir_entry *entry = NULL;
701 1072
702 ACPI_FUNCTION_TRACE("acpi_ec_add_fs"); 1073 ACPI_FUNCTION_TRACE("acpi_ec_add_fs");
703 1074
@@ -744,13 +1115,14 @@ acpi_ec_remove_fs (
744 Driver Interface 1115 Driver Interface
745 -------------------------------------------------------------------------- */ 1116 -------------------------------------------------------------------------- */
746 1117
1118
747static int 1119static int
748acpi_ec_add ( 1120acpi_ec_polling_add (
749 struct acpi_device *device) 1121 struct acpi_device *device)
750{ 1122{
751 int result; 1123 int result = 0;
752 acpi_status status; 1124 acpi_status status = AE_OK;
753 struct acpi_ec *ec; 1125 union acpi_ec *ec = NULL;
754 unsigned long uid; 1126 unsigned long uid;
755 1127
756 ACPI_FUNCTION_TRACE("acpi_ec_add"); 1128 ACPI_FUNCTION_TRACE("acpi_ec_add");
@@ -758,39 +1130,107 @@ acpi_ec_add (
758 if (!device) 1130 if (!device)
759 return_VALUE(-EINVAL); 1131 return_VALUE(-EINVAL);
760 1132
761 ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL); 1133 ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
762 if (!ec) 1134 if (!ec)
763 return_VALUE(-ENOMEM); 1135 return_VALUE(-ENOMEM);
764 memset(ec, 0, sizeof(struct acpi_ec)); 1136 memset(ec, 0, sizeof(union acpi_ec));
765 1137
766 ec->handle = device->handle; 1138 ec->common.handle = device->handle;
767 ec->uid = -1; 1139 ec->common.uid = -1;
768 atomic_set(&ec->pending_gpe, 0); 1140 spin_lock_init(&ec->polling.lock);
769 atomic_set(&ec->leaving_burst , 1);
770 init_MUTEX(&ec->sem);
771 init_waitqueue_head(&ec->wait);
772 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME); 1141 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
773 strcpy(acpi_device_class(device), ACPI_EC_CLASS); 1142 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
774 acpi_driver_data(device) = ec; 1143 acpi_driver_data(device) = ec;
775 1144
776 /* Use the global lock for all EC transactions? */ 1145 /* Use the global lock for all EC transactions? */
777 acpi_evaluate_integer(ec->handle, "_GLK", NULL, &ec->global_lock); 1146 acpi_evaluate_integer(ec->common.handle, "_GLK", NULL, &ec->common.global_lock);
778 1147
779 /* If our UID matches the UID for the ECDT-enumerated EC, 1148 /* If our UID matches the UID for the ECDT-enumerated EC,
780 we now have the *real* EC info, so kill the makeshift one.*/ 1149 we now have the *real* EC info, so kill the makeshift one.*/
781 acpi_evaluate_integer(ec->handle, "_UID", NULL, &uid); 1150 acpi_evaluate_integer(ec->common.handle, "_UID", NULL, &uid);
782 if (ec_ecdt && ec_ecdt->uid == uid) { 1151 if (ec_ecdt && ec_ecdt->common.uid == uid) {
783 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT, 1152 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
784 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler); 1153 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler);
1154
1155 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit, &acpi_ec_gpe_handler);
1156
1157 kfree(ec_ecdt);
1158 }
1159
1160 /* Get GPE bit assignment (EC events). */
1161 /* TODO: Add support for _GPE returning a package */
1162 status = acpi_evaluate_integer(ec->common.handle, "_GPE", NULL, &ec->common.gpe_bit);
1163 if (ACPI_FAILURE(status)) {
1164 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1165 "Error obtaining GPE bit assignment\n"));
1166 result = -ENODEV;
1167 goto end;
1168 }
785 1169
786 acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit, &acpi_ec_gpe_handler); 1170 result = acpi_ec_add_fs(device);
1171 if (result)
1172 goto end;
1173
1174 printk(KERN_INFO PREFIX "%s [%s] (gpe %d)\n",
1175 acpi_device_name(device), acpi_device_bid(device),
1176 (u32) ec->common.gpe_bit);
1177
1178 if (!first_ec)
1179 first_ec = device;
1180
1181end:
1182 if (result)
1183 kfree(ec);
1184
1185 return_VALUE(result);
1186}
1187static int
1188acpi_ec_burst_add (
1189 struct acpi_device *device)
1190{
1191 int result = 0;
1192 acpi_status status = AE_OK;
1193 union acpi_ec *ec = NULL;
1194 unsigned long uid;
1195
1196 ACPI_FUNCTION_TRACE("acpi_ec_add");
1197
1198 if (!device)
1199 return_VALUE(-EINVAL);
1200
1201 ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1202 if (!ec)
1203 return_VALUE(-ENOMEM);
1204 memset(ec, 0, sizeof(union acpi_ec));
1205
1206 ec->common.handle = device->handle;
1207 ec->common.uid = -1;
1208 atomic_set(&ec->burst.pending_gpe, 0);
1209 atomic_set(&ec->burst.leaving_burst , 1);
1210 init_MUTEX(&ec->burst.sem);
1211 init_waitqueue_head(&ec->burst.wait);
1212 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1213 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1214 acpi_driver_data(device) = ec;
1215
1216 /* Use the global lock for all EC transactions? */
1217 acpi_evaluate_integer(ec->common.handle, "_GLK", NULL, &ec->common.global_lock);
1218
1219 /* If our UID matches the UID for the ECDT-enumerated EC,
1220 we now have the *real* EC info, so kill the makeshift one.*/
1221 acpi_evaluate_integer(ec->common.handle, "_UID", NULL, &uid);
1222 if (ec_ecdt && ec_ecdt->common.uid == uid) {
1223 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
1224 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler);
1225
1226 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit, &acpi_ec_gpe_handler);
787 1227
788 kfree(ec_ecdt); 1228 kfree(ec_ecdt);
789 } 1229 }
790 1230
791 /* Get GPE bit assignment (EC events). */ 1231 /* Get GPE bit assignment (EC events). */
792 /* TODO: Add support for _GPE returning a package */ 1232 /* TODO: Add support for _GPE returning a package */
793 status = acpi_evaluate_integer(ec->handle, "_GPE", NULL, &ec->gpe_bit); 1233 status = acpi_evaluate_integer(ec->common.handle, "_GPE", NULL, &ec->common.gpe_bit);
794 if (ACPI_FAILURE(status)) { 1234 if (ACPI_FAILURE(status)) {
795 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1235 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
796 "Error obtaining GPE bit assignment\n")); 1236 "Error obtaining GPE bit assignment\n"));
@@ -804,7 +1244,7 @@ acpi_ec_add (
804 1244
805 printk(KERN_INFO PREFIX "%s [%s] (gpe %d)\n", 1245 printk(KERN_INFO PREFIX "%s [%s] (gpe %d)\n",
806 acpi_device_name(device), acpi_device_bid(device), 1246 acpi_device_name(device), acpi_device_bid(device),
807 (u32) ec->gpe_bit); 1247 (u32) ec->common.gpe_bit);
808 1248
809 if (!first_ec) 1249 if (!first_ec)
810 first_ec = device; 1250 first_ec = device;
@@ -822,7 +1262,7 @@ acpi_ec_remove (
822 struct acpi_device *device, 1262 struct acpi_device *device,
823 int type) 1263 int type)
824{ 1264{
825 struct acpi_ec *ec; 1265 union acpi_ec *ec = NULL;
826 1266
827 ACPI_FUNCTION_TRACE("acpi_ec_remove"); 1267 ACPI_FUNCTION_TRACE("acpi_ec_remove");
828 1268
@@ -844,7 +1284,7 @@ acpi_ec_io_ports (
844 struct acpi_resource *resource, 1284 struct acpi_resource *resource,
845 void *context) 1285 void *context)
846{ 1286{
847 struct acpi_ec *ec = (struct acpi_ec *) context; 1287 union acpi_ec *ec = (union acpi_ec *) context;
848 struct acpi_generic_address *addr; 1288 struct acpi_generic_address *addr;
849 1289
850 if (resource->id != ACPI_RSTYPE_IO) { 1290 if (resource->id != ACPI_RSTYPE_IO) {
@@ -856,10 +1296,10 @@ acpi_ec_io_ports (
856 * the second address region returned is the status/command 1296 * the second address region returned is the status/command
857 * port. 1297 * port.
858 */ 1298 */
859 if (ec->data_addr.register_bit_width == 0) { 1299 if (ec->common.data_addr.register_bit_width == 0) {
860 addr = &ec->data_addr; 1300 addr = &ec->common.data_addr;
861 } else if (ec->command_addr.register_bit_width == 0) { 1301 } else if (ec->common.command_addr.register_bit_width == 0) {
862 addr = &ec->command_addr; 1302 addr = &ec->common.command_addr;
863 } else { 1303 } else {
864 return AE_CTRL_TERMINATE; 1304 return AE_CTRL_TERMINATE;
865 } 1305 }
@@ -877,8 +1317,8 @@ static int
877acpi_ec_start ( 1317acpi_ec_start (
878 struct acpi_device *device) 1318 struct acpi_device *device)
879{ 1319{
880 acpi_status status; 1320 acpi_status status = AE_OK;
881 struct acpi_ec *ec; 1321 union acpi_ec *ec = NULL;
882 1322
883 ACPI_FUNCTION_TRACE("acpi_ec_start"); 1323 ACPI_FUNCTION_TRACE("acpi_ec_start");
884 1324
@@ -893,35 +1333,36 @@ acpi_ec_start (
893 /* 1333 /*
894 * Get I/O port addresses. Convert to GAS format. 1334 * Get I/O port addresses. Convert to GAS format.
895 */ 1335 */
896 status = acpi_walk_resources(ec->handle, METHOD_NAME__CRS, 1336 status = acpi_walk_resources(ec->common.handle, METHOD_NAME__CRS,
897 acpi_ec_io_ports, ec); 1337 acpi_ec_io_ports, ec);
898 if (ACPI_FAILURE(status) || ec->command_addr.register_bit_width == 0) { 1338 if (ACPI_FAILURE(status) || ec->common.command_addr.register_bit_width == 0) {
899 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error getting I/O port addresses")); 1339 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error getting I/O port addresses"));
900 return_VALUE(-ENODEV); 1340 return_VALUE(-ENODEV);
901 } 1341 }
902 1342
903 ec->status_addr = ec->command_addr; 1343 ec->common.status_addr = ec->common.command_addr;
904 1344
905 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n", 1345 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n",
906 (u32) ec->gpe_bit, (u32) ec->command_addr.address, 1346 (u32) ec->common.gpe_bit, (u32) ec->common.command_addr.address,
907 (u32) ec->data_addr.address)); 1347 (u32) ec->common.data_addr.address));
1348
908 1349
909 /* 1350 /*
910 * Install GPE handler 1351 * Install GPE handler
911 */ 1352 */
912 status = acpi_install_gpe_handler(NULL, ec->gpe_bit, 1353 status = acpi_install_gpe_handler(NULL, ec->common.gpe_bit,
913 ACPI_GPE_EDGE_TRIGGERED, &acpi_ec_gpe_handler, ec); 1354 ACPI_GPE_EDGE_TRIGGERED, &acpi_ec_gpe_handler, ec);
914 if (ACPI_FAILURE(status)) { 1355 if (ACPI_FAILURE(status)) {
915 return_VALUE(-ENODEV); 1356 return_VALUE(-ENODEV);
916 } 1357 }
917 acpi_set_gpe_type (NULL, ec->gpe_bit, ACPI_GPE_TYPE_RUNTIME); 1358 acpi_set_gpe_type (NULL, ec->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
918 acpi_enable_gpe (NULL, ec->gpe_bit, ACPI_NOT_ISR); 1359 acpi_enable_gpe (NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
919 1360
920 status = acpi_install_address_space_handler (ec->handle, 1361 status = acpi_install_address_space_handler (ec->common.handle,
921 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler, 1362 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler,
922 &acpi_ec_space_setup, ec); 1363 &acpi_ec_space_setup, ec);
923 if (ACPI_FAILURE(status)) { 1364 if (ACPI_FAILURE(status)) {
924 acpi_remove_gpe_handler(NULL, ec->gpe_bit, &acpi_ec_gpe_handler); 1365 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit, &acpi_ec_gpe_handler);
925 return_VALUE(-ENODEV); 1366 return_VALUE(-ENODEV);
926 } 1367 }
927 1368
@@ -934,8 +1375,8 @@ acpi_ec_stop (
934 struct acpi_device *device, 1375 struct acpi_device *device,
935 int type) 1376 int type)
936{ 1377{
937 acpi_status status; 1378 acpi_status status = AE_OK;
938 struct acpi_ec *ec; 1379 union acpi_ec *ec = NULL;
939 1380
940 ACPI_FUNCTION_TRACE("acpi_ec_stop"); 1381 ACPI_FUNCTION_TRACE("acpi_ec_stop");
941 1382
@@ -944,12 +1385,12 @@ acpi_ec_stop (
944 1385
945 ec = acpi_driver_data(device); 1386 ec = acpi_driver_data(device);
946 1387
947 status = acpi_remove_address_space_handler(ec->handle, 1388 status = acpi_remove_address_space_handler(ec->common.handle,
948 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler); 1389 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler);
949 if (ACPI_FAILURE(status)) 1390 if (ACPI_FAILURE(status))
950 return_VALUE(-ENODEV); 1391 return_VALUE(-ENODEV);
951 1392
952 status = acpi_remove_gpe_handler(NULL, ec->gpe_bit, &acpi_ec_gpe_handler); 1393 status = acpi_remove_gpe_handler(NULL, ec->common.gpe_bit, &acpi_ec_gpe_handler);
953 if (ACPI_FAILURE(status)) 1394 if (ACPI_FAILURE(status))
954 return_VALUE(-ENODEV); 1395 return_VALUE(-ENODEV);
955 1396
@@ -963,26 +1404,76 @@ acpi_fake_ecdt_callback (
963 void *context, 1404 void *context,
964 void **retval) 1405 void **retval)
965{ 1406{
1407
1408 if (acpi_ec_polling_mode)
1409 return acpi_fake_ecdt_polling_callback(handle,
1410 Level, context, retval);
1411 else
1412 return acpi_fake_ecdt_burst_callback(handle,
1413 Level, context, retval);
1414}
1415
1416static acpi_status __init
1417acpi_fake_ecdt_polling_callback (
1418 acpi_handle handle,
1419 u32 Level,
1420 void *context,
1421 void **retval)
1422{
966 acpi_status status; 1423 acpi_status status;
967 1424
968 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 1425 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
969 acpi_ec_io_ports, ec_ecdt); 1426 acpi_ec_io_ports, ec_ecdt);
970 if (ACPI_FAILURE(status)) 1427 if (ACPI_FAILURE(status))
971 return status; 1428 return status;
972 ec_ecdt->status_addr = ec_ecdt->command_addr; 1429 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
973 1430
974 ec_ecdt->uid = -1; 1431 ec_ecdt->common.uid = -1;
975 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->uid); 1432 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
976 1433
977 status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec_ecdt->gpe_bit); 1434 status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec_ecdt->common.gpe_bit);
978 if (ACPI_FAILURE(status)) 1435 if (ACPI_FAILURE(status))
979 return status; 1436 return status;
980 ec_ecdt->global_lock = TRUE; 1437 spin_lock_init(&ec_ecdt->polling.lock);
981 ec_ecdt->handle = handle; 1438 ec_ecdt->common.global_lock = TRUE;
1439 ec_ecdt->common.handle = handle;
982 1440
983 printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n", 1441 printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
984 (u32) ec_ecdt->gpe_bit, (u32) ec_ecdt->command_addr.address, 1442 (u32) ec_ecdt->common.gpe_bit, (u32) ec_ecdt->common.command_addr.address,
985 (u32) ec_ecdt->data_addr.address); 1443 (u32) ec_ecdt->common.data_addr.address);
1444
1445 return AE_CTRL_TERMINATE;
1446}
1447
1448static acpi_status __init
1449acpi_fake_ecdt_burst_callback (
1450 acpi_handle handle,
1451 u32 Level,
1452 void *context,
1453 void **retval)
1454{
1455 acpi_status status;
1456
1457 init_MUTEX(&ec_ecdt->burst.sem);
1458 init_waitqueue_head(&ec_ecdt->burst.wait);
1459 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1460 acpi_ec_io_ports, ec_ecdt);
1461 if (ACPI_FAILURE(status))
1462 return status;
1463 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
1464
1465 ec_ecdt->common.uid = -1;
1466 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
1467
1468 status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec_ecdt->common.gpe_bit);
1469 if (ACPI_FAILURE(status))
1470 return status;
1471 ec_ecdt->common.global_lock = TRUE;
1472 ec_ecdt->common.handle = handle;
1473
1474 printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1475 (u32) ec_ecdt->common.gpe_bit, (u32) ec_ecdt->common.command_addr.address,
1476 (u32) ec_ecdt->common.data_addr.address);
986 1477
987 return AE_CTRL_TERMINATE; 1478 return AE_CTRL_TERMINATE;
988} 1479}
@@ -1005,12 +1496,12 @@ acpi_ec_fake_ecdt(void)
1005 1496
1006 printk(KERN_INFO PREFIX "Try to make an fake ECDT\n"); 1497 printk(KERN_INFO PREFIX "Try to make an fake ECDT\n");
1007 1498
1008 ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL); 1499 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1009 if (!ec_ecdt) { 1500 if (!ec_ecdt) {
1010 ret = -ENOMEM; 1501 ret = -ENOMEM;
1011 goto error; 1502 goto error;
1012 } 1503 }
1013 memset(ec_ecdt, 0, sizeof(struct acpi_ec)); 1504 memset(ec_ecdt, 0, sizeof(union acpi_ec));
1014 1505
1015 status = acpi_get_devices (ACPI_EC_HID, 1506 status = acpi_get_devices (ACPI_EC_HID,
1016 acpi_fake_ecdt_callback, 1507 acpi_fake_ecdt_callback,
@@ -1031,6 +1522,60 @@ error:
1031static int __init 1522static int __init
1032acpi_ec_get_real_ecdt(void) 1523acpi_ec_get_real_ecdt(void)
1033{ 1524{
1525 if (acpi_ec_polling_mode)
1526 return acpi_ec_polling_get_real_ecdt();
1527 else
1528 return acpi_ec_burst_get_real_ecdt();
1529}
1530
1531static int __init
1532acpi_ec_polling_get_real_ecdt(void)
1533{
1534 acpi_status status;
1535 struct acpi_table_ecdt *ecdt_ptr;
1536
1537 status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
1538 (struct acpi_table_header **) &ecdt_ptr);
1539 if (ACPI_FAILURE(status))
1540 return -ENODEV;
1541
1542 printk(KERN_INFO PREFIX "Found ECDT\n");
1543
1544 /*
1545 * Generate a temporary ec context to use until the namespace is scanned
1546 */
1547 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1548 if (!ec_ecdt)
1549 return -ENOMEM;
1550 memset(ec_ecdt, 0, sizeof(union acpi_ec));
1551
1552 ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1553 ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1554 ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1555 ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
1556 spin_lock_init(&ec_ecdt->polling.lock);
1557 /* use the GL just to be safe */
1558 ec_ecdt->common.global_lock = TRUE;
1559 ec_ecdt->common.uid = ecdt_ptr->uid;
1560
1561 status = acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
1562 if (ACPI_FAILURE(status)) {
1563 goto error;
1564 }
1565
1566 return 0;
1567error:
1568 printk(KERN_ERR PREFIX "Could not use ECDT\n");
1569 kfree(ec_ecdt);
1570 ec_ecdt = NULL;
1571
1572 return -ENODEV;
1573}
1574
1575
1576static int __init
1577acpi_ec_burst_get_real_ecdt(void)
1578{
1034 acpi_status status; 1579 acpi_status status;
1035 struct acpi_table_ecdt *ecdt_ptr; 1580 struct acpi_table_ecdt *ecdt_ptr;
1036 1581
@@ -1044,22 +1589,22 @@ acpi_ec_get_real_ecdt(void)
1044 /* 1589 /*
1045 * Generate a temporary ec context to use until the namespace is scanned 1590 * Generate a temporary ec context to use until the namespace is scanned
1046 */ 1591 */
1047 ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL); 1592 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1048 if (!ec_ecdt) 1593 if (!ec_ecdt)
1049 return -ENOMEM; 1594 return -ENOMEM;
1050 memset(ec_ecdt, 0, sizeof(struct acpi_ec)); 1595 memset(ec_ecdt, 0, sizeof(union acpi_ec));
1051 1596
1052 init_MUTEX(&ec_ecdt->sem); 1597 init_MUTEX(&ec_ecdt->burst.sem);
1053 init_waitqueue_head(&ec_ecdt->wait); 1598 init_waitqueue_head(&ec_ecdt->burst.wait);
1054 ec_ecdt->command_addr = ecdt_ptr->ec_control; 1599 ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1055 ec_ecdt->status_addr = ecdt_ptr->ec_control; 1600 ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1056 ec_ecdt->data_addr = ecdt_ptr->ec_data; 1601 ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1057 ec_ecdt->gpe_bit = ecdt_ptr->gpe_bit; 1602 ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
1058 /* use the GL just to be safe */ 1603 /* use the GL just to be safe */
1059 ec_ecdt->global_lock = TRUE; 1604 ec_ecdt->common.global_lock = TRUE;
1060 ec_ecdt->uid = ecdt_ptr->uid; 1605 ec_ecdt->common.uid = ecdt_ptr->uid;
1061 1606
1062 status = acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->handle); 1607 status = acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
1063 if (ACPI_FAILURE(status)) { 1608 if (ACPI_FAILURE(status)) {
1064 goto error; 1609 goto error;
1065 } 1610 }
@@ -1092,20 +1637,20 @@ acpi_ec_ecdt_probe (void)
1092 /* 1637 /*
1093 * Install GPE handler 1638 * Install GPE handler
1094 */ 1639 */
1095 status = acpi_install_gpe_handler(NULL, ec_ecdt->gpe_bit, 1640 status = acpi_install_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1096 ACPI_GPE_EDGE_TRIGGERED, &acpi_ec_gpe_handler, 1641 ACPI_GPE_EDGE_TRIGGERED, &acpi_ec_gpe_handler,
1097 ec_ecdt); 1642 ec_ecdt);
1098 if (ACPI_FAILURE(status)) { 1643 if (ACPI_FAILURE(status)) {
1099 goto error; 1644 goto error;
1100 } 1645 }
1101 acpi_set_gpe_type (NULL, ec_ecdt->gpe_bit, ACPI_GPE_TYPE_RUNTIME); 1646 acpi_set_gpe_type (NULL, ec_ecdt->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1102 acpi_enable_gpe (NULL, ec_ecdt->gpe_bit, ACPI_NOT_ISR); 1647 acpi_enable_gpe (NULL, ec_ecdt->common.gpe_bit, ACPI_NOT_ISR);
1103 1648
1104 status = acpi_install_address_space_handler (ACPI_ROOT_OBJECT, 1649 status = acpi_install_address_space_handler (ACPI_ROOT_OBJECT,
1105 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler, 1650 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler,
1106 &acpi_ec_space_setup, ec_ecdt); 1651 &acpi_ec_space_setup, ec_ecdt);
1107 if (ACPI_FAILURE(status)) { 1652 if (ACPI_FAILURE(status)) {
1108 acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit, 1653 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1109 &acpi_ec_gpe_handler); 1654 &acpi_ec_gpe_handler);
1110 goto error; 1655 goto error;
1111 } 1656 }
@@ -1123,7 +1668,7 @@ error:
1123 1668
1124static int __init acpi_ec_init (void) 1669static int __init acpi_ec_init (void)
1125{ 1670{
1126 int result; 1671 int result = 0;
1127 1672
1128 ACPI_FUNCTION_TRACE("acpi_ec_init"); 1673 ACPI_FUNCTION_TRACE("acpi_ec_init");
1129 1674
@@ -1166,4 +1711,24 @@ static int __init acpi_fake_ecdt_setup(char *str)
1166 acpi_fake_ecdt_enabled = 1; 1711 acpi_fake_ecdt_enabled = 1;
1167 return 0; 1712 return 0;
1168} 1713}
1714
1169__setup("acpi_fake_ecdt", acpi_fake_ecdt_setup); 1715__setup("acpi_fake_ecdt", acpi_fake_ecdt_setup);
1716static int __init acpi_ec_set_polling_mode(char *str)
1717{
1718 int burst;
1719
1720 if (!get_option(&str, &burst))
1721 return 0;
1722
1723 if (burst) {
1724 acpi_ec_polling_mode = EC_BURST;
1725 acpi_ec_driver.ops.add = acpi_ec_burst_add;
1726 } else {
1727 acpi_ec_polling_mode = EC_POLLING;
1728 acpi_ec_driver.ops.add = acpi_ec_polling_add;
1729 }
1730 printk(KERN_INFO PREFIX "EC %s mode.\n",
1731 burst ? "burst": "polling");
1732 return 0;
1733}
1734__setup("ec_burst=", acpi_ec_set_polling_mode);
diff --git a/drivers/acpi/hotkey.c b/drivers/acpi/hotkey.c
index babdf762eadb..1f76a40badec 100644
--- a/drivers/acpi/hotkey.c
+++ b/drivers/acpi/hotkey.c
@@ -1,5 +1,5 @@
1/* 1/*
2 * hotkey.c - ACPI Hotkey Driver ($Revision:$) 2 * hotkey.c - ACPI Hotkey Driver ($Revision: 0.2 $)
3 * 3 *
4 * Copyright (C) 2004 Luming Yu <luming.yu@intel.com> 4 * Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
5 * 5 *
@@ -51,17 +51,18 @@
51#define ACPI_HOTKEY_POLLING 0x2 51#define ACPI_HOTKEY_POLLING 0x2
52#define ACPI_UNDEFINED_EVENT 0xf 52#define ACPI_UNDEFINED_EVENT 0xf
53 53
54#define MAX_CONFIG_RECORD_LEN 80 54#define RESULT_STR_LEN 80
55#define MAX_NAME_PATH_LEN 80
56#define MAX_CALL_PARM 80
57 55
58#define IS_EVENT(e) 0xff /* ((e) & 0x40000000) */ 56#define ACTION_METHOD 0
59#define IS_POLL(e) 0xff /* (~((e) & 0x40000000)) */ 57#define POLL_METHOD 1
60 58
59#define IS_EVENT(e) ((e) <= 10000 && (e) >0)
60#define IS_POLL(e) ((e) > 10000)
61#define IS_OTHERS(e) ((e)<=0 || (e)>=20000)
61#define _COMPONENT ACPI_HOTKEY_COMPONENT 62#define _COMPONENT ACPI_HOTKEY_COMPONENT
62ACPI_MODULE_NAME("acpi_hotkey") 63ACPI_MODULE_NAME("acpi_hotkey")
63 64
64 MODULE_AUTHOR("luming.yu@intel.com"); 65MODULE_AUTHOR("luming.yu@intel.com");
65MODULE_DESCRIPTION(ACPI_HOTK_NAME); 66MODULE_DESCRIPTION(ACPI_HOTK_NAME);
66MODULE_LICENSE("GPL"); 67MODULE_LICENSE("GPL");
67 68
@@ -114,7 +115,7 @@ struct acpi_event_hotkey {
114 char *action_method; /* action method */ 115 char *action_method; /* action method */
115}; 116};
116 117
117/* 118/*
118 * There are two ways to poll status 119 * There are two ways to poll status
119 * 1. directy call read_xxx method, without any arguments passed in 120 * 1. directy call read_xxx method, without any arguments passed in
120 * 2. call write_xxx method, with arguments passed in, you need 121 * 2. call write_xxx method, with arguments passed in, you need
@@ -131,7 +132,7 @@ struct acpi_polling_hotkey {
131 char *poll_method; /* poll method */ 132 char *poll_method; /* poll method */
132 acpi_handle action_handle; /* acpi handle attached action method */ 133 acpi_handle action_handle; /* acpi handle attached action method */
133 char *action_method; /* action method */ 134 char *action_method; /* action method */
134 void *poll_result; /* polling_result */ 135 union acpi_object *poll_result; /* polling_result */
135 struct proc_dir_entry *proc; 136 struct proc_dir_entry *proc;
136}; 137};
137 138
@@ -162,20 +163,25 @@ static struct acpi_driver hotkey_driver = {
162 }, 163 },
163}; 164};
164 165
166static void free_hotkey_device(union acpi_hotkey *key);
167static void free_hotkey_buffer(union acpi_hotkey *key);
168static void free_poll_hotkey_buffer(union acpi_hotkey *key);
165static int hotkey_open_config(struct inode *inode, struct file *file); 169static int hotkey_open_config(struct inode *inode, struct file *file);
170static int hotkey_poll_open_config(struct inode *inode, struct file *file);
166static ssize_t hotkey_write_config(struct file *file, 171static ssize_t hotkey_write_config(struct file *file,
167 const char __user * buffer, 172 const char __user * buffer,
168 size_t count, loff_t * data); 173 size_t count, loff_t * data);
169static ssize_t hotkey_write_poll_config(struct file *file,
170 const char __user * buffer,
171 size_t count, loff_t * data);
172static int hotkey_info_open_fs(struct inode *inode, struct file *file); 174static int hotkey_info_open_fs(struct inode *inode, struct file *file);
173static int hotkey_action_open_fs(struct inode *inode, struct file *file); 175static int hotkey_action_open_fs(struct inode *inode, struct file *file);
174static ssize_t hotkey_execute_aml_method(struct file *file, 176static ssize_t hotkey_execute_aml_method(struct file *file,
175 const char __user * buffer, 177 const char __user * buffer,
176 size_t count, loff_t * data); 178 size_t count, loff_t * data);
177static int hotkey_config_seq_show(struct seq_file *seq, void *offset); 179static int hotkey_config_seq_show(struct seq_file *seq, void *offset);
180static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset);
178static int hotkey_polling_open_fs(struct inode *inode, struct file *file); 181static int hotkey_polling_open_fs(struct inode *inode, struct file *file);
182static union acpi_hotkey *get_hotkey_by_event(struct
183 acpi_hotkey_list
184 *hotkey_list, int event);
179 185
180/* event based config */ 186/* event based config */
181static struct file_operations hotkey_config_fops = { 187static struct file_operations hotkey_config_fops = {
@@ -188,9 +194,9 @@ static struct file_operations hotkey_config_fops = {
188 194
189/* polling based config */ 195/* polling based config */
190static struct file_operations hotkey_poll_config_fops = { 196static struct file_operations hotkey_poll_config_fops = {
191 .open = hotkey_open_config, 197 .open = hotkey_poll_open_config,
192 .read = seq_read, 198 .read = seq_read,
193 .write = hotkey_write_poll_config, 199 .write = hotkey_write_config,
194 .llseek = seq_lseek, 200 .llseek = seq_lseek,
195 .release = single_release, 201 .release = single_release,
196}; 202};
@@ -227,7 +233,7 @@ static int hotkey_info_seq_show(struct seq_file *seq, void *offset)
227{ 233{
228 ACPI_FUNCTION_TRACE("hotkey_info_seq_show"); 234 ACPI_FUNCTION_TRACE("hotkey_info_seq_show");
229 235
230 seq_printf(seq, "Hotkey generic driver ver: %s", HOTKEY_ACPI_VERSION); 236 seq_printf(seq, "Hotkey generic driver ver: %s\n", HOTKEY_ACPI_VERSION);
231 237
232 return_VALUE(0); 238 return_VALUE(0);
233} 239}
@@ -239,27 +245,35 @@ static int hotkey_info_open_fs(struct inode *inode, struct file *file)
239 245
240static char *format_result(union acpi_object *object) 246static char *format_result(union acpi_object *object)
241{ 247{
242 char *buf = (char *)kmalloc(sizeof(union acpi_object), GFP_KERNEL); 248 char *buf = NULL;
243 249
244 memset(buf, 0, sizeof(union acpi_object)); 250 buf = (char *)kmalloc(RESULT_STR_LEN, GFP_KERNEL);
251 if (buf)
252 memset(buf, 0, RESULT_STR_LEN);
253 else
254 goto do_fail;
245 255
246 /* Now, just support integer type */ 256 /* Now, just support integer type */
247 if (object->type == ACPI_TYPE_INTEGER) 257 if (object->type == ACPI_TYPE_INTEGER)
248 sprintf(buf, "%d", (u32) object->integer.value); 258 sprintf(buf, "%d\n", (u32) object->integer.value);
249 259do_fail:
250 return buf; 260 return (buf);
251} 261}
252 262
253static int hotkey_polling_seq_show(struct seq_file *seq, void *offset) 263static int hotkey_polling_seq_show(struct seq_file *seq, void *offset)
254{ 264{
255 struct acpi_polling_hotkey *poll_hotkey = 265 struct acpi_polling_hotkey *poll_hotkey =
256 (struct acpi_polling_hotkey *)seq->private; 266 (struct acpi_polling_hotkey *)seq->private;
267 char *buf;
257 268
258 ACPI_FUNCTION_TRACE("hotkey_polling_seq_show"); 269 ACPI_FUNCTION_TRACE("hotkey_polling_seq_show");
259 270
260 if (poll_hotkey->poll_result) 271 if (poll_hotkey->poll_result){
261 seq_printf(seq, "%s", format_result(poll_hotkey->poll_result)); 272 buf = format_result(poll_hotkey->poll_result);
262 273 if(buf)
274 seq_printf(seq, "%s", buf);
275 kfree(buf);
276 }
263 return_VALUE(0); 277 return_VALUE(0);
264} 278}
265 279
@@ -276,19 +290,19 @@ static int hotkey_action_open_fs(struct inode *inode, struct file *file)
276/* Mapping external hotkey number to standardized hotkey event num */ 290/* Mapping external hotkey number to standardized hotkey event num */
277static int hotkey_get_internal_event(int event, struct acpi_hotkey_list *list) 291static int hotkey_get_internal_event(int event, struct acpi_hotkey_list *list)
278{ 292{
279 struct list_head *entries, *next; 293 struct list_head *entries;
280 int val = 0; 294 int val = -1;
281 295
282 ACPI_FUNCTION_TRACE("hotkey_get_internal_event"); 296 ACPI_FUNCTION_TRACE("hotkey_get_internal_event");
283 297
284 list_for_each_safe(entries, next, list->entries) { 298 list_for_each(entries, list->entries) {
285 union acpi_hotkey *key = 299 union acpi_hotkey *key =
286 container_of(entries, union acpi_hotkey, entries); 300 container_of(entries, union acpi_hotkey, entries);
287 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT 301 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT
288 && key->event_hotkey.external_hotkey_num == event) 302 && key->event_hotkey.external_hotkey_num == event){
289 val = key->link.hotkey_standard_num; 303 val = key->link.hotkey_standard_num;
290 else 304 break;
291 val = -1; 305 }
292 } 306 }
293 307
294 return_VALUE(val); 308 return_VALUE(val);
@@ -306,7 +320,7 @@ acpi_hotkey_notify_handler(acpi_handle handle, u32 event, void *data)
306 return_VOID; 320 return_VOID;
307 321
308 internal_event = hotkey_get_internal_event(event, &global_hotkey_list); 322 internal_event = hotkey_get_internal_event(event, &global_hotkey_list);
309 acpi_bus_generate_event(device, event, 0); 323 acpi_bus_generate_event(device, internal_event, 0);
310 324
311 return_VOID; 325 return_VOID;
312} 326}
@@ -329,13 +343,17 @@ static int auto_hotkey_remove(struct acpi_device *device, int type)
329static int create_polling_proc(union acpi_hotkey *device) 343static int create_polling_proc(union acpi_hotkey *device)
330{ 344{
331 struct proc_dir_entry *proc; 345 struct proc_dir_entry *proc;
346 char proc_name[80];
332 mode_t mode; 347 mode_t mode;
333 348
334 ACPI_FUNCTION_TRACE("create_polling_proc"); 349 ACPI_FUNCTION_TRACE("create_polling_proc");
335 mode = S_IFREG | S_IRUGO | S_IWUGO; 350 mode = S_IFREG | S_IRUGO | S_IWUGO;
336 351
337 proc = create_proc_entry(device->poll_hotkey.action_method, 352 sprintf(proc_name, "%d", device->link.hotkey_standard_num);
338 mode, hotkey_proc_dir); 353 /*
354 strcat(proc_name, device->poll_hotkey.poll_method);
355 */
356 proc = create_proc_entry(proc_name, mode, hotkey_proc_dir);
339 357
340 if (!proc) { 358 if (!proc) {
341 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 359 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
@@ -353,23 +371,6 @@ static int create_polling_proc(union acpi_hotkey *device)
353 return_VALUE(0); 371 return_VALUE(0);
354} 372}
355 373
356static int is_valid_acpi_path(const char *pathname)
357{
358 acpi_handle handle;
359 acpi_status status;
360 ACPI_FUNCTION_TRACE("is_valid_acpi_path");
361
362 status = acpi_get_handle(NULL, (char *)pathname, &handle);
363 return_VALUE(!ACPI_FAILURE(status));
364}
365
366static int is_valid_hotkey(union acpi_hotkey *device)
367{
368 ACPI_FUNCTION_TRACE("is_valid_hotkey");
369 /* Implement valid check */
370 return_VALUE(1);
371}
372
373static int hotkey_add(union acpi_hotkey *device) 374static int hotkey_add(union acpi_hotkey *device)
374{ 375{
375 int status = 0; 376 int status = 0;
@@ -378,15 +379,11 @@ static int hotkey_add(union acpi_hotkey *device)
378 ACPI_FUNCTION_TRACE("hotkey_add"); 379 ACPI_FUNCTION_TRACE("hotkey_add");
379 380
380 if (device->link.hotkey_type == ACPI_HOTKEY_EVENT) { 381 if (device->link.hotkey_type == ACPI_HOTKEY_EVENT) {
381 status = 382 acpi_bus_get_device(device->event_hotkey.bus_handle, &dev);
382 acpi_bus_get_device(device->event_hotkey.bus_handle, &dev);
383 if (status)
384 return_VALUE(status);
385
386 status = acpi_install_notify_handler(dev->handle, 383 status = acpi_install_notify_handler(dev->handle,
387 ACPI_SYSTEM_NOTIFY, 384 ACPI_DEVICE_NOTIFY,
388 acpi_hotkey_notify_handler, 385 acpi_hotkey_notify_handler,
389 device); 386 dev);
390 } else /* Add polling hotkey */ 387 } else /* Add polling hotkey */
391 create_polling_proc(device); 388 create_polling_proc(device);
392 389
@@ -409,84 +406,143 @@ static int hotkey_remove(union acpi_hotkey *device)
409 if (key->link.hotkey_standard_num == 406 if (key->link.hotkey_standard_num ==
410 device->link.hotkey_standard_num) { 407 device->link.hotkey_standard_num) {
411 list_del(&key->link.entries); 408 list_del(&key->link.entries);
412 remove_proc_entry(key->poll_hotkey.action_method, 409 free_hotkey_device(key);
413 hotkey_proc_dir);
414 global_hotkey_list.count--; 410 global_hotkey_list.count--;
415 break; 411 break;
416 } 412 }
417 } 413 }
414 kfree(device);
418 return_VALUE(0); 415 return_VALUE(0);
419} 416}
420 417
421static void hotkey_update(union acpi_hotkey *key) 418static int hotkey_update(union acpi_hotkey *key)
422{ 419{
423 struct list_head *entries, *next; 420 struct list_head *entries;
424 421
425 ACPI_FUNCTION_TRACE("hotkey_update"); 422 ACPI_FUNCTION_TRACE("hotkey_update");
426 423
427 list_for_each_safe(entries, next, global_hotkey_list.entries) { 424 list_for_each(entries, global_hotkey_list.entries) {
428 union acpi_hotkey *key = 425 union acpi_hotkey *tmp=
429 container_of(entries, union acpi_hotkey, entries); 426 container_of(entries, union acpi_hotkey, entries);
430 if (key->link.hotkey_standard_num == 427 if (tmp->link.hotkey_standard_num ==
431 key->link.hotkey_standard_num) { 428 key->link.hotkey_standard_num) {
432 key->event_hotkey.bus_handle = 429 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
433 key->event_hotkey.bus_handle; 430 free_hotkey_buffer(tmp);
434 key->event_hotkey.external_hotkey_num = 431 tmp->event_hotkey.bus_handle =
435 key->event_hotkey.external_hotkey_num; 432 key->event_hotkey.bus_handle;
436 key->event_hotkey.action_handle = 433 tmp->event_hotkey.external_hotkey_num =
437 key->event_hotkey.action_handle; 434 key->event_hotkey.external_hotkey_num;
438 key->event_hotkey.action_method = 435 tmp->event_hotkey.action_handle =
439 key->event_hotkey.action_method; 436 key->event_hotkey.action_handle;
437 tmp->event_hotkey.action_method =
438 key->event_hotkey.action_method;
439 kfree(key);
440 } else {
441 /*
442 char proc_name[80];
443
444 sprintf(proc_name, "%d", tmp->link.hotkey_standard_num);
445 strcat(proc_name, tmp->poll_hotkey.poll_method);
446 remove_proc_entry(proc_name,hotkey_proc_dir);
447 */
448 free_poll_hotkey_buffer(tmp);
449 tmp->poll_hotkey.poll_handle =
450 key->poll_hotkey.poll_handle;
451 tmp->poll_hotkey.poll_method =
452 key->poll_hotkey.poll_method;
453 tmp->poll_hotkey.action_handle =
454 key->poll_hotkey.action_handle;
455 tmp->poll_hotkey.action_method =
456 key->poll_hotkey.action_method;
457 tmp->poll_hotkey.poll_result =
458 key->poll_hotkey.poll_result;
459 /*
460 create_polling_proc(tmp);
461 */
462 kfree(key);
463 }
464 return_VALUE(0);
440 break; 465 break;
441 } 466 }
442 } 467 }
443 468
444 return_VOID; 469 return_VALUE(-ENODEV);
445} 470}
446 471
447static void free_hotkey_device(union acpi_hotkey *key) 472static void free_hotkey_device(union acpi_hotkey *key)
448{ 473{
449 struct acpi_device *dev; 474 struct acpi_device *dev;
450 int status;
451 475
452 ACPI_FUNCTION_TRACE("free_hotkey_device"); 476 ACPI_FUNCTION_TRACE("free_hotkey_device");
453 477
454 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) { 478 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
455 status = 479 acpi_bus_get_device(key->event_hotkey.bus_handle, &dev);
456 acpi_bus_get_device(key->event_hotkey.bus_handle, &dev);
457 if (dev->handle) 480 if (dev->handle)
458 acpi_remove_notify_handler(dev->handle, 481 acpi_remove_notify_handler(dev->handle,
459 ACPI_SYSTEM_NOTIFY, 482 ACPI_DEVICE_NOTIFY,
460 acpi_hotkey_notify_handler); 483 acpi_hotkey_notify_handler);
461 } else 484 free_hotkey_buffer(key);
462 remove_proc_entry(key->poll_hotkey.action_method, 485 } else {
463 hotkey_proc_dir); 486 char proc_name[80];
487
488 sprintf(proc_name, "%d", key->link.hotkey_standard_num);
489 /*
490 strcat(proc_name, key->poll_hotkey.poll_method);
491 */
492 remove_proc_entry(proc_name,hotkey_proc_dir);
493 free_poll_hotkey_buffer(key);
494 }
464 kfree(key); 495 kfree(key);
465 return_VOID; 496 return_VOID;
466} 497}
467 498
499static void
500free_hotkey_buffer(union acpi_hotkey *key)
501{
502 kfree(key->event_hotkey.action_method);
503}
504
505static void
506free_poll_hotkey_buffer(union acpi_hotkey *key)
507{
508 kfree(key->poll_hotkey.action_method);
509 kfree(key->poll_hotkey.poll_method);
510 kfree(key->poll_hotkey.poll_result);
511}
468static int 512static int
469init_hotkey_device(union acpi_hotkey *key, char *bus_str, char *action_str, 513init_hotkey_device(union acpi_hotkey *key, char *bus_str, char *action_str,
470 char *method, int std_num, int external_num) 514 char *method, int std_num, int external_num)
471{ 515{
516 acpi_handle tmp_handle;
517 acpi_status status = AE_OK;
518
472 ACPI_FUNCTION_TRACE("init_hotkey_device"); 519 ACPI_FUNCTION_TRACE("init_hotkey_device");
473 520
521 if(std_num < 0 || IS_POLL(std_num) || !key )
522 goto do_fail;
523
524 if(!bus_str || !action_str || !method)
525 goto do_fail;
526
474 key->link.hotkey_type = ACPI_HOTKEY_EVENT; 527 key->link.hotkey_type = ACPI_HOTKEY_EVENT;
475 key->link.hotkey_standard_num = std_num; 528 key->link.hotkey_standard_num = std_num;
476 key->event_hotkey.flag = 0; 529 key->event_hotkey.flag = 0;
477 if (is_valid_acpi_path(bus_str)) 530 key->event_hotkey.action_method = method;
478 acpi_get_handle((acpi_handle) 0,
479 bus_str, &(key->event_hotkey.bus_handle));
480 else
481 return_VALUE(-ENODEV);
482 key->event_hotkey.external_hotkey_num = external_num;
483 if (is_valid_acpi_path(action_str))
484 acpi_get_handle((acpi_handle) 0,
485 action_str, &(key->event_hotkey.action_handle));
486 key->event_hotkey.action_method = kmalloc(sizeof(method), GFP_KERNEL);
487 strcpy(key->event_hotkey.action_method, method);
488 531
489 return_VALUE(!is_valid_hotkey(key)); 532 status = acpi_get_handle(NULL,bus_str, &(key->event_hotkey.bus_handle));
533 if(ACPI_FAILURE(status))
534 goto do_fail;
535 key->event_hotkey.external_hotkey_num = external_num;
536 status = acpi_get_handle(NULL,action_str, &(key->event_hotkey.action_handle));
537 if(ACPI_FAILURE(status))
538 goto do_fail;
539 status = acpi_get_handle(key->event_hotkey.action_handle,
540 method, &tmp_handle);
541 if (ACPI_FAILURE(status))
542 goto do_fail;
543 return_VALUE(AE_OK);
544do_fail:
545 return_VALUE(-ENODEV);
490} 546}
491 547
492static int 548static int
@@ -495,34 +551,46 @@ init_poll_hotkey_device(union acpi_hotkey *key,
495 char *poll_method, 551 char *poll_method,
496 char *action_str, char *action_method, int std_num) 552 char *action_str, char *action_method, int std_num)
497{ 553{
554 acpi_status status = AE_OK;
555 acpi_handle tmp_handle;
556
498 ACPI_FUNCTION_TRACE("init_poll_hotkey_device"); 557 ACPI_FUNCTION_TRACE("init_poll_hotkey_device");
499 558
559 if(std_num < 0 || IS_EVENT(std_num) || !key)
560 goto do_fail;
561
562 if(!poll_str || !poll_method || !action_str || !action_method)
563 goto do_fail;
564
500 key->link.hotkey_type = ACPI_HOTKEY_POLLING; 565 key->link.hotkey_type = ACPI_HOTKEY_POLLING;
501 key->link.hotkey_standard_num = std_num; 566 key->link.hotkey_standard_num = std_num;
502 key->poll_hotkey.flag = 0; 567 key->poll_hotkey.flag = 0;
503 if (is_valid_acpi_path(poll_str))
504 acpi_get_handle((acpi_handle) 0,
505 poll_str, &(key->poll_hotkey.poll_handle));
506 else
507 return_VALUE(-ENODEV);
508 key->poll_hotkey.poll_method = poll_method; 568 key->poll_hotkey.poll_method = poll_method;
509 if (is_valid_acpi_path(action_str)) 569 key->poll_hotkey.action_method = action_method;
510 acpi_get_handle((acpi_handle) 0, 570
511 action_str, &(key->poll_hotkey.action_handle)); 571 status = acpi_get_handle(NULL,poll_str, &(key->poll_hotkey.poll_handle));
512 key->poll_hotkey.action_method = 572 if(ACPI_FAILURE(status))
513 kmalloc(sizeof(action_method), GFP_KERNEL); 573 goto do_fail;
514 strcpy(key->poll_hotkey.action_method, action_method); 574 status = acpi_get_handle(key->poll_hotkey.poll_handle,
575 poll_method, &tmp_handle);
576 if (ACPI_FAILURE(status))
577 goto do_fail;
578 status = acpi_get_handle(NULL,action_str, &(key->poll_hotkey.action_handle));
579 if (ACPI_FAILURE(status))
580 goto do_fail;
581 status = acpi_get_handle(key->poll_hotkey.action_handle,
582 action_method, &tmp_handle);
583 if (ACPI_FAILURE(status))
584 goto do_fail;
515 key->poll_hotkey.poll_result = 585 key->poll_hotkey.poll_result =
516 (union acpi_object *)kmalloc(sizeof(union acpi_object), GFP_KERNEL); 586 (union acpi_object *)kmalloc(sizeof(union acpi_object), GFP_KERNEL);
517 return_VALUE(is_valid_hotkey(key)); 587 if(!key->poll_hotkey.poll_result)
588 goto do_fail;
589 return_VALUE(AE_OK);
590do_fail:
591 return_VALUE(-ENODEV);
518} 592}
519 593
520static int check_hotkey_valid(union acpi_hotkey *key,
521 struct acpi_hotkey_list *list)
522{
523 ACPI_FUNCTION_TRACE("check_hotkey_valid");
524 return_VALUE(0);
525}
526 594
527static int hotkey_open_config(struct inode *inode, struct file *file) 595static int hotkey_open_config(struct inode *inode, struct file *file)
528{ 596{
@@ -531,10 +599,17 @@ static int hotkey_open_config(struct inode *inode, struct file *file)
531 (file, hotkey_config_seq_show, PDE(inode)->data)); 599 (file, hotkey_config_seq_show, PDE(inode)->data));
532} 600}
533 601
602static int hotkey_poll_open_config(struct inode *inode, struct file *file)
603{
604 ACPI_FUNCTION_TRACE("hotkey_poll_open_config");
605 return_VALUE(single_open
606 (file, hotkey_poll_config_seq_show, PDE(inode)->data));
607}
608
534static int hotkey_config_seq_show(struct seq_file *seq, void *offset) 609static int hotkey_config_seq_show(struct seq_file *seq, void *offset)
535{ 610{
536 struct acpi_hotkey_list *hotkey_list = &global_hotkey_list; 611 struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
537 struct list_head *entries, *next; 612 struct list_head *entries;
538 char bus_name[ACPI_PATHNAME_MAX] = { 0 }; 613 char bus_name[ACPI_PATHNAME_MAX] = { 0 };
539 char action_name[ACPI_PATHNAME_MAX] = { 0 }; 614 char action_name[ACPI_PATHNAME_MAX] = { 0 };
540 struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name }; 615 struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
@@ -542,10 +617,7 @@ static int hotkey_config_seq_show(struct seq_file *seq, void *offset)
542 617
543 ACPI_FUNCTION_TRACE(("hotkey_config_seq_show")); 618 ACPI_FUNCTION_TRACE(("hotkey_config_seq_show"));
544 619
545 if (!hotkey_list) 620 list_for_each(entries, hotkey_list->entries) {
546 goto end;
547
548 list_for_each_safe(entries, next, hotkey_list->entries) {
549 union acpi_hotkey *key = 621 union acpi_hotkey *key =
550 container_of(entries, union acpi_hotkey, entries); 622 container_of(entries, union acpi_hotkey, entries);
551 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) { 623 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
@@ -553,18 +625,37 @@ static int hotkey_config_seq_show(struct seq_file *seq, void *offset)
553 ACPI_NAME_TYPE_MAX, &bus); 625 ACPI_NAME_TYPE_MAX, &bus);
554 acpi_get_name(key->event_hotkey.action_handle, 626 acpi_get_name(key->event_hotkey.action_handle,
555 ACPI_NAME_TYPE_MAX, &act); 627 ACPI_NAME_TYPE_MAX, &act);
556 seq_printf(seq, "%s:%s:%s:%d:%d", bus_name, 628 seq_printf(seq, "%s:%s:%s:%d:%d\n", bus_name,
557 action_name, 629 action_name,
558 key->event_hotkey.action_method, 630 key->event_hotkey.action_method,
559 key->link.hotkey_standard_num, 631 key->link.hotkey_standard_num,
560 key->event_hotkey.external_hotkey_num); 632 key->event_hotkey.external_hotkey_num);
561 } /* ACPI_HOTKEY_POLLING */ 633 }
562 else { 634 }
635 seq_puts(seq, "\n");
636 return_VALUE(0);
637}
638
639static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset)
640{
641 struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
642 struct list_head *entries;
643 char bus_name[ACPI_PATHNAME_MAX] = { 0 };
644 char action_name[ACPI_PATHNAME_MAX] = { 0 };
645 struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
646 struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
647
648 ACPI_FUNCTION_TRACE(("hotkey_config_seq_show"));
649
650 list_for_each(entries, hotkey_list->entries) {
651 union acpi_hotkey *key =
652 container_of(entries, union acpi_hotkey, entries);
653 if (key->link.hotkey_type == ACPI_HOTKEY_POLLING) {
563 acpi_get_name(key->poll_hotkey.poll_handle, 654 acpi_get_name(key->poll_hotkey.poll_handle,
564 ACPI_NAME_TYPE_MAX, &bus); 655 ACPI_NAME_TYPE_MAX, &bus);
565 acpi_get_name(key->poll_hotkey.action_handle, 656 acpi_get_name(key->poll_hotkey.action_handle,
566 ACPI_NAME_TYPE_MAX, &act); 657 ACPI_NAME_TYPE_MAX, &act);
567 seq_printf(seq, "%s:%s:%s:%s:%d", bus_name, 658 seq_printf(seq, "%s:%s:%s:%s:%d\n", bus_name,
568 key->poll_hotkey.poll_method, 659 key->poll_hotkey.poll_method,
569 action_name, 660 action_name,
570 key->poll_hotkey.action_method, 661 key->poll_hotkey.action_method,
@@ -572,49 +663,83 @@ static int hotkey_config_seq_show(struct seq_file *seq, void *offset)
572 } 663 }
573 } 664 }
574 seq_puts(seq, "\n"); 665 seq_puts(seq, "\n");
575 end:
576 return_VALUE(0); 666 return_VALUE(0);
577} 667}
578 668
579static int 669static int
580get_parms(char *config_record, 670get_parms(char *config_record,
581 int *cmd, 671 int *cmd,
582 char *bus_handle, 672 char **bus_handle,
583 char *bus_method, 673 char **bus_method,
584 char *action_handle, 674 char **action_handle,
585 char *method, int *internal_event_num, int *external_event_num) 675 char **method, int *internal_event_num, int *external_event_num)
586{ 676{
587 char *tmp, *tmp1; 677 char *tmp, *tmp1, count;
588 ACPI_FUNCTION_TRACE(("get_parms")); 678 ACPI_FUNCTION_TRACE(("get_parms"));
589 679
590 sscanf(config_record, "%d", cmd); 680 sscanf(config_record, "%d", cmd);
591 681
682 if(*cmd == 1){
683 if(sscanf(config_record, "%d:%d", cmd, internal_event_num)!=2)
684 goto do_fail;
685 else
686 return (6);
687 }
592 tmp = strchr(config_record, ':'); 688 tmp = strchr(config_record, ':');
689 if (!tmp)
690 goto do_fail;
593 tmp++; 691 tmp++;
594 tmp1 = strchr(tmp, ':'); 692 tmp1 = strchr(tmp, ':');
595 strncpy(bus_handle, tmp, tmp1 - tmp); 693 if (!tmp1)
596 bus_handle[tmp1 - tmp] = 0; 694 goto do_fail;
695
696 count = tmp1 - tmp;
697 *bus_handle = (char *) kmalloc(count+1, GFP_KERNEL);
698 if(!*bus_handle)
699 goto do_fail;
700 strncpy(*bus_handle, tmp, count);
701 *(*bus_handle + count) = 0;
597 702
598 tmp = tmp1; 703 tmp = tmp1;
599 tmp++; 704 tmp++;
600 tmp1 = strchr(tmp, ':'); 705 tmp1 = strchr(tmp, ':');
601 strncpy(bus_method, tmp, tmp1 - tmp); 706 if (!tmp1)
602 bus_method[tmp1 - tmp] = 0; 707 goto do_fail;
708 count = tmp1 - tmp;
709 *bus_method = (char *) kmalloc(count+1, GFP_KERNEL);
710 if(!*bus_method)
711 goto do_fail;
712 strncpy(*bus_method, tmp, count);
713 *(*bus_method + count) = 0;
603 714
604 tmp = tmp1; 715 tmp = tmp1;
605 tmp++; 716 tmp++;
606 tmp1 = strchr(tmp, ':'); 717 tmp1 = strchr(tmp, ':');
607 strncpy(action_handle, tmp, tmp1 - tmp); 718 if (!tmp1)
608 action_handle[tmp1 - tmp] = 0; 719 goto do_fail;
720 count = tmp1 - tmp;
721 *action_handle = (char *) kmalloc(count+1, GFP_KERNEL);
722 strncpy(*action_handle, tmp, count);
723 *(*action_handle + count) = 0;
609 724
610 tmp = tmp1; 725 tmp = tmp1;
611 tmp++; 726 tmp++;
612 tmp1 = strchr(tmp, ':'); 727 tmp1 = strchr(tmp, ':');
613 strncpy(method, tmp, tmp1 - tmp); 728 if (!tmp1)
614 method[tmp1 - tmp] = 0; 729 goto do_fail;
730 count = tmp1 - tmp;
731 *method = (char *) kmalloc(count+1, GFP_KERNEL);
732 if(!*method)
733 goto do_fail;
734 strncpy(*method, tmp, count);
735 *(*method + count) = 0;
736
737 if(sscanf(tmp1 + 1, "%d:%d", internal_event_num, external_event_num)<=0)
738 goto do_fail;
615 739
616 sscanf(tmp1 + 1, "%d:%d", internal_event_num, external_event_num);
617 return_VALUE(6); 740 return_VALUE(6);
741do_fail:
742 return_VALUE(-1);
618} 743}
619 744
620/* count is length for one input record */ 745/* count is length for one input record */
@@ -622,135 +747,117 @@ static ssize_t hotkey_write_config(struct file *file,
622 const char __user * buffer, 747 const char __user * buffer,
623 size_t count, loff_t * data) 748 size_t count, loff_t * data)
624{ 749{
625 struct acpi_hotkey_list *hotkey_list = &global_hotkey_list; 750 char *config_record = NULL;
626 char config_record[MAX_CONFIG_RECORD_LEN]; 751 char *bus_handle = NULL;
627 char bus_handle[MAX_NAME_PATH_LEN]; 752 char *bus_method = NULL;
628 char bus_method[MAX_NAME_PATH_LEN]; 753 char *action_handle = NULL;
629 char action_handle[MAX_NAME_PATH_LEN]; 754 char *method = NULL;
630 char method[20];
631 int cmd, internal_event_num, external_event_num; 755 int cmd, internal_event_num, external_event_num;
632 int ret = 0; 756 int ret = 0;
633 union acpi_hotkey *key = NULL; 757 union acpi_hotkey *key = NULL;
634 758
635 ACPI_FUNCTION_TRACE(("hotkey_write_config")); 759 ACPI_FUNCTION_TRACE(("hotkey_write_config"));
636 760
637 if (!hotkey_list || count > MAX_CONFIG_RECORD_LEN) { 761 config_record = (char *) kmalloc(count+1, GFP_KERNEL);
638 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid arguments\n")); 762 if(!config_record)
639 return_VALUE(-EINVAL); 763 return_VALUE(-ENOMEM);
640 }
641 764
642 if (copy_from_user(config_record, buffer, count)) { 765 if (copy_from_user(config_record, buffer, count)) {
766 kfree(config_record);
643 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data \n")); 767 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data \n"));
644 return_VALUE(-EINVAL); 768 return_VALUE(-EINVAL);
645 } 769 }
646 config_record[count] = '\0'; 770 config_record[count] = 0;
647 771
648 ret = get_parms(config_record, 772 ret = get_parms(config_record,
649 &cmd, 773 &cmd,
650 bus_handle, 774 &bus_handle,
651 bus_method, 775 &bus_method,
652 action_handle, 776 &action_handle,
653 method, &internal_event_num, &external_event_num); 777 &method, &internal_event_num, &external_event_num);
778
779 kfree(config_record);
780 if(IS_OTHERS(internal_event_num))
781 goto do_fail;
654 if (ret != 6) { 782 if (ret != 6) {
783do_fail:
784 kfree(bus_handle);
785 kfree(bus_method);
786 kfree(action_handle);
787 kfree(method);
655 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 788 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
656 "Invalid data format ret=%d\n", ret)); 789 "Invalid data format ret=%d\n", ret));
657 return_VALUE(-EINVAL); 790 return_VALUE(-EINVAL);
658 } 791 }
659 792
660 key = kmalloc(sizeof(union acpi_hotkey), GFP_KERNEL); 793 key = kmalloc(sizeof(union acpi_hotkey), GFP_KERNEL);
661 ret = init_hotkey_device(key, bus_handle, action_handle, method, 794 if(!key)
795 goto do_fail;
796 memset(key, 0, sizeof(union acpi_hotkey));
797 if(cmd == 1) {
798 union acpi_hotkey *tmp = NULL;
799 tmp = get_hotkey_by_event(&global_hotkey_list,
800 internal_event_num);
801 if(!tmp)
802 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid key"));
803 else
804 memcpy(key, tmp, sizeof(union acpi_hotkey));
805 goto cont_cmd;
806 }
807 if (IS_EVENT(internal_event_num)) {
808 kfree(bus_method);
809 ret = init_hotkey_device(key, bus_handle, action_handle, method,
662 internal_event_num, external_event_num); 810 internal_event_num, external_event_num);
663 811 } else
664 if (ret || check_hotkey_valid(key, hotkey_list)) { 812 ret = init_poll_hotkey_device(key, bus_handle, bus_method,
813 action_handle, method,
814 internal_event_num);
815 if (ret) {
816 kfree(bus_handle);
817 kfree(action_handle);
818 if(IS_EVENT(internal_event_num))
819 free_hotkey_buffer(key);
820 else
821 free_poll_hotkey_buffer(key);
665 kfree(key); 822 kfree(key);
666 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid hotkey \n")); 823 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid hotkey \n"));
667 return_VALUE(-EINVAL); 824 return_VALUE(-EINVAL);
668 } 825 }
669 switch (cmd) {
670 case 0:
671 hotkey_add(key);
672 break;
673 case 1:
674 hotkey_remove(key);
675 free_hotkey_device(key);
676 break;
677 case 2:
678 hotkey_update(key);
679 break;
680 default:
681 break;
682 }
683 return_VALUE(count);
684}
685
686/* count is length for one input record */
687static ssize_t hotkey_write_poll_config(struct file *file,
688 const char __user * buffer,
689 size_t count, loff_t * data)
690{
691 struct seq_file *m = (struct seq_file *)file->private_data;
692 struct acpi_hotkey_list *hotkey_list =
693 (struct acpi_hotkey_list *)m->private;
694
695 char config_record[MAX_CONFIG_RECORD_LEN];
696 char polling_handle[MAX_NAME_PATH_LEN];
697 char action_handle[MAX_NAME_PATH_LEN];
698 char poll_method[20], action_method[20];
699 int ret, internal_event_num, cmd, external_event_num;
700 union acpi_hotkey *key = NULL;
701
702 ACPI_FUNCTION_TRACE("hotkey_write_poll_config");
703
704 if (!hotkey_list || count > MAX_CONFIG_RECORD_LEN) {
705 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid arguments\n"));
706 return_VALUE(-EINVAL);
707 }
708
709 if (copy_from_user(config_record, buffer, count)) {
710 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data \n"));
711 return_VALUE(-EINVAL);
712 }
713 config_record[count] = '\0';
714 826
715 ret = get_parms(config_record, 827cont_cmd:
716 &cmd, 828 kfree(bus_handle);
717 polling_handle, 829 kfree(action_handle);
718 poll_method,
719 action_handle,
720 action_method,
721 &internal_event_num, &external_event_num);
722
723 if (ret != 6) {
724 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data format\n"));
725 return_VALUE(-EINVAL);
726 }
727 830
728 key = kmalloc(sizeof(union acpi_hotkey), GFP_KERNEL);
729 ret = init_poll_hotkey_device(key, polling_handle, poll_method,
730 action_handle, action_method,
731 internal_event_num);
732 if (ret || check_hotkey_valid(key, hotkey_list)) {
733 kfree(key);
734 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid hotkey \n"));
735 return_VALUE(-EINVAL);
736 }
737 switch (cmd) { 831 switch (cmd) {
738 case 0: 832 case 0:
739 hotkey_add(key); 833 if(get_hotkey_by_event(&global_hotkey_list,key->link.hotkey_standard_num))
834 goto fail_out;
835 else
836 hotkey_add(key);
740 break; 837 break;
741 case 1: 838 case 1:
742 hotkey_remove(key); 839 hotkey_remove(key);
743 break; 840 break;
744 case 2: 841 case 2:
745 hotkey_update(key); 842 if(hotkey_update(key))
843 goto fail_out;
746 break; 844 break;
747 default: 845 default:
846 goto fail_out;
748 break; 847 break;
749 } 848 }
750 return_VALUE(count); 849 return_VALUE(count);
850fail_out:
851 if(IS_EVENT(internal_event_num))
852 free_hotkey_buffer(key);
853 else
854 free_poll_hotkey_buffer(key);
855 kfree(key);
856 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "invalid key\n"));
857 return_VALUE(-EINVAL);
751} 858}
752 859
753/* 860/*
754 * This function evaluates an ACPI method, given an int as parameter, the 861 * This function evaluates an ACPI method, given an int as parameter, the
755 * method is searched within the scope of the handle, can be NULL. The output 862 * method is searched within the scope of the handle, can be NULL. The output
756 * of the method is written is output, which can also be NULL 863 * of the method is written is output, which can also be NULL
@@ -775,7 +882,7 @@ static int write_acpi_int(acpi_handle handle, const char *method, int val,
775 return_VALUE(status == AE_OK); 882 return_VALUE(status == AE_OK);
776} 883}
777 884
778static int read_acpi_int(acpi_handle handle, const char *method, int *val) 885static int read_acpi_int(acpi_handle handle, const char *method, union acpi_object *val)
779{ 886{
780 struct acpi_buffer output; 887 struct acpi_buffer output;
781 union acpi_object out_obj; 888 union acpi_object out_obj;
@@ -786,62 +893,32 @@ static int read_acpi_int(acpi_handle handle, const char *method, int *val)
786 output.pointer = &out_obj; 893 output.pointer = &out_obj;
787 894
788 status = acpi_evaluate_object(handle, (char *)method, NULL, &output); 895 status = acpi_evaluate_object(handle, (char *)method, NULL, &output);
789 *val = out_obj.integer.value; 896 if(val){
897 val->integer.value = out_obj.integer.value;
898 val->type = out_obj.type;
899 } else
900 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "null val pointer"));
790 return_VALUE((status == AE_OK) 901 return_VALUE((status == AE_OK)
791 && (out_obj.type == ACPI_TYPE_INTEGER)); 902 && (out_obj.type == ACPI_TYPE_INTEGER));
792} 903}
793 904
794static acpi_handle 905static union acpi_hotkey *get_hotkey_by_event(struct
795get_handle_from_hotkeylist(struct acpi_hotkey_list *hotkey_list, int event_num) 906 acpi_hotkey_list
907 *hotkey_list, int event)
796{ 908{
797 struct list_head *entries, *next; 909 struct list_head *entries;
798
799 list_for_each_safe(entries, next, hotkey_list->entries) {
800 union acpi_hotkey *key =
801 container_of(entries, union acpi_hotkey, entries);
802 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT
803 && key->link.hotkey_standard_num == event_num) {
804 return (key->event_hotkey.action_handle);
805 }
806 }
807 return (NULL);
808}
809
810static
811char *get_method_from_hotkeylist(struct acpi_hotkey_list *hotkey_list,
812 int event_num)
813{
814 struct list_head *entries, *next;
815
816 list_for_each_safe(entries, next, hotkey_list->entries) {
817 union acpi_hotkey *key =
818 container_of(entries, union acpi_hotkey, entries);
819
820 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT &&
821 key->link.hotkey_standard_num == event_num)
822 return (key->event_hotkey.action_method);
823 }
824 return (NULL);
825}
826
827static struct acpi_polling_hotkey *get_hotkey_by_event(struct
828 acpi_hotkey_list
829 *hotkey_list, int event)
830{
831 struct list_head *entries, *next;
832 910
833 list_for_each_safe(entries, next, hotkey_list->entries) { 911 list_for_each(entries, hotkey_list->entries) {
834 union acpi_hotkey *key = 912 union acpi_hotkey *key =
835 container_of(entries, union acpi_hotkey, entries); 913 container_of(entries, union acpi_hotkey, entries);
836 if (key->link.hotkey_type == ACPI_HOTKEY_POLLING 914 if (key->link.hotkey_standard_num == event) {
837 && key->link.hotkey_standard_num == event) { 915 return(key);
838 return (&key->poll_hotkey);
839 } 916 }
840 } 917 }
841 return (NULL); 918 return(NULL);
842} 919}
843 920
844/* 921/*
845 * user call AML method interface: 922 * user call AML method interface:
846 * Call convention: 923 * Call convention:
847 * echo "event_num: arg type : value" 924 * echo "event_num: arg type : value"
@@ -854,48 +931,56 @@ static ssize_t hotkey_execute_aml_method(struct file *file,
854 size_t count, loff_t * data) 931 size_t count, loff_t * data)
855{ 932{
856 struct acpi_hotkey_list *hotkey_list = &global_hotkey_list; 933 struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
857 char arg[MAX_CALL_PARM]; 934 char *arg;
858 int event, type, value; 935 int event,method_type,type, value;
859 936 union acpi_hotkey *key;
860 char *method;
861 acpi_handle handle;
862 937
863 ACPI_FUNCTION_TRACE("hotkey_execte_aml_method"); 938 ACPI_FUNCTION_TRACE("hotkey_execte_aml_method");
864 939
865 if (!hotkey_list || count > MAX_CALL_PARM) { 940 arg = (char *) kmalloc(count+1, GFP_KERNEL);
866 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 1")); 941 if(!arg)
867 return_VALUE(-EINVAL); 942 return_VALUE(-ENOMEM);
868 } 943 arg[count]=0;
869 944
870 if (copy_from_user(arg, buffer, count)) { 945 if (copy_from_user(arg, buffer, count)) {
946 kfree(arg);
871 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 2")); 947 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 2"));
872 return_VALUE(-EINVAL); 948 return_VALUE(-EINVAL);
873 } 949 }
874 950
875 arg[count] = '\0'; 951 if (sscanf(arg, "%d:%d:%d:%d", &event, &method_type, &type, &value) != 4) {
876 952 kfree(arg);
877 if (sscanf(arg, "%d:%d:%d", &event, &type, &value) != 3) {
878 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 3")); 953 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 3"));
879 return_VALUE(-EINVAL); 954 return_VALUE(-EINVAL);
880 } 955 }
881 956 kfree(arg);
882 if (type == ACPI_TYPE_INTEGER) { 957 if (type == ACPI_TYPE_INTEGER) {
883 handle = get_handle_from_hotkeylist(hotkey_list, event); 958 key = get_hotkey_by_event(hotkey_list, event);
884 method = (char *)get_method_from_hotkeylist(hotkey_list, event); 959 if(!key)
960 goto do_fail;
885 if (IS_EVENT(event)) 961 if (IS_EVENT(event))
886 write_acpi_int(handle, method, value, NULL); 962 write_acpi_int(key->event_hotkey.action_handle,
963 key->event_hotkey.action_method, value, NULL);
887 else if (IS_POLL(event)) { 964 else if (IS_POLL(event)) {
888 struct acpi_polling_hotkey *key; 965 if ( method_type == POLL_METHOD )
889 key = (struct acpi_polling_hotkey *) 966 read_acpi_int(key->poll_hotkey.poll_handle,
890 get_hotkey_by_event(hotkey_list, event); 967 key->poll_hotkey.poll_method,
891 read_acpi_int(handle, method, key->poll_result); 968 key->poll_hotkey.poll_result);
969 else if ( method_type == ACTION_METHOD )
970 write_acpi_int(key->poll_hotkey.action_handle,
971 key->poll_hotkey.action_method, value, NULL);
972 else
973 goto do_fail;
974
892 } 975 }
893 } else { 976 } else {
894 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Not supported")); 977 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Not supported"));
895 return_VALUE(-EINVAL); 978 return_VALUE(-EINVAL);
896 } 979 }
897
898 return_VALUE(count); 980 return_VALUE(count);
981do_fail:
982 return_VALUE(-EINVAL);
983
899} 984}
900 985
901static int __init hotkey_init(void) 986static int __init hotkey_init(void)
@@ -928,7 +1013,7 @@ static int __init hotkey_init(void)
928 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1013 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
929 "Hotkey: Unable to create %s entry\n", 1014 "Hotkey: Unable to create %s entry\n",
930 HOTKEY_EV_CONFIG)); 1015 HOTKEY_EV_CONFIG));
931 return (-ENODEV); 1016 goto do_fail1;
932 } else { 1017 } else {
933 hotkey_config->proc_fops = &hotkey_config_fops; 1018 hotkey_config->proc_fops = &hotkey_config_fops;
934 hotkey_config->data = &global_hotkey_list; 1019 hotkey_config->data = &global_hotkey_list;
@@ -943,7 +1028,8 @@ static int __init hotkey_init(void)
943 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1028 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
944 "Hotkey: Unable to create %s entry\n", 1029 "Hotkey: Unable to create %s entry\n",
945 HOTKEY_EV_CONFIG)); 1030 HOTKEY_EV_CONFIG));
946 return (-ENODEV); 1031
1032 goto do_fail2;
947 } else { 1033 } else {
948 hotkey_poll_config->proc_fops = &hotkey_poll_config_fops; 1034 hotkey_poll_config->proc_fops = &hotkey_poll_config_fops;
949 hotkey_poll_config->data = &global_hotkey_list; 1035 hotkey_poll_config->data = &global_hotkey_list;
@@ -957,7 +1043,7 @@ static int __init hotkey_init(void)
957 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1043 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
958 "Hotkey: Unable to create %s entry\n", 1044 "Hotkey: Unable to create %s entry\n",
959 HOTKEY_ACTION)); 1045 HOTKEY_ACTION));
960 return (-ENODEV); 1046 goto do_fail3;
961 } else { 1047 } else {
962 hotkey_action->proc_fops = &hotkey_action_fops; 1048 hotkey_action->proc_fops = &hotkey_action_fops;
963 hotkey_action->owner = THIS_MODULE; 1049 hotkey_action->owner = THIS_MODULE;
@@ -970,7 +1056,7 @@ static int __init hotkey_init(void)
970 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1056 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
971 "Hotkey: Unable to create %s entry\n", 1057 "Hotkey: Unable to create %s entry\n",
972 HOTKEY_INFO)); 1058 HOTKEY_INFO));
973 return (-ENODEV); 1059 goto do_fail4;
974 } else { 1060 } else {
975 hotkey_info->proc_fops = &hotkey_info_fops; 1061 hotkey_info->proc_fops = &hotkey_info_fops;
976 hotkey_info->owner = THIS_MODULE; 1062 hotkey_info->owner = THIS_MODULE;
@@ -979,23 +1065,33 @@ static int __init hotkey_init(void)
979 } 1065 }
980 1066
981 result = acpi_bus_register_driver(&hotkey_driver); 1067 result = acpi_bus_register_driver(&hotkey_driver);
982 if (result < 0) { 1068 if (result < 0)
983 remove_proc_entry(HOTKEY_PROC, acpi_root_dir); 1069 goto do_fail5;
984 return (-ENODEV);
985 }
986 global_hotkey_list.count = 0; 1070 global_hotkey_list.count = 0;
987 global_hotkey_list.entries = &hotkey_entries; 1071 global_hotkey_list.entries = &hotkey_entries;
988 1072
989 INIT_LIST_HEAD(&hotkey_entries); 1073 INIT_LIST_HEAD(&hotkey_entries);
990 1074
991 return (0); 1075 return (0);
1076
1077do_fail5:
1078 remove_proc_entry(HOTKEY_INFO, hotkey_proc_dir);
1079do_fail4:
1080 remove_proc_entry(HOTKEY_ACTION, hotkey_proc_dir);
1081do_fail3:
1082 remove_proc_entry(HOTKEY_PL_CONFIG, hotkey_proc_dir);
1083do_fail2:
1084 remove_proc_entry(HOTKEY_EV_CONFIG, hotkey_proc_dir);
1085do_fail1:
1086 remove_proc_entry(HOTKEY_PROC, acpi_root_dir);
1087 return (-ENODEV);
992} 1088}
993 1089
994static void __exit hotkey_exit(void) 1090static void __exit hotkey_exit(void)
995{ 1091{
996 struct list_head *entries, *next; 1092 struct list_head *entries, *next;
997 1093
998 ACPI_FUNCTION_TRACE("hotkey_remove"); 1094 ACPI_FUNCTION_TRACE("hotkey_exit");
999 1095
1000 list_for_each_safe(entries, next, global_hotkey_list.entries) { 1096 list_for_each_safe(entries, next, global_hotkey_list.entries) {
1001 union acpi_hotkey *key = 1097 union acpi_hotkey *key =
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index bdd9f37f8101..7289da3c4db6 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -145,10 +145,14 @@ acpi_os_vprintf(const char *fmt, va_list args)
145#endif 145#endif
146} 146}
147 147
148extern int acpi_in_resume;
148void * 149void *
149acpi_os_allocate(acpi_size size) 150acpi_os_allocate(acpi_size size)
150{ 151{
151 return kmalloc(size, GFP_KERNEL); 152 if (acpi_in_resume)
153 return kmalloc(size, GFP_ATOMIC);
154 else
155 return kmalloc(size, GFP_KERNEL);
152} 156}
153 157
154void 158void
diff --git a/drivers/acpi/pci_irq.c b/drivers/acpi/pci_irq.c
index d1f42b972821..bb973d2109a1 100644
--- a/drivers/acpi/pci_irq.c
+++ b/drivers/acpi/pci_irq.c
@@ -269,7 +269,51 @@ acpi_pci_irq_del_prt (int segment, int bus)
269/* -------------------------------------------------------------------------- 269/* --------------------------------------------------------------------------
270 PCI Interrupt Routing Support 270 PCI Interrupt Routing Support
271 -------------------------------------------------------------------------- */ 271 -------------------------------------------------------------------------- */
272typedef int (*irq_lookup_func)(struct acpi_prt_entry *, int *, int *, char **);
272 273
274static int
275acpi_pci_allocate_irq(struct acpi_prt_entry *entry,
276 int *edge_level,
277 int *active_high_low,
278 char **link)
279{
280 int irq;
281
282 ACPI_FUNCTION_TRACE("acpi_pci_allocate_irq");
283
284 if (entry->link.handle) {
285 irq = acpi_pci_link_allocate_irq(entry->link.handle,
286 entry->link.index, edge_level, active_high_low, link);
287 if (irq < 0) {
288 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid IRQ link routing entry\n"));
289 return_VALUE(-1);
290 }
291 } else {
292 irq = entry->link.index;
293 *edge_level = ACPI_LEVEL_SENSITIVE;
294 *active_high_low = ACPI_ACTIVE_LOW;
295 }
296
297 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found IRQ %d\n", irq));
298 return_VALUE(irq);
299}
300
301static int
302acpi_pci_free_irq(struct acpi_prt_entry *entry,
303 int *edge_level,
304 int *active_high_low,
305 char **link)
306{
307 int irq;
308
309 ACPI_FUNCTION_TRACE("acpi_pci_free_irq");
310 if (entry->link.handle) {
311 irq = acpi_pci_link_free_irq(entry->link.handle);
312 } else {
313 irq = entry->link.index;
314 }
315 return_VALUE(irq);
316}
273/* 317/*
274 * acpi_pci_irq_lookup 318 * acpi_pci_irq_lookup
275 * success: return IRQ >= 0 319 * success: return IRQ >= 0
@@ -282,12 +326,13 @@ acpi_pci_irq_lookup (
282 int pin, 326 int pin,
283 int *edge_level, 327 int *edge_level,
284 int *active_high_low, 328 int *active_high_low,
285 char **link) 329 char **link,
330 irq_lookup_func func)
286{ 331{
287 struct acpi_prt_entry *entry = NULL; 332 struct acpi_prt_entry *entry = NULL;
288 int segment = pci_domain_nr(bus); 333 int segment = pci_domain_nr(bus);
289 int bus_nr = bus->number; 334 int bus_nr = bus->number;
290 int irq; 335 int ret;
291 336
292 ACPI_FUNCTION_TRACE("acpi_pci_irq_lookup"); 337 ACPI_FUNCTION_TRACE("acpi_pci_irq_lookup");
293 338
@@ -301,22 +346,8 @@ acpi_pci_irq_lookup (
301 return_VALUE(-1); 346 return_VALUE(-1);
302 } 347 }
303 348
304 if (entry->link.handle) { 349 ret = func(entry, edge_level, active_high_low, link);
305 irq = acpi_pci_link_get_irq(entry->link.handle, 350 return_VALUE(ret);
306 entry->link.index, edge_level, active_high_low, link);
307 if (irq < 0) {
308 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid IRQ link routing entry\n"));
309 return_VALUE(-1);
310 }
311 } else {
312 irq = entry->link.index;
313 *edge_level = ACPI_LEVEL_SENSITIVE;
314 *active_high_low = ACPI_ACTIVE_LOW;
315 }
316
317 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found IRQ %d\n", irq));
318
319 return_VALUE(irq);
320} 351}
321 352
322/* 353/*
@@ -330,7 +361,8 @@ acpi_pci_irq_derive (
330 int pin, 361 int pin,
331 int *edge_level, 362 int *edge_level,
332 int *active_high_low, 363 int *active_high_low,
333 char **link) 364 char **link,
365 irq_lookup_func func)
334{ 366{
335 struct pci_dev *bridge = dev; 367 struct pci_dev *bridge = dev;
336 int irq = -1; 368 int irq = -1;
@@ -363,7 +395,7 @@ acpi_pci_irq_derive (
363 } 395 }
364 396
365 irq = acpi_pci_irq_lookup(bridge->bus, PCI_SLOT(bridge->devfn), 397 irq = acpi_pci_irq_lookup(bridge->bus, PCI_SLOT(bridge->devfn),
366 pin, edge_level, active_high_low, link); 398 pin, edge_level, active_high_low, link, func);
367 } 399 }
368 400
369 if (irq < 0) { 401 if (irq < 0) {
@@ -415,7 +447,7 @@ acpi_pci_irq_enable (
415 * values override any BIOS-assigned IRQs set during boot. 447 * values override any BIOS-assigned IRQs set during boot.
416 */ 448 */
417 irq = acpi_pci_irq_lookup(dev->bus, PCI_SLOT(dev->devfn), pin, 449 irq = acpi_pci_irq_lookup(dev->bus, PCI_SLOT(dev->devfn), pin,
418 &edge_level, &active_high_low, &link); 450 &edge_level, &active_high_low, &link, acpi_pci_allocate_irq);
419 451
420 /* 452 /*
421 * If no PRT entry was found, we'll try to derive an IRQ from the 453 * If no PRT entry was found, we'll try to derive an IRQ from the
@@ -423,7 +455,7 @@ acpi_pci_irq_enable (
423 */ 455 */
424 if (irq < 0) 456 if (irq < 0)
425 irq = acpi_pci_irq_derive(dev, pin, &edge_level, 457 irq = acpi_pci_irq_derive(dev, pin, &edge_level,
426 &active_high_low, &link); 458 &active_high_low, &link, acpi_pci_allocate_irq);
427 459
428 /* 460 /*
429 * No IRQ known to the ACPI subsystem - maybe the BIOS / 461 * No IRQ known to the ACPI subsystem - maybe the BIOS /
@@ -462,7 +494,9 @@ acpi_pci_irq_enable (
462EXPORT_SYMBOL(acpi_pci_irq_enable); 494EXPORT_SYMBOL(acpi_pci_irq_enable);
463 495
464 496
465#ifdef CONFIG_ACPI_DEALLOCATE_IRQ 497/* FIXME: implement x86/x86_64 version */
498void __attribute__((weak)) acpi_unregister_gsi(u32 i) {}
499
466void 500void
467acpi_pci_irq_disable ( 501acpi_pci_irq_disable (
468 struct pci_dev *dev) 502 struct pci_dev *dev)
@@ -489,14 +523,14 @@ acpi_pci_irq_disable (
489 * First we check the PCI IRQ routing table (PRT) for an IRQ. 523 * First we check the PCI IRQ routing table (PRT) for an IRQ.
490 */ 524 */
491 gsi = acpi_pci_irq_lookup(dev->bus, PCI_SLOT(dev->devfn), pin, 525 gsi = acpi_pci_irq_lookup(dev->bus, PCI_SLOT(dev->devfn), pin,
492 &edge_level, &active_high_low, NULL); 526 &edge_level, &active_high_low, NULL, acpi_pci_free_irq);
493 /* 527 /*
494 * If no PRT entry was found, we'll try to derive an IRQ from the 528 * If no PRT entry was found, we'll try to derive an IRQ from the
495 * device's parent bridge. 529 * device's parent bridge.
496 */ 530 */
497 if (gsi < 0) 531 if (gsi < 0)
498 gsi = acpi_pci_irq_derive(dev, pin, 532 gsi = acpi_pci_irq_derive(dev, pin,
499 &edge_level, &active_high_low, NULL); 533 &edge_level, &active_high_low, NULL, acpi_pci_free_irq);
500 if (gsi < 0) 534 if (gsi < 0)
501 return_VOID; 535 return_VOID;
502 536
@@ -512,4 +546,3 @@ acpi_pci_irq_disable (
512 546
513 return_VOID; 547 return_VOID;
514} 548}
515#endif /* CONFIG_ACPI_DEALLOCATE_IRQ */
diff --git a/drivers/acpi/pci_link.c b/drivers/acpi/pci_link.c
index 6ad0e77df9b3..834c2ceff1aa 100644
--- a/drivers/acpi/pci_link.c
+++ b/drivers/acpi/pci_link.c
@@ -68,6 +68,10 @@ static struct acpi_driver acpi_pci_link_driver = {
68 }, 68 },
69}; 69};
70 70
71/*
72 * If a link is initialized, we never change its active and initialized
73 * later even the link is disable. Instead, we just repick the active irq
74 */
71struct acpi_pci_link_irq { 75struct acpi_pci_link_irq {
72 u8 active; /* Current IRQ */ 76 u8 active; /* Current IRQ */
73 u8 edge_level; /* All IRQs */ 77 u8 edge_level; /* All IRQs */
@@ -76,8 +80,7 @@ struct acpi_pci_link_irq {
76 u8 possible_count; 80 u8 possible_count;
77 u8 possible[ACPI_PCI_LINK_MAX_POSSIBLE]; 81 u8 possible[ACPI_PCI_LINK_MAX_POSSIBLE];
78 u8 initialized:1; 82 u8 initialized:1;
79 u8 suspend_resume:1; 83 u8 reserved:7;
80 u8 reserved:6;
81}; 84};
82 85
83struct acpi_pci_link { 86struct acpi_pci_link {
@@ -85,12 +88,14 @@ struct acpi_pci_link {
85 struct acpi_device *device; 88 struct acpi_device *device;
86 acpi_handle handle; 89 acpi_handle handle;
87 struct acpi_pci_link_irq irq; 90 struct acpi_pci_link_irq irq;
91 int refcnt;
88}; 92};
89 93
90static struct { 94static struct {
91 int count; 95 int count;
92 struct list_head entries; 96 struct list_head entries;
93} acpi_link; 97} acpi_link;
98DECLARE_MUTEX(acpi_link_lock);
94 99
95 100
96/* -------------------------------------------------------------------------- 101/* --------------------------------------------------------------------------
@@ -532,12 +537,12 @@ static int acpi_pci_link_allocate(
532 537
533 ACPI_FUNCTION_TRACE("acpi_pci_link_allocate"); 538 ACPI_FUNCTION_TRACE("acpi_pci_link_allocate");
534 539
535 if (link->irq.suspend_resume) { 540 if (link->irq.initialized) {
536 acpi_pci_link_set(link, link->irq.active); 541 if (link->refcnt == 0)
537 link->irq.suspend_resume = 0; 542 /* This means the link is disabled but initialized */
538 } 543 acpi_pci_link_set(link, link->irq.active);
539 if (link->irq.initialized)
540 return_VALUE(0); 544 return_VALUE(0);
545 }
541 546
542 /* 547 /*
543 * search for active IRQ in list of possible IRQs. 548 * search for active IRQ in list of possible IRQs.
@@ -596,13 +601,13 @@ static int acpi_pci_link_allocate(
596} 601}
597 602
598/* 603/*
599 * acpi_pci_link_get_irq 604 * acpi_pci_link_allocate_irq
600 * success: return IRQ >= 0 605 * success: return IRQ >= 0
601 * failure: return -1 606 * failure: return -1
602 */ 607 */
603 608
604int 609int
605acpi_pci_link_get_irq ( 610acpi_pci_link_allocate_irq (
606 acpi_handle handle, 611 acpi_handle handle,
607 int index, 612 int index,
608 int *edge_level, 613 int *edge_level,
@@ -613,7 +618,7 @@ acpi_pci_link_get_irq (
613 struct acpi_device *device = NULL; 618 struct acpi_device *device = NULL;
614 struct acpi_pci_link *link = NULL; 619 struct acpi_pci_link *link = NULL;
615 620
616 ACPI_FUNCTION_TRACE("acpi_pci_link_get_irq"); 621 ACPI_FUNCTION_TRACE("acpi_pci_link_allocate_irq");
617 622
618 result = acpi_bus_get_device(handle, &device); 623 result = acpi_bus_get_device(handle, &device);
619 if (result) { 624 if (result) {
@@ -633,21 +638,81 @@ acpi_pci_link_get_irq (
633 return_VALUE(-1); 638 return_VALUE(-1);
634 } 639 }
635 640
636 if (acpi_pci_link_allocate(link)) 641 down(&acpi_link_lock);
642 if (acpi_pci_link_allocate(link)) {
643 up(&acpi_link_lock);
637 return_VALUE(-1); 644 return_VALUE(-1);
645 }
638 646
639 if (!link->irq.active) { 647 if (!link->irq.active) {
648 up(&acpi_link_lock);
640 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Link active IRQ is 0!\n")); 649 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Link active IRQ is 0!\n"));
641 return_VALUE(-1); 650 return_VALUE(-1);
642 } 651 }
652 link->refcnt ++;
653 up(&acpi_link_lock);
643 654
644 if (edge_level) *edge_level = link->irq.edge_level; 655 if (edge_level) *edge_level = link->irq.edge_level;
645 if (active_high_low) *active_high_low = link->irq.active_high_low; 656 if (active_high_low) *active_high_low = link->irq.active_high_low;
646 if (name) *name = acpi_device_bid(link->device); 657 if (name) *name = acpi_device_bid(link->device);
658 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
659 "Link %s is referenced\n", acpi_device_bid(link->device)));
647 return_VALUE(link->irq.active); 660 return_VALUE(link->irq.active);
648} 661}
649 662
663/*
664 * We don't change link's irq information here. After it is reenabled, we
665 * continue use the info
666 */
667int
668acpi_pci_link_free_irq(acpi_handle handle)
669{
670 struct acpi_device *device = NULL;
671 struct acpi_pci_link *link = NULL;
672 acpi_status result;
673
674 ACPI_FUNCTION_TRACE("acpi_pci_link_free_irq");
675
676 result = acpi_bus_get_device(handle, &device);
677 if (result) {
678 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link device\n"));
679 return_VALUE(-1);
680 }
681
682 link = (struct acpi_pci_link *) acpi_driver_data(device);
683 if (!link) {
684 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n"));
685 return_VALUE(-1);
686 }
687
688 down(&acpi_link_lock);
689 if (!link->irq.initialized) {
690 up(&acpi_link_lock);
691 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Link isn't initialized\n"));
692 return_VALUE(-1);
693 }
650 694
695#ifdef FUTURE_USE
696 /*
697 * The Link reference count allows us to _DISable an unused link
698 * and suspend time, and set it again on resume.
699 * However, 2.6.12 still has irq_router.resume
700 * which blindly restores the link state.
701 * So we disable the reference count method
702 * to prevent duplicate acpi_pci_link_set()
703 * which would harm some systems
704 */
705 link->refcnt --;
706#endif
707 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
708 "Link %s is dereferenced\n", acpi_device_bid(link->device)));
709
710 if (link->refcnt == 0) {
711 acpi_ut_evaluate_object(link->handle, "_DIS", 0, NULL);
712 }
713 up(&acpi_link_lock);
714 return_VALUE(link->irq.active);
715}
651/* -------------------------------------------------------------------------- 716/* --------------------------------------------------------------------------
652 Driver Interface 717 Driver Interface
653 -------------------------------------------------------------------------- */ 718 -------------------------------------------------------------------------- */
@@ -677,6 +742,7 @@ acpi_pci_link_add (
677 strcpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS); 742 strcpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS);
678 acpi_driver_data(device) = link; 743 acpi_driver_data(device) = link;
679 744
745 down(&acpi_link_lock);
680 result = acpi_pci_link_get_possible(link); 746 result = acpi_pci_link_get_possible(link);
681 if (result) 747 if (result)
682 goto end; 748 goto end;
@@ -712,6 +778,7 @@ acpi_pci_link_add (
712end: 778end:
713 /* disable all links -- to be activated on use */ 779 /* disable all links -- to be activated on use */
714 acpi_ut_evaluate_object(link->handle, "_DIS", 0, NULL); 780 acpi_ut_evaluate_object(link->handle, "_DIS", 0, NULL);
781 up(&acpi_link_lock);
715 782
716 if (result) 783 if (result)
717 kfree(link); 784 kfree(link);
@@ -720,24 +787,42 @@ end:
720} 787}
721 788
722static int 789static int
723irqrouter_suspend( 790acpi_pci_link_resume(
724 struct sys_device *dev, 791 struct acpi_pci_link *link)
725 u32 state) 792{
793 ACPI_FUNCTION_TRACE("acpi_pci_link_resume");
794
795 if (link->refcnt && link->irq.active && link->irq.initialized)
796 return_VALUE(acpi_pci_link_set(link, link->irq.active));
797 else
798 return_VALUE(0);
799}
800
801/*
802 * FIXME: this is a workaround to avoid nasty warning. It will be removed
803 * after every device calls pci_disable_device in .resume.
804 */
805int acpi_in_resume;
806static int
807irqrouter_resume(
808 struct sys_device *dev)
726{ 809{
727 struct list_head *node = NULL; 810 struct list_head *node = NULL;
728 struct acpi_pci_link *link = NULL; 811 struct acpi_pci_link *link = NULL;
729 812
730 ACPI_FUNCTION_TRACE("irqrouter_suspend"); 813 ACPI_FUNCTION_TRACE("irqrouter_resume");
731 814
815 acpi_in_resume = 1;
732 list_for_each(node, &acpi_link.entries) { 816 list_for_each(node, &acpi_link.entries) {
733 link = list_entry(node, struct acpi_pci_link, node); 817 link = list_entry(node, struct acpi_pci_link, node);
734 if (!link) { 818 if (!link) {
735 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n")); 819 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
820 "Invalid link context\n"));
736 continue; 821 continue;
737 } 822 }
738 if (link->irq.active && link->irq.initialized) 823 acpi_pci_link_resume(link);
739 link->irq.suspend_resume = 1;
740 } 824 }
825 acpi_in_resume = 0;
741 return_VALUE(0); 826 return_VALUE(0);
742} 827}
743 828
@@ -756,8 +841,9 @@ acpi_pci_link_remove (
756 841
757 link = (struct acpi_pci_link *) acpi_driver_data(device); 842 link = (struct acpi_pci_link *) acpi_driver_data(device);
758 843
759 /* TBD: Acquire/release lock */ 844 down(&acpi_link_lock);
760 list_del(&link->node); 845 list_del(&link->node);
846 up(&acpi_link_lock);
761 847
762 kfree(link); 848 kfree(link);
763 849
@@ -849,9 +935,10 @@ int __init acpi_irq_balance_set(char *str)
849__setup("acpi_irq_balance", acpi_irq_balance_set); 935__setup("acpi_irq_balance", acpi_irq_balance_set);
850 936
851 937
938/* FIXME: we will remove this interface after all drivers call pci_disable_device */
852static struct sysdev_class irqrouter_sysdev_class = { 939static struct sysdev_class irqrouter_sysdev_class = {
853 set_kset_name("irqrouter"), 940 set_kset_name("irqrouter"),
854 .suspend = irqrouter_suspend, 941 .resume = irqrouter_resume,
855}; 942};
856 943
857 944
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 893b074e3d1a..2c04740c6543 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -81,30 +81,32 @@ module_param(bm_history, uint, 0644);
81 * 81 *
82 * To skip this limit, boot/load with a large max_cstate limit. 82 * To skip this limit, boot/load with a large max_cstate limit.
83 */ 83 */
84static int no_c2c3(struct dmi_system_id *id) 84static int set_max_cstate(struct dmi_system_id *id)
85{ 85{
86 if (max_cstate > ACPI_PROCESSOR_MAX_POWER) 86 if (max_cstate > ACPI_PROCESSOR_MAX_POWER)
87 return 0; 87 return 0;
88 88
89 printk(KERN_NOTICE PREFIX "%s detected - C2,C3 disabled." 89 printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate."
90 " Override with \"processor.max_cstate=%d\"\n", id->ident, 90 " Override with \"processor.max_cstate=%d\"\n", id->ident,
91 ACPI_PROCESSOR_MAX_POWER + 1); 91 (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1);
92 92
93 max_cstate = 1; 93 max_cstate = (long)id->driver_data;
94 94
95 return 0; 95 return 0;
96} 96}
97 97
98 98
99
100
101static struct dmi_system_id __initdata processor_power_dmi_table[] = { 99static struct dmi_system_id __initdata processor_power_dmi_table[] = {
102 { no_c2c3, "IBM ThinkPad R40e", { 100 { set_max_cstate, "IBM ThinkPad R40e", {
103 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 101 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
104 DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW") }}, 102 DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW") }, (void*)1},
105 { no_c2c3, "Medion 41700", { 103 { set_max_cstate, "Medion 41700", {
104 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
105 DMI_MATCH(DMI_BIOS_VERSION,"R01-A1J") }, (void*)1},
106 { set_max_cstate, "Clevo 5600D", {
106 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"), 107 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
107 DMI_MATCH(DMI_BIOS_VERSION,"R01-A1J") }}, 108 DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307") },
109 (void*)2},
108 {}, 110 {},
109}; 111};
110 112
@@ -549,7 +551,8 @@ static int acpi_processor_get_power_info_default_c1 (struct acpi_processor *pr)
549 ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_default_c1"); 551 ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_default_c1");
550 552
551 for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++) 553 for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++)
552 memset(pr->power.states, 0, sizeof(struct acpi_processor_cx)); 554 memset(&(pr->power.states[i]), 0,
555 sizeof(struct acpi_processor_cx));
553 556
554 /* if info is obtained from pblk/fadt, type equals state */ 557 /* if info is obtained from pblk/fadt, type equals state */
555 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; 558 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
@@ -580,7 +583,8 @@ static int acpi_processor_get_power_info_cst (struct acpi_processor *pr)
580 583
581 pr->power.count = 0; 584 pr->power.count = 0;
582 for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++) 585 for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++)
583 memset(pr->power.states, 0, sizeof(struct acpi_processor_cx)); 586 memset(&(pr->power.states[i]), 0,
587 sizeof(struct acpi_processor_cx));
584 588
585 status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer); 589 status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
586 if (ACPI_FAILURE(status)) { 590 if (ACPI_FAILURE(status)) {
@@ -763,7 +767,6 @@ static void acpi_processor_power_verify_c3(
763 } 767 }
764 768
765 if (pr->flags.bm_check) { 769 if (pr->flags.bm_check) {
766 printk("Disabling BM access before entering C3\n");
767 /* bus mastering control is necessary */ 770 /* bus mastering control is necessary */
768 if (!pr->flags.bm_control) { 771 if (!pr->flags.bm_control) {
769 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 772 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
@@ -771,7 +774,6 @@ static void acpi_processor_power_verify_c3(
771 return_VOID; 774 return_VOID;
772 } 775 }
773 } else { 776 } else {
774 printk("Invalidating cache before entering C3\n");
775 /* 777 /*
776 * WBINVD should be set in fadt, for C3 state to be 778 * WBINVD should be set in fadt, for C3 state to be
777 * supported on when bm_check is not required. 779 * supported on when bm_check is not required.
@@ -842,7 +844,7 @@ static int acpi_processor_get_power_info (
842 result = acpi_processor_get_power_info_cst(pr); 844 result = acpi_processor_get_power_info_cst(pr);
843 if ((result) || (acpi_processor_power_verify(pr) < 2)) { 845 if ((result) || (acpi_processor_power_verify(pr) < 2)) {
844 result = acpi_processor_get_power_info_fadt(pr); 846 result = acpi_processor_get_power_info_fadt(pr);
845 if (result) 847 if ((result) || (acpi_processor_power_verify(pr) < 2))
846 result = acpi_processor_get_power_info_default_c1(pr); 848 result = acpi_processor_get_power_info_default_c1(pr);
847 } 849 }
848 850
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-27 12:34:42 -0500