Changeset cf40770 in rtems-libbsd for linux


Ignore:
Timestamp:
May 18, 2017, 5:27:33 AM (2 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
c1e05b9ea378b2971e3d7704779112b4bc4296da, 4a77611a223ea883fb548679b516d326a020d447
Children:
b3a6ad0
Parents:
721b1c1
git-author:
Sebastian Huber <sebastian.huber@…> (05/18/17 05:27:33)
git-committer:
Sebastian Huber <sebastian.huber@…> (10/23/17 07:24:05)
Message:

Linux update to 4.12-rc1+

Linux baseline b23afd384801711ab6dbccd259cc14cb09a1dcaf.

Location:
linux
Files:
12 edited

Legend:

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

    r721b1c1 rcf40770  
    144144#define FM_L4_PARSE_RESULT_TCP  0x20
    145145
     146/* FD status field indicating whether the FM Parser has attempted to validate
     147 * the L4 csum of the frame.
     148 * Note that having this bit set doesn't necessarily imply that the checksum
     149 * is valid. One would have to check the parse results to find that out.
     150 */
     151#define FM_FD_STAT_L4CV         0x00000004
     152
    146153#define DPAA_SGT_MAX_ENTRIES 16 /* maximum number of entries in SG Table */
    147154#define DPAA_BUFF_RELEASE_MAX 8 /* maximum number of buffers released at once */
     
    268275         */
    269276        net_dev->features |= NETIF_F_GSO;
     277        net_dev->features |= NETIF_F_RXCSUM;
    270278
    271279        net_dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
     
    371379                        netstats[j] += cpustats[j];
    372380        }
     381}
     382
     383static int dpaa_setup_tc(struct net_device *net_dev, u32 handle, __be16 proto,
     384                         struct tc_to_netdev *tc)
     385{
     386        struct dpaa_priv *priv = netdev_priv(net_dev);
     387        u8 num_tc;
     388        int i;
     389
     390        if (tc->type != TC_SETUP_MQPRIO)
     391                return -EINVAL;
     392
     393        tc->mqprio->hw = TC_MQPRIO_HW_OFFLOAD_TCS;
     394        num_tc = tc->mqprio->num_tc;
     395
     396        if (num_tc == priv->num_tc)
     397                return 0;
     398
     399        if (!num_tc) {
     400                netdev_reset_tc(net_dev);
     401                goto out;
     402        }
     403
     404        if (num_tc > DPAA_TC_NUM) {
     405                netdev_err(net_dev, "Too many traffic classes: max %d supported.\n",
     406                           DPAA_TC_NUM);
     407                return -EINVAL;
     408        }
     409
     410        netdev_set_num_tc(net_dev, num_tc);
     411
     412        for (i = 0; i < num_tc; i++)
     413                netdev_set_tc_queue(net_dev, i, DPAA_TC_TXQ_NUM,
     414                                    i * DPAA_TC_TXQ_NUM);
     415
     416out:
     417        priv->num_tc = num_tc ? : 1;
     418        netif_set_real_num_tx_queues(net_dev, priv->num_tc * DPAA_TC_TXQ_NUM);
     419        return 0;
    373420}
    374421
     
    597644/* Use multiple WQs for FQ assignment:
    598645 *      - 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).
     646 *      - Rx Error and Tx Error queues go to WQ5 (giving them a better chance
     647 *        to be scheduled, in case there are many more FQs in WQ6).
     648 *      - Rx Default goes to WQ6.
     649 *      - Tx queues go to different WQs depending on their priority. Equal
     650 *        chunks of NR_CPUS queues go to WQ6 (lowest priority), WQ2, WQ1 and
     651 *        WQ0 (highest priority).
    603652 * This ensures that Tx-confirmed buffers are timely released. In particular,
    604653 * it avoids congestion on the Tx Confirm FQs, which can pile up PFDRs if they
     
    606655 * dequeue scheduling is round-robin.
    607656 */
    608 static inline void dpaa_assign_wq(struct dpaa_fq *fq)
     657static inline void dpaa_assign_wq(struct dpaa_fq *fq, int idx)
    609658{
    610659        switch (fq->fq_type) {
     
    615664        case FQ_TYPE_RX_ERROR:
    616665        case FQ_TYPE_TX_ERROR:
    617                 fq->wq = 2;
     666                fq->wq = 5;
    618667                break;
    619668        case FQ_TYPE_RX_DEFAULT:
     669                fq->wq = 6;
     670                break;
    620671        case FQ_TYPE_TX:
    621                 fq->wq = 3;
     672                switch (idx / DPAA_TC_TXQ_NUM) {
     673                case 0:
     674                        /* Low priority (best effort) */
     675                        fq->wq = 6;
     676                        break;
     677                case 1:
     678                        /* Medium priority */
     679                        fq->wq = 2;
     680                        break;
     681                case 2:
     682                        /* High priority */
     683                        fq->wq = 1;
     684                        break;
     685                case 3:
     686                        /* Very high priority */
     687                        fq->wq = 0;
     688                        break;
     689                default:
     690                        WARN(1, "Too many TX FQs: more than %d!\n",
     691                             DPAA_ETH_TXQ_NUM);
     692                }
    622693                break;
    623694        default:
     
    647718
    648719        for (i = 0; i < count; i++)
    649                 dpaa_assign_wq(dpaa_fq + i);
     720                dpaa_assign_wq(dpaa_fq + i, i);
    650721
    651722        return dpaa_fq;
     
    9691040                 */
    9701041                if (dpaa_fq->fq_type == FQ_TYPE_TX_CONFIRM)
    971                         initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_HOLDACTIVE);
     1042                        initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_AVOIDBLOCK);
    9721043
    9731044                /* FQ placement */
     
    10591130                if (dpaa_fq->flags & QMAN_FQ_FLAG_NO_ENQUEUE) {
    10601131                        initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_CONTEXTA);
    1061                         initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_HOLDACTIVE);
     1132                        initfq.fqd.fq_ctrl |= cpu_to_be16(QM_FQCTRL_HOLDACTIVE |
     1133                                                QM_FQCTRL_CTXASTASHING);
    10621134                        initfq.fqd.context_a.stashing.exclusive =
    10631135                                QM_STASHING_EXCL_DATA | QM_STASHING_EXCL_CTX |
     
    11391211#endif /* __rtems__ */
    11401212
    1141 static 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)
     1213static int dpaa_eth_init_tx_port(struct fman_port *port, struct dpaa_fq *errq,
     1214                                 struct dpaa_fq *defq,
     1215                                 struct dpaa_buffer_layout *buf_layout)
    11441216{
    11451217        struct fman_buffer_prefix_content buf_prefix_content;
     
    11601232
    11611233        err = fman_port_config(port, &params);
    1162         if (err)
     1234        if (err) {
    11631235                pr_err("%s: fman_port_config failed\n", __func__);
     1236                return err;
     1237        }
    11641238
    11651239        err = fman_port_cfg_buf_prefix_content(port, &buf_prefix_content);
    1166         if (err)
     1240        if (err) {
    11671241                pr_err("%s: fman_port_cfg_buf_prefix_content failed\n",
    11681242                       __func__);
     1243                return err;
     1244        }
    11691245
    11701246        err = fman_port_init(port);
    11711247        if (err)
    11721248                pr_err("%s: fm_port_init failed\n", __func__);
    1173 }
    1174 
    1175 static 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)
     1249
     1250        return err;
     1251}
     1252
     1253static int dpaa_eth_init_rx_port(struct fman_port *port, struct dpaa_bp **bps,
     1254                                 size_t count, struct dpaa_fq *errq,
     1255                                 struct dpaa_fq *defq,
     1256                                 struct dpaa_buffer_layout *buf_layout)
    11791257{
    11801258        struct fman_buffer_prefix_content buf_prefix_content;
     
    12041282
    12051283        err = fman_port_config(port, &params);
    1206         if (err)
     1284        if (err) {
    12071285                pr_err("%s: fman_port_config failed\n", __func__);
     1286                return err;
     1287        }
    12081288
    12091289        err = fman_port_cfg_buf_prefix_content(port, &buf_prefix_content);
    1210         if (err)
     1290        if (err) {
    12111291                pr_err("%s: fman_port_cfg_buf_prefix_content failed\n",
    12121292                       __func__);
     1293                return err;
     1294        }
    12131295
    12141296        err = fman_port_init(port);
    12151297        if (err)
    12161298                pr_err("%s: fm_port_init failed\n", __func__);
    1217 }
    1218 
    1219 static 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)
     1299
     1300        return err;
     1301}
     1302
     1303static int dpaa_eth_init_ports(struct mac_device *mac_dev,
     1304                               struct dpaa_bp **bps, size_t count,
     1305                               struct fm_port_fqs *port_fqs,
     1306                               struct dpaa_buffer_layout *buf_layout,
     1307                               struct device *dev)
    12241308{
    12251309        struct fman_port *rxport = mac_dev->port[RX];
    12261310        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]);
     1311        int err;
     1312
     1313        err = dpaa_eth_init_tx_port(txport, port_fqs->tx_errq,
     1314                                    port_fqs->tx_defq, &buf_layout[TX]);
     1315        if (err)
     1316                return err;
     1317
     1318        err = dpaa_eth_init_rx_port(rxport, bps, count, port_fqs->rx_errq,
     1319                                    port_fqs->rx_defq, &buf_layout[RX]);
     1320
     1321        return err;
    12321322}
    12331323
     
    16401730}
    16411731
     1732static u8 rx_csum_offload(const struct dpaa_priv *priv, const struct qm_fd *fd)
     1733{
     1734        /* The parser has run and performed L4 checksum validation.
     1735         * We know there were no parser errors (and implicitly no
     1736         * L4 csum error), otherwise we wouldn't be here.
     1737         */
     1738        if ((priv->net_dev->features & NETIF_F_RXCSUM) &&
     1739            (be32_to_cpu(fd->status) & FM_FD_STAT_L4CV))
     1740                return CHECKSUM_UNNECESSARY;
     1741
     1742        /* We're here because either the parser didn't run or the L4 checksum
     1743         * was not verified. This may include the case of a UDP frame with
     1744         * checksum zero or an L4 proto other than TCP/UDP
     1745         */
     1746        return CHECKSUM_NONE;
     1747}
     1748
    16421749/* Build a linear skb around the received buffer.
    16431750 * We are guaranteed there is enough room at the end of the data buffer to
     
    16701777        skb_put(skb, qm_fd_get_length(fd));
    16711778
    1672         skb->ip_summed = CHECKSUM_NONE;
     1779        skb->ip_summed = rx_csum_offload(priv, fd);
    16731780
    16741781        return skb;
     
    17301837                                goto free_buffers;
    17311838
    1732                         skb->ip_summed = CHECKSUM_NONE;
     1839                        skb->ip_summed = rx_csum_offload(priv, fd);
    17331840
    17341841                        /* Make sure forwarded skbs will have enough space
     
    23672474        struct net_device *net_dev;
    23682475#ifndef __rtems__
    2369         u32 fd_status = fd->status;
     2476        u32 fd_status;
    23702477#endif /* __rtems__ */
    23712478        struct dpaa_bp *dpaa_bp;
     
    26742781        .ndo_set_rx_mode = dpaa_set_rx_mode,
    26752782        .ndo_do_ioctl = dpaa_ioctl,
     2783        .ndo_setup_tc = dpaa_setup_tc,
    26762784};
    26772785
     
    29763084
    29773085        /* All real interfaces need their ports initialized */
    2978         dpaa_eth_init_ports(mac_dev, dpaa_bps, DPAA_BPS_NUM, &port_fqs,
    2979                             &priv->buf_layout[0], dev);
     3086        err = dpaa_eth_init_ports(mac_dev, dpaa_bps, DPAA_BPS_NUM, &port_fqs,
     3087                                  &priv->buf_layout[0], dev);
     3088        if (err)
     3089                goto init_ports_failed;
    29803090
    29813091        priv->percpu_priv = devm_alloc_percpu(dev, *priv->percpu_priv);
     
    29953105
    29963106#ifndef __rtems__
     3107        priv->num_tc = 1;
     3108        netif_set_real_num_tx_queues(net_dev, priv->num_tc * DPAA_TC_TXQ_NUM);
     3109
    29973110        /* Initialize NAPI */
    29983111        err = dpaa_napi_add(net_dev);
     
    30183131        dpaa_napi_del(net_dev);
    30193132alloc_percpu_failed:
     3133init_ports_failed:
    30203134#ifndef __rtems__
    30213135        dpaa_fq_free(dev, &priv->dpaa_fq_list);
  • linux/drivers/net/ethernet/freescale/dpaa/dpaa_eth.h

    r721b1c1 rcf40770  
    4040#include "dpaa_eth_trace.h"
    4141
    42 #define DPAA_ETH_TXQ_NUM        NR_CPUS
     42/* Number of prioritised traffic classes */
     43#define DPAA_TC_NUM             4
     44/* Number of Tx queues per traffic class */
     45#define DPAA_TC_TXQ_NUM         NR_CPUS
     46/* Total number of Tx queues */
     47#define DPAA_ETH_TXQ_NUM        (DPAA_TC_NUM * DPAA_TC_TXQ_NUM)
    4348
    4449#ifndef __rtems__
     
    162167
    163168#ifndef __rtems__
     169        u8 num_tc;
    164170        u32 msg_enable; /* net_device message level */
    165171#endif /* __rtems__ */
  • linux/drivers/net/ethernet/freescale/fman/fman.c

    r721b1c1 rcf40770  
    6868#define FPM_OFFSET              0x000C3000
    6969#define IMEM_OFFSET             0x000C4000
     70#define HWP_OFFSET              0x000C7000
    7071#define CGP_OFFSET              0x000DB000
    7172
     
    226227
    227228#define QMI_GS_HALT_NOT_BUSY            0x00000002
     229
     230/* HWP defines */
     231#define HWP_RPIMAC_PEN                  0x00000001
    228232
    229233/* IRAM defines */
     
    484488};
    485489
     490struct fman_hwp_regs {
     491        u32 res0000[0x844 / 4];         /* 0x000..0x843 */
     492        u32 fmprrpimac; /* FM Parser Internal memory access control */
     493        u32 res[(0x1000 - 0x848) / 4];  /* 0x848..0xFFF */
     494};
     495
    486496/* Structure that holds current FMan state.
    487497 * Used for saving run time information.
     
    617627        struct fman_qmi_regs __iomem *qmi_regs;
    618628        struct fman_dma_regs __iomem *dma_regs;
     629        struct fman_hwp_regs __iomem *hwp_regs;
    619630        fman_exceptions_cb *exception_cb;
    620631        fman_bus_error_cb *bus_error_cb;
     
    10101021}
    10111022
     1023static void hwp_init(struct fman_hwp_regs __iomem *hwp_rg)
     1024{
     1025        /* enable HW Parser */
     1026        iowrite32be(HWP_RPIMAC_PEN, &hwp_rg->fmprrpimac);
     1027}
     1028
    10121029static int enable(struct fman *fman, struct fman_cfg *cfg)
    10131030{
     
    12061223                state->fm_port_num_of_cg        = 256;
    12071224                state->num_of_rx_ports  = 6;
    1208                 state->total_fifo_size  = 122 * 1024;
     1225                state->total_fifo_size  = 136 * 1024;
    12091226                break;
    12101227
     
    18061823        fman->qmi_regs = base_addr + QMI_OFFSET;
    18071824        fman->dma_regs = base_addr + DMA_OFFSET;
     1825        fman->hwp_regs = base_addr + HWP_OFFSET;
    18081826        fman->base_addr = base_addr;
    18091827
     
    20762094        /* Init QMI Registers */
    20772095        qmi_init(fman->qmi_regs, fman->cfg);
     2096
     2097        /* Init HW Parser */
     2098        hwp_init(fman->hwp_regs);
    20782099
    20792100        err = enable(fman, cfg);
  • linux/drivers/net/ethernet/freescale/fman/fman.h

    r721b1c1 rcf40770  
    144144        u8 lpid;                /* Logical port id */
    145145        u8 shimr;               /* Shim header result  */
    146         u16 l2r;                /* Layer 2 result */
    147         u16 l3r;                /* Layer 3 result */
     146        __be16 l2r;             /* Layer 2 result */
     147        __be16 l3r;             /* Layer 3 result */
    148148        u8 l4r;         /* Layer 4 result */
    149149        u8 cplan;               /* Classification plan id */
    150         u16 nxthdr;             /* Next Header  */
    151         u16 cksum;              /* Running-sum */
     150        __be16 nxthdr;          /* Next Header  */
     151        __be16 cksum;           /* Running-sum */
    152152        /* Flags&fragment-offset field of the last IP-header */
    153         u16 flags_frag_off;
     153        __be16 flags_frag_off;
    154154        /* Routing type field of a IPV6 routing extension header */
    155155        u8 route_type;
  • linux/drivers/net/ethernet/freescale/fman/fman_dtsec.c

    r721b1c1 rcf40770  
    386386        /* check RGMII support */
    387387        if (iface == PHY_INTERFACE_MODE_RGMII ||
     388            iface == PHY_INTERFACE_MODE_RGMII_ID ||
     389            iface == PHY_INTERFACE_MODE_RGMII_RXID ||
     390            iface == PHY_INTERFACE_MODE_RGMII_TXID ||
    388391            iface == PHY_INTERFACE_MODE_RMII)
    389392                if (tmp & DTSEC_ID2_INT_REDUCED_OFF)
     
    395398                        return -EINVAL;
    396399
    397         is_rgmii = iface == PHY_INTERFACE_MODE_RGMII;
     400        is_rgmii = iface == PHY_INTERFACE_MODE_RGMII ||
     401                   iface == PHY_INTERFACE_MODE_RGMII_ID ||
     402                   iface == PHY_INTERFACE_MODE_RGMII_RXID ||
     403                   iface == PHY_INTERFACE_MODE_RGMII_TXID;
    398404        is_sgmii = iface == PHY_INTERFACE_MODE_SGMII;
    399405        is_qsgmii = iface == PHY_INTERFACE_MODE_QSGMII;
  • linux/drivers/net/ethernet/freescale/fman/fman_memac.c

    r721b1c1 rcf40770  
    448448        default:
    449449                tmp |= IF_MODE_GMII;
    450                 if (phy_if == PHY_INTERFACE_MODE_RGMII)
     450                if (phy_if == PHY_INTERFACE_MODE_RGMII ||
     451                    phy_if == PHY_INTERFACE_MODE_RGMII_ID ||
     452                    phy_if == PHY_INTERFACE_MODE_RGMII_RXID ||
     453                    phy_if == PHY_INTERFACE_MODE_RGMII_TXID)
    451454                        tmp |= IF_MODE_RGMII | IF_MODE_RGMII_AUTO;
    452455        }
  • linux/drivers/net/ethernet/freescale/fman/fman_memac.h

    r721b1c1 rcf40770  
    3737
    3838#include <linux/netdevice.h>
     39#include <linux/phy_fixed.h>
    3940
    4041struct fman_mac *memac_config(struct fman_mac_params *params);
  • linux/drivers/net/ethernet/freescale/fman/fman_port.c

    r721b1c1 rcf40770  
    6767#define BMI_PORT_REGS_OFFSET                            0
    6868#define QMI_PORT_REGS_OFFSET                            0x400
     69#define HWP_PORT_REGS_OFFSET                            0x800
    6970
    7071/* Default values */
     
    187188#define NIA_ENG_QMI_ENQ                                 0x00540000
    188189#define NIA_ENG_QMI_DEQ                                 0x00580000
    189 
     190#define NIA_ENG_HWP                                     0x00440000
    190191#define NIA_BMI_AC_ENQ_FRAME                            0x00000002
    191192#define NIA_BMI_AC_TX_RELEASE                           0x000002C0
     
    322323};
    323324
     325#define HWP_HXS_COUNT 16
     326#define HWP_HXS_PHE_REPORT 0x00000800
     327#define HWP_HXS_PCAC_PSTAT 0x00000100
     328#define HWP_HXS_PCAC_PSTOP 0x00000001
     329struct fman_port_hwp_regs {
     330        struct {
     331                u32 ssa; /* Soft Sequence Attachment */
     332                u32 lcv; /* Line-up Enable Confirmation Mask */
     333        } pmda[HWP_HXS_COUNT]; /* Parse Memory Direct Access Registers */
     334        u32 reserved080[(0x3f8 - 0x080) / 4]; /* (0x080-0x3f7) */
     335        u32 fmpr_pcac; /* Configuration Access Control */
     336};
     337
    324338/* QMI dequeue prefetch modes */
    325339enum fman_port_deq_prefetch {
     
    441455        union fman_port_bmi_regs __iomem *bmi_regs;
    442456        struct fman_port_qmi_regs __iomem *qmi_regs;
     457        struct fman_port_hwp_regs __iomem *hwp_regs;
    443458
    444459        struct fman_sp_buffer_offsets buffer_offsets;
     
    526541        tmp = (u32)cfg->rx_fd_bits << BMI_NEXT_ENG_FD_BITS_SHIFT;
    527542
    528         tmp |= NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME;
     543        tmp |= NIA_ENG_HWP;
    529544        iowrite32be(tmp, &regs->fmbm_rfne);
     545
     546        /* Parser Next Engine NIA */
     547        iowrite32be(NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME, &regs->fmbm_rfpne);
    530548
    531549        /* Enqueue NIA */
     
    670688}
    671689
     690static void stop_port_hwp(struct fman_port *port)
     691{
     692        struct fman_port_hwp_regs __iomem *regs = port->hwp_regs;
     693        int cnt = 100;
     694
     695        iowrite32be(HWP_HXS_PCAC_PSTOP, &regs->fmpr_pcac);
     696
     697        while (cnt-- > 0 &&
     698               (ioread32be(&regs->fmpr_pcac) & HWP_HXS_PCAC_PSTAT))
     699                udelay(10);
     700        if (!cnt)
     701                pr_err("Timeout stopping HW Parser\n");
     702}
     703
     704static void start_port_hwp(struct fman_port *port)
     705{
     706        struct fman_port_hwp_regs __iomem *regs = port->hwp_regs;
     707        int cnt = 100;
     708
     709        iowrite32be(0, &regs->fmpr_pcac);
     710
     711        while (cnt-- > 0 &&
     712               !(ioread32be(&regs->fmpr_pcac) & HWP_HXS_PCAC_PSTAT))
     713                udelay(10);
     714        if (!cnt)
     715                pr_err("Timeout starting HW Parser\n");
     716}
     717
     718static void init_hwp(struct fman_port *port)
     719{
     720        struct fman_port_hwp_regs __iomem *regs = port->hwp_regs;
     721        int i;
     722
     723        stop_port_hwp(port);
     724
     725        for (i = 0; i < HWP_HXS_COUNT; i++) {
     726                /* enable HXS error reporting into FD[STATUS] PHE */
     727                iowrite32be(0x00000000, &regs->pmda[i].ssa);
     728                iowrite32be(0xffffffff, &regs->pmda[i].lcv);
     729        }
     730
     731        start_port_hwp(port);
     732}
     733
    672734static int init(struct fman_port *port)
    673735{
     
    678740        case FMAN_PORT_TYPE_RX:
    679741                err = init_bmi_rx(port);
     742                if (!err)
     743                        init_hwp(port);
    680744                break;
    681745        case FMAN_PORT_TYPE_TX:
     
    691755        /* Init QMI registers */
    692756        err = init_qmi(port);
    693         return err;
     757        if (err)
     758                return err;
    694759
    695760        return 0;
     
    12521317        port->cfg = kzalloc(sizeof(*port->cfg), GFP_KERNEL);
    12531318        if (!port->cfg)
    1254                 goto err_params;
     1319                return -EINVAL;
    12551320
    12561321        /* Initialize FM port parameters which will be kept by the driver */
     
    12811346        port->bmi_regs = base_addr + BMI_PORT_REGS_OFFSET;
    12821347        port->qmi_regs = base_addr + QMI_PORT_REGS_OFFSET;
     1348        port->hwp_regs = base_addr + HWP_PORT_REGS_OFFSET;
    12831349
    12841350        port->max_frame_length = DFLT_PORT_MAX_FRAME_LENGTH;
     
    13321398err_port_cfg:
    13331399        kfree(port->cfg);
    1334 err_params:
    1335         kfree(port);
    13361400        return -EINVAL;
    13371401}
  • linux/drivers/soc/fsl/qbman/qman.c

    r721b1c1 rcf40770  
    13711371                spin_unlock(&p->cgr_lock);
    13721372                dev_crit(p->config->dev, "QUERYCONGESTION timeout\n");
     1373                qman_p_irqsource_add(p, QM_PIRQ_CSCI);
    13731374                return;
    13741375        }
     
    13851386                        cgr->cb(p, cgr, qman_cgrs_get(&rr, cgr->cgrid));
    13861387        spin_unlock(&p->cgr_lock);
     1388        qman_p_irqsource_add(p, QM_PIRQ_CSCI);
    13871389}
    13881390
     
    14441446
    14451447        qm_mr_cci_consume(&p->p, num);
     1448        qman_p_irqsource_add(p, QM_PIRQ_MRI);
    14461449        preempt_enable();
    14471450}
     
    14501453{
    14511454        if (is & QM_PIRQ_CSCI) {
     1455                qman_p_irqsource_remove(p, QM_PIRQ_CSCI);
    14521456                queue_work_on(smp_processor_id(), qm_portal_wq,
    14531457                              &p->congestion_work);
     
    14611465
    14621466        if (is & QM_PIRQ_MRI) {
     1467                qman_p_irqsource_remove(p, QM_PIRQ_MRI);
    14631468                queue_work_on(smp_processor_id(), qm_portal_wq,
    14641469                              &p->mr_work);
     
    20522057}
    20532058
    2054 static int qman_query_fq_np(struct qman_fq *fq,
    2055                             struct qm_mcr_queryfq_np *np)
     2059int qman_query_fq_np(struct qman_fq *fq, struct qm_mcr_queryfq_np *np)
    20562060{
    20572061        union qm_mc_command *mcc;
     
    20792083        return ret;
    20802084}
     2085EXPORT_SYMBOL(qman_query_fq_np);
    20812086
    20822087static int qman_query_cgr(struct qman_cgr *cgr,
  • linux/drivers/soc/fsl/qbman/qman_ccsr.c

    r721b1c1 rcf40770  
    4747u16 qm_channel_pool1 = QMAN_CHANNEL_POOL1;
    4848EXPORT_SYMBOL(qm_channel_pool1);
     49u16 qm_channel_caam = QMAN_CHANNEL_CAAM;
     50EXPORT_SYMBOL(qm_channel_caam);
    4951
    5052/* Register offsets */
     
    755757        }
    756758
    757         if ((qman_ip_rev & 0xff00) >= QMAN_REV30)
     759        if ((qman_ip_rev & 0xff00) >= QMAN_REV30) {
    758760                qm_channel_pool1 = QMAN_CHANNEL_POOL1_REV3;
     761                qm_channel_caam = QMAN_CHANNEL_CAAM_REV3;
     762        }
    759763
    760764        ret = zero_priv_mem(dev, node, fqd_a, fqd_sz);
  • linux/drivers/soc/fsl/qbman/qman_priv.h

    r721b1c1 rcf40770  
    3434
    3535#include <soc/fsl/qman.h>
     36#include <linux/dma-mapping.h>
    3637#include <linux/iommu.h>
    3738
     
    8990        return ((u64)q->a_bcnt_hi << 32) | be32_to_cpu(q->a_bcnt_lo);
    9091}
    91 
    92 /* "Query FQ Non-Programmable Fields" */
    93 
    94 struct qm_mcr_queryfq_np {
    95         u8 verb;
    96         u8 result;
    97         u8 __reserved1;
    98         u8 state;               /* QM_MCR_NP_STATE_*** */
    99         u32 fqd_link;           /* 24-bit, _res2[24-31] */
    100         u16 odp_seq;            /* 14-bit, _res3[14-15] */
    101         u16 orp_nesn;           /* 14-bit, _res4[14-15] */
    102         u16 orp_ea_hseq;        /* 15-bit, _res5[15] */
    103         u16 orp_ea_tseq;        /* 15-bit, _res6[15] */
    104         u32 orp_ea_hptr;        /* 24-bit, _res7[24-31] */
    105         u32 orp_ea_tptr;        /* 24-bit, _res8[24-31] */
    106         u32 pfdr_hptr;          /* 24-bit, _res9[24-31] */
    107         u32 pfdr_tptr;          /* 24-bit, _res10[24-31] */
    108         u8 __reserved2[5];
    109         u8 is;                  /* 1-bit, _res12[1-7] */
    110         u16 ics_surp;
    111         u32 byte_cnt;
    112         u32 frm_cnt;            /* 24-bit, _res13[24-31] */
    113         u32 __reserved3;
    114         u16 ra1_sfdr;           /* QM_MCR_NP_RA1_*** */
    115         u16 ra2_sfdr;           /* QM_MCR_NP_RA2_*** */
    116         u16 __reserved4;
    117         u16 od1_sfdr;           /* QM_MCR_NP_OD1_*** */
    118         u16 od2_sfdr;           /* QM_MCR_NP_OD2_*** */
    119         u16 od3_sfdr;           /* QM_MCR_NP_OD3_*** */
    120 } __packed;
    121 
    122 #define QM_MCR_NP_STATE_FE              0x10
    123 #define QM_MCR_NP_STATE_R               0x08
    124 #define QM_MCR_NP_STATE_MASK            0x07    /* Reads FQD::STATE; */
    125 #define QM_MCR_NP_STATE_OOS             0x00
    126 #define QM_MCR_NP_STATE_RETIRED         0x01
    127 #define QM_MCR_NP_STATE_TEN_SCHED       0x02
    128 #define QM_MCR_NP_STATE_TRU_SCHED       0x03
    129 #define QM_MCR_NP_STATE_PARKED          0x04
    130 #define QM_MCR_NP_STATE_ACTIVE          0x05
    131 #define QM_MCR_NP_PTR_MASK              0x07ff  /* for RA[12] & OD[123] */
    132 #define QM_MCR_NP_RA1_NRA(v)            (((v) >> 14) & 0x3)     /* FQD::NRA */
    133 #define QM_MCR_NP_RA2_IT(v)             (((v) >> 14) & 0x1)     /* FQD::IT */
    134 #define QM_MCR_NP_OD1_NOD(v)            (((v) >> 14) & 0x3)     /* FQD::NOD */
    135 #define QM_MCR_NP_OD3_NPC(v)            (((v) >> 14) & 0x3)     /* FQD::NPC */
    136 
    137 enum qm_mcr_queryfq_np_masks {
    138         qm_mcr_fqd_link_mask = BIT(24)-1,
    139         qm_mcr_odp_seq_mask = BIT(14)-1,
    140         qm_mcr_orp_nesn_mask = BIT(14)-1,
    141         qm_mcr_orp_ea_hseq_mask = BIT(15)-1,
    142         qm_mcr_orp_ea_tseq_mask = BIT(15)-1,
    143         qm_mcr_orp_ea_hptr_mask = BIT(24)-1,
    144         qm_mcr_orp_ea_tptr_mask = BIT(24)-1,
    145         qm_mcr_pfdr_hptr_mask = BIT(24)-1,
    146         qm_mcr_pfdr_tptr_mask = BIT(24)-1,
    147         qm_mcr_is_mask = BIT(1)-1,
    148         qm_mcr_frm_cnt_mask = BIT(24)-1,
    149 };
    150 #define qm_mcr_np_get(np, field) \
    151         ((np)->field & (qm_mcr_##field##_mask))
    15292
    15393/* Congestion Groups */
     
    274214int qman_query_fq(struct qman_fq *fq, struct qm_fqd *fqd);
    275215
    276 /*
    277  * For qman_volatile_dequeue(); Choose one PRECEDENCE. EXACT is optional. Use
    278  * NUMFRAMES(n) (6-bit) or NUMFRAMES_TILLEMPTY to fill in the frame-count. Use
    279  * FQID(n) to fill in the frame queue ID.
    280  */
    281 #define QM_VDQCR_PRECEDENCE_VDQCR       0x0
    282 #define QM_VDQCR_PRECEDENCE_SDQCR       0x80000000
    283 #define QM_VDQCR_EXACT                  0x40000000
    284 #define QM_VDQCR_NUMFRAMES_MASK         0x3f000000
    285 #define QM_VDQCR_NUMFRAMES_SET(n)       (((n) & 0x3f) << 24)
    286 #define QM_VDQCR_NUMFRAMES_GET(n)       (((n) >> 24) & 0x3f)
    287 #define QM_VDQCR_NUMFRAMES_TILLEMPTY    QM_VDQCR_NUMFRAMES_SET(0)
    288 
    289 #define QMAN_VOLATILE_FLAG_WAIT      0x00000001 /* wait if VDQCR is in use */
    290 #define QMAN_VOLATILE_FLAG_WAIT_INT  0x00000002 /* if wait, interruptible? */
    291 #define QMAN_VOLATILE_FLAG_FINISH    0x00000004 /* wait till VDQCR completes */
    292 
    293 /*
    294  * qman_volatile_dequeue - Issue a volatile dequeue command
    295  * @fq: the frame queue object to dequeue from
    296  * @flags: a bit-mask of QMAN_VOLATILE_FLAG_*** options
    297  * @vdqcr: bit mask of QM_VDQCR_*** options, as per qm_dqrr_vdqcr_set()
    298  *
    299  * Attempts to lock access to the portal's VDQCR volatile dequeue functionality.
    300  * The function will block and sleep if QMAN_VOLATILE_FLAG_WAIT is specified and
    301  * the VDQCR is already in use, otherwise returns non-zero for failure. If
    302  * QMAN_VOLATILE_FLAG_FINISH is specified, the function will only return once
    303  * the VDQCR command has finished executing (ie. once the callback for the last
    304  * DQRR entry resulting from the VDQCR command has been called). If not using
    305  * the FINISH flag, completion can be determined either by detecting the
    306  * presence of the QM_DQRR_STAT_UNSCHEDULED and QM_DQRR_STAT_DQCR_EXPIRED bits
    307  * in the "stat" parameter passed to the FQ's dequeue callback, or by waiting
    308  * for the QMAN_FQ_STATE_VDQCR bit to disappear.
    309  */
    310 int qman_volatile_dequeue(struct qman_fq *fq, u32 flags, u32 vdqcr);
    311 
    312216int qman_alloc_fq_table(u32 num_fqids);
    313217
  • linux/include/soc/fsl/qman.h

    r721b1c1 rcf40770  
    3838#define QM_CHANNEL_SWPORTAL0 0
    3939#define QMAN_CHANNEL_POOL1 0x21
     40#define QMAN_CHANNEL_CAAM 0x80
    4041#define QMAN_CHANNEL_POOL1_REV3 0x401
     42#define QMAN_CHANNEL_CAAM_REV3 0x840
    4143extern u16 qm_channel_pool1;
     44extern u16 qm_channel_caam;
    4245
    4346/* Portal processing (interrupt) sources */
     
    167170        qm_fd_set_param(fd, qm_fd_contig_big, 0, len)
    168171#define qm_fd_set_sg_big(fd, len) qm_fd_set_param(fd, qm_fd_sg_big, 0, len)
     172#define qm_fd_set_compound(fd, len) qm_fd_set_param(fd, qm_fd_compound, 0, len)
    169173
    170174static inline void qm_fd_clear_fd(struct qm_fd *fd)
     
    641645
    642646#define QMAN_CGR_FLAG_USE_INIT       0x00000001
     647#define QMAN_CGR_MODE_FRAME          0x00000001
    643648
    644649        /* Portal and Frame Queues */
     
    792797#define QMAN_INITFQ_FLAG_SCHED       0x00000001 /* schedule rather than park */
    793798#define QMAN_INITFQ_FLAG_LOCAL       0x00000004 /* set dest portal */
     799
     800/*
     801 * For qman_volatile_dequeue(); Choose one PRECEDENCE. EXACT is optional. Use
     802 * NUMFRAMES(n) (6-bit) or NUMFRAMES_TILLEMPTY to fill in the frame-count. Use
     803 * FQID(n) to fill in the frame queue ID.
     804 */
     805#define QM_VDQCR_PRECEDENCE_VDQCR       0x0
     806#define QM_VDQCR_PRECEDENCE_SDQCR       0x80000000
     807#define QM_VDQCR_EXACT                  0x40000000
     808#define QM_VDQCR_NUMFRAMES_MASK         0x3f000000
     809#define QM_VDQCR_NUMFRAMES_SET(n)       (((n) & 0x3f) << 24)
     810#define QM_VDQCR_NUMFRAMES_GET(n)       (((n) >> 24) & 0x3f)
     811#define QM_VDQCR_NUMFRAMES_TILLEMPTY    QM_VDQCR_NUMFRAMES_SET(0)
     812
     813#define QMAN_VOLATILE_FLAG_WAIT      0x00000001 /* wait if VDQCR is in use */
     814#define QMAN_VOLATILE_FLAG_WAIT_INT  0x00000002 /* if wait, interruptible? */
     815#define QMAN_VOLATILE_FLAG_FINISH    0x00000004 /* wait till VDQCR completes */
     816
     817/* "Query FQ Non-Programmable Fields" */
     818struct qm_mcr_queryfq_np {
     819        u8 verb;
     820        u8 result;
     821        u8 __reserved1;
     822        u8 state;               /* QM_MCR_NP_STATE_*** */
     823        u32 fqd_link;           /* 24-bit, _res2[24-31] */
     824        u16 odp_seq;            /* 14-bit, _res3[14-15] */
     825        u16 orp_nesn;           /* 14-bit, _res4[14-15] */
     826        u16 orp_ea_hseq;        /* 15-bit, _res5[15] */
     827        u16 orp_ea_tseq;        /* 15-bit, _res6[15] */
     828        u32 orp_ea_hptr;        /* 24-bit, _res7[24-31] */
     829        u32 orp_ea_tptr;        /* 24-bit, _res8[24-31] */
     830        u32 pfdr_hptr;          /* 24-bit, _res9[24-31] */
     831        u32 pfdr_tptr;          /* 24-bit, _res10[24-31] */
     832        u8 __reserved2[5];
     833        u8 is;                  /* 1-bit, _res12[1-7] */
     834        u16 ics_surp;
     835        u32 byte_cnt;
     836        u32 frm_cnt;            /* 24-bit, _res13[24-31] */
     837        u32 __reserved3;
     838        u16 ra1_sfdr;           /* QM_MCR_NP_RA1_*** */
     839        u16 ra2_sfdr;           /* QM_MCR_NP_RA2_*** */
     840        u16 __reserved4;
     841        u16 od1_sfdr;           /* QM_MCR_NP_OD1_*** */
     842        u16 od2_sfdr;           /* QM_MCR_NP_OD2_*** */
     843        u16 od3_sfdr;           /* QM_MCR_NP_OD3_*** */
     844} __packed;
     845
     846#define QM_MCR_NP_STATE_FE              0x10
     847#define QM_MCR_NP_STATE_R               0x08
     848#define QM_MCR_NP_STATE_MASK            0x07    /* Reads FQD::STATE; */
     849#define QM_MCR_NP_STATE_OOS             0x00
     850#define QM_MCR_NP_STATE_RETIRED         0x01
     851#define QM_MCR_NP_STATE_TEN_SCHED       0x02
     852#define QM_MCR_NP_STATE_TRU_SCHED       0x03
     853#define QM_MCR_NP_STATE_PARKED          0x04
     854#define QM_MCR_NP_STATE_ACTIVE          0x05
     855#define QM_MCR_NP_PTR_MASK              0x07ff  /* for RA[12] & OD[123] */
     856#define QM_MCR_NP_RA1_NRA(v)            (((v) >> 14) & 0x3)     /* FQD::NRA */
     857#define QM_MCR_NP_RA2_IT(v)             (((v) >> 14) & 0x1)     /* FQD::IT */
     858#define QM_MCR_NP_OD1_NOD(v)            (((v) >> 14) & 0x3)     /* FQD::NOD */
     859#define QM_MCR_NP_OD3_NPC(v)            (((v) >> 14) & 0x3)     /* FQD::NPC */
     860
     861enum qm_mcr_queryfq_np_masks {
     862        qm_mcr_fqd_link_mask = BIT(24) - 1,
     863        qm_mcr_odp_seq_mask = BIT(14) - 1,
     864        qm_mcr_orp_nesn_mask = BIT(14) - 1,
     865        qm_mcr_orp_ea_hseq_mask = BIT(15) - 1,
     866        qm_mcr_orp_ea_tseq_mask = BIT(15) - 1,
     867        qm_mcr_orp_ea_hptr_mask = BIT(24) - 1,
     868        qm_mcr_orp_ea_tptr_mask = BIT(24) - 1,
     869        qm_mcr_pfdr_hptr_mask = BIT(24) - 1,
     870        qm_mcr_pfdr_tptr_mask = BIT(24) - 1,
     871        qm_mcr_is_mask = BIT(1) - 1,
     872        qm_mcr_frm_cnt_mask = BIT(24) - 1,
     873};
     874
     875#define qm_mcr_np_get(np, field) \
     876        ((np)->field & (qm_mcr_##field##_mask))
    794877
    795878        /* Portal Management */
     
    9671050int qman_oos_fq(struct qman_fq *fq);
    9681051
     1052/*
     1053 * qman_volatile_dequeue - Issue a volatile dequeue command
     1054 * @fq: the frame queue object to dequeue from
     1055 * @flags: a bit-mask of QMAN_VOLATILE_FLAG_*** options
     1056 * @vdqcr: bit mask of QM_VDQCR_*** options, as per qm_dqrr_vdqcr_set()
     1057 *
     1058 * Attempts to lock access to the portal's VDQCR volatile dequeue functionality.
     1059 * The function will block and sleep if QMAN_VOLATILE_FLAG_WAIT is specified and
     1060 * the VDQCR is already in use, otherwise returns non-zero for failure. If
     1061 * QMAN_VOLATILE_FLAG_FINISH is specified, the function will only return once
     1062 * the VDQCR command has finished executing (ie. once the callback for the last
     1063 * DQRR entry resulting from the VDQCR command has been called). If not using
     1064 * the FINISH flag, completion can be determined either by detecting the
     1065 * presence of the QM_DQRR_STAT_UNSCHEDULED and QM_DQRR_STAT_DQCR_EXPIRED bits
     1066 * in the "stat" parameter passed to the FQ's dequeue callback, or by waiting
     1067 * for the QMAN_FQ_STATE_VDQCR bit to disappear.
     1068 */
     1069int qman_volatile_dequeue(struct qman_fq *fq, u32 flags, u32 vdqcr);
     1070
    9691071/**
    9701072 * qman_enqueue - Enqueue a frame to a frame queue
     
    9971099 */
    9981100int qman_release_fqid(u32 fqid);
     1101
     1102/**
     1103 * qman_query_fq_np - Queries non-programmable FQD fields
     1104 * @fq: the frame queue object to be queried
     1105 * @np: storage for the queried FQD fields
     1106 */
     1107int qman_query_fq_np(struct qman_fq *fq, struct qm_mcr_queryfq_np *np);
    9991108
    10001109        /* Pool-channel management */
Note: See TracChangeset for help on using the changeset viewer.