// Copyright(c) 2018-2020, Intel Corporation
//
// Redistribution  and  use  in source  and  binary  forms,  with  or  without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of  source code  must retain the  above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
// * Neither the name  of Intel Corporation  nor the names of its contributors
//   may be used to  endorse or promote  products derived  from this  software
//   without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE
// IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT OWNER  OR CONTRIBUTORS BE
// LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR
// CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT LIMITED  TO,  PROCUREMENT  OF
// SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA, OR PROFITS;  OR BUSINESS
// INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY  OF LIABILITY,  WHETHER IN
// CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif // HAVE_CONFIG_H

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif // _GNU_SOURCE

#include <stdio.h>

#include <opae/properties.h>
#include <opae/types_enum.h>

#include "pluginmgr.h"
#include "opae_int.h"
#include "props.h"


opae_wrapped_token *
opae_allocate_wrapped_token(fpga_token token,
			    const opae_api_adapter_table *adapter)
{
	opae_wrapped_token *wtok =
		(opae_wrapped_token *)malloc(sizeof(opae_wrapped_token));

	if (wtok) {
		wtok->magic = OPAE_WRAPPED_TOKEN_MAGIC;
		wtok->opae_token = token;
		wtok->adapter_table = (opae_api_adapter_table *)adapter;
	}

	return wtok;
}

opae_wrapped_handle *
opae_allocate_wrapped_handle(opae_wrapped_token *wt, fpga_handle opae_handle,
			     opae_api_adapter_table *adapter)
{
	opae_wrapped_handle *whan =
		(opae_wrapped_handle *)malloc(sizeof(opae_wrapped_handle));

	if (whan) {
		whan->magic = OPAE_WRAPPED_HANDLE_MAGIC;
		whan->wrapped_token = wt;
		whan->opae_handle = opae_handle;
		whan->adapter_table = adapter;
	}

	return whan;
}

opae_wrapped_event_handle *
opae_allocate_wrapped_event_handle(fpga_event_handle opae_event_handle,
				   opae_api_adapter_table *adapter)
{
	pthread_mutexattr_t mattr;
	opae_wrapped_event_handle *wevent = (opae_wrapped_event_handle *)malloc(
		sizeof(opae_wrapped_event_handle));

	if (wevent) {
		if (pthread_mutexattr_init(&mattr)) {
			OPAE_ERR("pthread_mutexattr_init() failed");
			goto out_free;
		}
		if (pthread_mutexattr_settype(&mattr,
					      PTHREAD_MUTEX_RECURSIVE)) {
			OPAE_ERR("pthread_mutexattr_settype() failed");
			goto out_destroy;
		}
		if (pthread_mutex_init(&wevent->lock, &mattr)) {
			OPAE_ERR("pthread_mutex_init() failed");
			goto out_destroy;
		}

		pthread_mutexattr_destroy(&mattr);

		wevent->magic = OPAE_WRAPPED_EVENT_HANDLE_MAGIC;
		wevent->flags = 0;
		wevent->opae_event_handle = opae_event_handle;
		wevent->adapter_table = adapter;
	}

	return wevent;

out_destroy:
	pthread_mutexattr_destroy(&mattr);
out_free:
	free(wevent);
	return NULL;
}

opae_wrapped_object *
opae_allocate_wrapped_object(fpga_object opae_object,
			     opae_api_adapter_table *adapter)
{
	opae_wrapped_object *wobj =
		(opae_wrapped_object *)malloc(sizeof(opae_wrapped_object));

	if (wobj) {
		wobj->magic = OPAE_WRAPPED_OBJECT_MAGIC;
		wobj->opae_object = opae_object;
		wobj->adapter_table = adapter;
	}

	return wobj;
}

fpga_result __OPAE_API__ fpgaInitialize(const char *config_file)
{
	return opae_plugin_mgr_initialize(config_file) ? FPGA_EXCEPTION
						       : FPGA_OK;
}

fpga_result __OPAE_API__ fpgaFinalize(void)
{
	return opae_plugin_mgr_finalize_all() ? FPGA_EXCEPTION
					      : FPGA_OK;
}

fpga_result __OPAE_API__ fpgaOpen(fpga_token token, fpga_handle *handle,
				  int flags)
{
	fpga_result res;
	fpga_result cres = FPGA_OK;
	opae_wrapped_token *wrapped_token;
	fpga_handle opae_handle = NULL;
	opae_wrapped_handle *wrapped_handle;

	wrapped_token = opae_validate_wrapped_token(token);

	ASSERT_NOT_NULL(wrapped_token);
	ASSERT_NOT_NULL(handle);
	ASSERT_NOT_NULL_RESULT(wrapped_token->adapter_table->fpgaOpen,
			       FPGA_NOT_SUPPORTED);
	ASSERT_NOT_NULL_RESULT(wrapped_token->adapter_table->fpgaClose,
			       FPGA_NOT_SUPPORTED);

	res = wrapped_token->adapter_table->fpgaOpen(wrapped_token->opae_token,
						     &opae_handle, flags);

	ASSERT_RESULT(res);

	wrapped_handle = opae_allocate_wrapped_handle(
		wrapped_token, opae_handle, wrapped_token->adapter_table);

	if (!wrapped_handle) {
		OPAE_ERR("malloc failed");
		res = FPGA_NO_MEMORY;
		cres = wrapped_token->adapter_table->fpgaClose(opae_handle);
	}

	*handle = wrapped_handle;

	return res != FPGA_OK ? res : cres;
}

fpga_result __OPAE_API__ fpgaClose(fpga_handle handle)
{
	fpga_result res;
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaClose,
			       FPGA_NOT_SUPPORTED);

	res = wrapped_handle->adapter_table->fpgaClose(
		wrapped_handle->opae_handle);

	opae_destroy_wrapped_handle(wrapped_handle);

	return res;
}

fpga_result __OPAE_API__ fpgaReset(fpga_handle handle)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaReset,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaReset(
		wrapped_handle->opae_handle);
}

