[apple/xnu.git] / osfmk / i386 / AT386 / bbclock.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/*
  Copyright 1988, 1989 by Intel Corporation, Santa Clara, California.

		All Rights Reserved

Permission to use, copy, modify, and distribute this software and
its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appears in all
copies and that both the copyright notice and this permission notice
appear in supporting documentation, and that the name of Intel
not be used in advertising or publicity pertaining to distribution
of the software without specific, written prior permission.

INTEL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
IN NO EVENT SHALL INTEL BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include <types.h>
#include <mach/message.h>
#include <kern/thread.h>
#include <kern/clock.h>
#include <kern/spl.h>
#include <kern/processor.h>
#include <kern/misc_protos.h>
#include <i386/cpu_data.h>
#include <i386/cpu_number.h>
#include <i386/pio.h>
#include <i386/AT386/rtc.h>
#include <i386/AT386/bbclock_entries.h>

/* local data */
static	int	month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

extern	char	dectohexdec(
			int			n);
extern int	hexdectodec(
			char			c);
extern int	yeartoday(
			int			yr);
extern void	rtcput(
			struct rtc_st		* regs);
extern int	rtcget(
			struct rtc_st		* regs);

#define	LOCK_BBC()	splclock()
#define	UNLOCK_BBC(s)	splx(s)

/*
 * Configure battery-backed clock.
 */
int
bbc_config(void)
{
	int		BbcFlag;
	struct rtc_st	rtclk;

	mp_disable_preemption();
	if (cpu_number() != master_cpu) {
		mp_enable_preemption();
		return(1);
	}

	/*
	 * Setup device.
	 */
	outb(RTC_ADDR, RTC_A);
	outb(RTC_DATA, RTC_DIV2 | RTC_RATE6);
	outb(RTC_ADDR, RTC_B);
	outb(RTC_DATA, RTC_HM);

	/*
	 * Probe the device by trying to read it.
	 */
	BbcFlag = (rtcget(&rtclk) ? 0 : 1);
	if (BbcFlag)
		printf("battery clock configured\n");
	else
		printf("WARNING: Battery Clock Failure!\n");
	mp_enable_preemption();
	return (BbcFlag);
}

/*
 * Get the current clock time.
 */
kern_return_t
bbc_gettime(
	mach_timespec_t	*cur_time)	/* OUT */
{
	struct rtc_st	rtclk;
	time_t		n;
	int		sec, min, hr, dom, mon, yr;
	int		i, days = 0;
	spl_t		s;
	thread_t	thread;

	if ((thread = current_thread()) != THREAD_NULL) {
		thread_bind(thread, master_processor);
		mp_disable_preemption();
		if (current_processor() != master_processor) {
			mp_enable_preemption();
			thread_block(THREAD_CONTINUE_NULL);
		} else {
			mp_enable_preemption();
		}
	}

	s = LOCK_BBC();
	rtcget(&rtclk);
	sec = hexdectodec(rtclk.rtc_sec);
	min = hexdectodec(rtclk.rtc_min);
	hr = hexdectodec(rtclk.rtc_hr);
	dom = hexdectodec(rtclk.rtc_dom);
	mon = hexdectodec(rtclk.rtc_mon);
	yr = hexdectodec(rtclk.rtc_yr);
	yr = (yr < 70) ? yr+100 : yr;
	n = sec + 60 * min + 3600 * hr;
	n += (dom - 1) * 3600 * 24;
	if (yeartoday(yr) == 366)
		month[1] = 29;
	for (i = mon - 2; i >= 0; i--)
		days += month[i];
	month[1] = 28;
	for (i = 70; i < yr; i++)
		days += yeartoday(i);
	n += days * 3600 * 24;
	cur_time->tv_sec  = n;
	cur_time->tv_nsec = 0;
	UNLOCK_BBC(s);

	if (thread != THREAD_NULL)
		thread_bind(thread, PROCESSOR_NULL);
	return (KERN_SUCCESS);
}

/*
 * Set the current clock time.
 */
kern_return_t
bbc_settime(
	mach_timespec_t	*new_time)
{
	struct rtc_st	rtclk;
	time_t		n;
	int		diff, i, j;
	spl_t		s;
	thread_t	thread;

	if ((thread = current_thread()) != THREAD_NULL) {
		thread_bind(thread, master_processor);
		mp_disable_preemption();
		if (current_processor() != master_processor) {
			mp_enable_preemption();
			thread_block(THREAD_CONTINUE_NULL);
		} else { 
			mp_enable_preemption();
		}
	}

	s = LOCK_BBC();
	rtcget(&rtclk);
	diff = 0;
	n = (new_time->tv_sec - diff) % (3600 * 24);   /* hrs+mins+secs */
	rtclk.rtc_sec = dectohexdec(n%60);
	n /= 60;
	rtclk.rtc_min = dectohexdec(n%60);
	rtclk.rtc_hr = dectohexdec(n/60);
	n = (new_time->tv_sec - diff) / (3600 * 24);	/* days */
	rtclk.rtc_dow = (n + 4) % 7;  /* 1/1/70 is Thursday */
	for (j = 70; n >= (i = yeartoday(j)); j++)
		n -= i;
	rtclk.rtc_yr = dectohexdec(j % 100);
	if (yeartoday(j) == 366)
		month[1] = 29;
	for (i = 0; n >= month[i]; i++)
		n -= month[i];
	month[1] = 28;
	rtclk.rtc_mon = dectohexdec(++i);
	rtclk.rtc_dom = dectohexdec(++n);
	rtcput(&rtclk);
	UNLOCK_BBC(s);

	if (thread != THREAD_NULL)
		thread_bind(current_thread(), PROCESSOR_NULL);

	return (KERN_SUCCESS);
}

