[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / scsi / lpfc / lpfc_mem.c

/*******************************************************************
 * This file is part of the Emulex Linux Device Driver for         *
 * Fibre Channel Host Bus Adapters.                                *
 * Copyright (C) 2004-2012 Emulex.  All rights reserved.           *
 * EMULEX and SLI are trademarks of Emulex.                        *
 * www.emulex.com                                                  *
 * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
 *                                                                 *
 * This program is free software; you can redistribute it and/or   *
 * modify it under the terms of version 2 of the GNU General       *
 * Public License as published by the Free Software Foundation.    *
 * This program is distributed in the hope that it will be useful. *
 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
 * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
 * more details, a copy of which can be found in the file COPYING  *
 * included with this package.                                     *
 *******************************************************************/

#include <linux/mempool.h>
#include <linux/slab.h>
#include <linux/pci.h>
#include <linux/interrupt.h>

#include <scsi/scsi_device.h>
#include <scsi/scsi_transport_fc.h>

#include <scsi/scsi.h>

#include "lpfc_hw4.h"
#include "lpfc_hw.h"
#include "lpfc_sli.h"
#include "lpfc_sli4.h"
#include "lpfc_nl.h"
#include "lpfc_disc.h"
#include "lpfc_scsi.h"
#include "lpfc.h"
#include "lpfc_crtn.h"

#define LPFC_MBUF_POOL_SIZE     64      /* max elements in MBUF safety pool */
#define LPFC_MEM_POOL_SIZE      64      /* max elem in non-DMA safety pool */


/**
 * lpfc_mem_alloc - create and allocate all PCI and memory pools
 * @phba: HBA to allocate pools for
 *
 * Description: Creates and allocates PCI pools lpfc_scsi_dma_buf_pool,
 * lpfc_mbuf_pool, lpfc_hrb_pool.  Creates and allocates kmalloc-backed mempools
 * for LPFC_MBOXQ_t and lpfc_nodelist.  Also allocates the VPI bitmask.
 *
 * Notes: Not interrupt-safe.  Must be called with no locks held.  If any
 * allocation fails, frees all successfully allocated memory before returning.
 *
 * Returns:
 *   0 on success
 *   -ENOMEM on failure (if any memory allocations fail)
 **/
int
lpfc_mem_alloc(struct lpfc_hba *phba, int align)
{
	struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool;
	int i;

	if (phba->sli_rev == LPFC_SLI_REV4) {
		/* Calculate alignment */
		if (phba->cfg_sg_dma_buf_size < SLI4_PAGE_SIZE)
			i = phba->cfg_sg_dma_buf_size;
		else
			i = SLI4_PAGE_SIZE;

		phba->lpfc_scsi_dma_buf_pool =
			pci_pool_create("lpfc_scsi_dma_buf_pool",
				phba->pcidev,
				phba->cfg_sg_dma_buf_size,
				i,
				0);
	} else {
		phba->lpfc_scsi_dma_buf_pool =
			pci_pool_create("lpfc_scsi_dma_buf_pool",
				phba->pcidev, phba->cfg_sg_dma_buf_size,
				align, 0);
	}

	if (!phba->lpfc_scsi_dma_buf_pool)
		goto fail;

	phba->lpfc_mbuf_pool = pci_pool_create("lpfc_mbuf_pool", phba->pcidev,
							LPFC_BPL_SIZE,
							align, 0);
	if (!phba->lpfc_mbuf_pool)
		goto fail_free_dma_buf_pool;

	pool->elements = kmalloc(sizeof(struct lpfc_dmabuf) *
					 LPFC_MBUF_POOL_SIZE, GFP_KERNEL);
	if (!pool->elements)
		goto fail_free_lpfc_mbuf_pool;

	pool->max_count = 0;
	pool->current_count = 0;
	for ( i = 0; i < LPFC_MBUF_POOL_SIZE; i++) {
		pool->elements[i].virt = pci_pool_alloc(phba->lpfc_mbuf_pool,
				       GFP_KERNEL, &pool->elements[i].phys);
		if (!pool->elements[i].virt)
			goto fail_free_mbuf_pool;
		pool->max_count++;
		pool->current_count++;
	}

	phba->mbox_mem_pool = mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE,
							 sizeof(LPFC_MBOXQ_t));
	if (!phba->mbox_mem_pool)
		goto fail_free_mbuf_pool;

	phba->nlp_mem_pool = mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE,
						sizeof(struct lpfc_nodelist));
	if (!phba->nlp_mem_pool)
		goto fail_free_mbox_pool;

	if (phba->sli_rev == LPFC_SLI_REV4) {
		phba->rrq_pool =
			mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE,
						sizeof(struct lpfc_node_rrq));
		if (!phba->rrq_pool)
			goto fail_free_nlp_mem_pool;
		phba->lpfc_hrb_pool = pci_pool_create("lpfc_hrb_pool",
					      phba->pcidev,
					      LPFC_HDR_BUF_SIZE, align, 0);
		if (!phba->lpfc_hrb_pool)
			goto fail_free_rrq_mem_pool;

		phba->lpfc_drb_pool = pci_pool_create("lpfc_drb_pool",
					      phba->pcidev,
					      LPFC_DATA_BUF_SIZE, align, 0);
		if (!phba->lpfc_drb_pool)
			goto fail_free_hrb_pool;
		phba->lpfc_hbq_pool = NULL;
	} else {
		phba->lpfc_hbq_pool = pci_pool_create("lpfc_hbq_pool",
			phba->pcidev, LPFC_BPL_SIZE, align, 0);
		if (!phba->lpfc_hbq_pool)
			goto fail_free_nlp_mem_pool;
		phba->lpfc_hrb_pool = NULL;
		phba->lpfc_drb_pool = NULL;
	}

	return 0;
 fail_free_hrb_pool:
	pci_pool_destroy(phba->lpfc_hrb_pool);
	phba->lpfc_hrb_pool = NULL;
 fail_free_rrq_mem_pool:
	mempool_destroy(phba->rrq_pool);
	phba->rrq_pool = NULL;
 fail_free_nlp_mem_pool:
	mempool_destroy(phba->nlp_mem_pool);
	phba->nlp_mem_pool = NULL;
 fail_free_mbox_pool:
	mempool_destroy(phba->mbox_mem_pool);
	phba->mbox_mem_pool = NULL;
 fail_free_mbuf_pool:
	while (i--)
		pci_pool_free(phba->lpfc_mbuf_pool, pool->elements[i].virt,
						 pool->elements[i].phys);
	kfree(pool->elements);
 fail_free_lpfc_mbuf_pool:
	pci_pool_destroy(phba->lpfc_mbuf_pool);
	phba->lpfc_mbuf_pool = NULL;
 fail_free_dma_buf_pool:
	pci_pool_destroy(phba->lpfc_scsi_dma_buf_pool);
	phba->lpfc_scsi_dma_buf_pool = NULL;
 fail:
	return -ENOMEM;
}

