drivers/net/bcm-sf2-eth-gmac.c

   1 /*
   2  * Copyright 2014 Broadcom Corporation.
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #ifdef BCM_GMAC_DEBUG
   8 #ifndef DEBUG
   9 #define DEBUG
  10 #endif
  11 #endif
  12
  13 #include <config.h>
  14 #include <common.h>
  15 #include <malloc.h>
  16 #include <net.h>
  17 #include <asm/io.h>
  18 #include <phy.h>
  19
  20 #include "bcm-sf2-eth.h"
  21 #include "bcm-sf2-eth-gmac.h"
  22
  23 #define SPINWAIT(exp, us) { \
  24         uint countdown = (us) + 9; \
  25         while ((exp) && (countdown >= 10)) {\
  26                 udelay(10); \
  27                 countdown -= 10; \
  28         } \
  29 }
  30
  31 static int gmac_disable_dma(struct eth_dma *dma, int dir);
  32 static int gmac_enable_dma(struct eth_dma *dma, int dir);
  33
  34 /* DMA Descriptor */
  35 typedef struct {
  36         /* misc control bits */
  37         uint32_t        ctrl1;
  38         /* buffer count and address extension */
  39         uint32_t        ctrl2;
  40         /* memory address of the date buffer, bits 31:0 */
  41         uint32_t        addrlow;
  42         /* memory address of the date buffer, bits 63:32 */
  43         uint32_t        addrhigh;
  44 } dma64dd_t;
  45
  46 uint32_t g_dmactrlflags;
  47
  48 static uint32_t dma_ctrlflags(uint32_t mask, uint32_t flags)
  49 {
  50         debug("%s enter\n", __func__);
  51
  52         g_dmactrlflags &= ~mask;
  53         g_dmactrlflags |= flags;
  54
  55         /* If trying to enable parity, check if parity is actually supported */
  56         if (g_dmactrlflags & DMA_CTRL_PEN) {
  57                 uint32_t control;
  58
  59                 control = readl(GMAC0_DMA_TX_CTRL_ADDR);
  60                 writel(control | D64_XC_PD, GMAC0_DMA_TX_CTRL_ADDR);
  61                 if (readl(GMAC0_DMA_TX_CTRL_ADDR) & D64_XC_PD) {
  62                         /*
  63                          * We *can* disable it, therefore it is supported;
  64                          * restore control register
  65                          */
  66                         writel(control, GMAC0_DMA_TX_CTRL_ADDR);
  67                 } else {
  68                         /* Not supported, don't allow it to be enabled */
  69                         g_dmactrlflags &= ~DMA_CTRL_PEN;
  70                 }
  71         }
  72
  73         return g_dmactrlflags;
  74 }
  75
  76 static inline void reg32_clear_bits(uint32_t reg, uint32_t value)
  77 {
  78         uint32_t v = readl(reg);
  79         v &= ~(value);
  80         writel(v, reg);
  81 }
  82
  83 static inline void reg32_set_bits(uint32_t reg, uint32_t value)
  84 {
  85         uint32_t v = readl(reg);
  86         v |= value;
  87         writel(v, reg);
  88 }
  89
  90 #ifdef BCM_GMAC_DEBUG
  91 static void dma_tx_dump(struct eth_dma *dma)
  92 {
  93         dma64dd_t *descp = NULL;
  94         uint8_t *bufp;
  95         int i;
  96
  97         printf("TX DMA Register:\n");
  98         printf("control:0x%x; ptr:0x%x; addrl:0x%x; addrh:0x%x; stat0:0x%x, stat1:0x%x\n",
  99                readl(GMAC0_DMA_TX_CTRL_ADDR),
 100                readl(GMAC0_DMA_TX_PTR_ADDR),
 101                readl(GMAC0_DMA_TX_ADDR_LOW_ADDR),
 102                readl(GMAC0_DMA_TX_ADDR_HIGH_ADDR),
 103                readl(GMAC0_DMA_TX_STATUS0_ADDR),
 104                readl(GMAC0_DMA_TX_STATUS1_ADDR));
 105
 106         printf("TX Descriptors:\n");
 107         for (i = 0; i < TX_BUF_NUM; i++) {
 108                 descp = (dma64dd_t *)(dma->tx_desc_aligned) + i;
 109                 printf("ctrl1:0x%08x; ctrl2:0x%08x; addr:0x%x 0x%08x\n",
 110                        descp->ctrl1, descp->ctrl2,
 111                        descp->addrhigh, descp->addrlow);
 112         }
 113
 114         printf("TX Buffers:\n");
 115         /* Initialize TX DMA descriptor table */
 116         for (i = 0; i < TX_BUF_NUM; i++) {
 117                 bufp = (uint8_t *)(dma->tx_buf + i * TX_BUF_SIZE);
 118                 printf("buf%d:0x%x; ", i, (uint32_t)bufp);
 119         }
 120         printf("\n");
 121 }
 122
 123 static void dma_rx_dump(struct eth_dma *dma)
 124 {
 125         dma64dd_t *descp = NULL;
 126         uint8_t *bufp;
 127         int i;
 128
 129         printf("RX DMA Register:\n");
 130         printf("control:0x%x; ptr:0x%x; addrl:0x%x; addrh:0x%x; stat0:0x%x, stat1:0x%x\n",
 131                readl(GMAC0_DMA_RX_CTRL_ADDR),
 132                readl(GMAC0_DMA_RX_PTR_ADDR),
 133                readl(GMAC0_DMA_RX_ADDR_LOW_ADDR),
 134                readl(GMAC0_DMA_RX_ADDR_HIGH_ADDR),
 135                readl(GMAC0_DMA_RX_STATUS0_ADDR),
 136                readl(GMAC0_DMA_RX_STATUS1_ADDR));
 137
 138         printf("RX Descriptors:\n");
 139         for (i = 0; i < RX_BUF_NUM; i++) {
 140                 descp = (dma64dd_t *)(dma->rx_desc_aligned) + i;
 141                 printf("ctrl1:0x%08x; ctrl2:0x%08x; addr:0x%x 0x%08x\n",
 142                        descp->ctrl1, descp->ctrl2,
 143                        descp->addrhigh, descp->addrlow);
 144         }
 145
 146         printf("RX Buffers:\n");
 147         for (i = 0; i < RX_BUF_NUM; i++) {
 148                 bufp = dma->rx_buf + i * RX_BUF_SIZE;
 149                 printf("buf%d:0x%x; ", i, (uint32_t)bufp);
 150         }
 151         printf("\n");
 152 }
 153 #endif
 154
 155 static int dma_tx_init(struct eth_dma *dma)
 156 {
 157         dma64dd_t *descp = NULL;
 158         uint8_t *bufp;
 159         int i;
 160         uint32_t ctrl;
 161
 162         debug("%s enter\n", __func__);
 163
 164         /* clear descriptor memory */
 165         memset((void *)(dma->tx_desc_aligned), 0,
 166                TX_BUF_NUM * sizeof(dma64dd_t));
 167         memset(dma->tx_buf, 0, TX_BUF_NUM * TX_BUF_SIZE);
 168
 169         /* Initialize TX DMA descriptor table */
 170         for (i = 0; i < TX_BUF_NUM; i++) {
 171                 descp = (dma64dd_t *)(dma->tx_desc_aligned) + i;
 172                 bufp = dma->tx_buf + i * TX_BUF_SIZE;
 173                 /* clear buffer memory */
 174                 memset((void *)bufp, 0, TX_BUF_SIZE);
 175
 176                 ctrl = 0;
 177                 /* if last descr set endOfTable */
 178                 if (i == (TX_BUF_NUM-1))
 179                         ctrl = D64_CTRL1_EOT;
 180                 descp->ctrl1 = ctrl;
 181                 descp->ctrl2 = 0;
 182                 descp->addrlow = (uint32_t)bufp;
 183                 descp->addrhigh = 0;
 184         }
 185
 186         /* flush descriptor and buffer */
 187         descp = dma->tx_desc_aligned;
 188         bufp = dma->tx_buf;
 189         flush_dcache_range((unsigned long)descp,
 190                            (unsigned long)(descp +
 191                                            sizeof(dma64dd_t) * TX_BUF_NUM));
 192         flush_dcache_range((unsigned long)(bufp),
 193                            (unsigned long)(bufp + TX_BUF_SIZE * TX_BUF_NUM));
 194
 195         /* initialize the DMA channel */
 196         writel((uint32_t)(dma->tx_desc_aligned), GMAC0_DMA_TX_ADDR_LOW_ADDR);
 197         writel(0, GMAC0_DMA_TX_ADDR_HIGH_ADDR);
 198
 199         /* now update the dma last descriptor */
 200         writel(((uint32_t)(dma->tx_desc_aligned)) & D64_XP_LD_MASK,
 201                GMAC0_DMA_TX_PTR_ADDR);
 202
 203         return 0;
 204 }
 205
 206 static int dma_rx_init(struct eth_dma *dma)
 207 {
 208         uint32_t last_desc;
 209         dma64dd_t *descp = NULL;
 210         uint8_t *bufp;
 211         uint32_t ctrl;
 212         int i;
 213
 214         debug("%s enter\n", __func__);
 215
 216         /* clear descriptor memory */
 217         memset((void *)(dma->rx_desc_aligned), 0,
 218                RX_BUF_NUM * sizeof(dma64dd_t));
 219         /* clear buffer memory */
 220         memset(dma->rx_buf, 0, RX_BUF_NUM * RX_BUF_SIZE);
 221
 222         /* Initialize RX DMA descriptor table */
 223         for (i = 0; i < RX_BUF_NUM; i++) {
 224                 descp = (dma64dd_t *)(dma->rx_desc_aligned) + i;
 225                 bufp = dma->rx_buf + i * RX_BUF_SIZE;
 226                 ctrl = 0;
 227                 /* if last descr set endOfTable */
 228                 if (i == (RX_BUF_NUM - 1))
 229                         ctrl = D64_CTRL1_EOT;
 230                 descp->ctrl1 = ctrl;
 231                 descp->ctrl2 = RX_BUF_SIZE;
 232                 descp->addrlow = (uint32_t)bufp;
 233                 descp->addrhigh = 0;
 234
 235                 last_desc = ((uint32_t)(descp) & D64_XP_LD_MASK)
 236                                 + sizeof(dma64dd_t);
 237         }
 238
 239         descp = dma->rx_desc_aligned;
 240         bufp = dma->rx_buf;
 241         /* flush descriptor and buffer */
 242         flush_dcache_range((unsigned long)descp,
 243                            (unsigned long)(descp +
 244                                            sizeof(dma64dd_t) * RX_BUF_NUM));
 245         flush_dcache_range((unsigned long)(bufp),
 246                            (unsigned long)(bufp + RX_BUF_SIZE * RX_BUF_NUM));
 247
 248         /* initailize the DMA channel */
 249         writel((uint32_t)descp, GMAC0_DMA_RX_ADDR_LOW_ADDR);
 250         writel(0, GMAC0_DMA_RX_ADDR_HIGH_ADDR);
 251
 252         /* now update the dma last descriptor */
 253         writel(last_desc, GMAC0_DMA_RX_PTR_ADDR);
 254
 255         return 0;
 256 }
 257
 258 static int dma_init(struct eth_dma *dma)
 259 {
 260         debug(" %s enter\n", __func__);
 261
 262         /*
 263          * Default flags: For backwards compatibility both
 264          * Rx Overflow Continue and Parity are DISABLED.
 265          */
 266         dma_ctrlflags(DMA_CTRL_ROC | DMA_CTRL_PEN, 0);
 267
 268         debug("rx burst len 0x%x\n",
 269               (readl(GMAC0_DMA_RX_CTRL_ADDR) & D64_RC_BL_MASK)
 270               >> D64_RC_BL_SHIFT);
 271         debug("tx burst len 0x%x\n",
 272               (readl(GMAC0_DMA_TX_CTRL_ADDR) & D64_XC_BL_MASK)
 273               >> D64_XC_BL_SHIFT);
 274
 275         dma_tx_init(dma);
 276         dma_rx_init(dma);
 277
 278         /* From end of chip_init() */
 279         /* enable the overflow continue feature and disable parity */
 280         dma_ctrlflags(DMA_CTRL_ROC | DMA_CTRL_PEN /* mask */,
 281                       DMA_CTRL_ROC /* value */);
 282
 283         return 0;
 284 }
 285
 286 static int dma_deinit(struct eth_dma *dma)
 287 {
 288         debug(" %s enter\n", __func__);
 289
 290         gmac_disable_dma(dma, MAC_DMA_RX);
 291         gmac_disable_dma(dma, MAC_DMA_TX);
 292
 293         free(dma->tx_buf);
 294         dma->tx_buf = NULL;
 295         free(dma->tx_desc);
 296         dma->tx_desc = NULL;
 297         dma->tx_desc_aligned = NULL;
 298
 299         free(dma->rx_buf);
 300         dma->rx_buf = NULL;
 301         free(dma->rx_desc);
 302         dma->rx_desc = NULL;
 303         dma->rx_desc_aligned = NULL;
 304
 305         return 0;
 306 }
 307
 308 int gmac_tx_packet(struct eth_dma *dma, void *packet, int length)
 309 {
 310         uint8_t *bufp = dma->tx_buf + dma->cur_tx_index * TX_BUF_SIZE;
 311
 312         /* kick off the dma */
 313         size_t len = length;
 314         int txout = dma->cur_tx_index;
 315         uint32_t flags;
 316         dma64dd_t *descp = NULL;
 317         uint32_t ctrl;
 318         uint32_t last_desc = (((uint32_t)dma->tx_desc_aligned) +
 319                               sizeof(dma64dd_t)) & D64_XP_LD_MASK;
 320         size_t buflen;
 321
 322         debug("%s enter\n", __func__);
 323
 324         /* load the buffer */
 325         memcpy(bufp, packet, len);
 326
 327         /* Add 4 bytes for Ethernet FCS/CRC */
 328         buflen = len + 4;
 329
 330         ctrl = (buflen & D64_CTRL2_BC_MASK);
 331
 332         /* the transmit will only be one frame or set SOF, EOF */
 333         /* also set int on completion */
 334         flags = D64_CTRL1_SOF | D64_CTRL1_IOC | D64_CTRL1_EOF;
 335
 336         /* txout points to the descriptor to uset */
 337         /* if last descriptor then set EOT */
 338         if (txout == (TX_BUF_NUM - 1)) {
 339                 flags |= D64_CTRL1_EOT;
 340                 last_desc = ((uint32_t)(dma->tx_desc_aligned)) & D64_XP_LD_MASK;
 341         }
 342
 343         /* write the descriptor */
 344         descp = ((dma64dd_t *)(dma->tx_desc_aligned)) + txout;
 345         descp->addrlow = (uint32_t)bufp;
 346         descp->addrhigh = 0;
 347         descp->ctrl1 = flags;
 348         descp->ctrl2 = ctrl;
 349
 350         /* flush descriptor and buffer */
 351         flush_dcache_range((unsigned long)descp,
 352                            (unsigned long)(descp + sizeof(dma64dd_t)));
 353         flush_dcache_range((unsigned long)bufp,
 354                            (unsigned long)(bufp + TX_BUF_SIZE));
 355
 356         /* now update the dma last descriptor */
 357         writel(last_desc, GMAC0_DMA_TX_PTR_ADDR);
 358
 359         /* tx dma should be enabled so packet should go out */
 360
 361         /* update txout */
 362         dma->cur_tx_index = (txout + 1) & (TX_BUF_NUM - 1);
 363
 364         return 0;
 365 }
 366
 367 bool gmac_check_tx_done(struct eth_dma *dma)
 368 {
 369         /* wait for tx to complete */
 370         uint32_t intstatus;
 371         bool xfrdone = false;
 372
 373         debug("%s enter\n", __func__);
 374
 375         intstatus = readl(GMAC0_INT_STATUS_ADDR);
 376
 377         debug("int(0x%x)\n", intstatus);
 378         if (intstatus & (I_XI0 | I_XI1 | I_XI2 | I_XI3)) {
 379                 xfrdone = true;
 380                 /* clear the int bits */
 381                 intstatus &= ~(I_XI0 | I_XI1 | I_XI2 | I_XI3);
 382                 writel(intstatus, GMAC0_INT_STATUS_ADDR);
 383         } else {
 384                 debug("Tx int(0x%x)\n", intstatus);
 385         }
 386
 387         return xfrdone;
 388 }
 389
 390 int gmac_check_rx_done(struct eth_dma *dma, uint8_t *buf)
 391 {
 392         void *bufp, *datap;
 393         size_t rcvlen = 0, buflen = 0;
 394         uint32_t stat0 = 0, stat1 = 0;
 395         uint32_t control, offset;
 396         uint8_t statbuf[HWRXOFF*2];
 397
 398         int index, curr, active;
 399         dma64dd_t *descp = NULL;
 400
 401         /* udelay(50); */
 402
 403         /*
 404          * this api will check if a packet has been received.
 405          * If so it will return the address of the buffer and current
 406          * descriptor index will be incremented to the
 407          * next descriptor. Once done with the frame the buffer should be
 408          * added back onto the descriptor and the lastdscr should be updated
 409          * to this descriptor.
 410          */
 411         index = dma->cur_rx_index;
 412         offset = (uint32_t)(dma->rx_desc_aligned);
 413         stat0 = readl(GMAC0_DMA_RX_STATUS0_ADDR) & D64_RS0_CD_MASK;
 414         stat1 = readl(GMAC0_DMA_RX_STATUS1_ADDR) & D64_RS0_CD_MASK;
 415         curr = ((stat0 - offset) & D64_RS0_CD_MASK) / sizeof(dma64dd_t);
 416         active = ((stat1 - offset) & D64_RS0_CD_MASK) / sizeof(dma64dd_t);
 417
 418         /* check if any frame */
 419         if (index == curr)
 420                 return -1;
 421
 422         debug("received packet\n");
 423         debug("expect(0x%x) curr(0x%x) active(0x%x)\n", index, curr, active);
 424         /* remove warning */
 425         if (index == active)
 426                 ;
 427
 428         /* get the packet pointer that corresponds to the rx descriptor */
 429         bufp = dma->rx_buf + index * RX_BUF_SIZE;
 430
 431         descp = (dma64dd_t *)(dma->rx_desc_aligned) + index;
 432         /* flush descriptor and buffer */
 433         flush_dcache_range((unsigned long)descp,
 434                            (unsigned long)(descp + sizeof(dma64dd_t)));
 435         flush_dcache_range((unsigned long)bufp,
 436                            (unsigned long)(bufp + RX_BUF_SIZE));
 437
 438         buflen = (descp->ctrl2 & D64_CTRL2_BC_MASK);
 439
 440         stat0 = readl(GMAC0_DMA_RX_STATUS0_ADDR);
 441         stat1 = readl(GMAC0_DMA_RX_STATUS1_ADDR);
 442
 443         debug("bufp(0x%x) index(0x%x) buflen(0x%x) stat0(0x%x) stat1(0x%x)\n",
 444               (uint32_t)bufp, index, buflen, stat0, stat1);
 445
 446         dma->cur_rx_index = (index + 1) & (RX_BUF_NUM - 1);
 447
 448         /* get buffer offset */
 449         control = readl(GMAC0_DMA_RX_CTRL_ADDR);
 450         offset = (control & D64_RC_RO_MASK) >> D64_RC_RO_SHIFT;
 451         rcvlen = *(uint16_t *)bufp;
 452
 453         debug("Received %d bytes\n", rcvlen);
 454         /* copy status into temp buf then copy data from rx buffer */
 455         memcpy(statbuf, bufp, offset);
 456         datap = (void *)((uint32_t)bufp + offset);
 457         memcpy(buf, datap, rcvlen);
 458
 459         /* update descriptor that is being added back on ring */
 460         descp->ctrl2 = RX_BUF_SIZE;
 461         descp->addrlow = (uint32_t)bufp;
 462         descp->addrhigh = 0;
 463         /* flush descriptor */
 464         flush_dcache_range((unsigned long)descp,
 465                            (unsigned long)(descp + sizeof(dma64dd_t)));
 466
 467         /* set the lastdscr for the rx ring */
 468         writel(((uint32_t)descp) & D64_XP_LD_MASK, GMAC0_DMA_RX_PTR_ADDR);
 469
 470         return (int)rcvlen;
 471 }
 472
 473 static int gmac_disable_dma(struct eth_dma *dma, int dir)
 474 {
 475         int status;
 476
 477         debug("%s enter\n", __func__);
 478
 479         if (dir == MAC_DMA_TX) {
 480                 /* address PR8249/PR7577 issue */
 481                 /* suspend tx DMA first */
 482                 writel(D64_XC_SE, GMAC0_DMA_TX_CTRL_ADDR);
 483                 SPINWAIT(((status = (readl(GMAC0_DMA_TX_STATUS0_ADDR) &
 484                                      D64_XS0_XS_MASK)) !=
 485                           D64_XS0_XS_DISABLED) &&
 486                          (status != D64_XS0_XS_IDLE) &&
 487                          (status != D64_XS0_XS_STOPPED), 10000);
 488
 489                 /*
 490                  * PR2414 WAR: DMA engines are not disabled until
 491                  * transfer finishes
 492                  */
 493                 writel(0, GMAC0_DMA_TX_CTRL_ADDR);
 494                 SPINWAIT(((status = (readl(GMAC0_DMA_TX_STATUS0_ADDR) &
 495                                      D64_XS0_XS_MASK)) !=
 496                           D64_XS0_XS_DISABLED), 10000);
 497
 498                 /* wait for the last transaction to complete */
 499                 udelay(2);
 500
 501                 status = (status == D64_XS0_XS_DISABLED);
 502         } else {
 503                 /*
 504                  * PR2414 WAR: DMA engines are not disabled until
 505                  * transfer finishes
 506                  */
 507                 writel(0, GMAC0_DMA_RX_CTRL_ADDR);
 508                 SPINWAIT(((status = (readl(GMAC0_DMA_RX_STATUS0_ADDR) &
 509                                      D64_RS0_RS_MASK)) !=
 510                           D64_RS0_RS_DISABLED), 10000);
 511
 512                 status = (status == D64_RS0_RS_DISABLED);
 513         }
 514
 515         return status;
 516 }
 517
 518 static int gmac_enable_dma(struct eth_dma *dma, int dir)
 519 {
 520         uint32_t control;
 521
 522         debug("%s enter\n", __func__);
 523
 524         if (dir == MAC_DMA_TX) {
 525                 dma->cur_tx_index = 0;
 526
 527                 /*
 528                  * These bits 20:18 (burstLen) of control register can be
 529                  * written but will take effect only if these bits are
 530                  * valid. So this will not affect previous versions
 531                  * of the DMA. They will continue to have those bits set to 0.
 532                  */
 533                 control = readl(GMAC0_DMA_TX_CTRL_ADDR);
 534
 535                 control |= D64_XC_XE;
 536                 if ((g_dmactrlflags & DMA_CTRL_PEN) == 0)
 537                         control |= D64_XC_PD;
 538
 539                 writel(control, GMAC0_DMA_TX_CTRL_ADDR);
 540
 541                 /* initailize the DMA channel */
 542                 writel((uint32_t)(dma->tx_desc_aligned),
 543                        GMAC0_DMA_TX_ADDR_LOW_ADDR);
 544                 writel(0, GMAC0_DMA_TX_ADDR_HIGH_ADDR);
 545         } else {
 546                 dma->cur_rx_index = 0;
 547
 548                 control = (readl(GMAC0_DMA_RX_CTRL_ADDR) &
 549                            D64_RC_AE) | D64_RC_RE;
 550
 551                 if ((g_dmactrlflags & DMA_CTRL_PEN) == 0)
 552                         control |= D64_RC_PD;
 553
 554                 if (g_dmactrlflags & DMA_CTRL_ROC)
 555                         control |= D64_RC_OC;
 556
 557                 /*
 558                  * These bits 20:18 (burstLen) of control register can be
 559                  * written but will take effect only if these bits are
 560                  * valid. So this will not affect previous versions
 561                  * of the DMA. They will continue to have those bits set to 0.
 562                  */
 563                 control &= ~D64_RC_BL_MASK;
 564                 /* Keep default Rx burstlen */
 565                 control |= readl(GMAC0_DMA_RX_CTRL_ADDR) & D64_RC_BL_MASK;
 566                 control |= HWRXOFF << D64_RC_RO_SHIFT;
 567
 568                 writel(control, GMAC0_DMA_RX_CTRL_ADDR);
 569
 570                 /*
 571                  * the rx descriptor ring should have
 572                  * the addresses set properly;
 573                  * set the lastdscr for the rx ring
 574                  */
 575                 writel(((uint32_t)(dma->rx_desc_aligned) +
 576                         (RX_BUF_NUM - 1) * RX_BUF_SIZE) &
 577                        D64_XP_LD_MASK, GMAC0_DMA_RX_PTR_ADDR);
 578         }
 579
 580         return 0;
 581 }
 582
 583 bool gmac_mii_busywait(unsigned int timeout)
 584 {
 585         uint32_t tmp = 0;
 586
 587         while (timeout > 10) {
 588                 tmp = readl(GMAC_MII_CTRL_ADDR);
 589                 if (tmp & (1 << GMAC_MII_BUSY_SHIFT)) {
 590                         udelay(10);
 591                         timeout -= 10;
 592                 } else {
 593                         break;
 594                 }
 595         }
 596         return tmp & (1 << GMAC_MII_BUSY_SHIFT);
 597 }
 598
 599 int gmac_miiphy_read(struct mii_dev *bus, int phyaddr, int devad, int reg)
 600 {
 601         uint32_t tmp = 0;
 602         u16 value = 0;
 603
 604         /* Busy wait timeout is 1ms */
 605         if (gmac_mii_busywait(1000)) {
 606                 error("%s: Prepare MII read: MII/MDIO busy\n", __func__);
 607                 return -1;
 608         }
 609
 610         /* Read operation */
 611         tmp = GMAC_MII_DATA_READ_CMD;
 612         tmp |= (phyaddr << GMAC_MII_PHY_ADDR_SHIFT) |
 613                 (reg << GMAC_MII_PHY_REG_SHIFT);
 614         debug("MII read cmd 0x%x, phy 0x%x, reg 0x%x\n", tmp, phyaddr, reg);
 615         writel(tmp, GMAC_MII_DATA_ADDR);
 616
 617         if (gmac_mii_busywait(1000)) {
 618                 error("%s: MII read failure: MII/MDIO busy\n", __func__);
 619                 return -1;
 620         }
 621
 622         value = readl(GMAC_MII_DATA_ADDR) & 0xffff;
 623         debug("MII read data 0x%x\n", value);
 624         return value;
 625 }
 626
 627 int gmac_miiphy_write(struct mii_dev *bus, int phyaddr, int devad, int reg,
 628                       u16 value)
 629 {
 630         uint32_t tmp = 0;
 631
 632         /* Busy wait timeout is 1ms */
 633         if (gmac_mii_busywait(1000)) {
 634                 error("%s: Prepare MII write: MII/MDIO busy\n", __func__);
 635                 return -1;
 636         }
 637
 638         /* Write operation */
 639         tmp = GMAC_MII_DATA_WRITE_CMD | (value & 0xffff);
 640         tmp |= ((phyaddr << GMAC_MII_PHY_ADDR_SHIFT) |
 641                 (reg << GMAC_MII_PHY_REG_SHIFT));
 642         debug("MII write cmd 0x%x, phy 0x%x, reg 0x%x, data 0x%x\n",
 643               tmp, phyaddr, reg, value);
 644         writel(tmp, GMAC_MII_DATA_ADDR);
 645
 646         if (gmac_mii_busywait(1000)) {
 647                 error("%s: MII write failure: MII/MDIO busy\n", __func__);
 648                 return -1;
 649         }
 650
 651         return 0;
 652 }
 653
 654 void gmac_init_reset(void)
 655 {
 656         debug("%s enter\n", __func__);
 657
 658         /* set command config reg CC_SR */
 659         reg32_set_bits(UNIMAC0_CMD_CFG_ADDR, CC_SR);
 660         udelay(GMAC_RESET_DELAY);
 661 }
 662
 663 void gmac_clear_reset(void)
 664 {
 665         debug("%s enter\n", __func__);
 666
 667         /* clear command config reg CC_SR */
 668         reg32_clear_bits(UNIMAC0_CMD_CFG_ADDR, CC_SR);
 669         udelay(GMAC_RESET_DELAY);
 670 }
 671
 672 static void gmac_enable_local(bool en)
 673 {
 674         uint32_t cmdcfg;
 675
 676         debug("%s enter\n", __func__);
 677
 678         /* read command config reg */
 679         cmdcfg = readl(UNIMAC0_CMD_CFG_ADDR);
 680
 681         /* put mac in reset */
 682         gmac_init_reset();
 683
 684         cmdcfg |= CC_SR;
 685
 686         /* first deassert rx_ena and tx_ena while in reset */
 687         cmdcfg &= ~(CC_RE | CC_TE);
 688         /* write command config reg */
 689         writel(cmdcfg, UNIMAC0_CMD_CFG_ADDR);
 690
 691         /* bring mac out of reset */
 692         gmac_clear_reset();
 693
 694         /* if not enable exit now */
 695         if (!en)
 696                 return;
 697
 698         /* enable the mac transmit and receive paths now */
 699         udelay(2);
 700         cmdcfg &= ~CC_SR;
 701         cmdcfg |= (CC_RE | CC_TE);
 702
 703         /* assert rx_ena and tx_ena when out of reset to enable the mac */
 704         writel(cmdcfg, UNIMAC0_CMD_CFG_ADDR);
 705
 706         return;
 707 }
 708
 709 int gmac_enable(void)
 710 {
 711         gmac_enable_local(1);
 712
 713         /* clear interrupts */
 714         writel(I_INTMASK, GMAC0_INT_STATUS_ADDR);
 715         return 0;
 716 }
 717
 718 int gmac_disable(void)
 719 {
 720         gmac_enable_local(0);
 721         return 0;
 722 }
 723
 724 int gmac_set_speed(int speed, int duplex)
 725 {
 726         uint32_t cmdcfg;
 727         uint32_t hd_ena;
 728         uint32_t speed_cfg;
 729
 730         hd_ena = duplex ? 0 : CC_HD;
 731         if (speed == 1000) {
 732                 speed_cfg = 2;
 733         } else if (speed == 100) {
 734                 speed_cfg = 1;
 735         } else if (speed == 10) {
 736                 speed_cfg = 0;
 737         } else {
 738                 error("%s: Invalid GMAC speed(%d)!\n", __func__, speed);
 739                 return -1;
 740         }
 741
 742         cmdcfg = readl(UNIMAC0_CMD_CFG_ADDR);
 743         cmdcfg &= ~(CC_ES_MASK | CC_HD);
 744         cmdcfg |= ((speed_cfg << CC_ES_SHIFT) | hd_ena);
 745
 746         printf("Change GMAC speed to %dMB\n", speed);
 747         debug("GMAC speed cfg 0x%x\n", cmdcfg);
 748         writel(cmdcfg, UNIMAC0_CMD_CFG_ADDR);
 749
 750         return 0;
 751 }
 752
 753 int gmac_set_mac_addr(unsigned char *mac)
 754 {
 755         /* set our local address */
 756         debug("GMAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
 757               mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
 758         writel(htonl(*(uint32_t *)mac), UNIMAC0_MAC_MSB_ADDR);
 759         writew(htons(*(uint32_t *)&mac[4]), UNIMAC0_MAC_LSB_ADDR);
 760
 761         return 0;
 762 }
 763
 764 int gmac_mac_init(struct eth_device *dev)
 765 {
 766         struct eth_info *eth = (struct eth_info *)(dev->priv);
 767         struct eth_dma *dma = &(eth->dma);
 768
 769         uint32_t tmp;
 770         uint32_t cmdcfg;
 771         int chipid;
 772
 773         debug("%s enter\n", __func__);
 774
 775         /* Always use GMAC0 */
 776         printf("Using GMAC%d\n", 0);
 777
 778         /* Reset AMAC0 core */
 779         writel(0, AMAC0_IDM_RESET_ADDR);
 780         tmp = readl(AMAC0_IO_CTRL_DIRECT_ADDR);
 781         /* Set clock */
 782         tmp &= ~(1 << AMAC0_IO_CTRL_CLK_250_SEL_SHIFT);
 783         tmp |= (1 << AMAC0_IO_CTRL_GMII_MODE_SHIFT);
 784         /* Set Tx clock */
 785         tmp &= ~(1 << AMAC0_IO_CTRL_DEST_SYNC_MODE_EN_SHIFT);
 786         writel(tmp, AMAC0_IO_CTRL_DIRECT_ADDR);
 787
 788         /* reset gmac */
 789         /*
 790          * As AMAC is just reset, NO need?
 791          * set eth_data into loopback mode to ensure no rx traffic
 792          * gmac_loopback(eth_data, TRUE);
 793          * ET_TRACE(("%s gmac loopback\n", __func__));
 794          * udelay(1);
 795          */
 796
 797         cmdcfg = readl(UNIMAC0_CMD_CFG_ADDR);
 798         cmdcfg &= ~(CC_TE | CC_RE | CC_RPI | CC_TAI | CC_HD | CC_ML |
 799                     CC_CFE | CC_RL | CC_RED | CC_PE | CC_TPI |
 800                     CC_PAD_EN | CC_PF);
 801         cmdcfg |= (CC_PROM | CC_NLC | CC_CFE);
 802         /* put mac in reset */
 803         gmac_init_reset();
 804         writel(cmdcfg, UNIMAC0_CMD_CFG_ADDR);
 805         gmac_clear_reset();
 806
 807         /* enable clear MIB on read */
 808         reg32_set_bits(GMAC0_DEV_CTRL_ADDR, DC_MROR);
 809         /* PHY: set smi_master to drive mdc_clk */
 810         reg32_set_bits(GMAC0_PHY_CTRL_ADDR, PC_MTE);
 811
 812         /* clear persistent sw intstatus */
 813         writel(0, GMAC0_INT_STATUS_ADDR);
 814
 815         if (dma_init(dma) < 0) {
 816                 error("%s: GMAC dma_init failed\n", __func__);
 817                 goto err_exit;
 818         }
 819
 820         chipid = CHIPID;
 821         printf("%s: Chip ID: 0x%x\n", __func__, chipid);
 822
 823         /* set switch bypass mode */
 824         tmp = readl(SWITCH_GLOBAL_CONFIG_ADDR);
 825         tmp |= (1 << CDRU_SWITCH_BYPASS_SWITCH_SHIFT);
 826
 827         /* Switch mode */
 828         /* tmp &= ~(1 << CDRU_SWITCH_BYPASS_SWITCH_SHIFT); */
 829
 830         writel(tmp, SWITCH_GLOBAL_CONFIG_ADDR);
 831
 832         tmp = readl(CRMU_CHIP_IO_PAD_CONTROL_ADDR);
 833         tmp &= ~(1 << CDRU_IOMUX_FORCE_PAD_IN_SHIFT);
 834         writel(tmp, CRMU_CHIP_IO_PAD_CONTROL_ADDR);
 835
 836         /* Set MDIO to internal GPHY */
 837         tmp = readl(GMAC_MII_CTRL_ADDR);
 838         /* Select internal MDC/MDIO bus*/
 839         tmp &= ~(1 << GMAC_MII_CTRL_BYP_SHIFT);
 840         /* select MDC/MDIO connecting to on-chip internal PHYs */
 841         tmp &= ~(1 << GMAC_MII_CTRL_EXT_SHIFT);
 842         /*
 843          * give bit[6:0](MDCDIV) with required divisor to set
 844          * the MDC clock frequency, 66MHZ/0x1A=2.5MHZ
 845          */
 846         tmp |= 0x1A;
 847
 848         writel(tmp, GMAC_MII_CTRL_ADDR);
 849
 850         if (gmac_mii_busywait(1000)) {
 851                 error("%s: Configure MDIO: MII/MDIO busy\n", __func__);
 852                 goto err_exit;
 853         }
 854
 855         /* Configure GMAC0 */
 856         /* enable one rx interrupt per received frame */
 857         writel(1 << GMAC0_IRL_FRAMECOUNT_SHIFT, GMAC0_INTR_RECV_LAZY_ADDR);
 858
 859         /* read command config reg */
 860         cmdcfg = readl(UNIMAC0_CMD_CFG_ADDR);
 861         /* enable 802.3x tx flow control (honor received PAUSE frames) */
 862         cmdcfg &= ~CC_RPI;
 863         /* enable promiscuous mode */
 864         cmdcfg |= CC_PROM;
 865         /* Disable loopback mode */
 866         cmdcfg &= ~CC_ML;
 867         /* set the speed */
 868         cmdcfg &= ~(CC_ES_MASK | CC_HD);
 869         /* Set to 1Gbps and full duplex by default */
 870         cmdcfg |= (2 << CC_ES_SHIFT);
 871
 872         /* put mac in reset */
 873         gmac_init_reset();
 874         /* write register */
 875         writel(cmdcfg, UNIMAC0_CMD_CFG_ADDR);
 876         /* bring mac out of reset */
 877         gmac_clear_reset();
 878
 879         /* set max frame lengths; account for possible vlan tag */
 880         writel(PKTSIZE + 32, UNIMAC0_FRM_LENGTH_ADDR);
 881
 882         return 0;
 883
 884 err_exit:
 885         dma_deinit(dma);
 886         return -1;
 887 }
 888
 889 int gmac_add(struct eth_device *dev)
 890 {
 891         struct eth_info *eth = (struct eth_info *)(dev->priv);
 892         struct eth_dma *dma = &(eth->dma);
 893         void *tmp;
 894
 895         /*
 896          * Desc has to be 16-byte aligned ?
 897          * If it is 8-byte aligned by malloc, fail Tx
 898          */
 899         tmp = malloc(sizeof(dma64dd_t) * TX_BUF_NUM + 8);
 900         if (tmp == NULL) {
 901                 printf("%s: Failed to allocate TX desc Buffer\n", __func__);
 902                 return -1;
 903         }
 904
 905         dma->tx_desc = (void *)tmp;
 906         dma->tx_desc_aligned = (void *)(((uint32_t)tmp) & (~0xf));
 907         debug("TX Descriptor Buffer: %p; length: 0x%x\n",
 908               dma->tx_desc_aligned, sizeof(dma64dd_t) * TX_BUF_NUM);
 909
 910         tmp = malloc(TX_BUF_SIZE * TX_BUF_NUM);
 911         if (tmp == NULL) {
 912                 printf("%s: Failed to allocate TX Data Buffer\n", __func__);
 913                 free(dma->tx_desc);
 914                 return -1;
 915         }
 916         dma->tx_buf = (uint8_t *)tmp;
 917         debug("TX Data Buffer: %p; length: 0x%x\n",
 918               dma->tx_buf, TX_BUF_SIZE * TX_BUF_NUM);
 919
 920         /* Desc has to be 16-byte aligned ? */
 921         tmp = malloc(sizeof(dma64dd_t) * RX_BUF_NUM + 8);
 922         if (tmp == NULL) {
 923                 printf("%s: Failed to allocate RX Descriptor\n", __func__);
 924                 free(dma->tx_desc);
 925                 free(dma->tx_buf);
 926                 return -1;
 927         }
 928         dma->rx_desc = tmp;
 929         dma->rx_desc_aligned = (void *)(((uint32_t)tmp) & (~0xf));
 930         debug("RX Descriptor Buffer: %p, length: 0x%x\n",
 931               dma->rx_desc_aligned, sizeof(dma64dd_t) * RX_BUF_NUM);
 932
 933         tmp = malloc(RX_BUF_SIZE * RX_BUF_NUM);
 934         if (tmp == NULL) {
 935                 printf("%s: Failed to allocate RX Data Buffer\n", __func__);
 936                 free(dma->tx_desc);
 937                 free(dma->tx_buf);
 938                 free(dma->rx_desc);
 939                 return -1;
 940         }
 941         dma->rx_buf = tmp;
 942         debug("RX Data Buffer: %p; length: 0x%x\n",
 943               dma->rx_buf, RX_BUF_SIZE * RX_BUF_NUM);
 944
 945         g_dmactrlflags = 0;
 946
 947         eth->phy_interface = PHY_INTERFACE_MODE_GMII;
 948
 949         dma->tx_packet = gmac_tx_packet;
 950         dma->check_tx_done = gmac_check_tx_done;
 951
 952         dma->check_rx_done = gmac_check_rx_done;
 953
 954         dma->enable_dma = gmac_enable_dma;
 955         dma->disable_dma = gmac_disable_dma;
 956
 957         eth->miiphy_read = gmac_miiphy_read;
 958         eth->miiphy_write = gmac_miiphy_write;
 959
 960         eth->mac_init = gmac_mac_init;
 961         eth->disable_mac = gmac_disable;
 962         eth->enable_mac = gmac_enable;
 963         eth->set_mac_addr = gmac_set_mac_addr;
 964         eth->set_mac_speed = gmac_set_speed;
 965
 966         return 0;
 967 }