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

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

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