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 /* Uncomment next line to get verbose print outs*/ 30 /* #define DEBUG */ 31 32 #include <linux/kernel.h> 33 #include <linux/module.h> 34 #include <linux/init.h> 35 #include <linux/types.h> 36 #include <linux/delay.h> 37 #include <linux/proc_fs.h> 38 #include <linux/seq_file.h> 39 #include <linux/interrupt.h> 40 #include <linux/list.h> 41 #include <asm/io.h> 42 #include <acpi/acpi_bus.h> 43 #include <acpi/acpi_drivers.h> 44 #include <acpi/actypes.h> 45 46 #define ACPI_EC_CLASS "embedded_controller" 47 #define ACPI_EC_DEVICE_NAME "Embedded Controller" 48 #define ACPI_EC_FILE_INFO "info" 49 50 #undef PREFIX 51 #define PREFIX "ACPI: EC: " 52 53 /* EC status register */ 54 #define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */ 55 #define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */ 56 #define ACPI_EC_FLAG_BURST 0x10 /* burst mode */ 57 #define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */ 58 59 /* EC commands */ 60 enum ec_command { 61 ACPI_EC_COMMAND_READ = 0x80, 62 ACPI_EC_COMMAND_WRITE = 0x81, 63 ACPI_EC_BURST_ENABLE = 0x82, 64 ACPI_EC_BURST_DISABLE = 0x83, 65 ACPI_EC_COMMAND_QUERY = 0x84, 66 }; 67 68 /* EC events */ 69 enum ec_event { 70 ACPI_EC_EVENT_OBF_1 = 1, /* Output buffer full */ 71 ACPI_EC_EVENT_IBF_0, /* Input buffer empty */ 72 }; 73 74 #define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */ 75 #define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */ 76 #define ACPI_EC_UDELAY 100 /* Wait 100us before polling EC again */ 77 78 enum { 79 EC_FLAGS_WAIT_GPE = 0, /* Don't check status until GPE arrives */ 80 EC_FLAGS_QUERY_PENDING, /* Query is pending */ 81 EC_FLAGS_GPE_MODE, /* Expect GPE to be sent for status change */ 82 EC_FLAGS_NO_GPE, /* Don't use GPE mode */ 83 EC_FLAGS_RESCHEDULE_POLL /* Re-schedule poll */ 84 }; 85 86 /* If we find an EC via the ECDT, we need to keep a ptr to its context */ 87 /* External interfaces use first EC only, so remember */ 88 typedef int (*acpi_ec_query_func) (void *data); 89 90 struct acpi_ec_query_handler { 91 struct list_head node; 92 acpi_ec_query_func func; 93 acpi_handle handle; 94 void *data; 95 u8 query_bit; 96 }; 97 98 static struct acpi_ec { 99 acpi_handle handle; 100 unsigned long gpe; 101 unsigned long command_addr; 102 unsigned long data_addr; 103 unsigned long global_lock; 104 unsigned long flags; 105 struct mutex lock; 106 wait_queue_head_t wait; 107 struct list_head list; 108 struct delayed_work work; 109 atomic_t irq_count; 110 u8 handlers_installed; 111 } *boot_ec, *first_ec; 112 113 /* 114 * Some Asus system have exchanged ECDT data/command IO addresses. 115 */ 116 static int print_ecdt_error(const struct dmi_system_id *id) 117 { 118 printk(KERN_NOTICE PREFIX "%s detected - " 119 "ECDT has exchanged control/data I/O address\n", 120 id->ident); 121 return 0; 122 } 123 124 static struct dmi_system_id __cpuinitdata ec_dmi_table[] = { 125 { 126 print_ecdt_error, "Asus L4R", { 127 DMI_MATCH(DMI_BIOS_VERSION, "1008.006"), 128 DMI_MATCH(DMI_PRODUCT_NAME, "L4R"), 129 DMI_MATCH(DMI_BOARD_NAME, "L4R") }, NULL}, 130 { 131 print_ecdt_error, "Asus M6R", { 132 DMI_MATCH(DMI_BIOS_VERSION, "0207"), 133 DMI_MATCH(DMI_PRODUCT_NAME, "M6R"), 134 DMI_MATCH(DMI_BOARD_NAME, "M6R") }, NULL}, 135 {}, 136 }; 137 138 /* -------------------------------------------------------------------------- 139 Transaction Management 140 -------------------------------------------------------------------------- */ 141 142 static inline u8 acpi_ec_read_status(struct acpi_ec *ec) 143 { 144 u8 x = inb(ec->command_addr); 145 pr_debug(PREFIX "---> status = 0x%2.2x\n", x); 146 return x; 147 } 148 149 static inline u8 acpi_ec_read_data(struct acpi_ec *ec) 150 { 151 u8 x = inb(ec->data_addr); 152 pr_debug(PREFIX "---> data = 0x%2.2x\n", x); 153 return inb(ec->data_addr); 154 } 155 156 static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command) 157 { 158 pr_debug(PREFIX "<--- command = 0x%2.2x\n", command); 159 outb(command, ec->command_addr); 160 } 161 162 static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data) 163 { 164 pr_debug(PREFIX "<--- data = 0x%2.2x\n", data); 165 outb(data, ec->data_addr); 166 } 167 168 static inline int acpi_ec_check_status(struct acpi_ec *ec, enum ec_event event) 169 { 170 if (test_bit(EC_FLAGS_WAIT_GPE, &ec->flags)) 171 return 0; 172 if (event == ACPI_EC_EVENT_OBF_1) { 173 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_OBF) 174 return 1; 175 } else if (event == ACPI_EC_EVENT_IBF_0) { 176 if (!(acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF)) 177 return 1; 178 } 179 180 return 0; 181 } 182 183 static void ec_schedule_ec_poll(struct acpi_ec *ec) 184 { 185 if (test_bit(EC_FLAGS_RESCHEDULE_POLL, &ec->flags)) 186 schedule_delayed_work(&ec->work, 187 msecs_to_jiffies(ACPI_EC_DELAY)); 188 } 189 190 static void ec_switch_to_poll_mode(struct acpi_ec *ec) 191 { 192 set_bit(EC_FLAGS_NO_GPE, &ec->flags); 193 clear_bit(EC_FLAGS_GPE_MODE, &ec->flags); 194 acpi_disable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 195 set_bit(EC_FLAGS_RESCHEDULE_POLL, &ec->flags); 196 } 197 198 static int acpi_ec_wait(struct acpi_ec *ec, enum ec_event event, int force_poll) 199 { 200 atomic_set(&ec->irq_count, 0); 201 if (likely(test_bit(EC_FLAGS_GPE_MODE, &ec->flags)) && 202 likely(!force_poll)) { 203 if (wait_event_timeout(ec->wait, acpi_ec_check_status(ec, event), 204 msecs_to_jiffies(ACPI_EC_DELAY))) 205 return 0; 206 clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 207 if (acpi_ec_check_status(ec, event)) { 208 /* missing GPEs, switch back to poll mode */ 209 if (printk_ratelimit()) 210 pr_info(PREFIX "missing confirmations, " 211 "switch off interrupt mode.\n"); 212 ec_switch_to_poll_mode(ec); 213 ec_schedule_ec_poll(ec); 214 return 0; 215 } 216 } else { 217 unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY); 218 clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 219 while (time_before(jiffies, delay)) { 220 if (acpi_ec_check_status(ec, event)) 221 return 0; 222 msleep(1); 223 } 224 if (acpi_ec_check_status(ec,event)) 225 return 0; 226 } 227 pr_err(PREFIX "acpi_ec_wait timeout, status = 0x%2.2x, event = %s\n", 228 acpi_ec_read_status(ec), 229 (event == ACPI_EC_EVENT_OBF_1) ? "\"b0=1\"" : "\"b1=0\""); 230 return -ETIME; 231 } 232 233 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, u8 command, 234 const u8 * wdata, unsigned wdata_len, 235 u8 * rdata, unsigned rdata_len, 236 int force_poll) 237 { 238 int result = 0; 239 set_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 240 pr_debug(PREFIX "transaction start\n"); 241 acpi_ec_write_cmd(ec, command); 242 for (; wdata_len > 0; --wdata_len) { 243 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, force_poll); 244 if (result) { 245 pr_err(PREFIX 246 "write_cmd timeout, command = %d\n", command); 247 goto end; 248 } 249 set_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 250 acpi_ec_write_data(ec, *(wdata++)); 251 } 252 253 if (!rdata_len) { 254 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, force_poll); 255 if (result) { 256 pr_err(PREFIX 257 "finish-write timeout, command = %d\n", command); 258 goto end; 259 } 260 } else if (command == ACPI_EC_COMMAND_QUERY) 261 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags); 262 263 for (; rdata_len > 0; --rdata_len) { 264 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1, force_poll); 265 if (result) { 266 pr_err(PREFIX "read timeout, command = %d\n", command); 267 goto end; 268 } 269 /* Don't expect GPE after last read */ 270 if (rdata_len > 1) 271 set_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 272 *(rdata++) = acpi_ec_read_data(ec); 273 } 274 end: 275 pr_debug(PREFIX "transaction end\n"); 276 return result; 277 } 278 279 static int acpi_ec_transaction(struct acpi_ec *ec, u8 command, 280 const u8 * wdata, unsigned wdata_len, 281 u8 * rdata, unsigned rdata_len, 282 int force_poll) 283 { 284 int status; 285 u32 glk; 286 287 if (!ec || (wdata_len && !wdata) || (rdata_len && !rdata)) 288 return -EINVAL; 289 290 if (rdata) 291 memset(rdata, 0, rdata_len); 292 293 mutex_lock(&ec->lock); 294 if (ec->global_lock) { 295 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 296 if (ACPI_FAILURE(status)) { 297 mutex_unlock(&ec->lock); 298 return -ENODEV; 299 } 300 } 301 302 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, 0); 303 if (status) { 304 pr_err(PREFIX "input buffer is not empty, " 305 "aborting transaction\n"); 306 goto end; 307 } 308 309 status = acpi_ec_transaction_unlocked(ec, command, 310 wdata, wdata_len, 311 rdata, rdata_len, 312 force_poll); 313 314 end: 315 316 if (ec->global_lock) 317 acpi_release_global_lock(glk); 318 mutex_unlock(&ec->lock); 319 320 return status; 321 } 322 323 /* 324 * Note: samsung nv5000 doesn't work with ec burst mode. 325 * http://bugzilla.kernel.org/show_bug.cgi?id=4980 326 */ 327 int acpi_ec_burst_enable(struct acpi_ec *ec) 328 { 329 u8 d; 330 return acpi_ec_transaction(ec, ACPI_EC_BURST_ENABLE, NULL, 0, &d, 1, 0); 331 } 332 333 int acpi_ec_burst_disable(struct acpi_ec *ec) 334 { 335 return acpi_ec_transaction(ec, ACPI_EC_BURST_DISABLE, NULL, 0, NULL, 0, 0); 336 } 337 338 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data) 339 { 340 int result; 341 u8 d; 342 343 result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_READ, 344 &address, 1, &d, 1, 0); 345 *data = d; 346 return result; 347 } 348 349 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data) 350 { 351 u8 wdata[2] = { address, data }; 352 return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE, 353 wdata, 2, NULL, 0, 0); 354 } 355 356 /* 357 * Externally callable EC access functions. For now, assume 1 EC only 358 */ 359 int ec_burst_enable(void) 360 { 361 if (!first_ec) 362 return -ENODEV; 363 return acpi_ec_burst_enable(first_ec); 364 } 365 366 EXPORT_SYMBOL(ec_burst_enable); 367 368 int ec_burst_disable(void) 369 { 370 if (!first_ec) 371 return -ENODEV; 372 return acpi_ec_burst_disable(first_ec); 373 } 374 375 EXPORT_SYMBOL(ec_burst_disable); 376 377 int ec_read(u8 addr, u8 * val) 378 { 379 int err; 380 u8 temp_data; 381 382 if (!first_ec) 383 return -ENODEV; 384 385 err = acpi_ec_read(first_ec, addr, &temp_data); 386 387 if (!err) { 388 *val = temp_data; 389 return 0; 390 } else 391 return err; 392 } 393 394 EXPORT_SYMBOL(ec_read); 395 396 int ec_write(u8 addr, u8 val) 397 { 398 int err; 399 400 if (!first_ec) 401 return -ENODEV; 402 403 err = acpi_ec_write(first_ec, addr, val); 404 405 return err; 406 } 407 408 EXPORT_SYMBOL(ec_write); 409 410 int ec_transaction(u8 command, 411 const u8 * wdata, unsigned wdata_len, 412 u8 * rdata, unsigned rdata_len, 413 int force_poll) 414 { 415 if (!first_ec) 416 return -ENODEV; 417 418 return acpi_ec_transaction(first_ec, command, wdata, 419 wdata_len, rdata, rdata_len, 420 force_poll); 421 } 422 423 EXPORT_SYMBOL(ec_transaction); 424 425 static int acpi_ec_query(struct acpi_ec *ec, u8 * data) 426 { 427 int result; 428 u8 d; 429 430 if (!ec || !data) 431 return -EINVAL; 432 433 /* 434 * Query the EC to find out which _Qxx method we need to evaluate. 435 * Note that successful completion of the query causes the ACPI_EC_SCI 436 * bit to be cleared (and thus clearing the interrupt source). 437 */ 438 439 result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1, 0); 440 if (result) 441 return result; 442 443 if (!d) 444 return -ENODATA; 445 446 *data = d; 447 return 0; 448 } 449 450 /* -------------------------------------------------------------------------- 451 Event Management 452 -------------------------------------------------------------------------- */ 453 int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit, 454 acpi_handle handle, acpi_ec_query_func func, 455 void *data) 456 { 457 struct acpi_ec_query_handler *handler = 458 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL); 459 if (!handler) 460 return -ENOMEM; 461 462 handler->query_bit = query_bit; 463 handler->handle = handle; 464 handler->func = func; 465 handler->data = data; 466 mutex_lock(&ec->lock); 467 list_add(&handler->node, &ec->list); 468 mutex_unlock(&ec->lock); 469 return 0; 470 } 471 472 EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler); 473 474 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit) 475 { 476 struct acpi_ec_query_handler *handler, *tmp; 477 mutex_lock(&ec->lock); 478 list_for_each_entry_safe(handler, tmp, &ec->list, node) { 479 if (query_bit == handler->query_bit) { 480 list_del(&handler->node); 481 kfree(handler); 482 } 483 } 484 mutex_unlock(&ec->lock); 485 } 486 487 EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler); 488 489 static void acpi_ec_gpe_query(void *ec_cxt) 490 { 491 struct acpi_ec *ec = ec_cxt; 492 u8 value = 0; 493 struct acpi_ec_query_handler *handler, copy; 494 495 if (!ec || acpi_ec_query(ec, &value)) 496 return; 497 mutex_lock(&ec->lock); 498 list_for_each_entry(handler, &ec->list, node) { 499 if (value == handler->query_bit) { 500 /* have custom handler for this bit */ 501 memcpy(©, handler, sizeof(copy)); 502 mutex_unlock(&ec->lock); 503 if (copy.func) { 504 copy.func(copy.data); 505 } else if (copy.handle) { 506 acpi_evaluate_object(copy.handle, NULL, NULL, NULL); 507 } 508 return; 509 } 510 } 511 mutex_unlock(&ec->lock); 512 } 513 514 static u32 acpi_ec_gpe_handler(void *data) 515 { 516 acpi_status status = AE_OK; 517 struct acpi_ec *ec = data; 518 u8 state = acpi_ec_read_status(ec); 519 520 pr_debug(PREFIX "~~~> interrupt\n"); 521 atomic_inc(&ec->irq_count); 522 if (atomic_read(&ec->irq_count) > 5) { 523 pr_err(PREFIX "GPE storm detected, disabling EC GPE\n"); 524 ec_switch_to_poll_mode(ec); 525 goto end; 526 } 527 clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 528 if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags)) 529 wake_up(&ec->wait); 530 531 if (state & ACPI_EC_FLAG_SCI) { 532 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) 533 status = acpi_os_execute(OSL_EC_BURST_HANDLER, 534 acpi_ec_gpe_query, ec); 535 } else if (!test_bit(EC_FLAGS_GPE_MODE, &ec->flags) && 536 !test_bit(EC_FLAGS_NO_GPE, &ec->flags) && 537 in_interrupt()) { 538 /* this is non-query, must be confirmation */ 539 if (printk_ratelimit()) 540 pr_info(PREFIX "non-query interrupt received," 541 " switching to interrupt mode\n"); 542 set_bit(EC_FLAGS_GPE_MODE, &ec->flags); 543 clear_bit(EC_FLAGS_RESCHEDULE_POLL, &ec->flags); 544 } 545 end: 546 ec_schedule_ec_poll(ec); 547 return ACPI_SUCCESS(status) ? 548 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED; 549 } 550 551 static void do_ec_poll(struct work_struct *work) 552 { 553 struct acpi_ec *ec = container_of(work, struct acpi_ec, work.work); 554 atomic_set(&ec->irq_count, 0); 555 (void)acpi_ec_gpe_handler(ec); 556 } 557 558 /* -------------------------------------------------------------------------- 559 Address Space Management 560 -------------------------------------------------------------------------- */ 561 562 static acpi_status 563 acpi_ec_space_handler(u32 function, acpi_physical_address address, 564 u32 bits, acpi_integer *value, 565 void *handler_context, void *region_context) 566 { 567 struct acpi_ec *ec = handler_context; 568 int result = 0, i; 569 u8 temp = 0; 570 571 if ((address > 0xFF) || !value || !handler_context) 572 return AE_BAD_PARAMETER; 573 574 if (function != ACPI_READ && function != ACPI_WRITE) 575 return AE_BAD_PARAMETER; 576 577 if (bits != 8 && acpi_strict) 578 return AE_BAD_PARAMETER; 579 580 acpi_ec_burst_enable(ec); 581 582 if (function == ACPI_READ) { 583 result = acpi_ec_read(ec, address, &temp); 584 *value = temp; 585 } else { 586 temp = 0xff & (*value); 587 result = acpi_ec_write(ec, address, temp); 588 } 589 590 for (i = 8; unlikely(bits - i > 0); i += 8) { 591 ++address; 592 if (function == ACPI_READ) { 593 result = acpi_ec_read(ec, address, &temp); 594 (*value) |= ((acpi_integer)temp) << i; 595 } else { 596 temp = 0xff & ((*value) >> i); 597 result = acpi_ec_write(ec, address, temp); 598 } 599 } 600 601 acpi_ec_burst_disable(ec); 602 603 switch (result) { 604 case -EINVAL: 605 return AE_BAD_PARAMETER; 606 break; 607 case -ENODEV: 608 return AE_NOT_FOUND; 609 break; 610 case -ETIME: 611 return AE_TIME; 612 break; 613 default: 614 return AE_OK; 615 } 616 } 617 618 /* -------------------------------------------------------------------------- 619 FS Interface (/proc) 620 -------------------------------------------------------------------------- */ 621 622 static struct proc_dir_entry *acpi_ec_dir; 623 624 static int acpi_ec_read_info(struct seq_file *seq, void *offset) 625 { 626 struct acpi_ec *ec = seq->private; 627 628 if (!ec) 629 goto end; 630 631 seq_printf(seq, "gpe:\t\t\t0x%02x\n", (u32) ec->gpe); 632 seq_printf(seq, "ports:\t\t\t0x%02x, 0x%02x\n", 633 (unsigned)ec->command_addr, (unsigned)ec->data_addr); 634 seq_printf(seq, "use global lock:\t%s\n", 635 ec->global_lock ? "yes" : "no"); 636 end: 637 return 0; 638 } 639 640 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file) 641 { 642 return single_open(file, acpi_ec_read_info, PDE(inode)->data); 643 } 644 645 static struct file_operations acpi_ec_info_ops = { 646 .open = acpi_ec_info_open_fs, 647 .read = seq_read, 648 .llseek = seq_lseek, 649 .release = single_release, 650 .owner = THIS_MODULE, 651 }; 652 653 static int acpi_ec_add_fs(struct acpi_device *device) 654 { 655 struct proc_dir_entry *entry = NULL; 656 657 if (!acpi_device_dir(device)) { 658 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 659 acpi_ec_dir); 660 if (!acpi_device_dir(device)) 661 return -ENODEV; 662 } 663 664 entry = proc_create_data(ACPI_EC_FILE_INFO, S_IRUGO, 665 acpi_device_dir(device), 666 &acpi_ec_info_ops, acpi_driver_data(device)); 667 if (!entry) 668 return -ENODEV; 669 return 0; 670 } 671 672 static int acpi_ec_remove_fs(struct acpi_device *device) 673 { 674 675 if (acpi_device_dir(device)) { 676 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device)); 677 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir); 678 acpi_device_dir(device) = NULL; 679 } 680 681 return 0; 682 } 683 684 /* -------------------------------------------------------------------------- 685 Driver Interface 686 -------------------------------------------------------------------------- */ 687 static acpi_status 688 ec_parse_io_ports(struct acpi_resource *resource, void *context); 689 690 static struct acpi_ec *make_acpi_ec(void) 691 { 692 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL); 693 if (!ec) 694 return NULL; 695 ec->flags = 1 << EC_FLAGS_QUERY_PENDING; 696 mutex_init(&ec->lock); 697 init_waitqueue_head(&ec->wait); 698 INIT_LIST_HEAD(&ec->list); 699 INIT_DELAYED_WORK_DEFERRABLE(&ec->work, do_ec_poll); 700 atomic_set(&ec->irq_count, 0); 701 return ec; 702 } 703 704 static acpi_status 705 acpi_ec_register_query_methods(acpi_handle handle, u32 level, 706 void *context, void **return_value) 707 { 708 struct acpi_namespace_node *node = handle; 709 struct acpi_ec *ec = context; 710 int value = 0; 711 if (sscanf(node->name.ascii, "_Q%x", &value) == 1) { 712 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL); 713 } 714 return AE_OK; 715 } 716 717 static acpi_status 718 ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval) 719 { 720 acpi_status status; 721 722 struct acpi_ec *ec = context; 723 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 724 ec_parse_io_ports, ec); 725 if (ACPI_FAILURE(status)) 726 return status; 727 728 /* Get GPE bit assignment (EC events). */ 729 /* TODO: Add support for _GPE returning a package */ 730 status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec->gpe); 731 if (ACPI_FAILURE(status)) 732 return status; 733 /* Use the global lock for all EC transactions? */ 734 acpi_evaluate_integer(handle, "_GLK", NULL, &ec->global_lock); 735 ec->handle = handle; 736 return AE_CTRL_TERMINATE; 737 } 738 739 static void ec_poll_stop(struct acpi_ec *ec) 740 { 741 clear_bit(EC_FLAGS_RESCHEDULE_POLL, &ec->flags); 742 cancel_delayed_work(&ec->work); 743 } 744 745 static void ec_remove_handlers(struct acpi_ec *ec) 746 { 747 ec_poll_stop(ec); 748 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle, 749 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler))) 750 pr_err(PREFIX "failed to remove space handler\n"); 751 if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe, 752 &acpi_ec_gpe_handler))) 753 pr_err(PREFIX "failed to remove gpe handler\n"); 754 ec->handlers_installed = 0; 755 } 756 757 static int acpi_ec_add(struct acpi_device *device) 758 { 759 struct acpi_ec *ec = NULL; 760 761 if (!device) 762 return -EINVAL; 763 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME); 764 strcpy(acpi_device_class(device), ACPI_EC_CLASS); 765 766 /* Check for boot EC */ 767 if (boot_ec && 768 (boot_ec->handle == device->handle || 769 boot_ec->handle == ACPI_ROOT_OBJECT)) { 770 ec = boot_ec; 771 boot_ec = NULL; 772 } else { 773 ec = make_acpi_ec(); 774 if (!ec) 775 return -ENOMEM; 776 if (ec_parse_device(device->handle, 0, ec, NULL) != 777 AE_CTRL_TERMINATE) { 778 kfree(ec); 779 return -EINVAL; 780 } 781 } 782 783 ec->handle = device->handle; 784 785 /* Find and register all query methods */ 786 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1, 787 acpi_ec_register_query_methods, ec, NULL); 788 789 if (!first_ec) 790 first_ec = ec; 791 acpi_driver_data(device) = ec; 792 acpi_ec_add_fs(device); 793 pr_info(PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n", 794 ec->gpe, ec->command_addr, ec->data_addr); 795 pr_info(PREFIX "driver started in %s mode\n", 796 (test_bit(EC_FLAGS_GPE_MODE, &ec->flags))?"interrupt":"poll"); 797 return 0; 798 } 799 800 static int acpi_ec_remove(struct acpi_device *device, int type) 801 { 802 struct acpi_ec *ec; 803 struct acpi_ec_query_handler *handler, *tmp; 804 805 if (!device) 806 return -EINVAL; 807 808 ec = acpi_driver_data(device); 809 mutex_lock(&ec->lock); 810 list_for_each_entry_safe(handler, tmp, &ec->list, node) { 811 list_del(&handler->node); 812 kfree(handler); 813 } 814 mutex_unlock(&ec->lock); 815 acpi_ec_remove_fs(device); 816 acpi_driver_data(device) = NULL; 817 if (ec == first_ec) 818 first_ec = NULL; 819 kfree(ec); 820 return 0; 821 } 822 823 static acpi_status 824 ec_parse_io_ports(struct acpi_resource *resource, void *context) 825 { 826 struct acpi_ec *ec = context; 827 828 if (resource->type != ACPI_RESOURCE_TYPE_IO) 829 return AE_OK; 830 831 /* 832 * The first address region returned is the data port, and 833 * the second address region returned is the status/command 834 * port. 835 */ 836 if (ec->data_addr == 0) 837 ec->data_addr = resource->data.io.minimum; 838 else if (ec->command_addr == 0) 839 ec->command_addr = resource->data.io.minimum; 840 else 841 return AE_CTRL_TERMINATE; 842 843 return AE_OK; 844 } 845 846 static int ec_install_handlers(struct acpi_ec *ec) 847 { 848 acpi_status status; 849 if (ec->handlers_installed) 850 return 0; 851 status = acpi_install_gpe_handler(NULL, ec->gpe, 852 ACPI_GPE_EDGE_TRIGGERED, 853 &acpi_ec_gpe_handler, ec); 854 if (ACPI_FAILURE(status)) 855 return -ENODEV; 856 857 acpi_set_gpe_type(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME); 858 acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 859 860 status = acpi_install_address_space_handler(ec->handle, 861 ACPI_ADR_SPACE_EC, 862 &acpi_ec_space_handler, 863 NULL, ec); 864 if (ACPI_FAILURE(status)) { 865 acpi_remove_gpe_handler(NULL, ec->gpe, &acpi_ec_gpe_handler); 866 return -ENODEV; 867 } 868 869 ec->handlers_installed = 1; 870 return 0; 871 } 872 873 static int acpi_ec_start(struct acpi_device *device) 874 { 875 struct acpi_ec *ec; 876 int ret = 0; 877 878 if (!device) 879 return -EINVAL; 880 881 ec = acpi_driver_data(device); 882 883 if (!ec) 884 return -EINVAL; 885 886 ret = ec_install_handlers(ec); 887 888 /* EC is fully operational, allow queries */ 889 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags); 890 ec_schedule_ec_poll(ec); 891 return ret; 892 } 893 894 static int acpi_ec_stop(struct acpi_device *device, int type) 895 { 896 struct acpi_ec *ec; 897 if (!device) 898 return -EINVAL; 899 ec = acpi_driver_data(device); 900 if (!ec) 901 return -EINVAL; 902 ec_remove_handlers(ec); 903 904 return 0; 905 } 906 907 int __init acpi_boot_ec_enable(void) 908 { 909 if (!boot_ec || boot_ec->handlers_installed) 910 return 0; 911 if (!ec_install_handlers(boot_ec)) { 912 first_ec = boot_ec; 913 return 0; 914 } 915 return -EFAULT; 916 } 917 918 static const struct acpi_device_id ec_device_ids[] = { 919 {"PNP0C09", 0}, 920 {"", 0}, 921 }; 922 923 int __init acpi_ec_ecdt_probe(void) 924 { 925 int ret; 926 acpi_status status; 927 struct acpi_table_ecdt *ecdt_ptr; 928 929 boot_ec = make_acpi_ec(); 930 if (!boot_ec) 931 return -ENOMEM; 932 /* 933 * Generate a boot ec context 934 */ 935 status = acpi_get_table(ACPI_SIG_ECDT, 1, 936 (struct acpi_table_header **)&ecdt_ptr); 937 if (ACPI_SUCCESS(status)) { 938 pr_info(PREFIX "EC description table is found, configuring boot EC\n"); 939 boot_ec->command_addr = ecdt_ptr->control.address; 940 boot_ec->data_addr = ecdt_ptr->data.address; 941 if (dmi_check_system(ec_dmi_table)) { 942 /* 943 * If the board falls into ec_dmi_table, it means 944 * that ECDT table gives the incorrect command/status 945 * & data I/O address. Just fix it. 946 */ 947 boot_ec->data_addr = ecdt_ptr->control.address; 948 boot_ec->command_addr = ecdt_ptr->data.address; 949 } 950 boot_ec->gpe = ecdt_ptr->gpe; 951 boot_ec->handle = ACPI_ROOT_OBJECT; 952 acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, &boot_ec->handle); 953 } else { 954 /* This workaround is needed only on some broken machines, 955 * which require early EC, but fail to provide ECDT */ 956 acpi_handle x; 957 printk(KERN_DEBUG PREFIX "Look up EC in DSDT\n"); 958 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, 959 boot_ec, NULL); 960 /* Check that acpi_get_devices actually find something */ 961 if (ACPI_FAILURE(status) || !boot_ec->handle) 962 goto error; 963 /* We really need to limit this workaround, the only ASUS, 964 * which needs it, has fake EC._INI method, so use it as flag. 965 * Keep boot_ec struct as it will be needed soon. 966 */ 967 if (ACPI_FAILURE(acpi_get_handle(boot_ec->handle, "_INI", &x))) 968 return -ENODEV; 969 } 970 971 ret = ec_install_handlers(boot_ec); 972 if (!ret) { 973 first_ec = boot_ec; 974 return 0; 975 } 976 error: 977 kfree(boot_ec); 978 boot_ec = NULL; 979 return -ENODEV; 980 } 981 982 static int acpi_ec_suspend(struct acpi_device *device, pm_message_t state) 983 { 984 struct acpi_ec *ec = acpi_driver_data(device); 985 /* Stop using GPE */ 986 set_bit(EC_FLAGS_NO_GPE, &ec->flags); 987 clear_bit(EC_FLAGS_GPE_MODE, &ec->flags); 988 acpi_disable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 989 return 0; 990 } 991 992 static int acpi_ec_resume(struct acpi_device *device) 993 { 994 struct acpi_ec *ec = acpi_driver_data(device); 995 /* Enable use of GPE back */ 996 clear_bit(EC_FLAGS_NO_GPE, &ec->flags); 997 acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 998 return 0; 999 } 1000 1001 static struct acpi_driver acpi_ec_driver = { 1002 .name = "ec", 1003 .class = ACPI_EC_CLASS, 1004 .ids = ec_device_ids, 1005 .ops = { 1006 .add = acpi_ec_add, 1007 .remove = acpi_ec_remove, 1008 .start = acpi_ec_start, 1009 .stop = acpi_ec_stop, 1010 .suspend = acpi_ec_suspend, 1011 .resume = acpi_ec_resume, 1012 }, 1013 }; 1014 1015 static int __init acpi_ec_init(void) 1016 { 1017 int result = 0; 1018 1019 if (acpi_disabled) 1020 return 0; 1021 1022 acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir); 1023 if (!acpi_ec_dir) 1024 return -ENODEV; 1025 1026 /* Now register the driver for the EC */ 1027 result = acpi_bus_register_driver(&acpi_ec_driver); 1028 if (result < 0) { 1029 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 1030 return -ENODEV; 1031 } 1032 1033 return result; 1034 } 1035 1036 subsys_initcall(acpi_ec_init); 1037 1038 /* EC driver currently not unloadable */ 1039 #if 0 1040 static void __exit acpi_ec_exit(void) 1041 { 1042 1043 acpi_bus_unregister_driver(&acpi_ec_driver); 1044 1045 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 1046 1047 return; 1048 } 1049 #endif /* 0 */ 1050