agent/device/device.cc

/*
 * Copyright 2018-present Open Networking Foundation

 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at

 * http://www.apache.org/licenses/LICENSE-2.0

 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "device.h"
#include "vendor.h"
#include "core_utils.h"

using namespace std;

// PonTrxBase class member function definitions
// Note: 'cout' logger has been used in this file instead of OPENOLT_LOG
// because the logger task may not be initialized in the openolt core module
// before PonTrx module is initialized in the main handler. In that case,
// any OPENOLT_LOG logger (which internally uses BCM_LOG) will not be logged.

PonTrxBase::PonTrxBase(string eeprom_file_name,
                       int port_addr,
                       string eeprom_file_path_name,
                       string sfp_presence_command) :
        _eeprom_file_name{eeprom_file_name},
        _port_addr{port_addr},
        _eeprom_file_path_format{eeprom_file_path_name},
        _sfp_presence_command{sfp_presence_command}
{
}

PonTrxBase::~PonTrxBase() {
    for (auto it : _t_data) {
        delete it;
    }
}

// returns the _sfp_presence_data
const set<int> PonTrxBase::get_sfp_presence_data() {
    return _sfp_presence_data;
}

// reads, updates and returns the _sfp_presence_data
const set<int> PonTrxBase::read_sfp_presence_data() {
    set<int> sp;
    // command to read the sfp presence array
    // The sample output of the command looks like below
    // root@localhost:~# onlpdump -p
    // Presence: 0 1 16
    const string& command = _sfp_presence_command;
    int status_code = system((command + " > temp.txt").c_str());
    if (status_code != 0) {
        perror("error getting sfp presence array from ONL\n");
        // return the current _sfp_presence_data
        return _sfp_presence_data;
    }
    ifstream ifs("temp.txt");
    string res = {istreambuf_iterator<char>(ifs), istreambuf_iterator<char>()};
    ifs.close(); // must close the inout stream so the file can be cleaned up
    // If there is issue reading the sfp presence array, print error and return existing data
    if (remove("temp.txt") != 0) {
        perror("Error deleting temporary file");
        // return the current sfp presence array
        return _sfp_presence_data;
    }

    // parse the output of sfp presence command and read which PON Trx are connected/disconnected now
    stringstream ss(res);
    string s;
    while (getline(ss, s, ' ')) {
        try {
            int i = stoi(s);
            // Set the Trx port index corresponding the PON port to true if it appears on the sfp presence command output
            if (i < TOTAL_PON_TRX_PORTS) {
                sp.insert(i);
            }

        } catch(invalid_argument) {
            // do nothing
        } catch(out_of_range) {
            // do nothing
        }
    }

    // If the current _sfp_presence_data is not same the newly read data,
    // update local copy and also raise an event.
    if (sp != _sfp_presence_data) {
        cout << "sfp presence data has been updated\n";

        set<int> sfp_ports_up, sfp_ports_down;

        set_difference(sp.begin(), sp.end(), _sfp_presence_data.begin(), _sfp_presence_data.end(), inserter(sfp_ports_up, sfp_ports_up.begin()));
        // New SFPs are detected
        if (sfp_ports_up.size() > 0) {
            cout << "following pon sfp ports are up: ";
            for (auto up_it : sfp_ports_up) {
                cout << up_it << " ";
            }
            cout << "\n";
        }
        set_difference(_sfp_presence_data.begin(), _sfp_presence_data.end(), sp.begin(), sp.end(), inserter(sfp_ports_down, sfp_ports_down.begin()));
        // Some SFPs are down
        if (sfp_ports_down.size() > 0) {
            cout << "following pon sfp ports are down: \n";
            for (auto down_it : sfp_ports_down) {
                cout << down_it << " ";
            }
            cout << "\n";
        }

        // FIXME: raise an event for all the PON Trx ports that have been updated
        _sfp_presence_data = sp;
    }

    return _sfp_presence_data;
}

// reads the EEPROM data. The sfp_index is the bus index corresponding to the PON Trx
// returns true if success
bool PonTrxBase::read_eeprom_data_for_sfp(int sfp_index) {
    ifstream is;
    int len;
    array<char, EEPROM_READ_PATH_SIZE> path{};
    array<unsigned char, EEPROM_DATA_READ_SIZE> data{};

    if (sfp_index >= TOTAL_PON_TRX_PORTS) {
        perror("invalid pon trx index\n");
        return false;
    }

    if (_eeprom_read_path.count(sfp_index) == 0) {
        _eeprom_read_path[sfp_index] = path;
        char file_name[PON_TRX_BUS_FORMAT_SIZE];
        char *tmp_place_holder = new char[PON_TRX_BUS_FORMAT_SIZE];
        // 4 is max length of _port_addr
        if ((_eeprom_file_path_format.length() + _eeprom_file_name.length() + 4) > PON_TRX_BUS_FORMAT_SIZE) {
            cerr << "resultant eeprom file length too long\n";
            delete []tmp_place_holder;
            return false;
        }
        strcpy(tmp_place_holder, _eeprom_file_path_format.c_str());
        sprintf(file_name, tmp_place_holder, bus_index[sfp_index], _port_addr, _eeprom_file_name.c_str());
        memcpy(&_eeprom_read_path[sfp_index][0], file_name, PON_TRX_BUS_FORMAT_SIZE);
        delete []tmp_place_holder;
    }
    cout << "eeprom file to read is: " << _eeprom_read_path[sfp_index].data() << "for sfp " << sfp_index << endl;
    FILE* fp = fopen(_eeprom_read_path[sfp_index].data(), "rb");
    if (!fp) {
        perror("failed to open file");
        _eeprom_read_path.erase(sfp_index);
        return false;
    }
    _eeprom_data[sfp_index] = data;
    int val, cnt = 0;

    // Populate EEPROM data
    while ((val = fgetc(fp)) != EOF && cnt < EEPROM_DATA_READ_SIZE) {
        _eeprom_data[sfp_index][cnt] = (unsigned char)val;
        cnt++;
    }
    fclose(fp);
    if (cnt != EEPROM_DATA_READ_SIZE) {
        cerr << "invalid length of data read:" << cnt << endl;
        _eeprom_read_path.erase(sfp_index);
        _eeprom_data.erase(sfp_index);
        return false;
    }

    return true;
}

// decodes the EEPROM data. The sfp_index is the bus index corresponding to the PON Trx
// returns true if success
bool PonTrxBase::decode_eeprom_data(int sfp_index) {
    /*
    try {
    */

    trx_data tmp, *store=NULL;
    tmp.sfp_index = sfp_index;

    // decode vendor name
    array<unsigned char, EEPROM_VENDOR_NAME_LENGTH> vn{};
    copy(&_eeprom_data[sfp_index][EEPROM_VENDOR_NAME_START_IDX],
         &_eeprom_data[sfp_index][EEPROM_VENDOR_NAME_START_IDX] + EEPROM_VENDOR_NAME_LENGTH,
         &vn[0]);
    pair<string, bool> res_str = hex_to_ascii_string(vn.data(), vn.max_size());
    if (!res_str.second) {
        perror("error decoding vendor name\n");
        return false;
    }
    tmp.vendor_name = res_str.first;
    cout << "[" << sfp_index << "]" << " vendor name: " << tmp.vendor_name << endl;


    // decode vendor oui
    array<unsigned char, EEPROM_VENDOR_OUI_LENGTH> oui{};
    copy(&_eeprom_data[sfp_index][EEPROM_VENDOR_OUI_START_IDX],
         &_eeprom_data[sfp_index][EEPROM_VENDOR_OUI_START_IDX] + EEPROM_VENDOR_OUI_LENGTH,
         &oui[0]);
    res_str = hex_to_ascii_string(oui.data(), oui.max_size());
    if (!res_str.second) {
        perror("error decoding vendor oui\n");
        return false;
    }
    if (res_str.first.length() == 3) { // vendor_oui length is 3
        memcpy(tmp.vendor_oui, res_str.first.c_str(), 3);
    }
    cout << "[" << sfp_index << "]" << " vendor oui: " << res_str.first << endl;

    // decode vendor part number
    array<unsigned char, EEPROM_VENDOR_PART_NUMBER_LENGTH> pn{};
    copy(&_eeprom_data[sfp_index][EEPROM_VENDOR_PART_NUMBER_START_IDX],
         &_eeprom_data[sfp_index][EEPROM_VENDOR_PART_NUMBER_START_IDX] + EEPROM_VENDOR_PART_NUMBER_LENGTH,
         &pn[0]);
    res_str = hex_to_ascii_string(pn.data(), pn.max_size());
    if (!res_str.second) {
        perror("error decoding vendor part number\n");
        return false;
    }
    tmp.vendor_part_no = res_str.first;
    cout << "[" << sfp_index << "]" << " vendor pn: " << tmp.vendor_part_no << endl;

    // decode vendor revision
    array<unsigned char, EEPROM_VENDOR_REVISION_LENGTH> rev{};
    copy(&_eeprom_data[sfp_index][EEPROM_VENDOR_REVISION_START_IDX],
         &_eeprom_data[sfp_index][EEPROM_VENDOR_REVISION_START_IDX] + EEPROM_VENDOR_REVISION_LENGTH,
         &rev[0]);
    res_str = hex_to_ascii_string(rev.data(), rev.max_size());
    if (!res_str.second) {
        perror("error decoding vendor revision\n");
        return false;
    }
    tmp.vendor_rev = res_str.first;
    cout << "[" << sfp_index << "]" << " vendor rev: " << tmp.vendor_rev << endl;

    // decode pon wavelength(s)
    array<unsigned char, EEPROM_DOWNSTREAM_WAVELENGTH_LENGTH> wv{};
    copy(&_eeprom_data[sfp_index][EEPROM_DOWNSTREAM_WAVELENGTH_START_IDX],
         &_eeprom_data[sfp_index][EEPROM_DOWNSTREAM_WAVELENGTH_START_IDX] + EEPROM_DOWNSTREAM_WAVELENGTH_LENGTH,
         &wv[0]);
    pair<uint32_t, bool> res_uint = hex_to_uinteger(wv.data(), wv.max_size());
    if (!res_uint.second) {
        perror("error decoding primary downstream wavelength\n");
        return false;
    }
    tmp.p_data[0].valid = true;
    tmp.p_data[0].wavelength = res_uint.first * EEPROM_WAVELENGTH_RESOLUTION;
    tmp.p_data[0].pon_type = get_pon_type_from_wavelength(tmp.p_data[0].wavelength);
    cout << "[" << sfp_index << "]" << " pon wavelength: " << tmp.p_data[0].wavelength << endl;
    // TODO: also fill the field pon_type

    // TODO: Let's ignore secondary wavelength decode for now as we do not know how the secondary wavelength is represent on the Combo PON
    tmp.p_data[1].valid = false;

    store = new(nothrow) trx_data;
    if (store == NULL) {
        perror("could not allocate memory for trx_data");
        return false;
    }

    // Copy data
    store->sfp_index = sfp_index;
    store->vendor_name = tmp.vendor_name;
    memcpy(store->vendor_oui, tmp.vendor_oui, 3);
    store->vendor_part_no = tmp.vendor_part_no;
    store->vendor_rev = tmp.vendor_rev;
    store->trx_type = tmp.trx_type;
    for (int i = 0; i < MAX_PONS_PER_TRX; i++) {
        store->p_data[i].valid = tmp.p_data[i].valid;
        store->p_data[i].wavelength = tmp.p_data[i].wavelength;
        store->p_data[i].pon_type = tmp.p_data[i].pon_type;
    }

    _t_data.insert(store);
    /*
    } catch(...) { // FIXME: Put specific exceptions here
        perror("caught exception\n");
        return false;
    }
    */
    return true;
}

