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