// 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.

#ifndef __OPAE_OPAE_INT_H__

#define __OPAE_OPAE_INT_H__

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <opae/types.h>

#include <opae/log.h>

#ifndef __USE_GNU

#define __USE_GNU

#endif // __USE_GNU

#include <pthread.h>

#define ASSERT_NOT_NULL_MSG_RESULT(__arg, __msg, __result) \

	do {                                                   \

		if (!__arg) {                                      \

			OPAE_ERR(__msg);                               \

			return __result;                               \

		}                                                  \

	} while (0)

/*

 * Check if argument is NULL and return FPGA_INVALID_PARAM and a message

 */

#define ASSERT_NOT_NULL_MSG(__arg, __msg) \

	ASSERT_NOT_NULL_MSG_RESULT(__arg, __msg, FPGA_INVALID_PARAM)

#define ASSERT_NOT_NULL(__arg) ASSERT_NOT_NULL_MSG(__arg, #__arg " is NULL")

#define ASSERT_NOT_NULL_RESULT(__arg, __result) \

	ASSERT_NOT_NULL_MSG_RESULT(__arg, #__arg " is NULL", __result)

#define ASSERT_RESULT(__result)    \

	do {                           \

		if ((__result) != FPGA_OK) \

			return __result;       \

	} while (0)

#define UNUSED_PARAM(x) ((void)x)

#define opae_mutex_lock(__res, __mtx_ptr)             \

	({                                                \

		(__res) = pthread_mutex_lock(__mtx_ptr);      \

		if (__res)                                    \

			OPAE_ERR("pthread_mutex_lock failed: %s", \

				 strerror(errno));                    \

		__res;                                        \

	})

#define opae_mutex_unlock(__res, __mtx_ptr)             \

	({                                                  \

		(__res) = pthread_mutex_unlock(__mtx_ptr);      \

		if (__res)                                      \

			OPAE_ERR("pthread_mutex_unlock failed: %s", \

				 strerror(errno));                      \

		__res;                                          \

	})

#ifndef __OPAE_ADAPTER_H__

typedef struct _opae_api_adapter_table opae_api_adapter_table;

#endif // __OPAE_ADAPTER_H__

//                                  k o t w

#define OPAE_WRAPPED_TOKEN_MAGIC 0x6b6f7477

typedef struct _opae_wrapped_token {

	uint32_t magic;

	fpga_token opae_token;

	opae_api_adapter_table *adapter_table;

} opae_wrapped_token;

opae_wrapped_token *

opae_allocate_wrapped_token(fpga_token token,

			    const opae_api_adapter_table *adapter);

static inline opae_wrapped_token *opae_validate_wrapped_token(fpga_token t)

{

	opae_wrapped_token *wt;

	if (!t)

		return NULL;

	wt = (opae_wrapped_token *)t;

	return (wt->magic == OPAE_WRAPPED_TOKEN_MAGIC) ? wt : NULL;

}

static inline void opae_destroy_wrapped_token(opae_wrapped_token *wt)

{

	wt->magic = 0;

	free(wt);

}

//                                   n a h w

#define OPAE_WRAPPED_HANDLE_MAGIC 0x6e616877

typedef struct _opae_wrapped_handle {

	uint32_t magic;

	opae_wrapped_token *wrapped_token;

	fpga_handle opae_handle;

	opae_api_adapter_table *adapter_table;

} opae_wrapped_handle;

opae_wrapped_handle *

opae_allocate_wrapped_handle(opae_wrapped_token *wt, fpga_handle opae_handle,

			     opae_api_adapter_table *adapter);

static inline opae_wrapped_handle *opae_validate_wrapped_handle(fpga_handle h)

{

	opae_wrapped_handle *wh;

	if (!h)

		return NULL;

	wh = (opae_wrapped_handle *)h;

	return (wh->magic == OPAE_WRAPPED_HANDLE_MAGIC) ? wh : NULL;

}

static inline void opae_destroy_wrapped_handle(opae_wrapped_handle *wh)

{

	wh->magic = 0;

	free(wh);

}

//                                         e v e w

#define OPAE_WRAPPED_EVENT_HANDLE_MAGIC 0x65766577

#define OPAE_WRAPPED_EVENT_HANDLE_CREATED 0x00000001

typedef struct _opae_wrapped_event_handle {

	uint32_t magic;

	pthread_mutex_t lock;

	uint32_t flags;

	fpga_event_handle opae_event_handle;

	opae_api_adapter_table *adapter_table;

} opae_wrapped_event_handle;

opae_wrapped_event_handle *

opae_allocate_wrapped_event_handle(fpga_event_handle opae_event_handle,

				   opae_api_adapter_table *adapter);

static inline opae_wrapped_event_handle *

opae_validate_wrapped_event_handle(fpga_event_handle h)

{

	opae_wrapped_event_handle *we;

	if (!h)

		return NULL;

	we = (opae_wrapped_event_handle *)h;

	return (we->magic == OPAE_WRAPPED_EVENT_HANDLE_MAGIC) ? we : NULL;

}

static inline void

opae_destroy_wrapped_event_handle(opae_wrapped_event_handle *we)

{

	int err;

	opae_mutex_lock(err, &we->lock);

	we->magic = 0;

	opae_mutex_unlock(err, &we->lock);

	if (pthread_mutex_destroy(&we->lock))

		OPAE_ERR("pthread_mutex_destroy() failed");

	free(we);

}

//                                   j b o w

#define OPAE_WRAPPED_OBJECT_MAGIC 0x6a626f77

typedef struct _opae_wrapped_object {

	uint32_t magic;

	fpga_object opae_object;

	opae_api_adapter_table *adapter_table;

} opae_wrapped_object;

opae_wrapped_object *

opae_allocate_wrapped_object(fpga_object opae_object,

			     opae_api_adapter_table *adapter);

static inline opae_wrapped_object *opae_validate_wrapped_object(fpga_object o)

{

	opae_wrapped_object *wo;

	if (!o)

		return NULL;

	wo = (opae_wrapped_object *)o;

	return (wo->magic == OPAE_WRAPPED_OBJECT_MAGIC) ? wo : NULL;

}

static inline void opae_destroy_wrapped_object(opae_wrapped_object *wo)

{

	wo->magic = 0;

	free(wo);

}

#endif // ___OPAE_OPAE_INT_H__