1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (c) 2017 Microchip Technology Inc. All rights reserved.
12 #include <linux/ethtool.h>
13 #include <linux/mii.h>
14 #include "usb_ether.h"
18 * Lan7x infrastructure commands
20 int lan7x_write_reg(struct usb_device *udev, u32 index, u32 data)
23 ALLOC_CACHE_ALIGN_BUFFER(u32, tmpbuf, 1);
28 len = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
29 USB_VENDOR_REQUEST_WRITE_REGISTER,
30 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
31 0, index, tmpbuf, sizeof(data),
32 USB_CTRL_SET_TIMEOUT_MS);
33 if (len != sizeof(data)) {
34 debug("%s failed: index=%d, data=%d, len=%d",
35 __func__, index, data, len);
41 int lan7x_read_reg(struct usb_device *udev, u32 index, u32 *data)
44 ALLOC_CACHE_ALIGN_BUFFER(u32, tmpbuf, 1);
46 len = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
47 USB_VENDOR_REQUEST_READ_REGISTER,
48 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
49 0, index, tmpbuf, sizeof(*data),
50 USB_CTRL_GET_TIMEOUT_MS);
52 if (len != sizeof(*data)) {
53 debug("%s failed: index=%d, len=%d", __func__, index, len);
61 static int lan7x_phy_wait_not_busy(struct usb_device *udev)
63 return lan7x_wait_for_bit(udev, __func__,
64 MII_ACC, MII_ACC_MII_BUSY,
68 int lan7x_mdio_read(struct usb_device *udev, int phy_id, int idx)
72 /* confirm MII not busy */
73 if (lan7x_phy_wait_not_busy(udev)) {
74 debug("MII is busy in %s\n", __func__);
78 /* set the address, index & direction (read from PHY) */
79 addr = (phy_id << 11) | (idx << 6) |
80 MII_ACC_MII_READ | MII_ACC_MII_BUSY;
81 lan7x_write_reg(udev, MII_ACC, addr);
83 if (lan7x_phy_wait_not_busy(udev)) {
84 debug("Timed out reading MII reg %02X\n", idx);
88 lan7x_read_reg(udev, MII_DATA, &val);
93 void lan7x_mdio_write(struct usb_device *udev, int phy_id, int idx, int regval)
97 /* confirm MII not busy */
98 if (lan7x_phy_wait_not_busy(udev)) {
99 debug("MII is busy in %s\n", __func__);
103 lan7x_write_reg(udev, MII_DATA, regval);
105 /* set the address, index & direction (write to PHY) */
106 addr = (phy_id << 11) | (idx << 6) |
107 MII_ACC_MII_WRITE | MII_ACC_MII_BUSY;
108 lan7x_write_reg(udev, MII_ACC, addr);
110 if (lan7x_phy_wait_not_busy(udev))
111 debug("Timed out writing MII reg %02X\n", idx);
115 * Lan7x phylib wrappers
117 static int lan7x_phylib_mdio_read(struct mii_dev *bus,
118 int addr, int devad, int reg)
120 struct usb_device *udev = dev_get_parent_priv(bus->priv);
122 return lan7x_mdio_read(udev, addr, reg);
125 static int lan7x_phylib_mdio_write(struct mii_dev *bus,
126 int addr, int devad, int reg, u16 val)
128 struct usb_device *udev = dev_get_parent_priv(bus->priv);
130 lan7x_mdio_write(udev, addr, reg, (int)val);
136 * Lan7x eeprom functions
138 static int lan7x_eeprom_confirm_not_busy(struct usb_device *udev)
140 return lan7x_wait_for_bit(udev, __func__,
141 E2P_CMD, E2P_CMD_EPC_BUSY,
145 static int lan7x_wait_eeprom(struct usb_device *udev)
147 return lan7x_wait_for_bit(udev, __func__,
149 (E2P_CMD_EPC_BUSY | E2P_CMD_EPC_TIMEOUT),
153 static int lan7x_read_eeprom(struct usb_device *udev,
154 u32 offset, u32 length, u8 *data)
159 ret = lan7x_eeprom_confirm_not_busy(udev);
163 for (i = 0; i < length; i++) {
164 val = E2P_CMD_EPC_BUSY | E2P_CMD_EPC_CMD_READ |
165 (offset & E2P_CMD_EPC_ADDR_MASK);
166 lan7x_write_reg(udev, E2P_CMD, val);
168 ret = lan7x_wait_eeprom(udev);
172 lan7x_read_reg(udev, E2P_DATA, &val);
173 data[i] = val & 0xFF;
180 * Lan7x phylib functions
182 int lan7x_phylib_register(struct udevice *udev)
184 struct usb_device *usbdev = dev_get_parent_priv(udev);
185 struct lan7x_private *priv = dev_get_priv(udev);
188 priv->mdiobus = mdio_alloc();
189 if (!priv->mdiobus) {
190 printf("mdio_alloc failed\n");
193 priv->mdiobus->read = lan7x_phylib_mdio_read;
194 priv->mdiobus->write = lan7x_phylib_mdio_write;
195 sprintf(priv->mdiobus->name,
196 "lan7x_mdiobus-d%hu-p%hu", usbdev->devnum, usbdev->portnr);
197 priv->mdiobus->priv = (void *)udev;
199 ret = mdio_register(priv->mdiobus);
201 printf("mdio_register failed\n");
209 int lan7x_eth_phylib_connect(struct udevice *udev, struct ueth_data *dev)
211 struct lan7x_private *priv = dev_get_priv(udev);
213 priv->phydev = phy_connect(priv->mdiobus, dev->phy_id,
214 udev, PHY_INTERFACE_MODE_MII);
217 printf("phy_connect failed\n");
223 int lan7x_eth_phylib_config_start(struct udevice *udev)
225 struct lan7x_private *priv = dev_get_priv(udev);
228 /* configure supported modes */
229 priv->phydev->supported = PHY_BASIC_FEATURES |
230 SUPPORTED_1000baseT_Full |
232 SUPPORTED_Asym_Pause;
234 priv->phydev->advertising = ADVERTISED_10baseT_Half |
235 ADVERTISED_10baseT_Full |
236 ADVERTISED_100baseT_Half |
237 ADVERTISED_100baseT_Full |
238 ADVERTISED_1000baseT_Full |
240 ADVERTISED_Asym_Pause |
243 priv->phydev->autoneg = AUTONEG_ENABLE;
245 ret = genphy_config_aneg(priv->phydev);
247 printf("genphy_config_aneg failed\n");
250 ret = phy_startup(priv->phydev);
252 printf("phy_startup failed\n");
256 debug("** %s() speed %i duplex %i adv %X supp %X\n", __func__,
257 priv->phydev->speed, priv->phydev->duplex,
258 priv->phydev->advertising, priv->phydev->supported);
263 int lan7x_update_flowcontrol(struct usb_device *udev,
264 struct ueth_data *dev,
265 uint32_t *flow, uint32_t *fct_flow)
267 uint32_t lcladv, rmtadv;
269 struct lan7x_private *priv = dev_get_priv(udev->dev);
271 debug("** %s()\n", __func__);
272 debug("** %s() priv->phydev->speed %i duplex %i\n", __func__,
273 priv->phydev->speed, priv->phydev->duplex);
275 if (priv->phydev->duplex == DUPLEX_FULL) {
276 lcladv = lan7x_mdio_read(udev, dev->phy_id, MII_ADVERTISE);
277 rmtadv = lan7x_mdio_read(udev, dev->phy_id, MII_LPA);
278 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
281 if (cap & FLOW_CTRL_TX) {
282 *flow = (FLOW_CR_TX_FCEN | 0xFFFF);
283 /* set fct_flow thresholds to 20% and 80% */
284 *fct_flow = ((MAX_RX_FIFO_SIZE * 2) / (10 * 512))
287 *fct_flow |= ((MAX_RX_FIFO_SIZE * 8) / (10 * 512))
294 if (cap & FLOW_CTRL_RX) {
295 *flow |= FLOW_CR_RX_FCEN;
305 int lan7x_read_eeprom_mac(unsigned char *enetaddr, struct usb_device *udev)
309 memset(enetaddr, 0, 6);
311 ret = lan7x_read_eeprom(udev, 0, 1, enetaddr);
313 if ((ret == 0) && (enetaddr[0] == EEPROM_INDICATOR)) {
314 ret = lan7x_read_eeprom(udev,
315 EEPROM_MAC_OFFSET, ETH_ALEN,
317 if ((ret == 0) && is_valid_ethaddr(enetaddr)) {
318 /* eeprom values are valid so use them */
319 debug("MAC address read from EEPROM %pM\n",
324 debug("MAC address read from EEPROM invalid %pM\n", enetaddr);
326 memset(enetaddr, 0, 6);
330 int lan7x_pmt_phy_reset(struct usb_device *udev,
331 struct ueth_data *dev)
336 ret = lan7x_read_reg(udev, PMT_CTL, &data);
339 ret = lan7x_write_reg(udev, PMT_CTL, data | PMT_CTL_PHY_RST);
343 /* for LAN7x, we need to check PMT_CTL_READY asserted */
344 ret = lan7x_wait_for_bit(udev, "PMT_CTL_PHY_RST",
345 PMT_CTL, PMT_CTL_PHY_RST,
346 false, 1000, 0); /* could take over 125mS */
350 return lan7x_wait_for_bit(udev, "PMT_CTL_READY",
351 PMT_CTL, PMT_CTL_READY,
355 int lan7x_basic_reset(struct usb_device *udev,
356 struct ueth_data *dev)
360 dev->phy_id = LAN7X_INTERNAL_PHY_ID; /* fixed phy id */
362 ret = lan7x_write_reg(udev, HW_CFG, HW_CFG_LRST);
366 ret = lan7x_wait_for_bit(udev, "HW_CFG_LRST",
372 debug("USB devnum %d portnr %d\n", udev->devnum, udev->portnr);
374 return lan7x_pmt_phy_reset(udev, dev);
377 void lan7x_eth_stop(struct udevice *dev)
379 debug("** %s()\n", __func__);
382 int lan7x_eth_send(struct udevice *dev, void *packet, int length)
384 struct lan7x_private *priv = dev_get_priv(dev);
385 struct ueth_data *ueth = &priv->ueth;
390 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, msg,
391 PKTSIZE + sizeof(tx_cmd_a) + sizeof(tx_cmd_b));
393 debug("** %s(), len %d, buf %#x\n", __func__, length,
394 (unsigned int)(ulong) msg);
395 if (length > PKTSIZE)
398 /* LAN7x disable all TX offload features for u-boot */
399 tx_cmd_a = (u32) (length & TX_CMD_A_LEN_MASK) | TX_CMD_A_FCS;
401 cpu_to_le32s(&tx_cmd_a);
402 cpu_to_le32s(&tx_cmd_b);
404 /* prepend cmd_a and cmd_b */
405 memcpy(msg, &tx_cmd_a, sizeof(tx_cmd_a));
406 memcpy(msg + sizeof(tx_cmd_a), &tx_cmd_b, sizeof(tx_cmd_b));
407 memcpy(msg + sizeof(tx_cmd_a) + sizeof(tx_cmd_b), (void *)packet,
409 err = usb_bulk_msg(ueth->pusb_dev,
410 usb_sndbulkpipe(ueth->pusb_dev, ueth->ep_out),
412 length + sizeof(tx_cmd_a) +
414 &actual_len, USB_BULK_SEND_TIMEOUT_MS);
415 debug("Tx: len = %u, actual = %u, err = %d\n",
416 (unsigned int)(length + sizeof(tx_cmd_a) + sizeof(tx_cmd_b)),
417 (unsigned int)actual_len, err);
422 int lan7x_eth_recv(struct udevice *dev, int flags, uchar **packetp)
424 struct lan7x_private *priv = dev_get_priv(dev);
425 struct ueth_data *ueth = &priv->ueth;
431 len = usb_ether_get_rx_bytes(ueth, &ptr);
432 debug("%s: first try, len=%d\n", __func__, len);
434 if (!(flags & ETH_RECV_CHECK_DEVICE))
436 ret = usb_ether_receive(ueth, RX_URB_SIZE);
440 len = usb_ether_get_rx_bytes(ueth, &ptr);
441 debug("%s: second try, len=%d\n", __func__, len);
445 * 1st 4 bytes contain the length of the actual data plus error info.
446 * Extract data length.
448 if (len < sizeof(packet_len)) {
449 debug("Rx: incomplete packet length\n");
452 memcpy(&rx_cmd_a, ptr, sizeof(rx_cmd_a));
453 le32_to_cpus(&rx_cmd_a);
454 if (rx_cmd_a & RX_CMD_A_RXE) {
455 debug("Rx: Error header=%#x", rx_cmd_a);
458 packet_len = (u16) (rx_cmd_a & RX_CMD_A_LEN_MASK);
460 if (packet_len > len - sizeof(packet_len)) {
461 debug("Rx: too large packet: %d\n", packet_len);
466 * For LAN7x, the length in command A does not
467 * include command A, B, and C length.
475 usb_ether_advance_rxbuf(ueth, -1);
479 int lan7x_free_pkt(struct udevice *dev, uchar *packet, int packet_len)
481 struct lan7x_private *priv = dev_get_priv(dev);
483 packet_len = ALIGN(packet_len, 4);
484 usb_ether_advance_rxbuf(&priv->ueth, sizeof(u32) + packet_len);
489 int lan7x_eth_remove(struct udevice *dev)
491 struct lan7x_private *priv = dev_get_priv(dev);
493 debug("** %s()\n", __func__);
495 mdio_unregister(priv->mdiobus);
496 mdio_free(priv->mdiobus);