m48t37.c

LoPEC Early Access VxWorks BSP

    NV_RAM_WRITE((ULONG)M48T37_ALARM_MINUTE, BIN_TO_BCD (alarm_time->minute));
    NV_RAM_WRITE((ULONG)M48T37_ALARM_HOUR, BIN_TO_BCD (alarm_time->hour));
    NV_RAM_WRITE((ULONG)M48T37_ALARM_DATE, BIN_TO_BCD (alarm_time->day_of_month));

    /* If repeatable(day, hour, minute, second)then set the repeat bits */

    alarm_clock_rpt1 = NV_RAM_READ((ULONG)M48T37_ALARM_SECOND);
    alarm_clock_rpt2 = NV_RAM_READ((ULONG)M48T37_ALARM_MINUTE);
    alarm_clock_rpt3 = NV_RAM_READ((ULONG)M48T37_ALARM_HOUR);
    alarm_clock_rpt4 = NV_RAM_READ((ULONG)M48T37_ALARM_DATE);

    if (method == ALARM_EVERY_DAY)
        {
 NV_RAM_WRITE((ULONG)M48T37_ALARM_DATE, alarm_clock_rpt4 | M48T37_REPEAT);
        }
    else if (method == ALARM_EVERY_HOUR)
        {
        NV_RAM_WRITE((ULONG)M48T37_ALARM_DATE, alarm_clock_rpt4 | M48T37_REPEAT);
        NV_RAM_WRITE((ULONG)M48T37_ALARM_HOUR, alarm_clock_rpt3 | M48T37_REPEAT);
        }
    else if (method == ALARM_EVERY_MINUTE)
        {
        NV_RAM_WRITE((ULONG)M48T37_ALARM_DATE, alarm_clock_rpt4 | M48T37_REPEAT);
        NV_RAM_WRITE((ULONG)M48T37_ALARM_HOUR, alarm_clock_rpt3 | M48T37_REPEAT);
        NV_RAM_WRITE((ULONG)M48T37_ALARM_MINUTE, alarm_clock_rpt2 | M48T37_REPEAT);
        }
    else if (method == ALARM_EVERY_SECOND) 
        {
        NV_RAM_WRITE((ULONG)M48T37_ALARM_DATE, alarm_clock_rpt4 | M48T37_REPEAT);
        NV_RAM_WRITE((ULONG)M48T37_ALARM_HOUR, alarm_clock_rpt3 | M48T37_REPEAT);
        NV_RAM_WRITE((ULONG)M48T37_ALARM_MINUTE, alarm_clock_rpt2 | M48T37_REPEAT);
        NV_RAM_WRITE((ULONG)M48T37_ALARM_SECOND, alarm_clock_rpt1 | M48T37_REPEAT);
        }
    else if (method != ALARM_EVERY_MONTH)
        {
        return (ERROR);
        }

    return (OK);

    }

/*******************************************************************************
*
* m48t37AlarmCancel - Disable the alarm clock.
*
* This routine disables the alarm clock.
*
* RETURNS: OK always. 
*/

STATUS m48t37AlarmCancel (void)
     {

     /* To disable the alarm clock we must write 0 to alarm registers */
    
     NV_RAM_WRITE((ULONG)M48T37_ALARM_SECOND, 0);
     NV_RAM_WRITE((ULONG)M48T37_ALARM_MINUTE, 0);
     NV_RAM_WRITE((ULONG)M48T37_ALARM_HOUR, 0);
     NV_RAM_WRITE((ULONG)M48T37_ALARM_DATE, 0);

     return (OK);

     }

/*******************************************************************************
*
* m48t37AlarmGet -  Populate an ALARM_DATE_TIME structure with current alarm clock settings. 
*
* This routine will retrieve the current alarm clock settings and place them
* in an ALARM_DATE_TIME structure and method which the user must pass in.
*
* RETURNS: OK, or error if the alarm settings are not valid.
*/

