xref: /illumos-gate/usr/src/uts/common/io/fibre-channel/fca/emlxs/emlxs_mem.c (revision a3170057)

/*
 * 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-2011 Emulex. All rights reserved.
 * Use is subject to license terms.
 * Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
 * Copyright 2020 RackTop Systems, Inc.
 */

#include <emlxs.h>

/* #define EMLXS_POOL_DEBUG */

EMLXS_MSG_DEF(EMLXS_MEM_C);


static uint32_t emlxs_mem_pool_alloc(emlxs_hba_t *hba, MEMSEG *seg,
			uint32_t count);
static void emlxs_mem_pool_free(emlxs_hba_t *hba, MEMSEG *seg, uint32_t count);


extern int32_t
emlxs_mem_alloc_buffer(emlxs_hba_t *hba)
{
	emlxs_port_t *port = &PPORT;
	emlxs_config_t *cfg;
	MBUF_INFO *buf_info;
	MEMSEG *seg;
	MBUF_INFO bufinfo;
	int32_t i;
	MATCHMAP *mp;
	MATCHMAP **bpl_table;

	buf_info = &bufinfo;
	cfg = &CFG;

	bzero(hba->memseg, sizeof (hba->memseg));

	/* Allocate the fc_table */
	bzero(buf_info, sizeof (MBUF_INFO));
	buf_info->size = (hba->max_iotag * sizeof (emlxs_buf_t *));

	(void) emlxs_mem_alloc(hba, buf_info);
	if (buf_info->virt == NULL) {

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg,
		    "fc_table buffer.");

		goto failed;
	}
	hba->fc_table = buf_info->virt;
	bzero(hba->fc_table, buf_info->size);

	/* Prepare the memory pools */
	for (i = 0; i < FC_MAX_SEG; i++) {
		seg = &hba->memseg[i];

		switch (i) {
		case MEM_NLP:
			(void) strlcpy(seg->fc_label, "Node Pool",
			    sizeof (seg->fc_label));
			seg->fc_memtag	= MEM_NLP;
			seg->fc_memsize	= sizeof (NODELIST);
			seg->fc_hi_water = hba->max_nodes + 2;
			seg->fc_lo_water = 2;
			seg->fc_step = 1;
			break;

		case MEM_IOCB:
			(void) strlcpy(seg->fc_label, "IOCB Pool",
			    sizeof (seg->fc_label));
			seg->fc_memtag	= MEM_IOCB;
			seg->fc_memsize	= sizeof (IOCBQ);
			seg->fc_hi_water = cfg[CFG_NUM_IOCBS].current;
			seg->fc_lo_water = cfg[CFG_NUM_IOCBS].low;
			seg->fc_step = cfg[CFG_NUM_IOCBS].low;
			break;

		case MEM_MBOX:
			(void) strlcpy(seg->fc_label, "MBOX Pool",
			    sizeof (seg->fc_label));
			seg->fc_memtag	= MEM_MBOX;
			seg->fc_memsize	= sizeof (MAILBOXQ);
			seg->fc_hi_water = hba->max_nodes + 32;
			seg->fc_lo_water = 32;
			seg->fc_step = 1;
			break;

		case MEM_BPL:
			if (hba->model_info.sli_mask & EMLXS_SLI4_MASK) {
				continue;
			}
			(void) strlcpy(seg->fc_label, "BPL Pool",
			    sizeof (seg->fc_label));
			seg->fc_memtag	= MEM_BPL;
			seg->fc_memsize	= hba->sli.sli3.mem_bpl_size;
			seg->fc_memflag	= FC_MBUF_DMA | FC_MBUF_SNGLSG;
			seg->fc_memalign = 32;
			seg->fc_hi_water = hba->max_iotag;
			seg->fc_lo_water = cfg[CFG_NUM_IOCBS].low;
			seg->fc_step = cfg[CFG_NUM_IOCBS].low;
			break;

		case MEM_BUF:
			/* These are the unsolicited ELS buffers. */
			(void) strlcpy(seg->fc_label, "BUF Pool",
			    sizeof (seg->fc_label));
			seg->fc_memtag	= MEM_BUF;
			seg->fc_memsize	= MEM_BUF_SIZE;
			seg->fc_memflag	= FC_MBUF_DMA | FC_MBUF_SNGLSG;
			seg->fc_memalign = 32;
			seg->fc_hi_water = MEM_ELSBUF_COUNT + MEM_BUF_COUNT;
			seg->fc_lo_water = MEM_ELSBUF_COUNT;
			seg->fc_step = 1;
			break;

		case MEM_IPBUF:
			/* These are the unsolicited IP buffers. */
			if (cfg[CFG_NETWORK_ON].current == 0) {
				continue;
			}

			(void) strlcpy(seg->fc_label, "IPBUF Pool",
			    sizeof (seg->fc_label));
			seg->fc_memtag	= MEM_IPBUF;
			seg->fc_memsize	= MEM_IPBUF_SIZE;
			seg->fc_memflag	= FC_MBUF_DMA | FC_MBUF_SNGLSG;
			seg->fc_memalign = 32;
			seg->fc_hi_water = MEM_IPBUF_COUNT;
			seg->fc_lo_water = 0;
			seg->fc_step = 4;
			break;

		case MEM_CTBUF:
			/* These are the unsolicited CT buffers. */
			(void) strlcpy(seg->fc_label, "CTBUF Pool",
			    sizeof (seg->fc_label));
			seg->fc_memtag	= MEM_CTBUF;
			seg->fc_memsize	= MEM_CTBUF_SIZE;
			seg->fc_memflag	= FC_MBUF_DMA | FC_MBUF_SNGLSG;
			seg->fc_memalign = 32;
			seg->fc_hi_water = MEM_CTBUF_COUNT;
			seg->fc_lo_water = MEM_CTBUF_COUNT;
			seg->fc_step = 1;
			break;

		case MEM_SGL1K:
			(void) strlcpy(seg->fc_label, "1K SGL Pool",
			    sizeof (seg->fc_label));
			seg->fc_memtag	= MEM_SGL1K;
			seg->fc_memsize	= 0x400;
			seg->fc_memflag	= FC_MBUF_DMA | FC_MBUF_SNGLSG;
			seg->fc_memalign = 32;
			seg->fc_hi_water = 0x5000;
			seg->fc_lo_water = 0;
			seg->fc_step = 0x100;
			break;

		case MEM_SGL2K:
			(void) strlcpy(seg->fc_label, "2K SGL Pool",
			    sizeof (seg->fc_label));
			seg->fc_memtag	= MEM_SGL2K;
			seg->fc_memsize	= 0x800;
			seg->fc_memflag	= FC_MBUF_DMA | FC_MBUF_SNGLSG;
			seg->fc_memalign = 32;
			seg->fc_hi_water = 0x5000;
			seg->fc_lo_water = 0;
			seg->fc_step = 0x100;
			break;

		case MEM_SGL4K:
			(void) strlcpy(seg->fc_label, "4K SGL Pool",
			    sizeof (seg->fc_label));
			seg->fc_memtag	= MEM_SGL4K;
			seg->fc_memsize	= 0x1000;
			seg->fc_memflag	= FC_MBUF_DMA | FC_MBUF_SNGLSG;
			seg->fc_memalign = 32;
			seg->fc_hi_water = 0x5000;
			seg->fc_lo_water = 0;
			seg->fc_step = 0x100;
			break;

#ifdef SFCT_SUPPORT
		case MEM_FCTBUF:
			/* These are the unsolicited FCT buffers. */
			if (!(port->flag & EMLXS_TGT_ENABLED)) {
				continue;
			}

			(void) strlcpy(seg->fc_label, "FCTBUF Pool",
			    sizeof (seg->fc_label));
			seg->fc_memtag	= MEM_FCTBUF;
			seg->fc_memsize	= MEM_FCTBUF_SIZE;
			seg->fc_memflag	= FC_MBUF_DMA | FC_MBUF_SNGLSG;
			seg->fc_memalign = 32;
			seg->fc_hi_water = MEM_FCTBUF_COUNT;
			seg->fc_lo_water = 0;
			seg->fc_step = 8;
			break;
#endif /* SFCT_SUPPORT */

		default:
			continue;
		}

		if (seg->fc_memsize == 0) {
			continue;
		}

		(void) emlxs_mem_pool_create(hba, seg);

		if (seg->fc_numblks < seg->fc_lo_water) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg,
			    "%s: count=%d size=%d flags=%x lo=%d hi=%d",
			    seg->fc_label, seg->fc_numblks,
			    seg->fc_memsize, seg->fc_memflag, seg->fc_lo_water,
			    seg->fc_hi_water);

			goto failed;
		}
	}

	hba->sli.sli3.bpl_table = NULL;
	seg = &hba->memseg[MEM_BPL];

	/* If SLI3 and MEM_BPL pool is static */
	if (!(hba->model_info.sli_mask & EMLXS_SLI4_MASK) &&
	    !(seg->fc_memflag & FC_MEMSEG_DYNAMIC)) {
		/*
		 * Allocate and Initialize bpl_table
		 * This is for increased performance.
		 */
		bzero(buf_info, sizeof (MBUF_INFO));
		buf_info->size = hba->max_iotag * sizeof (MATCHMAP *);

		(void) emlxs_mem_alloc(hba, buf_info);
		if (buf_info->virt == NULL) {

			EMLXS_MSGF(EMLXS_CONTEXT,
			    &emlxs_mem_alloc_failed_msg,
			    "BPL table buffer.");

			goto failed;
		}
		hba->sli.sli3.bpl_table = buf_info->virt;

		bpl_table = (MATCHMAP**)hba->sli.sli3.bpl_table;
		for (i = 0; i < hba->max_iotag; i++) {
			mp = (MATCHMAP *) emlxs_mem_get(hba, MEM_BPL);
			mp->flag |= MAP_TABLE_ALLOCATED;
			bpl_table[i] = mp;
		}
	}

	return (1);

