[people/ms/u-boot.git] / board / mousse / m48t59y.c

/*
 * SGS M48-T59Y TOD/NVRAM Driver
 *
 * (C) Copyright 2000
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
 * (C) Copyright 1999, by Curt McDowell, 08-06-99, Broadcom Corp.
 *
 * (C) Copyright 2001, James Dougherty, 07/18/01, Broadcom Corp.
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

/*
 * SGS M48-T59Y TOD/NVRAM Driver
 *
 * The SGS M48 an 8K NVRAM starting at offset M48_BASE_ADDR and
 * continuing for 8176 bytes. After that starts the Time-Of-Day (TOD)
 * registers which are used to set/get the internal date/time functions.
 *
 * This module implements Y2K compliance by taking full year numbers
 * and translating back and forth from the TOD 2-digit year.
 *
 * NOTE: for proper interaction with an operating system, the TOD should
 * be used to store Universal Coordinated Time (GMT) and timezone
 * conversions should be used.
 *
 * Here is a diagram of the memory layout:
 *
 * +---------------------------------------------+ 0xffe0a000
 * | Non-volatile memory                         | .
 * |                                             | .
 * | (8176 bytes of Non-volatile memory)         | .
 * |                                             | .
 * +---------------------------------------------+ 0xffe0bff0
 * | Flags                                       |
 * +---------------------------------------------+ 0xffe0bff1
 * | Unused                                      |
 * +---------------------------------------------+ 0xffe0bff2
 * | Alarm Seconds                               |
 * +---------------------------------------------+ 0xffe0bff3
 * | Alarm Minutes                               |
 * +---------------------------------------------+ 0xffe0bff4
 * | Alarm Date                                  |
 * +---------------------------------------------+ 0xffe0bff5
 * | Interrupts                                  |
 * +---------------------------------------------+ 0xffe0bff6
 * | WatchDog                                    |
 * +---------------------------------------------+ 0xffe0bff7
 * | Calibration                                 |
 * +---------------------------------------------+ 0xffe0bff8
 * | Seconds                                     |
 * +---------------------------------------------+ 0xffe0bff9
 * | Minutes                                     |
 * +---------------------------------------------+ 0xffe0bffa
 * | Hours                                       |
 * +---------------------------------------------+ 0xffe0bffb
 * | Day                                         |
 * +---------------------------------------------+ 0xffe0bffc
 * | Date                                        |
 * +---------------------------------------------+ 0xffe0bffd
 * | Month                                       |
 * +---------------------------------------------+ 0xffe0bffe
 * | Year (2 digits only)                        |
 * +---------------------------------------------+ 0xffe0bfff
 */
#include <common.h>
#include <rtc.h>
#include "mousse.h"

/*
 * Imported from mousse.h:
 *
 *   TOD_REG_BASE		Base of m48t59y TOD registers
 *   SYS_TOD_UNPROTECT()	Disable NVRAM write protect
 *   SYS_TOD_PROTECT()		Re-enable NVRAM write protect
 */

#define YEAR		0xf
#define MONTH		0xe
#define DAY		0xd
#define DAY_OF_WEEK	0xc
#define HOUR		0xb
#define MINUTE		0xa
#define SECOND		0x9
#define CONTROL		0x8
#define WATCH		0x7
#define INTCTL		0x6
#define WD_DATE		0x5
#define WD_HOUR		0x4
#define WD_MIN		0x3
#define WD_SEC		0x2
#define _UNUSED		0x1
#define FLAGS		0x0

#define M48_ADDR	((volatile unsigned char *) TOD_REG_BASE)

int m48_tod_init(void)
{
    SYS_TOD_UNPROTECT();

    M48_ADDR[CONTROL] = 0;
    M48_ADDR[WATCH] = 0;
    M48_ADDR[INTCTL] = 0;

    /*
     * If the oscillator is currently stopped (as on a new part shipped
     * from the factory), start it running.
     *
     * Here is an example of the TOD bytes on a brand new M48T59Y part:
     *		00 00 00 00 00 00 00 00 00 88 8c c3 bf c8 f5 01
     */

    if (M48_ADDR[SECOND] & 0x80)
	M48_ADDR[SECOND] = 0;

    /* Is battery low */
    if ( M48_ADDR[FLAGS] & 0x10) {
	 printf("NOTICE: Battery low on Real-Time Clock (replace SNAPHAT).\n");
    }

    SYS_TOD_PROTECT();

    return 0;
}

