drivers/net/stmmac/dwmac1000_core.c

   1 /*******************************************************************************
   2   This is the driver for the GMAC on-chip Ethernet controller for ST SoCs.
   3   DWC Ether MAC 10/100/1000 Universal version 3.41a  has been used for
   4   developing this code.
   5
   6   This only implements the mac core functions for this chip.
   7
   8   Copyright (C) 2007-2009  STMicroelectronics Ltd
   9
  10   This program is free software; you can redistribute it and/or modify it
  11   under the terms and conditions of the GNU General Public License,
  12   version 2, as published by the Free Software Foundation.
  13
  14   This program is distributed in the hope it will be useful, but WITHOUT
  15   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  17   more details.
  18
  19   You should have received a copy of the GNU General Public License along with
  20   this program; if not, write to the Free Software Foundation, Inc.,
  21   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  22
  23   The full GNU General Public License is included in this distribution in
  24   the file called "COPYING".
  25
  26   Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
  27 *******************************************************************************/
  28
  29 #include <linux/crc32.h>
  30 #include <linux/slab.h>
  31 #include <asm/io.h>
  32 #include "dwmac1000.h"
  33
  34 static void dwmac1000_core_init(void __iomem *ioaddr)
  35 {
  36         u32 value = readl(ioaddr + GMAC_CONTROL);
  37         value |= GMAC_CORE_INIT;
  38         writel(value, ioaddr + GMAC_CONTROL);
  39
  40         /* STBus Bridge Configuration */
  41         /*writel(0xc5608, ioaddr + 0x00007000);*/
  42
  43         /* Freeze MMC counters */
  44         writel(0x8, ioaddr + GMAC_MMC_CTRL);
  45         /* Mask GMAC interrupts */
  46         writel(0x207, ioaddr + GMAC_INT_MASK);
  47
  48 #ifdef STMMAC_VLAN_TAG_USED
  49         /* Tag detection without filtering */
  50         writel(0x0, ioaddr + GMAC_VLAN_TAG);
  51 #endif
  52 }
  53
  54 static int dwmac1000_rx_coe_supported(void __iomem *ioaddr)
  55 {
  56         u32 value = readl(ioaddr + GMAC_CONTROL);
  57
  58         value |= GMAC_CONTROL_IPC;
  59         writel(value, ioaddr + GMAC_CONTROL);
  60
  61         value = readl(ioaddr + GMAC_CONTROL);
  62
  63         return !!(value & GMAC_CONTROL_IPC);
  64 }
  65
  66 static void dwmac1000_dump_regs(void __iomem *ioaddr)
  67 {
  68         int i;
  69         pr_info("\tDWMAC1000 regs (base addr = 0x%p)\n", ioaddr);
  70
  71         for (i = 0; i < 55; i++) {
  72                 int offset = i * 4;
  73                 pr_info("\tReg No. %d (offset 0x%x): 0x%08x\n", i,
  74                         offset, readl(ioaddr + offset));
  75         }
  76 }
  77
  78 static void dwmac1000_set_umac_addr(void __iomem *ioaddr, unsigned char *addr,
  79                                 unsigned int reg_n)
  80 {
  81         stmmac_set_mac_addr(ioaddr, addr, GMAC_ADDR_HIGH(reg_n),
  82                                 GMAC_ADDR_LOW(reg_n));
  83 }
  84
  85 static void dwmac1000_get_umac_addr(void __iomem *ioaddr, unsigned char *addr,
  86                                 unsigned int reg_n)
  87 {
  88         stmmac_get_mac_addr(ioaddr, addr, GMAC_ADDR_HIGH(reg_n),
  89                                 GMAC_ADDR_LOW(reg_n));
  90 }
  91
  92 static void dwmac1000_set_filter(struct net_device *dev)
  93 {
  94         void __iomem *ioaddr = (void __iomem *) dev->base_addr;
  95         unsigned int value = 0;
  96
  97         CHIP_DBG(KERN_INFO "%s: # mcasts %d, # unicast %d\n",
  98                  __func__, netdev_mc_count(dev), netdev_uc_count(dev));
  99
 100         if (dev->flags & IFF_PROMISC)
 101                 value = GMAC_FRAME_FILTER_PR;
 102         else if ((netdev_mc_count(dev) > HASH_TABLE_SIZE)
 103                    || (dev->flags & IFF_ALLMULTI)) {
 104                 value = GMAC_FRAME_FILTER_PM;   /* pass all multi */
 105                 writel(0xffffffff, ioaddr + GMAC_HASH_HIGH);
 106                 writel(0xffffffff, ioaddr + GMAC_HASH_LOW);
 107         } else if (!netdev_mc_empty(dev)) {
 108                 u32 mc_filter[2];
 109                 struct netdev_hw_addr *ha;
 110
 111                 /* Hash filter for multicast */
 112                 value = GMAC_FRAME_FILTER_HMC;
 113
 114                 memset(mc_filter, 0, sizeof(mc_filter));
 115                 netdev_for_each_mc_addr(ha, dev) {
 116                         /* The upper 6 bits of the calculated CRC are used to
 117                            index the contens of the hash table */
 118                         int bit_nr =
 119                             bitrev32(~crc32_le(~0, ha->addr, 6)) >> 26;
 120                         /* The most significant bit determines the register to
 121                          * use (H/L) while the other 5 bits determine the bit
 122                          * within the register. */
 123                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
 124                 }
 125                 writel(mc_filter[0], ioaddr + GMAC_HASH_LOW);
 126                 writel(mc_filter[1], ioaddr + GMAC_HASH_HIGH);
 127         }
 128
 129         /* Handle multiple unicast addresses (perfect filtering)*/
 130         if (netdev_uc_count(dev) > GMAC_MAX_UNICAST_ADDRESSES)
 131                 /* Switch to promiscuous mode is more than 16 addrs
 132                    are required */
 133                 value |= GMAC_FRAME_FILTER_PR;
 134         else {
 135                 int reg = 1;
 136                 struct netdev_hw_addr *ha;
 137
 138                 netdev_for_each_uc_addr(ha, dev) {
 139                         dwmac1000_set_umac_addr(ioaddr, ha->addr, reg);
 140                         reg++;
 141                 }
 142         }
 143
 144 #ifdef FRAME_FILTER_DEBUG
 145         /* Enable Receive all mode (to debug filtering_fail errors) */
 146         value |= GMAC_FRAME_FILTER_RA;
 147 #endif
 148         writel(value, ioaddr + GMAC_FRAME_FILTER);
 149
 150         CHIP_DBG(KERN_INFO "\tFrame Filter reg: 0x%08x\n\tHash regs: "
 151             "HI 0x%08x, LO 0x%08x\n", readl(ioaddr + GMAC_FRAME_FILTER),
 152             readl(ioaddr + GMAC_HASH_HIGH), readl(ioaddr + GMAC_HASH_LOW));
 153 }
 154
 155 static void dwmac1000_flow_ctrl(void __iomem *ioaddr, unsigned int duplex,
 156                            unsigned int fc, unsigned int pause_time)
 157 {
 158         unsigned int flow = 0;
 159
 160         CHIP_DBG(KERN_DEBUG "GMAC Flow-Control:\n");
 161         if (fc & FLOW_RX) {
 162                 CHIP_DBG(KERN_DEBUG "\tReceive Flow-Control ON\n");
 163                 flow |= GMAC_FLOW_CTRL_RFE;
 164         }
 165         if (fc & FLOW_TX) {
 166                 CHIP_DBG(KERN_DEBUG "\tTransmit Flow-Control ON\n");
 167                 flow |= GMAC_FLOW_CTRL_TFE;
 168         }
 169
 170         if (duplex) {
 171                 CHIP_DBG(KERN_DEBUG "\tduplex mode: PAUSE %d\n", pause_time);
 172                 flow |= (pause_time << GMAC_FLOW_CTRL_PT_SHIFT);
 173         }
 174
 175         writel(flow, ioaddr + GMAC_FLOW_CTRL);
 176 }
 177
 178 static void dwmac1000_pmt(void __iomem *ioaddr, unsigned long mode)
 179 {
 180         unsigned int pmt = 0;
 181
 182         if (mode & WAKE_MAGIC) {
 183                 CHIP_DBG(KERN_DEBUG "GMAC: WOL Magic frame\n");
 184                 pmt |= power_down | magic_pkt_en;
 185         }
 186         if (mode & WAKE_UCAST) {
 187                 CHIP_DBG(KERN_DEBUG "GMAC: WOL on global unicast\n");
 188                 pmt |= global_unicast;
 189         }
 190
 191         writel(pmt, ioaddr + GMAC_PMT);
 192 }
 193
 194
 195 static void dwmac1000_irq_status(void __iomem *ioaddr)
 196 {
 197         u32 intr_status = readl(ioaddr + GMAC_INT_STATUS);
 198
 199         /* Not used events (e.g. MMC interrupts) are not handled. */
 200         if ((intr_status & mmc_tx_irq))
 201                 CHIP_DBG(KERN_DEBUG "GMAC: MMC tx interrupt: 0x%08x\n",
 202                     readl(ioaddr + GMAC_MMC_TX_INTR));
 203         if (unlikely(intr_status & mmc_rx_irq))
 204                 CHIP_DBG(KERN_DEBUG "GMAC: MMC rx interrupt: 0x%08x\n",
 205                     readl(ioaddr + GMAC_MMC_RX_INTR));
 206         if (unlikely(intr_status & mmc_rx_csum_offload_irq))
 207                 CHIP_DBG(KERN_DEBUG "GMAC: MMC rx csum offload: 0x%08x\n",
 208                     readl(ioaddr + GMAC_MMC_RX_CSUM_OFFLOAD));
 209         if (unlikely(intr_status & pmt_irq)) {
 210                 CHIP_DBG(KERN_DEBUG "GMAC: received Magic frame\n");
 211                 /* clear the PMT bits 5 and 6 by reading the PMT
 212                  * status register. */
 213                 readl(ioaddr + GMAC_PMT);
 214         }
 215 }
 216
 217 static const struct stmmac_ops dwmac1000_ops = {
 218         .core_init = dwmac1000_core_init,
 219         .rx_coe = dwmac1000_rx_coe_supported,
 220         .dump_regs = dwmac1000_dump_regs,
 221         .host_irq_status = dwmac1000_irq_status,
 222         .set_filter = dwmac1000_set_filter,
 223         .flow_ctrl = dwmac1000_flow_ctrl,
 224         .pmt = dwmac1000_pmt,
 225         .set_umac_addr = dwmac1000_set_umac_addr,
 226         .get_umac_addr = dwmac1000_get_umac_addr,
 227 };
 228
 229 struct mac_device_info *dwmac1000_setup(void __iomem *ioaddr)
 230 {
 231         struct mac_device_info *mac;
 232         u32 uid = readl(ioaddr + GMAC_VERSION);
 233
 234         pr_info("\tDWMAC1000 - user ID: 0x%x, Synopsys ID: 0x%x\n",
 235                 ((uid & 0x0000ff00) >> 8), (uid & 0x000000ff));
 236
 237         mac = kzalloc(sizeof(const struct mac_device_info), GFP_KERNEL);
 238         if (!mac)
 239                 return NULL;
 240
 241         mac->mac = &dwmac1000_ops;
 242         mac->dma = &dwmac1000_dma_ops;
 243
 244         mac->link.port = GMAC_CONTROL_PS;
 245         mac->link.duplex = GMAC_CONTROL_DM;
 246         mac->link.speed = GMAC_CONTROL_FES;
 247         mac->mii.addr = GMAC_MII_ADDR;
 248         mac->mii.data = GMAC_MII_DATA;
 249
 250         return mac;
 251 }