SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/sh_eth.c

   1 /*
   2  *  SuperH Ethernet device driver
   3  *
   4  *  Copyright (C) 2006-2008 Nobuhiro Iwamatsu
   5  *  Copyright (C) 2008-2009 Renesas Solutions Corp.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify it
   8  *  under the terms and conditions of the GNU General Public License,
   9  *  version 2, as published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope it will be useful, but WITHOUT
  12  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  *  more details.
  15  *  You should have received a copy of the GNU General Public License along with
  16  *  this program; if not, write to the Free Software Foundation, Inc.,
  17  *  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  *  The full GNU General Public License is included in this distribution in
  20  *  the file called "COPYING".
  21  */
  22
  23 #include <linux/init.h>
  24 #include <linux/dma-mapping.h>
  25 #include <linux/etherdevice.h>
  26 #include <linux/delay.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/mdio-bitbang.h>
  29 #include <linux/netdevice.h>
  30 #include <linux/phy.h>
  31 #include <linux/cache.h>
  32 #include <linux/io.h>
  33 #include <linux/pm_runtime.h>
  34 #include <asm/cacheflush.h>
  35
  36 #include "sh_eth.h"
  37
  38 /* There is CPU dependent code */
  39 #if defined(CONFIG_CPU_SUBTYPE_SH7724)
  40 #define SH_ETH_RESET_DEFAULT    1
  41 static void sh_eth_set_duplex(struct net_device *ndev)
  42 {
  43         struct sh_eth_private *mdp = netdev_priv(ndev);
  44         u32 ioaddr = ndev->base_addr;
  45
  46         if (mdp->duplex) /* Full */
  47                 ctrl_outl(ctrl_inl(ioaddr + ECMR) | ECMR_DM, ioaddr + ECMR);
  48         else            /* Half */
  49                 ctrl_outl(ctrl_inl(ioaddr + ECMR) & ~ECMR_DM, ioaddr + ECMR);
  50 }
  51
  52 static void sh_eth_set_rate(struct net_device *ndev)
  53 {
  54         struct sh_eth_private *mdp = netdev_priv(ndev);
  55         u32 ioaddr = ndev->base_addr;
  56
  57         switch (mdp->speed) {
  58         case 10: /* 10BASE */
  59                 ctrl_outl(ctrl_inl(ioaddr + ECMR) & ~ECMR_RTM, ioaddr + ECMR);
  60                 break;
  61         case 100:/* 100BASE */
  62                 ctrl_outl(ctrl_inl(ioaddr + ECMR) | ECMR_RTM, ioaddr + ECMR);
  63                 break;
  64         default:
  65                 break;
  66         }
  67 }
  68
  69 /* SH7724 */
  70 static struct sh_eth_cpu_data sh_eth_my_cpu_data = {
  71         .set_duplex     = sh_eth_set_duplex,
  72         .set_rate       = sh_eth_set_rate,
  73
  74         .ecsr_value     = ECSR_PSRTO | ECSR_LCHNG | ECSR_ICD,
  75         .ecsipr_value   = ECSIPR_PSRTOIP | ECSIPR_LCHNGIP | ECSIPR_ICDIP,
  76         .eesipr_value   = DMAC_M_RFRMER | DMAC_M_ECI | 0x01ff009f,
  77
  78         .tx_check       = EESR_FTC | EESR_CND | EESR_DLC | EESR_CD | EESR_RTO,
  79         .eesr_err_check = EESR_TWB | EESR_TABT | EESR_RABT | EESR_RDE |
  80                           EESR_RFRMER | EESR_TFE | EESR_TDE | EESR_ECI,
  81         .tx_error_check = EESR_TWB | EESR_TABT | EESR_TDE | EESR_TFE,
  82
  83         .apr            = 1,
  84         .mpr            = 1,
  85         .tpauser        = 1,
  86         .hw_swap        = 1,
  87         .rpadir         = 1,
  88         .rpadir_value   = 0x00020000, /* NET_IP_ALIGN assumed to be 2 */
  89 };
  90
  91 #elif defined(CONFIG_CPU_SUBTYPE_SH7763)
  92 #define SH_ETH_HAS_TSU  1
  93 static void sh_eth_chip_reset(struct net_device *ndev)
  94 {
  95         /* reset device */
  96         ctrl_outl(ARSTR_ARSTR, ARSTR);
  97         mdelay(1);
  98 }
  99
 100 static void sh_eth_reset(struct net_device *ndev)
 101 {
 102         u32 ioaddr = ndev->base_addr;
 103         int cnt = 100;
 104
 105         ctrl_outl(EDSR_ENALL, ioaddr + EDSR);
 106         ctrl_outl(ctrl_inl(ioaddr + EDMR) | EDMR_SRST, ioaddr + EDMR);
 107         while (cnt > 0) {
 108                 if (!(ctrl_inl(ioaddr + EDMR) & 0x3))
 109                         break;
 110                 mdelay(1);
 111                 cnt--;
 112         }
 113         if (cnt == 0)
 114                 printk(KERN_ERR "Device reset fail\n");
 115
 116         /* Table Init */
 117         ctrl_outl(0x0, ioaddr + TDLAR);
 118         ctrl_outl(0x0, ioaddr + TDFAR);
 119         ctrl_outl(0x0, ioaddr + TDFXR);
 120         ctrl_outl(0x0, ioaddr + TDFFR);
 121         ctrl_outl(0x0, ioaddr + RDLAR);
 122         ctrl_outl(0x0, ioaddr + RDFAR);
 123         ctrl_outl(0x0, ioaddr + RDFXR);
 124         ctrl_outl(0x0, ioaddr + RDFFR);
 125 }
 126
 127 static void sh_eth_set_duplex(struct net_device *ndev)
 128 {
 129         struct sh_eth_private *mdp = netdev_priv(ndev);
 130         u32 ioaddr = ndev->base_addr;
 131
 132         if (mdp->duplex) /* Full */
 133                 ctrl_outl(ctrl_inl(ioaddr + ECMR) | ECMR_DM, ioaddr + ECMR);
 134         else            /* Half */
 135                 ctrl_outl(ctrl_inl(ioaddr + ECMR) & ~ECMR_DM, ioaddr + ECMR);
 136 }
 137
 138 static void sh_eth_set_rate(struct net_device *ndev)
 139 {
 140         struct sh_eth_private *mdp = netdev_priv(ndev);
 141         u32 ioaddr = ndev->base_addr;
 142
 143         switch (mdp->speed) {
 144         case 10: /* 10BASE */
 145                 ctrl_outl(GECMR_10, ioaddr + GECMR);
 146                 break;
 147         case 100:/* 100BASE */
 148                 ctrl_outl(GECMR_100, ioaddr + GECMR);
 149                 break;
 150         case 1000: /* 1000BASE */
 151                 ctrl_outl(GECMR_1000, ioaddr + GECMR);
 152                 break;
 153         default:
 154                 break;
 155         }
 156 }
 157
 158 /* sh7763 */
 159 static struct sh_eth_cpu_data sh_eth_my_cpu_data = {
 160         .chip_reset     = sh_eth_chip_reset,
 161         .set_duplex     = sh_eth_set_duplex,
 162         .set_rate       = sh_eth_set_rate,
 163
 164         .ecsr_value     = ECSR_ICD | ECSR_MPD,
 165         .ecsipr_value   = ECSIPR_LCHNGIP | ECSIPR_ICDIP | ECSIPR_MPDIP,
 166         .eesipr_value   = DMAC_M_RFRMER | DMAC_M_ECI | 0x003fffff,
 167
 168         .tx_check       = EESR_TC1 | EESR_FTC,
 169         .eesr_err_check = EESR_TWB1 | EESR_TWB | EESR_TABT | EESR_RABT | \
 170                           EESR_RDE | EESR_RFRMER | EESR_TFE | EESR_TDE | \
 171                           EESR_ECI,
 172         .tx_error_check = EESR_TWB1 | EESR_TWB | EESR_TABT | EESR_TDE | \
 173                           EESR_TFE,
 174
 175         .apr            = 1,
 176         .mpr            = 1,
 177         .tpauser        = 1,
 178         .bculr          = 1,
 179         .hw_swap        = 1,
 180         .no_trimd       = 1,
 181         .no_ade         = 1,
 182 };
 183
 184 #elif defined(CONFIG_CPU_SUBTYPE_SH7619)
 185 #define SH_ETH_RESET_DEFAULT    1
 186 static struct sh_eth_cpu_data sh_eth_my_cpu_data = {
 187         .eesipr_value   = DMAC_M_RFRMER | DMAC_M_ECI | 0x003fffff,
 188
 189         .apr            = 1,
 190         .mpr            = 1,
 191         .tpauser        = 1,
 192         .hw_swap        = 1,
 193 };
 194 #elif defined(CONFIG_CPU_SUBTYPE_SH7710) || defined(CONFIG_CPU_SUBTYPE_SH7712)
 195 #define SH_ETH_RESET_DEFAULT    1
 196 #define SH_ETH_HAS_TSU  1
 197 static struct sh_eth_cpu_data sh_eth_my_cpu_data = {
 198         .eesipr_value   = DMAC_M_RFRMER | DMAC_M_ECI | 0x003fffff,
 199 };
 200 #endif
 201
 202 static void sh_eth_set_default_cpu_data(struct sh_eth_cpu_data *cd)
 203 {
 204         if (!cd->ecsr_value)
 205                 cd->ecsr_value = DEFAULT_ECSR_INIT;
 206
 207         if (!cd->ecsipr_value)
 208                 cd->ecsipr_value = DEFAULT_ECSIPR_INIT;
 209
 210         if (!cd->fcftr_value)
 211                 cd->fcftr_value = DEFAULT_FIFO_F_D_RFF | \
 212                                   DEFAULT_FIFO_F_D_RFD;
 213
 214         if (!cd->fdr_value)
 215                 cd->fdr_value = DEFAULT_FDR_INIT;
 216
 217         if (!cd->rmcr_value)
 218                 cd->rmcr_value = DEFAULT_RMCR_VALUE;
 219
 220         if (!cd->tx_check)
 221                 cd->tx_check = DEFAULT_TX_CHECK;
 222
 223         if (!cd->eesr_err_check)
 224                 cd->eesr_err_check = DEFAULT_EESR_ERR_CHECK;
 225
 226         if (!cd->tx_error_check)
 227                 cd->tx_error_check = DEFAULT_TX_ERROR_CHECK;
 228 }
 229
 230 #if defined(SH_ETH_RESET_DEFAULT)
 231 /* Chip Reset */
 232 static void sh_eth_reset(struct net_device *ndev)
 233 {
 234         u32 ioaddr = ndev->base_addr;
 235
 236         ctrl_outl(ctrl_inl(ioaddr + EDMR) | EDMR_SRST, ioaddr + EDMR);
 237         mdelay(3);
 238         ctrl_outl(ctrl_inl(ioaddr + EDMR) & ~EDMR_SRST, ioaddr + EDMR);
 239 }
 240 #endif
 241
 242 #if defined(CONFIG_CPU_SH4)
 243 static void sh_eth_set_receive_align(struct sk_buff *skb)
 244 {
 245         int reserve;
 246
 247         reserve = SH4_SKB_RX_ALIGN - ((u32)skb->data & (SH4_SKB_RX_ALIGN - 1));
 248         if (reserve)
 249                 skb_reserve(skb, reserve);
 250 }
 251 #else
 252 static void sh_eth_set_receive_align(struct sk_buff *skb)
 253 {
 254         skb_reserve(skb, SH2_SH3_SKB_RX_ALIGN);
 255 }
 256 #endif
 257
 258
 259 /* CPU <-> EDMAC endian convert */
 260 static inline __u32 cpu_to_edmac(struct sh_eth_private *mdp, u32 x)
 261 {
 262         switch (mdp->edmac_endian) {
 263         case EDMAC_LITTLE_ENDIAN:
 264                 return cpu_to_le32(x);
 265         case EDMAC_BIG_ENDIAN:
 266                 return cpu_to_be32(x);
 267         }
 268         return x;
 269 }
 270
 271 static inline __u32 edmac_to_cpu(struct sh_eth_private *mdp, u32 x)
 272 {
 273         switch (mdp->edmac_endian) {
 274         case EDMAC_LITTLE_ENDIAN:
 275                 return le32_to_cpu(x);
 276         case EDMAC_BIG_ENDIAN:
 277                 return be32_to_cpu(x);
 278         }
 279         return x;
 280 }
 281
 282 /*
 283  * Program the hardware MAC address from dev->dev_addr.
 284  */
 285 static void update_mac_address(struct net_device *ndev)
 286 {
 287         u32 ioaddr = ndev->base_addr;
 288
 289         ctrl_outl((ndev->dev_addr[0] << 24) | (ndev->dev_addr[1] << 16) |
 290                   (ndev->dev_addr[2] << 8) | (ndev->dev_addr[3]),
 291                   ioaddr + MAHR);
 292         ctrl_outl((ndev->dev_addr[4] << 8) | (ndev->dev_addr[5]),
 293                   ioaddr + MALR);
 294 }
 295
 296 /*
 297  * Get MAC address from SuperH MAC address register
 298  *
 299  * SuperH's Ethernet device doesn't have 'ROM' to MAC address.
 300  * This driver get MAC address that use by bootloader(U-boot or sh-ipl+g).
 301  * When you want use this device, you must set MAC address in bootloader.
 302  *
 303  */
 304 static void read_mac_address(struct net_device *ndev, unsigned char *mac)
 305 {
 306         u32 ioaddr = ndev->base_addr;
 307
 308         if (mac[0] || mac[1] || mac[2] || mac[3] || mac[4] || mac[5]) {
 309                 memcpy(ndev->dev_addr, mac, 6);
 310         } else {
 311                 ndev->dev_addr[0] = (ctrl_inl(ioaddr + MAHR) >> 24);
 312                 ndev->dev_addr[1] = (ctrl_inl(ioaddr + MAHR) >> 16) & 0xFF;
 313                 ndev->dev_addr[2] = (ctrl_inl(ioaddr + MAHR) >> 8) & 0xFF;
 314                 ndev->dev_addr[3] = (ctrl_inl(ioaddr + MAHR) & 0xFF);
 315                 ndev->dev_addr[4] = (ctrl_inl(ioaddr + MALR) >> 8) & 0xFF;
 316                 ndev->dev_addr[5] = (ctrl_inl(ioaddr + MALR) & 0xFF);
 317         }
 318 }
 319
 320 struct bb_info {
 321         struct mdiobb_ctrl ctrl;
 322         u32 addr;
 323         u32 mmd_msk;/* MMD */
 324         u32 mdo_msk;
 325         u32 mdi_msk;
 326         u32 mdc_msk;
 327 };
 328
 329 /* PHY bit set */
 330 static void bb_set(u32 addr, u32 msk)
 331 {
 332         ctrl_outl(ctrl_inl(addr) | msk, addr);
 333 }
 334
 335 /* PHY bit clear */
 336 static void bb_clr(u32 addr, u32 msk)
 337 {
 338         ctrl_outl((ctrl_inl(addr) & ~msk), addr);
 339 }
 340
 341 /* PHY bit read */
 342 static int bb_read(u32 addr, u32 msk)
 343 {
 344         return (ctrl_inl(addr) & msk) != 0;
 345 }
 346
 347 /* Data I/O pin control */
 348 static void sh_mmd_ctrl(struct mdiobb_ctrl *ctrl, int bit)
 349 {
 350         struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl);
 351         if (bit)
 352                 bb_set(bitbang->addr, bitbang->mmd_msk);
 353         else
 354                 bb_clr(bitbang->addr, bitbang->mmd_msk);
 355 }
 356
 357 /* Set bit data*/
 358 static void sh_set_mdio(struct mdiobb_ctrl *ctrl, int bit)
 359 {
 360         struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl);
 361
 362         if (bit)
 363                 bb_set(bitbang->addr, bitbang->mdo_msk);
 364         else
 365                 bb_clr(bitbang->addr, bitbang->mdo_msk);
 366 }
 367
 368 /* Get bit data*/
 369 static int sh_get_mdio(struct mdiobb_ctrl *ctrl)
 370 {
 371         struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl);
 372         return bb_read(bitbang->addr, bitbang->mdi_msk);
 373 }
 374
 375 /* MDC pin control */
 376 static void sh_mdc_ctrl(struct mdiobb_ctrl *ctrl, int bit)
 377 {
 378         struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl);
 379
 380         if (bit)
 381                 bb_set(bitbang->addr, bitbang->mdc_msk);
 382         else
 383                 bb_clr(bitbang->addr, bitbang->mdc_msk);
 384 }
 385
 386 /* mdio bus control struct */
 387 static struct mdiobb_ops bb_ops = {
 388         .owner = THIS_MODULE,
 389         .set_mdc = sh_mdc_ctrl,
 390         .set_mdio_dir = sh_mmd_ctrl,
 391         .set_mdio_data = sh_set_mdio,
 392         .get_mdio_data = sh_get_mdio,
 393 };
 394
 395 /* free skb and descriptor buffer */
 396 static void sh_eth_ring_free(struct net_device *ndev)
 397 {
 398         struct sh_eth_private *mdp = netdev_priv(ndev);
 399         int i;
 400
 401         /* Free Rx skb ringbuffer */
 402         if (mdp->rx_skbuff) {
 403                 for (i = 0; i < RX_RING_SIZE; i++) {
 404                         if (mdp->rx_skbuff[i])
 405                                 dev_kfree_skb(mdp->rx_skbuff[i]);
 406                 }
 407         }
 408         kfree(mdp->rx_skbuff);
 409
 410         /* Free Tx skb ringbuffer */
 411         if (mdp->tx_skbuff) {
 412                 for (i = 0; i < TX_RING_SIZE; i++) {
 413                         if (mdp->tx_skbuff[i])
 414                                 dev_kfree_skb(mdp->tx_skbuff[i]);
 415                 }
 416         }
 417         kfree(mdp->tx_skbuff);
 418 }
 419
 420 /* format skb and descriptor buffer */
 421 static void sh_eth_ring_format(struct net_device *ndev)
 422 {
 423         u32 ioaddr = ndev->base_addr;
 424         struct sh_eth_private *mdp = netdev_priv(ndev);
 425         int i;
 426         struct sk_buff *skb;
 427         struct sh_eth_rxdesc *rxdesc = NULL;
 428         struct sh_eth_txdesc *txdesc = NULL;
 429         int rx_ringsize = sizeof(*rxdesc) * RX_RING_SIZE;
 430         int tx_ringsize = sizeof(*txdesc) * TX_RING_SIZE;
 431
 432         mdp->cur_rx = mdp->cur_tx = 0;
 433         mdp->dirty_rx = mdp->dirty_tx = 0;
 434
 435         memset(mdp->rx_ring, 0, rx_ringsize);
 436
 437         /* build Rx ring buffer */
 438         for (i = 0; i < RX_RING_SIZE; i++) {
 439                 /* skb */
 440                 mdp->rx_skbuff[i] = NULL;
 441                 skb = dev_alloc_skb(mdp->rx_buf_sz);
 442                 mdp->rx_skbuff[i] = skb;
 443                 if (skb == NULL)
 444                         break;
 445                 dma_map_single(&ndev->dev, skb->tail, mdp->rx_buf_sz,
 446                                 DMA_FROM_DEVICE);
 447                 skb->dev = ndev; /* Mark as being used by this device. */
 448                 sh_eth_set_receive_align(skb);
 449
 450                 /* RX descriptor */
 451                 rxdesc = &mdp->rx_ring[i];
 452                 rxdesc->addr = virt_to_phys(PTR_ALIGN(skb->data, 4));
 453                 rxdesc->status = cpu_to_edmac(mdp, RD_RACT | RD_RFP);
 454
 455                 /* The size of the buffer is 16 byte boundary. */
 456                 rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
 457                 /* Rx descriptor address set */
 458                 if (i == 0) {
 459                         ctrl_outl(mdp->rx_desc_dma, ioaddr + RDLAR);
 460 #if defined(CONFIG_CPU_SUBTYPE_SH7763)
 461                         ctrl_outl(mdp->rx_desc_dma, ioaddr + RDFAR);
 462 #endif
 463                 }
 464         }
 465
 466         mdp->dirty_rx = (u32) (i - RX_RING_SIZE);
 467
 468         /* Mark the last entry as wrapping the ring. */
 469         rxdesc->status |= cpu_to_edmac(mdp, RD_RDEL);
 470
 471         memset(mdp->tx_ring, 0, tx_ringsize);
 472
 473         /* build Tx ring buffer */
 474         for (i = 0; i < TX_RING_SIZE; i++) {
 475                 mdp->tx_skbuff[i] = NULL;
 476                 txdesc = &mdp->tx_ring[i];
 477                 txdesc->status = cpu_to_edmac(mdp, TD_TFP);
 478                 txdesc->buffer_length = 0;
 479                 if (i == 0) {
 480                         /* Tx descriptor address set */
 481                         ctrl_outl(mdp->tx_desc_dma, ioaddr + TDLAR);
 482 #if defined(CONFIG_CPU_SUBTYPE_SH7763)
 483                         ctrl_outl(mdp->tx_desc_dma, ioaddr + TDFAR);
 484 #endif
 485                 }
 486         }
 487
 488         txdesc->status |= cpu_to_edmac(mdp, TD_TDLE);
 489 }
 490
 491 /* Get skb and descriptor buffer */
 492 static int sh_eth_ring_init(struct net_device *ndev)
 493 {
 494         struct sh_eth_private *mdp = netdev_priv(ndev);
 495         int rx_ringsize, tx_ringsize, ret = 0;
 496
 497         /*
 498          * +26 gets the maximum ethernet encapsulation, +7 & ~7 because the
 499          * card needs room to do 8 byte alignment, +2 so we can reserve
 500          * the first 2 bytes, and +16 gets room for the status word from the
 501          * card.
 502          */
 503         mdp->rx_buf_sz = (ndev->mtu <= 1492 ? PKT_BUF_SZ :
 504                           (((ndev->mtu + 26 + 7) & ~7) + 2 + 16));
 505         if (mdp->cd->rpadir)
 506                 mdp->rx_buf_sz += NET_IP_ALIGN;
 507
 508         /* Allocate RX and TX skb rings */
 509         mdp->rx_skbuff = kmalloc(sizeof(*mdp->rx_skbuff) * RX_RING_SIZE,
 510                                 GFP_KERNEL);
 511         if (!mdp->rx_skbuff) {
 512                 dev_err(&ndev->dev, "Cannot allocate Rx skb\n");
 513                 ret = -ENOMEM;
 514                 return ret;
 515         }
 516
 517         mdp->tx_skbuff = kmalloc(sizeof(*mdp->tx_skbuff) * TX_RING_SIZE,
 518                                 GFP_KERNEL);
 519         if (!mdp->tx_skbuff) {
 520                 dev_err(&ndev->dev, "Cannot allocate Tx skb\n");
 521                 ret = -ENOMEM;
 522                 goto skb_ring_free;
 523         }
 524
 525         /* Allocate all Rx descriptors. */
 526         rx_ringsize = sizeof(struct sh_eth_rxdesc) * RX_RING_SIZE;
 527         mdp->rx_ring = dma_alloc_coherent(NULL, rx_ringsize, &mdp->rx_desc_dma,
 528                         GFP_KERNEL);
 529
 530         if (!mdp->rx_ring) {
 531                 dev_err(&ndev->dev, "Cannot allocate Rx Ring (size %d bytes)\n",
 532                         rx_ringsize);
 533                 ret = -ENOMEM;
 534                 goto desc_ring_free;
 535         }
 536
 537         mdp->dirty_rx = 0;
 538
 539         /* Allocate all Tx descriptors. */
 540         tx_ringsize = sizeof(struct sh_eth_txdesc) * TX_RING_SIZE;
 541         mdp->tx_ring = dma_alloc_coherent(NULL, tx_ringsize, &mdp->tx_desc_dma,
 542                         GFP_KERNEL);
 543         if (!mdp->tx_ring) {
 544                 dev_err(&ndev->dev, "Cannot allocate Tx Ring (size %d bytes)\n",
 545                         tx_ringsize);
 546                 ret = -ENOMEM;
 547                 goto desc_ring_free;
 548         }
 549         return ret;
 550
 551 desc_ring_free:
 552         /* free DMA buffer */
 553         dma_free_coherent(NULL, rx_ringsize, mdp->rx_ring, mdp->rx_desc_dma);
 554
 555 skb_ring_free:
 556         /* Free Rx and Tx skb ring buffer */
 557         sh_eth_ring_free(ndev);
 558
 559         return ret;
 560 }
 561
 562 static int sh_eth_dev_init(struct net_device *ndev)
 563 {
 564         int ret = 0;
 565         struct sh_eth_private *mdp = netdev_priv(ndev);
 566         u32 ioaddr = ndev->base_addr;
 567         u_int32_t rx_int_var, tx_int_var;
 568         u32 val;
 569
 570         /* Soft Reset */
 571         sh_eth_reset(ndev);
 572
 573         /* Descriptor format */
 574         sh_eth_ring_format(ndev);
 575         if (mdp->cd->rpadir)
 576                 ctrl_outl(mdp->cd->rpadir_value, ioaddr + RPADIR);
 577
 578         /* all sh_eth int mask */
 579         ctrl_outl(0, ioaddr + EESIPR);
 580
 581 #if defined(__LITTLE_ENDIAN__)
 582         if (mdp->cd->hw_swap)
 583                 ctrl_outl(EDMR_EL, ioaddr + EDMR);
 584         else
 585 #endif
 586                 ctrl_outl(0, ioaddr + EDMR);
 587
 588         /* FIFO size set */
 589         ctrl_outl(mdp->cd->fdr_value, ioaddr + FDR);
 590         ctrl_outl(0, ioaddr + TFTR);
 591
 592         /* Frame recv control */
 593         ctrl_outl(mdp->cd->rmcr_value, ioaddr + RMCR);
 594
 595         rx_int_var = mdp->rx_int_var = DESC_I_RINT8 | DESC_I_RINT5;
 596         tx_int_var = mdp->tx_int_var = DESC_I_TINT2;
 597         ctrl_outl(rx_int_var | tx_int_var, ioaddr + TRSCER);
 598
 599         if (mdp->cd->bculr)
 600                 ctrl_outl(0x800, ioaddr + BCULR);       /* Burst sycle set */
 601
 602         ctrl_outl(mdp->cd->fcftr_value, ioaddr + FCFTR);
 603
 604         if (!mdp->cd->no_trimd)
 605                 ctrl_outl(0, ioaddr + TRIMD);
 606
 607         /* Recv frame limit set register */
 608         ctrl_outl(RFLR_VALUE, ioaddr + RFLR);
 609
 610         ctrl_outl(ctrl_inl(ioaddr + EESR), ioaddr + EESR);
 611         ctrl_outl(mdp->cd->eesipr_value, ioaddr + EESIPR);
 612
 613         /* PAUSE Prohibition */
 614         val = (ctrl_inl(ioaddr + ECMR) & ECMR_DM) |
 615                 ECMR_ZPF | (mdp->duplex ? ECMR_DM : 0) | ECMR_TE | ECMR_RE;
 616
 617         ctrl_outl(val, ioaddr + ECMR);
 618
 619         if (mdp->cd->set_rate)
 620                 mdp->cd->set_rate(ndev);
 621
 622         /* E-MAC Status Register clear */
 623         ctrl_outl(mdp->cd->ecsr_value, ioaddr + ECSR);
 624
 625         /* E-MAC Interrupt Enable register */
 626         ctrl_outl(mdp->cd->ecsipr_value, ioaddr + ECSIPR);
 627
 628         /* Set MAC address */
 629         update_mac_address(ndev);
 630
 631         /* mask reset */
 632         if (mdp->cd->apr)
 633                 ctrl_outl(APR_AP, ioaddr + APR);
 634         if (mdp->cd->mpr)
 635                 ctrl_outl(MPR_MP, ioaddr + MPR);
 636         if (mdp->cd->tpauser)
 637                 ctrl_outl(TPAUSER_UNLIMITED, ioaddr + TPAUSER);
 638
 639         /* Setting the Rx mode will start the Rx process. */
 640         ctrl_outl(EDRRR_R, ioaddr + EDRRR);
 641
 642         netif_start_queue(ndev);
 643
 644         return ret;
 645 }
 646
 647 /* free Tx skb function */
 648 static int sh_eth_txfree(struct net_device *ndev)
 649 {
 650         struct sh_eth_private *mdp = netdev_priv(ndev);
 651         struct sh_eth_txdesc *txdesc;
 652         int freeNum = 0;
 653         int entry = 0;
 654
 655         for (; mdp->cur_tx - mdp->dirty_tx > 0; mdp->dirty_tx++) {
 656                 entry = mdp->dirty_tx % TX_RING_SIZE;
 657                 txdesc = &mdp->tx_ring[entry];
 658                 if (txdesc->status & cpu_to_edmac(mdp, TD_TACT))
 659                         break;
 660                 /* Free the original skb. */
 661                 if (mdp->tx_skbuff[entry]) {
 662                         dev_kfree_skb_irq(mdp->tx_skbuff[entry]);
 663                         mdp->tx_skbuff[entry] = NULL;
 664                         freeNum++;
 665                 }
 666                 txdesc->status = cpu_to_edmac(mdp, TD_TFP);
 667                 if (entry >= TX_RING_SIZE - 1)
 668                         txdesc->status |= cpu_to_edmac(mdp, TD_TDLE);
 669
 670                 mdp->stats.tx_packets++;
 671                 mdp->stats.tx_bytes += txdesc->buffer_length;
 672         }
 673         return freeNum;
 674 }
 675
 676 /* Packet receive function */
 677 static int sh_eth_rx(struct net_device *ndev)
 678 {
 679         struct sh_eth_private *mdp = netdev_priv(ndev);
 680         struct sh_eth_rxdesc *rxdesc;
 681
 682         int entry = mdp->cur_rx % RX_RING_SIZE;
 683         int boguscnt = (mdp->dirty_rx + RX_RING_SIZE) - mdp->cur_rx;
 684         struct sk_buff *skb;
 685         u16 pkt_len = 0;
 686         u32 desc_status;
 687
 688         rxdesc = &mdp->rx_ring[entry];
 689         while (!(rxdesc->status & cpu_to_edmac(mdp, RD_RACT))) {
 690                 desc_status = edmac_to_cpu(mdp, rxdesc->status);
 691                 pkt_len = rxdesc->frame_length;
 692
 693                 if (--boguscnt < 0)
 694                         break;
 695
 696                 if (!(desc_status & RDFEND))
 697                         mdp->stats.rx_length_errors++;
 698
 699                 if (desc_status & (RD_RFS1 | RD_RFS2 | RD_RFS3 | RD_RFS4 |
 700                                    RD_RFS5 | RD_RFS6 | RD_RFS10)) {
 701                         mdp->stats.rx_errors++;
 702                         if (desc_status & RD_RFS1)
 703                                 mdp->stats.rx_crc_errors++;
 704                         if (desc_status & RD_RFS2)
 705                                 mdp->stats.rx_frame_errors++;
 706                         if (desc_status & RD_RFS3)
 707                                 mdp->stats.rx_length_errors++;
 708                         if (desc_status & RD_RFS4)
 709                                 mdp->stats.rx_length_errors++;
 710                         if (desc_status & RD_RFS6)
 711                                 mdp->stats.rx_missed_errors++;
 712                         if (desc_status & RD_RFS10)
 713                                 mdp->stats.rx_over_errors++;
 714                 } else {
 715                         if (!mdp->cd->hw_swap)
 716                                 sh_eth_soft_swap(
 717                                         phys_to_virt(ALIGN(rxdesc->addr, 4)),
 718                                         pkt_len + 2);
 719                         skb = mdp->rx_skbuff[entry];
 720                         mdp->rx_skbuff[entry] = NULL;
 721                         if (mdp->cd->rpadir)
 722                                 skb_reserve(skb, NET_IP_ALIGN);
 723                         skb_put(skb, pkt_len);
 724                         skb->protocol = eth_type_trans(skb, ndev);
 725                         netif_rx(skb);
 726                         mdp->stats.rx_packets++;
 727                         mdp->stats.rx_bytes += pkt_len;
 728                 }
 729                 rxdesc->status |= cpu_to_edmac(mdp, RD_RACT);
 730                 entry = (++mdp->cur_rx) % RX_RING_SIZE;
 731                 rxdesc = &mdp->rx_ring[entry];
 732         }
 733
 734         /* Refill the Rx ring buffers. */
 735         for (; mdp->cur_rx - mdp->dirty_rx > 0; mdp->dirty_rx++) {
 736                 entry = mdp->dirty_rx % RX_RING_SIZE;
 737                 rxdesc = &mdp->rx_ring[entry];
 738                 /* The size of the buffer is 16 byte boundary. */
 739                 rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
 740
 741                 if (mdp->rx_skbuff[entry] == NULL) {
 742                         skb = dev_alloc_skb(mdp->rx_buf_sz);
 743                         mdp->rx_skbuff[entry] = skb;
 744                         if (skb == NULL)
 745                                 break;  /* Better luck next round. */
 746                         dma_map_single(&ndev->dev, skb->tail, mdp->rx_buf_sz,
 747                                         DMA_FROM_DEVICE);
 748                         skb->dev = ndev;
 749                         sh_eth_set_receive_align(skb);
 750
 751                         skb->ip_summed = CHECKSUM_NONE;
 752                         rxdesc->addr = virt_to_phys(PTR_ALIGN(skb->data, 4));
 753                 }
 754                 if (entry >= RX_RING_SIZE - 1)
 755                         rxdesc->status |=
 756                                 cpu_to_edmac(mdp, RD_RACT | RD_RFP | RD_RDEL);
 757                 else
 758                         rxdesc->status |=
 759                                 cpu_to_edmac(mdp, RD_RACT | RD_RFP);
 760         }
 761
 762         /* Restart Rx engine if stopped. */
 763         /* If we don't need to check status, don't. -KDU */
 764         if (!(ctrl_inl(ndev->base_addr + EDRRR) & EDRRR_R))
 765                 ctrl_outl(EDRRR_R, ndev->base_addr + EDRRR);
 766
 767         return 0;
 768 }
 769
 770 /* error control function */
 771 static void sh_eth_error(struct net_device *ndev, int intr_status)
 772 {
 773         struct sh_eth_private *mdp = netdev_priv(ndev);
 774         u32 ioaddr = ndev->base_addr;
 775         u32 felic_stat;
 776         u32 link_stat;
 777         u32 mask;
 778
 779         if (intr_status & EESR_ECI) {
 780                 felic_stat = ctrl_inl(ioaddr + ECSR);
 781                 ctrl_outl(felic_stat, ioaddr + ECSR);   /* clear int */
 782                 if (felic_stat & ECSR_ICD)
 783                         mdp->stats.tx_carrier_errors++;
 784                 if (felic_stat & ECSR_LCHNG) {
 785                         /* Link Changed */
 786                         if (mdp->cd->no_psr || mdp->no_ether_link) {
 787                                 if (mdp->link == PHY_DOWN)
 788                                         link_stat = 0;
 789                                 else
 790                                         link_stat = PHY_ST_LINK;
 791                         } else {
 792                                 link_stat = (ctrl_inl(ioaddr + PSR));
 793                                 if (mdp->ether_link_active_low)
 794                                         link_stat = ~link_stat;
 795                         }
 796                         if (!(link_stat & PHY_ST_LINK)) {
 797                                 /* Link Down : disable tx and rx */
 798                                 ctrl_outl(ctrl_inl(ioaddr + ECMR) &
 799                                           ~(ECMR_RE | ECMR_TE), ioaddr + ECMR);
 800                         } else {
 801                                 /* Link Up */
 802                                 ctrl_outl(ctrl_inl(ioaddr + EESIPR) &
 803                                           ~DMAC_M_ECI, ioaddr + EESIPR);
 804                                 /*clear int */
 805                                 ctrl_outl(ctrl_inl(ioaddr + ECSR),
 806                                           ioaddr + ECSR);
 807                                 ctrl_outl(ctrl_inl(ioaddr + EESIPR) |
 808                                           DMAC_M_ECI, ioaddr + EESIPR);
 809                                 /* enable tx and rx */
 810                                 ctrl_outl(ctrl_inl(ioaddr + ECMR) |
 811                                           (ECMR_RE | ECMR_TE), ioaddr + ECMR);
 812                         }
 813                 }
 814         }
 815
 816         if (intr_status & EESR_TWB) {
 817                 /* Write buck end. unused write back interrupt */
 818                 if (intr_status & EESR_TABT)    /* Transmit Abort int */
 819                         mdp->stats.tx_aborted_errors++;
 820         }
 821
 822         if (intr_status & EESR_RABT) {
 823                 /* Receive Abort int */
 824                 if (intr_status & EESR_RFRMER) {
 825                         /* Receive Frame Overflow int */
 826                         mdp->stats.rx_frame_errors++;
 827                         dev_err(&ndev->dev, "Receive Frame Overflow\n");
 828                 }
 829         }
 830
 831         if (!mdp->cd->no_ade) {
 832                 if (intr_status & EESR_ADE && intr_status & EESR_TDE &&
 833                     intr_status & EESR_TFE)
 834                         mdp->stats.tx_fifo_errors++;
 835         }
 836
 837         if (intr_status & EESR_RDE) {
 838                 /* Receive Descriptor Empty int */
 839                 mdp->stats.rx_over_errors++;
 840
 841                 if (ctrl_inl(ioaddr + EDRRR) ^ EDRRR_R)
 842                         ctrl_outl(EDRRR_R, ioaddr + EDRRR);
 843                 dev_err(&ndev->dev, "Receive Descriptor Empty\n");
 844         }
 845         if (intr_status & EESR_RFE) {
 846                 /* Receive FIFO Overflow int */
 847                 mdp->stats.rx_fifo_errors++;
 848                 dev_err(&ndev->dev, "Receive FIFO Overflow\n");
 849         }
 850
 851         mask = EESR_TWB | EESR_TABT | EESR_ADE | EESR_TDE | EESR_TFE;
 852         if (mdp->cd->no_ade)
 853                 mask &= ~EESR_ADE;
 854         if (intr_status & mask) {
 855                 /* Tx error */
 856                 u32 edtrr = ctrl_inl(ndev->base_addr + EDTRR);
 857                 /* dmesg */
 858                 dev_err(&ndev->dev, "TX error. status=%8.8x cur_tx=%8.8x ",
 859                                 intr_status, mdp->cur_tx);
 860                 dev_err(&ndev->dev, "dirty_tx=%8.8x state=%8.8x EDTRR=%8.8x.\n",
 861                                 mdp->dirty_tx, (u32) ndev->state, edtrr);
 862                 /* dirty buffer free */
 863                 sh_eth_txfree(ndev);
 864
 865                 /* SH7712 BUG */
 866                 if (edtrr ^ EDTRR_TRNS) {
 867                         /* tx dma start */
 868                         ctrl_outl(EDTRR_TRNS, ndev->base_addr + EDTRR);
 869                 }
 870                 /* wakeup */
 871                 netif_wake_queue(ndev);
 872         }
 873 }
 874
 875 static irqreturn_t sh_eth_interrupt(int irq, void *netdev)
 876 {
 877         struct net_device *ndev = netdev;
 878         struct sh_eth_private *mdp = netdev_priv(ndev);
 879         struct sh_eth_cpu_data *cd = mdp->cd;
 880         irqreturn_t ret = IRQ_NONE;
 881         u32 ioaddr, intr_status = 0;
 882
 883         ioaddr = ndev->base_addr;
 884         spin_lock(&mdp->lock);
 885
 886         /* Get interrpt stat */
 887         intr_status = ctrl_inl(ioaddr + EESR);
 888         /* Clear interrupt */
 889         if (intr_status & (EESR_FRC | EESR_RMAF | EESR_RRF |
 890                         EESR_RTLF | EESR_RTSF | EESR_PRE | EESR_CERF |
 891                         cd->tx_check | cd->eesr_err_check)) {
 892                 ctrl_outl(intr_status, ioaddr + EESR);
 893                 ret = IRQ_HANDLED;
 894         } else
 895                 goto other_irq;
 896
 897         if (intr_status & (EESR_FRC | /* Frame recv*/
 898                         EESR_RMAF | /* Multi cast address recv*/
 899                         EESR_RRF  | /* Bit frame recv */
 900                         EESR_RTLF | /* Long frame recv*/
 901                         EESR_RTSF | /* short frame recv */
 902                         EESR_PRE  | /* PHY-LSI recv error */
 903                         EESR_CERF)){ /* recv frame CRC error */
 904                 sh_eth_rx(ndev);
 905         }
 906
 907         /* Tx Check */
 908         if (intr_status & cd->tx_check) {
 909                 sh_eth_txfree(ndev);
 910                 netif_wake_queue(ndev);
 911         }
 912
 913         if (intr_status & cd->eesr_err_check)
 914                 sh_eth_error(ndev, intr_status);
 915
 916 other_irq:
 917         spin_unlock(&mdp->lock);
 918
 919         return ret;
 920 }
 921
 922 static void sh_eth_timer(unsigned long data)
 923 {
 924         struct net_device *ndev = (struct net_device *)data;
 925         struct sh_eth_private *mdp = netdev_priv(ndev);
 926
 927         mod_timer(&mdp->timer, jiffies + (10 * HZ));
 928 }
 929
 930 /* PHY state control function */
 931 static void sh_eth_adjust_link(struct net_device *ndev)
 932 {
 933         struct sh_eth_private *mdp = netdev_priv(ndev);
 934         struct phy_device *phydev = mdp->phydev;
 935         u32 ioaddr = ndev->base_addr;
 936         int new_state = 0;
 937
 938         if (phydev->link != PHY_DOWN) {
 939                 if (phydev->duplex != mdp->duplex) {
 940                         new_state = 1;
 941                         mdp->duplex = phydev->duplex;
 942                         if (mdp->cd->set_duplex)
 943                                 mdp->cd->set_duplex(ndev);
 944                 }
 945
 946                 if (phydev->speed != mdp->speed) {
 947                         new_state = 1;
 948                         mdp->speed = phydev->speed;
 949                         if (mdp->cd->set_rate)
 950                                 mdp->cd->set_rate(ndev);
 951                 }
 952                 if (mdp->link == PHY_DOWN) {
 953                         ctrl_outl((ctrl_inl(ioaddr + ECMR) & ~ECMR_TXF)
 954                                         | ECMR_DM, ioaddr + ECMR);
 955                         new_state = 1;
 956                         mdp->link = phydev->link;
 957                 }
 958         } else if (mdp->link) {
 959                 new_state = 1;
 960                 mdp->link = PHY_DOWN;
 961                 mdp->speed = 0;
 962                 mdp->duplex = -1;
 963         }
 964
 965         if (new_state)
 966                 phy_print_status(phydev);
 967 }
 968
 969 /* PHY init function */
 970 static int sh_eth_phy_init(struct net_device *ndev)
 971 {
 972         struct sh_eth_private *mdp = netdev_priv(ndev);
 973         char phy_id[MII_BUS_ID_SIZE + 3];
 974         struct phy_device *phydev = NULL;
 975
 976         snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT,
 977                 mdp->mii_bus->id , mdp->phy_id);
 978
 979         mdp->link = PHY_DOWN;
 980         mdp->speed = 0;
 981         mdp->duplex = -1;
 982
 983         /* Try connect to PHY */
 984         phydev = phy_connect(ndev, phy_id, &sh_eth_adjust_link,
 985                                 0, PHY_INTERFACE_MODE_MII);
 986         if (IS_ERR(phydev)) {
 987                 dev_err(&ndev->dev, "phy_connect failed\n");
 988                 return PTR_ERR(phydev);
 989         }
 990
 991         dev_info(&ndev->dev, "attached phy %i to driver %s\n",
 992                 phydev->addr, phydev->drv->name);
 993
 994         mdp->phydev = phydev;
 995
 996         return 0;
 997 }
 998
 999 /* PHY control start function */