/**
 * lpfc_mem_free - Frees memory allocated by lpfc_mem_alloc
 * @phba: HBA to free memory for
 *
 * Description: Free the memory allocated by lpfc_mem_alloc routine. This
 * routine is a the counterpart of lpfc_mem_alloc.
 *
 * Returns: None
 **/
void
lpfc_mem_free(struct lpfc_hba *phba)
{
	int i;
	struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool;

	/* Free HBQ pools */
	lpfc_sli_hbqbuf_free_all(phba);
	if (phba->lpfc_drb_pool)
		pci_pool_destroy(phba->lpfc_drb_pool);
	phba->lpfc_drb_pool = NULL;
	if (phba->lpfc_hrb_pool)
		pci_pool_destroy(phba->lpfc_hrb_pool);
	phba->lpfc_hrb_pool = NULL;

	if (phba->lpfc_hbq_pool)
		pci_pool_destroy(phba->lpfc_hbq_pool);
	phba->lpfc_hbq_pool = NULL;

	if (phba->rrq_pool)
		mempool_destroy(phba->rrq_pool);
	phba->rrq_pool = NULL;

	/* Free NLP memory pool */
	mempool_destroy(phba->nlp_mem_pool);
	phba->nlp_mem_pool = NULL;

	/* Free mbox memory pool */
	mempool_destroy(phba->mbox_mem_pool);
	phba->mbox_mem_pool = NULL;

	/* Free MBUF memory pool */
	for (i = 0; i < pool->current_count; i++)
		pci_pool_free(phba->lpfc_mbuf_pool, pool->elements[i].virt,
			      pool->elements[i].phys);
	kfree(pool->elements);

	pci_pool_destroy(phba->lpfc_mbuf_pool);
	phba->lpfc_mbuf_pool = NULL;

	/* Free DMA buffer memory pool */
	pci_pool_destroy(phba->lpfc_scsi_dma_buf_pool);
	phba->lpfc_scsi_dma_buf_pool = NULL;

	return;
}

/**
 * lpfc_mem_free_all - Frees all PCI and driver memory
 * @phba: HBA to free memory for
 *
 * Description: Free memory from PCI and driver memory pools and also those
 * used : lpfc_scsi_dma_buf_pool, lpfc_mbuf_pool, lpfc_hrb_pool. Frees
 * kmalloc-backed mempools for LPFC_MBOXQ_t and lpfc_nodelist. Also frees
 * the VPI bitmask.
 *
 * Returns: None
 **/
void
lpfc_mem_free_all(struct lpfc_hba *phba)
{
	struct lpfc_sli *psli = &phba->sli;
	LPFC_MBOXQ_t *mbox, *next_mbox;
	struct lpfc_dmabuf   *mp;

	/* Free memory used in mailbox queue back to mailbox memory pool */
	list_for_each_entry_safe(mbox, next_mbox, &psli->mboxq, list) {
		mp = (struct lpfc_dmabuf *) (mbox->context1);
		if (mp) {
			lpfc_mbuf_free(phba, mp->virt, mp->phys);
			kfree(mp);
		}
		list_del(&mbox->list);
		mempool_free(mbox, phba->mbox_mem_pool);
	}
	/* Free memory used in mailbox cmpl list back to mailbox memory pool */
	list_for_each_entry_safe(mbox, next_mbox, &psli->mboxq_cmpl, list) {
		mp = (struct lpfc_dmabuf *) (mbox->context1);
		if (mp) {
			lpfc_mbuf_free(phba, mp->virt, mp->phys);
			kfree(mp);
		}
		list_del(&mbox->list);
		mempool_free(mbox, phba->mbox_mem_pool);
	}
	/* Free the active mailbox command back to the mailbox memory pool */
	spin_lock_irq(&phba->hbalock);
	psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
	spin_unlock_irq(&phba->hbalock);
	if (psli->mbox_active) {
		mbox = psli->mbox_active;
		mp = (struct lpfc_dmabuf *) (mbox->context1);
		if (mp) {
			lpfc_mbuf_free(phba, mp->virt, mp->phys);
			kfree(mp);
		}
		mempool_free(mbox, phba->mbox_mem_pool);
		psli->mbox_active = NULL;
	}

	/* Free and destroy all the allocated memory pools */
	lpfc_mem_free(phba);

	/* Free the iocb lookup array */
	kfree(psli->iocbq_lookup);
	psli->iocbq_lookup = NULL;

	return;
}

/**
 * lpfc_mbuf_alloc - Allocate an mbuf from the lpfc_mbuf_pool PCI pool
 * @phba: HBA which owns the pool to allocate from
 * @mem_flags: indicates if this is a priority (MEM_PRI) allocation
 * @handle: used to return the DMA-mapped address of the mbuf
 *
 * Description: Allocates a DMA-mapped buffer from the lpfc_mbuf_pool PCI pool.
 * Allocates from generic pci_pool_alloc function first and if that fails and
 * mem_flags has MEM_PRI set (the only defined flag), returns an mbuf from the
 * HBA's pool.
 *
 * Notes: Not interrupt-safe.  Must be called with no locks held.  Takes
 * phba->hbalock.
 *
 * Returns:
 *   pointer to the allocated mbuf on success
 *   NULL on failure
 **/
