9106ea45e3cb7a4f9dac56c4b9ce93e84064331c
[sfrench/cifs-2.6.git] / drivers / net / ethernet / mellanox / mlx5 / core / en_tx.c
1 /*
2  * Copyright (c) 2015-2016, 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 #include <linux/tcp.h>
34 #include <linux/if_vlan.h>
35 #include <net/dsfield.h>
36 #include "en.h"
37 #include "ipoib/ipoib.h"
38 #include "en_accel/en_accel.h"
39 #include "lib/clock.h"
40
41 #define MLX5E_SQ_NOPS_ROOM  MLX5_SEND_WQE_MAX_WQEBBS
42
43 #ifndef CONFIG_MLX5_EN_TLS
44 #define MLX5E_SQ_STOP_ROOM (MLX5_SEND_WQE_MAX_WQEBBS +\
45                             MLX5E_SQ_NOPS_ROOM)
46 #else
47 /* TLS offload requires MLX5E_SQ_STOP_ROOM to have
48  * enough room for a resync SKB, a normal SKB and a NOP
49  */
50 #define MLX5E_SQ_STOP_ROOM (2 * MLX5_SEND_WQE_MAX_WQEBBS +\
51                             MLX5E_SQ_NOPS_ROOM)
52 #endif
53
54 static inline void mlx5e_tx_dma_unmap(struct device *pdev,
55                                       struct mlx5e_sq_dma *dma)
56 {
57         switch (dma->type) {
58         case MLX5E_DMA_MAP_SINGLE:
59                 dma_unmap_single(pdev, dma->addr, dma->size, DMA_TO_DEVICE);
60                 break;
61         case MLX5E_DMA_MAP_PAGE:
62                 dma_unmap_page(pdev, dma->addr, dma->size, DMA_TO_DEVICE);
63                 break;
64         default:
65                 WARN_ONCE(true, "mlx5e_tx_dma_unmap unknown DMA type!\n");
66         }
67 }
68
69 static inline void mlx5e_dma_push(struct mlx5e_txqsq *sq,
70                                   dma_addr_t addr,
71                                   u32 size,
72                                   enum mlx5e_dma_map_type map_type)
73 {
74         u32 i = sq->dma_fifo_pc & sq->dma_fifo_mask;
75
76         sq->db.dma_fifo[i].addr = addr;
77         sq->db.dma_fifo[i].size = size;
78         sq->db.dma_fifo[i].type = map_type;
79         sq->dma_fifo_pc++;
80 }
81
82 static inline struct mlx5e_sq_dma *mlx5e_dma_get(struct mlx5e_txqsq *sq, u32 i)
83 {
84         return &sq->db.dma_fifo[i & sq->dma_fifo_mask];
85 }
86
87 static void mlx5e_dma_unmap_wqe_err(struct mlx5e_txqsq *sq, u8 num_dma)
88 {
89         int i;
90
91         for (i = 0; i < num_dma; i++) {
92                 struct mlx5e_sq_dma *last_pushed_dma =
93                         mlx5e_dma_get(sq, --sq->dma_fifo_pc);
94
95                 mlx5e_tx_dma_unmap(sq->pdev, last_pushed_dma);
96         }
97 }
98
99 #ifdef CONFIG_MLX5_CORE_EN_DCB
100 static inline int mlx5e_get_dscp_up(struct mlx5e_priv *priv, struct sk_buff *skb)
101 {
102         int dscp_cp = 0;
103
104         if (skb->protocol == htons(ETH_P_IP))
105                 dscp_cp = ipv4_get_dsfield(ip_hdr(skb)) >> 2;
106         else if (skb->protocol == htons(ETH_P_IPV6))
107                 dscp_cp = ipv6_get_dsfield(ipv6_hdr(skb)) >> 2;
108
109         return priv->dcbx_dp.dscp2prio[dscp_cp];
110 }
111 #endif
112
113 u16 mlx5e_select_queue(struct net_device *dev, struct sk_buff *skb,
114                        struct net_device *sb_dev,
115                        select_queue_fallback_t fallback)
116 {
117         struct mlx5e_priv *priv = netdev_priv(dev);
118         int channel_ix = fallback(dev, skb, NULL);
119         u16 num_channels;
120         int up = 0;
121
122         if (!netdev_get_num_tc(dev))
123                 return channel_ix;
124
125 #ifdef CONFIG_MLX5_CORE_EN_DCB
126         if (priv->dcbx_dp.trust_state == MLX5_QPTS_TRUST_DSCP)
127                 up = mlx5e_get_dscp_up(priv, skb);
128         else
129 #endif
130                 if (skb_vlan_tag_present(skb))
131                         up = skb->vlan_tci >> VLAN_PRIO_SHIFT;
132
133         /* channel_ix can be larger than num_channels since
134          * dev->num_real_tx_queues = num_channels * num_tc
135          */
136         num_channels = priv->channels.params.num_channels;
137         if (channel_ix >= num_channels)
138                 channel_ix = reciprocal_scale(channel_ix, num_channels);
139
140         return priv->channel_tc2txq[channel_ix][up];
141 }
142
143 static inline int mlx5e_skb_l2_header_offset(struct sk_buff *skb)
144 {
145 #define MLX5E_MIN_INLINE (ETH_HLEN + VLAN_HLEN)
146
147         return max(skb_network_offset(skb), MLX5E_MIN_INLINE);
148 }
149
150 static inline int mlx5e_skb_l3_header_offset(struct sk_buff *skb)
151 {
152         struct flow_keys keys;
153
154         if (skb_transport_header_was_set(skb))
155                 return skb_transport_offset(skb);
156         else if (skb_flow_dissect_flow_keys(skb, &keys, 0))
157                 return keys.control.thoff;
158         else
159                 return mlx5e_skb_l2_header_offset(skb);
160 }
161
162 static inline u16 mlx5e_calc_min_inline(enum mlx5_inline_modes mode,
163                                         struct sk_buff *skb)
164 {
165         u16 hlen;
166
167         switch (mode) {
168         case MLX5_INLINE_MODE_NONE:
169                 return 0;
170         case MLX5_INLINE_MODE_TCP_UDP:
171                 hlen = eth_get_headlen(skb->data, skb_headlen(skb));
172                 if (hlen == ETH_HLEN && !skb_vlan_tag_present(skb))
173                         hlen += VLAN_HLEN;
174                 break;
175         case MLX5_INLINE_MODE_IP:
176                 /* When transport header is set to zero, it means no transport
177                  * header. When transport header is set to 0xff's, it means
178                  * transport header wasn't set.
179                  */
180                 if (skb_transport_offset(skb)) {
181                         hlen = mlx5e_skb_l3_header_offset(skb);
182                         break;
183                 }
184                 /* fall through */
185         case MLX5_INLINE_MODE_L2:
186         default:
187                 hlen = mlx5e_skb_l2_header_offset(skb);
188         }
189         return min_t(u16, hlen, skb_headlen(skb));
190 }
191
192 static inline void mlx5e_insert_vlan(void *start, struct sk_buff *skb, u16 ihs)
193 {
194         struct vlan_ethhdr *vhdr = (struct vlan_ethhdr *)start;
195         int cpy1_sz = 2 * ETH_ALEN;
196         int cpy2_sz = ihs - cpy1_sz;
197
198         memcpy(vhdr, skb->data, cpy1_sz);
199         vhdr->h_vlan_proto = skb->vlan_proto;
200         vhdr->h_vlan_TCI = cpu_to_be16(skb_vlan_tag_get(skb));
201         memcpy(&vhdr->h_vlan_encapsulated_proto, skb->data + cpy1_sz, cpy2_sz);
202 }
203
204 static inline void
205 mlx5e_txwqe_build_eseg_csum(struct mlx5e_txqsq *sq, struct sk_buff *skb, struct mlx5_wqe_eth_seg *eseg)
206 {
207         if (likely(skb->ip_summed == CHECKSUM_PARTIAL)) {
208                 eseg->cs_flags = MLX5_ETH_WQE_L3_CSUM;
209                 if (skb->encapsulation) {
210                         eseg->cs_flags |= MLX5_ETH_WQE_L3_INNER_CSUM |
211                                           MLX5_ETH_WQE_L4_INNER_CSUM;
212                         sq->stats->csum_partial_inner++;
213                 } else {
214                         eseg->cs_flags |= MLX5_ETH_WQE_L4_CSUM;
215                         sq->stats->csum_partial++;
216                 }
217         } else
218                 sq->stats->csum_none++;
219 }
220
221 static inline u16
222 mlx5e_tx_get_gso_ihs(struct mlx5e_txqsq *sq, struct sk_buff *skb)
223 {
224         struct mlx5e_sq_stats *stats = sq->stats;
225         u16 ihs;
226
227         if (skb->encapsulation) {
228                 ihs = skb_inner_transport_offset(skb) + inner_tcp_hdrlen(skb);
229                 stats->tso_inner_packets++;
230                 stats->tso_inner_bytes += skb->len - ihs;
231         } else {
232                 if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4)
233                         ihs = skb_transport_offset(skb) + sizeof(struct udphdr);
234                 else
235                         ihs = skb_transport_offset(skb) + tcp_hdrlen(skb);
236                 stats->tso_packets++;
237                 stats->tso_bytes += skb->len - ihs;
238         }
239
240         return ihs;
241 }
242
243 static inline int
244 mlx5e_txwqe_build_dsegs(struct mlx5e_txqsq *sq, struct sk_buff *skb,
245                         unsigned char *skb_data, u16 headlen,
246                         struct mlx5_wqe_data_seg *dseg)
247 {
248         dma_addr_t dma_addr = 0;
249         u8 num_dma          = 0;
250         int i;
251
252         if (headlen) {
253                 dma_addr = dma_map_single(sq->pdev, skb_data, headlen,
254                                           DMA_TO_DEVICE);
255                 if (unlikely(dma_mapping_error(sq->pdev, dma_addr)))
256                         goto dma_unmap_wqe_err;
257
258                 dseg->addr       = cpu_to_be64(dma_addr);
259                 dseg->lkey       = sq->mkey_be;
260                 dseg->byte_count = cpu_to_be32(headlen);
261
262                 mlx5e_dma_push(sq, dma_addr, headlen, MLX5E_DMA_MAP_SINGLE);
263                 num_dma++;
264                 dseg++;
265         }
266
267         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
268                 struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
269                 int fsz = skb_frag_size(frag);
270
271                 dma_addr = skb_frag_dma_map(sq->pdev, frag, 0, fsz,
272                                             DMA_TO_DEVICE);
273                 if (unlikely(dma_mapping_error(sq->pdev, dma_addr)))
274                         goto dma_unmap_wqe_err;
275
276                 dseg->addr       = cpu_to_be64(dma_addr);
277                 dseg->lkey       = sq->mkey_be;
278                 dseg->byte_count = cpu_to_be32(fsz);
279
280                 mlx5e_dma_push(sq, dma_addr, fsz, MLX5E_DMA_MAP_PAGE);
281                 num_dma++;
282                 dseg++;
283         }
284
285         return num_dma;
286
287 dma_unmap_wqe_err:
288         mlx5e_dma_unmap_wqe_err(sq, num_dma);
289         return -ENOMEM;
290 }
291
292 static inline void mlx5e_fill_sq_frag_edge(struct mlx5e_txqsq *sq,
293                                            struct mlx5_wq_cyc *wq,
294                                            u16 pi, u16 frag_pi)
295 {
296         struct mlx5e_tx_wqe_info *edge_wi, *wi = &sq->db.wqe_info[pi];
297         u8 nnops = mlx5_wq_cyc_get_frag_size(wq) - frag_pi;
298
299         edge_wi = wi + nnops;
300
301         /* fill sq frag edge with nops to avoid wqe wrapping two pages */
302         for (; wi < edge_wi; wi++) {
303                 wi->skb        = NULL;
304                 wi->num_wqebbs = 1;
305                 mlx5e_post_nop(wq, sq->sqn, &sq->pc);
306         }
307         sq->stats->nop += nnops;
308 }
309
310 static inline void
311 mlx5e_txwqe_complete(struct mlx5e_txqsq *sq, struct sk_buff *skb,
312                      u8 opcode, u16 ds_cnt, u8 num_wqebbs, u32 num_bytes, u8 num_dma,
313                      struct mlx5e_tx_wqe_info *wi, struct mlx5_wqe_ctrl_seg *cseg)
314 {
315         struct mlx5_wq_cyc *wq = &sq->wq;
316
317         wi->num_bytes = num_bytes;
318         wi->num_dma = num_dma;
319         wi->num_wqebbs = num_wqebbs;
320         wi->skb = skb;
321
322         cseg->opmod_idx_opcode = cpu_to_be32((sq->pc << 8) | opcode);
323         cseg->qpn_ds           = cpu_to_be32((sq->sqn << 8) | ds_cnt);
324
325         netdev_tx_sent_queue(sq->txq, num_bytes);
326
327         if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP))
328                 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
329
330         sq->pc += wi->num_wqebbs;
331         if (unlikely(!mlx5e_wqc_has_room_for(wq, sq->cc, sq->pc, MLX5E_SQ_STOP_ROOM))) {
332                 netif_tx_stop_queue(sq->txq);
333                 sq->stats->stopped++;
334         }
335
336         if (!skb->xmit_more || netif_xmit_stopped(sq->txq))
337                 mlx5e_notify_hw(wq, sq->pc, sq->uar_map, cseg);
338 }
339
340 #define INL_HDR_START_SZ (sizeof(((struct mlx5_wqe_eth_seg *)NULL)->inline_hdr.start))
341
342 netdev_tx_t mlx5e_sq_xmit(struct mlx5e_txqsq *sq, struct sk_buff *skb,
343                           struct mlx5e_tx_wqe *wqe, u16 pi)
344 {
345         struct mlx5_wq_cyc *wq = &sq->wq;
346         struct mlx5_wqe_ctrl_seg *cseg;
347         struct mlx5_wqe_eth_seg  *eseg;
348         struct mlx5_wqe_data_seg *dseg;
349         struct mlx5e_tx_wqe_info *wi;
350
351         struct mlx5e_sq_stats *stats = sq->stats;
352         u16 ds_cnt, ds_cnt_inl = 0;
353         u16 headlen, ihs, frag_pi;
354         u8 num_wqebbs, opcode;
355         u32 num_bytes;
356         int num_dma;
357         __be16 mss;
358
359         /* Calc ihs and ds cnt, no writes to wqe yet */
360         ds_cnt = sizeof(*wqe) / MLX5_SEND_WQE_DS;
361         if (skb_is_gso(skb)) {
362                 opcode    = MLX5_OPCODE_LSO;
363                 mss       = cpu_to_be16(skb_shinfo(skb)->gso_size);
364                 ihs       = mlx5e_tx_get_gso_ihs(sq, skb);
365                 num_bytes = skb->len + (skb_shinfo(skb)->gso_segs - 1) * ihs;
366                 stats->packets += skb_shinfo(skb)->gso_segs;
367         } else {
368                 opcode    = MLX5_OPCODE_SEND;
369                 mss       = 0;
370                 ihs       = mlx5e_calc_min_inline(sq->min_inline_mode, skb);
371                 num_bytes = max_t(unsigned int, skb->len, ETH_ZLEN);
372                 stats->packets++;
373         }
374
375         stats->bytes     += num_bytes;
376         stats->xmit_more += skb->xmit_more;
377
378         headlen = skb->len - ihs - skb->data_len;
379         ds_cnt += !!headlen;
380         ds_cnt += skb_shinfo(skb)->nr_frags;
381
382         if (ihs) {
383                 ihs += !!skb_vlan_tag_present(skb) * VLAN_HLEN;
384
385                 ds_cnt_inl = DIV_ROUND_UP(ihs - INL_HDR_START_SZ, MLX5_SEND_WQE_DS);
386                 ds_cnt += ds_cnt_inl;
387         }
388
389         num_wqebbs = DIV_ROUND_UP(ds_cnt, MLX5_SEND_WQEBB_NUM_DS);
390         frag_pi = mlx5_wq_cyc_ctr2fragix(wq, sq->pc);
391         if (unlikely(frag_pi + num_wqebbs > mlx5_wq_cyc_get_frag_size(wq))) {
392                 mlx5e_fill_sq_frag_edge(sq, wq, pi, frag_pi);
393                 mlx5e_sq_fetch_wqe(sq, &wqe, &pi);
394         }
395
396         /* fill wqe */
397         wi   = &sq->db.wqe_info[pi];
398         cseg = &wqe->ctrl;
399         eseg = &wqe->eth;
400         dseg =  wqe->data;
401
402         mlx5e_txwqe_build_eseg_csum(sq, skb, eseg);
403
404         eseg->mss = mss;
405
406         if (ihs) {
407                 eseg->inline_hdr.sz = cpu_to_be16(ihs);
408                 if (skb_vlan_tag_present(skb)) {
409                         ihs -= VLAN_HLEN;
410                         mlx5e_insert_vlan(eseg->inline_hdr.start, skb, ihs);
411                         stats->added_vlan_packets++;
412                 } else {
413                         memcpy(eseg->inline_hdr.start, skb->data, ihs);
414                 }
415                 dseg += ds_cnt_inl;
416         } else if (skb_vlan_tag_present(skb)) {
417                 eseg->insert.type = cpu_to_be16(MLX5_ETH_WQE_INSERT_VLAN);
418                 if (skb->vlan_proto == cpu_to_be16(ETH_P_8021AD))
419                         eseg->insert.type |= cpu_to_be16(MLX5_ETH_WQE_SVLAN);
420                 eseg->insert.vlan_tci = cpu_to_be16(skb_vlan_tag_get(skb));
421                 stats->added_vlan_packets++;
422         }
423
424         num_dma = mlx5e_txwqe_build_dsegs(sq, skb, skb->data + ihs, headlen, dseg);
425         if (unlikely(num_dma < 0))
426                 goto err_drop;
427
428         mlx5e_txwqe_complete(sq, skb, opcode, ds_cnt, num_wqebbs, num_bytes,
429                              num_dma, wi, cseg);
430
431         return NETDEV_TX_OK;
432
433 err_drop:
434         stats->dropped++;
435         dev_kfree_skb_any(skb);
436
437         return NETDEV_TX_OK;
438 }
439
440 netdev_tx_t mlx5e_xmit(struct sk_buff *skb, struct net_device *dev)
441 {
442         struct mlx5e_priv *priv = netdev_priv(dev);
443         struct mlx5e_tx_wqe *wqe;
444         struct mlx5e_txqsq *sq;
445         u16 pi;
446
447         sq = priv->txq2sq[skb_get_queue_mapping(skb)];
448         mlx5e_sq_fetch_wqe(sq, &wqe, &pi);
449
450         /* might send skbs and update wqe and pi */
451         skb = mlx5e_accel_handle_tx(skb, sq, dev, &wqe, &pi);
452         if (unlikely(!skb))
453                 return NETDEV_TX_OK;
454
455         return mlx5e_sq_xmit(sq, skb, wqe, pi);
456 }
457
458 static void mlx5e_dump_error_cqe(struct mlx5e_txqsq *sq,
459                                  struct mlx5_err_cqe *err_cqe)
460 {
461         u32 ci = mlx5_cqwq_get_ci(&sq->cq.wq);
462
463         netdev_err(sq->channel->netdev,
464                    "Error cqe on cqn 0x%x, ci 0x%x, sqn 0x%x, syndrome 0x%x, vendor syndrome 0x%x\n",
465                    sq->cq.mcq.cqn, ci, sq->sqn, err_cqe->syndrome,
466                    err_cqe->vendor_err_synd);
467         mlx5_dump_err_cqe(sq->cq.mdev, err_cqe);
468 }
469
470 bool mlx5e_poll_tx_cq(struct mlx5e_cq *cq, int napi_budget)
471 {
472         struct mlx5e_sq_stats *stats;
473         struct mlx5e_txqsq *sq;
474         struct mlx5_cqe64 *cqe;
475         u32 dma_fifo_cc;
476         u32 nbytes;
477         u16 npkts;
478         u16 sqcc;
479         int i;
480
481         sq = container_of(cq, struct mlx5e_txqsq, cq);
482
483         if (unlikely(!test_bit(MLX5E_SQ_STATE_ENABLED, &sq->state)))
484                 return false;
485
486         cqe = mlx5_cqwq_get_cqe(&cq->wq);
487         if (!cqe)
488                 return false;
489
490         stats = sq->stats;
491
492         npkts = 0;
493         nbytes = 0;
494
495         /* sq->cc must be updated only after mlx5_cqwq_update_db_record(),
496          * otherwise a cq overrun may occur
497          */
498         sqcc = sq->cc;
499
500         /* avoid dirtying sq cache line every cqe */
501         dma_fifo_cc = sq->dma_fifo_cc;
502
503         i = 0;
504         do {
505                 u16 wqe_counter;
506                 bool last_wqe;
507
508                 mlx5_cqwq_pop(&cq->wq);
509
510                 wqe_counter = be16_to_cpu(cqe->wqe_counter);
511
512                 if (unlikely(cqe->op_own >> 4 == MLX5_CQE_REQ_ERR)) {
513                         if (!test_and_set_bit(MLX5E_SQ_STATE_RECOVERING,
514                                               &sq->state)) {
515                                 mlx5e_dump_error_cqe(sq,
516                                                      (struct mlx5_err_cqe *)cqe);
517                                 queue_work(cq->channel->priv->wq,
518                                            &sq->recover.recover_work);
519                         }
520                         stats->cqe_err++;
521                 }
522
523                 do {
524                         struct mlx5e_tx_wqe_info *wi;
525                         struct sk_buff *skb;
526                         u16 ci;
527                         int j;
528
529                         last_wqe = (sqcc == wqe_counter);
530
531                         ci = mlx5_wq_cyc_ctr2ix(&sq->wq, sqcc);
532                         wi = &sq->db.wqe_info[ci];
533                         skb = wi->skb;
534
535                         if (unlikely(!skb)) { /* nop */
536                                 sqcc++;
537                                 continue;
538                         }
539
540                         if (unlikely(skb_shinfo(skb)->tx_flags &
541                                      SKBTX_HW_TSTAMP)) {
542                                 struct skb_shared_hwtstamps hwts = {};
543
544                                 hwts.hwtstamp =
545                                         mlx5_timecounter_cyc2time(sq->clock,
546                                                                   get_cqe_ts(cqe));
547                                 skb_tstamp_tx(skb, &hwts);
548                         }
549
550                         for (j = 0; j < wi->num_dma; j++) {
551                                 struct mlx5e_sq_dma *dma =
552                                         mlx5e_dma_get(sq, dma_fifo_cc++);
553
554                                 mlx5e_tx_dma_unmap(sq->pdev, dma);
555                         }
556
557                         npkts++;
558                         nbytes += wi->num_bytes;
559                         sqcc += wi->num_wqebbs;
560                         napi_consume_skb(skb, napi_budget);
561                 } while (!last_wqe);
562
563         } while ((++i < MLX5E_TX_CQ_POLL_BUDGET) && (cqe = mlx5_cqwq_get_cqe(&cq->wq)));
564
565         stats->cqes += i;
566
567         mlx5_cqwq_update_db_record(&cq->wq);
568
569         /* ensure cq space is freed before enabling more cqes */
570         wmb();
571
572         sq->dma_fifo_cc = dma_fifo_cc;
573         sq->cc = sqcc;
574
575         netdev_tx_completed_queue(sq->txq, npkts, nbytes);
576
577         if (netif_tx_queue_stopped(sq->txq) &&
578             mlx5e_wqc_has_room_for(&sq->wq, sq->cc, sq->pc,
579                                    MLX5E_SQ_STOP_ROOM) &&
580             !test_bit(MLX5E_SQ_STATE_RECOVERING, &sq->state)) {
581                 netif_tx_wake_queue(sq->txq);
582                 stats->wake++;
583         }
584
585         return (i == MLX5E_TX_CQ_POLL_BUDGET);
586 }
587
588 void mlx5e_free_txqsq_descs(struct mlx5e_txqsq *sq)
589 {
590         struct mlx5e_tx_wqe_info *wi;
591         struct sk_buff *skb;
592         u16 ci;
593         int i;
594
595         while (sq->cc != sq->pc) {
596                 ci = mlx5_wq_cyc_ctr2ix(&sq->wq, sq->cc);
597                 wi = &sq->db.wqe_info[ci];
598                 skb = wi->skb;
599
600                 if (!skb) { /* nop */
601                         sq->cc++;
602                         continue;
603                 }
604
605                 for (i = 0; i < wi->num_dma; i++) {
606                         struct mlx5e_sq_dma *dma =
607                                 mlx5e_dma_get(sq, sq->dma_fifo_cc++);
608
609                         mlx5e_tx_dma_unmap(sq->pdev, dma);
610                 }
611
612                 dev_kfree_skb_any(skb);
613                 sq->cc += wi->num_wqebbs;
614         }
615 }
616
617 #ifdef CONFIG_MLX5_CORE_IPOIB
618 static inline void
619 mlx5i_txwqe_build_datagram(struct mlx5_av *av, u32 dqpn, u32 dqkey,
620                            struct mlx5_wqe_datagram_seg *dseg)
621 {
622         memcpy(&dseg->av, av, sizeof(struct mlx5_av));
623         dseg->av.dqp_dct = cpu_to_be32(dqpn | MLX5_EXTENDED_UD_AV);
624         dseg->av.key.qkey.qkey = cpu_to_be32(dqkey);
625 }
626
627 netdev_tx_t mlx5i_sq_xmit(struct mlx5e_txqsq *sq, struct sk_buff *skb,
628                           struct mlx5_av *av, u32 dqpn, u32 dqkey)
629 {
630         struct mlx5_wq_cyc *wq = &sq->wq;
631         struct mlx5i_tx_wqe *wqe;
632
633         struct mlx5_wqe_datagram_seg *datagram;
634         struct mlx5_wqe_ctrl_seg *cseg;
635         struct mlx5_wqe_eth_seg  *eseg;
636         struct mlx5_wqe_data_seg *dseg;
637         struct mlx5e_tx_wqe_info *wi;
638
639         struct mlx5e_sq_stats *stats = sq->stats;
640         u16 headlen, ihs, pi, frag_pi;
641         u16 ds_cnt, ds_cnt_inl = 0;
642         u8 num_wqebbs, opcode;
643         u32 num_bytes;
644         int num_dma;
645         __be16 mss;
646
647         /* Calc ihs and ds cnt, no writes to wqe yet */
648         ds_cnt = sizeof(*wqe) / MLX5_SEND_WQE_DS;
649         if (skb_is_gso(skb)) {
650                 opcode    = MLX5_OPCODE_LSO;
651                 mss       = cpu_to_be16(skb_shinfo(skb)->gso_size);
652                 ihs       = mlx5e_tx_get_gso_ihs(sq, skb);
653                 num_bytes = skb->len + (skb_shinfo(skb)->gso_segs - 1) * ihs;
654                 stats->packets += skb_shinfo(skb)->gso_segs;
655         } else {
656                 opcode    = MLX5_OPCODE_SEND;
657                 mss       = 0;
658                 ihs       = mlx5e_calc_min_inline(sq->min_inline_mode, skb);
659                 num_bytes = max_t(unsigned int, skb->len, ETH_ZLEN);
660                 stats->packets++;
661         }
662
663         stats->bytes     += num_bytes;
664         stats->xmit_more += skb->xmit_more;
665
666         headlen = skb->len - ihs - skb->data_len;
667         ds_cnt += !!headlen;
668         ds_cnt += skb_shinfo(skb)->nr_frags;
669
670         if (ihs) {
671                 ds_cnt_inl = DIV_ROUND_UP(ihs - INL_HDR_START_SZ, MLX5_SEND_WQE_DS);
672                 ds_cnt += ds_cnt_inl;
673         }
674
675         num_wqebbs = DIV_ROUND_UP(ds_cnt, MLX5_SEND_WQEBB_NUM_DS);
676         frag_pi = mlx5_wq_cyc_ctr2fragix(wq, sq->pc);
677         if (unlikely(frag_pi + num_wqebbs > mlx5_wq_cyc_get_frag_size(wq))) {
678                 pi = mlx5_wq_cyc_ctr2ix(wq, sq->pc);
679                 mlx5e_fill_sq_frag_edge(sq, wq, pi, frag_pi);
680         }
681
682         mlx5i_sq_fetch_wqe(sq, &wqe, &pi);
683
684         /* fill wqe */
685         wi       = &sq->db.wqe_info[pi];
686         cseg     = &wqe->ctrl;
687         datagram = &wqe->datagram;
688         eseg     = &wqe->eth;
689         dseg     =  wqe->data;
690
691         mlx5i_txwqe_build_datagram(av, dqpn, dqkey, datagram);
692
693         mlx5e_txwqe_build_eseg_csum(sq, skb, eseg);
694
695         eseg->mss = mss;
696
697         if (ihs) {
698                 memcpy(eseg->inline_hdr.start, skb->data, ihs);
699                 eseg->inline_hdr.sz = cpu_to_be16(ihs);
700                 dseg += ds_cnt_inl;
701         }
702
703         num_dma = mlx5e_txwqe_build_dsegs(sq, skb, skb->data + ihs, headlen, dseg);
704         if (unlikely(num_dma < 0))
705                 goto err_drop;
706
707         mlx5e_txwqe_complete(sq, skb, opcode, ds_cnt, num_wqebbs, num_bytes,
708                              num_dma, wi, cseg);
709
710         return NETDEV_TX_OK;
711
712 err_drop:
713         stats->dropped++;
714         dev_kfree_skb_any(skb);
715
716         return NETDEV_TX_OK;
717 }
718 #endif