failed:

	(void) emlxs_mem_free_buffer(hba);
	return (0);

} /* emlxs_mem_alloc_buffer() */


/*
 * emlxs_mem_free_buffer
 *
 * This routine will free iocb/data buffer space
 * and TGTM resource.
 */
extern int
emlxs_mem_free_buffer(emlxs_hba_t *hba)
{
	emlxs_port_t *port = &PPORT;
	emlxs_port_t *vport;
	int32_t j;
	MATCHMAP *mp;
	CHANNEL *cp;
	RING *rp;
	MBUF_INFO *buf_info;
	MBUF_INFO bufinfo;
	MATCHMAP **bpl_table;

	buf_info = &bufinfo;

	for (j = 0; j < hba->chan_count; j++) {
		cp = &hba->chan[j];

		/* Flush the ring */
		(void) emlxs_tx_channel_flush(hba, cp, 0);
	}

	if (!(hba->model_info.sli_mask & EMLXS_SLI4_MASK)) {
		/* free the mapped address match area for each ring */
		for (j = 0; j < MAX_RINGS; j++) {
			rp = &hba->sli.sli3.ring[j];

			while (rp->fc_mpoff) {
				uint64_t addr;

				addr = 0;
				mp = (MATCHMAP *)(rp->fc_mpoff);

				if ((j == hba->channel_els) ||
				    (j == hba->channel_ct) ||
#ifdef SFCT_SUPPORT
				    (j == hba->CHANNEL_FCT) ||
#endif /* SFCT_SUPPORT */
				    (j == hba->channel_ip)) {
					addr = mp->phys;
				}

				if ((mp = emlxs_mem_get_vaddr(hba, rp, addr))) {
					if (j == hba->channel_els) {
						emlxs_mem_put(hba,
						    MEM_ELSBUF, (void *)mp);
					} else if (j == hba->channel_ct) {
						emlxs_mem_put(hba,
						    MEM_CTBUF, (void *)mp);
					} else if (j == hba->channel_ip) {
						emlxs_mem_put(hba,
						    MEM_IPBUF, (void *)mp);
					}
#ifdef SFCT_SUPPORT
					else if (j == hba->CHANNEL_FCT) {
						emlxs_mem_put(hba,
						    MEM_FCTBUF, (void *)mp);
					}
#endif /* SFCT_SUPPORT */

				}
			}
		}
	}

	if (hba->flag & FC_HBQ_ENABLED) {
		emlxs_hbq_free_all(hba, EMLXS_ELS_HBQ_ID);
		emlxs_hbq_free_all(hba, EMLXS_IP_HBQ_ID);
		emlxs_hbq_free_all(hba, EMLXS_CT_HBQ_ID);

		if (port->flag & EMLXS_TGT_ENABLED) {
			emlxs_hbq_free_all(hba, EMLXS_FCT_HBQ_ID);
		}
	}

	/* Free the nodes */
	for (j = 0; j < MAX_VPORTS; j++) {
		vport = &VPORT(j);
		if (vport->node_count) {
			emlxs_node_destroy_all(vport);
		}
	}

	/* Make sure the mailbox queue is empty */
	emlxs_mb_flush(hba);

	if (hba->fc_table) {
		bzero(buf_info, sizeof (MBUF_INFO));
		buf_info->size = hba->max_iotag * sizeof (emlxs_buf_t *);
		buf_info->virt = hba->fc_table;
		emlxs_mem_free(hba, buf_info);
		hba->fc_table = NULL;
	}

	if (hba->sli.sli3.bpl_table) {
		/* Return MEM_BPLs to their pool */
		bpl_table = (MATCHMAP**)hba->sli.sli3.bpl_table;
		for (j = 0; j < hba->max_iotag; j++) {
			mp = bpl_table[j];
			mp->flag &= ~MAP_TABLE_ALLOCATED;
			emlxs_mem_put(hba, MEM_BPL, (void*)mp);
		}

		bzero(buf_info, sizeof (MBUF_INFO));
		buf_info->size = hba->max_iotag * sizeof (MATCHMAP *);
		buf_info->virt = hba->sli.sli3.bpl_table;
		emlxs_mem_free(hba, buf_info);
		hba->sli.sli3.bpl_table = NULL;
	}

	/* Free the memory segments */
	for (j = 0; j < FC_MAX_SEG; j++) {
		emlxs_mem_pool_destroy(hba, &hba->memseg[j]);
	}

	return (0);

} /* emlxs_mem_free_buffer() */


