/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: src/include/bootloader/bootloader.H $                         */
/*                                                                        */
/* OpenPOWER HostBoot Project                                             */
/*                                                                        */
/* Contributors Listed Below - COPYRIGHT 2015,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                                                     */

#ifndef __BOOT_LOADER_H
#define __BOOT_LOADER_H

/**
 * @file    bootloader.H
 *
 *  TaskInfo structs for each task that will run.
 */

#include <builtins.h>
#include <pnor_const.H>
#include <pnor_utils.H>
#include <common/ffs_hb.H>
#include <kernel/terminate.H>
#include <kernel/hbterminatetypes.H>
#include <bootloader/bootloaderif.H>

extern "C" void task_end_stub();
extern "C" void enterHBB(uint64_t i_hbb_hrmor, uint64_t i_hbb_offset);

#define assert(expr) \
{\
    if (unlikely(!(expr)))\
    {\
        task_end_stub();\
    }\
}

#define printk(format...)

namespace Bootloader{
    /**
     * @brief Get the current HBBL HRMOR
     *
     * Used to know where the bootloader is running
     */
    ALWAYS_INLINE
      inline uint64_t getHRMOR()
    {
        register uint64_t hrmor = 0;
        asm volatile("mfspr %0, 313" : "=r" (hrmor));
        return hrmor;
    }


    /**
     * @brief Pointer to bootloader scratch space
     *
     * Pointer to location in main storage which bootloader uses as
     * scratch space
     */
    extern uint8_t *g_blScratchSpace;

    /** @enum MMIOLoadStoreSizes
     *  @brief List of MMIO Load and Store Sizes.
     *
     *  These are the sizes (in bytes) for the load and store commands used
     *  to read and write data when handling an MMIO.
     */
    enum MMIOLoadStoreSizes
    {
        /** BYTESIZE */
        BYTESIZE = 1,
        /** WORDSIZE */
        WORDSIZE = 4,
        /** DBLWORDSIZE */
        DBLWORDSIZE = 8
    };

    /**
     * @brief Handle MMIO to copy code/data from one location to another
     *
     * @param[in] i_srcAddr     MMIO address to copy from
     * @param[in] i_destAddr    address to copy to
     * @param[in] i_size        number of bytes to copy
     * @param[in] i_ld_st_size  size of data in ld and st instructions
     *        BYTESIZE     => copy 1 byte at a time
     *        WORDSIZE     => copy 4 bytes at a time
     *        DBLWORDSIZE  => copy 8 bytes at a time
     */
    extern void handleMMIO(uint64_t i_srcAddr,
                           uint64_t i_destAddr,
                           uint32_t i_size,
                           MMIOLoadStoreSizes i_ld_st_size);

    /**
     * @brief Handle setting up to terminate Bootloader
     *
     * @param[in] i_moduleID    ID for module where terminate is occurring
     * @param[in] i_reasoncode  Reason code for why terminating
     * @param[in] i_word7       Data for SRC word 7 / @userdata2[0:31]
     *                             (optional, default is 0)
     * @param[in] i_word8       Data for SRC word 8 / @userdata2[32:63]
     *                             (optional, default is 0)
     * @param[in] i_executeTI   Flag for calling terminateExecuteTI
     *                             (optional, default is true)
     * @param[in] i_failAddr    Address associated with termination
     *                             (SRC word 6 / @userdata1[32:63],
     *                              optional, default is 0)
     */
    inline void bl_terminate(uint8_t  i_moduleID,
                             uint16_t i_reasoncode,
                             uint32_t i_word7 = 0,
                             uint32_t i_word8 = 0,
                             bool     i_executeTI = true,
                             uint64_t i_failAddr = 0)
    {
        termWriteSRC(TI_BOOTLOADER,
                     i_reasoncode,
                     i_failAddr);

        termModifySRC(i_moduleID,
                      i_word7,
                      i_word8);

        if(i_executeTI)
        {
            terminateExecuteTI();
        }
    }

    /** @enum HbbLengths
     *  @brief List of HBB lengths.
     *
     *  These are the lengths of the Hostboot Base data or instructions
     *  with and without ECC.
     */
    enum HbbLengths
    {
        /** LENGTH_WO_ECC */
        LENGTH_WO_ECC = 8,
        /** LENGTH_W_ECC */
        LENGTH_W_ECC = 9
    };

    /**
     *  @brief List of addresses where HBB and HBBL code is stored.
     *
     *  These specify locations where the Hostboot Bootloader code is
     *  stored and where it stores the Hostboot Base code.  The HBB code
     *  is copied to various locations as the HBBL works with it.  Then
     *  HBB is copied to its running location and its execution is started.
     */

    /** HW Keys hash is placed in the last 64 bytes of the HBBL */
#define HW_KEYS_HASH_ADDR (getHRMOR() + HBBL_EXCEPTION_VECTOR_SIZE \
                           + MAX_HBBL_SIZE - 64)
    /** Location of working copy of HBB with ECC */
#define HBB_ECC_WORKING_ADDR    (getHRMOR() + ( 1*MEGABYTE))

    /** Location of working copy of HBB without ECC */
#define HBB_WORKING_ADDR        (getHRMOR() - ( 1*MEGABYTE))

    /** Location of HBBL scratch space */
#define HBBL_SCRATCH_SPACE_ADDR (getHRMOR() + (64*KILOBYTE))

    /** Location of running copy of HBB */
#define HBB_HRMOR               (getHRMOR() - ( 2*MEGABYTE))
#define HBB_RUNNING_ADDR        (getHRMOR() - ( 2*MEGABYTE))

    enum
    {
        /** Offset for starting running copy of HBB */
        HBB_RUNNING_OFFSET = 0,
        /** Mask to indicate HRMOR should be ignored for the address */
        IGNORE_HRMOR_MASK = 0x8000000000000000ul
    };
} // end namespace Bootloader

#endif