void *
lpfc_mbuf_alloc(struct lpfc_hba *phba, int mem_flags, dma_addr_t *handle)
{
	struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool;
	unsigned long iflags;
	void *ret;

	ret = pci_pool_alloc(phba->lpfc_mbuf_pool, GFP_KERNEL, handle);

	spin_lock_irqsave(&phba->hbalock, iflags);
	if (!ret && (mem_flags & MEM_PRI) && pool->current_count) {
		pool->current_count--;
		ret = pool->elements[pool->current_count].virt;
		*handle = pool->elements[pool->current_count].phys;
	}
	spin_unlock_irqrestore(&phba->hbalock, iflags);
	return ret;
}

/**
 * __lpfc_mbuf_free - Free an mbuf from the lpfc_mbuf_pool PCI pool (locked)
 * @phba: HBA which owns the pool to return to
 * @virt: mbuf to free
 * @dma: the DMA-mapped address of the lpfc_mbuf_pool to be freed
 *
 * Description: Returns an mbuf lpfc_mbuf_pool to the lpfc_mbuf_safety_pool if
 * it is below its max_count, frees the mbuf otherwise.
 *
 * Notes: Must be called with phba->hbalock held to synchronize access to
 * lpfc_mbuf_safety_pool.
 *
 * Returns: None
 **/
void
__lpfc_mbuf_free(struct lpfc_hba * phba, void *virt, dma_addr_t dma)
{
	struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool;

	if (pool->current_count < pool->max_count) {
		pool->elements[pool->current_count].virt = virt;
		pool->elements[pool->current_count].phys = dma;
		pool->current_count++;
	} else {
		pci_pool_free(phba->lpfc_mbuf_pool, virt, dma);
	}
	return;
}

/**
 * lpfc_mbuf_free - Free an mbuf from the lpfc_mbuf_pool PCI pool (unlocked)
 * @phba: HBA which owns the pool to return to
 * @virt: mbuf to free
 * @dma: the DMA-mapped address of the lpfc_mbuf_pool to be freed
 *
 * Description: Returns an mbuf lpfc_mbuf_pool to the lpfc_mbuf_safety_pool if
 * it is below its max_count, frees the mbuf otherwise.
 *
 * Notes: Takes phba->hbalock.  Can be called with or without other locks held.
 *
 * Returns: None
 **/
void
lpfc_mbuf_free(struct lpfc_hba * phba, void *virt, dma_addr_t dma)
{
	unsigned long iflags;

	spin_lock_irqsave(&phba->hbalock, iflags);
	__lpfc_mbuf_free(phba, virt, dma);
	spin_unlock_irqrestore(&phba->hbalock, iflags);
	return;
}

/**
 * lpfc_els_hbq_alloc - Allocate an HBQ buffer
 * @phba: HBA to allocate HBQ buffer for
 *
 * Description: Allocates a DMA-mapped HBQ buffer from the lpfc_hrb_pool PCI
 * pool along a non-DMA-mapped container for it.
 *
 * Notes: Not interrupt-safe.  Must be called with no locks held.
 *
 * Returns:
 *   pointer to HBQ on success
 *   NULL on failure
 **/
struct hbq_dmabuf *
lpfc_els_hbq_alloc(struct lpfc_hba *phba)
{
	struct hbq_dmabuf *hbqbp;

	hbqbp = kzalloc(sizeof(struct hbq_dmabuf), GFP_KERNEL);
	if (!hbqbp)
		return NULL;

	hbqbp->dbuf.virt = pci_pool_alloc(phba->lpfc_hbq_pool, GFP_KERNEL,
					  &hbqbp->dbuf.phys);
	if (!hbqbp->dbuf.virt) {
		kfree(hbqbp);
		return NULL;
	}
	hbqbp->size = LPFC_BPL_SIZE;
	return hbqbp;
}

/**
 * lpfc_els_hbq_free - Frees an HBQ buffer allocated with lpfc_els_hbq_alloc
 * @phba: HBA buffer was allocated for
 * @hbqbp: HBQ container returned by lpfc_els_hbq_alloc
 *
 * Description: Frees both the container and the DMA-mapped buffer returned by
 * lpfc_els_hbq_alloc.
 *
 * Notes: Can be called with or without locks held.
 *
 * Returns: None
 **/
void
lpfc_els_hbq_free(struct lpfc_hba *phba, struct hbq_dmabuf *hbqbp)
{
	pci_pool_free(phba->lpfc_hbq_pool, hbqbp->dbuf.virt, hbqbp->dbuf.phys);
	kfree(hbqbp);
	return;
}

/**
 * lpfc_sli4_rb_alloc - Allocate an SLI4 Receive buffer
 * @phba: HBA to allocate a receive buffer for
 *
 * Description: Allocates a DMA-mapped receive buffer from the lpfc_hrb_pool PCI
 * pool along a non-DMA-mapped container for it.
 *
 * Notes: Not interrupt-safe.  Must be called with no locks held.
 *
 * Returns:
 *   pointer to HBQ on success
 *   NULL on failure
 **/
struct hbq_dmabuf *
lpfc_sli4_rb_alloc(struct lpfc_hba *phba)
{
	struct hbq_dmabuf *dma_buf;

	dma_buf = kzalloc(sizeof(struct hbq_dmabuf), GFP_KERNEL);
	if (!dma_buf)
		return NULL;

	dma_buf->hbuf.virt = pci_pool_alloc(phba->lpfc_hrb_pool, GFP_KERNEL,
					    &dma_buf->hbuf.phys);
	if (!dma_buf->hbuf.virt) {
		kfree(dma_buf);
		return NULL;
	}
	dma_buf->dbuf.virt = pci_pool_alloc(phba->lpfc_drb_pool, GFP_KERNEL,
					    &dma_buf->dbuf.phys);
	if (!dma_buf->dbuf.virt) {
		pci_pool_free(phba->lpfc_hrb_pool, dma_buf->hbuf.virt,
			      dma_buf->hbuf.phys);
		kfree(dma_buf);
		return NULL;
	}
	dma_buf->size = LPFC_BPL_SIZE;
	return dma_buf;
}

