cm: New header file for private CM types/func declaration

This new file would hold types/function/macro definitions which are
private to the CM library and should not be exposed to the applications.

CM library is spread out in multiple files and there are cases when a
function/type which is defined in one file need to be exposed to another
file such that its not exposed to the applications.

Also includes:
* `CM_RETURN_ERROR` macro definition and definition of the `cm_err_num`
  global variable were moved to `kcmlib.h` since they are a private
  items.

Author: coderarjob

include/cm/err.h

@@ -24,22 +24,9 @@ typedef enum CMErrors {
     CM_ERR_EVENT_HANDLER_ALREADY_REGISTERED = 101,
 } CMErrors;
 
-extern uint32_t cm_error_num__;
-
-static inline uint32_t cm_get_lib_error()
-{
-    return cm_error_num__;
-}
+uint32_t cm_get_lib_error();
 
 static inline uint32_t cm_get_os_error()
 {
     return (uint32_t)syscall (OSIF_SYSCALL_GET_OS_ERROR, 0, 0, 0, 0, 0);
 }
-
-/* Can be used to store an error code and return from a function */
-#define CM_RETURN_ERROR__(errno, rval)     \
-    do {                                   \
-        CM_DBG_ERROR ("Error %x.", errno); \
-        cm_error_num__ = errno;            \
-        return rval;                       \
-    } while (0)

include/kcmlib.h

@@ -0,0 +1,22 @@
+/*
+ * ---------------------------------------------------------------------------
+ * Megha Operating System V2 - App library Kernel Header - Private type/function declarations
+ * ---------------------------------------------------------------------------
+ * Types and function declarations defined here are private to the CM library and should not be
+ * exposed to the applications.
+ */
+
+#include <intrusive_list.h>
+#include <memloc.h>
+
+#pragma once
+
+extern uint32_t cm_error_num;
+
+/* Can be used to store an error code and return from a function */
+#define CM_RETURN_ERROR(errno, rval)       \
+    do {                                   \
+        CM_DBG_ERROR ("Error %x.", errno); \
+        cm_error_num = errno;              \
+        return rval;                       \
+    } while (0)

src/cm/cm.c

@@ -8,12 +8,18 @@
 #include <cm/cm.h>
 #include <cm/syscall.h>
 #include <cm/debug.h>
+#include <kcmlib.h>
 
 /* Variable to store Library error*/
-uint32_t cm_error_num__;
+uint32_t cm_error_num;
 
 #define cm_MICRODEC_TO_TICK_COUNT(us) ((us) / cm_get_tick_period_us())
 
+/***************************************************************************************************
+ * Halts thread for 'ms' miliseconds
+ *
+ * @return      Nothing
+ **************************************************************************************************/
 void cm_delay (UINT ms)
 {
     UINT us = ms * 1000;
@@ -25,3 +31,13 @@ void cm_delay (UINT ms)
         cm_process_handle_events();
     }
 }
+
+/***************************************************************************************************
+ * Return the last library error
+ *
+ * @return      Last libcm error
+ **************************************************************************************************/
+uint32_t cm_get_lib_error()
+{
+    return cm_error_num;
+}

src/cm/process.c

@@ -9,6 +9,7 @@
 #include <cm/err.h>
 #include <cm/cm.h>
 #include <stdbool.h>
+#include <kcmlib.h>
 
 /***************************************************************************************************
  * Handling of process events
@@ -25,7 +26,7 @@ static cm_event_handler app_event_handlers[OSIF_PROCESS_EVENTS_COUNT] = { 0 };
 bool cm_process_register_event_handler (OSIF_ProcessEvents e, cm_event_handler h)
 {
     if (app_event_handlers[e] != NULL) {
-        CM_RETURN_ERROR__ (CM_ERR_EVENT_HANDLER_ALREADY_REGISTERED, false);
+        CM_RETURN_ERROR (CM_ERR_EVENT_HANDLER_ALREADY_REGISTERED, false);
     }
 
     app_event_handlers[e] = h;
@@ -43,7 +44,7 @@ bool cm_process_handle_events()
 {
     volatile OSIF_ProcessEvent e = { 0 };
     if (!cm_process_pop_event ((OSIF_ProcessEvent*)&e)) {
-        CM_RETURN_ERROR__ (cm_get_os_error(), false);
+        CM_RETURN_ERROR (cm_get_os_error(), false);
     }
 
     switch (e.event) {
@@ -71,7 +72,7 @@ bool cm_process_handle_events()
 INT cm_process_create (const char* const filename, bool isKernelMode)
 {
     if (filename == NULL) {
-        CM_RETURN_ERROR__ (CM_ERR_INVALID_INPUT, CM_FAILURE);
+        CM_RETURN_ERROR (CM_ERR_INVALID_INPUT, CM_FAILURE);
     }
 
     KProcessFlags flags = PROCESS_FLAGS_NONE;
@@ -85,15 +86,15 @@ INT cm_process_create (const char* const filename, bool isKernelMode)
     INT pid = syscall (OSIF_SYSCALL_CREATE_PROCESS, (U32)file.startLocation, file.length,
                        (U32)flags, 0, 0);
     if (pid < 0) {
-        CM_RETURN_ERROR__ (cm_get_os_error(), CM_FAILURE);
+        CM_RETURN_ERROR (cm_get_os_error(), CM_FAILURE);
     }
     return pid;
 }
 
 INT cm_thread_create (void (*startLocation)(), bool isKernelMode)
 {
     if (!startLocation) {
-        CM_RETURN_ERROR__ (CM_ERR_INVALID_INPUT, CM_FAILURE);
+        CM_RETURN_ERROR (CM_ERR_INVALID_INPUT, CM_FAILURE);
     }
 
     KProcessFlags flags = PROCESS_FLAGS_THREAD;
@@ -103,7 +104,7 @@ INT cm_thread_create (void (*startLocation)(), bool isKernelMode)
 
     INT pid = syscall (OSIF_SYSCALL_CREATE_PROCESS, (U32)startLocation, 0, (U32)flags, 0, 0);
     if (pid < 0) {
-        CM_RETURN_ERROR__ (cm_get_os_error(), CM_FAILURE);
+        CM_RETURN_ERROR (cm_get_os_error(), CM_FAILURE);
     }
     return pid;
 }