fpga_result __OPAE_API__ fpgaGetPropertiesFromHandle(fpga_handle handle,
					fpga_properties *prop)
{
	fpga_result res;
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);
	struct _fpga_properties *p;
	int err;

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(prop);
	ASSERT_NOT_NULL_RESULT(
		wrapped_handle->adapter_table->fpgaGetPropertiesFromHandle,
		FPGA_NOT_SUPPORTED);

	res = wrapped_handle->adapter_table->fpgaGetPropertiesFromHandle(
		wrapped_handle->opae_handle, prop);

	ASSERT_RESULT(res);

	// If the output properties has a parent token set,
	// then it will be a raw token. We need to wrap it.

	p = opae_validate_and_lock_properties(*prop);

	ASSERT_NOT_NULL(p);

	if (FIELD_VALID(p, FPGA_PROPERTY_PARENT)) {
		opae_wrapped_token *wrapped_parent =
			opae_allocate_wrapped_token(
				p->parent, wrapped_handle->adapter_table);

		if (wrapped_parent) {
			p->parent = wrapped_parent;
			p->flags |= OPAE_PROPERTIES_FLAG_PARENT_ALLOC;
		} else {
			OPAE_ERR("malloc failed");
			res = FPGA_NO_MEMORY;
		}
	}

	opae_mutex_unlock(err, &p->lock);

	return res;
}

fpga_result __OPAE_API__ fpgaGetProperties(fpga_token token,
					   fpga_properties *prop)
{
	fpga_result res = FPGA_OK;
	opae_wrapped_token *wrapped_token = opae_validate_wrapped_token(token);

	ASSERT_NOT_NULL(prop);

	if (!token) {
		fpga_properties pr;

		pr = opae_properties_create();

		if (!pr) {
			OPAE_ERR("malloc failed");
			return FPGA_NO_MEMORY;
		}

		*prop = pr;

	} else {
		struct _fpga_properties *p;
		int err;

		ASSERT_NOT_NULL(wrapped_token);

		ASSERT_NOT_NULL_RESULT(
			wrapped_token->adapter_table->fpgaGetProperties,
			FPGA_NOT_SUPPORTED);

		res = wrapped_token->adapter_table->fpgaGetProperties(
			wrapped_token->opae_token, prop);

		ASSERT_RESULT(res);

		// If the output properties has a parent token set,
		// then it will be a raw token. We need to wrap it.

		p = opae_validate_and_lock_properties(*prop);

		ASSERT_NOT_NULL(p);

		if (FIELD_VALID(p, FPGA_PROPERTY_PARENT)) {
			opae_wrapped_token *wrapped_parent =
				opae_allocate_wrapped_token(
					p->parent,
					wrapped_token->adapter_table);

			if (wrapped_parent) {
				p->parent = wrapped_parent;
				p->flags |= OPAE_PROPERTIES_FLAG_PARENT_ALLOC;
			} else {
				OPAE_ERR("malloc failed");
				res = FPGA_NO_MEMORY;
			}
		}

		opae_mutex_unlock(err, &p->lock);
	}

	return res;
}

fpga_result __OPAE_API__ fpgaUpdateProperties(fpga_token token,
					      fpga_properties prop)
{
	fpga_result res;
	struct _fpga_properties *p;
	int err;
	opae_wrapped_token *wrapped_token = opae_validate_wrapped_token(token);
	opae_wrapped_token *wrapped_parent = NULL;

	ASSERT_NOT_NULL(wrapped_token);
	ASSERT_NOT_NULL_RESULT(
		wrapped_token->adapter_table->fpgaUpdateProperties,
		FPGA_NOT_SUPPORTED);

	// If the input properties already has a parent token
	// set, then it will be wrapped. If we allocated the wrapper,
	// Save the wrapper, and reuse it below.

	p = opae_validate_and_lock_properties(prop);

	ASSERT_NOT_NULL(p);

	if (FIELD_VALID(p, FPGA_PROPERTY_PARENT)
	    && (p->flags & OPAE_PROPERTIES_FLAG_PARENT_ALLOC)) {
		wrapped_parent = opae_validate_wrapped_token(p->parent);
		if (wrapped_parent)
			p->parent = wrapped_parent->opae_token;
	}

	res = wrapped_token->adapter_table->fpgaUpdateProperties(
		wrapped_token->opae_token, prop);

	if (res != FPGA_OK) {
		opae_mutex_unlock(err, &p->lock);
		return res;
	}

	// If the output properties has a parent token set,
	// then it will be a raw token. We need to wrap it.

	if (FIELD_VALID(p, FPGA_PROPERTY_PARENT)) {
		if (!wrapped_parent) {
			// We need to allocate a wrapper.
			wrapped_parent = opae_allocate_wrapped_token(
				p->parent, wrapped_token->adapter_table);

			if (wrapped_parent) {
				p->parent = wrapped_parent;
				p->flags |= OPAE_PROPERTIES_FLAG_PARENT_ALLOC;
			} else {
				OPAE_ERR("malloc failed");
				res = FPGA_NO_MEMORY;
			}
		} else {
			// We are re-using the wrapper from above.
			wrapped_parent->opae_token = p->parent;
			wrapped_parent->adapter_table =
				wrapped_token->adapter_table;
			p->parent = wrapped_parent;
			p->flags |= OPAE_PROPERTIES_FLAG_PARENT_ALLOC;
		}
	} else if (wrapped_parent)
		opae_destroy_wrapped_token(wrapped_parent);

	opae_mutex_unlock(err, &p->lock);

	return res;
}

fpga_result __OPAE_API__ fpgaWriteMMIO64(fpga_handle handle, uint32_t mmio_num,
					 uint64_t offset, uint64_t value)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaWriteMMIO64,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaWriteMMIO64(
		wrapped_handle->opae_handle, mmio_num, offset, value);
}

fpga_result __OPAE_API__ fpgaReadMMIO64(fpga_handle handle, uint32_t mmio_num,
			   uint64_t offset, uint64_t *value)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaReadMMIO64,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaReadMMIO64(
		wrapped_handle->opae_handle, mmio_num, offset, value);
}

fpga_result __OPAE_API__ fpgaWriteMMIO32(fpga_handle handle, uint32_t mmio_num,
			    uint64_t offset, uint32_t value)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaWriteMMIO32,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaWriteMMIO32(
		wrapped_handle->opae_handle, mmio_num, offset, value);
}

fpga_result __OPAE_API__ fpgaReadMMIO32(fpga_handle handle, uint32_t mmio_num,
			   uint64_t offset, uint32_t *value)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaReadMMIO32,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaReadMMIO32(
		wrapped_handle->opae_handle, mmio_num, offset, value);
}