/**
 * lpfc_sli4_rb_free - Frees a receive buffer
 * @phba: HBA buffer was allocated for
 * @dmab: DMA Buffer container returned by lpfc_sli4_hbq_alloc
 *
 * Description: Frees both the container and the DMA-mapped buffers returned by
 * lpfc_sli4_rb_alloc.
 *
 * Notes: Can be called with or without locks held.
 *
 * Returns: None
 **/
void
lpfc_sli4_rb_free(struct lpfc_hba *phba, struct hbq_dmabuf *dmab)
{
	pci_pool_free(phba->lpfc_hrb_pool, dmab->hbuf.virt, dmab->hbuf.phys);
	pci_pool_free(phba->lpfc_drb_pool, dmab->dbuf.virt, dmab->dbuf.phys);
	kfree(dmab);
	return;
}

/**
 * lpfc_in_buf_free - Free a DMA buffer
 * @phba: HBA buffer is associated with
 * @mp: Buffer to free
 *
 * Description: Frees the given DMA buffer in the appropriate way given if the
 * HBA is running in SLI3 mode with HBQs enabled.
 *
 * Notes: Takes phba->hbalock.  Can be called with or without other locks held.
 *
 * Returns: None
 **/
void
lpfc_in_buf_free(struct lpfc_hba *phba, struct lpfc_dmabuf *mp)
{
	struct hbq_dmabuf *hbq_entry;
	unsigned long flags;

	if (!mp)
		return;

	if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
		/* Check whether HBQ is still in use */
		spin_lock_irqsave(&phba->hbalock, flags);
		if (!phba->hbq_in_use) {
			spin_unlock_irqrestore(&phba->hbalock, flags);
			return;
		}
		hbq_entry = container_of(mp, struct hbq_dmabuf, dbuf);
		list_del(&hbq_entry->dbuf.list);
		if (hbq_entry->tag == -1) {
			(phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
				(phba, hbq_entry);
		} else {
			lpfc_sli_free_hbq(phba, hbq_entry);
		}
		spin_unlock_irqrestore(&phba->hbalock, flags);
	} else {
		lpfc_mbuf_free(phba, mp->virt, mp->phys);
		kfree(mp);
	}
	return;
}
Commit	Line	Data
dea3101e JB	1	/*******************************************************************
dea3101e JB	2	* This file is part of the Emulex Linux Device Driver for *
c44ce173	3	* Fibre Channel Host Bus Adapters. *
21a688cd	4	* Copyright (C) 2004-2012 Emulex. All rights reserved. *
c44ce173	5	* EMULEX and SLI are trademarks of Emulex. *
dea3101e	6	* www.emulex.com *
c44ce173	7	* Portions Copyright (C) 2004-2005 Christoph Hellwig *
dea3101e JB	8	* *
dea3101e JB	9	* This program is free software; you can redistribute it and/or *
c44ce173 JSEC	10	* modify it under the terms of version 2 of the GNU General *
	11	* Public License as published by the Free Software Foundation. *
	12	* This program is distributed in the hope that it will be useful. *
	13	* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
	14	* WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
	15	* FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
	16	* DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
	17	* TO BE LEGALLY INVALID. See the GNU General Public License for *
	18	* more details, a copy of which can be found in the file COPYING *
	19	* included with this package. *
dea3101e JB	20	*******************************************************************/
dea3101e JB	21
dea3101e	22	#include <linux/mempool.h>
5a0e3ad6	23	#include <linux/slab.h>
dea3101e JB	24	#include <linux/pci.h>
	25	#include <linux/interrupt.h>
	26
f888ba3c JSEC	27	#include <scsi/scsi_device.h>
	28	#include <scsi/scsi_transport_fc.h>
	29
91886523 JSEC	30	#include <scsi/scsi.h>
91886523 JSEC	31
da0436e9	32	#include "lpfc_hw4.h"
dea3101e JB	33	#include "lpfc_hw.h"
dea3101e JB	34	#include "lpfc_sli.h"
da0436e9	35	#include "lpfc_sli4.h"
ea2151b4	36	#include "lpfc_nl.h"
dea3101e JB	37	#include "lpfc_disc.h"
	38	#include "lpfc_scsi.h"
	39	#include "lpfc.h"
	40	#include "lpfc_crtn.h"
	41
	42	#define LPFC_MBUF_POOL_SIZE 64 /* max elements in MBUF safety pool */
	43	#define LPFC_MEM_POOL_SIZE 64 /* max elem in non-DMA safety pool */
	44
2e0fef85	45
e59058c4	46	/**
3621a710	47	* lpfc_mem_alloc - create and allocate all PCI and memory pools
e59058c4 JS	48	* @phba: HBA to allocate pools for
	49	*
	50	* Description: Creates and allocates PCI pools lpfc_scsi_dma_buf_pool,
da0436e9	51	* lpfc_mbuf_pool, lpfc_hrb_pool. Creates and allocates kmalloc-backed mempools
e59058c4 JS	52	* for LPFC_MBOXQ_t and lpfc_nodelist. Also allocates the VPI bitmask.
	53	*
	54	* Notes: Not interrupt-safe. Must be called with no locks held. If any
	55	* allocation fails, frees all successfully allocated memory before returning.
	56	*
	57	* Returns:
	58	* 0 on success
	59	* -ENOMEM on failure (if any memory allocations fail)
	60	**/
