Context Navigation

boot_utils.c @ 664

Last change on this file since 664 was 525, checked in by viala@…, 6 years ago
[boot] Uniformisation of style on some prototypes.
File size: 19.6 KB

Rev	Line
[439]	1	/*
	2	* boot_utils.c - TSAR bootloader utilities implementation.
	3	*
	4	* Authors : Alain Greiner / Vu Son (2016)
	5	*
	6	* Copyright (c) UPMC Sorbonne Universites
	7	*
	8	* This file is part of ALMOS-MKH.
	9	*
	10	* ALMOS-MKH is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; version 2.0 of the License.
	13	*
	14	* ALMOS-MKH is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with ALMOS-MKH; if not, write to the Free Software Foundation,
	21	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	22	*/
	23
	24	#include <stdarg.h>
	25
	26	#include <boot_tty_driver.h>
[457]	27	#include <hal_kernel_types.h>
[439]	28	#include <boot_utils.h>
	29
	30
	31	/****************************************************************************
	32	* Global variables *
	33	****************************************************************************/
	34
	35	extern boot_remote_spinlock_t tty0_lock; // allocated in boot.c
	36
	37	/****************************************************************************
	38	* Remote accesses. *
	39	****************************************************************************/
	40
	41	//////////////////////////////////
	42	uint32_t boot_remote_lw(xptr_t xp)
	43	{
	44	uint32_t res;
	45	uint32_t ptr;
	46	uint32_t cxy;
	47
	48	// Extracting information from the extended pointer
	49	ptr = (uint32_t)GET_PTR(xp);
	50	cxy = (uint32_t)GET_CXY(xp);
	51
	52	// Assembly instructions to get the work done.
	53	asm volatile("mfc2 $15, $24\n" /* $15 <= CP2_DATA_PADDR_EXT */
	54	"mtc2 %2, $24\n" /* CP2_DATA_PADDR_EXT <= cxy */
	55	"lw %0, 0(%1)\n" /* ptr <= data /
	56	"mtc2 $15, $24\n" /* CP2_DATA_PADDR_EXT <= $15 */
	57	"sync \n"
	58	: "=&r"(res) /* Temporary register so that it
	59	doesn't overlap the other inputs
	60	or outputs. */
	61	: "r"(ptr), "r"(cxy)
	62	: "$15"
	63	);
	64
	65	return res;
	66
	67	} // boot_remote_lw()
	68
	69	/////////////////////////////////////////////
	70	void boot_remote_sw(xptr_t xp, uint32_t data)
	71	{
	72	uint32_t ptr; /* Classic pointer to the distant memory location. */
	73	uint32_t cxy; /* Identifier of the cluster containing the distant
	74	memory location. */
	75
	76	/* Extracting information from the extended pointers. */
	77	ptr = (uint32_t)GET_PTR(xp);
	78	cxy = (uint32_t)GET_CXY(xp);
	79
	80	/* Assembly instructions to get the work done. */
	81	asm volatile("mfc2 $15, $24\n" /* $15 <= CP2_DATA_PADDR_EXT */
	82	"mtc2 %2, $24\n" /* CP2_DATA_PADDR_EXT <= cxy */
	83	"sw %0, 0(%1)\n" /* ptr <= data /
	84	"mtc2 $15, $24\n" /* CP2_DATA_PADDR_EXT <= $15 */
	85	"sync \n"
	86	:
	87	: "r"(data), "r"(ptr), "r"(cxy)
	88	: "$15", "memory"
	89	);
	90
	91	} // boot_remote_sw()
	92
	93	//////////////////////////////////////////////////////
	94	int32_t boot_remote_atomic_add(xptr_t xp, int32_t val)
	95	{
	96	int32_t res; /* Value stored at the distant memory location before
	97	the atomic operation. */
	98	uint32_t ptr; /* Classic pointer to the distant memory location. */
	99	uint32_t cxy; /* Identifier of the cluster containing the distant
	100	memory location. */
	101
	102	/* Extracting information from the extended pointers. */
	103	ptr = (uint32_t)GET_PTR(xp);
	104	cxy = (uint32_t)GET_CXY(xp);
	105
	106	/* Assembly instructions to get the work done. */
	107	asm volatile("mfc2 $15, $24 \n" /* $15 <= CP2_DATA_PADDR_EXT */
	108	"mtc2 %3, $24 \n" /* CP2_DATA_PADDR_EXT <= cxy */
	109	"1: \n"
	110	"ll %0, 0(%1) \n" /* res <= ptr /
	111	"addu $3, %0, %2\n" /* $3 <= res + val */
	112	"sc $3, 0(%1) \n" /* ptr <= $3 /
	113	"beq $3, $0, 1b\n" /* Retry until success. */
	114	"nop \n" /* Delayed slot. */
	115	"mtc2 $15, $24 \n" /* CP2_DATA_PADDR_EXT <= $15 */
	116	"sync \n"
	117	: "=&r"(res) /* Temporary register so that
	118	it doesn't overlap the other
	119	inputs or outputs. */
	120	: "r"(ptr), "r"(val), "r"(cxy)
	121	: "$3", "$15", "memory"
	122	);
	123
	124	return res;
	125
	126	} // boot_remote_atomic_add()
	127
	128	///////////////////////////////////////////////////////////////
	129	void boot_remote_memcpy(xptr_t dest, xptr_t src, uint32_t size)
	130	{
	131	uint32_t words_nr; /* Number of 32-bit words to be copied. */
	132	uint32_t dptr; /* Classic pointer to the destination buffer. */
	133	uint32_t dcxy; /* Identifier of the cluster containing the
	134	destination buffer. */
	135	uint32_t sptr; /* Classic pointer to the source buffer. */
	136	uint32_t scxy; /* Identifier of the cluster containing the
	137	source buffer. */
	138	uint32_t i; /* Iterator for memory copying loop. */
	139
	140	/* Extracting information from the extended pointers. */
	141	dptr = (uint32_t)GET_PTR(dest);
	142	dcxy = (uint32_t)GET_CXY(dest);
	143	sptr = (uint32_t)GET_PTR(src);
	144	scxy = (uint32_t)GET_CXY(src);
	145
	146	/*
	147	* Testing if we could perform word-by-word copy (if both addresses are
	148	* word-aligned).
	149	*/
	150	if ((dptr & 0x3) \|\| (sptr & 0x3))
	151	words_nr = 0;
	152	else
	153	words_nr = size >> 2;
	154
	155	/* Copying word-by-word. */
	156	for (i = 0; i < words_nr; i++)
	157	{
	158	asm volatile("mfc2 $15, $24\n" /* $15 <= CP2_DATA_PADDR_EXT */
	159	"mtc2 %0, $24\n" /* CP2_DATA_PADDR_EXT <= scxy */
	160	"lw $3, 0(%1)\n" /* $3 <= (sptr + 4i) */
	161	"mtc2 %2, $24\n" /* CP2_DATA_PADDR_EXT <= dcxy */
	162	"sw $3, 0(%3)\n" /* (dptr + 4i) <= $3 */
	163	"mtc2 $15, $24\n" /* CP2_DATA_PADDR_EXT <= $15 */
	164	"sync \n"
	165	:
	166	: "r"(scxy), "r"(sptr + (i << 2)),
	167	"r"(dcxy), "r"(dptr + (i << 2))
	168	: "$3", "$15", "memory"
	169	);
	170	}
	171
	172	/* Copying byte-by-byte if there is any left. */
	173	for (i = words_nr << 2; i < size; i++)
	174	{
	175	asm volatile("mfc2 $15, $24\n" /* $15 <= CP2_DATA_PADDR_EXT */
	176	"mtc2 %0, $24\n" /* CP2_DATA_PADDR_EXT <= scxy */
	177	"lb $3, 0(%1)\n" /* $3 <= (sptr + i) /
	178	"mtc2 %2, $24\n" /* CP2_DATA_PADDR_EXT <= dcxy */
	179	"sb $3, 0(%3)\n" /* (dptr + i) <= $3 /
	180	"mtc2 $15, $24\n" /* CP2_DATA_PADDR_EXT <= $15 */
	181	"sync \n"
	182	:
	183	: "r"(scxy), "r"(sptr + i),
	184	"r"(dcxy), "r"(dptr + i)
	185	: "$3", "$15", "memory"
	186	);
	187	}
	188
	189	} // boot_remote_memcpy()
	190
	191	/****************************************************************************
	192	* Atomic operations. *
	193	****************************************************************************/
	194
	195	int32_t boot_atomic_add(int32_t* ptr, int32_t val)
	196	{
	197	int32_t res; /* Value of the variable before the atomic operation. */
	198
	199	asm volatile(".set noreorder \n"
	200	"1: \n"
	201	"ll %0, 0(%1) \n" /* res <= ptr /
	202	"addu $3, %0, %2\n" /* $3 <= res + val */
	203	"sc $3, 0(%1) \n" /* $ptr <= $3 */
	204	"beq $3, $0, 1b\n" /* Retry until success. */
	205	"nop \n"
	206	"sync \n"
	207	".set reorder \n"
	208	: "=&r"(res) /* Temporary register so that it
	209	doesn't overlap the other
	210	inputs or outputs. */
	211	: "r"(ptr), "r"(val)
	212	: "$3", "memory"
	213	);
	214
	215	return res;
	216
	217	} // boot_atomic_add()
	218
	219	/****************************************************************************
	220	* Memory functions. *
	221	****************************************************************************/
	222
	223	///////////////////////////////////////////////////////
