Changeset cd089b9 in rtems-libbsd for linux


Ignore:
Timestamp:
May 5, 2017, 6:47:39 AM (2 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
5283630d2c9d40deb0183696d278e02644fe4326, bc2ba9a9cdc7381c2a4f2ae6ee303be636f31368
Children:
721b1c1
Parents:
28ee86a
git-author:
Sebastian Huber <sebastian.huber@…> (05/05/17 06:47:39)
git-committer:
Sebastian Huber <sebastian.huber@…> (10/23/17 07:23:59)
Message:

Linux update to 4.11-rc5

Linux baseline a71c9a1c779f2499fb2afc0553e543f18aff6edf (4.11-rc5).

Location:
linux
Files:
2 added
14 deleted
28 edited

Legend:

Unmodified
Added
Removed
  • linux/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c

    r28ee86a rcd089b9  
    33#include <rtems/bsd/local/opt_dpaa.h>
    44
    5 /* Copyright 2008 - 2015 Freescale Semiconductor Inc.
     5/* Copyright 2008 - 2016 Freescale Semiconductor Inc.
    66 *
    77 * Redistribution and use in source and binary forms, with or without
     
    3737#include <linux/init.h>
    3838#include <linux/module.h>
     39#include <linux/of_platform.h>
    3940#include <linux/of_mdio.h>
    4041#include <linux/of_net.h>
    41 #include <linux/kthread.h>
    4242#include <linux/io.h>
    4343#ifndef __rtems__
     
    5050#include <linux/tcp.h>
    5151#include <linux/net.h>
     52#include <linux/skbuff.h>
     53#include <linux/etherdevice.h>
    5254#include <linux/if_ether.h>
    5355#include <linux/highmem.h>
    5456#include <linux/percpu.h>
    5557#include <linux/dma-mapping.h>
     58#include <linux/sort.h>
    5659#endif /* __rtems__ */
    5760#include <soc/fsl/bman.h>
     61#include <soc/fsl/qman.h>
    5862
    5963#include "fman.h"
    6064#include "fman_port.h"
    61 
    6265#include "mac.h"
    6366#include "dpaa_eth.h"
    64 #include "dpaa_eth_common.h"
    65 
    66 /* CREATE_TRACE_POINTS only needs to be defined once. Other dpa files
     67
     68/* CREATE_TRACE_POINTS only needs to be defined once. Other dpaa files
    6769 * using trace events only need to #include <trace/events/sched.h>
    6870 */
     
    7072#include "dpaa_eth_trace.h"
    7173
    72 #define DPA_NAPI_WEIGHT         64
    73 
    74 /* Valid checksum indication */
    75 #define DPA_CSUM_VALID          0xFFFF
    76 
    77 #define DPA_DESCRIPTION "FSL DPAA Ethernet driver"
     74static int debug = -1;
     75module_param(debug, int, 0444);
     76MODULE_PARM_DESC(debug, "Module/Driver verbosity level (0=none,...,16=all)");
     77
     78static u16 tx_timeout = 1000;
     79module_param(tx_timeout, ushort, 0444);
     80MODULE_PARM_DESC(tx_timeout, "The Tx timeout in ms");
     81
     82#define FM_FD_STAT_RX_ERRORS                                            \
     83        (FM_FD_ERR_DMA | FM_FD_ERR_PHYSICAL     | \
     84         FM_FD_ERR_SIZE | FM_FD_ERR_CLS_DISCARD | \
     85         FM_FD_ERR_EXTRACTION | FM_FD_ERR_NO_SCHEME     | \
     86         FM_FD_ERR_PRS_TIMEOUT | FM_FD_ERR_PRS_ILL_INSTRUCT | \
     87         FM_FD_ERR_PRS_HDR_ERR)
     88
     89#define FM_FD_STAT_TX_ERRORS \
     90        (FM_FD_ERR_UNSUPPORTED_FORMAT | \
     91         FM_FD_ERR_LENGTH | FM_FD_ERR_DMA)
     92
     93#define DPAA_MSG_DEFAULT (NETIF_MSG_DRV | NETIF_MSG_PROBE | \
     94                          NETIF_MSG_LINK | NETIF_MSG_IFUP | \
     95                          NETIF_MSG_IFDOWN)
    7896
    7997#define DPAA_INGRESS_CS_THRESHOLD 0x10000000
     
    84102 */
    85103
    86 #ifndef __rtems__
    87 static u8 debug = -1;
    88 module_param(debug, byte, S_IRUGO);
    89 MODULE_PARM_DESC(debug, "Module/Driver verbosity level");
    90 
    91 /* This has to work in tandem with the DPA_CS_THRESHOLD_xxx values. */
    92 static u16 tx_timeout = 1000;
    93 module_param(tx_timeout, ushort, S_IRUGO);
    94 MODULE_PARM_DESC(tx_timeout, "The Tx timeout in ms");
    95 #endif /* __rtems__ */
    96 
    97 /* BM */
    98 
    99 #define DPAA_ETH_MAX_PAD (L1_CACHE_BYTES * 8)
    100 
    101 static u8 dpa_priv_common_bpid;
    102 
    103 static void _dpa_rx_error(struct net_device *net_dev,
    104                           const struct dpa_priv_s *priv,
    105                           struct dpa_percpu_priv_s *percpu_priv,
     104/* Size in bytes of the FQ taildrop threshold */
     105#define DPAA_FQ_TD 0x200000
     106
     107#define DPAA_CS_THRESHOLD_1G 0x06000000
     108/* Egress congestion threshold on 1G ports, range 0x1000 .. 0x10000000
     109 * The size in bytes of the egress Congestion State notification threshold on
     110 * 1G ports. The 1G dTSECs can quite easily be flooded by cores doing Tx in a
     111 * tight loop (e.g. by sending UDP datagrams at "while(1) speed"),
     112 * and the larger the frame size, the more acute the problem.
     113 * So we have to find a balance between these factors:
     114 * - avoiding the device staying congested for a prolonged time (risking
     115 *   the netdev watchdog to fire - see also the tx_timeout module param);
     116 * - affecting performance of protocols such as TCP, which otherwise
     117 *   behave well under the congestion notification mechanism;
     118 * - preventing the Tx cores from tightly-looping (as if the congestion
     119 *   threshold was too low to be effective);
     120 * - running out of memory if the CS threshold is set too high.
     121 */
     122
     123#define DPAA_CS_THRESHOLD_10G 0x10000000
     124/* The size in bytes of the egress Congestion State notification threshold on
     125 * 10G ports, range 0x1000 .. 0x10000000
     126 */
     127
     128/* Largest value that the FQD's OAL field can hold */
     129#define FSL_QMAN_MAX_OAL        127
     130
     131/* Default alignment for start of data in an Rx FD */
     132#define DPAA_FD_DATA_ALIGNMENT  16
     133
     134/* Values for the L3R field of the FM Parse Results
     135 */
     136/* L3 Type field: First IP Present IPv4 */
     137#define FM_L3_PARSE_RESULT_IPV4 0x8000
     138/* L3 Type field: First IP Present IPv6 */
     139#define FM_L3_PARSE_RESULT_IPV6 0x4000
     140/* Values for the L4R field of the FM Parse Results */
     141/* L4 Type field: UDP */
     142#define FM_L4_PARSE_RESULT_UDP  0x40
     143/* L4 Type field: TCP */
     144#define FM_L4_PARSE_RESULT_TCP  0x20
     145
     146#define DPAA_SGT_MAX_ENTRIES 16 /* maximum number of entries in SG Table */
     147#define DPAA_BUFF_RELEASE_MAX 8 /* maximum number of buffers released at once */
     148
     149#define FSL_DPAA_BPID_INV               0xff
     150#define FSL_DPAA_ETH_MAX_BUF_COUNT      128
     151#define FSL_DPAA_ETH_REFILL_THRESHOLD   80
     152
     153#define DPAA_TX_PRIV_DATA_SIZE  16
     154#define DPAA_PARSE_RESULTS_SIZE sizeof(struct fman_prs_result)
     155#define DPAA_TIME_STAMP_SIZE 8
     156#define DPAA_HASH_RESULTS_SIZE 8
     157#define DPAA_RX_PRIV_DATA_SIZE  (u16)(DPAA_TX_PRIV_DATA_SIZE + \
     158                                        dpaa_rx_extra_headroom)
     159
     160#define DPAA_ETH_RX_QUEUES      128
     161
     162#define DPAA_ENQUEUE_RETRIES    100000
     163
     164enum port_type {RX, TX};
     165
     166struct fm_port_fqs {
     167        struct dpaa_fq *tx_defq;
     168        struct dpaa_fq *tx_errq;
     169        struct dpaa_fq *rx_defq;
     170        struct dpaa_fq *rx_errq;
     171};
     172
     173/* All the dpa bps in use at any moment */
     174static struct dpaa_bp *dpaa_bp_array[BM_MAX_NUM_OF_POOLS];
     175
     176/* The raw buffer size must be cacheline aligned */
     177#ifndef __rtems__
     178#define DPAA_BP_RAW_SIZE 4096
     179#else /* __rtems__ */
     180/*
     181 * FIXME: Support multiple buffer pools.
     182 */
     183#define DPAA_BP_RAW_SIZE 2048
     184
     185/*
     186 * FIXME: 4 bytes would be enough for the mbuf pointer.  However, jumbo receive
     187 * frames overwrite this area if < 64 bytes.
     188 */
     189#define DPAA_OUT_OF_BAND_SIZE 64
     190
     191#define DPAA_MBUF_POINTER_OFFSET (DPAA_BP_RAW_SIZE - DPAA_OUT_OF_BAND_SIZE)
     192#endif /* __rtems__ */
     193/* When using more than one buffer pool, the raw sizes are as follows:
     194 * 1 bp: 4KB
     195 * 2 bp: 2KB, 4KB
     196 * 3 bp: 1KB, 2KB, 4KB
     197 * 4 bp: 1KB, 2KB, 4KB, 8KB
     198 */
     199static inline size_t bpool_buffer_raw_size(u8 index, u8 cnt)
     200{
     201        size_t res = DPAA_BP_RAW_SIZE / 4;
     202        u8 i;
     203
     204        for (i = (cnt < 3) ? cnt : 3; i < 3 + index; i++)
     205                res *= 2;
     206        return res;
     207}
     208
     209/* FMan-DMA requires 16-byte alignment for Rx buffers, but SKB_DATA_ALIGN is
     210 * even stronger (SMP_CACHE_BYTES-aligned), so we just get away with that,
     211 * via SKB_WITH_OVERHEAD(). We can't rely on netdev_alloc_frag() giving us
     212 * half-page-aligned buffers, so we reserve some more space for start-of-buffer
     213 * alignment.
     214 */
     215#ifndef __rtems__
     216#define dpaa_bp_size(raw_size) SKB_WITH_OVERHEAD((raw_size) - SMP_CACHE_BYTES)
     217#else /* __rtems__ */
     218#define dpaa_bp_size(raw_size) DPAA_MBUF_POINTER_OFFSET
     219#endif /* __rtems__ */
     220
     221#ifndef __rtems__
     222static int dpaa_max_frm;
     223#endif /* __rtems__ */
     224
     225#ifndef __rtems__
     226static int dpaa_rx_extra_headroom;
     227#else /* __rtems__ */
     228#define dpaa_rx_extra_headroom fman_get_rx_extra_headroom()
     229#endif /* __rtems__ */
     230
     231#define dpaa_get_max_mtu()      \
     232        (dpaa_max_frm - (VLAN_ETH_HLEN + ETH_FCS_LEN))
     233
     234#ifndef __rtems__
     235static int dpaa_netdev_init(struct net_device *net_dev,
     236                            const struct net_device_ops *dpaa_ops,
     237                            u16 tx_timeout)
     238{
     239        struct dpaa_priv *priv = netdev_priv(net_dev);
     240        struct device *dev = net_dev->dev.parent;
     241        struct dpaa_percpu_priv *percpu_priv;
     242        const u8 *mac_addr;
     243        int i, err;
     244
     245        /* Although we access another CPU's private data here
     246         * we do it at initialization so it is safe
     247         */
     248        for_each_possible_cpu(i) {
     249                percpu_priv = per_cpu_ptr(priv->percpu_priv, i);
     250                percpu_priv->net_dev = net_dev;
     251        }
     252
     253        net_dev->netdev_ops = dpaa_ops;
     254        mac_addr = priv->mac_dev->addr;
     255
     256        net_dev->mem_start = priv->mac_dev->res->start;
     257        net_dev->mem_end = priv->mac_dev->res->end;
     258
     259        net_dev->min_mtu = ETH_MIN_MTU;
     260        net_dev->max_mtu = dpaa_get_max_mtu();
     261
     262        net_dev->hw_features |= (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
     263                                 NETIF_F_LLTX);
     264
     265        net_dev->hw_features |= NETIF_F_SG | NETIF_F_HIGHDMA;
     266        /* The kernels enables GSO automatically, if we declare NETIF_F_SG.
     267         * For conformity, we'll still declare GSO explicitly.
     268         */
     269        net_dev->features |= NETIF_F_GSO;
     270
     271        net_dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
     272        /* we do not want shared skbs on TX */
     273        net_dev->priv_flags &= ~IFF_TX_SKB_SHARING;
     274
     275        net_dev->features |= net_dev->hw_features;
     276        net_dev->vlan_features = net_dev->features;
     277
     278        memcpy(net_dev->perm_addr, mac_addr, net_dev->addr_len);
     279        memcpy(net_dev->dev_addr, mac_addr, net_dev->addr_len);
     280
     281        net_dev->ethtool_ops = &dpaa_ethtool_ops;
     282
     283        net_dev->needed_headroom = priv->tx_headroom;
     284        net_dev->watchdog_timeo = msecs_to_jiffies(tx_timeout);
     285
     286        /* start without the RUNNING flag, phylib controls it later */
     287        netif_carrier_off(net_dev);
     288
     289        err = register_netdev(net_dev);
     290        if (err < 0) {
     291                dev_err(dev, "register_netdev() = %d\n", err);
     292                return err;
     293        }
     294
     295        return 0;
     296}
     297#endif /* __rtems__ */
     298
     299static int dpaa_stop(struct net_device *net_dev)
     300{
     301        struct mac_device *mac_dev;
     302        struct dpaa_priv *priv;
     303        int i, err, error;
     304
     305        priv = netdev_priv(net_dev);
     306        mac_dev = priv->mac_dev;
     307
     308#ifndef __rtems__
     309        netif_tx_stop_all_queues(net_dev);
     310#endif /* __rtems__ */
     311        /* Allow the Fman (Tx) port to process in-flight frames before we
     312         * try switching it off.
     313         */
     314        usleep_range(5000, 10000);
     315
     316        err = mac_dev->stop(mac_dev);
     317        if (err < 0)
     318                netif_err(priv, ifdown, net_dev, "mac_dev->stop() = %d\n",
     319                          err);
     320
     321        for (i = 0; i < ARRAY_SIZE(mac_dev->port); i++) {
     322                error = fman_port_disable(mac_dev->port[i]);
     323                if (error)
     324                        err = error;
     325        }
     326
     327#ifndef __rtems__
     328        if (net_dev->phydev)
     329                phy_disconnect(net_dev->phydev);
     330        net_dev->phydev = NULL;
     331#endif /* __rtems__ */
     332
     333        return err;
     334}
     335
     336#ifndef __rtems__
     337static void dpaa_tx_timeout(struct net_device *net_dev)
     338{
     339        struct dpaa_percpu_priv *percpu_priv;
     340        const struct dpaa_priv  *priv;
     341
     342        priv = netdev_priv(net_dev);
     343        percpu_priv = this_cpu_ptr(priv->percpu_priv);
     344
     345        netif_crit(priv, timer, net_dev, "Transmit timeout latency: %u ms\n",
     346                   jiffies_to_msecs(jiffies - dev_trans_start(net_dev)));
     347
     348        percpu_priv->stats.tx_errors++;
     349}
     350
     351/* Calculates the statistics for the given device by adding the statistics
     352 * collected by each CPU.
     353 */
     354static void dpaa_get_stats64(struct net_device *net_dev,
     355                             struct rtnl_link_stats64 *s)
     356{
     357        int numstats = sizeof(struct rtnl_link_stats64) / sizeof(u64);
     358        struct dpaa_priv *priv = netdev_priv(net_dev);
     359        struct dpaa_percpu_priv *percpu_priv;
     360        u64 *netstats = (u64 *)s;
     361        u64 *cpustats;
     362        int i, j;
     363
     364        for_each_possible_cpu(i) {
     365                percpu_priv = per_cpu_ptr(priv->percpu_priv, i);
     366
     367                cpustats = (u64 *)&percpu_priv->stats;
     368
     369                /* add stats from all CPUs */
     370                for (j = 0; j < numstats; j++)
     371                        netstats[j] += cpustats[j];
     372        }
     373}
     374
     375static struct mac_device *dpaa_mac_dev_get(struct platform_device *pdev)
     376{
     377        struct platform_device *of_dev;
     378        struct dpaa_eth_data *eth_data;
     379        struct device *dpaa_dev, *dev;
     380        struct device_node *mac_node;
     381        struct mac_device *mac_dev;
     382
     383        dpaa_dev = &pdev->dev;
     384        eth_data = dpaa_dev->platform_data;
     385        if (!eth_data)
     386                return ERR_PTR(-ENODEV);
     387
     388        mac_node = eth_data->mac_node;
     389
     390        of_dev = of_find_device_by_node(mac_node);
     391        if (!of_dev) {
     392                dev_err(dpaa_dev, "of_find_device_by_node(%s) failed\n",
     393                        mac_node->full_name);
     394                of_node_put(mac_node);
     395                return ERR_PTR(-EINVAL);
     396        }
     397        of_node_put(mac_node);
     398
     399        dev = &of_dev->dev;
     400
     401        mac_dev = dev_get_drvdata(dev);
     402        if (!mac_dev) {
     403                dev_err(dpaa_dev, "dev_get_drvdata(%s) failed\n",
     404                        dev_name(dev));
     405                return ERR_PTR(-EINVAL);
     406        }
     407
     408        return mac_dev;
     409}
     410
     411static int dpaa_set_mac_address(struct net_device *net_dev, void *addr)
     412{
     413        const struct dpaa_priv *priv;
     414        struct mac_device *mac_dev;
     415        struct sockaddr old_addr;
     416        int err;
     417
     418        priv = netdev_priv(net_dev);
     419
     420        memcpy(old_addr.sa_data, net_dev->dev_addr,  ETH_ALEN);
     421
     422        err = eth_mac_addr(net_dev, addr);
     423        if (err < 0) {
     424                netif_err(priv, drv, net_dev, "eth_mac_addr() = %d\n", err);
     425                return err;
     426        }
     427
     428        mac_dev = priv->mac_dev;
     429
     430        err = mac_dev->change_addr(mac_dev->fman_mac,
     431                                   (enet_addr_t *)net_dev->dev_addr);
     432        if (err < 0) {
     433                netif_err(priv, drv, net_dev, "mac_dev->change_addr() = %d\n",
     434                          err);
     435                /* reverting to previous address */
     436                eth_mac_addr(net_dev, &old_addr);
     437
     438                return err;
     439        }
     440
     441        return 0;
     442}
     443
     444static void dpaa_set_rx_mode(struct net_device *net_dev)
     445{
     446        const struct dpaa_priv  *priv;
     447        int err;
     448
     449        priv = netdev_priv(net_dev);
     450
     451        if (!!(net_dev->flags & IFF_PROMISC) != priv->mac_dev->promisc) {
     452                priv->mac_dev->promisc = !priv->mac_dev->promisc;
     453                err = priv->mac_dev->set_promisc(priv->mac_dev->fman_mac,
     454                                                 priv->mac_dev->promisc);
     455                if (err < 0)
     456                        netif_err(priv, drv, net_dev,
     457                                  "mac_dev->set_promisc() = %d\n",
     458                                  err);
     459        }
     460
     461        err = priv->mac_dev->set_multi(net_dev, priv->mac_dev);
     462        if (err < 0)
     463                netif_err(priv, drv, net_dev, "mac_dev->set_multi() = %d\n",
     464                          err);
     465}
     466#endif /* __rtems__ */
     467
     468static struct dpaa_bp *dpaa_bpid2pool(int bpid)
     469{
     470        if (WARN_ON(bpid < 0 || bpid >= BM_MAX_NUM_OF_POOLS))
     471                return NULL;
     472
     473        return dpaa_bp_array[bpid];
     474}
     475
     476/* checks if this bpool is already allocated */
     477static bool dpaa_bpid2pool_use(int bpid)
     478{
     479        if (dpaa_bpid2pool(bpid)) {
     480                atomic_inc(&dpaa_bp_array[bpid]->refs);
     481                return true;
     482        }
     483
     484        return false;
     485}
     486
     487/* called only once per bpid by dpaa_bp_alloc_pool() */
     488static void dpaa_bpid2pool_map(int bpid, struct dpaa_bp *dpaa_bp)
     489{
     490        dpaa_bp_array[bpid] = dpaa_bp;
     491        atomic_set(&dpaa_bp->refs, 1);
     492}
     493
     494static int dpaa_bp_alloc_pool(struct dpaa_bp *dpaa_bp)
     495{
     496        int err;
     497
     498        if (dpaa_bp->size == 0 || dpaa_bp->config_count == 0) {
     499                pr_err("%s: Buffer pool is not properly initialized! Missing size or initial number of buffers\n",
     500                       __func__);
     501                return -EINVAL;
     502        }
     503
     504        /* If the pool is already specified, we only create one per bpid */
     505        if (dpaa_bp->bpid != FSL_DPAA_BPID_INV &&
     506            dpaa_bpid2pool_use(dpaa_bp->bpid))
     507                return 0;
     508
     509        if (dpaa_bp->bpid == FSL_DPAA_BPID_INV) {
     510                dpaa_bp->pool = bman_new_pool();
     511                if (!dpaa_bp->pool) {
     512                        pr_err("%s: bman_new_pool() failed\n",
     513                               __func__);
     514                        return -ENODEV;
     515                }
     516
     517                dpaa_bp->bpid = (u8)bman_get_bpid(dpaa_bp->pool);
     518        }
     519
     520        if (dpaa_bp->seed_cb) {
     521                err = dpaa_bp->seed_cb(dpaa_bp);
     522                if (err)
     523                        goto pool_seed_failed;
     524        }
     525
     526        dpaa_bpid2pool_map(dpaa_bp->bpid, dpaa_bp);
     527
     528        return 0;
     529
     530pool_seed_failed:
     531        pr_err("%s: pool seeding failed\n", __func__);
     532        bman_free_pool(dpaa_bp->pool);
     533
     534        return err;
     535}
     536
     537/* remove and free all the buffers from the given buffer pool */
     538static void dpaa_bp_drain(struct dpaa_bp *bp)
     539{
     540        u8 num = 8;
     541        int ret;
     542
     543        do {
     544                struct bm_buffer bmb[8];
     545                int i;
     546
     547                ret = bman_acquire(bp->pool, bmb, num);
     548                if (ret < 0) {
     549                        if (num == 8) {
     550                                /* we have less than 8 buffers left;
     551                                 * drain them one by one
     552                                 */
     553                                num = 1;
     554                                ret = 1;
     555                                continue;
     556                        } else {
     557                                /* Pool is fully drained */
     558                                break;
     559                        }
     560                }
     561
     562                if (bp->free_buf_cb)
     563                        for (i = 0; i < num; i++)
     564                                bp->free_buf_cb(bp, &bmb[i]);
     565        } while (ret > 0);
     566}
     567
     568static void dpaa_bp_free(struct dpaa_bp *dpaa_bp)
     569{
     570        struct dpaa_bp *bp = dpaa_bpid2pool(dpaa_bp->bpid);
     571
     572        /* the mapping between bpid and dpaa_bp is done very late in the
     573         * allocation procedure; if something failed before the mapping, the bp
     574         * was not configured, therefore we don't need the below instructions
     575         */
     576        if (!bp)
     577                return;
     578
     579        if (!atomic_dec_and_test(&bp->refs))
     580                return;
     581
     582        if (bp->free_buf_cb)
     583                dpaa_bp_drain(bp);
     584
     585        dpaa_bp_array[bp->bpid] = NULL;
     586        bman_free_pool(bp->pool);
     587}
     588
     589static void dpaa_bps_free(struct dpaa_priv *priv)
     590{
     591        int i;
     592
     593        for (i = 0; i < DPAA_BPS_NUM; i++)
     594                dpaa_bp_free(priv->dpaa_bps[i]);
     595}
     596
     597/* Use multiple WQs for FQ assignment:
     598 *      - Tx Confirmation queues go to WQ1.
     599 *      - Rx Error and Tx Error queues go to WQ2 (giving them a better chance
     600 *        to be scheduled, in case there are many more FQs in WQ3).
     601 *      - Rx Default and Tx queues go to WQ3 (no differentiation between
     602 *        Rx and Tx traffic).
     603 * This ensures that Tx-confirmed buffers are timely released. In particular,
     604 * it avoids congestion on the Tx Confirm FQs, which can pile up PFDRs if they
     605 * are greatly outnumbered by other FQs in the system, while
     606 * dequeue scheduling is round-robin.
     607 */
     608static inline void dpaa_assign_wq(struct dpaa_fq *fq)
     609{
     610        switch (fq->fq_type) {
     611        case FQ_TYPE_TX_CONFIRM:
     612        case FQ_TYPE_TX_CONF_MQ:
     613                fq->wq = 1;
     614                break;
     615        case FQ_TYPE_RX_ERROR:
     616        case FQ_TYPE_TX_ERROR:
     617                fq->wq = 2;
     618                break;
     619        case FQ_TYPE_RX_DEFAULT:
     620        case FQ_TYPE_TX:
     621                fq->wq = 3;
     622                break;
     623        default:
     624                WARN(1, "Invalid FQ type %d for FQID %d!\n",
     625                     fq->fq_type, fq->fqid);
     626        }
     627}
     628
     629static struct dpaa_fq *dpaa_fq_alloc(struct device *dev,
     630                                     u32 start, u32 count,
     631                                     struct list_head *list,
     632                                     enum dpaa_fq_type fq_type)
     633{
     634        struct dpaa_fq *dpaa_fq;
     635        int i;
     636
     637        dpaa_fq = devm_kzalloc(dev, sizeof(*dpaa_fq) * count,
     638                               GFP_KERNEL);
     639        if (!dpaa_fq)
     640                return NULL;
     641
     642        for (i = 0; i < count; i++) {
     643                dpaa_fq[i].fq_type = fq_type;
     644                dpaa_fq[i].fqid = start ? start + i : 0;
     645                list_add_tail(&dpaa_fq[i].list, list);
     646        }
     647
     648        for (i = 0; i < count; i++)
     649                dpaa_assign_wq(dpaa_fq + i);
     650
     651        return dpaa_fq;
     652}
     653
     654static int dpaa_alloc_all_fqs(struct device *dev, struct list_head *list,
     655                              struct fm_port_fqs *port_fqs)
     656{
     657        struct dpaa_fq *dpaa_fq;
     658
     659        dpaa_fq = dpaa_fq_alloc(dev, 0, 1, list, FQ_TYPE_RX_ERROR);
     660        if (!dpaa_fq)
     661                goto fq_alloc_failed;
     662
     663        port_fqs->rx_errq = &dpaa_fq[0];
     664
     665        dpaa_fq = dpaa_fq_alloc(dev, 0, 1, list, FQ_TYPE_RX_DEFAULT);
     666        if (!dpaa_fq)
     667                goto fq_alloc_failed;
     668
     669        port_fqs->rx_defq = &dpaa_fq[0];
     670
     671        if (!dpaa_fq_alloc(dev, 0, DPAA_ETH_TXQ_NUM, list, FQ_TYPE_TX_CONF_MQ))
     672                goto fq_alloc_failed;
     673
     674        dpaa_fq = dpaa_fq_alloc(dev, 0, 1, list, FQ_TYPE_TX_ERROR);
     675        if (!dpaa_fq)
     676                goto fq_alloc_failed;
     677
     678        port_fqs->tx_errq = &dpaa_fq[0];
     679
     680        dpaa_fq = dpaa_fq_alloc(dev, 0, 1, list, FQ_TYPE_TX_CONFIRM);
     681        if (!dpaa_fq)
     682                goto fq_alloc_failed;
     683
     684        port_fqs->tx_defq = &dpaa_fq[0];
     685
     686        if (!dpaa_fq_alloc(dev, 0, DPAA_ETH_TXQ_NUM, list, FQ_TYPE_TX))
     687                goto fq_alloc_failed;
     688
     689        return 0;
     690
     691fq_alloc_failed:
     692        dev_err(dev, "dpaa_fq_alloc() failed\n");
     693        return -ENOMEM;
     694}
     695
     696static u32 rx_pool_channel;
     697static DEFINE_SPINLOCK(rx_pool_channel_init);
     698
     699static int dpaa_get_channel(void)
     700{
     701        spin_lock(&rx_pool_channel_init);
     702        if (!rx_pool_channel) {
     703                u32 pool;
     704                int ret;
     705
     706                ret = qman_alloc_pool(&pool);
     707
     708                if (!ret)
     709                        rx_pool_channel = pool;
     710        }
     711        spin_unlock(&rx_pool_channel_init);
     712        if (!rx_pool_channel)
     713                return -ENOMEM;
     714        return rx_pool_channel;
     715}
     716
     717#ifndef __rtems__
     718static void dpaa_release_channel(void)
     719{
     720        qman_release_pool(rx_pool_channel);
     721}
     722#endif /* __rtems__ */
     723
     724static void dpaa_eth_add_channel(u16 channel)
     725{
     726        u32 pool = QM_SDQCR_CHANNELS_POOL_CONV(channel);
     727#ifndef __rtems__
     728        const cpumask_t *cpus = qman_affine_cpus();
     729#endif /* __rtems__ */
     730        struct qman_portal *portal;
     731        int cpu;
     732
     733        for_each_cpu(cpu, cpus) {
     734                portal = qman_get_affine_portal(cpu);
     735                qman_p_static_dequeue_add(portal, pool);
     736        }
     737}
     738
     739/* Congestion group state change notification callback.
     740 * Stops the device's egress queues while they are congested and
     741 * wakes them upon exiting congested state.
     742 * Also updates some CGR-related stats.
     743 */
     744static void dpaa_eth_cgscn(struct qman_portal *qm, struct qman_cgr *cgr,
     745                           int congested)
     746{
     747        struct dpaa_priv *priv = (struct dpaa_priv *)container_of(cgr,
     748                struct dpaa_priv, cgr_data.cgr);
     749
     750        if (congested) {
     751                priv->cgr_data.congestion_start_jiffies = jiffies;
     752#ifndef __rtems__
     753                netif_tx_stop_all_queues(priv->net_dev);
     754#endif /* __rtems__ */
     755                priv->cgr_data.cgr_congested_count++;
     756        } else {
     757                priv->cgr_data.congested_jiffies +=
     758                        (jiffies - priv->cgr_data.congestion_start_jiffies);
     759#ifndef __rtems__
     760                netif_tx_wake_all_queues(priv->net_dev);
     761#endif /* __rtems__ */
     762        }
     763}
     764
     765static int dpaa_eth_cgr_init(struct dpaa_priv *priv)
     766{
     767        struct qm_mcc_initcgr initcgr;
     768        u32 cs_th;
     769        int err;
     770
     771        err = qman_alloc_cgrid(&priv->cgr_data.cgr.cgrid);
     772        if (err < 0) {
     773                if (netif_msg_drv(priv))
     774                        pr_err("%s: Error %d allocating CGR ID\n",
     775                               __func__, err);
     776                goto out_error;
     777        }
     778        priv->cgr_data.cgr.cb = dpaa_eth_cgscn;
     779
     780        /* Enable Congestion State Change Notifications and CS taildrop */
     781        memset(&initcgr, 0, sizeof(initcgr));
     782        initcgr.we_mask = cpu_to_be16(QM_CGR_WE_CSCN_EN | QM_CGR_WE_CS_THRES);
     783        initcgr.cgr.cscn_en = QM_CGR_EN;
     784
     785        /* Set different thresholds based on the MAC speed.
     786         * This may turn suboptimal if the MAC is reconfigured at a speed
     787         * lower than its max, e.g. if a dTSEC later negotiates a 100Mbps link.
     788         * In such cases, we ought to reconfigure the threshold, too.
     789         */
     790        if (priv->mac_dev->if_support & SUPPORTED_10000baseT_Full)
     791                cs_th = DPAA_CS_THRESHOLD_10G;
     792        else
     793                cs_th = DPAA_CS_THRESHOLD_1G;
     794        qm_cgr_cs_thres_set64(&initcgr.cgr.cs_thres, cs_th, 1);
     795
     796        initcgr.we_mask |= cpu_to_be16(QM_CGR_WE_CSTD_EN);
     797        initcgr.cgr.cstd_en = QM_CGR_EN;
     798
     799        err = qman_create_cgr(&priv->cgr_data.cgr, QMAN_CGR_FLAG_USE_INIT,
     800                              &initcgr);
     801        if (err < 0) {
     802                if (netif_msg_drv(priv))
     803                        pr_err("%s: Error %d creating CGR with ID %d\n",
     804                               __func__, err, priv->cgr_data.cgr.cgrid);
     805                qman_release_cgrid(priv->cgr_data.cgr.cgrid);
     806                goto out_error;
     807        }
     808        if (netif_msg_drv(priv))
     809                pr_debug("Created CGR %d for netdev with hwaddr %pM on QMan channel %d\n",
     810                         priv->cgr_data.cgr.cgrid, priv->mac_dev->addr,
     811                         priv->cgr_data.cgr.chan);
     812
     813out_error:
     814        return err;
     815}
     816
     817static inline void dpaa_setup_ingress(const struct dpaa_priv *priv,
     818                                      struct dpaa_fq *fq,
     819                                      const struct qman_fq *template)
     820{
     821        fq->fq_base = *template;
     822        fq->net_dev = priv->net_dev;
     823
     824        fq->flags = QMAN_FQ_FLAG_NO_ENQUEUE;
     825        fq->channel = priv->channel;
     826}
     827
     828static inline void dpaa_setup_egress(const struct dpaa_priv *priv,
     829                                     struct dpaa_fq *fq,
     830                                     struct fman_port *port,
     831                                     const struct qman_fq *template)
     832{
     833        fq->fq_base = *template;
     834        fq->net_dev = priv->net_dev;
     835
     836        if (port) {
     837                fq->flags = QMAN_FQ_FLAG_TO_DCPORTAL;
     838                fq->channel = (u16)fman_port_get_qman_channel_id(port);
     839        } else {
     840                fq->flags = QMAN_FQ_FLAG_NO_MODIFY;
     841        }
     842}
     843
     844static void dpaa_fq_setup(struct dpaa_priv *priv,
     845                          const struct dpaa_fq_cbs *fq_cbs,
     846                          struct fman_port *tx_port)
     847{
     848#ifndef __rtems__
     849        int egress_cnt = 0, conf_cnt = 0, num_portals = 0, cpu;
     850        const cpumask_t *affine_cpus = qman_affine_cpus();
     851        u16 portals[NR_CPUS];
     852#else /* __rtems__ */
     853        int egress_cnt = 0, conf_cnt = 0;
     854#endif /* __rtems__ */
     855        struct dpaa_fq *fq;
     856
     857#ifndef __rtems__
     858        for_each_cpu(cpu, affine_cpus)
     859                portals[num_portals++] = qman_affine_channel(cpu);
     860        if (num_portals == 0)
     861                dev_err(priv->net_dev->dev.parent,
     862                        "No Qman software (affine) channels found");
     863#endif /* __rtems__ */
     864
     865        /* Initialize each FQ in the list */
     866        list_for_each_entry(fq, &priv->dpaa_fq_list, list) {
     867                switch (fq->fq_type) {
     868                case FQ_TYPE_RX_DEFAULT:
     869                        dpaa_setup_ingress(priv, fq, &fq_cbs->rx_defq);
     870                        break;
     871                case FQ_TYPE_RX_ERROR:
     872                        dpaa_setup_ingress(priv, fq, &fq_cbs->rx_errq);
     873                        break;
     874                case FQ_TYPE_TX:
     875                        dpaa_setup_egress(priv, fq, tx_port,
     876                                          &fq_cbs->egress_ern);
     877                        /* If we have more Tx queues than the number of cores,
     878                         * just ignore the extra ones.
     879                         */
     880                        if (egress_cnt < DPAA_ETH_TXQ_NUM)
     881                                priv->egress_fqs[egress_cnt++] = &fq->fq_base;
     882                        break;
     883                case FQ_TYPE_TX_CONF_MQ:
     884                        priv->conf_fqs[conf_cnt++] = &fq->fq_base;
     885                        /* fall through */
     886                case FQ_TYPE_TX_CONFIRM:
     887                        dpaa_setup_ingress(priv, fq, &fq_cbs->tx_defq);
     888                        break;
     889                case FQ_TYPE_TX_ERROR:
     890                        dpaa_setup_ingress(priv, fq, &fq_cbs->tx_errq);
     891                        break;
     892                default:
     893#ifndef __rtems__
     894                        dev_warn(priv->net_dev->dev.parent,
     895                                 "Unknown FQ type detected!\n");
     896#else /* __rtems__ */
     897                        BSD_ASSERT(0);
     898#endif /* __rtems__ */
     899                        break;
     900                }
     901        }
     902
     903         /* Make sure all CPUs receive a corresponding Tx queue. */
     904        while (egress_cnt < DPAA_ETH_TXQ_NUM) {
     905                list_for_each_entry(fq, &priv->dpaa_fq_list, list) {
     906                        if (fq->fq_type != FQ_TYPE_TX)
     907                                continue;
     908                        priv->egress_fqs[egress_cnt++] = &fq->fq_base;
     909                        if (egress_cnt == DPAA_ETH_TXQ_NUM)
     910                                break;
     911                }
     912        }
     913}
     914
     915static inline int dpaa_tx_fq_to_id(const struct dpaa_priv *priv,
     916                                   struct qman_fq *tx_fq)
     917{
     918        int i;
     919
     920        for (i = 0; i < DPAA_ETH_TXQ_NUM; i++)
     921                if (priv->egress_fqs[i] == tx_fq)
     922                        return i;
     923
     924        return -EINVAL;
     925}
     926
     927static int dpaa_fq_init(struct dpaa_fq *dpaa_fq, bool td_enable)
     928{
     929        const struct dpaa_priv  *priv;
     930        struct qman_fq *confq = NULL;
     931        struct qm_mcc_initfq initfq;
     932#ifndef __rtems__
     933        struct device *dev;
     934#endif /* __rtems__ */
     935        struct qman_fq *fq;
     936        int queue_id;
     937        int err;
     938
     939        priv = netdev_priv(dpaa_fq->net_dev);
     940#ifndef __rtems__
     941        dev = dpaa_fq->net_dev->dev.parent;
     942#endif /* __rtems__ */
     943
     944        if (dpaa_fq->fqid == 0)
     945                dpaa_fq->flags |= QMAN_FQ_FLAG_DYNAMIC_FQID;
     946
     947        dpaa_fq->init = !(dpaa_fq->flags & QMAN_FQ_FLAG_NO_MODIFY);
     948
     949        err = qman_create_fq(dpaa_fq->fqid, dpaa_fq->flags, &dpaa_fq->fq_base);
     950        if (err) {
     951#ifndef __rtems__
     952                dev_err(dev, "qman_create_fq() failed\n");
     953#else /* __rtems__ */
     954                BSD_ASSERT(0);
     955#endif /* __rtems__ */
     956                return err;
     957        }
     958        fq = &dpaa_fq->fq_base;
     959
     960        if (dpaa_fq->init) {
     961                memset(&initfq, 0, sizeof(initfq));
     962
     963                initfq.we_mask = cpu_to_be16(QM_INITFQ_WE_FQCTRL);
     964                /* Note: we may get to keep an empty FQ in cache */
     965                initfq.fqd.fq_ctrl = cpu_to_be16(QM_FQCTRL_PREFERINCACHE);
     966
     967                /* Try to reduce the number of portal interrupts for
     968                 * Tx Confirmation FQs.
     969                 */
     970                if (dpaa_fq->fq_type == FQ_TYPE_TX_CONFIRM)
     971                        initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_HOLDACTIVE);
     972
     973                /* FQ placement */
     974                initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_DESTWQ);
     975
     976                qm_fqd_set_destwq(&initfq.fqd, dpaa_fq->channel, dpaa_fq->wq);
     977
     978                /* Put all egress queues in a congestion group of their own.
     979                 * Sensu stricto, the Tx confirmation queues are Rx FQs,
     980                 * rather than Tx - but they nonetheless account for the
     981                 * memory footprint on behalf of egress traffic. We therefore
     982                 * place them in the netdev's CGR, along with the Tx FQs.
     983                 */
     984                if (dpaa_fq->fq_type == FQ_TYPE_TX ||
     985                    dpaa_fq->fq_type == FQ_TYPE_TX_CONFIRM ||
     986                    dpaa_fq->fq_type == FQ_TYPE_TX_CONF_MQ) {
     987                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_CGID);
     988                        initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_CGE);
     989                        initfq.fqd.cgid = (u8)priv->cgr_data.cgr.cgrid;
     990                        /* Set a fixed overhead accounting, in an attempt to
     991                         * reduce the impact of fixed-size skb shells and the
     992                         * driver's needed headroom on system memory. This is
     993                         * especially the case when the egress traffic is
     994                         * composed of small datagrams.
     995                         * Unfortunately, QMan's OAL value is capped to an
     996                         * insufficient value, but even that is better than
     997                         * no overhead accounting at all.
     998                         */
     999                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_OAC);
     1000                        qm_fqd_set_oac(&initfq.fqd, QM_OAC_CG);
     1001                        qm_fqd_set_oal(&initfq.fqd,
     1002#ifndef __rtems__
     1003                                       min(sizeof(struct sk_buff) +
     1004#else /* __rtems__ */
     1005                                       min(
     1006#endif /* __rtems__ */
     1007                                       priv->tx_headroom,
     1008                                       (size_t)FSL_QMAN_MAX_OAL));
     1009                }
     1010
     1011                if (td_enable) {
     1012                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_TDTHRESH);
     1013                        qm_fqd_set_taildrop(&initfq.fqd, DPAA_FQ_TD, 1);
     1014                        initfq.fqd.fq_ctrl = cpu_to_be16(QM_FQCTRL_TDE);
     1015                }
     1016
     1017                if (dpaa_fq->fq_type == FQ_TYPE_TX) {
     1018                        queue_id = dpaa_tx_fq_to_id(priv, &dpaa_fq->fq_base);
     1019                        if (queue_id >= 0)
     1020                                confq = priv->conf_fqs[queue_id];
     1021                        if (confq) {
     1022                                initfq.we_mask |=
     1023                                        cpu_to_be16(QM_INITFQ_WE_CONTEXTA);
     1024                        /* ContextA: OVOM=1(use contextA2 bits instead of ICAD)
     1025                         *           A2V=1 (contextA A2 field is valid)
     1026                         *           A0V=1 (contextA A0 field is valid)
     1027                         *           B0V=1 (contextB field is valid)
     1028                         * ContextA A2: EBD=1 (deallocate buffers inside FMan)
     1029                         * ContextB B0(ASPID): 0 (absolute Virtual Storage ID)
     1030                         */
     1031                                qm_fqd_context_a_set64(&initfq.fqd,
     1032                                                       0x1e00000080000000ULL);
     1033                        }
     1034                }
     1035
     1036                /* Put all the ingress queues in our "ingress CGR". */
     1037                if (priv->use_ingress_cgr &&
     1038                    (dpaa_fq->fq_type == FQ_TYPE_RX_DEFAULT ||
     1039                     dpaa_fq->fq_type == FQ_TYPE_RX_ERROR)) {
     1040                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_CGID);
     1041                        initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_CGE);
     1042                        initfq.fqd.cgid = (u8)priv->ingress_cgr.cgrid;
     1043                        /* Set a fixed overhead accounting, just like for the
     1044                         * egress CGR.
     1045                         */
     1046                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_OAC);
     1047                        qm_fqd_set_oac(&initfq.fqd, QM_OAC_CG);
     1048                        qm_fqd_set_oal(&initfq.fqd,
     1049#ifndef __rtems__
     1050                                       min(sizeof(struct sk_buff) +
     1051#else /* __rtems__ */
     1052                                       min(
     1053#endif /* __rtems__ */
     1054                                       priv->tx_headroom,
     1055                                       (size_t)FSL_QMAN_MAX_OAL));
     1056                }
     1057
     1058                /* Initialization common to all ingress queues */
     1059                if (dpaa_fq->flags & QMAN_FQ_FLAG_NO_ENQUEUE) {
     1060                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_CONTEXTA);
     1061                        initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_HOLDACTIVE);
     1062                        initfq.fqd.context_a.stashing.exclusive =
     1063                                QM_STASHING_EXCL_DATA | QM_STASHING_EXCL_CTX |
     1064                                QM_STASHING_EXCL_ANNOTATION;
     1065                        qm_fqd_set_stashing(&initfq.fqd, 1, 2,
     1066                                            DIV_ROUND_UP(sizeof(struct qman_fq),
     1067                                                         64));
     1068                }
     1069
     1070                err = qman_init_fq(fq, QMAN_INITFQ_FLAG_SCHED, &initfq);
     1071                if (err < 0) {
     1072#ifndef __rtems__
     1073                        dev_err(dev, "qman_init_fq(%u) = %d\n",
     1074                                qman_fq_fqid(fq), err);
     1075#else /* __rtems__ */
     1076                        BSD_ASSERT(0);
     1077#endif /* __rtems__ */
     1078                        qman_destroy_fq(fq);
     1079                        return err;
     1080                }
     1081        }
     1082
     1083        dpaa_fq->fqid = qman_fq_fqid(fq);
     1084
     1085        return 0;
     1086}
     1087
     1088#ifndef __rtems__
     1089static int dpaa_fq_free_entry(struct device *dev, struct qman_fq *fq)
     1090{
     1091#ifndef __rtems__
     1092        const struct dpaa_priv  *priv;
     1093#endif /* __rtems__ */
     1094        struct dpaa_fq *dpaa_fq;
     1095        int err, error;
     1096
     1097        err = 0;
     1098
     1099        dpaa_fq = container_of(fq, struct dpaa_fq, fq_base);
     1100#ifndef __rtems__
     1101        priv = netdev_priv(dpaa_fq->net_dev);
     1102#endif /* __rtems__ */
     1103
     1104        if (dpaa_fq->init) {
     1105                err = qman_retire_fq(fq, NULL);
     1106                if (err < 0 && netif_msg_drv(priv))
     1107                        dev_err(dev, "qman_retire_fq(%u) = %d\n",
     1108                                qman_fq_fqid(fq), err);
     1109
     1110                error = qman_oos_fq(fq);
     1111                if (error < 0 && netif_msg_drv(priv)) {
     1112                        dev_err(dev, "qman_oos_fq(%u) = %d\n",
     1113                                qman_fq_fqid(fq), error);
     1114                        if (err >= 0)
     1115                                err = error;
     1116                }
     1117        }
     1118
     1119        qman_destroy_fq(fq);
     1120        list_del(&dpaa_fq->list);
     1121
     1122        return err;
     1123}
     1124
     1125static int dpaa_fq_free(struct device *dev, struct list_head *list)
     1126{
     1127        struct dpaa_fq *dpaa_fq, *tmp;
     1128        int err, error;
     1129
     1130        err = 0;
     1131        list_for_each_entry_safe(dpaa_fq, tmp, list, list) {
     1132                error = dpaa_fq_free_entry(dev, (struct qman_fq *)dpaa_fq);
     1133                if (error < 0 && err >= 0)
     1134                        err = error;
     1135        }
     1136
     1137        return err;
     1138}
     1139#endif /* __rtems__ */
     1140
     1141static void dpaa_eth_init_tx_port(struct fman_port *port, struct dpaa_fq *errq,
     1142                                  struct dpaa_fq *defq,
     1143                                  struct dpaa_buffer_layout *buf_layout)
     1144{
     1145        struct fman_buffer_prefix_content buf_prefix_content;
     1146        struct fman_port_params params;
     1147        int err;
     1148
     1149        memset(&params, 0, sizeof(params));
     1150        memset(&buf_prefix_content, 0, sizeof(buf_prefix_content));
     1151
     1152        buf_prefix_content.priv_data_size = buf_layout->priv_data_size;
     1153        buf_prefix_content.pass_prs_result = true;
     1154        buf_prefix_content.pass_hash_result = true;
     1155        buf_prefix_content.pass_time_stamp = false;
     1156        buf_prefix_content.data_align = DPAA_FD_DATA_ALIGNMENT;
     1157
     1158        params.specific_params.non_rx_params.err_fqid = errq->fqid;
     1159        params.specific_params.non_rx_params.dflt_fqid = defq->fqid;
     1160
     1161        err = fman_port_config(port, &params);
     1162        if (err)
     1163                pr_err("%s: fman_port_config failed\n", __func__);
     1164
     1165        err = fman_port_cfg_buf_prefix_content(port, &buf_prefix_content);
     1166        if (err)
     1167                pr_err("%s: fman_port_cfg_buf_prefix_content failed\n",
     1168                       __func__);
     1169
     1170        err = fman_port_init(port);
     1171        if (err)
     1172                pr_err("%s: fm_port_init failed\n", __func__);
     1173}
     1174
     1175static void dpaa_eth_init_rx_port(struct fman_port *port, struct dpaa_bp **bps,
     1176                                  size_t count, struct dpaa_fq *errq,
     1177                                  struct dpaa_fq *defq,
     1178                                  struct dpaa_buffer_layout *buf_layout)
     1179{
     1180        struct fman_buffer_prefix_content buf_prefix_content;
     1181        struct fman_port_rx_params *rx_p;
     1182        struct fman_port_params params;
     1183        int i, err;
     1184
     1185        memset(&params, 0, sizeof(params));
     1186        memset(&buf_prefix_content, 0, sizeof(buf_prefix_content));
     1187
     1188        buf_prefix_content.priv_data_size = buf_layout->priv_data_size;
     1189        buf_prefix_content.pass_prs_result = true;
     1190        buf_prefix_content.pass_hash_result = true;
     1191        buf_prefix_content.pass_time_stamp = false;
     1192        buf_prefix_content.data_align = DPAA_FD_DATA_ALIGNMENT;
     1193
     1194        rx_p = &params.specific_params.rx_params;
     1195        rx_p->err_fqid = errq->fqid;
     1196        rx_p->dflt_fqid = defq->fqid;
     1197
     1198        count = min(ARRAY_SIZE(rx_p->ext_buf_pools.ext_buf_pool), count);
     1199        rx_p->ext_buf_pools.num_of_pools_used = (u8)count;
     1200        for (i = 0; i < count; i++) {
     1201                rx_p->ext_buf_pools.ext_buf_pool[i].id =  bps[i]->bpid;
     1202                rx_p->ext_buf_pools.ext_buf_pool[i].size = (u16)bps[i]->size;
     1203        }
     1204
     1205        err = fman_port_config(port, &params);
     1206        if (err)
     1207                pr_err("%s: fman_port_config failed\n", __func__);
     1208
     1209        err = fman_port_cfg_buf_prefix_content(port, &buf_prefix_content);
     1210        if (err)
     1211                pr_err("%s: fman_port_cfg_buf_prefix_content failed\n",
     1212                       __func__);
     1213
     1214        err = fman_port_init(port);
     1215        if (err)
     1216                pr_err("%s: fm_port_init failed\n", __func__);
     1217}
     1218
     1219static void dpaa_eth_init_ports(struct mac_device *mac_dev,
     1220                                struct dpaa_bp **bps, size_t count,
     1221                                struct fm_port_fqs *port_fqs,
     1222                                struct dpaa_buffer_layout *buf_layout,
     1223                                struct device *dev)
     1224{
     1225        struct fman_port *rxport = mac_dev->port[RX];
     1226        struct fman_port *txport = mac_dev->port[TX];
     1227
     1228        dpaa_eth_init_tx_port(txport, port_fqs->tx_errq,
     1229                              port_fqs->tx_defq, &buf_layout[TX]);
     1230        dpaa_eth_init_rx_port(rxport, bps, count, port_fqs->rx_errq,
     1231                              port_fqs->rx_defq, &buf_layout[RX]);
     1232}
     1233
     1234static int dpaa_bman_release(const struct dpaa_bp *dpaa_bp,
     1235                             struct bm_buffer *bmb, int cnt)
     1236{
     1237        int err;
     1238
     1239        err = bman_release(dpaa_bp->pool, bmb, cnt);
     1240        /* Should never occur, address anyway to avoid leaking the buffers */
     1241        if (unlikely(WARN_ON(err)) && dpaa_bp->free_buf_cb)
     1242                while (cnt-- > 0)
     1243                        dpaa_bp->free_buf_cb(dpaa_bp, &bmb[cnt]);
     1244
     1245        return cnt;
     1246}
     1247
     1248static void dpaa_release_sgt_members(struct qm_sg_entry *sgt)
     1249{
     1250        struct bm_buffer bmb[DPAA_BUFF_RELEASE_MAX];
     1251        struct dpaa_bp *dpaa_bp;
     1252        int i = 0, j;
     1253
     1254        memset(bmb, 0, sizeof(bmb));
     1255
     1256        do {
     1257                dpaa_bp = dpaa_bpid2pool(sgt[i].bpid);
     1258                if (!dpaa_bp)
     1259                        return;
     1260
     1261                j = 0;
     1262                do {
     1263                        WARN_ON(qm_sg_entry_is_ext(&sgt[i]));
     1264
     1265                        bm_buffer_set64(&bmb[j], qm_sg_entry_get64(&sgt[i]));
     1266
     1267                        j++; i++;
     1268                } while (j < ARRAY_SIZE(bmb) &&
     1269                                !qm_sg_entry_is_final(&sgt[i - 1]) &&
     1270                                sgt[i - 1].bpid == sgt[i].bpid);
     1271
     1272                dpaa_bman_release(dpaa_bp, bmb, j);
     1273        } while (!qm_sg_entry_is_final(&sgt[i - 1]));
     1274}
     1275
     1276static void dpaa_fd_release(const struct net_device *net_dev,
     1277                            const struct qm_fd *fd)
     1278{
     1279        struct qm_sg_entry *sgt;
     1280        struct dpaa_bp *dpaa_bp;
     1281        struct bm_buffer bmb;
     1282        dma_addr_t addr;
     1283        void *vaddr;
     1284
     1285        bmb.data = 0;
     1286        bm_buffer_set64(&bmb, qm_fd_addr(fd));
     1287
     1288        dpaa_bp = dpaa_bpid2pool(fd->bpid);
     1289        if (!dpaa_bp)
     1290                return;
     1291
     1292        if (qm_fd_get_format(fd) == qm_fd_sg) {
     1293                vaddr = phys_to_virt(qm_fd_addr(fd));
     1294                sgt = vaddr + qm_fd_get_offset(fd);
     1295
     1296#ifndef __rtems__
     1297                dma_unmap_single(dpaa_bp->dev, qm_fd_addr(fd), dpaa_bp->size,
     1298                                 DMA_FROM_DEVICE);
     1299#endif /* __rtems__ */
     1300
     1301                dpaa_release_sgt_members(sgt);
     1302
     1303#ifndef __rtems__
     1304                addr = dma_map_single(dpaa_bp->dev, vaddr, dpaa_bp->size,
     1305                                      DMA_FROM_DEVICE);
     1306                if (dma_mapping_error(dpaa_bp->dev, addr)) {
     1307                        dev_err(dpaa_bp->dev, "DMA mapping failed");
     1308                        return;
     1309                }
     1310#else /* __rtems__ */
     1311                addr = (dma_addr_t)vaddr;
     1312#endif /* __rtems__ */
     1313                bm_buffer_set64(&bmb, addr);
     1314        }
     1315
     1316        dpaa_bman_release(dpaa_bp, &bmb, 1);
     1317}
     1318
     1319static void count_ern(struct dpaa_percpu_priv *percpu_priv,
     1320                      const union qm_mr_entry *msg)
     1321{
     1322        switch (msg->ern.rc & QM_MR_RC_MASK) {
     1323        case QM_MR_RC_CGR_TAILDROP:
     1324                percpu_priv->ern_cnt.cg_tdrop++;
     1325                break;
     1326        case QM_MR_RC_WRED:
     1327                percpu_priv->ern_cnt.wred++;
     1328                break;
     1329        case QM_MR_RC_ERROR:
     1330                percpu_priv->ern_cnt.err_cond++;
     1331                break;
     1332        case QM_MR_RC_ORPWINDOW_EARLY:
     1333                percpu_priv->ern_cnt.early_window++;
     1334                break;
     1335        case QM_MR_RC_ORPWINDOW_LATE:
     1336                percpu_priv->ern_cnt.late_window++;
     1337                break;
     1338        case QM_MR_RC_FQ_TAILDROP:
     1339                percpu_priv->ern_cnt.fq_tdrop++;
     1340                break;
     1341        case QM_MR_RC_ORPWINDOW_RETIRED:
     1342                percpu_priv->ern_cnt.fq_retired++;
     1343                break;
     1344        case QM_MR_RC_ORP_ZERO:
     1345                percpu_priv->ern_cnt.orp_zero++;
     1346                break;
     1347        }
     1348}
     1349
     1350#ifndef __rtems__
     1351/* Turn on HW checksum computation for this outgoing frame.
     1352 * If the current protocol is not something we support in this regard
     1353 * (or if the stack has already computed the SW checksum), we do nothing.
     1354 *
     1355 * Returns 0 if all goes well (or HW csum doesn't apply), and a negative value
     1356 * otherwise.
     1357 *
     1358 * Note that this function may modify the fd->cmd field and the skb data buffer
     1359 * (the Parse Results area).
     1360 */
     1361static int dpaa_enable_tx_csum(struct dpaa_priv *priv,
     1362                               struct sk_buff *skb,
     1363                               struct qm_fd *fd,
     1364                               char *parse_results)
     1365{
     1366        struct fman_prs_result *parse_result;
     1367        u16 ethertype = ntohs(skb->protocol);
     1368        struct ipv6hdr *ipv6h = NULL;
     1369        struct iphdr *iph;
     1370        int retval = 0;
     1371        u8 l4_proto;
     1372
     1373        if (skb->ip_summed != CHECKSUM_PARTIAL)
     1374                return 0;
     1375
     1376        /* Note: L3 csum seems to be already computed in sw, but we can't choose
     1377         * L4 alone from the FM configuration anyway.
     1378         */
     1379
     1380        /* Fill in some fields of the Parse Results array, so the FMan
     1381         * can find them as if they came from the FMan Parser.
     1382         */
     1383        parse_result = (struct fman_prs_result *)parse_results;
     1384
     1385        /* If we're dealing with VLAN, get the real Ethernet type */
     1386        if (ethertype == ETH_P_8021Q) {
     1387                /* We can't always assume the MAC header is set correctly
     1388                 * by the stack, so reset to beginning of skb->data
     1389                 */
     1390                skb_reset_mac_header(skb);
     1391                ethertype = ntohs(vlan_eth_hdr(skb)->h_vlan_encapsulated_proto);
     1392        }
     1393
     1394        /* Fill in the relevant L3 parse result fields
     1395         * and read the L4 protocol type
     1396         */
     1397        switch (ethertype) {
     1398        case ETH_P_IP:
     1399                parse_result->l3r = cpu_to_be16(FM_L3_PARSE_RESULT_IPV4);
     1400                iph = ip_hdr(skb);
     1401                WARN_ON(!iph);
     1402                l4_proto = iph->protocol;
     1403                break;
     1404        case ETH_P_IPV6:
     1405                parse_result->l3r = cpu_to_be16(FM_L3_PARSE_RESULT_IPV6);
     1406                ipv6h = ipv6_hdr(skb);
     1407                WARN_ON(!ipv6h);
     1408                l4_proto = ipv6h->nexthdr;
     1409                break;
     1410        default:
     1411                /* We shouldn't even be here */
     1412                if (net_ratelimit())
     1413                        netif_alert(priv, tx_err, priv->net_dev,
     1414                                    "Can't compute HW csum for L3 proto 0x%x\n",
     1415                                    ntohs(skb->protocol));
     1416                retval = -EIO;
     1417                goto return_error;
     1418        }
     1419
     1420        /* Fill in the relevant L4 parse result fields */
     1421        switch (l4_proto) {
     1422        case IPPROTO_UDP:
     1423                parse_result->l4r = FM_L4_PARSE_RESULT_UDP;
     1424                break;
     1425        case IPPROTO_TCP:
     1426                parse_result->l4r = FM_L4_PARSE_RESULT_TCP;
     1427                break;
     1428        default:
     1429                if (net_ratelimit())
     1430                        netif_alert(priv, tx_err, priv->net_dev,
     1431                                    "Can't compute HW csum for L4 proto 0x%x\n",
     1432                                    l4_proto);
     1433                retval = -EIO;
     1434                goto return_error;
     1435        }
     1436
     1437        /* At index 0 is IPOffset_1 as defined in the Parse Results */
     1438        parse_result->ip_off[0] = (u8)skb_network_offset(skb);
     1439        parse_result->l4_off = (u8)skb_transport_offset(skb);
     1440
     1441        /* Enable L3 (and L4, if TCP or UDP) HW checksum. */
     1442        fd->cmd |= cpu_to_be32(FM_FD_CMD_RPD | FM_FD_CMD_DTC);
     1443
     1444        /* On P1023 and similar platforms fd->cmd interpretation could
     1445         * be disabled by setting CONTEXT_A bit ICMD; currently this bit
     1446         * is not set so we do not need to check; in the future, if/when
     1447         * using context_a we need to check this bit
     1448         */
     1449
     1450return_error:
     1451        return retval;
     1452}
     1453#endif /* __rtems__ */
     1454
     1455static int dpaa_bp_add_8_bufs(const struct dpaa_bp *dpaa_bp)
     1456{
     1457#ifndef __rtems__
     1458        struct device *dev = dpaa_bp->dev;
     1459#endif /* __rtems__ */
     1460        struct bm_buffer bmb[8];
     1461        dma_addr_t addr;
     1462#ifndef __rtems__
     1463        void *new_buf;
     1464#endif /* __rtems__ */
     1465        u8 i;
     1466
     1467        for (i = 0; i < 8; i++) {
     1468#ifndef __rtems__
     1469                new_buf = netdev_alloc_frag(dpaa_bp->raw_size);
     1470                if (unlikely(!new_buf)) {
     1471                        dev_err(dev, "netdev_alloc_frag() failed, size %zu\n",
     1472                                dpaa_bp->raw_size);
     1473                        goto release_previous_buffs;
     1474                }
     1475                new_buf = PTR_ALIGN(new_buf, SMP_CACHE_BYTES);
     1476
     1477                addr = dma_map_single(dev, new_buf,
     1478                                      dpaa_bp->size, DMA_FROM_DEVICE);
     1479                if (unlikely(dma_mapping_error(dev, addr))) {
     1480                        dev_err(dpaa_bp->dev, "DMA map failed");
     1481                        goto release_previous_buffs;
     1482                }
     1483#else /* __rtems__ */
     1484                struct mbuf *m;
     1485
     1486                m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
     1487                if (unlikely(m == NULL)) {
     1488                        goto release_previous_buffs;
     1489                }
     1490
     1491                RTEMS_STATIC_ASSERT(DPAA_BP_RAW_SIZE == MCLBYTES,
     1492                    DPAA_BP_RAW_SIZE);
     1493                *(struct mbuf **)(mtod(m, char *) + DPAA_MBUF_POINTER_OFFSET) =
     1494                    m;
     1495                addr = mtod(m, dma_addr_t);
     1496#endif /* __rtems__ */
     1497
     1498                bmb[i].data = 0;
     1499                bm_buffer_set64(&bmb[i], addr);
     1500        }
     1501
     1502release_bufs:
     1503        return dpaa_bman_release(dpaa_bp, bmb, i);
     1504
     1505release_previous_buffs:
     1506#ifndef __rtems__
     1507        WARN_ONCE(1, "dpaa_eth: failed to add buffers on Rx\n");
     1508#endif /* __rtems__ */
     1509
     1510        bm_buffer_set64(&bmb[i], 0);
     1511        /* Avoid releasing a completely null buffer; bman_release() requires
     1512         * at least one buffer.
     1513         */
     1514        if (likely(i))
     1515                goto release_bufs;
     1516
     1517        return 0;
     1518}
     1519
     1520static int dpaa_bp_seed(struct dpaa_bp *dpaa_bp)
     1521{
     1522        int i;
     1523
     1524        /* Give each CPU an allotment of "config_count" buffers */
     1525        for_each_possible_cpu(i) {
     1526                int *count_ptr = per_cpu_ptr(dpaa_bp->percpu_count, i);
     1527                int j;
     1528
     1529                /* Although we access another CPU's counters here
     1530                 * we do it at boot time so it is safe
     1531                 */
     1532                for (j = 0; j < dpaa_bp->config_count; j += 8)
     1533                        *count_ptr += dpaa_bp_add_8_bufs(dpaa_bp);
     1534        }
     1535        return 0;
     1536}
     1537
     1538/* Add buffers/(pages) for Rx processing whenever bpool count falls below
     1539 * REFILL_THRESHOLD.
     1540 */
     1541static int dpaa_eth_refill_bpool(struct dpaa_bp *dpaa_bp, int *countptr)
     1542{
     1543        int count = *countptr;
     1544        int new_bufs;
     1545
     1546        if (unlikely(count < FSL_DPAA_ETH_REFILL_THRESHOLD)) {
     1547                do {
     1548                        new_bufs = dpaa_bp_add_8_bufs(dpaa_bp);
     1549                        if (unlikely(!new_bufs)) {
     1550                                /* Avoid looping forever if we've temporarily
     1551                                 * run out of memory. We'll try again at the
     1552                                 * next NAPI cycle.
     1553                                 */
     1554                                break;
     1555                        }
     1556                        count += new_bufs;
     1557                } while (count < FSL_DPAA_ETH_MAX_BUF_COUNT);
     1558
     1559                *countptr = count;
     1560                if (unlikely(count < FSL_DPAA_ETH_MAX_BUF_COUNT))
     1561                        return -ENOMEM;
     1562        }
     1563
     1564        return 0;
     1565}
     1566
     1567static int dpaa_eth_refill_bpools(struct dpaa_priv *priv)
     1568{
     1569        struct dpaa_bp *dpaa_bp;
     1570        int *countptr;
     1571        int res, i;
     1572
     1573        for (i = 0; i < DPAA_BPS_NUM; i++) {
     1574                dpaa_bp = priv->dpaa_bps[i];
     1575                if (!dpaa_bp)
     1576                        return -EINVAL;
     1577                countptr = this_cpu_ptr(dpaa_bp->percpu_count);
     1578                res  = dpaa_eth_refill_bpool(dpaa_bp, countptr);
     1579                if (res)
     1580                        return res;
     1581        }
     1582        return 0;
     1583}
     1584
     1585#ifndef __rtems__
     1586/* Cleanup function for outgoing frame descriptors that were built on Tx path,
     1587 * either contiguous frames or scatter/gather ones.
     1588 * Skb freeing is not handled here.
     1589 *
     1590 * This function may be called on error paths in the Tx function, so guard
     1591 * against cases when not all fd relevant fields were filled in.
     1592 *
     1593 * Return the skb backpointer, since for S/G frames the buffer containing it
     1594 * gets freed here.
     1595 */
     1596static struct sk_buff *dpaa_cleanup_tx_fd(const struct dpaa_priv *priv,
     1597                                          const struct qm_fd *fd)
     1598{
     1599        const enum dma_data_direction dma_dir = DMA_TO_DEVICE;
     1600        struct device *dev = priv->net_dev->dev.parent;
     1601        dma_addr_t addr = qm_fd_addr(fd);
     1602        const struct qm_sg_entry *sgt;
     1603        struct sk_buff **skbh, *skb;
     1604        int nr_frags, i;
     1605
     1606        skbh = (struct sk_buff **)phys_to_virt(addr);
     1607        skb = *skbh;
     1608
     1609        if (unlikely(qm_fd_get_format(fd) == qm_fd_sg)) {
     1610                nr_frags = skb_shinfo(skb)->nr_frags;
     1611                dma_unmap_single(dev, addr, qm_fd_get_offset(fd) +
     1612                                 sizeof(struct qm_sg_entry) * (1 + nr_frags),
     1613                                 dma_dir);
     1614
     1615                /* The sgt buffer has been allocated with netdev_alloc_frag(),
     1616                 * it's from lowmem.
     1617                 */
     1618                sgt = phys_to_virt(addr + qm_fd_get_offset(fd));
     1619
     1620                /* sgt[0] is from lowmem, was dma_map_single()-ed */
     1621                dma_unmap_single(dev, qm_sg_addr(&sgt[0]),
     1622                                 qm_sg_entry_get_len(&sgt[0]), dma_dir);
     1623
     1624                /* remaining pages were mapped with skb_frag_dma_map() */
     1625                for (i = 1; i < nr_frags; i++) {
     1626                        WARN_ON(qm_sg_entry_is_ext(&sgt[i]));
     1627
     1628                        dma_unmap_page(dev, qm_sg_addr(&sgt[i]),
     1629                                       qm_sg_entry_get_len(&sgt[i]), dma_dir);
     1630                }
     1631
     1632                /* Free the page frag that we allocated on Tx */
     1633                skb_free_frag(phys_to_virt(addr));
     1634        } else {
     1635                dma_unmap_single(dev, addr,
     1636                                 skb_tail_pointer(skb) - (u8 *)skbh, dma_dir);
     1637        }
     1638
     1639        return skb;
     1640}
     1641
     1642/* Build a linear skb around the received buffer.
     1643 * We are guaranteed there is enough room at the end of the data buffer to
     1644 * accommodate the shared info area of the skb.
     1645 */
     1646static struct sk_buff *contig_fd_to_skb(const struct dpaa_priv *priv,
     1647                                        const struct qm_fd *fd)
     1648{
     1649        ssize_t fd_off = qm_fd_get_offset(fd);
     1650        dma_addr_t addr = qm_fd_addr(fd);
     1651        struct dpaa_bp *dpaa_bp;
     1652        struct sk_buff *skb;
     1653        void *vaddr;
     1654
     1655        vaddr = phys_to_virt(addr);
     1656        WARN_ON(!IS_ALIGNED((unsigned long)vaddr, SMP_CACHE_BYTES));
     1657
     1658        dpaa_bp = dpaa_bpid2pool(fd->bpid);
     1659        if (!dpaa_bp)
     1660                goto free_buffer;
     1661
     1662        skb = build_skb(vaddr, dpaa_bp->size +
     1663                        SKB_DATA_ALIGN(sizeof(struct skb_shared_info)));
     1664        if (unlikely(!skb)) {
     1665                WARN_ONCE(1, "Build skb failure on Rx\n");
     1666                goto free_buffer;
     1667        }
     1668        WARN_ON(fd_off != priv->rx_headroom);
     1669        skb_reserve(skb, fd_off);
     1670        skb_put(skb, qm_fd_get_length(fd));
     1671
     1672        skb->ip_summed = CHECKSUM_NONE;
     1673
     1674        return skb;
     1675
     1676free_buffer:
     1677        skb_free_frag(vaddr);
     1678        return NULL;
     1679}
     1680
     1681/* Build an skb with the data of the first S/G entry in the linear portion and
     1682 * the rest of the frame as skb fragments.
     1683 *
     1684 * The page fragment holding the S/G Table is recycled here.
     1685 */
     1686static struct sk_buff *sg_fd_to_skb(const struct dpaa_priv *priv,
     1687                                    const struct qm_fd *fd)
     1688{
     1689        ssize_t fd_off = qm_fd_get_offset(fd);
     1690        dma_addr_t addr = qm_fd_addr(fd);
     1691        const struct qm_sg_entry *sgt;
     1692        struct page *page, *head_page;
     1693        struct dpaa_bp *dpaa_bp;
     1694        void *vaddr, *sg_vaddr;
     1695        int frag_off, frag_len;
     1696        struct sk_buff *skb;
     1697        dma_addr_t sg_addr;
     1698        int page_offset;
     1699        unsigned int sz;
     1700        int *count_ptr;
     1701        int i;
     1702
     1703        vaddr = phys_to_virt(addr);
     1704        WARN_ON(!IS_ALIGNED((unsigned long)vaddr, SMP_CACHE_BYTES));
     1705
     1706        /* Iterate through the SGT entries and add data buffers to the skb */
     1707        sgt = vaddr + fd_off;
     1708        for (i = 0; i < DPAA_SGT_MAX_ENTRIES; i++) {
     1709                /* Extension bit is not supported */
     1710                WARN_ON(qm_sg_entry_is_ext(&sgt[i]));
     1711
     1712                sg_addr = qm_sg_addr(&sgt[i]);
     1713                sg_vaddr = phys_to_virt(sg_addr);
     1714                WARN_ON(!IS_ALIGNED((unsigned long)sg_vaddr,
     1715                                    SMP_CACHE_BYTES));
     1716
     1717                /* We may use multiple Rx pools */
     1718                dpaa_bp = dpaa_bpid2pool(sgt[i].bpid);
     1719                if (!dpaa_bp)
     1720                        goto free_buffers;
     1721
     1722                count_ptr = this_cpu_ptr(dpaa_bp->percpu_count);
     1723                dma_unmap_single(dpaa_bp->dev, sg_addr, dpaa_bp->size,
     1724                                 DMA_FROM_DEVICE);
     1725                if (i == 0) {
     1726                        sz = dpaa_bp->size +
     1727                                SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
     1728                        skb = build_skb(sg_vaddr, sz);
     1729                        if (WARN_ON(unlikely(!skb)))
     1730                                goto free_buffers;
     1731
     1732                        skb->ip_summed = CHECKSUM_NONE;
     1733
     1734                        /* Make sure forwarded skbs will have enough space
     1735                         * on Tx, if extra headers are added.
     1736                         */
     1737                        WARN_ON(fd_off != priv->rx_headroom);
     1738                        skb_reserve(skb, fd_off);
     1739                        skb_put(skb, qm_sg_entry_get_len(&sgt[i]));
     1740                } else {
     1741                        /* Not the first S/G entry; all data from buffer will
     1742                         * be added in an skb fragment; fragment index is offset
     1743                         * by one since first S/G entry was incorporated in the
     1744                         * linear part of the skb.
     1745                         *
     1746                         * Caution: 'page' may be a tail page.
     1747                         */
     1748                        page = virt_to_page(sg_vaddr);
     1749                        head_page = virt_to_head_page(sg_vaddr);
     1750
     1751                        /* Compute offset in (possibly tail) page */
     1752                        page_offset = ((unsigned long)sg_vaddr &
     1753                                        (PAGE_SIZE - 1)) +
     1754                                (page_address(page) - page_address(head_page));
     1755                        /* page_offset only refers to the beginning of sgt[i];
     1756                         * but the buffer itself may have an internal offset.
     1757                         */
     1758                        frag_off = qm_sg_entry_get_off(&sgt[i]) + page_offset;
     1759                        frag_len = qm_sg_entry_get_len(&sgt[i]);
     1760                        /* skb_add_rx_frag() does no checking on the page; if
     1761                         * we pass it a tail page, we'll end up with
     1762                         * bad page accounting and eventually with segafults.
     1763                         */
     1764                        skb_add_rx_frag(skb, i - 1, head_page, frag_off,
     1765                                        frag_len, dpaa_bp->size);
     1766                }
     1767                /* Update the pool count for the current {cpu x bpool} */
     1768                (*count_ptr)--;
     1769
     1770                if (qm_sg_entry_is_final(&sgt[i]))
     1771                        break;
     1772        }
     1773        WARN_ONCE(i == DPAA_SGT_MAX_ENTRIES, "No final bit on SGT\n");
     1774
     1775        /* free the SG table buffer */
     1776        skb_free_frag(vaddr);
     1777
     1778        return skb;
     1779
     1780free_buffers:
     1781        /* compensate sw bpool counter changes */
     1782        for (i--; i >= 0; i--) {
     1783                dpaa_bp = dpaa_bpid2pool(sgt[i].bpid);
     1784                if (dpaa_bp) {
     1785                        count_ptr = this_cpu_ptr(dpaa_bp->percpu_count);
     1786                        (*count_ptr)++;
     1787                }
     1788        }
     1789        /* free all the SG entries */
     1790        for (i = 0; i < DPAA_SGT_MAX_ENTRIES ; i++) {
     1791                sg_addr = qm_sg_addr(&sgt[i]);
     1792                sg_vaddr = phys_to_virt(sg_addr);
     1793                skb_free_frag(sg_vaddr);
     1794                dpaa_bp = dpaa_bpid2pool(sgt[i].bpid);
     1795                if (dpaa_bp) {
     1796                        count_ptr = this_cpu_ptr(dpaa_bp->percpu_count);
     1797                        (*count_ptr)--;
     1798                }
     1799
     1800                if (qm_sg_entry_is_final(&sgt[i]))
     1801                        break;
     1802        }
     1803        /* free the SGT fragment */
     1804        skb_free_frag(vaddr);
     1805
     1806        return NULL;
     1807}
     1808
     1809static int skb_to_contig_fd(struct dpaa_priv *priv,
     1810                            struct sk_buff *skb, struct qm_fd *fd,
     1811                            int *offset)
     1812{
     1813        struct net_device *net_dev = priv->net_dev;
     1814        struct device *dev = net_dev->dev.parent;
     1815        enum dma_data_direction dma_dir;
     1816        unsigned char *buffer_start;
     1817        struct sk_buff **skbh;
     1818        dma_addr_t addr;
     1819        int err;
     1820
     1821        /* We are guaranteed to have at least tx_headroom bytes
     1822         * available, so just use that for offset.
     1823         */
     1824        fd->bpid = FSL_DPAA_BPID_INV;
     1825        buffer_start = skb->data - priv->tx_headroom;
     1826        dma_dir = DMA_TO_DEVICE;
     1827
     1828        skbh = (struct sk_buff **)buffer_start;
     1829        *skbh = skb;
     1830
     1831        /* Enable L3/L4 hardware checksum computation.
     1832         *
     1833         * We must do this before dma_map_single(DMA_TO_DEVICE), because we may
     1834         * need to write into the skb.
     1835         */
     1836        err = dpaa_enable_tx_csum(priv, skb, fd,
     1837                                  ((char *)skbh) + DPAA_TX_PRIV_DATA_SIZE);
     1838        if (unlikely(err < 0)) {
     1839                if (net_ratelimit())
     1840                        netif_err(priv, tx_err, net_dev, "HW csum error: %d\n",
     1841                                  err);
     1842                return err;
     1843        }
     1844
     1845        /* Fill in the rest of the FD fields */
     1846        qm_fd_set_contig(fd, priv->tx_headroom, skb->len);
     1847        fd->cmd |= cpu_to_be32(FM_FD_CMD_FCO);
     1848
     1849        /* Map the entire buffer size that may be seen by FMan, but no more */
     1850        addr = dma_map_single(dev, skbh,
     1851                              skb_tail_pointer(skb) - buffer_start, dma_dir);
     1852        if (unlikely(dma_mapping_error(dev, addr))) {
     1853                if (net_ratelimit())
     1854                        netif_err(priv, tx_err, net_dev, "dma_map_single() failed\n");
     1855                return -EINVAL;
     1856        }
     1857        qm_fd_addr_set64(fd, addr);
     1858
     1859        return 0;
     1860}
     1861
     1862static int skb_to_sg_fd(struct dpaa_priv *priv,
     1863                        struct sk_buff *skb, struct qm_fd *fd)
     1864{
     1865        const enum dma_data_direction dma_dir = DMA_TO_DEVICE;
     1866        const int nr_frags = skb_shinfo(skb)->nr_frags;
     1867        struct net_device *net_dev = priv->net_dev;
     1868        struct device *dev = net_dev->dev.parent;
     1869        struct qm_sg_entry *sgt;
     1870        struct sk_buff **skbh;
     1871        int i, j, err, sz;
     1872        void *buffer_start;
     1873        skb_frag_t *frag;
     1874        dma_addr_t addr;
     1875        size_t frag_len;
     1876        void *sgt_buf;
     1877
     1878        /* get a page frag to store the SGTable */
     1879        sz = SKB_DATA_ALIGN(priv->tx_headroom +
     1880                sizeof(struct qm_sg_entry) * (1 + nr_frags));
     1881        sgt_buf = netdev_alloc_frag(sz);
     1882        if (unlikely(!sgt_buf)) {
     1883                netdev_err(net_dev, "netdev_alloc_frag() failed for size %d\n",
     1884                           sz);
     1885                return -ENOMEM;
     1886        }
     1887
     1888        /* Enable L3/L4 hardware checksum computation.
     1889         *
     1890         * We must do this before dma_map_single(DMA_TO_DEVICE), because we may
     1891         * need to write into the skb.
     1892         */
     1893        err = dpaa_enable_tx_csum(priv, skb, fd,
     1894                                  sgt_buf + DPAA_TX_PRIV_DATA_SIZE);
     1895        if (unlikely(err < 0)) {
     1896                if (net_ratelimit())
     1897                        netif_err(priv, tx_err, net_dev, "HW csum error: %d\n",
     1898                                  err);
     1899                goto csum_failed;
     1900        }
     1901
     1902        sgt = (struct qm_sg_entry *)(sgt_buf + priv->tx_headroom);
     1903        qm_sg_entry_set_len(&sgt[0], skb_headlen(skb));
     1904        sgt[0].bpid = FSL_DPAA_BPID_INV;
     1905        sgt[0].offset = 0;
     1906        addr = dma_map_single(dev, skb->data,
     1907                              skb_headlen(skb), dma_dir);
     1908        if (unlikely(dma_mapping_error(dev, addr))) {
     1909                dev_err(dev, "DMA mapping failed");
     1910                err = -EINVAL;
     1911                goto sg0_map_failed;
     1912        }
     1913        qm_sg_entry_set64(&sgt[0], addr);
     1914
     1915        /* populate the rest of SGT entries */
     1916        frag = &skb_shinfo(skb)->frags[0];
     1917        frag_len = frag->size;
     1918        for (i = 1; i <= nr_frags; i++, frag++) {
     1919                WARN_ON(!skb_frag_page(frag));
     1920                addr = skb_frag_dma_map(dev, frag, 0,
     1921                                        frag_len, dma_dir);
     1922                if (unlikely(dma_mapping_error(dev, addr))) {
     1923                        dev_err(dev, "DMA mapping failed");
     1924                        err = -EINVAL;
     1925                        goto sg_map_failed;
     1926                }
     1927
     1928                qm_sg_entry_set_len(&sgt[i], frag_len);
     1929                sgt[i].bpid = FSL_DPAA_BPID_INV;
     1930                sgt[i].offset = 0;
     1931
     1932                /* keep the offset in the address */
     1933                qm_sg_entry_set64(&sgt[i], addr);
     1934                frag_len = frag->size;
     1935        }
     1936        qm_sg_entry_set_f(&sgt[i - 1], frag_len);
     1937
     1938        qm_fd_set_sg(fd, priv->tx_headroom, skb->len);
     1939
     1940        /* DMA map the SGT page */
     1941        buffer_start = (void *)sgt - priv->tx_headroom;
     1942        skbh = (struct sk_buff **)buffer_start;
     1943        *skbh = skb;
     1944
     1945        addr = dma_map_single(dev, buffer_start, priv->tx_headroom +
     1946                              sizeof(struct qm_sg_entry) * (1 + nr_frags),
     1947                              dma_dir);
     1948        if (unlikely(dma_mapping_error(dev, addr))) {
     1949                dev_err(dev, "DMA mapping failed");
     1950                err = -EINVAL;
     1951                goto sgt_map_failed;
     1952        }
     1953
     1954        fd->bpid = FSL_DPAA_BPID_INV;
     1955        fd->cmd |= cpu_to_be32(FM_FD_CMD_FCO);
     1956        qm_fd_addr_set64(fd, addr);
     1957
     1958        return 0;
     1959
     1960sgt_map_failed:
     1961sg_map_failed:
     1962        for (j = 0; j < i; j++)
     1963                dma_unmap_page(dev, qm_sg_addr(&sgt[j]),
     1964                               qm_sg_entry_get_len(&sgt[j]), dma_dir);
     1965sg0_map_failed:
     1966csum_failed:
     1967        skb_free_frag(sgt_buf);
     1968
     1969        return err;
     1970}
     1971
     1972static inline int dpaa_xmit(struct dpaa_priv *priv,
     1973                            struct rtnl_link_stats64 *percpu_stats,
     1974                            int queue,
     1975                            struct qm_fd *fd)
     1976{
     1977        struct qman_fq *egress_fq;
     1978        int err, i;
     1979
     1980        egress_fq = priv->egress_fqs[queue];
     1981        if (fd->bpid == FSL_DPAA_BPID_INV)
     1982                fd->cmd |= cpu_to_be32(qman_fq_fqid(priv->conf_fqs[queue]));
     1983
     1984        /* Trace this Tx fd */
     1985        trace_dpaa_tx_fd(priv->net_dev, egress_fq, fd);
     1986
     1987        for (i = 0; i < DPAA_ENQUEUE_RETRIES; i++) {
     1988                err = qman_enqueue(egress_fq, fd);
     1989                if (err != -EBUSY)
     1990                        break;
     1991        }
     1992
     1993        if (unlikely(err < 0)) {
     1994                percpu_stats->tx_errors++;
     1995                percpu_stats->tx_fifo_errors++;
     1996                return err;
     1997        }
     1998
     1999        percpu_stats->tx_packets++;
     2000        percpu_stats->tx_bytes += qm_fd_get_length(fd);
     2001
     2002        return 0;
     2003}
     2004
     2005static int dpaa_start_xmit(struct sk_buff *skb, struct net_device *net_dev)
     2006{
     2007        const int queue_mapping = skb_get_queue_mapping(skb);
     2008        bool nonlinear = skb_is_nonlinear(skb);
     2009        struct rtnl_link_stats64 *percpu_stats;
     2010        struct dpaa_percpu_priv *percpu_priv;
     2011        struct dpaa_priv *priv;
     2012        struct qm_fd fd;
     2013        int offset = 0;
     2014        int err = 0;
     2015
     2016        priv = netdev_priv(net_dev);
     2017        percpu_priv = this_cpu_ptr(priv->percpu_priv);
     2018        percpu_stats = &percpu_priv->stats;
     2019
     2020        qm_fd_clear_fd(&fd);
     2021
     2022        if (!nonlinear) {
     2023                /* We're going to store the skb backpointer at the beginning
     2024                 * of the data buffer, so we need a privately owned skb
     2025                 *
     2026                 * We've made sure skb is not shared in dev->priv_flags,
     2027                 * we need to verify the skb head is not cloned
     2028                 */
     2029                if (skb_cow_head(skb, priv->tx_headroom))
     2030                        goto enomem;
     2031
     2032                WARN_ON(skb_is_nonlinear(skb));
     2033        }
     2034
     2035        /* MAX_SKB_FRAGS is equal or larger than our dpaa_SGT_MAX_ENTRIES;
     2036         * make sure we don't feed FMan with more fragments than it supports.
     2037         */
     2038        if (nonlinear &&
     2039            likely(skb_shinfo(skb)->nr_frags < DPAA_SGT_MAX_ENTRIES)) {
     2040                /* Just create a S/G fd based on the skb */
     2041                err = skb_to_sg_fd(priv, skb, &fd);
     2042                percpu_priv->tx_frag_skbuffs++;
     2043        } else {
     2044                /* If the egress skb contains more fragments than we support
     2045                 * we have no choice but to linearize it ourselves.
     2046                 */
     2047                if (unlikely(nonlinear) && __skb_linearize(skb))
     2048                        goto enomem;
     2049
     2050                /* Finally, create a contig FD from this skb */
     2051                err = skb_to_contig_fd(priv, skb, &fd, &offset);
     2052        }
     2053        if (unlikely(err < 0))
     2054                goto skb_to_fd_failed;
     2055
     2056        if (likely(dpaa_xmit(priv, percpu_stats, queue_mapping, &fd) == 0))
     2057                return NETDEV_TX_OK;
     2058
     2059        dpaa_cleanup_tx_fd(priv, &fd);
     2060skb_to_fd_failed:
     2061enomem:
     2062        percpu_stats->tx_errors++;
     2063        dev_kfree_skb(skb);
     2064        return NETDEV_TX_OK;
     2065}
     2066#endif /* __rtems__ */
     2067
     2068static void dpaa_rx_error(struct net_device *net_dev,
     2069                          const struct dpaa_priv *priv,
     2070                          struct dpaa_percpu_priv *percpu_priv,
    1062071                          const struct qm_fd *fd,
    1072072                          u32 fqid)
    1082073{
    109         /* limit common, possibly innocuous Rx FIFO Overflow errors'
    110          * interference with zero-loss convergence benchmark results.
    111          */
    112         if (likely(fd->status & FM_FD_ERR_PHYSICAL))
    113                 pr_warn_once("non-zero error counters in fman statistics (sysfs)\n");
    114         else
    115 #ifndef __rtems__
    116                 if (net_ratelimit())
    117                         netif_err(priv, hw, net_dev, "Err FD status = 0x%08x\n",
    118                                   fd->status & FM_FD_STAT_RX_ERRORS);
    119 #else /* __rtems__ */
    120                 BSD_ASSERT(0);
    121 #endif /* __rtems__ */
    122 
    123 #ifndef __rtems__
     2074#ifndef __rtems__
     2075        if (net_ratelimit())
     2076                netif_err(priv, hw, net_dev, "Err FD status = 0x%08x\n",
     2077                          be32_to_cpu(fd->status) & FM_FD_STAT_RX_ERRORS);
     2078
    1242079        percpu_priv->stats.rx_errors++;
    1252080#endif /* __rtems__ */
    1262081
    127         if (fd->status & FM_FD_ERR_DMA)
     2082        if (be32_to_cpu(fd->status) & FM_FD_ERR_DMA)
    1282083                percpu_priv->rx_errors.dme++;
    129         if (fd->status & FM_FD_ERR_PHYSICAL)
     2084        if (be32_to_cpu(fd->status) & FM_FD_ERR_PHYSICAL)
    1302085                percpu_priv->rx_errors.fpe++;
    131         if (fd->status & FM_FD_ERR_SIZE)
     2086        if (be32_to_cpu(fd->status) & FM_FD_ERR_SIZE)
    1322087                percpu_priv->rx_errors.fse++;
    133         if (fd->status & FM_FD_ERR_PRS_HDR_ERR)
     2088        if (be32_to_cpu(fd->status) & FM_FD_ERR_PRS_HDR_ERR)
    1342089                percpu_priv->rx_errors.phe++;
    1352090
    136         dpa_fd_release(net_dev, fd);
    137 }
    138 
    139 static void _dpa_tx_error(struct net_device *net_dev,
    140                           const struct dpa_priv_s *priv,
    141                           struct dpa_percpu_priv_s *percpu_priv,
     2091        dpaa_fd_release(net_dev, fd);
     2092}
     2093
     2094static void dpaa_tx_error(struct net_device *net_dev,
     2095                          const struct dpaa_priv *priv,
     2096                          struct dpaa_percpu_priv *percpu_priv,
    1422097                          const struct qm_fd *fd,
    1432098                          u32 fqid)
     
    1482103        if (net_ratelimit())
    1492104                netif_warn(priv, hw, net_dev, "FD status = 0x%08x\n",
    150                            fd->status & FM_FD_STAT_TX_ERRORS);
     2105                           be32_to_cpu(fd->status) & FM_FD_STAT_TX_ERRORS);
    1512106
    1522107        percpu_priv->stats.tx_errors++;
     
    1572112#endif /* __rtems__ */
    1582113
    159         /* If we intended the buffers from this frame to go into the bpools
    160          * when the FMan transmit was done, we need to put it in manually.
    161          */
    162         if (fd->bpid != 0xff) {
    163                 dpa_fd_release(net_dev, fd);
    164                 return;
    165         }
    166 
    167 #ifndef __rtems__
    168         skb = _dpa_cleanup_tx_fd(priv, fd);
     2114#ifndef __rtems__
     2115        skb = dpaa_cleanup_tx_fd(priv, fd);
    1692116        dev_kfree_skb(skb);
    1702117#else /* __rtems__ */
    171         _dpa_cleanup_tx_fd(ifp, fd);
     2118        dpaa_cleanup_tx_fd(ifp, fd);
    1722119#endif /* __rtems__ */
    1732120}
     
    1762123static int dpaa_eth_poll(struct napi_struct *napi, int budget)
    1772124{
    178         struct dpa_napi_portal *np =
    179                         container_of(napi, struct dpa_napi_portal, napi);
     2125        struct dpaa_napi_portal *np =
     2126                        container_of(napi, struct dpaa_napi_portal, napi);
    1802127
    1812128        int cleaned = qman_p_poll_dqrr(np->p, budget);
    1822129
    1832130        if (cleaned < budget) {
    184                 int tmp;
    185 
    186                 napi_complete(napi);
    187                 tmp = qman_p_irqsource_add(np->p, QM_PIRQ_DQRI);
    188                 DPA_ERR_ON(tmp);
     2131                napi_complete_done(napi, cleaned);
     2132                qman_p_irqsource_add(np->p, QM_PIRQ_DQRI);
     2133
     2134        } else if (np->down) {
     2135                qman_p_irqsource_add(np->p, QM_PIRQ_DQRI);
    1892136        }
    1902137
     
    1932140#endif /* __rtems__ */
    1942141
    195 static void _dpa_tx_conf(struct net_device *net_dev,
    196                          const struct dpa_priv_s *priv,
    197                          struct dpa_percpu_priv_s *percpu_priv,
     2142static void dpaa_tx_conf(struct net_device *net_dev,
     2143                         const struct dpaa_priv *priv,
     2144                         struct dpaa_percpu_priv *percpu_priv,
    1982145                         const struct qm_fd *fd,
    1992146                         u32 fqid)
     
    2022149        struct sk_buff  *skb;
    2032150
    204         if (unlikely(fd->status & FM_FD_STAT_TX_ERRORS) != 0) {
     2151        if (unlikely(be32_to_cpu(fd->status) & FM_FD_STAT_TX_ERRORS)) {
    2052152                if (net_ratelimit())
    2062153                        netif_warn(priv, hw, net_dev, "FD status = 0x%08x\n",
    207                                    fd->status & FM_FD_STAT_TX_ERRORS);
     2154                                   be32_to_cpu(fd->status) &
     2155                                   FM_FD_STAT_TX_ERRORS);
    2082156
    2092157                percpu_priv->stats.tx_errors++;
     
    2122160        percpu_priv->tx_confirm++;
    2132161
    214         skb = _dpa_cleanup_tx_fd(priv, fd);
    215 
    216         dev_kfree_skb(skb);
     2162        skb = dpaa_cleanup_tx_fd(priv, fd);
     2163
     2164        consume_skb(skb);
    2172165#else /* __rtems__ */
    2182166        struct ifnet *ifp = net_dev->ifp;
     
    2222170        }
    2232171
    224         _dpa_cleanup_tx_fd(ifp, fd);
    225 #endif /* __rtems__ */
    226 }
    227 
    228 static enum qman_cb_dqrr_result
    229 priv_rx_error_dqrr(struct qman_portal *portal,
    230                    struct qman_fq *fq,
    231                    const struct qm_dqrr_entry *dq)
    232 {
     2172        dpaa_cleanup_tx_fd(ifp, fd);
     2173#endif /* __rtems__ */
     2174}
     2175
     2176static inline int dpaa_eth_napi_schedule(struct dpaa_percpu_priv *percpu_priv,
     2177                                         struct qman_portal *portal)
     2178{
     2179#ifndef __rtems__
     2180        if (unlikely(in_irq() || !in_serving_softirq())) {
     2181                /* Disable QMan IRQ and invoke NAPI */
     2182                qman_p_irqsource_remove(portal, QM_PIRQ_DQRI);
     2183
     2184                percpu_priv->np.p = portal;
     2185                napi_schedule(&percpu_priv->np.napi);
     2186                percpu_priv->in_interrupt++;
     2187                return 1;
     2188        }
     2189#endif /* __rtems__ */
     2190        return 0;
     2191}
     2192
     2193static enum qman_cb_dqrr_result rx_error_dqrr(struct qman_portal *portal,
     2194                                              struct qman_fq *fq,
     2195                                              const struct qm_dqrr_entry *dq)
     2196{
     2197        struct dpaa_fq *dpaa_fq = container_of(fq, struct dpaa_fq, fq_base);
     2198        struct dpaa_percpu_priv *percpu_priv;
    2332199        struct net_device *net_dev;
    234         struct dpa_priv_s *priv;
    235         struct dpa_percpu_priv_s *percpu_priv;
    236         int *count_ptr;
    237 
    238         net_dev = ((struct dpa_fq *)fq)->net_dev;
     2200        struct dpaa_bp *dpaa_bp;
     2201        struct dpaa_priv *priv;
     2202
     2203        net_dev = dpaa_fq->net_dev;
    2392204        priv = netdev_priv(net_dev);
    240 
    241         percpu_priv = raw_cpu_ptr(priv->percpu_priv);
    242         count_ptr = raw_cpu_ptr(priv->dpa_bp->percpu_count);
     2205        dpaa_bp = dpaa_bpid2pool(dq->fd.bpid);
     2206        if (!dpaa_bp)
     2207                return qman_cb_dqrr_consume;
     2208
     2209        percpu_priv = this_cpu_ptr(priv->percpu_priv);
    2432210
    2442211        if (dpaa_eth_napi_schedule(percpu_priv, portal))
    2452212                return qman_cb_dqrr_stop;
    2462213
    247         if (unlikely(dpaa_eth_refill_bpools(priv->dpa_bp, count_ptr)))
     2214        if (dpaa_eth_refill_bpools(priv))
    2482215                /* Unable to refill the buffer pool due to insufficient
    2492216                 * system memory. Just release the frame back into the pool,
    2502217                 * otherwise we'll soon end up with an empty buffer pool.
    2512218                 */
     2219                dpaa_fd_release(net_dev, &dq->fd);
     2220        else
     2221                dpaa_rx_error(net_dev, priv, percpu_priv, &dq->fd, fq->fqid);
     2222
     2223        return qman_cb_dqrr_consume;
     2224}
     2225
     2226#ifdef __rtems__
     2227static struct mbuf *
     2228dpaa_bp_addr_to_mbuf(dma_addr_t addr)
     2229{
     2230        void *vaddr = phys_to_virt(addr);
     2231
     2232        return (*(struct mbuf **)(vaddr + DPAA_MBUF_POINTER_OFFSET));
     2233}
     2234
     2235static struct mbuf *
     2236contig_fd_to_mbuf(const struct qm_fd *fd, struct ifnet *ifp)
     2237{
     2238        struct mbuf *m;
     2239        ssize_t fd_off = qm_fd_get_offset(fd);
     2240        dma_addr_t addr = qm_fd_addr(fd);
     2241
     2242        m = dpaa_bp_addr_to_mbuf(addr);
     2243        m->m_pkthdr.rcvif = ifp;
     2244        m->m_pkthdr.len = m->m_len = qm_fd_get_length(fd);
     2245        m->m_data = mtod(m, char *) + fd_off;
     2246
     2247        return (m);
     2248}
     2249
     2250static void
     2251dpaa_bp_recycle_frag(struct dpaa_bp *dpaa_bp, dma_addr_t addr, int *count_ptr)
     2252{
     2253        struct bm_buffer bmb;
     2254
     2255        bm_buffer_set64(&bmb, addr);
     2256
     2257        while (bman_release(dpaa_bp->pool, &bmb, 1))
     2258                cpu_relax();
     2259
     2260        ++(*count_ptr);
     2261}
     2262
     2263static struct mbuf *
     2264sg_fd_to_mbuf(struct dpaa_bp *dpaa_bp, const struct qm_fd *fd,
     2265    struct ifnet *ifp, int *count_ptr)
     2266{
     2267        ssize_t fd_off = qm_fd_get_offset(fd);
     2268        dma_addr_t addr = qm_fd_addr(fd);
     2269        const struct qm_sg_entry *sgt;
     2270        int i;
     2271        int len;
     2272        struct mbuf *m;
     2273        struct mbuf *last;
     2274
     2275        sgt = (const struct qm_sg_entry *)((char *)phys_to_virt(addr) + fd_off);
     2276        len = 0;
     2277
     2278        for (i = 0; i < DPAA_SGT_MAX_ENTRIES; ++i) {
     2279                dma_addr_t sg_addr;
     2280                int sg_len;
     2281                struct mbuf *n;
     2282
     2283                BSD_ASSERT(!qm_sg_entry_is_ext(&sgt[i]));
     2284                BSD_ASSERT(dpaa_bp == dpaa_bpid2pool(sgt[i].bpid));
     2285
     2286                sg_addr = qm_sg_addr(&sgt[i]);
     2287                n = dpaa_bp_addr_to_mbuf(sg_addr);
     2288
     2289                sg_len = qm_sg_entry_get_len(&sgt[i]);
     2290                len += sg_len;
     2291
     2292                if (i == 0) {
     2293                        m = n;
     2294                } else {
     2295                        last->m_next = n;
     2296                }
     2297
     2298                n->m_len = sg_len;
     2299                n->m_data = mtod(n, char *) + sgt[i].offset;
     2300                last = n;
     2301
     2302                --(*count_ptr);
     2303
     2304                if (qm_sg_entry_is_final(&sgt[i])) {
     2305                        break;
     2306                }
     2307        }
     2308
     2309        m->m_pkthdr.rcvif = ifp;
     2310        m->m_pkthdr.len = len;
     2311
     2312        dpaa_bp_recycle_frag(dpaa_bp, addr, count_ptr);
     2313
     2314        return (m);
     2315}
     2316
     2317static void
     2318dpaa_rx(struct net_device *net_dev, struct qman_portal *portal,
     2319    const struct dpaa_priv *priv, struct dpaa_percpu_priv *percpu_priv,
     2320    const struct qm_fd *fd, u32 fqid, int *count_ptr)
     2321{
     2322        struct dpaa_bp *dpaa_bp;
     2323        enum qm_fd_format fd_format;
     2324        struct mbuf *m;
     2325        struct ifnet *ifp;
     2326
     2327        ifp = net_dev->ifp;
     2328
     2329        if (unlikely(fd->status & FM_FD_STAT_RX_ERRORS) != 0) {
     2330                if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
     2331                dpaa_fd_release(net_dev, fd);
     2332                return;
     2333        }
     2334
     2335        dpaa_bp = dpaa_bpid2pool(fd->bpid);
     2336        fd_format = qm_fd_get_format(fd);
     2337
     2338        if (likely(fd_format == qm_fd_contig)) {
     2339                m = contig_fd_to_mbuf(fd, ifp);
     2340        } else {
     2341                BSD_ASSERT(fd_format == qm_fd_sg);
     2342                m = sg_fd_to_mbuf(dpaa_bp, fd, ifp, count_ptr);
     2343        }
     2344
     2345        /* Account for either the contig buffer or the SGT buffer (depending on
     2346         * which case we were in) having been removed from the pool.
     2347         */
     2348        (*count_ptr)--;
     2349
     2350        if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
     2351        (*ifp->if_input)(ifp, m);
     2352}
     2353#endif /* __rtems__ */
     2354static enum qman_cb_dqrr_result rx_default_dqrr(struct qman_portal *portal,
     2355                                                struct qman_fq *fq,
     2356                                                const struct qm_dqrr_entry *dq)
     2357{
     2358#ifndef __rtems__
     2359        struct rtnl_link_stats64 *percpu_stats;
     2360#endif /* __rtems__ */
     2361        struct dpaa_percpu_priv *percpu_priv;
     2362#ifndef __rtems__
     2363        const struct qm_fd *fd = &dq->fd;
     2364        dma_addr_t addr = qm_fd_addr(fd);
     2365        enum qm_fd_format fd_format;
     2366#endif /* __rtems__ */
     2367        struct net_device *net_dev;
     2368#ifndef __rtems__
     2369        u32 fd_status = fd->status;
     2370#endif /* __rtems__ */
     2371        struct dpaa_bp *dpaa_bp;
     2372        struct dpaa_priv *priv;
     2373#ifndef __rtems__
     2374        unsigned int skb_len;
     2375        struct sk_buff *skb;
     2376#endif /* __rtems__ */
     2377        int *count_ptr;
     2378
     2379#ifndef __rtems__
     2380        fd_status = be32_to_cpu(fd->status);
     2381        fd_format = qm_fd_get_format(fd);
     2382#endif /* __rtems__ */
     2383        net_dev = ((struct dpaa_fq *)fq)->net_dev;
     2384        priv = netdev_priv(net_dev);
     2385        dpaa_bp = dpaa_bpid2pool(dq->fd.bpid);
     2386        if (!dpaa_bp)
     2387                return qman_cb_dqrr_consume;
     2388
     2389#ifndef __rtems__
     2390        /* Trace the Rx fd */
     2391        trace_dpaa_rx_fd(net_dev, fq, &dq->fd);
     2392#endif /* __rtems__ */
     2393
     2394        percpu_priv = this_cpu_ptr(priv->percpu_priv);
     2395#ifndef __rtems__
     2396        percpu_stats = &percpu_priv->stats;
     2397#endif /* __rtems__ */
     2398
     2399        if (unlikely(dpaa_eth_napi_schedule(percpu_priv, portal)))
     2400                return qman_cb_dqrr_stop;
     2401
     2402        /* Make sure we didn't run out of buffers */
     2403        if (unlikely(dpaa_eth_refill_bpools(priv))) {
     2404#ifdef __rtems__
     2405                struct ifnet *ifp = net_dev->ifp;
     2406                if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
     2407#endif /* __rtems__ */
     2408                dpaa_fd_release(net_dev, &dq->fd);
     2409                return qman_cb_dqrr_consume;
     2410        }
     2411
     2412#ifndef __rtems__
     2413        if (unlikely(fd_status & FM_FD_STAT_RX_ERRORS) != 0) {
     2414                if (net_ratelimit())
     2415                        netif_warn(priv, hw, net_dev, "FD status = 0x%08x\n",
     2416                                   fd_status & FM_FD_STAT_RX_ERRORS);
     2417
     2418                percpu_stats->rx_errors++;
     2419                dpaa_fd_release(net_dev, fd);
     2420                return qman_cb_dqrr_consume;
     2421        }
     2422
     2423        dpaa_bp = dpaa_bpid2pool(fd->bpid);
     2424        if (!dpaa_bp)
     2425                return qman_cb_dqrr_consume;
     2426
     2427        dma_unmap_single(dpaa_bp->dev, addr, dpaa_bp->size, DMA_FROM_DEVICE);
     2428
     2429        /* prefetch the first 64 bytes of the frame or the SGT start */
     2430        prefetch(phys_to_virt(addr) + qm_fd_get_offset(fd));
     2431
     2432        fd_format = qm_fd_get_format(fd);
     2433        /* The only FD types that we may receive are contig and S/G */
     2434        WARN_ON((fd_format != qm_fd_contig) && (fd_format != qm_fd_sg));
     2435
     2436        /* Account for either the contig buffer or the SGT buffer (depending on
     2437         * which case we were in) having been removed from the pool.
     2438         */
     2439        count_ptr = this_cpu_ptr(dpaa_bp->percpu_count);
     2440        (*count_ptr)--;
     2441
     2442        if (likely(fd_format == qm_fd_contig))
     2443                skb = contig_fd_to_skb(priv, fd);
    2522444                dpa_fd_release(net_dev, &dq->fd);
    2532445        else
    254                 _dpa_rx_error(net_dev, priv, percpu_priv, &dq->fd, fq->fqid);
     2446                skb = sg_fd_to_skb(priv, fd);
     2447        if (!skb)
     2448                return qman_cb_dqrr_consume;
     2449
     2450        skb->protocol = eth_type_trans(skb, net_dev);
     2451
     2452        skb_len = skb->len;
     2453
     2454        if (unlikely(netif_receive_skb(skb) == NET_RX_DROP))
     2455                return qman_cb_dqrr_consume;
     2456
     2457        percpu_stats->rx_packets++;
     2458        percpu_stats->rx_bytes += skb_len;
     2459#else /* __rtems__ */
     2460        count_ptr = this_cpu_ptr(dpaa_bp->percpu_count);
     2461        dpaa_rx(net_dev, portal, priv, percpu_priv, &dq->fd, fq->fqid,
     2462                count_ptr);
     2463#endif /* __rtems__ */
    2552464
    2562465        return qman_cb_dqrr_consume;
    2572466}
    2582467
    259 static enum qman_cb_dqrr_result
    260 priv_rx_default_dqrr(struct qman_portal *portal,
    261                      struct qman_fq *fq,
    262                      const struct qm_dqrr_entry *dq)
    263 {
     2468static enum qman_cb_dqrr_result conf_error_dqrr(struct qman_portal *portal,
     2469                                                struct qman_fq *fq,
     2470                                                const struct qm_dqrr_entry *dq)
     2471{
     2472        struct dpaa_percpu_priv *percpu_priv;
    2642473        struct net_device *net_dev;
    265         struct dpa_priv_s *priv;
    266         struct dpa_percpu_priv_s *percpu_priv;
    267         int *count_ptr;
    268         struct dpa_bp *dpa_bp;
    269 
    270         net_dev = ((struct dpa_fq *)fq)->net_dev;
     2474        struct dpaa_priv *priv;
     2475
     2476        net_dev = ((struct dpaa_fq *)fq)->net_dev;
    2712477        priv = netdev_priv(net_dev);
    272         dpa_bp = priv->dpa_bp;
    273 
    274 #ifndef __rtems__
    275         /* Trace the Rx fd */
    276         trace_dpa_rx_fd(net_dev, fq, &dq->fd);
    277 #endif /* __rtems__ */
    278 
    279         /* IRQ handler, non-migratable; safe to use raw_cpu_ptr here */
    280         percpu_priv = raw_cpu_ptr(priv->percpu_priv);
    281         count_ptr = raw_cpu_ptr(dpa_bp->percpu_count);
    282 
    283         if (unlikely(dpaa_eth_napi_schedule(percpu_priv, portal)))
    284                 return qman_cb_dqrr_stop;
    285 
    286         /* Vale of plenty: make sure we didn't run out of buffers */
    287 
    288         if (unlikely(dpaa_eth_refill_bpools(dpa_bp, count_ptr)))
    289 #ifdef __rtems__
    290         {
    291                 struct ifnet *ifp = net_dev->ifp;
    292                 if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
    293 #endif /* __rtems__ */
    294                 /* Unable to refill the buffer pool due to insufficient
    295                  * system memory. Just release the frame back into the pool,
    296                  * otherwise we'll soon end up with an empty buffer pool.
    297                  */
    298                 dpa_fd_release(net_dev, &dq->fd);
    299 #ifdef __rtems__
    300         }
    301 #endif /* __rtems__ */
    302         else
    303                 _dpa_rx(net_dev, portal, priv, percpu_priv, &dq->fd, fq->fqid,
    304                         count_ptr);
    305 
    306         return qman_cb_dqrr_consume;
    307 }
    308 
    309 static enum qman_cb_dqrr_result
    310 priv_tx_conf_error_dqrr(struct qman_portal *portal,
    311                         struct qman_fq *fq,
    312                         const struct qm_dqrr_entry *dq)
    313 {
    314         struct net_device *net_dev;
    315         struct dpa_priv_s *priv;
    316         struct dpa_percpu_priv_s *percpu_priv;
    317 
    318         net_dev = ((struct dpa_fq *)fq)->net_dev;
    319         priv = netdev_priv(net_dev);
    320 
    321         percpu_priv = raw_cpu_ptr(priv->percpu_priv);
     2478
     2479        percpu_priv = this_cpu_ptr(priv->percpu_priv);
    3222480
    3232481        if (dpaa_eth_napi_schedule(percpu_priv, portal))
    3242482                return qman_cb_dqrr_stop;
    3252483
    326         _dpa_tx_error(net_dev, priv, percpu_priv, &dq->fd, fq->fqid);
     2484        dpaa_tx_error(net_dev, priv, percpu_priv, &dq->fd, fq->fqid);
    3272485
    3282486        return qman_cb_dqrr_consume;
    3292487}
    3302488
    331 static enum qman_cb_dqrr_result
    332 priv_tx_conf_default_dqrr(struct qman_portal *portal,
    333                           struct qman_fq *fq,
    334                           const struct qm_dqrr_entry *dq)
    335 {
     2489static enum qman_cb_dqrr_result conf_dflt_dqrr(struct qman_portal *portal,
     2490                                               struct qman_fq *fq,
     2491                                               const struct qm_dqrr_entry *dq)
     2492{
     2493        struct dpaa_percpu_priv *percpu_priv;
    3362494        struct net_device *net_dev;
    337         struct dpa_priv_s *priv;
    338         struct dpa_percpu_priv_s *percpu_priv;
    339 
    340         net_dev = ((struct dpa_fq *)fq)->net_dev;
     2495        struct dpaa_priv *priv;
     2496
     2497        net_dev = ((struct dpaa_fq *)fq)->net_dev;
    3412498        priv = netdev_priv(net_dev);
    3422499
    3432500#ifndef __rtems__
    3442501        /* Trace the fd */
    345         trace_dpa_tx_conf_fd(net_dev, fq, &dq->fd);
    346 #endif /* __rtems__ */
    347 
    348         /* Non-migratable context, safe to use raw_cpu_ptr */
    349         percpu_priv = raw_cpu_ptr(priv->percpu_priv);
     2502        trace_dpaa_tx_conf_fd(net_dev, fq, &dq->fd);
     2503#endif /* __rtems__ */
     2504
     2505        percpu_priv = this_cpu_ptr(priv->percpu_priv);
    3502506
    3512507        if (dpaa_eth_napi_schedule(percpu_priv, portal))
    3522508                return qman_cb_dqrr_stop;
    3532509
    354         _dpa_tx_conf(net_dev, priv, percpu_priv, &dq->fd, fq->fqid);
     2510        dpaa_tx_conf(net_dev, priv, percpu_priv, &dq->fd, fq->fqid);
    3552511
    3562512        return qman_cb_dqrr_consume;
    3572513}
    3582514
    359 static void priv_ern(struct qman_portal *portal,
    360                      struct qman_fq *fq,
    361                      const struct qm_mr_entry *msg)
    362 {
     2515static void egress_ern(struct qman_portal *portal,
     2516                       struct qman_fq *fq,
     2517                       const union qm_mr_entry *msg)
     2518{
     2519        const struct qm_fd *fd = &msg->ern.fd;
     2520        struct dpaa_percpu_priv *percpu_priv;
     2521        const struct dpaa_priv *priv;
    3632522        struct net_device *net_dev;
    364         const struct dpa_priv_s *priv;
    3652523#ifndef __rtems__
    3662524        struct sk_buff *skb;
     
    3682526        struct ifnet *ifp;
    3692527#endif /* __rtems__ */
    370         struct dpa_percpu_priv_s *percpu_priv;
    371         const struct qm_fd *fd = &msg->ern.fd;
    372 
    373         net_dev = ((struct dpa_fq *)fq)->net_dev;
     2528
     2529        net_dev = ((struct dpaa_fq *)fq)->net_dev;
    3742530        priv = netdev_priv(net_dev);
    375         /* Non-migratable context, safe to use raw_cpu_ptr */
    376         percpu_priv = raw_cpu_ptr(priv->percpu_priv);
     2531        percpu_priv = this_cpu_ptr(priv->percpu_priv);
    3772532
    3782533#ifndef __rtems__
     
    3852540        count_ern(percpu_priv, msg);
    3862541
    387         /* If we intended this buffer to go into the pool
    388          * when the FM was done, we need to put it in
    389          * manually.
    390          */
    391         if (msg->ern.fd.bpid != 0xff) {
    392                 dpa_fd_release(net_dev, fd);
    393                 return;
    394         }
    395 
    396 #ifndef __rtems__
    397         skb = _dpa_cleanup_tx_fd(priv, fd);
     2542#ifndef __rtems__
     2543        skb = dpaa_cleanup_tx_fd(priv, fd);
    3982544        dev_kfree_skb_any(skb);
    3992545#else /* __rtems__ */
    400         _dpa_cleanup_tx_fd(ifp, fd);
    401 #endif /* __rtems__ */
    402 }
    403 
    404 static const struct dpa_fq_cbs_t private_fq_cbs = {
    405         .rx_defq = { .cb = { .dqrr = priv_rx_default_dqrr } },
    406         .tx_defq = { .cb = { .dqrr = priv_tx_conf_default_dqrr } },
    407         .rx_errq = { .cb = { .dqrr = priv_rx_error_dqrr } },
    408         .tx_errq = { .cb = { .dqrr = priv_tx_conf_error_dqrr } },
    409         .egress_ern = { .cb = { .ern = priv_ern } }
     2546        dpaa_cleanup_tx_fd(ifp, fd);
     2547#endif /* __rtems__ */
     2548}
     2549
     2550static const struct dpaa_fq_cbs dpaa_fq_cbs = {
     2551        .rx_defq = { .cb = { .dqrr = rx_default_dqrr } },
     2552        .tx_defq = { .cb = { .dqrr = conf_dflt_dqrr } },
     2553        .rx_errq = { .cb = { .dqrr = rx_error_dqrr } },
     2554        .tx_errq = { .cb = { .dqrr = conf_error_dqrr } },
     2555        .egress_ern = { .cb = { .ern = egress_ern } }
    4102556};
    4112557
    412 static void dpaa_eth_napi_enable(struct dpa_priv_s *priv)
    413 {
    414 #ifndef __rtems__
    415         struct dpa_percpu_priv_s *percpu_priv;
    416         int i, j;
     2558static void dpaa_eth_napi_enable(struct dpaa_priv *priv)
     2559{
     2560#ifndef __rtems__
     2561        struct dpaa_percpu_priv *percpu_priv;
     2562        int i;
    4172563
    4182564        for_each_possible_cpu(i) {
    4192565                percpu_priv = per_cpu_ptr(priv->percpu_priv, i);
    4202566
    421                 for (j = 0; j < qman_portal_max; j++)
    422                         napi_enable(&percpu_priv->np[j].napi);
    423         }
    424 #endif /* __rtems__ */
    425 }
    426 
    427 static void dpaa_eth_napi_disable(struct dpa_priv_s *priv)
    428 {
    429 #ifndef __rtems__
    430         struct dpa_percpu_priv_s *percpu_priv;
    431         int i, j;
     2567                percpu_priv->np.down = 0;
     2568                napi_enable(&percpu_priv->np.napi);
     2569        }
     2570#endif /* __rtems__ */
     2571}
     2572
     2573static void dpaa_eth_napi_disable(struct dpaa_priv *priv)
     2574{
     2575#ifndef __rtems__
     2576        struct dpaa_percpu_priv *percpu_priv;
     2577        int i;
    4322578
    4332579        for_each_possible_cpu(i) {
    4342580                percpu_priv = per_cpu_ptr(priv->percpu_priv, i);
    4352581
    436                 for (j = 0; j < qman_portal_max; j++)
    437                         napi_disable(&percpu_priv->np[j].napi);
    438         }
    439 #endif /* __rtems__ */
    440 }
    441 
    442 #ifndef __rtems__
    443 static int dpa_eth_priv_start(struct net_device *net_dev)
     2582                percpu_priv->np.down = 1;
     2583                napi_disable(&percpu_priv->np.napi);
     2584        }
     2585#endif /* __rtems__ */
     2586}
     2587
     2588#ifndef __rtems__
     2589static int dpaa_open(struct net_device *net_dev)
    4442590#else /* __rtems__ */
    4452591int dpa_eth_priv_start(struct net_device *net_dev)
    4462592#endif /* __rtems__ */
    4472593{
    448         int err;
    449         struct dpa_priv_s *priv;
     2594        struct mac_device *mac_dev;
     2595        struct dpaa_priv *priv;
     2596        int err, i;
    4502597
    4512598        priv = netdev_priv(net_dev);
    452 
     2599        mac_dev = priv->mac_dev;
    4532600        dpaa_eth_napi_enable(priv);
    4542601
    455         err = dpa_start(net_dev);
    456         if (err < 0)
    457                 dpaa_eth_napi_disable(priv);
     2602#ifndef __rtems__
     2603        net_dev->phydev = mac_dev->init_phy(net_dev, priv->mac_dev);
     2604        if (!net_dev->phydev) {
     2605                netif_err(priv, ifup, net_dev, "init_phy() failed\n");
     2606                err = -ENODEV;
     2607                goto phy_init_failed;
     2608        }
     2609#endif /* __rtems__ */
     2610
     2611        for (i = 0; i < ARRAY_SIZE(mac_dev->port); i++) {
     2612                err = fman_port_enable(mac_dev->port[i]);
     2613                if (err)
     2614                        goto mac_start_failed;
     2615        }
     2616
     2617        err = priv->mac_dev->start(mac_dev);
     2618        if (err < 0) {
     2619                netif_err(priv, ifup, net_dev, "mac_dev->start() = %d\n", err);
     2620                goto mac_start_failed;
     2621        }
     2622
     2623#ifndef __rtems__
     2624        netif_tx_start_all_queues(net_dev);
     2625#endif /* __rtems__ */
     2626
     2627        return 0;
     2628
     2629mac_start_failed:
     2630        for (i = 0; i < ARRAY_SIZE(mac_dev->port); i++)
     2631                fman_port_disable(mac_dev->port[i]);
     2632
     2633#ifndef __rtems__
     2634phy_init_failed:
     2635#endif /* __rtems__ */
     2636        dpaa_eth_napi_disable(priv);
    4582637
    4592638        return err;
     
    4612640
    4622641#ifndef __rtems__
    463 static int dpa_eth_priv_stop(struct net_device *net_dev)
     2642static int dpaa_eth_stop(struct net_device *net_dev)
    4642643#else /* __rtems__ */
    4652644int dpa_eth_priv_stop(struct net_device *net_dev)
    4662645#endif /* __rtems__ */
    4672646{
     2647        struct dpaa_priv *priv;
    4682648        int err;
    469         struct dpa_priv_s *priv;
    470 
    471         err = dpa_stop(net_dev);
    472         /* Allow NAPI to consume any frame still in the Rx/TxConfirm
    473          * ingress queues. This is to avoid a race between the current
    474          * context and ksoftirqd which could leave NAPI disabled while
    475          * in fact there's still Rx traffic to be processed.
    476          */
    477         usleep_range(5000, 10000);
     2649
     2650        err = dpaa_stop(net_dev);
    4782651
    4792652        priv = netdev_priv(net_dev);
     
    4842657
    4852658#ifndef __rtems__
    486 static const struct net_device_ops dpa_private_ops = {
    487         .ndo_open = dpa_eth_priv_start,
    488         .ndo_start_xmit = dpa_tx,
    489         .ndo_stop = dpa_eth_priv_stop,
    490         .ndo_tx_timeout = dpa_timeout,
    491         .ndo_get_stats64 = dpa_get_stats64,
    492         .ndo_set_mac_address = dpa_set_mac_address,
     2659static int dpaa_ioctl(struct net_device *net_dev, struct ifreq *rq, int cmd)
     2660{
     2661        if (!net_dev->phydev)
     2662                return -EINVAL;
     2663        return phy_mii_ioctl(net_dev->phydev, rq, cmd);
     2664}
     2665
     2666static const struct net_device_ops dpaa_ops = {
     2667        .ndo_open = dpaa_open,
     2668        .ndo_start_xmit = dpaa_start_xmit,
     2669        .ndo_stop = dpaa_eth_stop,
     2670        .ndo_tx_timeout = dpaa_tx_timeout,
     2671        .ndo_get_stats64 = dpaa_get_stats64,
     2672        .ndo_set_mac_address = dpaa_set_mac_address,
    4932673        .ndo_validate_addr = eth_validate_addr,
    494 #ifdef CONFIG_FSL_DPAA_ETH_USE_NDO_SELECT_QUEUE
    495         .ndo_select_queue = dpa_select_queue,
    496 #endif
    497         .ndo_change_mtu = dpa_change_mtu,
    498         .ndo_set_rx_mode = dpa_set_rx_mode,
    499         .ndo_init = dpa_ndo_init,
    500         .ndo_set_features = dpa_set_features,
    501         .ndo_fix_features = dpa_fix_features,
     2674        .ndo_set_rx_mode = dpaa_set_rx_mode,
     2675        .ndo_do_ioctl = dpaa_ioctl,
    5022676};
    503 #endif /* __rtems__ */
    504 
    505 static int dpa_private_napi_add(struct net_device *net_dev)
    506 {
    507 #ifndef __rtems__
    508         struct dpa_priv_s *priv = netdev_priv(net_dev);
    509         struct dpa_percpu_priv_s *percpu_priv;
    510         int i, cpu;
     2677
     2678static int dpaa_napi_add(struct net_device *net_dev)
     2679{
     2680        struct dpaa_priv *priv = netdev_priv(net_dev);
     2681        struct dpaa_percpu_priv *percpu_priv;
     2682        int cpu;
    5112683
    5122684        for_each_possible_cpu(cpu) {
    5132685                percpu_priv = per_cpu_ptr(priv->percpu_priv, cpu);
    5142686
    515                 percpu_priv->np = devm_kzalloc(net_dev->dev.parent,
    516                         qman_portal_max * sizeof(struct dpa_napi_portal),
    517                         GFP_KERNEL);
    518 
    519                 if (!percpu_priv->np)
    520                         return -ENOMEM;
    521 
    522                 for (i = 0; i < qman_portal_max; i++)
    523                         netif_napi_add(net_dev, &percpu_priv->np[i].napi,
    524                                        dpaa_eth_poll, DPA_NAPI_WEIGHT);
    525         }
    526 #endif /* __rtems__ */
     2687                netif_napi_add(net_dev, &percpu_priv->np.napi,
     2688                               dpaa_eth_poll, NAPI_POLL_WEIGHT);
     2689        }
    5272690
    5282691        return 0;
    5292692}
    530 
    531 void dpa_private_napi_del(struct net_device *net_dev)
    532 {
    533 #ifndef __rtems__
    534         struct dpa_priv_s *priv = netdev_priv(net_dev);
    535         struct dpa_percpu_priv_s *percpu_priv;
    536         int i, cpu;
     2693#endif /* __rtems__ */
     2694
     2695static void dpaa_napi_del(struct net_device *net_dev)
     2696{
     2697#ifndef __rtems__
     2698        struct dpaa_priv *priv = netdev_priv(net_dev);
     2699        struct dpaa_percpu_priv *percpu_priv;
     2700        int cpu;
    5372701
    5382702        for_each_possible_cpu(cpu) {
    5392703                percpu_priv = per_cpu_ptr(priv->percpu_priv, cpu);
    5402704
    541                 if (percpu_priv->np) {
    542                         for (i = 0; i < qman_portal_max; i++)
    543                                 netif_napi_del(&percpu_priv->np[i].napi);
    544 
    545                         devm_kfree(net_dev->dev.parent, percpu_priv->np);
    546                 }
    547         }
    548 #endif /* __rtems__ */
    549 }
    550 
    551 static int dpa_private_netdev_init(struct net_device *net_dev)
    552 {
    553         int i;
    554         struct dpa_priv_s *priv = netdev_priv(net_dev);
    555         struct dpa_percpu_priv_s *percpu_priv;
    556 #ifndef __rtems__
    557         const u8 *mac_addr;
    558 #endif /* __rtems__ */
    559 
    560         /* Although we access another CPU's private data here
    561          * we do it at initialization so it is safe
    562          */
    563 #ifndef __rtems__
    564         for_each_possible_cpu(i) {
     2705                netif_napi_del(&percpu_priv->np.napi);
     2706        }
     2707#endif /* __rtems__ */
     2708}
     2709
     2710static inline void dpaa_bp_free_pf(const struct dpaa_bp *bp,
     2711                                   struct bm_buffer *bmb)
     2712{
     2713        dma_addr_t addr = bm_buf_addr(bmb);
     2714
     2715#ifndef __rtems__
     2716        dma_unmap_single(bp->dev, addr, bp->size, DMA_FROM_DEVICE);
     2717
     2718        skb_free_frag(phys_to_virt(addr));
    5652719#else /* __rtems__ */
    566         for (i = 0; i < (int)rtems_get_processor_count(); ++i) {
    567 #endif /* __rtems__ */
    568                 percpu_priv = per_cpu_ptr(priv->percpu_priv, i);
    569                 percpu_priv->net_dev = net_dev;
    570         }
    571 
    572 #ifndef __rtems__
    573         net_dev->netdev_ops = &dpa_private_ops;
    574         mac_addr = priv->mac_dev->addr;
    575 
    576         net_dev->mem_start = priv->mac_dev->res->start;
    577         net_dev->mem_end = priv->mac_dev->res->end;
    578 
    579         net_dev->hw_features |= (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
    580                 NETIF_F_LLTX);
    581 
    582         /* Advertise S/G and HIGHDMA support for private interfaces */
    583         net_dev->hw_features |= NETIF_F_SG | NETIF_F_HIGHDMA;
    584         /* Recent kernels enable GSO automatically, if
    585          * we declare NETIF_F_SG. For conformity, we'll
    586          * still declare GSO explicitly.
    587          */
    588         net_dev->features |= NETIF_F_GSO;
    589 
    590         return dpa_netdev_init(net_dev, mac_addr, tx_timeout);
    591 #else /* __rtems__ */
    592         return 0;
    593 #endif /* __rtems__ */
    594 }
    595 
    596 static struct dpa_bp *dpa_priv_bp_probe(struct device *dev)
    597 {
    598         struct dpa_bp *dpa_bp;
    599 
    600         dpa_bp = devm_kzalloc(dev, sizeof(*dpa_bp), GFP_KERNEL);
    601         if (!dpa_bp)
     2720        BSD_ASSERT(0);
     2721        m_freem(dpaa_bp_addr_to_mbuf(addr));
     2722#endif /* __rtems__ */
     2723}
     2724
     2725/* Alloc the dpaa_bp struct and configure default values */
     2726static struct dpaa_bp *dpaa_bp_alloc(struct device *dev)
     2727{
     2728        struct dpaa_bp *dpaa_bp;
     2729
     2730        dpaa_bp = devm_kzalloc(dev, sizeof(*dpaa_bp), GFP_KERNEL);
     2731        if (!dpaa_bp)
    6022732                return ERR_PTR(-ENOMEM);
    6032733
    604         dpa_bp->percpu_count = devm_alloc_percpu(dev, *dpa_bp->percpu_count);
    605         dpa_bp->config_count = FSL_DPAA_ETH_MAX_BUF_COUNT;
    606 
    607         dpa_bp->seed_cb = dpa_bp_priv_seed;
    608         dpa_bp->free_buf_cb = _dpa_bp_free_pf;
    609 
    610         return dpa_bp;
     2734        dpaa_bp->bpid = FSL_DPAA_BPID_INV;
     2735        dpaa_bp->percpu_count = devm_alloc_percpu(dev, *dpaa_bp->percpu_count);
     2736        dpaa_bp->config_count = FSL_DPAA_ETH_MAX_BUF_COUNT;
     2737
     2738        dpaa_bp->seed_cb = dpaa_bp_seed;
     2739        dpaa_bp->free_buf_cb = dpaa_bp_free_pf;
     2740
     2741        return dpaa_bp;
    6112742}
    6122743
     
    6162747 * before they reach our ingress queues and eat up memory.
    6172748 */
    618 static int dpaa_eth_priv_ingress_cgr_init(struct dpa_priv_s *priv)
     2749static int dpaa_ingress_cgr_init(struct dpaa_priv *priv)
    6192750{
    6202751        struct qm_mcc_initcgr initcgr;
     
    6242755        err = qman_alloc_cgrid(&priv->ingress_cgr.cgrid);
    6252756        if (err < 0) {
    626                 pr_err("Error %d allocating CGR ID\n", err);
     2757                if (netif_msg_drv(priv))
     2758                        pr_err("Error %d allocating CGR ID\n", err);
    6272759                goto out_error;
    6282760        }
    6292761
    6302762        /* Enable CS TD, but disable Congestion State Change Notifications. */
    631         initcgr.we_mask = QM_CGR_WE_CS_THRES;
     2763        memset(&initcgr, 0, sizeof(initcgr));
     2764        initcgr.we_mask = cpu_to_be16(QM_CGR_WE_CS_THRES);
    6322765        initcgr.cgr.cscn_en = QM_CGR_EN;
    6332766        cs_th = DPAA_INGRESS_CS_THRESHOLD;
    6342767        qm_cgr_cs_thres_set64(&initcgr.cgr.cs_thres, cs_th, 1);
    6352768
    636         initcgr.we_mask |= QM_CGR_WE_CSTD_EN;
     2769        initcgr.we_mask |= cpu_to_be16(QM_CGR_WE_CSTD_EN);
    6372770        initcgr.cgr.cstd_en = QM_CGR_EN;
    6382771
    639         /* This is actually a hack, because this CGR will be associated with
    640          * our affine SWP. However, we'll place our ingress FQs in it.
     2772        /* This CGR will be associated with the SWP affined to the current CPU.
     2773         * However, we'll place all our ingress FQs in it.
    6412774         */
    6422775        err = qman_create_cgr(&priv->ingress_cgr, QMAN_CGR_FLAG_USE_INIT,
    6432776                              &initcgr);
    6442777        if (err < 0) {
    645                 pr_err("Error %d creating ingress CGR with ID %d\n", err,
    646                        priv->ingress_cgr.cgrid);
     2778                if (netif_msg_drv(priv))
     2779                        pr_err("Error %d creating ingress CGR with ID %d\n",
     2780                               err, priv->ingress_cgr.cgrid);
    6472781                qman_release_cgrid(priv->ingress_cgr.cgrid);
    6482782                goto out_error;
    6492783        }
    650         pr_debug("Created ingress CGR %d for netdev with hwaddr %pM\n",
    651                  priv->ingress_cgr.cgrid, priv->mac_dev->addr);
    652 
    653         /* struct qman_cgr allows special cgrid values (i.e. outside the 0..255
    654          * range), but we have no common initialization path between the
    655          * different variants of the DPAA Eth driver, so we do it here rather
    656          * than modifying every other variant than "private Eth".
    657          */
     2784        if (netif_msg_drv(priv))
     2785                pr_debug("Created ingress CGR %d for netdev with hwaddr %pM\n",
     2786                         priv->ingress_cgr.cgrid, priv->mac_dev->addr);
     2787
    6582788        priv->use_ingress_cgr = true;
    6592789
     
    6622792}
    6632793
    664 static int dpa_priv_bp_create(struct net_device *net_dev, struct dpa_bp *dpa_bp,
    665                               size_t count)
    666 {
    667         struct dpa_priv_s *priv = netdev_priv(net_dev);
    668         int i;
    669 
    670         netif_dbg(priv, probe, net_dev,
    671                   "Using private BM buffer pools\n");
    672 
    673         priv->bp_count = count;
    674 
    675         for (i = 0; i < count; i++) {
    676                 int err;
    677 
    678                 err = dpa_bp_alloc(&dpa_bp[i]);
    679                 if (err < 0) {
    680                         dpa_bp_free(priv);
    681                         priv->dpa_bp = NULL;
    682                         return err;
    683                 }
    684 
    685                 priv->dpa_bp = &dpa_bp[i];
    686         }
    687 
    688         dpa_priv_common_bpid = priv->dpa_bp->bpid;
    689         return 0;
    690 }
    691 
    692 #ifndef __rtems__
    693 static const struct of_device_id dpa_match[];
    694 
    695 static int
    696 dpaa_eth_priv_probe(struct platform_device *pdev)
     2794#ifndef __rtems__
     2795static const struct of_device_id dpaa_match[];
     2796#endif /* __rtems__ */
     2797
     2798static inline u16 dpaa_get_headroom(struct dpaa_buffer_layout *bl)
     2799{
     2800        u16 headroom;
     2801
     2802        /* The frame headroom must accommodate:
     2803         * - the driver private data area
     2804         * - parse results, hash results, timestamp if selected
     2805         * If either hash results or time stamp are selected, both will
     2806         * be copied to/from the frame headroom, as TS is located between PR and
     2807         * HR in the IC and IC copy size has a granularity of 16bytes
     2808         * (see description of FMBM_RICP and FMBM_TICP registers in DPAARM)
     2809         *
     2810         * Also make sure the headroom is a multiple of data_align bytes
     2811         */
     2812        headroom = (u16)(bl->priv_data_size + DPAA_PARSE_RESULTS_SIZE +
     2813                DPAA_TIME_STAMP_SIZE + DPAA_HASH_RESULTS_SIZE);
     2814
     2815        return DPAA_FD_DATA_ALIGNMENT ? ALIGN(headroom,
     2816                                              DPAA_FD_DATA_ALIGNMENT) :
     2817                                        headroom;
     2818}
     2819
     2820#ifndef __rtems__
     2821static int dpaa_eth_probe(struct platform_device *pdev)
    6972822#else /* __rtems__ */
    6982823int
     
    7002825#endif /* __rtems__ */
    7012826{
     2827        struct dpaa_bp *dpaa_bps[DPAA_BPS_NUM] = {NULL};
     2828        struct dpaa_percpu_priv *percpu_priv;
     2829        struct net_device *net_dev = NULL;
     2830        struct dpaa_fq *dpaa_fq, *tmp;
     2831        struct dpaa_priv *priv = NULL;
     2832        struct fm_port_fqs port_fqs;
     2833#ifndef __rtems__
     2834        struct mac_device *mac_dev;
     2835#endif /* __rtems__ */
    7022836        int err = 0, i, channel;
    7032837        struct device *dev;
    704         struct dpa_bp *dpa_bp;
    705         struct dpa_fq *dpa_fq, *tmp;
    706         size_t count = 1;
    707         struct net_device *net_dev = NULL;
    708         struct dpa_priv_s *priv = NULL;
    709         struct dpa_percpu_priv_s *percpu_priv;
    710         struct fm_port_fqs port_fqs;
    711         struct dpa_buffer_layout_s *buf_layout = NULL;
    712 #ifndef __rtems__
    713         struct mac_device *mac_dev;
    714         struct task_struct *kth;
    715 #endif /* __rtems__ */
    7162838
    7172839        dev = &pdev->dev;
    718 
    719         /* Get the buffer pool assigned to this interface;
    720          * run only once the default pool probing code
    721          */
    722         dpa_bp = (dpa_bpid2pool(dpa_priv_common_bpid)) ? :
    723                         dpa_priv_bp_probe(dev);
    724         if (IS_ERR(dpa_bp))
    725                 return PTR_ERR(dpa_bp);
    7262840
    7272841#ifndef __rtems__
     
    7292843         * the private area
    7302844         */
    731         net_dev = alloc_etherdev_mq(sizeof(*priv), DPAA_ETH_TX_QUEUES);
     2845        net_dev = alloc_etherdev_mq(sizeof(*priv), DPAA_ETH_TXQ_NUM);
    7322846        if (!net_dev) {
    7332847                dev_err(dev, "alloc_etherdev_mq() failed\n");
     
    7392853#endif /* __rtems__ */
    7402854
    741 #ifdef CONFIG_FSL_DPAA_ETH_FRIENDLY_IF_NAME
    742         snprintf(net_dev->name, IFNAMSIZ, "fm%d-mac%d",
    743                  dpa_mac_fman_index_get(pdev),
    744                  dpa_mac_hw_index_get(pdev));
    745 #endif
    746 
    7472855        /* Do this here, so we can be verbose early */
    7482856#ifndef __rtems__
     
    7552863
    7562864#ifndef __rtems__
    757         priv->msg_enable = netif_msg_init(debug, -1);
    758 
    759         mac_dev = dpa_mac_dev_get(pdev);
    760         if (IS_ERR(mac_dev) || !mac_dev) {
     2865        priv->msg_enable = netif_msg_init(debug, DPAA_MSG_DEFAULT);
     2866
     2867        mac_dev = dpaa_mac_dev_get(pdev);
     2868        if (IS_ERR(mac_dev)) {
     2869                dev_err(dev, "dpaa_mac_dev_get() failed\n");
    7612870                err = PTR_ERR(mac_dev);
    7622871                goto mac_probe_failed;
    7632872        }
    764 #endif /* __rtems__ */
    765 
    766         /* We have physical ports, so we need to establish
    767          * the buffer layout.
     2873
     2874        /* If fsl_fm_max_frm is set to a higher value than the all-common 1500,
     2875         * we choose conservatively and let the user explicitly set a higher
     2876         * MTU via ifconfig. Otherwise, the user may end up with different MTUs
     2877         * in the same LAN.
     2878         * If on the other hand fsl_fm_max_frm has been chosen below 1500,
     2879         * start with the maximum allowed.
    7682880         */
    769         buf_layout = devm_kzalloc(dev, 2 * sizeof(*buf_layout),
    770                                   GFP_KERNEL);
    771         if (!buf_layout)
    772                 goto alloc_failed;
    773 
    774         dpa_set_buffers_layout(mac_dev, buf_layout);
    775 
    776         /* For private ports, need to compute the size of the default
    777          * buffer pool, based on FMan port buffer layout;also update
    778          * the maximum buffer size for private ports if necessary
    779          */
    780         dpa_bp->size = dpa_bp_size(&buf_layout[RX]);
    781 
    782         INIT_LIST_HEAD(&priv->dpa_fq_list);
     2881        net_dev->mtu = min(dpaa_get_max_mtu(), ETH_DATA_LEN);
     2882
     2883        netdev_dbg(net_dev, "Setting initial MTU on net device: %d\n",
     2884                   net_dev->mtu);
     2885#endif /* __rtems__ */
     2886
     2887        priv->buf_layout[RX].priv_data_size = DPAA_RX_PRIV_DATA_SIZE; /* Rx */
     2888        priv->buf_layout[TX].priv_data_size = DPAA_TX_PRIV_DATA_SIZE; /* Tx */
     2889
     2890#ifndef __rtems__
     2891        /* device used for DMA mapping */
     2892        arch_setup_dma_ops(dev, 0, 0, NULL, false);
     2893        err = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(40));
     2894        if (err) {
     2895                dev_err(dev, "dma_coerce_mask_and_coherent() failed\n");
     2896                goto dev_mask_failed;
     2897        }
     2898#endif /* __rtems__ */
     2899
     2900        /* bp init */
     2901        for (i = 0; i < DPAA_BPS_NUM; i++) {
     2902                int err;
     2903
     2904                dpaa_bps[i] = dpaa_bp_alloc(dev);
     2905                if (IS_ERR(dpaa_bps[i]))
     2906                        return PTR_ERR(dpaa_bps[i]);
     2907                /* the raw size of the buffers used for reception */
     2908                dpaa_bps[i]->raw_size = bpool_buffer_raw_size(i, DPAA_BPS_NUM);
     2909                /* avoid runtime computations by keeping the usable size here */
     2910                dpaa_bps[i]->size = dpaa_bp_size(dpaa_bps[i]->raw_size);
     2911                dpaa_bps[i]->dev = dev;
     2912
     2913                err = dpaa_bp_alloc_pool(dpaa_bps[i]);
     2914                if (err < 0) {
     2915                        dpaa_bps_free(priv);
     2916                        priv->dpaa_bps[i] = NULL;
     2917                        goto bp_create_failed;
     2918                }
     2919                priv->dpaa_bps[i] = dpaa_bps[i];
     2920        }
     2921
     2922        INIT_LIST_HEAD(&priv->dpaa_fq_list);
    7832923
    7842924        memset(&port_fqs, 0, sizeof(port_fqs));
    7852925
    786         err = dpa_fq_probe_mac(dev, &priv->dpa_fq_list, &port_fqs, true, RX);
    787         if (!err)
    788                 err = dpa_fq_probe_mac(dev, &priv->dpa_fq_list,
    789                                        &port_fqs, true, TX);
    790 
    791         if (err < 0)
     2926        err = dpaa_alloc_all_fqs(dev, &priv->dpaa_fq_list, &port_fqs);
     2927        if (err < 0) {
     2928                dev_err(dev, "dpaa_alloc_all_fqs() failed\n");
    7922929                goto fq_probe_failed;
    793 
    794         /* bp init */
    795 
    796         err = dpa_priv_bp_create(net_dev, dpa_bp, count);
    797 
    798         if (err < 0)
    799                 goto bp_create_failed;
     2930        }
    8002931
    8012932        priv->mac_dev = mac_dev;
    8022933
    803         channel = dpa_get_channel();
    804 
     2934        channel = dpaa_get_channel();
    8052935        if (channel < 0) {
     2936                dev_err(dev, "dpaa_get_channel() failed\n");
    8062937                err = channel;
    8072938                goto get_channel_failed;
     
    8102941        priv->channel = (u16)channel;
    8112942
    812 #ifndef __rtems__
    813         /* Start a thread that will walk the cpus with affine portals
     2943        /* Start a thread that will walk the CPUs with affine portals
    8142944         * and add this pool channel to each's dequeue mask.
    8152945         */
    816         kth = kthread_run(dpaa_eth_add_channel,
    817                           (void *)(unsigned long)priv->channel,
    818                           "dpaa_%p:%d", net_dev, priv->channel);
    819         if (!kth) {
    820                 err = -ENOMEM;
    821                 goto add_channel_failed;
    822         }
    823 #else /* __rtems__ */
    824         dpaa_eth_add_channel((void *)(unsigned long)priv->channel);
    825 #endif /* __rtems__ */
    826 
    827         dpa_fq_setup(priv, &private_fq_cbs, priv->mac_dev->port[TX]);
     2946        dpaa_eth_add_channel(priv->channel);
     2947
     2948        dpaa_fq_setup(priv, &dpaa_fq_cbs, priv->mac_dev->port[TX]);
    8282949
    8292950        /* Create a congestion group for this netdev, with
     
    8372958                goto tx_cgr_init_failed;
    8382959        }
    839         err = dpaa_eth_priv_ingress_cgr_init(priv);
     2960
     2961        err = dpaa_ingress_cgr_init(priv);
    8402962        if (err < 0) {
    8412963                dev_err(dev, "Error initializing ingress CGR\n");
     
    8442966
    8452967        /* Add the FQs to the interface, and make them active */
    846         list_for_each_entry_safe(dpa_fq, tmp, &priv->dpa_fq_list, list) {
    847                 err = dpa_fq_init(dpa_fq, false);
     2968        list_for_each_entry_safe(dpaa_fq, tmp, &priv->dpaa_fq_list, list) {
     2969                err = dpaa_fq_init(dpaa_fq, false);
    8482970                if (err < 0)
    8492971                        goto fq_alloc_failed;
    8502972        }
    8512973
    852         priv->buf_layout = buf_layout;
    853         priv->tx_headroom = dpa_get_headroom(&priv->buf_layout[TX]);
    854         priv->rx_headroom = dpa_get_headroom(&priv->buf_layout[RX]);
     2974        priv->tx_headroom = dpaa_get_headroom(&priv->buf_layout[TX]);
     2975        priv->rx_headroom = dpaa_get_headroom(&priv->buf_layout[RX]);
    8552976
    8562977        /* All real interfaces need their ports initialized */
    857         dpaa_eth_init_ports(mac_dev, dpa_bp, count, &port_fqs,
    858                             buf_layout, dev);
     2978        dpaa_eth_init_ports(mac_dev, dpaa_bps, DPAA_BPS_NUM, &port_fqs,
     2979                            &priv->buf_layout[0], dev);
    8592980
    8602981        priv->percpu_priv = devm_alloc_percpu(dev, *priv->percpu_priv);
    861 
    8622982        if (!priv->percpu_priv) {
    8632983                dev_err(dev, "devm_alloc_percpu() failed\n");
     
    8742994        }
    8752995
     2996#ifndef __rtems__
    8762997        /* Initialize NAPI */
    877         err = dpa_private_napi_add(net_dev);
    878 
     2998        err = dpaa_napi_add(net_dev);
    8792999        if (err < 0)
    8803000                goto napi_add_failed;
    8813001
    882         err = dpa_private_netdev_init(net_dev);
    883 
     3002        err = dpaa_netdev_init(net_dev, &dpaa_ops, tx_timeout);
    8843003        if (err < 0)
    8853004                goto netdev_init_failed;
    8863005
    887 #ifndef __rtems__
    8883006        dpaa_eth_sysfs_init(&net_dev->dev);
    8893007
    890         pr_info("Probed interface %s\n", net_dev->name);
     3008        netif_info(priv, probe, net_dev, "Probed interface %s\n",
     3009                   net_dev->name);
    8913010#endif /* __rtems__ */
    8923011
    8933012        return 0;
    8943013
     3014#ifndef __rtems__
    8953015netdev_init_failed:
    8963016napi_add_failed:
    897         dpa_private_napi_del(net_dev);
     3017#endif /* __rtems__ */
     3018        dpaa_napi_del(net_dev);
    8983019alloc_percpu_failed:
    8993020#ifndef __rtems__
    900         dpa_fq_free(dev, &priv->dpa_fq_list);
     3021        dpaa_fq_free(dev, &priv->dpaa_fq_list);
    9013022#endif /* __rtems__ */
    9023023fq_alloc_failed:
     
    9113032#endif /* __rtems__ */
    9123033tx_cgr_init_failed:
    913 #ifndef __rtems__
    914 add_channel_failed:
    915 #endif /* __rtems__ */
    9163034get_channel_failed:
    917         dpa_bp_free(priv);
     3035        dpaa_bps_free(priv);
    9183036bp_create_failed:
    9193037fq_probe_failed:
    920 alloc_failed:
    921 #ifndef __rtems__
     3038#ifndef __rtems__
     3039dev_mask_failed:
    9223040mac_probe_failed:
    9233041#endif /* __rtems__ */
     
    9263044        free_netdev(net_dev);
    9273045alloc_etherdev_mq_failed:
    928         if (atomic_read(&dpa_bp->refs) == 0)
    929                 devm_kfree(dev, dpa_bp);
     3046        for (i = 0; i < DPAA_BPS_NUM && dpaa_bps[i]; i++) {
     3047                if (atomic_read(&dpaa_bps[i]->refs) == 0)
     3048                        devm_kfree(dev, dpaa_bps[i]);
     3049        }
    9303050#else /* __rtems__ */
    9313051        BSD_ASSERT(0);
    9323052#endif /* __rtems__ */
    933 
    9343053        return err;
    9353054}
    9363055
    9373056#ifndef __rtems__
    938 static struct platform_device_id dpa_devtype[] = {
     3057static int dpaa_remove(struct platform_device *pdev)
     3058{
     3059        struct net_device *net_dev;
     3060        struct dpaa_priv *priv;
     3061        struct device *dev;
     3062        int err;
     3063
     3064        dev = &pdev->dev;
     3065        net_dev = dev_get_drvdata(dev);
     3066
     3067        priv = netdev_priv(net_dev);
     3068
     3069        dpaa_eth_sysfs_remove(dev);
     3070
     3071        dev_set_drvdata(dev, NULL);
     3072        unregister_netdev(net_dev);
     3073
     3074        err = dpaa_fq_free(dev, &priv->dpaa_fq_list);
     3075
     3076        qman_delete_cgr_safe(&priv->ingress_cgr);
     3077        qman_release_cgrid(priv->ingress_cgr.cgrid);
     3078        qman_delete_cgr_safe(&priv->cgr_data.cgr);
     3079        qman_release_cgrid(priv->cgr_data.cgr.cgrid);
     3080
     3081        dpaa_napi_del(net_dev);
     3082
     3083        dpaa_bps_free(priv);
     3084
     3085        free_netdev(net_dev);
     3086
     3087        return err;
     3088}
     3089#endif /* __rtems__ */
     3090
     3091#ifndef __rtems__
     3092static struct platform_device_id dpaa_devtype[] = {
    9393093        {
    9403094                .name = "dpaa-ethernet",
     
    9433097        }
    9443098};
    945 MODULE_DEVICE_TABLE(platform, dpa_devtype);
    946 
    947 static struct platform_driver dpa_driver = {
     3099MODULE_DEVICE_TABLE(platform, dpaa_devtype);
     3100
     3101static struct platform_driver dpaa_driver = {
    9483102        .driver = {
    9493103                .name = KBUILD_MODNAME,
    9503104        },
    951         .id_table = dpa_devtype,
    952         .probe = dpaa_eth_priv_probe,
    953         .remove = dpa_remove
     3105        .id_table = dpaa_devtype,
     3106        .probe = dpaa_eth_probe,
     3107        .remove = dpaa_remove
    9543108};
    9553109
    956 static int __init dpa_load(void)
     3110static int __init dpaa_load(void)
    9573111{
    9583112        int err;
    9593113
    960         pr_info(DPA_DESCRIPTION "\n");
    961 
    962         /* initialise dpaa_eth mirror values */
    963         dpa_rx_extra_headroom = fman_get_rx_extra_headroom();
    964         dpa_max_frm = fman_get_max_frm();
    965 
    966         err = platform_driver_register(&dpa_driver);
     3114        pr_debug("FSL DPAA Ethernet driver\n");
     3115
     3116        /* initialize dpaa_eth mirror values */
     3117        dpaa_rx_extra_headroom = fman_get_rx_extra_headroom();
     3118        dpaa_max_frm = fman_get_max_frm();
     3119
     3120        err = platform_driver_register(&dpaa_driver);
    9673121        if (err < 0)
    9683122                pr_err("Error, platform_driver_register() = %d\n", err);
     
    9703124        return err;
    9713125}
    972 module_init(dpa_load);
    973 
    974 static void __exit dpa_unload(void)
    975 {
    976         platform_driver_unregister(&dpa_driver);
    977 
    978         /* Only one channel is used and needs to be relased after all
     3126module_init(dpaa_load);
     3127
     3128static void __exit dpaa_unload(void)
     3129{
     3130        platform_driver_unregister(&dpaa_driver);
     3131
     3132        /* Only one channel is used and needs to be released after all
    9793133         * interfaces are removed
    9803134         */
    981         dpa_release_channel();
    982 }
    983 module_exit(dpa_unload);
     3135        dpaa_release_channel();
     3136}
     3137module_exit(dpaa_unload);
    9843138
    9853139MODULE_LICENSE("Dual BSD/GPL");
    986 MODULE_AUTHOR("Andy Fleming <afleming@freescale.com>");
    987 MODULE_DESCRIPTION(DPA_DESCRIPTION);
    988 #endif /* __rtems__ */
     3140MODULE_DESCRIPTION("FSL DPAA Ethernet driver");
     3141#endif /* __rtems__ */
  • linux/drivers/net/ethernet/freescale/dpaa/dpaa_eth.h

    r28ee86a rcd089b9  
    1 /* Copyright 2008 - 2015 Freescale Semiconductor Inc.
     1/* Copyright 2008 - 2016 Freescale Semiconductor Inc.
    22 *
    33 * Redistribution and use in source and binary forms, with or without
     
    2929 */
    3030
    31 #ifndef __DPA_H
    32 #define __DPA_H
     31#ifndef __DPAA_H
     32#define __DPAA_H
    3333
    3434#include <linux/netdevice.h>
    3535#include <soc/fsl/qman.h>
     36#include <soc/fsl/bman.h>
    3637
    3738#include "fman.h"
     
    3940#include "dpaa_eth_trace.h"
    4041
    41 #ifndef __rtems__
    42 extern int dpa_rx_extra_headroom;
    43 extern int dpa_max_frm;
    44 
    45 #define dpa_get_rx_extra_headroom() dpa_rx_extra_headroom
    46 #define dpa_get_max_frm() dpa_max_frm
     42#define DPAA_ETH_TXQ_NUM        NR_CPUS
     43
     44#ifndef __rtems__
     45#define DPAA_BPS_NUM 3 /* number of bpools per interface */
    4746#else /* __rtems__ */
    48 #define dpa_get_rx_extra_headroom fman_get_rx_extra_headroom
    49 #define dpa_get_max_frm fman_get_max_frm
    50 #endif /* __rtems__ */
    51 
    52 #define dpa_get_max_mtu()       \
    53         (dpa_get_max_frm() - (VLAN_ETH_HLEN + ETH_FCS_LEN))
    54 
    55 /* Simple enum of FQ types - used for array indexing */
    56 enum port_type {RX, TX};
    57 
    58 struct dpa_buffer_layout_s {
    59         u16 priv_data_size;
    60         bool parse_results;
    61         bool time_stamp;
    62         bool hash_results;
    63         u16 data_align;
    64 };
    65 
    66 #define DPA_ERR_ON(cond)
    67 
    68 #define DPA_TX_PRIV_DATA_SIZE   16
    69 #define DPA_PARSE_RESULTS_SIZE sizeof(struct fman_prs_result)
    70 #define DPA_TIME_STAMP_SIZE 8
    71 #define DPA_HASH_RESULTS_SIZE 8
    72 #define DPA_RX_PRIV_DATA_SIZE   (DPA_TX_PRIV_DATA_SIZE + \
    73                                         dpa_get_rx_extra_headroom())
    74 
    75 #define FM_FD_STAT_RX_ERRORS                                            \
    76         (FM_FD_ERR_DMA | FM_FD_ERR_PHYSICAL     | \
    77          FM_FD_ERR_SIZE | FM_FD_ERR_CLS_DISCARD | \
    78          FM_FD_ERR_EXTRACTION | FM_FD_ERR_NO_SCHEME     | \
    79          FM_FD_ERR_PRS_TIMEOUT | FM_FD_ERR_PRS_ILL_INSTRUCT | \
    80          FM_FD_ERR_PRS_HDR_ERR)
    81 
    82 #define FM_FD_STAT_TX_ERRORS \
    83         (FM_FD_ERR_UNSUPPORTED_FORMAT | \
    84          FM_FD_ERR_LENGTH | FM_FD_ERR_DMA)
    85 
    86 /* The raw buffer size must be cacheline aligned.
    87  * Normally we use 2K buffers.
    88  */
    89 #define DPA_BP_RAW_SIZE         2048
    90 
    91 /* This is what FMan is ever allowed to use.
    92  * FMan-DMA requires 16-byte alignment for Rx buffers, but SKB_DATA_ALIGN is
    93  * even stronger (SMP_CACHE_BYTES-aligned), so we just get away with that,
    94  * via SKB_WITH_OVERHEAD(). We can't rely on netdev_alloc_frag() giving us
    95  * half-page-aligned buffers (can we?), so we reserve some more space
    96  * for start-of-buffer alignment.
    97  */
    98 #ifndef __rtems__
    99 #define dpa_bp_size(buffer_layout)      (SKB_WITH_OVERHEAD(DPA_BP_RAW_SIZE) - \
    100                                                 SMP_CACHE_BYTES)
    101 #else /* __rtems__ */
    102 /*
    103  * FIXME: 4 bytes would be enough for the mbuf pointer.  However, jumbo receive
    104  * frames overwrite this area if < 64 bytes.
    105  */
    106 #define DPA_OUT_OF_BAND_SIZE 64
    107 #define DPA_MBUF_POINTER_OFFSET (DPA_BP_RAW_SIZE - DPA_OUT_OF_BAND_SIZE)
    108 #define dpa_bp_size(buffer_layout) DPA_MBUF_POINTER_OFFSET
    109 #endif /* __rtems__ */
    110 /* We must ensure that skb_shinfo is always cacheline-aligned. */
    111 #define DPA_SKB_SIZE(size)      ((size) & ~(SMP_CACHE_BYTES - 1))
    112 
    113 /* Largest value that the FQD's OAL field can hold.
    114  * This is DPAA-1.x specific.
    115  */
    116 #define FSL_QMAN_MAX_OAL        127
    117 
    118 /* Default alignment for start of data in an Rx FD */
    119 #define DPA_FD_DATA_ALIGNMENT  16
    120 
    121 /* Values for the L3R field of the FM Parse Results
    122  */
    123 /* L3 Type field: First IP Present IPv4 */
    124 #define FM_L3_PARSE_RESULT_IPV4 0x8000
    125 /* L3 Type field: First IP Present IPv6 */
    126 #define FM_L3_PARSE_RESULT_IPV6 0x4000
    127 
    128 /* Values for the L4R field of the FM Parse Results
    129  * See $8.8.4.7.20 - L4 HXS - L4 Results from DPAA-Rev2 Reference Manual.
    130  */
    131 /* L4 Type field: UDP */
    132 #define FM_L4_PARSE_RESULT_UDP  0x40
    133 /* L4 Type field: TCP */
    134 #define FM_L4_PARSE_RESULT_TCP  0x20
    135 
    136 /* number of Tx queues to FMan */
    137 #define DPAA_ETH_TX_QUEUES      NR_CPUS
    138 
    139 #define DPAA_ETH_RX_QUEUES      128
    140 
    141 #define FSL_DPAA_ETH_MAX_BUF_COUNT      128
    142 #define FSL_DPAA_ETH_REFILL_THRESHOLD   80
     47#define DPAA_BPS_NUM 1
     48#endif /* __rtems__ */
    14349
    14450/* More detailed FQ types - used for fine-grained WQ assignments */
    145 enum dpa_fq_type {
     51enum dpaa_fq_type {
    14652        FQ_TYPE_RX_DEFAULT = 1, /* Rx Default FQs */
    14753        FQ_TYPE_RX_ERROR,       /* Rx Error FQs */
    148         FQ_TYPE_RX_PCD,         /* User-defined PCDs */
    14954        FQ_TYPE_TX,             /* "Real" Tx FQs */
    15055        FQ_TYPE_TX_CONFIRM,     /* Tx default Conf FQ (actually an Rx FQ) */
     
    15358};
    15459
    155 struct dpa_fq {
     60struct dpaa_fq {
    15661        struct qman_fq fq_base;
    15762        struct list_head list;
     
    16267        u16 channel;
    16368        u8 wq;
    164         enum dpa_fq_type fq_type;
    165 };
    166 
    167 struct dpa_fq_cbs_t {
     69        enum dpaa_fq_type fq_type;
     70};
     71
     72struct dpaa_fq_cbs {
    16873        struct qman_fq rx_defq;
    16974        struct qman_fq tx_defq;
     
    17378};
    17479
    175 struct fqid_cell {
    176         u32 start;
    177         u32 count;
    178 };
    179 
    180 struct dpa_bp {
     80struct dpaa_bp {
     81        /* device used in the DMA mapping operations */
     82        struct device *dev;
     83        /* current number of buffers in the buffer pool alloted to each CPU */
     84        int __percpu *percpu_count;
     85        /* all buffers allocated for this pool have this raw size */
     86        size_t raw_size;
     87        /* all buffers in this pool have this same usable size */
     88        size_t size;
     89        /* the buffer pools are initialized with config_count buffers for each
     90         * CPU; at runtime the number of buffers per CPU is constantly brought
     91         * back to this level
     92         */
     93        u16 config_count;
     94        u8 bpid;
    18195        struct bman_pool *pool;
    182         u8 bpid;
    183 #ifndef __rtems__
    184         struct device *dev;
    185 #endif /* __rtems__ */
    186         /* the buffer pools used for the private ports are initialized
    187          * with config_count buffers for each CPU; at runtime the
    188          * number of buffers per CPU is constantly brought back to this
    189          * level
    190          */
    191         int config_count;
    192         size_t size;
    193         bool seed_pool;
    194         /* physical address of the contiguous memory used by the pool to store
    195          * the buffers
    196          */
    197         dma_addr_t paddr;
    198         /* virtual address of the contiguous memory used by the pool to store
    199          * the buffers
    200          */
    201         void __iomem *vaddr;
    202         /* current number of buffers in the bpool alloted to this CPU */
    203         int __percpu *percpu_count;
     96        /* bpool can be seeded before use by this cb */
     97        int (*seed_cb)(struct dpaa_bp *);
     98        /* bpool can be emptied before freeing by this cb */
     99        void (*free_buf_cb)(const struct dpaa_bp *, struct bm_buffer *);
    204100        atomic_t refs;
    205         /* some bpools need to be seeded before use by this cb */
    206         int (*seed_cb)(struct dpa_bp *);
    207         /* some bpools need to be emptied before freeing; this cb is used
    208          * for freeing of individual buffers taken from the pool
    209          */
    210         void (*free_buf_cb)(void *addr);
    211 };
    212 
    213 struct dpa_rx_errors {
     101};
     102
     103struct dpaa_rx_errors {
    214104        u64 dme;                /* DMA Error */
    215105        u64 fpe;                /* Frame Physical Error */
     
    219109
    220110/* Counters for QMan ERN frames - one counter per rejection code */
    221 struct dpa_ern_cnt {
     111struct dpaa_ern_cnt {
    222112        u64 cg_tdrop;           /* Congestion group taildrop */
    223113        u64 wred;               /* WRED congestion */
     
    230120};
    231121
    232 struct dpa_napi_portal {
     122struct dpaa_napi_portal {
    233123#ifndef __rtems__
    234124        struct napi_struct napi;
    235125#endif /* __rtems__ */
    236126        struct qman_portal *p;
    237 };
    238 
    239 struct dpa_percpu_priv_s {
     127        bool down;
     128};
     129
     130struct dpaa_percpu_priv {
    240131        struct net_device *net_dev;
    241         struct dpa_napi_portal *np;
     132        struct dpaa_napi_portal np;
    242133        u64 in_interrupt;
    243134        u64 tx_confirm;
     
    247138        struct rtnl_link_stats64 stats;
    248139#endif /* __rtems__ */
    249         struct dpa_rx_errors rx_errors;
    250         struct dpa_ern_cnt ern_cnt;
    251 };
    252 
    253 struct dpa_priv_s {
    254         struct dpa_percpu_priv_s __percpu *percpu_priv;
    255         struct dpa_bp *dpa_bp;
     140        struct dpaa_rx_errors rx_errors;
     141        struct dpaa_ern_cnt ern_cnt;
     142};
     143
     144struct dpaa_buffer_layout {
     145        u16 priv_data_size;
     146};
     147
     148struct dpaa_priv {
     149        struct dpaa_percpu_priv __percpu *percpu_priv;
     150        struct dpaa_bp *dpaa_bps[DPAA_BPS_NUM];
    256151        /* Store here the needed Tx headroom for convenience and speed
    257152         * (even though it can be computed based on the fields of buf_layout)
     
    260155        struct net_device *net_dev;
    261156        struct mac_device *mac_dev;
    262         struct qman_fq *egress_fqs[DPAA_ETH_TX_QUEUES];
    263         struct qman_fq *conf_fqs[DPAA_ETH_TX_QUEUES];
    264 
    265         size_t bp_count;
    266 
    267         u16 channel;    /* "fsl,qman-channel-id" */
    268         struct list_head dpa_fq_list;
     157        struct qman_fq *egress_fqs[DPAA_ETH_TXQ_NUM];
     158        struct qman_fq *conf_fqs[DPAA_ETH_TXQ_NUM];
     159
     160        u16 channel;
     161        struct list_head dpaa_fq_list;
    269162
    270163#ifndef __rtems__
     
    290183        struct qman_cgr ingress_cgr;
    291184
    292         struct dpa_buffer_layout_s *buf_layout;
     185        struct dpaa_buffer_layout buf_layout[2];
    293186        u16 rx_headroom;
    294187};
    295188
    296 struct fm_port_fqs {
    297         struct dpa_fq *tx_defq;
    298         struct dpa_fq *tx_errq;
    299         struct dpa_fq *rx_defq;
    300         struct dpa_fq *rx_errq;
    301 };
    302 
    303 int dpa_bp_priv_seed(struct dpa_bp *dpa_bp);
    304 int dpaa_eth_refill_bpools(struct dpa_bp *dpa_bp, int *count_ptr);
    305 void _dpa_rx(struct net_device *net_dev,
    306              struct qman_portal *portal,
    307              const struct dpa_priv_s *priv,
    308              struct dpa_percpu_priv_s *percpu_priv,
    309              const struct qm_fd *fd,
    310              u32 fqid,
    311              int *count_ptr);
    312 #ifndef __rtems__
    313 int dpa_tx(struct sk_buff *skb, struct net_device *net_dev);
    314 struct sk_buff *_dpa_cleanup_tx_fd(const struct dpa_priv_s *priv,
    315                                    const struct qm_fd *fd);
    316 
    317 /* Turn on HW checksum computation for this outgoing frame.
    318  * If the current protocol is not something we support in this regard
    319  * (or if the stack has already computed the SW checksum), we do nothing.
    320  *
    321  * Returns 0 if all goes well (or HW csum doesn't apply), and a negative value
    322  * otherwise.
    323  *
    324  * Note that this function may modify the fd->cmd field and the skb data buffer
    325  * (the Parse Results area).
    326  */
    327 int dpa_enable_tx_csum(struct dpa_priv_s *priv, struct sk_buff *skb,
    328                        struct qm_fd *fd, char *parse_results);
    329 #else /* __rtems__ */
    330 void _dpa_cleanup_tx_fd(struct ifnet *ifp, const struct qm_fd *fd);
    331 #endif /* __rtems__ */
    332 
    333 static inline int dpaa_eth_napi_schedule(struct dpa_percpu_priv_s *percpu_priv,
    334                                          struct qman_portal *portal)
    335 {
    336 #ifndef __rtems__
    337         /* In case of threaded ISR for RT enable kernel,
    338          * in_irq() does not return appropriate value, so use
    339          * in_serving_softirq to distinguish softirq or irq context.
    340          */
    341         if (unlikely(in_irq() || !in_serving_softirq())) {
    342                 /* Disable QMan IRQ and invoke NAPI */
    343                 int ret = qman_p_irqsource_remove(portal, QM_PIRQ_DQRI);
    344 
    345                 if (likely(!ret)) {
    346                         const struct qman_portal_config *pc =
    347                                         qman_p_get_portal_config(portal);
    348                         struct dpa_napi_portal *np =
    349                                         &percpu_priv->np[pc->channel];
    350 
    351                         np->p = portal;
    352                         napi_schedule(&np->napi);
    353                         percpu_priv->in_interrupt++;
    354                         return 1;
    355                 }
    356         }
    357 #else /* __rtems__ */
    358         /* FIXME */
    359 #endif /* __rtems__ */
    360         return 0;
    361 }
    362 
    363 static inline ssize_t __const dpa_fd_length(const struct qm_fd *fd)
    364 {
    365         return fd->length20;
    366 }
    367 
    368 static inline ssize_t __const dpa_fd_offset(const struct qm_fd *fd)
    369 {
    370         return fd->offset;
    371 }
    372 
    373 #ifndef __rtems__
    374 /* Verifies if the skb length is below the interface MTU */
    375 static inline int dpa_check_rx_mtu(struct sk_buff *skb, int mtu)
    376 {
    377         if (unlikely(skb->len > mtu))
    378                 if ((skb->protocol != htons(ETH_P_8021Q)) ||
    379                     (skb->len > mtu + 4))
    380                         return -1;
    381 
    382         return 0;
    383 }
    384 #endif /* __rtems__ */
    385 
    386 static inline u16 dpa_get_headroom(struct dpa_buffer_layout_s *bl)
    387 {
    388         u16 headroom;
    389         /* The frame headroom must accommodate:
    390          * - the driver private data area
    391          * - parse results, hash results, timestamp if selected
    392          * If either hash results or time stamp are selected, both will
    393          * be copied to/from the frame headroom, as TS is located between PR and
    394          * HR in the IC and IC copy size has a granularity of 16bytes
    395          * (see description of FMBM_RICP and FMBM_TICP registers in DPAARM)
    396          *
    397          * Also make sure the headroom is a multiple of data_align bytes
    398          */
    399         headroom = (u16)(bl->priv_data_size +
    400                    (bl->parse_results ? DPA_PARSE_RESULTS_SIZE : 0) +
    401                    (bl->hash_results || bl->time_stamp ?
    402                     DPA_TIME_STAMP_SIZE + DPA_HASH_RESULTS_SIZE : 0));
    403 
    404         return bl->data_align ? ALIGN(headroom, bl->data_align) : headroom;
    405 }
    406 
    407 #ifndef __rtems__
     189/* from dpaa_ethtool.c */
     190extern const struct ethtool_ops dpaa_ethtool_ops;
     191
     192/* from dpaa_eth_sysfs.c */
    408193void dpaa_eth_sysfs_remove(struct device *dev);
    409194void dpaa_eth_sysfs_init(struct device *dev);
    410 
    411 void dpa_private_napi_del(struct net_device *net_dev);
    412 #endif /* __rtems__ */
    413 
    414 static inline void clear_fd(struct qm_fd *fd)
    415 {
    416         fd->opaque_addr = 0;
    417         fd->opaque = 0;
    418         fd->cmd = 0;
    419 }
    420 
    421 static inline int _dpa_tx_fq_to_id(const struct dpa_priv_s *priv,
    422                 struct qman_fq *tx_fq)
    423 {
    424         int i;
    425 
    426         for (i = 0; i < DPAA_ETH_TX_QUEUES; i++)
    427                 if (priv->egress_fqs[i] == tx_fq)
    428                         return i;
    429 
    430         return -EINVAL;
    431 }
    432 
    433 #ifndef __rtems__
    434 static inline int dpa_xmit(struct dpa_priv_s *priv,
    435                            struct rtnl_link_stats64 *percpu_stats,
    436                            int queue,
    437                            struct qm_fd *fd)
    438 {
    439         int err, i;
    440         struct qman_fq *egress_fq;
    441 
    442         egress_fq = priv->egress_fqs[queue];
    443         if (fd->bpid == 0xff)
    444                 fd->cmd |= qman_fq_fqid(priv->conf_fqs[queue]);
    445 
    446         /* Trace this Tx fd */
    447         trace_dpa_tx_fd(priv->net_dev, egress_fq, fd);
    448 
    449         for (i = 0; i < 100000; i++) {
    450                 err = qman_enqueue(egress_fq, fd, 0);
    451                 if (err != -EBUSY)
    452                         break;
    453         }
    454 
    455         if (unlikely(err < 0)) {
    456                 percpu_stats->tx_errors++;
    457                 percpu_stats->tx_fifo_errors++;
    458                 return err;
    459         }
    460 
    461         percpu_stats->tx_packets++;
    462         percpu_stats->tx_bytes += dpa_fd_length(fd);
    463 
    464         return 0;
    465 }
    466 #endif /* __rtems__ */
    467 
    468 /* Use multiple WQs for FQ assignment:
    469  *      - Tx Confirmation queues go to WQ1.
    470  *      - Rx Default and Tx queues go to WQ3 (no differentiation between
    471  *        Rx and Tx traffic).
    472  *      - Rx Error and Tx Error queues go to WQ2 (giving them a better chance
    473  *        to be scheduled, in case there are many more FQs in WQ3).
    474  * This ensures that Tx-confirmed buffers are timely released. In particular,
    475  * it avoids congestion on the Tx Confirm FQs, which can pile up PFDRs if they
    476  * are greatly outnumbered by other FQs in the system, while
    477  * dequeue scheduling is round-robin.
    478  */
    479 static inline void _dpa_assign_wq(struct dpa_fq *fq)
    480 {
    481         switch (fq->fq_type) {
    482         case FQ_TYPE_TX_CONFIRM:
    483         case FQ_TYPE_TX_CONF_MQ:
    484                 fq->wq = 1;
    485                 break;
    486         case FQ_TYPE_RX_DEFAULT:
    487         case FQ_TYPE_TX:
    488                 fq->wq = 3;
    489                 break;
    490         case FQ_TYPE_RX_ERROR:
    491         case FQ_TYPE_TX_ERROR:
    492                 fq->wq = 2;
    493                 break;
    494         default:
    495                 WARN(1, "Invalid FQ type %d for FQID %d!\n",
    496                      fq->fq_type, fq->fqid);
    497         }
    498 }
    499 
    500 #ifdef CONFIG_FSL_DPAA_ETH_USE_NDO_SELECT_QUEUE
    501 /* Use in lieu of skb_get_queue_mapping() */
    502 #define dpa_get_queue_mapping(skb) \
    503         raw_smp_processor_id()
    504 #else
    505 /* Use the queue selected by XPS */
    506 #define dpa_get_queue_mapping(skb) \
    507         skb_get_queue_mapping(skb)
    508 #endif
    509 
    510 static inline void _dpa_bp_free_pf(void *addr)
    511 {
    512 #ifndef __rtems__
    513         put_page(virt_to_head_page(addr));
    514 #else /* __rtems__ */
    515         BSD_ASSERT(0);
    516 #endif /* __rtems__ */
    517 }
    518 
    519 #endif  /* __DPA_H */
     195#ifdef __rtems__
     196#include <sys/mbuf.h>
     197
     198#define DPAA_ENQUEUE_RETRIES 100000
     199#define DPAA_SGT_MAX_ENTRIES 16
     200#define DPAA_TX_PRIV_DATA_SIZE 16
     201#define FM_L3_PARSE_RESULT_IPV4 0x8000
     202#define FM_L3_PARSE_RESULT_IPV6 0x4000
     203#define FM_L4_PARSE_RESULT_UDP 0x40
     204#define FM_L4_PARSE_RESULT_TCP 0x20
     205#define FSL_DPAA_BPID_INV 0xff
     206
     207void dpaa_cleanup_tx_fd(struct ifnet *ifp, const struct qm_fd *fd);
     208#endif /* __rtems__ */
     209#endif  /* __DPAA_H */
  • linux/drivers/net/ethernet/freescale/dpaa/dpaa_eth_trace.h

    r28ee86a rcd089b9  
    8181                __entry->fqid = fq->fqid;
    8282                __entry->fd_addr = qm_fd_addr_get64(fd);
    83                 __entry->fd_format = fd->format;
    84                 __entry->fd_offset = dpa_fd_offset(fd);
    85                 __entry->fd_length = dpa_fd_length(fd);
     83                __entry->fd_format = qm_fd_get_format(fd);
     84                __entry->fd_offset = qm_fd_get_offset(fd);
     85                __entry->fd_length = qm_fd_get_length(fd);
    8686                __entry->fd_status = fd->status;
    8787                __assign_str(name, netdev->name);
     
    100100
    101101/* Tx (egress) fd */
    102 DEFINE_EVENT(dpaa_eth_fd, dpa_tx_fd,
     102DEFINE_EVENT(dpaa_eth_fd, dpaa_tx_fd,
    103103
    104104        TP_PROTO(struct net_device *netdev,
     
    110110
    111111/* Rx fd */
    112 DEFINE_EVENT(dpaa_eth_fd, dpa_rx_fd,
     112DEFINE_EVENT(dpaa_eth_fd, dpaa_rx_fd,
    113113
    114114        TP_PROTO(struct net_device *netdev,
     
    120120
    121121/* Tx confirmation fd */
    122 DEFINE_EVENT(dpaa_eth_fd, dpa_tx_conf_fd,
     122DEFINE_EVENT(dpaa_eth_fd, dpaa_tx_conf_fd,
    123123
    124124        TP_PROTO(struct net_device *netdev,
  • linux/drivers/net/ethernet/freescale/fman/fman.c

    r28ee86a rcd089b9  
    1717 *       derived from this software without specific prior written permission.
    1818 *
    19 // *
     19 *
    2020 * ALTERNATIVELY, this software may be distributed under the terms of the
    2121 * GNU General Public License ("GPL") as published by the Free Software
     
    3939#include "fman.h"
    4040#include "fman_muram.h"
    41 #include <asm/mpc85xx.h>
    42 
     41
     42#include <linux/fsl/guts.h>
    4343#include <linux/slab.h>
    4444#include <linux/delay.h>
     
    4949#include <linux/of_irq.h>
    5050#include <linux/interrupt.h>
     51#include <linux/libfdt_env.h>
    5152#ifdef __rtems__
    5253#include <bsp/fdt.h>
    5354#include <bsp/qoriq.h>
    5455#endif /* __rtems__ */
    55 
    5656
    5757/* General defines */
     
    8989#define EX_DMA_SINGLE_PORT_ECC          0x00008000
    9090
    91 #define DFLT_EXCEPTIONS \
    92          ((EX_DMA_BUS_ERROR)            | \
    93           (EX_DMA_READ_ECC)              | \
    94           (EX_DMA_SYSTEM_WRITE_ECC)      | \
    95           (EX_DMA_FM_WRITE_ECC)          | \
    96           (EX_FPM_STALL_ON_TASKS)        | \
    97           (EX_FPM_SINGLE_ECC)            | \
    98           (EX_FPM_DOUBLE_ECC)            | \
    99           (EX_QMI_DEQ_FROM_UNKNOWN_PORTID) | \
    100           (EX_BMI_LIST_RAM_ECC)          | \
    101           (EX_BMI_STORAGE_PROFILE_ECC)   | \
    102           (EX_BMI_STATISTICS_RAM_ECC)    | \
    103           (EX_MURAM_ECC)                 | \
    104           (EX_BMI_DISPATCH_RAM_ECC)      | \
    105           (EX_QMI_DOUBLE_ECC)            | \
    106           (EX_QMI_SINGLE_ECC))
    107 
    10891/* DMA defines */
    10992/* masks */
    110 #define DMA_MODE_AID_OR                 0x20000000
    111 #define DMA_MODE_SBER                   0x10000000
    11293#define DMA_MODE_BER                    0x00200000
    11394#define DMA_MODE_ECC                    0x00000020
    11495#define DMA_MODE_SECURE_PROT            0x00000800
    115 #define DMA_MODE_EMER_READ              0x00080000
    11696#define DMA_MODE_AXI_DBG_MASK           0x0F000000
    11797
     
    131111#define DMA_MODE_CEN_MASK                       0x00000007
    132112#define DMA_MODE_DBG_SHIFT                      7
    133 #define DMA_MODE_EMER_LVL_SHIFT         6
    134113#define DMA_MODE_AID_MODE_SHIFT         4
    135114
     
    161140#define FPM_RAM_MURAM_ECC               0x00008000
    162141#define FPM_RAM_IRAM_ECC                0x00004000
    163 #define FPM_RAM_MURAM_TEST_ECC          0x20000000
    164 #define FPM_RAM_IRAM_TEST_ECC           0x10000000
    165142#define FPM_IRAM_ECC_ERR_EX_EN          0x00020000
    166143#define FPM_MURAM_ECC_ERR_EX_EN 0x00040000
     
    248225#define QMI_INTR_EN_SINGLE_ECC          0x80000000
    249226
    250 #define QMI_TAPC_TAP                    22
    251 
    252227#define QMI_GS_HALT_NOT_BUSY            0x00000002
    253228
     
    267242#define DEFAULT_DMA_SOS_EMERGENCY               0
    268243#define DEFAULT_DMA_WATCHDOG                    0
    269 #define DEFAULT_DMA_EMERGENCY_SWITCH_COUNTER    0
    270244#define DEFAULT_DISP_LIMIT                      0
    271245#define DEFAULT_PRS_DISP_TH                     16
     
    510484};
    511485
    512 struct fman_rg {
    513         struct fman_fpm_regs __iomem *fpm_rg;
    514         struct fman_dma_regs __iomem *dma_rg;
    515         struct fman_bmi_regs __iomem *bmi_rg;
    516         struct fman_qmi_regs __iomem *qmi_rg;
    517 };
    518 
     486/* Structure that holds current FMan state.
     487 * Used for saving run time information.
     488 */
    519489struct fman_state_struct {
    520490        u8 fm_id;
     
    528498        u8 accumulated_num_of_open_dmas;
    529499        u8 accumulated_num_of_deq_tnums;
    530         bool low_end_restriction;
    531500        u32 exceptions;
    532501        u32 extra_fifo_pool_size;
     
    559528};
    560529
     530/* Structure that holds FMan initial configuration */
    561531struct fman_cfg {
    562532        u8 disp_limit_tsh;
     
    571541        int dma_cache_override;
    572542        enum fman_dma_aid_mode dma_aid_mode;
    573         bool dma_aid_override;
    574543        u32 dma_axi_dbg_num_of_beats;
    575544        u32 dma_cam_num_of_entries;
     
    583552        u32 dma_sos_emergency;
    584553        int dma_dbg_cnt_mode;
    585         bool dma_stop_on_bus_error;
    586         bool dma_en_emergency;
    587         u32 dma_emergency_bus_select;
    588         int dma_emergency_level;
    589         bool dma_en_emergency_smoother;
    590         u32 dma_emergency_switch_counter;
    591         bool halt_on_external_activ;
    592         bool halt_on_unrecov_ecc_err;
    593554        int catastrophic_err;
    594555        int dma_err;
    595         bool en_muram_test_mode;
    596         bool en_iram_test_mode;
    597         bool external_ecc_rams_enable;
    598         u16 tnum_aging_period;
    599556        u32 exceptions;
    600557        u16 clk_freq;
    601         bool pedantic_dma;
    602558        u32 cam_base_addr;
    603559        u32 fifo_base_addr;
    604560        u32 total_fifo_size;
    605561        u32 total_num_of_tasks;
    606         bool qmi_deq_option_support;
    607562        u32 qmi_def_tnums_thresh;
    608563};
    609564
     565/* Structure that holds information received from device tree */
    610566struct fman_dts_params {
    611567        void __iomem *base_addr;                /* FMan virtual address */
     
    622578        u32 num_of_qman_channels;               /* Number of QMan channels */
    623579
    624         phys_addr_t muram_phy_base_addr;        /* MURAM physical address */
    625         resource_size_t muram_size;             /* MURAM size */
     580        struct resource muram_res;              /* MURAM resource */
    626581};
     582
     583/** fman_exceptions_cb
     584 * fman         - Pointer to FMan
     585 * exception    - The exception.
     586 *
     587 * Exceptions user callback routine, will be called upon an exception
     588 * passing the exception identification.
     589 *
     590 * Return: irq status
     591 */
     592typedef irqreturn_t (fman_exceptions_cb)(struct fman *fman,
     593                                         enum fman_exceptions exception);
     594
     595/** fman_bus_error_cb
     596 * fman         - Pointer to FMan
     597 * port_id      - Port id
     598 * addr         - Address that caused the error
     599 * tnum         - Owner of error
     600 * liodn        - Logical IO device number
     601 *
     602 * Bus error user callback routine, will be called upon bus error,
     603 * passing parameters describing the errors and the owner.
     604 *
     605 * Return: IRQ status
     606 */
     607typedef irqreturn_t (fman_bus_error_cb)(struct fman *fman, u8 port_id,
     608                                        u64 addr, u8 tnum, u16 liodn);
    627609
    628610struct fman {
     
    644626        struct muram_info *muram;
    645627        /* cam section in muram */
    646         int cam_offset;
     628        unsigned long cam_offset;
    647629        size_t cam_size;
    648630        /* Fifo in MURAM */
    649         int fifo_offset;
     631        unsigned long fifo_offset;
    650632        size_t fifo_size;
    651         bool reset_on_init;
    652633
    653634        u32 liodn_base[64];
     
    657638};
    658639
    659 static void fman_exceptions(struct fman *fman, enum fman_exceptions exception)
    660 {
    661         pr_debug("FMan[%d] exception %d\n",
    662                  fman->state->fm_id, exception);
    663 }
    664 
    665 static void fman_bus_error(struct fman *fman, u8 __maybe_unused port_id,
    666                            u64 __maybe_unused addr, u8 __maybe_unused tnum,
    667                            u16 __maybe_unused liodn)
    668 {
    669         pr_debug("FMan[%d] bus error: port_id[%d]\n",
    670                  fman->state->fm_id, port_id);
    671 }
    672 
    673 static inline void call_mac_isr(struct fman *fman, u8 id)
    674 {
    675         if (fman->intr_mng[id].isr_cb)
     640static irqreturn_t fman_exceptions(struct fman *fman,
     641                                   enum fman_exceptions exception)
     642{
     643        dev_dbg(fman->dev, "%s: FMan[%d] exception %d\n",
     644                __func__, fman->state->fm_id, exception);
     645
     646        return IRQ_HANDLED;
     647}
     648
     649static irqreturn_t fman_bus_error(struct fman *fman, u8 __maybe_unused port_id,
     650                                  u64 __maybe_unused addr,
     651                                  u8 __maybe_unused tnum,
     652                                  u16 __maybe_unused liodn)
     653{
     654        dev_dbg(fman->dev, "%s: FMan[%d] bus error: port_id[%d]\n",
     655                __func__, fman->state->fm_id, port_id);
     656
     657        return IRQ_HANDLED;
     658}
     659
     660static inline irqreturn_t call_mac_isr(struct fman *fman, u8 id)
     661{
     662        if (fman->intr_mng[id].isr_cb) {
    676663                fman->intr_mng[id].isr_cb(fman->intr_mng[id].src_handle);
     664
     665                return IRQ_HANDLED;
     666        }
     667
     668        return IRQ_NONE;
    677669}
    678670
     
    681673        u8 sw_port_id = 0;
    682674
    683         if (hw_port_id >= BASE_TX_PORTID) {
     675        if (hw_port_id >= BASE_TX_PORTID)
    684676                sw_port_id = hw_port_id - BASE_TX_PORTID;
    685         } else if (hw_port_id >= BASE_RX_PORTID) {
     677        else if (hw_port_id >= BASE_RX_PORTID)
    686678                sw_port_id = hw_port_id - BASE_RX_PORTID;
    687         } else {
     679        else
    688680                sw_port_id = 0;
    689                 WARN_ON(false);
    690         }
    691681
    692682        return sw_port_id;
     
    698688        u32 tmp = 0;
    699689
    700         tmp = (u32)(port_id << FPM_PORT_FM_CTL_PORTID_SHIFT);
    701 
    702         tmp |= (FPM_PRT_FM_CTL2 | FPM_PRT_FM_CTL1);
     690        tmp = port_id << FPM_PORT_FM_CTL_PORTID_SHIFT;
     691
     692        tmp |= FPM_PRT_FM_CTL2 | FPM_PRT_FM_CTL1;
    703693
    704694        /* order restoration */
    705695        if (port_id % 2)
    706                 tmp |= (FPM_PRT_FM_CTL1 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT);
     696                tmp |= FPM_PRT_FM_CTL1 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT;
    707697        else
    708                 tmp |= (FPM_PRT_FM_CTL2 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT);
     698                tmp |= FPM_PRT_FM_CTL2 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT;
    709699
    710700        iowrite32be(tmp, &fpm_rg->fmfp_prc);
    711701}
    712702
    713 static void set_port_liodn(struct fman_rg *fman_rg, u8 port_id,
     703static void set_port_liodn(struct fman *fman, u8 port_id,
    714704                           u32 liodn_base, u32 liodn_ofst)
    715705{
     
    717707
    718708        /* set LIODN base for this port */
    719         tmp = ioread32be(&fman_rg->dma_rg->fmdmplr[port_id / 2]);
     709        tmp = ioread32be(&fman->dma_regs->fmdmplr[port_id / 2]);
    720710        if (port_id % 2) {
    721711                tmp &= ~DMA_LIODN_BASE_MASK;
     
    725715                tmp |= liodn_base << DMA_LIODN_SHIFT;
    726716        }
    727         iowrite32be(tmp, &fman_rg->dma_rg->fmdmplr[port_id / 2]);
    728         iowrite32be(liodn_ofst, &fman_rg->bmi_rg->fmbm_spliodn[port_id - 1]);
     717        iowrite32be(tmp, &fman->dma_regs->fmdmplr[port_id / 2]);
     718        iowrite32be(liodn_ofst, &fman->bmi_regs->fmbm_spliodn[port_id - 1]);
    729719}
    730720
     
    759749        cfg->catastrophic_err = DEFAULT_CATASTROPHIC_ERR;
    760750        cfg->dma_err = DEFAULT_DMA_ERR;
    761         cfg->halt_on_external_activ = false;
    762         cfg->halt_on_unrecov_ecc_err = false;
    763         cfg->en_iram_test_mode = false;
    764         cfg->en_muram_test_mode = false;
    765         cfg->external_ecc_rams_enable = false;
    766         cfg->dma_aid_override = false;
    767751        cfg->dma_aid_mode = DEFAULT_AID_MODE;
    768752        cfg->dma_comm_qtsh_clr_emer = DEFAULT_DMA_COMM_Q_LOW;
     
    771755        cfg->dma_cam_num_of_entries = DEFAULT_DMA_CAM_NUM_OF_ENTRIES;
    772756        cfg->dma_dbg_cnt_mode = DEFAULT_DMA_DBG_CNT_MODE;
    773         cfg->dma_en_emergency = false;
    774757        cfg->dma_sos_emergency = DEFAULT_DMA_SOS_EMERGENCY;
    775758        cfg->dma_watchdog = DEFAULT_DMA_WATCHDOG;
    776         cfg->dma_en_emergency_smoother = false;
    777         cfg->dma_emergency_switch_counter =
    778             DEFAULT_DMA_EMERGENCY_SWITCH_COUNTER;
    779759        cfg->disp_limit_tsh = DEFAULT_DISP_LIMIT;
    780760        cfg->prs_disp_tsh = DEFAULT_PRS_DISP_TH;
     
    786766        cfg->fm_ctl1_disp_tsh = DEFAULT_FM_CTL1_DISP_TH;
    787767        cfg->fm_ctl2_disp_tsh = DEFAULT_FM_CTL2_DISP_TH;
    788 
    789         cfg->pedantic_dma = false;
    790         cfg->tnum_aging_period = 0;
    791         cfg->dma_stop_on_bus_error = false;
    792         cfg->qmi_deq_option_support = false;
    793768}
    794769
     
    809784        tmp_reg = 0;
    810785        tmp_reg |= cfg->dma_cache_override << DMA_MODE_CACHE_OR_SHIFT;
    811         if (cfg->dma_aid_override)
    812                 tmp_reg |= DMA_MODE_AID_OR;
    813786        if (cfg->exceptions & EX_DMA_BUS_ERROR)
    814787                tmp_reg |= DMA_MODE_BER;
     
    817790            (cfg->exceptions & EX_DMA_FM_WRITE_ECC))
    818791                tmp_reg |= DMA_MODE_ECC;
    819         if (cfg->dma_stop_on_bus_error)
    820                 tmp_reg |= DMA_MODE_SBER;
    821792        if (cfg->dma_axi_dbg_num_of_beats)
    822793                tmp_reg |= (DMA_MODE_AXI_DBG_MASK &
     
    824795                        << DMA_MODE_AXI_DBG_SHIFT));
    825796
    826         if (cfg->dma_en_emergency) {
    827                 tmp_reg |= cfg->dma_emergency_bus_select;
    828                 tmp_reg |= cfg->dma_emergency_level << DMA_MODE_EMER_LVL_SHIFT;
    829                 if (cfg->dma_en_emergency_smoother)
    830                         iowrite32be(cfg->dma_emergency_switch_counter,
    831                                     &dma_rg->fmdmemsr);
    832         }
    833797        tmp_reg |= (((cfg->dma_cam_num_of_entries / DMA_CAM_UNITS) - 1) &
    834798                DMA_MODE_CEN_MASK) << DMA_MODE_CEN_SHIFT;
     
    836800        tmp_reg |= cfg->dma_dbg_cnt_mode << DMA_MODE_DBG_SHIFT;
    837801        tmp_reg |= cfg->dma_aid_mode << DMA_MODE_AID_MODE_SHIFT;
    838 
    839         if (cfg->pedantic_dma)
    840                 tmp_reg |= DMA_MODE_EMER_READ;
    841802
    842803        iowrite32be(tmp_reg, &dma_rg->fmdmmr);
     
    875836        fman->cam_offset = fman_muram_alloc(fman->muram, fman->cam_size);
    876837        if (IS_ERR_VALUE(fman->cam_offset)) {
    877                 pr_err("MURAM alloc for DMA CAM failed\n");
     838                dev_err(fman->dev, "%s: MURAM alloc for DMA CAM failed\n",
     839                        __func__);
    878840                return -ENOMEM;
    879841        }
     
    889851                                                    fman->cam_size);
    890852                if (IS_ERR_VALUE(fman->cam_offset)) {
    891                         pr_err("MURAM alloc for DMA CAM failed\n");
     853                        dev_err(fman->dev, "%s: MURAM alloc for DMA CAM failed\n",
     854                                __func__);
    892855                        return -ENOMEM;
    893856                }
     
    895858                if (fman->cfg->dma_cam_num_of_entries % 8 ||
    896859                    fman->cfg->dma_cam_num_of_entries > 32) {
    897                         pr_err("wrong dma_cam_num_of_entries\n");
     860                        dev_err(fman->dev, "%s: wrong dma_cam_num_of_entries\n",
     861                                __func__);
    898862                        return -EINVAL;
    899863                }
     
    902866                        fman_muram_offset_to_vbase(fman->muram,
    903867                                                   fman->cam_offset);
    904                 out_be32(cam_base_addr,
    905                          ~((1 << (32 - fman->cfg->dma_cam_num_of_entries)) -
    906                          1));
     868                iowrite32be(~((1 <<
     869                            (32 - fman->cfg->dma_cam_num_of_entries)) - 1),
     870                            cam_base_addr);
    907871        }
    908872
     
    949913        tmp_reg |= (cfg->catastrophic_err << FPM_EV_MASK_CAT_ERR_SHIFT);
    950914        tmp_reg |= (cfg->dma_err << FPM_EV_MASK_DMA_ERR_SHIFT);
    951         if (!cfg->halt_on_external_activ)
    952                 tmp_reg |= FPM_EV_MASK_EXTERNAL_HALT;
    953         if (!cfg->halt_on_unrecov_ecc_err)
    954                 tmp_reg |= FPM_EV_MASK_ECC_ERR_HALT;
     915        /* FMan is not halted upon external halt activation */
     916        tmp_reg |= FPM_EV_MASK_EXTERNAL_HALT;
     917        /* Man is not halted upon  Unrecoverable ECC error behavior */
     918        tmp_reg |= FPM_EV_MASK_ECC_ERR_HALT;
    955919        iowrite32be(tmp_reg, &fpm_rg->fmfp_ee);
    956920
     
    965929        /* event bits */
    966930        tmp_reg = (FPM_RAM_MURAM_ECC | FPM_RAM_IRAM_ECC);
    967         /* Rams enable not effected by RCR bit,
    968          * but by a COP configuration
    969          */
    970         if (cfg->external_ecc_rams_enable)
    971                 tmp_reg |= FPM_RAM_RAMS_ECC_EN_SRC_SEL;
    972 
    973         /* enable test mode */
    974         if (cfg->en_muram_test_mode)
    975                 tmp_reg |= FPM_RAM_MURAM_TEST_ECC;
    976         if (cfg->en_iram_test_mode)
    977                 tmp_reg |= FPM_RAM_IRAM_TEST_ECC;
     931
    978932        iowrite32be(tmp_reg, &fpm_rg->fm_rcr);
    979933
     
    1032986{
    1033987        u32 tmp_reg;
    1034         u16 period_in_fm_clocks;
    1035         u8 remainder;
    1036988
    1037989        /* Init QMI Registers */
     
    10491001        iowrite32be(tmp_reg, &qmi_rg->fmqm_eien);
    10501002
    1051         if (cfg->tnum_aging_period) {
    1052                 /* tnum_aging_period is in units of usec, clk_freq in Mhz */
    1053                 period_in_fm_clocks = (u16)
    1054                         (cfg->tnum_aging_period * cfg->clk_freq);
    1055                 /* period_in_fm_clocks must be a 64 multiple */
    1056                 remainder = (u8)(period_in_fm_clocks % 64);
    1057                 if (remainder) {
    1058                         tmp_reg = (u32)((period_in_fm_clocks / 64) + 1);
    1059                 } else {
    1060                         tmp_reg = (u32)(period_in_fm_clocks / 64);
    1061                         if (!tmp_reg)
    1062                                 tmp_reg = 1;
    1063                 }
    1064                 tmp_reg <<= QMI_TAPC_TAP;
    1065                 iowrite32be(tmp_reg, &qmi_rg->fmqm_tapc);
    1066         }
    10671003        tmp_reg = 0;
    10681004        /* Clear interrupt events */
     
    10741010}
    10751011
    1076 static int enable(struct fman_rg *fman_rg, struct fman_cfg *cfg)
     1012static int enable(struct fman *fman, struct fman_cfg *cfg)
    10771013{
    10781014        u32 cfg_reg = 0;
     
    10801016        /* Enable all modules */
    10811017
    1082         /* clear&enable global counters  - calculate reg and save for later,
     1018        /* clear&enable global counters - calculate reg and save for later,
    10831019         * because it's the same reg for QMI enable
    10841020         */
    10851021        cfg_reg = QMI_CFG_EN_COUNTERS;
    1086         if (cfg->qmi_deq_option_support)
    1087                 cfg_reg |= (u32)(((cfg->qmi_def_tnums_thresh) << 8) |
    1088                                   cfg->qmi_def_tnums_thresh);
    1089 
    1090         iowrite32be(BMI_INIT_START, &fman_rg->bmi_rg->fmbm_init);
     1022
     1023        /* Set enqueue and dequeue thresholds */
     1024        cfg_reg |= (cfg->qmi_def_tnums_thresh << 8) | cfg->qmi_def_tnums_thresh;
     1025
     1026        iowrite32be(BMI_INIT_START, &fman->bmi_regs->fmbm_init);
    10911027        iowrite32be(cfg_reg | QMI_CFG_ENQ_EN | QMI_CFG_DEQ_EN,
    1092                     &fman_rg->qmi_rg->fmqm_gc);
     1028                    &fman->qmi_regs->fmqm_gc);
    10931029
    10941030        return 0;
    10951031}
    10961032
    1097 static int set_exception(struct fman_rg *fman_rg,
     1033static int set_exception(struct fman *fman,
    10981034                         enum fman_exceptions exception, bool enable)
    10991035{
     
    11021038        switch (exception) {
    11031039        case FMAN_EX_DMA_BUS_ERROR:
    1104                 tmp = ioread32be(&fman_rg->dma_rg->fmdmmr);
     1040                tmp = ioread32be(&fman->dma_regs->fmdmmr);
    11051041                if (enable)
    11061042                        tmp |= DMA_MODE_BER;
     
    11081044                        tmp &= ~DMA_MODE_BER;
    11091045                /* disable bus error */
    1110                 iowrite32be(tmp, &fman_rg->dma_rg->fmdmmr);
     1046                iowrite32be(tmp, &fman->dma_regs->fmdmmr);
    11111047                break;
    11121048        case FMAN_EX_DMA_READ_ECC:
    11131049        case FMAN_EX_DMA_SYSTEM_WRITE_ECC:
    11141050        case FMAN_EX_DMA_FM_WRITE_ECC:
    1115                 tmp = ioread32be(&fman_rg->dma_rg->fmdmmr);
     1051                tmp = ioread32be(&fman->dma_regs->fmdmmr);
    11161052                if (enable)
    11171053                        tmp |= DMA_MODE_ECC;
    11181054                else
    11191055                        tmp &= ~DMA_MODE_ECC;
    1120                 iowrite32be(tmp, &fman_rg->dma_rg->fmdmmr);
     1056                iowrite32be(tmp, &fman->dma_regs->fmdmmr);
    11211057                break;
    11221058        case FMAN_EX_FPM_STALL_ON_TASKS:
    1123                 tmp = ioread32be(&fman_rg->fpm_rg->fmfp_ee);
     1059                tmp = ioread32be(&fman->fpm_regs->fmfp_ee);
    11241060                if (enable)
    11251061                        tmp |= FPM_EV_MASK_STALL_EN;
    11261062                else
    11271063                        tmp &= ~FPM_EV_MASK_STALL_EN;
    1128                 iowrite32be(tmp, &fman_rg->fpm_rg->fmfp_ee);
     1064                iowrite32be(tmp, &fman->fpm_regs->fmfp_ee);
    11291065                break;
    11301066        case FMAN_EX_FPM_SINGLE_ECC:
    1131                 tmp = ioread32be(&fman_rg->fpm_rg->fmfp_ee);
     1067                tmp = ioread32be(&fman->fpm_regs->fmfp_ee);
    11321068                if (enable)
    11331069                        tmp |= FPM_EV_MASK_SINGLE_ECC_EN;
    11341070                else
    11351071                        tmp &= ~FPM_EV_MASK_SINGLE_ECC_EN;
    1136                 iowrite32be(tmp, &fman_rg->fpm_rg->fmfp_ee);
     1072                iowrite32be(tmp, &fman->fpm_regs->fmfp_ee);
    11371073                break;
    11381074        case FMAN_EX_FPM_DOUBLE_ECC:
    1139                 tmp = ioread32be(&fman_rg->fpm_rg->fmfp_ee);
     1075                tmp = ioread32be(&fman->fpm_regs->fmfp_ee);
    11401076                if (enable)
    11411077                        tmp |= FPM_EV_MASK_DOUBLE_ECC_EN;
    11421078                else
    11431079                        tmp &= ~FPM_EV_MASK_DOUBLE_ECC_EN;
    1144                 iowrite32be(tmp, &fman_rg->fpm_rg->fmfp_ee);
     1080                iowrite32be(tmp, &fman->fpm_regs->fmfp_ee);
    11451081                break;
    11461082        case FMAN_EX_QMI_SINGLE_ECC:
    1147                 tmp = ioread32be(&fman_rg->qmi_rg->fmqm_ien);
     1083                tmp = ioread32be(&fman->qmi_regs->fmqm_ien);
    11481084                if (enable)
    11491085                        tmp |= QMI_INTR_EN_SINGLE_ECC;
    11501086                else
    11511087                        tmp &= ~QMI_INTR_EN_SINGLE_ECC;
    1152                 iowrite32be(tmp, &fman_rg->qmi_rg->fmqm_ien);
     1088                iowrite32be(tmp, &fman->qmi_regs->fmqm_ien);
    11531089                break;
    11541090        case FMAN_EX_QMI_DOUBLE_ECC:
    1155                 tmp = ioread32be(&fman_rg->qmi_rg->fmqm_eien);
     1091                tmp = ioread32be(&fman->qmi_regs->fmqm_eien);
    11561092                if (enable)
    11571093                        tmp |= QMI_ERR_INTR_EN_DOUBLE_ECC;
    11581094                else
    11591095                        tmp &= ~QMI_ERR_INTR_EN_DOUBLE_ECC;
    1160                 iowrite32be(tmp, &fman_rg->qmi_rg->fmqm_eien);
     1096                iowrite32be(tmp, &fman->qmi_regs->fmqm_eien);
    11611097                break;
    11621098        case FMAN_EX_QMI_DEQ_FROM_UNKNOWN_PORTID:
    1163                 tmp = ioread32be(&fman_rg->qmi_rg->fmqm_eien);
     1099                tmp = ioread32be(&fman->qmi_regs->fmqm_eien);
    11641100                if (enable)
    11651101                        tmp |= QMI_ERR_INTR_EN_DEQ_FROM_DEF;
    11661102                else
    11671103                        tmp &= ~QMI_ERR_INTR_EN_DEQ_FROM_DEF;
    1168                 iowrite32be(tmp, &fman_rg->qmi_rg->fmqm_eien);
     1104                iowrite32be(tmp, &fman->qmi_regs->fmqm_eien);
    11691105                break;
    11701106        case FMAN_EX_BMI_LIST_RAM_ECC:
    1171                 tmp = ioread32be(&fman_rg->bmi_rg->fmbm_ier);
     1107                tmp = ioread32be(&fman->bmi_regs->fmbm_ier);
    11721108                if (enable)
    11731109                        tmp |= BMI_ERR_INTR_EN_LIST_RAM_ECC;
    11741110                else
    11751111                        tmp &= ~BMI_ERR_INTR_EN_LIST_RAM_ECC;
    1176                 iowrite32be(tmp, &fman_rg->bmi_rg->fmbm_ier);
     1112                iowrite32be(tmp, &fman->bmi_regs->fmbm_ier);
    11771113                break;
    11781114        case FMAN_EX_BMI_STORAGE_PROFILE_ECC:
    1179                 tmp = ioread32be(&fman_rg->bmi_rg->fmbm_ier);
     1115                tmp = ioread32be(&fman->bmi_regs->fmbm_ier);
    11801116                if (enable)
    11811117                        tmp |= BMI_ERR_INTR_EN_STORAGE_PROFILE_ECC;
    11821118                else
    11831119                        tmp &= ~BMI_ERR_INTR_EN_STORAGE_PROFILE_ECC;
    1184                 iowrite32be(tmp, &fman_rg->bmi_rg->fmbm_ier);
     1120                iowrite32be(tmp, &fman->bmi_regs->fmbm_ier);
    11851121                break;
    11861122        case FMAN_EX_BMI_STATISTICS_RAM_ECC:
    1187                 tmp = ioread32be(&fman_rg->bmi_rg->fmbm_ier);
     1123                tmp = ioread32be(&fman->bmi_regs->fmbm_ier);
    11881124                if (enable)
    11891125                        tmp |= BMI_ERR_INTR_EN_STATISTICS_RAM_ECC;
    11901126                else
    11911127                        tmp &= ~BMI_ERR_INTR_EN_STATISTICS_RAM_ECC;
    1192                 iowrite32be(tmp, &fman_rg->bmi_rg->fmbm_ier);
     1128                iowrite32be(tmp, &fman->bmi_regs->fmbm_ier);
    11931129                break;
    11941130        case FMAN_EX_BMI_DISPATCH_RAM_ECC:
    1195                 tmp = ioread32be(&fman_rg->bmi_rg->fmbm_ier);
     1131                tmp = ioread32be(&fman->bmi_regs->fmbm_ier);
    11961132                if (enable)
    11971133                        tmp |= BMI_ERR_INTR_EN_DISPATCH_RAM_ECC;
    11981134                else
    11991135                        tmp &= ~BMI_ERR_INTR_EN_DISPATCH_RAM_ECC;
    1200                 iowrite32be(tmp, &fman_rg->bmi_rg->fmbm_ier);
     1136                iowrite32be(tmp, &fman->bmi_regs->fmbm_ier);
    12011137                break;
    12021138        case FMAN_EX_IRAM_ECC:
    1203                 tmp = ioread32be(&fman_rg->fpm_rg->fm_rie);
     1139                tmp = ioread32be(&fman->fpm_regs->fm_rie);
    12041140                if (enable) {
    12051141                        /* enable ECC if not enabled */
    1206                         enable_rams_ecc(fman_rg->fpm_rg);
     1142                        enable_rams_ecc(fman->fpm_regs);
    12071143                        /* enable ECC interrupts */
    12081144                        tmp |= FPM_IRAM_ECC_ERR_EX_EN;
     
    12111147                         * depending on driver status
    12121148                         */
    1213                         disable_rams_ecc(fman_rg->fpm_rg);
     1149                        disable_rams_ecc(fman->fpm_regs);
    12141150                        tmp &= ~FPM_IRAM_ECC_ERR_EX_EN;
    12151151                }
    1216                 iowrite32be(tmp, &fman_rg->fpm_rg->fm_rie);
     1152                iowrite32be(tmp, &fman->fpm_regs->fm_rie);
    12171153                break;
    12181154        case FMAN_EX_MURAM_ECC:
    1219                 tmp = ioread32be(&fman_rg->fpm_rg->fm_rie);
     1155                tmp = ioread32be(&fman->fpm_regs->fm_rie);
    12201156                if (enable) {
    12211157                        /* enable ECC if not enabled */
    1222                         enable_rams_ecc(fman_rg->fpm_rg);
     1158                        enable_rams_ecc(fman->fpm_regs);
    12231159                        /* enable ECC interrupts */
    12241160                        tmp |= FPM_MURAM_ECC_ERR_EX_EN;
     
    12271163                         * depending on driver status
    12281164                         */
    1229                         disable_rams_ecc(fman_rg->fpm_rg);
     1165                        disable_rams_ecc(fman->fpm_regs);
    12301166                        tmp &= ~FPM_MURAM_ECC_ERR_EX_EN;
    12311167                }
    1232                 iowrite32be(tmp, &fman_rg->fpm_rg->fm_rie);
     1168                iowrite32be(tmp, &fman->fpm_regs->fm_rie);
    12331169                break;
    12341170        default:
     
    13471283}
    13481284
    1349 static void bmi_err_event(struct fman *fman)
     1285static irqreturn_t bmi_err_event(struct fman *fman)
    13501286{
    13511287        u32 event, mask, force;
    13521288        struct fman_bmi_regs __iomem *bmi_rg = fman->bmi_regs;
     1289        irqreturn_t ret = IRQ_NONE;
    13531290
    13541291        event = ioread32be(&bmi_rg->fmbm_ievr);
     
    13631300
    13641301        if (event & BMI_ERR_INTR_EN_STORAGE_PROFILE_ECC)
    1365                 fman->exception_cb(fman, FMAN_EX_BMI_STORAGE_PROFILE_ECC);
     1302                ret = fman->exception_cb(fman, FMAN_EX_BMI_STORAGE_PROFILE_ECC);
    13661303        if (event & BMI_ERR_INTR_EN_LIST_RAM_ECC)
    1367                 fman->exception_cb(fman, FMAN_EX_BMI_LIST_RAM_ECC);
     1304                ret = fman->exception_cb(fman, FMAN_EX_BMI_LIST_RAM_ECC);
    13681305        if (event & BMI_ERR_INTR_EN_STATISTICS_RAM_ECC)
    1369                 fman->exception_cb(fman, FMAN_EX_BMI_STATISTICS_RAM_ECC);
     1306                ret = fman->exception_cb(fman, FMAN_EX_BMI_STATISTICS_RAM_ECC);
    13701307        if (event & BMI_ERR_INTR_EN_DISPATCH_RAM_ECC)
    1371                 fman->exception_cb(fman, FMAN_EX_BMI_DISPATCH_RAM_ECC);
    1372 }
    1373 
    1374 static void qmi_err_event(struct fman *fman)
     1308                ret = fman->exception_cb(fman, FMAN_EX_BMI_DISPATCH_RAM_ECC);
     1309
     1310        return ret;
     1311}
     1312
     1313static irqreturn_t qmi_err_event(struct fman *fman)
    13751314{
    13761315        u32 event, mask, force;
    13771316        struct fman_qmi_regs __iomem *qmi_rg = fman->qmi_regs;
     1317        irqreturn_t ret = IRQ_NONE;
    13781318
    13791319        event = ioread32be(&qmi_rg->fmqm_eie);
     
    13891329
    13901330        if (event & QMI_ERR_INTR_EN_DOUBLE_ECC)
    1391                 fman->exception_cb(fman, FMAN_EX_QMI_DOUBLE_ECC);
     1331                ret = fman->exception_cb(fman, FMAN_EX_QMI_DOUBLE_ECC);
    13921332        if (event & QMI_ERR_INTR_EN_DEQ_FROM_DEF)
    1393                 fman->exception_cb(fman, FMAN_EX_QMI_DEQ_FROM_UNKNOWN_PORTID);
    1394 }
    1395 
    1396 static void dma_err_event(struct fman *fman)
     1333                ret = fman->exception_cb(fman,
     1334                                         FMAN_EX_QMI_DEQ_FROM_UNKNOWN_PORTID);
     1335
     1336        return ret;
     1337}
     1338
     1339static irqreturn_t dma_err_event(struct fman *fman)
    13971340{
    13981341        u32 status, mask, com_id;
     
    14001343        u16 liodn;
    14011344        struct fman_dma_regs __iomem *dma_rg = fman->dma_regs;
     1345        irqreturn_t ret = IRQ_NONE;
    14021346
    14031347        status = ioread32be(&dma_rg->fmdmsr);
     
    14321376                            DMA_TRANSFER_TNUM_SHIFT);
    14331377                liodn = (u16)(com_id & DMA_TRANSFER_LIODN_MASK);
    1434                 fman->bus_error_cb(fman, relative_port_id, addr, tnum, liodn);
     1378                ret = fman->bus_error_cb(fman, relative_port_id, addr, tnum,
     1379                                         liodn);
    14351380        }
    14361381        if (status & DMA_STATUS_FM_SPDAT_ECC)
    1437                 fman->exception_cb(fman, FMAN_EX_DMA_SINGLE_PORT_ECC);
     1382                ret = fman->exception_cb(fman, FMAN_EX_DMA_SINGLE_PORT_ECC);
    14381383        if (status & DMA_STATUS_READ_ECC)
    1439                 fman->exception_cb(fman, FMAN_EX_DMA_READ_ECC);
     1384                ret = fman->exception_cb(fman, FMAN_EX_DMA_READ_ECC);
    14401385        if (status & DMA_STATUS_SYSTEM_WRITE_ECC)
    1441                 fman->exception_cb(fman, FMAN_EX_DMA_SYSTEM_WRITE_ECC);
     1386                ret = fman->exception_cb(fman, FMAN_EX_DMA_SYSTEM_WRITE_ECC);
    14421387        if (status & DMA_STATUS_FM_WRITE_ECC)
    1443                 fman->exception_cb(fman, FMAN_EX_DMA_FM_WRITE_ECC);
    1444 }
    1445 
    1446 static void fpm_err_event(struct fman *fman)
     1388                ret = fman->exception_cb(fman, FMAN_EX_DMA_FM_WRITE_ECC);
     1389
     1390        return ret;
     1391}
     1392
     1393static irqreturn_t fpm_err_event(struct fman *fman)
    14471394{
    14481395        u32 event;
    14491396        struct fman_fpm_regs __iomem *fpm_rg = fman->fpm_regs;
     1397        irqreturn_t ret = IRQ_NONE;
    14501398
    14511399        event = ioread32be(&fpm_rg->fmfp_ee);
     
    14551403        if ((event & FPM_EV_MASK_DOUBLE_ECC) &&
    14561404            (event & FPM_EV_MASK_DOUBLE_ECC_EN))
    1457                 fman->exception_cb(fman, FMAN_EX_FPM_DOUBLE_ECC);
     1405                ret = fman->exception_cb(fman, FMAN_EX_FPM_DOUBLE_ECC);
    14581406        if ((event & FPM_EV_MASK_STALL) && (event & FPM_EV_MASK_STALL_EN))
    1459                 fman->exception_cb(fman, FMAN_EX_FPM_STALL_ON_TASKS);
     1407                ret = fman->exception_cb(fman, FMAN_EX_FPM_STALL_ON_TASKS);
    14601408        if ((event & FPM_EV_MASK_SINGLE_ECC) &&
    14611409            (event & FPM_EV_MASK_SINGLE_ECC_EN))
    1462                 fman->exception_cb(fman, FMAN_EX_FPM_SINGLE_ECC);
    1463 }
    1464 
    1465 static void muram_err_intr(struct fman *fman)
     1410                ret = fman->exception_cb(fman, FMAN_EX_FPM_SINGLE_ECC);
     1411
     1412        return ret;
     1413}
     1414
     1415static irqreturn_t muram_err_intr(struct fman *fman)
    14661416{
    14671417        u32 event, mask;
    14681418        struct fman_fpm_regs __iomem *fpm_rg = fman->fpm_regs;
     1419        irqreturn_t ret = IRQ_NONE;
    14691420
    14701421        event = ioread32be(&fpm_rg->fm_rcr);
     
    14751426
    14761427        if ((mask & FPM_MURAM_ECC_ERR_EX_EN) && (event & FPM_RAM_MURAM_ECC))
    1477                 fman->exception_cb(fman, FMAN_EX_MURAM_ECC);
    1478 }
    1479 
    1480 static void qmi_event(struct fman *fman)
     1428                ret = fman->exception_cb(fman, FMAN_EX_MURAM_ECC);
     1429
     1430        return ret;
     1431}
     1432
     1433static irqreturn_t qmi_event(struct fman *fman)
    14811434{
    14821435        u32 event, mask, force;
    14831436        struct fman_qmi_regs __iomem *qmi_rg = fman->qmi_regs;
     1437        irqreturn_t ret = IRQ_NONE;
    14841438
    14851439        event = ioread32be(&qmi_rg->fmqm_ie);
     
    14941448
    14951449        if (event & QMI_INTR_EN_SINGLE_ECC)
    1496                 fman->exception_cb(fman, FMAN_EX_QMI_SINGLE_ECC);
     1450                ret = fman->exception_cb(fman, FMAN_EX_QMI_SINGLE_ECC);
     1451
     1452        return ret;
    14971453}
    14981454
     
    15351491{
    15361492        struct fman_iram_regs __iomem *iram;
    1537         int i;
    1538 
    1539         iram = (struct fman_iram_regs __iomem *)(fman->base_addr + IMEM_OFFSET);
     1493        int i, count;
     1494
     1495        iram = fman->base_addr + IMEM_OFFSET;
    15401496
    15411497        /* Enable the auto-increment */
    1542         out_be32(&iram->iadd, IRAM_IADD_AIE);
    1543         while (in_be32(&iram->iadd) != IRAM_IADD_AIE)
    1544                 ;
     1498        iowrite32be(IRAM_IADD_AIE, &iram->iadd);
     1499        count = 100;
     1500        do {
     1501                udelay(1);
     1502        } while ((ioread32be(&iram->iadd) != IRAM_IADD_AIE) && --count);
     1503        if (count == 0)
     1504                return -EBUSY;
    15451505
    15461506        for (i = 0; i < (fman->state->fm_iram_size / 4); i++)
    1547                 out_be32(&iram->idata, 0xffffffff);
    1548 
    1549         out_be32(&iram->iadd, fman->state->fm_iram_size - 4);
    1550         /* Memory barrier */
    1551         mb();
    1552         while (in_be32(&iram->idata) != 0xffffffff)
    1553                 ;
     1507                iowrite32be(0xffffffff, &iram->idata);
     1508
     1509        iowrite32be(fman->state->fm_iram_size - 4, &iram->iadd);
     1510        count = 100;
     1511        do {
     1512                udelay(1);
     1513        } while ((ioread32be(&iram->idata) != 0xffffffff) && --count);
     1514        if (count == 0)
     1515                return -EBUSY;
    15541516
    15551517        return 0;
     
    16241586        switch (module) {
    16251587        case FMAN_MOD_MAC:
    1626                         event = (intr_type == FMAN_INTR_TYPE_ERR) ?
    1627                         (FMAN_EV_ERR_MAC0 + mod_id) :
    1628                         (FMAN_EV_MAC0 + mod_id);
     1588                if (intr_type == FMAN_INTR_TYPE_ERR)
     1589                        event = FMAN_EV_ERR_MAC0 + mod_id;
     1590                else
     1591                        event = FMAN_EV_MAC0 + mod_id;
    16291592                break;
    16301593        case FMAN_MOD_FMAN_CTRL:
     
    16681631            (fman->state->total_fifo_size -
    16691632            fman->state->extra_fifo_pool_size)) {
    1670                 pr_err("Requested fifo size and extra size exceed total FIFO size.\n");
     1633                dev_err(fman->dev, "%s: Requested fifo size and extra size exceed total FIFO size.\n",
     1634                        __func__);
    16711635                return -EAGAIN;
    16721636        }
    16731637
    16741638        /* Read, modify and write to HW */
    1675         tmp = (u32)((fifo / FMAN_BMI_FIFO_UNITS - 1) |
    1676                     ((extra_fifo / FMAN_BMI_FIFO_UNITS) <<
    1677                     BMI_EXTRA_FIFO_SIZE_SHIFT));
     1639        tmp = (fifo / FMAN_BMI_FIFO_UNITS - 1) |
     1640               ((extra_fifo / FMAN_BMI_FIFO_UNITS) <<
     1641               BMI_EXTRA_FIFO_SIZE_SHIFT);
    16781642        iowrite32be(tmp, &bmi_rg->fmbm_pfs[port_id - 1]);
    16791643
     
    16941658        if (extra_tasks)
    16951659                fman->state->extra_tasks_pool_size =
    1696                 (u8)max(fman->state->extra_tasks_pool_size, extra_tasks);
     1660                max(fman->state->extra_tasks_pool_size, extra_tasks);
    16971661
    16981662        /* check that there are enough uncommitted tasks */
     
    17001664            (fman->state->total_num_of_tasks -
    17011665             fman->state->extra_tasks_pool_size)) {
    1702                 pr_err("Requested num_of_tasks and extra tasks pool for fm%d exceed total num_of_tasks.\n",
    1703                       fman->state->fm_id);
     1666                dev_err(fman->dev, "%s: Requested num_of_tasks and extra tasks pool for fm%d exceed total num_of_tasks.\n",
     1667                        __func__, fman->state->fm_id);
    17041668                return -EAGAIN;
    17051669        }
     
    17601724            (fman->state->accumulated_num_of_open_dmas - current_val +
    17611725             open_dmas > fman->state->max_num_of_open_dmas)) {
    1762                 pr_err("Requested num_of_open_dmas for fm%d exceeds total num_of_open_dmas.\n",
    1763                       fman->state->fm_id);
     1726                dev_err(fman->dev, "%s: Requested num_of_open_dmas for fm%d exceeds total num_of_open_dmas.\n",
     1727                        __func__, fman->state->fm_id);
    17641728                return -EAGAIN;
    17651729        } else if ((fman->state->rev_info.major >= 6) &&
     
    17691733                   current_val + open_dmas >
    17701734                   fman->state->dma_thresh_max_commq + 1)) {
    1771                 pr_err("Requested num_of_open_dmas for fm%d exceeds DMA Command queue (%d)\n",
    1772                       fman->state->fm_id,
     1735                dev_err(fman->dev, "%s: Requested num_of_open_dmas for fm%d exceeds DMA Command queue (%d)\n",
     1736                        __func__, fman->state->fm_id,
    17731737                       fman->state->dma_thresh_max_commq + 1);
    17741738                return -EAGAIN;
     
    18211785
    18221786        /* Initialize MURAM block */
    1823         fman->muram = fman_muram_init(fman->dts_params.muram_phy_base_addr,
    1824                                       fman->dts_params.muram_size);
     1787        fman->muram =
     1788                fman_muram_init(fman->dts_params.muram_res.start,
     1789                                resource_size(&fman->dts_params.muram_res));
    18251790        if (!fman->muram)
    18261791                goto err_fm_soc_specific;
     
    18371802        fman->exception_cb = fman_exceptions;
    18381803        fman->bus_error_cb = fman_bus_error;
    1839         fman->fpm_regs =
    1840                 (struct fman_fpm_regs __iomem *)(base_addr + FPM_OFFSET);
    1841         fman->bmi_regs =
    1842                 (struct fman_bmi_regs __iomem *)(base_addr + BMI_OFFSET);
    1843         fman->qmi_regs =
    1844                 (struct fman_qmi_regs __iomem *)(base_addr + QMI_OFFSET);
    1845         fman->dma_regs =
    1846                 (struct fman_dma_regs __iomem *)(base_addr + DMA_OFFSET);
     1804        fman->fpm_regs = base_addr + FPM_OFFSET;
     1805        fman->bmi_regs = base_addr + BMI_OFFSET;
     1806        fman->qmi_regs = base_addr + QMI_OFFSET;
     1807        fman->dma_regs = base_addr + DMA_OFFSET;
    18471808        fman->base_addr = base_addr;
    18481809
     
    18501811        fman_defconfig(fman->cfg);
    18511812
    1852         fman->cfg->qmi_deq_option_support = true;
    1853 
    18541813        fman->state->extra_fifo_pool_size = 0;
    1855         fman->state->exceptions = DFLT_EXCEPTIONS;
    1856         fman->reset_on_init = true;
     1814        fman->state->exceptions = (EX_DMA_BUS_ERROR                 |
     1815                                        EX_DMA_READ_ECC              |
     1816                                        EX_DMA_SYSTEM_WRITE_ECC      |
     1817                                        EX_DMA_FM_WRITE_ECC          |
     1818                                        EX_FPM_STALL_ON_TASKS        |
     1819                                        EX_FPM_SINGLE_ECC            |
     1820                                        EX_FPM_DOUBLE_ECC            |
     1821                                        EX_QMI_DEQ_FROM_UNKNOWN_PORTID |
     1822                                        EX_BMI_LIST_RAM_ECC          |
     1823                                        EX_BMI_STORAGE_PROFILE_ECC   |
     1824                                        EX_BMI_STATISTICS_RAM_ECC    |
     1825                                        EX_MURAM_ECC                 |
     1826                                        EX_BMI_DISPATCH_RAM_ECC      |
     1827                                        EX_QMI_DOUBLE_ECC            |
     1828                                        EX_QMI_SINGLE_ECC);
    18571829
    18581830        /* Read FMan revision for future use*/
     
    19131885}
    19141886
     1887#ifndef __rtems__
     1888static int fman_reset(struct fman *fman)
     1889{
     1890        u32 count;
     1891        int err = 0;
     1892
     1893        if (fman->state->rev_info.major < 6) {
     1894                iowrite32be(FPM_RSTC_FM_RESET, &fman->fpm_regs->fm_rstc);
     1895                /* Wait for reset completion */
     1896                count = 100;
     1897                do {
     1898                        udelay(1);
     1899                } while (((ioread32be(&fman->fpm_regs->fm_rstc)) &
     1900                         FPM_RSTC_FM_RESET) && --count);
     1901                if (count == 0)
     1902                        err = -EBUSY;
     1903
     1904                goto _return;
     1905        } else {
     1906#ifdef CONFIG_PPC
     1907                struct device_node *guts_node;
     1908                struct ccsr_guts __iomem *guts_regs;
     1909                u32 devdisr2, reg;
     1910
     1911                /* Errata A007273 */
     1912                guts_node =
     1913                        of_find_compatible_node(NULL, NULL,
     1914                                                "fsl,qoriq-device-config-2.0");
     1915                if (!guts_node) {
     1916                        dev_err(fman->dev, "%s: Couldn't find guts node\n",
     1917                                __func__);
     1918                        goto guts_node;
     1919                }
     1920
     1921                guts_regs = of_iomap(guts_node, 0);
     1922                if (!guts_regs) {
     1923                        dev_err(fman->dev, "%s: Couldn't map %s regs\n",
     1924                                __func__, guts_node->full_name);
     1925                        goto guts_regs;
     1926                }
     1927#define FMAN1_ALL_MACS_MASK     0xFCC00000
     1928#define FMAN2_ALL_MACS_MASK     0x000FCC00
     1929                /* Read current state */
     1930                devdisr2 = ioread32be(&guts_regs->devdisr2);
     1931                if (fman->dts_params.id == 0)
     1932                        reg = devdisr2 & ~FMAN1_ALL_MACS_MASK;
     1933                else
     1934                        reg = devdisr2 & ~FMAN2_ALL_MACS_MASK;
     1935
     1936                /* Enable all MACs */
     1937                iowrite32be(reg, &guts_regs->devdisr2);
     1938#endif
     1939
     1940                /* Perform FMan reset */
     1941                iowrite32be(FPM_RSTC_FM_RESET, &fman->fpm_regs->fm_rstc);
     1942
     1943                /* Wait for reset completion */
     1944                count = 100;
     1945                do {
     1946                        udelay(1);
     1947                } while (((ioread32be(&fman->fpm_regs->fm_rstc)) &
     1948                         FPM_RSTC_FM_RESET) && --count);
     1949                if (count == 0) {
     1950#ifdef CONFIG_PPC
     1951                        iounmap(guts_regs);
     1952                        of_node_put(guts_node);
     1953#endif
     1954                        err = -EBUSY;
     1955                        goto _return;
     1956                }
     1957#ifdef CONFIG_PPC
     1958
     1959                /* Restore devdisr2 value */
     1960                iowrite32be(devdisr2, &guts_regs->devdisr2);
     1961
     1962                iounmap(guts_regs);
     1963                of_node_put(guts_node);
     1964#endif
     1965
     1966                goto _return;
     1967
     1968#ifdef CONFIG_PPC
     1969guts_regs:
     1970                of_node_put(guts_node);
     1971guts_node:
     1972                dev_dbg(fman->dev, "%s: Didn't perform FManV3 reset due to Errata A007273!\n",
     1973                        __func__);
     1974#endif
     1975        }
     1976_return:
     1977        return err;
     1978}
     1979#endif /* __rtems__ */
     1980
    19151981static int fman_init(struct fman *fman)
    19161982{
    19171983        struct fman_cfg *cfg = NULL;
    1918         struct fman_rg fman_rg;
    1919         int err = 0, i;
     1984        int err = 0, i, count;
    19201985
    19211986        if (is_init_done(fman->cfg))
    19221987                return -EINVAL;
    1923 
    1924         fman_rg.bmi_rg = fman->bmi_regs;
    1925         fman_rg.qmi_rg = fman->qmi_regs;
    1926         fman_rg.fpm_rg = fman->fpm_regs;
    1927         fman_rg.dma_rg = fman->dma_regs;
    19281988
    19291989        fman->state->count1_micro_bit = FM_TIMESTAMP_1_USEC_BIT;
     
    19492009
    19502010                fman->liodn_offset[i] =
    1951                         ioread32be(&fman_rg.bmi_rg->fmbm_spliodn[i - 1]);
    1952                 liodn_base = ioread32be(&fman_rg.dma_rg->fmdmplr[i / 2]);
     2011                        ioread32be(&fman->bmi_regs->fmbm_spliodn[i - 1]);
     2012                liodn_base = ioread32be(&fman->dma_regs->fmdmplr[i / 2]);
    19532013                if (i % 2) {
    19542014                        /* FMDM_PLR LSB holds LIODN base for odd ports */
     
    19622022        }
    19632023
    1964         /* Reset the FM if required. */
    1965         if (fman->reset_on_init) {
    1966                 if (fman->state->rev_info.major >= 6) {
    1967                         /* Errata A007273 */
    1968                         pr_debug("FManV3 reset is not supported!\n");
    1969                 } else {
    1970                         out_be32(&fman->fpm_regs->fm_rstc, FPM_RSTC_FM_RESET);
    1971                         /* Memory barrier */
    1972                         mb();
    1973                         usleep_range(100, 300);
    1974                 }
    1975 
    1976                 if (!!(ioread32be(&fman_rg.qmi_rg->fmqm_gs) &
    1977                     QMI_GS_HALT_NOT_BUSY)) {
    1978                         resume(fman->fpm_regs);
    1979                         usleep_range(100, 300);
    1980                 }
     2024        err = fman_reset(fman);
     2025        if (err)
     2026                return err;
     2027
     2028        if (ioread32be(&fman->qmi_regs->fmqm_gs) & QMI_GS_HALT_NOT_BUSY) {
     2029                resume(fman->fpm_regs);
     2030                /* Wait until QMI is not in halt not busy state */
     2031                count = 100;
     2032                do {
     2033                        udelay(1);
     2034                } while (((ioread32be(&fman->qmi_regs->fmqm_gs)) &
     2035                         QMI_GS_HALT_NOT_BUSY) && --count);
     2036                if (count == 0)
     2037                        dev_warn(fman->dev, "%s: QMI is in halt not busy state\n",
     2038                                 __func__);
    19812039        }
    19822040
     
    20012059        fman->fifo_offset = fman_muram_alloc(fman->muram,
    20022060                                             fman->state->total_fifo_size);
    2003         if (IS_ERR_VALUE(fman->cam_offset)) {
     2061        if (IS_ERR_VALUE(fman->fifo_offset)) {
    20042062                free_init_resources(fman);
    2005                 pr_err("MURAM alloc for BMI FIFO failed\n");
     2063                dev_err(fman->dev, "%s: MURAM alloc for BMI FIFO failed\n",
     2064                        __func__);
    20062065                return -ENOMEM;
    20072066        }
     
    20182077        qmi_init(fman->qmi_regs, fman->cfg);
    20192078
    2020         err = enable(&fman_rg, cfg);
     2079        err = enable(fman, cfg);
    20212080        if (err != 0)
    20222081                return err;
     
    20342093{
    20352094        u32 bit_mask = 0;
    2036         struct fman_rg fman_rg;
    20372095
    20382096        if (!is_init_done(fman->cfg))
    20392097                return -EINVAL;
    2040 
    2041         fman_rg.bmi_rg = fman->bmi_regs;
    2042         fman_rg.qmi_rg = fman->qmi_regs;
    2043         fman_rg.fpm_rg = fman->fpm_regs;
    2044         fman_rg.dma_rg = fman->dma_regs;
    20452098
    20462099        bit_mask = get_exception_flag(exception);
     
    20512104                        fman->state->exceptions &= ~bit_mask;
    20522105        } else {
    2053                 pr_err("Undefined exception\n");
     2106                dev_err(fman->dev, "%s: Undefined exception (%d)\n",
     2107                        __func__, exception);
    20542108                return -EINVAL;
    20552109        }
    20562110
    2057         return set_exception(&fman_rg, exception, enable);
    2058 }
    2059 
     2111        return set_exception(fman, exception, enable);
     2112}
     2113
     2114/**
     2115 * fman_register_intr
     2116 * @fman:       A Pointer to FMan device
     2117 * @mod:        Calling module
     2118 * @mod_id:     Module id (if more than 1 exists, '0' if not)
     2119 * @intr_type:  Interrupt type (error/normal) selection.
     2120 * @f_isr:      The interrupt service routine.
     2121 * @h_src_arg:  Argument to be passed to f_isr.
     2122 *
     2123 * Used to register an event handler to be processed by FMan
     2124 *
     2125 * Return: 0 on success; Error code otherwise.
     2126 */
    20602127void fman_register_intr(struct fman *fman, enum fman_event_modules module,
    20612128                        u8 mod_id, enum fman_intr_type intr_type,
     
    20652132
    20662133        event = get_module_event(module, mod_id, intr_type);
    2067         WARN_ON(!(event < FMAN_EV_CNT));
     2134        WARN_ON(event >= FMAN_EV_CNT);
    20682135
    20692136        /* register in local FM structure */
     
    20712138        fman->intr_mng[event].src_handle = src_arg;
    20722139}
    2073 
     2140EXPORT_SYMBOL(fman_register_intr);
     2141
     2142/**
     2143 * fman_unregister_intr
     2144 * @fman:       A Pointer to FMan device
     2145 * @mod:        Calling module
     2146 * @mod_id:     Module id (if more than 1 exists, '0' if not)
     2147 * @intr_type:  Interrupt type (error/normal) selection.
     2148 *
     2149 * Used to unregister an event handler to be processed by FMan
     2150 *
     2151 * Return: 0 on success; Error code otherwise.
     2152 */
    20742153void fman_unregister_intr(struct fman *fman, enum fman_event_modules module,
    20752154                          u8 mod_id, enum fman_intr_type intr_type)
     
    20782157
    20792158        event = get_module_event(module, mod_id, intr_type);
    2080         WARN_ON(!(event < FMAN_EV_CNT));
     2159        WARN_ON(event >= FMAN_EV_CNT);
    20812160
    20822161        fman->intr_mng[event].isr_cb = NULL;
    20832162        fman->intr_mng[event].src_handle = NULL;
    20842163}
    2085 
     2164EXPORT_SYMBOL(fman_unregister_intr);
     2165
     2166/**
     2167 * fman_set_port_params
     2168 * @fman:               A Pointer to FMan device
     2169 * @port_params:        Port parameters
     2170 *
     2171 * Used by FMan Port to pass parameters to the FMan
     2172 *
     2173 * Return: 0 on success; Error code otherwise.
     2174 */
    20862175int fman_set_port_params(struct fman *fman,
    20872176                         struct fman_port_init_params *port_params)
    20882177{
    20892178        int err;
    2090         unsigned long int_flags;
     2179        unsigned long flags;
    20912180        u8 port_id = port_params->port_id, mac_id;
    2092         struct fman_rg fman_rg;
    2093 
    2094         fman_rg.bmi_rg = fman->bmi_regs;
    2095         fman_rg.qmi_rg = fman->qmi_regs;
    2096         fman_rg.fpm_rg = fman->fpm_regs;
    2097         fman_rg.dma_rg = fman->dma_regs;
    2098 
    2099         spin_lock_irqsave(&fman->spinlock, int_flags);
     2181
     2182        spin_lock_irqsave(&fman->spinlock, flags);
    21002183
    21012184        err = set_num_of_tasks(fman, port_params->port_id,
    21022185                               &port_params->num_of_tasks,
    21032186                               &port_params->num_of_extra_tasks);
    2104         if (err) {
    2105                 spin_unlock_irqrestore(&fman->spinlock, int_flags);
    2106                 return err;
    2107         }
     2187        if (err)
     2188                goto return_err;
    21082189
    21092190        /* TX Ports */
     
    21142195                fman->state->accumulated_num_of_deq_tnums +=
    21152196                        port_params->deq_pipeline_depth;
    2116                 enq_th = (ioread32be(&fman_rg.qmi_rg->fmqm_gc) &
     2197                enq_th = (ioread32be(&fman->qmi_regs->fmqm_gc) &
    21172198                          QMI_CFG_ENQ_MASK) >> QMI_CFG_ENQ_SHIFT;
    21182199                /* if enq_th is too big, we reduce it to the max value
     
    21252206                        fman->state->accumulated_num_of_deq_tnums - 1;
    21262207
    2127                         reg = ioread32be(&fman_rg.qmi_rg->fmqm_gc);
     2208                        reg = ioread32be(&fman->qmi_regs->fmqm_gc);
    21282209                        reg &= ~QMI_CFG_ENQ_MASK;
    21292210                        reg |= (enq_th << QMI_CFG_ENQ_SHIFT);
    2130                         iowrite32be(reg, &fman_rg.qmi_rg->fmqm_gc);
     2211                        iowrite32be(reg, &fman->qmi_regs->fmqm_gc);
    21312212                }
    21322213
    2133                 deq_th = ioread32be(&fman_rg.qmi_rg->fmqm_gc) &
     2214                deq_th = ioread32be(&fman->qmi_regs->fmqm_gc) &
    21342215                                    QMI_CFG_DEQ_MASK;
    21352216                /* if deq_th is too small, we enlarge it to the min