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

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This 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 OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_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/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;

#if	NCPUS > 1 && AT386
	mp_disable_preemption();
	if (cpu_number() != master_cpu) {
		mp_enable_preemption();
		return(1);
	}
#endif
	/*
	 * 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");
#if	NCPUS > 1 && AT386
	mp_enable_preemption();
#endif
	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 	NCPUS > 1 && AT386
	if ((thread = current_thread()) != THREAD_NULL) {
		thread_bind(thread, master_processor);
		mp_disable_preemption();
		if (current_processor() != master_processor) {
			mp_enable_preemption();
			thread_block((void (*)) 0);
		} else {
			mp_enable_preemption();
		}
	}
#endif
	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	NCPUS > 1 && AT386
	if (thread != THREAD_NULL)
		thread_bind(thread, PROCESSOR_NULL);
#endif
	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	NCPUS > 1 && AT386
	if ((thread = current_thread()) != THREAD_NULL) {
		thread_bind(thread, master_processor);
		mp_disable_preemption();
		if (current_processor() != master_processor) {
			mp_enable_preemption();
			thread_block((void (*)) 0);
		} else { 
			mp_enable_preemption();
		}
	}
#endif
	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 = 1970; 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	NCPUS > 1 && AT386
	if (thread != THREAD_NULL)
		thread_bind(current_thread(), PROCESSOR_NULL);
#endif
	return (KERN_SUCCESS);
}

/*
 * Get clock device attributes.
 */
kern_return_t
bbc_getattr(
	clock_flavor_t		flavor,
	clock_attr_t		attr,		/* OUT */
	mach_msg_type_number_t	*count)		/* IN/OUT */
{
	if (*count != 1)
		return (KERN_FAILURE);
	switch (flavor) {

	case CLOCK_GET_TIME_RES:	/* >0 res */
		*(clock_res_t *) attr = NSEC_PER_SEC;
		break;

	case CLOCK_ALARM_CURRES:	/* =0 no alarm */
	case CLOCK_ALARM_MINRES:
	case CLOCK_ALARM_MAXRES:
		*(clock_res_t *) attr = 0;
		break;

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