\f
/* DEVICE SPECIFIC ROUTINES */

int
rtcget(
	struct rtc_st	* regs)
{
	outb(RTC_ADDR, RTC_D); 
	if ((inb(RTC_DATA) & RTC_VRT) == 0)
		return (-1);
	outb(RTC_ADDR, RTC_A);	
	while (inb(RTC_DATA) & RTC_UIP)		/* busy wait */
		outb(RTC_ADDR, RTC_A);	
	load_rtc((unsigned char *)regs);
	return (0);
}	

void
rtcput(
	struct rtc_st	* regs)
{
	register unsigned char	x;

	outb(RTC_ADDR, RTC_B);
	x = inb(RTC_DATA);
	outb(RTC_ADDR, RTC_B);
	outb(RTC_DATA, x | RTC_SET); 	
	save_rtc((unsigned char *)regs);
	outb(RTC_ADDR, RTC_B);
	outb(RTC_DATA, x & ~RTC_SET); 
}

int
yeartoday(
	int	year)
{
        year += 1900;
	return((year % 4) ? 365 :
	       ((year % 100) ? 366 : ((year % 400) ? 365: 366)));
}

int
hexdectodec(
	char	n)
{
	return ((((n >> 4) & 0x0F) * 10) + (n & 0x0F));
}

char
dectohexdec(
	int	n)
{
	return ((char)(((n / 10) << 4) & 0xF0) | ((n % 10) & 0x0F));
}
Commit	Line	Data
21362eb3 A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28	/*
	29	* @OSF_COPYRIGHT@
	30	*/
	31	/*
	32	Copyright 1988, 1989 by Intel Corporation, Santa Clara, California.
	33
	34	All Rights Reserved
	35
	36	Permission to use, copy, modify, and distribute this software and
	37	its documentation for any purpose and without fee is hereby
	38	granted, provided that the above copyright notice appears in all
	39	copies and that both the copyright notice and this permission notice
	40	appear in supporting documentation, and that the name of Intel
	41	not be used in advertising or publicity pertaining to distribution
	42	of the software without specific, written prior permission.
	43
	44	INTEL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
	45	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
	46	IN NO EVENT SHALL INTEL BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
	47	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
	48	LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
	49	NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
	50	WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	51	*/
	52
	53	#include <types.h>
	54	#include <mach/message.h>
	55	#include <kern/thread.h>
	56	#include <kern/clock.h>
	57	#include <kern/spl.h>
	58	#include <kern/processor.h>
	59	#include <kern/misc_protos.h>
	60	#include <i386/cpu_data.h>
	61	#include <i386/cpu_number.h>
	62	#include <i386/pio.h>
	63	#include <i386/AT386/rtc.h>
	64	#include <i386/AT386/bbclock_entries.h>