fpga_result __OPAE_API__ fpgaWriteMMIO512(fpga_handle handle,
	uint32_t mmio_num, uint64_t offset, void *value)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaWriteMMIO512,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaWriteMMIO512(
		wrapped_handle->opae_handle, mmio_num, offset, value);
}

fpga_result __OPAE_API__ fpgaMapMMIO(fpga_handle handle, uint32_t mmio_num,
			uint64_t **mmio_ptr)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaMapMMIO,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaMapMMIO(
		wrapped_handle->opae_handle, mmio_num, mmio_ptr);
}

fpga_result __OPAE_API__ fpgaUnmapMMIO(fpga_handle handle, uint32_t mmio_num)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaUnmapMMIO,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaUnmapMMIO(
		wrapped_handle->opae_handle, mmio_num);
}

typedef struct _opae_enumeration_context {
	// <verbatim from fpgaEnumerate>
	const fpga_properties *filters;
	uint32_t num_filters;
	fpga_token *wrapped_tokens;
	uint32_t max_wrapped_tokens;
	uint32_t *num_matches;
	// </verbatim from fpgaEnumerate>

	fpga_token *adapter_tokens;
	uint32_t num_wrapped_tokens;
	uint32_t errors;
} opae_enumeration_context;

static int opae_enumerate(const opae_api_adapter_table *adapter, void *context)
{
	opae_enumeration_context *ctx = (opae_enumeration_context *)context;
	fpga_result res;
	uint32_t num_matches = 0;
	uint32_t i;
	uint32_t space_remaining;

	// TODO: accept/reject this adapter, based on device support
	if (adapter->supports_device) {
	}

	// TODO: accept/reject this adapter, based on host support
	if (adapter->supports_host) {
	}

	space_remaining = ctx->max_wrapped_tokens - ctx->num_wrapped_tokens;

	if (ctx->wrapped_tokens && !space_remaining)
		return OPAE_ENUM_STOP;

	if (!adapter->fpgaEnumerate) {
		OPAE_MSG("NULL fpgaEnumerate in adapter \"%s\"",
			 adapter->plugin.path);
		return OPAE_ENUM_CONTINUE;
	}

	res = adapter->fpgaEnumerate(ctx->filters, ctx->num_filters,
				     ctx->adapter_tokens, space_remaining,
				     &num_matches);

	if (res != FPGA_OK) {
		OPAE_ERR("fpgaEnumerate() failed for \"%s\"",
			 adapter->plugin.path);
		++ctx->errors;
		return OPAE_ENUM_CONTINUE;
	}

	*ctx->num_matches += num_matches;

	if (!ctx->adapter_tokens) {
		// requesting token count, only.
		return OPAE_ENUM_CONTINUE;
	}

	if (space_remaining > num_matches)
		space_remaining = num_matches;

	for (i = 0; i < space_remaining; ++i) {
		opae_wrapped_token *wt = opae_allocate_wrapped_token(
			ctx->adapter_tokens[i], adapter);
		if (!wt) {
			++ctx->errors;
			return OPAE_ENUM_STOP;
		}

		if (ctx->wrapped_tokens) {
			ctx->wrapped_tokens[ctx->num_wrapped_tokens++] = wt;
		} else {
			opae_destroy_wrapped_token(wt);
		}
	}

	return ctx->num_wrapped_tokens == ctx->max_wrapped_tokens
		       ? OPAE_ENUM_STOP
		       : OPAE_ENUM_CONTINUE;
}

fpga_result __OPAE_API__ fpgaEnumerate(const fpga_properties *filters,
	uint32_t num_filters, fpga_token *tokens, uint32_t max_tokens,
	uint32_t *num_matches)
{
	fpga_result res = FPGA_EXCEPTION;
	fpga_token *adapter_tokens = NULL;

	opae_enumeration_context enum_context;

	typedef struct _parent_token_fixup {
		struct _parent_token_fixup *next;
		fpga_properties prop;
		opae_wrapped_token *wrapped_token;
	} parent_token_fixup;

	parent_token_fixup *ptf_list = NULL;
	uint32_t i;

	ASSERT_NOT_NULL(num_matches);

	if ((max_tokens > 0) && !tokens) {
		OPAE_ERR("max_tokens > 0 with NULL tokens");
		return FPGA_INVALID_PARAM;
	}

	if ((num_filters > 0) && !filters) {
		OPAE_ERR("num_filters > 0 with NULL filters");
		return FPGA_INVALID_PARAM;
	}

	if ((num_filters == 0) && (filters != NULL)) {
		OPAE_ERR("num_filters == 0 with non-NULL filters");
		return FPGA_INVALID_PARAM;
	}

	*num_matches = 0;

	enum_context.filters = filters;
	enum_context.num_filters = num_filters;
	enum_context.wrapped_tokens = tokens;
	enum_context.max_wrapped_tokens = max_tokens;
	enum_context.num_matches = num_matches;

	if (tokens) {
		adapter_tokens =
			(fpga_token *)calloc(max_tokens, sizeof(fpga_token));
		if (!adapter_tokens) {
			OPAE_ERR("out of memory");
			return FPGA_NO_MEMORY;
		}
	}

	enum_context.adapter_tokens = adapter_tokens;
	enum_context.num_wrapped_tokens = 0;
	enum_context.errors = 0;

	// If any of the input filters has a parent token set,
	// then it will be wrapped. We need to unwrap it here,
	// then re-wrap below.
	for (i = 0; i < num_filters; ++i) {
		int err;
		struct _fpga_properties *p =
			opae_validate_and_lock_properties(filters[i]);

		if (!p) {
			OPAE_ERR("Invalid input filter");
			res = FPGA_INVALID_PARAM;
			goto out_free_tokens;
		}

		if (FIELD_VALID(p, FPGA_PROPERTY_PARENT)) {
			parent_token_fixup *fixup;
			opae_wrapped_token *wrapped_parent =
				opae_validate_wrapped_token(p->parent);

			if (!wrapped_parent) {
				OPAE_ERR("Invalid wrapped parent in filter");
				res = FPGA_INVALID_PARAM;
				opae_mutex_unlock(err, &p->lock);
				goto out_free_tokens;
			}

			fixup = (parent_token_fixup *)malloc(
				sizeof(parent_token_fixup));

			if (!fixup) {
				OPAE_ERR("malloc failed");
				res = FPGA_NO_MEMORY;
				opae_mutex_unlock(err, &p->lock);
				goto out_free_tokens;
			}

			fixup->next = NULL;
			fixup->prop = filters[i];
			fixup->wrapped_token = wrapped_parent;

			if (!ptf_list)
				ptf_list = fixup;
			else {
				fixup->next = ptf_list;
				ptf_list = fixup;
			}

			// Set the unwrapped parent token.
			p->parent = wrapped_parent->opae_token;
		}

		opae_mutex_unlock(err, &p->lock);
	}

	// perform the enumeration.
	opae_plugin_mgr_for_each_adapter(opae_enumerate, &enum_context);

	res = (enum_context.errors > 0) ? FPGA_EXCEPTION : FPGA_OK;

out_free_tokens:
	if (adapter_tokens)
		free(adapter_tokens);

	// Re-establish any wrapped parent tokens.
	while (ptf_list) {
		int err;
		parent_token_fixup *trash = ptf_list;
		struct _fpga_properties *p =
			opae_validate_and_lock_properties(trash->prop);
		ptf_list = ptf_list->next;

		if (p) {
			p->parent = trash->wrapped_token;
			opae_mutex_unlock(err, &p->lock);
		}

		free(trash);
	}

	return res;
}

