drivers/net/ethernet/synopsys/dwc-xlgmac-hw.c

   1 /* Synopsys DesignWare Core Enterprise Ethernet (XLGMAC) Driver
   2  *
   3  * Copyright (c) 2017 Synopsys, Inc. (www.synopsys.com)
   4  *
   5  * This program is dual-licensed; you may select either version 2 of
   6  * the GNU General Public License ("GPL") or BSD license ("BSD").
   7  *
   8  * This Synopsys DWC XLGMAC software driver and associated documentation
   9  * (hereinafter the "Software") is an unsupported proprietary work of
  10  * Synopsys, Inc. unless otherwise expressly agreed to in writing between
  11  * Synopsys and you. The Software IS NOT an item of Licensed Software or a
  12  * Licensed Product under any End User Software License Agreement or
  13  * Agreement for Licensed Products with Synopsys or any supplement thereto.
  14  * Synopsys is a registered trademark of Synopsys, Inc. Other names included
  15  * in the SOFTWARE may be the trademarks of their respective owners.
  16  */
  17
  18 #include <linux/phy.h>
  19 #include <linux/mdio.h>
  20 #include <linux/clk.h>
  21 #include <linux/bitrev.h>
  22 #include <linux/crc32.h>
  23 #include <linux/crc32poly.h>
  24 #include <linux/dcbnl.h>
  25
  26 #include "dwc-xlgmac.h"
  27 #include "dwc-xlgmac-reg.h"
  28
  29 static int xlgmac_tx_complete(struct xlgmac_dma_desc *dma_desc)
  30 {
  31         return !XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
  32                                 TX_NORMAL_DESC3_OWN_POS,
  33                                 TX_NORMAL_DESC3_OWN_LEN);
  34 }
  35
  36 static int xlgmac_disable_rx_csum(struct xlgmac_pdata *pdata)
  37 {
  38         u32 regval;
  39
  40         regval = readl(pdata->mac_regs + MAC_RCR);
  41         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_IPC_POS,
  42                                      MAC_RCR_IPC_LEN, 0);
  43         writel(regval, pdata->mac_regs + MAC_RCR);
  44
  45         return 0;
  46 }
  47
  48 static int xlgmac_enable_rx_csum(struct xlgmac_pdata *pdata)
  49 {
  50         u32 regval;
  51
  52         regval = readl(pdata->mac_regs + MAC_RCR);
  53         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_IPC_POS,
  54                                      MAC_RCR_IPC_LEN, 1);
  55         writel(regval, pdata->mac_regs + MAC_RCR);
  56
  57         return 0;
  58 }
  59
  60 static int xlgmac_set_mac_address(struct xlgmac_pdata *pdata, u8 *addr)
  61 {
  62         unsigned int mac_addr_hi, mac_addr_lo;
  63
  64         mac_addr_hi = (addr[5] <<  8) | (addr[4] <<  0);
  65         mac_addr_lo = (addr[3] << 24) | (addr[2] << 16) |
  66                       (addr[1] <<  8) | (addr[0] <<  0);
  67
  68         writel(mac_addr_hi, pdata->mac_regs + MAC_MACA0HR);
  69         writel(mac_addr_lo, pdata->mac_regs + MAC_MACA0LR);
  70
  71         return 0;
  72 }
  73
  74 static void xlgmac_set_mac_reg(struct xlgmac_pdata *pdata,
  75                                struct netdev_hw_addr *ha,
  76                                unsigned int *mac_reg)
  77 {
  78         unsigned int mac_addr_hi, mac_addr_lo;
  79         u8 *mac_addr;
  80
  81         mac_addr_lo = 0;
  82         mac_addr_hi = 0;
  83
  84         if (ha) {
  85                 mac_addr = (u8 *)&mac_addr_lo;
  86                 mac_addr[0] = ha->addr[0];
  87                 mac_addr[1] = ha->addr[1];
  88                 mac_addr[2] = ha->addr[2];
  89                 mac_addr[3] = ha->addr[3];
  90                 mac_addr = (u8 *)&mac_addr_hi;
  91                 mac_addr[0] = ha->addr[4];
  92                 mac_addr[1] = ha->addr[5];
  93
  94                 netif_dbg(pdata, drv, pdata->netdev,
  95                           "adding mac address %pM at %#x\n",
  96                           ha->addr, *mac_reg);
  97
  98                 mac_addr_hi = XLGMAC_SET_REG_BITS(mac_addr_hi,
  99                                                   MAC_MACA1HR_AE_POS,
 100                                                 MAC_MACA1HR_AE_LEN,
 101                                                 1);
 102         }
 103
 104         writel(mac_addr_hi, pdata->mac_regs + *mac_reg);
 105         *mac_reg += MAC_MACA_INC;
 106         writel(mac_addr_lo, pdata->mac_regs + *mac_reg);
 107         *mac_reg += MAC_MACA_INC;
 108 }
 109
 110 static int xlgmac_enable_rx_vlan_stripping(struct xlgmac_pdata *pdata)
 111 {
 112         u32 regval;
 113
 114         regval = readl(pdata->mac_regs + MAC_VLANTR);
 115         /* Put the VLAN tag in the Rx descriptor */
 116         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_EVLRXS_POS,
 117                                      MAC_VLANTR_EVLRXS_LEN, 1);
 118         /* Don't check the VLAN type */
 119         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_DOVLTC_POS,
 120                                      MAC_VLANTR_DOVLTC_LEN, 1);
 121         /* Check only C-TAG (0x8100) packets */
 122         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_ERSVLM_POS,
 123                                      MAC_VLANTR_ERSVLM_LEN, 0);
 124         /* Don't consider an S-TAG (0x88A8) packet as a VLAN packet */
 125         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_ESVL_POS,
 126                                      MAC_VLANTR_ESVL_LEN, 0);
 127         /* Enable VLAN tag stripping */
 128         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_EVLS_POS,
 129                                      MAC_VLANTR_EVLS_LEN, 0x3);
 130         writel(regval, pdata->mac_regs + MAC_VLANTR);
 131
 132         return 0;
 133 }
 134
 135 static int xlgmac_disable_rx_vlan_stripping(struct xlgmac_pdata *pdata)
 136 {
 137         u32 regval;
 138
 139         regval = readl(pdata->mac_regs + MAC_VLANTR);
 140         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_EVLS_POS,
 141                                      MAC_VLANTR_EVLS_LEN, 0);
 142         writel(regval, pdata->mac_regs + MAC_VLANTR);
 143
 144         return 0;
 145 }
 146
 147 static int xlgmac_enable_rx_vlan_filtering(struct xlgmac_pdata *pdata)
 148 {
 149         u32 regval;
 150
 151         regval = readl(pdata->mac_regs + MAC_PFR);
 152         /* Enable VLAN filtering */
 153         regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_VTFE_POS,
 154                                      MAC_PFR_VTFE_LEN, 1);
 155         writel(regval, pdata->mac_regs + MAC_PFR);
 156
 157         regval = readl(pdata->mac_regs + MAC_VLANTR);
 158         /* Enable VLAN Hash Table filtering */
 159         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_VTHM_POS,
 160                                      MAC_VLANTR_VTHM_LEN, 1);
 161         /* Disable VLAN tag inverse matching */
 162         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_VTIM_POS,
 163                                      MAC_VLANTR_VTIM_LEN, 0);
 164         /* Only filter on the lower 12-bits of the VLAN tag */
 165         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_ETV_POS,
 166                                      MAC_VLANTR_ETV_LEN, 1);
 167         /* In order for the VLAN Hash Table filtering to be effective,
 168          * the VLAN tag identifier in the VLAN Tag Register must not
 169          * be zero.  Set the VLAN tag identifier to "1" to enable the
 170          * VLAN Hash Table filtering.  This implies that a VLAN tag of
 171          * 1 will always pass filtering.
 172          */
 173         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_VL_POS,
 174                                      MAC_VLANTR_VL_LEN, 1);
 175         writel(regval, pdata->mac_regs + MAC_VLANTR);
 176
 177         return 0;
 178 }
 179
 180 static int xlgmac_disable_rx_vlan_filtering(struct xlgmac_pdata *pdata)
 181 {
 182         u32 regval;
 183
 184         regval = readl(pdata->mac_regs + MAC_PFR);
 185         /* Disable VLAN filtering */
 186         regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_VTFE_POS,
 187                                      MAC_PFR_VTFE_LEN, 0);
 188         writel(regval, pdata->mac_regs + MAC_PFR);
 189
 190         return 0;
 191 }
 192
 193 static u32 xlgmac_vid_crc32_le(__le16 vid_le)
 194 {
 195         unsigned char *data = (unsigned char *)&vid_le;
 196         unsigned char data_byte = 0;
 197         u32 crc = ~0;
 198         u32 temp = 0;
 199         int i, bits;
 200
 201         bits = get_bitmask_order(VLAN_VID_MASK);
 202         for (i = 0; i < bits; i++) {
 203                 if ((i % 8) == 0)
 204                         data_byte = data[i / 8];
 205
 206                 temp = ((crc & 1) ^ data_byte) & 1;
 207                 crc >>= 1;
 208                 data_byte >>= 1;
 209
 210                 if (temp)
 211                         crc ^= CRC32_POLY_LE;
 212         }
 213
 214         return crc;
 215 }
 216
 217 static int xlgmac_update_vlan_hash_table(struct xlgmac_pdata *pdata)
 218 {
 219         u16 vlan_hash_table = 0;
 220         __le16 vid_le;
 221         u32 regval;
 222         u32 crc;
 223         u16 vid;
 224
 225         /* Generate the VLAN Hash Table value */
 226         for_each_set_bit(vid, pdata->active_vlans, VLAN_N_VID) {
 227                 /* Get the CRC32 value of the VLAN ID */
 228                 vid_le = cpu_to_le16(vid);
 229                 crc = bitrev32(~xlgmac_vid_crc32_le(vid_le)) >> 28;
 230
 231                 vlan_hash_table |= (1 << crc);
 232         }
 233
 234         regval = readl(pdata->mac_regs + MAC_VLANHTR);
 235         /* Set the VLAN Hash Table filtering register */
 236         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANHTR_VLHT_POS,
 237                                      MAC_VLANHTR_VLHT_LEN, vlan_hash_table);
 238         writel(regval, pdata->mac_regs + MAC_VLANHTR);
 239
 240         return 0;
 241 }
 242
 243 static int xlgmac_set_promiscuous_mode(struct xlgmac_pdata *pdata,
 244                                        unsigned int enable)
 245 {
 246         unsigned int val = enable ? 1 : 0;
 247         u32 regval;
 248
 249         regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_PFR),
 250                                      MAC_PFR_PR_POS, MAC_PFR_PR_LEN);
 251         if (regval == val)
 252                 return 0;
 253
 254         netif_dbg(pdata, drv, pdata->netdev, "%s promiscuous mode\n",
 255                   enable ? "entering" : "leaving");
 256
 257         regval = readl(pdata->mac_regs + MAC_PFR);
 258         regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_PR_POS,
 259                                      MAC_PFR_PR_LEN, val);
 260         writel(regval, pdata->mac_regs + MAC_PFR);
 261
 262         /* Hardware will still perform VLAN filtering in promiscuous mode */
 263         if (enable) {
 264                 xlgmac_disable_rx_vlan_filtering(pdata);
 265         } else {
 266                 if (pdata->netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)
 267                         xlgmac_enable_rx_vlan_filtering(pdata);
 268         }
 269
 270         return 0;
 271 }
 272
 273 static int xlgmac_set_all_multicast_mode(struct xlgmac_pdata *pdata,
 274                                          unsigned int enable)
 275 {
 276         unsigned int val = enable ? 1 : 0;
 277         u32 regval;
 278
 279         regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_PFR),
 280                                      MAC_PFR_PM_POS, MAC_PFR_PM_LEN);
 281         if (regval == val)
 282                 return 0;
 283
 284         netif_dbg(pdata, drv, pdata->netdev, "%s allmulti mode\n",
 285                   enable ? "entering" : "leaving");
 286
 287         regval = readl(pdata->mac_regs + MAC_PFR);
 288         regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_PM_POS,
 289                                      MAC_PFR_PM_LEN, val);
 290         writel(regval, pdata->mac_regs + MAC_PFR);
 291
 292         return 0;
 293 }
 294
 295 static void xlgmac_set_mac_addn_addrs(struct xlgmac_pdata *pdata)
 296 {
 297         struct net_device *netdev = pdata->netdev;
 298         struct netdev_hw_addr *ha;
 299         unsigned int addn_macs;
 300         unsigned int mac_reg;
 301
 302         mac_reg = MAC_MACA1HR;
 303         addn_macs = pdata->hw_feat.addn_mac;
 304
 305         if (netdev_uc_count(netdev) > addn_macs) {
 306                 xlgmac_set_promiscuous_mode(pdata, 1);
 307         } else {
 308                 netdev_for_each_uc_addr(ha, netdev) {
 309                         xlgmac_set_mac_reg(pdata, ha, &mac_reg);
 310                         addn_macs--;
 311                 }
 312
 313                 if (netdev_mc_count(netdev) > addn_macs) {
 314                         xlgmac_set_all_multicast_mode(pdata, 1);
 315                 } else {
 316                         netdev_for_each_mc_addr(ha, netdev) {
 317                                 xlgmac_set_mac_reg(pdata, ha, &mac_reg);
 318                                 addn_macs--;
 319                         }
 320                 }
 321         }
 322
 323         /* Clear remaining additional MAC address entries */
 324         while (addn_macs--)
 325                 xlgmac_set_mac_reg(pdata, NULL, &mac_reg);
 326 }
 327
 328 static void xlgmac_set_mac_hash_table(struct xlgmac_pdata *pdata)
 329 {
 330         unsigned int hash_table_shift, hash_table_count;
 331         u32 hash_table[XLGMAC_MAC_HASH_TABLE_SIZE];
 332         struct net_device *netdev = pdata->netdev;
 333         struct netdev_hw_addr *ha;
 334         unsigned int hash_reg;
 335         unsigned int i;
 336         u32 crc;
 337
 338         hash_table_shift = 26 - (pdata->hw_feat.hash_table_size >> 7);
 339         hash_table_count = pdata->hw_feat.hash_table_size / 32;
 340         memset(hash_table, 0, sizeof(hash_table));
 341
 342         /* Build the MAC Hash Table register values */
 343         netdev_for_each_uc_addr(ha, netdev) {
 344                 crc = bitrev32(~crc32_le(~0, ha->addr, ETH_ALEN));
 345                 crc >>= hash_table_shift;
 346                 hash_table[crc >> 5] |= (1 << (crc & 0x1f));
 347         }
 348
 349         netdev_for_each_mc_addr(ha, netdev) {
 350                 crc = bitrev32(~crc32_le(~0, ha->addr, ETH_ALEN));
 351                 crc >>= hash_table_shift;
 352                 hash_table[crc >> 5] |= (1 << (crc & 0x1f));
 353         }
 354
 355         /* Set the MAC Hash Table registers */
 356         hash_reg = MAC_HTR0;
 357         for (i = 0; i < hash_table_count; i++) {
 358                 writel(hash_table[i], pdata->mac_regs + hash_reg);
 359                 hash_reg += MAC_HTR_INC;
 360         }
 361 }
 362
 363 static int xlgmac_add_mac_addresses(struct xlgmac_pdata *pdata)
 364 {
 365         if (pdata->hw_feat.hash_table_size)
 366                 xlgmac_set_mac_hash_table(pdata);
 367         else
 368                 xlgmac_set_mac_addn_addrs(pdata);
 369
 370         return 0;
 371 }
 372
 373 static void xlgmac_config_mac_address(struct xlgmac_pdata *pdata)
 374 {
 375         u32 regval;
 376
 377         xlgmac_set_mac_address(pdata, pdata->netdev->dev_addr);
 378
 379         /* Filtering is done using perfect filtering and hash filtering */
 380         if (pdata->hw_feat.hash_table_size) {
 381                 regval = readl(pdata->mac_regs + MAC_PFR);
 382                 regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_HPF_POS,
 383                                              MAC_PFR_HPF_LEN, 1);
 384                 regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_HUC_POS,
 385                                              MAC_PFR_HUC_LEN, 1);
 386                 regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_HMC_POS,
 387                                              MAC_PFR_HMC_LEN, 1);
 388                 writel(regval, pdata->mac_regs + MAC_PFR);
 389         }
 390 }
 391
 392 static void xlgmac_config_jumbo_enable(struct xlgmac_pdata *pdata)
 393 {
 394         unsigned int val;
 395         u32 regval;
 396
 397         val = (pdata->netdev->mtu > XLGMAC_STD_PACKET_MTU) ? 1 : 0;
 398
 399         regval = readl(pdata->mac_regs + MAC_RCR);
 400         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_JE_POS,
 401                                      MAC_RCR_JE_LEN, val);
 402         writel(regval, pdata->mac_regs + MAC_RCR);
 403 }
 404
 405 static void xlgmac_config_checksum_offload(struct xlgmac_pdata *pdata)
 406 {
 407         if (pdata->netdev->features & NETIF_F_RXCSUM)
 408                 xlgmac_enable_rx_csum(pdata);
 409         else
 410                 xlgmac_disable_rx_csum(pdata);
 411 }
 412
 413 static void xlgmac_config_vlan_support(struct xlgmac_pdata *pdata)
 414 {
 415         u32 regval;
 416
 417         regval = readl(pdata->mac_regs + MAC_VLANIR);
 418         /* Indicate that VLAN Tx CTAGs come from context descriptors */
 419         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANIR_CSVL_POS,
 420                                      MAC_VLANIR_CSVL_LEN, 0);
 421         regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANIR_VLTI_POS,
 422                                      MAC_VLANIR_VLTI_LEN, 1);
 423         writel(regval, pdata->mac_regs + MAC_VLANIR);
 424
 425         /* Set the current VLAN Hash Table register value */
 426         xlgmac_update_vlan_hash_table(pdata);
 427
 428         if (pdata->netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)
 429                 xlgmac_enable_rx_vlan_filtering(pdata);
 430         else
 431                 xlgmac_disable_rx_vlan_filtering(pdata);
 432
 433         if (pdata->netdev->features & NETIF_F_HW_VLAN_CTAG_RX)
 434                 xlgmac_enable_rx_vlan_stripping(pdata);
 435         else
 436                 xlgmac_disable_rx_vlan_stripping(pdata);
 437 }
 438
 439 static int xlgmac_config_rx_mode(struct xlgmac_pdata *pdata)
 440 {
 441         struct net_device *netdev = pdata->netdev;
 442         unsigned int pr_mode, am_mode;
 443
 444         pr_mode = ((netdev->flags & IFF_PROMISC) != 0);
 445         am_mode = ((netdev->flags & IFF_ALLMULTI) != 0);
 446
 447         xlgmac_set_promiscuous_mode(pdata, pr_mode);
 448         xlgmac_set_all_multicast_mode(pdata, am_mode);
 449
 450         xlgmac_add_mac_addresses(pdata);
 451
 452         return 0;
 453 }
 454
 455 static void xlgmac_prepare_tx_stop(struct xlgmac_pdata *pdata,
 456                                    struct xlgmac_channel *channel)
 457 {
 458         unsigned int tx_dsr, tx_pos, tx_qidx;
 459         unsigned long tx_timeout;
 460         unsigned int tx_status;
 461
 462         /* Calculate the status register to read and the position within */
 463         if (channel->queue_index < DMA_DSRX_FIRST_QUEUE) {
 464                 tx_dsr = DMA_DSR0;
 465                 tx_pos = (channel->queue_index * DMA_DSR_Q_LEN) +
 466                          DMA_DSR0_TPS_START;
 467         } else {
 468                 tx_qidx = channel->queue_index - DMA_DSRX_FIRST_QUEUE;
 469
 470                 tx_dsr = DMA_DSR1 + ((tx_qidx / DMA_DSRX_QPR) * DMA_DSRX_INC);
 471                 tx_pos = ((tx_qidx % DMA_DSRX_QPR) * DMA_DSR_Q_LEN) +
 472                          DMA_DSRX_TPS_START;
 473         }
 474
 475         /* The Tx engine cannot be stopped if it is actively processing
 476          * descriptors. Wait for the Tx engine to enter the stopped or
 477          * suspended state.  Don't wait forever though...
 478          */
 479         tx_timeout = jiffies + (XLGMAC_DMA_STOP_TIMEOUT * HZ);
 480         while (time_before(jiffies, tx_timeout)) {
 481                 tx_status = readl(pdata->mac_regs + tx_dsr);
 482                 tx_status = XLGMAC_GET_REG_BITS(tx_status, tx_pos,
 483                                                 DMA_DSR_TPS_LEN);
 484                 if ((tx_status == DMA_TPS_STOPPED) ||
 485                     (tx_status == DMA_TPS_SUSPENDED))
 486                         break;
 487
 488                 usleep_range(500, 1000);
 489         }
 490
 491         if (!time_before(jiffies, tx_timeout))
 492                 netdev_info(pdata->netdev,
 493                             "timed out waiting for Tx DMA channel %u to stop\n",
 494                             channel->queue_index);
 495 }
 496
 497 static void xlgmac_enable_tx(struct xlgmac_pdata *pdata)
 498 {
 499         struct xlgmac_channel *channel;
 500         unsigned int i;
 501         u32 regval;
 502
 503         /* Enable each Tx DMA channel */
 504         channel = pdata->channel_head;
 505         for (i = 0; i < pdata->channel_count; i++, channel++) {
 506                 if (!channel->tx_ring)
 507                         break;
 508
 509                 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_TCR));
 510                 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_TCR_ST_POS,
 511                                              DMA_CH_TCR_ST_LEN, 1);
 512                 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_TCR));
 513         }
 514
 515         /* Enable each Tx queue */
 516         for (i = 0; i < pdata->tx_q_count; i++) {
 517                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
 518                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_TXQEN_POS,
 519                                              MTL_Q_TQOMR_TXQEN_LEN,
 520                                         MTL_Q_ENABLED);
 521                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
 522         }
 523
 524         /* Enable MAC Tx */
 525         regval = readl(pdata->mac_regs + MAC_TCR);
 526         regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_TE_POS,
 527                                      MAC_TCR_TE_LEN, 1);
 528         writel(regval, pdata->mac_regs + MAC_TCR);
 529 }
 530
 531 static void xlgmac_disable_tx(struct xlgmac_pdata *pdata)
 532 {
 533         struct xlgmac_channel *channel;
 534         unsigned int i;
 535         u32 regval;
 536
 537         /* Prepare for Tx DMA channel stop */
 538         channel = pdata->channel_head;
 539         for (i = 0; i < pdata->channel_count; i++, channel++) {
 540                 if (!channel->tx_ring)
 541                         break;
 542
 543                 xlgmac_prepare_tx_stop(pdata, channel);
 544         }
 545
 546         /* Disable MAC Tx */
 547         regval = readl(pdata->mac_regs + MAC_TCR);
 548         regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_TE_POS,
 549                                      MAC_TCR_TE_LEN, 0);
 550         writel(regval, pdata->mac_regs + MAC_TCR);
 551
 552         /* Disable each Tx queue */
 553         for (i = 0; i < pdata->tx_q_count; i++) {
 554                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
 555                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_TXQEN_POS,
 556                                              MTL_Q_TQOMR_TXQEN_LEN, 0);
 557                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
 558         }
 559
 560         /* Disable each Tx DMA channel */
 561         channel = pdata->channel_head;
 562         for (i = 0; i < pdata->channel_count; i++, channel++) {
 563                 if (!channel->tx_ring)
 564                         break;
 565
 566                 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_TCR));
 567                 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_TCR_ST_POS,
 568                                              DMA_CH_TCR_ST_LEN, 0);
 569                 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_TCR));
 570         }
 571 }
 572
 573 static void xlgmac_prepare_rx_stop(struct xlgmac_pdata *pdata,
 574                                    unsigned int queue)
 575 {
 576         unsigned int rx_status, prxq, rxqsts;
 577         unsigned long rx_timeout;
 578
 579         /* The Rx engine cannot be stopped if it is actively processing
 580          * packets. Wait for the Rx queue to empty the Rx fifo.  Don't
 581          * wait forever though...
 582          */
 583         rx_timeout = jiffies + (XLGMAC_DMA_STOP_TIMEOUT * HZ);
 584         while (time_before(jiffies, rx_timeout)) {
 585                 rx_status = readl(XLGMAC_MTL_REG(pdata, queue, MTL_Q_RQDR));
 586                 prxq = XLGMAC_GET_REG_BITS(rx_status, MTL_Q_RQDR_PRXQ_POS,
 587                                            MTL_Q_RQDR_PRXQ_LEN);
 588                 rxqsts = XLGMAC_GET_REG_BITS(rx_status, MTL_Q_RQDR_RXQSTS_POS,
 589                                              MTL_Q_RQDR_RXQSTS_LEN);
 590                 if ((prxq == 0) && (rxqsts == 0))
 591                         break;
 592
 593                 usleep_range(500, 1000);
 594         }
 595
 596         if (!time_before(jiffies, rx_timeout))
 597                 netdev_info(pdata->netdev,
 598                             "timed out waiting for Rx queue %u to empty\n",
 599                             queue);
 600 }
 601
 602 static void xlgmac_enable_rx(struct xlgmac_pdata *pdata)
 603 {
 604         struct xlgmac_channel *channel;
 605         unsigned int regval, i;
 606
 607         /* Enable each Rx DMA channel */
 608         channel = pdata->channel_head;
 609         for (i = 0; i < pdata->channel_count; i++, channel++) {
 610                 if (!channel->rx_ring)
 611                         break;
 612
 613                 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_RCR));
 614                 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_RCR_SR_POS,
 615                                              DMA_CH_RCR_SR_LEN, 1);
 616                 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_RCR));
 617         }
 618
 619         /* Enable each Rx queue */
 620         regval = 0;
 621         for (i = 0; i < pdata->rx_q_count; i++)
 622                 regval |= (0x02 << (i << 1));
 623         writel(regval, pdata->mac_regs + MAC_RQC0R);
 624
 625         /* Enable MAC Rx */
 626         regval = readl(pdata->mac_regs + MAC_RCR);
 627         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_DCRCC_POS,
 628                                      MAC_RCR_DCRCC_LEN, 1);
 629         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_CST_POS,
 630                                      MAC_RCR_CST_LEN, 1);
 631         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_ACS_POS,
 632                                      MAC_RCR_ACS_LEN, 1);
 633         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_RE_POS,
 634                                      MAC_RCR_RE_LEN, 1);
 635         writel(regval, pdata->mac_regs + MAC_RCR);
 636 }
 637
 638 static void xlgmac_disable_rx(struct xlgmac_pdata *pdata)
 639 {
 640         struct xlgmac_channel *channel;
 641         unsigned int i;
 642         u32 regval;
 643
 644         /* Disable MAC Rx */
 645         regval = readl(pdata->mac_regs + MAC_RCR);
 646         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_DCRCC_POS,
 647                                      MAC_RCR_DCRCC_LEN, 0);
 648         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_CST_POS,
 649                                      MAC_RCR_CST_LEN, 0);
 650         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_ACS_POS,
 651                                      MAC_RCR_ACS_LEN, 0);
 652         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_RE_POS,
 653                                      MAC_RCR_RE_LEN, 0);
 654         writel(regval, pdata->mac_regs + MAC_RCR);
 655
 656         /* Prepare for Rx DMA channel stop */
 657         for (i = 0; i < pdata->rx_q_count; i++)
 658                 xlgmac_prepare_rx_stop(pdata, i);
 659
 660         /* Disable each Rx queue */
 661         writel(0, pdata->mac_regs + MAC_RQC0R);
 662
 663         /* Disable each Rx DMA channel */
 664         channel = pdata->channel_head;
 665         for (i = 0; i < pdata->channel_count; i++, channel++) {
 666                 if (!channel->rx_ring)
 667                         break;
 668
 669                 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_RCR));
 670                 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_RCR_SR_POS,
 671                                              DMA_CH_RCR_SR_LEN, 0);
 672                 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_RCR));
 673         }
 674 }
 675
 676 static void xlgmac_tx_start_xmit(struct xlgmac_channel *channel,
 677                                  struct xlgmac_ring *ring)
 678 {
 679         struct xlgmac_pdata *pdata = channel->pdata;
 680         struct xlgmac_desc_data *desc_data;
 681
 682         /* Make sure everything is written before the register write */
 683         wmb();
 684
 685         /* Issue a poll command to Tx DMA by writing address
 686          * of next immediate free descriptor
 687          */
 688         desc_data = XLGMAC_GET_DESC_DATA(ring, ring->cur);
 689         writel(lower_32_bits(desc_data->dma_desc_addr),
 690                XLGMAC_DMA_REG(channel, DMA_CH_TDTR_LO));
 691
 692         /* Start the Tx timer */
 693         if (pdata->tx_usecs && !channel->tx_timer_active) {
 694                 channel->tx_timer_active = 1;
 695                 mod_timer(&channel->tx_timer,
 696                           jiffies + usecs_to_jiffies(pdata->tx_usecs));
 697         }
 698
 699         ring->tx.xmit_more = 0;
 700 }
 701
 702 static void xlgmac_dev_xmit(struct xlgmac_channel *channel)
 703 {
 704         struct xlgmac_pdata *pdata = channel->pdata;
 705         struct xlgmac_ring *ring = channel->tx_ring;
 706         unsigned int tso_context, vlan_context;
 707         struct xlgmac_desc_data *desc_data;
 708         struct xlgmac_dma_desc *dma_desc;
 709         struct xlgmac_pkt_info *pkt_info;
 710         unsigned int csum, tso, vlan;
 711         int start_index = ring->cur;
 712         int cur_index = ring->cur;
 713         unsigned int tx_set_ic;
 714         int i;
 715
 716         pkt_info = &ring->pkt_info;
 717         csum = XLGMAC_GET_REG_BITS(pkt_info->attributes,
 718                                    TX_PACKET_ATTRIBUTES_CSUM_ENABLE_POS,
 719                                 TX_PACKET_ATTRIBUTES_CSUM_ENABLE_LEN);
 720         tso = XLGMAC_GET_REG_BITS(pkt_info->attributes,
 721                                   TX_PACKET_ATTRIBUTES_TSO_ENABLE_POS,
 722                                 TX_PACKET_ATTRIBUTES_TSO_ENABLE_LEN);
 723         vlan = XLGMAC_GET_REG_BITS(pkt_info->attributes,
 724                                    TX_PACKET_ATTRIBUTES_VLAN_CTAG_POS,
 725                                 TX_PACKET_ATTRIBUTES_VLAN_CTAG_LEN);
 726
 727         if (tso && (pkt_info->mss != ring->tx.cur_mss))
 728                 tso_context = 1;
 729         else
 730                 tso_context = 0;
 731
 732         if (vlan && (pkt_info->vlan_ctag != ring->tx.cur_vlan_ctag))
 733                 vlan_context = 1;
 734         else
 735                 vlan_context = 0;
 736
 737         /* Determine if an interrupt should be generated for this Tx:
 738          *   Interrupt:
 739          *     - Tx frame count exceeds the frame count setting
 740          *     - Addition of Tx frame count to the frame count since the
 741          *       last interrupt was set exceeds the frame count setting
 742          *   No interrupt:
 743          *     - No frame count setting specified (ethtool -C ethX tx-frames 0)
 744          *     - Addition of Tx frame count to the frame count since the
 745          *       last interrupt was set does not exceed the frame count setting
 746          */
 747         ring->coalesce_count += pkt_info->tx_packets;
 748         if (!pdata->tx_frames)
 749                 tx_set_ic = 0;
 750         else if (pkt_info->tx_packets > pdata->tx_frames)
 751                 tx_set_ic = 1;
 752         else if ((ring->coalesce_count % pdata->tx_frames) <
 753                  pkt_info->tx_packets)
 754                 tx_set_ic = 1;
 755         else
 756                 tx_set_ic = 0;
 757
 758         desc_data = XLGMAC_GET_DESC_DATA(ring, cur_index);
 759         dma_desc = desc_data->dma_desc;
 760
 761         /* Create a context descriptor if this is a TSO pkt_info */
 762         if (tso_context || vlan_context) {
 763                 if (tso_context) {
 764                         netif_dbg(pdata, tx_queued, pdata->netdev,
 765                                   "TSO context descriptor, mss=%u\n",
 766                                   pkt_info->mss);
 767
 768                         /* Set the MSS size */
 769                         dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
 770                                                 dma_desc->desc2,
 771                                                 TX_CONTEXT_DESC2_MSS_POS,
 772                                                 TX_CONTEXT_DESC2_MSS_LEN,
 773                                                 pkt_info->mss);
 774
 775                         /* Mark it as a CONTEXT descriptor */
 776                         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 777                                                 dma_desc->desc3,
 778                                                 TX_CONTEXT_DESC3_CTXT_POS,
 779                                                 TX_CONTEXT_DESC3_CTXT_LEN,
 780                                                 1);
 781
 782                         /* Indicate this descriptor contains the MSS */
 783                         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 784                                                 dma_desc->desc3,
 785                                                 TX_CONTEXT_DESC3_TCMSSV_POS,
 786                                                 TX_CONTEXT_DESC3_TCMSSV_LEN,
 787                                                 1);
 788
 789                         ring->tx.cur_mss = pkt_info->mss;
 790                 }
 791
 792                 if (vlan_context) {
 793                         netif_dbg(pdata, tx_queued, pdata->netdev,
 794                                   "VLAN context descriptor, ctag=%u\n",
 795                                   pkt_info->vlan_ctag);
 796
 797                         /* Mark it as a CONTEXT descriptor */
 798                         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 799                                                 dma_desc->desc3,
 800                                                 TX_CONTEXT_DESC3_CTXT_POS,
 801                                                 TX_CONTEXT_DESC3_CTXT_LEN,
 802                                                 1);
 803
 804                         /* Set the VLAN tag */
 805                         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 806                                                 dma_desc->desc3,
 807                                                 TX_CONTEXT_DESC3_VT_POS,
 808                                                 TX_CONTEXT_DESC3_VT_LEN,
 809                                                 pkt_info->vlan_ctag);
 810
 811                         /* Indicate this descriptor contains the VLAN tag */
 812                         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 813                                                 dma_desc->desc3,
 814                                                 TX_CONTEXT_DESC3_VLTV_POS,
 815                                                 TX_CONTEXT_DESC3_VLTV_LEN,
 816                                                 1);
 817
 818                         ring->tx.cur_vlan_ctag = pkt_info->vlan_ctag;
 819                 }
 820
 821                 cur_index++;
 822                 desc_data = XLGMAC_GET_DESC_DATA(ring, cur_index);
 823                 dma_desc = desc_data->dma_desc;
 824         }
 825
 826         /* Update buffer address (for TSO this is the header) */
 827         dma_desc->desc0 =  cpu_to_le32(lower_32_bits(desc_data->skb_dma));
 828         dma_desc->desc1 =  cpu_to_le32(upper_32_bits(desc_data->skb_dma));
 829
 830         /* Update the buffer length */
 831         dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
 832                                 dma_desc->desc2,
 833                                 TX_NORMAL_DESC2_HL_B1L_POS,
 834                                 TX_NORMAL_DESC2_HL_B1L_LEN,
 835                                 desc_data->skb_dma_len);
 836
 837         /* VLAN tag insertion check */
 838         if (vlan) {
 839                 dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
 840                                         dma_desc->desc2,
 841                                         TX_NORMAL_DESC2_VTIR_POS,
 842                                         TX_NORMAL_DESC2_VTIR_LEN,
 843                                         TX_NORMAL_DESC2_VLAN_INSERT);
 844                 pdata->stats.tx_vlan_packets++;
 845         }
 846
 847         /* Timestamp enablement check */
 848         if (XLGMAC_GET_REG_BITS(pkt_info->attributes,
 849                                 TX_PACKET_ATTRIBUTES_PTP_POS,
 850                                 TX_PACKET_ATTRIBUTES_PTP_LEN))
 851                 dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
 852                                         dma_desc->desc2,
 853                                         TX_NORMAL_DESC2_TTSE_POS,
 854                                         TX_NORMAL_DESC2_TTSE_LEN,
 855                                         1);
 856
 857         /* Mark it as First Descriptor */
 858         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 859                                 dma_desc->desc3,
 860                                 TX_NORMAL_DESC3_FD_POS,
 861                                 TX_NORMAL_DESC3_FD_LEN,
 862                                 1);
 863
 864         /* Mark it as a NORMAL descriptor */
 865         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 866                                 dma_desc->desc3,
 867                                 TX_NORMAL_DESC3_CTXT_POS,
 868                                 TX_NORMAL_DESC3_CTXT_LEN,
 869                                 0);
 870
 871         /* Set OWN bit if not the first descriptor */
 872         if (cur_index != start_index)
 873                 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 874                                         dma_desc->desc3,
 875                                         TX_NORMAL_DESC3_OWN_POS,
 876                                         TX_NORMAL_DESC3_OWN_LEN,
 877                                         1);
 878
 879         if (tso) {
 880                 /* Enable TSO */
 881                 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 882                                         dma_desc->desc3,
 883                                         TX_NORMAL_DESC3_TSE_POS,
 884                                         TX_NORMAL_DESC3_TSE_LEN, 1);
 885                 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 886                                         dma_desc->desc3,
 887                                         TX_NORMAL_DESC3_TCPPL_POS,
 888                                         TX_NORMAL_DESC3_TCPPL_LEN,
 889                                         pkt_info->tcp_payload_len);
 890                 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 891                                         dma_desc->desc3,
 892                                         TX_NORMAL_DESC3_TCPHDRLEN_POS,
 893                                         TX_NORMAL_DESC3_TCPHDRLEN_LEN,
 894                                         pkt_info->tcp_header_len / 4);
 895
 896                 pdata->stats.tx_tso_packets++;
 897         } else {
 898                 /* Enable CRC and Pad Insertion */
 899                 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 900                                         dma_desc->desc3,
 901                                         TX_NORMAL_DESC3_CPC_POS,
 902                                         TX_NORMAL_DESC3_CPC_LEN, 0);
 903
 904                 /* Enable HW CSUM */
 905                 if (csum)
 906                         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 907                                                 dma_desc->desc3,
 908                                                 TX_NORMAL_DESC3_CIC_POS,
 909                                                 TX_NORMAL_DESC3_CIC_LEN,
 910                                                 0x3);
 911
 912                 /* Set the total length to be transmitted */
 913                 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 914                                         dma_desc->desc3,
 915                                         TX_NORMAL_DESC3_FL_POS,
 916                                         TX_NORMAL_DESC3_FL_LEN,
 917                                         pkt_info->length);
 918         }
 919
 920         for (i = cur_index - start_index + 1; i < pkt_info->desc_count; i++) {
 921                 cur_index++;
 922                 desc_data = XLGMAC_GET_DESC_DATA(ring, cur_index);
 923                 dma_desc = desc_data->dma_desc;
 924
 925                 /* Update buffer address */
 926                 dma_desc->desc0 =
 927                         cpu_to_le32(lower_32_bits(desc_data->skb_dma));
 928                 dma_desc->desc1 =
 929                         cpu_to_le32(upper_32_bits(desc_data->skb_dma));
 930
 931                 /* Update the buffer length */
 932                 dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
 933                                         dma_desc->desc2,
 934                                         TX_NORMAL_DESC2_HL_B1L_POS,
 935                                         TX_NORMAL_DESC2_HL_B1L_LEN,
 936                                         desc_data->skb_dma_len);
 937
 938                 /* Set OWN bit */
 939                 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 940                                         dma_desc->desc3,
 941                                         TX_NORMAL_DESC3_OWN_POS,
 942                                         TX_NORMAL_DESC3_OWN_LEN, 1);
 943
 944                 /* Mark it as NORMAL descriptor */
 945                 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 946                                         dma_desc->desc3,
 947                                         TX_NORMAL_DESC3_CTXT_POS,
 948                                         TX_NORMAL_DESC3_CTXT_LEN, 0);
 949
 950                 /* Enable HW CSUM */
 951                 if (csum)
 952                         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 953                                                 dma_desc->desc3,
 954                                                 TX_NORMAL_DESC3_CIC_POS,
 955                                                 TX_NORMAL_DESC3_CIC_LEN,
 956                                                 0x3);
 957         }
 958
 959         /* Set LAST bit for the last descriptor */
 960         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 961                                 dma_desc->desc3,
 962                                 TX_NORMAL_DESC3_LD_POS,
 963                                 TX_NORMAL_DESC3_LD_LEN, 1);
 964
 965         /* Set IC bit based on Tx coalescing settings */
 966         if (tx_set_ic)
 967                 dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
 968                                         dma_desc->desc2,
 969                                         TX_NORMAL_DESC2_IC_POS,
 970                                         TX_NORMAL_DESC2_IC_LEN, 1);
 971
 972         /* Save the Tx info to report back during cleanup */
 973         desc_data->tx.packets = pkt_info->tx_packets;
 974         desc_data->tx.bytes = pkt_info->tx_bytes;
 975
 976         /* In case the Tx DMA engine is running, make sure everything
 977          * is written to the descriptor(s) before setting the OWN bit
 978          * for the first descriptor
 979          */
 980         dma_wmb();
 981
 982         /* Set OWN bit for the first descriptor */
 983         desc_data = XLGMAC_GET_DESC_DATA(ring, start_index);
 984         dma_desc = desc_data->dma_desc;
 985         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
 986                                 dma_desc->desc3,
 987                                 TX_NORMAL_DESC3_OWN_POS,
 988                                 TX_NORMAL_DESC3_OWN_LEN, 1);
 989
 990         if (netif_msg_tx_queued(pdata))
 991                 xlgmac_dump_tx_desc(pdata, ring, start_index,
 992                                     pkt_info->desc_count, 1);
 993
 994         /* Make sure ownership is written to the descriptor */
 995         smp_wmb();
 996
 997         ring->cur = cur_index + 1;
 998         if (!netdev_xmit_more() ||
 999             netif_xmit_stopped(netdev_get_tx_queue(pdata->netdev,
1000                                                    channel->queue_index)))
1001                 xlgmac_tx_start_xmit(channel, ring);
1002         else
1003                 ring->tx.xmit_more = 1;
1004
1005         XLGMAC_PR("%s: descriptors %u to %u written\n",
1006                   channel->name, start_index & (ring->dma_desc_count - 1),
1007                   (ring->cur - 1) & (ring->dma_desc_count - 1));
1008 }
1009
1010 static void xlgmac_get_rx_tstamp(struct xlgmac_pkt_info *pkt_info,
1011                                  struct xlgmac_dma_desc *dma_desc)
1012 {
1013         u32 tsa, tsd;
1014         u64 nsec;
1015
1016         tsa = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
1017                                      RX_CONTEXT_DESC3_TSA_POS,
1018                                 RX_CONTEXT_DESC3_TSA_LEN);
1019         tsd = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
1020                                      RX_CONTEXT_DESC3_TSD_POS,
1021                                 RX_CONTEXT_DESC3_TSD_LEN);
1022         if (tsa && !tsd) {
1023                 nsec = le32_to_cpu(dma_desc->desc1);
1024                 nsec <<= 32;
1025                 nsec |= le32_to_cpu(dma_desc->desc0);
1026                 if (nsec != 0xffffffffffffffffULL) {
1027                         pkt_info->rx_tstamp = nsec;
1028                         pkt_info->attributes = XLGMAC_SET_REG_BITS(
1029                                         pkt_info->attributes,
1030                                         RX_PACKET_ATTRIBUTES_RX_TSTAMP_POS,
1031                                         RX_PACKET_ATTRIBUTES_RX_TSTAMP_LEN,
1032                                         1);
1033                 }
1034         }
1035 }
1036
1037 static void xlgmac_tx_desc_reset(struct xlgmac_desc_data *desc_data)
1038 {
1039         struct xlgmac_dma_desc *dma_desc = desc_data->dma_desc;
1040
1041         /* Reset the Tx descriptor
1042          *   Set buffer 1 (lo) address to zero
1043          *   Set buffer 1 (hi) address to zero
1044          *   Reset all other control bits (IC, TTSE, B2L & B1L)
1045          *   Reset all other control bits (OWN, CTXT, FD, LD, CPC, CIC, etc)
1046          */
1047         dma_desc->desc0 = 0;
1048         dma_desc->desc1 = 0;
1049         dma_desc->desc2 = 0;
1050         dma_desc->desc3 = 0;
1051
1052         /* Make sure ownership is written to the descriptor */
1053         dma_wmb();
1054 }
1055
1056 static void xlgmac_tx_desc_init(struct xlgmac_channel *channel)
1057 {
1058         struct xlgmac_ring *ring = channel->tx_ring;
1059         struct xlgmac_desc_data *desc_data;
1060         int start_index = ring->cur;
1061         int i;
1062
1063         /* Initialze all descriptors */
1064         for (i = 0; i < ring->dma_desc_count; i++) {
1065                 desc_data = XLGMAC_GET_DESC_DATA(ring, i);
1066
1067                 /* Initialize Tx descriptor */
1068                 xlgmac_tx_desc_reset(desc_data);
1069         }
1070
1071         /* Update the total number of Tx descriptors */
1072         writel(ring->dma_desc_count - 1, XLGMAC_DMA_REG(channel, DMA_CH_TDRLR));
1073
1074         /* Update the starting address of descriptor ring */
1075         desc_data = XLGMAC_GET_DESC_DATA(ring, start_index);
1076         writel(upper_32_bits(desc_data->dma_desc_addr),
1077                XLGMAC_DMA_REG(channel, DMA_CH_TDLR_HI));
1078         writel(lower_32_bits(desc_data->dma_desc_addr),
1079                XLGMAC_DMA_REG(channel, DMA_CH_TDLR_LO));
1080 }
1081
1082 static void xlgmac_rx_desc_reset(struct xlgmac_pdata *pdata,
1083                                  struct xlgmac_desc_data *desc_data,
1084                                  unsigned int index)
1085 {
1086         struct xlgmac_dma_desc *dma_desc = desc_data->dma_desc;
1087         unsigned int rx_frames = pdata->rx_frames;
1088         unsigned int rx_usecs = pdata->rx_usecs;
1089         dma_addr_t hdr_dma, buf_dma;
1090         unsigned int inte;
1091
1092         if (!rx_usecs && !rx_frames) {
1093                 /* No coalescing, interrupt for every descriptor */
1094                 inte = 1;
1095         } else {
1096                 /* Set interrupt based on Rx frame coalescing setting */
1097                 if (rx_frames && !((index + 1) % rx_frames))
1098                         inte = 1;
1099                 else
1100                         inte = 0;
1101         }
1102
1103         /* Reset the Rx descriptor
1104          *   Set buffer 1 (lo) address to header dma address (lo)
1105          *   Set buffer 1 (hi) address to header dma address (hi)
1106          *   Set buffer 2 (lo) address to buffer dma address (lo)
1107          *   Set buffer 2 (hi) address to buffer dma address (hi) and
1108          *     set control bits OWN and INTE
1109          */
1110         hdr_dma = desc_data->rx.hdr.dma_base + desc_data->rx.hdr.dma_off;
1111         buf_dma = desc_data->rx.buf.dma_base + desc_data->rx.buf.dma_off;
1112         dma_desc->desc0 = cpu_to_le32(lower_32_bits(hdr_dma));
1113         dma_desc->desc1 = cpu_to_le32(upper_32_bits(hdr_dma));
1114         dma_desc->desc2 = cpu_to_le32(lower_32_bits(buf_dma));
1115         dma_desc->desc3 = cpu_to_le32(upper_32_bits(buf_dma));
1116
1117         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
1118                                 dma_desc->desc3,
1119                                 RX_NORMAL_DESC3_INTE_POS,
1120                                 RX_NORMAL_DESC3_INTE_LEN,
1121                                 inte);
1122
1123         /* Since the Rx DMA engine is likely running, make sure everything
1124          * is written to the descriptor(s) before setting the OWN bit
1125          * for the descriptor
1126          */
1127         dma_wmb();
1128
1129         dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
1130                                 dma_desc->desc3,
1131                                 RX_NORMAL_DESC3_OWN_POS,
1132                                 RX_NORMAL_DESC3_OWN_LEN,
1133                                 1);
1134
1135         /* Make sure ownership is written to the descriptor */
1136         dma_wmb();
1137 }
1138
1139 static void xlgmac_rx_desc_init(struct xlgmac_channel *channel)
1140 {
1141         struct xlgmac_pdata *pdata = channel->pdata;
1142         struct xlgmac_ring *ring = channel->rx_ring;
1143         unsigned int start_index = ring->cur;
1144         struct xlgmac_desc_data *desc_data;
1145         unsigned int i;
1146
1147         /* Initialize all descriptors */
1148         for (i = 0; i < ring->dma_desc_count; i++) {
1149                 desc_data = XLGMAC_GET_DESC_DATA(ring, i);
1150
1151                 /* Initialize Rx descriptor */
1152                 xlgmac_rx_desc_reset(pdata, desc_data, i);
1153         }
1154
1155         /* Update the total number of Rx descriptors */
1156         writel(ring->dma_desc_count - 1, XLGMAC_DMA_REG(channel, DMA_CH_RDRLR));
1157
1158         /* Update the starting address of descriptor ring */
1159         desc_data = XLGMAC_GET_DESC_DATA(ring, start_index);
1160         writel(upper_32_bits(desc_data->dma_desc_addr),
1161                XLGMAC_DMA_REG(channel, DMA_CH_RDLR_HI));
1162         writel(lower_32_bits(desc_data->dma_desc_addr),
1163                XLGMAC_DMA_REG(channel, DMA_CH_RDLR_LO));
1164
1165         /* Update the Rx Descriptor Tail Pointer */
1166         desc_data = XLGMAC_GET_DESC_DATA(ring, start_index +
1167                                           ring->dma_desc_count - 1);
1168         writel(lower_32_bits(desc_data->dma_desc_addr),
1169                XLGMAC_DMA_REG(channel, DMA_CH_RDTR_LO));
1170 }
1171
1172 static int xlgmac_is_context_desc(struct xlgmac_dma_desc *dma_desc)
1173 {
1174         /* Rx and Tx share CTXT bit, so check TDES3.CTXT bit */
1175         return XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
1176                                 TX_NORMAL_DESC3_CTXT_POS,
1177                                 TX_NORMAL_DESC3_CTXT_LEN);
1178 }
1179
1180 static int xlgmac_is_last_desc(struct xlgmac_dma_desc *dma_desc)
1181 {
1182         /* Rx and Tx share LD bit, so check TDES3.LD bit */
1183         return XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
1184                                 TX_NORMAL_DESC3_LD_POS,
1185                                 TX_NORMAL_DESC3_LD_LEN);
1186 }
1187
1188 static int xlgmac_disable_tx_flow_control(struct xlgmac_pdata *pdata)
1189 {
1190         unsigned int max_q_count, q_count;
1191         unsigned int reg, regval;
1192         unsigned int i;
1193
1194         /* Clear MTL flow control */
1195         for (i = 0; i < pdata->rx_q_count; i++) {
1196                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1197                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_EHFC_POS,
1198                                              MTL_Q_RQOMR_EHFC_LEN, 0);
1199                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1200         }
1201
1202         /* Clear MAC flow control */
1203         max_q_count = XLGMAC_MAX_FLOW_CONTROL_QUEUES;
1204         q_count = min_t(unsigned int, pdata->tx_q_count, max_q_count);
1205         reg = MAC_Q0TFCR;
1206         for (i = 0; i < q_count; i++) {
1207                 regval = readl(pdata->mac_regs + reg);
1208                 regval = XLGMAC_SET_REG_BITS(regval,
1209                                              MAC_Q0TFCR_TFE_POS,
1210                                         MAC_Q0TFCR_TFE_LEN,
1211                                         0);
1212                 writel(regval, pdata->mac_regs + reg);
1213
1214                 reg += MAC_QTFCR_INC;
1215         }
1216
1217         return 0;
1218 }
1219
1220 static int xlgmac_enable_tx_flow_control(struct xlgmac_pdata *pdata)
1221 {
1222         unsigned int max_q_count, q_count;
1223         unsigned int reg, regval;
1224         unsigned int i;
1225
1226         /* Set MTL flow control */
1227         for (i = 0; i < pdata->rx_q_count; i++) {
1228                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1229                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_EHFC_POS,
1230                                              MTL_Q_RQOMR_EHFC_LEN, 1);
1231                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1232         }
1233
1234         /* Set MAC flow control */
1235         max_q_count = XLGMAC_MAX_FLOW_CONTROL_QUEUES;
1236         q_count = min_t(unsigned int, pdata->tx_q_count, max_q_count);
1237         reg = MAC_Q0TFCR;
1238         for (i = 0; i < q_count; i++) {
1239                 regval = readl(pdata->mac_regs + reg);
1240
1241                 /* Enable transmit flow control */
1242                 regval = XLGMAC_SET_REG_BITS(regval, MAC_Q0TFCR_TFE_POS,
1243                                              MAC_Q0TFCR_TFE_LEN, 1);
1244                 /* Set pause time */
1245                 regval = XLGMAC_SET_REG_BITS(regval, MAC_Q0TFCR_PT_POS,
1246                                              MAC_Q0TFCR_PT_LEN, 0xffff);
1247
1248                 writel(regval, pdata->mac_regs + reg);
1249
1250                 reg += MAC_QTFCR_INC;
1251         }
1252
1253         return 0;
1254 }
1255
1256 static int xlgmac_disable_rx_flow_control(struct xlgmac_pdata *pdata)
1257 {
1258         u32 regval;
1259
1260         regval = readl(pdata->mac_regs + MAC_RFCR);
1261         regval = XLGMAC_SET_REG_BITS(regval, MAC_RFCR_RFE_POS,
1262                                      MAC_RFCR_RFE_LEN, 0);
1263         writel(regval, pdata->mac_regs + MAC_RFCR);
1264
1265         return 0;
1266 }
1267
1268 static int xlgmac_enable_rx_flow_control(struct xlgmac_pdata *pdata)
1269 {
1270         u32 regval;
1271
1272         regval = readl(pdata->mac_regs + MAC_RFCR);
1273         regval = XLGMAC_SET_REG_BITS(regval, MAC_RFCR_RFE_POS,
1274                                      MAC_RFCR_RFE_LEN, 1);
1275         writel(regval, pdata->mac_regs + MAC_RFCR);
1276
1277         return 0;
1278 }
1279
1280 static int xlgmac_config_tx_flow_control(struct xlgmac_pdata *pdata)
1281 {
1282         if (pdata->tx_pause)
1283                 xlgmac_enable_tx_flow_control(pdata);
1284         else
1285                 xlgmac_disable_tx_flow_control(pdata);
1286
1287         return 0;
1288 }
1289
1290 static int xlgmac_config_rx_flow_control(struct xlgmac_pdata *pdata)
1291 {
1292         if (pdata->rx_pause)
1293                 xlgmac_enable_rx_flow_control(pdata);
1294         else
1295                 xlgmac_disable_rx_flow_control(pdata);
1296
1297         return 0;
1298 }
1299
1300 static int xlgmac_config_rx_coalesce(struct xlgmac_pdata *pdata)
1301 {
1302         struct xlgmac_channel *channel;
1303         unsigned int i;
1304         u32 regval;
1305
1306         channel = pdata->channel_head;
1307         for (i = 0; i < pdata->channel_count; i++, channel++) {
1308                 if (!channel->rx_ring)
1309                         break;
1310
1311                 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_RIWT));
1312                 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_RIWT_RWT_POS,
1313                                              DMA_CH_RIWT_RWT_LEN,
1314                                              pdata->rx_riwt);
1315                 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_RIWT));
1316         }
1317
1318         return 0;
1319 }
1320
1321 static void xlgmac_config_flow_control(struct xlgmac_pdata *pdata)
1322 {
1323         xlgmac_config_tx_flow_control(pdata);
1324         xlgmac_config_rx_flow_control(pdata);
1325 }
1326
1327 static void xlgmac_config_rx_fep_enable(struct xlgmac_pdata *pdata)
1328 {
1329         unsigned int i;
1330         u32 regval;
1331
1332         for (i = 0; i < pdata->rx_q_count; i++) {
1333                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1334                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_FEP_POS,
1335                                              MTL_Q_RQOMR_FEP_LEN, 1);
1336                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1337         }
1338 }
1339
1340 static void xlgmac_config_rx_fup_enable(struct xlgmac_pdata *pdata)
1341 {
1342         unsigned int i;
1343         u32 regval;
1344
1345         for (i = 0; i < pdata->rx_q_count; i++) {
1346                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1347                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_FUP_POS,
1348                                              MTL_Q_RQOMR_FUP_LEN, 1);
1349                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1350         }
1351 }
1352
1353 static int xlgmac_config_tx_coalesce(struct xlgmac_pdata *pdata)
1354 {
1355         return 0;
1356 }
1357
1358 static void xlgmac_config_rx_buffer_size(struct xlgmac_pdata *pdata)
1359 {
1360         struct xlgmac_channel *channel;
1361         unsigned int i;
1362         u32 regval;
1363
1364         channel = pdata->channel_head;
1365         for (i = 0; i < pdata->channel_count; i++, channel++) {
1366                 if (!channel->rx_ring)
1367                         break;
1368
1369                 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_RCR));
1370                 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_RCR_RBSZ_POS,
1371                                              DMA_CH_RCR_RBSZ_LEN,
1372                                         pdata->rx_buf_size);
1373                 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_RCR));
1374         }
1375 }
1376
1377 static void xlgmac_config_tso_mode(struct xlgmac_pdata *pdata)
1378 {
1379         struct xlgmac_channel *channel;
1380         unsigned int i;
1381         u32 regval;
1382
1383         channel = pdata->channel_head;
1384         for (i = 0; i < pdata->channel_count; i++, channel++) {
1385                 if (!channel->tx_ring)
1386                         break;
1387
1388                 if (pdata->hw_feat.tso) {
1389                         regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1390                         regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_TCR_TSE_POS,
1391                                                      DMA_CH_TCR_TSE_LEN, 1);
1392                         writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1393                 }
1394         }
1395 }
1396
1397 static void xlgmac_config_sph_mode(struct xlgmac_pdata *pdata)
1398 {
1399         struct xlgmac_channel *channel;
1400         unsigned int i;
1401         u32 regval;
1402
1403         channel = pdata->channel_head;
1404         for (i = 0; i < pdata->channel_count; i++, channel++) {
1405                 if (!channel->rx_ring)
1406                         break;
1407
1408                 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_CR));
1409                 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_CR_SPH_POS,
1410                                              DMA_CH_CR_SPH_LEN, 1);
1411                 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_CR));
1412         }
1413
1414         regval = readl(pdata->mac_regs + MAC_RCR);
1415         regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_HDSMS_POS,
1416                                      MAC_RCR_HDSMS_LEN,
1417                                 XLGMAC_SPH_HDSMS_SIZE);
1418         writel(regval, pdata->mac_regs + MAC_RCR);
1419 }
1420
1421 static unsigned int xlgmac_usec_to_riwt(struct xlgmac_pdata *pdata,
1422                                         unsigned int usec)
1423 {
1424         unsigned long rate;
1425         unsigned int ret;
1426
1427         rate = pdata->sysclk_rate;
1428
1429         /* Convert the input usec value to the watchdog timer value. Each
1430          * watchdog timer value is equivalent to 256 clock cycles.
1431          * Calculate the required value as:
1432          *   ( usec * ( system_clock_mhz / 10^6 ) / 256
1433          */
1434         ret = (usec * (rate / 1000000)) / 256;
1435
1436         return ret;
1437 }
1438
1439 static unsigned int xlgmac_riwt_to_usec(struct xlgmac_pdata *pdata,
1440                                         unsigned int riwt)
1441 {
1442         unsigned long rate;
1443         unsigned int ret;
1444
1445         rate = pdata->sysclk_rate;
1446
1447         /* Convert the input watchdog timer value to the usec value. Each
1448          * watchdog timer value is equivalent to 256 clock cycles.
1449          * Calculate the required value as:
1450          *   ( riwt * 256 ) / ( system_clock_mhz / 10^6 )
1451          */
1452         ret = (riwt * 256) / (rate / 1000000);
1453
1454         return ret;
1455 }
1456
1457 static int xlgmac_config_rx_threshold(struct xlgmac_pdata *pdata,
1458                                       unsigned int val)
1459 {
1460         unsigned int i;
1461         u32 regval;
1462
1463         for (i = 0; i < pdata->rx_q_count; i++) {
1464                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1465                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_RTC_POS,
1466                                              MTL_Q_RQOMR_RTC_LEN, val);
1467                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1468         }
1469
1470         return 0;
1471 }
1472
1473 static void xlgmac_config_mtl_mode(struct xlgmac_pdata *pdata)
1474 {
1475         unsigned int i;
1476         u32 regval;
1477
1478         /* Set Tx to weighted round robin scheduling algorithm */
1479         regval = readl(pdata->mac_regs + MTL_OMR);
1480         regval = XLGMAC_SET_REG_BITS(regval, MTL_OMR_ETSALG_POS,
1481                                      MTL_OMR_ETSALG_LEN, MTL_ETSALG_WRR);
1482         writel(regval, pdata->mac_regs + MTL_OMR);
1483
1484         /* Set Tx traffic classes to use WRR algorithm with equal weights */
1485         for (i = 0; i < pdata->hw_feat.tc_cnt; i++) {
1486                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_TC_ETSCR));
1487                 regval = XLGMAC_SET_REG_BITS(regval, MTL_TC_ETSCR_TSA_POS,
1488                                              MTL_TC_ETSCR_TSA_LEN, MTL_TSA_ETS);
1489                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_TC_ETSCR));
1490
1491                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_TC_QWR));
1492                 regval = XLGMAC_SET_REG_BITS(regval, MTL_TC_QWR_QW_POS,
1493                                              MTL_TC_QWR_QW_LEN, 1);
1494                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_TC_QWR));
1495         }
1496
1497         /* Set Rx to strict priority algorithm */
1498         regval = readl(pdata->mac_regs + MTL_OMR);
1499         regval = XLGMAC_SET_REG_BITS(regval, MTL_OMR_RAA_POS,
1500                                      MTL_OMR_RAA_LEN, MTL_RAA_SP);
1501         writel(regval, pdata->mac_regs + MTL_OMR);
1502 }
1503
1504 static void xlgmac_config_queue_mapping(struct xlgmac_pdata *pdata)
1505 {
1506         unsigned int ppq, ppq_extra, prio, prio_queues;
1507         unsigned int qptc, qptc_extra, queue;
1508         unsigned int reg, regval;
1509         unsigned int mask;
1510         unsigned int i, j;
1511
1512         /* Map the MTL Tx Queues to Traffic Classes
1513          *   Note: Tx Queues >= Traffic Classes
1514          */
1515         qptc = pdata->tx_q_count / pdata->hw_feat.tc_cnt;
1516         qptc_extra = pdata->tx_q_count % pdata->hw_feat.tc_cnt;
1517
1518         for (i = 0, queue = 0; i < pdata->hw_feat.tc_cnt; i++) {
1519                 for (j = 0; j < qptc; j++) {
1520                         netif_dbg(pdata, drv, pdata->netdev,
1521                                   "TXq%u mapped to TC%u\n", queue, i);
1522                         regval = readl(XLGMAC_MTL_REG(pdata, queue,
1523                                                       MTL_Q_TQOMR));
1524                         regval = XLGMAC_SET_REG_BITS(regval,
1525                                                      MTL_Q_TQOMR_Q2TCMAP_POS,
1526                                                      MTL_Q_TQOMR_Q2TCMAP_LEN,
1527                                                      i);
1528                         writel(regval, XLGMAC_MTL_REG(pdata, queue,
1529                                                       MTL_Q_TQOMR));
1530                         queue++;
1531                 }
1532
1533                 if (i < qptc_extra) {
1534                         netif_dbg(pdata, drv, pdata->netdev,
1535                                   "TXq%u mapped to TC%u\n", queue, i);
1536                         regval = readl(XLGMAC_MTL_REG(pdata, queue,
1537                                                       MTL_Q_TQOMR));
1538                         regval = XLGMAC_SET_REG_BITS(regval,
1539                                                      MTL_Q_TQOMR_Q2TCMAP_POS,
1540                                                      MTL_Q_TQOMR_Q2TCMAP_LEN,
1541                                                      i);
1542                         writel(regval, XLGMAC_MTL_REG(pdata, queue,
1543                                                       MTL_Q_TQOMR));
1544                         queue++;
1545                 }
1546         }
1547
1548         /* Map the 8 VLAN priority values to available MTL Rx queues */
1549         prio_queues = min_t(unsigned int, IEEE_8021QAZ_MAX_TCS,
1550                             pdata->rx_q_count);
1551         ppq = IEEE_8021QAZ_MAX_TCS / prio_queues;
1552         ppq_extra = IEEE_8021QAZ_MAX_TCS % prio_queues;
1553
1554         reg = MAC_RQC2R;
1555         regval = 0;
1556         for (i = 0, prio = 0; i < prio_queues;) {
1557                 mask = 0;
1558                 for (j = 0; j < ppq; j++) {
1559                         netif_dbg(pdata, drv, pdata->netdev,
1560                                   "PRIO%u mapped to RXq%u\n", prio, i);
1561                         mask |= (1 << prio);
1562                         prio++;
1563                 }
1564
1565                 if (i < ppq_extra) {
1566                         netif_dbg(pdata, drv, pdata->netdev,
1567                                   "PRIO%u mapped to RXq%u\n", prio, i);
1568                         mask |= (1 << prio);
1569                         prio++;
1570                 }
1571
1572                 regval |= (mask << ((i++ % MAC_RQC2_Q_PER_REG) << 3));
1573
1574                 if ((i % MAC_RQC2_Q_PER_REG) && (i != prio_queues))
1575                         continue;
1576
1577                 writel(regval, pdata->mac_regs + reg);
1578                 reg += MAC_RQC2_INC;
1579                 regval = 0;
1580         }
1581
1582         /* Configure one to one, MTL Rx queue to DMA Rx channel mapping
1583          *  ie Q0 <--> CH0, Q1 <--> CH1 ... Q11 <--> CH11
1584          */
1585         reg = MTL_RQDCM0R;
1586         regval = readl(pdata->mac_regs + reg);
1587         regval |= (MTL_RQDCM0R_Q0MDMACH | MTL_RQDCM0R_Q1MDMACH |
1588                     MTL_RQDCM0R_Q2MDMACH | MTL_RQDCM0R_Q3MDMACH);
1589         writel(regval, pdata->mac_regs + reg);
1590
1591         reg += MTL_RQDCM_INC;
1592         regval = readl(pdata->mac_regs + reg);
1593         regval |= (MTL_RQDCM1R_Q4MDMACH | MTL_RQDCM1R_Q5MDMACH |
1594                     MTL_RQDCM1R_Q6MDMACH | MTL_RQDCM1R_Q7MDMACH);
1595         writel(regval, pdata->mac_regs + reg);
1596
1597         reg += MTL_RQDCM_INC;
1598         regval = readl(pdata->mac_regs + reg);
1599         regval |= (MTL_RQDCM2R_Q8MDMACH | MTL_RQDCM2R_Q9MDMACH |
1600                     MTL_RQDCM2R_Q10MDMACH | MTL_RQDCM2R_Q11MDMACH);
1601         writel(regval, pdata->mac_regs + reg);
1602 }
1603
1604 static unsigned int xlgmac_calculate_per_queue_fifo(
1605                                         unsigned int fifo_size,
1606                                         unsigned int queue_count)
1607 {
1608         unsigned int q_fifo_size;
1609         unsigned int p_fifo;
1610
1611         /* Calculate the configured fifo size */
1612         q_fifo_size = 1 << (fifo_size + 7);
1613
1614         /* The configured value may not be the actual amount of fifo RAM */
1615         q_fifo_size = min_t(unsigned int, XLGMAC_MAX_FIFO, q_fifo_size);
1616
1617         q_fifo_size = q_fifo_size / queue_count;
1618
1619         /* Each increment in the queue fifo size represents 256 bytes of
1620          * fifo, with 0 representing 256 bytes. Distribute the fifo equally
1621          * between the queues.
1622          */
1623         p_fifo = q_fifo_size / 256;
1624         if (p_fifo)
1625                 p_fifo--;
1626
1627         return p_fifo;
1628 }
1629
1630 static void xlgmac_config_tx_fifo_size(struct xlgmac_pdata *pdata)
1631 {
1632         unsigned int fifo_size;
1633         unsigned int i;
1634         u32 regval;
1635
1636         fifo_size = xlgmac_calculate_per_queue_fifo(
1637                                 pdata->hw_feat.tx_fifo_size,
1638                                 pdata->tx_q_count);
1639
1640         for (i = 0; i < pdata->tx_q_count; i++) {
1641                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1642                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_TQS_POS,
1643                                              MTL_Q_TQOMR_TQS_LEN, fifo_size);
1644                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1645         }
1646
1647         netif_info(pdata, drv, pdata->netdev,
1648                    "%d Tx hardware queues, %d byte fifo per queue\n",
1649                    pdata->tx_q_count, ((fifo_size + 1) * 256));
1650 }
1651
1652 static void xlgmac_config_rx_fifo_size(struct xlgmac_pdata *pdata)
1653 {
1654         unsigned int fifo_size;
1655         unsigned int i;
1656         u32 regval;
1657
1658         fifo_size = xlgmac_calculate_per_queue_fifo(
1659                                         pdata->hw_feat.rx_fifo_size,
1660                                         pdata->rx_q_count);
1661
1662         for (i = 0; i < pdata->rx_q_count; i++) {
1663                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1664                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_RQS_POS,
1665                                              MTL_Q_RQOMR_RQS_LEN, fifo_size);
1666                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1667         }
1668
1669         netif_info(pdata, drv, pdata->netdev,
1670                    "%d Rx hardware queues, %d byte fifo per queue\n",
1671                    pdata->rx_q_count, ((fifo_size + 1) * 256));
1672 }
1673
1674 static void xlgmac_config_flow_control_threshold(struct xlgmac_pdata *pdata)
1675 {
1676         unsigned int i;
1677         u32 regval;
1678
1679         for (i = 0; i < pdata->rx_q_count; i++) {
1680                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQFCR));
1681                 /* Activate flow control when less than 4k left in fifo */
1682                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQFCR_RFA_POS,
1683                                              MTL_Q_RQFCR_RFA_LEN, 2);
1684                 /* De-activate flow control when more than 6k left in fifo */
1685                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQFCR_RFD_POS,
1686                                              MTL_Q_RQFCR_RFD_LEN, 4);
1687                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQFCR));
1688         }
1689 }
1690
1691 static int xlgmac_config_tx_threshold(struct xlgmac_pdata *pdata,
1692                                       unsigned int val)
1693 {
1694         unsigned int i;
1695         u32 regval;
1696
1697         for (i = 0; i < pdata->tx_q_count; i++) {
1698                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1699                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_TTC_POS,
1700                                              MTL_Q_TQOMR_TTC_LEN, val);
1701                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1702         }
1703
1704         return 0;
1705 }
1706
1707 static int xlgmac_config_rsf_mode(struct xlgmac_pdata *pdata,
1708                                   unsigned int val)
1709 {
1710         unsigned int i;
1711         u32 regval;
1712
1713         for (i = 0; i < pdata->rx_q_count; i++) {
1714                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1715                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_RSF_POS,
1716                                              MTL_Q_RQOMR_RSF_LEN, val);
1717                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1718         }
1719
1720         return 0;
1721 }
1722
1723 static int xlgmac_config_tsf_mode(struct xlgmac_pdata *pdata,
1724                                   unsigned int val)
1725 {
1726         unsigned int i;
1727         u32 regval;
1728
1729         for (i = 0; i < pdata->tx_q_count; i++) {
1730                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1731                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_TSF_POS,
1732                                              MTL_Q_TQOMR_TSF_LEN, val);
1733                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1734         }
1735
1736         return 0;
1737 }
1738
1739 static int xlgmac_config_osp_mode(struct xlgmac_pdata *pdata)
1740 {
1741         struct xlgmac_channel *channel;
1742         unsigned int i;
1743         u32 regval;
1744
1745         channel = pdata->channel_head;
1746         for (i = 0; i < pdata->channel_count; i++, channel++) {
1747                 if (!channel->tx_ring)
1748                         break;
1749
1750                 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1751                 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_TCR_OSP_POS,
1752                                              DMA_CH_TCR_OSP_LEN,
1753                                         pdata->tx_osp_mode);
1754                 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1755         }
1756
1757         return 0;
1758 }
1759
1760 static int xlgmac_config_pblx8(struct xlgmac_pdata *pdata)
1761 {
1762         struct xlgmac_channel *channel;
1763         unsigned int i;
1764         u32 regval;
1765
1766         channel = pdata->channel_head;
1767         for (i = 0; i < pdata->channel_count; i++, channel++) {
1768                 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_CR));
1769                 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_CR_PBLX8_POS,
1770                                              DMA_CH_CR_PBLX8_LEN,
1771                                         pdata->pblx8);
1772                 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_CR));
1773         }
1774
1775         return 0;
1776 }
1777
1778 static int xlgmac_get_tx_pbl_val(struct xlgmac_pdata *pdata)
1779 {
1780         u32 regval;
1781
1782         regval = readl(XLGMAC_DMA_REG(pdata->channel_head, DMA_CH_TCR));
1783         regval = XLGMAC_GET_REG_BITS(regval, DMA_CH_TCR_PBL_POS,
1784                                      DMA_CH_TCR_PBL_LEN);
1785         return regval;
1786 }
1787
1788 static int xlgmac_config_tx_pbl_val(struct xlgmac_pdata *pdata)
1789 {
1790         struct xlgmac_channel *channel;
1791         unsigned int i;
1792         u32 regval;
1793
1794         channel = pdata->channel_head;
1795         for (i = 0; i < pdata->channel_count; i++, channel++) {
1796                 if (!channel->tx_ring)
1797                         break;
1798
1799                 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1800                 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_TCR_PBL_POS,
1801                                              DMA_CH_TCR_PBL_LEN,
1802                                         pdata->tx_pbl);
1803                 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1804         }
1805
1806         return 0;
1807 }
1808
1809 static int xlgmac_get_rx_pbl_val(struct xlgmac_pdata *pdata)
1810 {
1811         u32 regval;
1812
1813         regval = readl(XLGMAC_DMA_REG(pdata->channel_head, DMA_CH_RCR));
1814         regval = XLGMAC_GET_REG_BITS(regval, DMA_CH_RCR_PBL_POS,
1815                                      DMA_CH_RCR_PBL_LEN);
1816         return regval;
1817 }
1818
1819 static int xlgmac_config_rx_pbl_val(struct xlgmac_pdata *pdata)
1820 {
1821         struct xlgmac_channel *channel;
1822         unsigned int i;
1823         u32 regval;
1824
1825         channel = pdata->channel_head;
1826         for (i = 0; i < pdata->channel_count; i++, channel++) {
1827                 if (!channel->rx_ring)
1828                         break;
1829
1830                 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_RCR));
1831                 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_RCR_PBL_POS,
1832                                              DMA_CH_RCR_PBL_LEN,
1833                                         pdata->rx_pbl);
1834                 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_RCR));
1835         }
1836
1837         return 0;
1838 }
1839
1840 static u64 xlgmac_mmc_read(struct xlgmac_pdata *pdata, unsigned int reg_lo)
1841 {
1842         bool read_hi;
1843         u64 val;
1844
1845         switch (reg_lo) {
1846         /* These registers are always 64 bit */
1847         case MMC_TXOCTETCOUNT_GB_LO:
1848         case MMC_TXOCTETCOUNT_G_LO:
1849         case MMC_RXOCTETCOUNT_GB_LO:
1850         case MMC_RXOCTETCOUNT_G_LO:
1851                 read_hi = true;
1852                 break;
1853
1854         default:
1855                 read_hi = false;
1856         }
1857
1858         val = (u64)readl(pdata->mac_regs + reg_lo);
1859
1860         if (read_hi)
1861                 val |= ((u64)readl(pdata->mac_regs + reg_lo + 4) << 32);
1862
1863         return val;
1864 }
1865
1866 static void xlgmac_tx_mmc_int(struct xlgmac_pdata *pdata)
1867 {
1868         unsigned int mmc_isr = readl(pdata->mac_regs + MMC_TISR);
1869         struct xlgmac_stats *stats = &pdata->stats;
1870
1871         if (XLGMAC_GET_REG_BITS(mmc_isr,
1872                                 MMC_TISR_TXOCTETCOUNT_GB_POS,
1873                                 MMC_TISR_TXOCTETCOUNT_GB_LEN))
1874                 stats->txoctetcount_gb +=
1875                         xlgmac_mmc_read(pdata, MMC_TXOCTETCOUNT_GB_LO);
1876
1877         if (XLGMAC_GET_REG_BITS(mmc_isr,
1878                                 MMC_TISR_TXFRAMECOUNT_GB_POS,
1879                                 MMC_TISR_TXFRAMECOUNT_GB_LEN))
1880                 stats->txframecount_gb +=
1881                         xlgmac_mmc_read(pdata, MMC_TXFRAMECOUNT_GB_LO);
1882
1883         if (XLGMAC_GET_REG_BITS(mmc_isr,
1884                                 MMC_TISR_TXBROADCASTFRAMES_G_POS,
1885                                 MMC_TISR_TXBROADCASTFRAMES_G_LEN))
1886                 stats->txbroadcastframes_g +=
1887                         xlgmac_mmc_read(pdata, MMC_TXBROADCASTFRAMES_G_LO);
1888
1889         if (XLGMAC_GET_REG_BITS(mmc_isr,
1890                                 MMC_TISR_TXMULTICASTFRAMES_G_POS,
1891                                 MMC_TISR_TXMULTICASTFRAMES_G_LEN))
1892                 stats->txmulticastframes_g +=
1893                         xlgmac_mmc_read(pdata, MMC_TXMULTICASTFRAMES_G_LO);
1894
1895         if (XLGMAC_GET_REG_BITS(mmc_isr,
1896                                 MMC_TISR_TX64OCTETS_GB_POS,
1897                                 MMC_TISR_TX64OCTETS_GB_LEN))
1898                 stats->tx64octets_gb +=
1899                         xlgmac_mmc_read(pdata, MMC_TX64OCTETS_GB_LO);
1900
1901         if (XLGMAC_GET_REG_BITS(mmc_isr,
1902                                 MMC_TISR_TX65TO127OCTETS_GB_POS,
1903                                 MMC_TISR_TX65TO127OCTETS_GB_LEN))
1904                 stats->tx65to127octets_gb +=
1905                         xlgmac_mmc_read(pdata, MMC_TX65TO127OCTETS_GB_LO);
1906
1907         if (XLGMAC_GET_REG_BITS(mmc_isr,
1908                                 MMC_TISR_TX128TO255OCTETS_GB_POS,
1909                                 MMC_TISR_TX128TO255OCTETS_GB_LEN))
1910                 stats->tx128to255octets_gb +=
1911                         xlgmac_mmc_read(pdata, MMC_TX128TO255OCTETS_GB_LO);
1912
1913         if (XLGMAC_GET_REG_BITS(mmc_isr,
1914                                 MMC_TISR_TX256TO511OCTETS_GB_POS,
1915                                 MMC_TISR_TX256TO511OCTETS_GB_LEN))
1916                 stats->tx256to511octets_gb +=
1917                         xlgmac_mmc_read(pdata, MMC_TX256TO511OCTETS_GB_LO);
1918
1919         if (XLGMAC_GET_REG_BITS(mmc_isr,
1920                                 MMC_TISR_TX512TO1023OCTETS_GB_POS,
1921                                 MMC_TISR_TX512TO1023OCTETS_GB_LEN))
1922                 stats->tx512to1023octets_gb +=
1923                         xlgmac_mmc_read(pdata, MMC_TX512TO1023OCTETS_GB_LO);
1924
1925         if (XLGMAC_GET_REG_BITS(mmc_isr,
1926                                 MMC_TISR_TX1024TOMAXOCTETS_GB_POS,
1927                                 MMC_TISR_TX1024TOMAXOCTETS_GB_LEN))
1928                 stats->tx1024tomaxoctets_gb +=
1929                         xlgmac_mmc_read(pdata, MMC_TX1024TOMAXOCTETS_GB_LO);
1930
1931         if (XLGMAC_GET_REG_BITS(mmc_isr,
1932                                 MMC_TISR_TXUNICASTFRAMES_GB_POS,
1933                                 MMC_TISR_TXUNICASTFRAMES_GB_LEN))
1934                 stats->txunicastframes_gb +=
1935                         xlgmac_mmc_read(pdata, MMC_TXUNICASTFRAMES_GB_LO);
1936
1937         if (XLGMAC_GET_REG_BITS(mmc_isr,
1938                                 MMC_TISR_TXMULTICASTFRAMES_GB_POS,
1939                                 MMC_TISR_TXMULTICASTFRAMES_GB_LEN))
1940                 stats->txmulticastframes_gb +=
1941                         xlgmac_mmc_read(pdata, MMC_TXMULTICASTFRAMES_GB_LO);
1942
1943         if (XLGMAC_GET_REG_BITS(mmc_isr,
1944                                 MMC_TISR_TXBROADCASTFRAMES_GB_POS,
1945                                 MMC_TISR_TXBROADCASTFRAMES_GB_LEN))
1946                 stats->txbroadcastframes_g +=
1947                         xlgmac_mmc_read(pdata, MMC_TXBROADCASTFRAMES_GB_LO);
1948
1949         if (XLGMAC_GET_REG_BITS(mmc_isr,
1950                                 MMC_TISR_TXUNDERFLOWERROR_POS,
1951                                 MMC_TISR_TXUNDERFLOWERROR_LEN))
1952                 stats->txunderflowerror +=
1953                         xlgmac_mmc_read(pdata, MMC_TXUNDERFLOWERROR_LO);
1954
1955         if (XLGMAC_GET_REG_BITS(mmc_isr,
1956                                 MMC_TISR_TXOCTETCOUNT_G_POS,
1957                                 MMC_TISR_TXOCTETCOUNT_G_LEN))
1958                 stats->txoctetcount_g +=
1959                         xlgmac_mmc_read(pdata, MMC_TXOCTETCOUNT_G_LO);
1960
1961         if (XLGMAC_GET_REG_BITS(mmc_isr,
1962                                 MMC_TISR_TXFRAMECOUNT_G_POS,
1963                                 MMC_TISR_TXFRAMECOUNT_G_LEN))
1964                 stats->txframecount_g +=
1965                         xlgmac_mmc_read(pdata, MMC_TXFRAMECOUNT_G_LO);
1966
1967         if (XLGMAC_GET_REG_BITS(mmc_isr,
1968                                 MMC_TISR_TXPAUSEFRAMES_POS,
1969                                 MMC_TISR_TXPAUSEFRAMES_LEN))
1970                 stats->txpauseframes +=
1971                         xlgmac_mmc_read(pdata, MMC_TXPAUSEFRAMES_LO);
1972
1973         if (XLGMAC_GET_REG_BITS(mmc_isr,
1974                                 MMC_TISR_TXVLANFRAMES_G_POS,
1975                                 MMC_TISR_TXVLANFRAMES_G_LEN))
1976                 stats->txvlanframes_g +=
1977                         xlgmac_mmc_read(pdata, MMC_TXVLANFRAMES_G_LO);
1978 }
1979
1980 static void xlgmac_rx_mmc_int(struct xlgmac_pdata *pdata)
1981 {
1982         unsigned int mmc_isr = readl(pdata->mac_regs + MMC_RISR);
1983         struct xlgmac_stats *stats = &pdata->stats;
1984
1985         if (XLGMAC_GET_REG_BITS(mmc_isr,
1986                                 MMC_RISR_RXFRAMECOUNT_GB_POS,
1987                                 MMC_RISR_RXFRAMECOUNT_GB_LEN))
1988                 stats->rxframecount_gb +=
1989                         xlgmac_mmc_read(pdata, MMC_RXFRAMECOUNT_GB_LO);
1990
1991         if (XLGMAC_GET_REG_BITS(mmc_isr,
1992                                 MMC_RISR_RXOCTETCOUNT_GB_POS,
1993                                 MMC_RISR_RXOCTETCOUNT_GB_LEN))
1994                 stats->rxoctetcount_gb +=
1995                         xlgmac_mmc_read(pdata, MMC_RXOCTETCOUNT_GB_LO);
1996
1997         if (XLGMAC_GET_REG_BITS(mmc_isr,
1998                                 MMC_RISR_RXOCTETCOUNT_G_POS,
1999                                 MMC_RISR_RXOCTETCOUNT_G_LEN))
2000                 stats->rxoctetcount_g +=
2001                         xlgmac_mmc_read(pdata, MMC_RXOCTETCOUNT_G_LO);
2002
2003         if (XLGMAC_GET_REG_BITS(mmc_isr,
2004                                 MMC_RISR_RXBROADCASTFRAMES_G_POS,
2005                                 MMC_RISR_RXBROADCASTFRAMES_G_LEN))
2006                 stats->rxbroadcastframes_g +=
2007                         xlgmac_mmc_read(pdata, MMC_RXBROADCASTFRAMES_G_LO);
2008
2009         if (XLGMAC_GET_REG_BITS(mmc_isr,
2010                                 MMC_RISR_RXMULTICASTFRAMES_G_POS,
2011                                 MMC_RISR_RXMULTICASTFRAMES_G_LEN))
2012                 stats->rxmulticastframes_g +=
2013                         xlgmac_mmc_read(pdata, MMC_RXMULTICASTFRAMES_G_LO);
2014
2015         if (XLGMAC_GET_REG_BITS(mmc_isr,
2016                                 MMC_RISR_RXCRCERROR_POS,
2017                                 MMC_RISR_RXCRCERROR_LEN))
2018                 stats->rxcrcerror +=
2019                         xlgmac_mmc_read(pdata, MMC_RXCRCERROR_LO);
2020
2021         if (XLGMAC_GET_REG_BITS(mmc_isr,
2022                                 MMC_RISR_RXRUNTERROR_POS,
2023                                 MMC_RISR_RXRUNTERROR_LEN))
2024                 stats->rxrunterror +=
2025                         xlgmac_mmc_read(pdata, MMC_RXRUNTERROR);
2026
2027         if (XLGMAC_GET_REG_BITS(mmc_isr,
2028                                 MMC_RISR_RXJABBERERROR_POS,
2029                                 MMC_RISR_RXJABBERERROR_LEN))
2030                 stats->rxjabbererror +=
2031                         xlgmac_mmc_read(pdata, MMC_RXJABBERERROR);
2032
2033         if (XLGMAC_GET_REG_BITS(mmc_isr,
2034                                 MMC_RISR_RXUNDERSIZE_G_POS,
2035                                 MMC_RISR_RXUNDERSIZE_G_LEN))
2036                 stats->rxundersize_g +=
2037                         xlgmac_mmc_read(pdata, MMC_RXUNDERSIZE_G);
2038
2039         if (XLGMAC_GET_REG_BITS(mmc_isr,
2040                                 MMC_RISR_RXOVERSIZE_G_POS,
2041                                 MMC_RISR_RXOVERSIZE_G_LEN))
2042                 stats->rxoversize_g +=
2043                         xlgmac_mmc_read(pdata, MMC_RXOVERSIZE_G);
2044
2045         if (XLGMAC_GET_REG_BITS(mmc_isr,
2046                                 MMC_RISR_RX64OCTETS_GB_POS,
2047                                 MMC_RISR_RX64OCTETS_GB_LEN))
2048                 stats->rx64octets_gb +=
2049                         xlgmac_mmc_read(pdata, MMC_RX64OCTETS_GB_LO);
2050
2051         if (XLGMAC_GET_REG_BITS(mmc_isr,
2052                                 MMC_RISR_RX65TO127OCTETS_GB_POS,
2053                                 MMC_RISR_RX65TO127OCTETS_GB_LEN))
2054                 stats->rx65to127octets_gb +=
2055                         xlgmac_mmc_read(pdata, MMC_RX65TO127OCTETS_GB_LO);
2056
2057         if (XLGMAC_GET_REG_BITS(mmc_isr,
2058                                 MMC_RISR_RX128TO255OCTETS_GB_POS,
2059                                 MMC_RISR_RX128TO255OCTETS_GB_LEN))
2060                 stats->rx128to255octets_gb +=
2061                         xlgmac_mmc_read(pdata, MMC_RX128TO255OCTETS_GB_LO);
2062
2063         if (XLGMAC_GET_REG_BITS(mmc_isr,
2064                                 MMC_RISR_RX256TO511OCTETS_GB_POS,
2065                                 MMC_RISR_RX256TO511OCTETS_GB_LEN))
2066                 stats->rx256to511octets_gb +=
2067                         xlgmac_mmc_read(pdata, MMC_RX256TO511OCTETS_GB_LO);
2068
2069         if (XLGMAC_GET_REG_BITS(mmc_isr,
2070                                 MMC_RISR_RX512TO1023OCTETS_GB_POS,
2071                                 MMC_RISR_RX512TO1023OCTETS_GB_LEN))
2072                 stats->rx512to1023octets_gb +=
2073                         xlgmac_mmc_read(pdata, MMC_RX512TO1023OCTETS_GB_LO);
2074
2075         if (XLGMAC_GET_REG_BITS(mmc_isr,
2076                                 MMC_RISR_RX1024TOMAXOCTETS_GB_POS,
2077                                 MMC_RISR_RX1024TOMAXOCTETS_GB_LEN))
2078                 stats->rx1024tomaxoctets_gb +=
2079                         xlgmac_mmc_read(pdata, MMC_RX1024TOMAXOCTETS_GB_LO);
2080
2081         if (XLGMAC_GET_REG_BITS(mmc_isr,
2082                                 MMC_RISR_RXUNICASTFRAMES_G_POS,
2083                                 MMC_RISR_RXUNICASTFRAMES_G_LEN))
2084                 stats->rxunicastframes_g +=
2085                         xlgmac_mmc_read(pdata, MMC_RXUNICASTFRAMES_G_LO);
2086
2087         if (XLGMAC_GET_REG_BITS(mmc_isr,
2088                                 MMC_RISR_RXLENGTHERROR_POS,
2089                                 MMC_RISR_RXLENGTHERROR_LEN))
2090                 stats->rxlengtherror +=
2091                         xlgmac_mmc_read(pdata, MMC_RXLENGTHERROR_LO);
2092
2093         if (XLGMAC_GET_REG_BITS(mmc_isr,
2094                                 MMC_RISR_RXOUTOFRANGETYPE_POS,
2095                                 MMC_RISR_RXOUTOFRANGETYPE_LEN))
2096                 stats->rxoutofrangetype +=
2097                         xlgmac_mmc_read(pdata, MMC_RXOUTOFRANGETYPE_LO);
2098
2099         if (XLGMAC_GET_REG_BITS(mmc_isr,
2100                                 MMC_RISR_RXPAUSEFRAMES_POS,
2101                                 MMC_RISR_RXPAUSEFRAMES_LEN))
2102                 stats->rxpauseframes +=
2103                         xlgmac_mmc_read(pdata, MMC_RXPAUSEFRAMES_LO);
2104
2105         if (XLGMAC_GET_REG_BITS(mmc_isr,
2106                                 MMC_RISR_RXFIFOOVERFLOW_POS,
2107                                 MMC_RISR_RXFIFOOVERFLOW_LEN))
2108                 stats->rxfifooverflow +=
2109                         xlgmac_mmc_read(pdata, MMC_RXFIFOOVERFLOW_LO);
2110
2111         if (XLGMAC_GET_REG_BITS(mmc_isr,
2112                                 MMC_RISR_RXVLANFRAMES_GB_POS,
2113                                 MMC_RISR_RXVLANFRAMES_GB_LEN))
2114                 stats->rxvlanframes_gb +=
2115                         xlgmac_mmc_read(pdata, MMC_RXVLANFRAMES_GB_LO);
2116
2117         if (XLGMAC_GET_REG_BITS(mmc_isr,
2118                                 MMC_RISR_RXWATCHDOGERROR_POS,
2119                                 MMC_RISR_RXWATCHDOGERROR_LEN))
2120                 stats->rxwatchdogerror +=
2121                         xlgmac_mmc_read(pdata, MMC_RXWATCHDOGERROR);
2122 }
2123
2124 static void xlgmac_read_mmc_stats(struct xlgmac_pdata *pdata)
2125 {
2126         struct xlgmac_stats *stats = &pdata->stats;
2127         u32 regval;
2128
2129         /* Freeze counters */
2130         regval = readl(pdata->mac_regs + MMC_CR);
2131         regval = XLGMAC_SET_REG_BITS(regval, MMC_CR_MCF_POS,
2132                                      MMC_CR_MCF_LEN, 1);
2133         writel(regval, pdata->mac_regs + MMC_CR);
2134
2135         stats->txoctetcount_gb +=
2136                 xlgmac_mmc_read(pdata, MMC_TXOCTETCOUNT_GB_LO);
2137
2138         stats->txframecount_gb +=
2139                 xlgmac_mmc_read(pdata, MMC_TXFRAMECOUNT_GB_LO);
2140
2141         stats->txbroadcastframes_g +=
2142                 xlgmac_mmc_read(pdata, MMC_TXBROADCASTFRAMES_G_LO);
2143
2144         stats->txmulticastframes_g +=
2145                 xlgmac_mmc_read(pdata, MMC_TXMULTICASTFRAMES_G_LO);
2146
2147         stats->tx64octets_gb +=
2148                 xlgmac_mmc_read(pdata, MMC_TX64OCTETS_GB_LO);
2149
2150         stats->tx65to127octets_gb +=
2151                 xlgmac_mmc_read(pdata, MMC_TX65TO127OCTETS_GB_LO);
2152
2153         stats->tx128to255octets_gb +=
2154                 xlgmac_mmc_read(pdata, MMC_TX128TO255OCTETS_GB_LO);
2155
2156         stats->tx256to511octets_gb +=
2157                 xlgmac_mmc_read(pdata, MMC_TX256TO511OCTETS_GB_LO);
2158
2159         stats->tx512to1023octets_gb +=
2160                 xlgmac_mmc_read(pdata, MMC_TX512TO1023OCTETS_GB_LO);
2161
2162         stats->tx1024tomaxoctets_gb +=
2163                 xlgmac_mmc_read(pdata, MMC_TX1024TOMAXOCTETS_GB_LO);
2164
2165         stats->txunicastframes_gb +=
2166                 xlgmac_mmc_read(pdata, MMC_TXUNICASTFRAMES_GB_LO);
2167
2168         stats->txmulticastframes_gb +=
2169                 xlgmac_mmc_read(pdata, MMC_TXMULTICASTFRAMES_GB_LO);
2170
2171         stats->txbroadcastframes_g +=
2172                 xlgmac_mmc_read(pdata, MMC_TXBROADCASTFRAMES_GB_LO);
2173
2174         stats->txunderflowerror +=
2175                 xlgmac_mmc_read(pdata, MMC_TXUNDERFLOWERROR_LO);
2176
2177         stats->txoctetcount_g +=
2178                 xlgmac_mmc_read(pdata, MMC_TXOCTETCOUNT_G_LO);
2179
2180         stats->txframecount_g +=
2181                 xlgmac_mmc_read(pdata, MMC_TXFRAMECOUNT_G_LO);
2182
2183         stats->txpauseframes +=
2184                 xlgmac_mmc_read(pdata, MMC_TXPAUSEFRAMES_LO);
2185
2186         stats->txvlanframes_g +=
2187                 xlgmac_mmc_read(pdata, MMC_TXVLANFRAMES_G_LO);
2188
2189         stats->rxframecount_gb +=
2190                 xlgmac_mmc_read(pdata, MMC_RXFRAMECOUNT_GB_LO);
2191
2192         stats->rxoctetcount_gb +=
2193                 xlgmac_mmc_read(pdata, MMC_RXOCTETCOUNT_GB_LO);
2194
2195         stats->rxoctetcount_g +=
2196                 xlgmac_mmc_read(pdata, MMC_RXOCTETCOUNT_G_LO);
2197
2198         stats->rxbroadcastframes_g +=
2199                 xlgmac_mmc_read(pdata, MMC_RXBROADCASTFRAMES_G_LO);
2200
2201         stats->rxmulticastframes_g +=
2202                 xlgmac_mmc_read(pdata, MMC_RXMULTICASTFRAMES_G_LO);
2203
2204         stats->rxcrcerror +=
2205                 xlgmac_mmc_read(pdata, MMC_RXCRCERROR_LO);
2206
2207         stats->rxrunterror +=
2208                 xlgmac_mmc_read(pdata, MMC_RXRUNTERROR);
2209
2210         stats->rxjabbererror +=
2211                 xlgmac_mmc_read(pdata, MMC_RXJABBERERROR);
2212
2213         stats->rxundersize_g +=
2214                 xlgmac_mmc_read(pdata, MMC_RXUNDERSIZE_G);
2215
2216         stats->rxoversize_g +=
2217                 xlgmac_mmc_read(pdata, MMC_RXOVERSIZE_G);
2218
2219         stats->rx64octets_gb +=
2220                 xlgmac_mmc_read(pdata, MMC_RX64OCTETS_GB_LO);
2221
2222         stats->rx65to127octets_gb +=
2223                 xlgmac_mmc_read(pdata, MMC_RX65TO127OCTETS_GB_LO);
2224
2225         stats->rx128to255octets_gb +=
2226                 xlgmac_mmc_read(pdata, MMC_RX128TO255OCTETS_GB_LO);
2227
2228         stats->rx256to511octets_gb +=
2229                 xlgmac_mmc_read(pdata, MMC_RX256TO511OCTETS_GB_LO);
2230
2231         stats->rx512to1023octets_gb +=
2232                 xlgmac_mmc_read(pdata, MMC_RX512TO1023OCTETS_GB_LO);
2233
2234         stats->rx1024tomaxoctets_gb +=
2235                 xlgmac_mmc_read(pdata, MMC_RX1024TOMAXOCTETS_GB_LO);
2236
2237         stats->rxunicastframes_g +=
2238                 xlgmac_mmc_read(pdata, MMC_RXUNICASTFRAMES_G_LO);
2239
2240         stats->rxlengtherror +=
2241                 xlgmac_mmc_read(pdata, MMC_RXLENGTHERROR_LO);
2242
2243         stats->rxoutofrangetype +=
2244                 xlgmac_mmc_read(pdata, MMC_RXOUTOFRANGETYPE_LO);
2245
2246         stats->rxpauseframes +=
2247                 xlgmac_mmc_read(pdata, MMC_RXPAUSEFRAMES_LO);
2248
2249         stats->rxfifooverflow +=
2250                 xlgmac_mmc_read(pdata, MMC_RXFIFOOVERFLOW_LO);
2251
2252         stats->rxvlanframes_gb +=
2253                 xlgmac_mmc_read(pdata, MMC_RXVLANFRAMES_GB_LO);
2254
2255         stats->rxwatchdogerror +=
2256                 xlgmac_mmc_read(pdata, MMC_RXWATCHDOGERROR);
2257
2258         /* Un-freeze counters */
2259         regval = readl(pdata->mac_regs + MMC_CR);
2260         regval = XLGMAC_SET_REG_BITS(regval, MMC_CR_MCF_POS,
2261                                      MMC_CR_MCF_LEN, 0);
2262         writel(regval, pdata->mac_regs + MMC_CR);
2263 }
2264
2265 static void xlgmac_config_mmc(struct xlgmac_pdata *pdata)
2266 {
2267         u32 regval;
2268
2269         regval = readl(pdata->mac_regs + MMC_CR);
2270         /* Set counters to reset on read */
2271         regval = XLGMAC_SET_REG_BITS(regval, MMC_CR_ROR_POS,
2272                                      MMC_CR_ROR_LEN, 1);
2273         /* Reset the counters */
2274         regval = XLGMAC_SET_REG_BITS(regval, MMC_CR_CR_POS,
2275                                      MMC_CR_CR_LEN, 1);
2276         writel(regval, pdata->mac_regs + MMC_CR);
2277 }
2278
2279 static int xlgmac_write_rss_reg(struct xlgmac_pdata *pdata, unsigned int type,
2280                                 unsigned int index, unsigned int val)
2281 {
2282         unsigned int wait;
2283         int ret = 0;
2284         u32 regval;
2285
2286         mutex_lock(&pdata->rss_mutex);
2287
2288         regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_RSSAR),
2289                                      MAC_RSSAR_OB_POS, MAC_RSSAR_OB_LEN);
2290         if (regval) {
2291                 ret = -EBUSY;
2292                 goto unlock;
2293         }
2294
2295         writel(val, pdata->mac_regs + MAC_RSSDR);
2296
2297         regval = readl(pdata->mac_regs + MAC_RSSAR);
2298         regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSAR_RSSIA_POS,
2299                                      MAC_RSSAR_RSSIA_LEN, index);
2300         regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSAR_ADDRT_POS,
2301                                      MAC_RSSAR_ADDRT_LEN, type);
2302         regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSAR_CT_POS,
2303                                      MAC_RSSAR_CT_LEN, 0);
2304         regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSAR_OB_POS,
2305                                      MAC_RSSAR_OB_LEN, 1);
2306         writel(regval, pdata->mac_regs + MAC_RSSAR);
2307
2308         wait = 1000;
2309         while (wait--) {
2310                 regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_RSSAR),
2311                                              MAC_RSSAR_OB_POS,
2312                                              MAC_RSSAR_OB_LEN);
2313                 if (!regval)
2314                         goto unlock;
2315
2316                 usleep_range(1000, 1500);
2317         }
2318
2319         ret = -EBUSY;
2320
2321 unlock:
2322         mutex_unlock(&pdata->rss_mutex);
2323
2324         return ret;
2325 }
2326
2327 static int xlgmac_write_rss_hash_key(struct xlgmac_pdata *pdata)
2328 {
2329         unsigned int key_regs = sizeof(pdata->rss_key) / sizeof(u32);
2330         unsigned int *key = (unsigned int *)&pdata->rss_key;
2331         int ret;
2332
2333         while (key_regs--) {
2334                 ret = xlgmac_write_rss_reg(pdata, XLGMAC_RSS_HASH_KEY_TYPE,
2335                                            key_regs, *key++);
2336                 if (ret)
2337                         return ret;
2338         }
2339
2340         return 0;
2341 }
2342
2343 static int xlgmac_write_rss_lookup_table(struct xlgmac_pdata *pdata)
2344 {
2345         unsigned int i;
2346         int ret;
2347
2348         for (i = 0; i < ARRAY_SIZE(pdata->rss_table); i++) {
2349                 ret = xlgmac_write_rss_reg(pdata,
2350                                            XLGMAC_RSS_LOOKUP_TABLE_TYPE, i,
2351                                            pdata->rss_table[i]);
2352                 if (ret)
2353                         return ret;
2354         }
2355
2356         return 0;
2357 }
2358
2359 static int xlgmac_set_rss_hash_key(struct xlgmac_pdata *pdata, const u8 *key)
2360 {
2361         memcpy(pdata->rss_key, key, sizeof(pdata->rss_key));
2362
2363         return xlgmac_write_rss_hash_key(pdata);
2364 }
2365
2366 static int xlgmac_set_rss_lookup_table(struct xlgmac_pdata *pdata,
2367                                        const u32 *table)
2368 {
2369         unsigned int i;
2370         u32 tval;
2371
2372         for (i = 0; i < ARRAY_SIZE(pdata->rss_table); i++) {
2373                 tval = table[i];
2374                 pdata->rss_table[i] = XLGMAC_SET_REG_BITS(
2375                                                 pdata->rss_table[i],
2376                                                 MAC_RSSDR_DMCH_POS,
2377                                                 MAC_RSSDR_DMCH_LEN,
2378                                                 tval);
2379         }
2380
2381         return xlgmac_write_rss_lookup_table(pdata);
2382 }
2383
2384 static int xlgmac_enable_rss(struct xlgmac_pdata *pdata)
2385 {
2386         u32 regval;
2387         int ret;
2388
2389         if (!pdata->hw_feat.rss)
2390                 return -EOPNOTSUPP;
2391
2392         /* Program the hash key */
2393         ret = xlgmac_write_rss_hash_key(pdata);
2394         if (ret)
2395                 return ret;
2396
2397         /* Program the lookup table */
2398         ret = xlgmac_write_rss_lookup_table(pdata);
2399         if (ret)
2400                 return ret;
2401
2402         /* Set the RSS options */
2403         writel(pdata->rss_options, pdata->mac_regs + MAC_RSSCR);
2404
2405         /* Enable RSS */
2406         regval = readl(pdata->mac_regs + MAC_RSSCR);
2407         regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSCR_RSSE_POS,
2408                                      MAC_RSSCR_RSSE_LEN, 1);
2409         writel(regval, pdata->mac_regs + MAC_RSSCR);
2410
2411         return 0;
2412 }
2413
2414 static int xlgmac_disable_rss(struct xlgmac_pdata *pdata)
2415 {
2416         u32 regval;
2417
2418         if (!pdata->hw_feat.rss)
2419                 return -EOPNOTSUPP;
2420
2421         regval = readl(pdata->mac_regs + MAC_RSSCR);
2422         regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSCR_RSSE_POS,
2423                                      MAC_RSSCR_RSSE_LEN, 0);
2424         writel(regval, pdata->mac_regs + MAC_RSSCR);
2425
2426         return 0;
2427 }
2428
2429 static void xlgmac_config_rss(struct xlgmac_pdata *pdata)
2430 {
2431         int ret;
2432
2433         if (!pdata->hw_feat.rss)
2434                 return;
2435
2436         if (pdata->netdev->features & NETIF_F_RXHASH)
2437                 ret = xlgmac_enable_rss(pdata);
2438         else
2439                 ret = xlgmac_disable_rss(pdata);
2440
2441         if (ret)
2442                 netdev_err(pdata->netdev,
2443                            "error configuring RSS, RSS disabled\n");
2444 }
2445
2446 static void xlgmac_enable_dma_interrupts(struct xlgmac_pdata *pdata)
2447 {
2448         unsigned int dma_ch_isr, dma_ch_ier;
2449         struct xlgmac_channel *channel;
2450         unsigned int i;
2451
2452         channel = pdata->channel_head;
2453         for (i = 0; i < pdata->channel_count; i++, channel++) {
2454                 /* Clear all the interrupts which are set */
2455                 dma_ch_isr = readl(XLGMAC_DMA_REG(channel, DMA_CH_SR));
2456                 writel(dma_ch_isr, XLGMAC_DMA_REG(channel, DMA_CH_SR));
2457
2458                 /* Clear all interrupt enable bits */
2459                 dma_ch_ier = 0;
2460
2461                 /* Enable following interrupts
2462                  *   NIE  - Normal Interrupt Summary Enable
2463                  *   AIE  - Abnormal Interrupt Summary Enable
2464                  *   FBEE - Fatal Bus Error Enable
2465                  */
2466                 dma_ch_ier = XLGMAC_SET_REG_BITS(dma_ch_ier,
2467                                                  DMA_CH_IER_NIE_POS,
2468                                         DMA_CH_IER_NIE_LEN, 1);
2469                 dma_ch_ier = XLGMAC_SET_REG_BITS(dma_ch_ier,
2470                                                  DMA_CH_IER_AIE_POS,
2471                                         DMA_CH_IER_AIE_LEN, 1);
2472                 dma_ch_ier = XLGMAC_SET_REG_BITS(dma_ch_ier,
2473                                                  DMA_CH_IER_FBEE_POS,
2474                                         DMA_CH_IER_FBEE_LEN, 1);
2475
2476                 if (channel->tx_ring) {
2477                         /* Enable the following Tx interrupts
2478                          *   TIE  - Transmit Interrupt Enable (unless using
2479                          *          per channel interrupts)
2480                          */
2481                         if (!pdata->per_channel_irq)
2482                                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2483                                                 dma_ch_ier,
2484                                                 DMA_CH_IER_TIE_POS,
2485                                                 DMA_CH_IER_TIE_LEN,
2486                                                 1);
2487                 }
2488                 if (channel->rx_ring) {
2489                         /* Enable following Rx interrupts
2490                          *   RBUE - Receive Buffer Unavailable Enable
2491                          *   RIE  - Receive Interrupt Enable (unless using
2492                          *          per channel interrupts)
2493                          */
2494                         dma_ch_ier = XLGMAC_SET_REG_BITS(
2495                                         dma_ch_ier,
2496                                         DMA_CH_IER_RBUE_POS,
2497                                         DMA_CH_IER_RBUE_LEN,
2498                                         1);
2499                         if (!pdata->per_channel_irq)
2500                                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2501                                                 dma_ch_ier,
2502                                                 DMA_CH_IER_RIE_POS,
2503                                                 DMA_CH_IER_RIE_LEN,
2504                                                 1);
2505                 }
2506
2507                 writel(dma_ch_isr, XLGMAC_DMA_REG(channel, DMA_CH_IER));
2508         }
2509 }
2510
2511 static void xlgmac_enable_mtl_interrupts(struct xlgmac_pdata *pdata)
2512 {
2513         unsigned int q_count, i;
2514         unsigned int mtl_q_isr;
2515
2516         q_count = max(pdata->hw_feat.tx_q_cnt, pdata->hw_feat.rx_q_cnt);
2517         for (i = 0; i < q_count; i++) {
2518                 /* Clear all the interrupts which are set */
2519                 mtl_q_isr = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_ISR));
2520                 writel(mtl_q_isr, XLGMAC_MTL_REG(pdata, i, MTL_Q_ISR));
2521
2522                 /* No MTL interrupts to be enabled */
2523                 writel(0, XLGMAC_MTL_REG(pdata, i, MTL_Q_IER));
2524         }
2525 }
2526
2527 static void xlgmac_enable_mac_interrupts(struct xlgmac_pdata *pdata)
2528 {
2529         unsigned int mac_ier = 0;
2530         u32 regval;
2531
2532         /* Enable Timestamp interrupt */
2533         mac_ier = XLGMAC_SET_REG_BITS(mac_ier, MAC_IER_TSIE_POS,
2534                                       MAC_IER_TSIE_LEN, 1);
2535
2536         writel(mac_ier, pdata->mac_regs + MAC_IER);
2537
2538         /* Enable all counter interrupts */
2539         regval = readl(pdata->mac_regs + MMC_RIER);
2540         regval = XLGMAC_SET_REG_BITS(regval, MMC_RIER_ALL_INTERRUPTS_POS,
2541                                      MMC_RIER_ALL_INTERRUPTS_LEN, 0xffffffff);
2542         writel(regval, pdata->mac_regs + MMC_RIER);
2543         regval = readl(pdata->mac_regs + MMC_TIER);
2544         regval = XLGMAC_SET_REG_BITS(regval, MMC_TIER_ALL_INTERRUPTS_POS,
2545                                      MMC_TIER_ALL_INTERRUPTS_LEN, 0xffffffff);
2546         writel(regval, pdata->mac_regs + MMC_TIER);
2547 }
2548
2549 static int xlgmac_set_xlgmii_25000_speed(struct xlgmac_pdata *pdata)
2550 {
2551         u32 regval;
2552
2553         regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_TCR),
2554                                      MAC_TCR_SS_POS, MAC_TCR_SS_LEN);
2555         if (regval == 0x1)
2556                 return 0;
2557
2558         regval = readl(pdata->mac_regs + MAC_TCR);
2559         regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_SS_POS,
2560                                      MAC_TCR_SS_LEN, 0x1);
2561         writel(regval, pdata->mac_regs + MAC_TCR);
2562
2563         return 0;
2564 }
2565
2566 static int xlgmac_set_xlgmii_40000_speed(struct xlgmac_pdata *pdata)
2567 {
2568         u32 regval;
2569
2570         regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_TCR),
2571                                      MAC_TCR_SS_POS, MAC_TCR_SS_LEN);
2572         if (regval == 0)
2573                 return 0;
2574
2575         regval = readl(pdata->mac_regs + MAC_TCR);
2576         regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_SS_POS,
2577                                      MAC_TCR_SS_LEN, 0);
2578         writel(regval, pdata->mac_regs + MAC_TCR);
2579
2580         return 0;
2581 }
2582
2583 static int xlgmac_set_xlgmii_50000_speed(struct xlgmac_pdata *pdata)
2584 {
2585         u32 regval;
2586
2587         regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_TCR),
2588                                      MAC_TCR_SS_POS, MAC_TCR_SS_LEN);
2589         if (regval == 0x2)
2590                 return 0;
2591
2592         regval = readl(pdata->mac_regs + MAC_TCR);
2593         regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_SS_POS,
2594                                      MAC_TCR_SS_LEN, 0x2);
2595         writel(regval, pdata->mac_regs + MAC_TCR);
2596
2597         return 0;
2598 }
2599
2600 static int xlgmac_set_xlgmii_100000_speed(struct xlgmac_pdata *pdata)
2601 {
2602         u32 regval;
2603
2604         regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_TCR),
2605                                      MAC_TCR_SS_POS, MAC_TCR_SS_LEN);
2606         if (regval == 0x3)
2607                 return 0;
2608
2609         regval = readl(pdata->mac_regs + MAC_TCR);
2610         regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_SS_POS,
2611                                      MAC_TCR_SS_LEN, 0x3);
2612         writel(regval, pdata->mac_regs + MAC_TCR);
2613
2614         return 0;
2615 }
2616
2617 static void xlgmac_config_mac_speed(struct xlgmac_pdata *pdata)
2618 {
2619         switch (pdata->phy_speed) {
2620         case SPEED_100000:
2621                 xlgmac_set_xlgmii_100000_speed(pdata);
2622                 break;
2623
2624         case SPEED_50000:
2625                 xlgmac_set_xlgmii_50000_speed(pdata);
2626                 break;
2627
2628         case SPEED_40000:
2629                 xlgmac_set_xlgmii_40000_speed(pdata);
2630                 break;
2631
2632         case SPEED_25000:
2633                 xlgmac_set_xlgmii_25000_speed(pdata);
2634                 break;
2635         }
2636 }
2637
2638 static int xlgmac_dev_read(struct xlgmac_channel *channel)
2639 {
2640         struct xlgmac_pdata *pdata = channel->pdata;
2641         struct xlgmac_ring *ring = channel->rx_ring;
2642         struct net_device *netdev = pdata->netdev;
2643         struct xlgmac_desc_data *desc_data;
2644         struct xlgmac_dma_desc *dma_desc;
2645         struct xlgmac_pkt_info *pkt_info;
2646         unsigned int err, etlt, l34t;
2647
2648         desc_data = XLGMAC_GET_DESC_DATA(ring, ring->cur);
2649         dma_desc = desc_data->dma_desc;
2650         pkt_info = &ring->pkt_info;
2651
2652         /* Check for data availability */
2653         if (XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2654                                    RX_NORMAL_DESC3_OWN_POS,
2655                                    RX_NORMAL_DESC3_OWN_LEN))
2656                 return 1;
2657
2658         /* Make sure descriptor fields are read after reading the OWN bit */
2659         dma_rmb();
2660
2661         if (netif_msg_rx_status(pdata))
2662                 xlgmac_dump_rx_desc(pdata, ring, ring->cur);
2663
2664         if (XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2665                                    RX_NORMAL_DESC3_CTXT_POS,
2666                                    RX_NORMAL_DESC3_CTXT_LEN)) {
2667                 /* Timestamp Context Descriptor */
2668                 xlgmac_get_rx_tstamp(pkt_info, dma_desc);
2669
2670                 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2671                                         pkt_info->attributes,
2672                                         RX_PACKET_ATTRIBUTES_CONTEXT_POS,
2673                                         RX_PACKET_ATTRIBUTES_CONTEXT_LEN,
2674                                         1);
2675                 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2676                                 pkt_info->attributes,
2677                                 RX_PACKET_ATTRIBUTES_CONTEXT_NEXT_POS,
2678                                 RX_PACKET_ATTRIBUTES_CONTEXT_NEXT_LEN,
2679                                 0);
2680                 return 0;
2681         }
2682
2683         /* Normal Descriptor, be sure Context Descriptor bit is off */
2684         pkt_info->attributes = XLGMAC_SET_REG_BITS(
2685                                 pkt_info->attributes,
2686                                 RX_PACKET_ATTRIBUTES_CONTEXT_POS,
2687                                 RX_PACKET_ATTRIBUTES_CONTEXT_LEN,
2688                                 0);
2689
2690         /* Indicate if a Context Descriptor is next */
2691         if (XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2692                                    RX_NORMAL_DESC3_CDA_POS,
2693                                    RX_NORMAL_DESC3_CDA_LEN))
2694                 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2695                                 pkt_info->attributes,
2696                                 RX_PACKET_ATTRIBUTES_CONTEXT_NEXT_POS,
2697                                 RX_PACKET_ATTRIBUTES_CONTEXT_NEXT_LEN,
2698                                 1);
2699
2700         /* Get the header length */
2701         if (XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2702                                    RX_NORMAL_DESC3_FD_POS,
2703                                    RX_NORMAL_DESC3_FD_LEN)) {
2704                 desc_data->rx.hdr_len = XLGMAC_GET_REG_BITS_LE(dma_desc->desc2,
2705                                                         RX_NORMAL_DESC2_HL_POS,
2706                                                         RX_NORMAL_DESC2_HL_LEN);
2707                 if (desc_data->rx.hdr_len)
2708                         pdata->stats.rx_split_header_packets++;
2709         }
2710
2711         /* Get the RSS hash */
2712         if (XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2713                                    RX_NORMAL_DESC3_RSV_POS,
2714                                    RX_NORMAL_DESC3_RSV_LEN)) {
2715                 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2716                                 pkt_info->attributes,
2717                                 RX_PACKET_ATTRIBUTES_RSS_HASH_POS,
2718                                 RX_PACKET_ATTRIBUTES_RSS_HASH_LEN,
2719                                 1);
2720
2721                 pkt_info->rss_hash = le32_to_cpu(dma_desc->desc1);
2722
2723                 l34t = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2724                                               RX_NORMAL_DESC3_L34T_POS,
2725                                           RX_NORMAL_DESC3_L34T_LEN);
2726                 switch (l34t) {
2727                 case RX_DESC3_L34T_IPV4_TCP:
2728                 case RX_DESC3_L34T_IPV4_UDP:
2729                 case RX_DESC3_L34T_IPV6_TCP:
2730                 case RX_DESC3_L34T_IPV6_UDP:
2731                         pkt_info->rss_hash_type = PKT_HASH_TYPE_L4;
2732                         break;
2733                 default:
2734                         pkt_info->rss_hash_type = PKT_HASH_TYPE_L3;
2735                 }
2736         }
2737
2738         /* Get the pkt_info length */
2739         desc_data->rx.len = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2740                                         RX_NORMAL_DESC3_PL_POS,
2741                                         RX_NORMAL_DESC3_PL_LEN);
2742
2743         if (!XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2744                                     RX_NORMAL_DESC3_LD_POS,
2745                                     RX_NORMAL_DESC3_LD_LEN)) {
2746                 /* Not all the data has been transferred for this pkt_info */
2747                 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2748                                 pkt_info->attributes,
2749                                 RX_PACKET_ATTRIBUTES_INCOMPLETE_POS,
2750                                 RX_PACKET_ATTRIBUTES_INCOMPLETE_LEN,
2751                                 1);
2752                 return 0;
2753         }
2754
2755         /* This is the last of the data for this pkt_info */
2756         pkt_info->attributes = XLGMAC_SET_REG_BITS(
2757                         pkt_info->attributes,
2758                         RX_PACKET_ATTRIBUTES_INCOMPLETE_POS,
2759                         RX_PACKET_ATTRIBUTES_INCOMPLETE_LEN,
2760                         0);
2761
2762         /* Set checksum done indicator as appropriate */
2763         if (netdev->features & NETIF_F_RXCSUM)
2764                 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2765                                 pkt_info->attributes,
2766                                 RX_PACKET_ATTRIBUTES_CSUM_DONE_POS,
2767                                 RX_PACKET_ATTRIBUTES_CSUM_DONE_LEN,
2768                                 1);
2769
2770         /* Check for errors (only valid in last descriptor) */
2771         err = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2772                                      RX_NORMAL_DESC3_ES_POS,
2773                                      RX_NORMAL_DESC3_ES_LEN);
2774         etlt = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2775                                       RX_NORMAL_DESC3_ETLT_POS,
2776                                       RX_NORMAL_DESC3_ETLT_LEN);
2777         netif_dbg(pdata, rx_status, netdev, "err=%u, etlt=%#x\n", err, etlt);
2778
2779         if (!err || !etlt) {
2780                 /* No error if err is 0 or etlt is 0 */
2781                 if ((etlt == 0x09) &&
2782                     (netdev->features & NETIF_F_HW_VLAN_CTAG_RX)) {
2783                         pkt_info->attributes = XLGMAC_SET_REG_BITS(
2784                                         pkt_info->attributes,
2785                                         RX_PACKET_ATTRIBUTES_VLAN_CTAG_POS,
2786                                         RX_PACKET_ATTRIBUTES_VLAN_CTAG_LEN,
2787                                         1);
2788                         pkt_info->vlan_ctag =
2789                                 XLGMAC_GET_REG_BITS_LE(dma_desc->desc0,
2790                                                        RX_NORMAL_DESC0_OVT_POS,
2791                                                    RX_NORMAL_DESC0_OVT_LEN);
2792                         netif_dbg(pdata, rx_status, netdev, "vlan-ctag=%#06x\n",
2793                                   pkt_info->vlan_ctag);
2794                 }
2795         } else {
2796                 if ((etlt == 0x05) || (etlt == 0x06))
2797                         pkt_info->attributes = XLGMAC_SET_REG_BITS(
2798                                         pkt_info->attributes,
2799                                         RX_PACKET_ATTRIBUTES_CSUM_DONE_POS,
2800                                         RX_PACKET_ATTRIBUTES_CSUM_DONE_LEN,
2801                                         0);
2802                 else
2803                         pkt_info->errors = XLGMAC_SET_REG_BITS(
2804                                         pkt_info->errors,
2805                                         RX_PACKET_ERRORS_FRAME_POS,
2806                                         RX_PACKET_ERRORS_FRAME_LEN,
2807                                         1);
2808         }
2809
2810         XLGMAC_PR("%s - descriptor=%u (cur=%d)\n", channel->name,
2811                   ring->cur & (ring->dma_desc_count - 1), ring->cur);
2812
2813         return 0;
2814 }
2815
2816 static int xlgmac_enable_int(struct xlgmac_channel *channel,
2817                              enum xlgmac_int int_id)
2818 {
2819         unsigned int dma_ch_ier;
2820
2821         dma_ch_ier = readl(XLGMAC_DMA_REG(channel, DMA_CH_IER));
2822
2823         switch (int_id) {
2824         case XLGMAC_INT_DMA_CH_SR_TI:
2825                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2826                                 dma_ch_ier, DMA_CH_IER_TIE_POS,
2827                                 DMA_CH_IER_TIE_LEN, 1);
2828                 break;
2829         case XLGMAC_INT_DMA_CH_SR_TPS:
2830                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2831                                 dma_ch_ier, DMA_CH_IER_TXSE_POS,
2832                                 DMA_CH_IER_TXSE_LEN, 1);
2833                 break;
2834         case XLGMAC_INT_DMA_CH_SR_TBU:
2835                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2836                                 dma_ch_ier, DMA_CH_IER_TBUE_POS,
2837                                 DMA_CH_IER_TBUE_LEN, 1);
2838                 break;
2839         case XLGMAC_INT_DMA_CH_SR_RI:
2840                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2841                                 dma_ch_ier, DMA_CH_IER_RIE_POS,
2842                                 DMA_CH_IER_RIE_LEN, 1);
2843                 break;
2844         case XLGMAC_INT_DMA_CH_SR_RBU:
2845                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2846                                 dma_ch_ier, DMA_CH_IER_RBUE_POS,
2847                                 DMA_CH_IER_RBUE_LEN, 1);
2848                 break;
2849         case XLGMAC_INT_DMA_CH_SR_RPS:
2850                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2851                                 dma_ch_ier, DMA_CH_IER_RSE_POS,
2852                                 DMA_CH_IER_RSE_LEN, 1);
2853                 break;
2854         case XLGMAC_INT_DMA_CH_SR_TI_RI:
2855                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2856                                 dma_ch_ier, DMA_CH_IER_TIE_POS,
2857                                 DMA_CH_IER_TIE_LEN, 1);
2858                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2859                                 dma_ch_ier, DMA_CH_IER_RIE_POS,
2860                                 DMA_CH_IER_RIE_LEN, 1);
2861                 break;
2862         case XLGMAC_INT_DMA_CH_SR_FBE:
2863                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2864                                 dma_ch_ier, DMA_CH_IER_FBEE_POS,
2865                                 DMA_CH_IER_FBEE_LEN, 1);
2866                 break;
2867         case XLGMAC_INT_DMA_ALL:
2868                 dma_ch_ier |= channel->saved_ier;
2869                 break;
2870         default:
2871                 return -1;
2872         }
2873
2874         writel(dma_ch_ier, XLGMAC_DMA_REG(channel, DMA_CH_IER));
2875
2876         return 0;
2877 }
2878
2879 static int xlgmac_disable_int(struct xlgmac_channel *channel,
2880                               enum xlgmac_int int_id)
2881 {
2882         unsigned int dma_ch_ier;
2883
2884         dma_ch_ier = readl(XLGMAC_DMA_REG(channel, DMA_CH_IER));
2885
2886         switch (int_id) {
2887         case XLGMAC_INT_DMA_CH_SR_TI:
2888                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2889                                 dma_ch_ier, DMA_CH_IER_TIE_POS,
2890                                 DMA_CH_IER_TIE_LEN, 0);
2891                 break;
2892         case XLGMAC_INT_DMA_CH_SR_TPS:
2893                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2894                                 dma_ch_ier, DMA_CH_IER_TXSE_POS,
2895                                 DMA_CH_IER_TXSE_LEN, 0);
2896                 break;
2897         case XLGMAC_INT_DMA_CH_SR_TBU:
2898                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2899                                 dma_ch_ier, DMA_CH_IER_TBUE_POS,
2900                                 DMA_CH_IER_TBUE_LEN, 0);
2901                 break;
2902         case XLGMAC_INT_DMA_CH_SR_RI:
2903                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2904                                 dma_ch_ier, DMA_CH_IER_RIE_POS,
2905                                 DMA_CH_IER_RIE_LEN, 0);
2906                 break;
2907         case XLGMAC_INT_DMA_CH_SR_RBU:
2908                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2909                                 dma_ch_ier, DMA_CH_IER_RBUE_POS,
2910                                 DMA_CH_IER_RBUE_LEN, 0);
2911                 break;
2912         case XLGMAC_INT_DMA_CH_SR_RPS:
2913                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2914                                 dma_ch_ier, DMA_CH_IER_RSE_POS,
2915                                 DMA_CH_IER_RSE_LEN, 0);
2916                 break;
2917         case XLGMAC_INT_DMA_CH_SR_TI_RI:
2918                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2919                                 dma_ch_ier, DMA_CH_IER_TIE_POS,
2920                                 DMA_CH_IER_TIE_LEN, 0);
2921                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2922                                 dma_ch_ier, DMA_CH_IER_RIE_POS,
2923                                 DMA_CH_IER_RIE_LEN, 0);
2924                 break;
2925         case XLGMAC_INT_DMA_CH_SR_FBE:
2926                 dma_ch_ier = XLGMAC_SET_REG_BITS(
2927                                 dma_ch_ier, DMA_CH_IER_FBEE_POS,
2928                                 DMA_CH_IER_FBEE_LEN, 0);
2929                 break;
2930         case XLGMAC_INT_DMA_ALL:
2931                 channel->saved_ier = dma_ch_ier & XLGMAC_DMA_INTERRUPT_MASK;
2932                 dma_ch_ier &= ~XLGMAC_DMA_INTERRUPT_MASK;
2933                 break;
2934         default:
2935                 return -1;
2936         }
2937
2938         writel(dma_ch_ier, XLGMAC_DMA_REG(channel, DMA_CH_IER));
2939
2940         return 0;
2941 }
2942
2943 static int xlgmac_flush_tx_queues(struct xlgmac_pdata *pdata)
2944 {
2945         unsigned int i, count;
2946         u32 regval;
2947
2948         for (i = 0; i < pdata->tx_q_count; i++) {
2949                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
2950                 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_FTQ_POS,
2951                                              MTL_Q_TQOMR_FTQ_LEN, 1);
2952                 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
2953         }
2954
2955         /* Poll Until Poll Condition */
2956         for (i = 0; i < pdata->tx_q_count; i++) {
2957                 count = 2000;
2958                 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
2959                 regval = XLGMAC_GET_REG_BITS(regval, MTL_Q_TQOMR_FTQ_POS,
2960                                              MTL_Q_TQOMR_FTQ_LEN);
2961                 while (--count && regval)
2962                         usleep_range(500, 600);
2963
2964                 if (!count)
2965                         return -EBUSY;
2966         }
2967
2968         return 0;
2969 }
2970
2971 static void xlgmac_config_dma_bus(struct xlgmac_pdata *pdata)
2972 {
2973         u32 regval;
2974
2975         regval = readl(pdata->mac_regs + DMA_SBMR);
2976         /* Set enhanced addressing mode */
2977         regval = XLGMAC_SET_REG_BITS(regval, DMA_SBMR_EAME_POS,
2978                                      DMA_SBMR_EAME_LEN, 1);
2979         /* Set the System Bus mode */
2980         regval = XLGMAC_SET_REG_BITS(regval, DMA_SBMR_UNDEF_POS,
2981                                      DMA_SBMR_UNDEF_LEN, 1);
2982         regval = XLGMAC_SET_REG_BITS(regval, DMA_SBMR_BLEN_256_POS,
2983                                      DMA_SBMR_BLEN_256_LEN, 1);
2984         writel(regval, pdata->mac_regs + DMA_SBMR);
2985 }
2986
2987 static int xlgmac_hw_init(struct xlgmac_pdata *pdata)
2988 {
2989         struct xlgmac_desc_ops *desc_ops = &pdata->desc_ops;
2990         int ret;
2991
2992         /* Flush Tx queues */
2993         ret = xlgmac_flush_tx_queues(pdata);
2994         if (ret)
2995                 return ret;
2996
2997         /* Initialize DMA related features */
2998         xlgmac_config_dma_bus(pdata);
2999         xlgmac_config_osp_mode(pdata);
3000         xlgmac_config_pblx8(pdata);
3001         xlgmac_config_tx_pbl_val(pdata);
3002         xlgmac_config_rx_pbl_val(pdata);
3003         xlgmac_config_rx_coalesce(pdata);
3004         xlgmac_config_tx_coalesce(pdata);
3005         xlgmac_config_rx_buffer_size(pdata);
3006         xlgmac_config_tso_mode(pdata);
3007         xlgmac_config_sph_mode(pdata);
3008         xlgmac_config_rss(pdata);
3009         desc_ops->tx_desc_init(pdata);
3010         desc_ops->rx_desc_init(pdata);
3011         xlgmac_enable_dma_interrupts(pdata);
3012
3013         /* Initialize MTL related features */
3014         xlgmac_config_mtl_mode(pdata);
3015         xlgmac_config_queue_mapping(pdata);
3016         xlgmac_config_tsf_mode(pdata, pdata->tx_sf_mode);
3017         xlgmac_config_rsf_mode(pdata, pdata->rx_sf_mode);
3018         xlgmac_config_tx_threshold(pdata, pdata->tx_threshold);
3019         xlgmac_config_rx_threshold(pdata, pdata->rx_threshold);
3020         xlgmac_config_tx_fifo_size(pdata);
3021         xlgmac_config_rx_fifo_size(pdata);
3022         xlgmac_config_flow_control_threshold(pdata);
3023         xlgmac_config_rx_fep_enable(pdata);
3024         xlgmac_config_rx_fup_enable(pdata);
3025         xlgmac_enable_mtl_interrupts(pdata);
3026
3027         /* Initialize MAC related features */
3028         xlgmac_config_mac_address(pdata);
3029         xlgmac_config_rx_mode(pdata);
3030         xlgmac_config_jumbo_enable(pdata);
3031         xlgmac_config_flow_control(pdata);
3032         xlgmac_config_mac_speed(pdata);
3033         xlgmac_config_checksum_offload(pdata);
3034         xlgmac_config_vlan_support(pdata);
3035         xlgmac_config_mmc(pdata);
3036         xlgmac_enable_mac_interrupts(pdata);
3037
3038         return 0;
3039 }
3040
3041 static int xlgmac_hw_exit(struct xlgmac_pdata *pdata)
3042 {
3043         unsigned int count = 2000;
3044         u32 regval;
3045
3046         /* Issue a software reset */
3047         regval = readl(pdata->mac_regs + DMA_MR);
3048         regval = XLGMAC_SET_REG_BITS(regval, DMA_MR_SWR_POS,
3049                                      DMA_MR_SWR_LEN, 1);
3050         writel(regval, pdata->mac_regs + DMA_MR);
3051         usleep_range(10, 15);
3052
3053         /* Poll Until Poll Condition */
3054         while (--count &&
3055                XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + DMA_MR),
3056                                    DMA_MR_SWR_POS, DMA_MR_SWR_LEN))
3057                 usleep_range(500, 600);
3058
3059         if (!count)
3060                 return -EBUSY;
3061
3062         return 0;
3063 }
3064
3065 void xlgmac_init_hw_ops(struct xlgmac_hw_ops *hw_ops)
3066 {
3067         hw_ops->init = xlgmac_hw_init;
3068         hw_ops->exit = xlgmac_hw_exit;
3069
3070         hw_ops->tx_complete = xlgmac_tx_complete;
3071
3072         hw_ops->enable_tx = xlgmac_enable_tx;
3073         hw_ops->disable_tx = xlgmac_disable_tx;
3074         hw_ops->enable_rx = xlgmac_enable_rx;
3075         hw_ops->disable_rx = xlgmac_disable_rx;
3076
3077         hw_ops->dev_xmit = xlgmac_dev_xmit;
3078         hw_ops->dev_read = xlgmac_dev_read;
3079         hw_ops->enable_int = xlgmac_enable_int;
3080         hw_ops->disable_int = xlgmac_disable_int;
3081
3082         hw_ops->set_mac_address = xlgmac_set_mac_address;
3083         hw_ops->config_rx_mode = xlgmac_config_rx_mode;
3084         hw_ops->enable_rx_csum = xlgmac_enable_rx_csum;
3085         hw_ops->disable_rx_csum = xlgmac_disable_rx_csum;
3086
3087         /* For MII speed configuration */
3088         hw_ops->set_xlgmii_25000_speed = xlgmac_set_xlgmii_25000_speed;
3089         hw_ops->set_xlgmii_40000_speed = xlgmac_set_xlgmii_40000_speed;
3090         hw_ops->set_xlgmii_50000_speed = xlgmac_set_xlgmii_50000_speed;
3091         hw_ops->set_xlgmii_100000_speed = xlgmac_set_xlgmii_100000_speed;
3092
3093         /* For descriptor related operation */
3094         hw_ops->tx_desc_init = xlgmac_tx_desc_init;
3095         hw_ops->rx_desc_init = xlgmac_rx_desc_init;
3096         hw_ops->tx_desc_reset = xlgmac_tx_desc_reset;
3097         hw_ops->rx_desc_reset = xlgmac_rx_desc_reset;
3098         hw_ops->is_last_desc = xlgmac_is_last_desc;
3099         hw_ops->is_context_desc = xlgmac_is_context_desc;
3100         hw_ops->tx_start_xmit = xlgmac_tx_start_xmit;
3101
3102         /* For Flow Control */
3103         hw_ops->config_tx_flow_control = xlgmac_config_tx_flow_control;
3104         hw_ops->config_rx_flow_control = xlgmac_config_rx_flow_control;
3105
3106         /* For Vlan related config */
3107         hw_ops->enable_rx_vlan_stripping = xlgmac_enable_rx_vlan_stripping;
3108         hw_ops->disable_rx_vlan_stripping = xlgmac_disable_rx_vlan_stripping;
3109         hw_ops->enable_rx_vlan_filtering = xlgmac_enable_rx_vlan_filtering;
3110         hw_ops->disable_rx_vlan_filtering = xlgmac_disable_rx_vlan_filtering;
3111         hw_ops->update_vlan_hash_table = xlgmac_update_vlan_hash_table;
3112
3113         /* For RX coalescing */
3114         hw_ops->config_rx_coalesce = xlgmac_config_rx_coalesce;
3115         hw_ops->config_tx_coalesce = xlgmac_config_tx_coalesce;
3116         hw_ops->usec_to_riwt = xlgmac_usec_to_riwt;
3117         hw_ops->riwt_to_usec = xlgmac_riwt_to_usec;
3118
3119         /* For RX and TX threshold config */
3120         hw_ops->config_rx_threshold = xlgmac_config_rx_threshold;
3121         hw_ops->config_tx_threshold = xlgmac_config_tx_threshold;
3122
3123         /* For RX and TX Store and Forward Mode config */
3124         hw_ops->config_rsf_mode = xlgmac_config_rsf_mode;
3125         hw_ops->config_tsf_mode = xlgmac_config_tsf_mode;
3126
3127         /* For TX DMA Operating on Second Frame config */
3128         hw_ops->config_osp_mode = xlgmac_config_osp_mode;
3129
3130         /* For RX and TX PBL config */
3131         hw_ops->config_rx_pbl_val = xlgmac_config_rx_pbl_val;
3132         hw_ops->get_rx_pbl_val = xlgmac_get_rx_pbl_val;
3133         hw_ops->config_tx_pbl_val = xlgmac_config_tx_pbl_val;
3134         hw_ops->get_tx_pbl_val = xlgmac_get_tx_pbl_val;
3135         hw_ops->config_pblx8 = xlgmac_config_pblx8;
3136
3137         /* For MMC statistics support */
3138         hw_ops->tx_mmc_int = xlgmac_tx_mmc_int;
3139         hw_ops->rx_mmc_int = xlgmac_rx_mmc_int;
3140         hw_ops->read_mmc_stats = xlgmac_read_mmc_stats;
3141
3142         /* For Receive Side Scaling */
3143         hw_ops->enable_rss = xlgmac_enable_rss;
3144         hw_ops->disable_rss = xlgmac_disable_rss;
3145         hw_ops->set_rss_hash_key = xlgmac_set_rss_hash_key;
3146         hw_ops->set_rss_lookup_table = xlgmac_set_rss_lookup_table;
3147 }