/* Must hold EMLXS_MEMGET_LOCK when calling */
static uint32_t
emlxs_mem_pool_alloc(emlxs_hba_t *hba, MEMSEG *seg, uint32_t count)
{
	emlxs_port_t *port = &PPORT;
	uint8_t *bp = NULL;
	MATCHMAP *mp = NULL;
	MBUF_INFO *buf_info;
	MBUF_INFO local_buf_info;
	uint32_t i;
	uint32_t fc_numblks;

	if (seg->fc_memsize == 0) {
		return (0);
	}

	if (seg->fc_numblks >= seg->fc_hi_water) {
		return (0);
	}

	if (count == 0) {
		return (0);
	}

	if (count > (seg->fc_hi_water - seg->fc_numblks)) {
		count = (seg->fc_hi_water - seg->fc_numblks);
	}

	buf_info = &local_buf_info;
	fc_numblks = seg->fc_numblks;

	/* Check for initial allocation */
	if (!(seg->fc_memflag & FC_MEMSEG_PUT_ENABLED)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_detail_msg,
		    "%s alloc:%d n=%d s=%d f=%x l=%d,%d,%d "
		    "f=%d:%d",
		    seg->fc_label, count, seg->fc_numblks,
		    seg->fc_memsize, seg->fc_memflag, seg->fc_lo_water,
		    seg->fc_hi_water, seg->fc_step, seg->fc_memget_cnt,
		    seg->fc_low);
	}

	if (!(seg->fc_memflag & FC_MBUF_DMA)) {
		goto vmem_pool;
	}

/* dma_pool */

	for (i = 0; i < count; i++) {
		bzero(buf_info, sizeof (MBUF_INFO));
		buf_info->size = sizeof (MATCHMAP);
		buf_info->align = sizeof (void *);

		(void) emlxs_mem_alloc(hba, buf_info);
		if (buf_info->virt == NULL) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg,
			    "%s: count=%d size=%d",
			    seg->fc_label, seg->fc_numblks, seg->fc_memsize);

			goto done;
		}

		mp = (MATCHMAP *)buf_info->virt;
		bzero(mp, sizeof (MATCHMAP));

		bzero(buf_info, sizeof (MBUF_INFO));
		buf_info->size  = seg->fc_memsize;
		buf_info->flags = seg->fc_memflag;
		buf_info->align = seg->fc_memalign;

		(void) emlxs_mem_alloc(hba, buf_info);
		if (buf_info->virt == NULL) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg,
			    "%s: count=%d size=%d",
			    seg->fc_label, seg->fc_numblks, seg->fc_memsize);

			/* Free the mp object */
			bzero(buf_info, sizeof (MBUF_INFO));
			buf_info->size = sizeof (MATCHMAP);
			buf_info->virt = (void *)mp;
			emlxs_mem_free(hba, buf_info);

			goto done;
		}
		bp = (uint8_t *)buf_info->virt;
		bzero(bp, seg->fc_memsize);

		mp->virt = buf_info->virt;
		mp->phys = buf_info->phys;
		mp->size = buf_info->size;
		mp->dma_handle = buf_info->dma_handle;
		mp->data_handle = buf_info->data_handle;
		mp->tag = seg->fc_memtag;
		mp->segment = seg;
		mp->flag |= MAP_POOL_ALLOCATED;

#ifdef SFCT_SUPPORT
		if (mp->tag >= MEM_FCTSEG) {
			if (emlxs_fct_stmf_alloc(hba, mp)) {
				/* Free the DMA memory itself */
				emlxs_mem_free(hba, buf_info);

				/* Free the mp object */
				bzero(buf_info, sizeof (MBUF_INFO));
				buf_info->size = sizeof (MATCHMAP);
				buf_info->virt = (void *)mp;
				emlxs_mem_free(hba, buf_info);

				goto done;
			}
		}
#endif /* SFCT_SUPPORT */

		/* Add the buffer desc to the tail of the pool freelist */
		if (seg->fc_memget_end == NULL) {
			seg->fc_memget_ptr = (uint8_t *)mp;
			seg->fc_memget_cnt = 1;
		} else {
			*((uint8_t **)(seg->fc_memget_end)) = (uint8_t *)mp;
			seg->fc_memget_cnt++;
		}
		seg->fc_memget_end = (uint8_t *)mp;

		seg->fc_numblks++;
		seg->fc_total_memsize += (seg->fc_memsize + sizeof (MATCHMAP));
	}

	goto done;

