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