firmware/drivers/rtc/rtc_as3514.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 by Barry Wardell
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <stdbool.h>
  22 #include "config.h"
  23 #include "rtc.h"
  24 #include "as3514.h"
  25 #include "ascodec.h"
  26
  27 /* AMS Sansas start counting from Jan 1st 1970 instead of 1980 (not as3525v2) */
  28 #if (CONFIG_CPU==AS3525)
  29 #define SECS_ADJUST 315532800   /* seconds between 1970-1-1 and 1980-1-1 */
  30 #elif (CONFIG_CPU==AS3525v2)
  31 #define SECS_ADJUST 315532800 - (2*365*24*3600) - 26*(24*3600) + 7*3600 + 25*60
  32 #else
  33 #define SECS_ADJUST 0
  34 #endif
  35
  36 #define MINUTE_SECONDS      60
  37 #define HOUR_SECONDS        3600
  38 #define DAY_SECONDS         86400
  39 #define WEEK_SECONDS        604800
  40 #define YEAR_SECONDS        31536000
  41 #define LEAP_YEAR_SECONDS   31622400
  42
  43 /* Days in each month */
  44 static unsigned int days_in_month[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  45
  46 static inline bool is_leapyear(int year)
  47 {
  48     if( ((year%4)==0) && (((year%100)!=0) || ((year%400)==0)) )
  49         return true;
  50     else
  51         return false;
  52 }
  53
  54 #ifdef HAVE_RTC_ALARM /* as3543 */
  55 static int wakeup_h;
  56 static int wakeup_m;
  57 static bool alarm_enabled = false;
  58
  59 void rtc_set_alarm(int h, int m)
  60 {
  61     wakeup_h = h;
  62     wakeup_m = m;
  63 }
  64
  65 void rtc_get_alarm(int *h, int *m)
  66 {
  67     *h = wakeup_h;
  68     *m = wakeup_m;
  69 }
  70
  71 void rtc_alarm_poweroff(void)
  72 {
  73     if(!alarm_enabled)
  74         return;
  75
  76     struct tm tm;
  77     rtc_read_datetime(&tm);
  78     int hours = wakeup_h - tm.tm_hour;
  79     int mins  = wakeup_m - tm.tm_min;
  80     if(mins < 0)
  81     {
  82         mins += 60;
  83         hours -= 1;
  84     }
  85     if(hours < 0)
  86         hours += 24;
  87
  88     uint32_t seconds = hours*3600 + mins*60;
  89     if(seconds == 0)
  90         seconds = 24*3600;
  91
  92     seconds -= tm.tm_sec;
  93
  94     disable_irq();
  95
  96     ascodec_write(AS3543_WAKEUP, seconds);
  97     seconds >>= 8;
  98     ascodec_write(AS3543_WAKEUP, seconds);
  99     seconds >>= 8;
 100     seconds |= 1<<7; /* enable bit */
 101     ascodec_write(AS3543_WAKEUP, seconds);
 102
 103     /* write our desired time of wake up to detect power-up from RTC */
 104     ascodec_write(AS3543_WAKEUP, wakeup_h);
 105     ascodec_write(AS3543_WAKEUP, wakeup_m);
 106
 107     /* enable hearbeat watchdog */
 108     ascodec_write(AS3514_SYSTEM, (1<<3) | (1<<0));
 109
 110     /* In_Cntr : disable hearbeat source */
 111     ascodec_write_pmu(0x1a, 4, ascodec_read_pmu(0x1a, 4) & ~(3<<2));
 112
 113     while(1);
 114 }
 115
 116 void rtc_enable_alarm(bool enable)
 117 {
 118     alarm_enabled = enable;
 119 }
 120
 121 bool rtc_check_alarm_started(bool release_alarm)
 122 {
 123     (void) release_alarm;
 124
 125     /* 3 first reads give the 23 bits counter and enable bit */
 126     ascodec_read(AS3543_WAKEUP); /* bits  7:0  */
 127     ascodec_read(AS3543_WAKEUP); /* bits 15:8  */
 128     if(!(ascodec_read(AS3543_WAKEUP) & (1<<7))) /* enable bit */
 129         return false;
 130
 131     /* subsequent reads give the 16 bytes static SRAM */
 132     wakeup_h = ascodec_read(AS3543_WAKEUP);
 133     wakeup_m = ascodec_read(AS3543_WAKEUP);
 134
 135     struct tm tm;
 136     rtc_read_datetime(&tm);
 137
 138     /* were we powered up at the programmed time ? */
 139     return wakeup_h == tm.tm_hour && wakeup_m == tm.tm_min;
 140 }
 141
 142 bool rtc_check_alarm_flag(void)
 143 {
 144     /* We don't need to do anything special if it has already fired */
 145     return false;
 146 }
 147 #endif /* HAVE_RTC_ALARM */
 148
 149 void rtc_init(void)
 150 {
 151 }
 152
 153 int rtc_read_datetime(struct tm *tm)
 154 {
 155     char tmp[4];
 156     int i, year, mday, hour, min;
 157     unsigned int seconds;
 158
 159     /* RTC_AS3514's slave address is 0x46*/
 160     for (i = 0; i < 4; i++){
 161         tmp[i] = ascodec_read(AS3514_RTC_0 + i);
 162     }
 163     seconds = tmp[0] + (tmp[1]<<8) + (tmp[2]<<16) + (tmp[3]<<24);
 164     seconds -= SECS_ADJUST;
 165
 166     /* Convert seconds since Jan-1-1980 to format compatible with
 167      * get_time() from firmware/common/timefuncs.c */
 168
 169     /* weekday */
 170     tm->tm_wday = ((seconds % WEEK_SECONDS) / DAY_SECONDS + 2) % 7;
 171
 172     /* Year */
 173     year = 1980;
 174     while (seconds >= LEAP_YEAR_SECONDS)
 175     {
 176         if (is_leapyear(year)){
 177             seconds -= LEAP_YEAR_SECONDS;
 178         } else {
 179             seconds -= YEAR_SECONDS;
 180         }
 181
 182         year++;
 183     }
 184
 185     if (is_leapyear(year)) {
 186         days_in_month[1] = 29;
 187     } else {
 188         days_in_month[1] = 28;
 189         if(seconds>YEAR_SECONDS){
 190             year++;
 191             seconds -= YEAR_SECONDS;
 192         }
 193     }
 194     tm->tm_year = year%100 + 100;
 195
 196     /* Month */
 197     for (i = 0; i < 12; i++)
 198     {
 199         if (seconds < days_in_month[i]*DAY_SECONDS){
 200             tm->tm_mon = i;
 201             break;
 202         }
 203
 204         seconds -= days_in_month[i]*DAY_SECONDS;
 205     }
 206
 207     /* Month Day */
 208     mday = seconds/DAY_SECONDS;
 209     seconds -= mday*DAY_SECONDS;
 210     tm->tm_mday = mday + 1; /* 1 ... 31 */
 211
 212     /* Hour */
 213     hour = seconds/HOUR_SECONDS;
 214     seconds -= hour*HOUR_SECONDS;
 215     tm->tm_hour = hour;
 216
 217     /* Minute */
 218     min = seconds/MINUTE_SECONDS;
 219     seconds -= min*MINUTE_SECONDS;
 220     tm->tm_min = min;
 221
 222     /* Second */
 223     tm->tm_sec = seconds;
 224
 225     return 7;
 226 }
 227
 228 int rtc_write_datetime(const struct tm *tm)
 229 {
 230     int i, year;
 231     unsigned int year_days = 0;
 232     unsigned int month_days = 0;
 233     unsigned int seconds = 0;
 234
 235     year = 2000 + tm->tm_year - 100;
 236
 237     if(is_leapyear(year)) {
 238         days_in_month[1] = 29;
 239     } else {
 240         days_in_month[1] = 28;
 241     }
 242
 243     /* Number of days in months gone by this year*/
 244     for(i = 0; i < tm->tm_mon; i++){
 245         month_days += days_in_month[i];
 246     }
 247
 248     /* Number of days in years gone by since 1-Jan-1980 */
 249     year_days = 365*(tm->tm_year-100+20) + (tm->tm_year-100-1)/4 + 6;
 250
 251     /* Convert to seconds since 1-Jan-1980 */
 252     seconds = tm->tm_sec
 253             + tm->tm_min*MINUTE_SECONDS
 254             + tm->tm_hour*HOUR_SECONDS
 255             + (tm->tm_mday-1)*DAY_SECONDS
 256             + month_days*DAY_SECONDS
 257             + year_days*DAY_SECONDS;
 258     seconds += SECS_ADJUST;
 259
 260     /* Send data to RTC */
 261     for (i=0; i<4; i++){
 262         ascodec_write(AS3514_RTC_0 + i, ((seconds >> (8 * i)) & 0xff));
 263     }
 264     return 1;
 265 }