Telecominfraproject/OpenCellular
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenCellular.git synced 2026-01-27 10:22:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #249 from Telecominfraproject/ocware_alert_host

Browse Source 
Host code for alert
This commit is contained in:
swateeshrivastava
2019-03-05 17:00:57 +05:30
committed by GitHub
parent eb22ea8c55 a9af083880
commit 34ff2e9b3b
18 changed files with 2655 additions and 774 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
firmware/ec/platform/oc-sdr/schema/auto_schema.c
View File

@@ -141,6 +141,7 @@ SCHEMA_IMPORT const DriverStruct fact_sdr_fpga_adt7481_cfg;
SCHEMA_IMPORT const DriverStruct fact_sdr_fpga_ps_cfg;
SCHEMA_IMPORT const DriverStruct fact_sync_ts_cfg;
SCHEMA_IMPORT bool alert_log(void *, void *);
SCHEMA_IMPORT bool GPP_ap_Reset(void *, void *);
SCHEMA_IMPORT bool gpp_post_init(void *, void *);
SCHEMA_IMPORT bool gpp_pre_init(void *, void *);
@@ -167,7 +168,6 @@ const Component sys_schema[] = {
.name = "system",
.driver_cfg = &gbc_spi_flash_memory,
.ssHookSet = &(SSHookSet) {
.preInitFxn = NULL,
.postInitFxn = (ssHook_Cb)sys_post_init,
},
.components = (Component[]) {
@@ -206,6 +206,10 @@ const Component sys_schema[] = {
.name = "echo",
.cb_cmd = SYS_cmdEcho,
},
{
.name = "getAlertLogs",
.cb_cmd = alert_log,
},
{}
},
},
@@ -226,6 +230,13 @@ const Component sys_schema[] = {
},
{}
},
.commands = (Command[]) {
{
.name = "getAlertLogs",
.cb_cmd = alert_log,
},
{}
},
},
{
.name = "leadacid_sensor",
@@ -283,6 +294,13 @@ const Component sys_schema[] = {
{
.name = "comp_all",
.postDisabled = POST_DISABLED,
.commands = (Command[]) {
{
.name = "getAlertLogs",
.cb_cmd = alert_log,
},
{}
},
},
{
.name = "ec",
@@ -321,6 +339,13 @@ const Component sys_schema[] = {
{
.name = "comp_all",
.postDisabled = POST_DISABLED,
.commands = (Command[]) {
{
.name = "getAlertLogs",
.cb_cmd = alert_log,
},
{}
},
},
{
.name = "led",
@@ -354,6 +379,13 @@ const Component sys_schema[] = {
{
.name = "comp_all",
.postDisabled = POST_DISABLED,
.commands = (Command[]) {
{
.name = "getAlertLogs",
.cb_cmd = alert_log,
},
{}
},
},
{
.name = "port0",
@@ -409,6 +441,13 @@ const Component sys_schema[] = {
{
.name = "comp_all",
.postDisabled = POST_DISABLED,
.commands = (Command[]) {
{
.name = "getAlertLogs",
.cb_cmd = alert_log,
},
{}
},
},
{
.name = "ap",
@@ -445,6 +484,10 @@ const Component sys_schema[] = {
.name = "reset",
.cb_cmd = GPP_ap_Reset,
},
{
.name = "getAlertLogs",
.cb_cmd = alert_log,
},
{}
},
},
@@ -493,6 +536,10 @@ const Component sys_schema[] = {
.name = "reset",
.cb_cmd = SDR_reset,
},
{
.name = "getAlertLogs",
.cb_cmd = alert_log,
},
{}
},
},
@@ -554,6 +601,10 @@ const Component sys_schema[] = {
.name = "reset",
.cb_cmd = RFFE_reset,
},
{
.name = "getAlertLogs",
.cb_cmd = alert_log,
},
{}
},
},
@@ -708,6 +759,10 @@ const Component sys_schema[] = {
.name = "reset",
.cb_cmd = SYNC_reset,
},
{
.name = "getAlertLogs",
.cb_cmd = alert_log,
},
{}
},
.postDisabled = POST_DISABLED,

1418
firmware/ec/platform/oc-sdr/schema/sys_schema.json
View File

File diff suppressed because it is too large Load Diff

80
firmware/host/include/logger.h
View File

@@ -12,44 +12,66 @@
#include <syslog.h>
#include <libgen.h>
#define __filename__ (basename(__FILE__))
#define __filename__ (basename(__FILE__))
#ifdef CONSOLE_LOG
#define logit(facility, fmt, ...) \
{ \
if(facility != LOG_DEBUG) \
printf(fmt "\n", ##__VA_ARGS__); \
else \
printf ("[%s:%d, %s()]:" fmt "\n", __filename__, \
__LINE__, __func__, ##__VA_ARGS__); \
}
#else /* syslog */
#define logit(facility, fmt, ...) \
{ \
if(facility != LOG_DEBUG) \
syslog(facility, fmt "\n", ##__VA_ARGS__); \
else \
syslog(facility, "<d> [%s:%d, %s()]: " fmt "\n", \
__filename__, __LINE__, __func__, ##__VA_ARGS__); \
}
# define logit(facility, fmt, ...) \
{ \
if (facility != LOG_DEBUG) \
printf(fmt "\n", ##__VA_ARGS__); \
else \
printf("[%s:%d, %s()]:" fmt "\n", __filename__, __LINE__, \
__func__, ##__VA_ARGS__); \
}
#elif SYS_LOG /* syslog */
# define logit(facility, fmt, ...) \
{ \
if (facility != LOG_DEBUG) \
syslog(facility, fmt "\n", ##__VA_ARGS__); \
else \
syslog(facility, "<d> [%s:%d, %s()]: " fmt "\n", __filename__, \
__LINE__, __func__, ##__VA_ARGS__); \
}
#elif OCCLI_LOG
# define logit(facility, fmt, ...) \
{ \
FILE *fp; \
fp = fopen("./log/logFileOccli.txt", "a"); \
if (facility != LOG_DEBUG) \
fprintf(fp, fmt "\n", ##__VA_ARGS__); \
else \
fprintf(fp, "[%s:%d, %s()]:" fmt "\n", __filename__, __LINE__, \
__func__, ##__VA_ARGS__); \
fclose(fp); \
}
#else
# define logit(facility, fmt, ...) \
{ \
FILE *fp; \
fp = fopen("./log/logFileMW.txt", "a"); \
if (facility != LOG_DEBUG) \
fprintf(fp, fmt "\n", ##__VA_ARGS__); \
else \
fprintf(fp, "[%s:%d, %s()]:" fmt "\n", __filename__, __LINE__, \
__func__, ##__VA_ARGS__); \
fclose(fp); \
}
#endif
#define logemerg(fmt, ...) logit(LOG_EMERG, "<E> " fmt, ##__VA_ARGS__)
#define logalert(fmt, ...) logit(LOG_ALERT, "<A> " fmt, ##__VA_ARGS__)
#define logcrit(fmt, ...) logit(LOG_CRIT, "<C> " fmt, ##__VA_ARGS__)
#define logerr(fmt, ...) logit(LOG_ERR, "<e> " fmt, ##__VA_ARGS__)
#define logwarn(fmt, ...) logit(LOG_WARNING, "<w> " fmt, ##__VA_ARGS__)
#define lognotice(fmt, ...) logit(LOG_NOTICE, "<n> " fmt, ##__VA_ARGS__)
#define loginfo(fmt, ...) logit(LOG_INFO, "<i> " fmt, ##__VA_ARGS__)
#define logdebug(fmt, ...) logit(LOG_DEBUG, fmt, ##__VA_ARGS__)
#define logemerg(fmt, ...) logit(LOG_EMERG, "<E> " fmt, ##__VA_ARGS__)
#define logalert(fmt, ...) logit(LOG_ALERT, "<A> " fmt, ##__VA_ARGS__)
#define logcrit(fmt, ...) logit(LOG_CRIT, "<C> " fmt, ##__VA_ARGS__)
#define logerr(fmt, ...) logit(LOG_ERR, "<e> " fmt, ##__VA_ARGS__)
#define logwarn(fmt, ...) logit(LOG_WARNING, "<w> " fmt, ##__VA_ARGS__)
#define lognotice(fmt, ...) logit(LOG_NOTICE, "<n> " fmt, ##__VA_ARGS__)
#define loginfo(fmt, ...) logit(LOG_INFO, "<i> " fmt, ##__VA_ARGS__)
#define logdebug(fmt, ...) logit(LOG_DEBUG, fmt, ##__VA_ARGS__)
/*
* @param ident an input value (by pointer)
*
*/
extern void initlog(const char* ident);
extern void initlog(const char *ident);
/*
* deinitialize the logging routine
*

17
firmware/host/include/occli_common.h
View File

@@ -16,7 +16,7 @@
#define HIT_FILE_BUFF_SIZE 50
#define OCCLI_STRING_SIZE 128
#define RES_STR_BUFF_SIZE 10000
#define RES_STR_BUFF_SIZE 100000
#define OCMP_MAX_SIZE 10
#define OCCLI_CHAR_ARRAY_SIZE 30
#define OCMW_MAX_SUBSYSTEM 11
@@ -119,8 +119,7 @@ extern int32_t occli_recv_alertmsg_from_ocmw(char *resp, int32_t resplen);
*
* @return true if function succeeds, false otherwise
*/
extern int32_t ocmw_parse_msgframe(const Component *root,
strMsgFrame *msgFrame,
extern int32_t ocmw_parse_msgframe(const Component *root, strMsgFrame *msgFrame,
uint8_t actiontype,
ocmwSchemaSendBuf *ecSendBuf);
/*
@@ -186,9 +185,19 @@ extern void ocmw_free_global_pointer(void **ptr);
*
* @return true if function succeeds, false otherwise
*/
extern int8_t occli_printHelpMenu(const Component *root,char *cmd);
extern int8_t occli_printHelpMenu(const Component *root, char *cmd);
/*Display CLI window*/
extern void occli_print_opencelluar();
/*
* @param root an output value (by pointer)
* @param systemInfo an output value (by pointer)
*
* @return true if function succeeds, false otherwise
*/
extern void ocmw_handle_alert_msg(const Component *compBase,
OCMPMessageFrame *ecReceivedMsg,
int8_t *alertRecord);
#endif /* _OCCLI_COMM_H_ */

2
firmware/host/include/ocmw_core.h
View File

@@ -21,7 +21,7 @@ sem_t semCommandPost;
#define OCMW_BUSY_WAIT_INDEX 0
#define OCMW_TIMED_WAIT_INDEX 1
#define PARAM_STR_MAX_BUFF_SIZE 100
#define ALERT_MAX_BUFF_SIZE 400
extern int32_t ocmw_init();
/*
* @param actionType an input enum value (by value)

29
firmware/host/include/ocmw_helper.h
View File

@@ -39,6 +39,9 @@
#define PARAM_STR_BUFF_SIZE 100
#define PARAM_TYPE_BUFF_SIZE 32
#define OCMW_ALERT_ACTION_SIZE 12
#define OCMW_ALERT_DATE_SIZE 24
#define OCMW_ALERT_STRING_SIZE 64
#define OCMW_MAX_SUBSYSTEM_SIZE 16
#define OCMW_MAX_ACTION_SIZE 16
#define OCMW_MAX_MSGTYPE_SIZE 16
@@ -117,6 +120,24 @@ typedef struct {
char desc[OCMW_POST_DESC_SIZE]; /* Device description */
} ocwarePostReplyCode;
typedef struct alertevent {
char string[OCMW_ALERT_STRING_SIZE]; /* alert string */
char action[OCMW_ALERT_ACTION_SIZE]; /* ACTIVE / CLEAR */
char value[OCMW_ALERT_STRING_SIZE];
} alertevent;
typedef struct allAlertEvent {
char string[OCMW_ALERT_STRING_SIZE]; /* alert string */
char action[OCMW_ALERT_ACTION_SIZE]; /* ACTIVE / CLEAR */
char datetime[OCMW_ALERT_DATE_SIZE]; /* YYYY-MM-DD hh:mm:ss */
char value[OCMW_ALERT_STRING_SIZE];
char actualValue[OCMW_ALERT_STRING_SIZE];
} allAlertEvent;
typedef struct alertlist {
uint16_t nalerts; /* Number of alerts */
struct allAlertEvent *list; /* Alert list */
} alertlist;
/*
* @param sem an input value (by pointer)
*
@@ -170,4 +191,12 @@ extern int32_t ocmw_parse_obc_from_ec(ocmwSendRecvBuf ecInputData);
* @return true if function succeeds, false otherwise
*/
extern int32_t ocmw_parse_testingmodule_from_ec(ocmwSendRecvBuf ecInputData);
/*
* @param msgaction an input value (by value)
* @param msgtype an input value (by value)
* @param paramstr an input string (by pointer)
* @param paramvalue an input value (by pointer)
*
*/
extern int32_t ocmw_handle_show_alerts(char *response);
#endif /* _OCMW_HELPER_H_ */

7
firmware/host/include/ocmw_occli_comm.h
View File

@@ -13,9 +13,11 @@
#define PARAMSTR_NUMBER_LEN 12
#define TESTMOD_MAX_LEN 16
#define RES_STR_BUFF_SIZE 10000
#define RES_STR_BUFF_SIZE 100000
#define RES_ALERT_STR_BUFF_SIZE 1000
#define TEMP_STR_BUFF_SIZE 100
#define ALERT_STR_BUFF_SIZE 128
#define FINAL_STR_BUFF_SIZE 100
#define ALERT_STR_BUFF_SIZE 200
#define CMD_STR_BUFF_SIZE 100
#define OCMW_MAX_IMEI_SIZE 15
#define OCMW_MAX_MSG_SIZE 20
@@ -62,6 +64,7 @@ typedef enum {
EPKTGEN_STR,
DPKTGEN_STR,
ECLIENT_STR,
ALERTLOG_STR,
MAX_STR
} ocmw_token_t;

1
firmware/host/include/ocmw_schema.h
View File

@@ -1,5 +1,6 @@
/* OC Includes */
#include <occli_common.h>
#include <ocmw_core.h>
#ifndef _OCMW_SCHEMA_H_
#define _OCMW_SCHEMA_H_

60
firmware/host/include/ocware_stub_main_module.h
View File

@@ -116,6 +116,15 @@ typedef enum ocware_ret{
STUB_SUCCESS = 0
} ocware_stub_ret;
typedef struct {
uint8_t subsystemId;
uint8_t componentId;
uint8_t msgtype;
uint16_t paramId;
uint8_t paramSize;
uint8_t datatype;
void *data;
} OCWareStubAlertData;
extern int8_t debugGetCommand;
extern int8_t debugSetCommand;
@@ -142,7 +151,8 @@ extern ocware_stub_ret ocware_stub_parse_post_get_message(char *buffer);
* @return STUB_SUCCESS - for success
* STUB_FAILED - for failure
******************************************************************************/
extern ocware_stub_ret ocware_stub_parse_command_message(char *buffer);
extern ocware_stub_ret ocware_stub_parse_command_message(char *buffer,
uint8_t *alertFlag);
/******************************************************************************
* Function Name : ocware_stub_get_set_params
@@ -262,5 +272,53 @@ extern ocware_stub_ret ocware_stub_parse_debug_actiontype(OCMPMessage *msgFrameD
******************************************************************************/
extern ocware_stub_ret ocware_stub_get_post_database(OCMPMessage *msgFrameData,
char *payload);
/******************************************************************************
* Function Name : ocware_stub_parse_alert_get_message
* Description : Parse alert messages from MW
*
* @param buffer - output pointer to the message from MW
* index - index for record
*
* @return STUB_SUCCESS - for success
* STUB_FAILED - for failure
******************************************************************************/
extern ocware_stub_ret ocware_stub_parse_alert_get_message(char *buffer,
int8_t index);
/******************************************************************************
* Function Name : ocware_stub_get_alert_database
* Description : extract alert data from lookup table
*
* @param msgFrameData - output pointer to the OCMPheader field of the message
* from MW (by reference)
* @param payload - output pointer to the payload field of the message from MW
*
* @return STUB_SUCCESS - for success
* STUB_FAILED - for failure
******************************************************************************/
extern ocware_stub_ret ocware_stub_get_alert_database(OCMPMessage *msgFrameData,
char *payload,
int8_t index);
/******************************************************************************
* Function Name : ocware_stub_parse_command_from_schema
* Description : parse command from schema
*
* @param msgFrameData - pointer to the OCMPheader field of the message
* from MW (by reference)
*
* @return tempAlertFlag
******************************************************************************/
extern uint8_t ocware_stub_parse_command_from_schema(OCMPMessage *msgFrameData);
/******************************************************************************
* Function Name : ocware_stub_frame_alert_msgframe
* Description : extract alert data from based on subsystem
*
* @param msgFrameData - output pointer to the OCMPheader field of the message
* from MW (by reference)
* @param payload - output pointer to the payload field of the message from MW
*
* @return STUB_SUCCESS - for success
* STUB_FAILED - for failure
******************************************************************************/
extern ocware_stub_ret ocware_stub_frame_alert_msgframe(char *buffer);
#endif /* __OCMW_STUB_H__ */

17
firmware/host/occli/occli_main.c
View File

@@ -328,8 +328,6 @@ static int8_t occli_strjoin(char **deststrPtr, const char *srcstr,
/* strcat the new string */
strcat(*deststrPtr, srcstr);
logdebug("*deststrPtr='%s'", *deststrPtr);
return SUCCESS;
}
@@ -371,6 +369,9 @@ int8_t occli_parse_cliString(char *cliString)
char tempStr[OCCLI_STRING_MAX_LEN] = {0};
char *token = NULL;
if (cliString == NULL) {
return ret;
}
strcpy(tempStr, cliString);
token = strtok(tempStr, " ");
@@ -735,6 +736,11 @@ int32_t main(int32_t argc, char *argv[])
return FAILED;
}
ret = pthread_create(&alertThreadId, NULL,
occli_alertthread_messenger_to_ocmw, NULL);
if (ret != 0) {
return ret;
}
/* Execute the OC command (argv[1:]) and exit */
if (strcmp("occmd", basename(argv[0])) == 0) {
for (index= 1; index < argc; index++) {
@@ -752,7 +758,6 @@ int32_t main(int32_t argc, char *argv[])
}
if (cmdstr != NULL) {
logdebug("cmdstr='%s'", cmdstr);
occli_send_cmd_to_ocmw(cmdstr, strlen(cmdstr));
memset(response, 0, sizeof(response));
occli_recv_cmd_resp_from_ocmw(response, sizeof(response));
@@ -765,12 +770,6 @@ int32_t main(int32_t argc, char *argv[])
}
/* Entering interactive CLI */
else if (strcmp("occli", basename(argv[0])) == 0) {
ret = pthread_create(&alertThreadId, NULL,
occli_alertthread_messenger_to_ocmw, NULL);
if (ret != 0) {
return ret;
}
/* Initialize readline */
using_history();

151
firmware/host/ocmw/ocmw_clicmd.c
View File

@@ -36,6 +36,8 @@ extern uint8_t ocwarePostArrayIndex;
debugI2CData I2CInfo;
debugMDIOData MDIOInfo;
ethTivaClient clientInfo;
int8_t alertFlag = 0;
alertlist alerts;
struct matchString {
const char *key;
@@ -59,6 +61,7 @@ struct matchString {
{ "en_pktGen", EPKTGEN_STR },
{ "dis_pktGen", DPKTGEN_STR },
{ "en_tivaClient", ECLIENT_STR },
{ "getAlertLogs", ALERTLOG_STR },
{ NULL, MAX_STR },
};
@@ -199,6 +202,129 @@ int32_t ocmw_check_numeric_number(char *numstring)
}
return SUCCESS;
}
/**************************************************************************
* Function Name : ocmw_frame_alert_response
* Description : This Function used to frame alert response
* Input(s) : alerts
* Output(s) : response
***************************************************************************/
int32_t ocmw_frame_alert_response(char *response)
{
int32_t index = 0;
char alertstr[ALERT_MAX_BUFF_SIZE] = {0};
if (response == NULL) {
logerr("%s(): NULL pointer error", __func__);
return FAILED;
}
strncpy(response,
"-------------------------------------------------------"
"------------------------------------------------\n",
ALERT_STR_BUFF_SIZE);
if (snprintf(alertstr, ALERT_STR_BUFF_SIZE, "%-52s%-19s%-8s%-7s%-5s\n",
"ALERT DESCRIPTION", "TIME", "STATUS", "LIMIT",
"ACTUAL_VALUE") < 0) {
return FAILED;
}
strncat(response, alertstr, ALERT_STR_BUFF_SIZE);
if ((snprintf(alertstr, ALERT_STR_BUFF_SIZE,
"-----------------------------------------------------------"
"--------------------------------------------\n")) < 0) {
return FAILED;
}
strncat(response, alertstr, ALERT_STR_BUFF_SIZE);
for (index = 0; index < alerts.nalerts + 1; index++) {
if (snprintf(alertstr, ALERT_STR_BUFF_SIZE, "%-52s%-19s%-8s%-7s%-5s\n",
alerts.list[index].string, alerts.list[index].datetime,
alerts.list[index].action, alerts.list[index].value,
alerts.list[index].actualValue) < 0) {
return FAILED;
}
strncat(response, alertstr, ALERT_STR_BUFF_SIZE);
}
if ((snprintf(alertstr, ALERT_STR_BUFF_SIZE,
"------------------------------------------------------------"
"-------------------------------------------\n")) < 0) {
return FAILED;
}
strncat(response, alertstr, ALERT_STR_BUFF_SIZE);
return SUCCESS;
}
/**************************************************************************
* Function Name : ocmw_handle_show_alerts
* Description : This Function used to handle the alerts commands
* Input(s) : alerts
* Output(s) : response
***************************************************************************/
int32_t ocmw_handle_show_alerts(char *response)
{
int32_t ret = 0;
if (response == NULL) {
logerr("%s(): NULL pointer error", __func__);
return FAILED;
}
strncpy(response, "", RES_ALERT_STR_BUFF_SIZE);
ret = ocmw_frame_alert_response(response);
if (ret < 0) {
free(alerts.list);
return ret;
}
ret = ocmw_send_alert_to_occli(response, RES_ALERT_STR_BUFF_SIZE);
free(alerts.list);
alerts.nalerts = 0;
return ret;
}
/**************************************************************************
* Function Name : ocmw_handle_show_all_alerts
* Description : This Function used to handle the syncronous alerts
* Input(s) : strTokenArray
* Output(s) : response
***************************************************************************/
static int32_t ocmw_handle_show_all_alerts(char *strTokenArray[],
char *response)
{
char paramStr[PARAM_STR_BUFF_SIZE];
void *paramVal;
char tempParamStr[PARAM_STR_MAX_BUFF_SIZE] = { 0 };
int32_t ret = 0;
if (strTokenArray == NULL || response == NULL) {
logerr("%s(): NULL pointer error", __func__);
return FAILED;
}
alerts.nalerts = 0;
alerts.list = (struct allAlertEvent *)calloc(ALERT_MAX_BUFF_SIZE,
sizeof(struct allAlertEvent));
alertFlag++;
strcpy(tempParamStr, strTokenArray[0]);
strncpy(response, "", RES_STR_BUFF_SIZE);
if ((snprintf(paramStr, PARAM_STR_BUFF_SIZE, "%s.%s", strTokenArray[1],
strTokenArray[0])) < 0) {
return FAILED;
}
ret = ocmw_msgproc_send_msg(&strTokenArray[0], 0, OCMP_MSG_TYPE_COMMAND,
(int8_t *)paramStr, &paramVal);
if ((snprintf(response, RES_STR_BUFF_SIZE, "%s : %s", tempParamStr,
(ret != 0) ? "Failed" : "Success")) < 0) {
return FAILED;
}
if (ret < 0) {
logerr("Error in reading alerts");
}
ret = ocmw_frame_alert_response(response);
free(alerts.list);
alertFlag = 0;
alerts.nalerts = 0;
return ret;
}
/**************************************************************************
* Function Name : ocmw_handle_set_config
* Description : This Function used to handle the set config commands
@@ -916,8 +1042,8 @@ static ocmw_token_t ocmw_match_set_get_string(char *str)
static ocmw_token_t ocmw_match_string(char *str)
{
struct matchString *index = ocmwTokenTable;
for(; index->key != NULL &&
strncmp(index->key, str, strlen(index->key)) != 0; ++index);
for (; index->key != NULL && strcmp(index->key, str) != 0; ++index)
;
return index->token;
}
/**************************************************************************
@@ -1139,11 +1265,6 @@ int32_t ocmw_clicmd_handler(const char *cmdStr, char *response)
response);
ocmw_free_pointer(strTokenArray);
return (ret != 0) ? FAILED : SUCCESS;
} else if (strcmp("alerts", class) == 0) {
/* SCHEMA change :: Alert is not implimented */
/* ret = ocmw_handle_show_alerts(&strTokenArray[0], response);
ocmw_free_pointer(strTokenArray);
return (ret != 0) ? FAILED : SUCCESS;*/
} else {
if ((snprintf(response,
RES_STR_BUFF_SIZE, "[Error]: "
@@ -1285,6 +1406,22 @@ int32_t ocmw_clicmd_handler(const char *cmdStr, char *response)
return FAILED;
}
break;
case ALERTLOG_STR:
if (strTokenCount == 2) {
ret = ocmw_handle_show_all_alerts(&strTokenArray[0],
response);
ocmw_free_pointer(strTokenArray);
return (ret != 0) ? FAILED : SUCCESS;
} else {
ret = (strTokenCount < 2 ?
ocmw_frame_errorString(
cmdStr, INSUFFICIENT_PARAM, response) :
ocmw_frame_errorString(
cmdStr, INVALID_SYNTAX, response));
ocmw_free_pointer(strTokenArray);
return FAILED;
}
break;
default:
break;
}

42
firmware/host/ocmw/ocmw_core.c
View File

@@ -32,6 +32,8 @@ subSystemInfo systemInfo;
extern ocwarePostResultData ocwarePostArray[TEMP_STR_BUFF_SIZE];
extern uint8_t ocwarePostArrayIndex;
int8_t alertRecord = 1;
extern int8_t alertFlag;
ocwarePostReplyCode ocmwReplyCode[] = {
/* Message Type, reply code, Description */
{OCMP_MSG_TYPE_POST, POST_DEV_NOSTATUS , "POST DEV NOSTATUS"},
@@ -362,7 +364,7 @@ int32_t ocmw_msg_packetize_and_send(char * strTokenArray[], uint8_t action,
paramValLen = strlen((char *)paramVal);
if (!((msgType == OCMP_MSG_TYPE_COMMAND) &&
((strncmp(strTokenArray[1], "get", strlen("get")) == 0) ||
((strcmp(strTokenArray[1], "get")) ||
(strncmp(strTokenArray[1], "set", strlen("get")) == 0)))) {
if (paramValLen == 1 || paramValLen <= 5) {
logdebug ("Paramvalue is of integer type : %d\n", atoi( paramVal));
@@ -578,7 +580,6 @@ int32_t ocmw_msg_packetize_and_send(char * strTokenArray[], uint8_t action,
******************************************************************************/
void * ocmw_thread_uartmsgparser(void *pthreadData)
{
logdebug("Uart task created \n");
while (1) {
/* Waiting on the semecMsgParser to be released by uart */
sem_wait(&semecMsgParser);
@@ -624,6 +625,7 @@ void ocmw_ec_msgparser(void)
int32_t sendPktNonpayloadSize = 0;
sMsgParam dmsgFrameParam;
OCMPMessageFrame ecReceivedMsg;
alertRecord = 1;
sendPktNonpayloadSize = (sizeof(OCMPMessage) - sizeof(void *)
+ sizeof(OCMPHeader));
@@ -646,20 +648,20 @@ void ocmw_ec_msgparser(void)
actionType = ecReceivedMsg.message.action;
paramInfo = ecReceivedMsg.message.parameters;
/*
* TODO:Temporary fix for handling alerts
*/
if (msgType == OCMP_MSG_TYPE_ALERT) {
free(ecReceivedMsg.message.info);
return;
}
printf("Received from ec :\n");
for (indexCount = 0; indexCount < OCMP_MSG_SIZE; indexCount++) {
printf("0x%x ", mcuMsgBuf[indexCount]);
}
printf("\n");
/*
* Alerts handling
*/
if ((msgType == OCMP_MSG_TYPE_ALERT) || (alertFlag > 0)) {
ocmw_handle_alert_msg(sys_schema, &ecReceivedMsg, &alertRecord);
responseCount++;
ocmw_free_global_pointer((void**)&ecSendBufBkp);
return;
}
/* In case of timeout, return from the thread
* without processing the data to avoid sync issue.
*/
@@ -765,9 +767,21 @@ int32_t ocmw_send_msg(OCMPMessageFrame ecMsgFrame, uint8_t interface)
ret = ocmw_send_eth_msgto_ec((int8_t *) &ecMsgFrame,
OCMP_MSG_SIZE, sentDev);
#ifdef INTERFACE_STUB_EC
memset(ethRecvBuf, 0, sizeof(ethRecvBuf));
ocmw_recv_eth_msgfrom_ec(ethRecvBuf, sizeof(ethRecvBuf), OCMW_EC_STUB_DEV);
ocmw_ec_msgparser();
if (alertFlag > 0) {
while (1) {
memset(ethRecvBuf, 0, sizeof(ethRecvBuf));
ocmw_recv_eth_msgfrom_ec(ethRecvBuf,
sizeof(ethRecvBuf), OCMW_EC_STUB_DEV);
ocmw_ec_msgparser();
if (alertRecord == 0) {
break;
}
}
} else {
memset(ethRecvBuf, 0, sizeof(ethRecvBuf));
ocmw_recv_eth_msgfrom_ec(ethRecvBuf, sizeof(ethRecvBuf), OCMW_EC_STUB_DEV);
ocmw_ec_msgparser();
}
#endif
break;

234
firmware/host/ocmw/ocmw_schema.c
View File

@@ -11,6 +11,9 @@ static char *s_paramEnumValue[OCMW_VALUE_TYPE_MFG] = {0};
ocmwSchemaSendBuf *ecSendBufBkp;
ocwarePostResultData ocwarePostArray[TEMP_STR_BUFF_SIZE] = {{0}};
uint8_t ocwarePostArrayIndex;
extern alertlist alerts;
static uint8_t s_alertIndex = 0;
extern int8_t alertFlag;
/******************************************************************************
* Function Name : ocmw_parse_eepromdata_from_ec
* Description : parse the eeprom data coming from EC to AP
@@ -293,7 +296,236 @@ void ocmw_get_noOfElements(const Parameter *param_list, int32_t *noOfElement,
*noOfElement = elementCount;
*size = pSize;
}
/******************************************************************************
* Function Name : ocmw_get_alert_value
* Description : get the alert value from message
* Input(s) : paramtype, ecReceivedMsg
* Output(s) : recvdAlertVal
******************************************************************************/
void ocmw_get_alert_value(const Parameter *param, const char* paramtype,
char *alertVal, char *alertVal1, OCMPMessageFrame *ecReceivedMsg)
{
int8_t paramPos = 7;
int32_t recvdAlertVal = 0;
int32_t recvdAlertVal1 = 0;
char *alertEnumValue[2] = {0};
char regStr[BUF_SIZE] = {0};
char regStr1[BUF_SIZE] = {0};
int8_t enumCount = 0;
int8_t strCount = 0;
int8_t index = 0;
if ((param == NULL) || (paramtype == NULL)) {
logdebug("Invalid paramtype\n");
return ;
}
if (strcmp("uint16",paramtype) == 0) {
recvdAlertVal = *((uint16_t *)
&(ecReceivedMsg->message.info[paramPos]));
recvdAlertVal1 = *((uint16_t *)
&(ecReceivedMsg->message.info[paramPos + 2]));
} else if (strcmp("int16",paramtype) == 0) {
recvdAlertVal = *((int16_t *)
&(ecReceivedMsg->message.info[paramPos]));
recvdAlertVal1 = *((int16_t *)
&(ecReceivedMsg->message.info[paramPos + 2]));
} else if (strcmp("uint8",paramtype) == 0) {
recvdAlertVal = *((uint8_t *)
&(ecReceivedMsg->message.info[paramPos]));
recvdAlertVal1 = *((uint8_t *)
&(ecReceivedMsg->message.info[paramPos + 2]));
} else if (strcmp("string",paramtype) == 0) {
memcpy(regStr, &ecReceivedMsg->message.info[paramPos], param->size);
memcpy(regStr1, &ecReceivedMsg->message.info[paramPos + 2],
param->size);
strCount++;
}
if (enumCount) {
sprintf(alertVal, "%u(%s)", recvdAlertVal, regStr);
sprintf(alertVal1, "%u(%s)", recvdAlertVal1, regStr1);
} else if (strCount) {
sprintf(alertVal, "%s", regStr);
sprintf(alertVal1, "%s", regStr1);
} else {
sprintf(alertVal, "%u", recvdAlertVal);
sprintf(alertVal1, "%u", recvdAlertVal1);
}
for (index = 0; index < enumCount; index++) {
ocmw_free_global_pointer((void**)&alertEnumValue[index]);
}
return;
}
/******************************************************************************
* Function Name : ocmw_extract_dateTime_from_msgFrame
* Description : extract date time for alerts
* Input(s) : ecReceivedMsg
* Output(s) :
******************************************************************************/
void ocmw_extract_dateTime_from_msgFrame(OCMPMessageFrame *ecReceivedMsg)
{
uint8_t hour = 0;
uint8_t minuts = 0;
uint8_t second = 0;
uint8_t day = 0;
uint8_t month = 0;
uint8_t year = 0;
int8_t paramPos = 1;
hour = *((uint8_t *)
&(ecReceivedMsg->message.info[paramPos]));
minuts = *((uint8_t *)
&(ecReceivedMsg->message.info[paramPos + 1]));
second = *((uint8_t *)
&(ecReceivedMsg->message.info[paramPos + 2]));
day = *((uint8_t *)
&(ecReceivedMsg->message.info[paramPos + 3]));
month = *((uint8_t *)
&(ecReceivedMsg->message.info[paramPos + 4]));
year = *((uint8_t *)
&(ecReceivedMsg->message.info[paramPos + 5]));
sprintf(alerts.list[s_alertIndex].datetime, "%d:%d:%d %d/%d/20%d",
hour, minuts, second, day, month, year);
return;
}
/******************************************************************************
* Function Name : ocmw_handle_alert_msg
* Description : parse schema for alert message
* Input(s) : compBase, ecReceivedMsg
* Output(s) :
******************************************************************************/
void ocmw_handle_alert_msg(const Component *compBase,
OCMPMessageFrame *ecReceivedMsg, int8_t *alertRecord)
{
const Component *component = NULL;
const Component *subComponent = NULL;
const Component *subSystem = compBase;
const Driver *devDriver = NULL;
const Parameter *param = NULL;
char response[RES_STR_BUFF_SIZE] = {0};
int8_t count = 0;
int8_t countParamId = 0;
static int8_t alertCount = 0;
int8_t ret = 0;
int32_t alertElements = 0;
int32_t alertElementsTemp = 0;
int32_t size = 0;
sMsgParam *sMsgFrameParam = (sMsgParam *) malloc(sizeof(sMsgParam));
if ((subSystem == NULL) || (sMsgFrameParam == NULL)) {
logdebug("Invalid Memory\n");
return;
}
if ((alertFlag == 0) && (alerts.nalerts == 0)) {
alerts.list = (struct allAlertEvent *) calloc(ALERT_MAX_BUFF_SIZE,
sizeof(struct allAlertEvent));
}
memset(sMsgFrameParam, 0, sizeof(sMsgParam));
sMsgFrameParam->component = 1;
while (subSystem && subSystem->name) {
if (sMsgFrameParam->subsystem == ecReceivedMsg->message.subsystem) {
component = subSystem->components;
while (component && component->name) {
if (ecReceivedMsg->message.componentID ==
sMsgFrameParam->component) {
devDriver = component->driver;
if (devDriver != NULL) {
param = devDriver->alerts;
while (param && param->name) {
if(ecReceivedMsg->message.parameters ==
pow(2, countParamId)) {
sprintf(alerts.list[s_alertIndex].string,
"%s.%s.alerts.%s",
subSystem->name, component->name,
param->name);
ocmw_get_alert_value(param,
DATA_TYPE_MAP[param->type],
alerts.list[s_alertIndex].value,
alerts.list[s_alertIndex].actualValue,
ecReceivedMsg);
alertCount++;
break;
}
countParamId = countParamId + 1;
param += 1;
}
}
subComponent = component->components;
while (subComponent && subComponent->name) {
countParamId = 0;
devDriver = subComponent->driver;
if (devDriver != NULL) {
param = devDriver->alerts;
ocmw_get_noOfElements(param,&alertElements, &size);
while (param && param->name) {
if(ecReceivedMsg->message.parameters ==
pow(2, countParamId + alertElementsTemp)){
sprintf(alerts.list[s_alertIndex].string,
"%s.%s.alerts.%s.%s", subSystem->name,
component->name, subComponent->name,
param->name);
ocmw_get_alert_value(param,
DATA_TYPE_MAP[param->type],
alerts.list[s_alertIndex].value,
alerts.list[s_alertIndex].actualValue,
ecReceivedMsg);
count++;
alertCount++;
break;
}
countParamId = countParamId + 1;
param += 1;
}
}
if (count > 0)
break;
alertElementsTemp = alertElementsTemp + alertElements;
subComponent += 1;
}
break;
}
sMsgFrameParam->component += 1;
component += 1;
}
break;
}
sMsgFrameParam->subsystem += 1;
subSystem += 1;
}
if (ecReceivedMsg->message.action == OCMP_AXN_TYPE_ACTIVE) {
strcpy(alerts.list[s_alertIndex].action,"ACTIVE");
} else if (ecReceivedMsg->message.action == OCMP_AXN_TYPE_CLEAR) {
strcpy(alerts.list[s_alertIndex].action,"CLEAR");
}
ocmw_extract_dateTime_from_msgFrame(ecReceivedMsg);
logdebug("Alert : %25s%10s%5s\n", alerts.list[s_alertIndex].string,
alerts.list[s_alertIndex].action, alerts.list[s_alertIndex].value);
alerts.nalerts = s_alertIndex;
if ((alertFlag > 0) &&
(ecReceivedMsg->message.action == OCMP_AXN_TYPE_REPLY)) {
*alertRecord = 0;
if (alertCount > 0) {
alerts.nalerts = s_alertIndex - 1;
} else {
alerts.nalerts = 0;
}
sem_post(&semCliReturn);
s_alertIndex = 0;
alertFlag = 0;
} else if (alertFlag == 0) {
*alertRecord = 0;
ret = ocmw_handle_show_alerts(response);
if (ret == FAILED)
logdebug("Alert send error\n");
s_alertIndex = 0;
}
free(sMsgFrameParam);
s_alertIndex++;
return;
}
/******************************************************************************
* Function Name : ocmw_parse_command_msgframe
* Description : parse the command
@@ -1048,7 +1280,7 @@ void ocmw_deserialization_msgframe(const Component *subSystem,
int32_t ret = 0;
int8_t index = 0;
if (subSystem == NULL) {
if ((subSystem == NULL) || (ecSendBufBkp == NULL)) {
return;
}

252
firmware/host/ocwarestub/ocware_stub_database.c
View File

@@ -13,6 +13,7 @@
static OCWareStubsizeflag s_typeFlag;
static OCWareStubDatabase s_ocwareGlobalData[MAX_NUMBER_PARAM];
static OCWareStubPostData s_postGlobalArray[MAX_POST_DEVICE];
static OCWareStubAlertData alertGlobalData[MAX_NUMBER_PARAM];
static int16_t s_defInt16Val = DEFAULT_INT16;
static int64_t s_defInt64Val = DEFAULT_INT64;
@@ -25,6 +26,7 @@ int8_t debugGetCommand = STUB_FAILED;
int8_t debugSetCommand = STUB_FAILED;
int8_t PostResult = STUB_FAILED;
int8_t PostEnable = STUB_FAILED;
int16_t allAlertCount = 0;
extern const Component sys_schema[];
/******************************************************************************
* Function Name : ocware_stub_set_gpioinfo
@@ -179,6 +181,105 @@ ocware_stub_ret ocware_stub_get_post_database(OCMPMessage *msgFrameData,
msgFrameData->parameters = pos/3;
return STUB_SUCCESS;
}
/******************************************************************************
* Function Name : ocware_stub_frame_alert_msgframe
* Description : extract alert data from based on subsystem
*
* @param msgFrameData - output pointer to the OCMPheader field of the message
* from MW (by reference)
* @param payload - output pointer to the payload field of the message from MW
*
* @return STUB_SUCCESS - for success
* STUB_FAILED - for failure
******************************************************************************/
ocware_stub_ret ocware_stub_frame_alert_msgframe(char *buffer)
{
uint32_t ret = 0;
uint32_t subSystemNbr = 0;
uint32_t index = 0;
uint32_t alertIndex = 0;
uint32_t subsystemIndex = 0;
uint8_t printIndex = 0;
uint8_t tempAlertCount = allAlertCount;
OCMPMessageFrame *msgFrame = (OCMPMessageFrame *)buffer;
OCMPMessage *msgFrameData = (OCMPMessage*)&msgFrame->message;
subSystemNbr = msgFrameData->subsystem;
if (subSystemNbr != 0) {
for (subsystemIndex = 0; subsystemIndex < allAlertCount;
subsystemIndex++) {
if (alertGlobalData[subsystemIndex].subsystemId == subSystemNbr) {
break;
}
}
alertIndex = subsystemIndex;
while (alertGlobalData[alertIndex].subsystemId == subSystemNbr)
alertIndex++;
allAlertCount = alertIndex;
}
for (index = subsystemIndex; index < allAlertCount; index++) {
/*create the msgframe*/
ret = ocware_stub_parse_alert_get_message(buffer, index);
printf(" \n Sending Data :\n");
for (printIndex = 0; printIndex < OC_EC_MSG_SIZE; printIndex++) {
printf("0x%x ", buffer[printIndex] & 0xff);
}
ret = ocware_stub_send_msgframe_middleware(&buffer,
sizeof(OCMPMessageFrame));
if (ret != STUB_SUCCESS) {
printf("ocware_stub_send_msgframe_middleware failed: error value :"
"%d\n", ret);
return STUB_FAILED;
}
}
allAlertCount = tempAlertCount;
return STUB_SUCCESS;
}
/******************************************************************************
* Function Name : ocware_stub_get_alert_database
* Description : extract alert data from lookup table
*
* @param msgFrameData - output pointer to the OCMPheader field of the message
* from MW (by reference)
* @param payload - output pointer to the payload field of the message from MW
*
* @return STUB_SUCCESS - for success
* STUB_FAILED - for failure
******************************************************************************/
ocware_stub_ret ocware_stub_get_alert_database(OCMPMessage *msgFrameData,
char *payload, int8_t index)
{
uint8_t pos = 0;
uint8_t defHour = 10;
uint8_t defMinut = 22;
uint8_t defSecond = 15;
uint8_t defDay = 2;
uint8_t defMonth = 7;
uint8_t defYear = 18;
if (index == (allAlertCount - 1)) {
msgFrameData->action = OCMP_AXN_TYPE_REPLY;
} else {
msgFrameData->action = OCMP_AXN_TYPE_ACTIVE;
}
payload[pos + 1] = 2;
strcpy(&payload[pos + 1], (char*)&defHour);
strcpy(&payload[pos + 2], (char*)&defMinut);
strcpy(&payload[pos + 3], (char*)&defSecond);
strcpy(&payload[pos + 4], (char*)&defDay);
strcpy(&payload[pos + 5], (char*)&defMonth);
strcpy(&payload[pos + 6], (char*)&defYear);
strncpy(&payload[pos + 7], (char*)alertGlobalData[index].data,
alertGlobalData[index].paramSize);
strncpy(&payload[pos + 9], (char*)alertGlobalData[index].data,
alertGlobalData[index].paramSize);
msgFrameData->subsystem = alertGlobalData[index].subsystemId;
msgFrameData->componentID = alertGlobalData[index].componentId;
msgFrameData->parameters = alertGlobalData[index].paramId;
return STUB_SUCCESS;
}
/******************************************************************************
* Function Name : ocware_stub_get_gpioinfo
* Description : retrieve the GPIO information in the DB for debug
@@ -749,6 +850,152 @@ ocware_stub_ret ocware_create_command_debug_database(int8_t subsystemNbr,
}
return ret;
}
/******************************************************************************
* Function Name : ocware_stub_fill_alert_value
* Description : Function to fill default alert value in the DB
*
* @param param - pointer to the parameter field in a particular subsytem and
* component (by value)
* gStructIndex - index to the DB (by value)
*
* @return STUB_SUCCESS - for success
* STUB_FAILED - for failure
*****************************************************************************/
ocware_stub_ret ocware_stub_fill_alert_value(const Parameter *param,
uint16_t gStructIndex)
{
const char *paramtype;
if(param == NULL) {
return STUB_FAILED;
}
paramtype = DATA_TYPE_MAP[param->type];
if (!strcmp("uint16",paramtype)) {
strcpy(alertGlobalData[gStructIndex].data, (char *)&s_defInt16Val);
} else if (!strcmp("int16",paramtype)) {
strcpy(alertGlobalData[gStructIndex].data, (char*)&s_defInt16Val);
} else if (!strcmp("uint8",paramtype)) {
strcpy(alertGlobalData[gStructIndex].data, (char*)&s_defInt8Val);
} else if (!strcmp("int8",paramtype)) {
strcpy(alertGlobalData[gStructIndex].data, (char*)&s_defInt8Val);
} else if (!strcmp("string",paramtype)) {
strcpy(alertGlobalData[gStructIndex].data, DEFAULT_STRING);
} else if (!strcmp("enum",paramtype)) {
strcpy(alertGlobalData[gStructIndex].data, (char*)&s_defEnumVal);
} else {
strcpy(alertGlobalData[gStructIndex].data, (char*)&s_defInt8Val);
}
return STUB_SUCCESS;
}
/******************************************************************************
* Function Name : ocware_stub_create_alert_database
* Description : Parse the schema and add alert entries in the DB
*
* @return STUB_SUCCESS - for success
* STUB_FAILED - for failure
******************************************************************************/
ocware_stub_ret ocware_stub_create_alert_database()
{
ocware_stub_ret ret = STUB_FAILED;
int8_t subsystemNbr = 0;
int8_t componentNbr = 0;
const Component *component = NULL;
const Component *subComponent = NULL;
const Component *subSystem = NULL;
const Driver *devDriver = NULL;
const Parameter *param = NULL;
int8_t count = 0;
int8_t alertCount = 0;
int16_t gStructIndex = 0;
int16_t paramPos = 0;
for (subSystem = sys_schema; subSystem && subSystem->name; subSystem++) {
/* Subsystem loop */
componentNbr = 1;
for(component = subSystem->components; component && component->name;
component++) {
/* component loop */
devDriver = component->driver;
if (devDriver != NULL) {
/* This is for componenets w/o any sub component */
count = 0;
paramPos = 0;
param = devDriver->alerts;
/* Alert related parameters */
while (param && param->name) { /*Parameter loop */
alertGlobalData[gStructIndex].subsystemId = subsystemNbr;
alertGlobalData[gStructIndex].componentId = componentNbr;
alertGlobalData[gStructIndex].paramId
= pow(2, count);
alertGlobalData[gStructIndex].paramSize =
ocware_stub_get_paramSize (
DATA_TYPE_MAP[param->type],
OCMP_MSG_TYPE_CONFIG, param->name);
alertGlobalData[gStructIndex].msgtype =
OCMP_MSG_TYPE_CONFIG;
alertGlobalData[gStructIndex].data = malloc(sizeof(char)*
alertGlobalData[gStructIndex].paramSize);
if (alertGlobalData[gStructIndex].data == NULL) {
printf("Malloc failed\n");
return STUB_FAILED;
} else {
memset(alertGlobalData[gStructIndex].data, 0,
alertGlobalData[gStructIndex].paramSize);
}
ocware_stub_fill_alert_value(param, gStructIndex);
paramPos += alertGlobalData[gStructIndex].paramSize;
gStructIndex++;
param += 1;
count = count + 1;
allAlertCount++;
}
}
alertCount = 0;
subComponent = component->components;
while (subComponent && subComponent->name) {
devDriver = subComponent->driver;
if(devDriver == NULL) {
subComponent += 1;
continue;
}
param = devDriver->alerts;
/* Config related parameters */
while (param && param->name) { /*Parameter loop */
alertGlobalData[gStructIndex].subsystemId = subsystemNbr;
alertGlobalData[gStructIndex].componentId = componentNbr;
alertGlobalData[gStructIndex].paramId
= pow(2, alertCount);
alertGlobalData[gStructIndex].paramSize
= ocware_stub_get_paramSize (
DATA_TYPE_MAP[param->type],
OCMP_MSG_TYPE_CONFIG, param->name);
alertGlobalData[gStructIndex].msgtype = OCMP_MSG_TYPE_CONFIG;
alertGlobalData[gStructIndex].data
= malloc(alertGlobalData[gStructIndex].paramSize);
if (alertGlobalData[gStructIndex].data == NULL) {
printf("Malloc failed\n");
return STUB_FAILED;
} else {
memset(alertGlobalData[gStructIndex].data, 0,
alertGlobalData[gStructIndex].paramSize);
}
ocware_stub_fill_alert_value(param, gStructIndex);
gStructIndex++;
param += 1;
alertCount += 1;
allAlertCount++;
}
subComponent += 1;
}
componentNbr++;
}
subsystemNbr++;
}
return ret;
}
/******************************************************************************
* Function Name : ocware_stub_create_post_database
* Description : Parse the schema and add post entries
@@ -1080,6 +1327,7 @@ ocware_stub_ret ocware_stub_init_database()
subsystemNbr++;
}
ret = ocware_stub_create_post_database();
ret = ocware_stub_create_alert_database();
return ret;
}
@@ -1092,7 +1340,8 @@ ocware_stub_ret ocware_stub_init_database()
* @return STUB_SUCCESS - for success
* STUB_FAILED - for failure
******************************************************************************/
ocware_stub_ret ocware_stub_parse_command_message(char *buffer)
ocware_stub_ret ocware_stub_parse_command_message(char *buffer,
uint8_t *alertFlag)
{
OCMPMessageFrame *msgFrame = (OCMPMessageFrame *)buffer;
OCMPMessage *msgFrameData = (OCMPMessage*)&msgFrame->message;
@@ -1112,6 +1361,7 @@ ocware_stub_ret ocware_stub_parse_command_message(char *buffer)
ocware_stub_parse_debug_actiontype(msgFrameData);
ret = ocware_stub_get_set_params(msgFrameData);
}
*alertFlag = ocware_stub_parse_command_from_schema(msgFrameData);
msgFrameData->action = OCMP_AXN_TYPE_REPLY;
return ret;
}

50
firmware/host/ocwarestub/ocware_stub_main_module.c
View File

@@ -8,6 +8,7 @@
*/
#include <ocware_stub_main_module.h>
extern int16_t allAlertCount;
/******************************************************************************
* Function Name : ocware_stub_frame_newmsgframe
* Description : Frame the response packet from stub function
@@ -18,7 +19,8 @@
* @return STUB_SUCCESS - for success
* STUB_FAILED - for failure
******************************************************************************/
ocware_stub_ret ocware_stub_frame_newmsgframe(char *buffer, int32_t option)
ocware_stub_ret ocware_stub_frame_newmsgframe(char *buffer, int32_t option,
uint8_t *alertFlag)
{
int32_t ret = 0, index = 0;
OCMPMessageFrame *msgFrame = (OCMPMessageFrame *)buffer;
@@ -34,7 +36,7 @@ ocware_stub_ret ocware_stub_frame_newmsgframe(char *buffer, int32_t option)
switch(msgFrameData->msgtype) {
case OCMP_MSG_TYPE_COMMAND:
ret = ocware_stub_parse_command_message(buffer);
ret = ocware_stub_parse_command_message(buffer, alertFlag);
break;
case OCMP_MSG_TYPE_POST:
@@ -45,7 +47,7 @@ ocware_stub_ret ocware_stub_frame_newmsgframe(char *buffer, int32_t option)
ret = ocware_stub_get_set_params(msgFrameData);
}
if (ret == STUB_SUCCESS) {
if (ret == STUB_SUCCESS && (msgFrameData->msgtype != OCMP_MSG_TYPE_ALERT)) {
/* Setting the action type as REPLY */
msgFrame->message.action = OCMP_AXN_TYPE_REPLY;
printf(" \n Sending Data :\n");
@@ -97,14 +99,14 @@ ocware_stub_ret ocware_stub_validate_msgframe_header(char *buf,
******************************************************************************/
int32_t host_ocstubmain_func(int32_t argc, char *argv[])
{
int32_t rc = 0;
int32_t ret = 0;
char *buffer = NULL;
int32_t loopCount = 0;
char *rootpath = NULL;
uint8_t alertFlag = 0;
OCMPMessageFrame *msgFrame = NULL;
rc = ocware_stub_init_ethernet_comm();
if ( rc != STUB_SUCCESS) {
ret = ocware_stub_init_ethernet_comm();
if ( ret != STUB_SUCCESS) {
printf("\n ERROR: Init Failed - %d", __LINE__);
ocware_stub_deinit_ethernet_comm();
return STUB_FAILED;
@@ -138,11 +140,11 @@ int32_t host_ocstubmain_func(int32_t argc, char *argv[])
while (1) {
memset(buffer, 0, sizeof(OCMPMessageFrame));
rc = ocware_stub_recv_msgfrom_middleware(&buffer,
ret = ocware_stub_recv_msgfrom_middleware(&buffer,
sizeof(OCMPMessageFrame));
if (rc != STUB_SUCCESS) {
if (ret != STUB_SUCCESS) {
printf("ocware_stub_recv_msgfrom_middleware failed: error value :"
" %d\n", rc);
" %d\n", ret);
return STUB_FAILED;
}
@@ -151,26 +153,30 @@ int32_t host_ocstubmain_func(int32_t argc, char *argv[])
for (loopCount = 0; loopCount < OC_EC_MSG_SIZE; loopCount++) {
printf("0x%x ", buffer[loopCount] & 0xff);
}
printf("\n");
//#endif
rc = ocware_stub_validate_msgframe_header(buffer, &msgFrame->message);
if (rc != STUB_SUCCESS) {
ret = ocware_stub_validate_msgframe_header(buffer, &msgFrame->message);
if (ret != STUB_SUCCESS) {
printf("ocware_stub_validate_msgframe_header failed: error value :"
"%d\n", rc);
"%d\n", ret);
return STUB_FAILED;
}
rc = ocware_stub_frame_newmsgframe(buffer, rc);
if (rc != STUB_SUCCESS) {
ret = ocware_stub_frame_newmsgframe(buffer, ret, &alertFlag);
if (ret != STUB_SUCCESS) {
printf("ocware_stub_frame_newmsgframe failed: error value :"
"%d\n", rc);
"%d\n", ret);
return STUB_FAILED;
}
rc = ocware_stub_send_msgframe_middleware(&buffer,
if (alertFlag > 0) {
ret = ocware_stub_frame_alert_msgframe(buffer);
} else {
ret = ocware_stub_send_msgframe_middleware(&buffer,
sizeof(OCMPMessageFrame));
if (rc != STUB_SUCCESS) {
printf("ocware_stub_send_msgframe_middleware failed: error value :"
"%d\n", rc);
return STUB_FAILED;
if (ret != STUB_SUCCESS) {
printf("ocware_stub_send_msgframe_middleware failed: error value :"
"%d\n", ret);
return STUB_FAILED;
}
}
}
free(msgFrame);

68
firmware/host/ocwarestub/ocware_stub_parse_message.c
View File

@@ -11,6 +11,7 @@
#include <ocmw_occli_comm.h>
#include <ocware_stub_main_module.h>
extern const Component sys_schema[];
/******************************************************************************
* Function Name : ocware_stub_parse_debug_actiontype
* Description : Convert debug actiontype into the SET/GET
@@ -41,6 +42,46 @@ ocware_stub_ret ocware_stub_parse_debug_actiontype(OCMPMessage *msgFrameData)
return ret;
}
/******************************************************************************
* Function Name : ocware_stub_parse_command_from_schema
* Description : Parse the command from schema
*
* @param msgFrameData - output pointer to the OCMPheader field of the message
* from MW (by reference)
*
* @return tempAlertFlag
*******************************************************************************/
uint8_t ocware_stub_parse_command_from_schema(OCMPMessage *msgFrameData)
{
const Component *component = NULL;
const Component *subSystem = NULL;
const Command *command = NULL;
uint8_t subsystemNbr = 0;
uint8_t commandNbr = 0;
uint8_t coponentNbr = 1;
uint8_t tempAlertFlag = 0;
for (subSystem = sys_schema; subSystem && subSystem->name; subSystem++) {
if (subsystemNbr == msgFrameData->subsystem) {
component = subSystem->components;
if (coponentNbr == msgFrameData->componentID) {
command = component->commands;
while (command && command->name) {
if ((strcmp(command->name, "getAlertLogs") == 0) &&
(commandNbr == msgFrameData->action)) {
tempAlertFlag++;
break;
}
commandNbr++;
command++;
}
break;
}
}
subsystemNbr++;
}
return tempAlertFlag;
}
/******************************************************************************
* Function Name : ocware_stub_handle_post_enable
* Description : Process the post enable message
@@ -122,3 +163,30 @@ ocware_stub_ret ocware_stub_parse_post_get_message(char *buffer)
}
return ret;
}
/******************************************************************************
* Function Name : ocware_stub_parse_alert_get_message
* Description : Parse alert messages from MW
*
* @param buffer - output pointer to the message from MW
* index - index for record
*
* @return STUB_SUCCESS - for success
* STUB_FAILED - for failure
******************************************************************************/
ocware_stub_ret ocware_stub_parse_alert_get_message(char *buffer, int8_t index)
{
ocware_stub_ret ret = STUB_FAILED;
OCMPMessageFrame *msgFrame = NULL;
OCMPMessage *msgFrameData = NULL;
char *payload = NULL;
if(buffer == NULL) {
return ret;
}
msgFrame = (OCMPMessageFrame *)buffer;
msgFrameData = (OCMPMessage*)&msgFrame->message;
payload = (char *)&msgFrameData->info;
msgFrameData->action = OCMP_MSG_TYPE_ALERT;
ret = ocware_stub_get_alert_database(msgFrameData, payload, index);
return ret;
}

BIN
firmware/utilities/schema/__pycache__/schemautils.cpython-36.pyc Normal file
View File

Binary file not shown.

944
firmware/utilities/schema/valid_schema.json Normal file
View File

@@ -0,0 +1,944 @@
[
{
"name": "system",
"driver_cfg": "gbc_spi_flash_memory",
"ssHookSet": {
"postInitFxn": "sys_post_init"
},
"components": [
{
"name": "comp_all",
"driver": "SYSTEMDRV",
"driver_cfg": "gbc_gpp_gpioCfg",
"components": [
{
"name": "eeprom_sid",
"driver": "CAT24C04_gbc_sid",
"driver_cfg": "eeprom_gbc_sid"
},
{
"name": "eeprom_inv",
"driver": "CAT24C04_gbc_inv",
"driver_cfg": "eeprom_gbc_inv"
},
{
"name": "eeprom_mac",
"driver": "Driver_MAC"
},
{
"name": "SPI_flash",
"driver": "FLASHDRV",
"driver_cfg": "gbc_spi_flash_memory"
}
],
"commands": [
{
"name": "reset",
"cb_cmd": "SYS_cmdReset"
},
{
"name": "echo",
"cb_cmd": "SYS_cmdEcho"
},
{
"name": "getAlertLogs",
"cb_cmd": "alert_log"
}
]
}
]
},
{
"name": "power",
"components": [
{
"name": "comp_all",
"components": [
{
"name": "powerSource",
"driver": "PWRSRC",
"driver_cfg": "gbc_pwr_powerSource",
"postDisabled": "POST_DISABLED"
}
],
"commands": [
{
"name": "getAlertLogs",
"cb_cmd": "alert_log"
}
]
},
{
"name": "leadacid_sensor",
"components": [
{
"name": "temp_sensor1",
"driver": "SE98A",
"driver_cfg": "gbc_pwr_lead_acid_ts",
"factory_config": "fact_bc_se98a"
}
]
},
{
"name": "leadacid",
"components": [
{
"name": "battery",
"driver": "LTC4015",
"driver_cfg": "gbc_pwr_ext_bat_charger",
"factory_config": "fact_leadAcid_cfg"
}
]
},
{
"name": "lion",
"components": [
{
"name": "battery",
"driver": "LTC4015",
"driver_cfg": "gbc_pwr_int_bat_charger",
"factory_config": "fact_lithiumIon_cfg"
}
]
},
{
"name": "pse",
"driver": "LTC4274",
"driver_cfg": "gbc_pwr_pse",
"factory_config": "fact_ltc4274_cfg"
},
{
"name": "pd",
"driver": "LTC4275",
"driver_cfg": "gbc_pwr_pd"
}
]
},
{
"name": "bms",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED",
"commands": [
{
"name": "getAlertLogs",
"cb_cmd": "alert_log"
}
]
},
{
"name": "ec",
"components": [
{
"name": "temp_sensor1",
"driver": "SE98A",
"driver_cfg": "gbc_bms_ec_ts",
"factory_config": "fact_ec_se98a_cfg"
},
{
"name": "current_sensor1",
"driver": "INA226",
"driver_cfg": "gbc_bms_ec_ps_12v",
"factory_config": "fact_ec_12v_ps_cfg"
},
{
"name": "current_sensor2",
"driver": "INA226",
"driver_cfg": "gbc_bms_ec_ps_3p3v",
"factory_config": "fact_ec_3v_ps_cfg"
}
]
}
]
},
{
"name": "hci",
"ssHookSet": {
"preInitFxn": "HCI_Init",
"postInitFxn": "NULL"
},
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED",
"commands": [
{
"name": "getAlertLogs",
"cb_cmd": "alert_log"
}
]
},
{
"name": "led",
"components": [
{
"name": "temp_sensor1",
"driver": "SE98A",
"driver_cfg": "led_hci_ts",
"factory_config": "fact_led_se98a_cfg",
"postDisabled": "POST_DISABLED"
},
{
"name": "fw",
"driver": "HCI_LED",
"driver_cfg": "led_hci_ioexp"
}
]
},
{
"name": "buzzer",
"driver_cfg": "gbc_hci_buzzer",
"postDisabled": "POST_DISABLED"
}
]
},
{
"name": "ethernet",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED",
"commands": [
{
"name": "getAlertLogs",
"cb_cmd": "alert_log"
}
]
},
{
"name": "port0",
"driver": "ETH_SW",
"driver_cfg": "gbc_eth_port0"
},
{
"name": "port1",
"driver": "ETH_SW",
"driver_cfg": "gbc_eth_port1"
},
{
"name": "port2",
"driver": "ETH_SW",
"driver_cfg": "gbc_eth_port2"
},
{
"name": "port3",
"driver": "ETH_SW",
"driver_cfg": "gbc_eth_port3"
},
{
"name": "port4",
"driver": "ETH_SW",
"driver_cfg": "gbc_eth_port4"
}
]
},
{
"name": "obc",
"ssHookSet": {
"preInitFxn": "obc_pre_init",
"postInitFxn": "NULL"
},
"driver_cfg": "sync_obc_gpiocfg",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED"
},
{
"name": "iridium",
"driver": "OBC_Iridium",
"driver_cfg": "obc_irridium"
}
]
},
{
"name": "gpp",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED",
"commands": [
{
"name": "getAlertLogs",
"cb_cmd": "alert_log"
}
]
},
{
"name": "ap",
"components": [
{
"name": "temp_sensor1",
"driver": "SE98A",
"driver_cfg": "gbc_gpp_ap_ts1",
"factory_config": "fact_ap_se98a_ts1_cfg"
},
{
"name": "temp_sensor2",
"driver": "SE98A",
"driver_cfg": "gbc_gpp_ap_ts2",
"factory_config": "fact_ap_se98a_ts2_cfg"
},
{
"name": "temp_sensor3",
"driver": "SE98A",
"driver_cfg": "gbc_gpp_ap_ts3",
"factory_config": "fact_ap_se98a_ts3_cfg"
},
{
"name": "current_sensor1",
"driver": "INA226",
"driver_cfg": "gbc_gpp_ap_ps",
"factory_config": "fact_ap_3v_ps_cfg"
}
],
"driver_cfg": "gbc_gpp_gpioCfg",
"commands": [
{
"name": "reset",
"cb_cmd": "GPP_ap_Reset"
},
{
"name": "getAlertLogs",
"cb_cmd": "alert_log"
}
]
},
{
"name": "msata",
"components": [
{
"name": "current_sensor1",
"driver": "INA226",
"driver_cfg": "gbc_gpp_msata_ps",
"factory_config": "fact_msata_3v_ps_cfg"
}
]
}
],
"driver_cfg": "gbc_gpp_gpioCfg",
"ssHookSet": {
"preInitFxn": "gpp_pre_init",
"postInitFxn": "gpp_post_init"
}
},
{
"name": "sdr",
"components": [
{
"name": "comp_all",
"components": [
{
"name": "current_sensor1",
"driver": "INA226",
"driver_cfg": "sdr_ps",
"factory_config": "fact_sdr_3v_ps_cfg"
},
{
"name": "eeprom",
"driver_cfg": "eeprom_sdr_inv",
"driver": "CAT24C04_sdr_inv"
}
],
"driver_cfg": "sdr_gpioCfg",
"commands": [
{
"name": "reset",
"cb_cmd": "SDR_reset"
},
{
"name": "getAlertLogs",
"cb_cmd": "alert_log"
}
]
},
{
"name": "fpga",
"components": [
{
"name": "temp_sensor1",
"driver": "ADT7481",
"driver_cfg": "sdr_fpga_ts",
"factory_config": "fact_sdr_fpga_adt7481_cfg"
},
{
"name": "current_sensor1",
"driver": "INA226",
"driver_cfg": "sdr_fpga_ps",
"factory_config": "fact_sdr_fpga_ps_cfg"
}
]
},
{
"name": "fx3",
"driver_cfg": "sdr_gpioCfg",
"commands": [
{
"name": "reset",
"cb_cmd": "SDR_fx3Reset"
}
],
"postDisabled": "POST_DISABLED"
}
],
"driver_cfg": "sdr_gpioCfg",
"ssHookSet": {
"preInitFxn": "SDR_Init",
"postInitFxn": "NULL"
}
},
{
"name": "rffe",
"driver_cfg": "fe_rffecfg",
"components": [
{
"name": "comp_all",
"components": [
{
"name": "eeprom",
"driver": "CAT24C04_fe_inv",
"driver_cfg": "eeprom_fe_inv"
}
],
"driver_cfg": "sdr_gpioCfg",
"commands": [
{
"name": "reset",
"cb_cmd": "RFFE_reset"
},
{
"name": "getAlertLogs",
"cb_cmd": "alert_log"
}
]
},
{
"name": "ch1_sensor",
"components": [
{
"name": "temp_sensor1",
"driver": "ADT7481",
"driver_cfg": "fe_ch1_ts",
"factory_config": "fact_fe_ch1_adt7481_cfg"
},
{
"name": "current_sensor1",
"driver": "INA226",
"driver_cfg": "fe_ch1_ps_5_7v",
"factory_config": "fact_fe_ch1_ps_cfg"
}
]
},
{
"name": "ch2_sensor",
"components": [
{
"name": "temp_sensor1",
"driver": "ADT7481",
"driver_cfg": "fe_ch2_ts",
"factory_config": "fact_fe_ch2_adt7481_cfg"
},
{
"name": "current_sensor1",
"driver": "INA226",
"driver_cfg": "fe_ch2_ps_5_7v",
"factory_config": "fact_fe_ch2_ps_cfg"
}
]
},
{
"name": "ch1_fe",
"driver_cfg": "fe_ch1_pwrcfg",
"components": [
{
"name": "ch1_band",
"driver": "FE_Param",
"driver_cfg": "fe_ch1_bandcfg",
"factory_config": "fact_ch1_band_cfg"
},
{
"name": "watchdog",
"driver": "RFFEWatchdog",
"driver_cfg": "fe_ch1_watchdog"
},
{
"name": "power",
"driver": "RFPowerMonitor",
"driver_cfg": "fe_ch1_ads7830"
},
{
"name": "tx",
"driver": "DATXXR5APP",
"driver_cfg": "fe_ch1_gain",
"factory_config": "fact_ch1_tx_gain_cfg"
},
{
"name": "rx",
"driver": "DATXXR5APP",
"driver_cfg": "fe_ch1_lna",
"factory_config": "fact_ch1_rx_gain_cfg"
}
],
"commands": [
{
"name": "enable",
"cb_cmd": "RFFE_enablePA"
},
{
"name": "disable",
"cb_cmd": "RFFE_disablePA"
}
]
},
{
"name": "ch2_fe",
"driver_cfg": "fe_ch2_pwrcfg",
"components": [
{
"name": "ch2_band",
"driver": "FE_Param",
"driver_cfg": "fe_ch2_bandcfg",
"factory_config": "fact_ch2_band_cfg"
},
{
"name": "watchdog",
"driver": "RFFEWatchdog",
"driver_cfg": "fe_ch2_watchdog"
},
{
"name": "power",
"driver": "RFPowerMonitor",
"driver_cfg": "fe_ch2_ads7830"
},
{
"name": "tx",
"driver": "DATXXR5APP",
"driver_cfg": "fe_ch2_gain",
"factory_config": "fact_ch2_tx_gain_cfg"
},
{
"name": "rx",
"driver": "DATXXR5APP",
"driver_cfg": "fe_ch2_lna",
"factory_config": "fact_ch2_rx_gain_cfg"
}
],
"commands": [
{
"name": "enable",
"cb_cmd": "RFFE_enablePA"
},
{
"name": "disable",
"cb_cmd": "RFFE_disablePA"
}
]
}
],
"ssHookSet": {
"preInitFxn": "rffe_pre_init",
"postInitFxn": "rffe_post_init"
}
},
{
"name": "sync",
"driver_cfg": "sync_gpiocfg",
"ssHookSet": {
"preInitFxn": "SYNC_Init",
"postInitFxn": "NULL"
},
"components": [
{
"name": "comp_all",
"driver_cfg": "sync_gpiocfg",
"commands": [
{
"name": "reset",
"cb_cmd": "SYNC_reset"
},
{
"name": "getAlertLogs",
"cb_cmd": "alert_log"
}
],
"postDisabled": "POST_DISABLED"
},
{
"name": "gps",
"driver_cfg": "sync_gpiocfg",
"driver": "Sync_IO"
},
{
"name": "sensor",
"components": [
{
"name": "temp_sensor1",
"driver": "ADT7481",
"driver_cfg": "sync_gps_ts",
"factory_config": "fact_sync_ts_cfg"
}
]
}
]
},
{
"name": "testmodule",
"components": [
{
"name": "comp_all",
"commands": [
{
"name": "reset",
"cb_cmd": "TestMod_cmdReset"
}
],
"postDisabled": "POST_DISABLED"
},
{
"name": "2gsim",
"driver": "Testmod_G510",
"driver_cfg": "testModuleCfg"
}
]
},
{
"name": "debug",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED"
},
{
"name": "I2C",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED"
},
{
"name": "bus0",
"driver": "OC_I2C",
"driver_cfg": "debug_I2C0",
"postDisabled": "POST_DISABLED"
},
{
"name": "bus1",
"driver": "OC_I2C",
"driver_cfg": "debug_I2C1",
"postDisabled": "POST_DISABLED"
},
{
"name": "bus2",
"driver": "OC_I2C",
"driver_cfg": "debug_I2C2",
"postDisabled": "POST_DISABLED"
},
{
"name": "bus3",
"driver": "OC_I2C",
"driver_cfg": "debug_I2C3",
"postDisabled": "POST_DISABLED"
},
{
"name": "bus4",
"driver": "OC_I2C",
"driver_cfg": "debug_I2C4",
"postDisabled": "POST_DISABLED"
},
{
"name": "bus6",
"driver": "OC_I2C",
"driver_cfg": "debug_I2C6",
"postDisabled": "POST_DISABLED"
},
{
"name": "bus7",
"driver": "OC_I2C",
"driver_cfg": "debug_I2C7",
"postDisabled": "POST_DISABLED"
},
{
"name": "bus8",
"driver": "OC_I2C",
"driver_cfg": "debug_I2C8",
"postDisabled": "POST_DISABLED"
}
]
},
{
"name": "ec",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED"
},
{
"name": "PA",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pa",
"postDisabled": "POST_DISABLED"
},
{
"name": "PB",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pb",
"postDisabled": "POST_DISABLED"
},
{
"name": "PC",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pc",
"postDisabled": "POST_DISABLED"
},
{
"name": "PD",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pd",
"postDisabled": "POST_DISABLED"
},
{
"name": "PE",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pe",
"postDisabled": "POST_DISABLED"
},
{
"name": "PF",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pf",
"postDisabled": "POST_DISABLED"
},
{
"name": "PG",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pg",
"postDisabled": "POST_DISABLED"
},
{
"name": "PH",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_ph",
"postDisabled": "POST_DISABLED"
},
{
"name": "PJ",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pj",
"postDisabled": "POST_DISABLED"
},
{
"name": "PK",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pk",
"postDisabled": "POST_DISABLED"
},
{
"name": "PL",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pl",
"postDisabled": "POST_DISABLED"
},
{
"name": "PM",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pm",
"postDisabled": "POST_DISABLED"
},
{
"name": "PN",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pn",
"postDisabled": "POST_DISABLED"
},
{
"name": "PP",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pn",
"postDisabled": "POST_DISABLED"
},
{
"name": "PQ",
"driver": "OC_GPIO",
"driver_cfg": "debug_ec_gpio_pq",
"postDisabled": "POST_DISABLED"
}
]
},
{
"name": "gbc",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED"
},
{
"name": "ioexpanderx70",
"driver": "OC_GPIO",
"driver_cfg": "debug_gbc_ioexpanderx70"
},
{
"name": "ioexpanderx71",
"driver": "OC_GPIO",
"driver_cfg": "debug_gbc_ioexpanderx71"
}
]
},
{
"name": "sdr",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED"
},
{
"name": "ioexpanderx1E",
"driver": "OC_GPIO",
"driver_cfg": "debug_sdr_ioexpanderx1E"
}
]
},
{
"name": "fe",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED"
},
{
"name": "ioexpanderx18",
"driver": "OC_GPIO",
"driver_cfg": "debug_sdr_ioexpanderx1E"
},
{
"name": "ioexpanderx1C",
"driver": "OC_GPIO",
"driver_cfg": "debug_fe_ioexpanderx1C"
},
{
"name": "ioexpanderx1B",
"driver": "OC_GPIO",
"driver_cfg": "debug_fe_ioexpanderx1B"
},
{
"name": "ioexpanderx1A",
"driver": "OC_GPIO",
"driver_cfg": "debug_fe_ioexpanderx1A"
},
{
"name": "ioexpanderx1D",
"driver": "OC_GPIO",
"driver_cfg": "debug_fe_ioexpanderx1D"
}
]
},
{
"name": "sync",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED"
},
{
"name": "ioexpanderx71",
"driver": "OC_GPIO",
"driver_cfg": "debug_sync_ioexpanderx71"
}
]
},
{
"name": "ethernet",
"components": [
{
"name": "comp_all",
"postDisabled": "POST_DISABLED"
},
{
"name": "port0",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_phyport0",
"postDisabled": "POST_DISABLED"
},
{
"name": "port1",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_phyport1",
"postDisabled": "POST_DISABLED"
},
{
"name": "port2",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_phyport2",
"postDisabled": "POST_DISABLED"
},
{
"name": "port3",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_phyport3",
"postDisabled": "POST_DISABLED"
},
{
"name": "port4",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_phyport4",
"postDisabled": "POST_DISABLED"
},
{
"name": "global1",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_global1",
"postDisabled": "POST_DISABLED"
},
{
"name": "global2",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_global2",
"postDisabled": "POST_DISABLED"
},
{
"name": "swport0",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_swport0",
"postDisabled": "POST_DISABLED"
},
{
"name": "swport1",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_swport1",
"postDisabled": "POST_DISABLED"
},
{
"name": "swport2",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_swport2",
"postDisabled": "POST_DISABLED"
},
{
"name": "swport3",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_swport3",
"postDisabled": "POST_DISABLED"
},
{
"name": "swport4",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_swport4",
"postDisabled": "POST_DISABLED"
},
{
"name": "swport5",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_swport5",
"postDisabled": "POST_DISABLED"
},
{
"name": "swport6",
"driver": "OC_MDIO",
"driver_cfg": "debug_mdio_swport6",
"postDisabled": "POST_DISABLED"
}
]
}
]
}
]