1678705320

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/OPAE/opae-sdk/commit/<a class=hub.com/OPAE/opae-sdk/commit/59006520a918e7d1f7b94e1aca6a8429c20542a8">59006520a<a href="https://github.com/OPAE/opae-sdk/commit/59006520a918e7d1f7b94e1aca6a8429c20542a8">">Merge </a><a class="double-link" href="https://github.com/OPAE/opae-sdk/commit/<a class="double-link" href="https://github.com/OPAE/opae-sdk/commit/246ecd98be2895fdf09ed1982ade4627fbe04307">246ecd98b</a>">246ecd98b</a><a href="https://github.com/OPAE/opae-sdk/commit/59006520a918e7d1f7b94e1aca6a8429c20542a8"> into db21274dd">db21274dd</a>

Pull Request Pull Request #2452: hssi: 100G: revert recent changes back to a known good config

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

11100 of 18218 relevant lines covered (60.93%)

12743.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/samples/hssi/hssi_100g_cmd.h

// Copyright(c) 2020-2021, Intel Corporation
//
// Redistribution  and  use  in source  and  binary  forms,  with  or  without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of  source code  must retain the  above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
// * Neither the name  of Intel Corporation  nor the names of its contributors
//   may be used to  endorse or promote  products derived  from this  software
//   without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE
// IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT OWNER  OR CONTRIBUTORS BE
// LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR
// CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT LIMITED  TO,  PROCUREMENT  OF
// SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA, OR PROFITS;  OR BUSINESS
// INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY  OF LIABILITY,  WHETHER IN
// CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
#pragma once
#include "hssi_cmd.h"

#define CSR_SCRATCH     0x1000
#define CSR_FEATURES    0x1002
#define CSR_CTRL0       0x1009
#define CSR_CTRL1       0x1010
#define CSR_DST_ADDR_LO 0x1011
#define CSR_DST_ADDR_HI 0x1012
#define CSR_SRC_ADDR_LO 0x1013
#define CSR_SRC_ADDR_HI 0x1014
#define CSR_MLB_RST     0x1016

class hssi_100g_cmd : public hssi_cmd
{
public:
  hssi_100g_cmd()
    : port_(0)
    , eth_loopback_("on")
    , num_packets_(1)
    , gap_("none")
    , pattern_("random")
    , src_addr_("11:22:33:44:55:66")
    , dest_addr_("77:88:99:aa:bb:cc")
    , eth_ifc_("none")
  {}

  virtual const char *name() const override
  {
    return "hssi_100g";
  }

  virtual const char *description() const override
  {
    return "hssi 100G test\n";
  }

  virtual void add_options(CLI::App *app) override
  {
    auto opt = app->add_option("--port", port_,
                               "QSFP port");
    opt->check(CLI::Range(0, 7))->default_str(std::to_string(port_));

    opt = app->add_option("--eth-loopback", eth_loopback_,
                    "whether to enable loopback on the eth interface");
    opt->check(CLI::IsMember({"on", "off"}))->default_str(eth_loopback_);

    opt = app->add_option("--num-packets", num_packets_,
                          "number of packets");
    opt->default_str(std::to_string(num_packets_));

    opt = app->add_option("--gap", gap_,
                          "inter-packet gap");
    opt->check(CLI::IsMember({"random", "none"}))->default_str(gap_);

    opt = app->add_option("--pattern", pattern_,
                          "pattern mode");
    opt->check(CLI::IsMember({"random", "fixed", "increment"}))->default_str(pattern_);

    opt = app->add_option("--src-addr", src_addr_,
                          "source MAC address");
    opt->default_str(src_addr_);

    opt = app->add_option("--dest-addr", dest_addr_,
                          "destination MAC address");
    opt->default_str(dest_addr_);

    opt = app->add_option("--eth-ifc", eth_ifc_,
                          "ethernet interface name");
    opt->default_str(eth_ifc_);
  }

