1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2017 Broadcom. All Rights Reserved. The term * 5 * “Broadcom” refers to Broadcom Limited and/or its subsidiaries. * 6 * Copyright (C) 2004-2014 Emulex. All rights reserved. * 7 * EMULEX and SLI are trademarks of Emulex. * 8 * www.broadcom.com * 9 * Portions Copyright (C) 2004-2005 Christoph Hellwig * 10 * * 11 * This program is free software; you can redistribute it and/or * 12 * modify it under the terms of version 2 of the GNU General * 13 * Public License as published by the Free Software Foundation. * 14 * This program is distributed in the hope that it will be useful. * 15 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND * 16 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, * 17 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE * 18 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD * 19 * TO BE LEGALLY INVALID. See the GNU General Public License for * 20 * more details, a copy of which can be found in the file COPYING * 21 * included with this package. * 22 *******************************************************************/ 23 24 #include <linux/mempool.h> 25 #include <linux/slab.h> 26 #include <linux/pci.h> 27 #include <linux/interrupt.h> 28 29 #include <scsi/scsi.h> 30 #include <scsi/scsi_device.h> 31 #include <scsi/scsi_transport_fc.h> 32 #include <scsi/fc/fc_fs.h> 33 34 #include <linux/nvme-fc-driver.h> 35 36 #include "lpfc_hw4.h" 37 #include "lpfc_hw.h" 38 #include "lpfc_sli.h" 39 #include "lpfc_sli4.h" 40 #include "lpfc_nl.h" 41 #include "lpfc_disc.h" 42 #include "lpfc.h" 43 #include "lpfc_scsi.h" 44 #include "lpfc_nvme.h" 45 #include "lpfc_nvmet.h" 46 #include "lpfc_crtn.h" 47 #include "lpfc_logmsg.h" 48 49 #define LPFC_MBUF_POOL_SIZE 64 /* max elements in MBUF safety pool */ 50 #define LPFC_MEM_POOL_SIZE 64 /* max elem in non-DMA safety pool */ 51 #define LPFC_DEVICE_DATA_POOL_SIZE 64 /* max elements in device data pool */ 52 53 int 54 lpfc_mem_alloc_active_rrq_pool_s4(struct lpfc_hba *phba) { 55 size_t bytes; 56 int max_xri = phba->sli4_hba.max_cfg_param.max_xri; 57 58 if (max_xri <= 0) 59 return -ENOMEM; 60 bytes = ((BITS_PER_LONG - 1 + max_xri) / BITS_PER_LONG) * 61 sizeof(unsigned long); 62 phba->cfg_rrq_xri_bitmap_sz = bytes; 63 phba->active_rrq_pool = mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE, 64 bytes); 65 if (!phba->active_rrq_pool) 66 return -ENOMEM; 67 else 68 return 0; 69 } 70 71 /** 72 * lpfc_mem_alloc - create and allocate all PCI and memory pools 73 * @phba: HBA to allocate pools for 74 * 75 * Description: Creates and allocates PCI pools lpfc_sg_dma_buf_pool, 76 * lpfc_mbuf_pool, lpfc_hrb_pool. Creates and allocates kmalloc-backed mempools 77 * for LPFC_MBOXQ_t and lpfc_nodelist. Also allocates the VPI bitmask. 78 * 79 * Notes: Not interrupt-safe. Must be called with no locks held. If any 80 * allocation fails, frees all successfully allocated memory before returning. 81 * 82 * Returns: 83 * 0 on success 84 * -ENOMEM on failure (if any memory allocations fail) 85 **/ 86 int 87 lpfc_mem_alloc(struct lpfc_hba *phba, int align) 88 { 89 struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool; 90 int i; 91 92 if (phba->sli_rev == LPFC_SLI_REV4) { 93 /* Calculate alignment */ 94 if (phba->cfg_sg_dma_buf_size < SLI4_PAGE_SIZE) 95 i = phba->cfg_sg_dma_buf_size; 96 else 97 i = SLI4_PAGE_SIZE; 98 99 phba->lpfc_sg_dma_buf_pool = 100 dma_pool_create("lpfc_sg_dma_buf_pool", 101 &phba->pcidev->dev, 102 phba->cfg_sg_dma_buf_size, 103 i, 0); 104 if (!phba->lpfc_sg_dma_buf_pool) 105 goto fail; 106 107 } else { 108 phba->lpfc_sg_dma_buf_pool = 109 dma_pool_create("lpfc_sg_dma_buf_pool", 110 &phba->pcidev->dev, phba->cfg_sg_dma_buf_size, 111 align, 0); 112 113 if (!phba->lpfc_sg_dma_buf_pool) 114 goto fail; 115 } 116 117 phba->lpfc_mbuf_pool = dma_pool_create("lpfc_mbuf_pool", &phba->pcidev->dev, 118 LPFC_BPL_SIZE, 119 align, 0); 120 if (!phba->lpfc_mbuf_pool) 121 goto fail_free_dma_buf_pool; 122 123 pool->elements = kmalloc(sizeof(struct lpfc_dmabuf) * 124 LPFC_MBUF_POOL_SIZE, GFP_KERNEL); 125 if (!pool->elements) 126 goto fail_free_lpfc_mbuf_pool; 127 128 pool->max_count = 0; 129 pool->current_count = 0; 130 for ( i = 0; i < LPFC_MBUF_POOL_SIZE; i++) { 131 pool->elements[i].virt = dma_pool_alloc(phba->lpfc_mbuf_pool, 132 GFP_KERNEL, &pool->elements[i].phys); 133 if (!pool->elements[i].virt) 134 goto fail_free_mbuf_pool; 135 pool->max_count++; 136 pool->current_count++; 137 } 138 139 phba->mbox_mem_pool = mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE, 140 sizeof(LPFC_MBOXQ_t)); 141 if (!phba->mbox_mem_pool) 142 goto fail_free_mbuf_pool; 143 144 phba->nlp_mem_pool = mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE, 145 sizeof(struct lpfc_nodelist)); 146 if (!phba->nlp_mem_pool) 147 goto fail_free_mbox_pool; 148 149 if (phba->sli_rev == LPFC_SLI_REV4) { 150 phba->rrq_pool = 151 mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE, 152 sizeof(struct lpfc_node_rrq)); 153 if (!phba->rrq_pool) 154 goto fail_free_nlp_mem_pool; 155 phba->lpfc_hrb_pool = dma_pool_create("lpfc_hrb_pool", 156 &phba->pcidev->dev, 157 LPFC_HDR_BUF_SIZE, align, 0); 158 if (!phba->lpfc_hrb_pool) 159 goto fail_free_rrq_mem_pool; 160 161 phba->lpfc_drb_pool = dma_pool_create("lpfc_drb_pool", 162 &phba->pcidev->dev, 163 LPFC_DATA_BUF_SIZE, align, 0); 164 if (!phba->lpfc_drb_pool) 165 goto fail_free_hrb_pool; 166 phba->lpfc_hbq_pool = NULL; 167 } else { 168 phba->lpfc_hbq_pool = dma_pool_create("lpfc_hbq_pool", 169 &phba->pcidev->dev, LPFC_BPL_SIZE, align, 0); 170 if (!phba->lpfc_hbq_pool) 171 goto fail_free_nlp_mem_pool; 172 phba->lpfc_hrb_pool = NULL; 173 phba->lpfc_drb_pool = NULL; 174 } 175 176 if (phba->cfg_EnableXLane) { 177 phba->device_data_mem_pool = mempool_create_kmalloc_pool( 178 LPFC_DEVICE_DATA_POOL_SIZE, 179 sizeof(struct lpfc_device_data)); 180 if (!phba->device_data_mem_pool) 181 goto fail_free_drb_pool; 182 } else { 183 phba->device_data_mem_pool = NULL; 184 } 185 186 return 0; 187 fail_free_drb_pool: 188 dma_pool_destroy(phba->lpfc_drb_pool); 189 phba->lpfc_drb_pool = NULL; 190 fail_free_hrb_pool: 191 dma_pool_destroy(phba->lpfc_hrb_pool); 192 phba->lpfc_hrb_pool = NULL; 193 fail_free_rrq_mem_pool: 194 mempool_destroy(phba->rrq_pool); 195 phba->rrq_pool = NULL; 196 fail_free_nlp_mem_pool: 197 mempool_destroy(phba->nlp_mem_pool); 198 phba->nlp_mem_pool = NULL; 199 fail_free_mbox_pool: 200 mempool_destroy(phba->mbox_mem_pool); 201 phba->mbox_mem_pool = NULL; 202 fail_free_mbuf_pool: 203 while (i--) 204 dma_pool_free(phba->lpfc_mbuf_pool, pool->elements[i].virt, 205 pool->elements[i].phys); 206 kfree(pool->elements); 207 fail_free_lpfc_mbuf_pool: 208 dma_pool_destroy(phba->lpfc_mbuf_pool); 209 phba->lpfc_mbuf_pool = NULL; 210 fail_free_dma_buf_pool: 211 dma_pool_destroy(phba->lpfc_sg_dma_buf_pool); 212 phba->lpfc_sg_dma_buf_pool = NULL; 213 fail: 214 return -ENOMEM; 215 } 216 217 int 218 lpfc_nvmet_mem_alloc(struct lpfc_hba *phba) 219 { 220 phba->lpfc_nvmet_drb_pool = 221 dma_pool_create("lpfc_nvmet_drb_pool", 222 &phba->pcidev->dev, LPFC_NVMET_DATA_BUF_SIZE, 223 SGL_ALIGN_SZ, 0); 224 if (!phba->lpfc_nvmet_drb_pool) { 225 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 226 "6024 Can't enable NVME Target - no memory\n"); 227 return -ENOMEM; 228 } 229 return 0; 230 } 231 232 /** 233 * lpfc_mem_free - Frees memory allocated by lpfc_mem_alloc 234 * @phba: HBA to free memory for 235 * 236 * Description: Free the memory allocated by lpfc_mem_alloc routine. This 237 * routine is a the counterpart of lpfc_mem_alloc. 238 * 239 * Returns: None 240 **/ 241 void 242 lpfc_mem_free(struct lpfc_hba *phba) 243 { 244 int i; 245 struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool; 246 struct lpfc_device_data *device_data; 247 248 /* Free HBQ pools */ 249 lpfc_sli_hbqbuf_free_all(phba); 250 if (phba->lpfc_nvmet_drb_pool) 251 dma_pool_destroy(phba->lpfc_nvmet_drb_pool); 252 phba->lpfc_nvmet_drb_pool = NULL; 253 if (phba->lpfc_drb_pool) 254 dma_pool_destroy(phba->lpfc_drb_pool); 255 phba->lpfc_drb_pool = NULL; 256 if (phba->lpfc_hrb_pool) 257 dma_pool_destroy(phba->lpfc_hrb_pool); 258 phba->lpfc_hrb_pool = NULL; 259 if (phba->txrdy_payload_pool) 260 dma_pool_destroy(phba->txrdy_payload_pool); 261 phba->txrdy_payload_pool = NULL; 262 263 if (phba->lpfc_hbq_pool) 264 dma_pool_destroy(phba->lpfc_hbq_pool); 265 phba->lpfc_hbq_pool = NULL; 266 267 if (phba->rrq_pool) 268 mempool_destroy(phba->rrq_pool); 269 phba->rrq_pool = NULL; 270 271 /* Free NLP memory pool */ 272 mempool_destroy(phba->nlp_mem_pool); 273 phba->nlp_mem_pool = NULL; 274 if (phba->sli_rev == LPFC_SLI_REV4 && phba->active_rrq_pool) { 275 mempool_destroy(phba->active_rrq_pool); 276 phba->active_rrq_pool = NULL; 277 } 278 279 /* Free mbox memory pool */ 280 mempool_destroy(phba->mbox_mem_pool); 281 phba->mbox_mem_pool = NULL; 282 283 /* Free MBUF memory pool */ 284 for (i = 0; i < pool->current_count; i++) 285 dma_pool_free(phba->lpfc_mbuf_pool, pool->elements[i].virt, 286 pool->elements[i].phys); 287 kfree(pool->elements); 288 289 dma_pool_destroy(phba->lpfc_mbuf_pool); 290 phba->lpfc_mbuf_pool = NULL; 291 292 /* Free DMA buffer memory pool */ 293 dma_pool_destroy(phba->lpfc_sg_dma_buf_pool); 294 phba->lpfc_sg_dma_buf_pool = NULL; 295 296 /* Free Device Data memory pool */ 297 if (phba->device_data_mem_pool) { 298 /* Ensure all objects have been returned to the pool */ 299 while (!list_empty(&phba->luns)) { 300 device_data = list_first_entry(&phba->luns, 301 struct lpfc_device_data, 302 listentry); 303 list_del(&device_data->listentry); 304 mempool_free(device_data, phba->device_data_mem_pool); 305 } 306 mempool_destroy(phba->device_data_mem_pool); 307 } 308 phba->device_data_mem_pool = NULL; 309 return; 310 } 311 312 /** 313 * lpfc_mem_free_all - Frees all PCI and driver memory 314 * @phba: HBA to free memory for 315 * 316 * Description: Free memory from PCI and driver memory pools and also those 317 * used : lpfc_sg_dma_buf_pool, lpfc_mbuf_pool, lpfc_hrb_pool. Frees 318 * kmalloc-backed mempools for LPFC_MBOXQ_t and lpfc_nodelist. Also frees 319 * the VPI bitmask. 320 * 321 * Returns: None 322 **/ 323 void 324 lpfc_mem_free_all(struct lpfc_hba *phba) 325 { 326 struct lpfc_sli *psli = &phba->sli; 327 LPFC_MBOXQ_t *mbox, *next_mbox; 328 struct lpfc_dmabuf *mp; 329 330 /* Free memory used in mailbox queue back to mailbox memory pool */ 331 list_for_each_entry_safe(mbox, next_mbox, &psli->mboxq, list) { 332 mp = (struct lpfc_dmabuf *) (mbox->context1); 333 if (mp) { 334 lpfc_mbuf_free(phba, mp->virt, mp->phys); 335 kfree(mp); 336 } 337 list_del(&mbox->list); 338 mempool_free(mbox, phba->mbox_mem_pool); 339 } 340 /* Free memory used in mailbox cmpl list back to mailbox memory pool */ 341 list_for_each_entry_safe(mbox, next_mbox, &psli->mboxq_cmpl, list) { 342 mp = (struct lpfc_dmabuf *) (mbox->context1); 343 if (mp) { 344 lpfc_mbuf_free(phba, mp->virt, mp->phys); 345 kfree(mp); 346 } 347 list_del(&mbox->list); 348 mempool_free(mbox, phba->mbox_mem_pool); 349 } 350 /* Free the active mailbox command back to the mailbox memory pool */ 351 spin_lock_irq(&phba->hbalock); 352 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE; 353 spin_unlock_irq(&phba->hbalock); 354 if (psli->mbox_active) { 355 mbox = psli->mbox_active; 356 mp = (struct lpfc_dmabuf *) (mbox->context1); 357 if (mp) { 358 lpfc_mbuf_free(phba, mp->virt, mp->phys); 359 kfree(mp); 360 } 361 mempool_free(mbox, phba->mbox_mem_pool); 362 psli->mbox_active = NULL; 363 } 364 365 /* Free and destroy all the allocated memory pools */ 366 lpfc_mem_free(phba); 367 368 /* Free the iocb lookup array */ 369 kfree(psli->iocbq_lookup); 370 psli->iocbq_lookup = NULL; 371 372 return; 373 } 374 375 /** 376 * lpfc_mbuf_alloc - Allocate an mbuf from the lpfc_mbuf_pool PCI pool 377 * @phba: HBA which owns the pool to allocate from 378 * @mem_flags: indicates if this is a priority (MEM_PRI) allocation 379 * @handle: used to return the DMA-mapped address of the mbuf 380 * 381 * Description: Allocates a DMA-mapped buffer from the lpfc_mbuf_pool PCI pool. 382 * Allocates from generic dma_pool_alloc function first and if that fails and 383 * mem_flags has MEM_PRI set (the only defined flag), returns an mbuf from the 384 * HBA's pool. 385 * 386 * Notes: Not interrupt-safe. Must be called with no locks held. Takes 387 * phba->hbalock. 388 * 389 * Returns: 390 * pointer to the allocated mbuf on success 391 * NULL on failure 392 **/ 393 void * 394 lpfc_mbuf_alloc(struct lpfc_hba *phba, int mem_flags, dma_addr_t *handle) 395 { 396 struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool; 397 unsigned long iflags; 398 void *ret; 399 400 ret = dma_pool_alloc(phba->lpfc_mbuf_pool, GFP_KERNEL, handle); 401 402 spin_lock_irqsave(&phba->hbalock, iflags); 403 if (!ret && (mem_flags & MEM_PRI) && pool->current_count) { 404 pool->current_count--; 405 ret = pool->elements[pool->current_count].virt; 406 *handle = pool->elements[pool->current_count].phys; 407 } 408 spin_unlock_irqrestore(&phba->hbalock, iflags); 409 return ret; 410 } 411 412 /** 413 * __lpfc_mbuf_free - Free an mbuf from the lpfc_mbuf_pool PCI pool (locked) 414 * @phba: HBA which owns the pool to return to 415 * @virt: mbuf to free 416 * @dma: the DMA-mapped address of the lpfc_mbuf_pool to be freed 417 * 418 * Description: Returns an mbuf lpfc_mbuf_pool to the lpfc_mbuf_safety_pool if 419 * it is below its max_count, frees the mbuf otherwise. 420 * 421 * Notes: Must be called with phba->hbalock held to synchronize access to 422 * lpfc_mbuf_safety_pool. 423 * 424 * Returns: None 425 **/ 426 void 427 __lpfc_mbuf_free(struct lpfc_hba * phba, void *virt, dma_addr_t dma) 428 { 429 struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool; 430 431 if (pool->current_count < pool->max_count) { 432 pool->elements[pool->current_count].virt = virt; 433 pool->elements[pool->current_count].phys = dma; 434 pool->current_count++; 435 } else { 436 dma_pool_free(phba->lpfc_mbuf_pool, virt, dma); 437 } 438 return; 439 } 440 441 /** 442 * lpfc_mbuf_free - Free an mbuf from the lpfc_mbuf_pool PCI pool (unlocked) 443 * @phba: HBA which owns the pool to return to 444 * @virt: mbuf to free 445 * @dma: the DMA-mapped address of the lpfc_mbuf_pool to be freed 446 * 447 * Description: Returns an mbuf lpfc_mbuf_pool to the lpfc_mbuf_safety_pool if 448 * it is below its max_count, frees the mbuf otherwise. 449 * 450 * Notes: Takes phba->hbalock. Can be called with or without other locks held. 451 * 452 * Returns: None 453 **/ 454 void 455 lpfc_mbuf_free(struct lpfc_hba * phba, void *virt, dma_addr_t dma) 456 { 457 unsigned long iflags; 458 459 spin_lock_irqsave(&phba->hbalock, iflags); 460 __lpfc_mbuf_free(phba, virt, dma); 461 spin_unlock_irqrestore(&phba->hbalock, iflags); 462 return; 463 } 464 465 /** 466 * lpfc_nvmet_buf_alloc - Allocate an nvmet_buf from the 467 * lpfc_sg_dma_buf_pool PCI pool 468 * @phba: HBA which owns the pool to allocate from 469 * @mem_flags: indicates if this is a priority (MEM_PRI) allocation 470 * @handle: used to return the DMA-mapped address of the nvmet_buf 471 * 472 * Description: Allocates a DMA-mapped buffer from the lpfc_sg_dma_buf_pool 473 * PCI pool. Allocates from generic dma_pool_alloc function. 474 * 475 * Returns: 476 * pointer to the allocated nvmet_buf on success 477 * NULL on failure 478 **/ 479 void * 480 lpfc_nvmet_buf_alloc(struct lpfc_hba *phba, int mem_flags, dma_addr_t *handle) 481 { 482 void *ret; 483 484 ret = dma_pool_alloc(phba->lpfc_sg_dma_buf_pool, GFP_KERNEL, handle); 485 return ret; 486 } 487 488 /** 489 * lpfc_nvmet_buf_free - Free an nvmet_buf from the lpfc_sg_dma_buf_pool 490 * PCI pool 491 * @phba: HBA which owns the pool to return to 492 * @virt: nvmet_buf to free 493 * @dma: the DMA-mapped address of the lpfc_sg_dma_buf_pool to be freed 494 * 495 * Returns: None 496 **/ 497 void 498 lpfc_nvmet_buf_free(struct lpfc_hba *phba, void *virt, dma_addr_t dma) 499 { 500 dma_pool_free(phba->lpfc_sg_dma_buf_pool, virt, dma); 501 } 502 503 /** 504 * lpfc_els_hbq_alloc - Allocate an HBQ buffer 505 * @phba: HBA to allocate HBQ buffer for 506 * 507 * Description: Allocates a DMA-mapped HBQ buffer from the lpfc_hrb_pool PCI 508 * pool along a non-DMA-mapped container for it. 509 * 510 * Notes: Not interrupt-safe. Must be called with no locks held. 511 * 512 * Returns: 513 * pointer to HBQ on success 514 * NULL on failure 515 **/ 516 struct hbq_dmabuf * 517 lpfc_els_hbq_alloc(struct lpfc_hba *phba) 518 { 519 struct hbq_dmabuf *hbqbp; 520 521 hbqbp = kzalloc(sizeof(struct hbq_dmabuf), GFP_KERNEL); 522 if (!hbqbp) 523 return NULL; 524 525 hbqbp->dbuf.virt = dma_pool_alloc(phba->lpfc_hbq_pool, GFP_KERNEL, 526 &hbqbp->dbuf.phys); 527 if (!hbqbp->dbuf.virt) { 528 kfree(hbqbp); 529 return NULL; 530 } 531 hbqbp->total_size = LPFC_BPL_SIZE; 532 return hbqbp; 533 } 534 535 /** 536 * lpfc_els_hbq_free - Frees an HBQ buffer allocated with lpfc_els_hbq_alloc 537 * @phba: HBA buffer was allocated for 538 * @hbqbp: HBQ container returned by lpfc_els_hbq_alloc 539 * 540 * Description: Frees both the container and the DMA-mapped buffer returned by 541 * lpfc_els_hbq_alloc. 542 * 543 * Notes: Can be called with or without locks held. 544 * 545 * Returns: None 546 **/ 547 void 548 lpfc_els_hbq_free(struct lpfc_hba *phba, struct hbq_dmabuf *hbqbp) 549 { 550 dma_pool_free(phba->lpfc_hbq_pool, hbqbp->dbuf.virt, hbqbp->dbuf.phys); 551 kfree(hbqbp); 552 return; 553 } 554 555 /** 556 * lpfc_sli4_rb_alloc - Allocate an SLI4 Receive buffer 557 * @phba: HBA to allocate a receive buffer for 558 * 559 * Description: Allocates a DMA-mapped receive buffer from the lpfc_hrb_pool PCI 560 * pool along a non-DMA-mapped container for it. 561 * 562 * Notes: Not interrupt-safe. Must be called with no locks held. 563 * 564 * Returns: 565 * pointer to HBQ on success 566 * NULL on failure 567 **/ 568 struct hbq_dmabuf * 569 lpfc_sli4_rb_alloc(struct lpfc_hba *phba) 570 { 571 struct hbq_dmabuf *dma_buf; 572 573 dma_buf = kzalloc(sizeof(struct hbq_dmabuf), GFP_KERNEL); 574 if (!dma_buf) 575 return NULL; 576 577 dma_buf->hbuf.virt = dma_pool_alloc(phba->lpfc_hrb_pool, GFP_KERNEL, 578 &dma_buf->hbuf.phys); 579 if (!dma_buf->hbuf.virt) { 580 kfree(dma_buf); 581 return NULL; 582 } 583 dma_buf->dbuf.virt = dma_pool_alloc(phba->lpfc_drb_pool, GFP_KERNEL, 584 &dma_buf->dbuf.phys); 585 if (!dma_buf->dbuf.virt) { 586 dma_pool_free(phba->lpfc_hrb_pool, dma_buf->hbuf.virt, 587 dma_buf->hbuf.phys); 588 kfree(dma_buf); 589 return NULL; 590 } 591 dma_buf->total_size = LPFC_DATA_BUF_SIZE; 592 return dma_buf; 593 } 594 595 /** 596 * lpfc_sli4_rb_free - Frees a receive buffer 597 * @phba: HBA buffer was allocated for 598 * @dmab: DMA Buffer container returned by lpfc_sli4_hbq_alloc 599 * 600 * Description: Frees both the container and the DMA-mapped buffers returned by 601 * lpfc_sli4_rb_alloc. 602 * 603 * Notes: Can be called with or without locks held. 604 * 605 * Returns: None 606 **/ 607 void 608 lpfc_sli4_rb_free(struct lpfc_hba *phba, struct hbq_dmabuf *dmab) 609 { 610 dma_pool_free(phba->lpfc_hrb_pool, dmab->hbuf.virt, dmab->hbuf.phys); 611 dma_pool_free(phba->lpfc_drb_pool, dmab->dbuf.virt, dmab->dbuf.phys); 612 kfree(dmab); 613 } 614 615 /** 616 * lpfc_sli4_nvmet_alloc - Allocate an SLI4 Receive buffer 617 * @phba: HBA to allocate a receive buffer for 618 * 619 * Description: Allocates a DMA-mapped receive buffer from the lpfc_hrb_pool PCI 620 * pool along a non-DMA-mapped container for it. 621 * 622 * Notes: Not interrupt-safe. Must be called with no locks held. 623 * 624 * Returns: 625 * pointer to HBQ on success 626 * NULL on failure 627 **/ 628 struct rqb_dmabuf * 629 lpfc_sli4_nvmet_alloc(struct lpfc_hba *phba) 630 { 631 struct rqb_dmabuf *dma_buf; 632 633 dma_buf = kzalloc(sizeof(struct rqb_dmabuf), GFP_KERNEL); 634 if (!dma_buf) 635 return NULL; 636 637 dma_buf->hbuf.virt = dma_pool_alloc(phba->lpfc_hrb_pool, GFP_KERNEL, 638 &dma_buf->hbuf.phys); 639 if (!dma_buf->hbuf.virt) { 640 kfree(dma_buf); 641 return NULL; 642 } 643 dma_buf->dbuf.virt = dma_pool_alloc(phba->lpfc_nvmet_drb_pool, 644 GFP_KERNEL, &dma_buf->dbuf.phys); 645 if (!dma_buf->dbuf.virt) { 646 dma_pool_free(phba->lpfc_hrb_pool, dma_buf->hbuf.virt, 647 dma_buf->hbuf.phys); 648 kfree(dma_buf); 649 return NULL; 650 } 651 dma_buf->total_size = LPFC_NVMET_DATA_BUF_SIZE; 652 return dma_buf; 653 } 654 655 /** 656 * lpfc_sli4_nvmet_free - Frees a receive buffer 657 * @phba: HBA buffer was allocated for 658 * @dmab: DMA Buffer container returned by lpfc_sli4_rbq_alloc 659 * 660 * Description: Frees both the container and the DMA-mapped buffers returned by 661 * lpfc_sli4_nvmet_alloc. 662 * 663 * Notes: Can be called with or without locks held. 664 * 665 * Returns: None 666 **/ 667 void 668 lpfc_sli4_nvmet_free(struct lpfc_hba *phba, struct rqb_dmabuf *dmab) 669 { 670 dma_pool_free(phba->lpfc_hrb_pool, dmab->hbuf.virt, dmab->hbuf.phys); 671 dma_pool_free(phba->lpfc_nvmet_drb_pool, 672 dmab->dbuf.virt, dmab->dbuf.phys); 673 kfree(dmab); 674 } 675 676 /** 677 * lpfc_in_buf_free - Free a DMA buffer 678 * @phba: HBA buffer is associated with 679 * @mp: Buffer to free 680 * 681 * Description: Frees the given DMA buffer in the appropriate way given if the 682 * HBA is running in SLI3 mode with HBQs enabled. 683 * 684 * Notes: Takes phba->hbalock. Can be called with or without other locks held. 685 * 686 * Returns: None 687 **/ 688 void 689 lpfc_in_buf_free(struct lpfc_hba *phba, struct lpfc_dmabuf *mp) 690 { 691 struct hbq_dmabuf *hbq_entry; 692 unsigned long flags; 693 694 if (!mp) 695 return; 696 697 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) { 698 hbq_entry = container_of(mp, struct hbq_dmabuf, dbuf); 699 /* Check whether HBQ is still in use */ 700 spin_lock_irqsave(&phba->hbalock, flags); 701 if (!phba->hbq_in_use) { 702 spin_unlock_irqrestore(&phba->hbalock, flags); 703 return; 704 } 705 list_del(&hbq_entry->dbuf.list); 706 if (hbq_entry->tag == -1) { 707 (phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer) 708 (phba, hbq_entry); 709 } else { 710 lpfc_sli_free_hbq(phba, hbq_entry); 711 } 712 spin_unlock_irqrestore(&phba->hbalock, flags); 713 } else { 714 lpfc_mbuf_free(phba, mp->virt, mp->phys); 715 kfree(mp); 716 } 717 return; 718 } 719 720 /** 721 * lpfc_rq_buf_free - Free a RQ DMA buffer 722 * @phba: HBA buffer is associated with 723 * @mp: Buffer to free 724 * 725 * Description: Frees the given DMA buffer in the appropriate way given by 726 * reposting it to its associated RQ so it can be reused. 727 * 728 * Notes: Takes phba->hbalock. Can be called with or without other locks held. 729 * 730 * Returns: None 731 **/ 732 void 733 lpfc_rq_buf_free(struct lpfc_hba *phba, struct lpfc_dmabuf *mp) 734 { 735 struct lpfc_rqb *rqbp; 736 struct lpfc_rqe hrqe; 737 struct lpfc_rqe drqe; 738 struct rqb_dmabuf *rqb_entry; 739 unsigned long flags; 740 int rc; 741 742 if (!mp) 743 return; 744 745 rqb_entry = container_of(mp, struct rqb_dmabuf, hbuf); 746 rqbp = rqb_entry->hrq->rqbp; 747 748 spin_lock_irqsave(&phba->hbalock, flags); 749 list_del(&rqb_entry->hbuf.list); 750 hrqe.address_lo = putPaddrLow(rqb_entry->hbuf.phys); 751 hrqe.address_hi = putPaddrHigh(rqb_entry->hbuf.phys); 752 drqe.address_lo = putPaddrLow(rqb_entry->dbuf.phys); 753 drqe.address_hi = putPaddrHigh(rqb_entry->dbuf.phys); 754 rc = lpfc_sli4_rq_put(rqb_entry->hrq, rqb_entry->drq, &hrqe, &drqe); 755 if (rc < 0) { 756 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 757 "6409 Cannot post to RQ %d: %x %x\n", 758 rqb_entry->hrq->queue_id, 759 rqb_entry->hrq->host_index, 760 rqb_entry->hrq->hba_index); 761 (rqbp->rqb_free_buffer)(phba, rqb_entry); 762 } else { 763 list_add_tail(&rqb_entry->hbuf.list, &rqbp->rqb_buffer_list); 764 rqbp->buffer_count++; 765 } 766 767 spin_unlock_irqrestore(&phba->hbalock, flags); 768 } 769