bcmolt_pon_type PonTrxBase::get_pon_type_from_wavelength(int wavelength) {
    bcmolt_pon_type pon_type = BCMOLT_PON_TYPE_UNKNOWN;
    switch (wavelength) {
        case GPON_DOWNSTREAM_WAVELENGTH_NM:
            pon_type = BCMOLT_PON_TYPE_GPON;
        case XGSPON_DOWNSTREAM_WAVELENGTH_NM:
            pon_type = BCMOLT_PON_TYPE_XGPON;
        // Add more in the future as needed.
    }
    return pon_type;
}

bcmolt_pon_type PonTrxBase::get_sfp_mode(int sfp_index) {
    bcmolt_pon_type pon0_type = BCMOLT_PON_TYPE_UNKNOWN;
    bcmolt_pon_type pon1_type = BCMOLT_PON_TYPE_UNKNOWN;
    trx_data *td = NULL;
    set<trx_data*>::iterator it;
    // Iterate the trx data set and break if we find a trx data with mathcing sfp index
    for (it = _t_data.begin(); it != _t_data.end(); it++) {
        if ((*it)->sfp_index == sfp_index) {
            td = *it;
            break;
        }
    }
    if (it == _t_data.end()) {
        perror("end of iterator, pon type not detected");
        return pon0_type;
    }
    if (td == NULL) {
        cerr << "trx data is null\n";
        return pon0_type;
    }

    // Find the PON type/mode
    if (td->p_data[0].valid) {
        pon0_type = td->p_data[0].pon_type;
        if (pon0_type == BCMOLT_PON_TYPE_UNKNOWN) {
            return pon0_type;
        }
        if (td->p_data[1].valid) {
            pon1_type = td->p_data[1].pon_type;
            if (pon1_type == BCMOLT_PON_TYPE_UNKNOWN) {
                return pon1_type;
            }

            if  (pon0_type == pon1_type) {
                return pon0_type;
            } else {
                return BCMOLT_PON_TYPE_XGPON_GPON_WDMA; // Combo SFP!
            }
        }
        return pon0_type;
    }

    return pon0_type;
}

// Returns the MAC System Mode based on the set of SFP IDs provided.
// The derived class will most likely need to override this method to provide a
// different implementation for that particular OLT platform.
pair<bcmolt_system_mode, bool> PonTrxBase::get_mac_system_mode(int olt_mac_id, set<int> sfp_ids) {
    bool ret = true;
    bcmolt_system_mode sm = BCMOLT_SYSTEM_MODE_GPON__16_X;

    return {sm, ret};
}

// Get trx data for sfp
trx_data* PonTrxBase::get_trx_data(int sfp_index) {
    for (auto it : _t_data) {
        if (it->sfp_index == sfp_index) {
            cout << "[" << sfp_index << "]" << " found trx data\n";
            return (it);
        }
    }
    return NULL;
}