Deleted Added
sdiff udiff text old ( 170076 ) new ( 170654 )
full compact
cxgb_sge.c (170076) cxgb_sge.c (170654)
1/**************************************************************************
2
3Copyright (c) 2007, Chelsio Inc.
4All rights reserved.
5
6Redistribution and use in source and binary forms, with or without
7modification, are permitted provided that the following conditions are met:
8

--- 14 unchanged lines hidden (view full) ---

23INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26POSSIBILITY OF SUCH DAMAGE.
27
28***************************************************************************/
29
30#include <sys/cdefs.h>
1/**************************************************************************
2
3Copyright (c) 2007, Chelsio Inc.
4All rights reserved.
5
6Redistribution and use in source and binary forms, with or without
7modification, are permitted provided that the following conditions are met:
8

--- 14 unchanged lines hidden (view full) ---

23INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26POSSIBILITY OF SUCH DAMAGE.
27
28***************************************************************************/
29
30#include <sys/cdefs.h>
31__FBSDID("$FreeBSD: head/sys/dev/cxgb/cxgb_sge.c 170076 2007-05-28 22:57:27Z kmacy $");
31__FBSDID("$FreeBSD: head/sys/dev/cxgb/cxgb_sge.c 170654 2007-06-13 05:36:00Z kmacy $");
32
33#include <sys/param.h>
34#include <sys/systm.h>
35#include <sys/kernel.h>
36#include <sys/module.h>
37#include <sys/bus.h>
38#include <sys/conf.h>
39#include <machine/bus.h>

--- 262 unchanged lines hidden (view full) ---

302 */
303 if (sopeop == RSPQ_NSOP_NEOP || sopeop == RSPQ_SOP)
304 return;
305
306 len = G_RSPD_LEN(ntohl(resp->len_cq));
307 switch (sopeop) {
308 case RSPQ_SOP_EOP:
309 m->m_len = m->m_pkthdr.len = len;
32
33#include <sys/param.h>
34#include <sys/systm.h>
35#include <sys/kernel.h>
36#include <sys/module.h>
37#include <sys/bus.h>
38#include <sys/conf.h>
39#include <machine/bus.h>

--- 262 unchanged lines hidden (view full) ---

302 */
303 if (sopeop == RSPQ_NSOP_NEOP || sopeop == RSPQ_SOP)
304 return;
305
306 len = G_RSPD_LEN(ntohl(resp->len_cq));
307 switch (sopeop) {
308 case RSPQ_SOP_EOP:
309 m->m_len = m->m_pkthdr.len = len;
310 memcpy(m->m_data, resp->imm_data, len);
310 memcpy(mtod(m, uint8_t *), resp->imm_data, len);
311 break;
312 case RSPQ_EOP:
313 memcpy(cl, resp->imm_data, len);
314 m_iovappend(m, cl, MSIZE, len, 0);
315 break;
316 }
317}
318

--- 342 unchanged lines hidden (view full) ---

661
662 t3_slow_intr_handler(sc);
663}
664
665static void
666sge_timer_cb(void *arg)
667{
668 adapter_t *sc = arg;
311 break;
312 case RSPQ_EOP:
313 memcpy(cl, resp->imm_data, len);
314 m_iovappend(m, cl, MSIZE, len, 0);
315 break;
316 }
317}
318

--- 342 unchanged lines hidden (view full) ---

