/* Ein Datum in die Datenbank schreiben */
static void pg_insert(char *query){
PGresult *res;
if(pg_connect()){
res = PQexec(connection, query);
if(!res || PQresultStatus(res) != PGRES_COMMAND_OK){
DEBUGOUT2("Fehler beim INSERT: %s\n", query);
#ifndef NO_LOGING
snprintf(get_error_buffer(), ERR_BUFFERSIZE, "Fehler beim INSERT: %s", query);
log_error(get_error_buffer());
#endif
} else {
DEBUGOUT2("Query: '%s' ausgefuehrt\n", query);
}
PQclear(res);
}
}
/** e1000_read_invm_word_i210 - Reads OTP
* @hw: pointer to the HW structure
* @address: the word address (aka eeprom offset) to read
* @data: pointer to the data read
*
* Reads 16-bit words from the OTP. Return error when the word is not
* stored in OTP.
**/
static s32 e1000_read_invm_word_i210(struct e1000_hw *hw, u8 address, u16 *data)
{
s32 status = -E1000_ERR_INVM_VALUE_NOT_FOUND;
u32 invm_dword;
u16 i;
u8 record_type, word_address;
DEBUGFUNC("e1000_read_invm_word_i210");
for (i = 0; i < E1000_INVM_SIZE; i++) {
invm_dword = E1000_READ_REG(hw, E1000_INVM_DATA_REG(i));
/* Get record type */
record_type = INVM_DWORD_TO_RECORD_TYPE(invm_dword);
if (record_type == E1000_INVM_UNINITIALIZED_STRUCTURE)
break;
if (record_type == E1000_INVM_CSR_AUTOLOAD_STRUCTURE)
i += E1000_INVM_CSR_AUTOLOAD_DATA_SIZE_IN_DWORDS;
if (record_type == E1000_INVM_RSA_KEY_SHA256_STRUCTURE)
i += E1000_INVM_RSA_KEY_SHA256_DATA_SIZE_IN_DWORDS;
if (record_type == E1000_INVM_WORD_AUTOLOAD_STRUCTURE) {
word_address = INVM_DWORD_TO_WORD_ADDRESS(invm_dword);
if (word_address == address) {
*data = INVM_DWORD_TO_WORD_DATA(invm_dword);
DEBUGOUT2("Read INVM Word 0x%02x = %x",
address, *data);
status = E1000_SUCCESS;
break;
}
}
}
if (status != E1000_SUCCESS)
DEBUGOUT1("Requested word 0x%02x not found in OTP\n", address);
return status;
}
/* Guckt ob Verbindung da und versucht aufzubauen.
* gibt 1 zurueck, wenn erfolgreich, sonst 0 */
static int pg_connect(){
if (PQstatus(connection) == CONNECTION_OK){
PQexec(connection,"SELECT 1"); /* Status neusetzen erzwingen */
}
if(PQstatus(connection) != CONNECTION_OK){
if (connection == NULL){
if(conn_string == NULL){
conn_string = malloc(sizeof(char)*512);
snprintf(conn_string, 512, "host=%s dbname=%s user=%s password=%s connect_timeout=%s", global_opts.pg_host, global_opts.pg_database, global_opts.pg_user, global_opts.pg_pass, global_opts.pg_timeout);
}
connection = PQconnectdb(conn_string); /* Connection aufbauen */
add_clean(clean_write, connection); /* Callbackfunktion zum Aufraeumen registrieren */
} else {
PQreset(connection); /* Connecion resetten */
}
if(PQstatus(connection) != CONNECTION_OK){
DEBUGOUT2("\nFehler beim Aufbau der Datenbankverbindung\n%s\n", PQerrorMessage(connection));
#ifndef NO_LOGING
snprintf(get_error_buffer(), ERR_BUFFERSIZE, "Fehler beim Aufbau der Datenbankverbindung: %s", PQerrorMessage(connection));
log_error(get_error_buffer());
#endif
return 0;
}
DEBUGOUT1("\nDatenbankverbindung erfolgreich hergestellt\n");
}
return 1;
}
/**
* ixgbe_set_mac_type - Sets MAC type
* @hw: pointer to the HW structure
*
* This function sets the mac type of the adapter based on the
* vendor ID and device ID stored in the hw structure.
**/
s32 ixgbe_set_mac_type(struct ixgbe_hw *hw)
{
s32 ret_val = IXGBE_SUCCESS;
DEBUGFUNC("ixgbe_set_mac_type\n");
if (hw->vendor_id == IXGBE_INTEL_VENDOR_ID) {
switch (hw->device_id) {
case IXGBE_DEV_ID_82598:
case IXGBE_DEV_ID_82598_BX:
case IXGBE_DEV_ID_82598AF_SINGLE_PORT:
case IXGBE_DEV_ID_82598AF_DUAL_PORT:
case IXGBE_DEV_ID_82598AT:
case IXGBE_DEV_ID_82598AT2:
case IXGBE_DEV_ID_82598EB_CX4:
case IXGBE_DEV_ID_82598_CX4_DUAL_PORT:
case IXGBE_DEV_ID_82598_DA_DUAL_PORT:
case IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM:
case IXGBE_DEV_ID_82598EB_XF_LR:
case IXGBE_DEV_ID_82598EB_SFP_LOM:
hw->mac.type = ixgbe_mac_82598EB;
break;
case IXGBE_DEV_ID_82599_KX4:
case IXGBE_DEV_ID_82599_KX4_MEZZ:
case IXGBE_DEV_ID_82599_XAUI_LOM:
case IXGBE_DEV_ID_82599_COMBO_BACKPLANE:
case IXGBE_DEV_ID_82599_KR:
case IXGBE_DEV_ID_82599_SFP:
case IXGBE_DEV_ID_82599_BACKPLANE_FCOE:
case IXGBE_DEV_ID_82599_SFP_FCOE:
case IXGBE_DEV_ID_82599_SFP_EM:
case IXGBE_DEV_ID_82599_SFP_SF2:
case IXGBE_DEV_ID_82599EN_SFP:
case IXGBE_DEV_ID_82599_CX4:
case IXGBE_DEV_ID_82599_T3_LOM:
hw->mac.type = ixgbe_mac_82599EB;
break;
case IXGBE_DEV_ID_82599_VF:
hw->mac.type = ixgbe_mac_82599_vf;
break;
case IXGBE_DEV_ID_X540_VF:
hw->mac.type = ixgbe_mac_X540_vf;
break;
case IXGBE_DEV_ID_X540T:
case IXGBE_DEV_ID_X540T1:
hw->mac.type = ixgbe_mac_X540;
break;
default:
ret_val = IXGBE_ERR_DEVICE_NOT_SUPPORTED;
break;
}
} else {
ret_val = IXGBE_ERR_DEVICE_NOT_SUPPORTED;
}
DEBUGOUT2("ixgbe_set_mac_type found mac: %d, returns: %d\n",
hw->mac.type, ret_val);
return ret_val;
}
/* Wertkonvertierungen fuer den 'einfachen' Außensensor */
static auss1_data process_auss1(time_t timestamp, u_char address, u_char *buffer){
auss1_data data; /* Datenstruktur */
data.timestamp = timestamp; /* Zeitstempel */
data.address = address; /* Addresse */
data.temp = convert_signed_int(buffer[2],buffer[3]); /* Temparatur */
DEBUGOUT2("Aussensensor1 an Addresse %i\n", address);
DEBUGOUT2("Temp.: %3.1f\n", (data.temp*0.1));
#ifndef NO_LOGING
if(get_flag(LOG_DATA_FLAG)){
check_log_buffer();
sprintf(prepend_type_address(AUSS1,address), "Temp: %3.1f°C",(data.temp*0.1));
log_data(timestamp, log_buffer);
}
#endif
return data;
}
/* Wertkonvertierungen fuer den Regensensor (ein Zaehlschritt = 370ml/m^2)*/
static regen_data process_regen(time_t timestamp, u_char address, u_char *buffer){
regen_data data; /* Datenstruktur */
int new_rain_count = 0; /* Neuer Zaehlerstand */
int now_rain_count = 0; /* Delta-Zaehlerstand */
data.timestamp = timestamp; /* Zeitstempel */
data.address = address; /* Addresse */
new_rain_count = ((buffer[2] & 0x1F) << 7) | remove_msb(buffer[3]); /* Niederschlagszaehler */
if (get_flag(NOT_USE_ADDR_FLAG))
address = 0;
if(last_rain_count[address%16] == -1) /* Nach Programmstart Zaehler initialisieren */
last_rain_count[address%16] = new_rain_count;
now_rain_count = new_rain_count - last_rain_count[address%16]; /* neuen Niederschlag berechnen */
if(now_rain_count < 0){ /* Wenn Integerueberlauf im Sensor */
now_rain_count = (0x3FFF - last_rain_count[address%16]) + new_rain_count; /* Dann letzten gemessenen Wert vom Max-Integer-Wert abziehen und neuen Zaehlwert dazurechnen */
DEBUGOUT1("Integer-Ueberlauf\n");
}
data.counter = (now_rain_count * 370); /* Ein Zaehlschritt entspricht 370ml/m^2, also aenderung mit 370 multiplizieren und zuweisen */
last_rain_count[address%16] = new_rain_count; /* Zaehler neu setzen */
DEBUGOUT2("Regensensor an Addresse %i\n", data.address);
DEBUGOUT3("Zaehler: %d Differenz: %d\n", new_rain_count,now_rain_count);
DEBUGOUT2("Niederschlag: %dml/m^2\n", data.counter);
#ifndef NO_LOGING
if(get_flag(LOG_DATA_FLAG)){
check_log_buffer();
sprintf(prepend_type_address(REGEN,address), "Rain: %dml/m^2",data.counter);
log_data(timestamp, log_buffer);
}
#endif
return data;
}
/******************************************************************************
* return the mac address from EEPROM
*
* hw - Struct containing variables accessed by shared code
* mac_addr - Ethernet Address if EEPROM contents are valid, 0 otherwise
*
* Returns: None.
******************************************************************************/
void
ixgb_get_ee_mac_addr(struct ixgb_hw *hw, uint8_t *mac_addr)
{
int i;
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
DEBUGFUNC("ixgb_get_ee_mac_addr");
if(ixgb_check_and_get_eeprom_data(hw) == TRUE) {
for(i = 0; i < IXGB_ETH_LENGTH_OF_ADDRESS; i++) {
mac_addr[i] = ee_map->mac_addr[i];
DEBUGOUT2("mac(%d) = %.2X\n", i, mac_addr[i]);
}
}
}
/* Wertkonvertierungen fuer den 'besseren' Außensensor */
static auss2_data process_auss2(time_t timestamp, u_char address, u_char *buffer){
auss2_data data; /* Datenstruktur */
data.timestamp = timestamp; /* Zeitstempel */
data.address = address; /* Addresse */
data.temp = convert_signed_int(buffer[2],buffer[3]); /* Temparatur */
data.hum = remove_msb(buffer[4]); /* Luftfeuchte */
DEBUGOUT2("Aussensensor2 an Addresse %i\n", address);
DEBUGOUT3("Temp.: %3.1f°C Feuchte: %d%%\n",(data.temp*0.1),data.hum);
#ifndef NO_LOGING
if(get_flag(LOG_DATA_FLAG)){
check_log_buffer();
sprintf(prepend_type_address(AUSS2,address), "Temp: %3.1f°C Hum: %d%%",(data.temp*0.1),data.hum);
log_data(timestamp, log_buffer);
}
#endif
return data;
}
/**
* ixgbe_init_eeprom_params_X540 - Initialize EEPROM params
* @hw: pointer to hardware structure
*
* Initializes the EEPROM parameters ixgbe_eeprom_info within the
* ixgbe_hw struct in order to set up EEPROM access.
**/
s32 ixgbe_init_eeprom_params_X540(struct ixgbe_hw *hw)
{
struct ixgbe_eeprom_info *eeprom = &hw->eeprom;
u32 eec;
u16 eeprom_size;
DEBUGFUNC("ixgbe_init_eeprom_params_X540");
if (eeprom->type == ixgbe_eeprom_uninitialized) {
eeprom->semaphore_delay = 10;
eeprom->type = ixgbe_flash;
eec = IXGBE_READ_REG(hw, IXGBE_EEC);
eeprom_size = (u16)((eec & IXGBE_EEC_SIZE) >>
IXGBE_EEC_SIZE_SHIFT);
eeprom->word_size = 1 << (eeprom_size +
IXGBE_EEPROM_WORD_SIZE_SHIFT);
DEBUGOUT2("Eeprom params: type = %d, size = %d\n",
eeprom->type, eeprom->word_size);
}
/* Wertkonvertierungen fuer das Pyranometer */
static pyano_data process_pyano(time_t timestamp, u_char address, u_char *buffer){
pyano_data data; /* Datenstruktur */
data.timestamp = timestamp; /* Zeitstempel */
data.rawrad = convert_unsigned_int(buffer[2],buffer[3]); /* 'Roh-Strahlung' - Strahlung ohne Multiplikator */
data.mult = buffer[4] & 0x03; /* Multiplikator */
data.absrad = (0x01 << data.mult) * data.rawrad; /* Absolute Strahlung */
DEBUGOUT2("Pyranometer an Addresse %i\n", address);
DEBUGOUT4("Rel. Strahl.: %d Mult.: %d Abs. Strahl.: %d\n",data.rawrad,data.mult,data.absrad);
#ifndef NO_LOGING
if(get_flag(LOG_DATA_FLAG)){
check_log_buffer();
sprintf(prepend_type_address(PYANO,address), "Int: %d",data.absrad);
log_data(timestamp, log_buffer);
}
#endif
return data;
}
/* Wertkonvertierungen fuer den Windsensor */
static winds_data process_winds(time_t timestamp, u_char address, u_char *buffer){
winds_data data; /* Datenstruktur */
data.timestamp = timestamp; /* Zeitstempel */
data.address = address; /* Addresse */
data.geschw = convert_unsigned_int(buffer[2],buffer[3]); /* Windgeschwindigkeit */
data.schwank = buffer[4] & 0x03; /* Schwankungsbreite */
data.richt = convert_unsigned_int(buffer[5],buffer[6]); /* Windrichtung */
DEBUGOUT2("Windsensor an Addresse %i\n", address);
DEBUGOUT4("Geschw.: %3.1fKm/h Schwank: %d Richtung: %d°\n",(data.geschw*0.1),data.schwank,data.richt);
#ifndef NO_LOGING
if(get_flag(LOG_DATA_FLAG)){
check_log_buffer();
sprintf(prepend_type_address(WINDS,address), "Spd: %3.1fKm/h Fluct: %d%% Dir:%d°",(data.geschw*0.1),data.schwank,data.richt);
log_data(timestamp, log_buffer);
}
#endif
return data;
}
/* Wertkonvertierungen fuer den Helligkeitssensor */
static helli_data process_helli(time_t timestamp, u_char address, u_char *buffer){
helli_data data; /* Datenstruktur */
data.timestamp = timestamp; /* Zeitstempel */
data.address = address; /* Addresse */
data.rawlum = convert_unsigned_int(buffer[2],buffer[3]); /* 'Roh-Helligkeit' - Helligkeit ohne Multiplikator */
data.mult = buffer[4] & 0x03; /* Multiplikator */
data.abslum = (0x01 << data.mult) * data.rawlum; /* Absolute Helligkeit */
DEBUGOUT2("Helligkeitssensor an Addresse %i\n", address);
DEBUGOUT4("Rel. Hell.: %d Mult.: %d Abs. Hell.: %d\n",data.rawlum,data.mult,data.abslum);
#ifndef NO_LOGING
if(get_flag(LOG_DATA_FLAG)){
check_log_buffer();
sprintf(prepend_type_address(HELLI,address), "Bright: %d",data.abslum);
log_data(timestamp, log_buffer);
}
#endif
return data;
}
/* Wertkonvertierungen fuer den Innensensor */
static innen_data process_innen(time_t timestamp, u_char address, u_char *buffer){
innen_data data; /* Datenstruktur */
data.timestamp = timestamp; /* Zeitstempel */
data.address = address; /* Addresse */
data.temp = convert_signed_int(buffer[2],buffer[3]); /* Temparatur */
data.hum = remove_msb(buffer[4]); /* Luftfeuchte */
data.press = convert_unsigned_int(buffer[5],buffer[6]); /* Luftdruck */
DEBUGOUT2("Innensensor an Addresse %i\n",address);
DEBUGOUT4("Temp.: %3.1f°C Feuchte: %d%% Druck: %dhPa\n",(data.temp*0.1),data.hum,data.press);
#ifndef NO_LOGING
if(get_flag(LOG_DATA_FLAG)){
check_log_buffer();
sprintf(prepend_type_address(INNEN,address), "Temp: %3.1f°C Hum: %d%% Press: %dhPa",(data.temp*0.1),data.hum,data.press);
log_data(timestamp, log_buffer);
}
#endif
return data;
}
/**
* fm10k_set_mac_type - Sets MAC type
* @hw: pointer to the HW structure
*
* This function sets the mac type of the adapter based on the
* vendor ID and device ID stored in the hw structure.
**/
s32 fm10k_set_mac_type(struct fm10k_hw *hw)
{
s32 ret_val = FM10K_SUCCESS;
DEBUGFUNC("fm10k_set_mac_type");
if (hw->vendor_id != FM10K_INTEL_VENDOR_ID) {
ERROR_REPORT2(FM10K_ERROR_UNSUPPORTED,
"Unsupported vendor id: %x\n", hw->vendor_id);
return FM10K_ERR_DEVICE_NOT_SUPPORTED;
}
switch (hw->device_id) {
case FM10K_DEV_ID_PF:
#ifdef BOULDER_RAPIDS_HW
case FM10K_DEV_ID_SDI_FM10420_QDA2:
#endif /* BOULDER_RAPIDS_HW */
#ifdef ATWOOD_CHANNEL_HW
case FM10K_DEV_ID_SDI_FM10420_DA2:
#endif /* ATWOOD_CHANNEL_HW */
hw->mac.type = fm10k_mac_pf;
break;
case FM10K_DEV_ID_VF:
hw->mac.type = fm10k_mac_vf;
break;
default:
ret_val = FM10K_ERR_DEVICE_NOT_SUPPORTED;
ERROR_REPORT2(FM10K_ERROR_UNSUPPORTED,
"Unsupported device id: %x\n",
hw->device_id);
break;
}
DEBUGOUT2("fm10k_set_mac_type found mac: %d, returns: %d\n",
hw->mac.type, ret_val);
return ret_val;
}
/* Bestimmung der Sensoren und Weiterreichung an die Funktionen zum auswerten der Werte
* sowie zum wegschreiben */
void process_data(time_t timestamp, u_char *buffer){
u_char type; /* Sensortyp */
u_char address; /* Sensoraddresse */
type = get_hi_nibble(remove_msb(buffer[1]));
address = get_lo_nibble(buffer[1]);
DEBUGOUT1(asctime(localtime(×tamp)));
switch (type){
case FERNB :
DEBUGOUT2("Fernbedienung an Addresse %i\n", address);
DEBUGOUT1("\nnoch nix zu implementiert!\n\n");
break;
case AUSS1 :
write_auss1(process_auss1(timestamp,address, buffer));
break;
case AUSS2 :
write_auss2(process_auss2(timestamp,address, buffer));
break;
case REGEN :
write_regen(process_regen(timestamp,address, buffer));
break;
case WINDS :
write_winds(process_winds(timestamp,address, buffer));
break;
case INNEN :
write_innen(process_innen(timestamp,address, buffer));
break;
case HELLI :
write_helli(process_helli(timestamp,address, buffer));
break;
case PYANO :
write_pyano(process_pyano(timestamp,address, buffer));
break;
}
}
/**
* ixgbe_set_mac_type - Sets MAC type
* @hw: pointer to the HW structure
*
* This function sets the mac type of the adapter based on the
* vendor ID and device ID stored in the hw structure.
**/
s32 ixgbe_set_mac_type(struct ixgbe_hw *hw)
{
s32 ret_val = IXGBE_SUCCESS;
DEBUGFUNC("ixgbe_set_mac_type\n");
if (hw->vendor_id != IXGBE_INTEL_VENDOR_ID) {
ERROR_REPORT2(IXGBE_ERROR_UNSUPPORTED,
"Unsupported vendor id: %x", hw->vendor_id);
return IXGBE_ERR_DEVICE_NOT_SUPPORTED;
}
hw->mvals = ixgbe_mvals_base;
switch (hw->device_id) {
case IXGBE_DEV_ID_82598:
case IXGBE_DEV_ID_82598_BX:
case IXGBE_DEV_ID_82598AF_SINGLE_PORT:
case IXGBE_DEV_ID_82598AF_DUAL_PORT:
case IXGBE_DEV_ID_82598AT:
case IXGBE_DEV_ID_82598AT2:
case IXGBE_DEV_ID_82598EB_CX4:
case IXGBE_DEV_ID_82598_CX4_DUAL_PORT:
case IXGBE_DEV_ID_82598_DA_DUAL_PORT:
case IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM:
case IXGBE_DEV_ID_82598EB_XF_LR:
case IXGBE_DEV_ID_82598EB_SFP_LOM:
hw->mac.type = ixgbe_mac_82598EB;
break;
case IXGBE_DEV_ID_82599_KX4:
case IXGBE_DEV_ID_82599_KX4_MEZZ:
case IXGBE_DEV_ID_82599_XAUI_LOM:
case IXGBE_DEV_ID_82599_COMBO_BACKPLANE:
case IXGBE_DEV_ID_82599_KR:
case IXGBE_DEV_ID_82599_SFP:
case IXGBE_DEV_ID_82599_BACKPLANE_FCOE:
case IXGBE_DEV_ID_82599_SFP_FCOE:
case IXGBE_DEV_ID_82599_SFP_EM:
case IXGBE_DEV_ID_82599_SFP_SF2:
case IXGBE_DEV_ID_82599_SFP_SF_QP:
case IXGBE_DEV_ID_82599_QSFP_SF_QP:
case IXGBE_DEV_ID_82599EN_SFP:
case IXGBE_DEV_ID_82599_CX4:
case IXGBE_DEV_ID_82599_BYPASS:
case IXGBE_DEV_ID_82599_T3_LOM:
hw->mac.type = ixgbe_mac_82599EB;
break;
case IXGBE_DEV_ID_82599_VF:
case IXGBE_DEV_ID_82599_VF_HV:
hw->mac.type = ixgbe_mac_82599_vf;
break;
case IXGBE_DEV_ID_X540_VF:
case IXGBE_DEV_ID_X540_VF_HV:
hw->mac.type = ixgbe_mac_X540_vf;
hw->mvals = ixgbe_mvals_X540;
break;
case IXGBE_DEV_ID_X540T:
case IXGBE_DEV_ID_X540T1:
case IXGBE_DEV_ID_X540_BYPASS:
hw->mac.type = ixgbe_mac_X540;
hw->mvals = ixgbe_mvals_X540;
break;
case IXGBE_DEV_ID_X550T:
case IXGBE_DEV_ID_X550T1:
hw->mac.type = ixgbe_mac_X550;
hw->mvals = ixgbe_mvals_X550;
break;
case IXGBE_DEV_ID_X550EM_X_KX4:
case IXGBE_DEV_ID_X550EM_X_KR:
case IXGBE_DEV_ID_X550EM_X_10G_T:
case IXGBE_DEV_ID_X550EM_X_1G_T:
case IXGBE_DEV_ID_X550EM_X_SFP:
hw->mac.type = ixgbe_mac_X550EM_x;
hw->mvals = ixgbe_mvals_X550EM_x;
break;
case IXGBE_DEV_ID_X550_VF:
case IXGBE_DEV_ID_X550_VF_HV:
hw->mac.type = ixgbe_mac_X550_vf;
hw->mvals = ixgbe_mvals_X550;
break;
case IXGBE_DEV_ID_X550EM_X_VF:
case IXGBE_DEV_ID_X550EM_X_VF_HV:
hw->mac.type = ixgbe_mac_X550EM_x_vf;
hw->mvals = ixgbe_mvals_X550EM_x;
break;
default:
ret_val = IXGBE_ERR_DEVICE_NOT_SUPPORTED;
ERROR_REPORT2(IXGBE_ERROR_UNSUPPORTED,
"Unsupported device id: %x",
hw->device_id);
break;
}
DEBUGOUT2("ixgbe_set_mac_type found mac: %d, returns: %d\n",
hw->mac.type, ret_val);
return ret_val;
}
static int
read_and_compare(int ttyFd, DataPack *standartMessage)
{
DataPack buffer, decodedBuffer;
char* buffPtr=(char*)&buffer;
int buffFill=0;
int pass = 1;
long iteration = 0;
struct timeval selectDelay;
fd_set set, *fdSet = &set;
int retval;
long lastLength = 1;
*((uint32_t*)buffPtr) = htonl(RECIVEREADYMAGIC);
while(config.work)
{
retval = write(ttyFd, &buffer, sizeof(uint32_t));
if (-1 == retval)
{
perror("Client error write ready status: ");
kill(0, SIGTERM);
return EIO;
}
usleep(calculate_delay_in_usec(2 * WAITBASEDELAY, WAITBASEDELAY));
selectDelay.tv_sec = 0;
selectDelay.tv_usec = BASEDELAY;
FD_ZERO(fdSet);
FD_SET(ttyFd, fdSet);
select(ttyFd + 1, fdSet, NULL, NULL, &selectDelay);
retval = read(ttyFd, &buffer, sizeof(buffer));
if (retval == -1)
{
if (errno == EAGAIN)
continue;
perror("Client: read data error");
kill(0, SIGTERM);
return EIO;
}
buffer.magic = ntohl(buffer.magic);
if (buffer.magic == RECIVEREADYMAGIC)
{
continue;
}
else if (buffer.magic == SENDMAGIC)
{
buffPtr = (char*)&buffer;
buffFill = retval;
break;
}
else if (buffer.magic == WAITMAGIC)
{
DEBUGOUT("Geting wait message - again");
DEBUGPARAMETRS("Unexpected value in buffer: %X", (uint32_t)buffer.magic);
kill(0, SIGTERM);
}
else
{
DEBUGOUT("Unexpected value in buffer: %X", (uint32_t)buffer.magic);
kill(0, SIGTERM);
return EINVAL;
}
}
DEBUGMSG("Ready to read status wrote");
while(/*config.work && */ lastLength > 0)
{
if (buffFill == sizeof(buffer))
{
convert_network_string_to_datapack((char*)&buffer, &decodedBuffer);
pass = pass && !compare_data_packages(standartMessage, &decodedBuffer);
buffFill = 0;
buffPtr = (char*)&buffer;
DEBUGOUT2("Message decoded: left space %d", decodedBuffer.dataTotalLength);
lastLength = (int)decodedBuffer.dataTotalLength;
memset(&buffer, 0, sizeof(buffer));
++iteration;
continue;
}
selectDelay.tv_sec = 0;
selectDelay.tv_usec = 20 * calculate_delay_from_speed_usec( tioGetDefL( "PORTSPEED", 115200 ) );
FD_ZERO(fdSet);
FD_SET(ttyFd, fdSet);
retval = select(ttyFd + 1, fdSet, NULL, NULL, &selectDelay);
if (retval == -1)
{
if ( errno == EINTR )
continue;
perror("Client compare failed: ");
kill(0, SIGTERM);
return EIO;
}
else if (retval == 0)
{
if (lastLength < 0)
break;
DEBUGOUT("Too long nothing happening: Waiting more bytes %ld\n", lastLength);
kill(0, SIGTERM);
break;
}
retval = read(ttyFd, buffPtr, sizeof(buffer) - buffFill);
if (retval == -1)
{
if(errno == EAGAIN)
{
continue;
}
perror("Client read port data failed: ");
kill(0,SIGTERM);
return EIO;
}
buffFill += retval;
buffPtr += retval;
}
DEBUGMSG("Client decode finished");
return (pass && (iteration > 0)) ? 0 : 1;
}
/**
* ixgbe_dcb_config - Struct containing DCB settings.
* @dcb_config: Pointer to DCB config structure
*
* This function checks DCB rules for DCB settings.
* The following rules are checked:
* 1. The sum of bandwidth percentages of all Bandwidth Groups must total 100%.
* 2. The sum of bandwidth percentages of all Traffic Classes within a Bandwidth
* Group must total 100.
* 3. A Traffic Class should not be set to both Link Strict Priority
* and Group Strict Priority.
* 4. Link strict Bandwidth Groups can only have link strict traffic classes
* with zero bandwidth.
*/
s32 ixgbe_dcb_check_config_cee(struct ixgbe_dcb_config *dcb_config)
{
struct ixgbe_dcb_tc_path *p;
s32 ret_val = IXGBE_SUCCESS;
u8 i, j, bw = 0, bw_id;
u8 bw_sum[2][IXGBE_DCB_MAX_BW_GROUP];
bool link_strict[2][IXGBE_DCB_MAX_BW_GROUP];
memset(bw_sum, 0, sizeof(bw_sum));
memset(link_strict, 0, sizeof(link_strict));
/* First Tx, then Rx */
for (i = 0; i < 2; i++) {
/* Check each traffic class for rule violation */
for (j = 0; j < IXGBE_DCB_MAX_TRAFFIC_CLASS; j++) {
p = &dcb_config->tc_config[j].path[i];
bw = p->bwg_percent;
bw_id = p->bwg_id;
if (bw_id >= IXGBE_DCB_MAX_BW_GROUP) {
ret_val = IXGBE_ERR_CONFIG;
goto err_config;
}
if (p->tsa == ixgbe_dcb_tsa_strict) {
link_strict[i][bw_id] = TRUE;
/* Link strict should have zero bandwidth */
if (bw) {
ret_val = IXGBE_ERR_CONFIG;
goto err_config;
}
} else if (!bw) {
/*
* Traffic classes without link strict
* should have non-zero bandwidth.
*/
ret_val = IXGBE_ERR_CONFIG;
goto err_config;
}
bw_sum[i][bw_id] += bw;
}
bw = 0;
/* Check each bandwidth group for rule violation */
for (j = 0; j < IXGBE_DCB_MAX_BW_GROUP; j++) {
bw += dcb_config->bw_percentage[i][j];
/*
* Sum of bandwidth percentages of all traffic classes
* within a Bandwidth Group must total 100 except for
* link strict group (zero bandwidth).
*/
if (link_strict[i][j]) {
if (bw_sum[i][j]) {
/*
* Link strict group should have zero
* bandwidth.
*/
ret_val = IXGBE_ERR_CONFIG;
goto err_config;
}
} else if (bw_sum[i][j] != IXGBE_DCB_BW_PERCENT &&
bw_sum[i][j] != 0) {
ret_val = IXGBE_ERR_CONFIG;
goto err_config;
}
}
if (bw != IXGBE_DCB_BW_PERCENT) {
ret_val = IXGBE_ERR_CONFIG;
goto err_config;
}
}
err_config:
DEBUGOUT2("DCB error code %d while checking %s settings.\n",
ret_val, (i == IXGBE_DCB_TX_CONFIG) ? "Tx" : "Rx");
return ret_val;
}
