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 struct {
  56     unsigned int seconds;   /* total seconds to wakeup */
  57     int hour;               /* wake-up hour */
  58     int min;                /* wake-up minute */
  59     bool enabled;           /* alarm enabled or not */
  60     unsigned char flag;     /* flag used by the OF */
  61 } alarm;
  62
  63 void rtc_set_alarm(int h, int m)
  64 {
  65     alarm.hour = h;
  66     alarm.min = m;
  67 }
  68
  69 void rtc_get_alarm(int *h, int *m)
  70 {
  71     *h = alarm.hour;
  72     *m = alarm.min;
  73 }
  74
  75 /* Reads the AS3543 wakeup register */
  76 static void alarm_read(void)
  77 {
  78     unsigned char buf[6];
  79     unsigned int i;
  80     int oldstatus;
  81
  82     /* read raw data */
  83     oldstatus = disable_irq_save();
  84     ascodec_read(0);
  85     for (i = 0; i < sizeof(buf); i++) {
  86         buf[i] = ascodec_read(AS3543_WAKEUP);
  87     }
  88     restore_irq(oldstatus);
  89
  90     /* decode */
  91     alarm.seconds = buf[0] | (buf[1] << 8) | ((buf[2] & 0x7F) << 16);
  92     alarm.enabled = buf[2] & (1 << 7);
  93     alarm.flag = buf[3];
  94     alarm.hour = buf[4];
  95     alarm.min = buf[5];
  96 }
  97
  98 /* Writes the AS3543 wakeup register */
  99 static void alarm_write(void)
 100 {
 101     unsigned char buf[6];
 102     unsigned int i;
 103     int oldstatus;
 104
 105     /* encode */
 106     buf[0] = alarm.seconds  & 0xFF;
 107     buf[1] = (alarm.seconds >> 8) & 0xFF;
 108     buf[2] = ((alarm.seconds >> 16) & 0x7F) | (alarm.enabled ? (1 << 7) : 0);
 109     buf[3] = alarm.flag;
 110     buf[4] = alarm.hour;
 111     buf[5] = alarm.min;
 112
 113     /* write raw data */
 114     oldstatus = disable_irq_save();
 115     ascodec_read(0);
 116     for (i = 0; i < sizeof(buf); i++) {
 117         ascodec_write(AS3543_WAKEUP, buf[i]);
 118     }
 119     restore_irq(oldstatus);
 120 }
 121
 122 void rtc_alarm_poweroff(void)
 123 {
 124     if(!alarm.enabled)
 125         return;
 126
 127     struct tm tm;
 128     rtc_read_datetime(&tm);
 129     int hours = alarm.hour - tm.tm_hour;
 130     int mins  = alarm.min - tm.tm_min;
 131     if(mins < 0)
 132     {
 133         mins += 60;
 134         hours -= 1;
 135     }
 136     if(hours < 0)
 137         hours += 24;
 138
 139     uint32_t seconds = hours*3600 + mins*60;
 140     if(seconds == 0)
 141         seconds = 24*3600;
 142
 143     seconds -= tm.tm_sec;
 144
 145     /* write wakeup register */
 146     alarm.seconds = seconds;
 147     alarm.enabled = true;
 148     alarm_write();
 149
 150     /* enable heartbeat watchdog */
 151     ascodec_write(AS3514_SYSTEM, (1<<3) | (1<<0));
 152
 153     /* In_Cntr : disable heartbeat source */
 154     ascodec_write_pmu(0x1a, 4, ascodec_read_pmu(0x1a, 4) & ~(3<<2));
 155
 156     while(1);
 157 }
 158
 159 void rtc_enable_alarm(bool enable)
 160 {
 161     alarm.enabled = enable;
 162 }
 163
 164 bool rtc_check_alarm_started(bool release_alarm)
 165 {
 166     /* read wakeup register and check if alarm was enabled */
 167     alarm_read();
 168     if (!alarm.enabled) {
 169         return false;
 170     }
 171
 172     alarm.enabled = !release_alarm;
 173     alarm_write();
 174
 175     struct tm tm;
 176     rtc_read_datetime(&tm);
 177
 178     /* were we powered up at the programmed time ? */
 179     return alarm.hour == tm.tm_hour && alarm.min == tm.tm_min;
 180 }
 181
 182 bool rtc_check_alarm_flag(void)
 183 {
 184     /* We don't need to do anything special if it has already fired */
 185     return false;
 186 }
 187 #endif /* HAVE_RTC_ALARM */
 188
 189 void rtc_init(void)
 190 {
 191 }
 192
 193 int rtc_read_datetime(struct tm *tm)
 194 {
 195     char tmp[4];
 196     int i, year, mday, hour, min;
 197     unsigned int seconds;
 198
 199     /* RTC_AS3514's slave address is 0x46*/
 200     for (i = 0; i < 4; i++){
 201         tmp[i] = ascodec_read(AS3514_RTC_0 + i);
 202     }
 203     seconds = tmp[0] + (tmp[1]<<8) + (tmp[2]<<16) + (tmp[3]<<24);
 204     seconds -= SECS_ADJUST;
 205
 206     /* Convert seconds since Jan-1-1980 to format compatible with
 207      * get_time() from firmware/common/timefuncs.c */
 208
 209     /* weekday */
 210     tm->tm_wday = ((seconds % WEEK_SECONDS) / DAY_SECONDS + 2) % 7;
 211
 212     /* Year */
 213     year = 1980;
 214     while (seconds >= LEAP_YEAR_SECONDS)
 215     {
 216         if (is_leapyear(year)){
 217             seconds -= LEAP_YEAR_SECONDS;
 218         } else {
 219             seconds -= YEAR_SECONDS;
 220         }
 221
 222         year++;
 223     }
 224
 225     if (is_leapyear(year)) {
 226         days_in_month[1] = 29;
 227     } else {
 228         days_in_month[1] = 28;
 229         if(seconds>YEAR_SECONDS){
 230             year++;
 231             seconds -= YEAR_SECONDS;
 232         }
 233     }
 234     tm->tm_year = year%100 + 100;
 235
 236     /* Month */
 237     for (i = 0; i < 12; i++)
 238     {
 239         if (seconds < days_in_month[i]*DAY_SECONDS){
 240             tm->tm_mon = i;
 241             break;
 242         }
 243
 244         seconds -= days_in_month[i]*DAY_SECONDS;
 245     }
 246
 247     /* Month Day */
 248     mday = seconds/DAY_SECONDS;
 249     seconds -= mday*DAY_SECONDS;
 250     tm->tm_mday = mday + 1; /* 1 ... 31 */
 251
 252     /* Hour */
 253     hour = seconds/HOUR_SECONDS;
 254     seconds -= hour*HOUR_SECONDS;
 255     tm->tm_hour = hour;
 256
 257     /* Minute */
 258     min = seconds/MINUTE_SECONDS;
 259     seconds -= min*MINUTE_SECONDS;
 260     tm->tm_min = min;
 261
 262     /* Second */
 263     tm->tm_sec = seconds;
 264
 265     return 7;
 266 }
 267
 268 int rtc_write_datetime(const struct tm *tm)
 269 {
 270     int i, year;
 271     unsigned int year_days = 0;
 272     unsigned int month_days = 0;
 273     unsigned int seconds = 0;
 274
 275     year = 2000 + tm->tm_year - 100;
 276
 277     if(is_leapyear(year)) {
 278         days_in_month[1] = 29;
 279     } else {
 280         days_in_month[1] = 28;
 281     }
 282
 283     /* Number of days in months gone by this year*/
 284     for(i = 0; i < tm->tm_mon; i++){
 285         month_days += days_in_month[i];
 286     }
 287
 288     /* Number of days in years gone by since 1-Jan-1980 */
 289     year_days = 365*(tm->tm_year-100+20) + (tm->tm_year-100-1)/4 + 6;
 290
 291     /* Convert to seconds since 1-Jan-1980 */
 292     seconds = tm->tm_sec
 293             + tm->tm_min*MINUTE_SECONDS
 294             + tm->tm_hour*HOUR_SECONDS
 295             + (tm->tm_mday-1)*DAY_SECONDS
 296             + month_days*DAY_SECONDS
 297             + year_days*DAY_SECONDS;
 298     seconds += SECS_ADJUST;
 299
 300     /* Send data to RTC */
 301     for (i=0; i<4; i++){
 302         ascodec_write(AS3514_RTC_0 + i, ((seconds >> (8 * i)) & 0xff));
 303     }
 304     return 1;
 305 }