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