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