1 /* 2 * File: Operation.h 3 * 4 * Copyright (c) Freescale Semiconductor, Inc. All rights reserved. 5 * See included license file for license details. 6 */ 7 #if !defined(_Operation_h_) 8 #define _Operation_h_ 9 10 #include "stdafx.h" 11 #include <vector> 12 #include "DataSource.h" 13 #include "DataTarget.h" 14 #include "smart_ptr.h" 15 16 namespace elftosb 17 { 18 19 /*! 20 * \brief Abstract base class for all boot operations. 21 */ 22 class Operation 23 { 24 public: Operation()25 Operation() {} ~Operation()26 virtual ~Operation() {} 27 }; 28 29 /*! 30 * \brief Load data into memory operation. 31 */ 32 class LoadOperation : public Operation 33 { 34 public: LoadOperation()35 LoadOperation() : Operation(), m_source(), m_target() {} 36 37 void setSource(DataSource * source); getSource()38 inline DataSource * getSource() { return m_source; } 39 40 void setTarget(DataTarget * target); getTarget()41 inline DataTarget * getTarget() { return m_target; } 42 setDCDLoad(bool isDCD)43 inline void setDCDLoad(bool isDCD) { m_isDCDLoad = isDCD; } isDCDLoad()44 inline bool isDCDLoad() const { return m_isDCDLoad; } 45 46 protected: 47 smart_ptr<DataSource> m_source; 48 smart_ptr<DataTarget> m_target; 49 bool m_isDCDLoad; 50 }; 51 52 /*! 53 * \brief Operation to execute code at a certain address. 54 */ 55 class ExecuteOperation : public Operation 56 { 57 public: 58 enum execute_type_t 59 { 60 kJump, 61 kCall 62 }; 63 64 public: ExecuteOperation()65 ExecuteOperation() : Operation(), m_target(), m_argument(0), m_type(kCall), m_isHAB(false) {} 66 setTarget(DataTarget * target)67 inline void setTarget(DataTarget * target) { m_target = target; } getTarget()68 inline DataTarget * getTarget() { return m_target; } 69 setArgument(uint32_t arg)70 inline void setArgument(uint32_t arg) { m_argument = arg; } getArgument()71 inline uint32_t getArgument() { return m_argument; } 72 setExecuteType(execute_type_t type)73 inline void setExecuteType(execute_type_t type) { m_type = type; } getExecuteType()74 inline execute_type_t getExecuteType() { return m_type; } 75 setIsHAB(bool isHAB)76 inline void setIsHAB(bool isHAB) { m_isHAB = isHAB; } isHAB()77 inline bool isHAB() const { return m_isHAB; } 78 79 protected: 80 smart_ptr<DataTarget> m_target; 81 uint32_t m_argument; 82 execute_type_t m_type; 83 bool m_isHAB; 84 }; 85 86 /*! 87 * \brief Authenticate with HAB and execute the entry point. 88 */ 89 class HABExecuteOperation : public ExecuteOperation 90 { 91 public: HABExecuteOperation()92 HABExecuteOperation() : ExecuteOperation() {} 93 }; 94 95 /*! 96 * \brief Operation to switch boot modes. 97 */ 98 class BootModeOperation : public Operation 99 { 100 public: BootModeOperation()101 BootModeOperation() : Operation() {} 102 setBootMode(uint32_t mode)103 inline void setBootMode(uint32_t mode) { m_bootMode = mode; } getBootMode()104 inline uint32_t getBootMode() const { return m_bootMode; } 105 106 protected: 107 uint32_t m_bootMode; //!< The new boot mode value. 108 }; 109 110 /*! 111 * \brief Ordered sequence of operations. 112 * 113 * The operation objects owned by the sequence are \e not deleted when the 114 * sequence is destroyed. The owner of the sequence must manually delete 115 * the operation objects. 116 */ 117 class OperationSequence 118 { 119 public: 120 typedef std::vector<Operation*> operation_list_t; //!< Type for a list of operation objects. 121 typedef operation_list_t::iterator iterator_t; //!< Iterator over operations. 122 typedef operation_list_t::const_iterator const_iterator_t; //!< Const iterator over operations. 123 124 public: 125 //! \brief Default constructor. OperationSequence()126 OperationSequence() {} 127 128 //! \brief Constructor. Makes a one-element sequence from \a soleElement. OperationSequence(Operation * soleElement)129 OperationSequence(Operation * soleElement) { m_operations.push_back(soleElement); } 130 131 //! \brief Destructor. 132 virtual ~OperationSequence(); 133 134 //! \name Iterators 135 //@{ begin()136 inline iterator_t begin() { return m_operations.begin(); } begin()137 inline const_iterator_t begin() const { return m_operations.begin(); } end()138 inline iterator_t end() { return m_operations.end(); } end()139 inline const_iterator_t end() const { return m_operations.end(); } 140 //@} 141 142 inline Operation * operator [] (unsigned index) const { return m_operations[index]; } 143 144 //! \name Status 145 //@{ 146 //! \brief Returns the number of operations in the sequence. getCount()147 inline unsigned getCount() const { return m_operations.size(); } 148 //@} 149 150 //! \name Operations 151 //@{ 152 //! \brief Append one operation object to the sequence. append(Operation * op)153 inline void append(Operation * op) { m_operations.push_back(op); } 154 155 //! \brief Append the contents of \a other onto this sequence. 156 void append(const OperationSequence * other); 157 158 //! \brief Appends \a other onto this sequence. 159 OperationSequence & operator += (const OperationSequence * other) { append(other); return *this; } 160 //@} 161 162 protected: 163 operation_list_t m_operations; //!< The list of operations. 164 }; 165 166 }; // namespace elftosb 167 168 #endif // _Operation_h_ 169