/*

 * Copyright (c) 2004-2008 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.

 *

 */

/*

 * Abstract:

 *    Implementation of vendor specific transport interface.

 *  This is the "Test" vendor which allows compilation and some

 *  testing without a real vendor interface.

 * These objects are part of the opensm family of objects.

 *

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif				/* HAVE_CONFIG_H */

#ifdef OSM_VENDOR_INTF_TEST

#include <stdlib.h>

#include <string.h>

#include <opensm/osm_log.h>

#include <vendor/osm_vendor_test.h>

#include <vendor/osm_vendor_api.h>

void osm_vendor_construct(IN osm_vendor_t * const p_vend)

{

	memset(p_vend, 0, sizeof(*p_vend));

}

void osm_vendor_destroy(IN osm_vendor_t * const p_vend)

{

	UNUSED_PARAM(p_vend);

}

void osm_vendor_delete(IN osm_vendor_t ** const pp_vend)

{

	CL_ASSERT(pp_vend);

	osm_vendor_destroy(*pp_vend);

	free(*pp_vend);

	*pp_vend = NULL;

}

ib_api_status_t

osm_vendor_init(IN osm_vendor_t * const p_vend,

		IN osm_log_t * const p_log, IN const uint32_t timeout)

{

	OSM_LOG_ENTER(p_log);

	CL_ASSERT(p_vend);

	CL_ASSERT(p_log);

	p_vend->p_log = p_log;

	p_vend->timeout = timeout;

	OSM_LOG_EXIT(p_log);

	return (IB_SUCCESS);

}

osm_vendor_t *osm_vendor_new(IN osm_log_t * const p_log,

			     IN const uint32_t timeout)

{

	ib_api_status_t status;

	osm_vendor_t *p_vend;

	OSM_LOG_ENTER(p_log);

	CL_ASSERT(p_log);

	p_vend = malloc(sizeof(*p_vend));

	if (p_vend != NULL) {

		memset(p_vend, 0, sizeof(*p_vend));

		status = osm_vendor_init(p_vend, p_log, timeout);

		if (status != IB_SUCCESS) {

			osm_vendor_delete(&p_vend);

		}

	}

	OSM_LOG_EXIT(p_log);

	return (p_vend);

}

ib_mad_t *osm_vendor_get(IN osm_bind_handle_t h_bind,

			 IN const uint32_t size,

			 IN osm_vend_wrap_t * const p_vend_wrap)

{

	osm_vendor_t *p_vend;

	ib_mad_t *p_mad;

	OSM_LOG_ENTER(h_bind->p_vend->p_log);

	UNUSED_PARAM(p_vend_wrap);

	p_vend = h_bind->p_vend;

	/*

	   Simply malloc the MAD off the heap.

	 */

	p_mad = (ib_mad_t *) malloc(size);

	osm_log(p_vend->p_log, OSM_LOG_VERBOSE,

		"osm_vendor_get: " "MAD %p.\n", p_mad);

	if (p_mad)

		memset(p_mad, 0, size);

	OSM_LOG_EXIT(p_vend->p_log);

	return (p_mad);

}

void

osm_vendor_put(IN osm_bind_handle_t h_bind,

	       IN osm_vend_wrap_t * const p_vend_wrap,

	       IN ib_mad_t * const p_mad)

{

	osm_vendor_t *p_vend;

	OSM_LOG_ENTER(h_bind->p_vend->p_log);

	UNUSED_PARAM(p_vend_wrap);

	p_vend = h_bind->p_vend;

	osm_log(p_vend->p_log, OSM_LOG_VERBOSE,

		"osm_vendor_put: " "MAD %p.\n", p_mad);

	/*

	   Return the MAD to the heap.

	 */

	free(p_mad);

	OSM_LOG_EXIT(p_vend->p_log);

}

ib_api_status_t

osm_vendor_send(IN osm_bind_handle_t h_bind,

		IN osm_vend_wrap_t * const p_vend_wrap,

		IN osm_mad_addr_t * const p_mad_addr,

		IN ib_mad_t * const p_mad,

		IN void *transaction_context, IN boolean_t const resp_expected)

{

	osm_vendor_t *p_vend = h_bind->p_vend;

	OSM_LOG_ENTER(p_vend->p_log);

	UNUSED_PARAM(p_vend_wrap);

	UNUSED_PARAM(p_mad_addr);

	UNUSED_PARAM(transaction_context);

	UNUSED_PARAM(resp_expected);

	osm_log(p_vend->p_log, OSM_LOG_VERBOSE,

		"osm_vendor_send: " "MAD %p.\n", p_mad);

	OSM_LOG_EXIT(p_vend->p_log);

	return (IB_SUCCESS);

}

osm_bind_handle_t

osm_vendor_bind(IN osm_vendor_t * const p_vend,

		IN osm_bind_info_t * const p_bind_info,

		IN osm_mad_pool_t * const p_mad_pool,

		IN osm_vend_mad_recv_callback_t mad_recv_callback,

		IN void *context)

{

	osm_bind_handle_t h_bind;

	OSM_LOG_ENTER(p_vend->p_log);

	CL_ASSERT(p_vend);

	CL_ASSERT(p_bind_info);

	CL_ASSERT(p_mad_pool);

	CL_ASSERT(mad_recv_callback);

	CL_ASSERT(context);

	UNUSED_PARAM(p_vend);

	UNUSED_PARAM(p_mad_pool);

	UNUSED_PARAM(mad_recv_callback);

	UNUSED_PARAM(context);

	h_bind = (osm_bind_handle_t) malloc(sizeof(*h_bind));

	if (h_bind != NULL) {

		memset(h_bind, 0, sizeof(*h_bind));

		h_bind->p_vend = p_vend;

		h_bind->port_guid = p_bind_info->port_guid;

		h_bind->mad_class = p_bind_info->mad_class;

		h_bind->class_version = p_bind_info->class_version;

		h_bind->is_responder = p_bind_info->is_responder;

		h_bind->is_trap_processor = p_bind_info->is_trap_processor;

		h_bind->is_report_processor = p_bind_info->is_report_processor;

		h_bind->send_q_size = p_bind_info->send_q_size;

		h_bind->recv_q_size = p_bind_info->recv_q_size;

	}

	OSM_LOG_EXIT(p_vend->p_log);

	return (h_bind);

}

ib_api_status_t

osm_vendor_get_ports(IN osm_vendor_t * const p_vend,

		     IN ib_net64_t * const p_guids,

		     IN uint32_t * const num_guids)

{

	OSM_LOG_ENTER(p_vend->p_log);

	*p_guids = CL_NTOH64(0x0000000000001234);

	*num_guids = 1;

	OSM_LOG_EXIT(p_vend->p_log);

	return (IB_SUCCESS);

}

ib_api_status_t osm_vendor_local_lid_change(IN osm_bind_handle_t h_bind)

{

	osm_vendor_t *p_vend = h_bind->p_vend;

	OSM_LOG_ENTER(p_vend->p_log);

	OSM_LOG_EXIT(p_vend->p_log);

	return (IB_SUCCESS);

}

void osm_vendor_set_debug(IN osm_vendor_t * const p_vend, IN int32_t level)

{

}

#endif				/* OSM_VENDOR_INTF_TEST */