RDK Documentation (Open Sourced RDK Components)
rmh_api.h
1 /*
2  * If not stated otherwise in this file or this component's Licenses.txt file the
3  * following copyright and licenses apply:
4  *
5  * Copyright 2016 RDK Management
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18 */
19 #ifndef RMH_API_H
20 #define RMH_API_H
21 
22 /**
23  * @defgroup MOCAHAL MoCA HAL
24  *
25  * MoCA HAL is an abstraction layer, implemented for interacting with MoCA driver.
26  * MoCA HAL API's functionality should be implemented by OEMs.
27  * moca_hal.c file provides the function call prototypes and structure definitions used for
28  * the RDK MoCA hardware abstraction layer.
29  *
30  * @defgroup MOCAHAL_GENERIC_API MoCA HAL Generic APIs
31  * @ingroup MOCAHAL
32  *
33  * @defgroup MOCAHAL_SOC_API MoCA HAL SoC APIs
34  * @ingroup MOCAHAL
35  */
36 
37 #ifdef __cplusplus
38 extern "C" {
39 #endif
40 
41 
42 RMH_API_IMPLEMENTATION_GENERIC_THEN_SOC(
43 /********************************************************************************************************************/
44 /* API Declaration */
45 RMH_Handle RMH_Initialize(const RMH_EventCallback eventCB, void * userContext),
46 
47 /* API Name */
48 RMH_Initialize,
49 
50 /* Description */
51 "Initialize the RMH library and return a handle to the instance. This handle will be used in all future communication "
52 "with the RMH library. This function will fail if the MoCA driver is not properly install or is not able to operate. "
53 "Multiple simultaneous instances of RMH_Initialize are supported in single and multiprocess environments.",
54 
55 /* Parameters */
56 PARAMETERS(
57  INPUT_PARAM(eventCB, const RMH_EventCallback,
58  "A pointer to a function which will handle any callbacks from the RMH MoCA library. A value of NULL is permitted if you do not wish to receive callbacks"),
59 
60  INPUT_PARAM(userContext, void*,
61  "A pointer to some data that will be passed back with each callback. A value of NULL is permitted if the client requires no context during callbacks")
62 ),
63 
64 /* Wrap API */
65 FALSE,
66 
67 /* Tags */
68 "Core"
69 /********************************************************************************************************************/
70 )
71 
72 
73 
74 RMH_API_IMPLEMENTATION_SOC_THEN_GENERIC(
75 /********************************************************************************************************************/
76 /* API Declaration */
77 RMH_Result RMH_Destroy(RMH_Handle handle),
78 
79 /* API Name */
80 RMH_Destroy,
81 
82 /* Description */
83 "Destroy the instance of RMH library which was created by RMH_Initialize",
84 
85 /* Parameters */
86 PARAMETERS(
87  INPUT_PARAM(handle, RMH_Handle,
88  "The RMH handle as returned by RMH_Initialize")
89 ),
90 
91 /* Wrap API */
92 TRUE,
93 
94 /* Tags */
95 "Core"
96 /********************************************************************************************************************/
97 )
98 
99 
100 
101 RMH_API_IMPLEMENTATION_SOC_ONLY(
102 /********************************************************************************************************************/
103 /* API Declaration */
104 RMH_Result RMH_ValidateHandle(RMH_Handle handle),
105 
106 /* API Name */
107 RMH_ValidateHandle,
108 
109 /* Description */
110 "Returns RMH_SUCCESS if the handle is still valid.",
111 
112 /* Parameters */
113 PARAMETERS(
114  INPUT_PARAM(handle, RMH_Handle,
115  "The RMH handle as returned by RMH_Initialize")
116 ),
117 
118 /* Wrap API */
119 TRUE,
120 
121 /* Tags */
122 "Core"
123 /********************************************************************************************************************/
124 )
125 
126 
127 
128 RMH_API_IMPLEMENTATION_GENERIC_THEN_SOC(
129 /********************************************************************************************************************/
130 /* API Declaration */
131 RMH_Result RMH_SetEventCallbacks(RMH_Handle handle, const uint32_t value),
132 
133 /* API Name */
134 RMH_SetEventCallbacks,
135 
136 /* Description */
137 "Set the list of callbacks you which to receive. For each callback a call will be made to <eventCB> which is provided "
138 "in the call to <RMH_Initialize>. By default all callbacks are disabled. Any subsequent calls to this API will "
139 "overwrite previous calls. For example, if you originally set value to 'RMH_API_PRINT' and later set to "
140 "'LINK_STATUS_CHANGED | MOCA_VERSION_CHANGED' you will stop receiving callbacks for 'RMH_API_PRINT'.",
141 
142 /* Parameters */
143 PARAMETERS(
144  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
145  INPUT_PARAM(value, const uint32_t, "A bitmask list of <RMH_Event> indicating the callbacks to be received.")
146 ),
147 
148 /* Wrap API */
149 TRUE,
150 
151 /* Tags */
152 "Core"
153 /********************************************************************************************************************/
154 )
155 
156 
157 
158 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
159 /********************************************************************************************************************/
160 /* API Declaration */
161 RMH_Result RMH_GetEventCallbacks(RMH_Handle handle, uint32_t* response),
162 
163 /* API Name */
164 RMH_GetEventCallbacks,
165 
166 /* Description */
167 "Get the list of events for which the client has registered.",
168 
169 /* Parameters */
170 PARAMETERS(
171  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
172  OUTPUT_PARAM(response, uint32_t*, "A bitmask list of <RMH_Event> indicating the currently enabled callbacks.")
173 ),
174 
175 /* Wrap API */
176 TRUE,
177 
178 /* Tags */
179 "Core"
180 /********************************************************************************************************************/
181 )
182 
183 
184 
185 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
186 /********************************************************************************************************************/
187 /* API Declaration */
188 RMH_Result RMH_GetAllAPIs(const RMH_Handle handle, RMH_APIList** apiList),
189 
190 /* API Name */
191 RMH_GetAllAPIs,
192 
193 /* Description */
194 "Return a list of all APIs which are part of RMH.",
195 
196 /* Parameters */
197 PARAMETERS(
198  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize. NULL is valid for this API."),
199  OUTPUT_PARAM(apiList, RMH_APIList**, "Output list of APIs")
200 ),
201 
202 /* Wrap API */
203 TRUE,
204 
205 /* Tags */
206 "Core"
207 /********************************************************************************************************************/
208 )
209 
210 
211 
212 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
213 /********************************************************************************************************************/
214 /* API Declaration */
215 
216 RMH_Result RMH_GetUnimplementedAPIs(const RMH_Handle handle, RMH_APIList** apiList),
217 
218 /* API Name */
219 RMH_GetUnimplementedAPIs,
220 
221 /* Description */
222 "Return a list of all RMH APIs which are unimplemented by the SoC library.",
223 
224 /* Parameters */
225 PARAMETERS(
226  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize. NULL is valid for this API."),
227  OUTPUT_PARAM(apiList, RMH_APIList**, "Output list of APIs")
228 ),
229 
230 /* Wrap API */
231 TRUE,
232 
233 /* Tags */
234 "Core"
235 /********************************************************************************************************************/
236 )
237 
238 
239 
240 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
241 /********************************************************************************************************************/
242 /* API Declaration */
243 RMH_Result RMH_GetAPITags(const RMH_Handle handle, RMH_APITagList** apiTags),
244 
245 /* API Name */
246 RMH_GetAPITags,
247 
248 /* Description */
249 "Return the list of all RMH APIs grouped into lists by their tags.",
250 
251 /* Parameters */
252 PARAMETERS(
253  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize. NULL is valid for this API."),
254  OUTPUT_PARAM(apiTags, RMH_APITagList**, "Output list of Tags and APIs which belong to them")
255 ),
256 
257 /* Wrap API */
258 TRUE,
259 
260 /* Tags */
261 "Core"
262 /********************************************************************************************************************/
263 )
264 
265 
266 
267 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
268 /********************************************************************************************************************/
269 /* API Declaration */
270 const char* const RMH_ResultToString(const RMH_Result value),
271 
272 /* API Name */
273 RMH_ResultToString,
274 
275 /* Description */
276 "Convert <RMH_Result> to a string",
277 
278 /* Parameters */
279 PARAMETERS(
280  INPUT_PARAM(value, const RMH_Result, "Value to be printed as a string")
281 ),
282 
283 /* Wrap API */
284 FALSE,
285 
286 /* Tags */
287 "Core"
288 /********************************************************************************************************************/
289 )
290 
291 
292 
293 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
294 /********************************************************************************************************************/
295 /* API Declaration */
296 const char* const RMH_LinkStatusToString(const RMH_LinkStatus value),
297 
298 /* API Name */
299 RMH_LinkStatusToString,
300 
301 /* Description */
302 "Convert <RMH_LinkStatus> to a string",
303 
304 /* Parameters */
305 PARAMETERS(
306  INPUT_PARAM(value, const RMH_LinkStatus, "Value to be printed as a string")
307 ),
308 
309 /* Wrap API */
310 FALSE,
311 
312 /* Tags */
313 "Core,Link"
314 /********************************************************************************************************************/
315 )
316 
317 
318 
319 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
320 /********************************************************************************************************************/
321 /* API Declaration */
322 const char* const RMH_AdmissionStatusToString(const RMH_AdmissionStatus value),
323 
324 /* API Name */
325 RMH_AdmissionStatusToString,
326 
327 /* Description */
328 "Convert <RMH_AdmissionStatus> to a string",
329 
330 /* Parameters */
331 PARAMETERS(
332  INPUT_PARAM(value, const RMH_AdmissionStatus, "Value to be printed as a string")
333 ),
334 
335 /* Wrap API */
336 FALSE,
337 
338 /* Tags */
339 "Core"
340 /********************************************************************************************************************/
341 )
342 
343 
344 
345 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
346 /********************************************************************************************************************/
347 /* API Declaration */
348 const char* const RMH_MoCAResetReasonToString(const RMH_MoCAResetReason value),
349 
350 /* API Name */
351 RMH_MoCAResetReasonToString,
352 
353 /* Description */
354 "Convert <RMH_MoCAResetReason> to a string",
355 
356 /* Parameters */
357 PARAMETERS(
358  INPUT_PARAM(value, const RMH_MoCAResetReason, "Value to be printed as a string")
359 ),
360 
361 /* Wrap API */
362 FALSE,
363 
364 /* Tags */
365 "Core"
366 /********************************************************************************************************************/
367 )
368 
369 
370 
371 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
372 /********************************************************************************************************************/
373 /* API Declaration */
374 const char* const RMH_SubcarrierProfileToString(const RMH_SubcarrierProfile value),
375 
376 /* API Name */
377 RMH_SubcarrierProfileToString,
378 
379 /* Description */
380 "Convert <RMH_SubcarrierProfile> to a string",
381 
382 /* Parameters */
383 PARAMETERS(
384  INPUT_PARAM(value, const RMH_SubcarrierProfile, "Value to be printed as a string")
385 ),
386 
387 /* Wrap API */
388 FALSE,
389 
390 /* Tags */
391 "Core"
392 /********************************************************************************************************************/
393 )
394 
395 
396 
397 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
398 /********************************************************************************************************************/
399 /* API Declaration */
400 const char* const RMH_PERModeToString(const RMH_PERMode value),
401 
402 /* API Name */
403 RMH_PERModeToString,
404 
405 /* Description */
406 "Convert <RMH_PERMode> to a string",
407 
408 /* Parameters */
409 PARAMETERS(
410  INPUT_PARAM(value, const RMH_PERMode, "Value to be printed as a string")
411 ),
412 
413 /* Wrap API */
414 FALSE,
415 
416 /* Tags */
417 "Core"
418 /********************************************************************************************************************/
419 )
420 
421 
422 
423 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
424 /********************************************************************************************************************/
425 /* API Declaration */
426 const char* const RMH_MoCAVersionToString(const RMH_MoCAVersion value),
427 
428 /* API Name */
429 RMH_MoCAVersionToString,
430 
431 /* Description */
432 "Convert <RMH_MoCAVersion> to a string",
433 
434 /* Parameters */
435 PARAMETERS(
436  INPUT_PARAM(value, const RMH_MoCAVersion, "Value to be printed as a string")
437 ),
438 
439 /* Wrap API */
440 FALSE,
441 
442 /* Tags */
443 "Core,Version"
444 /********************************************************************************************************************/
445 )
446 
447 
448 
449 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
450 /********************************************************************************************************************/
451 /* API Declaration */
452 const char* const RMH_PowerModeToString(const uint32_t value, char* responseBuf, const size_t responseBufSize),
453 
454 /* API Name */
455 RMH_PowerModeToString,
456 
457 /* Description */
458 "The input <value> should be a a bitmask of type <RMH_PowerMode>. This will be converted to a printable string.",
459 
460 /* Parameters */
461 PARAMETERS(
462  INPUT_PARAM(value, const uint32_t, "A bitmask of <RMH_PowerMode> to be printed as a string"),
463  OUTPUT_PARAM(responseBuf, char*, "A buffer where the log level string will be written"),
464  INPUT_PARAM(responseBufSize, const size_t, "The size in bytes of the buffer <responseBuf>")
465 ),
466 
467 /* Wrap API */
468 FALSE,
469 
470 /* Tags */
471 "Core,Power"
472 /********************************************************************************************************************/
473 )
474 
475 
476 
477 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
478 /********************************************************************************************************************/
479 /* API Declaration */
480 const char* const RMH_BandToString(const RMH_Band value),
481 
482 /* API Name */
483 RMH_BandToString,
484 
485 /* Description */
486 "Convert <value> to a printable string.",
487 
488 /* Parameters */
489 PARAMETERS(
490  INPUT_PARAM(value, const RMH_Band, "Value to be printed as a string")
491 ),
492 
493 /* Wrap API */
494 FALSE,
495 
496 /* Tags */
497 "Core"
498 /********************************************************************************************************************/
499 )
500 
501 
502 
503 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
504 /********************************************************************************************************************/
505 /* API Declaration */
506 const char* const RMH_LogLevelToString(const uint32_t value, char* responseBuf, const size_t responseBufSize),
507 
508 /* API Name */
509 RMH_LogLevelToString,
510 
511 /* Description */
512 "Return a the bitmask <value> as a string. The bitmask is expected to contain one or more of <RMH_LogLevel>",
513 
514 /* Parameters */
515 PARAMETERS(
516  INPUT_PARAM(value, const uint32_t, "A bitmask of <RMH_LogLevel> to be printed as a string"),
517  OUTPUT_PARAM(responseBuf, char*, "A buffer where the log level string will be written"),
518  INPUT_PARAM(responseBufSize, const size_t, "The size in bytes of the buffer <responseBuf>")
519 ),
520 
521 /* Wrap API */
522 FALSE,
523 
524 /* Tags */
525 "Core,log"
526 /********************************************************************************************************************/
527 )
528 
529 
530 
531 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
532 /********************************************************************************************************************/
533 /* API Declaration */
534 const char* const RMH_EventToString(const uint32_t value, char* responseBuf, const size_t responseBufSize),
535 
536 /* API Name */
537 RMH_EventToString,
538 
539 /* Description */
540 "Return a the bitmask <value> as a string. The bitmask is expected to contain one or more of <RMH_Event>",
541 
542 /* Parameters */
543 PARAMETERS(
544  INPUT_PARAM(value, const uint32_t, "A bitmask of <RMH_Event> to be printed as a string"),
545  OUTPUT_PARAM(responseBuf, char*, "A buffer where the log level string will be written"),
546  INPUT_PARAM(responseBufSize, const size_t, "The size in bytes of the buffer <responseBuf>")
547 ),
548 
549 /* Wrap API */
550 FALSE,
551 
552 /* Tags */
553 "Core"
554 /********************************************************************************************************************/
555 )
556 
557 
558 
559 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
560 /********************************************************************************************************************/
561 /* API Declaration */
562 const char* const RMH_MacToString(const RMH_MacAddress_t value, char* responseBuf, const size_t responseBufSize),
563 
564 /* API Name */
565 RMH_MacToString,
566 
567 /* Description */
568 "Return a the provded MAC address in <value> as a string.",
569 
570 /* Parameters */
571 PARAMETERS(
572  INPUT_PARAM(value, const RMH_MacAddress_t, "A byte array MAC address"),
573  OUTPUT_PARAM(responseBuf, char*, "A buffer where the MAC string will be written"),
574  INPUT_PARAM(responseBufSize, const size_t, "The size in bytes of the buffer <responseBuf>")
575 ),
576 
577 /* Wrap API */
578 FALSE,
579 
580 /* Tags */
581 "Core,mac"
582 /********************************************************************************************************************/
583 )
584 
585 
586 
587 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
588 /********************************************************************************************************************/
589 /* API Declaration */
590 const char* const RMH_ACATypeToString(const RMH_ACAType value),
591 
592 /* API Name */
593 RMH_ACATypeToString,
594 
595 /* Description */
596 "Convert <value> to a printable string.",
597 
598 /* Parameters */
599 PARAMETERS(
600  INPUT_PARAM(value, const RMH_ACAType, "Value to be printed as a string")
601 ),
602 
603 /* Wrap API */
604 FALSE,
605 
606 /* Tags */
607 "Core"
608 /********************************************************************************************************************/
609 )
610 
611 
612 
613 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
614 /********************************************************************************************************************/
615 /* API Declaration */
616 const char* const RMH_ACAStatusToString(const RMH_ACAStatus value),
617 
618 /* API Name */
619 RMH_ACAStatusToString,
620 
621 /* Description */
622 "Convert <value> to a printable string.",
623 
624 /* Parameters */
625 PARAMETERS(
626  INPUT_PARAM(value, const RMH_ACAStatus, "Value to be printed as a string")
627 ),
628 
629 /* Wrap API */
630 FALSE,
631 
632 /* Tags */
633 "Core"
634 /********************************************************************************************************************/
635 )
636 
637 
638 
639 RMH_API_IMPLEMENTATION_SOC_ONLY(
640 /********************************************************************************************************************/
641 /* API Declaration */
642 
643 RMH_Result RMH_Self_GetEnabled(const RMH_Handle handle, bool* response),
644 
645 /* API Name */
646 RMH_Self_GetEnabled,
647 
648 /* Description */
649 "Return if the MoCA driver is actively connected to or attempting to connect to a MoCA network",
650 
651 /* Parameters */
652 PARAMETERS(
653  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
654  OUTPUT_PARAM(response, bool*,
655  "Set to 'true' if the MoCA driver is active. Otherwise set to 'false'.")
656 ),
657 
658 /* Wrap API */
659 TRUE,
660 
661 /* Tags */
662 "Self,Status"
663 /********************************************************************************************************************/
664 )
665 
666 
667 
668 RMH_API_IMPLEMENTATION_SOC_ONLY(
669 /********************************************************************************************************************/
670 /* API Declaration */
671 RMH_Result RMH_Self_SetEnabled(const RMH_Handle handle, const bool value),
672 
673 /* API Name */
674 RMH_Self_SetEnabled,
675 
676 /* Description */
677 "Enable or disable the MoCA driver to connect to a MoCA network. Once enabled the driver will use whatever "
678 "parameters it has been configured for.",
679 
680 /* Parameters */
681 PARAMETERS(
682  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
683  INPUT_PARAM(value, const bool,
684  "Pass 'true' to enable the MoCA driver. Otherwise pass to 'false'.")
685 ),
686 
687 /* Wrap API */
688 TRUE,
689 
690 /* Tags */
691 "Configuration [Set]"
692 /********************************************************************************************************************/
693 )
694 
695 
696 
697 RMH_API_IMPLEMENTATION_SOC_ONLY(
698 /********************************************************************************************************************/
699 /* API Declaration */
700 RMH_Result RMH_Self_GetMoCALinkUp(const RMH_Handle handle, bool* response),
701 
702 /* API Name */
703 RMH_Self_GetMoCALinkUp,
704 
705 /* Description */
706 "Check if this device is actively connected to a MoCA network. If so, RMH_Network and RMH_Remote APIs will then be "
707 "valid to call.",
708 
709 /* Parameters */
710 PARAMETERS(
711  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
712  OUTPUT_PARAM(response, bool*,
713  "Set to 'true' if this is device is actively connected to a MoCA Network")
714 ),
715 
716 /* Wrap API */
717 TRUE,
718 
719 /* Tags */
720 "Configuration [Get],Link"
721 /********************************************************************************************************************/
722 )
723 
724 
725 
726 RMH_API_IMPLEMENTATION_SOC_ONLY(
727 /********************************************************************************************************************/
728 /* API Declaration */
729 RMH_Result RMH_Self_GetLOF(const RMH_Handle handle, uint32_t* response),
730 
731 /* API Name */
732 RMH_Self_GetLOF,
733 
734 /* Description */
735 "The last frequency on which this device operated.",
736 
737 /* Parameters */
738 PARAMETERS(
739  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
740  OUTPUT_PARAM(response, uint32_t*, "The last operating frequency of the device")
741 ),
742 
743 /* Wrap API */
744 TRUE,
745 
746 /* Tags */
747 "Configuration [Get],Frequency"
748 /********************************************************************************************************************/
749 )
750 
751 
752 
753 RMH_API_IMPLEMENTATION_SOC_ONLY(
754 /********************************************************************************************************************/
755 /* API Declaration */
756 RMH_Result RMH_Self_SetLOF(const RMH_Handle handle, const uint32_t value),
757 
758 /* API Name */
759 RMH_Self_SetLOF,
760 
761 /* Description */
762 "Manually set the last operating frequency of the device. This can be helpful to control what frequency is used for "
763 " future network connections.",
764 
765 /* Parameters */
766 PARAMETERS(
767  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
768  INPUT_PARAM(value, const uint32_t, "The desired last operating frequency of the device")
769 ),
770 
771 /* Wrap API */
772 TRUE,
773 
774 /* Tags */
775 "Configuration [Set],Frequency"
776 /********************************************************************************************************************/
777 )
778 
779 
780 
781 RMH_API_IMPLEMENTATION_SOC_ONLY(
782 /********************************************************************************************************************/
783 /* API Declaration */
784 RMH_Result RMH_Self_GetScanLOFOnly(const RMH_Handle handle, bool* response),
785 
786 /* API Name */
787 RMH_Self_GetScanLOFOnly,
788 
789 /* Description */
790 "Return if the device is scanning only the last operating frequency when attempting to establish a connection to a "
791 "MoCA network",
792 
793 /* Parameters */
794 PARAMETERS(
795  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
796  OUTPUT_PARAM(response, bool*,
797  "Set to 'true' if only the LOF is being checked when joining a MoCA network. Otherwise set to 'false'.")
798 ),
799 
800 /* Wrap API */
801 TRUE,
802 
803 /* Tags */
804 "Configuration [Get],Frequency"
805 /********************************************************************************************************************/
806 )
807 
808 
809 
810 RMH_API_IMPLEMENTATION_SOC_ONLY(
811 /********************************************************************************************************************/
812 /* API Declaration */
813 RMH_Result RMH_Self_SetScanLOFOnly(const RMH_Handle handle, const bool value),
814 
815 /* API Name */
816 RMH_Self_SetScanLOFOnly,
817 
818 /* Description */
819 "Indicate if the device should join networks only on the last operating frequency. This is helpful to control the "
820 "exact frequency used for MoCA",
821 
822 /* Parameters */
823 PARAMETERS(
824  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
825  INPUT_PARAM(value, const bool,
826  "Pass 'true' to ensure this node will only join a network at the LOF. Otherwise pass to 'false'.")
827 ),
828 
829 /* Wrap API */
830 TRUE,
831 
832 /* Tags */
833 "Configuration [Set],Frequency"
834 /********************************************************************************************************************/
835 )
836 
837 
838 
839 RMH_API_IMPLEMENTATION_SOC_ONLY(
840 /********************************************************************************************************************/
841 /* API Declaration */
842 RMH_Result RMH_Self_GetPreferredNCEnabled(const RMH_Handle handle, bool* response),
843 
844 /* API Name */
845 RMH_Self_GetPreferredNCEnabled,
846 
847 /* Description */
848 "Return if this device is a preferred NC.",
849 
850 /* Parameters */
851 PARAMETERS(
852  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
853  OUTPUT_PARAM(response, bool*,
854  "Set to 'true' if the device is a preferred NC. Otherwise set to 'false'.")
855 ),
856 
857 /* Wrap API */
858 TRUE,
859 
860 /* Tags */
861 "Configuration [Get],NC"
862 /********************************************************************************************************************/
863 )
864 
865 
866 
867 RMH_API_IMPLEMENTATION_SOC_ONLY(
868 /********************************************************************************************************************/
869 /* API Declaration */
870 RMH_Result RMH_Self_SetPreferredNCEnabled(const RMH_Handle handle, const bool value),
871 
872 /* API Name */
873 RMH_Self_SetPreferredNCEnabled,
874 
875 /* Description */
876 "Enable or disable preferred NC on this device. If this is enabled the device has a greater chance of becoming the NC, "
877 "if set disable the chance of becoming the NC is reduced. However, please keep in mind that depending on your network "
878 "configuration, a device with preferred NC disabled could still become the NC."
879 "\n**NOTE: Setting this value may trigger a restart of the MoCA driver and cause the device to temporarily leave the network.",
880 
881 /* Parameters */
882 PARAMETERS(
883  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
884  INPUT_PARAM(value, const bool,
885  "Pass 'true' to enable this device as a preferred NC. Otherwise pass to 'false'.")
886 ),
887 
888 /* Wrap API */
889 TRUE,
890 
891 /* Tags */
892 "Configuration [Set],NC"
893 /********************************************************************************************************************/
894 )
895 
896 
897 
898 RMH_API_IMPLEMENTATION_SOC_ONLY(
899 /********************************************************************************************************************/
900 /* API Declaration */
901 RMH_Result RMH_Self_GetPrimaryChannelOffset(const RMH_Handle handle, int32_t* response),
902 
903 /* API Name */
904 RMH_Self_GetPrimaryChannelOffset,
905 
906 /* Description */
907 "TBD [mocaIfPrimaryChannelOffset]",
908 
909 /* Parameters */
910 PARAMETERS(
911  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
912  OUTPUT_PARAM(response, int32_t*, "TBD")
913 ),
914 
915 /* Wrap API */
916 TRUE,
917 
918 /* Tags */
919 "Configuration [Get],NC"
920 /********************************************************************************************************************/
921 )
922 
923 
924 
925 RMH_API_IMPLEMENTATION_SOC_ONLY(
926 /********************************************************************************************************************/
927 /* API Declaration */
928 RMH_Result RMH_Self_SetPrimaryChannelOffset(const RMH_Handle handle, const int32_t value),
929 
930 /* API Name */
931 RMH_Self_SetPrimaryChannelOffset,
932 
933 /* Description */
934 "TBD [mocaIfSecondaryChannelOffset]",
935 
936 /* Parameters */
937 PARAMETERS(
938  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
939  INPUT_PARAM(value, const int32_t, "TBD")
940 ),
941 
942 /* Wrap API */
943 TRUE,
944 
945 /* Tags */
946 "Configuration [Set],NC"
947 /********************************************************************************************************************/
948 )
949 
950 
951 
952 RMH_API_IMPLEMENTATION_SOC_ONLY(
953 /********************************************************************************************************************/
954 /* API Declaration */
955 RMH_Result RMH_Self_GetSecondaryChannelOffset(const RMH_Handle handle, int32_t* response),
956 
957 /* API Name */
958 RMH_Self_GetSecondaryChannelOffset,
959 
960 /* Description */
961 "TBD",
962 
963 /* Parameters */
964 PARAMETERS(
965  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
966  OUTPUT_PARAM(response, int32_t*, "TBD")
967 ),
968 
969 /* Wrap API */
970 TRUE,
971 
972 /* Tags */
973 "Configuration [Get],NC"
974 /********************************************************************************************************************/
975 )
976 
977 
978 
979 RMH_API_IMPLEMENTATION_SOC_ONLY(
980 /********************************************************************************************************************/
981 /* API Declaration */
982 RMH_Result RMH_Self_SetSecondaryChannelOffset(const RMH_Handle handle, const int32_t value),
983 
984 /* API Name */
985 RMH_Self_SetSecondaryChannelOffset,
986 
987 /* Description */
988 "TBD",
989 
990 /* Parameters */
991 PARAMETERS(
992  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
993  INPUT_PARAM(value, const int32_t, "TBD")
994 ),
995 
996 /* Wrap API */
997 TRUE,
998 
999 /* Tags */
1000 "Configuration [Set],NC"
1001 /********************************************************************************************************************/
1002 )
1003 
1004 
1005 
1006 RMH_API_IMPLEMENTATION_SOC_ONLY(
1007 /********************************************************************************************************************/
1008 /* API Declaration */
1009 RMH_Result RMH_Self_GetSoftwareVersion(const RMH_Handle handle, char* responseBuf, const size_t responseBufSize),
1010 
1011 /* API Name */
1012 RMH_Self_GetSoftwareVersion,
1013 
1014 /* Description */
1015 "Return the version of software being used by the MoCA driver on this device. [mocaIfSoftwareVersion]",
1016 
1017 /* Parameters */
1018 PARAMETERS(
1019  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1020  OUTPUT_PARAM(responseBuf, char*, "A buffer where the software version string will be written"),
1021  INPUT_PARAM(responseBufSize, const size_t, "The size in bytes of the buffer <responseBuf>")
1022 ),
1023 
1024 /* Wrap API */
1025 TRUE,
1026 
1027 /* Tags */
1028 "Configuration [Get],Version"
1029 /********************************************************************************************************************/
1030 )
1031 
1032 
1033 
1034 RMH_API_IMPLEMENTATION_SOC_ONLY(
1035 /********************************************************************************************************************/
1036 /* API Declaration */
1037 RMH_Result RMH_Self_GetHighestSupportedMoCAVersion(const RMH_Handle handle, RMH_MoCAVersion* response),
1038 
1039 /* API Name */
1040 RMH_Self_GetHighestSupportedMoCAVersion,
1041 
1042 /* Description */
1043 "Return the highest version of MoCA supported by the MoCA driver on this device. [mocaIfMocaVersion]",
1044 
1045 /* Parameters */
1046 PARAMETERS(
1047  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1048  OUTPUT_PARAM(response, RMH_MoCAVersion*, "The highest version of MoCA supported")
1049 ),
1050 
1051 /* Wrap API */
1052 TRUE,
1053 
1054 /* Tags */
1055 "Configuration [Get],Version"
1056 /********************************************************************************************************************/
1057 )
1058 
1059 
1060 
1061 RMH_API_IMPLEMENTATION_SOC_ONLY(
1062 /********************************************************************************************************************/
1063 /* API Declaration */
1064 RMH_Result RMH_Self_GetFrequencyMask(const RMH_Handle handle, uint32_t* response),
1065 
1066 /* API Name */
1067 RMH_Self_GetFrequencyMask,
1068 
1069 /* Description */
1070 "Set the bit mask for specifying which frequencies should be scanned during the listening phase of network search. "
1071 "Depending on the RF band of operation, the MSB of this parameter corresponds to the lowest frequency channel of the band. "
1072 "Each subsequent bit of this parameter represents the next highest 25MHz channel. The base channels for each RF band "
1073 "are as follows:\n\n"
1074 "\tBand D-Low : 46 (1150 MHz)\n"
1075 "\tBand D-High: 56 (1400 MHz)\n"
1076 "\tBand Ext-D : 46 (1150 MHz)\n"
1077 "\tBand C4 : 40 (1000 MHz)\n"
1078 "\tBand E : 20 ( 500 MHz)\n"
1079 "\tBand F : 27 ( 675 MHz)\n"
1080 "\tBand H : 39 ( 975 MHz)",
1081 
1082 /* Parameters */
1083 PARAMETERS(
1084  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1085  OUTPUT_PARAM(response, uint32_t*,
1086  "The bitmask of frequencies this device will use when joining a network")
1087 ),
1088 
1089 /* Wrap API */
1090 TRUE,
1091 
1092 /* Tags */
1093 "Configuration [Get],Frequency"
1094 /********************************************************************************************************************/
1095 )
1096 
1097 
1098 
1099 RMH_API_IMPLEMENTATION_SOC_ONLY(
1100 /********************************************************************************************************************/
1101 /* API Declaration */
1102 RMH_Result RMH_Self_SetFrequencyMask(const RMH_Handle handle, const uint32_t value),
1103 
1104 /* API Name */
1105 RMH_Self_SetFrequencyMask,
1106 
1107 /* Description */
1108 "Set the bit mask for specifying which frequencies should be scanned during the listening phase of network search. "
1109 "Depending on the RF band of operation, the MSB of this parameter corresponds to the lowest frequency channel of the band. "
1110 "Each subsequent bit of this parameter represents the next highest 25MHz channel. The base channels for each RF band "
1111 "are as follows:\n\n"
1112 "\tBand D-Low : 46 (1150 MHz)\n"
1113 "\tBand D-High: 56 (1400 MHz)\n"
1114 "\tBand Ext-D : 46 (1150 MHz)\n"
1115 "\tBand C4 : 40 (1000 MHz)\n"
1116 "\tBand E : 20 ( 500 MHz)\n"
1117 "\tBand F : 27 ( 675 MHz)\n"
1118 "\tBand H : 39 ( 975 MHz)\n",
1119 
1120 /* Parameters */
1121 PARAMETERS(
1122  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1123  INPUT_PARAM(value, const uint32_t,
1124  "The bitmask of frequencies this device should use when joining a network")
1125 ),
1126 
1127 /* Wrap API */
1128 TRUE,
1129 
1130 /* Tags */
1131 "Configuration [Set],Frequency"
1132 /********************************************************************************************************************/
1133 )
1134 
1135 
1136 
1137 RMH_API_IMPLEMENTATION_SOC_ONLY(
1138 /********************************************************************************************************************/
1139 /* API Declaration */
1140 RMH_Result RMH_Self_GetMaxPacketAggregation(const RMH_Handle handle, uint32_t* response),
1141 
1142 /* API Name */
1143 RMH_Self_GetMaxPacketAggregation,
1144 
1145 /* Description */
1146 "Get the maximum number of packets this device will aggregate. [mocaIfPduNumber]",
1147 
1148 /* Parameters */
1149 PARAMETERS(
1150  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1151  OUTPUT_PARAM(response, uint32_t*, "The maximum number of packets this device will aggregate")
1152 ),
1153 
1154 /* Wrap API */
1155 TRUE,
1156 
1157 /* Tags */
1158 "Configuration [Get]"
1159 /********************************************************************************************************************/
1160 )
1161 
1162 
1163 
1164 RMH_API_IMPLEMENTATION_SOC_ONLY(
1165 /********************************************************************************************************************/
1166 /* API Declaration */
1167 RMH_Result RMH_Self_SetMaxPacketAggregation(const RMH_Handle handle, const uint32_t value),
1168 
1169 /* API Name */
1170 RMH_Self_SetMaxPacketAggregation,
1171 
1172 /* Description */
1173 "Set the maximum allowed packets for aggregated transmissions.",
1174 
1175 /* Parameters */
1176 PARAMETERS(
1177  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1178  INPUT_PARAM(value, const uint32_t, "The maximum number of packets this device can aggregate")
1179 ),
1180 
1181 /* Wrap API */
1182 TRUE,
1183 
1184 /* Tags */
1185 "Configuration [Set]"
1186 /********************************************************************************************************************/
1187 )
1188 
1189 
1190 
1191 RMH_API_IMPLEMENTATION_SOC_ONLY(
1192 /********************************************************************************************************************/
1193 /* API Declaration */
1194 RMH_Result RMH_Self_GetMaxFrameSize(const RMH_Handle handle, uint32_t* response),
1195 
1196 /* API Name */
1197 RMH_Self_GetMaxFrameSize,
1198 
1199 /* Description */
1200 "The maximum number of bytes this node can receive in one frame (aggregated transmission). [mocaIfAggregationSize]",
1201 
1202 /* Parameters */
1203 PARAMETERS(
1204  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1205  OUTPUT_PARAM(response, uint32_t*, "The maximum number of packets this device will aggregate")
1206 ),
1207 
1208 /* Wrap API */
1209 TRUE,
1210 
1211 /* Tags */
1212 "Configuration [Get]"
1213 /********************************************************************************************************************/
1214 )
1215 
1216 
1217 
1218 RMH_API_IMPLEMENTATION_SOC_ONLY(
1219 /********************************************************************************************************************/
1220 /* API Declaration */
1221 RMH_Result RMH_Self_SetMaxFrameSize(const RMH_Handle handle, const uint32_t value),
1222 
1223 /* API Name */
1224 RMH_Self_SetMaxFrameSize,
1225 
1226 /* Description */
1227 "Set the maximum number of bytes this node can receive in one frame (aggregated transmission).",
1228 
1229 /* Parameters */
1230 PARAMETERS(
1231  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1232  INPUT_PARAM(value, const uint32_t, "The maximum number of packets this device can aggregate")
1233 ),
1234 
1235 /* Wrap API */
1236 TRUE,
1237 
1238 /* Tags */
1239 "Configuration [Set]"
1240 /********************************************************************************************************************/
1241 )
1242 
1243 
1244 
1245 RMH_API_IMPLEMENTATION_SOC_ONLY(
1246 /********************************************************************************************************************/
1247 /* API Declaration */
1248 RMH_Result RMH_Self_GetLowBandwidthLimit(const RMH_Handle handle, uint32_t* response),
1249 
1250 /* API Name */
1251 RMH_Self_GetLowBandwidthLimit,
1252 
1253 /* Description */
1254 "Get the current lower limit for PHY rate between two nodes.",
1255 
1256 /* Parameters */
1257 PARAMETERS(
1258  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1259  OUTPUT_PARAM(response, uint32_t*, "The lower PHY limit")
1260 ),
1261 
1262 /* Wrap API */
1263 TRUE,
1264 
1265 /* Tags */
1266 "Configuration [Get]"
1267 /********************************************************************************************************************/
1268 )
1269 
1270 
1271 
1272 RMH_API_IMPLEMENTATION_SOC_ONLY(
1273 /********************************************************************************************************************/
1274 /* API Declaration */
1275 RMH_Result RMH_Self_SetLowBandwidthLimit(const RMH_Handle handle, const uint32_t value),
1276 
1277 /* API Name */
1278 RMH_Self_SetLowBandwidthLimit,
1279 
1280 /* Description */
1281 "Set the lower threshold for the PHY link bandwidth between two nodes. If the rate falls below this limit a callback "
1282 "of type <RMH_EVENT_LOW_BANDWIDTH> will be triggered",
1283 
1284 /* Parameters */
1285 PARAMETERS(
1286  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1287  INPUT_PARAM(value, const uint32_t, "The new value to use as the lower PHY limit")
1288 ),
1289 
1290 /* Wrap API */
1291 TRUE,
1292 
1293 /* Tags */
1294 "Configuration [Set]"
1295 /********************************************************************************************************************/
1296 )
1297 
1298 
1299 
1300 RMH_API_IMPLEMENTATION_SOC_ONLY(
1301 /********************************************************************************************************************/
1302 /* API Declaration */
1303 RMH_Result RMH_Self_GetMaxBitrate(const RMH_Handle handle, uint32_t* response),
1304 
1305 /* API Name */
1306 RMH_Self_GetMaxBitrate,
1307 
1308 /* Description */
1309 "The maximum PHY rate supported in non-turbo mode.",
1310 
1311 /* Parameters */
1312 PARAMETERS(
1313  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1314  OUTPUT_PARAM(response, uint32_t*, "The maximum PHY rate")
1315 ),
1316 
1317 /* Wrap API */
1318 TRUE,
1319 
1320 /* Tags */
1321 "Configuration [Get],Phy"
1322 /********************************************************************************************************************/
1323 )
1324 
1325 
1326 
1327 RMH_API_IMPLEMENTATION_SOC_ONLY(
1328 /********************************************************************************************************************/
1329 /* API Declaration */
1330 RMH_Result RMH_Self_SetTxPowerLimit(const RMH_Handle handle, const int32_t value),
1331 
1332 /* API Name */
1333 RMH_Self_SetTxPowerLimit,
1334 
1335 /* Description */
1336 "Set the maximum transmitter power level for this device."
1337 "\n**NOTE: Setting this value may trigger a restart of the MoCA driver and cause the device to temporarily leave the network.",
1338 
1339 /* Parameters */
1340 PARAMETERS(
1341  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1342  INPUT_PARAM(value, const int32_t, "Desired transmitter power level. Minimum value -31, maximum value 3.")
1343 ),
1344 
1345 /* Wrap API */
1346 TRUE,
1347 
1348 /* Tags */
1349 "Configuration [Set],Power"
1350 /********************************************************************************************************************/
1351 )
1352 
1353 
1354 
1355 RMH_API_IMPLEMENTATION_SOC_ONLY(
1356 /********************************************************************************************************************/
1357 /* API Declaration */
1358 RMH_Result RMH_Self_GetTxPowerLimit(const RMH_Handle handle, int32_t* response),
1359 
1360 /* API Name */
1361 RMH_Self_GetTxPowerLimit,
1362 
1363 /* Description */
1364 "Get the current maximum transmission power level for this device.",
1365 
1366 /* Parameters */
1367 PARAMETERS(
1368  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1369  OUTPUT_PARAM(response, int32_t*, "The maximum transmission power for this device")
1370 ),
1371 
1372 /* Wrap API */
1373 TRUE,
1374 
1375 /* Tags */
1376 "Configuration [Get],Power"
1377 /********************************************************************************************************************/
1378 )
1379 
1380 
1381 
1382 RMH_API_IMPLEMENTATION_SOC_ONLY(
1383 /********************************************************************************************************************/
1384 /* API Declaration */
1385 RMH_Result RMH_Self_GetSupportedFrequencies(const RMH_Handle handle, uint32_t* responseArray, const size_t responseArraySize, size_t* responseArrayUsed),
1386 
1387 /* API Name */
1388 RMH_Self_GetSupportedFrequencies,
1389 
1390 /* Description */
1391 "Return a list of frequencies in the band used by this node. This frequency list does not account for taboo channels "
1392 "or other filters which would limit the scope of frequencies this device would use to join a network. [mocaIfChannelSupport]",
1393 
1394 /* Parameters */
1395 PARAMETERS(
1396  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1397  OUTPUT_PARAM(responseArray, uint32_t*, "An array where the frequency list should be stored"),
1398  INPUT_PARAM(responseArraySize, const size_t, "The size of the response array"),
1399  OUTPUT_PARAM(responseArrayUsed, size_t*, "The number of entries in the response array which have valid data")
1400 ),
1401 
1402 /* Wrap API */
1403 TRUE,
1404 
1405 /* Tags */
1406 "Configuration [Get],Frequency"
1407 /********************************************************************************************************************/
1408 )
1409 
1410 
1411 
1412 RMH_API_IMPLEMENTATION_SOC_ONLY(
1413 /********************************************************************************************************************/
1414 /* API Declaration */
1415 RMH_Result RMH_Self_GetSupportedBand(const RMH_Handle handle, RMH_Band* response),
1416 
1417 /* API Name */
1418 RMH_Self_GetSupportedBand,
1419 
1420 /* Description */
1421 "Return the band supported by the MoCA device. [mocaIfSupportedBands]\n\n"
1422 " --- Band Frequencies -------------------------------------------------------\n"
1423 " RMH_BAND_C4 [MoCA 1.1]: 1000\n"
1424 " RMH_BAND_D [MoCA 1.1]: 1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500\n"
1425 " RMH_BAND_D_LOW: 1125, 1150, 1175, 1200, 1225\n"
1426 " RMH_BAND_D_HIGH: 1350, 1375, 1400, 1425, 1450, 1475, 1500, 1525, 1550, 1575, 1600, 1625\n"
1427 " RMH_BAND_D_EX: 1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500\n"
1428 " RMH_BAND_E: 500, 525, 550, 575, 600\n"
1429 " RMH_BAND_F: 675, 700, 725, 750, 775, 800, 825, 850\n"
1430 " RMH_BAND_H: 975, 1000, 1025\n",
1431 
1432 /* Parameters */
1433 PARAMETERS(
1434  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1435  OUTPUT_PARAM(response, RMH_Band*, "The band supported by this MoCA device")
1436 ),
1437 
1438 /* Wrap API */
1439 TRUE,
1440 
1441 /* Tags */
1442 "Configuration [Get],Frequency"
1443 /********************************************************************************************************************/
1444 )
1445 
1446 
1447 
1448 RMH_API_IMPLEMENTATION_SOC_ONLY(
1449 /********************************************************************************************************************/
1450 /* API Declaration */
1451 RMH_Result RMH_Self_GetQAM256Enabled(const RMH_Handle handle, bool* response),
1452 
1453 /* API Name */
1454 RMH_Self_GetQAM256Enabled,
1455 
1456 /* Description */
1457 "Return if this device is set as QAM256 capable in admission negotiations.",
1458 
1459 /* Parameters */
1460 PARAMETERS(
1461  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1462  OUTPUT_PARAM(response, bool*, "Set to 'true' if QAM256 support is enabled. Otherwise set to 'false'.")
1463 ),
1464 
1465 /* Wrap API */
1466 TRUE,
1467 
1468 /* Tags */
1469 "Self,QAM"
1470 /********************************************************************************************************************/
1471 )
1472 
1473 
1474 
1475 RMH_API_IMPLEMENTATION_SOC_ONLY(
1476 /********************************************************************************************************************/
1477 /* API Declaration */
1478 RMH_Result RMH_Self_SetQAM256Enabled(const RMH_Handle handle, const bool value),
1479 
1480 /* API Name */
1481 RMH_Self_SetQAM256Enabled,
1482 
1483 /* Description */
1484 "Enable or disable the QAM256 ability in admission negotiations."
1485 "\n**NOTE: Setting this value may trigger a restart of the MoCA driver and cause the device to temporarily leave the network.",
1486 
1487 /* Parameters */
1488 PARAMETERS(
1489  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1490  INPUT_PARAM(value, const bool, "Pass 'true' to enable QAM256 support on this device. Otherwise pass to 'false'.")
1491 ),
1492 
1493 /* Wrap API */
1494 TRUE,
1495 
1496 /* Tags */
1497 "Configuration [Set],QAM"
1498 /********************************************************************************************************************/
1499 )
1500 
1501 
1502 
1503 RMH_API_IMPLEMENTATION_SOC_ONLY(
1504 /********************************************************************************************************************/
1505 /* API Declaration */
1506 RMH_Result RMH_Self_GetQAM256TargetPhyRate(const RMH_Handle handle, uint32_t* response),
1507 
1508 /* API Name */
1509 RMH_Self_GetQAM256TargetPhyRate,
1510 
1511 /* Description */
1512 "Get the target PHY rate for normal transmissions to MoCA 1.1 nodes when they support qam256",
1513 
1514 /* Parameters */
1515 PARAMETERS(
1516  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1517  OUTPUT_PARAM(response, uint32_t*, "The target PHY rate in Mbps")
1518 ),
1519 
1520 /* Wrap API */
1521 TRUE,
1522 
1523 /* Tags */
1524 "Self,QAM,Phy"
1525 /********************************************************************************************************************/
1526 )
1527 
1528 
1529 
1530 RMH_API_IMPLEMENTATION_SOC_ONLY(
1531 /********************************************************************************************************************/
1532 /* API Declaration */
1533 RMH_Result RMH_Self_SetQAM256TargetPhyRate(const RMH_Handle handle, const uint32_t value),
1534 
1535 /* API Name */
1536 RMH_Self_SetQAM256TargetPhyRate,
1537 
1538 /* Description */
1539 "Set the target PHY rate for normal transmissions to MoCA 1.1 nodes when they support qam256",
1540 
1541 /* Parameters */
1542 PARAMETERS(
1543  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1544  INPUT_PARAM(value, const uint32_t, "The target PHY rate in Mbps")
1545 ),
1546 
1547 /* Wrap API */
1548 TRUE,
1549 
1550 /* Tags */
1551 "Configuration [Set],QAM,Phy"
1552 /********************************************************************************************************************/
1553 )
1554 
1555 
1556 
1557 RMH_API_IMPLEMENTATION_SOC_ONLY(
1558 /********************************************************************************************************************/
1559 /* API Declaration */
1560 
1561 RMH_Result RMH_Self_GetPrimaryChannelTargetPhyRate(const RMH_Handle handle, uint32_t* response),
1562 
1563 /* API Name */
1564 RMH_Self_GetPrimaryChannelTargetPhyRate,
1565 
1566 /* Description */
1567 "Get the target PHY rate for unicast transmissions on the primary channel.",
1568 
1569 /* Parameters */
1570 PARAMETERS(
1571  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1572  OUTPUT_PARAM(response, uint32_t*, "The target PHY rate in Mbps")
1573 ),
1574 
1575 /* Wrap API */
1576 TRUE,
1577 
1578 /* Tags */
1579 "Self,QAM,Phy"
1580 /********************************************************************************************************************/
1581 )
1582 
1583 
1584 
1585 RMH_API_IMPLEMENTATION_SOC_ONLY(
1586 /********************************************************************************************************************/
1587 /* API Declaration */
1588 RMH_Result RMH_Self_SetPrimaryChannelTargetPhyRate(const RMH_Handle handle, const uint32_t value),
1589 
1590 /* API Name */
1591 RMH_Self_SetPrimaryChannelTargetPhyRate,
1592 
1593 /* Description */
1594 "Set the target PHY rate for unicast transmissions on the primary channel.",
1595 
1596 /* Parameters */
1597 PARAMETERS(
1598  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1599  INPUT_PARAM(value, const uint32_t, "The target PHY rate in Mbps")
1600 ),
1601 
1602 /* Wrap API */
1603 TRUE,
1604 
1605 /* Tags */
1606 "Configuration [Set],QAM,Phy"
1607 /********************************************************************************************************************/
1608 )
1609 
1610 
1611 RMH_API_IMPLEMENTATION_SOC_ONLY(
1612 /********************************************************************************************************************/
1613 /* API Declaration */
1614 RMH_Result RMH_Self_GetSecondaryChannelTargetPhyRate(const RMH_Handle handle, uint32_t* response),
1615 
1616 /* API Name */
1617 RMH_Self_GetSecondaryChannelTargetPhyRate,
1618 
1619 /* Description */
1620 "Get the target PHY rate for unicast transmissions on the secondary channel.",
1621 
1622 /* Parameters */
1623 PARAMETERS(
1624  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1625  OUTPUT_PARAM(response, uint32_t*, "The target PHY rate in Mbps")
1626 ),
1627 
1628 /* Wrap API */
1629 TRUE,
1630 
1631 /* Tags */
1632 "Self,QAM,Phy"
1633 /********************************************************************************************************************/
1634 )
1635 
1636 
1637 
1638 RMH_API_IMPLEMENTATION_SOC_ONLY(
1639 /********************************************************************************************************************/
1640 /* API Declaration */
1641 RMH_Result RMH_Self_SetSecondaryChannelTargetPhyRate(const RMH_Handle handle, const uint32_t value),
1642 
1643 /* API Name */
1644 RMH_Self_SetSecondaryChannelTargetPhyRate,
1645 
1646 /* Description */
1647 "Set the target PHY rate for unicast transmissions on the secondary channel.",
1648 
1649 /* Parameters */
1650 PARAMETERS(
1651  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1652  INPUT_PARAM(value, const uint32_t, "The target PHY rate in Mbps")
1653 ),
1654 
1655 /* Wrap API */
1656 TRUE,
1657 
1658 /* Tags */
1659 "Configuration [Set],QAM,Phy"
1660 /********************************************************************************************************************/
1661 )
1662 
1663 
1664 
1665 RMH_API_IMPLEMENTATION_SOC_ONLY(
1666 /********************************************************************************************************************/
1667 /* API Declaration */
1668 RMH_Result RMH_Self_GetTurboEnabled(const RMH_Handle handle, bool* response),
1669 
1670 /* API Name */
1671 RMH_Self_GetTurboEnabled,
1672 
1673 /* Description */
1674 "Return if turbo mode is enabled on this device",
1675 
1676 /* Parameters */
1677 PARAMETERS(
1678  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1679  OUTPUT_PARAM(response, bool*, "Set to 'true' if turbo is enabled. Otherwise set to 'false'.")
1680 ),
1681 
1682 /* Wrap API */
1683 TRUE,
1684 
1685 /* Tags */
1686 "Self,Turbo"
1687 /********************************************************************************************************************/
1688 )
1689 
1690 
1691 
1692 RMH_API_IMPLEMENTATION_SOC_ONLY(
1693 /********************************************************************************************************************/
1694 /* API Declaration */
1695 RMH_Result RMH_Self_SetTurboEnabled(const RMH_Handle handle, const bool value),
1696 
1697 /* API Name */
1698 RMH_Self_SetTurboEnabled,
1699 
1700 /* Description */
1701 "Enable or disable turbo mode on this device",
1702 
1703 /* Parameters */
1704 PARAMETERS(
1705  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1706  INPUT_PARAM(value, const bool, "Pass 'true' to enable turbo on this device. Otherwise pass to 'false'.")
1707 ),
1708 
1709 /* Wrap API */
1710 TRUE,
1711 
1712 /* Tags */
1713 "Configuration [Set],Turbo"
1714 /********************************************************************************************************************/
1715 )
1716 
1717 
1718 
1719 RMH_API_IMPLEMENTATION_SOC_ONLY(
1720 /********************************************************************************************************************/
1721 /* API Declaration */
1722 RMH_Result RMH_Self_GetBondingEnabled(const RMH_Handle handle, bool* response),
1723 
1724 /* API Name */
1725 RMH_Self_GetBondingEnabled,
1726 
1727 /* Description */
1728 "Return if bonding mode is enabled on this device",
1729 
1730 /* Parameters */
1731 PARAMETERS(
1732  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1733  OUTPUT_PARAM(response, bool*, "Set to 'true' if bonding is enabled. Otherwise set to 'false'.")
1734 ),
1735 
1736 /* Wrap API */
1737 TRUE,
1738 
1739 /* Tags */
1740 "Self,Bonding"
1741 /********************************************************************************************************************/
1742 )
1743 
1744 
1745 
1746 RMH_API_IMPLEMENTATION_SOC_ONLY(
1747 /********************************************************************************************************************/
1748 /* API Declaration */
1749 
1750 RMH_Result RMH_Self_SetBondingEnabled(const RMH_Handle handle, const bool value),
1751 
1752 /* API Name */
1753 RMH_Self_SetBondingEnabled,
1754 
1755 /* Description */
1756 "Enable or disable bonding mode on this device",
1757 
1758 /* Parameters */
1759 PARAMETERS(
1760  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1761  INPUT_PARAM(value, const bool, "Pass 'true' to enable bonding on this device. Otherwise pass to 'false'.")
1762 ),
1763 
1764 /* Wrap API */
1765 TRUE,
1766 
1767 /* Tags */
1768 "Configuration [Set],Bonding"
1769 /********************************************************************************************************************/
1770 )
1771 
1772 
1773 
1774 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
1775 /********************************************************************************************************************/
1776 /* API Declaration */
1777 RMH_Result RMH_Self_GetLinkStatus(const RMH_Handle handle, RMH_LinkStatus* status),
1778 
1779 /* API Name */
1780 RMH_Self_GetLinkStatus,
1781 
1782 /* Description */
1783 "Current operational status of the MoCA interface [mocaIfStatus]. This API combines all known information about the MoCA device, "
1784 "including the driver, MoCA link, interface status, ect. to determine if the link is functional. >RMH_LINK_STATUS_UP> "
1785 "indicates MoCA is ready for use.",
1786 
1787 /* Parameters */
1788 PARAMETERS(
1789  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1790  OUTPUT_PARAM(status, RMH_LinkStatus*, "The current link state of MoCA")
1791 ),
1792 
1793 /* Wrap API */
1794 TRUE,
1795 
1796 /* Tags */
1797 "Configuration [Get],Link"
1798 /********************************************************************************************************************/
1799 )
1800 
1801 
1802 
1803 RMH_API_IMPLEMENTATION_SOC_ONLY(
1804 /********************************************************************************************************************/
1805 /* API Declaration */
1806 RMH_Result RMH_Self_GetPrivacyEnabled(const RMH_Handle handle, bool* response),
1807 
1808 /* API Name */
1809 RMH_Self_GetPrivacyEnabled,
1810 
1811 /* Description */
1812 "Return if MoCA privacy is enabled on this device",
1813 
1814 /* Parameters */
1815 PARAMETERS(
1816  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1817  OUTPUT_PARAM(response, bool*, "Set to 'true' if MoCA privacy is enabled. Otherwise set to 'false'.")
1818 ),
1819 
1820 /* Wrap API */
1821 TRUE,
1822 
1823 /* Tags */
1824 "Configuration [Get],Self,Privacy"
1825 /********************************************************************************************************************/
1826 )
1827 
1828 
1829 
1830 RMH_API_IMPLEMENTATION_SOC_ONLY(
1831 /********************************************************************************************************************/
1832 /* API Declaration */
1833 RMH_Result RMH_Self_SetPrivacyEnabled(const RMH_Handle handle, const bool value),
1834 
1835 /* API Name */
1836 RMH_Self_SetPrivacyEnabled,
1837 
1838 /* Description */
1839 "Enable or disable MoCA privacy on this device. If enabled the device will only be permitted to join networks with "
1840 "other devices which have the same password.",
1841 
1842 /* Parameters */
1843 PARAMETERS(
1844  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1845  INPUT_PARAM(value, const bool, "Pass 'true' to enable MoCA privacy on this device. Otherwise pass to 'false'.")
1846 ),
1847 
1848 /* Wrap API */
1849 TRUE,
1850 
1851 /* Tags */
1852 "Configuration [Set],Self,Privacy"
1853 /********************************************************************************************************************/
1854 )
1855 
1856 
1857 
1858 RMH_API_IMPLEMENTATION_SOC_ONLY(
1859 /********************************************************************************************************************/
1860 /* API Declaration */
1861 RMH_Result RMH_Self_GetPrivacyPassword(const RMH_Handle handle, char* responseBuf, const size_t responseBufSize),
1862 
1863 /* API Name */
1864 RMH_Self_GetPrivacyPassword,
1865 
1866 /* Description */
1867 "Get the current MoCA privacy password.",
1868 
1869 /* Parameters */
1870 PARAMETERS(
1871  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1872  OUTPUT_PARAM(responseBuf, char*, "A buffer where the MoCA password will be written"),
1873  INPUT_PARAM(responseBufSize, const size_t, "The size in bytes of the buffer <responseBuf>")
1874 ),
1875 
1876 /* Wrap API */
1877 TRUE,
1878 
1879 /* Tags */
1880 "Self,Privacy"
1881 /********************************************************************************************************************/
1882 )
1883 
1884 
1885 
1886 RMH_API_IMPLEMENTATION_SOC_ONLY(
1887 /********************************************************************************************************************/
1888 /* API Declaration */
1889 RMH_Result RMH_Self_SetPrivacyPassword(const RMH_Handle handle, const char* value),
1890 
1891 /* API Name */
1892 RMH_Self_SetPrivacyPassword,
1893 
1894 /* Description */
1895 "Set the network password used to generate privacy keys. This string must be between 12 and 17 characters long with "
1896 "each character being a decimal number (0-9).",
1897 
1898 /* Parameters */
1899 PARAMETERS(
1900  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1901  INPUT_PARAM(value, const char*, "The MoCA network password. Although this is a string only 0-9 are permitted.")
1902 ),
1903 
1904 /* Wrap API */
1905 TRUE,
1906 
1907 /* Tags */
1908 "Configuration [Set],Privacy"
1909 /********************************************************************************************************************/
1910 )
1911 
1912 
1913 
1914 RMH_API_IMPLEMENTATION_SOC_ONLY(
1915 /********************************************************************************************************************/
1916 /* API Declaration */
1917 RMH_Result RMH_Self_GetPrivacyMACManagementKey(RMH_Handle handle, char* responseBuf, const size_t responseBufSize),
1918 
1919 /* API Name */
1920 RMH_Self_GetPrivacyMACManagementKey,
1921 
1922 /* Description */
1923 "Get the SHA1 hash of the MoCA password as an ASCII string. [mocaIfPasswordHash]",
1924 
1925 /* Parameters */
1926 PARAMETERS(
1927  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1928  OUTPUT_PARAM(responseBuf, char*, "A buffer where the MoCA managment key will be written"),
1929  INPUT_PARAM(responseBufSize, const size_t, "The size in bytes of the buffer <responseBuf>")
1930 ),
1931 
1932 /* Wrap API */
1933 TRUE,
1934 
1935 /* Tags */
1936 "Self,Privacy"
1937 /********************************************************************************************************************/
1938 )
1939 
1940 
1941 
1942 
1943 RMH_API_IMPLEMENTATION_SOC_ONLY(
1944 /********************************************************************************************************************/
1945 /* API Declaration */
1946 RMH_Result RMH_Self_GetTabooChannels(const RMH_Handle handle, uint32_t *channelMaskStart, uint32_t *channelMask),
1947 
1948 /* API Name */
1949 RMH_Self_GetTabooChannels,
1950 
1951 /* Description */
1952 "Return which channels will be taboo on this device. <channelMaskStart> will indicate the channel number of the lowest "
1953 "RF frequency covered by <channel mask>. The bitmask <channelMask> is then used to identify exactly which frequencies "
1954 "are taboo. Each consecutive bit of <channelMask> corresponds to channels offset by multiples of 25MHz. A bit in "
1955 "<channelMask> will be set to '1' if that channel is taboo.",
1956 
1957 /* Parameters */
1958 PARAMETERS(
1959  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1960  INPUT_PARAM(channelMaskStart, uint32_t*, "The channel number of the lowest frequency which is taboo"),
1961  INPUT_PARAM(channelMask, uint32_t*,
1962  "A bitmask of channels which are taboo. The first bit corresponds to the frequency of <channelMaskStart>")
1963 ),
1964 
1965 /* Wrap API */
1966 TRUE,
1967 
1968 /* Tags */
1969 "Self,Taboo,Frequency"
1970 /********************************************************************************************************************/
1971 )
1972 
1973 
1974 
1975 RMH_API_IMPLEMENTATION_SOC_ONLY(
1976 /********************************************************************************************************************/
1977 /* API Declaration */
1978 RMH_Result RMH_Self_SetTabooChannels(const RMH_Handle handle, const uint32_t channelMaskStart, const uint32_t channelMask),
1979 
1980 /* API Name */
1981 RMH_Self_SetTabooChannels,
1982 
1983 /* Description */
1984 "Set which channels will be taboo on this device. <channelMaskStart> will indicate the channel number of the lowest "
1985 "RF frequency covered by <channel mask>. The bitmask <channelMask> is then used to identify exactly which frequencies "
1986 "are taboo. Each consecutive bit of <channelMask> corresponds to channels offset by multiples of 25MHz. A bit in "
1987 "<channelMask> must be set to '1' if that channel is taboo.",
1988 
1989 /* Parameters */
1990 PARAMETERS(
1991  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
1992  INPUT_PARAM(channelMaskStart, const uint32_t, "The channel number of the lowest frequency which is taboo"),
1993  INPUT_PARAM(channelMask, const uint32_t,
1994  "A bitmask of channels which are taboo. The first bit corresponds to the frequency of <channelMaskStart>")
1995 ),
1996 
1997 /* Wrap API */
1998 TRUE,
1999 
2000 /* Tags */
2001 "Configuration [Set],Taboo"
2002 /********************************************************************************************************************/
2003 )
2004 
2005 
2006 
2007 RMH_API_IMPLEMENTATION_SOC_ONLY(
2008 /********************************************************************************************************************/
2009 /* API Declaration */
2010 RMH_Result RMH_Self_RestoreDefaultSettings(const RMH_Handle handle),
2011 
2012 /* API Name */
2013 RMH_Self_RestoreDefaultSettings,
2014 
2015 /* Description */
2016 "Return this device to its default MoCA configuration",
2017 
2018 /* Parameters */
2019 PARAMETERS(
2020  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize")
2021 ),
2022 
2023 /* Wrap API */
2024 TRUE,
2025 
2026 /* Tags */
2027 "Configuration [Set]"
2028 /********************************************************************************************************************/
2029 )
2030 
2031 
2032 
2033 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
2034 /********************************************************************************************************************/
2035 /* API Declaration */
2036 RMH_Result RMH_Self_RestoreRDKDefaultSettings(const RMH_Handle handle),
2037 
2038 /* API Name */
2039 RMH_Self_RestoreRDKDefaultSettings,
2040 
2041 /* Description */
2042 "Return this device to its default RDK MoCA configuration",
2043 
2044 /* Parameters */
2045 PARAMETERS(
2046  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize")
2047 ),
2048 
2049 /* Wrap API */
2050 TRUE,
2051 
2052 /* Tags */
2053 "Configuration [Set]"
2054 /********************************************************************************************************************/
2055 )
2056 
2057 
2058 
2059 RMH_API_IMPLEMENTATION_SOC_ONLY(
2060 /********************************************************************************************************************/
2061 /* API Declaration */
2062 RMH_Result RMH_Self_GetMaxAllocationElements(const RMH_Handle handle, uint32_t* response),
2063 
2064 /* API Name */
2065 RMH_Self_GetMaxAllocationElements,
2066 
2067 /* Description */
2068 "Return the maximum number of allocation elements, excluding the TAUs and the Dummy DAUs, in one MAP the Node can process [mocaIfAeNumber]",
2069 
2070 /* Parameters */
2071 PARAMETERS(
2072  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2073  OUTPUT_PARAM(response, uint32_t*, "Maximum number of allocation elements")
2074 ),
2075 
2076 /* Wrap API */
2077 TRUE,
2078 
2079 /* Tags */
2080 "Configuration [Get]"
2081 /********************************************************************************************************************/
2082 )
2083 
2084 
2085 
2086 RMH_API_IMPLEMENTATION_SOC_ONLY(
2087 /********************************************************************************************************************/
2088 /* API Declaration */
2089 RMH_Result RMH_Self_GetLastResetReason(const RMH_Handle handle, RMH_MoCAResetReason* response),
2090 
2091 
2092 /* API Name */
2093 RMH_Self_GetLastResetReason,
2094 
2095 /* Description */
2096 "Return the reason for the most recent link reset [mocaIfResetReason]",
2097 
2098 /* Parameters */
2099 PARAMETERS(
2100  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2101  OUTPUT_PARAM(response, RMH_MoCAResetReason*, "The reason for the most recent link reset")
2102 ),
2103 
2104 /* Wrap API */
2105 TRUE,
2106 
2107 /* Tags */
2108 "Network,Remote Node"
2109 /********************************************************************************************************************/
2110 )
2111 
2112 
2113 
2114 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
2115 /********************************************************************************************************************/
2116 /* API Declaration */
2117 RMH_Result RMH_Interface_GetEnabled(const RMH_Handle handle, bool *response),
2118 
2119 /* API Name */
2120 RMH_Interface_GetEnabled,
2121 
2122 /* Description */
2123 "Check if the MoCA interface is enabled at the kernel level. Do not confuse with <RMH_Self_GetEnabled> which checks if "
2124 "the MoCA driver is active",
2125 
2126 /* Parameters */
2127 PARAMETERS(
2128  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2129  OUTPUT_PARAM(response, bool*,
2130  "Set to 'true' if the MoCA interface is enabled at the kernel level. Otherwise set to 'false'.")
2131 ),
2132 
2133 /* Wrap API */
2134 TRUE,
2135 
2136 /* Tags */
2137 "Configuration [Get],Interface"
2138 /********************************************************************************************************************/
2139 )
2140 
2141 
2142 
2143 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
2144 /********************************************************************************************************************/
2145 /* API Declaration */
2146 RMH_Result RMH_Interface_SetEnabled(const RMH_Handle handle, const bool value),
2147 
2148 /* API Name */
2149 RMH_Interface_SetEnabled,
2150 
2151 /* Description */
2152 "Set MoCA interface enabled or disabled at the kernel level. Do not confuse with <RMH_Self_SetEnabled> which checks "
2153 "if the MoCA driver is active",
2154 
2155 /* Parameters */
2156 PARAMETERS(
2157  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2158  INPUT_PARAM(value, const bool, "Pass 'true' to enable the interface. Otherwise pass to 'false'.")
2159 ),
2160 
2161 /* Wrap API */
2162 TRUE,
2163 
2164 /* Tags */
2165 "Configuration [Set],Interface"
2166 /********************************************************************************************************************/
2167 )
2168 
2169 
2170 
2171 RMH_API_IMPLEMENTATION_SOC_ONLY(
2172 /********************************************************************************************************************/
2173 /* API Declaration */
2174 RMH_Result RMH_Interface_GetName(const RMH_Handle handle, char* responseBuf, const size_t responseBufSize),
2175 
2176 /* API Name */
2177 RMH_Interface_GetName,
2178 
2179 /* Description */
2180 "Return the Linux interface name associated with the MoCA device. [mocaIfName]",
2181 
2182 /* Parameters */
2183 PARAMETERS(
2184  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2185  OUTPUT_PARAM(responseBuf, char*, "A buffer where the interface name will be written"),
2186  INPUT_PARAM(responseBufSize, const size_t, "The size in bytes of the buffer <responseBuf>")
2187 ),
2188 
2189 /* Wrap API */
2190 TRUE,
2191 
2192 /* Tags */
2193 "Configuration [Get],Interface"
2194 /********************************************************************************************************************/
2195 )
2196 
2197 
2198 
2199 RMH_API_IMPLEMENTATION_SOC_ONLY(
2200 /********************************************************************************************************************/
2201 /* API Declaration */
2202 RMH_Result RMH_Interface_GetMac(const RMH_Handle handle, RMH_MacAddress_t* response),
2203 
2204 /* API Name */
2205 RMH_Interface_GetMac,
2206 
2207 /* Description */
2208 "Return the MAC address associated with this MoCA device. [mocaIfMacAddress]",
2209 
2210 /* Parameters */
2211 PARAMETERS(
2212  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2213  OUTPUT_PARAM(response, RMH_MacAddress_t*, "The MAC address as a byte array")
2214 ),
2215 
2216 /* Wrap API */
2217 TRUE,
2218 
2219 /* Tags */
2220 "Configuration [Get],Interface,mac"
2221 /********************************************************************************************************************/
2222 )
2223 
2224 
2225 
2226 RMH_API_IMPLEMENTATION_SOC_ONLY(
2227 /********************************************************************************************************************/
2228 /* API Declaration */
2229 RMH_Result RMH_Interface_SetMac(const RMH_Handle handle, const RMH_MacAddress_t value),
2230 
2231 /* API Name */
2232 RMH_Interface_SetMac,
2233 
2234 /* Description */
2235 "Set the MAC address associated with this MoCA device.",
2236 
2237 /* Parameters */
2238 PARAMETERS(
2239  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2240  INPUT_PARAM(value, const RMH_MacAddress_t, "The desired MAC address as a byte array")
2241 ),
2242 
2243 /* Wrap API */
2244 TRUE,
2245 
2246 /* Tags */
2247 "Configuration [Set],Interface,mac"
2248 /********************************************************************************************************************/
2249 )
2250 
2251 
2252 
2253 RMH_API_IMPLEMENTATION_SOC_ONLY(
2254 /********************************************************************************************************************/
2255 /* API Declaration */
2256 RMH_Result RMH_Power_GetMode(const RMH_Handle handle, RMH_PowerMode* response),
2257 
2258 /* API Name */
2259 RMH_Power_GetMode,
2260 
2261 /* Description */
2262 "Return the current MoCA power state of this device.",
2263 
2264 /* Parameters */
2265 PARAMETERS(
2266  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2267  OUTPUT_PARAM(response, RMH_PowerMode*, "The current power mode of this device")
2268 ),
2269 
2270 /* Wrap API */
2271 TRUE,
2272 
2273 /* Tags */
2274 "Configuration [Get],Power"
2275 /********************************************************************************************************************/
2276 )
2277 
2278 
2279 
2280 RMH_API_IMPLEMENTATION_SOC_ONLY(
2281 /********************************************************************************************************************/
2282 /* API Declaration */
2283 RMH_Result RMH_Power_GetSupportedModes(const RMH_Handle handle, uint32_t* response),
2284 
2285 /* API Name */
2286 RMH_Power_GetSupportedModes,
2287 
2288 /* Description */
2289 "Return a bitmask of <RMH_PowerMode> indicating all MoCA power modes supported by this device. [mocaIfPowerStateCap]",
2290 
2291 /* Parameters */
2292 PARAMETERS(
2293  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2294  OUTPUT_PARAM(response, uint32_t*, "A bitmask of <RMH_PowerMode> listing supported modes")
2295 ),
2296 
2297 /* Wrap API */
2298 TRUE,
2299 
2300 /* Tags */
2301 "Configuration [Get],Power"
2302 /********************************************************************************************************************/
2303 )
2304 
2305 
2306 
2307 RMH_API_IMPLEMENTATION_SOC_ONLY(
2308 /********************************************************************************************************************/
2309 /* API Declaration */
2310 RMH_Result RMH_Power_GetStandbyMode(const RMH_Handle handle, RMH_PowerMode* response),
2311 
2312 /* API Name */
2313 RMH_Power_GetStandbyMode,
2314 
2315 /* Description */
2316 "Return the power state MoCA will go to when the system goes to standby.",
2317 
2318 /* Parameters */
2319 PARAMETERS(
2320  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2321  OUTPUT_PARAM(response, RMH_PowerMode*, "The power mode of this device will use in standby")
2322 ),
2323 
2324 /* Wrap API */
2325 TRUE,
2326 
2327 /* Tags */
2328 "Configuration [Get],Power"
2329 /********************************************************************************************************************/
2330 )
2331 
2332 
2333 
2334 RMH_API_IMPLEMENTATION_SOC_ONLY(
2335 /********************************************************************************************************************/
2336 /* API Declaration */
2337 RMH_Result RMH_Power_SetStandbyMode(const RMH_Handle handle, const RMH_PowerMode response),
2338 
2339 /* API Name */
2340 RMH_Power_SetStandbyMode,
2341 
2342 /* Description */
2343 "Set the power state of the MoCA device when the device goes to standby. This may trigger MoCA to restart.",
2344 
2345 /* Parameters */
2346 PARAMETERS(
2347  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2348  INPUT_PARAM(response, const RMH_PowerMode, "The desired power mode for the device")
2349 ),
2350 
2351 /* Wrap API */
2352 TRUE,
2353 
2354 /* Tags */
2355 "Configuration [Set],Power"
2356 /********************************************************************************************************************/
2357 )
2358 
2359 
2360 
2361 RMH_API_IMPLEMENTATION_SOC_ONLY(
2362 /********************************************************************************************************************/
2363 /* API Declaration */
2364 RMH_Result RMH_Power_GetTxPowerControlEnabled(const RMH_Handle handle, bool* response),
2365 
2366 /* API Name */
2367 RMH_Power_GetTxPowerControlEnabled,
2368 
2369 /* Description */
2370 "Return if transmit power control is enabled or disabled for this device",
2371 
2372 /* Parameters */
2373 PARAMETERS(
2374  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2375  OUTPUT_PARAM(response, bool*,
2376  "Set to 'true' if transmission power control is enabled. Otherwise set to 'false'.")
2377 ),
2378 
2379 /* Wrap API */
2380 TRUE,
2381 
2382 /* Tags */
2383 "Configuration [Get],Power"
2384 /********************************************************************************************************************/
2385 )
2386 
2387 
2388 
2389 RMH_API_IMPLEMENTATION_SOC_ONLY(
2390 /********************************************************************************************************************/
2391 /* API Declaration */
2392 RMH_Result RMH_Power_SetTxPowerControlEnabled(const RMH_Handle handle, const bool value),
2393 
2394 /* API Name */
2395 RMH_Power_SetTxPowerControlEnabled,
2396 
2397 /* Description */
2398 "Enable or disable if transmit power control is enabled for this device",
2399 
2400 /* Parameters */
2401 PARAMETERS(
2402  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2403  INPUT_PARAM(value, const bool, "Pass 'true' to enable transmission power control on this device. Otherwise pass to 'false'.")
2404 ),
2405 
2406 /* Wrap API */
2407 TRUE,
2408 
2409 /* Tags */
2410 "Configuration [Set],Power"
2411 /********************************************************************************************************************/
2412 )
2413 
2414 
2415 
2416 RMH_API_IMPLEMENTATION_SOC_ONLY(
2417 /********************************************************************************************************************/
2418 /* API Declaration */
2419 RMH_Result RMH_Power_GetTxBeaconPowerReductionEnabled(const RMH_Handle handle, bool* response),
2420 
2421 /* API Name */
2422 RMH_Power_GetTxBeaconPowerReductionEnabled,
2423 
2424 /* Description */
2425 "Return if beacon power reduction is enabled on this device.",
2426 
2427 /* Parameters */
2428 PARAMETERS(
2429  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2430  OUTPUT_PARAM(response, bool*, "Set to 'true' if beacon power reduction is enabled. Otherwise set to 'false'.")
2431 ),
2432 
2433 /* Wrap API */
2434 TRUE,
2435 
2436 /* Tags */
2437 "Configuration [Get],Power"
2438 /********************************************************************************************************************/
2439 )
2440 
2441 
2442 
2443 RMH_API_IMPLEMENTATION_SOC_ONLY(
2444 /********************************************************************************************************************/
2445 /* API Declaration */
2446 RMH_Result RMH_Power_SetTxBeaconPowerReductionEnabled(const RMH_Handle handle, const bool value),
2447 
2448 /* API Name */
2449 RMH_Power_SetTxBeaconPowerReductionEnabled,
2450 
2451 /* Description */
2452 "Enable or disable if beacon power reduction on this device.",
2453 
2454 /* Parameters */
2455 PARAMETERS(
2456  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2457  INPUT_PARAM(value, const bool, "Pass 'true' to enable beacon power control on this device. Otherwise pass to 'false'.")
2458 ),
2459 
2460 /* Wrap API */
2461 TRUE,
2462 
2463 /* Tags */
2464 "Configuration [Set],Power"
2465 /********************************************************************************************************************/
2466 )
2467 
2468 
2469 
2470 RMH_API_IMPLEMENTATION_SOC_ONLY(
2471 /********************************************************************************************************************/
2472 /* API Declaration */
2473 RMH_Result RMH_Power_GetTxBeaconPowerReduction(const RMH_Handle handle, uint32_t* response),
2474 
2475 /* API Name */
2476 RMH_Power_GetTxBeaconPowerReduction,
2477 
2478 /* Description */
2479 "Return the power control back-off used by this node for transmitting beacons",
2480 
2481 /* Parameters */
2482 PARAMETERS(
2483  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2484  OUTPUT_PARAM(response, uint32_t*, "Beacon power reduction")
2485 ),
2486 
2487 /* Wrap API */
2488 TRUE,
2489 
2490 /* Tags */
2491 "Self,Power"
2492 /********************************************************************************************************************/
2493 )
2494 
2495 
2496 
2497 RMH_API_IMPLEMENTATION_SOC_ONLY(
2498 /********************************************************************************************************************/
2499 /* API Declaration */
2500 RMH_Result RMH_Power_SetTxBeaconPowerReduction(const RMH_Handle handle, const uint32_t value),
2501 
2502 /* API Name */
2503 RMH_Power_SetTxBeaconPowerReduction,
2504 
2505 /* Description */
2506 "Set the power control back-off used by this node for transmitting beacons",
2507 
2508 /* Parameters */
2509 PARAMETERS(
2510  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2511  INPUT_PARAM(value, const uint32_t, "Beacon power reduction. Minimum value 0, Maximum value 5.")
2512 ),
2513 
2514 /* Wrap API */
2515 TRUE,
2516 
2517 /* Tags */
2518 "Configuration [Set],Power"
2519 /********************************************************************************************************************/
2520 )
2521 
2522 
2523 
2524 RMH_API_IMPLEMENTATION_SOC_ONLY(
2525 /********************************************************************************************************************/
2526 /* API Declaration */
2527 RMH_Result RMH_Network_GetNumNodes(const RMH_Handle handle, uint32_t* response),
2528 
2529 /* API Name */
2530 RMH_Network_GetNumNodes,
2531 
2532 /* Description */
2533 "Return the number of MoCA nodes in the network. [mocaIfNumNodes]",
2534 
2535 /* Parameters */
2536 PARAMETERS(
2537  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2538  OUTPUT_PARAM(response, uint32_t*, "Number of MoCA nodes in the network")
2539 ),
2540 
2541 /* Wrap API */
2542 TRUE,
2543 
2544 /* Tags */
2545 "Network"
2546 /********************************************************************************************************************/
2547 )
2548 
2549 
2550 
2551 RMH_API_IMPLEMENTATION_SOC_ONLY(
2552 /********************************************************************************************************************/
2553 /* API Declaration */
2554 RMH_Result RMH_Network_GetNodeId(const RMH_Handle handle, uint32_t* response),
2555 
2556 /* API Name */
2557 RMH_Network_GetNodeId,
2558 
2559 /* Description */
2560 "Return the node ID of this device. [mocaIfNodeID] This is a zero based ID which uniquely identifies this node on the network.",
2561 
2562 /* Parameters */
2563 PARAMETERS(
2564  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2565  OUTPUT_PARAM(response, uint32_t*, "The device's node ID")
2566 ),
2567 
2568 /* Wrap API */
2569 TRUE,
2570 
2571 /* Tags */
2572 "Network"
2573 /********************************************************************************************************************/
2574 )
2575 
2576 
2577 
2578 RMH_API_IMPLEMENTATION_SOC_ONLY(
2579 /********************************************************************************************************************/
2580 /* API Declaration */
2581 RMH_Result RMH_Network_GetNodeIds(const RMH_Handle handle, RMH_NodeList_Uint32_t* response),
2582 
2583 /* API Name */
2584 RMH_Network_GetNodeIds,
2585 
2586 /* Description */
2587 "Return a list of every node ID on the network. This differs from <RMH_Network_GetRemoteNodeIds> as this API *includes* the self node",
2588 
2589 /* Parameters */
2590 PARAMETERS(
2591  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2592  OUTPUT_PARAM(response, RMH_NodeList_Uint32_t*, "Where the index is the node Id, if <nodePresent> is 'true', <nodeValue> is the node Id.")
2593 ),
2594 
2595 /* Wrap API */
2596 TRUE,
2597 
2598 /* Tags */
2599 "Network"
2600 /********************************************************************************************************************/
2601 )
2602 
2603 
2604 
2605 RMH_API_IMPLEMENTATION_SOC_ONLY(
2606 /********************************************************************************************************************/
2607 /* API Declaration */
2608 RMH_Result RMH_Network_GetRemoteNodeIds(const RMH_Handle handle, RMH_NodeList_Uint32_t* response),
2609 
2610 /* API Name */
2611 RMH_Network_GetRemoteNodeIds,
2612 
2613 /* Description */
2614 "Return a list of every node ID on the network. This differs from <RMH_Network_GetNodeIds> as this API *does not include* the self node",
2615 
2616 /* Parameters */
2617 PARAMETERS(
2618  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2619  OUTPUT_PARAM(response, RMH_NodeList_Uint32_t*, "Where the index is the node Id, if <nodePresent> is 'true', <nodeValue> is the node Id.")
2620 ),
2621 
2622 /* Wrap API */
2623 TRUE,
2624 
2625 /* Tags */
2626 "Network,Remote Node"
2627 /********************************************************************************************************************/
2628 )
2629 
2630 
2631 
2632 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
2633 /********************************************************************************************************************/
2634 /* API Declaration */
2635 RMH_Result RMH_Network_GetAssociatedIds(const RMH_Handle handle, RMH_NodeList_Uint32_t* response),
2636 
2637 /* API Name */
2638 RMH_Network_GetAssociatedIds,
2639 
2640 /* Description */
2641 "Return a list of the associated ID for every node on the network. This is a one-based index of every remote node on the network. The self node is not included in this list.",
2642 
2643 /* Parameters */
2644 PARAMETERS(
2645  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2646  OUTPUT_PARAM(response, RMH_NodeList_Uint32_t*, "Where the index is the node Id, if <nodePresent> is 'true', <nodeValue> is the associated Id for that node.")
2647 ),
2648 
2649 /* Wrap API */
2650 TRUE,
2651 
2652 /* Tags */
2653 "Network"
2654 /********************************************************************************************************************/
2655 )
2656 
2657 
2658 
2659 RMH_API_IMPLEMENTATION_SOC_ONLY(
2660 /********************************************************************************************************************/
2661 /* API Declaration */
2662 RMH_Result RMH_Network_GetNCNodeId(const RMH_Handle handle, uint32_t* response),
2663 
2664 /* API Name */
2665 RMH_Network_GetNCNodeId,
2666 
2667 /* Description */
2668 "Return the node ID of the network coordinator. [mocaIfNC]",
2669 
2670 /* Parameters */
2671 PARAMETERS(
2672  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2673  OUTPUT_PARAM(response, uint32_t*, "The network coordinator node Id")
2674 ),
2675 
2676 /* Wrap API */
2677 TRUE,
2678 
2679 /* Tags */
2680 "Network,NC"
2681 /********************************************************************************************************************/
2682 )
2683 
2684 
2685 
2686 RMH_API_IMPLEMENTATION_SOC_ONLY(
2687 /********************************************************************************************************************/
2688 /* API Declaration */
2689 RMH_Result RMH_Network_GetBackupNCNodeId(const RMH_Handle handle, uint32_t* response),
2690 
2691 /* API Name */
2692 RMH_Network_GetBackupNCNodeId,
2693 
2694 /* Description */
2695 "Return the node ID of the backup network coordinator. [mocaIfBackupNC]",
2696 
2697 /* Parameters */
2698 PARAMETERS(
2699  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2700  OUTPUT_PARAM(response, uint32_t*, "The backup network coordinator node Id")
2701 ),
2702 
2703 /* Wrap API */
2704 TRUE,
2705 
2706 /* Tags */
2707 "Network,NC"
2708 /********************************************************************************************************************/
2709 )
2710 
2711 
2712 
2713 RMH_API_IMPLEMENTATION_SOC_ONLY(
2714 /********************************************************************************************************************/
2715 /* API Declaration */
2716 RMH_Result RMH_Network_GetNCMac(const RMH_Handle handle, RMH_MacAddress_t* response),
2717 
2718 /* API Name */
2719 RMH_Network_GetNCMac,
2720 
2721 /* Description */
2722 "Return the MAC address of the network coordinator.",
2723 
2724 /* Parameters */
2725 PARAMETERS(
2726  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2727  OUTPUT_PARAM(response, RMH_MacAddress_t*, "The MAC address of the network coordinator")
2728 ),
2729 
2730 /* Wrap API */
2731 TRUE,
2732 
2733 /* Tags */
2734 "Network,NC,mac"
2735 /********************************************************************************************************************/
2736 )
2737 
2738 
2739 
2740 RMH_API_IMPLEMENTATION_SOC_ONLY(
2741 /********************************************************************************************************************/
2742 /* API Declaration */
2743 RMH_Result RMH_Network_GetLinkUptime(const RMH_Handle handle, uint32_t* response),
2744 
2745 /* API Name */
2746 RMH_Network_GetLinkUptime,
2747 
2748 /* Description */
2749 "Returns the amount of time this node has been part of the MoCA network [mocaIfLinkUpTime]. Time is in seconds",
2750 
2751 /* Parameters */
2752 PARAMETERS(
2753  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2754  OUTPUT_PARAM(response, uint32_t*, "Number of seconds this node has been in the network")
2755 ),
2756 
2757 /* Wrap API */
2758 TRUE,
2759 
2760 /* Tags */
2761 "Network,Link"
2762 /********************************************************************************************************************/
2763 )
2764 
2765 
2766 
2767 RMH_API_IMPLEMENTATION_SOC_ONLY(
2768 /********************************************************************************************************************/
2769 /* API Declaration */
2770 RMH_Result RMH_Network_GetResetCount(const RMH_Handle handle, uint32_t* response),
2771 
2772 /* API Name */
2773 RMH_Network_GetResetCount,
2774 
2775 /* Description */
2776 "Returns the number of times the MoCA link has gone down since the last boot. [mocaIfResetCount]",
2777 
2778 /* Parameters */
2779 PARAMETERS(
2780  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2781  OUTPUT_PARAM(response, uint32_t*, "Number of seconds this node has been in the network")
2782 ),
2783 
2784 /* Wrap API */
2785 TRUE,
2786 
2787 /* Tags */
2788 "Network,Link,"
2789 /********************************************************************************************************************/
2790 )
2791 
2792 
2793 
2794 RMH_API_IMPLEMENTATION_SOC_ONLY(
2795 /********************************************************************************************************************/
2796 /* API Declaration */
2797 RMH_Result RMH_Network_GetLinkDownCount(const RMH_Handle handle, uint32_t* response),
2798 
2799 /* API Name */
2800 RMH_Network_GetLinkDownCount,
2801 
2802 /* Description */
2803 "Returns the number of times the MoCA link has gone down since the last boot. [mocaIfLinkDownCount]",
2804 
2805 /* Parameters */
2806 PARAMETERS(
2807  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2808  OUTPUT_PARAM(response, uint32_t*, "Number of seconds this node has been in the network")
2809 ),
2810 
2811 /* Wrap API */
2812 TRUE,
2813 
2814 /* Tags */
2815 "Network,Link,"
2816 /********************************************************************************************************************/
2817 )
2818 
2819 
2820 
2821 RMH_API_IMPLEMENTATION_SOC_ONLY(
2822 /********************************************************************************************************************/
2823 /* API Declaration */
2824 RMH_Result RMH_Network_GetMixedMode(const RMH_Handle handle, bool* response),
2825 
2826 /* API Name */
2827 RMH_Network_GetMixedMode,
2828 
2829 /* Description */
2830 "Check if the MoCA network contains both 1.1 and 2.0 nodes",
2831 
2832 /* Parameters */
2833 PARAMETERS(
2834  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2835  OUTPUT_PARAM(response, bool*, "Set to 'true' if both 1.1 and 2.0 nodes are present in the network. Otherwise set to 'false'.")
2836 ),
2837 
2838 /* Wrap API */
2839 TRUE,
2840 
2841 /* Tags */
2842 "Network"
2843 /********************************************************************************************************************/
2844 )
2845 
2846 
2847 
2848 RMH_API_IMPLEMENTATION_SOC_ONLY(
2849 /********************************************************************************************************************/
2850 /* API Declaration */
2851 RMH_Result RMH_Network_GetRFChannelFreq(const RMH_Handle handle, uint32_t* response),
2852 
2853 /* API Name */
2854 RMH_Network_GetRFChannelFreq,
2855 
2856 /* Description */
2857 "Return the frequency which the MoCA network is operating on. [mocaIfRFChannel]",
2858 
2859 /* Parameters */
2860 PARAMETERS(
2861  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2862  OUTPUT_PARAM(response, uint32_t*, "The frequency of the MoCA network")
2863 ),
2864 
2865 /* Wrap API */
2866 TRUE,
2867 
2868 /* Tags */
2869 "Network,Frequency"
2870 /********************************************************************************************************************/
2871 )
2872 
2873 
2874 
2875 RMH_API_IMPLEMENTATION_SOC_ONLY(
2876 /********************************************************************************************************************/
2877 /* API Declaration */
2878 RMH_Result RMH_Network_GetPrimaryChannelFreq(const RMH_Handle handle, uint32_t* response),
2879 
2880 /* API Name */
2881 RMH_Network_GetPrimaryChannelFreq,
2882 
2883 /* Description */
2884 "Return the primary MoCA 2.0 channel",
2885 
2886 /* Parameters */
2887 PARAMETERS(
2888  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2889  OUTPUT_PARAM(response, uint32_t*, "The primary MoCA 2.0 channel")
2890 ),
2891 
2892 /* Wrap API */
2893 TRUE,
2894 
2895 /* Tags */
2896 "Network,Frequency"
2897 /********************************************************************************************************************/
2898 )
2899 
2900 
2901 
2902 RMH_API_IMPLEMENTATION_SOC_ONLY(
2903 /********************************************************************************************************************/
2904 /* API Declaration */
2905 RMH_Result RMH_Network_GetSecondaryChannelFreq(const RMH_Handle handle, uint32_t* response),
2906 
2907 /* API Name */
2908 RMH_Network_GetSecondaryChannelFreq,
2909 
2910 /* Description */
2911 "Return the secondary MoCA 2.0 channel",
2912 
2913 /* Parameters */
2914 PARAMETERS(
2915  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2916  OUTPUT_PARAM(response, uint32_t*, "The secondary MoCA 2.0 channel")
2917 ),
2918 
2919 /* Wrap API */
2920 TRUE,
2921 
2922 /* Tags */
2923 "Network,Frequency"
2924 /********************************************************************************************************************/
2925 )
2926 
2927 
2928 
2929 RMH_API_IMPLEMENTATION_SOC_ONLY(
2930 /********************************************************************************************************************/
2931 /* API Declaration */
2932 RMH_Result RMH_Network_GetMoCAVersion(const RMH_Handle handle, RMH_MoCAVersion* response),
2933 
2934 /* API Name */
2935 RMH_Network_GetMoCAVersion,
2936 
2937 /* Description */
2938 "Return the version of MoCA under which the network is operating. [mocaIfNetworkVersion]",
2939 
2940 /* Parameters */
2941 PARAMETERS(
2942  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2943  OUTPUT_PARAM(response, RMH_MoCAVersion*, "The MoCA version of the network")
2944 ),
2945 
2946 /* Wrap API */
2947 TRUE,
2948 
2949 /* Tags */
2950 "Network,Version"
2951 /********************************************************************************************************************/
2952 )
2953 
2954 
2955 
2956 RMH_API_IMPLEMENTATION_SOC_ONLY(
2957 /********************************************************************************************************************/
2958 /* API Declaration */
2959 RMH_Result RMH_Network_GetTxBroadcastPhyRate(const RMH_Handle handle, uint32_t* response),
2960 
2961 /* API Name */
2962 RMH_Network_GetTxBroadcastPhyRate,
2963 
2964 /* Description */
2965 "Return the PHY rate at which broadcast packets are transmitted from this node",
2966 
2967 /* Parameters */
2968 PARAMETERS(
2969  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2970  OUTPUT_PARAM(response, uint32_t*, "The broadcast transmission PHY rate")
2971 ),
2972 
2973 /* Wrap API */
2974 TRUE,
2975 
2976 /* Tags */
2977 "Configuration [Get],Phy"
2978 /********************************************************************************************************************/
2979 )
2980 
2981 
2982 
2983 RMH_API_IMPLEMENTATION_SOC_ONLY(
2984 /********************************************************************************************************************/
2985 /* API Declaration */
2986 RMH_Result RMH_Network_GetTxGCDPhyRate(const RMH_Handle handle, uint32_t* response),
2987 
2988 /* API Name */
2989 RMH_Network_GetTxGCDPhyRate,
2990 
2991 /* Description */
2992 "Return the GCD PHY rate which packets are transmitted from this node. [mocaIfTxGcdRate]",
2993 
2994 /* Parameters */
2995 PARAMETERS(
2996  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
2997  OUTPUT_PARAM(response, uint32_t*, "The GCD transmission PHY rate")
2998 ),
2999 
3000 /* Wrap API */
3001 TRUE,
3002 
3003 /* Tags */
3004 "Configuration [Get],Phy"
3005 /********************************************************************************************************************/
3006 )
3007 
3008 
3009 
3010 RMH_API_IMPLEMENTATION_SOC_ONLY(
3011 /********************************************************************************************************************/
3012 /* API Declaration */
3013 RMH_Result RMH_Network_GetTxMapPhyRate(const RMH_Handle handle, uint32_t* response),
3014 
3015 /* API Name */
3016 RMH_Network_GetTxMapPhyRate,
3017 
3018 /* Description */
3019 "Return the PHY rate at which MAP packets are transmitted from this node",
3020 
3021 /* Parameters */
3022 PARAMETERS(
3023  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3024  OUTPUT_PARAM(response, uint32_t*, "The MAP transmission PHY rate")
3025 ),
3026 
3027 /* Wrap API */
3028 TRUE,
3029 
3030 /* Tags */
3031 "Network,Phy"
3032 /********************************************************************************************************************/
3033 )
3034 
3035 
3036 
3037 RMH_API_IMPLEMENTATION_SOC_ONLY(
3038 /********************************************************************************************************************/
3039 /* API Declaration */
3040 RMH_Result RMH_Network_GetTxGcdPowerReduction(const RMH_Handle handle, uint32_t* response),
3041 
3042 /* API Name */
3043 RMH_Network_GetTxGcdPowerReduction,
3044 
3045 /* Description */
3046 "The transmit power control back-off used for broadcast transmissions from this node. [mocaIfTxGcdPowerReduction]",
3047 
3048 /* Parameters */
3049 PARAMETERS(
3050  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3051  OUTPUT_PARAM(response, uint32_t*, "Transmit power control reduction. Minimum value 0, Maximum value 35")
3052 ),
3053 
3054 /* Wrap API */
3055 TRUE,
3056 
3057 /* Tags */
3058 "Network,Power"
3059 /********************************************************************************************************************/
3060 )
3061 
3062 
3063 
3064 RMH_API_IMPLEMENTATION_SOC_ONLY(
3065 /********************************************************************************************************************/
3066 /* API Declaration */
3067 RMH_Result RMH_Network_GetTabooChannels(const RMH_Handle handle, uint32_t *channelMaskStart, uint32_t *channelMask),
3068 
3069 /* API Name */
3070 RMH_Network_GetTabooChannels,
3071 
3072 /* Description */
3073 "Return which beacon channels will be taboo on this device. <channelMaskStart> will indicate the channel number of the lowest "
3074 "RF frequency covered by <channel mask>. The bitmask <channelMask> is then used to identify exactly which frequencies "
3075 "are taboo. Each consecutive bit of <channelMask> corresponds to channels offset by multiples of 25MHz. A bit in "
3076 "<channelMask> will be set to '1' if that channel is taboo. [mocaIfTabooChannelMask]",
3077 
3078 /* Parameters */
3079 PARAMETERS(
3080  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3081  INPUT_PARAM(channelMaskStart, uint32_t*, "The channel number of the lowest frequency which is taboo"),
3082  INPUT_PARAM(channelMask, uint32_t*,
3083  "A bitmask of channels which are taboo. The first bit corresponds to the frequency of <channelMaskStart>")
3084 ),
3085 
3086 /* Wrap API */
3087 TRUE,
3088 
3089 /* Tags */
3090 "Network,Taboo,Frequency"
3091 /********************************************************************************************************************/
3092 )
3093 
3094 
3095 
3096 RMH_API_IMPLEMENTATION_SOC_ONLY(
3097 /********************************************************************************************************************/
3098 /* API Declaration */
3099 RMH_Result RMH_Network_GetTxUnicastPhyRate(const RMH_Handle handle, RMH_NodeMesh_Uint32_t* response),
3100 
3101 /* API Name */
3102 RMH_Network_GetTxUnicastPhyRate,
3103 
3104 /* Description */
3105 "Return the unicast transmit PHY rates between all nodes on the network. The resulting matrix will be in "
3106 "<RMH_NodeMesh_Uint32_t>. Where the index is the node Id, if <nodePresent> is 'true', then <nodeValue> is "
3107 "a list of the unicast PHY rates from this node Id to every other node on the network.",
3108 
3109 /* Parameters */
3110 PARAMETERS(
3111  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3112  OUTPUT_PARAM(response, RMH_NodeMesh_Uint32_t*, "The PHY rate mesh table")
3113 ),
3114 
3115 /* Wrap API */
3116 TRUE,
3117 
3118 /* Tags */
3119 "Network,Phy"
3120 /********************************************************************************************************************/
3121 )
3122 
3123 
3124 
3125 RMH_API_IMPLEMENTATION_SOC_ONLY(
3126 /********************************************************************************************************************/
3127 /* API Declaration */
3128 RMH_Result RMH_Network_GetTxVLPER(const RMH_Handle handle, RMH_NodeMesh_Uint32_t* response),
3129 
3130 /* API Name */
3131 RMH_Network_GetTxVLPER,
3132 
3133 /* Description */
3134 "Return the transmit VLPER (Very Low Packet Error Rate) PHY rates *between* all MoCA 2.0 nodes on the network. The "
3135 "resulting matrix will be in <RMH_NodeMesh_Uint32_t>. Where the index is the node Id, if <nodePresent> is 'true', "
3136 "then <nodeValue> is a list of the unicast PHY rates from this node Id to every other node on the network. Note, "
3137 "MoCA 1.1 nodes will have <nodePresent> set to 'true', however they <nodeValue> will be 0.",
3138 
3139 /* Parameters */
3140 PARAMETERS(
3141  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3142  OUTPUT_PARAM(response, RMH_NodeMesh_Uint32_t*, "The PHY rate mesh table")
3143 ),
3144 
3145 /* Wrap API */
3146 TRUE,
3147 
3148 /* Tags */
3149 "Network,Phy"
3150 /********************************************************************************************************************/
3151 )
3152 
3153 
3154 
3155 RMH_API_IMPLEMENTATION_SOC_ONLY(
3156 /********************************************************************************************************************/
3157 /* API Declaration */
3158 RMH_Result RMH_Network_GetTxNPER(const RMH_Handle handle, RMH_NodeMesh_Uint32_t* response),
3159 
3160 /* API Name */
3161 RMH_Network_GetTxNPER,
3162 
3163 /* Description */
3164 "Return the transmit NPER (Nominal Packet Error Rate) PHY rates *from* all MoCA 2.0 nodes on the network. The "
3165 "resulting matrix will be in <RMH_NodeMesh_Uint32_t>. Where the index is the node Id, if <nodePresent> is 'true', "
3166 "then <nodeValue> is a list of the unicast PHY rates from this node Id to every other node on the network. Note, "
3167 "MoCA 1.1 nodes will have <nodePresent> set to 'true', however they <nodeValue> will be 0.",
3168 
3169 /* Parameters */
3170 PARAMETERS(
3171  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3172  OUTPUT_PARAM(response, RMH_NodeMesh_Uint32_t*, "The PHY rate mesh table")
3173 ),
3174 
3175 /* Wrap API */
3176 TRUE,
3177 
3178 /* Tags */
3179 "Network,Phy"
3180 /********************************************************************************************************************/
3181 )
3182 
3183 
3184 
3185 RMH_API_IMPLEMENTATION_SOC_ONLY(
3186 /********************************************************************************************************************/
3187 /* API Declaration */
3188 RMH_Result RMH_Network_GetBitLoadingInfo(const RMH_Handle handle, RMH_NodeMesh_Uint32_t* response),
3189 
3190 /* API Name */
3191 RMH_Network_GetBitLoadingInfo,
3192 
3193 /* Description */
3194 "TBD",
3195 
3196 /* Parameters */
3197 PARAMETERS(
3198  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3199  OUTPUT_PARAM(response, RMH_NodeMesh_Uint32_t*, "The resulting bitloading information")
3200 ),
3201 
3202 /* Wrap API */
3203 TRUE,
3204 
3205 /* Tags */
3206 "Network"
3207 /********************************************************************************************************************/
3208 )
3209 
3210 
3211 
3212 RMH_API_IMPLEMENTATION_SOC_ONLY(
3213 /********************************************************************************************************************/
3214 /* API Declaration */
3215 RMH_Result RMH_Network_GetBondedConnections(RMH_Handle handle, RMH_NodeMesh_Uint32_t* response),
3216 
3217 /* API Name */
3218 RMH_Network_GetBondedConnections,
3219 
3220 /* Description */
3221 "Return the bonded status for all nodes on the network. 'nodeValue' will 1 if the connection is bonded, 0 if not.",
3222 
3223 /* Parameters */
3224 PARAMETERS(
3225  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3226  OUTPUT_PARAM(response, RMH_NodeMesh_Uint32_t*, "A mesh table representing connections between all nodes.")
3227 ),
3228 
3229 /* Wrap API */
3230 TRUE,
3231 
3232 /* Tags */
3233 "Network"
3234 /********************************************************************************************************************/
3235 )
3236 
3237 
3238 
3239 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
3240 /********************************************************************************************************************/
3241 /* API Declaration */
3242 RMH_Result RMH_RemoteNode_GetNodeIdFromAssociatedId(const RMH_Handle handle, const uint32_t associatedId, uint32_t* response),
3243 
3244 /* API Name */
3245 RMH_RemoteNode_GetNodeIdFromAssociatedId,
3246 
3247 /* Description */
3248 "Convert an associated Id into a Node Id.",
3249 
3250 /* Parameters */
3251 PARAMETERS(
3252  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3253  INPUT_PARAM(associatedId, const uint32_t, "The associated Id of the node"),
3254  OUTPUT_PARAM(response, uint32_t*, "The node Id")
3255 ),
3256 
3257 /* Wrap API */
3258 TRUE,
3259 
3260 /* Tags */
3261 "Remote Node"
3262 /********************************************************************************************************************/
3263 )
3264 
3265 
3266 
3267 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
3268 /********************************************************************************************************************/
3269 /* API Declaration */
3270 RMH_Result RMH_RemoteNode_GetAssociatedIdFromNodeId(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3271 
3272 /* API Name */
3273 RMH_RemoteNode_GetAssociatedIdFromNodeId,
3274 
3275 /* Description */
3276 "Convert a node Id into an associated Id.",
3277 
3278 /* Parameters */
3279 PARAMETERS(
3280  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3281  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3282  OUTPUT_PARAM(response, uint32_t*, "The associated Id of the node")
3283 ),
3284 
3285 /* Wrap API */
3286 TRUE,
3287 
3288 /* Tags */
3289 "Remote Node"
3290 /********************************************************************************************************************/
3291 )
3292 
3293 
3294 
3295 RMH_API_IMPLEMENTATION_SOC_ONLY(
3296 /********************************************************************************************************************/
3297 /* API Declaration */
3298 RMH_Result RMH_RemoteNode_GetMac(const RMH_Handle handle, const uint32_t nodeId, RMH_MacAddress_t* response),
3299 
3300 /* API Name */
3301 RMH_RemoteNode_GetMac,
3302 
3303 /* Description */
3304 "Return the MAC address of the remote node specificed by <nodeId>",
3305 
3306 /* Parameters */
3307 PARAMETERS(
3308  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3309  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3310  OUTPUT_PARAM(response, RMH_MacAddress_t*, "The MAC address of the remote node as a byte array")
3311 ),
3312 
3313 /* Wrap API */
3314 TRUE,
3315 
3316 /* Tags */
3317 "Remote Node,mac"
3318 /********************************************************************************************************************/
3319 )
3320 
3321 
3322 
3323 RMH_API_IMPLEMENTATION_SOC_ONLY(
3324 /********************************************************************************************************************/
3325 /* API Declaration */
3326 RMH_Result RMH_RemoteNode_GetPreferredNC(const RMH_Handle handle, const uint32_t nodeId, bool* response),
3327 
3328 /* API Name */
3329 RMH_RemoteNode_GetPreferredNC,
3330 
3331 /* Description */
3332 "Return if the node indicated by <nodeId> is a preferred NC or not.",
3333 
3334 /* Parameters */
3335 PARAMETERS(
3336  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3337  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3338  OUTPUT_PARAM(response, bool*, "Set to 'true' if the remote node is a preferred NC. Otherwise set to 'false'.")
3339 ),
3340 
3341 /* Wrap API */
3342 TRUE,
3343 
3344 /* Tags */
3345 "Remote Node,NC"
3346 /********************************************************************************************************************/
3347 )
3348 
3349 
3350 
3351 RMH_API_IMPLEMENTATION_SOC_ONLY(
3352 /********************************************************************************************************************/
3353 /* API Declaration */
3354 RMH_Result RMH_RemoteNode_GetHighestSupportedMoCAVersion(const RMH_Handle handle, const uint32_t nodeId, RMH_MoCAVersion* response),
3355 
3356 /* API Name */
3357 RMH_RemoteNode_GetHighestSupportedMoCAVersion,
3358 
3359 /* Description */
3360 "Return the highest supported version of MoCA by the remote node specified by <nodeId>",
3361 
3362 /* Parameters */
3363 PARAMETERS(
3364  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3365  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3366  OUTPUT_PARAM(response, RMH_MoCAVersion*, "The highest version of MoCA supported")
3367 ),
3368 
3369 /* Wrap API */
3370 TRUE,
3371 
3372 /* Tags */
3373 "Remote Node,Version"
3374 /********************************************************************************************************************/
3375 )
3376 
3377 
3378 
3379 RMH_API_IMPLEMENTATION_SOC_ONLY(
3380 /********************************************************************************************************************/
3381 /* API Declaration */
3382 RMH_Result RMH_RemoteNode_GetActiveMoCAVersion(const RMH_Handle handle, const uint32_t nodeId, RMH_MoCAVersion* response),
3383 
3384 /* API Name */
3385 RMH_RemoteNode_GetActiveMoCAVersion,
3386 
3387 /* Description */
3388 "Return the active supported version of MoCA by the remote node specificed by <nodeId>. There are cases where devices that "
3389 "support MoCA 2.0 may be actively using MoCA 1.1. For example, when the NC is a MoCA 1.1 node.",
3390 
3391 /* Parameters */
3392 PARAMETERS(
3393  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3394  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3395  OUTPUT_PARAM(response, RMH_MoCAVersion*, "The active version of MoCA on the remote node")
3396 ),
3397 
3398 /* Wrap API */
3399 TRUE,
3400 
3401 /* Tags */
3402 "Remote Node,Version"
3403 /********************************************************************************************************************/
3404 )
3405 
3406 
3407 
3408 RMH_API_IMPLEMENTATION_SOC_ONLY(
3409 /********************************************************************************************************************/
3410 /* API Declaration */
3411 RMH_Result RMH_RemoteNode_GetQAM256Capable(const RMH_Handle handle, const uint32_t nodeId, bool* response),
3412 
3413 /* API Name */
3414 RMH_RemoteNode_GetQAM256Capable,
3415 
3416 /* Description */
3417 "Return if the node indicated by <nodeId> has QAM256 enabled or not.",
3418 
3419 /* Parameters */
3420 PARAMETERS(
3421  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3422  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3423  OUTPUT_PARAM(response, bool*, "Set to 'true' if the remote node is a QAM256 capable. Otherwise set to 'false'.")
3424 ),
3425 
3426 /* Wrap API */
3427 TRUE,
3428 
3429 /* Tags */
3430 "Remote Node"
3431 /********************************************************************************************************************/
3432 )
3433 
3434 
3435 
3436 RMH_API_IMPLEMENTATION_SOC_ONLY(
3437 /********************************************************************************************************************/
3438 /* API Declaration */
3439 RMH_Result RMH_RemoteNode_GetMaxPacketAggregation(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3440 
3441 /* API Name */
3442 RMH_RemoteNode_GetMaxPacketAggregation,
3443 
3444 /* Description */
3445 "Return the maximum number of packets for aggregated transmissions for the node indicated by <nodeId>",
3446 
3447 /* Parameters */
3448 PARAMETERS(
3449  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3450  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3451  OUTPUT_PARAM(response, uint32_t*, "The maximum number of packets <nodeId> will aggregate")
3452 ),
3453 
3454 /* Wrap API */
3455 TRUE,
3456 
3457 /* Tags */
3458 "Remote Node"
3459 /********************************************************************************************************************/
3460 )
3461 
3462 
3463 
3464 RMH_API_IMPLEMENTATION_SOC_ONLY(
3465 /********************************************************************************************************************/
3466 /* API Declaration */
3467 RMH_Result RMH_RemoteNode_GetMaxFrameSize(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3468 
3469 /* API Name */
3470 RMH_RemoteNode_GetMaxFrameSize,
3471 
3472 /* Description */
3473 "The maximum number of bytes this node can receive in one frame (aggregated transmission).",
3474 
3475 /* Parameters */
3476 PARAMETERS(
3477  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3478  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3479  OUTPUT_PARAM(response, uint32_t*, "The maximum number of packets this device will aggregate")
3480 ),
3481 
3482 /* Wrap API */
3483 TRUE,
3484 
3485 /* Tags */
3486 "Remote Node"
3487 /********************************************************************************************************************/
3488 )
3489 
3490 
3491 RMH_API_IMPLEMENTATION_SOC_ONLY(
3492 /********************************************************************************************************************/
3493 /* API Declaration */
3494 RMH_Result RMH_RemoteNode_GetBondingCapable(const RMH_Handle handle, const uint32_t nodeId, bool* response),
3495 
3496 /* API Name */
3497 RMH_RemoteNode_GetBondingCapable,
3498 
3499 /* Description */
3500 "Return if the node indicated by <nodeId> is bonding capable enabled or not.",
3501 
3502 /* Parameters */
3503 PARAMETERS(
3504  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3505  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3506  OUTPUT_PARAM(response, bool*, "Set to 'true' if the remote node supports bonding. Otherwise set to 'false'.")
3507 ),
3508 
3509 /* Wrap API */
3510 TRUE,
3511 
3512 /* Tags */
3513 "Remote Node,Bonding"
3514 /********************************************************************************************************************/
3515 )
3516 
3517 
3518 
3519 RMH_API_IMPLEMENTATION_SOC_ONLY(
3520 /********************************************************************************************************************/
3521 /* API Declaration */
3522 RMH_Result RMH_RemoteNode_GetRxUnicastPhyRate(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3523 
3524 /* API Name */
3525 RMH_RemoteNode_GetRxUnicastPhyRate,
3526 
3527 /* Description */
3528 "Return the PHY rate at which unicast packets are received from <nodeId> from the self node.",
3529 
3530 /* Parameters */
3531 PARAMETERS(
3532  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3533  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3534  OUTPUT_PARAM(response, uint32_t*, "The unicast receive PHY rate")
3535 ),
3536 
3537 /* Wrap API */
3538 TRUE,
3539 
3540 /* Tags */
3541 "Remote Node,Phy"
3542 /********************************************************************************************************************/
3543 )
3544 
3545 
3546 
3547 RMH_API_IMPLEMENTATION_SOC_ONLY(
3548 /********************************************************************************************************************/
3549 /* API Declaration */
3550 RMH_Result RMH_RemoteNode_GetRxBroadcastPhyRate(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3551 
3552 /* API Name */
3553 RMH_RemoteNode_GetRxBroadcastPhyRate,
3554 
3555 /* Description */
3556 "Return the PHY rate at which broadcast packets are received from <nodeId>.",
3557 
3558 /* Parameters */
3559 PARAMETERS(
3560  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3561  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3562  OUTPUT_PARAM(response, uint32_t*, "The broadcast receive PHY rate")
3563 ),
3564 
3565 /* Wrap API */
3566 TRUE,
3567 
3568 /* Tags */
3569 "Remote Node,Phy"
3570 /********************************************************************************************************************/
3571 )
3572 
3573 
3574 
3575 RMH_API_IMPLEMENTATION_SOC_ONLY(
3576 /********************************************************************************************************************/
3577 /* API Declaration */
3578 RMH_Result RMH_RemoteNode_GetRxBroadcastPower(const RMH_Handle handle, const uint32_t nodeId, float* response),
3579 
3580 /* API Name */
3581 RMH_RemoteNode_GetRxBroadcastPower,
3582 
3583 /* Description */
3584 "Return the power level at which broadcast packets are received from <nodeId>.",
3585 
3586 /* Parameters */
3587 PARAMETERS(
3588  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3589  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3590  OUTPUT_PARAM(response, float*, "The broadcast receive power level")
3591 ),
3592 
3593 /* Wrap API */
3594 TRUE,
3595 
3596 /* Tags */
3597 "Remote Node,Power"
3598 /********************************************************************************************************************/
3599 )
3600 
3601 
3602 
3603 RMH_API_IMPLEMENTATION_SOC_ONLY(
3604 /********************************************************************************************************************/
3605 /* API Declaration */
3606 RMH_Result RMH_RemoteNode_GetRxUnicastPower(const RMH_Handle handle, const uint32_t nodeId, float* response),
3607 
3608 /* API Name */
3609 RMH_RemoteNode_GetRxUnicastPower,
3610 
3611 /* Description */
3612 "Return the power level at which unicast packets are received from <nodeId> from the self node.",
3613 
3614 /* Parameters */
3615 PARAMETERS(
3616  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3617  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3618  OUTPUT_PARAM(response, float*, "The unicast receive power level rate")
3619 ),
3620 
3621 /* Wrap API */
3622 TRUE,
3623 
3624 /* Tags */
3625 "Remote Node,Power"
3626 /********************************************************************************************************************/
3627 )
3628 
3629 
3630 
3631 RMH_API_IMPLEMENTATION_SOC_ONLY(
3632 /********************************************************************************************************************/
3633 /* API Declaration */
3634 RMH_Result RMH_RemoteNode_GetRxMapPower(const RMH_Handle handle, const uint32_t nodeId, float* response),
3635 
3636 /* API Name */
3637 RMH_RemoteNode_GetRxMapPower,
3638 
3639 /* Description */
3640 "Return the power level at which MAP packets are received by <nodeId>.",
3641 
3642 /* Parameters */
3643 PARAMETERS(
3644  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3645  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3646  OUTPUT_PARAM(response, float*, "The MAP receive power level rate")
3647 ),
3648 
3649 /* Wrap API */
3650 TRUE,
3651 
3652 /* Tags */
3653 "Remote Node,Power"
3654 /********************************************************************************************************************/
3655 )
3656 
3657 
3658 
3659 RMH_API_IMPLEMENTATION_SOC_ONLY(
3660 /********************************************************************************************************************/
3661 /* API Declaration */
3662 RMH_Result RMH_RemoteNode_GetRxPackets(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3663 
3664 /* API Name */
3665 RMH_RemoteNode_GetRxPackets,
3666 
3667 /* Description */
3668 "Return the number of packets <nodeId> has received.",
3669 
3670 /* Parameters */
3671 PARAMETERS(
3672  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3673  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3674  OUTPUT_PARAM(response, uint32_t*, "Number of packets received by <nodeId>")
3675 ),
3676 
3677 /* Wrap API */
3678 TRUE,
3679 
3680 /* Tags */
3681 "Remote Node"
3682 /********************************************************************************************************************/
3683 )
3684 
3685 
3686 
3687 RMH_API_IMPLEMENTATION_SOC_ONLY(
3688 /********************************************************************************************************************/
3689 /* API Declaration */
3690 RMH_Result RMH_RemoteNode_GetRxSNR(const RMH_Handle handle, const uint32_t nodeId, float* response),
3691 
3692 /* API Name */
3693 RMH_RemoteNode_GetRxSNR,
3694 
3695 /* Description */
3696 "The signal to noise ratio of <nodeId> based on the Type 1 probe from per node. Measured in dB.",
3697 
3698 /* Parameters */
3699 PARAMETERS(
3700  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3701  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3702  OUTPUT_PARAM(response, float*, "The SNR of <nodeId>")
3703 ),
3704 
3705 /* Wrap API */
3706 TRUE,
3707 
3708 /* Tags */
3709 "Remote Node"
3710 /********************************************************************************************************************/
3711 )
3712 
3713 
3714 
3715 RMH_API_IMPLEMENTATION_SOC_ONLY(
3716 /********************************************************************************************************************/
3717 /* API Declaration */
3718 RMH_Result RMH_RemoteNode_GetRxCorrectedErrors(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3719 
3720 /* API Name */
3721 RMH_RemoteNode_GetRxCorrectedErrors,
3722 
3723 /* Description */
3724 "Return the number of packets with corrected errors <nodeId> has received",
3725 
3726 /* Parameters */
3727 PARAMETERS(
3728  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3729  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3730  OUTPUT_PARAM(response, uint32_t*, "The number of corrected packets with errors")
3731 ),
3732 
3733 /* Wrap API */
3734 TRUE,
3735 
3736 /* Tags */
3737 "Remote Node"
3738 /********************************************************************************************************************/
3739 )
3740 
3741 
3742 
3743 RMH_API_IMPLEMENTATION_SOC_ONLY(
3744 /********************************************************************************************************************/
3745 /* API Declaration */
3746 RMH_Result RMH_RemoteNode_GetRxUnCorrectedErrors(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3747 
3748 /* API Name */
3749 RMH_RemoteNode_GetRxUnCorrectedErrors,
3750 
3751 /* Description */
3752 "Return the number of packets with uncorrected errors <nodeId> has received",
3753 
3754 /* Parameters */
3755 PARAMETERS(
3756  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3757  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3758  OUTPUT_PARAM(response, uint32_t*, "The number of uncorrected packets with errors")
3759 ),
3760 
3761 /* Wrap API */
3762 TRUE,
3763 
3764 /* Tags */
3765 "Remote Node"
3766 /********************************************************************************************************************/
3767 )
3768 
3769 
3770 
3771 RMH_API_IMPLEMENTATION_SOC_ONLY(
3772 /********************************************************************************************************************/
3773 /* API Declaration */
3774 RMH_Result RMH_RemoteNode_GetRxTotalErrors(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3775 
3776 /* API Name */
3777 RMH_RemoteNode_GetRxTotalErrors,
3778 
3779 /* Description */
3780 "Return the total number of packets with errors <nodeId> has received",
3781 
3782 /* Parameters */
3783 PARAMETERS(
3784  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3785  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3786  OUTPUT_PARAM(response, uint32_t*, "The number of total number of packets with errors")
3787 ),
3788 
3789 /* Wrap API */
3790 TRUE,
3791 
3792 /* Tags */
3793 "Remote Node"
3794 /********************************************************************************************************************/
3795 )
3796 
3797 
3798 
3799 RMH_API_IMPLEMENTATION_SOC_ONLY(
3800 /********************************************************************************************************************/
3801 /* API Declaration */
3802 RMH_Result RMH_RemoteNode_GetTxUnicastPhyRate(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3803 
3804 /* API Name */
3805 RMH_RemoteNode_GetTxUnicastPhyRate,
3806 
3807 /* Description */
3808 "Return the PHY rate at which unicast packets are transmitted from <nodeId> to the self node.",
3809 
3810 /* Parameters */
3811 PARAMETERS(
3812  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3813  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3814  OUTPUT_PARAM(response, uint32_t*, "The unicast transmission PHY rate")
3815 ),
3816 
3817 /* Wrap API */
3818 TRUE,
3819 
3820 /* Tags */
3821 "Remote Node,Phy"
3822 /********************************************************************************************************************/
3823 )
3824 
3825 
3826 
3827 RMH_API_IMPLEMENTATION_SOC_ONLY(
3828 /********************************************************************************************************************/
3829 /* API Declaration */
3830 RMH_Result RMH_RemoteNode_GetTxUnicastPower(const RMH_Handle handle, const uint32_t nodeId, float* response),
3831 
3832 /* API Name */
3833 RMH_RemoteNode_GetTxUnicastPower,
3834 
3835 /* Description */
3836 "Return the power level rate at which unicast packets are transmitted from <nodeId> to the self node.",
3837 
3838 /* Parameters */
3839 PARAMETERS(
3840  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3841  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3842  OUTPUT_PARAM(response, float*, "The unicast transmission power level rate")
3843 ),
3844 
3845 /* Wrap API */
3846 TRUE,
3847 
3848 /* Tags */
3849 "Remote Node,Power"
3850 /********************************************************************************************************************/
3851 )
3852 
3853 
3854 
3855 RMH_API_IMPLEMENTATION_SOC_ONLY(
3856 /********************************************************************************************************************/
3857 /* API Declaration */
3858 RMH_Result RMH_RemoteNode_GetTxPowerReduction(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3859 
3860 /* API Name */
3861 RMH_RemoteNode_GetTxPowerReduction,
3862 
3863 /* Description */
3864 "The transmit power control back-off used for transmissions from the specified <nodeId>",
3865 
3866 /* Parameters */
3867 PARAMETERS(
3868  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3869  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3870  OUTPUT_PARAM(response, uint32_t*, "The transmission power reduction of <nodeId>")
3871 ),
3872 
3873 /* Wrap API */
3874 TRUE,
3875 
3876 /* Tags */
3877 "Remote Node,Power"
3878 /********************************************************************************************************************/
3879 )
3880 
3881 
3882 
3883 RMH_API_IMPLEMENTATION_SOC_ONLY(
3884 /********************************************************************************************************************/
3885 /* API Declaration */
3886 RMH_Result RMH_RemoteNode_GetTxPackets(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
3887 
3888 /* API Name */
3889 RMH_RemoteNode_GetTxPackets,
3890 
3891 /* Description */
3892 "Return the total number of packets <nodeId> has transmitted.",
3893 
3894 /* Parameters */
3895 PARAMETERS(
3896  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3897  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3898  OUTPUT_PARAM(response, uint32_t*, "The total number of packets transmitted by <nodeId>")
3899 ),
3900 
3901 /* Wrap API */
3902 TRUE,
3903 
3904 /* Tags */
3905 "Remote Node"
3906 /********************************************************************************************************************/
3907 )
3908 
3909 
3910 
3911 RMH_API_IMPLEMENTATION_SOC_ONLY(
3912 /********************************************************************************************************************/
3913 /* API Declaration */
3914 RMH_Result RMH_RemoteNode_Reset(const RMH_Handle handle, const uint32_t nodeListMask, const uint32_t startTime),
3915 
3916 
3917 /* API Name */
3918 RMH_RemoteNode_Reset,
3919 
3920 /* Description */
3921 "Instruct one or more nodes to initiate a MoCA Reset command. This will result in the specfied nodes dropping from the network and then rejoining.",
3922 
3923 /* Parameters */
3924 PARAMETERS(
3925  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3926  INPUT_PARAM(nodeListMask, const uint32_t, "A bitmask of nodes to be reset [mocaIfMrNodeMask]. For example, to reset a given node use 'nodeListMask |= (1 << nodeId)'"),
3927  INPUT_PARAM(startTime, const uint32_t, "The time in seconds to start the reset command [mocaIfMrStartTime]")
3928 ),
3929 
3930 /* Wrap API */
3931 TRUE,
3932 
3933 /* Tags */
3934 "Network,Remote Node"
3935 /********************************************************************************************************************/
3936 )
3937 
3938 
3939 
3940 RMH_API_IMPLEMENTATION_SOC_ONLY(
3941 /********************************************************************************************************************/
3942 /* API Declaration */
3943 RMH_Result RMH_RemoteNode_GetRxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed),
3944 
3945 /* API Name */
3946 RMH_RemoteNode_GetRxUnicastSubcarrierModulation,
3947 
3948 /* Description */
3949 "Return the unicast recieve subcarrier modulation profiles for the primary MoCA channel.",
3950 
3951 /* Parameters */
3952 PARAMETERS(
3953  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3954  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3955  INPUT_PARAM(perMode, const RMH_PERMode, "The PER Mode to check. This parameter will be ignored for MoCA devices older than 2.0"),
3956  OUTPUT_PARAM(responseArray, RMH_SubcarrierProfile*, "An array where the sub carrier modulation should be stored"),
3957  INPUT_PARAM(responseArraySize, const size_t, "The size of the response array"),
3958  OUTPUT_PARAM(responseArrayUsed, size_t*, "The number of entries in the response array which have valid data")
3959 ),
3960 
3961 /* Wrap API */
3962 TRUE,
3963 
3964 /* Tags */
3965 "Remote Node,Phy"
3966 /********************************************************************************************************************/
3967 )
3968 
3969 
3970 
3971 RMH_API_IMPLEMENTATION_SOC_ONLY(
3972 /********************************************************************************************************************/
3973 /* API Declaration */
3974 RMH_Result RMH_RemoteNode_GetTxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed),
3975 
3976 /* API Name */
3977 RMH_RemoteNode_GetTxUnicastSubcarrierModulation,
3978 
3979 /* Description */
3980 "Return the unicast transmit subcarrier modulation profiles for the primary MoCA channel.",
3981 
3982 /* Parameters */
3983 PARAMETERS(
3984  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
3985  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
3986  INPUT_PARAM(perMode, const RMH_PERMode, "The PER Mode to check. This parameter will be ignored for MoCA devices older than 2.0"),
3987  OUTPUT_PARAM(responseArray, RMH_SubcarrierProfile*, "An array where the sub carrier modulation should be stored"),
3988  INPUT_PARAM(responseArraySize, const size_t, "The size of the response array"),
3989  OUTPUT_PARAM(responseArrayUsed, size_t*, "The number of entries in the response array which have valid data")
3990 ),
3991 
3992 /* Wrap API */
3993 TRUE,
3994 
3995 /* Tags */
3996 "Remote Node,Phy"
3997 /********************************************************************************************************************/
3998 )
3999 
4000 
4001 
4002 RMH_API_IMPLEMENTATION_SOC_ONLY(
4003 /********************************************************************************************************************/
4004 /* API Declaration */
4005 RMH_Result RMH_RemoteNode_GetSecondaryRxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed),
4006 
4007 /* API Name */
4008 RMH_RemoteNode_GetSecondaryRxUnicastSubcarrierModulation,
4009 
4010 /* Description */
4011 "Return the unicast recieve subcarrier modulation profiles for the secondary MoCA channel.",
4012 
4013 /* Parameters */
4014 PARAMETERS(
4015  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4016  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4017  INPUT_PARAM(perMode, const RMH_PERMode, "The PER Mode to check. This parameter will be ignored for MoCA devices older than 2.0"),
4018  OUTPUT_PARAM(responseArray, RMH_SubcarrierProfile*, "An array where the sub carrier modulation should be stored"),
4019  INPUT_PARAM(responseArraySize, const size_t, "The size of the response array"),
4020  OUTPUT_PARAM(responseArrayUsed, size_t*, "The number of entries in the response array which have valid data")
4021 ),
4022 
4023 /* Wrap API */
4024 TRUE,
4025 
4026 /* Tags */
4027 "Remote Node,Phy"
4028 /********************************************************************************************************************/
4029 )
4030 
4031 
4032 
4033 RMH_API_IMPLEMENTATION_SOC_ONLY(
4034 /********************************************************************************************************************/
4035 /* API Declaration */
4036 RMH_Result RMH_RemoteNode_GetSecondaryTxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed),
4037 
4038 /* API Name */
4039 RMH_RemoteNode_GetSecondaryTxUnicastSubcarrierModulation,
4040 
4041 /* Description */
4042 "Return the unicast transmit subcarrier modulation profiles for the secondary MoCA channel.",
4043 
4044 /* Parameters */
4045 PARAMETERS(
4046  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4047  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4048  INPUT_PARAM(perMode, const RMH_PERMode, "The PER Mode to check. This parameter will be ignored for MoCA devices older than 2.0"),
4049  OUTPUT_PARAM(responseArray, RMH_SubcarrierProfile*, "An array where the sub carrier modulation should be stored"),
4050  INPUT_PARAM(responseArraySize, const size_t, "The size of the response array"),
4051  OUTPUT_PARAM(responseArrayUsed, size_t*, "The number of entries in the response array which have valid data")
4052 ),
4053 
4054 /* Wrap API */
4055 TRUE,
4056 
4057 /* Tags */
4058 "Remote Node,Phy"
4059 /********************************************************************************************************************/
4060 )
4061 
4062 
4063 
4064 RMH_API_IMPLEMENTATION_SOC_ONLY(
4065 /********************************************************************************************************************/
4066 /* API Declaration */
4067 RMH_Result RMH_RemoteNode_GetRxBroadcastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed),
4068 
4069 /* API Name */
4070 RMH_RemoteNode_GetRxBroadcastSubcarrierModulation,
4071 
4072 /* Description */
4073 "Return the broadcast subcarrier modulation profiles for the channel. In the case of a MoCA 1.1 connection this will return the SubcarrierModulation",
4074 
4075 /* Parameters */
4076 PARAMETERS(
4077  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4078  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4079  INPUT_PARAM(perMode, const RMH_PERMode, "The PER Mode to check. This parameter will be ignored for MoCA devices older than 2.0"),
4080  OUTPUT_PARAM(responseArray, RMH_SubcarrierProfile*, "An array where the sub carrier modulation should be stored"),
4081  INPUT_PARAM(responseArraySize, const size_t, "The size of the response array"),
4082  OUTPUT_PARAM(responseArrayUsed, size_t*, "The number of entries in the response array which have valid data")
4083 ),
4084 
4085 /* Wrap API */
4086 TRUE,
4087 
4088 /* Tags */
4089 "Remote Node,Phy"
4090 /********************************************************************************************************************/
4091 )
4092 
4093 
4094 
4095 RMH_API_IMPLEMENTATION_SOC_ONLY(
4096 /********************************************************************************************************************/
4097 /* API Declaration */
4098 RMH_Result RMH_RemoteNode_GetTxBroadcastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed),
4099 
4100 /* API Name */
4101 RMH_RemoteNode_GetTxBroadcastSubcarrierModulation,
4102 
4103 /* Description */
4104 "Return the broadcast subcarrier modulation profiles for the channel. In the case of a MoCA 1.1 connection this will return the SubcarrierModulation",
4105 
4106 /* Parameters */
4107 PARAMETERS(
4108  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4109  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4110  INPUT_PARAM(perMode, const RMH_PERMode, "The PER Mode to check. This parameter will be ignored for MoCA devices older than 2.0"),
4111  OUTPUT_PARAM(responseArray, RMH_SubcarrierProfile*, "An array where the sub carrier modulation should be stored"),
4112  INPUT_PARAM(responseArraySize, const size_t, "The size of the response array"),
4113  OUTPUT_PARAM(responseArrayUsed, size_t*, "The number of entries in the response array which have valid data")
4114 ),
4115 
4116 /* Wrap API */
4117 TRUE,
4118 
4119 /* Tags */
4120 "Remote Node,Phy"
4121 /********************************************************************************************************************/
4122 )
4123 
4124 
4125 
4126 RMH_API_IMPLEMENTATION_SOC_ONLY(
4127 /********************************************************************************************************************/
4128 /* API Declaration */
4129 RMH_Result RMH_RemoteNode_GetMaxConstellation_GCD100(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
4130 
4131 /* API Name */
4132 RMH_RemoteNode_GetMaxConstellation_GCD100,
4133 
4134 /* Description */
4135 "Return the GCD (broadcast) constellation limit for 100 MHz profiles",
4136 
4137 /* Parameters */
4138 PARAMETERS(
4139  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4140  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4141  OUTPUT_PARAM(response, uint32_t*, "The GCD constellation for 100MHz for <nodeId>")
4142 ),
4143 
4144 /* Wrap API */
4145 TRUE,
4146 
4147 /* Tags */
4148 "Remote Node"
4149 /********************************************************************************************************************/
4150 )
4151 
4152 
4153 
4154 RMH_API_IMPLEMENTATION_SOC_ONLY(
4155 /********************************************************************************************************************/
4156 /* API Declaration */
4157 RMH_Result RMH_RemoteNode_SetMaxConstellation_GCD100(const RMH_Handle handle, const uint32_t nodeId, const uint32_t maxConstellation),
4158 
4159 /* API Name */
4160 RMH_RemoteNode_SetMaxConstellation_GCD100,
4161 
4162 /* Description */
4163 "Set the GCD (broadcast) constellation limit for 100 MHz profiles",
4164 
4165 /* Parameters */
4166 PARAMETERS(
4167  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4168  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4169  INPUT_PARAM(maxConstellation, const uint32_t, "The desired GCD constellation for 100MHz for <nodeId> between 0 and 10")
4170 ),
4171 
4172 /* Wrap API */
4173 TRUE,
4174 
4175 /* Tags */
4176 "Remote Node"
4177 /********************************************************************************************************************/
4178 )
4179 
4180 
4181 
4182 RMH_API_IMPLEMENTATION_SOC_ONLY(
4183 /********************************************************************************************************************/
4184 /* API Declaration */
4185 RMH_Result RMH_RemoteNode_GetMaxConstellation_GCD50(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
4186 
4187 /* API Name */
4188 RMH_RemoteNode_GetMaxConstellation_GCD50,
4189 
4190 /* Description */
4191 "Return the GCD (broadcast) constellation limit for 50 MHz profiles",
4192 
4193 /* Parameters */
4194 PARAMETERS(
4195  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4196  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4197  OUTPUT_PARAM(response, uint32_t*, "The GCD constellation for 50MHz for <nodeId>")
4198 ),
4199 
4200 /* Wrap API */
4201 TRUE,
4202 
4203 /* Tags */
4204 "Remote Node"
4205 /********************************************************************************************************************/
4206 )
4207 
4208 
4209 
4210 RMH_API_IMPLEMENTATION_SOC_ONLY(
4211 /********************************************************************************************************************/
4212 /* API Declaration */
4213 RMH_Result RMH_RemoteNode_SetMaxConstellation_GCD50(const RMH_Handle handle, const uint32_t nodeId, const uint32_t maxConstellation),
4214 
4215 /* API Name */
4216 RMH_RemoteNode_SetMaxConstellation_GCD50,
4217 
4218 /* Description */
4219 "Set the GCD (broadcast) constellation limit for 50 MHz profiles",
4220 
4221 /* Parameters */
4222 PARAMETERS(
4223  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4224  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4225  INPUT_PARAM(maxConstellation, const uint32_t, "The desired GCD constellation for 50MHz for <nodeId> between 0 and 10")
4226 ),
4227 
4228 /* Wrap API */
4229 TRUE,
4230 
4231 /* Tags */
4232 "Remote Node"
4233 /********************************************************************************************************************/
4234 )
4235 
4236 
4237 
4238 RMH_API_IMPLEMENTATION_SOC_ONLY(
4239 /********************************************************************************************************************/
4240 /* API Declaration */
4241 RMH_Result RMH_RemoteNode_GetMaxConstellation_P2P100(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
4242 
4243 /* API Name */
4244 RMH_RemoteNode_GetMaxConstellation_P2P100,
4245 
4246 /* Description */
4247 "Return the point-to-point (unicast) constellation limit for 100 MHz profiles",
4248 
4249 /* Parameters */
4250 PARAMETERS(
4251  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4252  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4253  OUTPUT_PARAM(response, uint32_t*, "The point-to-point constellation for 100MHz for <nodeId>")
4254 ),
4255 
4256 /* Wrap API */
4257 TRUE,
4258 
4259 /* Tags */
4260 "Remote Node"
4261 /********************************************************************************************************************/
4262 )
4263 
4264 
4265 
4266 RMH_API_IMPLEMENTATION_SOC_ONLY(
4267 /********************************************************************************************************************/
4268 /* API Declaration */
4269 RMH_Result RMH_RemoteNode_SetMaxConstellation_P2P100(const RMH_Handle handle, const uint32_t nodeId, const uint32_t maxConstellation),
4270 
4271 /* API Name */
4272 RMH_RemoteNode_SetMaxConstellation_P2P100,
4273 
4274 /* Description */
4275 "Set the point-to-point (unicast) constellation limit for 100 MHz profiles",
4276 
4277 /* Parameters */
4278 PARAMETERS(
4279  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4280  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4281  INPUT_PARAM(maxConstellation, const uint32_t, "The desired point-to-point constellation for 100MHz for <nodeId> between 0 and 10")
4282 ),
4283 
4284 /* Wrap API */
4285 TRUE,
4286 
4287 /* Tags */
4288 "Remote Node"
4289 /********************************************************************************************************************/
4290 )
4291 
4292 
4293 
4294 RMH_API_IMPLEMENTATION_SOC_ONLY(
4295 /********************************************************************************************************************/
4296 /* API Declaration */
4297 RMH_Result RMH_RemoteNode_GetMaxConstellation_P2P50(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
4298 
4299 /* API Name */
4300 RMH_RemoteNode_GetMaxConstellation_P2P50,
4301 
4302 /* Description */
4303 "Return the point-to-point (unicast) constellation limit for 50 MHz profiles",
4304 
4305 /* Parameters */
4306 PARAMETERS(
4307  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4308  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4309  OUTPUT_PARAM(response, uint32_t*, "The point-to-point constellation for 50MHz for <nodeId>")
4310 ),
4311 
4312 /* Wrap API */
4313 TRUE,
4314 
4315 /* Tags */
4316 "Remote Node"
4317 /********************************************************************************************************************/
4318 )
4319 
4320 
4321 
4322 RMH_API_IMPLEMENTATION_SOC_ONLY(
4323 /********************************************************************************************************************/
4324 /* API Declaration */
4325 RMH_Result RMH_RemoteNode_SetMaxConstellation_P2P50(const RMH_Handle handle, const uint32_t nodeId, const uint32_t maxConstellation),
4326 
4327 /* API Name */
4328 RMH_RemoteNode_SetMaxConstellation_P2P50,
4329 
4330 /* Description */
4331 "Set the point-to-point (unicast) constellation limit for 50 MHz profiles",
4332 
4333 /* Parameters */
4334 PARAMETERS(
4335  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4336  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4337  INPUT_PARAM(maxConstellation, const uint32_t, "The desired point-to-point constellation for 50MHz for <nodeId> between 0 and 10")
4338 ),
4339 
4340 /* Wrap API */
4341 TRUE,
4342 
4343 /* Tags */
4344 "Remote Node"
4345 /********************************************************************************************************************/
4346 )
4347 
4348 
4349 
4350 RMH_API_IMPLEMENTATION_SOC_ONLY(
4351 /********************************************************************************************************************/
4352 /* API Declaration */
4353 RMH_Result RMH_PQOS_GetMaxIngressFlows(const RMH_Handle handle, uint32_t* response),
4354 
4355 /* API Name */
4356 RMH_PQOS_GetMaxIngressFlows,
4357 
4358 /* Description */
4359 "Return the maximum number of supported Ingress PQoS Flows by the Node [mocaIfSupportedIngressPqosFlows]",
4360 
4361 /* Parameters */
4362 PARAMETERS(
4363  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4364  OUTPUT_PARAM(response, uint32_t*, "Maximum number of supported Ingress PQoS Flows by the Node")
4365 ),
4366 
4367 /* Wrap API */
4368 TRUE,
4369 
4370 /* Tags */
4371 "PQoS"
4372 /********************************************************************************************************************/
4373 )
4374 
4375 
4376 
4377 RMH_API_IMPLEMENTATION_SOC_ONLY(
4378 /********************************************************************************************************************/
4379 /* API Declaration */
4380 RMH_Result RMH_PQOS_GetMaxEgressFlows(const RMH_Handle handle, uint32_t* response),
4381 
4382 /* API Name */
4383 RMH_PQOS_GetMaxEgressFlows,
4384 
4385 /* Description */
4386 "Return the maximum number of supported Egress PQoS Flows by the Node [mocaIfSupportedEgressPqosFlows]",
4387 
4388 /* Parameters */
4389 PARAMETERS(
4390  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4391  OUTPUT_PARAM(response, uint32_t*, "Maximum number of supported Egress PQoS Flows by the Node")
4392 ),
4393 
4394 /* Wrap API */
4395 TRUE,
4396 
4397 /* Tags */
4398 "PQoS"
4399 /********************************************************************************************************************/
4400 )
4401 
4402 
4403 
4404 RMH_API_IMPLEMENTATION_SOC_ONLY(
4405 /********************************************************************************************************************/
4406 /* API Declaration */
4407 RMH_Result RMH_PQoS_GetNumIngressFlows(const RMH_Handle handle, uint32_t* response),
4408 
4409 /* API Name */
4410 RMH_PQoS_GetNumIngressFlows,
4411 
4412 /* Description */
4413 "Return the number of ingress flows",
4414 
4415 /* Parameters */
4416 PARAMETERS(
4417  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4418  OUTPUT_PARAM(response, uint32_t*, "The number of ingress flows")
4419 ),
4420 
4421 /* Wrap API */
4422 TRUE,
4423 
4424 /* Tags */
4425 "PQoS"
4426 /********************************************************************************************************************/
4427 )
4428 
4429 
4430 
4431 RMH_API_IMPLEMENTATION_SOC_ONLY(
4432 /********************************************************************************************************************/
4433 /* API Declaration */
4434 RMH_Result RMH_PQoS_GetNumEgressFlows(const RMH_Handle handle, uint32_t* response),
4435 
4436 /* API Name */
4437 RMH_PQoS_GetNumEgressFlows,
4438 
4439 /* Description */
4440 "Return the number of egress flows",
4441 
4442 /* Parameters */
4443 PARAMETERS(
4444  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4445  OUTPUT_PARAM(response, uint32_t*, "The number of egress flows")
4446 ),
4447 
4448 /* Wrap API */
4449 TRUE,
4450 
4451 /* Tags */
4452 "PQoS"
4453 /********************************************************************************************************************/
4454 )
4455 
4456 
4457 
4458 RMH_API_IMPLEMENTATION_SOC_ONLY(
4459 /********************************************************************************************************************/
4460 /* API Declaration */
4461 RMH_Result RMH_PQoS_GetEgressBandwidth(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response),
4462 
4463 /* API Name */
4464 RMH_PQoS_GetEgressBandwidth,
4465 
4466 /* Description */
4467 "Return the amount of egress bandwidth available on a particular node.",
4468 
4469 /* Parameters */
4470 PARAMETERS(
4471  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4472  INPUT_PARAM(nodeId, const uint32_t, "The node Id of the remote node to inspect"),
4473  OUTPUT_PARAM(response, uint32_t*, "The available egress bandwidth")
4474 ),
4475 
4476 /* Wrap API */
4477 TRUE,
4478 
4479 /* Tags */
4480 "PQoS"
4481 /********************************************************************************************************************/
4482 )
4483 
4484 
4485 
4486 RMH_API_IMPLEMENTATION_SOC_ONLY(
4487 /********************************************************************************************************************/
4488 /* API Declaration */
4489 RMH_Result RMH_PQoS_GetIngressFlowIds(const RMH_Handle handle, RMH_MacAddress_t* responseArray, const size_t responseArraySize, size_t* responseArrayUsed),
4490 
4491 /* API Name */
4492 RMH_PQoS_GetIngressFlowIds,
4493 
4494 /* Description */
4495 "Return a list of the unique Id for each existing ingress flows.",
4496 
4497 /* Parameters */
4498 PARAMETERS(
4499  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4500  OUTPUT_PARAM(responseArray, RMH_MacAddress_t*, "An array where the flow unique Ids should be returned"),
4501  INPUT_PARAM(responseArraySize, const size_t, "The size of the response array"),
4502  OUTPUT_PARAM(responseArrayUsed, size_t*, "The number of entries in the response array which have valid data")
4503 ),
4504 
4505 /* Wrap API */
4506 TRUE,
4507 
4508 /* Tags */
4509 "PQoS"
4510 /********************************************************************************************************************/
4511 )
4512 
4513 
4514 
4515 RMH_API_IMPLEMENTATION_SOC_ONLY(
4516 /********************************************************************************************************************/
4517 /* API Declaration */
4518 RMH_Result RMH_PQoSFlow_GetPeakDataRate(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4519 
4520 /* API Name */
4521 RMH_PQoSFlow_GetPeakDataRate,
4522 
4523 /* Description */
4524 "Return the peak data rate in Kbps for the flow specified by <flowId>",
4525 
4526 /* Parameters */
4527 PARAMETERS(
4528  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4529  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4530  OUTPUT_PARAM(response, uint32_t*, "The peak data rate in Kbps")
4531 ),
4532 
4533 /* Wrap API */
4534 TRUE,
4535 
4536 /* Tags */
4537 "PQoS"
4538 /********************************************************************************************************************/
4539 )
4540 
4541 
4542 
4543 RMH_API_IMPLEMENTATION_SOC_ONLY(
4544 /********************************************************************************************************************/
4545 /* API Declaration */
4546 RMH_Result RMH_PQoSFlow_GetBurstSize(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4547 
4548 /* API Name */
4549 RMH_PQoSFlow_GetBurstSize,
4550 
4551 /* Description */
4552 "Return the number of packets per burst for the flow specified by <flowId>",
4553 
4554 /* Parameters */
4555 PARAMETERS(
4556  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4557  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4558  OUTPUT_PARAM(response, uint32_t*, "The packets per burst")
4559 ),
4560 
4561 /* Wrap API */
4562 TRUE,
4563 
4564 /* Tags */
4565 "PQoS"
4566 /********************************************************************************************************************/
4567 )
4568 
4569 
4570 
4571 RMH_API_IMPLEMENTATION_SOC_ONLY(
4572 /********************************************************************************************************************/
4573 /* API Declaration */
4574 RMH_Result RMH_PQoSFlow_GetLeaseTime(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4575 
4576 /* API Name */
4577 RMH_PQoSFlow_GetLeaseTime,
4578 
4579 /* Description */
4580 "Return the lease time in seconds for the flow specified by <flowId>. Zero indicates an infinite lease time.",
4581 
4582 /* Parameters */
4583 PARAMETERS(
4584  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4585  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4586  OUTPUT_PARAM(response, uint32_t*, "The lease time in seconds")
4587 ),
4588 
4589 /* Wrap API */
4590 TRUE,
4591 
4592 /* Tags */
4593 "PQoS"
4594 /********************************************************************************************************************/
4595 )
4596 
4597 
4598 
4599 RMH_API_IMPLEMENTATION_SOC_ONLY(
4600 /********************************************************************************************************************/
4601 /* API Declaration */
4602 RMH_Result RMH_PQoSFlow_GetLeaseTimeRemaining(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4603 
4604 /* API Name */
4605 RMH_PQoSFlow_GetLeaseTimeRemaining,
4606 
4607 /* Description */
4608 "Return the lease time remaining in seconds for the flow specified by <flowId>",
4609 
4610 /* Parameters */
4611 PARAMETERS(
4612  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4613  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4614  OUTPUT_PARAM(response, uint32_t*, "The lease time remaining in seconds")
4615 ),
4616 
4617 /* Wrap API */
4618 TRUE,
4619 
4620 /* Tags */
4621 "PQoS"
4622 /********************************************************************************************************************/
4623 )
4624 
4625 
4626 
4627 RMH_API_IMPLEMENTATION_SOC_ONLY(
4628 /********************************************************************************************************************/
4629 /* API Declaration */
4630 RMH_Result RMH_PQoSFlow_GetFlowTag(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4631 
4632 /* API Name */
4633 RMH_PQoSFlow_GetFlowTag,
4634 
4635 /* Description */
4636 "Return the tag for the flow specified by <flowId>. This is optional for application use",
4637 
4638 /* Parameters */
4639 PARAMETERS(
4640  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4641  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4642  OUTPUT_PARAM(response, uint32_t*, "The flow tag")
4643 ),
4644 
4645 /* Wrap API */
4646 TRUE,
4647 
4648 /* Tags */
4649 "PQoS"
4650 /********************************************************************************************************************/
4651 )
4652 
4653 
4654 
4655 RMH_API_IMPLEMENTATION_SOC_ONLY(
4656 /********************************************************************************************************************/
4657 /* API Declaration */
4658 RMH_Result RMH_PQoSFlow_GetMaxLatency(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4659 
4660 /* API Name */
4661 RMH_PQoSFlow_GetMaxLatency,
4662 
4663 /* Description */
4664 "Return the maximum latency of the flow specified by <flowId>",
4665 
4666 /* Parameters */
4667 PARAMETERS(
4668  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4669  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4670  OUTPUT_PARAM(response, uint32_t*, "The maximum latency")
4671 ),
4672 
4673 /* Wrap API */
4674 TRUE,
4675 
4676 /* Tags */
4677 "PQoS"
4678 /********************************************************************************************************************/
4679 )
4680 
4681 
4682 
4683 RMH_API_IMPLEMENTATION_SOC_ONLY(
4684 /********************************************************************************************************************/
4685 /* API Declaration */
4686 RMH_Result RMH_PQoSFlow_GetShortTermAvgRatio(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4687 
4688 /* API Name */
4689 RMH_PQoSFlow_GetShortTermAvgRatio,
4690 
4691 /* Description */
4692 "Return the short term average ratio for the flow specified by <flowId>. This is the ratio of the short term average "
4693 "rate of the flow compared to the peak rate over the interval of <RMH_PQoSFlow_GetMaxLatency>. This value plus one "
4694 "serves as the numerator of the ratio. The denominator is 256. This value is only applicable when the maximun latency "
4695 "value is greater than or equal to 10 ms.",
4696 
4697 /* Parameters */
4698 PARAMETERS(
4699  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4700  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4701  OUTPUT_PARAM(response, uint32_t*, "The short term average ratio")
4702 ),
4703 
4704 /* Wrap API */
4705 TRUE,
4706 
4707 /* Tags */
4708 "PQoS"
4709 /********************************************************************************************************************/
4710 )
4711 
4712 
4713 
4714 RMH_API_IMPLEMENTATION_SOC_ONLY(
4715 /********************************************************************************************************************/
4716 /* API Declaration */
4717 RMH_Result RMH_PQoSFlow_GetMaxRetry(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4718 
4719 /* API Name */
4720 RMH_PQoSFlow_GetMaxRetry,
4721 
4722 /* Description */
4723 "Retrun the maximum number of retransmission attempts for each MSDU of the flow specified by <flowId>.",
4724 
4725 /* Parameters */
4726 PARAMETERS(
4727  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4728  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4729  OUTPUT_PARAM(response, uint32_t*, "The maximum retransmission attempts")
4730 ),
4731 
4732 /* Wrap API */
4733 TRUE,
4734 
4735 /* Tags */
4736 "PQoS"
4737 /********************************************************************************************************************/
4738 )
4739 
4740 
4741 
4742 RMH_API_IMPLEMENTATION_SOC_ONLY(
4743 /********************************************************************************************************************/
4744 /* API Declaration */
4745 RMH_Result RMH_PQoSFlow_GetVLANTag(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4746 
4747 /* API Name */
4748 RMH_PQoSFlow_GetVLANTag,
4749 
4750 /* Description */
4751 "Return the VLAN priority for the flow specified by <flowId>. This is used for MSDU classification when "
4752 "<RMH_PQoSFlow_GetIngressClassificationRule> is 6 or 7.",
4753 
4754 /* Parameters */
4755 PARAMETERS(
4756  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4757  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4758  OUTPUT_PARAM(response, uint32_t*, "The VLAN tag")
4759 ),
4760 
4761 /* Wrap API */
4762 TRUE,
4763 
4764 /* Tags */
4765 "PQoS"
4766 /********************************************************************************************************************/
4767 )
4768 
4769 
4770 
4771 RMH_API_IMPLEMENTATION_SOC_ONLY(
4772 /********************************************************************************************************************/
4773 /* API Declaration */
4774 RMH_Result RMH_PQoSFlow_GetFlowPer(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4775 
4776 /* API Name */
4777 RMH_PQoSFlow_GetFlowPer,
4778 
4779 /* Description */
4780 "Return the flow packet error ratio profile for the flow specified by <flowId>. This is to specify whether the flow "
4781 "should use the nominal packet error rate (PER) PHY profile or the Very Low PER PHY profile.",
4782 
4783 /* Parameters */
4784 PARAMETERS(
4785  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4786  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4787  OUTPUT_PARAM(response, uint32_t*, "The flow PER profile")
4788 ),
4789 
4790 /* Wrap API */
4791 TRUE,
4792 
4793 /* Tags */
4794 "PQoS"
4795 /********************************************************************************************************************/
4796 )
4797 
4798 
4799 
4800 RMH_API_IMPLEMENTATION_SOC_ONLY(
4801 /********************************************************************************************************************/
4802 /* API Declaration */
4803 RMH_Result RMH_PQoSFlow_GetIngressClassificationRule(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4804 
4805 /* API Name */
4806 RMH_PQoSFlow_GetIngressClassificationRule,
4807 
4808 /* Description */
4809 "Return the ingress classification rule for assigning MSDUs to the flow specified by <flowId>.",
4810 
4811 /* Parameters */
4812 PARAMETERS(
4813  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4814  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4815  OUTPUT_PARAM(response, uint32_t*, "The ingress classification rule")
4816 ),
4817 
4818 /* Wrap API */
4819 TRUE,
4820 
4821 /* Tags */
4822 "PQoS"
4823 /********************************************************************************************************************/
4824 )
4825 
4826 
4827 
4828 RMH_API_IMPLEMENTATION_SOC_ONLY(
4829 /********************************************************************************************************************/
4830 /* API Declaration */
4831 RMH_Result RMH_PQoSFlow_GetPacketSize(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4832 
4833 /* API Name */
4834 RMH_PQoSFlow_GetPacketSize,
4835 
4836 /* Description */
4837 "Return the packet size in bytes of the flow specified by <flowId>. This includes the VLAN header but not including "
4838 "the FCS.",
4839 
4840 /* Parameters */
4841 PARAMETERS(
4842  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4843  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4844  OUTPUT_PARAM(response, uint32_t*, "The flow packet size")
4845 ),
4846 
4847 /* Wrap API */
4848 TRUE,
4849 
4850 /* Tags */
4851 "PQoS"
4852 /********************************************************************************************************************/
4853 )
4854 
4855 
4856 
4857 RMH_API_IMPLEMENTATION_SOC_ONLY(
4858 /********************************************************************************************************************/
4859 /* API Declaration */
4860 RMH_Result RMH_PQoSFlow_GetTotalTxPackets(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4861 
4862 /* API Name */
4863 RMH_PQoSFlow_GetTotalTxPackets,
4864 
4865 /* Description */
4866 "Return the total number of packets transmitted on the flow specified by <flowId>.",
4867 
4868 /* Parameters */
4869 PARAMETERS(
4870  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4871  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4872  OUTPUT_PARAM(response, uint32_t*, "The total number of packets transmitted")
4873 ),
4874 
4875 /* Wrap API */
4876 TRUE,
4877 
4878 /* Tags */
4879 "PQoS"
4880 /********************************************************************************************************************/
4881 )
4882 
4883 
4884 
4885 RMH_API_IMPLEMENTATION_SOC_ONLY(
4886 /********************************************************************************************************************/
4887 /* API Declaration */
4888 RMH_Result RMH_PQoSFlow_GetDSCPMoCA(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4889 
4890 /* API Name */
4891 RMH_PQoSFlow_GetDSCPMoCA,
4892 
4893 /* Description */
4894 "Return the DSCP MoCA value for the flow specified by <flowId>. The value of the three MSB of the DSCP Type of "
4895 "Service field is used for MSDU classification when <RMH_PQoSFlow_GetIngressClassificationRule> is set to 1 or 3.",
4896 
4897 /* Parameters */
4898 PARAMETERS(
4899  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4900  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4901  OUTPUT_PARAM(response, uint32_t*, "The DSCP MoCA")
4902 ),
4903 
4904 /* Wrap API */
4905 TRUE,
4906 
4907 /* Tags */
4908 "PQoS"
4909 /********************************************************************************************************************/
4910 )
4911 
4912 
4913 
4914 RMH_API_IMPLEMENTATION_SOC_ONLY(
4915 /********************************************************************************************************************/
4916 /* API Declaration */
4917 RMH_Result RMH_PQoSFlow_GetDFID(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response),
4918 
4919 /* API Name */
4920 RMH_PQoSFlow_GetDFID,
4921 
4922 /* Description */
4923 "Return the destination flow ID of the flow specified by <flowId>.",
4924 
4925 /* Parameters */
4926 PARAMETERS(
4927  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4928  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4929  OUTPUT_PARAM(response, uint32_t*, "The DFID of the flow")
4930 ),
4931 
4932 /* Wrap API */
4933 TRUE,
4934 
4935 /* Tags */
4936 "PQoS"
4937 /********************************************************************************************************************/
4938 )
4939 
4940 
4941 
4942 RMH_API_IMPLEMENTATION_SOC_ONLY(
4943 /********************************************************************************************************************/
4944 /* API Declaration */
4945 RMH_Result RMH_PQoSFlow_GetDestination(const RMH_Handle handle, const RMH_MacAddress_t flowId, RMH_MacAddress_t *response),
4946 
4947 /* API Name */
4948 RMH_PQoSFlow_GetDestination,
4949 
4950 /* Description */
4951 "Return the destination MAC address of the traffic to be sent to the flow specified by <flowId>.",
4952 
4953 /* Parameters */
4954 PARAMETERS(
4955  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4956  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4957  OUTPUT_PARAM(response, RMH_MacAddress_t*, "The destination MAC of the flow")
4958 ),
4959 
4960 /* Wrap API */
4961 TRUE,
4962 
4963 /* Tags */
4964 "PQoS"
4965 /********************************************************************************************************************/
4966 )
4967 
4968 
4969 
4970 RMH_API_IMPLEMENTATION_SOC_ONLY(
4971 /********************************************************************************************************************/
4972 /* API Declaration */
4973 RMH_Result RMH_PQoSFlow_GetIngressMac(const RMH_Handle handle, const RMH_MacAddress_t flowId, RMH_MacAddress_t *response),
4974 
4975 /* API Name */
4976 RMH_PQoSFlow_GetIngressMac,
4977 
4978 /* Description */
4979 "Return the ingress MAC address of the flow specified by <flowId>.",
4980 
4981 /* Parameters */
4982 PARAMETERS(
4983  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
4984  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
4985  OUTPUT_PARAM(response, RMH_MacAddress_t*, "The ingress MAC of the flow")
4986 ),
4987 
4988 /* Wrap API */
4989 TRUE,
4990 
4991 /* Tags */
4992 "PQoS"
4993 /********************************************************************************************************************/
4994 )
4995 
4996 
4997 
4998 RMH_API_IMPLEMENTATION_SOC_ONLY(
4999 /********************************************************************************************************************/
5000 /* API Declaration */
5001 RMH_Result RMH_PQoSFlow_GetEgressMac(const RMH_Handle handle, const RMH_MacAddress_t flowId, RMH_MacAddress_t *response),
5002 
5003 /* API Name */
5004 RMH_PQoSFlow_GetEgressMac,
5005 
5006 /* Description */
5007 "Return the egress MAC address of the flow specified by <flowId>.",
5008 
5009 /* Parameters */
5010 PARAMETERS(
5011  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5012  INPUT_PARAM(flowId, const RMH_MacAddress_t, "The unique flow identifier"),
5013  OUTPUT_PARAM(response, RMH_MacAddress_t*, "The egress MAC of the flow")
5014 ),
5015 
5016 /* Wrap API */
5017 TRUE,
5018 
5019 /* Tags */
5020 "PQoS"
5021 /********************************************************************************************************************/
5022 )
5023 
5024 
5025 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
5026 /********************************************************************************************************************/
5027 /* API Declaration */
5028 RMH_Result RMH_PQoS_GetMaxEgressBandwidth(const RMH_Handle handle, uint32_t* response),
5029 
5030 /* API Name */
5031 RMH_PQoS_GetMaxEgressBandwidth,
5032 
5033 /* Description */
5034 "Return the node Id with the maximum available bandwidth",
5035 
5036 /* Parameters */
5037 PARAMETERS(
5038  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5039  OUTPUT_PARAM(response, uint32_t*, "The node Id with the maximum egress bandwidth")
5040 ),
5041 
5042 /* Wrap API */
5043 TRUE,
5044 
5045 /* Tags */
5046 "PQoS"
5047 /********************************************************************************************************************/
5048 )
5049 
5050 
5051 
5052 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
5053 /********************************************************************************************************************/
5054 /* API Declaration */
5055 RMH_Result RMH_PQoS_GetMinEgressBandwidth(const RMH_Handle handle, uint32_t* response),
5056 
5057 /* API Name */
5058 RMH_PQoS_GetMinEgressBandwidth,
5059 
5060 /* Description */
5061 "Return the node Id with the minimum available bandwidth",
5062 
5063 /* Parameters */
5064 PARAMETERS(
5065  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5066  OUTPUT_PARAM(response, uint32_t*, "The node Id with the minimum egress bandwidth")
5067 ),
5068 
5069 /* Wrap API */
5070 TRUE,
5071 
5072 /* Tags */
5073 "PQoS"
5074 /********************************************************************************************************************/
5075 )
5076 
5077 
5078 
5079 RMH_API_IMPLEMENTATION_SOC_ONLY(
5080 /********************************************************************************************************************/
5081 /* API Declaration */
5082 RMH_Result RMH_Stats_GetAdmissionAttempts(const RMH_Handle handle, uint32_t* response),
5083 
5084 /* API Name */
5085 RMH_Stats_GetAdmissionAttempts,
5086 
5087 /* Description */
5088 "Return the number of admission attempts this node has made. "
5089 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5090 
5091 /* Parameters */
5092 PARAMETERS(
5093  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5094  OUTPUT_PARAM(response, uint32_t*, "The number of admission attempts")
5095 ),
5096 
5097 /* Wrap API */
5098 TRUE,
5099 
5100 /* Tags */
5101 "Stats"
5102 /********************************************************************************************************************/
5103 )
5104 
5105 
5106 
5107 RMH_API_IMPLEMENTATION_SOC_ONLY(
5108 /********************************************************************************************************************/
5109 /* API Declaration */
5110 RMH_Result RMH_Stats_GetAdmissionFailures(const RMH_Handle handle, uint32_t* response),
5111 
5112 /* API Name */
5113 RMH_Stats_GetAdmissionFailures,
5114 
5115 /* Description */
5116 "Return the number of admission failures for this node"
5117 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5118 
5119 /* Parameters */
5120 PARAMETERS(
5121  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5122  OUTPUT_PARAM(response, uint32_t*, "The number of admission failures by this node")
5123 ),
5124 
5125 /* Wrap API */
5126 TRUE,
5127 
5128 /* Tags */
5129 "Stats"
5130 /********************************************************************************************************************/
5131 )
5132 
5133 
5134 
5135 RMH_API_IMPLEMENTATION_SOC_ONLY(
5136 /********************************************************************************************************************/
5137 /* API Declaration */
5138 RMH_Result RMH_Stats_GetAdmissionSucceeded(const RMH_Handle handle, uint32_t* response),
5139 
5140 /* API Name */
5141 RMH_Stats_GetAdmissionSucceeded,
5142 
5143 /* Description */
5144 "Return the number of successful admissions for this node. "
5145 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5146 
5147 /* Parameters */
5148 PARAMETERS(
5149  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5150  OUTPUT_PARAM(response, uint32_t*, "The number of successful admissions by this node")
5151 ),
5152 
5153 /* Wrap API */
5154 TRUE,
5155 
5156 /* Tags */
5157 "Stats"
5158 /********************************************************************************************************************/
5159 )
5160 
5161 
5162 
5163 RMH_API_IMPLEMENTATION_SOC_ONLY(
5164 /********************************************************************************************************************/
5165 /* API Declaration */
5166 RMH_Result RMH_Stats_GetAdmissionsDeniedAsNC(const RMH_Handle handle, uint32_t* response),
5167 
5168 /* API Name */
5169 RMH_Stats_GetAdmissionsDeniedAsNC,
5170 
5171 /* Description */
5172 "Return the number of admissions this node has denied when it was the NC. "
5173 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5174 
5175 /* Parameters */
5176 PARAMETERS(
5177  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5178  OUTPUT_PARAM(response, uint32_t*, "The number of admissions this node has denied when it was the NC")
5179 ),
5180 
5181 /* Wrap API */
5182 TRUE,
5183 
5184 /* Tags */
5185 "Stats,NC"
5186 /********************************************************************************************************************/
5187 )
5188 
5189 
5190 
5191 RMH_API_IMPLEMENTATION_SOC_ONLY(
5192 /********************************************************************************************************************/
5193 /* API Declaration */
5194 RMH_Result RMH_Stats_GetAdmissionsFailedNoResponse(const RMH_Handle handle, uint32_t* response),
5195 
5196 /* API Name */
5197 RMH_Stats_GetAdmissionsFailedNoResponse,
5198 
5199 /* Description */
5200 "Return the number of admissions attempts that this node has failed with no response"
5201 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5202 
5203 /* Parameters */
5204 PARAMETERS(
5205  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5206  OUTPUT_PARAM(response, uint32_t*, "The number of admissions this node has failed with no response")
5207 ),
5208 
5209 /* Wrap API */
5210 TRUE,
5211 
5212 /* Tags */
5213 "Stats"
5214 /********************************************************************************************************************/
5215 )
5216 
5217 
5218 
5219 RMH_API_IMPLEMENTATION_SOC_ONLY(
5220 /********************************************************************************************************************/
5221 /* API Declaration */
5222 RMH_Result RMH_Stats_GetAdmissionsFailedChannelUnusable(const RMH_Handle handle, uint32_t* response),
5223 
5224 /* API Name */
5225 RMH_Stats_GetAdmissionsFailedChannelUnusable,
5226 
5227 /* Description */
5228 "Return the number of admissions attempts that this node has failed with an unusable channel"
5229 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5230 
5231 /* Parameters */
5232 PARAMETERS(
5233  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5234  OUTPUT_PARAM(response, uint32_t*, "The number of admissions this node has failed with an unusable channel")
5235 ),
5236 
5237 /* Wrap API */
5238 TRUE,
5239 
5240 /* Tags */
5241 "Stats"
5242 /********************************************************************************************************************/
5243 )
5244 
5245 
5246 
5247 RMH_API_IMPLEMENTATION_SOC_ONLY(
5248 /********************************************************************************************************************/
5249 /* API Declaration */
5250 RMH_Result RMH_Stats_GetAdmissionsFailedT2Timeout(const RMH_Handle handle, uint32_t* response),
5251 
5252 /* API Name */
5253 RMH_Stats_GetAdmissionsFailedT2Timeout,
5254 
5255 /* Description */
5256 "Return the number of admissions attempts that this node has failed with a T2 timeout"
5257 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5258 
5259 /* Parameters */
5260 PARAMETERS(
5261  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5262  OUTPUT_PARAM(response, uint32_t*, "The number of admissions this node has failed with a T2 timeout")
5263 ),
5264 
5265 /* Wrap API */
5266 TRUE,
5267 
5268 /* Tags */
5269 "Stats"
5270 /********************************************************************************************************************/
5271 )
5272 
5273 
5274 
5275 RMH_API_IMPLEMENTATION_SOC_ONLY(
5276 /********************************************************************************************************************/
5277 /* API Declaration */
5278 RMH_Result RMH_Stats_GetAdmissionsFailedResyncLoss(const RMH_Handle handle, uint32_t* response),
5279 
5280 /* API Name */
5281 RMH_Stats_GetAdmissionsFailedResyncLoss,
5282 
5283 /* Description */
5284 "Return the number of admissions attempts that this node has failed with resync lost"
5285 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5286 
5287 /* Parameters */
5288 PARAMETERS(
5289  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5290  OUTPUT_PARAM(response, uint32_t*, "The number of admissions this node has failed with resync lost")
5291 ),
5292 
5293 /* Wrap API */
5294 TRUE,
5295 
5296 /* Tags */
5297 "Stats"
5298 /********************************************************************************************************************/
5299 )
5300 
5301 
5302 
5303 RMH_API_IMPLEMENTATION_SOC_ONLY(
5304 /********************************************************************************************************************/
5305 /* API Declaration */
5306 RMH_Result RMH_Stats_GetAdmissionsFailedPrivacyFullBlacklist(const RMH_Handle handle, uint32_t* response),
5307 
5308 /* API Name */
5309 RMH_Stats_GetAdmissionsFailedPrivacyFullBlacklist,
5310 
5311 /* Description */
5312 "Return the number of admissions attempts that this node has failed because of a privacy issue, the network was full, or this node was blacklisted."
5313 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5314 
5315 /* Parameters */
5316 PARAMETERS(
5317  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5318  OUTPUT_PARAM(response, uint32_t*, "The number of admissions this node has failed")
5319 ),
5320 
5321 /* Wrap API */
5322 TRUE,
5323 
5324 /* Tags */
5325 "Stats"
5326 /********************************************************************************************************************/
5327 )
5328 
5329 
5330 
5331 RMH_API_IMPLEMENTATION_SOC_ONLY(
5332 /********************************************************************************************************************/
5333 /* API Declaration */
5334 RMH_Result RMH_Stats_GetTxTotalBytes(const RMH_Handle handle, uint32_t* response),
5335 
5336 /* API Name */
5337 RMH_Stats_GetTxTotalBytes,
5338 
5339 /* Description */
5340 "Return the total number of bytes transmitted by this node. "
5341 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5342 
5343 /* Parameters */
5344 PARAMETERS(
5345  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5346  OUTPUT_PARAM(response, uint32_t*, "The total number of bytes transmitted by this node")
5347 ),
5348 
5349 /* Wrap API */
5350 TRUE,
5351 
5352 /* Tags */
5353 "Stats"
5354 /********************************************************************************************************************/
5355 )
5356 
5357 
5358 
5359 RMH_API_IMPLEMENTATION_SOC_ONLY(
5360 /********************************************************************************************************************/
5361 /* API Declaration */
5362 RMH_Result RMH_Stats_GetRxTotalBytes(const RMH_Handle handle, uint32_t* response),
5363 
5364 /* API Name */
5365 RMH_Stats_GetRxTotalBytes,
5366 
5367 /* Description */
5368 "Return the total number of bytes received by this node. "
5369 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5370 
5371 /* Parameters */
5372 PARAMETERS(
5373  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5374  OUTPUT_PARAM(response, uint32_t*, "The total number of bytes received by this node")
5375 ),
5376 
5377 /* Wrap API */
5378 TRUE,
5379 
5380 /* Tags */
5381 "Stats"
5382 /********************************************************************************************************************/
5383 )
5384 
5385 
5386 
5387 RMH_API_IMPLEMENTATION_SOC_ONLY(
5388 /********************************************************************************************************************/
5389 /* API Declaration */
5390 RMH_Result RMH_Stats_GetTxTotalPackets(const RMH_Handle handle, uint32_t* response),
5391 
5392 /* API Name */
5393 RMH_Stats_GetTxTotalPackets,
5394 
5395 /* Description */
5396 "Return the total number of packets transmitted by this node. "
5397 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5398 
5399 /* Parameters */
5400 PARAMETERS(
5401  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5402  OUTPUT_PARAM(response, uint32_t*, "The number of packets transmitted by this node")
5403 ),
5404 
5405 /* Wrap API */
5406 TRUE,
5407 
5408 /* Tags */
5409 "Stats"
5410 /********************************************************************************************************************/
5411 )
5412 
5413 
5414 
5415 RMH_API_IMPLEMENTATION_SOC_ONLY(
5416 /********************************************************************************************************************/
5417 /* API Declaration */
5418 RMH_Result RMH_Stats_GetRxTotalPackets(const RMH_Handle handle, uint32_t* response),
5419 
5420 /* API Name */
5421 RMH_Stats_GetRxTotalPackets,
5422 
5423 /* Description */
5424 "Return the total number of packets received by this node. "
5425 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5426 
5427 /* Parameters */
5428 PARAMETERS(
5429  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5430  OUTPUT_PARAM(response, uint32_t*, "The number of received transmitted by this node")
5431 ),
5432 
5433 /* Wrap API */
5434 TRUE,
5435 
5436 /* Tags */
5437 "Stats"
5438 /********************************************************************************************************************/
5439 )
5440 
5441 
5442 
5443 RMH_API_IMPLEMENTATION_SOC_ONLY(
5444 /********************************************************************************************************************/
5445 /* API Declaration */
5446 RMH_Result RMH_Stats_GetTxUnicastPackets(const RMH_Handle handle, uint32_t* response),
5447 
5448 /* API Name */
5449 RMH_Stats_GetTxUnicastPackets,
5450 
5451 /* Description */
5452 "Return the number of unicast packets transmitted by this node. "
5453 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5454 
5455 /* Parameters */
5456 PARAMETERS(
5457  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5458  OUTPUT_PARAM(response, uint32_t*, "The number of unicast packets transmitted by this node")
5459 ),
5460 
5461 /* Wrap API */
5462 TRUE,
5463 
5464 /* Tags */
5465 "Stats"
5466 /********************************************************************************************************************/
5467 )
5468 
5469 
5470 
5471 RMH_API_IMPLEMENTATION_SOC_ONLY(
5472 /********************************************************************************************************************/
5473 /* API Declaration */
5474 RMH_Result RMH_Stats_GetRxUnicastPackets(const RMH_Handle handle, uint32_t* response),
5475 
5476 /* API Name */
5477 RMH_Stats_GetRxUnicastPackets,
5478 
5479 /* Description */
5480 "Return the number of unicast packets received by this node. "
5481 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5482 
5483 /* Parameters */
5484 PARAMETERS(
5485  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5486  OUTPUT_PARAM(response, uint32_t*, "The number of unicast packets received by this node")
5487 ),
5488 
5489 /* Wrap API */
5490 TRUE,
5491 
5492 /* Tags */
5493 "Stats"
5494 /********************************************************************************************************************/
5495 )
5496 
5497 
5498 
5499 RMH_API_IMPLEMENTATION_SOC_ONLY(
5500 /********************************************************************************************************************/
5501 /* API Declaration */
5502 RMH_Result RMH_Stats_GetTxBroadcastPackets(const RMH_Handle handle, uint32_t* response),
5503 
5504 /* API Name */
5505 RMH_Stats_GetTxBroadcastPackets,
5506 
5507 /* Description */
5508 "Return the number of broadcast packets transmitted by this node. "
5509 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5510 
5511 /* Parameters */
5512 PARAMETERS(
5513  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5514  OUTPUT_PARAM(response, uint32_t*, "The number of broadcast packets transmitted by this node")
5515 ),
5516 
5517 /* Wrap API */
5518 TRUE,
5519 
5520 /* Tags */
5521 "Stats"
5522 /********************************************************************************************************************/
5523 )
5524 
5525 
5526 
5527 RMH_API_IMPLEMENTATION_SOC_ONLY(
5528 /********************************************************************************************************************/
5529 /* API Declaration */
5530 RMH_Result RMH_Stats_GetRxBroadcastPackets(const RMH_Handle handle, uint32_t* response),
5531 
5532 /* API Name */
5533 RMH_Stats_GetRxBroadcastPackets,
5534 
5535 /* Description */
5536 "Return the number of broadcast packets received by this node. "
5537 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5538 
5539 /* Parameters */
5540 PARAMETERS(
5541  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5542  OUTPUT_PARAM(response, uint32_t*, "The number of broadcast packets received by this node")
5543 ),
5544 
5545 /* Wrap API */
5546 TRUE,
5547 
5548 /* Tags */
5549 "Stats"
5550 /********************************************************************************************************************/
5551 )
5552 
5553 
5554 
5555 RMH_API_IMPLEMENTATION_SOC_ONLY(
5556 /********************************************************************************************************************/
5557 /* API Declaration */
5558 RMH_Result RMH_Stats_GetTxMulticastPackets(const RMH_Handle handle, uint32_t* response),
5559 
5560 /* API Name */
5561 RMH_Stats_GetTxMulticastPackets,
5562 
5563 /* Description */
5564 "Return the number of multicast packets transmitted by this node. "
5565 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5566 
5567 /* Parameters */
5568 PARAMETERS(
5569  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5570  OUTPUT_PARAM(response, uint32_t*, "The number of multicast packets transmitted by this node")
5571 ),
5572 
5573 /* Wrap API */
5574 TRUE,
5575 
5576 /* Tags */
5577 "Stats"
5578 /********************************************************************************************************************/
5579 )
5580 
5581 
5582 
5583 RMH_API_IMPLEMENTATION_SOC_ONLY(
5584 /********************************************************************************************************************/
5585 /* API Declaration */
5586 RMH_Result RMH_Stats_GetRxMulticastPackets(const RMH_Handle handle, uint32_t* response),
5587 
5588 /* API Name */
5589 RMH_Stats_GetRxMulticastPackets,
5590 
5591 /* Description */
5592 "Return the number of multicast packets received by this node. "
5593 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5594 
5595 /* Parameters */
5596 PARAMETERS(
5597  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5598  OUTPUT_PARAM(response, uint32_t*, "The number of multicast packets received by this node")
5599 ),
5600 
5601 /* Wrap API */
5602 TRUE,
5603 
5604 /* Tags */
5605 "Stats"
5606 /********************************************************************************************************************/
5607 )
5608 
5609 
5610 
5611 RMH_API_IMPLEMENTATION_SOC_ONLY(
5612 /********************************************************************************************************************/
5613 /* API Declaration */
5614 RMH_Result RMH_Stats_GetTxReservationRequestPackets(const RMH_Handle handle, uint32_t* response),
5615 
5616 /* API Name */
5617 RMH_Stats_GetTxReservationRequestPackets,
5618 
5619 /* Description */
5620 "Return the number of reservation request packets transmitted by this node. "
5621 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5622 
5623 /* Parameters */
5624 PARAMETERS(
5625  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5626  OUTPUT_PARAM(response, uint32_t*, "The number of reservation request packets transmitted by this node")
5627 ),
5628 
5629 /* Wrap API */
5630 TRUE,
5631 
5632 /* Tags */
5633 "Stats"
5634 /********************************************************************************************************************/
5635 )
5636 
5637 
5638 
5639 RMH_API_IMPLEMENTATION_SOC_ONLY(
5640 /********************************************************************************************************************/
5641 /* API Declaration */
5642 RMH_Result RMH_Stats_GetRxReservationRequestPackets(const RMH_Handle handle, uint32_t* response),
5643 
5644 /* API Name */
5645 RMH_Stats_GetRxReservationRequestPackets,
5646 
5647 /* Description */
5648 "Return the number of reservation request packets received by this node. "
5649 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5650 
5651 /* Parameters */
5652 PARAMETERS(
5653  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5654  OUTPUT_PARAM(response, uint32_t*, "The number of reservation request packets received by this node")
5655 ),
5656 
5657 /* Wrap API */
5658 TRUE,
5659 
5660 /* Tags */
5661 "Stats"
5662 /********************************************************************************************************************/
5663 )
5664 
5665 
5666 
5667 RMH_API_IMPLEMENTATION_SOC_ONLY(
5668 /********************************************************************************************************************/
5669 /* API Declaration */
5670 RMH_Result RMH_Stats_GetTxMapPackets(const RMH_Handle handle, uint32_t* response),
5671 
5672 /* API Name */
5673 RMH_Stats_GetTxMapPackets,
5674 
5675 /* Description */
5676 "Return the number of MAP transmitted by this node. "
5677 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5678 
5679 /* Parameters */
5680 PARAMETERS(
5681  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5682  OUTPUT_PARAM(response, uint32_t*, "The number of MAP packets transmitted by this node")
5683 ),
5684 
5685 /* Wrap API */
5686 TRUE,
5687 
5688 /* Tags */
5689 "Stats"
5690 /********************************************************************************************************************/
5691 )
5692 
5693 
5694 
5695 RMH_API_IMPLEMENTATION_SOC_ONLY(
5696 /********************************************************************************************************************/
5697 /* API Declaration */
5698 RMH_Result RMH_Stats_GetRxMapPackets(const RMH_Handle handle, uint32_t* response),
5699 
5700 /* API Name */
5701 RMH_Stats_GetRxMapPackets,
5702 
5703 /* Description */
5704 "Return the number of MAP received by this node. "
5705 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5706 
5707 /* Parameters */
5708 PARAMETERS(
5709  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5710  OUTPUT_PARAM(response, uint32_t*, "The number of MAP packets received by this node")
5711 ),
5712 
5713 /* Wrap API */
5714 TRUE,
5715 
5716 /* Tags */
5717 "Stats"
5718 /********************************************************************************************************************/
5719 )
5720 
5721 
5722 
5723 RMH_API_IMPLEMENTATION_SOC_ONLY(
5724 /********************************************************************************************************************/
5725 /* API Declaration */
5726 RMH_Result RMH_Stats_GetTxLinkControlPackets(const RMH_Handle handle, uint32_t* response),
5727 
5728 /* API Name */
5729 RMH_Stats_GetTxLinkControlPackets,
5730 
5731 /* Description */
5732 "Return the number of link control transmitted by this node. "
5733 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5734 
5735 /* Parameters */
5736 PARAMETERS(
5737  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5738  OUTPUT_PARAM(response, uint32_t*, "The number of link control packets transmitted by this node")
5739 ),
5740 
5741 /* Wrap API */
5742 TRUE,
5743 
5744 /* Tags */
5745 "Stats"
5746 /********************************************************************************************************************/
5747 )
5748 
5749 
5750 
5751 RMH_API_IMPLEMENTATION_SOC_ONLY(
5752 /********************************************************************************************************************/
5753 /* API Declaration */
5754 RMH_Result RMH_Stats_GetRxLinkControlPackets(const RMH_Handle handle, uint32_t* response),
5755 
5756 /* API Name */
5757 RMH_Stats_GetRxLinkControlPackets,
5758 
5759 /* Description */
5760 "Return the number of link control received by this node. "
5761 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5762 
5763 /* Parameters */
5764 PARAMETERS(
5765  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5766  OUTPUT_PARAM(response, uint32_t*, "The number of link control packets received by this node")
5767 ),
5768 
5769 /* Wrap API */
5770 TRUE,
5771 
5772 /* Tags */
5773 "Stats"
5774 /********************************************************************************************************************/
5775 )
5776 
5777 
5778 
5779 RMH_API_IMPLEMENTATION_SOC_ONLY(
5780 /********************************************************************************************************************/
5781 /* API Declaration */
5782 RMH_Result RMH_Stats_GetTxBeacons(const RMH_Handle handle, uint32_t* response),
5783 
5784 /* API Name */
5785 RMH_Stats_GetTxBeacons,
5786 
5787 /* Description */
5788 "Return the number of beacons transmitted by this node. "
5789 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5790 
5791 /* Parameters */
5792 PARAMETERS(
5793  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5794  OUTPUT_PARAM(response, uint32_t*, "The number of beacons transmitted by this node")
5795 ),
5796 
5797 /* Wrap API */
5798 TRUE,
5799 
5800 /* Tags */
5801 "Stats"
5802 /********************************************************************************************************************/
5803 )
5804 
5805 
5806 
5807 RMH_API_IMPLEMENTATION_SOC_ONLY(
5808 /********************************************************************************************************************/
5809 /* API Declaration */
5810 RMH_Result RMH_Stats_GetRxBeacons(const RMH_Handle handle, uint32_t* response),
5811 
5812 /* API Name */
5813 RMH_Stats_GetRxBeacons,
5814 
5815 /* Description */
5816 "Return the number of beacons received by this node. "
5817 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5818 
5819 /* Parameters */
5820 PARAMETERS(
5821  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5822  OUTPUT_PARAM(response, uint32_t*, "The number of beacons received by this node")
5823 ),
5824 
5825 /* Wrap API */
5826 TRUE,
5827 
5828 /* Tags */
5829 "Stats"
5830 /********************************************************************************************************************/
5831 )
5832 
5833 
5834 
5835 RMH_API_IMPLEMENTATION_SOC_ONLY(
5836 /********************************************************************************************************************/
5837 /* API Declaration */
5838 RMH_Result RMH_Stats_GetRxUnknownProtocolPackets(const RMH_Handle handle, uint32_t* response),
5839 
5840 /* API Name */
5841 RMH_Stats_GetRxUnknownProtocolPackets,
5842 
5843 /* Description */
5844 "Return the number of unknown packets received by this node. "
5845 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5846 
5847 /* Parameters */
5848 PARAMETERS(
5849  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5850  OUTPUT_PARAM(response, uint32_t*, "The number of unknown packets received by this node")
5851 ),
5852 
5853 /* Wrap API */
5854 TRUE,
5855 
5856 /* Tags */
5857 "Stats"
5858 /********************************************************************************************************************/
5859 )
5860 
5861 
5862 
5863 RMH_API_IMPLEMENTATION_SOC_ONLY(
5864 /********************************************************************************************************************/
5865 /* API Declaration */
5866 RMH_Result RMH_Stats_GetTxDroppedPackets(const RMH_Handle handle, uint32_t* response),
5867 
5868 /* API Name */
5869 RMH_Stats_GetTxDroppedPackets,
5870 
5871 /* Description */
5872 "Return the number of packets this node has dropped before transmitting. "
5873 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5874 
5875 /* Parameters */
5876 PARAMETERS(
5877  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5878  OUTPUT_PARAM(response, uint32_t*, "The number of packets dropped by this node before transmitting")
5879 ),
5880 
5881 /* Wrap API */
5882 TRUE,
5883 
5884 /* Tags */
5885 "Stats"
5886 /********************************************************************************************************************/
5887 )
5888 
5889 
5890 
5891 RMH_API_IMPLEMENTATION_SOC_ONLY(
5892 /********************************************************************************************************************/
5893 /* API Declaration */
5894 RMH_Result RMH_Stats_GetRxDroppedPackets(const RMH_Handle handle, uint32_t* response),
5895 
5896 /* API Name */
5897 RMH_Stats_GetRxDroppedPackets,
5898 
5899 /* Description */
5900 "Return the number of packets this node has dropped after receiving. "
5901 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5902 
5903 /* Parameters */
5904 PARAMETERS(
5905  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5906  OUTPUT_PARAM(response, uint32_t*, "The number of received packets dropped by this node")
5907 ),
5908 
5909 /* Wrap API */
5910 TRUE,
5911 
5912 /* Tags */
5913 "Stats"
5914 /********************************************************************************************************************/
5915 )
5916 
5917 
5918 
5919 RMH_API_IMPLEMENTATION_SOC_ONLY(
5920 /********************************************************************************************************************/
5921 /* API Declaration */
5922 RMH_Result RMH_Stats_GetTxTotalErrors(const RMH_Handle handle, uint32_t* response),
5923 
5924 /* API Name */
5925 RMH_Stats_GetTxTotalErrors,
5926 
5927 /* Description */
5928 "Return the total number of transmit errors by this node. "
5929 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5930 
5931 /* Parameters */
5932 PARAMETERS(
5933  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5934  OUTPUT_PARAM(response, uint32_t*, "The total number of transmit errors by this node")
5935 ),
5936 
5937 /* Wrap API */
5938 TRUE,
5939 
5940 /* Tags */
5941 "Stats"
5942 /********************************************************************************************************************/
5943 )
5944 
5945 
5946 
5947 RMH_API_IMPLEMENTATION_SOC_ONLY(
5948 /********************************************************************************************************************/
5949 /* API Declaration */
5950 RMH_Result RMH_Stats_GetRxTotalErrors(const RMH_Handle handle, uint32_t* response),
5951 
5952 /* API Name */
5953 RMH_Stats_GetRxTotalErrors,
5954 
5955 /* Description */
5956 "Return the total number of received errors by this node. "
5957 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5958 
5959 /* Parameters */
5960 PARAMETERS(
5961  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5962  OUTPUT_PARAM(response, uint32_t*, "The total number of receive errors by this node")
5963 ),
5964 
5965 /* Wrap API */
5966 TRUE,
5967 
5968 /* Tags */
5969 "Stats"
5970 /********************************************************************************************************************/
5971 )
5972 
5973 
5974 
5975 RMH_API_IMPLEMENTATION_SOC_ONLY(
5976 /********************************************************************************************************************/
5977 /* API Declaration */
5978 RMH_Result RMH_Stats_GetRxCRCErrors(const RMH_Handle handle, uint32_t* response),
5979 
5980 /* API Name */
5981 RMH_Stats_GetRxCRCErrors,
5982 
5983 /* Description */
5984 "Return the total number of packets this node has received with CRC errors. "
5985 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
5986 
5987 /* Parameters */
5988 PARAMETERS(
5989  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
5990  OUTPUT_PARAM(response, uint32_t*, "The total number of received packets with CRC errors")
5991 ),
5992 
5993 /* Wrap API */
5994 TRUE,
5995 
5996 /* Tags */
5997 "Stats"
5998 /********************************************************************************************************************/
5999 )
6000 
6001 
6002 
6003 RMH_API_IMPLEMENTATION_SOC_ONLY(
6004 /********************************************************************************************************************/
6005 /* API Declaration */
6006 RMH_Result RMH_Stats_GetRxTimeoutErrors(const RMH_Handle handle, uint32_t* response),
6007 
6008 /* API Name */
6009 RMH_Stats_GetRxTimeoutErrors,
6010 
6011 /* Description */
6012 "Return the total number of packets this node has received with timeout errors. "
6013 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
6014 
6015 /* Parameters */
6016 PARAMETERS(
6017  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6018  OUTPUT_PARAM(response, uint32_t*, "The total number of received packets with timeout errors")
6019 ),
6020 
6021 /* Wrap API */
6022 TRUE,
6023 
6024 /* Tags */
6025 "Stats"
6026 /********************************************************************************************************************/
6027 )
6028 
6029 
6030 
6031 RMH_API_IMPLEMENTATION_SOC_ONLY(
6032 /********************************************************************************************************************/
6033 /* API Declaration */
6034 RMH_Result RMH_Stats_GetRxTotalAggregatedPackets(const RMH_Handle handle, uint32_t* response),
6035 
6036 /* API Name */
6037 RMH_Stats_GetRxTotalAggregatedPackets,
6038 
6039 /* Description */
6040 "Return the total number of received aggregated packets. "
6041 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
6042 
6043 /* Parameters */
6044 PARAMETERS(
6045  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6046  OUTPUT_PARAM(response, uint32_t*, "The total number of received aggregated packets")
6047 ),
6048 
6049 /* Wrap API */
6050 TRUE,
6051 
6052 /* Tags */
6053 "Stats"
6054 /********************************************************************************************************************/
6055 )
6056 
6057 
6058 
6059 RMH_API_IMPLEMENTATION_SOC_ONLY(
6060 /********************************************************************************************************************/
6061 /* API Declaration */
6062 RMH_Result RMH_Stats_GetTxTotalAggregatedPackets(const RMH_Handle handle, uint32_t* response),
6063 
6064 /* API Name */
6065 RMH_Stats_GetTxTotalAggregatedPackets,
6066 
6067 /* Description */
6068 "Return the total number of transmitted aggregated packets. "
6069 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
6070 
6071 /* Parameters */
6072 PARAMETERS(
6073  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6074  OUTPUT_PARAM(response, uint32_t*, "The total number of transmitted aggregated packets")
6075 ),
6076 
6077 /* Wrap API */
6078 TRUE,
6079 
6080 /* Tags */
6081 "Stats"
6082 /********************************************************************************************************************/
6083 )
6084 
6085 
6086 RMH_API_IMPLEMENTATION_SOC_ONLY(
6087 /********************************************************************************************************************/
6088 /* API Declaration */
6089 
6090 RMH_Result RMH_Stats_GetRxPacketAggregation(const RMH_Handle handle, uint32_t* responseArray, const size_t responseArraySize, size_t* responseArrayUsed),
6091 
6092 /* API Name */
6093 RMH_Stats_GetRxPacketAggregation,
6094 
6095 /* Description */
6096 "Return an array indicating the number of packets received per aggregation number. "
6097 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
6098 
6099 /* Parameters */
6100 PARAMETERS(
6101  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6102  OUTPUT_PARAM(responseArray, uint32_t*, "An array where the aggregation information should be returned"),
6103  INPUT_PARAM(responseArraySize, const size_t, "The size of the response array"),
6104  OUTPUT_PARAM(responseArrayUsed, size_t*, "The number of entries in the response array which have valid data")
6105 ),
6106 
6107 /* Wrap API */
6108 TRUE,
6109 
6110 /* Tags */
6111 "Stats"
6112 /********************************************************************************************************************/
6113 )
6114 
6115 
6116 
6117 RMH_API_IMPLEMENTATION_SOC_ONLY(
6118 /********************************************************************************************************************/
6119 /* API Declaration */
6120 RMH_Result RMH_Stats_GetTxPacketAggregation(const RMH_Handle handle, uint32_t* responseArray, const size_t responseArraySize, size_t* responseArrayUsed),
6121 
6122 /* API Name */
6123 RMH_Stats_GetTxPacketAggregation,
6124 
6125 /* Description */
6126 "Return an array indicating the number of packets transmitted per aggregation number. The array index indicates "
6127 "the number of transmitted bursts. So index 0 counts transmitted bursts with actual aggregation of 0, index 2 counts "
6128 "actual aggregation of 2, and so on."
6129 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
6130 
6131 /* Parameters */
6132 PARAMETERS(
6133  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6134  OUTPUT_PARAM(responseArray, uint32_t*, "An array where the aggregation information should be returned"),
6135  INPUT_PARAM(responseArraySize, const size_t, "The size of the response array"),
6136  OUTPUT_PARAM(responseArrayUsed, size_t*, "The number of entries in the response array which have valid data")
6137 ),
6138 
6139 /* Wrap API */
6140 TRUE,
6141 
6142 /* Tags */
6143 "Stats"
6144 /********************************************************************************************************************/
6145 )
6146 
6147 
6148 
6149 RMH_API_IMPLEMENTATION_SOC_ONLY(
6150 /********************************************************************************************************************/
6151 /* API Declaration */
6152 RMH_Result RMH_Stats_GetRxCorrectedErrors(const RMH_Handle handle, RMH_NodeList_Uint32_t* response),
6153 
6154 /* API Name */
6155 RMH_Stats_GetRxCorrectedErrors,
6156 
6157 /* Description */
6158 "Return the number of received packets from every node with errors which were corrected. "
6159 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
6160 
6161 /* Parameters */
6162 PARAMETERS(
6163  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6164  OUTPUT_PARAM(response, RMH_NodeList_Uint32_t*,
6165  "Where the index is the node Id, if <nodePresent> is 'true', <nodeValue> is the number of corrected errors for that node.")
6166 ),
6167 
6168 /* Wrap API */
6169 TRUE,
6170 
6171 /* Tags */
6172 "Stats"
6173 /********************************************************************************************************************/
6174 )
6175 
6176 
6177 
6178 RMH_API_IMPLEMENTATION_SOC_ONLY(
6179 /********************************************************************************************************************/
6180 /* API Declaration */
6181 RMH_Result RMH_Stats_GetRxUncorrectedErrors(const RMH_Handle handle, RMH_NodeList_Uint32_t* response),
6182 
6183 /* API Name */
6184 RMH_Stats_GetRxUncorrectedErrors,
6185 
6186 /* Description */
6187 "Return the number of received packets from every node with errors which were not corrected. "
6188 "\n**NOTE: This counter is reset by <RMH_Stats_Reset>",
6189 
6190 /* Parameters */
6191 PARAMETERS(
6192  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6193  OUTPUT_PARAM(response, RMH_NodeList_Uint32_t*,
6194  "Where the index is the node Id, if <nodePresent> is 'true', <nodeValue> is the number of uncorrected errors for that node.")
6195 ),
6196 
6197 /* Wrap API */
6198 TRUE,
6199 
6200 /* Tags */
6201 "Stats"
6202 /********************************************************************************************************************/
6203 )
6204 
6205 
6206 
6207 RMH_API_IMPLEMENTATION_SOC_ONLY(
6208 /********************************************************************************************************************/
6209 /* API Declaration */
6210 RMH_Result RMH_Stats_Reset(const RMH_Handle handle),
6211 
6212 /* API Name */
6213 RMH_Stats_Reset,
6214 
6215 /* Description */
6216 "Reset MoCA statistics counters back to zero.",
6217 
6218 /* Parameters */
6219 PARAMETERS(
6220  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize")
6221 ),
6222 
6223 /* Wrap API */
6224 TRUE,
6225 
6226 /* Tags */
6227 "Stats"
6228 /********************************************************************************************************************/
6229 )
6230 
6231 
6232 RMH_API_IMPLEMENTATION_GENERIC_THEN_SOC(
6233 /********************************************************************************************************************/
6234 /* API Declaration */
6235 RMH_Result RMH_Log_GetAPILevel(const RMH_Handle handle, uint32_t* response),
6236 
6237 /* API Name */
6238 RMH_Log_GetAPILevel,
6239 
6240 /* Description */
6241 "Return a bitmask of <RMH_LogLevel> which indicates the currently enabled RMH log types in the RMH library. Note, this "
6242 "API is for log messages from RMH libraries only. The log level of the lower level MoCA driver should be read with "
6243 "<RMH_Log_GetDriverLevel>.",
6244 
6245 /* Parameters */
6246 PARAMETERS(
6247  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6248  OUTPUT_PARAM(response, uint32_t*, "The RMH API log level")
6249 ),
6250 
6251 /* Wrap API */
6252 TRUE,
6253 
6254 /* Tags */
6255 "Log"
6256 /********************************************************************************************************************/
6257 )
6258 
6259 
6260 
6261 RMH_API_IMPLEMENTATION_GENERIC_THEN_SOC(
6262 /********************************************************************************************************************/
6263 /* API Declaration */
6264 RMH_Result RMH_Log_SetAPILevel(const RMH_Handle handle, const uint32_t value),
6265 
6266 /* API Name */
6267 RMH_Log_SetAPILevel,
6268 
6269 /* Description */
6270 "Set the log level of the RMH library. This is set as a bitmask of <RMH_LogLevel> indicating the RMH log types to "
6271 "enable in the RMH libraries. Note, this API is for log messages from RMH libraries only. The log level of the lower "
6272 "level MoCA driver should be set with <RMH_Log_SetDriverLevel>.",
6273 
6274 /* Parameters */
6275 PARAMETERS(
6276  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6277  INPUT_PARAM(value, const uint32_t, "The desired RMH API log level")
6278 ),
6279 
6280 /* Wrap API */
6281 TRUE,
6282 
6283 /* Tags */
6284 "Log"
6285 /********************************************************************************************************************/
6286 )
6287 
6288 
6289 
6290 RMH_API_IMPLEMENTATION_SOC_ONLY(
6291 /********************************************************************************************************************/
6292 /* API Declaration */
6293 RMH_Result RMH_Log_GetDriverLevel(const RMH_Handle handle, RMH_LogLevel* response),
6294 
6295 /* API Name */
6296 RMH_Log_GetDriverLevel,
6297 
6298 /* Description */
6299 "Return a bitmask of <RMH_LogLevel> which indicates the currently enabled RMH log types in the MoCA driver. Note, this "
6300 "API is for log messages from SoC MoCA driver only. The log level of the RMH library should be read with "
6301 "<RMH_Log_GetAPILevel>.",
6302 
6303 /* Parameters */
6304 PARAMETERS(
6305  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6306  OUTPUT_PARAM(response, RMH_LogLevel*, "The SoC MoCA Driver log level")
6307 ),
6308 
6309 /* Wrap API */
6310 TRUE,
6311 
6312 /* Tags */
6313 "Log"
6314 /********************************************************************************************************************/
6315 )
6316 
6317 
6318 
6319 RMH_API_IMPLEMENTATION_SOC_ONLY(
6320 /********************************************************************************************************************/
6321 /* API Declaration */
6322 RMH_Result RMH_Log_SetDriverLevel(const RMH_Handle handle, const RMH_LogLevel value),
6323 
6324 /* API Name */
6325 RMH_Log_SetDriverLevel,
6326 
6327 /* Description */
6328 "Set the log level of the MoCA driver. This is set as a bitmask of <RMH_LogLevel> indicating the RMH log types to "
6329 "enable at the driver. Note, this API is for log messages from SoC MoCA driver only. The log level of the RMH "
6330 "libraries should be set with <RMH_Log_SetAPILevel>.",
6331 
6332 /* Parameters */
6333 PARAMETERS(
6334  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6335  INPUT_PARAM(value, const RMH_LogLevel, "The desired SoC MoCA Driver log level")
6336 ),
6337 
6338 /* Wrap API */
6339 TRUE,
6340 
6341 /* Tags */
6342 "Log"
6343 /********************************************************************************************************************/
6344 )
6345 
6346 
6347 
6348 RMH_API_IMPLEMENTATION_SOC_ONLY(
6349 /********************************************************************************************************************/
6350 /* API Declaration */
6351 RMH_Result RMH_Log_GetDriverFilename(const RMH_Handle handle, char* responseBuf, const size_t responseBufSize),
6352 
6353 /* API Name */
6354 RMH_Log_GetDriverFilename,
6355 
6356 /* Description */
6357 "Get the file name where MoCA driver logs are currently being captured.",
6358 
6359 /* Parameters */
6360 PARAMETERS(
6361  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6362  OUTPUT_PARAM(responseBuf, char*, "A buffer where the filename will be written"),
6363  INPUT_PARAM(responseBufSize, const size_t, "The size in bytes of the buffer <responseBuf>")
6364 ),
6365 
6366 /* Wrap API */
6367 TRUE,
6368 
6369 /* Tags */
6370 "Log"
6371 /********************************************************************************************************************/
6372 )
6373 
6374 
6375 
6376 RMH_API_IMPLEMENTATION_SOC_ONLY(
6377 /********************************************************************************************************************/
6378 /* API Declaration */
6379 RMH_Result RMH_Log_SetDriverFilename(const RMH_Handle handle, const char* value),
6380 
6381 /* API Name */
6382 RMH_Log_SetDriverFilename,
6383 
6384 /* Description */
6385 "Set the file name where MoCA driver logs should be captured to. If logs are already being captured to a file this "
6386 "capture will stop at that location and begin in this file. If the new log file already exists new logs will append "
6387 "to it.",
6388 
6389 /* Parameters */
6390 PARAMETERS(
6391  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6392  INPUT_PARAM(value, const char*, "A file name where logs should be written.")
6393 ),
6394 
6395 /* Wrap API */
6396 TRUE,
6397 
6398 /* Tags */
6399 "Log"
6400 /********************************************************************************************************************/
6401 )
6402 
6403 
6404 
6405 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
6406 /********************************************************************************************************************/
6407 /* API Declaration */
6408 RMH_Result RMH_Log_CreateDriverFile(const RMH_Handle handle, char* responseBuf, const size_t responseBufSize),
6409 
6410 /* API Name */
6411 RMH_Log_CreateDriverFile,
6412 
6413 /* Description */
6414 "Create a new log file in standard RDK formate. This will:\n"
6415 "\t1. Locate the file at a writable location in the rootfs.\n"
6416 "\t2. Name the file using a RDK standard naming convention.\n"
6417 "\t3. Put any necessary static information at the beginning of the file.\n"
6418 "\t This includes build details and other useful information.",
6419 
6420 /* Parameters */
6421 PARAMETERS(
6422  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize. NULL is valid for this API."),
6423  INPUT_PARAM(responseBuf, char *, "The file name "),
6424  INPUT_PARAM(responseBufSize, const size_t, "The size in bytes of the buffer <responseBuf>")
6425 ),
6426 
6427 /* Wrap API */
6428 TRUE,
6429 
6430 /* Tags */
6431 "log"
6432 /********************************************************************************************************************/
6433 )
6434 
6435 
6436 
6437 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
6438 /********************************************************************************************************************/
6439 /* API Declaration */
6440 RMH_Result RMH_Log_PrintStatus(const RMH_Handle handle, const char* filename),
6441 
6442 /* API Name */
6443 RMH_Log_PrintStatus,
6444 
6445 /* Description */
6446 "Print a generic status summary of the MoCA device and network. If <filename> is NULL all log messages are printed "
6447 "with RMH_LOG_MESSAGE. If it is not NULL the status will be appended to that file",
6448 
6449 /* Parameters */
6450 PARAMETERS(
6451  INPUT_PARAM(handle, const RMH_Handle,
6452  "The RMH handle as returned by RMH_Initialize. NULL is valid for this API."),
6453  INPUT_PARAM(filename, const char *,
6454  "The file name where to write the status. If this is NULL the status will be written to RMH_LOG_MESSAGE")
6455 ),
6456 
6457 /* Wrap API */
6458 TRUE,
6459 
6460 /* Tags */
6461 "Status"
6462 /********************************************************************************************************************/
6463 )
6464 
6465 
6466 
6467 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
6468 /********************************************************************************************************************/
6469 /* API Declaration */
6470 RMH_Result RMH_Log_PrintStats(const RMH_Handle handle, const char* filename),
6471 
6472 /* API Name */
6473 RMH_Log_PrintStats,
6474 
6475 /* Description */
6476 "Print a summary of of the Tx/Rx MoCA stats. If <filename> is NULL all log messages are printed "
6477 "with RMH_LOG_MESSAGE. If it is not NULL the status will be appended to that file",
6478 
6479 /* Parameters */
6480 PARAMETERS(
6481  INPUT_PARAM(handle, const RMH_Handle,
6482  "The RMH handle as returned by RMH_Initialize. NULL is valid for this API."),
6483  INPUT_PARAM(filename, const char *,
6484  "The file name where to write the status. If this is NULL the status will be written to RMH_LOG_MESSAGE")
6485 ),
6486 
6487 /* Wrap API */
6488 TRUE,
6489 
6490 /* Tags */
6491 "Stats,Status"
6492 /********************************************************************************************************************/
6493 )
6494 
6495 
6496 
6497 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
6498 /********************************************************************************************************************/
6499 /* API Declaration */
6500 RMH_Result RMH_Log_PrintFlows(const RMH_Handle handle, const char* filename),
6501 
6502 /* API Name */
6503 RMH_Log_PrintFlows,
6504 
6505 /* Description */
6506 "Print a generic status summary of the MoCA flows. If <filename> is NULL all log messages are printed with "
6507 "RMH_LOG_MESSAGE with RMH_LOG_MESSAGE. If it is not NULL the status will be appended to that file",
6508 
6509 /* Parameters */
6510 PARAMETERS(
6511  INPUT_PARAM(handle, const RMH_Handle,
6512  "The RMH handle as returned by RMH_Initialize. NULL is valid for this API."),
6513  INPUT_PARAM(filename, const char *,
6514  "The file name where to write the status. If this is NULL the status will be written to RMH_LOG_MESSAGE")
6515 ),
6516 
6517 /* Wrap API */
6518 TRUE,
6519 
6520 /* Tags */
6521 "PQoS,Status"
6522 /********************************************************************************************************************/
6523 )
6524 
6525 
6526 
6527 RMH_API_IMPLEMENTATION_GENERIC_ONLY(
6528 /********************************************************************************************************************/
6529 /* API Declaration */
6530 RMH_Result RMH_Log_PrintModulation(const RMH_Handle handle, const char* filename),
6531 
6532 /* API Name */
6533 RMH_Log_PrintModulation,
6534 
6535 /* Description */
6536 "Print a summary of the sub carrier modulation bitloading information.",
6537 
6538 /* Parameters */
6539 PARAMETERS(
6540  INPUT_PARAM(handle, const RMH_Handle,
6541  "The RMH handle as returned by RMH_Initialize. NULL is valid for this API."),
6542  INPUT_PARAM(filename, const char *,
6543  "The file name where to write the status. If this is NULL the status will be written to RMH_LOG_MESSAGE")
6544 ),
6545 
6546 /* Wrap API */
6547 TRUE,
6548 
6549 /* Tags */
6550 "Status"
6551 /********************************************************************************************************************/
6552 )
6553 
6554 
6555 
6556 RMH_API_IMPLEMENTATION_SOC_ONLY(
6557 /********************************************************************************************************************/
6558 /* API Declaration */
6559 RMH_Result RMH_ACA_Request(const RMH_Handle handle, const uint32_t channelNum, const uint32_t sourceNodeId, const uint32_t destinationNodeMask, const RMH_ACAType type),
6560 
6561 /* API Name */
6562 RMH_ACA_Request,
6563 
6564 /* Description */
6565 "Instruct the driver to perform a new ACA operation [mocaIfAcaInitiate]. Returns RMH_SUCCESS if the ACA operation was started successfully. This call will fail if an ACA operation is already in progress.",
6566 
6567 /* Parameters */
6568 PARAMETERS(
6569  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6570  INPUT_PARAM(channelNum, const uint32_t, "The channel number to perform the ACA on [mocaIfAcaChannel]"),
6571  INPUT_PARAM(sourceNodeId, const uint32_t, "The Node ID of the source node for the ACA. [mocaIfAcaNodeID]"),
6572  INPUT_PARAM(destinationNodeMask, const uint32_t, "The bitmask of the destination nodes for the ACA [mocaIfAcaReportNodeMask]. To include a given node in the ACA use 'destinationNodeMask |= (1 << nodeId)"),
6573  INPUT_PARAM(type, const RMH_ACAType, "The type of ACA to perform, either EVM or Quiet. [mocaIfAcaType]")
6574 ),
6575 
6576 /* Wrap API */
6577 TRUE,
6578 
6579 /* Tags */
6580 "ACA"
6581 /********************************************************************************************************************/
6582 )
6583 
6584 
6585 
6586 RMH_API_IMPLEMENTATION_SOC_ONLY(
6587 /********************************************************************************************************************/
6588 /* API Declaration */
6589 RMH_Result RMH_ACA_GetChannel(const RMH_Handle handle, uint32_t* response),
6590 
6591 /* API Name */
6592 RMH_ACA_GetChannel,
6593 
6594 /* Description */
6595 "Return the channel number of the last requested ACA. [mocaIfAcaNodeID]",
6596 
6597 /* Parameters */
6598 PARAMETERS(
6599  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6600  OUTPUT_PARAM(response, uint32_t*, "The channel number of the last requested ACA. [mocaIfAcaNodeID]")
6601 ),
6602 
6603 /* Wrap API */
6604 TRUE,
6605 
6606 /* Tags */
6607 "ACA"
6608 /********************************************************************************************************************/
6609 )
6610 
6611 
6612 
6613 RMH_API_IMPLEMENTATION_SOC_ONLY(
6614 /********************************************************************************************************************/
6615 /* API Declaration */
6616 RMH_Result RMH_ACA_GetSourceNodeId(const RMH_Handle handle, uint32_t* response),
6617 
6618 /* API Name */
6619 RMH_ACA_GetSourceNodeId,
6620 
6621 /* Description */
6622 "Return the Node ID of the source node for the last requested ACA. [mocaIfAcaNodeID]",
6623 
6624 /* Parameters */
6625 PARAMETERS(
6626  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6627  OUTPUT_PARAM(response, uint32_t*, "The Node ID of the source node for the last requested ACA. [mocaIfAcaNodeID]")
6628 ),
6629 
6630 /* Wrap API */
6631 TRUE,
6632 
6633 /* Tags */
6634 "ACA"
6635 /********************************************************************************************************************/
6636 )
6637 
6638 
6639 
6640 RMH_API_IMPLEMENTATION_SOC_ONLY(
6641 /********************************************************************************************************************/
6642 /* API Declaration */
6643 RMH_Result RMH_ACA_GetDestinationNodeMask(const RMH_Handle handle, uint32_t* response),
6644 
6645 /* API Name */
6646 RMH_ACA_GetDestinationNodeMask,
6647 
6648 /* Description */
6649 "Return the bitmask of the destination nodes for the last requested ACA. [mocaIfAcaReportNodeMask]",
6650 
6651 /* Parameters */
6652 PARAMETERS(
6653  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6654  OUTPUT_PARAM(response, uint32_t*, "The bitmask of the destination nodes for the last requested ACA. [mocaIfAcaReportNodeMask]")
6655 ),
6656 
6657 /* Wrap API */
6658 TRUE,
6659 
6660 /* Tags */
6661 "ACA"
6662 /********************************************************************************************************************/
6663 )
6664 
6665 
6666 
6667 RMH_API_IMPLEMENTATION_SOC_ONLY(
6668 /********************************************************************************************************************/
6669 /* API Declaration */
6670 RMH_Result RMH_ACA_GetType(const RMH_Handle handle, RMH_ACAType* response),
6671 
6672 /* API Name */
6673 RMH_ACA_GetType,
6674 
6675 /* Description */
6676 "Return the type of the last requested ACA operation",
6677 
6678 /* Parameters */
6679 PARAMETERS(
6680  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6681  OUTPUT_PARAM(response, uint32_t*, "The type of the last requested ACA operation [mocaIfAcaType]")
6682 ),
6683 
6684 /* Wrap API */
6685 TRUE,
6686 
6687 /* Tags */
6688 "ACA"
6689 /********************************************************************************************************************/
6690 )
6691 
6692 
6693 
6694 RMH_API_IMPLEMENTATION_SOC_ONLY(
6695 /********************************************************************************************************************/
6696 /* API Declaration */
6697 RMH_Result RMH_ACA_GetStatus(const RMH_Handle handle, RMH_ACAStatus* response),
6698 
6699 /* API Name */
6700 RMH_ACA_GetStatus,
6701 
6702 /* Description */
6703 "Return the current status of the last requested ACA operation",
6704 
6705 /* Parameters */
6706 PARAMETERS(
6707  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6708  OUTPUT_PARAM(response, RMH_ACAStatus*, "The current status of the previously started ACA operation [mocaIfAcaStatus]")
6709 ),
6710 
6711 /* Wrap API */
6712 TRUE,
6713 
6714 /* Tags */
6715 "ACA"
6716 /********************************************************************************************************************/
6717 )
6718 
6719 
6720 
6721 RMH_API_IMPLEMENTATION_SOC_ONLY(
6722 /********************************************************************************************************************/
6723 /* API Declaration */
6724 RMH_Result RMH_ACA_GetTotalRxPower(const RMH_Handle handle, int32_t* response),
6725 
6726 /* API Name */
6727 RMH_ACA_GetTotalRxPower,
6728 
6729 /* Description */
6730 "Return the total power from the last completed ACA operation. This call will fail if an ACA operation is already in progress",
6731 
6732 /* Parameters */
6733 PARAMETERS(
6734  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6735  OUTPUT_PARAM(response, int32_t*, "The total power from the last completed ACA operation [mocaIfAcaTotalRxPower]")
6736 ),
6737 
6738 /* Wrap API */
6739 TRUE,
6740 
6741 /* Tags */
6742 "ACA"
6743 /********************************************************************************************************************/
6744 )
6745 
6746 
6747 
6748 RMH_API_IMPLEMENTATION_SOC_ONLY(
6749 /********************************************************************************************************************/
6750 /* API Declaration */
6751 RMH_Result RMH_ACA_GetPowerProfile(const RMH_Handle handle, uint8_t* responseArray, const size_t responseArraySize, size_t* responseArrayUsed),
6752 
6753 
6754 /* API Name */
6755 RMH_ACA_GetPowerProfile,
6756 
6757 /* Description */
6758 "Return the total power from the last completed ACA operation. This call will fail if an ACA operation already is in progress",
6759 
6760 /* Parameters */
6761 PARAMETERS(
6762  INPUT_PARAM(handle, const RMH_Handle, "The RMH handle as returned by RMH_Initialize"),
6763  INPUT_PARAM(responseArray, uint8_t*, "The ACA power profile. This is a binary string array with 1 byte for each subcarrier. [mocaIfAcaPowerProfile]"),
6764  INPUT_PARAM(responseArraySize, const size_t, "The size of <responseArray>"),
6765  OUTPUT_PARAM(responseArrayUsed, size_t*, "The number of entries in the response array which have valid data")
6766 ),
6767 
6768 /* Wrap API */
6769 TRUE,
6770 
6771 /* Tags */
6772 "ACA"
6773 /********************************************************************************************************************/
6774 )
6775 
6776 #ifdef DOX_MOCA
6777 /**
6778  * @addtogroup MOCAHAL_GENERIC_API
6779  * @{
6780  */
6781 
6782  /**
6783  * @brief Initialize the RMH library and return a handle to the instance.
6784  *
6785  * This handle will be used in all future communication with the RMH library.
6786  * This function will fail if the MoCA driver is not properly installed or is not able to operate.
6787  * Multiple simultaneous instances of RMH_Initialize are supported in single and multiprocess environments.
6788  *
6789  * @param[in] eventCB A pointer to a function which will handle any callbacks from the RMH MoCA library
6790  * A value of NULL is permitted if you do not wish to receive callbacks.
6791  * @param[in] userContext A pointer to some data that will be passed back with each callback.
6792  * A value of NULL is permitted if the client requires no context during callbacks.
6793  */
6794 RMH_Handle RMH_Initialize(const RMH_EventCallback eventCB, void * userContext);
6795 
6796 /**
6797  * @brief Destroy the instance of RMH library which was created by RMH_Initialize.
6798  *
6799  * @param[in] handle The RMH handle as returned by RMH_Initialize.
6800  */
6801 RMH_Result RMH_Destroy(RMH_Handle handle);
6802 
6803 /**
6804  * @brief Set the list of callbacks you wish to receive.
6805  *
6806  * For each callback a call will be made to eventCB which is provided in the call to RMH_Initialize.
6807  * By default all callbacks are disabled.
6808  * Any subsequent calls to this API will overwrite previous calls.
6809  * For example, if you originally set value to 'RMH_API_PRINT' and later set to LINK_STATUS_CHANGED | MOCA_VERSION_CHANGED'
6810  * you will stop receiving callbacks for 'RMH_API_PRINT'.
6811  *
6812  * @param[in] handle The RMH handle as returned by RMH_Initialize.
6813  * @param[in] value A bitmask list of RMH_Event indicating the callbacks to be received.
6814  */
6815 RMH_Result RMH_SetEventCallbacks(RMH_Handle handle, const uint32_t value);
6816 
6817 /**
6818  * @brief Get the list of events for which the client has registered.
6819  *
6820  * @param[in] handle The RMH handle as returned by RMH_Initialize.
6821  * @param[out] response A bitmask list of RMH_Event indicating the currently enabled callbacks.
6822  */
6823 RMH_Result RMH_GetEventCallbacks(RMH_Handle handle, uint32_t* response);
6824 
6825 /**
6826  * @brief Return a list of all APIs which are part of RMH.
6827  *
6828  * @param[in] handle The RMH handle as returned by RMH_Initialize. NULL is valid for this API.
6829  * @param[out] apiList Output list of APIs.
6830  */
6831 RMH_Result RMH_GetAllAPIs(const RMH_Handle handle, RMH_APIList** apiList);
6832 
6833 /**
6834  * @brief Return a list of all RMH APIs which are unimplemented by the SoC library.
6835  *
6836  * @param[in] handle The RMH handle as returned by RMH_Initialize. NULL is valid for this API.
6837  * @param[out] apiList Output list of APIs.
6838  */
6839 RMH_Result RMH_GetUnimplementedAPIs(const RMH_Handle handle, RMH_APIList** apiList);
6840 
6841 /**
6842  * @brief Return the list of all RMH APIs grouped into lists by their tags.
6843  *
6844  * @param[in] handle The RMH handle as returned by RMH_Initialize. NULL is valid for this API.
6845  * @param[out] apiTags Output list of Tags and APIs which belong to them.
6846  */
6847 RMH_Result RMH_GetAPITags(const RMH_Handle handle, RMH_APITagList** apiTags);
6848 
6849 /**
6850  * @brief Convert RMH_Result to a string.
6851  *
6852  * @param[in] value Value to be printed as a string.
6853  */
6854 const char* const RMH_ResultToString(const RMH_Result value);
6855 
6856 /**
6857  * @brief Convert RMH_LinkStatus to a string.
6858  *
6859  * @param[in] value Value to be printed as a string.
6860  */
6861 const char* const RMH_LinkStatusToString(const RMH_LinkStatus value);
6862 
6863 /**
6864  * @brief Convert RMH_AdmissionStatus to a string.
6865  *
6866  * @param[in] value Value to be printed as a string.
6867  */
6868 const char* const RMH_AdmissionStatusToString(const RMH_AdmissionStatus value);
6869 
6870 /**
6871  * @brief Convert RMH_MoCAResetReason to a string.
6872  *
6873  * @param[in] value Value to be printed as a string.
6874  */
6875 const char* const RMH_MoCAResetReasonToString(const RMH_MoCAResetReason value);
6876 
6877 /**
6878  * @brief Convert RMH_SubcarrierProfile to a string.
6879  *
6880  * @param[in] value Value to be printed as a string.
6881  */
6882 const char* const RMH_SubcarrierProfileToString(const RMH_SubcarrierProfile value);
6883 
6884 /**
6885  * @brief Convert RMH_PERMode to a string.
6886  *
6887  * @param[in] value Value to be printed as a string.
6888  */
6889 const char* const RMH_PERModeToString(const RMH_PERMode value);
6890 
6891 /**
6892  * @brief Convert RMH_MoCAVersion to a string.
6893  *
6894  * @param[in] value Value to be printed as a string.
6895  */
6896 const char* const RMH_MoCAVersionToString(const RMH_MoCAVersion value);
6897 
6898 /**
6899  * @brief The input value should be a a bitmask of type RMH_PowerMode.
6900  *
6901  * This will be converted to a printable string.
6902  *
6903  * @param[in] value A bitmask of RMH_PowerMode to be printed as a string.
6904  * @param[out] responseBuf A buffer where the log level string will be written.
6905  * @param[in] responseBufSize The size in bytes of the buffer <responseBuf>.
6906  */
6907 const char* const RMH_PowerModeToString(const uint32_t value, char* responseBuf, const size_t responseBufSize);
6908 
6909 /**
6910  * @brief Convert value to a printable string.
6911  *
6912  * @param[in] value Value to be printed as a string.
6913  */
6914 const char* const RMH_BandToString(const RMH_Band value);
6915 
6916 /**
6917  * @brief Return the bitmask value as a string.
6918  *
6919  * The bitmask is expected to contain one or more of RMH_LogLevel.
6920  *
6921  * @param[in] value A bitmask of RMH_LogLevel to be printed as a string.
6922  * @param[out] responseBuf A buffer where the log level string will be written.
6923  * @param[in] responseBufSize The size in bytes of the buffer responseBuf.
6924  */
6925 const char* const RMH_LogLevelToString(const uint32_t value, char* responseBuf, const size_t responseBufSize);
6926 
6927 /**
6928  * @brief Return the bitmask value as a string.
6929  *
6930  * The bitmask is expected to contain one or more of RMH_Event.
6931  *
6932  * @param[in] value A bitmask of RMH_LogLevel to be printed as a string.
6933  * @param[out] responseBuf A buffer where the log level string will be written.
6934  * @param[in] responseBufSize The size in bytes of the buffer responseBuf.
6935  *
6936  */
6937 const char* const RMH_EventToString(const uint32_t value, char* responseBuf, const size_t responseBufSize);
6938 
6939 /**
6940  * @brief Returns the provided MAC address in value as a string.
6941  *
6942  * @param[in] value A byte array MAC address.
6943  * @param[out] responseBuf A buffer where the MAC string will be written.
6944  * @param[in] responseBufSize The size in bytes of the buffer responseBuf.
6945  *
6946  */
6947 const char* const RMH_MacToString(const RMH_MacAddress_t value, char* responseBuf, const size_t responseBufSize);
6948 
6949 /**
6950  * @brief Convert value to a printable string.
6951  *
6952  * @param[in] value A byte array MAC address.
6953  * @param[out] responseBuf A buffer where the MAC string will be written.
6954  * @param[in] responseBufSize The size in bytes of the buffer <responseBuf>.
6955  *
6956  */
6957 const char* const RMH_ACATypeToString(const RMH_ACAType value);
6958 
6959 /**
6960  * @brief Convert ACA status to a printable string.
6961  *
6962  * @param[in] value Value to be printed as a string.
6963  *
6964  */
6965 const char* const RMH_ACAStatusToString(const RMH_ACAStatus value);
6966 
6967 /**
6968  * @brief Check if the MoCA interface is enabled at the kernel level.
6969  *
6970  * Do not confuse with RMH_Self_GetEnabled which checks if the MoCA driver is active.
6971  *
6972  * @param[in] handle The RMH handle as returned by RMH_Initialize.
6973  * @param[out] response Set to true if the MoCA interface is enabled at the kernel level. Otherwise set to false.
6974  */
6975 RMH_Result RMH_Interface_GetEnabled(const RMH_Handle handle, bool *response);
6976 
6977 /**
6978  * @brief Set MoCA interface enabled or disabled at the kernel level.
6979  *
6980  * Do not confuse with RMH_Self_SetEnabled which checks if the MoCA driver is active.
6981  *
6982  * @param[in] handle The RMH handle as returned by RMH_Initialize.
6983  * @param[out] response Set to true if the MoCA interface is enabled at the kernel level. Otherwise set to false.
6984  */
6985 RMH_Result RMH_Interface_SetEnabled(const RMH_Handle handle, const bool value);
6986 
6987 /**
6988  * @brief Enable MoCA using RDK specific configuration.
6989  *
6990  * @param[in] handle The RMH handle as returned by RMH_Initialize.
6991  */
6992 RMH_Result RMH_Self_SetEnabledRDK(const RMH_Handle handle);
6993 
6994 /**
6995  * @brief Current operational status of the MoCA interface [mocaIfStatus].
6996  *
6997  * This API combines all known information about the MoCA device, including the driver, MoCA link, interface status, etc
6998  * to determine if the link is functional.
6999  * RMH_LINK_STATUS_UP indicates MoCA is ready for use.
7000  *
7001  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7002  * @param[out] status The current link state of MoCA.
7003  */
7004 RMH_Result RMH_Self_GetLinkStatus(const RMH_Handle handle, RMH_LinkStatus* status);
7005 
7006 /**
7007  * @brief Return a list of the associated ID for every node on the network.
7008  *
7009  * This is a one-based index of every remote node on the network.
7010  * The self node is not included in this list.
7011  *
7012  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7013  * @param[out] response The index is the node Id, if nodePresent is 'true', nodeValue is the associated Id for that node.
7014  */
7015 RMH_Result RMH_Network_GetAssociatedIds(const RMH_Handle handle, RMH_NodeList_Uint32_t* response);
7016 
7017 /**
7018  * @brief Convert an associated Id into a Node Id.
7019  *
7020  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7021  * @param[in] associatedId The associated Id of the node.
7022  * @param[out] response The node Id.
7023  *
7024  */
7025 RMH_Result RMH_RemoteNode_GetNodeIdFromAssociatedId(const RMH_Handle handle, const uint32_t associatedId, uint32_t* response);
7026 
7027 /**
7028  * @brief Convert a node Id into an associated Id.
7029  *
7030  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7031  * @param[in] nodeId The node Id of the remote node to inspect.
7032  * @param[out] response The associated Id of the node.
7033  *
7034  */
7035 RMH_Result RMH_RemoteNode_GetAssociatedIdFromNodeId(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
7036 
7037 /**
7038  * @brief Return the node Id with the maximum available bandwidth.
7039  *
7040  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7041  * @param[out] response The node Id with the maximum egress bandwidth.
7042  *
7043  */
7044 RMH_Result RMH_PQoS_GetMaxEgressBandwidth(const RMH_Handle handle, uint32_t* response);
7045 
7046 /**
7047  * @brief Create a new log file in standard RDK format.
7048  *
7049  * This will:
7050  * -# Locate the file at a writable location in the rootfs.
7051  * -# Name the file using a RDK standard naming convention.
7052  * -# Put any necessary static information at the beginning of the file.
7053  * -# This includes build details and other useful information.
7054  *
7055  * @param[in] handle The RMH handle as returned by RMH_Initialize. NULL is valid for this API.
7056  * @param[in] responseBuf The file name.
7057  * @param[in] responseBufSize The size in bytes of the buffer responseBuf.
7058  *
7059  * @note This API is for log messages from SoC MoCA driver only.
7060  * The log level of the RMH libraries should be set with RMH_Log_SetAPILevel.
7061  */
7062 RMH_Result RMH_Log_CreateDriverFile(const RMH_Handle handle, char* responseBuf, const size_t responseBufSize);
7063 
7064 /**
7065  * @brief Print a summary of of the Tx/Rx MoCA status.
7066  *
7067  * If filename is NULL all log messages are printed with RMH_LOG_MESSAGE.
7068  * If it is not NULL the status will be appended to that file.
7069  *
7070  * @param[in] handle The RMH handle as returned by RMH_Initialize. NULL is valid for this API.
7071  * @param[in] filename The file name where to write the status.
7072  * If this is NULL the status will be written to RMH_LOG_MESSAGE.
7073  */
7074 RMH_Result RMH_Log_PrintStats(const RMH_Handle handle, const char* filename);
7075 
7076 /**
7077  * @brief Print a generic status summary of the MoCA flows.
7078  *
7079  * If filename is NULL all log messages are printed with RMH_LOG_MESSAGE with RMH_LOG_MESSAGE.
7080  * If it is not NULL the status will be appended to that file.
7081  *
7082  * @param[in] handle The RMH handle as returned by RMH_Initialize. NULL is valid for this API.
7083  * @param[in] filename The file name where to write the status.
7084  * If this is NULL the status will be written to RMH_LOG_MESSAGE.
7085  */
7086 RMH_Result RMH_Log_PrintFlows(const RMH_Handle handle, const char* filename);
7087 
7088 /**
7089  * @brief Print a summary of the sub carrier modulation bitloading information.
7090  *
7091  * @param[in] handle The RMH handle as returned by RMH_Initialize. NULL is valid for this API.
7092  * @param[in] filename The file name where to write the status.
7093  * If this is NULL the status will be written to RMH_LOG_MESSAGE.
7094  */
7095 RMH_Result RMH_Log_PrintModulation(const RMH_Handle handle, const char* filename);
7096 
7097 
7098 /** @} */ //End of doxygen tag MOCAHAL_GENERIC_API
7099 
7100 
7101 /**
7102  * @addtogroup MOCAHAL_SOC_API
7103  * @{
7104  */
7105 /**
7106  * @brief Return if the MoCA driver is actively connected to or attempting to connect to a MoCA network.
7107  *
7108  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7109  * @param[in] response Set to 'true' if the MoCA driver is active. Otherwise set to 'false'.
7110  *
7111  */
7112 RMH_Result RMH_Self_GetEnabled(const RMH_Handle handle, bool* response);
7113 
7114 /**
7115  * @brief Enable or disable the MoCA driver to connect to a MoCA network.
7116  * Once enabled the driver will use whatever parameters it has been configured for.
7117  *
7118  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7119  * @param[in] value Pass 'true' to enable the MoCA driver. Otherwise pass to 'false'.
7120  *
7121  */
7122 RMH_Result RMH_Self_SetEnabled(const RMH_Handle handle, const bool value);
7123 
7124 /**
7125  * @brief Check if this device is actively connected to a MoCA network.
7126  * If so, RMH_Network and RMH_Remote APIs will then be valid to call.
7127  *
7128  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7129  * @param[in] response Set to 'true' if this is device is actively connected to a MoCA Network.
7130  *
7131  */
7132 RMH_Result RMH_Self_GetMoCALinkUp(const RMH_Handle handle, bool* response);
7133 
7134 /**
7135  * @brief The last frequency on which this device operated.
7136  *
7137  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7138  * @param[in] response The last operating frequency of the device.
7139  *
7140  */
7141 RMH_Result RMH_Self_GetLOF(const RMH_Handle handle, uint32_t* response);
7142 
7143 /**
7144  * @brief Manually set the last operating frequency of the device.
7145  *
7146  * This can be helpful to control what frequency is used for future network connections.
7147  *
7148  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7149  * @param[in] value The desired last operating frequency of the device.
7150  *
7151  */
7152 RMH_Result RMH_Self_SetLOF(const RMH_Handle handle, const uint32_t value);
7153 
7154 /**
7155  * @brief Return if the device is scanning only the last operating frequency when attempting to establish a
7156  * connection to a MoCA network.
7157  *
7158  * This can be helpful to control what frequency is used for future network connections.
7159  *
7160  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7161  * @param[out] response Set to 'true' if only the LOF is being checked when joining a MoCA network.
7162  * Otherwise set to 'false'.
7163  *
7164  */
7165 RMH_Result RMH_Self_GetScanLOFOnly(const RMH_Handle handle, bool* response);
7166 
7167 /**
7168  * @brief Indicate if the device should join networks only on the last operating frequency.
7169  *
7170  * This is helpful to control the exact frequency used for MoCA.
7171  *
7172  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7173  * @param[out] response Pass 'true' to ensure this node will only join a network at the LOF.
7174  * Otherwise pass to 'false'.
7175  *
7176  */
7177 RMH_Result RMH_Self_SetScanLOFOnly(const RMH_Handle handle, const bool value);
7178 
7179 /**
7180  * @brief Return if this device is a preferred NC.
7181  *
7182  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7183  * @param[out] response Set to 'true' if the device is a preferred NC. Otherwise set to 'false'.
7184  *
7185  */
7186 RMH_Result RMH_Self_GetPreferredNCEnabled(const RMH_Handle handle, bool* response);
7187 
7188 /**
7189  * @brief Enable or disable preferred NC on this device.
7190  *
7191  * If this is enabled the device has a greater chance of becoming the NC, if set disable the chance of becoming the NC is reduced.
7192  * However, please keep in mind that depending on your network configuration, a device with preferred NC disabled could still
7193  * become the NC.
7194  *
7195  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7196  * @param[out] value Pass 'true' to enable this device as a preferred NC. Otherwise pass to 'false'.
7197  *
7198  * @note Setting this value may trigger a restart of the MoCA driver and cause the device to temporarily leave the network.
7199  *
7200  */
7201 RMH_Result RMH_Self_SetPreferredNCEnabled(const RMH_Handle handle, const bool value);
7202 
7203 /**
7204  * @brief TBD [mocaIfPrimaryChannelOffset]
7205  *
7206  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7207  * @param[out] response TBD.
7208  *
7209  */
7210 
7211 RMH_Result RMH_Self_GetPrimaryChannelOffset(const RMH_Handle handle, int32_t* response);
7212 
7213 /**
7214  * @brief TBD [mocaIfSecondaryChannelOffset]
7215  *
7216  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7217  * @param[in] value TBD.
7218  */
7219 RMH_Result RMH_Self_SetPrimaryChannelOffset(const RMH_Handle handle, const int32_t value);
7220 
7221 /**
7222  * @brief TBD [mocaIfSecondaryChannelOffset]
7223  *
7224  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7225  * @param[in] value TBD.
7226  *
7227  */
7228 RMH_Result RMH_Self_GetSecondaryChannelOffset(const RMH_Handle handle, int32_t* response);
7229 
7230 /**
7231  * @brief TBD [mocaIfSecondaryChannelOffset]
7232  *
7233  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7234  * @param[in] value TBD.
7235  *
7236  */
7237 RMH_Result RMH_Self_SetSecondaryChannelOffset(const RMH_Handle handle, const int32_t value);
7238 
7239 /**
7240  * @brief Return the version of software being used by the MoCA driver on this device. [mocaIfSoftwareVersion]
7241  *
7242  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7243  * @param[out] responseBuf A buffer where the software version string will be written.
7244  * @param[in] responseBufSize The size in bytes of the buffer <responseBuf>.
7245  *
7246  */
7247 RMH_Result RMH_Self_GetSoftwareVersion(const RMH_Handle handle, char* responseBuf, const size_t responseBufSize);
7248 
7249 /**
7250  * @brief Return the highest version of MoCA supported by the MoCA driver on this device. [mocaIfMocaVersion].
7251  *
7252  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7253  * @param[out] response The highest version of MoCA supported.
7254  *
7255  */
7256 RMH_Result RMH_Self_GetHighestSupportedMoCAVersion(const RMH_Handle handle, RMH_MoCAVersion* response);
7257 
7258 /**
7259  * @brief Gets the bit mask of frequencies the device used during the listening phase of network search.
7260  *
7261  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7262  * @param[out] response The bitmask of frequencies this device will use when joining a network.
7263  *
7264  */
7265 RMH_Result RMH_Self_GetFrequencyMask(const RMH_Handle handle, uint32_t* response);
7266 
7267 /**
7268  * @brief Set the bit mask for specifying which frequencies should be scanned during the listening phase of network search.
7269  *
7270  * Depending on the RF band of operation, the MSB of this parameter corresponds to the lowest frequency channel of the band.
7271  * Each subsequent bit of this parameter represents the next highest 25MHz channel.
7272  * The base channels for each RF band are as follows:
7273  * - Band D-Low : 46 (1150 MHz)
7274  * - Band D-High: 56 (1400 MHz)
7275  * - Band Ext-D : 46 (1150 MHz)
7276  * - Band C4 : 40 (1000 MHz)
7277  * - Band E : 20 ( 500 MHz)
7278  * - Band F : 27 ( 675 MHz)
7279  * - Band H : 39 ( 975 MHz)
7280  *
7281  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7282  * @param[in] value The bitmask of frequencies this device should use when joining a network.
7283  *
7284  */
7285 RMH_Result RMH_Self_SetFrequencyMask(const RMH_Handle handle, const uint32_t value);
7286 
7287 /**
7288  * @brief Get the maximum number of packets this device will aggregate.
7289  *
7290  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7291  * @param[in] response The maximum number of packets this device will aggregate.
7292  *
7293  */
7294 
7295 RMH_Result RMH_Self_GetMaxPacketAggregation(const RMH_Handle handle, uint32_t* response);
7296 
7297 /**
7298  * @brief Set the maximum allowed packets for aggregated transmissions.
7299  *
7300  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7301  * @param[in] value The maximum number of packets this device can aggregate.
7302  *
7303  */
7304 RMH_Result RMH_Self_SetMaxPacketAggregation(const RMH_Handle handle, const uint32_t value);
7305 
7306 /**
7307  * @brief The maximum number of bytes this node can receive in one frame.
7308  *
7309  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7310  * @param[out] response The maximum number of packets this device can aggregate.
7311  *
7312  */
7313 RMH_Result RMH_Self_GetMaxFrameSize(const RMH_Handle handle, uint32_t* response);
7314 
7315 /**
7316  * @brief Set the maximum number of bytes this node can receive in one frame (aggregated transmission).
7317  *
7318  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7319  * @param[in] value The maximum number of packets this device can aggregate.
7320  *
7321  */
7322 RMH_Result RMH_Self_SetMaxFrameSize(const RMH_Handle handle, const uint32_t value);
7323 
7324 /**
7325  * @brief Get the current lower limit for PHY rate between two nodes.
7326  *
7327  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7328  * @param[out] response The lower PHY limit.
7329  *
7330  */
7331 RMH_Result RMH_Self_GetLowBandwidthLimit(const RMH_Handle handle, uint32_t* response);
7332 
7333 /**
7334  * @brief Set the lower threshold for the PHY link bandwidth between two nodes.
7335  *
7336  * If the rate falls below this limit a callback of type <RMH_EVENT_LOW_BANDWIDTH> will be triggered.
7337  *
7338  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7339  * @param[in] value The new value to use as the lower PHY limit.
7340  *
7341  */
7342 RMH_Result RMH_Self_SetLowBandwidthLimit(const RMH_Handle handle, const uint32_t value);
7343 
7344 /**
7345  * @brief The maximum PHY rate supported in non-turbo mode.
7346  *
7347  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7348  * @param[in] response The maximum PHY rate.
7349  *
7350  */
7351 RMH_Result RMH_Self_GetMaxBitrate(const RMH_Handle handle, uint32_t* response);
7352 
7353 /**
7354  * @brief Set the maximum transmitter power level for this device.
7355  *
7356  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7357  * @param[in] value Desired transmitter power level. Minimum value -31, maximum value 3.
7358  *
7359  * @note Setting this value may trigger a restart of the MoCA driver and cause the device to temporarily leave the network.
7360  *
7361  */
7362 RMH_Result RMH_Self_SetTxPowerLimit(const RMH_Handle handle, const int32_t value);
7363 
7364 /**
7365  * @brief Returns the maximum transmitter power level for this device.
7366  *
7367  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7368  * @param[in] value The maximum transmission power for this device.
7369  *
7370  */
7371 RMH_Result RMH_Self_GetTxPowerLimit(const RMH_Handle handle, int32_t* response);
7372 
7373 /**
7374  * @brief Return a list of frequencies in the band used by this node.
7375  *
7376  * This frequency list does not account for taboo channels or other filters which would limit the scope of frequencies
7377  * this device would use to join a network. [mocaIfChannelSupport].
7378  *
7379  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7380  * @param[out] responseArray An array where the frequency list should be stored.
7381  * @param[in] responseArraySize The size of the response array.
7382  * @param[out] responseArrayUsed The number of entries in the response array which have valid data.
7383  *
7384  */
7385 RMH_Result RMH_Self_GetSupportedFrequencies(const RMH_Handle handle, uint32_t* responseArray, const size_t responseArraySize, size_t* responseArrayUsed);
7386 
7387 /**
7388  * @brief Return the band supported by the MoCA device. [mocaIfSupportedBands].
7389  *
7390  * - RMH_BAND_C4 [MoCA 1.1]: 1000
7391  * - RMH_BAND_D [MoCA 1.1]: 1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500
7392  * - RMH_BAND_D_LOW: 1125, 1150, 1175, 1200, 1225
7393  * - RMH_BAND_D_HIGH: 1350, 1375, 1400, 1425, 1450, 1475, 1500, 1525, 1550, 1575, 1600, 1625
7394  * - RMH_BAND_D_EX: 1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500
7395  * - RMH_BAND_E: 500, 525, 550, 575, 600
7396  * - RMH_BAND_F: 675, 700, 725, 750, 775, 800, 825, 850
7397  * - RMH_BAND_H: 975, 1000, 1025
7398  *
7399  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7400  * @param[out] response The band supported by this MoCA device.
7401  *
7402  */
7403 RMH_Result RMH_Self_GetSupportedBand(const RMH_Handle handle, RMH_Band* response);
7404 
7405 /**
7406  * @brief Return if this device is set as QAM256 capable in admission negotiations.
7407  *
7408  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7409  * @param[out] response Set to 'true' if QAM256 support is enabled. Otherwise set to 'false'.
7410  *
7411  */
7412 RMH_Result RMH_Self_GetQAM256Enabled(const RMH_Handle handle, bool* response);
7413 
7414 /**
7415  * @brief Enable or disable the QAM256 ability in admission negotiations.
7416  *
7417  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7418  * @param[in] value Pass 'true' to enable QAM256 support on this device. Otherwise pass to 'false'.
7419  *
7420  * @note Setting this value may trigger a restart of the MoCA driver and cause the device to temporarily leave the network.
7421  *
7422  */
7423 RMH_Result RMH_Self_SetQAM256Enabled(const RMH_Handle handle, const bool value);
7424 
7425 /**
7426  * @brief Get the target PHY rate in Mbps.
7427  *
7428  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7429  * @param[out] response The target PHY rate in Mbps.
7430  *
7431  */
7432 RMH_Result RMH_Self_GetQAM256TargetPhyRate(const RMH_Handle handle, uint32_t* response);
7433 
7434 /**
7435  * @brief Set the target PHY rate in Mbps.
7436  *
7437  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7438  * @param[in] value The target PHY rate in Mbps.
7439  *
7440  * @note Setting this value may trigger a restart of the MoCA driver and cause the device to temporarily leave the network.
7441  *
7442  */
7443 RMH_Result RMH_Self_SetQAM256TargetPhyRate(const RMH_Handle handle, const uint32_t value);
7444 
7445 /**
7446  * @brief Return if turbo mode is enabled on this device.
7447  *
7448  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7449  * @param[out] response Set to true if turbo is enabled. Otherwise set to false.
7450  *
7451  */
7452 RMH_Result RMH_Self_GetTurboEnabled(const RMH_Handle handle, bool* response);
7453 
7454 /**
7455  * @brief Enable or disable turbo mode on this device.
7456  *
7457  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7458  * @param[in] value Pass 'true' to enable turbo on this device. Otherwise pass to 'false'.
7459  *
7460  */
7461 RMH_Result RMH_Self_SetTurboEnabled(const RMH_Handle handle, const bool value);
7462 
7463 /**
7464  * @brief Return if bonding mode is enabled on this device.
7465  *
7466  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7467  * @param[in] response Set to 'true' if bonding is enabled. Otherwise set to 'false'.
7468  *
7469  */
7470 RMH_Result RMH_Self_GetBondingEnabled(const RMH_Handle handle, bool* response);
7471 
7472 /**
7473  * @brief Enable or disable bonding mode on this device.
7474  *
7475  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7476  * @param[in] value Pass 'true' to enable bonding on this device. Otherwise pass to 'false'.
7477  *
7478  */
7479 RMH_Result RMH_Self_SetBondingEnabled(const RMH_Handle handle, const bool value);
7480 
7481 
7482 /**
7483  * @brief Return if MoCA privacy is enabled on this device.
7484  *
7485  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7486  * @param[out] response Set to 'true' if MoCA privacy is enabled. Otherwise set to 'false'.
7487  */
7488 RMH_Result RMH_Self_GetPrivacyEnabled(const RMH_Handle handle, bool* response);
7489 
7490 /**
7491  * @brief Enable or disable MoCA privacy on this device.
7492  *
7493  * If enabled the device will only be permitted to join networks with other devices which have the same password.
7494  *
7495  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7496  * @param[out] value "Pass 'true' to enable MoCA privacy on this device. Otherwise pass to 'false'.
7497  */
7498 RMH_Result RMH_Self_SetPrivacyEnabled(const RMH_Handle handle, const bool value);
7499 
7500 /**
7501  * @brief Get the current MoCA privacy password.
7502  *
7503  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7504  * @param[out] responseBuf A buffer where the MoCA password will be written.
7505  * @param[in] responseBufSize The size in bytes of the buffer <responseBuf>.
7506  */
7507 RMH_Result RMH_Self_GetPrivacyPassword(const RMH_Handle handle, char* responseBuf, const size_t responseBufSize);
7508 
7509 /**
7510  * @brief Set the network password used to generate privacy keys.
7511  *
7512  * This string must be between 12 and 17 characters long with each character being a decimal number (0-9).
7513  *
7514  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7515  * @param[in] value The MoCA network password. Although this is a string only 0-9 are permitted.
7516  */
7517 RMH_Result RMH_Self_SetPrivacyPassword(const RMH_Handle handle, const char* value);
7518 
7519 /**
7520  * @brief Get the SHA1 hash of the MoCA password as an ASCII string. [mocaIfPasswordHash].
7521  *
7522  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7523  * @param[out] responseBuf A buffer where the MoCA managment key will be written.
7524  * @param[in] responseBufSize The size in bytes of the buffer responseBuf.
7525  */
7526 RMH_Result RMH_Self_GetPrivacyMACManagementKey(RMH_Handle handle, char* responseBuf, const size_t responseBufSize);
7527 
7528 /**
7529  * @brief Return if the RDK specific inter-frame gap of 10us is enabled on this device.
7530  *
7531  * This should be enabled on all MoCA 2.0 devices that would become the NC to ensure endure compatibility
7532  * with all RDK vendors.
7533  *
7534  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7535  * @param[out] response Set to 'true' if RDK IFG of 10us is enabled. Otherwise set to 'false'.
7536  */
7537 RMH_Result RMH_Self_GetRDKInteroperabilityIFGEnabled(const RMH_Handle handle, bool* response);
7538 
7539 /**
7540  * @brief Enable or disable the RDK specific inter-frame gap of 10us.
7541  *
7542  * This setting is needed by all MoCA 2.0 devices that would become the NC to ensure endure compatibility with all RDK vendors.
7543  *
7544  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7545  * @param[in] value Pass true to enable RDK IFG of 10us. Otherwise pass to false.
7546  */
7547 RMH_Result RMH_Self_SetRDKInteroperabilityIFGEnabled(const RMH_Handle handle, const bool value);
7548 
7549 /**
7550  * @brief Return which channels will be taboo on this device.
7551  *
7552  * channelMaskStart will indicate the channel number of the lowest RF frequency covered by channel mask.
7553  * The bitmask channelMask is then used to identify exactly which frequencies are taboo.
7554  * Each consecutive bit of channelMask corresponds to channels offset by multiples of 25MHz.
7555  * A bit in channelMask will be set to '1' if that channel is taboo.
7556  *
7557  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7558  * @param[in] channelMaskStart The channel number of the lowest frequency which is taboo.
7559  * @param[in] channelMask A bitmask of channels which are taboo.
7560  * The first bit corresponds to the frequency of channelMaskStart.
7561  */
7562 RMH_Result RMH_Self_GetTabooChannels(const RMH_Handle handle, uint32_t *channelMaskStart, uint32_t *channelMask);
7563 
7564 /**
7565  * @brief Set which channels will be taboo on this device.
7566  *
7567  * channelMaskStart will indicate the channel number of the lowest RF frequency covered by channel mask.
7568  * The bitmask channelMask is then used to identify exactly which frequencies are taboo.
7569  * Each consecutive bit of channelMask corresponds to channels offset by multiples of 25MHz.
7570  * A bit in channelMask must be set to 1 if that channel is taboo.
7571  *
7572  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7573  * @param[in] channelMaskStart The channel number of the lowest frequency which is taboo.
7574  * @param[in] channelMask A bitmask of channels which are taboo.
7575  * The first bit corresponds to the frequency of channelMaskStart.
7576  */
7577 RMH_Result RMH_Self_SetTabooChannels(const RMH_Handle handle, const uint32_t channelMaskStart, const uint32_t channelMask);
7578 
7579 /**
7580  * @brief Return this device to its default configuration.
7581  *
7582  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7583  */
7584 RMH_Result RMH_Self_RestoreDefaultSettings(const RMH_Handle handle);
7585 
7586 /**
7587  * @brief Return the maximum number of allocation elements, excluding the TAUs and the Dummy DAUs,
7588  * in one MAP the Node can process [mocaIfAeNumber].
7589  *
7590  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7591  * @param[out] response Maximum number of allocation elements.
7592  */
7593 
7594 RMH_Result RMH_Self_GetMaxAllocationElements(const RMH_Handle handle, uint32_t* response);
7595 
7596 /**
7597  * @brief Return the reason for the most recent link reset [mocaIfResetReason].
7598  *
7599  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7600  * @param[out] response The reason for the most recent link reset.
7601  */
7602 RMH_Result RMH_Self_GetLastResetReason(const RMH_Handle handle, RMH_MoCAResetReason* response);
7603 
7604 /**
7605  * @brief Return the Linux interface name associated with the MoCA device. [mocaIfName]
7606  *
7607  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7608  * @param[out] responseBuf A buffer where the interface name will be written.
7609  * @param[in] responseBufSize The size in bytes of the buffer responseBuf.
7610  */
7611 RMH_Result RMH_Interface_GetName(const RMH_Handle handle, char* responseBuf, const size_t responseBufSize);
7612 
7613 /**
7614  * @brief Return the MAC address associated with this MoCA device. [mocaIfMacAddress].
7615  *
7616  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7617  * @param[out] response The MAC address as a byte array.
7618  */
7619 RMH_Result RMH_Interface_GetMac(const RMH_Handle handle, RMH_MacAddress_t* response);
7620 
7621 /**
7622  * @brief Set the MAC address associated with this MoCA device.
7623  *
7624  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7625  * @param[in] value The desired MAC address as a byte array.
7626  */
7627 RMH_Result RMH_Interface_SetMac(const RMH_Handle handle, const RMH_MacAddress_t value);
7628 
7629 /**
7630  * @brief Return the current MoCA power state of this device.
7631  *
7632  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7633  * @param[out] response The current power mode of this device.
7634  */
7635 RMH_Result RMH_Power_GetMode(const RMH_Handle handle, RMH_PowerMode* response);
7636 
7637 /**
7638  * @brief Return a bitmask of RMH_PowerMode indicating all MoCA power modes supported by this device mocaIfPowerStateCap.
7639  *
7640  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7641  * @param[out] response A bitmask of RMH_PowerMode listing supported modes.
7642  */
7643 RMH_Result RMH_Power_GetSupportedModes(const RMH_Handle handle, uint32_t* response);
7644 
7645 /**
7646  * @brief Return if transmit power control is enabled or disabled for this device.
7647  *
7648  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7649  * @param[out] response Set to 'true' if transmission power control is enabled. Otherwise set to 'false'.
7650  */
7651 RMH_Result RMH_Power_GetTxPowerControlEnabled(const RMH_Handle handle, bool* response);
7652 
7653 /**
7654  * @brief Enable or disable if transmit power control is enabled for this device.
7655  *
7656  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7657  * @param[in] value Pass 'true' to enable transmission power control on this device. Otherwise pass to 'false'.
7658  */
7659 RMH_Result RMH_Power_SetTxPowerControlEnabled(const RMH_Handle handle, const bool value);
7660 
7661 /**
7662  * @brief Return if beacon power reduction is enabled on this device.
7663  *
7664  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7665  * @param[out] response Set to 'true' if beacon power reduction is enabled. Otherwise set to 'false'.
7666  */
7667 RMH_Result RMH_Power_GetTxBeaconPowerReductionEnabled(const RMH_Handle handle, bool* response);
7668 
7669 /**
7670  * @brief Enable or disable if beacon power reduction on this device.
7671  *
7672  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7673  * @param[in] value Pass true to enable beacon power control on this device. Otherwise pass to false.
7674  */
7675 RMH_Result RMH_Power_SetTxBeaconPowerReductionEnabled(const RMH_Handle handle, const bool value);
7676 
7677 /**
7678  * @brief Return the power control back-off used by this node for transmitting beacons.
7679  *
7680  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7681  * @param[out] response Beacon power reduction.
7682  */
7683 RMH_Result RMH_Power_GetTxBeaconPowerReduction(const RMH_Handle handle, uint32_t* response);
7684 
7685 /**
7686  * @brief Set the power control back-off used by this node for transmitting beacons.
7687  *
7688  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7689  * @param[in] value Beacon power reduction. Minimum value 0, Maximum value 5.
7690  */
7691 
7692 RMH_Result RMH_Power_SetTxBeaconPowerReduction(const RMH_Handle handle, const uint32_t value);
7693 
7694 /**
7695  * @brief Return the number of MoCA nodes in the network. [mocaIfNumNodes].
7696  *
7697  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7698  * @param[out] response Number of MoCA nodes in the network.
7699  */
7700 RMH_Result RMH_Network_GetNumNodes(const RMH_Handle handle, uint32_t* response);
7701 
7702 /**
7703  * @brief Return the node ID of this device.
7704  *
7705  * [mocaIfNodeID] This is a zero based ID which uniquely identifies this node on the network.
7706  *
7707  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7708  * @param[out] response The device's node ID.
7709  */
7710 
7711 RMH_Result RMH_Network_GetNodeId(const RMH_Handle handle, uint32_t* response);
7712 
7713 /**
7714  * @brief Return a list of every node ID on the network.
7715  *
7716  * This differs from RMH_Network_GetRemoteNodeIds as this API includes the self node.
7717  *
7718  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7719  * @param[out] response The index is the node Id, if nodePresent is 'true', nodeValue is the node Id.
7720  */
7721 RMH_Result RMH_Network_GetNodeIds(const RMH_Handle handle, RMH_NodeList_Uint32_t* response);
7722 
7723 
7724 /**
7725  * @brief Return a list of every node ID on the network.
7726  *
7727  * This differs from RMH_Network_GetNodeIds as this API does not include the self node.
7728  *
7729  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7730  * @param[out] response The index is the node Id, if nodePresent is 'true', nodeValue is the node Id.
7731  */
7732 RMH_Result RMH_Network_GetRemoteNodeIds(const RMH_Handle handle, RMH_NodeList_Uint32_t* response);
7733 
7734 /**
7735  * @brief Return the node ID of the network coordinator. [mocaIfNC]
7736  *
7737  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7738  * @param[out] response The network coordinator node Id.
7739  */
7740 RMH_Result RMH_Network_GetNCNodeId(const RMH_Handle handle, uint32_t* response);
7741 
7742 /**
7743  * @brief Return the node ID of the backup network coordinator [mocaIfBackupNC].
7744  *
7745  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7746  * @param[out] response The backup network coordinator node Id.
7747  */
7748 RMH_Result RMH_Network_GetBackupNCNodeId(const RMH_Handle handle, uint32_t* response);
7749 
7750 /**
7751  * @brief Return the MAC address of the network coordinator.
7752  *
7753  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7754  * @param[out] response The MAC address of the network coordinator.
7755  */
7756 RMH_Result RMH_Network_GetNCMac(const RMH_Handle handle, RMH_MacAddress_t* response);
7757 
7758 /**
7759  * @brief Returns the amount of time this node has been part of the MoCA network [mocaIfLinkUpTime].
7760  *
7761  * Time is in seconds.
7762  *
7763  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7764  * @param[out] response Number of seconds this node has been in the network.
7765  */
7766 RMH_Result RMH_Network_GetLinkUptime(const RMH_Handle handle, uint32_t* response);
7767 
7768 /**
7769  * @brief Returns the number of times the MoCA link has gone down since the last boot. [mocaIfResetCount]
7770  *
7771  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7772  * @param[out] response Number of seconds this node has been in the network.
7773  */
7774 RMH_Result RMH_Network_GetResetCount(const RMH_Handle handle, uint32_t* response);
7775 
7776 /**
7777  * @brief Returns the number of times the MoCA link has gone down since the last boot [mocaIfLinkDownCount].
7778  *
7779  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7780  * @param[out] response Number of seconds this node has been in the network.
7781  */
7782 RMH_Result RMH_Network_GetLinkDownCount(const RMH_Handle handle, uint32_t* response);
7783 
7784 /**
7785  * @brief Check if the MoCA network contains both 1.1 and 2.0 nodes.
7786  *
7787  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7788  * @param[out] response Set to true if both 1.1 and 2.0 nodes are present in the network. Otherwise set to false.
7789  */
7790 
7791 RMH_Result RMH_Network_GetMixedMode(const RMH_Handle handle, bool* response);
7792 
7793 /**
7794  * @brief Return the frequency which the MoCA network is operating on. [mocaIfRFChannel]
7795  *
7796  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7797  * @param[out] response The frequency of the MoCA network.
7798  */
7799 RMH_Result RMH_Network_GetRFChannelFreq(const RMH_Handle handle, uint32_t* response);
7800 
7801 /**
7802  * @brief Return the primary MoCA 2.0 channel.
7803  *
7804  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7805  * @param[out] response The primary MoCA 2.0 channel.
7806  */
7807 RMH_Result RMH_Network_GetPrimaryChannelFreq(const RMH_Handle handle, uint32_t* response);
7808 
7809 /**
7810  * @brief Return the secondary MoCA 2.0 channel.
7811  *
7812  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7813  * @param[out] response The secondary MoCA 2.0 channel.
7814  */
7815 RMH_Result RMH_Network_GetSecondaryChannelFreq(const RMH_Handle handle, uint32_t* response);
7816 
7817 /**
7818  * @brief Return the version of MoCA under which the network is operating. [mocaIfNetworkVersion]
7819  *
7820  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7821  * @param[out] response The MoCA version of the network.
7822  */
7823 RMH_Result RMH_Network_GetMoCAVersion(const RMH_Handle handle, RMH_MoCAVersion* response);
7824 
7825 /**
7826  * @brief Return the PHY rate at which broadcast packets are transmitted from this node.
7827  *
7828  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7829  * @param[out] response The broadcast transmission PHY rate.
7830  */
7831 RMH_Result RMH_Network_GetTxBroadcastPhyRate(const RMH_Handle handle, uint32_t* response);
7832 
7833 /**
7834  * @brief Return the GCD PHY rate which packets are transmitted from this node.
7835  *
7836  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7837  * @param[out] response The GCD transmission PHY rate.
7838  */
7839 RMH_Result RMH_Network_GetTxGCDPhyRate(const RMH_Handle handle, uint32_t* response);
7840 
7841 /**
7842  * @brief Return the PHY rate at which MAP packets are transmitted from this node.
7843  *
7844  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7845  * @param[out] response The MAP transmission PHY rate.
7846  */
7847 RMH_Result RMH_Network_GetTxMapPhyRate(const RMH_Handle handle, uint32_t* response);
7848 
7849 /**
7850  * @brief The transmit power control back-off used for broadcast transmissions from this node. [mocaIfTxGcdPowerReduction]
7851  *
7852  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7853  * @param[out] response Transmit power control reduction. Minimum value 0, Maximum value 35.
7854  */
7855 RMH_Result RMH_Network_GetTxGcdPowerReduction(const RMH_Handle handle, uint32_t* response);
7856 
7857 /**
7858  * @brief Return which beacon channels will be taboo on this device.
7859  *
7860  * channelMaskStart will indicate the channel number of the lowest.
7861  * RF frequency covered by channel mask.
7862  * The bitmask channelMask is then used to identify exactly which frequencies.
7863  *
7864  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7865  * @param[in] channelMaskStart The channel number of the lowest frequency which is taboo.
7866  * @param[in] channelMask A bitmask of channels which are taboo.
7867  * The first bit corresponds to the frequency of channelMaskStart.
7868  */
7869 RMH_Result RMH_Network_GetTabooChannels(const RMH_Handle handle, uint32_t *channelMaskStart, uint32_t *channelMask);
7870 
7871 /**
7872  * @brief Return the unicast transmit PHY rates between all nodes on the network.
7873  *
7874  * The resulting matrix will be in RMH_NodeMesh_Uint32_t Where the index is the node Id
7875  * If nodePresent is 'true', then nodeValue is a list of the unicast PHY rates from this
7876  * node Id to every other node on the network.
7877  *
7878  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7879  * @param[out] response A bitmask of channels which are taboo.
7880  * The first bit corresponds to the frequency of channelMaskStart.
7881  */
7882 RMH_Result RMH_Network_GetTxUnicastPhyRate(const RMH_Handle handle, RMH_NodeMesh_Uint32_t* response);
7883 
7884 /**
7885  * @brief Return the transmit VLPER (Very Low Packet Error Rate) PHY rates between all MoCA 2.0 nodes on the network.
7886  *
7887  * The resulting matrix will be in RMH_NodeMesh_Uint32_t Where the index is the node Id.
7888  * if nodePresent is 'true'then <nodeValue> is a list of the unicast PHY rates from this node Id
7889  * to every other node on the network.
7890  *
7891  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7892  * @param[out] response A bitmask of channels which are taboo.
7893  * The first bit corresponds to the frequency of channelMaskStart.
7894  *
7895  * @note MoCA 1.1 nodes will have nodePresent set to 'true', however they nodeValue will be 0.
7896  */
7897 RMH_Result RMH_Network_GetTxVLPER(const RMH_Handle handle, RMH_NodeMesh_Uint32_t* response);
7898 
7899 /**
7900  * @brief Return the transmit NPER (Nominal Packet Error Rate) PHY rates *from* all MoCA 2.0 nodes on the network.
7901  *
7902  * The resulting matrix will be in RMH_NodeMesh_Uint32_t Where the index is the node Id.
7903  * if nodePresent is 'true'then nodeValue is a list of the unicast PHY rates from this node Id
7904  * to every other node on the network.
7905  *
7906  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7907  * @param[out] response The PHY rate mesh table.
7908  *
7909  * @note MoCA 1.1 nodes will have nodePresent set to 'true', however they nodeValue will be 0.
7910  */
7911 RMH_Result RMH_Network_GetTxNPER(const RMH_Handle handle, RMH_NodeMesh_Uint32_t* response);
7912 
7913 /**
7914  * @brief Returns the bit loading information.
7915  *
7916  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7917  * @param[out] response The resulting bitloading information.
7918  *
7919  */
7920 RMH_Result RMH_Network_GetBitLoadingInfo(const RMH_Handle handle, RMH_NodeMesh_Uint32_t* response);
7921 
7922 /**
7923  * @brief Return the MAC address of the remote node specified by nodeId
7924  *
7925  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7926  * @param[in] nodeId The node Id of the remote node to inspect.
7927  * @param[out] response The MAC address of the remote node as a byte array.
7928  *
7929  */
7930 RMH_Result RMH_RemoteNode_GetMac(const RMH_Handle handle, const uint32_t nodeId, RMH_MacAddress_t* response);
7931 
7932 /**
7933  * @brief Return if the node indicated by nodeId is a preferred NC or not.
7934  *
7935  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7936  * @param[in] nodeId The node Id of the remote node to inspect.
7937  * @param[out] response Returns True, if the remote node is a preferred NC. False otherwise.
7938  *
7939  */
7940 RMH_Result RMH_RemoteNode_GetPreferredNC(const RMH_Handle handle, const uint32_t nodeId, bool* response);
7941 
7942 /**
7943  * @brief Return the highest supported version of MoCA by the remote node specified by nodeId.
7944  *
7945  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7946  * @param[in] nodeId The node Id of the remote node to inspect.
7947  * @param[out] response The highest version of MoCA supported.
7948  *
7949  */
7950 RMH_Result RMH_RemoteNode_GetHighestSupportedMoCAVersion(const RMH_Handle handle, const uint32_t nodeId, RMH_MoCAVersion* response);
7951 
7952 /**
7953  * @brief Return the active supported version of MoCA by the remote node specificed by nodeId.
7954  *
7955  * There are cases where devices that support MoCA 2.0 may be actively using MoCA 1.1 .
7956  * For example, when the NC is a MoCA 1.1 node.
7957  *
7958  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7959  * @param[in] nodeId The node Id of the remote node to inspect.
7960  * @param[out] response The active version of MoCA on the remote node.
7961  *
7962  */
7963 RMH_Result RMH_RemoteNode_GetActiveMoCAVersion(const RMH_Handle handle, const uint32_t nodeId, RMH_MoCAVersion* response);
7964 
7965 /**
7966  * @brief Return if the node indicated by nodeId has QAM256 enabled or not.
7967  *
7968  * There are cases where devices that support MoCA 2.0 may be actively using MoCA 1.1 .
7969  * For example, when the NC is a MoCA 1.1 node.
7970  *
7971  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7972  * @param[in] nodeId The node Id of the remote node to inspect.
7973  * @param[out] response Set to true if the remote node is a QAM256 capable. Otherwise set to false.
7974  *
7975  */
7976 RMH_Result RMH_RemoteNode_GetQAM256Capable(const RMH_Handle handle, const uint32_t nodeId, bool* response);
7977 
7978 /**
7979  * @brief Return the maximum number of packets for aggregated transmissions for the node indicated by nodeId.
7980  *
7981  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7982  * @param[in] nodeId The node Id of the remote node to inspect.
7983  * @param[out] response The maximum number of packets nodeId will aggregate.
7984  *
7985  */
7986 RMH_Result RMH_RemoteNode_GetMaxPacketAggregation(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
7987 
7988 /**
7989  * @brief The maximum number of bytes this node can receive in one frame (aggregated transmission).
7990  *
7991  * @param[in] handle The RMH handle as returned by RMH_Initialize.
7992  * @param[in] nodeId The node Id of the remote node to inspect.
7993  * @param[out] response The maximum number of packets this device will aggregate.
7994  *
7995  */
7996 RMH_Result RMH_RemoteNode_GetMaxFrameSize(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
7997 
7998 /**
7999  * @brief Return if the node indicated by nodeId is bonding capable enabled or not.
8000  *
8001  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8002  * @param[in] nodeId The node Id of the remote node to inspect.
8003  * @param[out] response Set to true if the remote node supports bonding. Otherwise set to false.
8004  *
8005  */
8006 RMH_Result RMH_RemoteNode_GetBondingCapable(const RMH_Handle handle, const uint32_t nodeId, bool* response);
8007 
8008 /**
8009  * @brief Return the PHY rate at which unicast packets are received from nodeId of the self node.
8010  *
8011  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8012  * @param[in] nodeId The node Id of the remote node to inspect.
8013  * @param[out] response The unicast receive PHY rate.
8014  *
8015  */
8016 RMH_Result RMH_RemoteNode_GetRxUnicastPhyRate(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
8017 
8018 /**
8019  * @brief Return the PHY rate at which broadcast packets are received from nodeId.
8020  *
8021  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8022  * @param[in] nodeId The node Id of the remote node to inspect.
8023  * @param[out] response The broadcast receive PHY rate.
8024  *
8025  */
8026 RMH_Result RMH_RemoteNode_GetRxBroadcastPhyRate(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
8027 
8028 /**
8029  * @brief Return the power level at which broadcast packets are received from nodeId.
8030  *
8031  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8032  * @param[in] nodeId The node Id of the remote node to inspect.
8033  * @param[out] response The broadcast receive power level.
8034  *
8035  */
8036 RMH_Result RMH_RemoteNode_GetRxBroadcastPower(const RMH_Handle handle, const uint32_t nodeId, float* response);
8037 
8038 /**
8039  * @brief Return the power level at which unicast packets are received from nodeId from the self node.
8040  *
8041  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8042  * @param[in] nodeId The node Id of the remote node to inspect.
8043  * @param[out] response The unicast receive power level.
8044  *
8045  */
8046 RMH_Result RMH_RemoteNode_GetRxUnicastPower(const RMH_Handle handle, const uint32_t nodeId, float* response);
8047 
8048 /**
8049  * @brief Return the power level at which MAP packets are received by nodeId.
8050  *
8051  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8052  * @param[in] nodeId The node Id of the remote node to inspect.
8053  * @param[out] response The MAP receive power level rate.
8054  *
8055  */
8056 RMH_Result RMH_RemoteNode_GetRxMapPower(const RMH_Handle handle, const uint32_t nodeId, float* response);
8057 
8058 /**
8059  * @brief Return the number of packets nodeId has received.
8060  *
8061  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8062  * @param[in] nodeId The node Id of the remote node to inspect.
8063  * @param[out] response Number of packets received by nodeId.
8064  *
8065  */
8066 RMH_Result RMH_RemoteNode_GetRxPackets(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
8067 
8068 /**
8069  * @brief The signal to noise ratio of nodeId based on the Type 1 probe from per node.
8070  *
8071  * Measured in dB.
8072  *
8073  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8074  * @param[in] nodeId The node Id of the remote node to inspect.
8075  * @param[out] response The SNR of nodeId.
8076  *
8077  */
8078 RMH_Result RMH_RemoteNode_GetRxSNR(const RMH_Handle handle, const uint32_t nodeId, float* response);
8079 
8080 /**
8081  * @brief Return the number of packets with corrected errors nodeId has received.
8082  *
8083  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8084  * @param[in] nodeId The node Id of the remote node to inspect.
8085  * @param[out] response The number of corrected packets with errors.
8086  *
8087  */
8088 RMH_Result RMH_RemoteNode_GetRxCorrectedErrors(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
8089 
8090 /**
8091  * @brief Return the number of packets with uncorrected errors <nodeId> has received.
8092  *
8093  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8094  * @param[in] nodeId The node Id of the remote node to inspect.
8095  * @param[out] response The number of corrected packets with errors.
8096  *
8097  */
8098 RMH_Result RMH_RemoteNode_GetRxUnCorrectedErrors(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
8099 
8100 /**
8101  * @brief Return the total number of packets with errors nodeId has received.
8102  *
8103  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8104  * @param[in] nodeId The node Id of the remote node to inspect.
8105  * @param[out] response The number of total number of packets with errors.
8106  *
8107  */
8108 RMH_Result RMH_RemoteNode_GetRxTotalErrors(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
8109 
8110 /**
8111  * @brief Return the PHY rate at which unicast packets are transmitted from nodeId to the self node.
8112  *
8113  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8114  * @param[in] nodeId The node Id of the remote node to inspect.
8115  * @param[out] response The unicast transmission PHY rate.
8116  *
8117  */
8118 RMH_Result RMH_RemoteNode_GetTxUnicastPhyRate(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
8119 
8120 /**
8121  * @brief Return the power level rate at which unicast packets are transmitted from nodeId to the self node.
8122  *
8123  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8124  * @param[in] nodeId The node Id of the remote node to inspect.
8125  * @param[out] response The unicast transmission power level rate.
8126  *
8127  */
8128 RMH_Result RMH_RemoteNode_GetTxUnicastPower(const RMH_Handle handle, const uint32_t nodeId, float* response);
8129 
8130 /**
8131  * @brief The transmit power control back-off used for transmissions from the specified nodeId.
8132  *
8133  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8134  * @param[in] nodeId The node Id of the remote node to inspect.
8135  * @param[out] response The transmission power reduction of nodeId.
8136  *
8137  */
8138 RMH_Result RMH_RemoteNode_GetTxPowerReduction(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
8139 
8140 /**
8141  * @brief Return the total number of packets nodeId has transmitted.
8142  *
8143  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8144  * @param[in] nodeId The node Id of the remote node to inspect.
8145  * @param[out] response The total number of packets transmitted by nodeId.
8146  *
8147  */
8148 RMH_Result RMH_RemoteNode_GetTxPackets(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
8149 
8150 /**
8151  * @brief Instruct one or more nodes to initiate a MoCA Reset command.
8152  *
8153  * This will result in the specfied nodes dropping from the network and then rejoining.
8154  *
8155  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8156  * @param[in] nodeListMask A bitmask of nodes to be reset [mocaIfMrNodeMask].
8157  * For example, to reset a given node use 'nodeListMask |= (1 << nodeId)'")
8158  *
8159  * @param[in] startTime The time in seconds to start the reset command [mocaIfMrStartTime].
8160  *
8161  */
8162 RMH_Result RMH_RemoteNode_Reset(const RMH_Handle handle, const uint32_t nodeListMask, const uint32_t startTime);
8163 
8164 /**
8165  * @brief Return the unicast recieve subcarrier modulation profiles for the primary MoCA channel.
8166  *
8167  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8168  * @param[in] nodeId The node Id of the remote node to inspect.
8169  * @param[in] perMode The PER Mode to check.This parameter will be ignored for MoCA devices older than 2.0.
8170  * @param[out] responseArray An array where the sub carrier modulation should be stored.
8171  * @param[in] responseArraySize The size of the response array.
8172  * @param[out] responseArrayUsed The number of entries in the response array which have valid data.
8173  *
8174  */
8175 RMH_Result RMH_RemoteNode_GetRxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed);
8176 
8177 /**
8178  * @brief Return the unicast transmit subcarrier modulation profiles for the primary MoCA channel.
8179  *
8180  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8181  * @param[in] nodeId The node Id of the remote node to inspect.
8182  * @param[in] perMode The PER Mode to check.This parameter will be ignored for MoCA devices older than 2.0.
8183  * @param[out] responseArray An array where the sub carrier modulation should be stored.
8184  * @param[in] responseArraySize The size of the response array.
8185  * @param[out] responseArrayUsed The number of entries in the response array which have valid data.
8186  *
8187  */
8188 RMH_Result RMH_RemoteNode_GetTxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed);
8189 
8190 /**
8191  * @brief Return the unicast recieve subcarrier modulation profiles for the secondary MoCA channel.
8192  *
8193  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8194  * @param[in] nodeId The node Id of the remote node to inspect.
8195  * @param[in] perMode The PER Mode to check.This parameter will be ignored for MoCA devices older than 2.0.
8196  * @param[out] responseArray An array where the sub carrier modulation should be stored.
8197  * @param[in] responseArraySize The size of the response array.
8198  * @param[out] responseArrayUsed The number of entries in the response array which have valid data.
8199  *
8200  */
8201 RMH_Result RMH_RemoteNode_GetSecondaryRxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed);
8202 
8203 /**
8204  * @brief Return the unicast transmit subcarrier modulation profiles for the secondary MoCA channel.
8205  *
8206  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8207  * @param[in] nodeId The node Id of the remote node to inspect.
8208  * @param[in] perMode The PER Mode to check.This parameter will be ignored for MoCA devices older than 2.0.
8209  * @param[out] responseArray An array where the sub carrier modulation should be stored.
8210  * @param[in] responseArraySize The size of the response array.
8211  * @param[out] responseArrayUsed The number of entries in the response array which have valid data.
8212  *
8213  */
8214 RMH_Result RMH_RemoteNode_GetSecondaryTxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed);
8215 
8216 /**
8217  * @brief Return the receive broadcast subcarrier modulation profiles for the channel.
8218  *
8219  * In the case of a MoCA 1.1 connection this will return the SubcarrierModulation.
8220  *
8221  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8222  * @param[in] nodeId The node Id of the remote node to inspect.
8223  * @param[in] perMode The PER Mode to check.This parameter will be ignored for MoCA devices older than 2.0.
8224  * @param[out] responseArray An array where the sub carrier modulation should be stored.
8225  * @param[in] responseArraySize The size of the response array.
8226  * @param[out] responseArrayUsed The number of entries in the response array which have valid data.
8227  *
8228  */
8229 RMH_Result RMH_RemoteNode_GetRxBroadcastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed);
8230 
8231 /**
8232  * @brief Return the transmission broadcast subcarrier modulation profiles for the channel.
8233  *
8234  * In the case of a MoCA 1.1 connection this will return the SubcarrierModulation.
8235  *
8236  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8237  * @param[in] nodeId The node Id of the remote node to inspect.
8238  * @param[in] perMode The PER Mode to check.This parameter will be ignored for MoCA devices older than 2.0.
8239  * @param[out] responseArray An array where the sub carrier modulation should be stored.
8240  * @param[in] responseArraySize The size of the response array.
8241  * @param[out] responseArrayUsed The number of entries in the response array which have valid data.
8242  *
8243  */
8244 RMH_Result RMH_RemoteNode_GetTxBroadcastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile* responseArray, const size_t responseArraySize, size_t* responseArrayUsed);
8245 
8246 /**
8247  * @brief Return the maximum number of supported Ingress PQoS Flows by the Node [mocaIfSupportedIngressPqosFlows].
8248  *
8249  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8250  * @param[out] response Maximum number of supported Ingress PQoS Flows by the Node.
8251  *
8252  */
8253 RMH_Result RMH_PQOS_GetMaxIngressFlows(const RMH_Handle handle, uint32_t* response);
8254 
8255 /**
8256  * @brief Return the maximum number of supported Egress PQoS Flows by the Node [mocaIfSupportedEgressPqosFlows].
8257  *
8258  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8259  * @param[out] response Maximum number of supported Egress PQoS Flows by the Node.
8260  *
8261  */
8262 RMH_Result RMH_PQOS_GetMaxEgressFlows(const RMH_Handle handle, uint32_t* response);
8263 
8264 /**
8265  * @brief Return the number of ingress flows.
8266  *
8267  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8268  * @param[out] response The number of ingress flows.
8269  *
8270  */
8271 RMH_Result RMH_PQoS_GetNumIngressFlows(const RMH_Handle handle, uint32_t* response);
8272 
8273 /**
8274  * @brief Return the number of egress flows.
8275  *
8276  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8277  * @param[out] response The number of egress flows.
8278  *
8279  */
8280 RMH_Result RMH_PQoS_GetNumEgressFlows(const RMH_Handle handle, uint32_t* response);
8281 
8282 /**
8283  * @brief Return the amount of egress bandwidth available on a particular node.
8284  *
8285  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8286  * @param[in] nodeId The node Id of the remote node to inspect.
8287  * @param[out] response The available egress bandwidth.
8288  *
8289  */
8290 RMH_Result RMH_PQoS_GetEgressBandwidth(const RMH_Handle handle, const uint32_t nodeId, uint32_t* response);
8291 
8292 /**
8293  * @brief Return a list of the unique Id for each existing ingress flows.
8294  *
8295  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8296  * @param[out] responseArray An array where the flow unique Ids should be returned.
8297  * @param[in] responseArraySize The size of the response array.
8298  * @param[out] responseArrayUsed The number of entries in the response array which have valid data.
8299  *
8300  */
8301 RMH_Result RMH_PQoS_GetIngressFlowIds(const RMH_Handle handle, RMH_MacAddress_t* responseArray, const size_t responseArraySize, size_t* responseArrayUsed);
8302 
8303 /**
8304  * @brief Return the peak data rate in Kbps for the flow specified by flowId.
8305  *
8306  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8307  * @param[in] flowId The unique flow identifier.
8308  * @param[out] response The peak data rate in Kbps.
8309  *
8310  */
8311 RMH_Result RMH_PQoSFlow_GetPeakDataRate(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8312 
8313 /**
8314  * @brief Return the number of packets per burst for the flow specified by flowId.
8315  *
8316  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8317  * @param[in] flowId The unique flow identifier.
8318  * @param[out] response The packets per burst.
8319  *
8320  */
8321 RMH_Result RMH_PQoSFlow_GetBurstSize(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8322 
8323 /**
8324  * @brief Return the lease time in seconds for the flow specified by flowId.
8325  *
8326  * Zero indicates an infinite lease time.
8327  *
8328  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8329  * @param[in] flowId The unique flow identifier.
8330  * @param[out] response The lease time in seconds.
8331  *
8332  */
8333 RMH_Result RMH_PQoSFlow_GetLeaseTime(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8334 
8335 /**
8336  * @brief Return the lease time remaining in seconds for the flow specified by flowId.
8337  *
8338  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8339  * @param[in] flowId The unique flow identifier.
8340  * @param[out] response The lease time remaining in seconds.
8341  *
8342  */
8343 RMH_Result RMH_PQoSFlow_GetLeaseTimeRemaining(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8344 
8345 /**
8346  * @brief Return the tag for the flow specified by flowId. This is optional for application use.
8347  *
8348  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8349  * @param[in] flowId The unique flow identifier.
8350  * @param[out] response The flow tag.
8351  *
8352  */
8353 RMH_Result RMH_PQoSFlow_GetFlowTag(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8354 
8355 /**
8356  * @brief Return the maximum latency of the flow specified by flowId.
8357  *
8358  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8359  * @param[in] flowId The unique flow identifier.
8360  * @param[out] response The maximum latency.
8361  *
8362  */
8363 RMH_Result RMH_PQoSFlow_GetMaxLatency(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8364 
8365 /**
8366  * @brief Return the short term average ratio for the flow specified by flowId.
8367  *
8368  * This is the ratio of the short term average rate of the flow compared to the peak rate
8369  * over the interval of RMH_PQoSFlow_GetMaxLatency.
8370  * This value plus one serves as the numerator of the ratio.
8371  * The denominator is 256.
8372  * This value is only applicable when the maximun latency value is greater than or equal to 10 ms.
8373  *
8374  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8375  * @param[in] flowId The unique flow identifier.
8376  * @param[out] response The short term average ratio.
8377  *
8378  */
8379 RMH_Result RMH_PQoSFlow_GetShortTermAvgRatio(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8380 
8381 /**
8382  * @brief Return the maximum number of retransmission attempts for each MSDU of the flow specified by flowId.
8383  *
8384  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8385  * @param[in] flowId The unique flow identifier.
8386  * @param[out] response The maximum retransmission attempts.
8387  *
8388  */
8389 RMH_Result RMH_PQoSFlow_GetMaxRetry(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8390 
8391 /**
8392  * @brief Return the VLAN priority for the flow specified by flowId.
8393  *
8394  * This is used for MSDU classification when RMH_PQoSFlow_GetIngressClassificationRule is 6 or 7.
8395  *
8396  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8397  * @param[in] flowId The unique flow identifier.
8398  * @param[out] response The VLAN tag.
8399  *
8400  */
8401 RMH_Result RMH_PQoSFlow_GetVLANTag(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8402 
8403 /**
8404  * @brief Return the flow packet error ratio profile for the flow specified by flowId.
8405  *
8406  * This is to specify whether the flow should use the nominal packet error rate (PER) PHY profile
8407  * or the Very Low PER PHY profile.
8408  *
8409  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8410  * @param[in] flowId The unique flow identifier.
8411  * @param[out] response The flow PER profile.
8412  *
8413  */
8414 RMH_Result RMH_PQoSFlow_GetFlowPer(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8415 
8416 /**
8417  * @brief Return the ingress classification rule for assigning MSDUs to the flow specified by flowId.
8418  *
8419  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8420  * @param[in] flowId The unique flow identifier.
8421  * @param[out] response The ingress classification rule.
8422  *
8423  */
8424 RMH_Result RMH_PQoSFlow_GetIngressClassificationRule(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8425 
8426 /**
8427  * @brief Return the packet size in bytes of the flow specified by flowId.
8428  *
8429  * This includes the VLAN header but not including the FCS.
8430  *
8431  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8432  * @param[in] flowId The unique flow identifier.
8433  * @param[out] response The flow packet size.
8434  *
8435  */
8436 RMH_Result RMH_PQoSFlow_GetPacketSize(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8437 
8438 /**
8439  * @brief Return the total number of packets transmitted on the flow specified by flowId.
8440  *
8441  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8442  * @param[in] flowId The unique flow identifier.
8443  * @param[out] response The total number of packets transmitted.
8444  *
8445  */
8446 RMH_Result RMH_PQoSFlow_GetTotalTxPackets(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8447 
8448 /**
8449  * @brief Return the DSCP MoCA value for the flow specified by flowId.
8450  *
8451  * The value of the three MSB of the DSCP Type of Service field is used for MSDU classification when
8452  * RMH_PQoSFlow_GetIngressClassificationRule is set to 1 or 3.
8453  *
8454  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8455  * @param[in] flowId The unique flow identifier.
8456  * @param[out] response The DSCP MoCA.
8457  *
8458  */
8459 RMH_Result RMH_PQoSFlow_GetDSCPMoCA(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8460 
8461 /**
8462  * @brief Return the destination flow ID of the flow specified by flowId.
8463  *
8464  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8465  * @param[in] flowId The unique flow identifier.
8466  * @param[out] response The DFID of the flow.
8467  *
8468  */
8469 RMH_Result RMH_PQoSFlow_GetDFID(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t* response);
8470 
8471 /**
8472  * @brief Return the destination flow ID of the flow specified by flowId.
8473  *
8474  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8475  * @param[in] flowId The unique flow identifier.
8476  * @param[out] response The DFID of the flow.
8477  *
8478  */
8479 RMH_Result RMH_PQoSFlow_GetDestination(const RMH_Handle handle, const RMH_MacAddress_t flowId, RMH_MacAddress_t *response);
8480 
8481 /**
8482  * @brief Return the ingress MAC address of the flow specified by flowId.
8483  *
8484  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8485  * @param[in] flowId The unique flow identifier.
8486  * @param[out] response The ingress MAC of the flow.
8487  *
8488  */
8489 RMH_Result RMH_PQoSFlow_GetIngressMac(const RMH_Handle handle, const RMH_MacAddress_t flowId, RMH_MacAddress_t *response);
8490 
8491 /**
8492  * @brief Return the egress MAC address of the flow specified by flowId.
8493  *
8494  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8495  * @param[in] flowId The unique flow identifier.
8496  * @param[out] response The ingress MAC of the flow.
8497  *
8498  */
8499 RMH_Result RMH_PQoSFlow_GetEgressMac(const RMH_Handle handle, const RMH_MacAddress_t flowId, RMH_MacAddress_t *response);
8500 
8501 
8502 /**
8503  * @brief Return the node Id with the minimum available bandwidth.
8504  *
8505  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8506  * @param[out] response The node Id with the minimum available bandwidth.
8507  *
8508  */
8509 
8510 RMH_Result RMH_PQoS_GetMinEgressBandwidth(const RMH_Handle handle, uint32_t* response);
8511 
8512 /**
8513  * @brief Return the number of admission attempts this node has made.
8514  *
8515  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8516  * @param[out] response The number of admission attempts.
8517  *
8518  * @note This counter is reset by RMH_Stats_Reset.
8519  */
8520 RMH_Result RMH_Stats_GetAdmissionAttempts(const RMH_Handle handle, uint32_t* response);
8521 
8522 /**
8523  * @brief Return the number of admission failures for this node.
8524  *
8525  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8526  * @param[out] response The number of admission failures by this node.
8527  *
8528  * @note This counter is reset by RMH_Stats_Reset.
8529  */
8530 RMH_Result RMH_Stats_GetAdmissionFailures(const RMH_Handle handle, uint32_t* response);
8531 
8532 /**
8533  * @brief Return the number of successful admissions for this node.
8534  *
8535  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8536  * @param[out] response The number of successful admissions by this node.
8537  *
8538  * @note This counter is reset by RMH_Stats_Reset.
8539  */
8540 RMH_Result RMH_Stats_GetAdmissionSucceeded(const RMH_Handle handle, uint32_t* response);
8541 
8542 /**
8543  * @brief Return the number of admissions this node has denied when it was the NC.
8544  *
8545  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8546  * @param[out] response The number of admissions this node has denied when it was the NC.
8547  *
8548  * @note This counter is reset by RMH_Stats_Reset.
8549  */
8550 RMH_Result RMH_Stats_GetAdmissionsDeniedAsNC(const RMH_Handle handle, uint32_t* response);
8551 
8552 /**
8553  * @brief Return the total number of bytes transmitted by this node.
8554  *
8555  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8556  * @param[out] response The total number of bytes transmitted by this node.
8557  *
8558  * @note This counter is reset by RMH_Stats_Reset.
8559  */
8560 RMH_Result RMH_Stats_GetTxTotalBytes(const RMH_Handle handle, uint32_t* response);
8561 
8562 /**
8563  * @brief Return the total number of bytes received by this node.
8564  *
8565  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8566  * @param[out] response The total number of bytes received by this node.
8567  *
8568  * @note This counter is reset by RMH_Stats_Reset.
8569  */
8570 RMH_Result RMH_Stats_GetRxTotalBytes(const RMH_Handle handle, uint32_t* response);
8571 
8572 /**
8573  * @brief Return the total number of packets transmitted by this node.
8574  *
8575  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8576  * @param[out] response The number of packets transmitted by this node.
8577  *
8578  * @note This counter is reset by RMH_Stats_Reset.
8579  */
8580 RMH_Result RMH_Stats_GetTxTotalPackets(const RMH_Handle handle, uint32_t* response);
8581 
8582 /**
8583  * @brief Return the total number of packets received by this node.
8584  *
8585  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8586  * @param[out] response The number of received transmitted by this node.
8587  *
8588  * @note This counter is reset by RMH_Stats_Reset.
8589  */
8590 RMH_Result RMH_Stats_GetRxTotalPackets(const RMH_Handle handle, uint32_t* response);
8591 
8592 /**
8593  * @brief Return the number of unicast packets transmitted by this node.
8594  *
8595  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8596  * @param[out] response The number of unicast packets transmitted by this node.
8597  *
8598  * @note This counter is reset by RMH_Stats_Reset.
8599  */
8600 RMH_Result RMH_Stats_GetTxUnicastPackets(const RMH_Handle handle, uint32_t* response);
8601 
8602 /**
8603  * @brief Return the number of unicast packets received by this node.
8604  *
8605  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8606  * @param[out] response The number of unicast packets received by this node.
8607  *
8608  * @note This counter is reset by RMH_Stats_Reset.
8609  */
8610 RMH_Result RMH_Stats_GetRxUnicastPackets(const RMH_Handle handle, uint32_t* response);
8611 
8612 /**
8613  * @brief Return the number of broadcast packets transmitted by this node.
8614  *
8615  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8616  * @param[out] response The number of broadcast packets transmitted by this node.
8617  *
8618  * @note This counter is reset by RMH_Stats_Reset.
8619  */
8620 RMH_Result RMH_Stats_GetTxBroadcastPackets(const RMH_Handle handle, uint32_t* response);
8621 
8622 /**
8623  * @brief Return the number of broadcast packets received by this node.
8624  *
8625  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8626  * @param[out] response The number of broadcast packets received by this node.
8627  *
8628  * @note This counter is reset by RMH_Stats_Reset.
8629  */
8630 RMH_Result RMH_Stats_GetRxBroadcastPackets(const RMH_Handle handle, uint32_t* response);
8631 
8632 /**
8633  * @brief Return the number of multicast packets transmitted by this node.
8634  *
8635  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8636  * @param[out] response The number of multicast packets transmitted by this node.
8637  *
8638  * @note This counter is reset by RMH_Stats_Reset.
8639  */
8640 RMH_Result RMH_Stats_GetTxMulticastPackets(const RMH_Handle handle, uint32_t* response);
8641 
8642 /**
8643  * @brief Return the number of multicast packets received by this node.
8644  *
8645  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8646  * @param[out] response The number of multicast packets received by this node.
8647  *
8648  * @note This counter is reset by RMH_Stats_Reset.
8649  */
8650 RMH_Result RMH_Stats_GetRxMulticastPackets(const RMH_Handle handle, uint32_t* response);
8651 
8652 /**
8653  * @brief Return the number of reservation request packets transmitted by this node.
8654  *
8655  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8656  * @param[out] response The number of reservation request packets transmitted by this node.
8657  *
8658  * @note This counter is reset by RMH_Stats_Reset.
8659  */
8660 RMH_Result RMH_Stats_GetTxReservationRequestPackets(const RMH_Handle handle, uint32_t* response);
8661 
8662 /**
8663  * @brief Return the number of reservation request packets received by this node.
8664  *
8665  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8666  * @param[out] response The number of reservation request packets received by this node.
8667  *
8668  * @note This counter is reset by RMH_Stats_Reset.
8669  */
8670 RMH_Result RMH_Stats_GetRxReservationRequestPackets(const RMH_Handle handle, uint32_t* response);
8671 
8672 /**
8673  * @brief Return the number of MAP transmitted by this node.
8674  *
8675  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8676  * @param[out] response The number of MAP packets transmitted by this node.
8677  *
8678  * @note This counter is reset by RMH_Stats_Reset.
8679  */
8680 RMH_Result RMH_Stats_GetTxMapPackets(const RMH_Handle handle, uint32_t* response);
8681 
8682 /**
8683  * @brief Return the number of MAP received by this node.
8684  *
8685  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8686  * @param[out] response The number of MAP packets received by this node.
8687  *
8688  * @note This counter is reset by RMH_Stats_Reset.
8689  */
8690 RMH_Result RMH_Stats_GetRxMapPackets(const RMH_Handle handle, uint32_t* response);
8691 
8692 /**
8693  * @brief Return the number of link control transmitted by this node.
8694  *
8695  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8696  * @param[out] response The number of link control packets transmitted by this node.
8697  *
8698  * @note This counter is reset by RMH_Stats_Reset.
8699  */
8700 RMH_Result RMH_Stats_GetTxLinkControlPackets(const RMH_Handle handle, uint32_t* response);
8701 
8702 /**
8703  * @brief Return the number of link control received by this node.
8704  *
8705  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8706  * @param[out] response The number of link control packets received by this node.
8707  *
8708  * @note This counter is reset by RMH_Stats_Reset.
8709  */
8710 RMH_Result RMH_Stats_GetRxLinkControlPackets(const RMH_Handle handle, uint32_t* response);
8711 
8712 /**
8713  * @brief Return the number of link control received by this node.
8714  *
8715  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8716  * @param[out] response The number of link control packets received by this node.
8717  *
8718  * @note This counter is reset by RMH_Stats_Reset.
8719  */
8720 RMH_Result RMH_Stats_GetTxBeacons(const RMH_Handle handle, uint32_t* response);
8721 
8722 /**
8723  * @brief Return the number of beacons received by this node.
8724  *
8725  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8726  * @param[out] response The number of beacons received by this node.
8727  *
8728  * @note This counter is reset by RMH_Stats_Reset.
8729  */
8730 RMH_Result RMH_Stats_GetRxBeacons(const RMH_Handle handle, uint32_t* response);
8731 
8732 /**
8733  * @brief Return the number of unknown packets received by this node.
8734  *
8735  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8736  * @param[out] response The number of unknown packets received by this node.
8737  *
8738  * @note This counter is reset by RMH_Stats_Reset.
8739  */
8740 RMH_Result RMH_Stats_GetRxUnknownProtocolPackets(const RMH_Handle handle, uint32_t* response);
8741 
8742 /**
8743  * @brief Return the number of packets this node has dropped before transmitting.
8744  *
8745  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8746  * @param[out] response The number of packets dropped by this node before transmitting.
8747  *
8748  * @note This counter is reset by RMH_Stats_Reset.
8749  */
8750 RMH_Result RMH_Stats_GetTxDroppedPackets(const RMH_Handle handle, uint32_t* response);
8751 
8752 /**
8753  * @brief Return the number of packets this node has dropped after receiving.
8754  *
8755  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8756  * @param[out] response The number of received packets dropped by this node.
8757  *
8758  * @note This counter is reset by RMH_Stats_Reset.
8759  */
8760 RMH_Result RMH_Stats_GetRxDroppedPackets(const RMH_Handle handle, uint32_t* response);
8761 
8762 /**
8763  * @brief Return the total number of transmit errors by this node.
8764  *
8765  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8766  * @param[out] response The total number of transmit errors by this node.
8767  *
8768  * @note This counter is reset by RMH_Stats_Reset.
8769  */
8770 RMH_Result RMH_Stats_GetTxTotalErrors(const RMH_Handle handle, uint32_t* response);
8771 
8772 /**
8773  * @brief Return the total number of received errors by this node.
8774  *
8775  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8776  * @param[out] response The total number of receive errors by this node.
8777  *
8778  * @note This counter is reset by RMH_Stats_Reset.
8779  */
8780 RMH_Result RMH_Stats_GetRxTotalErrors(const RMH_Handle handle, uint32_t* response);
8781 
8782 /**
8783  * @brief Return the total number of packets this node has received with CRC errors.
8784  *
8785  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8786  * @param[out] response The total number of received packets with CRC errors.
8787  *
8788  * @note This counter is reset by RMH_Stats_Reset.
8789  */
8790 RMH_Result RMH_Stats_GetRxCRCErrors(const RMH_Handle handle, uint32_t* response);
8791 
8792 /**
8793  * @brief Return the total number of packets this node has received with timeout errors.
8794  *
8795  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8796  * @param[out] response The total number of received packets with timeout errors.
8797  *
8798  * @note This counter is reset by RMH_Stats_Reset.
8799  */
8800 RMH_Result RMH_Stats_GetRxTimeoutErrors(const RMH_Handle handle, uint32_t* response);
8801 
8802 /**
8803  * @brief Return the total number of received aggregated packets.
8804  *
8805  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8806  * @param[out] response The total number of received aggregated packets.
8807  *
8808  * @note This counter is reset by RMH_Stats_Reset.
8809  */
8810 RMH_Result RMH_Stats_GetRxTotalAggregatedPackets(const RMH_Handle handle, uint32_t* response);
8811 
8812 /**
8813  * @brief Return the total number of transmitted aggregated packets.
8814  *
8815  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8816  * @param[out] response The total number of transmitted aggregated packets.
8817  *
8818  * @note This counter is reset by RMH_Stats_Reset.
8819  */
8820 RMH_Result RMH_Stats_GetTxTotalAggregatedPackets(const RMH_Handle handle, uint32_t* response);
8821 
8822 /**
8823  * @brief Return an array indicating the number of packets received per aggregation number.
8824  *
8825  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8826  * @param[out] responseArray The total number of transmitted aggregated packets.
8827  * @param[in] responseArraySize The size of the response array.
8828  * @param[out] responseArrayUsed The number of entries in the response array which have valid data.
8829  *
8830  * @note This counter is reset by RMH_Stats_Reset.
8831  */
8832 RMH_Result RMH_Stats_GetRxPacketAggregation(const RMH_Handle handle, uint32_t* responseArray, const size_t responseArraySize, size_t* responseArrayUsed);
8833 
8834 /**
8835  * @brief Return an array indicating the number of packets transmitted per aggregation number.
8836  *
8837  * The array index indicates the number of transmitted bursts.
8838  * So index 0 counts transmitted bursts with actual aggregation of 0, index 2 counts actual aggregation of 2, and so on.
8839  *
8840  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8841  * @param[out] responseArray An array where the aggregation information should be returned.
8842  * @param[in] responseArraySize The size of the response array.
8843  * @param[out] responseArrayUsed The number of entries in the response array which have valid data.
8844  *
8845  * @note This counter is reset by RMH_Stats_Reset.
8846  */
8847 RMH_Result RMH_Stats_GetTxPacketAggregation(const RMH_Handle handle, uint32_t* responseArray, const size_t responseArraySize, size_t* responseArrayUsed);
8848 
8849 /**
8850  * @brief Return the number of received packets from every node with errors which were corrected.
8851  *
8852  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8853  * @param[out] response Number of corrected errors for that node, if nodePresent is true.
8854  *
8855  * @note This counter is reset by RMH_Stats_Reset.
8856  */
8857 RMH_Result RMH_Stats_GetRxCorrectedErrors(const RMH_Handle handle, RMH_NodeList_Uint32_t* response);
8858 
8859 /**
8860  * @brief Return the number of received packets from every node with errors which were not corrected.
8861  *
8862  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8863  * @param[out] response Number of corrected errors for that node, if nodePresent is true.
8864  *
8865  * @note This counter is reset by RMH_Stats_Reset.
8866  */
8867 RMH_Result RMH_Stats_GetRxUncorrectedErrors(const RMH_Handle handle, RMH_NodeList_Uint32_t* response);
8868 
8869 /**
8870  * @brief Reset MoCA statistics counters back to zero.
8871  *
8872  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8873  */
8874 RMH_Result RMH_Stats_Reset(const RMH_Handle handle);
8875 
8876 /**
8877  * @brief Return a bitmask of RMH_LogLevel which indicates the currently enabled RMH log types in the RMH library.
8878  *
8879  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8880  * @param[out] response The RMH API log level.
8881  *
8882  * @note This API is for log messages from RMH libraries only.
8883  * The log level of the lower level MoCA driver should be read with RMH_Log_GetDriverLevel.
8884  */
8885 RMH_Result RMH_Log_GetAPILevel(const RMH_Handle handle, uint32_t* response);
8886 
8887 /**
8888  * @brief Set the log level of the RMH library.
8889  *
8890  * This is set as a bitmask of RMH_LogLevel indicating the RMH log types to enable in the RMH libraries.
8891  *
8892  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8893  * @param[in] value The desired RMH API log level.
8894  *
8895  */
8896 RMH_Result RMH_Log_SetAPILevel(const RMH_Handle handle, const uint32_t value);
8897 
8898 /**
8899  * @brief Return a bitmask of RMH_LogLevel which indicates the currently enabled RMH log types in the MoCA driver.
8900  *
8901  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8902  * @param[out] response The SoC MoCA Driver log level.
8903  *
8904  * @note This API is for log messages from SoC MoCA driver only.
8905  * The log level of the RMH library should be read with RMH_Log_GetDriverLevel.
8906  */
8907 RMH_Result RMH_Log_GetDriverLevel(const RMH_Handle handle, RMH_LogLevel* response);
8908 
8909 /**
8910  * @brief Set the log level of the MoCA driver.
8911  *
8912  * This is set as a bitmask of RMH_LogLevel indicating the RMH log types to enable at the driver.
8913  *
8914  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8915  * @param[out] response The SoC MoCA Driver log level.
8916  *
8917  * @note This API is for log messages from SoC MoCA driver only.
8918  * The log level of the RMH libraries should be set with RMH_Log_SetAPILevel.
8919  */
8920 RMH_Result RMH_Log_SetDriverLevel(const RMH_Handle handle, const RMH_LogLevel value);
8921 
8922 /**
8923  * @brief Get the file name where MoCA driver logs are currently being captured.
8924  *
8925  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8926  * @param[out] responseBuf A buffer where the filename will be written.
8927  * @param[in] responseBufSize The size in bytes of the buffer responseBuf.
8928  *
8929  * @note This API is for log messages from SoC MoCA driver only.
8930  * The log level of the RMH libraries should be set with RMH_Log_SetAPILevel.
8931  */
8932 RMH_Result RMH_Log_GetDriverFilename(const RMH_Handle handle, char* responseBuf, const size_t responseBufSize);
8933 
8934 /**
8935  * @brief Set the file name where MoCA driver logs should be captured to.
8936  *
8937  * If logs are already being captured to a file this capture will stop at that location and begin in this file.
8938  * If the new log file already exists new logs will append to it.
8939  *
8940  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8941  * @param[in] value A file name where logs should be written.
8942  *
8943  * @note This API is for log messages from SoC MoCA driver only.
8944  * The log level of the RMH libraries should be set with RMH_Log_SetAPILevel.
8945  */
8946 RMH_Result RMH_Log_SetDriverFilename(const RMH_Handle handle, const char* value);
8947 
8948 
8949 /**
8950  * @brief Print a generic status summary of the MoCA device and network.
8951  *
8952  * If filename is NULL all log messages are printed with RMH_LOG_MESSAGE.
8953  * If it is not NULL the status will be appended to that file.
8954  *
8955  * @param[in] handle The RMH handle as returned by RMH_Initialize. NULL is valid for this API.
8956  * @param[in] filename The file name where to write the status.
8957  * If this is NULL the status will be written to RMH_LOG_MESSAGE.
8958  */
8959 RMH_Result RMH_Log_PrintStatus(const RMH_Handle handle, const char* filename);
8960 
8961 
8962 
8963 /**
8964  * @brief Print a summary of the sub carrier modulation bitloading information.
8965  *
8966  * @param[in] handle The RMH handle as returned by RMH_Initialize. NULL is valid for this API.
8967  * @param[in] filename The file name where to write the status.
8968  * If this is NULL the status will be written to RMH_LOG_MESSAGE.
8969  */
8970 RMH_Result RMH_ACA_Request(const RMH_Handle handle, const uint32_t channelNum, const uint32_t sourceNodeId, const uint32_t destinationNodeMask, const RMH_ACAType type);
8971 
8972 /**
8973  * @brief Return the channel number of the last requested ACA. [mocaIfAcaNodeID].
8974  *
8975  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8976  * @param[out] response The channel number of the last requested ACA. [mocaIfAcaNodeID].
8977  */
8978 RMH_Result RMH_ACA_GetChannel(const RMH_Handle handle, uint32_t* response);
8979 
8980 /**
8981  * @brief Return the Node ID of the source node for the last requested ACA. [mocaIfAcaNodeID].
8982  *
8983  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8984  * @param[out] response The Node ID of the source node for the last requested ACA. [mocaIfAcaNodeID].
8985  */
8986 RMH_Result RMH_ACA_GetSourceNodeId(const RMH_Handle handle, uint32_t* response);
8987 
8988 /**
8989  * @brief Return the bitmask of the destination nodes for the last requested ACA. [mocaIfAcaReportNodeMask].
8990  *
8991  * @param[in] handle The RMH handle as returned by RMH_Initialize.
8992  * @param[out] response The bitmask of the destination nodes for the last requested ACA.
8993  * [mocaIfAcaReportNodeMask].
8994  */
8995 RMH_Result RMH_ACA_GetDestinationNodeMask(const RMH_Handle handle, uint32_t* response);
8996 
8997 /**
8998  * @brief Return the type of the last requested ACA operation.
8999  *
9000  * @param[in] handle The RMH handle as returned by RMH_Initialize.
9001  * @param[out] response The type of the last requested ACA operation [mocaIfAcaType].
9002  */
9003 RMH_Result RMH_ACA_GetType(const RMH_Handle handle, RMH_ACAType* response);
9004 
9005 /**
9006  * @brief Return the current status of the last requested ACA operation.
9007  *
9008  * @param[in] handle The RMH handle as returned by RMH_Initialize.
9009  * @param[out] response The current status of the previously started ACA operation [mocaIfAcaStatus].
9010  */
9011 RMH_Result RMH_ACA_GetStatus(const RMH_Handle handle, RMH_ACAStatus* response);
9012 
9013 /**
9014  * @brief Return the total power from the last completed ACA operation.
9015  *
9016  * This call will fail if an ACA operation is already in progress.
9017  *
9018  * @param[in] handle The RMH handle as returned by RMH_Initialize.
9019  * @param[out] response The total power from the last completed ACA operation [mocaIfAcaTotalRxPower].
9020  */
9021 RMH_Result RMH_ACA_GetTotalRxPower(const RMH_Handle handle, int32_t* response);
9022 
9023 /**
9024  * @brief Returns the ACA power profile.
9025  *
9026  * Returns a binary string array with 1 byte for each subcarrier. [mocaIfAcaPowerProfile].
9027  *
9028  * @param[in] handle The RMH handle as returned by RMH_Initialize.
9029  * @param[in] responseArray The ACA power profile.
9030  * @param[in] responseArraySize The size of responseArray.
9031  * @param[out] responseArrayUsed The number of entries in the response array which have valid data.
9032  */
9033 RMH_Result RMH_ACA_GetPowerProfile(const RMH_Handle handle, uint8_t* responseArray, const size_t responseArraySize, size_t* responseArrayUsed);
9034 
9035 /** @} */ //End of doxygen tag MOCAHAL_SOC_API
9036 
9037 #endif
9038 
9039 #ifdef __cplusplus
9040 }
9041 #endif
9042 
9043 #endif /* RMH_API_H */
RMH_PQoS_GetMinEgressBandwidth
RMH_Result RMH_PQoS_GetMinEgressBandwidth(const RMH_Handle handle, uint32_t *response)
Return the node Id with the minimum available bandwidth.
RMH_Network_GetNCMac
RMH_Result RMH_Network_GetNCMac(const RMH_Handle handle, RMH_MacAddress_t *response)
Return the MAC address of the network coordinator.
RMH_Stats_GetAdmissionFailures
RMH_Result RMH_Stats_GetAdmissionFailures(const RMH_Handle handle, uint32_t *response)
Return the number of admission failures for this node.
RMH_Log_GetDriverLevel
RMH_Result RMH_Log_GetDriverLevel(const RMH_Handle handle, RMH_LogLevel *response)
Return a bitmask of RMH_LogLevel which indicates the currently enabled RMH log types in the MoCA driv...
RMH_Power_GetMode
RMH_Result RMH_Power_GetMode(const RMH_Handle handle, RMH_PowerMode *response)
Return the current MoCA power state of this device.
RMH_GetAPITags
RMH_Result RMH_GetAPITags(const RMH_Handle handle, RMH_APITagList **apiTags)
Return the list of all RMH APIs grouped into lists by their tags.
RMH_Stats_GetRxMulticastPackets
RMH_Result RMH_Stats_GetRxMulticastPackets(const RMH_Handle handle, uint32_t *response)
Return the number of multicast packets received by this node.
RMH_Self_GetPreferredNCEnabled
RMH_Result RMH_Self_GetPreferredNCEnabled(const RMH_Handle handle, bool *response)
Return if this device is a preferred NC.
RMH_Stats_Reset
RMH_Result RMH_Stats_Reset(const RMH_Handle handle)
Reset MoCA statistics counters back to zero.
RMH_Stats_GetRxTotalAggregatedPackets
RMH_Result RMH_Stats_GetRxTotalAggregatedPackets(const RMH_Handle handle, uint32_t *response)
Return the total number of received aggregated packets.
RMH_RemoteNode_GetRxBroadcastPhyRate
RMH_Result RMH_RemoteNode_GetRxBroadcastPhyRate(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
Return the PHY rate at which broadcast packets are received from nodeId.
RMH_Self_GetMaxBitrate
RMH_Result RMH_Self_GetMaxBitrate(const RMH_Handle handle, uint32_t *response)
The maximum PHY rate supported in non-turbo mode.
RMH_Stats_GetTxBroadcastPackets
RMH_Result RMH_Stats_GetTxBroadcastPackets(const RMH_Handle handle, uint32_t *response)
Return the number of broadcast packets transmitted by this node.
RMH_Log_GetDriverFilename
RMH_Result RMH_Log_GetDriverFilename(const RMH_Handle handle, char *responseBuf, const size_t responseBufSize)
Get the file name where MoCA driver logs are currently being captured.
RMH_Stats_GetTxPacketAggregation
RMH_Result RMH_Stats_GetTxPacketAggregation(const RMH_Handle handle, uint32_t *responseArray, const size_t responseArraySize, size_t *responseArrayUsed)
Return an array indicating the number of packets transmitted per aggregation number.
RMH_Stats_GetRxCRCErrors
RMH_Result RMH_Stats_GetRxCRCErrors(const RMH_Handle handle, uint32_t *response)
Return the total number of packets this node has received with CRC errors.
RMH_Self_GetRDKInteroperabilityIFGEnabled
RMH_Result RMH_Self_GetRDKInteroperabilityIFGEnabled(const RMH_Handle handle, bool *response)
Return if the RDK specific inter-frame gap of 10us is enabled on this device.
Driver
Definition: Driver.hpp:45
RMH_Stats_GetTxTotalErrors
RMH_Result RMH_Stats_GetTxTotalErrors(const RMH_Handle handle, uint32_t *response)
Return the total number of transmit errors by this node.
RMH_Stats_GetTxMulticastPackets
RMH_Result RMH_Stats_GetTxMulticastPackets(const RMH_Handle handle, uint32_t *response)
Return the number of multicast packets transmitted by this node.
RMH_Self_GetLinkStatus
RMH_Result RMH_Self_GetLinkStatus(const RMH_Handle handle, RMH_LinkStatus *status)
Current operational status of the MoCA interface [mocaIfStatus].
RMH_AdmissionStatusToString
const char *const RMH_AdmissionStatusToString(const RMH_AdmissionStatus value)
Convert RMH_AdmissionStatus to a string.
Definition: librmh_api_no_wrap.c:92
RMH_Self_SetQAM256TargetPhyRate
RMH_Result RMH_Self_SetQAM256TargetPhyRate(const RMH_Handle handle, const uint32_t value)
Set the target PHY rate in Mbps.
RMH_RemoteNode_Reset
RMH_Result RMH_RemoteNode_Reset(const RMH_Handle handle, const uint32_t nodeListMask, const uint32_t startTime)
Instruct one or more nodes to initiate a MoCA Reset command.
RMH_ACA_GetTotalRxPower
RMH_Result RMH_ACA_GetTotalRxPower(const RMH_Handle handle, int32_t *response)
Return the total power from the last completed ACA operation.
RMH_RemoteNode_GetMac
RMH_Result RMH_RemoteNode_GetMac(const RMH_Handle handle, const uint32_t nodeId, RMH_MacAddress_t *response)
Return the MAC address of the remote node specified by nodeId.
RMH_Network_GetLinkUptime
RMH_Result RMH_Network_GetLinkUptime(const RMH_Handle handle, uint32_t *response)
Returns the amount of time this node has been part of the MoCA network [mocaIfLinkUpTime].
RMH_Log_SetDriverLevel
RMH_Result RMH_Log_SetDriverLevel(const RMH_Handle handle, const RMH_LogLevel value)
Set the log level of the MoCA driver.
RMH_ACA_GetPowerProfile
RMH_Result RMH_ACA_GetPowerProfile(const RMH_Handle handle, uint8_t *responseArray, const size_t responseArraySize, size_t *responseArrayUsed)
Returns the ACA power profile.
RMH_Stats_GetAdmissionAttempts
RMH_Result RMH_Stats_GetAdmissionAttempts(const RMH_Handle handle, uint32_t *response)
Return the number of admission attempts this node has made.
RMH_Network_GetSecondaryChannelFreq
RMH_Result RMH_Network_GetSecondaryChannelFreq(const RMH_Handle handle, uint32_t *response)
Return the secondary MoCA 2.0 channel.
RMH_Stats_GetAdmissionSucceeded
RMH_Result RMH_Stats_GetAdmissionSucceeded(const RMH_Handle handle, uint32_t *response)
Return the number of successful admissions for this node.
RMH_Interface_SetEnabled
RMH_Result RMH_Interface_SetEnabled(const RMH_Handle handle, const bool value)
Set MoCA interface enabled or disabled at the kernel level.
RMH_Network_GetBackupNCNodeId
RMH_Result RMH_Network_GetBackupNCNodeId(const RMH_Handle handle, uint32_t *response)
Return the node ID of the backup network coordinator [mocaIfBackupNC].
RMH_PQoS_GetNumIngressFlows
RMH_Result RMH_PQoS_GetNumIngressFlows(const RMH_Handle handle, uint32_t *response)
Return the number of ingress flows.
RMH_Log_CreateDriverFile
RMH_Result RMH_Log_CreateDriverFile(const RMH_Handle handle, char *responseBuf, const size_t responseBufSize)
Create a new log file in standard RDK format.
RMH_Network_GetNodeIds
RMH_Result RMH_Network_GetNodeIds(const RMH_Handle handle, RMH_NodeList_Uint32_t *response)
Return a list of every node ID on the network.
RMH_RemoteNode_GetPreferredNC
RMH_Result RMH_RemoteNode_GetPreferredNC(const RMH_Handle handle, const uint32_t nodeId, bool *response)
Return if the node indicated by nodeId is a preferred NC or not.
RMH_PQOS_GetMaxEgressFlows
RMH_Result RMH_PQOS_GetMaxEgressFlows(const RMH_Handle handle, uint32_t *response)
Return the maximum number of supported Egress PQoS Flows by the Node [mocaIfSupportedEgressPqosFlows]...
RMH_Stats_GetAdmissionsDeniedAsNC
RMH_Result RMH_Stats_GetAdmissionsDeniedAsNC(const RMH_Handle handle, uint32_t *response)
Return the number of admissions this node has denied when it was the NC.
RMH_Power_SetTxBeaconPowerReductionEnabled
RMH_Result RMH_Power_SetTxBeaconPowerReductionEnabled(const RMH_Handle handle, const bool value)
Enable or disable if beacon power reduction on this device.
RMH_PQOS_GetMaxIngressFlows
RMH_Result RMH_PQOS_GetMaxIngressFlows(const RMH_Handle handle, uint32_t *response)
Return the maximum number of supported Ingress PQoS Flows by the Node [mocaIfSupportedIngressPqosFlow...
Version
Definition: Operands.hpp:514
RMH_RemoteNode_GetRxBroadcastPower
RMH_Result RMH_RemoteNode_GetRxBroadcastPower(const RMH_Handle handle, const uint32_t nodeId, float *response)
Return the power level at which broadcast packets are received from nodeId.
RMH_GetAllAPIs
RMH_Result RMH_GetAllAPIs(const RMH_Handle handle, RMH_APIList **apiList)
Return a list of all APIs which are part of RMH.
RMH_PQoSFlow_GetVLANTag
RMH_Result RMH_PQoSFlow_GetVLANTag(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the VLAN priority for the flow specified by flowId.
RMH_Self_SetMaxFrameSize
RMH_Result RMH_Self_SetMaxFrameSize(const RMH_Handle handle, const uint32_t value)
Set the maximum number of bytes this node can receive in one frame (aggregated transmission).
RMH_LogLevelToString
const char *const RMH_LogLevelToString(const uint32_t value, char *responseBuf, const size_t responseBufSize)
Return the bitmask value as a string.
Definition: librmh_api_no_wrap.c:166
RMH_Power_GetTxBeaconPowerReductionEnabled
RMH_Result RMH_Power_GetTxBeaconPowerReductionEnabled(const RMH_Handle handle, bool *response)
Return if beacon power reduction is enabled on this device.
RMH_PQoSFlow_GetDestination
RMH_Result RMH_PQoSFlow_GetDestination(const RMH_Handle handle, const RMH_MacAddress_t flowId, RMH_MacAddress_t *response)
Return the destination flow ID of the flow specified by flowId.
RMH_Stats_GetTxMapPackets
RMH_Result RMH_Stats_GetTxMapPackets(const RMH_Handle handle, uint32_t *response)
Return the number of MAP transmitted by this node.
RMH_PQoSFlow_GetFlowPer
RMH_Result RMH_PQoSFlow_GetFlowPer(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the flow packet error ratio profile for the flow specified by flowId.
RMH_Stats_GetTxTotalAggregatedPackets
RMH_Result RMH_Stats_GetTxTotalAggregatedPackets(const RMH_Handle handle, uint32_t *response)
Return the total number of transmitted aggregated packets.
RMH_RemoteNode_GetTxUnicastPower
RMH_Result RMH_RemoteNode_GetTxUnicastPower(const RMH_Handle handle, const uint32_t nodeId, float *response)
Return the power level rate at which unicast packets are transmitted from nodeId to the self node.
RMH_NodeList_Uint32_t
Definition: rmh_type.h:195
RMH_PQoSFlow_GetBurstSize
RMH_Result RMH_PQoSFlow_GetBurstSize(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the number of packets per burst for the flow specified by flowId.
RMH_MoCAVersionToString
const char *const RMH_MoCAVersionToString(const RMH_MoCAVersion value)
Convert RMH_MoCAVersion to a string.
Definition: librmh_api_no_wrap.c:122
RMH_RemoteNode_GetSecondaryRxUnicastSubcarrierModulation
RMH_Result RMH_RemoteNode_GetSecondaryRxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile *responseArray, const size_t responseArraySize, size_t *responseArrayUsed)
Return the unicast recieve subcarrier modulation profiles for the secondary MoCA channel.
RMH_Power_GetTxPowerControlEnabled
RMH_Result RMH_Power_GetTxPowerControlEnabled(const RMH_Handle handle, bool *response)
Return if transmit power control is enabled or disabled for this device.
RMH_Network_GetNodeId
RMH_Result RMH_Network_GetNodeId(const RMH_Handle handle, uint32_t *response)
Return the node ID of this device.
RMH_Stats_GetTxReservationRequestPackets
RMH_Result RMH_Stats_GetTxReservationRequestPackets(const RMH_Handle handle, uint32_t *response)
Return the number of reservation request packets transmitted by this node.
RMH_ACA_GetType
RMH_Result RMH_ACA_GetType(const RMH_Handle handle, RMH_ACAType *response)
Return the type of the last requested ACA operation.
RMH_Log_SetDriverFilename
RMH_Result RMH_Log_SetDriverFilename(const RMH_Handle handle, const char *value)
Set the file name where MoCA driver logs should be captured to.
RMH_BandToString
const char *const RMH_BandToString(const RMH_Band value)
Convert value to a printable string.
Definition: librmh_api_no_wrap.c:96
RMH_Self_SetMaxPacketAggregation
RMH_Result RMH_Self_SetMaxPacketAggregation(const RMH_Handle handle, const uint32_t value)
Set the maximum allowed packets for aggregated transmissions.
RMH_RemoteNode_GetHighestSupportedMoCAVersion
RMH_Result RMH_RemoteNode_GetHighestSupportedMoCAVersion(const RMH_Handle handle, const uint32_t nodeId, RMH_MoCAVersion *response)
Return the highest supported version of MoCA by the remote node specified by nodeId.
RMH_RemoteNode_GetRxCorrectedErrors
RMH_Result RMH_RemoteNode_GetRxCorrectedErrors(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
Return the number of packets with corrected errors nodeId has received.
RMH_Self_SetFrequencyMask
RMH_Result RMH_Self_SetFrequencyMask(const RMH_Handle handle, const uint32_t value)
Set the bit mask for specifying which frequencies should be scanned during the listening phase of net...
RMH_PQoSFlow_GetMaxRetry
RMH_Result RMH_PQoSFlow_GetMaxRetry(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the maximum number of retransmission attempts for each MSDU of the flow specified by flowId.
RMH_GetEventCallbacks
RMH_Result RMH_GetEventCallbacks(RMH_Handle handle, uint32_t *response)
Get the list of events for which the client has registered.
RMH_Self_GetHighestSupportedMoCAVersion
RMH_Result RMH_Self_GetHighestSupportedMoCAVersion(const RMH_Handle handle, RMH_MoCAVersion *response)
Return the highest version of MoCA supported by the MoCA driver on this device. [mocaIfMocaVersion].
RMH_APITagList
Definition: rmh_type.h:240
RMH_Network_GetNumNodes
RMH_Result RMH_Network_GetNumNodes(const RMH_Handle handle, uint32_t *response)
Return the number of MoCA nodes in the network. [mocaIfNumNodes].
RMH_RemoteNode_GetNodeIdFromAssociatedId
RMH_Result RMH_RemoteNode_GetNodeIdFromAssociatedId(const RMH_Handle handle, const uint32_t associatedId, uint32_t *response)
Convert an associated Id into a Node Id.
RMH_RemoteNode_GetRxMapPower
RMH_Result RMH_RemoteNode_GetRxMapPower(const RMH_Handle handle, const uint32_t nodeId, float *response)
Return the power level at which MAP packets are received by nodeId.
RMH_PQoSFlow_GetIngressClassificationRule
RMH_Result RMH_PQoSFlow_GetIngressClassificationRule(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the ingress classification rule for assigning MSDUs to the flow specified by flowId.
RMH_RemoteNode_GetRxBroadcastSubcarrierModulation
RMH_Result RMH_RemoteNode_GetRxBroadcastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile *responseArray, const size_t responseArraySize, size_t *responseArrayUsed)
Return the receive broadcast subcarrier modulation profiles for the channel.
RMH_Self_GetSecondaryChannelOffset
RMH_Result RMH_Self_GetSecondaryChannelOffset(const RMH_Handle handle, int32_t *response)
TBD [mocaIfSecondaryChannelOffset].
RMH_PQoS_GetNumEgressFlows
RMH_Result RMH_PQoS_GetNumEgressFlows(const RMH_Handle handle, uint32_t *response)
Return the number of egress flows.
RMH_Self_SetPreferredNCEnabled
RMH_Result RMH_Self_SetPreferredNCEnabled(const RMH_Handle handle, const bool value)
Enable or disable preferred NC on this device.
RMH_Self_GetTurboEnabled
RMH_Result RMH_Self_GetTurboEnabled(const RMH_Handle handle, bool *response)
Return if turbo mode is enabled on this device.
RMH_Self_GetLowBandwidthLimit
RMH_Result RMH_Self_GetLowBandwidthLimit(const RMH_Handle handle, uint32_t *response)
Get the current lower limit for PHY rate between two nodes.
RMH_Network_GetRFChannelFreq
RMH_Result RMH_Network_GetRFChannelFreq(const RMH_Handle handle, uint32_t *response)
Return the frequency which the MoCA network is operating on. [mocaIfRFChannel].
RMH_RemoteNode_GetRxUnCorrectedErrors
RMH_Result RMH_RemoteNode_GetRxUnCorrectedErrors(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
Return the number of packets with uncorrected errors <nodeId> has received.
RMH_LinkStatusToString
const char *const RMH_LinkStatusToString(const RMH_LinkStatus value)
Convert RMH_LinkStatus to a string.
Definition: librmh_api_no_wrap.c:88
RMH_Self_SetBondingEnabled
RMH_Result RMH_Self_SetBondingEnabled(const RMH_Handle handle, const bool value)
Enable or disable bonding mode on this device.
RMH_GetUnimplementedAPIs
RMH_Result RMH_GetUnimplementedAPIs(const RMH_Handle handle, RMH_APIList **apiList)
Return a list of all RMH APIs which are unimplemented by the SoC library.
RMH_Self_GetSupportedFrequencies
RMH_Result RMH_Self_GetSupportedFrequencies(const RMH_Handle handle, uint32_t *responseArray, const size_t responseArraySize, size_t *responseArrayUsed)
Return a list of frequencies in the band used by this node.
RMH_RemoteNode_GetTxBroadcastSubcarrierModulation
RMH_Result RMH_RemoteNode_GetTxBroadcastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile *responseArray, const size_t responseArraySize, size_t *responseArrayUsed)
Return the transmission broadcast subcarrier modulation profiles for the channel.
RMH_Network_GetMixedMode
RMH_Result RMH_Network_GetMixedMode(const RMH_Handle handle, bool *response)
Check if the MoCA network contains both 1.1 and 2.0 nodes.
RMH_Power_GetTxBeaconPowerReduction
RMH_Result RMH_Power_GetTxBeaconPowerReduction(const RMH_Handle handle, uint32_t *response)
Return the power control back-off used by this node for transmitting beacons.
RMH_Stats_GetRxTotalErrors
RMH_Result RMH_Stats_GetRxTotalErrors(const RMH_Handle handle, uint32_t *response)
Return the total number of received errors by this node.
RMH_RemoteNode_GetRxPackets
RMH_Result RMH_RemoteNode_GetRxPackets(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
Return the number of packets nodeId has received.
RMH_Network_GetTxGcdPowerReduction
RMH_Result RMH_Network_GetTxGcdPowerReduction(const RMH_Handle handle, uint32_t *response)
The transmit power control back-off used for broadcast transmissions from this node....
RMH_Self_GetBondingEnabled
RMH_Result RMH_Self_GetBondingEnabled(const RMH_Handle handle, bool *response)
Return if bonding mode is enabled on this device.
RMH_PQoSFlow_GetMaxLatency
RMH_Result RMH_PQoSFlow_GetMaxLatency(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the maximum latency of the flow specified by flowId.
RMH_Network_GetTxGCDPhyRate
RMH_Result RMH_Network_GetTxGCDPhyRate(const RMH_Handle handle, uint32_t *response)
Return the GCD PHY rate which packets are transmitted from this node.
RMH
Definition: librmh.h:57
RMH_PQoSFlow_GetShortTermAvgRatio
RMH_Result RMH_PQoSFlow_GetShortTermAvgRatio(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the short term average ratio for the flow specified by flowId.
RMH_Self_GetPrivacyPassword
RMH_Result RMH_Self_GetPrivacyPassword(const RMH_Handle handle, char *responseBuf, const size_t responseBufSize)
Get the current MoCA privacy password.
RMH_Power_SetTxBeaconPowerReduction
RMH_Result RMH_Power_SetTxBeaconPowerReduction(const RMH_Handle handle, const uint32_t value)
Set the power control back-off used by this node for transmitting beacons.
RMH_Stats_GetTxDroppedPackets
RMH_Result RMH_Stats_GetTxDroppedPackets(const RMH_Handle handle, uint32_t *response)
Return the number of packets this node has dropped before transmitting.
RMH_PQoS_GetIngressFlowIds
RMH_Result RMH_PQoS_GetIngressFlowIds(const RMH_Handle handle, RMH_MacAddress_t *responseArray, const size_t responseArraySize, size_t *responseArrayUsed)
Return a list of the unique Id for each existing ingress flows.
RMH_RemoteNode_GetRxUnicastSubcarrierModulation
RMH_Result RMH_RemoteNode_GetRxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile *responseArray, const size_t responseArraySize, size_t *responseArrayUsed)
Return the unicast recieve subcarrier modulation profiles for the primary MoCA channel.
RMH_RemoteNode_GetRxTotalErrors
RMH_Result RMH_RemoteNode_GetRxTotalErrors(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
Return the total number of packets with errors nodeId has received.
RMH_Self_SetRDKInteroperabilityIFGEnabled
RMH_Result RMH_Self_SetRDKInteroperabilityIFGEnabled(const RMH_Handle handle, const bool value)
Enable or disable the RDK specific inter-frame gap of 10us.
RMH_ACA_GetStatus
RMH_Result RMH_ACA_GetStatus(const RMH_Handle handle, RMH_ACAStatus *response)
Return the current status of the last requested ACA operation.
RMH_Stats_GetRxBeacons
RMH_Result RMH_Stats_GetRxBeacons(const RMH_Handle handle, uint32_t *response)
Return the number of beacons received by this node.
RMH_ACA_GetChannel
RMH_Result RMH_ACA_GetChannel(const RMH_Handle handle, uint32_t *response)
Return the channel number of the last requested ACA. [mocaIfAcaNodeID].
RMH_RemoteNode_GetRxUnicastPhyRate
RMH_Result RMH_RemoteNode_GetRxUnicastPhyRate(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
Return the PHY rate at which unicast packets are received from nodeId of the self node.
RMH_Stats_GetTxUnicastPackets
RMH_Result RMH_Stats_GetTxUnicastPackets(const RMH_Handle handle, uint32_t *response)
Return the number of unicast packets transmitted by this node.
RMH_Network_GetTxNPER
RMH_Result RMH_Network_GetTxNPER(const RMH_Handle handle, RMH_NodeMesh_Uint32_t *response)
Return the transmit NPER (Nominal Packet Error Rate) PHY rates from all MoCA 2.0 nodes on the network...
RMH_Stats_GetRxUncorrectedErrors
RMH_Result RMH_Stats_GetRxUncorrectedErrors(const RMH_Handle handle, RMH_NodeList_Uint32_t *response)
Return the number of received packets from every node with errors which were not corrected.
RMH_Stats_GetTxTotalBytes
RMH_Result RMH_Stats_GetTxTotalBytes(const RMH_Handle handle, uint32_t *response)
Return the total number of bytes transmitted by this node.
RMH_Interface_GetEnabled
RMH_Result RMH_Interface_GetEnabled(const RMH_Handle handle, bool *response)
Check if the MoCA interface is enabled at the kernel level.
RMH_Self_SetScanLOFOnly
RMH_Result RMH_Self_SetScanLOFOnly(const RMH_Handle handle, const bool value)
Indicate if the device should join networks only on the last operating frequency.
RMH_Network_GetTabooChannels
RMH_Result RMH_Network_GetTabooChannels(const RMH_Handle handle, uint32_t *channelMaskStart, uint32_t *channelMask)
Return which beacon channels will be taboo on this device.
RMH_Self_SetLOF
RMH_Result RMH_Self_SetLOF(const RMH_Handle handle, const uint32_t value)
Manually set the last operating frequency of the device.
RMH_Network_GetTxVLPER
RMH_Result RMH_Network_GetTxVLPER(const RMH_Handle handle, RMH_NodeMesh_Uint32_t *response)
Return the transmit VLPER (Very Low Packet Error Rate) PHY rates between all MoCA 2....
RMH_PQoSFlow_GetTotalTxPackets
RMH_Result RMH_PQoSFlow_GetTotalTxPackets(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the total number of packets transmitted on the flow specified by flowId.
RMH_RemoteNode_GetQAM256Capable
RMH_Result RMH_RemoteNode_GetQAM256Capable(const RMH_Handle handle, const uint32_t nodeId, bool *response)
Return if the node indicated by nodeId has QAM256 enabled or not.
RMH_Self_GetSoftwareVersion
RMH_Result RMH_Self_GetSoftwareVersion(const RMH_Handle handle, char *responseBuf, const size_t responseBufSize)
Return the version of software being used by the MoCA driver on this device. [mocaIfSoftwareVersion].
RMH_Network_GetTxUnicastPhyRate
RMH_Result RMH_Network_GetTxUnicastPhyRate(const RMH_Handle handle, RMH_NodeMesh_Uint32_t *response)
Return the unicast transmit PHY rates between all nodes on the network.
RMH_MoCAResetReasonToString
const char *const RMH_MoCAResetReasonToString(const RMH_MoCAResetReason value)
Convert RMH_MoCAResetReason to a string.
Definition: librmh_api_no_wrap.c:108
RMH_Self_SetPrivacyPassword
RMH_Result RMH_Self_SetPrivacyPassword(const RMH_Handle handle, const char *value)
Set the network password used to generate privacy keys.
RMH_Network_GetAssociatedIds
RMH_Result RMH_Network_GetAssociatedIds(const RMH_Handle handle, RMH_NodeList_Uint32_t *response)
Return a list of the associated ID for every node on the network.
RMH_Stats_GetRxTotalBytes
RMH_Result RMH_Stats_GetRxTotalBytes(const RMH_Handle handle, uint32_t *response)
Return the total number of bytes received by this node.
RMH_MacToString
const char *const RMH_MacToString(const RMH_MacAddress_t value, char *responseBuf, const size_t responseBufSize)
Returns the provided MAC address in value as a string.
Definition: librmh_api_no_wrap.c:174
RMH_Self_SetTabooChannels
RMH_Result RMH_Self_SetTabooChannels(const RMH_Handle handle, const uint32_t channelMaskStart, const uint32_t channelMask)
Set which channels will be taboo on this device.
RMH_PERModeToString
const char *const RMH_PERModeToString(const RMH_PERMode value)
Convert RMH_PERMode to a string.
Definition: librmh_api_no_wrap.c:116
RMH_APIList
Definition: rmh_type.h:234
RMH_Stats_GetRxDroppedPackets
RMH_Result RMH_Stats_GetRxDroppedPackets(const RMH_Handle handle, uint32_t *response)
Return the number of packets this node has dropped after receiving.
RMH_Self_GetScanLOFOnly
RMH_Result RMH_Self_GetScanLOFOnly(const RMH_Handle handle, bool *response)
Return if the device is scanning only the last operating frequency when attempting to establish a con...
RMH_Power_SetTxPowerControlEnabled
RMH_Result RMH_Power_SetTxPowerControlEnabled(const RMH_Handle handle, const bool value)
Enable or disable if transmit power control is enabled for this device.
RMH_NodeMesh_Uint32_t
Definition: rmh_type.h:205
RMH_Stats_GetTxBeacons
RMH_Result RMH_Stats_GetTxBeacons(const RMH_Handle handle, uint32_t *response)
Return the number of link control received by this node.
RMH_Self_SetEnabled
RMH_Result RMH_Self_SetEnabled(const RMH_Handle handle, const bool value)
Enable or disable the MoCA driver to connect to a MoCA network. Once enabled the driver will use what...
RMH_Initialize
RMH_Handle RMH_Initialize(const RMH_EventCallback eventCB, void *userContext)
Initialize the RMH library and return a handle to the instance.
Definition: librmh_api_no_wrap.c:23
RMH_Stats_GetTxTotalPackets
RMH_Result RMH_Stats_GetTxTotalPackets(const RMH_Handle handle, uint32_t *response)
Return the total number of packets transmitted by this node.
RMH_Interface_GetMac
RMH_Result RMH_Interface_GetMac(const RMH_Handle handle, RMH_MacAddress_t *response)
Return the MAC address associated with this MoCA device. [mocaIfMacAddress].
RMH_Stats_GetRxMapPackets
RMH_Result RMH_Stats_GetRxMapPackets(const RMH_Handle handle, uint32_t *response)
Return the number of MAP received by this node.
Mode
This class extents DSConstant to mange the front panel text display mode like time display mode or te...
RMH_Network_GetLinkDownCount
RMH_Result RMH_Network_GetLinkDownCount(const RMH_Handle handle, uint32_t *response)
Returns the number of times the MoCA link has gone down since the last boot [mocaIfLinkDownCount].
RMH_Power_GetSupportedModes
RMH_Result RMH_Power_GetSupportedModes(const RMH_Handle handle, uint32_t *response)
Return a bitmask of RMH_PowerMode indicating all MoCA power modes supported by this device mocaIfPowe...
RMH_Network_GetNCNodeId
RMH_Result RMH_Network_GetNCNodeId(const RMH_Handle handle, uint32_t *response)
Return the node ID of the network coordinator. [mocaIfNC].
RMH_Interface_SetMac
RMH_Result RMH_Interface_SetMac(const RMH_Handle handle, const RMH_MacAddress_t value)
Set the MAC address associated with this MoCA device.
RMH_RemoteNode_GetTxUnicastSubcarrierModulation
RMH_Result RMH_RemoteNode_GetTxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile *responseArray, const size_t responseArraySize, size_t *responseArrayUsed)
Return the unicast transmit subcarrier modulation profiles for the primary MoCA channel.
RMH_Self_GetSupportedBand
RMH_Result RMH_Self_GetSupportedBand(const RMH_Handle handle, RMH_Band *response)
Return the band supported by the MoCA device. [mocaIfSupportedBands].
RMH_PowerModeToString
const char *const RMH_PowerModeToString(const uint32_t value, char *responseBuf, const size_t responseBufSize)
The input value should be a a bitmask of type RMH_PowerMode.
Definition: librmh_api_no_wrap.c:162
RMH_Stats_GetRxBroadcastPackets
RMH_Result RMH_Stats_GetRxBroadcastPackets(const RMH_Handle handle, uint32_t *response)
Return the number of broadcast packets received by this node.
RMH_ResultToString
const char *const RMH_ResultToString(const RMH_Result value)
Convert RMH_Result to a string.
Definition: librmh_api_no_wrap.c:84
RMH_Self_SetTxPowerLimit
RMH_Result RMH_Self_SetTxPowerLimit(const RMH_Handle handle, const int32_t value)
Set the maximum transmitter power level for this device.
RMH_Stats_GetRxTotalPackets
RMH_Result RMH_Stats_GetRxTotalPackets(const RMH_Handle handle, uint32_t *response)
Return the total number of packets received by this node.
RMH_Self_GetPrivacyEnabled
RMH_Result RMH_Self_GetPrivacyEnabled(const RMH_Handle handle, bool *response)
Return if MoCA privacy is enabled on this device.
RMH_Self_GetMaxPacketAggregation
RMH_Result RMH_Self_GetMaxPacketAggregation(const RMH_Handle handle, uint32_t *response)
Get the maximum number of packets this device will aggregate.
RMH_ACA_GetSourceNodeId
RMH_Result RMH_ACA_GetSourceNodeId(const RMH_Handle handle, uint32_t *response)
Return the Node ID of the source node for the last requested ACA. [mocaIfAcaNodeID].
RMH_Self_GetPrimaryChannelOffset
RMH_Result RMH_Self_GetPrimaryChannelOffset(const RMH_Handle handle, int32_t *response)
TBD [mocaIfPrimaryChannelOffset].
RMH_ACA_Request
RMH_Result RMH_ACA_Request(const RMH_Handle handle, const uint32_t channelNum, const uint32_t sourceNodeId, const uint32_t destinationNodeMask, const RMH_ACAType type)
Print a summary of the sub carrier modulation bitloading information.
RMH_Log_SetAPILevel
RMH_Result RMH_Log_SetAPILevel(const RMH_Handle handle, const uint32_t value)
Set the log level of the RMH library.
RMH_SubcarrierProfileToString
const char *const RMH_SubcarrierProfileToString(const RMH_SubcarrierProfile value)
Convert RMH_SubcarrierProfile to a string.
Definition: librmh_api_no_wrap.c:112
RMH_Self_GetMoCALinkUp
RMH_Result RMH_Self_GetMoCALinkUp(const RMH_Handle handle, bool *response)
Check if this device is actively connected to a MoCA network. If so, RMH_Network and RMH_Remote APIs ...
RMH_RemoteNode_GetAssociatedIdFromNodeId
RMH_Result RMH_RemoteNode_GetAssociatedIdFromNodeId(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
Convert a node Id into an associated Id.
RMH_SetEventCallbacks
RMH_Result RMH_SetEventCallbacks(RMH_Handle handle, const uint32_t value)
Set the list of callbacks you wish to receive.
RMH_Destroy
RMH_Result RMH_Destroy(RMH_Handle handle)
Destroy the instance of RMH library which was created by RMH_Initialize.
RMH_RemoteNode_GetTxPowerReduction
RMH_Result RMH_RemoteNode_GetTxPowerReduction(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
The transmit power control back-off used for transmissions from the specified nodeId.
RMH_Self_GetTabooChannels
RMH_Result RMH_Self_GetTabooChannels(const RMH_Handle handle, uint32_t *channelMaskStart, uint32_t *channelMask)
Return which channels will be taboo on this device.
Get
Definition: AampcliGet.h:38
RMH_Network_GetBitLoadingInfo
RMH_Result RMH_Network_GetBitLoadingInfo(const RMH_Handle handle, RMH_NodeMesh_Uint32_t *response)
Returns the bit loading information.
RMH_Self_SetPrivacyEnabled
RMH_Result RMH_Self_SetPrivacyEnabled(const RMH_Handle handle, const bool value)
Enable or disable MoCA privacy on this device.
RMH_RemoteNode_GetTxUnicastPhyRate
RMH_Result RMH_RemoteNode_GetTxUnicastPhyRate(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
Return the PHY rate at which unicast packets are transmitted from nodeId to the self node.
RMH_Self_RestoreDefaultSettings
RMH_Result RMH_Self_RestoreDefaultSettings(const RMH_Handle handle)
Return this device to its default configuration.
RMH_Self_SetQAM256Enabled
RMH_Result RMH_Self_SetQAM256Enabled(const RMH_Handle handle, const bool value)
Enable or disable the QAM256 ability in admission negotiations.
RMH_RemoteNode_GetTxPackets
RMH_Result RMH_RemoteNode_GetTxPackets(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
Return the total number of packets nodeId has transmitted.
RMH_Stats_GetRxLinkControlPackets
RMH_Result RMH_Stats_GetRxLinkControlPackets(const RMH_Handle handle, uint32_t *response)
Return the number of link control received by this node.
RMH_RemoteNode_GetMaxFrameSize
RMH_Result RMH_RemoteNode_GetMaxFrameSize(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
The maximum number of bytes this node can receive in one frame (aggregated transmission).
RMH_Self_SetEnabledRDK
RMH_Result RMH_Self_SetEnabledRDK(const RMH_Handle handle)
Enable MoCA using RDK specific configuration.
RMH_PQoS_GetMaxEgressBandwidth
RMH_Result RMH_PQoS_GetMaxEgressBandwidth(const RMH_Handle handle, uint32_t *response)
Return the node Id with the maximum available bandwidth.
RMH_PQoSFlow_GetLeaseTime
RMH_Result RMH_PQoSFlow_GetLeaseTime(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the lease time in seconds for the flow specified by flowId.
RMH_Log_PrintFlows
RMH_Result RMH_Log_PrintFlows(const RMH_Handle handle, const char *filename)
Print a generic status summary of the MoCA flows.
RMH_Self_GetFrequencyMask
RMH_Result RMH_Self_GetFrequencyMask(const RMH_Handle handle, uint32_t *response)
Gets the bit mask of frequencies the device used during the listening phase of network search.
RMH_PQoSFlow_GetPeakDataRate
RMH_Result RMH_PQoSFlow_GetPeakDataRate(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the peak data rate in Kbps for the flow specified by flowId.
RMH_PQoSFlow_GetDFID
RMH_Result RMH_PQoSFlow_GetDFID(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the destination flow ID of the flow specified by flowId.
RMH_Stats_GetRxUnknownProtocolPackets
RMH_Result RMH_Stats_GetRxUnknownProtocolPackets(const RMH_Handle handle, uint32_t *response)
Return the number of unknown packets received by this node.
RMH_PQoSFlow_GetIngressMac
RMH_Result RMH_PQoSFlow_GetIngressMac(const RMH_Handle handle, const RMH_MacAddress_t flowId, RMH_MacAddress_t *response)
Return the ingress MAC address of the flow specified by flowId.
RMH_PQoSFlow_GetFlowTag
RMH_Result RMH_PQoSFlow_GetFlowTag(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the tag for the flow specified by flowId. This is optional for application use.
RMH_Stats_GetRxTimeoutErrors
RMH_Result RMH_Stats_GetRxTimeoutErrors(const RMH_Handle handle, uint32_t *response)
Return the total number of packets this node has received with timeout errors.
Set
Definition: AampcliSet.h:42
RMH_ACA_GetDestinationNodeMask
RMH_Result RMH_ACA_GetDestinationNodeMask(const RMH_Handle handle, uint32_t *response)
Return the bitmask of the destination nodes for the last requested ACA. [mocaIfAcaReportNodeMask].
RMH_Log_GetAPILevel
RMH_Result RMH_Log_GetAPILevel(const RMH_Handle handle, uint32_t *response)
Return a bitmask of RMH_LogLevel which indicates the currently enabled RMH log types in the RMH libra...
RMH_Stats_GetRxPacketAggregation
RMH_Result RMH_Stats_GetRxPacketAggregation(const RMH_Handle handle, uint32_t *responseArray, const size_t responseArraySize, size_t *responseArrayUsed)
Return an array indicating the number of packets received per aggregation number.
RMH_PQoS_GetEgressBandwidth
RMH_Result RMH_PQoS_GetEgressBandwidth(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
Return the amount of egress bandwidth available on a particular node.
RMH_Self_GetEnabled
RMH_Result RMH_Self_GetEnabled(const RMH_Handle handle, bool *response)
Return if the MoCA driver is actively connected to or attempting to connect to a MoCA network.
RMH_Log_PrintStatus
RMH_Result RMH_Log_PrintStatus(const RMH_Handle handle, const char *filename)
Print a generic status summary of the MoCA device and network.
RMH_Self_SetPrimaryChannelOffset
RMH_Result RMH_Self_SetPrimaryChannelOffset(const RMH_Handle handle, const int32_t value)
TBD [mocaIfSecondaryChannelOffset].
RMH_Self_SetLowBandwidthLimit
RMH_Result RMH_Self_SetLowBandwidthLimit(const RMH_Handle handle, const uint32_t value)
Set the lower threshold for the PHY link bandwidth between two nodes.
RMH_Stats_GetRxCorrectedErrors
RMH_Result RMH_Stats_GetRxCorrectedErrors(const RMH_Handle handle, RMH_NodeList_Uint32_t *response)
Return the number of received packets from every node with errors which were corrected.
RMH_Stats_GetRxReservationRequestPackets
RMH_Result RMH_Stats_GetRxReservationRequestPackets(const RMH_Handle handle, uint32_t *response)
Return the number of reservation request packets received by this node.
RMH_Self_GetMaxFrameSize
RMH_Result RMH_Self_GetMaxFrameSize(const RMH_Handle handle, uint32_t *response)
The maximum number of bytes this node can receive in one frame.
RMH_Network_GetPrimaryChannelFreq
RMH_Result RMH_Network_GetPrimaryChannelFreq(const RMH_Handle handle, uint32_t *response)
Return the primary MoCA 2.0 channel.
RMH_Log_PrintStats
RMH_Result RMH_Log_PrintStats(const RMH_Handle handle, const char *filename)
Print a summary of of the Tx/Rx MoCA status.
RMH_PQoSFlow_GetEgressMac
RMH_Result RMH_PQoSFlow_GetEgressMac(const RMH_Handle handle, const RMH_MacAddress_t flowId, RMH_MacAddress_t *response)
Return the egress MAC address of the flow specified by flowId.
RMH_EventToString
const char *const RMH_EventToString(const uint32_t value, char *responseBuf, const size_t responseBufSize)
Return the bitmask value as a string.
Definition: librmh_api_no_wrap.c:170
RMH_RemoteNode_GetBondingCapable
RMH_Result RMH_RemoteNode_GetBondingCapable(const RMH_Handle handle, const uint32_t nodeId, bool *response)
Return if the node indicated by nodeId is bonding capable enabled or not.
RMH_Self_SetTurboEnabled
RMH_Result RMH_Self_SetTurboEnabled(const RMH_Handle handle, const bool value)
Enable or disable turbo mode on this device.
RMH_Network_GetTxMapPhyRate
RMH_Result RMH_Network_GetTxMapPhyRate(const RMH_Handle handle, uint32_t *response)
Return the PHY rate at which MAP packets are transmitted from this node.
RMH_Self_GetQAM256TargetPhyRate
RMH_Result RMH_Self_GetQAM256TargetPhyRate(const RMH_Handle handle, uint32_t *response)
Get the target PHY rate in Mbps.
RMH_Stats_GetRxUnicastPackets
RMH_Result RMH_Stats_GetRxUnicastPackets(const RMH_Handle handle, uint32_t *response)
Return the number of unicast packets received by this node.
RMH_Self_GetLastResetReason
RMH_Result RMH_Self_GetLastResetReason(const RMH_Handle handle, RMH_MoCAResetReason *response)
Return the reason for the most recent link reset [mocaIfResetReason].
RMH_PQoSFlow_GetPacketSize
RMH_Result RMH_PQoSFlow_GetPacketSize(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the packet size in bytes of the flow specified by flowId.
RMH_Interface_GetName
RMH_Result RMH_Interface_GetName(const RMH_Handle handle, char *responseBuf, const size_t responseBufSize)
Return the Linux interface name associated with the MoCA device. [mocaIfName].
RMH_Self_GetLOF
RMH_Result RMH_Self_GetLOF(const RMH_Handle handle, uint32_t *response)
The last frequency on which this device operated.
RMH_Log_PrintModulation
RMH_Result RMH_Log_PrintModulation(const RMH_Handle handle, const char *filename)
Print a summary of the sub carrier modulation bitloading information.
RMH_RemoteNode_GetRxSNR
RMH_Result RMH_RemoteNode_GetRxSNR(const RMH_Handle handle, const uint32_t nodeId, float *response)
The signal to noise ratio of nodeId based on the Type 1 probe from per node.
RMH_Network_GetRemoteNodeIds
RMH_Result RMH_Network_GetRemoteNodeIds(const RMH_Handle handle, RMH_NodeList_Uint32_t *response)
Return a list of every node ID on the network.
RMH_Network_GetMoCAVersion
RMH_Result RMH_Network_GetMoCAVersion(const RMH_Handle handle, RMH_MoCAVersion *response)
Return the version of MoCA under which the network is operating. [mocaIfNetworkVersion].
RMH_Network_GetTxBroadcastPhyRate
RMH_Result RMH_Network_GetTxBroadcastPhyRate(const RMH_Handle handle, uint32_t *response)
Return the PHY rate at which broadcast packets are transmitted from this node.
RMH_Network_GetResetCount
RMH_Result RMH_Network_GetResetCount(const RMH_Handle handle, uint32_t *response)
Returns the number of times the MoCA link has gone down since the last boot. [mocaIfResetCount].
RMH_RemoteNode_GetRxUnicastPower
RMH_Result RMH_RemoteNode_GetRxUnicastPower(const RMH_Handle handle, const uint32_t nodeId, float *response)
Return the power level at which unicast packets are received from nodeId from the self node.
RMH_PQoSFlow_GetLeaseTimeRemaining
RMH_Result RMH_PQoSFlow_GetLeaseTimeRemaining(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the lease time remaining in seconds for the flow specified by flowId.
RMH_PQoSFlow_GetDSCPMoCA
RMH_Result RMH_PQoSFlow_GetDSCPMoCA(const RMH_Handle handle, const RMH_MacAddress_t flowId, uint32_t *response)
Return the DSCP MoCA value for the flow specified by flowId.
TRUE
#define TRUE
Defines for TRUE/FALSE/ENABLE flags.
Definition: wifi_common_hal.h:199
RMH_RemoteNode_GetSecondaryTxUnicastSubcarrierModulation
RMH_Result RMH_RemoteNode_GetSecondaryTxUnicastSubcarrierModulation(const RMH_Handle handle, const uint32_t nodeId, const RMH_PERMode perMode, RMH_SubcarrierProfile *responseArray, const size_t responseArraySize, size_t *responseArrayUsed)
Return the unicast transmit subcarrier modulation profiles for the secondary MoCA channel.
RMH_Self_GetTxPowerLimit
RMH_Result RMH_Self_GetTxPowerLimit(const RMH_Handle handle, int32_t *response)
Returns the maximum transmitter power level for this device.
RMH_RemoteNode_GetMaxPacketAggregation
RMH_Result RMH_RemoteNode_GetMaxPacketAggregation(const RMH_Handle handle, const uint32_t nodeId, uint32_t *response)
Return the maximum number of packets for aggregated transmissions for the node indicated by nodeId.
RMH_Self_GetMaxAllocationElements
RMH_Result RMH_Self_GetMaxAllocationElements(const RMH_Handle handle, uint32_t *response)
Return the maximum number of allocation elements, excluding the TAUs and the Dummy DAUs,...
RMH_Self_SetSecondaryChannelOffset
RMH_Result RMH_Self_SetSecondaryChannelOffset(const RMH_Handle handle, const int32_t value)
TBD [mocaIfSecondaryChannelOffset].
Packet
Definition: SubtecPacket.hpp:31
RMH_Stats_GetTxLinkControlPackets
RMH_Result RMH_Stats_GetTxLinkControlPackets(const RMH_Handle handle, uint32_t *response)
Return the number of link control transmitted by this node.
RMH_RemoteNode_GetActiveMoCAVersion
RMH_Result RMH_RemoteNode_GetActiveMoCAVersion(const RMH_Handle handle, const uint32_t nodeId, RMH_MoCAVersion *response)
Return the active supported version of MoCA by the remote node specificed by nodeId.
RMH_ACAStatusToString
const char *const RMH_ACAStatusToString(const RMH_ACAStatus value)
Convert ACA status to a printable string.
Definition: librmh_api_no_wrap.c:104
RMH_ACATypeToString
const char *const RMH_ACATypeToString(const RMH_ACAType value)
Convert value to a printable string.
Definition: librmh_api_no_wrap.c:100
RMH_Self_GetPrivacyMACManagementKey
RMH_Result RMH_Self_GetPrivacyMACManagementKey(RMH_Handle handle, char *responseBuf, const size_t responseBufSize)
Get the SHA1 hash of the MoCA password as an ASCII string. [mocaIfPasswordHash].
RMH_Self_GetQAM256Enabled
RMH_Result RMH_Self_GetQAM256Enabled(const RMH_Handle handle, bool *response)
Return if this device is set as QAM256 capable in admission negotiations.