git.sur5r.net Git - u-boot/blob - drivers/net/sunxi_emac.c

   1 /*
   2  * sunxi_emac.c -- Allwinner A10 ethernet driver
   3  *
   4  * (C) Copyright 2012, Stefan Roese <sr@denx.de>
   5  *
   6  * SPDX-License-Identifier:     GPL-2.0+
   7  */
   8
   9 #include <common.h>
  10 #include <linux/err.h>
  11 #include <malloc.h>
  12 #include <miiphy.h>
  13 #include <net.h>
  14 #include <asm/io.h>
  15 #include <asm/arch/clock.h>
  16 #include <asm/arch/gpio.h>
  17
  18 /* EMAC register  */
  19 struct emac_regs {
  20         u32 ctl;        /* 0x00 */
  21         u32 tx_mode;    /* 0x04 */
  22         u32 tx_flow;    /* 0x08 */
  23         u32 tx_ctl0;    /* 0x0c */
  24         u32 tx_ctl1;    /* 0x10 */
  25         u32 tx_ins;     /* 0x14 */
  26         u32 tx_pl0;     /* 0x18 */
  27         u32 tx_pl1;     /* 0x1c */
  28         u32 tx_sta;     /* 0x20 */
  29         u32 tx_io_data; /* 0x24 */
  30         u32 tx_io_data1;/* 0x28 */
  31         u32 tx_tsvl0;   /* 0x2c */
  32         u32 tx_tsvh0;   /* 0x30 */
  33         u32 tx_tsvl1;   /* 0x34 */
  34         u32 tx_tsvh1;   /* 0x38 */
  35         u32 rx_ctl;     /* 0x3c */
  36         u32 rx_hash0;   /* 0x40 */
  37         u32 rx_hash1;   /* 0x44 */
  38         u32 rx_sta;     /* 0x48 */
  39         u32 rx_io_data; /* 0x4c */
  40         u32 rx_fbc;     /* 0x50 */
  41         u32 int_ctl;    /* 0x54 */
  42         u32 int_sta;    /* 0x58 */
  43         u32 mac_ctl0;   /* 0x5c */
  44         u32 mac_ctl1;   /* 0x60 */
  45         u32 mac_ipgt;   /* 0x64 */
  46         u32 mac_ipgr;   /* 0x68 */
  47         u32 mac_clrt;   /* 0x6c */
  48         u32 mac_maxf;   /* 0x70 */
  49         u32 mac_supp;   /* 0x74 */
  50         u32 mac_test;   /* 0x78 */
  51         u32 mac_mcfg;   /* 0x7c */
  52         u32 mac_mcmd;   /* 0x80 */
  53         u32 mac_madr;   /* 0x84 */
  54         u32 mac_mwtd;   /* 0x88 */
  55         u32 mac_mrdd;   /* 0x8c */
  56         u32 mac_mind;   /* 0x90 */
  57         u32 mac_ssrr;   /* 0x94 */
  58         u32 mac_a0;     /* 0x98 */
  59         u32 mac_a1;     /* 0x9c */
  60 };
  61
  62 /* SRAMC register  */
  63 struct sunxi_sramc_regs {
  64         u32 ctrl0;
  65         u32 ctrl1;
  66 };
  67
  68 /* 0: Disable       1: Aborted frame enable(default) */
  69 #define EMAC_TX_AB_M            (0x1 << 0)
  70 /* 0: CPU           1: DMA(default) */
  71 #define EMAC_TX_TM              (0x1 << 1)
  72
  73 #define EMAC_TX_SETUP           (0)
  74
  75 /* 0: DRQ asserted  1: DRQ automatically(default) */
  76 #define EMAC_RX_DRQ_MODE        (0x1 << 1)
  77 /* 0: CPU           1: DMA(default) */
  78 #define EMAC_RX_TM              (0x1 << 2)
  79 /* 0: Normal(default)        1: Pass all Frames */
  80 #define EMAC_RX_PA              (0x1 << 4)
  81 /* 0: Normal(default)        1: Pass Control Frames */
  82 #define EMAC_RX_PCF             (0x1 << 5)
  83 /* 0: Normal(default)        1: Pass Frames with CRC Error */
  84 #define EMAC_RX_PCRCE           (0x1 << 6)
  85 /* 0: Normal(default)        1: Pass Frames with Length Error */
  86 #define EMAC_RX_PLE             (0x1 << 7)
  87 /* 0: Normal                 1: Pass Frames length out of range(default) */
  88 #define EMAC_RX_POR             (0x1 << 8)
  89 /* 0: Not accept             1: Accept unicast Packets(default) */
  90 #define EMAC_RX_UCAD            (0x1 << 16)
  91 /* 0: Normal(default)        1: DA Filtering */
  92 #define EMAC_RX_DAF             (0x1 << 17)
  93 /* 0: Not accept             1: Accept multicast Packets(default) */
  94 #define EMAC_RX_MCO             (0x1 << 20)
  95 /* 0: Disable(default)       1: Enable Hash filter */
  96 #define EMAC_RX_MHF             (0x1 << 21)
  97 /* 0: Not accept             1: Accept Broadcast Packets(default) */
  98 #define EMAC_RX_BCO             (0x1 << 22)
  99 /* 0: Disable(default)       1: Enable SA Filtering */
 100 #define EMAC_RX_SAF             (0x1 << 24)
 101 /* 0: Normal(default)        1: Inverse Filtering */
 102 #define EMAC_RX_SAIF            (0x1 << 25)
 103
 104 #define EMAC_RX_SETUP           (EMAC_RX_POR | EMAC_RX_UCAD | EMAC_RX_DAF | \
 105                                  EMAC_RX_MCO | EMAC_RX_BCO)
 106
 107 /* 0: Disable                1: Enable Receive Flow Control(default) */
 108 #define EMAC_MAC_CTL0_RFC       (0x1 << 2)
 109 /* 0: Disable                1: Enable Transmit Flow Control(default) */
 110 #define EMAC_MAC_CTL0_TFC       (0x1 << 3)
 111
 112 #define EMAC_MAC_CTL0_SETUP     (EMAC_MAC_CTL0_RFC | EMAC_MAC_CTL0_TFC)
 113
 114 /* 0: Disable                1: Enable MAC Frame Length Checking(default) */
 115 #define EMAC_MAC_CTL1_FLC       (0x1 << 1)
 116 /* 0: Disable(default)       1: Enable Huge Frame */
 117 #define EMAC_MAC_CTL1_HF        (0x1 << 2)
 118 /* 0: Disable(default)       1: Enable MAC Delayed CRC */
 119 #define EMAC_MAC_CTL1_DCRC      (0x1 << 3)
 120 /* 0: Disable                1: Enable MAC CRC(default) */
 121 #define EMAC_MAC_CTL1_CRC       (0x1 << 4)
 122 /* 0: Disable                1: Enable MAC PAD Short frames(default) */
 123 #define EMAC_MAC_CTL1_PC        (0x1 << 5)
 124 /* 0: Disable(default)       1: Enable MAC PAD Short frames and append CRC */
 125 #define EMAC_MAC_CTL1_VC        (0x1 << 6)
 126 /* 0: Disable(default)       1: Enable MAC auto detect Short frames */
 127 #define EMAC_MAC_CTL1_ADP       (0x1 << 7)
 128 /* 0: Disable(default)       1: Enable */
 129 #define EMAC_MAC_CTL1_PRE       (0x1 << 8)
 130 /* 0: Disable(default)       1: Enable */
 131 #define EMAC_MAC_CTL1_LPE       (0x1 << 9)
 132 /* 0: Disable(default)       1: Enable no back off */
 133 #define EMAC_MAC_CTL1_NB        (0x1 << 12)
 134 /* 0: Disable(default)       1: Enable */
 135 #define EMAC_MAC_CTL1_BNB       (0x1 << 13)
 136 /* 0: Disable(default)       1: Enable */
 137 #define EMAC_MAC_CTL1_ED        (0x1 << 14)
 138
 139 #define EMAC_MAC_CTL1_SETUP     (EMAC_MAC_CTL1_FLC | EMAC_MAC_CTL1_CRC | \
 140                                  EMAC_MAC_CTL1_PC)
 141
 142 #define EMAC_MAC_IPGT           0x15
 143
 144 #define EMAC_MAC_NBTB_IPG1      0xc
 145 #define EMAC_MAC_NBTB_IPG2      0x12
 146
 147 #define EMAC_MAC_CW             0x37
 148 #define EMAC_MAC_RM             0xf
 149
 150 #define EMAC_MAC_MFL            0x0600
 151
 152 /* Receive status */
 153 #define EMAC_CRCERR             (0x1 << 4)
 154 #define EMAC_LENERR             (0x3 << 5)
 155
 156 #define DMA_CPU_TRRESHOLD       2000
 157
 158 struct emac_eth_dev {
 159         struct emac_regs *regs;
 160         struct mii_dev *bus;
 161         struct phy_device *phydev;
 162         int link_printed;
 163 };
 164
 165 struct emac_rxhdr {
 166         s16 rx_len;
 167         u16 rx_status;
 168 };
 169
 170 static void emac_inblk_32bit(void *reg, void *data, int count)
 171 {
 172         int cnt = (count + 3) >> 2;
 173
 174         if (cnt) {
 175                 u32 *buf = data;
 176
 177                 do {
 178                         u32 x = readl(reg);
 179                         *buf++ = x;
 180                 } while (--cnt);
 181         }
 182 }
 183
 184 static void emac_outblk_32bit(void *reg, void *data, int count)
 185 {
 186         int cnt = (count + 3) >> 2;
 187
 188         if (cnt) {
 189                 const u32 *buf = data;
 190
 191                 do {
 192                         writel(*buf++, reg);
 193                 } while (--cnt);
 194         }
 195 }
 196
 197 /* Read a word from phyxcer */
 198 static int emac_mdio_read(struct mii_dev *bus, int addr, int devad, int reg)
 199 {
 200         struct emac_eth_dev *priv = bus->priv;
 201         struct emac_regs *regs = priv->regs;
 202
 203         /* issue the phy address and reg */
 204         writel(addr << 8 | reg, &regs->mac_madr);
 205
 206         /* pull up the phy io line */
 207         writel(0x1, &regs->mac_mcmd);
 208
 209         /* Wait read complete */
 210         mdelay(1);
 211
 212         /* push down the phy io line */
 213         writel(0x0, &regs->mac_mcmd);
 214
 215         /* And read data */
 216         return readl(&regs->mac_mrdd);
 217 }
 218
 219 /* Write a word to phyxcer */
 220 static int emac_mdio_write(struct mii_dev *bus, int addr, int devad, int reg,
 221                           u16 value)
 222 {
 223         struct emac_eth_dev *priv = bus->priv;
 224         struct emac_regs *regs = priv->regs;
 225
 226         /* issue the phy address and reg */
 227         writel(addr << 8 | reg, &regs->mac_madr);
 228
 229         /* pull up the phy io line */
 230         writel(0x1, &regs->mac_mcmd);
 231
 232         /* Wait write complete */
 233         mdelay(1);
 234
 235         /* push down the phy io line */
 236         writel(0x0, &regs->mac_mcmd);
 237
 238         /* and write data */
 239         writel(value, &regs->mac_mwtd);
 240
 241         return 0;
 242 }
 243
 244 static int sunxi_emac_init_phy(struct emac_eth_dev *priv, void *dev)
 245 {
 246         int ret, mask = 0xffffffff;
 247
 248 #ifdef CONFIG_PHY_ADDR
 249         mask = 1 << CONFIG_PHY_ADDR;
 250 #endif
 251
 252         priv->bus = mdio_alloc();
 253         if (!priv->bus) {
 254                 printf("Failed to allocate MDIO bus\n");
 255                 return -ENOMEM;
 256         }
 257
 258         priv->bus->read = emac_mdio_read;
 259         priv->bus->write = emac_mdio_write;
 260         priv->bus->priv = priv;
 261         strcpy(priv->bus->name, "emac");
 262
 263         ret = mdio_register(priv->bus);
 264         if (ret)
 265                 return ret;
 266
 267         priv->phydev = phy_find_by_mask(priv->bus, mask,
 268                                         PHY_INTERFACE_MODE_MII);
 269         if (!priv->phydev)
 270                 return -ENODEV;
 271
 272         phy_connect_dev(priv->phydev, dev);
 273         phy_config(priv->phydev);
 274
 275         return 0;
 276 }
 277
 278 static void emac_setup(struct emac_eth_dev *priv)
 279 {
 280         struct emac_regs *regs = priv->regs;
 281         u32 reg_val;
 282
 283         /* Set up TX */
 284         writel(EMAC_TX_SETUP, &regs->tx_mode);
 285
 286         /* Set up RX */
 287         writel(EMAC_RX_SETUP, &regs->rx_ctl);
 288
 289         /* Set MAC */
 290         /* Set MAC CTL0 */
 291         writel(EMAC_MAC_CTL0_SETUP, &regs->mac_ctl0);
 292
 293         /* Set MAC CTL1 */
 294         reg_val = 0;
 295         if (priv->phydev->duplex == DUPLEX_FULL)
 296                 reg_val = (0x1 << 0);
 297         writel(EMAC_MAC_CTL1_SETUP | reg_val, &regs->mac_ctl1);
 298
 299         /* Set up IPGT */
 300         writel(EMAC_MAC_IPGT, &regs->mac_ipgt);
 301
 302         /* Set up IPGR */
 303         writel(EMAC_MAC_NBTB_IPG2 | (EMAC_MAC_NBTB_IPG1 << 8), &regs->mac_ipgr);
 304
 305         /* Set up Collison window */
 306         writel(EMAC_MAC_RM | (EMAC_MAC_CW << 8), &regs->mac_clrt);
 307
 308         /* Set up Max Frame Length */
 309         writel(EMAC_MAC_MFL, &regs->mac_maxf);
 310 }
 311
 312 static void emac_reset(struct eth_device *dev)
 313 {
 314         struct emac_regs *regs = (struct emac_regs *)dev->iobase;
 315
 316         debug("resetting device\n");
 317
 318         /* RESET device */
 319         writel(0, &regs->ctl);
 320         udelay(200);
 321
 322         writel(1, &regs->ctl);
 323         udelay(200);
 324 }
 325
 326 static int sunxi_emac_eth_init(struct eth_device *dev, bd_t *bd)
 327 {
 328         struct emac_regs *regs = (struct emac_regs *)dev->iobase;
 329         struct emac_eth_dev *priv = dev->priv;
 330         int ret;
 331
 332         /* Init EMAC */
 333
 334         /* Flush RX FIFO */
 335         setbits_le32(&regs->rx_ctl, 0x8);
 336         udelay(1);
 337
 338         /* Init MAC */
 339
 340         /* Soft reset MAC */
 341         clrbits_le32(&regs->mac_ctl0, 0x1 << 15);
 342
 343         /* Clear RX counter */
 344         writel(0x0, &regs->rx_fbc);
 345         udelay(1);
 346
 347         /* Set up EMAC */
 348         emac_setup(priv);
 349
 350         writel(dev->enetaddr[0] << 16 | dev->enetaddr[1] << 8 |
 351                dev->enetaddr[2], &regs->mac_a1);
 352         writel(dev->enetaddr[3] << 16 | dev->enetaddr[4] << 8 |
 353                dev->enetaddr[5], &regs->mac_a0);
 354
 355         mdelay(1);
 356
 357         emac_reset(dev);
 358
 359         /* PHY POWER UP */
 360         ret = phy_startup(priv->phydev);
 361         if (ret) {
 362                 printf("Could not initialize PHY %s\n",
 363                        priv->phydev->dev->name);
 364                 return ret;
 365         }
 366
 367         /* Print link status only once */
 368         if (!priv->link_printed) {
 369                 printf("ENET Speed is %d Mbps - %s duplex connection\n",
 370                        priv->phydev->speed,
 371                        priv->phydev->duplex ? "FULL" : "HALF");
 372                 priv->link_printed = 1;
 373         }
 374
 375         /* Set EMAC SPEED depend on PHY */
 376         if (priv->phydev->speed == SPEED_100)
 377                 setbits_le32(&regs->mac_supp, 1 << 8);
 378         else
 379                 clrbits_le32(&regs->mac_supp, 1 << 8);
 380
 381         /* Set duplex depend on phy */
 382         if (priv->phydev->duplex == DUPLEX_FULL)
 383                 setbits_le32(&regs->mac_ctl1, 1 << 0);
 384         else
 385                 clrbits_le32(&regs->mac_ctl1, 1 << 0);
 386
 387         /* Enable RX/TX */
 388         setbits_le32(&regs->ctl, 0x7);
 389
 390         return 0;
 391 }
 392
 393 static void sunxi_emac_eth_halt(struct eth_device *dev)
 394 {
 395         /* Nothing to do here */
 396 }
 397
 398 static int sunxi_emac_eth_recv(struct eth_device *dev)
 399 {
 400         struct emac_regs *regs = (struct emac_regs *)dev->iobase;
 401         struct emac_rxhdr rxhdr;
 402         u32 rxcount;
 403         u32 reg_val;
 404         int rx_len;
 405         int rx_status;
 406         int good_packet;
 407
 408         /* Check packet ready or not */
 409
 410         /* Race warning: The first packet might arrive with
 411          * the interrupts disabled, but the second will fix
 412          */
 413         rxcount = readl(&regs->rx_fbc);
 414         if (!rxcount) {
 415                 /* Had one stuck? */
 416                 rxcount = readl(&regs->rx_fbc);
 417                 if (!rxcount)
 418                         return 0;
 419         }
 420
 421         reg_val = readl(&regs->rx_io_data);
 422         if (reg_val != 0x0143414d) {
 423                 /* Disable RX */
 424                 clrbits_le32(&regs->ctl, 0x1 << 2);
 425
 426                 /* Flush RX FIFO */
 427                 setbits_le32(&regs->rx_ctl, 0x1 << 3);
 428                 while (readl(&regs->rx_ctl) & (0x1 << 3))
 429                         ;
 430
 431                 /* Enable RX */
 432                 setbits_le32(&regs->ctl, 0x1 << 2);
 433
 434                 return 0;
 435         }
 436
 437         /* A packet ready now
 438          * Get status/length
 439          */
 440         good_packet = 1;
 441
 442         emac_inblk_32bit(&regs->rx_io_data, &rxhdr, sizeof(rxhdr));
 443
 444         rx_len = rxhdr.rx_len;
 445         rx_status = rxhdr.rx_status;
 446
 447         /* Packet Status check */
 448         if (rx_len < 0x40) {
 449                 good_packet = 0;
 450                 debug("RX: Bad Packet (runt)\n");
 451         }
 452
 453         /* rx_status is identical to RSR register. */
 454         if (0 & rx_status & (EMAC_CRCERR | EMAC_LENERR)) {
 455                 good_packet = 0;
 456                 if (rx_status & EMAC_CRCERR)
 457                         printf("crc error\n");
 458                 if (rx_status & EMAC_LENERR)
 459                         printf("length error\n");
 460         }
 461
 462         /* Move data from EMAC */
 463         if (good_packet) {
 464                 if (rx_len > DMA_CPU_TRRESHOLD) {
 465                         printf("Received packet is too big (len=%d)\n", rx_len);
 466                 } else {
 467                         emac_inblk_32bit((void *)&regs->rx_io_data,
 468                                          net_rx_packets[0], rx_len);
 469
 470                         /* Pass to upper layer */
 471                         net_process_received_packet(net_rx_packets[0], rx_len);
 472                         return rx_len;
 473                 }
 474         }
 475
 476         return 0;
 477 }
 478
 479 static int sunxi_emac_eth_send(struct eth_device *dev, void *packet, int len)
 480 {
 481         struct emac_regs *regs = (struct emac_regs *)dev->iobase;
 482
 483         /* Select channel 0 */
 484         writel(0, &regs->tx_ins);
 485
 486         /* Write packet */
 487         emac_outblk_32bit((void *)&regs->tx_io_data, packet, len);
 488
 489         /* Set TX len */
 490         writel(len, &regs->tx_pl0);
 491
 492         /* Start translate from fifo to phy */
 493         setbits_le32(&regs->tx_ctl0, 1);
 494
 495         return 0;
 496 }
 497
 498 int sunxi_emac_initialize(void)
 499 {
 500         struct sunxi_ccm_reg *const ccm =
 501                 (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
 502         struct sunxi_sramc_regs *sram =
 503                 (struct sunxi_sramc_regs *)SUNXI_SRAMC_BASE;
 504         struct emac_regs *regs =
 505                 (struct emac_regs *)SUNXI_EMAC_BASE;
 506         struct eth_device *dev;
 507         struct emac_eth_dev *priv;
 508         int pin;
 509
 510         dev = malloc(sizeof(*dev));
 511         if (dev == NULL)
 512                 return -ENOMEM;
 513
 514         priv = (struct emac_eth_dev *)malloc(sizeof(struct emac_eth_dev));
 515         if (!priv) {
 516                 free(dev);
 517                 return -ENOMEM;
 518         }
 519
 520         memset(dev, 0, sizeof(*dev));
 521         memset(priv, 0, sizeof(struct emac_eth_dev));
 522
 523         /* Map SRAM to EMAC */
 524         setbits_le32(&sram->ctrl1, 0x5 << 2);
 525
 526         /* Configure pin mux settings for MII Ethernet */
 527         for (pin = SUNXI_GPA(0); pin <= SUNXI_GPA(17); pin++)
 528                 sunxi_gpio_set_cfgpin(pin, SUNXI_GPA_EMAC);
 529
 530         /* Set up clock gating */
 531         setbits_le32(&ccm->ahb_gate0, 0x1 << AHB_GATE_OFFSET_EMAC);
 532
 533         /* Set MII clock */
 534         clrsetbits_le32(&regs->mac_mcfg, 0xf << 2, 0xd << 2);
 535
 536         priv->regs = regs;
 537         dev->iobase = (int)regs;
 538         dev->priv = priv;
 539         dev->init = sunxi_emac_eth_init;
 540         dev->halt = sunxi_emac_eth_halt;
 541         dev->send = sunxi_emac_eth_send;
 542         dev->recv = sunxi_emac_eth_recv;
 543         strcpy(dev->name, "emac");
 544
 545         eth_register(dev);
 546
 547         return sunxi_emac_init_phy(priv, dev);
 548 }