1abb87edaSPriyangaRamasamy #include "config.h" 2abb87edaSPriyangaRamasamy 36c71c9dcSSunny Srivastava #include "common_utility.hpp" 4abb87edaSPriyangaRamasamy #include "defines.hpp" 56c71c9dcSSunny Srivastava #include "ibm_vpd_utils.hpp" 6e12b181bSSunnySrivastava1984 #include "ipz_parser.hpp" 7abb87edaSPriyangaRamasamy #include "keyword_vpd_parser.hpp" 8a00936f8SAlpana Kumari #include "memory_vpd_parser.hpp" 9e12b181bSSunnySrivastava1984 #include "parser_factory.hpp" 10a20be8ecSSunnySrivastava1984 #include "vpd_exceptions.hpp" 11abb87edaSPriyangaRamasamy 129094d4f6SSunnySrivastava1984 #include <assert.h> 138ea3f6d0SAlpana Kumari #include <ctype.h> 148ea3f6d0SAlpana Kumari 15abb87edaSPriyangaRamasamy #include <CLI/CLI.hpp> 1688edeb6fSSantosh Puranik #include <algorithm> 177ce68724Salpana07 #include <boost/algorithm/string.hpp> 1865b83601SAlpana Kumari #include <cstdarg> 19abb87edaSPriyangaRamasamy #include <exception> 2083a1d5deSPriyangaRamasamy #include <filesystem> 21abb87edaSPriyangaRamasamy #include <fstream> 222f793048SAlpana Kumari #include <gpiod.hpp> 23abb87edaSPriyangaRamasamy #include <iostream> 24abb87edaSPriyangaRamasamy #include <iterator> 25abb87edaSPriyangaRamasamy #include <nlohmann/json.hpp> 26280197e3SAndrew Geissler #include <phosphor-logging/log.hpp> 277ce68724Salpana07 #include <regex> 28abb87edaSPriyangaRamasamy 29abb87edaSPriyangaRamasamy using namespace std; 30abb87edaSPriyangaRamasamy using namespace openpower::vpd; 31abb87edaSPriyangaRamasamy using namespace CLI; 32abb87edaSPriyangaRamasamy using namespace vpd::keyword::parser; 3383a1d5deSPriyangaRamasamy using namespace openpower::vpd::constants; 3483a1d5deSPriyangaRamasamy namespace fs = filesystem; 3583a1d5deSPriyangaRamasamy using json = nlohmann::json; 36e12b181bSSunnySrivastava1984 using namespace openpower::vpd::parser::factory; 37945a02d3SSunnySrivastava1984 using namespace openpower::vpd::inventory; 38a00936f8SAlpana Kumari using namespace openpower::vpd::memory::parser; 39e12b181bSSunnySrivastava1984 using namespace openpower::vpd::parser::interface; 40a20be8ecSSunnySrivastava1984 using namespace openpower::vpd::exceptions; 41280197e3SAndrew Geissler using namespace phosphor::logging; 42abb87edaSPriyangaRamasamy 433c24414fSSunny Srivastava // Map to hold record, kwd pair which can be re-stored at standby. 443c24414fSSunny Srivastava // The list of keywords for VSYS record is as per the S0 system. Should 453c24414fSSunny Srivastava // be updated for another type of systems 463c24414fSSunny Srivastava static const std::unordered_map<std::string, std::vector<std::string>> 473c24414fSSunny Srivastava svpdKwdMap{{"VSYS", {"BR", "TM", "SE", "SU", "RB"}}, 483c24414fSSunny Srivastava {"VCEN", {"FC", "SE"}}, 493c24414fSSunny Srivastava {"LXR0", {"LX"}}}; 503c24414fSSunny Srivastava 5188edeb6fSSantosh Puranik /** 528589375fSSantosh Puranik * @brief Returns the power state for chassis0 538589375fSSantosh Puranik */ 548589375fSSantosh Puranik static auto getPowerState() 558589375fSSantosh Puranik { 568589375fSSantosh Puranik // TODO: How do we handle multiple chassis? 578589375fSSantosh Puranik string powerState{}; 588589375fSSantosh Puranik auto bus = sdbusplus::bus::new_default(); 598589375fSSantosh Puranik auto properties = 608589375fSSantosh Puranik bus.new_method_call("xyz.openbmc_project.State.Chassis", 618589375fSSantosh Puranik "/xyz/openbmc_project/state/chassis0", 628589375fSSantosh Puranik "org.freedesktop.DBus.Properties", "Get"); 638589375fSSantosh Puranik properties.append("xyz.openbmc_project.State.Chassis"); 648589375fSSantosh Puranik properties.append("CurrentPowerState"); 658589375fSSantosh Puranik auto result = bus.call(properties); 668589375fSSantosh Puranik if (!result.is_method_error()) 678589375fSSantosh Puranik { 688589375fSSantosh Puranik variant<string> val; 698589375fSSantosh Puranik result.read(val); 708589375fSSantosh Puranik if (auto pVal = get_if<string>(&val)) 718589375fSSantosh Puranik { 728589375fSSantosh Puranik powerState = *pVal; 738589375fSSantosh Puranik } 748589375fSSantosh Puranik } 758589375fSSantosh Puranik cout << "Power state is: " << powerState << endl; 768589375fSSantosh Puranik return powerState; 778589375fSSantosh Puranik } 788589375fSSantosh Puranik 798589375fSSantosh Puranik /** 8088edeb6fSSantosh Puranik * @brief Expands location codes 8188edeb6fSSantosh Puranik */ 8288edeb6fSSantosh Puranik static auto expandLocationCode(const string& unexpanded, const Parsed& vpdMap, 8388edeb6fSSantosh Puranik bool isSystemVpd) 8488edeb6fSSantosh Puranik { 8588edeb6fSSantosh Puranik auto expanded{unexpanded}; 8688edeb6fSSantosh Puranik static constexpr auto SYSTEM_OBJECT = "/system/chassis/motherboard"; 8788edeb6fSSantosh Puranik static constexpr auto VCEN_IF = "com.ibm.ipzvpd.VCEN"; 8888edeb6fSSantosh Puranik static constexpr auto VSYS_IF = "com.ibm.ipzvpd.VSYS"; 8988edeb6fSSantosh Puranik size_t idx = expanded.find("fcs"); 9088edeb6fSSantosh Puranik try 9188edeb6fSSantosh Puranik { 9288edeb6fSSantosh Puranik if (idx != string::npos) 9388edeb6fSSantosh Puranik { 9488edeb6fSSantosh Puranik string fc{}; 9588edeb6fSSantosh Puranik string se{}; 9688edeb6fSSantosh Puranik if (isSystemVpd) 9788edeb6fSSantosh Puranik { 9888edeb6fSSantosh Puranik const auto& fcData = vpdMap.at("VCEN").at("FC"); 9988edeb6fSSantosh Puranik const auto& seData = vpdMap.at("VCEN").at("SE"); 10088edeb6fSSantosh Puranik fc = string(fcData.data(), fcData.size()); 10188edeb6fSSantosh Puranik se = string(seData.data(), seData.size()); 10288edeb6fSSantosh Puranik } 10388edeb6fSSantosh Puranik else 10488edeb6fSSantosh Puranik { 10588edeb6fSSantosh Puranik fc = readBusProperty(SYSTEM_OBJECT, VCEN_IF, "FC"); 10688edeb6fSSantosh Puranik se = readBusProperty(SYSTEM_OBJECT, VCEN_IF, "SE"); 10788edeb6fSSantosh Puranik } 10888edeb6fSSantosh Puranik 10981671f6dSAlpana Kumari // TODO: See if ND0 can be placed in the JSON 11081671f6dSAlpana Kumari expanded.replace(idx, 3, fc.substr(0, 4) + ".ND0." + se); 11188edeb6fSSantosh Puranik } 11288edeb6fSSantosh Puranik else 11388edeb6fSSantosh Puranik { 11488edeb6fSSantosh Puranik idx = expanded.find("mts"); 11588edeb6fSSantosh Puranik if (idx != string::npos) 11688edeb6fSSantosh Puranik { 11788edeb6fSSantosh Puranik string mt{}; 11888edeb6fSSantosh Puranik string se{}; 11988edeb6fSSantosh Puranik if (isSystemVpd) 12088edeb6fSSantosh Puranik { 12188edeb6fSSantosh Puranik const auto& mtData = vpdMap.at("VSYS").at("TM"); 12288edeb6fSSantosh Puranik const auto& seData = vpdMap.at("VSYS").at("SE"); 12388edeb6fSSantosh Puranik mt = string(mtData.data(), mtData.size()); 12488edeb6fSSantosh Puranik se = string(seData.data(), seData.size()); 12588edeb6fSSantosh Puranik } 12688edeb6fSSantosh Puranik else 12788edeb6fSSantosh Puranik { 12888edeb6fSSantosh Puranik mt = readBusProperty(SYSTEM_OBJECT, VSYS_IF, "TM"); 12988edeb6fSSantosh Puranik se = readBusProperty(SYSTEM_OBJECT, VSYS_IF, "SE"); 13088edeb6fSSantosh Puranik } 13188edeb6fSSantosh Puranik 13288edeb6fSSantosh Puranik replace(mt.begin(), mt.end(), '-', '.'); 13388edeb6fSSantosh Puranik expanded.replace(idx, 3, mt + "." + se); 13488edeb6fSSantosh Puranik } 13588edeb6fSSantosh Puranik } 13688edeb6fSSantosh Puranik } 1378e15b93aSPatrick Williams catch (const exception& e) 13888edeb6fSSantosh Puranik { 13958e22145SAlpana Kumari cerr << "Failed to expand location code with exception: " << e.what() 14058e22145SAlpana Kumari << "\n"; 14188edeb6fSSantosh Puranik } 14288edeb6fSSantosh Puranik return expanded; 14388edeb6fSSantosh Puranik } 1442f793048SAlpana Kumari 145abb87edaSPriyangaRamasamy /** 146abb87edaSPriyangaRamasamy * @brief Populate FRU specific interfaces. 147abb87edaSPriyangaRamasamy * 148abb87edaSPriyangaRamasamy * This is a common method which handles both 149abb87edaSPriyangaRamasamy * ipz and keyword specific interfaces thus, 150abb87edaSPriyangaRamasamy * reducing the code redundancy. 151abb87edaSPriyangaRamasamy * @param[in] map - Reference to the innermost keyword-value map. 152abb87edaSPriyangaRamasamy * @param[in] preIntrStr - Reference to the interface string. 153abb87edaSPriyangaRamasamy * @param[out] interfaces - Reference to interface map. 154abb87edaSPriyangaRamasamy */ 155abb87edaSPriyangaRamasamy template <typename T> 156abb87edaSPriyangaRamasamy static void populateFruSpecificInterfaces(const T& map, 157abb87edaSPriyangaRamasamy const string& preIntrStr, 158abb87edaSPriyangaRamasamy inventory::InterfaceMap& interfaces) 159abb87edaSPriyangaRamasamy { 160abb87edaSPriyangaRamasamy inventory::PropertyMap prop; 161abb87edaSPriyangaRamasamy 162abb87edaSPriyangaRamasamy for (const auto& kwVal : map) 163abb87edaSPriyangaRamasamy { 164abb87edaSPriyangaRamasamy auto kw = kwVal.first; 165abb87edaSPriyangaRamasamy 166abb87edaSPriyangaRamasamy if (kw[0] == '#') 167abb87edaSPriyangaRamasamy { 16858e22145SAlpana Kumari kw = string("PD_") + kw[1]; 169abb87edaSPriyangaRamasamy } 1708ea3f6d0SAlpana Kumari else if (isdigit(kw[0])) 1718ea3f6d0SAlpana Kumari { 17258e22145SAlpana Kumari kw = string("N_") + kw; 1738ea3f6d0SAlpana Kumari } 1743ab26a74SAlpana Kumari if constexpr (is_same<T, KeywordVpdMap>::value) 1753ab26a74SAlpana Kumari { 1763ab26a74SAlpana Kumari if (get_if<Binary>(&kwVal.second)) 1773ab26a74SAlpana Kumari { 1783ab26a74SAlpana Kumari Binary vec(get_if<Binary>(&kwVal.second)->begin(), 1793ab26a74SAlpana Kumari get_if<Binary>(&kwVal.second)->end()); 180abb87edaSPriyangaRamasamy prop.emplace(move(kw), move(vec)); 181abb87edaSPriyangaRamasamy } 1823ab26a74SAlpana Kumari else 1833ab26a74SAlpana Kumari { 1843ab26a74SAlpana Kumari if (kw == "MemorySizeInKB") 1853ab26a74SAlpana Kumari { 1863ab26a74SAlpana Kumari inventory::PropertyMap memProp; 1873ab26a74SAlpana Kumari auto memVal = get_if<size_t>(&kwVal.second); 1883ab26a74SAlpana Kumari if (memVal) 1893ab26a74SAlpana Kumari { 1903ab26a74SAlpana Kumari memProp.emplace(move(kw), 1913ab26a74SAlpana Kumari ((*memVal) * CONVERT_MB_TO_KB)); 1923ab26a74SAlpana Kumari interfaces.emplace( 1933ab26a74SAlpana Kumari "xyz.openbmc_project.Inventory.Item.Dimm", 1943ab26a74SAlpana Kumari move(memProp)); 1953ab26a74SAlpana Kumari } 1963ab26a74SAlpana Kumari else 1973ab26a74SAlpana Kumari { 1983ab26a74SAlpana Kumari cerr << "MemorySizeInKB value not found in vpd map\n"; 1993ab26a74SAlpana Kumari } 2003ab26a74SAlpana Kumari } 2013ab26a74SAlpana Kumari } 2023ab26a74SAlpana Kumari } 2033ab26a74SAlpana Kumari else 2043ab26a74SAlpana Kumari { 2053ab26a74SAlpana Kumari Binary vec(kwVal.second.begin(), kwVal.second.end()); 2063ab26a74SAlpana Kumari prop.emplace(move(kw), move(vec)); 2073ab26a74SAlpana Kumari } 2083ab26a74SAlpana Kumari } 209abb87edaSPriyangaRamasamy 210abb87edaSPriyangaRamasamy interfaces.emplace(preIntrStr, move(prop)); 211abb87edaSPriyangaRamasamy } 212abb87edaSPriyangaRamasamy 213abb87edaSPriyangaRamasamy /** 214abb87edaSPriyangaRamasamy * @brief Populate Interfaces. 215abb87edaSPriyangaRamasamy * 216abb87edaSPriyangaRamasamy * This method populates common and extra interfaces to dbus. 217abb87edaSPriyangaRamasamy * @param[in] js - json object 218abb87edaSPriyangaRamasamy * @param[out] interfaces - Reference to interface map 219abb87edaSPriyangaRamasamy * @param[in] vpdMap - Reference to the parsed vpd map. 22088edeb6fSSantosh Puranik * @param[in] isSystemVpd - Denotes whether we are collecting the system VPD. 221abb87edaSPriyangaRamasamy */ 222abb87edaSPriyangaRamasamy template <typename T> 223abb87edaSPriyangaRamasamy static void populateInterfaces(const nlohmann::json& js, 224abb87edaSPriyangaRamasamy inventory::InterfaceMap& interfaces, 22588edeb6fSSantosh Puranik const T& vpdMap, bool isSystemVpd) 226abb87edaSPriyangaRamasamy { 227abb87edaSPriyangaRamasamy for (const auto& ifs : js.items()) 228abb87edaSPriyangaRamasamy { 22988edeb6fSSantosh Puranik string inf = ifs.key(); 230abb87edaSPriyangaRamasamy inventory::PropertyMap props; 231abb87edaSPriyangaRamasamy 232abb87edaSPriyangaRamasamy for (const auto& itr : ifs.value().items()) 233abb87edaSPriyangaRamasamy { 23488edeb6fSSantosh Puranik const string& busProp = itr.key(); 23588edeb6fSSantosh Puranik 23631970dedSAlpana Kumari if (itr.value().is_boolean()) 23731970dedSAlpana Kumari { 23888edeb6fSSantosh Puranik props.emplace(busProp, itr.value().get<bool>()); 23988edeb6fSSantosh Puranik } 24088edeb6fSSantosh Puranik else if (itr.value().is_string()) 24188edeb6fSSantosh Puranik { 2420d61c588SPriyanga Ramasamy if (busProp == "LocationCode" && inf == IBM_LOCATION_CODE_INF) 2430d61c588SPriyanga Ramasamy { 2440d61c588SPriyanga Ramasamy std::string prop; 24558e22145SAlpana Kumari if constexpr (is_same<T, Parsed>::value) 24688edeb6fSSantosh Puranik { 247414d5aefSAlpana Kumari // TODO deprecate the com.ibm interface later 2480d61c588SPriyanga Ramasamy prop = expandLocationCode(itr.value().get<string>(), 2490d61c588SPriyanga Ramasamy vpdMap, isSystemVpd); 2500d61c588SPriyanga Ramasamy } 2510d61c588SPriyanga Ramasamy else if constexpr (is_same<T, KeywordVpdMap>::value) 2520d61c588SPriyanga Ramasamy { 2530d61c588SPriyanga Ramasamy // Send empty Parsed object to expandLocationCode api. 2540d61c588SPriyanga Ramasamy prop = expandLocationCode(itr.value().get<string>(), 2550d61c588SPriyanga Ramasamy Parsed{}, false); 2560d61c588SPriyanga Ramasamy } 25788edeb6fSSantosh Puranik props.emplace(busProp, prop); 258414d5aefSAlpana Kumari interfaces.emplace(XYZ_LOCATION_CODE_INF, props); 25969f76024SPriyanga Ramasamy interfaces.emplace(IBM_LOCATION_CODE_INF, props); 26088edeb6fSSantosh Puranik } 26188edeb6fSSantosh Puranik else 26288edeb6fSSantosh Puranik { 26388edeb6fSSantosh Puranik props.emplace(busProp, itr.value().get<string>()); 26488edeb6fSSantosh Puranik } 26588edeb6fSSantosh Puranik } 266ed609affSSantosh Puranik else if (itr.value().is_array()) 267ed609affSSantosh Puranik { 268ed609affSSantosh Puranik try 269ed609affSSantosh Puranik { 270ed609affSSantosh Puranik props.emplace(busProp, itr.value().get<Binary>()); 271ed609affSSantosh Puranik } 2728e15b93aSPatrick Williams catch (const nlohmann::detail::type_error& e) 273ed609affSSantosh Puranik { 274ed609affSSantosh Puranik std::cerr << "Type exception: " << e.what() << "\n"; 275ed609affSSantosh Puranik // Ignore any type errors 276ed609affSSantosh Puranik } 277ed609affSSantosh Puranik } 27831970dedSAlpana Kumari else if (itr.value().is_object()) 27931970dedSAlpana Kumari { 280abb87edaSPriyangaRamasamy const string& rec = itr.value().value("recordName", ""); 281abb87edaSPriyangaRamasamy const string& kw = itr.value().value("keywordName", ""); 282abb87edaSPriyangaRamasamy const string& encoding = itr.value().value("encoding", ""); 283abb87edaSPriyangaRamasamy 28458e22145SAlpana Kumari if constexpr (is_same<T, Parsed>::value) 285abb87edaSPriyangaRamasamy { 28688edeb6fSSantosh Puranik if (!rec.empty() && !kw.empty() && vpdMap.count(rec) && 28788edeb6fSSantosh Puranik vpdMap.at(rec).count(kw)) 288abb87edaSPriyangaRamasamy { 289abb87edaSPriyangaRamasamy auto encoded = 290abb87edaSPriyangaRamasamy encodeKeyword(vpdMap.at(rec).at(kw), encoding); 29188edeb6fSSantosh Puranik props.emplace(busProp, encoded); 292abb87edaSPriyangaRamasamy } 293abb87edaSPriyangaRamasamy } 29458e22145SAlpana Kumari else if constexpr (is_same<T, KeywordVpdMap>::value) 295abb87edaSPriyangaRamasamy { 296abb87edaSPriyangaRamasamy if (!kw.empty() && vpdMap.count(kw)) 297abb87edaSPriyangaRamasamy { 2983ab26a74SAlpana Kumari auto kwValue = get_if<Binary>(&vpdMap.at(kw)); 2993ab26a74SAlpana Kumari auto uintValue = get_if<size_t>(&vpdMap.at(kw)); 3003ab26a74SAlpana Kumari 3013ab26a74SAlpana Kumari if (kwValue) 3023ab26a74SAlpana Kumari { 303abb87edaSPriyangaRamasamy auto prop = 3043ab26a74SAlpana Kumari string((*kwValue).begin(), (*kwValue).end()); 3053ab26a74SAlpana Kumari 306abb87edaSPriyangaRamasamy auto encoded = encodeKeyword(prop, encoding); 3073ab26a74SAlpana Kumari 30888edeb6fSSantosh Puranik props.emplace(busProp, encoded); 309abb87edaSPriyangaRamasamy } 3103ab26a74SAlpana Kumari else if (uintValue) 3113ab26a74SAlpana Kumari { 3123ab26a74SAlpana Kumari props.emplace(busProp, *uintValue); 3133ab26a74SAlpana Kumari } 3143ab26a74SAlpana Kumari } 315abb87edaSPriyangaRamasamy } 316abb87edaSPriyangaRamasamy } 317b1e64bb6SMatt Spinler else if (itr.value().is_number()) 318b1e64bb6SMatt Spinler { 319b1e64bb6SMatt Spinler // For now assume the value is a size_t. In the future it would 320b1e64bb6SMatt Spinler // be nice to come up with a way to get the type from the JSON. 321b1e64bb6SMatt Spinler props.emplace(busProp, itr.value().get<size_t>()); 322b1e64bb6SMatt Spinler } 32331970dedSAlpana Kumari } 324abb87edaSPriyangaRamasamy interfaces.emplace(inf, move(props)); 325abb87edaSPriyangaRamasamy } 326abb87edaSPriyangaRamasamy } 327abb87edaSPriyangaRamasamy 32837233785SPriyanga Ramasamy /*API to reset EEPROM pointer to a safe position to avoid VPD corruption. 32937233785SPriyanga Ramasamy * Currently do reset only for DIMM VPD.*/ 33037233785SPriyanga Ramasamy static void resetEEPROMPointer(const nlohmann::json& js, const string& file, 33137233785SPriyanga Ramasamy ifstream& vpdFile) 33237233785SPriyanga Ramasamy { 33337233785SPriyanga Ramasamy for (const auto& item : js["frus"][file]) 33437233785SPriyanga Ramasamy { 33537233785SPriyanga Ramasamy if (item.find("extraInterfaces") != item.end()) 33637233785SPriyanga Ramasamy { 33737233785SPriyanga Ramasamy if (item["extraInterfaces"].find( 33837233785SPriyanga Ramasamy "xyz.openbmc_project.Inventory.Item.Dimm") != 33937233785SPriyanga Ramasamy item["extraInterfaces"].end()) 34037233785SPriyanga Ramasamy { 34137233785SPriyanga Ramasamy // moves the EEPROM pointer to 2048 'th byte. 34237233785SPriyanga Ramasamy vpdFile.seekg(2047, std::ios::beg); 34337233785SPriyanga Ramasamy // Read that byte and discard - to affirm the move 34437233785SPriyanga Ramasamy // operation. 34537233785SPriyanga Ramasamy char ch; 34637233785SPriyanga Ramasamy vpdFile.read(&ch, sizeof(ch)); 34737233785SPriyanga Ramasamy } 34837233785SPriyanga Ramasamy return; 34937233785SPriyanga Ramasamy } 35037233785SPriyanga Ramasamy } 35137233785SPriyanga Ramasamy } 35237233785SPriyanga Ramasamy 3532f793048SAlpana Kumari static Binary getVpdDataInVector(const nlohmann::json& js, const string& file) 35458e22145SAlpana Kumari { 35558e22145SAlpana Kumari uint32_t offset = 0; 35658e22145SAlpana Kumari // check if offset present? 35758e22145SAlpana Kumari for (const auto& item : js["frus"][file]) 35858e22145SAlpana Kumari { 35958e22145SAlpana Kumari if (item.find("offset") != item.end()) 36058e22145SAlpana Kumari { 36158e22145SAlpana Kumari offset = item["offset"]; 36258e22145SAlpana Kumari } 36358e22145SAlpana Kumari } 36458e22145SAlpana Kumari 36558e22145SAlpana Kumari // TODO: Figure out a better way to get max possible VPD size. 3663c2a2b9eSPriyanga Ramasamy auto maxVPDSize = std::min(std::filesystem::file_size(file), 3673c2a2b9eSPriyanga Ramasamy static_cast<uintmax_t>(65504)); 3683c2a2b9eSPriyanga Ramasamy 36958e22145SAlpana Kumari Binary vpdVector; 3703c2a2b9eSPriyanga Ramasamy vpdVector.resize(maxVPDSize); 37158e22145SAlpana Kumari ifstream vpdFile; 37258e22145SAlpana Kumari vpdFile.open(file, ios::binary); 37358e22145SAlpana Kumari 37458e22145SAlpana Kumari vpdFile.seekg(offset, ios_base::cur); 3753c2a2b9eSPriyanga Ramasamy vpdFile.read(reinterpret_cast<char*>(&vpdVector[0]), maxVPDSize); 37658e22145SAlpana Kumari vpdVector.resize(vpdFile.gcount()); 37758e22145SAlpana Kumari 37837233785SPriyanga Ramasamy resetEEPROMPointer(js, file, vpdFile); 37937233785SPriyanga Ramasamy 38058e22145SAlpana Kumari return vpdVector; 38158e22145SAlpana Kumari } 38258e22145SAlpana Kumari 3832f793048SAlpana Kumari /** This API will be called at the end of VPD collection to perform any post 3842f793048SAlpana Kumari * actions. 3852f793048SAlpana Kumari * 3862f793048SAlpana Kumari * @param[in] json - json object 3872f793048SAlpana Kumari * @param[in] file - eeprom file path 3882f793048SAlpana Kumari */ 3892f793048SAlpana Kumari static void postFailAction(const nlohmann::json& json, const string& file) 3902f793048SAlpana Kumari { 3912f793048SAlpana Kumari if ((json["frus"][file].at(0)).find("postActionFail") == 3922f793048SAlpana Kumari json["frus"][file].at(0).end()) 3932f793048SAlpana Kumari { 3942f793048SAlpana Kumari return; 3952f793048SAlpana Kumari } 3962f793048SAlpana Kumari 3972f793048SAlpana Kumari uint8_t pinValue = 0; 3982f793048SAlpana Kumari string pinName; 3992f793048SAlpana Kumari 4002f793048SAlpana Kumari for (const auto& postAction : 4012f793048SAlpana Kumari (json["frus"][file].at(0))["postActionFail"].items()) 4022f793048SAlpana Kumari { 4032f793048SAlpana Kumari if (postAction.key() == "pin") 4042f793048SAlpana Kumari { 4052f793048SAlpana Kumari pinName = postAction.value(); 4062f793048SAlpana Kumari } 4072f793048SAlpana Kumari else if (postAction.key() == "value") 4082f793048SAlpana Kumari { 4092f793048SAlpana Kumari // Get the value to set 4102f793048SAlpana Kumari pinValue = postAction.value(); 4112f793048SAlpana Kumari } 4122f793048SAlpana Kumari } 4132f793048SAlpana Kumari 4142f793048SAlpana Kumari cout << "Setting GPIO: " << pinName << " to " << (int)pinValue << endl; 4152f793048SAlpana Kumari 4162f793048SAlpana Kumari try 4172f793048SAlpana Kumari { 4182f793048SAlpana Kumari gpiod::line outputLine = gpiod::find_line(pinName); 4192f793048SAlpana Kumari 4202f793048SAlpana Kumari if (!outputLine) 4212f793048SAlpana Kumari { 4222f793048SAlpana Kumari cout << "Couldn't find output line:" << pinName 4232f793048SAlpana Kumari << " on GPIO. Skipping...\n"; 4242f793048SAlpana Kumari 4252f793048SAlpana Kumari return; 4262f793048SAlpana Kumari } 4272f793048SAlpana Kumari outputLine.request( 4282f793048SAlpana Kumari {"Disable line", ::gpiod::line_request::DIRECTION_OUTPUT, 0}, 4292f793048SAlpana Kumari pinValue); 4302f793048SAlpana Kumari } 4318e15b93aSPatrick Williams catch (const system_error&) 4322f793048SAlpana Kumari { 4332f793048SAlpana Kumari cerr << "Failed to set post-action GPIO" << endl; 4342f793048SAlpana Kumari } 4352f793048SAlpana Kumari } 4362f793048SAlpana Kumari 4372e6c6f73SAlpana Kumari /** 4382e6c6f73SAlpana Kumari * @brief This sets the appropriate value to presence GPIO based on device 4392e6c6f73SAlpana Kumari * attached or not on expander GPIO, which enables that FRU's VPD collection. 4402f793048SAlpana Kumari * 4412f793048SAlpana Kumari * @param[in] json - json object 4422f793048SAlpana Kumari * @param[in] file - eeprom file path 4432f793048SAlpana Kumari */ 4442f793048SAlpana Kumari static void preAction(const nlohmann::json& json, const string& file) 4452f793048SAlpana Kumari { 4462e6c6f73SAlpana Kumari if ((json["frus"][file].at(0)).find("presence") != 4472f793048SAlpana Kumari json["frus"][file].at(0).end()) 4482f793048SAlpana Kumari { 4492e6c6f73SAlpana Kumari if (((json["frus"][file].at(0)["presence"]).find("pin") != 4502e6c6f73SAlpana Kumari json["frus"][file].at(0)["presence"].end()) && 4512e6c6f73SAlpana Kumari ((json["frus"][file].at(0)["presence"]).find("value") != 4522e6c6f73SAlpana Kumari json["frus"][file].at(0)["presence"].end())) 4532e6c6f73SAlpana Kumari { 454*2e14789fSSunny Srivastava string presPinName = json["frus"][file].at(0)["presence"]["pin"]; 455*2e14789fSSunny Srivastava Byte presPinValue = json["frus"][file].at(0)["presence"]["value"]; 4562e6c6f73SAlpana Kumari 4572e6c6f73SAlpana Kumari try 4582e6c6f73SAlpana Kumari { 4592e6c6f73SAlpana Kumari gpiod::line presenceLine = gpiod::find_line(presPinName); 4602e6c6f73SAlpana Kumari 4612e6c6f73SAlpana Kumari if (!presenceLine) 4622e6c6f73SAlpana Kumari { 4632e6c6f73SAlpana Kumari cerr << "couldn't find presence line:" << presPinName 4642e6c6f73SAlpana Kumari << "\n"; 4652f793048SAlpana Kumari return; 4662f793048SAlpana Kumari } 4672f793048SAlpana Kumari 4682e6c6f73SAlpana Kumari presenceLine.request({"Read the presence line", 4692e6c6f73SAlpana Kumari gpiod::line_request::DIRECTION_INPUT, 0}); 4702f793048SAlpana Kumari 4712e6c6f73SAlpana Kumari Byte gpioData = presenceLine.get_value(); 4722e6c6f73SAlpana Kumari 4732e6c6f73SAlpana Kumari if (gpioData != presPinValue) 4742f793048SAlpana Kumari { 4752e6c6f73SAlpana Kumari return; 4762f793048SAlpana Kumari } 4772e6c6f73SAlpana Kumari } 4782e6c6f73SAlpana Kumari catch (system_error&) 4792f793048SAlpana Kumari { 4802e6c6f73SAlpana Kumari cerr << "Failed to get the presence GPIO for - " << presPinName 4812e6c6f73SAlpana Kumari << endl; 4822e6c6f73SAlpana Kumari return; 4832e6c6f73SAlpana Kumari } 4842e6c6f73SAlpana Kumari } 4852e6c6f73SAlpana Kumari } 4862e6c6f73SAlpana Kumari 4872e6c6f73SAlpana Kumari if ((json["frus"][file].at(0)).find("preAction") != 4882e6c6f73SAlpana Kumari json["frus"][file].at(0).end()) 4892e6c6f73SAlpana Kumari { 4902e6c6f73SAlpana Kumari if (((json["frus"][file].at(0)["preAction"]).find("pin") != 4912e6c6f73SAlpana Kumari json["frus"][file].at(0)["preAction"].end()) && 4922e6c6f73SAlpana Kumari ((json["frus"][file].at(0)["preAction"]).find("value") != 4932e6c6f73SAlpana Kumari json["frus"][file].at(0)["preAction"].end())) 4942e6c6f73SAlpana Kumari { 4952e6c6f73SAlpana Kumari string pinName = json["frus"][file].at(0)["preAction"]["pin"]; 4962f793048SAlpana Kumari // Get the value to set 4972e6c6f73SAlpana Kumari Byte pinValue = json["frus"][file].at(0)["preAction"]["value"]; 4982f793048SAlpana Kumari 4992e6c6f73SAlpana Kumari cout << "Setting GPIO: " << pinName << " to " << (int)pinValue 5002e6c6f73SAlpana Kumari << endl; 5012f793048SAlpana Kumari try 5022f793048SAlpana Kumari { 5032f793048SAlpana Kumari gpiod::line outputLine = gpiod::find_line(pinName); 5042f793048SAlpana Kumari 5052f793048SAlpana Kumari if (!outputLine) 5062f793048SAlpana Kumari { 5072f793048SAlpana Kumari cout << "Couldn't find output line:" << pinName 5082f793048SAlpana Kumari << " on GPIO. Skipping...\n"; 5092f793048SAlpana Kumari 5102f793048SAlpana Kumari return; 5112f793048SAlpana Kumari } 5122e6c6f73SAlpana Kumari outputLine.request({"FRU pre-action", 5132e6c6f73SAlpana Kumari ::gpiod::line_request::DIRECTION_OUTPUT, 0}, 5142f793048SAlpana Kumari pinValue); 5152f793048SAlpana Kumari } 5162e6c6f73SAlpana Kumari catch (system_error&) 5172f793048SAlpana Kumari { 5182e6c6f73SAlpana Kumari cerr << "Failed to set pre-action for GPIO - " << pinName 5192e6c6f73SAlpana Kumari << endl; 5202f793048SAlpana Kumari return; 5212f793048SAlpana Kumari } 5222e6c6f73SAlpana Kumari } 5232e6c6f73SAlpana Kumari } 5242f793048SAlpana Kumari 5252f793048SAlpana Kumari // Now bind the device 5264c3bf5beSAlpana Kumari string bind = json["frus"][file].at(0).value("devAddress", ""); 5272f793048SAlpana Kumari cout << "Binding device " << bind << endl; 5282f793048SAlpana Kumari string bindCmd = string("echo \"") + bind + 5292f793048SAlpana Kumari string("\" > /sys/bus/i2c/drivers/at24/bind"); 5302f793048SAlpana Kumari cout << bindCmd << endl; 5312f793048SAlpana Kumari executeCmd(bindCmd); 5322f793048SAlpana Kumari 5332f793048SAlpana Kumari // Check if device showed up (test for file) 5342f793048SAlpana Kumari if (!fs::exists(file)) 5352f793048SAlpana Kumari { 5362f793048SAlpana Kumari cout << "EEPROM " << file << " does not exist. Take failure action" 5372f793048SAlpana Kumari << endl; 5382f793048SAlpana Kumari // If not, then take failure postAction 5392f793048SAlpana Kumari postFailAction(json, file); 5402f793048SAlpana Kumari } 5412f793048SAlpana Kumari } 5422f793048SAlpana Kumari 543abb87edaSPriyangaRamasamy /** 544d3a379a6SSantosh Puranik * @brief Set certain one time properties in the inventory 545d3a379a6SSantosh Puranik * Use this function to insert the Functional and Enabled properties into the 546d3a379a6SSantosh Puranik * inventory map. This function first checks if the object in question already 547d3a379a6SSantosh Puranik * has these properties hosted on D-Bus, if the property is already there, it is 548d3a379a6SSantosh Puranik * not modified, hence the name "one time". If the property is not already 549d3a379a6SSantosh Puranik * present, it will be added to the map with a suitable default value (true for 550d3a379a6SSantosh Puranik * Functional and false for Enabled) 551d3a379a6SSantosh Puranik * 552d3a379a6SSantosh Puranik * @param[in] object - The inventory D-Bus obejct without the inventory prefix. 553d3a379a6SSantosh Puranik * @param[inout] interfaces - Reference to a map of inventory interfaces to 554d3a379a6SSantosh Puranik * which the properties will be attached. 555d3a379a6SSantosh Puranik */ 556d3a379a6SSantosh Puranik static void setOneTimeProperties(const std::string& object, 557d3a379a6SSantosh Puranik inventory::InterfaceMap& interfaces) 558d3a379a6SSantosh Puranik { 559d3a379a6SSantosh Puranik auto bus = sdbusplus::bus::new_default(); 560d3a379a6SSantosh Puranik auto objectPath = INVENTORY_PATH + object; 561d3a379a6SSantosh Puranik auto prop = bus.new_method_call("xyz.openbmc_project.Inventory.Manager", 562d3a379a6SSantosh Puranik objectPath.c_str(), 563d3a379a6SSantosh Puranik "org.freedesktop.DBus.Properties", "Get"); 564d3a379a6SSantosh Puranik prop.append("xyz.openbmc_project.State.Decorator.OperationalStatus"); 565d3a379a6SSantosh Puranik prop.append("Functional"); 566d3a379a6SSantosh Puranik try 567d3a379a6SSantosh Puranik { 568d3a379a6SSantosh Puranik auto result = bus.call(prop); 569d3a379a6SSantosh Puranik } 570d3a379a6SSantosh Puranik catch (const sdbusplus::exception::SdBusError& e) 571d3a379a6SSantosh Puranik { 572d3a379a6SSantosh Puranik // Treat as property unavailable 573d3a379a6SSantosh Puranik inventory::PropertyMap prop; 574d3a379a6SSantosh Puranik prop.emplace("Functional", true); 575d3a379a6SSantosh Puranik interfaces.emplace( 576d3a379a6SSantosh Puranik "xyz.openbmc_project.State.Decorator.OperationalStatus", 577d3a379a6SSantosh Puranik move(prop)); 578d3a379a6SSantosh Puranik } 579d3a379a6SSantosh Puranik prop = bus.new_method_call("xyz.openbmc_project.Inventory.Manager", 580d3a379a6SSantosh Puranik objectPath.c_str(), 581d3a379a6SSantosh Puranik "org.freedesktop.DBus.Properties", "Get"); 582d3a379a6SSantosh Puranik prop.append("xyz.openbmc_project.Object.Enable"); 583d3a379a6SSantosh Puranik prop.append("Enabled"); 584d3a379a6SSantosh Puranik try 585d3a379a6SSantosh Puranik { 586d3a379a6SSantosh Puranik auto result = bus.call(prop); 587d3a379a6SSantosh Puranik } 588d3a379a6SSantosh Puranik catch (const sdbusplus::exception::SdBusError& e) 589d3a379a6SSantosh Puranik { 590d3a379a6SSantosh Puranik // Treat as property unavailable 591d3a379a6SSantosh Puranik inventory::PropertyMap prop; 592d3a379a6SSantosh Puranik prop.emplace("Enabled", false); 593d3a379a6SSantosh Puranik interfaces.emplace("xyz.openbmc_project.Object.Enable", move(prop)); 594d3a379a6SSantosh Puranik } 595d3a379a6SSantosh Puranik } 596d3a379a6SSantosh Puranik 597d3a379a6SSantosh Puranik /** 5988e140a1cSPriyangaRamasamy * @brief Prime the Inventory 5998e140a1cSPriyangaRamasamy * Prime the inventory by populating only the location code, 6008e140a1cSPriyangaRamasamy * type interface and the inventory object for the frus 6018e140a1cSPriyangaRamasamy * which are not system vpd fru. 602abb87edaSPriyangaRamasamy * 6038e140a1cSPriyangaRamasamy * @param[in] jsObject - Reference to vpd inventory json object 6048e140a1cSPriyangaRamasamy * @param[in] vpdMap - Reference to the parsed vpd map 6058e140a1cSPriyangaRamasamy * 6068e140a1cSPriyangaRamasamy * @returns Map of items in extraInterface. 6078e140a1cSPriyangaRamasamy */ 6088e140a1cSPriyangaRamasamy template <typename T> 6098e140a1cSPriyangaRamasamy inventory::ObjectMap primeInventory(const nlohmann::json& jsObject, 6108e140a1cSPriyangaRamasamy const T& vpdMap) 6118e140a1cSPriyangaRamasamy { 6128e140a1cSPriyangaRamasamy inventory::ObjectMap objects; 6138e140a1cSPriyangaRamasamy 6148e140a1cSPriyangaRamasamy for (auto& itemFRUS : jsObject["frus"].items()) 6158e140a1cSPriyangaRamasamy { 6168e140a1cSPriyangaRamasamy for (auto& itemEEPROM : itemFRUS.value()) 6178e140a1cSPriyangaRamasamy { 6182e6c6f73SAlpana Kumari // Take pre actions if needed 6192e6c6f73SAlpana Kumari if (itemEEPROM.find("preAction") != itemEEPROM.end()) 6202e6c6f73SAlpana Kumari { 6212e6c6f73SAlpana Kumari preAction(jsObject, itemFRUS.key()); 6222e6c6f73SAlpana Kumari } 6232e6c6f73SAlpana Kumari 6248e140a1cSPriyangaRamasamy inventory::InterfaceMap interfaces; 6258e140a1cSPriyangaRamasamy inventory::Object object(itemEEPROM.at("inventoryPath")); 6268e140a1cSPriyangaRamasamy 62750f60bf8SSantosh Puranik if ((itemFRUS.key() != systemVpdFilePath) && 62850f60bf8SSantosh Puranik !itemEEPROM.value("noprime", false)) 6298e140a1cSPriyangaRamasamy { 630cfd7a75aSAlpana Kumari inventory::PropertyMap presProp; 631cfd7a75aSAlpana Kumari presProp.emplace("Present", false); 632cfd7a75aSAlpana Kumari interfaces.emplace("xyz.openbmc_project.Inventory.Item", 633d3a379a6SSantosh Puranik presProp); 634d3a379a6SSantosh Puranik setOneTimeProperties(object, interfaces); 6358e140a1cSPriyangaRamasamy if (itemEEPROM.find("extraInterfaces") != itemEEPROM.end()) 6368e140a1cSPriyangaRamasamy { 6378e140a1cSPriyangaRamasamy for (const auto& eI : itemEEPROM["extraInterfaces"].items()) 6388e140a1cSPriyangaRamasamy { 6398e140a1cSPriyangaRamasamy inventory::PropertyMap props; 640414d5aefSAlpana Kumari if (eI.key() == IBM_LOCATION_CODE_INF) 6418e140a1cSPriyangaRamasamy { 6428e140a1cSPriyangaRamasamy if constexpr (std::is_same<T, Parsed>::value) 6438e140a1cSPriyangaRamasamy { 6448e140a1cSPriyangaRamasamy for (auto& lC : eI.value().items()) 6458e140a1cSPriyangaRamasamy { 6468e140a1cSPriyangaRamasamy auto propVal = expandLocationCode( 6478e140a1cSPriyangaRamasamy lC.value().get<string>(), vpdMap, true); 6488e140a1cSPriyangaRamasamy 6498e140a1cSPriyangaRamasamy props.emplace(move(lC.key()), 6508e140a1cSPriyangaRamasamy move(propVal)); 651b0f3749dSSantosh Puranik interfaces.emplace(XYZ_LOCATION_CODE_INF, 652b0f3749dSSantosh Puranik props); 6538e140a1cSPriyangaRamasamy interfaces.emplace(move(eI.key()), 6548e140a1cSPriyangaRamasamy move(props)); 6558e140a1cSPriyangaRamasamy } 6568e140a1cSPriyangaRamasamy } 6578e140a1cSPriyangaRamasamy } 6588e140a1cSPriyangaRamasamy else if (eI.key().find("Inventory.Item.") != 6598e140a1cSPriyangaRamasamy string::npos) 6608e140a1cSPriyangaRamasamy { 6618e140a1cSPriyangaRamasamy interfaces.emplace(move(eI.key()), move(props)); 6628e140a1cSPriyangaRamasamy } 663d3a379a6SSantosh Puranik else if (eI.key() == 664d3a379a6SSantosh Puranik "xyz.openbmc_project.Inventory.Item") 665d3a379a6SSantosh Puranik { 666d3a379a6SSantosh Puranik for (auto& val : eI.value().items()) 667d3a379a6SSantosh Puranik { 668d3a379a6SSantosh Puranik if (val.key() == "PrettyName") 669d3a379a6SSantosh Puranik { 670d3a379a6SSantosh Puranik presProp.emplace(val.key(), 671d3a379a6SSantosh Puranik val.value().get<string>()); 672d3a379a6SSantosh Puranik } 673d3a379a6SSantosh Puranik } 674d3a379a6SSantosh Puranik // Use insert_or_assign here as we may already have 675d3a379a6SSantosh Puranik // inserted the present property only earlier in 676d3a379a6SSantosh Puranik // this function under this same interface. 677d3a379a6SSantosh Puranik interfaces.insert_or_assign(eI.key(), 678d3a379a6SSantosh Puranik move(presProp)); 679d3a379a6SSantosh Puranik } 6808e140a1cSPriyangaRamasamy } 6818e140a1cSPriyangaRamasamy } 6828e140a1cSPriyangaRamasamy objects.emplace(move(object), move(interfaces)); 6838e140a1cSPriyangaRamasamy } 6848e140a1cSPriyangaRamasamy } 6858e140a1cSPriyangaRamasamy } 6868e140a1cSPriyangaRamasamy return objects; 6878e140a1cSPriyangaRamasamy } 6888e140a1cSPriyangaRamasamy 68965b83601SAlpana Kumari /** 69065b83601SAlpana Kumari * @brief This API executes command to set environment variable 69165b83601SAlpana Kumari * And then reboot the system 69265b83601SAlpana Kumari * @param[in] key -env key to set new value 69365b83601SAlpana Kumari * @param[in] value -value to set. 69465b83601SAlpana Kumari */ 69565b83601SAlpana Kumari void setEnvAndReboot(const string& key, const string& value) 69665b83601SAlpana Kumari { 69765b83601SAlpana Kumari // set env and reboot and break. 69865b83601SAlpana Kumari executeCmd("/sbin/fw_setenv", key, value); 699280197e3SAndrew Geissler log<level::INFO>("Rebooting BMC to pick up new device tree"); 70065b83601SAlpana Kumari // make dbus call to reboot 70165b83601SAlpana Kumari auto bus = sdbusplus::bus::new_default_system(); 70265b83601SAlpana Kumari auto method = bus.new_method_call( 70365b83601SAlpana Kumari "org.freedesktop.systemd1", "/org/freedesktop/systemd1", 70465b83601SAlpana Kumari "org.freedesktop.systemd1.Manager", "Reboot"); 70565b83601SAlpana Kumari bus.call_noreply(method); 70665b83601SAlpana Kumari } 70765b83601SAlpana Kumari 70865b83601SAlpana Kumari /* 70965b83601SAlpana Kumari * @brief This API checks for env var fitconfig. 71065b83601SAlpana Kumari * If not initialised OR updated as per the current system type, 71165b83601SAlpana Kumari * update this env var and reboot the system. 71265b83601SAlpana Kumari * 71365b83601SAlpana Kumari * @param[in] systemType IM kwd in vpd tells about which system type it is. 71465b83601SAlpana Kumari * */ 71565b83601SAlpana Kumari void setDevTreeEnv(const string& systemType) 71665b83601SAlpana Kumari { 71737e72701SAlpana Kumari // Init with default dtb 71837e72701SAlpana Kumari string newDeviceTree = "conf-aspeed-bmc-ibm-rainier-p1.dtb"; 719e5f177a5SSantosh Puranik static const deviceTreeMap deviceTreeSystemTypeMap = { 720e5f177a5SSantosh Puranik {RAINIER_2U, "conf-aspeed-bmc-ibm-rainier-p1.dtb"}, 721e5f177a5SSantosh Puranik {RAINIER_2U_V2, "conf-aspeed-bmc-ibm-rainier.dtb"}, 722e5f177a5SSantosh Puranik {RAINIER_4U, "conf-aspeed-bmc-ibm-rainier-4u-p1.dtb"}, 723e5f177a5SSantosh Puranik {RAINIER_4U_V2, "conf-aspeed-bmc-ibm-rainier-4u.dtb"}, 724e5f177a5SSantosh Puranik {RAINIER_1S4U, "conf-aspeed-bmc-ibm-rainier-1s4u.dtb"}, 725e5f177a5SSantosh Puranik {EVEREST, "conf-aspeed-bmc-ibm-everest.dtb"}}; 72665b83601SAlpana Kumari 72765b83601SAlpana Kumari if (deviceTreeSystemTypeMap.find(systemType) != 72865b83601SAlpana Kumari deviceTreeSystemTypeMap.end()) 72965b83601SAlpana Kumari { 73065b83601SAlpana Kumari newDeviceTree = deviceTreeSystemTypeMap.at(systemType); 73165b83601SAlpana Kumari } 73237e72701SAlpana Kumari else 73337e72701SAlpana Kumari { 73437e72701SAlpana Kumari // System type not supported 735ab1e22c3SAlpana Kumari string err = "This System type not found/supported in dtb table " + 736ab1e22c3SAlpana Kumari systemType + 737ab1e22c3SAlpana Kumari ".Please check the HW and IM keywords in the system " 738ab1e22c3SAlpana Kumari "VPD.Breaking..."; 739ab1e22c3SAlpana Kumari 740ab1e22c3SAlpana Kumari // map to hold additional data in case of logging pel 741ab1e22c3SAlpana Kumari PelAdditionalData additionalData{}; 742ab1e22c3SAlpana Kumari additionalData.emplace("DESCRIPTION", err); 743ab1e22c3SAlpana Kumari createPEL(additionalData, PelSeverity::WARNING, 744ab1e22c3SAlpana Kumari errIntfForInvalidSystemType); 745ab1e22c3SAlpana Kumari exit(-1); 74637e72701SAlpana Kumari } 74765b83601SAlpana Kumari 74865b83601SAlpana Kumari string readVarValue; 74965b83601SAlpana Kumari bool envVarFound = false; 75065b83601SAlpana Kumari 75165b83601SAlpana Kumari vector<string> output = executeCmd("/sbin/fw_printenv"); 75265b83601SAlpana Kumari for (const auto& entry : output) 75365b83601SAlpana Kumari { 75465b83601SAlpana Kumari size_t pos = entry.find("="); 75565b83601SAlpana Kumari string key = entry.substr(0, pos); 75665b83601SAlpana Kumari if (key != "fitconfig") 75765b83601SAlpana Kumari { 75865b83601SAlpana Kumari continue; 75965b83601SAlpana Kumari } 76065b83601SAlpana Kumari 76165b83601SAlpana Kumari envVarFound = true; 76265b83601SAlpana Kumari if (pos + 1 < entry.size()) 76365b83601SAlpana Kumari { 76465b83601SAlpana Kumari readVarValue = entry.substr(pos + 1); 76565b83601SAlpana Kumari if (readVarValue.find(newDeviceTree) != string::npos) 76665b83601SAlpana Kumari { 76765b83601SAlpana Kumari // fitconfig is Updated. No action needed 76865b83601SAlpana Kumari break; 76965b83601SAlpana Kumari } 77065b83601SAlpana Kumari } 77165b83601SAlpana Kumari // set env and reboot and break. 77265b83601SAlpana Kumari setEnvAndReboot(key, newDeviceTree); 77365b83601SAlpana Kumari exit(0); 77465b83601SAlpana Kumari } 77565b83601SAlpana Kumari 77665b83601SAlpana Kumari // check If env var Not found 77765b83601SAlpana Kumari if (!envVarFound) 77865b83601SAlpana Kumari { 77965b83601SAlpana Kumari setEnvAndReboot("fitconfig", newDeviceTree); 78065b83601SAlpana Kumari } 78165b83601SAlpana Kumari } 78265b83601SAlpana Kumari 7838e140a1cSPriyangaRamasamy /** 7849094d4f6SSunnySrivastava1984 * @brief API to call VPD manager to write VPD to EEPROM. 7859094d4f6SSunnySrivastava1984 * @param[in] Object path. 7869094d4f6SSunnySrivastava1984 * @param[in] record to be updated. 7879094d4f6SSunnySrivastava1984 * @param[in] keyword to be updated. 7889094d4f6SSunnySrivastava1984 * @param[in] keyword data to be updated 7899094d4f6SSunnySrivastava1984 */ 7909094d4f6SSunnySrivastava1984 void updateHardware(const string& objectName, const string& recName, 7919094d4f6SSunnySrivastava1984 const string& kwdName, const Binary& data) 7929094d4f6SSunnySrivastava1984 { 7939094d4f6SSunnySrivastava1984 try 7949094d4f6SSunnySrivastava1984 { 7959094d4f6SSunnySrivastava1984 auto bus = sdbusplus::bus::new_default(); 7969094d4f6SSunnySrivastava1984 auto properties = 7979094d4f6SSunnySrivastava1984 bus.new_method_call(BUSNAME, OBJPATH, IFACE, "WriteKeyword"); 7989094d4f6SSunnySrivastava1984 properties.append( 7999094d4f6SSunnySrivastava1984 static_cast<sdbusplus::message::object_path>(objectName)); 8009094d4f6SSunnySrivastava1984 properties.append(recName); 8019094d4f6SSunnySrivastava1984 properties.append(kwdName); 8029094d4f6SSunnySrivastava1984 properties.append(data); 8039094d4f6SSunnySrivastava1984 bus.call(properties); 8049094d4f6SSunnySrivastava1984 } 8058be4334fSPatrick Williams catch (const sdbusplus::exception::exception& e) 8069094d4f6SSunnySrivastava1984 { 8079094d4f6SSunnySrivastava1984 std::string what = 8089094d4f6SSunnySrivastava1984 "VPDManager WriteKeyword api failed for inventory path " + 8099094d4f6SSunnySrivastava1984 objectName; 8109094d4f6SSunnySrivastava1984 what += " record " + recName; 8119094d4f6SSunnySrivastava1984 what += " keyword " + kwdName; 8129094d4f6SSunnySrivastava1984 what += " with bus error = " + std::string(e.what()); 8139094d4f6SSunnySrivastava1984 8149094d4f6SSunnySrivastava1984 // map to hold additional data in case of logging pel 8159094d4f6SSunnySrivastava1984 PelAdditionalData additionalData{}; 8169094d4f6SSunnySrivastava1984 additionalData.emplace("CALLOUT_INVENTORY_PATH", objectName); 8179094d4f6SSunnySrivastava1984 additionalData.emplace("DESCRIPTION", what); 8180746eeebSSunny Srivastava createPEL(additionalData, PelSeverity::WARNING, errIntfForBusFailure); 8199094d4f6SSunnySrivastava1984 } 8209094d4f6SSunnySrivastava1984 } 8219094d4f6SSunnySrivastava1984 8229094d4f6SSunnySrivastava1984 /** 8233c24414fSSunny Srivastava * @brief An api to get list of blank system VPD properties. 8243c24414fSSunny Srivastava * @param[in] vpdMap - IPZ vpd map. 8253c24414fSSunny Srivastava * @param[in] objectPath - Object path for the FRU. 8263c24414fSSunny Srivastava * @param[out] blankPropertyList - Properties which are blank in System VPD and 8273c24414fSSunny Srivastava * needs to be updated as standby. 8283c24414fSSunny Srivastava */ 8293c24414fSSunny Srivastava void getListOfBlankSystemVpd(Parsed& vpdMap, const string& objectPath, 8303c24414fSSunny Srivastava std::vector<RestoredEeproms>& blankPropertyList) 8313c24414fSSunny Srivastava { 8323c24414fSSunny Srivastava for (const auto& systemRecKwdPair : svpdKwdMap) 8333c24414fSSunny Srivastava { 8343c24414fSSunny Srivastava auto it = vpdMap.find(systemRecKwdPair.first); 8353c24414fSSunny Srivastava 8363c24414fSSunny Srivastava // check if record is found in map we got by parser 8373c24414fSSunny Srivastava if (it != vpdMap.end()) 8383c24414fSSunny Srivastava { 8393c24414fSSunny Srivastava const auto& kwdListForRecord = systemRecKwdPair.second; 8403c24414fSSunny Srivastava for (const auto& keyword : kwdListForRecord) 8413c24414fSSunny Srivastava { 8423c24414fSSunny Srivastava DbusPropertyMap& kwdValMap = it->second; 8433c24414fSSunny Srivastava auto iterator = kwdValMap.find(keyword); 8443c24414fSSunny Srivastava 8453c24414fSSunny Srivastava if (iterator != kwdValMap.end()) 8463c24414fSSunny Srivastava { 8473c24414fSSunny Srivastava string& kwdValue = iterator->second; 8483c24414fSSunny Srivastava 8493c24414fSSunny Srivastava // check bus data 8503c24414fSSunny Srivastava const string& recordName = systemRecKwdPair.first; 8513c24414fSSunny Srivastava const string& busValue = readBusProperty( 8523c24414fSSunny Srivastava objectPath, ipzVpdInf + recordName, keyword); 8533c24414fSSunny Srivastava 8543c24414fSSunny Srivastava if (busValue.find_first_not_of(' ') != string::npos) 8553c24414fSSunny Srivastava { 8563c24414fSSunny Srivastava if (kwdValue.find_first_not_of(' ') == string::npos) 8573c24414fSSunny Srivastava { 8583c24414fSSunny Srivastava // implies data is blank on EEPROM but not on cache. 8593c24414fSSunny Srivastava // So EEPROM vpd update is required. 8603c24414fSSunny Srivastava Binary busData(busValue.begin(), busValue.end()); 8613c24414fSSunny Srivastava 8623c24414fSSunny Srivastava blankPropertyList.push_back(std::make_tuple( 8633c24414fSSunny Srivastava objectPath, recordName, keyword, busData)); 8643c24414fSSunny Srivastava } 8653c24414fSSunny Srivastava } 8663c24414fSSunny Srivastava } 8673c24414fSSunny Srivastava } 8683c24414fSSunny Srivastava } 8693c24414fSSunny Srivastava } 8703c24414fSSunny Srivastava } 8713c24414fSSunny Srivastava 8723c24414fSSunny Srivastava /** 8739094d4f6SSunnySrivastava1984 * @brief API to check if we need to restore system VPD 8749094d4f6SSunnySrivastava1984 * This functionality is only applicable for IPZ VPD data. 8759094d4f6SSunnySrivastava1984 * @param[in] vpdMap - IPZ vpd map 8769094d4f6SSunnySrivastava1984 * @param[in] objectPath - Object path for the FRU 8779094d4f6SSunnySrivastava1984 */ 8783c24414fSSunny Srivastava void restoreSystemVPD(Parsed& vpdMap, const string& objectPath) 8799094d4f6SSunnySrivastava1984 { 8809094d4f6SSunnySrivastava1984 for (const auto& systemRecKwdPair : svpdKwdMap) 8819094d4f6SSunnySrivastava1984 { 8829094d4f6SSunnySrivastava1984 auto it = vpdMap.find(systemRecKwdPair.first); 8839094d4f6SSunnySrivastava1984 8849094d4f6SSunnySrivastava1984 // check if record is found in map we got by parser 8859094d4f6SSunnySrivastava1984 if (it != vpdMap.end()) 8869094d4f6SSunnySrivastava1984 { 8879094d4f6SSunnySrivastava1984 const auto& kwdListForRecord = systemRecKwdPair.second; 8889094d4f6SSunnySrivastava1984 for (const auto& keyword : kwdListForRecord) 8899094d4f6SSunnySrivastava1984 { 8909094d4f6SSunnySrivastava1984 DbusPropertyMap& kwdValMap = it->second; 8919094d4f6SSunnySrivastava1984 auto iterator = kwdValMap.find(keyword); 8929094d4f6SSunnySrivastava1984 8939094d4f6SSunnySrivastava1984 if (iterator != kwdValMap.end()) 8949094d4f6SSunnySrivastava1984 { 8959094d4f6SSunnySrivastava1984 string& kwdValue = iterator->second; 8969094d4f6SSunnySrivastava1984 8979094d4f6SSunnySrivastava1984 // check bus data 8989094d4f6SSunnySrivastava1984 const string& recordName = systemRecKwdPair.first; 8999094d4f6SSunnySrivastava1984 const string& busValue = readBusProperty( 9009094d4f6SSunnySrivastava1984 objectPath, ipzVpdInf + recordName, keyword); 9019094d4f6SSunnySrivastava1984 9029094d4f6SSunnySrivastava1984 if (busValue.find_first_not_of(' ') != string::npos) 9039094d4f6SSunnySrivastava1984 { 9049094d4f6SSunnySrivastava1984 if (kwdValue.find_first_not_of(' ') != string::npos) 9059094d4f6SSunnySrivastava1984 { 9069094d4f6SSunnySrivastava1984 // both the data are present, check for mismatch 9079094d4f6SSunnySrivastava1984 if (busValue != kwdValue) 9089094d4f6SSunnySrivastava1984 { 9099094d4f6SSunnySrivastava1984 string errMsg = "VPD data mismatch on cache " 9109094d4f6SSunnySrivastava1984 "and hardware for record: "; 9119094d4f6SSunnySrivastava1984 errMsg += (*it).first; 9129094d4f6SSunnySrivastava1984 errMsg += " and keyword: "; 9139094d4f6SSunnySrivastava1984 errMsg += keyword; 9149094d4f6SSunnySrivastava1984 9159094d4f6SSunnySrivastava1984 // data mismatch 9169094d4f6SSunnySrivastava1984 PelAdditionalData additionalData; 9179094d4f6SSunnySrivastava1984 additionalData.emplace("CALLOUT_INVENTORY_PATH", 9189094d4f6SSunnySrivastava1984 objectPath); 9199094d4f6SSunnySrivastava1984 9209094d4f6SSunnySrivastava1984 additionalData.emplace("DESCRIPTION", errMsg); 9219094d4f6SSunnySrivastava1984 9220746eeebSSunny Srivastava createPEL(additionalData, PelSeverity::WARNING, 9230746eeebSSunny Srivastava errIntfForInvalidVPD); 9249094d4f6SSunnySrivastava1984 } 9259094d4f6SSunnySrivastava1984 } 9269094d4f6SSunnySrivastava1984 else 9279094d4f6SSunnySrivastava1984 { 9289094d4f6SSunnySrivastava1984 // implies hardware data is blank 9299094d4f6SSunnySrivastava1984 // update the map 9309094d4f6SSunnySrivastava1984 Binary busData(busValue.begin(), busValue.end()); 9319094d4f6SSunnySrivastava1984 9329094d4f6SSunnySrivastava1984 // update the map as well, so that cache data is not 93390a63b9bSSunny Srivastava // updated as blank while populating VPD map on Dbus 93490a63b9bSSunny Srivastava // in populateDBus Api 9359094d4f6SSunnySrivastava1984 kwdValue = busValue; 93690a63b9bSSunny Srivastava } 9379094d4f6SSunnySrivastava1984 } 9389094d4f6SSunnySrivastava1984 else if (kwdValue.find_first_not_of(' ') == string::npos) 9399094d4f6SSunnySrivastava1984 { 9409094d4f6SSunnySrivastava1984 string errMsg = "VPD is blank on both cache and " 9419094d4f6SSunnySrivastava1984 "hardware for record: "; 9429094d4f6SSunnySrivastava1984 errMsg += (*it).first; 9439094d4f6SSunnySrivastava1984 errMsg += " and keyword: "; 9449094d4f6SSunnySrivastava1984 errMsg += keyword; 9459094d4f6SSunnySrivastava1984 errMsg += ". SSR need to update hardware VPD."; 9469094d4f6SSunnySrivastava1984 9479094d4f6SSunnySrivastava1984 // both the data are blanks, log PEL 9489094d4f6SSunnySrivastava1984 PelAdditionalData additionalData; 9499094d4f6SSunnySrivastava1984 additionalData.emplace("CALLOUT_INVENTORY_PATH", 9509094d4f6SSunnySrivastava1984 objectPath); 9519094d4f6SSunnySrivastava1984 9529094d4f6SSunnySrivastava1984 additionalData.emplace("DESCRIPTION", errMsg); 9539094d4f6SSunnySrivastava1984 9549094d4f6SSunnySrivastava1984 // log PEL TODO: Block IPL 9550746eeebSSunny Srivastava createPEL(additionalData, PelSeverity::ERROR, 9560746eeebSSunny Srivastava errIntfForBlankSystemVPD); 9579094d4f6SSunnySrivastava1984 continue; 9589094d4f6SSunnySrivastava1984 } 9599094d4f6SSunnySrivastava1984 } 9609094d4f6SSunnySrivastava1984 } 9619094d4f6SSunnySrivastava1984 } 9629094d4f6SSunnySrivastava1984 } 9639094d4f6SSunnySrivastava1984 } 9649094d4f6SSunnySrivastava1984 9659094d4f6SSunnySrivastava1984 /** 9667ce68724Salpana07 * @brief This checks for is this FRU a processor 9677ce68724Salpana07 * And if yes, then checks for is this primary 9687ce68724Salpana07 * 9697ce68724Salpana07 * @param[in] js- vpd json to get the information about this FRU 9707ce68724Salpana07 * @param[in] filePath- FRU vpd 9717ce68724Salpana07 * 9727ce68724Salpana07 * @return true/false 9737ce68724Salpana07 */ 9747ce68724Salpana07 bool isThisPrimaryProcessor(nlohmann::json& js, const string& filePath) 9757ce68724Salpana07 { 9767ce68724Salpana07 bool isProcessor = false; 9777ce68724Salpana07 bool isPrimary = false; 9787ce68724Salpana07 9797ce68724Salpana07 for (const auto& item : js["frus"][filePath]) 9807ce68724Salpana07 { 9817ce68724Salpana07 if (item.find("extraInterfaces") != item.end()) 9827ce68724Salpana07 { 9837ce68724Salpana07 for (const auto& eI : item["extraInterfaces"].items()) 9847ce68724Salpana07 { 9857ce68724Salpana07 if (eI.key().find("Inventory.Item.Cpu") != string::npos) 9867ce68724Salpana07 { 9877ce68724Salpana07 isProcessor = true; 9887ce68724Salpana07 } 9897ce68724Salpana07 } 9907ce68724Salpana07 } 9917ce68724Salpana07 9927ce68724Salpana07 if (isProcessor) 9937ce68724Salpana07 { 9947ce68724Salpana07 string cpuType = item.value("cpuType", ""); 9957ce68724Salpana07 if (cpuType == "primary") 9967ce68724Salpana07 { 9977ce68724Salpana07 isPrimary = true; 9987ce68724Salpana07 } 9997ce68724Salpana07 } 10007ce68724Salpana07 } 10017ce68724Salpana07 10027ce68724Salpana07 return (isProcessor && isPrimary); 10037ce68724Salpana07 } 10047ce68724Salpana07 10057ce68724Salpana07 /** 10067ce68724Salpana07 * @brief This finds DIMM vpd in vpd json and enables them by binding the device 10077ce68724Salpana07 * driver 10087ce68724Salpana07 * @param[in] js- vpd json to iterate through and take action if it is DIMM 10097ce68724Salpana07 */ 10107ce68724Salpana07 void doEnableAllDimms(nlohmann::json& js) 10117ce68724Salpana07 { 10127ce68724Salpana07 // iterate over each fru 10137ce68724Salpana07 for (const auto& eachFru : js["frus"].items()) 10147ce68724Salpana07 { 10157ce68724Salpana07 // skip the driver binding if eeprom already exists 10167ce68724Salpana07 if (fs::exists(eachFru.key())) 10177ce68724Salpana07 { 10187ce68724Salpana07 continue; 10197ce68724Salpana07 } 10207ce68724Salpana07 10217ce68724Salpana07 for (const auto& eachInventory : eachFru.value()) 10227ce68724Salpana07 { 10237ce68724Salpana07 if (eachInventory.find("extraInterfaces") != eachInventory.end()) 10247ce68724Salpana07 { 10257ce68724Salpana07 for (const auto& eI : eachInventory["extraInterfaces"].items()) 10267ce68724Salpana07 { 10277ce68724Salpana07 if (eI.key().find("Inventory.Item.Dimm") != string::npos) 10287ce68724Salpana07 { 10297ce68724Salpana07 string dimmVpd = eachFru.key(); 10307ce68724Salpana07 // fetch it from 10317ce68724Salpana07 // "/sys/bus/i2c/drivers/at24/414-0050/eeprom" 10327ce68724Salpana07 10337ce68724Salpana07 regex matchPatern("([0-9]+-[0-9]{4})"); 10347ce68724Salpana07 smatch matchFound; 10357ce68724Salpana07 if (regex_search(dimmVpd, matchFound, matchPatern)) 10367ce68724Salpana07 { 10377ce68724Salpana07 vector<string> i2cReg; 10387ce68724Salpana07 boost::split(i2cReg, matchFound.str(0), 10397ce68724Salpana07 boost::is_any_of("-")); 10407ce68724Salpana07 10417ce68724Salpana07 // remove 0s from begining 10427ce68724Salpana07 const regex pattern("^0+(?!$)"); 10437ce68724Salpana07 for (auto& i : i2cReg) 10447ce68724Salpana07 { 10457ce68724Salpana07 i = regex_replace(i, pattern, ""); 10467ce68724Salpana07 } 10477ce68724Salpana07 10487ce68724Salpana07 if (i2cReg.size() == 2) 10497ce68724Salpana07 { 10507ce68724Salpana07 // echo 24c32 0x50 > 10517ce68724Salpana07 // /sys/bus/i2c/devices/i2c-16/new_device 10527ce68724Salpana07 string cmnd = "echo 24c32 0x" + i2cReg[1] + 10537ce68724Salpana07 " > /sys/bus/i2c/devices/i2c-" + 10547ce68724Salpana07 i2cReg[0] + "/new_device"; 10557ce68724Salpana07 10567ce68724Salpana07 executeCmd(cmnd); 10577ce68724Salpana07 } 10587ce68724Salpana07 } 10597ce68724Salpana07 } 10607ce68724Salpana07 } 10617ce68724Salpana07 } 10627ce68724Salpana07 } 10637ce68724Salpana07 } 10647ce68724Salpana07 } 10657ce68724Salpana07 10667ce68724Salpana07 /** 10678e140a1cSPriyangaRamasamy * @brief Populate Dbus. 1068abb87edaSPriyangaRamasamy * This method invokes all the populateInterface functions 1069abb87edaSPriyangaRamasamy * and notifies PIM about dbus object. 10708e140a1cSPriyangaRamasamy * @param[in] vpdMap - Either IPZ vpd map or Keyword vpd map based on the 10718e140a1cSPriyangaRamasamy * input. 1072abb87edaSPriyangaRamasamy * @param[in] js - Inventory json object 1073abb87edaSPriyangaRamasamy * @param[in] filePath - Path of the vpd file 1074abb87edaSPriyangaRamasamy * @param[in] preIntrStr - Interface string 1075abb87edaSPriyangaRamasamy */ 1076abb87edaSPriyangaRamasamy template <typename T> 10779094d4f6SSunnySrivastava1984 static void populateDbus(T& vpdMap, nlohmann::json& js, const string& filePath) 1078abb87edaSPriyangaRamasamy { 1079abb87edaSPriyangaRamasamy inventory::InterfaceMap interfaces; 1080abb87edaSPriyangaRamasamy inventory::ObjectMap objects; 1081abb87edaSPriyangaRamasamy inventory::PropertyMap prop; 10826aa5450eSShantappa Teekappanavar string ccinFromVpd; 1083abb87edaSPriyangaRamasamy 108450f60bf8SSantosh Puranik bool isSystemVpd = (filePath == systemVpdFilePath); 108550f60bf8SSantosh Puranik if constexpr (is_same<T, Parsed>::value) 108650f60bf8SSantosh Puranik { 10876aa5450eSShantappa Teekappanavar ccinFromVpd = getKwVal(vpdMap, "VINI", "CC"); 10886aa5450eSShantappa Teekappanavar transform(ccinFromVpd.begin(), ccinFromVpd.end(), ccinFromVpd.begin(), 10896aa5450eSShantappa Teekappanavar ::toupper); 10906aa5450eSShantappa Teekappanavar 109150f60bf8SSantosh Puranik if (isSystemVpd) 109250f60bf8SSantosh Puranik { 109350f60bf8SSantosh Puranik std::vector<std::string> interfaces = {motherBoardInterface}; 109450f60bf8SSantosh Puranik // call mapper to check for object path creation 109550f60bf8SSantosh Puranik MapperResponse subTree = 109650f60bf8SSantosh Puranik getObjectSubtreeForInterfaces(pimPath, 0, interfaces); 109750f60bf8SSantosh Puranik string mboardPath = 109850f60bf8SSantosh Puranik js["frus"][filePath].at(0).value("inventoryPath", ""); 109950f60bf8SSantosh Puranik 110050f60bf8SSantosh Puranik // Attempt system VPD restore if we have a motherboard 110150f60bf8SSantosh Puranik // object in the inventory. 110250f60bf8SSantosh Puranik if ((subTree.size() != 0) && 110350f60bf8SSantosh Puranik (subTree.find(pimPath + mboardPath) != subTree.end())) 110450f60bf8SSantosh Puranik { 11053c24414fSSunny Srivastava restoreSystemVPD(vpdMap, mboardPath); 110650f60bf8SSantosh Puranik } 110750f60bf8SSantosh Puranik else 110850f60bf8SSantosh Puranik { 110950f60bf8SSantosh Puranik log<level::ERR>("No object path found"); 111050f60bf8SSantosh Puranik } 111150f60bf8SSantosh Puranik } 11127ce68724Salpana07 else 11137ce68724Salpana07 { 11147ce68724Salpana07 // check if it is processor vpd. 11157ce68724Salpana07 auto isPrimaryCpu = isThisPrimaryProcessor(js, filePath); 11167ce68724Salpana07 11177ce68724Salpana07 if (isPrimaryCpu) 11187ce68724Salpana07 { 11197ce68724Salpana07 auto ddVersion = getKwVal(vpdMap, "CRP0", "DD"); 11207ce68724Salpana07 11217ce68724Salpana07 auto chipVersion = atoi(ddVersion.substr(1, 2).c_str()); 11227ce68724Salpana07 11237ce68724Salpana07 if (chipVersion >= 2) 11247ce68724Salpana07 { 11257ce68724Salpana07 doEnableAllDimms(js); 11267ce68724Salpana07 } 11277ce68724Salpana07 } 11287ce68724Salpana07 } 112950f60bf8SSantosh Puranik } 113050f60bf8SSantosh Puranik 113132c687f5SPriyanga Ramasamy if (isSystemVpd) 113232c687f5SPriyanga Ramasamy { 113332c687f5SPriyanga Ramasamy string systemJsonName{}; 113432c687f5SPriyanga Ramasamy if constexpr (is_same<T, Parsed>::value) 113532c687f5SPriyanga Ramasamy { 113632c687f5SPriyanga Ramasamy // pick the right system json 113732c687f5SPriyanga Ramasamy systemJsonName = getSystemsJson(vpdMap); 113832c687f5SPriyanga Ramasamy } 113932c687f5SPriyanga Ramasamy 114032c687f5SPriyanga Ramasamy fs::path target = systemJsonName; 114132c687f5SPriyanga Ramasamy fs::path link = INVENTORY_JSON_SYM_LINK; 114232c687f5SPriyanga Ramasamy 114332c687f5SPriyanga Ramasamy // Create the directory for hosting the symlink 114432c687f5SPriyanga Ramasamy fs::create_directories(VPD_FILES_PATH); 114532c687f5SPriyanga Ramasamy // unlink the symlink previously created (if any) 114632c687f5SPriyanga Ramasamy remove(INVENTORY_JSON_SYM_LINK); 114732c687f5SPriyanga Ramasamy // create a new symlink based on the system 114832c687f5SPriyanga Ramasamy fs::create_symlink(target, link); 114932c687f5SPriyanga Ramasamy 115032c687f5SPriyanga Ramasamy // Reloading the json 115132c687f5SPriyanga Ramasamy ifstream inventoryJson(link); 115232c687f5SPriyanga Ramasamy js = json::parse(inventoryJson); 115332c687f5SPriyanga Ramasamy inventoryJson.close(); 115432c687f5SPriyanga Ramasamy } 115532c687f5SPriyanga Ramasamy 1156abb87edaSPriyangaRamasamy for (const auto& item : js["frus"][filePath]) 1157abb87edaSPriyangaRamasamy { 1158abb87edaSPriyangaRamasamy const auto& objectPath = item["inventoryPath"]; 1159abb87edaSPriyangaRamasamy sdbusplus::message::object_path object(objectPath); 11609094d4f6SSunnySrivastava1984 11616aa5450eSShantappa Teekappanavar vector<string> ccinList; 11626aa5450eSShantappa Teekappanavar if (item.find("ccin") != item.end()) 11636aa5450eSShantappa Teekappanavar { 11646aa5450eSShantappa Teekappanavar for (const auto& cc : item["ccin"]) 11656aa5450eSShantappa Teekappanavar { 11666aa5450eSShantappa Teekappanavar string ccin = cc; 11676aa5450eSShantappa Teekappanavar transform(ccin.begin(), ccin.end(), ccin.begin(), ::toupper); 11686aa5450eSShantappa Teekappanavar ccinList.push_back(ccin); 11696aa5450eSShantappa Teekappanavar } 11706aa5450eSShantappa Teekappanavar } 11716aa5450eSShantappa Teekappanavar 11726aa5450eSShantappa Teekappanavar if (!ccinFromVpd.empty() && !ccinList.empty() && 11736aa5450eSShantappa Teekappanavar (find(ccinList.begin(), ccinList.end(), ccinFromVpd) == 11746aa5450eSShantappa Teekappanavar ccinList.end())) 11756aa5450eSShantappa Teekappanavar { 11766aa5450eSShantappa Teekappanavar continue; 11776aa5450eSShantappa Teekappanavar } 11786aa5450eSShantappa Teekappanavar 1179e3fed701SPriyanga Ramasamy if ((isSystemVpd) || (item.value("noprime", false))) 1180d3a379a6SSantosh Puranik { 1181e3fed701SPriyanga Ramasamy 1182e3fed701SPriyanga Ramasamy // Populate one time properties for the system VPD and its sub-frus 1183e3fed701SPriyanga Ramasamy // and for other non-primeable frus. 1184d3a379a6SSantosh Puranik // For the remaining FRUs, this will get handled as a part of 1185d3a379a6SSantosh Puranik // priming the inventory. 1186d3a379a6SSantosh Puranik setOneTimeProperties(objectPath, interfaces); 1187d3a379a6SSantosh Puranik } 1188d3a379a6SSantosh Puranik 1189abb87edaSPriyangaRamasamy // Populate the VPD keywords and the common interfaces only if we 1190abb87edaSPriyangaRamasamy // are asked to inherit that data from the VPD, else only add the 1191abb87edaSPriyangaRamasamy // extraInterfaces. 1192abb87edaSPriyangaRamasamy if (item.value("inherit", true)) 1193abb87edaSPriyangaRamasamy { 119458e22145SAlpana Kumari if constexpr (is_same<T, Parsed>::value) 1195abb87edaSPriyangaRamasamy { 11968e140a1cSPriyangaRamasamy // Each record in the VPD becomes an interface and all 11978e140a1cSPriyangaRamasamy // keyword within the record are properties under that 11988e140a1cSPriyangaRamasamy // interface. 1199abb87edaSPriyangaRamasamy for (const auto& record : vpdMap) 1200abb87edaSPriyangaRamasamy { 1201abb87edaSPriyangaRamasamy populateFruSpecificInterfaces( 1202e12b181bSSunnySrivastava1984 record.second, ipzVpdInf + record.first, interfaces); 1203abb87edaSPriyangaRamasamy } 1204abb87edaSPriyangaRamasamy } 120558e22145SAlpana Kumari else if constexpr (is_same<T, KeywordVpdMap>::value) 1206abb87edaSPriyangaRamasamy { 1207e12b181bSSunnySrivastava1984 populateFruSpecificInterfaces(vpdMap, kwdVpdInf, interfaces); 1208abb87edaSPriyangaRamasamy } 120988edeb6fSSantosh Puranik if (js.find("commonInterfaces") != js.end()) 121088edeb6fSSantosh Puranik { 121188edeb6fSSantosh Puranik populateInterfaces(js["commonInterfaces"], interfaces, vpdMap, 121288edeb6fSSantosh Puranik isSystemVpd); 121388edeb6fSSantosh Puranik } 1214abb87edaSPriyangaRamasamy } 12150859eb65SSantosh Puranik else 12160859eb65SSantosh Puranik { 12170859eb65SSantosh Puranik // Check if we have been asked to inherit specific record(s) 121858e22145SAlpana Kumari if constexpr (is_same<T, Parsed>::value) 12190859eb65SSantosh Puranik { 12200859eb65SSantosh Puranik if (item.find("copyRecords") != item.end()) 12210859eb65SSantosh Puranik { 12220859eb65SSantosh Puranik for (const auto& record : item["copyRecords"]) 12230859eb65SSantosh Puranik { 12240859eb65SSantosh Puranik const string& recordName = record; 12250859eb65SSantosh Puranik if (vpdMap.find(recordName) != vpdMap.end()) 12260859eb65SSantosh Puranik { 12270859eb65SSantosh Puranik populateFruSpecificInterfaces( 1228e12b181bSSunnySrivastava1984 vpdMap.at(recordName), ipzVpdInf + recordName, 12290859eb65SSantosh Puranik interfaces); 12300859eb65SSantosh Puranik } 12310859eb65SSantosh Puranik } 12320859eb65SSantosh Puranik } 12330859eb65SSantosh Puranik } 12340859eb65SSantosh Puranik } 1235abb87edaSPriyangaRamasamy // Populate interfaces and properties that are common to every FRU 12368e140a1cSPriyangaRamasamy // and additional interface that might be defined on a per-FRU 12378e140a1cSPriyangaRamasamy // basis. 1238abb87edaSPriyangaRamasamy if (item.find("extraInterfaces") != item.end()) 1239abb87edaSPriyangaRamasamy { 124088edeb6fSSantosh Puranik populateInterfaces(item["extraInterfaces"], interfaces, vpdMap, 124188edeb6fSSantosh Puranik isSystemVpd); 1242abb87edaSPriyangaRamasamy } 1243abb87edaSPriyangaRamasamy objects.emplace(move(object), move(interfaces)); 1244abb87edaSPriyangaRamasamy } 1245abb87edaSPriyangaRamasamy 12468e140a1cSPriyangaRamasamy if (isSystemVpd) 12478e140a1cSPriyangaRamasamy { 12488e140a1cSPriyangaRamasamy inventory::ObjectMap primeObject = primeInventory(js, vpdMap); 12498e140a1cSPriyangaRamasamy objects.insert(primeObject.begin(), primeObject.end()); 125065b83601SAlpana Kumari 1251f05effdbSAlpana Kumari // set the U-boot environment variable for device-tree 1252f05effdbSAlpana Kumari if constexpr (is_same<T, Parsed>::value) 1253f05effdbSAlpana Kumari { 1254e5f177a5SSantosh Puranik setDevTreeEnv(fs::path(getSystemsJson(vpdMap)).filename()); 1255f05effdbSAlpana Kumari } 12568e140a1cSPriyangaRamasamy } 12578e140a1cSPriyangaRamasamy 1258abb87edaSPriyangaRamasamy // Notify PIM 12596c71c9dcSSunny Srivastava common::utility::callPIM(move(objects)); 1260abb87edaSPriyangaRamasamy } 1261abb87edaSPriyangaRamasamy 1262abb87edaSPriyangaRamasamy int main(int argc, char** argv) 1263abb87edaSPriyangaRamasamy { 1264abb87edaSPriyangaRamasamy int rc = 0; 1265a20be8ecSSunnySrivastava1984 json js{}; 1266c2fe40f8SPriyangaRamasamy Binary vpdVector{}; 1267c2fe40f8SPriyangaRamasamy string file{}; 1268a20be8ecSSunnySrivastava1984 // map to hold additional data in case of logging pel 1269a20be8ecSSunnySrivastava1984 PelAdditionalData additionalData{}; 1270a20be8ecSSunnySrivastava1984 1271a20be8ecSSunnySrivastava1984 // this is needed to hold base fru inventory path in case there is ECC or 1272a20be8ecSSunnySrivastava1984 // vpd exception while parsing the file 1273a20be8ecSSunnySrivastava1984 std::string baseFruInventoryPath = {}; 1274abb87edaSPriyangaRamasamy 12750746eeebSSunny Srivastava // severity for PEL 12760746eeebSSunny Srivastava PelSeverity pelSeverity = PelSeverity::WARNING; 12770746eeebSSunny Srivastava 1278abb87edaSPriyangaRamasamy try 1279abb87edaSPriyangaRamasamy { 1280abb87edaSPriyangaRamasamy App app{"ibm-read-vpd - App to read IPZ format VPD, parse it and store " 1281abb87edaSPriyangaRamasamy "in DBUS"}; 1282abb87edaSPriyangaRamasamy 1283abb87edaSPriyangaRamasamy app.add_option("-f, --file", file, "File containing VPD (IPZ/KEYWORD)") 12842f793048SAlpana Kumari ->required(); 1285abb87edaSPriyangaRamasamy 1286abb87edaSPriyangaRamasamy CLI11_PARSE(app, argc, argv); 1287abb87edaSPriyangaRamasamy 12880746eeebSSunny Srivastava // PEL severity should be ERROR in case of any system VPD failure 12890746eeebSSunny Srivastava if (file == systemVpdFilePath) 12900746eeebSSunny Srivastava { 12910746eeebSSunny Srivastava pelSeverity = PelSeverity::ERROR; 12920746eeebSSunny Srivastava } 12930746eeebSSunny Srivastava 12940246a4d7SSantosh Puranik auto jsonToParse = INVENTORY_JSON_DEFAULT; 12950246a4d7SSantosh Puranik 12960246a4d7SSantosh Puranik // If the symlink exists, it means it has been setup for us, switch the 12970246a4d7SSantosh Puranik // path 12980246a4d7SSantosh Puranik if (fs::exists(INVENTORY_JSON_SYM_LINK)) 12990246a4d7SSantosh Puranik { 13000246a4d7SSantosh Puranik jsonToParse = INVENTORY_JSON_SYM_LINK; 13010246a4d7SSantosh Puranik } 13020246a4d7SSantosh Puranik 1303abb87edaSPriyangaRamasamy // Make sure that the file path we get is for a supported EEPROM 13040246a4d7SSantosh Puranik ifstream inventoryJson(jsonToParse); 1305a20be8ecSSunnySrivastava1984 if (!inventoryJson) 1306a20be8ecSSunnySrivastava1984 { 13070746eeebSSunny Srivastava throw(VpdJsonException("Failed to access Json path", jsonToParse)); 1308a20be8ecSSunnySrivastava1984 } 1309a20be8ecSSunnySrivastava1984 1310a20be8ecSSunnySrivastava1984 try 1311a20be8ecSSunnySrivastava1984 { 1312a20be8ecSSunnySrivastava1984 js = json::parse(inventoryJson); 1313a20be8ecSSunnySrivastava1984 } 13148e15b93aSPatrick Williams catch (const json::parse_error& ex) 1315a20be8ecSSunnySrivastava1984 { 13160746eeebSSunny Srivastava throw(VpdJsonException("Json parsing failed", jsonToParse)); 1317a20be8ecSSunnySrivastava1984 } 1318abb87edaSPriyangaRamasamy 131912e24ff3SSantosh Puranik // Do we have the mandatory "frus" section? 132012e24ff3SSantosh Puranik if (js.find("frus") == js.end()) 132112e24ff3SSantosh Puranik { 132212e24ff3SSantosh Puranik throw(VpdJsonException("FRUs section not found in JSON", 132312e24ff3SSantosh Puranik jsonToParse)); 132412e24ff3SSantosh Puranik } 132512e24ff3SSantosh Puranik 1326647868edSPriyangaRamasamy // Check if it's a udev path - patterned as(/ahb/ahb:apb/ahb:apb:bus@) 1327647868edSPriyangaRamasamy if (file.find("/ahb:apb") != string::npos) 1328647868edSPriyangaRamasamy { 1329647868edSPriyangaRamasamy // Translate udev path to a generic /sys/bus/.. file path. 1330647868edSPriyangaRamasamy udevToGenericPath(file); 133112e24ff3SSantosh Puranik 133212e24ff3SSantosh Puranik if ((js["frus"].find(file) != js["frus"].end()) && 133350f60bf8SSantosh Puranik (file == systemVpdFilePath)) 1334647868edSPriyangaRamasamy { 13353c24414fSSunny Srivastava // We need manager service active to process restoring of 13363c24414fSSunny Srivastava // system VPD on hardware. So in case any system restore is 13373c24414fSSunny Srivastava // required, update hardware in the second trigger of parser 13383c24414fSSunny Srivastava // code for system vpd file path. 13393c24414fSSunny Srivastava 13403c24414fSSunny Srivastava std::vector<std::string> interfaces{motherBoardInterface}; 13413c24414fSSunny Srivastava 13423c24414fSSunny Srivastava // call mapper to check for object path creation 13433c24414fSSunny Srivastava MapperResponse subTree = 13443c24414fSSunny Srivastava getObjectSubtreeForInterfaces(pimPath, 0, interfaces); 13453c24414fSSunny Srivastava string mboardPath = 13463c24414fSSunny Srivastava js["frus"][file].at(0).value("inventoryPath", ""); 13473c24414fSSunny Srivastava 13483c24414fSSunny Srivastava // Attempt system VPD restore if we have a motherboard 13493c24414fSSunny Srivastava // object in the inventory. 13503c24414fSSunny Srivastava if ((subTree.size() != 0) && 13513c24414fSSunny Srivastava (subTree.find(pimPath + mboardPath) != subTree.end())) 13523c24414fSSunny Srivastava { 13533c24414fSSunny Srivastava vpdVector = getVpdDataInVector(js, file); 13543c24414fSSunny Srivastava ParserInterface* parser = 13553c24414fSSunny Srivastava ParserFactory::getParser(vpdVector); 13563c24414fSSunny Srivastava variant<KeywordVpdMap, Store> parseResult; 13573c24414fSSunny Srivastava parseResult = parser->parse(); 13583c24414fSSunny Srivastava 13593c24414fSSunny Srivastava if (auto pVal = get_if<Store>(&parseResult)) 13603c24414fSSunny Srivastava { 13613c24414fSSunny Srivastava // map to hold all the keywords whose value is blank and 13623c24414fSSunny Srivastava // needs to be updated at standby. 13633c24414fSSunny Srivastava vector<RestoredEeproms> blankSystemVpdProperties{}; 13643c24414fSSunny Srivastava getListOfBlankSystemVpd(pVal->getVpdMap(), mboardPath, 13653c24414fSSunny Srivastava blankSystemVpdProperties); 13663c24414fSSunny Srivastava 13673c24414fSSunny Srivastava // if system VPD restore is required, update the 13683c24414fSSunny Srivastava // EEPROM 13693c24414fSSunny Srivastava for (const auto& item : blankSystemVpdProperties) 13703c24414fSSunny Srivastava { 13713c24414fSSunny Srivastava updateHardware(get<0>(item), get<1>(item), 13723c24414fSSunny Srivastava get<2>(item), get<3>(item)); 13733c24414fSSunny Srivastava } 13743c24414fSSunny Srivastava } 13753c24414fSSunny Srivastava else 13763c24414fSSunny Srivastava { 13773c24414fSSunny Srivastava std::cout << "Not a valid format to restore system VPD" 13783c24414fSSunny Srivastava << std::endl; 13793c24414fSSunny Srivastava } 13803c24414fSSunny Srivastava // release the parser object 13813c24414fSSunny Srivastava ParserFactory::freeParser(parser); 13823c24414fSSunny Srivastava } 13833c24414fSSunny Srivastava else 13843c24414fSSunny Srivastava { 13853c24414fSSunny Srivastava log<level::ERR>("No object path found"); 13863c24414fSSunny Srivastava } 1387647868edSPriyangaRamasamy return 0; 1388647868edSPriyangaRamasamy } 1389647868edSPriyangaRamasamy } 1390647868edSPriyangaRamasamy 1391647868edSPriyangaRamasamy if (file.empty()) 1392647868edSPriyangaRamasamy { 1393647868edSPriyangaRamasamy cerr << "The EEPROM path <" << file << "> is not valid."; 1394647868edSPriyangaRamasamy return 0; 1395647868edSPriyangaRamasamy } 139612e24ff3SSantosh Puranik if (js["frus"].find(file) == js["frus"].end()) 1397abb87edaSPriyangaRamasamy { 139888edeb6fSSantosh Puranik return 0; 1399abb87edaSPriyangaRamasamy } 1400abb87edaSPriyangaRamasamy 14012f793048SAlpana Kumari if (!fs::exists(file)) 14022f793048SAlpana Kumari { 14032f793048SAlpana Kumari cout << "Device path: " << file 14042f793048SAlpana Kumari << " does not exist. Spurious udev event? Exiting." << endl; 14052f793048SAlpana Kumari return 0; 14062f793048SAlpana Kumari } 14072f793048SAlpana Kumari 1408a20be8ecSSunnySrivastava1984 baseFruInventoryPath = js["frus"][file][0]["inventoryPath"]; 14098589375fSSantosh Puranik // Check if we can read the VPD file based on the power state 141027a5e95aSSantosh Puranik // We skip reading VPD when the power is ON in two scenarios: 141127a5e95aSSantosh Puranik // 1) The eeprom we are trying to read is that of the system VPD 141227a5e95aSSantosh Puranik // 2) The JSON tells us that the FRU EEPROM cannot be read when 141327a5e95aSSantosh Puranik // we are powered ON. 141427a5e95aSSantosh Puranik if (js["frus"][file].at(0).value("powerOffOnly", false) || 141527a5e95aSSantosh Puranik (file == systemVpdFilePath)) 14168589375fSSantosh Puranik { 14178589375fSSantosh Puranik if ("xyz.openbmc_project.State.Chassis.PowerState.On" == 14188589375fSSantosh Puranik getPowerState()) 14198589375fSSantosh Puranik { 14208589375fSSantosh Puranik cout << "This VPD cannot be read when power is ON" << endl; 14218589375fSSantosh Puranik return 0; 14228589375fSSantosh Puranik } 14238589375fSSantosh Puranik } 1424a20be8ecSSunnySrivastava1984 14252f793048SAlpana Kumari try 14262f793048SAlpana Kumari { 1427c2fe40f8SPriyangaRamasamy vpdVector = getVpdDataInVector(js, file); 142833c61c2dSPriyangaRamasamy ParserInterface* parser = ParserFactory::getParser(vpdVector); 14292f793048SAlpana Kumari variant<KeywordVpdMap, Store> parseResult; 14302f793048SAlpana Kumari parseResult = parser->parse(); 14319a19554cSSunnySrivastava1984 1432e12b181bSSunnySrivastava1984 if (auto pVal = get_if<Store>(&parseResult)) 1433abb87edaSPriyangaRamasamy { 1434e12b181bSSunnySrivastava1984 populateDbus(pVal->getVpdMap(), js, file); 1435e12b181bSSunnySrivastava1984 } 1436e12b181bSSunnySrivastava1984 else if (auto pVal = get_if<KeywordVpdMap>(&parseResult)) 1437abb87edaSPriyangaRamasamy { 1438e12b181bSSunnySrivastava1984 populateDbus(*pVal, js, file); 1439abb87edaSPriyangaRamasamy } 1440abb87edaSPriyangaRamasamy 1441e12b181bSSunnySrivastava1984 // release the parser object 1442e12b181bSSunnySrivastava1984 ParserFactory::freeParser(parser); 1443abb87edaSPriyangaRamasamy } 14448e15b93aSPatrick Williams catch (const exception& e) 14452f793048SAlpana Kumari { 14462f793048SAlpana Kumari postFailAction(js, file); 1447a504c3eeSPriyangaRamasamy throw; 14482f793048SAlpana Kumari } 14492f793048SAlpana Kumari } 1450a20be8ecSSunnySrivastava1984 catch (const VpdJsonException& ex) 1451a20be8ecSSunnySrivastava1984 { 1452a20be8ecSSunnySrivastava1984 additionalData.emplace("JSON_PATH", ex.getJsonPath()); 1453a20be8ecSSunnySrivastava1984 additionalData.emplace("DESCRIPTION", ex.what()); 14540746eeebSSunny Srivastava createPEL(additionalData, pelSeverity, errIntfForJsonFailure); 1455a20be8ecSSunnySrivastava1984 1456a20be8ecSSunnySrivastava1984 cerr << ex.what() << "\n"; 1457a20be8ecSSunnySrivastava1984 rc = -1; 1458a20be8ecSSunnySrivastava1984 } 1459a20be8ecSSunnySrivastava1984 catch (const VpdEccException& ex) 1460a20be8ecSSunnySrivastava1984 { 1461a20be8ecSSunnySrivastava1984 additionalData.emplace("DESCRIPTION", "ECC check failed"); 1462a20be8ecSSunnySrivastava1984 additionalData.emplace("CALLOUT_INVENTORY_PATH", 1463a20be8ecSSunnySrivastava1984 INVENTORY_PATH + baseFruInventoryPath); 14640746eeebSSunny Srivastava createPEL(additionalData, pelSeverity, errIntfForEccCheckFail); 1465c2fe40f8SPriyangaRamasamy dumpBadVpd(file, vpdVector); 1466a20be8ecSSunnySrivastava1984 cerr << ex.what() << "\n"; 1467a20be8ecSSunnySrivastava1984 rc = -1; 1468a20be8ecSSunnySrivastava1984 } 1469a20be8ecSSunnySrivastava1984 catch (const VpdDataException& ex) 1470a20be8ecSSunnySrivastava1984 { 1471a20be8ecSSunnySrivastava1984 additionalData.emplace("DESCRIPTION", "Invalid VPD data"); 1472a20be8ecSSunnySrivastava1984 additionalData.emplace("CALLOUT_INVENTORY_PATH", 1473a20be8ecSSunnySrivastava1984 INVENTORY_PATH + baseFruInventoryPath); 14740746eeebSSunny Srivastava createPEL(additionalData, pelSeverity, errIntfForInvalidVPD); 1475c2fe40f8SPriyangaRamasamy dumpBadVpd(file, vpdVector); 1476a20be8ecSSunnySrivastava1984 cerr << ex.what() << "\n"; 1477a20be8ecSSunnySrivastava1984 rc = -1; 1478a20be8ecSSunnySrivastava1984 } 14798e15b93aSPatrick Williams catch (const exception& e) 1480abb87edaSPriyangaRamasamy { 1481c2fe40f8SPriyangaRamasamy dumpBadVpd(file, vpdVector); 1482abb87edaSPriyangaRamasamy cerr << e.what() << "\n"; 1483abb87edaSPriyangaRamasamy rc = -1; 1484abb87edaSPriyangaRamasamy } 1485abb87edaSPriyangaRamasamy 1486abb87edaSPriyangaRamasamy return rc; 1487abb87edaSPriyangaRamasamy } 1488