[apple/xnu.git] / osfmk / ppc / misc.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@
 */
#include <debug.h>
#include <mach_debug.h>

#include <mach/ppc/thread_status.h>
#include <mach/vm_types.h>
#include <kern/thread.h>
#include <kern/misc_protos.h>
#include <ppc/proc_reg.h>
#include <ppc/pmap.h>
#include <ppc/misc_protos.h>
#include <ppc/exception.h>

/*
 * copyin/out_multiple - the assembler copyin/out functions jump to C for
 * help when the copyin lies over a segment boundary. The C breaks
 * down the copy into two sub-copies and re-calls the assembler with
 * these sub-copies. Very rare occurrance. Warning: These functions are
 * called whilst active_thread->thread_recover is still set.
 */

extern boolean_t copyin_multiple(const char *src,
				 char *dst,
				 vm_size_t count);

boolean_t copyin_multiple(const char *src,
			  char *dst,
			  vm_size_t count)
{
	const char *midpoint;
	vm_size_t first_count;
	boolean_t first_result;

	/* Assert that we've been called because of a segment boundary,
	 * this function is more expensive than the assembler, and should
	 * only be called in this difficult case.
	 */
	assert(((vm_offset_t)src & 0xF0000000) !=
	       ((vm_offset_t)(src + count -1) & 0xF0000000));

	/* TODO NMGS define sensible constants for segments, and apply
	 * to C and assembler (assembler is much harder)
	 */
	midpoint = (const char*) ((vm_offset_t)(src + count) & 0xF0000000);
	first_count = (midpoint - src);

	first_result = copyin(src, dst, first_count);
	
	/* If there was an error, stop now and return error */
	if (first_result != 0)
		return first_result;

	/* otherwise finish the job and return result */
	return copyin(midpoint, dst + first_count, count-first_count);
}

extern int copyout_multiple(const char *src, char *dst, vm_size_t count);

int copyout_multiple(const char *src, char *dst, vm_size_t count)
{
	char *midpoint;
	vm_size_t first_count;
	boolean_t first_result;

	/* Assert that we've been called because of a segment boundary,
	 * this function is more expensive than the assembler, and should
	 * only be called in this difficult case. For copyout, the
	 * segment boundary is on the dst
	 */
	assert(((vm_offset_t)dst & 0xF0000000) !=
	       ((vm_offset_t)(dst + count - 1) & 0xF0000000));

	/* TODO NMGS define sensible constants for segments, and apply
	 * to C and assembler (assembler is much harder)
	 */
	midpoint = (char *) ((vm_offset_t)(dst + count) & 0xF0000000);
	first_count = (midpoint - dst);

	first_result = copyout(src, dst, first_count);
	
	/* If there was an error, stop now and return error */
	if (first_result != 0)
		return first_result;

	/* otherwise finish the job and return result */

	return copyout(src + first_count, midpoint, count-first_count);
}

int bcmp(
	const char	*a,
	const char	*b,
	vm_size_t	len)
{
	if (len == 0)
		return 0;

	do
		if (*a++ != *b++)
			break;
	while (--len);  

	return len;
} 

#if DEBUG
void regDump(struct ppc_saved_state *state)
{
	int i;

	for (i=0; i<32; i++) {
		if ((i % 8) == 0)
			kprintf("\n%4d :",i);
			kprintf(" %08x",*(&state->r0+i));
	}

	kprintf("\n");
	kprintf("cr        = 0x%08x\t\t",state->cr);
	kprintf("xer       = 0x%08x\n",state->xer); 
	kprintf("lr        = 0x%08x\t\t",state->lr); 
	kprintf("ctr       = 0x%08x\n",state->ctr); 
	kprintf("srr0(iar) = 0x%08x\t\t",state->srr0); 
	kprintf("srr1(msr) = 0x%08B\n",state->srr1,
		    "\x10\x11""EE\x12PR\x13""FP\x14ME\x15""FE0\x16SE\x18"
		    "FE1\x19""AL\x1a""EP\x1bIT\x1c""DT");
	kprintf("mq        = 0x%08x\t\t",state->mq);
	kprintf("sr_copyin = 0x%08x\n",state->sr_copyin);
	kprintf("\n");

	/* Be nice - for user tasks, generate some stack trace */
	if (state->srr1 & MASK(MSR_PR)) {
		char *addr = (char*)state->r1;
		unsigned int buf[2];
		for (i = 0; i < 8; i++) {
			if (addr == (char*)NULL)
				break;
			if (!copyin(addr,(char*)buf, 2 * sizeof(int))) {
				printf("0x%08x : %08x\n",buf[0],buf[1]);
				addr = (char*)buf[0];
			} else {
				break;
			}
		}
	}
}
#endif /* DEBUG */

