/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at
 * http://www.opensource.org/licenses/cddl1.txt.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2004-2012 Emulex. All rights reserved.
 * Use is subject to license terms.
 * Copyright 2020 RackTop Systems, Inc.
 */

#define	DEF_EVENT_STRUCT  /* Needed for emlxs_events.h in emlxs_event.h */
#include <emlxs.h>


/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
EMLXS_MSG_DEF(EMLXS_EVENT_C);


static uint32_t emlxs_event_check(emlxs_port_t *port, emlxs_event_t *evt);
static void emlxs_event_destroy(emlxs_hba_t *hba, emlxs_event_entry_t *entry);

extern void
emlxs_null_func() {}


static uint32_t
emlxs_event_check(emlxs_port_t *port, emlxs_event_t *evt)
{
	emlxs_hba_t *hba = HBA;

	/* Check if the event is being requested */
	if ((hba->event_mask & evt->mask)) {
		return (1);
	}

#ifdef SAN_DIAG_SUPPORT
	if ((port->sd_event_mask & evt->mask)) {
		return (1);
	}
#endif /* SAN_DIAG_SUPPORT */

	return (0);

} /* emlxs_event_check() */


extern uint32_t
emlxs_event_queue_create(emlxs_hba_t *hba)
{
	emlxs_event_queue_t *eventq = &EVENTQ;
	ddi_iblock_cookie_t iblock;

	/* Clear the queue */
	bzero(eventq, sizeof (emlxs_event_queue_t));

	cv_init(&eventq->lock_cv, NULL, CV_DRIVER, NULL);

	if (!(hba->intr_flags & EMLXS_MSI_ENABLED)) {
		/* Get the current interrupt block cookie */
		(void) ddi_get_iblock_cookie(hba->dip, (uint_t)EMLXS_INUMBER,
		    &iblock);

		/* Create the mutex lock */
		mutex_init(&eventq->lock, NULL, MUTEX_DRIVER, (void *)iblock);
	}
#ifdef  MSI_SUPPORT
	else {
		/* Create event mutex lock */
		mutex_init(&eventq->lock, NULL, MUTEX_DRIVER,
		    DDI_INTR_PRI(hba->intr_arg));
	}
#endif

	return (1);

} /* emlxs_event_queue_create() */


extern void
emlxs_event_queue_destroy(emlxs_hba_t *hba)
{
	emlxs_port_t *vport;
	emlxs_event_queue_t *eventq = &EVENTQ;
	uint32_t i;
	uint32_t wakeup = 0;

	mutex_enter(&eventq->lock);

	/* Clear all event masks and broadcast a wakeup */
	/* to clear any sleeping threads */
	if (hba->event_mask) {
		hba->event_mask = 0;
		hba->event_timer = 0;
		wakeup = 1;
	}

	for (i = 0; i < MAX_VPORTS; i++) {
		vport = &VPORT(i);

		if (vport->sd_event_mask) {
			vport->sd_event_mask = 0;
			wakeup = 1;
		}
	}

	if (wakeup) {
		cv_broadcast(&eventq->lock_cv);

		mutex_exit(&eventq->lock);
		BUSYWAIT_MS(10);
		mutex_enter(&eventq->lock);
	}

	/* Destroy the remaining events */
	while (eventq->first) {
		emlxs_event_destroy(hba, eventq->first);
	}

	mutex_exit(&eventq->lock);

	/* Destroy the queue lock */
	mutex_destroy(&eventq->lock);
	cv_destroy(&eventq->lock_cv);

	/* Clear the queue */
	bzero(eventq, sizeof (emlxs_event_queue_t));

	return;

} /* emlxs_event_queue_destroy() */


/* Event queue lock must be held */
static void
emlxs_event_destroy(emlxs_hba_t *hba, emlxs_event_entry_t *entry)
{
	emlxs_event_queue_t *eventq = &EVENTQ;
	emlxs_port_t *port;
	uint32_t missed = 0;

	port = (emlxs_port_t *)entry->port;

	eventq->count--;
	if (eventq->count == 0) {
		eventq->first = NULL;
		eventq->last = NULL;
	} else {
		if (entry->prev) {
			entry->prev->next = entry->next;
		}
		if (entry->next) {
			entry->next->prev = entry->prev;
		}
		if (eventq->first == entry) {
			eventq->first = entry->next;
		}
		if (eventq->last == entry) {
			eventq->last = entry->prev;
		}
	}

	entry->prev = NULL;
	entry->next = NULL;

	if ((entry->evt->mask == EVT_LINK) ||
	    (entry->evt->mask == EVT_RSCN)) {
		if (!(entry->flag & EMLXS_DFC_EVENT_DONE)) {
			hba->hba_event.missed++;
			missed = 1;
		}
	}

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_dequeued_msg,
	    "%s[%d]: flag=%x missed=%d cnt=%d",
	    entry->evt->label, entry->id, entry->flag, missed, eventq->count);

	/* Call notification handler */
	if (entry->evt->destroy != emlxs_null_func) {
		entry->evt->destroy(entry);
	}

	/* Free context buffer */
	if (entry->bp && entry->size) {
		kmem_free(entry->bp, entry->size);
	}

	/* Free entry buffer */
	kmem_free(entry, sizeof (emlxs_event_entry_t));

	return;

} /* emlxs_event_destroy() */


