/*

* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  This is a project specific source file for building the 

*                clock related functions as part of librt library.

*

*/

#include <time.h>

#include <errno.h>

#include <pthread.h>

#include <stdlib.h>

#include <e32std.h>

#include <sys/_timeval.h>

#include <sys/types.h>

#include "lposix.h"

#define UNIX_BASE	TTime(MAKE_TINT64(0x00dcddb3,0x0f2f8000))    // 00:00, Jan 1st 1970

#define BOUNDARY_CHECK(rqtp) ( (rqtp->tv_nsec != 0 && rqtp->tv_nsec < 1000) || \

							   rqtp->tv_nsec >= 1000000000L )\

extern "C" {

//Returns the resolution (granularity) of a clock

//This value is placed in a (non-NULL) *res

EXPORT_C int clock_getres(clockid_t clock_id, struct timespec* res)

{

	int retval = -1;

	//We expect the user of the library to give us a valid pointer	

	if(res == NULL)

		{

		return 0; //no strict reactions please.

		}

	switch (clock_id) 

		{

		case CLOCK_REALTIME:

			//Since Symbian OS is not realtime,we simulate the same using

			//the available wall clock whose resolution is upto microseconds

			res->tv_sec = 0;

			res->tv_nsec = 1000;

			retval = 0;

			break;

		default:

			//For all other clocks that cannot be supported or invalid clockids,

			//we set errno to not-supported

			retval = -1;

			errno = EINVAL;

			break;

		}

	return retval;

}

//Allow the calling process to retrieve the value used by a clock which 

//is specified by clock_id

EXPORT_C int clock_gettime (clockid_t clock_id, struct timespec *tp)

{

	int retval = -1;

	TTime t;

	TTimeIntervalSeconds iSeconds;

	TInt err;

	//We expect the user of the library to give us a valid pointer	

	if(tp == NULL)

		{

		errno = EFAULT;

		return retval;

		}

	switch(clock_id)

		{

		case CLOCK_REALTIME:

			//Since Symbian OS is not realtime,we simulate the same using

			//the available wall clock.We use TTime::HomeTime() call to get

			//the wall clock time

			t.HomeTime();

			err = t.SecondsFrom(UNIX_BASE, iSeconds); //TODO check for the negative tests..

			if (!err)

				{

				t-=iSeconds;//extracting seconds info into iSeconds 			

				tp->tv_sec = iSeconds.Int();

				tp->tv_nsec = t.Int64();

				retval = 0;

				}

			break;

		default:

			//For all other clocks that cannot be supported or invalid clockids,

			//we set errno to invalid

			retval = -1;

			errno = EINVAL;

			break;

		}

	return retval;

}

//The clock_settime allow the calling process to set the value used by a 

//clock which is specified by  clock_id

EXPORT_C int clock_settime (clockid_t clock_id, const struct timespec *tp)

{

	int retval = -1;

	TTime t(MAKE_TINT64 (0x00dcddb3 ,0x0f2f8000)) ;  // 00:00, Jan 1st 1970

	TInt err;

	TInt64 microtime;

	if(tp == NULL)

		{

		errno = EFAULT;

		return retval;

		}

	//Check for boundary values of seconds and microseconds

	if (BOUNDARY_CHECK(tp))

		{

		errno = EINVAL;

		return retval;

		}

	switch(clock_id)

		{

		case CLOCK_REALTIME:

			//We support only the wall-clock,hence use the 

			//User::SetHomeTime call to set the time

			t+=(TTimeIntervalSeconds)tp->tv_sec;

			microtime = (tp->tv_nsec)/1000;

			t+=(TTimeIntervalMicroSeconds)microtime;        

			err = User::SetUTCTime(t);

			if(err)

				{

				MapError(err,errno);

				break;

				}

			else

				retval = 0;	

			break;

		default:

			//For all other clocks that cannot be supported or invalid clockids,

			//we set errno to invalid

			retval = -1;

			errno = EINVAL;

			break;

		}	

	return retval;

}

//Returns the clock ID of the CPU-time clock of the process specified by pid

EXPORT_C int clock_getcpuclockid (pid_t pid, clockid_t *clock_id)

{

	int retval = -1;

	if(clock_id == NULL)

		{

		errno = EFAULT;

		return retval;

		}

	/* We don't allow any process ID but our own.  */

	if (pid == 0)

		{

		//The only available clock is the realtime wall clock

		//Hence we set the clockid to that

		*clock_id = CLOCK_REALTIME;

		retval = 0;

		}

	else

		errno = ESRCH;

	return retval;

}

//clock_nanosleep will not be interrupted by the signal emulation. 

//hence EINTR is not valid here. 

EXPORT_C int clock_nanosleep(clockid_t clock_id, int flags,

       const struct timespec *rqtp, struct timespec */*rmtp*/)

{

	int retval = -1;

	if(rqtp == NULL)

		{

		errno = EFAULT;

		return retval;

		}

	//Check for boundary values of seconds and microseconds

	if (BOUNDARY_CHECK(rqtp))

		{

		errno = EINVAL;

		return retval;

		}

	switch(clock_id)

		{

		case CLOCK_REALTIME:

			{

			switch(flags)

				{

				case TIMER_ABSTIME:

					{

					TTime lSetTime(MAKE_TINT64 (0x00dcddb3 ,0x0f2f8000)) ;  // 00:00, Jan 1st 1970				

					lSetTime+=(TTimeIntervalSeconds)rqtp->tv_sec;

					lSetTime+=(TTimeIntervalMicroSeconds)(rqtp->tv_nsec/1000);

					User::At(lSetTime);

					}

					break;

				default:

					{

					unsigned long timeout;

					timeout = (1000000 * rqtp->tv_sec) + (rqtp->tv_nsec /1000);

					User::AfterHighRes(timeout);

					}

					break;

				}

			}

			retval = 0;

			break;

		default:

			//For all other clocks that cannot be supported or invalid clockids,

			//we set errno to invalid

			retval = -1;

			errno = EINVAL;

			break;

		}

	return retval;	

}

} // extern "C"

//EOF