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