/*

 * Copyright (c) 2008, Intel Corporation.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU Lesser General Public License,

 * version 2.1, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License

 * for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */

#include "utils.h"

#include "api_lib.h"

#include "adapt_impl.h"

static struct sa_table adapter_table;

static const u_int32_t adapter_handle_offset = 0x100;

#define HBA_SHORT_NAME_LIMIT    64

/*

 * Support for adapter information.

 */

HBA_UINT32

adapter_get_count(void)

{

	return adapter_table.st_limit;

}

/*

 * Get adapter name.

 */

HBA_STATUS

adapter_get_name(HBA_UINT32 index, char *buf)

{

	HBA_STATUS status;

	struct adapter_info *ap;

	status = HBA_STATUS_ERROR_ILLEGAL_INDEX;

	ap = sa_table_lookup(&adapter_table, index);

	if (ap != NULL) {

		snprintf(buf, HBA_SHORT_NAME_LIMIT,

			"%s-%u", ap->ad_name, index);

		status = HBA_STATUS_OK;

	}

	return status;

}

/*

 * Add an adapter to the table.

 */

HBA_STATUS

adapter_create(struct adapter_info *ap)

{

	int index;

	index = sa_table_append(&adapter_table, ap);

	if (index < 0)

		return HBA_STATUS_ERROR;

	ap->ad_index = index;

	return HBA_STATUS_OK;

}

void

adapter_destroy(struct adapter_info *ap)

{

	sa_table_destroy_all(&ap->ad_ports);

	free(ap);

}

void

adapter_destroy_all(void)

{

	struct adapter_info *ap;

	int i;

	for (i = 0; i < adapter_table.st_limit; i++) {

		ap = adapter_table.st_table[i];

		if (ap) {

			adapter_table.st_table[i] = NULL;

			adapter_destroy(ap);

		}

	}

	sa_table_destroy(&adapter_table);

}

struct adapter_info *

adapter_open_handle(HBA_HANDLE handle)

{

	return sa_table_lookup(&adapter_table, handle -

			       adapter_handle_offset);

}

struct port_info *

adapter_get_port(HBA_HANDLE handle, HBA_UINT32 port)

{

	struct adapter_info *ap;

	struct port_info *pp = NULL;

	ap = adapter_open_handle(handle);

	if (ap)

		pp = sa_table_lookup(&ap->ad_ports, port);

	return pp;

}

struct port_info *

adapter_get_rport(HBA_HANDLE handle, HBA_UINT32 port, HBA_UINT32 rport)

{

	struct port_info *pp;

	struct port_info *rp = NULL;

	pp = adapter_get_port(handle, port);

	if (pp) {

		get_rport_info(pp);

		rp = sa_table_lookup(&pp->ap_rports, rport);

	}

	return rp;

}

/*

 * Get the Nth discovered port information.

 */

struct port_info *

adapter_get_rport_n(HBA_HANDLE handle, HBA_UINT32 port, HBA_UINT32 n)

{

	struct port_info *pp;

	struct port_info *rp = NULL;

	pp = adapter_get_port(handle, port);

	if (pp) {

		get_rport_info(pp);

		rp = sa_table_lookup_n(&pp->ap_rports, n);

	}

	return rp;

}

static void *

adapter_target_match(void *rp_arg, void *target_arg)

{

	struct port_info *rp = rp_arg;

	if (rp->ap_scsi_target != *(u_int32_t *)target_arg)

		rp_arg = NULL;

	return rp_arg;

}

/*

 * Get the rport by scsi_target number.

 */

struct port_info *

adapter_get_rport_target(HBA_HANDLE handle, HBA_UINT32 port, HBA_UINT32 n)

{

	struct port_info *pp;

	struct port_info *rp = NULL;

	pp = adapter_get_port(handle, port);

	if (pp) {

		get_rport_info(pp);

		rp = sa_table_search(&pp->ap_rports,

				     adapter_target_match, &n);

	}

	return rp;

}

static void *

adapter_wwpn_match(void *rp_arg, void *wwpn_arg)

{

	struct port_info *rp = rp_arg;

	if (memcmp(&rp->ap_attr.PortWWN, wwpn_arg, sizeof(HBA_WWN)) != 0)

		rp_arg = NULL;

	return rp_arg;

}

struct port_info *

adapter_get_rport_by_wwn(struct port_info *pp, HBA_WWN wwpn)

{

	struct port_info *rp;

	get_rport_info(pp);

	rp = sa_table_search(&pp->ap_rports, adapter_wwpn_match, &wwpn);

	return rp;

}

static void *

adapter_fcid_match(void *rp_arg, void *fcid_arg)

{

	struct port_info *rp = rp_arg;

	if (rp->ap_attr.PortFcId != *(fc_fid_t *)fcid_arg)

		rp_arg = NULL;

	return rp_arg;

}

struct port_info *

adapter_get_rport_by_fcid(struct port_info *pp, fc_fid_t fcid)

{

	struct port_info *rp;

	get_rport_info(pp);

	rp = sa_table_search(&pp->ap_rports, adapter_fcid_match, &fcid);

	return rp;

}

/*

 * Open adapter by name.

 */

HBA_HANDLE

adapter_open(char *name)

{

	char buf[256];

	HBA_HANDLE i;

	HBA_STATUS status;

	for (i = 0; i < adapter_table.st_limit; i++) {

		status = adapter_get_name(i, buf);

		if (status != HBA_STATUS_OK)

			return 0;

		if (!strcmp(buf, name))

			return adapter_handle_offset + i;

	}

	return 0;

}