STATUS m48t37AlarmGet
     (
     UCHAR * method,			/* method = ALARM_EVERY_XXXX */
     ALARM_DATE_TIME * alarm_time	/* pointer to alarm parameters */
     )
     {
     UCHAR alarm_date_reg;		/* M48T37_ALARM_DATE reg. */
     UCHAR alarm_hour_reg;		/* M48T37_ALARM_HOUR reg. */
     UCHAR alarm_minute_reg;		/* M48T37_ALARM_MINUTE reg. */
     UCHAR alarm_second_reg;		/* M48T37_ALARM_SECOND reg. */

     UCHAR rpt4 = 0;			/* RPT4 bit */
     UCHAR rpt3 = 0;			/* RPT3 bit */
     UCHAR rpt2 = 0; 			/* RPT3 bit */
     UCHAR rpt1 = 0;			/* RPT1 bit */

     /* Read the values from the alarm clock */

     alarm_date_reg = NV_RAM_READ((ULONG)M48T37_ALARM_DATE);
     alarm_hour_reg = NV_RAM_READ((ULONG)M48T37_ALARM_HOUR);
     alarm_minute_reg = NV_RAM_READ((ULONG)M48T37_ALARM_MINUTE);
     alarm_second_reg = NV_RAM_READ((ULONG)M48T37_ALARM_SECOND);

     /* Determine if the alarm is set for a repeat mode */
     
     rpt4 = (alarm_date_reg >> ALARM_REPEAT_SHIFT_VALUE);
     rpt3 = (alarm_hour_reg >> ALARM_REPEAT_SHIFT_VALUE);
     rpt2 = (alarm_minute_reg >> ALARM_REPEAT_SHIFT_VALUE);
     rpt1 = (alarm_second_reg >> ALARM_REPEAT_SHIFT_VALUE);
 
     if ((rpt4 == 0x01) && (rpt3 == 0x01) && (rpt2 == 0x01) && (rpt1 == 0x01))
        {

        /* ALARM_EVERY_SECOND */

        *method = ALARM_EVERY_SECOND; 
        }
     else if ((rpt4 == 0x01) && (rpt3 == 0x01) && (rpt2 == 0x01) && 
              (rpt1 == 0x00))
        {

        /* ALARM_EVERY_MINUTE */

        *method = ALARM_EVERY_MINUTE;
        }
     else if ((rpt4 == 0x01) && (rpt3 == 0x01) && (rpt2 == 0x00) && 
              (rpt1 == 0x00))
        {

        /* ALARM_EVERY_HOUR */

        *method = ALARM_EVERY_HOUR; 
        }
     else if ((rpt4 == 0x01) && (rpt3 == 0x00) && (rpt2 == 0x00) && 
              (rpt1 == 0x00))
        {

        /* ALARM_EVERY_DAY */

        *method = ALARM_EVERY_DAY;
        }
     else if ((rpt4 == 0x00) && (rpt3 == 0x00) && (rpt2 == 0x00) && 
              (rpt1 == 0x00))
        {

        /* ALARM_EVERY_MONTH */

        *method = ALARM_EVERY_MONTH;
        }
     else
        {

        /* Unknown alarm configuration */

        return (ERROR);
        }

     /* populate alarm_time with alarm clock settings */

     alarm_time->day_of_month = BCD_TO_BIN ( alarm_date_reg & ALARM_DATE_MASK );
     alarm_time->hour = BCD_TO_BIN ( alarm_hour_reg & ALARM_HOUR_MASK ); 
     alarm_time->minute = BCD_TO_BIN ( alarm_minute_reg & ALARM_MINUTE_MASK ); 
     alarm_time->second = BCD_TO_BIN ( alarm_second_reg & ALARM_SECOND_MASK ); 

     return (OK);
     
     }

/*******************************************************************************
*
* m48t37AlarmShow - Display current alarm clock settings on the user's display.
*
* This routine retrieves the current alarm clock settings and sends them to 
* the user's display.
*
* RETURN: OK, or ERROR if unable to retrieve current settings.
*/

