1/* 2 * ec.c - ACPI Embedded Controller Driver (v3) 3 * 4 * Copyright (C) 2001-2015 Intel Corporation 5 * Author: 2014, 2015 Lv Zheng <lv.zheng@intel.com> 6 * 2006, 2007 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com> 7 * 2006 Denis Sadykov <denis.m.sadykov@intel.com> 8 * 2004 Luming Yu <luming.yu@intel.com> 9 * 2001, 2002 Andy Grover <andrew.grover@intel.com> 10 * 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 11 * Copyright (C) 2008 Alexey Starikovskiy <astarikovskiy@suse.de> 12 * 13 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 14 * 15 * This program is free software; you can redistribute it and/or modify 16 * it under the terms of the GNU General Public License as published by 17 * the Free Software Foundation; either version 2 of the License, or (at 18 * your option) any later version. 19 * 20 * This program is distributed in the hope that it will be useful, but 21 * WITHOUT ANY WARRANTY; without even the implied warranty of 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 23 * General Public License for more details. 24 * 25 * You should have received a copy of the GNU General Public License along 26 * with this program; if not, write to the Free Software Foundation, Inc., 27 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 28 * 29 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 30 */ 31 32/* Uncomment next line to get verbose printout */ 33/* #define DEBUG */ 34#define pr_fmt(fmt) "ACPI : EC: " fmt 35 36#include <linux/kernel.h> 37#include <linux/module.h> 38#include <linux/init.h> 39#include <linux/types.h> 40#include <linux/delay.h> 41#include <linux/interrupt.h> 42#include <linux/list.h> 43#include <linux/spinlock.h> 44#include <linux/slab.h> 45#include <linux/acpi.h> 46#include <linux/dmi.h> 47#include <asm/io.h> 48 49#include "internal.h" 50 51#define ACPI_EC_CLASS "embedded_controller" 52#define ACPI_EC_DEVICE_NAME "Embedded Controller" 53#define ACPI_EC_FILE_INFO "info" 54 55/* EC status register */ 56#define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */ 57#define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */ 58#define ACPI_EC_FLAG_CMD 0x08 /* Input buffer contains a command */ 59#define ACPI_EC_FLAG_BURST 0x10 /* burst mode */ 60#define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */ 61 62/* EC commands */ 63enum ec_command { 64 ACPI_EC_COMMAND_READ = 0x80, 65 ACPI_EC_COMMAND_WRITE = 0x81, 66 ACPI_EC_BURST_ENABLE = 0x82, 67 ACPI_EC_BURST_DISABLE = 0x83, 68 ACPI_EC_COMMAND_QUERY = 0x84, 69}; 70 71#define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */ 72#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */ 73#define ACPI_EC_MSI_UDELAY 550 /* Wait 550us for MSI EC */ 74#define ACPI_EC_UDELAY_POLL 1000 /* Wait 1ms for EC transaction polling */ 75#define ACPI_EC_CLEAR_MAX 100 /* Maximum number of events to query 76 * when trying to clear the EC */ 77 78enum { 79 EC_FLAGS_QUERY_PENDING, /* Query is pending */ 80 EC_FLAGS_HANDLERS_INSTALLED, /* Handlers for GPE and 81 * OpReg are installed */ 82 EC_FLAGS_STARTED, /* Driver is started */ 83 EC_FLAGS_STOPPED, /* Driver is stopped */ 84 EC_FLAGS_COMMAND_STORM, /* GPE storms occurred to the 85 * current command processing */ 86}; 87 88#define ACPI_EC_COMMAND_POLL 0x01 /* Available for command byte */ 89#define ACPI_EC_COMMAND_COMPLETE 0x02 /* Completed last byte */ 90 91/* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */ 92static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY; 93module_param(ec_delay, uint, 0644); 94MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes"); 95 96/* 97 * If the number of false interrupts per one transaction exceeds 98 * this threshold, will think there is a GPE storm happened and 99 * will disable the GPE for normal transaction. 100 */ 101static unsigned int ec_storm_threshold __read_mostly = 8; 102module_param(ec_storm_threshold, uint, 0644); 103MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm"); 104 105struct acpi_ec_query_handler { 106 struct list_head node; 107 acpi_ec_query_func func; 108 acpi_handle handle; 109 void *data; 110 u8 query_bit; 111 struct kref kref; 112}; 113 114struct transaction { 115 const u8 *wdata; 116 u8 *rdata; 117 unsigned short irq_count; 118 u8 command; 119 u8 wi; 120 u8 ri; 121 u8 wlen; 122 u8 rlen; 123 u8 flags; 124 unsigned long timestamp; 125}; 126 127static int acpi_ec_query(struct acpi_ec *ec, u8 *data); 128static void advance_transaction(struct acpi_ec *ec); 129 130struct acpi_ec *boot_ec, *first_ec; 131EXPORT_SYMBOL(first_ec); 132 133static int EC_FLAGS_MSI; /* Out-of-spec MSI controller */ 134static int EC_FLAGS_VALIDATE_ECDT; /* ASUStec ECDTs need to be validated */ 135static int EC_FLAGS_SKIP_DSDT_SCAN; /* Not all BIOS survive early DSDT scan */ 136static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */ 137static int EC_FLAGS_QUERY_HANDSHAKE; /* Needs QR_EC issued when SCI_EVT set */ 138 139/* -------------------------------------------------------------------------- 140 * Logging/Debugging 141 * -------------------------------------------------------------------------- */ 142 143/* 144 * Splitters used by the developers to track the boundary of the EC 145 * handling processes. 146 */ 147#ifdef DEBUG 148#define EC_DBG_SEP " " 149#define EC_DBG_DRV "+++++" 150#define EC_DBG_STM "=====" 151#define EC_DBG_REQ "*****" 152#define EC_DBG_EVT "#####" 153#else 154#define EC_DBG_SEP "" 155#define EC_DBG_DRV 156#define EC_DBG_STM 157#define EC_DBG_REQ 158#define EC_DBG_EVT 159#endif 160 161#define ec_log_raw(fmt, ...) \ 162 pr_info(fmt "\n", ##__VA_ARGS__) 163#define ec_dbg_raw(fmt, ...) \ 164 pr_debug(fmt "\n", ##__VA_ARGS__) 165#define ec_log(filter, fmt, ...) \ 166 ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__) 167#define ec_dbg(filter, fmt, ...) \ 168 ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__) 169 170#define ec_log_drv(fmt, ...) \ 171 ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__) 172#define ec_dbg_drv(fmt, ...) \ 173 ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__) 174#define ec_dbg_stm(fmt, ...) \ 175 ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__) 176#define ec_dbg_req(fmt, ...) \ 177 ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__) 178#define ec_dbg_evt(fmt, ...) \ 179 ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__) 180#define ec_dbg_ref(ec, fmt, ...) \ 181 ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__) 182 183/* -------------------------------------------------------------------------- 184 * Device Flags 185 * -------------------------------------------------------------------------- */ 186 187static bool acpi_ec_started(struct acpi_ec *ec) 188{ 189 return test_bit(EC_FLAGS_STARTED, &ec->flags) && 190 !test_bit(EC_FLAGS_STOPPED, &ec->flags); 191} 192 193static bool acpi_ec_flushed(struct acpi_ec *ec) 194{ 195 return ec->reference_count == 1; 196} 197 198/* -------------------------------------------------------------------------- 199 * EC Registers 200 * -------------------------------------------------------------------------- */ 201 202static inline u8 acpi_ec_read_status(struct acpi_ec *ec) 203{ 204 u8 x = inb(ec->command_addr); 205 206 ec_dbg_raw("EC_SC(R) = 0x%2.2x " 207 "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d", 208 x, 209 !!(x & ACPI_EC_FLAG_SCI), 210 !!(x & ACPI_EC_FLAG_BURST), 211 !!(x & ACPI_EC_FLAG_CMD), 212 !!(x & ACPI_EC_FLAG_IBF), 213 !!(x & ACPI_EC_FLAG_OBF)); 214 return x; 215} 216 217static inline u8 acpi_ec_read_data(struct acpi_ec *ec) 218{ 219 u8 x = inb(ec->data_addr); 220 221 ec->curr->timestamp = jiffies; 222 ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x); 223 return x; 224} 225 226static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command) 227{ 228 ec_dbg_raw("EC_SC(W) = 0x%2.2x", command); 229 outb(command, ec->command_addr); 230 ec->curr->timestamp = jiffies; 231} 232 233static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data) 234{ 235 ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data); 236 outb(data, ec->data_addr); 237 ec->curr->timestamp = jiffies; 238} 239 240#ifdef DEBUG 241static const char *acpi_ec_cmd_string(u8 cmd) 242{ 243 switch (cmd) { 244 case 0x80: 245 return "RD_EC"; 246 case 0x81: 247 return "WR_EC"; 248 case 0x82: 249 return "BE_EC"; 250 case 0x83: 251 return "BD_EC"; 252 case 0x84: 253 return "QR_EC"; 254 } 255 return "UNKNOWN"; 256} 257#else 258#define acpi_ec_cmd_string(cmd) "UNDEF" 259#endif 260 261/* -------------------------------------------------------------------------- 262 * GPE Registers 263 * -------------------------------------------------------------------------- */ 264 265static inline bool acpi_ec_is_gpe_raised(struct acpi_ec *ec) 266{ 267 acpi_event_status gpe_status = 0; 268 269 (void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status); 270 return (gpe_status & ACPI_EVENT_FLAG_SET) ? true : false; 271} 272 273static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open) 274{ 275 if (open) 276 acpi_enable_gpe(NULL, ec->gpe); 277 else { 278 BUG_ON(ec->reference_count < 1); 279 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE); 280 } 281 if (acpi_ec_is_gpe_raised(ec)) { 282 /* 283 * On some platforms, EN=1 writes cannot trigger GPE. So 284 * software need to manually trigger a pseudo GPE event on 285 * EN=1 writes. 286 */ 287 ec_dbg_raw("Polling quirk"); 288 advance_transaction(ec); 289 } 290} 291 292static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close) 293{ 294 if (close) 295 acpi_disable_gpe(NULL, ec->gpe); 296 else { 297 BUG_ON(ec->reference_count < 1); 298 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE); 299 } 300} 301 302static inline void acpi_ec_clear_gpe(struct acpi_ec *ec) 303{ 304 /* 305 * GPE STS is a W1C register, which means: 306 * 1. Software can clear it without worrying about clearing other 307 * GPEs' STS bits when the hardware sets them in parallel. 308 * 2. As long as software can ensure only clearing it when it is 309 * set, hardware won't set it in parallel. 310 * So software can clear GPE in any contexts. 311 * Warning: do not move the check into advance_transaction() as the 312 * EC commands will be sent without GPE raised. 313 */ 314 if (!acpi_ec_is_gpe_raised(ec)) 315 return; 316 acpi_clear_gpe(NULL, ec->gpe); 317} 318 319/* -------------------------------------------------------------------------- 320 * Transaction Management 321 * -------------------------------------------------------------------------- */ 322 323static void acpi_ec_submit_request(struct acpi_ec *ec) 324{ 325 ec->reference_count++; 326 if (ec->reference_count == 1) 327 acpi_ec_enable_gpe(ec, true); 328} 329 330static void acpi_ec_complete_request(struct acpi_ec *ec) 331{ 332 bool flushed = false; 333 334 ec->reference_count--; 335 if (ec->reference_count == 0) 336 acpi_ec_disable_gpe(ec, true); 337 flushed = acpi_ec_flushed(ec); 338 if (flushed) 339 wake_up(&ec->wait); 340} 341 342static void acpi_ec_set_storm(struct acpi_ec *ec, u8 flag) 343{ 344 if (!test_bit(flag, &ec->flags)) { 345 acpi_ec_disable_gpe(ec, false); 346 ec_dbg_drv("Polling enabled"); 347 set_bit(flag, &ec->flags); 348 } 349} 350 351static void acpi_ec_clear_storm(struct acpi_ec *ec, u8 flag) 352{ 353 if (test_bit(flag, &ec->flags)) { 354 clear_bit(flag, &ec->flags); 355 acpi_ec_enable_gpe(ec, false); 356 ec_dbg_drv("Polling disabled"); 357 } 358} 359 360/* 361 * acpi_ec_submit_flushable_request() - Increase the reference count unless 362 * the flush operation is not in 363 * progress 364 * @ec: the EC device 365 * 366 * This function must be used before taking a new action that should hold 367 * the reference count. If this function returns false, then the action 368 * must be discarded or it will prevent the flush operation from being 369 * completed. 370 */ 371static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec) 372{ 373 if (!acpi_ec_started(ec)) 374 return false; 375 acpi_ec_submit_request(ec); 376 return true; 377} 378 379static void acpi_ec_submit_query(struct acpi_ec *ec) 380{ 381 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) { 382 ec_dbg_req("Event started"); 383 schedule_work(&ec->work); 384 } 385} 386 387static void acpi_ec_complete_query(struct acpi_ec *ec) 388{ 389 if (ec->curr->command == ACPI_EC_COMMAND_QUERY) { 390 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags); 391 ec_dbg_req("Event stopped"); 392 } 393} 394 395static int ec_transaction_completed(struct acpi_ec *ec) 396{ 397 unsigned long flags; 398 int ret = 0; 399 400 spin_lock_irqsave(&ec->lock, flags); 401 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE)) 402 ret = 1; 403 spin_unlock_irqrestore(&ec->lock, flags); 404 return ret; 405} 406 407static void advance_transaction(struct acpi_ec *ec) 408{ 409 struct transaction *t; 410 u8 status; 411 bool wakeup = false; 412 413 ec_dbg_stm("%s (%d)", in_interrupt() ? "IRQ" : "TASK", 414 smp_processor_id()); 415 /* 416 * By always clearing STS before handling all indications, we can 417 * ensure a hardware STS 0->1 change after this clearing can always 418 * trigger a GPE interrupt. 419 */ 420 acpi_ec_clear_gpe(ec); 421 status = acpi_ec_read_status(ec); 422 t = ec->curr; 423 if (!t) 424 goto err; 425 if (t->flags & ACPI_EC_COMMAND_POLL) { 426 if (t->wlen > t->wi) { 427 if ((status & ACPI_EC_FLAG_IBF) == 0) 428 acpi_ec_write_data(ec, t->wdata[t->wi++]); 429 else 430 goto err; 431 } else if (t->rlen > t->ri) { 432 if ((status & ACPI_EC_FLAG_OBF) == 1) { 433 t->rdata[t->ri++] = acpi_ec_read_data(ec); 434 if (t->rlen == t->ri) { 435 t->flags |= ACPI_EC_COMMAND_COMPLETE; 436 if (t->command == ACPI_EC_COMMAND_QUERY) 437 ec_dbg_req("Command(%s) hardware completion", 438 acpi_ec_cmd_string(t->command)); 439 wakeup = true; 440 } 441 } else 442 goto err; 443 } else if (t->wlen == t->wi && 444 (status & ACPI_EC_FLAG_IBF) == 0) { 445 t->flags |= ACPI_EC_COMMAND_COMPLETE; 446 wakeup = true; 447 } 448 goto out; 449 } else { 450 if (EC_FLAGS_QUERY_HANDSHAKE && 451 !(status & ACPI_EC_FLAG_SCI) && 452 (t->command == ACPI_EC_COMMAND_QUERY)) { 453 t->flags |= ACPI_EC_COMMAND_POLL; 454 acpi_ec_complete_query(ec); 455 t->rdata[t->ri++] = 0x00; 456 t->flags |= ACPI_EC_COMMAND_COMPLETE; 457 ec_dbg_req("Command(%s) software completion", 458 acpi_ec_cmd_string(t->command)); 459 wakeup = true; 460 } else if ((status & ACPI_EC_FLAG_IBF) == 0) { 461 acpi_ec_write_cmd(ec, t->command); 462 t->flags |= ACPI_EC_COMMAND_POLL; 463 acpi_ec_complete_query(ec); 464 } else 465 goto err; 466 goto out; 467 } 468err: 469 /* 470 * If SCI bit is set, then don't think it's a false IRQ 471 * otherwise will take a not handled IRQ as a false one. 472 */ 473 if (!(status & ACPI_EC_FLAG_SCI)) { 474 if (in_interrupt() && t) { 475 if (t->irq_count < ec_storm_threshold) 476 ++t->irq_count; 477 /* Allow triggering on 0 threshold */ 478 if (t->irq_count == ec_storm_threshold) 479 acpi_ec_set_storm(ec, EC_FLAGS_COMMAND_STORM); 480 } 481 } 482out: 483 if (status & ACPI_EC_FLAG_SCI) 484 acpi_ec_submit_query(ec); 485 if (wakeup && in_interrupt()) 486 wake_up(&ec->wait); 487} 488 489static void start_transaction(struct acpi_ec *ec) 490{ 491 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0; 492 ec->curr->flags = 0; 493 ec->curr->timestamp = jiffies; 494 advance_transaction(ec); 495} 496 497static int ec_poll(struct acpi_ec *ec) 498{ 499 unsigned long flags; 500 int repeat = 5; /* number of command restarts */ 501 502 while (repeat--) { 503 unsigned long delay = jiffies + 504 msecs_to_jiffies(ec_delay); 505 unsigned long usecs = ACPI_EC_UDELAY_POLL; 506 do { 507 /* don't sleep with disabled interrupts */ 508 if (EC_FLAGS_MSI || irqs_disabled()) { 509 usecs = ACPI_EC_MSI_UDELAY; 510 udelay(usecs); 511 if (ec_transaction_completed(ec)) 512 return 0; 513 } else { 514 if (wait_event_timeout(ec->wait, 515 ec_transaction_completed(ec), 516 usecs_to_jiffies(usecs))) 517 return 0; 518 } 519 spin_lock_irqsave(&ec->lock, flags); 520 if (time_after(jiffies, 521 ec->curr->timestamp + 522 usecs_to_jiffies(usecs))) 523 advance_transaction(ec); 524 spin_unlock_irqrestore(&ec->lock, flags); 525 } while (time_before(jiffies, delay)); 526 pr_debug("controller reset, restart transaction\n"); 527 spin_lock_irqsave(&ec->lock, flags); 528 start_transaction(ec); 529 spin_unlock_irqrestore(&ec->lock, flags); 530 } 531 return -ETIME; 532} 533 534static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, 535 struct transaction *t) 536{ 537 unsigned long tmp; 538 int ret = 0; 539 540 if (EC_FLAGS_MSI) 541 udelay(ACPI_EC_MSI_UDELAY); 542 /* start transaction */ 543 spin_lock_irqsave(&ec->lock, tmp); 544 /* Enable GPE for command processing (IBF=0/OBF=1) */ 545 if (!acpi_ec_submit_flushable_request(ec)) { 546 ret = -EINVAL; 547 goto unlock; 548 } 549 ec_dbg_ref(ec, "Increase command"); 550 /* following two actions should be kept atomic */ 551 ec->curr = t; 552 ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command)); 553 start_transaction(ec); 554 spin_unlock_irqrestore(&ec->lock, tmp); 555 ret = ec_poll(ec); 556 spin_lock_irqsave(&ec->lock, tmp); 557 if (t->irq_count == ec_storm_threshold) 558 acpi_ec_clear_storm(ec, EC_FLAGS_COMMAND_STORM); 559 ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command)); 560 ec->curr = NULL; 561 /* Disable GPE for command processing (IBF=0/OBF=1) */ 562 acpi_ec_complete_request(ec); 563 ec_dbg_ref(ec, "Decrease command"); 564unlock: 565 spin_unlock_irqrestore(&ec->lock, tmp); 566 return ret; 567} 568 569static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t) 570{ 571 int status; 572 u32 glk; 573 574 if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata)) 575 return -EINVAL; 576 if (t->rdata) 577 memset(t->rdata, 0, t->rlen); 578 mutex_lock(&ec->mutex); 579 if (ec->global_lock) { 580 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 581 if (ACPI_FAILURE(status)) { 582 status = -ENODEV; 583 goto unlock; 584 } 585 } 586 587 status = acpi_ec_transaction_unlocked(ec, t); 588 589 if (test_bit(EC_FLAGS_COMMAND_STORM, &ec->flags)) 590 msleep(1); 591 if (ec->global_lock) 592 acpi_release_global_lock(glk); 593unlock: 594 mutex_unlock(&ec->mutex); 595 return status; 596} 597 598static int acpi_ec_burst_enable(struct acpi_ec *ec) 599{ 600 u8 d; 601 struct transaction t = {.command = ACPI_EC_BURST_ENABLE, 602 .wdata = NULL, .rdata = &d, 603 .wlen = 0, .rlen = 1}; 604 605 return acpi_ec_transaction(ec, &t); 606} 607 608static int acpi_ec_burst_disable(struct acpi_ec *ec) 609{ 610 struct transaction t = {.command = ACPI_EC_BURST_DISABLE, 611 .wdata = NULL, .rdata = NULL, 612 .wlen = 0, .rlen = 0}; 613 614 return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ? 615 acpi_ec_transaction(ec, &t) : 0; 616} 617 618static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data) 619{ 620 int result; 621 u8 d; 622 struct transaction t = {.command = ACPI_EC_COMMAND_READ, 623 .wdata = &address, .rdata = &d, 624 .wlen = 1, .rlen = 1}; 625 626 result = acpi_ec_transaction(ec, &t); 627 *data = d; 628 return result; 629} 630 631static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data) 632{ 633 u8 wdata[2] = { address, data }; 634 struct transaction t = {.command = ACPI_EC_COMMAND_WRITE, 635 .wdata = wdata, .rdata = NULL, 636 .wlen = 2, .rlen = 0}; 637 638 return acpi_ec_transaction(ec, &t); 639} 640 641int ec_read(u8 addr, u8 *val) 642{ 643 int err; 644 u8 temp_data; 645 646 if (!first_ec) 647 return -ENODEV; 648 649 err = acpi_ec_read(first_ec, addr, &temp_data); 650 651 if (!err) { 652 *val = temp_data; 653 return 0; 654 } 655 return err; 656} 657EXPORT_SYMBOL(ec_read); 658 659int ec_write(u8 addr, u8 val) 660{ 661 int err; 662 663 if (!first_ec) 664 return -ENODEV; 665 666 err = acpi_ec_write(first_ec, addr, val); 667 668 return err; 669} 670EXPORT_SYMBOL(ec_write); 671 672int ec_transaction(u8 command, 673 const u8 *wdata, unsigned wdata_len, 674 u8 *rdata, unsigned rdata_len) 675{ 676 struct transaction t = {.command = command, 677 .wdata = wdata, .rdata = rdata, 678 .wlen = wdata_len, .rlen = rdata_len}; 679 680 if (!first_ec) 681 return -ENODEV; 682 683 return acpi_ec_transaction(first_ec, &t); 684} 685EXPORT_SYMBOL(ec_transaction); 686 687/* Get the handle to the EC device */ 688acpi_handle ec_get_handle(void) 689{ 690 if (!first_ec) 691 return NULL; 692 return first_ec->handle; 693} 694EXPORT_SYMBOL(ec_get_handle); 695 696/* 697 * Process _Q events that might have accumulated in the EC. 698 * Run with locked ec mutex. 699 */ 700static void acpi_ec_clear(struct acpi_ec *ec) 701{ 702 int i, status; 703 u8 value = 0; 704 705 for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) { 706 status = acpi_ec_query(ec, &value); 707 if (status || !value) 708 break; 709 } 710 711 if (unlikely(i == ACPI_EC_CLEAR_MAX)) 712 pr_warn("Warning: Maximum of %d stale EC events cleared\n", i); 713 else 714 pr_info("%d stale EC events cleared\n", i); 715} 716 717static void acpi_ec_start(struct acpi_ec *ec, bool resuming) 718{ 719 unsigned long flags; 720 721 spin_lock_irqsave(&ec->lock, flags); 722 if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) { 723 ec_dbg_drv("Starting EC"); 724 /* Enable GPE for event processing (SCI_EVT=1) */ 725 if (!resuming) { 726 acpi_ec_submit_request(ec); 727 ec_dbg_ref(ec, "Increase driver"); 728 } 729 ec_log_drv("EC started"); 730 } 731 spin_unlock_irqrestore(&ec->lock, flags); 732} 733 734static bool acpi_ec_stopped(struct acpi_ec *ec) 735{ 736 unsigned long flags; 737 bool flushed; 738 739 spin_lock_irqsave(&ec->lock, flags); 740 flushed = acpi_ec_flushed(ec); 741 spin_unlock_irqrestore(&ec->lock, flags); 742 return flushed; 743} 744 745static void acpi_ec_stop(struct acpi_ec *ec, bool suspending) 746{ 747 unsigned long flags; 748 749 spin_lock_irqsave(&ec->lock, flags); 750 if (acpi_ec_started(ec)) { 751 ec_dbg_drv("Stopping EC"); 752 set_bit(EC_FLAGS_STOPPED, &ec->flags); 753 spin_unlock_irqrestore(&ec->lock, flags); 754 wait_event(ec->wait, acpi_ec_stopped(ec)); 755 spin_lock_irqsave(&ec->lock, flags); 756 /* Disable GPE for event processing (SCI_EVT=1) */ 757 if (!suspending) { 758 acpi_ec_complete_request(ec); 759 ec_dbg_ref(ec, "Decrease driver"); 760 } 761 clear_bit(EC_FLAGS_STARTED, &ec->flags); 762 clear_bit(EC_FLAGS_STOPPED, &ec->flags); 763 ec_log_drv("EC stopped"); 764 } 765 spin_unlock_irqrestore(&ec->lock, flags); 766} 767 768void acpi_ec_block_transactions(void) 769{ 770 struct acpi_ec *ec = first_ec; 771 772 if (!ec) 773 return; 774 775 mutex_lock(&ec->mutex); 776 /* Prevent transactions from being carried out */ 777 acpi_ec_stop(ec, true); 778 mutex_unlock(&ec->mutex); 779} 780 781void acpi_ec_unblock_transactions(void) 782{ 783 struct acpi_ec *ec = first_ec; 784 785 if (!ec) 786 return; 787 788 /* Allow transactions to be carried out again */ 789 acpi_ec_start(ec, true); 790 791 if (EC_FLAGS_CLEAR_ON_RESUME) 792 acpi_ec_clear(ec); 793} 794 795void acpi_ec_unblock_transactions_early(void) 796{ 797 /* 798 * Allow transactions to happen again (this function is called from 799 * atomic context during wakeup, so we don't need to acquire the mutex). 800 */ 801 if (first_ec) 802 acpi_ec_start(first_ec, true); 803} 804 805/* -------------------------------------------------------------------------- 806 Event Management 807 -------------------------------------------------------------------------- */ 808static struct acpi_ec_query_handler * 809acpi_ec_get_query_handler(struct acpi_ec_query_handler *handler) 810{ 811 if (handler) 812 kref_get(&handler->kref); 813 return handler; 814} 815 816static void acpi_ec_query_handler_release(struct kref *kref) 817{ 818 struct acpi_ec_query_handler *handler = 819 container_of(kref, struct acpi_ec_query_handler, kref); 820 821 kfree(handler); 822} 823 824static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler) 825{ 826 kref_put(&handler->kref, acpi_ec_query_handler_release); 827} 828 829int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit, 830 acpi_handle handle, acpi_ec_query_func func, 831 void *data) 832{ 833 struct acpi_ec_query_handler *handler = 834 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL); 835 836 if (!handler) 837 return -ENOMEM; 838 839 handler->query_bit = query_bit; 840 handler->handle = handle; 841 handler->func = func; 842 handler->data = data; 843 mutex_lock(&ec->mutex); 844 kref_init(&handler->kref); 845 list_add(&handler->node, &ec->list); 846 mutex_unlock(&ec->mutex); 847 return 0; 848} 849EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler); 850 851void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit) 852{ 853 struct acpi_ec_query_handler *handler, *tmp; 854 LIST_HEAD(free_list); 855 856 mutex_lock(&ec->mutex); 857 list_for_each_entry_safe(handler, tmp, &ec->list, node) { 858 if (query_bit == handler->query_bit) { 859 list_del_init(&handler->node); 860 list_add(&handler->node, &free_list); 861 } 862 } 863 mutex_unlock(&ec->mutex); 864 list_for_each_entry_safe(handler, tmp, &free_list, node) 865 acpi_ec_put_query_handler(handler); 866} 867EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler); 868 869static void acpi_ec_run(void *cxt) 870{ 871 struct acpi_ec_query_handler *handler = cxt; 872 873 if (!handler) 874 return; 875 ec_dbg_evt("Query(0x%02x) started", handler->query_bit); 876 if (handler->func) 877 handler->func(handler->data); 878 else if (handler->handle) 879 acpi_evaluate_object(handler->handle, NULL, NULL, NULL); 880 ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit); 881 acpi_ec_put_query_handler(handler); 882} 883 884static int acpi_ec_query(struct acpi_ec *ec, u8 *data) 885{ 886 u8 value = 0; 887 int result; 888 acpi_status status; 889 struct acpi_ec_query_handler *handler; 890 struct transaction t = {.command = ACPI_EC_COMMAND_QUERY, 891 .wdata = NULL, .rdata = &value, 892 .wlen = 0, .rlen = 1}; 893 894 /* 895 * Query the EC to find out which _Qxx method we need to evaluate. 896 * Note that successful completion of the query causes the ACPI_EC_SCI 897 * bit to be cleared (and thus clearing the interrupt source). 898 */ 899 result = acpi_ec_transaction(ec, &t); 900 if (result) 901 return result; 902 if (data) 903 *data = value; 904 if (!value) 905 return -ENODATA; 906 907 mutex_lock(&ec->mutex); 908 list_for_each_entry(handler, &ec->list, node) { 909 if (value == handler->query_bit) { 910 /* have custom handler for this bit */ 911 handler = acpi_ec_get_query_handler(handler); 912 ec_dbg_evt("Query(0x%02x) scheduled", 913 handler->query_bit); 914 status = acpi_os_execute((handler->func) ? 915 OSL_NOTIFY_HANDLER : OSL_GPE_HANDLER, 916 acpi_ec_run, handler); 917 if (ACPI_FAILURE(status)) 918 result = -EBUSY; 919 break; 920 } 921 } 922 mutex_unlock(&ec->mutex); 923 return result; 924} 925 926static void acpi_ec_gpe_poller(struct work_struct *work) 927{ 928 struct acpi_ec *ec = container_of(work, struct acpi_ec, work); 929 930 acpi_ec_query(ec, NULL); 931} 932 933static u32 acpi_ec_gpe_handler(acpi_handle gpe_device, 934 u32 gpe_number, void *data) 935{ 936 unsigned long flags; 937 struct acpi_ec *ec = data; 938 939 spin_lock_irqsave(&ec->lock, flags); 940 advance_transaction(ec); 941 spin_unlock_irqrestore(&ec->lock, flags); 942 return ACPI_INTERRUPT_HANDLED; 943} 944 945/* -------------------------------------------------------------------------- 946 * Address Space Management 947 * -------------------------------------------------------------------------- */ 948 949static acpi_status 950acpi_ec_space_handler(u32 function, acpi_physical_address address, 951 u32 bits, u64 *value64, 952 void *handler_context, void *region_context) 953{ 954 struct acpi_ec *ec = handler_context; 955 int result = 0, i, bytes = bits / 8; 956 u8 *value = (u8 *)value64; 957 958 if ((address > 0xFF) || !value || !handler_context) 959 return AE_BAD_PARAMETER; 960 961 if (function != ACPI_READ && function != ACPI_WRITE) 962 return AE_BAD_PARAMETER; 963 964 if (EC_FLAGS_MSI || bits > 8) 965 acpi_ec_burst_enable(ec); 966 967 for (i = 0; i < bytes; ++i, ++address, ++value) 968 result = (function == ACPI_READ) ? 969 acpi_ec_read(ec, address, value) : 970 acpi_ec_write(ec, address, *value); 971 972 if (EC_FLAGS_MSI || bits > 8) 973 acpi_ec_burst_disable(ec); 974 975 switch (result) { 976 case -EINVAL: 977 return AE_BAD_PARAMETER; 978 case -ENODEV: 979 return AE_NOT_FOUND; 980 case -ETIME: 981 return AE_TIME; 982 default: 983 return AE_OK; 984 } 985} 986 987/* -------------------------------------------------------------------------- 988 * Driver Interface 989 * -------------------------------------------------------------------------- */ 990 991static acpi_status 992ec_parse_io_ports(struct acpi_resource *resource, void *context); 993 994static struct acpi_ec *make_acpi_ec(void) 995{ 996 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL); 997 998 if (!ec) 999 return NULL; 1000 ec->flags = 1 << EC_FLAGS_QUERY_PENDING; 1001 mutex_init(&ec->mutex); 1002 init_waitqueue_head(&ec->wait); 1003 INIT_LIST_HEAD(&ec->list); 1004 spin_lock_init(&ec->lock); 1005 INIT_WORK(&ec->work, acpi_ec_gpe_poller); 1006 return ec; 1007} 1008 1009static acpi_status 1010acpi_ec_register_query_methods(acpi_handle handle, u32 level, 1011 void *context, void **return_value) 1012{ 1013 char node_name[5]; 1014 struct acpi_buffer buffer = { sizeof(node_name), node_name }; 1015 struct acpi_ec *ec = context; 1016 int value = 0; 1017 acpi_status status; 1018 1019 status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer); 1020 1021 if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1) 1022 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL); 1023 return AE_OK; 1024} 1025 1026static acpi_status 1027ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval) 1028{ 1029 acpi_status status; 1030 unsigned long long tmp = 0; 1031 struct acpi_ec *ec = context; 1032 1033 /* clear addr values, ec_parse_io_ports depend on it */ 1034 ec->command_addr = ec->data_addr = 0; 1035 1036 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 1037 ec_parse_io_ports, ec); 1038 if (ACPI_FAILURE(status)) 1039 return status; 1040 1041 /* Get GPE bit assignment (EC events). */ 1042 /* TODO: Add support for _GPE returning a package */ 1043 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp); 1044 if (ACPI_FAILURE(status)) 1045 return status; 1046 ec->gpe = tmp; 1047 /* Use the global lock for all EC transactions? */ 1048 tmp = 0; 1049 acpi_evaluate_integer(handle, "_GLK", NULL, &tmp); 1050 ec->global_lock = tmp; 1051 ec->handle = handle; 1052 return AE_CTRL_TERMINATE; 1053} 1054 1055static int ec_install_handlers(struct acpi_ec *ec) 1056{ 1057 acpi_status status; 1058 1059 if (test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags)) 1060 return 0; 1061 status = acpi_install_gpe_raw_handler(NULL, ec->gpe, 1062 ACPI_GPE_EDGE_TRIGGERED, 1063 &acpi_ec_gpe_handler, ec); 1064 if (ACPI_FAILURE(status)) 1065 return -ENODEV; 1066 1067 acpi_ec_start(ec, false); 1068 status = acpi_install_address_space_handler(ec->handle, 1069 ACPI_ADR_SPACE_EC, 1070 &acpi_ec_space_handler, 1071 NULL, ec); 1072 if (ACPI_FAILURE(status)) { 1073 if (status == AE_NOT_FOUND) { 1074 /* 1075 * Maybe OS fails in evaluating the _REG object. 1076 * The AE_NOT_FOUND error will be ignored and OS 1077 * continue to initialize EC. 1078 */ 1079 pr_err("Fail in evaluating the _REG object" 1080 " of EC device. Broken bios is suspected.\n"); 1081 } else { 1082 acpi_ec_stop(ec, false); 1083 acpi_remove_gpe_handler(NULL, ec->gpe, 1084 &acpi_ec_gpe_handler); 1085 return -ENODEV; 1086 } 1087 } 1088 1089 set_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags); 1090 return 0; 1091} 1092 1093static void ec_remove_handlers(struct acpi_ec *ec) 1094{ 1095 if (!test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags)) 1096 return; 1097 acpi_ec_stop(ec, false); 1098 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle, 1099 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler))) 1100 pr_err("failed to remove space handler\n"); 1101 if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe, 1102 &acpi_ec_gpe_handler))) 1103 pr_err("failed to remove gpe handler\n"); 1104 clear_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags); 1105} 1106 1107static int acpi_ec_add(struct acpi_device *device) 1108{ 1109 struct acpi_ec *ec = NULL; 1110 int ret; 1111 1112 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME); 1113 strcpy(acpi_device_class(device), ACPI_EC_CLASS); 1114 1115 /* Check for boot EC */ 1116 if (boot_ec && 1117 (boot_ec->handle == device->handle || 1118 boot_ec->handle == ACPI_ROOT_OBJECT)) { 1119 ec = boot_ec; 1120 boot_ec = NULL; 1121 } else { 1122 ec = make_acpi_ec(); 1123 if (!ec) 1124 return -ENOMEM; 1125 } 1126 if (ec_parse_device(device->handle, 0, ec, NULL) != 1127 AE_CTRL_TERMINATE) { 1128 kfree(ec); 1129 return -EINVAL; 1130 } 1131 1132 /* Find and register all query methods */ 1133 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1, 1134 acpi_ec_register_query_methods, NULL, ec, NULL); 1135 1136 if (!first_ec) 1137 first_ec = ec; 1138 device->driver_data = ec; 1139 1140 ret = !!request_region(ec->data_addr, 1, "EC data"); 1141 WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr); 1142 ret = !!request_region(ec->command_addr, 1, "EC cmd"); 1143 WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr); 1144 1145 pr_info("GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n", 1146 ec->gpe, ec->command_addr, ec->data_addr); 1147 1148 ret = ec_install_handlers(ec); 1149 1150 /* Reprobe devices depending on the EC */ 1151 acpi_walk_dep_device_list(ec->handle); 1152 1153 /* EC is fully operational, allow queries */ 1154 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags); 1155 1156 /* Clear stale _Q events if hardware might require that */ 1157 if (EC_FLAGS_CLEAR_ON_RESUME) 1158 acpi_ec_clear(ec); 1159 return ret; 1160} 1161 1162static int acpi_ec_remove(struct acpi_device *device) 1163{ 1164 struct acpi_ec *ec; 1165 struct acpi_ec_query_handler *handler, *tmp; 1166 1167 if (!device) 1168 return -EINVAL; 1169 1170 ec = acpi_driver_data(device); 1171 ec_remove_handlers(ec); 1172 mutex_lock(&ec->mutex); 1173 list_for_each_entry_safe(handler, tmp, &ec->list, node) { 1174 list_del(&handler->node); 1175 kfree(handler); 1176 } 1177 mutex_unlock(&ec->mutex); 1178 release_region(ec->data_addr, 1); 1179 release_region(ec->command_addr, 1); 1180 device->driver_data = NULL; 1181 if (ec == first_ec) 1182 first_ec = NULL; 1183 kfree(ec); 1184 return 0; 1185} 1186 1187static acpi_status 1188ec_parse_io_ports(struct acpi_resource *resource, void *context) 1189{ 1190 struct acpi_ec *ec = context; 1191 1192 if (resource->type != ACPI_RESOURCE_TYPE_IO) 1193 return AE_OK; 1194 1195 /* 1196 * The first address region returned is the data port, and 1197 * the second address region returned is the status/command 1198 * port. 1199 */ 1200 if (ec->data_addr == 0) 1201 ec->data_addr = resource->data.io.minimum; 1202 else if (ec->command_addr == 0) 1203 ec->command_addr = resource->data.io.minimum; 1204 else 1205 return AE_CTRL_TERMINATE; 1206 1207 return AE_OK; 1208} 1209 1210int __init acpi_boot_ec_enable(void) 1211{ 1212 if (!boot_ec || test_bit(EC_FLAGS_HANDLERS_INSTALLED, &boot_ec->flags)) 1213 return 0; 1214 if (!ec_install_handlers(boot_ec)) { 1215 first_ec = boot_ec; 1216 return 0; 1217 } 1218 return -EFAULT; 1219} 1220 1221static const struct acpi_device_id ec_device_ids[] = { 1222 {"PNP0C09", 0}, 1223 {"", 0}, 1224}; 1225 1226/* Some BIOS do not survive early DSDT scan, skip it */ 1227static int ec_skip_dsdt_scan(const struct dmi_system_id *id) 1228{ 1229 EC_FLAGS_SKIP_DSDT_SCAN = 1; 1230 return 0; 1231} 1232 1233/* ASUStek often supplies us with broken ECDT, validate it */ 1234static int ec_validate_ecdt(const struct dmi_system_id *id) 1235{ 1236 EC_FLAGS_VALIDATE_ECDT = 1; 1237 return 0; 1238} 1239 1240/* MSI EC needs special treatment, enable it */ 1241static int ec_flag_msi(const struct dmi_system_id *id) 1242{ 1243 pr_debug("Detected MSI hardware, enabling workarounds.\n"); 1244 EC_FLAGS_MSI = 1; 1245 EC_FLAGS_VALIDATE_ECDT = 1; 1246 return 0; 1247} 1248 1249/* 1250 * Clevo M720 notebook actually works ok with IRQ mode, if we lifted 1251 * the GPE storm threshold back to 20 1252 */ 1253static int ec_enlarge_storm_threshold(const struct dmi_system_id *id) 1254{ 1255 pr_debug("Setting the EC GPE storm threshold to 20\n"); 1256 ec_storm_threshold = 20; 1257 return 0; 1258} 1259 1260/* 1261 * Acer EC firmware refuses to respond QR_EC when SCI_EVT is not set, for 1262 * which case, we complete the QR_EC without issuing it to the firmware. 1263 * https://bugzilla.kernel.org/show_bug.cgi?id=86211 1264 */ 1265static int ec_flag_query_handshake(const struct dmi_system_id *id) 1266{ 1267 pr_debug("Detected the EC firmware requiring QR_EC issued when SCI_EVT set\n"); 1268 EC_FLAGS_QUERY_HANDSHAKE = 1; 1269 return 0; 1270} 1271 1272/* 1273 * On some hardware it is necessary to clear events accumulated by the EC during 1274 * sleep. These ECs stop reporting GPEs until they are manually polled, if too 1275 * many events are accumulated. (e.g. Samsung Series 5/9 notebooks) 1276 * 1277 * https://bugzilla.kernel.org/show_bug.cgi?id=44161 1278 * 1279 * Ideally, the EC should also be instructed NOT to accumulate events during 1280 * sleep (which Windows seems to do somehow), but the interface to control this 1281 * behaviour is not known at this time. 1282 * 1283 * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx, 1284 * however it is very likely that other Samsung models are affected. 1285 * 1286 * On systems which don't accumulate _Q events during sleep, this extra check 1287 * should be harmless. 1288 */ 1289static int ec_clear_on_resume(const struct dmi_system_id *id) 1290{ 1291 pr_debug("Detected system needing EC poll on resume.\n"); 1292 EC_FLAGS_CLEAR_ON_RESUME = 1; 1293 return 0; 1294} 1295 1296static struct dmi_system_id ec_dmi_table[] __initdata = { 1297 { 1298 ec_skip_dsdt_scan, "Compal JFL92", { 1299 DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"), 1300 DMI_MATCH(DMI_BOARD_NAME, "JFL92") }, NULL}, 1301 { 1302 ec_flag_msi, "MSI hardware", { 1303 DMI_MATCH(DMI_BIOS_VENDOR, "Micro-Star")}, NULL}, 1304 { 1305 ec_flag_msi, "MSI hardware", { 1306 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star")}, NULL}, 1307 { 1308 ec_flag_msi, "MSI hardware", { 1309 DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-Star")}, NULL}, 1310 { 1311 ec_flag_msi, "MSI hardware", { 1312 DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-STAR")}, NULL}, 1313 { 1314 ec_flag_msi, "Quanta hardware", { 1315 DMI_MATCH(DMI_SYS_VENDOR, "Quanta"), 1316 DMI_MATCH(DMI_PRODUCT_NAME, "TW8/SW8/DW8"),}, NULL}, 1317 { 1318 ec_flag_msi, "Quanta hardware", { 1319 DMI_MATCH(DMI_SYS_VENDOR, "Quanta"), 1320 DMI_MATCH(DMI_PRODUCT_NAME, "TW9/SW9"),}, NULL}, 1321 { 1322 ec_flag_msi, "Clevo W350etq", { 1323 DMI_MATCH(DMI_SYS_VENDOR, "CLEVO CO."), 1324 DMI_MATCH(DMI_PRODUCT_NAME, "W35_37ET"),}, NULL}, 1325 { 1326 ec_validate_ecdt, "ASUS hardware", { 1327 DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL}, 1328 { 1329 ec_validate_ecdt, "ASUS hardware", { 1330 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc.") }, NULL}, 1331 { 1332 ec_enlarge_storm_threshold, "CLEVO hardware", { 1333 DMI_MATCH(DMI_SYS_VENDOR, "CLEVO Co."), 1334 DMI_MATCH(DMI_PRODUCT_NAME, "M720T/M730T"),}, NULL}, 1335 { 1336 ec_skip_dsdt_scan, "HP Folio 13", { 1337 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1338 DMI_MATCH(DMI_PRODUCT_NAME, "HP Folio 13"),}, NULL}, 1339 { 1340 ec_validate_ecdt, "ASUS hardware", { 1341 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTek Computer Inc."), 1342 DMI_MATCH(DMI_PRODUCT_NAME, "L4R"),}, NULL}, 1343 { 1344 ec_clear_on_resume, "Samsung hardware", { 1345 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD.")}, NULL}, 1346 { 1347 ec_flag_query_handshake, "Acer hardware", { 1348 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), }, NULL}, 1349 {}, 1350}; 1351 1352int __init acpi_ec_ecdt_probe(void) 1353{ 1354 acpi_status status; 1355 struct acpi_ec *saved_ec = NULL; 1356 struct acpi_table_ecdt *ecdt_ptr; 1357 1358 boot_ec = make_acpi_ec(); 1359 if (!boot_ec) 1360 return -ENOMEM; 1361 /* 1362 * Generate a boot ec context 1363 */ 1364 dmi_check_system(ec_dmi_table); 1365 status = acpi_get_table(ACPI_SIG_ECDT, 1, 1366 (struct acpi_table_header **)&ecdt_ptr); 1367 if (ACPI_SUCCESS(status)) { 1368 pr_info("EC description table is found, configuring boot EC\n"); 1369 boot_ec->command_addr = ecdt_ptr->control.address; 1370 boot_ec->data_addr = ecdt_ptr->data.address; 1371 boot_ec->gpe = ecdt_ptr->gpe; 1372 boot_ec->handle = ACPI_ROOT_OBJECT; 1373 acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, 1374 &boot_ec->handle); 1375 /* Don't trust ECDT, which comes from ASUSTek */ 1376 if (!EC_FLAGS_VALIDATE_ECDT) 1377 goto install; 1378 saved_ec = kmemdup(boot_ec, sizeof(struct acpi_ec), GFP_KERNEL); 1379 if (!saved_ec) 1380 return -ENOMEM; 1381 /* fall through */ 1382 } 1383 1384 if (EC_FLAGS_SKIP_DSDT_SCAN) { 1385 kfree(saved_ec); 1386 return -ENODEV; 1387 } 1388 1389 /* This workaround is needed only on some broken machines, 1390 * which require early EC, but fail to provide ECDT */ 1391 pr_debug("Look up EC in DSDT\n"); 1392 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, 1393 boot_ec, NULL); 1394 /* Check that acpi_get_devices actually find something */ 1395 if (ACPI_FAILURE(status) || !boot_ec->handle) 1396 goto error; 1397 if (saved_ec) { 1398 /* try to find good ECDT from ASUSTek */ 1399 if (saved_ec->command_addr != boot_ec->command_addr || 1400 saved_ec->data_addr != boot_ec->data_addr || 1401 saved_ec->gpe != boot_ec->gpe || 1402 saved_ec->handle != boot_ec->handle) 1403 pr_info("ASUSTek keeps feeding us with broken " 1404 "ECDT tables, which are very hard to workaround. " 1405 "Trying to use DSDT EC info instead. Please send " 1406 "output of acpidump to linux-acpi@vger.kernel.org\n"); 1407 kfree(saved_ec); 1408 saved_ec = NULL; 1409 } else { 1410 /* We really need to limit this workaround, the only ASUS, 1411 * which needs it, has fake EC._INI method, so use it as flag. 1412 * Keep boot_ec struct as it will be needed soon. 1413 */ 1414 if (!dmi_name_in_vendors("ASUS") || 1415 !acpi_has_method(boot_ec->handle, "_INI")) 1416 return -ENODEV; 1417 } 1418install: 1419 if (!ec_install_handlers(boot_ec)) { 1420 first_ec = boot_ec; 1421 return 0; 1422 } 1423error: 1424 kfree(boot_ec); 1425 kfree(saved_ec); 1426 boot_ec = NULL; 1427 return -ENODEV; 1428} 1429 1430static struct acpi_driver acpi_ec_driver = { 1431 .name = "ec", 1432 .class = ACPI_EC_CLASS, 1433 .ids = ec_device_ids, 1434 .ops = { 1435 .add = acpi_ec_add, 1436 .remove = acpi_ec_remove, 1437 }, 1438}; 1439 1440int __init acpi_ec_init(void) 1441{ 1442 int result = 0; 1443 1444 /* Now register the driver for the EC */ 1445 result = acpi_bus_register_driver(&acpi_ec_driver); 1446 if (result < 0) 1447 return -ENODEV; 1448 1449 return result; 1450} 1451 1452/* EC driver currently not unloadable */ 1453#if 0 1454static void __exit acpi_ec_exit(void) 1455{ 1456 1457 acpi_bus_unregister_driver(&acpi_ec_driver); 1458} 1459#endif /* 0 */ 1460