fpga_result __OPAE_API__ fpgaCloneToken(fpga_token src, fpga_token *dst)
{
	fpga_result res;
	fpga_result dres = FPGA_OK;
	fpga_token cloned_token = NULL;
	opae_wrapped_token *wrapped_dst_token;
	opae_wrapped_token *wrapped_src_token =
		opae_validate_wrapped_token(src);

	ASSERT_NOT_NULL(wrapped_src_token);
	ASSERT_NOT_NULL(dst);
	ASSERT_NOT_NULL_RESULT(wrapped_src_token->adapter_table->fpgaCloneToken,
			       FPGA_NOT_SUPPORTED);
	ASSERT_NOT_NULL_RESULT(
		wrapped_src_token->adapter_table->fpgaDestroyToken,
		FPGA_NOT_SUPPORTED);

	res = wrapped_src_token->adapter_table->fpgaCloneToken(
		wrapped_src_token->opae_token, &cloned_token);

	ASSERT_RESULT(res);

	wrapped_dst_token = opae_allocate_wrapped_token(
		cloned_token, wrapped_src_token->adapter_table);

	if (!wrapped_dst_token) {
		OPAE_ERR("malloc failed");
		res = FPGA_NO_MEMORY;
		dres = wrapped_src_token->adapter_table->fpgaDestroyToken(
			&cloned_token);
	}

	*dst = wrapped_dst_token;

	return res != FPGA_OK ? res : dres;
}

fpga_result __OPAE_API__ fpgaDestroyToken(fpga_token *token)
{
	fpga_result res;
	opae_wrapped_token *wrapped_token;

	ASSERT_NOT_NULL(token);

	wrapped_token = opae_validate_wrapped_token(*token);

	ASSERT_NOT_NULL(wrapped_token);
	ASSERT_NOT_NULL_RESULT(wrapped_token->adapter_table->fpgaDestroyToken,
			       FPGA_NOT_SUPPORTED);

	res = wrapped_token->adapter_table->fpgaDestroyToken(
		&wrapped_token->opae_token);

	opae_destroy_wrapped_token(wrapped_token);

	return res;
}

fpga_result __OPAE_API__ fpgaGetNumUmsg(fpga_handle handle, uint64_t *value)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(value);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaGetNumUmsg,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaGetNumUmsg(
		wrapped_handle->opae_handle, value);
}

fpga_result __OPAE_API__ fpgaSetUmsgAttributes(fpga_handle handle,
					       uint64_t value)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(
		wrapped_handle->adapter_table->fpgaSetUmsgAttributes,
		FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaSetUmsgAttributes(
		wrapped_handle->opae_handle, value);
}

fpga_result __OPAE_API__ fpgaTriggerUmsg(fpga_handle handle, uint64_t value)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaTriggerUmsg,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaTriggerUmsg(
		wrapped_handle->opae_handle, value);
}

fpga_result __OPAE_API__ fpgaGetUmsgPtr(fpga_handle handle, uint64_t **umsg_ptr)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(umsg_ptr);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaGetUmsgPtr,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaGetUmsgPtr(
		wrapped_handle->opae_handle, umsg_ptr);
}

fpga_result __OPAE_API__ fpgaPrepareBuffer(fpga_handle handle,
	uint64_t len, void **buf_addr, uint64_t *wsid, int flags)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	// A special case: allow each plugin to respond FPGA_OK
	// when !buf_addr and !len as an indication that
	// FPGA_BUF_PREALLOCATED is supported by the plugin.
	if (!(flags & FPGA_BUF_PREALLOCATED) || (len > 0)) {
		// Assert only if not the special case described above.
		ASSERT_NOT_NULL(buf_addr);
	}

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(wsid);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaPrepareBuffer,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaPrepareBuffer(
		wrapped_handle->opae_handle, len, buf_addr, wsid, flags);
}

fpga_result __OPAE_API__ fpgaReleaseBuffer(fpga_handle handle, uint64_t wsid)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaReleaseBuffer,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaReleaseBuffer(
		wrapped_handle->opae_handle, wsid);
}

fpga_result __OPAE_API__ fpgaGetIOAddress(fpga_handle handle, uint64_t wsid,
					  uint64_t *ioaddr)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(ioaddr);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaGetIOAddress,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaGetIOAddress(
		wrapped_handle->opae_handle, wsid, ioaddr);
}

fpga_result __OPAE_API__ fpgaGetOPAECVersion(fpga_version *version)
{
	ASSERT_NOT_NULL(version);

	version->major = OPAE_VERSION_MAJOR;
	version->minor = OPAE_VERSION_MINOR;
	version->patch = OPAE_VERSION_REVISION;

	return FPGA_OK;
}

fpga_result __OPAE_API__ fpgaGetOPAECVersionString(char *version_str,
						   size_t len)
{
	ASSERT_NOT_NULL(version_str);
	if (len <= sizeof(OPAE_VERSION))
		return FPGA_INVALID_PARAM;

	snprintf(version_str, len, "%s", OPAE_VERSION);

	return FPGA_OK;
}

