source: src/linux/universal/linux-4.9/drivers/net/ethernet/mellanox/mlx4/en_rx.c @ 31884

Last change on this file since 31884 was 31884, checked in by brainslayer, 7 days ago

update kernels

File size: 38.8 KB
Line 
1/*
2 * Copyright (c) 2007 Mellanox Technologies. All rights reserved.
3 *
4 * This software is available to you under a choice of one of two
5 * licenses.  You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 *     Redistribution and use in source and binary forms, with or
11 *     without modification, are permitted provided that the following
12 *     conditions are met:
13 *
14 *      - Redistributions of source code must retain the above
15 *        copyright notice, this list of conditions and the following
16 *        disclaimer.
17 *
18 *      - Redistributions in binary form must reproduce the above
19 *        copyright notice, this list of conditions and the following
20 *        disclaimer in the documentation and/or other materials
21 *        provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 *
32 */
33
34#include <net/busy_poll.h>
35#include <linux/bpf.h>
36#include <linux/mlx4/cq.h>
37#include <linux/slab.h>
38#include <linux/mlx4/qp.h>
39#include <linux/skbuff.h>
40#include <linux/rculist.h>
41#include <linux/if_ether.h>
42#include <linux/if_vlan.h>
43#include <linux/vmalloc.h>
44#include <linux/irq.h>
45
46#if IS_ENABLED(CONFIG_IPV6)
47#include <net/ip6_checksum.h>
48#endif
49
50#include "mlx4_en.h"
51
52static int mlx4_alloc_pages(struct mlx4_en_priv *priv,
53                            struct mlx4_en_rx_alloc *page_alloc,
54                            const struct mlx4_en_frag_info *frag_info,
55                            gfp_t _gfp)
56{
57        int order;
58        struct page *page;
59        dma_addr_t dma;
60
61        for (order = frag_info->order; ;) {
62                gfp_t gfp = _gfp;
63
64                if (order)
65                        gfp |= __GFP_COMP | __GFP_NOWARN | __GFP_NOMEMALLOC;
66                page = alloc_pages(gfp, order);
67                if (likely(page))
68                        break;
69                if (--order < 0 ||
70                    ((PAGE_SIZE << order) < frag_info->frag_size))
71                        return -ENOMEM;
72        }
73        dma = dma_map_page(priv->ddev, page, 0, PAGE_SIZE << order,
74                           frag_info->dma_dir);
75        if (unlikely(dma_mapping_error(priv->ddev, dma))) {
76                put_page(page);
77                return -ENOMEM;
78        }
79        page_alloc->page_size = PAGE_SIZE << order;
80        page_alloc->page = page;
81        page_alloc->dma = dma;
82        page_alloc->page_offset = 0;
83        /* Not doing get_page() for each frag is a big win
84         * on asymetric workloads. Note we can not use atomic_set().
85         */
86        page_ref_add(page, page_alloc->page_size / frag_info->frag_stride - 1);
87        return 0;
88}
89
90static int mlx4_en_alloc_frags(struct mlx4_en_priv *priv,
91                               struct mlx4_en_rx_desc *rx_desc,
92                               struct mlx4_en_rx_alloc *frags,
93                               struct mlx4_en_rx_alloc *ring_alloc,
94                               gfp_t gfp)
95{
96        struct mlx4_en_rx_alloc page_alloc[MLX4_EN_MAX_RX_FRAGS];
97        const struct mlx4_en_frag_info *frag_info;
98        struct page *page;
99        dma_addr_t dma;
100        int i;
101
102        for (i = 0; i < priv->num_frags; i++) {
103                frag_info = &priv->frag_info[i];
104                page_alloc[i] = ring_alloc[i];
105                page_alloc[i].page_offset += frag_info->frag_stride;
106
107                if (page_alloc[i].page_offset + frag_info->frag_stride <=
108                    ring_alloc[i].page_size)
109                        continue;
110
111                if (unlikely(mlx4_alloc_pages(priv, &page_alloc[i],
112                                              frag_info, gfp)))
113                        goto out;
114        }
115
116        for (i = 0; i < priv->num_frags; i++) {
117                frags[i] = ring_alloc[i];
118                dma = ring_alloc[i].dma + ring_alloc[i].page_offset;
119                ring_alloc[i] = page_alloc[i];
120                rx_desc->data[i].addr = cpu_to_be64(dma);
121        }
122
123        return 0;
124
125out:
126        while (i--) {
127                if (page_alloc[i].page != ring_alloc[i].page) {
128                        dma_unmap_page(priv->ddev, page_alloc[i].dma,
129                                page_alloc[i].page_size,
130                                priv->frag_info[i].dma_dir);
131                        page = page_alloc[i].page;
132                        /* Revert changes done by mlx4_alloc_pages */
133                        page_ref_sub(page, page_alloc[i].page_size /
134                                           priv->frag_info[i].frag_stride - 1);
135                        put_page(page);
136                }
137        }
138        return -ENOMEM;
139}
140
141static void mlx4_en_free_frag(struct mlx4_en_priv *priv,
142                              struct mlx4_en_rx_alloc *frags,
143                              int i)
144{
145        const struct mlx4_en_frag_info *frag_info = &priv->frag_info[i];
146        u32 next_frag_end = frags[i].page_offset + 2 * frag_info->frag_stride;
147
148
149        if (next_frag_end > frags[i].page_size)
150                dma_unmap_page(priv->ddev, frags[i].dma, frags[i].page_size,
151                               frag_info->dma_dir);
152
153        if (frags[i].page)
154                put_page(frags[i].page);
155}
156
157static int mlx4_en_init_allocator(struct mlx4_en_priv *priv,
158                                  struct mlx4_en_rx_ring *ring)
159{
160        int i;
161        struct mlx4_en_rx_alloc *page_alloc;
162
163        for (i = 0; i < priv->num_frags; i++) {
164                const struct mlx4_en_frag_info *frag_info = &priv->frag_info[i];
165
166                if (mlx4_alloc_pages(priv, &ring->page_alloc[i],
167                                     frag_info, GFP_KERNEL | __GFP_COLD))
168                        goto out;
169
170                en_dbg(DRV, priv, "  frag %d allocator: - size:%d frags:%d\n",
171                       i, ring->page_alloc[i].page_size,
172                       page_ref_count(ring->page_alloc[i].page));
173        }
174        return 0;
175
176out:
177        while (i--) {
178                struct page *page;
179
180                page_alloc = &ring->page_alloc[i];
181                dma_unmap_page(priv->ddev, page_alloc->dma,
182                               page_alloc->page_size,
183                               priv->frag_info[i].dma_dir);
184                page = page_alloc->page;
185                /* Revert changes done by mlx4_alloc_pages */
186                page_ref_sub(page, page_alloc->page_size /
187                                   priv->frag_info[i].frag_stride - 1);
188                put_page(page);
189                page_alloc->page = NULL;
190        }
191        return -ENOMEM;
192}
193
194static void mlx4_en_destroy_allocator(struct mlx4_en_priv *priv,
195                                      struct mlx4_en_rx_ring *ring)
196{
197        struct mlx4_en_rx_alloc *page_alloc;
198        int i;
199
200        for (i = 0; i < priv->num_frags; i++) {
201                const struct mlx4_en_frag_info *frag_info = &priv->frag_info[i];
202
203                page_alloc = &ring->page_alloc[i];
204                en_dbg(DRV, priv, "Freeing allocator:%d count:%d\n",
205                       i, page_count(page_alloc->page));
206
207                dma_unmap_page(priv->ddev, page_alloc->dma,
208                                page_alloc->page_size, frag_info->dma_dir);
209                while (page_alloc->page_offset + frag_info->frag_stride <
210                       page_alloc->page_size) {
211                        put_page(page_alloc->page);
212                        page_alloc->page_offset += frag_info->frag_stride;
213                }
214                page_alloc->page = NULL;
215        }
216}
217
218static void mlx4_en_init_rx_desc(struct mlx4_en_priv *priv,
219                                 struct mlx4_en_rx_ring *ring, int index)
220{
221        struct mlx4_en_rx_desc *rx_desc = ring->buf + ring->stride * index;
222        int possible_frags;
223        int i;
224
225        /* Set size and memtype fields */
226        for (i = 0; i < priv->num_frags; i++) {
227                rx_desc->data[i].byte_count =
228                        cpu_to_be32(priv->frag_info[i].frag_size);
229                rx_desc->data[i].lkey = cpu_to_be32(priv->mdev->mr.key);
230        }
231
232        /* If the number of used fragments does not fill up the ring stride,
233         * remaining (unused) fragments must be padded with null address/size
234         * and a special memory key */
235        possible_frags = (ring->stride - sizeof(struct mlx4_en_rx_desc)) / DS_SIZE;
236        for (i = priv->num_frags; i < possible_frags; i++) {
237                rx_desc->data[i].byte_count = 0;
238                rx_desc->data[i].lkey = cpu_to_be32(MLX4_EN_MEMTYPE_PAD);
239                rx_desc->data[i].addr = 0;
240        }
241}
242
243static int mlx4_en_prepare_rx_desc(struct mlx4_en_priv *priv,
244                                   struct mlx4_en_rx_ring *ring, int index,
245                                   gfp_t gfp)
246{
247        struct mlx4_en_rx_desc *rx_desc = ring->buf + (index * ring->stride);
248        struct mlx4_en_rx_alloc *frags = ring->rx_info +
249                                        (index << priv->log_rx_info);
250
251        if (ring->page_cache.index > 0) {
252                frags[0] = ring->page_cache.buf[--ring->page_cache.index];
253                rx_desc->data[0].addr = cpu_to_be64(frags[0].dma);
254                return 0;
255        }
256
257        return mlx4_en_alloc_frags(priv, rx_desc, frags, ring->page_alloc, gfp);
258}
259
260static inline bool mlx4_en_is_ring_empty(struct mlx4_en_rx_ring *ring)
261{
262        return ring->prod == ring->cons;
263}
264
265static inline void mlx4_en_update_rx_prod_db(struct mlx4_en_rx_ring *ring)
266{
267        *ring->wqres.db.db = cpu_to_be32(ring->prod & 0xffff);
268}
269
270static void mlx4_en_free_rx_desc(struct mlx4_en_priv *priv,
271                                 struct mlx4_en_rx_ring *ring,
272                                 int index)
273{
274        struct mlx4_en_rx_alloc *frags;
275        int nr;
276
277        frags = ring->rx_info + (index << priv->log_rx_info);
278        for (nr = 0; nr < priv->num_frags; nr++) {
279                en_dbg(DRV, priv, "Freeing fragment:%d\n", nr);
280                mlx4_en_free_frag(priv, frags, nr);
281        }
282}
283
284static int mlx4_en_fill_rx_buffers(struct mlx4_en_priv *priv)
285{
286        struct mlx4_en_rx_ring *ring;
287        int ring_ind;
288        int buf_ind;
289        int new_size;
290
291        for (buf_ind = 0; buf_ind < priv->prof->rx_ring_size; buf_ind++) {
292                for (ring_ind = 0; ring_ind < priv->rx_ring_num; ring_ind++) {
293                        ring = priv->rx_ring[ring_ind];
294
295                        if (mlx4_en_prepare_rx_desc(priv, ring,
296                                                    ring->actual_size,
297                                                    GFP_KERNEL | __GFP_COLD)) {
298                                if (ring->actual_size < MLX4_EN_MIN_RX_SIZE) {
299                                        en_err(priv, "Failed to allocate enough rx buffers\n");
300                                        return -ENOMEM;
301                                } else {
302                                        new_size = rounddown_pow_of_two(ring->actual_size);
303                                        en_warn(priv, "Only %d buffers allocated reducing ring size to %d\n",
304                                                ring->actual_size, new_size);
305                                        goto reduce_rings;
306                                }
307                        }
308                        ring->actual_size++;
309                        ring->prod++;
310                }
311        }
312        return 0;
313
314reduce_rings:
315        for (ring_ind = 0; ring_ind < priv->rx_ring_num; ring_ind++) {
316                ring = priv->rx_ring[ring_ind];
317                while (ring->actual_size > new_size) {
318                        ring->actual_size--;
319                        ring->prod--;
320                        mlx4_en_free_rx_desc(priv, ring, ring->actual_size);
321                }
322        }
323
324        return 0;
325}
326
327static void mlx4_en_free_rx_buf(struct mlx4_en_priv *priv,
328                                struct mlx4_en_rx_ring *ring)
329{
330        int index;
331
332        en_dbg(DRV, priv, "Freeing Rx buf - cons:%d prod:%d\n",
333               ring->cons, ring->prod);
334
335        /* Unmap and free Rx buffers */
336        while (!mlx4_en_is_ring_empty(ring)) {
337                index = ring->cons & ring->size_mask;
338                en_dbg(DRV, priv, "Processing descriptor:%d\n", index);
339                mlx4_en_free_rx_desc(priv, ring, index);
340                ++ring->cons;
341        }
342}
343
344void mlx4_en_set_num_rx_rings(struct mlx4_en_dev *mdev)
345{
346        int i;
347        int num_of_eqs;
348        int num_rx_rings;
349        struct mlx4_dev *dev = mdev->dev;
350
351        mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH) {
352                num_of_eqs = max_t(int, MIN_RX_RINGS,
353                                   min_t(int,
354                                         mlx4_get_eqs_per_port(mdev->dev, i),
355                                         DEF_RX_RINGS));
356
357                num_rx_rings = mlx4_low_memory_profile() ? MIN_RX_RINGS :
358                        min_t(int, num_of_eqs,
359                              netif_get_num_default_rss_queues());
360                mdev->profile.prof[i].rx_ring_num =
361                        rounddown_pow_of_two(num_rx_rings);
362        }
363}
364
365int mlx4_en_create_rx_ring(struct mlx4_en_priv *priv,
366                           struct mlx4_en_rx_ring **pring,
367                           u32 size, u16 stride, int node)
368{
369        struct mlx4_en_dev *mdev = priv->mdev;
370        struct mlx4_en_rx_ring *ring;
371        int err = -ENOMEM;
372        int tmp;
373
374        ring = kzalloc_node(sizeof(*ring), GFP_KERNEL, node);
375        if (!ring) {
376                ring = kzalloc(sizeof(*ring), GFP_KERNEL);
377                if (!ring) {
378                        en_err(priv, "Failed to allocate RX ring structure\n");
379                        return -ENOMEM;
380                }
381        }
382
383        ring->prod = 0;
384        ring->cons = 0;
385        ring->size = size;
386        ring->size_mask = size - 1;
387        ring->stride = stride;
388        ring->log_stride = ffs(ring->stride) - 1;
389        ring->buf_size = ring->size * ring->stride + TXBB_SIZE;
390
391        tmp = size * roundup_pow_of_two(MLX4_EN_MAX_RX_FRAGS *
392                                        sizeof(struct mlx4_en_rx_alloc));
393        ring->rx_info = vmalloc_node(tmp, node);
394        if (!ring->rx_info) {
395                ring->rx_info = vmalloc(tmp);
396                if (!ring->rx_info) {
397                        err = -ENOMEM;
398                        goto err_ring;
399                }
400        }
401
402        en_dbg(DRV, priv, "Allocated rx_info ring at addr:%p size:%d\n",
403                 ring->rx_info, tmp);
404
405        /* Allocate HW buffers on provided NUMA node */
406        set_dev_node(&mdev->dev->persist->pdev->dev, node);
407        err = mlx4_alloc_hwq_res(mdev->dev, &ring->wqres, ring->buf_size);
408        set_dev_node(&mdev->dev->persist->pdev->dev, mdev->dev->numa_node);
409        if (err)
410                goto err_info;
411
412        ring->buf = ring->wqres.buf.direct.buf;
413
414        ring->hwtstamp_rx_filter = priv->hwtstamp_config.rx_filter;
415
416        *pring = ring;
417        return 0;
418
419err_info:
420        vfree(ring->rx_info);
421        ring->rx_info = NULL;
422err_ring:
423        kfree(ring);
424        *pring = NULL;
425
426        return err;
427}
428
429int mlx4_en_activate_rx_rings(struct mlx4_en_priv *priv)
430{
431        struct mlx4_en_rx_ring *ring;
432        int i;
433        int ring_ind;
434        int err;
435        int stride = roundup_pow_of_two(sizeof(struct mlx4_en_rx_desc) +
436                                        DS_SIZE * priv->num_frags);
437
438        for (ring_ind = 0; ring_ind < priv->rx_ring_num; ring_ind++) {
439                ring = priv->rx_ring[ring_ind];
440
441                ring->prod = 0;
442                ring->cons = 0;
443                ring->actual_size = 0;
444                ring->cqn = priv->rx_cq[ring_ind]->mcq.cqn;
445
446                ring->stride = stride;
447                if (ring->stride <= TXBB_SIZE) {
448                        /* Stamp first unused send wqe */
449                        __be32 *ptr = (__be32 *)ring->buf;
450                        __be32 stamp = cpu_to_be32(1 << STAMP_SHIFT);
451                        *ptr = stamp;
452                        /* Move pointer to start of rx section */
453                        ring->buf += TXBB_SIZE;
454                }
455
456                ring->log_stride = ffs(ring->stride) - 1;
457                ring->buf_size = ring->size * ring->stride;
458
459                memset(ring->buf, 0, ring->buf_size);
460                mlx4_en_update_rx_prod_db(ring);
461
462                /* Initialize all descriptors */
463                for (i = 0; i < ring->size; i++)
464                        mlx4_en_init_rx_desc(priv, ring, i);
465
466                /* Initialize page allocators */
467                err = mlx4_en_init_allocator(priv, ring);
468                if (err) {
469                        en_err(priv, "Failed initializing ring allocator\n");
470                        if (ring->stride <= TXBB_SIZE)
471                                ring->buf -= TXBB_SIZE;
472                        ring_ind--;
473                        goto err_allocator;
474                }
475        }
476        err = mlx4_en_fill_rx_buffers(priv);
477        if (err)
478                goto err_buffers;
479
480        for (ring_ind = 0; ring_ind < priv->rx_ring_num; ring_ind++) {
481                ring = priv->rx_ring[ring_ind];
482
483                ring->size_mask = ring->actual_size - 1;
484                mlx4_en_update_rx_prod_db(ring);
485        }
486
487        return 0;
488
489err_buffers:
490        for (ring_ind = 0; ring_ind < priv->rx_ring_num; ring_ind++)
491                mlx4_en_free_rx_buf(priv, priv->rx_ring[ring_ind]);
492
493        ring_ind = priv->rx_ring_num - 1;
494err_allocator:
495        while (ring_ind >= 0) {
496                if (priv->rx_ring[ring_ind]->stride <= TXBB_SIZE)
497                        priv->rx_ring[ring_ind]->buf -= TXBB_SIZE;
498                mlx4_en_destroy_allocator(priv, priv->rx_ring[ring_ind]);
499                ring_ind--;
500        }
501        return err;
502}
503
504/* We recover from out of memory by scheduling our napi poll
505 * function (mlx4_en_process_cq), which tries to allocate
506 * all missing RX buffers (call to mlx4_en_refill_rx_buffers).
507 */
508void mlx4_en_recover_from_oom(struct mlx4_en_priv *priv)
509{
510        int ring;
511
512        if (!priv->port_up)
513                return;
514
515        for (ring = 0; ring < priv->rx_ring_num; ring++) {
516                if (mlx4_en_is_ring_empty(priv->rx_ring[ring])) {
517                        local_bh_disable();
518                        napi_reschedule(&priv->rx_cq[ring]->napi);
519                        local_bh_enable();
520                }
521        }
522}
523
524/* When the rx ring is running in page-per-packet mode, a released frame can go
525 * directly into a small cache, to avoid unmapping or touching the page
526 * allocator. In bpf prog performance scenarios, buffers are either forwarded
527 * or dropped, never converted to skbs, so every page can come directly from
528 * this cache when it is sized to be a multiple of the napi budget.
529 */
530bool mlx4_en_rx_recycle(struct mlx4_en_rx_ring *ring,
531                        struct mlx4_en_rx_alloc *frame)
532{
533        struct mlx4_en_page_cache *cache = &ring->page_cache;
534
535        if (cache->index >= MLX4_EN_CACHE_SIZE)
536                return false;
537
538        cache->buf[cache->index++] = *frame;
539        return true;
540}
541
542void mlx4_en_destroy_rx_ring(struct mlx4_en_priv *priv,
543                             struct mlx4_en_rx_ring **pring,
544                             u32 size, u16 stride)
545{
546        struct mlx4_en_dev *mdev = priv->mdev;
547        struct mlx4_en_rx_ring *ring = *pring;
548        struct bpf_prog *old_prog;
549
550        old_prog = rcu_dereference_protected(
551                                        ring->xdp_prog,
552                                        lockdep_is_held(&mdev->state_lock));
553        if (old_prog)
554                bpf_prog_put(old_prog);
555        mlx4_free_hwq_res(mdev->dev, &ring->wqres, size * stride + TXBB_SIZE);
556        vfree(ring->rx_info);
557        ring->rx_info = NULL;
558        kfree(ring);
559        *pring = NULL;
560}
561
562void mlx4_en_deactivate_rx_ring(struct mlx4_en_priv *priv,
563                                struct mlx4_en_rx_ring *ring)
564{
565        int i;
566
567        for (i = 0; i < ring->page_cache.index; i++) {
568                struct mlx4_en_rx_alloc *frame = &ring->page_cache.buf[i];
569
570                dma_unmap_page(priv->ddev, frame->dma, frame->page_size,
571                               priv->frag_info[0].dma_dir);
572                put_page(frame->page);
573        }
574        ring->page_cache.index = 0;
575        mlx4_en_free_rx_buf(priv, ring);
576        if (ring->stride <= TXBB_SIZE)
577                ring->buf -= TXBB_SIZE;
578        mlx4_en_destroy_allocator(priv, ring);
579}
580
581
582static int mlx4_en_complete_rx_desc(struct mlx4_en_priv *priv,
583                                    struct mlx4_en_rx_desc *rx_desc,
584                                    struct mlx4_en_rx_alloc *frags,
585                                    struct sk_buff *skb,
586                                    int length)
587{
588        struct skb_frag_struct *skb_frags_rx = skb_shinfo(skb)->frags;
589        struct mlx4_en_frag_info *frag_info;
590        int nr;
591        dma_addr_t dma;
592
593        /* Collect used fragments while replacing them in the HW descriptors */
594        for (nr = 0; nr < priv->num_frags; nr++) {
595                frag_info = &priv->frag_info[nr];
596                if (length <= frag_info->frag_prefix_size)
597                        break;
598                if (unlikely(!frags[nr].page))
599                        goto fail;
600
601                dma = be64_to_cpu(rx_desc->data[nr].addr);
602                dma_sync_single_for_cpu(priv->ddev, dma, frag_info->frag_size,
603                                        DMA_FROM_DEVICE);
604
605                /* Save page reference in skb */
606                __skb_frag_set_page(&skb_frags_rx[nr], frags[nr].page);
607                skb_frag_size_set(&skb_frags_rx[nr], frag_info->frag_size);
608                skb_frags_rx[nr].page_offset = frags[nr].page_offset;
609                skb->truesize += frag_info->frag_stride;
610                frags[nr].page = NULL;
611        }
612        /* Adjust size of last fragment to match actual length */
613        if (nr > 0)
614                skb_frag_size_set(&skb_frags_rx[nr - 1],
615                        length - priv->frag_info[nr - 1].frag_prefix_size);
616        return nr;
617
618fail:
619        while (nr > 0) {
620                nr--;
621                __skb_frag_unref(&skb_frags_rx[nr]);
622        }
623        return 0;
624}
625
626
627static struct sk_buff *mlx4_en_rx_skb(struct mlx4_en_priv *priv,
628                                      struct mlx4_en_rx_desc *rx_desc,
629                                      struct mlx4_en_rx_alloc *frags,
630                                      unsigned int length)
631{
632        struct sk_buff *skb;
633        void *va;
634        int used_frags;
635        dma_addr_t dma;
636
637        skb = netdev_alloc_skb(priv->dev, SMALL_PACKET_SIZE + NET_IP_ALIGN);
638        if (unlikely(!skb)) {
639                en_dbg(RX_ERR, priv, "Failed allocating skb\n");
640                return NULL;
641        }
642        skb_reserve(skb, NET_IP_ALIGN);
643        skb->len = length;
644
645        /* Get pointer to first fragment so we could copy the headers into the
646         * (linear part of the) skb */
647        va = page_address(frags[0].page) + frags[0].page_offset;
648
649        if (length <= SMALL_PACKET_SIZE) {
650                /* We are copying all relevant data to the skb - temporarily
651                 * sync buffers for the copy */
652                dma = be64_to_cpu(rx_desc->data[0].addr);
653                dma_sync_single_for_cpu(priv->ddev, dma, length,
654                                        DMA_FROM_DEVICE);
655                skb_copy_to_linear_data(skb, va, length);
656                skb->tail += length;
657        } else {
658                unsigned int pull_len;
659
660                /* Move relevant fragments to skb */
661                used_frags = mlx4_en_complete_rx_desc(priv, rx_desc, frags,
662                                                        skb, length);
663                if (unlikely(!used_frags)) {
664                        kfree_skb(skb);
665                        return NULL;
666                }
667                skb_shinfo(skb)->nr_frags = used_frags;
668
669                pull_len = eth_get_headlen(va, SMALL_PACKET_SIZE);
670                /* Copy headers into the skb linear buffer */
671                memcpy(skb->data, va, pull_len);
672                skb->tail += pull_len;
673
674                /* Skip headers in first fragment */
675                skb_shinfo(skb)->frags[0].page_offset += pull_len;
676
677                /* Adjust size of first fragment */
678                skb_frag_size_sub(&skb_shinfo(skb)->frags[0], pull_len);
679                skb->data_len = length - pull_len;
680        }
681        return skb;
682}
683
684static void validate_loopback(struct mlx4_en_priv *priv, struct sk_buff *skb)
685{
686        int i;
687        int offset = ETH_HLEN;
688
689        for (i = 0; i < MLX4_LOOPBACK_TEST_PAYLOAD; i++, offset++) {
690                if (*(skb->data + offset) != (unsigned char) (i & 0xff))
691                        goto out_loopback;
692        }
693        /* Loopback found */
694        priv->loopback_ok = 1;
695
696out_loopback:
697        dev_kfree_skb_any(skb);
698}
699
700static void mlx4_en_refill_rx_buffers(struct mlx4_en_priv *priv,
701                                     struct mlx4_en_rx_ring *ring)
702{
703        int index = ring->prod & ring->size_mask;
704
705        while ((u32) (ring->prod - ring->cons) < ring->actual_size) {
706                if (mlx4_en_prepare_rx_desc(priv, ring, index,
707                                            GFP_ATOMIC | __GFP_COLD))
708                        break;
709                ring->prod++;
710                index = ring->prod & ring->size_mask;
711        }
712}
713
714/* When hardware doesn't strip the vlan, we need to calculate the checksum
715 * over it and add it to the hardware's checksum calculation
716 */
717static inline __wsum get_fixed_vlan_csum(__wsum hw_checksum,
718                                         struct vlan_hdr *vlanh)
719{
720        return csum_add(hw_checksum, *(__wsum *)vlanh);
721}
722
723/* Although the stack expects checksum which doesn't include the pseudo
724 * header, the HW adds it. To address that, we are subtracting the pseudo
725 * header checksum from the checksum value provided by the HW.
726 */
727static void get_fixed_ipv4_csum(__wsum hw_checksum, struct sk_buff *skb,
728                                struct iphdr *iph)
729{
730        __u16 length_for_csum = 0;
731        __wsum csum_pseudo_header = 0;
732
733        length_for_csum = (be16_to_cpu(iph->tot_len) - (iph->ihl << 2));
734        csum_pseudo_header = csum_tcpudp_nofold(iph->saddr, iph->daddr,
735                                                length_for_csum, iph->protocol, 0);
736        skb->csum = csum_sub(hw_checksum, csum_pseudo_header);
737}
738
739#if IS_ENABLED(CONFIG_IPV6)
740/* In IPv6 packets, besides subtracting the pseudo header checksum,
741 * we also compute/add the IP header checksum which
742 * is not added by the HW.
743 */
744static int get_fixed_ipv6_csum(__wsum hw_checksum, struct sk_buff *skb,
745                               struct ipv6hdr *ipv6h)
746{
747        __wsum csum_pseudo_hdr = 0;
748
749        if (unlikely(ipv6h->nexthdr == IPPROTO_FRAGMENT ||
750                     ipv6h->nexthdr == IPPROTO_HOPOPTS))
751                return -1;
752        hw_checksum = csum_add(hw_checksum, (__force __wsum)htons(ipv6h->nexthdr));
753
754        csum_pseudo_hdr = csum_partial(&ipv6h->saddr,
755                                       sizeof(ipv6h->saddr) + sizeof(ipv6h->daddr), 0);
756        csum_pseudo_hdr = csum_add(csum_pseudo_hdr, (__force __wsum)ipv6h->payload_len);
757        csum_pseudo_hdr = csum_add(csum_pseudo_hdr, (__force __wsum)ntohs(ipv6h->nexthdr));
758
759        skb->csum = csum_sub(hw_checksum, csum_pseudo_hdr);
760        skb->csum = csum_add(skb->csum, csum_partial(ipv6h, sizeof(struct ipv6hdr), 0));
761        return 0;
762}
763#endif
764static int check_csum(struct mlx4_cqe *cqe, struct sk_buff *skb, void *va,
765                      netdev_features_t dev_features)
766{
767        __wsum hw_checksum = 0;
768
769        void *hdr = (u8 *)va + sizeof(struct ethhdr);
770
771        hw_checksum = csum_unfold((__force __sum16)cqe->checksum);
772
773        if (cqe->vlan_my_qpn & cpu_to_be32(MLX4_CQE_CVLAN_PRESENT_MASK) &&
774            !(dev_features & NETIF_F_HW_VLAN_CTAG_RX)) {
775                hw_checksum = get_fixed_vlan_csum(hw_checksum, hdr);
776                hdr += sizeof(struct vlan_hdr);
777        }
778
779        if (cqe->status & cpu_to_be16(MLX4_CQE_STATUS_IPV4))
780                get_fixed_ipv4_csum(hw_checksum, skb, hdr);
781#if IS_ENABLED(CONFIG_IPV6)
782        else if (cqe->status & cpu_to_be16(MLX4_CQE_STATUS_IPV6))
783                if (unlikely(get_fixed_ipv6_csum(hw_checksum, skb, hdr)))
784                        return -1;
785#endif
786        return 0;
787}
788
789int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int budget)
790{
791        struct mlx4_en_priv *priv = netdev_priv(dev);
792        struct mlx4_en_dev *mdev = priv->mdev;
793        struct mlx4_cqe *cqe;
794        struct mlx4_en_rx_ring *ring = priv->rx_ring[cq->ring];
795        struct mlx4_en_rx_alloc *frags;
796        struct mlx4_en_rx_desc *rx_desc;
797        struct bpf_prog *xdp_prog;
798        int doorbell_pending;
799        struct sk_buff *skb;
800        int tx_index;
801        int index;
802        int nr;
803        unsigned int length;
804        int polled = 0;
805        int ip_summed;
806        int factor = priv->cqe_factor;
807        u64 timestamp;
808        bool l2_tunnel;
809
810        if (unlikely(!priv->port_up))
811                return 0;
812
813        if (unlikely(budget <= 0))
814                return polled;
815
816        /* Protect accesses to: ring->xdp_prog, priv->mac_hash list */
817        rcu_read_lock();
818        xdp_prog = rcu_dereference(ring->xdp_prog);
819        doorbell_pending = 0;
820        tx_index = (priv->tx_ring_num - priv->xdp_ring_num) + cq->ring;
821
822        /* We assume a 1:1 mapping between CQEs and Rx descriptors, so Rx
823         * descriptor offset can be deduced from the CQE index instead of
824         * reading 'cqe->index' */
825        index = cq->mcq.cons_index & ring->size_mask;
826        cqe = mlx4_en_get_cqe(cq->buf, index, priv->cqe_size) + factor;
827
828        /* Process all completed CQEs */
829        while (XNOR(cqe->owner_sr_opcode & MLX4_CQE_OWNER_MASK,
830                    cq->mcq.cons_index & cq->size)) {
831
832                frags = ring->rx_info + (index << priv->log_rx_info);
833                rx_desc = ring->buf + (index << ring->log_stride);
834
835                /*
836                 * make sure we read the CQE after we read the ownership bit
837                 */
838                dma_rmb();
839
840                /* Drop packet on bad receive or bad checksum */
841                if (unlikely((cqe->owner_sr_opcode & MLX4_CQE_OPCODE_MASK) ==
842                                                MLX4_CQE_OPCODE_ERROR)) {
843                        en_err(priv, "CQE completed in error - vendor syndrom:%d syndrom:%d\n",
844                               ((struct mlx4_err_cqe *)cqe)->vendor_err_syndrome,
845                               ((struct mlx4_err_cqe *)cqe)->syndrome);
846                        goto next;
847                }
848                if (unlikely(cqe->badfcs_enc & MLX4_CQE_BAD_FCS)) {
849                        en_dbg(RX_ERR, priv, "Accepted frame with bad FCS\n");
850                        goto next;
851                }
852
853                /* Check if we need to drop the packet if SRIOV is not enabled
854                 * and not performing the selftest or flb disabled
855                 */
856                if (priv->flags & MLX4_EN_FLAG_RX_FILTER_NEEDED) {
857                        struct ethhdr *ethh;
858                        dma_addr_t dma;
859                        /* Get pointer to first fragment since we haven't
860                         * skb yet and cast it to ethhdr struct
861                         */
862                        dma = be64_to_cpu(rx_desc->data[0].addr);
863                        dma_sync_single_for_cpu(priv->ddev, dma, sizeof(*ethh),
864                                                DMA_FROM_DEVICE);
865                        ethh = (struct ethhdr *)(page_address(frags[0].page) +
866                                                 frags[0].page_offset);
867
868                        if (is_multicast_ether_addr(ethh->h_dest)) {
869                                struct mlx4_mac_entry *entry;
870                                struct hlist_head *bucket;
871                                unsigned int mac_hash;
872
873                                /* Drop the packet, since HW loopback-ed it */
874                                mac_hash = ethh->h_source[MLX4_EN_MAC_HASH_IDX];
875                                bucket = &priv->mac_hash[mac_hash];
876                                hlist_for_each_entry_rcu(entry, bucket, hlist) {
877                                        if (ether_addr_equal_64bits(entry->mac,
878                                                                    ethh->h_source))
879                                                goto next;
880                                }
881                        }
882                }
883
884                /*
885                 * Packet is OK - process it.
886                 */
887                length = be32_to_cpu(cqe->byte_cnt);
888                length -= ring->fcs_del;
889                ring->bytes += length;
890                ring->packets++;
891                l2_tunnel = (dev->hw_enc_features & NETIF_F_RXCSUM) &&
892                        (cqe->vlan_my_qpn & cpu_to_be32(MLX4_CQE_L2_TUNNEL));
893
894                /* A bpf program gets first chance to drop the packet. It may
895                 * read bytes but not past the end of the frag.
896                 */
897                if (xdp_prog) {
898                        struct xdp_buff xdp;
899                        dma_addr_t dma;
900                        u32 act;
901
902                        dma = be64_to_cpu(rx_desc->data[0].addr);
903                        dma_sync_single_for_cpu(priv->ddev, dma,
904                                                priv->frag_info[0].frag_size,
905                                                DMA_FROM_DEVICE);
906
907                        xdp.data = page_address(frags[0].page) +
908                                                        frags[0].page_offset;
909                        xdp.data_end = xdp.data + length;
910
911                        act = bpf_prog_run_xdp(xdp_prog, &xdp);
912                        switch (act) {
913                        case XDP_PASS:
914                                break;
915                        case XDP_TX:
916                                if (likely(!mlx4_en_xmit_frame(frags, dev,
917                                                        length, tx_index,
918                                                        &doorbell_pending)))
919                                        goto consumed;
920                                goto xdp_drop; /* Drop on xmit failure */
921                        default:
922                                bpf_warn_invalid_xdp_action(act);
923                        case XDP_ABORTED:
924                        case XDP_DROP:
925xdp_drop:
926                                if (likely(mlx4_en_rx_recycle(ring, frags)))
927                                        goto consumed;
928                                goto next;
929                        }
930                }
931
932                if (likely(dev->features & NETIF_F_RXCSUM)) {
933                        if (cqe->status & cpu_to_be16(MLX4_CQE_STATUS_TCP |
934                                                      MLX4_CQE_STATUS_UDP)) {
935                                if ((cqe->status & cpu_to_be16(MLX4_CQE_STATUS_IPOK)) &&
936                                    cqe->checksum == cpu_to_be16(0xffff)) {
937                                        ip_summed = CHECKSUM_UNNECESSARY;
938                                        ring->csum_ok++;
939                                } else {
940                                        ip_summed = CHECKSUM_NONE;
941                                        ring->csum_none++;
942                                }
943                        } else {
944                                if (priv->flags & MLX4_EN_FLAG_RX_CSUM_NON_TCP_UDP &&
945                                    (cqe->status & cpu_to_be16(MLX4_CQE_STATUS_IPV4 |
946                                                               MLX4_CQE_STATUS_IPV6))) {
947                                        ip_summed = CHECKSUM_COMPLETE;
948                                        ring->csum_complete++;
949                                } else {
950                                        ip_summed = CHECKSUM_NONE;
951                                        ring->csum_none++;
952                                }
953                        }
954                } else {
955                        ip_summed = CHECKSUM_NONE;
956                        ring->csum_none++;
957                }
958
959                /* This packet is eligible for GRO if it is:
960                 * - DIX Ethernet (type interpretation)
961                 * - TCP/IP (v4)
962                 * - without IP options
963                 * - not an IP fragment
964                 */
965                if (dev->features & NETIF_F_GRO) {
966                        struct sk_buff *gro_skb = napi_get_frags(&cq->napi);
967                        if (!gro_skb)
968                                goto next;
969
970                        nr = mlx4_en_complete_rx_desc(priv,
971                                rx_desc, frags, gro_skb,
972                                length);
973                        if (!nr)
974                                goto next;
975
976                        if (ip_summed == CHECKSUM_COMPLETE) {
977                                void *va = skb_frag_address(skb_shinfo(gro_skb)->frags);
978                                if (check_csum(cqe, gro_skb, va,
979                                               dev->features)) {
980                                        ip_summed = CHECKSUM_NONE;
981                                        ring->csum_none++;
982                                        ring->csum_complete--;
983                                }
984                        }
985
986                        skb_shinfo(gro_skb)->nr_frags = nr;
987                        gro_skb->len = length;
988                        gro_skb->data_len = length;
989                        gro_skb->ip_summed = ip_summed;
990
991                        if (l2_tunnel && ip_summed == CHECKSUM_UNNECESSARY)
992                                gro_skb->csum_level = 1;
993
994                        if ((cqe->vlan_my_qpn &
995                            cpu_to_be32(MLX4_CQE_CVLAN_PRESENT_MASK)) &&
996                            (dev->features & NETIF_F_HW_VLAN_CTAG_RX)) {
997                                u16 vid = be16_to_cpu(cqe->sl_vid);
998
999                                __vlan_hwaccel_put_tag(gro_skb, htons(ETH_P_8021Q), vid);
1000                        } else if ((be32_to_cpu(cqe->vlan_my_qpn) &
1001                                  MLX4_CQE_SVLAN_PRESENT_MASK) &&
1002                                 (dev->features & NETIF_F_HW_VLAN_STAG_RX)) {
1003                                __vlan_hwaccel_put_tag(gro_skb,
1004                                                       htons(ETH_P_8021AD),
1005                                                       be16_to_cpu(cqe->sl_vid));
1006                        }
1007
1008                        if (dev->features & NETIF_F_RXHASH)
1009                                skb_set_hash(gro_skb,
1010                                             be32_to_cpu(cqe->immed_rss_invalid),
1011                                             (ip_summed == CHECKSUM_UNNECESSARY) ?
1012                                                PKT_HASH_TYPE_L4 :
1013                                                PKT_HASH_TYPE_L3);
1014
1015                        skb_record_rx_queue(gro_skb, cq->ring);
1016
1017                        if (ring->hwtstamp_rx_filter == HWTSTAMP_FILTER_ALL) {
1018                                timestamp = mlx4_en_get_cqe_ts(cqe);
1019                                mlx4_en_fill_hwtstamps(mdev,
1020                                                       skb_hwtstamps(gro_skb),
1021                                                       timestamp);
1022                        }
1023
1024                        napi_gro_frags(&cq->napi);
1025                        goto next;
1026                }
1027
1028                /* GRO not possible, complete processing here */
1029                skb = mlx4_en_rx_skb(priv, rx_desc, frags, length);
1030                if (unlikely(!skb)) {
1031                        ring->dropped++;
1032                        goto next;
1033                }
1034
1035                if (unlikely(priv->validate_loopback)) {
1036                        validate_loopback(priv, skb);
1037                        goto next;
1038                }
1039
1040                if (ip_summed == CHECKSUM_COMPLETE) {
1041                        if (check_csum(cqe, skb, skb->data, dev->features)) {
1042                                ip_summed = CHECKSUM_NONE;
1043                                ring->csum_complete--;
1044                                ring->csum_none++;
1045                        }
1046                }
1047
1048                skb->ip_summed = ip_summed;
1049                skb->protocol = eth_type_trans(skb, dev);
1050                skb_record_rx_queue(skb, cq->ring);
1051
1052                if (l2_tunnel && ip_summed == CHECKSUM_UNNECESSARY)
1053                        skb->csum_level = 1;
1054
1055                if (dev->features & NETIF_F_RXHASH)
1056                        skb_set_hash(skb,
1057                                     be32_to_cpu(cqe->immed_rss_invalid),
1058                                     (ip_summed == CHECKSUM_UNNECESSARY) ?
1059                                        PKT_HASH_TYPE_L4 :
1060                                        PKT_HASH_TYPE_L3);
1061
1062                if ((be32_to_cpu(cqe->vlan_my_qpn) &
1063                    MLX4_CQE_CVLAN_PRESENT_MASK) &&
1064                    (dev->features & NETIF_F_HW_VLAN_CTAG_RX))
1065                        __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), be16_to_cpu(cqe->sl_vid));
1066                else if ((be32_to_cpu(cqe->vlan_my_qpn) &
1067                          MLX4_CQE_SVLAN_PRESENT_MASK) &&
1068                         (dev->features & NETIF_F_HW_VLAN_STAG_RX))
1069                        __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021AD),
1070                                               be16_to_cpu(cqe->sl_vid));
1071
1072                if (ring->hwtstamp_rx_filter == HWTSTAMP_FILTER_ALL) {
1073                        timestamp = mlx4_en_get_cqe_ts(cqe);
1074                        mlx4_en_fill_hwtstamps(mdev, skb_hwtstamps(skb),
1075                                               timestamp);
1076                }
1077
1078                napi_gro_receive(&cq->napi, skb);
1079next:
1080                for (nr = 0; nr < priv->num_frags; nr++)
1081                        mlx4_en_free_frag(priv, frags, nr);
1082
1083consumed:
1084                ++cq->mcq.cons_index;
1085                index = (cq->mcq.cons_index) & ring->size_mask;
1086                cqe = mlx4_en_get_cqe(cq->buf, index, priv->cqe_size) + factor;
1087                if (++polled == budget)
1088                        goto out;
1089        }
1090
1091out:
1092        rcu_read_unlock();
1093        if (doorbell_pending)
1094                mlx4_en_xmit_doorbell(priv->tx_ring[tx_index]);
1095
1096        AVG_PERF_COUNTER(priv->pstats.rx_coal_avg, polled);
1097        mlx4_cq_set_ci(&cq->mcq);
1098        wmb(); /* ensure HW sees CQ consumer before we post new buffers */
1099        ring->cons = cq->mcq.cons_index;
1100        mlx4_en_refill_rx_buffers(priv, ring);
1101        mlx4_en_update_rx_prod_db(ring);
1102        return polled;
1103}
1104
1105
1106void mlx4_en_rx_irq(struct mlx4_cq *mcq)
1107{
1108        struct mlx4_en_cq *cq = container_of(mcq, struct mlx4_en_cq, mcq);
1109        struct mlx4_en_priv *priv = netdev_priv(cq->dev);
1110
1111        if (likely(priv->port_up))
1112                napi_schedule_irqoff(&cq->napi);
1113        else
1114                mlx4_en_arm_cq(priv, cq);
1115}
1116
1117/* Rx CQ polling - called by NAPI */
1118int mlx4_en_poll_rx_cq(struct napi_struct *napi, int budget)
1119{
1120        struct mlx4_en_cq *cq = container_of(napi, struct mlx4_en_cq, napi);
1121        struct net_device *dev = cq->dev;
1122        struct mlx4_en_priv *priv = netdev_priv(dev);
1123        int done;
1124
1125        done = mlx4_en_process_rx_cq(dev, cq, budget);
1126
1127        /* If we used up all the quota - we're probably not done yet... */
1128        if (done == budget) {
1129                const struct cpumask *aff;
1130                struct irq_data *idata;
1131                int cpu_curr;
1132
1133                INC_PERF_COUNTER(priv->pstats.napi_quota);
1134
1135                cpu_curr = smp_processor_id();
1136                idata = irq_desc_get_irq_data(cq->irq_desc);
1137                aff = irq_data_get_affinity_mask(idata);
1138
1139                if (likely(cpumask_test_cpu(cpu_curr, aff)))
1140                        return budget;
1141
1142                /* Current cpu is not according to smp_irq_affinity -
1143                 * probably affinity changed. need to stop this NAPI
1144                 * poll, and restart it on the right CPU
1145                 */
1146                done = 0;
1147        }
1148        /* Done for now */
1149        napi_complete_done(napi, done);
1150        mlx4_en_arm_cq(priv, cq);
1151        return done;
1152}
1153
1154static const int frag_sizes[] = {
1155        FRAG_SZ0,
1156        FRAG_SZ1,
1157        FRAG_SZ2,
1158        FRAG_SZ3
1159};
1160
1161void mlx4_en_calc_rx_buf(struct net_device *dev)
1162{
1163        enum dma_data_direction dma_dir = PCI_DMA_FROMDEVICE;
1164        struct mlx4_en_priv *priv = netdev_priv(dev);
1165        int eff_mtu = MLX4_EN_EFF_MTU(dev->mtu);
1166        int order = MLX4_EN_ALLOC_PREFER_ORDER;
1167        u32 align = SMP_CACHE_BYTES;
1168        int buf_size = 0;
1169        int i = 0;
1170
1171        /* bpf requires buffers to be set up as 1 packet per page.
1172         * This only works when num_frags == 1.
1173         */
1174        if (priv->xdp_ring_num) {
1175                dma_dir = PCI_DMA_BIDIRECTIONAL;
1176                /* This will gain efficient xdp frame recycling at the expense
1177                 * of more costly truesize accounting
1178                 */
1179                align = PAGE_SIZE;
1180                order = 0;
1181        }
1182
1183        while (buf_size < eff_mtu) {
1184                priv->frag_info[i].order = order;
1185                priv->frag_info[i].frag_size =
1186                        (eff_mtu > buf_size + frag_sizes[i]) ?
1187                                frag_sizes[i] : eff_mtu - buf_size;
1188                priv->frag_info[i].frag_prefix_size = buf_size;
1189                priv->frag_info[i].frag_stride =
1190                                ALIGN(priv->frag_info[i].frag_size, align);
1191                priv->frag_info[i].dma_dir = dma_dir;
1192                buf_size += priv->frag_info[i].frag_size;
1193                i++;
1194        }
1195
1196        priv->num_frags = i;
1197        priv->rx_skb_size = eff_mtu;
1198        priv->log_rx_info = ROUNDUP_LOG2(i * sizeof(struct mlx4_en_rx_alloc));
1199
1200        en_dbg(DRV, priv, "Rx buffer scatter-list (effective-mtu:%d num_frags:%d):\n",
1201               eff_mtu, priv->num_frags);
1202        for (i = 0; i < priv->num_frags; i++) {
1203                en_err(priv,
1204                       "  frag:%d - size:%d prefix:%d stride:%d\n",
1205                       i,
1206                       priv->frag_info[i].frag_size,
1207                       priv->frag_info[i].frag_prefix_size,
1208                       priv->frag_info[i].frag_stride);
1209        }
1210}
1211
1212/* RSS related functions */
1213
1214static int mlx4_en_config_rss_qp(struct mlx4_en_priv *priv, int qpn,
1215                                 struct mlx4_en_rx_ring *ring,
1216                                 enum mlx4_qp_state *state,
1217                                 struct mlx4_qp *qp)
1218{
1219        struct mlx4_en_dev *mdev = priv->mdev;
1220        struct mlx4_qp_context *context;
1221        int err = 0;
1222
1223        context = kmalloc(sizeof(*context), GFP_KERNEL);
1224        if (!context)
1225                return -ENOMEM;
1226
1227        err = mlx4_qp_alloc(mdev->dev, qpn, qp, GFP_KERNEL);
1228        if (err) {
1229                en_err(priv, "Failed to allocate qp #%x\n", qpn);
1230                goto out;
1231        }
1232        qp->event = mlx4_en_sqp_event;
1233
1234        memset(context, 0, sizeof *context);
1235        mlx4_en_fill_qp_context(priv, ring->actual_size, ring->stride, 0, 0,
1236                                qpn, ring->cqn, -1, context);
1237        context->db_rec_addr = cpu_to_be64(ring->wqres.db.dma);
1238
1239        /* Cancel FCS removal if FW allows */
1240        if (mdev->dev->caps.flags & MLX4_DEV_CAP_FLAG_FCS_KEEP) {
1241                context->param3 |= cpu_to_be32(1 << 29);
1242                if (priv->dev->features & NETIF_F_RXFCS)
1243                        ring->fcs_del = 0;
1244                else
1245                        ring->fcs_del = ETH_FCS_LEN;
1246        } else
1247                ring->fcs_del = 0;
1248
1249        err = mlx4_qp_to_ready(mdev->dev, &ring->wqres.mtt, context, qp, state);
1250        if (err) {
1251                mlx4_qp_remove(mdev->dev, qp);
1252                mlx4_qp_free(mdev->dev, qp);
1253        }
1254        mlx4_en_update_rx_prod_db(ring);
1255out:
1256        kfree(context);
1257        return err;
1258}
1259
1260int mlx4_en_create_drop_qp(struct mlx4_en_priv *priv)
1261{
1262        int err;
1263        u32 qpn;
1264
1265        err = mlx4_qp_reserve_range(priv->mdev->dev, 1, 1, &qpn,
1266                                    MLX4_RESERVE_A0_QP);
1267        if (err) {
1268                en_err(priv, "Failed reserving drop qpn\n");
1269                return err;
1270        }
1271        err = mlx4_qp_alloc(priv->mdev->dev, qpn, &priv->drop_qp, GFP_KERNEL);
1272        if (err) {
1273                en_err(priv, "Failed allocating drop qp\n");
1274                mlx4_qp_release_range(priv->mdev->dev, qpn, 1);
1275                return err;
1276        }
1277
1278        return 0;
1279}
1280
1281void mlx4_en_destroy_drop_qp(struct mlx4_en_priv *priv)
1282{
1283        u32 qpn;
1284
1285        qpn = priv->drop_qp.qpn;
1286        mlx4_qp_remove(priv->mdev->dev, &priv->drop_qp);
1287        mlx4_qp_free(priv->mdev->dev, &priv->drop_qp);
1288        mlx4_qp_release_range(priv->mdev->dev, qpn, 1);
1289}
1290
1291/* Allocate rx qp's and configure them according to rss map */
1292int mlx4_en_config_rss_steer(struct mlx4_en_priv *priv)
1293{
1294        struct mlx4_en_dev *mdev = priv->mdev;
1295        struct mlx4_en_rss_map *rss_map = &priv->rss_map;
1296        struct mlx4_qp_context context;
1297        struct mlx4_rss_context *rss_context;
1298        int rss_rings;
1299        void *ptr;
1300        u8 rss_mask = (MLX4_RSS_IPV4 | MLX4_RSS_TCP_IPV4 | MLX4_RSS_IPV6 |
1301                        MLX4_RSS_TCP_IPV6);
1302        int i, qpn;
1303        int err = 0;
1304        int good_qps = 0;
1305
1306        en_dbg(DRV, priv, "Configuring rss steering\n");
1307        err = mlx4_qp_reserve_range(mdev->dev, priv->rx_ring_num,
1308                                    priv->rx_ring_num,
1309                                    &rss_map->base_qpn, 0);
1310        if (err) {
1311                en_err(priv, "Failed reserving %d qps\n", priv->rx_ring_num);
1312                return err;
1313        }
1314
1315        for (i = 0; i < priv->rx_ring_num; i++) {
1316                qpn = rss_map->base_qpn + i;
1317                err = mlx4_en_config_rss_qp(priv, qpn, priv->rx_ring[i],
1318                                            &rss_map->state[i],
1319                                            &rss_map->qps[i]);
1320                if (err)
1321                        goto rss_err;
1322
1323                ++good_qps;
1324        }
1325
1326        /* Configure RSS indirection qp */
1327        err = mlx4_qp_alloc(mdev->dev, priv->base_qpn, &rss_map->indir_qp, GFP_KERNEL);
1328        if (err) {
1329                en_err(priv, "Failed to allocate RSS indirection QP\n");
1330                goto rss_err;
1331        }
1332        rss_map->indir_qp.event = mlx4_en_sqp_event;
1333        mlx4_en_fill_qp_context(priv, 0, 0, 0, 1, priv->base_qpn,
1334                                priv->rx_ring[0]->cqn, -1, &context);
1335
1336        if (!priv->prof->rss_rings || priv->prof->rss_rings > priv->rx_ring_num)
1337                rss_rings = priv->rx_ring_num;
1338        else
1339                rss_rings = priv->prof->rss_rings;
1340
1341        ptr = ((void *) &context) + offsetof(struct mlx4_qp_context, pri_path)
1342                                        + MLX4_RSS_OFFSET_IN_QPC_PRI_PATH;
1343        rss_context = ptr;
1344        rss_context->base_qpn = cpu_to_be32(ilog2(rss_rings) << 24 |
1345                                            (rss_map->base_qpn));
1346        rss_context->default_qpn = cpu_to_be32(rss_map->base_qpn);
1347        if (priv->mdev->profile.udp_rss) {
1348                rss_mask |=  MLX4_RSS_UDP_IPV4 | MLX4_RSS_UDP_IPV6;
1349                rss_context->base_qpn_udp = rss_context->default_qpn;
1350        }
1351
1352        if (mdev->dev->caps.tunnel_offload_mode == MLX4_TUNNEL_OFFLOAD_MODE_VXLAN) {
1353                en_info(priv, "Setting RSS context tunnel type to RSS on inner headers\n");
1354                rss_mask |= MLX4_RSS_BY_INNER_HEADERS;
1355        }
1356
1357        rss_context->flags = rss_mask;
1358        rss_context->hash_fn = MLX4_RSS_HASH_TOP;
1359        if (priv->rss_hash_fn == ETH_RSS_HASH_XOR) {
1360                rss_context->hash_fn = MLX4_RSS_HASH_XOR;
1361        } else if (priv->rss_hash_fn == ETH_RSS_HASH_TOP) {
1362                rss_context->hash_fn = MLX4_RSS_HASH_TOP;
1363                memcpy(rss_context->rss_key, priv->rss_key,
1364                       MLX4_EN_RSS_KEY_SIZE);
1365        } else {
1366                en_err(priv, "Unknown RSS hash function requested\n");
1367                err = -EINVAL;
1368                goto indir_err;
1369        }
1370        err = mlx4_qp_to_ready(mdev->dev, &priv->res.mtt, &context,
1371                               &rss_map->indir_qp, &rss_map->indir_state);
1372        if (err)
1373                goto indir_err;
1374
1375        return 0;
1376
1377indir_err:
1378        mlx4_qp_modify(mdev->dev, NULL, rss_map->indir_state,
1379                       MLX4_QP_STATE_RST, NULL, 0, 0, &rss_map->indir_qp);
1380        mlx4_qp_remove(mdev->dev, &rss_map->indir_qp);
1381        mlx4_qp_free(mdev->dev, &rss_map->indir_qp);
1382rss_err:
1383        for (i = 0; i < good_qps; i++) {
1384                mlx4_qp_modify(mdev->dev, NULL, rss_map->state[i],
1385                               MLX4_QP_STATE_RST, NULL, 0, 0, &rss_map->qps[i]);
1386                mlx4_qp_remove(mdev->dev, &rss_map->qps[i]);
1387                mlx4_qp_free(mdev->dev, &rss_map->qps[i]);
1388        }
1389        mlx4_qp_release_range(mdev->dev, rss_map->base_qpn, priv->rx_ring_num);
1390        return err;
1391}
1392
1393void mlx4_en_release_rss_steer(struct mlx4_en_priv *priv)
1394{
1395        struct mlx4_en_dev *mdev = priv->mdev;
1396        struct mlx4_en_rss_map *rss_map = &priv->rss_map;
1397        int i;
1398
1399        mlx4_qp_modify(mdev->dev, NULL, rss_map->indir_state,
1400                       MLX4_QP_STATE_RST, NULL, 0, 0, &rss_map->indir_qp);
1401        mlx4_qp_remove(mdev->dev, &rss_map->indir_qp);
1402        mlx4_qp_free(mdev->dev, &rss_map->indir_qp);
1403
1404        for (i = 0; i < priv->rx_ring_num; i++) {
1405                mlx4_qp_modify(mdev->dev, NULL, rss_map->state[i],
1406                               MLX4_QP_STATE_RST, NULL, 0, 0, &rss_map->qps[i]);
1407                mlx4_qp_remove(mdev->dev, &rss_map->qps[i]);
1408                mlx4_qp_free(mdev->dev, &rss_map->qps[i]);
1409        }
1410        mlx4_qp_release_range(mdev->dev, rss_map->base_qpn, priv->rx_ring_num);
1411}
Note: See TracBrowser for help on using the repository browser.