[525]	224	void boot_memcpy( void * dst, const void * src, uint32_t size )
[439]	225	{
	226	uint32_t * wdst = dst;
[525]	227	const uint32_t * wsrc = src;
[439]	228
	229	// word-by-word copy if both addresses are word-aligned
	230	if ( (((uint32_t)dst & 0x3) == 0) && (((uint32_t)src & 0x3) == 0) )
	231	{
	232	while (size > 3)
	233	{
	234	wdst++ = wsrc++;
	235	size -= 4;
	236	}
	237	}
	238
	239	unsigned char * cdst = (unsigned char *)wdst;
[525]	240	const unsigned char * csrc = (const unsigned char *)wsrc;
[439]	241
	242	// byte-by-byte copy if:
	243	// - At least 1 of the 2 addresses is not word-aligned,
	244	// - 'size' value is not a multiple of 4 bytes.
	245	while (size)
	246	{
	247	cdst++ = csrc++;
	248	}
	249	} // boot_memcpy()
	250
	251	////////////////////////////////////////////////////
[525]	252	void boot_memset( void * dst, int val, uint32_t size )
[439]	253	{
	254	val &= 0xFF;
	255
	256	// build a word-sized value
	257	uint32_t wval = (val << 24) \| (val << 16) \| (val << 8) \| val;
	258	uint32_t * wdst = (uint32_t *)dst;
	259
	260	// word per word if address aligned
	261	if (((uint32_t)dst & 0x3) == 0)
	262	{
	263	while (size > 3)
	264	{
	265	*wdst++ = wval;
	266	size -= 4;
	267	}
	268	}
	269
	270	char * cdst = (char *)wdst;
	271
	272	// byte per byte
	273	while (size--)
	274	{
	275	*cdst++ = (char)val;
	276	}
	277	} // boot_memset()
	278
	279	/****************************************************************************
	280	* String functions. *
	281	****************************************************************************/
	282
	283	///////////////////////////////////////
