init. 1AQQW051HEADmaster

1 files changed, 523 insertions, 0 deletions

diff --git a/Core/EM/ACPI/TimeAndAlarm.asl b/Core/EM/ACPI/TimeAndAlarm.asl
new file mode 100644
index 0000000..31ecd78
--- /dev/null
+++ b/Core/EM/ACPI/TimeAndAlarm.asl
@@ -0,0 +1,523 @@
+//**********************************************************************
+//**********************************************************************
+//**                                                                  **
+//**        (C)Copyright 1985-2014, American Megatrends, Inc.         **
+//**                                                                  **
+//**                       All Rights Reserved.                       **
+//**                                                                  **
+//**             5555 Oakbrook Pkwy, Norcross, GA 30093               **
+//**                                                                  **
+//**                       Phone: (770)-246-8600                      **
+//**                                                                  **
+//**********************************************************************
+//**********************************************************************
+// $Header: /Alaska/BIN/Modules/ACPI/Template/Core/TimeAndAlarm.asl 1     1/23/14 5:25p Oleksiyy $
+//
+// $Revision: 1 $
+//
+// $Date: 1/23/14 5:25p $
+
+
+
+        // !!! IMPORTANT !!! !!! IMPORTANT !!! !!! IMPORTANT !!! !!! IMPORTANT !!! 
+        // This is an example of ACPI Time and Alarm Device implementation, proven to be working on Sharkbay platform. 
+        // On different platforms this code may not work "as is" and may require light or heavy modification
+
+
+        // ACPI RTC device
+        //
+        // Note: we assume 24-hr mode and date/time in BCD.
+
+        Device(TAAD)
+        {
+            Name (_HID, "ACPI000E")
+            Name (_CID, "ACPI000E")
+            Name (_UID, 1)
+
+            Name(PRWP, Package(){Zero, 4})             
+            Method(_PRW, 0) { Return(PRWP) } // can wakeup from S4 state
+
+            Name (TMZN, 2047)  // Timezone - set to 2047 to indicate value not specified. Will be used if no buffer for SMI was found
+            Name (DAYL, 0)     // daylight - bit field to indicate daylight adjustment requirement. Will be used if no buffer for SMI was found
+            Name (ALWS, 0xF)   // Init Alarm wake status - Stores alarm wake status; 0xF to indicate contents are invalid
+          
+            Name (ATBF, 0x100000000) //Adress of communication buffer
+            Name (BUFU, 0x0) //Indicator that buffer was allocated and usable.
+		
+            //Mutex used to synchronize between methods	accessing RTC	
+            Mutex(RTCL, 0) 
+
+			// Region for SW SMI port
+            OperationRegion (CSMI, SystemIO, SMIP , 0x1) 
+            Field (CSMI, ByteAcc, NoLock, Preserve) 
+            { 
+                INQ,8
+            } 
+
+            OperationRegion (ADPS, SystemIO, PMBS, 4)
+            Field (ADPS, ByteAcc,NoLock,Preserve) 
+            {
+                PMS, 16,
+                PMEN, 16
+            }
+
+            // Regions for SW SMI data buffer.  Need two, one for byte access, one for nibble access.
+            OperationRegion (DSMI, SystemMemory, ATBF, 0x4)
+            Field (DSMI, AnyAcc, NoLock, Preserve) 
+            { 
+                BSTA, 8, 
+                BDLY, 8,
+                BTZN, 16 
+            } 
+            
+    	    
+            OperationRegion(VRTC, SystemCMOS, 0, 0x10)
+            Field(VRTC, ByteAcc, Lock, Preserve) 
+            {
+
+                SEC, 8,
+                SECA, 8, 
+                
+                MIN, 8,
+                MINA, 8,
+                
+                HOR, 8,
+                HORA, 8,
+                
+                DAYW, 8,                
+                DAY, 8,
+                
+                MON, 8,
+                YEAR, 8,
+
+                STAA, 8,
+                STAB, 8,
+                STAC, 8,
+                STAD, 8
+            }
+
+            Method(_S1W, 0) {
+                return (0)
+            }
+            Method(_S2W, 0) {
+                return (0)
+            }
+            Method(_S3W, 0) {
+                return (3)
+            }
+            Method(_S4W, 0) {
+                return (3)
+            }
+
+            Method(_DSW, 3) {
+
+                // Disable the device's wake capabilities
+                if( LEqual(Arg0, 0) ) {
+                    And(PMEN, 0x0400, PMEN)
+                }
+                if( LEqual(Arg0, 1) ) {
+                    if( LLessEqual(Arg1, 4) ){
+                        Or(PMEN, 0x400, PMEN)
+                    }                    
+                }
+                return
+            }
+
+            // RTC Allow Update
+            Method (ALLW, 0x0, Serialized) {
+                Acquire(RTCL, 2000)
+                
+                And(STAB, 0x7F, STAB)
+
+                Release(RTCL)
+                Return (One)
+            }
+
+            // RTC Inhibit Update
+            Method (INHB, 0x00, Serialized) {
+                Acquire(RTCL, 2000)
+                Or(STAB, 0x80, STAB)
+                Release(RTCL)
+                Return (One)
+            }
+
+            Method (RTWT, 0x00) {
+                Acquire(RTCL, 2000)
+
+                // Loop until an update completes (the Update-Ended Flag (UF) is set)
+                While( LNotEqual(And(STAC, 0x10), 0x10 )){
+                    NoOp
+                }
+
+                Release(RTCL)
+                return (One)
+            }
+
+            // Get Capability
+            // This object is required and provides the OSPM with a bit mask of the device capabilities. The device 
+            // can implement the time function inaddition to the wake function. The capabilities bitmask will 
+            // indicate to the OSPM what support is implemented. If the platform implements both AC and DC 
+            // timers then it is capable of waking up based on the power source
+
+            // Only AC timer here, so it will be the wake source regardless of the power source	
+            Method (_GCP, 0x0, NotSerialized)
+            {
+                //Store(0x11, DBG8)
+                Return (0x5) //Get/Set real time features implemented, real time accuracy in seconds and AC timer only;
+            }
+            
+            
+            // Get Real time Method
+            // This object is required ifthe capabilities bit 2 is set to 1. The OSPM can use this object to get time. 
+            // The return value is a buffer containing the time information
+            Method (_GRT, 0x0, Serialized)
+            {   
+                Name(RBUF, Buffer(16) {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}) //Buffer of 16 bytes - return value
+
+                // Create fields to address different offsets in the buffer
+                CreateWordField(RBUF, 0x0, TYAR)
+                CreateByteField(RBUF, 0x2, TMON)
+                CreateByteField(RBUF, 0x3, TDAY)
+                CreateByteField(RBUF, 0x4, THOR)
+                CreateByteField(RBUF, 0x5, TMIN)
+                CreateByteField(RBUF, 0x6, TSEC)
+                CreateByteField(RBUF, 0x7, TVAL)	// Time Valid if 1, not valid if 0
+                CreateWordField(RBUF, 0xA, TZN)     // Timezone not supported through rRTC - return value stored in ASL
+                CreateByteField(RBUF, 0xC, DYL)     // Daylight not supported through rRTC - emulate in ASL
+
+                if (BUFU) 
+                {
+                    // Read value from NVRAM
+                    Store (0x01, BSTA)
+                    Store (ATAA, INQ)
+                    Sleep (100)
+
+                    if( LEqual(BSTA, 0x03 ) ) {
+                        Store (BDLY, DAYL)
+                        Store (BTZN, TMZN)
+                    } else {
+                        Store(2047, TMZN)
+                        Store (0, DAYL)
+                    }
+                }
+
+                RTWT()
+		
+                FromBCD(YEAR, TYAR)    // Get Year
+                FromBCD (MON, TMON)    // Get Month
+                FromBCD (DAY, TDAY)    // Get Day
+                FromBCD (HOR, THOR)
+                FromBCD (MIN, TMIN)
+                FromBCD (SEC, TSEC)
+
+                Store (TMZN, TZN)
+                Store (DAYL, DYL)
+                
+                // we don't have centry byte
+                ADD(TYAR, 2000, TYAR)
+
+                Store (0x1, TVAL) // Data valid
+                return (RBUF)
+            }
+
+            // Set Real Time
+            // This object is required if the capabilities bit 2 is set to 1. The OSPM can use this object to set the 
+            // time. The argument is a buffer containingthe time information
+
+            Method (_SRT, 0x1, Serialized)
+            {
+                CreateWordField(Arg0, 0x0, TYAR)
+                CreateByteField(Arg0, 0x2, TMON)
+                CreateByteField(Arg0, 0x3, TDAY)
+                CreateByteField(Arg0, 0x4, THOR)
+                CreateByteField(Arg0, 0x5, TMIN)
+                CreateByteField(Arg0, 0x6, TSEC)
+                CreateWordField(Arg0, 0xA, TZN)     // Timezone not supported through rRTC - return value stored in ASL
+                CreateByteField(Arg0, 0xC, DYL)     // Daylight not supported through rRTC
+
+                // TODO: Adjust the timezone, daylight, date and time based on the daylight bitmask
+                
+                if (BUFU) 
+                {
+                    // Send Daylight to NVRAM
+                    Store (0x2, BSTA)
+                    Store (DYL, BDLY)
+                    Store (TZN, BTZN)
+
+                    Store (ATAA, INQ)
+                }
+
+                RTWT()	
+
+                ToBCD(Subtract(TYAR, 2000), YEAR)
+                ToBCD (TMON, MON)   // Set month
+                ToBCD (TDAY, DAY)   // Set day
+                ToBCD (THOR, HOR)   // Set hour
+                ToBCD (TMIN, MIN)   // Set minute
+                ToBCD (TSEC, SEC)   // Set second
+
+                Store (TZN, TMZN)
+                Store (DYL, DAYL)
+
+                If(LEqual(BSTA, 0x3)) // SMI handler set status to OK
+                {
+                    return (0x0) // return success
+                }
+
+                return (0xFFFFFFFF) // return error
+            }
+
+            // Get wake Status
+            //This object is required and enables the OSPM to read the status ofwake alarms. Expired wake timers 
+            //will wake the platform even if the transition to a sleep state was completed after the wake timer has 
+            //expired. This method enables the OSPM to retrieve the status of wake timers and clear any of them if 
+            //needed.
+
+            Method (_GWS, 0x1, Serialized)
+            {
+                // From the ACPI specification
+                // "Writes to the DC timer when AC only wake is supported will be ignored"
+                if (LEqual(0x1, Arg0)) {
+                    return (0x0)
+                }
+                
+                // read alarm status from Register C and remember if it was set
+                // if it wasn't set, keep alarm wake status field invalid
+                // if it was set, indicate to the OS that the alarm expired and that it woke the system.
+                // TODO: Find out if the alarm woke the system, for now assume it did (this will need usage of SMI 
+                // handlers.)
+
+                if (LEqual(0xF, ALWS)) {
+                    if (LAnd (STAC, 0x20)) {
+                        Store (0x3, ALWS)
+                        return (ALWS)
+                    }
+                }
+                
+                return (0x0)
+            }	
+
+            // Clear Wake alarm status.
+            //This object is required and enables the OSPM to clear the status of wake alarms. Expired wake 
+            //timers will wake the platform even if the transition to a sleep state was completed after the wake 
+            //timer has expired. This method enables the OSPMto clear the status of expired wake timers.
+            Method (_CWS, 0x1, Serialized) 
+            { 
+                // From the ACPI specification
+                // "Writes to the DC timer when AC only wake is supported will be ignored"
+                if (LEqual(1, Arg0)) {
+                    return (0) 
+                }
+                
+                RTWT()
+
+                INHB()
+                // Clear the alarm seconds, alarm minutes and alarm hours
+                Store (0x00, SECA)
+                Store (0x00, MINA)
+                Store (0x00, HORA)
+                ALLW()
+                
+                // Clear the "Date Alarm" in RTC_REGD (bits 5:0)
+                And (STAD, 0x80, STAD)
+
+                // Reading Register C should clear the "Alarm Flag (AF)" (Bit5)
+                if (LEqual(0xF, ALWS)) {
+                    Store (STAC, Local0)
+                }
+
+                // Disable the "Alarm Interrupt Enable" (AIE) bit in RTC_REGB     
+                And(STAB, 0xDF, STAB)
+
+                // Mark ALWS invalid
+                Store (0xF, ALWS) 
+                
+                return (0x0)		
+            }
+            
+            // Sets the timer wake policy. 
+            
+            //This object is required and sets the expired timer wake policy.The policy is applied when a 
+            //corresponding timer expired but the wake signal was not asserted as a result of the power source. 
+            //The platform accumulates elapsed time on the power source and asserts the wake signal when the 
+            //elapsed timer on the power source exceeds the expired timer wake policy value. Power source 
+            //transitions do not reset the expired timer wake policy values. When the Wake Alarm device asserts 
+            //the wake, the expired timer wake policy values ofboth the AC timer and DC timer are reset to 
+            //0xFFFFFFFF automatically by hardware. 
+
+            Method (_STP, 0x2, Serialized) 
+            {
+                // From the ACPI specification
+                // "Writes to the DC timer when AC only wake is supported will be ignored"
+                if (LEqual(0x1, Arg0)) {
+                    return (0)
+                }
+
+                //                 
+                if (LGreater(Arg1, 0x01)) {
+                    return (0x1)
+                }
+
+                return (0x0)
+            }
+           
+            // Set the value in specified timer
+
+            //This object is required and setsthe timer to the specified value. As defined in _TIV, the value 
+            //indicates the number of seconds between the time when the timer is programmed and the time when 
+            //it expires. When the Wake Alarm device asserts the wake signal, the timer value is automatically 
+            //reset to 0xFFFFFFFF (disabled). 
+            Method (_STV, 0x2, Serialized)
+            {
+                Name(THOR, 0)
+                Name(TMIN, 0)
+                Name(TSEC, 0)
+
+                // From the ACPI specification
+                // "Writes to the DC timer when AC only wake is supported will be ignored"
+                if (LEqual(0x01, Arg0)) {
+                    return (0x0)
+                }
+
+                
+                // RTC hours/minutes/seconds cannot be set for more than 23 hours, 59 minutes
+                //  and 59 seconds in the future, otherwise we would be setting the current time
+                //  and the alarm would tigger immediatly
+                if (LGreater(Arg1, 86399)) {
+                    return (0x1)
+                }
+                
+                //  Divide the time (which is passed in seconds) into hours, minutes and seconds
+                Divide(Arg1, 60, TSEC, TMIN)
+                Divide(TMIN, 60, TMIN, THOR)
+
+                RTWT()
+                // Add the current seconds to the number of seconds in the future to set the alarm
+                //  and check if its greater than 59
+                if( LGreater(Add(FromBCD(SEC), TSEC, TSEC), 59) ){
+                    // It is greater than 59, so get the mod 60 and convert to BCD and store into the
+                    //  the seconds alarm. Increment the TMIN too
+                    ToBCD(Mod(TSEC, 60), Local1)
+                    INCREMENT(TMIN)
+                } else {
+                    // Its less than 60, just conver to BCD and store it
+                    ToBCD(TSEC, Local1)
+                }
+                Store(Local1, TSEC)
+
+                // Add the current minutes to the number of minutes in the future
+                //  and check if its greater than 59
+                if( LGreater(Add(FromBCD(MIN), TMIN, TMIN), 59) ){
+                    // It is greater than 59, so get the mod 60 and store it into 
+                    //  the minutes alarm and increment the THORs
+                    ToBCD(Mod(TMIN, 60), Local1)
+                    INCREMENT(THOR)
+                } else {
+                    // Its less than 60, just conver to BCD and store it
+                    ToBCD(TMIN, Local1)
+                }
+                Store(Local1, TMIN)
+                
+                // Add the current hours to the number of hours in the future
+                //  and check if its greater than 24
+                if( LGreater(Add(FromBCD(HOR), THOR, THOR), 23) ){
+                    // It is greater than 63, so get the mod 24 and store it into 
+                    //  the hours alarm
+                    ToBCD(Mod(THOR, 60), Local1)
+                } else {
+                    ToBCD(THOR, Local1)
+                }
+                Store(Local1, THOR)
+
+                // Inhibit updating and then program the Alarm
+                INHB()
+                Store(THOR, HORA)
+                Store(TMIN, MINA)
+                Store(TSEC, SECA)
+
+                // Clear the Date Alarm in RTC_REGD (bits 5:0) to ensure they do not
+                //  interfere the RTC alarm
+                And (STAD, 0x80, STAD)
+
+                // Write the Alarm Interrupt Enable (AIE) bit in RTC_REGB
+                OR(STAB, 0x20, STAB) 
+                ALLW()
+
+                Or(PMEN, 0x0400, PMEN)
+                Or(PMS,  0x0400, PMS)
+
+                return (0x0)
+            }
+
+            // Get the timer wake policy of the specified timer
+            //This object returns the current expired timer wake policy setting ofthe specified timer.
+
+            // Ret Value is an Integer (DWORD) containing current expired timer wake policy:
+            //0x00000000 - The timer will wake up the system instantly after the power source changes
+            //0x00000001 - 0xFFFFFFFE: Time between the power source changes and the timer wakes up the 
+            //system ( in units of seconds)
+            //0xFFFFFFFF - The timer will never wake up the system after the power source changes
+
+            Method (_TIP, 0x1, Serialized) {
+
+                if( LEqual(Arg0, 1)) {
+                    return (0xFFFFFFFF)
+                }
+
+                return (0x0)
+            }            
+
+
+            // Get the remaining timer value
+            Method (_TIV, 0x1, Serialized)
+            {
+                Name(TTIM, 0x00000000)
+                
+                // If queried about the DC timer, return 
+                if (LEqual(0x01, Arg0)) {
+                    return (0xFFFFFFFF)
+                }
+ 
+                RTWT()
+ 
+                if( LGreaterEqual(HORA, HOR) ) {
+                    FromBCD(Subtract(HORA, HOR), Local0)
+                } else {
+                    Subtract(24, FromBCD(HOR), Local0)
+                        Add(FromBCD(HORA), Local0, Local0)
+                }
+                Add(Multiply(Local0, 3600), TTIM, TTIM)
+
+                if( LGreaterEqual(MINA, MIN) ) {
+                    FromBCD(Subtract(MINA, MIN), Local0)
+                } else {
+                    Subtract(60, FromBCD(MIN), Local0)
+                    Add(FromBCD(MINA), Local0, Local0)
+                }
+                Add(Multiply(Local0, 60), TTIM, TTIM)
+
+                if( LGreaterEqual(SECA, SEC) ) {
+                    FromBCD(Subtract(SECA, SEC), Local0)
+                } else {
+                    Subtract(60, FromBCD(SEC), Local0)
+                    Add(FromBCD(SECA), Local0, Local0)
+                }
+                Add(Local0, TTIM, TTIM)
+ 
+                return (TTIM)
+            }
+        }
+
+//**********************************************************************
+//**********************************************************************
+//**                                                                  **
+//**        (C)Copyright 1985-2014, American Megatrends, Inc.         **
+//**                                                                  **
+//**                       All Rights Reserved.                       **
+//**                                                                  **
+//**             5555 Oakbrook Pkwy, Norcross, GA 30093               **
+//**                                                                  **
+//**                       Phone: (770)-246-8600                      **
+//**                                                                  **
+//**********************************************************************
+//**********************************************************************
\ No newline at end of file