[thirdparty/u-boot.git] / cmd / mdio.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2011 Freescale Semiconductor, Inc
 * Andy Fleming
 */

/*
 * MDIO Commands
 */

#include <common.h>
#include <command.h>
#include <miiphy.h>
#include <phy.h>

static char last_op[2];
static uint last_data;
static uint last_addr_lo;
static uint last_addr_hi;
static uint last_devad_lo;
static uint last_devad_hi;
static uint last_reg_lo;
static uint last_reg_hi;

static int extract_range(char *input, int *plo, int *phi)
{
	char *end;
	*plo = simple_strtol(input, &end, 16);
	if (end == input)
		return -1;

	if ((*end == '-') && *(++end))
		*phi = simple_strtol(end, NULL, 16);
	else if (*end == '\0')
		*phi = *plo;
	else
		return -1;

	return 0;
}

static int mdio_write_ranges(struct phy_device *phydev, struct mii_dev *bus,
			     int addrlo,
			     int addrhi, int devadlo, int devadhi,
			     int reglo, int reghi, unsigned short data,
			     int extended)
{
	int addr, devad, reg;
	int err = 0;

	for (addr = addrlo; addr <= addrhi; addr++) {
		for (devad = devadlo; devad <= devadhi; devad++) {
			for (reg = reglo; reg <= reghi; reg++) {
				if (!extended)
					err = bus->write(bus, addr, devad,
							 reg, data);
				else
					err = phydev->drv->writeext(phydev,
							addr, devad, reg, data);

				if (err)
					goto err_out;
			}
		}
	}

err_out:
	return err;
}

static int mdio_read_ranges(struct phy_device *phydev, struct mii_dev *bus,
			    int addrlo,
			    int addrhi, int devadlo, int devadhi,
			    int reglo, int reghi, int extended)
{
	int addr, devad, reg;

	printf("Reading from bus %s\n", bus->name);
	for (addr = addrlo; addr <= addrhi; addr++) {
		printf("PHY at address %x:\n", addr);

		for (devad = devadlo; devad <= devadhi; devad++) {
			for (reg = reglo; reg <= reghi; reg++) {
				int val;

				if (!extended)
					val = bus->read(bus, addr, devad, reg);
				else
					val = phydev->drv->readext(phydev, addr,
						devad, reg);

				if (val < 0) {
					printf("Error\n");

					return val;
				}

				if (devad >= 0)
					printf("%d.", devad);

				printf("%d - 0x%x\n", reg, val & 0xffff);
			}
		}
	}

	return 0;
}

/* The register will be in the form [a[-b].]x[-y] */
static int extract_reg_range(char *input, int *devadlo, int *devadhi,
			     int *reglo, int *reghi)
{
	char *regstr;

	/* use strrchr to find the last string after a '.' */
	regstr = strrchr(input, '.');

	/* If it exists, extract the devad(s) */
	if (regstr) {
		char devadstr[32];

		strncpy(devadstr, input, regstr - input);
		devadstr[regstr - input] = '\0';

		if (extract_range(devadstr, devadlo, devadhi))
			return -1;

		regstr++;
	} else {
		/* Otherwise, we have no devad, and we just got regs */
		*devadlo = *devadhi = MDIO_DEVAD_NONE;

		regstr = input;
	}

	return extract_range(regstr, reglo, reghi);
}

static int extract_phy_range(char *const argv[], int argc, struct mii_dev **bus,
			     struct phy_device **phydev,
			     int *addrlo, int *addrhi)
{
	struct phy_device *dev = *phydev;

	if ((argc < 1) || (argc > 2))
		return -1;

	/* If there are two arguments, it's busname addr */
	if (argc == 2) {
		*bus = miiphy_get_dev_by_name(argv[0]);

		if (!*bus)
			return -1;

		return extract_range(argv[1], addrlo, addrhi);
	}

	/* It must be one argument, here */

	/*
	 * This argument can be one of two things:
	 * 1) Ethernet device name
	 * 2) Just an address (use the previously-used bus)
	 *
	 * We check all buses for a PHY which is connected to an ethernet
	 * device by the given name.  If none are found, we call
	 * extract_range() on the string, and see if it's an address range.
	 */
	dev = mdio_phydev_for_ethname(argv[0]);

	if (dev) {
		*addrlo = *addrhi = dev->addr;
		*bus = dev->bus;

		return 0;
	}

	/* It's an address or nothing useful */
	return extract_range(argv[0], addrlo, addrhi);
}