[521]	284	void boot_strcpy( char * dest, const char * src)
[439]	285	{
	286	/* Copying the string. */
	287	while ((dest++ = src++) != '\0');
	288
	289	} // boot_strcpy()
	290
	291	/////////////////////////////
[521]	292	uint32_t boot_strlen( const char * s )
[439]	293	{
	294	uint32_t res = 0; /* Length of the string (in bytes). */
[523]	295	while (*s++ != '\0') {
	296	res++;
[439]	297	}
	298
	299	return res;
	300	} // boot_strlen()
	301
	302	///////////////////////////////////
[521]	303	int boot_strcmp( const char * s1, const char * s2 )
[439]	304	{
[523]	305	if (s1 == s2)
[439]	306	return 0;
	307
	308	while (1)
	309	{
	310	if (s1 != s2)
	311	return 1;
	312	if (*s1 == '\0')
	313	break;
	314	s1++;
	315	s2++;
	316	}
	317
	318	return 0;
	319
	320	} // boot_strcmp()
	321
	322	/****************************************************************************
	323	* Display functions. *
	324	****************************************************************************/
	325
	326	/////////////////////////
[521]	327	void boot_puts( const char * str )
[439]	328	{
	329	boot_tty_write(str, boot_strlen(str));
	330
	331	} // boot_puts()
	332
	333	///////////////////////////////////////