extern void
emlxs_event(emlxs_port_t *port, emlxs_event_t *evt, void *bp, uint32_t size)
{
	emlxs_hba_t *hba = HBA;
	emlxs_event_queue_t *eventq = &EVENTQ;
	emlxs_event_entry_t *entry;
	uint32_t i;
	uint32_t mask;

	if (emlxs_event_check(port, evt) == 0) {
		goto failed;
	}

	/* Create event entry */
	if (!(entry = (emlxs_event_entry_t *)kmem_alloc(
	    sizeof (emlxs_event_entry_t), KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s: Unable to allocate event entry.", evt->label);

		goto failed;
	}

	/* Initialize */
	bzero(entry, sizeof (emlxs_event_entry_t));

	entry->evt = evt;
	entry->port = (void *)port;
	entry->bp = bp;
	entry->size = size;

	mutex_enter(&eventq->lock);

	/* Set the event timer */
	entry->timestamp = hba->timer_tics;
	if (evt->timeout) {
		entry->timer = entry->timestamp + evt->timeout;
	}

	/* Eventq id starts with 1 */
	if (eventq->next_id == 0) {
		eventq->next_id = 1;
	}

	/* Set the event id */
	entry->id = eventq->next_id++;

	/* Set last event table */
	mask = evt->mask;
	for (i = 0; i < 32; i++) {
		if (mask & 0x01) {
			eventq->last_id[i] = entry->id;
		}
		mask >>= 1;
	}

	/* Put event on bottom of queue */
	entry->next = NULL;
	if (eventq->count == 0) {
		entry->prev = NULL;
		eventq->first = entry;
		eventq->last = entry;
	} else {
		entry->prev = eventq->last;
		entry->prev->next = entry;
		eventq->last = entry;
	}
	eventq->count++;

	if ((entry->evt->mask == EVT_LINK) ||
	    (entry->evt->mask == EVT_RSCN)) {
		hba->hba_event.new++;
	}

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_queued_msg,
	    "%s[%d]: bp=%p size=%d cnt=%d", entry->evt->label,
	    entry->id, bp, size, eventq->count);

	/* Broadcast the event */
	cv_broadcast(&eventq->lock_cv);

	mutex_exit(&eventq->lock);

	return;

failed:

	if (bp && size) {
		kmem_free(bp, size);
	}

	return;

} /* emlxs_event() */


extern void
emlxs_timer_check_events(emlxs_hba_t *hba)
{
	emlxs_config_t *cfg = &CFG;
	emlxs_event_queue_t *eventq = &EVENTQ;
	emlxs_event_entry_t *entry;
	emlxs_event_entry_t *next;

	if (!cfg[CFG_TIMEOUT_ENABLE].current) {
		return;
	}

	if ((hba->event_timer > hba->timer_tics)) {
		return;
	}

	if (eventq->count) {
		mutex_enter(&eventq->lock);

		entry = eventq->first;
		while (entry) {
			if ((!entry->timer) ||
			    (entry->timer > hba->timer_tics)) {
				entry = entry->next;
				continue;
			}

			/* Event timed out, destroy it */
			next = entry->next;
			emlxs_event_destroy(hba, entry);
			entry = next;
		}

		mutex_exit(&eventq->lock);
	}

	/* Set next event timer check */
	hba->event_timer = hba->timer_tics + EMLXS_EVENT_PERIOD;

	return;

} /* emlxs_timer_check_events() */


extern void
emlxs_log_rscn_event(emlxs_port_t *port, uint8_t *payload, uint32_t size)
{
	uint8_t *bp;
	uint32_t *ptr;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_rscn_event) == 0) {
		return;
	}

	if (size > MAX_RSCN_PAYLOAD) {
		size = MAX_RSCN_PAYLOAD;
	}

	size += sizeof (uint32_t);

	/* Save a copy of the payload for the event log */
	if (!(bp = (uint8_t *)kmem_alloc(size, KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s: Unable to allocate buffer.", emlxs_rscn_event.label);

		return;
	}

	/*
	 * Buffer Format:
	 *	word[0] = DID of the RSCN
	 *	word[1] = RSCN Payload
	 */
	ptr = (uint32_t *)bp;
	*ptr++ = port->did;
	bcopy(payload, (char *)ptr, (size - sizeof (uint32_t)));

	emlxs_event(port, &emlxs_rscn_event, bp, size);

	return;

} /* emlxs_log_rscn_event() */


extern void
emlxs_log_vportrscn_event(emlxs_port_t *port, uint8_t *payload, uint32_t size)
{
	uint8_t *bp;
	uint8_t *ptr;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_vportrscn_event) == 0) {
		return;
	}

	if (size > MAX_RSCN_PAYLOAD) {
		size = MAX_RSCN_PAYLOAD;
	}

	size += sizeof (NAME_TYPE);

	/* Save a copy of the payload for the event log */
	if (!(bp = (uint8_t *)kmem_alloc(size, KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s: Unable to allocate buffer.",
		    emlxs_vportrscn_event.label);

		return;
	}

	/*
	 * Buffer Format:
	 *	word[0 - 4] = WWPN of the RSCN
	 *	word[5] = RSCN Payload
	 */
	ptr = bp;
	bcopy(&port->wwpn, ptr, sizeof (NAME_TYPE));
	ptr += sizeof (NAME_TYPE);
	bcopy(payload, ptr, (size - sizeof (NAME_TYPE)));

	emlxs_event(port, &emlxs_vportrscn_event, bp, size);

	return;

} /* emlxs_log_vportrscn_event() */