fpga_result __OPAE_API__ fpgaGetOPAECBuildString(char *build_str, size_t len)
{
	ASSERT_NOT_NULL(build_str);
	if (!len)
		return FPGA_INVALID_PARAM;

	snprintf(build_str, len,
		 "%s%s",
		 OPAE_GIT_COMMIT_HASH,
		 OPAE_GIT_SRC_TREE_DIRTY ? "*" : "");
	build_str[len - 1] = '\0';

	return FPGA_OK;
}

fpga_result __OPAE_API__ fpgaReadError(fpga_token token,
	uint32_t error_num, uint64_t *value)
{
	opae_wrapped_token *wrapped_token = opae_validate_wrapped_token(token);

	ASSERT_NOT_NULL(wrapped_token);
	ASSERT_NOT_NULL(value);
	ASSERT_NOT_NULL_RESULT(wrapped_token->adapter_table->fpgaReadError,
			       FPGA_NOT_SUPPORTED);

	return wrapped_token->adapter_table->fpgaReadError(
		wrapped_token->opae_token, error_num, value);
}

fpga_result __OPAE_API__ fpgaClearError(fpga_token token, uint32_t error_num)
{
	opae_wrapped_token *wrapped_token = opae_validate_wrapped_token(token);

	ASSERT_NOT_NULL(wrapped_token);
	ASSERT_NOT_NULL_RESULT(wrapped_token->adapter_table->fpgaClearError,
			       FPGA_NOT_SUPPORTED);

	return wrapped_token->adapter_table->fpgaClearError(
		wrapped_token->opae_token, error_num);
}

fpga_result __OPAE_API__ fpgaClearAllErrors(fpga_token token)
{
	opae_wrapped_token *wrapped_token = opae_validate_wrapped_token(token);

	ASSERT_NOT_NULL(wrapped_token);
	ASSERT_NOT_NULL_RESULT(wrapped_token->adapter_table->fpgaClearAllErrors,
			       FPGA_NOT_SUPPORTED);

	return wrapped_token->adapter_table->fpgaClearAllErrors(
		wrapped_token->opae_token);
}

fpga_result __OPAE_API__ fpgaGetErrorInfo(fpga_token token, uint32_t error_num,
					  struct fpga_error_info *error_info)
{
	opae_wrapped_token *wrapped_token = opae_validate_wrapped_token(token);

	ASSERT_NOT_NULL(wrapped_token);
	ASSERT_NOT_NULL(error_info);
	ASSERT_NOT_NULL_RESULT(wrapped_token->adapter_table->fpgaGetErrorInfo,
			       FPGA_NOT_SUPPORTED);

	return wrapped_token->adapter_table->fpgaGetErrorInfo(
		wrapped_token->opae_token, error_num, error_info);
}

const char * __OPAE_API__ fpgaErrStr(fpga_result e)
{
	switch (e) {
	case FPGA_OK:
		return "success";
	case FPGA_INVALID_PARAM:
		return "invalid parameter";
	case FPGA_BUSY:
		return "resource busy";
	case FPGA_EXCEPTION:
		return "exception";
	case FPGA_NOT_FOUND:
		return "not found";
	case FPGA_NO_MEMORY:
		return "no memory";
	case FPGA_NOT_SUPPORTED:
		return "not supported";
	case FPGA_NO_DRIVER:
		return "no driver available";
	case FPGA_NO_DAEMON:
		return "no fpga daemon running";
	case FPGA_NO_ACCESS:
		return "insufficient privileges";
	case FPGA_RECONF_ERROR:
		return "reconfiguration error";
	default:
		return "unknown error";
	}
}

fpga_result __OPAE_API__ fpgaCreateEventHandle(fpga_event_handle *event_handle)
{
	opae_wrapped_event_handle *wrapped_event_handle;

	ASSERT_NOT_NULL(event_handle);

	// We don't have an adapter table yet, so just create an empty object.
	wrapped_event_handle = opae_allocate_wrapped_event_handle(NULL, NULL);

	ASSERT_NOT_NULL_RESULT(wrapped_event_handle, FPGA_NO_MEMORY);

	*event_handle = wrapped_event_handle;

	return FPGA_OK;
}

fpga_result __OPAE_API__ fpgaDestroyEventHandle(fpga_event_handle *event_handle)
{
	fpga_result res = FPGA_OK;
	opae_wrapped_event_handle *wrapped_event_handle;
	int ires;

	ASSERT_NOT_NULL(event_handle);

	wrapped_event_handle =
		opae_validate_wrapped_event_handle(*event_handle);

	ASSERT_NOT_NULL(wrapped_event_handle);

	opae_mutex_lock(ires, &wrapped_event_handle->lock);

	if (wrapped_event_handle->flags & OPAE_WRAPPED_EVENT_HANDLE_CREATED) {

		if (!wrapped_event_handle->adapter_table
			     ->fpgaDestroyEventHandle) {
			OPAE_ERR("NULL fpgaDestroyEventHandle() in adapter.");
			opae_mutex_unlock(ires, &wrapped_event_handle->lock);
			return FPGA_NOT_SUPPORTED;
		}

		if (!wrapped_event_handle->opae_event_handle) {
			OPAE_ERR("NULL fpga_event_handle in wrapper.");
			opae_mutex_unlock(ires, &wrapped_event_handle->lock);
			return FPGA_INVALID_PARAM;
		}

		res = wrapped_event_handle->adapter_table
			      ->fpgaDestroyEventHandle(
				      &wrapped_event_handle->opae_event_handle);
	}

	opae_mutex_unlock(ires, &wrapped_event_handle->lock);

	opae_destroy_wrapped_event_handle(wrapped_event_handle);

	return res;
}

