1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (c) 2017 Microchip Technology Inc. All rights reserved. 4 */ 5 6 #include <dm.h> 7 #include <malloc.h> 8 #include <miiphy.h> 9 #include <memalign.h> 10 #include <usb.h> 11 #include <linux/ethtool.h> 12 #include <linux/mii.h> 13 #include "usb_ether.h" 14 #include "lan7x.h" 15 16 /* 17 * Lan7x infrastructure commands 18 */ 19 int lan7x_write_reg(struct usb_device *udev, u32 index, u32 data) 20 { 21 int len; 22 ALLOC_CACHE_ALIGN_BUFFER(u32, tmpbuf, 1); 23 24 cpu_to_le32s(&data); 25 tmpbuf[0] = data; 26 27 len = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 28 USB_VENDOR_REQUEST_WRITE_REGISTER, 29 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 30 0, index, tmpbuf, sizeof(data), 31 USB_CTRL_SET_TIMEOUT_MS); 32 if (len != sizeof(data)) { 33 debug("%s failed: index=%d, data=%d, len=%d", 34 __func__, index, data, len); 35 return -EIO; 36 } 37 return 0; 38 } 39 40 int lan7x_read_reg(struct usb_device *udev, u32 index, u32 *data) 41 { 42 int len; 43 ALLOC_CACHE_ALIGN_BUFFER(u32, tmpbuf, 1); 44 45 len = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 46 USB_VENDOR_REQUEST_READ_REGISTER, 47 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 48 0, index, tmpbuf, sizeof(*data), 49 USB_CTRL_GET_TIMEOUT_MS); 50 *data = tmpbuf[0]; 51 if (len != sizeof(*data)) { 52 debug("%s failed: index=%d, len=%d", __func__, index, len); 53 return -EIO; 54 } 55 56 le32_to_cpus(data); 57 return 0; 58 } 59 60 static int lan7x_phy_wait_not_busy(struct usb_device *udev) 61 { 62 return lan7x_wait_for_bit(udev, __func__, 63 MII_ACC, MII_ACC_MII_BUSY, 64 false, 100, 0); 65 } 66 67 int lan7x_mdio_read(struct usb_device *udev, int phy_id, int idx) 68 { 69 u32 val, addr; 70 71 /* confirm MII not busy */ 72 if (lan7x_phy_wait_not_busy(udev)) { 73 debug("MII is busy in %s\n", __func__); 74 return -ETIMEDOUT; 75 } 76 77 /* set the address, index & direction (read from PHY) */ 78 addr = (phy_id << 11) | (idx << 6) | 79 MII_ACC_MII_READ | MII_ACC_MII_BUSY; 80 lan7x_write_reg(udev, MII_ACC, addr); 81 82 if (lan7x_phy_wait_not_busy(udev)) { 83 debug("Timed out reading MII reg %02X\n", idx); 84 return -ETIMEDOUT; 85 } 86 87 lan7x_read_reg(udev, MII_DATA, &val); 88 89 return val & 0xFFFF; 90 } 91 92 void lan7x_mdio_write(struct usb_device *udev, int phy_id, int idx, int regval) 93 { 94 u32 addr; 95 96 /* confirm MII not busy */ 97 if (lan7x_phy_wait_not_busy(udev)) { 98 debug("MII is busy in %s\n", __func__); 99 return; 100 } 101 102 lan7x_write_reg(udev, MII_DATA, regval); 103 104 /* set the address, index & direction (write to PHY) */ 105 addr = (phy_id << 11) | (idx << 6) | 106 MII_ACC_MII_WRITE | MII_ACC_MII_BUSY; 107 lan7x_write_reg(udev, MII_ACC, addr); 108 109 if (lan7x_phy_wait_not_busy(udev)) 110 debug("Timed out writing MII reg %02X\n", idx); 111 } 112 113 /* 114 * Lan7x phylib wrappers 115 */ 116 static int lan7x_phylib_mdio_read(struct mii_dev *bus, 117 int addr, int devad, int reg) 118 { 119 struct usb_device *udev = dev_get_parent_priv(bus->priv); 120 121 return lan7x_mdio_read(udev, addr, reg); 122 } 123 124 static int lan7x_phylib_mdio_write(struct mii_dev *bus, 125 int addr, int devad, int reg, u16 val) 126 { 127 struct usb_device *udev = dev_get_parent_priv(bus->priv); 128 129 lan7x_mdio_write(udev, addr, reg, (int)val); 130 131 return 0; 132 } 133 134 /* 135 * Lan7x eeprom functions 136 */ 137 static int lan7x_eeprom_confirm_not_busy(struct usb_device *udev) 138 { 139 return lan7x_wait_for_bit(udev, __func__, 140 E2P_CMD, E2P_CMD_EPC_BUSY, 141 false, 100, 0); 142 } 143 144 static int lan7x_wait_eeprom(struct usb_device *udev) 145 { 146 return lan7x_wait_for_bit(udev, __func__, 147 E2P_CMD, 148 (E2P_CMD_EPC_BUSY | E2P_CMD_EPC_TIMEOUT), 149 false, 100, 0); 150 } 151 152 static int lan7x_read_eeprom(struct usb_device *udev, 153 u32 offset, u32 length, u8 *data) 154 { 155 u32 val; 156 int i, ret; 157 158 ret = lan7x_eeprom_confirm_not_busy(udev); 159 if (ret) 160 return ret; 161 162 for (i = 0; i < length; i++) { 163 val = E2P_CMD_EPC_BUSY | E2P_CMD_EPC_CMD_READ | 164 (offset & E2P_CMD_EPC_ADDR_MASK); 165 lan7x_write_reg(udev, E2P_CMD, val); 166 167 ret = lan7x_wait_eeprom(udev); 168 if (ret) 169 return ret; 170 171 lan7x_read_reg(udev, E2P_DATA, &val); 172 data[i] = val & 0xFF; 173 offset++; 174 } 175 return ret; 176 } 177 178 /* 179 * Lan7x phylib functions 180 */ 181 int lan7x_phylib_register(struct udevice *udev) 182 { 183 struct usb_device *usbdev = dev_get_parent_priv(udev); 184 struct lan7x_private *priv = dev_get_priv(udev); 185 int ret; 186 187 priv->mdiobus = mdio_alloc(); 188 if (!priv->mdiobus) { 189 printf("mdio_alloc failed\n"); 190 return -ENOMEM; 191 } 192 priv->mdiobus->read = lan7x_phylib_mdio_read; 193 priv->mdiobus->write = lan7x_phylib_mdio_write; 194 sprintf(priv->mdiobus->name, 195 "lan7x_mdiobus-d%hu-p%hu", usbdev->devnum, usbdev->portnr); 196 priv->mdiobus->priv = (void *)udev; 197 198 ret = mdio_register(priv->mdiobus); 199 if (ret) { 200 printf("mdio_register failed\n"); 201 free(priv->mdiobus); 202 return -ENOMEM; 203 } 204 205 return 0; 206 } 207 208 int lan7x_eth_phylib_connect(struct udevice *udev, struct ueth_data *dev) 209 { 210 struct lan7x_private *priv = dev_get_priv(udev); 211 212 priv->phydev = phy_connect(priv->mdiobus, dev->phy_id, 213 udev, PHY_INTERFACE_MODE_MII); 214 215 if (!priv->phydev) { 216 printf("phy_connect failed\n"); 217 return -ENODEV; 218 } 219 return 0; 220 } 221 222 int lan7x_eth_phylib_config_start(struct udevice *udev) 223 { 224 struct lan7x_private *priv = dev_get_priv(udev); 225 int ret; 226 227 /* configure supported modes */ 228 priv->phydev->supported = PHY_BASIC_FEATURES | 229 SUPPORTED_1000baseT_Full | 230 SUPPORTED_Pause | 231 SUPPORTED_Asym_Pause; 232 233 priv->phydev->advertising = ADVERTISED_10baseT_Half | 234 ADVERTISED_10baseT_Full | 235 ADVERTISED_100baseT_Half | 236 ADVERTISED_100baseT_Full | 237 ADVERTISED_1000baseT_Full | 238 ADVERTISED_Pause | 239 ADVERTISED_Asym_Pause | 240 ADVERTISED_Autoneg; 241 242 priv->phydev->autoneg = AUTONEG_ENABLE; 243 244 ret = genphy_config_aneg(priv->phydev); 245 if (ret) { 246 printf("genphy_config_aneg failed\n"); 247 return ret; 248 } 249 ret = phy_startup(priv->phydev); 250 if (ret) { 251 printf("phy_startup failed\n"); 252 return ret; 253 } 254 255 debug("** %s() speed %i duplex %i adv %X supp %X\n", __func__, 256 priv->phydev->speed, priv->phydev->duplex, 257 priv->phydev->advertising, priv->phydev->supported); 258 259 return 0; 260 } 261 262 int lan7x_update_flowcontrol(struct usb_device *udev, 263 struct ueth_data *dev, 264 uint32_t *flow, uint32_t *fct_flow) 265 { 266 uint32_t lcladv, rmtadv; 267 u8 cap = 0; 268 struct lan7x_private *priv = dev_get_priv(udev->dev); 269 270 debug("** %s()\n", __func__); 271 debug("** %s() priv->phydev->speed %i duplex %i\n", __func__, 272 priv->phydev->speed, priv->phydev->duplex); 273 274 if (priv->phydev->duplex == DUPLEX_FULL) { 275 lcladv = lan7x_mdio_read(udev, dev->phy_id, MII_ADVERTISE); 276 rmtadv = lan7x_mdio_read(udev, dev->phy_id, MII_LPA); 277 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv); 278 279 debug("TX Flow "); 280 if (cap & FLOW_CTRL_TX) { 281 *flow = (FLOW_CR_TX_FCEN | 0xFFFF); 282 /* set fct_flow thresholds to 20% and 80% */ 283 *fct_flow = ((MAX_RX_FIFO_SIZE * 2) / (10 * 512)) 284 & 0x7FUL; 285 *fct_flow <<= 8UL; 286 *fct_flow |= ((MAX_RX_FIFO_SIZE * 8) / (10 * 512)) 287 & 0x7FUL; 288 debug("EN "); 289 } else { 290 debug("DIS "); 291 } 292 debug("RX Flow "); 293 if (cap & FLOW_CTRL_RX) { 294 *flow |= FLOW_CR_RX_FCEN; 295 debug("EN"); 296 } else { 297 debug("DIS"); 298 } 299 } 300 debug("\n"); 301 return 0; 302 } 303 304 int lan7x_read_eeprom_mac(unsigned char *enetaddr, struct usb_device *udev) 305 { 306 int ret; 307 308 memset(enetaddr, 0, 6); 309 310 ret = lan7x_read_eeprom(udev, 0, 1, enetaddr); 311 312 if ((ret == 0) && (enetaddr[0] == EEPROM_INDICATOR)) { 313 ret = lan7x_read_eeprom(udev, 314 EEPROM_MAC_OFFSET, ETH_ALEN, 315 enetaddr); 316 if ((ret == 0) && is_valid_ethaddr(enetaddr)) { 317 /* eeprom values are valid so use them */ 318 debug("MAC address read from EEPROM %pM\n", 319 enetaddr); 320 return 0; 321 } 322 } 323 debug("MAC address read from EEPROM invalid %pM\n", enetaddr); 324 325 memset(enetaddr, 0, 6); 326 return -EINVAL; 327 } 328 329 int lan7x_pmt_phy_reset(struct usb_device *udev, 330 struct ueth_data *dev) 331 { 332 int ret; 333 u32 data; 334 335 ret = lan7x_read_reg(udev, PMT_CTL, &data); 336 if (ret) 337 return ret; 338 ret = lan7x_write_reg(udev, PMT_CTL, data | PMT_CTL_PHY_RST); 339 if (ret) 340 return ret; 341 342 /* for LAN7x, we need to check PMT_CTL_READY asserted */ 343 ret = lan7x_wait_for_bit(udev, "PMT_CTL_PHY_RST", 344 PMT_CTL, PMT_CTL_PHY_RST, 345 false, 1000, 0); /* could take over 125mS */ 346 if (ret) 347 return ret; 348 349 return lan7x_wait_for_bit(udev, "PMT_CTL_READY", 350 PMT_CTL, PMT_CTL_READY, 351 true, 1000, 0); 352 } 353 354 int lan7x_basic_reset(struct usb_device *udev, 355 struct ueth_data *dev) 356 { 357 int ret; 358 359 dev->phy_id = LAN7X_INTERNAL_PHY_ID; /* fixed phy id */ 360 361 ret = lan7x_write_reg(udev, HW_CFG, HW_CFG_LRST); 362 if (ret) 363 return ret; 364 365 ret = lan7x_wait_for_bit(udev, "HW_CFG_LRST", 366 HW_CFG, HW_CFG_LRST, 367 false, 1000, 0); 368 if (ret) 369 return ret; 370 371 debug("USB devnum %d portnr %d\n", udev->devnum, udev->portnr); 372 373 return lan7x_pmt_phy_reset(udev, dev); 374 } 375 376 void lan7x_eth_stop(struct udevice *dev) 377 { 378 debug("** %s()\n", __func__); 379 } 380 381 int lan7x_eth_send(struct udevice *dev, void *packet, int length) 382 { 383 struct lan7x_private *priv = dev_get_priv(dev); 384 struct ueth_data *ueth = &priv->ueth; 385 int err; 386 int actual_len; 387 u32 tx_cmd_a; 388 u32 tx_cmd_b; 389 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, msg, 390 PKTSIZE + sizeof(tx_cmd_a) + sizeof(tx_cmd_b)); 391 392 debug("** %s(), len %d, buf %#x\n", __func__, length, 393 (unsigned int)(ulong) msg); 394 if (length > PKTSIZE) 395 return -ENOSPC; 396 397 /* LAN7x disable all TX offload features for u-boot */ 398 tx_cmd_a = (u32) (length & TX_CMD_A_LEN_MASK) | TX_CMD_A_FCS; 399 tx_cmd_b = 0; 400 cpu_to_le32s(&tx_cmd_a); 401 cpu_to_le32s(&tx_cmd_b); 402 403 /* prepend cmd_a and cmd_b */ 404 memcpy(msg, &tx_cmd_a, sizeof(tx_cmd_a)); 405 memcpy(msg + sizeof(tx_cmd_a), &tx_cmd_b, sizeof(tx_cmd_b)); 406 memcpy(msg + sizeof(tx_cmd_a) + sizeof(tx_cmd_b), (void *)packet, 407 length); 408 err = usb_bulk_msg(ueth->pusb_dev, 409 usb_sndbulkpipe(ueth->pusb_dev, ueth->ep_out), 410 (void *)msg, 411 length + sizeof(tx_cmd_a) + 412 sizeof(tx_cmd_b), 413 &actual_len, USB_BULK_SEND_TIMEOUT_MS); 414 debug("Tx: len = %u, actual = %u, err = %d\n", 415 (unsigned int)(length + sizeof(tx_cmd_a) + sizeof(tx_cmd_b)), 416 (unsigned int)actual_len, err); 417 418 return err; 419 } 420 421 int lan7x_eth_recv(struct udevice *dev, int flags, uchar **packetp) 422 { 423 struct lan7x_private *priv = dev_get_priv(dev); 424 struct ueth_data *ueth = &priv->ueth; 425 uint8_t *ptr; 426 int ret, len; 427 u32 packet_len = 0; 428 u32 rx_cmd_a = 0; 429 430 len = usb_ether_get_rx_bytes(ueth, &ptr); 431 debug("%s: first try, len=%d\n", __func__, len); 432 if (!len) { 433 if (!(flags & ETH_RECV_CHECK_DEVICE)) 434 return -EAGAIN; 435 ret = usb_ether_receive(ueth, RX_URB_SIZE); 436 if (ret == -EAGAIN) 437 return ret; 438 439 len = usb_ether_get_rx_bytes(ueth, &ptr); 440 debug("%s: second try, len=%d\n", __func__, len); 441 } 442 443 /* 444 * 1st 4 bytes contain the length of the actual data plus error info. 445 * Extract data length. 446 */ 447 if (len < sizeof(packet_len)) { 448 debug("Rx: incomplete packet length\n"); 449 goto err; 450 } 451 memcpy(&rx_cmd_a, ptr, sizeof(rx_cmd_a)); 452 le32_to_cpus(&rx_cmd_a); 453 if (rx_cmd_a & RX_CMD_A_RXE) { 454 debug("Rx: Error header=%#x", rx_cmd_a); 455 goto err; 456 } 457 packet_len = (u16) (rx_cmd_a & RX_CMD_A_LEN_MASK); 458 459 if (packet_len > len - sizeof(packet_len)) { 460 debug("Rx: too large packet: %d\n", packet_len); 461 goto err; 462 } 463 464 /* 465 * For LAN7x, the length in command A does not 466 * include command A, B, and C length. 467 * So use it as is. 468 */ 469 470 *packetp = ptr + 10; 471 return packet_len; 472 473 err: 474 usb_ether_advance_rxbuf(ueth, -1); 475 return -EINVAL; 476 } 477 478 int lan7x_free_pkt(struct udevice *dev, uchar *packet, int packet_len) 479 { 480 struct lan7x_private *priv = dev_get_priv(dev); 481 482 packet_len = ALIGN(packet_len, 4); 483 usb_ether_advance_rxbuf(&priv->ueth, sizeof(u32) + packet_len); 484 485 return 0; 486 } 487 488 int lan7x_eth_remove(struct udevice *dev) 489 { 490 struct lan7x_private *priv = dev_get_priv(dev); 491 492 debug("** %s()\n", __func__); 493 free(priv->phydev); 494 mdio_unregister(priv->mdiobus); 495 mdio_free(priv->mdiobus); 496 497 return 0; 498 } 499