[people/ms/u-boot.git] / board / etin / debris / phantom.c

/*
 * board/eva/phantom.c
 *
 * Phantom RTC device driver for EVA
 *
 * Author: Sangmoon Kim
 *         dogoil@etinsys.com
 *
 * Copyright 2002 Etinsys Inc.
 *
 * 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.
 */

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

#if defined(CONFIG_CMD_DATE)

#define RTC_BASE (CFG_NVRAM_BASE_ADDR + 0x7fff8)

#define RTC_YEAR                ( RTC_BASE + 7 )
#define RTC_MONTH               ( RTC_BASE + 6 )
#define RTC_DAY_OF_MONTH        ( RTC_BASE + 5 )
#define RTC_DAY_OF_WEEK         ( RTC_BASE + 4 )
#define RTC_HOURS               ( RTC_BASE + 3 )
#define RTC_MINUTES             ( RTC_BASE + 2 )
#define RTC_SECONDS             ( RTC_BASE + 1 )
#define RTC_CENTURY             ( RTC_BASE + 0 )

#define RTC_CONTROLA            RTC_CENTURY
#define RTC_CONTROLB            RTC_SECONDS
#define RTC_CONTROLC            RTC_DAY_OF_WEEK

#define RTC_CA_WRITE            0x80
#define RTC_CA_READ             0x40

#define RTC_CB_OSC_DISABLE      0x80

#define RTC_CC_BATTERY_FLAG     0x80
#define RTC_CC_FREQ_TEST        0x40


static int phantom_flag = -1;
static int century_flag = -1;

static uchar rtc_read(unsigned int addr)
{
	return *(volatile unsigned char *)(addr);
}

static void rtc_write(unsigned int addr, uchar val)
{
	*(volatile unsigned char *)(addr) = val;
}

static unsigned char phantom_rtc_sequence[] = {
	0xc5, 0x3a, 0xa3, 0x5c, 0xc5, 0x3a, 0xa3, 0x5c
};

static unsigned char* phantom_rtc_read(int addr, unsigned char rtc[8])
{
	int i, j;
	unsigned char v;
	unsigned char save = rtc_read(addr);

	for (j = 0; j < 8; j++) {
		v = phantom_rtc_sequence[j];
		for (i = 0; i < 8; i++) {
			rtc_write(addr, v & 1);
			v >>= 1;
		}
	}
	for (j = 0; j < 8; j++) {
		v = 0;
		for (i = 0; i < 8; i++) {
			if(rtc_read(addr) & 1)
				v |= 1 << i;
		}
		rtc[j] = v;
	}
	rtc_write(addr, save);
	return rtc;
}

static void phantom_rtc_write(int addr, unsigned char rtc[8])
{
	int i, j;
	unsigned char v;
	unsigned char save = rtc_read(addr);
	for (j = 0; j < 8; j++) {
		v = phantom_rtc_sequence[j];
		for (i = 0; i < 8; i++) {
			rtc_write(addr, v & 1);
			v >>= 1;
		}
	}
	for (j = 0; j < 8; j++) {
		v = rtc[j];
		for (i = 0; i < 8; i++) {
			rtc_write(addr, v & 1);
			v >>= 1;
		}
	}
	rtc_write(addr, save);
}

static int get_phantom_flag(void)
{
	int i;
	unsigned char rtc[8];

	phantom_rtc_read(RTC_BASE, rtc);

	for(i = 1; i < 8; i++) {
		if (rtc[i] != rtc[0])
			return 1;
	}
	return 0;
}

