USRP Hardware Driver and USRP Manual  Version: 4.1.0.4-3
UHD and USRP Manual
chdr_types.hpp
Go to the documentation of this file.
1 //
2 // Copyright 2019 Ettus Research, a National Instruments Brand
3 //
4 // SPDX-License-Identifier: GPL-3.0-or-later
5 //
6 
7 #pragma once
8 
10 #include <uhd/types/endianness.hpp>
11 #include <uhd/utils/byteswap.hpp>
12 #include <boost/format.hpp>
13 #include <boost/optional.hpp>
14 #include <deque>
15 #include <list>
16 #include <memory>
17 #include <vector>
18 
19 namespace uhd { namespace rfnoc { namespace chdr {
20 
22  PKT_TYPE_MGMT = 0x0,
23  PKT_TYPE_STRS = 0x1,
24  PKT_TYPE_STRC = 0x2,
25  PKT_TYPE_CTRL = 0x4,
28 };
29 
30 //----------------------------------------------------
31 // CHDR Header
32 //----------------------------------------------------
33 
35 {
36 public: // Functions
37  chdr_header() = default;
38  chdr_header(const chdr_header& rhs) = default;
39  chdr_header(chdr_header&& rhs) = default;
40 
42  chdr_header(uint64_t flat_hdr) : _flat_hdr(flat_hdr) {}
43 
45  inline uint8_t get_vc() const
46  {
47  return get_field<uint8_t>(_flat_hdr, VC_OFFSET, VC_WIDTH);
48  }
49 
51  inline void set_vc(uint8_t vc)
52  {
53  _flat_hdr = set_field(_flat_hdr, vc, VC_OFFSET, VC_WIDTH);
54  }
55 
57  inline bool get_eob() const
58  {
59  return get_field<bool>(_flat_hdr, EOB_OFFSET, EOB_WIDTH);
60  }
61 
63  inline void set_eob(bool eob)
64  {
65  _flat_hdr = set_field(_flat_hdr, eob, EOB_OFFSET, EOB_WIDTH);
66  }
67 
69  inline bool get_eov() const
70  {
71  return get_field<bool>(_flat_hdr, EOV_OFFSET, EOV_WIDTH);
72  }
73 
75  inline void set_eov(bool eov)
76  {
77  _flat_hdr = set_field(_flat_hdr, eov, EOV_OFFSET, EOV_WIDTH);
78  }
79 
81  inline packet_type_t get_pkt_type() const
82  {
83  return get_field<packet_type_t>(_flat_hdr, PKT_TYPE_OFFSET, PKT_TYPE_WIDTH);
84  }
85 
87  inline void set_pkt_type(packet_type_t pkt_type)
88  {
89  _flat_hdr = set_field(_flat_hdr, pkt_type, PKT_TYPE_OFFSET, PKT_TYPE_WIDTH);
90  }
91 
93  inline uint8_t get_num_mdata() const
94  {
95  return get_field<uint8_t>(_flat_hdr, NUM_MDATA_OFFSET, NUM_MDATA_WIDTH);
96  }
97 
99  inline void set_num_mdata(uint8_t num_mdata)
100  {
101  _flat_hdr = set_field(_flat_hdr, num_mdata, NUM_MDATA_OFFSET, NUM_MDATA_WIDTH);
102  }
103 
105  inline uint16_t get_seq_num() const
106  {
107  return get_field<uint16_t>(_flat_hdr, SEQ_NUM_OFFSET, SEQ_NUM_WIDTH);
108  }
109 
111  inline void set_seq_num(uint16_t seq_num)
112  {
113  _flat_hdr = set_field(_flat_hdr, seq_num, SEQ_NUM_OFFSET, SEQ_NUM_WIDTH);
114  }
115 
117  inline uint16_t get_length() const
118  {
119  return get_field<uint16_t>(_flat_hdr, LENGTH_OFFSET, LENGTH_WIDTH);
120  }
121 
123  inline void set_length(uint16_t length)
124  {
125  _flat_hdr = set_field(_flat_hdr, length, LENGTH_OFFSET, LENGTH_WIDTH);
126  }
127 
129  inline uint16_t get_dst_epid() const
130  {
131  return get_field<uint16_t>(_flat_hdr, DST_EPID_OFFSET, DST_EPID_WIDTH);
132  }
133 
135  inline void set_dst_epid(uint16_t dst_epid)
136  {
137  _flat_hdr = set_field(_flat_hdr, dst_epid, DST_EPID_OFFSET, DST_EPID_WIDTH);
138  }
139 
141  inline uint64_t pack() const
142  {
143  return _flat_hdr;
144  }
145 
147  inline operator uint64_t() const
148  {
149  return pack();
150  }
151 
153  inline bool operator==(const chdr_header& rhs) const
154  {
155  return _flat_hdr == rhs._flat_hdr;
156  }
157 
159  inline bool operator!=(const chdr_header& rhs) const
160  {
161  return _flat_hdr != rhs._flat_hdr;
162  }
163 
165  inline const chdr_header& operator=(const chdr_header& rhs)
166  {
167  _flat_hdr = rhs._flat_hdr;
168  return *this;
169  }
170 
172  inline const chdr_header& operator=(const uint64_t& rhs)
173  {
174  _flat_hdr = rhs;
175  return *this;
176  }
177 
179  inline const std::string to_string() const
180  {
181  // The static_casts are because vc and num_mdata are uint8_t -> unsigned char
182  // For some reason, despite the %u meaning unsigned int, boost still formats them
183  // as chars
184  return str(boost::format("chdr_header{vc:%u, eob:%c, eov:%c, pkt_type:%u, "
185  "num_mdata:%u, seq_num:%u, length:%u, dst_epid:%u}\n")
186  % static_cast<uint16_t>(get_vc()) % (get_eob() ? 'Y' : 'N')
187  % (get_eov() ? 'Y' : 'N') % get_pkt_type()
188  % static_cast<uint16_t>(get_num_mdata()) % get_seq_num() % get_length()
189  % get_dst_epid());
190  }
191 
192 private:
193  // The flattened representation of the header stored in host order
194  uint64_t _flat_hdr = 0;
195 
196  static constexpr size_t VC_WIDTH = 6;
197  static constexpr size_t EOB_WIDTH = 1;
198  static constexpr size_t EOV_WIDTH = 1;
199  static constexpr size_t PKT_TYPE_WIDTH = 3;
200  static constexpr size_t NUM_MDATA_WIDTH = 5;
201  static constexpr size_t SEQ_NUM_WIDTH = 16;
202  static constexpr size_t LENGTH_WIDTH = 16;
203  static constexpr size_t DST_EPID_WIDTH = 16;
204 
205  static constexpr size_t VC_OFFSET = 58;
206  static constexpr size_t EOB_OFFSET = 57;
207  static constexpr size_t EOV_OFFSET = 56;
208  static constexpr size_t PKT_TYPE_OFFSET = 53;
209  static constexpr size_t NUM_MDATA_OFFSET = 48;
210  static constexpr size_t SEQ_NUM_OFFSET = 32;
211  static constexpr size_t LENGTH_OFFSET = 16;
212  static constexpr size_t DST_EPID_OFFSET = 0;
213 
214  static inline uint64_t mask(const size_t width)
215  {
216  return ((uint64_t(1) << width) - 1);
217  }
218 
219  template <typename field_t>
220  static inline field_t get_field(
221  const uint64_t flat_hdr, const size_t offset, const size_t width)
222  {
223  return static_cast<field_t>((flat_hdr >> offset) & mask(width));
224  }
225 
226  template <typename field_t>
227  static inline uint64_t set_field(const uint64_t old_val,
228  const field_t field,
229  const size_t offset,
230  const size_t width)
231  {
232  return (old_val & ~(mask(width) << offset))
233  | ((static_cast<uint64_t>(field) & mask(width)) << offset);
234  }
235 };
236 
237 
238 //----------------------------------------------------
239 // CHDR Control Packet Payload
240 //----------------------------------------------------
241 
243  CMD_OKAY = 0x0,
244  CMD_CMDERR = 0x1,
245  CMD_TSERR = 0x2,
246  CMD_WARNING = 0x3,
247 };
248 
250  OP_SLEEP = 0x0,
251  OP_WRITE = 0x1,
252  OP_READ = 0x2,
256  OP_POLL = 0x6,
257  OP_USER1 = 0xA,
258  OP_USER2 = 0xB,
259  OP_USER3 = 0xC,
260  OP_USER4 = 0xD,
261  OP_USER5 = 0xE,
262  OP_USER6 = 0xF,
263 };
264 
266 {
267 public: // Members
269  uint16_t dst_port = 0;
271  uint16_t src_port = 0;
273  uint8_t seq_num = 0;
275  boost::optional<uint64_t> timestamp = boost::none;
277  bool is_ack = false;
279  uint16_t src_epid = 0;
281  uint32_t address = 0;
283  std::vector<uint32_t> data_vtr = {0};
285  uint8_t byte_enable = 0xF;
290 
291 public: // Functions
292  ctrl_payload() = default;
293  ctrl_payload(const ctrl_payload& rhs) = default;
294  ctrl_payload(ctrl_payload&& rhs) = default;
295 
296  ctrl_payload& operator=(const ctrl_payload& rhs) = default;
297 
299  void populate_header(chdr_header& header) const;
300 
302  size_t serialize(uint64_t* buff,
303  size_t max_size_bytes,
304  const std::function<uint64_t(uint64_t)>& conv_byte_order) const;
305 
307  template <endianness_t endianness>
308  size_t serialize(uint64_t* buff, size_t max_size_bytes) const
309  {
310  auto conv_byte_order = [](uint64_t x) -> uint64_t {
311  return (endianness == uhd::ENDIANNESS_BIG) ? uhd::htonx<uint64_t>(x)
312  : uhd::htowx<uint64_t>(x);
313  };
314  return serialize(buff, max_size_bytes, conv_byte_order);
315  }
316 
318  void deserialize(const uint64_t* buff,
319  size_t num_elems,
320  const std::function<uint64_t(uint64_t)>& conv_byte_order);
321 
323  template <endianness_t endianness>
324  void deserialize(const uint64_t* buff, size_t num_elems)
325  {
326  auto conv_byte_order = [](uint64_t x) -> uint64_t {
327  return (endianness == uhd::ENDIANNESS_BIG) ? uhd::ntohx<uint64_t>(x)
328  : uhd::wtohx<uint64_t>(x);
329  };
330  deserialize(buff, num_elems, conv_byte_order);
331  }
332 
334  size_t get_length() const;
335 
336  // Return whether or not we have a valid timestamp
337  bool has_timestamp() const
338  {
339  return bool(timestamp);
340  }
341 
343  bool operator==(const ctrl_payload& rhs) const;
344 
346  inline bool operator!=(const ctrl_payload& rhs) const
347  {
348  return !(*this == rhs);
349  }
350 
352  const std::string to_string() const;
353 
354 private:
355  static constexpr size_t DST_PORT_WIDTH = 10;
356  static constexpr size_t SRC_PORT_WIDTH = 10;
357  static constexpr size_t NUM_DATA_WIDTH = 4;
358  static constexpr size_t SEQ_NUM_WIDTH = 6;
359  static constexpr size_t HAS_TIME_WIDTH = 1;
360  static constexpr size_t IS_ACK_WIDTH = 1;
361  static constexpr size_t SRC_EPID_WIDTH = 16;
362  static constexpr size_t ADDRESS_WIDTH = 20;
363  static constexpr size_t BYTE_ENABLE_WIDTH = 4;
364  static constexpr size_t OPCODE_WIDTH = 4;
365  static constexpr size_t STATUS_WIDTH = 2;
366 
367  // Offsets assume 64-bit alignment
368  static constexpr size_t DST_PORT_OFFSET = 0;
369  static constexpr size_t SRC_PORT_OFFSET = 10;
370  static constexpr size_t NUM_DATA_OFFSET = 20;
371  static constexpr size_t SEQ_NUM_OFFSET = 24;
372  static constexpr size_t HAS_TIME_OFFSET = 30;
373  static constexpr size_t IS_ACK_OFFSET = 31;
374  static constexpr size_t SRC_EPID_OFFSET = 32;
375  static constexpr size_t ADDRESS_OFFSET = 0;
376  static constexpr size_t BYTE_ENABLE_OFFSET = 20;
377  static constexpr size_t OPCODE_OFFSET = 24;
378  static constexpr size_t STATUS_OFFSET = 30;
379  static constexpr size_t LO_DATA_OFFSET = 0;
380  static constexpr size_t HI_DATA_OFFSET = 32;
381 };
382 
383 //----------------------------------------------------
384 // CHDR Stream Status Packet Payload
385 //----------------------------------------------------
386 
388  STRS_OKAY = 0x0,
389  STRS_CMDERR = 0x1,
390  STRS_SEQERR = 0x2,
391  STRS_DATAERR = 0x3,
392  STRS_RTERR = 0x4,
393 };
394 
396 {
397 public: // Members
399  uint16_t src_epid = 0;
403  uint64_t capacity_bytes = 0;
405  uint32_t capacity_pkts = 0;
407  uint64_t xfer_count_bytes = 0;
409  uint64_t xfer_count_pkts = 0;
411  uint16_t buff_info = 0;
413  uint64_t status_info = 0;
414 
415 public: // Functions
416  strs_payload() = default;
417  strs_payload(const strs_payload& rhs) = default;
418  strs_payload(strs_payload&& rhs) = default;
419 
420  strs_payload& operator=(const strs_payload& rhs) = default;
421 
423  void populate_header(chdr_header& header) const;
424 
426  size_t serialize(uint64_t* buff,
427  size_t max_size_bytes,
428  const std::function<uint64_t(uint64_t)>& conv_byte_order) const;
429 
431  template <endianness_t endianness>
432  size_t serialize(uint64_t* buff, size_t max_size_bytes) const
433  {
434  auto conv_byte_order = [](uint64_t x) -> uint64_t {
435  return (endianness == uhd::ENDIANNESS_BIG) ? uhd::htonx<uint64_t>(x)
436  : uhd::htowx<uint64_t>(x);
437  };
438  return serialize(buff, max_size_bytes, conv_byte_order);
439  }
440 
442  void deserialize(const uint64_t* buff,
443  size_t num_elems,
444  const std::function<uint64_t(uint64_t)>& conv_byte_order);
445 
447  template <endianness_t endianness>
448  void deserialize(const uint64_t* buff, size_t num_elems)
449  {
450  auto conv_byte_order = [](uint64_t x) -> uint64_t {
451  return (endianness == uhd::ENDIANNESS_BIG) ? uhd::ntohx<uint64_t>(x)
452  : uhd::wtohx<uint64_t>(x);
453  };
454  deserialize(buff, num_elems, conv_byte_order);
455  }
456 
458  size_t get_length() const;
459 
461  bool operator==(const strs_payload& rhs) const;
462 
464  inline bool operator!=(const strs_payload& rhs) const
465  {
466  return !(*this == rhs);
467  }
468 
470  const std::string to_string() const;
471 
472 private:
473  static constexpr size_t SRC_EPID_WIDTH = 16;
474  static constexpr size_t STATUS_WIDTH = 4;
475  static constexpr size_t CAPACITY_BYTES_WIDTH = 40;
476  static constexpr size_t CAPACITY_PKTS_WIDTH = 24;
477  static constexpr size_t XFER_COUNT_PKTS_WIDTH = 40;
478  static constexpr size_t BUFF_INFO_WIDTH = 16;
479  static constexpr size_t STATUS_INFO_WIDTH = 48;
480 
481  // Offsets assume 64-bit alignment
482  static constexpr size_t SRC_EPID_OFFSET = 0;
483  static constexpr size_t STATUS_OFFSET = 16;
484  static constexpr size_t CAPACITY_BYTES_OFFSET = 24;
485  static constexpr size_t CAPACITY_PKTS_OFFSET = 0;
486  static constexpr size_t XFER_COUNT_PKTS_OFFSET = 24;
487  static constexpr size_t BUFF_INFO_OFFSET = 0;
488  static constexpr size_t STATUS_INFO_OFFSET = 16;
489 };
490 
491 //----------------------------------------------------
492 // CHDR Stream Command Packet Payload
493 //----------------------------------------------------
494 
496  STRC_INIT = 0x0,
497  STRC_PING = 0x1,
498  STRC_RESYNC = 0x2,
499 };
500 
502 {
503 public: // Members
505  uint16_t src_epid = 0;
509  uint8_t op_data = 0;
511  uint64_t num_pkts = 0;
513  uint64_t num_bytes = 0;
515  static constexpr size_t MAX_PACKET_SIZE = 128;
516 
517 public: // Functions
518  strc_payload() = default;
519  strc_payload(const strc_payload& rhs) = default;
520  strc_payload(strc_payload&& rhs) = default;
521 
522  strc_payload& operator=(const strc_payload& rhs) = default;
523 
525  void populate_header(chdr_header& header) const;
526 
528  size_t serialize(uint64_t* buff,
529  size_t max_size_bytes,
530  const std::function<uint64_t(uint64_t)>& conv_byte_order) const;
531 
533  template <endianness_t endianness>
534  size_t serialize(uint64_t* buff, size_t max_size_bytes) const
535  {
536  auto conv_byte_order = [](uint64_t x) -> uint64_t {
537  return (endianness == uhd::ENDIANNESS_BIG) ? uhd::htonx<uint64_t>(x)
538  : uhd::htowx<uint64_t>(x);
539  };
540  return serialize(buff, max_size_bytes, conv_byte_order);
541  }
542 
544  void deserialize(const uint64_t* buff,
545  size_t num_elems,
546  const std::function<uint64_t(uint64_t)>& conv_byte_order);
547 
549  template <endianness_t endianness>
550  void deserialize(const uint64_t* buff, size_t num_elems)
551  {
552  auto conv_byte_order = [](uint64_t x) -> uint64_t {
553  return (endianness == uhd::ENDIANNESS_BIG) ? uhd::ntohx<uint64_t>(x)
554  : uhd::wtohx<uint64_t>(x);
555  };
556  deserialize(buff, num_elems, conv_byte_order);
557  }
558 
560  size_t get_length() const;
561 
563  bool operator==(const strc_payload& rhs) const;
564 
566  inline bool operator!=(const strc_payload& rhs) const
567  {
568  return !(*this == rhs);
569  }
570 
572  const std::string to_string() const;
573 
574 private:
575  static constexpr size_t SRC_EPID_WIDTH = 16;
576  static constexpr size_t OP_CODE_WIDTH = 4;
577  static constexpr size_t OP_DATA_WIDTH = 4;
578  static constexpr size_t NUM_PKTS_WIDTH = 40;
579 
580  // Offsets assume 64-bit alignment
581  static constexpr size_t SRC_EPID_OFFSET = 0;
582  static constexpr size_t OP_CODE_OFFSET = 16;
583  static constexpr size_t OP_DATA_OFFSET = 20;
584  static constexpr size_t NUM_PKTS_OFFSET = 24;
585 };
586 
587 //----------------------------------------------------
588 // CHDR Management Packet Payload
589 //----------------------------------------------------
590 
592 // An operation consists of an operation code and some
593 // payload associated with that operation.
595 {
596 public:
597  // Operation code
598  enum op_code_t {
600  MGMT_OP_NOP = 0,
602  MGMT_OP_ADVERTISE = 1,
604  MGMT_OP_SEL_DEST = 2,
606  MGMT_OP_RETURN = 3,
608  MGMT_OP_INFO_REQ = 4,
610  MGMT_OP_INFO_RESP = 5,
612  MGMT_OP_CFG_WR_REQ = 6,
614  MGMT_OP_CFG_RD_REQ = 7,
616  MGMT_OP_CFG_RD_RESP = 8
617  };
618 
620  using payload_t = uint64_t;
621 
624  {
625  const uint16_t dest;
626 
627  sel_dest_payload(uint16_t dest_) : dest(dest_) {}
628  sel_dest_payload(payload_t payload_) : dest(static_cast<uint16_t>(payload_)) {}
629  operator payload_t() const
630  {
631  return static_cast<payload_t>(dest);
632  }
633  };
634 
637  struct cfg_payload
638  {
639  const uint16_t addr;
640  const uint32_t data;
641 
642  cfg_payload(uint16_t addr_, uint32_t data_ = 0) : addr(addr_), data(data_) {}
644  : addr(static_cast<uint16_t>(payload_ >> 0))
645  , data(static_cast<uint32_t>(payload_ >> 16))
646  {
647  }
648  operator payload_t() const
649  {
650  return ((static_cast<payload_t>(data) << 16) | static_cast<payload_t>(addr));
651  }
652  };
653 
656  {
657  const uint16_t device_id;
658  const uint8_t node_type;
659  const uint16_t node_inst;
660  const uint32_t ext_info;
661 
662  node_info_payload(uint16_t device_id_,
663  uint8_t node_type_,
664  uint16_t node_inst_,
665  uint32_t ext_info_)
666  : device_id(device_id_)
667  , node_type(node_type_)
668  , node_inst(node_inst_)
669  , ext_info(ext_info_)
670  {
671  }
673  : device_id(static_cast<uint16_t>(payload_ >> 0))
674  , node_type(static_cast<uint8_t>((payload_ >> 16) & 0xF))
675  , node_inst(static_cast<uint16_t>((payload_ >> 20) & 0x3FF))
676  , ext_info(static_cast<uint32_t>((payload_ >> 30) & 0x3FFFF))
677  {
678  }
679  operator payload_t() const
680  {
681  return ((static_cast<payload_t>(device_id) << 0)
682  | (static_cast<payload_t>(node_type & 0xF) << 16)
683  | (static_cast<payload_t>(node_inst & 0x3FF) << 20)
684  | (static_cast<payload_t>(ext_info & 0x3FFFF) << 30));
685  }
686  };
687 
688  mgmt_op_t(const op_code_t op_code, const payload_t op_payload = 0)
689  : _op_code(op_code), _op_payload(op_payload)
690  {
691  }
692  mgmt_op_t(const mgmt_op_t& rhs) = default;
693 
695  inline op_code_t get_op_code() const
696  {
697  return _op_code;
698  }
699 
701  inline uint64_t get_op_payload() const
702  {
703  return _op_payload;
704  }
705 
707  inline bool operator==(const mgmt_op_t& rhs) const
708  {
709  return (_op_code == rhs._op_code) && (_op_payload == rhs._op_payload);
710  }
711 
713  const std::string to_string() const;
714 
715 private:
716  op_code_t _op_code;
717  payload_t _op_payload;
718 };
719 
721 // A hop is a collection for management transactions for
722 // a single node.
724 {
725 public:
726  mgmt_hop_t() = default;
727  mgmt_hop_t(const mgmt_hop_t& rhs) = default;
728 
730  // Operations are added to the hop in FIFO order and executed in FIFO order.
731  inline void add_op(const mgmt_op_t& op)
732  {
733  _ops.push_back(op);
734  }
735 
737  inline size_t get_num_ops() const
738  {
739  return _ops.size();
740  }
741 
743  inline const mgmt_op_t& get_op(size_t i) const
744  {
745  return _ops.at(i);
746  }
747 
749  // The RFNoC Specification section 2.2.6 specifies that for chdr widths
750  // greater than 64, all MSBs are 0, so we pad out the hop based on the width
751  size_t serialize(std::vector<uint64_t>& target,
752  const std::function<uint64_t(uint64_t)>& conv_byte_order,
753  const size_t padding_size) const;
754 
756  // The RFNoC Specification section 2.2.6 specifies that for chdr widths
757  // greater than 64, all MSBs are 0, so we remove padding based on the width
758  void deserialize(std::list<uint64_t>& src,
759  const std::function<uint64_t(uint64_t)>& conv_byte_order,
760  const size_t padding_size);
761 
763  inline bool operator==(const mgmt_hop_t& rhs) const
764  {
765  return _ops == rhs._ops;
766  }
767 
769  const std::string to_string() const;
770 
771 private:
772  std::vector<mgmt_op_t> _ops;
773 };
774 
776 // A transaction is a collection of hops, where each hop is a collection
777 // of management transactions.
779 {
780 public:
781  mgmt_payload() = default;
782  mgmt_payload(const mgmt_payload& rhs) = default;
783  mgmt_payload(mgmt_payload&& rhs) = default;
784 
785  mgmt_payload& operator=(const mgmt_payload& rhs) = default;
786 
787  inline void set_header(sep_id_t src_epid, uint16_t protover, chdr_w_t chdr_w)
788  {
789  set_src_epid(src_epid);
790  set_chdr_w(chdr_w);
791  set_proto_ver(protover);
792  }
793 
795  // Hops are added to the hop in FIFO order and executed in FIFO order.
796  inline void add_hop(const mgmt_hop_t& hop)
797  {
798  _hops.push_back(hop);
799  }
800 
802  inline size_t get_num_hops() const
803  {
804  return _hops.size();
805  }
806 
808  inline const mgmt_hop_t& get_hop(size_t i) const
809  {
810  return _hops.at(i);
811  }
812 
815  {
816  auto hop = _hops.front();
817  _hops.pop_front();
818  return hop;
819  }
820 
821  inline size_t get_size_bytes() const
822  {
823  size_t num_lines = 1; /* header */
824  for (const auto& hop : _hops) {
825  num_lines += hop.get_num_ops();
826  }
827  return num_lines * (chdr_w_to_bits(_chdr_w) / 8);
828  }
829 
831  void populate_header(chdr_header& header) const;
832 
834  size_t serialize(uint64_t* buff,
835  size_t max_size_bytes,
836  const std::function<uint64_t(uint64_t)>& conv_byte_order) const;
837 
839  template <endianness_t endianness>
840  size_t serialize(uint64_t* buff, size_t max_size_bytes) const
841  {
842  auto conv_byte_order = [](uint64_t x) -> uint64_t {
843  return (endianness == uhd::ENDIANNESS_BIG) ? uhd::htonx<uint64_t>(x)
844  : uhd::htowx<uint64_t>(x);
845  };
846  return serialize(buff, max_size_bytes, conv_byte_order);
847  }
848 
850  void deserialize(const uint64_t* buff,
851  size_t num_elems,
852  const std::function<uint64_t(uint64_t)>& conv_byte_order);
853 
855  template <endianness_t endianness>
856  void deserialize(const uint64_t* buff, size_t num_elems)
857  {
858  auto conv_byte_order = [](uint64_t x) -> uint64_t {
859  return (endianness == uhd::ENDIANNESS_BIG) ? uhd::ntohx<uint64_t>(x)
860  : uhd::wtohx<uint64_t>(x);
861  };
862  deserialize(buff, num_elems, conv_byte_order);
863  }
864 
866  size_t get_length() const;
867 
869  const std::string to_string() const;
870 
872  const std::string hops_to_string() const;
873 
875  inline sep_id_t get_src_epid() const
876  {
877  return _src_epid;
878  }
879 
881  inline void set_src_epid(sep_id_t src_epid)
882  {
883  _src_epid = src_epid;
884  }
885 
887  bool operator==(const mgmt_payload& rhs) const;
888 
890  inline chdr_w_t get_chdr_w() const
891  {
892  return _chdr_w;
893  }
894 
896  inline void set_chdr_w(chdr_w_t chdr_w)
897  {
898  _chdr_w = chdr_w;
899  _padding_size = (chdr_w_to_bits(_chdr_w) / 64) - 1;
900  }
901 
903  inline uint16_t get_proto_ver() const
904  {
905  return _protover;
906  }
907 
909  inline void set_proto_ver(uint16_t proto_ver)
910  {
911  _protover = proto_ver;
912  }
913 
914 private:
915  sep_id_t _src_epid = 0;
916  uint16_t _protover = 0;
917  chdr_w_t _chdr_w = CHDR_W_64;
918  size_t _padding_size = 0;
919  std::deque<mgmt_hop_t> _hops;
920 };
921 
923 template <typename payload_t>
925 
926 template <>
928 {
929  return PKT_TYPE_CTRL;
930 }
931 
932 template <>
934 {
935  return PKT_TYPE_MGMT;
936 }
937 
938 template <>
940 {
941  return PKT_TYPE_STRC;
942 }
943 
944 template <>
946 {
947  return PKT_TYPE_STRS;
948 }
949 
950 }}} // namespace uhd::rfnoc::chdr
Definition: chdr_types.hpp:35
void set_vc(uint8_t vc)
Set the virtual channel field (6 bits)
Definition: chdr_types.hpp:51
void set_eob(bool eob)
Set the end-of-burst flag (1 bit)
Definition: chdr_types.hpp:63
uint8_t get_vc() const
Get the virtual channel field (6 bits)
Definition: chdr_types.hpp:45
void set_pkt_type(packet_type_t pkt_type)
Set the packet type field (3 bits)
Definition: chdr_types.hpp:87
const std::string to_string() const
Return a string representation of this object.
Definition: chdr_types.hpp:179
chdr_header(const chdr_header &rhs)=default
chdr_header(uint64_t flat_hdr)
Unpack the header from a uint64_t.
Definition: chdr_types.hpp:42
void set_length(uint16_t length)
Set the packet length field (16 bits)
Definition: chdr_types.hpp:123
bool operator!=(const chdr_header &rhs) const
Comparison operator (!=)
Definition: chdr_types.hpp:159
const chdr_header & operator=(const chdr_header &rhs)
Assignment operator (=) from a chdr_header.
Definition: chdr_types.hpp:165
uint64_t pack() const
Pack the header into a uint64_t.
Definition: chdr_types.hpp:141
uint16_t get_seq_num() const
Get the sequence number field (16 bits)
Definition: chdr_types.hpp:105
void set_dst_epid(uint16_t dst_epid)
Set the destination EPID field (16 bits)
Definition: chdr_types.hpp:135
uint16_t get_length() const
Get the packet length field (16 bits)
Definition: chdr_types.hpp:117
chdr_header(chdr_header &&rhs)=default
bool get_eov() const
Get the end-of-vector flag (1 bit)
Definition: chdr_types.hpp:69
packet_type_t get_pkt_type() const
Get the packet type field (3 bits)
Definition: chdr_types.hpp:81
const chdr_header & operator=(const uint64_t &rhs)
Assignment operator (=) from a uint64_t.
Definition: chdr_types.hpp:172
bool get_eob() const
Get the end-of-burst flag (1 bit)
Definition: chdr_types.hpp:57
uint8_t get_num_mdata() const
Get number of metadata words field (5 bits)
Definition: chdr_types.hpp:93
void set_eov(bool eov)
Set the end-of-vector flag (1 bit)
Definition: chdr_types.hpp:75
uint16_t get_dst_epid() const
Get the destination EPID field (16 bits)
Definition: chdr_types.hpp:129
void set_num_mdata(uint8_t num_mdata)
Set number of metadata words field (5 bits)
Definition: chdr_types.hpp:99
void set_seq_num(uint16_t seq_num)
Set the sequence number field (16 bits)
Definition: chdr_types.hpp:111
bool operator==(const chdr_header &rhs) const
Comparison operator (==)
Definition: chdr_types.hpp:153
Definition: chdr_types.hpp:266
bool has_timestamp() const
Definition: chdr_types.hpp:337
size_t get_length() const
Get the serialized size of this payload in 64 bit words.
size_t serialize(uint64_t *buff, size_t max_size_bytes, const std::function< uint64_t(uint64_t)> &conv_byte_order) const
Serialize the payload to a uint64_t buffer.
const std::string to_string() const
Return a string representation of this object.
size_t serialize(uint64_t *buff, size_t max_size_bytes) const
Serialize the payload to a uint64_t buffer (no conversion function)
Definition: chdr_types.hpp:308
ctrl_payload(const ctrl_payload &rhs)=default
bool operator==(const ctrl_payload &rhs) const
Comparison operator (==)
ctrl_payload & operator=(const ctrl_payload &rhs)=default
bool operator!=(const ctrl_payload &rhs) const
Comparison operator (!=)
Definition: chdr_types.hpp:346
void populate_header(chdr_header &header) const
Populate the header for this type of packet.
ctrl_payload(ctrl_payload &&rhs)=default
void deserialize(const uint64_t *buff, size_t num_elems)
Deserialize the payload from a uint64_t buffer (no conversion function)
Definition: chdr_types.hpp:324
void deserialize(const uint64_t *buff, size_t num_elems, const std::function< uint64_t(uint64_t)> &conv_byte_order)
Deserialize the payload from a uint64_t buffer.
A class that represents a single management hop.
Definition: chdr_types.hpp:724
void deserialize(std::list< uint64_t > &src, const std::function< uint64_t(uint64_t)> &conv_byte_order, const size_t padding_size)
Deserialize the payload from a uint64_t buffer.
bool operator==(const mgmt_hop_t &rhs) const
Comparison operator (==)
Definition: chdr_types.hpp:763
const mgmt_op_t & get_op(size_t i) const
Get the n'th operation in the hop.
Definition: chdr_types.hpp:743
size_t serialize(std::vector< uint64_t > &target, const std::function< uint64_t(uint64_t)> &conv_byte_order, const size_t padding_size) const
Serialize the payload to a uint64_t buffer.
void add_op(const mgmt_op_t &op)
Add a management operation to this hop.
Definition: chdr_types.hpp:731
const std::string to_string() const
Return a string representation of this object.
mgmt_hop_t(const mgmt_hop_t &rhs)=default
size_t get_num_ops() const
Get the number of management operations in this hop.
Definition: chdr_types.hpp:737
A class that represents a single management operation.
Definition: chdr_types.hpp:595
mgmt_op_t(const mgmt_op_t &rhs)=default
op_code_t
Definition: chdr_types.hpp:598
op_code_t get_op_code() const
Get the op-code for this transaction.
Definition: chdr_types.hpp:695
mgmt_op_t(const op_code_t op_code, const payload_t op_payload=0)
Definition: chdr_types.hpp:688
uint64_t get_op_payload() const
Get the payload for this transaction.
Definition: chdr_types.hpp:701
uint64_t payload_t
The payload for an operation is 48 bits wide.
Definition: chdr_types.hpp:620
bool operator==(const mgmt_op_t &rhs) const
Comparison operator (==)
Definition: chdr_types.hpp:707
const std::string to_string() const
Return a string representation of this object.
A class that represents a complete multi-hop management transaction.
Definition: chdr_types.hpp:779
size_t get_num_hops() const
Get the number of management hops in this hop.
Definition: chdr_types.hpp:802
const mgmt_hop_t & get_hop(size_t i) const
Get the n'th hop in the transaction.
Definition: chdr_types.hpp:808
void set_proto_ver(uint16_t proto_ver)
Set the protocol version for this transaction.
Definition: chdr_types.hpp:909
chdr_w_t get_chdr_w() const
Return the CHDR_W for this transaction.
Definition: chdr_types.hpp:890
void set_src_epid(sep_id_t src_epid)
Set the source EPID for this transaction.
Definition: chdr_types.hpp:881
void set_chdr_w(chdr_w_t chdr_w)
Set the CHDR_W for this transaction.
Definition: chdr_types.hpp:896
mgmt_payload(const mgmt_payload &rhs)=default
void set_header(sep_id_t src_epid, uint16_t protover, chdr_w_t chdr_w)
Definition: chdr_types.hpp:787
size_t get_length() const
Get the serialized size of this payload in 64 bit words.
void deserialize(const uint64_t *buff, size_t num_elems, const std::function< uint64_t(uint64_t)> &conv_byte_order)
Deserialize the payload from a uint64_t buffer.
mgmt_hop_t pop_hop()
Pop the first hop of the transaction and return it.
Definition: chdr_types.hpp:814
void add_hop(const mgmt_hop_t &hop)
Add a management hop to this transaction.
Definition: chdr_types.hpp:796
void populate_header(chdr_header &header) const
Populate the header for this type of packet.
mgmt_payload & operator=(const mgmt_payload &rhs)=default
void deserialize(const uint64_t *buff, size_t num_elems)
Deserialize the payload from a uint64_t buffer (no conversion function)
Definition: chdr_types.hpp:856
size_t get_size_bytes() const
Definition: chdr_types.hpp:821
size_t serialize(uint64_t *buff, size_t max_size_bytes) const
Serialize the payload to a uint64_t buffer (no conversion function)
Definition: chdr_types.hpp:840
sep_id_t get_src_epid() const
Return the source EPID for this transaction.
Definition: chdr_types.hpp:875
uint16_t get_proto_ver() const
Return the protocol version for this transaction.
Definition: chdr_types.hpp:903
const std::string to_string() const
Return a string representation of this object.
const std::string hops_to_string() const
Return a string representaiton of the hops contained by this object.
mgmt_payload(mgmt_payload &&rhs)=default
size_t serialize(uint64_t *buff, size_t max_size_bytes, const std::function< uint64_t(uint64_t)> &conv_byte_order) const
Serialize the payload to a uint64_t buffer.
bool operator==(const mgmt_payload &rhs) const
Comparison operator (==)
Definition: chdr_types.hpp:502
const std::string to_string() const
Return a string representation of this object.
bool operator==(const strc_payload &rhs) const
Comparison operator (==)
strc_payload(const strc_payload &rhs)=default
strc_payload(strc_payload &&rhs)=default
size_t serialize(uint64_t *buff, size_t max_size_bytes) const
Serialize the payload to a uint64_t buffer (no conversion function)
Definition: chdr_types.hpp:534
size_t get_length() const
Get the serialized size of this payload in 64 bit words.
void deserialize(const uint64_t *buff, size_t num_elems)
Deserialize the payload from a uint64_t buffer (no conversion function)
Definition: chdr_types.hpp:550
size_t serialize(uint64_t *buff, size_t max_size_bytes, const std::function< uint64_t(uint64_t)> &conv_byte_order) const
Serialize the payload to a uint64_t buffer.
void populate_header(chdr_header &header) const
Populate the header for this type of packet.
strc_payload & operator=(const strc_payload &rhs)=default
bool operator!=(const strc_payload &rhs) const
Comparison operator (!=)
Definition: chdr_types.hpp:566
void deserialize(const uint64_t *buff, size_t num_elems, const std::function< uint64_t(uint64_t)> &conv_byte_order)
Deserialize the payload from a uint64_t buffer.
Definition: chdr_types.hpp:396
size_t serialize(uint64_t *buff, size_t max_size_bytes, const std::function< uint64_t(uint64_t)> &conv_byte_order) const
Serialize the payload to a uint64_t buffer.
bool operator!=(const strs_payload &rhs) const
Comparison operator (!=)
Definition: chdr_types.hpp:464
strs_payload & operator=(const strs_payload &rhs)=default
bool operator==(const strs_payload &rhs) const
Comparison operator (==)
void deserialize(const uint64_t *buff, size_t num_elems, const std::function< uint64_t(uint64_t)> &conv_byte_order)
Deserialize the payload from a uint64_t buffer.
const std::string to_string() const
Return a string representation of this object.
size_t serialize(uint64_t *buff, size_t max_size_bytes) const
Serialize the payload to a uint64_t buffer (no conversion function)
Definition: chdr_types.hpp:432
strs_payload(strs_payload &&rhs)=default
void deserialize(const uint64_t *buff, size_t num_elems)
Deserialize the payload from a uint64_t buffer (no conversion function)
Definition: chdr_types.hpp:448
strs_payload(const strs_payload &rhs)=default
size_t get_length() const
Get the serialized size of this payload in 64 bit words.
void populate_header(chdr_header &header) const
Populate the header for this type of packet.
#define UHD_API
Definition: config.h:70
strs_status_t
Definition: chdr_types.hpp:387
@ STRS_CMDERR
No error.
Definition: chdr_types.hpp:389
@ STRS_OKAY
Definition: chdr_types.hpp:388
@ STRS_DATAERR
Packet out of sequence (sequence error)
Definition: chdr_types.hpp:391
@ STRS_RTERR
Data integrity check failed.
Definition: chdr_types.hpp:392
@ STRS_SEQERR
A stream command signalled an error.
Definition: chdr_types.hpp:390
constexpr packet_type_t payload_to_packet_type< mgmt_payload >()
Definition: chdr_types.hpp:933
constexpr packet_type_t payload_to_packet_type< strs_payload >()
Definition: chdr_types.hpp:945
strc_op_code_t
Definition: chdr_types.hpp:495
@ STRC_RESYNC
Trigger a stream status response.
Definition: chdr_types.hpp:498
@ STRC_INIT
Definition: chdr_types.hpp:496
@ STRC_PING
Initialize stream.
Definition: chdr_types.hpp:497
constexpr packet_type_t payload_to_packet_type< strc_payload >()
Definition: chdr_types.hpp:939
ctrl_opcode_t
Definition: chdr_types.hpp:249
@ OP_WRITE
Definition: chdr_types.hpp:251
@ OP_SLEEP
Definition: chdr_types.hpp:250
@ OP_USER1
Definition: chdr_types.hpp:257
@ OP_POLL
Definition: chdr_types.hpp:256
@ OP_USER2
Definition: chdr_types.hpp:258
@ OP_BLOCK_WRITE
Definition: chdr_types.hpp:254
@ OP_USER6
Definition: chdr_types.hpp:262
@ OP_READ
Definition: chdr_types.hpp:252
@ OP_READ_WRITE
Definition: chdr_types.hpp:253
@ OP_BLOCK_READ
Definition: chdr_types.hpp:255
@ OP_USER3
Definition: chdr_types.hpp:259
@ OP_USER4
Definition: chdr_types.hpp:260
@ OP_USER5
Definition: chdr_types.hpp:261
ctrl_status_t
Definition: chdr_types.hpp:242
@ CMD_TSERR
Slave asserted a command error.
Definition: chdr_types.hpp:245
@ CMD_OKAY
Definition: chdr_types.hpp:243
@ CMD_CMDERR
Transaction successful.
Definition: chdr_types.hpp:244
@ CMD_WARNING
Slave asserted a time stamp error.
Definition: chdr_types.hpp:246
constexpr packet_type_t payload_to_packet_type< ctrl_payload >()
Definition: chdr_types.hpp:927
constexpr packet_type_t payload_to_packet_type()
Conversion from payload_t to pkt_type.
packet_type_t
Definition: chdr_types.hpp:21
@ PKT_TYPE_DATA_WITH_TS
Data Packet without TimeStamp.
Definition: chdr_types.hpp:27
@ PKT_TYPE_DATA_NO_TS
Control Transaction.
Definition: chdr_types.hpp:26
@ PKT_TYPE_MGMT
Definition: chdr_types.hpp:22
@ PKT_TYPE_STRS
Management packet.
Definition: chdr_types.hpp:23
@ PKT_TYPE_CTRL
Stream Command.
Definition: chdr_types.hpp:25
@ PKT_TYPE_STRC
Stream status.
Definition: chdr_types.hpp:24
uint16_t sep_id_t
Stream Endpoint ID Type.
Definition: rfnoc_types.hpp:38
chdr_w_t
Type that indicates the CHDR Width in bits.
Definition: rfnoc_types.hpp:19
@ CHDR_W_64
Definition: rfnoc_types.hpp:19
constexpr size_t chdr_w_to_bits(chdr_w_t chdr_w)
Conversion from chdr_w_t to a number of bits.
Definition: rfnoc_types.hpp:21
UHD_INLINE size_t width(const soft_reg_field_t field)
Definition: soft_register.hpp:76
Definition: build_info.hpp:12
@ ENDIANNESS_BIG
Definition: endianness.hpp:30
Definition: chdr_types.hpp:638
cfg_payload(payload_t payload_)
Definition: chdr_types.hpp:643
const uint32_t data
Definition: chdr_types.hpp:640
cfg_payload(uint16_t addr_, uint32_t data_=0)
Definition: chdr_types.hpp:642
const uint16_t addr
Definition: chdr_types.hpp:639
An interpretation class for the payload for MGMT_OP_INFO_RESP.
Definition: chdr_types.hpp:656
const uint16_t node_inst
Definition: chdr_types.hpp:659
node_info_payload(payload_t payload_)
Definition: chdr_types.hpp:672
const uint8_t node_type
Definition: chdr_types.hpp:658
const uint32_t ext_info
Definition: chdr_types.hpp:660
const uint16_t device_id
Definition: chdr_types.hpp:657
node_info_payload(uint16_t device_id_, uint8_t node_type_, uint16_t node_inst_, uint32_t ext_info_)
Definition: chdr_types.hpp:662
An interpretation class for the payload for MGMT_OP_SEL_DEST.
Definition: chdr_types.hpp:624
sel_dest_payload(uint16_t dest_)
Definition: chdr_types.hpp:627
const uint16_t dest
Definition: chdr_types.hpp:625
sel_dest_payload(payload_t payload_)
Definition: chdr_types.hpp:628