drivers/net/phy/aquantia.c - platform/external/u-boot - Gitiles

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Aquantia PHY drivers
  *
  * Copyright 2014 Freescale Semiconductor, Inc.
  * Copyright 2018, 2021 NXP
  */
 #include <config.h>
 #include <common.h>
 #include <dm.h>
 #include <log.h>
 #include <net.h>
 #include <phy.h>
 #include <linux/bitops.h>
 #include <linux/delay.h>
 #include <u-boot/crc.h>
 #include <malloc.h>
 #include <asm/byteorder.h>
 #include <fs.h>

 #define AQUNTIA_10G_CTL		0x20
 #define AQUNTIA_VENDOR_P1	0xc400

 #define AQUNTIA_SPEED_LSB_MASK	0x2000
 #define AQUNTIA_SPEED_MSB_MASK	0x40

 #define AQUANTIA_SYSTEM_INTERFACE_SR     0xe812
 #define  AQUANTIA_SYSTEM_INTERFACE_SR_READY	BIT(0)
 #define AQUANTIA_VENDOR_PROVISIONING_REG 0xC441
 #define AQUANTIA_FIRMWARE_ID		 0x20
 #define AQUANTIA_RESERVED_STATUS	 0xc885
 #define AQUANTIA_FIRMWARE_MAJOR_MASK	 0xff00
 #define AQUANTIA_FIRMWARE_MINOR_MASK	 0xff
 #define AQUANTIA_FIRMWARE_BUILD_MASK	 0xf0

 #define AQUANTIA_USX_AUTONEG_CONTROL_ENA 0x0008
 #define AQUANTIA_SI_IN_USE_MASK          0x0078
 #define AQUANTIA_SI_USXGMII              0x0018

 /* registers in MDIO_MMD_VEND1 region */
 #define AQUANTIA_VND1_GLOBAL_SC			0x000
 #define  AQUANTIA_VND1_GLOBAL_SC_LP		BIT(0xb)

 #define GLOBAL_FIRMWARE_ID 0x20
 #define GLOBAL_FAULT 0xc850
 #define GLOBAL_RSTATUS_1 0xc885

 #define GLOBAL_ALARM_1 0xcc00
 #define SYSTEM_READY_BIT 0x40

 #define GLOBAL_STANDARD_CONTROL 0x0
 #define SOFT_RESET BIT(15)
 #define LOW_POWER BIT(11)

 #define MAILBOX_CONTROL 0x0200
 #define MAILBOX_EXECUTE BIT(15)
 #define MAILBOX_WRITE BIT(14)
 #define MAILBOX_RESET_CRC BIT(12)
 #define MAILBOX_BUSY BIT(8)

 #define MAILBOX_CRC 0x0201

 #define MAILBOX_ADDR_MSW 0x0202
 #define MAILBOX_ADDR_LSW 0x0203

 #define MAILBOX_DATA_MSW 0x0204
 #define MAILBOX_DATA_LSW 0x0205

 #define UP_CONTROL 0xc001
 #define UP_RESET BIT(15)
 #define UP_RUN_STALL_OVERRIDE BIT(6)
 #define UP_RUN_STALL BIT(0)

 #define AQUANTIA_PMA_RX_VENDOR_P1		0xe400
 #define  AQUANTIA_PMA_RX_VENDOR_P1_MDI_MSK	GENMASK(1, 0)
 /* MDI reversal configured through registers */
 #define  AQUANTIA_PMA_RX_VENDOR_P1_MDI_CFG	BIT(1)
 /* MDI reversal enabled */
 #define  AQUANTIA_PMA_RX_VENDOR_P1_MDI_REV	BIT(0)

 /*
  * global start rate, the protocol associated with this speed is used by default
  * on SI.
  */
 #define AQUANTIA_VND1_GSTART_RATE		0x31a
 #define  AQUANTIA_VND1_GSTART_RATE_OFF		0
 #define  AQUANTIA_VND1_GSTART_RATE_100M		1
 #define  AQUANTIA_VND1_GSTART_RATE_1G		2
 #define  AQUANTIA_VND1_GSTART_RATE_10G		3
 #define  AQUANTIA_VND1_GSTART_RATE_2_5G		4
 #define  AQUANTIA_VND1_GSTART_RATE_5G		5

 /* SYSCFG registers for 100M, 1G, 2.5G, 5G, 10G */
 #define AQUANTIA_VND1_GSYSCFG_BASE		0x31b
 #define AQUANTIA_VND1_GSYSCFG_100M		0
 #define AQUANTIA_VND1_GSYSCFG_1G		1
 #define AQUANTIA_VND1_GSYSCFG_2_5G		2
 #define AQUANTIA_VND1_GSYSCFG_5G		3
 #define AQUANTIA_VND1_GSYSCFG_10G		4

 #define AQUANTIA_VND1_SMBUS0			0xc485
 #define AQUANTIA_VND1_SMBUS1			0xc495

 /* addresses of memory segments in the phy */
 #define DRAM_BASE_ADDR 0x3FFE0000
 #define IRAM_BASE_ADDR 0x40000000

 /* firmware image format constants */
 #define VERSION_STRING_SIZE 0x40
 #define VERSION_STRING_OFFSET 0x0200
 #define HEADER_OFFSET 0x300

 /* driver private data */
 #define AQUANTIA_NA		0
 #define AQUANTIA_GEN1		1
 #define AQUANTIA_GEN2		2
 #define AQUANTIA_GEN3		3

 #pragma pack(1)
 struct fw_header {
 	u8 padding[4];
 	u8 iram_offset[3];
 	u8 iram_size[3];
 	u8 dram_offset[3];
 	u8 dram_size[3];
 };

 #pragma pack()

 #if defined(CONFIG_PHY_AQUANTIA_UPLOAD_FW)
 static int aquantia_read_fw(u8 **fw_addr, size_t *fw_length)
 {
 	loff_t length, read;
 	int ret;
 	void *addr = NULL;

 	*fw_addr = NULL;
 	*fw_length = 0;
 	debug("Loading Acquantia microcode from %s %s\n",
 	      CONFIG_PHY_AQUANTIA_FW_PART, CONFIG_PHY_AQUANTIA_FW_NAME);
 	ret = fs_set_blk_dev("mmc", CONFIG_PHY_AQUANTIA_FW_PART, FS_TYPE_ANY);
 	if (ret < 0)
 		goto cleanup;

 	ret = fs_size(CONFIG_PHY_AQUANTIA_FW_NAME, &length);
 	if (ret < 0)
 		goto cleanup;

 	addr = malloc(length);
 	if (!addr) {
 		ret = -ENOMEM;
 		goto cleanup;
 	}

 	ret = fs_set_blk_dev("mmc", CONFIG_PHY_AQUANTIA_FW_PART, FS_TYPE_ANY);
 	if (ret < 0)
 		goto cleanup;

 	ret = fs_read(CONFIG_PHY_AQUANTIA_FW_NAME, (ulong)addr, 0, length,
 		      &read);
 	if (ret < 0)
 		goto cleanup;

 	*fw_addr = addr;
 	*fw_length = length;
 	debug("Found Acquantia microcode.\n");

 cleanup:
 	if (ret < 0) {
 		printf("loading firmware file %s %s failed with error %d\n",
 		       CONFIG_PHY_AQUANTIA_FW_PART,
 		       CONFIG_PHY_AQUANTIA_FW_NAME, ret);
 		free(addr);
 	}
 	return ret;
 }

 /* load data into the phy's memory */
 static int aquantia_load_memory(struct phy_device *phydev, u32 addr,
 				const u8 *data, size_t len)
 {
 	size_t pos;
 	u16 crc = 0, up_crc;

 	phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_CONTROL, MAILBOX_RESET_CRC);
 	phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_ADDR_MSW, addr >> 16);
 	phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_ADDR_LSW, addr & 0xfffc);

 	for (pos = 0; pos < len; pos += min(sizeof(u32), len - pos)) {
 		u32 word = 0;

 		memcpy(&word, &data[pos], min(sizeof(u32), len - pos));

 		phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_DATA_MSW,
 			  (word >> 16));
 		phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_DATA_LSW,
 			  word & 0xffff);

 		phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_CONTROL,
 			  MAILBOX_EXECUTE | MAILBOX_WRITE);

 		/* keep a big endian CRC to match the phy processor */
 		word = cpu_to_be32(word);
 		crc = crc16_ccitt(crc, (u8 *)&word, sizeof(word));
 	}

 	up_crc = phy_read(phydev, MDIO_MMD_VEND1, MAILBOX_CRC);
 	if (crc != up_crc) {
 		printf("%s crc mismatch: calculated 0x%04hx phy 0x%04hx\n",
 		       phydev->dev->name, crc, up_crc);
 		return -EINVAL;
 	}
 	return 0;
 }

 static u32 unpack_u24(const u8 *data)
 {
 	return (data[2] << 16) + (data[1] << 8) + data[0];
 }

 static int aquantia_upload_firmware(struct phy_device *phydev)
 {
 	int ret;
 	u8 *addr = NULL;
 	size_t fw_length = 0;
 	u16 calculated_crc, read_crc;
 	char version[VERSION_STRING_SIZE];
 	u32 primary_offset, iram_offset, iram_size, dram_offset, dram_size;
 	const struct fw_header *header;

 	ret = aquantia_read_fw(&addr, &fw_length);
 	if (ret != 0)
 		return ret;

 	read_crc = (addr[fw_length - 2] << 8)  | addr[fw_length - 1];
 	calculated_crc = crc16_ccitt(0, addr, fw_length - 2);
 	if (read_crc != calculated_crc) {
 		printf("%s bad firmware crc: file 0x%04x calculated 0x%04x\n",
 		       phydev->dev->name, read_crc, calculated_crc);
 		ret = -EINVAL;
 		goto done;
 	}

 	/* Find the DRAM and IRAM sections within the firmware file. */
 	primary_offset = ((addr[9] & 0xf) << 8 | addr[8]) << 12;

 	header = (struct fw_header *)&addr[primary_offset + HEADER_OFFSET];

 	iram_offset = primary_offset + unpack_u24(header->iram_offset);
 	iram_size = unpack_u24(header->iram_size);

 	dram_offset = primary_offset + unpack_u24(header->dram_offset);
 	dram_size = unpack_u24(header->dram_size);

 	debug("primary %d iram offset=%d size=%d dram offset=%d size=%d\n",
 	      primary_offset, iram_offset, iram_size, dram_offset, dram_size);

 	strlcpy(version, (char *)&addr[dram_offset + VERSION_STRING_OFFSET],
 		VERSION_STRING_SIZE);
 	printf("%s loading firmare version '%s'\n", phydev->dev->name, version);

 	/* stall the microcprocessor */
 	phy_write(phydev, MDIO_MMD_VEND1, UP_CONTROL,
 		  UP_RUN_STALL | UP_RUN_STALL_OVERRIDE);

 	debug("loading dram 0x%08x from offset=%d size=%d\n",
 	      DRAM_BASE_ADDR, dram_offset, dram_size);
 	ret = aquantia_load_memory(phydev, DRAM_BASE_ADDR, &addr[dram_offset],
 				   dram_size);
 	if (ret != 0)
 		goto done;

 	debug("loading iram 0x%08x from offset=%d size=%d\n",
 	      IRAM_BASE_ADDR, iram_offset, iram_size);
 	ret = aquantia_load_memory(phydev, IRAM_BASE_ADDR, &addr[iram_offset],
 				   iram_size);
 	if (ret != 0)
 		goto done;

 	/* make sure soft reset and low power mode are clear */
 	phy_write(phydev, MDIO_MMD_VEND1, GLOBAL_STANDARD_CONTROL, 0);

 	/* Release the microprocessor. UP_RESET must be held for 100 usec. */
 	phy_write(phydev, MDIO_MMD_VEND1, UP_CONTROL,
 		  UP_RUN_STALL | UP_RUN_STALL_OVERRIDE | UP_RESET);

 	udelay(100);

 	phy_write(phydev, MDIO_MMD_VEND1, UP_CONTROL, UP_RUN_STALL_OVERRIDE);

 	printf("%s firmare loading done.\n", phydev->dev->name);
 done:
 	free(addr);
 	return ret;
 }
 #else
 static int aquantia_upload_firmware(struct phy_device *phydev)
 {
 	printf("ERROR %s firmware loading disabled.\n", phydev->dev->name);
 	return -1;
 }
 #endif

 struct {
 	u16 syscfg;
 	int cnt;
 	u16 start_rate;
 } aquantia_syscfg[PHY_INTERFACE_MODE_MAX] = {
 	[PHY_INTERFACE_MODE_SGMII] =      {0x04b, AQUANTIA_VND1_GSYSCFG_1G,
 					   AQUANTIA_VND1_GSTART_RATE_1G},
 	[PHY_INTERFACE_MODE_2500BASEX]  = {0x144, AQUANTIA_VND1_GSYSCFG_2_5G,
 					   AQUANTIA_VND1_GSTART_RATE_2_5G},
 	[PHY_INTERFACE_MODE_10GBASER] =   {0x100, AQUANTIA_VND1_GSYSCFG_10G,
 					   AQUANTIA_VND1_GSTART_RATE_10G},
 	[PHY_INTERFACE_MODE_USXGMII] =    {0x080, AQUANTIA_VND1_GSYSCFG_10G,
 					   AQUANTIA_VND1_GSTART_RATE_10G},
 };

 static int aquantia_set_proto(struct phy_device *phydev,
 			      phy_interface_t interface)
 {
 	int i;

 	if (!aquantia_syscfg[interface].cnt)
 		return 0;

 	/* set the default rate to enable the SI link */
 	phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_GSTART_RATE,
 		  aquantia_syscfg[interface].start_rate);

 	/* set selected protocol for all relevant line side link speeds */
 	for (i = 0; i <= aquantia_syscfg[interface].cnt; i++)
 		phy_write(phydev, MDIO_MMD_VEND1,
 			  AQUANTIA_VND1_GSYSCFG_BASE + i,
 			  aquantia_syscfg[interface].syscfg);
 	return 0;
 }

 static int aquantia_dts_config(struct phy_device *phydev)
 {
 #ifdef CONFIG_DM_ETH
 	ofnode node = phydev->node;
 	u32 prop;
 	u16 reg;

 	/* this code only works on gen2 and gen3 PHYs */
 	if (phydev->drv->data != AQUANTIA_GEN2 &&
 	    phydev->drv->data != AQUANTIA_GEN3)
 		return -ENOTSUPP;

 	if (!ofnode_valid(node))
 		return 0;

 	if (!ofnode_read_u32(node, "mdi-reversal", &prop)) {
 		debug("mdi-reversal = %d\n", (int)prop);
 		reg =  phy_read(phydev, MDIO_MMD_PMAPMD,
 				AQUANTIA_PMA_RX_VENDOR_P1);
 		reg &= ~AQUANTIA_PMA_RX_VENDOR_P1_MDI_MSK;
 		reg |= AQUANTIA_PMA_RX_VENDOR_P1_MDI_CFG;
 		reg |= prop ? AQUANTIA_PMA_RX_VENDOR_P1_MDI_REV : 0;
 		phy_write(phydev, MDIO_MMD_PMAPMD, AQUANTIA_PMA_RX_VENDOR_P1,
 			  reg);
 	}
 	if (!ofnode_read_u32(node, "smb-addr", &prop)) {
 		debug("smb-addr = %x\n", (int)prop);
 		/*
 		 * there are two addresses here, normally just one bus would
 		 * be in use so we're setting both regs using the same DT
 		 * property.
 		 */
 		phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_SMBUS0,
 			  (u16)(prop << 1));
 		phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_SMBUS1,
 			  (u16)(prop << 1));
 	}

 #endif
 	return 0;
 }

 static bool aquantia_link_is_up(struct phy_device *phydev)
 {
 	u16 reg, regmask;
 	int devad, regnum;

 	/*
 	 * On Gen 2 and 3 we have a bit that indicates that both system and
 	 * line side are ready for data, use that if possible.
 	 */
 	if (phydev->drv->data == AQUANTIA_GEN2 ||
 	    phydev->drv->data == AQUANTIA_GEN3) {
 		devad = MDIO_MMD_PHYXS;
 		regnum = AQUANTIA_SYSTEM_INTERFACE_SR;
 		regmask = AQUANTIA_SYSTEM_INTERFACE_SR_READY;
 	} else {
 		devad = MDIO_MMD_AN;
 		regnum = MDIO_STAT1;
 		regmask = MDIO_AN_STAT1_COMPLETE;
 	}
 	/* the register should be latched, do a double read */
 	phy_read(phydev, devad, regnum);
 	reg = phy_read(phydev, devad, regnum);

 	return !!(reg & regmask);
 }

 int aquantia_config(struct phy_device *phydev)
 {
 	int interface = phydev->interface;
 	u32 val, id, rstatus, fault;
 	u32 reg_val1 = 0;
 	int num_retries = 5;
 	int usx_an = 0;

 	/*
 	 * check if the system is out of reset and init sequence completed.
 	 * chip-wide reset for gen1 quad phys takes longer
 	 */
 	while (--num_retries) {
 		rstatus = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_ALARM_1);
 		if (rstatus & SYSTEM_READY_BIT)
 			break;
 		mdelay(10);
 	}

 	id = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_FIRMWARE_ID);
 	rstatus = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_RSTATUS_1);
 	fault = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_FAULT);

 	if (id != 0)
 		debug("%s running firmware version %X.%X.%X\n",
 		      phydev->dev->name, (id >> 8), id & 0xff,
 		      (rstatus >> 4) & 0xf);

 	if (fault != 0)
 		printf("%s fault 0x%04x detected\n", phydev->dev->name, fault);

 	if (id == 0 || fault != 0) {
 		int ret;

 		ret = aquantia_upload_firmware(phydev);
 		if (ret != 0)
 			return ret;
 	}
 	/*
 	 * for backward compatibility convert XGMII into either 10GBase-R or
 	 * USXGMII based on FW config
 	 */
 	if (interface == PHY_INTERFACE_MODE_XGMII) {
 		debug("use 10GBase-R or USXGMII SI protos, XGMII is not valid\n");

 		reg_val1 = phy_read(phydev, MDIO_MMD_PHYXS,
 				    AQUANTIA_SYSTEM_INTERFACE_SR);
 		if ((reg_val1 & AQUANTIA_SI_IN_USE_MASK) == AQUANTIA_SI_USXGMII)
 			interface = PHY_INTERFACE_MODE_USXGMII;
 		else
 			interface = PHY_INTERFACE_MODE_10GBASER;
 	}

 	/*
 	 * if link is up already we can just use it, otherwise configure
 	 * the protocols in the PHY.  If link is down set the system
 	 * interface protocol to use based on phydev->interface
 	 */
 	if (!aquantia_link_is_up(phydev) &&
 	    (phydev->drv->data == AQUANTIA_GEN2 ||
 	     phydev->drv->data == AQUANTIA_GEN3)) {
 		/* set PHY in low power mode so we can configure protocols */
 		phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_GLOBAL_SC,
 			  AQUANTIA_VND1_GLOBAL_SC_LP);
 		mdelay(10);

 		/* configure protocol based on phydev->interface */
 		aquantia_set_proto(phydev, interface);
 		/* apply custom configuration based on DT */
 		aquantia_dts_config(phydev);

 		/* wake PHY back up */
 		phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_GLOBAL_SC, 0);
 		mdelay(10);
 	}

 	val = phy_read(phydev, MDIO_MMD_PMAPMD, MII_BMCR);

 	switch (interface) {
 	case PHY_INTERFACE_MODE_SGMII:
 		/* 1000BASE-T mode */
 		phydev->advertising = SUPPORTED_1000baseT_Full;
 		phydev->supported = phydev->advertising;

 		val = (val & ~AQUNTIA_SPEED_LSB_MASK) | AQUNTIA_SPEED_MSB_MASK;
 		phy_write(phydev, MDIO_MMD_PMAPMD, MII_BMCR, val);
 		break;
 	case PHY_INTERFACE_MODE_USXGMII:
 		usx_an = 1;
 		/* FALLTHROUGH */
 	case PHY_INTERFACE_MODE_10GBASER:
 		/* 10GBASE-T mode */
 		phydev->advertising = SUPPORTED_10000baseT_Full;
 		phydev->supported = phydev->advertising;

 		if (!(val & AQUNTIA_SPEED_LSB_MASK) ||
 		    !(val & AQUNTIA_SPEED_MSB_MASK))
 			phy_write(phydev, MDIO_MMD_PMAPMD, MII_BMCR,
 				  AQUNTIA_SPEED_LSB_MASK |
 				  AQUNTIA_SPEED_MSB_MASK);

 		/* If SI is USXGMII then start USXGMII autoneg */
 		reg_val1 =  phy_read(phydev, MDIO_MMD_PHYXS,
 				     AQUANTIA_VENDOR_PROVISIONING_REG);

 		if (usx_an) {
 			reg_val1 |= AQUANTIA_USX_AUTONEG_CONTROL_ENA;
 			debug("%s: system interface USXGMII\n",
 			      phydev->dev->name);
 		} else {
 			reg_val1 &= ~AQUANTIA_USX_AUTONEG_CONTROL_ENA;
 			debug("%s: system interface 10GBase-R\n",
 			      phydev->dev->name);
 		}

 		phy_write(phydev, MDIO_MMD_PHYXS,
 			  AQUANTIA_VENDOR_PROVISIONING_REG, reg_val1);
 		break;
 	case PHY_INTERFACE_MODE_2500BASEX:
 		/* 2.5GBASE-T mode */
 		phydev->advertising = SUPPORTED_1000baseT_Full;
 		phydev->supported = phydev->advertising;

 		phy_write(phydev, MDIO_MMD_AN, AQUNTIA_10G_CTL, 1);
 		phy_write(phydev, MDIO_MMD_AN, AQUNTIA_VENDOR_P1, 0x9440);
 		break;
 	case PHY_INTERFACE_MODE_MII:
 		/* 100BASE-TX mode */
 		phydev->advertising = SUPPORTED_100baseT_Full;
 		phydev->supported = phydev->advertising;

 		val = (val & ~AQUNTIA_SPEED_MSB_MASK) | AQUNTIA_SPEED_LSB_MASK;
 		phy_write(phydev, MDIO_MMD_PMAPMD, MII_BMCR, val);
 		break;
 	};

 	val = phy_read(phydev, MDIO_MMD_VEND1, AQUANTIA_RESERVED_STATUS);
 	reg_val1 = phy_read(phydev, MDIO_MMD_VEND1, AQUANTIA_FIRMWARE_ID);

 	debug("%s: %s Firmware Version %x.%x.%x\n", phydev->dev->name,
 	      phydev->drv->name,
 	      (reg_val1 & AQUANTIA_FIRMWARE_MAJOR_MASK) >> 8,
 	      reg_val1 & AQUANTIA_FIRMWARE_MINOR_MASK,
 	      (val & AQUANTIA_FIRMWARE_BUILD_MASK) >> 4);

 	return 0;
 }

 int aquantia_startup(struct phy_device *phydev)
 {
 	u32 speed;
 	int i = 0;
 	int reg;

 	phydev->duplex = DUPLEX_FULL;

 	/* if the AN is still in progress, wait till timeout. */
 	if (!aquantia_link_is_up(phydev)) {
 		printf("%s Waiting for PHY auto negotiation to complete",
 		       phydev->dev->name);
 		do {
 			udelay(1000);
 			if ((i++ % 500) == 0)
 				printf(".");
 		} while (!aquantia_link_is_up(phydev) &&
 			 i < (4 * PHY_ANEG_TIMEOUT));

 		if (i > PHY_ANEG_TIMEOUT)
 			printf(" TIMEOUT !\n");
 	}

 	/* Read twice because link state is latched and a
 	 * read moves the current state into the register */
 	phy_read(phydev, MDIO_MMD_AN, MDIO_STAT1);
 	reg = phy_read(phydev, MDIO_MMD_AN, MDIO_STAT1);
 	if (reg < 0 || !(reg & MDIO_STAT1_LSTATUS))
 		phydev->link = 0;
 	else
 		phydev->link = 1;

 	speed = phy_read(phydev, MDIO_MMD_PMAPMD, MII_BMCR);
 	if (speed & AQUNTIA_SPEED_MSB_MASK) {
 		if (speed & AQUNTIA_SPEED_LSB_MASK)
 			phydev->speed = SPEED_10000;
 		else
 			phydev->speed = SPEED_1000;
 	} else {
 		if (speed & AQUNTIA_SPEED_LSB_MASK)
 			phydev->speed = SPEED_100;
 		else
 			phydev->speed = SPEED_10;
 	}

 	return 0;
 }

 struct phy_driver aq1202_driver = {
 	.name = "Aquantia AQ1202",
 	.uid = 0x3a1b445,
 	.mask = 0xfffffff0,
 	.features = PHY_10G_FEATURES,
 	.mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 			MDIO_MMD_PHYXS | MDIO_MMD_AN |
 			MDIO_MMD_VEND1),
 	.config = &aquantia_config,
 	.startup = &aquantia_startup,
 	.shutdown = &gen10g_shutdown,
 };

 struct phy_driver aq2104_driver = {
 	.name = "Aquantia AQ2104",
 	.uid = 0x3a1b460,
 	.mask = 0xfffffff0,
 	.features = PHY_10G_FEATURES,
 	.mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 			MDIO_MMD_PHYXS | MDIO_MMD_AN |
 			MDIO_MMD_VEND1),
 	.config = &aquantia_config,
 	.startup = &aquantia_startup,
 	.shutdown = &gen10g_shutdown,
 };

 struct phy_driver aqr105_driver = {
 	.name = "Aquantia AQR105",
 	.uid = 0x3a1b4a2,
 	.mask = 0xfffffff0,
 	.features = PHY_10G_FEATURES,
 	.mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 			MDIO_MMD_PHYXS | MDIO_MMD_AN |
 			MDIO_MMD_VEND1),
 	.config = &aquantia_config,
 	.startup = &aquantia_startup,
 	.shutdown = &gen10g_shutdown,
 	.data = AQUANTIA_GEN1,
 };

 struct phy_driver aqr106_driver = {
 	.name = "Aquantia AQR106",
 	.uid = 0x3a1b4d0,
 	.mask = 0xfffffff0,
 	.features = PHY_10G_FEATURES,
 	.mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 			MDIO_MMD_PHYXS | MDIO_MMD_AN |
 			MDIO_MMD_VEND1),
 	.config = &aquantia_config,
 	.startup = &aquantia_startup,
 	.shutdown = &gen10g_shutdown,
 };

 struct phy_driver aqr107_driver = {
 	.name = "Aquantia AQR107",
 	.uid = 0x3a1b4e0,
 	.mask = 0xfffffff0,
 	.features = PHY_10G_FEATURES,
 	.mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 			MDIO_MMD_PHYXS | MDIO_MMD_AN |
 			MDIO_MMD_VEND1),
 	.config = &aquantia_config,
 	.startup = &aquantia_startup,
 	.shutdown = &gen10g_shutdown,
 	.data = AQUANTIA_GEN2,
 };

 struct phy_driver aqr112_driver = {
 	.name = "Aquantia AQR112",
 	.uid = 0x3a1b660,
 	.mask = 0xfffffff0,
 	.features = PHY_10G_FEATURES,
 	.mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS |
 		 MDIO_MMD_PHYXS | MDIO_MMD_AN |
 		 MDIO_MMD_VEND1),
 	.config = &aquantia_config,
 	.startup = &aquantia_startup,
 	.shutdown = &gen10g_shutdown,
 	.data = AQUANTIA_GEN3,
 };

 struct phy_driver aqr113c_driver = {
 	.name = "Aquantia AQR113C",
 	.uid = 0x31c31c12,
 	.mask = 0xfffffff0,
 	.features = PHY_10G_FEATURES,
 	.mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS |
 		 MDIO_MMD_PHYXS | MDIO_MMD_AN |
 		 MDIO_MMD_VEND1),
 	.config = &aquantia_config,
 	.startup = &aquantia_startup,
 	.shutdown = &gen10g_shutdown,
 	.data = AQUANTIA_GEN3,
 };

 struct phy_driver aqr405_driver = {
 	.name = "Aquantia AQR405",
 	.uid = 0x3a1b4b2,
 	.mask = 0xfffffff0,
 	.features = PHY_10G_FEATURES,
 	.mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS|
 		 MDIO_MMD_PHYXS | MDIO_MMD_AN |
 		 MDIO_MMD_VEND1),
 	.config = &aquantia_config,
 	.startup = &aquantia_startup,
 	.shutdown = &gen10g_shutdown,
 	.data = AQUANTIA_GEN1,
 };

 struct phy_driver aqr412_driver = {
 	.name = "Aquantia AQR412",
 	.uid = 0x3a1b710,
 	.mask = 0xfffffff0,
 	.features = PHY_10G_FEATURES,
 	.mmds = (MDIO_MMD_PMAPMD | MDIO_MMD_PCS |
 		 MDIO_MMD_PHYXS | MDIO_MMD_AN |
 		 MDIO_MMD_VEND1),
 	.config = &aquantia_config,
 	.startup = &aquantia_startup,
 	.shutdown = &gen10g_shutdown,
 	.data = AQUANTIA_GEN3,
 };

 int phy_aquantia_init(void)
 {
 	phy_register(&aq1202_driver);
 	phy_register(&aq2104_driver);
 	phy_register(&aqr105_driver);
 	phy_register(&aqr106_driver);
 	phy_register(&aqr107_driver);
 	phy_register(&aqr112_driver);
 	phy_register(&aqr113c_driver);
 	phy_register(&aqr405_driver);
 	phy_register(&aqr412_driver);

 	return 0;
 }
	// SPDX-License-Identifier: GPL-2.0+
	/*
	* Aquantia PHY drivers
	*
	* Copyright 2014 Freescale Semiconductor, Inc.
	* Copyright 2018, 2021 NXP
	*/
	#include <config.h>
	#include <common.h>
	#include <dm.h>
	#include <log.h>
	#include <net.h>
	#include <phy.h>
	#include <linux/bitops.h>
	#include <linux/delay.h>
	#include <u-boot/crc.h>
	#include <malloc.h>
	#include <asm/byteorder.h>
	#include <fs.h>

	#define AQUNTIA_10G_CTL 0x20
	#define AQUNTIA_VENDOR_P1 0xc400

	#define AQUNTIA_SPEED_LSB_MASK 0x2000
	#define AQUNTIA_SPEED_MSB_MASK 0x40

	#define AQUANTIA_SYSTEM_INTERFACE_SR 0xe812
	#define AQUANTIA_SYSTEM_INTERFACE_SR_READY BIT(0)
	#define AQUANTIA_VENDOR_PROVISIONING_REG 0xC441
	#define AQUANTIA_FIRMWARE_ID 0x20
	#define AQUANTIA_RESERVED_STATUS 0xc885
	#define AQUANTIA_FIRMWARE_MAJOR_MASK 0xff00
	#define AQUANTIA_FIRMWARE_MINOR_MASK 0xff
	#define AQUANTIA_FIRMWARE_BUILD_MASK 0xf0

	#define AQUANTIA_USX_AUTONEG_CONTROL_ENA 0x0008
	#define AQUANTIA_SI_IN_USE_MASK 0x0078
	#define AQUANTIA_SI_USXGMII 0x0018

	/* registers in MDIO_MMD_VEND1 region */
	#define AQUANTIA_VND1_GLOBAL_SC 0x000
	#define AQUANTIA_VND1_GLOBAL_SC_LP BIT(0xb)

	#define GLOBAL_FIRMWARE_ID 0x20
	#define GLOBAL_FAULT 0xc850
	#define GLOBAL_RSTATUS_1 0xc885

	#define GLOBAL_ALARM_1 0xcc00
	#define SYSTEM_READY_BIT 0x40

	#define GLOBAL_STANDARD_CONTROL 0x0
	#define SOFT_RESET BIT(15)
	#define LOW_POWER BIT(11)

	#define MAILBOX_CONTROL 0x0200
	#define MAILBOX_EXECUTE BIT(15)
	#define MAILBOX_WRITE BIT(14)
	#define MAILBOX_RESET_CRC BIT(12)
	#define MAILBOX_BUSY BIT(8)

	#define MAILBOX_CRC 0x0201

	#define MAILBOX_ADDR_MSW 0x0202
	#define MAILBOX_ADDR_LSW 0x0203

	#define MAILBOX_DATA_MSW 0x0204
	#define MAILBOX_DATA_LSW 0x0205

	#define UP_CONTROL 0xc001
	#define UP_RESET BIT(15)
	#define UP_RUN_STALL_OVERRIDE BIT(6)
	#define UP_RUN_STALL BIT(0)

	#define AQUANTIA_PMA_RX_VENDOR_P1 0xe400
	#define AQUANTIA_PMA_RX_VENDOR_P1_MDI_MSK GENMASK(1, 0)
	/* MDI reversal configured through registers */
	#define AQUANTIA_PMA_RX_VENDOR_P1_MDI_CFG BIT(1)
	/* MDI reversal enabled */
	#define AQUANTIA_PMA_RX_VENDOR_P1_MDI_REV BIT(0)

	/*
	* global start rate, the protocol associated with this speed is used by default
	* on SI.
	*/
	#define AQUANTIA_VND1_GSTART_RATE 0x31a
	#define AQUANTIA_VND1_GSTART_RATE_OFF 0
	#define AQUANTIA_VND1_GSTART_RATE_100M 1
	#define AQUANTIA_VND1_GSTART_RATE_1G 2
	#define AQUANTIA_VND1_GSTART_RATE_10G 3
	#define AQUANTIA_VND1_GSTART_RATE_2_5G 4
	#define AQUANTIA_VND1_GSTART_RATE_5G 5

	/* SYSCFG registers for 100M, 1G, 2.5G, 5G, 10G */
	#define AQUANTIA_VND1_GSYSCFG_BASE 0x31b
	#define AQUANTIA_VND1_GSYSCFG_100M 0
	#define AQUANTIA_VND1_GSYSCFG_1G 1
	#define AQUANTIA_VND1_GSYSCFG_2_5G 2
	#define AQUANTIA_VND1_GSYSCFG_5G 3
	#define AQUANTIA_VND1_GSYSCFG_10G 4

	#define AQUANTIA_VND1_SMBUS0 0xc485
	#define AQUANTIA_VND1_SMBUS1 0xc495

	/* addresses of memory segments in the phy */
	#define DRAM_BASE_ADDR 0x3FFE0000
	#define IRAM_BASE_ADDR 0x40000000

	/* firmware image format constants */
	#define VERSION_STRING_SIZE 0x40
	#define VERSION_STRING_OFFSET 0x0200
	#define HEADER_OFFSET 0x300

	/* driver private data */
	#define AQUANTIA_NA 0
	#define AQUANTIA_GEN1 1
	#define AQUANTIA_GEN2 2
	#define AQUANTIA_GEN3 3

	#pragma pack(1)
	struct fw_header {
	u8 padding[4];
	u8 iram_offset[3];
	u8 iram_size[3];
	u8 dram_offset[3];
	u8 dram_size[3];
	};

	#pragma pack()

	#if defined(CONFIG_PHY_AQUANTIA_UPLOAD_FW)
	static int aquantia_read_fw(u8 *fw_addr, size_t fw_length)
	{
	loff_t length, read;
	int ret;
	void *addr = NULL;

	*fw_addr = NULL;
	*fw_length = 0;
	debug("Loading Acquantia microcode from %s %s\n",
	CONFIG_PHY_AQUANTIA_FW_PART, CONFIG_PHY_AQUANTIA_FW_NAME);
	ret = fs_set_blk_dev("mmc", CONFIG_PHY_AQUANTIA_FW_PART, FS_TYPE_ANY);
	if (ret < 0)
	goto cleanup;

	ret = fs_size(CONFIG_PHY_AQUANTIA_FW_NAME, &length);
	if (ret < 0)
	goto cleanup;

	addr = malloc(length);
	if (!addr) {
	ret = -ENOMEM;
	goto cleanup;
	}

	ret = fs_set_blk_dev("mmc", CONFIG_PHY_AQUANTIA_FW_PART, FS_TYPE_ANY);
	if (ret < 0)
	goto cleanup;

	ret = fs_read(CONFIG_PHY_AQUANTIA_FW_NAME, (ulong)addr, 0, length,
	&read);
	if (ret < 0)
	goto cleanup;

	*fw_addr = addr;
	*fw_length = length;
	debug("Found Acquantia microcode.\n");

	cleanup:
	if (ret < 0) {
	printf("loading firmware file %s %s failed with error %d\n",
	CONFIG_PHY_AQUANTIA_FW_PART,
	CONFIG_PHY_AQUANTIA_FW_NAME, ret);
	free(addr);
	}
	return ret;
	}

	/* load data into the phy's memory */
	static int aquantia_load_memory(struct phy_device *phydev, u32 addr,
	const u8 *data, size_t len)
	{
	size_t pos;
	u16 crc = 0, up_crc;

	phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_CONTROL, MAILBOX_RESET_CRC);
	phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_ADDR_MSW, addr >> 16);
	phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_ADDR_LSW, addr & 0xfffc);

	for (pos = 0; pos < len; pos += min(sizeof(u32), len - pos)) {
	u32 word = 0;

	memcpy(&word, &data[pos], min(sizeof(u32), len - pos));

	phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_DATA_MSW,
	(word >> 16));
	phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_DATA_LSW,
	word & 0xffff);

	phy_write(phydev, MDIO_MMD_VEND1, MAILBOX_CONTROL,
	MAILBOX_EXECUTE \| MAILBOX_WRITE);

	/* keep a big endian CRC to match the phy processor */
	word = cpu_to_be32(word);
	crc = crc16_ccitt(crc, (u8 *)&word, sizeof(word));
	}

	up_crc = phy_read(phydev, MDIO_MMD_VEND1, MAILBOX_CRC);
	if (crc != up_crc) {
	printf("%s crc mismatch: calculated 0x%04hx phy 0x%04hx\n",
	phydev->dev->name, crc, up_crc);
	return -EINVAL;
	}
	return 0;
	}

	static u32 unpack_u24(const u8 *data)
	{
	return (data[2] << 16) + (data[1] << 8) + data[0];
	}

	static int aquantia_upload_firmware(struct phy_device *phydev)
	{
	int ret;
	u8 *addr = NULL;
	size_t fw_length = 0;
	u16 calculated_crc, read_crc;
	char version[VERSION_STRING_SIZE];
	u32 primary_offset, iram_offset, iram_size, dram_offset, dram_size;
	const struct fw_header *header;

	ret = aquantia_read_fw(&addr, &fw_length);
	if (ret != 0)
	return ret;

	read_crc = (addr[fw_length - 2] << 8) \| addr[fw_length - 1];
	calculated_crc = crc16_ccitt(0, addr, fw_length - 2);
	if (read_crc != calculated_crc) {
	printf("%s bad firmware crc: file 0x%04x calculated 0x%04x\n",
	phydev->dev->name, read_crc, calculated_crc);
	ret = -EINVAL;
	goto done;
	}

	/* Find the DRAM and IRAM sections within the firmware file. */
	primary_offset = ((addr[9] & 0xf) << 8 \| addr[8]) << 12;

	header = (struct fw_header *)&addr[primary_offset + HEADER_OFFSET];

	iram_offset = primary_offset + unpack_u24(header->iram_offset);
	iram_size = unpack_u24(header->iram_size);

	dram_offset = primary_offset + unpack_u24(header->dram_offset);
	dram_size = unpack_u24(header->dram_size);

	debug("primary %d iram offset=%d size=%d dram offset=%d size=%d\n",
	primary_offset, iram_offset, iram_size, dram_offset, dram_size);

	strlcpy(version, (char *)&addr[dram_offset + VERSION_STRING_OFFSET],
	VERSION_STRING_SIZE);
	printf("%s loading firmare version '%s'\n", phydev->dev->name, version);

	/* stall the microcprocessor */
	phy_write(phydev, MDIO_MMD_VEND1, UP_CONTROL,
	UP_RUN_STALL \| UP_RUN_STALL_OVERRIDE);

	debug("loading dram 0x%08x from offset=%d size=%d\n",
	DRAM_BASE_ADDR, dram_offset, dram_size);
	ret = aquantia_load_memory(phydev, DRAM_BASE_ADDR, &addr[dram_offset],
	dram_size);
	if (ret != 0)
	goto done;

	debug("loading iram 0x%08x from offset=%d size=%d\n",
	IRAM_BASE_ADDR, iram_offset, iram_size);
	ret = aquantia_load_memory(phydev, IRAM_BASE_ADDR, &addr[iram_offset],
	iram_size);
	if (ret != 0)
	goto done;

	/* make sure soft reset and low power mode are clear */
	phy_write(phydev, MDIO_MMD_VEND1, GLOBAL_STANDARD_CONTROL, 0);

	/* Release the microprocessor. UP_RESET must be held for 100 usec. */
	phy_write(phydev, MDIO_MMD_VEND1, UP_CONTROL,
	UP_RUN_STALL \| UP_RUN_STALL_OVERRIDE \| UP_RESET);

	udelay(100);

	phy_write(phydev, MDIO_MMD_VEND1, UP_CONTROL, UP_RUN_STALL_OVERRIDE);

	printf("%s firmare loading done.\n", phydev->dev->name);
	done:
	free(addr);
	return ret;
	}
	#else
	static int aquantia_upload_firmware(struct phy_device *phydev)
	{
	printf("ERROR %s firmware loading disabled.\n", phydev->dev->name);
	return -1;
	}
	#endif

	struct {
	u16 syscfg;
	int cnt;
	u16 start_rate;
	} aquantia_syscfg[PHY_INTERFACE_MODE_MAX] = {
	[PHY_INTERFACE_MODE_SGMII] = {0x04b, AQUANTIA_VND1_GSYSCFG_1G,
	AQUANTIA_VND1_GSTART_RATE_1G},
	[PHY_INTERFACE_MODE_2500BASEX] = {0x144, AQUANTIA_VND1_GSYSCFG_2_5G,
	AQUANTIA_VND1_GSTART_RATE_2_5G},
	[PHY_INTERFACE_MODE_10GBASER] = {0x100, AQUANTIA_VND1_GSYSCFG_10G,
	AQUANTIA_VND1_GSTART_RATE_10G},
	[PHY_INTERFACE_MODE_USXGMII] = {0x080, AQUANTIA_VND1_GSYSCFG_10G,
	AQUANTIA_VND1_GSTART_RATE_10G},
	};

	static int aquantia_set_proto(struct phy_device *phydev,
	phy_interface_t interface)
	{
	int i;

	if (!aquantia_syscfg[interface].cnt)
	return 0;

	/* set the default rate to enable the SI link */
	phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_GSTART_RATE,
	aquantia_syscfg[interface].start_rate);

	/* set selected protocol for all relevant line side link speeds */
	for (i = 0; i <= aquantia_syscfg[interface].cnt; i++)
	phy_write(phydev, MDIO_MMD_VEND1,
	AQUANTIA_VND1_GSYSCFG_BASE + i,
	aquantia_syscfg[interface].syscfg);
	return 0;
	}

	static int aquantia_dts_config(struct phy_device *phydev)
	{
	#ifdef CONFIG_DM_ETH
	ofnode node = phydev->node;
	u32 prop;
	u16 reg;

	/* this code only works on gen2 and gen3 PHYs */
	if (phydev->drv->data != AQUANTIA_GEN2 &&
	phydev->drv->data != AQUANTIA_GEN3)
	return -ENOTSUPP;

	if (!ofnode_valid(node))
	return 0;

	if (!ofnode_read_u32(node, "mdi-reversal", &prop)) {
	debug("mdi-reversal = %d\n", (int)prop);
	reg = phy_read(phydev, MDIO_MMD_PMAPMD,
	AQUANTIA_PMA_RX_VENDOR_P1);
	reg &= ~AQUANTIA_PMA_RX_VENDOR_P1_MDI_MSK;
	reg \|= AQUANTIA_PMA_RX_VENDOR_P1_MDI_CFG;
	reg \|= prop ? AQUANTIA_PMA_RX_VENDOR_P1_MDI_REV : 0;
	phy_write(phydev, MDIO_MMD_PMAPMD, AQUANTIA_PMA_RX_VENDOR_P1,
	reg);
	}
	if (!ofnode_read_u32(node, "smb-addr", &prop)) {
	debug("smb-addr = %x\n", (int)prop);
	/*
	* there are two addresses here, normally just one bus would
	* be in use so we're setting both regs using the same DT
	* property.
	*/
	phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_SMBUS0,
	(u16)(prop << 1));
	phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_SMBUS1,
	(u16)(prop << 1));
	}

	#endif
	return 0;
	}

	static bool aquantia_link_is_up(struct phy_device *phydev)
	{
	u16 reg, regmask;
	int devad, regnum;

	/*
	* On Gen 2 and 3 we have a bit that indicates that both system and
	* line side are ready for data, use that if possible.
	*/
	if (phydev->drv->data == AQUANTIA_GEN2 \|\|
	phydev->drv->data == AQUANTIA_GEN3) {
	devad = MDIO_MMD_PHYXS;
	regnum = AQUANTIA_SYSTEM_INTERFACE_SR;
	regmask = AQUANTIA_SYSTEM_INTERFACE_SR_READY;
	} else {
	devad = MDIO_MMD_AN;
	regnum = MDIO_STAT1;
	regmask = MDIO_AN_STAT1_COMPLETE;
	}
	/* the register should be latched, do a double read */
	phy_read(phydev, devad, regnum);
	reg = phy_read(phydev, devad, regnum);

	return !!(reg & regmask);
	}

	int aquantia_config(struct phy_device *phydev)
	{
	int interface = phydev->interface;
	u32 val, id, rstatus, fault;
	u32 reg_val1 = 0;
	int num_retries = 5;
	int usx_an = 0;

	/*
	* check if the system is out of reset and init sequence completed.
	* chip-wide reset for gen1 quad phys takes longer
	*/
	while (--num_retries) {
	rstatus = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_ALARM_1);
	if (rstatus & SYSTEM_READY_BIT)
	break;
	mdelay(10);
	}

	id = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_FIRMWARE_ID);
	rstatus = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_RSTATUS_1);
	fault = phy_read(phydev, MDIO_MMD_VEND1, GLOBAL_FAULT);

	if (id != 0)
	debug("%s running firmware version %X.%X.%X\n",
	phydev->dev->name, (id >> 8), id & 0xff,
	(rstatus >> 4) & 0xf);

	if (fault != 0)
	printf("%s fault 0x%04x detected\n", phydev->dev->name, fault);

	if (id == 0 \|\| fault != 0) {
	int ret;

	ret = aquantia_upload_firmware(phydev);
	if (ret != 0)
	return ret;
	}
	/*
	* for backward compatibility convert XGMII into either 10GBase-R or
	* USXGMII based on FW config
	*/
	if (interface == PHY_INTERFACE_MODE_XGMII) {
	debug("use 10GBase-R or USXGMII SI protos, XGMII is not valid\n");

	reg_val1 = phy_read(phydev, MDIO_MMD_PHYXS,
	AQUANTIA_SYSTEM_INTERFACE_SR);
	if ((reg_val1 & AQUANTIA_SI_IN_USE_MASK) == AQUANTIA_SI_USXGMII)
	interface = PHY_INTERFACE_MODE_USXGMII;
	else
	interface = PHY_INTERFACE_MODE_10GBASER;
	}

	/*
	* if link is up already we can just use it, otherwise configure
	* the protocols in the PHY. If link is down set the system
	* interface protocol to use based on phydev->interface
	*/
	if (!aquantia_link_is_up(phydev) &&
	(phydev->drv->data == AQUANTIA_GEN2 \|\|
	phydev->drv->data == AQUANTIA_GEN3)) {
	/* set PHY in low power mode so we can configure protocols */
	phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_GLOBAL_SC,
	AQUANTIA_VND1_GLOBAL_SC_LP);
	mdelay(10);

	/* configure protocol based on phydev->interface */
	aquantia_set_proto(phydev, interface);
	/* apply custom configuration based on DT */
	aquantia_dts_config(phydev);

	/* wake PHY back up */
	phy_write(phydev, MDIO_MMD_VEND1, AQUANTIA_VND1_GLOBAL_SC, 0);
	mdelay(10);
	}

	val = phy_read(phydev, MDIO_MMD_PMAPMD, MII_BMCR);

	switch (interface) {
	case PHY_INTERFACE_MODE_SGMII:
	/* 1000BASE-T mode */
	phydev->advertising = SUPPORTED_1000baseT_Full;
	phydev->supported = phydev->advertising;

	val = (val & ~AQUNTIA_SPEED_LSB_MASK) \| AQUNTIA_SPEED_MSB_MASK;
	phy_write(phydev, MDIO_MMD_PMAPMD, MII_BMCR, val);
	break;
	case PHY_INTERFACE_MODE_USXGMII:
	usx_an = 1;
	/* FALLTHROUGH */
	case PHY_INTERFACE_MODE_10GBASER:
	/* 10GBASE-T mode */
	phydev->advertising = SUPPORTED_10000baseT_Full;
	phydev->supported = phydev->advertising;

	if (!(val & AQUNTIA_SPEED_LSB_MASK) \|\|
	!(val & AQUNTIA_SPEED_MSB_MASK))
	phy_write(phydev, MDIO_MMD_PMAPMD, MII_BMCR,
	AQUNTIA_SPEED_LSB_MASK \|
	AQUNTIA_SPEED_MSB_MASK);

	/* If SI is USXGMII then start USXGMII autoneg */
	reg_val1 = phy_read(phydev, MDIO_MMD_PHYXS,
	AQUANTIA_VENDOR_PROVISIONING_REG);

	if (usx_an) {
	reg_val1 \|= AQUANTIA_USX_AUTONEG_CONTROL_ENA;
	debug("%s: system interface USXGMII\n",
	phydev->dev->name);
	} else {
	reg_val1 &= ~AQUANTIA_USX_AUTONEG_CONTROL_ENA;
	debug("%s: system interface 10GBase-R\n",
	phydev->dev->name);
	}

	phy_write(phydev, MDIO_MMD_PHYXS,
	AQUANTIA_VENDOR_PROVISIONING_REG, reg_val1);
	break;
	case PHY_INTERFACE_MODE_2500BASEX:
	/* 2.5GBASE-T mode */
	phydev->advertising = SUPPORTED_1000baseT_Full;
	phydev->supported = phydev->advertising;

	phy_write(phydev, MDIO_MMD_AN, AQUNTIA_10G_CTL, 1);
	phy_write(phydev, MDIO_MMD_AN, AQUNTIA_VENDOR_P1, 0x9440);
	break;
	case PHY_INTERFACE_MODE_MII:
	/* 100BASE-TX mode */
	phydev->advertising = SUPPORTED_100baseT_Full;
	phydev->supported = phydev->advertising;

	val = (val & ~AQUNTIA_SPEED_MSB_MASK) \| AQUNTIA_SPEED_LSB_MASK;
	phy_write(phydev, MDIO_MMD_PMAPMD, MII_BMCR, val);
	break;
	};

	val = phy_read(phydev, MDIO_MMD_VEND1, AQUANTIA_RESERVED_STATUS);
	reg_val1 = phy_read(phydev, MDIO_MMD_VEND1, AQUANTIA_FIRMWARE_ID);

	debug("%s: %s Firmware Version %x.%x.%x\n", phydev->dev->name,
	phydev->drv->name,
	(reg_val1 & AQUANTIA_FIRMWARE_MAJOR_MASK) >> 8,
	reg_val1 & AQUANTIA_FIRMWARE_MINOR_MASK,
	(val & AQUANTIA_FIRMWARE_BUILD_MASK) >> 4);

	return 0;
	}

	int aquantia_startup(struct phy_device *phydev)
	{
	u32 speed;
	int i = 0;
	int reg;

	phydev->duplex = DUPLEX_FULL;

	/* if the AN is still in progress, wait till timeout. */
	if (!aquantia_link_is_up(phydev)) {
	printf("%s Waiting for PHY auto negotiation to complete",
	phydev->dev->name);
	do {
	udelay(1000);
	if ((i++ % 500) == 0)
	printf(".");
	} while (!aquantia_link_is_up(phydev) &&
	i < (4 * PHY_ANEG_TIMEOUT));

	if (i > PHY_ANEG_TIMEOUT)
	printf(" TIMEOUT !\n");
	}

	/* Read twice because link state is latched and a
	* read moves the current state into the register */
	phy_read(phydev, MDIO_MMD_AN, MDIO_STAT1);
	reg = phy_read(phydev, MDIO_MMD_AN, MDIO_STAT1);
	if (reg < 0 \|\| !(reg & MDIO_STAT1_LSTATUS))
	phydev->link = 0;
	else
	phydev->link = 1;

	speed = phy_read(phydev, MDIO_MMD_PMAPMD, MII_BMCR);
	if (speed & AQUNTIA_SPEED_MSB_MASK) {
	if (speed & AQUNTIA_SPEED_LSB_MASK)
	phydev->speed = SPEED_10000;
	else
	phydev->speed = SPEED_1000;
	} else {
	if (speed & AQUNTIA_SPEED_LSB_MASK)
	phydev->speed = SPEED_100;
	else
	phydev->speed = SPEED_10;
	}

	return 0;
	}

	struct phy_driver aq1202_driver = {
	.name = "Aquantia AQ1202",
	.uid = 0x3a1b445,
	.mask = 0xfffffff0,
	.features = PHY_10G_FEATURES,
	.mmds = (MDIO_MMD_PMAPMD \| MDIO_MMD_PCS\|
	MDIO_MMD_PHYXS \| MDIO_MMD_AN \|
	MDIO_MMD_VEND1),
	.config = &aquantia_config,
	.startup = &aquantia_startup,
	.shutdown = &gen10g_shutdown,
	};

	struct phy_driver aq2104_driver = {
	.name = "Aquantia AQ2104",
	.uid = 0x3a1b460,
	.mask = 0xfffffff0,
	.features = PHY_10G_FEATURES,
	.mmds = (MDIO_MMD_PMAPMD \| MDIO_MMD_PCS\|
	MDIO_MMD_PHYXS \| MDIO_MMD_AN \|
	MDIO_MMD_VEND1),
	.config = &aquantia_config,
	.startup = &aquantia_startup,
	.shutdown = &gen10g_shutdown,
	};

	struct phy_driver aqr105_driver = {
	.name = "Aquantia AQR105",
	.uid = 0x3a1b4a2,
	.mask = 0xfffffff0,
	.features = PHY_10G_FEATURES,
	.mmds = (MDIO_MMD_PMAPMD \| MDIO_MMD_PCS\|
	MDIO_MMD_PHYXS \| MDIO_MMD_AN \|
	MDIO_MMD_VEND1),
	.config = &aquantia_config,
	.startup = &aquantia_startup,
	.shutdown = &gen10g_shutdown,
	.data = AQUANTIA_GEN1,
	};

	struct phy_driver aqr106_driver = {
	.name = "Aquantia AQR106",
	.uid = 0x3a1b4d0,
	.mask = 0xfffffff0,
	.features = PHY_10G_FEATURES,
	.mmds = (MDIO_MMD_PMAPMD \| MDIO_MMD_PCS\|
	MDIO_MMD_PHYXS \| MDIO_MMD_AN \|
	MDIO_MMD_VEND1),
	.config = &aquantia_config,
	.startup = &aquantia_startup,
	.shutdown = &gen10g_shutdown,
	};

	struct phy_driver aqr107_driver = {
	.name = "Aquantia AQR107",
	.uid = 0x3a1b4e0,
	.mask = 0xfffffff0,
	.features = PHY_10G_FEATURES,
	.mmds = (MDIO_MMD_PMAPMD \| MDIO_MMD_PCS\|
	MDIO_MMD_PHYXS \| MDIO_MMD_AN \|
	MDIO_MMD_VEND1),
	.config = &aquantia_config,
	.startup = &aquantia_startup,
	.shutdown = &gen10g_shutdown,
	.data = AQUANTIA_GEN2,
	};

	struct phy_driver aqr112_driver = {
	.name = "Aquantia AQR112",
	.uid = 0x3a1b660,
	.mask = 0xfffffff0,
	.features = PHY_10G_FEATURES,
	.mmds = (MDIO_MMD_PMAPMD \| MDIO_MMD_PCS \|
	MDIO_MMD_PHYXS \| MDIO_MMD_AN \|
	MDIO_MMD_VEND1),
	.config = &aquantia_config,
	.startup = &aquantia_startup,
	.shutdown = &gen10g_shutdown,
	.data = AQUANTIA_GEN3,
	};

	struct phy_driver aqr113c_driver = {
	.name = "Aquantia AQR113C",
	.uid = 0x31c31c12,
	.mask = 0xfffffff0,
	.features = PHY_10G_FEATURES,
	.mmds = (MDIO_MMD_PMAPMD \| MDIO_MMD_PCS \|
	MDIO_MMD_PHYXS \| MDIO_MMD_AN \|
	MDIO_MMD_VEND1),
	.config = &aquantia_config,
	.startup = &aquantia_startup,
	.shutdown = &gen10g_shutdown,
	.data = AQUANTIA_GEN3,
	};

	struct phy_driver aqr405_driver = {
	.name = "Aquantia AQR405",
	.uid = 0x3a1b4b2,
	.mask = 0xfffffff0,
	.features = PHY_10G_FEATURES,
	.mmds = (MDIO_MMD_PMAPMD \| MDIO_MMD_PCS\|
	MDIO_MMD_PHYXS \| MDIO_MMD_AN \|
	MDIO_MMD_VEND1),
	.config = &aquantia_config,
	.startup = &aquantia_startup,
	.shutdown = &gen10g_shutdown,
	.data = AQUANTIA_GEN1,
	};

	struct phy_driver aqr412_driver = {
	.name = "Aquantia AQR412",
	.uid = 0x3a1b710,
	.mask = 0xfffffff0,
	.features = PHY_10G_FEATURES,
	.mmds = (MDIO_MMD_PMAPMD \| MDIO_MMD_PCS \|
	MDIO_MMD_PHYXS \| MDIO_MMD_AN \|
	MDIO_MMD_VEND1),
	.config = &aquantia_config,
	.startup = &aquantia_startup,
	.shutdown = &gen10g_shutdown,
	.data = AQUANTIA_GEN3,
	};

	int phy_aquantia_init(void)
	{
	phy_register(&aq1202_driver);
	phy_register(&aq2104_driver);
	phy_register(&aqr105_driver);
	phy_register(&aqr106_driver);
	phy_register(&aqr107_driver);
	phy_register(&aqr112_driver);
	phy_register(&aqr113c_driver);
	phy_register(&aqr405_driver);
	phy_register(&aqr412_driver);

	return 0;
	}