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