1 /* 2 * ec.c - ACPI Embedded Controller Driver (v2.1) 3 * 4 * Copyright (C) 2006-2008 Alexey Starikovskiy <astarikovskiy@suse.de> 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 printout */ 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 <linux/spinlock.h> 42 #include <asm/io.h> 43 #include <acpi/acpi_bus.h> 44 #include <acpi/acpi_drivers.h> 45 #include <linux/dmi.h> 46 47 #define ACPI_EC_CLASS "embedded_controller" 48 #define ACPI_EC_DEVICE_NAME "Embedded Controller" 49 #define ACPI_EC_FILE_INFO "info" 50 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 #define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */ 69 #define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */ 70 #define ACPI_EC_CDELAY 10 /* Wait 10us before polling EC */ 71 #define ACPI_EC_MSI_UDELAY 550 /* Wait 550us for MSI EC */ 72 73 #define ACPI_EC_STORM_THRESHOLD 8 /* number of false interrupts 74 per one transaction */ 75 76 enum { 77 EC_FLAGS_QUERY_PENDING, /* Query is pending */ 78 EC_FLAGS_GPE_STORM, /* GPE storm detected */ 79 EC_FLAGS_HANDLERS_INSTALLED /* Handlers for GPE and 80 * OpReg are installed */ 81 }; 82 83 /* If we find an EC via the ECDT, we need to keep a ptr to its context */ 84 /* External interfaces use first EC only, so remember */ 85 typedef int (*acpi_ec_query_func) (void *data); 86 87 struct acpi_ec_query_handler { 88 struct list_head node; 89 acpi_ec_query_func func; 90 acpi_handle handle; 91 void *data; 92 u8 query_bit; 93 }; 94 95 struct transaction { 96 const u8 *wdata; 97 u8 *rdata; 98 unsigned short irq_count; 99 u8 command; 100 u8 wi; 101 u8 ri; 102 u8 wlen; 103 u8 rlen; 104 bool done; 105 }; 106 107 static struct acpi_ec { 108 acpi_handle handle; 109 unsigned long gpe; 110 unsigned long command_addr; 111 unsigned long data_addr; 112 unsigned long global_lock; 113 unsigned long flags; 114 struct mutex lock; 115 wait_queue_head_t wait; 116 struct list_head list; 117 struct transaction *curr; 118 spinlock_t curr_lock; 119 } *boot_ec, *first_ec; 120 121 static int EC_FLAGS_MSI; /* Out-of-spec MSI controller */ 122 static int EC_FLAGS_VALIDATE_ECDT; /* ASUStec ECDTs need to be validated */ 123 static int EC_FLAGS_SKIP_DSDT_SCAN; /* Not all BIOS survive early DSDT scan */ 124 125 /* -------------------------------------------------------------------------- 126 Transaction Management 127 -------------------------------------------------------------------------- */ 128 129 static inline u8 acpi_ec_read_status(struct acpi_ec *ec) 130 { 131 u8 x = inb(ec->command_addr); 132 pr_debug(PREFIX "---> status = 0x%2.2x\n", x); 133 return x; 134 } 135 136 static inline u8 acpi_ec_read_data(struct acpi_ec *ec) 137 { 138 u8 x = inb(ec->data_addr); 139 pr_debug(PREFIX "---> data = 0x%2.2x\n", x); 140 return x; 141 } 142 143 static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command) 144 { 145 pr_debug(PREFIX "<--- command = 0x%2.2x\n", command); 146 outb(command, ec->command_addr); 147 } 148 149 static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data) 150 { 151 pr_debug(PREFIX "<--- data = 0x%2.2x\n", data); 152 outb(data, ec->data_addr); 153 } 154 155 static int ec_transaction_done(struct acpi_ec *ec) 156 { 157 unsigned long flags; 158 int ret = 0; 159 spin_lock_irqsave(&ec->curr_lock, flags); 160 if (!ec->curr || ec->curr->done) 161 ret = 1; 162 spin_unlock_irqrestore(&ec->curr_lock, flags); 163 return ret; 164 } 165 166 static void start_transaction(struct acpi_ec *ec) 167 { 168 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0; 169 ec->curr->done = false; 170 acpi_ec_write_cmd(ec, ec->curr->command); 171 } 172 173 static void advance_transaction(struct acpi_ec *ec, u8 status) 174 { 175 unsigned long flags; 176 spin_lock_irqsave(&ec->curr_lock, flags); 177 if (!ec->curr) 178 goto unlock; 179 if (ec->curr->wlen > ec->curr->wi) { 180 if ((status & ACPI_EC_FLAG_IBF) == 0) 181 acpi_ec_write_data(ec, 182 ec->curr->wdata[ec->curr->wi++]); 183 else 184 goto err; 185 } else if (ec->curr->rlen > ec->curr->ri) { 186 if ((status & ACPI_EC_FLAG_OBF) == 1) { 187 ec->curr->rdata[ec->curr->ri++] = acpi_ec_read_data(ec); 188 if (ec->curr->rlen == ec->curr->ri) 189 ec->curr->done = true; 190 } else 191 goto err; 192 } else if (ec->curr->wlen == ec->curr->wi && 193 (status & ACPI_EC_FLAG_IBF) == 0) 194 ec->curr->done = true; 195 goto unlock; 196 err: 197 /* false interrupt, state didn't change */ 198 if (in_interrupt()) 199 ++ec->curr->irq_count; 200 unlock: 201 spin_unlock_irqrestore(&ec->curr_lock, flags); 202 } 203 204 static int acpi_ec_sync_query(struct acpi_ec *ec); 205 206 static int ec_check_sci_sync(struct acpi_ec *ec, u8 state) 207 { 208 if (state & ACPI_EC_FLAG_SCI) { 209 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) 210 return acpi_ec_sync_query(ec); 211 } 212 return 0; 213 } 214 215 static int ec_poll(struct acpi_ec *ec) 216 { 217 unsigned long flags; 218 int repeat = 2; /* number of command restarts */ 219 while (repeat--) { 220 unsigned long delay = jiffies + 221 msecs_to_jiffies(ACPI_EC_DELAY); 222 do { 223 /* don't sleep with disabled interrupts */ 224 if (EC_FLAGS_MSI || irqs_disabled()) { 225 udelay(ACPI_EC_MSI_UDELAY); 226 if (ec_transaction_done(ec)) 227 return 0; 228 } else { 229 if (wait_event_timeout(ec->wait, 230 ec_transaction_done(ec), 231 msecs_to_jiffies(1))) 232 return 0; 233 } 234 advance_transaction(ec, acpi_ec_read_status(ec)); 235 } while (time_before(jiffies, delay)); 236 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) 237 break; 238 pr_debug(PREFIX "controller reset, restart transaction\n"); 239 spin_lock_irqsave(&ec->curr_lock, flags); 240 start_transaction(ec); 241 spin_unlock_irqrestore(&ec->curr_lock, flags); 242 } 243 return -ETIME; 244 } 245 246 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, 247 struct transaction *t) 248 { 249 unsigned long tmp; 250 int ret = 0; 251 if (EC_FLAGS_MSI) 252 udelay(ACPI_EC_MSI_UDELAY); 253 /* start transaction */ 254 spin_lock_irqsave(&ec->curr_lock, tmp); 255 /* following two actions should be kept atomic */ 256 ec->curr = t; 257 start_transaction(ec); 258 if (ec->curr->command == ACPI_EC_COMMAND_QUERY) 259 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags); 260 spin_unlock_irqrestore(&ec->curr_lock, tmp); 261 ret = ec_poll(ec); 262 spin_lock_irqsave(&ec->curr_lock, tmp); 263 ec->curr = NULL; 264 spin_unlock_irqrestore(&ec->curr_lock, tmp); 265 return ret; 266 } 267 268 static int ec_check_ibf0(struct acpi_ec *ec) 269 { 270 u8 status = acpi_ec_read_status(ec); 271 return (status & ACPI_EC_FLAG_IBF) == 0; 272 } 273 274 static int ec_wait_ibf0(struct acpi_ec *ec) 275 { 276 unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY); 277 /* interrupt wait manually if GPE mode is not active */ 278 while (time_before(jiffies, delay)) 279 if (wait_event_timeout(ec->wait, ec_check_ibf0(ec), 280 msecs_to_jiffies(1))) 281 return 0; 282 return -ETIME; 283 } 284 285 static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t) 286 { 287 int status; 288 u32 glk; 289 if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata)) 290 return -EINVAL; 291 if (t->rdata) 292 memset(t->rdata, 0, t->rlen); 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 status = -ENODEV; 298 goto unlock; 299 } 300 } 301 if (ec_wait_ibf0(ec)) { 302 pr_err(PREFIX "input buffer is not empty, " 303 "aborting transaction\n"); 304 status = -ETIME; 305 goto end; 306 } 307 pr_debug(PREFIX "transaction start\n"); 308 /* disable GPE during transaction if storm is detected */ 309 if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) { 310 /* 311 * It has to be disabled at the hardware level regardless of the 312 * GPE reference counting, so that it doesn't trigger. 313 */ 314 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE); 315 } 316 317 status = acpi_ec_transaction_unlocked(ec, t); 318 319 /* check if we received SCI during transaction */ 320 ec_check_sci_sync(ec, acpi_ec_read_status(ec)); 321 if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) { 322 msleep(1); 323 /* 324 * It is safe to enable the GPE outside of the transaction. Use 325 * acpi_set_gpe() for that, since we used it to disable the GPE 326 * above. 327 */ 328 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE); 329 } else if (t->irq_count > ACPI_EC_STORM_THRESHOLD) { 330 pr_info(PREFIX "GPE storm detected, " 331 "transactions will use polling mode\n"); 332 set_bit(EC_FLAGS_GPE_STORM, &ec->flags); 333 } 334 pr_debug(PREFIX "transaction end\n"); 335 end: 336 if (ec->global_lock) 337 acpi_release_global_lock(glk); 338 unlock: 339 mutex_unlock(&ec->lock); 340 return status; 341 } 342 343 static int acpi_ec_burst_enable(struct acpi_ec *ec) 344 { 345 u8 d; 346 struct transaction t = {.command = ACPI_EC_BURST_ENABLE, 347 .wdata = NULL, .rdata = &d, 348 .wlen = 0, .rlen = 1}; 349 350 return acpi_ec_transaction(ec, &t); 351 } 352 353 static int acpi_ec_burst_disable(struct acpi_ec *ec) 354 { 355 struct transaction t = {.command = ACPI_EC_BURST_DISABLE, 356 .wdata = NULL, .rdata = NULL, 357 .wlen = 0, .rlen = 0}; 358 359 return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ? 360 acpi_ec_transaction(ec, &t) : 0; 361 } 362 363 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data) 364 { 365 int result; 366 u8 d; 367 struct transaction t = {.command = ACPI_EC_COMMAND_READ, 368 .wdata = &address, .rdata = &d, 369 .wlen = 1, .rlen = 1}; 370 371 result = acpi_ec_transaction(ec, &t); 372 *data = d; 373 return result; 374 } 375 376 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data) 377 { 378 u8 wdata[2] = { address, data }; 379 struct transaction t = {.command = ACPI_EC_COMMAND_WRITE, 380 .wdata = wdata, .rdata = NULL, 381 .wlen = 2, .rlen = 0}; 382 383 return acpi_ec_transaction(ec, &t); 384 } 385 386 /* 387 * Externally callable EC access functions. For now, assume 1 EC only 388 */ 389 int ec_burst_enable(void) 390 { 391 if (!first_ec) 392 return -ENODEV; 393 return acpi_ec_burst_enable(first_ec); 394 } 395 396 EXPORT_SYMBOL(ec_burst_enable); 397 398 int ec_burst_disable(void) 399 { 400 if (!first_ec) 401 return -ENODEV; 402 return acpi_ec_burst_disable(first_ec); 403 } 404 405 EXPORT_SYMBOL(ec_burst_disable); 406 407 int ec_read(u8 addr, u8 * val) 408 { 409 int err; 410 u8 temp_data; 411 412 if (!first_ec) 413 return -ENODEV; 414 415 err = acpi_ec_read(first_ec, addr, &temp_data); 416 417 if (!err) { 418 *val = temp_data; 419 return 0; 420 } else 421 return err; 422 } 423 424 EXPORT_SYMBOL(ec_read); 425 426 int ec_write(u8 addr, u8 val) 427 { 428 int err; 429 430 if (!first_ec) 431 return -ENODEV; 432 433 err = acpi_ec_write(first_ec, addr, val); 434 435 return err; 436 } 437 438 EXPORT_SYMBOL(ec_write); 439 440 int ec_transaction(u8 command, 441 const u8 * wdata, unsigned wdata_len, 442 u8 * rdata, unsigned rdata_len, 443 int force_poll) 444 { 445 struct transaction t = {.command = command, 446 .wdata = wdata, .rdata = rdata, 447 .wlen = wdata_len, .rlen = rdata_len}; 448 if (!first_ec) 449 return -ENODEV; 450 451 return acpi_ec_transaction(first_ec, &t); 452 } 453 454 EXPORT_SYMBOL(ec_transaction); 455 456 static int acpi_ec_query_unlocked(struct acpi_ec *ec, u8 * data) 457 { 458 int result; 459 u8 d; 460 struct transaction t = {.command = ACPI_EC_COMMAND_QUERY, 461 .wdata = NULL, .rdata = &d, 462 .wlen = 0, .rlen = 1}; 463 if (!ec || !data) 464 return -EINVAL; 465 /* 466 * Query the EC to find out which _Qxx method we need to evaluate. 467 * Note that successful completion of the query causes the ACPI_EC_SCI 468 * bit to be cleared (and thus clearing the interrupt source). 469 */ 470 result = acpi_ec_transaction_unlocked(ec, &t); 471 if (result) 472 return result; 473 if (!d) 474 return -ENODATA; 475 *data = d; 476 return 0; 477 } 478 479 /* -------------------------------------------------------------------------- 480 Event Management 481 -------------------------------------------------------------------------- */ 482 int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit, 483 acpi_handle handle, acpi_ec_query_func func, 484 void *data) 485 { 486 struct acpi_ec_query_handler *handler = 487 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL); 488 if (!handler) 489 return -ENOMEM; 490 491 handler->query_bit = query_bit; 492 handler->handle = handle; 493 handler->func = func; 494 handler->data = data; 495 mutex_lock(&ec->lock); 496 list_add(&handler->node, &ec->list); 497 mutex_unlock(&ec->lock); 498 return 0; 499 } 500 501 EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler); 502 503 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit) 504 { 505 struct acpi_ec_query_handler *handler, *tmp; 506 mutex_lock(&ec->lock); 507 list_for_each_entry_safe(handler, tmp, &ec->list, node) { 508 if (query_bit == handler->query_bit) { 509 list_del(&handler->node); 510 kfree(handler); 511 } 512 } 513 mutex_unlock(&ec->lock); 514 } 515 516 EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler); 517 518 static void acpi_ec_run(void *cxt) 519 { 520 struct acpi_ec_query_handler *handler = cxt; 521 if (!handler) 522 return; 523 pr_debug(PREFIX "start query execution\n"); 524 if (handler->func) 525 handler->func(handler->data); 526 else if (handler->handle) 527 acpi_evaluate_object(handler->handle, NULL, NULL, NULL); 528 pr_debug(PREFIX "stop query execution\n"); 529 kfree(handler); 530 } 531 532 static int acpi_ec_sync_query(struct acpi_ec *ec) 533 { 534 u8 value = 0; 535 int status; 536 struct acpi_ec_query_handler *handler, *copy; 537 if ((status = acpi_ec_query_unlocked(ec, &value))) 538 return status; 539 list_for_each_entry(handler, &ec->list, node) { 540 if (value == handler->query_bit) { 541 /* have custom handler for this bit */ 542 copy = kmalloc(sizeof(*handler), GFP_KERNEL); 543 if (!copy) 544 return -ENOMEM; 545 memcpy(copy, handler, sizeof(*copy)); 546 pr_debug(PREFIX "push query execution (0x%2x) on queue\n", value); 547 return acpi_os_execute((copy->func) ? 548 OSL_NOTIFY_HANDLER : OSL_GPE_HANDLER, 549 acpi_ec_run, copy); 550 } 551 } 552 return 0; 553 } 554 555 static void acpi_ec_gpe_query(void *ec_cxt) 556 { 557 struct acpi_ec *ec = ec_cxt; 558 if (!ec) 559 return; 560 mutex_lock(&ec->lock); 561 acpi_ec_sync_query(ec); 562 mutex_unlock(&ec->lock); 563 } 564 565 static void acpi_ec_gpe_query(void *ec_cxt); 566 567 static int ec_check_sci(struct acpi_ec *ec, u8 state) 568 { 569 if (state & ACPI_EC_FLAG_SCI) { 570 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) { 571 pr_debug(PREFIX "push gpe query to the queue\n"); 572 return acpi_os_execute(OSL_NOTIFY_HANDLER, 573 acpi_ec_gpe_query, ec); 574 } 575 } 576 return 0; 577 } 578 579 static u32 acpi_ec_gpe_handler(void *data) 580 { 581 struct acpi_ec *ec = data; 582 583 pr_debug(PREFIX "~~~> interrupt\n"); 584 585 advance_transaction(ec, acpi_ec_read_status(ec)); 586 if (ec_transaction_done(ec) && 587 (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) == 0) { 588 wake_up(&ec->wait); 589 ec_check_sci(ec, acpi_ec_read_status(ec)); 590 } 591 return ACPI_INTERRUPT_HANDLED; 592 } 593 594 /* -------------------------------------------------------------------------- 595 Address Space Management 596 -------------------------------------------------------------------------- */ 597 598 static acpi_status 599 acpi_ec_space_handler(u32 function, acpi_physical_address address, 600 u32 bits, acpi_integer *value, 601 void *handler_context, void *region_context) 602 { 603 struct acpi_ec *ec = handler_context; 604 int result = 0, i; 605 u8 temp = 0; 606 607 if ((address > 0xFF) || !value || !handler_context) 608 return AE_BAD_PARAMETER; 609 610 if (function != ACPI_READ && function != ACPI_WRITE) 611 return AE_BAD_PARAMETER; 612 613 if (bits != 8 && acpi_strict) 614 return AE_BAD_PARAMETER; 615 616 if (EC_FLAGS_MSI) 617 acpi_ec_burst_enable(ec); 618 619 if (function == ACPI_READ) { 620 result = acpi_ec_read(ec, address, &temp); 621 *value = temp; 622 } else { 623 temp = 0xff & (*value); 624 result = acpi_ec_write(ec, address, temp); 625 } 626 627 for (i = 8; unlikely(bits - i > 0); i += 8) { 628 ++address; 629 if (function == ACPI_READ) { 630 result = acpi_ec_read(ec, address, &temp); 631 (*value) |= ((acpi_integer)temp) << i; 632 } else { 633 temp = 0xff & ((*value) >> i); 634 result = acpi_ec_write(ec, address, temp); 635 } 636 } 637 638 if (EC_FLAGS_MSI) 639 acpi_ec_burst_disable(ec); 640 641 switch (result) { 642 case -EINVAL: 643 return AE_BAD_PARAMETER; 644 break; 645 case -ENODEV: 646 return AE_NOT_FOUND; 647 break; 648 case -ETIME: 649 return AE_TIME; 650 break; 651 default: 652 return AE_OK; 653 } 654 } 655 656 /* -------------------------------------------------------------------------- 657 FS Interface (/proc) 658 -------------------------------------------------------------------------- */ 659 660 static struct proc_dir_entry *acpi_ec_dir; 661 662 static int acpi_ec_read_info(struct seq_file *seq, void *offset) 663 { 664 struct acpi_ec *ec = seq->private; 665 666 if (!ec) 667 goto end; 668 669 seq_printf(seq, "gpe:\t\t\t0x%02x\n", (u32) ec->gpe); 670 seq_printf(seq, "ports:\t\t\t0x%02x, 0x%02x\n", 671 (unsigned)ec->command_addr, (unsigned)ec->data_addr); 672 seq_printf(seq, "use global lock:\t%s\n", 673 ec->global_lock ? "yes" : "no"); 674 end: 675 return 0; 676 } 677 678 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file) 679 { 680 return single_open(file, acpi_ec_read_info, PDE(inode)->data); 681 } 682 683 static const struct file_operations acpi_ec_info_ops = { 684 .open = acpi_ec_info_open_fs, 685 .read = seq_read, 686 .llseek = seq_lseek, 687 .release = single_release, 688 .owner = THIS_MODULE, 689 }; 690 691 static int acpi_ec_add_fs(struct acpi_device *device) 692 { 693 struct proc_dir_entry *entry = NULL; 694 695 if (!acpi_device_dir(device)) { 696 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 697 acpi_ec_dir); 698 if (!acpi_device_dir(device)) 699 return -ENODEV; 700 } 701 702 entry = proc_create_data(ACPI_EC_FILE_INFO, S_IRUGO, 703 acpi_device_dir(device), 704 &acpi_ec_info_ops, acpi_driver_data(device)); 705 if (!entry) 706 return -ENODEV; 707 return 0; 708 } 709 710 static int acpi_ec_remove_fs(struct acpi_device *device) 711 { 712 713 if (acpi_device_dir(device)) { 714 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device)); 715 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir); 716 acpi_device_dir(device) = NULL; 717 } 718 719 return 0; 720 } 721 722 /* -------------------------------------------------------------------------- 723 Driver Interface 724 -------------------------------------------------------------------------- */ 725 static acpi_status 726 ec_parse_io_ports(struct acpi_resource *resource, void *context); 727 728 static struct acpi_ec *make_acpi_ec(void) 729 { 730 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL); 731 if (!ec) 732 return NULL; 733 ec->flags = 1 << EC_FLAGS_QUERY_PENDING; 734 mutex_init(&ec->lock); 735 init_waitqueue_head(&ec->wait); 736 INIT_LIST_HEAD(&ec->list); 737 spin_lock_init(&ec->curr_lock); 738 return ec; 739 } 740 741 static acpi_status 742 acpi_ec_register_query_methods(acpi_handle handle, u32 level, 743 void *context, void **return_value) 744 { 745 char node_name[5]; 746 struct acpi_buffer buffer = { sizeof(node_name), node_name }; 747 struct acpi_ec *ec = context; 748 int value = 0; 749 acpi_status status; 750 751 status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer); 752 753 if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1) { 754 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL); 755 } 756 return AE_OK; 757 } 758 759 static acpi_status 760 ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval) 761 { 762 acpi_status status; 763 unsigned long long tmp = 0; 764 765 struct acpi_ec *ec = context; 766 767 /* clear addr values, ec_parse_io_ports depend on it */ 768 ec->command_addr = ec->data_addr = 0; 769 770 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 771 ec_parse_io_ports, ec); 772 if (ACPI_FAILURE(status)) 773 return status; 774 775 /* Get GPE bit assignment (EC events). */ 776 /* TODO: Add support for _GPE returning a package */ 777 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp); 778 if (ACPI_FAILURE(status)) 779 return status; 780 ec->gpe = tmp; 781 /* Use the global lock for all EC transactions? */ 782 tmp = 0; 783 acpi_evaluate_integer(handle, "_GLK", NULL, &tmp); 784 ec->global_lock = tmp; 785 ec->handle = handle; 786 return AE_CTRL_TERMINATE; 787 } 788 789 static int ec_install_handlers(struct acpi_ec *ec) 790 { 791 acpi_status status; 792 if (test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags)) 793 return 0; 794 status = acpi_install_gpe_handler(NULL, ec->gpe, 795 ACPI_GPE_EDGE_TRIGGERED, 796 &acpi_ec_gpe_handler, ec); 797 if (ACPI_FAILURE(status)) 798 return -ENODEV; 799 800 acpi_enable_gpe(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME); 801 status = acpi_install_address_space_handler(ec->handle, 802 ACPI_ADR_SPACE_EC, 803 &acpi_ec_space_handler, 804 NULL, ec); 805 if (ACPI_FAILURE(status)) { 806 if (status == AE_NOT_FOUND) { 807 /* 808 * Maybe OS fails in evaluating the _REG object. 809 * The AE_NOT_FOUND error will be ignored and OS 810 * continue to initialize EC. 811 */ 812 printk(KERN_ERR "Fail in evaluating the _REG object" 813 " of EC device. Broken bios is suspected.\n"); 814 } else { 815 acpi_remove_gpe_handler(NULL, ec->gpe, 816 &acpi_ec_gpe_handler); 817 acpi_disable_gpe(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME); 818 return -ENODEV; 819 } 820 } 821 822 set_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags); 823 return 0; 824 } 825 826 static void ec_remove_handlers(struct acpi_ec *ec) 827 { 828 acpi_disable_gpe(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME); 829 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle, 830 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler))) 831 pr_err(PREFIX "failed to remove space handler\n"); 832 if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe, 833 &acpi_ec_gpe_handler))) 834 pr_err(PREFIX "failed to remove gpe handler\n"); 835 clear_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags); 836 } 837 838 static int acpi_ec_add(struct acpi_device *device) 839 { 840 struct acpi_ec *ec = NULL; 841 int ret; 842 843 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME); 844 strcpy(acpi_device_class(device), ACPI_EC_CLASS); 845 846 /* Check for boot EC */ 847 if (boot_ec && 848 (boot_ec->handle == device->handle || 849 boot_ec->handle == ACPI_ROOT_OBJECT)) { 850 ec = boot_ec; 851 boot_ec = NULL; 852 } else { 853 ec = make_acpi_ec(); 854 if (!ec) 855 return -ENOMEM; 856 } 857 if (ec_parse_device(device->handle, 0, ec, NULL) != 858 AE_CTRL_TERMINATE) { 859 kfree(ec); 860 return -EINVAL; 861 } 862 863 ec->handle = device->handle; 864 865 /* Find and register all query methods */ 866 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1, 867 acpi_ec_register_query_methods, NULL, ec, NULL); 868 869 if (!first_ec) 870 first_ec = ec; 871 device->driver_data = ec; 872 acpi_ec_add_fs(device); 873 pr_info(PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n", 874 ec->gpe, ec->command_addr, ec->data_addr); 875 876 ret = ec_install_handlers(ec); 877 878 /* EC is fully operational, allow queries */ 879 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags); 880 return ret; 881 } 882 883 static int acpi_ec_remove(struct acpi_device *device, int type) 884 { 885 struct acpi_ec *ec; 886 struct acpi_ec_query_handler *handler, *tmp; 887 888 if (!device) 889 return -EINVAL; 890 891 ec = acpi_driver_data(device); 892 ec_remove_handlers(ec); 893 mutex_lock(&ec->lock); 894 list_for_each_entry_safe(handler, tmp, &ec->list, node) { 895 list_del(&handler->node); 896 kfree(handler); 897 } 898 mutex_unlock(&ec->lock); 899 acpi_ec_remove_fs(device); 900 device->driver_data = NULL; 901 if (ec == first_ec) 902 first_ec = NULL; 903 kfree(ec); 904 return 0; 905 } 906 907 static acpi_status 908 ec_parse_io_ports(struct acpi_resource *resource, void *context) 909 { 910 struct acpi_ec *ec = context; 911 912 if (resource->type != ACPI_RESOURCE_TYPE_IO) 913 return AE_OK; 914 915 /* 916 * The first address region returned is the data port, and 917 * the second address region returned is the status/command 918 * port. 919 */ 920 if (ec->data_addr == 0) 921 ec->data_addr = resource->data.io.minimum; 922 else if (ec->command_addr == 0) 923 ec->command_addr = resource->data.io.minimum; 924 else 925 return AE_CTRL_TERMINATE; 926 927 return AE_OK; 928 } 929 930 int __init acpi_boot_ec_enable(void) 931 { 932 if (!boot_ec || test_bit(EC_FLAGS_HANDLERS_INSTALLED, &boot_ec->flags)) 933 return 0; 934 if (!ec_install_handlers(boot_ec)) { 935 first_ec = boot_ec; 936 return 0; 937 } 938 return -EFAULT; 939 } 940 941 static const struct acpi_device_id ec_device_ids[] = { 942 {"PNP0C09", 0}, 943 {"", 0}, 944 }; 945 946 /* Some BIOS do not survive early DSDT scan, skip it */ 947 static int ec_skip_dsdt_scan(const struct dmi_system_id *id) 948 { 949 EC_FLAGS_SKIP_DSDT_SCAN = 1; 950 return 0; 951 } 952 953 /* ASUStek often supplies us with broken ECDT, validate it */ 954 static int ec_validate_ecdt(const struct dmi_system_id *id) 955 { 956 EC_FLAGS_VALIDATE_ECDT = 1; 957 return 0; 958 } 959 960 /* MSI EC needs special treatment, enable it */ 961 static int ec_flag_msi(const struct dmi_system_id *id) 962 { 963 printk(KERN_DEBUG PREFIX "Detected MSI hardware, enabling workarounds.\n"); 964 EC_FLAGS_MSI = 1; 965 EC_FLAGS_VALIDATE_ECDT = 1; 966 return 0; 967 } 968 969 static struct dmi_system_id __initdata ec_dmi_table[] = { 970 { 971 ec_skip_dsdt_scan, "Compal JFL92", { 972 DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"), 973 DMI_MATCH(DMI_BOARD_NAME, "JFL92") }, NULL}, 974 { 975 ec_flag_msi, "MSI hardware", { 976 DMI_MATCH(DMI_BIOS_VENDOR, "Micro-Star")}, NULL}, 977 { 978 ec_flag_msi, "MSI hardware", { 979 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star")}, NULL}, 980 { 981 ec_flag_msi, "MSI hardware", { 982 DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-Star")}, NULL}, 983 { 984 ec_validate_ecdt, "ASUS hardware", { 985 DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL}, 986 {}, 987 }; 988 989 990 int __init acpi_ec_ecdt_probe(void) 991 { 992 acpi_status status; 993 struct acpi_ec *saved_ec = NULL; 994 struct acpi_table_ecdt *ecdt_ptr; 995 996 boot_ec = make_acpi_ec(); 997 if (!boot_ec) 998 return -ENOMEM; 999 /* 1000 * Generate a boot ec context 1001 */ 1002 dmi_check_system(ec_dmi_table); 1003 status = acpi_get_table(ACPI_SIG_ECDT, 1, 1004 (struct acpi_table_header **)&ecdt_ptr); 1005 if (ACPI_SUCCESS(status)) { 1006 pr_info(PREFIX "EC description table is found, configuring boot EC\n"); 1007 boot_ec->command_addr = ecdt_ptr->control.address; 1008 boot_ec->data_addr = ecdt_ptr->data.address; 1009 boot_ec->gpe = ecdt_ptr->gpe; 1010 boot_ec->handle = ACPI_ROOT_OBJECT; 1011 acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, &boot_ec->handle); 1012 /* Don't trust ECDT, which comes from ASUSTek */ 1013 if (!EC_FLAGS_VALIDATE_ECDT) 1014 goto install; 1015 saved_ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL); 1016 if (!saved_ec) 1017 return -ENOMEM; 1018 memcpy(saved_ec, boot_ec, sizeof(struct acpi_ec)); 1019 /* fall through */ 1020 } 1021 1022 if (EC_FLAGS_SKIP_DSDT_SCAN) 1023 return -ENODEV; 1024 1025 /* This workaround is needed only on some broken machines, 1026 * which require early EC, but fail to provide ECDT */ 1027 printk(KERN_DEBUG PREFIX "Look up EC in DSDT\n"); 1028 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, 1029 boot_ec, NULL); 1030 /* Check that acpi_get_devices actually find something */ 1031 if (ACPI_FAILURE(status) || !boot_ec->handle) 1032 goto error; 1033 if (saved_ec) { 1034 /* try to find good ECDT from ASUSTek */ 1035 if (saved_ec->command_addr != boot_ec->command_addr || 1036 saved_ec->data_addr != boot_ec->data_addr || 1037 saved_ec->gpe != boot_ec->gpe || 1038 saved_ec->handle != boot_ec->handle) 1039 pr_info(PREFIX "ASUSTek keeps feeding us with broken " 1040 "ECDT tables, which are very hard to workaround. " 1041 "Trying to use DSDT EC info instead. Please send " 1042 "output of acpidump to linux-acpi@vger.kernel.org\n"); 1043 kfree(saved_ec); 1044 saved_ec = NULL; 1045 } else { 1046 /* We really need to limit this workaround, the only ASUS, 1047 * which needs it, has fake EC._INI method, so use it as flag. 1048 * Keep boot_ec struct as it will be needed soon. 1049 */ 1050 acpi_handle dummy; 1051 if (!dmi_name_in_vendors("ASUS") || 1052 ACPI_FAILURE(acpi_get_handle(boot_ec->handle, "_INI", 1053 &dummy))) 1054 return -ENODEV; 1055 } 1056 install: 1057 if (!ec_install_handlers(boot_ec)) { 1058 first_ec = boot_ec; 1059 return 0; 1060 } 1061 error: 1062 kfree(boot_ec); 1063 boot_ec = NULL; 1064 return -ENODEV; 1065 } 1066 1067 static int acpi_ec_suspend(struct acpi_device *device, pm_message_t state) 1068 { 1069 struct acpi_ec *ec = acpi_driver_data(device); 1070 /* Stop using the GPE, but keep it reference counted. */ 1071 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE); 1072 return 0; 1073 } 1074 1075 static int acpi_ec_resume(struct acpi_device *device) 1076 { 1077 struct acpi_ec *ec = acpi_driver_data(device); 1078 /* Enable the GPE again, but don't reference count it once more. */ 1079 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE); 1080 return 0; 1081 } 1082 1083 static struct acpi_driver acpi_ec_driver = { 1084 .name = "ec", 1085 .class = ACPI_EC_CLASS, 1086 .ids = ec_device_ids, 1087 .ops = { 1088 .add = acpi_ec_add, 1089 .remove = acpi_ec_remove, 1090 .suspend = acpi_ec_suspend, 1091 .resume = acpi_ec_resume, 1092 }, 1093 }; 1094 1095 int __init acpi_ec_init(void) 1096 { 1097 int result = 0; 1098 1099 acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir); 1100 if (!acpi_ec_dir) 1101 return -ENODEV; 1102 1103 /* Now register the driver for the EC */ 1104 result = acpi_bus_register_driver(&acpi_ec_driver); 1105 if (result < 0) { 1106 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 1107 return -ENODEV; 1108 } 1109 1110 return result; 1111 } 1112 1113 /* EC driver currently not unloadable */ 1114 #if 0 1115 static void __exit acpi_ec_exit(void) 1116 { 1117 1118 acpi_bus_unregister_driver(&acpi_ec_driver); 1119 1120 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 1121 1122 return; 1123 } 1124 #endif /* 0 */ 1125