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