src/plugins/avf/output.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2018 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17
  18 #include <vlib/vlib.h>
  19 #include <vlib/unix/unix.h>
  20 #include <vlib/pci/pci.h>
  21 #include <vnet/ethernet/ethernet.h>
  22 #include <vnet/devices/devices.h>
  23
  24 #include <avf/avf.h>
  25
  26 #define AVF_TXQ_DESC_CMD(x)             (1 << (x + 4))
  27 #define AVF_TXQ_DESC_CMD_EOP            AVF_TXQ_DESC_CMD(0)
  28 #define AVF_TXQ_DESC_CMD_RS             AVF_TXQ_DESC_CMD(1)
  29 #define AVF_TXQ_DESC_CMD_RSV            AVF_TXQ_DESC_CMD(2)
  30
  31 static_always_inline u8
  32 avf_tx_desc_get_dtyp (avf_tx_desc_t * d)
  33 {
  34   return d->qword[1] & 0x0f;
  35 }
  36
  37 VNET_DEVICE_CLASS_TX_FN (avf_device_class) (vlib_main_t * vm,
  38                                             vlib_node_runtime_t * node,
  39                                             vlib_frame_t * frame)
  40 {
  41   avf_main_t *am = &avf_main;
  42   vnet_interface_output_runtime_t *rd = (void *) node->runtime_data;
  43   avf_device_t *ad = pool_elt_at_index (am->devices, rd->dev_instance);
  44   u32 thread_index = vm->thread_index;
  45   u8 qid = thread_index;
  46   avf_txq_t *txq = vec_elt_at_index (ad->txqs, qid % ad->num_queue_pairs);
  47   avf_tx_desc_t *d0, *d1, *d2, *d3;
  48   u32 *buffers = vlib_frame_vector_args (frame);
  49   u32 bi0, bi1, bi2, bi3;
  50   u16 n_left, n_left_to_send, n_in_batch;
  51   vlib_buffer_t *b0, *b1, *b2, *b3;
  52   u16 next;
  53   u16 n_retry = 5;
  54   u16 mask = txq->size - 1;
  55   u64 bits = (AVF_TXQ_DESC_CMD_EOP | AVF_TXQ_DESC_CMD_RS |
  56               AVF_TXQ_DESC_CMD_RSV);
  57
  58   clib_spinlock_lock_if_init (&txq->lock);
  59
  60   n_left_to_send = frame->n_vectors;
  61   next = txq->next;
  62
  63 retry:
  64   /* release consumed bufs */
  65   if (txq->n_enqueued)
  66     {
  67       u16 first, slot, n_free = 0;
  68       first = slot = (next - txq->n_enqueued) & mask;
  69       d0 = txq->descs + slot;
  70       while (n_free < txq->n_enqueued && avf_tx_desc_get_dtyp (d0) == 0x0F)
  71         {
  72           n_free++;
  73           slot = (slot + 1) & mask;
  74           d0 = txq->descs + slot;
  75         }
  76
  77       if (n_free)
  78         {
  79           txq->n_enqueued -= n_free;
  80           vlib_buffer_free_from_ring (vm, txq->bufs, first, txq->size,
  81                                       n_free);
  82         }
  83     }
  84
  85   n_in_batch = clib_min (n_left_to_send, txq->size - txq->n_enqueued - 8);
  86   n_left = n_in_batch;
  87
  88   while (n_left >= 8)
  89     {
  90       u16 slot0, slot1, slot2, slot3;
  91
  92       vlib_prefetch_buffer_with_index (vm, buffers[4], LOAD);
  93       vlib_prefetch_buffer_with_index (vm, buffers[5], LOAD);
  94       vlib_prefetch_buffer_with_index (vm, buffers[6], LOAD);
  95       vlib_prefetch_buffer_with_index (vm, buffers[7], LOAD);
  96
  97       slot0 = next;
  98       slot1 = (next + 1) & mask;
  99       slot2 = (next + 2) & mask;
 100       slot3 = (next + 3) & mask;
 101
 102       d0 = txq->descs + slot0;
 103       d1 = txq->descs + slot1;
 104       d2 = txq->descs + slot2;
 105       d3 = txq->descs + slot3;
 106
 107       bi0 = buffers[0];
 108       bi1 = buffers[1];
 109       bi2 = buffers[2];
 110       bi3 = buffers[3];
 111
 112       txq->bufs[slot0] = bi0;
 113       txq->bufs[slot1] = bi1;
 114       txq->bufs[slot2] = bi2;
 115       txq->bufs[slot3] = bi3;
 116       b0 = vlib_get_buffer (vm, bi0);
 117       b1 = vlib_get_buffer (vm, bi1);
 118       b2 = vlib_get_buffer (vm, bi2);
 119       b3 = vlib_get_buffer (vm, bi3);
 120
 121       if (ad->flags & AVF_DEVICE_F_VA_DMA)
 122         {
 123           d0->qword[0] = vlib_buffer_get_current_va (b0);
 124           d1->qword[0] = vlib_buffer_get_current_va (b1);
 125           d2->qword[0] = vlib_buffer_get_current_va (b2);
 126           d3->qword[0] = vlib_buffer_get_current_va (b3);
 127         }
 128       else
 129         {
 130           d0->qword[0] = vlib_buffer_get_current_pa (vm, b0);
 131           d1->qword[0] = vlib_buffer_get_current_pa (vm, b1);
 132           d2->qword[0] = vlib_buffer_get_current_pa (vm, b2);
 133           d3->qword[0] = vlib_buffer_get_current_pa (vm, b3);
 134         }
 135
 136       d0->qword[1] = ((u64) b0->current_length) << 34 | bits;
 137       d1->qword[1] = ((u64) b1->current_length) << 34 | bits;
 138       d2->qword[1] = ((u64) b2->current_length) << 34 | bits;
 139       d3->qword[1] = ((u64) b3->current_length) << 34 | bits;
 140
 141       next = (next + 4) & mask;
 142       txq->n_enqueued += 4;
 143       buffers += 4;
 144       n_left -= 4;
 145     }
 146
 147   while (n_left)
 148     {
 149       d0 = txq->descs + next;
 150       bi0 = buffers[0];
 151       txq->bufs[next] = bi0;
 152       b0 = vlib_get_buffer (vm, bi0);
 153
 154       if (ad->flags & AVF_DEVICE_F_VA_DMA)
 155         d0->qword[0] = vlib_buffer_get_current_va (b0);
 156       else
 157         d0->qword[0] = vlib_buffer_get_current_pa (vm, b0);
 158
 159       d0->qword[1] = (((u64) b0->current_length) << 34) | bits;
 160
 161       next = (next + 1) & mask;
 162       txq->n_enqueued++;
 163       buffers++;
 164       n_left--;
 165     }
 166
 167   CLIB_MEMORY_BARRIER ();
 168   *(txq->qtx_tail) = txq->next = next;
 169
 170   n_left_to_send -= n_in_batch;
 171
 172   if (n_left_to_send)
 173     {
 174       if (n_retry--)
 175         goto retry;
 176
 177       vlib_buffer_free (vm, buffers, n_left_to_send);
 178       vlib_error_count (vm, node->node_index,
 179                         AVF_TX_ERROR_NO_FREE_SLOTS, n_left_to_send);
 180     }
 181
 182   clib_spinlock_unlock_if_init (&txq->lock);
 183
 184   return frame->n_vectors - n_left;
 185 }
 186
 187 /*
 188  * fd.io coding-style-patch-verification: ON
 189  *
 190  * Local Variables:
 191  * eval: (c-set-style "gnu")
 192  * End:
 193  */