1000 static int sh_eth_phy_start(struct net_device *ndev)
1001 {
1002         struct sh_eth_private *mdp = netdev_priv(ndev);
1003         int ret;
1004
1005         ret = sh_eth_phy_init(ndev);
1006         if (ret)
1007                 return ret;
1008
1009         /* reset phy - this also wakes it from PDOWN */
1010         phy_write(mdp->phydev, MII_BMCR, BMCR_RESET);
1011         phy_start(mdp->phydev);
1012
1013         return 0;
1014 }
1015
1016 /* network device open function */
1017 static int sh_eth_open(struct net_device *ndev)
1018 {
1019         int ret = 0;
1020         struct sh_eth_private *mdp = netdev_priv(ndev);
1021
1022         pm_runtime_get_sync(&mdp->pdev->dev);
1023
1024         ret = request_irq(ndev->irq, sh_eth_interrupt,
1025 #if defined(CONFIG_CPU_SUBTYPE_SH7763) || defined(CONFIG_CPU_SUBTYPE_SH7764)
1026                                 IRQF_SHARED,
1027 #else
1028                                 0,
1029 #endif
1030                                 ndev->name, ndev);
1031         if (ret) {
1032                 dev_err(&ndev->dev, "Can not assign IRQ number\n");
1033                 return ret;
1034         }
1035
1036         /* Descriptor set */
1037         ret = sh_eth_ring_init(ndev);
1038         if (ret)
1039                 goto out_free_irq;
1040
1041         /* device init */
1042         ret = sh_eth_dev_init(ndev);
1043         if (ret)
1044                 goto out_free_irq;
1045
1046         /* PHY control start*/
1047         ret = sh_eth_phy_start(ndev);
1048         if (ret)
1049                 goto out_free_irq;
1050
1051         /* Set the timer to check for link beat. */
1052         init_timer(&mdp->timer);
1053         mdp->timer.expires = (jiffies + (24 * HZ)) / 10;/* 2.4 sec. */
1054         setup_timer(&mdp->timer, sh_eth_timer, (unsigned long)ndev);
1055
1056         return ret;
1057
1058 out_free_irq:
1059         free_irq(ndev->irq, ndev);
1060         pm_runtime_put_sync(&mdp->pdev->dev);
1061         return ret;
1062 }
1063
1064 /* Timeout function */
1065 static void sh_eth_tx_timeout(struct net_device *ndev)
1066 {
1067         struct sh_eth_private *mdp = netdev_priv(ndev);
1068         u32 ioaddr = ndev->base_addr;
1069         struct sh_eth_rxdesc *rxdesc;
1070         int i;
1071
1072         netif_stop_queue(ndev);
1073
1074         /* worning message out. */
1075         printk(KERN_WARNING "%s: transmit timed out, status %8.8x,"
1076                " resetting...\n", ndev->name, (int)ctrl_inl(ioaddr + EESR));
1077
1078         /* tx_errors count up */
1079         mdp->stats.tx_errors++;
1080
1081         /* timer off */
1082         del_timer_sync(&mdp->timer);
1083
1084         /* Free all the skbuffs in the Rx queue. */
1085         for (i = 0; i < RX_RING_SIZE; i++) {
1086                 rxdesc = &mdp->rx_ring[i];
1087                 rxdesc->status = 0;
1088                 rxdesc->addr = 0xBADF00D0;
1089                 if (mdp->rx_skbuff[i])
1090                         dev_kfree_skb(mdp->rx_skbuff[i]);
1091                 mdp->rx_skbuff[i] = NULL;
1092         }
1093         for (i = 0; i < TX_RING_SIZE; i++) {
1094                 if (mdp->tx_skbuff[i])
1095                         dev_kfree_skb(mdp->tx_skbuff[i]);
1096                 mdp->tx_skbuff[i] = NULL;
1097         }
1098
1099         /* device init */
1100         sh_eth_dev_init(ndev);
1101
1102         /* timer on */
1103         mdp->timer.expires = (jiffies + (24 * HZ)) / 10;/* 2.4 sec. */
1104         add_timer(&mdp->timer);
1105 }
1106
1107 /* Packet transmit function */
1108 static int sh_eth_start_xmit(struct sk_buff *skb, struct net_device *ndev)
1109 {
1110         struct sh_eth_private *mdp = netdev_priv(ndev);
1111         struct sh_eth_txdesc *txdesc;
1112         u32 entry;
1113         unsigned long flags;
1114
1115         spin_lock_irqsave(&mdp->lock, flags);
1116         if ((mdp->cur_tx - mdp->dirty_tx) >= (TX_RING_SIZE - 4)) {
1117                 if (!sh_eth_txfree(ndev)) {
1118                         netif_stop_queue(ndev);
1119                         spin_unlock_irqrestore(&mdp->lock, flags);
1120                         return NETDEV_TX_BUSY;
1121                 }
1122         }
1123         spin_unlock_irqrestore(&mdp->lock, flags);
1124
1125         entry = mdp->cur_tx % TX_RING_SIZE;
1126         mdp->tx_skbuff[entry] = skb;
1127         txdesc = &mdp->tx_ring[entry];
1128         txdesc->addr = virt_to_phys(skb->data);
1129         /* soft swap. */
1130         if (!mdp->cd->hw_swap)
1131                 sh_eth_soft_swap(phys_to_virt(ALIGN(txdesc->addr, 4)),
1132                                  skb->len + 2);
1133         /* write back */
1134         __flush_purge_region(skb->data, skb->len);
1135         if (skb->len < ETHERSMALL)
1136                 txdesc->buffer_length = ETHERSMALL;
1137         else
1138                 txdesc->buffer_length = skb->len;
1139
1140         if (entry >= TX_RING_SIZE - 1)
1141                 txdesc->status |= cpu_to_edmac(mdp, TD_TACT | TD_TDLE);
1142         else
1143                 txdesc->status |= cpu_to_edmac(mdp, TD_TACT);
1144
1145         mdp->cur_tx++;
1146
1147         if (!(ctrl_inl(ndev->base_addr + EDTRR) & EDTRR_TRNS))
1148                 ctrl_outl(EDTRR_TRNS, ndev->base_addr + EDTRR);
1149
1150         ndev->trans_start = jiffies;
1151
1152         return NETDEV_TX_OK;
1153 }
1154
1155 /* device close function */
1156 static int sh_eth_close(struct net_device *ndev)
1157 {
1158         struct sh_eth_private *mdp = netdev_priv(ndev);
1159         u32 ioaddr = ndev->base_addr;
1160         int ringsize;
1161
1162         netif_stop_queue(ndev);
1163
1164         /* Disable interrupts by clearing the interrupt mask. */
1165         ctrl_outl(0x0000, ioaddr + EESIPR);
1166
1167         /* Stop the chip's Tx and Rx processes. */
1168         ctrl_outl(0, ioaddr + EDTRR);
1169         ctrl_outl(0, ioaddr + EDRRR);
1170
1171         /* PHY Disconnect */
1172         if (mdp->phydev) {
1173                 phy_stop(mdp->phydev);
1174                 phy_disconnect(mdp->phydev);
1175         }
1176
1177         free_irq(ndev->irq, ndev);
1178
1179         del_timer_sync(&mdp->timer);
1180
1181         /* Free all the skbuffs in the Rx queue. */
1182         sh_eth_ring_free(ndev);
1183
1184         /* free DMA buffer */
1185         ringsize = sizeof(struct sh_eth_rxdesc) * RX_RING_SIZE;
1186         dma_free_coherent(NULL, ringsize, mdp->rx_ring, mdp->rx_desc_dma);
1187
1188         /* free DMA buffer */
1189         ringsize = sizeof(struct sh_eth_txdesc) * TX_RING_SIZE;
1190         dma_free_coherent(NULL, ringsize, mdp->tx_ring, mdp->tx_desc_dma);
1191
1192         pm_runtime_put_sync(&mdp->pdev->dev);
1193
1194         return 0;
1195 }
1196
1197 static struct net_device_stats *sh_eth_get_stats(struct net_device *ndev)
1198 {
1199         struct sh_eth_private *mdp = netdev_priv(ndev);
1200         u32 ioaddr = ndev->base_addr;
1201
1202         pm_runtime_get_sync(&mdp->pdev->dev);
1203
1204         mdp->stats.tx_dropped += ctrl_inl(ioaddr + TROCR);
1205         ctrl_outl(0, ioaddr + TROCR);   /* (write clear) */
1206         mdp->stats.collisions += ctrl_inl(ioaddr + CDCR);
1207         ctrl_outl(0, ioaddr + CDCR);    /* (write clear) */
1208         mdp->stats.tx_carrier_errors += ctrl_inl(ioaddr + LCCR);
1209         ctrl_outl(0, ioaddr + LCCR);    /* (write clear) */
1210 #if defined(CONFIG_CPU_SUBTYPE_SH7763)
1211         mdp->stats.tx_carrier_errors += ctrl_inl(ioaddr + CERCR);/* CERCR */
1212         ctrl_outl(0, ioaddr + CERCR);   /* (write clear) */
1213         mdp->stats.tx_carrier_errors += ctrl_inl(ioaddr + CEECR);/* CEECR */
1214         ctrl_outl(0, ioaddr + CEECR);   /* (write clear) */
1215 #else
1216         mdp->stats.tx_carrier_errors += ctrl_inl(ioaddr + CNDCR);
1217         ctrl_outl(0, ioaddr + CNDCR);   /* (write clear) */
1218 #endif
1219         pm_runtime_put_sync(&mdp->pdev->dev);
1220
1221         return &mdp->stats;
1222 }
1223
1224 /* ioctl to device funciotn*/
1225 static int sh_eth_do_ioctl(struct net_device *ndev, struct ifreq *rq,
1226                                 int cmd)
1227 {
1228         struct sh_eth_private *mdp = netdev_priv(ndev);
1229         struct phy_device *phydev = mdp->phydev;
1230
1231         if (!netif_running(ndev))
1232                 return -EINVAL;
1233
1234         if (!phydev)
1235                 return -ENODEV;
1236
1237         return phy_mii_ioctl(phydev, if_mii(rq), cmd);
1238 }
1239
1240 #if defined(SH_ETH_HAS_TSU)
1241 /* Multicast reception directions set */
1242 static void sh_eth_set_multicast_list(struct net_device *ndev)
1243 {
1244         u32 ioaddr = ndev->base_addr;
1245
1246         if (ndev->flags & IFF_PROMISC) {
1247                 /* Set promiscuous. */
1248                 ctrl_outl((ctrl_inl(ioaddr + ECMR) & ~ECMR_MCT) | ECMR_PRM,
1249                           ioaddr + ECMR);
1250         } else {
1251                 /* Normal, unicast/broadcast-only mode. */
1252                 ctrl_outl((ctrl_inl(ioaddr + ECMR) & ~ECMR_PRM) | ECMR_MCT,
1253                           ioaddr + ECMR);
1254         }
1255 }
1256
1257 /* SuperH's TSU register init function */
1258 static void sh_eth_tsu_init(u32 ioaddr)
1259 {
1260         ctrl_outl(0, ioaddr + TSU_FWEN0);       /* Disable forward(0->1) */
1261         ctrl_outl(0, ioaddr + TSU_FWEN1);       /* Disable forward(1->0) */
1262         ctrl_outl(0, ioaddr + TSU_FCM); /* forward fifo 3k-3k */
1263         ctrl_outl(0xc, ioaddr + TSU_BSYSL0);
1264         ctrl_outl(0xc, ioaddr + TSU_BSYSL1);
1265         ctrl_outl(0, ioaddr + TSU_PRISL0);
1266         ctrl_outl(0, ioaddr + TSU_PRISL1);
1267         ctrl_outl(0, ioaddr + TSU_FWSL0);
1268         ctrl_outl(0, ioaddr + TSU_FWSL1);
1269         ctrl_outl(TSU_FWSLC_POSTENU | TSU_FWSLC_POSTENL, ioaddr + TSU_FWSLC);
1270 #if defined(CONFIG_CPU_SUBTYPE_SH7763)
1271         ctrl_outl(0, ioaddr + TSU_QTAG0);       /* Disable QTAG(0->1) */
1272         ctrl_outl(0, ioaddr + TSU_QTAG1);       /* Disable QTAG(1->0) */
1273 #else
1274         ctrl_outl(0, ioaddr + TSU_QTAGM0);      /* Disable QTAG(0->1) */
1275         ctrl_outl(0, ioaddr + TSU_QTAGM1);      /* Disable QTAG(1->0) */
1276 #endif
1277         ctrl_outl(0, ioaddr + TSU_FWSR);        /* all interrupt status clear */
1278         ctrl_outl(0, ioaddr + TSU_FWINMK);      /* Disable all interrupt */
1279         ctrl_outl(0, ioaddr + TSU_TEN); /* Disable all CAM entry */
1280         ctrl_outl(0, ioaddr + TSU_POST1);       /* Disable CAM entry [ 0- 7] */
1281         ctrl_outl(0, ioaddr + TSU_POST2);       /* Disable CAM entry [ 8-15] */
1282         ctrl_outl(0, ioaddr + TSU_POST3);       /* Disable CAM entry [16-23] */
1283         ctrl_outl(0, ioaddr + TSU_POST4);       /* Disable CAM entry [24-31] */
1284 }
1285 #endif /* SH_ETH_HAS_TSU */
1286
1287 /* MDIO bus release function */
1288 static int sh_mdio_release(struct net_device *ndev)
1289 {
1290         struct mii_bus *bus = dev_get_drvdata(&ndev->dev);
1291
1292         /* unregister mdio bus */
1293         mdiobus_unregister(bus);
1294
1295         /* remove mdio bus info from net_device */
1296         dev_set_drvdata(&ndev->dev, NULL);
1297
1298         /* free bitbang info */
1299         free_mdio_bitbang(bus);
1300
1301         return 0;
1302 }
1303
1304 /* MDIO bus init function */
1305 static int sh_mdio_init(struct net_device *ndev, int id)
1306 {
1307         int ret, i;
1308         struct bb_info *bitbang;
1309         struct sh_eth_private *mdp = netdev_priv(ndev);
1310
1311         /* create bit control struct for PHY */
1312         bitbang = kzalloc(sizeof(struct bb_info), GFP_KERNEL);
1313         if (!bitbang) {
1314                 ret = -ENOMEM;
1315                 goto out;
1316         }
1317
1318         /* bitbang init */
1319         bitbang->addr = ndev->base_addr + PIR;
1320         bitbang->mdi_msk = 0x08;
1321         bitbang->mdo_msk = 0x04;
1322         bitbang->mmd_msk = 0x02;/* MMD */
1323         bitbang->mdc_msk = 0x01;
1324         bitbang->ctrl.ops = &bb_ops;
1325
1326         /* MII contorller setting */
1327         mdp->mii_bus = alloc_mdio_bitbang(&bitbang->ctrl);
1328         if (!mdp->mii_bus) {
1329                 ret = -ENOMEM;
1330                 goto out_free_bitbang;
1331         }
1332
1333         /* Hook up MII support for ethtool */
1334         mdp->mii_bus->name = "sh_mii";
1335         mdp->mii_bus->parent = &ndev->dev;
1336         snprintf(mdp->mii_bus->id, MII_BUS_ID_SIZE, "%x", id);
1337
1338         /* PHY IRQ */
1339         mdp->mii_bus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL);
1340         if (!mdp->mii_bus->irq) {
1341                 ret = -ENOMEM;
1342                 goto out_free_bus;
1343         }
1344
1345         for (i = 0; i < PHY_MAX_ADDR; i++)
1346                 mdp->mii_bus->irq[i] = PHY_POLL;
1347
1348         /* regist mdio bus */
1349         ret = mdiobus_register(mdp->mii_bus);
1350         if (ret)
1351                 goto out_free_irq;
1352
1353         dev_set_drvdata(&ndev->dev, mdp->mii_bus);
1354
1355         return 0;
1356
1357 out_free_irq:
1358         kfree(mdp->mii_bus->irq);
1359
1360 out_free_bus:
1361         free_mdio_bitbang(mdp->mii_bus);
1362
1363 out_free_bitbang:
1364         kfree(bitbang);
1365
1366 out:
1367         return ret;
1368 }
1369
1370 static const struct net_device_ops sh_eth_netdev_ops = {
1371         .ndo_open               = sh_eth_open,
1372         .ndo_stop               = sh_eth_close,
1373         .ndo_start_xmit         = sh_eth_start_xmit,
1374         .ndo_get_stats          = sh_eth_get_stats,
1375 #if defined(SH_ETH_HAS_TSU)
1376         .ndo_set_multicast_list = sh_eth_set_multicast_list,
1377 #endif
1378         .ndo_tx_timeout         = sh_eth_tx_timeout,
1379         .ndo_do_ioctl           = sh_eth_do_ioctl,
1380         .ndo_validate_addr      = eth_validate_addr,
1381         .ndo_set_mac_address    = eth_mac_addr,
1382         .ndo_change_mtu         = eth_change_mtu,
1383 };
1384
1385 static int sh_eth_drv_probe(struct platform_device *pdev)
1386 {
1387         int ret, i, devno = 0;
1388         struct resource *res;
1389         struct net_device *ndev = NULL;
1390         struct sh_eth_private *mdp;
1391         struct sh_eth_plat_data *pd;
1392
1393         /* get base addr */
1394         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1395         if (unlikely(res == NULL)) {
1396                 dev_err(&pdev->dev, "invalid resource\n");
1397                 ret = -EINVAL;
1398                 goto out;
1399         }
1400
1401         ndev = alloc_etherdev(sizeof(struct sh_eth_private));
1402         if (!ndev) {
1403                 dev_err(&pdev->dev, "Could not allocate device.\n");
1404                 ret = -ENOMEM;
1405                 goto out;
1406         }
1407
1408         /* The sh Ether-specific entries in the device structure. */
1409         ndev->base_addr = res->start;
1410         devno = pdev->id;
1411         if (devno < 0)
1412                 devno = 0;
1413
1414         ndev->dma = -1;
1415         ret = platform_get_irq(pdev, 0);
1416         if (ret < 0) {
1417                 ret = -ENODEV;
1418                 goto out_release;
1419         }
1420         ndev->irq = ret;
1421
1422         SET_NETDEV_DEV(ndev, &pdev->dev);
1423
1424         /* Fill in the fields of the device structure with ethernet values. */
1425         ether_setup(ndev);
1426
1427         mdp = netdev_priv(ndev);
1428         spin_lock_init(&mdp->lock);
1429         mdp->pdev = pdev;
1430         pm_runtime_enable(&pdev->dev);
1431         pm_runtime_resume(&pdev->dev);
1432
1433         pd = (struct sh_eth_plat_data *)(pdev->dev.platform_data);
1434         /* get PHY ID */
1435         mdp->phy_id = pd->phy;
1436         /* EDMAC endian */
1437         mdp->edmac_endian = pd->edmac_endian;
1438         mdp->no_ether_link = pd->no_ether_link;
1439         mdp->ether_link_active_low = pd->ether_link_active_low;
1440
1441         /* set cpu data */
1442         mdp->cd = &sh_eth_my_cpu_data;
1443         sh_eth_set_default_cpu_data(mdp->cd);
1444
1445         /* set function */
1446         ndev->netdev_ops = &sh_eth_netdev_ops;
1447         ndev->watchdog_timeo = TX_TIMEOUT;
1448
1449         mdp->post_rx = POST_RX >> (devno << 1);
1450         mdp->post_fw = POST_FW >> (devno << 1);
1451
1452         /* read and set MAC address */
1453         read_mac_address(ndev, pd->mac_addr);
1454
1455         /* First device only init */
1456         if (!devno) {
1457                 if (mdp->cd->chip_reset)
1458                         mdp->cd->chip_reset(ndev);
1459
1460 #if defined(SH_ETH_HAS_TSU)
1461                 /* TSU init (Init only)*/
1462                 sh_eth_tsu_init(SH_TSU_ADDR);
1463 #endif
1464         }
1465
1466         /* network device register */
1467         ret = register_netdev(ndev);
1468         if (ret)
1469                 goto out_release;
1470
1471         /* mdio bus init */
1472         ret = sh_mdio_init(ndev, pdev->id);
1473         if (ret)
1474                 goto out_unregister;
1475
1476         /* pritnt device infomation */
1477         pr_info("Base address at 0x%x, ",
1478                (u32)ndev->base_addr);
1479
1480         for (i = 0; i < 5; i++)
1481                 printk("%02X:", ndev->dev_addr[i]);
1482         printk("%02X, IRQ %d.\n", ndev->dev_addr[i], ndev->irq);
1483
1484         platform_set_drvdata(pdev, ndev);
1485
1486         return ret;
1487
1488 out_unregister:
1489         unregister_netdev(ndev);
1490
1491 out_release:
1492         /* net_dev free */
1493         if (ndev)
1494                 free_netdev(ndev);
1495
1496 out:
1497         return ret;
1498 }
1499
1500 static int sh_eth_drv_remove(struct platform_device *pdev)
1501 {
1502         struct net_device *ndev = platform_get_drvdata(pdev);
1503
1504         sh_mdio_release(ndev);
1505         unregister_netdev(ndev);
1506         flush_scheduled_work();
1507         pm_runtime_disable(&pdev->dev);
1508         free_netdev(ndev);
1509         platform_set_drvdata(pdev, NULL);
1510
1511         return 0;
1512 }
1513
1514 static int sh_eth_runtime_nop(struct device *dev)
1515 {
1516         /*
1517          * Runtime PM callback shared between ->runtime_suspend()
1518          * and ->runtime_resume(). Simply returns success.
1519          *
1520          * This driver re-initializes all registers after
1521          * pm_runtime_get_sync() anyway so there is no need
1522          * to save and restore registers here.
1523          */
1524         return 0;
1525 }
1526
1527 static struct dev_pm_ops sh_eth_dev_pm_ops = {
1528         .runtime_suspend = sh_eth_runtime_nop,
1529         .runtime_resume = sh_eth_runtime_nop,
1530 };
1531
1532 static struct platform_driver sh_eth_driver = {
1533         .probe = sh_eth_drv_probe,
1534         .remove = sh_eth_drv_remove,
1535         .driver = {
1536                    .name = CARDNAME,
1537                    .pm = &sh_eth_dev_pm_ops,
1538         },
1539 };
1540
1541 static int __init sh_eth_init(void)
1542 {
1543         return platform_driver_register(&sh_eth_driver);
1544 }
1545
1546 static void __exit sh_eth_cleanup(void)
1547 {
1548         platform_driver_unregister(&sh_eth_driver);
1549 }
1550
1551 module_init(sh_eth_init);
1552 module_exit(sh_eth_cleanup);
1553
1554 MODULE_AUTHOR("Nobuhiro Iwamatsu, Yoshihiro Shimoda");
1555 MODULE_DESCRIPTION("Renesas SuperH Ethernet driver");
1556 MODULE_LICENSE("GPL v2");