#ifdef 0
/*
 * invalidate_cache_for_io
 *
 * Takes cache of those requests which may require to flush the
 * data cache first before invalidation.
 */


void
invalidate_cache_for_io(vm_offset_t area, unsigned count, boolean_t phys)
{
	vm_offset_t aligned_start, aligned_end, end;

	/* For unaligned reads we need to flush any
	 * unaligned cache lines. We invalidate the
	 * rest as this is faster
	 */

	aligned_start = area & ~(CACHE_LINE_SIZE-1);
	if (aligned_start != area)
		flush_dcache(aligned_start, CACHE_LINE_SIZE, phys);

	end = area + count;
	aligned_end = (end & ~(CACHE_LINE_SIZE-1));
	if (aligned_end != end)
		flush_dcache(aligned_end, CACHE_LINE_SIZE, phys);

	invalidate_dcache(area, count, phys);
}

extern void tracecopyin(unsigned int src, unsigned int dest, unsigned int lgn, unsigned int from);
void tracecopyin(unsigned int src, unsigned int dest, unsigned int lgn, unsigned int from) {
	
	spl_t					spl;

	spl = splhigh();
	printf("Copy in called from %08X: src=%08X; dest=%08X; lgn=%08X\n", from, src, dest, lgn);
	splx(spl);
	return;
}

extern void tracecopyout(unsigned int src, unsigned int dest, unsigned int lgn, unsigned int from);
void tracecopyout(unsigned int src, unsigned int dest, unsigned int lgn, unsigned int from) {

	spl_t					spl;

	spl = splhigh();
	printf("Copy out called from %08X: src=%08X; dest=%08X; lgn=%08X\n", from, src, dest, lgn);
	splx(spl);
	return;
}

extern void tracecopystr(unsigned int src, unsigned int dest, unsigned int max, 
	unsigned int lgn, unsigned int from);
void tracecopystr(unsigned int src, unsigned int dest, unsigned int max,
	unsigned int lgn, unsigned int from) {

	spl_t					spl;

	spl = splhigh();
	printf("Copy in string called from %08X: src=%08X; dest=%08X; max=%08X; lgnadr=%08X\n", 
		from, src, dest, max, lgn);
	splx(spl);
	return;
}