STATUS m48t37AlarmShow (void)
     {
     UCHAR method = 0;			/* method = ALARM_EVERY_XXXX */
     ALARM_DATE_TIME * alarm_time = 0;	/* pointer to alarm parameters */

     /* Retrieve the current settings */

     if (m48t37AlarmGet(&method, alarm_time) == ERROR)
        {
        return (ERROR);
        }
 
     /* Send the alarm settings to the user's display */

     if ((alarm_time->day_of_month == 0) && (alarm_time->hour == 0) && 
         (alarm_time->minute == 0) && (alarm_time->second == 0))
        {
        printf("Alarm is disabled.\n");
        return (OK);
        }

     if (method == ALARM_EVERY_MONTH)
        {
        printf("Alarm is set to go off once a month at:\n");
        printf("  Date: %d\n",alarm_time->day_of_month);
        printf("  Hour: %d\n",alarm_time->hour);
        printf("Minute: %d\n",alarm_time->minute);
        printf("Second: %d\n",alarm_time->second);
        }
     else if (method == ALARM_EVERY_DAY)
        {
        printf("Alarm is set to go off once a day at:\n");
        printf("  Hour: %d\n",alarm_time->hour);
        printf("Minute: %d\n",alarm_time->minute);
        printf("Second: %d\n",alarm_time->second);
        }
     else if (method == ALARM_EVERY_HOUR)
        {
        printf("Alarm is set to go off once an hour at:\n");
        printf("Minute: %d\n",alarm_time->minute);
        printf("Second: %d\n",alarm_time->second);
        }
     else if (method == ALARM_EVERY_MINUTE)
        {
        printf("Alarm is set to go off once a minute at:\n");
        printf("Second: %d\n",alarm_time->second);
        }
     else if (method == ALARM_EVERY_SECOND)
        {
        printf("Alarm is set to go off once a second.\n");
        }
     else
        {

        /* Unknown method */

        return (ERROR);
        }

     return (OK);

     }

/*******************************************************************************
*
* m48t37FailsafeSet - Set failsafe timer parameters/feed failsafe timer.
*
* This routine sets the failsafe timer configuration parameters. It is also
* used to "feed" the failsafe to prevent expiration of the timer.
*
* The reset parameter determines whether timer expiration will generate
* an interrupt or a board reset.  If set to FALSE an interrupt will be 
* generated.  If set to TRUE a board reset will occur.
*
* If failsafe timer expiration is configured to generate an interrupt,
* the interrupt must be enabled and a handler attached before m48t37FailsafeSet
* is called to arm the failsafe timer. When the failsafe interrupt occurs,
* m48t37FailsafeSet must be called with "seconds" set to 0 to clear the
* interrupt, or m48t37FailsafeCancel must be called before the handler returns.
*
* RETURNS: OK if successful or ERROR if parameter error.
*
* SEE ALSO: m48t37FailsafeGet ()
*/

STATUS m48t37FailsafeSet
    (
    UCHAR seconds,	/* timer interval, 0 = disarm, 1-31 = arm, else ERROR */
    BOOL  reset		/* board reset or interrupt on timer expiration */
    )
    {
    UCHAR temp = 0;	/* 0 = disarm failsafe timer */

    if (seconds > M48T37FAILSAFE_MULTIPLIER_MAX)
         return (ERROR);

    /* if seconds is non-zero, buildup the failsafe control register image */

    if (seconds != 0)
        {

        /* configure the failsafe "steering" bit */

        temp = (reset ? M48T37FAILSAFE_WDS_RESET : 
                 M48T37FAILSAFE_WDS_INTERRUPT) << M48T37FAILSAFE_WDS_SHIFT;

        /* configure the multiplier field */

        temp |= seconds << M48T37FAILSAFE_MULTIPLIER_SHIFT;

        /* set the resolution to seconds */

        temp |= M48T37FAILSAFE_RESOLUTION_SECS;
        }

    /* write the failsafe ( watchdog ) timer control register */

    NV_RAM_WRITE((ULONG)M48T37_FAILSAFE, temp);

    return (OK);

    }

/*******************************************************************************
*
* m48t37FailsafeGet - Get failsafe timer parameters.
*
* This routine gets the failsafe timer configuration parameters. Note that it
* returns the current configuration of the timer, not the amount of time
* remaining until timer expiration.
*
* RETURNS: OK always.
*
* SEE ALSO: m48t37FailsafeSet ()
*/

STATUS m48t37FailsafeGet
    (
    UCHAR * seconds,	/* address for returning seconds (or NULL) */
    BOOL  * reset	/* address for returning expiration action (or NULL) */
    )
    {
    UCHAR temp;

    /* read the failsafe timer control register */

    temp = NV_RAM_READ((ULONG)M48T37_FAILSAFE);

    /* return configured timeout if requested */

    if (seconds != NULL)
        *seconds = (temp & M48T37FAILSAFE_MULTIPLIER_MASK)
                    >> M48T37FAILSAFE_MULTIPLIER_SHIFT;

    /* return configured timeout action if requested */

    if (reset != NULL)
        *reset = (temp & M48T37FAILSAFE_WDS_MASK) >> M48T37FAILSAFE_WDS_SHIFT;

    return (OK);

    }

/*******************************************************************************
*
* m48t37FailsafeCausedReset - Determine if failsafe timer caused last board reset.
*
* This routine determines whether the failsafe timer caused the last board
* reset.
*
* RETURNS: TRUE if failsafe timer caused last board reset, FALSE if not.
*/

