[J-u-boot.git] / cmd / mfsl.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2007 Michal Simek
 *
 * Michal  SIMEK <[email protected]>
 */

/*
 * Microblaze FSL support
 */

#include <common.h>
#include <config.h>
#include <command.h>
#include <asm/asm.h>

int do_frd (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	unsigned int fslnum;
	unsigned int num;
	unsigned int blocking;

	if (argc < 2)
		return CMD_RET_USAGE;

	fslnum = (unsigned int)simple_strtoul (argv[1], NULL, 16);
	blocking = (unsigned int)simple_strtoul (argv[2], NULL, 16);
	if (fslnum < 0 || fslnum >= XILINX_FSL_NUMBER) {
		puts ("Bad number of FSL\n");
		return CMD_RET_USAGE;
	}

	switch (fslnum) {
#if (XILINX_FSL_NUMBER > 0)
	case 0:
		switch (blocking) {
		case 0:	NGET (num, 0);
			break;
		case 1:	NCGET (num, 0);
			break;
		case 2:	GET (num, 0);
			break;
		case 3:	CGET (num, 0);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 1)
	case 1:
		switch (blocking) {
		case 0:	NGET (num, 1);
			break;
		case 1:	NCGET (num, 1);
			break;
		case 2:	GET (num, 1);
			break;
		case 3:	CGET (num, 1);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 2)
	case 2:
		switch (blocking) {
		case 0:	NGET (num, 2);
			break;
		case 1:	NCGET (num, 2);
			break;
		case 2:	GET (num, 2);
			break;
		case 3:	CGET (num, 2);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 3)
	case 3:
		switch (blocking) {
		case 0:	NGET (num, 3);
			break;
		case 1:	NCGET (num, 3);
			break;
		case 2:	GET (num, 3);
			break;
		case 3:	CGET (num, 3);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 4)
	case 4:
		switch (blocking) {
		case 0:	NGET (num, 4);
			break;
		case 1:	NCGET (num, 4);
			break;
		case 2:	GET (num, 4);
			break;
		case 3:	CGET (num, 4);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 5)
	case 5:
		switch (blocking) {
		case 0:	NGET (num, 5);
			break;
		case 1:	NCGET (num, 5);
			break;
		case 2:	GET (num, 5);
			break;
		case 3:	CGET (num, 5);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 6)
	case 6:
		switch (blocking) {
		case 0:	NGET (num, 6);
			break;
		case 1:	NCGET (num, 6);
			break;
		case 2:	GET (num, 6);
			break;
		case 3:	CGET (num, 6);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 7)
	case 7:
		switch (blocking) {
		case 0:	NGET (num, 7);
			break;
		case 1:	NCGET (num, 7);
			break;
		case 2:	GET (num, 7);
			break;
		case 3:	CGET (num, 7);
			break;
		default:
			return 2;
		}
		break;
#endif
	default:
		return 1;
	}

	printf ("%01x: 0x%08x - %s %s read\n", fslnum, num,
		blocking < 2  ? "non blocking" : "blocking",
		((blocking == 1) || (blocking == 3)) ? "control" : "data" );
	return 0;
}

