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