sys/dev/axgbe/xgbe-dev.c

   1 /*
   2  * AMD 10Gb Ethernet driver
   3  *
   4  * Copyright (c) 2014-2016,2020 Advanced Micro Devices, Inc.
   5  *
   6  * This file is available to you under your choice of the following two
   7  * licenses:
   8  *
   9  * License 1: GPLv2
  10  *
  11  * This file is free software; you may copy, redistribute and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation, either version 2 of the License, or (at
  14  * your option) any later version.
  15  *
  16  * This file is distributed in the hope that it will be useful, but
  17  * WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19  * General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  *
  24  * This file incorporates work covered by the following copyright and
  25  * permission notice:
  26  *     The Synopsys DWC ETHER XGMAC Software Driver and documentation
  27  *     (hereinafter "Software") is an unsupported proprietary work of Synopsys,
  28  *     Inc. unless otherwise expressly agreed to in writing between Synopsys
  29  *     and you.
  30  *
  31  *     The Software IS NOT an item of Licensed Software or Licensed Product
  32  *     under any End User Software License Agreement or Agreement for Licensed
  33  *     Product with Synopsys or any supplement thereto.  Permission is hereby
  34  *     granted, free of charge, to any person obtaining a copy of this software
  35  *     annotated with this license and the Software, to deal in the Software
  36  *     without restriction, including without limitation the rights to use,
  37  *     copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  38  *     of the Software, and to permit persons to whom the Software is furnished
  39  *     to do so, subject to the following conditions:
  40  *
  41  *     The above copyright notice and this permission notice shall be included
  42  *     in all copies or substantial portions of the Software.
  43  *
  44  *     THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS"
  45  *     BASIS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  46  *     TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  47  *     PARTICULAR PURPOSE ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS
  48  *     BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  49  *     CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  50  *     SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  51  *     INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  52  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  53  *     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  54  *     THE POSSIBILITY OF SUCH DAMAGE.
  55  *
  56  *
  57  * License 2: Modified BSD
  58  *
  59  * Redistribution and use in source and binary forms, with or without
  60  * modification, are permitted provided that the following conditions are met:
  61  *     * Redistributions of source code must retain the above copyright
  62  *       notice, this list of conditions and the following disclaimer.
  63  *     * Redistributions in binary form must reproduce the above copyright
  64  *       notice, this list of conditions and the following disclaimer in the
  65  *       documentation and/or other materials provided with the distribution.
  66  *     * Neither the name of Advanced Micro Devices, Inc. nor the
  67  *       names of its contributors may be used to endorse or promote products
  68  *       derived from this software without specific prior written permission.
  69  *
  70  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  71  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  72  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  73  * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  74  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  75  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  76  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  77  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  78  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  79  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  80  *
  81  * This file incorporates work covered by the following copyright and
  82  * permission notice:
  83  *     The Synopsys DWC ETHER XGMAC Software Driver and documentation
  84  *     (hereinafter "Software") is an unsupported proprietary work of Synopsys,
  85  *     Inc. unless otherwise expressly agreed to in writing between Synopsys
  86  *     and you.
  87  *
  88  *     The Software IS NOT an item of Licensed Software or Licensed Product
  89  *     under any End User Software License Agreement or Agreement for Licensed
  90  *     Product with Synopsys or any supplement thereto.  Permission is hereby
  91  *     granted, free of charge, to any person obtaining a copy of this software
  92  *     annotated with this license and the Software, to deal in the Software
  93  *     without restriction, including without limitation the rights to use,
  94  *     copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  95  *     of the Software, and to permit persons to whom the Software is furnished
  96  *     to do so, subject to the following conditions:
  97  *
  98  *     The above copyright notice and this permission notice shall be included
  99  *     in all copies or substantial portions of the Software.
 100  *
 101  *     THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS"
 102  *     BASIS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 103  *     TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 104  *     PARTICULAR PURPOSE ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS
 105  *     BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 106  *     CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 107  *     SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 108  *     INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 109  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 110  *     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 111  *     THE POSSIBILITY OF SUCH DAMAGE.
 112  */
 113
 114 #include <sys/cdefs.h>
 115 __FBSDID("$FreeBSD$");
 116
 117 #include "xgbe.h"
 118 #include "xgbe-common.h"
 119
 120 #include <net/if_dl.h>
 121
 122 static inline unsigned int xgbe_get_max_frame(struct xgbe_prv_data *pdata)
 123 {
 124         return (if_getmtu(pdata->netdev) + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN);
 125 }
 126
 127 static unsigned int
 128 xgbe_usec_to_riwt(struct xgbe_prv_data *pdata, unsigned int usec)
 129 {
 130         unsigned long rate;
 131         unsigned int ret;
 132
 133         rate = pdata->sysclk_rate;
 134
 135         /*
 136          * Convert the input usec value to the watchdog timer value. Each
 137          * watchdog timer value is equivalent to 256 clock cycles.
 138          * Calculate the required value as:
 139          *   ( usec * ( system_clock_mhz / 10^6 ) / 256
 140          */
 141         ret = (usec * (rate / 1000000)) / 256;
 142
 143         return (ret);
 144 }
 145
 146 static unsigned int
 147 xgbe_riwt_to_usec(struct xgbe_prv_data *pdata, unsigned int riwt)
 148 {
 149         unsigned long rate;
 150         unsigned int ret;
 151
 152         rate = pdata->sysclk_rate;
 153
 154         /*
 155          * Convert the input watchdog timer value to the usec value. Each
 156          * watchdog timer value is equivalent to 256 clock cycles.
 157          * Calculate the required value as:
 158          *   ( riwt * 256 ) / ( system_clock_mhz / 10^6 )
 159          */
 160         ret = (riwt * 256) / (rate / 1000000);
 161
 162         return (ret);
 163 }
 164
 165 static int
 166 xgbe_config_pbl_val(struct xgbe_prv_data *pdata)
 167 {
 168         unsigned int pblx8, pbl;
 169         unsigned int i;
 170
 171         pblx8 = DMA_PBL_X8_DISABLE;
 172         pbl = pdata->pbl;
 173
 174         if (pdata->pbl > 32) {
 175                 pblx8 = DMA_PBL_X8_ENABLE;
 176                 pbl >>= 3;
 177         }
 178
 179         for (i = 0; i < pdata->channel_count; i++) {
 180                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_CR, PBLX8,
 181                     pblx8);
 182
 183                 if (pdata->channel[i]->tx_ring)
 184                         XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_TCR,
 185                             PBL, pbl);
 186
 187                 if (pdata->channel[i]->rx_ring)
 188                         XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_RCR,
 189                             PBL, pbl);
 190         }
 191
 192         return (0);
 193 }
 194
 195 static int
 196 xgbe_config_osp_mode(struct xgbe_prv_data *pdata)
 197 {
 198         unsigned int i;
 199
 200         for (i = 0; i < pdata->channel_count; i++) {
 201                 if (!pdata->channel[i]->tx_ring)
 202                         break;
 203
 204                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_TCR, OSP,
 205                     pdata->tx_osp_mode);
 206         }
 207
 208         return (0);
 209 }
 210
 211 static int
 212 xgbe_config_rsf_mode(struct xgbe_prv_data *pdata, unsigned int val)
 213 {
 214         unsigned int i;
 215
 216         for (i = 0; i < pdata->rx_q_count; i++)
 217                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQOMR, RSF, val);
 218
 219         return (0);
 220 }
 221
 222 static int
 223 xgbe_config_tsf_mode(struct xgbe_prv_data *pdata, unsigned int val)
 224 {
 225         unsigned int i;
 226
 227         for (i = 0; i < pdata->tx_q_count; i++)
 228                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_TQOMR, TSF, val);
 229
 230         return (0);
 231 }
 232
 233 static int
 234 xgbe_config_rx_threshold(struct xgbe_prv_data *pdata, unsigned int val)
 235 {
 236         unsigned int i;
 237
 238         for (i = 0; i < pdata->rx_q_count; i++)
 239                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQOMR, RTC, val);
 240
 241         return (0);
 242 }
 243
 244 static int
 245 xgbe_config_tx_threshold(struct xgbe_prv_data *pdata, unsigned int val)
 246 {
 247         unsigned int i;
 248
 249         for (i = 0; i < pdata->tx_q_count; i++)
 250                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_TQOMR, TTC, val);
 251
 252         return (0);
 253 }
 254
 255 static int
 256 xgbe_config_rx_coalesce(struct xgbe_prv_data *pdata)
 257 {
 258         unsigned int i;
 259
 260         for (i = 0; i < pdata->channel_count; i++) {
 261                 if (!pdata->channel[i]->rx_ring)
 262                         break;
 263
 264                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_RIWT, RWT,
 265                     pdata->rx_riwt);
 266         }
 267
 268         return (0);
 269 }
 270
 271 static int
 272 xgbe_config_tx_coalesce(struct xgbe_prv_data *pdata)
 273 {
 274         return (0);
 275 }
 276
 277 static void
 278 xgbe_config_rx_buffer_size(struct xgbe_prv_data *pdata)
 279 {
 280         unsigned int i;
 281
 282         for (i = 0; i < pdata->channel_count; i++) {
 283                 if (!pdata->channel[i]->rx_ring)
 284                         break;
 285
 286                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_RCR, RBSZ,
 287                     pdata->rx_buf_size);
 288         }
 289 }
 290
 291 static void
 292 xgbe_config_tso_mode(struct xgbe_prv_data *pdata)
 293 {
 294         unsigned int i;
 295
 296         int tso_enabled = (if_getcapenable(pdata->netdev) & IFCAP_TSO);
 297
 298         for (i = 0; i < pdata->channel_count; i++) {
 299                 if (!pdata->channel[i]->tx_ring)
 300                         break;
 301
 302                 axgbe_printf(1, "TSO in channel %d %s\n", i, tso_enabled ? "enabled" : "disabled");
 303                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_TCR, TSE, tso_enabled ? 1 : 0);
 304         }
 305 }
 306
 307 static void
 308 xgbe_config_sph_mode(struct xgbe_prv_data *pdata)
 309 {
 310         unsigned int i;
 311         int sph_enable_flag = XGMAC_IOREAD_BITS(pdata, MAC_HWF1R, SPHEN);
 312
 313         axgbe_printf(1, "sph_enable %d sph feature enabled?: %d\n",
 314             pdata->sph_enable, sph_enable_flag);
 315
 316         if (pdata->sph_enable && sph_enable_flag)
 317                 axgbe_printf(0, "SPH Enabled\n");
 318
 319         for (i = 0; i < pdata->channel_count; i++) {
 320                 if (!pdata->channel[i]->rx_ring)
 321                         break;
 322                 if (pdata->sph_enable && sph_enable_flag) {
 323                         /* Enable split header feature */
 324                         XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_CR, SPH, 1);
 325                 } else {
 326                         /* Disable split header feature */
 327                         XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_CR, SPH, 0);
 328                 }
 329
 330                 /* per-channel confirmation of SPH being disabled/enabled */
 331                 int val = XGMAC_DMA_IOREAD_BITS(pdata->channel[i], DMA_CH_CR, SPH);
 332                 axgbe_printf(0, "%s: SPH %s in channel %d\n", __func__,
 333                     (val ? "enabled" : "disabled"), i);
 334         }
 335
 336         if (pdata->sph_enable && sph_enable_flag)
 337                 XGMAC_IOWRITE_BITS(pdata, MAC_RCR, HDSMS, XGBE_SPH_HDSMS_SIZE);
 338 }
 339
 340 static int
 341 xgbe_write_rss_reg(struct xgbe_prv_data *pdata, unsigned int type,
 342     unsigned int index, unsigned int val)
 343 {
 344         unsigned int wait;
 345         int ret = 0;
 346
 347         mtx_lock(&pdata->rss_mutex);
 348
 349         if (XGMAC_IOREAD_BITS(pdata, MAC_RSSAR, OB)) {
 350                 ret = -EBUSY;
 351                 goto unlock;
 352         }
 353
 354         XGMAC_IOWRITE(pdata, MAC_RSSDR, val);
 355
 356         XGMAC_IOWRITE_BITS(pdata, MAC_RSSAR, RSSIA, index);
 357         XGMAC_IOWRITE_BITS(pdata, MAC_RSSAR, ADDRT, type);
 358         XGMAC_IOWRITE_BITS(pdata, MAC_RSSAR, CT, 0);
 359         XGMAC_IOWRITE_BITS(pdata, MAC_RSSAR, OB, 1);
 360
 361         wait = 1000;
 362         while (wait--) {
 363                 if (!XGMAC_IOREAD_BITS(pdata, MAC_RSSAR, OB))
 364                         goto unlock;
 365
 366                 DELAY(1000);
 367         }
 368
 369         ret = -EBUSY;
 370
 371 unlock:
 372         mtx_unlock(&pdata->rss_mutex);
 373
 374         return (ret);
 375 }
 376
 377 static int
 378 xgbe_write_rss_hash_key(struct xgbe_prv_data *pdata)
 379 {
 380         unsigned int key_regs = sizeof(pdata->rss_key) / sizeof(uint32_t);
 381         unsigned int *key = (unsigned int *)&pdata->rss_key;
 382         int ret;
 383
 384         while (key_regs--) {
 385                 ret = xgbe_write_rss_reg(pdata, XGBE_RSS_HASH_KEY_TYPE,
 386                     key_regs, *key++);
 387                 if (ret)
 388                         return (ret);
 389         }
 390
 391         return (0);
 392 }
 393
 394 static int
 395 xgbe_write_rss_lookup_table(struct xgbe_prv_data *pdata)
 396 {
 397         unsigned int i;
 398         int ret;
 399
 400         for (i = 0; i < ARRAY_SIZE(pdata->rss_table); i++) {
 401                 ret = xgbe_write_rss_reg(pdata, XGBE_RSS_LOOKUP_TABLE_TYPE, i,
 402                     pdata->rss_table[i]);
 403                 if (ret)
 404                         return (ret);
 405         }
 406
 407         return (0);
 408 }
 409
 410 static int
 411 xgbe_set_rss_hash_key(struct xgbe_prv_data *pdata, const uint8_t *key)
 412 {
 413         memcpy(pdata->rss_key, key, sizeof(pdata->rss_key));
 414
 415         return (xgbe_write_rss_hash_key(pdata));
 416 }
 417
 418 static int
 419 xgbe_set_rss_lookup_table(struct xgbe_prv_data *pdata, const uint32_t *table)
 420 {
 421         unsigned int i;
 422
 423         for (i = 0; i < ARRAY_SIZE(pdata->rss_table); i++)
 424                 XGMAC_SET_BITS(pdata->rss_table[i], MAC_RSSDR, DMCH, table[i]);
 425
 426         return (xgbe_write_rss_lookup_table(pdata));
 427 }
 428
 429 static int
 430 xgbe_enable_rss(struct xgbe_prv_data *pdata)
 431 {
 432         int ret;
 433
 434         if (!pdata->hw_feat.rss)
 435                 return (-EOPNOTSUPP);
 436
 437         /* Program the hash key */
 438         ret = xgbe_write_rss_hash_key(pdata);
 439         if (ret)
 440                 return (ret);
 441
 442         /* Program the lookup table */
 443         ret = xgbe_write_rss_lookup_table(pdata);
 444         if (ret)
 445                 return (ret);
 446
 447         /* Set the RSS options */
 448         XGMAC_IOWRITE(pdata, MAC_RSSCR, pdata->rss_options);
 449
 450         /* Enable RSS */
 451         XGMAC_IOWRITE_BITS(pdata, MAC_RSSCR, RSSE, 1);
 452
 453         axgbe_printf(0, "RSS Enabled\n");
 454
 455         return (0);
 456 }
 457
 458 static int
 459 xgbe_disable_rss(struct xgbe_prv_data *pdata)
 460 {
 461         if (!pdata->hw_feat.rss)
 462                 return (-EOPNOTSUPP);
 463
 464         XGMAC_IOWRITE_BITS(pdata, MAC_RSSCR, RSSE, 0);
 465
 466         axgbe_printf(0, "RSS Disabled\n");
 467
 468         return (0);
 469 }
 470
 471 static void
 472 xgbe_config_rss(struct xgbe_prv_data *pdata)
 473 {
 474         int ret;
 475
 476         if (!pdata->hw_feat.rss)
 477                 return;
 478
 479         /* Check if the interface has RSS capability */
 480         if (pdata->enable_rss)
 481                 ret = xgbe_enable_rss(pdata);
 482         else
 483                 ret = xgbe_disable_rss(pdata);
 484
 485         if (ret)
 486                 axgbe_error("error configuring RSS, RSS disabled\n");
 487 }
 488
 489 static int
 490 xgbe_disable_tx_flow_control(struct xgbe_prv_data *pdata)
 491 {
 492         unsigned int max_q_count, q_count;
 493         unsigned int reg, reg_val;
 494         unsigned int i;
 495
 496         /* Clear MTL flow control */
 497         for (i = 0; i < pdata->rx_q_count; i++)
 498                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQOMR, EHFC, 0);
 499
 500         /* Clear MAC flow control */
 501         max_q_count = XGMAC_MAX_FLOW_CONTROL_QUEUES;
 502         q_count = min_t(unsigned int, pdata->tx_q_count, max_q_count);
 503         reg = MAC_Q0TFCR;
 504         for (i = 0; i < q_count; i++) {
 505                 reg_val = XGMAC_IOREAD(pdata, reg);
 506                 XGMAC_SET_BITS(reg_val, MAC_Q0TFCR, TFE, 0);
 507                 XGMAC_IOWRITE(pdata, reg, reg_val);
 508
 509                 reg += MAC_QTFCR_INC;
 510         }
 511
 512         return (0);
 513 }
 514
 515 static int
 516 xgbe_enable_tx_flow_control(struct xgbe_prv_data *pdata)
 517 {
 518         unsigned int max_q_count, q_count;
 519         unsigned int reg, reg_val;
 520         unsigned int i;
 521
 522         /* Set MTL flow control */
 523         for (i = 0; i < pdata->rx_q_count; i++) {
 524                 unsigned int ehfc = 0;
 525
 526                 if (pdata->rx_rfd[i]) {
 527                         /* Flow control thresholds are established */
 528                         /* TODO - enable pfc/ets support */
 529                         ehfc = 1;
 530                 }
 531
 532                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQOMR, EHFC, ehfc);
 533
 534                 axgbe_printf(1, "flow control %s for RXq%u\n",
 535                     ehfc ? "enabled" : "disabled", i);
 536         }
 537
 538         /* Set MAC flow control */
 539         max_q_count = XGMAC_MAX_FLOW_CONTROL_QUEUES;
 540         q_count = min_t(unsigned int, pdata->tx_q_count, max_q_count);
 541         reg = MAC_Q0TFCR;
 542         for (i = 0; i < q_count; i++) {
 543                 reg_val = XGMAC_IOREAD(pdata, reg);
 544
 545                 /* Enable transmit flow control */
 546                 XGMAC_SET_BITS(reg_val, MAC_Q0TFCR, TFE, 1);
 547
 548                 /* Set pause time */
 549                 XGMAC_SET_BITS(reg_val, MAC_Q0TFCR, PT, 0xffff);
 550
 551                 XGMAC_IOWRITE(pdata, reg, reg_val);
 552
 553                 reg += MAC_QTFCR_INC;
 554         }
 555
 556         return (0);
 557 }
 558
 559 static int
 560 xgbe_disable_rx_flow_control(struct xgbe_prv_data *pdata)
 561 {
 562         XGMAC_IOWRITE_BITS(pdata, MAC_RFCR, RFE, 0);
 563
 564         return (0);
 565 }
 566
 567 static int
 568 xgbe_enable_rx_flow_control(struct xgbe_prv_data *pdata)
 569 {
 570         XGMAC_IOWRITE_BITS(pdata, MAC_RFCR, RFE, 1);
 571
 572         return (0);
 573 }
 574
 575 static int
 576 xgbe_config_tx_flow_control(struct xgbe_prv_data *pdata)
 577 {
 578         if (pdata->tx_pause)
 579                 xgbe_enable_tx_flow_control(pdata);
 580         else
 581                 xgbe_disable_tx_flow_control(pdata);
 582
 583         return (0);
 584 }
 585
 586 static int
 587 xgbe_config_rx_flow_control(struct xgbe_prv_data *pdata)
 588 {
 589         if (pdata->rx_pause)
 590                 xgbe_enable_rx_flow_control(pdata);
 591         else
 592                 xgbe_disable_rx_flow_control(pdata);
 593
 594         return (0);
 595 }
 596
 597 static void
 598 xgbe_config_flow_control(struct xgbe_prv_data *pdata)
 599 {
 600         xgbe_config_tx_flow_control(pdata);
 601         xgbe_config_rx_flow_control(pdata);
 602
 603         XGMAC_IOWRITE_BITS(pdata, MAC_RFCR, PFCE, 0);
 604 }
 605
 606 static void
 607 xgbe_enable_dma_interrupts(struct xgbe_prv_data *pdata)
 608 {
 609         struct xgbe_channel *channel;
 610         unsigned int i, ver;
 611
 612         /* Set the interrupt mode if supported */
 613         if (pdata->channel_irq_mode)
 614                 XGMAC_IOWRITE_BITS(pdata, DMA_MR, INTM,
 615                     pdata->channel_irq_mode);
 616
 617         ver = XGMAC_GET_BITS(pdata->hw_feat.version, MAC_VR, SNPSVER);
 618
 619         for (i = 0; i < pdata->channel_count; i++) {
 620                 channel = pdata->channel[i];
 621
 622                 /* Clear all the interrupts which are set */
 623                 XGMAC_DMA_IOWRITE(channel, DMA_CH_SR,
 624                                   XGMAC_DMA_IOREAD(channel, DMA_CH_SR));
 625
 626                 /* Clear all interrupt enable bits */
 627                 channel->curr_ier = 0;
 628
 629                 /* Enable following interrupts
 630                  *   NIE  - Normal Interrupt Summary Enable
 631                  *   AIE  - Abnormal Interrupt Summary Enable
 632                  *   FBEE - Fatal Bus Error Enable
 633                  */
 634                 if (ver < 0x21) {
 635                         XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, NIE20, 1);
 636                         XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, AIE20, 1);
 637                 } else {
 638                         XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, NIE, 1);
 639                         XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, AIE, 1);
 640                 }
 641                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, FBEE, 1);
 642
 643                 if (channel->tx_ring) {
 644                         /* Enable the following Tx interrupts
 645                          *   TIE  - Transmit Interrupt Enable (unless using
 646                          *        per channel interrupts in edge triggered
 647                          *        mode)
 648                          */
 649                         if (!pdata->per_channel_irq || pdata->channel_irq_mode)
 650                                 XGMAC_SET_BITS(channel->curr_ier,
 651                                                DMA_CH_IER, TIE, 1);
 652                 }
 653                 if (channel->rx_ring) {
 654                         /* Enable following Rx interrupts
 655                          *   RBUE - Receive Buffer Unavailable Enable
 656                          *   RIE  - Receive Interrupt Enable (unless using
 657                          *        per channel interrupts in edge triggered
 658                          *        mode)
 659                          */
 660                         XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, RBUE, 1);
 661                         if (!pdata->per_channel_irq || pdata->channel_irq_mode)
 662                                 XGMAC_SET_BITS(channel->curr_ier,
 663                                                DMA_CH_IER, RIE, 1);
 664                 }
 665
 666                 XGMAC_DMA_IOWRITE(channel, DMA_CH_IER, channel->curr_ier);
 667         }
 668 }
 669
 670 static void
 671 xgbe_enable_mtl_interrupts(struct xgbe_prv_data *pdata)
 672 {
 673         unsigned int mtl_q_isr;
 674         unsigned int q_count, i;
 675
 676         q_count = max(pdata->hw_feat.tx_q_cnt, pdata->hw_feat.rx_q_cnt);
 677         for (i = 0; i < q_count; i++) {
 678                 /* Clear all the interrupts which are set */
 679                 mtl_q_isr = XGMAC_MTL_IOREAD(pdata, i, MTL_Q_ISR);
 680                 XGMAC_MTL_IOWRITE(pdata, i, MTL_Q_ISR, mtl_q_isr);
 681
 682                 /* No MTL interrupts to be enabled */
 683                 XGMAC_MTL_IOWRITE(pdata, i, MTL_Q_IER, 0);
 684         }
 685 }
 686
 687 static void
 688 xgbe_enable_mac_interrupts(struct xgbe_prv_data *pdata)
 689 {
 690         unsigned int mac_ier = 0;
 691
 692         /* Enable Timestamp interrupt */
 693         XGMAC_SET_BITS(mac_ier, MAC_IER, TSIE, 1);
 694
 695         XGMAC_IOWRITE(pdata, MAC_IER, mac_ier);
 696
 697         /* Enable all counter interrupts */
 698         XGMAC_IOWRITE_BITS(pdata, MMC_RIER, ALL_INTERRUPTS, 0xffffffff);
 699         XGMAC_IOWRITE_BITS(pdata, MMC_TIER, ALL_INTERRUPTS, 0xffffffff);
 700
 701         /* Enable MDIO single command completion interrupt */
 702         XGMAC_IOWRITE_BITS(pdata, MAC_MDIOIER, SNGLCOMPIE, 1);
 703 }
 704
 705 static int
 706 xgbe_set_speed(struct xgbe_prv_data *pdata, int speed)
 707 {
 708         unsigned int ss;
 709
 710         switch (speed) {
 711         case SPEED_1000:
 712                 ss = 0x03;
 713                 break;
 714         case SPEED_2500:
 715                 ss = 0x02;
 716                 break;
 717         case SPEED_10000:
 718                 ss = 0x00;
 719                 break;
 720         default:
 721                 return (-EINVAL);
 722         }
 723
 724         if (XGMAC_IOREAD_BITS(pdata, MAC_TCR, SS) != ss)
 725                 XGMAC_IOWRITE_BITS(pdata, MAC_TCR, SS, ss);
 726
 727         return (0);
 728 }
 729
 730 static int
 731 xgbe_enable_rx_vlan_stripping(struct xgbe_prv_data *pdata)
 732 {
 733         /* Put the VLAN tag in the Rx descriptor */
 734         XGMAC_IOWRITE_BITS(pdata, MAC_VLANTR, EVLRXS, 1);
 735
 736         /* Don't check the VLAN type */
 737         XGMAC_IOWRITE_BITS(pdata, MAC_VLANTR, DOVLTC, 1);
 738
 739         /* Check only C-TAG (0x8100) packets */
 740         XGMAC_IOWRITE_BITS(pdata, MAC_VLANTR, ERSVLM, 0);
 741
 742         /* Don't consider an S-TAG (0x88A8) packet as a VLAN packet */
 743         XGMAC_IOWRITE_BITS(pdata, MAC_VLANTR, ESVL, 0);
 744
 745         /* Enable VLAN tag stripping */
 746         XGMAC_IOWRITE_BITS(pdata, MAC_VLANTR, EVLS, 0x3);
 747
 748         axgbe_printf(0, "VLAN Stripping Enabled\n");
 749
 750         return (0);
 751 }
 752
 753 static int
 754 xgbe_disable_rx_vlan_stripping(struct xgbe_prv_data *pdata)
 755 {
 756         XGMAC_IOWRITE_BITS(pdata, MAC_VLANTR, EVLS, 0);
 757
 758         axgbe_printf(0, "VLAN Stripping Disabled\n");
 759
 760         return (0);
 761 }
 762
 763 static int
 764 xgbe_enable_rx_vlan_filtering(struct xgbe_prv_data *pdata)
 765 {
 766         /* Enable VLAN filtering */
 767         XGMAC_IOWRITE_BITS(pdata, MAC_PFR, VTFE, 1);
 768
 769         /* Enable VLAN Hash Table filtering */
 770         XGMAC_IOWRITE_BITS(pdata, MAC_VLANTR, VTHM, 1);
 771
 772         /* Disable VLAN tag inverse matching */
 773         XGMAC_IOWRITE_BITS(pdata, MAC_VLANTR, VTIM, 0);
 774
 775         /* Only filter on the lower 12-bits of the VLAN tag */
 776         XGMAC_IOWRITE_BITS(pdata, MAC_VLANTR, ETV, 1);
 777
 778         /* In order for the VLAN Hash Table filtering to be effective,
 779          * the VLAN tag identifier in the VLAN Tag Register must not
 780          * be zero.  Set the VLAN tag identifier to "1" to enable the
 781          * VLAN Hash Table filtering.  This implies that a VLAN tag of
 782          * 1 will always pass filtering.
 783          */
 784         XGMAC_IOWRITE_BITS(pdata, MAC_VLANTR, VL, 1);
 785
 786         axgbe_printf(0, "VLAN filtering Enabled\n");
 787
 788         return (0);
 789 }
 790
 791 static int
 792 xgbe_disable_rx_vlan_filtering(struct xgbe_prv_data *pdata)
 793 {
 794         /* Disable VLAN filtering */
 795         XGMAC_IOWRITE_BITS(pdata, MAC_PFR, VTFE, 0);
 796
 797         axgbe_printf(0, "VLAN filtering Disabled\n");
 798
 799         return (0);
 800 }
 801
 802 static uint32_t
 803 xgbe_vid_crc32_le(__le16 vid_le)
 804 {
 805         uint32_t crc = ~0;
 806         uint32_t temp = 0;
 807         unsigned char *data = (unsigned char *)&vid_le;
 808         unsigned char data_byte = 0;
 809         int i, bits;
 810
 811         bits = get_bitmask_order(VLAN_VID_MASK);
 812         for (i = 0; i < bits; i++) {
 813                 if ((i % 8) == 0)
 814                         data_byte = data[i / 8];
 815
 816                 temp = ((crc & 1) ^ data_byte) & 1;
 817                 crc >>= 1;
 818                 data_byte >>= 1;
 819
 820                 if (temp)
 821                         crc ^= CRC32_POLY_LE;
 822         }
 823
 824         return (crc);
 825 }
 826
 827 static int
 828 xgbe_update_vlan_hash_table(struct xgbe_prv_data *pdata)
 829 {
 830         uint32_t crc;
 831         uint16_t vid;
 832         uint16_t vlan_hash_table = 0;
 833         __le16 vid_le = 0;
 834
 835         axgbe_printf(1, "%s: Before updating VLANHTR 0x%x\n", __func__,
 836             XGMAC_IOREAD(pdata, MAC_VLANHTR));
 837
 838         /* Generate the VLAN Hash Table value */
 839         for_each_set_bit(vid, pdata->active_vlans, VLAN_NVID) {
 840
 841                 /* Get the CRC32 value of the VLAN ID */
 842                 vid_le = cpu_to_le16(vid);
 843                 crc = bitrev32(~xgbe_vid_crc32_le(vid_le)) >> 28;
 844
 845                 vlan_hash_table |= (1 << crc);
 846                 axgbe_printf(1, "%s: vid 0x%x vid_le 0x%x crc 0x%x "
 847                     "vlan_hash_table 0x%x\n", __func__, vid, vid_le, crc,
 848                     vlan_hash_table);
 849         }
 850
 851         /* Set the VLAN Hash Table filtering register */
 852         XGMAC_IOWRITE_BITS(pdata, MAC_VLANHTR, VLHT, vlan_hash_table);
 853
 854         axgbe_printf(1, "%s: After updating VLANHTR 0x%x\n", __func__,
 855                 XGMAC_IOREAD(pdata, MAC_VLANHTR));
 856
 857         return (0);
 858 }
 859
 860 static int
 861 xgbe_set_promiscuous_mode(struct xgbe_prv_data *pdata, unsigned int enable)
 862 {
 863         unsigned int val = enable ? 1 : 0;
 864
 865         if (XGMAC_IOREAD_BITS(pdata, MAC_PFR, PR) == val)
 866                 return (0);
 867
 868         axgbe_printf(1, "%s promiscous mode\n", enable? "entering" : "leaving");
 869
 870         XGMAC_IOWRITE_BITS(pdata, MAC_PFR, PR, val);
 871
 872         /* Hardware will still perform VLAN filtering in promiscuous mode */
 873         if (enable) {
 874                 axgbe_printf(1, "Disabling rx vlan filtering\n");
 875                 xgbe_disable_rx_vlan_filtering(pdata);
 876         } else {
 877                 if ((if_getcapenable(pdata->netdev) & IFCAP_VLAN_HWFILTER)) {
 878                         axgbe_printf(1, "Enabling rx vlan filtering\n");
 879                         xgbe_enable_rx_vlan_filtering(pdata);
 880                 }
 881         }
 882
 883         return (0);
 884 }
 885
 886 static int
 887 xgbe_set_all_multicast_mode(struct xgbe_prv_data *pdata, unsigned int enable)
 888 {
 889         unsigned int val = enable ? 1 : 0;
 890
 891         if (XGMAC_IOREAD_BITS(pdata, MAC_PFR, PM) == val)
 892                 return (0);
 893
 894         axgbe_printf(1,"%s allmulti mode\n", enable ? "entering" : "leaving");
 895         XGMAC_IOWRITE_BITS(pdata, MAC_PFR, PM, val);
 896
 897         return (0);
 898 }
 899
 900 static void
 901 xgbe_set_mac_reg(struct xgbe_prv_data *pdata, char *addr, unsigned int *mac_reg)
 902 {
 903         unsigned int mac_addr_hi, mac_addr_lo;
 904         uint8_t *mac_addr;
 905
 906         mac_addr_lo = 0;
 907         mac_addr_hi = 0;
 908
 909         if (addr) {
 910                 mac_addr = (uint8_t *)&mac_addr_lo;
 911                 mac_addr[0] = addr[0];
 912                 mac_addr[1] = addr[1];
 913                 mac_addr[2] = addr[2];
 914                 mac_addr[3] = addr[3];
 915                 mac_addr = (uint8_t *)&mac_addr_hi;
 916                 mac_addr[0] = addr[4];
 917                 mac_addr[1] = addr[5];
 918
 919                 axgbe_printf(1, "adding mac address %pM at %#x\n", addr, *mac_reg);
 920
 921                 XGMAC_SET_BITS(mac_addr_hi, MAC_MACA1HR, AE, 1);
 922         }
 923
 924         XGMAC_IOWRITE(pdata, *mac_reg, mac_addr_hi);
 925         *mac_reg += MAC_MACA_INC;
 926         XGMAC_IOWRITE(pdata, *mac_reg, mac_addr_lo);
 927         *mac_reg += MAC_MACA_INC;
 928 }
 929
 930 static void
 931 xgbe_set_mac_addn_addrs(struct xgbe_prv_data *pdata)
 932 {
 933         unsigned int mac_reg;
 934         unsigned int addn_macs;
 935
 936         mac_reg = MAC_MACA1HR;
 937         addn_macs = pdata->hw_feat.addn_mac;
 938
 939         xgbe_set_mac_reg(pdata, pdata->mac_addr, &mac_reg);
 940         addn_macs--;
 941
 942         /* Clear remaining additional MAC address entries */
 943         while (addn_macs--)
 944                 xgbe_set_mac_reg(pdata, NULL, &mac_reg);
 945 }
 946
 947 static int
 948 xgbe_add_mac_addresses(struct xgbe_prv_data *pdata)
 949 {
 950         /* TODO - add support to set mac hash table */
 951         xgbe_set_mac_addn_addrs(pdata);
 952
 953         return (0);
 954 }
 955
 956 static int
 957 xgbe_set_mac_address(struct xgbe_prv_data *pdata, uint8_t *addr)
 958 {
 959         unsigned int mac_addr_hi, mac_addr_lo;
 960
 961         mac_addr_hi = (addr[5] <<  8) | (addr[4] <<  0);
 962         mac_addr_lo = (addr[3] << 24) | (addr[2] << 16) |
 963                       (addr[1] <<  8) | (addr[0] <<  0);
 964
 965         XGMAC_IOWRITE(pdata, MAC_MACA0HR, mac_addr_hi);
 966         XGMAC_IOWRITE(pdata, MAC_MACA0LR, mac_addr_lo);
 967
 968         return (0);
 969 }
 970
 971 static int
 972 xgbe_config_rx_mode(struct xgbe_prv_data *pdata)
 973 {
 974         unsigned int pr_mode, am_mode;
 975
 976         pr_mode = ((pdata->netdev->if_flags & IFF_PPROMISC) != 0);
 977         am_mode = ((pdata->netdev->if_flags & IFF_ALLMULTI) != 0);
 978
 979         xgbe_set_promiscuous_mode(pdata, pr_mode);
 980         xgbe_set_all_multicast_mode(pdata, am_mode);
 981
 982         xgbe_add_mac_addresses(pdata);
 983
 984         return (0);
 985 }
 986
 987 static int
 988 xgbe_clr_gpio(struct xgbe_prv_data *pdata, unsigned int gpio)
 989 {
 990         unsigned int reg;
 991
 992         if (gpio > 15)
 993                 return (-EINVAL);
 994
 995         reg = XGMAC_IOREAD(pdata, MAC_GPIOSR);
 996
 997         reg &= ~(1 << (gpio + 16));
 998         XGMAC_IOWRITE(pdata, MAC_GPIOSR, reg);
 999
1000         return (0);
1001 }
1002
1003 static int
1004 xgbe_set_gpio(struct xgbe_prv_data *pdata, unsigned int gpio)
1005 {
1006         unsigned int reg;
1007
1008         if (gpio > 15)
1009                 return (-EINVAL);
1010
1011         reg = XGMAC_IOREAD(pdata, MAC_GPIOSR);
1012
1013         reg |= (1 << (gpio + 16));
1014         XGMAC_IOWRITE(pdata, MAC_GPIOSR, reg);
1015
1016         return (0);
1017 }
1018
1019 static int
1020 xgbe_read_mmd_regs_v2(struct xgbe_prv_data *pdata, int prtad, int mmd_reg)
1021 {
1022         unsigned long flags;
1023         unsigned int mmd_address, index, offset;
1024         int mmd_data;
1025
1026         if (mmd_reg & MII_ADDR_C45)
1027                 mmd_address = mmd_reg & ~MII_ADDR_C45;
1028         else
1029                 mmd_address = (pdata->mdio_mmd << 16) | (mmd_reg & 0xffff);
1030
1031         /* The PCS registers are accessed using mmio. The underlying
1032          * management interface uses indirect addressing to access the MMD
1033          * register sets. This requires accessing of the PCS register in two
1034          * phases, an address phase and a data phase.
1035          *
1036          * The mmio interface is based on 16-bit offsets and values. All
1037          * register offsets must therefore be adjusted by left shifting the
1038          * offset 1 bit and reading 16 bits of data.
1039          */
1040         mmd_address <<= 1;
1041         index = mmd_address & ~pdata->xpcs_window_mask;
1042         offset = pdata->xpcs_window + (mmd_address & pdata->xpcs_window_mask);
1043
1044         spin_lock_irqsave(&pdata->xpcs_lock, flags);
1045         XPCS32_IOWRITE(pdata, pdata->xpcs_window_sel_reg, index);
1046         mmd_data = XPCS16_IOREAD(pdata, offset);
1047         spin_unlock_irqrestore(&pdata->xpcs_lock, flags);
1048
1049         return (mmd_data);
1050 }
1051
1052 static void
1053 xgbe_write_mmd_regs_v2(struct xgbe_prv_data *pdata, int prtad, int mmd_reg,
1054     int mmd_data)
1055 {
1056         unsigned long flags;
1057         unsigned int mmd_address, index, offset;
1058
1059         if (mmd_reg & MII_ADDR_C45)
1060                 mmd_address = mmd_reg & ~MII_ADDR_C45;
1061         else
1062                 mmd_address = (pdata->mdio_mmd << 16) | (mmd_reg & 0xffff);
1063
1064         /* The PCS registers are accessed using mmio. The underlying
1065          * management interface uses indirect addressing to access the MMD
1066          * register sets. This requires accessing of the PCS register in two
1067          * phases, an address phase and a data phase.
1068          *
1069          * The mmio interface is based on 16-bit offsets and values. All
1070          * register offsets must therefore be adjusted by left shifting the
1071          * offset 1 bit and writing 16 bits of data.
1072          */
1073         mmd_address <<= 1;
1074         index = mmd_address & ~pdata->xpcs_window_mask;
1075         offset = pdata->xpcs_window + (mmd_address & pdata->xpcs_window_mask);
1076
1077         spin_lock_irqsave(&pdata->xpcs_lock, flags);
1078         XPCS32_IOWRITE(pdata, pdata->xpcs_window_sel_reg, index);
1079         XPCS16_IOWRITE(pdata, offset, mmd_data);
1080         spin_unlock_irqrestore(&pdata->xpcs_lock, flags);
1081 }
1082
1083 static int
1084 xgbe_read_mmd_regs_v1(struct xgbe_prv_data *pdata, int prtad, int mmd_reg)
1085 {
1086         unsigned long flags;
1087         unsigned int mmd_address;
1088         int mmd_data;
1089
1090         if (mmd_reg & MII_ADDR_C45)
1091                 mmd_address = mmd_reg & ~MII_ADDR_C45;
1092         else
1093                 mmd_address = (pdata->mdio_mmd << 16) | (mmd_reg & 0xffff);
1094
1095         /* The PCS registers are accessed using mmio. The underlying APB3
1096          * management interface uses indirect addressing to access the MMD
1097          * register sets. This requires accessing of the PCS register in two
1098          * phases, an address phase and a data phase.
1099          *
1100          * The mmio interface is based on 32-bit offsets and values. All
1101          * register offsets must therefore be adjusted by left shifting the
1102          * offset 2 bits and reading 32 bits of data.
1103          */
1104         spin_lock_irqsave(&pdata->xpcs_lock, flags);
1105         XPCS32_IOWRITE(pdata, PCS_V1_WINDOW_SELECT, mmd_address >> 8);
1106         mmd_data = XPCS32_IOREAD(pdata, (mmd_address & 0xff) << 2);
1107         spin_unlock_irqrestore(&pdata->xpcs_lock, flags);
1108
1109         return (mmd_data);
1110 }
1111
1112 static void
1113 xgbe_write_mmd_regs_v1(struct xgbe_prv_data *pdata, int prtad, int mmd_reg,
1114     int mmd_data)
1115 {
1116         unsigned int mmd_address;
1117         unsigned long flags;
1118
1119         if (mmd_reg & MII_ADDR_C45)
1120                 mmd_address = mmd_reg & ~MII_ADDR_C45;
1121         else
1122                 mmd_address = (pdata->mdio_mmd << 16) | (mmd_reg & 0xffff);
1123
1124         /* The PCS registers are accessed using mmio. The underlying APB3
1125          * management interface uses indirect addressing to access the MMD
1126          * register sets. This requires accessing of the PCS register in two
1127          * phases, an address phase and a data phase.
1128          *
1129          * The mmio interface is based on 32-bit offsets and values. All
1130          * register offsets must therefore be adjusted by left shifting the
1131          * offset 2 bits and writing 32 bits of data.
1132          */
1133         spin_lock_irqsave(&pdata->xpcs_lock, flags);
1134         XPCS32_IOWRITE(pdata, PCS_V1_WINDOW_SELECT, mmd_address >> 8);
1135         XPCS32_IOWRITE(pdata, (mmd_address & 0xff) << 2, mmd_data);
1136         spin_unlock_irqrestore(&pdata->xpcs_lock, flags);
1137 }
1138
1139 static int
1140 xgbe_read_mmd_regs(struct xgbe_prv_data *pdata, int prtad, int mmd_reg)
1141 {
1142         switch (pdata->vdata->xpcs_access) {
1143         case XGBE_XPCS_ACCESS_V1:
1144                 return (xgbe_read_mmd_regs_v1(pdata, prtad, mmd_reg));
1145
1146         case XGBE_XPCS_ACCESS_V2:
1147         default:
1148                 return (xgbe_read_mmd_regs_v2(pdata, prtad, mmd_reg));
1149         }
1150 }
1151
1152 static void
1153 xgbe_write_mmd_regs(struct xgbe_prv_data *pdata, int prtad, int mmd_reg,
1154     int mmd_data)
1155 {
1156         switch (pdata->vdata->xpcs_access) {
1157         case XGBE_XPCS_ACCESS_V1:
1158                 return (xgbe_write_mmd_regs_v1(pdata, prtad, mmd_reg, mmd_data));
1159
1160         case XGBE_XPCS_ACCESS_V2:
1161         default:
1162                 return (xgbe_write_mmd_regs_v2(pdata, prtad, mmd_reg, mmd_data));
1163         }
1164 }
1165
1166 static unsigned int
1167 xgbe_create_mdio_sca(int port, int reg)
1168 {
1169         unsigned int mdio_sca, da;
1170
1171         da = (reg & MII_ADDR_C45) ? reg >> 16 : 0;
1172
1173         mdio_sca = 0;
1174         XGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, RA, reg);
1175         XGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, PA, port);
1176         XGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, DA, da);
1177
1178         return (mdio_sca);
1179 }
1180
1181 static int
1182 xgbe_write_ext_mii_regs(struct xgbe_prv_data *pdata, int addr, int reg,
1183     uint16_t val)
1184 {
1185         unsigned int mdio_sca, mdio_sccd;
1186
1187         mtx_lock_spin(&pdata->mdio_mutex);
1188
1189         mdio_sca = xgbe_create_mdio_sca(addr, reg);
1190         XGMAC_IOWRITE(pdata, MAC_MDIOSCAR, mdio_sca);
1191
1192         mdio_sccd = 0;
1193         XGMAC_SET_BITS(mdio_sccd, MAC_MDIOSCCDR, DATA, val);
1194         XGMAC_SET_BITS(mdio_sccd, MAC_MDIOSCCDR, CMD, 1);
1195         XGMAC_SET_BITS(mdio_sccd, MAC_MDIOSCCDR, BUSY, 1);
1196         XGMAC_IOWRITE(pdata, MAC_MDIOSCCDR, mdio_sccd);
1197
1198         if (msleep_spin(pdata, &pdata->mdio_mutex, "mdio_xfer", hz / 8) ==
1199             EWOULDBLOCK) {
1200                 axgbe_error("%s: MDIO write error\n", __func__);
1201                 mtx_unlock_spin(&pdata->mdio_mutex);
1202                 return (-ETIMEDOUT);
1203         }
1204
1205         mtx_unlock_spin(&pdata->mdio_mutex);
1206         return (0);
1207 }
1208
1209 static int
1210 xgbe_read_ext_mii_regs(struct xgbe_prv_data *pdata, int addr, int reg)
1211 {
1212         unsigned int mdio_sca, mdio_sccd;
1213
1214         mtx_lock_spin(&pdata->mdio_mutex);
1215
1216         mdio_sca = xgbe_create_mdio_sca(addr, reg);
1217         XGMAC_IOWRITE(pdata, MAC_MDIOSCAR, mdio_sca);
1218
1219         mdio_sccd = 0;
1220         XGMAC_SET_BITS(mdio_sccd, MAC_MDIOSCCDR, CMD, 3);
1221         XGMAC_SET_BITS(mdio_sccd, MAC_MDIOSCCDR, BUSY, 1);
1222         XGMAC_IOWRITE(pdata, MAC_MDIOSCCDR, mdio_sccd);
1223
1224         if (msleep_spin(pdata, &pdata->mdio_mutex, "mdio_xfer", hz / 8) ==
1225             EWOULDBLOCK) {
1226                 axgbe_error("%s: MDIO read error\n", __func__);
1227                 mtx_unlock_spin(&pdata->mdio_mutex);
1228                 return (-ETIMEDOUT);
1229         }
1230
1231         mtx_unlock_spin(&pdata->mdio_mutex);
1232
1233         return (XGMAC_IOREAD_BITS(pdata, MAC_MDIOSCCDR, DATA));
1234 }
1235
1236 static int
1237 xgbe_set_ext_mii_mode(struct xgbe_prv_data *pdata, unsigned int port,
1238     enum xgbe_mdio_mode mode)
1239 {
1240         unsigned int reg_val = XGMAC_IOREAD(pdata, MAC_MDIOCL22R);
1241
1242         switch (mode) {
1243         case XGBE_MDIO_MODE_CL22:
1244                 if (port > XGMAC_MAX_C22_PORT)
1245                         return (-EINVAL);
1246                 reg_val |= (1 << port);
1247                 break;
1248         case XGBE_MDIO_MODE_CL45:
1249                 break;
1250         default:
1251                 return (-EINVAL);
1252         }
1253
1254         XGMAC_IOWRITE(pdata, MAC_MDIOCL22R, reg_val);
1255
1256         return (0);
1257 }
1258
1259 static int
1260 xgbe_tx_complete(struct xgbe_ring_desc *rdesc)
1261 {
1262         return (!XGMAC_GET_BITS_LE(rdesc->desc3, TX_NORMAL_DESC3, OWN));
1263 }
1264
1265 static int
1266 xgbe_disable_rx_csum(struct xgbe_prv_data *pdata)
1267 {
1268         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, IPC, 0);
1269
1270         axgbe_printf(0, "Receive checksum offload Disabled\n");
1271         return (0);
1272 }
1273
1274 static int
1275 xgbe_enable_rx_csum(struct xgbe_prv_data *pdata)
1276 {
1277         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, IPC, 1);
1278
1279         axgbe_printf(0, "Receive checksum offload Enabled\n");
1280         return (0);
1281 }
1282
1283 static void
1284 xgbe_tx_desc_reset(struct xgbe_ring_data *rdata)
1285 {
1286         struct xgbe_ring_desc *rdesc = rdata->rdesc;
1287
1288         /* Reset the Tx descriptor
1289          *   Set buffer 1 (lo) address to zero
1290          *   Set buffer 1 (hi) address to zero
1291          *   Reset all other control bits (IC, TTSE, B2L & B1L)
1292          *   Reset all other control bits (OWN, CTXT, FD, LD, CPC, CIC, etc)
1293          */
1294         rdesc->desc0 = 0;
1295         rdesc->desc1 = 0;
1296         rdesc->desc2 = 0;
1297         rdesc->desc3 = 0;
1298
1299         wmb();
1300 }
1301
1302 static void
1303 xgbe_tx_desc_init(struct xgbe_channel *channel)
1304 {
1305         struct xgbe_ring *ring = channel->tx_ring;
1306         struct xgbe_ring_data *rdata;
1307         int i;
1308         int start_index = ring->cur;
1309
1310         /* Initialze all descriptors */
1311         for (i = 0; i < ring->rdesc_count; i++) {
1312                 rdata = XGBE_GET_DESC_DATA(ring, i);
1313
1314                 /* Initialize Tx descriptor */
1315                 xgbe_tx_desc_reset(rdata);
1316         }
1317
1318         /* Update the total number of Tx descriptors */
1319         XGMAC_DMA_IOWRITE(channel, DMA_CH_TDRLR, ring->rdesc_count - 1);
1320
1321         /* Update the starting address of descriptor ring */
1322         rdata = XGBE_GET_DESC_DATA(ring, start_index);
1323         XGMAC_DMA_IOWRITE(channel, DMA_CH_TDLR_HI,
1324             upper_32_bits(rdata->rdata_paddr));
1325         XGMAC_DMA_IOWRITE(channel, DMA_CH_TDLR_LO,
1326             lower_32_bits(rdata->rdata_paddr));
1327 }
1328
1329 static void
1330 xgbe_rx_desc_init(struct xgbe_channel *channel)
1331 {
1332         struct xgbe_ring *ring = channel->rx_ring;
1333         struct xgbe_ring_data *rdata;
1334         unsigned int start_index = ring->cur;
1335
1336         /*
1337          * Just set desc_count and the starting address of the desc list
1338          * here. Rest will be done as part of the txrx path.
1339          */
1340
1341         /* Update the total number of Rx descriptors */
1342         XGMAC_DMA_IOWRITE(channel, DMA_CH_RDRLR, ring->rdesc_count - 1);
1343
1344         /* Update the starting address of descriptor ring */
1345         rdata = XGBE_GET_DESC_DATA(ring, start_index);
1346         XGMAC_DMA_IOWRITE(channel, DMA_CH_RDLR_HI,
1347             upper_32_bits(rdata->rdata_paddr));
1348         XGMAC_DMA_IOWRITE(channel, DMA_CH_RDLR_LO,
1349             lower_32_bits(rdata->rdata_paddr));
1350 }
1351
1352 static int
1353 xgbe_dev_read(struct xgbe_channel *channel)
1354 {
1355         struct xgbe_prv_data *pdata = channel->pdata;
1356         struct xgbe_ring *ring = channel->rx_ring;
1357         struct xgbe_ring_data *rdata;
1358         struct xgbe_ring_desc *rdesc;
1359         struct xgbe_packet_data *packet = &ring->packet_data;
1360         unsigned int err, etlt, l34t = 0;
1361
1362         axgbe_printf(1, "-->xgbe_dev_read: cur = %d\n", ring->cur);
1363
1364         rdata = XGBE_GET_DESC_DATA(ring, ring->cur);
1365         rdesc = rdata->rdesc;
1366
1367         /* Check for data availability */
1368         if (XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, OWN))
1369                 return (1);
1370
1371         rmb();
1372
1373         if (XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, CTXT)) {
1374                 /* TODO - Timestamp Context Descriptor */
1375                 XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1376                     CONTEXT, 1);
1377                 XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1378                     CONTEXT_NEXT, 0);
1379                 return (0);
1380         }
1381
1382         /* Normal Descriptor, be sure Context Descriptor bit is off */
1383         XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES, CONTEXT, 0);
1384
1385         /* Indicate if a Context Descriptor is next */
1386         if (XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, CDA))
1387                 XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1388                     CONTEXT_NEXT, 1);
1389
1390         /* Get the header length */
1391         if (XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, FD)) {
1392                 XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1393                     FIRST, 1);
1394                 rdata->rx.hdr_len = XGMAC_GET_BITS_LE(rdesc->desc2,
1395                     RX_NORMAL_DESC2, HL);
1396                 if (rdata->rx.hdr_len)
1397                         pdata->ext_stats.rx_split_header_packets++;
1398         } else
1399                 XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1400                     FIRST, 0);
1401
1402         /* Get the RSS hash */
1403         if (XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, RSV)) {
1404                 XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1405                     RSS_HASH, 1);
1406
1407                 packet->rss_hash = le32_to_cpu(rdesc->desc1);
1408
1409                 l34t = XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, L34T);
1410                 switch (l34t) {
1411                 case RX_DESC3_L34T_IPV4_TCP:
1412                         packet->rss_hash_type = M_HASHTYPE_RSS_TCP_IPV4;
1413                         break;
1414                 case RX_DESC3_L34T_IPV4_UDP:
1415                         packet->rss_hash_type = M_HASHTYPE_RSS_UDP_IPV4;
1416                         break;
1417                 case RX_DESC3_L34T_IPV6_TCP:
1418                         packet->rss_hash_type = M_HASHTYPE_RSS_TCP_IPV6;
1419                         break;
1420                 case RX_DESC3_L34T_IPV6_UDP:
1421                         packet->rss_hash_type = M_HASHTYPE_RSS_UDP_IPV6;
1422                         break;
1423                 default:
1424                         packet->rss_hash_type = M_HASHTYPE_OPAQUE;
1425                         break;
1426                 }
1427         }
1428
1429         /* Not all the data has been transferred for this packet */
1430         if (!XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, LD)) {
1431                 /* This is not the last of the data for this packet */
1432                 XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1433                     LAST, 0);
1434                 return (0);
1435         }
1436
1437         /* This is the last of the data for this packet */
1438         XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1439             LAST, 1);
1440
1441         /* Get the packet length */
1442         rdata->rx.len = XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, PL);
1443
1444         /* Set checksum done indicator as appropriate */
1445         /* TODO - add tunneling support */
1446         XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1447             CSUM_DONE, 1);
1448
1449         /* Check for errors (only valid in last descriptor) */
1450         err = XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, ES);
1451         etlt = XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, ETLT);
1452         axgbe_printf(1, "%s: err=%u, etlt=%#x\n", __func__, err, etlt);
1453
1454         if (!err || !etlt) {
1455                 /* No error if err is 0 or etlt is 0 */
1456                 if (etlt == 0x09) {
1457                         XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1458                             VLAN_CTAG, 1);
1459                         packet->vlan_ctag = XGMAC_GET_BITS_LE(rdesc->desc0,
1460                             RX_NORMAL_DESC0, OVT);
1461                         axgbe_printf(1, "vlan-ctag=%#06x\n", packet->vlan_ctag);
1462                 }
1463         } else {
1464                 unsigned int tnp = XGMAC_GET_BITS(packet->attributes,
1465                     RX_PACKET_ATTRIBUTES, TNP);
1466
1467                 if ((etlt == 0x05) || (etlt == 0x06)) {
1468                         axgbe_printf(1, "%s: err1 l34t %d err 0x%x etlt 0x%x\n",
1469                             __func__, l34t, err, etlt);
1470                         XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1471                             CSUM_DONE, 0);
1472                         XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1473                             TNPCSUM_DONE, 0);
1474                         pdata->ext_stats.rx_csum_errors++;
1475                 } else if (tnp && ((etlt == 0x09) || (etlt == 0x0a))) {
1476                         axgbe_printf(1, "%s: err2  l34t %d err 0x%x etlt 0x%x\n",
1477                             __func__, l34t, err, etlt);
1478                         XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1479                             CSUM_DONE, 0);
1480                         XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES,
1481                             TNPCSUM_DONE, 0);
1482                         pdata->ext_stats.rx_vxlan_csum_errors++;
1483                 } else {
1484                         axgbe_printf(1, "%s: tnp %d l34t %d err 0x%x etlt 0x%x\n",
1485                             __func__, tnp, l34t, err, etlt);
1486                         axgbe_printf(1, "%s: Channel: %d SR 0x%x DSR 0x%x \n",
1487                             __func__, channel->queue_index,
1488                             XGMAC_DMA_IOREAD(channel, DMA_CH_SR),
1489                             XGMAC_DMA_IOREAD(channel, DMA_CH_DSR));
1490                         axgbe_printf(1, "%s: ring cur %d dirty %d\n",
1491                             __func__, ring->cur, ring->dirty);
1492                         axgbe_printf(1, "%s: Desc 0x%08x-0x%08x-0x%08x-0x%08x\n",
1493                             __func__, rdesc->desc0, rdesc->desc1, rdesc->desc2,
1494                             rdesc->desc3);
1495                         XGMAC_SET_BITS(packet->errors, RX_PACKET_ERRORS,
1496                             FRAME, 1);
1497                 }
1498         }
1499
1500         axgbe_printf(1, "<--xgbe_dev_read: %s - descriptor=%u (cur=%d)\n",
1501             channel->name, ring->cur & (ring->rdesc_count - 1), ring->cur);
1502
1503         return (0);
1504 }
1505
1506 static int
1507 xgbe_is_context_desc(struct xgbe_ring_desc *rdesc)
1508 {
1509         /* Rx and Tx share CTXT bit, so check TDES3.CTXT bit */
1510         return (XGMAC_GET_BITS_LE(rdesc->desc3, TX_NORMAL_DESC3, CTXT));
1511 }
1512
1513 static int
1514 xgbe_is_last_desc(struct xgbe_ring_desc *rdesc)
1515 {
1516         /* Rx and Tx share LD bit, so check TDES3.LD bit */
1517         return (XGMAC_GET_BITS_LE(rdesc->desc3, TX_NORMAL_DESC3, LD));
1518 }
1519
1520 static int
1521 xgbe_enable_int(struct xgbe_channel *channel, enum xgbe_int int_id)
1522 {
1523         struct xgbe_prv_data *pdata = channel->pdata;
1524
1525         axgbe_printf(1, "enable_int: DMA_CH_IER read - 0x%x\n",
1526             channel->curr_ier);
1527
1528         switch (int_id) {
1529         case XGMAC_INT_DMA_CH_SR_TI:
1530                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, TIE, 1);
1531                 break;
1532         case XGMAC_INT_DMA_CH_SR_TPS:
1533                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, TXSE, 1);
1534                 break;
1535         case XGMAC_INT_DMA_CH_SR_TBU:
1536                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, TBUE, 1);
1537                 break;
1538         case XGMAC_INT_DMA_CH_SR_RI:
1539                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, RIE, 1);
1540                 break;
1541         case XGMAC_INT_DMA_CH_SR_RBU:
1542                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, RBUE, 1);
1543                 break;
1544         case XGMAC_INT_DMA_CH_SR_RPS:
1545                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, RSE, 1);
1546                 break;
1547         case XGMAC_INT_DMA_CH_SR_TI_RI:
1548                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, TIE, 1);
1549                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, RIE, 1);
1550                 break;
1551         case XGMAC_INT_DMA_CH_SR_FBE:
1552                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, FBEE, 1);
1553                 break;
1554         case XGMAC_INT_DMA_ALL:
1555                 channel->curr_ier |= channel->saved_ier;
1556                 break;
1557         default:
1558                 return (-1);
1559         }
1560
1561         XGMAC_DMA_IOWRITE(channel, DMA_CH_IER, channel->curr_ier);
1562
1563         axgbe_printf(1, "enable_int: DMA_CH_IER write - 0x%x\n",
1564             channel->curr_ier);
1565
1566         return (0);
1567 }
1568
1569 static int
1570 xgbe_disable_int(struct xgbe_channel *channel, enum xgbe_int int_id)
1571 {
1572         struct xgbe_prv_data *pdata = channel->pdata;
1573
1574         axgbe_printf(1, "disable_int: DMA_CH_IER read - 0x%x\n",
1575             channel->curr_ier);
1576
1577         switch (int_id) {
1578         case XGMAC_INT_DMA_CH_SR_TI:
1579                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, TIE, 0);
1580                 break;
1581         case XGMAC_INT_DMA_CH_SR_TPS:
1582                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, TXSE, 0);
1583                 break;
1584         case XGMAC_INT_DMA_CH_SR_TBU:
1585                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, TBUE, 0);
1586                 break;
1587         case XGMAC_INT_DMA_CH_SR_RI:
1588                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, RIE, 0);
1589                 break;
1590         case XGMAC_INT_DMA_CH_SR_RBU:
1591                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, RBUE, 0);
1592                 break;
1593         case XGMAC_INT_DMA_CH_SR_RPS:
1594                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, RSE, 0);
1595                 break;
1596         case XGMAC_INT_DMA_CH_SR_TI_RI:
1597                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, TIE, 0);
1598                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, RIE, 0);
1599                 break;
1600         case XGMAC_INT_DMA_CH_SR_FBE:
1601                 XGMAC_SET_BITS(channel->curr_ier, DMA_CH_IER, FBEE, 0);
1602                 break;
1603         case XGMAC_INT_DMA_ALL:
1604                 channel->saved_ier = channel->curr_ier;
1605                 channel->curr_ier = 0;
1606                 break;
1607         default:
1608                 return (-1);
1609         }
1610
1611         XGMAC_DMA_IOWRITE(channel, DMA_CH_IER, channel->curr_ier);
1612
1613         axgbe_printf(1, "disable_int: DMA_CH_IER write - 0x%x\n",
1614             channel->curr_ier);
1615
1616         return (0);
1617 }
1618
1619 static int
1620 __xgbe_exit(struct xgbe_prv_data *pdata)
1621 {
1622         unsigned int count = 2000;
1623
1624         /* Issue a software reset */
1625         XGMAC_IOWRITE_BITS(pdata, DMA_MR, SWR, 1);
1626         DELAY(10);
1627
1628         /* Poll Until Poll Condition */
1629         while (--count && XGMAC_IOREAD_BITS(pdata, DMA_MR, SWR))
1630                 DELAY(500);
1631
1632         if (!count)
1633                 return (-EBUSY);
1634
1635         return (0);
1636 }
1637
1638 static int
1639 xgbe_exit(struct xgbe_prv_data *pdata)
1640 {
1641         int ret;
1642
1643         /* To guard against possible incorrectly generated interrupts,
1644          * issue the software reset twice.
1645          */
1646         ret = __xgbe_exit(pdata);
1647         if (ret) {
1648                 axgbe_error("%s: exit error %d\n", __func__, ret);
1649                 return (ret);
1650         }
1651
1652         return (__xgbe_exit(pdata));
1653 }
1654
1655 static int
1656 xgbe_flush_tx_queues(struct xgbe_prv_data *pdata)
1657 {
1658         unsigned int i, count;
1659
1660         if (XGMAC_GET_BITS(pdata->hw_feat.version, MAC_VR, SNPSVER) < 0x21)
1661                 return (0);
1662
1663         for (i = 0; i < pdata->tx_q_count; i++)
1664                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_TQOMR, FTQ, 1);
1665
1666         /* Poll Until Poll Condition */
1667         for (i = 0; i < pdata->tx_q_count; i++) {
1668                 count = 2000;
1669                 while (--count && XGMAC_MTL_IOREAD_BITS(pdata, i,
1670                                                         MTL_Q_TQOMR, FTQ))
1671                         DELAY(500);
1672
1673                 if (!count)
1674                         return (-EBUSY);
1675         }
1676
1677         return (0);
1678 }
1679
1680 static void
1681 xgbe_config_dma_bus(struct xgbe_prv_data *pdata)
1682 {
1683         unsigned int sbmr;
1684
1685         sbmr = XGMAC_IOREAD(pdata, DMA_SBMR);
1686
1687         /* Set enhanced addressing mode */
1688         XGMAC_SET_BITS(sbmr, DMA_SBMR, EAME, 1);
1689
1690         /* Set the System Bus mode */
1691         XGMAC_SET_BITS(sbmr, DMA_SBMR, UNDEF, 1);
1692         XGMAC_SET_BITS(sbmr, DMA_SBMR, BLEN, pdata->blen >> 2);
1693         XGMAC_SET_BITS(sbmr, DMA_SBMR, AAL, pdata->aal);
1694         XGMAC_SET_BITS(sbmr, DMA_SBMR, RD_OSR_LMT, pdata->rd_osr_limit - 1);
1695         XGMAC_SET_BITS(sbmr, DMA_SBMR, WR_OSR_LMT, pdata->wr_osr_limit - 1);
1696
1697         XGMAC_IOWRITE(pdata, DMA_SBMR, sbmr);
1698
1699         /* Set descriptor fetching threshold */
1700         if (pdata->vdata->tx_desc_prefetch)
1701                 XGMAC_IOWRITE_BITS(pdata, DMA_TXEDMACR, TDPS,
1702                     pdata->vdata->tx_desc_prefetch);
1703
1704         if (pdata->vdata->rx_desc_prefetch)
1705                 XGMAC_IOWRITE_BITS(pdata, DMA_RXEDMACR, RDPS,
1706                     pdata->vdata->rx_desc_prefetch);
1707 }
1708
1709 static void
1710 xgbe_config_dma_cache(struct xgbe_prv_data *pdata)
1711 {
1712         XGMAC_IOWRITE(pdata, DMA_AXIARCR, pdata->arcr);
1713         XGMAC_IOWRITE(pdata, DMA_AXIAWCR, pdata->awcr);
1714         if (pdata->awarcr)
1715                 XGMAC_IOWRITE(pdata, DMA_AXIAWARCR, pdata->awarcr);
1716 }
1717
1718 static void
1719 xgbe_config_mtl_mode(struct xgbe_prv_data *pdata)
1720 {
1721         unsigned int i;
1722
1723         /* Set Tx to weighted round robin scheduling algorithm */
1724         XGMAC_IOWRITE_BITS(pdata, MTL_OMR, ETSALG, MTL_ETSALG_WRR);
1725
1726         /* Set Tx traffic classes to use WRR algorithm with equal weights */
1727         for (i = 0; i < pdata->hw_feat.tc_cnt; i++) {
1728                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_TC_ETSCR, TSA,
1729                     MTL_TSA_ETS);
1730                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_TC_QWR, QW, 1);
1731         }
1732
1733         /* Set Rx to strict priority algorithm */
1734         XGMAC_IOWRITE_BITS(pdata, MTL_OMR, RAA, MTL_RAA_SP);
1735 }
1736
1737 static void
1738 xgbe_queue_flow_control_threshold(struct xgbe_prv_data *pdata,
1739     unsigned int queue, unsigned int q_fifo_size)
1740 {
1741         unsigned int frame_fifo_size;
1742         unsigned int rfa, rfd;
1743
1744         frame_fifo_size = XGMAC_FLOW_CONTROL_ALIGN(xgbe_get_max_frame(pdata));
1745         axgbe_printf(1, "%s: queue %d q_fifo_size %d frame_fifo_size 0x%x\n",
1746             __func__, queue, q_fifo_size, frame_fifo_size);
1747
1748         /* TODO - add pfc/ets related support */
1749
1750         /* This path deals with just maximum frame sizes which are
1751          * limited to a jumbo frame of 9,000 (plus headers, etc.)
1752          * so we can never exceed the maximum allowable RFA/RFD
1753          * values.
1754          */
1755         if (q_fifo_size <= 2048) {
1756                 /* rx_rfd to zero to signal no flow control */
1757                 pdata->rx_rfa[queue] = 0;
1758                 pdata->rx_rfd[queue] = 0;
1759                 return;
1760         }
1761
1762         if (q_fifo_size <= 4096) {
1763                 /* Between 2048 and 4096 */
1764                 pdata->rx_rfa[queue] = 0;       /* Full - 1024 bytes */
1765                 pdata->rx_rfd[queue] = 1;       /* Full - 1536 bytes */
1766                 return;
1767         }
1768
1769         if (q_fifo_size <= frame_fifo_size) {
1770                 /* Between 4096 and max-frame */
1771                 pdata->rx_rfa[queue] = 2;       /* Full - 2048 bytes */
1772                 pdata->rx_rfd[queue] = 5;       /* Full - 3584 bytes */
1773                 return;
1774         }
1775
1776         if (q_fifo_size <= (frame_fifo_size * 3)) {
1777                 /* Between max-frame and 3 max-frames,
1778                  * trigger if we get just over a frame of data and
1779                  * resume when we have just under half a frame left.
1780                  */
1781                 rfa = q_fifo_size - frame_fifo_size;
1782                 rfd = rfa + (frame_fifo_size / 2);
1783         } else {
1784                 /* Above 3 max-frames - trigger when just over
1785                  * 2 frames of space available
1786                  */
1787                 rfa = frame_fifo_size * 2;
1788                 rfa += XGMAC_FLOW_CONTROL_UNIT;
1789                 rfd = rfa + frame_fifo_size;
1790         }
1791
1792         pdata->rx_rfa[queue] = XGMAC_FLOW_CONTROL_VALUE(rfa);
1793         pdata->rx_rfd[queue] = XGMAC_FLOW_CONTROL_VALUE(rfd);
1794         axgbe_printf(1, "%s: forced queue %d rfa 0x%x rfd 0x%x\n", __func__,
1795             queue, pdata->rx_rfa[queue], pdata->rx_rfd[queue]);
1796 }
1797
1798 static void
1799 xgbe_calculate_flow_control_threshold(struct xgbe_prv_data *pdata,
1800     unsigned int *fifo)
1801 {
1802         unsigned int q_fifo_size;
1803         unsigned int i;
1804
1805         for (i = 0; i < pdata->rx_q_count; i++) {
1806                 q_fifo_size = (fifo[i] + 1) * XGMAC_FIFO_UNIT;
1807
1808                 axgbe_printf(1, "%s: fifo[%d] - 0x%x q_fifo_size 0x%x\n",
1809                     __func__, i, fifo[i], q_fifo_size);
1810                 xgbe_queue_flow_control_threshold(pdata, i, q_fifo_size);
1811         }
1812 }
1813
1814 static void
1815 xgbe_config_flow_control_threshold(struct xgbe_prv_data *pdata)
1816 {
1817         unsigned int i;
1818
1819         for (i = 0; i < pdata->rx_q_count; i++) {
1820                 axgbe_printf(1, "%s: queue %d rfa %d rfd %d\n", __func__, i,
1821                     pdata->rx_rfa[i], pdata->rx_rfd[i]);
1822
1823                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQFCR, RFA,
1824                                        pdata->rx_rfa[i]);
1825                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQFCR, RFD,
1826                                        pdata->rx_rfd[i]);
1827
1828                 axgbe_printf(1, "%s: MTL_Q_RQFCR 0x%x\n", __func__,
1829                     XGMAC_MTL_IOREAD(pdata, i, MTL_Q_RQFCR));
1830         }
1831 }
1832
1833 static unsigned int
1834 xgbe_get_tx_fifo_size(struct xgbe_prv_data *pdata)
1835 {
1836         /* The configured value may not be the actual amount of fifo RAM */
1837         return (min_t(unsigned int, pdata->tx_max_fifo_size,
1838             pdata->hw_feat.tx_fifo_size));
1839 }
1840
1841 static unsigned int
1842 xgbe_get_rx_fifo_size(struct xgbe_prv_data *pdata)
1843 {
1844         /* The configured value may not be the actual amount of fifo RAM */
1845         return (min_t(unsigned int, pdata->rx_max_fifo_size,
1846             pdata->hw_feat.rx_fifo_size));
1847 }
1848
1849 static void
1850 xgbe_calculate_equal_fifo(unsigned int fifo_size, unsigned int queue_count,
1851     unsigned int *fifo)
1852 {
1853         unsigned int q_fifo_size;
1854         unsigned int p_fifo;
1855         unsigned int i;
1856
1857         q_fifo_size = fifo_size / queue_count;
1858
1859         /* Calculate the fifo setting by dividing the queue's fifo size
1860          * by the fifo allocation increment (with 0 representing the
1861          * base allocation increment so decrement the result by 1).
1862          */
1863         p_fifo = q_fifo_size / XGMAC_FIFO_UNIT;
1864         if (p_fifo)
1865                 p_fifo--;
1866
1867         /* Distribute the fifo equally amongst the queues */
1868         for (i = 0; i < queue_count; i++)
1869                 fifo[i] = p_fifo;
1870 }
1871
1872 static unsigned int
1873 xgbe_set_nonprio_fifos(unsigned int fifo_size, unsigned int queue_count,
1874     unsigned int *fifo)
1875 {
1876         unsigned int i;
1877
1878         MPASS(powerof2(XGMAC_FIFO_MIN_ALLOC));
1879
1880         if (queue_count <= IEEE_8021QAZ_MAX_TCS)
1881                 return (fifo_size);
1882
1883         /* Rx queues 9 and up are for specialized packets,
1884          * such as PTP or DCB control packets, etc. and
1885          * don't require a large fifo
1886          */
1887         for (i = IEEE_8021QAZ_MAX_TCS; i < queue_count; i++) {
1888                 fifo[i] = (XGMAC_FIFO_MIN_ALLOC / XGMAC_FIFO_UNIT) - 1;
1889                 fifo_size -= XGMAC_FIFO_MIN_ALLOC;
1890         }
1891
1892         return (fifo_size);
1893 }
1894
1895 static void
1896 xgbe_config_tx_fifo_size(struct xgbe_prv_data *pdata)
1897 {
1898         unsigned int fifo_size;
1899         unsigned int fifo[XGBE_MAX_QUEUES];
1900         unsigned int i;
1901
1902         fifo_size = xgbe_get_tx_fifo_size(pdata);
1903         axgbe_printf(1, "%s: fifo_size 0x%x\n", __func__, fifo_size);
1904
1905         xgbe_calculate_equal_fifo(fifo_size, pdata->tx_q_count, fifo);
1906
1907         for (i = 0; i < pdata->tx_q_count; i++) {
1908                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_TQOMR, TQS, fifo[i]);
1909                 axgbe_printf(1, "Tx q %d FIFO Size 0x%x\n", i,
1910                     XGMAC_MTL_IOREAD(pdata, i, MTL_Q_TQOMR));
1911         }
1912
1913         axgbe_printf(1, "%d Tx hardware queues, %d byte fifo per queue\n",
1914             pdata->tx_q_count, ((fifo[0] + 1) * XGMAC_FIFO_UNIT));
1915 }
1916
1917 static void
1918 xgbe_config_rx_fifo_size(struct xgbe_prv_data *pdata)
1919 {
1920         unsigned int fifo_size;
1921         unsigned int fifo[XGBE_MAX_QUEUES];
1922         unsigned int prio_queues;
1923         unsigned int i;
1924
1925         /* TODO - add pfc/ets related support */
1926
1927         /* Clear any DCB related fifo/queue information */
1928         fifo_size = xgbe_get_rx_fifo_size(pdata);
1929         prio_queues = XGMAC_PRIO_QUEUES(pdata->rx_q_count);
1930         axgbe_printf(1, "%s: fifo_size 0x%x rx_q_cnt %d prio %d\n", __func__,
1931             fifo_size, pdata->rx_q_count, prio_queues);
1932
1933         /* Assign a minimum fifo to the non-VLAN priority queues */
1934         fifo_size = xgbe_set_nonprio_fifos(fifo_size, pdata->rx_q_count, fifo);
1935
1936         xgbe_calculate_equal_fifo(fifo_size, prio_queues, fifo);
1937
1938         for (i = 0; i < pdata->rx_q_count; i++) {
1939                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQOMR, RQS, fifo[i]);
1940                 axgbe_printf(1, "Rx q %d FIFO Size 0x%x\n", i,
1941                     XGMAC_MTL_IOREAD(pdata, i, MTL_Q_RQOMR));
1942         }
1943
1944         xgbe_calculate_flow_control_threshold(pdata, fifo);
1945         xgbe_config_flow_control_threshold(pdata);
1946
1947         axgbe_printf(1, "%u Rx hardware queues, %u byte fifo/queue\n",
1948             pdata->rx_q_count, ((fifo[0] + 1) * XGMAC_FIFO_UNIT));
1949 }
1950
1951 static void
1952 xgbe_config_queue_mapping(struct xgbe_prv_data *pdata)
1953 {
1954         unsigned int qptc, qptc_extra, queue;
1955         unsigned int prio_queues;
1956         unsigned int ppq, ppq_extra, prio;
1957         unsigned int mask;
1958         unsigned int i, j, reg, reg_val;
1959
1960         /* Map the MTL Tx Queues to Traffic Classes
1961          *   Note: Tx Queues >= Traffic Classes
1962          */
1963         qptc = pdata->tx_q_count / pdata->hw_feat.tc_cnt;
1964         qptc_extra = pdata->tx_q_count % pdata->hw_feat.tc_cnt;
1965
1966         for (i = 0, queue = 0; i < pdata->hw_feat.tc_cnt; i++) {
1967                 for (j = 0; j < qptc; j++) {
1968                         axgbe_printf(1, "TXq%u mapped to TC%u\n", queue, i);
1969                         XGMAC_MTL_IOWRITE_BITS(pdata, queue, MTL_Q_TQOMR,
1970                             Q2TCMAP, i);
1971                         pdata->q2tc_map[queue++] = i;
1972                 }
1973
1974                 if (i < qptc_extra) {
1975                         axgbe_printf(1, "TXq%u mapped to TC%u\n", queue, i);
1976                         XGMAC_MTL_IOWRITE_BITS(pdata, queue, MTL_Q_TQOMR,
1977                             Q2TCMAP, i);
1978                         pdata->q2tc_map[queue++] = i;
1979                 }
1980         }
1981
1982         /* Map the 8 VLAN priority values to available MTL Rx queues */
1983         prio_queues = XGMAC_PRIO_QUEUES(pdata->rx_q_count);
1984         ppq = IEEE_8021QAZ_MAX_TCS / prio_queues;
1985         ppq_extra = IEEE_8021QAZ_MAX_TCS % prio_queues;
1986
1987         reg = MAC_RQC2R;
1988         reg_val = 0;
1989         for (i = 0, prio = 0; i < prio_queues;) {
1990                 mask = 0;
1991                 for (j = 0; j < ppq; j++) {
1992                         axgbe_printf(1, "PRIO%u mapped to RXq%u\n", prio, i);
1993                         mask |= (1 << prio);
1994                         pdata->prio2q_map[prio++] = i;
1995                 }
1996
1997                 if (i < ppq_extra) {
1998                         axgbe_printf(1, "PRIO%u mapped to RXq%u\n", prio, i);
1999                         mask |= (1 << prio);
2000                         pdata->prio2q_map[prio++] = i;
2001                 }
2002
2003                 reg_val |= (mask << ((i++ % MAC_RQC2_Q_PER_REG) << 3));
2004
2005                 if ((i % MAC_RQC2_Q_PER_REG) && (i != prio_queues))
2006                         continue;
2007
2008                 XGMAC_IOWRITE(pdata, reg, reg_val);
2009                 reg += MAC_RQC2_INC;
2010                 reg_val = 0;
2011         }
2012
2013         /* Select dynamic mapping of MTL Rx queue to DMA Rx channel */
2014         reg = MTL_RQDCM0R;
2015         reg_val = 0;
2016         for (i = 0; i < pdata->rx_q_count;) {
2017                 reg_val |= (0x80 << ((i++ % MTL_RQDCM_Q_PER_REG) << 3));
2018
2019                 if ((i % MTL_RQDCM_Q_PER_REG) && (i != pdata->rx_q_count))
2020                         continue;
2021
2022                 XGMAC_IOWRITE(pdata, reg, reg_val);
2023
2024                 reg += MTL_RQDCM_INC;
2025                 reg_val = 0;
2026         }
2027 }
2028
2029 static void
2030 xgbe_config_mac_address(struct xgbe_prv_data *pdata)
2031 {
2032         xgbe_set_mac_address(pdata, IF_LLADDR(pdata->netdev));
2033
2034         /* Filtering is done using perfect filtering and hash filtering */
2035         if (pdata->hw_feat.hash_table_size) {
2036                 XGMAC_IOWRITE_BITS(pdata, MAC_PFR, HPF, 1);
2037                 XGMAC_IOWRITE_BITS(pdata, MAC_PFR, HUC, 1);
2038                 XGMAC_IOWRITE_BITS(pdata, MAC_PFR, HMC, 1);
2039         }
2040 }
2041
2042 static void
2043 xgbe_config_jumbo_enable(struct xgbe_prv_data *pdata)
2044 {
2045         unsigned int val;
2046
2047         val = (if_getmtu(pdata->netdev) > XGMAC_STD_PACKET_MTU) ? 1 : 0;
2048
2049         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, JE, val);
2050 }
2051
2052 static void
2053 xgbe_config_mac_speed(struct xgbe_prv_data *pdata)
2054 {
2055         xgbe_set_speed(pdata, pdata->phy_speed);
2056 }
2057
2058 static void
2059 xgbe_config_checksum_offload(struct xgbe_prv_data *pdata)
2060 {
2061         if ((if_getcapenable(pdata->netdev) & IFCAP_RXCSUM))
2062                 xgbe_enable_rx_csum(pdata);
2063         else
2064                 xgbe_disable_rx_csum(pdata);
2065 }
2066
2067 static void
2068 xgbe_config_vlan_support(struct xgbe_prv_data *pdata)
2069 {
2070         /* Indicate that VLAN Tx CTAGs come from context descriptors */
2071         XGMAC_IOWRITE_BITS(pdata, MAC_VLANIR, CSVL, 0);
2072         XGMAC_IOWRITE_BITS(pdata, MAC_VLANIR, VLTI, 1);
2073
2074         /* Set the current VLAN Hash Table register value */
2075         xgbe_update_vlan_hash_table(pdata);
2076
2077         if ((if_getcapenable(pdata->netdev) & IFCAP_VLAN_HWFILTER)) {
2078                 axgbe_printf(1, "Enabling rx vlan filtering\n");
2079                 xgbe_enable_rx_vlan_filtering(pdata);
2080         } else {
2081                 axgbe_printf(1, "Disabling rx vlan filtering\n");
2082                 xgbe_disable_rx_vlan_filtering(pdata);
2083         }
2084
2085         if ((if_getcapenable(pdata->netdev) & IFCAP_VLAN_HWTAGGING)) {
2086                 axgbe_printf(1, "Enabling rx vlan stripping\n");
2087                 xgbe_enable_rx_vlan_stripping(pdata);
2088         } else {
2089                 axgbe_printf(1, "Disabling rx vlan stripping\n");
2090                 xgbe_disable_rx_vlan_stripping(pdata);
2091         }
2092 }
2093
2094 static uint64_t
2095 xgbe_mmc_read(struct xgbe_prv_data *pdata, unsigned int reg_lo)
2096 {
2097         bool read_hi;
2098         uint64_t val;
2099
2100         if (pdata->vdata->mmc_64bit) {
2101                 switch (reg_lo) {
2102                 /* These registers are always 32 bit */
2103                 case MMC_RXRUNTERROR:
2104                 case MMC_RXJABBERERROR:
2105                 case MMC_RXUNDERSIZE_G:
2106                 case MMC_RXOVERSIZE_G:
2107                 case MMC_RXWATCHDOGERROR:
2108                         read_hi = false;
2109                         break;
2110
2111                 default:
2112                         read_hi = true;
2113                 }
2114         } else {
2115                 switch (reg_lo) {
2116                 /* These registers are always 64 bit */
2117                 case MMC_TXOCTETCOUNT_GB_LO:
2118                 case MMC_TXOCTETCOUNT_G_LO:
2119                 case MMC_RXOCTETCOUNT_GB_LO:
2120                 case MMC_RXOCTETCOUNT_G_LO:
2121                         read_hi = true;
2122                         break;
2123
2124                 default:
2125                         read_hi = false;
2126                 }
2127         }
2128
2129         val = XGMAC_IOREAD(pdata, reg_lo);
2130
2131         if (read_hi)
2132                 val |= ((uint64_t)XGMAC_IOREAD(pdata, reg_lo + 4) << 32);
2133
2134         return (val);
2135 }
2136
2137 static void
2138 xgbe_tx_mmc_int(struct xgbe_prv_data *pdata)
2139 {
2140         struct xgbe_mmc_stats *stats = &pdata->mmc_stats;
2141         unsigned int mmc_isr = XGMAC_IOREAD(pdata, MMC_TISR);
2142
2143         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXOCTETCOUNT_GB))
2144                 stats->txoctetcount_gb +=
2145                     xgbe_mmc_read(pdata, MMC_TXOCTETCOUNT_GB_LO);
2146
2147         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXFRAMECOUNT_GB))
2148                 stats->txframecount_gb +=
2149                     xgbe_mmc_read(pdata, MMC_TXFRAMECOUNT_GB_LO);
2150
2151         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXBROADCASTFRAMES_G))
2152                 stats->txbroadcastframes_g +=
2153                     xgbe_mmc_read(pdata, MMC_TXBROADCASTFRAMES_G_LO);
2154
2155         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXMULTICASTFRAMES_G))
2156                 stats->txmulticastframes_g +=
2157                     xgbe_mmc_read(pdata, MMC_TXMULTICASTFRAMES_G_LO);
2158
2159         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX64OCTETS_GB))
2160                 stats->tx64octets_gb +=
2161                     xgbe_mmc_read(pdata, MMC_TX64OCTETS_GB_LO);
2162
2163         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX65TO127OCTETS_GB))
2164                 stats->tx65to127octets_gb +=
2165                     xgbe_mmc_read(pdata, MMC_TX65TO127OCTETS_GB_LO);
2166
2167         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX128TO255OCTETS_GB))
2168                 stats->tx128to255octets_gb +=
2169                     xgbe_mmc_read(pdata, MMC_TX128TO255OCTETS_GB_LO);
2170
2171         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX256TO511OCTETS_GB))
2172                 stats->tx256to511octets_gb +=
2173                     xgbe_mmc_read(pdata, MMC_TX256TO511OCTETS_GB_LO);
2174
2175         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX512TO1023OCTETS_GB))
2176                 stats->tx512to1023octets_gb +=
2177                     xgbe_mmc_read(pdata, MMC_TX512TO1023OCTETS_GB_LO);
2178
2179         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX1024TOMAXOCTETS_GB))
2180                 stats->tx1024tomaxoctets_gb +=
2181                     xgbe_mmc_read(pdata, MMC_TX1024TOMAXOCTETS_GB_LO);
2182
2183         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXUNICASTFRAMES_GB))
2184                 stats->txunicastframes_gb +=
2185                     xgbe_mmc_read(pdata, MMC_TXUNICASTFRAMES_GB_LO);
2186
2187         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXMULTICASTFRAMES_GB))
2188                 stats->txmulticastframes_gb +=
2189                     xgbe_mmc_read(pdata, MMC_TXMULTICASTFRAMES_GB_LO);
2190
2191         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXBROADCASTFRAMES_GB))
2192                 stats->txbroadcastframes_g +=
2193                     xgbe_mmc_read(pdata, MMC_TXBROADCASTFRAMES_GB_LO);
2194
2195         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXUNDERFLOWERROR))
2196                 stats->txunderflowerror +=
2197                     xgbe_mmc_read(pdata, MMC_TXUNDERFLOWERROR_LO);
2198
2199         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXOCTETCOUNT_G))
2200                 stats->txoctetcount_g +=
2201                     xgbe_mmc_read(pdata, MMC_TXOCTETCOUNT_G_LO);
2202
2203         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXFRAMECOUNT_G))
2204                 stats->txframecount_g +=
2205                     xgbe_mmc_read(pdata, MMC_TXFRAMECOUNT_G_LO);
2206
2207         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXPAUSEFRAMES))
2208                 stats->txpauseframes +=
2209                     xgbe_mmc_read(pdata, MMC_TXPAUSEFRAMES_LO);
2210
2211         if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXVLANFRAMES_G))
2212                 stats->txvlanframes_g +=
2213                     xgbe_mmc_read(pdata, MMC_TXVLANFRAMES_G_LO);
2214 }
2215
2216 static void
2217 xgbe_rx_mmc_int(struct xgbe_prv_data *pdata)
2218 {
2219         struct xgbe_mmc_stats *stats = &pdata->mmc_stats;
2220         unsigned int mmc_isr = XGMAC_IOREAD(pdata, MMC_RISR);
2221
2222         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXFRAMECOUNT_GB))
2223                 stats->rxframecount_gb +=
2224                     xgbe_mmc_read(pdata, MMC_RXFRAMECOUNT_GB_LO);
2225
2226         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXOCTETCOUNT_GB))
2227                 stats->rxoctetcount_gb +=
2228                     xgbe_mmc_read(pdata, MMC_RXOCTETCOUNT_GB_LO);
2229
2230         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXOCTETCOUNT_G))
2231                 stats->rxoctetcount_g +=
2232                     xgbe_mmc_read(pdata, MMC_RXOCTETCOUNT_G_LO);
2233
2234         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXBROADCASTFRAMES_G))
2235                 stats->rxbroadcastframes_g +=
2236                     xgbe_mmc_read(pdata, MMC_RXBROADCASTFRAMES_G_LO);
2237
2238         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXMULTICASTFRAMES_G))
2239                 stats->rxmulticastframes_g +=
2240                     xgbe_mmc_read(pdata, MMC_RXMULTICASTFRAMES_G_LO);
2241
2242         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXCRCERROR))
2243                 stats->rxcrcerror +=
2244                     xgbe_mmc_read(pdata, MMC_RXCRCERROR_LO);
2245
2246         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXRUNTERROR))
2247                 stats->rxrunterror +=
2248                     xgbe_mmc_read(pdata, MMC_RXRUNTERROR);
2249
2250         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXJABBERERROR))
2251                 stats->rxjabbererror +=
2252                     xgbe_mmc_read(pdata, MMC_RXJABBERERROR);
2253
2254         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXUNDERSIZE_G))
2255                 stats->rxundersize_g +=
2256                     xgbe_mmc_read(pdata, MMC_RXUNDERSIZE_G);
2257
2258         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXOVERSIZE_G))
2259                 stats->rxoversize_g +=
2260                     xgbe_mmc_read(pdata, MMC_RXOVERSIZE_G);
2261
2262         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX64OCTETS_GB))
2263                 stats->rx64octets_gb +=
2264                     xgbe_mmc_read(pdata, MMC_RX64OCTETS_GB_LO);
2265
2266         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX65TO127OCTETS_GB))
2267                 stats->rx65to127octets_gb +=
2268                     xgbe_mmc_read(pdata, MMC_RX65TO127OCTETS_GB_LO);
2269
2270         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX128TO255OCTETS_GB))
2271                 stats->rx128to255octets_gb +=
2272                     xgbe_mmc_read(pdata, MMC_RX128TO255OCTETS_GB_LO);
2273
2274         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX256TO511OCTETS_GB))
2275                 stats->rx256to511octets_gb +=
2276                     xgbe_mmc_read(pdata, MMC_RX256TO511OCTETS_GB_LO);
2277
2278         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX512TO1023OCTETS_GB))
2279                 stats->rx512to1023octets_gb +=
2280                     xgbe_mmc_read(pdata, MMC_RX512TO1023OCTETS_GB_LO);
2281
2282         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX1024TOMAXOCTETS_GB))
2283                 stats->rx1024tomaxoctets_gb +=
2284                     xgbe_mmc_read(pdata, MMC_RX1024TOMAXOCTETS_GB_LO);
2285
2286         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXUNICASTFRAMES_G))
2287                 stats->rxunicastframes_g +=
2288                     xgbe_mmc_read(pdata, MMC_RXUNICASTFRAMES_G_LO);
2289
2290         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXLENGTHERROR))
2291                 stats->rxlengtherror +=
2292                     xgbe_mmc_read(pdata, MMC_RXLENGTHERROR_LO);
2293
2294         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXOUTOFRANGETYPE))
2295                 stats->rxoutofrangetype +=
2296                     xgbe_mmc_read(pdata, MMC_RXOUTOFRANGETYPE_LO);
2297
2298         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXPAUSEFRAMES))
2299                 stats->rxpauseframes +=
2300                     xgbe_mmc_read(pdata, MMC_RXPAUSEFRAMES_LO);
2301
2302         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXFIFOOVERFLOW))
2303                 stats->rxfifooverflow +=
2304                     xgbe_mmc_read(pdata, MMC_RXFIFOOVERFLOW_LO);
2305
2306         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXVLANFRAMES_GB))
2307                 stats->rxvlanframes_gb +=
2308                     xgbe_mmc_read(pdata, MMC_RXVLANFRAMES_GB_LO);
2309
2310         if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXWATCHDOGERROR))
2311                 stats->rxwatchdogerror +=
2312                     xgbe_mmc_read(pdata, MMC_RXWATCHDOGERROR);
2313 }
2314
2315 static void
2316 xgbe_read_mmc_stats(struct xgbe_prv_data *pdata)
2317 {
2318         struct xgbe_mmc_stats *stats = &pdata->mmc_stats;
2319
2320         /* Freeze counters */
2321         XGMAC_IOWRITE_BITS(pdata, MMC_CR, MCF, 1);
2322
2323         stats->txoctetcount_gb +=
2324             xgbe_mmc_read(pdata, MMC_TXOCTETCOUNT_GB_LO);
2325
2326         stats->txframecount_gb +=
2327             xgbe_mmc_read(pdata, MMC_TXFRAMECOUNT_GB_LO);
2328
2329         stats->txbroadcastframes_g +=
2330             xgbe_mmc_read(pdata, MMC_TXBROADCASTFRAMES_G_LO);
2331
2332         stats->txmulticastframes_g +=
2333             xgbe_mmc_read(pdata, MMC_TXMULTICASTFRAMES_G_LO);
2334
2335         stats->tx64octets_gb +=
2336             xgbe_mmc_read(pdata, MMC_TX64OCTETS_GB_LO);
2337
2338         stats->tx65to127octets_gb +=
2339             xgbe_mmc_read(pdata, MMC_TX65TO127OCTETS_GB_LO);
2340
2341         stats->tx128to255octets_gb +=
2342             xgbe_mmc_read(pdata, MMC_TX128TO255OCTETS_GB_LO);
2343
2344         stats->tx256to511octets_gb +=
2345             xgbe_mmc_read(pdata, MMC_TX256TO511OCTETS_GB_LO);
2346
2347         stats->tx512to1023octets_gb +=
2348             xgbe_mmc_read(pdata, MMC_TX512TO1023OCTETS_GB_LO);
2349
2350         stats->tx1024tomaxoctets_gb +=
2351             xgbe_mmc_read(pdata, MMC_TX1024TOMAXOCTETS_GB_LO);
2352
2353         stats->txunicastframes_gb +=
2354             xgbe_mmc_read(pdata, MMC_TXUNICASTFRAMES_GB_LO);
2355
2356         stats->txmulticastframes_gb +=
2357             xgbe_mmc_read(pdata, MMC_TXMULTICASTFRAMES_GB_LO);
2358
2359         stats->txbroadcastframes_gb +=
2360             xgbe_mmc_read(pdata, MMC_TXBROADCASTFRAMES_GB_LO);
2361
2362         stats->txunderflowerror +=
2363             xgbe_mmc_read(pdata, MMC_TXUNDERFLOWERROR_LO);
2364
2365         stats->txoctetcount_g +=
2366             xgbe_mmc_read(pdata, MMC_TXOCTETCOUNT_G_LO);
2367
2368         stats->txframecount_g +=
2369             xgbe_mmc_read(pdata, MMC_TXFRAMECOUNT_G_LO);
2370
2371         stats->txpauseframes +=
2372             xgbe_mmc_read(pdata, MMC_TXPAUSEFRAMES_LO);
2373
2374         stats->txvlanframes_g +=
2375             xgbe_mmc_read(pdata, MMC_TXVLANFRAMES_G_LO);
2376
2377         stats->rxframecount_gb +=
2378             xgbe_mmc_read(pdata, MMC_RXFRAMECOUNT_GB_LO);
2379
2380         stats->rxoctetcount_gb +=
2381             xgbe_mmc_read(pdata, MMC_RXOCTETCOUNT_GB_LO);
2382
2383         stats->rxoctetcount_g +=
2384             xgbe_mmc_read(pdata, MMC_RXOCTETCOUNT_G_LO);
2385
2386         stats->rxbroadcastframes_g +=
2387             xgbe_mmc_read(pdata, MMC_RXBROADCASTFRAMES_G_LO);
2388
2389         stats->rxmulticastframes_g +=
2390             xgbe_mmc_read(pdata, MMC_RXMULTICASTFRAMES_G_LO);
2391
2392         stats->rxcrcerror +=
2393             xgbe_mmc_read(pdata, MMC_RXCRCERROR_LO);
2394
2395         stats->rxrunterror +=
2396             xgbe_mmc_read(pdata, MMC_RXRUNTERROR);
2397
2398         stats->rxjabbererror +=
2399             xgbe_mmc_read(pdata, MMC_RXJABBERERROR);
2400
2401         stats->rxundersize_g +=
2402             xgbe_mmc_read(pdata, MMC_RXUNDERSIZE_G);
2403
2404         stats->rxoversize_g +=
2405             xgbe_mmc_read(pdata, MMC_RXOVERSIZE_G);
2406
2407         stats->rx64octets_gb +=
2408             xgbe_mmc_read(pdata, MMC_RX64OCTETS_GB_LO);
2409
2410         stats->rx65to127octets_gb +=
2411             xgbe_mmc_read(pdata, MMC_RX65TO127OCTETS_GB_LO);
2412
2413         stats->rx128to255octets_gb +=
2414             xgbe_mmc_read(pdata, MMC_RX128TO255OCTETS_GB_LO);
2415
2416         stats->rx256to511octets_gb +=
2417             xgbe_mmc_read(pdata, MMC_RX256TO511OCTETS_GB_LO);
2418
2419         stats->rx512to1023octets_gb +=
2420             xgbe_mmc_read(pdata, MMC_RX512TO1023OCTETS_GB_LO);
2421
2422         stats->rx1024tomaxoctets_gb +=
2423             xgbe_mmc_read(pdata, MMC_RX1024TOMAXOCTETS_GB_LO);
2424
2425         stats->rxunicastframes_g +=
2426             xgbe_mmc_read(pdata, MMC_RXUNICASTFRAMES_G_LO);
2427
2428         stats->rxlengtherror +=
2429             xgbe_mmc_read(pdata, MMC_RXLENGTHERROR_LO);
2430
2431         stats->rxoutofrangetype +=
2432             xgbe_mmc_read(pdata, MMC_RXOUTOFRANGETYPE_LO);
2433
2434         stats->rxpauseframes +=
2435             xgbe_mmc_read(pdata, MMC_RXPAUSEFRAMES_LO);
2436
2437         stats->rxfifooverflow +=
2438             xgbe_mmc_read(pdata, MMC_RXFIFOOVERFLOW_LO);
2439
2440         stats->rxvlanframes_gb +=
2441             xgbe_mmc_read(pdata, MMC_RXVLANFRAMES_GB_LO);
2442
2443         stats->rxwatchdogerror +=
2444             xgbe_mmc_read(pdata, MMC_RXWATCHDOGERROR);
2445
2446         /* Un-freeze counters */
2447         XGMAC_IOWRITE_BITS(pdata, MMC_CR, MCF, 0);
2448 }
2449
2450 static void
2451 xgbe_config_mmc(struct xgbe_prv_data *pdata)
2452 {
2453         /* Set counters to reset on read */
2454         XGMAC_IOWRITE_BITS(pdata, MMC_CR, ROR, 1);
2455
2456         /* Reset the counters */
2457         XGMAC_IOWRITE_BITS(pdata, MMC_CR, CR, 1);
2458 }
2459
2460 static void
2461 xgbe_txq_prepare_tx_stop(struct xgbe_prv_data *pdata, unsigned int queue)
2462 {
2463         unsigned int tx_status;
2464         unsigned long tx_timeout;
2465
2466         /* The Tx engine cannot be stopped if it is actively processing
2467          * packets. Wait for the Tx queue to empty the Tx fifo.  Don't
2468          * wait forever though...
2469          */
2470         tx_timeout = ticks + (XGBE_DMA_STOP_TIMEOUT * hz);
2471         while (ticks < tx_timeout) {
2472                 tx_status = XGMAC_MTL_IOREAD(pdata, queue, MTL_Q_TQDR);
2473                 if ((XGMAC_GET_BITS(tx_status, MTL_Q_TQDR, TRCSTS) != 1) &&
2474                     (XGMAC_GET_BITS(tx_status, MTL_Q_TQDR, TXQSTS) == 0))
2475                         break;
2476
2477                 DELAY(500);
2478         }
2479
2480         if (ticks >= tx_timeout)
2481                 axgbe_printf(1, "timed out waiting for Tx queue %u to empty\n",
2482                     queue);
2483 }
2484
2485 static void
2486 xgbe_prepare_tx_stop(struct xgbe_prv_data *pdata, unsigned int queue)
2487 {
2488         unsigned int tx_dsr, tx_pos, tx_qidx;
2489         unsigned int tx_status;
2490         unsigned long tx_timeout;
2491
2492         if (XGMAC_GET_BITS(pdata->hw_feat.version, MAC_VR, SNPSVER) > 0x20)
2493                 return (xgbe_txq_prepare_tx_stop(pdata, queue));
2494
2495         /* Calculate the status register to read and the position within */
2496         if (queue < DMA_DSRX_FIRST_QUEUE) {
2497                 tx_dsr = DMA_DSR0;
2498                 tx_pos = (queue * DMA_DSR_Q_WIDTH) + DMA_DSR0_TPS_START;
2499         } else {
2500                 tx_qidx = queue - DMA_DSRX_FIRST_QUEUE;
2501
2502                 tx_dsr = DMA_DSR1 + ((tx_qidx / DMA_DSRX_QPR) * DMA_DSRX_INC);
2503                 tx_pos = ((tx_qidx % DMA_DSRX_QPR) * DMA_DSR_Q_WIDTH) +
2504                          DMA_DSRX_TPS_START;
2505         }
2506
2507         /* The Tx engine cannot be stopped if it is actively processing
2508          * descriptors. Wait for the Tx engine to enter the stopped or
2509          * suspended state.  Don't wait forever though...
2510          */
2511         tx_timeout = ticks + (XGBE_DMA_STOP_TIMEOUT * hz);
2512         while (ticks < tx_timeout) {
2513                 tx_status = XGMAC_IOREAD(pdata, tx_dsr);
2514                 tx_status = GET_BITS(tx_status, tx_pos, DMA_DSR_TPS_WIDTH);
2515                 if ((tx_status == DMA_TPS_STOPPED) ||
2516                     (tx_status == DMA_TPS_SUSPENDED))
2517                         break;
2518
2519                 DELAY(500);
2520         }
2521
2522         if (ticks >= tx_timeout)
2523                 axgbe_printf(1, "timed out waiting for Tx DMA channel %u to stop\n",
2524                     queue);
2525 }
2526
2527 static void
2528 xgbe_enable_tx(struct xgbe_prv_data *pdata)
2529 {
2530         unsigned int i;
2531
2532         /* Enable each Tx DMA channel */
2533         for (i = 0; i < pdata->channel_count; i++) {
2534                 if (!pdata->channel[i]->tx_ring)
2535                         break;
2536
2537                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_TCR, ST, 1);
2538         }
2539
2540         /* Enable each Tx queue */
2541         for (i = 0; i < pdata->tx_q_count; i++)
2542                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_TQOMR, TXQEN,
2543                     MTL_Q_ENABLED);
2544
2545         /* Enable MAC Tx */
2546         XGMAC_IOWRITE_BITS(pdata, MAC_TCR, TE, 1);
2547 }
2548
2549 static void
2550 xgbe_disable_tx(struct xgbe_prv_data *pdata)
2551 {
2552         unsigned int i;
2553
2554         /* Prepare for Tx DMA channel stop */
2555         for (i = 0; i < pdata->tx_q_count; i++)
2556                 xgbe_prepare_tx_stop(pdata, i);
2557
2558         /* Disable MAC Tx */
2559         XGMAC_IOWRITE_BITS(pdata, MAC_TCR, TE, 0);
2560
2561         /* Disable each Tx queue */
2562         for (i = 0; i < pdata->tx_q_count; i++)
2563                 XGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_TQOMR, TXQEN, 0);
2564
2565         /* Disable each Tx DMA channel */
2566         for (i = 0; i < pdata->channel_count; i++) {
2567                 if (!pdata->channel[i]->tx_ring)
2568                         break;
2569
2570                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_TCR, ST, 0);
2571         }
2572 }
2573
2574 static void
2575 xgbe_prepare_rx_stop(struct xgbe_prv_data *pdata, unsigned int queue)
2576 {
2577         unsigned int rx_status;
2578         unsigned long rx_timeout;
2579
2580         /* The Rx engine cannot be stopped if it is actively processing
2581          * packets. Wait for the Rx queue to empty the Rx fifo.  Don't
2582          * wait forever though...
2583          */
2584         rx_timeout = ticks + (XGBE_DMA_STOP_TIMEOUT * hz);
2585         while (ticks < rx_timeout) {
2586                 rx_status = XGMAC_MTL_IOREAD(pdata, queue, MTL_Q_RQDR);
2587                 if ((XGMAC_GET_BITS(rx_status, MTL_Q_RQDR, PRXQ) == 0) &&
2588                     (XGMAC_GET_BITS(rx_status, MTL_Q_RQDR, RXQSTS) == 0))
2589                         break;
2590
2591                 DELAY(500);
2592         }
2593
2594         if (ticks >= rx_timeout)
2595                 axgbe_printf(1, "timed out waiting for Rx queue %d to empty\n",
2596                     queue);
2597 }
2598
2599 static void
2600 xgbe_enable_rx(struct xgbe_prv_data *pdata)
2601 {
2602         unsigned int reg_val, i;
2603
2604         /* Enable each Rx DMA channel */
2605         for (i = 0; i < pdata->channel_count; i++) {
2606                 if (!pdata->channel[i]->rx_ring)
2607                         break;
2608
2609                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_RCR, SR, 1);
2610         }
2611
2612         /* Enable each Rx queue */
2613         reg_val = 0;
2614         for (i = 0; i < pdata->rx_q_count; i++)
2615                 reg_val |= (0x02 << (i << 1));
2616         XGMAC_IOWRITE(pdata, MAC_RQC0R, reg_val);
2617
2618         /* Enable MAC Rx */
2619         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, DCRCC, 1);
2620         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, CST, 1);
2621         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, ACS, 1);
2622         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, RE, 1);
2623 }
2624
2625 static void
2626 xgbe_disable_rx(struct xgbe_prv_data *pdata)
2627 {
2628         unsigned int i;
2629
2630         /* Disable MAC Rx */
2631         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, DCRCC, 0);
2632         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, CST, 0);
2633         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, ACS, 0);
2634         XGMAC_IOWRITE_BITS(pdata, MAC_RCR, RE, 0);
2635
2636         /* Prepare for Rx DMA channel stop */
2637         for (i = 0; i < pdata->rx_q_count; i++)
2638                 xgbe_prepare_rx_stop(pdata, i);
2639
2640         /* Disable each Rx queue */
2641         XGMAC_IOWRITE(pdata, MAC_RQC0R, 0);
2642
2643         /* Disable each Rx DMA channel */
2644         for (i = 0; i < pdata->channel_count; i++) {
2645                 if (!pdata->channel[i]->rx_ring)
2646                         break;
2647
2648                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_RCR, SR, 0);
2649         }
2650 }
2651
2652 static void
2653 xgbe_powerup_tx(struct xgbe_prv_data *pdata)
2654 {
2655         unsigned int i;
2656
2657         /* Enable each Tx DMA channel */
2658         for (i = 0; i < pdata->channel_count; i++) {
2659                 if (!pdata->channel[i]->tx_ring)
2660                         break;
2661
2662                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_TCR, ST, 1);
2663         }
2664
2665         /* Enable MAC Tx */
2666         XGMAC_IOWRITE_BITS(pdata, MAC_TCR, TE, 1);
2667 }
2668
2669 static void
2670 xgbe_powerdown_tx(struct xgbe_prv_data *pdata)
2671 {
2672         unsigned int i;
2673
2674         /* Prepare for Tx DMA channel stop */
2675         for (i = 0; i < pdata->tx_q_count; i++)
2676                 xgbe_prepare_tx_stop(pdata, i);
2677
2678         /* Disable MAC Tx */
2679         XGMAC_IOWRITE_BITS(pdata, MAC_TCR, TE, 0);
2680
2681         /* Disable each Tx DMA channel */
2682         for (i = 0; i < pdata->channel_count; i++) {
2683                 if (!pdata->channel[i]->tx_ring)
2684                         break;
2685
2686                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_TCR, ST, 0);
2687         }
2688 }
2689
2690 static void
2691 xgbe_powerup_rx(struct xgbe_prv_data *pdata)
2692 {
2693         unsigned int i;
2694
2695         /* Enable each Rx DMA channel */
2696         for (i = 0; i < pdata->channel_count; i++) {
2697                 if (!pdata->channel[i]->rx_ring)
2698                         break;
2699
2700                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_RCR, SR, 1);
2701         }
2702 }
2703
2704 static void
2705 xgbe_powerdown_rx(struct xgbe_prv_data *pdata)
2706 {
2707         unsigned int i;
2708
2709         /* Disable each Rx DMA channel */
2710         for (i = 0; i < pdata->channel_count; i++) {
2711                 if (!pdata->channel[i]->rx_ring)
2712                         break;
2713
2714                 XGMAC_DMA_IOWRITE_BITS(pdata->channel[i], DMA_CH_RCR, SR, 0);
2715         }
2716 }
2717
2718 static int
2719 xgbe_init(struct xgbe_prv_data *pdata)
2720 {
2721         struct xgbe_desc_if *desc_if = &pdata->desc_if;
2722         int ret;
2723
2724         /* Flush Tx queues */
2725         ret = xgbe_flush_tx_queues(pdata);
2726         if (ret) {
2727                 axgbe_error("error flushing TX queues\n");
2728                 return (ret);
2729         }
2730
2731         /*
2732          * Initialize DMA related features
2733          */
2734         xgbe_config_dma_bus(pdata);
2735         xgbe_config_dma_cache(pdata);
2736         xgbe_config_osp_mode(pdata);
2737         xgbe_config_pbl_val(pdata);
2738         xgbe_config_rx_coalesce(pdata);
2739         xgbe_config_tx_coalesce(pdata);
2740         xgbe_config_rx_buffer_size(pdata);
2741         xgbe_config_tso_mode(pdata);
2742         xgbe_config_sph_mode(pdata);
2743         xgbe_config_rss(pdata);
2744         desc_if->wrapper_tx_desc_init(pdata);
2745         desc_if->wrapper_rx_desc_init(pdata);
2746         xgbe_enable_dma_interrupts(pdata);
2747
2748         /*
2749          * Initialize MTL related features
2750          */
2751         xgbe_config_mtl_mode(pdata);
2752         xgbe_config_queue_mapping(pdata);
2753         xgbe_config_tsf_mode(pdata, pdata->tx_sf_mode);
2754         xgbe_config_rsf_mode(pdata, pdata->rx_sf_mode);
2755         xgbe_config_tx_threshold(pdata, pdata->tx_threshold);
2756         xgbe_config_rx_threshold(pdata, pdata->rx_threshold);
2757         xgbe_config_tx_fifo_size(pdata);
2758         xgbe_config_rx_fifo_size(pdata);
2759         /*TODO: Error Packet and undersized good Packet forwarding enable
2760                 (FEP and FUP)
2761          */
2762         xgbe_enable_mtl_interrupts(pdata);
2763
2764         /*
2765          * Initialize MAC related features
2766          */
2767         xgbe_config_mac_address(pdata);
2768         xgbe_config_rx_mode(pdata);
2769         xgbe_config_jumbo_enable(pdata);
2770         xgbe_config_flow_control(pdata);
2771         xgbe_config_mac_speed(pdata);
2772         xgbe_config_checksum_offload(pdata);
2773         xgbe_config_vlan_support(pdata);
2774         xgbe_config_mmc(pdata);
2775         xgbe_enable_mac_interrupts(pdata);
2776
2777         return (0);
2778 }
2779
2780 void
2781 xgbe_init_function_ptrs_dev(struct xgbe_hw_if *hw_if)
2782 {
2783
2784         hw_if->tx_complete = xgbe_tx_complete;
2785
2786         hw_if->set_mac_address = xgbe_set_mac_address;
2787         hw_if->config_rx_mode = xgbe_config_rx_mode;
2788
2789         hw_if->enable_rx_csum = xgbe_enable_rx_csum;
2790         hw_if->disable_rx_csum = xgbe_disable_rx_csum;
2791
2792         hw_if->enable_rx_vlan_stripping = xgbe_enable_rx_vlan_stripping;
2793         hw_if->disable_rx_vlan_stripping = xgbe_disable_rx_vlan_stripping;
2794         hw_if->enable_rx_vlan_filtering = xgbe_enable_rx_vlan_filtering;
2795         hw_if->disable_rx_vlan_filtering = xgbe_disable_rx_vlan_filtering;
2796         hw_if->update_vlan_hash_table = xgbe_update_vlan_hash_table;
2797
2798         hw_if->read_mmd_regs = xgbe_read_mmd_regs;
2799         hw_if->write_mmd_regs = xgbe_write_mmd_regs;
2800
2801         hw_if->set_speed = xgbe_set_speed;
2802
2803         hw_if->set_ext_mii_mode = xgbe_set_ext_mii_mode;
2804         hw_if->read_ext_mii_regs = xgbe_read_ext_mii_regs;
2805         hw_if->write_ext_mii_regs = xgbe_write_ext_mii_regs;
2806
2807         hw_if->set_gpio = xgbe_set_gpio;
2808         hw_if->clr_gpio = xgbe_clr_gpio;
2809
2810         hw_if->enable_tx = xgbe_enable_tx;
2811         hw_if->disable_tx = xgbe_disable_tx;
2812         hw_if->enable_rx = xgbe_enable_rx;
2813         hw_if->disable_rx = xgbe_disable_rx;
2814
2815         hw_if->powerup_tx = xgbe_powerup_tx;
2816         hw_if->powerdown_tx = xgbe_powerdown_tx;
2817         hw_if->powerup_rx = xgbe_powerup_rx;
2818         hw_if->powerdown_rx = xgbe_powerdown_rx;
2819
2820         hw_if->dev_read = xgbe_dev_read;
2821         hw_if->enable_int = xgbe_enable_int;
2822         hw_if->disable_int = xgbe_disable_int;
2823         hw_if->init = xgbe_init;
2824         hw_if->exit = xgbe_exit;
2825
2826         /* Descriptor related Sequences have to be initialized here */
2827         hw_if->tx_desc_init = xgbe_tx_desc_init;
2828         hw_if->rx_desc_init = xgbe_rx_desc_init;
2829         hw_if->tx_desc_reset = xgbe_tx_desc_reset;
2830         hw_if->is_last_desc = xgbe_is_last_desc;
2831         hw_if->is_context_desc = xgbe_is_context_desc;
2832
2833         /* For FLOW ctrl */
2834         hw_if->config_tx_flow_control = xgbe_config_tx_flow_control;
2835         hw_if->config_rx_flow_control = xgbe_config_rx_flow_control;
2836
2837         /* For RX coalescing */
2838         hw_if->config_rx_coalesce = xgbe_config_rx_coalesce;
2839         hw_if->config_tx_coalesce = xgbe_config_tx_coalesce;
2840         hw_if->usec_to_riwt = xgbe_usec_to_riwt;
2841         hw_if->riwt_to_usec = xgbe_riwt_to_usec;
2842
2843         /* For RX and TX threshold config */
2844         hw_if->config_rx_threshold = xgbe_config_rx_threshold;
2845         hw_if->config_tx_threshold = xgbe_config_tx_threshold;
2846
2847         /* For RX and TX Store and Forward Mode config */
2848         hw_if->config_rsf_mode = xgbe_config_rsf_mode;
2849         hw_if->config_tsf_mode = xgbe_config_tsf_mode;
2850
2851         /* For TX DMA Operating on Second Frame config */
2852         hw_if->config_osp_mode = xgbe_config_osp_mode;
2853
2854         /* For MMC statistics support */
2855         hw_if->tx_mmc_int = xgbe_tx_mmc_int;
2856         hw_if->rx_mmc_int = xgbe_rx_mmc_int;
2857         hw_if->read_mmc_stats = xgbe_read_mmc_stats;
2858
2859         /* For Receive Side Scaling */
2860         hw_if->enable_rss = xgbe_enable_rss;
2861         hw_if->disable_rss = xgbe_disable_rss;
2862         hw_if->set_rss_hash_key = xgbe_set_rss_hash_key;
2863         hw_if->set_rss_lookup_table = xgbe_set_rss_lookup_table;
2864 }