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