vmem_pool:

	for (i = 0; i < count; i++) {
		bzero(buf_info, sizeof (MBUF_INFO));
		buf_info->size  = seg->fc_memsize;

		(void) emlxs_mem_alloc(hba, buf_info);
		if (buf_info->virt == NULL) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg,
			    "%s: count=%d size=%d",
			    seg->fc_label, seg->fc_numblks, seg->fc_memsize);

			goto done;
		}
		bp = (uint8_t *)buf_info->virt;

		/* Add the buffer to the tail of the pool freelist */
		if (seg->fc_memget_end == NULL) {
			seg->fc_memget_ptr = (uint8_t *)bp;
			seg->fc_memget_cnt = 1;
		} else {
			*((uint8_t **)(seg->fc_memget_end)) = (uint8_t *)bp;
			seg->fc_memget_cnt++;
		}
		seg->fc_memget_end = (uint8_t *)bp;

		seg->fc_numblks++;
		seg->fc_total_memsize += seg->fc_memsize;
	}

done:

	return ((seg->fc_numblks - fc_numblks));

} /* emlxs_mem_pool_alloc() */


/* Must hold EMLXS_MEMGET_LOCK & EMLXS_MEMPUT_LOCK when calling */
static void
emlxs_mem_pool_free(emlxs_hba_t *hba, MEMSEG *seg, uint32_t count)
{
	emlxs_port_t *port = &PPORT;
	uint8_t *bp = NULL;
	MATCHMAP *mp = NULL;
	MBUF_INFO *buf_info;
	MBUF_INFO local_buf_info;

	if ((seg->fc_memsize == 0) ||
	    (seg->fc_numblks == 0) ||
	    (count == 0)) {
		return;
	}

	/* Check max count */
	if (count > seg->fc_numblks) {
		count = seg->fc_numblks;
	}

	/* Move memput list to memget list */
	if (seg->fc_memput_ptr) {
		if (seg->fc_memget_end == NULL) {
			seg->fc_memget_ptr = seg->fc_memput_ptr;
		} else {
			*((uint8_t **)(seg->fc_memget_end)) =\
			    seg->fc_memput_ptr;
		}
		seg->fc_memget_end = seg->fc_memput_end;
		seg->fc_memget_cnt += seg->fc_memput_cnt;

		seg->fc_memput_ptr = NULL;
		seg->fc_memput_end = NULL;
		seg->fc_memput_cnt = 0;
	}

	buf_info = &local_buf_info;

	/* Check for final deallocation */
	if (!(seg->fc_memflag & FC_MEMSEG_GET_ENABLED)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_detail_msg,
		    "%s free:%d n=%d s=%d f=%x l=%d,%d,%d "
		    "f=%d:%d",
		    seg->fc_label, count, seg->fc_numblks,
		    seg->fc_memsize, seg->fc_memflag, seg->fc_lo_water,
		    seg->fc_hi_water, seg->fc_step, seg->fc_memget_cnt,
		    seg->fc_low);
	}

	if (!(seg->fc_memflag & FC_MBUF_DMA)) {
		goto vmem_pool;
	}

dma_pool:

	/* Free memory associated with all buffers on get buffer pool */
	while (count && ((bp = seg->fc_memget_ptr) != NULL)) {
		/* Remove buffer from list */
		if (seg->fc_memget_end == bp) {
			seg->fc_memget_ptr = NULL;
			seg->fc_memget_end = NULL;
			seg->fc_memget_cnt = 0;

		} else {
			seg->fc_memget_ptr = *((uint8_t **)bp);
			seg->fc_memget_cnt--;
		}
		mp = (MATCHMAP *)bp;

#ifdef SFCT_SUPPORT
		if (mp->tag >= MEM_FCTSEG) {
			emlxs_fct_stmf_free(hba, mp);
		}
#endif /* SFCT_SUPPORT */

		/* Free the DMA memory itself */
		bzero(buf_info, sizeof (MBUF_INFO));
		buf_info->size = mp->size;
		buf_info->virt = mp->virt;
		buf_info->phys = mp->phys;
		buf_info->dma_handle = mp->dma_handle;
		buf_info->data_handle = mp->data_handle;
		buf_info->flags = seg->fc_memflag;
		emlxs_mem_free(hba, buf_info);

		/* Free the handle */
		bzero(buf_info, sizeof (MBUF_INFO));
		buf_info->size = sizeof (MATCHMAP);
		buf_info->virt = (void *)mp;
		emlxs_mem_free(hba, buf_info);

		seg->fc_numblks--;
		seg->fc_total_memsize -= (seg->fc_memsize + sizeof (MATCHMAP));

		count--;
	}

	return;

vmem_pool:

	/* Free memory associated with all buffers on get buffer pool */
	while (count && ((bp = seg->fc_memget_ptr) != NULL)) {
		/* Remove buffer from list */
		if (seg->fc_memget_end == bp) {
			seg->fc_memget_ptr = NULL;
			seg->fc_memget_end = NULL;
			seg->fc_memget_cnt = 0;

		} else {
			seg->fc_memget_ptr = *((uint8_t **)bp);
			seg->fc_memget_cnt--;
		}

		/* Free the Virtual memory itself */
		bzero(buf_info, sizeof (MBUF_INFO));
		buf_info->size = seg->fc_memsize;
		buf_info->virt = bp;
		emlxs_mem_free(hba, buf_info);

		seg->fc_numblks--;
		seg->fc_total_memsize -= seg->fc_memsize;

		count--;
	}

	return;

} /* emlxs_mem_pool_free() */


extern uint32_t
emlxs_mem_pool_create(emlxs_hba_t *hba, MEMSEG *seg)
{
	emlxs_config_t *cfg = &CFG;

	mutex_enter(&EMLXS_MEMGET_LOCK);
	mutex_enter(&EMLXS_MEMPUT_LOCK);

	if (seg->fc_memsize == 0) {
		mutex_exit(&EMLXS_MEMPUT_LOCK);
		mutex_exit(&EMLXS_MEMGET_LOCK);

		return (0);
	}

	/* Sanity check hi > lo */
	if (seg->fc_lo_water > seg->fc_hi_water) {
		seg->fc_hi_water = seg->fc_lo_water;
	}

	/* If dynamic pools are disabled, then force pool to max level */
	if (cfg[CFG_MEM_DYNAMIC].current == 0) {
		seg->fc_lo_water = seg->fc_hi_water;
	}

	/* If pool is dynamic, then fc_step must be >0 */
	/* Otherwise, fc_step must be 0 */
	if (seg->fc_lo_water != seg->fc_hi_water) {
		seg->fc_memflag |= FC_MEMSEG_DYNAMIC;

		if (seg->fc_step == 0) {
			seg->fc_step = 1;
		}
	} else {
		seg->fc_step = 0;
	}

	seg->fc_numblks = 0;
	seg->fc_total_memsize = 0;
	seg->fc_low = 0;

	(void) emlxs_mem_pool_alloc(hba, seg, seg->fc_lo_water);

	seg->fc_memflag |= (FC_MEMSEG_PUT_ENABLED|FC_MEMSEG_GET_ENABLED);

	mutex_exit(&EMLXS_MEMPUT_LOCK);
	mutex_exit(&EMLXS_MEMGET_LOCK);

	return (seg->fc_numblks);

} /* emlxs_mem_pool_create() */