fpga_result __OPAE_API__ fpgaGetOSObjectFromEventHandle(
	const fpga_event_handle eh, int *fd)
{
	fpga_result res;
	opae_wrapped_event_handle *wrapped_event_handle =
		opae_validate_wrapped_event_handle(eh);
	int ires;

	ASSERT_NOT_NULL(fd);
	ASSERT_NOT_NULL(wrapped_event_handle);

	opae_mutex_lock(ires, &wrapped_event_handle->lock);

	if (!(wrapped_event_handle->flags
	      & OPAE_WRAPPED_EVENT_HANDLE_CREATED)) {
		OPAE_ERR(
			"Attempting to query OS event object before event handle is registered.");
		opae_mutex_unlock(ires, &wrapped_event_handle->lock);
		return FPGA_INVALID_PARAM;
	}

	if (!wrapped_event_handle->opae_event_handle) {
		OPAE_ERR("NULL fpga_event_handle in wrapper.");
		opae_mutex_unlock(ires, &wrapped_event_handle->lock);
		return FPGA_INVALID_PARAM;
	}

	if (!wrapped_event_handle->adapter_table
		     ->fpgaGetOSObjectFromEventHandle) {
		OPAE_ERR("NULL fpgaGetOSObjectFromEventHandle in adapter.");
		opae_mutex_unlock(ires, &wrapped_event_handle->lock);
		return FPGA_NOT_SUPPORTED;
	}

	res = wrapped_event_handle->adapter_table
		      ->fpgaGetOSObjectFromEventHandle(
			      wrapped_event_handle->opae_event_handle, fd);

	opae_mutex_unlock(ires, &wrapped_event_handle->lock);

	return res;
}

fpga_result __OPAE_API__ fpgaRegisterEvent(fpga_handle handle,
	fpga_event_type event_type, fpga_event_handle event_handle,
	uint32_t flags)
{
	fpga_result res = FPGA_OK;
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);
	opae_wrapped_event_handle *wrapped_event_handle =
		opae_validate_wrapped_event_handle(event_handle);
	int ires;

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(wrapped_event_handle);

	opae_mutex_lock(ires, &wrapped_event_handle->lock);

	if (!(wrapped_event_handle->flags
	      & OPAE_WRAPPED_EVENT_HANDLE_CREATED)) {
		// Now that we have an adapter table, store the adapter in
		// the wrapped_event_handle, and create the event handle.

		if (!wrapped_handle->adapter_table->fpgaCreateEventHandle) {
			OPAE_ERR("NULL fpgaCreateEventHandle() in adapter.");
			opae_mutex_unlock(ires, &wrapped_event_handle->lock);
			return FPGA_NOT_SUPPORTED;
		}

		res = wrapped_handle->adapter_table->fpgaCreateEventHandle(
			&wrapped_event_handle->opae_event_handle);

		if (res != FPGA_OK) {
			opae_mutex_unlock(ires, &wrapped_event_handle->lock);
			return res;
		}

		// The event_handle is now created.
		wrapped_event_handle->adapter_table =
			wrapped_handle->adapter_table;
		wrapped_event_handle->flags |=
			OPAE_WRAPPED_EVENT_HANDLE_CREATED;
	}

	if (!wrapped_event_handle->opae_event_handle) {
		OPAE_ERR("NULL fpga_event_handle");
		opae_mutex_unlock(ires, &wrapped_event_handle->lock);
		return FPGA_INVALID_PARAM;
	}

	if (!wrapped_event_handle->adapter_table) {
		OPAE_ERR("NULL adapter table in wrapped event handle.");
		opae_mutex_unlock(ires, &wrapped_event_handle->lock);
		return FPGA_INVALID_PARAM;
	}

	if (!wrapped_event_handle->adapter_table->fpgaRegisterEvent) {
		OPAE_ERR("NULL fpgaRegisterEvent() in adapter.");
		opae_mutex_unlock(ires, &wrapped_event_handle->lock);
		return FPGA_NOT_SUPPORTED;
	}

	res = wrapped_event_handle->adapter_table->fpgaRegisterEvent(
		wrapped_handle->opae_handle, event_type,
		wrapped_event_handle->opae_event_handle, flags);

	opae_mutex_unlock(ires, &wrapped_event_handle->lock);

	return res;
}

fpga_result __OPAE_API__ fpgaUnregisterEvent(fpga_handle handle,
	fpga_event_type event_type, fpga_event_handle event_handle)
{
	fpga_result res;
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);
	opae_wrapped_event_handle *wrapped_event_handle =
		opae_validate_wrapped_event_handle(event_handle);
	int ires;

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(wrapped_event_handle);

	opae_mutex_lock(ires, &wrapped_event_handle->lock);

	if (!(wrapped_event_handle->flags
	      & OPAE_WRAPPED_EVENT_HANDLE_CREATED)) {
		OPAE_ERR(
			"Attempting to unregister event object before registering it.");
		opae_mutex_unlock(ires, &wrapped_event_handle->lock);
		return FPGA_INVALID_PARAM;
	}

	if (!wrapped_event_handle->opae_event_handle) {
		OPAE_ERR("NULL fpga_event_handle in wrapper.");
		opae_mutex_unlock(ires, &wrapped_event_handle->lock);
		return FPGA_INVALID_PARAM;
	}

	if (!wrapped_event_handle->adapter_table->fpgaUnregisterEvent) {
		OPAE_ERR("NULL fpgaUnregisterEvent() in adapter.");
		opae_mutex_unlock(ires, &wrapped_event_handle->lock);
		return FPGA_NOT_SUPPORTED;
	}

	res = wrapped_event_handle->adapter_table->fpgaUnregisterEvent(
		wrapped_handle->opae_handle, event_type,
		wrapped_event_handle->opae_event_handle);

	opae_mutex_unlock(ires, &wrapped_event_handle->lock);

	return res;
}

fpga_result __OPAE_API__ fpgaAssignPortToInterface(fpga_handle fpga,
	uint32_t interface_num, uint32_t slot_num, int flags)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(fpga);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(
		wrapped_handle->adapter_table->fpgaAssignPortToInterface,
		FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaAssignPortToInterface(
		wrapped_handle->opae_handle, interface_num, slot_num, flags);
}

fpga_result __OPAE_API__ fpgaAssignToInterface(fpga_handle fpga,
	fpga_token accelerator, uint32_t host_interface, int flags)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(fpga);
	opae_wrapped_token *wrapped_token =
		opae_validate_wrapped_token(accelerator);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(wrapped_token);
	ASSERT_NOT_NULL_RESULT(
		wrapped_handle->adapter_table->fpgaAssignToInterface,
		FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaAssignToInterface(
		wrapped_handle->opae_handle, wrapped_token->opae_token,
		host_interface, flags);
}

fpga_result __OPAE_API__ fpgaReleaseFromInterface(fpga_handle fpga,
						  fpga_token accelerator)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(fpga);
	opae_wrapped_token *wrapped_token =
		opae_validate_wrapped_token(accelerator);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(wrapped_token);
	ASSERT_NOT_NULL_RESULT(
		wrapped_handle->adapter_table->fpgaReleaseFromInterface,
		FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaReleaseFromInterface(
		wrapped_handle->opae_handle, wrapped_token->opae_token);
}