void rtc_reset(void)
{
	if (phantom_flag < 0)
		phantom_flag = get_phantom_flag();

	if (phantom_flag) {
		unsigned char rtc[8];
		phantom_rtc_read(RTC_BASE, rtc);
		if(rtc[4] & 0x30) {
			printf( "real-time-clock was stopped. Now starting...\n" );
			rtc[4] &= 0x07;
			phantom_rtc_write(RTC_BASE, rtc);
		}
	} else {
		uchar reg_a, reg_b, reg_c;
		reg_a = rtc_read( RTC_CONTROLA );
		reg_b = rtc_read( RTC_CONTROLB );

		if ( reg_b & RTC_CB_OSC_DISABLE )
		{
			printf( "real-time-clock was stopped. Now starting...\n" );
			reg_a |= RTC_CA_WRITE;
			reg_b &= ~RTC_CB_OSC_DISABLE;
			rtc_write( RTC_CONTROLA, reg_a );
			rtc_write( RTC_CONTROLB, reg_b );
		}

		/* make sure read/write clock register bits are cleared */
		reg_a &= ~( RTC_CA_WRITE | RTC_CA_READ );
		rtc_write( RTC_CONTROLA, reg_a );

		reg_c = rtc_read( RTC_CONTROLC );
		if (( reg_c & RTC_CC_BATTERY_FLAG ) == 0 )
			printf( "RTC battery low. Clock setting may not be reliable.\n");
	}
}

inline unsigned bcd2bin (uchar n)
{
	return ((((n >> 4) & 0x0F) * 10) + (n & 0x0F));
}

inline unsigned char bin2bcd (unsigned int n)
{
	return (((n / 10) << 4) | (n % 10));
}

static int get_century_flag(void)
{
	int flag = 0;
	int bcd, century;
	bcd = rtc_read( RTC_CENTURY );
	century = bcd2bin( bcd & 0x3F );
	rtc_write( RTC_CENTURY, bin2bcd(century+1));
	if (bcd == rtc_read( RTC_CENTURY ))
		flag = 1;
	rtc_write( RTC_CENTURY, bcd);
	return flag;
}

