/* IBM_PROLOG_BEGIN_TAG */ /* This is an automatically generated prolog. */ /* */ /* $Source: src/import/chips/centaur/procedures/hwp/memory/p9c_mss_maint_cmds.H $ */ /* */ /* OpenPOWER HostBoot Project */ /* */ /* Contributors Listed Below - COPYRIGHT 2017 */ /* [+] International Business Machines Corp. */ /* */ /* */ /* 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. */ /* */ /* IBM_PROLOG_END_TAG */ /// /// @file p9c_mss_maint_cmds.H /// @brief Utility functions for running maint cmds,accessing markstore, and accessing steer muxes. /// *HWP HWP Owner: Luke Mulkey /// *HWP HWP Backup: Andre Marin /// *HWP Team: Memory /// *HWP Level: 2 /// *HWP Consumed by: HB:CI /// #ifndef _MSS_MAINT_CMDS_H #define _MSS_MAINT_CMDS_H //------------------------------------------------------------------------------ // Includes //------------------------------------------------------------------------------ #include #include //------------------------------------------------------------------------------ // Constants and enums //------------------------------------------------------------------------------ /// /// @brief Structure to get count of repairs applied /// struct repair_count { uint8_t symbolmark_count[MAX_RANKS_PER_PORT]; uint8_t chipmark_count[MAX_RANKS_PER_PORT]; uint8_t steer_count[MAX_RANKS_PER_PORT]; }; /// /// @brief For index into this table, use 1st symbol index of x8 chip mark / 4. /// static const uint8_t mss_x8_chip_mark_to_centaurDQ[18][2] = { // centaurDQ port 1st symbol index of chip mark {64, 1}, // 0 {64, 0}, // 4 {56, 1}, // 8 {48, 1}, // 12 {40, 1}, // 16 {32, 1}, // 20 {24, 1}, // 24 {16, 1}, // 28 {8, 1}, // 32 {0, 1}, // 36 {56, 0}, // 40 {48, 0}, // 44 {40, 0}, // 48 {32, 0}, // 52 {24, 0}, // 56 {16, 0}, // 60 {8, 0}, // 64 {0, 0} // 68 }; /// /// @brief For index into this table, use 1st symbol index of x4 chip mark / 2. /// static const uint8_t mss_x4_chip_mark_to_centaurDQ[36][2] = { // centaurDQ port 1st symbol index of x4 chip mark {68, 1}, // 0 - NOTE: not actually valid in x4 mode.... {64, 1}, // 2 {68, 0}, // 4 {64, 0}, // 6 {60, 1}, // 8 {56, 1}, // 10 {52, 1}, // 12 {48, 1}, // 14 {44, 1}, // 16 {40, 1}, // 18 {36, 1}, // 20 {32, 1}, // 22 {28, 1}, // 24 {24, 1}, // 26 {20, 1}, // 28 {16, 1}, // 30 {12, 1}, // 32 {8, 1}, // 34 {4, 1}, // 36 {0, 1}, // 38 {60, 0}, // 40 {56, 0}, // 42 {52, 0}, // 44 {48, 0}, // 46 {44, 0}, // 48 {40, 0}, // 50 {36, 0}, // 52 {32, 0}, // 54 {28, 0}, // 56 {24, 0}, // 58 {20, 0}, // 60 {16, 0}, // 62 {12, 0}, // 64 {8, 0}, // 66 {4, 0}, // 68 {0, 0} // 70 }; /// /// @brief Used to get addess range of all ranks from get_address_range() /// const uint8_t MSS_ALL_RANKS = 0xff; /// /// @brief Used to indicate invalid symbol /// const uint8_t MSS_INVALID_SYMBOL = 0xff; /// /// @brief SteerMux information /// namespace mss_SteerMux { /// /// @brief Used to specify read or write steer mux /// enum mux_type { READ_MUX = 0, WRITE_MUX = 1, }; /// /// @brief Used to specify steer type /// enum steer_type { DRAM_SPARE_PORT0 = 0, // Spare DRAM on port0 DRAM_SPARE_PORT1 = 1, // Spare DRAM on port1 ECC_SPARE = 2, // ECC spare (used in x4 mode only) }; }; //------------------------------------------------------------------------------ // Parent class for all maintenance command types //------------------------------------------------------------------------------ /// /// @brief Contains functions common to multiple maint cmd types. /// class mss_MaintCmd { public: // enums /// /// @brief Index into array containing data patterns to load into memory /// enum PatternIndex { PATTERN_0 = 0, //0x00 PATTERN_1 = 1, //0xFF PATTERN_2 = 2, //0xF0 PATTERN_3 = 3, //0x0F PATTERN_4 = 4, //0xAA PATTERN_5 = 5, //0x55 PATTERN_6 = 6, //0xCC PATTERN_7 = 7, //0x33 PATTERN_RANDOM = 8, // random seed }; /// /// @brief Inject type used for atomic error inject maint cmd /// enum InjectType { ATOMIC_ALT_CE_INJ = 0, ATOMIC_ALT_CHIPKILL_INJ = 1, ATOMIC_ALT_UE_INJ = 2, ATOMIC_ALT_SUE_INJ = 3, }; /// /// @brief Stop conditions for maint cmds. /// enum StopCondition { NO_STOP_CONDITIONS = 0x0000, ///< Turn off all stop conditions STOP_IMMEDIATE = 0x8000, ///< Stop immediately if stop on error condition hit STOP_END_OF_RANK = 0x4000, ///< Stop at end of rank if stop on error condition hit STOP_ON_HARD_NCE_ETE = 0x2000, ///< Stop on hard new CE error threshlold equal STOP_ON_INT_NCE_ETE = 0x1000, ///< Stop on intermittent new CE error threshlold equal STOP_ON_SOFT_NCE_ETE = 0x0800, ///< Stop on soft new CE error threshlold equal STOP_ON_SCE = 0x0400, ///< Stop on symbol corrected error (error on symbol already marked) STOP_ON_MCE = 0x0200, ///< Stop on mark corrected error (error on chip already marked) STOP_ON_RETRY_CE_ETE = 0x0100, ///< Stop on retry CE error threshold equal (UE that went away on retry) STOP_ON_MPE = 0x0080, ///< Stop on mark placed error (hw placed a chip mark) STOP_ON_UE = 0x0040, ///< Stop on UE STOP_ON_SUE = 0x0020, ///< Stop on SUE STOP_ON_END_ADDRESS = 0x0010, ///< Stop when MBMACAQ = MBMEAQ ENABLE_CMD_COMPLETE_ATTENTION = 0x0008, ///< Enable command complete attention }; /// /// @brief speed options for time base commands. /// enum TimeBaseSpeed { BG_SCRUB, ///< Background scrubbing (field). FAST_MIN_BW_IMPACT, ///< Runtime DRAM repairs procedures (field) and the initial fast scrub of memory (field). FAST_MED_BW_IMPACT, ///< Background scrubbing (mnfg) and the initial fast scrub of memory (mnfg) FAST_MAX_BW_IMPACT, ///< IPL time DRAM repairs procedures (field / mnfg) and runtime DRAM repairs procedures (mnfg). }; protected: /// /// @brief Maintenance command types /// enum CmdType { TIMEBASE_READ = 0, TIMEBASE_SCRUB = 1, TIMEBASE_STEER_CLEANUP = 2, TIMEBASE_INIT = 3, TIMEBASE_RANDOM_INIT = 4, SUPERFAST_READ = 8, SUPERFAST_INIT = 9, SUPERFAST_RANDOM_INIT = 10, MEMORY_DISPLAY = 16, MEMORY_ALTER = 17, MEMORY_ALTER_WITH_ECC_OVERRIDE = 18, ATOMIC_ALTER_ERROR_INJECT = 19, INCREMENT_MBMACA_ADDRESS = 20, }; public: /// /// @brief Constructor /// /// @param[in] i_target MBA target /// @param[in] i_start_addr Address cmd will start at /// @param[in] i_end_addr, Address cmd will stop at /// @param[in] i_stop_condition Mask of error conditions cmd should stop on /// @param[in] i_poll Set to true if you wait for command to complete /// @param[in] i_cmd_type Command type /// mss_MaintCmd( const fapi2::Target& i_target, const fapi2::buffer& i_start_addr, const fapi2::buffer& i_end_addr, const uint32_t i_stop_condition, const bool i_poll, const CmdType i_cmd_type ); /// /// @brief Destructor /// virtual ~mss_MaintCmd() {} //---------------------------------------------------------------------- // These are pure virtual functions that must be defined by every child // class. //---------------------------------------------------------------------- /// /// @brief Gets the cmd type of a given object /// @return CmdType /// virtual CmdType getCmdType() const = 0; /// /// @brief Saves any settings that need to be restored when command is done. /// Loads the setup parameters into the hardware. Starts the command, /// then either polls for complete or exits with command running. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// virtual fapi2::ReturnCode setupAndExecuteCmd() = 0; //---------------------------------------------------------------------- // These are virtual functions that will have a default definition in this // class but can be overriden by a child class. //---------------------------------------------------------------------- /// /// @brief Stops running maint cmd, and saves the address it stopped at. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// virtual fapi2::ReturnCode stopCmd(); /// /// @brief Called once a command is done if we need to restore settings that /// had to be modified to run a specific command type, or clear error /// data in the hw that is no longer relevant. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// @note NOT YET IMPLEMENTED /// virtual fapi2::ReturnCode cleanupCmd(); protected: //---------------------------------------------------------------------- // These are virtual functions that will have a default definition in this // class but can be overriden by a child class. //---------------------------------------------------------------------- /// /// @brief Checks for valid hw state and setup required before a cmd is run. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// virtual fapi2::ReturnCode preConditionCheck(); /// /// @brief Loads command type into hw. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// virtual fapi2::ReturnCode loadCmdType(); /// /// @brief Loads start address into hw. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// virtual fapi2::ReturnCode loadStartAddress(); /// /// @brief Loads end address into hw. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// virtual fapi2::ReturnCode loadEndAddress(); /// /// @brief Loads stop conditions into hw. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// virtual fapi2::ReturnCode loadStopCondMask(); /// /// @brief Starts command. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// virtual fapi2::ReturnCode startMaintCmd(); /// /// @brief Polls for command complete. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// virtual fapi2::ReturnCode pollForMaintCmdComplete(); /// /// @brief FOR DEBUG ONLY: Reads hw regs for FFDC after command is done. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// virtual fapi2::ReturnCode collectFFDC(); /// /// @brief Loads pattern into hw. /// @param[in] i_initPattern Index into array containing patterns to load. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// @note For now, no array of pattens, just hardcoded pattern of all 0's. /// virtual fapi2::ReturnCode loadPattern(const PatternIndex i_initPattern); /// /// @brief Loads timebase speed into hw. /// @param[in] i_speed See enum TimeBaseSpeed /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// virtual fapi2::ReturnCode loadSpeed(const TimeBaseSpeed i_speed); /// /// @brief Checks for hw to be right state after cmd is started. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// @note For now, no array of pattens, just hardcoded pattern of all 0's. /// virtual fapi2::ReturnCode postConditionCheck(); protected: const fapi2::Target iv_target; // MBA fapi2::Target iv_targetCentaur; // Centaur associated with this MBA fapi2::buffer iv_start_addr; // Start address fapi2::buffer iv_end_addr; // End address uint32_t iv_stop_condition; // Mask of stop contitions bool iv_poll; // Set true to wait for cmd complete const CmdType iv_cmd_type; // Command type uint8_t iv_mbaPosition; // 0 = mba01, 1 = mba23 }; //------------------------------------------------------------------------------ // Child classes //------------------------------------------------------------------------------ /// /// @brief Init an address range to a pattern /// class mss_SuperFastInit : public mss_MaintCmd { public: /// /// @brief Superfastinit Constructor /// /// @param[in] i_target MBA target /// @param[in] i_start_addr Address cmd will start at /// @param[in] i_end_addr, Address cmd will stop at /// @param[in] i_initPattern Pattern to initialize memory /// @param[in] i_stop_condition Mask of error conditions cmd should stop on /// @param[in] i_poll Set to true if you wait for command to complete /// mss_SuperFastInit( const fapi2::Target& i_target, // MBA target const fapi2::buffer& i_start_addr, // Address cmd will start at const fapi2::buffer& i_end_addr, // Address cmd will stop at const PatternIndex i_initPattern, // Index into table containing patterns to load into memory const uint32_t i_stop_condition, // Mask of error conditions cmd should stop on const bool i_poll ); // Set to true if you wait for command to complete public: /// /// @brief Return superfastinit cmd type /// fapi2::ReturnCode setupAndExecuteCmd(); CmdType getCmdType() const { return cv_cmd_type; } // This class's implementation of parent class functions that can be // overridden. /// /// @brief Set superfastinit start addr /// @param[in] i_start_addr Start Address /// void setStartAddr(const fapi2::buffer i_start_addr) { iv_start_addr = i_start_addr; } /// /// @brief Set superfastinit end addr /// @param[in] i_end_addr End Address /// void setEndAddr(const fapi2::buffer i_end_addr ) { iv_end_addr = i_end_addr; } fapi2::buffer getStartAddr() const { return iv_start_addr; } fapi2::buffer getEndAddr() const { return iv_end_addr; } private: fapi2::ReturnCode setSavedData(const uint32_t i_savedData ) { fapi2::ReturnCode l_rc; iv_savedData = i_savedData; return l_rc; } uint32_t getSavedData() { return iv_savedData; } private: // Class variable(s) static const CmdType cv_cmd_type; private: // Instance variable(s) // List of things to save may be cmd-specific, so keep it here for now uint32_t iv_savedData; // Index into table containing patterns to load into memory PatternIndex iv_initPattern; }; //------------------------------------------------------------------------------ // SuperFastRandomInit //------------------------------------------------------------------------------ /// /// @brief init an address range to random pattern /// class mss_SuperFastRandomInit : public mss_MaintCmd { public: // Constructor(s) /// /// @brief SuperFastRandomInit Constructor /// /// @param[in] i_target MBA target /// @param[in] i_start_addr Address cmd will start at /// @param[in] i_end_addr, Address cmd will stop at /// @param[in] i_initPattern Pattern to initialize /// @param[in] i_stop_condition Mask of error conditions cmd should stop on /// @param[in] i_poll Set to true if you wait for command to complete /// mss_SuperFastRandomInit( const fapi2::Target& i_target, // MBA target const fapi2::buffer& i_start_addr, // Address cmd will start at const fapi2::buffer& i_end_addr, // Address cmd will stop at const PatternIndex i_initPattern, // Index into table containing pattern to use for random seed const uint32_t i_stop_condition, // Mask of error conditions cmd should stop on const bool i_poll ); // Set to true if you wait for command to complete public: fapi2::ReturnCode setupAndExecuteCmd(); CmdType getCmdType() const { return cv_cmd_type; } // This class's implementation of parent class functions that can be // overridden. fapi2::ReturnCode cleanupCmd(); void setStartAddr(const fapi2::buffer i_start_addr) { iv_start_addr = i_start_addr; } void setEndAddr(const fapi2::buffer i_end_addr ) { iv_end_addr = i_end_addr; } fapi2::buffer getStartAddr() const { return iv_start_addr; } fapi2::buffer getEndAddr() const { return iv_end_addr; } private: fapi2::ReturnCode setSavedData( const uint32_t i_savedData ) { fapi2::ReturnCode l_rc; iv_savedData = i_savedData; return l_rc; } uint32_t getSavedData() { return iv_savedData; } private: // Class variable(s) static const CmdType cv_cmd_type; private: // Instance variable(s) // List of things to save may be cmd-specific, so keep it here for now uint32_t iv_savedData; // Index into table containing patterns to load into memory PatternIndex iv_initPattern; // Setting that had to be restored when done fapi2::buffer iv_saved_MBA_WRD_MODE; }; //------------------------------------------------------------------------------ // mss_SuperFastRead //------------------------------------------------------------------------------ class mss_SuperFastRead : public mss_MaintCmd { public: // Constructor(s) /// /// @brief SuperFastRead Constructor /// /// @param[in] i_target MBA target /// @param[in] i_start_addr Address cmd will start at /// @param[in] i_end_addr, Address cmd will stop at /// @param[in] i_stop_condition Mask of error conditions cmd should stop on /// @param[in] i_poll Set to true if you wait for command to complete /// mss_SuperFastRead( const fapi2::Target& i_target, // MBA target const fapi2::buffer& i_start_addr, // Address cmd will start at const fapi2::buffer& i_end_addr, // Address cmd will stop at const uint32_t i_stop_condition, // Mask of error conditions cmd should stop on const bool i_poll ); // Set to true if you wait for command to complete public: fapi2::ReturnCode setupAndExecuteCmd(); CmdType getCmdType() const { return cv_cmd_type; } // This class's implementation of parent class functions that can be // overridden. fapi2::ReturnCode cleanupCmd(); void setStartAddr(const fapi2::buffer i_start_addr) { iv_start_addr = i_start_addr; } void setEndAddr(const fapi2::buffer i_end_addr ) { iv_end_addr = i_end_addr; } fapi2::buffer getStartAddr() const { return iv_start_addr; } fapi2::buffer getEndAddr() const { return iv_end_addr; } private: fapi2::ReturnCode setSavedData(const uint32_t i_savedData ) { fapi2::ReturnCode l_rc; iv_savedData = i_savedData; return l_rc; } uint32_t getSavedData() { return iv_savedData; } fapi2::ReturnCode ueTrappingSetup(); private: // Class variable(s) static const CmdType cv_cmd_type; private: // Instance variable(s) // List of things to save may be cmd-specific, so keep it here for now uint32_t iv_savedData; // Setting that had to be restored when done fapi2::buffer iv_saved_MBA_RRQ0; }; //------------------------------------------------------------------------------ // mss_AtomicInject //------------------------------------------------------------------------------ class mss_AtomicInject : public mss_MaintCmd { public: // Constructor(s) /// /// @brief AtomicInject Constructor /// @param[in] i_target MBA target /// @param[in] i_start_addr Address cmd will start at /// @param[in] i_injectType Type of inject /// mss_AtomicInject( const fapi2::Target& i_target, // MBA target const fapi2::buffer& i_start_addr, // Address to inject on const InjectType i_injectType); // Inject type public: fapi2::ReturnCode setupAndExecuteCmd(); CmdType getCmdType() const { return cv_cmd_type; } void setStartAddr(const fapi2::buffer i_start_addr) { iv_start_addr = i_start_addr; } fapi2::buffer getStartAddr() const { return iv_start_addr; } void setInjectType(const InjectType i_injectType) { iv_injectType = i_injectType; } private: fapi2::ReturnCode setSavedData(const uint32_t i_savedData ) { fapi2::ReturnCode l_rc; iv_savedData = i_savedData; return l_rc; } uint32_t getSavedData() { return iv_savedData; } private: // Class variable(s) static const CmdType cv_cmd_type; private: // Instance variable(s) // List of things to save may be cmd-specific, so keep it here for now uint32_t iv_savedData; // Inject type InjectType iv_injectType; }; //------------------------------------------------------------------------------ // Display //------------------------------------------------------------------------------ class mss_Display : public mss_MaintCmd { public: // Constructor(s) /// /// @brief Display Constructor /// @param[in] i_target MBA target /// @param[in] i_start_addr Address cmd will start at /// mss_Display( const fapi2::Target& i_target, // MBA target const fapi2::buffer& i_start_addr ); // Address to display public: // Function declaration(s) fapi2::ReturnCode setupAndExecuteCmd(); CmdType getCmdType() const { return cv_cmd_type; } void setStartAddr(const fapi2::buffer& i_start_addr) { iv_start_addr = i_start_addr; } fapi2::buffer getStartAddr() const { return iv_start_addr; } private: fapi2::ReturnCode setSavedData(const uint32_t i_savedData ) { fapi2::ReturnCode l_rc; iv_savedData = i_savedData; return l_rc; } uint32_t getSavedData() { return iv_savedData; } private: // Class variable(s) static const CmdType cv_cmd_type; private: // Instance variable(s) // List of things to save may be cmd-specific, so keep it here for now uint32_t iv_savedData; }; /// /// @brief Edit MBSPA register /// class mss_IncrementAddress : public mss_MaintCmd { public: // Constructor(s) /// /// @brief IncrementAddress Constructor /// @param[in] i_target MBA target /// mss_IncrementAddress( const fapi2::Target& i_target ); // MBA target public: fapi2::ReturnCode setupAndExecuteCmd(); CmdType getCmdType() const { return cv_cmd_type; } private: static const CmdType cv_cmd_type; }; /// /// @brief Set timebase speed /// class mss_TimeBaseScrub : public mss_MaintCmd { public: // Constructor(s) /// /// @brief TimeBaseScrub Constructor /// @param[in] i_target MBA target /// @param[in] i_start_addr Address cmd will start at /// @param[in] i_end_addr, Address cmd will stop at /// @param[in] i_speed TimeBase Speed /// @param[in] i_stop_condition Mask of error conditions cmd should stop on /// @param[in] i_poll Set to true if you wait for command to complete /// mss_TimeBaseScrub( const fapi2::Target& i_target, // MBA target const fapi2::buffer& i_start_addr, // Address cmd will start at const fapi2::buffer& i_end_addr, // Address cmd will stop at TimeBaseSpeed i_speed, // See enum TimeBaseSpeed uint32_t i_stop_condition, // Mask of error conditions cmd should stop on bool i_poll ); // Set to true if you wait for command to complete public: fapi2::ReturnCode setupAndExecuteCmd(); CmdType getCmdType() const { return cv_cmd_type; } // This class's implementation of parent class functions that can be // overridden. void setStartAddr(fapi2::buffer i_start_addr) { iv_start_addr = i_start_addr; } void setEndAddr( fapi2::buffer i_end_addr ) { iv_end_addr = i_end_addr; } fapi2::buffer getStartAddr() const { return iv_start_addr; } fapi2::buffer getEndAddr() const { return iv_end_addr; } private: fapi2::ReturnCode setSavedData( uint32_t i_savedData ) { fapi2::ReturnCode l_rc; iv_savedData = i_savedData; return l_rc; } uint32_t getSavedData() { return iv_savedData; } private: // Class variable(s) static const CmdType cv_cmd_type; private: // Instance variable(s) // list of things to save may be specific to each cmd, so keep it // here for now uint32_t iv_savedData; // See enum TimeBaseSpeed TimeBaseSpeed iv_speed; }; /// /// @brief Execute TimeBaseSteerCleanup /// class mss_TimeBaseSteerCleanup : public mss_MaintCmd { public: // Constructor(s) /// /// @brief TimeBaseSteerCleanup Constructor /// @param[in] i_target MBA target /// @param[in] i_start_addr Address cmd will start at /// @param[in] i_end_addr, Address cmd will stop at /// @param[in] i_stop_condition Mask of error conditions cmd should stop on /// @param[in] i_speed TimeBase speed /// @param[in] i_poll Set to true if you wait for command to complete /// mss_TimeBaseSteerCleanup( const fapi2::Target& i_target, // MBA target const fapi2::buffer& i_start_addr, // Address cmd will start at const fapi2::buffer& i_end_addr, // Address cmd will stop at const TimeBaseSpeed i_speed, // See enum TimeBaseSpeed const uint32_t i_stop_condition, // Mask of error conditions cmd should stop on const bool i_poll ); // Set to true if you wait for command to complete public: fapi2::ReturnCode setupAndExecuteCmd(); CmdType getCmdType() const { return cv_cmd_type; } // This class's implementation of parent class functions that can be // overridden. void setStartAddr(fapi2::buffer i_start_addr) { iv_start_addr = i_start_addr; } void setEndAddr( fapi2::buffer i_end_addr ) { iv_end_addr = i_end_addr; } fapi2::buffer getStartAddr() const { return iv_start_addr; } fapi2::buffer getEndAddr() const { return iv_end_addr; } private: fapi2::ReturnCode setSavedData( uint32_t i_savedData ) { fapi2::ReturnCode l_rc; iv_savedData = i_savedData; return l_rc; } uint32_t getSavedData() { return iv_savedData; } private: // Class variable(s) static const CmdType cv_cmd_type; private: // Instance variable(s) // list of things to save may be specific to each cmd, so keep it // here for now uint32_t iv_savedData; // See enum TimeBaseSpeed TimeBaseSpeed iv_speed; }; //------------------------------------------------------------------------------ // Utility funcitons //------------------------------------------------------------------------------ /// /// @brief Calculates start and end address for a single rank, or all ranks behind the MBA. /// /// @param[in] i_target MBA target /// @param[in] i_rank Either single rank on the MBA to get start/end address /// for (0x00-0x07) /// Or MSS_ALL_RANKS = 0xff to get start/end address for /// all ranks behind the MBA. /// @param[out] o_start_addr Address to start cmd at. /// @param[out] o_end_addr Address to stop cmd at. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_get_address_range( const fapi2::Target& i_target, uint8_t i_rank, fapi2::buffer& o_start_addr, fapi2::buffer& o_end_addr ); /// /// @brief Calculates start and end address for a single slave rank /// /// @param[in] i_target MBA target /// @param[in] i_master master rank corresponding to the desired slave rank on the MBA to get start/end address /// for (0x00-0x07) /// @param[in] i_slave Slave rank to get the address range for /// @param[out] o_start_addr Address to start cmd at. /// @param[out] o_end_addr Address to stop cmd at. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_get_slave_address_range( const fapi2::Target& i_target, const uint8_t i_master, const uint8_t i_slave, fapi2::buffer& o_start_addr, fapi2::buffer& o_end_addr ); /// /// @brief Mark store is implemented as one register per rank, so read register for the given rank. /// /// If MPE FIR for the given rank (scrub or fetch) is on after the read, /// we will read one more time to make sure we get latest. /// /// @param[in] i_target MBA target /// @param[in] i_rank Rank to get markstore for. /// @param[out] o_symbolMark Symbol mark, converted from galois field to symbol /// index,(if no mark return 0xff) /// @param[out] o_chipMark Chip mark, converted from galois field to first /// symbol index of the chip, (if no mark return 0xff) /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_get_mark_store( const fapi2::Target& i_target, const uint8_t i_rank, uint8_t& o_symbolMark, uint8_t& o_chipMark ); /// /// @brief Mark store is implemented as one register per rank, so write register the rank. /// /// NOTE: Will be writing to both chip and symbol /// field at same time, so should use a read/modify/write approach to /// avoid unintentionally over-writing something. /// /// @param[in] i_target MBA target /// @param[in] i_rank Rank to write markstore for. /// @param[in] i_symbolMark Symbol index, which will be converted to galois field /// (if input is 0xff, we write 0x00 for no symbol mark). /// @param[in] i_chipMark First symbol index of the chip, which will be /// converted to galois field (if input is 0xff, we write /// 0x00 for no chip mark). /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_put_mark_store( const fapi2::Target& i_target, const uint8_t i_rank, const uint8_t i_symbolMark, const uint8_t i_chipMark ); /// /// @brief Gets either the read or write steer mux control register for the given rank /// /// Converts from steer code to x8/x4 dram index to /// first symbol index for all DRAMs steered on that rank. /// /// @param[in] i_target MBA target /// @param[in] i_rank Rank we want to read steer mux for. /// @param[in] i_mux_type Select either the read mux or the write mux /// to get. /// @param[out] o_dramSparePort0Symbol First symbol index of the DRAM fixed by the /// spare on port0 (if no steer, return 0xff) /// @param[out] o_dramSparePort1Symbol First symbol index of the DRAM fixed by the /// spare on port1 (if no steer, return 0xff) /// @param[out] o_eccSpareSymbol First symbol index of the DRAM fixed by the /// ECC spare, which can be used on either port0 /// or port1 (if no steer, return 0xff) /// @note The ECC spare is available only with x4 mode ECC. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_get_steer_mux( const fapi2::Target& i_target, const uint8_t i_rank, const mss_SteerMux::mux_type i_mux_type, uint8_t& o_dramSparePort0Symbol, uint8_t& o_dramSparePort1Symbol, uint8_t& o_eccSpareSymbol ); /// /// @brief Updates the read or write steer mux control register with the steer type for the rank /// /// /// @param[in] i_target MBA target /// @param[in] i_rank Rank we want to write steer mux for. /// @param[in] i_mux_type Select either the read mux or the write mux /// to update. /// @param[in] i_steer_type 0 = DRAM_SPARE_PORT0, Spare DRAM on port0 /// 1 = DRAM_SPARE_PORT1, Spare DRAM on port1 /// 2 = ECC_SPARE, ECC spare (used in x4 mode only) /// @param[in] i_symbol First symbol index of the DRAM to steer /// around. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_put_steer_mux( const fapi2::Target& i_target, const uint8_t i_rank, const mss_SteerMux::mux_type i_mux_type, const uint8_t i_steer_type, const uint8_t i_symbol ); /// /// @brief Reads the steer muxes for the given rank /// /// @param[in] i_target MBA target /// @param[in] i_rank Rank we want to read steer mux for. /// @param[out] o_dramSparePort0Symbol First symbol index of the DRAM fixed by the /// spare on port0 (if no steer, return 0xff) /// @param[out] o_dramSparePort1Symbol First symbol index of the DRAM fixed by the /// spare on port1 (if no steer, return 0xff) /// @param[out] o_eccSpareSymbol First symbol index of the DRAM fixed by the /// ECC spare, which can be used on either port0 /// or port1 (if no steer, return 0xff) /// @note The ECC spare is available only with x4 mode ECC. /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_check_steering(const fapi2::Target& i_target, const uint8_t i_rank, uint8_t& o_dramSparePort0Symbol, uint8_t& o_dramSparePort1Symbol, uint8_t& o_eccSpareSymbol ); /// /// @brief Set write mux, wait for periodic cal, set read mux, for the given rank. /// /// @param[in] i_target MBA target /// @param[in] i_rank Rank we want to write steer mux for. /// @param[in] i_symbol First symbol index of the DRAM to steer /// around. /// @param[in] i_x4EccSpare If true, writes the x4 ECC Spare. Otherwise, /// writes the DRAM spare (default). /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_do_steering(const fapi2::Target& i_target, const uint8_t i_rank, const uint8_t i_symbol, const bool i_x4EccSpare = false ); /// /// @brief This procedure applies the maximum possible DRAM repairs (chip/symbol marks, DRAM steers) /// /// brief cont. : to known bad bits recorded in /// DIMM VPD. This operation is done on both valid logical DIMM pairs /// behind the given MBA. /// /// @param[in] i_target MBA target /// @param[out] o_repairs_applied 8-bit mask, where a bit set means the /// specified rank had any repairs applied. /// /// rank0 = 0x80 (maps to port0_dimm0, port1_dimm0) /// rank1 = 0x40 (maps to port0_dimm0, port1_dimm0) /// rank2 = 0x20 (maps to port0_dimm0, port1_dimm0) /// rank3 = 0x10 (maps to port0_dimm0, port1_dimm0) /// rank4 = 0x08 (maps to port0_dimm1, port1_dimm1) /// rank5 = 0x04 (maps to port0_dimm1, port1_dimm1) /// rank6 = 0x02 (maps to port0_dimm1, port1_dimm1) /// rank7 = 0x01 (maps to port0_dimm1, port1_dimm1) /// /// @param[out] o_repairs_exceeded 4-bit mask, where a bit set means the /// specified DIMM-select on the specified port /// had more bad bits than could be repaired. /// /// port0_dimm0 = 0x8 /// port0_dimm1 = 0x4 /// port1_dimm0 = 0x2 /// port1_dimm1 = 0x1 /// /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_restore_DRAM_repairs( const fapi2::Target& i_target, uint8_t& o_repairs_applied, uint8_t& o_repairs_exceeded); /// /// @brief This procedure counts the maximum possible DRAM repairs (chip/symbol marks, DRAM steers) /// /// brief cont. to known bad bits recorded in /// DIMM VPD. This operation is done on both valid logical DIMM pairs /// behind the given MBA. /// /// @param[in] i_target MBA target /// @param[out] o_repairs_applied 8-bit mask, where a bit set means the /// specified rank had any repairs applied. /// /// rank0 = 0x80 (maps to port0_dimm0, port1_dimm0) /// rank1 = 0x40 (maps to port0_dimm0, port1_dimm0) /// rank2 = 0x20 (maps to port0_dimm0, port1_dimm0) /// rank3 = 0x10 (maps to port0_dimm0, port1_dimm0) /// rank4 = 0x08 (maps to port0_dimm1, port1_dimm1) /// rank5 = 0x04 (maps to port0_dimm1, port1_dimm1) /// rank6 = 0x02 (maps to port0_dimm1, port1_dimm1) /// rank7 = 0x01 (maps to port0_dimm1, port1_dimm1) /// /// @param[out] o_repairs_exceeded 4-bit mask, where a bit set means the /// specified DIMM-select on the specified port /// had more bad bits than could be repaired. /// /// port0_dimm0 = 0x8 /// port0_dimm1 = 0x4 /// port1_dimm0 = 0x2 /// port1_dimm1 = 0x1 /// /// @param[in] i_strandby_flag Boolean if we are in standby at call time /// @param[out] o_repair_count Repair counts /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_restore_DRAM_repairs_asm( const fapi2::Target& i_target, uint8_t& o_repairs_applied, uint8_t& o_repairs_exceeded, const bool i_standby_flag, struct repair_count& o_repair_count); /// /// @brief This function takes converts from a Centaur DQ on a given port to a corresponding symbol index. /// @param[in] i_dq Centaur DQ from 0-71 /// @param[in] i_port port 0 or 1 /// @return Symbol index /// uint8_t mss_centaurDQ_to_symbol( const uint8_t i_dq, const uint8_t i_port ); /// /// @brief Identifies UE bits from trap data for data bits /// /// This function compares trapped actual UE data to an expected /// data pattern in order to identify the bits that contributed to /// a UE encountered during IPL memory diagnostics. /// /// @param[in] i_target MBA target /// @param[in] i_rank Rank containing the UE. /// @param[in] i_ue_trap UE trap number /// @param[in] i_pattern Pattern that triggered the UE. /// @param[out] io_bad_bits Map of bad bits (Centaur DQ format) 2 ports x 10 bytes /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_IPL_UE_isolation_data_bad_bits( const fapi2::Target& i_target, const uint8_t i_rank, const uint8_t i_ue_trap, const uint8_t i_pattern, uint8_t (&io_bad_bits)[2][10]); /// /// @brief Identifies UE bits from trap data for the 65th byte /// /// This function compares trapped actual UE data to an expected /// data pattern in order to identify the bits that contributed to /// a UE encountered during IPL memory diagnostics. /// /// @param[in] i_target MBA target /// @param[in] i_rank Rank containing the UE. /// @param[in] i_ue_trap UE trap number /// @param[in] i_pattern Pattern that triggered the UE. /// @param[in] i_dram_width DRAM width /// @param[out] io_bad_bits Map of bad bits (Centaur DQ format) 2 ports x 10 bytes /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_IPL_UE_isolation_65byte( const fapi2::Target& i_target, const uint8_t i_rank, const uint8_t i_ue_trap, const uint8_t i_pattern, const uint8_t i_dram_width, uint8_t (&io_bad_bits)[2][10]); /// /// @brief Identifies UE bits from trap data for the ecc byte /// /// This function compares trapped actual UE data to an expected /// data pattern in order to identify the bits that contributed to /// a UE encountered during IPL memory diagnostics. /// /// @param[in] i_target MBA target /// @param[in] i_rank Rank containing the UE. /// @param[in] i_ue_trap UE trap number /// @param[in] i_pattern Pattern that triggered the UE. /// @param[in] i_dram_width DRAM width /// @param[out] io_bad_bits Map of bad bits (Centaur DQ format) 2 ports x 10 bytes /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_IPL_UE_isolation_ecc( const fapi2::Target& i_target, const uint8_t i_rank, const uint8_t i_ue_trap, const uint8_t i_pattern, const uint8_t i_dram_width, uint8_t (&io_bad_bits)[2][10]); /// /// @brief Identifies UE bits from trap data /// /// This function compares trapped actual UE data to an expected /// data pattern in order to identify the bits that contributed to /// a UE encountered during IPL memory diagnostics. /// /// @param[in] i_target MBA target /// @param[in] i_rank Rank containing the UE. /// @param[out] o_bad_bits Map of bad bits (Centaur DQ format) 2 ports x 10 bytes /// @return Non-SUCCESS if an internal function fails, SUCCESS otherwise. /// fapi2::ReturnCode mss_IPL_UE_isolation( const fapi2::Target& i_target, const uint8_t i_rank, uint8_t (&o_bad_bits)[2][10]); /// /// @brief Update o_symbolMark and o_chipMark with mark_store values /// @param[in] i_target Centaur MBA target /// @param[in] i_rank Centaur input rank /// @param[out] o_symbolMark Symbol Mark /// @param[out] o_chipMark Chip Mark /// @param[out] mark_store Markstore array /// void mss_get_dummy_mark_store( const fapi2::Target& i_target, const uint8_t i_rank, uint8_t& o_symbolMark, uint8_t& o_chipMark, uint8_t mark_store[8][2]); /// /// @brief Set mark store with new symbol and chip mark values /// @param[in] i_target Centaur MBA target /// @param[in] i_rank Centaur input rank /// @param[out] i_symbolMark Symbol Mark /// @param[out] i_chipMarkChip Mark /// @param[out] mark_store Markstore array /// void mss_put_dummy_mark_store( const fapi2::Target& i_target, const uint8_t i_rank, const uint8_t i_symbolMark, const uint8_t i_chipMark, uint8_t mark_store[8][2]); /// /// @brief Pull steer mux values from steer array /// @param[in] i_target Centaur MBA target /// @param[in] i_rank Centuar input rank /// @param[in] i_mux_type Read or Write /// @param[out] o_dramSparePort0Symbol Port 0 spare val /// @param[out] o_dramSparePort1Symbol Port 1 spare val /// @param[out] o_eccSpareSymbol Ecc Spare val /// @param[out] steer[8][3] Steer mux array /// void mss_get_dummy_steer_mux( const fapi2::Target& i_target, const uint8_t i_rank, const mss_SteerMux::mux_type i_mux_type, uint8_t& o_dramSparePort0Symbol, uint8_t& o_dramSparePort1Symbol, uint8_t& o_eccSpareSymbol, uint8_t steer[8][3]); /// /// @brief Set steer mux value for a given rank and type /// @param[in] i_target Centaur MBA target /// @param[in] i_rank Centuar input rank /// @param[in] i_mux_type Read or Write /// @param[in] i_steer_type spare port 0, port 1 or ecc spare /// @param[in] i_symbol First symbol index of byte to steer /// @param[out] steer[8][3] Steer mux array /// void mss_put_dummy_steer_mux( const fapi2::Target& i_target, const uint8_t i_rank, const mss_SteerMux::mux_type i_mux_type, const uint8_t i_steer_type, const uint8_t i_symbol, uint8_t steer[8][3]); /// /// @brief Populate output vars with corresponding steer mux array values /// @param[in] i_target Centaur MBA target /// @param[in] i_rank Centuar input rank /// @param[out] o_dramSparePort0Symbol Spare port 0 symbol /// @param[out] o_dramSparePort1Symbol Spare port 1 symbol /// @param[out] o_eccSpareSymbol ECC spare symbol /// @param[out] steer[8][3] Steer mux array /// void mss_check_dummy_steering(const fapi2::Target& i_target, const uint8_t i_rank, uint8_t& o_dramSparePort0Symbol, uint8_t& o_dramSparePort1Symbol, uint8_t& o_eccSpareSymbol, uint8_t steer[8][3]); #endif/// _MSS_MAINT_CMDS_H */