int do_fwr (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	unsigned int fslnum;
	unsigned int num;
	unsigned int blocking;

	if (argc < 3)
		return CMD_RET_USAGE;

	fslnum = (unsigned int)simple_strtoul (argv[1], NULL, 16);
	num = (unsigned int)simple_strtoul (argv[2], NULL, 16);
	blocking = (unsigned int)simple_strtoul (argv[3], NULL, 16);
	if (fslnum < 0 || fslnum >= XILINX_FSL_NUMBER)
		return CMD_RET_USAGE;

	switch (fslnum) {
#if (XILINX_FSL_NUMBER > 0)
	case 0:
		switch (blocking) {
		case 0:	NPUT (num, 0);
			break;
		case 1:	NCPUT (num, 0);
			break;
		case 2:	PUT (num, 0);
			break;
		case 3:	CPUT (num, 0);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 1)
	case 1:
		switch (blocking) {
		case 0:	NPUT (num, 1);
			break;
		case 1:	NCPUT (num, 1);
			break;
		case 2:	PUT (num, 1);
			break;
		case 3:	CPUT (num, 1);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 2)
	case 2:
		switch (blocking) {
		case 0:	NPUT (num, 2);
			break;
		case 1:	NCPUT (num, 2);
			break;
		case 2:	PUT (num, 2);
			break;
		case 3:	CPUT (num, 2);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 3)
	case 3:
		switch (blocking) {
		case 0:	NPUT (num, 3);
			break;
		case 1:	NCPUT (num, 3);
			break;
		case 2:	PUT (num, 3);
			break;
		case 3:	CPUT (num, 3);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 4)
	case 4:
		switch (blocking) {
		case 0:	NPUT (num, 4);
			break;
		case 1:	NCPUT (num, 4);
			break;
		case 2:	PUT (num, 4);
			break;
		case 3:	CPUT (num, 4);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 5)
	case 5:
		switch (blocking) {
		case 0:	NPUT (num, 5);
			break;
		case 1:	NCPUT (num, 5);
			break;
		case 2:	PUT (num, 5);
			break;
		case 3:	CPUT (num, 5);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 6)
	case 6:
		switch (blocking) {
		case 0:	NPUT (num, 6);
			break;
		case 1:	NCPUT (num, 6);
			break;
		case 2:	PUT (num, 6);
			break;
		case 3:	CPUT (num, 6);
			break;
		default:
			return 2;
		}
		break;
#endif
#if (XILINX_FSL_NUMBER > 7)
	case 7:
		switch (blocking) {
		case 0:	NPUT (num, 7);
			break;
		case 1:	NCPUT (num, 7);
			break;
		case 2:	PUT (num, 7);
			break;
		case 3:	CPUT (num, 7);
			break;
		default:
			return 2;
		}
		break;
#endif
	default:
		return 1;
	}

	printf ("%01x: 0x%08x - %s %s write\n", fslnum, num,
		blocking < 2  ? "non blocking" : "blocking",
		((blocking == 1) || (blocking == 3)) ? "control" : "data" );
	return 0;

}

int do_rspr (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	unsigned int reg = 0;
	unsigned int val = 0;

	if (argc < 2)
		return CMD_RET_USAGE;

	reg = (unsigned int)simple_strtoul (argv[1], NULL, 16);
	val = (unsigned int)simple_strtoul (argv[2], NULL, 16);
	switch (reg) {
	case 0x1:
		if (argc > 2) {
			MTS (val, rmsr);
			NOP;
			MFS (val, rmsr);
		} else {
			MFS (val, rmsr);
		}
		puts ("MSR");
		break;
	case 0x3:
		MFS (val, rear);
		puts ("EAR");
		break;
	case 0x5:
		MFS (val, resr);
		puts ("ESR");
		break;
	default:
		puts ("Unsupported register\n");
		return 1;
	}
	printf (": 0x%08x\n", val);
	return 0;
}

/***************************************************/

U_BOOT_CMD (frd, 3, 1, do_frd,
		"read data from FSL",
		"- [fslnum [0|1|2|3]]\n"
		" 0 - non blocking data read\n"
		" 1 - non blocking control read\n"
		" 2 - blocking data read\n"
		" 3 - blocking control read");

U_BOOT_CMD (fwr, 4, 1, do_fwr,
		"write data to FSL",
		"- [fslnum [0|1|2|3]]\n"
		" 0 - non blocking data write\n"
		" 1 - non blocking control write\n"
		" 2 - blocking data write\n"
		" 3 - blocking control write");

U_BOOT_CMD (rspr, 3, 1, do_rspr,
		"read/write special purpose register",
		"- reg_num [write value] read/write special purpose register\n"
		" 1 - MSR - Machine status register\n"
		" 3 - EAR - Exception address register\n"
		" 5 - ESR - Exception status register");
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
100ea07e MS	2	/*
	3	* (C) Copyright 2007 Michal Simek
	4	*
	5	* Michal SIMEK <[email protected]>
f7e2e0eb MS	6	*/
	7
	8	/*
	9	* Microblaze FSL support
	10	*/
	11
	12	#include <common.h>
	13	#include <config.h>
	14	#include <command.h>
