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