[people/ms/u-boot.git] / rtc / ds1302.c

/*
 * ds1302.c - Support for the Dallas Semiconductor DS1302 Timekeeping Chip
 *
 * Rex G. Feany <rfeany@zumanetworks.com>
 *
 */

#include <common.h>
#include <command.h>
#include <rtc.h>

#if defined(CONFIG_RTC_DS1302) && (CONFIG_COMMANDS & CFG_CMD_DATE)

/* GPP Pins */
#define DATA		0x200
#define SCLK		0x400
#define RST		0x800

/* Happy Fun Defines(tm) */
#define RESET		rtc_go_low(RST), rtc_go_low(SCLK)
#define N_RESET		rtc_go_high(RST), rtc_go_low(SCLK)

#define CLOCK_HIGH	rtc_go_high(SCLK)
#define CLOCK_LOW	rtc_go_low(SCLK)

#define DATA_HIGH	rtc_go_high(DATA)
#define DATA_LOW	rtc_go_low(DATA)
#define DATA_READ	(GTREGREAD(GPP_VALUE) & DATA)

#undef RTC_DEBUG

#ifdef RTC_DEBUG
#  define DPRINTF(x,args...)	printf("ds1302: " x , ##args)
static inline void DUMP(const char *ptr, int num)
{
	while (num--) printf("%x ", *ptr++);
	printf("]\n");
}
#else
#  define DPRINTF(x,args...)
#  define DUMP(ptr, num)
#endif

/* time data format for DS1302 */
struct ds1302_st
{
	unsigned char CH:1;		/* clock halt 1=stop 0=start */
	unsigned char sec10:3;
	unsigned char sec:4;

	unsigned char zero0:1;
	unsigned char min10:3;
	unsigned char min:4;

	unsigned char fmt:1;		/* 1=12 hour 0=24 hour */
	unsigned char zero1:1;
	unsigned char hr10:2;	/* 10 (0-2) or am/pm (am/pm, 0-1) */
	unsigned char hr:4;

	unsigned char zero2:2;
	unsigned char date10:2;
	unsigned char date:4;

	unsigned char zero3:3;
	unsigned char month10:1;
	unsigned char month:4;

	unsigned char zero4:5;
	unsigned char day:3; 		/* day of week */

	unsigned char year10:4;
	unsigned char year:4;

	unsigned char WP:1;		/* write protect 1=protect 0=unprot */
	unsigned char zero5:7;
};

static int ds1302_initted=0;

/* Pin control */
static inline void
rtc_go_high(unsigned int mask)
{
	unsigned int f = GTREGREAD(GPP_VALUE) | mask;

	GT_REG_WRITE(GPP_VALUE, f);
}

static inline void
rtc_go_low(unsigned int mask)
{
	unsigned int f = GTREGREAD(GPP_VALUE) & ~mask;

	GT_REG_WRITE(GPP_VALUE, f);
}

static inline void
rtc_go_input(unsigned int mask)
{
	unsigned int f = GTREGREAD(GPP_IO_CONTROL) & ~mask;

	GT_REG_WRITE(GPP_IO_CONTROL, f);
}

static inline void
rtc_go_output(unsigned int mask)
{
	unsigned int f = GTREGREAD(GPP_IO_CONTROL) | mask;

	GT_REG_WRITE(GPP_IO_CONTROL, f);
}

/* Access data in RTC */

static void
write_byte(unsigned char b)
{
	int i;
	unsigned char mask=1;

	for(i=0;i<8;i++) {
		CLOCK_LOW;			/* Lower clock */
		(b&mask)?DATA_HIGH:DATA_LOW;	/* set data */
		udelay(1);
		CLOCK_HIGH;		/* latch data with rising clock */
		udelay(1);
		mask=mask<<1;
	}
}

static unsigned char
read_byte(void)
{
	int i;
	unsigned char mask=1;
	unsigned char b=0;

	for(i=0;i<8;i++) {
		CLOCK_LOW;
		udelay(1);
		if (DATA_READ) b|=mask;	/* if this bit is high, set in b */
		CLOCK_HIGH;		/* clock out next bit */
		udelay(1);
		mask=mask<<1;
	}
	return b;
}

