1140408291

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/<a class="double-link" href="https://git"><a class=hub.com/OPAE/opae-sdk/commit/<a class="double-link" href="https://git"><a class=hub.com/OPAE/opae-sdk/commit/<a class="double-link" href="https://git"><a class=hub.com/OPAE/opae-sdk/commit/9d51da664794a73577b628d46f507c717c865b75">9d51da664">&lt;a href=&quot;https://github.com/OPAE/opae-sdk/commit/</a><a class="double-link" href="https://github.com/OPAE/opae-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OPAE/opae-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OPAE/opae-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OPAE/opae-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OPAE/opae-sdk/commit/9d51da664794a73577b628d46f507c717c865b75">9d51da664</a><a href="https://github.com/OPAE/opae-sdk/commit/9d51da664794a73577b628d46f507c717c865b75">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/OPAE/opae-sdk/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/OPAE/opae-sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/OPAE/opae-sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/OPAE/opae-sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/OPAE/opae-sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/OPAE/opae-sdk/commit/9d51da664794a73577b628d46f507c717c865b75&quot;&gt;9d51da664&lt;/a&gt;&lt;a href=&quot;https://github.com/OPAE/opae-sdk/commit/9d51da664794a73577b628d46f507c717c865b75&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/OPAE/opae-sdk/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/OPAE/opae-sdk/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;htt... (continued)

Pull Request Pull Request #2167: cpeng: change alignment to xfer limit

Run Details

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

10680 of 17078 relevant lines covered (62.54%)

12162.51 hits per line

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

0.0

/ofs/apps/cpeng/hps.cpp

// Copyright(c) 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.
#include <algorithm>
#include <chrono>
#include <fstream>
#include <thread>
#include <vector>
#include <unistd.h>
#include "afu_test.h"
#include "ofs_cpeng.h"

const char *cpeng_guid = "44bfc10d-b42a-44e5-bd42-57dc93ea7f91";

using opae::fpga::types::shared_buffer;
using opae_exception = opae::fpga::types::exception;
using usec = std::chrono::microseconds;
using msec = std::chrono::milliseconds;

const size_t pg_size = sysconf(_SC_PAGESIZE);
constexpr size_t MB(uint32_t count) {
  return count * 1024 * 1024;
}

constexpr size_t aligned(size_t n, size_t sz) {
  return (n + sz-1) & ~(sz-1);
}
const usec default_timeout_usec(msec(1000));

// TODO: make enums in ofs cpeng yaml spec
std::map<uint32_t, uint8_t> limit_map {
  { 64, 0b00},
  { 128, 0b01},
  { 512, 0b10},
  { 1024, 0b11}
};

class cpeng : public opae::afu_test::command
{
public:
  cpeng()
    : filename_("u-boot.itb")
    , destination_offset_(0x2000000)
    , timeout_usec_(default_timeout_usec.count())
    , chunk_(pg_size)
    , data_request_limit_(512)
    , soft_reset_(false)
    , skip_ssbl_verify_(false)
    , skip_kernel_verify_(false)
  {
  }
  virtual ~cpeng(){}
  virtual const char *name() const
  {
    return "cpeng";
  }

  virtual const char *description() const
  {
    return "Run copy engine commands";
  }

  virtual const char *afu_id() const
  {
    return cpeng_guid;
  }

  virtual void add_options(CLI::App *app)
  {
    std::map<std::string, uint32_t> units = {{"s", 1E6}, {"ms", 1E3}, {"us", 1}};
    std::vector<uint32_t> limits = { 64, 128, 512, 1024 };
    app->add_option("-f,--filename", filename_, "Image file to copy")
      ->default_val(filename_)
      ->check(CLI::ExistingFile);
    app->add_option("-d,--destination", destination_offset_, "HPS DDR Offset")
      ->default_str(std::to_string(destination_offset_));
    app->add_option("-t,--timeout", timeout_usec_, "Timeout")
      ->default_str(std::to_string(timeout_usec_))
      ->transform(CLI::AsNumberWithUnit(units));
    app->add_option("-c,--chunk", chunk_, "Chunk size. 0 indicates no chunks")
      ->default_str(std::to_string(chunk_));
    app->add_option("-r,--data-request-limit",
                    data_request_limit_,
                    "data request limit is pcie transfer width")
      ->default_str(std::to_string(data_request_limit_))
      ->check(CLI::IsMember(limits));
    app->add_flag("--soft-reset", soft_reset_, "Issue soft reset only");
    app->add_flag("--skip-ssbl-verify", skip_ssbl_verify_, "Do not wait for ssbl verify");
    app->add_flag("--skip-kernel-verify", skip_kernel_verify_, "Do not wait for kernel verify");
  }