fpga_result __OPAE_API__ fpgaReconfigureSlot(fpga_handle fpga, uint32_t slot,
				const uint8_t *bitstream, size_t bitstream_len,
				int flags)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(fpga);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(bitstream);
	ASSERT_NOT_NULL_RESULT(
		wrapped_handle->adapter_table->fpgaReconfigureSlot,
		FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaReconfigureSlot(
		wrapped_handle->opae_handle, slot, bitstream, bitstream_len,
		flags);
}

fpga_result __OPAE_API__ fpgaTokenGetObject(fpga_token token, const char *name,
			       fpga_object *object, int flags)
{
	fpga_result res;
	fpga_result dres = FPGA_OK;
	fpga_object obj = NULL;
	opae_wrapped_object *wrapped_object;
	opae_wrapped_token *wrapped_token = opae_validate_wrapped_token(token);

	ASSERT_NOT_NULL(wrapped_token);
	ASSERT_NOT_NULL(name);
	ASSERT_NOT_NULL(object);
	ASSERT_NOT_NULL_RESULT(wrapped_token->adapter_table->fpgaTokenGetObject,
			       FPGA_NOT_SUPPORTED);
	ASSERT_NOT_NULL_RESULT(wrapped_token->adapter_table->fpgaDestroyObject,
			       FPGA_NOT_SUPPORTED);

	res = wrapped_token->adapter_table->fpgaTokenGetObject(
		wrapped_token->opae_token, name, &obj, flags);

	ASSERT_RESULT(res);

	wrapped_object =
		opae_allocate_wrapped_object(obj, wrapped_token->adapter_table);

	if (!wrapped_object) {
		OPAE_ERR("malloc failed");
		res = FPGA_NO_MEMORY;
		dres = wrapped_token->adapter_table->fpgaDestroyObject(&obj);
	}

	*object = wrapped_object;

	return res != FPGA_OK ? res : dres;
}

fpga_result __OPAE_API__ fpgaHandleGetObject(fpga_handle handle,
	const char *name, fpga_object *object, int flags)
{
	fpga_result res;
	fpga_result dres = FPGA_OK;
	fpga_object obj = NULL;
	opae_wrapped_object *wrapped_object;
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(name);
	ASSERT_NOT_NULL(object);
	ASSERT_NOT_NULL_RESULT(
		wrapped_handle->adapter_table->fpgaHandleGetObject,
		FPGA_NOT_SUPPORTED);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaDestroyObject,
			       FPGA_NOT_SUPPORTED);

	res = wrapped_handle->adapter_table->fpgaHandleGetObject(
		wrapped_handle->opae_handle, name, &obj, flags);

	ASSERT_RESULT(res);

	wrapped_object = opae_allocate_wrapped_object(
		obj, wrapped_handle->adapter_table);

	if (!wrapped_object) {
		OPAE_ERR("malloc failed");
		res = FPGA_NO_MEMORY;
		dres = wrapped_handle->adapter_table->fpgaDestroyObject(&obj);
	}

	*object = wrapped_object;

	return res != FPGA_OK ? res : dres;
}

fpga_result __OPAE_API__ fpgaObjectGetObjectAt(fpga_object parent,
	size_t index, fpga_object *object)
{
	fpga_result res;
	fpga_result dres = FPGA_OK;
	fpga_object obj = NULL;
	opae_wrapped_object *wrapped_child_object;
	opae_wrapped_object *wrapped_object =
		opae_validate_wrapped_object(parent);

	ASSERT_NOT_NULL(wrapped_object);
	ASSERT_NOT_NULL(object);
	ASSERT_NOT_NULL_RESULT(
		wrapped_object->adapter_table->fpgaObjectGetObjectAt,
		FPGA_NOT_SUPPORTED);
	ASSERT_NOT_NULL_RESULT(wrapped_object->adapter_table->fpgaDestroyObject,
			       FPGA_NOT_SUPPORTED);

	res = wrapped_object->adapter_table->fpgaObjectGetObjectAt(
		wrapped_object->opae_object, index, &obj);

	ASSERT_RESULT(res);

	wrapped_child_object = opae_allocate_wrapped_object(
		obj, wrapped_object->adapter_table);

	if (!wrapped_child_object) {
		OPAE_ERR("malloc failed");
		res = FPGA_NO_MEMORY;
		dres = wrapped_object->adapter_table->fpgaDestroyObject(&obj);
	}

	*object = wrapped_child_object;

	return res != FPGA_OK ? res : dres;

}

fpga_result __OPAE_API__ fpgaObjectGetObject(fpga_object parent,
	const char *name, fpga_object *object, int flags)
{
	fpga_result res;
	fpga_result dres = FPGA_OK;
	fpga_object obj = NULL;
	opae_wrapped_object *wrapped_child_object;
	opae_wrapped_object *wrapped_object =
		opae_validate_wrapped_object(parent);

	ASSERT_NOT_NULL(wrapped_object);
	ASSERT_NOT_NULL(name);
	ASSERT_NOT_NULL(object);
	ASSERT_NOT_NULL_RESULT(
		wrapped_object->adapter_table->fpgaObjectGetObject,
		FPGA_NOT_SUPPORTED);
	ASSERT_NOT_NULL_RESULT(wrapped_object->adapter_table->fpgaDestroyObject,
			       FPGA_NOT_SUPPORTED);

	res = wrapped_object->adapter_table->fpgaObjectGetObject(
		wrapped_object->opae_object, name, &obj, flags);

	ASSERT_RESULT(res);

	wrapped_child_object = opae_allocate_wrapped_object(
		obj, wrapped_object->adapter_table);

	if (!wrapped_child_object) {
		OPAE_ERR("malloc failed");
		res = FPGA_NO_MEMORY;
		dres = wrapped_object->adapter_table->fpgaDestroyObject(&obj);
	}

	*object = wrapped_child_object;

	return res != FPGA_OK ? res : dres;
}