extern uint32_t
emlxs_flush_ct_event(emlxs_port_t *port, uint32_t rxid)
{
	emlxs_hba_t *hba = HBA;
	emlxs_event_queue_t *eventq = &EVENTQ;
	emlxs_event_entry_t *entry;
	uint32_t *ptr;
	uint32_t found = 0;

	mutex_enter(&eventq->lock);

	for (entry = eventq->first; entry != NULL; entry = entry->next) {
		if ((entry->port != port) ||
		    (entry->evt != &emlxs_ct_event)) {
			continue;
		}

		ptr = (uint32_t *)entry->bp;
		if (rxid == *ptr) {
			/* This will prevent a CT exchange abort */
			/* in emlxs_ct_event_destroy() */
			entry->flag |= EMLXS_DFC_EVENT_DONE;

			emlxs_event_destroy(hba, entry);
			found = 1;
			break;
		}
	}

	mutex_exit(&eventq->lock);

	return (found);

} /* emlxs_flush_ct_event() */


extern uint32_t
emlxs_log_ct_event(emlxs_port_t *port, uint8_t *payload, uint32_t size,
    uint32_t rxid)
{
	uint8_t *bp;
	uint32_t *ptr;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_ct_event) == 0) {
		return (1);
	}

	if (size > MAX_CT_PAYLOAD) {
		size = MAX_CT_PAYLOAD;
	}

	size += sizeof (uint32_t);

	/* Save a copy of the payload for the event log */
	if (!(bp = (uint8_t *)kmem_alloc(size, KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s: Unable to allocate buffer.", emlxs_ct_event.label);

		return (1);
	}

	/*
	 * Buffer Format:
	 *	word[0] = RXID tag for outgoing reply to this CT request
	 *	word[1] = CT Payload
	 */
	ptr = (uint32_t *)bp;
	*ptr++ = rxid;
	bcopy(payload, (char *)ptr, (size - sizeof (uint32_t)));

	emlxs_event(port, &emlxs_ct_event, bp, size);

	return (0);

} /* emlxs_log_ct_event() */


extern void
emlxs_ct_event_destroy(emlxs_event_entry_t *entry)
{
	emlxs_port_t *port = (emlxs_port_t *)entry->port;
	emlxs_hba_t *hba = HBA;
	uint32_t rxid;

	if (!(entry->flag & EMLXS_DFC_EVENT_DONE)) {

		rxid = *(uint32_t *)entry->bp;

		/* Abort exchange */
		emlxs_thread_spawn(hba, emlxs_abort_ct_exchange,
		    entry->port, (void *)(unsigned long)rxid);
	}

	return;

} /* emlxs_ct_event_destroy() */


extern void
emlxs_log_link_event(emlxs_port_t *port)
{
	emlxs_hba_t *hba = HBA;
	uint8_t *bp;
	dfc_linkinfo_t *linkinfo;
	uint8_t *byte;
	uint8_t *linkspeed;
	uint8_t *liptype;
	uint8_t *resv1;
	uint8_t *resv2;
	uint32_t size;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_link_event) == 0) {
		return;
	}

	size = sizeof (dfc_linkinfo_t) + sizeof (uint32_t);

	/* Save a copy of the buffer for the event log */
	if (!(bp = (uint8_t *)kmem_alloc(size, KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s: Unable to allocate buffer.", emlxs_link_event.label);

		return;
	}

	/*
	 * Buffer Format:
	 *	word[0] = Linkspeed:8
	 *	word[0] = LIP_type:8
	 *	word[0] = resv1:8
	 *	word[0] = resv2:8
	 *	word[1] = dfc_linkinfo_t data
	 */
	byte = (uint8_t *)bp;
	linkspeed = &byte[0];
	liptype = &byte[1];
	resv1 = &byte[2];
	resv2 = &byte[3];
	linkinfo = (dfc_linkinfo_t *)&byte[4];

	*resv1 = 0;
	*resv2 = 0;

	if (hba->state <= FC_LINK_DOWN) {
		*linkspeed = 0;
		*liptype = 0;
	} else {
		/* Set linkspeed */
		if (hba->linkspeed == LA_2GHZ_LINK) {
			*linkspeed = HBA_PORTSPEED_2GBIT;
		} else if (hba->linkspeed == LA_4GHZ_LINK) {
			*linkspeed = HBA_PORTSPEED_4GBIT;
		} else if (hba->linkspeed == LA_8GHZ_LINK) {
			*linkspeed = HBA_PORTSPEED_8GBIT;
		} else if (hba->linkspeed == LA_10GHZ_LINK) {
			*linkspeed = HBA_PORTSPEED_10GBIT;
		} else if (hba->linkspeed == LA_16GHZ_LINK) {
			*linkspeed = HBA_PORTSPEED_16GBIT;
		} else if (hba->linkspeed == LA_32GHZ_LINK) {
			*linkspeed = HBA_PORTSPEED_32GBIT;
		} else {
			*linkspeed = HBA_PORTSPEED_1GBIT;
		}

		/* Set LIP type */
		*liptype = port->lip_type;
	}

	bzero(linkinfo, sizeof (dfc_linkinfo_t));

	linkinfo->a_linkEventTag = hba->link_event_tag;
	linkinfo->a_linkUp = HBASTATS.LinkUp;
	linkinfo->a_linkDown = HBASTATS.LinkDown;
	linkinfo->a_linkMulti = HBASTATS.LinkMultiEvent;

	if (hba->state <= FC_LINK_DOWN) {
		linkinfo->a_linkState = LNK_DOWN;
		linkinfo->a_DID = port->prev_did;
	} else if (hba->state < FC_READY) {
		linkinfo->a_linkState = LNK_DISCOVERY;
	} else {
		linkinfo->a_linkState = LNK_READY;
	}

	if (linkinfo->a_linkState != LNK_DOWN) {
		if (hba->topology == TOPOLOGY_LOOP) {
			if (hba->flag & FC_FABRIC_ATTACHED) {
				linkinfo->a_topology = LNK_PUBLIC_LOOP;
			} else {
				linkinfo->a_topology = LNK_LOOP;
			}

			linkinfo->a_alpa = port->did & 0xff;
			linkinfo->a_DID = linkinfo->a_alpa;
			linkinfo->a_alpaCnt = port->alpa_map[0];

			if (linkinfo->a_alpaCnt > 127) {
				linkinfo->a_alpaCnt = 127;
			}

			bcopy((void *)&port->alpa_map[1], linkinfo->a_alpaMap,
			    linkinfo->a_alpaCnt);
		} else {
			if (port->node_count == 1) {
				linkinfo->a_topology = LNK_PT2PT;
			} else {
				linkinfo->a_topology = LNK_FABRIC;
			}

			linkinfo->a_DID = port->did;
		}
	}

	bcopy(&hba->wwpn, linkinfo->a_wwpName, 8);
	bcopy(&hba->wwnn, linkinfo->a_wwnName, 8);

	emlxs_event(port, &emlxs_link_event, bp, size);

	return;

} /* emlxs_log_link_event() */


extern void
emlxs_log_dump_event(emlxs_port_t *port, uint8_t *buffer, uint32_t size)
{
	emlxs_hba_t *hba = HBA;
	uint8_t *bp;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_dump_event) == 0) {
#ifdef DUMP_SUPPORT
		/* Schedule a dump thread */
		emlxs_dump(hba, EMLXS_DRV_DUMP, 0, 0);
#endif /* DUMP_SUPPORT */
		return;
	}

	if (buffer && size) {
		/* Save a copy of the buffer for the event log */
		if (!(bp = (uint8_t *)kmem_alloc(size, KM_NOSLEEP))) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
			    "%s: Unable to allocate buffer.",
			    emlxs_dump_event.label);

			return;
		}

		bcopy(buffer, bp, size);
	} else {
		bp = NULL;
		size = 0;
	}

	emlxs_event(port, &emlxs_dump_event, bp, size);

	return;

} /* emlxs_log_dump_event() */