BOOL m48t37FailsafeCausedReset (void)
    {
    UCHAR m48t37_flags_value;		/* M48T37_FLAGS reg. */

    /* Read the Flags register */

    m48t37_flags_value = NV_RAM_READ((ULONG)M48T37_FLAGS);

    /* Determine if failsafe flag is set */

    if ((m48t37_flags_value & M48T37_FAILSAFE_FLAG) == 0x80)
        {
        return (TRUE);
        }
    else
        return (FALSE);
    }

/*******************************************************************************
*
* m48t37Intr - Interrupt handler for the M48T37.
*
* This routine is a generic interrupt handler for the M48T37.  It determines
* whether the interrupt was triggered by the alarm clock or the failsafe 
* timer and calls the appropriate interrupt handler.  The interrupt handlers
* are defined in the real-time clock/alarm clock and failsafe timer "interface"
* files (ie. sysRtc.c and sysFailsafe.c).  It is in these files that the user
* can design their own interrupt handlers by adjusting the existing example
* interrupt handlers.
*
* RETURNS: void.
*/

LOCAL void m48t37Intr (void)
    {
    UCHAR m48t37_flags_value;		/* M48T37_FLAGS reg. */

    m48t37_flags_value = NV_RAM_READ((ULONG)M48T37_FLAGS);

    #ifdef INCLUDE_RTC

    /* Alarm clock interrupt - alarm clock interrupt handler */

    if (m48t37_flags_value & M48T37_ALARM_FLAG)
       {

       /* 
        * Call the alarm clock "interface" interrupt handler.
        * If the user wishes to write their own handler routine, they
        * need only edit the interface handler routine. 
        */

       sysAlarmIntr(); 
       }
    #endif /* INCLUDE_RTC */

    #ifdef INCLUDE_FAILSAFE

    /* Failsafe timer interrupt - failsafe timer interrupt handler */

    if (m48t37_flags_value & M48T37_FAILSAFE_FLAG)
       {

       /*
        * Call the failsafe timer "interface" interrupt handler.
        * If the user wishes to write their own handler routine, they
        * need only edit the interface handler routine.
        */

       sysFailsafeIntr(); 
       }
    #endif /* INCLUDE_FAILSAFE */

    }

/*******************************************************************************
*
* m48t37FailsafeShow - Show the current failsafe timer parameters.
*
* This routine displays the current failsafe timer configuration parameters.
*
* RETURNS: OK always
*
* SEE ALSO:m48t37FailsafeSet (),  m48t37FailsafeGet () 
*/

STATUS m48t37FailsafeShow (void)
    {
    UCHAR seconds;	/* timer interval, 0 = disarmed, 1-31 = arm */
    BOOL  reset;	/* board reset or interrupt on timer expiration */

    /* get current watchdog configuration */

    if (m48t37FailsafeGet(&seconds, &reset) != OK)
        return (ERROR);

    if (seconds == 0)
        printf ("Failsafe is disabled.\r\n");
    else
        printf ("Failsafe timeout set at %d second%s and generates a%s.\r\n",
                seconds, (seconds == 1) ? "" : "s",
                reset ? " board reset" : "n interrupt");

    return (OK);

    }

/*******************************************************************************
*
* m48t37Init - Initialize the M48T37. 
*
* This routine initializes the M48T37 by connecting the interrupt
* handler function pointer to the RTC interrupt line.  This routine enables the
* RTC interrupt. 
*
* RETURNS: OK always
*
*/

STATUS m48t37Init (void)
    {
    intConnect (INUM_TO_IVEC(RTC_INT_VEC), m48t37Intr, 0);

    intEnable (RTC_INT_LVL);

    return (OK);

    }
#endif /* INCLUDE_RTC, INCLUDE_FAILSAFE */

/*******************************************************************************
*
* m48t37FailsafeCancel - cancel the failsafe timer 
*
* This routine cancels the failsafe timer.
*
* RETURNS: OK always. 
*
* SEE ALSO: m48t37FailsafeSet ()
*/

STATUS  m48t37FailsafeCancel (void)
    {
    UCHAR temp = 0;	/* 0 = disarm failsafe timer */

    /* write the failsafe ( watchdog ) timer control register */

    NV_RAM_WRITE((ULONG)M48T37_FAILSAFE, temp);

    return (OK);

    }