fpga_result __OPAE_API__ fpgaDestroyObject(fpga_object *obj)
{
	fpga_result res;
	opae_wrapped_object *wrapped_object;

	ASSERT_NOT_NULL(obj);

	wrapped_object = opae_validate_wrapped_object(*obj);

	ASSERT_NOT_NULL(wrapped_object);
	ASSERT_NOT_NULL_RESULT(wrapped_object->adapter_table->fpgaDestroyObject,
			       FPGA_NOT_SUPPORTED);

	res = wrapped_object->adapter_table->fpgaDestroyObject(
		&wrapped_object->opae_object);

	opae_destroy_wrapped_object(wrapped_object);

	return res;
}

fpga_result __OPAE_API__ fpgaObjectRead(fpga_object obj, uint8_t *buffer,
	size_t offset, size_t len, int flags)
{
	opae_wrapped_object *wrapped_object = opae_validate_wrapped_object(obj);

	ASSERT_NOT_NULL(wrapped_object);
	ASSERT_NOT_NULL(buffer);
	ASSERT_NOT_NULL_RESULT(wrapped_object->adapter_table->fpgaObjectRead,
			       FPGA_NOT_SUPPORTED);

	return wrapped_object->adapter_table->fpgaObjectRead(
		wrapped_object->opae_object, buffer, offset, len, flags);
}

fpga_result __OPAE_API__ fpgaObjectGetSize(fpga_object obj, uint64_t *value,
					   int flags)
{
	opae_wrapped_object *wrapped_object = opae_validate_wrapped_object(obj);

	ASSERT_NOT_NULL(wrapped_object);
	ASSERT_NOT_NULL(value);
	ASSERT_NOT_NULL_RESULT(wrapped_object->adapter_table->fpgaObjectGetSize,
			       FPGA_NOT_SUPPORTED);

	return wrapped_object->adapter_table->fpgaObjectGetSize(
		wrapped_object->opae_object, value, flags);
}

fpga_result __OPAE_API__ fpgaObjectGetType(fpga_object obj,
					   enum fpga_sysobject_type *type)
{
	opae_wrapped_object *wrapped_object = opae_validate_wrapped_object(obj);

	ASSERT_NOT_NULL(wrapped_object);
	ASSERT_NOT_NULL(type);
	ASSERT_NOT_NULL_RESULT(wrapped_object->adapter_table->fpgaObjectGetType,
			       FPGA_NOT_SUPPORTED);

	return wrapped_object->adapter_table->fpgaObjectGetType(
		wrapped_object->opae_object, type);
}

fpga_result __OPAE_API__ fpgaObjectRead64(fpga_object obj, uint64_t *value,
					  int flags)
{
	opae_wrapped_object *wrapped_object = opae_validate_wrapped_object(obj);

	ASSERT_NOT_NULL(wrapped_object);
	ASSERT_NOT_NULL(value);
	ASSERT_NOT_NULL_RESULT(wrapped_object->adapter_table->fpgaObjectRead64,
			       FPGA_NOT_SUPPORTED);

	return wrapped_object->adapter_table->fpgaObjectRead64(
		wrapped_object->opae_object, value, flags);
}

fpga_result __OPAE_API__ fpgaObjectWrite64(fpga_object obj, uint64_t value,
					   int flags)
{
	opae_wrapped_object *wrapped_object = opae_validate_wrapped_object(obj);

	ASSERT_NOT_NULL(wrapped_object);
	ASSERT_NOT_NULL_RESULT(wrapped_object->adapter_table->fpgaObjectWrite64,
			       FPGA_NOT_SUPPORTED);

	return wrapped_object->adapter_table->fpgaObjectWrite64(
		wrapped_object->opae_object, value, flags);
}

fpga_result __OPAE_API__ fpgaSetUserClock(fpga_handle handle,
	uint64_t high_clk, uint64_t low_clk, int flags)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaSetUserClock,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaSetUserClock(
		wrapped_handle->opae_handle, high_clk, low_clk, flags);
}

fpga_result __OPAE_API__ fpgaGetUserClock(fpga_handle handle,
	uint64_t *high_clk, uint64_t *low_clk, int flags)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(low_clk);
	ASSERT_NOT_NULL(high_clk);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaGetUserClock,
			       FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaGetUserClock(
		wrapped_handle->opae_handle, high_clk, low_clk, flags);
}

fpga_result __OPAE_API__ fpgaGetNumMetrics(fpga_handle handle,
					   uint64_t *num_metrics)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(num_metrics);

	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaGetNumMetrics,
			     FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaGetNumMetrics(
		wrapped_handle->opae_handle, num_metrics);
}

fpga_result __OPAE_API__ fpgaGetMetricsInfo(fpga_handle handle,
				fpga_metric_info *metric_info,
				uint64_t *num_metrics)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(metric_info);
	ASSERT_NOT_NULL(num_metrics);
	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaGetMetricsInfo,
			    FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaGetMetricsInfo(
		wrapped_handle->opae_handle, metric_info, num_metrics);
}

fpga_result __OPAE_API__ fpgaGetMetricsByIndex(fpga_handle handle,
				uint64_t *metric_num,
				uint64_t num_metric_indexes,
				fpga_metric *metrics)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(num_metric_indexes);
	ASSERT_NOT_NULL(metrics);

	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaGetMetricsByIndex,
			   FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaGetMetricsByIndex(
		wrapped_handle->opae_handle, metric_num, num_metric_indexes, metrics);
}

fpga_result __OPAE_API__ fpgaGetMetricsByName(fpga_handle handle,
				char **metrics_names,
				uint64_t num_metric_names,
				fpga_metric *metrics)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(metrics_names);
	ASSERT_NOT_NULL(metrics);

	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaGetMetricsByName,
			   FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaGetMetricsByName(
		wrapped_handle->opae_handle, metrics_names, num_metric_names, metrics);
}

fpga_result __OPAE_API__ fpgaGetMetricsThresholdInfo(fpga_handle handle,
	metric_threshold *metric_thresholds,
	uint32_t *num_thresholds)
{
	opae_wrapped_handle *wrapped_handle =
		opae_validate_wrapped_handle(handle);

	ASSERT_NOT_NULL(wrapped_handle);
	ASSERT_NOT_NULL(num_thresholds);

	ASSERT_NOT_NULL_RESULT(wrapped_handle->adapter_table->fpgaGetMetricsThresholdInfo,
		FPGA_NOT_SUPPORTED);

	return wrapped_handle->adapter_table->fpgaGetMetricsThresholdInfo(
		wrapped_handle->opae_handle, metric_thresholds, num_thresholds);
}