/******************************************************************* * This file is part of the Emulex Linux Device Driver for * * Fibre Channel Host Bus Adapters. * * Copyright (C) 2017-2023 Broadcom. All Rights Reserved. The term * * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. * * Copyright (C) 2004-2014 Emulex. All rights reserved. * * EMULEX and SLI are trademarks of Emulex. * * www.broadcom.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.h> #include <scsi/scsi_device.h> #include <scsi/scsi_transport_fc.h> #include <scsi/fc/fc_fs.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.h" #include "lpfc_scsi.h" #include "lpfc_crtn.h" #include "lpfc_logmsg.h" #define LPFC_MBUF_POOL_SIZE … #define LPFC_MEM_POOL_SIZE … #define LPFC_DEVICE_DATA_POOL_SIZE … #define LPFC_RRQ_POOL_SIZE … #define LPFC_MBX_POOL_SIZE … /* lpfc_mbox_free_sli_mbox * * @phba: HBA to free memory for * @mbox: mailbox command to free * * This routine detects the mbox type and calls the correct * free routine to fully release all associated memory. */ static void lpfc_mem_free_sli_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *mbox) { … } int lpfc_mem_alloc_active_rrq_pool_s4(struct lpfc_hba *phba) { … } /** * lpfc_mem_alloc - create and allocate all PCI and memory pools * @phba: HBA to allocate pools for * @align: alignment requirement for blocks; must be a power of two * * Description: Creates and allocates PCI pools 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) { … } int lpfc_nvmet_mem_alloc(struct lpfc_hba *phba) { … } /** * 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) { … } /** * 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_sg_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) { … } /** * 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 dma_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) { … } /** * __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) { … } /** * 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) { … } /** * lpfc_nvmet_buf_alloc - Allocate an nvmet_buf from the * lpfc_sg_dma_buf_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 nvmet_buf * * Description: Allocates a DMA-mapped buffer from the lpfc_sg_dma_buf_pool * PCI pool. Allocates from generic dma_pool_alloc function. * * Returns: * pointer to the allocated nvmet_buf on success * NULL on failure **/ void * lpfc_nvmet_buf_alloc(struct lpfc_hba *phba, int mem_flags, dma_addr_t *handle) { … } /** * lpfc_nvmet_buf_free - Free an nvmet_buf from the lpfc_sg_dma_buf_pool * PCI pool * @phba: HBA which owns the pool to return to * @virt: nvmet_buf to free * @dma: the DMA-mapped address of the lpfc_sg_dma_buf_pool to be freed * * Returns: None **/ void lpfc_nvmet_buf_free(struct lpfc_hba *phba, void *virt, dma_addr_t dma) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * lpfc_sli4_nvmet_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. * * Returns: * pointer to HBQ on success * NULL on failure **/ struct rqb_dmabuf * lpfc_sli4_nvmet_alloc(struct lpfc_hba *phba) { … } /** * lpfc_sli4_nvmet_free - Frees a receive buffer * @phba: HBA buffer was allocated for * @dmab: DMA Buffer container returned by lpfc_sli4_rbq_alloc * * Description: Frees both the container and the DMA-mapped buffers returned by * lpfc_sli4_nvmet_alloc. * * Notes: Can be called with or without locks held. * * Returns: None **/ void lpfc_sli4_nvmet_free(struct lpfc_hba *phba, struct rqb_dmabuf *dmab) { … } /** * 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) { … } /** * lpfc_rq_buf_free - Free a RQ DMA buffer * @phba: HBA buffer is associated with * @mp: Buffer to free * * Description: Frees the given DMA buffer in the appropriate way given by * reposting it to its associated RQ so it can be reused. * * Notes: Takes phba->hbalock. Can be called with or without other locks held. * * Returns: None **/ void lpfc_rq_buf_free(struct lpfc_hba *phba, struct lpfc_dmabuf *mp) { … }
Codebase Browser
linux