[ACPI] revert Embedded Controller to polling-mode by default (ala 2.6.12)
[linux-2.6.git] / drivers / acpi / ec.c
1 /*
2  *  acpi_ec.c - ACPI Embedded Controller Driver ($Revision: 38 $)
3  *
4  *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
5  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7  *
8  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9  *
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; either version 2 of the License, or (at
13  *  your option) any later version.
14  *
15  *  This program is distributed in the hope that it will be useful, but
16  *  WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  *  General Public License for more details.
19  *
20  *  You should have received a copy of the GNU General Public License along
21  *  with this program; if not, write to the Free Software Foundation, Inc.,
22  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23  *
24  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25  */
26
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/types.h>
31 #include <linux/delay.h>
32 #include <linux/proc_fs.h>
33 #include <linux/seq_file.h>
34 #include <linux/interrupt.h>
35 #include <asm/io.h>
36 #include <acpi/acpi_bus.h>
37 #include <acpi/acpi_drivers.h>
38 #include <acpi/actypes.h>
39
40 #define _COMPONENT              ACPI_EC_COMPONENT
41 ACPI_MODULE_NAME                ("acpi_ec")
42
43 #define ACPI_EC_COMPONENT               0x00100000
44 #define ACPI_EC_CLASS                   "embedded_controller"
45 #define ACPI_EC_HID                     "PNP0C09"
46 #define ACPI_EC_DRIVER_NAME             "ACPI Embedded Controller Driver"
47 #define ACPI_EC_DEVICE_NAME             "Embedded Controller"
48 #define ACPI_EC_FILE_INFO               "info"
49
50
51 #define ACPI_EC_FLAG_OBF        0x01    /* Output buffer full */
52 #define ACPI_EC_FLAG_IBF        0x02    /* Input buffer full */
53 #define ACPI_EC_FLAG_BURST      0x10    /* burst mode */
54 #define ACPI_EC_FLAG_SCI        0x20    /* EC-SCI occurred */
55
56 #define ACPI_EC_EVENT_OBF       0x01    /* Output buffer full */
57 #define ACPI_EC_EVENT_IBE       0x02    /* Input buffer empty */
58
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 */
61
62 #define ACPI_EC_UDELAY         100     /* Poll @ 100us increments */
63 #define ACPI_EC_UDELAY_COUNT   1000    /* Wait 10ms max. during EC ops */
64
65 #define ACPI_EC_COMMAND_READ    0x80
66 #define ACPI_EC_COMMAND_WRITE   0x81
67 #define ACPI_EC_BURST_ENABLE    0x82
68 #define ACPI_EC_BURST_DISABLE   0x83
69 #define ACPI_EC_COMMAND_QUERY   0x84
70
71 #define EC_POLLING              0xFF
72 #define EC_BURST                0x00
73
74
75 static int acpi_ec_remove (struct acpi_device *device, int type);
76 static int acpi_ec_start (struct acpi_device *device);
77 static int acpi_ec_stop (struct acpi_device *device, int type);
78 static int acpi_ec_burst_add ( struct acpi_device *device);
79 static int acpi_ec_polling_add ( struct acpi_device     *device);
80
81 static struct acpi_driver acpi_ec_driver = {
82         .name =         ACPI_EC_DRIVER_NAME,
83         .class =        ACPI_EC_CLASS,
84         .ids =          ACPI_EC_HID,
85         .ops =          {
86                                 .add =          acpi_ec_polling_add,
87                                 .remove =       acpi_ec_remove,
88                                 .start =        acpi_ec_start,
89                                 .stop =         acpi_ec_stop,
90                         },
91 };
92 union acpi_ec {
93         struct {
94                 u32                             mode;
95                 acpi_handle                     handle;
96                 unsigned long                   uid;
97                 unsigned long                   gpe_bit;
98                 struct acpi_generic_address     status_addr;
99                 struct acpi_generic_address     command_addr;
100                 struct acpi_generic_address     data_addr;
101                 unsigned long                   global_lock;
102         } common;
103
104         struct {
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;
131 };
132
133 static int acpi_ec_polling_wait ( union acpi_ec *ec, u8 event); 
134 static int acpi_ec_burst_wait(union acpi_ec *ec, unsigned int event);
135 static int acpi_ec_polling_read ( union acpi_ec *ec, u8 address, u32 *data);
136 static int acpi_ec_burst_read( union acpi_ec *ec, u8 address, u32 *data);
137 static int acpi_ec_polling_write ( union acpi_ec *ec, u8 address, u8 data);
138 static int acpi_ec_burst_write ( union acpi_ec *ec, u8 address, u8 data);
139 static int acpi_ec_polling_query ( union acpi_ec *ec, u32 *data);
140 static int acpi_ec_burst_query ( union acpi_ec *ec, u32 *data);
141 static void acpi_ec_gpe_polling_query ( void *ec_cxt);
142 static void acpi_ec_gpe_burst_query ( void *ec_cxt);
143 static u32 acpi_ec_gpe_polling_handler ( void *data);
144 static u32 acpi_ec_gpe_burst_handler ( void *data);
145 static acpi_status __init
146 acpi_fake_ecdt_polling_callback (
147         acpi_handle     handle,
148         u32             Level,
149         void            *context,
150         void            **retval);
151
152 static acpi_status __init
153 acpi_fake_ecdt_burst_callback (
154         acpi_handle     handle,
155         u32             Level,
156         void            *context,
157         void            **retval);
158
159 static int __init
160 acpi_ec_polling_get_real_ecdt(void);
161 static int __init
162 acpi_ec_burst_get_real_ecdt(void);
163 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
164 static union acpi_ec    *ec_ecdt;
165
166 /* External interfaces use first EC only, so remember */
167 static struct acpi_device *first_ec;
168 static int acpi_ec_polling_mode = EC_POLLING;
169
170 /* --------------------------------------------------------------------------
171                              Transaction Management
172    -------------------------------------------------------------------------- */
173
174 static inline u32 acpi_ec_read_status(union acpi_ec *ec)
175 {
176         u32     status = 0;
177
178         acpi_hw_low_level_read(8, &status, &ec->common.status_addr);
179         return status;
180 }
181
182 static int
183 acpi_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
193 static int
194 acpi_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 }
228 static int acpi_ec_burst_wait(union acpi_ec *ec, unsigned int event)
229 {
230         int     result = 0;
231
232         ACPI_FUNCTION_TRACE("acpi_ec_wait");
233
234         ec->burst.expect_event = event;
235         smp_mb();
236
237         result = wait_event_interruptible_timeout(ec->burst.wait,
238                                         !ec->burst.expect_event,
239                                         msecs_to_jiffies(ACPI_EC_DELAY));
240         
241         ec->burst.expect_event = 0;
242         smp_mb();
243
244         if (result < 0){
245                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR," result  = %d ", result));
246                 return_VALUE(result);
247         }
248
249         /*
250          * Verify that the event in question has actually happened by
251          * querying EC status. Do the check even if operation timed-out
252          * to make sure that we did not miss interrupt.
253          */
254         switch (event) {
255         case ACPI_EC_EVENT_OBF:
256                 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_OBF)
257                         return_VALUE(0);
258                 break;
259
260         case ACPI_EC_EVENT_IBE:
261                 if (~acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF)
262                         return_VALUE(0);
263                 break;
264         }
265
266         return_VALUE(-ETIME);
267 }
268
269
270
271 static int
272 acpi_ec_enter_burst_mode (
273         union acpi_ec           *ec)
274 {
275         u32                     tmp = 0;
276         int                     status = 0;
277
278         ACPI_FUNCTION_TRACE("acpi_ec_enter_burst_mode");
279
280         status = acpi_ec_read_status(ec);
281         if (status != -EINVAL &&
282                 !(status & ACPI_EC_FLAG_BURST)){
283                 acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE, &ec->common.command_addr);
284                 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
285                 if (status){
286                         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
287                         return_VALUE(-EINVAL);
288                 }
289                 acpi_hw_low_level_read(8, &tmp, &ec->common.data_addr);
290                 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
291                 if(tmp != 0x90 ) {/* Burst ACK byte*/
292                         return_VALUE(-EINVAL);
293                 }
294         }
295
296         atomic_set(&ec->burst.leaving_burst , 0);
297         return_VALUE(0);
298 }
299
300 static int
301 acpi_ec_leave_burst_mode (
302         union acpi_ec           *ec)
303 {
304         int                     status =0;
305
306         ACPI_FUNCTION_TRACE("acpi_ec_leave_burst_mode");
307
308         atomic_set(&ec->burst.leaving_burst , 1);
309         status = acpi_ec_read_status(ec);
310         if (status != -EINVAL &&
311                 (status & ACPI_EC_FLAG_BURST)){
312                 acpi_hw_low_level_write(8, ACPI_EC_BURST_DISABLE, &ec->common.command_addr);
313                 status = acpi_ec_wait(ec, ACPI_EC_FLAG_IBF);
314                 if (status){
315                         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
316                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,"------->wait fail\n"));
317                         return_VALUE(-EINVAL);
318                 }
319                 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
320                 status = acpi_ec_read_status(ec);
321         }
322
323         return_VALUE(0);
324 }
325
326 static int
327 acpi_ec_read (
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 }
337 static int
338 acpi_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 }
348 static int
349 acpi_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         
389 end:
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
399 static int
400 acpi_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
441 end:
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
450 static int
451 acpi_ec_burst_read (
452         union acpi_ec           *ec,
453         u8                      address,
454         u32                     *data)
455 {
456         int                     status = 0;
457         u32                     glk;
458
459         ACPI_FUNCTION_TRACE("acpi_ec_read");
460
461         if (!ec || !data)
462                 return_VALUE(-EINVAL);
463
464 retry:
465         *data = 0;
466
467         if (ec->common.global_lock) {
468                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
469                 if (ACPI_FAILURE(status))
470                         return_VALUE(-ENODEV);
471         }
472
473         WARN_ON(in_interrupt());
474         down(&ec->burst.sem);
475
476         if(acpi_ec_enter_burst_mode(ec))
477                 goto end;
478
479         acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ, &ec->common.command_addr);
480         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
481         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
482         if (status) {
483                 goto end;
484         }
485
486         acpi_hw_low_level_write(8, address, &ec->common.data_addr);
487         status= acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
488         if (status){
489                 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
490                 goto end;
491         }
492
493         acpi_hw_low_level_read(8, data, &ec->common.data_addr);
494         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
495
496         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
497                 *data, address));
498         
499 end:
500         acpi_ec_leave_burst_mode(ec);
501         up(&ec->burst.sem);
502
503         if (ec->common.global_lock)
504                 acpi_release_global_lock(glk);
505
506         if(atomic_read(&ec->burst.leaving_burst) == 2){
507                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,"aborted, retry ...\n"));
508                 while(atomic_read(&ec->burst.pending_gpe)){
509                         msleep(1);      
510                 }
511                 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
512                 goto retry;
513         }
514
515         return_VALUE(status);
516 }
517
518
519 static int
520 acpi_ec_burst_write (
521         union acpi_ec           *ec,
522         u8                      address,
523         u8                      data)
524 {
525         int                     status = 0;
526         u32                     glk;
527         u32                     tmp;
528
529         ACPI_FUNCTION_TRACE("acpi_ec_write");
530
531         if (!ec)
532                 return_VALUE(-EINVAL);
533 retry:
534         if (ec->common.global_lock) {
535                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
536                 if (ACPI_FAILURE(status))
537                         return_VALUE(-ENODEV);
538         }
539
540         WARN_ON(in_interrupt());
541         down(&ec->burst.sem);
542
543         if(acpi_ec_enter_burst_mode(ec))
544                 goto end;
545
546         status = acpi_ec_read_status(ec);
547         if (status != -EINVAL &&
548                 !(status & ACPI_EC_FLAG_BURST)){
549                 acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE, &ec->common.command_addr);
550                 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
551                 if (status)
552                         goto end;
553                 acpi_hw_low_level_read(8, &tmp, &ec->common.data_addr);
554                 if(tmp != 0x90 ) /* Burst ACK byte*/
555                         goto end;
556         }
557         /*Now we are in burst mode*/
558
559         acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE, &ec->common.command_addr);
560         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
561         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
562         if (status){
563                 goto end;
564         }
565
566         acpi_hw_low_level_write(8, address, &ec->common.data_addr);
567         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
568         if (status){
569                 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
570                 goto end;
571         }
572
573         acpi_hw_low_level_write(8, data, &ec->common.data_addr);
574         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
575         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
576         if (status)
577                 goto end;
578
579         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
580                 data, address));
581
582 end:
583         acpi_ec_leave_burst_mode(ec);
584         up(&ec->burst.sem);
585
586         if (ec->common.global_lock)
587                 acpi_release_global_lock(glk);
588
589         if(atomic_read(&ec->burst.leaving_burst) == 2){
590                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,"aborted, retry ...\n"));
591                 while(atomic_read(&ec->burst.pending_gpe)){
592                         msleep(1);      
593                 }
594                 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
595                 goto retry;
596         }
597
598         return_VALUE(status);
599 }
600
601 /*
602  * Externally callable EC access functions. For now, assume 1 EC only
603  */
604 int
605 ec_read(u8 addr, u8 *val)
606 {
607         union acpi_ec *ec;
608         int err;
609         u32 temp_data;
610
611         if (!first_ec)
612                 return -ENODEV;
613
614         ec = acpi_driver_data(first_ec);
615
616         err = acpi_ec_read(ec, addr, &temp_data);
617
618         if (!err) {
619                 *val = temp_data;
620                 return 0;
621         }
622         else
623                 return err;
624 }
625 EXPORT_SYMBOL(ec_read);
626
627 int
628 ec_write(u8 addr, u8 val)
629 {
630         union acpi_ec *ec;
631         int err;
632
633         if (!first_ec)
634                 return -ENODEV;
635
636         ec = acpi_driver_data(first_ec);
637
638         err = acpi_ec_write(ec, addr, val);
639
640         return err;
641 }
642 EXPORT_SYMBOL(ec_write);
643
644 static int
645 acpi_ec_query (
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 }
654 static int
655 acpi_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
693 end:
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 }
701 static int
702 acpi_ec_burst_query (
703         union acpi_ec           *ec,
704         u32                     *data)
705 {
706         int                     status = 0;
707         u32                     glk;
708
709         ACPI_FUNCTION_TRACE("acpi_ec_query");
710
711         if (!ec || !data)
712                 return_VALUE(-EINVAL);
713         *data = 0;
714
715         if (ec->common.global_lock) {
716                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
717                 if (ACPI_FAILURE(status))
718                         return_VALUE(-ENODEV);
719         }
720
721         down(&ec->burst.sem);
722         if(acpi_ec_enter_burst_mode(ec))
723                 goto end;
724         /*
725          * Query the EC to find out which _Qxx method we need to evaluate.
726          * Note that successful completion of the query causes the ACPI_EC_SCI
727          * bit to be cleared (and thus clearing the interrupt source).
728          */
729         acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY, &ec->common.command_addr);
730         status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
731         if (status){
732                 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
733                 goto end;
734         }
735
736         acpi_hw_low_level_read(8, data, &ec->common.data_addr);
737         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
738         if (!*data)
739                 status = -ENODATA;
740
741 end:
742         acpi_ec_leave_burst_mode(ec);
743         up(&ec->burst.sem);
744
745         if (ec->common.global_lock)
746                 acpi_release_global_lock(glk);
747
748         if(atomic_read(&ec->burst.leaving_burst) == 2){
749                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,"aborted, retry ...\n"));
750                 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
751                 status = -ENODATA;
752         }
753         return_VALUE(status);
754 }
755
756
757 /* --------------------------------------------------------------------------
758                                 Event Management
759    -------------------------------------------------------------------------- */
760
761 union acpi_ec_query_data {
762         acpi_handle             handle;
763         u8                      data;
764 };
765
766 static void
767 acpi_ec_gpe_query (
768         void                    *ec_cxt)
769 {
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
776 static void
777 acpi_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
815 end:    
816         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
817 }
818 static void
819 acpi_ec_gpe_burst_query (
820         void                    *ec_cxt)
821 {
822         union acpi_ec           *ec = (union acpi_ec *) ec_cxt;
823         u32                     value;
824         int                     result = -ENODATA;
825         static char             object_name[5] = {'_','Q','0','0','\0'};
826         const char              hex[] = {'0','1','2','3','4','5','6','7',
827                                          '8','9','A','B','C','D','E','F'};
828
829         ACPI_FUNCTION_TRACE("acpi_ec_gpe_query");
830
831         if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_SCI)
832                 result = acpi_ec_query(ec, &value);
833
834         if (result)
835                 goto end;
836
837         object_name[2] = hex[((value >> 4) & 0x0F)];
838         object_name[3] = hex[(value & 0x0F)];
839
840         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name));
841
842         acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
843 end:    
844         atomic_dec(&ec->burst.pending_gpe);
845         return;
846 }
847
848 static u32
849 acpi_ec_gpe_handler (
850         void                    *data)
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 }
857 static u32
858 acpi_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 }
877 static u32
878 acpi_ec_gpe_burst_handler (
879         void                    *data)
880 {
881         acpi_status             status = AE_OK;
882         u32                     value;
883         union acpi_ec           *ec = (union acpi_ec *) data;
884
885         if (!ec)
886                 return ACPI_INTERRUPT_NOT_HANDLED;
887
888         acpi_disable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
889
890         value = acpi_ec_read_status(ec);
891
892         if((value & ACPI_EC_FLAG_IBF) &&
893                 !(value & ACPI_EC_FLAG_BURST) &&
894                         (atomic_read(&ec->burst.leaving_burst) == 0)) { 
895         /*
896          * the embedded controller disables 
897          * burst mode for any reason other 
898          * than the burst disable command
899          * to process critical event.
900          */
901                 atomic_set(&ec->burst.leaving_burst , 2); /* block current pending transaction
902                                         and retry */
903                 wake_up(&ec->burst.wait);
904         }else {
905                 if ((ec->burst.expect_event == ACPI_EC_EVENT_OBF &&
906                                 (value & ACPI_EC_FLAG_OBF)) ||
907                                 (ec->burst.expect_event == ACPI_EC_EVENT_IBE &&
908                                 !(value & ACPI_EC_FLAG_IBF))) {
909                         ec->burst.expect_event = 0;
910                         wake_up(&ec->burst.wait);
911                         return ACPI_INTERRUPT_HANDLED;
912                 }
913         }
914
915         if (value & ACPI_EC_FLAG_SCI){
916                 atomic_add(1, &ec->burst.pending_gpe) ;
917                 status = acpi_os_queue_for_execution(OSD_PRIORITY_GPE,
918                                                 acpi_ec_gpe_query, ec);
919                 return status == AE_OK ?
920                 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
921         } 
922         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
923         return status == AE_OK ?
924                 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
925 }
926
927 /* --------------------------------------------------------------------------
928                              Address Space Management
929    -------------------------------------------------------------------------- */
930
931 static acpi_status
932 acpi_ec_space_setup (
933         acpi_handle             region_handle,
934         u32                     function,
935         void                    *handler_context,
936         void                    **return_context)
937 {
938         /*
939          * The EC object is in the handler context and is needed
940          * when calling the acpi_ec_space_handler.
941          */
942         *return_context  = (function != ACPI_REGION_DEACTIVATE) ?
943                                                 handler_context : NULL;
944
945         return AE_OK;
946 }
947
948
949 static acpi_status
950 acpi_ec_space_handler (
951         u32                     function,
952         acpi_physical_address   address,
953         u32                     bit_width,
954         acpi_integer            *value,
955         void                    *handler_context,
956         void                    *region_context)
957 {
958         int                     result = 0;
959         union acpi_ec           *ec = NULL;
960         u64                     temp = *value;
961         acpi_integer            f_v = 0;
962         int                     i = 0;
963
964         ACPI_FUNCTION_TRACE("acpi_ec_space_handler");
965
966         if ((address > 0xFF) || !value || !handler_context)
967                 return_VALUE(AE_BAD_PARAMETER);
968
969         if (bit_width != 8 && acpi_strict) {
970                 printk(KERN_WARNING PREFIX "acpi_ec_space_handler: bit_width should be 8\n");
971                 return_VALUE(AE_BAD_PARAMETER);
972         }
973
974         ec = (union acpi_ec *) handler_context;
975
976 next_byte:
977         switch (function) {
978         case ACPI_READ:
979                 temp = 0;
980                 result = acpi_ec_read(ec, (u8) address, (u32 *)&temp);
981                 break;
982         case ACPI_WRITE:
983                 result = acpi_ec_write(ec, (u8) address, (u8) temp);
984                 break;
985         default:
986                 result = -EINVAL;
987                 goto out;
988                 break;
989         }
990
991         bit_width -= 8;
992         if (bit_width) {
993                 if (function == ACPI_READ)
994                         f_v |= temp << 8 * i;
995                 if (function == ACPI_WRITE)
996                         temp >>= 8;
997                 i++;
998                 address++;
999                 goto next_byte;
1000         }
1001
1002         if (function == ACPI_READ) {
1003                 f_v |= temp << 8 * i;
1004                 *value = f_v;
1005         }
1006
1007                 
1008 out:
1009         switch (result) {
1010         case -EINVAL:
1011                 return_VALUE(AE_BAD_PARAMETER);
1012                 break;
1013         case -ENODEV:
1014                 return_VALUE(AE_NOT_FOUND);
1015                 break;
1016         case -ETIME:
1017                 return_VALUE(AE_TIME);
1018                 break;
1019         default:
1020                 return_VALUE(AE_OK);
1021         }
1022 }
1023
1024
1025 /* --------------------------------------------------------------------------
1026                               FS Interface (/proc)
1027    -------------------------------------------------------------------------- */
1028
1029 static struct proc_dir_entry    *acpi_ec_dir;
1030
1031
1032 static int
1033 acpi_ec_read_info (struct seq_file *seq, void *offset)
1034 {
1035         union acpi_ec           *ec = (union acpi_ec *) seq->private;
1036
1037         ACPI_FUNCTION_TRACE("acpi_ec_read_info");
1038
1039         if (!ec)
1040                 goto end;
1041
1042         seq_printf(seq, "gpe bit:                 0x%02x\n",
1043                 (u32) ec->common.gpe_bit);
1044         seq_printf(seq, "ports:                   0x%02x, 0x%02x\n",
1045                 (u32) ec->common.status_addr.address, (u32) ec->common.data_addr.address);
1046         seq_printf(seq, "use global lock:         %s\n",
1047                 ec->common.global_lock?"yes":"no");
1048         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
1049
1050 end:
1051         return_VALUE(0);
1052 }
1053
1054 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
1055 {
1056         return single_open(file, acpi_ec_read_info, PDE(inode)->data);
1057 }
1058
1059 static struct file_operations acpi_ec_info_ops = {
1060         .open           = acpi_ec_info_open_fs,
1061         .read           = seq_read,
1062         .llseek         = seq_lseek,
1063         .release        = single_release,
1064         .owner = THIS_MODULE,
1065 };
1066
1067 static int
1068 acpi_ec_add_fs (
1069         struct acpi_device      *device)
1070 {
1071         struct proc_dir_entry   *entry = NULL;
1072
1073         ACPI_FUNCTION_TRACE("acpi_ec_add_fs");
1074
1075         if (!acpi_device_dir(device)) {
1076                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1077                         acpi_ec_dir);
1078                 if (!acpi_device_dir(device))
1079                         return_VALUE(-ENODEV);
1080         }
1081
1082         entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
1083                 acpi_device_dir(device));
1084         if (!entry)
1085                 ACPI_DEBUG_PRINT((ACPI_DB_WARN,
1086                         "Unable to create '%s' fs entry\n",
1087                         ACPI_EC_FILE_INFO));
1088         else {
1089                 entry->proc_fops = &acpi_ec_info_ops;
1090                 entry->data = acpi_driver_data(device);
1091                 entry->owner = THIS_MODULE;
1092         }
1093
1094         return_VALUE(0);
1095 }
1096
1097
1098 static int
1099 acpi_ec_remove_fs (
1100         struct acpi_device      *device)
1101 {
1102         ACPI_FUNCTION_TRACE("acpi_ec_remove_fs");
1103
1104         if (acpi_device_dir(device)) {
1105                 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
1106                 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir);
1107                 acpi_device_dir(device) = NULL;
1108         }
1109
1110         return_VALUE(0);
1111 }
1112
1113
1114 /* --------------------------------------------------------------------------
1115                                Driver Interface
1116    -------------------------------------------------------------------------- */
1117
1118
1119 static int
1120 acpi_ec_polling_add (
1121         struct acpi_device      *device)
1122 {
1123         int                     result = 0;
1124         acpi_status             status = AE_OK;
1125         union acpi_ec           *ec = NULL;
1126         unsigned long           uid;
1127
1128         ACPI_FUNCTION_TRACE("acpi_ec_add");
1129
1130         if (!device)
1131                 return_VALUE(-EINVAL);
1132
1133         ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1134         if (!ec)
1135                 return_VALUE(-ENOMEM);
1136         memset(ec, 0, sizeof(union acpi_ec));
1137
1138         ec->common.handle = device->handle;
1139         ec->common.uid = -1;
1140         spin_lock_init(&ec->polling.lock);
1141         strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1142         strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1143         acpi_driver_data(device) = ec;
1144
1145         /* Use the global lock for all EC transactions? */
1146         acpi_evaluate_integer(ec->common.handle, "_GLK", NULL, &ec->common.global_lock);
1147
1148         /* If our UID matches the UID for the ECDT-enumerated EC,
1149            we now have the *real* EC info, so kill the makeshift one.*/
1150         acpi_evaluate_integer(ec->common.handle, "_UID", NULL, &uid);
1151         if (ec_ecdt && ec_ecdt->common.uid == uid) {
1152                 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
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         }
1169
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
1181 end:
1182         if (result)
1183                 kfree(ec);
1184
1185         return_VALUE(result);
1186 }
1187 static int
1188 acpi_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);
1227
1228                 kfree(ec_ecdt);
1229         }
1230
1231         /* Get GPE bit assignment (EC events). */
1232         /* TODO: Add support for _GPE returning a package */
1233         status = acpi_evaluate_integer(ec->common.handle, "_GPE", NULL, &ec->common.gpe_bit);
1234         if (ACPI_FAILURE(status)) {
1235                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1236                         "Error obtaining GPE bit assignment\n"));
1237                 result = -ENODEV;
1238                 goto end;
1239         }
1240
1241         result = acpi_ec_add_fs(device);
1242         if (result)
1243                 goto end;
1244
1245         printk(KERN_INFO PREFIX "%s [%s] (gpe %d)\n",
1246                 acpi_device_name(device), acpi_device_bid(device),
1247                 (u32) ec->common.gpe_bit);
1248
1249         if (!first_ec)
1250                 first_ec = device;
1251
1252 end:
1253         if (result)
1254                 kfree(ec);
1255
1256         return_VALUE(result);
1257 }
1258
1259
1260 static int
1261 acpi_ec_remove (
1262         struct acpi_device      *device,
1263         int                     type)
1264 {
1265         union acpi_ec           *ec = NULL;
1266
1267         ACPI_FUNCTION_TRACE("acpi_ec_remove");
1268
1269         if (!device)
1270                 return_VALUE(-EINVAL);
1271
1272         ec = acpi_driver_data(device);
1273
1274         acpi_ec_remove_fs(device);
1275
1276         kfree(ec);
1277
1278         return_VALUE(0);
1279 }
1280
1281
1282 static acpi_status
1283 acpi_ec_io_ports (
1284         struct acpi_resource    *resource,
1285         void                    *context)
1286 {
1287         union acpi_ec           *ec = (union acpi_ec *) context;
1288         struct acpi_generic_address *addr;
1289
1290         if (resource->id != ACPI_RSTYPE_IO) {
1291                 return AE_OK;
1292         }
1293
1294         /*
1295          * The first address region returned is the data port, and
1296          * the second address region returned is the status/command
1297          * port.
1298          */
1299         if (ec->common.data_addr.register_bit_width == 0) {
1300                 addr = &ec->common.data_addr;
1301         } else if (ec->common.command_addr.register_bit_width == 0) {
1302                 addr = &ec->common.command_addr;
1303         } else {
1304                 return AE_CTRL_TERMINATE;
1305         }
1306
1307         addr->address_space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1308         addr->register_bit_width = 8;
1309         addr->register_bit_offset = 0;
1310         addr->address = resource->data.io.min_base_address;
1311
1312         return AE_OK;
1313 }
1314
1315
1316 static int
1317 acpi_ec_start (
1318         struct acpi_device      *device)
1319 {
1320         acpi_status             status = AE_OK;
1321         union acpi_ec           *ec = NULL;
1322
1323         ACPI_FUNCTION_TRACE("acpi_ec_start");
1324
1325         if (!device)
1326                 return_VALUE(-EINVAL);
1327
1328         ec = acpi_driver_data(device);
1329
1330         if (!ec)
1331                 return_VALUE(-EINVAL);
1332
1333         /*
1334          * Get I/O port addresses. Convert to GAS format.
1335          */
1336         status = acpi_walk_resources(ec->common.handle, METHOD_NAME__CRS,
1337                 acpi_ec_io_ports, ec);
1338         if (ACPI_FAILURE(status) || ec->common.command_addr.register_bit_width == 0) {
1339                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error getting I/O port addresses"));
1340                 return_VALUE(-ENODEV);
1341         }
1342
1343         ec->common.status_addr = ec->common.command_addr;
1344
1345         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n",
1346                 (u32) ec->common.gpe_bit, (u32) ec->common.command_addr.address,
1347                 (u32) ec->common.data_addr.address));
1348
1349
1350         /*
1351          * Install GPE handler
1352          */
1353         status = acpi_install_gpe_handler(NULL, ec->common.gpe_bit,
1354                 ACPI_GPE_EDGE_TRIGGERED, &acpi_ec_gpe_handler, ec);
1355         if (ACPI_FAILURE(status)) {
1356                 return_VALUE(-ENODEV);
1357         }
1358         acpi_set_gpe_type (NULL, ec->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1359         acpi_enable_gpe (NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
1360
1361         status = acpi_install_address_space_handler (ec->common.handle,
1362                         ACPI_ADR_SPACE_EC, &acpi_ec_space_handler,
1363                         &acpi_ec_space_setup, ec);
1364         if (ACPI_FAILURE(status)) {
1365                 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit, &acpi_ec_gpe_handler);
1366                 return_VALUE(-ENODEV);
1367         }
1368
1369         return_VALUE(AE_OK);
1370 }
1371
1372
1373 static int
1374 acpi_ec_stop (
1375         struct acpi_device      *device,
1376         int                     type)
1377 {
1378         acpi_status             status = AE_OK;
1379         union acpi_ec           *ec = NULL;
1380
1381         ACPI_FUNCTION_TRACE("acpi_ec_stop");
1382
1383         if (!device)
1384                 return_VALUE(-EINVAL);
1385
1386         ec = acpi_driver_data(device);
1387
1388         status = acpi_remove_address_space_handler(ec->common.handle,
1389                 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler);
1390         if (ACPI_FAILURE(status))
1391                 return_VALUE(-ENODEV);
1392
1393         status = acpi_remove_gpe_handler(NULL, ec->common.gpe_bit, &acpi_ec_gpe_handler);
1394         if (ACPI_FAILURE(status))
1395                 return_VALUE(-ENODEV);
1396
1397         return_VALUE(0);
1398 }
1399
1400 static acpi_status __init
1401 acpi_fake_ecdt_callback (
1402         acpi_handle     handle,
1403         u32             Level,
1404         void            *context,
1405         void            **retval)
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
1416 static acpi_status __init
1417 acpi_fake_ecdt_polling_callback (
1418         acpi_handle     handle,
1419         u32             Level,
1420         void            *context,
1421         void            **retval)
1422 {
1423         acpi_status     status;
1424
1425         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1426                 acpi_ec_io_ports, ec_ecdt);
1427         if (ACPI_FAILURE(status))
1428                 return status;
1429         ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
1430
1431         ec_ecdt->common.uid = -1;
1432         acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
1433
1434         status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec_ecdt->common.gpe_bit);
1435         if (ACPI_FAILURE(status))
1436                 return status;
1437         spin_lock_init(&ec_ecdt->polling.lock);
1438         ec_ecdt->common.global_lock = TRUE;
1439         ec_ecdt->common.handle = handle;
1440
1441         printk(KERN_INFO PREFIX  "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1442                 (u32) ec_ecdt->common.gpe_bit, (u32) ec_ecdt->common.command_addr.address,
1443                 (u32) ec_ecdt->common.data_addr.address);
1444
1445         return AE_CTRL_TERMINATE;
1446 }
1447
1448 static acpi_status __init
1449 acpi_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);
1477
1478         return AE_CTRL_TERMINATE;
1479 }
1480
1481 /*
1482  * Some BIOS (such as some from Gateway laptops) access EC region very early
1483  * such as in BAT0._INI or EC._INI before an EC device is found and
1484  * do not provide an ECDT. According to ACPI spec, ECDT isn't mandatorily
1485  * required, but if EC regison is accessed early, it is required.
1486  * The routine tries to workaround the BIOS bug by pre-scan EC device
1487  * It assumes that _CRS, _HID, _GPE, _UID methods of EC don't touch any
1488  * op region (since _REG isn't invoked yet). The assumption is true for
1489  * all systems found.
1490  */
1491 static int __init
1492 acpi_ec_fake_ecdt(void)
1493 {
1494         acpi_status     status;
1495         int             ret = 0;
1496
1497         printk(KERN_INFO PREFIX "Try to make an fake ECDT\n");
1498
1499         ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1500         if (!ec_ecdt) {
1501                 ret = -ENOMEM;
1502                 goto error;
1503         }
1504         memset(ec_ecdt, 0, sizeof(union acpi_ec));
1505
1506         status = acpi_get_devices (ACPI_EC_HID,
1507                                 acpi_fake_ecdt_callback,
1508                                 NULL,
1509                                 NULL);
1510         if (ACPI_FAILURE(status)) {
1511                 kfree(ec_ecdt);
1512                 ec_ecdt = NULL;
1513                 ret = -ENODEV;
1514                 goto error;
1515         }
1516         return 0;
1517 error:
1518         printk(KERN_ERR PREFIX "Can't make an fake ECDT\n");
1519         return ret;
1520 }
1521
1522 static int __init
1523 acpi_ec_get_real_ecdt(void)
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
1531 static int __init
1532 acpi_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;
1567 error:
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
1576 static int __init
1577 acpi_ec_burst_get_real_ecdt(void)
1578 {
1579         acpi_status             status;
1580         struct acpi_table_ecdt  *ecdt_ptr;
1581
1582         status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
1583                 (struct acpi_table_header **) &ecdt_ptr);
1584         if (ACPI_FAILURE(status))
1585                 return -ENODEV;
1586
1587         printk(KERN_INFO PREFIX "Found ECDT\n");
1588
1589         /*
1590          * Generate a temporary ec context to use until the namespace is scanned
1591          */
1592         ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1593         if (!ec_ecdt)
1594                 return -ENOMEM;
1595         memset(ec_ecdt, 0, sizeof(union acpi_ec));
1596
1597         init_MUTEX(&ec_ecdt->burst.sem);
1598         init_waitqueue_head(&ec_ecdt->burst.wait);
1599         ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1600         ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1601         ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1602         ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
1603         /* use the GL just to be safe */
1604         ec_ecdt->common.global_lock = TRUE;
1605         ec_ecdt->common.uid = ecdt_ptr->uid;
1606
1607         status = acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
1608         if (ACPI_FAILURE(status)) {
1609                 goto error;
1610         }
1611
1612         return 0;
1613 error:
1614         printk(KERN_ERR PREFIX "Could not use ECDT\n");
1615         kfree(ec_ecdt);
1616         ec_ecdt = NULL;
1617
1618         return -ENODEV;
1619 }
1620
1621 static int __initdata acpi_fake_ecdt_enabled;
1622 int __init
1623 acpi_ec_ecdt_probe (void)
1624 {
1625         acpi_status             status;
1626         int                     ret;
1627
1628         ret = acpi_ec_get_real_ecdt();
1629         /* Try to make a fake ECDT */
1630         if (ret && acpi_fake_ecdt_enabled) {
1631                 ret = acpi_ec_fake_ecdt();
1632         }
1633
1634         if (ret)
1635                 return 0;
1636
1637         /*
1638          * Install GPE handler
1639          */
1640         status = acpi_install_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1641                 ACPI_GPE_EDGE_TRIGGERED, &acpi_ec_gpe_handler,
1642                 ec_ecdt);
1643         if (ACPI_FAILURE(status)) {
1644                 goto error;
1645         }
1646         acpi_set_gpe_type (NULL, ec_ecdt->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1647         acpi_enable_gpe (NULL, ec_ecdt->common.gpe_bit, ACPI_NOT_ISR);
1648
1649         status = acpi_install_address_space_handler (ACPI_ROOT_OBJECT,
1650                         ACPI_ADR_SPACE_EC, &acpi_ec_space_handler,
1651                         &acpi_ec_space_setup, ec_ecdt);
1652         if (ACPI_FAILURE(status)) {
1653                 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1654                         &acpi_ec_gpe_handler);
1655                 goto error;
1656         }
1657
1658         return 0;
1659
1660 error:
1661         printk(KERN_ERR PREFIX "Could not use ECDT\n");
1662         kfree(ec_ecdt);
1663         ec_ecdt = NULL;
1664
1665         return -ENODEV;
1666 }
1667
1668
1669 static int __init acpi_ec_init (void)
1670 {
1671         int                     result = 0;
1672
1673         ACPI_FUNCTION_TRACE("acpi_ec_init");
1674
1675         if (acpi_disabled)
1676                 return_VALUE(0);
1677
1678         acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
1679         if (!acpi_ec_dir)
1680                 return_VALUE(-ENODEV);
1681
1682         /* Now register the driver for the EC */
1683         result = acpi_bus_register_driver(&acpi_ec_driver);
1684         if (result < 0) {
1685                 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1686                 return_VALUE(-ENODEV);
1687         }
1688
1689         return_VALUE(result);
1690 }
1691
1692 subsys_initcall(acpi_ec_init);
1693
1694 /* EC driver currently not unloadable */
1695 #if 0
1696 static void __exit
1697 acpi_ec_exit (void)
1698 {
1699         ACPI_FUNCTION_TRACE("acpi_ec_exit");
1700
1701         acpi_bus_unregister_driver(&acpi_ec_driver);
1702
1703         remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1704
1705         return_VOID;
1706 }
1707 #endif /* 0 */
1708
1709 static int __init acpi_fake_ecdt_setup(char *str)
1710 {
1711         acpi_fake_ecdt_enabled = 1;
1712         return 0;
1713 }
1714
1715 __setup("acpi_fake_ecdt", acpi_fake_ecdt_setup);
1716 static 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);