USRP Hardware Driver and USRP Manual Version: 4.6.0.0
UHD and USRP Manual
 
Loading...
Searching...
No Matches
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
12#include <boost/format.hpp>
13#include <boost/optional.hpp>
14#include <deque>
15#include <list>
16#include <memory>
17#include <vector>
18
19namespace uhd { namespace rfnoc { namespace chdr {
20
29
30//----------------------------------------------------
31// CHDR Header
32//----------------------------------------------------
33
35{
36public: // 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
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
192private:
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
248
264
266{
267public: // 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
291public: // 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)
313 };
314 return serialize(buff, max_size_bytes, conv_byte_order);
315 }
316
321 void deserialize(const uint64_t* buff,
322 size_t buff_size,
323 const std::function<uint64_t(uint64_t)>& conv_byte_order);
324
328 template <endianness_t endianness>
329 void deserialize(const uint64_t* buff, size_t buff_size)
330 {
331 auto conv_byte_order = [](uint64_t x) -> uint64_t {
332 return (endianness == uhd::ENDIANNESS_BIG) ? uhd::ntohx<uint64_t>(x)
334 };
335 deserialize(buff, buff_size, conv_byte_order);
336 }
337
339 size_t get_length() const;
340
341 // Return whether or not we have a valid timestamp
342 bool has_timestamp() const
343 {
344 return bool(timestamp);
345 }
346
348 bool operator==(const ctrl_payload& rhs) const;
349
351 inline bool operator!=(const ctrl_payload& rhs) const
352 {
353 return !(*this == rhs);
354 }
355
357 const std::string to_string() const;
358
359private:
360 static constexpr size_t DST_PORT_WIDTH = 10;
361 static constexpr size_t SRC_PORT_WIDTH = 10;
362 static constexpr size_t NUM_DATA_WIDTH = 4;
363 static constexpr size_t SEQ_NUM_WIDTH = 6;
364 static constexpr size_t HAS_TIME_WIDTH = 1;
365 static constexpr size_t IS_ACK_WIDTH = 1;
366 static constexpr size_t SRC_EPID_WIDTH = 16;
367 static constexpr size_t ADDRESS_WIDTH = 20;
368 static constexpr size_t BYTE_ENABLE_WIDTH = 4;
369 static constexpr size_t OPCODE_WIDTH = 4;
370 static constexpr size_t STATUS_WIDTH = 2;
371
372 // Offsets assume 64-bit alignment
373 static constexpr size_t DST_PORT_OFFSET = 0;
374 static constexpr size_t SRC_PORT_OFFSET = 10;
375 static constexpr size_t NUM_DATA_OFFSET = 20;
376 static constexpr size_t SEQ_NUM_OFFSET = 24;
377 static constexpr size_t HAS_TIME_OFFSET = 30;
378 static constexpr size_t IS_ACK_OFFSET = 31;
379 static constexpr size_t SRC_EPID_OFFSET = 32;
380 static constexpr size_t ADDRESS_OFFSET = 0;
381 static constexpr size_t BYTE_ENABLE_OFFSET = 20;
382 static constexpr size_t OPCODE_OFFSET = 24;
383 static constexpr size_t STATUS_OFFSET = 30;
384 static constexpr size_t LO_DATA_OFFSET = 0;
385 static constexpr size_t HI_DATA_OFFSET = 32;
386};
387
388//----------------------------------------------------
389// CHDR Stream Status Packet Payload
390//----------------------------------------------------
391
399
401{
402public: // Members
404 uint16_t src_epid = 0;
408 uint64_t capacity_bytes = 0;
410 uint32_t capacity_pkts = 0;
412 uint64_t xfer_count_bytes = 0;
414 uint64_t xfer_count_pkts = 0;
416 uint16_t buff_info = 0;
418 uint64_t status_info = 0;
419
420public: // Functions
421 strs_payload() = default;
422 strs_payload(const strs_payload& rhs) = default;
423 strs_payload(strs_payload&& rhs) = default;
424
425 strs_payload& operator=(const strs_payload& rhs) = default;
426
428 void populate_header(chdr_header& header) const;
429
431 size_t serialize(uint64_t* buff,
432 size_t max_size_bytes,
433 const std::function<uint64_t(uint64_t)>& conv_byte_order) const;
434
436 template <endianness_t endianness>
437 size_t serialize(uint64_t* buff, size_t max_size_bytes) const
438 {
439 auto conv_byte_order = [](uint64_t x) -> uint64_t {
440 return (endianness == uhd::ENDIANNESS_BIG) ? uhd::htonx<uint64_t>(x)
442 };
443 return serialize(buff, max_size_bytes, conv_byte_order);
444 }
445
450 void deserialize(const uint64_t* buff,
451 size_t buff_size,
452 const std::function<uint64_t(uint64_t)>& conv_byte_order);
453
457 template <endianness_t endianness>
458 void deserialize(const uint64_t* buff, size_t buff_size)
459 {
460 auto conv_byte_order = [](uint64_t x) -> uint64_t {
461 return (endianness == uhd::ENDIANNESS_BIG) ? uhd::ntohx<uint64_t>(x)
463 };
464 deserialize(buff, buff_size, conv_byte_order);
465 }
466
468 size_t get_length() const;
469
471 bool operator==(const strs_payload& rhs) const;
472
474 inline bool operator!=(const strs_payload& rhs) const
475 {
476 return !(*this == rhs);
477 }
478
480 const std::string to_string() const;
481
482private:
483 static constexpr size_t SRC_EPID_WIDTH = 16;
484 static constexpr size_t STATUS_WIDTH = 4;
485 static constexpr size_t CAPACITY_BYTES_WIDTH = 40;
486 static constexpr size_t CAPACITY_PKTS_WIDTH = 24;
487 static constexpr size_t XFER_COUNT_PKTS_WIDTH = 40;
488 static constexpr size_t BUFF_INFO_WIDTH = 16;
489 static constexpr size_t STATUS_INFO_WIDTH = 48;
490
491 // Offsets assume 64-bit alignment
492 static constexpr size_t SRC_EPID_OFFSET = 0;
493 static constexpr size_t STATUS_OFFSET = 16;
494 static constexpr size_t CAPACITY_BYTES_OFFSET = 24;
495 static constexpr size_t CAPACITY_PKTS_OFFSET = 0;
496 static constexpr size_t XFER_COUNT_PKTS_OFFSET = 24;
497 static constexpr size_t BUFF_INFO_OFFSET = 0;
498 static constexpr size_t STATUS_INFO_OFFSET = 16;
499};
500
501//----------------------------------------------------
502// CHDR Stream Command Packet Payload
503//----------------------------------------------------
504
510
512{
513public: // Members
515 uint16_t src_epid = 0;
519 uint8_t op_data = 0;
521 uint64_t num_pkts = 0;
523 uint64_t num_bytes = 0;
525 static constexpr size_t MAX_PACKET_SIZE = 128;
526
527public: // Functions
528 strc_payload() = default;
529 strc_payload(const strc_payload& rhs) = default;
530 strc_payload(strc_payload&& rhs) = default;
531
532 strc_payload& operator=(const strc_payload& rhs) = default;
533
535 void populate_header(chdr_header& header) const;
536
538 size_t serialize(uint64_t* buff,
539 size_t max_size_bytes,
540 const std::function<uint64_t(uint64_t)>& conv_byte_order) const;
541
543 template <endianness_t endianness>
544 size_t serialize(uint64_t* buff, size_t max_size_bytes) const
545 {
546 auto conv_byte_order = [](uint64_t x) -> uint64_t {
547 return (endianness == uhd::ENDIANNESS_BIG) ? uhd::htonx<uint64_t>(x)
549 };
550 return serialize(buff, max_size_bytes, conv_byte_order);
551 }
552
557 void deserialize(const uint64_t* buff,
558 size_t buff_size,
559 const std::function<uint64_t(uint64_t)>& conv_byte_order);
560
564 template <endianness_t endianness>
565 void deserialize(const uint64_t* buff, size_t buff_size)
566 {
567 auto conv_byte_order = [](uint64_t x) -> uint64_t {
568 return (endianness == uhd::ENDIANNESS_BIG) ? uhd::ntohx<uint64_t>(x)
570 };
571 deserialize(buff, buff_size, conv_byte_order);
572 }
573
575 size_t get_length() const;
576
578 bool operator==(const strc_payload& rhs) const;
579
581 inline bool operator!=(const strc_payload& rhs) const
582 {
583 return !(*this == rhs);
584 }
585
587 const std::string to_string() const;
588
589private:
590 static constexpr size_t SRC_EPID_WIDTH = 16;
591 static constexpr size_t OP_CODE_WIDTH = 4;
592 static constexpr size_t OP_DATA_WIDTH = 4;
593 static constexpr size_t NUM_PKTS_WIDTH = 40;
594
595 // Offsets assume 64-bit alignment
596 static constexpr size_t SRC_EPID_OFFSET = 0;
597 static constexpr size_t OP_CODE_OFFSET = 16;
598 static constexpr size_t OP_DATA_OFFSET = 20;
599 static constexpr size_t NUM_PKTS_OFFSET = 24;
600};
601
602//----------------------------------------------------
603// CHDR Management Packet Payload
604//----------------------------------------------------
605
607// An operation consists of an operation code and some
608// payload associated with that operation.
610{
611public:
612 // Operation code
613 // Note that a management packet has 8 bits available for op codes. The
614 // values for these enums are used to construct the packets, so these values
615 // must match the values in rfnoc_chdr_internal_utils.vh.
618 MGMT_OP_NOP = 0,
620 MGMT_OP_ADVERTISE = 1,
622 MGMT_OP_SEL_DEST = 2,
624 MGMT_OP_RETURN = 3,
626 MGMT_OP_INFO_REQ = 4,
628 MGMT_OP_INFO_RESP = 5,
630 MGMT_OP_CFG_WR_REQ = 6,
632 MGMT_OP_CFG_RD_REQ = 7,
634 MGMT_OP_CFG_RD_RESP = 8
635 };
636
638 using payload_t = uint64_t;
639
642 {
643 const uint16_t dest;
644
645 sel_dest_payload(uint16_t dest_) : dest(dest_) {}
646 sel_dest_payload(payload_t payload_) : dest(static_cast<uint16_t>(payload_)) {}
647 operator payload_t() const
648 {
649 return static_cast<payload_t>(dest);
650 }
651 };
652
656 {
657 const uint16_t addr;
658 const uint32_t data;
659
660 cfg_payload(uint16_t addr_, uint32_t data_ = 0) : addr(addr_), data(data_) {}
662 : addr(static_cast<uint16_t>(payload_ >> 0))
663 , data(static_cast<uint32_t>(payload_ >> 16))
664 {
665 }
666 operator payload_t() const
667 {
668 return ((static_cast<payload_t>(data) << 16) | static_cast<payload_t>(addr));
669 }
670 };
671
674 {
675 const uint16_t device_id;
676 const uint8_t node_type;
677 const uint16_t node_inst;
678 const uint32_t ext_info;
679
680 node_info_payload(uint16_t device_id_,
681 uint8_t node_type_,
682 uint16_t node_inst_,
683 uint32_t ext_info_)
684 : device_id(device_id_)
685 , node_type(node_type_)
686 , node_inst(node_inst_)
687 , ext_info(ext_info_)
688 {
689 }
691 : device_id(static_cast<uint16_t>(payload_ >> 0))
692 , node_type(static_cast<uint8_t>((payload_ >> 16) & 0xF))
693 , node_inst(static_cast<uint16_t>((payload_ >> 20) & 0x3FF))
694 , ext_info(static_cast<uint32_t>((payload_ >> 30) & 0x3FFFF))
695 {
696 }
697 operator payload_t() const
698 {
699 return ((static_cast<payload_t>(device_id) << 0)
700 | (static_cast<payload_t>(node_type & 0xF) << 16)
701 | (static_cast<payload_t>(node_inst & 0x3FF) << 20)
702 | (static_cast<payload_t>(ext_info & 0x3FFFF) << 30));
703 }
704 };
705
706 mgmt_op_t(const op_code_t op_code,
707 const payload_t op_payload = 0,
708 const uint8_t ops_pending = 0)
709 : _op_code(op_code), _op_payload(op_payload), _ops_pending(ops_pending)
710 {
711 }
712 mgmt_op_t(const mgmt_op_t& rhs) = default;
713
715 // Note that ops_pending is not used by UHD, since it can infer this value
716 // from the ops vector in mgmt_hop_t. It is needed only by the CHDR
717 // dissector.
718 inline uint8_t get_ops_pending() const
719 {
720 return _ops_pending;
721 }
722
724 inline op_code_t get_op_code() const
725 {
726 return _op_code;
727 }
728
730 inline uint64_t get_op_payload() const
731 {
732 return _op_payload;
733 }
734
736 inline bool operator==(const mgmt_op_t& rhs) const
737 {
738 return (_op_code == rhs._op_code) && (_op_payload == rhs._op_payload);
739 }
740
742 const std::string to_string() const;
743
744private:
745 op_code_t _op_code;
746 payload_t _op_payload;
747 uint8_t _ops_pending;
748};
749
751// A hop is a collection for management transactions for
752// a single node.
754{
755public:
756 mgmt_hop_t() = default;
757 mgmt_hop_t(const mgmt_hop_t& rhs) = default;
758
760 // Operations are added to the hop in FIFO order and executed in FIFO order.
761 inline void add_op(const mgmt_op_t& op)
762 {
763 _ops.push_back(op);
764 }
765
767 inline size_t get_num_ops() const
768 {
769 return _ops.size();
770 }
771
773 inline const mgmt_op_t& get_op(size_t i) const
774 {
775 return _ops.at(i);
776 }
777
779 // The RFNoC Specification section 2.2.6 specifies that for chdr widths
780 // greater than 64, all MSBs are 0, so we pad out the hop based on the width
781 size_t serialize(std::vector<uint64_t>& target,
782 const std::function<uint64_t(uint64_t)>& conv_byte_order,
783 const size_t padding_size) const;
784
786 // The RFNoC Specification section 2.2.6 specifies that for chdr widths
787 // greater than 64, all MSBs are 0, so we remove padding based on the width
788 void deserialize(std::list<uint64_t>& src,
789 const std::function<uint64_t(uint64_t)>& conv_byte_order,
790 const size_t padding_size);
791
793 inline bool operator==(const mgmt_hop_t& rhs) const
794 {
795 return _ops == rhs._ops;
796 }
797
799 const std::string to_string() const;
800
801private:
802 std::vector<mgmt_op_t> _ops;
803};
804
806// A transaction is a collection of hops, where each hop is a collection
807// of management transactions.
809{
810public:
811 mgmt_payload() = default;
812 mgmt_payload(const mgmt_payload& rhs) = default;
813 mgmt_payload(mgmt_payload&& rhs) = default;
814
815 mgmt_payload& operator=(const mgmt_payload& rhs) = default;
816
817 inline void set_header(sep_id_t src_epid, uint16_t protover, chdr_w_t chdr_w)
818 {
819 set_src_epid(src_epid);
820 set_chdr_w(chdr_w);
821 set_proto_ver(protover);
822 }
823
825 // Hops are added to the hop in FIFO order and executed in FIFO order.
826 inline void add_hop(const mgmt_hop_t& hop)
827 {
828 _hops.push_back(hop);
829 }
830
832 inline size_t get_num_hops() const
833 {
834 return _hops.size();
835 }
836
838 inline const mgmt_hop_t& get_hop(size_t i) const
839 {
840 return _hops.at(i);
841 }
842
845 {
846 auto hop = _hops.front();
847 _hops.pop_front();
848 return hop;
849 }
850
851 inline size_t get_size_bytes() const
852 {
853 size_t num_lines = 1; /* header */
854 for (const auto& hop : _hops) {
855 num_lines += hop.get_num_ops();
856 }
857 return num_lines * (chdr_w_to_bits(_chdr_w) / 8);
858 }
859
861 void populate_header(chdr_header& header) const;
862
864 size_t serialize(uint64_t* buff,
865 size_t max_size_bytes,
866 const std::function<uint64_t(uint64_t)>& conv_byte_order) const;
867
869 template <endianness_t endianness>
870 size_t serialize(uint64_t* buff, size_t max_size_bytes) const
871 {
872 auto conv_byte_order = [](uint64_t x) -> uint64_t {
873 return (endianness == uhd::ENDIANNESS_BIG) ? uhd::htonx<uint64_t>(x)
875 };
876 return serialize(buff, max_size_bytes, conv_byte_order);
877 }
878
883 void deserialize(const uint64_t* buff,
884 size_t buff_size,
885 const std::function<uint64_t(uint64_t)>& conv_byte_order);
886
890 template <endianness_t endianness>
891 void deserialize(const uint64_t* buff, size_t buff_size)
892 {
893 auto conv_byte_order = [](uint64_t x) -> uint64_t {
894 return (endianness == uhd::ENDIANNESS_BIG) ? uhd::ntohx<uint64_t>(x)
896 };
897 deserialize(buff, buff_size, conv_byte_order);
898 }
899
901 size_t get_length() const;
902
904 const std::string to_string() const;
905
907 const std::string hops_to_string() const;
908
910 inline sep_id_t get_src_epid() const
911 {
912 return _src_epid;
913 }
914
916 inline void set_src_epid(sep_id_t src_epid)
917 {
918 _src_epid = src_epid;
919 }
920
922 bool operator==(const mgmt_payload& rhs) const;
923
925 inline chdr_w_t get_chdr_w() const
926 {
927 return _chdr_w;
928 }
929
931 inline void set_chdr_w(chdr_w_t chdr_w)
932 {
933 _chdr_w = chdr_w;
934 _padding_size = (chdr_w_to_bits(_chdr_w) / 64) - 1;
935 }
936
938 inline uint16_t get_proto_ver() const
939 {
940 return _protover;
941 }
942
944 inline void set_proto_ver(uint16_t proto_ver)
945 {
946 _protover = proto_ver;
947 }
948
949private:
950 sep_id_t _src_epid = 0;
951 uint16_t _protover = 0;
952 chdr_w_t _chdr_w = CHDR_W_64;
953 size_t _padding_size = 0;
954 std::deque<mgmt_hop_t> _hops;
955};
956
958template <typename payload_t>
960
961template <>
966
967template <>
972
973template <>
978
979template <>
984
985}}} // 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
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
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
const chdr_header & operator=(const chdr_header &rhs)
Assignment operator (=) from a chdr_header.
Definition chdr_types.hpp:165
const chdr_header & operator=(const uint64_t &rhs)
Assignment operator (=) from a uint64_t.
Definition chdr_types.hpp:172
bool operator==(const chdr_header &rhs) const
Comparison operator (==)
Definition chdr_types.hpp:153
Definition chdr_types.hpp:266
ctrl_payload & operator=(const ctrl_payload &rhs)=default
bool has_timestamp() const
Definition chdr_types.hpp:342
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.
void deserialize(const uint64_t *buff, size_t buff_size)
Definition chdr_types.hpp:329
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 (==)
void deserialize(const uint64_t *buff, size_t buff_size, const std::function< uint64_t(uint64_t)> &conv_byte_order)
bool operator!=(const ctrl_payload &rhs) const
Comparison operator (!=)
Definition chdr_types.hpp:351
void populate_header(chdr_header &header) const
Populate the header for this type of packet.
ctrl_payload(ctrl_payload &&rhs)=default
A class that represents a single management hop.
Definition chdr_types.hpp:754
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:793
const mgmt_op_t & get_op(size_t i) const
Get the n'th operation in the hop.
Definition chdr_types.hpp:773
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:761
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:767
A class that represents a single management operation.
Definition chdr_types.hpp:610
mgmt_op_t(const op_code_t op_code, const payload_t op_payload=0, const uint8_t ops_pending=0)
Definition chdr_types.hpp:706
mgmt_op_t(const mgmt_op_t &rhs)=default
op_code_t
Definition chdr_types.hpp:616
op_code_t get_op_code() const
Get the op-code for this transaction.
Definition chdr_types.hpp:724
uint8_t get_ops_pending() const
Get the ops pending for this transaction.
Definition chdr_types.hpp:718
uint64_t get_op_payload() const
Get the payload for this transaction.
Definition chdr_types.hpp:730
uint64_t payload_t
The payload for an operation is 48 bits wide.
Definition chdr_types.hpp:638
bool operator==(const mgmt_op_t &rhs) const
Comparison operator (==)
Definition chdr_types.hpp:736
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:809
size_t get_num_hops() const
Get the number of management hops in this hop.
Definition chdr_types.hpp:832
void set_proto_ver(uint16_t proto_ver)
Set the protocol version for this transaction.
Definition chdr_types.hpp:944
chdr_w_t get_chdr_w() const
Return the CHDR_W for this transaction.
Definition chdr_types.hpp:925
void deserialize(const uint64_t *buff, size_t buff_size, const std::function< uint64_t(uint64_t)> &conv_byte_order)
void set_src_epid(sep_id_t src_epid)
Set the source EPID for this transaction.
Definition chdr_types.hpp:916
void set_chdr_w(chdr_w_t chdr_w)
Set the CHDR_W for this transaction.
Definition chdr_types.hpp:931
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:817
size_t get_length() const
Get the serialized size of this payload in 64 bit words.
mgmt_hop_t pop_hop()
Pop the first hop of the transaction and return it.
Definition chdr_types.hpp:844
mgmt_payload & operator=(const mgmt_payload &rhs)=default
void add_hop(const mgmt_hop_t &hop)
Add a management hop to this transaction.
Definition chdr_types.hpp:826
void populate_header(chdr_header &header) const
Populate the header for this type of packet.
void deserialize(const uint64_t *buff, size_t buff_size)
Definition chdr_types.hpp:891
size_t get_size_bytes() const
Definition chdr_types.hpp:851
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:870
sep_id_t get_src_epid() const
Return the source EPID for this transaction.
Definition chdr_types.hpp:910
uint16_t get_proto_ver() const
Return the protocol version for this transaction.
Definition chdr_types.hpp:938
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
const mgmt_hop_t & get_hop(size_t i) const
Get the n'th hop in the transaction.
Definition chdr_types.hpp:838
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:512
const std::string to_string() const
Return a string representation of this object.
bool operator==(const strc_payload &rhs) const
Comparison operator (==)
void deserialize(const uint64_t *buff, size_t buff_size, const std::function< uint64_t(uint64_t)> &conv_byte_order)
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:544
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.
void populate_header(chdr_header &header) const
Populate the header for this type of packet.
void deserialize(const uint64_t *buff, size_t buff_size)
Definition chdr_types.hpp:565
bool operator!=(const strc_payload &rhs) const
Comparison operator (!=)
Definition chdr_types.hpp:581
strc_payload & operator=(const strc_payload &rhs)=default
Definition chdr_types.hpp:401
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:474
bool operator==(const strs_payload &rhs) const
Comparison operator (==)
void deserialize(const uint64_t *buff, size_t buff_size)
Definition chdr_types.hpp:458
strs_payload & operator=(const strs_payload &rhs)=default
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:437
strs_payload(strs_payload &&rhs)=default
void deserialize(const uint64_t *buff, size_t buff_size, const std::function< uint64_t(uint64_t)> &conv_byte_order)
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:87
strs_status_t
Definition chdr_types.hpp:392
@ STRS_CMDERR
No error.
Definition chdr_types.hpp:394
@ STRS_OKAY
Definition chdr_types.hpp:393
@ STRS_DATAERR
Packet out of sequence (sequence error)
Definition chdr_types.hpp:396
@ STRS_RTERR
Data integrity check failed.
Definition chdr_types.hpp:397
@ STRS_SEQERR
A stream command signalled an error.
Definition chdr_types.hpp:395
constexpr packet_type_t payload_to_packet_type< mgmt_payload >()
Definition chdr_types.hpp:968
constexpr packet_type_t payload_to_packet_type< strs_payload >()
Definition chdr_types.hpp:980
strc_op_code_t
Definition chdr_types.hpp:505
@ STRC_RESYNC
Trigger a stream status response.
Definition chdr_types.hpp:508
@ STRC_INIT
Definition chdr_types.hpp:506
@ STRC_PING
Initialize stream.
Definition chdr_types.hpp:507
constexpr packet_type_t payload_to_packet_type< strc_payload >()
Definition chdr_types.hpp:974
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:962
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:73
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:22
Definition build_info.hpp:12
T ntohx(T)
network to host: short, long, or long-long
Definition byteswap.ipp:112
T htowx(T)
host to worknet: short, long, or long-long
Definition byteswap.ipp:142
T wtohx(T)
worknet to host: short, long, or long-long
Definition byteswap.ipp:132
T htonx(T)
host to network: short, long, or long-long
Definition byteswap.ipp:122
@ ENDIANNESS_BIG
Definition endianness.hpp:30
Definition chdr_types.hpp:656
cfg_payload(payload_t payload_)
Definition chdr_types.hpp:661
const uint32_t data
Definition chdr_types.hpp:658
cfg_payload(uint16_t addr_, uint32_t data_=0)
Definition chdr_types.hpp:660
const uint16_t addr
Definition chdr_types.hpp:657
An interpretation class for the payload for MGMT_OP_INFO_RESP.
Definition chdr_types.hpp:674
const uint16_t node_inst
Definition chdr_types.hpp:677
node_info_payload(payload_t payload_)
Definition chdr_types.hpp:690
const uint8_t node_type
Definition chdr_types.hpp:676
const uint32_t ext_info
Definition chdr_types.hpp:678
const uint16_t device_id
Definition chdr_types.hpp:675
node_info_payload(uint16_t device_id_, uint8_t node_type_, uint16_t node_inst_, uint32_t ext_info_)
Definition chdr_types.hpp:680
An interpretation class for the payload for MGMT_OP_SEL_DEST.
Definition chdr_types.hpp:642
sel_dest_payload(uint16_t dest_)
Definition chdr_types.hpp:645
const uint16_t dest
Definition chdr_types.hpp:643
sel_dest_payload(payload_t payload_)
Definition chdr_types.hpp:646