dea3101e	61	int
da0436e9	62	lpfc_mem_alloc(struct lpfc_hba *phba, int align)
dea3101e JB	63	{
	64	struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool;
	65	int i;
	66
96f7077f JS	67	if (phba->sli_rev == LPFC_SLI_REV4) {
	68	/* Calculate alignment */
	69	if (phba->cfg_sg_dma_buf_size < SLI4_PAGE_SIZE)
	70	i = phba->cfg_sg_dma_buf_size;
	71	else
	72	i = SLI4_PAGE_SIZE;
	73
da0436e9 JS	74	phba->lpfc_scsi_dma_buf_pool =
	75	pci_pool_create("lpfc_scsi_dma_buf_pool",
	76	phba->pcidev,
	77	phba->cfg_sg_dma_buf_size,
96f7077f	78	i,
da0436e9	79	0);
96f7077f	80	} else {
da0436e9 JS	81	phba->lpfc_scsi_dma_buf_pool =
	82	pci_pool_create("lpfc_scsi_dma_buf_pool",
	83	phba->pcidev, phba->cfg_sg_dma_buf_size,
	84	align, 0);
96f7077f JS	85	}
96f7077f JS	86
dea3101e JB	87	if (!phba->lpfc_scsi_dma_buf_pool)
	88	goto fail;
	89
	90	phba->lpfc_mbuf_pool = pci_pool_create("lpfc_mbuf_pool", phba->pcidev,
da0436e9 JS	91	LPFC_BPL_SIZE,
da0436e9 JS	92	align, 0);
dea3101e JB	93	if (!phba->lpfc_mbuf_pool)
	94	goto fail_free_dma_buf_pool;
	95
	96	pool->elements = kmalloc(sizeof(struct lpfc_dmabuf) *
	97	LPFC_MBUF_POOL_SIZE, GFP_KERNEL);
a96e0c77 MK	98	if (!pool->elements)
	99	goto fail_free_lpfc_mbuf_pool;
	100
dea3101e JB	101	pool->max_count = 0;
	102	pool->current_count = 0;
	103	for ( i = 0; i < LPFC_MBUF_POOL_SIZE; i++) {
	104	pool->elements[i].virt = pci_pool_alloc(phba->lpfc_mbuf_pool,
	105	GFP_KERNEL, &pool->elements[i].phys);
	106	if (!pool->elements[i].virt)
	107	goto fail_free_mbuf_pool;
	108	pool->max_count++;
	109	pool->current_count++;
	110	}
	111
0eaae62a MD	112	phba->mbox_mem_pool = mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE,
0eaae62a MD	113	sizeof(LPFC_MBOXQ_t));
dea3101e JB	114	if (!phba->mbox_mem_pool)
	115	goto fail_free_mbuf_pool;
	116
0eaae62a MD	117	phba->nlp_mem_pool = mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE,
0eaae62a MD	118	sizeof(struct lpfc_nodelist));
dea3101e JB	119	if (!phba->nlp_mem_pool)
dea3101e JB	120	goto fail_free_mbox_pool;
8568a4d2 JS	121
8568a4d2 JS	122	if (phba->sli_rev == LPFC_SLI_REV4) {
19ca7609 JS	123	phba->rrq_pool =
	124	mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE,
	125	sizeof(struct lpfc_node_rrq));
	126	if (!phba->rrq_pool)
	127	goto fail_free_nlp_mem_pool;
8568a4d2	128	phba->lpfc_hrb_pool = pci_pool_create("lpfc_hrb_pool",
da0436e9 JS	129	phba->pcidev,
da0436e9 JS	130	LPFC_HDR_BUF_SIZE, align, 0);
8568a4d2	131	if (!phba->lpfc_hrb_pool)
19ca7609	132	goto fail_free_rrq_mem_pool;
8568a4d2 JS	133
8568a4d2 JS	134	phba->lpfc_drb_pool = pci_pool_create("lpfc_drb_pool",
da0436e9 JS	135	phba->pcidev,
da0436e9 JS	136	LPFC_DATA_BUF_SIZE, align, 0);
8568a4d2 JS	137	if (!phba->lpfc_drb_pool)
	138	goto fail_free_hrb_pool;
	139	phba->lpfc_hbq_pool = NULL;
	140	} else {
	141	phba->lpfc_hbq_pool = pci_pool_create("lpfc_hbq_pool",
	142	phba->pcidev, LPFC_BPL_SIZE, align, 0);
	143	if (!phba->lpfc_hbq_pool)
	144	goto fail_free_nlp_mem_pool;
	145	phba->lpfc_hrb_pool = NULL;
	146	phba->lpfc_drb_pool = NULL;
	147	}
92d7f7b0	148
dea3101e	149	return 0;
8568a4d2	150	fail_free_hrb_pool:
da0436e9 JS	151	pci_pool_destroy(phba->lpfc_hrb_pool);
da0436e9 JS	152	phba->lpfc_hrb_pool = NULL;
19ca7609 JS	153	fail_free_rrq_mem_pool:
	154	mempool_destroy(phba->rrq_pool);
	155	phba->rrq_pool = NULL;
ed957684 JS	156	fail_free_nlp_mem_pool:
	157	mempool_destroy(phba->nlp_mem_pool);
	158	phba->nlp_mem_pool = NULL;
dea3101e JB	159	fail_free_mbox_pool:
dea3101e JB	160	mempool_destroy(phba->mbox_mem_pool);
2e0fef85	161	phba->mbox_mem_pool = NULL;
dea3101e	162	fail_free_mbuf_pool:
a96e0c77	163	while (i--)
dea3101e JB	164	pci_pool_free(phba->lpfc_mbuf_pool, pool->elements[i].virt,
	165	pool->elements[i].phys);
	166	kfree(pool->elements);