extern void
emlxs_mem_pool_destroy(emlxs_hba_t *hba, MEMSEG *seg)
{
	emlxs_port_t *port = &PPORT;

	mutex_enter(&EMLXS_MEMGET_LOCK);
	mutex_enter(&EMLXS_MEMPUT_LOCK);

	if (seg->fc_memsize == 0) {
		mutex_exit(&EMLXS_MEMPUT_LOCK);
		mutex_exit(&EMLXS_MEMGET_LOCK);
		return;
	}

	/* Leave FC_MEMSEG_PUT_ENABLED set for now */
	seg->fc_memflag &= ~FC_MEMSEG_GET_ENABLED;

	/* Try to free all objects */
	emlxs_mem_pool_free(hba, seg, seg->fc_numblks);

	if (seg->fc_numblks) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_detail_msg,
		    "mem_pool_destroy: %s leak detected: "
		    "%d objects still allocated.",
		    seg->fc_label, seg->fc_numblks);
	} else {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_detail_msg,
		    "mem_pool_destroy: %s destroyed.",
		    seg->fc_label);

		/* Clear all */
		bzero(seg, sizeof (MEMSEG));
	}

	mutex_exit(&EMLXS_MEMPUT_LOCK);
	mutex_exit(&EMLXS_MEMGET_LOCK);

	return;

} /* emlxs_mem_pool_destroy() */


extern void
emlxs_mem_pool_clean(emlxs_hba_t *hba, MEMSEG *seg)
{
	emlxs_port_t *port = &PPORT;
	uint32_t clean_count;
	uint32_t free_count;
	uint32_t free_pad;

	mutex_enter(&EMLXS_MEMGET_LOCK);
	mutex_enter(&EMLXS_MEMPUT_LOCK);

	if (!(seg->fc_memflag & FC_MEMSEG_DYNAMIC)) {
		mutex_exit(&EMLXS_MEMPUT_LOCK);
		mutex_exit(&EMLXS_MEMGET_LOCK);
		return;
	}

	if (!(seg->fc_memflag & FC_MEMSEG_GET_ENABLED)) {
		goto done;
	}

#ifdef EMLXS_POOL_DEBUG
	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_detail_msg,
	    "%s clean: n=%d s=%d f=%x l=%d,%d,%d "
	    "f=%d:%d",
	    seg->fc_label, seg->fc_numblks,
	    seg->fc_memsize, seg->fc_memflag, seg->fc_lo_water,
	    seg->fc_hi_water, seg->fc_step, seg->fc_memget_cnt,
	    seg->fc_low);
#endif /* EMLXS_POOL_DEBUG */

	/* Calculatge current free count */
	free_count = (seg->fc_memget_cnt + seg->fc_memput_cnt);

	/* Reset fc_low value to current free count */
	clean_count = seg->fc_low;
	seg->fc_low = free_count;

	/* Return if pool is already at lo water mark */
	if (seg->fc_numblks <= seg->fc_lo_water) {
		goto done;
	}

	/* Return if there is nothing to clean */
	if ((free_count == 0) ||
	    (clean_count <= 1)) {
		goto done;
	}

	/* Calculate a 3 percent free pad count (1 being minimum) */
	if (seg->fc_numblks > 66) {
		free_pad = ((seg->fc_numblks * 3)/100);
	} else {
		free_pad = 1;
	}

	/* Return if fc_low is below pool free pad */
	if (clean_count <= free_pad) {
		goto done;
	}

	clean_count -= free_pad;

	/* clean_count can't exceed minimum pool levels */
	if (clean_count > (seg->fc_numblks - seg->fc_lo_water)) {
		clean_count = (seg->fc_numblks - seg->fc_lo_water);
	}

	emlxs_mem_pool_free(hba, seg, clean_count);

done:
	if (seg->fc_last != seg->fc_numblks) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_detail_msg,
		    "%s update: n=%d->%d s=%d f=%x l=%d,%d,%d "
		    "f=%d:%d",
		    seg->fc_label, seg->fc_last, seg->fc_numblks,
		    seg->fc_memsize, seg->fc_memflag, seg->fc_lo_water,
		    seg->fc_hi_water, seg->fc_step, seg->fc_memget_cnt,
		    seg->fc_low);

		seg->fc_last = seg->fc_numblks;
	}

	mutex_exit(&EMLXS_MEMPUT_LOCK);
	mutex_exit(&EMLXS_MEMGET_LOCK);
	return;

} /* emlxs_mem_pool_clean() */


extern void *
emlxs_mem_pool_get(emlxs_hba_t *hba, MEMSEG *seg)
{
	emlxs_port_t	*port = &PPORT;
	void		*bp = NULL;
	MATCHMAP	*mp;
	uint32_t	free_count;

	mutex_enter(&EMLXS_MEMGET_LOCK);

	/* Check if memory pool is GET enabled */
	if (!(seg->fc_memflag & FC_MEMSEG_GET_ENABLED)) {
		mutex_exit(&EMLXS_MEMGET_LOCK);
		return (NULL);
	}

	/* If no entries on memget list, then check memput list */
	if (!seg->fc_memget_ptr) {
		mutex_enter(&EMLXS_MEMPUT_LOCK);
		if (seg->fc_memput_ptr) {
			/*
			 * Move list from memput to memget
			 */
			seg->fc_memget_ptr = seg->fc_memput_ptr;
			seg->fc_memget_end = seg->fc_memput_end;
			seg->fc_memget_cnt = seg->fc_memput_cnt;
			seg->fc_memput_ptr = NULL;
			seg->fc_memput_end = NULL;
			seg->fc_memput_cnt = 0;
		}
		mutex_exit(&EMLXS_MEMPUT_LOCK);
	}

	/* If no entries on memget list, then pool is empty */
	/* Try to allocate more if pool is dynamic */
	if (!seg->fc_memget_ptr &&
	    (seg->fc_memflag & FC_MEMSEG_DYNAMIC)) {
		(void) emlxs_mem_pool_alloc(hba, seg,  seg->fc_step);
		seg->fc_low = 0;
	}

	/* If no entries on memget list, then pool is empty */
	if (!seg->fc_memget_ptr) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_alloc_failed_msg,
		    "%s empty.", seg->fc_label);

		mutex_exit(&EMLXS_MEMGET_LOCK);
		return (NULL);
	}

	/* Remove an entry from the get list */
	bp = seg->fc_memget_ptr;

	if (seg->fc_memget_end == bp) {
		seg->fc_memget_ptr = NULL;
		seg->fc_memget_end = NULL;
		seg->fc_memget_cnt = 0;

	} else {
		seg->fc_memget_ptr = *((uint8_t **)bp);
		seg->fc_memget_cnt--;
	}

	/* Initialize buffer */
	if (!(seg->fc_memflag & FC_MBUF_DMA)) {
		bzero(bp, seg->fc_memsize);
	} else {
		mp = (MATCHMAP *)bp;
		mp->fc_mptr = NULL;
		mp->flag |= MAP_POOL_ALLOCATED;
	}

	/* Set fc_low if pool is dynamic */
	if (seg->fc_memflag & FC_MEMSEG_DYNAMIC) {
		free_count = (seg->fc_memget_cnt + seg->fc_memput_cnt);
		if (free_count < seg->fc_low) {
			seg->fc_low = free_count;
		}
	}

	mutex_exit(&EMLXS_MEMGET_LOCK);

	return (bp);

} /* emlxs_mem_pool_get() */