/* ---------------------------------------------------------------- */
static int do_mdio(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	char op[2];
	int addrlo, addrhi, reglo, reghi, devadlo, devadhi;
	unsigned short	data;
	int pos = argc - 1;
	struct mii_dev *bus;
	struct phy_device *phydev = NULL;
	int extended = 0;

	if (argc < 2)
		return CMD_RET_USAGE;

	/*
	 * We use the last specified parameters, unless new ones are
	 * entered.
	 */
	op[0] = argv[1][0];
	addrlo = last_addr_lo;
	addrhi = last_addr_hi;
	devadlo = last_devad_lo;
	devadhi = last_devad_hi;
	reglo  = last_reg_lo;
	reghi  = last_reg_hi;
	data   = last_data;

	bus = mdio_get_current_dev();

	if (flag & CMD_FLAG_REPEAT)
		op[0] = last_op[0];

	if (strlen(argv[1]) > 1) {
		op[1] = argv[1][1];
		if (op[1] == 'x') {
			phydev = mdio_phydev_for_ethname(argv[2]);

			if (phydev) {
				addrlo = phydev->addr;
				addrhi = addrlo;
				bus = phydev->bus;
				extended = 1;
			} else {
				return -1;
			}

			if (!phydev->drv ||
			    (!phydev->drv->writeext && (op[0] == 'w')) ||
			    (!phydev->drv->readext && (op[0] == 'r'))) {
				puts("PHY does not have extended functions\n");
				return -1;
			}
		}
	}

	switch (op[0]) {
	case 'w':
		if (pos > 1)
			data = simple_strtoul(argv[pos--], NULL, 16);
	case 'r':
		if (pos > 1)
			if (extract_reg_range(argv[pos--], &devadlo, &devadhi,
					      &reglo, &reghi))
				return -1;

	default:
		if (pos > 1)
			if (extract_phy_range(&argv[2], pos - 1, &bus,
					      &phydev, &addrlo, &addrhi))
				return -1;

		break;
	}

	if (op[0] == 'l') {
		mdio_list_devices();

		return 0;
	}

	/* Save the chosen bus */
	miiphy_set_current_dev(bus->name);

	switch (op[0]) {
	case 'w':
		mdio_write_ranges(phydev, bus, addrlo, addrhi, devadlo, devadhi,
				  reglo, reghi, data, extended);
		break;

	case 'r':
		mdio_read_ranges(phydev, bus, addrlo, addrhi, devadlo, devadhi,
				 reglo, reghi, extended);
		break;
	}

	/*
	 * Save the parameters for repeats.
	 */
	last_op[0] = op[0];
	last_addr_lo = addrlo;
	last_addr_hi = addrhi;
	last_devad_lo = devadlo;
	last_devad_hi = devadhi;
	last_reg_lo  = reglo;
	last_reg_hi  = reghi;
	last_data    = data;

	return 0;
}

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

U_BOOT_CMD(
	mdio,	6,	1,	do_mdio,
	"MDIO utility commands",
	"list			- List MDIO buses\n"
	"mdio read <phydev> [<devad>.]<reg> - "
		"read PHY's register at <devad>.<reg>\n"
	"mdio write <phydev> [<devad>.]<reg> <data> - "
		"write PHY's register at <devad>.<reg>\n"
	"mdio rx <phydev> [<devad>.]<reg> - "
		"read PHY's extended register at <devad>.<reg>\n"
	"mdio wx <phydev> [<devad>.]<reg> <data> - "
		"write PHY's extended register at <devad>.<reg>\n"
	"<phydev> may be:\n"
	"   <busname>  <addr>\n"
	"   <addr>\n"
	"   <eth name>\n"
	"<addr> <devad>, and <reg> may be ranges, e.g. 1-5.4-0x1f.\n"
);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
995daa0b AF	2	/*
	3	* (C) Copyright 2011 Freescale Semiconductor, Inc
	4	* Andy Fleming
995daa0b AF	5	*/
	6
	7	/*
	8	* MDIO Commands
	9	*/
	10
	11	#include <common.h>
	12	#include <command.h>
	13	#include <miiphy.h>
	14	#include <phy.h>
	15
995daa0b AF	16	static char last_op[2];
	17	static uint last_data;
	18	static uint last_addr_lo;
	19	static uint last_addr_hi;
	20	static uint last_devad_lo;
	21	static uint last_devad_hi;
	22	static uint last_reg_lo;
	23	static uint last_reg_hi;
	24
	25	static int extract_range(char input, int plo, int *phi)
	26	{
	27	char *end;
15a2acdf	28	*plo = simple_strtol(input, &end, 16);
995daa0b AF	29	if (end == input)
	30	return -1;
	31
	32	if ((end == '-') && (++end))
15a2acdf	33	*phi = simple_strtol(end, NULL, 16);
995daa0b AF	34	else if (*end == '\0')
	35	phi = plo;
	36	else
	37	return -1;
	38
	39	return 0;
	40	}
	41
