[BACK]Return to getsecs.c CVS log [TXT][DIR] Up to [local] / sys / arch / landisk / stand / boot

Annotation of sys/arch/landisk/stand/boot/getsecs.c, Revision 1.1.1.1

1.1       nbrk        1: /*     $NetBSD: getsecs.c,v 1.2 2006/09/11 13:48:57 nonaka Exp $       */
                      2:
                      3: #include <sys/param.h>
                      4:
                      5: #include <netinet/in.h>
                      6: #include <netinet/in_systm.h>
                      7:
                      8: #include <lib/libsa/stand.h>
                      9: #include <lib/libsa/net.h>
                     10: #include <lib/libsa/netif.h>
                     11:
                     12: #include <sh/devreg.h>
                     13: #include <arch/sh/dev/scireg.h>
                     14:
                     15: #include <arch/landisk/dev/rs5c313reg.h>
                     16:
                     17: /**
                     18:  * RICOH RS5C313
                     19:  *
                     20:  * Web page: http://www.ricoh.co.jp/LSI/product_rtc/3wire/5c313/
                     21:  *
                     22:  * How to control RS5C313 on LANDISK
                     23:  *   see http://www.mizore.jp/wiki/index.php?LANDISK/rtc
                     24:  */
                     25:
                     26: uint8_t rtc_read(uint32_t addr);
                     27: void rtc_write(uint32_t addr, uint8_t data);
                     28:
                     29: static void
                     30: rtc_init(void)
                     31: {
                     32:
                     33:        SHREG_SCSPTR = SCSPTR_SPB1IO | SCSPTR_SPB1DT
                     34:                       | SCSPTR_SPB0IO | SCSPTR_SPB0DT;
                     35:        delay(1);
                     36: }
                     37:
                     38: /* control RTC chip enable */
                     39: static void
                     40: rtc_ce(int onoff)
                     41: {
                     42:
                     43:        if (onoff) {
                     44:                _reg_write_1(0xb0000003, (1 << 1));
                     45:        } else {
                     46:                _reg_write_1(0xb0000003, (0 << 1));
                     47:        }
                     48:        delay(1);
                     49: }
                     50:
                     51: static inline void
                     52: rtc_clk(int onoff)
                     53: {
                     54:
                     55:        if (onoff) {
                     56:                SHREG_SCSPTR |= SCSPTR_SPB0DT;
                     57:        } else {
                     58:                SHREG_SCSPTR &= ~SCSPTR_SPB0DT;
                     59:        }
                     60:        delay(1);
                     61: }
                     62:
                     63: static void
                     64: rtc_dir(int output)
                     65: {
                     66:
                     67:        if (output) {
                     68:                SHREG_SCSPTR |= SCSPTR_SPB1IO;
                     69:        } else {
                     70:                SHREG_SCSPTR &= ~SCSPTR_SPB1IO;
                     71:        }
                     72:        delay(1);
                     73: }
                     74:
                     75: /* data-out */
                     76: static void
                     77: rtc_do(int onoff)
                     78: {
                     79:
                     80:        if (onoff) {
                     81:                SHREG_SCSPTR |= SCSPTR_SPB1DT;
                     82:        } else {
                     83:                SHREG_SCSPTR &= ~SCSPTR_SPB1DT;
                     84:        }
                     85:        delay(1);
                     86:
                     87:        rtc_clk(0);
                     88:        rtc_clk(1);
                     89: }
                     90:
                     91: /* data-in */
                     92: static int
                     93: rtc_di(void)
                     94: {
                     95:        int d;
                     96:
                     97:        d = (SHREG_SCSPTR & SCSPTR_SPB1DT) ? 1 : 0;
                     98:
                     99:        rtc_clk(0);
                    100:        rtc_clk(1);
                    101:
                    102:        return d;
                    103: }
                    104:
                    105: uint8_t
                    106: rtc_read(uint32_t addr)
                    107: {
                    108:        uint8_t data;
                    109:
                    110:        rtc_init();
                    111:        rtc_ce(1);
                    112:
                    113:        rtc_dir(1);
                    114:        rtc_do(1);              /* Don't care */
                    115:        rtc_do(1);              /* R/#W = 1(READ) */
                    116:        rtc_do(1);              /* AD = 1 */
                    117:        rtc_do(0);              /* DT = 0 */
                    118:        rtc_do(addr & 0x8);     /* A3 */
                    119:        rtc_do(addr & 0x4);     /* A2 */
                    120:        rtc_do(addr & 0x2);     /* A1 */
                    121:        rtc_do(addr & 0x1);     /* A0 */
                    122:
                    123:        rtc_dir(0);
                    124:        (void)rtc_di();
                    125:        (void)rtc_di();
                    126:        (void)rtc_di();
                    127:        (void)rtc_di();
                    128:        data = rtc_di();        /* D3 */
                    129:        data <<= 1;
                    130:        data |= rtc_di();       /* D2 */
                    131:        data <<= 1;
                    132:        data |= rtc_di();       /* D1 */
                    133:        data <<= 1;
                    134:        data |= rtc_di();       /* D0 */
                    135:
                    136:        rtc_ce(0);
                    137:
                    138:        return data & 0xf;
                    139: }
                    140:
                    141: void
                    142: rtc_write(uint32_t addr, uint8_t data)
                    143: {
                    144:
                    145:        rtc_init();
                    146:        rtc_ce(1);
                    147:
                    148:        rtc_dir(1);
                    149:        rtc_do(1);              /* Don't care */
                    150:        rtc_do(0);              /* R/#W = 0(WRITE) */
                    151:        rtc_do(1);              /* AD = 1 */
                    152:        rtc_do(0);              /* DT = 0 */
                    153:        rtc_do(addr & 0x8);     /* A3 */
                    154:        rtc_do(addr & 0x4);     /* A2 */
                    155:        rtc_do(addr & 0x2);     /* A1 */
                    156:        rtc_do(addr & 0x1);     /* A0 */
                    157:
                    158:        rtc_do(1);              /* Don't care */
                    159:        rtc_do(0);              /* R/#W = 0(WRITE) */
                    160:        rtc_do(0);              /* AD = 0 */
                    161:        rtc_do(1);              /* DT = 1 */
                    162:        rtc_do(data & 0x8);     /* D3 */
                    163:        rtc_do(data & 0x4);     /* D2 */
                    164:        rtc_do(data & 0x2);     /* D1 */
                    165:        rtc_do(data & 0x1);     /* D0 */
                    166:
                    167:        rtc_ce(0);
                    168: }
                    169:
                    170: time_t
                    171: getsecs(void)
                    172: {
                    173:        uint32_t sec, min, hour, day;
                    174: #if 0
                    175:        uint32_t mon, year;
                    176: #endif
                    177:        time_t secs;
                    178:
                    179:        sec = rtc_read(RS5C313_SEC1);
                    180:        sec += rtc_read(RS5C313_SEC10) * 10;
                    181:        min = rtc_read(RS5C313_MIN1);
                    182:        min += rtc_read(RS5C313_MIN10) * 10;
                    183:        hour = rtc_read(RS5C313_HOUR1);
                    184:        hour += rtc_read(RS5C313_HOUR10) * 10;
                    185:        day = rtc_read(RS5C313_DAY1);
                    186:        day += rtc_read(RS5C313_DAY10) * 10;
                    187: #if 0
                    188:        mon = rtc_read(RS5C313_MON1);
                    189:        mon += rtc_read(RS5C313_MON10) * 10;
                    190:        year = rtc_read(RS5C313_YEAR1);
                    191:        year += rtc_read(RS5C313_YEAR10) * 10;
                    192: #endif
                    193:
                    194:        secs = sec;
                    195:        secs += min * 60;
                    196:        secs += hour * 60 * 60;
                    197:        secs += day * 60 * 60 * 24;
                    198: #if 0
                    199:        /* XXX mon, year */
                    200: #endif
                    201:
                    202: #if defined(DEBUG)
                    203:        printf("getsecs: secs = %d\n", (uint32_t)secs);
                    204: #endif
                    205:
                    206:        return secs;
                    207: }

CVSweb