1 /****************************************************************************/
3 * linux/arch/sh/boards/snapgear/rtc.c -- Secureedge5410 RTC code
5 * Copyright (C) 2002 David McCullough <davidm@snapgear.com>
6 * Copyright (C) 2003 Paul Mundt <lethal@linux-sh.org>
8 * The SecureEdge5410 can have one of 2 real time clocks, the SH
9 * built in version or the preferred external DS1302. Here we work out
10 * each to see what we have and then run with it.
12 /****************************************************************************/
14 #include <linux/init.h>
15 #include <linux/kernel.h>
16 #include <linux/sched.h>
17 #include <linux/time.h>
18 #include <linux/rtc.h>
19 #include <linux/mc146818rtc.h>
21 #include <asm/snapgear.h>
23 static int use_ds1302
;
25 /****************************************************************************/
27 * we need to implement a DS1302 driver here that can operate in
28 * conjunction with the builtin rtc driver which is already quite friendly
30 /*****************************************************************************/
32 #define RTC_CMD_READ 0x81 /* Read command */
33 #define RTC_CMD_WRITE 0x80 /* Write command */
35 #define RTC_ADDR_YEAR 0x06 /* Address of year register */
36 #define RTC_ADDR_DAY 0x05 /* Address of day of week register */
37 #define RTC_ADDR_MON 0x04 /* Address of month register */
38 #define RTC_ADDR_DATE 0x03 /* Address of day of month register */
39 #define RTC_ADDR_HOUR 0x02 /* Address of hour register */
40 #define RTC_ADDR_MIN 0x01 /* Address of minute register */
41 #define RTC_ADDR_SEC 0x00 /* Address of second register */
43 #define RTC_RESET 0x1000
44 #define RTC_IODATA 0x0800
45 #define RTC_SCLK 0x0400
49 #define set_dp(x) SECUREEDGE_WRITE_IOPORT(x, 0x1c00)
50 #define get_dp(x) SECUREEDGE_READ_IOPORT()
52 static void ds1302_sendbits(unsigned int val
)
56 for (i
= 8; (i
); i
--, val
>>= 1) {
57 set_dp((get_dp() & ~RTC_IODATA
) | ((val
& 0x1) ? RTC_IODATA
: 0));
58 set_dp(get_dp() | RTC_SCLK
); // clock high
59 set_dp(get_dp() & ~RTC_SCLK
); // clock low
63 static unsigned int ds1302_recvbits(void)
68 for (i
= 0, val
= 0; (i
< 8); i
++) {
69 val
|= (((get_dp() & RTC_IODATA
) ? 1 : 0) << i
);
70 set_dp(get_dp() | RTC_SCLK
); // clock high
71 set_dp(get_dp() & ~RTC_SCLK
); // clock low
76 static unsigned int ds1302_readbyte(unsigned int addr
)
81 local_irq_save(flags
);
82 set_dirp(get_dirp() | RTC_RESET
| RTC_IODATA
| RTC_SCLK
);
83 set_dp(get_dp() & ~(RTC_RESET
| RTC_IODATA
| RTC_SCLK
));
85 set_dp(get_dp() | RTC_RESET
);
86 ds1302_sendbits(((addr
& 0x3f) << 1) | RTC_CMD_READ
);
87 set_dirp(get_dirp() & ~RTC_IODATA
);
88 val
= ds1302_recvbits();
89 set_dp(get_dp() & ~RTC_RESET
);
90 local_irq_restore(flags
);
95 static void ds1302_writebyte(unsigned int addr
, unsigned int val
)
99 local_irq_save(flags
);
100 set_dirp(get_dirp() | RTC_RESET
| RTC_IODATA
| RTC_SCLK
);
101 set_dp(get_dp() & ~(RTC_RESET
| RTC_IODATA
| RTC_SCLK
));
102 set_dp(get_dp() | RTC_RESET
);
103 ds1302_sendbits(((addr
& 0x3f) << 1) | RTC_CMD_WRITE
);
104 ds1302_sendbits(val
);
105 set_dp(get_dp() & ~RTC_RESET
);
106 local_irq_restore(flags
);
109 static void ds1302_reset(void)
112 /* Hardware dependant reset/init */
113 local_irq_save(flags
);
114 set_dirp(get_dirp() | RTC_RESET
| RTC_IODATA
| RTC_SCLK
);
115 set_dp(get_dp() & ~(RTC_RESET
| RTC_IODATA
| RTC_SCLK
));
116 local_irq_restore(flags
);
119 /*****************************************************************************/
121 static inline int bcd2int(int val
)
123 return((((val
& 0xf0) >> 4) * 10) + (val
& 0xf));
126 static inline int int2bcd(int val
)
128 return(((val
/ 10) << 4) + (val
% 10));
131 /*****************************************************************************/
133 * Write and Read some RAM in the DS1302, if it works assume it's there
134 * Otherwise use the SH4 internal RTC
137 void snapgear_rtc_gettimeofday(struct timespec
*);
138 int snapgear_rtc_settimeofday(const time_t);
140 void __init
secureedge5410_rtc_init(void)
142 unsigned char *test
= "snapgear";
149 for (i
= 0; test
[i
]; i
++)
150 ds1302_writebyte(32 + i
, test
[i
]);
152 for (i
= 0; test
[i
]; i
++)
153 if (ds1302_readbyte(32 + i
) != test
[i
]) {
159 rtc_sh_get_time
= snapgear_rtc_gettimeofday
;
160 rtc_sh_set_time
= snapgear_rtc_settimeofday
;
163 printk("SnapGear RTC: using %s rtc.\n", use_ds1302
? "ds1302" : "internal");
166 /****************************************************************************/
168 * our generic interface that chooses the correct code to use
171 void snapgear_rtc_gettimeofday(struct timespec
*ts
)
173 unsigned int sec
, min
, hr
, day
, mon
, yr
;
178 sec
= bcd2int(ds1302_readbyte(RTC_ADDR_SEC
));
179 min
= bcd2int(ds1302_readbyte(RTC_ADDR_MIN
));
180 hr
= bcd2int(ds1302_readbyte(RTC_ADDR_HOUR
));
181 day
= bcd2int(ds1302_readbyte(RTC_ADDR_DATE
));
182 mon
= bcd2int(ds1302_readbyte(RTC_ADDR_MON
));
183 yr
= bcd2int(ds1302_readbyte(RTC_ADDR_YEAR
));
186 if (yr
> 99 || mon
< 1 || mon
> 12 || day
> 31 || day
< 1 ||
187 hr
> 23 || min
> 59 || sec
> 59) {
189 "SnapGear RTC: invalid value, resetting to 1 Jan 2000\n");
190 ds1302_writebyte(RTC_ADDR_MIN
, min
= 0);
191 ds1302_writebyte(RTC_ADDR_HOUR
, hr
= 0);
192 ds1302_writebyte(RTC_ADDR_DAY
, 7);
193 ds1302_writebyte(RTC_ADDR_DATE
, day
= 1);
194 ds1302_writebyte(RTC_ADDR_MON
, mon
= 1);
195 ds1302_writebyte(RTC_ADDR_YEAR
, yr
= 0);
196 ds1302_writebyte(RTC_ADDR_SEC
, sec
= 0);
199 ts
->tv_sec
= mktime(2000 + yr
, mon
, day
, hr
, min
, sec
);
200 if (ts
->tv_sec
< 0) {
202 printk("BAD TIME %d %d %d %d %d %d\n", yr
, mon
, day
, hr
, min
, sec
);
210 int snapgear_rtc_settimeofday(const time_t secs
)
213 int real_seconds
, real_minutes
, cmos_minutes
;
214 unsigned long nowtime
;
220 * This is called direct from the kernel timer handling code.
221 * It is supposed to synchronize the kernel clock to the RTC.
227 ds1302_writebyte(RTC_ADDR_SEC
, ds1302_readbyte(RTC_ADDR_SEC
) | 0x80);
229 cmos_minutes
= bcd2int(ds1302_readbyte(RTC_ADDR_MIN
));
232 * since we're only adjusting minutes and seconds,
233 * don't interfere with hour overflow. This avoids
234 * messing with unknown time zones but requires your
235 * RTC not to be off by more than 15 minutes
237 real_seconds
= nowtime
% 60;
238 real_minutes
= nowtime
/ 60;
239 if (((abs(real_minutes
- cmos_minutes
) + 15)/30) & 1)
240 real_minutes
+= 30; /* correct for half hour time zone */
243 if (abs(real_minutes
- cmos_minutes
) < 30) {
244 ds1302_writebyte(RTC_ADDR_MIN
, int2bcd(real_minutes
));
245 ds1302_writebyte(RTC_ADDR_SEC
, int2bcd(real_seconds
));
248 "SnapGear RTC: can't update from %d to %d\n",
249 cmos_minutes
, real_minutes
);
254 ds1302_writebyte(RTC_ADDR_SEC
, ds1302_readbyte(RTC_ADDR_SEC
) & ~0x80);
258 unsigned char secureedge5410_cmos_read(int addr
)
260 unsigned char val
= 0;
263 return(__CMOS_READ(addr
, w
));
266 case RTC_SECONDS
: val
= ds1302_readbyte(RTC_ADDR_SEC
); break;
267 case RTC_SECONDS_ALARM
: break;
268 case RTC_MINUTES
: val
= ds1302_readbyte(RTC_ADDR_MIN
); break;
269 case RTC_MINUTES_ALARM
: break;
270 case RTC_HOURS
: val
= ds1302_readbyte(RTC_ADDR_HOUR
); break;
271 case RTC_HOURS_ALARM
: break;
272 case RTC_DAY_OF_WEEK
: val
= ds1302_readbyte(RTC_ADDR_DAY
); break;
273 case RTC_DAY_OF_MONTH
: val
= ds1302_readbyte(RTC_ADDR_DATE
); break;
274 case RTC_MONTH
: val
= ds1302_readbyte(RTC_ADDR_MON
); break;
275 case RTC_YEAR
: val
= ds1302_readbyte(RTC_ADDR_YEAR
); break;
276 case RTC_REG_A
: /* RTC_FREQ_SELECT */ break;
277 case RTC_REG_B
: /* RTC_CONTROL */ break;
278 case RTC_REG_C
: /* RTC_INTR_FLAGS */ break;
279 case RTC_REG_D
: val
= RTC_VRT
/* RTC_VALID */; break;
286 void secureedge5410_cmos_write(unsigned char val
, int addr
)
289 __CMOS_WRITE(val
, addr
, w
);
294 case RTC_SECONDS
: ds1302_writebyte(RTC_ADDR_SEC
, val
); break;
295 case RTC_SECONDS_ALARM
: break;
296 case RTC_MINUTES
: ds1302_writebyte(RTC_ADDR_MIN
, val
); break;
297 case RTC_MINUTES_ALARM
: break;
298 case RTC_HOURS
: ds1302_writebyte(RTC_ADDR_HOUR
, val
); break;
299 case RTC_HOURS_ALARM
: break;
300 case RTC_DAY_OF_WEEK
: ds1302_writebyte(RTC_ADDR_DAY
, val
); break;
301 case RTC_DAY_OF_MONTH
: ds1302_writebyte(RTC_ADDR_DATE
, val
); break;
302 case RTC_MONTH
: ds1302_writebyte(RTC_ADDR_MON
, val
); break;
303 case RTC_YEAR
: ds1302_writebyte(RTC_ADDR_YEAR
, val
); break;
304 case RTC_REG_A
: /* RTC_FREQ_SELECT */ break;
305 case RTC_REG_B
: /* RTC_CONTROL */ break;
306 case RTC_REG_C
: /* RTC_INTR_FLAGS */ break;
307 case RTC_REG_D
: /* RTC_VALID */ break;