int rtc_get( struct rtc_time *tmp)
{
	if (phantom_flag < 0)
		phantom_flag = get_phantom_flag();

	if (phantom_flag)
	{
		unsigned char rtc[8];

		phantom_rtc_read(RTC_BASE, rtc);

		tmp->tm_sec	= bcd2bin(rtc[1] & 0x7f);
		tmp->tm_min	= bcd2bin(rtc[2] & 0x7f);
		tmp->tm_hour	= bcd2bin(rtc[3] & 0x1f);
		tmp->tm_wday	= bcd2bin(rtc[4] & 0x7);
		tmp->tm_mday	= bcd2bin(rtc[5] & 0x3f);
		tmp->tm_mon	= bcd2bin(rtc[6] & 0x1f);
		tmp->tm_year	= bcd2bin(rtc[7]) + 1900;
		tmp->tm_yday = 0;
		tmp->tm_isdst = 0;

		if( (rtc[3] & 0x80)  && (rtc[3] & 0x40) ) tmp->tm_hour += 12;
		if (tmp->tm_year < 1970) tmp->tm_year += 100;
	} else {
		uchar sec, min, hour;
		uchar mday, wday, mon, year;

		int century;

		uchar reg_a;

		if (century_flag < 0)
			century_flag = get_century_flag();

		reg_a = rtc_read( RTC_CONTROLA );
		/* lock clock registers for read */
		rtc_write( RTC_CONTROLA, ( reg_a | RTC_CA_READ ));

		sec     = rtc_read( RTC_SECONDS );
		min     = rtc_read( RTC_MINUTES );
		hour    = rtc_read( RTC_HOURS );
		mday    = rtc_read( RTC_DAY_OF_MONTH );
		wday    = rtc_read( RTC_DAY_OF_WEEK );
		mon     = rtc_read( RTC_MONTH );
		year    = rtc_read( RTC_YEAR );
		century = rtc_read( RTC_CENTURY );

		/* unlock clock registers after read */
		rtc_write( RTC_CONTROLA, ( reg_a & ~RTC_CA_READ ));

		tmp->tm_sec  = bcd2bin( sec  & 0x7F );
		tmp->tm_min  = bcd2bin( min  & 0x7F );
		tmp->tm_hour = bcd2bin( hour & 0x3F );
		tmp->tm_mday = bcd2bin( mday & 0x3F );
		tmp->tm_mon  = bcd2bin( mon & 0x1F );
		tmp->tm_wday = bcd2bin( wday & 0x07 );

		if (century_flag) {
			tmp->tm_year = bcd2bin( year ) +
				( bcd2bin( century & 0x3F ) * 100 );
		} else {
			tmp->tm_year = bcd2bin( year ) + 1900;
			if (tmp->tm_year < 1970) tmp->tm_year += 100;
		}

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

	return 0;
}

void rtc_set( struct rtc_time *tmp )
{
	if (phantom_flag < 0)
		phantom_flag = get_phantom_flag();

	if (phantom_flag) {
		uint year;
		unsigned char rtc[8];

		year = tmp->tm_year;
		year -= (year < 2000) ? 1900 : 2000;

		rtc[0] = bin2bcd(0);
		rtc[1] = bin2bcd(tmp->tm_sec);
		rtc[2] = bin2bcd(tmp->tm_min);
		rtc[3] = bin2bcd(tmp->tm_hour);
		rtc[4] = bin2bcd(tmp->tm_wday);
		rtc[5] = bin2bcd(tmp->tm_mday);
		rtc[6] = bin2bcd(tmp->tm_mon);
		rtc[7] = bin2bcd(year);

		phantom_rtc_write(RTC_BASE, rtc);
	} else {
		uchar reg_a;
		if (century_flag < 0)
			century_flag = get_century_flag();

		/* lock clock registers for write */
		reg_a = rtc_read( RTC_CONTROLA );
		rtc_write( RTC_CONTROLA, ( reg_a | RTC_CA_WRITE ));

		rtc_write( RTC_MONTH, bin2bcd( tmp->tm_mon ));

		rtc_write( RTC_DAY_OF_WEEK, bin2bcd( tmp->tm_wday ));
		rtc_write( RTC_DAY_OF_MONTH, bin2bcd( tmp->tm_mday ));
		rtc_write( RTC_HOURS, bin2bcd( tmp->tm_hour ));
		rtc_write( RTC_MINUTES, bin2bcd( tmp->tm_min ));
		rtc_write( RTC_SECONDS, bin2bcd( tmp->tm_sec ));

		/* break year up into century and year in century */
		if (century_flag) {
			rtc_write( RTC_YEAR, bin2bcd( tmp->tm_year % 100 ));
			rtc_write( RTC_CENTURY, bin2bcd( tmp->tm_year / 100 ));
			reg_a &= 0xc0;
			reg_a |= bin2bcd( tmp->tm_year / 100 );
		} else {
			rtc_write(RTC_YEAR, bin2bcd(tmp->tm_year -
				((tmp->tm_year < 2000) ? 1900 : 2000)));
		}

		/* unlock clock registers after read */
		rtc_write( RTC_CONTROLA, ( reg_a  & ~RTC_CA_WRITE ));
	}
}

#endif
Commit	Line	Data
15647dc7 WD	1	/*
	2	* board/eva/phantom.c
	3	*
	4	* Phantom RTC device driver for EVA
	5	*
	6	* Author: Sangmoon Kim
	7	* dogoil@etinsys.com
	8	*
	9	* Copyright 2002 Etinsys Inc.
	10	*
	11	* This program is free software; you can redistribute it and/or modify it
	12	* under the terms of the GNU General Public License as published by the
	13	* Free Software Foundation; either version 2 of the License, or (at your
	14	* option) any later version.
	15	*/
	16
	17	#include <common.h>
	18	#include <command.h>
	19	#include <rtc.h>
	20
b9307262	21	#if defined(CONFIG_CMD_DATE)
15647dc7 WD	22
	23	#define RTC_BASE (CFG_NVRAM_BASE_ADDR + 0x7fff8)
	24
	25	#define RTC_YEAR ( RTC_BASE + 7 )
	26	#define RTC_MONTH ( RTC_BASE + 6 )
	27	#define RTC_DAY_OF_MONTH ( RTC_BASE + 5 )
	28	#define RTC_DAY_OF_WEEK ( RTC_BASE + 4 )
	29	#define RTC_HOURS ( RTC_BASE + 3 )
	30	#define RTC_MINUTES ( RTC_BASE + 2 )
	31	#define RTC_SECONDS ( RTC_BASE + 1 )
	32	#define RTC_CENTURY ( RTC_BASE + 0 )
	33
	34	#define RTC_CONTROLA RTC_CENTURY
	35	#define RTC_CONTROLB RTC_SECONDS
	36	#define RTC_CONTROLC RTC_DAY_OF_WEEK
	37
	38	#define RTC_CA_WRITE 0x80
	39	#define RTC_CA_READ 0x40
	40
	41	#define RTC_CB_OSC_DISABLE 0x80
	42
	43	#define RTC_CC_BATTERY_FLAG 0x80
	44	#define RTC_CC_FREQ_TEST 0x40
	45
	46
	47	static int phantom_flag = -1;
	48	static int century_flag = -1;
	49
	50	static uchar rtc_read(unsigned int addr)
	51	{
	52	return (volatile unsigned char )(addr);
	53	}
	54
	55	static void rtc_write(unsigned int addr, uchar val)
	56	{
	57	(volatile unsigned char )(addr) = val;
	58	}
	59
	60	static unsigned char phantom_rtc_sequence[] = {
	61	0xc5, 0x3a, 0xa3, 0x5c, 0xc5, 0x3a, 0xa3, 0x5c
	62	};
	63
	64	static unsigned char* phantom_rtc_read(int addr, unsigned char rtc[8])
	65	{
	66	int i, j;
	67	unsigned char v;
	68	unsigned char save = rtc_read(addr);
	69
	70	for (j = 0; j < 8; j++) {
	71	v = phantom_rtc_sequence[j];
	72	for (i = 0; i < 8; i++) {
	73	rtc_write(addr, v & 1);
	74	v >>= 1;
	75	}
	76	}
	77	for (j = 0; j < 8; j++) {
	78	v = 0;
	79	for (i = 0; i < 8; i++) {
	80	if(rtc_read(addr) & 1)
	81	v \|= 1 << i;
	82	}
	83	rtc[j] = v;
	84	}
	85	rtc_write(addr, save);
86	return rtc;
87	}
88
89	static void phantom_rtc_write(int addr, unsigned char rtc[8])
90	{
91	int i, j;
92	unsigned char v;
93	unsigned char save = rtc_read(addr);
94	for (j = 0; j < 8; j++) {
95	v = phantom_rtc_sequence[j];
96	for (i = 0; i < 8; i++) {
97	rtc_write(addr, v & 1);
98	v >>= 1;
99	}
100	}
101	for (j = 0; j < 8; j++) {
102	v = rtc[j];
103	for (i = 0; i < 8; i++) {
104	rtc_write(addr, v & 1);
105	v >>= 1;
106	}
107	}
108	rtc_write(addr, save);
109	}
110
111	static int get_phantom_flag(void)
112	{
113	int i;
114	unsigned char rtc[8];
115
116	phantom_rtc_read(RTC_BASE, rtc);
117
118	for(i = 1; i < 8; i++) {
119	if (rtc[i] != rtc[0])
120	return 1;
121	}
122	return 0;
123	}
124
125	void rtc_reset(void)
126	{
127	if (phantom_flag < 0)
128	phantom_flag = get_phantom_flag();
129
130	if (phantom_flag) {
131	unsigned char rtc[8];
132	phantom_rtc_read(RTC_BASE, rtc);
133	if(rtc[4] & 0x30) {
134	printf( "real-time-clock was stopped. Now starting...\n" );
135	rtc[4] &= 0x07;
136	phantom_rtc_write(RTC_BASE, rtc);
137	}
138	} else {
139	uchar reg_a, reg_b, reg_c;
140	reg_a = rtc_read( RTC_CONTROLA );
141	reg_b = rtc_read( RTC_CONTROLB );
142
143	if ( reg_b & RTC_CB_OSC_DISABLE )
144	{
145	printf( "real-time-clock was stopped. Now starting...\n" );
146	reg_a \|= RTC_CA_WRITE;
147	reg_b &= ~RTC_CB_OSC_DISABLE;
148	rtc_write( RTC_CONTROLA, reg_a );
149	rtc_write( RTC_CONTROLB, reg_b );
150	}
151
152	/* make sure read/write clock register bits are cleared */
153	reg_a &= ~( RTC_CA_WRITE \| RTC_CA_READ );
154	rtc_write( RTC_CONTROLA, reg_a );
155
156	reg_c = rtc_read( RTC_CONTROLC );
157	if (( reg_c & RTC_CC_BATTERY_FLAG ) == 0 )
158	printf( "RTC battery low. Clock setting may not be reliable.\n");
159	}
160	}
161
162	inline unsigned bcd2bin (uchar n)
163	{
164	return ((((n >> 4) & 0x0F) * 10) + (n & 0x0F));
165	}
166
167	inline unsigned char bin2bcd (unsigned int n)
168	{
169	return (((n / 10) << 4) \| (n % 10));
170	}
171
172	static int get_century_flag(void)
173	{
174	int flag = 0;
175	int bcd, century;
176	bcd = rtc_read( RTC_CENTURY );
177	century = bcd2bin( bcd & 0x3F );
178	rtc_write( RTC_CENTURY, bin2bcd(century+1));
179	if (bcd == rtc_read( RTC_CENTURY ))
180	flag = 1;
181	rtc_write( RTC_CENTURY, bcd);
182	return flag;
183	}
184
b73a19e1	185	int rtc_get( struct rtc_time *tmp)
15647dc7 WD	186	{
	187	if (phantom_flag < 0)
	188	phantom_flag = get_phantom_flag();
	189
	190	if (phantom_flag)
	191	{
	192	unsigned char rtc[8];
	193
	194	phantom_rtc_read(RTC_BASE, rtc);
	195
	196	tmp->tm_sec = bcd2bin(rtc[1] & 0x7f);
	197	tmp->tm_min = bcd2bin(rtc[2] & 0x7f);
	198	tmp->tm_hour = bcd2bin(rtc[3] & 0x1f);
	199	tmp->tm_wday = bcd2bin(rtc[4] & 0x7);
	200	tmp->tm_mday = bcd2bin(rtc[5] & 0x3f);
	201	tmp->tm_mon = bcd2bin(rtc[6] & 0x1f);
	202	tmp->tm_year = bcd2bin(rtc[7]) + 1900;
	203	tmp->tm_yday = 0;
	204	tmp->tm_isdst = 0;
	205
	206	if( (rtc[3] & 0x80) && (rtc[3] & 0x40) ) tmp->tm_hour += 12;
	207	if (tmp->tm_year < 1970) tmp->tm_year += 100;
	208	} else {
	209	uchar sec, min, hour;
	210	uchar mday, wday, mon, year;
	211
	212	int century;
	213
	214	uchar reg_a;
	215
	216	if (century_flag < 0)
	217	century_flag = get_century_flag();
	218
	219	reg_a = rtc_read( RTC_CONTROLA );
	220	/* lock clock registers for read */
	221	rtc_write( RTC_CONTROLA, ( reg_a \| RTC_CA_READ ));
	222
	223	sec = rtc_read( RTC_SECONDS );
	224	min = rtc_read( RTC_MINUTES );
	225	hour = rtc_read( RTC_HOURS );
	226	mday = rtc_read( RTC_DAY_OF_MONTH );
	227	wday = rtc_read( RTC_DAY_OF_WEEK );
	228	mon = rtc_read( RTC_MONTH );
	229	year = rtc_read( RTC_YEAR );
	230	century = rtc_read( RTC_CENTURY );
	231
	232	/* unlock clock registers after read */
	233	rtc_write( RTC_CONTROLA, ( reg_a & ~RTC_CA_READ ));
	234
	235	tmp->tm_sec = bcd2bin( sec & 0x7F );
	236	tmp->tm_min = bcd2bin( min & 0x7F );
	237	tmp->tm_hour = bcd2bin( hour & 0x3F );
	238	tmp->tm_mday = bcd2bin( mday & 0x3F );
	239	tmp->tm_mon = bcd2bin( mon & 0x1F );
	240	tmp->tm_wday = bcd2bin( wday & 0x07 );
	241
	242	if (century_flag) {
	243	tmp->tm_year = bcd2bin( year ) +
	244	( bcd2bin( century & 0x3F ) * 100 );
	245	} else {
	246	tmp->tm_year = bcd2bin( year ) + 1900;
	247	if (tmp->tm_year < 1970) tmp->tm_year += 100;
	248	}
	249
250	tmp->tm_yday = 0;
251	tmp->tm_isdst= 0;
252	}
b73a19e1 YT	253
b73a19e1 YT	254	return 0;
15647dc7 WD	255	}
	256
	257	void rtc_set( struct rtc_time *tmp )
	258	{
	259	if (phantom_flag < 0)
	260	phantom_flag = get_phantom_flag();
	261
	262	if (phantom_flag) {
	263	uint year;
	264	unsigned char rtc[8];
	265
	266	year = tmp->tm_year;
	267	year -= (year < 2000) ? 1900 : 2000;
	268
	269	rtc[0] = bin2bcd(0);
	270	rtc[1] = bin2bcd(tmp->tm_sec);
	271	rtc[2] = bin2bcd(tmp->tm_min);
	272	rtc[3] = bin2bcd(tmp->tm_hour);
	273	rtc[4] = bin2bcd(tmp->tm_wday);
	274	rtc[5] = bin2bcd(tmp->tm_mday);
	275	rtc[6] = bin2bcd(tmp->tm_mon);
	276	rtc[7] = bin2bcd(year);
	277
	278	phantom_rtc_write(RTC_BASE, rtc);
	279	} else {
	280	uchar reg_a;
	281	if (century_flag < 0)
	282	century_flag = get_century_flag();
	283
	284	/* lock clock registers for write */
	285	reg_a = rtc_read( RTC_CONTROLA );
	286	rtc_write( RTC_CONTROLA, ( reg_a \| RTC_CA_WRITE ));
	287
	288	rtc_write( RTC_MONTH, bin2bcd( tmp->tm_mon ));
	289
	290	rtc_write( RTC_DAY_OF_WEEK, bin2bcd( tmp->tm_wday ));
	291	rtc_write( RTC_DAY_OF_MONTH, bin2bcd( tmp->tm_mday ));
	292	rtc_write( RTC_HOURS, bin2bcd( tmp->tm_hour ));
	293	rtc_write( RTC_MINUTES, bin2bcd( tmp->tm_min ));
	294	rtc_write( RTC_SECONDS, bin2bcd( tmp->tm_sec ));
	295
	296	/* break year up into century and year in century */
	297	if (century_flag) {
	298	rtc_write( RTC_YEAR, bin2bcd( tmp->tm_year % 100 ));
	299	rtc_write( RTC_CENTURY, bin2bcd( tmp->tm_year / 100 ));
	300	reg_a &= 0xc0;
	301	reg_a \|= bin2bcd( tmp->tm_year / 100 );
	302	} else {
	303	rtc_write(RTC_YEAR, bin2bcd(tmp->tm_year -
	304	((tmp->tm_year < 2000) ? 1900 : 2000)));
	305	}
	306
	307	/* unlock clock registers after read */
	308	rtc_write( RTC_CONTROLA, ( reg_a & ~RTC_CA_WRITE ));
	309	}
	310	}
	311
	312	#endif