1 /* 2 * ec.c - ACPI Embedded Controller Driver (v2.0) 3 * 4 * Copyright (C) 2006, 2007 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com> 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 print outs*/ 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 <asm/io.h> 42 #include <acpi/acpi_bus.h> 43 #include <acpi/acpi_drivers.h> 44 #include <acpi/actypes.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 /* EC events */ 69 enum ec_event { 70 ACPI_EC_EVENT_OBF_1 = 1, /* Output buffer full */ 71 ACPI_EC_EVENT_IBF_0, /* Input buffer empty */ 72 }; 73 74 #define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */ 75 #define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */ 76 77 enum { 78 EC_FLAGS_WAIT_GPE = 0, /* Don't check status until GPE arrives */ 79 EC_FLAGS_QUERY_PENDING, /* Query is pending */ 80 EC_FLAGS_GPE_MODE, /* Expect GPE to be sent for status change */ 81 EC_FLAGS_NO_ADDRESS_GPE, /* Expect GPE only for non-address event */ 82 EC_FLAGS_ADDRESS, /* Address is being written */ 83 EC_FLAGS_NO_WDATA_GPE, /* Don't expect WDATA GPE event */ 84 EC_FLAGS_WDATA, /* Data is being written */ 85 EC_FLAGS_NO_OBF1_GPE, /* Don't expect GPE before read */ 86 }; 87 88 static int acpi_ec_remove(struct acpi_device *device, int type); 89 static int acpi_ec_start(struct acpi_device *device); 90 static int acpi_ec_stop(struct acpi_device *device, int type); 91 static int acpi_ec_add(struct acpi_device *device); 92 93 static const struct acpi_device_id ec_device_ids[] = { 94 {"PNP0C09", 0}, 95 {"", 0}, 96 }; 97 98 static struct acpi_driver acpi_ec_driver = { 99 .name = "ec", 100 .class = ACPI_EC_CLASS, 101 .ids = ec_device_ids, 102 .ops = { 103 .add = acpi_ec_add, 104 .remove = acpi_ec_remove, 105 .start = acpi_ec_start, 106 .stop = acpi_ec_stop, 107 }, 108 }; 109 110 /* If we find an EC via the ECDT, we need to keep a ptr to its context */ 111 /* External interfaces use first EC only, so remember */ 112 typedef int (*acpi_ec_query_func) (void *data); 113 114 struct acpi_ec_query_handler { 115 struct list_head node; 116 acpi_ec_query_func func; 117 acpi_handle handle; 118 void *data; 119 u8 query_bit; 120 }; 121 122 static struct acpi_ec { 123 acpi_handle handle; 124 unsigned long gpe; 125 unsigned long command_addr; 126 unsigned long data_addr; 127 unsigned long global_lock; 128 unsigned long flags; 129 struct mutex lock; 130 wait_queue_head_t wait; 131 struct list_head list; 132 u8 handlers_installed; 133 } *boot_ec, *first_ec; 134 135 /* -------------------------------------------------------------------------- 136 Transaction Management 137 -------------------------------------------------------------------------- */ 138 139 static inline u8 acpi_ec_read_status(struct acpi_ec *ec) 140 { 141 u8 x = inb(ec->command_addr); 142 pr_debug(PREFIX "---> status = 0x%2.2x\n", x); 143 return x; 144 } 145 146 static inline u8 acpi_ec_read_data(struct acpi_ec *ec) 147 { 148 u8 x = inb(ec->data_addr); 149 pr_debug(PREFIX "---> data = 0x%2.2x\n", x); 150 return inb(ec->data_addr); 151 } 152 153 static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command) 154 { 155 pr_debug(PREFIX "<--- command = 0x%2.2x\n", command); 156 outb(command, ec->command_addr); 157 } 158 159 static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data) 160 { 161 pr_debug(PREFIX "<--- data = 0x%2.2x\n", data); 162 outb(data, ec->data_addr); 163 } 164 165 static inline int acpi_ec_check_status(struct acpi_ec *ec, enum ec_event event) 166 { 167 if (test_bit(EC_FLAGS_WAIT_GPE, &ec->flags)) 168 return 0; 169 if (event == ACPI_EC_EVENT_OBF_1) { 170 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_OBF) 171 return 1; 172 } else if (event == ACPI_EC_EVENT_IBF_0) { 173 if (!(acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF)) 174 return 1; 175 } 176 177 return 0; 178 } 179 180 static int acpi_ec_wait(struct acpi_ec *ec, enum ec_event event, int force_poll) 181 { 182 int ret = 0; 183 184 if (unlikely(event == ACPI_EC_EVENT_OBF_1 && 185 test_bit(EC_FLAGS_NO_OBF1_GPE, &ec->flags))) 186 force_poll = 1; 187 if (unlikely(test_bit(EC_FLAGS_ADDRESS, &ec->flags) && 188 test_bit(EC_FLAGS_NO_ADDRESS_GPE, &ec->flags))) 189 force_poll = 1; 190 if (unlikely(test_bit(EC_FLAGS_WDATA, &ec->flags) && 191 test_bit(EC_FLAGS_NO_WDATA_GPE, &ec->flags))) 192 force_poll = 1; 193 if (likely(test_bit(EC_FLAGS_GPE_MODE, &ec->flags)) && 194 likely(!force_poll)) { 195 if (wait_event_timeout(ec->wait, acpi_ec_check_status(ec, event), 196 msecs_to_jiffies(ACPI_EC_DELAY))) 197 goto end; 198 clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 199 if (acpi_ec_check_status(ec, event)) { 200 if (event == ACPI_EC_EVENT_OBF_1) { 201 /* miss OBF_1 GPE, don't expect it */ 202 pr_info(PREFIX "missing OBF confirmation, " 203 "don't expect it any longer.\n"); 204 set_bit(EC_FLAGS_NO_OBF1_GPE, &ec->flags); 205 } else if (test_bit(EC_FLAGS_ADDRESS, &ec->flags)) { 206 /* miss address GPE, don't expect it anymore */ 207 pr_info(PREFIX "missing address confirmation, " 208 "don't expect it any longer.\n"); 209 set_bit(EC_FLAGS_NO_ADDRESS_GPE, &ec->flags); 210 } else if (test_bit(EC_FLAGS_WDATA, &ec->flags)) { 211 /* miss write data GPE, don't expect it */ 212 pr_info(PREFIX "missing write data confirmation, " 213 "don't expect it any longer.\n"); 214 set_bit(EC_FLAGS_NO_WDATA_GPE, &ec->flags); 215 } else { 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 clear_bit(EC_FLAGS_GPE_MODE, &ec->flags); 221 } 222 goto end; 223 } 224 } else { 225 unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY); 226 clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 227 while (time_before(jiffies, delay)) { 228 if (acpi_ec_check_status(ec, event)) 229 goto end; 230 } 231 } 232 pr_err(PREFIX "acpi_ec_wait timeout," 233 " status = %d, expect_event = %d\n", 234 acpi_ec_read_status(ec), event); 235 ret = -ETIME; 236 end: 237 clear_bit(EC_FLAGS_ADDRESS, &ec->flags); 238 return ret; 239 } 240 241 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, u8 command, 242 const u8 * wdata, unsigned wdata_len, 243 u8 * rdata, unsigned rdata_len, 244 int force_poll) 245 { 246 int result = 0; 247 set_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 248 acpi_ec_write_cmd(ec, command); 249 pr_debug(PREFIX "transaction start\n"); 250 for (; wdata_len > 0; --wdata_len) { 251 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, force_poll); 252 if (result) { 253 pr_err(PREFIX 254 "write_cmd timeout, command = %d\n", command); 255 goto end; 256 } 257 /* mark the address byte written to EC */ 258 if (rdata_len + wdata_len > 1) 259 set_bit(EC_FLAGS_ADDRESS, &ec->flags); 260 set_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 261 acpi_ec_write_data(ec, *(wdata++)); 262 } 263 264 if (!rdata_len) { 265 set_bit(EC_FLAGS_WDATA, &ec->flags); 266 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, force_poll); 267 if (result) { 268 pr_err(PREFIX 269 "finish-write timeout, command = %d\n", command); 270 goto end; 271 } 272 } else if (command == ACPI_EC_COMMAND_QUERY) 273 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags); 274 275 for (; rdata_len > 0; --rdata_len) { 276 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1, force_poll); 277 if (result) { 278 pr_err(PREFIX "read timeout, command = %d\n", command); 279 goto end; 280 } 281 /* Don't expect GPE after last read */ 282 if (rdata_len > 1) 283 set_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 284 *(rdata++) = acpi_ec_read_data(ec); 285 } 286 end: 287 pr_debug(PREFIX "transaction end\n"); 288 return result; 289 } 290 291 static int acpi_ec_transaction(struct acpi_ec *ec, u8 command, 292 const u8 * wdata, unsigned wdata_len, 293 u8 * rdata, unsigned rdata_len, 294 int force_poll) 295 { 296 int status; 297 u32 glk; 298 299 if (!ec || (wdata_len && !wdata) || (rdata_len && !rdata)) 300 return -EINVAL; 301 302 if (rdata) 303 memset(rdata, 0, rdata_len); 304 305 mutex_lock(&ec->lock); 306 if (ec->global_lock) { 307 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 308 if (ACPI_FAILURE(status)) { 309 mutex_unlock(&ec->lock); 310 return -ENODEV; 311 } 312 } 313 314 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, 0); 315 if (status) { 316 pr_err(PREFIX "input buffer is not empty, " 317 "aborting transaction\n"); 318 goto end; 319 } 320 321 status = acpi_ec_transaction_unlocked(ec, command, 322 wdata, wdata_len, 323 rdata, rdata_len, 324 force_poll); 325 326 end: 327 328 if (ec->global_lock) 329 acpi_release_global_lock(glk); 330 mutex_unlock(&ec->lock); 331 332 return status; 333 } 334 335 /* 336 * Note: samsung nv5000 doesn't work with ec burst mode. 337 * http://bugzilla.kernel.org/show_bug.cgi?id=4980 338 */ 339 int acpi_ec_burst_enable(struct acpi_ec *ec) 340 { 341 u8 d; 342 return acpi_ec_transaction(ec, ACPI_EC_BURST_ENABLE, NULL, 0, &d, 1, 0); 343 } 344 345 int acpi_ec_burst_disable(struct acpi_ec *ec) 346 { 347 return acpi_ec_transaction(ec, ACPI_EC_BURST_DISABLE, NULL, 0, NULL, 0, 0); 348 } 349 350 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data) 351 { 352 int result; 353 u8 d; 354 355 result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_READ, 356 &address, 1, &d, 1, 0); 357 *data = d; 358 return result; 359 } 360 361 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data) 362 { 363 u8 wdata[2] = { address, data }; 364 return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE, 365 wdata, 2, NULL, 0, 0); 366 } 367 368 /* 369 * Externally callable EC access functions. For now, assume 1 EC only 370 */ 371 int ec_burst_enable(void) 372 { 373 if (!first_ec) 374 return -ENODEV; 375 return acpi_ec_burst_enable(first_ec); 376 } 377 378 EXPORT_SYMBOL(ec_burst_enable); 379 380 int ec_burst_disable(void) 381 { 382 if (!first_ec) 383 return -ENODEV; 384 return acpi_ec_burst_disable(first_ec); 385 } 386 387 EXPORT_SYMBOL(ec_burst_disable); 388 389 int ec_read(u8 addr, u8 * val) 390 { 391 int err; 392 u8 temp_data; 393 394 if (!first_ec) 395 return -ENODEV; 396 397 err = acpi_ec_read(first_ec, addr, &temp_data); 398 399 if (!err) { 400 *val = temp_data; 401 return 0; 402 } else 403 return err; 404 } 405 406 EXPORT_SYMBOL(ec_read); 407 408 int ec_write(u8 addr, u8 val) 409 { 410 int err; 411 412 if (!first_ec) 413 return -ENODEV; 414 415 err = acpi_ec_write(first_ec, addr, val); 416 417 return err; 418 } 419 420 EXPORT_SYMBOL(ec_write); 421 422 int ec_transaction(u8 command, 423 const u8 * wdata, unsigned wdata_len, 424 u8 * rdata, unsigned rdata_len, 425 int force_poll) 426 { 427 if (!first_ec) 428 return -ENODEV; 429 430 return acpi_ec_transaction(first_ec, command, wdata, 431 wdata_len, rdata, rdata_len, 432 force_poll); 433 } 434 435 EXPORT_SYMBOL(ec_transaction); 436 437 static int acpi_ec_query(struct acpi_ec *ec, u8 * data) 438 { 439 int result; 440 u8 d; 441 442 if (!ec || !data) 443 return -EINVAL; 444 445 /* 446 * Query the EC to find out which _Qxx method we need to evaluate. 447 * Note that successful completion of the query causes the ACPI_EC_SCI 448 * bit to be cleared (and thus clearing the interrupt source). 449 */ 450 451 result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1, 0); 452 if (result) 453 return result; 454 455 if (!d) 456 return -ENODATA; 457 458 *data = d; 459 return 0; 460 } 461 462 /* -------------------------------------------------------------------------- 463 Event Management 464 -------------------------------------------------------------------------- */ 465 int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit, 466 acpi_handle handle, acpi_ec_query_func func, 467 void *data) 468 { 469 struct acpi_ec_query_handler *handler = 470 kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL); 471 if (!handler) 472 return -ENOMEM; 473 474 handler->query_bit = query_bit; 475 handler->handle = handle; 476 handler->func = func; 477 handler->data = data; 478 mutex_lock(&ec->lock); 479 list_add(&handler->node, &ec->list); 480 mutex_unlock(&ec->lock); 481 return 0; 482 } 483 484 EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler); 485 486 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit) 487 { 488 struct acpi_ec_query_handler *handler, *tmp; 489 mutex_lock(&ec->lock); 490 list_for_each_entry_safe(handler, tmp, &ec->list, node) { 491 if (query_bit == handler->query_bit) { 492 list_del(&handler->node); 493 kfree(handler); 494 } 495 } 496 mutex_unlock(&ec->lock); 497 } 498 499 EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler); 500 501 static void acpi_ec_gpe_query(void *ec_cxt) 502 { 503 struct acpi_ec *ec = ec_cxt; 504 u8 value = 0; 505 struct acpi_ec_query_handler *handler, copy; 506 507 if (!ec || acpi_ec_query(ec, &value)) 508 return; 509 mutex_lock(&ec->lock); 510 list_for_each_entry(handler, &ec->list, node) { 511 if (value == handler->query_bit) { 512 /* have custom handler for this bit */ 513 memcpy(©, handler, sizeof(copy)); 514 mutex_unlock(&ec->lock); 515 if (copy.func) { 516 copy.func(copy.data); 517 } else if (copy.handle) { 518 acpi_evaluate_object(copy.handle, NULL, NULL, NULL); 519 } 520 return; 521 } 522 } 523 mutex_unlock(&ec->lock); 524 } 525 526 static u32 acpi_ec_gpe_handler(void *data) 527 { 528 acpi_status status = AE_OK; 529 struct acpi_ec *ec = data; 530 531 pr_debug(PREFIX "~~~> interrupt\n"); 532 clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags); 533 if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags)) 534 wake_up(&ec->wait); 535 536 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_SCI) { 537 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) 538 status = acpi_os_execute(OSL_EC_BURST_HANDLER, 539 acpi_ec_gpe_query, ec); 540 } else if (unlikely(!test_bit(EC_FLAGS_GPE_MODE, &ec->flags))) { 541 /* this is non-query, must be confirmation */ 542 if (printk_ratelimit()) 543 pr_info(PREFIX "non-query interrupt received," 544 " switching to interrupt mode\n"); 545 set_bit(EC_FLAGS_GPE_MODE, &ec->flags); 546 } 547 548 return ACPI_SUCCESS(status) ? 549 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED; 550 } 551 552 /* -------------------------------------------------------------------------- 553 Address Space Management 554 -------------------------------------------------------------------------- */ 555 556 static acpi_status 557 acpi_ec_space_setup(acpi_handle region_handle, 558 u32 function, void *handler_context, void **return_context) 559 { 560 /* 561 * The EC object is in the handler context and is needed 562 * when calling the acpi_ec_space_handler. 563 */ 564 *return_context = (function != ACPI_REGION_DEACTIVATE) ? 565 handler_context : NULL; 566 567 return AE_OK; 568 } 569 570 static acpi_status 571 acpi_ec_space_handler(u32 function, acpi_physical_address address, 572 u32 bits, acpi_integer *value, 573 void *handler_context, void *region_context) 574 { 575 struct acpi_ec *ec = handler_context; 576 int result = 0, i; 577 u8 temp = 0; 578 579 if ((address > 0xFF) || !value || !handler_context) 580 return AE_BAD_PARAMETER; 581 582 if (function != ACPI_READ && function != ACPI_WRITE) 583 return AE_BAD_PARAMETER; 584 585 if (bits != 8 && acpi_strict) 586 return AE_BAD_PARAMETER; 587 588 acpi_ec_burst_enable(ec); 589 590 if (function == ACPI_READ) { 591 result = acpi_ec_read(ec, address, &temp); 592 *value = temp; 593 } else { 594 temp = 0xff & (*value); 595 result = acpi_ec_write(ec, address, temp); 596 } 597 598 for (i = 8; unlikely(bits - i > 0); i += 8) { 599 ++address; 600 if (function == ACPI_READ) { 601 result = acpi_ec_read(ec, address, &temp); 602 (*value) |= ((acpi_integer)temp) << i; 603 } else { 604 temp = 0xff & ((*value) >> i); 605 result = acpi_ec_write(ec, address, temp); 606 } 607 } 608 609 acpi_ec_burst_disable(ec); 610 611 switch (result) { 612 case -EINVAL: 613 return AE_BAD_PARAMETER; 614 break; 615 case -ENODEV: 616 return AE_NOT_FOUND; 617 break; 618 case -ETIME: 619 return AE_TIME; 620 break; 621 default: 622 return AE_OK; 623 } 624 } 625 626 /* -------------------------------------------------------------------------- 627 FS Interface (/proc) 628 -------------------------------------------------------------------------- */ 629 630 static struct proc_dir_entry *acpi_ec_dir; 631 632 static int acpi_ec_read_info(struct seq_file *seq, void *offset) 633 { 634 struct acpi_ec *ec = seq->private; 635 636 if (!ec) 637 goto end; 638 639 seq_printf(seq, "gpe:\t\t\t0x%02x\n", (u32) ec->gpe); 640 seq_printf(seq, "ports:\t\t\t0x%02x, 0x%02x\n", 641 (unsigned)ec->command_addr, (unsigned)ec->data_addr); 642 seq_printf(seq, "use global lock:\t%s\n", 643 ec->global_lock ? "yes" : "no"); 644 end: 645 return 0; 646 } 647 648 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file) 649 { 650 return single_open(file, acpi_ec_read_info, PDE(inode)->data); 651 } 652 653 static struct file_operations acpi_ec_info_ops = { 654 .open = acpi_ec_info_open_fs, 655 .read = seq_read, 656 .llseek = seq_lseek, 657 .release = single_release, 658 .owner = THIS_MODULE, 659 }; 660 661 static int acpi_ec_add_fs(struct acpi_device *device) 662 { 663 struct proc_dir_entry *entry = NULL; 664 665 if (!acpi_device_dir(device)) { 666 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 667 acpi_ec_dir); 668 if (!acpi_device_dir(device)) 669 return -ENODEV; 670 } 671 672 entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO, 673 acpi_device_dir(device)); 674 if (!entry) 675 return -ENODEV; 676 else { 677 entry->proc_fops = &acpi_ec_info_ops; 678 entry->data = acpi_driver_data(device); 679 entry->owner = THIS_MODULE; 680 } 681 682 return 0; 683 } 684 685 static int acpi_ec_remove_fs(struct acpi_device *device) 686 { 687 688 if (acpi_device_dir(device)) { 689 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device)); 690 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir); 691 acpi_device_dir(device) = NULL; 692 } 693 694 return 0; 695 } 696 697 /* -------------------------------------------------------------------------- 698 Driver Interface 699 -------------------------------------------------------------------------- */ 700 static acpi_status 701 ec_parse_io_ports(struct acpi_resource *resource, void *context); 702 703 static struct acpi_ec *make_acpi_ec(void) 704 { 705 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL); 706 if (!ec) 707 return NULL; 708 ec->flags = 1 << EC_FLAGS_QUERY_PENDING; 709 mutex_init(&ec->lock); 710 init_waitqueue_head(&ec->wait); 711 INIT_LIST_HEAD(&ec->list); 712 return ec; 713 } 714 715 static acpi_status 716 acpi_ec_register_query_methods(acpi_handle handle, u32 level, 717 void *context, void **return_value) 718 { 719 struct acpi_namespace_node *node = handle; 720 struct acpi_ec *ec = context; 721 int value = 0; 722 if (sscanf(node->name.ascii, "_Q%x", &value) == 1) { 723 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL); 724 } 725 return AE_OK; 726 } 727 728 static acpi_status 729 ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval) 730 { 731 acpi_status status; 732 733 struct acpi_ec *ec = context; 734 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 735 ec_parse_io_ports, ec); 736 if (ACPI_FAILURE(status)) 737 return status; 738 739 /* Get GPE bit assignment (EC events). */ 740 /* TODO: Add support for _GPE returning a package */ 741 status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec->gpe); 742 if (ACPI_FAILURE(status)) 743 return status; 744 /* Find and register all query methods */ 745 acpi_walk_namespace(ACPI_TYPE_METHOD, handle, 1, 746 acpi_ec_register_query_methods, ec, NULL); 747 /* Use the global lock for all EC transactions? */ 748 acpi_evaluate_integer(handle, "_GLK", NULL, &ec->global_lock); 749 ec->handle = handle; 750 return AE_CTRL_TERMINATE; 751 } 752 753 static void ec_remove_handlers(struct acpi_ec *ec) 754 { 755 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle, 756 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler))) 757 pr_err(PREFIX "failed to remove space handler\n"); 758 if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe, 759 &acpi_ec_gpe_handler))) 760 pr_err(PREFIX "failed to remove gpe handler\n"); 761 ec->handlers_installed = 0; 762 } 763 764 static int acpi_ec_add(struct acpi_device *device) 765 { 766 struct acpi_ec *ec = NULL; 767 768 if (!device) 769 return -EINVAL; 770 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME); 771 strcpy(acpi_device_class(device), ACPI_EC_CLASS); 772 773 /* Check for boot EC */ 774 if (boot_ec) { 775 if (boot_ec->handle == device->handle) { 776 /* Pre-loaded EC from DSDT, just move pointer */ 777 ec = boot_ec; 778 boot_ec = NULL; 779 goto end; 780 } else if (boot_ec->handle == ACPI_ROOT_OBJECT) { 781 /* ECDT-based EC, time to shut it down */ 782 ec_remove_handlers(boot_ec); 783 kfree(boot_ec); 784 first_ec = boot_ec = NULL; 785 } 786 } 787 788 ec = make_acpi_ec(); 789 if (!ec) 790 return -ENOMEM; 791 792 if (ec_parse_device(device->handle, 0, ec, NULL) != 793 AE_CTRL_TERMINATE) { 794 kfree(ec); 795 return -EINVAL; 796 } 797 ec->handle = device->handle; 798 end: 799 if (!first_ec) 800 first_ec = ec; 801 acpi_driver_data(device) = ec; 802 acpi_ec_add_fs(device); 803 pr_info(PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n", 804 ec->gpe, ec->command_addr, ec->data_addr); 805 pr_info(PREFIX "driver started in %s mode\n", 806 (test_bit(EC_FLAGS_GPE_MODE, &ec->flags))?"interrupt":"poll"); 807 return 0; 808 } 809 810 static int acpi_ec_remove(struct acpi_device *device, int type) 811 { 812 struct acpi_ec *ec; 813 struct acpi_ec_query_handler *handler, *tmp; 814 815 if (!device) 816 return -EINVAL; 817 818 ec = acpi_driver_data(device); 819 mutex_lock(&ec->lock); 820 list_for_each_entry_safe(handler, tmp, &ec->list, node) { 821 list_del(&handler->node); 822 kfree(handler); 823 } 824 mutex_unlock(&ec->lock); 825 acpi_ec_remove_fs(device); 826 acpi_driver_data(device) = NULL; 827 if (ec == first_ec) 828 first_ec = NULL; 829 kfree(ec); 830 return 0; 831 } 832 833 static acpi_status 834 ec_parse_io_ports(struct acpi_resource *resource, void *context) 835 { 836 struct acpi_ec *ec = context; 837 838 if (resource->type != ACPI_RESOURCE_TYPE_IO) 839 return AE_OK; 840 841 /* 842 * The first address region returned is the data port, and 843 * the second address region returned is the status/command 844 * port. 845 */ 846 if (ec->data_addr == 0) 847 ec->data_addr = resource->data.io.minimum; 848 else if (ec->command_addr == 0) 849 ec->command_addr = resource->data.io.minimum; 850 else 851 return AE_CTRL_TERMINATE; 852 853 return AE_OK; 854 } 855 856 static int ec_install_handlers(struct acpi_ec *ec) 857 { 858 acpi_status status; 859 if (ec->handlers_installed) 860 return 0; 861 status = acpi_install_gpe_handler(NULL, ec->gpe, 862 ACPI_GPE_EDGE_TRIGGERED, 863 &acpi_ec_gpe_handler, ec); 864 if (ACPI_FAILURE(status)) 865 return -ENODEV; 866 867 acpi_set_gpe_type(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME); 868 acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR); 869 870 status = acpi_install_address_space_handler(ec->handle, 871 ACPI_ADR_SPACE_EC, 872 &acpi_ec_space_handler, 873 &acpi_ec_space_setup, ec); 874 if (ACPI_FAILURE(status)) { 875 acpi_remove_gpe_handler(NULL, ec->gpe, &acpi_ec_gpe_handler); 876 return -ENODEV; 877 } 878 879 ec->handlers_installed = 1; 880 return 0; 881 } 882 883 static int acpi_ec_start(struct acpi_device *device) 884 { 885 struct acpi_ec *ec; 886 int ret = 0; 887 888 if (!device) 889 return -EINVAL; 890 891 ec = acpi_driver_data(device); 892 893 if (!ec) 894 return -EINVAL; 895 896 ret = ec_install_handlers(ec); 897 898 /* EC is fully operational, allow queries */ 899 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags); 900 return ret; 901 } 902 903 static int acpi_ec_stop(struct acpi_device *device, int type) 904 { 905 struct acpi_ec *ec; 906 if (!device) 907 return -EINVAL; 908 ec = acpi_driver_data(device); 909 if (!ec) 910 return -EINVAL; 911 ec_remove_handlers(ec); 912 913 return 0; 914 } 915 916 int __init acpi_boot_ec_enable(void) 917 { 918 if (!boot_ec || boot_ec->handlers_installed) 919 return 0; 920 if (!ec_install_handlers(boot_ec)) { 921 first_ec = boot_ec; 922 return 0; 923 } 924 return -EFAULT; 925 } 926 927 int __init acpi_ec_ecdt_probe(void) 928 { 929 int ret; 930 acpi_status status; 931 struct acpi_table_ecdt *ecdt_ptr; 932 933 boot_ec = make_acpi_ec(); 934 if (!boot_ec) 935 return -ENOMEM; 936 /* 937 * Generate a boot ec context 938 */ 939 status = acpi_get_table(ACPI_SIG_ECDT, 1, 940 (struct acpi_table_header **)&ecdt_ptr); 941 if (ACPI_SUCCESS(status)) { 942 pr_info(PREFIX "EC description table is found, configuring boot EC\n"); 943 boot_ec->command_addr = ecdt_ptr->control.address; 944 boot_ec->data_addr = ecdt_ptr->data.address; 945 boot_ec->gpe = ecdt_ptr->gpe; 946 boot_ec->handle = ACPI_ROOT_OBJECT; 947 } else { 948 /* This workaround is needed only on some broken machines, 949 * which require early EC, but fail to provide ECDT */ 950 acpi_handle x; 951 printk(KERN_DEBUG PREFIX "Look up EC in DSDT\n"); 952 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, 953 boot_ec, NULL); 954 /* Check that acpi_get_devices actually find something */ 955 if (ACPI_FAILURE(status) || !boot_ec->handle) 956 goto error; 957 /* We really need to limit this workaround, the only ASUS, 958 * which needs it, has fake EC._INI method, so use it as flag. 959 * Keep boot_ec struct as it will be needed soon. 960 */ 961 if (ACPI_FAILURE(acpi_get_handle(boot_ec->handle, "_INI", &x))) 962 return -ENODEV; 963 } 964 965 ret = ec_install_handlers(boot_ec); 966 if (!ret) { 967 first_ec = boot_ec; 968 return 0; 969 } 970 error: 971 kfree(boot_ec); 972 boot_ec = NULL; 973 return -ENODEV; 974 } 975 976 static int __init acpi_ec_init(void) 977 { 978 int result = 0; 979 980 if (acpi_disabled) 981 return 0; 982 983 acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir); 984 if (!acpi_ec_dir) 985 return -ENODEV; 986 987 /* Now register the driver for the EC */ 988 result = acpi_bus_register_driver(&acpi_ec_driver); 989 if (result < 0) { 990 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 991 return -ENODEV; 992 } 993 994 return result; 995 } 996 997 subsys_initcall(acpi_ec_init); 998 999 /* EC driver currently not unloadable */ 1000 #if 0 1001 static void __exit acpi_ec_exit(void) 1002 { 1003 1004 acpi_bus_unregister_driver(&acpi_ec_driver); 1005 1006 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 1007 1008 return; 1009 } 1010 #endif /* 0 */ 1011