target/linux/ramips/files/drivers/net/ramips.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
  28 #include <ramips_eth_platform.h>
  29 #include "ramips_eth.h"
  30
  31 #define TX_TIMEOUT (20 * HZ / 100)
  32 #define MAX_RX_LENGTH   1600
  33
  34 #ifdef CONFIG_RALINK_RT305X
  35 #include "ramips_esw.c"
  36 #else
  37 static inline int rt305x_esw_init(void) { return 0; }
  38 static inline void rt305x_esw_exit(void) { }
  39 #endif
  40
  41 #define phys_to_bus(a)  (a & 0x1FFFFFFF)
  42
  43 #ifdef CONFIG_RAMIPS_ETH_DEBUG
  44 #define RADEBUG(fmt, args...)   printk(KERN_DEBUG fmt, ## args)
  45 #else
  46 #define RADEBUG(fmt, args...)   do {} while (0)
  47 #endif
  48
  49 static struct net_device * ramips_dev;
  50 static void __iomem *ramips_fe_base = 0;
  51
  52 static inline void
  53 ramips_fe_wr(u32 val, unsigned reg)
  54 {
  55         __raw_writel(val, ramips_fe_base + reg);
  56 }
  57
  58 static inline u32
  59 ramips_fe_rr(unsigned reg)
  60 {
  61         return __raw_readl(ramips_fe_base + reg);
  62 }
  63
  64 static inline void
  65 ramips_fe_int_disable(u32 mask)
  66 {
  67         ramips_fe_wr(ramips_fe_rr(RAMIPS_FE_INT_ENABLE) & ~mask,
  68                      RAMIPS_FE_INT_ENABLE);
  69         /* flush write */
  70         ramips_fe_rr(RAMIPS_FE_INT_ENABLE);
  71 }
  72
  73 static inline void
  74 ramips_fe_int_enable(u32 mask)
  75 {
  76         ramips_fe_wr(ramips_fe_rr(RAMIPS_FE_INT_ENABLE) | mask,
  77                      RAMIPS_FE_INT_ENABLE);
  78         /* flush write */
  79         ramips_fe_rr(RAMIPS_FE_INT_ENABLE);
  80 }
  81
  82 static inline void
  83 ramips_hw_set_macaddr(unsigned char *mac)
  84 {
  85         ramips_fe_wr((mac[0] << 8) | mac[1], RAMIPS_GDMA1_MAC_ADRH);
  86         ramips_fe_wr((mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) | mac[5],
  87                      RAMIPS_GDMA1_MAC_ADRL);
  88 }
  89
  90 #ifdef CONFIG_RALINK_RT288X
  91 static void
  92 ramips_setup_mdio_cfg(struct raeth_priv *re)
  93 {
  94         unsigned int mdio_cfg;
  95
  96         mdio_cfg = RAMIPS_MDIO_CFG_TX_CLK_SKEW_200 |
  97                    RAMIPS_MDIO_CFG_TX_CLK_SKEW_200 |
  98                    RAMIPS_MDIO_CFG_GP1_FRC_EN;
  99
 100         if (re->duplex == DUPLEX_FULL)
 101                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_DUPLEX;
 102
 103         if (re->tx_fc)
 104                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_FC_TX;
 105
 106         if (re->rx_fc)
 107                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_FC_RX;
 108
 109         switch (re->speed) {
 110         case SPEED_10:
 111                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_SPEED_10;
 112                 break;
 113         case SPEED_100:
 114                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_SPEED_100;
 115                 break;
 116         case SPEED_1000:
 117                 mdio_cfg |= RAMIPS_MDIO_CFG_GP1_SPEED_1000;
 118                 break;
 119         default:
 120                 BUG();
 121         }
 122
 123         ramips_fe_wr(mdio_cfg, RAMIPS_MDIO_CFG);
 124 }
 125 #else
 126 static inline void ramips_setup_mdio_cfg(struct raeth_priv *re)
 127 {
 128 }
 129 #endif /* CONFIG_RALINK_RT288X */
 130
 131 static void
 132 ramips_cleanup_dma(struct raeth_priv *re)
 133 {
 134         int i;
 135
 136         for (i = 0; i < NUM_RX_DESC; i++)
 137                 if (re->rx_skb[i]) {
 138                         dma_unmap_single(&re->netdev->dev, re->rx_dma[i],
 139                                          MAX_RX_LENGTH, DMA_FROM_DEVICE);
 140                         dev_kfree_skb_any(re->rx_skb[i]);
 141                 }
 142
 143         if (re->rx)
 144                 dma_free_coherent(&re->netdev->dev,
 145                                   NUM_RX_DESC * sizeof(struct ramips_rx_dma),
 146                                   re->rx, re->rx_desc_dma);
 147
 148         if (re->tx)
 149                 dma_free_coherent(&re->netdev->dev,
 150                                   NUM_TX_DESC * sizeof(struct ramips_tx_dma),
 151                                   re->tx, re->tx_desc_dma);
 152 }
 153
 154 static int
 155 ramips_alloc_dma(struct raeth_priv *re)
 156 {
 157         int err = -ENOMEM;
 158         int i;
 159
 160         re->skb_free_idx = 0;
 161
 162         /* setup tx ring */
 163         re->tx = dma_alloc_coherent(&re->netdev->dev,
 164                                     NUM_TX_DESC * sizeof(struct ramips_tx_dma),
 165                                     &re->tx_desc_dma, GFP_ATOMIC);
 166         if (!re->tx)
 167                 goto err_cleanup;
 168
 169         memset(re->tx, 0, NUM_TX_DESC * sizeof(struct ramips_tx_dma));
 170         for (i = 0; i < NUM_TX_DESC; i++) {
 171                 re->tx[i].txd2 = TX_DMA_LSO | TX_DMA_DONE;
 172                 re->tx[i].txd4 = TX_DMA_QN(3) | TX_DMA_PN(1);
 173         }
 174
 175         /* setup rx ring */
 176         re->rx = dma_alloc_coherent(&re->netdev->dev,
 177                                     NUM_RX_DESC * sizeof(struct ramips_rx_dma),
 178                                     &re->rx_desc_dma, GFP_ATOMIC);
 179         if (!re->rx)
 180                 goto err_cleanup;
 181
 182         memset(re->rx, 0, sizeof(struct ramips_rx_dma) * NUM_RX_DESC);
 183         for (i = 0; i < NUM_RX_DESC; i++) {
 184                 dma_addr_t dma_addr;
 185                 struct sk_buff *new_skb = dev_alloc_skb(MAX_RX_LENGTH +
 186                                                         NET_IP_ALIGN);
 187
 188                 if (!new_skb)
 189                         goto err_cleanup;
 190
 191                 skb_reserve(new_skb, NET_IP_ALIGN);
 192
 193                 dma_addr = dma_map_single(&re->netdev->dev, new_skb->data,
 194                                           MAX_RX_LENGTH, DMA_FROM_DEVICE);
 195                 re->rx_dma[i] = dma_addr;
 196                 re->rx[i].rxd1 = (unsigned int) re->rx_dma[i];
 197                 re->rx[i].rxd2 |= RX_DMA_LSO;
 198                 re->rx_skb[i] = new_skb;
 199         }
 200
 201         return 0;
 202
 203  err_cleanup:
 204         ramips_cleanup_dma(re);
 205         return err;
 206 }
 207
 208 static void
 209 ramips_setup_dma(struct raeth_priv *re)
 210 {
 211         ramips_fe_wr(re->tx_desc_dma, RAMIPS_TX_BASE_PTR0);
 212         ramips_fe_wr(NUM_TX_DESC, RAMIPS_TX_MAX_CNT0);
 213         ramips_fe_wr(0, RAMIPS_TX_CTX_IDX0);
 214         ramips_fe_wr(RAMIPS_PST_DTX_IDX0, RAMIPS_PDMA_RST_CFG);
 215
 216         ramips_fe_wr(re->rx_desc_dma, RAMIPS_RX_BASE_PTR0);
 217         ramips_fe_wr(NUM_RX_DESC, RAMIPS_RX_MAX_CNT0);
 218         ramips_fe_wr((NUM_RX_DESC - 1), RAMIPS_RX_CALC_IDX0);
 219         ramips_fe_wr(RAMIPS_PST_DRX_IDX0, RAMIPS_PDMA_RST_CFG);
 220 }
 221
 222 static int
 223 ramips_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 224 {
 225         struct raeth_priv *priv = netdev_priv(dev);
 226         unsigned long tx;
 227         unsigned int tx_next;
 228         dma_addr_t mapped_addr;
 229
 230         if (priv->plat->min_pkt_len) {
 231                 if (skb->len < priv->plat->min_pkt_len) {
 232                         if (skb_padto(skb, priv->plat->min_pkt_len)) {
 233                                 printk(KERN_ERR
 234                                        "ramips_eth: skb_padto failed\n");
 235                                 kfree_skb(skb);
 236                                 return 0;
 237                         }
 238                         skb_put(skb, priv->plat->min_pkt_len - skb->len);
 239                 }
 240         }
 241
 242         dev->trans_start = jiffies;
 243         mapped_addr = dma_map_single(&priv->netdev->dev, skb->data, skb->len,
 244                                      DMA_TO_DEVICE);
 245
 246         spin_lock(&priv->page_lock);
 247         tx = ramips_fe_rr(RAMIPS_TX_CTX_IDX0);
 248         tx_next = (tx + 1) % NUM_TX_DESC;
 249
 250         if ((priv->tx_skb[tx]) || (priv->tx_skb[tx_next]) ||
 251             !(priv->tx[tx].txd2 & TX_DMA_DONE) ||
 252             !(priv->tx[tx_next].txd2 & TX_DMA_DONE))
 253                 goto out;
 254
 255         priv->tx[tx].txd1 = (unsigned int) mapped_addr;
 256         priv->tx[tx].txd2 &= ~(TX_DMA_PLEN0_MASK | TX_DMA_DONE);
 257         priv->tx[tx].txd2 |= TX_DMA_PLEN0(skb->len);
 258         dev->stats.tx_packets++;
 259         dev->stats.tx_bytes += skb->len;
 260         priv->tx_skb[tx] = skb;
 261         wmb();
 262         ramips_fe_wr(tx_next, RAMIPS_TX_CTX_IDX0);
 263         spin_unlock(&priv->page_lock);
 264         return NETDEV_TX_OK;
 265
 266  out:
 267         spin_unlock(&priv->page_lock);
 268         dev->stats.tx_dropped++;
 269         kfree_skb(skb);
 270         return NETDEV_TX_OK;
 271 }
 272
 273 static void
 274 ramips_eth_rx_hw(unsigned long ptr)
 275 {
 276         struct net_device *dev = (struct net_device *) ptr;
 277         struct raeth_priv *priv = netdev_priv(dev);
 278         int rx;
 279         int max_rx = 16;
 280
 281         while (max_rx) {
 282                 struct sk_buff *rx_skb, *new_skb;
 283                 int pktlen;
 284
 285                 rx = (ramips_fe_rr(RAMIPS_RX_CALC_IDX0) + 1) % NUM_RX_DESC;
 286                 if (!(priv->rx[rx].rxd2 & RX_DMA_DONE))
 287                         break;
 288                 max_rx--;
 289
 290                 rx_skb = priv->rx_skb[rx];
 291                 pktlen = RX_DMA_PLEN0(priv->rx[rx].rxd2);
 292
 293                 new_skb = netdev_alloc_skb(dev, MAX_RX_LENGTH + NET_IP_ALIGN);
 294                 /* Reuse the buffer on allocation failures */
 295                 if (new_skb) {
 296                         dma_addr_t dma_addr;
 297
 298                         dma_unmap_single(&priv->netdev->dev, priv->rx_dma[rx],
 299                                          MAX_RX_LENGTH, DMA_FROM_DEVICE);
 300
 301                         skb_put(rx_skb, pktlen);
 302                         rx_skb->dev = dev;
 303                         rx_skb->protocol = eth_type_trans(rx_skb, dev);
 304                         rx_skb->ip_summed = CHECKSUM_NONE;
 305                         dev->stats.rx_packets++;
 306                         dev->stats.rx_bytes += pktlen;
 307                         netif_rx(rx_skb);
 308
 309                         priv->rx_skb[rx] = new_skb;
 310                         skb_reserve(new_skb, NET_IP_ALIGN);
 311
 312                         dma_addr = dma_map_single(&priv->netdev->dev,
 313                                                   new_skb->data,
 314                                                   MAX_RX_LENGTH,
 315                                                   DMA_FROM_DEVICE);
 316                         priv->rx_dma[rx] = dma_addr;
 317                         priv->rx[rx].rxd1 = (unsigned int) dma_addr;
 318                 } else {
 319                         dev->stats.rx_dropped++;
 320                 }
 321
 322                 priv->rx[rx].rxd2 &= ~RX_DMA_DONE;
 323                 wmb();
 324                 ramips_fe_wr(rx, RAMIPS_RX_CALC_IDX0);
 325         }
 326
 327         if (max_rx == 0)
 328                 tasklet_schedule(&priv->rx_tasklet);
 329         else
 330                 ramips_fe_int_enable(RAMIPS_RX_DLY_INT);
 331 }
 332
 333 static void
 334 ramips_eth_tx_housekeeping(unsigned long ptr)
 335 {
 336         struct net_device *dev = (struct net_device*)ptr;
 337         struct raeth_priv *priv = netdev_priv(dev);
 338
 339         spin_lock(&priv->page_lock);
 340         while ((priv->tx[priv->skb_free_idx].txd2 & TX_DMA_DONE) &&
 341                (priv->tx_skb[priv->skb_free_idx])) {
 342                 dev_kfree_skb_irq(priv->tx_skb[priv->skb_free_idx]);
 343                 priv->tx_skb[priv->skb_free_idx] = 0;
 344                 priv->skb_free_idx++;
 345                 if (priv->skb_free_idx >= NUM_TX_DESC)
 346                         priv->skb_free_idx = 0;
 347         }
 348         spin_unlock(&priv->page_lock);
 349
 350         ramips_fe_int_enable(RAMIPS_TX_DLY_INT);
 351 }
 352
 353 static void
 354 ramips_eth_timeout(struct net_device *dev)
 355 {
 356         struct raeth_priv *priv = netdev_priv(dev);
 357
 358         tasklet_schedule(&priv->tx_housekeeping_tasklet);
 359 }
 360
 361 static irqreturn_t
 362 ramips_eth_irq(int irq, void *dev)
 363 {
 364         struct raeth_priv *priv = netdev_priv(dev);
 365         unsigned long fe_int = ramips_fe_rr(RAMIPS_FE_INT_STATUS);
 366
 367         ramips_fe_wr(0xFFFFFFFF, RAMIPS_FE_INT_STATUS);
 368
 369         if (fe_int & RAMIPS_RX_DLY_INT) {
 370                 ramips_fe_int_disable(RAMIPS_RX_DLY_INT);
 371                 tasklet_schedule(&priv->rx_tasklet);
 372         }
 373
 374         if (fe_int & RAMIPS_TX_DLY_INT) {
 375                 ramips_fe_int_disable(RAMIPS_TX_DLY_INT);
 376                 tasklet_schedule(&priv->tx_housekeeping_tasklet);
 377         }
 378
 379         return IRQ_HANDLED;
 380 }
 381
 382 static int
 383 ramips_eth_open(struct net_device *dev)
 384 {
 385         struct raeth_priv *priv = netdev_priv(dev);
 386         int err;
 387
 388         err = request_irq(dev->irq, ramips_eth_irq, IRQF_DISABLED,
 389                           dev->name, dev);
 390         if (err)
 391                 return err;
 392
 393         err = ramips_alloc_dma(priv);
 394         if (err)
 395                 goto err_free_irq;
 396
 397         ramips_hw_set_macaddr(dev->dev_addr);
 398
 399         ramips_setup_dma(priv);
 400         ramips_fe_wr((ramips_fe_rr(RAMIPS_PDMA_GLO_CFG) & 0xff) |
 401                 (RAMIPS_TX_WB_DDONE | RAMIPS_RX_DMA_EN |
 402                 RAMIPS_TX_DMA_EN | RAMIPS_PDMA_SIZE_4DWORDS),
 403                 RAMIPS_PDMA_GLO_CFG);
 404         ramips_fe_wr((ramips_fe_rr(RAMIPS_FE_GLO_CFG) &
 405                 ~(RAMIPS_US_CYC_CNT_MASK << RAMIPS_US_CYC_CNT_SHIFT)) |
 406                 ((priv->plat->sys_freq / RAMIPS_US_CYC_CNT_DIVISOR) << RAMIPS_US_CYC_CNT_SHIFT),
 407                 RAMIPS_FE_GLO_CFG);
 408
 409         tasklet_init(&priv->tx_housekeeping_tasklet, ramips_eth_tx_housekeeping,
 410                      (unsigned long)dev);
 411         tasklet_init(&priv->rx_tasklet, ramips_eth_rx_hw, (unsigned long)dev);
 412
 413         ramips_setup_mdio_cfg(priv);
 414
 415         ramips_fe_wr(RAMIPS_DELAY_INIT, RAMIPS_DLY_INT_CFG);
 416         ramips_fe_wr(RAMIPS_TX_DLY_INT | RAMIPS_RX_DLY_INT, RAMIPS_FE_INT_ENABLE);
 417         ramips_fe_wr(ramips_fe_rr(RAMIPS_GDMA1_FWD_CFG) &
 418                 ~(RAMIPS_GDM1_ICS_EN | RAMIPS_GDM1_TCS_EN | RAMIPS_GDM1_UCS_EN | 0xffff),
 419                 RAMIPS_GDMA1_FWD_CFG);
 420         ramips_fe_wr(ramips_fe_rr(RAMIPS_CDMA_CSG_CFG) &
 421                 ~(RAMIPS_ICS_GEN_EN | RAMIPS_TCS_GEN_EN | RAMIPS_UCS_GEN_EN),
 422                 RAMIPS_CDMA_CSG_CFG);
 423         ramips_fe_wr(RAMIPS_PSE_FQFC_CFG_INIT, RAMIPS_PSE_FQ_CFG);
 424         ramips_fe_wr(1, RAMIPS_FE_RST_GL);
 425         ramips_fe_wr(0, RAMIPS_FE_RST_GL);
 426
 427         netif_start_queue(dev);
 428         return 0;
 429
 430  err_free_irq:
 431         free_irq(dev->irq, dev);
 432         return err;
 433 }
 434
 435 static int
 436 ramips_eth_stop(struct net_device *dev)
 437 {
 438         struct raeth_priv *priv = netdev_priv(dev);
 439
 440         ramips_fe_wr(ramips_fe_rr(RAMIPS_PDMA_GLO_CFG) &
 441                      ~(RAMIPS_TX_WB_DDONE | RAMIPS_RX_DMA_EN | RAMIPS_TX_DMA_EN),
 442                      RAMIPS_PDMA_GLO_CFG);
 443
 444         /* disable all interrupts in the hw */
 445         ramips_fe_wr(0, RAMIPS_FE_INT_ENABLE);
 446
 447         free_irq(dev->irq, dev);
 448         netif_stop_queue(dev);
 449         tasklet_kill(&priv->tx_housekeeping_tasklet);
 450         tasklet_kill(&priv->rx_tasklet);
 451         ramips_cleanup_dma(priv);
 452         RADEBUG("ramips_eth: stopped\n");
 453         return 0;
 454 }
 455
 456 static int __init
 457 ramips_eth_probe(struct net_device *dev)
 458 {
 459         struct raeth_priv *priv = netdev_priv(dev);
 460
 461         BUG_ON(!priv->plat->reset_fe);
 462         priv->plat->reset_fe();
 463         net_srandom(jiffies);
 464         memcpy(dev->dev_addr, priv->plat->mac, ETH_ALEN);
 465
 466         ether_setup(dev);
 467         dev->mtu = 1500;
 468         dev->watchdog_timeo = TX_TIMEOUT;
 469         spin_lock_init(&priv->page_lock);
 470
 471         return 0;
 472 }
 473
 474 static const struct net_device_ops ramips_eth_netdev_ops = {
 475         .ndo_init               = ramips_eth_probe,
 476         .ndo_open               = ramips_eth_open,
 477         .ndo_stop               = ramips_eth_stop,
 478         .ndo_start_xmit         = ramips_eth_hard_start_xmit,
 479         .ndo_tx_timeout         = ramips_eth_timeout,
 480         .ndo_change_mtu         = eth_change_mtu,
 481         .ndo_set_mac_address    = eth_mac_addr,
 482         .ndo_validate_addr      = eth_validate_addr,
 483 };
 484
 485 static int
 486 ramips_eth_plat_probe(struct platform_device *plat)
 487 {
 488         struct raeth_priv *priv;
 489         struct ramips_eth_platform_data *data = plat->dev.platform_data;
 490         struct resource *res;
 491         int err;
 492
 493         if (!data) {
 494                 dev_err(&plat->dev, "no platform data specified\n");
 495                 return -EINVAL;
 496         }
 497
 498         res = platform_get_resource(plat, IORESOURCE_MEM, 0);
 499         if (!res) {
 500                 dev_err(&plat->dev, "no memory resource found\n");
 501                 return -ENXIO;
 502         }
 503
 504         ramips_fe_base = ioremap_nocache(res->start, res->end - res->start + 1);
 505         if (!ramips_fe_base)
 506                 return -ENOMEM;
 507
 508         ramips_dev = alloc_etherdev(sizeof(struct raeth_priv));
 509         if (!ramips_dev) {
 510                 dev_err(&plat->dev, "alloc_etherdev failed\n");
 511                 err = -ENOMEM;
 512                 goto err_unmap;
 513         }
 514
 515         strcpy(ramips_dev->name, "eth%d");
 516         ramips_dev->irq = platform_get_irq(plat, 0);
 517         if (ramips_dev->irq < 0) {
 518                 dev_err(&plat->dev, "no IRQ resource found\n");
 519                 err = -ENXIO;
 520                 goto err_free_dev;
 521         }
 522         ramips_dev->addr_len = ETH_ALEN;
 523         ramips_dev->base_addr = (unsigned long)ramips_fe_base;
 524         ramips_dev->netdev_ops = &ramips_eth_netdev_ops;
 525
 526         priv = netdev_priv(ramips_dev);
 527
 528         priv->netdev = ramips_dev;
 529         priv->speed = data->speed;
 530         priv->duplex = data->duplex;
 531         priv->rx_fc = data->rx_fc;
 532         priv->tx_fc = data->tx_fc;
 533         priv->plat = data;
 534
 535         err = register_netdev(ramips_dev);
 536         if (err) {
 537                 dev_err(&plat->dev, "error bringing up device\n");
 538                 goto err_free_dev;
 539         }
 540
 541         RADEBUG("ramips_eth: loaded\n");
 542         return 0;
 543
 544  err_free_dev:
 545         kfree(ramips_dev);
 546  err_unmap:
 547         iounmap(ramips_fe_base);
 548         return err;
 549 }
 550
 551 static int
 552 ramips_eth_plat_remove(struct platform_device *plat)
 553 {
 554         unregister_netdev(ramips_dev);
 555         free_netdev(ramips_dev);
 556         RADEBUG("ramips_eth: unloaded\n");
 557         return 0;
 558 }
 559
 560 static struct platform_driver ramips_eth_driver = {
 561         .probe = ramips_eth_plat_probe,
 562         .remove = ramips_eth_plat_remove,
 563         .driver = {
 564                 .name = "ramips_eth",
 565                 .owner = THIS_MODULE,
 566         },
 567 };
 568
 569 static int __init
 570 ramips_eth_init(void)
 571 {
 572         int ret;
 573
 574         ret = rt305x_esw_init();
 575         if (ret)
 576                 return ret;
 577
 578         ret = platform_driver_register(&ramips_eth_driver);
 579         if (ret) {
 580                 printk(KERN_ERR
 581                        "ramips_eth: Error registering platfom driver!\n");
 582                 goto esw_cleanup;
 583         }
 584
 585         return 0;
 586
 587 esw_cleanup:
 588         rt305x_esw_exit();
 589         return ret;
 590 }
 591
 592 static void __exit
 593 ramips_eth_cleanup(void)
 594 {
 595         platform_driver_unregister(&ramips_eth_driver);
 596         rt305x_esw_exit();
 597 }
 598
 599 module_init(ramips_eth_init);
 600 module_exit(ramips_eth_cleanup);
 601
 602 MODULE_LICENSE("GPL");
 603 MODULE_AUTHOR("John Crispin <blogic@openwrt.org>");
 604 MODULE_DESCRIPTION("ethernet driver for ramips boards");