net/af_packet: make qdisc bypass configurable
[dpdk.git] / drivers / net / ark / ark_ethdev_tx.c
1 /*-
2  * BSD LICENSE
3  *
4  * Copyright (c) 2015-2017 Atomic Rules LLC
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * * Redistributions of source code must retain the above copyright
12  * notice, this list of conditions and the following disclaimer.
13  * * Redistributions in binary form must reproduce the above copyright
14  * notice, this list of conditions and the following disclaimer in
15  * the documentation and/or other materials provided with the
16  * distribution.
17  * * Neither the name of copyright holder nor the names of its
18  * contributors may be used to endorse or promote products derived
19  * from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include <unistd.h>
35
36 #include "ark_ethdev_tx.h"
37 #include "ark_global.h"
38 #include "ark_mpu.h"
39 #include "ark_ddm.h"
40 #include "ark_logs.h"
41
42 #define ARK_TX_META_SIZE   32
43 #define ARK_TX_META_OFFSET (RTE_PKTMBUF_HEADROOM - ARK_TX_META_SIZE)
44 #define ARK_TX_MAX_NOCHAIN (RTE_MBUF_DEFAULT_DATAROOM)
45
46
47 /* ************************************************************************* */
48 struct ark_tx_queue {
49         struct ark_tx_meta *meta_q;
50         struct rte_mbuf **bufs;
51
52         /* handles for hw objects */
53         struct ark_mpu_t *mpu;
54         struct ark_ddm_t *ddm;
55
56         /* Stats HW tracks bytes and packets, need to count send errors */
57         uint64_t tx_errors;
58
59         uint32_t queue_size;
60         uint32_t queue_mask;
61
62         /* 3 indexes to the paired data rings. */
63         uint32_t prod_index;            /* where to put the next one */
64         uint32_t free_index;            /* mbuf has been freed */
65
66         /* The queue Id is used to identify the HW Q */
67         uint16_t phys_qid;
68         /* The queue Index within the dpdk device structures */
69         uint16_t queue_index;
70
71         uint32_t pad[1];
72
73         /* second cache line - fields only used in slow path */
74         MARKER cacheline1 __rte_cache_min_aligned;
75         uint32_t cons_index;            /* hw is done, can be freed */
76 } __rte_cache_aligned;
77
78 /* Forward declarations */
79 static uint32_t eth_ark_tx_jumbo(struct ark_tx_queue *queue,
80                                  struct rte_mbuf *mbuf);
81 static int eth_ark_tx_hw_queue_config(struct ark_tx_queue *queue);
82 static void free_completed_tx(struct ark_tx_queue *queue);
83
84 static inline void
85 ark_tx_hw_queue_stop(struct ark_tx_queue *queue)
86 {
87         ark_mpu_stop(queue->mpu);
88 }
89
90 /* ************************************************************************* */
91 static inline void
92 eth_ark_tx_meta_from_mbuf(struct ark_tx_meta *meta,
93                           const struct rte_mbuf *mbuf,
94                           uint8_t flags)
95 {
96         meta->physaddr = rte_mbuf_data_dma_addr(mbuf);
97         meta->delta_ns = 0;
98         meta->data_len = rte_pktmbuf_data_len(mbuf);
99         meta->flags = flags;
100 }
101
102 /* ************************************************************************* */
103 uint16_t
104 eth_ark_xmit_pkts_noop(void *vtxq __rte_unused,
105                        struct rte_mbuf **tx_pkts __rte_unused,
106                        uint16_t nb_pkts __rte_unused)
107 {
108         return 0;
109 }
110
111 /* ************************************************************************* */
112 uint16_t
113 eth_ark_xmit_pkts(void *vtxq, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
114 {
115         struct ark_tx_queue *queue;
116         struct rte_mbuf *mbuf;
117         struct ark_tx_meta *meta;
118
119         uint32_t idx;
120         uint32_t prod_index_limit;
121         int stat;
122         uint16_t nb;
123
124         queue = (struct ark_tx_queue *)vtxq;
125
126         /* free any packets after the HW is done with them */
127         free_completed_tx(queue);
128
129         prod_index_limit = queue->queue_size + queue->free_index;
130
131         for (nb = 0;
132              (nb < nb_pkts) && (queue->prod_index != prod_index_limit);
133              ++nb) {
134                 mbuf = tx_pkts[nb];
135
136                 if (ARK_TX_PAD_TO_60) {
137                         if (unlikely(rte_pktmbuf_pkt_len(mbuf) < 60)) {
138                                 /* this packet even if it is small can be split,
139                                  * be sure to add to the end mbuf
140                                  */
141                                 uint16_t to_add =
142                                         60 - rte_pktmbuf_pkt_len(mbuf);
143                                 char *appended =
144                                         rte_pktmbuf_append(mbuf, to_add);
145
146                                 if (appended == 0) {
147                                         /* This packet is in error,
148                                          * we cannot send it so just
149                                          * count it and delete it.
150                                          */
151                                         queue->tx_errors += 1;
152                                         rte_pktmbuf_free(mbuf);
153                                         continue;
154                                 }
155                                 memset(appended, 0, to_add);
156                         }
157                 }
158
159                 if (unlikely(mbuf->nb_segs != 1)) {
160                         stat = eth_ark_tx_jumbo(queue, mbuf);
161                         if (unlikely(stat != 0))
162                                 break;          /* Queue is full */
163                 } else {
164                         idx = queue->prod_index & queue->queue_mask;
165                         queue->bufs[idx] = mbuf;
166                         meta = &queue->meta_q[idx];
167                         eth_ark_tx_meta_from_mbuf(meta,
168                                                   mbuf,
169                                                   ARK_DDM_SOP |
170                                                   ARK_DDM_EOP);
171                         queue->prod_index++;
172                 }
173         }
174
175         if (ARK_TX_DEBUG && (nb != nb_pkts)) {
176                 PMD_TX_LOG(DEBUG, "TX: Failure to send:"
177                            " req: %" PRIU32
178                            " sent: %" PRIU32
179                            " prod: %" PRIU32
180                            " cons: %" PRIU32
181                            " free: %" PRIU32 "\n",
182                            nb_pkts, nb,
183                            queue->prod_index,
184                            queue->cons_index,
185                            queue->free_index);
186                 ark_mpu_dump(queue->mpu,
187                              "TX Failure MPU: ",
188                              queue->phys_qid);
189         }
190
191         /* let FPGA know producer index.  */
192         if (likely(nb != 0))
193                 ark_mpu_set_producer(queue->mpu, queue->prod_index);
194
195         return nb;
196 }
197
198 /* ************************************************************************* */
199 static uint32_t
200 eth_ark_tx_jumbo(struct ark_tx_queue *queue, struct rte_mbuf *mbuf)
201 {
202         struct rte_mbuf *next;
203         struct ark_tx_meta *meta;
204         uint32_t free_queue_space;
205         uint32_t idx;
206         uint8_t flags = ARK_DDM_SOP;
207
208         free_queue_space = queue->queue_mask -
209                 (queue->prod_index - queue->free_index);
210         if (unlikely(free_queue_space < mbuf->nb_segs))
211                 return -1;
212
213         while (mbuf != NULL) {
214                 next = mbuf->next;
215
216                 idx = queue->prod_index & queue->queue_mask;
217                 queue->bufs[idx] = mbuf;
218                 meta = &queue->meta_q[idx];
219
220                 flags |= (next == NULL) ? ARK_DDM_EOP : 0;
221                 eth_ark_tx_meta_from_mbuf(meta, mbuf, flags);
222                 queue->prod_index++;
223
224                 flags &= ~ARK_DDM_SOP;  /* drop SOP flags */
225                 mbuf = next;
226         }
227
228         return 0;
229 }
230
231 /* ************************************************************************* */
232 int
233 eth_ark_tx_queue_setup(struct rte_eth_dev *dev,
234                        uint16_t queue_idx,
235                        uint16_t nb_desc,
236                        unsigned int socket_id,
237                        const struct rte_eth_txconf *tx_conf __rte_unused)
238 {
239         struct ark_adapter *ark = (struct ark_adapter *)dev->data->dev_private;
240         struct ark_tx_queue *queue;
241         int status;
242
243         /* Future: divide the Q's evenly with multi-ports */
244         int port = dev->data->port_id;
245         int qidx = port + queue_idx;
246
247         if (!rte_is_power_of_2(nb_desc)) {
248                 PMD_DRV_LOG(ERR,
249                             "DPDK Arkville configuration queue size"
250                             " must be power of two %u (%s)\n",
251                             nb_desc, __func__);
252                 return -1;
253         }
254
255         /* Allocate queue struct */
256         queue = rte_zmalloc_socket("Ark_txqueue",
257                                    sizeof(struct ark_tx_queue),
258                                    64,
259                                    socket_id);
260         if (queue == 0) {
261                 PMD_DRV_LOG(ERR, "Failed to allocate tx "
262                             "queue memory in %s\n",
263                             __func__);
264                 return -ENOMEM;
265         }
266
267         /* we use zmalloc no need to initialize fields */
268         queue->queue_size = nb_desc;
269         queue->queue_mask = nb_desc - 1;
270         queue->phys_qid = qidx;
271         queue->queue_index = queue_idx;
272         dev->data->tx_queues[queue_idx] = queue;
273
274         queue->meta_q =
275                 rte_zmalloc_socket("Ark_txqueue meta",
276                                    nb_desc * sizeof(struct ark_tx_meta),
277                                    64,
278                                    socket_id);
279         queue->bufs =
280                 rte_zmalloc_socket("Ark_txqueue bufs",
281                                    nb_desc * sizeof(struct rte_mbuf *),
282                                    64,
283                                    socket_id);
284
285         if (queue->meta_q == 0 || queue->bufs == 0) {
286                 PMD_DRV_LOG(ERR, "Failed to allocate "
287                             "queue memory in %s\n", __func__);
288                 rte_free(queue->meta_q);
289                 rte_free(queue->bufs);
290                 rte_free(queue);
291                 return -ENOMEM;
292         }
293
294         queue->ddm = RTE_PTR_ADD(ark->ddm.v, qidx * ARK_DDM_QOFFSET);
295         queue->mpu = RTE_PTR_ADD(ark->mputx.v, qidx * ARK_MPU_QOFFSET);
296
297         status = eth_ark_tx_hw_queue_config(queue);
298
299         if (unlikely(status != 0)) {
300                 rte_free(queue->meta_q);
301                 rte_free(queue->bufs);
302                 rte_free(queue);
303                 return -1;              /* ERROR CODE */
304         }
305
306         return 0;
307 }
308
309 /* ************************************************************************* */
310 static int
311 eth_ark_tx_hw_queue_config(struct ark_tx_queue *queue)
312 {
313         phys_addr_t queue_base, ring_base, cons_index_addr;
314         uint32_t write_interval_ns;
315
316         /* Verify HW -- MPU */
317         if (ark_mpu_verify(queue->mpu, sizeof(struct ark_tx_meta)))
318                 return -1;
319
320         queue_base = rte_malloc_virt2phy(queue);
321         ring_base = rte_malloc_virt2phy(queue->meta_q);
322         cons_index_addr =
323                 queue_base + offsetof(struct ark_tx_queue, cons_index);
324
325         ark_mpu_stop(queue->mpu);
326         ark_mpu_reset(queue->mpu);
327
328         /* Stop and Reset and configure MPU */
329         ark_mpu_configure(queue->mpu, ring_base, queue->queue_size, 1);
330
331         /*
332          * Adjust the write interval based on queue size --
333          * increase pcie traffic  when low mbuf count
334          * Queue sizes less than 128 are not allowed
335          */
336         switch (queue->queue_size) {
337         case 128:
338                 write_interval_ns = 500;
339                 break;
340         case 256:
341                 write_interval_ns = 500;
342                 break;
343         case 512:
344                 write_interval_ns = 1000;
345                 break;
346         default:
347                 write_interval_ns = 2000;
348                 break;
349         }
350
351         /* Completion address in UDM */
352         ark_ddm_setup(queue->ddm, cons_index_addr, write_interval_ns);
353
354         return 0;
355 }
356
357 /* ************************************************************************* */
358 void
359 eth_ark_tx_queue_release(void *vtx_queue)
360 {
361         struct ark_tx_queue *queue;
362
363         queue = (struct ark_tx_queue *)vtx_queue;
364
365         ark_tx_hw_queue_stop(queue);
366
367         queue->cons_index = queue->prod_index;
368         free_completed_tx(queue);
369
370         rte_free(queue->meta_q);
371         rte_free(queue->bufs);
372         rte_free(queue);
373 }
374
375 /* ************************************************************************* */
376 int
377 eth_ark_tx_queue_stop(struct rte_eth_dev *dev, uint16_t queue_id)
378 {
379         struct ark_tx_queue *queue;
380         int cnt = 0;
381
382         queue = dev->data->tx_queues[queue_id];
383
384         /* Wait for DDM to send out all packets. */
385         while (queue->cons_index != queue->prod_index) {
386                 usleep(100);
387                 if (cnt++ > 10000)
388                         return -1;
389         }
390
391         ark_mpu_stop(queue->mpu);
392         free_completed_tx(queue);
393
394         dev->data->tx_queue_state[queue_id] = RTE_ETH_QUEUE_STATE_STOPPED;
395
396         return 0;
397 }
398
399 int
400 eth_ark_tx_queue_start(struct rte_eth_dev *dev, uint16_t queue_id)
401 {
402         struct ark_tx_queue *queue;
403
404         queue = dev->data->tx_queues[queue_id];
405         if (dev->data->tx_queue_state[queue_id] == RTE_ETH_QUEUE_STATE_STARTED)
406                 return 0;
407
408         ark_mpu_start(queue->mpu);
409         dev->data->tx_queue_state[queue_id] = RTE_ETH_QUEUE_STATE_STARTED;
410
411         return 0;
412 }
413
414 /* ************************************************************************* */
415 static void
416 free_completed_tx(struct ark_tx_queue *queue)
417 {
418         struct rte_mbuf *mbuf;
419         struct ark_tx_meta *meta;
420         uint32_t top_index;
421
422         top_index = queue->cons_index;  /* read once */
423         while (queue->free_index != top_index) {
424                 meta = &queue->meta_q[queue->free_index & queue->queue_mask];
425                 mbuf = queue->bufs[queue->free_index & queue->queue_mask];
426
427                 if (likely((meta->flags & ARK_DDM_SOP) != 0)) {
428                         /* ref count of the mbuf is checked in this call. */
429                         rte_pktmbuf_free(mbuf);
430                 }
431                 queue->free_index++;
432         }
433 }
434
435 /* ************************************************************************* */
436 void
437 eth_tx_queue_stats_get(void *vqueue, struct rte_eth_stats *stats)
438 {
439         struct ark_tx_queue *queue;
440         struct ark_ddm_t *ddm;
441         uint64_t bytes, pkts;
442
443         queue = vqueue;
444         ddm = queue->ddm;
445
446         bytes = ark_ddm_queue_byte_count(ddm);
447         pkts = ark_ddm_queue_pkt_count(ddm);
448
449         stats->q_opackets[queue->queue_index] = pkts;
450         stats->q_obytes[queue->queue_index] = bytes;
451         stats->opackets += pkts;
452         stats->obytes += bytes;
453         stats->oerrors += queue->tx_errors;
454 }
455
456 void
457 eth_tx_queue_stats_reset(void *vqueue)
458 {
459         struct ark_tx_queue *queue;
460         struct ark_ddm_t *ddm;
461
462         queue = vqueue;
463         ddm = queue->ddm;
464
465         ark_ddm_queue_reset_stats(ddm);
466         queue->tx_errors = 0;
467 }