static void
decode_rtc_time(struct tcb *tcp, const long addr)
{
struct rtc_time rt;
if (!umove_or_printaddr(tcp, addr, &rt))
print_rtc_time(tcp, &rt);
}
/*FUNCTION**********************************************************************
*
* Function Name : print_current_time
* Returned Value :
* Comments :
*
*END**************************************************************************/
static void print_current_time(void)
{
DATE_STRUCT time_rtc;
TIME_STRUCT time_mqx;
_rtc_get_time_mqxd (&time_rtc);
_time_from_date (&time_rtc, &time_mqx);
print_rtc_time(&time_rtc, &time_mqx);
}
static void
decode_rtc_wkalrm(struct tcb *tcp, const long addr)
{
struct rtc_wkalrm wk;
if (!umove_or_printaddr(tcp, addr, &wk)) {
tprintf("{enabled=%d, pending=%d, time=", wk.enabled, wk.pending);
print_rtc_time(tcp, &wk.time);
tprints("}");
}
}
int
main(void)
{
const unsigned int size = get_page_size();
void *const page = tail_alloc(size);
init_magic(page, size);
struct rtc_time *rt = tail_alloc(sizeof(*rt));
init_magic(rt, sizeof(*rt));
struct rtc_wkalrm *wk = tail_alloc(sizeof(*wk));
init_magic(wk, sizeof(*wk));
struct rtc_pll_info *pll = tail_alloc(sizeof(*pll));
init_magic(pll, sizeof(*pll));
/* RTC_ALM_READ */
ioctl(-1, RTC_ALM_READ, 0);
printf("ioctl(-1, RTC_ALM_READ, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_ALM_READ, page);
printf("ioctl(-1, RTC_ALM_READ, %p) = -1 EBADF (%m)\n", page);
/* RTC_RD_TIME */
ioctl(-1, RTC_RD_TIME, 0);
printf("ioctl(-1, RTC_RD_TIME, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_RD_TIME, page);
printf("ioctl(-1, RTC_RD_TIME, %p) = -1 EBADF (%m)\n", page);
/* RTC_ALM_SET */
ioctl(-1, RTC_ALM_SET, 0);
printf("ioctl(-1, RTC_ALM_SET, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_ALM_SET, rt);
printf("ioctl(-1, RTC_ALM_SET, ");
print_rtc_time(rt);
errno = EBADF;
printf(") = -1 EBADF (%m)\n");
/* RTC_SET_TIME */
ioctl(-1, RTC_SET_TIME, 0);
printf("ioctl(-1, RTC_SET_TIME, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_SET_TIME, rt);
printf("ioctl(-1, RTC_SET_TIME, ");
print_rtc_time(rt);
errno = EBADF;
printf(") = -1 EBADF (%m)\n");
/* RTC_IRQP_SET */
ioctl(-1, RTC_IRQP_SET, lmagic);
printf("ioctl(-1, RTC_IRQP_SET, %lu) = -1 EBADF (%m)\n", lmagic);
/* RTC_EPOCH_SET */
ioctl(-1, RTC_EPOCH_SET, lmagic);
printf("ioctl(-1, RTC_EPOCH_SET, %lu) = -1 EBADF (%m)\n", lmagic);
/* RTC_IRQP_READ */
ioctl(-1, RTC_IRQP_READ, 0);
printf("ioctl(-1, RTC_IRQP_READ, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_IRQP_READ, page);
printf("ioctl(-1, RTC_IRQP_READ, %p) = -1 EBADF (%m)\n", page);
/* RTC_EPOCH_READ */
ioctl(-1, RTC_EPOCH_READ, 0);
printf("ioctl(-1, RTC_EPOCH_READ, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_EPOCH_READ, page);
printf("ioctl(-1, RTC_EPOCH_READ, %p) = -1 EBADF (%m)\n", page);
/* RTC_WKALM_RD */
ioctl(-1, RTC_WKALM_RD, 0);
printf("ioctl(-1, RTC_WKALM_RD, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_WKALM_RD, page);
printf("ioctl(-1, RTC_WKALM_RD, %p) = -1 EBADF (%m)\n", page);
/* RTC_WKALM_SET */
ioctl(-1, RTC_WKALM_SET, 0);
printf("ioctl(-1, RTC_WKALM_SET, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_WKALM_SET, wk);
printf("ioctl(-1, RTC_WKALM_SET, {enabled=%u, pending=%u, time=",
(unsigned) wk->enabled, (unsigned) wk->pending);
print_rtc_time(&wk->time);
errno = EBADF;
printf("}) = -1 EBADF (%m)\n");
/* RTC_PLL_GET */
ioctl(-1, RTC_PLL_GET, 0);
printf("ioctl(-1, RTC_PLL_GET, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_PLL_GET, page);
printf("ioctl(-1, RTC_PLL_GET, %p) = -1 EBADF (%m)\n", page);
/* RTC_PLL_SET */
ioctl(-1, RTC_PLL_SET, 0);
printf("ioctl(-1, RTC_PLL_SET, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_PLL_SET, pll);
printf("ioctl(-1, RTC_PLL_SET, {pll_ctrl=%d, pll_value=%d"
", pll_max=%d, pll_min=%d, pll_posmult=%d, pll_negmult=%d"
", pll_clock=%ld}) = -1 EBADF (%m)\n",
pll->pll_ctrl, pll->pll_value, pll->pll_max, pll->pll_min,
pll->pll_posmult, pll->pll_negmult, pll->pll_clock);
#ifdef RTC_VL_READ
/* RTC_VL_READ */
ioctl(-1, RTC_VL_READ, 0);
printf("ioctl(-1, RTC_VL_READ, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_VL_READ, page);
printf("ioctl(-1, RTC_VL_READ, %p) = -1 EBADF (%m)\n", page);
#endif
unsigned int i;
for (i = 0; i < ARRAY_SIZE(rtc_argless); ++i) {
ioctl(-1, (unsigned long) rtc_argless[i].val, lmagic);
printf("ioctl(-1, %s) = -1 EBADF (%m)\n", rtc_argless[i].str);
}
ioctl(-1, RTC_UIE_OFF, lmagic);
printf("ioctl(-1, %s) = -1 EBADF (%m)\n", "PHN_NOT_OH or RTC_UIE_OFF");
ioctl(-1, RTC_AIE_ON, lmagic);
#ifdef HPPA
printf("ioctl(-1, %s) = -1 EBADF (%m)\n", "PA_PERF_ON or RTC_AIE_ON");
#else
printf("ioctl(-1, %s) = -1 EBADF (%m)\n", "RTC_AIE_ON");
#endif
ioctl(-1, _IO(0x70, 0x40), lmagic);
printf("ioctl(-1, %s, %#lx) = -1 EBADF (%m)\n", "NVRAM_INIT", lmagic);
puts("+++ exited with 0 +++");
return 0;
}
void main_task
(
uint_32 initial_data
)
{
DATE_STRUCT time_rtc;
TIME_STRUCT time_mqx;
if (_lwevent_create(&lwevent,0) != MQX_OK)
{
printf("\nMake event failed");
_task_block();
}
printf ("\fStart time (MQX synchronized to RTC time during bsp init):\n\n");
/* initialize time */
time_rtc.YEAR = 2010;
time_rtc.MONTH = 10;
time_rtc.DAY = 15;
time_rtc.HOUR = 10;
time_rtc.MINUTE = 8;
time_rtc.SECOND = 0;
time_rtc.MILLISEC = 0;
_time_from_date (&time_rtc, &time_mqx);
_time_set( &time_mqx);
if( _rtc_sync_with_mqx(FALSE) != MQX_OK )
{
printf("\nError synchronize time!\n");
_task_block();
}
_time_get (&time_mqx);
_time_to_date (&time_mqx, &time_rtc);
print_mqx_time(&time_rtc, &time_mqx);
print_current_time();
/* except MPC5125 */
#ifndef BSP_TWRMPC5125
install_interrupt();
/* enable stopwatch */
install_stopwatch();
/* enable alarm */
install_alarm();
_lwevent_wait_ticks(&lwevent,LWE_ALARM,FALSE,0);
_lwevent_clear(&lwevent,LWE_ALARM);
printf ("\nALARM!\n");
print_current_time();
/* end of alarm */
printf ("Continue wasting time (2 minutes max) ...\n");
_lwevent_wait_ticks(&lwevent,LWE_STOPWATCH,FALSE,0);
_lwevent_clear(&lwevent,LWE_STOPWATCH);
printf ("\nSTOPWATCH!\n");
print_current_time();
printf ("\nClearing RTC:\n");
_rtc_init (RTC_INIT_FLAG_CLEAR | RTC_INIT_FLAG_ENABLE);
print_current_time();
install_alarm();
_lwevent_wait_ticks(&lwevent,LWE_ALARM,FALSE,0);
_lwevent_clear(&lwevent,LWE_ALARM);
printf ("ALARM!\n");
print_current_time();
#else /* BSP_TWRMPC5125 */
printf ("Waste 10 seconds here\n");
_time_delay(10000);
_rtc_get_time_mqxd (&time_rtc);
print_rtc_time(&time_rtc, &time_mqx);
#endif
printf ("Synchronize RTC to MQX time again:\n");
_rtc_sync_with_mqx (FALSE);
_rtc_get_time_mqxd (&time_rtc);
_time_from_date (&time_rtc, &time_mqx);
print_rtc_time(&time_rtc, &time_mqx);
#if PSP_HAS_IRTC == 1
irtc_test();
#endif /* PSP_HAS_IRTC == 1 */
/* Test tamper event functionality on MCF51EMxx device */
#if PSP_MQX_CPU_IS_MCF51EM
test_tamper();
#else
printf ("Finish, press/hold reset to repeat.\n");
_task_block() ;
#endif
}
void main_task
(
uint32_t initial_data
)
{ /* Body */
uint32_t rtc_time;
uint32_t rtc_time_default;
TIME_STRUCT mqx_time;
DATE_STRUCT date_time;
if (_lwevent_create(&lwevent,0) != MQX_OK)
{
printf("\nMake event failed");
_task_block();
}
printf ("\f RTC Demo :\n\n");
_rtc_get_time(&rtc_time);
print_rtc_time(rtc_time);
/* initialize time */
date_time.YEAR = RTC_TIME_INIT_TM_YEAR;
date_time.MONTH = RTC_TIME_INIT_TM_MON;
date_time.DAY = RTC_TIME_INIT_TM_MDAY;
date_time.HOUR = RTC_TIME_INIT_TM_HOUR;
date_time.MINUTE = RTC_TIME_INIT_TM_MIN;
date_time.SECOND = RTC_TIME_INIT_TM_SEC;
date_time.MILLISEC = 0;
/* Convert date time to time struct */
if ( _time_from_date(&date_time, &mqx_time) == FALSE)
{
printf("\n Cannot convert date_time ");
_task_block();
}
/* Convert rtc time to TIME_STRUCT */
rtc_time = mqx_time.SECONDS;
printf(" Set RTC time is: %s %s %3d %.2d:%.2d:%.2d %d\n",
_days_abbrev[date_time.WDAY],
_months_abbrev[date_time.MONTH - 1],
date_time.DAY,
date_time.HOUR,
date_time.MINUTE,
date_time.SECOND,
date_time.YEAR);
/* Set MQX time*/
_time_set(&mqx_time);
/* Set RTC time*/
_rtc_set_time(rtc_time);
printf("\n MQX time: %d SECONDS, %d MILISECOND ", mqx_time.SECONDS, mqx_time.MILLISECONDS);
/*
* set-up alarm
*/
/* install callback */
_rtc_callback_reg((INT_ISR_FPTR)rtc_callback, (void*)NULL);
/* Set alarm to maximum time to avoid unexpected interrupt in next running */
_rtc_set_alarm(MAXIMUM_SECONDS_IN_TIME,(uint32_t)0);
_lwevent_clear(&lwevent,LWE_ALARM);
/* Get current time */
_rtc_get_time(&rtc_time);
/* setup alarm in next 10 seconds & period 4 seconds*/
rtc_time += (uint32_t)ALARM_NEXT_TIME; /* Alarm occurs in next 10 seconds */
printf("\n Setup to occur alarm in next %d seconds & with period: %d seconds",ALARM_NEXT_TIME, ALARM_PERIOD);
_rtc_set_alarm(rtc_time,(uint32_t)ALARM_PERIOD);
printf("\n Wait %d seconds ....",ALARM_NEXT_TIME);
/* Wait to clear LWE_ALARM event */
_lwevent_wait_ticks(&lwevent,LWE_ALARM,FALSE,0);
_lwevent_clear(&lwevent,LWE_ALARM);
printf ("\nALARM! ALARM! ALARM!\n");
/* Print current time */
_rtc_get_time(&rtc_time);
print_rtc_time(rtc_time);
printf("\n Wait next alarm in %d seconds....",ALARM_PERIOD);
_lwevent_wait_ticks(&lwevent,LWE_ALARM,FALSE,0);
_lwevent_clear(&lwevent,LWE_ALARM);
printf ("\nALARM! ALARM! ALARM!\n");
_rtc_get_time(&rtc_time);
print_rtc_time(rtc_time);
printf ("\nClearing RTC:\n");
_rtc_set_time(0);
_rtc_get_time(&rtc_time_default);
print_rtc_time(rtc_time_default);
/* Wait 2 seconds after resynchronize rtc time with mqx time*/
do{
_rtc_get_time(&rtc_time);
} while ((rtc_time - rtc_time_default) < 2);
/* Get current time & display on terminal */
_rtc_get_time(&rtc_time);
print_rtc_time(rtc_time);
printf ("Synchronize RTC to MQX time again:\n");
_time_get(&mqx_time);
rtc_time = mqx_time.SECONDS;
_rtc_set_time(rtc_time);
_rtc_get_time(&rtc_time);
print_rtc_time(rtc_time);
#if PSP_HAS_IRTC == 1
irtc_test();
#endif /* PSP_HAS_IRTC == 1 */
printf ("Finish, press/hold reset to repeat.\n");
_task_block() ;
} /* Endbody */