extern void
emlxs_mem_pool_put(emlxs_hba_t *hba, MEMSEG *seg, void *bp)
{
	emlxs_port_t	*port = &PPORT;
	MATCHMAP	*mp;

	/* Free the pool object */
	mutex_enter(&EMLXS_MEMPUT_LOCK);

	/* Check if memory pool is PUT enabled */
	if (!(seg->fc_memflag & FC_MEMSEG_PUT_ENABLED)) {
		mutex_exit(&EMLXS_MEMPUT_LOCK);
		return;
	}

	/* Check if buffer was just freed */
	if ((seg->fc_memput_end == bp) || (seg->fc_memget_end == bp)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
		    "%s: Freeing free object: bp=%p", seg->fc_label, bp);

		mutex_exit(&EMLXS_MEMPUT_LOCK);
		return;
	}

	/* Validate DMA buffer */
	if (seg->fc_memflag & FC_MBUF_DMA) {
		mp = (MATCHMAP *)bp;

		if (!(mp->flag & MAP_POOL_ALLOCATED) ||
		    (mp->segment != seg)) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
			    "mem_pool_put: %s invalid: mp=%p " \
			    "tag=0x%x flag=%x", seg->fc_label,
			    mp, mp->tag, mp->flag);

			EMLXS_STATE_CHANGE(hba, FC_ERROR);

			mutex_exit(&EMLXS_MEMPUT_LOCK);

			emlxs_thread_spawn(hba, emlxs_shutdown_thread,
			    NULL, NULL);

			return;
		}
	}

	/* Release buffer to the end of the memput list */
	if (seg->fc_memput_end == NULL) {
		seg->fc_memput_ptr = bp;
		seg->fc_memput_cnt = 1;
	} else {
		*((void **)(seg->fc_memput_end)) = bp;
		seg->fc_memput_cnt++;
	}
	seg->fc_memput_end = bp;
	*((void **)(bp)) = NULL;

	mutex_exit(&EMLXS_MEMPUT_LOCK);

	/* This is for late PUT's after an initial */
	/* emlxs_mem_pool_destroy call */
	if ((seg->fc_memflag & FC_MEMSEG_PUT_ENABLED) &&
	    !(seg->fc_memflag & FC_MEMSEG_GET_ENABLED)) {
		emlxs_mem_pool_destroy(hba, seg);
	}

	return;

} /* emlxs_mem_pool_put() */


extern MATCHMAP *
emlxs_mem_buf_alloc(emlxs_hba_t *hba, uint32_t size)
{
	emlxs_port_t *port = &PPORT;
	uint8_t *bp = NULL;
	MATCHMAP *mp = NULL;
	MBUF_INFO *buf_info;
	MBUF_INFO bufinfo;

	buf_info = &bufinfo;

	bzero(buf_info, sizeof (MBUF_INFO));
	buf_info->size = sizeof (MATCHMAP);
	buf_info->align = sizeof (void *);

	(void) emlxs_mem_alloc(hba, buf_info);
	if (buf_info->virt == NULL) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg,
		    "MEM_BUF_ALLOC buffer.");

		return (NULL);
	}

	mp = (MATCHMAP *)buf_info->virt;
	bzero(mp, sizeof (MATCHMAP));

	bzero(buf_info, sizeof (MBUF_INFO));
	buf_info->size = size;
	buf_info->flags = FC_MBUF_DMA | FC_MBUF_SNGLSG;
	buf_info->align = 32;

	(void) emlxs_mem_alloc(hba, buf_info);
	if (buf_info->virt == NULL) {

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg,
		    "MEM_BUF_ALLOC DMA buffer.");

		/* Free the mp object */
		bzero(buf_info, sizeof (MBUF_INFO));
		buf_info->size = sizeof (MATCHMAP);
		buf_info->virt = (void *)mp;
		emlxs_mem_free(hba, buf_info);

		return (NULL);
	}
	bp = (uint8_t *)buf_info->virt;
	bzero(bp, buf_info->size);

	mp->virt = buf_info->virt;
	mp->phys = buf_info->phys;
	mp->size = buf_info->size;
	mp->dma_handle = buf_info->dma_handle;
	mp->data_handle = buf_info->data_handle;
	mp->tag = MEM_BUF;
	mp->flag |= MAP_BUF_ALLOCATED;

	return (mp);

} /* emlxs_mem_buf_alloc() */


extern void
emlxs_mem_buf_free(emlxs_hba_t *hba, MATCHMAP *mp)
{
	MBUF_INFO bufinfo;
	MBUF_INFO *buf_info;

	buf_info = &bufinfo;

	if (!(mp->flag & MAP_BUF_ALLOCATED)) {
		return;
	}

	bzero(buf_info, sizeof (MBUF_INFO));
	buf_info->size = mp->size;
	buf_info->virt = mp->virt;
	buf_info->phys = mp->phys;
	buf_info->dma_handle = mp->dma_handle;
	buf_info->data_handle = mp->data_handle;
	buf_info->flags = FC_MBUF_DMA;
	emlxs_mem_free(hba, buf_info);

	bzero(buf_info, sizeof (MBUF_INFO));
	buf_info->size = sizeof (MATCHMAP);
	buf_info->virt = (void *)mp;
	emlxs_mem_free(hba, buf_info);

	return;

} /* emlxs_mem_buf_free() */