a96e0c77	167	fail_free_lpfc_mbuf_pool:
dea3101e	168	pci_pool_destroy(phba->lpfc_mbuf_pool);
2e0fef85	169	phba->lpfc_mbuf_pool = NULL;
dea3101e JB	170	fail_free_dma_buf_pool:
dea3101e JB	171	pci_pool_destroy(phba->lpfc_scsi_dma_buf_pool);
2e0fef85	172	phba->lpfc_scsi_dma_buf_pool = NULL;
dea3101e JB	173	fail:
	174	return -ENOMEM;
	175	}
	176
e59058c4	177	/**
da0436e9	178	* lpfc_mem_free - Frees memory allocated by lpfc_mem_alloc
e59058c4 JS	179	* @phba: HBA to free memory for
e59058c4 JS	180	*
da0436e9 JS	181	* Description: Free the memory allocated by lpfc_mem_alloc routine. This
da0436e9 JS	182	* routine is a the counterpart of lpfc_mem_alloc.
e59058c4 JS	183	*
	184	* Returns: None
	185	**/
dea3101e	186	void
da0436e9	187	lpfc_mem_free(struct lpfc_hba *phba)
dea3101e	188	{
dea3101e	189	int i;
da0436e9	190	struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool;
dea3101e	191
da0436e9	192	/* Free HBQ pools */
ed957684	193	lpfc_sli_hbqbuf_free_all(phba);
8568a4d2 JS	194	if (phba->lpfc_drb_pool)
8568a4d2 JS	195	pci_pool_destroy(phba->lpfc_drb_pool);
da0436e9	196	phba->lpfc_drb_pool = NULL;
8568a4d2 JS	197	if (phba->lpfc_hrb_pool)
8568a4d2 JS	198	pci_pool_destroy(phba->lpfc_hrb_pool);
da0436e9 JS	199	phba->lpfc_hrb_pool = NULL;
da0436e9 JS	200
8568a4d2 JS	201	if (phba->lpfc_hbq_pool)
	202	pci_pool_destroy(phba->lpfc_hbq_pool);
	203	phba->lpfc_hbq_pool = NULL;
	204
21a688cd JS	205	if (phba->rrq_pool)
	206	mempool_destroy(phba->rrq_pool);
	207	phba->rrq_pool = NULL;
	208
da0436e9 JS	209	/* Free NLP memory pool */
	210	mempool_destroy(phba->nlp_mem_pool);
	211	phba->nlp_mem_pool = NULL;
	212
	213	/* Free mbox memory pool */
	214	mempool_destroy(phba->mbox_mem_pool);
	215	phba->mbox_mem_pool = NULL;
	216
	217	/* Free MBUF memory pool */
	218	for (i = 0; i < pool->current_count; i++)
	219	pci_pool_free(phba->lpfc_mbuf_pool, pool->elements[i].virt,
	220	pool->elements[i].phys);
	221	kfree(pool->elements);
	222
	223	pci_pool_destroy(phba->lpfc_mbuf_pool);
	224	phba->lpfc_mbuf_pool = NULL;
ed957684	225
da0436e9 JS	226	/* Free DMA buffer memory pool */
	227	pci_pool_destroy(phba->lpfc_scsi_dma_buf_pool);
	228	phba->lpfc_scsi_dma_buf_pool = NULL;
	229
	230	return;
	231	}
	232
	233	/**
	234	* lpfc_mem_free_all - Frees all PCI and driver memory
	235	* @phba: HBA to free memory for
	236	*
	237	* Description: Free memory from PCI and driver memory pools and also those
	238	* used : lpfc_scsi_dma_buf_pool, lpfc_mbuf_pool, lpfc_hrb_pool. Frees
	239	* kmalloc-backed mempools for LPFC_MBOXQ_t and lpfc_nodelist. Also frees
	240	* the VPI bitmask.
	241	*
	242	* Returns: None
	243	**/
	244	void
	245	lpfc_mem_free_all(struct lpfc_hba *phba)
	246	{
	247	struct lpfc_sli *psli = &phba->sli;
	248	LPFC_MBOXQ_t mbox, next_mbox;
	249	struct lpfc_dmabuf *mp;
	250
	251	/* Free memory used in mailbox queue back to mailbox memory pool */
dea3101e JB	252	list_for_each_entry_safe(mbox, next_mbox, &psli->mboxq, list) {
	253	mp = (struct lpfc_dmabuf *) (mbox->context1);
	254	if (mp) {
	255	lpfc_mbuf_free(phba, mp->virt, mp->phys);
	256	kfree(mp);
	257	}
	258	list_del(&mbox->list);
	259	mempool_free(mbox, phba->mbox_mem_pool);
	260	}
da0436e9	261	/* Free memory used in mailbox cmpl list back to mailbox memory pool */
92d7f7b0 JS	262	list_for_each_entry_safe(mbox, next_mbox, &psli->mboxq_cmpl, list) {
	263	mp = (struct lpfc_dmabuf *) (mbox->context1);
	264	if (mp) {
	265	lpfc_mbuf_free(phba, mp->virt, mp->phys);
	266	kfree(mp);
	267	}
	268	list_del(&mbox->list);
	269	mempool_free(mbox, phba->mbox_mem_pool);
	270	}
da0436e9 JS	271	/* Free the active mailbox command back to the mailbox memory pool */
da0436e9 JS	272	spin_lock_irq(&phba->hbalock);
dea3101e	273	psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
da0436e9	274	spin_unlock_irq(&phba->hbalock);
dea3101e JB	275	if (psli->mbox_active) {
	276	mbox = psli->mbox_active;
	277	mp = (struct lpfc_dmabuf *) (mbox->context1);
	278	if (mp) {
	279	lpfc_mbuf_free(phba, mp->virt, mp->phys);
	280	kfree(mp);
	281	}
	282	mempool_free(mbox, phba->mbox_mem_pool);
	283	psli->mbox_active = NULL;
	284	}
	285
da0436e9 JS	286	/* Free and destroy all the allocated memory pools */
da0436e9 JS	287	lpfc_mem_free(phba);
2e0fef85	288
e59058c4	289	/* Free the iocb lookup array */
9f49d3b0 JS	290	kfree(psli->iocbq_lookup);
9f49d3b0 JS	291	psli->iocbq_lookup = NULL;
da0436e9 JS	292
da0436e9 JS	293	return;
dea3101e JB	294	}
dea3101e JB	295
e59058c4	296	/**
3621a710	297	* lpfc_mbuf_alloc - Allocate an mbuf from the lpfc_mbuf_pool PCI pool
e59058c4 JS	298	* @phba: HBA which owns the pool to allocate from
	299	* @mem_flags: indicates if this is a priority (MEM_PRI) allocation
	300	* @handle: used to return the DMA-mapped address of the mbuf
	301	*
	302	* Description: Allocates a DMA-mapped buffer from the lpfc_mbuf_pool PCI pool.
	303	* Allocates from generic pci_pool_alloc function first and if that fails and
	304	* mem_flags has MEM_PRI set (the only defined flag), returns an mbuf from the
	305	* HBA's pool.
	306	*
	307	* Notes: Not interrupt-safe. Must be called with no locks held. Takes
	308	* phba->hbalock.
	309	*
	310	* Returns:
	311	* pointer to the allocated mbuf on success
	312	* NULL on failure
	313	**/