  virtual int run(test_afu *afu, CLI::App *app) override
  {
    (void)app;

    hssi_afu *hafu = dynamic_cast<hssi_afu *>(afu);

    uint64_t bin_src_addr = mac_bits_for(src_addr_);
    if (bin_src_addr == INVALID_MAC) {
      std::cerr << "invalid MAC address: " << src_addr_ << std::endl;
      return test_afu::error;
    }

    uint64_t bin_dest_addr = mac_bits_for(dest_addr_);
    if (bin_dest_addr == INVALID_MAC) {
      std::cerr << "invalid MAC address: " << dest_addr_ << std::endl;
      return test_afu::error;
    }

    std::string eth_ifc = eth_ifc_;
    if (eth_ifc == "none")
      eth_ifc = hafu->ethernet_interface();

    std::cout << "100G loopback test" << std::endl
              << "  port: " << port_ << std::endl
              << "  eth_loopback: " << eth_loopback_ << std::endl
              << "  num_packets: " << num_packets_ << std::endl
              << "  gap: " << gap_ << std::endl
              << "  src_address: " << src_addr_ << std::endl
              << "    (bits): 0x" << std::hex << bin_src_addr << std::endl
              << "  dest_address: " << dest_addr_ << std::endl
              << "    (bits): 0x" << std::hex << bin_dest_addr << std::endl
              << "  pattern: " << pattern_ << std::endl
              << "  eth: " << eth_ifc << std::endl
              << std::endl;

    if (eth_ifc == "") {
      std::cout << "No eth interface, so not "
                   "honoring --eth-loopback." << std::endl;
    } else {
      if (eth_loopback_ == "on")
        enable_eth_loopback(eth_ifc, true);
      else
        enable_eth_loopback(eth_ifc, false);
    }

    hafu->write64(TRAFFIC_CTRL_PORT_SEL, port_);

    uint32_t reg = num_packets_;
    if (reg)
      reg |= 0x80000000;
    hafu->mbox_write(CSR_CTRL0, reg);

    hafu->mbox_write(CSR_SRC_ADDR_LO, static_cast<uint32_t>(bin_src_addr));
    hafu->mbox_write(CSR_SRC_ADDR_HI, static_cast<uint32_t>(bin_src_addr >> 32));

    hafu->mbox_write(CSR_DST_ADDR_LO, static_cast<uint32_t>(bin_dest_addr));
    hafu->mbox_write(CSR_DST_ADDR_HI, static_cast<uint32_t>(bin_dest_addr >> 32));

    reg = 0;
    if (gap_ == "random")
      reg |= 1 << 6;

    if (pattern_ == "fixed")
      reg |= 1 << 4;
    else if (pattern_ == "increment")
      reg |= 2 << 4;

    hafu->mbox_write(CSR_CTRL1, reg);

    print_registers(std::cout, hafu);

    std::cout << std::endl;

    if (eth_ifc == "") {
      std::cout << "No eth interface, so not "
                   "showing stats." << std::endl;
    } else {
      show_eth_stats(eth_ifc);

      if (eth_loopback_ == "on")
        enable_eth_loopback(eth_ifc, false);
    }

    return test_afu::success;
  }

  virtual const char *afu_id() const override
  {
    return "43425ee6-92b2-4742-b03a-bd8d4a533812";
  }

