[people/ms/u-boot.git] / cmd / mfsl.c

/*
 * (C) Copyright 2007 Michal Simek
 *
 * Michal  SIMEK <monstr@monstr.eu>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

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