/*

 * Get port by WWPN.

 * Returns NULL if WWN not unique.

 * If countp is non-NULL, the int it points to will be set to the

 * number found so that the caller can tell if the WWN was ambiguous.

 */

struct port_info *

adapter_get_port_by_wwn(HBA_HANDLE handle, HBA_WWN wwn, int *countp)

{

	struct adapter_info *ap;

	struct port_info *pp_found = NULL;

	struct port_info *pp;

	int count = 0;

	int p;

	ap = adapter_open_handle(handle);

	if (ap != NULL) {

		for (p = 0; p < ap->ad_ports.st_limit; p++) {

			pp = ap->ad_ports.st_table[p];

			if (pp &&

			    !memcmp(&pp->ap_attr.PortWWN, &wwn, sizeof(wwn))) {

				count++;

				pp_found = pp;

			}

		}

	}

	if (count > 1)

		pp_found = NULL;

	if (countp != NULL)

		*countp = count;

	return pp_found;

}

/*

 * Open adapter by WWN.

 */

HBA_STATUS

adapter_open_by_wwn(HBA_HANDLE *phandle, HBA_WWN wwn)

{

	struct adapter_info *ap;

	struct port_info *pp;

	HBA_HANDLE found_handle = 0;

	int count = 0;

	HBA_STATUS status;

	int i;

	int p;

	for (i = 0; i < adapter_table.st_limit; i++) {

		ap = adapter_table.st_table[i];

		if (!ap)

			continue;

		if (memcmp(&ap->ad_attr.NodeWWN, &wwn, sizeof(wwn)) == 0) {

			count++;

			found_handle = ap->ad_index + adapter_handle_offset;

		} else {

			for (p = 0; p < ap->ad_ports.st_limit; p++) {

				pp = ap->ad_ports.st_table[p];

				if (!pp)

					continue;

				if (memcmp(&pp->ap_attr.PortWWN,

					   &wwn, sizeof(wwn)) == 0) {

					count++;

					found_handle = ap->ad_index +

						       adapter_handle_offset;

				}

			}

		}

	}

	*phandle = HBA_HANDLE_INVALID;

	if (count == 1) {

		status = HBA_STATUS_OK;

		*phandle = found_handle;

	} else if (count > 1) {

		status = HBA_STATUS_ERROR_AMBIGUOUS_WWN;

	} else {

		status = HBA_STATUS_ERROR_ILLEGAL_WWN;

	}

	return status;

}

/*

 * Close adapter.

 */

void

adapter_close(HBA_HANDLE handle)

{

}

/*

 * Get adapter attributes.

 */

HBA_STATUS

adapter_get_attr(HBA_HANDLE handle, HBA_ADAPTERATTRIBUTES *pattr)

{

	struct adapter_info *ap;

	ap = adapter_open_handle(handle);

	if (ap) {

		*pattr = ap->ad_attr;       /* struct copy */

		return HBA_STATUS_OK;

	}

	return HBA_STATUS_ERROR;

}

/*

 * Get adapter port attributes.

 */

HBA_STATUS

adapter_get_port_attr(HBA_HANDLE handle, HBA_UINT32 port,

			HBA_PORTATTRIBUTES *pattr)

{

	struct port_info *pp;

	pp = adapter_get_port(handle, port);

	if (pp) {

		*pattr = pp->ap_attr;       /* struct copy */

		return HBA_STATUS_OK;

	}

	return HBA_STATUS_ERROR;

}

/*

 * Get discovered (remote) port attributes.

 */

HBA_STATUS

adapter_get_rport_attr(HBA_HANDLE handle, HBA_UINT32 port, HBA_UINT32 rport,

			 HBA_PORTATTRIBUTES *pattr)

{

	struct port_info *rp;

	rp = adapter_get_rport_n(handle, port, rport);

	if (rp) {

		*pattr = rp->ap_attr;       /* struct copy */

		return HBA_STATUS_OK;

	}

	return HBA_STATUS_ERROR;

}

/*

 * Get adapter port attributes.

 */

HBA_STATUS

adapter_get_port_attr_by_wwn(HBA_HANDLE handle, HBA_WWN wwn,

			       HBA_PORTATTRIBUTES *pattr)

{

	struct adapter_info *ap;

	struct port_info *pp;

	struct port_info *pp_found = NULL;

	u_int32_t p;

	int count = 0;

	HBA_STATUS status;

	ap = adapter_open_handle(handle);

	if (ap != NULL) {

		for (p = 0; p < ap->ad_ports.st_limit; p++) {

			pp = ap->ad_ports.st_table[p];

			if (pp == NULL)

				continue;

			if (!memcmp(&pp->ap_attr.PortWWN, &wwn, sizeof(wwn))) {

				count++;

				pp_found = pp;

			}

			pp = sa_table_search(&pp->ap_rports,

					     adapter_wwpn_match,

					     &wwn);

			if (pp) {

				count++;

				pp_found = pp;

			}

		}

	}

	pp = pp_found;

	if (pp != NULL) {

		if (count > 1) {

			status = HBA_STATUS_ERROR_AMBIGUOUS_WWN;

		} else {

			*pattr = pp->ap_attr;       /* struct copy */

			status = HBA_STATUS_OK;

		}

	} else {

		status = HBA_STATUS_ERROR_ILLEGAL_WWN;

	}

	return status;

}