extern void
emlxs_log_temp_event(emlxs_port_t *port, uint32_t type, uint32_t temp)
{
	emlxs_hba_t *hba = HBA;
	uint32_t *bp;
	uint32_t size;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_temp_event) == 0) {
#ifdef DUMP_SUPPORT
		/* Schedule a dump thread */
		emlxs_dump(hba, EMLXS_TEMP_DUMP, type, temp);
#endif /* DUMP_SUPPORT */
		return;
	}

	size = 2 * sizeof (uint32_t);

	if (!(bp = (uint32_t *)kmem_alloc(size, KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s: Unable to allocate buffer.", emlxs_temp_event.label);

		return;
	}

	bp[0] = type;
	bp[1] = temp;

	emlxs_event(port, &emlxs_temp_event, bp, size);

	return;

} /* emlxs_log_temp_event() */



extern void
emlxs_log_fcoe_event(emlxs_port_t *port, menlo_init_rsp_t *init_rsp)
{
	emlxs_hba_t *hba = HBA;
	uint8_t *bp;
	uint32_t size;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_fcoe_event) == 0) {
		return;
	}

	/* Check if this is a FCOE adapter */
	if (hba->model_info.device_id != PCI_DEVICE_ID_HORNET) {
		return;
	}

	size = sizeof (menlo_init_rsp_t);

	if (!(bp = (uint8_t *)kmem_alloc(size, KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s: Unable to allocate buffer.", emlxs_fcoe_event.label);

		return;
	}

	bcopy((uint8_t *)init_rsp, bp, size);

	emlxs_event(port, &emlxs_fcoe_event, bp, size);

	return;

} /* emlxs_log_fcoe_event() */


extern void
emlxs_log_async_event(emlxs_port_t *port, IOCB *iocb)
{
	uint8_t *bp;
	uint32_t size;

	if (emlxs_event_check(port, &emlxs_async_event) == 0) {
		return;
	}

	/* ASYNC_STATUS_CN response size */
	size = 64;

	if (!(bp = (uint8_t *)kmem_alloc(size, KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s: Unable to allocate buffer.", emlxs_async_event.label);

		return;
	}

	bcopy((uint8_t *)iocb, bp, size);

	emlxs_event(port, &emlxs_async_event, bp, size);

	return;

} /* emlxs_log_async_event() */


extern uint32_t
emlxs_get_dfc_eventinfo(emlxs_port_t *port, HBA_EVENTINFO *eventinfo,
    uint32_t *eventcount, uint32_t *missed)
{
	emlxs_hba_t *hba = HBA;
	emlxs_event_queue_t *eventq = &EVENTQ;
	emlxs_event_entry_t *entry;
	uint32_t max_events;
	dfc_linkinfo_t *linkinfo;
	uint32_t *word;
	uint8_t *byte;
	uint8_t linkspeed;
	uint8_t liptype;
	fc_affected_id_t *aid;
	uint32_t events;
	uint8_t format;

	if (!eventinfo || !eventcount || !missed) {
		return (DFC_ARG_NULL);
	}

	max_events = *eventcount;
	*eventcount = 0;
	*missed = 0;

	mutex_enter(&eventq->lock);

	/* Account for missed events */
	if (hba->hba_event.new > hba->hba_event.missed) {
		hba->hba_event.new -= hba->hba_event.missed;
	} else {
		hba->hba_event.new = 0;
	}

	*missed = hba->hba_event.missed;
	hba->hba_event.missed = 0;

	if (!hba->hba_event.new) {
		hba->hba_event.last_id = eventq->next_id - 1;
		mutex_exit(&eventq->lock);
		return (0);
	}

	/* A new event has occurred since last acquisition */

	events = 0;
	entry = eventq->first;
	while (entry && (events < max_events)) {

		/* Skip old events */
		if (entry->id <= hba->hba_event.last_id) {
			entry = entry->next;
			continue;
		}

		/* Process this entry */
		switch (entry->evt->mask) {
		case EVT_LINK:
			byte = (uint8_t *)entry->bp;
			linkspeed = byte[0];
			liptype = byte[1];
			linkinfo = (dfc_linkinfo_t *)&byte[4];

			if (linkinfo->a_linkState == LNK_DOWN) {
				eventinfo->EventCode =
				    HBA_EVENT_LINK_DOWN;
				eventinfo->Event.Link_EventInfo.
				    PortFcId = linkinfo->a_DID;
				eventinfo->Event.Link_EventInfo.
				    Reserved[0] = 0;
				eventinfo->Event.Link_EventInfo.
				    Reserved[1] = 0;
				eventinfo->Event.Link_EventInfo.
				    Reserved[2] = 0;
			} else {
				eventinfo->EventCode =
				    HBA_EVENT_LINK_UP;
				eventinfo->Event.Link_EventInfo.
				    PortFcId = linkinfo->a_DID;

				if ((linkinfo->a_topology ==
				    LNK_PUBLIC_LOOP) ||
				    (linkinfo->a_topology ==
				    LNK_LOOP)) {
					eventinfo->Event.
					    Link_EventInfo.
					    Reserved[0] = 2;
				} else {
					eventinfo->Event.
					    Link_EventInfo.
					    Reserved[0] = 1;
				}

				eventinfo->Event.Link_EventInfo.
				    Reserved[1] = liptype;
				eventinfo->Event.Link_EventInfo.
				    Reserved[2] = linkspeed;
			}

			eventinfo++;
			events++;
			hba->hba_event.new--;
			break;

		case EVT_RSCN:
			word = (uint32_t *)entry->bp;
			eventinfo->EventCode = HBA_EVENT_RSCN;
			eventinfo->Event.RSCN_EventInfo.PortFcId =
			    word[0] & 0xFFFFFF;
			/* word[1] is the RSCN payload command */

			aid = (fc_affected_id_t *)&word[2];
			format = aid->aff_format;

			switch (format) {
			case 0:	/* Port */
				eventinfo->Event.RSCN_EventInfo.
				    NPortPage =
				    aid->aff_d_id & 0x00ffffff;
				break;

			case 1:	/* Area */
				eventinfo->Event.RSCN_EventInfo.
				    NPortPage =
				    aid->aff_d_id & 0x00ffff00;
				break;

			case 2:	/* Domain */
				eventinfo->Event.RSCN_EventInfo.
				    NPortPage =
				    aid->aff_d_id & 0x00ff0000;
				break;

			case 3:	/* Network */
				eventinfo->Event.RSCN_EventInfo.
				    NPortPage = 0;
				break;
			}

			eventinfo->Event.RSCN_EventInfo.Reserved[0] =
			    0;
			eventinfo->Event.RSCN_EventInfo.Reserved[1] =
			    0;

			eventinfo++;
			events++;
			hba->hba_event.new--;
			break;
		}

		hba->hba_event.last_id = entry->id;
		entry = entry->next;
	}

	/* Return number of events acquired */
	*eventcount = events;

	mutex_exit(&eventq->lock);

	return (0);

} /* emlxs_get_dfc_eventinfo() */


void
emlxs_get_dfc_event(emlxs_port_t *port, emlxs_dfc_event_t *dfc_event,
    uint32_t sleep)
{
	emlxs_hba_t *hba = HBA;
	emlxs_event_queue_t *eventq = &EVENTQ;
	emlxs_event_entry_t *entry;
	uint32_t found;
	uint32_t mask;
	uint32_t i;
	uint32_t size = 0;
	uint32_t rc;

	if (dfc_event->dataout && dfc_event->size) {
		size = dfc_event->size;
	}
	dfc_event->size = 0;

	/* Calculate the event index */
	mask = dfc_event->event;
	for (i = 0; i < 32; i++) {
		if (mask & 0x01) {
			break;
		}

		mask >>= 1;
	}

	if (i == 32) {
		return;
	}

	mutex_enter(&eventq->lock);

wait_for_event:

	/* Check if no new event has occurred */
	if (dfc_event->last_id == eventq->last_id[i]) {
		if (!sleep) {
			mutex_exit(&eventq->lock);
			return;
		}

		/* While event is still active and */
		/* no new event has been logged */
		while ((dfc_event->event & hba->event_mask) &&
		    (dfc_event->last_id == eventq->last_id[i])) {

			rc = cv_wait_sig(&eventq->lock_cv, &eventq->lock);

			/* Check if thread was killed by kernel */
			if (rc == 0) {
				dfc_event->pid = 0;
				dfc_event->event = 0;
				mutex_exit(&eventq->lock);
				return;
			}
		}

		/* If the event is no longer registered then */
		/* return immediately */
		if (!(dfc_event->event & hba->event_mask)) {
			mutex_exit(&eventq->lock);
			return;
		}
	}

	/* !!! An event has occurred since last_id !!! */

	/* Check if event data is not being requested */
	if (!size) {
		/* If so, then just return the last event id */
		dfc_event->last_id = eventq->last_id[i];

		mutex_exit(&eventq->lock);
		return;
	}

	/* !!! The requester wants the next event buffer !!! */

	found = 0;
	entry = eventq->first;
	while (entry) {
		if ((entry->id > dfc_event->last_id) &&
		    (entry->evt->mask == dfc_event->event)) {
			found = 1;
			break;
		}

		entry = entry->next;
	}

	if (!found) {
		/* Update last_id to the last known event */
		dfc_event->last_id = eventq->last_id[i];

		/* Try waiting again if we can */
		goto wait_for_event;
	}

	/* !!! Next event found !!! */

	/* Copy the context buffer to the buffer provided */
	if (entry->bp && entry->size) {
		if (entry->size < size) {
			size = entry->size;
		}

		bcopy((void *)entry->bp, dfc_event->dataout, size);

		/* Event has been retrieved by DFCLIB */
		entry->flag |= EMLXS_DFC_EVENT_DONE;

		dfc_event->size = size;
	}

	dfc_event->last_id = entry->id;

	mutex_exit(&eventq->lock);

	return;

} /* emlxs_get_dfc_event() */


uint32_t
emlxs_kill_dfc_event(emlxs_port_t *port, emlxs_dfc_event_t *dfc_event)
{
	emlxs_hba_t *hba = HBA;
	emlxs_event_queue_t *eventq = &EVENTQ;

	mutex_enter(&eventq->lock);
	dfc_event->pid = 0;
	dfc_event->event = 0;
	cv_broadcast(&eventq->lock_cv);
	mutex_exit(&eventq->lock);

	return (0);

} /* emlxs_kill_dfc_event() */


#ifdef SAN_DIAG_SUPPORT
extern void
emlxs_log_sd_basic_els_event(emlxs_port_t *port, uint32_t subcat,
    HBA_WWN *portname, HBA_WWN *nodename)
{
	struct sd_plogi_rcv_v0	*bp;
	uint32_t		size;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_sd_els_event) == 0) {
		return;
	}

	size = sizeof (struct sd_plogi_rcv_v0);

	if (!(bp = (struct sd_plogi_rcv_v0 *)kmem_alloc(size, KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s: Unable to allocate buffer.", emlxs_sd_els_event.label);

		return;
	}

	/*
	 * we are using version field to store subtype, libdfc
	 * will fix this up before returning data to app.
	 */
	bp->sd_plogir_version = subcat;
	bcopy((uint8_t *)portname, (uint8_t *)&bp->sd_plogir_portname,
	    sizeof (HBA_WWN));
	bcopy((uint8_t *)nodename, (uint8_t *)&bp->sd_plogir_nodename,
	    sizeof (HBA_WWN));

	emlxs_event(port, &emlxs_sd_els_event, bp, size);

	return;

} /* emlxs_log_sd_basic_els_event() */


extern void
emlxs_log_sd_prlo_event(emlxs_port_t *port, HBA_WWN *remoteport)
{
	struct sd_prlo_rcv_v0	*bp;
	uint32_t		size;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_sd_els_event) == 0) {
		return;
	}

	size = sizeof (struct sd_prlo_rcv_v0);

	if (!(bp = (struct sd_prlo_rcv_v0 *)kmem_alloc(size,
	    KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s PRLO: Unable to allocate buffer.",
		    emlxs_sd_els_event.label);

		return;
	}

	/*
	 * we are using version field to store subtype, libdfc
	 * will fix this up before returning data to app.
	 */
	bp->sd_prlor_version = SD_ELS_SUBCATEGORY_PRLO_RCV;
	bcopy((uint8_t *)remoteport, (uint8_t *)&bp->sd_prlor_remoteport,
	    sizeof (HBA_WWN));

	emlxs_event(port, &emlxs_sd_els_event, bp, size);

	return;

} /* emlxs_log_sd_prlo_event() */


extern void
emlxs_log_sd_lsrjt_event(emlxs_port_t *port, HBA_WWN *remoteport,
    uint32_t orig_cmd, uint32_t reason, uint32_t reason_expl)
{
	struct sd_lsrjt_rcv_v0	*bp;
	uint32_t		size;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_sd_els_event) == 0) {
		return;
	}

	size = sizeof (struct sd_lsrjt_rcv_v0);

	if (!(bp = (struct sd_lsrjt_rcv_v0 *)kmem_alloc(size,
	    KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s LSRJT: Unable to allocate buffer.",
		    emlxs_sd_els_event.label);

		return;
	}

	/*
	 * we are using version field to store subtype, libdfc
	 * will fix this up before returning data to app.
	 */
	bp->sd_lsrjtr_version = SD_ELS_SUBCATEGORY_LSRJT_RCV;
	bcopy((uint8_t *)remoteport, (uint8_t *)&bp->sd_lsrjtr_remoteport,
	    sizeof (HBA_WWN));
	bp->sd_lsrjtr_original_cmd = orig_cmd;
	bp->sd_lsrjtr_reasoncode = reason;
	bp->sd_lsrjtr_reasoncodeexpl = reason_expl;

	emlxs_event(port, &emlxs_sd_els_event, bp, size);

	return;

} /* emlxs_log_sd_lsrjt_event() */


extern void
emlxs_log_sd_fc_bsy_event(emlxs_port_t *port, HBA_WWN *remoteport)
{
	struct sd_pbsy_rcv_v0	*bp;
	uint32_t		size;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_sd_fabric_event) == 0) {
		return;
	}

	size = sizeof (struct sd_pbsy_rcv_v0);

	if (!(bp = (struct sd_pbsy_rcv_v0 *)kmem_alloc(size,
	    KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s BSY: Unable to allocate buffer.",
		    emlxs_sd_fabric_event.label);

		return;
	}

	/*
	 * we are using version field to store subtype, libdfc
	 * will fix this up before returning data to app.
	 */
	if (remoteport == NULL)
		bp->sd_pbsyr_evt_version = SD_FABRIC_SUBCATEGORY_FABRIC_BUSY;
	else
	{
		bp->sd_pbsyr_evt_version = SD_FABRIC_SUBCATEGORY_PORT_BUSY;
		bcopy((uint8_t *)remoteport, (uint8_t *)&bp->sd_pbsyr_rport,
		    sizeof (HBA_WWN));
	}

	emlxs_event(port, &emlxs_sd_fabric_event, bp, size);

	return;

} /* emlxs_log_sd_fc_bsy_event() */


