/*

 * Copyright (c) 2004-2009 Voltaire, Inc. All rights reserved.

 * Copyright (c) 2002-2005 Mellanox Technologies LTD. All rights reserved.

 * Copyright (c) 1996-2003 Intel Corporation. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

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

 *

 * 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 AUTHORS 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 IN THE

 * SOFTWARE.

 *

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif				/* HAVE_CONFIG_H */

#include <complib/cl_event.h>

#include <complib/cl_debug.h>

#include <sys/time.h>

#include <sys/errno.h>

void cl_event_construct(IN cl_event_t * p_event)

{

	CL_ASSERT(p_event);

	p_event->state = CL_UNINITIALIZED;

}

cl_status_t cl_event_init(IN cl_event_t * const p_event,

			  IN const boolean_t manual_reset)

{

	CL_ASSERT(p_event);

	cl_event_construct(p_event);

	pthread_cond_init(&p_event->condvar, NULL);

	pthread_mutex_init(&p_event->mutex, NULL);

	p_event->signaled = FALSE;

	p_event->manual_reset = manual_reset;

	p_event->state = CL_INITIALIZED;

	return CL_SUCCESS;

}

void cl_event_destroy(IN cl_event_t * const p_event)

{

	CL_ASSERT(cl_is_state_valid(p_event->state));

	/* Destroy only if the event was constructed */

	if (p_event->state == CL_INITIALIZED) {

		pthread_cond_broadcast(&p_event->condvar);

		pthread_cond_destroy(&p_event->condvar);

		pthread_mutex_destroy(&p_event->mutex);

	}

	p_event->state = CL_UNINITIALIZED;

}

cl_status_t cl_event_signal(IN cl_event_t * const p_event)

{

	/* Make sure that the event was started */

	CL_ASSERT(p_event->state == CL_INITIALIZED);

	pthread_mutex_lock(&p_event->mutex);

	p_event->signaled = TRUE;

	/* Wake up one or all depending on whether the event is auto-resetting. */

	if (p_event->manual_reset)

		pthread_cond_broadcast(&p_event->condvar);

	else

		pthread_cond_signal(&p_event->condvar);

	pthread_mutex_unlock(&p_event->mutex);

	return CL_SUCCESS;

}

cl_status_t cl_event_reset(IN cl_event_t * const p_event)

{

	/* Make sure that the event was started */

	CL_ASSERT(p_event->state == CL_INITIALIZED);

	pthread_mutex_lock(&p_event->mutex);

	p_event->signaled = FALSE;

	pthread_mutex_unlock(&p_event->mutex);

	return CL_SUCCESS;

}

cl_status_t cl_event_wait_on(IN cl_event_t * const p_event,

			     IN const uint32_t wait_us,

			     IN const boolean_t interruptible)

{

	cl_status_t status;

	int wait_ret;

	struct timespec timeout;

	struct timeval curtime;

	/* Make sure that the event was Started */

	CL_ASSERT(p_event->state == CL_INITIALIZED);

	pthread_mutex_lock(&p_event->mutex);

	/* Return immediately if the event is signalled. */

	if (p_event->signaled) {

		if (!p_event->manual_reset)

			p_event->signaled = FALSE;

		pthread_mutex_unlock(&p_event->mutex);

		return CL_SUCCESS;

	}

	/* If just testing the state, return CL_TIMEOUT. */

	if (wait_us == 0) {

		pthread_mutex_unlock(&p_event->mutex);

		return CL_TIMEOUT;

	}

	if (wait_us == EVENT_NO_TIMEOUT) {

		/* Wait for condition variable to be signaled or broadcast. */

		if (pthread_cond_wait(&p_event->condvar, &p_event->mutex))

			status = CL_NOT_DONE;

		else

			status = CL_SUCCESS;

	} else {

		/* Get the current time */

		if (gettimeofday(&curtime, NULL) == 0) {

			unsigned long n_sec =

			    (curtime.tv_usec + (wait_us % 1000000)) * 1000;

			timeout.tv_sec = curtime.tv_sec + (wait_us / 1000000)

			    + (n_sec / 1000000000);

			timeout.tv_nsec = n_sec % 1000000000;

			wait_ret = pthread_cond_timedwait(&p_event->condvar,

							  &p_event->mutex,

							  &timeout);

			if (wait_ret == 0)

				status =

				    (p_event->

				     signaled ? CL_SUCCESS : CL_NOT_DONE);

			else if (wait_ret == ETIMEDOUT)

				status = CL_TIMEOUT;

			else

				status = CL_NOT_DONE;

		} else

			status = CL_ERROR;

	}

	if (!p_event->manual_reset)

		p_event->signaled = FALSE;

	pthread_mutex_unlock(&p_event->mutex);

	return status;

}