target/linux/ramips/files/drivers/net/ethernet/ramips/ramips_main.c

   1 /*
   2  *   This program is free software; you can redistribute it and/or modify
   3  *   it under the terms of the GNU General Public License as published by
   4  *   the Free Software Foundation; version 2 of the License
   5  *
   6  *   This program is distributed in the hope that it will be useful,
   7  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  *   GNU General Public License for more details.
  10  *
  11  *   You should have received a copy of the GNU General Public License
  12  *   along with this program; if not, write to the Free Software
  13  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  14  *
  15  *   Copyright (C) 2009 John Crispin <blogic@openwrt.org>
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/kernel.h>
  20 #include <linux/types.h>
  21 #include <linux/dma-mapping.h>
  22 #include <linux/init.h>
  23 #include <linux/skbuff.h>
  24 #include <linux/etherdevice.h>
  25 #include <linux/ethtool.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/phy.h>
  28
  29 #include <ramips_eth_platform.h>
  30 #include "ramips_eth.h"
  31
  32 #define TX_TIMEOUT (20 * HZ / 100)
  33 #define MAX_RX_LENGTH   1600
  34
  35 #ifdef CONFIG_RALINK_RT305X
  36 #include <rt305x.h>
  37 #include "ramips_esw.c"
  38 #else
  39 static inline int rt305x_esw_init(void) { return 0; }
  40 static inline void rt305x_esw_exit(void) { }
  41 static inline int soc_is_rt5350(void) { return 0; }
  42 #endif
  43
  44 #define phys_to_bus(a)  (a & 0x1FFFFFFF)
  45
  46 #ifdef CONFIG_RAMIPS_ETH_DEBUG
  47 #define RADEBUG(fmt, args...)   printk(KERN_DEBUG fmt, ## args)
  48 #else
  49 #define RADEBUG(fmt, args...)   do {} while (0)
  50 #endif
  51
  52 #define RX_DLY_INT ((soc_is_rt5350())?(RT5350_RX_DLY_INT):(RAMIPS_RX_DLY_INT))
  53 #define TX_DLY_INT ((soc_is_rt5350())?(RT5350_TX_DLY_INT):(RAMIPS_TX_DLY_INT))
  54
  55 enum raeth_reg {
  56         RAETH_REG_PDMA_GLO_CFG = 0,
  57         RAETH_REG_PDMA_RST_CFG,
  58         RAETH_REG_DLY_INT_CFG,
  59         RAETH_REG_TX_BASE_PTR0,
  60         RAETH_REG_TX_MAX_CNT0,
  61         RAETH_REG_TX_CTX_IDX0,
  62         RAETH_REG_RX_BASE_PTR0,
  63         RAETH_REG_RX_MAX_CNT0,
  64         RAETH_REG_RX_CALC_IDX0,
  65         RAETH_REG_FE_INT_ENABLE,
  66         RAETH_REG_FE_INT_STATUS,
  67         RAETH_REG_COUNT
  68 };
  69
  70 static const u32 ramips_reg_table[RAETH_REG_COUNT] = {
  71         [RAETH_REG_PDMA_GLO_CFG] = RAMIPS_PDMA_GLO_CFG,
  72         [RAETH_REG_PDMA_RST_CFG] = RAMIPS_PDMA_RST_CFG,
  73         [RAETH_REG_DLY_INT_CFG] = RAMIPS_DLY_INT_CFG,
  74         [RAETH_REG_TX_BASE_PTR0] = RAMIPS_TX_BASE_PTR0,
  75         [RAETH_REG_TX_MAX_CNT0] = RAMIPS_TX_MAX_CNT0,
  76         [RAETH_REG_TX_CTX_IDX0] = RAMIPS_TX_CTX_IDX0,
  77         [RAETH_REG_RX_BASE_PTR0] = RAMIPS_RX_BASE_PTR0,
  78         [RAETH_REG_RX_MAX_CNT0] = RAMIPS_RX_MAX_CNT0,
  79         [RAETH_REG_RX_CALC_IDX0] = RAMIPS_RX_CALC_IDX0,
  80         [RAETH_REG_FE_INT_ENABLE] = RAMIPS_FE_INT_ENABLE,
  81         [RAETH_REG_FE_INT_STATUS] = RAMIPS_FE_INT_STATUS,
  82 };
  83
  84 static const u32 rt5350_reg_table[RAETH_REG_COUNT] = {
  85         [RAETH_REG_PDMA_GLO_CFG] = RT5350_PDMA_GLO_CFG,
  86         [RAETH_REG_PDMA_RST_CFG] = RT5350_PDMA_RST_CFG,
  87         [RAETH_REG_DLY_INT_CFG] = RT5350_DLY_INT_CFG,
  88         [RAETH_REG_TX_BASE_PTR0] = RT5350_TX_BASE_PTR0,
  89         [RAETH_REG_TX_MAX_CNT0] = RT5350_TX_MAX_CNT0,
  90         [RAETH_REG_TX_CTX_IDX0] = RT5350_TX_CTX_IDX0,
  91         [RAETH_REG_RX_BASE_PTR0] = RT5350_RX_BASE_PTR0,
  92         [RAETH_REG_RX_MAX_CNT0] = RT5350_RX_MAX_CNT0,
  93         [RAETH_REG_RX_CALC_IDX0] = RT5350_RX_CALC_IDX0,
  94         [RAETH_REG_FE_INT_ENABLE] = RT5350_FE_INT_ENABLE,
  95         [RAETH_REG_FE_INT_STATUS] = RT5350_FE_INT_STATUS,
  96 };
  97
  98 static struct net_device * ramips_dev;
  99 static void __iomem *ramips_fe_base = 0;
 100
 101 static inline u32 get_reg_offset(enum raeth_reg reg)
 102 {
 103         const u32 *table;
 104
 105         if (soc_is_rt5350())
 106                 table = rt5350_reg_table;
 107         else
 108                 table = ramips_reg_table;
 109
 110         return table[reg];
 111 }
 112
 113 static inline void
 114 ramips_fe_wr(u32 val, unsigned reg)
 115 {
 116         __raw_writel(val, ramips_fe_base + reg);
 117 }
 118
 119 static inline u32
 120 ramips_fe_rr(unsigned reg)
 121 {
 122         return __raw_readl(ramips_fe_base + reg);
 123 }
 124
 125 static inline void
 126 ramips_fe_twr(u32 val, enum raeth_reg reg)
 127 {
 128         ramips_fe_wr(val, get_reg_offset(reg));
 129 }
 130
 131 static inline u32
 132 ramips_fe_trr(enum raeth_reg reg)
 133 {
 134         return ramips_fe_rr(get_reg_offset(reg));
 135 }
 136
 137 static inline void
 138 ramips_fe_int_disable(u32 mask)
 139 {
 140         ramips_fe_twr(ramips_fe_trr(RAETH_REG_FE_INT_ENABLE) & ~mask,
 141                      RAETH_REG_FE_INT_ENABLE);
 142         /* flush write */
 143         ramips_fe_trr(RAETH_REG_FE_INT_ENABLE);
 144 }
 145
 146 static inline void
 147 ramips_fe_int_enable(u32 mask)
 148 {
 149         ramips_fe_twr(ramips_fe_trr(RAETH_REG_FE_INT_ENABLE) | mask,
 150                      RAETH_REG_FE_INT_ENABLE);
 151         /* flush write */
 152         ramips_fe_trr(RAETH_REG_FE_INT_ENABLE);
 153 }
 154
 155 static inline void
 156 ramips_hw_set_macaddr(unsigned char *mac)
 157 {
 158         if (soc_is_rt5350()) {
 159                 ramips_fe_wr((mac[0] << 8) | mac[1], RT5350_SDM_MAC_ADRH);
 160                 ramips_fe_wr((mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) | mac[5],
 161                              RT5350_SDM_MAC_ADRL);
 162         } else {
 163                 ramips_fe_wr((mac[0] << 8) | mac[1], RAMIPS_GDMA1_MAC_ADRH);
 164                 ramips_fe_wr((mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) | mac[5],
 165                              RAMIPS_GDMA1_MAC_ADRL);
 166         }
 167 }
 168
 169 static struct sk_buff *
 170 ramips_alloc_skb(struct raeth_priv *re)
 171 {
 172         struct sk_buff *skb;
 173
 174         skb = netdev_alloc_skb(re->netdev, MAX_RX_LENGTH + NET_IP_ALIGN);
 175         if (!skb)
 176                 return NULL;
 177
 178         skb_reserve(skb, NET_IP_ALIGN);
 179
 180         return skb;
 181 }
 182
 183 static void
 184 ramips_ring_setup(struct raeth_priv *re)
 185 {
 186         int len;
 187         int i;
 188
 189         memset(re->tx_info, 0, NUM_TX_DESC * sizeof(struct raeth_tx_info));
 190
 191         len = NUM_TX_DESC * sizeof(struct ramips_tx_dma);
 192         memset(re->tx, 0, len);
 193
 194         for (i = 0; i < NUM_TX_DESC; i++) {
 195                 struct raeth_tx_info *txi;
 196                 struct ramips_tx_dma *txd;
 197
 198                 txd = &re->tx[i];
 199                 txd->txd4 = TX_DMA_QN(3) | TX_DMA_PN(1);
 200                 txd->txd2 = TX_DMA_LSO | TX_DMA_DONE;
 201
 202                 txi = &re->tx_info[i];
 203                 txi->tx_desc = txd;
 204                 if (txi->tx_skb != NULL) {
 205                         netdev_warn(re->netdev,
 206                                     "dirty skb for TX desc %d\n", i);
 207                         txi->tx_skb = NULL;
 208                 }
 209         }
 210
 211         len = NUM_RX_DESC * sizeof(struct ramips_rx_dma);
 212         memset(re->rx, 0, len);
 213
 214         for (i = 0; i < NUM_RX_DESC; i++) {
 215                 struct raeth_rx_info *rxi;
 216                 struct ramips_rx_dma *rxd;
 217                 dma_addr_t dma_addr;
 218
 219                 rxd = &re->rx[i];
 220                 rxi = &re->rx_info[i];
 221                 BUG_ON(rxi->rx_skb == NULL);
 222                 dma_addr = dma_map_single(&re->netdev->dev, rxi->rx_skb->data,
 223                                           MAX_RX_LENGTH, DMA_FROM_DEVICE);
 224                 rxi->rx_dma = dma_addr;
 225                 rxi->rx_desc = rxd;
 226
 227                 rxd->rxd1 = (unsigned int) dma_addr;
 228                 rxd->rxd2 = RX_DMA_LSO;
 229         }
 230
 231         /* flush descriptors */
 232         wmb();
 233 }
 234
 235 static void
 236 ramips_ring_cleanup(struct raeth_priv *re)
 237 {
 238         int i;
 239
 240         for (i = 0; i < NUM_RX_DESC; i++) {
 241                 struct raeth_rx_info *rxi;
 242
 243                 rxi = &re->rx_info[i];
 244                 if (rxi->rx_skb)
 245                         dma_unmap_single(&re->netdev->dev, rxi->rx_dma,
 246                                          MAX_RX_LENGTH, DMA_FROM_DEVICE);
 247         }
 248
 249         for (i = 0; i < NUM_TX_DESC; i++) {
 250                 struct raeth_tx_info *txi;
 251
 252                 txi = &re->tx_info[i];
 253                 if (txi->tx_skb) {
 254                         dev_kfree_skb_any(txi->tx_skb);
 255                         txi->tx_skb = NULL;
 256                 }
 257         }
 258
 259         netdev_reset_queue(re->netdev);
 260 }
 261
 262 #if defined(CONFIG_RALINK_RT288X) || defined(CONFIG_RALINK_RT3883)
 263
 264 #define RAMIPS_MDIO_RETRY       1000
 265
 266 static unsigned char *ramips_speed_str(struct raeth_priv *re)
 267 {
 268         switch (re->speed) {
 269         case SPEED_1000:
 270                 return "1000";
 271         case SPEED_100:
 272                 return "100";
 273         case SPEED_10:
 274                 return "10";
 275         }
 276
 277         return "?";
 278 }
 279
 280 static void ramips_link_adjust(struct raeth_priv *re)
 281 {
 282         struct ramips_eth_platform_data *pdata;
 283         u32 mdio_cfg;
 284
 285         pdata = re->parent->platform_data;
 286         if (!re->link) {
 287                 netif_carrier_off(re->netdev);
 288                 netdev_info(re->netdev, "link down\n");
 289                 return;
 290         }
 291
 292         mdio_cfg = RAMIPS_MDIO_CFG_TX_CLK_SKEW_200 |
 293                    RAMIPS_MDIO_CFG_TX_CLK_SKEW_200 |
 294                    RAMIPS_MDIO_CFG_GP1_FRC_EN;
 295
 296         if (re->duplex == DUPLEX_FULL)
 297                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_DUPLEX;
 298
 299         if (re->tx_fc)
 300                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_FC_TX;
 301
 302         if (re->rx_fc)
 303                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_FC_RX;
 304
 305         switch (re->speed) {
 306         case SPEED_10:
 307                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_SPEED_10;
 308                 break;
 309         case SPEED_100:
 310                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_SPEED_100;
 311                 break;
 312         case SPEED_1000:
 313                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_SPEED_1000;
 314                 break;
 315         default:
 316                 BUG();
 317         }
 318
 319         ramips_fe_wr(mdio_cfg, RAMIPS_MDIO_CFG);
 320
 321         netif_carrier_on(re->netdev);
 322         netdev_info(re->netdev, "link up (%sMbps/%s duplex)\n",
 323                     ramips_speed_str(re),
 324                     (DUPLEX_FULL == re->duplex) ? "Full" : "Half");
 325 }
 326
 327 static int
 328 ramips_mdio_wait_ready(struct raeth_priv *re)
 329 {
 330         int retries;
 331
 332         retries = RAMIPS_MDIO_RETRY;
 333         while (1) {
 334                 u32 t;
 335
 336                 t = ramips_fe_rr(RAMIPS_MDIO_ACCESS);
 337                 if ((t & (0x1 << 31)) == 0)
 338                         return 0;
 339
 340                 if (retries-- == 0)
 341                         break;
 342
 343                 udelay(1);
 344         }
 345
 346         dev_err(re->parent, "MDIO operation timed out\n");
 347         return -ETIMEDOUT;
 348 }
 349
 350 static int
 351 ramips_mdio_read(struct mii_bus *bus, int phy_addr, int phy_reg)
 352 {
 353         struct raeth_priv *re = bus->priv;
 354         int err;
 355         u32 t;
 356
 357         err = ramips_mdio_wait_ready(re);
 358         if (err)
 359                 return 0xffff;
 360
 361         t = (phy_addr << 24) | (phy_reg << 16);
 362         ramips_fe_wr(t, RAMIPS_MDIO_ACCESS);
 363         t |= (1 << 31);
 364         ramips_fe_wr(t, RAMIPS_MDIO_ACCESS);
 365
 366         err = ramips_mdio_wait_ready(re);
 367         if (err)
 368                 return 0xffff;
 369
 370         RADEBUG("%s: addr=%04x, reg=%04x, value=%04x\n", __func__,
 371                 phy_addr, phy_reg, ramips_fe_rr(RAMIPS_MDIO_ACCESS) & 0xffff);
 372
 373         return ramips_fe_rr(RAMIPS_MDIO_ACCESS) & 0xffff;
 374 }
 375
 376 static int
 377 ramips_mdio_write(struct mii_bus *bus, int phy_addr, int phy_reg, u16 val)
 378 {
 379         struct raeth_priv *re = bus->priv;
 380         int err;
 381         u32 t;
 382
 383         RADEBUG("%s: addr=%04x, reg=%04x, value=%04x\n", __func__,
 384                 phy_addr, phy_reg, ramips_fe_rr(RAMIPS_MDIO_ACCESS) & 0xffff);
 385
 386         err = ramips_mdio_wait_ready(re);
 387         if (err)
 388                 return err;
 389
 390         t = (1 << 30) | (phy_addr << 24) | (phy_reg << 16) | val;
 391         ramips_fe_wr(t, RAMIPS_MDIO_ACCESS);
 392         t |= (1 << 31);
 393         ramips_fe_wr(t, RAMIPS_MDIO_ACCESS);
 394
 395         return ramips_mdio_wait_ready(re);
 396 }
 397
 398 static int
 399 ramips_mdio_reset(struct mii_bus *bus)
 400 {
 401         /* TODO */
 402         return 0;
 403 }
 404
 405 static int
 406 ramips_mdio_init(struct raeth_priv *re)
 407 {
 408         int err;
 409         int i;
 410
 411         re->mii_bus = mdiobus_alloc();
 412         if (re->mii_bus == NULL)
 413                 return -ENOMEM;
 414
 415         re->mii_bus->name = "ramips_mdio";
 416         re->mii_bus->read = ramips_mdio_read;
 417         re->mii_bus->write = ramips_mdio_write;
 418         re->mii_bus->reset = ramips_mdio_reset;
 419         re->mii_bus->irq = re->mii_irq;
 420         re->mii_bus->priv = re;
 421         re->mii_bus->parent = re->parent;
 422
 423         snprintf(re->mii_bus->id, MII_BUS_ID_SIZE, "%s", "ramips_mdio");
 424         re->mii_bus->phy_mask = 0;
 425
 426         for (i = 0; i < PHY_MAX_ADDR; i++)
 427                 re->mii_irq[i] = PHY_POLL;
 428
 429         err = mdiobus_register(re->mii_bus);
 430         if (err)
 431                 goto err_free_bus;
 432
 433         return 0;
 434
 435 err_free_bus:
 436         kfree(re->mii_bus);
 437         return err;
 438 }
 439
 440 static void
 441 ramips_mdio_cleanup(struct raeth_priv *re)
 442 {
 443         mdiobus_unregister(re->mii_bus);
 444         kfree(re->mii_bus);
 445 }
 446
 447 static void
 448 ramips_phy_link_adjust(struct net_device *dev)
 449 {
 450         struct raeth_priv *re = netdev_priv(dev);
 451         struct phy_device *phydev = re->phy_dev;
 452         unsigned long flags;
 453         int status_change = 0;
 454
 455         spin_lock_irqsave(&re->phy_lock, flags);
 456
 457         if (phydev->link)
 458                 if (re->duplex != phydev->duplex ||
 459                     re->speed != phydev->speed)
 460                         status_change = 1;
 461
 462         if (phydev->link != re->link)
 463                 status_change = 1;
 464
 465         re->link = phydev->link;
 466         re->duplex = phydev->duplex;
 467         re->speed = phydev->speed;
 468
 469         if (status_change)
 470                 ramips_link_adjust(re);
 471
 472         spin_unlock_irqrestore(&re->phy_lock, flags);
 473 }
 474
 475 static int
 476 ramips_phy_connect_multi(struct raeth_priv *re)
 477 {
 478         struct net_device *netdev = re->netdev;
 479         struct ramips_eth_platform_data *pdata;
 480         struct phy_device *phydev = NULL;
 481         int phy_addr;
 482         int ret = 0;
 483
 484         pdata = re->parent->platform_data;
 485         for (phy_addr = 0; phy_addr < PHY_MAX_ADDR; phy_addr++) {
 486                 if (!(pdata->phy_mask & (1 << phy_addr)))
 487                         continue;
 488
 489                 if (re->mii_bus->phy_map[phy_addr] == NULL)
 490                         continue;
 491
 492                 RADEBUG("%s: PHY found at %s, uid=%08x\n",
 493                         netdev->name,
 494                         dev_name(&re->mii_bus->phy_map[phy_addr]->dev),
 495                         re->mii_bus->phy_map[phy_addr]->phy_id);
 496
 497                 if (phydev == NULL)
 498                         phydev = re->mii_bus->phy_map[phy_addr];
 499         }
 500
 501         if (!phydev) {
 502                 netdev_err(netdev, "no PHY found with phy_mask=%08x\n",
 503                            pdata->phy_mask);
 504                 return -ENODEV;
 505         }
 506
 507         re->phy_dev = phy_connect(netdev, dev_name(&phydev->dev),
 508                                   ramips_phy_link_adjust, 0,
 509                                   pdata->phy_if_mode);
 510
 511         if (IS_ERR(re->phy_dev)) {
 512                 netdev_err(netdev, "could not connect to PHY at %s\n",
 513                            dev_name(&phydev->dev));
 514                 return PTR_ERR(re->phy_dev);
 515         }
 516
 517         phydev->supported &= PHY_GBIT_FEATURES;
 518         phydev->advertising = phydev->supported;
 519
 520         RADEBUG("%s: connected to PHY at %s [uid=%08x, driver=%s]\n",
 521                 netdev->name, dev_name(&phydev->dev),
 522                 phydev->phy_id, phydev->drv->name);
 523
 524         re->link = 0;
 525         re->speed = 0;
 526         re->duplex = -1;
 527         re->rx_fc = 0;
 528         re->tx_fc = 0;
 529
 530         return ret;
 531 }
 532
 533 static int
 534 ramips_phy_connect_fixed(struct raeth_priv *re)
 535 {
 536         struct ramips_eth_platform_data *pdata;
 537
 538         pdata = re->parent->platform_data;
 539         switch (pdata->speed) {
 540         case SPEED_10:
 541         case SPEED_100:
 542         case SPEED_1000:
 543                 break;
 544         default:
 545                 netdev_err(re->netdev, "invalid speed specified\n");
 546                 return -EINVAL;
 547         }
 548
 549         RADEBUG("%s: using fixed link parameters\n", re->netdev->name);
 550
 551         re->speed = pdata->speed;
 552         re->duplex = pdata->duplex;
 553         re->tx_fc = pdata->tx_fc;
 554         re->rx_fc = pdata->tx_fc;
 555
 556         return 0;
 557 }
 558
 559 static int
 560 ramips_phy_connect(struct raeth_priv *re)
 561 {
 562         struct ramips_eth_platform_data *pdata;
 563
 564         pdata = re->parent->platform_data;
 565         if (pdata->phy_mask)
 566                 return ramips_phy_connect_multi(re);
 567
 568         return ramips_phy_connect_fixed(re);
 569 }
 570
 571 static void
 572 ramips_phy_disconnect(struct raeth_priv *re)
 573 {
 574         if (re->phy_dev)
 575                 phy_disconnect(re->phy_dev);
 576 }
 577
 578 static void
 579 ramips_phy_start(struct raeth_priv *re)
 580 {
 581         unsigned long flags;
 582
 583         if (re->phy_dev) {
 584                 phy_start(re->phy_dev);
 585         } else {
 586                 spin_lock_irqsave(&re->phy_lock, flags);
 587                 re->link = 1;
 588                 ramips_link_adjust(re);
 589                 spin_unlock_irqrestore(&re->phy_lock, flags);
 590         }
 591 }
 592
 593 static void
 594 ramips_phy_stop(struct raeth_priv *re)
 595 {
 596         unsigned long flags;
 597
 598         if (re->phy_dev)
 599                 phy_stop(re->phy_dev);
 600
 601         spin_lock_irqsave(&re->phy_lock, flags);
 602         re->link = 0;
 603         ramips_link_adjust(re);
 604         spin_unlock_irqrestore(&re->phy_lock, flags);
 605 }
 606 #else
 607 static inline int
 608 ramips_mdio_init(struct raeth_priv *re)
 609 {
 610         return 0;
 611 }
 612
 613 static inline void
 614 ramips_mdio_cleanup(struct raeth_priv *re)
 615 {
 616 }
 617
 618 static inline int
 619 ramips_phy_connect(struct raeth_priv *re)
 620 {
 621         return 0;
 622 }
 623
 624 static inline void
 625 ramips_phy_disconnect(struct raeth_priv *re)
 626 {
 627 }
 628
 629 static inline void
 630 ramips_phy_start(struct raeth_priv *re)
 631 {
 632 }
 633
 634 static inline void
 635 ramips_phy_stop(struct raeth_priv *re)
 636 {
 637 }
 638 #endif /* CONFIG_RALINK_RT288X || CONFIG_RALINK_RT3883 */
 639
 640 static void
 641 ramips_ring_free(struct raeth_priv *re)
 642 {
 643         int len;
 644         int i;
 645
 646         if (re->rx_info) {
 647                 for (i = 0; i < NUM_RX_DESC; i++) {
 648                         struct raeth_rx_info *rxi;
 649
 650                         rxi = &re->rx_info[i];
 651                         if (rxi->rx_skb)
 652                                 dev_kfree_skb_any(rxi->rx_skb);
 653                 }
 654                 kfree(re->rx_info);
 655         }
 656
 657         if (re->rx) {
 658                 len = NUM_RX_DESC * sizeof(struct ramips_rx_dma);
 659                 dma_free_coherent(&re->netdev->dev, len, re->rx,
 660                                   re->rx_desc_dma);
 661         }
 662
 663         if (re->tx) {
 664                 len = NUM_TX_DESC * sizeof(struct ramips_tx_dma);
 665                 dma_free_coherent(&re->netdev->dev, len, re->tx,
 666                                   re->tx_desc_dma);
 667         }
 668
 669         kfree(re->tx_info);
 670 }
 671
 672 static int
 673 ramips_ring_alloc(struct raeth_priv *re)
 674 {
 675         int len;
 676         int err = -ENOMEM;
 677         int i;
 678
 679         re->tx_info = kzalloc(NUM_TX_DESC * sizeof(struct raeth_tx_info),
 680                               GFP_ATOMIC);
 681         if (!re->tx_info)
 682                 goto err_cleanup;
 683
 684         re->rx_info = kzalloc(NUM_RX_DESC * sizeof(struct raeth_rx_info),
 685                               GFP_ATOMIC);
 686         if (!re->rx_info)
 687                 goto err_cleanup;
 688
 689         /* allocate tx ring */
 690         len = NUM_TX_DESC * sizeof(struct ramips_tx_dma);
 691         re->tx = dma_alloc_coherent(&re->netdev->dev, len,
 692                                           &re->tx_desc_dma, GFP_ATOMIC);
 693         if (!re->tx)
 694                 goto err_cleanup;
 695
 696         /* allocate rx ring */
 697         len = NUM_RX_DESC * sizeof(struct ramips_rx_dma);
 698         re->rx = dma_alloc_coherent(&re->netdev->dev, len,
 699                                     &re->rx_desc_dma, GFP_ATOMIC);
 700         if (!re->rx)
 701                 goto err_cleanup;
 702
 703         for (i = 0; i < NUM_RX_DESC; i++) {
 704                 struct sk_buff *skb;
 705
 706                 skb = ramips_alloc_skb(re);
 707                 if (!skb)
 708                         goto err_cleanup;
 709
 710                 re->rx_info[i].rx_skb = skb;
 711         }
 712
 713         return 0;
 714
 715 err_cleanup:
 716         ramips_ring_free(re);
 717         return err;
 718 }
 719
 720 static void
 721 ramips_setup_dma(struct raeth_priv *re)
 722 {
 723         ramips_fe_twr(re->tx_desc_dma, RAETH_REG_TX_BASE_PTR0);
 724         ramips_fe_twr(NUM_TX_DESC, RAETH_REG_TX_MAX_CNT0);
 725         ramips_fe_twr(0, RAETH_REG_TX_CTX_IDX0);
 726         ramips_fe_twr(RAMIPS_PST_DTX_IDX0, RAETH_REG_PDMA_RST_CFG);
 727
 728         ramips_fe_twr(re->rx_desc_dma, RAETH_REG_RX_BASE_PTR0);
 729         ramips_fe_twr(NUM_RX_DESC, RAETH_REG_RX_MAX_CNT0);
 730         ramips_fe_twr((NUM_RX_DESC - 1), RAETH_REG_RX_CALC_IDX0);
 731         ramips_fe_twr(RAMIPS_PST_DRX_IDX0, RAETH_REG_PDMA_RST_CFG);
 732 }
 733
 734 static int
 735 ramips_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 736 {
 737         struct raeth_priv *re = netdev_priv(dev);
 738         struct raeth_tx_info *txi, *txi_next;
 739         struct ramips_tx_dma *txd, *txd_next;
 740         unsigned long tx;
 741         unsigned int tx_next;
 742         dma_addr_t mapped_addr;
 743
 744         if (re->plat->min_pkt_len) {
 745                 if (skb->len < re->plat->min_pkt_len) {
 746                         if (skb_padto(skb, re->plat->min_pkt_len)) {
 747                                 printk(KERN_ERR
 748                                        "ramips_eth: skb_padto failed\n");
 749                                 kfree_skb(skb);
 750                                 return 0;
 751                         }
 752                         skb_put(skb, re->plat->min_pkt_len - skb->len);
 753                 }
 754         }
 755
 756         dev->trans_start = jiffies;
 757         mapped_addr = dma_map_single(&re->netdev->dev, skb->data, skb->len,
 758                                      DMA_TO_DEVICE);
 759
 760         spin_lock(&re->page_lock);
 761         tx = ramips_fe_trr(RAETH_REG_TX_CTX_IDX0);
 762         tx_next = (tx + 1) % NUM_TX_DESC;
 763
 764         txi = &re->tx_info[tx];
 765         txd = txi->tx_desc;
 766         txi_next = &re->tx_info[tx_next];
 767         txd_next = txi_next->tx_desc;
 768
 769         if ((txi->tx_skb) || (txi_next->tx_skb) ||
 770             !(txd->txd2 & TX_DMA_DONE) ||
 771             !(txd_next->txd2 & TX_DMA_DONE))
 772                 goto out;
 773
 774         txi->tx_skb = skb;
 775
 776         txd->txd1 = (unsigned int) mapped_addr;
 777         wmb();
 778         txd->txd2 = TX_DMA_LSO | TX_DMA_PLEN0(skb->len);
 779         dev->stats.tx_packets++;
 780         dev->stats.tx_bytes += skb->len;
 781         ramips_fe_twr(tx_next, RAETH_REG_TX_CTX_IDX0);
 782         netdev_sent_queue(dev, skb->len);
 783         spin_unlock(&re->page_lock);
 784         return NETDEV_TX_OK;
 785
 786  out:
 787         spin_unlock(&re->page_lock);
 788         dev->stats.tx_dropped++;
 789         kfree_skb(skb);
 790         return NETDEV_TX_OK;
 791 }
 792
 793 static void
 794 ramips_eth_rx_hw(unsigned long ptr)
 795 {
 796         struct net_device *dev = (struct net_device *) ptr;
 797         struct raeth_priv *re = netdev_priv(dev);
 798         int rx;
 799         int max_rx = 16;
 800
 801         rx = ramips_fe_trr(RAETH_REG_RX_CALC_IDX0);
 802
 803         while (max_rx) {
 804                 struct raeth_rx_info *rxi;
 805                 struct ramips_rx_dma *rxd;
 806                 struct sk_buff *rx_skb, *new_skb;
 807                 int pktlen;
 808
 809                 rx = (rx + 1) % NUM_RX_DESC;
 810
 811                 rxi = &re->rx_info[rx];
 812                 rxd = rxi->rx_desc;
 813                 if (!(rxd->rxd2 & RX_DMA_DONE))
 814                         break;
 815
 816                 rx_skb = rxi->rx_skb;
 817                 pktlen = RX_DMA_PLEN0(rxd->rxd2);
 818
 819                 new_skb = ramips_alloc_skb(re);
 820                 /* Reuse the buffer on allocation failures */
 821                 if (new_skb) {
 822                         dma_addr_t dma_addr;
 823
 824                         dma_unmap_single(&re->netdev->dev, rxi->rx_dma,
 825                                          MAX_RX_LENGTH, DMA_FROM_DEVICE);
 826
 827                         skb_put(rx_skb, pktlen);
 828                         rx_skb->dev = dev;
 829                         rx_skb->protocol = eth_type_trans(rx_skb, dev);
 830                         rx_skb->ip_summed = CHECKSUM_NONE;
 831                         dev->stats.rx_packets++;
 832                         dev->stats.rx_bytes += pktlen;
 833                         netif_rx(rx_skb);
 834
 835                         rxi->rx_skb = new_skb;
 836
 837                         dma_addr = dma_map_single(&re->netdev->dev,
 838                                                   new_skb->data,
 839                                                   MAX_RX_LENGTH,
 840                                                   DMA_FROM_DEVICE);
 841                         rxi->rx_dma = dma_addr;
 842                         rxd->rxd1 = (unsigned int) dma_addr;
 843                         wmb();
 844                 } else {
 845                         dev->stats.rx_dropped++;
 846                 }
 847
 848                 rxd->rxd2 = RX_DMA_LSO;
 849                 ramips_fe_twr(rx, RAETH_REG_RX_CALC_IDX0);
 850                 max_rx--;
 851         }
 852
 853         if (max_rx == 0)
 854                 tasklet_schedule(&re->rx_tasklet);
 855         else
 856                 ramips_fe_int_enable(RX_DLY_INT);
 857 }
 858
 859 static void
 860 ramips_eth_tx_housekeeping(unsigned long ptr)
 861 {
 862         struct net_device *dev = (struct net_device*)ptr;
 863         struct raeth_priv *re = netdev_priv(dev);
 864         unsigned int bytes_compl = 0, pkts_compl = 0;
 865
 866         spin_lock(&re->page_lock);
 867         while (1) {
 868                 struct raeth_tx_info *txi;
 869                 struct ramips_tx_dma *txd;
 870
 871                 txi = &re->tx_info[re->skb_free_idx];
 872                 txd = txi->tx_desc;
 873
 874                 if (!(txd->txd2 & TX_DMA_DONE) || !(txi->tx_skb))
 875                         break;
 876
 877                 pkts_compl++;
 878                 bytes_compl += txi->tx_skb->len;
 879
 880                 dev_kfree_skb_irq(txi->tx_skb);
 881                 txi->tx_skb = NULL;
 882                 re->skb_free_idx++;
 883                 if (re->skb_free_idx >= NUM_TX_DESC)
 884                         re->skb_free_idx = 0;
 885         }
 886         netdev_completed_queue(dev, pkts_compl, bytes_compl);
 887         spin_unlock(&re->page_lock);
 888
 889         ramips_fe_int_enable(TX_DLY_INT);
 890 }
 891
 892 static void
 893 ramips_eth_timeout(struct net_device *dev)
 894 {
 895         struct raeth_priv *re = netdev_priv(dev);
 896
 897         tasklet_schedule(&re->tx_housekeeping_tasklet);
 898 }
 899
 900 static irqreturn_t
 901 ramips_eth_irq(int irq, void *dev)
 902 {
 903         struct raeth_priv *re = netdev_priv(dev);
 904         unsigned int status;
 905
 906         status = ramips_fe_trr(RAETH_REG_FE_INT_STATUS);
 907         status &= ramips_fe_trr(RAETH_REG_FE_INT_ENABLE);
 908
 909         if (!status)
 910                 return IRQ_NONE;
 911
 912         ramips_fe_twr(status, RAETH_REG_FE_INT_STATUS);
 913
 914         if (status & RX_DLY_INT) {
 915                 ramips_fe_int_disable(RX_DLY_INT);
 916                 tasklet_schedule(&re->rx_tasklet);
 917         }
 918
 919         if (status & TX_DLY_INT) {
 920                 ramips_fe_int_disable(TX_DLY_INT);
 921                 tasklet_schedule(&re->tx_housekeeping_tasklet);
 922         }
 923
 924         raeth_debugfs_update_int_stats(re, status);
 925
 926         return IRQ_HANDLED;
 927 }
 928
 929 static int
 930 ramips_eth_hw_init(struct net_device *dev)
 931 {
 932         struct raeth_priv *re = netdev_priv(dev);
 933         int err;
 934
 935         err = request_irq(dev->irq, ramips_eth_irq, IRQF_DISABLED,
 936                           dev->name, dev);
 937         if (err)
 938                 return err;
 939
 940         err = ramips_ring_alloc(re);
 941         if (err)
 942                 goto err_free_irq;
 943
 944         ramips_ring_setup(re);
 945         ramips_hw_set_macaddr(dev->dev_addr);
 946
 947         ramips_setup_dma(re);
 948         ramips_fe_wr((ramips_fe_rr(RAMIPS_FE_GLO_CFG) &
 949                 ~(RAMIPS_US_CYC_CNT_MASK << RAMIPS_US_CYC_CNT_SHIFT)) |
 950                 ((re->plat->sys_freq / RAMIPS_US_CYC_CNT_DIVISOR) << RAMIPS_US_CYC_CNT_SHIFT),
 951                 RAMIPS_FE_GLO_CFG);
 952
 953         tasklet_init(&re->tx_housekeeping_tasklet, ramips_eth_tx_housekeeping,
 954                      (unsigned long)dev);
 955         tasklet_init(&re->rx_tasklet, ramips_eth_rx_hw, (unsigned long)dev);
 956
 957
 958         ramips_fe_twr(RAMIPS_DELAY_INIT, RAETH_REG_DLY_INT_CFG);
 959         ramips_fe_twr(TX_DLY_INT | RX_DLY_INT, RAETH_REG_FE_INT_ENABLE);
 960         if (soc_is_rt5350()) {
 961                 ramips_fe_wr(ramips_fe_rr(RT5350_SDM_CFG) &
 962                         ~(RT5350_SDM_ICS_EN | RT5350_SDM_TCS_EN | RT5350_SDM_UCS_EN | 0xffff),
 963                         RT5350_SDM_CFG);
 964         } else {
 965                 ramips_fe_wr(ramips_fe_rr(RAMIPS_GDMA1_FWD_CFG) &
 966                         ~(RAMIPS_GDM1_ICS_EN | RAMIPS_GDM1_TCS_EN | RAMIPS_GDM1_UCS_EN | 0xffff),
 967                         RAMIPS_GDMA1_FWD_CFG);
 968                 ramips_fe_wr(ramips_fe_rr(RAMIPS_CDMA_CSG_CFG) &
 969                         ~(RAMIPS_ICS_GEN_EN | RAMIPS_TCS_GEN_EN | RAMIPS_UCS_GEN_EN),
 970                         RAMIPS_CDMA_CSG_CFG);
 971                 ramips_fe_wr(RAMIPS_PSE_FQFC_CFG_INIT, RAMIPS_PSE_FQ_CFG);
 972         }
 973         ramips_fe_wr(1, RAMIPS_FE_RST_GL);
 974         ramips_fe_wr(0, RAMIPS_FE_RST_GL);
 975
 976         return 0;
 977
 978 err_free_irq:
 979         free_irq(dev->irq, dev);
 980         return err;
 981 }
 982
 983 static int
 984 ramips_eth_open(struct net_device *dev)
 985 {
 986         struct raeth_priv *re = netdev_priv(dev);
 987
 988         ramips_fe_twr((ramips_fe_trr(RAETH_REG_PDMA_GLO_CFG) & 0xff) |
 989                 (RAMIPS_TX_WB_DDONE | RAMIPS_RX_DMA_EN |
 990                 RAMIPS_TX_DMA_EN | RAMIPS_PDMA_SIZE_4DWORDS),
 991                 RAETH_REG_PDMA_GLO_CFG);
 992         ramips_phy_start(re);
 993         netif_start_queue(dev);
 994         return 0;
 995 }
 996
 997 static int
 998 ramips_eth_stop(struct net_device *dev)
 999 {
1000         struct raeth_priv *re = netdev_priv(dev);
1001
1002         ramips_fe_twr(ramips_fe_trr(RAETH_REG_PDMA_GLO_CFG) &
1003                      ~(RAMIPS_TX_WB_DDONE | RAMIPS_RX_DMA_EN | RAMIPS_TX_DMA_EN),
1004                      RAETH_REG_PDMA_GLO_CFG);
1005
1006         netif_stop_queue(dev);
1007         ramips_phy_stop(re);
1008         RADEBUG("ramips_eth: stopped\n");
1009         return 0;
1010 }
1011
1012 static int __init
1013 ramips_eth_probe(struct net_device *dev)
1014 {
1015         struct raeth_priv *re = netdev_priv(dev);
1016         int err;
1017
1018         BUG_ON(!re->plat->reset_fe);
1019         re->plat->reset_fe();
1020         net_srandom(jiffies);
1021         memcpy(dev->dev_addr, re->plat->mac, ETH_ALEN);
1022
1023         ether_setup(dev);
1024         dev->mtu = 1500;
1025         dev->watchdog_timeo = TX_TIMEOUT;
1026         spin_lock_init(&re->page_lock);
1027         spin_lock_init(&re->phy_lock);
1028
1029         err = ramips_mdio_init(re);
1030         if (err)
1031                 return err;
1032
1033         err = ramips_phy_connect(re);
1034         if (err)
1035                 goto err_mdio_cleanup;
1036
1037         err = raeth_debugfs_init(re);
1038         if (err)
1039                 goto err_phy_disconnect;
1040
1041         err = ramips_eth_hw_init(dev);
1042         if (err)
1043                 goto err_debugfs;
1044
1045         return 0;
1046
1047 err_debugfs:
1048         raeth_debugfs_exit(re);
1049 err_phy_disconnect:
1050         ramips_phy_disconnect(re);
1051 err_mdio_cleanup:
1052         ramips_mdio_cleanup(re);
1053         return err;
1054 }
1055
1056 static void
1057 ramips_eth_uninit(struct net_device *dev)
1058 {
1059         struct raeth_priv *re = netdev_priv(dev);
1060
1061         raeth_debugfs_exit(re);
1062         ramips_phy_disconnect(re);
1063         ramips_mdio_cleanup(re);
1064         ramips_fe_twr(0, RAETH_REG_FE_INT_ENABLE);
1065         free_irq(dev->irq, dev);
1066         tasklet_kill(&re->tx_housekeeping_tasklet);
1067         tasklet_kill(&re->rx_tasklet);
1068         ramips_ring_cleanup(re);
1069         ramips_ring_free(re);
1070 }
1071
1072 static const struct net_device_ops ramips_eth_netdev_ops = {
1073         .ndo_init               = ramips_eth_probe,
1074         .ndo_uninit             = ramips_eth_uninit,
1075         .ndo_open               = ramips_eth_open,
1076         .ndo_stop               = ramips_eth_stop,
1077         .ndo_start_xmit         = ramips_eth_hard_start_xmit,
1078         .ndo_tx_timeout         = ramips_eth_timeout,
1079         .ndo_change_mtu         = eth_change_mtu,
1080         .ndo_set_mac_address    = eth_mac_addr,
1081         .ndo_validate_addr      = eth_validate_addr,
1082 };
1083
1084 static int
1085 ramips_eth_plat_probe(struct platform_device *plat)
1086 {
1087         struct raeth_priv *re;
1088         struct ramips_eth_platform_data *data = plat->dev.platform_data;
1089         struct resource *res;
1090         int err;
1091
1092         if (!data) {
1093                 dev_err(&plat->dev, "no platform data specified\n");
1094                 return -EINVAL;
1095         }
1096
1097         res = platform_get_resource(plat, IORESOURCE_MEM, 0);
1098         if (!res) {
1099                 dev_err(&plat->dev, "no memory resource found\n");
1100                 return -ENXIO;
1101         }
1102
1103         ramips_fe_base = ioremap_nocache(res->start, res->end - res->start + 1);
1104         if (!ramips_fe_base)
1105                 return -ENOMEM;
1106
1107         ramips_dev = alloc_etherdev(sizeof(struct raeth_priv));
1108         if (!ramips_dev) {
1109                 dev_err(&plat->dev, "alloc_etherdev failed\n");
1110                 err = -ENOMEM;
1111                 goto err_unmap;
1112         }
1113
1114         strcpy(ramips_dev->name, "eth%d");
1115         ramips_dev->irq = platform_get_irq(plat, 0);
1116         if (ramips_dev->irq < 0) {
1117                 dev_err(&plat->dev, "no IRQ resource found\n");
1118                 err = -ENXIO;
1119                 goto err_free_dev;
1120         }
1121         ramips_dev->addr_len = ETH_ALEN;
1122         ramips_dev->base_addr = (unsigned long)ramips_fe_base;
1123         ramips_dev->netdev_ops = &ramips_eth_netdev_ops;
1124
1125         re = netdev_priv(ramips_dev);
1126
1127         re->netdev = ramips_dev;
1128         re->parent = &plat->dev;
1129         re->speed = data->speed;
1130         re->duplex = data->duplex;
1131         re->rx_fc = data->rx_fc;
1132         re->tx_fc = data->tx_fc;
1133         re->plat = data;
1134
1135         err = register_netdev(ramips_dev);
1136         if (err) {
1137                 dev_err(&plat->dev, "error bringing up device\n");
1138                 goto err_free_dev;
1139         }
1140
1141         RADEBUG("ramips_eth: loaded\n");
1142         return 0;
1143
1144  err_free_dev:
1145         kfree(ramips_dev);
1146  err_unmap:
1147         iounmap(ramips_fe_base);
1148         return err;
1149 }
1150
1151 static int
1152 ramips_eth_plat_remove(struct platform_device *plat)
1153 {
1154         unregister_netdev(ramips_dev);
1155         free_netdev(ramips_dev);
1156         RADEBUG("ramips_eth: unloaded\n");
1157         return 0;
1158 }
1159
1160 static struct platform_driver ramips_eth_driver = {
1161         .probe = ramips_eth_plat_probe,
1162         .remove = ramips_eth_plat_remove,
1163         .driver = {
1164                 .name = "ramips_eth",
1165                 .owner = THIS_MODULE,
1166         },
1167 };
1168
1169 static int __init
1170 ramips_eth_init(void)
1171 {
1172         int ret;
1173
1174         ret = raeth_debugfs_root_init();
1175         if (ret)
1176                 goto err_out;
1177
1178         ret = rt305x_esw_init();
1179         if (ret)
1180                 goto err_debugfs_exit;
1181
1182         ret = platform_driver_register(&ramips_eth_driver);
1183         if (ret) {
1184                 printk(KERN_ERR
1185                        "ramips_eth: Error registering platfom driver!\n");
1186                 goto esw_cleanup;
1187         }
1188
1189         return 0;
1190
1191 esw_cleanup:
1192         rt305x_esw_exit();
1193 err_debugfs_exit:
1194         raeth_debugfs_root_exit();
1195 err_out:
1196         return ret;
1197 }
1198
1199 static void __exit
1200 ramips_eth_cleanup(void)
1201 {
1202         platform_driver_unregister(&ramips_eth_driver);
1203         rt305x_esw_exit();
1204         raeth_debugfs_root_exit();
1205 }
1206
1207 module_init(ramips_eth_init);
1208 module_exit(ramips_eth_cleanup);
1209
1210 MODULE_LICENSE("GPL");
1211 MODULE_AUTHOR("John Crispin <blogic@openwrt.org>");
1212 MODULE_DESCRIPTION("ethernet driver for ramips boards");