static void
read_ser_drv(unsigned char addr, unsigned char *buf, int count)
{
	int i;
#ifdef RTC_DEBUG
	char *foo = buf;
#endif

	DPRINTF("READ 0x%x bytes @ 0x%x [ ", count, addr);

	addr|=1;	/* READ */
	N_RESET;
	udelay(4);
	write_byte(addr);
	rtc_go_input(DATA); /* Put gpp pin into input mode */
	udelay(1);
	for(i=0;i<count;i++) *(buf++)=read_byte();
	RESET;
	rtc_go_output(DATA);/* Reset gpp for output */
	udelay(4);

	DUMP(foo, count);
}

static void
write_ser_drv(unsigned char addr, unsigned char *buf, int count)
{
	int i;

	DPRINTF("WRITE 0x%x bytes @ 0x%x [ ", count, addr);
	DUMP(buf, count);

	addr&=~1;	/* WRITE */
	N_RESET;
	udelay(4);
	write_byte(addr);
	for(i=0;i<count;i++) write_byte(*(buf++));
	RESET;
	udelay(4);

}

void
rtc_init(void)
{
    	struct ds1302_st bbclk;
	unsigned char b;
	int mod;

	DPRINTF("init\n");

	rtc_go_output(DATA|SCLK|RST);

	/* disable write protect */
	b = 0;
	write_ser_drv(0x8e,&b,1);

	/* enable trickle */
	b = 0xa5;	/* 1010.0101 */
	write_ser_drv(0x90,&b,1);

	/* read burst */
	read_ser_drv(0xbe, (unsigned char *)&bbclk, 8);

	/* Sanity checks */
	mod = 0;
	if (bbclk.CH) {
		printf("ds1302: Clock was halted, starting clock\n");
		bbclk.CH=0;
		mod=1;
	}

	if (bbclk.fmt) {
		printf("ds1302: Clock was in 12 hour mode, fixing\n");
		bbclk.fmt=0;
		mod=1;
	}

	if (bbclk.year>9) {
		printf("ds1302: Year was corrupted, fixing\n");
		bbclk.year10=100;	/* 2000 - why not? ;) */
		bbclk.year=0;
		mod=1;
	}

	/* Write out the changes if needed */
	if (mod) {
		/* enable write protect */
		bbclk.WP = 1;
		write_ser_drv(0xbe,(unsigned char *)&bbclk,8);
	} else {
		/* Else just turn write protect on */
		b = 0x80;
		write_ser_drv(0x8e,&b,1);
	}
	DPRINTF("init done\n");

	ds1302_initted=1;
}

void
rtc_reset(void)
{
	if(!ds1302_initted) rtc_init();
	/* TODO */
}

void
rtc_get(struct rtc_time *tmp)
{
	struct ds1302_st bbclk;

	if(!ds1302_initted) rtc_init();

	read_ser_drv(0xbe,(unsigned char *)&bbclk, 8);      /* read burst */

	if (bbclk.CH) {
		printf("ds1302: rtc_get: Clock was halted, clock probably "
			"corrupt\n");
	}

	tmp->tm_sec=10*bbclk.sec10+bbclk.sec;
	tmp->tm_min=10*bbclk.min10+bbclk.min;
	tmp->tm_hour=10*bbclk.hr10+bbclk.hr;
	tmp->tm_wday=bbclk.day;
	tmp->tm_mday=10*bbclk.date10+bbclk.date;
	tmp->tm_mon=10*bbclk.month10+bbclk.month;
	tmp->tm_year=10*bbclk.year10+bbclk.year + 1900;

	tmp->tm_yday = 0;
	tmp->tm_isdst= 0;

	DPRINTF("Get DATE: %4d-%02d-%02d (wday=%d)  TIME: %2d:%02d:%02d\n",
		tmp->tm_year, tmp->tm_mon, tmp->tm_mday, tmp->tm_wday,
		tmp->tm_hour, tmp->tm_min, tmp->tm_sec );
}