26b807c4 SB	42	static int mdio_write_ranges(struct phy_device phydev, struct mii_dev bus,
26b807c4 SB	43	int addrlo,
088f1b19	44	int addrhi, int devadlo, int devadhi,
26b807c4 SB	45	int reglo, int reghi, unsigned short data,
26b807c4 SB	46	int extended)
995daa0b AF	47	{
	48	int addr, devad, reg;
	49	int err = 0;
	50
	51	for (addr = addrlo; addr <= addrhi; addr++) {
	52	for (devad = devadlo; devad <= devadhi; devad++) {
	53	for (reg = reglo; reg <= reghi; reg++) {
26b807c4 SB	54	if (!extended)
	55	err = bus->write(bus, addr, devad,
	56	reg, data);
	57	else
	58	err = phydev->drv->writeext(phydev,
	59	addr, devad, reg, data);
995daa0b AF	60
	61	if (err)
	62	goto err_out;
	63	}
	64	}
	65	}
	66
	67	err_out:
	68	return err;
	69	}
	70
26b807c4 SB	71	static int mdio_read_ranges(struct phy_device phydev, struct mii_dev bus,
26b807c4 SB	72	int addrlo,
088f1b19	73	int addrhi, int devadlo, int devadhi,
26b807c4	74	int reglo, int reghi, int extended)
995daa0b AF	75	{
	76	int addr, devad, reg;
	77
	78	printf("Reading from bus %s\n", bus->name);
	79	for (addr = addrlo; addr <= addrhi; addr++) {
15a2acdf	80	printf("PHY at address %x:\n", addr);
995daa0b AF	81
	82	for (devad = devadlo; devad <= devadhi; devad++) {
	83	for (reg = reglo; reg <= reghi; reg++) {
a621b167	84	int val;
995daa0b	85
26b807c4 SB	86	if (!extended)
	87	val = bus->read(bus, addr, devad, reg);
	88	else
	89	val = phydev->drv->readext(phydev, addr,
	90	devad, reg);
	91
995daa0b AF	92	if (val < 0) {
	93	printf("Error\n");
	94
	95	return val;
	96	}
	97
	98	if (devad >= 0)
	99	printf("%d.", devad);
	100
	101	printf("%d - 0x%x\n", reg, val & 0xffff);
	102	}
	103	}
	104	}
	105
	106	return 0;
	107	}
	108
	109	/* The register will be in the form [a[-b].]x[-y] */
088f1b19 KP	110	static int extract_reg_range(char input, int devadlo, int *devadhi,
088f1b19 KP	111	int reglo, int reghi)
995daa0b AF	112	{
	113	char *regstr;
	114
	115	/* use strrchr to find the last string after a '.' */
	116	regstr = strrchr(input, '.');
	117
	118	/* If it exists, extract the devad(s) */
	119	if (regstr) {
	120	char devadstr[32];
	121
	122	strncpy(devadstr, input, regstr - input);
	123	devadstr[regstr - input] = '\0';
	124
	125	if (extract_range(devadstr, devadlo, devadhi))
	126	return -1;
	127
	128	regstr++;
	129	} else {
	130	/* Otherwise, we have no devad, and we just got regs */
	131	devadlo = devadhi = MDIO_DEVAD_NONE;
	132
	133	regstr = input;
	134	}
	135
	136	return extract_range(regstr, reglo, reghi);
	137	}
	138
