--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagleboard/src/variant.cpp Thu Oct 15 12:59:54 2009 +0100
@@ -0,0 +1,780 @@
+// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// omap3530/beaglboard/src/variant.cpp
+//
+
+#include <kernel.h>
+#include <beagle/variant.h>
+#include <beagle/mconf.h>
+#include <beagle/beagle_gpio.h>
+#include <assp/omap3530_assp/omap3530_uart.h>
+#include <assp/omap3530_assp/omap3530_gpio.h>
+#include <assp/omap3530_shared/tps65950.h>
+
+#define ENABLE_WFI
+#define IDLE_TICK_SUPPRESSION
+
+
+#ifdef IDLE_TICK_SUPPRESSION
+#include <assp/omap3530_shared/omap3_mstick.h>
+#endif
+
+
+GLREF_C void ArmWaitForInterrupt();
+
+
+//These constants define Custom Restart Reasons in SuperPage::iHwStartupReason
+const TUint KHtCustomRestartMax = 0xff;
+const TUint KHtCustomRestartShift = 8;
+const TUint KHtCustomRestartMask = KHtCustomRestartMax << KHtCustomRestartShift;
+
+//TODO: unncomment when referenced
+const TUint KHtRestartStartupModesMax = 0xf; // Variable, platform dependant
+//const TUint KHtRestartStartupModesShift = 16; // Variable, platform dependant
+//const TUint KHtRestartStartupModesMask = KHtRestartStartupModesMax << KHtRestartStartupModesShift;
+
+void BeagleVariantFault(TInt aLine)
+ {
+ Kern::Fault("BeagleVariant",aLine);
+ }
+
+#define V_FAULT() BeagleVariantFault(__LINE__)
+
+// Debug output
+#define XON 17
+#define XOFF 19
+#define DEBUG_XON_XOFF 0 // Non-zero if we want XON-XOFF handshaking
+
+GLDEF_D Beagle TheVariant;
+TUint32 Variant::iBaseAddress=0;
+
+
+
+
+
+EXPORT_C Asic* VariantInitialise()
+ {
+ return &TheVariant;
+ }
+
+Beagle::Beagle()
+ {
+ iDebugInitialised=EFalse;
+ }
+
+//
+// TO DO: (optional)
+//
+// Specify the RAM zone configuration.
+//
+// The lowest addressed zone must have the highest preference as the bootstrap
+// will always allocate from the lowest address up. Once the kernel has initialised
+// then the zone preferences will decide from which RAM zone memory is allocated.
+//
+// const TUint KVariantRamZoneCount = ?;
+// static const SRamZone KRamZoneConfig[KVariantRamZoneCount+1] =
+// iBase iSize iID iPref iFlags
+// {
+// __SRAM_ZONE(0x????????, 0x???????, ?, ?, ?),
+// ...
+// __SRAM_ZONE(0x????????, 0x???????, ?, ?, ?),
+// __SRAM_ZONE_END, // end of zone list
+// };
+//
+
+TInt Beagle::RamZoneCallback(TRamZoneOp aOp, TAny* aId, const TAny* aMasks)
+ {
+ //
+ // TO DO: (optional)
+ //
+ // Handle RAM zone operations requested by the kernel.
+ //
+ return TheVariant.DoRamZoneCallback(aOp, (TUint)aId, (const TUint*)aMasks);
+ }
+
+
+TInt Beagle::DoRamZoneCallback(TRamZoneOp aOp, TUint aId, const TUint* aMasks)
+ {
+ //
+ // TO DO: (optional)
+ //
+ // Handle RAM zone operations requested by the kernel.
+ //
+ // Three types of operation need to be supported:
+ // ERamZoneOp_Init: Update power state of the RAM zones after the
+ // kernel has initialised.
+ // ERamZoneOp_PowerUp: A RAM zone changing from used to empty.
+ // ERamZoneOp_PowerDown: A RAM zone changing from empty to used.
+ //
+
+ switch (aOp)
+ {
+ case ERamZoneOp_Init:
+ break;
+ case ERamZoneOp_PowerUp:
+ break;
+ case ERamZoneOp_PowerDown:
+ break;
+ default:
+ return KErrNotSupported;
+ }
+ return KErrNone;
+ }
+
+TUint Beagle::SysClkFrequency() const
+ {
+ return 26000000;
+ }
+
+TUint Beagle::SysClk32kFrequency() const
+ {
+ return 32768;
+ }
+
+TUint Beagle::AltClkFrequency() const
+ {
+ // Doesn't appear to be connected on Beagle
+ return 0;
+ }
+
+void Beagle::Init1()
+ {
+ __KTRACE_OPT(KBOOT,Kern::Printf("Beagle::Init1()"));
+ Omap3530Assp::Init1();
+ }
+
+
+EXPORT_C TInt Variant::GetMsTickPeriod()
+ {
+ return TheVariant.MsTickPeriod();
+
+ }
+
+void Beagle::Init3()
+ {
+ __KTRACE_OPT(KBOOT,Kern::Printf("Beagle::Init3()"));
+
+ Omap3530Assp::Init3();
+
+ Variant::Init3();
+ }
+
+void Variant::Init3()
+//
+// Phase 3 initialisation
+//
+ {
+ __KTRACE_OPT(KHARDWARE, Kern::Printf(">Variant::Init3"));
+ }
+
+EXPORT_C TUint Variant::BaseLinAddress()
+ {
+ return((TUint)iBaseAddress);
+ }
+
+EXPORT_C void Variant::MarkDebugPortOff()
+ {
+ TheVariant.iDebugInitialised=EFalse;
+ }
+
+EXPORT_C void Variant::UartInit()
+ {
+ if (!TheVariant.iDebugInitialised)
+ {
+ const Omap3530Uart::TUartNumber portNumber( Omap3530Assp::DebugPortNumber() );
+
+ if( portNumber >= 0 )
+ {
+ Omap3530Uart::TUart uart( portNumber );
+
+ uart.Init();
+ uart.DefineMode( Omap3530Uart::TUart::EUart );
+ uart.SetBaud( Omap3530Uart::TUart::E115200 );
+ uart.SetDataFormat( Omap3530Uart::TUart::E8Data, Omap3530Uart::TUart::E1Stop, Omap3530Uart::TUart::ENone );
+ uart.Enable();
+
+ TheVariant.iDebugInitialised=ETrue;
+ }
+ }
+ }
+
+void Beagle::DebugInit()
+ {
+ Variant::UartInit();
+ }
+
+void Beagle::DebugOutput(TUint aLetter)
+//
+// Output a character to the debug port
+//
+ {
+ const Omap3530Uart::TUartNumber portNumber( Omap3530Assp::DebugPortNumber() );
+
+ if( portNumber >= 0 )
+ {
+ if (!iDebugInitialised)
+ {
+ DebugInit();
+ }
+ Omap3530Uart::TUart uart( portNumber );
+ // If the FIFO is full we need to wait..
+ while( uart.TxFifoFull() );
+ uart.Write( aLetter );
+ }
+ }
+
+void Beagle::Idle()
+//
+// The NULL thread idle loop
+//
+ {
+ // Idle the CPU, suppressing the system tick if possible
+
+ //
+ // TO DO: (optional)
+ //
+ // Idle Tick supression:
+ // 1- obtain the number of idle Ticks before the next NTimer expiration (NTimerQ::IdleTime())
+ // 2- if the number of Ticks is large enough (criteria to be defined) reset the Hardware Timer
+ // to only interrupt again when the corresponding time has expired.
+ // 2.1- the calculation of the new value to program the Hardware Timer with should take in
+ // consideration the rounding value (NTimerQ::iRounding)
+ // 3- call the low level Sleep function (e'g. Bootstrap: address in iIdleFunction)
+ // 4- on coming back from Idle need to read the Hardware Timer and determine if woken up due to
+ // timer expiration (system time for new match<=current system time<system time for new match-tick period)
+ // or some other Interrupt.
+ // 4.1- if timer expiration, adjust System Time by adding the number of Ticks suppressed to NTimerQ::iMsCount
+ // 4.2- if other interrupt, calculate the number of Ticks skipped until woken up and adjust the System Time as
+ // above
+ //
+ // Support for different Sleep Modes:
+ // Often the Sleep mode a platform can go to depends on how many resources such as clocks/voltages can be
+ // turned Off or lowered to a suitable level. If different Sleep modes are supported this code may need
+ // to be able to find out what power resources are On or Off or used to what level. This could be achieved by
+ // enquiring the Resource Manager (see \beagle_variant\inc\beagle_power.h).
+ // Then a decision could be made to what Sleep level we go to.
+ //
+ // Example calls:
+ // Obtain the number of Idle Ticks before the next NTimer expiration
+ // TInt aTicksLeft = NTimerQ::IdleTime();
+ // ...
+ // Find out the deepest Sleep mode available for current resource usage and sleeping time
+ // TemplateResourceManager* aManager = TTemplatePowerController::ResourceManager();
+ // TemplateResourceManager::TSleepModes aMode = aManager -> MapSleepMode(aTicksLeft*MsTickPeriod());
+ // ...
+ // Find out the state of some particular resources
+ // TBool aResourceState = aManager -> GetResourceState(TemplateResourceManager::AsynchBinResourceUsedByZOnly);
+ // TUint aResourceLevel = aManager -> GetResourceLevel(TemplateResourceManager::SynchMlResourceUsedByXOnly);
+ // ...
+
+#ifdef ENABLE_WFI
+ TInt irq = NKern::DisableAllInterrupts();
+
+# ifdef IDLE_TICK_SUPPRESSION
+ TInt maxSleepTicks = NTimerQ::IdleTime();
+ TInt suppressedTicks = Omap3::MsTick::SuppressIdleTicks( maxSleepTicks );
+# endif
+
+ ArmWaitForInterrupt();
+
+
+# ifdef IDLE_TICK_SUPPRESSION
+ if( suppressedTicks > 0 )
+ {
+ suppressedTicks = Omap3::MsTick::EndIdleTickSuppression( suppressedTicks );
+ if( suppressedTicks > 0 )
+ {
+ NTimerQ::Advance( suppressedTicks );
+ }
+ }
+# endif
+
+ NKern::RestoreInterrupts( irq );
+#endif // ifdef ENABLE_WFI
+ }
+
+TInt Beagle::VariantHal(TInt aFunction, TAny* a1, TAny* a2)
+ {
+ TInt r=KErrNone;
+ switch(aFunction)
+ {
+ case EVariantHalVariantInfo:
+ {
+ TVariantInfoV01Buf infoBuf;
+ TVariantInfoV01& info=infoBuf();
+ info.iRomVersion=Epoc::RomHeader().iVersion;
+
+ //
+ // TO DO: (mandatory)
+ //
+ // Fill in the TVariantInfoV01 info structure
+ // info.iMachineUniqueId=;
+ // info.iLedCapabilities=;
+ // info.iProcessorClockInKHz=;
+ // info.iSpeedFactor=;
+ //
+ Kern::InfoCopy(*(TDes8*)a1,infoBuf);
+ break;
+ }
+ case EVariantHalDebugPortSet:
+ {
+ //
+ // TO DO: (mandatory)
+ //
+ // Write the iDebugPort field of the SuperPage, as in the following EXAMPLE ONLY:
+ //
+ TUint32 thePort = (TUint32)a1;
+ switch(thePort)
+ {
+ case 1:
+ case 2:
+ case 3:
+ TheVariant.iDebugInitialised=EFalse;
+ case (TUint32)KNullDebugPort:
+ Kern::SuperPage().iDebugPort = thePort;
+ break;
+ default:
+ r=KErrNotSupported;
+ }
+ break;
+ }
+ case EVariantHalDebugPortGet:
+ {
+ kumemput32(a1, &Kern::SuperPage().iDebugPort, sizeof(TUint32));
+ break;
+ }
+ case EVariantHalSwitches:
+ {
+ //
+ // TO DO: (optional)
+ //
+ // Read the state of any switches, as in the following EXAMPLE ONLY:
+ //
+ TUint32 x = Variant::Switches();
+ kumemput32(a1, &x, sizeof(x));
+ break;
+ }
+ case EVariantHalLedMaskSet:
+ {
+ //
+ // TO DO: (optional)
+ //
+ // Set the state of any on-board LEDs, e.g:
+ // TUint32 aLedMask=(TUint32)a1;
+ // Variant::ModifyLedState(~aLedMask,aLedMask);
+ //
+ break;
+ }
+ case EVariantHalLedMaskGet:
+ {
+ //
+ // TO DO: (optional)
+ //
+ // Read the state of any on-board LEDs, e.g:
+ // TUint32 x = Variant::LedState();
+ // kumemput32(a1, &x, sizeof(x));
+ //
+ break;
+ }
+
+ case EVariantHalCustomRestartReason:
+ {
+ //Restart reason is stored in super page
+ TInt x = (Kern::SuperPage().iHwStartupReason & KHtCustomRestartMask) >> KHtCustomRestartShift ;
+ kumemput32(a1, &x, sizeof(TInt));
+ break;
+ }
+
+ case EVariantHalCustomRestart:
+ {
+ if(!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt,__PLATSEC_DIAGNOSTIC_STRING("Checked by Hal function EVariantHalCustomRestart")))
+ return KErrPermissionDenied;
+ if ((TUint)a1 > KHtCustomRestartMax)
+ return KErrArgument;
+ Kern::Restart((TInt)a1 << KHtCustomRestartShift);
+ }
+ break;
+
+ case EVariantHalCaseState:
+ {
+ //
+ // TO DO: (optional)
+ //
+ // Read the state of the case, e.g:
+ // TUint32 x = Variant::CaseState();
+ // kumemput32(a1, &x, sizeof(x));
+ //
+ break;
+ }
+
+ case EVariantHalPersistStartupMode:
+ {
+ if (!Kern::CurrentThreadHasCapability(ECapabilityWriteDeviceData,__PLATSEC_DIAGNOSTIC_STRING("Checked by Hal function EDisplayHalSetBacklightOn")))
+ return KErrPermissionDenied;
+
+ if ((TUint)a1 > KHtRestartStartupModesMax ) // Restart startup mode max value
+ return KErrArgument;
+ //
+ // TO DO: (optional)
+ //
+ // Store the restart reason locally,
+ // which will eventually be picked up by
+ // the power controller, e.g:
+ // iCustomRestartReason = (TUint)a1;
+ break;
+ }
+
+
+ case EVariantHalGetPersistedStartupMode:
+ {
+ //
+ // TO DO: (optional)
+ //
+ // Read the restart startup mode, e.g:
+ // TInt startup = (Kern::SuperPage().iHwStartupReason & KHtRestartStartupModesMask) >> KHtRestartStartupModesShift;
+ // kumemput32(a1, &startup, sizeof(TInt));
+ break;
+ }
+
+ case EVariantHalGetMaximumCustomRestartReasons:
+ {
+ //
+ // TO DO: (optional)
+ //
+ // Read the maximum custom restart reason, e.g:
+ // kumemput32(a1, &KHtCustomRestartMax, sizeof(TUint));
+ break;
+ }
+
+
+ case EVariantHalGetMaximumRestartStartupModes:
+ {
+ //
+ // TO DO: (optional)
+ //
+ // Read the maximum restart startup mode, e.g:
+ // kumemput32(a1, &KHtRestartStartupModesMax, sizeof(TUint));
+ break;
+ }
+
+
+ default:
+ r=KErrNotSupported;
+ break;
+ }
+ return r;
+ }
+
+TPtr8 Beagle::MachineConfiguration()
+ {
+ return TPtr8((TUint8*)&Kern::MachineConfig(),sizeof(TActualMachineConfig),sizeof(TActualMachineConfig));
+ }
+
+
+EXPORT_C void Variant::PowerReset()
+ {
+ //
+ // TO DO: (optional)
+ //
+ // Reset all power supplies
+ //
+ }
+
+EXPORT_C TUint Variant::Switches()
+ {
+ //
+ // TO DO: (optional)
+ //
+ // Read the state of on-board switches
+ //
+ return 0; // EXAMPLE ONLY
+ }
+
+// USB Client controller
+
+TBool Beagle::UsbClientConnectorDetectable()
+ {
+ __KTRACE_OPT(KHARDWARE, Kern::Printf("Beagle::UsbClientConnectorDetectable"));
+
+ // TO DO: The return value should reflect the actual situation.
+ return ETrue;
+ }
+
+
+TBool Beagle::UsbClientConnectorInserted()
+ {
+ __KTRACE_OPT(KHARDWARE, Kern::Printf("Beagle::UsbClientConnectorInserted"));
+
+ // TO DO: Query cable status here. The return value should reflect the actual current state.
+ return ETrue;
+ }
+
+
+TInt Beagle::RegisterUsbClientConnectorCallback(TInt (*aCallback)(TAny*), TAny* aPtr)
+ {
+ __KTRACE_OPT(KHARDWARE, Kern::Printf("Beagle::RegisterUsbClientConnectorCallback"));
+
+ iUsbClientConnectorCallback = aCallback;
+ iUsbClientConnectorCallbackArg = aPtr;
+
+ // TO DO: Register and enable the interrupt(s) for detecting USB cable insertion/removal here.
+ // (Register UsbClientConnectorIsr.)
+
+ // TO DO: The return value should reflect the actual situation.
+ return KErrNone;
+ }
+
+
+void Beagle::UnregisterUsbClientConnectorCallback()
+ {
+ __KTRACE_OPT(KHARDWARE, Kern::Printf("Beagle::UnregisterUsbClientConnectorCallback"));
+
+ // TO DO: Disable and unbind the interrupt(s) for detecting USB cable insertion/removal here.
+
+ iUsbClientConnectorCallback = NULL;
+ iUsbClientConnectorCallbackArg = NULL;
+ }
+
+
+TBool Beagle::UsbSoftwareConnectable()
+ {
+ __KTRACE_OPT(KHARDWARE, Kern::Printf("Beagle::UsbSoftwareConnectable"));
+
+ // TO DO: The return value should reflect the actual situation.
+ return ETrue;
+ }
+
+
+TInt Beagle::UsbConnect()
+ {
+ __KTRACE_OPT(KHARDWARE, Kern::Printf("Beagle::UsbConnect"));
+
+ // TO DO: Do here whatever is necessary for the UDC to appear on the bus (and thus to the host).
+
+ return KErrNone;
+ }
+
+
+TInt Beagle::UsbDisconnect()
+ {
+ __KTRACE_OPT(KHARDWARE, Kern::Printf("Beagle::UsbDisconnect"));
+
+ // TO DO: Do here whatever is necessary for the UDC to appear disconnected from the bus (and thus from the
+ // host).
+
+ return KErrNone;
+ }
+
+
+void Beagle::UsbClientConnectorIsr(TAny *aPtr)
+//
+// Services the USB cable interrupt.
+//
+ {
+ __KTRACE_OPT(KHARDWARE, Kern::Printf("Beagle::UsbClientConnectorIsr()"));
+
+ Beagle* tm = static_cast<Beagle*>(aPtr);
+
+ // TO DO: Service interrupt here: determmine cause, clear condition flag (if applicable), etc.
+
+ if (tm->UsbClientConnectorInserted())
+ {
+ __KTRACE_OPT(KHARDWARE, Kern::Printf(" > USB cable now inserted."));
+ }
+ else
+ {
+ __KTRACE_OPT(KHARDWARE, Kern::Printf(" > USB cable now removed."));
+ }
+
+ // Important: Inform the USB stack.
+ if (tm->iUsbClientConnectorCallback)
+ {
+ (*tm->iUsbClientConnectorCallback)(tm->iUsbClientConnectorCallbackArg);
+ }
+ }
+
+// Used to convert time to BCD and vice-versa
+const TInt KSecsPerMin = 60;
+const TInt KSecsPerHour = 60*KSecsPerMin;
+const TInt KSecsPerDay = 24*KSecsPerHour;
+//const TInt KSecsPerLeapYr = 366*KSecsPerDay;
+const TInt KSecsPerYr = 365*KSecsPerDay;
+const TInt KSecsDaysPer4Years = (3*KSecsPerYr)+ 366*KSecsPerDay;
+
+//#define BCDTONUM0_3_4_7(a) ((a&0xf)+(((a)>>4)*10))
+#define BCDTONUM0_3_4_6(a) ((a&0xf)+((((a)>>4)&7)*10))
+
+// Days in each month
+LOCAL_D const TInt8 mTab[2][12]=
+ {
+ {31,28,31,30,31,30,31,31,30,31,30,31}, // 28 days in Feb
+ {31,29,31,30,31,30,31,31,30,31,30,31} // 29 days in Feb
+ };
+
+void GetMonthData(TInt aDayInYear, TBool aLeap, TUint8& aMonth, TUint8& aDay )
+/**
+ Work out day of the month and month
+ @param aDayInYear Day of the year
+ @param aLeap True if it is a leap year
+ @param aMonth Return month (range 01-12)
+ @param aDay Return day of the month (range 01-31)
+ */
+{
+ TInt i;
+ TInt runtot=0;
+ for (i=0; i<12; i++)
+ {
+ if ((aDayInYear>=runtot) && (aDayInYear < mTab[aLeap][i]+runtot))
+ {
+ // Month and day of the month both start from 1, rather than
+ // zero (hence the +1)
+ aMonth=i+1;
+ aDay=aDayInYear-runtot+1;
+ break;
+ }
+ runtot+=mTab[aLeap][i];
+ }
+}
+
+LOCAL_C void SecondsToYMD( const TInt aTime, TUint8& aYear, TUint8& aMonth, TUint8& aDay )
+/**
+ Work out year, day of the month and month
+ @param aTime Time in secs from year 2000
+ @param aYear Return year number
+ @param aMonth Return month (range 01-12)
+ @param aDay Return day of the month (range 01-31)
+ */
+{
+ // Work out year within 4 years first
+ aYear = (aTime / KSecsDaysPer4Years)*4;
+ aDay=0;
+ aMonth=0;
+ TInt adjyear = aTime % KSecsDaysPer4Years;
+
+
+ if (adjyear<KSecsPerYr + KSecsPerDay)
+ {
+ GetMonthData(adjyear/KSecsPerDay, ETrue, aMonth, aDay);
+ }
+ else
+ {
+ adjyear-=(KSecsPerYr + KSecsPerDay);
+ aYear+=(adjyear/KSecsPerYr)+1;
+ GetMonthData((adjyear%KSecsPerYr)/KSecsPerDay, EFalse, aMonth, aDay);
+ }
+}
+
+
+EXPORT_C TInt Beagle::SystemTimeInSecondsFrom2000(TInt& aTime)
+ {
+
+ if(!TPS65950::Initialized())
+ {
+ return KErrNotSupported;
+ }
+
+ TPS65950::TRtcTime time;
+ TPS65950::GetRtcData( time );
+
+ aTime = time.iSecond;
+ aTime += time.iMinute * KSecsPerMin;
+ aTime += time.iHour * KSecsPerHour;
+
+ // Careful - day starts from 1
+ aTime += (time.iDay-1) * KSecsPerDay;
+
+ // Determine whether it is a leap year, for the purpose of this chip
+ // years run from 2000 onwards and the driver won't care beyond
+ // yr2000 + 0x7fffffff(secs) (60 odd years). In brief, we can just divide
+ // by 4 and ignore the problem of years divisible by 100
+ TInt yrs= time.iYear;
+ TUint yrsMod4 = yrs%4;
+ TBool isLeap = (yrsMod4) ? EFalse : ETrue;
+
+ // Careful - month starts from 1
+ for (TInt i=0; i < time.iMonth-1; i++)
+ {
+ aTime += mTab[isLeap][i] * KSecsPerDay;
+ }
+
+ aTime += (yrs/4) * KSecsDaysPer4Years;
+
+ if ( isLeap )
+ {
+ // Add KSecsPerDay, because first year is always a leap year
+ aTime+=(KSecsPerYr*(yrsMod4))+KSecsPerDay;
+ }
+ return KErrNone;
+ }
+
+EXPORT_C TInt Beagle::SetSystemTimeInSecondsFrom2000(TInt aTime)
+ {
+ if(!TPS65950::Initialized())
+ {
+ return KErrNotSupported;
+ }
+
+ TPS65950::TRtcTime rtc;
+ TInt secs = aTime % KSecsPerMin;
+ TInt mins_insecs = (aTime % KSecsPerHour) - secs;
+ TInt hours_insecs = (aTime % KSecsPerDay) - mins_insecs - secs;
+
+ rtc.iSecond = secs;
+ rtc.iMinute = mins_insecs/KSecsPerMin;
+ rtc.iHour = hours_insecs/KSecsPerHour;
+
+ SecondsToYMD( aTime, rtc.iYear, rtc.iMonth, rtc.iDay);
+
+ TPS65950::SetRtcData( rtc );
+
+ return KErrNone;
+ }
+
+
+TInt Beagle::IsExternalInterrupt(TInt /*anId*/)
+ {
+ return EFalse;
+ }
+
+TInt Beagle::InterruptBind(TInt /*anId*/, TIsr /*anIsr*/, TAny* /*aPtr*/)
+ {
+ return KErrNotSupported;
+ }
+
+TInt Beagle::InterruptUnbind(TInt /*anId*/)
+ {
+ return KErrNotSupported;
+ }
+
+TInt Beagle::InterruptEnable(TInt /*anId*/)
+ {
+ return KErrNotSupported;
+ }
+
+TInt Beagle::InterruptDisable(TInt /*anId*/)
+ {
+ return KErrNotSupported;
+ }
+
+TInt Beagle::InterruptClear(TInt /*anId*/)
+ {
+ return KErrNotSupported;
+ }
+
+
+
+
+
+
+//---eof