void
rtc_set(struct rtc_time *tmp)
{
	struct ds1302_st bbclk;
	unsigned char b=0;

	if(!ds1302_initted) rtc_init();

	DPRINTF("Set DATE: %4d-%02d-%02d (wday=%d)  TIME: %2d:%02d:%02d\n",
		tmp->tm_year, tmp->tm_mon, tmp->tm_mday, tmp->tm_wday,
		tmp->tm_hour, tmp->tm_min, tmp->tm_sec);

	memset(&bbclk,0,sizeof(bbclk));
	bbclk.CH=0; /* dont halt */
	bbclk.WP=1; /* write protect when we're done */

	bbclk.sec10=tmp->tm_sec/10;
	bbclk.sec=tmp->tm_sec%10;

	bbclk.min10=tmp->tm_min/10;
	bbclk.min=tmp->tm_min%10;

	bbclk.hr10=tmp->tm_hour/10;
	bbclk.hr=tmp->tm_hour%10;

	bbclk.day=tmp->tm_wday;

	bbclk.date10=tmp->tm_mday/10;
	bbclk.date=tmp->tm_mday%10;

	bbclk.month10=tmp->tm_mon/10;
	bbclk.month=tmp->tm_mon%10;

	tmp->tm_year -= 1900;
	bbclk.year10=tmp->tm_year/10;
	bbclk.year=tmp->tm_year%10;

	write_ser_drv(0x8e,&b,1);           /* disable write protect */
	write_ser_drv(0xbe,(unsigned char *)&bbclk, 8);     /* write burst */
}