  std::ostream & print_registers(std::ostream &os, hssi_afu *hafu) const
  {
    os << "0x40000 " << std::setw(21) << "ETH_AFU_DFH" << ": " <<
      int_to_hex(hafu->read64(ETH_AFU_DFH)) << std::endl;
    os << "0x40008 " << std::setw(21) << "ETH_AFU_ID_L" << ": " <<
      int_to_hex(hafu->read64(ETH_AFU_ID_L)) << std::endl;
    os << "0x40010 " << std::setw(21) << "ETH_AFU_ID_H" << ": " <<
      int_to_hex(hafu->read64(ETH_AFU_ID_H)) << std::endl;
    os << "0x40030 " << std::setw(21) << "TRAFFIC_CTRL_CMD" << ": " <<
      int_to_hex(hafu->read64(TRAFFIC_CTRL_CMD)) << std::endl;
    os << "0x40038 " << std::setw(21) << "TRAFFIC_CTRL_DATA" << ": " <<
      int_to_hex(hafu->read64(TRAFFIC_CTRL_DATA)) << std::endl;
    os << "0x40040 " << std::setw(21) << "TRAFFIC_CTRL_PORT_SEL" << ": " <<
      int_to_hex(hafu->read64(TRAFFIC_CTRL_PORT_SEL)) << std::endl;
    os << "0x40048 " << std::setw(21) << "AFU_SCRATCHPAD" << ": " <<
      int_to_hex(hafu->read64(AFU_SCRATCHPAD)) << std::endl;
    
    os << std::endl;

    os << "0x1000 " << std::setw(22) << "scratch" << ": " <<
      int_to_hex(hafu->mbox_read(CSR_SCRATCH)) << std::endl;
    os << "0x1002 " << std::setw(22) << "features" << ": " <<
      int_to_hex(hafu->mbox_read(CSR_FEATURES)) << std::endl;
    os << "0x1009 " << std::setw(22) << "ctrl0" << ": " <<
      int_to_hex(hafu->mbox_read(CSR_CTRL0)) << std::endl;
    os << "0x1010 " << std::setw(22) << "ctrl1" << ": " <<
      int_to_hex(hafu->mbox_read(CSR_CTRL1)) << std::endl;
    os << "0x1011 " << std::setw(22) << "dst_addr_lo" << ": " <<
      int_to_hex(hafu->mbox_read(CSR_DST_ADDR_LO)) << std::endl;
    os << "0x1012 " << std::setw(22) << "dst_addr_hi" << ": " <<
      int_to_hex(hafu->mbox_read(CSR_DST_ADDR_HI)) << std::endl;
    os << "0x1013 " << std::setw(22) << "src_addr_lo" << ": " <<
      int_to_hex(hafu->mbox_read(CSR_SRC_ADDR_LO)) << std::endl;
    os << "0x1014 " << std::setw(22) << "src_addr_hi" << ": " <<
      int_to_hex(hafu->mbox_read(CSR_SRC_ADDR_HI)) << std::endl;
    os << "0x1016 " << std::setw(22) << "mlb_rst" << ": " <<
      int_to_hex(hafu->mbox_read(CSR_MLB_RST)) << std::endl;

    return os;
  }

protected:
  uint32_t port_;
  std::string eth_loopback_;
  uint32_t num_packets_;
  std::string gap_;
  std::string pattern_;
  std::string src_addr_;
  std::string dest_addr_;
  std::string eth_ifc_;
};

