1/*- 2 * Copyright (c) 2000 Michael Smith 3 * Copyright (c) 2000 BSDi 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: --- 10 unchanged lines hidden (view full) --- 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * |
27 * $FreeBSD: head/sys/dev/acpica/acpi_ec.c 116927 2003-06-27 21:57:42Z njl $ |
28 */ 29/****************************************************************************** 30 * 31 * 1. Copyright Notice 32 * 33 * Some or all of this work - Copyright (c) 1999, Intel Corp. All rights 34 * reserved. 35 * --- 203 unchanged lines hidden (view full) --- 239 bus_space_handle_t ec_csr_handle; 240 241 int ec_locked; 242 int ec_lockhandle; 243 int ec_pendquery; 244 int ec_csrvalue; 245}; 246 |
247static int acpi_ec_event_driven = 0; |
248TUNABLE_INT("hw.acpi.ec.event_driven", &acpi_ec_event_driven); 249 250#define EC_LOCK_TIMEOUT 1000 /* 1ms */ 251 252static __inline ACPI_STATUS 253EcLock(struct acpi_ec_softc *sc) 254{ 255 ACPI_STATUS status; 256 257 /* XXX ACPI_WAIT_FOREVER is probably a bad idea, what is a better time? */ |
258 status = AcpiAcquireGlobalLock(ACPI_WAIT_FOREVER, &sc->ec_lockhandle); 259 if (ACPI_SUCCESS(status)) 260 sc->ec_locked = 1; |
261 |
262 return (status); |
263} 264 265static __inline void 266EcUnlock(struct acpi_ec_softc *sc) 267{ |
268 sc->ec_locked = 0; |
269 AcpiReleaseGlobalLock(sc->ec_lockhandle); 270} 271 272static __inline int 273EcIsLocked(struct acpi_ec_softc *sc) 274{ |
275 return (sc->ec_locked != 0); |
276} 277 278typedef struct 279{ |
280 EC_COMMAND Command; 281 UINT8 Address; 282 UINT8 Data; |
283} EC_REQUEST; 284 285static void EcGpeHandler(void *Context); 286static ACPI_STATUS EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, |
287 void *Context, void **return_Context); 288static ACPI_STATUS EcSpaceHandler(UINT32 Function, 289 ACPI_PHYSICAL_ADDRESS Address, 290 UINT32 width, ACPI_INTEGER *Value, 291 void *Context, void *RegionContext); |
292static ACPI_STATUS EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event); 293static ACPI_STATUS EcQuery(struct acpi_ec_softc *sc, UINT8 *Data); |
294static ACPI_STATUS EcTransaction(struct acpi_ec_softc *sc, 295 EC_REQUEST *EcRequest); 296static ACPI_STATUS EcRead(struct acpi_ec_softc *sc, UINT8 Address, 297 UINT8 *Data); 298static ACPI_STATUS EcWrite(struct acpi_ec_softc *sc, UINT8 Address, 299 UINT8 *Data); |
300static void acpi_ec_identify(driver_t driver, device_t bus); 301static int acpi_ec_probe(device_t dev); 302static int acpi_ec_attach(device_t dev); 303 304static device_method_t acpi_ec_methods[] = { 305 /* Device interface */ 306 DEVMETHOD(device_identify, acpi_ec_identify), 307 DEVMETHOD(device_probe, acpi_ec_probe), --- 19 unchanged lines hidden (view full) --- 327 * before most other things, this works out OK. 328 */ 329static void 330acpi_ec_identify(driver_t driver, device_t bus) 331{ 332 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 333 334 /* XXX implement - need an ACPI 2.0 system to test this */ |
335} 336 337/* 338 * We could setup resources in the probe routine in order to have them printed 339 * when the device is attached. 340 */ 341static int 342acpi_ec_probe(device_t dev) 343{ 344 |
345 if (acpi_get_type(dev) == ACPI_TYPE_DEVICE && !acpi_disabled("ec") && |
346 acpi_MatchHid(dev, "PNP0C09")) { 347 348 /* 349 * Set device description 350 */ 351 device_set_desc(dev, "embedded controller"); |
352 return (0); |
353 } |
354 return (ENXIO); |
355} 356 357static int 358acpi_ec_attach(device_t dev) 359{ 360 struct acpi_ec_softc *sc; 361 ACPI_STATUS Status; |
362 int errval = 0; |
363 364 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 365 366 /* 367 * Fetch/initialise softc 368 */ 369 sc = device_get_softc(dev); 370 bzero(sc, sizeof(*sc)); 371 sc->ec_dev = dev; 372 sc->ec_handle = acpi_get_handle(dev); 373 374 /* 375 * Attach bus resources 376 */ 377 sc->ec_data_rid = 0; |
378 sc->ec_data_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, 379 &sc->ec_data_rid, 0, ~0, 1, RF_ACTIVE); 380 if (sc->ec_data_res == NULL) { |
381 device_printf(dev, "can't allocate data port\n"); 382 errval = ENXIO; 383 goto out; 384 } 385 sc->ec_data_tag = rman_get_bustag(sc->ec_data_res); 386 sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res); 387 388 sc->ec_csr_rid = 1; |
389 sc->ec_csr_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, 390 &sc->ec_csr_rid, 0, ~0, 1, RF_ACTIVE); 391 if (sc->ec_csr_res == NULL) { |
392 device_printf(dev, "can't allocate command/status port\n"); 393 errval = ENXIO; 394 goto out; 395 } 396 sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res); 397 sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res); 398 399 /* 400 * Install GPE handler 401 * 402 * Evaluate the _GPE method to find the GPE bit used by the EC to signal 403 * status (SCI). 404 */ 405 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE\n")); |
406 Status = acpi_EvaluateInteger(sc->ec_handle, "_GPE", &sc->ec_gpebit); 407 if (ACPI_FAILURE(Status)) { 408 device_printf(dev, "can't evaluate _GPE - %s\n", 409 AcpiFormatException(Status)); 410 errval = ENXIO; |
411 goto out; 412 } 413 414 /* 415 * Install a handler for this EC's GPE bit. Note that EC SCIs are 416 * treated as both edge- and level-triggered interrupts; in other words 417 * we clear the status bit immediately after getting an EC-SCI, then 418 * again after we're done processing the event. This guarantees that 419 * events we cause while performing a transaction (e.g. IBE/OBF) get 420 * cleared before re-enabling the GPE. 421 */ |
422 Status = AcpiInstallGpeHandler(sc->ec_gpebit, 423 ACPI_EVENT_LEVEL_TRIGGERED | ACPI_EVENT_EDGE_TRIGGERED, 424 EcGpeHandler, sc); 425 if (ACPI_FAILURE(Status)) { |
426 device_printf(dev, "can't install GPE handler for %s - %s\n", 427 acpi_name(sc->ec_handle), AcpiFormatException(Status)); 428 errval = ENXIO; 429 goto out; 430 } 431 432 /* 433 * Install address space handler 434 */ 435 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n")); |
436 Status = AcpiInstallAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC, 437 EcSpaceHandler, EcSpaceSetup, sc); 438 if (ACPI_FAILURE(Status)) { |
439 device_printf(dev, "can't install address space handler for %s - %s\n", 440 acpi_name(sc->ec_handle), AcpiFormatException(Status)); 441 panic("very suck"); 442 errval = ENXIO; 443 goto out; 444 } 445 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attach complete\n")); |
446 return_VALUE (0); 447 |
448 out: |
449 if (sc->ec_csr_res) |
450 bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_csr_rid, 451 sc->ec_csr_res); |
452 if (sc->ec_data_res) |
453 bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_data_rid, 454 sc->ec_data_res); |
455 return_VALUE (errval); |
456} 457 458static void 459EcGpeQueryHandler(void *Context) 460{ 461 struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context; 462 UINT8 Data; 463 ACPI_STATUS Status; --- 9 unchanged lines hidden (view full) --- 473 * Bail out if the EC_SCI bit of the status register is not set. 474 * Note that this function should only be called when 475 * this bit is set (polling is used to detect IBE/OBF events). 476 * 477 * It is safe to do this without locking the controller, as it's 478 * OK to call EcQuery when there's no data ready; in the worst 479 * case we should just find nothing waiting for us and bail. 480 */ |
481 if ((EC_GET_CSR(sc) & EC_EVENT_SCI) == 0) |
482 break; 483 484 /* 485 * Find out why the EC is signalling us 486 */ 487 Status = EcQuery(sc, &Data); 488 489 /* --- 12 unchanged lines hidden (view full) --- 502 strupr(qxx); 503 Status = AcpiEvaluateObject(sc->ec_handle, qxx, NULL, NULL); 504 /* 505 * Ignore spurious query requests. 506 */ 507 if (ACPI_FAILURE(Status) && (Data != 0 || Status != AE_NOT_FOUND)) { 508 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 509 "evaluation of GPE query method %s failed - %s\n", |
510 qxx, AcpiFormatException(Status)); |
511 } 512 } 513 /* I know I request Level trigger cleanup */ 514 if (ACPI_FAILURE(AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE))) |
515 printf("EcGpeQueryHandler:ClearEvent Failed\n"); |
516 if (ACPI_FAILURE(AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE, 0))) |
517 printf("EcGpeQueryHandler:EnableEvent Failed\n"); |
518} 519 520/* 521 * Handle a GPE sent to us. 522 */ 523static void 524EcGpeHandler(void *Context) 525{ 526 struct acpi_ec_softc *sc = Context; 527 int csrvalue; 528 529 /* 530 * If EC is locked, the intr must process EcRead/Write wait only. 531 * Query request must be pending. 532 */ |
533 if (EcIsLocked(sc)) { |
534 csrvalue = EC_GET_CSR(sc); 535 if (csrvalue & EC_EVENT_SCI) 536 sc->ec_pendquery = 1; |
537 if ((csrvalue & EC_FLAG_OUTPUT_BUFFER) != 0 || 538 (csrvalue & EC_FLAG_INPUT_BUFFER) == 0) { |
539 sc->ec_csrvalue = csrvalue; |
540 wakeup(&sc->ec_csrvalue); |
541 } |
542 } else { |
543 /* Queue GpeQuery Handler */ 544 if (ACPI_FAILURE(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH, 545 EcGpeQueryHandler,Context))) { 546 printf("QueryHandler Queuing Failed\n"); 547 } 548 } |
549} 550 551static ACPI_STATUS |
552EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context, 553 void **RegionContext) |
554{ 555 556 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 557 558 /* 559 * Just pass the context through, there's nothing to do here. 560 */ 561 *RegionContext = Context; 562 |
563 return_ACPI_STATUS (AE_OK); |
564} 565 566static ACPI_STATUS |
567EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width, 568 ACPI_INTEGER *Value, void *Context, void *RegionContext) |
569{ 570 struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context; 571 ACPI_STATUS Status = AE_OK; 572 EC_REQUEST EcRequest; 573 int i; 574 575 ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Address); 576 |
577 if (Address > 0xFF || width % 8 != 0 || Value == NULL || Context == NULL) 578 return_ACPI_STATUS (AE_BAD_PARAMETER); |
579 580 switch (Function) { 581 case ACPI_READ: 582 EcRequest.Command = EC_COMMAND_READ; 583 EcRequest.Address = Address; 584 (*Value) = 0; 585 break; |
586 case ACPI_WRITE: 587 EcRequest.Command = EC_COMMAND_WRITE; 588 EcRequest.Address = Address; 589 break; |
590 default: |
591 device_printf(sc->ec_dev, "invalid Address Space function %d\n", 592 Function); 593 return_ACPI_STATUS (AE_BAD_PARAMETER); |
594 } 595 596 /* 597 * Perform the transaction. 598 */ 599 for (i = 0; i < width; i += 8) { 600 if (Function == ACPI_READ) 601 EcRequest.Data = 0; 602 else 603 EcRequest.Data = (UINT8)((*Value) >> i); |
604 Status = EcTransaction(sc, &EcRequest); 605 if (ACPI_FAILURE(Status)) |
606 break; |
607 *Value |= (ACPI_INTEGER)EcRequest.Data << i; |
608 if (++EcRequest.Address == 0) |
609 return_ACPI_STATUS (AE_BAD_PARAMETER); |
610 } |
611 return_ACPI_STATUS (Status); |
612} 613 614/* 615 * Wait for an event interrupt for a specific condition. 616 */ 617static ACPI_STATUS 618EcWaitEventIntr(struct acpi_ec_softc *sc, EC_EVENT Event) 619{ 620 EC_STATUS EcStatus; 621 int i; 622 623 ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Event); 624 625 /* XXX this should test whether interrupts are available some other way */ 626 if (cold || acpi_ec_event_driven) |
627 return_ACPI_STATUS (EcWaitEvent(sc, Event)); |
628 |
629 if (!EcIsLocked(sc)) { |
630 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 631 "EcWaitEventIntr called without EC lock!\n"); |
632 } |
633 634 EcStatus = EC_GET_CSR(sc); 635 636 /* XXX waiting too long? */ |
637 for (i = 0; i < 10; i++) { |
638 /* 639 * Check EC status against the desired event. 640 */ 641 if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) && |
642 (EcStatus & EC_FLAG_OUTPUT_BUFFER) != 0) 643 return_ACPI_STATUS (AE_OK); |
644 645 if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) && |
646 (EcStatus & EC_FLAG_INPUT_BUFFER) == 0) 647 return_ACPI_STATUS (AE_OK); |
648 649 sc->ec_csrvalue = 0; |
650 /* XXX sleeping with Acpi Global Lock held */ 651 if (tsleep(&sc->ec_csrvalue, PZERO, "EcWait", 1) != EWOULDBLOCK) { |
652 EcStatus = sc->ec_csrvalue; |
653 } else { |
654 EcStatus = EC_GET_CSR(sc); 655 } 656 } |
657 return_ACPI_STATUS (AE_ERROR); |
658} 659 660static ACPI_STATUS 661EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event) 662{ 663 EC_STATUS EcStatus; 664 UINT32 i = 0; 665 |
666 if (!EcIsLocked(sc)) { |
667 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 668 "EcWaitEvent called without EC lock!\n"); |
669 } |
670 671 /* 672 * Stall 1us: 673 * ---------- 674 * Stall for 1 microsecond before reading the status register 675 * for the first time. This allows the EC to set the IBF/OBF 676 * bit to its proper state. 677 * --- 6 unchanged lines hidden (view full) --- 684 * Wait For Event: 685 * --------------- 686 * Poll the EC status register to detect completion of the last 687 * command. Wait up to 10ms (in 10us chunks) for this to occur. 688 */ 689 for (i = 0; i < 1000; i++) { 690 EcStatus = EC_GET_CSR(sc); 691 |
692 if (Event == EC_EVENT_OUTPUT_BUFFER_FULL && 693 (EcStatus & EC_FLAG_OUTPUT_BUFFER) != 0) 694 return (AE_OK); |
695 |
696 if (Event == EC_EVENT_INPUT_BUFFER_EMPTY && 697 (EcStatus & EC_FLAG_INPUT_BUFFER) == 0) |
698 return(AE_OK); 699 700 AcpiOsStall(10); 701 } 702 |
703 return (AE_ERROR); |
704} 705 706static ACPI_STATUS 707EcQuery(struct acpi_ec_softc *sc, UINT8 *Data) 708{ 709 ACPI_STATUS Status; 710 |
711 Status = EcLock(sc); 712 if (ACPI_FAILURE(Status)) 713 return (Status); |
714 715 EC_SET_CSR(sc, EC_COMMAND_QUERY); |
716 Status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL); 717 if (ACPI_SUCCESS(Status)) |
718 *Data = EC_GET_DATA(sc); 719 720 EcUnlock(sc); 721 |
722 if (ACPI_FAILURE(Status)) { |
723 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 724 "timeout waiting for EC to respond to EC_COMMAND_QUERY\n"); |
725 } 726 return (Status); |
727} 728 729static ACPI_STATUS 730EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest) 731{ 732 ACPI_STATUS Status; 733 |
734 Status = EcLock(sc); 735 if (ACPI_FAILURE(Status)) 736 return (Status); |
737 738 /* 739 * Perform the transaction. 740 */ 741 switch (EcRequest->Command) { 742 case EC_COMMAND_READ: |
743 Status = EcRead(sc, EcRequest->Address, &EcRequest->Data); |
744 break; |
745 case EC_COMMAND_WRITE: |
746 Status = EcWrite(sc, EcRequest->Address, &EcRequest->Data); |
747 break; |
748 default: 749 Status = AE_SUPPORT; 750 break; 751 } 752 |
753 EcUnlock(sc); 754 755 /* 756 * Clear & Re-Enable the EC GPE: 757 * ----------------------------- 758 * 'Consume' any EC GPE events that we generated while performing 759 * the transaction (e.g. IBF/OBF). Clearing the GPE here shouldn't 760 * have an adverse affect on outstanding EC-SCI's, as the source 761 * (EC-SCI) will still be high and thus should trigger the GPE 762 * immediately after we re-enabling it. 763 */ |
764 if (sc->ec_pendquery) { |
765 if (ACPI_FAILURE(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH, 766 EcGpeQueryHandler, sc))) 767 printf("Pend Query Queuing Failed\n"); 768 sc->ec_pendquery = 0; 769 } 770 |
771 if (ACPI_FAILURE(AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE))) { |
772 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 773 "EcRequest: Unable to clear the EC GPE.\n"); |
774 } 775 if (ACPI_FAILURE(AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE, 0))) { |
776 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 777 "EcRequest: Unable to re-enable the EC GPE.\n"); |
778 } |
779 |
780 return (Status); |
781} 782 783 784static ACPI_STATUS 785EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data) 786{ 787 ACPI_STATUS Status; 788 |
789 if (!EcIsLocked(sc)) { |
790 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 791 "EcRead called without EC lock!\n"); |
792 } |
793 794 /*EcBurstEnable(EmbeddedController);*/ 795 796 EC_SET_CSR(sc, EC_COMMAND_READ); |
797 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY); 798 if (ACPI_FAILURE(Status)) { |
799 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 800 "EcRead: Failed waiting for EC to process read command.\n"); |
801 return (Status); |
802 } 803 804 EC_SET_DATA(sc, Address); |
805 Status = EcWaitEventIntr(sc, EC_EVENT_OUTPUT_BUFFER_FULL); 806 if (ACPI_FAILURE(Status)) { |
807 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 808 "EcRead: Failed waiting for EC to send data.\n"); |
809 return (Status); |
810 } 811 |
812 *Data = EC_GET_DATA(sc); |
813 814 /*EcBurstDisable(EmbeddedController);*/ 815 |
816 return (AE_OK); |
817} 818 819static ACPI_STATUS 820EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data) 821{ 822 ACPI_STATUS Status; 823 |
824 if (!EcIsLocked(sc)) { |
825 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 826 "EcWrite called without EC lock!\n"); |
827 } |
828 829 /*EcBurstEnable(EmbeddedController);*/ 830 831 EC_SET_CSR(sc, EC_COMMAND_WRITE); |
832 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY); 833 if (ACPI_FAILURE(Status)) { |
834 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 835 "EcWrite: Failed waiting for EC to process write command.\n"); |
836 return (Status); |
837 } 838 839 EC_SET_DATA(sc, Address); |
840 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY); 841 if (ACPI_FAILURE(Status)) { |
842 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 843 "EcRead: Failed waiting for EC to process address.\n"); |
844 return (Status); |
845 } 846 847 EC_SET_DATA(sc, *Data); |
848 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY); 849 if (ACPI_FAILURE(Status)) { |
850 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev), 851 "EcWrite: Failed waiting for EC to process data.\n"); |
852 return (Status); |
853 } 854 855 /*EcBurstDisable(EmbeddedController);*/ 856 |
857 return (AE_OK); |
858} |