drivers/net/ethernet/freescale/fs_enet/mac-fec.c

   1 /*
   2  * Freescale Ethernet controllers
   3  *
   4  * Copyright (c) 2005 Intracom S.A.
   5  *  by Pantelis Antoniou <panto@intracom.gr>
   6  *
   7  * 2005 (c) MontaVista Software, Inc.
   8  * Vitaly Bordug <vbordug@ru.mvista.com>
   9  *
  10  * This file is licensed under the terms of the GNU General Public License
  11  * version 2. This program is licensed "as is" without any warranty of any
  12  * kind, whether express or implied.
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/kernel.h>
  17 #include <linux/types.h>
  18 #include <linux/string.h>
  19 #include <linux/ptrace.h>
  20 #include <linux/errno.h>
  21 #include <linux/crc32.h>
  22 #include <linux/ioport.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/delay.h>
  25 #include <linux/netdevice.h>
  26 #include <linux/etherdevice.h>
  27 #include <linux/skbuff.h>
  28 #include <linux/spinlock.h>
  29 #include <linux/mii.h>
  30 #include <linux/ethtool.h>
  31 #include <linux/bitops.h>
  32 #include <linux/fs.h>
  33 #include <linux/platform_device.h>
  34 #include <linux/of_address.h>
  35 #include <linux/of_device.h>
  36 #include <linux/of_irq.h>
  37 #include <linux/gfp.h>
  38
  39 #include <asm/irq.h>
  40 #include <linux/uaccess.h>
  41
  42 #include "fs_enet.h"
  43 #include "fec.h"
  44
  45 /*************************************************/
  46
  47 #if defined(CONFIG_CPM1)
  48 /* for a CPM1 __raw_xxx's are sufficient */
  49 #define __fs_out32(addr, x)     __raw_writel(x, addr)
  50 #define __fs_out16(addr, x)     __raw_writew(x, addr)
  51 #define __fs_in32(addr) __raw_readl(addr)
  52 #define __fs_in16(addr) __raw_readw(addr)
  53 #else
  54 /* for others play it safe */
  55 #define __fs_out32(addr, x)     out_be32(addr, x)
  56 #define __fs_out16(addr, x)     out_be16(addr, x)
  57 #define __fs_in32(addr) in_be32(addr)
  58 #define __fs_in16(addr) in_be16(addr)
  59 #endif
  60
  61 /* write */
  62 #define FW(_fecp, _reg, _v) __fs_out32(&(_fecp)->fec_ ## _reg, (_v))
  63
  64 /* read */
  65 #define FR(_fecp, _reg) __fs_in32(&(_fecp)->fec_ ## _reg)
  66
  67 /* set bits */
  68 #define FS(_fecp, _reg, _v) FW(_fecp, _reg, FR(_fecp, _reg) | (_v))
  69
  70 /* clear bits */
  71 #define FC(_fecp, _reg, _v) FW(_fecp, _reg, FR(_fecp, _reg) & ~(_v))
  72
  73 /*
  74  * Delay to wait for FEC reset command to complete (in us)
  75  */
  76 #define FEC_RESET_DELAY         50
  77
  78 static int whack_reset(struct fec __iomem *fecp)
  79 {
  80         int i;
  81
  82         FW(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET);
  83         for (i = 0; i < FEC_RESET_DELAY; i++) {
  84                 if ((FR(fecp, ecntrl) & FEC_ECNTRL_RESET) == 0)
  85                         return 0;       /* OK */
  86                 udelay(1);
  87         }
  88
  89         return -1;
  90 }
  91
  92 static int do_pd_setup(struct fs_enet_private *fep)
  93 {
  94         struct platform_device *ofdev = to_platform_device(fep->dev);
  95
  96         fep->interrupt = irq_of_parse_and_map(ofdev->dev.of_node, 0);
  97         if (!fep->interrupt)
  98                 return -EINVAL;
  99
 100         fep->fec.fecp = of_iomap(ofdev->dev.of_node, 0);
 101         if (!fep->fcc.fccp)
 102                 return -EINVAL;
 103
 104         return 0;
 105 }
 106
 107 #define FEC_NAPI_EVENT_MSK      (FEC_ENET_RXF | FEC_ENET_RXB | FEC_ENET_TXF)
 108 #define FEC_EVENT               (FEC_ENET_RXF | FEC_ENET_TXF)
 109 #define FEC_ERR_EVENT_MSK       (FEC_ENET_HBERR | FEC_ENET_BABR | \
 110                                  FEC_ENET_BABT | FEC_ENET_EBERR)
 111
 112 static int setup_data(struct net_device *dev)
 113 {
 114         struct fs_enet_private *fep = netdev_priv(dev);
 115
 116         if (do_pd_setup(fep) != 0)
 117                 return -EINVAL;
 118
 119         fep->fec.hthi = 0;
 120         fep->fec.htlo = 0;
 121
 122         fep->ev_napi = FEC_NAPI_EVENT_MSK;
 123         fep->ev = FEC_EVENT;
 124         fep->ev_err = FEC_ERR_EVENT_MSK;
 125
 126         return 0;
 127 }
 128
 129 static int allocate_bd(struct net_device *dev)
 130 {
 131         struct fs_enet_private *fep = netdev_priv(dev);
 132         const struct fs_platform_info *fpi = fep->fpi;
 133
 134         fep->ring_base = (void __force __iomem *)dma_alloc_coherent(fep->dev,
 135                                             (fpi->tx_ring + fpi->rx_ring) *
 136                                             sizeof(cbd_t), &fep->ring_mem_addr,
 137                                             GFP_KERNEL);
 138         if (fep->ring_base == NULL)
 139                 return -ENOMEM;
 140
 141         return 0;
 142 }
 143
 144 static void free_bd(struct net_device *dev)
 145 {
 146         struct fs_enet_private *fep = netdev_priv(dev);
 147         const struct fs_platform_info *fpi = fep->fpi;
 148
 149         if(fep->ring_base)
 150                 dma_free_coherent(fep->dev, (fpi->tx_ring + fpi->rx_ring)
 151                                         * sizeof(cbd_t),
 152                                         (void __force *)fep->ring_base,
 153                                         fep->ring_mem_addr);
 154 }
 155
 156 static void cleanup_data(struct net_device *dev)
 157 {
 158         /* nothing */
 159 }
 160
 161 static void set_promiscuous_mode(struct net_device *dev)
 162 {
 163         struct fs_enet_private *fep = netdev_priv(dev);
 164         struct fec __iomem *fecp = fep->fec.fecp;
 165
 166         FS(fecp, r_cntrl, FEC_RCNTRL_PROM);
 167 }
 168
 169 static void set_multicast_start(struct net_device *dev)
 170 {
 171         struct fs_enet_private *fep = netdev_priv(dev);
 172
 173         fep->fec.hthi = 0;
 174         fep->fec.htlo = 0;
 175 }
 176
 177 static void set_multicast_one(struct net_device *dev, const u8 *mac)
 178 {
 179         struct fs_enet_private *fep = netdev_priv(dev);
 180         int temp, hash_index;
 181         u32 crc, csrVal;
 182
 183         crc = ether_crc(6, mac);
 184
 185         temp = (crc & 0x3f) >> 1;
 186         hash_index = ((temp & 0x01) << 4) |
 187                      ((temp & 0x02) << 2) |
 188                      ((temp & 0x04)) |
 189                      ((temp & 0x08) >> 2) |
 190                      ((temp & 0x10) >> 4);
 191         csrVal = 1 << hash_index;
 192         if (crc & 1)
 193                 fep->fec.hthi |= csrVal;
 194         else
 195                 fep->fec.htlo |= csrVal;
 196 }
 197
 198 static void set_multicast_finish(struct net_device *dev)
 199 {
 200         struct fs_enet_private *fep = netdev_priv(dev);
 201         struct fec __iomem *fecp = fep->fec.fecp;
 202
 203         /* if all multi or too many multicasts; just enable all */
 204         if ((dev->flags & IFF_ALLMULTI) != 0 ||
 205             netdev_mc_count(dev) > FEC_MAX_MULTICAST_ADDRS) {
 206                 fep->fec.hthi = 0xffffffffU;
 207                 fep->fec.htlo = 0xffffffffU;
 208         }
 209
 210         FC(fecp, r_cntrl, FEC_RCNTRL_PROM);
 211         FW(fecp, grp_hash_table_high, fep->fec.hthi);
 212         FW(fecp, grp_hash_table_low, fep->fec.htlo);
 213 }
 214
 215 static void set_multicast_list(struct net_device *dev)
 216 {
 217         struct netdev_hw_addr *ha;
 218
 219         if ((dev->flags & IFF_PROMISC) == 0) {
 220                 set_multicast_start(dev);
 221                 netdev_for_each_mc_addr(ha, dev)
 222                         set_multicast_one(dev, ha->addr);
 223                 set_multicast_finish(dev);
 224         } else
 225                 set_promiscuous_mode(dev);
 226 }
 227
 228 static void restart(struct net_device *dev)
 229 {
 230         struct fs_enet_private *fep = netdev_priv(dev);
 231         struct fec __iomem *fecp = fep->fec.fecp;
 232         const struct fs_platform_info *fpi = fep->fpi;
 233         dma_addr_t rx_bd_base_phys, tx_bd_base_phys;
 234         int r;
 235         u32 addrhi, addrlo;
 236
 237         struct mii_bus *mii = dev->phydev->mdio.bus;
 238         struct fec_info* fec_inf = mii->priv;
 239
 240         r = whack_reset(fep->fec.fecp);
 241         if (r != 0)
 242                 dev_err(fep->dev, "FEC Reset FAILED!\n");
 243         /*
 244          * Set station address.
 245          */
 246         addrhi = ((u32) dev->dev_addr[0] << 24) |
 247                  ((u32) dev->dev_addr[1] << 16) |
 248                  ((u32) dev->dev_addr[2] <<  8) |
 249                   (u32) dev->dev_addr[3];
 250         addrlo = ((u32) dev->dev_addr[4] << 24) |
 251                  ((u32) dev->dev_addr[5] << 16);
 252         FW(fecp, addr_low, addrhi);
 253         FW(fecp, addr_high, addrlo);
 254
 255         /*
 256          * Reset all multicast.
 257          */
 258         FW(fecp, grp_hash_table_high, fep->fec.hthi);
 259         FW(fecp, grp_hash_table_low, fep->fec.htlo);
 260
 261         /*
 262          * Set maximum receive buffer size.
 263          */
 264         FW(fecp, r_buff_size, PKT_MAXBLR_SIZE);
 265 #ifdef CONFIG_FS_ENET_MPC5121_FEC
 266         FW(fecp, r_cntrl, PKT_MAXBUF_SIZE << 16);
 267 #else
 268         FW(fecp, r_hash, PKT_MAXBUF_SIZE);
 269 #endif
 270
 271         /* get physical address */
 272         rx_bd_base_phys = fep->ring_mem_addr;
 273         tx_bd_base_phys = rx_bd_base_phys + sizeof(cbd_t) * fpi->rx_ring;
 274
 275         /*
 276          * Set receive and transmit descriptor base.
 277          */
 278         FW(fecp, r_des_start, rx_bd_base_phys);
 279         FW(fecp, x_des_start, tx_bd_base_phys);
 280
 281         fs_init_bds(dev);
 282
 283         /*
 284          * Enable big endian and don't care about SDMA FC.
 285          */
 286 #ifdef CONFIG_FS_ENET_MPC5121_FEC
 287         FS(fecp, dma_control, 0xC0000000);
 288 #else
 289         FW(fecp, fun_code, 0x78000000);
 290 #endif
 291
 292         /*
 293          * Set MII speed.
 294          */
 295         FW(fecp, mii_speed, fec_inf->mii_speed);
 296
 297         /*
 298          * Clear any outstanding interrupt.
 299          */
 300         FW(fecp, ievent, 0xffc0);
 301 #ifndef CONFIG_FS_ENET_MPC5121_FEC
 302         FW(fecp, ivec, (virq_to_hw(fep->interrupt) / 2) << 29);
 303
 304         FW(fecp, r_cntrl, FEC_RCNTRL_MII_MODE); /* MII enable */
 305 #else
 306         /*
 307          * Only set MII/RMII mode - do not touch maximum frame length
 308          * configured before.
 309          */
 310         FS(fecp, r_cntrl, fpi->use_rmii ?
 311                         FEC_RCNTRL_RMII_MODE : FEC_RCNTRL_MII_MODE);
 312 #endif
 313         /*
 314          * adjust to duplex mode
 315          */
 316         if (dev->phydev->duplex) {
 317                 FC(fecp, r_cntrl, FEC_RCNTRL_DRT);
 318                 FS(fecp, x_cntrl, FEC_TCNTRL_FDEN);     /* FD enable */
 319         } else {
 320                 FS(fecp, r_cntrl, FEC_RCNTRL_DRT);
 321                 FC(fecp, x_cntrl, FEC_TCNTRL_FDEN);     /* FD disable */
 322         }
 323
 324         /* Restore multicast and promiscuous settings */
 325         set_multicast_list(dev);
 326
 327         /*
 328          * Enable interrupts we wish to service.
 329          */
 330         FW(fecp, imask, FEC_ENET_TXF | FEC_ENET_TXB |
 331            FEC_ENET_RXF | FEC_ENET_RXB);
 332
 333         /*
 334          * And last, enable the transmit and receive processing.
 335          */
 336         FW(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
 337         FW(fecp, r_des_active, 0x01000000);
 338 }
 339
 340 static void stop(struct net_device *dev)
 341 {
 342         struct fs_enet_private *fep = netdev_priv(dev);
 343         const struct fs_platform_info *fpi = fep->fpi;
 344         struct fec __iomem *fecp = fep->fec.fecp;
 345
 346         struct fec_info *feci = dev->phydev->mdio.bus->priv;
 347
 348         int i;
 349
 350         if ((FR(fecp, ecntrl) & FEC_ECNTRL_ETHER_EN) == 0)
 351                 return;         /* already down */
 352
 353         FW(fecp, x_cntrl, 0x01);        /* Graceful transmit stop */
 354         for (i = 0; ((FR(fecp, ievent) & 0x10000000) == 0) &&
 355              i < FEC_RESET_DELAY; i++)
 356                 udelay(1);
 357
 358         if (i == FEC_RESET_DELAY)
 359                 dev_warn(fep->dev, "FEC timeout on graceful transmit stop\n");
 360         /*
 361          * Disable FEC. Let only MII interrupts.
 362          */
 363         FW(fecp, imask, 0);
 364         FC(fecp, ecntrl, FEC_ECNTRL_ETHER_EN);
 365
 366         fs_cleanup_bds(dev);
 367
 368         /* shut down FEC1? that's where the mii bus is */
 369         if (fpi->has_phy) {
 370                 FS(fecp, r_cntrl, fpi->use_rmii ?
 371                                 FEC_RCNTRL_RMII_MODE :
 372                                 FEC_RCNTRL_MII_MODE);   /* MII/RMII enable */
 373                 FS(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
 374                 FW(fecp, ievent, FEC_ENET_MII);
 375                 FW(fecp, mii_speed, feci->mii_speed);
 376         }
 377 }
 378
 379 static void napi_clear_event_fs(struct net_device *dev)
 380 {
 381         struct fs_enet_private *fep = netdev_priv(dev);
 382         struct fec __iomem *fecp = fep->fec.fecp;
 383
 384         FW(fecp, ievent, FEC_NAPI_EVENT_MSK);
 385 }
 386
 387 static void napi_enable_fs(struct net_device *dev)
 388 {
 389         struct fs_enet_private *fep = netdev_priv(dev);
 390         struct fec __iomem *fecp = fep->fec.fecp;
 391
 392         FS(fecp, imask, FEC_NAPI_EVENT_MSK);
 393 }
 394
 395 static void napi_disable_fs(struct net_device *dev)
 396 {
 397         struct fs_enet_private *fep = netdev_priv(dev);
 398         struct fec __iomem *fecp = fep->fec.fecp;
 399
 400         FC(fecp, imask, FEC_NAPI_EVENT_MSK);
 401 }
 402
 403 static void rx_bd_done(struct net_device *dev)
 404 {
 405         struct fs_enet_private *fep = netdev_priv(dev);
 406         struct fec __iomem *fecp = fep->fec.fecp;
 407
 408         FW(fecp, r_des_active, 0x01000000);
 409 }
 410
 411 static void tx_kickstart(struct net_device *dev)
 412 {
 413         struct fs_enet_private *fep = netdev_priv(dev);
 414         struct fec __iomem *fecp = fep->fec.fecp;
 415
 416         FW(fecp, x_des_active, 0x01000000);
 417 }
 418
 419 static u32 get_int_events(struct net_device *dev)
 420 {
 421         struct fs_enet_private *fep = netdev_priv(dev);
 422         struct fec __iomem *fecp = fep->fec.fecp;
 423
 424         return FR(fecp, ievent) & FR(fecp, imask);
 425 }
 426
 427 static void clear_int_events(struct net_device *dev, u32 int_events)
 428 {
 429         struct fs_enet_private *fep = netdev_priv(dev);
 430         struct fec __iomem *fecp = fep->fec.fecp;
 431
 432         FW(fecp, ievent, int_events);
 433 }
 434
 435 static void ev_error(struct net_device *dev, u32 int_events)
 436 {
 437         struct fs_enet_private *fep = netdev_priv(dev);
 438
 439         dev_warn(fep->dev, "FEC ERROR(s) 0x%x\n", int_events);
 440 }
 441
 442 static int get_regs(struct net_device *dev, void *p, int *sizep)
 443 {
 444         struct fs_enet_private *fep = netdev_priv(dev);
 445
 446         if (*sizep < sizeof(struct fec))
 447                 return -EINVAL;
 448
 449         memcpy_fromio(p, fep->fec.fecp, sizeof(struct fec));
 450
 451         return 0;
 452 }
 453
 454 static int get_regs_len(struct net_device *dev)
 455 {
 456         return sizeof(struct fec);
 457 }
 458
 459 static void tx_restart(struct net_device *dev)
 460 {
 461         /* nothing */
 462 }
 463
 464 /*************************************************************************/
 465
 466 const struct fs_ops fs_fec_ops = {
 467         .setup_data             = setup_data,
 468         .cleanup_data           = cleanup_data,
 469         .set_multicast_list     = set_multicast_list,
 470         .restart                = restart,
 471         .stop                   = stop,
 472         .napi_clear_event       = napi_clear_event_fs,
 473         .napi_enable            = napi_enable_fs,
 474         .napi_disable           = napi_disable_fs,
 475         .rx_bd_done             = rx_bd_done,
 476         .tx_kickstart           = tx_kickstart,
 477         .get_int_events         = get_int_events,
 478         .clear_int_events       = clear_int_events,
 479         .ev_error               = ev_error,
 480         .get_regs               = get_regs,
 481         .get_regs_len           = get_regs_len,
 482         .tx_restart             = tx_restart,
 483         .allocate_bd            = allocate_bd,
 484         .free_bd                = free_bd,
 485 };
 486