int
onlp_sfpi_eeprom_read(int port, uint8_t data[256])
{
/*
* Read the SFP eeprom into data[]
*
* Return MISSING if SFP is missing.
* Return OK if eeprom is read
*/
int size = 0;
if(port <0 || port >= 54)
return ONLP_STATUS_E_INTERNAL;
if(port < 48)
return ONLP_STATUS_E_UNSUPPORTED;
memset(data, 0, 256);
if(onlp_file_read(data, 256, &size, PORT_EEPROM_FORMAT, onlp_sfpi_map_bus_index(port-48)) != ONLP_STATUS_OK) {
AIM_LOG_ERROR("Unable to read eeprom from port(%d)\r\n", port);
return ONLP_STATUS_E_INTERNAL;
}
if (size != 256) {
AIM_LOG_ERROR("Unable to read eeprom from port(%d), size is different!\r\n", port);
return ONLP_STATUS_E_INTERNAL;
}
return ONLP_STATUS_OK;
}
int
onlp_ledi_info_get(onlp_oid_t id, onlp_led_info_t* info)
{
int len, local_id = 0;
uint8_t data[driver_value_len] = {0};
VALIDATE(id);
local_id = ONLP_OID_ID_GET(id);
/* Set the onlp_oid_hdr_t and capabilities */
*info = linfo[ONLP_OID_ID_GET(id)];
/* Get LED mode */
if (onlp_file_read(data, sizeof(data), &len, "%s%s",
prefix_path, file_names[local_id]) != 0) {
return ONLP_STATUS_E_INTERNAL;
}
info->mode = driver_to_onlp_led_mode(local_id, (char*)data);
/* Set the on/off status */
if (info->mode != ONLP_LED_MODE_OFF) {
info->status |= ONLP_LED_STATUS_ON;
}
return ONLP_STATUS_OK;
}
int
onlp_file_vread_all(uint8_t** data, const char* fmt, va_list vargs)
{
int rv;
uint8_t* contents = NULL;
char * fname = NULL;
int fsize, rsize;
if(data == NULL || fmt == NULL) {
return ONLP_STATUS_E_PARAM;
}
fname = aim_vdfstrdup(fmt, vargs);
*data = NULL;
if((fsize = onlp_file_size(fname)) > 0) {
contents = aim_zmalloc(fsize);
if((rv = onlp_file_read(contents, fsize, &rsize, fname)) >= 0) {
*data = contents;
rv = rsize;
}
}
else {
rv = fsize;
}
aim_free(fname);
return rv;
}
/**
* @brief Get the PSU's operational status.
* @param id The PSU OID.
* @param rv [out] Receives the operational status.
*/
int onlp_psui_status_get(onlp_oid_t id, uint32_t* rv)
{
int result = ONLP_STATUS_OK;
hwmon_psu_state_t psu_state;
int local_id;
VALIDATE(id);
int len;
char buf[ONLP_CONFIG_INFO_STR_MAX];
local_id = ONLP_OID_ID_GET(id);
if(local_id >= ONLP_PSU_MAX) {
result = ONLP_STATUS_E_INVALID;
} else {
result = onlp_file_read((uint8_t*)&buf, ONLP_CONFIG_INFO_STR_MAX, &len, "%s""psu%d", INV_HWMON_PREFIX, local_id);
if( result != ONLP_STATUS_OK ) {return result;}
psu_state = (uint8_t)strtoul(buf, NULL, 0);
if( psu_state == HWMON_PSU_UNPOWERED) {
*rv = ONLP_PSU_STATUS_PRESENT|ONLP_PSU_STATUS_UNPLUGGED;
} else if ( psu_state == HWMON_PSU_NORMAL) {
*rv = ONLP_PSU_STATUS_PRESENT;
} else if( psu_state == HWMON_PSU_FAULT) {
*rv = ONLP_PSU_STATUS_PRESENT|ONLP_PSU_STATUS_FAILED;
} else if( psu_state == HWMON_PSU_NOT_INSTALLED) {
*rv = 0;
} else {
result = ONLP_STATUS_E_INVALID;
}
}
return result;
}
int
onlp_fani_info_get(onlp_oid_t id, onlp_fan_info_t* rv)
{
*rv = fans__[ONLP_OID_ID_GET(id)];
rv->caps |= ONLP_FAN_CAPS_GET_RPM;
int len;
char direction[16] = {0};
int fid = ONLP_OID_ID_GET(id);
/* Read the current airflow direction */
onlp_file_read((uint8_t*)direction, sizeof(direction), &len,
SYS_HWMON_PREFIX "/fan_dir");
#define FAN_DIR_F2B "front-to-back"
#define FAN_DIR_B2F "back-to-front"
if(!strncmp(direction, FAN_DIR_F2B, strlen(FAN_DIR_F2B))) {
rv->status |= ONLP_FAN_STATUS_F2B;
rv->caps |= ONLP_FAN_CAPS_F2B;
}
else if(!strncmp(direction, FAN_DIR_B2F, strlen(FAN_DIR_B2F))) {
rv->status |= ONLP_FAN_STATUS_B2F;
rv->caps |= ONLP_FAN_CAPS_B2F;
}
else {
AIM_LOG_WARN("Invalid fan direction: '%s'", direction);
}
switch(fid)
{
case FAN_ID_FAN1:
case FAN_ID_FAN2:
case FAN_ID_FAN3:
case FAN_ID_FAN4:
{
if(rv->status & ONLP_FAN_STATUS_F2B) {
return sys_fan_info_get__(rv, fid);
}
if(rv->status & ONLP_FAN_STATUS_B2F) {
return sys_fan_info_get__(rv, fid+4);
}
return ONLP_STATUS_E_INTERNAL;
}
case FAN_ID_FAN5:
case FAN_ID_FAN6:
{
return psu_fan_info_get__(rv, fid);
}
}
return ONLP_STATUS_E_INVALID;
}
psu_type_t get_psu_type(int id, char* modelname, int modelname_len)
{
int ret = 0, value = 0;
char model[PSU_MODEL_NAME_LEN + 1] = {0};
char fan_dir[PSU_FAN_DIR_LEN + 1] = {0};
char *path = NULL;
if (modelname && modelname_len < PSU_MODEL_NAME_LEN) {
return PSU_TYPE_UNKNOWN;
}
/* Check AC model name */
path = (id == PSU1_ID) ? PSU1_AC_EEPROM_NODE(psu_model_name) : PSU2_AC_EEPROM_NODE(psu_model_name);
ret = onlp_file_read((uint8_t*)model, PSU_MODEL_NAME_LEN, &value, path);
if (ret != ONLP_STATUS_OK || value != PSU_MODEL_NAME_LEN) {
return PSU_TYPE_UNKNOWN;
}
if (strncmp(model, "YM-2651Y", strlen("YM-2651Y")) != 0) {
return PSU_TYPE_UNKNOWN;
}
if (modelname) {
strncpy(modelname, model, modelname_len-1);
}
path = (id == PSU1_ID) ? PSU1_AC_PMBUS_NODE(psu_fan_dir) : PSU2_AC_PMBUS_NODE(psu_fan_dir);
ret = onlp_file_read((uint8_t*)fan_dir, sizeof(fan_dir), &value, path);
if (ret != ONLP_STATUS_OK) {
return PSU_TYPE_UNKNOWN;
}
if (strncmp(fan_dir, "F2B", strlen("F2B")) == 0) {
return PSU_TYPE_AC_F2B;
}
if (strncmp(fan_dir, "B2F", strlen("B2F")) == 0) {
return PSU_TYPE_AC_B2F;
}
return PSU_TYPE_UNKNOWN;
}
int
wnc_sys_eeprom_parse_file(const char* file, wnc_sys_eeprom_t* e)
{
int rv;
uint8_t data[256];
int len;
rv = onlp_file_read(data, sizeof(data), &len, (char*)file);
if(rv >= 0) {
rv = wnc_sys_eeprom_parse_data(data, sizeof(data), e);
}
return rv;
}
static void
psu_module_name_get(int id, onlp_psu_info_t* info)
{
char node_path[ONLP_NODE_MAX_PATH_LEN] = {0};
uint8_t temp[ONLP_CONFIG_INFO_STR_MAX] = {0};
int ret, len;
#if 1
strncpy(info->model, "N/A", 3);
#else
memset(node_path, 0, ONLP_NODE_MAX_PATH_LEN);
sprintf(node_path, module_devfiles__[id], "model");
ret = onlp_file_read(temp, ONLP_CONFIG_INFO_STR_MAX, &len, node_path);
if (ret == 0) {
/*remove the '\n'*/
temp[strlen((char*)temp)-1] = 0;
snprintf(info->model, ONLP_CONFIG_INFO_STR_MAX, "%s", temp);
}
else {
AIM_LOG_ERROR("Unable to read model name from file(%s)\r\n", node_path);
strncpy(info->model, "N/A", 3);
}
#endif
memset(node_path, 0, ONLP_NODE_MAX_PATH_LEN);
sprintf(node_path, module_devfiles__[id], "serial");
ret = onlp_file_read(temp, ONLP_CONFIG_INFO_STR_MAX, &len, node_path);
if (ret == 0) {
/*remove the '\n'*/
temp[strlen((char*)temp)-1] = 0;
snprintf(info->serial, ONLP_CONFIG_INFO_STR_MAX, "%s", temp);
}
else {
AIM_LOG_ERROR("Unable to read model name from file(%s)\r\n", node_path);
strncpy(info->serial, "N/A", 3);
}
}
int
onlp_sysi_onie_data_get(uint8_t** data, int* size)
{
uint8_t* rdata = aim_zmalloc(256);
if(onlp_file_read(rdata, 256, size, EEPROM_NODE(eeprom)) == ONLP_STATUS_OK) {
if(*size == 256) {
*data = rdata;
return ONLP_STATUS_OK;
}
}
aim_free(rdata);
*size = 0;
return ONLP_STATUS_E_INTERNAL;
}
static int
psu_power_info_get(int id, char *node, int *value)
{
int len, ret = 0;
char buf[PSU_NODE_MAX_INT_LEN + 1] = {0};
*value = 0;
ret = onlp_file_read((uint8_t*)buf, sizeof(buf), &len,
PSU_POWER_PREFIX, id, node);
if (ret == 0) {
*value = atoi(buf);
}
return ret;
}
static int
psu2_thermal_info_get__(onlp_thermal_info_t* info, int id)
{
int rv;
uint8_t buffer[64];
double dvalue;
int len;
memset(buffer, 0, sizeof(buffer));
rv = onlp_file_read(buffer, sizeof(buffer), &len, SYS_HWMON2_PREFIX "/psu2_temp_%d", id);
if (rv == ONLP_STATUS_OK)
{
dvalue = atof((const char *)buffer);
info->mcelsius = (int)(dvalue * 1000);
}
return rv;
}
int
onlp_sfpi_eeprom_read(int port, uint8_t data[256])
{
char* path;
int len = 0;
/*
* Read the SFP eeprom into data[]
*
* Return MISSING if SFP is missing.
* Return OK if eeprom is read
*/
memset(data, 0, 256);
path = sfp_get_port_path(port, "eeprom");
if (onlp_file_read(&data[0], 256, &len, path) < 0) {
AIM_LOG_ERROR("Unable to read eeprom from port(%d)\r\n", port);
return ONLP_STATUS_E_INTERNAL;
}
return ONLP_STATUS_OK;
}
static int
msn2100_sfp_node_read_int(char *node_path, int *value)
{
int data_len = 0, ret = 0;
char buf[SFP_SYSFS_VALUE_LEN] = {0};
*value = -1;
ret = onlp_file_read((uint8_t*)buf, sizeof(buf), &data_len, node_path);
if (ret == 0) {
if (!strncmp(buf, SFP_PRESENT_STATUS, strlen(SFP_PRESENT_STATUS))) {
*value = 1;
} else if (!strncmp(buf, SFP_NOT_PRESENT_STATUS, strlen(SFP_NOT_PRESENT_STATUS))) {
*value = 0;
}
}
return ret;
}
int psu_serial_number_get(int id, char *serial, int serial_len)
{
int size = 0;
int ret = ONLP_STATUS_OK;
char *prefix = NULL;
if (serial == NULL || serial_len < PSU_SERIAL_NUMBER_LEN) {
return ONLP_STATUS_E_PARAM;
}
prefix = (id == PSU1_ID) ? PSU1_AC_PMBUS_PREFIX : PSU2_AC_PMBUS_PREFIX;
ret = onlp_file_read((uint8_t*)serial, PSU_SERIAL_NUMBER_LEN, &size, "%s%s", prefix, "psu_mfr_serial");
if (ret != ONLP_STATUS_OK || size != PSU_SERIAL_NUMBER_LEN) {
return ONLP_STATUS_E_INTERNAL;
}
serial[PSU_SERIAL_NUMBER_LEN] = '\0';
return ONLP_STATUS_OK;
}
/*
* Retrieve the information structure for the given thermal OID.
*
* If the OID is invalid, return ONLP_E_STATUS_INVALID.
* If an unexpected error occurs, return ONLP_E_STATUS_INTERNAL.
* Otherwise, return ONLP_STATUS_OK with the OID's information.
*
* Note -- it is expected that you fill out the information
* structure even if the sensor described by the OID is not present.
*/
int
onlp_thermali_info_get(onlp_oid_t id, onlp_thermal_info_t* info)
{
int rv, len = 10, temp_base=1, local_id = 0;
char r_data[10] = {0};
VALIDATE(id);
local_id = ONLP_OID_ID_GET(id);
/* Set the onlp_oid_hdr_t and capabilities */
*info = linfo[local_id];
rv = onlp_file_read((uint8_t*)r_data, sizeof(r_data), &len, "%s/%s",
prefix_path, last_path[local_id]);
if (rv < 0) {
return ONLP_STATUS_E_INTERNAL;
}
info->mcelsius = atoi(r_data) / temp_base;
return ONLP_STATUS_OK;
}
static int
sys_thermal_info_get__(onlp_thermal_info_t* info, int id)
{
int rv;
if (id == THERMAL_ID_THERMAL3)
{
rv = onlp_file_read_int(&info->mcelsius, SYS_HWMON1_PREFIX "/mac_temp");
info->mcelsius *= 1000;
}
else
{
uint8_t buffer[64];
double dvalue;
int len;
memset(buffer, 0, sizeof(buffer));
rv = onlp_file_read(buffer, sizeof(buffer), &len, SYS_HWMON1_PREFIX "/remote_temp%d", id);
if (rv == ONLP_STATUS_OK)
{
dvalue = atof((const char *)buffer);
info->mcelsius = (int)(dvalue * 1000);
}
}
if(rv == ONLP_STATUS_E_INTERNAL)
return rv;
if(rv == ONLP_STATUS_E_MISSING)
{
info->status &= ~(ONLP_THERMAL_STATUS_PRESENT);
return ONLP_STATUS_OK;
}
return ONLP_STATUS_OK;
}
int
onlp_psui_info_get(onlp_oid_t id, onlp_psu_info_t* info)
{
int ret = ONLP_STATUS_OK;
int len;
int local_id = ONLP_OID_ID_GET(id);
uint8_t temp[ONLP_CONFIG_INFO_STR_MAX] = {0};
VALIDATE(id);
if(local_id >= ONLP_PSU_MAX) {
return ONLP_STATUS_E_INVALID;
}
*info = __onlp_psu_info[LOCAL_ID_TO_INFO_IDX(local_id)]; /* Set the onlp_oid_hdr_t */
ret = onlp_file_read(temp, ONLP_CONFIG_INFO_STR_MAX, &len, INV_HWMON_PREFIX"psoc_psu%d_vendor", local_id);
if(ret != ONLP_STATUS_OK) { return ret; }
/*remove the '\n'*/
temp[strlen((char*)temp)-1] = 0;
snprintf(info->model, ONLP_CONFIG_INFO_STR_MAX, "%s", temp);
memset(temp, 0, ONLP_CONFIG_INFO_STR_MAX);
ret = onlp_file_read(temp, ONLP_CONFIG_INFO_STR_MAX, &len, INV_HWMON_PREFIX"psoc_psu%d_serial", local_id);
if(ret != ONLP_STATUS_OK) { return ret; }
/*remove the '\n'*/
temp[strlen((char*)temp)-1] = 0;
snprintf(info->serial, ONLP_CONFIG_INFO_STR_MAX, "%s", temp);
ret = onlp_psui_status_get(id, &info->status);
if(ret != ONLP_STATUS_OK) { return ret; }
if(info->status & ONLP_PSU_STATUS_PRESENT) {
info->caps = ONLP_PSU_CAPS_AC;
/*millivolts*/
ret = onlp_file_read_int(&info->mvin, INV_HWMON_PREFIX"psoc_psu%d_vin", local_id);
if(ret != ONLP_STATUS_OK) { return ret; }
if(info->mvin >= 0) {
info->caps |= ONLP_PSU_CAPS_VIN;
}
ret = onlp_file_read_int(&info->mvout, INV_HWMON_PREFIX"psoc_psu%d_vout", local_id);
if(ret != ONLP_STATUS_OK) { return ret; }
if(info->mvout >= 0) {
info->caps |= ONLP_PSU_CAPS_VOUT;
}
/* milliamps */
ret = onlp_file_read_int(&info->miin, INV_HWMON_PREFIX"psoc_psu%d_iin", local_id);
if(ret != ONLP_STATUS_OK) { return ret; }
if(info->miin >= 0) {
info->caps |= ONLP_PSU_CAPS_IIN;
}
ret = onlp_file_read_int(&info->miout, INV_HWMON_PREFIX"psoc_psu%d_iout", local_id);
if(ret != ONLP_STATUS_OK) { return ret; }
if(info->miout >= 0) {
info->caps |= ONLP_PSU_CAPS_IOUT;
}
/* milliwatts */
ret = onlp_file_read_int(&info->mpin, INV_HWMON_PREFIX"psoc_psu%d_pin", local_id);
if(ret != ONLP_STATUS_OK) { return ret; }
if(info->mpin >= 0) {
info->caps |= ONLP_PSU_CAPS_PIN;
}
ret = onlp_file_read_int(&info->mpout, INV_HWMON_PREFIX"psoc_psu%d_pout", local_id);
if(ret != ONLP_STATUS_OK) { return ret; }
if(info->mpout >= 0) {
info->caps |= ONLP_PSU_CAPS_POUT;
}
}
return ret;
}
/*
* Retrieve the information structure for the given thermal OID.
*
* If the OID is invalid, return ONLP_E_STATUS_INVALID.
* If an unexpected error occurs, return ONLP_E_STATUS_INTERNAL.
* Otherwise, return ONLP_STATUS_OK with the OID's information.
*
* Note -- it is expected that you fill out the information
* structure even if the sensor described by the OID is not present.
*/
int
onlp_thermali_info_get(onlp_oid_t id, onlp_thermal_info_t* info)
{
int tid;
int size;
char cmd[THERMAL_MAX_LENGTH/2] = {0};
char temp[4];
uint8_t data[THERMAL_MAX_LENGTH] = {0};
//char *ipmi_cmd;
char * tag, *p;
struct timeval new_tv;
long last_time;
int get_data_by_ipmi=0;
VALIDATE(id);
tid = ONLP_OID_ID_GET(id);
if(tid > THERMAL_1_ON_PSU2 || tid <= THERMAL_RESERVED)
return ONLP_STATUS_E_INTERNAL;
/* Set the onlp_oid_hdr_t and capabilities */
*info = linfo[tid];
if(tid == THERMAL_CPU_CORE) {
return onlp_file_read_int_max(&info->mcelsius, cpu_coretemp_files);
}
if(thermali_time_exist())
{
if(onlp_file_read(data, THERMAL_MAX_LENGTH, &size, THERMAL_CHECK_TIME)!=ONLP_STATUS_OK)
{
last_time=0;
}
else
last_time = atol((char*)data);
}
else
last_time=0;
gettimeofday(&new_tv,NULL);
if(last_time==0) /* first time */
{
get_data_by_ipmi=1;
}
else
{
if(new_tv.tv_sec > last_time)
{
if((new_tv.tv_sec - last_time) > THERMAL_CAN_SET_IPMI_TIME)
{
get_data_by_ipmi=1;
}
else
get_data_by_ipmi=0;
}
else if(new_tv.tv_sec == last_time)
get_data_by_ipmi=0;
else
get_data_by_ipmi=1;
}
memset(data ,0x0, THERMAL_MAX_LENGTH);
snprintf((char*)data, THERMAL_MAX_LENGTH-1, "%ld", new_tv.tv_sec);
if(onlp_file_write_str((char*)data, THERMAL_CHECK_TIME)!=ONLP_STATUS_OK)
{
return ONLP_STATUS_E_INTERNAL;
}
if(get_data_by_ipmi || !thermali_sdr_file_exist()) /* Set ipmitool cmd to get all data and save to file*/
{
/* set ipmi cmd */
snprintf(cmd, (THERMAL_MAX_LENGTH/2) -1, "%s > %s ", THERMAL_IPMI_SDR_CMD, THERMAL_IPMI_SDR_FILE);
system(cmd);
fflush(stdout);
}
tag= thermal_sensor_table[tid].tag;
if(tag==NULL)
return ONLP_STATUS_E_INTERNAL;
snprintf(cmd, (THERMAL_MAX_LENGTH/2) -1, "cat %s|grep %s > %s ", THERMAL_IPMI_SDR_FILE, tag, THERMAL_IPMI_TMP_FILE);
system(cmd);
if(onlp_file_read(data, THERMAL_MAX_LENGTH, &size, THERMAL_IPMI_TMP_FILE)!=ONLP_STATUS_OK)
{
return ONLP_STATUS_E_INTERNAL;
}
p=strstr((char*)data, THERMAL_IPMI_TMP_FILE_FIND);
if(p==NULL)
{
return ONLP_STATUS_E_INTERNAL;
}
if(((uint8_t*)p-data) < sizeof(temp)/sizeof(char))
{
return ONLP_STATUS_E_INTERNAL;
}
temp[0]=data[(uint8_t*)p-data-4];
temp[1]=data[(uint8_t*)p-data-3];
temp[2]=data[(uint8_t*)p-data-2];
info->mcelsius=ONLPLIB_ATOI(temp) * 1000;
return ONLP_STATUS_OK;
}
