]> pilppa.org Git - linux-2.6-omap-h63xx.git/blob - drivers/acpi/ec.c
Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux...
[linux-2.6-omap-h63xx.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 #define ACPI_EC_COMPONENT               0x00100000
43 #define ACPI_EC_CLASS                   "embedded_controller"
44 #define ACPI_EC_HID                     "PNP0C09"
45 #define ACPI_EC_DRIVER_NAME             "ACPI Embedded Controller Driver"
46 #define ACPI_EC_DEVICE_NAME             "Embedded Controller"
47 #define ACPI_EC_FILE_INFO               "info"
48
49 /* EC status register */
50 #define ACPI_EC_FLAG_OBF        0x01    /* Output buffer full */
51 #define ACPI_EC_FLAG_IBF        0x02    /* Input buffer full */
52 #define ACPI_EC_FLAG_BURST      0x10    /* burst mode */
53 #define ACPI_EC_FLAG_SCI        0x20    /* EC-SCI occurred */
54
55 /* EC commands */
56 #define ACPI_EC_COMMAND_READ    0x80
57 #define ACPI_EC_COMMAND_WRITE   0x81
58 #define ACPI_EC_BURST_ENABLE    0x82
59 #define ACPI_EC_BURST_DISABLE   0x83
60 #define ACPI_EC_COMMAND_QUERY   0x84
61
62 /* EC events */
63 enum {
64         ACPI_EC_EVENT_OBF_1 = 1,        /* Output buffer full */
65         ACPI_EC_EVENT_IBF_0,            /* Input buffer empty */
66 };
67
68 #define ACPI_EC_DELAY           50      /* Wait 50ms max. during EC ops */
69 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
70 #define ACPI_EC_UDELAY         100      /* Poll @ 100us increments */
71 #define ACPI_EC_UDELAY_COUNT   1000     /* Wait 10ms max. during EC ops */
72
73 enum {
74         EC_INTR = 1,    /* Output buffer full */
75         EC_POLL,        /* Input buffer empty */
76 };
77
78 static int acpi_ec_remove(struct acpi_device *device, int type);
79 static int acpi_ec_start(struct acpi_device *device);
80 static int acpi_ec_stop(struct acpi_device *device, int type);
81 static int acpi_ec_add(struct acpi_device *device);
82
83 static struct acpi_driver acpi_ec_driver = {
84         .name = ACPI_EC_DRIVER_NAME,
85         .class = ACPI_EC_CLASS,
86         .ids = ACPI_EC_HID,
87         .ops = {
88                 .add = acpi_ec_add,
89                 .remove = acpi_ec_remove,
90                 .start = acpi_ec_start,
91                 .stop = acpi_ec_stop,
92                 },
93 };
94
95 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
96 struct acpi_ec {
97         acpi_handle handle;
98         unsigned long uid;
99         unsigned long gpe_bit;
100         unsigned long command_addr;
101         unsigned long data_addr;
102         unsigned long global_lock;
103         struct semaphore sem;
104         unsigned int expect_event;
105         atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort */
106         wait_queue_head_t wait;
107 } *ec_ecdt;
108
109 /* External interfaces use first EC only, so remember */
110 static struct acpi_device *first_ec;
111 static int acpi_ec_mode = EC_INTR;
112
113 /* --------------------------------------------------------------------------
114                              Transaction Management
115    -------------------------------------------------------------------------- */
116
117 static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
118 {
119         return inb(ec->command_addr);
120 }
121
122 static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
123 {
124         return inb(ec->data_addr);
125 }
126
127 static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
128 {
129         outb(command, ec->command_addr);
130 }
131
132 static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
133 {
134         outb(data, ec->data_addr);
135 }
136
137 static int acpi_ec_check_status(u8 status, u8 event)
138 {
139         switch (event) {
140         case ACPI_EC_EVENT_OBF_1:
141                 if (status & ACPI_EC_FLAG_OBF)
142                         return 1;
143                 break;
144         case ACPI_EC_EVENT_IBF_0:
145                 if (!(status & ACPI_EC_FLAG_IBF))
146                         return 1;
147                 break;
148         default:
149                 break;
150         }
151
152         return 0;
153 }
154
155 static int acpi_ec_wait(struct acpi_ec *ec, u8 event)
156 {
157         int i = (acpi_ec_mode == EC_POLL) ? ACPI_EC_UDELAY_COUNT : 0;
158         long time_left;
159
160         ec->expect_event = event;
161         if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
162                 ec->expect_event = 0;
163                 return 0;
164         }
165
166         do {
167                 if (acpi_ec_mode == EC_POLL) {
168                         udelay(ACPI_EC_UDELAY);
169                 } else {
170                         time_left = wait_event_timeout(ec->wait,
171                                     !ec->expect_event,
172                                     msecs_to_jiffies(ACPI_EC_DELAY));
173                         if (time_left > 0) {
174                                 ec->expect_event = 0;
175                                 return 0;
176                         }
177                 }
178                 if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
179                         ec->expect_event = 0;
180                         return 0;
181                 }
182         } while (--i > 0);
183
184         ec->expect_event = 0;
185
186         return -ETIME;
187 }
188
189 #ifdef ACPI_FUTURE_USAGE
190 /*
191  * Note: samsung nv5000 doesn't work with ec burst mode.
192  * http://bugzilla.kernel.org/show_bug.cgi?id=4980
193  */
194 int acpi_ec_enter_burst_mode(struct acpi_ec *ec)
195 {
196         u8 tmp = 0;
197         u8 status = 0;
198
199
200         status = acpi_ec_read_status(ec);
201         if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) {
202                 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
203                 if (status)
204                         goto end;
205                 acpi_ec_write_cmd(ec, ACPI_EC_BURST_ENABLE);
206                 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1);
207                 tmp = acpi_ec_read_data(ec);
208                 if (tmp != 0x90) {      /* Burst ACK byte */
209                         return -EINVAL;
210                 }
211         }
212
213         atomic_set(&ec->leaving_burst, 0);
214         return 0;
215   end:
216         ACPI_EXCEPTION((AE_INFO, status, "EC wait, burst mode"));
217         return -1;
218 }
219
220 int acpi_ec_leave_burst_mode(struct acpi_ec *ec)
221 {
222         u8 status = 0;
223
224
225         status = acpi_ec_read_status(ec);
226         if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){
227                 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
228                 if(status)
229                         goto end;
230                 acpi_ec_write_cmd(ec, ACPI_EC_BURST_DISABLE);
231                 acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
232         }
233         atomic_set(&ec->leaving_burst, 1);
234         return 0;
235   end:
236         ACPI_EXCEPTION((AE_INFO, status, "EC leave burst mode"));
237         return -1;
238 }
239 #endif /* ACPI_FUTURE_USAGE */
240
241 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, u8 command,
242                                         const u8 *wdata, unsigned wdata_len,
243                                         u8 *rdata, unsigned rdata_len)
244 {
245         int result;
246
247         acpi_ec_write_cmd(ec, command);
248
249         for (; wdata_len > 0; wdata_len --) {
250                 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
251                 if (result)
252                         return result;
253                 acpi_ec_write_data(ec, *(wdata++));
254         }
255
256         if (command == ACPI_EC_COMMAND_WRITE) {
257                 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
258                 if (result)
259                         return result;
260         }
261
262         for (; rdata_len > 0; rdata_len --) {
263                 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1);
264                 if (result)
265                         return result;
266
267                 *(rdata++) = acpi_ec_read_data(ec);
268         }
269
270         return 0;
271 }
272
273 static int acpi_ec_transaction(struct acpi_ec *ec, u8 command,
274                                 const u8 *wdata, unsigned wdata_len,
275                                 u8 *rdata, unsigned rdata_len)
276 {
277         int status;
278         u32 glk;
279
280         if (!ec || (wdata_len && !wdata) || (rdata_len && !rdata))
281                 return -EINVAL;
282
283         if (rdata)
284                 memset(rdata, 0, rdata_len);
285
286         if (ec->global_lock) {
287                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
288                 if (ACPI_FAILURE(status))
289                         return -ENODEV;
290         }
291         down(&ec->sem);
292
293         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
294         if (status) {
295                 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
296                 goto end;
297         }
298
299         status = acpi_ec_transaction_unlocked(ec, command,
300                                               wdata, wdata_len,
301                                               rdata, rdata_len);
302
303 end:
304         up(&ec->sem);
305
306         if (ec->global_lock)
307                 acpi_release_global_lock(glk);
308
309         return status;
310 }
311
312 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
313 {
314         int result;
315         u8 d;
316
317         result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_READ,
318                                      &address, 1, &d, 1);
319         *data = d;
320         return result;
321 }
322
323 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
324 {
325         u8 wdata[2] = { address, data };
326         return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE,
327                                    wdata, 2, NULL, 0);
328 }
329
330 /*
331  * Externally callable EC access functions. For now, assume 1 EC only
332  */
333 int ec_read(u8 addr, u8 *val)
334 {
335         struct acpi_ec *ec;
336         int err;
337         u8 temp_data;
338
339         if (!first_ec)
340                 return -ENODEV;
341
342         ec = acpi_driver_data(first_ec);
343
344         err = acpi_ec_read(ec, addr, &temp_data);
345
346         if (!err) {
347                 *val = temp_data;
348                 return 0;
349         } else
350                 return err;
351 }
352
353 EXPORT_SYMBOL(ec_read);
354
355 int ec_write(u8 addr, u8 val)
356 {
357         struct acpi_ec *ec;
358         int err;
359
360         if (!first_ec)
361                 return -ENODEV;
362
363         ec = acpi_driver_data(first_ec);
364
365         err = acpi_ec_write(ec, addr, val);
366
367         return err;
368 }
369
370 EXPORT_SYMBOL(ec_write);
371
372 extern int ec_transaction(u8 command,
373                           const u8 *wdata, unsigned wdata_len,
374                           u8 *rdata, unsigned rdata_len)
375 {
376         struct acpi_ec *ec;
377
378         if (!first_ec)
379                 return -ENODEV;
380
381         ec = acpi_driver_data(first_ec);
382
383         return acpi_ec_transaction(ec, command, wdata,
384                                    wdata_len, rdata, rdata_len);
385 }
386
387 EXPORT_SYMBOL(ec_transaction);
388
389 static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
390 {
391         int result;
392         u8 d;
393
394         if (!ec || !data)
395                 return -EINVAL;
396
397         /*
398          * Query the EC to find out which _Qxx method we need to evaluate.
399          * Note that successful completion of the query causes the ACPI_EC_SCI
400          * bit to be cleared (and thus clearing the interrupt source).
401          */
402
403         result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1);
404         if (result)
405                 return result;
406
407         if (!d)
408                 return -ENODATA;
409
410         *data = d;
411         return 0;
412 }
413
414 /* --------------------------------------------------------------------------
415                                 Event Management
416    -------------------------------------------------------------------------- */
417
418 struct acpi_ec_query_data {
419         acpi_handle handle;
420         u8 data;
421 };
422
423 static void acpi_ec_gpe_query(void *ec_cxt)
424 {
425         struct acpi_ec *ec = (struct acpi_ec *)ec_cxt;
426         u8 value = 0;
427         static char object_name[8];
428
429         if (!ec)
430                 goto end;
431
432         value = acpi_ec_read_status(ec);
433
434         if (!(value & ACPI_EC_FLAG_SCI))
435                 goto end;
436
437         if (acpi_ec_query(ec, &value))
438                 goto end;
439
440         snprintf(object_name, 8, "_Q%2.2X", value);
441
442         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s", object_name));
443
444         acpi_evaluate_object(ec->handle, object_name, NULL, NULL);
445
446       end:
447         acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
448 }
449
450 static u32 acpi_ec_gpe_handler(void *data)
451 {
452         acpi_status status = AE_OK;
453         u8 value;
454         struct acpi_ec *ec = (struct acpi_ec *)data;
455
456         acpi_clear_gpe(NULL, ec->gpe_bit, ACPI_ISR);
457         value = acpi_ec_read_status(ec);
458
459         if (acpi_ec_mode == EC_INTR) {
460                 if (acpi_ec_check_status(value, ec->expect_event)) {
461                         ec->expect_event = 0;
462                         wake_up(&ec->wait);
463                 }
464         }
465
466         if (value & ACPI_EC_FLAG_SCI) {
467                 status = acpi_os_execute(OSL_EC_BURST_HANDLER, acpi_ec_gpe_query, ec);
468                 return status == AE_OK ?
469                     ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
470         }
471         acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_ISR);
472         return status == AE_OK ?
473             ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
474 }
475
476 /* --------------------------------------------------------------------------
477                              Address Space Management
478    -------------------------------------------------------------------------- */
479
480 static acpi_status
481 acpi_ec_space_setup(acpi_handle region_handle,
482                     u32 function, void *handler_context, void **return_context)
483 {
484         /*
485          * The EC object is in the handler context and is needed
486          * when calling the acpi_ec_space_handler.
487          */
488         *return_context = (function != ACPI_REGION_DEACTIVATE) ?
489             handler_context : NULL;
490
491         return AE_OK;
492 }
493
494 static acpi_status
495 acpi_ec_space_handler(u32 function,
496                       acpi_physical_address address,
497                       u32 bit_width,
498                       acpi_integer * value,
499                       void *handler_context, void *region_context)
500 {
501         int result = 0;
502         struct acpi_ec *ec = NULL;
503         u64 temp = *value;
504         acpi_integer f_v = 0;
505         int i = 0;
506
507
508         if ((address > 0xFF) || !value || !handler_context)
509                 return AE_BAD_PARAMETER;
510
511         if (bit_width != 8 && acpi_strict) {
512                 return AE_BAD_PARAMETER;
513         }
514
515         ec = (struct acpi_ec *)handler_context;
516
517       next_byte:
518         switch (function) {
519         case ACPI_READ:
520                 temp = 0;
521                 result = acpi_ec_read(ec, (u8) address, (u8 *) &temp);
522                 break;
523         case ACPI_WRITE:
524                 result = acpi_ec_write(ec, (u8) address, (u8) temp);
525                 break;
526         default:
527                 result = -EINVAL;
528                 goto out;
529                 break;
530         }
531
532         bit_width -= 8;
533         if (bit_width) {
534                 if (function == ACPI_READ)
535                         f_v |= temp << 8 * i;
536                 if (function == ACPI_WRITE)
537                         temp >>= 8;
538                 i++;
539                 address++;
540                 goto next_byte;
541         }
542
543         if (function == ACPI_READ) {
544                 f_v |= temp << 8 * i;
545                 *value = f_v;
546         }
547
548       out:
549         switch (result) {
550         case -EINVAL:
551                 return AE_BAD_PARAMETER;
552                 break;
553         case -ENODEV:
554                 return AE_NOT_FOUND;
555                 break;
556         case -ETIME:
557                 return AE_TIME;
558                 break;
559         default:
560                 return AE_OK;
561         }
562 }
563
564 /* --------------------------------------------------------------------------
565                               FS Interface (/proc)
566    -------------------------------------------------------------------------- */
567
568 static struct proc_dir_entry *acpi_ec_dir;
569
570 static int acpi_ec_read_info(struct seq_file *seq, void *offset)
571 {
572         struct acpi_ec *ec = (struct acpi_ec *)seq->private;
573
574
575         if (!ec)
576                 goto end;
577
578         seq_printf(seq, "gpe bit:                 0x%02x\n",
579                    (u32) ec->gpe_bit);
580         seq_printf(seq, "ports:                   0x%02x, 0x%02x\n",
581                    (u32) ec->command_addr,
582                    (u32) ec->data_addr);
583         seq_printf(seq, "use global lock:         %s\n",
584                    ec->global_lock ? "yes" : "no");
585         acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
586
587       end:
588         return 0;
589 }
590
591 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
592 {
593         return single_open(file, acpi_ec_read_info, PDE(inode)->data);
594 }
595
596 static struct file_operations acpi_ec_info_ops = {
597         .open = acpi_ec_info_open_fs,
598         .read = seq_read,
599         .llseek = seq_lseek,
600         .release = single_release,
601         .owner = THIS_MODULE,
602 };
603
604 static int acpi_ec_add_fs(struct acpi_device *device)
605 {
606         struct proc_dir_entry *entry = NULL;
607
608
609         if (!acpi_device_dir(device)) {
610                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
611                                                      acpi_ec_dir);
612                 if (!acpi_device_dir(device))
613                         return -ENODEV;
614         }
615
616         entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
617                                   acpi_device_dir(device));
618         if (!entry)
619                 return -ENODEV;
620         else {
621                 entry->proc_fops = &acpi_ec_info_ops;
622                 entry->data = acpi_driver_data(device);
623                 entry->owner = THIS_MODULE;
624         }
625
626         return 0;
627 }
628
629 static int acpi_ec_remove_fs(struct acpi_device *device)
630 {
631
632         if (acpi_device_dir(device)) {
633                 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
634                 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir);
635                 acpi_device_dir(device) = NULL;
636         }
637
638         return 0;
639 }
640
641 /* --------------------------------------------------------------------------
642                                Driver Interface
643    -------------------------------------------------------------------------- */
644
645 static int acpi_ec_add(struct acpi_device *device)
646 {
647         int result = 0;
648         acpi_status status = AE_OK;
649         struct acpi_ec *ec = NULL;
650
651
652         if (!device)
653                 return -EINVAL;
654
655         ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
656         if (!ec)
657                 return -ENOMEM;
658         memset(ec, 0, sizeof(struct acpi_ec));
659
660         ec->handle = device->handle;
661         ec->uid = -1;
662         init_MUTEX(&ec->sem);
663         if (acpi_ec_mode == EC_INTR) {
664                 atomic_set(&ec->leaving_burst, 1);
665                 init_waitqueue_head(&ec->wait);
666         }
667         strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
668         strcpy(acpi_device_class(device), ACPI_EC_CLASS);
669         acpi_driver_data(device) = ec;
670
671         /* Use the global lock for all EC transactions? */
672         acpi_evaluate_integer(ec->handle, "_GLK", NULL,
673                               &ec->global_lock);
674
675         /* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
676            http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
677         if (ec_ecdt) {
678                 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
679                                                   ACPI_ADR_SPACE_EC,
680                                                   &acpi_ec_space_handler);
681
682                 acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
683                                         &acpi_ec_gpe_handler);
684
685                 kfree(ec_ecdt);
686         }
687
688         /* Get GPE bit assignment (EC events). */
689         /* TODO: Add support for _GPE returning a package */
690         status =
691             acpi_evaluate_integer(ec->handle, "_GPE", NULL,
692                                   &ec->gpe_bit);
693         if (ACPI_FAILURE(status)) {
694                 ACPI_EXCEPTION((AE_INFO, status, "Obtaining GPE bit assignment"));
695                 result = -ENODEV;
696                 goto end;
697         }
698
699         result = acpi_ec_add_fs(device);
700         if (result)
701                 goto end;
702
703         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s [%s] (gpe %d) interrupt mode.",
704                acpi_device_name(device), acpi_device_bid(device),
705                (u32) ec->gpe_bit));
706
707         if (!first_ec)
708                 first_ec = device;
709
710   end:
711         if (result)
712                 kfree(ec);
713
714         return result;
715 }
716
717 static int acpi_ec_remove(struct acpi_device *device, int type)
718 {
719         struct acpi_ec *ec = NULL;
720
721
722         if (!device)
723                 return -EINVAL;
724
725         ec = acpi_driver_data(device);
726
727         acpi_ec_remove_fs(device);
728
729         kfree(ec);
730
731         return 0;
732 }
733
734 static acpi_status
735 acpi_ec_io_ports(struct acpi_resource *resource, void *context)
736 {
737         struct acpi_ec *ec = (struct acpi_ec *)context;
738
739         if (resource->type != ACPI_RESOURCE_TYPE_IO) {
740                 return AE_OK;
741         }
742
743         /*
744          * The first address region returned is the data port, and
745          * the second address region returned is the status/command
746          * port.
747          */
748         if (ec->data_addr == 0) {
749                 ec->data_addr = resource->data.io.minimum;
750         } else if (ec->command_addr == 0) {
751                 ec->command_addr = resource->data.io.minimum;
752         } else {
753                 return AE_CTRL_TERMINATE;
754         }
755
756         return AE_OK;
757 }
758
759 static int acpi_ec_start(struct acpi_device *device)
760 {
761         acpi_status status = AE_OK;
762         struct acpi_ec *ec = NULL;
763
764
765         if (!device)
766                 return -EINVAL;
767
768         ec = acpi_driver_data(device);
769
770         if (!ec)
771                 return -EINVAL;
772
773         /*
774          * Get I/O port addresses. Convert to GAS format.
775          */
776         status = acpi_walk_resources(ec->handle, METHOD_NAME__CRS,
777                                      acpi_ec_io_ports, ec);
778         if (ACPI_FAILURE(status) || ec->command_addr == 0) {
779                 ACPI_EXCEPTION((AE_INFO, status,
780                                 "Error getting I/O port addresses"));
781                 return -ENODEV;
782         }
783
784         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02lx, ports=0x%2lx,0x%2lx",
785                           ec->gpe_bit, ec->command_addr, ec->data_addr));
786
787         /*
788          * Install GPE handler
789          */
790         status = acpi_install_gpe_handler(NULL, ec->gpe_bit,
791                                           ACPI_GPE_EDGE_TRIGGERED,
792                                           &acpi_ec_gpe_handler, ec);
793         if (ACPI_FAILURE(status)) {
794                 return -ENODEV;
795         }
796         acpi_set_gpe_type(NULL, ec->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
797         acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
798
799         status = acpi_install_address_space_handler(ec->handle,
800                                                     ACPI_ADR_SPACE_EC,
801                                                     &acpi_ec_space_handler,
802                                                     &acpi_ec_space_setup, ec);
803         if (ACPI_FAILURE(status)) {
804                 acpi_remove_gpe_handler(NULL, ec->gpe_bit,
805                                         &acpi_ec_gpe_handler);
806                 return -ENODEV;
807         }
808
809         return AE_OK;
810 }
811
812 static int acpi_ec_stop(struct acpi_device *device, int type)
813 {
814         acpi_status status = AE_OK;
815         struct acpi_ec *ec = NULL;
816
817
818         if (!device)
819                 return -EINVAL;
820
821         ec = acpi_driver_data(device);
822
823         status = acpi_remove_address_space_handler(ec->handle,
824                                                    ACPI_ADR_SPACE_EC,
825                                                    &acpi_ec_space_handler);
826         if (ACPI_FAILURE(status))
827                 return -ENODEV;
828
829         status =
830             acpi_remove_gpe_handler(NULL, ec->gpe_bit,
831                                     &acpi_ec_gpe_handler);
832         if (ACPI_FAILURE(status))
833                 return -ENODEV;
834
835         return 0;
836 }
837
838 static acpi_status __init
839 acpi_fake_ecdt_callback(acpi_handle handle,
840                         u32 Level, void *context, void **retval)
841 {
842         acpi_status status;
843
844         init_MUTEX(&ec_ecdt->sem);
845         if (acpi_ec_mode == EC_INTR) {
846                 init_waitqueue_head(&ec_ecdt->wait);
847         }
848         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
849                                      acpi_ec_io_ports, ec_ecdt);
850         if (ACPI_FAILURE(status))
851                 return status;
852
853         ec_ecdt->uid = -1;
854         acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->uid);
855
856         status =
857             acpi_evaluate_integer(handle, "_GPE", NULL,
858                                   &ec_ecdt->gpe_bit);
859         if (ACPI_FAILURE(status))
860                 return status;
861         ec_ecdt->global_lock = TRUE;
862         ec_ecdt->handle = handle;
863
864         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "GPE=0x%02lx, ports=0x%2lx, 0x%2lx",
865                ec_ecdt->gpe_bit, ec_ecdt->command_addr, ec_ecdt->data_addr));
866
867         return AE_CTRL_TERMINATE;
868 }
869
870 /*
871  * Some BIOS (such as some from Gateway laptops) access EC region very early
872  * such as in BAT0._INI or EC._INI before an EC device is found and
873  * do not provide an ECDT. According to ACPI spec, ECDT isn't mandatorily
874  * required, but if EC regison is accessed early, it is required.
875  * The routine tries to workaround the BIOS bug by pre-scan EC device
876  * It assumes that _CRS, _HID, _GPE, _UID methods of EC don't touch any
877  * op region (since _REG isn't invoked yet). The assumption is true for
878  * all systems found.
879  */
880 static int __init acpi_ec_fake_ecdt(void)
881 {
882         acpi_status status;
883         int ret = 0;
884
885         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Try to make an fake ECDT"));
886
887         ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
888         if (!ec_ecdt) {
889                 ret = -ENOMEM;
890                 goto error;
891         }
892         memset(ec_ecdt, 0, sizeof(struct acpi_ec));
893
894         status = acpi_get_devices(ACPI_EC_HID,
895                                   acpi_fake_ecdt_callback, NULL, NULL);
896         if (ACPI_FAILURE(status)) {
897                 kfree(ec_ecdt);
898                 ec_ecdt = NULL;
899                 ret = -ENODEV;
900                 ACPI_EXCEPTION((AE_INFO, status, "Can't make an fake ECDT"));
901                 goto error;
902         }
903         return 0;
904   error:
905         return ret;
906 }
907
908 static int __init acpi_ec_get_real_ecdt(void)
909 {
910         acpi_status status;
911         struct acpi_table_ecdt *ecdt_ptr;
912
913         status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
914                                          (struct acpi_table_header **)
915                                          &ecdt_ptr);
916         if (ACPI_FAILURE(status))
917                 return -ENODEV;
918
919         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found ECDT"));
920
921         /*
922          * Generate a temporary ec context to use until the namespace is scanned
923          */
924         ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
925         if (!ec_ecdt)
926                 return -ENOMEM;
927         memset(ec_ecdt, 0, sizeof(struct acpi_ec));
928
929         init_MUTEX(&ec_ecdt->sem);
930         if (acpi_ec_mode == EC_INTR) {
931                 init_waitqueue_head(&ec_ecdt->wait);
932         }
933         ec_ecdt->command_addr = ecdt_ptr->ec_control.address;
934         ec_ecdt->data_addr = ecdt_ptr->ec_data.address;
935         ec_ecdt->gpe_bit = ecdt_ptr->gpe_bit;
936         /* use the GL just to be safe */
937         ec_ecdt->global_lock = TRUE;
938         ec_ecdt->uid = ecdt_ptr->uid;
939
940         status =
941             acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->handle);
942         if (ACPI_FAILURE(status)) {
943                 goto error;
944         }
945
946         return 0;
947   error:
948         ACPI_EXCEPTION((AE_INFO, status, "Could not use ECDT"));
949         kfree(ec_ecdt);
950         ec_ecdt = NULL;
951
952         return -ENODEV;
953 }
954
955 static int __initdata acpi_fake_ecdt_enabled;
956 int __init acpi_ec_ecdt_probe(void)
957 {
958         acpi_status status;
959         int ret;
960
961         ret = acpi_ec_get_real_ecdt();
962         /* Try to make a fake ECDT */
963         if (ret && acpi_fake_ecdt_enabled) {
964                 ret = acpi_ec_fake_ecdt();
965         }
966
967         if (ret)
968                 return 0;
969
970         /*
971          * Install GPE handler
972          */
973         status = acpi_install_gpe_handler(NULL, ec_ecdt->gpe_bit,
974                                           ACPI_GPE_EDGE_TRIGGERED,
975                                           &acpi_ec_gpe_handler, ec_ecdt);
976         if (ACPI_FAILURE(status)) {
977                 goto error;
978         }
979         acpi_set_gpe_type(NULL, ec_ecdt->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
980         acpi_enable_gpe(NULL, ec_ecdt->gpe_bit, ACPI_NOT_ISR);
981
982         status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
983                                                     ACPI_ADR_SPACE_EC,
984                                                     &acpi_ec_space_handler,
985                                                     &acpi_ec_space_setup,
986                                                     ec_ecdt);
987         if (ACPI_FAILURE(status)) {
988                 acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
989                                         &acpi_ec_gpe_handler);
990                 goto error;
991         }
992
993         return 0;
994
995       error:
996         ACPI_EXCEPTION((AE_INFO, status, "Could not use ECDT"));
997         kfree(ec_ecdt);
998         ec_ecdt = NULL;
999
1000         return -ENODEV;
1001 }
1002
1003 static int __init acpi_ec_init(void)
1004 {
1005         int result = 0;
1006
1007
1008         if (acpi_disabled)
1009                 return 0;
1010
1011         acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
1012         if (!acpi_ec_dir)
1013                 return -ENODEV;
1014
1015         /* Now register the driver for the EC */
1016         result = acpi_bus_register_driver(&acpi_ec_driver);
1017         if (result < 0) {
1018                 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1019                 return -ENODEV;
1020         }
1021
1022         return result;
1023 }
1024
1025 subsys_initcall(acpi_ec_init);
1026
1027 /* EC driver currently not unloadable */
1028 #if 0
1029 static void __exit acpi_ec_exit(void)
1030 {
1031
1032         acpi_bus_unregister_driver(&acpi_ec_driver);
1033
1034         remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1035
1036         return;
1037 }
1038 #endif                          /* 0 */
1039
1040 static int __init acpi_fake_ecdt_setup(char *str)
1041 {
1042         acpi_fake_ecdt_enabled = 1;
1043         return 1;
1044 }
1045
1046 __setup("acpi_fake_ecdt", acpi_fake_ecdt_setup);
1047 static int __init acpi_ec_set_intr_mode(char *str)
1048 {
1049         int intr;
1050
1051         if (!get_option(&str, &intr))
1052                 return 0;
1053
1054         if (intr) {
1055                 acpi_ec_mode = EC_INTR;
1056         } else {
1057                 acpi_ec_mode = EC_POLL;
1058         }
1059         acpi_ec_driver.ops.add = acpi_ec_add;
1060         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "EC %s mode.\n", intr ? "interrupt" : "polling"));
1061
1062         return 1;
1063 }
1064
1065 __setup("ec_intr=", acpi_ec_set_intr_mode);