extern void *
emlxs_mem_get(emlxs_hba_t *hba, uint32_t seg_id)
{
	emlxs_port_t	*port = &PPORT;
	void		*bp;
	MAILBOXQ	*mbq;
	IOCBQ		*iocbq;
	NODELIST	*node;
	MEMSEG		*seg;

	if (seg_id >= FC_MAX_SEG) {

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
		    "mem_get: Invalid segment id = %d",
		    seg_id);

		return (NULL);
	}
	seg = &hba->memseg[seg_id];

	/* Alloc a buffer from the pool */
	bp = emlxs_mem_pool_get(hba, seg);

	if (bp) {
		switch (seg_id) {
		case MEM_MBOX:
			mbq = (MAILBOXQ *)bp;
			mbq->flag |= MBQ_POOL_ALLOCATED;
			break;

		case MEM_IOCB:
			iocbq = (IOCBQ *)bp;
			iocbq->flag |= IOCB_POOL_ALLOCATED;
			break;

		case MEM_NLP:
			node = (NODELIST *)bp;
			node->flag |= NODE_POOL_ALLOCATED;
			break;
		}
	}

	return (bp);

} /* emlxs_mem_get() */


extern void
emlxs_mem_put(emlxs_hba_t *hba, uint32_t seg_id, void *bp)
{
	emlxs_port_t	*port = &PPORT;
	MAILBOXQ	*mbq;
	IOCBQ		*iocbq;
	NODELIST	*node;
	MEMSEG		*seg;
	MATCHMAP	*mp;

	if (seg_id >= FC_MAX_SEG) {

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
		    "mem_put: Invalid segment id = %d: bp=%p",
		    seg_id, bp);

		return;
	}
	seg = &hba->memseg[seg_id];

	/* Verify buffer */
	switch (seg_id) {
	case MEM_MBOX:
		mbq = (MAILBOXQ *)bp;

		if (!(mbq->flag & MBQ_POOL_ALLOCATED)) {
			return;
		}
		break;

	case MEM_IOCB:
		iocbq = (IOCBQ *)bp;

		if (!(iocbq->flag & IOCB_POOL_ALLOCATED)) {
			return;
		}

		/* Any IOCBQ with a packet attached did not come */
		/* from our pool */
		if (iocbq->sbp) {
			return;
		}
		break;

	case MEM_NLP:
		node = (NODELIST *)bp;

		if (!(node->flag & NODE_POOL_ALLOCATED)) {
			return;
		}
		break;

	default:
		mp = (MATCHMAP *)bp;

		if (mp->flag & MAP_BUF_ALLOCATED) {
			emlxs_mem_buf_free(hba, mp);
			return;
		}

		if (mp->flag & MAP_TABLE_ALLOCATED) {
			return;
		}

		if (!(mp->flag & MAP_POOL_ALLOCATED)) {
			return;
		}
		break;
	}

	/* Free a buffer to the pool */
	emlxs_mem_pool_put(hba, seg, bp);

	return;

} /* emlxs_mem_put() */


/*
 * Look up the virtual address given a mapped address
 */
/* SLI3 */
extern MATCHMAP *
emlxs_mem_get_vaddr(emlxs_hba_t *hba, RING *rp, uint64_t mapbp)
{
	emlxs_port_t *port = &PPORT;
	MATCHMAP *prev;
	MATCHMAP *mp;

	if (rp->ringno == hba->channel_els) {
		mp = (MATCHMAP *)rp->fc_mpoff;
		prev = 0;

		while (mp) {
			if (mp->phys == mapbp) {
				if (prev == 0) {
					rp->fc_mpoff = mp->fc_mptr;
				} else {
					prev->fc_mptr = mp->fc_mptr;
				}

				if (rp->fc_mpon == mp) {
					rp->fc_mpon = (void *)prev;
				}

				mp->fc_mptr = NULL;

				EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
				    DDI_DMA_SYNC_FORKERNEL);

				HBASTATS.ElsUbPosted--;

				return (mp);
			}

			prev = mp;
			mp = (MATCHMAP *)mp->fc_mptr;
		}

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
		    "ELS Buffer not mapped: bp=%lx ringno=%x mpoff=%p mpon=%p",
		    mapbp, rp->ringno, rp->fc_mpoff, rp->fc_mpon);

	} else if (rp->ringno == hba->channel_ct) {

		mp = (MATCHMAP *)rp->fc_mpoff;
		prev = 0;

		while (mp) {
			if (mp->phys == mapbp) {
				if (prev == 0) {
					rp->fc_mpoff = mp->fc_mptr;
				} else {
					prev->fc_mptr = mp->fc_mptr;
				}

				if (rp->fc_mpon == mp) {
					rp->fc_mpon = (void *)prev;
				}

				mp->fc_mptr = NULL;

				EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
				    DDI_DMA_SYNC_FORKERNEL);

				HBASTATS.CtUbPosted--;

				return (mp);
			}

			prev = mp;
			mp = (MATCHMAP *)mp->fc_mptr;
		}

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
		    "CT Buffer not mapped: bp=%lx ringno=%x mpoff=%p mpon=%p",
		    mapbp, rp->ringno, rp->fc_mpoff, rp->fc_mpon);

	} else if (rp->ringno == hba->channel_ip) {

		mp = (MATCHMAP *)rp->fc_mpoff;
		prev = 0;

		while (mp) {
			if (mp->phys == mapbp) {
				if (prev == 0) {
					rp->fc_mpoff = mp->fc_mptr;
				} else {
					prev->fc_mptr = mp->fc_mptr;
				}

				if (rp->fc_mpon == mp) {
					rp->fc_mpon = (void *)prev;
				}

				mp->fc_mptr = NULL;

				EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
				    DDI_DMA_SYNC_FORKERNEL);

				HBASTATS.IpUbPosted--;

				return (mp);
			}

			prev = mp;
			mp = (MATCHMAP *)mp->fc_mptr;
		}

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
		    "IP Buffer not mapped: bp=%lx ringno=%x mpoff=%p mpon=%p",
		    mapbp, rp->ringno, rp->fc_mpoff, rp->fc_mpon);

