Added source of Freescale's 'elftosb' tool

[karo-tx-uboot.git] / tools / elftosb / common / Operation.h

diff --git a/tools/elftosb/common/Operation.h b/tools/elftosb/common/Operation.h
new file mode 100644 (file)
index 0000000..2b184e3
--- /dev/null
+++ b/tools/elftosb/common/Operation.h
@@ -0,0 +1,168 @@
+/*
+ * File:       Operation.h
+ *
+ * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
+ * See included license file for license details.
+ */
+#if !defined(_Operation_h_)
+#define _Operation_h_
+
+#include "stdafx.h"
+#include <vector>
+#include "DataSource.h"
+#include "DataTarget.h"
+#include "smart_ptr.h"
+
+namespace elftosb
+{
+
+/*!
+ * \brief Abstract base class for all boot operations.
+ */
+class Operation
+{
+public:
+       Operation() {}
+       virtual ~Operation() {}
+};
+
+/*!
+ * \brief Load data into memory operation.
+ */
+class LoadOperation : public Operation
+{
+public:
+       LoadOperation() : Operation(), m_source(), m_target() {}
+       
+       void setSource(DataSource * source);
+       inline DataSource * getSource() { return m_source; }
+       
+       void setTarget(DataTarget * target);
+       inline DataTarget * getTarget() { return m_target; }
+       
+       inline void setDCDLoad(bool isDCD) { m_isDCDLoad = isDCD; }
+       inline bool isDCDLoad() const { return m_isDCDLoad; }
+       
+protected:
+       smart_ptr<DataSource> m_source;
+       smart_ptr<DataTarget> m_target;
+       bool m_isDCDLoad;
+};
+
+/*!
+ * \brief Operation to execute code at a certain address.
+ */
+class ExecuteOperation : public Operation
+{
+public:
+       enum execute_type_t
+       {
+               kJump,
+               kCall
+       };
+       
+public:
+       ExecuteOperation() : Operation(), m_target(), m_argument(0), m_type(kCall), m_isHAB(false) {}
+
+       inline void setTarget(DataTarget * target) { m_target = target; }
+       inline DataTarget * getTarget() { return m_target; }
+       
+       inline void setArgument(uint32_t arg) { m_argument = arg; }
+       inline uint32_t getArgument() { return m_argument; }
+       
+       inline void setExecuteType(execute_type_t type) { m_type = type; }
+       inline execute_type_t getExecuteType() { return m_type; }
+       
+       inline void setIsHAB(bool isHAB) { m_isHAB = isHAB; }
+       inline bool isHAB() const { return m_isHAB; }
+       
+protected:
+       smart_ptr<DataTarget> m_target;
+       uint32_t m_argument;
+       execute_type_t m_type;
+       bool m_isHAB;
+};
+
+/*!
+ * \brief Authenticate with HAB and execute the entry point.
+ */
+class HABExecuteOperation : public ExecuteOperation
+{
+public:
+       HABExecuteOperation() : ExecuteOperation() {}
+};
+
+/*!
+ * \brief Operation to switch boot modes.
+ */
+class BootModeOperation : public Operation
+{
+public:
+       BootModeOperation() : Operation() {}
+       
+       inline void setBootMode(uint32_t mode) { m_bootMode = mode; }
+       inline uint32_t getBootMode() const { return m_bootMode; }
+
+protected:
+       uint32_t m_bootMode;    //!< The new boot mode value.
+};
+
+/*!
+ * \brief Ordered sequence of operations.
+ *
+ * The operation objects owned by the sequence are \e not deleted when the
+ * sequence is destroyed. The owner of the sequence must manually delete
+ * the operation objects.
+ */
+class OperationSequence
+{
+public:
+       typedef std::vector<Operation*> operation_list_t;       //!< Type for a list of operation objects.
+       typedef operation_list_t::iterator iterator_t;  //!< Iterator over operations.
+       typedef operation_list_t::const_iterator const_iterator_t;      //!< Const iterator over operations.
+
+public:
+       //! \brief Default constructor.
+       OperationSequence() {}
+       
+       //! \brief Constructor. Makes a one-element sequence from \a soleElement.
+       OperationSequence(Operation * soleElement) { m_operations.push_back(soleElement); }
+       
+       //! \brief Destructor.
+       virtual ~OperationSequence();
+       
+       //! \name Iterators
+       //@{
+       inline iterator_t begin() { return m_operations.begin(); }
+       inline const_iterator_t begin() const { return m_operations.begin(); }
+       inline iterator_t end() { return m_operations.end(); }
+       inline const_iterator_t end() const { return m_operations.end(); }
+       //@}
+       
+       inline Operation * operator [] (unsigned index) const { return m_operations[index]; }
+       
+       //! \name Status
+       //@{
+       //! \brief Returns the number of operations in the sequence.
+       inline unsigned getCount() const { return m_operations.size(); }
+       //@}
+       
+       //! \name Operations
+       //@{
+       //! \brief Append one operation object to the sequence.
+       inline void append(Operation * op) { m_operations.push_back(op); }
+       
+       //! \brief Append the contents of \a other onto this sequence.
+       void append(const OperationSequence * other);
+       
+       //! \brief Appends \a other onto this sequence.
+       OperationSequence & operator += (const OperationSequence * other) { append(other); return *this; }
+       //@}
+
+protected:
+       operation_list_t m_operations;  //!< The list of operations.
+};
+
+}; // namespace elftosb
+
+#endif // _Operation_h_