1	// Copyright(c) 2020-2021, Intel Corporation
2	//
3	// Redistribution and use in source and binary forms, with or without
4	// modification, are permitted provided that the following conditions are met:
5	//
6	// * Redistributions of source code must retain the above copyright notice,
7	// this list of conditions and the following disclaimer.
8	// * Redistributions in binary form must reproduce the above copyright notice,
9	// this list of conditions and the following disclaimer in the documentation
10	// and/or other materials provided with the distribution.
11	// * Neither the name of Intel Corporation nor the names of its contributors
12	// may be used to endorse or promote products derived from this software
13	// without specific prior written permission.
14	//
15	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18	// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19	// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20	// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21	// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22	// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23	// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24	// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25	// POSSIBILITY OF SUCH DAMAGE.
26	#pragma once
27	#include "hssi_cmd.h"
28
29	#define CSR_SCRATCH 0x1000
30	#define CSR_FEATURES 0x1002
31	#define CSR_CTRL0 0x1009
32	#define CSR_CTRL1 0x1010
33	#define CSR_DST_ADDR_LO 0x1011
34	#define CSR_DST_ADDR_HI 0x1012
35	#define CSR_SRC_ADDR_LO 0x1013
36	#define CSR_SRC_ADDR_HI 0x1014
37	#define CSR_MLB_RST 0x1016
38
39	class hssi_100g_cmd : public hssi_cmd
40	{
41	public:
42	hssi_100g_cmd()	×
43	: port_(0)	×
44	, eth_loopback_("on")
45	, num_packets_(1)
46	, gap_("none")
47	, pattern_("random")
48	, src_addr_("11:22:33:44:55:66")
49	, dest_addr_("77:88:99:aa:bb:cc")
50	, eth_ifc_("none")	×
51	{}	×
52
53	virtual const char *name() const override	×
54	{
55	return "hssi_100g";	×
56	}
57
58	virtual const char *description() const override	×
59	{
60	return "hssi 100G test\n";	×
61	}
62
63	virtual void add_options(CLI::App *app) override	×
64	{
65	auto opt = app->add_option("--port", port_,	×
66	"QSFP port");
67	opt->check(CLI::Range(0, 7))->default_str(std::to_string(port_));	×
68
69	opt = app->add_option("--eth-loopback", eth_loopback_,	×
70	"whether to enable loopback on the eth interface");
71	opt->check(CLI::IsMember({"on", "off"}))->default_str(eth_loopback_);	×
72
73	opt = app->add_option("--num-packets", num_packets_,	×
74	"number of packets");
75	opt->default_str(std::to_string(num_packets_));	×
76
77	opt = app->add_option("--gap", gap_,	×
78	"inter-packet gap");
79	opt->check(CLI::IsMember({"random", "none"}))->default_str(gap_);	×
80
81	opt = app->add_option("--pattern", pattern_,	×
82	"pattern mode");
83	opt->check(CLI::IsMember({"random", "fixed", "increment"}))->default_str(pattern_);	×
84
85	opt = app->add_option("--src-addr", src_addr_,	×
86	"source MAC address");
87	opt->default_str(src_addr_);	×
88
89	opt = app->add_option("--dest-addr", dest_addr_,	×
90	"destination MAC address");
91	opt->default_str(dest_addr_);	×
92
93	opt = app->add_option("--eth-ifc", eth_ifc_,	×
94	"ethernet interface name");
95	opt->default_str(eth_ifc_);	×
96	}	×
97
98	virtual int run(test_afu afu, CLI::App app) override	×
99	{
100	(void)app;
101
102	hssi_afu hafu = dynamic_cast<hssi_afu >(afu);	×
103
104	uint64_t bin_src_addr = mac_bits_for(src_addr_);	×
105	if (bin_src_addr == INVALID_MAC) {	×
106	std::cerr << "invalid MAC address: " << src_addr_ << std::endl;	×
107	return test_afu::error;	×
108	}
109
110	uint64_t bin_dest_addr = mac_bits_for(dest_addr_);	×
111	if (bin_dest_addr == INVALID_MAC) {	×
112	std::cerr << "invalid MAC address: " << dest_addr_ << std::endl;	×
113	return test_afu::error;	×
114	}
115
116	std::string eth_ifc = eth_ifc_;	×
117	if (eth_ifc == "none")	×
118	eth_ifc = hafu->ethernet_interface();	×
119
120	std::cout << "100G loopback test" << std::endl	×
121	<< " port: " << port_ << std::endl	×
122	<< " eth_loopback: " << eth_loopback_ << std::endl	×
123	<< " num_packets: " << num_packets_ << std::endl	×
124	<< " gap: " << gap_ << std::endl	×
125	<< " src_address: " << src_addr_ << std::endl	×
126	<< " (bits): 0x" << std::hex << bin_src_addr << std::endl	×
127	<< " dest_address: " << dest_addr_ << std::endl	×
128	<< " (bits): 0x" << std::hex << bin_dest_addr << std::endl	×
129	<< " pattern: " << pattern_ << std::endl	×
130	<< " eth: " << eth_ifc << std::endl	×
131	<< std::endl;	×
132
133	if (eth_ifc == "") {	×
134	std::cout << "No eth interface, so not "
135	"honoring --eth-loopback." << std::endl;	×
136	} else {
137	if (eth_loopback_ == "on")	×
138	enable_eth_loopback(eth_ifc, true);	×
139	else
140	enable_eth_loopback(eth_ifc, false);	×
141	}
142
143	hafu->write64(TRAFFIC_CTRL_PORT_SEL, port_);	×
144
145	uint32_t reg = num_packets_;	×
146	if (reg)	×
147	reg \|= 0x80000000;	×
148	hafu->mbox_write(CSR_CTRL0, reg);	×
149
150	hafu->mbox_write(CSR_SRC_ADDR_LO, static_cast<uint32_t>(bin_src_addr));	×
151	hafu->mbox_write(CSR_SRC_ADDR_HI, static_cast<uint32_t>(bin_src_addr >> 32));	×
152
153	hafu->mbox_write(CSR_DST_ADDR_LO, static_cast<uint32_t>(bin_dest_addr));	×
154	hafu->mbox_write(CSR_DST_ADDR_HI, static_cast<uint32_t>(bin_dest_addr >> 32));	×
155
156	reg = 0;	×
157	if (gap_ == "random")	×
158	reg \|= 1 << 6;	×
159
160	if (pattern_ == "fixed")	×
161	reg \|= 1 << 4;	×
162	else if (pattern_ == "increment")	×
163	reg \|= 2 << 4;	×
164
165	hafu->mbox_write(CSR_CTRL1, reg);	×
166
167	print_registers(std::cout, hafu);	×
168
169	std::cout << std::endl;	×
170
171	if (eth_ifc == "") {	×
172	std::cout << "No eth interface, so not "
173	"showing stats." << std::endl;	×
174	} else {
175	show_eth_stats(eth_ifc);	×
176
177	if (eth_loopback_ == "on")	×
178	enable_eth_loopback(eth_ifc, false);	×
179	}
180
181	return test_afu::success;	×
182	}
183
184	virtual const char *afu_id() const override	×
185	{
186	return "43425ee6-92b2-4742-b03a-bd8d4a533812";	×
187	}
188
189	std::ostream & print_registers(std::ostream &os, hssi_afu *hafu) const	×
190	{
191	os << "0x40000 " << std::setw(21) << "ETH_AFU_DFH" << ": " <<
192	int_to_hex(hafu->read64(ETH_AFU_DFH)) << std::endl;	×
193	os << "0x40008 " << std::setw(21) << "ETH_AFU_ID_L" << ": " <<
194	int_to_hex(hafu->read64(ETH_AFU_ID_L)) << std::endl;	×
195	os << "0x40010 " << std::setw(21) << "ETH_AFU_ID_H" << ": " <<
196	int_to_hex(hafu->read64(ETH_AFU_ID_H)) << std::endl;	×
197	os << "0x40030 " << std::setw(21) << "TRAFFIC_CTRL_CMD" << ": " <<
198	int_to_hex(hafu->read64(TRAFFIC_CTRL_CMD)) << std::endl;	×
199	os << "0x40038 " << std::setw(21) << "TRAFFIC_CTRL_DATA" << ": " <<
200	int_to_hex(hafu->read64(TRAFFIC_CTRL_DATA)) << std::endl;	×
201	os << "0x40040 " << std::setw(21) << "TRAFFIC_CTRL_PORT_SEL" << ": " <<
202	int_to_hex(hafu->read64(TRAFFIC_CTRL_PORT_SEL)) << std::endl;	×
203	os << "0x40048 " << std::setw(21) << "AFU_SCRATCHPAD" << ": " <<
204	int_to_hex(hafu->read64(AFU_SCRATCHPAD)) << std::endl;	×
205
206	os << std::endl;	×
207
208	os << "0x1000 " << std::setw(22) << "scratch" << ": " <<
209	int_to_hex(hafu->mbox_read(CSR_SCRATCH)) << std::endl;	×
210	os << "0x1002 " << std::setw(22) << "features" << ": " <<
211	int_to_hex(hafu->mbox_read(CSR_FEATURES)) << std::endl;	×
212	os << "0x1009 " << std::setw(22) << "ctrl0" << ": " <<
213	int_to_hex(hafu->mbox_read(CSR_CTRL0)) << std::endl;	×
214	os << "0x1010 " << std::setw(22) << "ctrl1" << ": " <<
215	int_to_hex(hafu->mbox_read(CSR_CTRL1)) << std::endl;	×
216	os << "0x1011 " << std::setw(22) << "dst_addr_lo" << ": " <<
217	int_to_hex(hafu->mbox_read(CSR_DST_ADDR_LO)) << std::endl;	×
218	os << "0x1012 " << std::setw(22) << "dst_addr_hi" << ": " <<
219	int_to_hex(hafu->mbox_read(CSR_DST_ADDR_HI)) << std::endl;	×
220	os << "0x1013 " << std::setw(22) << "src_addr_lo" << ": " <<
221	int_to_hex(hafu->mbox_read(CSR_SRC_ADDR_LO)) << std::endl;	×
222	os << "0x1014 " << std::setw(22) << "src_addr_hi" << ": " <<
223	int_to_hex(hafu->mbox_read(CSR_SRC_ADDR_HI)) << std::endl;	×
224	os << "0x1016 " << std::setw(22) << "mlb_rst" << ": " <<
225	int_to_hex(hafu->mbox_read(CSR_MLB_RST)) << std::endl;	×
226
227	return os;	×
228	}
229
230	protected:
231	uint32_t port_;
232	std::string eth_loopback_;
233	uint32_t num_packets_;
234	std::string gap_;
235	std::string pattern_;
236	std::string src_addr_;
237	std::string dest_addr_;
238	std::string eth_ifc_;
239	};

OPAE / opae-sdk / 1678705320

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous