?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] Fix bugs in analog tv i2c-helper chipset drivers
[linux-2.6/history.git] / drivers / acpi / ec.c
blob5b21db55776f9cbf2a5d23ea3d260d5bbfe26bf1
1 /*
2 * acpi_ec.c - ACPI Embedded Controller Driver ($Revision: 38 $)
3 *
4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6 *
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or (at
12 * your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
22 *
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24 */
25
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/types.h>
30 #include <linux/delay.h>
31 #include <linux/proc_fs.h>
32 #include <asm/io.h>
33 #include <acpi/acpi_bus.h>
34 #include <acpi/acpi_drivers.h>
35 #include <acpi/actypes.h>
36
37 #define _COMPONENT ACPI_EC_COMPONENT
38 ACPI_MODULE_NAME ("acpi_ec")
39
40 #define ACPI_EC_COMPONENT 0x00100000
41 #define ACPI_EC_CLASS "embedded_controller"
42 #define ACPI_EC_HID "PNP0C09"
43 #define ACPI_EC_DRIVER_NAME "ACPI Embedded Controller Driver"
44 #define ACPI_EC_DEVICE_NAME "Embedded Controller"
45 #define ACPI_EC_FILE_INFO "info"
46
47
48 #define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
49 #define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
50 #define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
51
52 #define ACPI_EC_EVENT_OBF 0x01 /* Output buffer full */
53 #define ACPI_EC_EVENT_IBE 0x02 /* Input buffer empty */
54
55 #define ACPI_EC_UDELAY 100 /* Poll @ 100us increments */
56 #define ACPI_EC_UDELAY_COUNT 1000 /* Wait 10ms max. during EC ops */
57 #define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
58
59 #define ACPI_EC_COMMAND_READ 0x80
60 #define ACPI_EC_COMMAND_WRITE 0x81
61 #define ACPI_EC_COMMAND_QUERY 0x84
62
63 static int acpi_ec_add (struct acpi_device *device);
64 static int acpi_ec_remove (struct acpi_device *device, int type);
65 static int acpi_ec_start (struct acpi_device *device);
66 static int acpi_ec_stop (struct acpi_device *device, int type);
67
68 static struct acpi_driver acpi_ec_driver = {
69 .name = ACPI_EC_DRIVER_NAME,
70 .class = ACPI_EC_CLASS,
71 .ids = ACPI_EC_HID,
72 .ops = {
73 .add = acpi_ec_add,
74 .remove = acpi_ec_remove,
75 .start = acpi_ec_start,
76 .stop = acpi_ec_stop,
77 },
78 };
79
80 struct acpi_ec {
81 acpi_handle handle;
82 unsigned long uid;
83 unsigned long gpe_bit;
84 struct acpi_generic_address status_addr;
85 struct acpi_generic_address command_addr;
86 struct acpi_generic_address data_addr;
87 unsigned long global_lock;
88 spinlock_t lock;
89 };
90
91 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
92 static struct acpi_ec *ec_ecdt;
93
94 /* External interfaces use first EC only, so remember */
95 static struct acpi_device *first_ec;
96
97 /* --------------------------------------------------------------------------
98 Transaction Management
99 -------------------------------------------------------------------------- */
100
101 static int
102 acpi_ec_wait (
103 struct acpi_ec *ec,
104 u8 event)
105 {
106 u32 acpi_ec_status = 0;
107 u32 i = ACPI_EC_UDELAY_COUNT;
108
109 if (!ec)
110 return -EINVAL;
111
112 /* Poll the EC status register waiting for the event to occur. */
113 switch (event) {
114 case ACPI_EC_EVENT_OBF:
115 do {
116 acpi_hw_low_level_read(8, &acpi_ec_status, &ec->status_addr);
117 if (acpi_ec_status & ACPI_EC_FLAG_OBF)
118 return 0;
119 udelay(ACPI_EC_UDELAY);
120 } while (--i>0);
121 break;
122 case ACPI_EC_EVENT_IBE:
123 do {
124 acpi_hw_low_level_read(8, &acpi_ec_status, &ec->status_addr);
125 if (!(acpi_ec_status & ACPI_EC_FLAG_IBF))
126 return 0;
127 udelay(ACPI_EC_UDELAY);
128 } while (--i>0);
129 break;
130 default:
131 return -EINVAL;
132 }
133
134 return -ETIME;
135 }
136
137
138 static int
139 acpi_ec_read (
140 struct acpi_ec *ec,
141 u8 address,
142 u32 *data)
143 {
144 acpi_status status = AE_OK;
145 int result = 0;
146 unsigned long flags = 0;
147 u32 glk = 0;
148
149 ACPI_FUNCTION_TRACE("acpi_ec_read");
150
151 if (!ec || !data)
152 return_VALUE(-EINVAL);
153
154 *data = 0;
155
156 if (ec->global_lock) {
157 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
158 if (ACPI_FAILURE(status))
159 return_VALUE(-ENODEV);
160 }
161
162 spin_lock_irqsave(&ec->lock, flags);
163
164 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ, &ec->command_addr);
165 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
166 if (result)
167 goto end;
168
169 acpi_hw_low_level_write(8, address, &ec->data_addr);
170 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
171 if (result)
172 goto end;
173
174
175 acpi_hw_low_level_read(8, data, &ec->data_addr);
176
177 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
178 *data, address));
179
180 end:
181 spin_unlock_irqrestore(&ec->lock, flags);
182
183 if (ec->global_lock)
184 acpi_release_global_lock(glk);
185
186 return_VALUE(result);
187 }
188
189
190 static int
191 acpi_ec_write (
192 struct acpi_ec *ec,
193 u8 address,
194 u8 data)
195 {
196 int result = 0;
197 acpi_status status = AE_OK;
198 unsigned long flags = 0;
199 u32 glk = 0;
200
201 ACPI_FUNCTION_TRACE("acpi_ec_write");
202
203 if (!ec)
204 return_VALUE(-EINVAL);
205
206 if (ec->global_lock) {
207 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
208 if (ACPI_FAILURE(status))
209 return_VALUE(-ENODEV);
210 }
211
212 spin_lock_irqsave(&ec->lock, flags);
213
214 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE, &ec->command_addr);
215 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
216 if (result)
217 goto end;
218
219 acpi_hw_low_level_write(8, address, &ec->data_addr);
220 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
221 if (result)
222 goto end;
223
224 acpi_hw_low_level_write(8, data, &ec->data_addr);
225 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
226 if (result)
227 goto end;
228
229 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
230 data, address));
231
232 end:
233 spin_unlock_irqrestore(&ec->lock, flags);
234
235 if (ec->global_lock)
236 acpi_release_global_lock(glk);
237
238 return_VALUE(result);
239 }
240
241 /*
242 * Externally callable EC access functions. For now, assume 1 EC only
243 */
244 int
245 ec_read(u8 addr, u8 *val)
246 {
247 struct acpi_ec *ec;
248 int err;
249 u32 temp_data;
250
251 if (!first_ec)
252 return -ENODEV;
253
254 ec = acpi_driver_data(first_ec);
255
256 err = acpi_ec_read(ec, addr, &temp_data);
257
258 if (!err) {
259 *val = temp_data;
260 return 0;
261 }
262 else
263 return err;
264 }
265
266 int
267 ec_write(u8 addr, u8 val)
268 {
269 struct acpi_ec *ec;
270 int err;
271
272 if (!first_ec)
273 return -ENODEV;
274
275 ec = acpi_driver_data(first_ec);
276
277 err = acpi_ec_write(ec, addr, val);
278
279 return err;
280 }
281
282
283 static int
284 acpi_ec_query (
285 struct acpi_ec *ec,
286 u32 *data)
287 {
288 int result = 0;
289 acpi_status status = AE_OK;
290 unsigned long flags = 0;
291 u32 glk = 0;
292
293 ACPI_FUNCTION_TRACE("acpi_ec_query");
294
295 if (!ec || !data)
296 return_VALUE(-EINVAL);
297
298 *data = 0;
299
300 if (ec->global_lock) {
301 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
302 if (ACPI_FAILURE(status))
303 return_VALUE(-ENODEV);
304 }
305
306 /*
307 * Query the EC to find out which _Qxx method we need to evaluate.
308 * Note that successful completion of the query causes the ACPI_EC_SCI
309 * bit to be cleared (and thus clearing the interrupt source).
310 */
311 spin_lock_irqsave(&ec->lock, flags);
312
313 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY, &ec->command_addr);
314 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
315 if (result)
316 goto end;
317
318 acpi_hw_low_level_read(8, data, &ec->data_addr);
319 if (!*data)
320 result = -ENODATA;
321
322 end:
323 spin_unlock_irqrestore(&ec->lock, flags);
324
325 if (ec->global_lock)
326 acpi_release_global_lock(glk);
327
328 return_VALUE(result);
329 }
330
331
332 /* --------------------------------------------------------------------------
333 Event Management
334 -------------------------------------------------------------------------- */
335
336 struct acpi_ec_query_data {
337 acpi_handle handle;
338 u8 data;
339 };
340
341 static void
342 acpi_ec_gpe_query (
343 void *ec_cxt)
344 {
345 struct acpi_ec *ec = (struct acpi_ec *) ec_cxt;
346 u32 value = 0;
347 unsigned long flags = 0;
348 static char object_name[5] = {'_','Q','0','0','\0'};
349 const char hex[] = {'0','1','2','3','4','5','6','7',
350 '8','9','A','B','C','D','E','F'};
351
352 ACPI_FUNCTION_TRACE("acpi_ec_gpe_query");
353
354 if (!ec_cxt)
355 goto end;
356
357 spin_lock_irqsave(&ec->lock, flags);
358 acpi_hw_low_level_read(8, &value, &ec->command_addr);
359 spin_unlock_irqrestore(&ec->lock, flags);
360
361 /* TBD: Implement asynch events!
362 * NOTE: All we care about are EC-SCI's. Other EC events are
363 * handled via polling (yuck!). This is because some systems
364 * treat EC-SCIs as level (versus EDGE!) triggered, preventing
365 * a purely interrupt-driven approach (grumble, grumble).
366 */
367 if (!(value & ACPI_EC_FLAG_SCI))
368 goto end;
369
370 if (acpi_ec_query(ec, &value))
371 goto end;
372
373 object_name[2] = hex[((value >> 4) & 0x0F)];
374 object_name[3] = hex[(value & 0x0F)];
375
376 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name));
377
378 acpi_evaluate_object(ec->handle, object_name, NULL, NULL);
379
380 end:
381 acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
382 }
383
384 static void
385 acpi_ec_gpe_handler (
386 void *data)
387 {
388 acpi_status status = AE_OK;
389 struct acpi_ec *ec = (struct acpi_ec *) data;
390
391 if (!ec)
392 return;
393
394 acpi_disable_gpe(NULL, ec->gpe_bit, ACPI_ISR);
395
396 status = acpi_os_queue_for_execution(OSD_PRIORITY_GPE,
397 acpi_ec_gpe_query, ec);
398 }
399
400 /* --------------------------------------------------------------------------
401 Address Space Management
402 -------------------------------------------------------------------------- */
403
404 static acpi_status
405 acpi_ec_space_setup (
406 acpi_handle region_handle,
407 u32 function,
408 void *handler_context,
409 void **return_context)
410 {
411 /*
412 * The EC object is in the handler context and is needed
413 * when calling the acpi_ec_space_handler.
414 */
415 if(function == ACPI_REGION_DEACTIVATE)
416 *return_context = NULL;
417 else
418 *return_context = handler_context;
419
420 return AE_OK;
421 }
422
423
424 static acpi_status
425 acpi_ec_space_handler (
426 u32 function,
427 acpi_physical_address address,
428 u32 bit_width,
429 acpi_integer *value,
430 void *handler_context,
431 void *region_context)
432 {
433 int result = 0;
434 struct acpi_ec *ec = NULL;
435 u32 temp = 0;
436
437 ACPI_FUNCTION_TRACE("acpi_ec_space_handler");
438
439 if ((address > 0xFF) || (bit_width != 8) || !value || !handler_context)
440 return_VALUE(AE_BAD_PARAMETER);
441
442 ec = (struct acpi_ec *) handler_context;
443
444 switch (function) {
445 case ACPI_READ:
446 result = acpi_ec_read(ec, (u8) address, &temp);
447 *value = (acpi_integer) temp;
448 break;
449 case ACPI_WRITE:
450 result = acpi_ec_write(ec, (u8) address, (u8) *value);
451 break;
452 default:
453 result = -EINVAL;
454 break;
455 }
456
457 switch (result) {
458 case -EINVAL:
459 return_VALUE(AE_BAD_PARAMETER);
460 break;
461 case -ENODEV:
462 return_VALUE(AE_NOT_FOUND);
463 break;
464 case -ETIME:
465 return_VALUE(AE_TIME);
466 break;
467 default:
468 return_VALUE(AE_OK);
469 }
470
471 }
472
473
474 /* --------------------------------------------------------------------------
475 FS Interface (/proc)
476 -------------------------------------------------------------------------- */
477
478 struct proc_dir_entry *acpi_ec_dir = NULL;
479
480
481 static int
482 acpi_ec_read_info (
483 char *page,
484 char **start,
485 off_t off,
486 int count,
487 int *eof,
488 void *data)
489 {
490 struct acpi_ec *ec = (struct acpi_ec *) data;
491 char *p = page;
492 int len = 0;
493
494 ACPI_FUNCTION_TRACE("acpi_ec_read_info");
495
496 if (!ec || (off != 0))
497 goto end;
498
499 p += sprintf(p, "gpe bit: 0x%02x\n",
500 (u32) ec->gpe_bit);
501 p += sprintf(p, "ports: 0x%02x, 0x%02x\n",
502 (u32) ec->status_addr.address, (u32) ec->data_addr.address);
503 p += sprintf(p, "use global lock: %s\n",
504 ec->global_lock?"yes":"no");
505
506 end:
507 len = (p - page);
508 if (len <= off+count) *eof = 1;
509 *start = page + off;
510 len -= off;
511 if (len>count) len = count;
512 if (len<0) len = 0;
513
514 return_VALUE(len);
515 }
516
517
518 static int
519 acpi_ec_add_fs (
520 struct acpi_device *device)
521 {
522 struct proc_dir_entry *entry = NULL;
523
524 ACPI_FUNCTION_TRACE("acpi_ec_add_fs");
525
526 if (!acpi_device_dir(device)) {
527 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
528 acpi_ec_dir);
529 if (!acpi_device_dir(device))
530 return_VALUE(-ENODEV);
531 }
532
533 entry = create_proc_read_entry(ACPI_EC_FILE_INFO, S_IRUGO,
534 acpi_device_dir(device), acpi_ec_read_info,
535 acpi_driver_data(device));
536 if (!entry)
537 ACPI_DEBUG_PRINT((ACPI_DB_WARN,
538 "Unable to create '%s' fs entry\n",
539 ACPI_EC_FILE_INFO));
540
541 return_VALUE(0);
542 }
543
544
545 static int
546 acpi_ec_remove_fs (
547 struct acpi_device *device)
548 {
549 ACPI_FUNCTION_TRACE("acpi_ec_remove_fs");
550
551 return_VALUE(0);
552 }
553
554
555 /* --------------------------------------------------------------------------
556 Driver Interface
557 -------------------------------------------------------------------------- */
558
559 static int
560 acpi_ec_add (
561 struct acpi_device *device)
562 {
563 int result = 0;
564 acpi_status status = AE_OK;
565 struct acpi_ec *ec = NULL;
566 unsigned long uid;
567
568 ACPI_FUNCTION_TRACE("acpi_ec_add");
569
570 if (!device)
571 return_VALUE(-EINVAL);
572
573 ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
574 if (!ec)
575 return_VALUE(-ENOMEM);
576 memset(ec, 0, sizeof(struct acpi_ec));
577
578 ec->handle = device->handle;
579 ec->uid = -1;
580 ec->lock = SPIN_LOCK_UNLOCKED;
581 sprintf(acpi_device_name(device), "%s", ACPI_EC_DEVICE_NAME);
582 sprintf(acpi_device_class(device), "%s", ACPI_EC_CLASS);
583 acpi_driver_data(device) = ec;
584
585 /* Use the global lock for all EC transactions? */
586 acpi_evaluate_integer(ec->handle, "_GLK", NULL, &ec->global_lock);
587
588 /* If our UID matches the UID for the ECDT-enumerated EC,
589 we now have the *real* EC info, so kill the makeshift one.*/
590 acpi_evaluate_integer(ec->handle, "_UID", NULL, &uid);
591 if (ec_ecdt && ec_ecdt->uid == uid) {
592 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
593 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler);
594
595 acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit, &acpi_ec_gpe_handler);
596
597 kfree(ec_ecdt);
598 }
599
600 /* Get GPE bit assignment (EC events). */
601 /* TODO: Add support for _GPE returning a package */
602 status = acpi_evaluate_integer(ec->handle, "_GPE", NULL, &ec->gpe_bit);
603 if (ACPI_FAILURE(status)) {
604 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
605 "Error obtaining GPE bit assignment\n"));
606 result = -ENODEV;
607 goto end;
608 }
609
610 result = acpi_ec_add_fs(device);
611 if (result)
612 goto end;
613
614 printk(KERN_INFO PREFIX "%s [%s] (gpe %d)\n",
615 acpi_device_name(device), acpi_device_bid(device),
616 (u32) ec->gpe_bit);
617
618 if (!first_ec)
619 first_ec = device;
620
621 end:
622 if (result)
623 kfree(ec);
624
625 return_VALUE(result);
626 }
627
628
629 static int
630 acpi_ec_remove (
631 struct acpi_device *device,
632 int type)
633 {
634 struct acpi_ec *ec = NULL;
635
636 ACPI_FUNCTION_TRACE("acpi_ec_remove");
637
638 if (!device)
639 return_VALUE(-EINVAL);
640
641 ec = acpi_driver_data(device);
642
643 acpi_ec_remove_fs(device);
644
645 kfree(ec);
646
647 return_VALUE(0);
648 }
649
650
651 static acpi_status
652 acpi_ec_io_ports (
653 struct acpi_resource *resource,
654 void *context)
655 {
656 struct acpi_ec *ec = (struct acpi_ec *) context;
657 struct acpi_generic_address *addr;
658
659 if (resource->id != ACPI_RSTYPE_IO) {
660 return AE_OK;
661 }
662
663 /*
664 * The first address region returned is the data port, and
665 * the second address region returned is the status/command
666 * port.
667 */
668 if (ec->data_addr.register_bit_width == 0) {
669 addr = &ec->data_addr;
670 } else if (ec->command_addr.register_bit_width == 0) {
671 addr = &ec->command_addr;
672 } else {
673 return AE_CTRL_TERMINATE;
674 }
675
676 addr->address_space_id = ACPI_ADR_SPACE_SYSTEM_IO;
677 addr->register_bit_width = 8;
678 addr->register_bit_offset = 0;
679 addr->address = resource->data.io.min_base_address;
680
681 return AE_OK;
682 }
683
684
685 static int
686 acpi_ec_start (
687 struct acpi_device *device)
688 {
689 acpi_status status = AE_OK;
690 struct acpi_ec *ec = NULL;
691
692 ACPI_FUNCTION_TRACE("acpi_ec_start");
693
694 if (!device)
695 return_VALUE(-EINVAL);
696
697 ec = acpi_driver_data(device);
698
699 if (!ec)
700 return_VALUE(-EINVAL);
701
702 /*
703 * Get I/O port addresses. Convert to GAS format.
704 */
705 status = acpi_walk_resources(ec->handle, METHOD_NAME__CRS,
706 acpi_ec_io_ports, ec);
707 if (ACPI_FAILURE(status) || ec->command_addr.register_bit_width == 0) {
708 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error getting I/O port addresses"));
709 return_VALUE(-ENODEV);
710 }
711
712 ec->status_addr = ec->command_addr;
713
714 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n",
715 (u32) ec->gpe_bit, (u32) ec->command_addr.address,
716 (u32) ec->data_addr.address));
717
718 /*
719 * Install GPE handler
720 */
721 status = acpi_install_gpe_handler(NULL, ec->gpe_bit,
722 ACPI_EVENT_EDGE_TRIGGERED, &acpi_ec_gpe_handler, ec);
723 if (ACPI_FAILURE(status)) {
724 return_VALUE(-ENODEV);
725 }
726
727 status = acpi_install_address_space_handler (ec->handle,
728 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler,
729 &acpi_ec_space_setup, ec);
730 if (ACPI_FAILURE(status)) {
731 acpi_remove_gpe_handler(NULL, ec->gpe_bit, &acpi_ec_gpe_handler);
732 return_VALUE(-ENODEV);
733 }
734
735 return_VALUE(AE_OK);
736 }
737
738
739 static int
740 acpi_ec_stop (
741 struct acpi_device *device,
742 int type)
743 {
744 acpi_status status = AE_OK;
745 struct acpi_ec *ec = NULL;
746
747 ACPI_FUNCTION_TRACE("acpi_ec_stop");
748
749 if (!device)
750 return_VALUE(-EINVAL);
751
752 ec = acpi_driver_data(device);
753
754 status = acpi_remove_address_space_handler(ec->handle,
755 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler);
756 if (ACPI_FAILURE(status))
757 return_VALUE(-ENODEV);
758
759 status = acpi_remove_gpe_handler(NULL, ec->gpe_bit, &acpi_ec_gpe_handler);
760 if (ACPI_FAILURE(status))
761 return_VALUE(-ENODEV);
762
763 return_VALUE(0);
764 }
765
766
767 int __init
768 acpi_ec_ecdt_probe (void)
769 {
770 acpi_status status;
771 struct acpi_table_ecdt *ecdt_ptr;
772
773 status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
774 (struct acpi_table_header **) &ecdt_ptr);
775 if (ACPI_FAILURE(status))
776 return 0;
777
778 printk(KERN_INFO PREFIX "Found ECDT\n");
779
780 /*
781 * Generate a temporary ec context to use until the namespace is scanned
782 */
783 ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
784 if (!ec_ecdt)
785 return -ENOMEM;
786 memset(ec_ecdt, 0, sizeof(struct acpi_ec));
787
788 ec_ecdt->command_addr = ecdt_ptr->ec_control;
789 ec_ecdt->status_addr = ecdt_ptr->ec_control;
790 ec_ecdt->data_addr = ecdt_ptr->ec_data;
791 ec_ecdt->gpe_bit = ecdt_ptr->gpe_bit;
792 ec_ecdt->lock = SPIN_LOCK_UNLOCKED;
793 /* use the GL just to be safe */
794 ec_ecdt->global_lock = TRUE;
795 ec_ecdt->uid = ecdt_ptr->uid;
796
797 status = acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->handle);
798 if (ACPI_FAILURE(status)) {
799 goto error;
800 }
801
802 /*
803 * Install GPE handler
804 */
805 status = acpi_install_gpe_handler(NULL, ec_ecdt->gpe_bit,
806 ACPI_EVENT_EDGE_TRIGGERED, &acpi_ec_gpe_handler,
807 ec_ecdt);
808 if (ACPI_FAILURE(status)) {
809 goto error;
810 }
811
812 status = acpi_install_address_space_handler (ACPI_ROOT_OBJECT,
813 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler,
814 &acpi_ec_space_setup, ec_ecdt);
815 if (ACPI_FAILURE(status)) {
816 acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
817 &acpi_ec_gpe_handler);
818 goto error;
819 }
820
821 return 0;
822
823 error:
824 printk(KERN_ERR PREFIX "Could not use ECDT\n");
825 kfree(ec_ecdt);
826 ec_ecdt = NULL;
827
828 return -ENODEV;
829 }
830
831
832 static int __init acpi_ec_init (void)
833 {
834 int result = 0;
835
836 ACPI_FUNCTION_TRACE("acpi_ec_init");
837
838 if (acpi_disabled)
839 return_VALUE(0);
840
841 acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
842 if (!acpi_ec_dir)
843 return_VALUE(-ENODEV);
844
845 /* Now register the driver for the EC */
846 result = acpi_bus_register_driver(&acpi_ec_driver);
847 if (result < 0) {
848 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
849 return_VALUE(-ENODEV);
850 }
851
852 return_VALUE(result);
853 }
854
855 subsys_initcall(acpi_ec_init);
856
857 /* EC driver currently not unloadable */
858 #if 0
859 static void __exit
860 acpi_ec_exit (void)
861 {
862 ACPI_FUNCTION_TRACE("acpi_ec_exit");
863
864 acpi_bus_unregister_driver(&acpi_ec_driver);
865
866 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
867
868 return_VOID;
869 }
870 #endif /* 0 */
871
Historical 2.5/2.6 development