6367cee0d66a2b502b2579a1ea23e7985251d6a5
[linux-3.10.git] / drivers / net / cxgb3 / sge.c
1 /*
2  * Copyright (c) 2005-2007 Chelsio, Inc. 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 #include <linux/skbuff.h>
33 #include <linux/netdevice.h>
34 #include <linux/etherdevice.h>
35 #include <linux/if_vlan.h>
36 #include <linux/ip.h>
37 #include <linux/tcp.h>
38 #include <linux/dma-mapping.h>
39 #include "common.h"
40 #include "regs.h"
41 #include "sge_defs.h"
42 #include "t3_cpl.h"
43 #include "firmware_exports.h"
44
45 #define USE_GTS 0
46
47 #define SGE_RX_SM_BUF_SIZE 1536
48
49 #define SGE_RX_COPY_THRES  256
50 #define SGE_RX_PULL_LEN    128
51
52 /*
53  * Page chunk size for FL0 buffers if FL0 is to be populated with page chunks.
54  * It must be a divisor of PAGE_SIZE.  If set to 0 FL0 will use sk_buffs
55  * directly.
56  */
57 #define FL0_PG_CHUNK_SIZE  2048
58
59 #define SGE_RX_DROP_THRES 16
60
61 /*
62  * Period of the Tx buffer reclaim timer.  This timer does not need to run
63  * frequently as Tx buffers are usually reclaimed by new Tx packets.
64  */
65 #define TX_RECLAIM_PERIOD (HZ / 4)
66
67 /* WR size in bytes */
68 #define WR_LEN (WR_FLITS * 8)
69
70 /*
71  * Types of Tx queues in each queue set.  Order here matters, do not change.
72  */
73 enum { TXQ_ETH, TXQ_OFLD, TXQ_CTRL };
74
75 /* Values for sge_txq.flags */
76 enum {
77         TXQ_RUNNING = 1 << 0,   /* fetch engine is running */
78         TXQ_LAST_PKT_DB = 1 << 1,       /* last packet rang the doorbell */
79 };
80
81 struct tx_desc {
82         __be64 flit[TX_DESC_FLITS];
83 };
84
85 struct rx_desc {
86         __be32 addr_lo;
87         __be32 len_gen;
88         __be32 gen2;
89         __be32 addr_hi;
90 };
91
92 struct tx_sw_desc {             /* SW state per Tx descriptor */
93         struct sk_buff *skb;
94         u8 eop;       /* set if last descriptor for packet */
95         u8 addr_idx;  /* buffer index of first SGL entry in descriptor */
96         u8 fragidx;   /* first page fragment associated with descriptor */
97         s8 sflit;     /* start flit of first SGL entry in descriptor */
98 };
99
100 struct rx_sw_desc {                /* SW state per Rx descriptor */
101         union {
102                 struct sk_buff *skb;
103                 struct fl_pg_chunk pg_chunk;
104         };
105         DECLARE_PCI_UNMAP_ADDR(dma_addr);
106 };
107
108 struct rsp_desc {               /* response queue descriptor */
109         struct rss_header rss_hdr;
110         __be32 flags;
111         __be32 len_cq;
112         u8 imm_data[47];
113         u8 intr_gen;
114 };
115
116 /*
117  * Holds unmapping information for Tx packets that need deferred unmapping.
118  * This structure lives at skb->head and must be allocated by callers.
119  */
120 struct deferred_unmap_info {
121         struct pci_dev *pdev;
122         dma_addr_t addr[MAX_SKB_FRAGS + 1];
123 };
124
125 /*
126  * Maps a number of flits to the number of Tx descriptors that can hold them.
127  * The formula is
128  *
129  * desc = 1 + (flits - 2) / (WR_FLITS - 1).
130  *
131  * HW allows up to 4 descriptors to be combined into a WR.
132  */
133 static u8 flit_desc_map[] = {
134         0,
135 #if SGE_NUM_GENBITS == 1
136         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
137         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
138         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
139         4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
140 #elif SGE_NUM_GENBITS == 2
141         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
142         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
143         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
144         4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
145 #else
146 # error "SGE_NUM_GENBITS must be 1 or 2"
147 #endif
148 };
149
150 static inline struct sge_qset *fl_to_qset(const struct sge_fl *q, int qidx)
151 {
152         return container_of(q, struct sge_qset, fl[qidx]);
153 }
154
155 static inline struct sge_qset *rspq_to_qset(const struct sge_rspq *q)
156 {
157         return container_of(q, struct sge_qset, rspq);
158 }
159
160 static inline struct sge_qset *txq_to_qset(const struct sge_txq *q, int qidx)
161 {
162         return container_of(q, struct sge_qset, txq[qidx]);
163 }
164
165 /**
166  *      refill_rspq - replenish an SGE response queue
167  *      @adapter: the adapter
168  *      @q: the response queue to replenish
169  *      @credits: how many new responses to make available
170  *
171  *      Replenishes a response queue by making the supplied number of responses
172  *      available to HW.
173  */
174 static inline void refill_rspq(struct adapter *adapter,
175                                const struct sge_rspq *q, unsigned int credits)
176 {
177         rmb();
178         t3_write_reg(adapter, A_SG_RSPQ_CREDIT_RETURN,
179                      V_RSPQ(q->cntxt_id) | V_CREDITS(credits));
180 }
181
182 /**
183  *      need_skb_unmap - does the platform need unmapping of sk_buffs?
184  *
185  *      Returns true if the platfrom needs sk_buff unmapping.  The compiler
186  *      optimizes away unecessary code if this returns true.
187  */
188 static inline int need_skb_unmap(void)
189 {
190         /*
191          * This structure is used to tell if the platfrom needs buffer
192          * unmapping by checking if DECLARE_PCI_UNMAP_ADDR defines anything.
193          */
194         struct dummy {
195                 DECLARE_PCI_UNMAP_ADDR(addr);
196         };
197
198         return sizeof(struct dummy) != 0;
199 }
200
201 /**
202  *      unmap_skb - unmap a packet main body and its page fragments
203  *      @skb: the packet
204  *      @q: the Tx queue containing Tx descriptors for the packet
205  *      @cidx: index of Tx descriptor
206  *      @pdev: the PCI device
207  *
208  *      Unmap the main body of an sk_buff and its page fragments, if any.
209  *      Because of the fairly complicated structure of our SGLs and the desire
210  *      to conserve space for metadata, the information necessary to unmap an
211  *      sk_buff is spread across the sk_buff itself (buffer lengths), the HW Tx
212  *      descriptors (the physical addresses of the various data buffers), and
213  *      the SW descriptor state (assorted indices).  The send functions
214  *      initialize the indices for the first packet descriptor so we can unmap
215  *      the buffers held in the first Tx descriptor here, and we have enough
216  *      information at this point to set the state for the next Tx descriptor.
217  *
218  *      Note that it is possible to clean up the first descriptor of a packet
219  *      before the send routines have written the next descriptors, but this
220  *      race does not cause any problem.  We just end up writing the unmapping
221  *      info for the descriptor first.
222  */
223 static inline void unmap_skb(struct sk_buff *skb, struct sge_txq *q,
224                              unsigned int cidx, struct pci_dev *pdev)
225 {
226         const struct sg_ent *sgp;
227         struct tx_sw_desc *d = &q->sdesc[cidx];
228         int nfrags, frag_idx, curflit, j = d->addr_idx;
229
230         sgp = (struct sg_ent *)&q->desc[cidx].flit[d->sflit];
231         frag_idx = d->fragidx;
232
233         if (frag_idx == 0 && skb_headlen(skb)) {
234                 pci_unmap_single(pdev, be64_to_cpu(sgp->addr[0]),
235                                  skb_headlen(skb), PCI_DMA_TODEVICE);
236                 j = 1;
237         }
238
239         curflit = d->sflit + 1 + j;
240         nfrags = skb_shinfo(skb)->nr_frags;
241
242         while (frag_idx < nfrags && curflit < WR_FLITS) {
243                 pci_unmap_page(pdev, be64_to_cpu(sgp->addr[j]),
244                                skb_shinfo(skb)->frags[frag_idx].size,
245                                PCI_DMA_TODEVICE);
246                 j ^= 1;
247                 if (j == 0) {
248                         sgp++;
249                         curflit++;
250                 }
251                 curflit++;
252                 frag_idx++;
253         }
254
255         if (frag_idx < nfrags) {   /* SGL continues into next Tx descriptor */
256                 d = cidx + 1 == q->size ? q->sdesc : d + 1;
257                 d->fragidx = frag_idx;
258                 d->addr_idx = j;
259                 d->sflit = curflit - WR_FLITS - j; /* sflit can be -1 */
260         }
261 }
262
263 /**
264  *      free_tx_desc - reclaims Tx descriptors and their buffers
265  *      @adapter: the adapter
266  *      @q: the Tx queue to reclaim descriptors from
267  *      @n: the number of descriptors to reclaim
268  *
269  *      Reclaims Tx descriptors from an SGE Tx queue and frees the associated
270  *      Tx buffers.  Called with the Tx queue lock held.
271  */
272 static void free_tx_desc(struct adapter *adapter, struct sge_txq *q,
273                          unsigned int n)
274 {
275         struct tx_sw_desc *d;
276         struct pci_dev *pdev = adapter->pdev;
277         unsigned int cidx = q->cidx;
278
279         const int need_unmap = need_skb_unmap() &&
280                                q->cntxt_id >= FW_TUNNEL_SGEEC_START;
281
282         d = &q->sdesc[cidx];
283         while (n--) {
284                 if (d->skb) {   /* an SGL is present */
285                         if (need_unmap)
286                                 unmap_skb(d->skb, q, cidx, pdev);
287                         if (d->eop)
288                                 kfree_skb(d->skb);
289                 }
290                 ++d;
291                 if (++cidx == q->size) {
292                         cidx = 0;
293                         d = q->sdesc;
294                 }
295         }
296         q->cidx = cidx;
297 }
298
299 /**
300  *      reclaim_completed_tx - reclaims completed Tx descriptors
301  *      @adapter: the adapter
302  *      @q: the Tx queue to reclaim completed descriptors from
303  *
304  *      Reclaims Tx descriptors that the SGE has indicated it has processed,
305  *      and frees the associated buffers if possible.  Called with the Tx
306  *      queue's lock held.
307  */
308 static inline void reclaim_completed_tx(struct adapter *adapter,
309                                         struct sge_txq *q)
310 {
311         unsigned int reclaim = q->processed - q->cleaned;
312
313         if (reclaim) {
314                 free_tx_desc(adapter, q, reclaim);
315                 q->cleaned += reclaim;
316                 q->in_use -= reclaim;
317         }
318 }
319
320 /**
321  *      should_restart_tx - are there enough resources to restart a Tx queue?
322  *      @q: the Tx queue
323  *
324  *      Checks if there are enough descriptors to restart a suspended Tx queue.
325  */
326 static inline int should_restart_tx(const struct sge_txq *q)
327 {
328         unsigned int r = q->processed - q->cleaned;
329
330         return q->in_use - r < (q->size >> 1);
331 }
332
333 /**
334  *      free_rx_bufs - free the Rx buffers on an SGE free list
335  *      @pdev: the PCI device associated with the adapter
336  *      @rxq: the SGE free list to clean up
337  *
338  *      Release the buffers on an SGE free-buffer Rx queue.  HW fetching from
339  *      this queue should be stopped before calling this function.
340  */
341 static void free_rx_bufs(struct pci_dev *pdev, struct sge_fl *q)
342 {
343         unsigned int cidx = q->cidx;
344
345         while (q->credits--) {
346                 struct rx_sw_desc *d = &q->sdesc[cidx];
347
348                 pci_unmap_single(pdev, pci_unmap_addr(d, dma_addr),
349                                  q->buf_size, PCI_DMA_FROMDEVICE);
350                 if (q->use_pages) {
351                         put_page(d->pg_chunk.page);
352                         d->pg_chunk.page = NULL;
353                 } else {
354                         kfree_skb(d->skb);
355                         d->skb = NULL;
356                 }
357                 if (++cidx == q->size)
358                         cidx = 0;
359         }
360
361         if (q->pg_chunk.page) {
362                 __free_page(q->pg_chunk.page);
363                 q->pg_chunk.page = NULL;
364         }
365 }
366
367 /**
368  *      add_one_rx_buf - add a packet buffer to a free-buffer list
369  *      @va:  buffer start VA
370  *      @len: the buffer length
371  *      @d: the HW Rx descriptor to write
372  *      @sd: the SW Rx descriptor to write
373  *      @gen: the generation bit value
374  *      @pdev: the PCI device associated with the adapter
375  *
376  *      Add a buffer of the given length to the supplied HW and SW Rx
377  *      descriptors.
378  */
379 static inline void add_one_rx_buf(void *va, unsigned int len,
380                                   struct rx_desc *d, struct rx_sw_desc *sd,
381                                   unsigned int gen, struct pci_dev *pdev)
382 {
383         dma_addr_t mapping;
384
385         mapping = pci_map_single(pdev, va, len, PCI_DMA_FROMDEVICE);
386         pci_unmap_addr_set(sd, dma_addr, mapping);
387
388         d->addr_lo = cpu_to_be32(mapping);
389         d->addr_hi = cpu_to_be32((u64) mapping >> 32);
390         wmb();
391         d->len_gen = cpu_to_be32(V_FLD_GEN1(gen));
392         d->gen2 = cpu_to_be32(V_FLD_GEN2(gen));
393 }
394
395 static int alloc_pg_chunk(struct sge_fl *q, struct rx_sw_desc *sd, gfp_t gfp)
396 {
397         if (!q->pg_chunk.page) {
398                 q->pg_chunk.page = alloc_page(gfp);
399                 if (unlikely(!q->pg_chunk.page))
400                         return -ENOMEM;
401                 q->pg_chunk.va = page_address(q->pg_chunk.page);
402                 q->pg_chunk.offset = 0;
403         }
404         sd->pg_chunk = q->pg_chunk;
405
406         q->pg_chunk.offset += q->buf_size;
407         if (q->pg_chunk.offset == PAGE_SIZE)
408                 q->pg_chunk.page = NULL;
409         else {
410                 q->pg_chunk.va += q->buf_size;
411                 get_page(q->pg_chunk.page);
412         }
413         return 0;
414 }
415
416 /**
417  *      refill_fl - refill an SGE free-buffer list
418  *      @adapter: the adapter
419  *      @q: the free-list to refill
420  *      @n: the number of new buffers to allocate
421  *      @gfp: the gfp flags for allocating new buffers
422  *
423  *      (Re)populate an SGE free-buffer list with up to @n new packet buffers,
424  *      allocated with the supplied gfp flags.  The caller must assure that
425  *      @n does not exceed the queue's capacity.
426  */
427 static void refill_fl(struct adapter *adap, struct sge_fl *q, int n, gfp_t gfp)
428 {
429         void *buf_start;
430         struct rx_sw_desc *sd = &q->sdesc[q->pidx];
431         struct rx_desc *d = &q->desc[q->pidx];
432
433         while (n--) {
434                 if (q->use_pages) {
435                         if (unlikely(alloc_pg_chunk(q, sd, gfp))) {
436 nomem:                          q->alloc_failed++;
437                                 break;
438                         }
439                         buf_start = sd->pg_chunk.va;
440                 } else {
441                         struct sk_buff *skb = alloc_skb(q->buf_size, gfp);
442
443                         if (!skb)
444                                 goto nomem;
445
446                         sd->skb = skb;
447                         buf_start = skb->data;
448                 }
449
450                 add_one_rx_buf(buf_start, q->buf_size, d, sd, q->gen,
451                                adap->pdev);
452                 d++;
453                 sd++;
454                 if (++q->pidx == q->size) {
455                         q->pidx = 0;
456                         q->gen ^= 1;
457                         sd = q->sdesc;
458                         d = q->desc;
459                 }
460                 q->credits++;
461         }
462         wmb();
463         t3_write_reg(adap, A_SG_KDOORBELL, V_EGRCNTX(q->cntxt_id));
464 }
465
466 static inline void __refill_fl(struct adapter *adap, struct sge_fl *fl)
467 {
468         refill_fl(adap, fl, min(16U, fl->size - fl->credits), GFP_ATOMIC);
469 }
470
471 /**
472  *      recycle_rx_buf - recycle a receive buffer
473  *      @adapter: the adapter
474  *      @q: the SGE free list
475  *      @idx: index of buffer to recycle
476  *
477  *      Recycles the specified buffer on the given free list by adding it at
478  *      the next available slot on the list.
479  */
480 static void recycle_rx_buf(struct adapter *adap, struct sge_fl *q,
481                            unsigned int idx)
482 {
483         struct rx_desc *from = &q->desc[idx];
484         struct rx_desc *to = &q->desc[q->pidx];
485
486         q->sdesc[q->pidx] = q->sdesc[idx];
487         to->addr_lo = from->addr_lo;    /* already big endian */
488         to->addr_hi = from->addr_hi;    /* likewise */
489         wmb();
490         to->len_gen = cpu_to_be32(V_FLD_GEN1(q->gen));
491         to->gen2 = cpu_to_be32(V_FLD_GEN2(q->gen));
492         q->credits++;
493
494         if (++q->pidx == q->size) {
495                 q->pidx = 0;
496                 q->gen ^= 1;
497         }
498         t3_write_reg(adap, A_SG_KDOORBELL, V_EGRCNTX(q->cntxt_id));
499 }
500
501 /**
502  *      alloc_ring - allocate resources for an SGE descriptor ring
503  *      @pdev: the PCI device
504  *      @nelem: the number of descriptors
505  *      @elem_size: the size of each descriptor
506  *      @sw_size: the size of the SW state associated with each ring element
507  *      @phys: the physical address of the allocated ring
508  *      @metadata: address of the array holding the SW state for the ring
509  *
510  *      Allocates resources for an SGE descriptor ring, such as Tx queues,
511  *      free buffer lists, or response queues.  Each SGE ring requires
512  *      space for its HW descriptors plus, optionally, space for the SW state
513  *      associated with each HW entry (the metadata).  The function returns
514  *      three values: the virtual address for the HW ring (the return value
515  *      of the function), the physical address of the HW ring, and the address
516  *      of the SW ring.
517  */
518 static void *alloc_ring(struct pci_dev *pdev, size_t nelem, size_t elem_size,
519                         size_t sw_size, dma_addr_t * phys, void *metadata)
520 {
521         size_t len = nelem * elem_size;
522         void *s = NULL;
523         void *p = dma_alloc_coherent(&pdev->dev, len, phys, GFP_KERNEL);
524
525         if (!p)
526                 return NULL;
527         if (sw_size) {
528                 s = kcalloc(nelem, sw_size, GFP_KERNEL);
529
530                 if (!s) {
531                         dma_free_coherent(&pdev->dev, len, p, *phys);
532                         return NULL;
533                 }
534         }
535         if (metadata)
536                 *(void **)metadata = s;
537         memset(p, 0, len);
538         return p;
539 }
540
541 /**
542  *      free_qset - free the resources of an SGE queue set
543  *      @adapter: the adapter owning the queue set
544  *      @q: the queue set
545  *
546  *      Release the HW and SW resources associated with an SGE queue set, such
547  *      as HW contexts, packet buffers, and descriptor rings.  Traffic to the
548  *      queue set must be quiesced prior to calling this.
549  */
550 static void t3_free_qset(struct adapter *adapter, struct sge_qset *q)
551 {
552         int i;
553         struct pci_dev *pdev = adapter->pdev;
554
555         if (q->tx_reclaim_timer.function)
556                 del_timer_sync(&q->tx_reclaim_timer);
557
558         for (i = 0; i < SGE_RXQ_PER_SET; ++i)
559                 if (q->fl[i].desc) {
560                         spin_lock(&adapter->sge.reg_lock);
561                         t3_sge_disable_fl(adapter, q->fl[i].cntxt_id);
562                         spin_unlock(&adapter->sge.reg_lock);
563                         free_rx_bufs(pdev, &q->fl[i]);
564                         kfree(q->fl[i].sdesc);
565                         dma_free_coherent(&pdev->dev,
566                                           q->fl[i].size *
567                                           sizeof(struct rx_desc), q->fl[i].desc,
568                                           q->fl[i].phys_addr);
569                 }
570
571         for (i = 0; i < SGE_TXQ_PER_SET; ++i)
572                 if (q->txq[i].desc) {
573                         spin_lock(&adapter->sge.reg_lock);
574                         t3_sge_enable_ecntxt(adapter, q->txq[i].cntxt_id, 0);
575                         spin_unlock(&adapter->sge.reg_lock);
576                         if (q->txq[i].sdesc) {
577                                 free_tx_desc(adapter, &q->txq[i],
578                                              q->txq[i].in_use);
579                                 kfree(q->txq[i].sdesc);
580                         }
581                         dma_free_coherent(&pdev->dev,
582                                           q->txq[i].size *
583                                           sizeof(struct tx_desc),
584                                           q->txq[i].desc, q->txq[i].phys_addr);
585                         __skb_queue_purge(&q->txq[i].sendq);
586                 }
587
588         if (q->rspq.desc) {
589                 spin_lock(&adapter->sge.reg_lock);
590                 t3_sge_disable_rspcntxt(adapter, q->rspq.cntxt_id);
591                 spin_unlock(&adapter->sge.reg_lock);
592                 dma_free_coherent(&pdev->dev,
593                                   q->rspq.size * sizeof(struct rsp_desc),
594                                   q->rspq.desc, q->rspq.phys_addr);
595         }
596
597         memset(q, 0, sizeof(*q));
598 }
599
600 /**
601  *      init_qset_cntxt - initialize an SGE queue set context info
602  *      @qs: the queue set
603  *      @id: the queue set id
604  *
605  *      Initializes the TIDs and context ids for the queues of a queue set.
606  */
607 static void init_qset_cntxt(struct sge_qset *qs, unsigned int id)
608 {
609         qs->rspq.cntxt_id = id;
610         qs->fl[0].cntxt_id = 2 * id;
611         qs->fl[1].cntxt_id = 2 * id + 1;
612         qs->txq[TXQ_ETH].cntxt_id = FW_TUNNEL_SGEEC_START + id;
613         qs->txq[TXQ_ETH].token = FW_TUNNEL_TID_START + id;
614         qs->txq[TXQ_OFLD].cntxt_id = FW_OFLD_SGEEC_START + id;
615         qs->txq[TXQ_CTRL].cntxt_id = FW_CTRL_SGEEC_START + id;
616         qs->txq[TXQ_CTRL].token = FW_CTRL_TID_START + id;
617 }
618
619 /**
620  *      sgl_len - calculates the size of an SGL of the given capacity
621  *      @n: the number of SGL entries
622  *
623  *      Calculates the number of flits needed for a scatter/gather list that
624  *      can hold the given number of entries.
625  */
626 static inline unsigned int sgl_len(unsigned int n)
627 {
628         /* alternatively: 3 * (n / 2) + 2 * (n & 1) */
629         return (3 * n) / 2 + (n & 1);
630 }
631
632 /**
633  *      flits_to_desc - returns the num of Tx descriptors for the given flits
634  *      @n: the number of flits
635  *
636  *      Calculates the number of Tx descriptors needed for the supplied number
637  *      of flits.
638  */
639 static inline unsigned int flits_to_desc(unsigned int n)
640 {
641         BUG_ON(n >= ARRAY_SIZE(flit_desc_map));
642         return flit_desc_map[n];
643 }
644
645 /**
646  *      get_packet - return the next ingress packet buffer from a free list
647  *      @adap: the adapter that received the packet
648  *      @fl: the SGE free list holding the packet
649  *      @len: the packet length including any SGE padding
650  *      @drop_thres: # of remaining buffers before we start dropping packets
651  *
652  *      Get the next packet from a free list and complete setup of the
653  *      sk_buff.  If the packet is small we make a copy and recycle the
654  *      original buffer, otherwise we use the original buffer itself.  If a
655  *      positive drop threshold is supplied packets are dropped and their
656  *      buffers recycled if (a) the number of remaining buffers is under the
657  *      threshold and the packet is too big to copy, or (b) the packet should
658  *      be copied but there is no memory for the copy.
659  */
660 static struct sk_buff *get_packet(struct adapter *adap, struct sge_fl *fl,
661                                   unsigned int len, unsigned int drop_thres)
662 {
663         struct sk_buff *skb = NULL;
664         struct rx_sw_desc *sd = &fl->sdesc[fl->cidx];
665
666         prefetch(sd->skb->data);
667         fl->credits--;
668
669         if (len <= SGE_RX_COPY_THRES) {
670                 skb = alloc_skb(len, GFP_ATOMIC);
671                 if (likely(skb != NULL)) {
672                         __skb_put(skb, len);
673                         pci_dma_sync_single_for_cpu(adap->pdev,
674                                             pci_unmap_addr(sd, dma_addr), len,
675                                             PCI_DMA_FROMDEVICE);
676                         memcpy(skb->data, sd->skb->data, len);
677                         pci_dma_sync_single_for_device(adap->pdev,
678                                             pci_unmap_addr(sd, dma_addr), len,
679                                             PCI_DMA_FROMDEVICE);
680                 } else if (!drop_thres)
681                         goto use_orig_buf;
682 recycle:
683                 recycle_rx_buf(adap, fl, fl->cidx);
684                 return skb;
685         }
686
687         if (unlikely(fl->credits < drop_thres))
688                 goto recycle;
689
690 use_orig_buf:
691         pci_unmap_single(adap->pdev, pci_unmap_addr(sd, dma_addr),
692                          fl->buf_size, PCI_DMA_FROMDEVICE);
693         skb = sd->skb;
694         skb_put(skb, len);
695         __refill_fl(adap, fl);
696         return skb;
697 }
698
699 /**
700  *      get_packet_pg - return the next ingress packet buffer from a free list
701  *      @adap: the adapter that received the packet
702  *      @fl: the SGE free list holding the packet
703  *      @len: the packet length including any SGE padding
704  *      @drop_thres: # of remaining buffers before we start dropping packets
705  *
706  *      Get the next packet from a free list populated with page chunks.
707  *      If the packet is small we make a copy and recycle the original buffer,
708  *      otherwise we attach the original buffer as a page fragment to a fresh
709  *      sk_buff.  If a positive drop threshold is supplied packets are dropped
710  *      and their buffers recycled if (a) the number of remaining buffers is
711  *      under the threshold and the packet is too big to copy, or (b) there's
712  *      no system memory.
713  *
714  *      Note: this function is similar to @get_packet but deals with Rx buffers
715  *      that are page chunks rather than sk_buffs.
716  */
717 static struct sk_buff *get_packet_pg(struct adapter *adap, struct sge_fl *fl,
718                                      unsigned int len, unsigned int drop_thres)
719 {
720         struct sk_buff *skb = NULL;
721         struct rx_sw_desc *sd = &fl->sdesc[fl->cidx];
722
723         if (len <= SGE_RX_COPY_THRES) {
724                 skb = alloc_skb(len, GFP_ATOMIC);
725                 if (likely(skb != NULL)) {
726                         __skb_put(skb, len);
727                         pci_dma_sync_single_for_cpu(adap->pdev,
728                                             pci_unmap_addr(sd, dma_addr), len,
729                                             PCI_DMA_FROMDEVICE);
730                         memcpy(skb->data, sd->pg_chunk.va, len);
731                         pci_dma_sync_single_for_device(adap->pdev,
732                                             pci_unmap_addr(sd, dma_addr), len,
733                                             PCI_DMA_FROMDEVICE);
734                 } else if (!drop_thres)
735                         return NULL;
736 recycle:
737                 fl->credits--;
738                 recycle_rx_buf(adap, fl, fl->cidx);
739                 return skb;
740         }
741
742         if (unlikely(fl->credits <= drop_thres))
743                 goto recycle;
744
745         skb = alloc_skb(SGE_RX_PULL_LEN, GFP_ATOMIC);
746         if (unlikely(!skb)) {
747                 if (!drop_thres)
748                         return NULL;
749                 goto recycle;
750         }
751
752         pci_unmap_single(adap->pdev, pci_unmap_addr(sd, dma_addr),
753                          fl->buf_size, PCI_DMA_FROMDEVICE);
754         __skb_put(skb, SGE_RX_PULL_LEN);
755         memcpy(skb->data, sd->pg_chunk.va, SGE_RX_PULL_LEN);
756         skb_fill_page_desc(skb, 0, sd->pg_chunk.page,
757                            sd->pg_chunk.offset + SGE_RX_PULL_LEN,
758                            len - SGE_RX_PULL_LEN);
759         skb->len = len;
760         skb->data_len = len - SGE_RX_PULL_LEN;
761         skb->truesize += skb->data_len;
762
763         fl->credits--;
764         /*
765          * We do not refill FLs here, we let the caller do it to overlap a
766          * prefetch.
767          */
768         return skb;
769 }
770
771 /**
772  *      get_imm_packet - return the next ingress packet buffer from a response
773  *      @resp: the response descriptor containing the packet data
774  *
775  *      Return a packet containing the immediate data of the given response.
776  */
777 static inline struct sk_buff *get_imm_packet(const struct rsp_desc *resp)
778 {
779         struct sk_buff *skb = alloc_skb(IMMED_PKT_SIZE, GFP_ATOMIC);
780
781         if (skb) {
782                 __skb_put(skb, IMMED_PKT_SIZE);
783                 skb_copy_to_linear_data(skb, resp->imm_data, IMMED_PKT_SIZE);
784         }
785         return skb;
786 }
787
788 /**
789  *      calc_tx_descs - calculate the number of Tx descriptors for a packet
790  *      @skb: the packet
791  *
792  *      Returns the number of Tx descriptors needed for the given Ethernet
793  *      packet.  Ethernet packets require addition of WR and CPL headers.
794  */
795 static inline unsigned int calc_tx_descs(const struct sk_buff *skb)
796 {
797         unsigned int flits;
798
799         if (skb->len <= WR_LEN - sizeof(struct cpl_tx_pkt))
800                 return 1;
801
802         flits = sgl_len(skb_shinfo(skb)->nr_frags + 1) + 2;
803         if (skb_shinfo(skb)->gso_size)
804                 flits++;
805         return flits_to_desc(flits);
806 }
807
808 /**
809  *      make_sgl - populate a scatter/gather list for a packet
810  *      @skb: the packet
811  *      @sgp: the SGL to populate
812  *      @start: start address of skb main body data to include in the SGL
813  *      @len: length of skb main body data to include in the SGL
814  *      @pdev: the PCI device
815  *
816  *      Generates a scatter/gather list for the buffers that make up a packet
817  *      and returns the SGL size in 8-byte words.  The caller must size the SGL
818  *      appropriately.
819  */
820 static inline unsigned int make_sgl(const struct sk_buff *skb,
821                                     struct sg_ent *sgp, unsigned char *start,
822                                     unsigned int len, struct pci_dev *pdev)
823 {
824         dma_addr_t mapping;
825         unsigned int i, j = 0, nfrags;
826
827         if (len) {
828                 mapping = pci_map_single(pdev, start, len, PCI_DMA_TODEVICE);
829                 sgp->len[0] = cpu_to_be32(len);
830                 sgp->addr[0] = cpu_to_be64(mapping);
831                 j = 1;
832         }
833
834         nfrags = skb_shinfo(skb)->nr_frags;
835         for (i = 0; i < nfrags; i++) {
836                 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
837
838                 mapping = pci_map_page(pdev, frag->page, frag->page_offset,
839                                        frag->size, PCI_DMA_TODEVICE);
840                 sgp->len[j] = cpu_to_be32(frag->size);
841                 sgp->addr[j] = cpu_to_be64(mapping);
842                 j ^= 1;
843                 if (j == 0)
844                         ++sgp;
845         }
846         if (j)
847                 sgp->len[j] = 0;
848         return ((nfrags + (len != 0)) * 3) / 2 + j;
849 }
850
851 /**
852  *      check_ring_tx_db - check and potentially ring a Tx queue's doorbell
853  *      @adap: the adapter
854  *      @q: the Tx queue
855  *
856  *      Ring the doorbel if a Tx queue is asleep.  There is a natural race,
857  *      where the HW is going to sleep just after we checked, however,
858  *      then the interrupt handler will detect the outstanding TX packet
859  *      and ring the doorbell for us.
860  *
861  *      When GTS is disabled we unconditionally ring the doorbell.
862  */
863 static inline void check_ring_tx_db(struct adapter *adap, struct sge_txq *q)
864 {
865 #if USE_GTS
866         clear_bit(TXQ_LAST_PKT_DB, &q->flags);
867         if (test_and_set_bit(TXQ_RUNNING, &q->flags) == 0) {
868                 set_bit(TXQ_LAST_PKT_DB, &q->flags);
869                 t3_write_reg(adap, A_SG_KDOORBELL,
870                              F_SELEGRCNTX | V_EGRCNTX(q->cntxt_id));
871         }
872 #else
873         wmb();                  /* write descriptors before telling HW */
874         t3_write_reg(adap, A_SG_KDOORBELL,
875                      F_SELEGRCNTX | V_EGRCNTX(q->cntxt_id));
876 #endif
877 }
878
879 static inline void wr_gen2(struct tx_desc *d, unsigned int gen)
880 {
881 #if SGE_NUM_GENBITS == 2
882         d->flit[TX_DESC_FLITS - 1] = cpu_to_be64(gen);
883 #endif
884 }
885
886 /**
887  *      write_wr_hdr_sgl - write a WR header and, optionally, SGL
888  *      @ndesc: number of Tx descriptors spanned by the SGL
889  *      @skb: the packet corresponding to the WR
890  *      @d: first Tx descriptor to be written
891  *      @pidx: index of above descriptors
892  *      @q: the SGE Tx queue
893  *      @sgl: the SGL
894  *      @flits: number of flits to the start of the SGL in the first descriptor
895  *      @sgl_flits: the SGL size in flits
896  *      @gen: the Tx descriptor generation
897  *      @wr_hi: top 32 bits of WR header based on WR type (big endian)
898  *      @wr_lo: low 32 bits of WR header based on WR type (big endian)
899  *
900  *      Write a work request header and an associated SGL.  If the SGL is
901  *      small enough to fit into one Tx descriptor it has already been written
902  *      and we just need to write the WR header.  Otherwise we distribute the
903  *      SGL across the number of descriptors it spans.
904  */
905 static void write_wr_hdr_sgl(unsigned int ndesc, struct sk_buff *skb,
906                              struct tx_desc *d, unsigned int pidx,
907                              const struct sge_txq *q,
908                              const struct sg_ent *sgl,
909                              unsigned int flits, unsigned int sgl_flits,
910                              unsigned int gen, __be32 wr_hi,
911                              __be32 wr_lo)
912 {
913         struct work_request_hdr *wrp = (struct work_request_hdr *)d;
914         struct tx_sw_desc *sd = &q->sdesc[pidx];
915
916         sd->skb = skb;
917         if (need_skb_unmap()) {
918                 sd->fragidx = 0;
919                 sd->addr_idx = 0;
920                 sd->sflit = flits;
921         }
922
923         if (likely(ndesc == 1)) {
924                 sd->eop = 1;
925                 wrp->wr_hi = htonl(F_WR_SOP | F_WR_EOP | V_WR_DATATYPE(1) |
926                                    V_WR_SGLSFLT(flits)) | wr_hi;
927                 wmb();
928                 wrp->wr_lo = htonl(V_WR_LEN(flits + sgl_flits) |
929                                    V_WR_GEN(gen)) | wr_lo;
930                 wr_gen2(d, gen);
931         } else {
932                 unsigned int ogen = gen;
933                 const u64 *fp = (const u64 *)sgl;
934                 struct work_request_hdr *wp = wrp;
935
936                 wrp->wr_hi = htonl(F_WR_SOP | V_WR_DATATYPE(1) |
937                                    V_WR_SGLSFLT(flits)) | wr_hi;
938
939                 while (sgl_flits) {
940                         unsigned int avail = WR_FLITS - flits;
941
942                         if (avail > sgl_flits)
943                                 avail = sgl_flits;
944                         memcpy(&d->flit[flits], fp, avail * sizeof(*fp));
945                         sgl_flits -= avail;
946                         ndesc--;
947                         if (!sgl_flits)
948                                 break;
949
950                         fp += avail;
951                         d++;
952                         sd->eop = 0;
953                         sd++;
954                         if (++pidx == q->size) {
955                                 pidx = 0;
956                                 gen ^= 1;
957                                 d = q->desc;
958                                 sd = q->sdesc;
959                         }
960
961                         sd->skb = skb;
962                         wrp = (struct work_request_hdr *)d;
963                         wrp->wr_hi = htonl(V_WR_DATATYPE(1) |
964                                            V_WR_SGLSFLT(1)) | wr_hi;
965                         wrp->wr_lo = htonl(V_WR_LEN(min(WR_FLITS,
966                                                         sgl_flits + 1)) |
967                                            V_WR_GEN(gen)) | wr_lo;
968                         wr_gen2(d, gen);
969                         flits = 1;
970                 }
971                 sd->eop = 1;
972                 wrp->wr_hi |= htonl(F_WR_EOP);
973                 wmb();
974                 wp->wr_lo = htonl(V_WR_LEN(WR_FLITS) | V_WR_GEN(ogen)) | wr_lo;
975                 wr_gen2((struct tx_desc *)wp, ogen);
976                 WARN_ON(ndesc != 0);
977         }
978 }
979
980 /**
981  *      write_tx_pkt_wr - write a TX_PKT work request
982  *      @adap: the adapter
983  *      @skb: the packet to send
984  *      @pi: the egress interface
985  *      @pidx: index of the first Tx descriptor to write
986  *      @gen: the generation value to use
987  *      @q: the Tx queue
988  *      @ndesc: number of descriptors the packet will occupy
989  *      @compl: the value of the COMPL bit to use
990  *
991  *      Generate a TX_PKT work request to send the supplied packet.
992  */
993 static void write_tx_pkt_wr(struct adapter *adap, struct sk_buff *skb,
994                             const struct port_info *pi,
995                             unsigned int pidx, unsigned int gen,
996                             struct sge_txq *q, unsigned int ndesc,
997                             unsigned int compl)
998 {
999         unsigned int flits, sgl_flits, cntrl, tso_info;
1000         struct sg_ent *sgp, sgl[MAX_SKB_FRAGS / 2 + 1];
1001         struct tx_desc *d = &q->desc[pidx];
1002         struct cpl_tx_pkt *cpl = (struct cpl_tx_pkt *)d;
1003
1004         cpl->len = htonl(skb->len | 0x80000000);
1005         cntrl = V_TXPKT_INTF(pi->port_id);
1006
1007         if (vlan_tx_tag_present(skb) && pi->vlan_grp)
1008                 cntrl |= F_TXPKT_VLAN_VLD | V_TXPKT_VLAN(vlan_tx_tag_get(skb));
1009
1010         tso_info = V_LSO_MSS(skb_shinfo(skb)->gso_size);
1011         if (tso_info) {
1012                 int eth_type;
1013                 struct cpl_tx_pkt_lso *hdr = (struct cpl_tx_pkt_lso *)cpl;
1014
1015                 d->flit[2] = 0;
1016                 cntrl |= V_TXPKT_OPCODE(CPL_TX_PKT_LSO);
1017                 hdr->cntrl = htonl(cntrl);
1018                 eth_type = skb_network_offset(skb) == ETH_HLEN ?
1019                     CPL_ETH_II : CPL_ETH_II_VLAN;
1020                 tso_info |= V_LSO_ETH_TYPE(eth_type) |
1021                     V_LSO_IPHDR_WORDS(ip_hdr(skb)->ihl) |
1022                     V_LSO_TCPHDR_WORDS(tcp_hdr(skb)->doff);
1023                 hdr->lso_info = htonl(tso_info);
1024                 flits = 3;
1025         } else {
1026                 cntrl |= V_TXPKT_OPCODE(CPL_TX_PKT);
1027                 cntrl |= F_TXPKT_IPCSUM_DIS;    /* SW calculates IP csum */
1028                 cntrl |= V_TXPKT_L4CSUM_DIS(skb->ip_summed != CHECKSUM_PARTIAL);
1029                 cpl->cntrl = htonl(cntrl);
1030
1031                 if (skb->len <= WR_LEN - sizeof(*cpl)) {
1032                         q->sdesc[pidx].skb = NULL;
1033                         if (!skb->data_len)
1034                                 skb_copy_from_linear_data(skb, &d->flit[2],
1035                                                           skb->len);
1036                         else
1037                                 skb_copy_bits(skb, 0, &d->flit[2], skb->len);
1038
1039                         flits = (skb->len + 7) / 8 + 2;
1040                         cpl->wr.wr_hi = htonl(V_WR_BCNTLFLT(skb->len & 7) |
1041                                               V_WR_OP(FW_WROPCODE_TUNNEL_TX_PKT)
1042                                               | F_WR_SOP | F_WR_EOP | compl);
1043                         wmb();
1044                         cpl->wr.wr_lo = htonl(V_WR_LEN(flits) | V_WR_GEN(gen) |
1045                                               V_WR_TID(q->token));
1046                         wr_gen2(d, gen);
1047                         kfree_skb(skb);
1048                         return;
1049                 }
1050
1051                 flits = 2;
1052         }
1053
1054         sgp = ndesc == 1 ? (struct sg_ent *)&d->flit[flits] : sgl;
1055         sgl_flits = make_sgl(skb, sgp, skb->data, skb_headlen(skb), adap->pdev);
1056
1057         write_wr_hdr_sgl(ndesc, skb, d, pidx, q, sgl, flits, sgl_flits, gen,
1058                          htonl(V_WR_OP(FW_WROPCODE_TUNNEL_TX_PKT) | compl),
1059                          htonl(V_WR_TID(q->token)));
1060 }
1061
1062 /**
1063  *      eth_xmit - add a packet to the Ethernet Tx queue
1064  *      @skb: the packet
1065  *      @dev: the egress net device
1066  *
1067  *      Add a packet to an SGE Tx queue.  Runs with softirqs disabled.
1068  */
1069 int t3_eth_xmit(struct sk_buff *skb, struct net_device *dev)
1070 {
1071         unsigned int ndesc, pidx, credits, gen, compl;
1072         const struct port_info *pi = netdev_priv(dev);
1073         struct adapter *adap = pi->adapter;
1074         struct sge_qset *qs = pi->qs;
1075         struct sge_txq *q = &qs->txq[TXQ_ETH];
1076
1077         /*
1078          * The chip min packet length is 9 octets but play safe and reject
1079          * anything shorter than an Ethernet header.
1080          */
1081         if (unlikely(skb->len < ETH_HLEN)) {
1082                 dev_kfree_skb(skb);
1083                 return NETDEV_TX_OK;
1084         }
1085
1086         spin_lock(&q->lock);
1087         reclaim_completed_tx(adap, q);
1088
1089         credits = q->size - q->in_use;
1090         ndesc = calc_tx_descs(skb);
1091
1092         if (unlikely(credits < ndesc)) {
1093                 if (!netif_queue_stopped(dev)) {
1094                         netif_stop_queue(dev);
1095                         set_bit(TXQ_ETH, &qs->txq_stopped);
1096                         q->stops++;
1097                         dev_err(&adap->pdev->dev,
1098                                 "%s: Tx ring %u full while queue awake!\n",
1099                                 dev->name, q->cntxt_id & 7);
1100                 }
1101                 spin_unlock(&q->lock);
1102                 return NETDEV_TX_BUSY;
1103         }
1104
1105         q->in_use += ndesc;
1106         if (unlikely(credits - ndesc < q->stop_thres)) {
1107                 q->stops++;
1108                 netif_stop_queue(dev);
1109                 set_bit(TXQ_ETH, &qs->txq_stopped);
1110 #if !USE_GTS
1111                 if (should_restart_tx(q) &&
1112                     test_and_clear_bit(TXQ_ETH, &qs->txq_stopped)) {
1113                         q->restarts++;
1114                         netif_wake_queue(dev);
1115                 }
1116 #endif
1117         }
1118
1119         gen = q->gen;
1120         q->unacked += ndesc;
1121         compl = (q->unacked & 8) << (S_WR_COMPL - 3);
1122         q->unacked &= 7;
1123         pidx = q->pidx;
1124         q->pidx += ndesc;
1125         if (q->pidx >= q->size) {
1126                 q->pidx -= q->size;
1127                 q->gen ^= 1;
1128         }
1129
1130         /* update port statistics */
1131         if (skb->ip_summed == CHECKSUM_COMPLETE)
1132                 qs->port_stats[SGE_PSTAT_TX_CSUM]++;
1133         if (skb_shinfo(skb)->gso_size)
1134                 qs->port_stats[SGE_PSTAT_TSO]++;
1135         if (vlan_tx_tag_present(skb) && pi->vlan_grp)
1136                 qs->port_stats[SGE_PSTAT_VLANINS]++;
1137
1138         dev->trans_start = jiffies;
1139         spin_unlock(&q->lock);
1140
1141         /*
1142          * We do not use Tx completion interrupts to free DMAd Tx packets.
1143          * This is good for performamce but means that we rely on new Tx
1144          * packets arriving to run the destructors of completed packets,
1145          * which open up space in their sockets' send queues.  Sometimes
1146          * we do not get such new packets causing Tx to stall.  A single
1147          * UDP transmitter is a good example of this situation.  We have
1148          * a clean up timer that periodically reclaims completed packets
1149          * but it doesn't run often enough (nor do we want it to) to prevent
1150          * lengthy stalls.  A solution to this problem is to run the
1151          * destructor early, after the packet is queued but before it's DMAd.
1152          * A cons is that we lie to socket memory accounting, but the amount
1153          * of extra memory is reasonable (limited by the number of Tx
1154          * descriptors), the packets do actually get freed quickly by new
1155          * packets almost always, and for protocols like TCP that wait for
1156          * acks to really free up the data the extra memory is even less.
1157          * On the positive side we run the destructors on the sending CPU
1158          * rather than on a potentially different completing CPU, usually a
1159          * good thing.  We also run them without holding our Tx queue lock,
1160          * unlike what reclaim_completed_tx() would otherwise do.
1161          *
1162          * Run the destructor before telling the DMA engine about the packet
1163          * to make sure it doesn't complete and get freed prematurely.
1164          */
1165         if (likely(!skb_shared(skb)))
1166                 skb_orphan(skb);
1167
1168         write_tx_pkt_wr(adap, skb, pi, pidx, gen, q, ndesc, compl);
1169         check_ring_tx_db(adap, q);
1170         return NETDEV_TX_OK;
1171 }
1172
1173 /**
1174  *      write_imm - write a packet into a Tx descriptor as immediate data
1175  *      @d: the Tx descriptor to write
1176  *      @skb: the packet
1177  *      @len: the length of packet data to write as immediate data
1178  *      @gen: the generation bit value to write
1179  *
1180  *      Writes a packet as immediate data into a Tx descriptor.  The packet
1181  *      contains a work request at its beginning.  We must write the packet
1182  *      carefully so the SGE doesn't read it accidentally before it's written
1183  *      in its entirety.
1184  */
1185 static inline void write_imm(struct tx_desc *d, struct sk_buff *skb,
1186                              unsigned int len, unsigned int gen)
1187 {
1188         struct work_request_hdr *from = (struct work_request_hdr *)skb->data;
1189         struct work_request_hdr *to = (struct work_request_hdr *)d;
1190
1191         if (likely(!skb->data_len))
1192                 memcpy(&to[1], &from[1], len - sizeof(*from));
1193         else
1194                 skb_copy_bits(skb, sizeof(*from), &to[1], len - sizeof(*from));
1195
1196         to->wr_hi = from->wr_hi | htonl(F_WR_SOP | F_WR_EOP |
1197                                         V_WR_BCNTLFLT(len & 7));
1198         wmb();
1199         to->wr_lo = from->wr_lo | htonl(V_WR_GEN(gen) |
1200                                         V_WR_LEN((len + 7) / 8));
1201         wr_gen2(d, gen);
1202         kfree_skb(skb);
1203 }
1204
1205 /**
1206  *      check_desc_avail - check descriptor availability on a send queue
1207  *      @adap: the adapter
1208  *      @q: the send queue
1209  *      @skb: the packet needing the descriptors
1210  *      @ndesc: the number of Tx descriptors needed
1211  *      @qid: the Tx queue number in its queue set (TXQ_OFLD or TXQ_CTRL)
1212  *
1213  *      Checks if the requested number of Tx descriptors is available on an
1214  *      SGE send queue.  If the queue is already suspended or not enough
1215  *      descriptors are available the packet is queued for later transmission.
1216  *      Must be called with the Tx queue locked.
1217  *
1218  *      Returns 0 if enough descriptors are available, 1 if there aren't
1219  *      enough descriptors and the packet has been queued, and 2 if the caller
1220  *      needs to retry because there weren't enough descriptors at the
1221  *      beginning of the call but some freed up in the mean time.
1222  */
1223 static inline int check_desc_avail(struct adapter *adap, struct sge_txq *q,
1224                                    struct sk_buff *skb, unsigned int ndesc,
1225                                    unsigned int qid)
1226 {
1227         if (unlikely(!skb_queue_empty(&q->sendq))) {
1228               addq_exit:__skb_queue_tail(&q->sendq, skb);
1229                 return 1;
1230         }
1231         if (unlikely(q->size - q->in_use < ndesc)) {
1232                 struct sge_qset *qs = txq_to_qset(q, qid);
1233
1234                 set_bit(qid, &qs->txq_stopped);
1235                 smp_mb__after_clear_bit();
1236
1237                 if (should_restart_tx(q) &&
1238                     test_and_clear_bit(qid, &qs->txq_stopped))
1239                         return 2;
1240
1241                 q->stops++;
1242                 goto addq_exit;
1243         }
1244         return 0;
1245 }
1246
1247 /**
1248  *      reclaim_completed_tx_imm - reclaim completed control-queue Tx descs
1249  *      @q: the SGE control Tx queue
1250  *
1251  *      This is a variant of reclaim_completed_tx() that is used for Tx queues
1252  *      that send only immediate data (presently just the control queues) and
1253  *      thus do not have any sk_buffs to release.
1254  */
1255 static inline void reclaim_completed_tx_imm(struct sge_txq *q)
1256 {
1257         unsigned int reclaim = q->processed - q->cleaned;
1258
1259         q->in_use -= reclaim;
1260         q->cleaned += reclaim;
1261 }
1262
1263 static inline int immediate(const struct sk_buff *skb)
1264 {
1265         return skb->len <= WR_LEN;
1266 }
1267
1268 /**
1269  *      ctrl_xmit - send a packet through an SGE control Tx queue
1270  *      @adap: the adapter
1271  *      @q: the control queue
1272  *      @skb: the packet
1273  *
1274  *      Send a packet through an SGE control Tx queue.  Packets sent through
1275  *      a control queue must fit entirely as immediate data in a single Tx
1276  *      descriptor and have no page fragments.
1277  */
1278 static int ctrl_xmit(struct adapter *adap, struct sge_txq *q,
1279                      struct sk_buff *skb)
1280 {
1281         int ret;
1282         struct work_request_hdr *wrp = (struct work_request_hdr *)skb->data;
1283
1284         if (unlikely(!immediate(skb))) {
1285                 WARN_ON(1);
1286                 dev_kfree_skb(skb);
1287                 return NET_XMIT_SUCCESS;
1288         }
1289
1290         wrp->wr_hi |= htonl(F_WR_SOP | F_WR_EOP);
1291         wrp->wr_lo = htonl(V_WR_TID(q->token));
1292
1293         spin_lock(&q->lock);
1294       again:reclaim_completed_tx_imm(q);
1295
1296         ret = check_desc_avail(adap, q, skb, 1, TXQ_CTRL);
1297         if (unlikely(ret)) {
1298                 if (ret == 1) {
1299                         spin_unlock(&q->lock);
1300                         return NET_XMIT_CN;
1301                 }
1302                 goto again;
1303         }
1304
1305         write_imm(&q->desc[q->pidx], skb, skb->len, q->gen);
1306
1307         q->in_use++;
1308         if (++q->pidx >= q->size) {
1309                 q->pidx = 0;
1310                 q->gen ^= 1;
1311         }
1312         spin_unlock(&q->lock);
1313         wmb();
1314         t3_write_reg(adap, A_SG_KDOORBELL,
1315                      F_SELEGRCNTX | V_EGRCNTX(q->cntxt_id));
1316         return NET_XMIT_SUCCESS;
1317 }
1318
1319 /**
1320  *      restart_ctrlq - restart a suspended control queue
1321  *      @qs: the queue set cotaining the control queue
1322  *
1323  *      Resumes transmission on a suspended Tx control queue.
1324  */
1325 static void restart_ctrlq(unsigned long data)
1326 {
1327         struct sk_buff *skb;
1328         struct sge_qset *qs = (struct sge_qset *)data;
1329         struct sge_txq *q = &qs->txq[TXQ_CTRL];
1330
1331         spin_lock(&q->lock);
1332       again:reclaim_completed_tx_imm(q);
1333
1334         while (q->in_use < q->size &&
1335                (skb = __skb_dequeue(&q->sendq)) != NULL) {
1336
1337                 write_imm(&q->desc[q->pidx], skb, skb->len, q->gen);
1338
1339                 if (++q->pidx >= q->size) {
1340                         q->pidx = 0;
1341                         q->gen ^= 1;
1342                 }
1343                 q->in_use++;
1344         }
1345
1346         if (!skb_queue_empty(&q->sendq)) {
1347                 set_bit(TXQ_CTRL, &qs->txq_stopped);
1348                 smp_mb__after_clear_bit();
1349
1350                 if (should_restart_tx(q) &&
1351                     test_and_clear_bit(TXQ_CTRL, &qs->txq_stopped))
1352                         goto again;
1353                 q->stops++;
1354         }
1355
1356         spin_unlock(&q->lock);
1357         wmb();
1358         t3_write_reg(qs->adap, A_SG_KDOORBELL,
1359                      F_SELEGRCNTX | V_EGRCNTX(q->cntxt_id));
1360 }
1361
1362 /*
1363  * Send a management message through control queue 0
1364  */
1365 int t3_mgmt_tx(struct adapter *adap, struct sk_buff *skb)
1366 {
1367         int ret; 
1368         local_bh_disable();
1369         ret = ctrl_xmit(adap, &adap->sge.qs[0].txq[TXQ_CTRL], skb);
1370         local_bh_enable();
1371
1372         return ret;
1373 }
1374
1375 /**
1376  *      deferred_unmap_destructor - unmap a packet when it is freed
1377  *      @skb: the packet
1378  *
1379  *      This is the packet destructor used for Tx packets that need to remain
1380  *      mapped until they are freed rather than until their Tx descriptors are
1381  *      freed.
1382  */
1383 static void deferred_unmap_destructor(struct sk_buff *skb)
1384 {
1385         int i;
1386         const dma_addr_t *p;
1387         const struct skb_shared_info *si;
1388         const struct deferred_unmap_info *dui;
1389
1390         dui = (struct deferred_unmap_info *)skb->head;
1391         p = dui->addr;
1392
1393         if (skb->tail - skb->transport_header)
1394                 pci_unmap_single(dui->pdev, *p++,
1395                                  skb->tail - skb->transport_header,
1396                                  PCI_DMA_TODEVICE);
1397
1398         si = skb_shinfo(skb);
1399         for (i = 0; i < si->nr_frags; i++)
1400                 pci_unmap_page(dui->pdev, *p++, si->frags[i].size,
1401                                PCI_DMA_TODEVICE);
1402 }
1403
1404 static void setup_deferred_unmapping(struct sk_buff *skb, struct pci_dev *pdev,
1405                                      const struct sg_ent *sgl, int sgl_flits)
1406 {
1407         dma_addr_t *p;
1408         struct deferred_unmap_info *dui;
1409
1410         dui = (struct deferred_unmap_info *)skb->head;
1411         dui->pdev = pdev;
1412         for (p = dui->addr; sgl_flits >= 3; sgl++, sgl_flits -= 3) {
1413                 *p++ = be64_to_cpu(sgl->addr[0]);
1414                 *p++ = be64_to_cpu(sgl->addr[1]);
1415         }
1416         if (sgl_flits)
1417                 *p = be64_to_cpu(sgl->addr[0]);
1418 }
1419
1420 /**
1421  *      write_ofld_wr - write an offload work request
1422  *      @adap: the adapter
1423  *      @skb: the packet to send
1424  *      @q: the Tx queue
1425  *      @pidx: index of the first Tx descriptor to write
1426  *      @gen: the generation value to use
1427  *      @ndesc: number of descriptors the packet will occupy
1428  *
1429  *      Write an offload work request to send the supplied packet.  The packet
1430  *      data already carry the work request with most fields populated.
1431  */
1432 static void write_ofld_wr(struct adapter *adap, struct sk_buff *skb,
1433                           struct sge_txq *q, unsigned int pidx,
1434                           unsigned int gen, unsigned int ndesc)
1435 {
1436         unsigned int sgl_flits, flits;
1437         struct work_request_hdr *from;
1438         struct sg_ent *sgp, sgl[MAX_SKB_FRAGS / 2 + 1];
1439         struct tx_desc *d = &q->desc[pidx];
1440
1441         if (immediate(skb)) {
1442                 q->sdesc[pidx].skb = NULL;
1443                 write_imm(d, skb, skb->len, gen);
1444                 return;
1445         }
1446
1447         /* Only TX_DATA builds SGLs */
1448
1449         from = (struct work_request_hdr *)skb->data;
1450         memcpy(&d->flit[1], &from[1],
1451                skb_transport_offset(skb) - sizeof(*from));
1452
1453         flits = skb_transport_offset(skb) / 8;
1454         sgp = ndesc == 1 ? (struct sg_ent *)&d->flit[flits] : sgl;
1455         sgl_flits = make_sgl(skb, sgp, skb_transport_header(skb),
1456                              skb->tail - skb->transport_header,
1457                              adap->pdev);
1458         if (need_skb_unmap()) {
1459                 setup_deferred_unmapping(skb, adap->pdev, sgp, sgl_flits);
1460                 skb->destructor = deferred_unmap_destructor;
1461         }
1462
1463         write_wr_hdr_sgl(ndesc, skb, d, pidx, q, sgl, flits, sgl_flits,
1464                          gen, from->wr_hi, from->wr_lo);
1465 }
1466
1467 /**
1468  *      calc_tx_descs_ofld - calculate # of Tx descriptors for an offload packet
1469  *      @skb: the packet
1470  *
1471  *      Returns the number of Tx descriptors needed for the given offload
1472  *      packet.  These packets are already fully constructed.
1473  */
1474 static inline unsigned int calc_tx_descs_ofld(const struct sk_buff *skb)
1475 {
1476         unsigned int flits, cnt;
1477
1478         if (skb->len <= WR_LEN)
1479                 return 1;       /* packet fits as immediate data */
1480
1481         flits = skb_transport_offset(skb) / 8;  /* headers */
1482         cnt = skb_shinfo(skb)->nr_frags;
1483         if (skb->tail != skb->transport_header)
1484                 cnt++;
1485         return flits_to_desc(flits + sgl_len(cnt));
1486 }
1487
1488 /**
1489  *      ofld_xmit - send a packet through an offload queue
1490  *      @adap: the adapter
1491  *      @q: the Tx offload queue
1492  *      @skb: the packet
1493  *
1494  *      Send an offload packet through an SGE offload queue.
1495  */
1496 static int ofld_xmit(struct adapter *adap, struct sge_txq *q,
1497                      struct sk_buff *skb)
1498 {
1499         int ret;
1500         unsigned int ndesc = calc_tx_descs_ofld(skb), pidx, gen;
1501
1502         spin_lock(&q->lock);
1503       again:reclaim_completed_tx(adap, q);
1504
1505         ret = check_desc_avail(adap, q, skb, ndesc, TXQ_OFLD);
1506         if (unlikely(ret)) {
1507                 if (ret == 1) {
1508                         skb->priority = ndesc;  /* save for restart */
1509                         spin_unlock(&q->lock);
1510                         return NET_XMIT_CN;
1511                 }
1512                 goto again;
1513         }
1514
1515         gen = q->gen;
1516         q->in_use += ndesc;
1517         pidx = q->pidx;
1518         q->pidx += ndesc;
1519         if (q->pidx >= q->size) {
1520                 q->pidx -= q->size;
1521                 q->gen ^= 1;
1522         }
1523         spin_unlock(&q->lock);
1524
1525         write_ofld_wr(adap, skb, q, pidx, gen, ndesc);
1526         check_ring_tx_db(adap, q);
1527         return NET_XMIT_SUCCESS;
1528 }
1529
1530 /**
1531  *      restart_offloadq - restart a suspended offload queue
1532  *      @qs: the queue set cotaining the offload queue
1533  *
1534  *      Resumes transmission on a suspended Tx offload queue.
1535  */
1536 static void restart_offloadq(unsigned long data)
1537 {
1538         struct sk_buff *skb;
1539         struct sge_qset *qs = (struct sge_qset *)data;
1540         struct sge_txq *q = &qs->txq[TXQ_OFLD];
1541         const struct port_info *pi = netdev_priv(qs->netdev);
1542         struct adapter *adap = pi->adapter;
1543
1544         spin_lock(&q->lock);
1545       again:reclaim_completed_tx(adap, q);
1546
1547         while ((skb = skb_peek(&q->sendq)) != NULL) {
1548                 unsigned int gen, pidx;
1549                 unsigned int ndesc = skb->priority;
1550
1551                 if (unlikely(q->size - q->in_use < ndesc)) {
1552                         set_bit(TXQ_OFLD, &qs->txq_stopped);
1553                         smp_mb__after_clear_bit();
1554
1555                         if (should_restart_tx(q) &&
1556                             test_and_clear_bit(TXQ_OFLD, &qs->txq_stopped))
1557                                 goto again;
1558                         q->stops++;
1559                         break;
1560                 }
1561
1562                 gen = q->gen;
1563                 q->in_use += ndesc;
1564                 pidx = q->pidx;
1565                 q->pidx += ndesc;
1566                 if (q->pidx >= q->size) {
1567                         q->pidx -= q->size;
1568                         q->gen ^= 1;
1569                 }
1570                 __skb_unlink(skb, &q->sendq);
1571                 spin_unlock(&q->lock);
1572
1573                 write_ofld_wr(adap, skb, q, pidx, gen, ndesc);
1574                 spin_lock(&q->lock);
1575         }
1576         spin_unlock(&q->lock);
1577
1578 #if USE_GTS
1579         set_bit(TXQ_RUNNING, &q->flags);
1580         set_bit(TXQ_LAST_PKT_DB, &q->flags);
1581 #endif
1582         wmb();
1583         t3_write_reg(adap, A_SG_KDOORBELL,
1584                      F_SELEGRCNTX | V_EGRCNTX(q->cntxt_id));
1585 }
1586
1587 /**
1588  *      queue_set - return the queue set a packet should use
1589  *      @skb: the packet
1590  *
1591  *      Maps a packet to the SGE queue set it should use.  The desired queue
1592  *      set is carried in bits 1-3 in the packet's priority.
1593  */
1594 static inline int queue_set(const struct sk_buff *skb)
1595 {
1596         return skb->priority >> 1;
1597 }
1598
1599 /**
1600  *      is_ctrl_pkt - return whether an offload packet is a control packet
1601  *      @skb: the packet
1602  *
1603  *      Determines whether an offload packet should use an OFLD or a CTRL
1604  *      Tx queue.  This is indicated by bit 0 in the packet's priority.
1605  */
1606 static inline int is_ctrl_pkt(const struct sk_buff *skb)
1607 {
1608         return skb->priority & 1;
1609 }
1610
1611 /**
1612  *      t3_offload_tx - send an offload packet
1613  *      @tdev: the offload device to send to
1614  *      @skb: the packet
1615  *
1616  *      Sends an offload packet.  We use the packet priority to select the
1617  *      appropriate Tx queue as follows: bit 0 indicates whether the packet
1618  *      should be sent as regular or control, bits 1-3 select the queue set.
1619  */
1620 int t3_offload_tx(struct t3cdev *tdev, struct sk_buff *skb)
1621 {
1622         struct adapter *adap = tdev2adap(tdev);
1623         struct sge_qset *qs = &adap->sge.qs[queue_set(skb)];
1624
1625         if (unlikely(is_ctrl_pkt(skb)))
1626                 return ctrl_xmit(adap, &qs->txq[TXQ_CTRL], skb);
1627
1628         return ofld_xmit(adap, &qs->txq[TXQ_OFLD], skb);
1629 }
1630
1631 /**
1632  *      offload_enqueue - add an offload packet to an SGE offload receive queue
1633  *      @q: the SGE response queue
1634  *      @skb: the packet
1635  *
1636  *      Add a new offload packet to an SGE response queue's offload packet
1637  *      queue.  If the packet is the first on the queue it schedules the RX
1638  *      softirq to process the queue.
1639  */
1640 static inline void offload_enqueue(struct sge_rspq *q, struct sk_buff *skb)
1641 {
1642         skb->next = skb->prev = NULL;
1643         if (q->rx_tail)
1644                 q->rx_tail->next = skb;
1645         else {
1646                 struct sge_qset *qs = rspq_to_qset(q);
1647
1648                 napi_schedule(&qs->napi);
1649                 q->rx_head = skb;
1650         }
1651         q->rx_tail = skb;
1652 }
1653
1654 /**
1655  *      deliver_partial_bundle - deliver a (partial) bundle of Rx offload pkts
1656  *      @tdev: the offload device that will be receiving the packets
1657  *      @q: the SGE response queue that assembled the bundle
1658  *      @skbs: the partial bundle
1659  *      @n: the number of packets in the bundle
1660  *
1661  *      Delivers a (partial) bundle of Rx offload packets to an offload device.
1662  */
1663 static inline void deliver_partial_bundle(struct t3cdev *tdev,
1664                                           struct sge_rspq *q,
1665                                           struct sk_buff *skbs[], int n)
1666 {
1667         if (n) {
1668                 q->offload_bundles++;
1669                 tdev->recv(tdev, skbs, n);
1670         }
1671 }
1672
1673 /**
1674  *      ofld_poll - NAPI handler for offload packets in interrupt mode
1675  *      @dev: the network device doing the polling
1676  *      @budget: polling budget
1677  *
1678  *      The NAPI handler for offload packets when a response queue is serviced
1679  *      by the hard interrupt handler, i.e., when it's operating in non-polling
1680  *      mode.  Creates small packet batches and sends them through the offload
1681  *      receive handler.  Batches need to be of modest size as we do prefetches
1682  *      on the packets in each.
1683  */
1684 static int ofld_poll(struct napi_struct *napi, int budget)
1685 {
1686         struct sge_qset *qs = container_of(napi, struct sge_qset, napi);
1687         struct sge_rspq *q = &qs->rspq;
1688         struct adapter *adapter = qs->adap;
1689         int work_done = 0;
1690
1691         while (work_done < budget) {
1692                 struct sk_buff *head, *tail, *skbs[RX_BUNDLE_SIZE];
1693                 int ngathered;
1694
1695                 spin_lock_irq(&q->lock);
1696                 head = q->rx_head;
1697                 if (!head) {
1698                         napi_complete(napi);
1699                         spin_unlock_irq(&q->lock);
1700                         return work_done;
1701                 }
1702
1703                 tail = q->rx_tail;
1704                 q->rx_head = q->rx_tail = NULL;
1705                 spin_unlock_irq(&q->lock);
1706
1707                 for (ngathered = 0; work_done < budget && head; work_done++) {
1708                         prefetch(head->data);
1709                         skbs[ngathered] = head;
1710                         head = head->next;
1711                         skbs[ngathered]->next = NULL;
1712                         if (++ngathered == RX_BUNDLE_SIZE) {
1713                                 q->offload_bundles++;
1714                                 adapter->tdev.recv(&adapter->tdev, skbs,
1715                                                    ngathered);
1716                                 ngathered = 0;
1717                         }
1718                 }
1719                 if (head) {     /* splice remaining packets back onto Rx queue */
1720                         spin_lock_irq(&q->lock);
1721                         tail->next = q->rx_head;
1722                         if (!q->rx_head)
1723                                 q->rx_tail = tail;
1724                         q->rx_head = head;
1725                         spin_unlock_irq(&q->lock);
1726                 }
1727                 deliver_partial_bundle(&adapter->tdev, q, skbs, ngathered);
1728         }
1729
1730         return work_done;
1731 }
1732
1733 /**
1734  *      rx_offload - process a received offload packet
1735  *      @tdev: the offload device receiving the packet
1736  *      @rq: the response queue that received the packet
1737  *      @skb: the packet
1738  *      @rx_gather: a gather list of packets if we are building a bundle
1739  *      @gather_idx: index of the next available slot in the bundle
1740  *
1741  *      Process an ingress offload pakcet and add it to the offload ingress
1742  *      queue.  Returns the index of the next available slot in the bundle.
1743  */
1744 static inline int rx_offload(struct t3cdev *tdev, struct sge_rspq *rq,
1745                              struct sk_buff *skb, struct sk_buff *rx_gather[],
1746                              unsigned int gather_idx)
1747 {
1748         skb_reset_mac_header(skb);
1749         skb_reset_network_header(skb);
1750         skb_reset_transport_header(skb);
1751
1752         if (rq->polling) {
1753                 rx_gather[gather_idx++] = skb;
1754                 if (gather_idx == RX_BUNDLE_SIZE) {
1755                         tdev->recv(tdev, rx_gather, RX_BUNDLE_SIZE);
1756                         gather_idx = 0;
1757                         rq->offload_bundles++;
1758                 }
1759         } else
1760                 offload_enqueue(rq, skb);
1761
1762         return gather_idx;
1763 }
1764
1765 /**
1766  *      restart_tx - check whether to restart suspended Tx queues
1767  *      @qs: the queue set to resume
1768  *
1769  *      Restarts suspended Tx queues of an SGE queue set if they have enough
1770  *      free resources to resume operation.
1771  */
1772 static void restart_tx(struct sge_qset *qs)
1773 {
1774         if (test_bit(TXQ_ETH, &qs->txq_stopped) &&
1775             should_restart_tx(&qs->txq[TXQ_ETH]) &&
1776             test_and_clear_bit(TXQ_ETH, &qs->txq_stopped)) {
1777                 qs->txq[TXQ_ETH].restarts++;
1778                 if (netif_running(qs->netdev))
1779                         netif_wake_queue(qs->netdev);
1780         }
1781
1782         if (test_bit(TXQ_OFLD, &qs->txq_stopped) &&
1783             should_restart_tx(&qs->txq[TXQ_OFLD]) &&
1784             test_and_clear_bit(TXQ_OFLD, &qs->txq_stopped)) {
1785                 qs->txq[TXQ_OFLD].restarts++;
1786                 tasklet_schedule(&qs->txq[TXQ_OFLD].qresume_tsk);
1787         }
1788         if (test_bit(TXQ_CTRL, &qs->txq_stopped) &&
1789             should_restart_tx(&qs->txq[TXQ_CTRL]) &&
1790             test_and_clear_bit(TXQ_CTRL, &qs->txq_stopped)) {
1791                 qs->txq[TXQ_CTRL].restarts++;
1792                 tasklet_schedule(&qs->txq[TXQ_CTRL].qresume_tsk);
1793         }
1794 }
1795
1796 /**
1797  *      rx_eth - process an ingress ethernet packet
1798  *      @adap: the adapter
1799  *      @rq: the response queue that received the packet
1800  *      @skb: the packet
1801  *      @pad: amount of padding at the start of the buffer
1802  *
1803  *      Process an ingress ethernet pakcet and deliver it to the stack.
1804  *      The padding is 2 if the packet was delivered in an Rx buffer and 0
1805  *      if it was immediate data in a response.
1806  */
1807 static void rx_eth(struct adapter *adap, struct sge_rspq *rq,
1808                    struct sk_buff *skb, int pad)
1809 {
1810         struct cpl_rx_pkt *p = (struct cpl_rx_pkt *)(skb->data + pad);
1811         struct port_info *pi;
1812
1813         skb_pull(skb, sizeof(*p) + pad);
1814         skb->protocol = eth_type_trans(skb, adap->port[p->iff]);
1815         skb->dev->last_rx = jiffies;
1816         pi = netdev_priv(skb->dev);
1817         if (pi->rx_csum_offload && p->csum_valid && p->csum == 0xffff &&
1818             !p->fragment) {
1819                 rspq_to_qset(rq)->port_stats[SGE_PSTAT_RX_CSUM_GOOD]++;
1820                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1821         } else
1822                 skb->ip_summed = CHECKSUM_NONE;
1823
1824         if (unlikely(p->vlan_valid)) {
1825                 struct vlan_group *grp = pi->vlan_grp;
1826
1827                 rspq_to_qset(rq)->port_stats[SGE_PSTAT_VLANEX]++;
1828                 if (likely(grp))
1829                         __vlan_hwaccel_rx(skb, grp, ntohs(p->vlan),
1830                                           rq->polling);
1831                 else
1832                         dev_kfree_skb_any(skb);
1833         } else if (rq->polling)
1834                 netif_receive_skb(skb);
1835         else
1836                 netif_rx(skb);
1837 }
1838
1839 /**
1840  *      handle_rsp_cntrl_info - handles control information in a response
1841  *      @qs: the queue set corresponding to the response
1842  *      @flags: the response control flags
1843  *
1844  *      Handles the control information of an SGE response, such as GTS
1845  *      indications and completion credits for the queue set's Tx queues.
1846  *      HW coalesces credits, we don't do any extra SW coalescing.
1847  */
1848 static inline void handle_rsp_cntrl_info(struct sge_qset *qs, u32 flags)
1849 {
1850         unsigned int credits;
1851
1852 #if USE_GTS
1853         if (flags & F_RSPD_TXQ0_GTS)
1854                 clear_bit(TXQ_RUNNING, &qs->txq[TXQ_ETH].flags);
1855 #endif
1856
1857         credits = G_RSPD_TXQ0_CR(flags);
1858         if (credits)
1859                 qs->txq[TXQ_ETH].processed += credits;
1860
1861         credits = G_RSPD_TXQ2_CR(flags);
1862         if (credits)
1863                 qs->txq[TXQ_CTRL].processed += credits;
1864
1865 # if USE_GTS
1866         if (flags & F_RSPD_TXQ1_GTS)
1867                 clear_bit(TXQ_RUNNING, &qs->txq[TXQ_OFLD].flags);
1868 # endif
1869         credits = G_RSPD_TXQ1_CR(flags);
1870         if (credits)
1871                 qs->txq[TXQ_OFLD].processed += credits;
1872 }
1873
1874 /**
1875  *      check_ring_db - check if we need to ring any doorbells
1876  *      @adapter: the adapter
1877  *      @qs: the queue set whose Tx queues are to be examined
1878  *      @sleeping: indicates which Tx queue sent GTS
1879  *
1880  *      Checks if some of a queue set's Tx queues need to ring their doorbells
1881  *      to resume transmission after idling while they still have unprocessed
1882  *      descriptors.
1883  */
1884 static void check_ring_db(struct adapter *adap, struct sge_qset *qs,
1885                           unsigned int sleeping)
1886 {
1887         if (sleeping & F_RSPD_TXQ0_GTS) {
1888                 struct sge_txq *txq = &qs->txq[TXQ_ETH];
1889
1890                 if (txq->cleaned + txq->in_use != txq->processed &&
1891                     !test_and_set_bit(TXQ_LAST_PKT_DB, &txq->flags)) {
1892                         set_bit(TXQ_RUNNING, &txq->flags);
1893                         t3_write_reg(adap, A_SG_KDOORBELL, F_SELEGRCNTX |
1894                                      V_EGRCNTX(txq->cntxt_id));
1895                 }
1896         }
1897
1898         if (sleeping & F_RSPD_TXQ1_GTS) {
1899                 struct sge_txq *txq = &qs->txq[TXQ_OFLD];
1900
1901                 if (txq->cleaned + txq->in_use != txq->processed &&
1902                     !test_and_set_bit(TXQ_LAST_PKT_DB, &txq->flags)) {
1903                         set_bit(TXQ_RUNNING, &txq->flags);
1904                         t3_write_reg(adap, A_SG_KDOORBELL, F_SELEGRCNTX |
1905                                      V_EGRCNTX(txq->cntxt_id));
1906                 }
1907         }
1908 }
1909
1910 /**
1911  *      is_new_response - check if a response is newly written
1912  *      @r: the response descriptor
1913  *      @q: the response queue
1914  *
1915  *      Returns true if a response descriptor contains a yet unprocessed
1916  *      response.
1917  */
1918 static inline int is_new_response(const struct rsp_desc *r,
1919                                   const struct sge_rspq *q)
1920 {
1921         return (r->intr_gen & F_RSPD_GEN2) == q->gen;
1922 }
1923
1924 #define RSPD_GTS_MASK  (F_RSPD_TXQ0_GTS | F_RSPD_TXQ1_GTS)
1925 #define RSPD_CTRL_MASK (RSPD_GTS_MASK | \
1926                         V_RSPD_TXQ0_CR(M_RSPD_TXQ0_CR) | \
1927                         V_RSPD_TXQ1_CR(M_RSPD_TXQ1_CR) | \
1928                         V_RSPD_TXQ2_CR(M_RSPD_TXQ2_CR))
1929
1930 /* How long to delay the next interrupt in case of memory shortage, in 0.1us. */
1931 #define NOMEM_INTR_DELAY 2500
1932
1933 /**
1934  *      process_responses - process responses from an SGE response queue
1935  *      @adap: the adapter
1936  *      @qs: the queue set to which the response queue belongs
1937  *      @budget: how many responses can be processed in this round
1938  *
1939  *      Process responses from an SGE response queue up to the supplied budget.
1940  *      Responses include received packets as well as credits and other events
1941  *      for the queues that belong to the response queue's queue set.
1942  *      A negative budget is effectively unlimited.
1943  *
1944  *      Additionally choose the interrupt holdoff time for the next interrupt
1945  *      on this queue.  If the system is under memory shortage use a fairly
1946  *      long delay to help recovery.
1947  */
1948 static int process_responses(struct adapter *adap, struct sge_qset *qs,
1949                              int budget)
1950 {
1951         struct sge_rspq *q = &qs->rspq;
1952         struct rsp_desc *r = &q->desc[q->cidx];
1953         int budget_left = budget;
1954         unsigned int sleeping = 0;
1955         struct sk_buff *offload_skbs[RX_BUNDLE_SIZE];
1956         int ngathered = 0;
1957
1958         q->next_holdoff = q->holdoff_tmr;
1959
1960         while (likely(budget_left && is_new_response(r, q))) {
1961                 int eth, ethpad = 2;
1962                 struct sk_buff *skb = NULL;
1963                 u32 len, flags = ntohl(r->flags);
1964                 u32 rss_hi = *(const u32 *)r, rss_lo = r->rss_hdr.rss_hash_val;
1965
1966                 eth = r->rss_hdr.opcode == CPL_RX_PKT;
1967
1968                 if (unlikely(flags & F_RSPD_ASYNC_NOTIF)) {
1969                         skb = alloc_skb(AN_PKT_SIZE, GFP_ATOMIC);
1970                         if (!skb)
1971                                 goto no_mem;
1972
1973                         memcpy(__skb_put(skb, AN_PKT_SIZE), r, AN_PKT_SIZE);
1974                         skb->data[0] = CPL_ASYNC_NOTIF;
1975                         rss_hi = htonl(CPL_ASYNC_NOTIF << 24);
1976                         q->async_notif++;
1977                 } else if (flags & F_RSPD_IMM_DATA_VALID) {
1978                         skb = get_imm_packet(r);
1979                         if (unlikely(!skb)) {
1980 no_mem:
1981                                 q->next_holdoff = NOMEM_INTR_DELAY;
1982                                 q->nomem++;
1983                                 /* consume one credit since we tried */
1984                                 budget_left--;
1985                                 break;
1986                         }
1987                         q->imm_data++;
1988                         ethpad = 0;
1989                 } else if ((len = ntohl(r->len_cq)) != 0) {
1990                         struct sge_fl *fl;
1991
1992                         fl = (len & F_RSPD_FLQ) ? &qs->fl[1] : &qs->fl[0];
1993                         if (fl->use_pages) {
1994                                 void *addr = fl->sdesc[fl->cidx].pg_chunk.va;
1995
1996                                 prefetch(addr);
1997 #if L1_CACHE_BYTES < 128
1998                                 prefetch(addr + L1_CACHE_BYTES);
1999 #endif
2000                                 __refill_fl(adap, fl);
2001
2002                                 skb = get_packet_pg(adap, fl, G_RSPD_LEN(len),
2003                                                  eth ? SGE_RX_DROP_THRES : 0);
2004                         } else
2005                                 skb = get_packet(adap, fl, G_RSPD_LEN(len),
2006                                                  eth ? SGE_RX_DROP_THRES : 0);
2007                         if (unlikely(!skb)) {
2008                                 if (!eth)
2009                                         goto no_mem;
2010                                 q->rx_drops++;
2011                         } else if (unlikely(r->rss_hdr.opcode == CPL_TRACE_PKT))
2012                                 __skb_pull(skb, 2);
2013
2014                         if (++fl->cidx == fl->size)
2015                                 fl->cidx = 0;
2016                 } else
2017                         q->pure_rsps++;
2018
2019                 if (flags & RSPD_CTRL_MASK) {
2020                         sleeping |= flags & RSPD_GTS_MASK;
2021                         handle_rsp_cntrl_info(qs, flags);
2022                 }
2023
2024                 r++;
2025                 if (unlikely(++q->cidx == q->size)) {
2026                         q->cidx = 0;
2027                         q->gen ^= 1;
2028                         r = q->desc;
2029                 }
2030                 prefetch(r);
2031
2032                 if (++q->credits >= (q->size / 4)) {
2033                         refill_rspq(adap, q, q->credits);
2034                         q->credits = 0;
2035                 }
2036
2037                 if (likely(skb != NULL)) {
2038                         if (eth)
2039                                 rx_eth(adap, q, skb, ethpad);
2040                         else {
2041                                 q->offload_pkts++;
2042                                 /* Preserve the RSS info in csum & priority */
2043                                 skb->csum = rss_hi;
2044                                 skb->priority = rss_lo;
2045                                 ngathered = rx_offload(&adap->tdev, q, skb,
2046                                                        offload_skbs,
2047                                                        ngathered);
2048                         }
2049                 }
2050                 --budget_left;
2051         }
2052
2053         deliver_partial_bundle(&adap->tdev, q, offload_skbs, ngathered);
2054         if (sleeping)
2055                 check_ring_db(adap, qs, sleeping);
2056
2057         smp_mb();               /* commit Tx queue .processed updates */
2058         if (unlikely(qs->txq_stopped != 0))
2059                 restart_tx(qs);
2060
2061         budget -= budget_left;
2062         return budget;
2063 }
2064
2065 static inline int is_pure_response(const struct rsp_desc *r)
2066 {
2067         u32 n = ntohl(r->flags) & (F_RSPD_ASYNC_NOTIF | F_RSPD_IMM_DATA_VALID);
2068
2069         return (n | r->len_cq) == 0;
2070 }
2071
2072 /**
2073  *      napi_rx_handler - the NAPI handler for Rx processing
2074  *      @napi: the napi instance
2075  *      @budget: how many packets we can process in this round
2076  *
2077  *      Handler for new data events when using NAPI.
2078  */
2079 static int napi_rx_handler(struct napi_struct *napi, int budget)
2080 {
2081         struct sge_qset *qs = container_of(napi, struct sge_qset, napi);
2082         struct adapter *adap = qs->adap;
2083         int work_done = process_responses(adap, qs, budget);
2084
2085         if (likely(work_done < budget)) {
2086                 napi_complete(napi);
2087
2088                 /*
2089                  * Because we don't atomically flush the following
2090                  * write it is possible that in very rare cases it can
2091                  * reach the device in a way that races with a new
2092                  * response being written plus an error interrupt
2093                  * causing the NAPI interrupt handler below to return
2094                  * unhandled status to the OS.  To protect against
2095                  * this would require flushing the write and doing
2096                  * both the write and the flush with interrupts off.
2097                  * Way too expensive and unjustifiable given the
2098                  * rarity of the race.
2099                  *
2100                  * The race cannot happen at all with MSI-X.
2101                  */
2102                 t3_write_reg(adap, A_SG_GTS, V_RSPQ(qs->rspq.cntxt_id) |
2103                              V_NEWTIMER(qs->rspq.next_holdoff) |
2104                              V_NEWINDEX(qs->rspq.cidx));
2105         }
2106         return work_done;
2107 }
2108
2109 /*
2110  * Returns true if the device is already scheduled for polling.
2111  */
2112 static inline int napi_is_scheduled(struct napi_struct *napi)
2113 {
2114         return test_bit(NAPI_STATE_SCHED, &napi->state);
2115 }
2116
2117 /**
2118  *      process_pure_responses - process pure responses from a response queue
2119  *      @adap: the adapter
2120  *      @qs: the queue set owning the response queue
2121  *      @r: the first pure response to process
2122  *
2123  *      A simpler version of process_responses() that handles only pure (i.e.,
2124  *      non data-carrying) responses.  Such respones are too light-weight to
2125  *      justify calling a softirq under NAPI, so we handle them specially in
2126  *      the interrupt handler.  The function is called with a pointer to a
2127  *      response, which the caller must ensure is a valid pure response.
2128  *
2129  *      Returns 1 if it encounters a valid data-carrying response, 0 otherwise.
2130  */
2131 static int process_pure_responses(struct adapter *adap, struct sge_qset *qs,
2132                                   struct rsp_desc *r)
2133 {
2134         struct sge_rspq *q = &qs->rspq;
2135         unsigned int sleeping = 0;
2136
2137         do {
2138                 u32 flags = ntohl(r->flags);
2139
2140                 r++;
2141                 if (unlikely(++q->cidx == q->size)) {
2142                         q->cidx = 0;
2143                         q->gen ^= 1;
2144                         r = q->desc;
2145                 }
2146                 prefetch(r);
2147
2148                 if (flags & RSPD_CTRL_MASK) {
2149                         sleeping |= flags & RSPD_GTS_MASK;
2150                         handle_rsp_cntrl_info(qs, flags);
2151                 }
2152
2153                 q->pure_rsps++;
2154                 if (++q->credits >= (q->size / 4)) {
2155                         refill_rspq(adap, q, q->credits);
2156                         q->credits = 0;
2157                 }
2158         } while (is_new_response(r, q) && is_pure_response(r));
2159
2160         if (sleeping)
2161                 check_ring_db(adap, qs, sleeping);
2162
2163         smp_mb();               /* commit Tx queue .processed updates */
2164         if (unlikely(qs->txq_stopped != 0))
2165                 restart_tx(qs);
2166
2167         return is_new_response(r, q);
2168 }
2169
2170 /**
2171  *      handle_responses - decide what to do with new responses in NAPI mode
2172  *      @adap: the adapter
2173  *      @q: the response queue
2174  *
2175  *      This is used by the NAPI interrupt handlers to decide what to do with
2176  *      new SGE responses.  If there are no new responses it returns -1.  If
2177  *      there are new responses and they are pure (i.e., non-data carrying)
2178  *      it handles them straight in hard interrupt context as they are very
2179  *      cheap and don't deliver any packets.  Finally, if there are any data
2180  *      signaling responses it schedules the NAPI handler.  Returns 1 if it
2181  *      schedules NAPI, 0 if all new responses were pure.
2182  *
2183  *      The caller must ascertain NAPI is not already running.
2184  */
2185 static inline int handle_responses(struct adapter *adap, struct sge_rspq *q)
2186 {
2187         struct sge_qset *qs = rspq_to_qset(q);
2188         struct rsp_desc *r = &q->desc[q->cidx];
2189
2190         if (!is_new_response(r, q))
2191                 return -1;
2192         if (is_pure_response(r) && process_pure_responses(adap, qs, r) == 0) {
2193                 t3_write_reg(adap, A_SG_GTS, V_RSPQ(q->cntxt_id) |
2194                              V_NEWTIMER(q->holdoff_tmr) | V_NEWINDEX(q->cidx));
2195                 return 0;
2196         }
2197         napi_schedule(&qs->napi);
2198         return 1;
2199 }
2200
2201 /*
2202  * The MSI-X interrupt handler for an SGE response queue for the non-NAPI case
2203  * (i.e., response queue serviced in hard interrupt).
2204  */
2205 irqreturn_t t3_sge_intr_msix(int irq, void *cookie)
2206 {
2207         struct sge_qset *qs = cookie;
2208         struct adapter *adap = qs->adap;
2209         struct sge_rspq *q = &qs->rspq;
2210
2211         spin_lock(&q->lock);
2212         if (process_responses(adap, qs, -1) == 0)
2213                 q->unhandled_irqs++;
2214         t3_write_reg(adap, A_SG_GTS, V_RSPQ(q->cntxt_id) |
2215                      V_NEWTIMER(q->next_holdoff) | V_NEWINDEX(q->cidx));
2216         spin_unlock(&q->lock);
2217         return IRQ_HANDLED;
2218 }
2219
2220 /*
2221  * The MSI-X interrupt handler for an SGE response queue for the NAPI case
2222  * (i.e., response queue serviced by NAPI polling).
2223  */
2224 static irqreturn_t t3_sge_intr_msix_napi(int irq, void *cookie)
2225 {
2226         struct sge_qset *qs = cookie;
2227         struct sge_rspq *q = &qs->rspq;
2228
2229         spin_lock(&q->lock);
2230
2231         if (handle_responses(qs->adap, q) < 0)
2232                 q->unhandled_irqs++;
2233         spin_unlock(&q->lock);
2234         return IRQ_HANDLED;
2235 }
2236
2237 /*
2238  * The non-NAPI MSI interrupt handler.  This needs to handle data events from
2239  * SGE response queues as well as error and other async events as they all use
2240  * the same MSI vector.  We use one SGE response queue per port in this mode
2241  * and protect all response queues with queue 0's lock.
2242  */
2243 static irqreturn_t t3_intr_msi(int irq, void *cookie)
2244 {
2245         int new_packets = 0;
2246         struct adapter *adap = cookie;
2247         struct sge_rspq *q = &adap->sge.qs[0].rspq;
2248
2249         spin_lock(&q->lock);
2250
2251         if (process_responses(adap, &adap->sge.qs[0], -1)) {
2252                 t3_write_reg(adap, A_SG_GTS, V_RSPQ(q->cntxt_id) |
2253                              V_NEWTIMER(q->next_holdoff) | V_NEWINDEX(q->cidx));
2254                 new_packets = 1;
2255         }
2256
2257         if (adap->params.nports == 2 &&
2258             process_responses(adap, &adap->sge.qs[1], -1)) {
2259                 struct sge_rspq *q1 = &adap->sge.qs[1].rspq;
2260
2261                 t3_write_reg(adap, A_SG_GTS, V_RSPQ(q1->cntxt_id) |
2262                              V_NEWTIMER(q1->next_holdoff) |
2263                              V_NEWINDEX(q1->cidx));
2264                 new_packets = 1;
2265         }
2266
2267         if (!new_packets && t3_slow_intr_handler(adap) == 0)
2268                 q->unhandled_irqs++;
2269
2270         spin_unlock(&q->lock);
2271         return IRQ_HANDLED;
2272 }
2273
2274 static int rspq_check_napi(struct sge_qset *qs)
2275 {
2276         struct sge_rspq *q = &qs->rspq;
2277
2278         if (!napi_is_scheduled(&qs->napi) &&
2279             is_new_response(&q->desc[q->cidx], q)) {
2280                 napi_schedule(&qs->napi);
2281                 return 1;
2282         }
2283         return 0;
2284 }
2285
2286 /*
2287  * The MSI interrupt handler for the NAPI case (i.e., response queues serviced
2288  * by NAPI polling).  Handles data events from SGE response queues as well as
2289  * error and other async events as they all use the same MSI vector.  We use
2290  * one SGE response queue per port in this mode and protect all response
2291  * queues with queue 0's lock.
2292  */
2293 static irqreturn_t t3_intr_msi_napi(int irq, void *cookie)
2294 {
2295         int new_packets;
2296         struct adapter *adap = cookie;
2297         struct sge_rspq *q = &adap->sge.qs[0].rspq;
2298
2299         spin_lock(&q->lock);
2300
2301         new_packets = rspq_check_napi(&adap->sge.qs[0]);
2302         if (adap->params.nports == 2)
2303                 new_packets += rspq_check_napi(&adap->sge.qs[1]);
2304         if (!new_packets && t3_slow_intr_handler(adap) == 0)
2305                 q->unhandled_irqs++;
2306
2307         spin_unlock(&q->lock);
2308         return IRQ_HANDLED;
2309 }
2310
2311 /*
2312  * A helper function that processes responses and issues GTS.
2313  */
2314 static inline int process_responses_gts(struct adapter *adap,
2315                                         struct sge_rspq *rq)
2316 {
2317         int work;
2318
2319         work = process_responses(adap, rspq_to_qset(rq), -1);
2320         t3_write_reg(adap, A_SG_GTS, V_RSPQ(rq->cntxt_id) |
2321                      V_NEWTIMER(rq->next_holdoff) | V_NEWINDEX(rq->cidx));
2322         return work;
2323 }
2324
2325 /*
2326  * The legacy INTx interrupt handler.  This needs to handle data events from
2327  * SGE response queues as well as error and other async events as they all use
2328  * the same interrupt pin.  We use one SGE response queue per port in this mode
2329  * and protect all response queues with queue 0's lock.
2330  */
2331 static irqreturn_t t3_intr(int irq, void *cookie)
2332 {
2333         int work_done, w0, w1;
2334         struct adapter *adap = cookie;
2335         struct sge_rspq *q0 = &adap->sge.qs[0].rspq;
2336         struct sge_rspq *q1 = &adap->sge.qs[1].rspq;
2337
2338         spin_lock(&q0->lock);
2339
2340         w0 = is_new_response(&q0->desc[q0->cidx], q0);
2341         w1 = adap->params.nports == 2 &&
2342             is_new_response(&q1->desc[q1->cidx], q1);
2343
2344         if (likely(w0 | w1)) {
2345                 t3_write_reg(adap, A_PL_CLI, 0);
2346                 t3_read_reg(adap, A_PL_CLI);    /* flush */
2347
2348                 if (likely(w0))
2349                         process_responses_gts(adap, q0);
2350
2351                 if (w1)
2352                         process_responses_gts(adap, q1);
2353
2354                 work_done = w0 | w1;
2355         } else
2356                 work_done = t3_slow_intr_handler(adap);
2357
2358         spin_unlock(&q0->lock);
2359         return IRQ_RETVAL(work_done != 0);
2360 }
2361
2362 /*
2363  * Interrupt handler for legacy INTx interrupts for T3B-based cards.
2364  * Handles data events from SGE response queues as well as error and other
2365  * async events as they all use the same interrupt pin.  We use one SGE
2366  * response queue per port in this mode and protect all response queues with
2367  * queue 0's lock.
2368  */
2369 static irqreturn_t t3b_intr(int irq, void *cookie)
2370 {
2371         u32 map;
2372         struct adapter *adap = cookie;
2373         struct sge_rspq *q0 = &adap->sge.qs[0].rspq;
2374
2375         t3_write_reg(adap, A_PL_CLI, 0);
2376         map = t3_read_reg(adap, A_SG_DATA_INTR);
2377
2378         if (unlikely(!map))     /* shared interrupt, most likely */
2379                 return IRQ_NONE;
2380
2381         spin_lock(&q0->lock);
2382
2383         if (unlikely(map & F_ERRINTR))
2384                 t3_slow_intr_handler(adap);
2385
2386         if (likely(map & 1))
2387                 process_responses_gts(adap, q0);
2388
2389         if (map & 2)
2390                 process_responses_gts(adap, &adap->sge.qs[1].rspq);
2391
2392         spin_unlock(&q0->lock);
2393         return IRQ_HANDLED;
2394 }
2395
2396 /*
2397  * NAPI interrupt handler for legacy INTx interrupts for T3B-based cards.
2398  * Handles data events from SGE response queues as well as error and other
2399  * async events as they all use the same interrupt pin.  We use one SGE
2400  * response queue per port in this mode and protect all response queues with
2401  * queue 0's lock.
2402  */
2403 static irqreturn_t t3b_intr_napi(int irq, void *cookie)
2404 {
2405         u32 map;
2406         struct adapter *adap = cookie;
2407         struct sge_qset *qs0 = &adap->sge.qs[0];
2408         struct sge_rspq *q0 = &qs0->rspq;
2409
2410         t3_write_reg(adap, A_PL_CLI, 0);
2411         map = t3_read_reg(adap, A_SG_DATA_INTR);
2412
2413         if (unlikely(!map))     /* shared interrupt, most likely */
2414                 return IRQ_NONE;
2415
2416         spin_lock(&q0->lock);
2417
2418         if (unlikely(map & F_ERRINTR))
2419                 t3_slow_intr_handler(adap);
2420
2421         if (likely(map & 1))
2422                 napi_schedule(&qs0->napi);
2423
2424         if (map & 2)
2425                 napi_schedule(&adap->sge.qs[1].napi);
2426
2427         spin_unlock(&q0->lock);
2428         return IRQ_HANDLED;
2429 }
2430
2431 /**
2432  *      t3_intr_handler - select the top-level interrupt handler
2433  *      @adap: the adapter
2434  *      @polling: whether using NAPI to service response queues
2435  *
2436  *      Selects the top-level interrupt handler based on the type of interrupts
2437  *      (MSI-X, MSI, or legacy) and whether NAPI will be used to service the
2438  *      response queues.
2439  */
2440 irq_handler_t t3_intr_handler(struct adapter *adap, int polling)
2441 {
2442         if (adap->flags & USING_MSIX)
2443                 return polling ? t3_sge_intr_msix_napi : t3_sge_intr_msix;
2444         if (adap->flags & USING_MSI)
2445                 return polling ? t3_intr_msi_napi : t3_intr_msi;
2446         if (adap->params.rev > 0)
2447                 return polling ? t3b_intr_napi : t3b_intr;
2448         return t3_intr;
2449 }
2450
2451 #define SGE_PARERR (F_CPPARITYERROR | F_OCPARITYERROR | F_RCPARITYERROR | \
2452                     F_IRPARITYERROR | V_ITPARITYERROR(M_ITPARITYERROR) | \
2453                     V_FLPARITYERROR(M_FLPARITYERROR) | F_LODRBPARITYERROR | \
2454                     F_HIDRBPARITYERROR | F_LORCQPARITYERROR | \
2455                     F_HIRCQPARITYERROR)
2456 #define SGE_FRAMINGERR (F_UC_REQ_FRAMINGERROR | F_R_REQ_FRAMINGERROR)
2457 #define SGE_FATALERR (SGE_PARERR | SGE_FRAMINGERR | F_RSPQCREDITOVERFOW | \
2458                       F_RSPQDISABLED)
2459
2460 /**
2461  *      t3_sge_err_intr_handler - SGE async event interrupt handler
2462  *      @adapter: the adapter
2463  *
2464  *      Interrupt handler for SGE asynchronous (non-data) events.
2465  */
2466 void t3_sge_err_intr_handler(struct adapter *adapter)
2467 {
2468         unsigned int v, status = t3_read_reg(adapter, A_SG_INT_CAUSE);
2469
2470         if (status & SGE_PARERR)
2471                 CH_ALERT(adapter, "SGE parity error (0x%x)\n",
2472                          status & SGE_PARERR);
2473         if (status & SGE_FRAMINGERR)
2474                 CH_ALERT(adapter, "SGE framing error (0x%x)\n",
2475                          status & SGE_FRAMINGERR);
2476
2477         if (status & F_RSPQCREDITOVERFOW)
2478                 CH_ALERT(adapter, "SGE response queue credit overflow\n");
2479
2480         if (status & F_RSPQDISABLED) {
2481                 v = t3_read_reg(adapter, A_SG_RSPQ_FL_STATUS);
2482
2483                 CH_ALERT(adapter,
2484                          "packet delivered to disabled response queue "
2485                          "(0x%x)\n", (v >> S_RSPQ0DISABLED) & 0xff);
2486         }
2487
2488         if (status & (F_HIPIODRBDROPERR | F_LOPIODRBDROPERR))
2489                 CH_ALERT(adapter, "SGE dropped %s priority doorbell\n",
2490                          status & F_HIPIODRBDROPERR ? "high" : "lo");
2491
2492         t3_write_reg(adapter, A_SG_INT_CAUSE, status);
2493         if (status &  SGE_FATALERR)
2494                 t3_fatal_err(adapter);
2495 }
2496
2497 /**
2498  *      sge_timer_cb - perform periodic maintenance of an SGE qset
2499  *      @data: the SGE queue set to maintain
2500  *
2501  *      Runs periodically from a timer to perform maintenance of an SGE queue
2502  *      set.  It performs two tasks:
2503  *
2504  *      a) Cleans up any completed Tx descriptors that may still be pending.
2505  *      Normal descriptor cleanup happens when new packets are added to a Tx
2506  *      queue so this timer is relatively infrequent and does any cleanup only
2507  *      if the Tx queue has not seen any new packets in a while.  We make a
2508  *      best effort attempt to reclaim descriptors, in that we don't wait
2509  *      around if we cannot get a queue's lock (which most likely is because
2510  *      someone else is queueing new packets and so will also handle the clean
2511  *      up).  Since control queues use immediate data exclusively we don't
2512  *      bother cleaning them up here.
2513  *
2514  *      b) Replenishes Rx queues that have run out due to memory shortage.
2515  *      Normally new Rx buffers are added when existing ones are consumed but
2516  *      when out of memory a queue can become empty.  We try to add only a few
2517  *      buffers here, the queue will be replenished fully as these new buffers
2518  *      are used up if memory shortage has subsided.
2519  */
2520 static void sge_timer_cb(unsigned long data)
2521 {
2522         spinlock_t *lock;
2523         struct sge_qset *qs = (struct sge_qset *)data;
2524         struct adapter *adap = qs->adap;
2525
2526         if (spin_trylock(&qs->txq[TXQ_ETH].lock)) {
2527                 reclaim_completed_tx(adap, &qs->txq[TXQ_ETH]);
2528                 spin_unlock(&qs->txq[TXQ_ETH].lock);
2529         }
2530         if (spin_trylock(&qs->txq[TXQ_OFLD].lock)) {
2531                 reclaim_completed_tx(adap, &qs->txq[TXQ_OFLD]);
2532                 spin_unlock(&qs->txq[TXQ_OFLD].lock);
2533         }
2534         lock = (adap->flags & USING_MSIX) ? &qs->rspq.lock :
2535                                             &adap->sge.qs[0].rspq.lock;
2536         if (spin_trylock_irq(lock)) {
2537                 if (!napi_is_scheduled(&qs->napi)) {
2538                         u32 status = t3_read_reg(adap, A_SG_RSPQ_FL_STATUS);
2539
2540                         if (qs->fl[0].credits < qs->fl[0].size)
2541                                 __refill_fl(adap, &qs->fl[0]);
2542                         if (qs->fl[1].credits < qs->fl[1].size)
2543                                 __refill_fl(adap, &qs->fl[1]);
2544
2545                         if (status & (1 << qs->rspq.cntxt_id)) {
2546                                 qs->rspq.starved++;
2547                                 if (qs->rspq.credits) {
2548                                         refill_rspq(adap, &qs->rspq, 1);
2549                                         qs->rspq.credits--;
2550                                         qs->rspq.restarted++;
2551                                         t3_write_reg(adap, A_SG_RSPQ_FL_STATUS,
2552                                                      1 << qs->rspq.cntxt_id);
2553                                 }
2554                         }
2555                 }
2556                 spin_unlock_irq(lock);
2557         }
2558         mod_timer(&qs->tx_reclaim_timer, jiffies + TX_RECLAIM_PERIOD);
2559 }
2560
2561 /**
2562  *      t3_update_qset_coalesce - update coalescing settings for a queue set
2563  *      @qs: the SGE queue set
2564  *      @p: new queue set parameters
2565  *
2566  *      Update the coalescing settings for an SGE queue set.  Nothing is done
2567  *      if the queue set is not initialized yet.
2568  */
2569 void t3_update_qset_coalesce(struct sge_qset *qs, const struct qset_params *p)
2570 {
2571         qs->rspq.holdoff_tmr = max(p->coalesce_usecs * 10, 1U);/* can't be 0 */
2572         qs->rspq.polling = p->polling;
2573         qs->napi.poll = p->polling ? napi_rx_handler : ofld_poll;
2574 }
2575
2576 /**
2577  *      t3_sge_alloc_qset - initialize an SGE queue set
2578  *      @adapter: the adapter
2579  *      @id: the queue set id
2580  *      @nports: how many Ethernet ports will be using this queue set
2581  *      @irq_vec_idx: the IRQ vector index for response queue interrupts
2582  *      @p: configuration parameters for this queue set
2583  *      @ntxq: number of Tx queues for the queue set
2584  *      @netdev: net device associated with this queue set
2585  *
2586  *      Allocate resources and initialize an SGE queue set.  A queue set
2587  *      comprises a response queue, two Rx free-buffer queues, and up to 3
2588  *      Tx queues.  The Tx queues are assigned roles in the order Ethernet
2589  *      queue, offload queue, and control queue.
2590  */
2591 int t3_sge_alloc_qset(struct adapter *adapter, unsigned int id, int nports,
2592                       int irq_vec_idx, const struct qset_params *p,
2593                       int ntxq, struct net_device *dev)
2594 {
2595         int i, ret = -ENOMEM;
2596         struct sge_qset *q = &adapter->sge.qs[id];
2597
2598         init_qset_cntxt(q, id);
2599         init_timer(&q->tx_reclaim_timer);
2600         q->tx_reclaim_timer.data = (unsigned long)q;
2601         q->tx_reclaim_timer.function = sge_timer_cb;
2602
2603         q->fl[0].desc = alloc_ring(adapter->pdev, p->fl_size,
2604                                    sizeof(struct rx_desc),
2605                                    sizeof(struct rx_sw_desc),
2606                                    &q->fl[0].phys_addr, &q->fl[0].sdesc);
2607         if (!q->fl[0].desc)
2608                 goto err;
2609
2610         q->fl[1].desc = alloc_ring(adapter->pdev, p->jumbo_size,
2611                                    sizeof(struct rx_desc),
2612                                    sizeof(struct rx_sw_desc),
2613                                    &q->fl[1].phys_addr, &q->fl[1].sdesc);
2614         if (!q->fl[1].desc)
2615                 goto err;
2616
2617         q->rspq.desc = alloc_ring(adapter->pdev, p->rspq_size,
2618                                   sizeof(struct rsp_desc), 0,
2619                                   &q->rspq.phys_addr, NULL);
2620         if (!q->rspq.desc)
2621                 goto err;
2622
2623         for (i = 0; i < ntxq; ++i) {
2624                 /*
2625                  * The control queue always uses immediate data so does not
2626                  * need to keep track of any sk_buffs.
2627                  */
2628                 size_t sz = i == TXQ_CTRL ? 0 : sizeof(struct tx_sw_desc);
2629
2630                 q->txq[i].desc = alloc_ring(adapter->pdev, p->txq_size[i],
2631                                             sizeof(struct tx_desc), sz,
2632                                             &q->txq[i].phys_addr,
2633                                             &q->txq[i].sdesc);
2634                 if (!q->txq[i].desc)
2635                         goto err;
2636
2637                 q->txq[i].gen = 1;
2638                 q->txq[i].size = p->txq_size[i];
2639                 spin_lock_init(&q->txq[i].lock);
2640                 skb_queue_head_init(&q->txq[i].sendq);
2641         }
2642
2643         tasklet_init(&q->txq[TXQ_OFLD].qresume_tsk, restart_offloadq,
2644                      (unsigned long)q);
2645         tasklet_init(&q->txq[TXQ_CTRL].qresume_tsk, restart_ctrlq,
2646                      (unsigned long)q);
2647
2648         q->fl[0].gen = q->fl[1].gen = 1;
2649         q->fl[0].size = p->fl_size;
2650         q->fl[1].size = p->jumbo_size;
2651
2652         q->rspq.gen = 1;
2653         q->rspq.size = p->rspq_size;
2654         spin_lock_init(&q->rspq.lock);
2655
2656         q->txq[TXQ_ETH].stop_thres = nports *
2657             flits_to_desc(sgl_len(MAX_SKB_FRAGS + 1) + 3);
2658
2659 #if FL0_PG_CHUNK_SIZE > 0
2660         q->fl[0].buf_size = FL0_PG_CHUNK_SIZE;
2661 #else
2662         q->fl[0].buf_size = SGE_RX_SM_BUF_SIZE + sizeof(struct cpl_rx_data);
2663 #endif
2664         q->fl[0].use_pages = FL0_PG_CHUNK_SIZE > 0;
2665         q->fl[1].buf_size = is_offload(adapter) ?
2666                 (16 * 1024) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)) :
2667                 MAX_FRAME_SIZE + 2 + sizeof(struct cpl_rx_pkt);
2668
2669         spin_lock(&adapter->sge.reg_lock);
2670
2671         /* FL threshold comparison uses < */
2672         ret = t3_sge_init_rspcntxt(adapter, q->rspq.cntxt_id, irq_vec_idx,
2673                                    q->rspq.phys_addr, q->rspq.size,
2674                                    q->fl[0].buf_size, 1, 0);
2675         if (ret)
2676                 goto err_unlock;
2677
2678         for (i = 0; i < SGE_RXQ_PER_SET; ++i) {
2679                 ret = t3_sge_init_flcntxt(adapter, q->fl[i].cntxt_id, 0,
2680                                           q->fl[i].phys_addr, q->fl[i].size,
2681                                           q->fl[i].buf_size, p->cong_thres, 1,
2682                                           0);
2683                 if (ret)
2684                         goto err_unlock;
2685         }
2686
2687         ret = t3_sge_init_ecntxt(adapter, q->txq[TXQ_ETH].cntxt_id, USE_GTS,
2688                                  SGE_CNTXT_ETH, id, q->txq[TXQ_ETH].phys_addr,
2689                                  q->txq[TXQ_ETH].size, q->txq[TXQ_ETH].token,
2690                                  1, 0);
2691         if (ret)
2692                 goto err_unlock;
2693
2694         if (ntxq > 1) {
2695                 ret = t3_sge_init_ecntxt(adapter, q->txq[TXQ_OFLD].cntxt_id,
2696                                          USE_GTS, SGE_CNTXT_OFLD, id,
2697                                          q->txq[TXQ_OFLD].phys_addr,
2698                                          q->txq[TXQ_OFLD].size, 0, 1, 0);
2699                 if (ret)
2700                         goto err_unlock;
2701         }
2702
2703         if (ntxq > 2) {
2704                 ret = t3_sge_init_ecntxt(adapter, q->txq[TXQ_CTRL].cntxt_id, 0,
2705                                          SGE_CNTXT_CTRL, id,
2706                                          q->txq[TXQ_CTRL].phys_addr,
2707                                          q->txq[TXQ_CTRL].size,
2708                                          q->txq[TXQ_CTRL].token, 1, 0);
2709                 if (ret)
2710                         goto err_unlock;
2711         }
2712
2713         spin_unlock(&adapter->sge.reg_lock);
2714
2715         q->adap = adapter;
2716         q->netdev = dev;
2717         t3_update_qset_coalesce(q, p);
2718
2719         refill_fl(adapter, &q->fl[0], q->fl[0].size, GFP_KERNEL);
2720         refill_fl(adapter, &q->fl[1], q->fl[1].size, GFP_KERNEL);
2721         refill_rspq(adapter, &q->rspq, q->rspq.size - 1);
2722
2723         t3_write_reg(adapter, A_SG_GTS, V_RSPQ(q->rspq.cntxt_id) |
2724                      V_NEWTIMER(q->rspq.holdoff_tmr));
2725
2726         mod_timer(&q->tx_reclaim_timer, jiffies + TX_RECLAIM_PERIOD);
2727         return 0;
2728
2729       err_unlock:
2730         spin_unlock(&adapter->sge.reg_lock);
2731       err:
2732         t3_free_qset(adapter, q);
2733         return ret;
2734 }
2735
2736 /**
2737  *      t3_free_sge_resources - free SGE resources
2738  *      @adap: the adapter
2739  *
2740  *      Frees resources used by the SGE queue sets.
2741  */
2742 void t3_free_sge_resources(struct adapter *adap)
2743 {
2744         int i;
2745
2746         for (i = 0; i < SGE_QSETS; ++i)
2747                 t3_free_qset(adap, &adap->sge.qs[i]);
2748 }
2749
2750 /**
2751  *      t3_sge_start - enable SGE
2752  *      @adap: the adapter
2753  *
2754  *      Enables the SGE for DMAs.  This is the last step in starting packet
2755  *      transfers.
2756  */
2757 void t3_sge_start(struct adapter *adap)
2758 {
2759         t3_set_reg_field(adap, A_SG_CONTROL, F_GLOBALENABLE, F_GLOBALENABLE);
2760 }
2761
2762 /**
2763  *      t3_sge_stop - disable SGE operation
2764  *      @adap: the adapter
2765  *
2766  *      Disables the DMA engine.  This can be called in emeregencies (e.g.,
2767  *      from error interrupts) or from normal process context.  In the latter
2768  *      case it also disables any pending queue restart tasklets.  Note that
2769  *      if it is called in interrupt context it cannot disable the restart
2770  *      tasklets as it cannot wait, however the tasklets will have no effect
2771  *      since the doorbells are disabled and the driver will call this again
2772  *      later from process context, at which time the tasklets will be stopped
2773  *      if they are still running.
2774  */
2775 void t3_sge_stop(struct adapter *adap)
2776 {
2777         t3_set_reg_field(adap, A_SG_CONTROL, F_GLOBALENABLE, 0);
2778         if (!in_interrupt()) {
2779                 int i;
2780
2781                 for (i = 0; i < SGE_QSETS; ++i) {
2782                         struct sge_qset *qs = &adap->sge.qs[i];
2783
2784                         tasklet_kill(&qs->txq[TXQ_OFLD].qresume_tsk);
2785                         tasklet_kill(&qs->txq[TXQ_CTRL].qresume_tsk);
2786                 }
2787         }
2788 }
2789
2790 /**
2791  *      t3_sge_init - initialize SGE
2792  *      @adap: the adapter
2793  *      @p: the SGE parameters
2794  *
2795  *      Performs SGE initialization needed every time after a chip reset.
2796  *      We do not initialize any of the queue sets here, instead the driver
2797  *      top-level must request those individually.  We also do not enable DMA
2798  *      here, that should be done after the queues have been set up.
2799  */
2800 void t3_sge_init(struct adapter *adap, struct sge_params *p)
2801 {
2802         unsigned int ctrl, ups = ffs(pci_resource_len(adap->pdev, 2) >> 12);
2803
2804         ctrl = F_DROPPKT | V_PKTSHIFT(2) | F_FLMODE | F_AVOIDCQOVFL |
2805             F_CQCRDTCTRL | F_CONGMODE | F_TNLFLMODE | F_FATLPERREN |
2806             V_HOSTPAGESIZE(PAGE_SHIFT - 11) | F_BIGENDIANINGRESS |
2807             V_USERSPACESIZE(ups ? ups - 1 : 0) | F_ISCSICOALESCING;
2808 #if SGE_NUM_GENBITS == 1
2809         ctrl |= F_EGRGENCTRL;
2810 #endif
2811         if (adap->params.rev > 0) {
2812                 if (!(adap->flags & (USING_MSIX | USING_MSI)))
2813                         ctrl |= F_ONEINTMULTQ | F_OPTONEINTMULTQ;
2814         }
2815         t3_write_reg(adap, A_SG_CONTROL, ctrl);
2816         t3_write_reg(adap, A_SG_EGR_RCQ_DRB_THRSH, V_HIRCQDRBTHRSH(512) |
2817                      V_LORCQDRBTHRSH(512));
2818         t3_write_reg(adap, A_SG_TIMER_TICK, core_ticks_per_usec(adap) / 10);
2819         t3_write_reg(adap, A_SG_CMDQ_CREDIT_TH, V_THRESHOLD(32) |
2820                      V_TIMEOUT(200 * core_ticks_per_usec(adap)));
2821         t3_write_reg(adap, A_SG_HI_DRB_HI_THRSH,
2822                      adap->params.rev < T3_REV_C ? 1000 : 500);
2823         t3_write_reg(adap, A_SG_HI_DRB_LO_THRSH, 256);
2824         t3_write_reg(adap, A_SG_LO_DRB_HI_THRSH, 1000);
2825         t3_write_reg(adap, A_SG_LO_DRB_LO_THRSH, 256);
2826         t3_write_reg(adap, A_SG_OCO_BASE, V_BASE1(0xfff));
2827         t3_write_reg(adap, A_SG_DRB_PRI_THRESH, 63 * 1024);
2828 }
2829
2830 /**
2831  *      t3_sge_prep - one-time SGE initialization
2832  *      @adap: the associated adapter
2833  *      @p: SGE parameters
2834  *
2835  *      Performs one-time initialization of SGE SW state.  Includes determining
2836  *      defaults for the assorted SGE parameters, which admins can change until
2837  *      they are used to initialize the SGE.
2838  */
2839 void __devinit t3_sge_prep(struct adapter *adap, struct sge_params *p)
2840 {
2841         int i;
2842
2843         p->max_pkt_size = (16 * 1024) - sizeof(struct cpl_rx_data) -
2844             SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
2845
2846         for (i = 0; i < SGE_QSETS; ++i) {
2847                 struct qset_params *q = p->qset + i;
2848
2849                 q->polling = adap->params.rev > 0;
2850                 q->coalesce_usecs = 5;
2851                 q->rspq_size = 1024;
2852                 q->fl_size = 1024;
2853                 q->jumbo_size = 512;
2854                 q->txq_size[TXQ_ETH] = 1024;
2855                 q->txq_size[TXQ_OFLD] = 1024;
2856                 q->txq_size[TXQ_CTRL] = 256;
2857                 q->cong_thres = 0;
2858         }
2859
2860         spin_lock_init(&adap->sge.reg_lock);
2861 }
2862
2863 /**
2864  *      t3_get_desc - dump an SGE descriptor for debugging purposes
2865  *      @qs: the queue set
2866  *      @qnum: identifies the specific queue (0..2: Tx, 3:response, 4..5: Rx)
2867  *      @idx: the descriptor index in the queue
2868  *      @data: where to dump the descriptor contents
2869  *
2870  *      Dumps the contents of a HW descriptor of an SGE queue.  Returns the
2871  *      size of the descriptor.
2872  */
2873 int t3_get_desc(const struct sge_qset *qs, unsigned int qnum, unsigned int idx,
2874                 unsigned char *data)
2875 {
2876         if (qnum >= 6)
2877                 return -EINVAL;
2878
2879         if (qnum < 3) {
2880                 if (!qs->txq[qnum].desc || idx >= qs->txq[qnum].size)
2881                         return -EINVAL;
2882                 memcpy(data, &qs->txq[qnum].desc[idx], sizeof(struct tx_desc));
2883                 return sizeof(struct tx_desc);
2884         }
2885
2886         if (qnum == 3) {
2887                 if (!qs->rspq.desc || idx >= qs->rspq.size)
2888                         return -EINVAL;
2889                 memcpy(data, &qs->rspq.desc[idx], sizeof(struct rsp_desc));
2890                 return sizeof(struct rsp_desc);
2891         }
2892
2893         qnum -= 4;
2894         if (!qs->fl[qnum].desc || idx >= qs->fl[qnum].size)
2895                 return -EINVAL;
2896         memcpy(data, &qs->fl[qnum].desc[idx], sizeof(struct rx_desc));
2897         return sizeof(struct rx_desc);
2898 }