/*
 * m48_tod_set
 */

static int to_bcd(int value)
{
    return value / 10 * 16 + value % 10;
}

static int from_bcd(int value)
{
    return value / 16 * 10 + value % 16;
}

static int day_of_week(int y, int m, int d)	/* 0-6 ==> Sun-Sat */
{
    static int t[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
    y -= m < 3;
    return (y + y/4 - y/100 + y/400 + t[m-1] + d) % 7;
}

/*
 * Note: the TOD should store the current GMT
 */

int m48_tod_set(int year,		/* 1980-2079 */
		int month,		/* 01-12 */
		int day,		/* 01-31 */
		int hour,		/* 00-23 */
		int minute,		/* 00-59 */
		int second)		/* 00-59 */

{
    SYS_TOD_UNPROTECT();

    M48_ADDR[CONTROL] |= 0x80;	/* Set WRITE bit */

    M48_ADDR[YEAR] = to_bcd(year % 100);
    M48_ADDR[MONTH] = to_bcd(month);
    M48_ADDR[DAY] = to_bcd(day);
    M48_ADDR[DAY_OF_WEEK] = day_of_week(year, month, day) + 1;
    M48_ADDR[HOUR] = to_bcd(hour);
    M48_ADDR[MINUTE] = to_bcd(minute);
    M48_ADDR[SECOND] = to_bcd(second);

    M48_ADDR[CONTROL] &= ~0x80;	/* Clear WRITE bit */

    SYS_TOD_PROTECT();

    return 0;
}

/*
 * Note: the TOD should store the current GMT
 */

int m48_tod_get(int *year,		/* 1980-2079 */
		int *month,		/* 01-12 */
		int *day,		/* 01-31 */
		int *hour,		/* 00-23 */
		int *minute,		/* 00-59 */
		int *second)		/* 00-59 */
{
    int y;

    SYS_TOD_UNPROTECT();

    M48_ADDR[CONTROL] |= 0x40;	/* Set READ bit */

    y = from_bcd(M48_ADDR[YEAR]);
    *year = y < 80 ? 2000 + y : 1900 + y;
    *month = from_bcd(M48_ADDR[MONTH]);
    *day = from_bcd(M48_ADDR[DAY]);
    /* day_of_week = M48_ADDR[DAY_OF_WEEK] & 0xf; */
    *hour = from_bcd(M48_ADDR[HOUR]);
    *minute = from_bcd(M48_ADDR[MINUTE]);
    *second = from_bcd(M48_ADDR[SECOND] & 0x7f);

    M48_ADDR[CONTROL] &= ~0x40;	/* Clear READ bit */

    SYS_TOD_PROTECT();

    return 0;
}

int m48_tod_get_second(void)
{
    return from_bcd(M48_ADDR[SECOND] & 0x7f);
}

/*
 * Watchdog function
 *
 *  If usec is 0, the watchdog timer is disarmed.
 *
 *  If usec is non-zero, the watchdog timer is armed (or re-armed) for
 *    approximately usec microseconds (if the exact requested usec is
 *    not supported by the chip, the next higher available value is used).
 *
 *  Minimum watchdog timeout = 62500 usec
 *  Maximum watchdog timeout = 124 sec (124000000 usec)
 */

void m48_watchdog_arm(int usec)
{
    int		mpy, res;

    SYS_TOD_UNPROTECT();

    if (usec == 0) {
	res = 0;
	mpy = 0;
    } else if (usec < 2000000) {	/* Resolution: 1/16s if below 2s */
	res = 0;
	mpy = (usec + 62499) / 62500;
    } else if (usec < 8000000) {	/* Resolution: 1/4s if below 8s */
	res = 1;
	mpy = (usec + 249999) / 250000;
    } else if (usec < 32000000) {	/* Resolution: 1s if below 32s */
	res = 2;
	mpy = (usec + 999999) / 1000000;
    } else {				/* Resolution: 4s up to 124s */
	res = 3;
	mpy = (usec + 3999999) / 4000000;
	if (mpy > 31)
	    mpy = 31;
    }

    M48_ADDR[WATCH] = (0x80 |		/* Steer to RST signal (IRQ = N/C) */
		       mpy << 2 |
		       res);

    SYS_TOD_PROTECT();
}

/*
 * U-Boot RTC support.
 */
int
rtc_get( struct rtc_time *tmp )
{
	m48_tod_get(&tmp->tm_year,
		    &tmp->tm_mon,
		    &tmp->tm_mday,
		    &tmp->tm_hour,
		    &tmp->tm_min,
		    &tmp->tm_sec);
	tmp->tm_yday = 0;
	tmp->tm_isdst= 0;

#ifdef RTC_DEBUG
	printf( "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 );
#endif

	return 0;
}

int rtc_set( struct rtc_time *tmp )
{
	m48_tod_set(tmp->tm_year,		/* 1980-2079 */
		    tmp->tm_mon,		/* 01-12 */
		    tmp->tm_mday,              /* 01-31 */
		    tmp->tm_hour,		/* 00-23 */
		    tmp->tm_min,		/* 00-59 */
		    tmp->tm_sec);		/* 00-59 */

#ifdef RTC_DEBUG
	printf( "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);
#endif

	return 0;
}

void
rtc_reset (void)
{
  m48_tod_init();
}
Commit	Line	Data
cc1c8a13 WD	1	/*
	2	* SGS M48-T59Y TOD/NVRAM Driver
	3	*
	4	* (C) Copyright 2000
	5	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
	6	*
	7	* (C) Copyright 1999, by Curt McDowell, 08-06-99, Broadcom Corp.
	8	*
	9	* (C) Copyright 2001, James Dougherty, 07/18/01, Broadcom Corp.
	10	*
1a459660	11	* SPDX-License-Identifier: GPL-2.0+
cc1c8a13 WD	12	*/
	13
	14	/*
	15	* SGS M48-T59Y TOD/NVRAM Driver
	16	*
	17	* The SGS M48 an 8K NVRAM starting at offset M48_BASE_ADDR and
	18	* continuing for 8176 bytes. After that starts the Time-Of-Day (TOD)
	19	* registers which are used to set/get the internal date/time functions.
	20	*
	21	* This module implements Y2K compliance by taking full year numbers
	22	* and translating back and forth from the TOD 2-digit year.
	23	*
	24	* NOTE: for proper interaction with an operating system, the TOD should
	25	* be used to store Universal Coordinated Time (GMT) and timezone
	26	* conversions should be used.
	27	*
	28	* Here is a diagram of the memory layout:
	29	*
	30	* +---------------------------------------------+ 0xffe0a000
	31	* \| Non-volatile memory \| .
	32	* \| \| .
	33	* \| (8176 bytes of Non-volatile memory) \| .
	34	* \| \| .
	35	* +---------------------------------------------+ 0xffe0bff0
	36	* \| Flags \|
	37	* +---------------------------------------------+ 0xffe0bff1
	38	* \| Unused \|
	39	* +---------------------------------------------+ 0xffe0bff2
	40	* \| Alarm Seconds \|
	41	* +---------------------------------------------+ 0xffe0bff3
	42	* \| Alarm Minutes \|
	43	* +---------------------------------------------+ 0xffe0bff4
	44	* \| Alarm Date \|
	45	* +---------------------------------------------+ 0xffe0bff5
	46	* \| Interrupts \|
	47	* +---------------------------------------------+ 0xffe0bff6
	48	* \| WatchDog \|
	49	* +---------------------------------------------+ 0xffe0bff7
	50	* \| Calibration \|
	51	* +---------------------------------------------+ 0xffe0bff8
	52	* \| Seconds \|
	53	* +---------------------------------------------+ 0xffe0bff9
	54	* \| Minutes \|
	55	* +---------------------------------------------+ 0xffe0bffa
	56	* \| Hours \|
	57	* +---------------------------------------------+ 0xffe0bffb
	58	* \| Day \|
	59	* +---------------------------------------------+ 0xffe0bffc
	60	* \| Date \|
	61	* +---------------------------------------------+ 0xffe0bffd
	62	* \| Month \|
	63	* +---------------------------------------------+ 0xffe0bffe
	64	* \| Year (2 digits only) \|
	65	* +---------------------------------------------+ 0xffe0bfff
	66	*/
	67	#include <common.h>
	68	#include <rtc.h>
	69	#include "mousse.h"
	70
	71	/*
	72	* Imported from mousse.h:
	73	*
	74	* TOD_REG_BASE Base of m48t59y TOD registers
	75	* SYS_TOD_UNPROTECT() Disable NVRAM write protect
76	* SYS_TOD_PROTECT() Re-enable NVRAM write protect
77	*/
78
79	#define YEAR 0xf
80	#define MONTH 0xe
81	#define DAY 0xd
82	#define DAY_OF_WEEK 0xc
83	#define HOUR 0xb
84	#define MINUTE 0xa
85	#define SECOND 0x9
86	#define CONTROL 0x8
87	#define WATCH 0x7
88	#define INTCTL 0x6
89	#define WD_DATE 0x5
90	#define WD_HOUR 0x4
91	#define WD_MIN 0x3
92	#define WD_SEC 0x2
93	#define _UNUSED 0x1
94	#define FLAGS 0x0
95
96	#define M48_ADDR ((volatile unsigned char *) TOD_REG_BASE)
97
98	int m48_tod_init(void)
99	{
100	SYS_TOD_UNPROTECT();
101
102	M48_ADDR[CONTROL] = 0;
103	M48_ADDR[WATCH] = 0;
104	M48_ADDR[INTCTL] = 0;
105
106	/*
107	* If the oscillator is currently stopped (as on a new part shipped
108	* from the factory), start it running.
109	*
110	* Here is an example of the TOD bytes on a brand new M48T59Y part:
111	* 00 00 00 00 00 00 00 00 00 88 8c c3 bf c8 f5 01
112	*/
113
114	if (M48_ADDR[SECOND] & 0x80)
115	M48_ADDR[SECOND] = 0;
116
117	/* Is battery low */
118	if ( M48_ADDR[FLAGS] & 0x10) {
119	printf("NOTICE: Battery low on Real-Time Clock (replace SNAPHAT).\n");
120	}
121
122	SYS_TOD_PROTECT();
123
124	return 0;
125	}
126
127	/*
128	* m48_tod_set
129	*/
130
131	static int to_bcd(int value)
132	{
133	return value / 10 * 16 + value % 10;
134	}
135
136	static int from_bcd(int value)
137	{
138	return value / 16 * 10 + value % 16;
139	}
140
141	static int day_of_week(int y, int m, int d) /* 0-6 ==> Sun-Sat */
142	{
143	static int t[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
144	y -= m < 3;
145	return (y + y/4 - y/100 + y/400 + t[m-1] + d) % 7;
146	}
147
148	/*
149	* Note: the TOD should store the current GMT
150	*/
151
152	int m48_tod_set(int year, /* 1980-2079 */
153	int month, /* 01-12 */
154	int day, /* 01-31 */
155	int hour, /* 00-23 */
156	int minute, /* 00-59 */
157	int second) /* 00-59 */
158
159	{
160	SYS_TOD_UNPROTECT();
161
162	M48_ADDR[CONTROL] \|= 0x80; /* Set WRITE bit */
163
164	M48_ADDR[YEAR] = to_bcd(year % 100);
165	M48_ADDR[MONTH] = to_bcd(month);
166	M48_ADDR[DAY] = to_bcd(day);
167	M48_ADDR[DAY_OF_WEEK] = day_of_week(year, month, day) + 1;
168	M48_ADDR[HOUR] = to_bcd(hour);
169	M48_ADDR[MINUTE] = to_bcd(minute);
170	M48_ADDR[SECOND] = to_bcd(second);
171
172	M48_ADDR[CONTROL] &= ~0x80; /* Clear WRITE bit */
173
174	SYS_TOD_PROTECT();
175
176	return 0;
177	}
178
179	/*
180	* Note: the TOD should store the current GMT
181	*/
182
183	int m48_tod_get(int year, / 1980-2079 */
184	int month, / 01-12 */
185	int day, / 01-31 */
186	int hour, / 00-23 */
187	int minute, / 00-59 */
188	int second) / 00-59 */
189	{
190	int y;
191
192	SYS_TOD_UNPROTECT();
193
194	M48_ADDR[CONTROL] \|= 0x40; /* Set READ bit */
195
196	y = from_bcd(M48_ADDR[YEAR]);
197	*year = y < 80 ? 2000 + y : 1900 + y;
198	*month = from_bcd(M48_ADDR[MONTH]);
199	*day = from_bcd(M48_ADDR[DAY]);
200	/* day_of_week = M48_ADDR[DAY_OF_WEEK] & 0xf; */
201	*hour = from_bcd(M48_ADDR[HOUR]);
202	*minute = from_bcd(M48_ADDR[MINUTE]);
203	*second = from_bcd(M48_ADDR[SECOND] & 0x7f);
204
205	M48_ADDR[CONTROL] &= ~0x40; /* Clear READ bit */
206
207	SYS_TOD_PROTECT();
208
209	return 0;
210	}
211
212	int m48_tod_get_second(void)
213	{
214	return from_bcd(M48_ADDR[SECOND] & 0x7f);
215	}
216
217	/*
218	* Watchdog function
219	*
220	* If usec is 0, the watchdog timer is disarmed.
221	*
222	* If usec is non-zero, the watchdog timer is armed (or re-armed) for
223	* approximately usec microseconds (if the exact requested usec is
224	* not supported by the chip, the next higher available value is used).
225	*
226	* Minimum watchdog timeout = 62500 usec
227	* Maximum watchdog timeout = 124 sec (124000000 usec)
228	*/
229
230	void m48_watchdog_arm(int usec)
231	{
232	int mpy, res;
233
234	SYS_TOD_UNPROTECT();
235
236	if (usec == 0) {
237	res = 0;
238	mpy = 0;
239	} else if (usec < 2000000) { /* Resolution: 1/16s if below 2s */
240	res = 0;
241	mpy = (usec + 62499) / 62500;
242	} else if (usec < 8000000) { /* Resolution: 1/4s if below 8s */
243	res = 1;
244	mpy = (usec + 249999) / 250000;
245	} else if (usec < 32000000) { /* Resolution: 1s if below 32s */
246	res = 2;
247	mpy = (usec + 999999) / 1000000;
248	} else { /* Resolution: 4s up to 124s */
249	res = 3;
250	mpy = (usec + 3999999) / 4000000;
251	if (mpy > 31)
252	mpy = 31;
253	}
254
255	M48_ADDR[WATCH] = (0x80 \| /* Steer to RST signal (IRQ = N/C) */
256	mpy << 2 \|
257	res);
258
259	SYS_TOD_PROTECT();
260	}
261
262	/*
263	* U-Boot RTC support.
264	*/
b73a19e1	265	int
cc1c8a13 WD	266	rtc_get( struct rtc_time *tmp )
	267	{
	268	m48_tod_get(&tmp->tm_year,
	269	&tmp->tm_mon,
	270	&tmp->tm_mday,
	271	&tmp->tm_hour,
	272	&tmp->tm_min,
	273	&tmp->tm_sec);
	274	tmp->tm_yday = 0;
	275	tmp->tm_isdst= 0;
	276
	277	#ifdef RTC_DEBUG
	278	printf( "Get DATE: %4d-%02d-%02d (wday=%d) TIME: %2d:%02d:%02d\n",
	279	tmp->tm_year, tmp->tm_mon, tmp->tm_mday, tmp->tm_wday,
	280	tmp->tm_hour, tmp->tm_min, tmp->tm_sec );
	281	#endif
b73a19e1 YT	282
b73a19e1 YT	283	return 0;
cc1c8a13 WD	284	}
cc1c8a13 WD	285
d1e23194	286	int rtc_set( struct rtc_time *tmp )
cc1c8a13 WD	287	{
	288	m48_tod_set(tmp->tm_year, /* 1980-2079 */
	289	tmp->tm_mon, /* 01-12 */
	290	tmp->tm_mday, /* 01-31 */
	291	tmp->tm_hour, /* 00-23 */
	292	tmp->tm_min, /* 00-59 */
	293	tmp->tm_sec); /* 00-59 */
	294
	295	#ifdef RTC_DEBUG
	296	printf( "Set DATE: %4d-%02d-%02d (wday=%d) TIME: %2d:%02d:%02d\n",
	297	tmp->tm_year, tmp->tm_mon, tmp->tm_mday, tmp->tm_wday,
	298	tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
	299	#endif
	300
d1e23194	301	return 0;
cc1c8a13 WD	302	}
	303
	304	void
	305	rtc_reset (void)
	306	{
	307	m48_tod_init();
	308	}