  virtual int run(opae::afu_test::afu *afu, __attribute__((unused)) CLI::App *app)
  {
    log_ = spdlog::get(this->name());
    ofs_cpeng cpeng;

    // Initialize cpeng driver
    ofs_cpeng_init(&cpeng, afu->handle()->c_type());
    if (ofs_cpeng_wait_for_hps_ready(&cpeng, timeout_usec_)) {
      log_->warn("HPS is not ready");
      return 1;
    }

    if (soft_reset_) {
      log_->debug("issuing soft reset only");
      ofs_cpeng_ce_soft_reset(&cpeng);
      return 0;
    }

    // check the chunks size is a multiple of data request limit
    if (chunk_ % data_request_limit_) {
      log_->error("chunk size ({}) must be aligned to request limit size ({})",
                   chunk_, data_request_limit_);
      return 2;
    }

    // Open file, get the size
    std::ifstream inp(filename_, std::ios::binary | std::ios::ate);
    size_t sz = inp.tellg();
    inp.seekg(0, std::ios::beg);

    // if chunk_ CLI arg is 0, use the file size
    // otherwise, use the smaller of chunk_ and file size
    size_t chunk = chunk_ ? std::min(static_cast<size_t>(chunk_), sz) : sz;
    shared_buffer::ptr_t buffer(0);
    // make sure we align our buffer size to data request limit
    try {
      buffer = shared_buffer::allocate(afu->handle(),
                                       aligned(chunk, data_request_limit_));
    } catch (opae_exception &ex) {
      log_->error("could not allocate {} bytes of memory", chunk);
      if (chunk > pg_size) {
        auto hugepage_sz = chunk <= MB(2) ? "2MB" : "1GB";
        log_->error("might need {} hugepages reserved", hugepage_sz);
      }
      return 3;
    }
    // get a char* of the buffer so we can read into it every chunk iteration
    auto ptr = reinterpret_cast<char*>(const_cast<uint8_t*>(buffer->c_type()));

    memset(ptr, 0, buffer->size());
    size_t written = 0;
    log_->info("starting copy of file:{}, size: {}, chunk size: {}",
               filename_, sz, chunk);
    uint32_t n_chunks = 0;
    // set our xfer size to chunk size
    // but align it with req. limit size in case
    // our chunk is the entire file
    auto xfer_sz = aligned(chunk, data_request_limit_);
    // set the data req. limit to CLI arg (default arg is 512, default in HW is 1k)
    ofs_cpeng_set_data_req_limit(&cpeng, limit_map[data_request_limit_]);
    while (written < sz) {
        auto unread = sz-written;
        inp.read(ptr, chunk);
        if (ofs_cpeng_copy_chunk(
              &cpeng, buffer->io_address(),
              destination_offset_ + written,
              xfer_sz,
              timeout_usec_)) {
          auto status = ofs_cpeng_dma_status(&cpeng);
          log_->warn("copy chunk: {}, size: {}, unread: {}, dma_status: {:x}",
                      n_chunks, xfer_sz, unread, status);
          if (dmastatus_err(&cpeng)) {
            return 4;
          }
        }
        ++n_chunks;
        written += chunk;
        // if we're at the last chunk,
        // 1. zero out our buffer
        // 2. set 'chunk' to number of unread bytes
        // 3. set 'xfer_sz' to the req. limit aligned value of the last chunk
        if (unread < chunk) {
          memset(ptr, 0, chunk);
          chunk = unread;
          xfer_sz = aligned(chunk, data_request_limit_);
          log_->info("last chunk {}, aligned {}", chunk, xfer_sz);
        }
    }
    log_->info("transferred file in {} chunk(s)", n_chunks);
    ofs_cpeng_image_complete(&cpeng);

    // wait for both ssbl and kernel verify (if not skipped)
    if (!skip_ssbl_verify_) {
      wait_for_verify("ssbl", &cpeng, ofs_cpeng_hps_ssbl_verify);
    }
    if (!skip_kernel_verify_) {
      wait_for_verify("kernel", &cpeng, ofs_cpeng_hps_kernel_verify);
    }

    return 0;
  }


private:
  bool dmastatus_err(ofs_cpeng *cpeng)
  {
    if (ofs_cpeng_dma_status_error(cpeng)) {
        uint64_t axist_cpl = ofs_cpeng_ce_axist_cpl_sts(cpeng);
        uint64_t acelite_bresp = ofs_cpeng_ce_acelite_bresp_sts(cpeng);
        uint64_t fifo1_status = ofs_cpeng_ce_fifo1_status(cpeng);
        uint64_t fifo2_status = ofs_cpeng_ce_fifo2_status(cpeng);
        if (axist_cpl) {
          log_->error("CE_AXIST_CPL_STS: {:x}", axist_cpl);
        }
        if (acelite_bresp) {
          log_->error("CE_ACELITE_BRESP_STS: {:x}", acelite_bresp);
        }
        if (fifo1_status) {
          log_->error("CE_FIFO1_STS: {:x}", fifo1_status);
        }
        if (fifo2_status) {
          log_->error("CE_FIFO2_STS: {:x}", fifo2_status);
        }
        ofs_cpeng_ce_soft_reset(cpeng);
        return true;
      }
      return false;
  }

