drivers/usb/eth/lan7x.c

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