65
66	/* local data */
67	static int month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
68
69	extern char dectohexdec(
70	int n);
71	extern int hexdectodec(
72	char c);
73	extern int yeartoday(
74	int yr);
75	extern void rtcput(
76	struct rtc_st * regs);
77	extern int rtcget(
78	struct rtc_st * regs);
79
80	#define LOCK_BBC() splclock()
81	#define UNLOCK_BBC(s) splx(s)
82
83	/*
84	* Configure battery-backed clock.
85	*/
86	int
87	bbc_config(void)
88	{
89	int BbcFlag;
90	struct rtc_st rtclk;
91
92	mp_disable_preemption();
93	if (cpu_number() != master_cpu) {
94	mp_enable_preemption();
95	return(1);
96	}
97
98	/*
99	* Setup device.
100	*/
101	outb(RTC_ADDR, RTC_A);
102	outb(RTC_DATA, RTC_DIV2 \| RTC_RATE6);
103	outb(RTC_ADDR, RTC_B);
104	outb(RTC_DATA, RTC_HM);
105
106	/*
107	* Probe the device by trying to read it.
108	*/
109	BbcFlag = (rtcget(&rtclk) ? 0 : 1);
110	if (BbcFlag)
111	printf("battery clock configured\n");
112	else
113	printf("WARNING: Battery Clock Failure!\n");
114	mp_enable_preemption();
115	return (BbcFlag);
116	}
117
118	/*
119	* Get the current clock time.
120	*/
121	kern_return_t
122	bbc_gettime(
123	mach_timespec_t cur_time) / OUT */
124	{
125	struct rtc_st rtclk;
126	time_t n;
127	int sec, min, hr, dom, mon, yr;
128	int i, days = 0;
129	spl_t s;
130	thread_t thread;
131
132	if ((thread = current_thread()) != THREAD_NULL) {
133	thread_bind(thread, master_processor);
134	mp_disable_preemption();
135	if (current_processor() != master_processor) {
136	mp_enable_preemption();
137	thread_block(THREAD_CONTINUE_NULL);
138	} else {
139	mp_enable_preemption();
140	}
141	}
142
143	s = LOCK_BBC();
144	rtcget(&rtclk);
145	sec = hexdectodec(rtclk.rtc_sec);
146	min = hexdectodec(rtclk.rtc_min);
147	hr = hexdectodec(rtclk.rtc_hr);
148	dom = hexdectodec(rtclk.rtc_dom);
149	mon = hexdectodec(rtclk.rtc_mon);
150	yr = hexdectodec(rtclk.rtc_yr);
151	yr = (yr < 70) ? yr+100 : yr;
152	n = sec + 60 * min + 3600 * hr;
153	n += (dom - 1) * 3600 * 24;
154	if (yeartoday(yr) == 366)
155	month[1] = 29;
156	for (i = mon - 2; i >= 0; i--)
157	days += month[i];
158	month[1] = 28;
159	for (i = 70; i < yr; i++)
160	days += yeartoday(i);
161	n += days * 3600 * 24;
162	cur_time->tv_sec = n;
163	cur_time->tv_nsec = 0;
164	UNLOCK_BBC(s);
165
166	if (thread != THREAD_NULL)
167	thread_bind(thread, PROCESSOR_NULL);
168	return (KERN_SUCCESS);
169	}
170
171	/*
172	* Set the current clock time.
173	*/
174	kern_return_t
175	bbc_settime(
176	mach_timespec_t *new_time)
177	{
178	struct rtc_st rtclk;
179	time_t n;
180	int diff, i, j;
181	spl_t s;
182	thread_t thread;
183
184	if ((thread = current_thread()) != THREAD_NULL) {
185	thread_bind(thread, master_processor);
186	mp_disable_preemption();
187	if (current_processor() != master_processor) {
188	mp_enable_preemption();
189	thread_block(THREAD_CONTINUE_NULL);
190	} else {
191	mp_enable_preemption();
192	}
193	}
194
195	s = LOCK_BBC();
196	rtcget(&rtclk);
197	diff = 0;
198	n = (new_time->tv_sec - diff) % (3600 * 24); /* hrs+mins+secs */
199	rtclk.rtc_sec = dectohexdec(n%60);
200	n /= 60;
201	rtclk.rtc_min = dectohexdec(n%60);
202	rtclk.rtc_hr = dectohexdec(n/60);
203	n = (new_time->tv_sec - diff) / (3600 * 24); /* days */
204	rtclk.rtc_dow = (n + 4) % 7; /* 1/1/70 is Thursday */
205	for (j = 70; n >= (i = yeartoday(j)); j++)
206	n -= i;
207	rtclk.rtc_yr = dectohexdec(j % 100);
208	if (yeartoday(j) == 366)
209	month[1] = 29;
210	for (i = 0; n >= month[i]; i++)
211	n -= month[i];
212	month[1] = 28;
213	rtclk.rtc_mon = dectohexdec(++i);
214	rtclk.rtc_dom = dectohexdec(++n);
215	rtcput(&rtclk);
216	UNLOCK_BBC(s);
217
218	if (thread != THREAD_NULL)
219	thread_bind(current_thread(), PROCESSOR_NULL);
220
221	return (KERN_SUCCESS);
222	}
223
224	\f
225	/* DEVICE SPECIFIC ROUTINES */
226
227	int
228	rtcget(
229	struct rtc_st * regs)
230	{
231	outb(RTC_ADDR, RTC_D);
232	if ((inb(RTC_DATA) & RTC_VRT) == 0)
233	return (-1);
234	outb(RTC_ADDR, RTC_A);
235	while (inb(RTC_DATA) & RTC_UIP) /* busy wait */
236	outb(RTC_ADDR, RTC_A);
237	load_rtc((unsigned char *)regs);
238	return (0);
239	}
240
241	void
242	rtcput(
243	struct rtc_st * regs)
244	{
245	register unsigned char x;
246
247	outb(RTC_ADDR, RTC_B);
248	x = inb(RTC_DATA);
249	outb(RTC_ADDR, RTC_B);
250	outb(RTC_DATA, x \| RTC_SET);
251	save_rtc((unsigned char *)regs);
252	outb(RTC_ADDR, RTC_B);
253	outb(RTC_DATA, x & ~RTC_SET);
254	}
255
256	int
257	yeartoday(
258	int year)
259	{
260	year += 1900;
261	return((year % 4) ? 365 :
262	((year % 100) ? 366 : ((year % 400) ? 365: 366)));
263	}
264
265	int
266	hexdectodec(
267	char n)
268	{
269	return ((((n >> 4) & 0x0F) * 10) + (n & 0x0F));
270	}
271
272	char
273	dectohexdec(
274	int n)
275	{
276	return ((char)(((n / 10) << 4) & 0xF0) \| ((n % 10) & 0x0F));
277	}