  void wait_for_verify(const char *stage, ofs_cpeng *cpeng, int (*verify_fn)(ofs_cpeng *))
  {
      log_->info("waiting for {} verify...", stage);
      auto sleep_time = usec(200);
      uint32_t verify = 0;
      while(!verify) {
        verify = verify_fn(cpeng);
        std::this_thread::sleep_for(sleep_time);
      }
      if (verify != 0b1){
        log_->error("error with {} verify: {:x}", stage, verify);
      }
      log_->info("{} verified", stage);
  }

  std::string filename_;
  uint64_t destination_offset_;
  uint32_t timeout_usec_;
  uint32_t chunk_;
  uint32_t data_request_limit_;
  bool soft_reset_;
  bool skip_ssbl_verify_;
  bool skip_kernel_verify_;
  std::shared_ptr<spdlog::logger> log_;
};


class heartbeat : public opae::afu_test::command
{
public:
  heartbeat()
  {
  }
  virtual ~heartbeat(){}
  virtual const char *name() const
  {
    return "heartbeat";
  }

  virtual const char *description() const
  {
    return "Check for HPS heartbeat";
  }

  virtual const char *afu_id() const
  {
    return cpeng_guid;
  }

  virtual int run(opae::afu_test::afu *afu, __attribute__((unused)) CLI::App *app)
  {
    log_ = spdlog::get(this->name());
    ofs_cpeng cpeng;

    // Initialize cpeng driver
    ofs_cpeng_init(&cpeng, afu->handle()->c_type());
    return check_heartbeat(&cpeng);
  }


private:
  int check_heartbeat(ofs_cpeng *cpeng)
  {
    uint64_t value = 0;
    while (true) {
      std::this_thread::sleep_for(msec(1000));
      auto next = ofs_cpeng_hps2host_rsp(cpeng);
      if (next <= value) {
        log_->warn("could not detect heartbeat, value: 0x{:x}", next);
      } else {
        log_->info("heartbeat value: 0x{:x}", next);
      }
      value = next;
    }
    return 0;
  }

  std::shared_ptr<spdlog::logger> log_;
};

int main(int argc, char *argv[])
{
  opae::afu_test::afu hps(cpeng_guid);
  hps.register_command<cpeng>();
  hps.register_command<heartbeat>();
  hps.main(argc, argv);
  return 0;
}


