Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband: (21 commits)
RDMA/nes: Update iw_nes version
RDMA/nes: Fix error path in nes_accept()
RDMA/nes: Fix hang issues for large cluster dynamic connections
RDMA/nes: Increase rexmit timeout interval
RDMA/nes: Check for sequence number wrap-around
RDMA/nes: Do not set apbvt entry for loopback
RDMA/nes: Fix unused variable compile warning when INFINIBAND_NES_DEBUG=n
RDMA/nes: Fix fw_ver in /sys
RDMA/nes: Set trace length to 1 inch for SFP_D
RDMA/nes: Enable repause timer for port 1
RDMA/nes: Correct CDR loop filter setting for port 1
RDMA/nes: Modify thermo mitigation to flip SerDes1 ref clk to internal
RDMA/nes: Fix resource issues in nes_create_cq() and nes_destroy_cq()
RDMA/nes: Remove root_256()'s unused pbl_count_256 parameter
mlx4_core: Fix memory leak in mlx4_enable_msi_x()
IB/mthca: Fix timeout for INIT_HCA and a few other commands
RDMA/cxgb3: Don't zero QP attrs when moving to IDLE
RDMA/nes: Fix bugs in nes_reg_phys_mr()
RDMA/nes: Fix compiler warning at nes_verbs.c:1955
IPoIB: Disable NAPI while CQ is being drained
...
+130
-95
+8
drivers/infiniband/hw/cxgb3/iwch_cm.c
+8
drivers/infiniband/hw/cxgb3/iwch_cm.c
···
1830
1830
ep->com.rpl_err = 0;
1831
1831
ep->ird = conn_param->ird;
1832
1832
ep->ord = conn_param->ord;
1833
+
1834
+
if (peer2peer && ep->ird == 0)
1835
+
ep->ird = 1;
1836
+
1833
1837
PDBG("%s %d ird %d ord %d\n", __func__, __LINE__, ep->ird, ep->ord);
1834
1838
1835
1839
get_ep(&ep->com);
···
1919
1915
conn_param->private_data, ep->plen);
1920
1916
ep->ird = conn_param->ird;
1921
1917
ep->ord = conn_param->ord;
1918
+
1919
+
if (peer2peer && ep->ord == 0)
1920
+
ep->ord = 1;
1921
+
1922
1922
ep->com.tdev = h->rdev.t3cdev_p;
1923
1923
1924
1924
cm_id->add_ref(cm_id);
-1
drivers/infiniband/hw/cxgb3/iwch_qp.c
-1
drivers/infiniband/hw/cxgb3/iwch_qp.c
+9
-7
drivers/infiniband/hw/mthca/mthca_cmd.c
+9
-7
drivers/infiniband/hw/mthca/mthca_cmd.c
···
157
157
enum {
158
158
CMD_TIME_CLASS_A = (HZ + 999) / 1000 + 1,
159
159
CMD_TIME_CLASS_B = (HZ + 99) / 100 + 1,
160
-
CMD_TIME_CLASS_C = (HZ + 9) / 10 + 1
160
+
CMD_TIME_CLASS_C = (HZ + 9) / 10 + 1,
161
+
CMD_TIME_CLASS_D = 60 * HZ
161
162
};
162
163
#else
163
164
enum {
164
165
CMD_TIME_CLASS_A = 60 * HZ,
165
166
CMD_TIME_CLASS_B = 60 * HZ,
166
-
CMD_TIME_CLASS_C = 60 * HZ
167
+
CMD_TIME_CLASS_C = 60 * HZ,
168
+
CMD_TIME_CLASS_D = 60 * HZ
167
169
};
168
170
#endif
169
171
···
600
598
u64 out;
601
599
int ret;
602
600
603
-
ret = mthca_cmd_imm(dev, 0, &out, 0, 0, CMD_SYS_EN, HZ, status);
601
+
ret = mthca_cmd_imm(dev, 0, &out, 0, 0, CMD_SYS_EN, CMD_TIME_CLASS_D, status);
604
602
605
603
if (*status == MTHCA_CMD_STAT_DDR_MEM_ERR)
606
604
mthca_warn(dev, "SYS_EN DDR error: syn=%x, sock=%d, "
···
613
611
614
612
int mthca_SYS_DIS(struct mthca_dev *dev, u8 *status)
615
613
{
616
-
return mthca_cmd(dev, 0, 0, 0, CMD_SYS_DIS, HZ, status);
614
+
return mthca_cmd(dev, 0, 0, 0, CMD_SYS_DIS, CMD_TIME_CLASS_C, status);
617
615
}
618
616
619
617
static int mthca_map_cmd(struct mthca_dev *dev, u16 op, struct mthca_icm *icm,
···
1392
1390
MTHCA_PUT(inbox, param->uarc_base, INIT_HCA_UAR_CTX_BASE_OFFSET);
1393
1391
}
1394
1392
1395
-
err = mthca_cmd(dev, mailbox->dma, 0, 0, CMD_INIT_HCA, HZ, status);
1393
+
err = mthca_cmd(dev, mailbox->dma, 0, 0, CMD_INIT_HCA, CMD_TIME_CLASS_D, status);
1396
1394
1397
1395
mthca_free_mailbox(dev, mailbox);
1398
1396
return err;
···
1452
1450
1453
1451
int mthca_CLOSE_IB(struct mthca_dev *dev, int port, u8 *status)
1454
1452
{
1455
-
return mthca_cmd(dev, 0, port, 0, CMD_CLOSE_IB, HZ, status);
1453
+
return mthca_cmd(dev, 0, port, 0, CMD_CLOSE_IB, CMD_TIME_CLASS_A, status);
1456
1454
}
1457
1455
1458
1456
int mthca_CLOSE_HCA(struct mthca_dev *dev, int panic, u8 *status)
1459
1457
{
1460
-
return mthca_cmd(dev, 0, 0, panic, CMD_CLOSE_HCA, HZ, status);
1458
+
return mthca_cmd(dev, 0, 0, panic, CMD_CLOSE_HCA, CMD_TIME_CLASS_C, status);
1461
1459
}
1462
1460
1463
1461
int mthca_SET_IB(struct mthca_dev *dev, struct mthca_set_ib_param *param,
+1
-3
drivers/infiniband/hw/nes/nes.h
+1
-3
drivers/infiniband/hw/nes/nes.h
+42
-42
drivers/infiniband/hw/nes/nes_cm.c
+42
-42
drivers/infiniband/hw/nes/nes_cm.c
···
56
56
#include <net/neighbour.h>
57
57
#include <net/route.h>
58
58
#include <net/ip_fib.h>
59
+
#include <net/tcp.h>
59
60
60
61
#include "nes.h"
61
62
···
541
540
struct list_head *list_node;
542
541
struct nes_cm_core *cm_core = g_cm_core;
543
542
u32 settimer = 0;
543
+
unsigned long timetosend;
544
544
int ret = NETDEV_TX_OK;
545
545
546
546
struct list_head timer_list;
···
646
644
send_entry->retrycount);
647
645
if (send_entry->send_retrans) {
648
646
send_entry->retranscount--;
647
+
timetosend = (NES_RETRY_TIMEOUT <<
648
+
(NES_DEFAULT_RETRANS - send_entry->retranscount));
649
+
649
650
send_entry->timetosend = jiffies +
650
-
NES_RETRY_TIMEOUT;
651
+
min(timetosend, NES_MAX_TIMEOUT);
651
652
if (nexttimeout > send_entry->timetosend ||
652
653
!settimer) {
653
654
nexttimeout = send_entry->timetosend;
···
859
854
{
860
855
unsigned long flags;
861
856
struct nes_cm_listener *listen_node;
862
-
__be32 tmp_addr = cpu_to_be32(dst_addr);
863
857
864
858
/* walk list and find cm_node associated with this session ID */
865
859
spin_lock_irqsave(&cm_core->listen_list_lock, flags);
···
874
870
}
875
871
}
876
872
spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
877
-
878
-
nes_debug(NES_DBG_CM, "Unable to find listener for %pI4:%x\n",
879
-
&tmp_addr, dst_port);
880
873
881
874
/* no listener */
882
875
return NULL;
···
1326
1325
nes_debug(NES_DBG_CM, "Received FIN, cm_node = %p, state = %u. "
1327
1326
"refcnt=%d\n", cm_node, cm_node->state,
1328
1327
atomic_read(&cm_node->ref_count));
1329
-
cm_node->tcp_cntxt.rcv_nxt++;
1330
-
cleanup_retrans_entry(cm_node);
1331
1328
switch (cm_node->state) {
1332
1329
case NES_CM_STATE_SYN_RCVD:
1333
1330
case NES_CM_STATE_SYN_SENT:
1334
1331
case NES_CM_STATE_ESTABLISHED:
1335
1332
case NES_CM_STATE_MPAREQ_SENT:
1336
1333
case NES_CM_STATE_MPAREJ_RCVD:
1334
+
cm_node->tcp_cntxt.rcv_nxt++;
1335
+
cleanup_retrans_entry(cm_node);
1337
1336
cm_node->state = NES_CM_STATE_LAST_ACK;
1338
1337
send_fin(cm_node, NULL);
1339
1338
break;
1340
1339
case NES_CM_STATE_FIN_WAIT1:
1340
+
cm_node->tcp_cntxt.rcv_nxt++;
1341
+
cleanup_retrans_entry(cm_node);
1341
1342
cm_node->state = NES_CM_STATE_CLOSING;
1342
1343
send_ack(cm_node, NULL);
1343
1344
/* Wait for ACK as this is simultanous close..
···
1347
1344
* Just rm the node.. Done.. */
1348
1345
break;
1349
1346
case NES_CM_STATE_FIN_WAIT2:
1347
+
cm_node->tcp_cntxt.rcv_nxt++;
1348
+
cleanup_retrans_entry(cm_node);
1350
1349
cm_node->state = NES_CM_STATE_TIME_WAIT;
1351
1350
send_ack(cm_node, NULL);
1352
1351
schedule_nes_timer(cm_node, NULL, NES_TIMER_TYPE_CLOSE, 1, 0);
1353
1352
break;
1354
1353
case NES_CM_STATE_TIME_WAIT:
1354
+
cm_node->tcp_cntxt.rcv_nxt++;
1355
+
cleanup_retrans_entry(cm_node);
1355
1356
cm_node->state = NES_CM_STATE_CLOSED;
1356
1357
rem_ref_cm_node(cm_node->cm_core, cm_node);
1357
1358
break;
···
1391
1384
passive_state = atomic_add_return(1, &cm_node->passive_state);
1392
1385
if (passive_state == NES_SEND_RESET_EVENT)
1393
1386
create_event(cm_node, NES_CM_EVENT_RESET);
1394
-
cleanup_retrans_entry(cm_node);
1395
1387
cm_node->state = NES_CM_STATE_CLOSED;
1396
1388
dev_kfree_skb_any(skb);
1397
1389
break;
···
1404
1398
active_open_err(cm_node, skb, reset);
1405
1399
break;
1406
1400
case NES_CM_STATE_CLOSED:
1407
-
cleanup_retrans_entry(cm_node);
1408
1401
drop_packet(skb);
1409
1402
break;
1403
+
case NES_CM_STATE_LAST_ACK:
1404
+
cm_node->cm_id->rem_ref(cm_node->cm_id);
1410
1405
case NES_CM_STATE_TIME_WAIT:
1411
-
cleanup_retrans_entry(cm_node);
1412
1406
cm_node->state = NES_CM_STATE_CLOSED;
1413
1407
rem_ref_cm_node(cm_node->cm_core, cm_node);
1414
1408
drop_packet(skb);
1415
1409
break;
1416
1410
case NES_CM_STATE_FIN_WAIT1:
1417
-
cleanup_retrans_entry(cm_node);
1418
1411
nes_debug(NES_DBG_CM, "Bad state %s[%u]\n", __func__, __LINE__);
1419
1412
default:
1420
1413
drop_packet(skb);
···
1460
1455
NES_PASSIVE_STATE_INDICATED);
1461
1456
break;
1462
1457
case NES_CM_STATE_MPAREQ_SENT:
1458
+
cleanup_retrans_entry(cm_node);
1463
1459
if (res_type == NES_MPA_REQUEST_REJECT) {
1464
1460
type = NES_CM_EVENT_MPA_REJECT;
1465
1461
cm_node->state = NES_CM_STATE_MPAREJ_RCVD;
···
1524
1518
rcv_wnd = cm_node->tcp_cntxt.rcv_wnd;
1525
1519
if (ack_seq != loc_seq_num)
1526
1520
err = 1;
1527
-
else if ((seq + rcv_wnd) < rcv_nxt)
1521
+
else if (!between(seq, rcv_nxt, (rcv_nxt+rcv_wnd)))
1528
1522
err = 1;
1529
1523
if (err) {
1530
1524
nes_debug(NES_DBG_CM, "%s[%u] create abort for cm_node=%p "
···
1658
1652
}
1659
1653
}
1660
1654
1661
-
static void handle_ack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
1655
+
static int handle_ack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
1662
1656
struct tcphdr *tcph)
1663
1657
{
1664
1658
int datasize = 0;
1665
1659
u32 inc_sequence;
1666
1660
u32 rem_seq_ack;
1667
1661
u32 rem_seq;
1668
-
int ret;
1662
+
int ret = 0;
1669
1663
int optionsize;
1670
1664
optionsize = (tcph->doff << 2) - sizeof(struct tcphdr);
1671
1665
1672
1666
if (check_seq(cm_node, tcph, skb))
1673
-
return;
1667
+
return -EINVAL;
1674
1668
1675
1669
skb_pull(skb, tcph->doff << 2);
1676
1670
inc_sequence = ntohl(tcph->seq);
1677
1671
rem_seq = ntohl(tcph->seq);
1678
1672
rem_seq_ack = ntohl(tcph->ack_seq);
1679
1673
datasize = skb->len;
1680
-
cleanup_retrans_entry(cm_node);
1681
1674
switch (cm_node->state) {
1682
1675
case NES_CM_STATE_SYN_RCVD:
1683
1676
/* Passive OPEN */
1677
+
cleanup_retrans_entry(cm_node);
1684
1678
ret = handle_tcp_options(cm_node, tcph, skb, optionsize, 1);
1685
1679
if (ret)
1686
1680
break;
1687
1681
cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
1688
-
if (cm_node->tcp_cntxt.rem_ack_num !=
1689
-
cm_node->tcp_cntxt.loc_seq_num) {
1690
-
nes_debug(NES_DBG_CM, "rem_ack_num != loc_seq_num\n");
1691
-
cleanup_retrans_entry(cm_node);
1692
-
send_reset(cm_node, skb);
1693
-
return;
1694
-
}
1695
1682
cm_node->state = NES_CM_STATE_ESTABLISHED;
1696
-
cleanup_retrans_entry(cm_node);
1697
1683
if (datasize) {
1698
1684
cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
1699
1685
handle_rcv_mpa(cm_node, skb);
1700
-
} else { /* rcvd ACK only */
1686
+
} else /* rcvd ACK only */
1701
1687
dev_kfree_skb_any(skb);
1702
-
cleanup_retrans_entry(cm_node);
1703
-
}
1704
1688
break;
1705
1689
case NES_CM_STATE_ESTABLISHED:
1706
1690
/* Passive OPEN */
···
1702
1706
drop_packet(skb);
1703
1707
break;
1704
1708
case NES_CM_STATE_MPAREQ_SENT:
1705
-
cleanup_retrans_entry(cm_node);
1706
1709
cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
1707
1710
if (datasize) {
1708
1711
cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
1709
1712
handle_rcv_mpa(cm_node, skb);
1710
-
} else { /* Could be just an ack pkt.. */
1711
-
cleanup_retrans_entry(cm_node);
1713
+
} else /* Could be just an ack pkt.. */
1712
1714
dev_kfree_skb_any(skb);
1713
-
}
1714
1715
break;
1715
1716
case NES_CM_STATE_LISTENING:
1716
1717
case NES_CM_STATE_CLOSED:
···
1715
1722
send_reset(cm_node, skb);
1716
1723
break;
1717
1724
case NES_CM_STATE_LAST_ACK:
1725
+
case NES_CM_STATE_CLOSING:
1718
1726
cleanup_retrans_entry(cm_node);
1719
1727
cm_node->state = NES_CM_STATE_CLOSED;
1720
1728
cm_node->cm_id->rem_ref(cm_node->cm_id);
1721
-
case NES_CM_STATE_CLOSING:
1722
-
cleanup_retrans_entry(cm_node);
1723
1729
rem_ref_cm_node(cm_node->cm_core, cm_node);
1724
1730
drop_packet(skb);
1725
1731
break;
···
1733
1741
case NES_CM_STATE_MPAREQ_RCVD:
1734
1742
case NES_CM_STATE_UNKNOWN:
1735
1743
default:
1744
+
cleanup_retrans_entry(cm_node);
1736
1745
drop_packet(skb);
1737
1746
break;
1738
1747
}
1748
+
return ret;
1739
1749
}
1740
1750
1741
1751
···
1843
1849
enum nes_tcpip_pkt_type pkt_type = NES_PKT_TYPE_UNKNOWN;
1844
1850
struct tcphdr *tcph = tcp_hdr(skb);
1845
1851
u32 fin_set = 0;
1852
+
int ret = 0;
1846
1853
skb_pull(skb, ip_hdr(skb)->ihl << 2);
1847
1854
1848
1855
nes_debug(NES_DBG_CM, "process_packet: cm_node=%p state =%d syn=%d "
···
1869
1874
handle_synack_pkt(cm_node, skb, tcph);
1870
1875
break;
1871
1876
case NES_PKT_TYPE_ACK:
1872
-
handle_ack_pkt(cm_node, skb, tcph);
1873
-
if (fin_set)
1877
+
ret = handle_ack_pkt(cm_node, skb, tcph);
1878
+
if (fin_set && !ret)
1874
1879
handle_fin_pkt(cm_node);
1875
1880
break;
1876
1881
case NES_PKT_TYPE_RST:
1877
1882
handle_rst_pkt(cm_node, skb, tcph);
1878
1883
break;
1879
1884
default:
1880
-
drop_packet(skb);
1881
-
if (fin_set)
1885
+
if ((fin_set) && (!check_seq(cm_node, tcph, skb)))
1882
1886
handle_fin_pkt(cm_node);
1887
+
drop_packet(skb);
1883
1888
break;
1884
1889
}
1885
1890
}
···
2705
2710
/* associate the node with the QP */
2706
2711
nesqp->cm_node = (void *)cm_node;
2707
2712
cm_node->nesqp = nesqp;
2708
-
nes_add_ref(&nesqp->ibqp);
2709
2713
2710
2714
nes_debug(NES_DBG_CM, "QP%u, cm_node=%p, jiffies = %lu listener = %p\n",
2711
2715
nesqp->hwqp.qp_id, cm_node, jiffies, cm_node->listener);
···
2757
2763
nes_debug(NES_DBG_CM, "Unable to register memory region"
2758
2764
"for lSMM for cm_node = %p \n",
2759
2765
cm_node);
2766
+
pci_free_consistent(nesdev->pcidev,
2767
+
nesqp->private_data_len+sizeof(struct ietf_mpa_frame),
2768
+
nesqp->ietf_frame, nesqp->ietf_frame_pbase);
2760
2769
return -ENOMEM;
2761
2770
}
2762
2771
···
2876
2879
2877
2880
/* notify OF layer that accept event was successful */
2878
2881
cm_id->add_ref(cm_id);
2882
+
nes_add_ref(&nesqp->ibqp);
2879
2883
2880
2884
cm_event.event = IW_CM_EVENT_ESTABLISHED;
2881
2885
cm_event.status = IW_CM_EVENT_STATUS_ACCEPTED;
···
2957
2959
struct nes_device *nesdev;
2958
2960
struct nes_cm_node *cm_node;
2959
2961
struct nes_cm_info cm_info;
2962
+
int apbvt_set = 0;
2960
2963
2961
2964
ibqp = nes_get_qp(cm_id->device, conn_param->qpn);
2962
2965
if (!ibqp)
···
2995
2996
conn_param->private_data_len);
2996
2997
2997
2998
if (cm_id->local_addr.sin_addr.s_addr !=
2998
-
cm_id->remote_addr.sin_addr.s_addr)
2999
+
cm_id->remote_addr.sin_addr.s_addr) {
2999
3000
nes_manage_apbvt(nesvnic, ntohs(cm_id->local_addr.sin_port),
3000
3001
PCI_FUNC(nesdev->pcidev->devfn), NES_MANAGE_APBVT_ADD);
3002
+
apbvt_set = 1;
3003
+
}
3001
3004
3002
3005
/* set up the connection params for the node */
3003
3006
cm_info.loc_addr = htonl(cm_id->local_addr.sin_addr.s_addr);
···
3016
3015
conn_param->private_data_len, (void *)conn_param->private_data,
3017
3016
&cm_info);
3018
3017
if (!cm_node) {
3019
-
if (cm_id->local_addr.sin_addr.s_addr !=
3020
-
cm_id->remote_addr.sin_addr.s_addr)
3018
+
if (apbvt_set)
3021
3019
nes_manage_apbvt(nesvnic, ntohs(cm_id->local_addr.sin_port),
3022
3020
PCI_FUNC(nesdev->pcidev->devfn),
3023
3021
NES_MANAGE_APBVT_DEL);
···
3025
3025
return -ENOMEM;
3026
3026
}
3027
3027
3028
-
cm_node->apbvt_set = 1;
3028
+
cm_node->apbvt_set = apbvt_set;
3029
3029
nesqp->cm_node = cm_node;
3030
3030
cm_node->nesqp = nesqp;
3031
3031
nes_add_ref(&nesqp->ibqp);
+1
drivers/infiniband/hw/nes/nes_cm.h
+1
drivers/infiniband/hw/nes/nes_cm.h
+18
-12
drivers/infiniband/hw/nes/nes_hw.c
+18
-12
drivers/infiniband/hw/nes/nes_hw.c
···
550
550
msleep(1);
551
551
}
552
552
if (int_cnt > 1) {
553
-
u32 sds;
554
553
spin_lock_irqsave(&nesadapter->phy_lock, flags);
555
-
sds = nes_read_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1);
556
-
sds |= 0x00000040;
557
-
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1, sds);
554
+
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1, 0x0000F0C8);
558
555
mh_detected++;
559
556
reset_value = nes_read32(nesdev->regs+NES_SOFTWARE_RESET);
560
557
reset_value |= 0x0000003d;
···
576
579
if (++ext_cnt > int_cnt) {
577
580
spin_lock_irqsave(&nesadapter->phy_lock, flags);
578
581
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1,
579
-
0x0000F0C8);
582
+
0x0000F088);
580
583
mh_detected++;
581
584
reset_value = nes_read32(nesdev->regs+NES_SOFTWARE_RESET);
582
585
reset_value |= 0x0000003d;
···
761
764
return 0;
762
765
763
766
/* init serdes 1 */
767
+
if (!(OneG_Mode && (nesadapter->phy_type[1] != NES_PHY_TYPE_PUMA_1G)))
768
+
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_CDR_CONTROL1, 0x000000FF);
769
+
764
770
switch (nesadapter->phy_type[1]) {
765
771
case NES_PHY_TYPE_ARGUS:
766
772
case NES_PHY_TYPE_SFP_D:
···
771
771
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_TX_EMP1, 0x00000000);
772
772
break;
773
773
case NES_PHY_TYPE_CX4:
774
-
sds = nes_read_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1);
775
-
sds &= 0xFFFFFFBF;
776
-
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1, sds);
777
774
if (wide_ppm_offset)
778
775
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_CDR_CONTROL1, 0x000FFFAA);
779
-
else
780
-
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_CDR_CONTROL1, 0x000000FF);
781
776
break;
782
777
case NES_PHY_TYPE_PUMA_1G:
783
778
sds = nes_read_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1);
784
779
sds |= 0x000000100;
785
780
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1, sds);
786
781
}
787
-
if (!OneG_Mode)
782
+
if (!OneG_Mode) {
788
783
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_TX_HIGHZ_LANE_MODE1, 0x11110000);
784
+
sds = nes_read_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1);
785
+
sds &= 0xFFFFFFBF;
786
+
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1, sds);
787
+
}
789
788
} else {
790
789
/* init serdes 0 */
791
790
nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL0, 0x00000008);
···
912
913
u32temp &= 0x7fffffff;
913
914
u32temp |= 0x7fff0010;
914
915
nes_write_indexed(nesdev, 0x000021f8, u32temp);
916
+
if (port_count > 1) {
917
+
u32temp = nes_read_indexed(nesdev, 0x000023f8);
918
+
u32temp &= 0x7fffffff;
919
+
u32temp |= 0x7fff0010;
920
+
nes_write_indexed(nesdev, 0x000023f8, u32temp);
921
+
}
915
922
}
916
923
}
917
924
···
1371
1366
if (phy_type == NES_PHY_TYPE_ARGUS) {
1372
1367
nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc302, 0x000C);
1373
1368
nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc319, 0x0008);
1369
+
nes_write_10G_phy_reg(nesdev, phy_index, 0x3, 0x0027, 0x0001);
1374
1370
} else {
1375
1371
nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc302, 0x0004);
1376
1372
nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc319, 0x0038);
1373
+
nes_write_10G_phy_reg(nesdev, phy_index, 0x3, 0x0027, 0x0013);
1377
1374
}
1378
1375
nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc31a, 0x0098);
1379
1376
nes_write_10G_phy_reg(nesdev, phy_index, 0x3, 0x0026, 0x0E00);
1380
-
nes_write_10G_phy_reg(nesdev, phy_index, 0x3, 0x0027, 0x0001);
1381
1377
1382
1378
/* setup LEDs */
1383
1379
nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xd006, 0x0007);
+44
-23
drivers/infiniband/hw/nes/nes_verbs.c
+44
-23
drivers/infiniband/hw/nes/nes_verbs.c
···
1627
1627
nescq->hw_cq.cq_number = nes_ucontext->mcrqf & 0xffff;
1628
1628
else
1629
1629
nescq->hw_cq.cq_number = nesvnic->mcrq_qp_id + nes_ucontext->mcrqf-1;
1630
+
nescq->mcrqf = nes_ucontext->mcrqf;
1630
1631
nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1631
1632
}
1632
1633
nes_debug(NES_DBG_CQ, "CQ Virtual Address = %08lX, size = %u.\n",
···
1683
1682
if (!context)
1684
1683
pci_free_consistent(nesdev->pcidev, nescq->cq_mem_size, mem,
1685
1684
nescq->hw_cq.cq_pbase);
1685
+
else {
1686
+
pci_free_consistent(nesdev->pcidev, nespbl->pbl_size,
1687
+
nespbl->pbl_vbase, nespbl->pbl_pbase);
1688
+
kfree(nespbl);
1689
+
}
1690
+
1686
1691
nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1687
1692
kfree(nescq);
1688
1693
return ERR_PTR(-ENOMEM);
···
1712
1705
if (!context)
1713
1706
pci_free_consistent(nesdev->pcidev, nescq->cq_mem_size, mem,
1714
1707
nescq->hw_cq.cq_pbase);
1708
+
else {
1709
+
pci_free_consistent(nesdev->pcidev, nespbl->pbl_size,
1710
+
nespbl->pbl_vbase, nespbl->pbl_pbase);
1711
+
kfree(nespbl);
1712
+
}
1715
1713
nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1716
1714
kfree(nescq);
1717
1715
return ERR_PTR(-ENOMEM);
···
1734
1722
if (!context)
1735
1723
pci_free_consistent(nesdev->pcidev, nescq->cq_mem_size, mem,
1736
1724
nescq->hw_cq.cq_pbase);
1725
+
else {
1726
+
pci_free_consistent(nesdev->pcidev, nespbl->pbl_size,
1727
+
nespbl->pbl_vbase, nespbl->pbl_pbase);
1728
+
kfree(nespbl);
1729
+
}
1737
1730
nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1738
1731
kfree(nescq);
1739
1732
return ERR_PTR(-ENOMEM);
···
1791
1774
if (!context)
1792
1775
pci_free_consistent(nesdev->pcidev, nescq->cq_mem_size, mem,
1793
1776
nescq->hw_cq.cq_pbase);
1777
+
else {
1778
+
pci_free_consistent(nesdev->pcidev, nespbl->pbl_size,
1779
+
nespbl->pbl_vbase, nespbl->pbl_pbase);
1780
+
kfree(nespbl);
1781
+
}
1794
1782
nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1795
1783
kfree(nescq);
1796
1784
return ERR_PTR(-EIO);
···
1877
1855
set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_OPCODE_IDX, opcode);
1878
1856
set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_ID_IDX,
1879
1857
(nescq->hw_cq.cq_number | ((u32)PCI_FUNC(nesdev->pcidev->devfn) << 16)));
1880
-
nes_free_resource(nesadapter, nesadapter->allocated_cqs, nescq->hw_cq.cq_number);
1858
+
if (!nescq->mcrqf)
1859
+
nes_free_resource(nesadapter, nesadapter->allocated_cqs, nescq->hw_cq.cq_number);
1860
+
1881
1861
atomic_set(&cqp_request->refcount, 2);
1882
1862
nes_post_cqp_request(nesdev, cqp_request);
1883
1863
···
1919
1895
static u32 root_256(struct nes_device *nesdev,
1920
1896
struct nes_root_vpbl *root_vpbl,
1921
1897
struct nes_root_vpbl *new_root,
1922
-
u16 pbl_count_4k,
1923
-
u16 pbl_count_256)
1898
+
u16 pbl_count_4k)
1924
1899
{
1925
1900
u64 leaf_pbl;
1926
1901
int i, j, k;
···
1975
1952
int ret;
1976
1953
struct nes_adapter *nesadapter = nesdev->nesadapter;
1977
1954
uint pg_cnt = 0;
1978
-
u16 pbl_count_256;
1955
+
u16 pbl_count_256 = 0;
1979
1956
u16 pbl_count = 0;
1980
1957
u8 use_256_pbls = 0;
1981
1958
u8 use_4k_pbls = 0;
···
2035
2012
}
2036
2013
2037
2014
if (use_256_pbls && use_two_level) {
2038
-
if (root_256(nesdev, root_vpbl, &new_root, pbl_count_4k, pbl_count_256) == 1) {
2015
+
if (root_256(nesdev, root_vpbl, &new_root, pbl_count_4k) == 1) {
2039
2016
if (new_root.pbl_pbase != 0)
2040
2017
root_vpbl = &new_root;
2041
2018
} else {
···
2145
2122
struct nes_root_vpbl root_vpbl;
2146
2123
u32 stag;
2147
2124
u32 i;
2125
+
unsigned long mask;
2148
2126
u32 stag_index = 0;
2149
2127
u32 next_stag_index = 0;
2150
2128
u32 driver_key = 0;
···
2173
2149
if (num_phys_buf > (1024*512)) {
2174
2150
return ERR_PTR(-E2BIG);
2175
2151
}
2152
+
2153
+
if ((buffer_list[0].addr ^ *iova_start) & ~PAGE_MASK)
2154
+
return ERR_PTR(-EINVAL);
2176
2155
2177
2156
err = nes_alloc_resource(nesadapter, nesadapter->allocated_mrs, nesadapter->max_mr,
2178
2157
&stag_index, &next_stag_index);
···
2242
2215
root_pbl_index++;
2243
2216
cur_pbl_index = 0;
2244
2217
}
2245
-
if (buffer_list[i].addr & ~PAGE_MASK) {
2246
-
/* TODO: Unwind allocated buffers */
2247
-
nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
2248
-
nes_debug(NES_DBG_MR, "Unaligned Memory Buffer: 0x%x\n",
2249
-
(unsigned int) buffer_list[i].addr);
2250
-
ibmr = ERR_PTR(-EINVAL);
2251
-
kfree(nesmr);
2252
-
goto reg_phys_err;
2253
-
}
2254
2218
2255
-
if (!buffer_list[i].size) {
2219
+
mask = !buffer_list[i].size;
2220
+
if (i != 0)
2221
+
mask |= buffer_list[i].addr;
2222
+
if (i != num_phys_buf - 1)
2223
+
mask |= buffer_list[i].addr + buffer_list[i].size;
2224
+
2225
+
if (mask & ~PAGE_MASK) {
2256
2226
nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
2257
-
nes_debug(NES_DBG_MR, "Invalid Buffer Size\n");
2227
+
nes_debug(NES_DBG_MR, "Invalid buffer addr or size\n");
2258
2228
ibmr = ERR_PTR(-EINVAL);
2259
2229
kfree(nesmr);
2260
2230
goto reg_phys_err;
···
2262
2238
if ((buffer_list[i-1].addr+PAGE_SIZE) != buffer_list[i].addr)
2263
2239
single_page = 0;
2264
2240
}
2265
-
vpbl.pbl_vbase[cur_pbl_index].pa_low = cpu_to_le32((u32)buffer_list[i].addr);
2241
+
vpbl.pbl_vbase[cur_pbl_index].pa_low = cpu_to_le32((u32)buffer_list[i].addr & PAGE_MASK);
2266
2242
vpbl.pbl_vbase[cur_pbl_index++].pa_high =
2267
2243
cpu_to_le32((u32)((((u64)buffer_list[i].addr) >> 32)));
2268
2244
}
···
2274
2250
nes_debug(NES_DBG_MR, "Registering STag 0x%08X, VA = 0x%016lX,"
2275
2251
" length = 0x%016lX, index = 0x%08X\n",
2276
2252
stag, (unsigned long)*iova_start, (unsigned long)region_length, stag_index);
2277
-
2278
-
region_length -= (*iova_start)&PAGE_MASK;
2279
2253
2280
2254
/* Make the leaf PBL the root if only one PBL */
2281
2255
if (root_pbl_index == 1) {
···
2808
2786
struct nes_vnic *nesvnic = nesibdev->nesvnic;
2809
2787
2810
2788
nes_debug(NES_DBG_INIT, "\n");
2811
-
return sprintf(buf, "%x.%x.%x\n",
2812
-
(int)(nesvnic->nesdev->nesadapter->fw_ver >> 32),
2813
-
(int)(nesvnic->nesdev->nesadapter->fw_ver >> 16) & 0xffff,
2814
-
(int)(nesvnic->nesdev->nesadapter->fw_ver & 0xffff));
2789
+
return sprintf(buf, "%u.%u\n",
2790
+
(nesvnic->nesdev->nesadapter->firmware_version >> 16),
2791
+
(nesvnic->nesdev->nesadapter->firmware_version & 0x000000ff));
2815
2792
}
2816
2793
2817
2794
+1
drivers/infiniband/hw/nes/nes_verbs.h
+1
drivers/infiniband/hw/nes/nes_verbs.h
+4
-2
drivers/infiniband/ulp/ipoib/ipoib_ib.c
+4
-2
drivers/infiniband/ulp/ipoib/ipoib_ib.c
···
685
685
queue_delayed_work(ipoib_workqueue, &priv->ah_reap_task,
686
686
round_jiffies_relative(HZ));
687
687
688
-
set_bit(IPOIB_FLAG_INITIALIZED, &priv->flags);
688
+
if (!test_and_set_bit(IPOIB_FLAG_INITIALIZED, &priv->flags))
689
+
napi_enable(&priv->napi);
689
690
690
691
return 0;
691
692
}
···
805
804
struct ipoib_tx_buf *tx_req;
806
805
int i;
807
806
808
-
clear_bit(IPOIB_FLAG_INITIALIZED, &priv->flags);
807
+
if (test_and_clear_bit(IPOIB_FLAG_INITIALIZED, &priv->flags))
808
+
napi_disable(&priv->napi);
809
809
810
810
ipoib_cm_dev_stop(dev);
811
811
+1
-4
drivers/infiniband/ulp/ipoib/ipoib_main.c
+1
-4
drivers/infiniband/ulp/ipoib/ipoib_main.c
···
106
106
107
107
ipoib_dbg(priv, "bringing up interface\n");
108
108
109
-
if (!test_and_set_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags))
110
-
napi_enable(&priv->napi);
109
+
set_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags);
111
110
112
111
if (ipoib_pkey_dev_delay_open(dev))
113
112
return 0;
···
142
143
ipoib_ib_dev_stop(dev, 1);
143
144
144
145
err_disable:
145
-
napi_disable(&priv->napi);
146
146
clear_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags);
147
147
148
148
return -EINVAL;
···
154
156
ipoib_dbg(priv, "stopping interface\n");
155
157
156
158
clear_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags);
157
-
napi_disable(&priv->napi);
158
159
159
160
netif_stop_queue(dev);
160
161