088f1b19	139	static int extract_phy_range(char const argv[], int argc, struct mii_dev *bus,
26b807c4	140	struct phy_device **phydev,
088f1b19	141	int addrlo, int addrhi)
995daa0b	142	{
26b807c4	143	struct phy_device dev = phydev;
995daa0b AF	144
	145	if ((argc < 1) \|\| (argc > 2))
	146	return -1;
	147
	148	/* If there are two arguments, it's busname addr */
	149	if (argc == 2) {
	150	*bus = miiphy_get_dev_by_name(argv[0]);
	151
	152	if (!*bus)
	153	return -1;
	154
	155	return extract_range(argv[1], addrlo, addrhi);
	156	}
	157
	158	/* It must be one argument, here */
	159
	160	/*
	161	* This argument can be one of two things:
	162	* 1) Ethernet device name
	163	* 2) Just an address (use the previously-used bus)
	164	*
	165	* We check all buses for a PHY which is connected to an ethernet
	166	* device by the given name. If none are found, we call
	167	* extract_range() on the string, and see if it's an address range.
	168	*/
26b807c4	169	dev = mdio_phydev_for_ethname(argv[0]);
995daa0b	170
26b807c4 SB	171	if (dev) {
	172	addrlo = addrhi = dev->addr;
	173	*bus = dev->bus;
995daa0b AF	174
	175	return 0;
	176	}
	177
	178	/* It's an address or nothing useful */
	179	return extract_range(argv[0], addrlo, addrhi);
	180	}
	181
	182	/* ---------------------------------------------------------------- */
	183	static int do_mdio(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
	184	{
	185	char op[2];
	186	int addrlo, addrhi, reglo, reghi, devadlo, devadhi;
	187	unsigned short data;
	188	int pos = argc - 1;
	189	struct mii_dev *bus;
26b807c4 SB	190	struct phy_device *phydev = NULL;
26b807c4 SB	191	int extended = 0;
995daa0b AF	192
995daa0b AF	193	if (argc < 2)
4c12eeb8	194	return CMD_RET_USAGE;
995daa0b AF	195
	196	/*
	197	* We use the last specified parameters, unless new ones are
	198	* entered.
	199	*/
	200	op[0] = argv[1][0];
	201	addrlo = last_addr_lo;
	202	addrhi = last_addr_hi;
	203	devadlo = last_devad_lo;
	204	devadhi = last_devad_hi;
	205	reglo = last_reg_lo;
	206	reghi = last_reg_hi;
	207	data = last_data;
	208
	209	bus = mdio_get_current_dev();
	210
	211	if (flag & CMD_FLAG_REPEAT)
	212	op[0] = last_op[0];
	213
26b807c4 SB	214	if (strlen(argv[1]) > 1) {
	215	op[1] = argv[1][1];
	216	if (op[1] == 'x') {
	217	phydev = mdio_phydev_for_ethname(argv[2]);
	218
	219	if (phydev) {
	220	addrlo = phydev->addr;
	221	addrhi = addrlo;
	222	bus = phydev->bus;
	223	extended = 1;
	224	} else {
	225	return -1;
	226	}
	227
	228	if (!phydev->drv \|\|
	229	(!phydev->drv->writeext && (op[0] == 'w')) \|\|
	230	(!phydev->drv->readext && (op[0] == 'r'))) {
	231	puts("PHY does not have extended functions\n");
	232	return -1;
	233	}
	234	}
	235	}
	236
995daa0b AF	237	switch (op[0]) {
	238	case 'w':
	239	if (pos > 1)
	240	data = simple_strtoul(argv[pos--], NULL, 16);
	241	case 'r':
	242	if (pos > 1)
	243	if (extract_reg_range(argv[pos--], &devadlo, &devadhi,
c5503898	244	&reglo, &reghi))
995daa0b AF	245	return -1;
	246
	247	default:
	248	if (pos > 1)
c5503898 MS	249	if (extract_phy_range(&argv[2], pos - 1, &bus,
c5503898 MS	250	&phydev, &addrlo, &addrhi))
995daa0b AF	251	return -1;
	252
	253	break;
	254	}
	255
	256	if (op[0] == 'l') {
	257	mdio_list_devices();
	258
	259	return 0;
	260	}
	261
	262	/* Save the chosen bus */
	263	miiphy_set_current_dev(bus->name);
	264
	265	switch (op[0]) {
	266	case 'w':
26b807c4 SB	267	mdio_write_ranges(phydev, bus, addrlo, addrhi, devadlo, devadhi,
26b807c4 SB	268	reglo, reghi, data, extended);
995daa0b AF	269	break;
	270
	271	case 'r':
26b807c4 SB	272	mdio_read_ranges(phydev, bus, addrlo, addrhi, devadlo, devadhi,
26b807c4 SB	273	reglo, reghi, extended);
995daa0b AF	274	break;
	275	}
	276
	277	/*
	278	* Save the parameters for repeats.
	279	*/
	280	last_op[0] = op[0];
	281	last_addr_lo = addrlo;
	282	last_addr_hi = addrhi;
	283	last_devad_lo = devadlo;
	284	last_devad_hi = devadhi;
	285	last_reg_lo = reglo;
	286	last_reg_hi = reghi;
	287	last_data = data;
	288
	289	return 0;
	290	}
	291
	292	/***************************************************/
	293
	294	U_BOOT_CMD(
	295	mdio, 6, 1, do_mdio,
	296	"MDIO utility commands",
	297	"list - List MDIO buses\n"
	298	"mdio read <phydev> [<devad>.]<reg> - "
	299	"read PHY's register at <devad>.<reg>\n"
	300	"mdio write <phydev> [<devad>.]<reg> <data> - "
	301	"write PHY's register at <devad>.<reg>\n"
26b807c4 SB	302	"mdio rx <phydev> [<devad>.]<reg> - "
	303	"read PHY's extended register at <devad>.<reg>\n"
	304	"mdio wx <phydev> [<devad>.]<reg> <data> - "
	305	"write PHY's extended register at <devad>.<reg>\n"
995daa0b AF	306	"<phydev> may be:\n"
	307	" <busname> <addr>\n"
	308	" <addr>\n"
	309	" <eth name>\n"
	310	"<addr> <devad>, and <reg> may be ranges, e.g. 1-5.4-0x1f.\n"
	311	);