#ifdef SFCT_SUPPORT
	} else if (rp->ringno == hba->CHANNEL_FCT) {
		mp = (MATCHMAP *)rp->fc_mpoff;
		prev = 0;

		while (mp) {
			if (mp->phys == mapbp) {
				if (prev == 0) {
					rp->fc_mpoff = mp->fc_mptr;
				} else {
					prev->fc_mptr = mp->fc_mptr;
				}

				if (rp->fc_mpon == mp) {
					rp->fc_mpon = (void *)prev;
				}

				mp->fc_mptr = NULL;

				EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
				    DDI_DMA_SYNC_FORKERNEL);

				HBASTATS.FctUbPosted--;

				return (mp);
			}

			prev = mp;
			mp = (MATCHMAP *)mp->fc_mptr;
		}

		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
		    "FCT Buffer not mapped: bp=%lx ringno=%x mpoff=%p mpon=%p",
		    mapbp, rp->ringno, rp->fc_mpoff, rp->fc_mpon);

#endif /* SFCT_SUPPORT */
	}

	return (0);

} /* emlxs_mem_get_vaddr() */


/*
 * Given a virtual address bp, generate the physical mapped address and
 * place it where addr points to. Save the address pair for lookup later.
 */
/* SLI3 */
extern void
emlxs_mem_map_vaddr(emlxs_hba_t *hba, RING *rp, MATCHMAP *mp,
    uint32_t *haddr, uint32_t *laddr)
{
	if (rp->ringno == hba->channel_els) {
		/*
		 * Update slot fc_mpon points to then bump it
		 * fc_mpoff is pointer head of the list.
		 * fc_mpon is pointer tail of the list.
		 */
		mp->fc_mptr = NULL;
		if (rp->fc_mpoff == 0) {
			rp->fc_mpoff = (void *)mp;
			rp->fc_mpon = (void *)mp;
		} else {
			((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
			    (void *)mp;
			rp->fc_mpon = (void *)mp;
		}

		if (hba->flag & FC_SLIM2_MODE) {

			/* return mapped address */
			*haddr = PADDR_HI(mp->phys);
			/* return mapped address */
			*laddr = PADDR_LO(mp->phys);
		} else {
			/* return mapped address */
			*laddr = PADDR_LO(mp->phys);
		}

		HBASTATS.ElsUbPosted++;

	} else if (rp->ringno == hba->channel_ct) {
		/*
		 * Update slot fc_mpon points to then bump it
		 * fc_mpoff is pointer head of the list.
		 * fc_mpon is pointer tail of the list.
		 */
		mp->fc_mptr = NULL;
		if (rp->fc_mpoff == 0) {
			rp->fc_mpoff = (void *)mp;
			rp->fc_mpon = (void *)mp;
		} else {
			((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
			    (void *)mp;
			rp->fc_mpon = (void *)mp;
		}

		if (hba->flag & FC_SLIM2_MODE) {
			/* return mapped address */
			*haddr = PADDR_HI(mp->phys);
			/* return mapped address */
			*laddr = PADDR_LO(mp->phys);
		} else {
			/* return mapped address */
			*laddr = PADDR_LO(mp->phys);
		}

		HBASTATS.CtUbPosted++;


	} else if (rp->ringno == hba->channel_ip) {
		/*
		 * Update slot fc_mpon points to then bump it
		 * fc_mpoff is pointer head of the list.
		 * fc_mpon is pointer tail of the list.
		 */
		mp->fc_mptr = NULL;
		if (rp->fc_mpoff == 0) {
			rp->fc_mpoff = (void *)mp;
			rp->fc_mpon = (void *)mp;
		} else {
			((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
			    (void *)mp;
			rp->fc_mpon = (void *)mp;
		}

		if (hba->flag & FC_SLIM2_MODE) {
			/* return mapped address */
			*haddr = PADDR_HI(mp->phys);
			*laddr = PADDR_LO(mp->phys);
		} else {
			*laddr = PADDR_LO(mp->phys);
		}

		HBASTATS.IpUbPosted++;


#ifdef SFCT_SUPPORT
	} else if (rp->ringno == hba->CHANNEL_FCT) {
		/*
		 * Update slot fc_mpon points to then bump it
		 * fc_mpoff is pointer head of the list.
		 * fc_mpon is pointer tail of the list.
		 */
		mp->fc_mptr = NULL;
		if (rp->fc_mpoff == 0) {
			rp->fc_mpoff = (void *)mp;
			rp->fc_mpon = (void *)mp;
		} else {
			((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
			    (void *)mp;
			rp->fc_mpon = (void *)mp;
		}

		if (hba->flag & FC_SLIM2_MODE) {
			/* return mapped address */
			*haddr = PADDR_HI(mp->phys);
			/* return mapped address */
			*laddr = PADDR_LO(mp->phys);
		} else {
			/* return mapped address */
			*laddr = PADDR_LO(mp->phys);
		}

		HBASTATS.FctUbPosted++;

#endif /* SFCT_SUPPORT */
	}
} /* emlxs_mem_map_vaddr() */


/* SLI3 */
uint32_t
emlxs_hbq_alloc(emlxs_hba_t *hba, uint32_t hbq_id)
{
	emlxs_port_t *port = &PPORT;
	HBQ_INIT_t *hbq;
	MBUF_INFO *buf_info;
	MBUF_INFO bufinfo;

	hbq = &hba->sli.sli3.hbq_table[hbq_id];

	if (hbq->HBQ_host_buf.virt == 0) {
		buf_info = &bufinfo;

		/* Get the system's page size in a DDI-compliant way. */
		bzero(buf_info, sizeof (MBUF_INFO));
		buf_info->size = hbq->HBQ_numEntries * sizeof (HBQE_t);
		buf_info->flags = FC_MBUF_DMA;
		buf_info->align = 4096;

		(void) emlxs_mem_alloc(hba, buf_info);

		if (buf_info->virt == NULL) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_msg,
			    "Unable to alloc HBQ.");
			return (ENOMEM);
		}

		hbq->HBQ_host_buf.virt = buf_info->virt;
		hbq->HBQ_host_buf.phys = buf_info->phys;
		hbq->HBQ_host_buf.data_handle = buf_info->data_handle;
		hbq->HBQ_host_buf.dma_handle = buf_info->dma_handle;
		hbq->HBQ_host_buf.size = buf_info->size;
		hbq->HBQ_host_buf.tag = hbq_id;

		bzero((char *)hbq->HBQ_host_buf.virt, buf_info->size);
	}

	return (0);

} /* emlxs_hbq_alloc() */