70124c26	15	#include <asm/asm.h>
f7e2e0eb	16
54841ab5	17	int do_frd (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
f7e2e0eb MS	18	{
	19	unsigned int fslnum;
	20	unsigned int num;
	21	unsigned int blocking;
	22
47e26b1b	23	if (argc < 2)
4c12eeb8	24	return CMD_RET_USAGE;
f7e2e0eb MS	25
	26	fslnum = (unsigned int)simple_strtoul (argv[1], NULL, 16);
	27	blocking = (unsigned int)simple_strtoul (argv[2], NULL, 16);
	28	if (fslnum < 0 \|\| fslnum >= XILINX_FSL_NUMBER) {
	29	puts ("Bad number of FSL\n");
4c12eeb8	30	return CMD_RET_USAGE;
f7e2e0eb MS	31	}
	32
	33	switch (fslnum) {
	34	#if (XILINX_FSL_NUMBER > 0)
	35	case 0:
ab874d50 MS	36	switch (blocking) {
	37	case 0: NGET (num, 0);
	38	break;
	39	case 1: NCGET (num, 0);
	40	break;
	41	case 2: GET (num, 0);
	42	break;
	43	case 3: CGET (num, 0);
	44	break;
	45	default:
	46	return 2;
f7e2e0eb MS	47	}
	48	break;
	49	#endif
	50	#if (XILINX_FSL_NUMBER > 1)
	51	case 1:
ab874d50 MS	52	switch (blocking) {
	53	case 0: NGET (num, 1);
	54	break;
	55	case 1: NCGET (num, 1);
	56	break;
	57	case 2: GET (num, 1);
	58	break;
	59	case 3: CGET (num, 1);
	60	break;
	61	default:
	62	return 2;
f7e2e0eb MS	63	}
	64	break;
	65	#endif
	66	#if (XILINX_FSL_NUMBER > 2)
	67	case 2:
ab874d50 MS	68	switch (blocking) {
	69	case 0: NGET (num, 2);
	70	break;
	71	case 1: NCGET (num, 2);
	72	break;
	73	case 2: GET (num, 2);
	74	break;
	75	case 3: CGET (num, 2);
	76	break;
	77	default:
	78	return 2;
f7e2e0eb MS	79	}
	80	break;
	81	#endif
	82	#if (XILINX_FSL_NUMBER > 3)
	83	case 3:
ab874d50 MS	84	switch (blocking) {
	85	case 0: NGET (num, 3);
	86	break;
	87	case 1: NCGET (num, 3);
	88	break;
	89	case 2: GET (num, 3);
	90	break;
	91	case 3: CGET (num, 3);
	92	break;
	93	default:
	94	return 2;
f7e2e0eb MS	95	}
	96	break;
	97	#endif
	98	#if (XILINX_FSL_NUMBER > 4)
	99	case 4:
ab874d50 MS	100	switch (blocking) {
	101	case 0: NGET (num, 4);
	102	break;
	103	case 1: NCGET (num, 4);
	104	break;
	105	case 2: GET (num, 4);
	106	break;
	107	case 3: CGET (num, 4);
	108	break;
	109	default:
	110	return 2;
f7e2e0eb MS	111	}
	112	break;
	113	#endif
	114	#if (XILINX_FSL_NUMBER > 5)
	115	case 5:
ab874d50 MS	116	switch (blocking) {
	117	case 0: NGET (num, 5);
	118	break;
	119	case 1: NCGET (num, 5);
	120	break;
	121	case 2: GET (num, 5);
	122	break;
	123	case 3: CGET (num, 5);
	124	break;
	125	default:
	126	return 2;
f7e2e0eb MS	127	}
	128	break;
	129	#endif
	130	#if (XILINX_FSL_NUMBER > 6)
	131	case 6:
ab874d50 MS	132	switch (blocking) {
	133	case 0: NGET (num, 6);
	134	break;
	135	case 1: NCGET (num, 6);
	136	break;
	137	case 2: GET (num, 6);
	138	break;
	139	case 3: CGET (num, 6);
	140	break;
	141	default:
	142	return 2;
f7e2e0eb MS	143	}
	144	break;
	145	#endif
	146	#if (XILINX_FSL_NUMBER > 7)
	147	case 7:
ab874d50 MS	148	switch (blocking) {
	149	case 0: NGET (num, 7);
	150	break;
	151	case 1: NCGET (num, 7);
	152	break;
	153	case 2: GET (num, 7);
	154	break;
	155	case 3: CGET (num, 7);
	156	break;
	157	default:
	158	return 2;
f7e2e0eb MS	159	}
	160	break;
	161	#endif
	162	default:
	163	return 1;
	164	}
	165
f2302d44	166	printf ("%01x: 0x%08x - %s %s read\n", fslnum, num,
ab874d50 MS	167	blocking < 2 ? "non blocking" : "blocking",
ab874d50 MS	168	((blocking == 1) \|\| (blocking == 3)) ? "control" : "data" );
f7e2e0eb MS	169	return 0;
	170	}
	171
54841ab5	172	int do_fwr (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
f7e2e0eb MS	173	{
	174	unsigned int fslnum;
	175	unsigned int num;
	176	unsigned int blocking;
	177
47e26b1b	178	if (argc < 3)
4c12eeb8	179	return CMD_RET_USAGE;
f7e2e0eb MS	180
	181	fslnum = (unsigned int)simple_strtoul (argv[1], NULL, 16);
	182	num = (unsigned int)simple_strtoul (argv[2], NULL, 16);
	183	blocking = (unsigned int)simple_strtoul (argv[3], NULL, 16);
47e26b1b	184	if (fslnum < 0 \|\| fslnum >= XILINX_FSL_NUMBER)
4c12eeb8	185	return CMD_RET_USAGE;
f7e2e0eb MS	186
	187	switch (fslnum) {
	188	#if (XILINX_FSL_NUMBER > 0)
	189	case 0:
ab874d50 MS	190	switch (blocking) {
	191	case 0: NPUT (num, 0);
	192	break;
	193	case 1: NCPUT (num, 0);
	194	break;
	195	case 2: PUT (num, 0);
	196	break;
	197	case 3: CPUT (num, 0);
	198	break;
	199	default:
	200	return 2;
f7e2e0eb MS	201	}
	202	break;
	203	#endif
	204	#if (XILINX_FSL_NUMBER > 1)
	205	case 1:
ab874d50 MS	206	switch (blocking) {
	207	case 0: NPUT (num, 1);
	208	break;
	209	case 1: NCPUT (num, 1);
	210	break;
	211	case 2: PUT (num, 1);
	212	break;
	213	case 3: CPUT (num, 1);
	214	break;
	215	default:
	216	return 2;
f7e2e0eb MS	217	}
	218	break;
	219	#endif
	220	#if (XILINX_FSL_NUMBER > 2)
	221	case 2:
ab874d50 MS	222	switch (blocking) {
	223	case 0: NPUT (num, 2);
	224	break;
	225	case 1: NCPUT (num, 2);
	226	break;
	227	case 2: PUT (num, 2);
	228	break;
	229	case 3: CPUT (num, 2);
	230	break;
	231	default:
	232	return 2;
f7e2e0eb MS	233	}
	234	break;
	235	#endif
	236	#if (XILINX_FSL_NUMBER > 3)
	237	case 3:
ab874d50 MS	238	switch (blocking) {
	239	case 0: NPUT (num, 3);
	240	break;
	241	case 1: NCPUT (num, 3);
	242	break;
	243	case 2: PUT (num, 3);
	244	break;
	245	case 3: CPUT (num, 3);
	246	break;
	247	default:
	248	return 2;
f7e2e0eb MS	249	}
	250	break;
	251	#endif
	252	#if (XILINX_FSL_NUMBER > 4)
	253	case 4:
ab874d50 MS	254	switch (blocking) {
	255	case 0: NPUT (num, 4);
	256	break;
	257	case 1: NCPUT (num, 4);
	258	break;
	259	case 2: PUT (num, 4);
	260	break;
	261	case 3: CPUT (num, 4);
	262	break;
	263	default:
	264	return 2;
f7e2e0eb MS	265	}
	266	break;
	267	#endif
	268	#if (XILINX_FSL_NUMBER > 5)
	269	case 5:
ab874d50 MS	270	switch (blocking) {
	271	case 0: NPUT (num, 5);
	272	break;
	273	case 1: NCPUT (num, 5);
	274	break;
	275	case 2: PUT (num, 5);
	276	break;
	277	case 3: CPUT (num, 5);
	278	break;
	279	default:
	280	return 2;
f7e2e0eb MS	281	}
	282	break;
	283	#endif
	284	#if (XILINX_FSL_NUMBER > 6)
	285	case 6:
ab874d50 MS	286	switch (blocking) {
	287	case 0: NPUT (num, 6);
	288	break;
	289	case 1: NCPUT (num, 6);
	290	break;
	291	case 2: PUT (num, 6);
	292	break;
	293	case 3: CPUT (num, 6);
	294	break;
	295	default:
	296	return 2;
f7e2e0eb MS	297	}
	298	break;
	299	#endif
	300	#if (XILINX_FSL_NUMBER > 7)
	301	case 7:
ab874d50 MS	302	switch (blocking) {
	303	case 0: NPUT (num, 7);
	304	break;
	305	case 1: NCPUT (num, 7);
	306	break;
	307	case 2: PUT (num, 7);
	308	break;
	309	case 3: CPUT (num, 7);
	310	break;
	311	default:
	312	return 2;
f7e2e0eb MS	313	}
	314	break;
	315	#endif
	316	default:
	317	return 1;
	318	}
	319
f2302d44	320	printf ("%01x: 0x%08x - %s %s write\n", fslnum, num,
ab874d50 MS	321	blocking < 2 ? "non blocking" : "blocking",
ab874d50 MS	322	((blocking == 1) \|\| (blocking == 3)) ? "control" : "data" );
f7e2e0eb MS	323	return 0;
	324
	325	}
	326
54841ab5	327	int do_rspr (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
f7e2e0eb	328	{
e69f66c6	329	unsigned int reg = 0;
48fbd3a4	330	unsigned int val = 0;
f7e2e0eb	331
47e26b1b	332	if (argc < 2)
4c12eeb8	333	return CMD_RET_USAGE;
47e26b1b	334
481d4328 MS	335	reg = (unsigned int)simple_strtoul (argv[1], NULL, 16);
481d4328 MS	336	val = (unsigned int)simple_strtoul (argv[2], NULL, 16);
e69f66c6 MS	337	switch (reg) {
	338	case 0x1:
	339	if (argc > 2) {
	340	MTS (val, rmsr);
	341	NOP;
	342	MFS (val, rmsr);
e69f66c6 MS	343	} else {
	344	MFS (val, rmsr);
	345	}
	346	puts ("MSR");
	347	break;
	348	case 0x3:
	349	MFS (val, rear);
	350	puts ("EAR");
	351	break;
	352	case 0x5:
	353	MFS (val, resr);
	354	puts ("ESR");
	355	break;
	356	default:
481d4328	357	puts ("Unsupported register\n");
e69f66c6	358	return 1;
48fbd3a4	359	}
f2302d44	360	printf (": 0x%08x\n", val);
f7e2e0eb MS	361	return 0;
	362	}
	363
	364	/***************************************************/
	365
	366	U_BOOT_CMD (frd, 3, 1, do_frd,
2fb2604d	367	"read data from FSL",
ab874d50 MS	368	"- [fslnum [0\|1\|2\|3]]\n"
	369	" 0 - non blocking data read\n"
	370	" 1 - non blocking control read\n"
	371	" 2 - blocking data read\n"
a89c33db	372	" 3 - blocking control read");
f7e2e0eb MS	373
f7e2e0eb MS	374	U_BOOT_CMD (fwr, 4, 1, do_fwr,
2fb2604d	375	"write data to FSL",
ab874d50 MS	376	"- [fslnum [0\|1\|2\|3]]\n"
	377	" 0 - non blocking data write\n"
	378	" 1 - non blocking control write\n"
	379	" 2 - blocking data write\n"
a89c33db	380	" 3 - blocking control write");
f7e2e0eb	381
e69f66c6	382	U_BOOT_CMD (rspr, 3, 1, do_rspr,
2fb2604d	383	"read/write special purpose register",
e69f66c6	384	"- reg_num [write value] read/write special purpose register\n"
481d4328 MS	385	" 1 - MSR - Machine status register\n"
481d4328 MS	386	" 3 - EAR - Exception address register\n"
a89c33db	387	" 5 - ESR - Exception status register");