extern void
emlxs_log_sd_fc_rdchk_event(emlxs_port_t *port, HBA_WWN *remoteport,
    uint32_t lun, uint32_t opcode, uint32_t fcp_param)
{
	struct sd_fcprdchkerr_v0	*bp;
	uint32_t			size;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_sd_fabric_event) == 0) {
		return;
	}

	size = sizeof (struct sd_fcprdchkerr_v0);

	if (!(bp = (struct sd_fcprdchkerr_v0 *)kmem_alloc(size,
	    KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s RDCHK: Unable to allocate buffer.",
		    emlxs_sd_fabric_event.label);

		return;
	}

	/*
	 * we are using version field to store subtype, libdfc
	 * will fix this up before returning data to app.
	 */
	bp->sd_fcprdchkerr_version = SD_FABRIC_SUBCATEGORY_FCPRDCHKERR;
	bcopy((uint8_t *)remoteport, (uint8_t *)&bp->sd_fcprdchkerr_rport,
	    sizeof (HBA_WWN));
	bp->sd_fcprdchkerr_lun = lun;
	bp->sd_fcprdchkerr_opcode = opcode;
	bp->sd_fcprdchkerr_fcpiparam = fcp_param;

	emlxs_event(port, &emlxs_sd_fabric_event, bp, size);

	return;

} /* emlxs_log_sd_rdchk_event() */


