////////////////////////////////////////////////////////////////////////////////
//
// The University of Illinois/NCSA
// Open Source License (NCSA)
// 
// Copyright (c) 2014-2020, Advanced Micro Devices, Inc. All rights reserved.
// 
// Developed by:
// 
//                 AMD Research and AMD HSA Software Development
// 
//                 Advanced Micro Devices, Inc.
// 
//                 www.amd.com
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal with the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
// 
//  - Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimers.
//  - Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimers in
//    the documentation and/or other materials provided with the distribution.
//  - Neither the names of Advanced Micro Devices, Inc,
//    nor the names of its contributors may be used to endorse or promote
//    products derived from this Software without specific prior written
//    permission.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS WITH THE SOFTWARE.
//
////////////////////////////////////////////////////////////////////////////////

#ifndef HSA_RUNTIME_CORE_INC_HSA_INTERNAL_H
#define HSA_RUNTIME_CORE_INC_HSA_INTERNAL_H

#include "inc/hsa.h"

namespace rocr {
namespace HSA {

  // Define core namespace interfaces - copy of function declarations in hsa.h
  hsa_status_t hsa_init();
  hsa_status_t hsa_shut_down();
  hsa_status_t
    hsa_system_get_info(hsa_system_info_t attribute, void *value);
  hsa_status_t hsa_extension_get_name(uint16_t extension, const char** name);
  hsa_status_t hsa_system_extension_supported(uint16_t extension, uint16_t version_major,
                                                      uint16_t version_minor, bool* result);
  hsa_status_t hsa_system_major_extension_supported(uint16_t extension,
                                                            uint16_t version_major,
                                                            uint16_t* version_minor, bool* result);
  hsa_status_t
    hsa_system_get_extension_table(uint16_t extension, uint16_t version_major,
    uint16_t version_minor, void *table);
  hsa_status_t hsa_system_get_major_extension_table(uint16_t extension,
                                                            uint16_t version_major,
                                                            size_t table_length, void* table);
  hsa_status_t
    hsa_iterate_agents(hsa_status_t (*callback)(hsa_agent_t agent, void *data),
    void *data);
  hsa_status_t hsa_agent_get_info(hsa_agent_t agent,
    hsa_agent_info_t attribute,
    void *value);
  hsa_status_t hsa_agent_get_exception_policies(hsa_agent_t agent,
    hsa_profile_t profile,
    uint16_t *mask);
  hsa_status_t hsa_cache_get_info(hsa_cache_t cache, hsa_cache_info_t attribute,
                                          void* value);
  hsa_status_t hsa_agent_iterate_caches(
      hsa_agent_t agent, hsa_status_t (*callback)(hsa_cache_t cache, void* data), void* value);
  hsa_status_t
    hsa_agent_extension_supported(uint16_t extension, hsa_agent_t agent,
    uint16_t version_major,
    uint16_t version_minor, bool *result);
  hsa_status_t hsa_agent_major_extension_supported(uint16_t extension, hsa_agent_t agent,
                                                           uint16_t version_major,
                                                           uint16_t* version_minor, bool* result);
  hsa_status_t
    hsa_queue_create(hsa_agent_t agent, uint32_t size, hsa_queue_type32_t type,
    void (*callback)(hsa_status_t status, hsa_queue_t *source,
    void *data),
    void *data, uint32_t private_segment_size,
    uint32_t group_segment_size, hsa_queue_t **queue);
  hsa_status_t
    hsa_soft_queue_create(hsa_region_t region, uint32_t size,
    hsa_queue_type32_t type, uint32_t features,
    hsa_signal_t completion_signal, hsa_queue_t **queue);
  hsa_status_t hsa_queue_destroy(hsa_queue_t *queue);
  hsa_status_t hsa_queue_inactivate(hsa_queue_t *queue);
  uint64_t hsa_queue_load_read_index_scacquire(const hsa_queue_t* queue);
  uint64_t hsa_queue_load_read_index_relaxed(const hsa_queue_t *queue);
  uint64_t hsa_queue_load_write_index_scacquire(const hsa_queue_t* queue);
  uint64_t hsa_queue_load_write_index_relaxed(const hsa_queue_t *queue);
  void hsa_queue_store_write_index_relaxed(const hsa_queue_t *queue,
    uint64_t value);
  void hsa_queue_store_write_index_screlease(const hsa_queue_t* queue, uint64_t value);
  uint64_t hsa_queue_cas_write_index_scacq_screl(const hsa_queue_t* queue,
                                                         uint64_t expected, uint64_t value);
  uint64_t hsa_queue_cas_write_index_scacquire(const hsa_queue_t* queue, uint64_t expected,
                                                       uint64_t value);
  uint64_t hsa_queue_cas_write_index_relaxed(const hsa_queue_t *queue,
    uint64_t expected,
    uint64_t value);
  uint64_t hsa_queue_cas_write_index_screlease(const hsa_queue_t* queue, uint64_t expected,
                                                       uint64_t value);
  uint64_t hsa_queue_add_write_index_scacq_screl(const hsa_queue_t* queue, uint64_t value);
  uint64_t hsa_queue_add_write_index_scacquire(const hsa_queue_t* queue, uint64_t value);
  uint64_t
    hsa_queue_add_write_index_relaxed(const hsa_queue_t *queue, uint64_t value);
  uint64_t hsa_queue_add_write_index_screlease(const hsa_queue_t* queue, uint64_t value);
  void hsa_queue_store_read_index_relaxed(const hsa_queue_t *queue,
    uint64_t value);
  void hsa_queue_store_read_index_screlease(const hsa_queue_t* queue, uint64_t value);
  hsa_status_t hsa_agent_iterate_regions(
    hsa_agent_t agent,
    hsa_status_t (*callback)(hsa_region_t region, void *data), void *data);
  hsa_status_t hsa_region_get_info(hsa_region_t region,
    hsa_region_info_t attribute,
    void *value);
  hsa_status_t hsa_memory_register(void *address, size_t size);
  hsa_status_t hsa_memory_deregister(void *address, size_t size);
  hsa_status_t
    hsa_memory_allocate(hsa_region_t region, size_t size, void **ptr);
  hsa_status_t hsa_memory_free(void *ptr);
  hsa_status_t hsa_memory_copy(void *dst, const void *src, size_t size);
  hsa_status_t hsa_memory_assign_agent(void *ptr, hsa_agent_t agent,
    hsa_access_permission_t access);
  hsa_status_t
    hsa_signal_create(hsa_signal_value_t initial_value, uint32_t num_consumers,
    const hsa_agent_t *consumers, hsa_signal_t *signal);
  hsa_status_t hsa_signal_destroy(hsa_signal_t signal);
  hsa_signal_value_t hsa_signal_load_relaxed(hsa_signal_t signal);
  hsa_signal_value_t hsa_signal_load_scacquire(hsa_signal_t signal);
  void
    hsa_signal_store_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_store_screlease(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_silent_store_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_silent_store_screlease(hsa_signal_t signal, hsa_signal_value_t value);
  hsa_signal_value_t
    hsa_signal_wait_relaxed(hsa_signal_t signal,
    hsa_signal_condition_t condition,
    hsa_signal_value_t compare_value,
    uint64_t timeout_hint,
    hsa_wait_state_t wait_expectancy_hint);
  hsa_signal_value_t hsa_signal_wait_scacquire(hsa_signal_t signal,
                                                       hsa_signal_condition_t condition,
                                                       hsa_signal_value_t compare_value,
                                                       uint64_t timeout_hint,
                                                       hsa_wait_state_t wait_expectancy_hint);
  hsa_status_t hsa_signal_group_create(uint32_t num_signals, const hsa_signal_t* signals,
                                               uint32_t num_consumers, const hsa_agent_t* consumers,
                                               hsa_signal_group_t* signal_group);
  hsa_status_t hsa_signal_group_destroy(hsa_signal_group_t signal_group);
  hsa_status_t hsa_signal_group_wait_any_scacquire(hsa_signal_group_t signal_group,
                                                           const hsa_signal_condition_t* conditions,
                                                           const hsa_signal_value_t* compare_values,
                                                           hsa_wait_state_t wait_state_hint,
                                                           hsa_signal_t* signal,
                                                           hsa_signal_value_t* value);
  hsa_status_t hsa_signal_group_wait_any_relaxed(hsa_signal_group_t signal_group,
                                                         const hsa_signal_condition_t* conditions,
                                                         const hsa_signal_value_t* compare_values,
                                                         hsa_wait_state_t wait_state_hint,
                                                         hsa_signal_t* signal,
                                                         hsa_signal_value_t* value);
  void
    hsa_signal_and_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_and_scacquire(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_and_screlease(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_and_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value);
  void
    hsa_signal_or_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_or_scacquire(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_or_screlease(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_or_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value);
  void
    hsa_signal_xor_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_xor_scacquire(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_xor_screlease(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_xor_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value);
  void
    hsa_signal_add_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_add_scacquire(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_add_screlease(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_add_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value);
  void
    hsa_signal_subtract_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_subtract_scacquire(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_subtract_screlease(hsa_signal_t signal, hsa_signal_value_t value);
  void hsa_signal_subtract_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value);
  hsa_signal_value_t
    hsa_signal_exchange_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
  hsa_signal_value_t hsa_signal_exchange_scacquire(hsa_signal_t signal,
                                                           hsa_signal_value_t value);
  hsa_signal_value_t hsa_signal_exchange_screlease(hsa_signal_t signal,
                                                           hsa_signal_value_t value);
  hsa_signal_value_t hsa_signal_exchange_scacq_screl(hsa_signal_t signal,
                                                             hsa_signal_value_t value);
  hsa_signal_value_t hsa_signal_cas_relaxed(hsa_signal_t signal,
    hsa_signal_value_t expected,
    hsa_signal_value_t value);
  hsa_signal_value_t hsa_signal_cas_scacquire(hsa_signal_t signal,
                                                      hsa_signal_value_t expected,
                                                      hsa_signal_value_t value);
  hsa_signal_value_t hsa_signal_cas_screlease(hsa_signal_t signal,
                                                      hsa_signal_value_t expected,
                                                      hsa_signal_value_t value);
  hsa_signal_value_t hsa_signal_cas_scacq_screl(hsa_signal_t signal,
                                                        hsa_signal_value_t expected,
                                                        hsa_signal_value_t value);

  //===--- Instruction Set Architecture -----------------------------------===//

  hsa_status_t hsa_isa_from_name(
      const char *name,
      hsa_isa_t *isa);
  hsa_status_t hsa_agent_iterate_isas(
      hsa_agent_t agent,
      hsa_status_t (*callback)(hsa_isa_t isa,
                               void *data),
      void *data);
  /* deprecated */ hsa_status_t hsa_isa_get_info(
      hsa_isa_t isa,
      hsa_isa_info_t attribute,
      uint32_t index,
      void *value);
  hsa_status_t hsa_isa_get_info_alt(
      hsa_isa_t isa,
      hsa_isa_info_t attribute,
      void *value);
  hsa_status_t hsa_isa_get_exception_policies(
      hsa_isa_t isa,
      hsa_profile_t profile,
      uint16_t *mask);
  hsa_status_t hsa_isa_get_round_method(
      hsa_isa_t isa,
      hsa_fp_type_t fp_type,
      hsa_flush_mode_t flush_mode,
      hsa_round_method_t *round_method);
  hsa_status_t hsa_wavefront_get_info(
      hsa_wavefront_t wavefront,
      hsa_wavefront_info_t attribute,
      void *value);
  hsa_status_t hsa_isa_iterate_wavefronts(
      hsa_isa_t isa,
      hsa_status_t (*callback)(hsa_wavefront_t wavefront,
                               void *data),
      void *data);
  /* deprecated */ hsa_status_t hsa_isa_compatible(
      hsa_isa_t code_object_isa,
      hsa_isa_t agent_isa,
      bool *result);

  //===--- Code Objects (deprecated) --------------------------------------===//

  /* deprecated */ hsa_status_t hsa_code_object_serialize(
      hsa_code_object_t code_object,
      hsa_status_t (*alloc_callback)(size_t size,
                                     hsa_callback_data_t data,
                                     void **address),
      hsa_callback_data_t callback_data,
      const char *options,
      void **serialized_code_object,
      size_t *serialized_code_object_size);
  /* deprecated */ hsa_status_t hsa_code_object_deserialize(
      void *serialized_code_object,
      size_t serialized_code_object_size,
      const char *options,
      hsa_code_object_t *code_object);
  /* deprecated */ hsa_status_t hsa_code_object_destroy(
      hsa_code_object_t code_object);
  /* deprecated */ hsa_status_t hsa_code_object_get_info(
      hsa_code_object_t code_object,
      hsa_code_object_info_t attribute,
      void *value);
  /* deprecated */ hsa_status_t hsa_code_object_get_symbol(
      hsa_code_object_t code_object,
      const char *symbol_name,
      hsa_code_symbol_t *symbol);
  /* deprecated */ hsa_status_t hsa_code_object_get_symbol_from_name(
      hsa_code_object_t code_object,
      const char *module_name,
      const char *symbol_name,
      hsa_code_symbol_t *symbol);
  /* deprecated */ hsa_status_t hsa_code_symbol_get_info(
      hsa_code_symbol_t code_symbol,
      hsa_code_symbol_info_t attribute,
      void *value);
  /* deprecated */ hsa_status_t hsa_code_object_iterate_symbols(
      hsa_code_object_t code_object,
      hsa_status_t (*callback)(hsa_code_object_t code_object,
                               hsa_code_symbol_t symbol,
                               void *data),
      void *data);

  //===--- Executable -----------------------------------------------------===//

  hsa_status_t hsa_code_object_reader_create_from_file(
      hsa_file_t file,
      hsa_code_object_reader_t *code_object_reader);
  hsa_status_t hsa_code_object_reader_create_from_memory(
      const void *code_object,
      size_t size,
      hsa_code_object_reader_t *code_object_reader);
  hsa_status_t hsa_code_object_reader_destroy(
      hsa_code_object_reader_t code_object_reader);
  /* deprecated */ hsa_status_t hsa_executable_create(
      hsa_profile_t profile,
      hsa_executable_state_t executable_state,
      const char *options,
      hsa_executable_t *executable);
  hsa_status_t hsa_executable_create_alt(
      hsa_profile_t profile,
      hsa_default_float_rounding_mode_t default_float_rounding_mode,
      const char *options,
      hsa_executable_t *executable);
  hsa_status_t hsa_executable_destroy(
      hsa_executable_t executable);
  /* deprecated */ hsa_status_t hsa_executable_load_code_object(
      hsa_executable_t executable,
      hsa_agent_t agent,
      hsa_code_object_t code_object,
      const char *options);
  hsa_status_t hsa_executable_load_program_code_object(
      hsa_executable_t executable,
      hsa_code_object_reader_t code_object_reader,
      const char *options,
      hsa_loaded_code_object_t *loaded_code_object);
  hsa_status_t hsa_executable_load_agent_code_object(
      hsa_executable_t executable,
      hsa_agent_t agent,
      hsa_code_object_reader_t code_object_reader,
      const char *options,
      hsa_loaded_code_object_t *loaded_code_object);
  hsa_status_t hsa_executable_freeze(
      hsa_executable_t executable,
      const char *options);
  hsa_status_t hsa_executable_get_info(
      hsa_executable_t executable,
      hsa_executable_info_t attribute,
      void *value);
  hsa_status_t hsa_executable_global_variable_define(
      hsa_executable_t executable,
      const char *variable_name,
      void *address);
  hsa_status_t hsa_executable_agent_global_variable_define(
      hsa_executable_t executable,
      hsa_agent_t agent,
      const char *variable_name,
      void *address);
  hsa_status_t hsa_executable_readonly_variable_define(
      hsa_executable_t executable,
      hsa_agent_t agent,
      const char *variable_name,
      void *address);
  hsa_status_t hsa_executable_validate(
      hsa_executable_t executable,
      uint32_t *result);
  hsa_status_t hsa_executable_validate_alt(
      hsa_executable_t executable,
      const char *options,
      uint32_t *result);
  /* deprecated */ hsa_status_t hsa_executable_get_symbol(
      hsa_executable_t executable,
      const char *module_name,
      const char *symbol_name,
      hsa_agent_t agent,
      int32_t call_convention,
      hsa_executable_symbol_t *symbol);
  hsa_status_t hsa_executable_get_symbol_by_name(
      hsa_executable_t executable,
      const char *symbol_name,
      const hsa_agent_t *agent,
      hsa_executable_symbol_t *symbol);
  hsa_status_t hsa_executable_symbol_get_info(
      hsa_executable_symbol_t executable_symbol,
      hsa_executable_symbol_info_t attribute,
      void *value);
  /* deprecated */ hsa_status_t hsa_executable_iterate_symbols(
      hsa_executable_t executable,
      hsa_status_t (*callback)(hsa_executable_t executable,
                               hsa_executable_symbol_t symbol,
                               void *data),
      void *data);
  hsa_status_t hsa_executable_iterate_agent_symbols(
      hsa_executable_t executable,
      hsa_agent_t agent,
      hsa_status_t (*callback)(hsa_executable_t exec,
                               hsa_agent_t agent,
                               hsa_executable_symbol_t symbol,
                               void *data),
      void *data);
  hsa_status_t hsa_executable_iterate_program_symbols(
      hsa_executable_t executable,
      hsa_status_t (*callback)(hsa_executable_t exec,
                               hsa_executable_symbol_t symbol,
                               void *data),
      void *data);

  //===--- Runtime Notifications ------------------------------------------===//

  hsa_status_t hsa_status_string(
      hsa_status_t status,
      const char **status_string);

}   //  namespace HSA
}   //  namespace rocr

#ifdef BUILDING_HSA_CORE_RUNTIME
//This using declaration is deliberate!
//We want unqualified name resolution to fail when building the runtime.  This is a guard against accidental use of the intercept layer in the runtime.
//using namespace rocr::HSA;
#endif

#endif
