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 spinlock_t lock; 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 unsigned long flags = 0; 327 u32 glk = 0; 328 329 ACPI_FUNCTION_TRACE("acpi_ec_read"); 330 331 if (!ec || !data) 332 return_VALUE(-EINVAL); 333 334 *data = 0; 335 336 if (ec->common.global_lock) { 337 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 338 if (ACPI_FAILURE(status)) 339 return_VALUE(-ENODEV); 340 } 341 342 spin_lock_irqsave(&ec->poll.lock, flags); 343 344 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ, 345 &ec->common.command_addr); 346 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 347 if (result) 348 goto end; 349 350 acpi_hw_low_level_write(8, address, &ec->common.data_addr); 351 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 352 if (result) 353 goto end; 354 355 acpi_hw_low_level_read(8, data, &ec->common.data_addr); 356 357 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n", 358 *data, address)); 359 360 end: 361 spin_unlock_irqrestore(&ec->poll.lock, flags); 362 363 if (ec->common.global_lock) 364 acpi_release_global_lock(glk); 365 366 return_VALUE(result); 367 } 368 369 static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data) 370 { 371 int result = 0; 372 acpi_status status = AE_OK; 373 unsigned long flags = 0; 374 u32 glk = 0; 375 376 ACPI_FUNCTION_TRACE("acpi_ec_write"); 377 378 if (!ec) 379 return_VALUE(-EINVAL); 380 381 if (ec->common.global_lock) { 382 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 383 if (ACPI_FAILURE(status)) 384 return_VALUE(-ENODEV); 385 } 386 387 spin_lock_irqsave(&ec->poll.lock, flags); 388 389 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE, 390 &ec->common.command_addr); 391 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 392 if (result) 393 goto end; 394 395 acpi_hw_low_level_write(8, address, &ec->common.data_addr); 396 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 397 if (result) 398 goto end; 399 400 acpi_hw_low_level_write(8, data, &ec->common.data_addr); 401 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 402 if (result) 403 goto end; 404 405 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n", 406 data, address)); 407 408 end: 409 spin_unlock_irqrestore(&ec->poll.lock, flags); 410 411 if (ec->common.global_lock) 412 acpi_release_global_lock(glk); 413 414 return_VALUE(result); 415 } 416 417 static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data) 418 { 419 int status = 0; 420 u32 glk; 421 422 ACPI_FUNCTION_TRACE("acpi_ec_read"); 423 424 if (!ec || !data) 425 return_VALUE(-EINVAL); 426 427 *data = 0; 428 429 if (ec->common.global_lock) { 430 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 431 if (ACPI_FAILURE(status)) 432 return_VALUE(-ENODEV); 433 } 434 435 WARN_ON(in_interrupt()); 436 down(&ec->intr.sem); 437 438 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 439 if (status) { 440 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n"); 441 goto end; 442 } 443 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ, 444 &ec->common.command_addr); 445 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 446 if (status) { 447 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n"); 448 } 449 450 acpi_hw_low_level_write(8, address, &ec->common.data_addr); 451 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 452 if (status) { 453 printk(KERN_DEBUG PREFIX "read EC, OB not full\n"); 454 goto end; 455 } 456 acpi_hw_low_level_read(8, data, &ec->common.data_addr); 457 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n", 458 *data, address)); 459 460 end: 461 up(&ec->intr.sem); 462 463 if (ec->common.global_lock) 464 acpi_release_global_lock(glk); 465 466 return_VALUE(status); 467 } 468 469 static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data) 470 { 471 int status = 0; 472 u32 glk; 473 474 ACPI_FUNCTION_TRACE("acpi_ec_write"); 475 476 if (!ec) 477 return_VALUE(-EINVAL); 478 479 if (ec->common.global_lock) { 480 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 481 if (ACPI_FAILURE(status)) 482 return_VALUE(-ENODEV); 483 } 484 485 WARN_ON(in_interrupt()); 486 down(&ec->intr.sem); 487 488 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 489 if (status) { 490 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n"); 491 } 492 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE, 493 &ec->common.command_addr); 494 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 495 if (status) { 496 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n"); 497 } 498 499 acpi_hw_low_level_write(8, address, &ec->common.data_addr); 500 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 501 if (status) { 502 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n"); 503 } 504 505 acpi_hw_low_level_write(8, data, &ec->common.data_addr); 506 507 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n", 508 data, address)); 509 510 up(&ec->intr.sem); 511 512 if (ec->common.global_lock) 513 acpi_release_global_lock(glk); 514 515 return_VALUE(status); 516 } 517 518 /* 519 * Externally callable EC access functions. For now, assume 1 EC only 520 */ 521 int ec_read(u8 addr, u8 * val) 522 { 523 union acpi_ec *ec; 524 int err; 525 u32 temp_data; 526 527 if (!first_ec) 528 return -ENODEV; 529 530 ec = acpi_driver_data(first_ec); 531 532 err = acpi_ec_read(ec, addr, &temp_data); 533 534 if (!err) { 535 *val = temp_data; 536 return 0; 537 } else 538 return err; 539 } 540 541 EXPORT_SYMBOL(ec_read); 542 543 int ec_write(u8 addr, u8 val) 544 { 545 union acpi_ec *ec; 546 int err; 547 548 if (!first_ec) 549 return -ENODEV; 550 551 ec = acpi_driver_data(first_ec); 552 553 err = acpi_ec_write(ec, addr, val); 554 555 return err; 556 } 557 558 EXPORT_SYMBOL(ec_write); 559 560 static int acpi_ec_query(union acpi_ec *ec, u32 * data) 561 { 562 if (acpi_ec_poll_mode) 563 return acpi_ec_poll_query(ec, data); 564 else 565 return acpi_ec_intr_query(ec, data); 566 } 567 static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data) 568 { 569 int result = 0; 570 acpi_status status = AE_OK; 571 unsigned long flags = 0; 572 u32 glk = 0; 573 574 ACPI_FUNCTION_TRACE("acpi_ec_query"); 575 576 if (!ec || !data) 577 return_VALUE(-EINVAL); 578 579 *data = 0; 580 581 if (ec->common.global_lock) { 582 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 583 if (ACPI_FAILURE(status)) 584 return_VALUE(-ENODEV); 585 } 586 587 /* 588 * Query the EC to find out which _Qxx method we need to evaluate. 589 * Note that successful completion of the query causes the ACPI_EC_SCI 590 * bit to be cleared (and thus clearing the interrupt source). 591 */ 592 spin_lock_irqsave(&ec->poll.lock, flags); 593 594 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY, 595 &ec->common.command_addr); 596 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 597 if (result) 598 goto end; 599 600 acpi_hw_low_level_read(8, data, &ec->common.data_addr); 601 if (!*data) 602 result = -ENODATA; 603 604 end: 605 spin_unlock_irqrestore(&ec->poll.lock, flags); 606 607 if (ec->common.global_lock) 608 acpi_release_global_lock(glk); 609 610 return_VALUE(result); 611 } 612 static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data) 613 { 614 int status = 0; 615 u32 glk; 616 617 ACPI_FUNCTION_TRACE("acpi_ec_query"); 618 619 if (!ec || !data) 620 return_VALUE(-EINVAL); 621 *data = 0; 622 623 if (ec->common.global_lock) { 624 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk); 625 if (ACPI_FAILURE(status)) 626 return_VALUE(-ENODEV); 627 } 628 629 down(&ec->intr.sem); 630 631 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE); 632 if (status) { 633 printk(KERN_DEBUG PREFIX "query EC, IB not empty\n"); 634 goto end; 635 } 636 /* 637 * Query the EC to find out which _Qxx method we need to evaluate. 638 * Note that successful completion of the query causes the ACPI_EC_SCI 639 * bit to be cleared (and thus clearing the interrupt source). 640 */ 641 acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY, 642 &ec->common.command_addr); 643 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF); 644 if (status) { 645 printk(KERN_DEBUG PREFIX "query EC, OB not full\n"); 646 goto end; 647 } 648 649 acpi_hw_low_level_read(8, data, &ec->common.data_addr); 650 if (!*data) 651 status = -ENODATA; 652 653 end: 654 up(&ec->intr.sem); 655 656 if (ec->common.global_lock) 657 acpi_release_global_lock(glk); 658 659 return_VALUE(status); 660 } 661 662 /* -------------------------------------------------------------------------- 663 Event Management 664 -------------------------------------------------------------------------- */ 665 666 union acpi_ec_query_data { 667 acpi_handle handle; 668 u8 data; 669 }; 670 671 static void acpi_ec_gpe_query(void *ec_cxt) 672 { 673 if (acpi_ec_poll_mode) 674 acpi_ec_gpe_poll_query(ec_cxt); 675 else 676 acpi_ec_gpe_intr_query(ec_cxt); 677 } 678 679 static void acpi_ec_gpe_poll_query(void *ec_cxt) 680 { 681 union acpi_ec *ec = (union acpi_ec *)ec_cxt; 682 u32 value = 0; 683 unsigned long flags = 0; 684 static char object_name[5] = { '_', 'Q', '0', '0', '\0' }; 685 const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', 686 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 687 }; 688 689 ACPI_FUNCTION_TRACE("acpi_ec_gpe_query"); 690 691 if (!ec_cxt) 692 goto end; 693 694 spin_lock_irqsave(&ec->poll.lock, flags); 695 acpi_hw_low_level_read(8, &value, &ec->common.command_addr); 696 spin_unlock_irqrestore(&ec->poll.lock, flags); 697 698 /* TBD: Implement asynch events! 699 * NOTE: All we care about are EC-SCI's. Other EC events are 700 * handled via polling (yuck!). This is because some systems 701 * treat EC-SCIs as level (versus EDGE!) triggered, preventing 702 * a purely interrupt-driven approach (grumble, grumble). 703 */ 704 if (!(value & ACPI_EC_FLAG_SCI)) 705 goto end; 706 707 if (acpi_ec_query(ec, &value)) 708 goto end; 709 710 object_name[2] = hex[((value >> 4) & 0x0F)]; 711 object_name[3] = hex[(value & 0x0F)]; 712 713 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name)); 714 715 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL); 716 717 end: 718 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR); 719 } 720 static void acpi_ec_gpe_intr_query(void *ec_cxt) 721 { 722 union acpi_ec *ec = (union acpi_ec *)ec_cxt; 723 u32 value; 724 int result = -ENODATA; 725 static char object_name[5] = { '_', 'Q', '0', '0', '\0' }; 726 const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', 727 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 728 }; 729 730 ACPI_FUNCTION_TRACE("acpi_ec_gpe_query"); 731 732 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_SCI) 733 result = acpi_ec_query(ec, &value); 734 735 if (result) 736 goto end; 737 738 object_name[2] = hex[((value >> 4) & 0x0F)]; 739 object_name[3] = hex[(value & 0x0F)]; 740 741 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name)); 742 743 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL); 744 end: 745 atomic_dec(&ec->intr.pending_gpe); 746 return; 747 } 748 749 static u32 acpi_ec_gpe_handler(void *data) 750 { 751 if (acpi_ec_poll_mode) 752 return acpi_ec_gpe_poll_handler(data); 753 else 754 return acpi_ec_gpe_intr_handler(data); 755 } 756 static u32 acpi_ec_gpe_poll_handler(void *data) 757 { 758 acpi_status status = AE_OK; 759 union acpi_ec *ec = (union acpi_ec *)data; 760 761 if (!ec) 762 return ACPI_INTERRUPT_NOT_HANDLED; 763 764 acpi_disable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR); 765 766 status = acpi_os_queue_for_execution(OSD_PRIORITY_GPE, 767 acpi_ec_gpe_query, ec); 768 769 if (status == AE_OK) 770 return ACPI_INTERRUPT_HANDLED; 771 else 772 return ACPI_INTERRUPT_NOT_HANDLED; 773 } 774 static u32 acpi_ec_gpe_intr_handler(void *data) 775 { 776 acpi_status status = AE_OK; 777 u32 value; 778 union acpi_ec *ec = (union acpi_ec *)data; 779 780 if (!ec) 781 return ACPI_INTERRUPT_NOT_HANDLED; 782 783 acpi_clear_gpe(NULL, ec->common.gpe_bit, ACPI_ISR); 784 value = acpi_ec_read_status(ec); 785 786 switch (ec->intr.expect_event) { 787 case ACPI_EC_EVENT_OBF: 788 if (!(value & ACPI_EC_FLAG_OBF)) 789 break; 790 case ACPI_EC_EVENT_IBE: 791 if ((value & ACPI_EC_FLAG_IBF)) 792 break; 793 ec->intr.expect_event = 0; 794 wake_up(&ec->intr.wait); 795 return ACPI_INTERRUPT_HANDLED; 796 default: 797 break; 798 } 799 800 if (value & ACPI_EC_FLAG_SCI) { 801 atomic_add(1, &ec->intr.pending_gpe); 802 status = acpi_os_queue_for_execution(OSD_PRIORITY_GPE, 803 acpi_ec_gpe_query, ec); 804 return status == AE_OK ? 805 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED; 806 } 807 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR); 808 return status == AE_OK ? 809 ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED; 810 } 811 812 /* -------------------------------------------------------------------------- 813 Address Space Management 814 -------------------------------------------------------------------------- */ 815 816 static acpi_status 817 acpi_ec_space_setup(acpi_handle region_handle, 818 u32 function, void *handler_context, void **return_context) 819 { 820 /* 821 * The EC object is in the handler context and is needed 822 * when calling the acpi_ec_space_handler. 823 */ 824 *return_context = (function != ACPI_REGION_DEACTIVATE) ? 825 handler_context : NULL; 826 827 return AE_OK; 828 } 829 830 static acpi_status 831 acpi_ec_space_handler(u32 function, 832 acpi_physical_address address, 833 u32 bit_width, 834 acpi_integer * value, 835 void *handler_context, void *region_context) 836 { 837 int result = 0; 838 union acpi_ec *ec = NULL; 839 u64 temp = *value; 840 acpi_integer f_v = 0; 841 int i = 0; 842 843 ACPI_FUNCTION_TRACE("acpi_ec_space_handler"); 844 845 if ((address > 0xFF) || !value || !handler_context) 846 return_VALUE(AE_BAD_PARAMETER); 847 848 if (bit_width != 8 && acpi_strict) { 849 printk(KERN_WARNING PREFIX 850 "acpi_ec_space_handler: bit_width should be 8\n"); 851 return_VALUE(AE_BAD_PARAMETER); 852 } 853 854 ec = (union acpi_ec *)handler_context; 855 856 next_byte: 857 switch (function) { 858 case ACPI_READ: 859 temp = 0; 860 result = acpi_ec_read(ec, (u8) address, (u32 *) & temp); 861 break; 862 case ACPI_WRITE: 863 result = acpi_ec_write(ec, (u8) address, (u8) temp); 864 break; 865 default: 866 result = -EINVAL; 867 goto out; 868 break; 869 } 870 871 bit_width -= 8; 872 if (bit_width) { 873 if (function == ACPI_READ) 874 f_v |= temp << 8 * i; 875 if (function == ACPI_WRITE) 876 temp >>= 8; 877 i++; 878 address++; 879 goto next_byte; 880 } 881 882 if (function == ACPI_READ) { 883 f_v |= temp << 8 * i; 884 *value = f_v; 885 } 886 887 out: 888 switch (result) { 889 case -EINVAL: 890 return_VALUE(AE_BAD_PARAMETER); 891 break; 892 case -ENODEV: 893 return_VALUE(AE_NOT_FOUND); 894 break; 895 case -ETIME: 896 return_VALUE(AE_TIME); 897 break; 898 default: 899 return_VALUE(AE_OK); 900 } 901 } 902 903 /* -------------------------------------------------------------------------- 904 FS Interface (/proc) 905 -------------------------------------------------------------------------- */ 906 907 static struct proc_dir_entry *acpi_ec_dir; 908 909 static int acpi_ec_read_info(struct seq_file *seq, void *offset) 910 { 911 union acpi_ec *ec = (union acpi_ec *)seq->private; 912 913 ACPI_FUNCTION_TRACE("acpi_ec_read_info"); 914 915 if (!ec) 916 goto end; 917 918 seq_printf(seq, "gpe bit: 0x%02x\n", 919 (u32) ec->common.gpe_bit); 920 seq_printf(seq, "ports: 0x%02x, 0x%02x\n", 921 (u32) ec->common.status_addr.address, 922 (u32) ec->common.data_addr.address); 923 seq_printf(seq, "use global lock: %s\n", 924 ec->common.global_lock ? "yes" : "no"); 925 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR); 926 927 end: 928 return_VALUE(0); 929 } 930 931 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file) 932 { 933 return single_open(file, acpi_ec_read_info, PDE(inode)->data); 934 } 935 936 static struct file_operations acpi_ec_info_ops = { 937 .open = acpi_ec_info_open_fs, 938 .read = seq_read, 939 .llseek = seq_lseek, 940 .release = single_release, 941 .owner = THIS_MODULE, 942 }; 943 944 static int acpi_ec_add_fs(struct acpi_device *device) 945 { 946 struct proc_dir_entry *entry = NULL; 947 948 ACPI_FUNCTION_TRACE("acpi_ec_add_fs"); 949 950 if (!acpi_device_dir(device)) { 951 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 952 acpi_ec_dir); 953 if (!acpi_device_dir(device)) 954 return_VALUE(-ENODEV); 955 } 956 957 entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO, 958 acpi_device_dir(device)); 959 if (!entry) 960 ACPI_DEBUG_PRINT((ACPI_DB_WARN, 961 "Unable to create '%s' fs entry\n", 962 ACPI_EC_FILE_INFO)); 963 else { 964 entry->proc_fops = &acpi_ec_info_ops; 965 entry->data = acpi_driver_data(device); 966 entry->owner = THIS_MODULE; 967 } 968 969 return_VALUE(0); 970 } 971 972 static int acpi_ec_remove_fs(struct acpi_device *device) 973 { 974 ACPI_FUNCTION_TRACE("acpi_ec_remove_fs"); 975 976 if (acpi_device_dir(device)) { 977 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device)); 978 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir); 979 acpi_device_dir(device) = NULL; 980 } 981 982 return_VALUE(0); 983 } 984 985 /* -------------------------------------------------------------------------- 986 Driver Interface 987 -------------------------------------------------------------------------- */ 988 989 static int acpi_ec_poll_add(struct acpi_device *device) 990 { 991 int result = 0; 992 acpi_status status = AE_OK; 993 union acpi_ec *ec = NULL; 994 unsigned long uid; 995 996 ACPI_FUNCTION_TRACE("acpi_ec_add"); 997 998 if (!device) 999 return_VALUE(-EINVAL); 1000 1001 ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL); 1002 if (!ec) 1003 return_VALUE(-ENOMEM); 1004 memset(ec, 0, sizeof(union acpi_ec)); 1005 1006 ec->common.handle = device->handle; 1007 ec->common.uid = -1; 1008 spin_lock_init(&ec->poll.lock); 1009 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME); 1010 strcpy(acpi_device_class(device), ACPI_EC_CLASS); 1011 acpi_driver_data(device) = ec; 1012 1013 /* Use the global lock for all EC transactions? */ 1014 acpi_evaluate_integer(ec->common.handle, "_GLK", NULL, 1015 &ec->common.global_lock); 1016 1017 /* If our UID matches the UID for the ECDT-enumerated EC, 1018 we now have the *real* EC info, so kill the makeshift one. */ 1019 acpi_evaluate_integer(ec->common.handle, "_UID", NULL, &uid); 1020 if (ec_ecdt && ec_ecdt->common.uid == uid) { 1021 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT, 1022 ACPI_ADR_SPACE_EC, 1023 &acpi_ec_space_handler); 1024 1025 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit, 1026 &acpi_ec_gpe_handler); 1027 1028 kfree(ec_ecdt); 1029 } 1030 1031 /* Get GPE bit assignment (EC events). */ 1032 /* TODO: Add support for _GPE returning a package */ 1033 status = 1034 acpi_evaluate_integer(ec->common.handle, "_GPE", NULL, 1035 &ec->common.gpe_bit); 1036 if (ACPI_FAILURE(status)) { 1037 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1038 "Error obtaining GPE bit assignment\n")); 1039 result = -ENODEV; 1040 goto end; 1041 } 1042 1043 result = acpi_ec_add_fs(device); 1044 if (result) 1045 goto end; 1046 1047 printk(KERN_INFO PREFIX "%s [%s] (gpe %d) polling mode.\n", 1048 acpi_device_name(device), acpi_device_bid(device), 1049 (u32) ec->common.gpe_bit); 1050 1051 if (!first_ec) 1052 first_ec = device; 1053 1054 end: 1055 if (result) 1056 kfree(ec); 1057 1058 return_VALUE(result); 1059 } 1060 static int acpi_ec_intr_add(struct acpi_device *device) 1061 { 1062 int result = 0; 1063 acpi_status status = AE_OK; 1064 union acpi_ec *ec = NULL; 1065 unsigned long uid; 1066 1067 ACPI_FUNCTION_TRACE("acpi_ec_add"); 1068 1069 if (!device) 1070 return_VALUE(-EINVAL); 1071 1072 ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL); 1073 if (!ec) 1074 return_VALUE(-ENOMEM); 1075 memset(ec, 0, sizeof(union acpi_ec)); 1076 1077 ec->common.handle = device->handle; 1078 ec->common.uid = -1; 1079 atomic_set(&ec->intr.pending_gpe, 0); 1080 atomic_set(&ec->intr.leaving_burst, 1); 1081 init_MUTEX(&ec->intr.sem); 1082 init_waitqueue_head(&ec->intr.wait); 1083 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME); 1084 strcpy(acpi_device_class(device), ACPI_EC_CLASS); 1085 acpi_driver_data(device) = ec; 1086 1087 /* Use the global lock for all EC transactions? */ 1088 acpi_evaluate_integer(ec->common.handle, "_GLK", NULL, 1089 &ec->common.global_lock); 1090 1091 /* If our UID matches the UID for the ECDT-enumerated EC, 1092 we now have the *real* EC info, so kill the makeshift one. */ 1093 acpi_evaluate_integer(ec->common.handle, "_UID", NULL, &uid); 1094 if (ec_ecdt && ec_ecdt->common.uid == uid) { 1095 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT, 1096 ACPI_ADR_SPACE_EC, 1097 &acpi_ec_space_handler); 1098 1099 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit, 1100 &acpi_ec_gpe_handler); 1101 1102 kfree(ec_ecdt); 1103 } 1104 1105 /* Get GPE bit assignment (EC events). */ 1106 /* TODO: Add support for _GPE returning a package */ 1107 status = 1108 acpi_evaluate_integer(ec->common.handle, "_GPE", NULL, 1109 &ec->common.gpe_bit); 1110 if (ACPI_FAILURE(status)) { 1111 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1112 "Error obtaining GPE bit assignment\n")); 1113 result = -ENODEV; 1114 goto end; 1115 } 1116 1117 result = acpi_ec_add_fs(device); 1118 if (result) 1119 goto end; 1120 1121 printk(KERN_INFO PREFIX "%s [%s] (gpe %d) interrupt mode.\n", 1122 acpi_device_name(device), acpi_device_bid(device), 1123 (u32) ec->common.gpe_bit); 1124 1125 if (!first_ec) 1126 first_ec = device; 1127 1128 end: 1129 if (result) 1130 kfree(ec); 1131 1132 return_VALUE(result); 1133 } 1134 1135 static int acpi_ec_remove(struct acpi_device *device, int type) 1136 { 1137 union acpi_ec *ec = NULL; 1138 1139 ACPI_FUNCTION_TRACE("acpi_ec_remove"); 1140 1141 if (!device) 1142 return_VALUE(-EINVAL); 1143 1144 ec = acpi_driver_data(device); 1145 1146 acpi_ec_remove_fs(device); 1147 1148 kfree(ec); 1149 1150 return_VALUE(0); 1151 } 1152 1153 static acpi_status 1154 acpi_ec_io_ports(struct acpi_resource *resource, void *context) 1155 { 1156 union acpi_ec *ec = (union acpi_ec *)context; 1157 struct acpi_generic_address *addr; 1158 1159 if (resource->type != ACPI_RESOURCE_TYPE_IO) { 1160 return AE_OK; 1161 } 1162 1163 /* 1164 * The first address region returned is the data port, and 1165 * the second address region returned is the status/command 1166 * port. 1167 */ 1168 if (ec->common.data_addr.register_bit_width == 0) { 1169 addr = &ec->common.data_addr; 1170 } else if (ec->common.command_addr.register_bit_width == 0) { 1171 addr = &ec->common.command_addr; 1172 } else { 1173 return AE_CTRL_TERMINATE; 1174 } 1175 1176 addr->address_space_id = ACPI_ADR_SPACE_SYSTEM_IO; 1177 addr->register_bit_width = 8; 1178 addr->register_bit_offset = 0; 1179 addr->address = resource->data.io.minimum; 1180 1181 return AE_OK; 1182 } 1183 1184 static int acpi_ec_start(struct acpi_device *device) 1185 { 1186 acpi_status status = AE_OK; 1187 union acpi_ec *ec = NULL; 1188 1189 ACPI_FUNCTION_TRACE("acpi_ec_start"); 1190 1191 if (!device) 1192 return_VALUE(-EINVAL); 1193 1194 ec = acpi_driver_data(device); 1195 1196 if (!ec) 1197 return_VALUE(-EINVAL); 1198 1199 /* 1200 * Get I/O port addresses. Convert to GAS format. 1201 */ 1202 status = acpi_walk_resources(ec->common.handle, METHOD_NAME__CRS, 1203 acpi_ec_io_ports, ec); 1204 if (ACPI_FAILURE(status) 1205 || ec->common.command_addr.register_bit_width == 0) { 1206 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1207 "Error getting I/O port addresses")); 1208 return_VALUE(-ENODEV); 1209 } 1210 1211 ec->common.status_addr = ec->common.command_addr; 1212 1213 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n", 1214 (u32) ec->common.gpe_bit, 1215 (u32) ec->common.command_addr.address, 1216 (u32) ec->common.data_addr.address)); 1217 1218 /* 1219 * Install GPE handler 1220 */ 1221 status = acpi_install_gpe_handler(NULL, ec->common.gpe_bit, 1222 ACPI_GPE_EDGE_TRIGGERED, 1223 &acpi_ec_gpe_handler, ec); 1224 if (ACPI_FAILURE(status)) { 1225 return_VALUE(-ENODEV); 1226 } 1227 acpi_set_gpe_type(NULL, ec->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME); 1228 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR); 1229 1230 status = acpi_install_address_space_handler(ec->common.handle, 1231 ACPI_ADR_SPACE_EC, 1232 &acpi_ec_space_handler, 1233 &acpi_ec_space_setup, ec); 1234 if (ACPI_FAILURE(status)) { 1235 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit, 1236 &acpi_ec_gpe_handler); 1237 return_VALUE(-ENODEV); 1238 } 1239 1240 return_VALUE(AE_OK); 1241 } 1242 1243 static int acpi_ec_stop(struct acpi_device *device, int type) 1244 { 1245 acpi_status status = AE_OK; 1246 union acpi_ec *ec = NULL; 1247 1248 ACPI_FUNCTION_TRACE("acpi_ec_stop"); 1249 1250 if (!device) 1251 return_VALUE(-EINVAL); 1252 1253 ec = acpi_driver_data(device); 1254 1255 status = acpi_remove_address_space_handler(ec->common.handle, 1256 ACPI_ADR_SPACE_EC, 1257 &acpi_ec_space_handler); 1258 if (ACPI_FAILURE(status)) 1259 return_VALUE(-ENODEV); 1260 1261 status = 1262 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit, 1263 &acpi_ec_gpe_handler); 1264 if (ACPI_FAILURE(status)) 1265 return_VALUE(-ENODEV); 1266 1267 return_VALUE(0); 1268 } 1269 1270 static acpi_status __init 1271 acpi_fake_ecdt_callback(acpi_handle handle, 1272 u32 Level, void *context, void **retval) 1273 { 1274 1275 if (acpi_ec_poll_mode) 1276 return acpi_fake_ecdt_poll_callback(handle, 1277 Level, context, retval); 1278 else 1279 return acpi_fake_ecdt_intr_callback(handle, 1280 Level, context, retval); 1281 } 1282 1283 static acpi_status __init 1284 acpi_fake_ecdt_poll_callback(acpi_handle handle, 1285 u32 Level, void *context, void **retval) 1286 { 1287 acpi_status status; 1288 1289 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 1290 acpi_ec_io_ports, ec_ecdt); 1291 if (ACPI_FAILURE(status)) 1292 return status; 1293 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr; 1294 1295 ec_ecdt->common.uid = -1; 1296 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid); 1297 1298 status = 1299 acpi_evaluate_integer(handle, "_GPE", NULL, 1300 &ec_ecdt->common.gpe_bit); 1301 if (ACPI_FAILURE(status)) 1302 return status; 1303 spin_lock_init(&ec_ecdt->poll.lock); 1304 ec_ecdt->common.global_lock = TRUE; 1305 ec_ecdt->common.handle = handle; 1306 1307 printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n", 1308 (u32) ec_ecdt->common.gpe_bit, 1309 (u32) ec_ecdt->common.command_addr.address, 1310 (u32) ec_ecdt->common.data_addr.address); 1311 1312 return AE_CTRL_TERMINATE; 1313 } 1314 1315 static acpi_status __init 1316 acpi_fake_ecdt_intr_callback(acpi_handle handle, 1317 u32 Level, void *context, void **retval) 1318 { 1319 acpi_status status; 1320 1321 init_MUTEX(&ec_ecdt->intr.sem); 1322 init_waitqueue_head(&ec_ecdt->intr.wait); 1323 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 1324 acpi_ec_io_ports, ec_ecdt); 1325 if (ACPI_FAILURE(status)) 1326 return status; 1327 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr; 1328 1329 ec_ecdt->common.uid = -1; 1330 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid); 1331 1332 status = 1333 acpi_evaluate_integer(handle, "_GPE", NULL, 1334 &ec_ecdt->common.gpe_bit); 1335 if (ACPI_FAILURE(status)) 1336 return status; 1337 ec_ecdt->common.global_lock = TRUE; 1338 ec_ecdt->common.handle = handle; 1339 1340 printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n", 1341 (u32) ec_ecdt->common.gpe_bit, 1342 (u32) ec_ecdt->common.command_addr.address, 1343 (u32) ec_ecdt->common.data_addr.address); 1344 1345 return AE_CTRL_TERMINATE; 1346 } 1347 1348 /* 1349 * Some BIOS (such as some from Gateway laptops) access EC region very early 1350 * such as in BAT0._INI or EC._INI before an EC device is found and 1351 * do not provide an ECDT. According to ACPI spec, ECDT isn't mandatorily 1352 * required, but if EC regison is accessed early, it is required. 1353 * The routine tries to workaround the BIOS bug by pre-scan EC device 1354 * It assumes that _CRS, _HID, _GPE, _UID methods of EC don't touch any 1355 * op region (since _REG isn't invoked yet). The assumption is true for 1356 * all systems found. 1357 */ 1358 static int __init acpi_ec_fake_ecdt(void) 1359 { 1360 acpi_status status; 1361 int ret = 0; 1362 1363 printk(KERN_INFO PREFIX "Try to make an fake ECDT\n"); 1364 1365 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL); 1366 if (!ec_ecdt) { 1367 ret = -ENOMEM; 1368 goto error; 1369 } 1370 memset(ec_ecdt, 0, sizeof(union acpi_ec)); 1371 1372 status = acpi_get_devices(ACPI_EC_HID, 1373 acpi_fake_ecdt_callback, NULL, NULL); 1374 if (ACPI_FAILURE(status)) { 1375 kfree(ec_ecdt); 1376 ec_ecdt = NULL; 1377 ret = -ENODEV; 1378 goto error; 1379 } 1380 return 0; 1381 error: 1382 printk(KERN_ERR PREFIX "Can't make an fake ECDT\n"); 1383 return ret; 1384 } 1385 1386 static int __init acpi_ec_get_real_ecdt(void) 1387 { 1388 if (acpi_ec_poll_mode) 1389 return acpi_ec_poll_get_real_ecdt(); 1390 else 1391 return acpi_ec_intr_get_real_ecdt(); 1392 } 1393 1394 static int __init acpi_ec_poll_get_real_ecdt(void) 1395 { 1396 acpi_status status; 1397 struct acpi_table_ecdt *ecdt_ptr; 1398 1399 status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING, 1400 (struct acpi_table_header **) 1401 &ecdt_ptr); 1402 if (ACPI_FAILURE(status)) 1403 return -ENODEV; 1404 1405 printk(KERN_INFO PREFIX "Found ECDT\n"); 1406 1407 /* 1408 * Generate a temporary ec context to use until the namespace is scanned 1409 */ 1410 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL); 1411 if (!ec_ecdt) 1412 return -ENOMEM; 1413 memset(ec_ecdt, 0, sizeof(union acpi_ec)); 1414 1415 ec_ecdt->common.command_addr = ecdt_ptr->ec_control; 1416 ec_ecdt->common.status_addr = ecdt_ptr->ec_control; 1417 ec_ecdt->common.data_addr = ecdt_ptr->ec_data; 1418 ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit; 1419 spin_lock_init(&ec_ecdt->poll.lock); 1420 /* use the GL just to be safe */ 1421 ec_ecdt->common.global_lock = TRUE; 1422 ec_ecdt->common.uid = ecdt_ptr->uid; 1423 1424 status = 1425 acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle); 1426 if (ACPI_FAILURE(status)) { 1427 goto error; 1428 } 1429 1430 return 0; 1431 error: 1432 printk(KERN_ERR PREFIX "Could not use ECDT\n"); 1433 kfree(ec_ecdt); 1434 ec_ecdt = NULL; 1435 1436 return -ENODEV; 1437 } 1438 1439 static int __init acpi_ec_intr_get_real_ecdt(void) 1440 { 1441 acpi_status status; 1442 struct acpi_table_ecdt *ecdt_ptr; 1443 1444 status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING, 1445 (struct acpi_table_header **) 1446 &ecdt_ptr); 1447 if (ACPI_FAILURE(status)) 1448 return -ENODEV; 1449 1450 printk(KERN_INFO PREFIX "Found ECDT\n"); 1451 1452 /* 1453 * Generate a temporary ec context to use until the namespace is scanned 1454 */ 1455 ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL); 1456 if (!ec_ecdt) 1457 return -ENOMEM; 1458 memset(ec_ecdt, 0, sizeof(union acpi_ec)); 1459 1460 init_MUTEX(&ec_ecdt->intr.sem); 1461 init_waitqueue_head(&ec_ecdt->intr.wait); 1462 ec_ecdt->common.command_addr = ecdt_ptr->ec_control; 1463 ec_ecdt->common.status_addr = ecdt_ptr->ec_control; 1464 ec_ecdt->common.data_addr = ecdt_ptr->ec_data; 1465 ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit; 1466 /* use the GL just to be safe */ 1467 ec_ecdt->common.global_lock = TRUE; 1468 ec_ecdt->common.uid = ecdt_ptr->uid; 1469 1470 status = 1471 acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle); 1472 if (ACPI_FAILURE(status)) { 1473 goto error; 1474 } 1475 1476 return 0; 1477 error: 1478 printk(KERN_ERR PREFIX "Could not use ECDT\n"); 1479 kfree(ec_ecdt); 1480 ec_ecdt = NULL; 1481 1482 return -ENODEV; 1483 } 1484 1485 static int __initdata acpi_fake_ecdt_enabled; 1486 int __init acpi_ec_ecdt_probe(void) 1487 { 1488 acpi_status status; 1489 int ret; 1490 1491 ret = acpi_ec_get_real_ecdt(); 1492 /* Try to make a fake ECDT */ 1493 if (ret && acpi_fake_ecdt_enabled) { 1494 ret = acpi_ec_fake_ecdt(); 1495 } 1496 1497 if (ret) 1498 return 0; 1499 1500 /* 1501 * Install GPE handler 1502 */ 1503 status = acpi_install_gpe_handler(NULL, ec_ecdt->common.gpe_bit, 1504 ACPI_GPE_EDGE_TRIGGERED, 1505 &acpi_ec_gpe_handler, ec_ecdt); 1506 if (ACPI_FAILURE(status)) { 1507 goto error; 1508 } 1509 acpi_set_gpe_type(NULL, ec_ecdt->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME); 1510 acpi_enable_gpe(NULL, ec_ecdt->common.gpe_bit, ACPI_NOT_ISR); 1511 1512 status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT, 1513 ACPI_ADR_SPACE_EC, 1514 &acpi_ec_space_handler, 1515 &acpi_ec_space_setup, 1516 ec_ecdt); 1517 if (ACPI_FAILURE(status)) { 1518 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit, 1519 &acpi_ec_gpe_handler); 1520 goto error; 1521 } 1522 1523 return 0; 1524 1525 error: 1526 printk(KERN_ERR PREFIX "Could not use ECDT\n"); 1527 kfree(ec_ecdt); 1528 ec_ecdt = NULL; 1529 1530 return -ENODEV; 1531 } 1532 1533 static int __init acpi_ec_init(void) 1534 { 1535 int result = 0; 1536 1537 ACPI_FUNCTION_TRACE("acpi_ec_init"); 1538 1539 if (acpi_disabled) 1540 return_VALUE(0); 1541 1542 acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir); 1543 if (!acpi_ec_dir) 1544 return_VALUE(-ENODEV); 1545 1546 /* Now register the driver for the EC */ 1547 result = acpi_bus_register_driver(&acpi_ec_driver); 1548 if (result < 0) { 1549 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 1550 return_VALUE(-ENODEV); 1551 } 1552 1553 return_VALUE(result); 1554 } 1555 1556 subsys_initcall(acpi_ec_init); 1557 1558 /* EC driver currently not unloadable */ 1559 #if 0 1560 static void __exit acpi_ec_exit(void) 1561 { 1562 ACPI_FUNCTION_TRACE("acpi_ec_exit"); 1563 1564 acpi_bus_unregister_driver(&acpi_ec_driver); 1565 1566 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir); 1567 1568 return_VOID; 1569 } 1570 #endif /* 0 */ 1571 1572 static int __init acpi_fake_ecdt_setup(char *str) 1573 { 1574 acpi_fake_ecdt_enabled = 1; 1575 return 0; 1576 } 1577 1578 __setup("acpi_fake_ecdt", acpi_fake_ecdt_setup); 1579 static int __init acpi_ec_set_intr_mode(char *str) 1580 { 1581 int intr; 1582 1583 if (!get_option(&str, &intr)) 1584 return 0; 1585 1586 if (intr) { 1587 acpi_ec_poll_mode = EC_INTR; 1588 acpi_ec_driver.ops.add = acpi_ec_intr_add; 1589 } else { 1590 acpi_ec_poll_mode = EC_POLL; 1591 acpi_ec_driver.ops.add = acpi_ec_poll_add; 1592 } 1593 printk(KERN_INFO PREFIX "EC %s mode.\n", intr ? "interrupt" : "polling"); 1594 return 0; 1595 } 1596 1597 __setup("ec_intr=", acpi_ec_set_intr_mode); 1598