extern void
emlxs_log_sd_scsi_event(emlxs_port_t *port, uint32_t type,
    HBA_WWN *remoteport, int32_t lun)
{
	struct sd_scsi_generic_v0	*bp;
	uint32_t			size;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_sd_scsi_event) == 0) {
		return;
	}

	size = sizeof (struct sd_scsi_generic_v0);

	if (!(bp = (struct sd_scsi_generic_v0 *)kmem_alloc(size,
	    KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s: Unable to allocate buffer.",
		    emlxs_sd_scsi_event.label);

		return;
	}

	/*
	 * we are using version field to store subtype, libdfc
	 * will fix this up before returning data to app.
	 */
	bp->sd_scsi_generic_version = type;
	bcopy((uint8_t *)remoteport, (uint8_t *)&bp->sd_scsi_generic_rport,
	    sizeof (HBA_WWN));
	bp->sd_scsi_generic_lun = lun;

	emlxs_event(port, &emlxs_sd_scsi_event, bp, size);

	return;

} /* emlxs_log_sd_scsi_event() */


extern void
emlxs_log_sd_scsi_check_event(emlxs_port_t *port, HBA_WWN *remoteport,
    uint32_t lun, uint32_t cmdcode, uint32_t sensekey,
    uint32_t asc, uint32_t ascq)
{
	struct sd_scsi_checkcond_v0	*bp;
	uint32_t			size;

	/* Check if the event is being requested */
	if (emlxs_event_check(port, &emlxs_sd_scsi_event) == 0) {
		return;
	}

	size = sizeof (struct sd_scsi_checkcond_v0);

	if (!(bp = (struct sd_scsi_checkcond_v0 *)kmem_alloc(size,
	    KM_NOSLEEP))) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_event_debug_msg,
		    "%s CHECK: Unable to allocate buffer.",
		    emlxs_sd_scsi_event.label);

		return;
	}

	/*
	 * we are using version field to store subtype, libdfc
	 * will fix this up before returning data to app.
	 */
	bp->sd_scsi_checkcond_version = SD_SCSI_SUBCATEGORY_CHECKCONDITION;
	bcopy((uint8_t *)remoteport, (uint8_t *)&bp->sd_scsi_checkcond_rport,
	    sizeof (HBA_WWN));
	bp->sd_scsi_checkcond_lun = lun;
	bp->sd_scsi_checkcond_cmdcode = cmdcode;
	bp->sd_scsi_checkcond_sensekey = sensekey;
	bp->sd_scsi_checkcond_asc = asc;
	bp->sd_scsi_checkcond_ascq = ascq;

	emlxs_event(port, &emlxs_sd_scsi_event, bp, size);

	return;

} /* emlxs_log_sd_scsi_check_event() */