[521]	334	void boot_printf( const char * format , ... )
[439]	335	{
	336	va_list args;
	337	va_start( args , format );
	338
	339	// take the lock protecting TTY0
	340	boot_remote_lock( XPTR( 0 , &tty0_lock ) );
	341
	342	printf_text:
	343
	344	while ( *format )
	345	{
	346	uint32_t i;
	347	for (i = 0 ; format[i] && (format[i] != '%') ; i++);
	348	if (i)
	349	{
	350	boot_tty_write( format , i );
	351	format += i;
	352	}
	353	if (*format == '%')
	354	{
	355	format++;
	356	goto printf_arguments;
	357	}
	358	}
	359
	360	// release the lock
	361	boot_remote_unlock( XPTR( 0 , &tty0_lock ) );
	362
	363	va_end( args );
	364	return;
	365
	366	printf_arguments:
	367
	368	{
	369	char buf[20];
	370	char * pbuf = NULL;
	371	uint32_t len = 0;
	372	static const char HexaTab[] = "0123456789ABCDEF";
	373	uint32_t i;
	374
	375	switch (*format++)
	376	{
	377	case ('c'): /* char conversion */
	378	{
	379	int val = va_arg( args , int );
	380	len = 1;
	381	buf[0] = val;
	382	pbuf = &buf[0];
	383	break;
	384	}
	385	case ('d'): /* 32 bits decimal signed */
	386	{
	387	int val = va_arg( args , int );
	388	if (val < 0)
	389	{
	390	val = -val;
	391	boot_tty_write( "-" , 1 );
	392	}
	393	for(i = 0; i < 10; i++)
	394	{
	395	buf[9 - i] = HexaTab[val % 10];
	396	if (!(val /= 10)) break;
	397	}
	398	len = i + 1;
	399	pbuf = &buf[9 - i];
	400	break;
	401	}
	402	case ('u'): /* 32 bits decimal unsigned */
	403	{
	404	uint32_t val = va_arg( args , uint32_t );
	405	for(i = 0; i < 10; i++)
	406	{
	407	buf[9 - i] = HexaTab[val % 10];
	408	if (!(val /= 10)) break;
	409	}
	410	len = i + 1;
	411	pbuf = &buf[9 - i];
	412	break;
	413	}
	414	case ('x'): /* 32 bits hexadecimal unsigned */
	415	{
	416	uint32_t val = va_arg( args , uint32_t );
	417	boot_tty_write( "0x" , 2 );
	418	for(i = 0; i < 8; i++)
	419	{
	420	buf[7 - i] = HexaTab[val & 0xF];
	421	if (!(val = (val>>4))) break;
	422	}
	423	len = i + 1;
	424	pbuf = &buf[7 - i];
	425	break;
	426	}
	427	case ('X'): /* 32 bits hexadecimal unsigned on 10 char */
	428	{
	429	uint32_t val = va_arg( args , uint32_t );
	430	boot_tty_write( "0x" , 2 );
	431	for(i = 0; i < 8; i++)
	432	{
	433	buf[7 - i] = HexaTab[val & 0xF];
	434	val = (val>>4);
	435	}
	436	len = 8;
	437	pbuf = buf;
	438	break;
	439	}
	440	case ('l'): /* 64 bits hexadecimal unsigned */
	441	{
	442	uint64_t val = va_arg( args , uint64_t );
	443	boot_tty_write( "0x" , 2 );
	444	for(i = 0; i < 16; i++)
	445	{
	446	buf[15 - i] = HexaTab[val & 0xF];
	447	if (!(val = (val>>4))) break;
	448	}
	449	len = i + 1;
	450	pbuf = &buf[15 - i];
	451	break;
	452	}
	453	case ('L'): /* 64 bits hexadecimal unsigned on 18 char */
	454	{
	455	uint64_t val = va_arg( args , uint64_t );
	456	boot_tty_write( "0x" , 2 );
	457	for(i = 0; i < 16; i++)
	458	{
	459	buf[15 - i] = HexaTab[val & 0xF];
	460	val = (val>>4);
	461	}
	462	len = 16;
	463	pbuf = buf;
	464	break;
	465	}
	466	case ('s'): /* string */
	467	{
	468	char* str = va_arg( args , char* );
	469	while (str[len])
	470	{
	471	len++;
	472	}
	473	pbuf = str;
	474	break;
	475	}
	476	default:
	477	{
	478	boot_tty_write( "\n[PANIC] in boot_printf() : illegal format\n", 43 );
	479	}
	480	}
	481
	482	if( pbuf != NULL ) boot_tty_write( pbuf, len );
	483
	484	goto printf_text;
	485	}
	486	} // boot_printf()
	487
	488
	489
	490
	491
	492
	493	/****************************************************************************
	494	* Misc. functions. *
	495	****************************************************************************/
	496
	497	////////////////
