1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
|
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2008 by Maurus Cuelenaere
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
/*
* Jz OnChip Real Time Clock interface for Linux
*
*/
#include "config.h"
#include "jz4740.h"
#include "rtc.h"
#include "timefuncs.h"
#include "logf.h"
static const unsigned int yearday[5] = {0, 366, 366+365, 366+365*2, 366+365*3};
static const unsigned int sweekday = 6;
static const unsigned int sum_monthday[13] = {
0,
31,
31+28,
31+28+31,
31+28+31+30,
31+28+31+30+31,
31+28+31+30+31+30,
31+28+31+30+31+30+31,
31+28+31+30+31+30+31+31,
31+28+31+30+31+30+31+31+30,
31+28+31+30+31+30+31+31+30+31,
31+28+31+30+31+30+31+31+30+31+30,
365
};
static unsigned int jz_mktime(int year, int mon, int day, int hour, int min,
int sec)
{
unsigned int seccounter;
if (year < 2000)
year = 2000;
year -= 2000;
seccounter = (year/4)*(365*3+366);
seccounter += yearday[year%4];
if (year%4)
seccounter += sum_monthday[mon-1];
else
if (mon >= 3)
seccounter += sum_monthday[mon-1]+1;
else
seccounter += sum_monthday[mon-1];
seccounter += day-1;
seccounter *= 24;
seccounter += hour;
seccounter *= 60;
seccounter += min;
seccounter *= 60;
seccounter += sec;
return seccounter;
}
static void jz_gettime(unsigned int rtc, int *year, int *mon, int *day,
int *hour, int *min, int *sec, int *weekday)
{
unsigned int tday, tsec, i, tmp;
tday = rtc/(24*3600);
*weekday = ((tday % 7) + sweekday) % 7;
*year = (tday/(366+365*3)) * 4;
tday = tday%(366+365*3);
for (i=0;i<5;i++)
{
if (tday<yearday[i])
{
*year += i-1;
tday -= yearday[i-1];
break;
}
}
for (i=0;i<13;i++)
{
tmp = sum_monthday[i];
if (((*year%4) == 0) && (i>=2))
tmp += 1;
if (tday<tmp)
{
*mon = i;
tmp = sum_monthday[i-1];
if (((*year%4) == 0) && ((i-1)>=2))
tmp += 1;
*day = tday - tmp + 1;
break;
}
}
tsec = rtc % (24 * 3600);
*hour = tsec / 3600;
*min = (tsec / 60) % 60;
*sec = tsec - *hour*3600 - *min*60;
*year += 2000;
}
int rtc_read_datetime(unsigned char* buf)
{
struct tm rtc_tm;
unsigned int sec,mon,mday,wday,year,hour,min;
/*
* Only the values that we read from the RTC are set. We leave
* tm_wday, tm_yday and tm_isdst untouched. Even though the
* RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated
* by the RTC when initially set to a non-zero value.
*/
jz_gettime(REG_RTC_RSR, &year, &mon, &mday, &hour, &min, &sec, &wday);
year -= 2000;
rtc_tm.tm_sec = sec;
rtc_tm.tm_min = min;
rtc_tm.tm_hour = hour;
rtc_tm.tm_mday = mday;
rtc_tm.tm_wday = wday;
/* Don't use centry, but start from year 1970 */
rtc_tm.tm_mon = mon;
if (year <= 69)
year += 100;
rtc_tm.tm_year = year;
rtc_tm.tm_yday = 0; /* Not implemented for now */
rtc_tm.tm_isdst = -1; /* Not implemented for now */
(*((struct tm*)buf)) = rtc_tm;
return 1;
}
int rtc_write_datetime(unsigned char* buf)
{
struct tm *rtc_tm = (struct tm*)buf;
unsigned int year, lval;
year = rtc_tm->tm_year;
/* Don't use centry, but start from year 1970 */
if (year > 69)
year -= 100;
year += 2000;
lval = jz_mktime(year, rtc_tm->tm_mon, rtc_tm->tm_mday, rtc_tm->tm_hour,
rtc_tm->tm_min, rtc_tm->tm_sec);
__cpm_start_rtc();
udelay(100);
REG_RTC_RSR = lval;
__cpm_stop_rtc();
return 0;
}
#if 0
void get_rtc_alm_time(struct rtc_time *alm_tm)
{
unsigned int sec,mon,mday,wday,year,hour,min;
unsigned int lval;
unsigned long flags;
/*
* Only the values that we read from the RTC are set. That
* means only tm_hour, tm_min, and tm_sec.
*/
lval = REG_RTC_RSAR;
jz_gettime(lval, &year, &mon, &mday, &hour, &min, &sec, &wday);
alm_tm->tm_sec = sec;
alm_tm->tm_min = min;
alm_tm->tm_hour = hour;
}
int rtc_ioctl(unsigned int cmd,struct rtc_time *val,unsigned int epo)
{
struct rtc_time wtime;
switch (cmd) {
case RTC_ALM_READ: /* Read the present alarm time */
/*
* This returns a struct rtc_time. Reading >= 0xc0
* means "don't care" or "match all". Only the tm_hour,
* tm_min, and tm_sec values are filled in.
*/
get_rtc_alm_time(val);
break;
case RTC_ALM_SET: /* Store a time into the alarm */
{
unsigned char ahrs, amin, asec;
unsigned int sec,mon,mday,wday,year,hour,min;
unsigned int lval;
unsigned long flags;
struct rtc_time alm_tm;
alm_tm = *val;
ahrs = alm_tm.tm_hour;
amin = alm_tm.tm_min;
asec = alm_tm.tm_sec;
if (ahrs >= 24)
return -1;
if (amin >= 60)
return -1;
if (asec >= 60)
return -1;
flags = spin_lock_irqsave();
lval = REG_RTC_RSR;
jz_gettime(lval, &year, &mon, &mday, &hour, &min, &sec, &wday);
hour = ahrs;
min = amin;
sec = asec;
lval = jz_mktime(year, mon, mday, hour, min, sec);
REG_RTC_RSAR = lval;
spin_unlock_irqrestore(flags);
break;
}
case RTC_RD_TIME: /* Read the time/date from RTC */
get_rtc_time(val);
break;
case RTC_SET_TIME: /* Set the RTC */
{
struct rtc_time rtc_tm;
unsigned int mon, day, hrs, min, sec, leap_yr, date;
unsigned int yrs;
unsigned int lval;
unsigned long flags;
rtc_tm = *val;
yrs = rtc_tm.tm_year;// + 1900;
mon = rtc_tm.tm_mon + 1; /* tm_mon starts at zero */
day = rtc_tm.tm_wday;
date = rtc_tm.tm_mday;
hrs = rtc_tm.tm_hour;
min = rtc_tm.tm_min;
sec = rtc_tm.tm_sec;
if (yrs < 1970)
return -EINVAL;
leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
if ((mon > 12) || (date == 0))
return -EINVAL;
if (date > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
return -EINVAL;
if ((hrs >= 24) || (min >= 60) || (sec >= 60))
return -EINVAL;
if ((yrs -= epoch) > 255) /* They are unsigned */
return -EINVAL;
flags = spin_lock_irqsave();
/* These limits and adjustments are independant of
* whether the chip is in binary mode or not.
*/
if (yrs > 169) {
spin_unlock_irqrestore(flags);
return -EINVAL;
}
yrs += epoch;
lval = jz_mktime(yrs, mon, date, hrs, min, sec);
REG_RTC_RSR = lval;
/* FIXME: maybe we need to write alarm register here. */
spin_unlock_irqrestore(flags);
return 0;
}
break;
case RTC_EPOCH_READ: /* Read the epoch. */
epo = epoch;
return 0;
case RTC_EPOCH_SET: /* Set the epoch. */
/*
* There were no RTC clocks before 1900.
*/
if (epo < 1900)
return -EINVAL;
epoch = epo;
return 0;
default:
return -EINVAL;
}
return -EINVAL;
}
#endif
void rtc_init(void)
{
__cpm_start_rtc();
REG_RTC_RCR = RTC_RCR_RTCE;
udelay(70);
while( !(REG_RTC_RCR & RTC_RCR_WRDY) );
REG_RTC_RGR = (0x7fff | RTC_RGR_LOCK);
udelay(70);
__cpm_stop_rtc();
}
|