void
emlxs_get_sd_event(emlxs_port_t *port, emlxs_dfc_event_t *dfc_event,
    uint32_t sleep)
{
	emlxs_hba_t *hba = HBA;
	emlxs_event_queue_t *eventq = &EVENTQ;
	emlxs_event_entry_t *entry;
	uint32_t found;
	uint32_t mask;
	uint32_t i;
	uint32_t size = 0;
	uint32_t rc;

	if (dfc_event->dataout && dfc_event->size) {
		size = dfc_event->size;
	}
	dfc_event->size = 0;

	/* Calculate the event index */
	mask = dfc_event->event;
	for (i = 0; i < 32; i++) {
		if (mask & 0x01) {
			break;
		}

		mask >>= 1;
	}

	if (i == 32) {
		return;
	}

	mutex_enter(&eventq->lock);

wait_for_event:

	/* Check if no new event has ocurred */
	if (dfc_event->last_id == eventq->last_id[i]) {
		if (!sleep) {
			mutex_exit(&eventq->lock);
			return;
		}

		/* While event is active and no new event has been logged */
		while ((dfc_event->event & port->sd_event_mask) &&
		    (dfc_event->last_id == eventq->last_id[i])) {
			rc = cv_wait_sig(&eventq->lock_cv, &eventq->lock);

			/* Check if thread was killed by kernel */
			if (rc == 0) {
				dfc_event->pid = 0;
				dfc_event->event = 0;
				mutex_exit(&eventq->lock);
				return;
			}
		}

		/* If the event is no longer registered then return */
		if (!(dfc_event->event & port->sd_event_mask)) {
			mutex_exit(&eventq->lock);
			return;
		}
	}

	/* !!! An event has occurred since last_id !!! */

	/* Check if event data is not being requested */
	if (!size) {
		/* If so, then just return the last event id */
		dfc_event->last_id = eventq->last_id[i];

		mutex_exit(&eventq->lock);
		return;
	}

	/* !!! The requester wants the next event buffer !!! */

	found = 0;
	entry = eventq->first;
	while (entry) {
		if ((entry->id > dfc_event->last_id) &&
		    (entry->port == (void *)port) &&
		    (entry->evt->mask == dfc_event->event)) {
			found = 1;
			break;
		}

		entry = entry->next;
	}

	if (!found) {
		/* Update last_id to the last known event */
		dfc_event->last_id = eventq->last_id[i];

		/* Try waiting again if we can */
		goto wait_for_event;
	}

	/* !!! Next event found !!! */

	/* Copy the context buffer to the buffer provided */
	if (entry->bp && entry->size) {
		if (entry->size < size) {
			size = entry->size;
		}

		bcopy((void *)entry->bp, dfc_event->dataout, size);

		/* Event has been retrieved by SANDIAG */
		entry->flag |= EMLXS_SD_EVENT_DONE;

		dfc_event->size = size;
	}

	dfc_event->last_id = entry->id;

	mutex_exit(&eventq->lock);

	return;

} /* emlxs_get_sd_event */
#endif /* SAN_DIAG_SUPPORT */