661
662 t3_slow_intr_handler(sc);
663}
664
665static void
666sge_timer_cb(void *arg)
667{
668 adapter_t *sc = arg;
669 struct port_info *p;
669 struct sge_qset *qs;
670 struct sge_txq *txq;
671 int i, j;
672 int reclaim_eth, reclaim_ofl, refill_rx;
673
674 for (i = 0; i < sc->params.nports; i++)
675 for (j = 0; j < sc->port[i].nqsets; j++) {
676 qs = &sc->sge.qs[i + j];
677 txq = &qs->txq[0];
678 reclaim_eth = txq[TXQ_ETH].processed - txq[TXQ_ETH].cleaned;
679 reclaim_ofl = txq[TXQ_OFLD].processed - txq[TXQ_OFLD].cleaned;
680 refill_rx = ((qs->fl[0].credits < qs->fl[0].size) ||
681 (qs->fl[1].credits < qs->fl[1].size));
682 if (reclaim_eth || reclaim_ofl || refill_rx) {
670 struct sge_qset *qs;
671 struct sge_txq *txq;
672 int i, j;
673 int reclaim_eth, reclaim_ofl, refill_rx;
674
675 for (i = 0; i < sc->params.nports; i++)
676 for (j = 0; j < sc->port[i].nqsets; j++) {
677 qs = &sc->sge.qs[i + j];
678 txq = &qs->txq[0];
679 reclaim_eth = txq[TXQ_ETH].processed - txq[TXQ_ETH].cleaned;
680 reclaim_ofl = txq[TXQ_OFLD].processed - txq[TXQ_OFLD].cleaned;
681 refill_rx = ((qs->fl[0].credits < qs->fl[0].size) ||
682 (qs->fl[1].credits < qs->fl[1].size));
683 if (reclaim_eth || reclaim_ofl || refill_rx) {
683 taskqueue_enqueue(sc->tq, &sc->timer_reclaim_task);
684 goto done;
684 p = &sc->port[i];
685 taskqueue_enqueue(p->tq, &p->timer_reclaim_task);
686 break;
685 }
686 }
687 }
688 }
687done:
688 callout_reset(&sc->sge_timer_ch, TX_RECLAIM_PERIOD, sge_timer_cb, sc);
689}
690
691/*
692 * This is meant to be a catch-all function to keep sge state private
693 * to sge.c
694 *
695 */
696int
689 callout_reset(&sc->sge_timer_ch, TX_RECLAIM_PERIOD, sge_timer_cb, sc);
690}
691
692/*
693 * This is meant to be a catch-all function to keep sge state private
694 * to sge.c
695 *
696 */
697int
697t3_sge_init_sw(adapter_t *sc)
698t3_sge_init_adapter(adapter_t *sc)
698{
699{
699
700 callout_init(&sc->sge_timer_ch, CALLOUT_MPSAFE);
701 callout_reset(&sc->sge_timer_ch, TX_RECLAIM_PERIOD, sge_timer_cb, sc);
700 callout_init(&sc->sge_timer_ch, CALLOUT_MPSAFE);
701 callout_reset(&sc->sge_timer_ch, TX_RECLAIM_PERIOD, sge_timer_cb, sc);
702 TASK_INIT(&sc->timer_reclaim_task, 0, sge_timer_reclaim, sc);
703 TASK_INIT(&sc->slow_intr_task, 0, sge_slow_intr_handler, sc);
704 return (0);
705}
706
702 TASK_INIT(&sc->slow_intr_task, 0, sge_slow_intr_handler, sc);
703 return (0);
704}
705
706int
707t3_sge_init_port(struct port_info *p)
708{
709 TASK_INIT(&p->timer_reclaim_task, 0, sge_timer_reclaim, p);
710}
711
707void
708t3_sge_deinit_sw(adapter_t *sc)
709{
712void
713t3_sge_deinit_sw(adapter_t *sc)
714{
715 int i;
716
710 callout_drain(&sc->sge_timer_ch);
717 callout_drain(&sc->sge_timer_ch);
711 if (sc->tq) {
712 taskqueue_drain(sc->tq, &sc->timer_reclaim_task);
718 if (sc->tq)
713 taskqueue_drain(sc->tq, &sc->slow_intr_task);
719 taskqueue_drain(sc->tq, &sc->slow_intr_task);
714 }
720 for (i = 0; i < sc->params.nports; i++)
721 if (sc->port[i].tq != NULL)
722 taskqueue_drain(sc->port[i].tq, &sc->port[i].timer_reclaim_task);
715}
716
717/**
718 * refill_rspq - replenish an SGE response queue
719 * @adapter: the adapter
720 * @q: the response queue to replenish
721 * @credits: how many new responses to make available
722 *

--- 8 unchanged lines hidden (view full) ---

731 t3_write_reg(sc, A_SG_RSPQ_CREDIT_RETURN,
732 V_RSPQ(q->cntxt_id) | V_CREDITS(credits));
733}
734
735
736static void
737sge_timer_reclaim(void *arg, int ncount)
738{
723}
724
725/**
726 * refill_rspq - replenish an SGE response queue
727 * @adapter: the adapter
728 * @q: the response queue to replenish
729 * @credits: how many new responses to make available
730 *

--- 8 unchanged lines hidden (view full) ---

739 t3_write_reg(sc, A_SG_RSPQ_CREDIT_RETURN,
740 V_RSPQ(q->cntxt_id) | V_CREDITS(credits));
741}
742
743
744static void
745sge_timer_reclaim(void *arg, int ncount)
746{
739 adapter_t *sc = arg;
740 int i, nqsets = 0;
747 struct port_info *p = arg;
748 int i, nqsets = p->nqsets;
749 adapter_t *sc = p->adapter;
741 struct sge_qset *qs;
742 struct sge_txq *txq;
743 struct mtx *lock;
744 struct mbuf *m_vec[TX_CLEAN_MAX_DESC];
745 int n, reclaimable;
750 struct sge_qset *qs;
751 struct sge_txq *txq;
752 struct mtx *lock;
753 struct mbuf *m_vec[TX_CLEAN_MAX_DESC];
754 int n, reclaimable;
746 /*
747 * XXX assuming these quantities are allowed to change during operation
748 */
749 for (i = 0; i < sc->params.nports; i++)
750 nqsets += sc->port[i].nqsets;
751
752 for (i = 0; i < nqsets; i++) {
753 qs = &sc->sge.qs[i];
754 txq = &qs->txq[TXQ_ETH];
755 reclaimable = desc_reclaimable(txq);
756 if (reclaimable > 0) {
755
756 for (i = 0; i < nqsets; i++) {
757 qs = &sc->sge.qs[i];
758 txq = &qs->txq[TXQ_ETH];
759 reclaimable = desc_reclaimable(txq);
760 if (reclaimable > 0) {
757 mtx_lock(&txq->lock);
761 mtx_lock(&txq->lock);
758 n = reclaim_completed_tx(sc, txq, TX_CLEAN_MAX_DESC, m_vec);
759 mtx_unlock(&txq->lock);
760
762 n = reclaim_completed_tx(sc, txq, TX_CLEAN_MAX_DESC, m_vec);
763 mtx_unlock(&txq->lock);
764
761 for (i = 0; i < n; i++) {
765 for (i = 0; i < n; i++)
762 m_freem_vec(m_vec[i]);
766 m_freem_vec(m_vec[i]);
763 }
764 if (qs->port->ifp->if_drv_flags & IFF_DRV_OACTIVE &&
767
768 if (p->ifp->if_drv_flags & IFF_DRV_OACTIVE &&
765 txq->size - txq->in_use >= TX_START_MAX_DESC) {
769 txq->size - txq->in_use >= TX_START_MAX_DESC) {
766 qs->port->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
767 taskqueue_enqueue(qs->port->tq, &qs->port->start_task);
770 p->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
771 taskqueue_enqueue(p->tq, &p->start_task);
768 }
772 }
769 }
770
773 }
774
771 txq = &qs->txq[TXQ_OFLD];
772 reclaimable = desc_reclaimable(txq);
773 if (reclaimable > 0) {
774 mtx_lock(&txq->lock);
775 n = reclaim_completed_tx(sc, txq, TX_CLEAN_MAX_DESC, m_vec);
776 mtx_unlock(&txq->lock);
777
775 txq = &qs->txq[TXQ_OFLD];
776 reclaimable = desc_reclaimable(txq);
777 if (reclaimable > 0) {
778 mtx_lock(&txq->lock);
779 n = reclaim_completed_tx(sc, txq, TX_CLEAN_MAX_DESC, m_vec);
780 mtx_unlock(&txq->lock);
781
778 for (i = 0; i < n; i++) {
782 for (i = 0; i < n; i++)
779 m_freem_vec(m_vec[i]);
783 m_freem_vec(m_vec[i]);
780 }
781 }
782
783 lock = (sc->flags & USING_MSIX) ? &qs->rspq.lock :
784 &sc->sge.qs[0].rspq.lock;
785
786 if (mtx_trylock(lock)) {
787 /* XXX currently assume that we are *NOT* polling */
788 uint32_t status = t3_read_reg(sc, A_SG_RSPQ_FL_STATUS);

--- 355 unchanged lines hidden (view full) ---

1144 txd->flit[2] = 0;
1145 cntrl |= V_TXPKT_OPCODE(CPL_TX_PKT_LSO);
1146 hdr->cntrl = htonl(cntrl);
1147
1148 if (__predict_false(m0->m_len < TCPPKTHDRSIZE)) {
1149 pkthdr = &tmp[0];
1150 m_copydata(m0, 0, TCPPKTHDRSIZE, pkthdr);
1151 } else {
784 }
785
786 lock = (sc->flags & USING_MSIX) ? &qs->rspq.lock :
787 &sc->sge.qs[0].rspq.lock;
788
789 if (mtx_trylock(lock)) {
790 /* XXX currently assume that we are *NOT* polling */
791 uint32_t status = t3_read_reg(sc, A_SG_RSPQ_FL_STATUS);

--- 355 unchanged lines hidden (view full) ---

1147 txd->flit[2] = 0;
1148 cntrl |= V_TXPKT_OPCODE(CPL_TX_PKT_LSO);
1149 hdr->cntrl = htonl(cntrl);
1150
1151 if (__predict_false(m0->m_len < TCPPKTHDRSIZE)) {
1152 pkthdr = &tmp[0];
1153 m_copydata(m0, 0, TCPPKTHDRSIZE, pkthdr);
1154 } else {
1152 pkthdr = m0->m_data;
1155 pkthdr = mtod(m0, uint8_t *);
1153 }
1154
1155 if (__predict_false(m0->m_flags & M_VLANTAG)) {
1156 eth_type = CPL_ETH_II_VLAN;
1157 ip = (struct ip *)(pkthdr + ETHER_HDR_LEN +
1158 ETHER_VLAN_ENCAP_LEN);
1159 } else {
1160 eth_type = CPL_ETH_II;

--- 12 unchanged lines hidden (view full) ---

1173 cpl->cntrl = htonl(cntrl);
1174
1175 if (mlen <= WR_LEN - sizeof(*cpl)) {
1176 txq_prod(txq, 1, &txqs);
1177 txq->sdesc[txqs.pidx].m = m0;
1178 m_set_priority(m0, txqs.pidx);
1179
1180 if (m0->m_len == m0->m_pkthdr.len)
1156 }
1157
1158 if (__predict_false(m0->m_flags & M_VLANTAG)) {
1159 eth_type = CPL_ETH_II_VLAN;
1160 ip = (struct ip *)(pkthdr + ETHER_HDR_LEN +
1161 ETHER_VLAN_ENCAP_LEN);
1162 } else {
1163 eth_type = CPL_ETH_II;

--- 12 unchanged lines hidden (view full) ---

1176 cpl->cntrl = htonl(cntrl);
1177
1178 if (mlen <= WR_LEN - sizeof(*cpl)) {
1179 txq_prod(txq, 1, &txqs);
1180 txq->sdesc[txqs.pidx].m = m0;
1181 m_set_priority(m0, txqs.pidx);
1182
1183 if (m0->m_len == m0->m_pkthdr.len)
1181 memcpy(&txd->flit[2], m0->m_data, mlen);
1184 memcpy(&txd->flit[2], mtod(m0, uint8_t *), mlen);
1182 else
1183 m_copydata(m0, 0, mlen, (caddr_t)&txd->flit[2]);
1184
1185 flits = (mlen + 7) / 8 + 2;
1186 cpl->wr.wr_hi = htonl(V_WR_BCNTLFLT(mlen & 7) |
1187 V_WR_OP(FW_WROPCODE_TUNNEL_TX_PKT) |
1188 F_WR_SOP | F_WR_EOP | txqs.compl);
1189 wmb();

--- 148 unchanged lines hidden (view full) ---

1338 * Send a packet through an SGE control Tx queue. Packets sent through
1339 * a control queue must fit entirely as immediate data in a single Tx
1340 * descriptor and have no page fragments.
1341 */
1342static int
1343ctrl_xmit(adapter_t *adap, struct sge_txq *q, struct mbuf *m)
1344{
1345 int ret;
1185 else
1186 m_copydata(m0, 0, mlen, (caddr_t)&txd->flit[2]);
1187
1188 flits = (mlen + 7) / 8 + 2;
1189 cpl->wr.wr_hi = htonl(V_WR_BCNTLFLT(mlen & 7) |
1190 V_WR_OP(FW_WROPCODE_TUNNEL_TX_PKT) |
1191 F_WR_SOP | F_WR_EOP | txqs.compl);
1192 wmb();

--- 148 unchanged lines hidden (view full) ---

1341 * Send a packet through an SGE control Tx queue. Packets sent through
1342 * a control queue must fit entirely as immediate data in a single Tx
1343 * descriptor and have no page fragments.
1344 */
1345static int
1346ctrl_xmit(adapter_t *adap, struct sge_txq *q, struct mbuf *m)
1347{
1348 int ret;
1346 struct work_request_hdr *wrp = (struct work_request_hdr *)m->m_data;
1349 struct work_request_hdr *wrp = mtod(m, struct work_request_hdr *);
1347
1348 if (__predict_false(!immediate(m))) {
1349 m_freem(m);
1350 return 0;
1351 }
1352
1353 wrp->wr_hi |= htonl(F_WR_SOP | F_WR_EOP);
1354 wrp->wr_lo = htonl(V_WR_TID(q->token));

--- 187 unchanged lines hidden (view full) ---

1542 * if they are still running.
1543 */
1544void
1545t3_sge_stop(adapter_t *sc)
1546{
1547 int i;
1548 t3_set_reg_field(sc, A_SG_CONTROL, F_GLOBALENABLE, 0);
1549
1350
1351 if (__predict_false(!immediate(m))) {
1352 m_freem(m);
1353 return 0;
1354 }
1355
1356 wrp->wr_hi |= htonl(F_WR_SOP | F_WR_EOP);
1357 wrp->wr_lo = htonl(V_WR_TID(q->token));

--- 187 unchanged lines hidden (view full) ---

1545 * if they are still running.
1546 */
1547void
1548t3_sge_stop(adapter_t *sc)
1549{
1550 int i;
1551 t3_set_reg_field(sc, A_SG_CONTROL, F_GLOBALENABLE, 0);
1552
1553 if (sc->tq == NULL)
1554 return;
1555
1550 for (i = 0; i < SGE_QSETS; ++i) {
1551 struct sge_qset *qs = &sc->sge.qs[i];
1552
1553 taskqueue_drain(sc->tq, &qs->txq[TXQ_OFLD].qresume_tsk);
1554 taskqueue_drain(sc->tq, &qs->txq[TXQ_CTRL].qresume_tsk);
1555 }
1556}
1557

--- 542 unchanged lines hidden (view full) ---

2100 t3_free_qset(sc, q);
2101
2102 return (ret);
2103}
2104
2105void
2106t3_rx_eth(struct port_info *pi, struct sge_rspq *rq, struct mbuf *m, int ethpad)
2107{
1556 for (i = 0; i < SGE_QSETS; ++i) {
1557 struct sge_qset *qs = &sc->sge.qs[i];
1558
1559 taskqueue_drain(sc->tq, &qs->txq[TXQ_OFLD].qresume_tsk);
1560 taskqueue_drain(sc->tq, &qs->txq[TXQ_CTRL].qresume_tsk);
1561 }
1562}
1563

--- 542 unchanged lines hidden (view full) ---

2106 t3_free_qset(sc, q);
2107
2108 return (ret);
2109}
2110
2111void
2112t3_rx_eth(struct port_info *pi, struct sge_rspq *rq, struct mbuf *m, int ethpad)
2113{
2108 struct cpl_rx_pkt *cpl = (struct cpl_rx_pkt *)(m->m_data + ethpad);
2114 struct cpl_rx_pkt *cpl = (struct cpl_rx_pkt *)(mtod(m, uint8_t *) + ethpad);
2109 struct ifnet *ifp = pi->ifp;
2110
2115 struct ifnet *ifp = pi->ifp;
2116
2111 DPRINTF("rx_eth m=%p m->m_data=%p p->iff=%d\n", m, m->m_data, cpl->iff);
2117 DPRINTF("rx_eth m=%p m->m_data=%p p->iff=%d\n", m, mtod(m, uint8_t *), cpl->iff);
2112 if (&pi->adapter->port[cpl->iff] != pi)
2118 if (&pi->adapter->port[cpl->iff] != pi)
2113 panic("bad port index %d m->m_data=%p\n", cpl->iff, m->m_data);
2119 panic("bad port index %d m->m_data=%p\n", cpl->iff, mtod(m, uint8_t *));
2114
2115 if ((ifp->if_capenable & IFCAP_RXCSUM) && !cpl->fragment &&
2116 cpl->csum_valid && cpl->csum == 0xffff) {
2117 m->m_pkthdr.csum_flags = (CSUM_IP_CHECKED|CSUM_IP_VALID);
2118 rspq_to_qset(rq)->port_stats[SGE_PSTAT_RX_CSUM_GOOD]++;
2119 m->m_pkthdr.csum_flags = (CSUM_IP_CHECKED|CSUM_IP_VALID|CSUM_DATA_VALID|CSUM_PSEUDO_HDR);
2120 m->m_pkthdr.csum_data = 0xffff;
2121 }
2122 /*
2123 * XXX need to add VLAN support for 6.x
2124 */
2125#ifdef VLAN_SUPPORTED
2126 if (__predict_false(cpl->vlan_valid)) {
2127 m->m_pkthdr.ether_vtag = ntohs(cpl->vlan);
2128 m->m_flags |= M_VLANTAG;
2129 }
2130#endif
2131
2132 m->m_pkthdr.rcvif = ifp;
2120
2121 if ((ifp->if_capenable & IFCAP_RXCSUM) && !cpl->fragment &&
2122 cpl->csum_valid && cpl->csum == 0xffff) {
2123 m->m_pkthdr.csum_flags = (CSUM_IP_CHECKED|CSUM_IP_VALID);
2124 rspq_to_qset(rq)->port_stats[SGE_PSTAT_RX_CSUM_GOOD]++;
2125 m->m_pkthdr.csum_flags = (CSUM_IP_CHECKED|CSUM_IP_VALID|CSUM_DATA_VALID|CSUM_PSEUDO_HDR);
2126 m->m_pkthdr.csum_data = 0xffff;
2127 }
2128 /*
2129 * XXX need to add VLAN support for 6.x
2130 */
2131#ifdef VLAN_SUPPORTED
2132 if (__predict_false(cpl->vlan_valid)) {
2133 m->m_pkthdr.ether_vtag = ntohs(cpl->vlan);
2134 m->m_flags |= M_VLANTAG;
2135 }
2136#endif
2137
2138 m->m_pkthdr.rcvif = ifp;
2133 m->m_pkthdr.header = m->m_data + sizeof(*cpl) + ethpad;
2139 m->m_pkthdr.header = mtod(m, uint8_t *) + sizeof(*cpl) + ethpad;
2134 m_explode(m);
2135 /*
2136 * adjust after conversion to mbuf chain
2137 */
2138 m_adj(m, sizeof(*cpl) + ethpad);
2139
2140 (*ifp->if_input)(ifp, m);
2141}

--- 68 unchanged lines hidden (view full) ---

2210
2211done:
2212 if (++fl->cidx == fl->size)
2213 fl->cidx = 0;
2214
2215 return (ret);
2216}
2217
2140 m_explode(m);
2141 /*
2142 * adjust after conversion to mbuf chain
2143 */
2144 m_adj(m, sizeof(*cpl) + ethpad);
2145
2146 (*ifp->if_input)(ifp, m);
2147}

--- 68 unchanged lines hidden (view full) ---

2216
2217done:
2218 if (++fl->cidx == fl->size)
2219 fl->cidx = 0;
2220
2221 return (ret);
2222}
2223
2218
2219/**
2220 * handle_rsp_cntrl_info - handles control information in a response
2221 * @qs: the queue set corresponding to the response
2222 * @flags: the response control flags
2223 *
2224 * Handles the control information of an SGE response, such as GTS
2225 * indications and completion credits for the queue set's Tx queues.
2226 * HW coalesces credits, we don't do any extra SW coalescing.

--- 7 unchanged lines hidden (view full) ---

2234 if (flags & F_RSPD_TXQ0_GTS)
2235 clear_bit(TXQ_RUNNING, &qs->txq[TXQ_ETH].flags);
2236#endif
2237 credits = G_RSPD_TXQ0_CR(flags);
2238 if (credits) {
2239 qs->txq[TXQ_ETH].processed += credits;
2240 if (desc_reclaimable(&qs->txq[TXQ_ETH]) > TX_START_MAX_DESC)
2241 taskqueue_enqueue(qs->port->adapter->tq,
2224/**
2225 * handle_rsp_cntrl_info - handles control information in a response
2226 * @qs: the queue set corresponding to the response
2227 * @flags: the response control flags
2228 *
2229 * Handles the control information of an SGE response, such as GTS
2230 * indications and completion credits for the queue set's Tx queues.
2231 * HW coalesces credits, we don't do any extra SW coalescing.

--- 7 unchanged lines hidden (view full) ---

2239 if (flags & F_RSPD_TXQ0_GTS)
2240 clear_bit(TXQ_RUNNING, &qs->txq[TXQ_ETH].flags);
2241#endif
2242 credits = G_RSPD_TXQ0_CR(flags);
2243 if (credits) {
2244 qs->txq[TXQ_ETH].processed += credits;
2245 if (desc_reclaimable(&qs->txq[TXQ_ETH]) > TX_START_MAX_DESC)
2246 taskqueue_enqueue(qs->port->adapter->tq,
2242 &qs->port->adapter->timer_reclaim_task);
2247 &qs->port->timer_reclaim_task);
2243 }
2244
2245 credits = G_RSPD_TXQ2_CR(flags);
2246 if (credits)
2247 qs->txq[TXQ_CTRL].processed += credits;
2248
2249# if USE_GTS
2250 if (flags & F_RSPD_TXQ1_GTS)

--- 105 unchanged lines hidden (view full) ---

2356
2357 prefetch(r);
2358 if (++rspq->credits >= (rspq->size / 4)) {
2359 refill_rspq(adap, rspq, rspq->credits);
2360 rspq->credits = 0;
2361 }
2362
2363 if (eop) {
2248 }
2249
2250 credits = G_RSPD_TXQ2_CR(flags);
2251 if (credits)
2252 qs->txq[TXQ_CTRL].processed += credits;
2253
2254# if USE_GTS
2255 if (flags & F_RSPD_TXQ1_GTS)

--- 105 unchanged lines hidden (view full) ---

2361
2362 prefetch(r);
2363 if (++rspq->credits >= (rspq->size / 4)) {
2364 refill_rspq(adap, rspq, rspq->credits);
2365 rspq->credits = 0;
2366 }
2367
2368 if (eop) {
2364 prefetch(rspq->m->m_data);
2365 prefetch(rspq->m->m_data + L1_CACHE_BYTES);
2369 prefetch(mtod(rspq->m, uint8_t *));
2370 prefetch(mtod(rspq->m, uint8_t *) + L1_CACHE_BYTES);
2366
2367 if (eth) {
2368 t3_rx_eth_lro(adap, rspq, rspq->m, ethpad,
2369 rss_hash, rss_csum, lro);
2370
2371 rspq->m = NULL;
2372 } else {
2373 rspq->m->m_pkthdr.csum_data = rss_csum;

--- 9 unchanged lines hidden (view full) ---

2383 taskqueue_enqueue(adap->tq, &adap->timer_reclaim_task);
2384#else
2385 __refill_fl(adap, &qs->fl[0]);
2386 __refill_fl(adap, &qs->fl[1]);
2387#endif
2388 }
2389 --budget_left;
2390 }
2371
2372 if (eth) {
2373 t3_rx_eth_lro(adap, rspq, rspq->m, ethpad,
2374 rss_hash, rss_csum, lro);
2375
2376 rspq->m = NULL;
2377 } else {
2378 rspq->m->m_pkthdr.csum_data = rss_csum;

--- 9 unchanged lines hidden (view full) ---

2388 taskqueue_enqueue(adap->tq, &adap->timer_reclaim_task);
2389#else
2390 __refill_fl(adap, &qs->fl[0]);
2391 __refill_fl(adap, &qs->fl[1]);
2392#endif
2393 }
2394 --budget_left;
2395 }
2391
2392
2393 deliver_partial_bundle(&adap->tdev, rspq, offload_mbufs, ngathered);
2394 t3_lro_flush(adap, qs, &qs->lro);
2395
2396 if (sleeping)
2397 check_ring_db(adap, qs, sleeping);
2398
2399 smp_mb(); /* commit Tx queue processed updates */

--- 115 unchanged lines hidden (view full) ---

2515#ifndef LRO_WORKING
2516 return (0);
2517#endif
2518
2519 sc = arg1;
2520 enabled = sc->sge.qs[0].lro.enabled;
2521 err = sysctl_handle_int(oidp, &enabled, arg2, req);
2522
2396
2397 deliver_partial_bundle(&adap->tdev, rspq, offload_mbufs, ngathered);
2398 t3_lro_flush(adap, qs, &qs->lro);
2399
2400 if (sleeping)
2401 check_ring_db(adap, qs, sleeping);
2402
2403 smp_mb(); /* commit Tx queue processed updates */

--- 115 unchanged lines hidden (view full) ---

2519#ifndef LRO_WORKING
2520 return (0);
2521#endif
2522
2523 sc = arg1;
2524 enabled = sc->sge.qs[0].lro.enabled;
2525 err = sysctl_handle_int(oidp, &enabled, arg2, req);
2526
2523 if (err != 0) {
2527 if (err != 0)
2524 return (err);
2528 return (err);
2525 }
2526 if (enabled == sc->sge.qs[0].lro.enabled)
2527 return (0);
2528
2529 for (i = 0; i < sc->params.nports; i++)
2530 for (j = 0; j < sc->port[i].nqsets; j++)
2531 nqsets++;
2532
2529 if (enabled == sc->sge.qs[0].lro.enabled)
2530 return (0);
2531
2532 for (i = 0; i < sc->params.nports; i++)
2533 for (j = 0; j < sc->port[i].nqsets; j++)
2534 nqsets++;
2535
2533 for (i = 0; i < nqsets; i++) {
2536 for (i = 0; i < nqsets; i++)
2534 sc->sge.qs[i].lro.enabled = enabled;
2537 sc->sge.qs[i].lro.enabled = enabled;
2535 }
2536
2537 return (0);
2538}
2539
2540static int
2541t3_set_coalesce_nsecs(SYSCTL_HANDLER_ARGS)
2542{
2543 adapter_t *sc = arg1;

--- 122 unchanged lines hidden --- 		2538
2539 return (0);
2540}
2541
2542static int
2543t3_set_coalesce_nsecs(SYSCTL_HANDLER_ARGS)
2544{
2545 adapter_t *sc = arg1;

--- 122 unchanged lines hidden ---