unsigned int ExceptionTrace = 0;
extern void ExceptionTracePrint(struct savearea *sv, int type);
void ExceptionTracePrint(struct savearea *sv, int type) {

	spl_t					spl;

	spl = splhigh();
	
	if(type) {
		printf("   Trap from %08X, type=%08X, R0=%08X, R1=%08X, R3=%08X, LR=%08X, AST=%08X\n", 
			sv->save_srr0, sv->save_exception, sv->save_r0, sv->save_r1, sv->save_r3,
			sv->save_lr, need_ast[0]);
	}
	else {
		printf("Syscall from %08X, type=%08X, R0=%08X, R1=%08X, R3=%08X, LR=%08X, AST=%08X\n", 
			sv->save_srr0, sv->save_exception, sv->save_r0, sv->save_r1, sv->save_r3,
			sv->save_lr, need_ast[0]);
	}
	splx(spl);
	return;
}
#endif
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	#include <debug.h>
	26	#include <mach_debug.h>
	27
	28	#include <mach/ppc/thread_status.h>
	29	#include <mach/vm_types.h>
	30	#include <kern/thread.h>
	31	#include <kern/misc_protos.h>
	32	#include <ppc/proc_reg.h>
	33	#include <ppc/pmap.h>
	34	#include <ppc/misc_protos.h>
	35	#include <ppc/exception.h>
	36
	37	/*
	38	* copyin/out_multiple - the assembler copyin/out functions jump to C for
	39	* help when the copyin lies over a segment boundary. The C breaks
	40	* down the copy into two sub-copies and re-calls the assembler with
	41	* these sub-copies. Very rare occurrance. Warning: These functions are
	42	* called whilst active_thread->thread_recover is still set.
	43	*/
	44
	45	extern boolean_t copyin_multiple(const char *src,
	46	char *dst,
	47	vm_size_t count);
	48
	49	boolean_t copyin_multiple(const char *src,
	50	char *dst,
	51	vm_size_t count)
	52	{
	53	const char *midpoint;
	54	vm_size_t first_count;
	55	boolean_t first_result;
	56
	57	/* Assert that we've been called because of a segment boundary,
	58	* this function is more expensive than the assembler, and should
	59	* only be called in this difficult case.
	60	*/
	61	assert(((vm_offset_t)src & 0xF0000000) !=
	62	((vm_offset_t)(src + count -1) & 0xF0000000));
	63
	64	/* TODO NMGS define sensible constants for segments, and apply
65	* to C and assembler (assembler is much harder)
66	*/
67	midpoint = (const char*) ((vm_offset_t)(src + count) & 0xF0000000);
68	first_count = (midpoint - src);
69
70	first_result = copyin(src, dst, first_count);
71
72	/* If there was an error, stop now and return error */
73	if (first_result != 0)
74	return first_result;
75
76	/* otherwise finish the job and return result */
77	return copyin(midpoint, dst + first_count, count-first_count);
78	}
79
80	extern int copyout_multiple(const char src, char dst, vm_size_t count);
81
82	int copyout_multiple(const char src, char dst, vm_size_t count)
83	{
84	char *midpoint;
85	vm_size_t first_count;
86	boolean_t first_result;
87
88	/* Assert that we've been called because of a segment boundary,
89	* this function is more expensive than the assembler, and should
90	* only be called in this difficult case. For copyout, the
91	* segment boundary is on the dst
92	*/
93	assert(((vm_offset_t)dst & 0xF0000000) !=
94	((vm_offset_t)(dst + count - 1) & 0xF0000000));
95
96	/* TODO NMGS define sensible constants for segments, and apply
97	* to C and assembler (assembler is much harder)
98	*/
99	midpoint = (char *) ((vm_offset_t)(dst + count) & 0xF0000000);
100	first_count = (midpoint - dst);
101
102	first_result = copyout(src, dst, first_count);
103
104	/* If there was an error, stop now and return error */
105	if (first_result != 0)
106	return first_result;
107
108	/* otherwise finish the job and return result */
109
110	return copyout(src + first_count, midpoint, count-first_count);
111	}
112
113	int bcmp(
114	const char *a,
115	const char *b,
116	vm_size_t len)
117	{
118	if (len == 0)
119	return 0;
120
121	do
122	if (a++ != b++)
123	break;
124	while (--len);
125
126	return len;
127	}
128
129	#if DEBUG
130	void regDump(struct ppc_saved_state *state)
131	{
132	int i;
133
134	for (i=0; i<32; i++) {
135	if ((i % 8) == 0)
136	kprintf("\n%4d :",i);
137	kprintf(" %08x",*(&state->r0+i));
138	}
139
140	kprintf("\n");
141	kprintf("cr = 0x%08x\t\t",state->cr);
142	kprintf("xer = 0x%08x\n",state->xer);
143	kprintf("lr = 0x%08x\t\t",state->lr);
144	kprintf("ctr = 0x%08x\n",state->ctr);
145	kprintf("srr0(iar) = 0x%08x\t\t",state->srr0);
146	kprintf("srr1(msr) = 0x%08B\n",state->srr1,
147	"\x10\x11""EE\x12PR\x13""FP\x14ME\x15""FE0\x16SE\x18"
148	"FE1\x19""AL\x1a""EP\x1bIT\x1c""DT");
149	kprintf("mq = 0x%08x\t\t",state->mq);
150	kprintf("sr_copyin = 0x%08x\n",state->sr_copyin);
151	kprintf("\n");
152
153	/* Be nice - for user tasks, generate some stack trace */
154	if (state->srr1 & MASK(MSR_PR)) {
155	char addr = (char)state->r1;
156	unsigned int buf[2];
157	for (i = 0; i < 8; i++) {
158	if (addr == (char*)NULL)
159	break;
160	if (!copyin(addr,(char)buf, 2 sizeof(int))) {
161	printf("0x%08x : %08x\n",buf[0],buf[1]);
162	addr = (char*)buf[0];
163	} else {
164	break;
165	}
166	}
167	}
168	}
169	#endif /* DEBUG */
170
171	#ifdef 0
172	/*
173	* invalidate_cache_for_io
174	*
175	* Takes cache of those requests which may require to flush the
176	* data cache first before invalidation.
177	*/
178
179
180	void
181	invalidate_cache_for_io(vm_offset_t area, unsigned count, boolean_t phys)
182	{
183	vm_offset_t aligned_start, aligned_end, end;
184
185	/* For unaligned reads we need to flush any
186	* unaligned cache lines. We invalidate the
187	* rest as this is faster
188	*/
189
190	aligned_start = area & ~(CACHE_LINE_SIZE-1);
191	if (aligned_start != area)
192	flush_dcache(aligned_start, CACHE_LINE_SIZE, phys);
193
194	end = area + count;
195	aligned_end = (end & ~(CACHE_LINE_SIZE-1));
196	if (aligned_end != end)
197	flush_dcache(aligned_end, CACHE_LINE_SIZE, phys);
198
199	invalidate_dcache(area, count, phys);
200	}
201
202	extern void tracecopyin(unsigned int src, unsigned int dest, unsigned int lgn, unsigned int from);
203	void tracecopyin(unsigned int src, unsigned int dest, unsigned int lgn, unsigned int from) {
204
205	spl_t spl;
206
207	spl = splhigh();
208	printf("Copy in called from %08X: src=%08X; dest=%08X; lgn=%08X\n", from, src, dest, lgn);
209	splx(spl);
210	return;
211	}
212
213	extern void tracecopyout(unsigned int src, unsigned int dest, unsigned int lgn, unsigned int from);
214	void tracecopyout(unsigned int src, unsigned int dest, unsigned int lgn, unsigned int from) {
215
216	spl_t spl;
217
218	spl = splhigh();
219	printf("Copy out called from %08X: src=%08X; dest=%08X; lgn=%08X\n", from, src, dest, lgn);
220	splx(spl);
221	return;
222	}
223
224	extern void tracecopystr(unsigned int src, unsigned int dest, unsigned int max,
225	unsigned int lgn, unsigned int from);
226	void tracecopystr(unsigned int src, unsigned int dest, unsigned int max,
227	unsigned int lgn, unsigned int from) {
228
229	spl_t spl;
230
231	spl = splhigh();
232	printf("Copy in string called from %08X: src=%08X; dest=%08X; max=%08X; lgnadr=%08X\n",
233	from, src, dest, max, lgn);
234	splx(spl);
235	return;
236	}
237
238	unsigned int ExceptionTrace = 0;
239	extern void ExceptionTracePrint(struct savearea *sv, int type);
240	void ExceptionTracePrint(struct savearea *sv, int type) {
241
242	spl_t spl;
243
244	spl = splhigh();
245
246	if(type) {
247	printf(" Trap from %08X, type=%08X, R0=%08X, R1=%08X, R3=%08X, LR=%08X, AST=%08X\n",
248	sv->save_srr0, sv->save_exception, sv->save_r0, sv->save_r1, sv->save_r3,
249	sv->save_lr, need_ast[0]);
250	}
251	else {
252	printf("Syscall from %08X, type=%08X, R0=%08X, R1=%08X, R3=%08X, LR=%08X, AST=%08X\n",
253	sv->save_srr0, sv->save_exception, sv->save_r0, sv->save_r1, sv->save_r3,
254	sv->save_lr, need_ast[0]);
255	}
256	splx(spl);
257	return;
258	}
259	#endif