[474]	498	void boot_exit( void )
[439]	499	{
	500	boot_printf("\n[BOOT PANIC] core %x suicide at cycle %d...\n",
	501	boot_get_procid() , boot_get_proctime() );
	502
	503	while (1) asm volatile ("nop");
	504
	505	} // boot_exit()
	506
	507	////////////////////////////
[474]	508	uint32_t boot_get_proctime( void )
[439]	509	{
	510	uint32_t res; /* Value stored in the CP0_COUNT register. */
	511
	512	asm volatile("mfc0 %0, $9" : "=r"(res));
	513
	514	return res;
	515
	516	} // boot_get_proctime()
	517
	518
	519	//////////////////////////
[474]	520	uint32_t boot_get_procid( void )
[439]	521	{
	522	uint32_t res; /* Value stored in the CP0_PROCID register. */
	523
	524	asm volatile("mfc0 %0, $15, 1" : "=r"(res));
	525
	526	return (res & 0xFFF);
	527
	528	} // boot_get_procid()
	529
	530
	531	////////////////////////////////////////////////
	532	void boot_remote_barrier( xptr_t xp_barrier,
	533	uint32_t count)
	534	{
	535	boot_remote_barrier_t * ptr;
	536	uint32_t cxy;
	537	uint32_t expected;
	538	uint32_t current;
	539
	540	// Extract information from the extended pointer
	541	ptr = (boot_remote_barrier_t*)GET_PTR(xp_barrier);
	542	cxy = (uint32_t) GET_CXY(xp_barrier);
	543
	544	// Explicitly test the barrier sense value because no initialization
	545	if (boot_remote_lw(XPTR(cxy, &ptr->sense)) == 0) expected = 1;
	546	else expected = 0;
	547
	548	// Atomically increment counter
	549	current = boot_remote_atomic_add(XPTR(cxy, &ptr->current), 1);
	550
	551	// The processor arrived last resets the barrier and toggles its sense
	552	if (current == (count - 1))
	553	{
	554	boot_remote_sw(XPTR(cxy, &ptr->current), 0);
	555	boot_remote_sw(XPTR(cxy, &ptr->sense), expected);
	556	}
	557	// Other processors poll the sense
	558	else
	559	{
	560	while (boot_remote_lw(XPTR(cxy, &ptr->sense)) != expected);
	561	}
	562
	563	} // boot_barrier()
	564
	565	////////////////////////////////////////
	566	void boot_remote_lock( xptr_t lock_xp )
	567
	568	{
	569	// Extract information from the extended pointer
	570	boot_remote_spinlock_t * ptr = (boot_remote_spinlock_t *)GET_PTR( lock_xp );
	571	uint32_t cxy = GET_CXY( lock_xp );
	572
	573	// get next free ticket
	574	uint32_t ticket = boot_remote_atomic_add( XPTR( cxy , &ptr->ticket ) , 1 );
	575
	576	// poll the current slot index
	577	while ( boot_remote_lw( XPTR( cxy , &ptr->current ) ) != ticket )
	578	{
	579	asm volatile ("nop");
	580	}
	581
	582	} // boot_remote_lock()
	583
	584	/////////////////////////////////////////
	585	void boot_remote_unlock( xptr_t lock_xp )
	586	{
	587	asm volatile ( "sync" ); // for consistency
	588
	589	// Extract information from the extended pointer
	590	boot_remote_spinlock_t * ptr = (boot_remote_spinlock_t *)GET_PTR( lock_xp );
	591	uint32_t cxy = GET_CXY( lock_xp );
	592	xptr_t current_xp = XPTR( cxy , &ptr->current );
	593
	594	// get current index value
	595	uint32_t current = boot_remote_lw( current_xp );
	596
	597	// increment current index
	598	boot_remote_sw( current_xp , current + 1 );
	599
	600	} // boot_remote_unlock()
	601
	602

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/boot/tsar_mips32/boot_utils.c @ 664

Download in other formats: