drivers/net/smc911x.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * SMSC LAN9[12]1[567] Network driver
   4  *
   5  * (c) 2007 Pengutronix, Sascha Hauer <s.hauer@pengutronix.de>
   6  */
   7
   8 #include <common.h>
   9 #include <command.h>
  10 #include <malloc.h>
  11 #include <net.h>
  12 #include <miiphy.h>
  13 #include <linux/io.h>
  14 #include <linux/types.h>
  15
  16 #include "smc911x.h"
  17
  18 struct chip_id {
  19         u16 id;
  20         char *name;
  21 };
  22
  23 static const struct chip_id chip_ids[] =  {
  24         { CHIP_89218, "LAN89218" },
  25         { CHIP_9115, "LAN9115" },
  26         { CHIP_9116, "LAN9116" },
  27         { CHIP_9117, "LAN9117" },
  28         { CHIP_9118, "LAN9118" },
  29         { CHIP_9211, "LAN9211" },
  30         { CHIP_9215, "LAN9215" },
  31         { CHIP_9216, "LAN9216" },
  32         { CHIP_9217, "LAN9217" },
  33         { CHIP_9218, "LAN9218" },
  34         { CHIP_9220, "LAN9220" },
  35         { CHIP_9221, "LAN9221" },
  36         { 0, NULL },
  37 };
  38
  39 #define DRIVERNAME "smc911x"
  40
  41 #if defined (CONFIG_SMC911X_32_BIT) && \
  42         defined (CONFIG_SMC911X_16_BIT)
  43 #error "SMC911X: Only one of CONFIG_SMC911X_32_BIT and \
  44         CONFIG_SMC911X_16_BIT shall be set"
  45 #endif
  46
  47 #if defined (CONFIG_SMC911X_32_BIT)
  48 static u32 smc911x_reg_read(struct eth_device *dev, u32 offset)
  49 {
  50         return readl(dev->iobase + offset);
  51 }
  52
  53 static void smc911x_reg_write(struct eth_device *dev, u32 offset, u32 val)
  54 {
  55         writel(val, dev->iobase + offset);
  56 }
  57 #elif defined (CONFIG_SMC911X_16_BIT)
  58 static u32 smc911x_reg_read(struct eth_device *dev, u32 offset)
  59 {
  60         return (readw(dev->iobase + offset) & 0xffff) |
  61                (readw(dev->iobase + offset + 2) << 16);
  62 }
  63 static void smc911x_reg_write(struct eth_device *dev, u32 offset, u32 val)
  64 {
  65         writew(val & 0xffff, dev->iobase + offset);
  66         writew(val >> 16, dev->iobase + offset + 2);
  67 }
  68 #else
  69 #error "SMC911X: undefined bus width"
  70 #endif /* CONFIG_SMC911X_16_BIT */
  71
  72 static u32 smc911x_get_mac_csr(struct eth_device *dev, u8 reg)
  73 {
  74         while (smc911x_reg_read(dev, MAC_CSR_CMD) & MAC_CSR_CMD_CSR_BUSY)
  75                 ;
  76         smc911x_reg_write(dev, MAC_CSR_CMD,
  77                         MAC_CSR_CMD_CSR_BUSY | MAC_CSR_CMD_R_NOT_W | reg);
  78         while (smc911x_reg_read(dev, MAC_CSR_CMD) & MAC_CSR_CMD_CSR_BUSY)
  79                 ;
  80
  81         return smc911x_reg_read(dev, MAC_CSR_DATA);
  82 }
  83
  84 static void smc911x_set_mac_csr(struct eth_device *dev, u8 reg, u32 data)
  85 {
  86         while (smc911x_reg_read(dev, MAC_CSR_CMD) & MAC_CSR_CMD_CSR_BUSY)
  87                 ;
  88         smc911x_reg_write(dev, MAC_CSR_DATA, data);
  89         smc911x_reg_write(dev, MAC_CSR_CMD, MAC_CSR_CMD_CSR_BUSY | reg);
  90         while (smc911x_reg_read(dev, MAC_CSR_CMD) & MAC_CSR_CMD_CSR_BUSY)
  91                 ;
  92 }
  93
  94 static int smc911x_detect_chip(struct eth_device *dev)
  95 {
  96         unsigned long val, i;
  97
  98         val = smc911x_reg_read(dev, BYTE_TEST);
  99         if (val == 0xffffffff) {
 100                 /* Special case -- no chip present */
 101                 return -1;
 102         } else if (val != 0x87654321) {
 103                 printf(DRIVERNAME ": Invalid chip endian 0x%08lx\n", val);
 104                 return -1;
 105         }
 106
 107         val = smc911x_reg_read(dev, ID_REV) >> 16;
 108         for (i = 0; chip_ids[i].id != 0; i++) {
 109                 if (chip_ids[i].id == val) break;
 110         }
 111         if (!chip_ids[i].id) {
 112                 printf(DRIVERNAME ": Unknown chip ID %04lx\n", val);
 113                 return -1;
 114         }
 115
 116         dev->priv = (void *)&chip_ids[i];
 117
 118         return 0;
 119 }
 120
 121 static void smc911x_reset(struct eth_device *dev)
 122 {
 123         int timeout;
 124
 125         /*
 126          *  Take out of PM setting first
 127          *  Device is already wake up if PMT_CTRL_READY bit is set
 128          */
 129         if ((smc911x_reg_read(dev, PMT_CTRL) & PMT_CTRL_READY) == 0) {
 130                 /* Write to the bytetest will take out of powerdown */
 131                 smc911x_reg_write(dev, BYTE_TEST, 0x0);
 132
 133                 timeout = 10;
 134
 135                 while (timeout-- &&
 136                         !(smc911x_reg_read(dev, PMT_CTRL) & PMT_CTRL_READY))
 137                         udelay(10);
 138                 if (timeout < 0) {
 139                         printf(DRIVERNAME
 140                                 ": timeout waiting for PM restore\n");
 141                         return;
 142                 }
 143         }
 144
 145         /* Disable interrupts */
 146         smc911x_reg_write(dev, INT_EN, 0);
 147
 148         smc911x_reg_write(dev, HW_CFG, HW_CFG_SRST);
 149
 150         timeout = 1000;
 151         while (timeout-- && smc911x_reg_read(dev, E2P_CMD) & E2P_CMD_EPC_BUSY)
 152                 udelay(10);
 153
 154         if (timeout < 0) {
 155                 printf(DRIVERNAME ": reset timeout\n");
 156                 return;
 157         }
 158
 159         /* Reset the FIFO level and flow control settings */
 160         smc911x_set_mac_csr(dev, FLOW, FLOW_FCPT | FLOW_FCEN);
 161         smc911x_reg_write(dev, AFC_CFG, 0x0050287F);
 162
 163         /* Set to LED outputs */
 164         smc911x_reg_write(dev, GPIO_CFG, 0x70070000);
 165 }
 166
 167 static void smc911x_handle_mac_address(struct eth_device *dev)
 168 {
 169         unsigned long addrh, addrl;
 170         uchar *m = dev->enetaddr;
 171
 172         addrl = m[0] | (m[1] << 8) | (m[2] << 16) | (m[3] << 24);
 173         addrh = m[4] | (m[5] << 8);
 174         smc911x_set_mac_csr(dev, ADDRL, addrl);
 175         smc911x_set_mac_csr(dev, ADDRH, addrh);
 176
 177         printf(DRIVERNAME ": MAC %pM\n", m);
 178 }
 179
 180 static int smc911x_eth_phy_read(struct eth_device *dev,
 181                                 u8 phy, u8 reg, u16 *val)
 182 {
 183         while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY)
 184                 ;
 185
 186         smc911x_set_mac_csr(dev, MII_ACC, phy << 11 | reg << 6 |
 187                                 MII_ACC_MII_BUSY);
 188
 189         while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY)
 190                 ;
 191
 192         *val = smc911x_get_mac_csr(dev, MII_DATA);
 193
 194         return 0;
 195 }
 196
 197 static int smc911x_eth_phy_write(struct eth_device *dev,
 198                                 u8 phy, u8 reg, u16  val)
 199 {
 200         while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY)
 201                 ;
 202
 203         smc911x_set_mac_csr(dev, MII_DATA, val);
 204         smc911x_set_mac_csr(dev, MII_ACC,
 205                 phy << 11 | reg << 6 | MII_ACC_MII_BUSY | MII_ACC_MII_WRITE);
 206
 207         while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY)
 208                 ;
 209         return 0;
 210 }
 211
 212 static int smc911x_phy_reset(struct eth_device *dev)
 213 {
 214         u32 reg;
 215
 216         reg = smc911x_reg_read(dev, PMT_CTRL);
 217         reg &= ~0xfffff030;
 218         reg |= PMT_CTRL_PHY_RST;
 219         smc911x_reg_write(dev, PMT_CTRL, reg);
 220
 221         mdelay(100);
 222
 223         return 0;
 224 }
 225
 226 static void smc911x_phy_configure(struct eth_device *dev)
 227 {
 228         int timeout;
 229         u16 status;
 230
 231         smc911x_phy_reset(dev);
 232
 233         smc911x_eth_phy_write(dev, 1, MII_BMCR, BMCR_RESET);
 234         mdelay(1);
 235         smc911x_eth_phy_write(dev, 1, MII_ADVERTISE, 0x01e1);
 236         smc911x_eth_phy_write(dev, 1, MII_BMCR, BMCR_ANENABLE |
 237                                 BMCR_ANRESTART);
 238
 239         timeout = 5000;
 240         do {
 241                 mdelay(1);
 242                 if ((timeout--) == 0)
 243                         goto err_out;
 244
 245                 if (smc911x_eth_phy_read(dev, 1, MII_BMSR, &status) != 0)
 246                         goto err_out;
 247         } while (!(status & BMSR_LSTATUS));
 248
 249         printf(DRIVERNAME ": phy initialized\n");
 250
 251         return;
 252
 253 err_out:
 254         printf(DRIVERNAME ": autonegotiation timed out\n");
 255 }
 256
 257 static void smc911x_enable(struct eth_device *dev)
 258 {
 259         /* Enable TX */
 260         smc911x_reg_write(dev, HW_CFG, 8 << 16 | HW_CFG_SF);
 261
 262         smc911x_reg_write(dev, GPT_CFG, GPT_CFG_TIMER_EN | 10000);
 263
 264         smc911x_reg_write(dev, TX_CFG, TX_CFG_TX_ON);
 265
 266         /* no padding to start of packets */
 267         smc911x_reg_write(dev, RX_CFG, 0);
 268
 269         smc911x_set_mac_csr(dev, MAC_CR, MAC_CR_TXEN | MAC_CR_RXEN |
 270                                 MAC_CR_HBDIS);
 271 }
 272
 273 static int smc911x_init(struct eth_device *dev, bd_t * bd)
 274 {
 275         struct chip_id *id = dev->priv;
 276
 277         printf(DRIVERNAME ": detected %s controller\n", id->name);
 278
 279         smc911x_reset(dev);
 280
 281         /* Configure the PHY, initialize the link state */
 282         smc911x_phy_configure(dev);
 283
 284         smc911x_handle_mac_address(dev);
 285
 286         /* Turn on Tx + Rx */
 287         smc911x_enable(dev);
 288
 289         return 0;
 290 }
 291
 292 static int smc911x_send(struct eth_device *dev, void *packet, int length)
 293 {
 294         u32 *data = (u32*)packet;
 295         u32 tmplen;
 296         u32 status;
 297
 298         smc911x_reg_write(dev, TX_DATA_FIFO, TX_CMD_A_INT_FIRST_SEG |
 299                                 TX_CMD_A_INT_LAST_SEG | length);
 300         smc911x_reg_write(dev, TX_DATA_FIFO, length);
 301
 302         tmplen = (length + 3) / 4;
 303
 304         while (tmplen--)
 305                 smc911x_reg_write(dev, TX_DATA_FIFO, *data++);
 306
 307         /* wait for transmission */
 308         while (!((smc911x_reg_read(dev, TX_FIFO_INF) &
 309                                         TX_FIFO_INF_TSUSED) >> 16));
 310
 311         /* get status. Ignore 'no carrier' error, it has no meaning for
 312          * full duplex operation
 313          */
 314         status = smc911x_reg_read(dev, TX_STATUS_FIFO) &
 315                         (TX_STS_LOC | TX_STS_LATE_COLL | TX_STS_MANY_COLL |
 316                         TX_STS_MANY_DEFER | TX_STS_UNDERRUN);
 317
 318         if (!status)
 319                 return 0;
 320
 321         printf(DRIVERNAME ": failed to send packet: %s%s%s%s%s\n",
 322                 status & TX_STS_LOC ? "TX_STS_LOC " : "",
 323                 status & TX_STS_LATE_COLL ? "TX_STS_LATE_COLL " : "",
 324                 status & TX_STS_MANY_COLL ? "TX_STS_MANY_COLL " : "",
 325                 status & TX_STS_MANY_DEFER ? "TX_STS_MANY_DEFER " : "",
 326                 status & TX_STS_UNDERRUN ? "TX_STS_UNDERRUN" : "");
 327
 328         return -1;
 329 }
 330
 331 static void smc911x_halt(struct eth_device *dev)
 332 {
 333         smc911x_reset(dev);
 334         smc911x_handle_mac_address(dev);
 335 }
 336
 337 static int smc911x_recv(struct eth_device *dev)
 338 {
 339         u32 *data = (u32 *)net_rx_packets[0];
 340         u32 pktlen, tmplen;
 341         u32 status;
 342
 343         if ((smc911x_reg_read(dev, RX_FIFO_INF) & RX_FIFO_INF_RXSUSED) >> 16) {
 344                 status = smc911x_reg_read(dev, RX_STATUS_FIFO);
 345                 pktlen = (status & RX_STS_PKT_LEN) >> 16;
 346
 347                 smc911x_reg_write(dev, RX_CFG, 0);
 348
 349                 tmplen = (pktlen + 3) / 4;
 350                 while (tmplen--)
 351                         *data++ = smc911x_reg_read(dev, RX_DATA_FIFO);
 352
 353                 if (status & RX_STS_ES)
 354                         printf(DRIVERNAME
 355                                 ": dropped bad packet. Status: 0x%08x\n",
 356                                 status);
 357                 else
 358                         net_process_received_packet(net_rx_packets[0], pktlen);
 359         }
 360
 361         return 0;
 362 }
 363
 364 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
 365 /* wrapper for smc911x_eth_phy_read */
 366 static int smc911x_miiphy_read(struct mii_dev *bus, int phy, int devad,
 367                                int reg)
 368 {
 369         struct eth_device *dev = eth_get_dev_by_name(bus->name);
 370         u16 val = 0;
 371         int ret;
 372
 373         if (!dev)
 374                 return -ENODEV;
 375
 376         ret = smc911x_eth_phy_read(dev, phy, reg, &val);
 377         if (ret < 0)
 378                 return ret;
 379
 380         return val;
 381 }
 382 /* wrapper for smc911x_eth_phy_write */
 383 static int smc911x_miiphy_write(struct mii_dev *bus, int phy, int devad,
 384                                 int reg, u16 val)
 385 {
 386         struct eth_device *dev = eth_get_dev_by_name(bus->name);
 387
 388         if (!dev)
 389                 return -ENODEV;
 390
 391         return smc911x_eth_phy_write(dev, phy, reg, val);
 392 }
 393
 394 static int smc911x_initialize_mii(struct eth_device *dev)
 395 {
 396         struct mii_dev *mdiodev = mdio_alloc();
 397         int ret;
 398
 399         if (!mdiodev)
 400                 return -ENOMEM;
 401
 402         strncpy(mdiodev->name, dev->name, MDIO_NAME_LEN);
 403         mdiodev->read = smc911x_miiphy_read;
 404         mdiodev->write = smc911x_miiphy_write;
 405
 406         ret = mdio_register(mdiodev);
 407         if (ret < 0) {
 408                 mdio_free(mdiodev);
 409                 return ret;
 410         }
 411
 412         return 0;
 413 }
 414 #else
 415 static int smc911x_initialize_mii(struct eth_device *dev)
 416 {
 417         return 0;
 418 }
 419 #endif
 420
 421 int smc911x_initialize(u8 dev_num, int base_addr)
 422 {
 423         unsigned long addrl, addrh;
 424         struct eth_device *dev;
 425         int ret;
 426
 427         dev = calloc(1, sizeof(*dev));
 428         if (!dev)
 429                 return -ENOMEM;
 430
 431         dev->iobase = base_addr;
 432
 433         /* Try to detect chip. Will fail if not present. */
 434         ret = smc911x_detect_chip(dev);
 435         if (ret) {
 436                 ret = 0;        /* Card not detected is not an error */
 437                 goto err_detect;
 438         }
 439
 440         addrh = smc911x_get_mac_csr(dev, ADDRH);
 441         addrl = smc911x_get_mac_csr(dev, ADDRL);
 442         if (!(addrl == 0xffffffff && addrh == 0x0000ffff)) {
 443                 /* address is obtained from optional eeprom */
 444                 dev->enetaddr[0] = addrl;
 445                 dev->enetaddr[1] = addrl >>  8;
 446                 dev->enetaddr[2] = addrl >> 16;
 447                 dev->enetaddr[3] = addrl >> 24;
 448                 dev->enetaddr[4] = addrh;
 449                 dev->enetaddr[5] = addrh >> 8;
 450         }
 451
 452         dev->init = smc911x_init;
 453         dev->halt = smc911x_halt;
 454         dev->send = smc911x_send;
 455         dev->recv = smc911x_recv;
 456         sprintf(dev->name, "%s-%hu", DRIVERNAME, dev_num);
 457
 458         eth_register(dev);
 459
 460         ret = smc911x_initialize_mii(dev);
 461         if (ret)
 462                 goto err_mii;
 463
 464         return 1;
 465
 466 err_mii:
 467         eth_unregister(dev);
 468 err_detect:
 469         free(dev);
 470         return ret;
 471 }