dea3101e JB	314	void *
	315	lpfc_mbuf_alloc(struct lpfc_hba phba, int mem_flags, dma_addr_t handle)
	316	{
	317	struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool;
2e0fef85	318	unsigned long iflags;
dea3101e JB	319	void *ret;
	320
	321	ret = pci_pool_alloc(phba->lpfc_mbuf_pool, GFP_KERNEL, handle);
	322
2e0fef85	323	spin_lock_irqsave(&phba->hbalock, iflags);
92d7f7b0	324	if (!ret && (mem_flags & MEM_PRI) && pool->current_count) {
dea3101e JB	325	pool->current_count--;
	326	ret = pool->elements[pool->current_count].virt;
	327	*handle = pool->elements[pool->current_count].phys;
	328	}
2e0fef85	329	spin_unlock_irqrestore(&phba->hbalock, iflags);
dea3101e JB	330	return ret;
	331	}
	332
e59058c4	333	/**
3621a710	334	* __lpfc_mbuf_free - Free an mbuf from the lpfc_mbuf_pool PCI pool (locked)
e59058c4 JS	335	* @phba: HBA which owns the pool to return to
	336	* @virt: mbuf to free
	337	* @dma: the DMA-mapped address of the lpfc_mbuf_pool to be freed
	338	*
	339	* Description: Returns an mbuf lpfc_mbuf_pool to the lpfc_mbuf_safety_pool if
	340	* it is below its max_count, frees the mbuf otherwise.
	341	*
	342	* Notes: Must be called with phba->hbalock held to synchronize access to
	343	* lpfc_mbuf_safety_pool.
	344	*
	345	* Returns: None
	346	**/
dea3101e	347	void
2e0fef85	348	__lpfc_mbuf_free(struct lpfc_hba * phba, void *virt, dma_addr_t dma)
dea3101e JB	349	{
	350	struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool;
	351
	352	if (pool->current_count < pool->max_count) {
	353	pool->elements[pool->current_count].virt = virt;
	354	pool->elements[pool->current_count].phys = dma;
	355	pool->current_count++;
	356	} else {
	357	pci_pool_free(phba->lpfc_mbuf_pool, virt, dma);
	358	}
	359	return;
	360	}
2e0fef85	361
e59058c4	362	/**
3621a710	363	* lpfc_mbuf_free - Free an mbuf from the lpfc_mbuf_pool PCI pool (unlocked)
e59058c4 JS	364	* @phba: HBA which owns the pool to return to
	365	* @virt: mbuf to free
	366	* @dma: the DMA-mapped address of the lpfc_mbuf_pool to be freed
	367	*
	368	* Description: Returns an mbuf lpfc_mbuf_pool to the lpfc_mbuf_safety_pool if
	369	* it is below its max_count, frees the mbuf otherwise.
	370	*
	371	* Notes: Takes phba->hbalock. Can be called with or without other locks held.
	372	*
	373	* Returns: None
	374	**/
2e0fef85 JS	375	void
	376	lpfc_mbuf_free(struct lpfc_hba * phba, void *virt, dma_addr_t dma)
	377	{
	378	unsigned long iflags;
	379
	380	spin_lock_irqsave(&phba->hbalock, iflags);
	381	__lpfc_mbuf_free(phba, virt, dma);
	382	spin_unlock_irqrestore(&phba->hbalock, iflags);
	383	return;
	384	}
ed957684	385
e59058c4	386	/**
3621a710	387	* lpfc_els_hbq_alloc - Allocate an HBQ buffer
e59058c4 JS	388	* @phba: HBA to allocate HBQ buffer for
e59058c4 JS	389	*
da0436e9	390	* Description: Allocates a DMA-mapped HBQ buffer from the lpfc_hrb_pool PCI
e59058c4 JS	391	* pool along a non-DMA-mapped container for it.
	392	*
	393	* Notes: Not interrupt-safe. Must be called with no locks held.
	394	*
	395	* Returns:
	396	* pointer to HBQ on success
	397	* NULL on failure
	398	**/