1	// Copyright(c) 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	#include <algorithm>
27	#include <chrono>
28	#include <fstream>
29	#include <thread>
30	#include <vector>
31	#include <unistd.h>
32	#include "afu_test.h"
33	#include "ofs_cpeng.h"
34
35	const char *cpeng_guid = "44bfc10d-b42a-44e5-bd42-57dc93ea7f91";
36
37	using opae::fpga::types::shared_buffer;
38	using opae_exception = opae::fpga::types::exception;
39	using usec = std::chrono::microseconds;
40	using msec = std::chrono::milliseconds;
41
42	const size_t pg_size = sysconf(_SC_PAGESIZE);
43	constexpr size_t MB(uint32_t count) {	×
44	return count * 1024 * 1024;	×
45	}
46
47	constexpr size_t aligned(size_t n, size_t sz) {	×
48	return (n + sz-1) & ~(sz-1);	×
49	}
50	const usec default_timeout_usec(msec(1000));
51
52	// TODO: make enums in ofs cpeng yaml spec
53	std::map<uint32_t, uint8_t> limit_map {
54	{ 64, 0b00},
55	{ 128, 0b01},
56	{ 512, 0b10},
57	{ 1024, 0b11}
58	};
59
60	class cpeng : public opae::afu_test::command
61	{
62	public:
63	cpeng()	×
64	: filename_("u-boot.itb")	×
65	, destination_offset_(0x2000000)
66	, timeout_usec_(default_timeout_usec.count())	×
67	, chunk_(pg_size)
68	, data_request_limit_(512)
69	, soft_reset_(false)
70	, skip_ssbl_verify_(false)
71	, skip_kernel_verify_(false)	×
72	{
73	}	×
74	virtual ~cpeng(){}	×
75	virtual const char *name() const	×
76	{
77	return "cpeng";	×
78	}
79
80	virtual const char *description() const	×
81	{
82	return "Run copy engine commands";	×
83	}
84
85	virtual const char *afu_id() const	×
86	{
87	return cpeng_guid;	×
88	}
89
90	virtual void add_options(CLI::App *app)	×
91	{
92	std::map<std::string, uint32_t> units = {{"s", 1E6}, {"ms", 1E3}, {"us", 1}};	×
93	std::vector<uint32_t> limits = { 64, 128, 512, 1024 };	×
94	app->add_option("-f,--filename", filename_, "Image file to copy")	×
95	->default_val(filename_)	×
96	->check(CLI::ExistingFile);	×
97	app->add_option("-d,--destination", destination_offset_, "HPS DDR Offset")	×
98	->default_str(std::to_string(destination_offset_));	×
99	app->add_option("-t,--timeout", timeout_usec_, "Timeout")	×
100	->default_str(std::to_string(timeout_usec_))	×
101	->transform(CLI::AsNumberWithUnit(units));	×
102	app->add_option("-c,--chunk", chunk_, "Chunk size. 0 indicates no chunks")	×
103	->default_str(std::to_string(chunk_));	×
104	app->add_option("-r,--data-request-limit",
105	data_request_limit_,	×
106	"data request limit is pcie transfer width")
107	->default_str(std::to_string(data_request_limit_))	×
108	->check(CLI::IsMember(limits));	×
109	app->add_flag("--soft-reset", soft_reset_, "Issue soft reset only");	×
110	app->add_flag("--skip-ssbl-verify", skip_ssbl_verify_, "Do not wait for ssbl verify");	×
111	app->add_flag("--skip-kernel-verify", skip_kernel_verify_, "Do not wait for kernel verify");	×
112	}	×
113
114	virtual int run(opae::afu_test::afu afu, __attribute__((unused)) CLI::App app)	×
115	{
116	log_ = spdlog::get(this->name());	×
117	ofs_cpeng cpeng;
118
119	// Initialize cpeng driver
120	ofs_cpeng_init(&cpeng, afu->handle()->c_type());	×
121	if (ofs_cpeng_wait_for_hps_ready(&cpeng, timeout_usec_)) {	×
122	log_->warn("HPS is not ready");	×
123	return 1;	×
124	}
125
126	if (soft_reset_) {	×
127	log_->debug("issuing soft reset only");	×
128	ofs_cpeng_ce_soft_reset(&cpeng);	×
129	return 0;	×
130	}
131
132	// check the chunks size is a multiple of data request limit
133	if (chunk_ % data_request_limit_) {	×
134	log_->error("chunk size ({}) must be aligned to request limit size ({})",	×
135	chunk_, data_request_limit_);	×
136	return 2;	×
137	}
138
139	// Open file, get the size
140	std::ifstream inp(filename_, std::ios::binary \| std::ios::ate);	×
141	size_t sz = inp.tellg();	×
142	inp.seekg(0, std::ios::beg);	×
143
144	// if chunk_ CLI arg is 0, use the file size
145	// otherwise, use the smaller of chunk_ and file size
146	size_t chunk = chunk_ ? std::min(static_cast<size_t>(chunk_), sz) : sz;	×
147	shared_buffer::ptr_t buffer(0);	×
148	// make sure we align our buffer size to data request limit
149	try {
150	buffer = shared_buffer::allocate(afu->handle(),	×
151	aligned(chunk, data_request_limit_));	×
152	} catch (opae_exception &ex) {	×
153	log_->error("could not allocate {} bytes of memory", chunk);	×
154	if (chunk > pg_size) {	×
155	auto hugepage_sz = chunk <= MB(2) ? "2MB" : "1GB";	×
156	log_->error("might need {} hugepages reserved", hugepage_sz);	×
157	}
158	return 3;	×
159	}
160	// get a char* of the buffer so we can read into it every chunk iteration
161	auto ptr = reinterpret_cast<char>(const_cast<uint8_t>(buffer->c_type()));	×
162
163	memset(ptr, 0, buffer->size());	×
164	size_t written = 0;	×
165	log_->info("starting copy of file:{}, size: {}, chunk size: {}",	×
166	filename_, sz, chunk);	×
167	uint32_t n_chunks = 0;	×
168	// set our xfer size to chunk size
169	// but align it with req. limit size in case
170	// our chunk is the entire file
171	auto xfer_sz = aligned(chunk, data_request_limit_);	×
172	// set the data req. limit to CLI arg (default arg is 512, default in HW is 1k)
173	ofs_cpeng_set_data_req_limit(&cpeng, limit_map[data_request_limit_]);	×
174	while (written < sz) {	×
175	auto unread = sz-written;	×
176	inp.read(ptr, chunk);	×
177	if (ofs_cpeng_copy_chunk(	×
178	&cpeng, buffer->io_address(),
179	destination_offset_ + written,	×
180	xfer_sz,
181	timeout_usec_)) {	×
182	auto status = ofs_cpeng_dma_status(&cpeng);	×
183	log_->warn("copy chunk: {}, size: {}, unread: {}, dma_status: {:x}",	×
184	n_chunks, xfer_sz, unread, status);
185	if (dmastatus_err(&cpeng)) {	×
186	return 4;	×
187	}
188	}
189	++n_chunks;	×
190	written += chunk;	×
191	// if we're at the last chunk,
192	// 1. zero out our buffer
193	// 2. set 'chunk' to number of unread bytes
194	// 3. set 'xfer_sz' to the req. limit aligned value of the last chunk
195	if (unread < chunk) {	×
196	memset(ptr, 0, chunk);	×
197	chunk = unread;	×
198	xfer_sz = aligned(chunk, data_request_limit_);	×
199	log_->info("last chunk {}, aligned {}", chunk, xfer_sz);	×
200	}
201	}
202	log_->info("transferred file in {} chunk(s)", n_chunks);	×
203	ofs_cpeng_image_complete(&cpeng);	×
204
205	// wait for both ssbl and kernel verify (if not skipped)
206	if (!skip_ssbl_verify_) {	×
207	wait_for_verify("ssbl", &cpeng, ofs_cpeng_hps_ssbl_verify);	×
208	}
209	if (!skip_kernel_verify_) {	×
210	wait_for_verify("kernel", &cpeng, ofs_cpeng_hps_kernel_verify);	×
211	}
212
213	return 0;	×
214	}
215
216
217	private:
218	bool dmastatus_err(ofs_cpeng *cpeng)	×
219	{
220	if (ofs_cpeng_dma_status_error(cpeng)) {	×
221	uint64_t axist_cpl = ofs_cpeng_ce_axist_cpl_sts(cpeng);	×
222	uint64_t acelite_bresp = ofs_cpeng_ce_acelite_bresp_sts(cpeng);	×
223	uint64_t fifo1_status = ofs_cpeng_ce_fifo1_status(cpeng);	×
224	uint64_t fifo2_status = ofs_cpeng_ce_fifo2_status(cpeng);	×
225	if (axist_cpl) {	×
226	log_->error("CE_AXIST_CPL_STS: {:x}", axist_cpl);	×
227	}
228	if (acelite_bresp) {	×
229	log_->error("CE_ACELITE_BRESP_STS: {:x}", acelite_bresp);	×
230	}
231	if (fifo1_status) {	×
232	log_->error("CE_FIFO1_STS: {:x}", fifo1_status);	×
233	}
234	if (fifo2_status) {	×
235	log_->error("CE_FIFO2_STS: {:x}", fifo2_status);	×
236	}
237	ofs_cpeng_ce_soft_reset(cpeng);	×
238	return true;	×
239	}
240	return false;	×
241	}
242
243	void wait_for_verify(const char stage, ofs_cpeng cpeng, int (verify_fn)(ofs_cpeng ))	×
244	{
245	log_->info("waiting for {} verify...", stage);	×
246	auto sleep_time = usec(200);	×
247	uint32_t verify = 0;	×
248	while(!verify) {	×
249	verify = verify_fn(cpeng);	×
250	std::this_thread::sleep_for(sleep_time);	×
251	}
252	if (verify != 0b1){	×
253	log_->error("error with {} verify: {:x}", stage, verify);	×
254	}
255	log_->info("{} verified", stage);	×
256	}	×
257
258	std::string filename_;
259	uint64_t destination_offset_;
260	uint32_t timeout_usec_;
261	uint32_t chunk_;
262	uint32_t data_request_limit_;
263	bool soft_reset_;
264	bool skip_ssbl_verify_;
265	bool skip_kernel_verify_;
266	std::shared_ptr<spdlog::logger> log_;
267	};
268
269
270	class heartbeat : public opae::afu_test::command
271	{
272	public:
273	heartbeat()	×
274	{	×
275	}	×
276	virtual ~heartbeat(){}	×
277	virtual const char *name() const	×
278	{
279	return "heartbeat";	×
280	}
281
282	virtual const char *description() const	×
283	{
284	return "Check for HPS heartbeat";	×
285	}
286
287	virtual const char *afu_id() const	×
288	{
289	return cpeng_guid;	×
290	}
291
292	virtual int run(opae::afu_test::afu afu, __attribute__((unused)) CLI::App app)	×
293	{
294	log_ = spdlog::get(this->name());	×
295	ofs_cpeng cpeng;
296
297	// Initialize cpeng driver
298	ofs_cpeng_init(&cpeng, afu->handle()->c_type());	×
299	return check_heartbeat(&cpeng);	×
300	}
301
302
303	private:
304	int check_heartbeat(ofs_cpeng *cpeng)	×
305	{
306	uint64_t value = 0;	×
307	while (true) {
308	std::this_thread::sleep_for(msec(1000));	×
309	auto next = ofs_cpeng_hps2host_rsp(cpeng);	×
310	if (next <= value) {	×
311	log_->warn("could not detect heartbeat, value: 0x{:x}", next);	×
312	} else {
313	log_->info("heartbeat value: 0x{:x}", next);	×
314	}
315	value = next;	×
316	}	×
317	return 0;
318	}
319
320	std::shared_ptr<spdlog::logger> log_;
321	};
322
323	int main(int argc, char *argv[])	×
324	{
325	opae::afu_test::afu hps(cpeng_guid);	×
326	hps.register_command<cpeng>();	×
327	hps.register_command<heartbeat>();	×
328	hps.main(argc, argv);	×
329	return 0;	×
330	}
331

OPAE / opae-sdk / 1140408291

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