#endif
Commit	Line	Data
fe8c2806 WD	1	/*
	2	* ds1302.c - Support for the Dallas Semiconductor DS1302 Timekeeping Chip
	3	*
	4	* Rex G. Feany <rfeany@zumanetworks.com>
	5	*
	6	*/
	7
	8	#include <common.h>
	9	#include <command.h>
	10	#include <rtc.h>
	11
	12	#if defined(CONFIG_RTC_DS1302) && (CONFIG_COMMANDS & CFG_CMD_DATE)
	13
	14	/* GPP Pins */
	15	#define DATA 0x200
	16	#define SCLK 0x400
	17	#define RST 0x800
	18
	19	/* Happy Fun Defines(tm) */
	20	#define RESET rtc_go_low(RST), rtc_go_low(SCLK)
	21	#define N_RESET rtc_go_high(RST), rtc_go_low(SCLK)
	22
	23	#define CLOCK_HIGH rtc_go_high(SCLK)
	24	#define CLOCK_LOW rtc_go_low(SCLK)
	25
	26	#define DATA_HIGH rtc_go_high(DATA)
	27	#define DATA_LOW rtc_go_low(DATA)
	28	#define DATA_READ (GTREGREAD(GPP_VALUE) & DATA)
	29
	30	#undef RTC_DEBUG
	31
	32	#ifdef RTC_DEBUG
	33	# define DPRINTF(x,args...) printf("ds1302: " x , ##args)
	34	static inline void DUMP(const char *ptr, int num)
	35	{
	36	while (num--) printf("%x ", *ptr++);
	37	printf("]\n");
	38	}
	39	#else
	40	# define DPRINTF(x,args...)
	41	# define DUMP(ptr, num)
	42	#endif
	43
	44	/* time data format for DS1302 */
	45	struct ds1302_st
	46	{
	47	unsigned char CH:1; /* clock halt 1=stop 0=start */
	48	unsigned char sec10:3;
	49	unsigned char sec:4;
	50
	51	unsigned char zero0:1;
	52	unsigned char min10:3;
	53	unsigned char min:4;
	54
	55	unsigned char fmt:1; /* 1=12 hour 0=24 hour */
	56	unsigned char zero1:1;
	57	unsigned char hr10:2; /* 10 (0-2) or am/pm (am/pm, 0-1) */
	58	unsigned char hr:4;
	59
	60	unsigned char zero2:2;
	61	unsigned char date10:2;
	62	unsigned char date:4;
	63
	64	unsigned char zero3:3;
65	unsigned char month10:1;
66	unsigned char month:4;
67
68	unsigned char zero4:5;
69	unsigned char day:3; /* day of week */
70
71	unsigned char year10:4;
72	unsigned char year:4;
73
74	unsigned char WP:1; /* write protect 1=protect 0=unprot */
75	unsigned char zero5:7;
76	};
77
78	static int ds1302_initted=0;
79
80	/* Pin control */
81	static inline void
82	rtc_go_high(unsigned int mask)
83	{
84	unsigned int f = GTREGREAD(GPP_VALUE) \| mask;
85
86	GT_REG_WRITE(GPP_VALUE, f);
87	}
88
89	static inline void
90	rtc_go_low(unsigned int mask)
91	{
92	unsigned int f = GTREGREAD(GPP_VALUE) & ~mask;
93
94	GT_REG_WRITE(GPP_VALUE, f);
95	}
96
97	static inline void
98	rtc_go_input(unsigned int mask)
99	{
100	unsigned int f = GTREGREAD(GPP_IO_CONTROL) & ~mask;
101
102	GT_REG_WRITE(GPP_IO_CONTROL, f);
103	}
104
105	static inline void
106	rtc_go_output(unsigned int mask)
107	{
108	unsigned int f = GTREGREAD(GPP_IO_CONTROL) \| mask;
109
110	GT_REG_WRITE(GPP_IO_CONTROL, f);
111	}
112
113	/* Access data in RTC */
114
115	static void
116	write_byte(unsigned char b)
117	{
118	int i;
119	unsigned char mask=1;
120
121	for(i=0;i<8;i++) {
122	CLOCK_LOW; /* Lower clock */
123	(b&mask)?DATA_HIGH:DATA_LOW; /* set data */
124	udelay(1);
125	CLOCK_HIGH; /* latch data with rising clock */
126	udelay(1);
127	mask=mask<<1;
128	}
129	}
130
131	static unsigned char
132	read_byte(void)
133	{
134	int i;
135	unsigned char mask=1;
136	unsigned char b=0;
137
138	for(i=0;i<8;i++) {
139	CLOCK_LOW;
140	udelay(1);
141	if (DATA_READ) b\|=mask; /* if this bit is high, set in b */
142	CLOCK_HIGH; /* clock out next bit */
143	udelay(1);
144	mask=mask<<1;
145	}
146	return b;
147	}
148
149	static void
150	read_ser_drv(unsigned char addr, unsigned char *buf, int count)
151	{
152	int i;
153	#ifdef RTC_DEBUG
154	char *foo = buf;
155	#endif
156
157	DPRINTF("READ 0x%x bytes @ 0x%x [ ", count, addr);
158
159	addr\|=1; /* READ */
160	N_RESET;
161	udelay(4);
162	write_byte(addr);
163	rtc_go_input(DATA); /* Put gpp pin into input mode */
164	udelay(1);
165	for(i=0;i<count;i++) *(buf++)=read_byte();
166	RESET;
167	rtc_go_output(DATA);/* Reset gpp for output */
168	udelay(4);
169
170	DUMP(foo, count);
171	}
172
173	static void
174	write_ser_drv(unsigned char addr, unsigned char *buf, int count)
175	{
176	int i;
177
178	DPRINTF("WRITE 0x%x bytes @ 0x%x [ ", count, addr);
179	DUMP(buf, count);
180
181	addr&=~1; /* WRITE */
182	N_RESET;
183	udelay(4);
184	write_byte(addr);
185	for(i=0;i<count;i++) write_byte(*(buf++));
186	RESET;
187	udelay(4);
188
189	}
190
191	void
192	rtc_init(void)
193	{
194	struct ds1302_st bbclk;
195	unsigned char b;
196	int mod;
197
198	DPRINTF("init\n");
199
200	rtc_go_output(DATA\|SCLK\|RST);
201
202	/* disable write protect */
203	b = 0;
204	write_ser_drv(0x8e,&b,1);
205
206	/* enable trickle */
207	b = 0xa5; /* 1010.0101 */
208	write_ser_drv(0x90,&b,1);
209
210	/* read burst */
211	read_ser_drv(0xbe, (unsigned char *)&bbclk, 8);
212
213	/* Sanity checks */
214	mod = 0;
215	if (bbclk.CH) {
216	printf("ds1302: Clock was halted, starting clock\n");
217	bbclk.CH=0;
218	mod=1;
219	}
220
221	if (bbclk.fmt) {
222	printf("ds1302: Clock was in 12 hour mode, fixing\n");
223	bbclk.fmt=0;
224	mod=1;
225	}
226
227	if (bbclk.year>9) {
228	printf("ds1302: Year was corrupted, fixing\n");
229	bbclk.year10=100; /* 2000 - why not? ;) */
230	bbclk.year=0;
231	mod=1;
232	}
233
234	/* Write out the changes if needed */
235	if (mod) {
236	/* enable write protect */
237	bbclk.WP = 1;
238	write_ser_drv(0xbe,(unsigned char *)&bbclk,8);
239	} else {
240	/* Else just turn write protect on */
241	b = 0x80;
242	write_ser_drv(0x8e,&b,1);
243	}
244	DPRINTF("init done\n");
245
246	ds1302_initted=1;
247	}
248
249	void
250	rtc_reset(void)
251	{
252	if(!ds1302_initted) rtc_init();
253	/* TODO */
254	}
255
256	void
257	rtc_get(struct rtc_time *tmp)
258	{
259	struct ds1302_st bbclk;
260
261	if(!ds1302_initted) rtc_init();
262
263	read_ser_drv(0xbe,(unsigned char )&bbclk, 8); / read burst */
264
265	if (bbclk.CH) {
266	printf("ds1302: rtc_get: Clock was halted, clock probably "
267	"corrupt\n");
268	}
269
270	tmp->tm_sec=10*bbclk.sec10+bbclk.sec;
271	tmp->tm_min=10*bbclk.min10+bbclk.min;
272	tmp->tm_hour=10*bbclk.hr10+bbclk.hr;
273	tmp->tm_wday=bbclk.day;
274	tmp->tm_mday=10*bbclk.date10+bbclk.date;
275	tmp->tm_mon=10*bbclk.month10+bbclk.month;
276	tmp->tm_year=10*bbclk.year10+bbclk.year + 1900;
277
278	tmp->tm_yday = 0;
279	tmp->tm_isdst= 0;
280
281	DPRINTF("Get DATE: %4d-%02d-%02d (wday=%d) TIME: %2d:%02d:%02d\n",
282	tmp->tm_year, tmp->tm_mon, tmp->tm_mday, tmp->tm_wday,
283	tmp->tm_hour, tmp->tm_min, tmp->tm_sec );
284	}
285
286	void
287	rtc_set(struct rtc_time *tmp)
288	{
289	struct ds1302_st bbclk;
290	unsigned char b=0;
291
292	if(!ds1302_initted) rtc_init();
293
294	DPRINTF("Set DATE: %4d-%02d-%02d (wday=%d) TIME: %2d:%02d:%02d\n",
295	tmp->tm_year, tmp->tm_mon, tmp->tm_mday, tmp->tm_wday,
296	tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
297
298	memset(&bbclk,0,sizeof(bbclk));
299	bbclk.CH=0; /* dont halt */
300	bbclk.WP=1; /* write protect when we're done */
301
302	bbclk.sec10=tmp->tm_sec/10;
303	bbclk.sec=tmp->tm_sec%10;
304
305	bbclk.min10=tmp->tm_min/10;
306	bbclk.min=tmp->tm_min%10;
307
308	bbclk.hr10=tmp->tm_hour/10;
309	bbclk.hr=tmp->tm_hour%10;
310
311	bbclk.day=tmp->tm_wday;
312
313	bbclk.date10=tmp->tm_mday/10;
314	bbclk.date=tmp->tm_mday%10;
315
316	bbclk.month10=tmp->tm_mon/10;
317	bbclk.month=tmp->tm_mon%10;
318
319	tmp->tm_year -= 1900;
320	bbclk.year10=tmp->tm_year/10;
321	bbclk.year=tmp->tm_year%10;
322
323	write_ser_drv(0x8e,&b,1); /* disable write protect */
324	write_ser_drv(0xbe,(unsigned char )&bbclk, 8); / write burst */
325	}
326
327	#endif