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;