drivers/net/sfc/base/ef10_rx.c

   1 /*
   2  * Copyright (c) 2012-2016 Solarflare Communications Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright notice,
   9  *    this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright notice,
  11  *    this list of conditions and the following disclaimer in the documentation
  12  *    and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  21  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  22  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  24  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * The views and conclusions contained in the software and documentation are
  27  * those of the authors and should not be interpreted as representing official
  28  * policies, either expressed or implied, of the FreeBSD Project.
  29  */
  30
  31 #include "efx.h"
  32 #include "efx_impl.h"
  33
  34
  35 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD
  36
  37
  38 static  __checkReturn   efx_rc_t
  39 efx_mcdi_init_rxq(
  40         __in            efx_nic_t *enp,
  41         __in            uint32_t size,
  42         __in            uint32_t target_evq,
  43         __in            uint32_t label,
  44         __in            uint32_t instance,
  45         __in            efsys_mem_t *esmp,
  46         __in            boolean_t disable_scatter,
  47         __in            uint32_t ps_bufsize)
  48 {
  49         efx_mcdi_req_t req;
  50         uint8_t payload[MAX(MC_CMD_INIT_RXQ_EXT_IN_LEN,
  51                             MC_CMD_INIT_RXQ_EXT_OUT_LEN)];
  52         int npages = EFX_RXQ_NBUFS(size);
  53         int i;
  54         efx_qword_t *dma_addr;
  55         uint64_t addr;
  56         efx_rc_t rc;
  57         uint32_t dma_mode;
  58
  59         /* If this changes, then the payload size might need to change. */
  60         EFSYS_ASSERT3U(MC_CMD_INIT_RXQ_OUT_LEN, ==, 0);
  61         EFSYS_ASSERT3U(size, <=, EFX_RXQ_MAXNDESCS);
  62
  63         if (ps_bufsize > 0)
  64                 dma_mode = MC_CMD_INIT_RXQ_EXT_IN_PACKED_STREAM;
  65         else
  66                 dma_mode = MC_CMD_INIT_RXQ_EXT_IN_SINGLE_PACKET;
  67
  68         (void) memset(payload, 0, sizeof (payload));
  69         req.emr_cmd = MC_CMD_INIT_RXQ;
  70         req.emr_in_buf = payload;
  71         req.emr_in_length = MC_CMD_INIT_RXQ_EXT_IN_LEN;
  72         req.emr_out_buf = payload;
  73         req.emr_out_length = MC_CMD_INIT_RXQ_EXT_OUT_LEN;
  74
  75         MCDI_IN_SET_DWORD(req, INIT_RXQ_EXT_IN_SIZE, size);
  76         MCDI_IN_SET_DWORD(req, INIT_RXQ_EXT_IN_TARGET_EVQ, target_evq);
  77         MCDI_IN_SET_DWORD(req, INIT_RXQ_EXT_IN_LABEL, label);
  78         MCDI_IN_SET_DWORD(req, INIT_RXQ_EXT_IN_INSTANCE, instance);
  79         MCDI_IN_POPULATE_DWORD_8(req, INIT_RXQ_EXT_IN_FLAGS,
  80             INIT_RXQ_EXT_IN_FLAG_BUFF_MODE, 0,
  81             INIT_RXQ_EXT_IN_FLAG_HDR_SPLIT, 0,
  82             INIT_RXQ_EXT_IN_FLAG_TIMESTAMP, 0,
  83             INIT_RXQ_EXT_IN_CRC_MODE, 0,
  84             INIT_RXQ_EXT_IN_FLAG_PREFIX, 1,
  85             INIT_RXQ_EXT_IN_FLAG_DISABLE_SCATTER, disable_scatter,
  86             INIT_RXQ_EXT_IN_DMA_MODE,
  87             dma_mode,
  88             INIT_RXQ_EXT_IN_PACKED_STREAM_BUFF_SIZE, ps_bufsize);
  89         MCDI_IN_SET_DWORD(req, INIT_RXQ_EXT_IN_OWNER_ID, 0);
  90         MCDI_IN_SET_DWORD(req, INIT_RXQ_EXT_IN_PORT_ID, EVB_PORT_ID_ASSIGNED);
  91
  92         dma_addr = MCDI_IN2(req, efx_qword_t, INIT_RXQ_IN_DMA_ADDR);
  93         addr = EFSYS_MEM_ADDR(esmp);
  94
  95         for (i = 0; i < npages; i++) {
  96                 EFX_POPULATE_QWORD_2(*dma_addr,
  97                     EFX_DWORD_1, (uint32_t)(addr >> 32),
  98                     EFX_DWORD_0, (uint32_t)(addr & 0xffffffff));
  99
 100                 dma_addr++;
 101                 addr += EFX_BUF_SIZE;
 102         }
 103
 104         efx_mcdi_execute(enp, &req);
 105
 106         if (req.emr_rc != 0) {
 107                 rc = req.emr_rc;
 108                 goto fail1;
 109         }
 110
 111         return (0);
 112
 113 fail1:
 114         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 115
 116         return (rc);
 117 }
 118
 119 static  __checkReturn   efx_rc_t
 120 efx_mcdi_fini_rxq(
 121         __in            efx_nic_t *enp,
 122         __in            uint32_t instance)
 123 {
 124         efx_mcdi_req_t req;
 125         uint8_t payload[MAX(MC_CMD_FINI_RXQ_IN_LEN,
 126                             MC_CMD_FINI_RXQ_OUT_LEN)];
 127         efx_rc_t rc;
 128
 129         (void) memset(payload, 0, sizeof (payload));
 130         req.emr_cmd = MC_CMD_FINI_RXQ;
 131         req.emr_in_buf = payload;
 132         req.emr_in_length = MC_CMD_FINI_RXQ_IN_LEN;
 133         req.emr_out_buf = payload;
 134         req.emr_out_length = MC_CMD_FINI_RXQ_OUT_LEN;
 135
 136         MCDI_IN_SET_DWORD(req, FINI_RXQ_IN_INSTANCE, instance);
 137
 138         efx_mcdi_execute_quiet(enp, &req);
 139
 140         if ((req.emr_rc != 0) && (req.emr_rc != MC_CMD_ERR_EALREADY)) {
 141                 rc = req.emr_rc;
 142                 goto fail1;
 143         }
 144
 145         return (0);
 146
 147 fail1:
 148         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 149
 150         return (rc);
 151 }
 152
 153
 154         __checkReturn   efx_rc_t
 155 ef10_rx_init(
 156         __in            efx_nic_t *enp)
 157 {
 158
 159         return (0);
 160 }
 161
 162
 163 /*
 164  * EF10 RX pseudo-header
 165  * ---------------------
 166  *
 167  * Receive packets are prefixed by an (optional) 14 byte pseudo-header:
 168  *
 169  *  +00: Toeplitz hash value.
 170  *       (32bit little-endian)
 171  *  +04: Outer VLAN tag. Zero if the packet did not have an outer VLAN tag.
 172  *       (16bit big-endian)
 173  *  +06: Inner VLAN tag. Zero if the packet did not have an inner VLAN tag.
 174  *       (16bit big-endian)
 175  *  +08: Packet Length. Zero if the RX datapath was in cut-through mode.
 176  *       (16bit little-endian)
 177  *  +10: MAC timestamp. Zero if timestamping is not enabled.
 178  *       (32bit little-endian)
 179  *
 180  * See "The RX Pseudo-header" in SF-109306-TC.
 181  */
 182
 183         __checkReturn   efx_rc_t
 184 ef10_rx_prefix_pktlen(
 185         __in            efx_nic_t *enp,
 186         __in            uint8_t *buffer,
 187         __out           uint16_t *lengthp)
 188 {
 189         _NOTE(ARGUNUSED(enp))
 190
 191         /*
 192          * The RX pseudo-header contains the packet length, excluding the
 193          * pseudo-header. If the hardware receive datapath was operating in
 194          * cut-through mode then the length in the RX pseudo-header will be
 195          * zero, and the packet length must be obtained from the DMA length
 196          * reported in the RX event.
 197          */
 198         *lengthp = buffer[8] | (buffer[9] << 8);
 199         return (0);
 200 }
 201
 202                         void
 203 ef10_rx_qpost(
 204         __in            efx_rxq_t *erp,
 205         __in_ecount(n)  efsys_dma_addr_t *addrp,
 206         __in            size_t size,
 207         __in            unsigned int n,
 208         __in            unsigned int completed,
 209         __in            unsigned int added)
 210 {
 211         efx_qword_t qword;
 212         unsigned int i;
 213         unsigned int offset;
 214         unsigned int id;
 215
 216         /* The client driver must not overfill the queue */
 217         EFSYS_ASSERT3U(added - completed + n, <=,
 218             EFX_RXQ_LIMIT(erp->er_mask + 1));
 219
 220         id = added & (erp->er_mask);
 221         for (i = 0; i < n; i++) {
 222                 EFSYS_PROBE4(rx_post, unsigned int, erp->er_index,
 223                     unsigned int, id, efsys_dma_addr_t, addrp[i],
 224                     size_t, size);
 225
 226                 EFX_POPULATE_QWORD_3(qword,
 227                     ESF_DZ_RX_KER_BYTE_CNT, (uint32_t)(size),
 228                     ESF_DZ_RX_KER_BUF_ADDR_DW0,
 229                     (uint32_t)(addrp[i] & 0xffffffff),
 230                     ESF_DZ_RX_KER_BUF_ADDR_DW1,
 231                     (uint32_t)(addrp[i] >> 32));
 232
 233                 offset = id * sizeof (efx_qword_t);
 234                 EFSYS_MEM_WRITEQ(erp->er_esmp, offset, &qword);
 235
 236                 id = (id + 1) & (erp->er_mask);
 237         }
 238 }
 239
 240                         void
 241 ef10_rx_qpush(
 242         __in    efx_rxq_t *erp,
 243         __in    unsigned int added,
 244         __inout unsigned int *pushedp)
 245 {
 246         efx_nic_t *enp = erp->er_enp;
 247         unsigned int pushed = *pushedp;
 248         uint32_t wptr;
 249         efx_dword_t dword;
 250
 251         /* Hardware has alignment restriction for WPTR */
 252         wptr = P2ALIGN(added, EF10_RX_WPTR_ALIGN);
 253         if (pushed == wptr)
 254                 return;
 255
 256         *pushedp = wptr;
 257
 258         /* Push the populated descriptors out */
 259         wptr &= erp->er_mask;
 260
 261         EFX_POPULATE_DWORD_1(dword, ERF_DZ_RX_DESC_WPTR, wptr);
 262
 263         /* Guarantee ordering of memory (descriptors) and PIO (doorbell) */
 264         EFX_DMA_SYNC_QUEUE_FOR_DEVICE(erp->er_esmp, erp->er_mask + 1,
 265             wptr, pushed & erp->er_mask);
 266         EFSYS_PIO_WRITE_BARRIER();
 267         EFX_BAR_TBL_WRITED(enp, ER_DZ_RX_DESC_UPD_REG,
 268                             erp->er_index, &dword, B_FALSE);
 269 }
 270
 271         __checkReturn   efx_rc_t
 272 ef10_rx_qflush(
 273         __in    efx_rxq_t *erp)
 274 {
 275         efx_nic_t *enp = erp->er_enp;
 276         efx_rc_t rc;
 277
 278         if ((rc = efx_mcdi_fini_rxq(enp, erp->er_index)) != 0)
 279                 goto fail1;
 280
 281         return (0);
 282
 283 fail1:
 284         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 285
 286         return (rc);
 287 }
 288
 289                 void
 290 ef10_rx_qenable(
 291         __in    efx_rxq_t *erp)
 292 {
 293         /* FIXME */
 294         _NOTE(ARGUNUSED(erp))
 295         /* FIXME */
 296 }
 297
 298         __checkReturn   efx_rc_t
 299 ef10_rx_qcreate(
 300         __in            efx_nic_t *enp,
 301         __in            unsigned int index,
 302         __in            unsigned int label,
 303         __in            efx_rxq_type_t type,
 304         __in            efsys_mem_t *esmp,
 305         __in            size_t n,
 306         __in            uint32_t id,
 307         __in            efx_evq_t *eep,
 308         __in            efx_rxq_t *erp)
 309 {
 310         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 311         efx_rc_t rc;
 312         boolean_t disable_scatter;
 313         unsigned int ps_buf_size;
 314
 315         _NOTE(ARGUNUSED(id, erp))
 316
 317         EFX_STATIC_ASSERT(EFX_EV_RX_NLABELS == (1 << ESF_DZ_RX_QLABEL_WIDTH));
 318         EFSYS_ASSERT3U(label, <, EFX_EV_RX_NLABELS);
 319         EFSYS_ASSERT3U(enp->en_rx_qcount + 1, <, encp->enc_rxq_limit);
 320
 321         EFX_STATIC_ASSERT(ISP2(EFX_RXQ_MAXNDESCS));
 322         EFX_STATIC_ASSERT(ISP2(EFX_RXQ_MINNDESCS));
 323
 324         if (!ISP2(n) || (n < EFX_RXQ_MINNDESCS) || (n > EFX_RXQ_MAXNDESCS)) {
 325                 rc = EINVAL;
 326                 goto fail1;
 327         }
 328         if (index >= encp->enc_rxq_limit) {
 329                 rc = EINVAL;
 330                 goto fail2;
 331         }
 332
 333         switch (type) {
 334         case EFX_RXQ_TYPE_DEFAULT:
 335         case EFX_RXQ_TYPE_SCATTER:
 336                 ps_buf_size = 0;
 337                 break;
 338         default:
 339                 rc = ENOTSUP;
 340                 goto fail3;
 341         }
 342
 343         EFSYS_ASSERT(ps_buf_size == 0);
 344
 345         /* Scatter can only be disabled if the firmware supports doing so */
 346         if (type == EFX_RXQ_TYPE_SCATTER)
 347                 disable_scatter = B_FALSE;
 348         else
 349                 disable_scatter = encp->enc_rx_disable_scatter_supported;
 350
 351         if ((rc = efx_mcdi_init_rxq(enp, n, eep->ee_index, label, index,
 352                     esmp, disable_scatter, ps_buf_size)) != 0)
 353                 goto fail6;
 354
 355         erp->er_eep = eep;
 356         erp->er_label = label;
 357
 358         ef10_ev_rxlabel_init(eep, erp, label, ps_buf_size != 0);
 359
 360         return (0);
 361
 362 fail6:
 363         EFSYS_PROBE(fail6);
 364 fail3:
 365         EFSYS_PROBE(fail3);
 366 fail2:
 367         EFSYS_PROBE(fail2);
 368 fail1:
 369         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 370
 371         return (rc);
 372 }
 373
 374                 void
 375 ef10_rx_qdestroy(
 376         __in    efx_rxq_t *erp)
 377 {
 378         efx_nic_t *enp = erp->er_enp;
 379         efx_evq_t *eep = erp->er_eep;
 380         unsigned int label = erp->er_label;
 381
 382         ef10_ev_rxlabel_fini(eep, label);
 383
 384         EFSYS_ASSERT(enp->en_rx_qcount != 0);
 385         --enp->en_rx_qcount;
 386
 387         EFSYS_KMEM_FREE(enp->en_esip, sizeof (efx_rxq_t), erp);
 388 }
 389
 390                 void
 391 ef10_rx_fini(
 392         __in    efx_nic_t *enp)
 393 {
 394         _NOTE(ARGUNUSED(enp))
 395 }
 396
 397 #endif /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD */