rtc.c

/*
 * Copyright (c) 2010, Mariano Alvira <mar@devl.org> and other contributors
 * to the MC1322x project (http://mc1322x.devl.org)
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the Institute nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * This file is part of libmc1322x: see http://mc1322x.devl.org
 * for details.
 *
 *
 */

#include <mc1322x.h>
#include <stdlib.h>
#include "rtc.h"

/* Define USE_32KHZ in board.h to start and use the 32 KHz
   oscillator, otherwise the 2 KHz ring oscillator is used. */

int rtc_freq = 0;
static int __use_32khz = 0;

/* Init RTC */
void rtc_init_osc(int use_32khz)
{
        __use_32khz = use_32khz;

        if (use_32khz)
        {
                uint32_t old;

                /* You have to hold its hand with this one */
                /* once you start the 32KHz crystal it can only be
                 * stopped with a reset (hard or soft). */

                /* first, disable the ring osc */
                CRM->RINGOSC_CNTLbits.ROSC_EN = 0;

                /* enable the 32kHZ crystal */
                CRM->XTAL32_CNTLbits.XTAL32_EN = 1;

                /* set the XTAL32_EXISTS bit */
                /* the datasheet says to do this after you check that RTC_COUNT
                   is changing, but it is not correct; it needs to be set first */
                CRM->SYS_CNTLbits.XTAL32_EXISTS = 1;

                old = CRM->RTC_COUNT;
                while (CRM->RTC_COUNT == old)
                        continue;

                /* RTC has started up */
                rtc_freq = 32000;
        }
        else
        {
                /* Enable ring osc */
                CRM->RINGOSC_CNTLbits.ROSC_EN = 1;
                CRM->XTAL32_CNTLbits.XTAL32_EN = 0;

                /* Set default tune values from datasheet */
                CRM->RINGOSC_CNTLbits.ROSC_CTUNE = 0x6;
                CRM->RINGOSC_CNTLbits.ROSC_FTUNE = 0x17;

                /* Trigger calibration */
                rtc_calibrate();
        }
}

uint32_t __rtc_try(int loading, int timeout)
{
        /* Total loading is
             ctune * 1000 fF + ftune * 160 fF
           ctune = 0-15
           ftune = 0-31
           max = 19960 fF
        */

#define RTC_LOADING_MIN 0
#define RTC_LOADING_MAX 19960

        /* The fine tune covers a range larger than a single coarse
           step.  Check all coarse steps within the fine tune range to
           find the optimal CTUNE, FTUNE pairs. */
#define CTUNE_MAX 15
#define FTUNE_MAX 31
#define CSTEP 1000
#define FSTEP 160
#define MAX_F (FSTEP*FTUNE_MAX)  /* actually lcm(CSTEP,FSTEP) would be better,
                                    but in this case it's basically the same */
        int ctune;
        int ftune;
        int ctune_start = (loading - MAX_F) / CSTEP;
        int ctune_end = loading / CSTEP;
        int best_err = loading, best_ctune = 0, best_ftune = 0;

        uint32_t count;

        if (ctune_start < 0) ctune_start = 0;
        if (ctune_end > CTUNE_MAX) ctune_end = CTUNE_MAX;

        for (ctune = ctune_start; ctune <= ctune_end; ctune++)
        {
                int this_loading, this_err;

                ftune = ((loading - (ctune * CSTEP)) + (FSTEP / 2)) / FSTEP;
                if (ftune < 0) ftune = 0;
                if (ftune > FTUNE_MAX) ftune = FTUNE_MAX;

                this_loading = ctune * CSTEP + ftune * FSTEP;
                this_err = abs(this_loading - loading);
                if (this_err < best_err) {
                        best_err = this_err;
                        best_ctune = ctune;
                        best_ftune = ftune;
                }
        }

//      printf("requested loading %d, actual loading %d\r\n", loading,
//                best_ctune * CSTEP + best_ftune * FSTEP);

        /* Run the calibration */
        CRM->RINGOSC_CNTLbits.ROSC_CTUNE = best_ctune;
        CRM->RINGOSC_CNTLbits.ROSC_FTUNE = best_ftune;
        CRM->CAL_CNTLbits.CAL_TIMEOUT = timeout;
        CRM->STATUSbits.CAL_DONE = 1;
        CRM->CAL_CNTLbits.CAL_EN = 1;
        while (CRM->STATUSbits.CAL_DONE == 0)
                continue;

        /* Result should ideally be close to (REF_OSC * (timeout / 2000)) */
        count = CRM->CAL_COUNT;
        if (count == 0) count = 1;  /* avoid divide by zero problems */
        return count;
}

/* Calibrate the ring oscillator */
void rtc_calibrate(void)
{
        /* Just bisect a few times.  Our best tuning accuracy is about
           1/500 of the full scale, so doing this 8-9 times is about
           as accurate as we can get */
        int i;
        int low = RTC_LOADING_MIN, high = RTC_LOADING_MAX;
        int mid;
        uint32_t count;

        if (__use_32khz) {
                rtc_freq = 32000;
                return;
        }

#define TIMEOUT 100  /* 50 msec per attempt */

        for (i = 0; i < 9; i++)
        {
                mid = (low + high) / 2;
                count = __rtc_try(mid, TIMEOUT);
                // careful about overflow
                rtc_freq = REF_OSC / ((count + TIMEOUT/2) / TIMEOUT);

                if (rtc_freq > 2000)
                        low = mid;  // increase loading
                else
                        high = mid; // decrease loading
        }

//      printf("RTC calibrated to %d Hz\r\n", rtc_freq);
}


/* Delay for the specified number of milliseconds by polling RTC */
void rtc_delay_ms(uint32_t msec)
{
        uint32_t start;

        start = CRM->RTC_COUNT;
        while ((CRM->RTC_COUNT - start) < ((msec * rtc_freq) / 1000))
                continue;
}