1 /* 2 * acpi_ec.c - ACPI Embedded Controller Driver ($Revision: 38 $) 3 * 4 * Copyright (C) 2004 Luming Yu <luming.yu@intel.com> 5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 7 * 8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or (at 13 * your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, but 16 * WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License along 21 * with this program; if not, write to the Free Software Foundation, Inc., 22 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 23 * 24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 25 */ 26 27 #include <linux/kernel.h> 28 #include <linux/module.h> 29 #include <linux/init.h> 30 #include <linux/types.h> 31 #include <linux/delay.h> 32 #include <linux/proc_fs.h> 33 #include <linux/seq_file.h> 34 #include <linux/interrupt.h> 35 #include <asm/io.h> 36 #include <acpi/acpi_bus.h> 37 #include <acpi/acpi_drivers.h> 38 #include <acpi/actypes.h> 39 40 #define _COMPONENT ACPI_EC_COMPONENT 41 ACPI_MODULE_NAME("acpi_ec") 42 #define ACPI_EC_COMPONENT 0x00100000 43 #define ACPI_EC_CLASS "embedded_controller" 44 #define ACPI_EC_HID "PNP0C09" 45 #define ACPI_EC_DRIVER_NAME "ACPI Embedded Controller Driver" 46 #define ACPI_EC_DEVICE_NAME "Embedded Controller" 47 #define ACPI_EC_FILE_INFO "info" 48 #define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */ 49 #define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */ 50 #define ACPI_EC_FLAG_BURST 0x10 /* burst mode */ 51 #define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */ 52 #define ACPI_EC_EVENT_OBF 0x01 /* Output buffer full */ 53 #define ACPI_EC_EVENT_IBE 0x02 /* Input buffer empty */ 54 #define ACPI_EC_DELAY 50 /* Wait 50ms max. during EC ops */ 55 #define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */ 56 #define ACPI_EC_UDELAY 100 /* Poll @ 100us increments */ 57 #define ACPI_EC_UDELAY_COUNT 1000 /* Wait 10ms max. during EC ops */ 58 #define ACPI_EC_COMMAND_READ 0x80 59 #define ACPI_EC_COMMAND_WRITE 0x81 60 #define ACPI_EC_BURST_ENABLE 0x82 61 #define ACPI_EC_BURST_DISABLE 0x83 62 #define ACPI_EC_COMMAND_QUERY 0x84 63 #define EC_POLL 0xFF 64 #define EC_INTR 0x00 65 static int acpi_ec_remove(struct acpi_device *device, int type); 66 static int acpi_ec_start(struct acpi_device *device); 67 static int acpi_ec_stop(struct acpi_device *device, int type); 68 static int acpi_ec_intr_add(struct acpi_device *device); 69 static int acpi_ec_poll_add(struct acpi_device *device); 70 71 static struct acpi_driver acpi_ec_driver = { 72 .name = ACPI_EC_DRIVER_NAME, 73 .class = ACPI_EC_CLASS, 74 .ids = ACPI_EC_HID, 75 .ops = { 76 .add = acpi_ec_intr_add, 77 .remove = acpi_ec_remove, 78 .start = acpi_ec_start, 79 .stop = acpi_ec_stop, 80 }, 81 }; 82 union acpi_ec { 83 struct { 84 u32 mode; 85 acpi_handle handle; 86 unsigned long uid; 87 unsigned long gpe_bit; 88 struct acpi_generic_address status_addr; 89 struct acpi_generic_address command_addr; 90 struct acpi_generic_address data_addr; 91 unsigned long global_lock; 92 } common; 93 94 struct { 95 u32 mode; 96 acpi_handle handle; 97 unsigned long uid; 98 unsigned long gpe_bit; 99 struct acpi_generic_address status_addr; 100 struct acpi_generic_address command_addr; 101 struct acpi_generic_address data_addr; 102 unsigned long global_lock; 103 unsigned int expect_event; 104 atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort */ 105 atomic_t pending_gpe; 106 struct semaphore sem; 107 wait_queue_head_t wait; 108 } intr; 109 110 struct { 111 u32 mode; 112 acpi_handle handle; 113 unsigned long uid; 114 unsigned long gpe_bit; 115 struct acpi_generic_address status_addr; 116 struct acpi_generic_address command_addr; 117 struct acpi_generic_address data_addr; 118 unsigned long global_lock; 119 struct semaphore sem; 120 } poll; 121 }; 122 123 static int acpi_ec_poll_wait(union acpi_ec *ec, u8 event); 124 static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event); 125 static int acpi_ec_poll_read(union acpi_ec *ec, u8 address, u32 * data); 126 static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data); 127 static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data); 128 static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data); 129 static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data); 130 static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data); 131 static void acpi_ec_gpe_poll_query(void *ec_cxt); 132 static void acpi_ec_gpe_intr_query(void *ec_cxt); 133 static u32 acpi_ec_gpe_poll_handler(void *data); 134 static u32 acpi_ec_gpe_intr_handler(void *data); 135 static acpi_status __init 136 acpi_fake_ecdt_poll_callback(acpi_handle handle, 137 u32 Level, void *context, void **retval); 138 139 static acpi_status __init 140 acpi_fake_ecdt_intr_callback(acpi_handle handle, 141 u32 Level, void *context, void **retval); 142 143 static int __init acpi_ec_poll_get_real_ecdt(void); 144 static int __init acpi_ec_intr_get_real_ecdt(void); 145 /* If we find an EC via the ECDT, we need to keep a ptr to its context */ 146 static union acpi_ec *ec_ecdt; 147 148 /* External interfaces use first EC only, so remember */ 149 static struct acpi_device *first_ec; 150 static int acpi_ec_poll_mode = EC_INTR; 151 152 /* -------------------------------------------------------------------------- 153 Transaction Management 154 -------------------------------------------------------------------------- */ 155 156 static u32 acpi_ec_read_status(union acpi_ec *ec) 157 { 158 u32 status = 0; 159 160 acpi_hw_low_level_read(8, &status, &ec->common.status_addr); 161 return status; 162 } 163 164 static int acpi_ec_wait(union acpi_ec *ec, u8 event) 165 { 166 if (acpi_ec_poll_mode) 167 return acpi_ec_poll_wait(ec, event); 168 else 169 return acpi_ec_intr_wait(ec, event); 170 } 171 172 static int acpi_ec_poll_wait(union acpi_ec *ec, u8 event) 173 { 174 u32 acpi_ec_status = 0; 175 u32 i = ACPI_EC_UDELAY_COUNT; 176 177 if (!ec) 178 return -EINVAL; 179 180 /* Poll the EC status register waiting for the event to occur. */ 181 switch (event) { 182 case ACPI_EC_EVENT_OBF: 183 do { 184 acpi_hw_low_level_read(8, &acpi_ec_status, 185 &ec->common.status_addr); 186 if (acpi_ec_status & ACPI_EC_FLAG_OBF) 187 return 0; 188 udelay(ACPI_EC_UDELAY); 189 } while (--i > 0); 190 break; 191 case ACPI_EC_EVENT_IBE: 192 do { 193 acpi_hw_low_level_read(8, &acpi_ec_status, 194 &ec->common.status_addr); 195 if (!(acpi_ec_status & ACPI_EC_FLAG_IBF)) 196 return 0; 197 udelay(ACPI_EC_UDELAY); 198 } while (--i > 0); 199 break; 200 default: 201 return -EINVAL; 202 } 203 204 return -ETIME; 205 } 206 static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event) 207 { 208 int result = 0; 209 210 ACPI_FUNCTION_TRACE("acpi_ec_wait"); 211 212 ec->intr.expect_event = event; 213 smp_mb(); 214 215 switch (event) { 216 case ACPI_EC_EVENT_IBE: 217 if (~acpi_ec_read_status(ec) & event) { 218 ec->intr.expect_event = 0; 219 return_VALUE(0); 220 } 221 break; 222 default: 223 break; 224 } 225 226 result = wait_event_timeout(ec->intr.wait, 227 !ec->intr.expect_event, 228 msecs_to_jiffies(ACPI_EC_DELAY)); 229 230 ec->intr.expect_event = 0; 231 smp_mb(); 232 233 /* 234 * Verify that the event in question has actually happened by 235 * querying EC status. Do the check even if operation timed-out 236 * to make sure that we did not miss interrupt. 237 */ 238 switch (event) { 239 case ACPI_EC_EVENT_OBF: 240 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_OBF) 241 return_VALUE(0); 242 break; 243 244 case ACPI_EC_EVENT_IBE: 245 if (~acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) 246 return_VALUE(0); 247 break; 248 } 249 250 return_VALUE(-ETIME); 251 } 252 253 #ifdef ACPI_FUTURE_USAGE 254 /* 255 * Note: samsung nv5000 doesn't work with ec burst mode. 256 * http://bugzilla.kernel.org/show_bug.cgi?id=4980 257 */ 258 int acpi_ec_enter_burst_mode(union acpi_ec *ec) 259 { 260 u32 tmp = 0; 261 int status = 0; 262 263 ACPI_FUNCTION_TRACE("acpi_ec_enter_burst_mode"); 264 265 status = acpi_ec_read_status(ec); 266 if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) { 267 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 268 if (status) 269 goto end; 270 acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE, 271 &ec->common.command_addr); 272 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 273 acpi_hw_low_level_read(8, &tmp, &ec->common.data_addr); 274 if (tmp != 0x90) { /* Burst ACK byte */ 275 return_VALUE(-EINVAL); 276 } 277 } 278 279 atomic_set(&ec->intr.leaving_burst, 0); 280 return_VALUE(0); 281 end: 282 printk(KERN_WARNING PREFIX "Error in acpi_ec_wait\n"); 283 return_VALUE(-1); 284 } 285 286 int acpi_ec_leave_burst_mode(union acpi_ec *ec) 287 { 288 int status = 0; 289 290 ACPI_FUNCTION_TRACE("acpi_ec_leave_burst_mode"); 291 292 status = acpi_ec_read_status(ec); 293 if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){ 294 status = acpi_ec_wait(ec, ACPI_EC_FLAG_IBF); 295 if(status) 296 goto end; 297 acpi_hw_low_level_write(8, ACPI_EC_BURST_DISABLE, &ec->common.command_addr); 298 acpi_ec_wait(ec, ACPI_EC_FLAG_IBF); 299 } 300 atomic_set(&ec->intr.leaving_burst, 1); 301 return_VALUE(0); 302 end: 303 printk(KERN_WARNING PREFIX "leave burst_mode:error\n"); 304 return_VALUE(-1); 305 } 306 #endif /* ACPI_FUTURE_USAGE */ 307 308 static int acpi_ec_read(union acpi_ec *ec, u8 address, u32 * data) 309 { 310 if (acpi_ec_poll_mode) 311 return acpi_ec_poll_read(ec, address, data); 312 else 313 return acpi_ec_intr_read(ec, address, data); 314 } 315 static int acpi_ec_write(union acpi_ec *ec, u8 address, u8 data) 316 { 317 if (acpi_ec_poll_mode) 318 return acpi_ec_poll_write(ec, address, data); 319 else 320 return acpi_ec_intr_write(ec, address, data); 321 } 322 static int acpi_ec_poll_read(union acpi_ec *ec, u8 address, u32 * data) 323 { 324 acpi_status status = AE_OK; 325 int result = 0; 326 u32 glk = 0; 327 328 ACPI_FUNCTION_TRACE("acpi_ec_read"); 329 330 if (!ec || !data) 331 return_VALUE(-EINVAL); 332 333 *data = 0; 334 335 if (ec->common.global_lock) { 336 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 337 if (ACPI_FAILURE(status)) 338 return_VALUE(-ENODEV); 339 } 340 341 if (down_interruptible(&ec->poll.sem)) { 342 result = -ERESTARTSYS; 343 goto end_nosem; 344 } 345 346 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ, 347 &ec->common.command_addr); 348 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 349 if (result) 350 goto end; 351 352 acpi_hw_low_level_write(8, address, &ec->common.data_addr); 353 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 354 if (result) 355 goto end; 356 357 acpi_hw_low_level_read(8, data, &ec->common.data_addr); 358 359 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n", 360 *data, address)); 361 362 end: 363 up(&ec->poll.sem); 364 end_nosem: 365 if (ec->common.global_lock) 366 acpi_release_global_lock(glk); 367 368 return_VALUE(result); 369 } 370 371 static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data) 372 { 373 int result = 0; 374 acpi_status status = AE_OK; 375 u32 glk = 0; 376 377 ACPI_FUNCTION_TRACE("acpi_ec_write"); 378 379 if (!ec) 380 return_VALUE(-EINVAL); 381 382 if (ec->common.global_lock) { 383 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 384 if (ACPI_FAILURE(status)) 385 return_VALUE(-ENODEV); 386 } 387 388 if (down_interruptible(&ec->poll.sem)) { 389 result = -ERESTARTSYS; 390 goto end_nosem; 391 } 392 393 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE, 394 &ec->common.command_addr); 395 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 396 if (result) 397 goto end; 398 399 acpi_hw_low_level_write(8, address, &ec->common.data_addr); 400 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 401 if (result) 402 goto end; 403 404 acpi_hw_low_level_write(8, data, &ec->common.data_addr); 405 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 406 if (result) 407 goto end; 408 409 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n", 410 data, address)); 411 412 end: 413 up(&ec->poll.sem); 414 end_nosem: 415 if (ec->common.global_lock) 416 acpi_release_global_lock(glk); 417 418 return_VALUE(result); 419 } 420 421 static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data) 422 { 423 int status = 0; 424 u32 glk; 425 426 ACPI_FUNCTION_TRACE("acpi_ec_read"); 427 428 if (!ec || !data) 429 return_VALUE(-EINVAL); 430 431 *data = 0; 432 433 if (ec->common.global_lock) { 434 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 435 if (ACPI_FAILURE(status)) 436 return_VALUE(-ENODEV); 437 } 438 439 WARN_ON(in_interrupt()); 440 down(&ec->intr.sem); 441 442 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 443 if (status) { 444 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n"); 445 goto end; 446 } 447 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ, 448 &ec->common.command_addr); 449 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 450 if (status) { 451 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n"); 452 } 453 454 acpi_hw_low_level_write(8, address, &ec->common.data_addr); 455 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 456 if (status) { 457 printk(KERN_DEBUG PREFIX "read EC, OB not full\n"); 458 goto end; 459 } 460 acpi_hw_low_level_read(8, data, &ec->common.data_addr); 461 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n", 462 *data, address)); 463 464 end: 465 up(&ec->intr.sem); 466 467 if (ec->common.global_lock) 468 acpi_release_global_lock(glk); 469 470 return_VALUE(status); 471 } 472 473 static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data) 474 { 475 int status = 0; 476 u32 glk; 477 478 ACPI_FUNCTION_TRACE("acpi_ec_write"); 479 480 if (!ec) 481 return_VALUE(-EINVAL); 482 483 if (ec->common.global_lock) { 484 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 485 if (ACPI_FAILURE(status)) 486 return_VALUE(-ENODEV); 487 } 488 489 WARN_ON(in_interrupt()); 490 down(&ec->intr.sem); 491 492 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 493 if (status) { 494 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n"); 495 } 496 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE, 497 &ec->common.command_addr); 498 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 499 if (status) { 500 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n"); 501 } 502 503 acpi_hw_low_level_write(8, address, &ec->common.data_addr); 504 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 505 if (status) { 506 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n"); 507 } 508 509 acpi_hw_low_level_write(8, data, &ec->common.data_addr); 510 511 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n", 512 data, address)); 513 514 up(&ec->intr.sem); 515 516 if (ec->common.global_lock) 517 acpi_release_global_lock(glk); 518 519 return_VALUE(status); 520 } 521 522 /* 523 * Externally callable EC access functions. For now, assume 1 EC only 524 */ 525 int ec_read(u8 addr, u8 * val) 526 { 527 union acpi_ec *ec; 528 int err; 529 u32 temp_data; 530 531 if (!first_ec) 532 return -ENODEV; 533 534 ec = acpi_driver_data(first_ec); 535 536 err = acpi_ec_read(ec, addr, &temp_data); 537 538 if (!err) { 539 *val = temp_data; 540 return 0; 541 } else 542 return err; 543 } 544 545 EXPORT_SYMBOL(ec_read); 546 547 int ec_write(u8 addr, u8 val) 548 { 549 union acpi_ec *ec; 550 int err; 551 552 if (!first_ec) 553 return -ENODEV; 554 555 ec = acpi_driver_data(first_ec); 556 557 err = acpi_ec_write(ec, addr, val); 558 559 return err; 560 } 561 562 EXPORT_SYMBOL(ec_write); 563 564 static int acpi_ec_query(union acpi_ec *ec, u32 * data) 565 { 566 if (acpi_ec_poll_mode) 567 return acpi_ec_poll_query(ec, data); 568 else 569 return acpi_ec_intr_query(ec, data); 570 } 571 static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data) 572 { 573 int result = 0; 574 acpi_status status = AE_OK; 575 u32 glk = 0; 576 577 ACPI_FUNCTION_TRACE("acpi_ec_query"); 578 579 if (!ec || !data) 580 return_VALUE(-EINVAL); 581 582 *data = 0; 583 584 if (ec->common.global_lock) { 585 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 586 if (ACPI_FAILURE(status)) 587 return_VALUE(-ENODEV); 588 } 589 590 /* 591 * Query the EC to find out which _Qxx method we need to evaluate. 592 * Note that successful completion of the query causes the ACPI_EC_SCI 593 * bit to be cleared (and thus clearing the interrupt source). 594 */ 595 if (down_interruptible(&ec->poll.sem)) { 596 result = -ERESTARTSYS; 597 goto end_nosem; 598 } 599 600 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY, 601 &ec->common.command_addr); 602 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 603 if (result) 604 goto end; 605 606 acpi_hw_low_level_read(8, data, &ec->common.data_addr); 607 if (!*data) 608 result = -ENODATA; 609 610 end: 611 up(&ec->poll.sem); 612 end_nosem: 613 if (ec->common.global_lock) 614 acpi_release_global_lock(glk); 615 616 return_VALUE(result); 617 } 618 static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data) 619 { 620 int status = 0; 621 u32 glk; 622 623 ACPI_FUNCTION_TRACE("acpi_ec_query"); 624 625 if (!ec || !data) 626 return_VALUE(-EINVAL); 627 *data = 0; 628 629 if (ec->common.global_lock) { 630 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 631 if (ACPI_FAILURE(status)) 632 return_VALUE(-ENODEV); 633 } 634 635 down(&ec->intr.sem); 636 637 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 638 if (status) { 639 printk(KERN_DEBUG PREFIX "query EC, IB not empty\n"); 640 goto end; 641 } 642 /* 643 * Query the EC to find out which _Qxx method we need to evaluate. 644 * Note that successful completion of the query causes the ACPI_EC_SCI 645 * bit to be cleared (and thus clearing the interrupt source). 646 */ 647 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY, 648 &ec->common.command_addr); 649 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 650 if (status) { 651 printk(KERN_DEBUG PREFIX "query EC, OB not full\n"); 652 goto end; 653 } 654 655 acpi_hw_low_level_read(8, data, &ec->common.data_addr); 656 if (!*data) 657 status = -ENODATA; 658 659 end: 660 up(&ec->intr.sem); 661 662 if (ec->common.global_lock) 663 acpi_release_global_lock(glk); 664 665 return_VALUE(status); 666 } 667 668 /* -------------------------------------------------------------------------- 669 Event Management 670 -------------------------------------------------------------------------- */ 671 672 union acpi_ec_query_data { 673 acpi_handle handle; 674 u8 data; 675 }; 676 677 static void acpi_ec_gpe_query(void *ec_cxt) 678 { 679 if (acpi_ec_poll_mode) 680 acpi_ec_gpe_poll_query(ec_cxt); 681 else 682 acpi_ec_gpe_intr_query(ec_cxt); 683 } 684 685 static void acpi_ec_gpe_poll_query(void *ec_cxt) 686 { 687 union acpi_ec *ec = (union acpi_ec *)ec_cxt; 688 u32 value = 0; 689 static char object_name[5] = { '_', 'Q', '0', '0', '\0' }; 690 const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', 691 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 692 }; 693 694 ACPI_FUNCTION_TRACE("acpi_ec_gpe_query"); 695 696 if (!ec_cxt) 697 goto end; 698 699 if (down_interruptible (&ec->poll.sem)) { 700 return_VOID; 701 } 702 acpi_hw_low_level_read(8, &value, &ec->common.command_addr); 703 up(&ec->poll.sem); 704 705 /* TBD: Implement asynch events! 706 * NOTE: All we care about are EC-SCI's. Other EC events are 707 * handled via polling (yuck!). This is because some systems 708 * treat EC-SCIs as level (versus EDGE!) triggered, preventing 709 * a purely interrupt-driven approach (grumble, grumble). 710 */ 711 if (!(value & ACPI_EC_FLAG_SCI)) 712 goto end; 713 714 if (acpi_ec_query(ec, &value)) 715 goto end; 716 717 object_name[2] = hex[((value >> 4) & 0x0F)]; 718 object_name[3] = hex[(value & 0x0F)]; 719 720 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name)); 721 722 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL); 723 724 end: 725 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR); 726 } 727 static void acpi_ec_gpe_intr_query(void *ec_cxt) 728 { 729 union acpi_ec *ec = (union acpi_ec *)ec_cxt; 730 u32 value; 731 int result = -ENODATA; 732 static char object_name[5] = { '_', 'Q', '0', '0', '\0' }; 733 const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', 734 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 735 }; 736 737 ACPI_FUNCTION_TRACE("acpi_ec_gpe_query"); 738 739 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_SCI) 740 result = acpi_ec_query(ec, &value); 741 742 if (result) 743 goto end; 744 745 object_name[2] = hex[((value >> 4) & 0x0F)]; 746 object_name[3] = hex[(value & 0x0F)]; 747 748 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name)); 749 750 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL); 751 end: 752 atomic_dec(&ec->intr.pending_gpe); 753 return; 754 } 755 756 static u32 acpi_ec_gpe_handler(void *data) 757 { 758 if (acpi_ec_poll_mode) 759 return acpi_ec_gpe_poll_handler(data); 760 else 761 return acpi_ec_gpe_intr_handler(data); 762 } 763 static u32 acpi_ec_gpe_poll_handler(void *data) 764 { 765 acpi_status status = AE_OK; 766 union acpi_ec *ec = (union acpi_ec *)data; 767 768 if (!ec) 769 return ACPI_INTERRUPT_NOT_HANDLED; 770 771 acpi_disable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR); 772 773 status = acpi_os_execute(OSL_EC_POLL_HANDLER, acpi_ec_gpe_query, ec); 774 775 if (status == AE_OK) 776 return ACPI_INTERRUPT_HANDLED; 777 else 778 return ACPI_INTERRUPT_NOT_HANDLED; 779 } 780 static u32 acpi_ec_gpe_intr_handler(void *data) 781 { 782 acpi_status status = AE_OK; 783 u32 value; 784 union acpi_ec *ec = (union acpi_ec *)data; 785 786 if (!ec) 787 return ACPI_INTERRUPT_NOT_HANDLED; 788 789 acpi_clear_gpe(NULL, ec->common.gpe_bit, ACPI_ISR); 790 value = acpi_ec_read_status(ec); 791 792 switch (ec->intr.expect_event) { 793 case ACPI_EC_EVENT_OBF: 794 if (!(value & ACPI_EC_FLAG_OBF)) 795 break; 796 case ACPI_EC_EVENT_IBE: 797 if ((value & ACPI_EC_FLAG_IBF)) 798 break; 799 ec->intr.expect_event = 0; 800 wake_up(&ec->intr.wait); 801 return ACPI_INTERRUPT_HANDLED; 802 default: 803 break; 804 } 805 806 if (value & ACPI_EC_FLAG_SCI) { 807 atomic_add(1, &ec->intr.pending_gpe); 808 status = acpi_os_execute(OSL_EC_BURST_HANDLER, 809 acpi_ec_gpe_query, ec); 810 return status == AE_OK ? 811 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED; 812 } 813 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR); 814 return status == AE_OK ? 815 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED; 816 } 817 818 /* -------------------------------------------------------------------------- 819 Address Space Management 820 -------------------------------------------------------------------------- */ 821 822 static acpi_status 823 acpi_ec_space_setup(acpi_handle region_handle, 824 u32 function, void *handler_context, void **return_context) 825 { 826 /* 827 * The EC object is in the handler context and is needed 828 * when calling the acpi_ec_space_handler. 829 */ 830 *return_context = (function != ACPI_REGION_DEACTIVATE) ? 831 handler_context : NULL; 832 833 return AE_OK; 834 } 835 836 static acpi_status 837 acpi_ec_space_handler(u32 function, 838 acpi_physical_address address, 839 u32 bit_width, 840 acpi_integer * value, 841 void *handler_context, void *region_context) 842 { 843 int result = 0; 844 union acpi_ec *ec = NULL; 845 u64 temp = *value; 846 acpi_integer f_v = 0; 847 int i = 0; 848 849 ACPI_FUNCTION_TRACE("acpi_ec_space_handler"); 850 851 if ((address > 0xFF) || !value || !handler_context) 852 return_VALUE(AE_BAD_PARAMETER); 853 854 if (bit_width != 8 && acpi_strict) { 855 printk(KERN_WARNING PREFIX 856 "acpi_ec_space_handler: bit_width should be 8\n"); 857 return_VALUE(AE_BAD_PARAMETER); 858 } 859 860 ec = (union acpi_ec *)handler_context; 861 862 next_byte: 863 switch (function) { 864 case ACPI_READ: 865 temp = 0; 866 result = acpi_ec_read(ec, (u8) address, (u32 *) & temp); 867 break; 868 case ACPI_WRITE: 869 result = acpi_ec_write(ec, (u8) address, (u8) temp); 870 break; 871 default: 872 result = -EINVAL; 873 goto out; 874 break; 875 } 876 877 bit_width -= 8; 878 if (bit_width) { 879 if (function == ACPI_READ) 880 f_v |= temp << 8 * i; 881 if (function == ACPI_WRITE) 882 temp >>= 8; 883 i++; 884 address++; 885 goto next_byte; 886 } 887 888 if (function == ACPI_READ) { 889 f_v |= temp << 8 * i; 890 *value = f_v; 891 } 892 893 out: 894 switch (result) { 895 case -EINVAL: 896 return_VALUE(AE_BAD_PARAMETER); 897 break; 898 case -ENODEV: 899 return_VALUE(AE_NOT_FOUND); 900 break; 901 case -ETIME: 902 return_VALUE(AE_TIME); 903 break; 904 default: 905 return_VALUE(AE_OK); 906 } 907 } 908 909 /* -------------------------------------------------------------------------- 910 FS Interface (/proc) 911 -------------------------------------------------------------------------- */ 912 913 static struct proc_dir_entry *acpi_ec_dir; 914 915 static int acpi_ec_read_info(struct seq_file *seq, void *offset) 916 { 917 union acpi_ec *ec = (union acpi_ec *)seq->private; 918 919 ACPI_FUNCTION_TRACE("acpi_ec_read_info"); 920 921 if (!ec) 922 goto end; 923 924 seq_printf(seq, "gpe bit: 0x%02x\n", 925 (u32) ec->common.gpe_bit); 926 seq_printf(seq, "ports: 0x%02x, 0x%02x\n", 927 (u32) ec->common.status_addr.address, 928 (u32) ec->common.data_addr.address); 929 seq_printf(seq, "use global lock: %s\n", 930 ec->common.global_lock ? "yes" : "no"); 931 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR); 932 933 end: 934 return_VALUE(0); 935 } 936 937 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file) 938 { 939 return single_open(file, acpi_ec_read_info, PDE(inode)->data); 940 } 941 942 static struct file_operations acpi_ec_info_ops = { 943 .open = acpi_ec_info_open_fs, 944 .read = seq_read, 945 .llseek = seq_lseek, 946 .release = single_release, 947 .owner = THIS_MODULE, 948 }; 949 950 static int acpi_ec_add_fs(struct acpi_device *device) 951 { 952 struct proc_dir_entry *entry = NULL; 953 954 ACPI_FUNCTION_TRACE("acpi_ec_add_fs"); 955 956 if (!acpi_device_dir(device)) { 957 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 958 acpi_ec_dir); 959 if (!acpi_device_dir(device)) 960 return_VALUE(-ENODEV); 961 } 962 963 entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO, 964 acpi_device_dir(device)); 965 if (!entry) 966 ACPI_DEBUG_PRINT((ACPI_DB_WARN, 967 "Unable to create '%s' fs entry\n", 968 ACPI_EC_FILE_INFO)); 969 else { 970 entry->proc_fops = &acpi_ec_info_ops; 971 entry->data = acpi_driver_data(device); 972 entry->owner = THIS_MODULE; 973 } 974 975 return_VALUE(0); 976 } 977 978 static int acpi_ec_remove_fs(struct acpi_device *device) 979 { 980 ACPI_FUNCTION_TRACE("acpi_ec_remove_fs"); 981 982 if (acpi_device_dir(device)) { 983 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device)); 984 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir); 985 acpi_device_dir(device) = NULL; 986 } 987 988 return_VALUE(0); 989 } 990 991 /* -------------------------------------------------------------------------- 992 Driver Interface 993 -------------------------------------------------------------------------- */ 994 995 static int acpi_ec_poll_add(struct acpi_device *device) 996 { 997 int result = 0; 998 acpi_status status = AE_OK; 999 union acpi_ec *ec = NULL; 1000 1001 ACPI_FUNCTION_TRACE("acpi_ec_add"); 1002 1003 if (!device) 1004 return_VALUE(-EINVAL); 1005 1006 ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL); 1007 if (!ec) 1008 return_VALUE(-ENOMEM); 1009 memset(ec, 0, sizeof(union acpi_ec)); 1010 1011 ec->common.handle = device->handle; 1012 ec->common.uid = -1; 1013 init_MUTEX(&ec->poll.sem); 1014 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME); 1015 strcpy(acpi_device_class(device), ACPI_EC_CLASS); 1016 acpi_driver_data(device) = ec; 1017 1018 /* Use the global lock for all EC transactions? */ 1019 acpi_evaluate_integer(ec->common.handle, "_GLK", NULL, 1020 &ec->common.global_lock); 1021 1022 /* XXX we don't test uids, because on some boxes ecdt uid = 0, see: 1023 http://bugzilla.kernel.org/show_bug.cgi?id=6111 */ 1024 if (ec_ecdt) { 1025 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT, 1026 ACPI_ADR_SPACE_EC, 1027 &acpi_ec_space_handler); 1028 1029 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit, 1030 &acpi_ec_gpe_handler); 1031 1032 kfree(ec_ecdt); 1033 } 1034 1035 /* Get GPE bit assignment (EC events). */ 1036 /* TODO: Add support for _GPE returning a package */ 1037 status = 1038 acpi_evaluate_integer(ec->common.handle, "_GPE", NULL, 1039 &ec->common.gpe_bit); 1040 if (ACPI_FAILURE(status)) { 1041 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1042 "Error obtaining GPE bit assignment\n")); 1043 result = -ENODEV; 1044 goto end; 1045 } 1046 1047 result = acpi_ec_add_fs(device); 1048 if (result) 1049 goto end; 1050 1051 printk(KERN_INFO PREFIX "%s [%s] (gpe %d) polling mode.\n", 1052 acpi_device_name(device), acpi_device_bid(device), 1053 (u32) ec->common.gpe_bit); 1054 1055 if (!first_ec) 1056 first_ec = device; 1057 1058 end: 1059 if (result) 1060 kfree(ec); 1061 1062 return_VALUE(result); 1063 } 1064 static int acpi_ec_intr_add(struct acpi_device *device) 1065 { 1066 int result = 0; 1067 acpi_status status = AE_OK; 1068 union acpi_ec *ec = NULL; 1069 1070 ACPI_FUNCTION_TRACE("acpi_ec_add"); 1071 1072 if (!device) 1073 return_VALUE(-EINVAL); 1074 1075 ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL); 1076 if (!ec) 1077 return_VALUE(-ENOMEM); 1078 memset(ec, 0, sizeof(union acpi_ec)); 1079 1080 ec->common.handle = device->handle; 1081 ec->common.uid = -1; 1082 atomic_set(&ec->intr.pending_gpe, 0); 1083 atomic_set(&ec->intr.leaving_burst, 1); 1084 init_MUTEX(&ec->intr.sem); 1085 init_waitqueue_head(&ec->intr.wait); 1086 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME); 1087 strcpy(acpi_device_class(device), ACPI_EC_CLASS); 1088 acpi_driver_data(device) = ec; 1089 1090 /* Use the global lock for all EC transactions? */ 1091 acpi_evaluate_integer(ec->common.handle, "_GLK", NULL, 1092 &ec->common.global_lock); 1093 1094 /* XXX we don't test uids, because on some boxes ecdt uid = 0, see: 1095 http://bugzilla.kernel.org/show_bug.cgi?id=6111 */ 1096 if (ec_ecdt) { 1097 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT, 1098 ACPI_ADR_SPACE_EC, 1099 &acpi_ec_space_handler); 1100 1101 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit, 1102 &acpi_ec_gpe_handler); 1103 1104 kfree(ec_ecdt); 1105 } 1106 1107 /* Get GPE bit assignment (EC events). */ 1108 /* TODO: Add support for _GPE returning a package */ 1109 status = 1110 acpi_evaluate_integer(ec->common.handle, "_GPE", NULL, 1111 &ec->common.gpe_bit); 1112 if (ACPI_FAILURE(status)) { 1113 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1114 "Error obtaining GPE bit assignment\n")); 1115 result = -ENODEV; 1116 goto end; 1117 } 1118 1119 result = acpi_ec_add_fs(device); 1120 if (result) 1121 goto end; 1122 1123 printk(KERN_INFO PREFIX "%s [%s] (gpe %d) interrupt mode.\n", 1124 acpi_device_name(device), acpi_device_bid(device), 1125 (u32) ec->common.gpe_bit); 1126 1127 if (!first_ec) 1128 first_ec = device; 1129 1130 end: 1131 if (result) 1132 kfree(ec); 1133 1134 return_VALUE(result); 1135 } 1136 1137 static int acpi_ec_remove(struct acpi_device *device, int type) 1138 { 1139 union acpi_ec *ec = NULL; 1140 1141 ACPI_FUNCTION_TRACE("acpi_ec_remove"); 1142 1143 if (!device) 1144 return_VALUE(-EINVAL); 1145 1146 ec = acpi_driver_data(device); 1147 1148 acpi_ec_remove_fs(device); 1149 1150 kfree(ec); 1151 1152 return_VALUE(0); 1153 } 1154 1155 static acpi_status 1156 acpi_ec_io_ports(struct acpi_resource *resource, void *context) 1157 { 1158 union acpi_ec *ec = (union acpi_ec *)context; 1159 struct acpi_generic_address *addr; 1160 1161 if (resource->type != ACPI_RESOURCE_TYPE_IO) { 1162 return AE_OK; 1163 } 1164 1165 /* 1166 * The first address region returned is the data port, and 1167 * the second address region returned is the status/command 1168 * port. 1169 */ 1170 if (ec->common.data_addr.register_bit_width == 0) { 1171 addr = &ec->common.data_addr; 1172 } else if (ec->common.command_addr.register_bit_width == 0) { 1173 addr = &ec->common.command_addr; 1174 } else { 1175 return AE_CTRL_TERMINATE; 1176 } 1177 1178 addr->address_space_id = ACPI_ADR_SPACE_SYSTEM_IO; 1179 addr->register_bit_width = 8; 1180 addr->register_bit_offset = 0; 1181 addr->address = resource->data.io.minimum; 1182 1183 return AE_OK; 1184 } 1185 1186 static int acpi_ec_start(struct acpi_device *device) 1187 { 1188 acpi_status status = AE_OK; 1189 union acpi_ec *ec = NULL; 1190 1191 ACPI_FUNCTION_TRACE("acpi_ec_start"); 1192 1193 if (!device) 1194 return_VALUE(-EINVAL); 1195 1196 ec = acpi_driver_data(device); 1197 1198 if (!ec) 1199 return_VALUE(-EINVAL); 1200 1201 /* 1202 * Get I/O port addresses. Convert to GAS format. 1203 */ 1204 status = acpi_walk_resources(ec->common.handle, METHOD_NAME__CRS, 1205 acpi_ec_io_ports, ec); 1206 if (ACPI_FAILURE(status) 1207 || ec->common.command_addr.register_bit_width == 0) { 1208 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1209 "Error getting I/O port addresses")); 1210 return_VALUE(-ENODEV); 1211 } 1212 1213 ec->common.status_addr = ec->common.command_addr; 1214 1215 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n", 1216 (u32) ec->common.gpe_bit, 1217 (u32) ec->common.command_addr.address, 1218 (u32) ec->common.data_addr.address)); 1219 1220 /* 1221 * Install GPE handler 1222 */ 1223 status = acpi_install_gpe_handler(NULL, ec->common.gpe_bit, 1224 ACPI_GPE_EDGE_TRIGGERED, 1225 &acpi_ec_gpe_handler, ec); 1226 if (ACPI_FAILURE(status)) { 1227 return_VALUE(-ENODEV); 1228 } 1229 acpi_set_gpe_type(NULL, ec->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME); 1230 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR); 1231 1232 status = acpi_install_address_space_handler(ec->common.handle, 1233 ACPI_ADR_SPACE_EC, 1234 &acpi_ec_space_handler, 1235 &acpi_ec_space_setup, ec); 1236 if (ACPI_FAILURE(status)) { 1237 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit, 1238 &acpi_ec_gpe_handler); 1239 return_VALUE(-ENODEV); 1240 } 1241 1242 return_VALUE(AE_OK); 1243 } 1244 1245 static int acpi_ec_stop(struct acpi_device *device, int type) 1246 { 1247 acpi_status status = AE_OK; 1248 union acpi_ec *ec = NULL; 1249 1250 ACPI_FUNCTION_TRACE("acpi_ec_stop"); 1251 1252 if (!device) 1253 return_VALUE(-EINVAL); 1254 1255 ec = acpi_driver_data(device); 1256 1257 status = acpi_remove_address_space_handler(ec->common.handle, 1258 ACPI_ADR_SPACE_EC, 1259 &acpi_ec_space_handler); 1260 if (ACPI_FAILURE(status)) 1261 return_VALUE(-ENODEV); 1262 1263 status = 1264 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit, 1265 &acpi_ec_gpe_handler); 1266 if (ACPI_FAILURE(status)) 1267 return_VALUE(-ENODEV); 1268 1269 return_VALUE(0); 1270 } 1271 1272 static acpi_status __init 1273 acpi_fake_ecdt_callback(acpi_handle handle, 1274 u32 Level, void *context, void **retval) 1275 { 1276 1277 if (acpi_ec_poll_mode) 1278 return acpi_fake_ecdt_poll_callback(handle, 1279 Level, context, retval); 1280 else 1281 return acpi_fake_ecdt_intr_callback(handle, 1282 Level, context, retval); 1283 } 1284 1285 static acpi_status __init 1286 acpi_fake_ecdt_poll_callback(acpi_handle handle, 1287 u32 Level, void *context, void **retval) 1288 { 1289 acpi_status status; 1290 1291 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 1292 acpi_ec_io_ports, ec_ecdt); 1293 if (ACPI_FAILURE(status)) 1294 return status; 1295 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr; 1296 1297 ec_ecdt->common.uid = -1; 1298 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid); 1299 1300 status = 1301 acpi_evaluate_integer(handle, "_GPE", NULL, 1302 &ec_ecdt->common.gpe_bit); 1303 if (ACPI_FAILURE(status)) 1304 return status; 1305 init_MUTEX(&ec_ecdt->poll.sem); 1306 ec_ecdt->common.global_lock = TRUE; 1307 ec_ecdt->common.handle = handle; 1308 1309 printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n", 1310 (u32) ec_ecdt->common.gpe_bit, 1311 (u32) ec_ecdt->common.command_addr.address, 1312 (u32) ec_ecdt->common.data_addr.address); 1313 1314 return AE_CTRL_TERMINATE; 1315 } 1316 1317 static acpi_status __init 1318 acpi_fake_ecdt_intr_callback(acpi_handle handle, 1319 u32 Level, void *context, void **retval) 1320 { 1321 acpi_status status; 1322 1323 init_MUTEX(&ec_ecdt->intr.sem); 1324 init_waitqueue_head(&ec_ecdt->intr.wait); 1325 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 1326 acpi_ec_io_ports, ec_ecdt); 1327 if (ACPI_FAILURE(status)) 1328 return status; 1329 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr; 1330 1331 ec_ecdt->common.uid = -1; 1332 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid); 1333 1334 status = 1335 acpi_evaluate_integer(handle, "_GPE", NULL, 1336 &ec_ecdt->common.gpe_bit); 1337 if (ACPI_FAILURE(status)) 1338 return status; 1339 ec_ecdt->common.global_lock = TRUE; 1340 ec_ecdt->common.handle = handle; 1341 1342 printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n", 1343 (u32) ec_ecdt->common.gpe_bit, 1344 (u32) ec_ecdt->common.command_addr.address, 1345 (u32) ec_ecdt->common.data_addr.address); 1346 1347 return AE_CTRL_TERMINATE; 1348 } 1349 1350 /* 1351 * Some BIOS (such as some from Gateway laptops) access EC region very early 1352 * such as in BAT0._INI or EC._INI before an EC device is found and 1353 * do not provide an ECDT. According to ACPI spec, ECDT isn't mandatorily 1354 * required, but if EC regison is accessed early, it is required. 1355 * The routine tries to workaround the BIOS bug by pre-scan EC device 1356 * It assumes that _CRS, _HID, _GPE, _UID methods of EC don't touch any 1357 * op region (since _REG isn't invoked yet). The assumption is true for 1358 * all systems found. 1359 */ 1360 static int __init acpi_ec_fake_ecdt(void) 1361 { 1362 acpi_status status; 1363 int ret = 0; 1364 1365 printk(KERN_INFO PREFIX "Try to make an fake ECDT\n"); 1366 1367 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL); 1368 if (!ec_ecdt) { 1369 ret = -ENOMEM; 1370 goto error; 1371 } 1372 memset(ec_ecdt, 0, sizeof(union acpi_ec)); 1373 1374 status = acpi_get_devices(ACPI_EC_HID, 1375 acpi_fake_ecdt_callback, NULL, NULL); 1376 if (ACPI_FAILURE(status)) { 1377 kfree(ec_ecdt); 1378 ec_ecdt = NULL; 1379 ret = -ENODEV; 1380 goto error; 1381 } 1382 return 0; 1383 error: 1384 printk(KERN_ERR PREFIX "Can't make an fake ECDT\n"); 1385 return ret; 1386 } 1387 1388 static int __init acpi_ec_get_real_ecdt(void) 1389 { 1390 if (acpi_ec_poll_mode) 1391 return acpi_ec_poll_get_real_ecdt(); 1392 else 1393 return acpi_ec_intr_get_real_ecdt(); 1394 } 1395 1396 static int __init acpi_ec_poll_get_real_ecdt(void) 1397 { 1398 acpi_status status; 1399 struct acpi_table_ecdt *ecdt_ptr; 1400 1401 status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING, 1402 (struct acpi_table_header **) 1403 &ecdt_ptr); 1404 if (ACPI_FAILURE(status)) 1405 return -ENODEV; 1406 1407 printk(KERN_INFO PREFIX "Found ECDT\n"); 1408 1409 /* 1410 * Generate a temporary ec context to use until the namespace is scanned 1411 */ 1412 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL); 1413 if (!ec_ecdt) 1414 return -ENOMEM; 1415 memset(ec_ecdt, 0, sizeof(union acpi_ec)); 1416 1417 ec_ecdt->common.command_addr = ecdt_ptr->ec_control; 1418 ec_ecdt->common.status_addr = ecdt_ptr->ec_control; 1419 ec_ecdt->common.data_addr = ecdt_ptr->ec_data; 1420 ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit; 1421 init_MUTEX(&ec_ecdt->poll.sem); 1422 /* use the GL just to be safe */ 1423 ec_ecdt->common.global_lock = TRUE; 1424 ec_ecdt->common.uid = ecdt_ptr->uid; 1425 1426 status = 1427 acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle); 1428 if (ACPI_FAILURE(status)) { 1429 goto error; 1430 } 1431 1432 return 0; 1433 error: 1434 printk(KERN_ERR PREFIX "Could not use ECDT\n"); 1435 kfree(ec_ecdt); 1436 ec_ecdt = NULL; 1437 1438 return -ENODEV; 1439 } 1440 1441 static int __init acpi_ec_intr_get_real_ecdt(void) 1442 { 1443 acpi_status status; 1444 struct acpi_table_ecdt *ecdt_ptr; 1445 1446 status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING, 1447 (struct acpi_table_header **) 1448 &ecdt_ptr); 1449 if (ACPI_FAILURE(status)) 1450 return -ENODEV; 1451 1452 printk(KERN_INFO PREFIX "Found ECDT\n"); 1453 1454 /* 1455 * Generate a temporary ec context to use until the namespace is scanned 1456 */ 1457 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL); 1458 if (!ec_ecdt) 1459 return -ENOMEM; 1460 memset(ec_ecdt, 0, sizeof(union acpi_ec)); 1461 1462 init_MUTEX(&ec_ecdt->intr.sem); 1463 init_waitqueue_head(&ec_ecdt->intr.wait); 1464 ec_ecdt->common.command_addr = ecdt_ptr->ec_control; 1465 ec_ecdt->common.status_addr = ecdt_ptr->ec_control; 1466 ec_ecdt->common.data_addr = ecdt_ptr->ec_data; 1467 ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit; 1468 /* use the GL just to be safe */ 1469 ec_ecdt->common.global_lock = TRUE; 1470 ec_ecdt->common.uid = ecdt_ptr->uid; 1471 1472 status = 1473 acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle); 1474 if (ACPI_FAILURE(status)) { 1475 goto error; 1476 } 1477 1478 return 0; 1479 error: 1480 printk(KERN_ERR PREFIX "Could not use ECDT\n"); 1481 kfree(ec_ecdt); 1482 ec_ecdt = NULL; 1483 1484 return -ENODEV; 1485 } 1486 1487 static int __initdata acpi_fake_ecdt_enabled; 1488 int __init acpi_ec_ecdt_probe(void) 1489 { 1490 acpi_status status; 1491 int ret; 1492 1493 ret = acpi_ec_get_real_ecdt(); 1494 /* Try to make a fake ECDT */ 1495 if (ret && acpi_fake_ecdt_enabled) { 1496 ret = acpi_ec_fake_ecdt(); 1497 } 1498 1499 if (ret) 1500 return 0; 1501 1502 /* 1503 * Install GPE handler 1504 */ 1505 status = acpi_install_gpe_handler(NULL, ec_ecdt->common.gpe_bit, 1506 ACPI_GPE_EDGE_TRIGGERED, 1507 &acpi_ec_gpe_handler, ec_ecdt); 1508 if (ACPI_FAILURE(status)) { 1509 goto error; 1510 } 1511 acpi_set_gpe_type(NULL, ec_ecdt->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME); 1512 acpi_enable_gpe(NULL, ec_ecdt->common.gpe_bit, ACPI_NOT_ISR); 1513 1514 status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT, 1515 ACPI_ADR_SPACE_EC, 1516 &acpi_ec_space_handler, 1517 &acpi_ec_space_setup, 1518 ec_ecdt); 1519 if (ACPI_FAILURE(status)) { 1520 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit, 1521 &acpi_ec_gpe_handler); 1522 goto error; 1523 } 1524 1525 return 0; 1526 1527 error: 1528 printk(KERN_ERR PREFIX "Could not use ECDT\n"); 1529 kfree(ec_ecdt); 1530 ec_ecdt = NULL; 1531 1532 return -ENODEV; 1533 } 1534 1535 static int __init acpi_ec_init(void) 1536 { 1537 int result = 0; 1538 1539 ACPI_FUNCTION_TRACE("acpi_ec_init"); 1540 1541 if (acpi_disabled) 1542 return_VALUE(0); 1543 1544 acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir); 1545 if (!acpi_ec_dir) 1546 return_VALUE(-ENODEV); 1547 1548 /* Now register the driver for the EC */ 1549 result = acpi_bus_register_driver(&acpi_ec_driver); 1550 if (result < 0) { 1551 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 1552 return_VALUE(-ENODEV); 1553 } 1554 1555 return_VALUE(result); 1556 } 1557 1558 subsys_initcall(acpi_ec_init); 1559 1560 /* EC driver currently not unloadable */ 1561 #if 0 1562 static void __exit acpi_ec_exit(void) 1563 { 1564 ACPI_FUNCTION_TRACE("acpi_ec_exit"); 1565 1566 acpi_bus_unregister_driver(&acpi_ec_driver); 1567 1568 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 1569 1570 return_VOID; 1571 } 1572 #endif /* 0 */ 1573 1574 static int __init acpi_fake_ecdt_setup(char *str) 1575 { 1576 acpi_fake_ecdt_enabled = 1; 1577 return 1; 1578 } 1579 1580 __setup("acpi_fake_ecdt", acpi_fake_ecdt_setup); 1581 static int __init acpi_ec_set_intr_mode(char *str) 1582 { 1583 int intr; 1584 1585 if (!get_option(&str, &intr)) 1586 return 0; 1587 1588 if (intr) { 1589 acpi_ec_poll_mode = EC_INTR; 1590 acpi_ec_driver.ops.add = acpi_ec_intr_add; 1591 } else { 1592 acpi_ec_poll_mode = EC_POLL; 1593 acpi_ec_driver.ops.add = acpi_ec_poll_add; 1594 } 1595 printk(KERN_INFO PREFIX "EC %s mode.\n", intr ? "interrupt" : "polling"); 1596 return 1; 1597 } 1598 1599 __setup("ec_intr=", acpi_ec_set_intr_mode); 1600