1 /* 2 * ec.c - ACPI Embedded Controller Driver (v2.0) 3 * 4 * Copyright (C) 2006, 2007 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com> 5 * Copyright (C) 2006 Denis Sadykov <denis.m.sadykov@intel.com> 6 * Copyright (C) 2004 Luming Yu <luming.yu@intel.com> 7 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 8 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 9 * 10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or (at 15 * your option) any later version. 16 * 17 * This program is distributed in the hope that it will be useful, but 18 * WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 20 * General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License along 23 * with this program; if not, write to the Free Software Foundation, Inc., 24 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 25 * 26 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 27 */ 28 29 #include <linux/kernel.h> 30 #include <linux/module.h> 31 #include <linux/init.h> 32 #include <linux/types.h> 33 #include <linux/delay.h> 34 #include <linux/proc_fs.h> 35 #include <linux/seq_file.h> 36 #include <linux/interrupt.h> 37 #include <linux/list.h> 38 #include <asm/io.h> 39 #include <acpi/acpi_bus.h> 40 #include <acpi/acpi_drivers.h> 41 #include <acpi/actypes.h> 42 43 #define ACPI_EC_CLASS "embedded_controller" 44 #define ACPI_EC_DEVICE_NAME "Embedded Controller" 45 #define ACPI_EC_FILE_INFO "info" 46 47 #undef PREFIX 48 #define PREFIX "ACPI: EC: " 49 50 /* EC status register */ 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 /* EC commands */ 57 enum ec_command { 58 ACPI_EC_COMMAND_READ = 0x80, 59 ACPI_EC_COMMAND_WRITE = 0x81, 60 ACPI_EC_BURST_ENABLE = 0x82, 61 ACPI_EC_BURST_DISABLE = 0x83, 62 ACPI_EC_COMMAND_QUERY = 0x84, 63 }; 64 65 /* EC events */ 66 enum ec_event { 67 ACPI_EC_EVENT_OBF_1 = 1, /* Output buffer full */ 68 ACPI_EC_EVENT_IBF_0, /* Input buffer empty */ 69 }; 70 71 #define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */ 72 #define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */ 73 74 static enum ec_mode { 75 EC_INTR = 1, /* Output buffer full */ 76 EC_POLL, /* Input buffer empty */ 77 } acpi_ec_mode = EC_INTR; 78 79 static int acpi_ec_remove(struct acpi_device *device, int type); 80 static int acpi_ec_start(struct acpi_device *device); 81 static int acpi_ec_stop(struct acpi_device *device, int type); 82 static int acpi_ec_add(struct acpi_device *device); 83 84 static const struct acpi_device_id ec_device_ids[] = { 85 {"PNP0C09", 0}, 86 {"", 0}, 87 }; 88 89 static struct acpi_driver acpi_ec_driver = { 90 .name = "ec", 91 .class = ACPI_EC_CLASS, 92 .ids = ec_device_ids, 93 .ops = { 94 .add = acpi_ec_add, 95 .remove = acpi_ec_remove, 96 .start = acpi_ec_start, 97 .stop = acpi_ec_stop, 98 }, 99 }; 100 101 /* If we find an EC via the ECDT, we need to keep a ptr to its context */ 102 /* External interfaces use first EC only, so remember */ 103 typedef int (*acpi_ec_query_func) (void *data); 104 105 struct acpi_ec_query_handler { 106 struct list_head node; 107 acpi_ec_query_func func; 108 acpi_handle handle; 109 void *data; 110 u8 query_bit; 111 }; 112 113 static struct acpi_ec { 114 acpi_handle handle; 115 unsigned long gpe; 116 unsigned long command_addr; 117 unsigned long data_addr; 118 unsigned long global_lock; 119 struct mutex lock; 120 atomic_t query_pending; 121 atomic_t event_count; 122 wait_queue_head_t wait; 123 struct list_head list; 124 } *boot_ec, *first_ec; 125 126 /* -------------------------------------------------------------------------- 127 Transaction Management 128 -------------------------------------------------------------------------- */ 129 130 static inline u8 acpi_ec_read_status(struct acpi_ec *ec) 131 { 132 return inb(ec->command_addr); 133 } 134 135 static inline u8 acpi_ec_read_data(struct acpi_ec *ec) 136 { 137 return inb(ec->data_addr); 138 } 139 140 static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command) 141 { 142 outb(command, ec->command_addr); 143 } 144 145 static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data) 146 { 147 outb(data, ec->data_addr); 148 } 149 150 static inline int acpi_ec_check_status(struct acpi_ec *ec, enum ec_event event, 151 unsigned old_count) 152 { 153 u8 status = acpi_ec_read_status(ec); 154 if (old_count == atomic_read(&ec->event_count)) 155 return 0; 156 if (event == ACPI_EC_EVENT_OBF_1) { 157 if (status & ACPI_EC_FLAG_OBF) 158 return 1; 159 } else if (event == ACPI_EC_EVENT_IBF_0) { 160 if (!(status & ACPI_EC_FLAG_IBF)) 161 return 1; 162 } 163 164 return 0; 165 } 166 167 static int acpi_ec_wait(struct acpi_ec *ec, enum ec_event event, 168 unsigned count, int force_poll) 169 { 170 if (unlikely(force_poll) || acpi_ec_mode == EC_POLL) { 171 unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY); 172 while (time_before(jiffies, delay)) { 173 if (acpi_ec_check_status(ec, event, 0)) 174 return 0; 175 } 176 } else { 177 if (wait_event_timeout(ec->wait, 178 acpi_ec_check_status(ec, event, count), 179 msecs_to_jiffies(ACPI_EC_DELAY)) || 180 acpi_ec_check_status(ec, event, 0)) { 181 return 0; 182 } else { 183 printk(KERN_ERR PREFIX "acpi_ec_wait timeout," 184 " status = %d, expect_event = %d\n", 185 acpi_ec_read_status(ec), event); 186 } 187 } 188 189 return -ETIME; 190 } 191 192 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, u8 command, 193 const u8 * wdata, unsigned wdata_len, 194 u8 * rdata, unsigned rdata_len, 195 int force_poll) 196 { 197 int result = 0; 198 unsigned count = atomic_read(&ec->event_count); 199 acpi_ec_write_cmd(ec, command); 200 201 for (; wdata_len > 0; --wdata_len) { 202 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, count, force_poll); 203 if (result) { 204 printk(KERN_ERR PREFIX 205 "write_cmd timeout, command = %d\n", command); 206 goto end; 207 } 208 count = atomic_read(&ec->event_count); 209 acpi_ec_write_data(ec, *(wdata++)); 210 } 211 212 if (!rdata_len) { 213 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, count, force_poll); 214 if (result) { 215 printk(KERN_ERR PREFIX 216 "finish-write timeout, command = %d\n", command); 217 goto end; 218 } 219 } else if (command == ACPI_EC_COMMAND_QUERY) { 220 atomic_set(&ec->query_pending, 0); 221 } 222 223 for (; rdata_len > 0; --rdata_len) { 224 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1, count, force_poll); 225 if (result) { 226 printk(KERN_ERR PREFIX "read timeout, command = %d\n", 227 command); 228 goto end; 229 } 230 count = atomic_read(&ec->event_count); 231 *(rdata++) = acpi_ec_read_data(ec); 232 } 233 end: 234 return result; 235 } 236 237 static int acpi_ec_transaction(struct acpi_ec *ec, u8 command, 238 const u8 * wdata, unsigned wdata_len, 239 u8 * rdata, unsigned rdata_len, 240 int force_poll) 241 { 242 int status; 243 u32 glk; 244 245 if (!ec || (wdata_len && !wdata) || (rdata_len && !rdata)) 246 return -EINVAL; 247 248 if (rdata) 249 memset(rdata, 0, rdata_len); 250 251 mutex_lock(&ec->lock); 252 if (ec->global_lock) { 253 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 254 if (ACPI_FAILURE(status)) { 255 mutex_unlock(&ec->lock); 256 return -ENODEV; 257 } 258 } 259 260 /* Make sure GPE is enabled before doing transaction */ 261 acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 262 263 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, 0, 0); 264 if (status) { 265 printk(KERN_ERR PREFIX 266 "input buffer is not empty, aborting transaction\n"); 267 goto end; 268 } 269 270 status = acpi_ec_transaction_unlocked(ec, command, 271 wdata, wdata_len, 272 rdata, rdata_len, 273 force_poll); 274 275 end: 276 277 if (ec->global_lock) 278 acpi_release_global_lock(glk); 279 mutex_unlock(&ec->lock); 280 281 return status; 282 } 283 284 /* 285 * Note: samsung nv5000 doesn't work with ec burst mode. 286 * http://bugzilla.kernel.org/show_bug.cgi?id=4980 287 */ 288 int acpi_ec_burst_enable(struct acpi_ec *ec) 289 { 290 u8 d; 291 return acpi_ec_transaction(ec, ACPI_EC_BURST_ENABLE, NULL, 0, &d, 1, 0); 292 } 293 294 int acpi_ec_burst_disable(struct acpi_ec *ec) 295 { 296 return acpi_ec_transaction(ec, ACPI_EC_BURST_DISABLE, NULL, 0, NULL, 0, 0); 297 } 298 299 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data) 300 { 301 int result; 302 u8 d; 303 304 result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_READ, 305 &address, 1, &d, 1, 0); 306 *data = d; 307 return result; 308 } 309 310 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data) 311 { 312 u8 wdata[2] = { address, data }; 313 return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE, 314 wdata, 2, NULL, 0, 0); 315 } 316 317 /* 318 * Externally callable EC access functions. For now, assume 1 EC only 319 */ 320 int ec_burst_enable(void) 321 { 322 if (!first_ec) 323 return -ENODEV; 324 return acpi_ec_burst_enable(first_ec); 325 } 326 327 EXPORT_SYMBOL(ec_burst_enable); 328 329 int ec_burst_disable(void) 330 { 331 if (!first_ec) 332 return -ENODEV; 333 return acpi_ec_burst_disable(first_ec); 334 } 335 336 EXPORT_SYMBOL(ec_burst_disable); 337 338 int ec_read(u8 addr, u8 * val) 339 { 340 int err; 341 u8 temp_data; 342 343 if (!first_ec) 344 return -ENODEV; 345 346 err = acpi_ec_read(first_ec, addr, &temp_data); 347 348 if (!err) { 349 *val = temp_data; 350 return 0; 351 } else 352 return err; 353 } 354 355 EXPORT_SYMBOL(ec_read); 356 357 int ec_write(u8 addr, u8 val) 358 { 359 int err; 360 361 if (!first_ec) 362 return -ENODEV; 363 364 err = acpi_ec_write(first_ec, addr, val); 365 366 return err; 367 } 368 369 EXPORT_SYMBOL(ec_write); 370 371 int ec_transaction(u8 command, 372 const u8 * wdata, unsigned wdata_len, 373 u8 * rdata, unsigned rdata_len, 374 int force_poll) 375 { 376 if (!first_ec) 377 return -ENODEV; 378 379 return acpi_ec_transaction(first_ec, command, wdata, 380 wdata_len, rdata, rdata_len, 381 force_poll); 382 } 383 384 EXPORT_SYMBOL(ec_transaction); 385 386 static int acpi_ec_query(struct acpi_ec *ec, u8 * data) 387 { 388 int result; 389 u8 d; 390 391 if (!ec || !data) 392 return -EINVAL; 393 394 /* 395 * Query the EC to find out which _Qxx method we need to evaluate. 396 * Note that successful completion of the query causes the ACPI_EC_SCI 397 * bit to be cleared (and thus clearing the interrupt source). 398 */ 399 400 result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1, 0); 401 if (result) 402 return result; 403 404 if (!d) 405 return -ENODATA; 406 407 *data = d; 408 return 0; 409 } 410 411 /* -------------------------------------------------------------------------- 412 Event Management 413 -------------------------------------------------------------------------- */ 414 int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit, 415 acpi_handle handle, acpi_ec_query_func func, 416 void *data) 417 { 418 struct acpi_ec_query_handler *handler = 419 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL); 420 if (!handler) 421 return -ENOMEM; 422 423 handler->query_bit = query_bit; 424 handler->handle = handle; 425 handler->func = func; 426 handler->data = data; 427 mutex_lock(&ec->lock); 428 list_add_tail(&handler->node, &ec->list); 429 mutex_unlock(&ec->lock); 430 return 0; 431 } 432 433 EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler); 434 435 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit) 436 { 437 struct acpi_ec_query_handler *handler; 438 mutex_lock(&ec->lock); 439 list_for_each_entry(handler, &ec->list, node) { 440 if (query_bit == handler->query_bit) { 441 list_del(&handler->node); 442 kfree(handler); 443 break; 444 } 445 } 446 mutex_unlock(&ec->lock); 447 } 448 449 EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler); 450 451 static void acpi_ec_gpe_query(void *ec_cxt) 452 { 453 struct acpi_ec *ec = ec_cxt; 454 u8 value = 0; 455 struct acpi_ec_query_handler *handler, copy; 456 457 if (!ec || acpi_ec_query(ec, &value)) 458 return; 459 mutex_lock(&ec->lock); 460 list_for_each_entry(handler, &ec->list, node) { 461 if (value == handler->query_bit) { 462 /* have custom handler for this bit */ 463 memcpy(©, handler, sizeof(copy)); 464 mutex_unlock(&ec->lock); 465 if (copy.func) { 466 copy.func(copy.data); 467 } else if (copy.handle) { 468 acpi_evaluate_object(copy.handle, NULL, NULL, NULL); 469 } 470 return; 471 } 472 } 473 mutex_unlock(&ec->lock); 474 } 475 476 static u32 acpi_ec_gpe_handler(void *data) 477 { 478 acpi_status status = AE_OK; 479 u8 value; 480 struct acpi_ec *ec = data; 481 482 atomic_inc(&ec->event_count); 483 484 if (acpi_ec_mode == EC_INTR) { 485 wake_up(&ec->wait); 486 } 487 488 value = acpi_ec_read_status(ec); 489 if ((value & ACPI_EC_FLAG_SCI) && !atomic_read(&ec->query_pending)) { 490 atomic_set(&ec->query_pending, 1); 491 status = 492 acpi_os_execute(OSL_EC_BURST_HANDLER, acpi_ec_gpe_query, ec); 493 } 494 495 return status == AE_OK ? 496 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED; 497 } 498 499 /* -------------------------------------------------------------------------- 500 Address Space Management 501 -------------------------------------------------------------------------- */ 502 503 static acpi_status 504 acpi_ec_space_setup(acpi_handle region_handle, 505 u32 function, void *handler_context, void **return_context) 506 { 507 /* 508 * The EC object is in the handler context and is needed 509 * when calling the acpi_ec_space_handler. 510 */ 511 *return_context = (function != ACPI_REGION_DEACTIVATE) ? 512 handler_context : NULL; 513 514 return AE_OK; 515 } 516 517 static acpi_status 518 acpi_ec_space_handler(u32 function, acpi_physical_address address, 519 u32 bits, acpi_integer *value, 520 void *handler_context, void *region_context) 521 { 522 struct acpi_ec *ec = handler_context; 523 int result = 0, i = 0; 524 u8 temp = 0; 525 526 if ((address > 0xFF) || !value || !handler_context) 527 return AE_BAD_PARAMETER; 528 529 if (function != ACPI_READ && function != ACPI_WRITE) 530 return AE_BAD_PARAMETER; 531 532 if (bits != 8 && acpi_strict) 533 return AE_BAD_PARAMETER; 534 535 while (bits - i > 0) { 536 if (function == ACPI_READ) { 537 result = acpi_ec_read(ec, address, &temp); 538 (*value) |= ((acpi_integer)temp) << i; 539 } else { 540 temp = 0xff & ((*value) >> i); 541 result = acpi_ec_write(ec, address, temp); 542 } 543 i += 8; 544 ++address; 545 } 546 547 switch (result) { 548 case -EINVAL: 549 return AE_BAD_PARAMETER; 550 break; 551 case -ENODEV: 552 return AE_NOT_FOUND; 553 break; 554 case -ETIME: 555 return AE_TIME; 556 break; 557 default: 558 return AE_OK; 559 } 560 } 561 562 /* -------------------------------------------------------------------------- 563 FS Interface (/proc) 564 -------------------------------------------------------------------------- */ 565 566 static struct proc_dir_entry *acpi_ec_dir; 567 568 static int acpi_ec_read_info(struct seq_file *seq, void *offset) 569 { 570 struct acpi_ec *ec = seq->private; 571 572 if (!ec) 573 goto end; 574 575 seq_printf(seq, "gpe:\t\t\t0x%02x\n", (u32) ec->gpe); 576 seq_printf(seq, "ports:\t\t\t0x%02x, 0x%02x\n", 577 (unsigned)ec->command_addr, (unsigned)ec->data_addr); 578 seq_printf(seq, "use global lock:\t%s\n", 579 ec->global_lock ? "yes" : "no"); 580 end: 581 return 0; 582 } 583 584 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file) 585 { 586 return single_open(file, acpi_ec_read_info, PDE(inode)->data); 587 } 588 589 static struct file_operations acpi_ec_info_ops = { 590 .open = acpi_ec_info_open_fs, 591 .read = seq_read, 592 .llseek = seq_lseek, 593 .release = single_release, 594 .owner = THIS_MODULE, 595 }; 596 597 static int acpi_ec_add_fs(struct acpi_device *device) 598 { 599 struct proc_dir_entry *entry = NULL; 600 601 if (!acpi_device_dir(device)) { 602 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 603 acpi_ec_dir); 604 if (!acpi_device_dir(device)) 605 return -ENODEV; 606 } 607 608 entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO, 609 acpi_device_dir(device)); 610 if (!entry) 611 return -ENODEV; 612 else { 613 entry->proc_fops = &acpi_ec_info_ops; 614 entry->data = acpi_driver_data(device); 615 entry->owner = THIS_MODULE; 616 } 617 618 return 0; 619 } 620 621 static int acpi_ec_remove_fs(struct acpi_device *device) 622 { 623 624 if (acpi_device_dir(device)) { 625 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device)); 626 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir); 627 acpi_device_dir(device) = NULL; 628 } 629 630 return 0; 631 } 632 633 /* -------------------------------------------------------------------------- 634 Driver Interface 635 -------------------------------------------------------------------------- */ 636 static acpi_status 637 ec_parse_io_ports(struct acpi_resource *resource, void *context); 638 639 static struct acpi_ec *make_acpi_ec(void) 640 { 641 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL); 642 if (!ec) 643 return NULL; 644 645 atomic_set(&ec->query_pending, 1); 646 atomic_set(&ec->event_count, 1); 647 mutex_init(&ec->lock); 648 init_waitqueue_head(&ec->wait); 649 INIT_LIST_HEAD(&ec->list); 650 651 return ec; 652 } 653 654 static acpi_status 655 acpi_ec_register_query_methods(acpi_handle handle, u32 level, 656 void *context, void **return_value) 657 { 658 struct acpi_namespace_node *node = handle; 659 struct acpi_ec *ec = context; 660 int value = 0; 661 if (sscanf(node->name.ascii, "_Q%x", &value) == 1) { 662 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL); 663 } 664 return AE_OK; 665 } 666 667 static acpi_status 668 ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval) 669 { 670 acpi_status status; 671 672 struct acpi_ec *ec = context; 673 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 674 ec_parse_io_ports, ec); 675 if (ACPI_FAILURE(status)) 676 return status; 677 678 /* Get GPE bit assignment (EC events). */ 679 /* TODO: Add support for _GPE returning a package */ 680 status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec->gpe); 681 if (ACPI_FAILURE(status)) 682 return status; 683 684 /* Find and register all query methods */ 685 acpi_walk_namespace(ACPI_TYPE_METHOD, handle, 1, 686 acpi_ec_register_query_methods, ec, NULL); 687 688 /* Use the global lock for all EC transactions? */ 689 acpi_evaluate_integer(handle, "_GLK", NULL, &ec->global_lock); 690 691 ec->handle = handle; 692 693 printk(KERN_INFO PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n", 694 ec->gpe, ec->command_addr, ec->data_addr); 695 696 return AE_CTRL_TERMINATE; 697 } 698 699 static int acpi_ec_add(struct acpi_device *device) 700 { 701 struct acpi_ec *ec = NULL; 702 703 if (!device) 704 return -EINVAL; 705 706 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME); 707 strcpy(acpi_device_class(device), ACPI_EC_CLASS); 708 709 ec = make_acpi_ec(); 710 if (!ec) 711 return -ENOMEM; 712 713 if (ec_parse_device(device->handle, 0, ec, NULL) != 714 AE_CTRL_TERMINATE) { 715 kfree(ec); 716 return -EINVAL; 717 } 718 719 /* Check if we found the boot EC */ 720 if (boot_ec) { 721 if (boot_ec->gpe == ec->gpe) { 722 /* We might have incorrect info for GL at boot time */ 723 mutex_lock(&boot_ec->lock); 724 boot_ec->global_lock = ec->global_lock; 725 /* Copy handlers from new ec into boot ec */ 726 list_splice(&ec->list, &boot_ec->list); 727 mutex_unlock(&boot_ec->lock); 728 kfree(ec); 729 ec = boot_ec; 730 } 731 } else 732 first_ec = ec; 733 ec->handle = device->handle; 734 acpi_driver_data(device) = ec; 735 736 acpi_ec_add_fs(device); 737 return 0; 738 } 739 740 static int acpi_ec_remove(struct acpi_device *device, int type) 741 { 742 struct acpi_ec *ec; 743 struct acpi_ec_query_handler *handler, *tmp; 744 745 if (!device) 746 return -EINVAL; 747 748 ec = acpi_driver_data(device); 749 mutex_lock(&ec->lock); 750 list_for_each_entry_safe(handler, tmp, &ec->list, node) { 751 list_del(&handler->node); 752 kfree(handler); 753 } 754 mutex_unlock(&ec->lock); 755 acpi_ec_remove_fs(device); 756 acpi_driver_data(device) = NULL; 757 if (ec == first_ec) 758 first_ec = NULL; 759 760 /* Don't touch boot EC */ 761 if (boot_ec != ec) 762 kfree(ec); 763 return 0; 764 } 765 766 static acpi_status 767 ec_parse_io_ports(struct acpi_resource *resource, void *context) 768 { 769 struct acpi_ec *ec = context; 770 771 if (resource->type != ACPI_RESOURCE_TYPE_IO) 772 return AE_OK; 773 774 /* 775 * The first address region returned is the data port, and 776 * the second address region returned is the status/command 777 * port. 778 */ 779 if (ec->data_addr == 0) 780 ec->data_addr = resource->data.io.minimum; 781 else if (ec->command_addr == 0) 782 ec->command_addr = resource->data.io.minimum; 783 else 784 return AE_CTRL_TERMINATE; 785 786 return AE_OK; 787 } 788 789 static int ec_install_handlers(struct acpi_ec *ec) 790 { 791 acpi_status status; 792 status = acpi_install_gpe_handler(NULL, ec->gpe, 793 ACPI_GPE_EDGE_TRIGGERED, 794 &acpi_ec_gpe_handler, ec); 795 if (ACPI_FAILURE(status)) 796 return -ENODEV; 797 798 acpi_set_gpe_type(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME); 799 acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 800 801 status = acpi_install_address_space_handler(ec->handle, 802 ACPI_ADR_SPACE_EC, 803 &acpi_ec_space_handler, 804 &acpi_ec_space_setup, ec); 805 if (ACPI_FAILURE(status)) { 806 acpi_remove_gpe_handler(NULL, ec->gpe, &acpi_ec_gpe_handler); 807 return -ENODEV; 808 } 809 810 return 0; 811 } 812 813 static int acpi_ec_start(struct acpi_device *device) 814 { 815 struct acpi_ec *ec; 816 int ret = 0; 817 818 if (!device) 819 return -EINVAL; 820 821 ec = acpi_driver_data(device); 822 823 if (!ec) 824 return -EINVAL; 825 826 /* Boot EC is already working */ 827 if (ec != boot_ec) 828 ret = ec_install_handlers(ec); 829 830 /* EC is fully operational, allow queries */ 831 atomic_set(&ec->query_pending, 0); 832 833 return ret; 834 } 835 836 static int acpi_ec_stop(struct acpi_device *device, int type) 837 { 838 acpi_status status; 839 struct acpi_ec *ec; 840 841 if (!device) 842 return -EINVAL; 843 844 ec = acpi_driver_data(device); 845 if (!ec) 846 return -EINVAL; 847 848 /* Don't touch boot EC */ 849 if (ec == boot_ec) 850 return 0; 851 852 status = acpi_remove_address_space_handler(ec->handle, 853 ACPI_ADR_SPACE_EC, 854 &acpi_ec_space_handler); 855 if (ACPI_FAILURE(status)) 856 return -ENODEV; 857 858 status = acpi_remove_gpe_handler(NULL, ec->gpe, &acpi_ec_gpe_handler); 859 if (ACPI_FAILURE(status)) 860 return -ENODEV; 861 862 return 0; 863 } 864 865 int __init acpi_ec_ecdt_probe(void) 866 { 867 int ret; 868 acpi_status status; 869 struct acpi_table_ecdt *ecdt_ptr; 870 871 boot_ec = make_acpi_ec(); 872 if (!boot_ec) 873 return -ENOMEM; 874 /* 875 * Generate a boot ec context 876 */ 877 status = acpi_get_table(ACPI_SIG_ECDT, 1, 878 (struct acpi_table_header **)&ecdt_ptr); 879 if (ACPI_SUCCESS(status)) { 880 printk(KERN_INFO PREFIX "EC description table is found, configuring boot EC\n\n"); 881 boot_ec->command_addr = ecdt_ptr->control.address; 882 boot_ec->data_addr = ecdt_ptr->data.address; 883 boot_ec->gpe = ecdt_ptr->gpe; 884 boot_ec->handle = ACPI_ROOT_OBJECT; 885 } else { 886 printk(KERN_DEBUG PREFIX "Look up EC in DSDT\n"); 887 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, 888 boot_ec, NULL); 889 /* Check that acpi_get_devices actually find something */ 890 if (ACPI_FAILURE(status) || !boot_ec->handle) 891 goto error; 892 } 893 894 ret = ec_install_handlers(boot_ec); 895 if (!ret) { 896 first_ec = boot_ec; 897 return 0; 898 } 899 error: 900 kfree(boot_ec); 901 boot_ec = NULL; 902 903 return -ENODEV; 904 } 905 906 static int __init acpi_ec_init(void) 907 { 908 int result = 0; 909 910 if (acpi_disabled) 911 return 0; 912 913 acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir); 914 if (!acpi_ec_dir) 915 return -ENODEV; 916 917 /* Now register the driver for the EC */ 918 result = acpi_bus_register_driver(&acpi_ec_driver); 919 if (result < 0) { 920 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 921 return -ENODEV; 922 } 923 924 return result; 925 } 926 927 subsys_initcall(acpi_ec_init); 928 929 /* EC driver currently not unloadable */ 930 #if 0 931 static void __exit acpi_ec_exit(void) 932 { 933 934 acpi_bus_unregister_driver(&acpi_ec_driver); 935 936 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 937 938 return; 939 } 940 #endif /* 0 */ 941 942 static int __init acpi_ec_set_intr_mode(char *str) 943 { 944 int intr; 945 946 if (!get_option(&str, &intr)) 947 return 0; 948 949 acpi_ec_mode = (intr) ? EC_INTR : EC_POLL; 950 951 printk(KERN_NOTICE PREFIX "%s mode.\n", intr ? "interrupt" : "polling"); 952 953 return 1; 954 } 955 956 __setup("ec_intr=", acpi_ec_set_intr_mode); 957