51ef4c26 JS	399	struct hbq_dmabuf *
51ef4c26 JS	400	lpfc_els_hbq_alloc(struct lpfc_hba *phba)
ed957684	401	{
51ef4c26 JS	402	struct hbq_dmabuf *hbqbp;
51ef4c26 JS	403
2e90f4b5	404	hbqbp = kzalloc(sizeof(struct hbq_dmabuf), GFP_KERNEL);
51ef4c26 JS	405	if (!hbqbp)
	406	return NULL;
	407
8568a4d2	408	hbqbp->dbuf.virt = pci_pool_alloc(phba->lpfc_hbq_pool, GFP_KERNEL,
51ef4c26 JS	409	&hbqbp->dbuf.phys);
	410	if (!hbqbp->dbuf.virt) {
	411	kfree(hbqbp);
	412	return NULL;
	413	}
	414	hbqbp->size = LPFC_BPL_SIZE;
	415	return hbqbp;
ed957684 JS	416	}
ed957684 JS	417
e59058c4	418	/**
da0436e9	419	* lpfc_els_hbq_free - Frees an HBQ buffer allocated with lpfc_els_hbq_alloc
e59058c4 JS	420	* @phba: HBA buffer was allocated for
	421	* @hbqbp: HBQ container returned by lpfc_els_hbq_alloc
	422	*
	423	* Description: Frees both the container and the DMA-mapped buffer returned by
	424	* lpfc_els_hbq_alloc.
	425	*
	426	* Notes: Can be called with or without locks held.
	427	*
	428	* Returns: None
	429	**/
ed957684	430	void
51ef4c26	431	lpfc_els_hbq_free(struct lpfc_hba phba, struct hbq_dmabuf hbqbp)
ed957684	432	{
8568a4d2	433	pci_pool_free(phba->lpfc_hbq_pool, hbqbp->dbuf.virt, hbqbp->dbuf.phys);
51ef4c26	434	kfree(hbqbp);
ed957684 JS	435	return;
	436	}
	437
da0436e9 JS	438	/**
	439	* lpfc_sli4_rb_alloc - Allocate an SLI4 Receive buffer
	440	* @phba: HBA to allocate a receive buffer for
	441	*
	442	* Description: Allocates a DMA-mapped receive buffer from the lpfc_hrb_pool PCI
	443	* pool along a non-DMA-mapped container for it.
	444	*
	445	* Notes: Not interrupt-safe. Must be called with no locks held.
	446	*
	447	* Returns:
	448	* pointer to HBQ on success
	449	* NULL on failure
	450	**/
	451	struct hbq_dmabuf *
	452	lpfc_sli4_rb_alloc(struct lpfc_hba *phba)
	453	{
	454	struct hbq_dmabuf *dma_buf;
	455
2e90f4b5	456	dma_buf = kzalloc(sizeof(struct hbq_dmabuf), GFP_KERNEL);
da0436e9 JS	457	if (!dma_buf)
	458	return NULL;
	459
	460	dma_buf->hbuf.virt = pci_pool_alloc(phba->lpfc_hrb_pool, GFP_KERNEL,
	461	&dma_buf->hbuf.phys);
	462	if (!dma_buf->hbuf.virt) {
	463	kfree(dma_buf);
	464	return NULL;
	465	}
	466	dma_buf->dbuf.virt = pci_pool_alloc(phba->lpfc_drb_pool, GFP_KERNEL,
	467	&dma_buf->dbuf.phys);
	468	if (!dma_buf->dbuf.virt) {
	469	pci_pool_free(phba->lpfc_hrb_pool, dma_buf->hbuf.virt,
	470	dma_buf->hbuf.phys);
	471	kfree(dma_buf);
	472	return NULL;
	473	}
	474	dma_buf->size = LPFC_BPL_SIZE;
	475	return dma_buf;
	476	}
	477
	478	/**
	479	* lpfc_sli4_rb_free - Frees a receive buffer
	480	* @phba: HBA buffer was allocated for
	481	* @dmab: DMA Buffer container returned by lpfc_sli4_hbq_alloc
	482	*
	483	* Description: Frees both the container and the DMA-mapped buffers returned by
	484	* lpfc_sli4_rb_alloc.
	485	*
	486	* Notes: Can be called with or without locks held.
	487	*
	488	* Returns: None
	489	**/
	490	void
	491	lpfc_sli4_rb_free(struct lpfc_hba phba, struct hbq_dmabuf dmab)
	492	{
	493	pci_pool_free(phba->lpfc_hrb_pool, dmab->hbuf.virt, dmab->hbuf.phys);
	494	pci_pool_free(phba->lpfc_drb_pool, dmab->dbuf.virt, dmab->dbuf.phys);
	495	kfree(dmab);
	496	return;
	497	}
	498
e59058c4	499	/**
3621a710	500	* lpfc_in_buf_free - Free a DMA buffer
e59058c4 JS	501	* @phba: HBA buffer is associated with
	502	* @mp: Buffer to free
	503	*
	504	* Description: Frees the given DMA buffer in the appropriate way given if the
	505	* HBA is running in SLI3 mode with HBQs enabled.
	506	*
	507	* Notes: Takes phba->hbalock. Can be called with or without other locks held.
	508	*
	509	* Returns: None
	510	**/
92d7f7b0 JS	511	void
	512	lpfc_in_buf_free(struct lpfc_hba phba, struct lpfc_dmabuf mp)
	513	{
	514	struct hbq_dmabuf *hbq_entry;
3163f725	515	unsigned long flags;
92d7f7b0	516
7f5f3d0d JS	517	if (!mp)
	518	return;
	519
92d7f7b0	520	if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
3163f725 JS	521	/* Check whether HBQ is still in use */
	522	spin_lock_irqsave(&phba->hbalock, flags);
	523	if (!phba->hbq_in_use) {
	524	spin_unlock_irqrestore(&phba->hbalock, flags);
	525	return;
	526	}
92d7f7b0	527	hbq_entry = container_of(mp, struct hbq_dmabuf, dbuf);
3163f725	528	list_del(&hbq_entry->dbuf.list);
92d7f7b0	529	if (hbq_entry->tag == -1) {
51ef4c26 JS	530	(phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
51ef4c26 JS	531	(phba, hbq_entry);
92d7f7b0 JS	532	} else {
	533	lpfc_sli_free_hbq(phba, hbq_entry);
	534	}
3163f725	535	spin_unlock_irqrestore(&phba->hbalock, flags);
92d7f7b0 JS	536	} else {
	537	lpfc_mbuf_free(phba, mp->virt, mp->phys);
	538	kfree(mp);
	539	}
	540	return;
	541	}