1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2008 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
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 *******************************************************************/
22 #include <linux/blkdev.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
25 #include <linux/delay.h>
27 #include <scsi/scsi.h>
28 #include <scsi/scsi_cmnd.h>
29 #include <scsi/scsi_device.h>
30 #include <scsi/scsi_host.h>
31 #include <scsi/scsi_transport_fc.h>
35 #include "lpfc_disc.h"
36 #include "lpfc_scsi.h"
38 #include "lpfc_crtn.h"
39 #include "lpfc_logmsg.h"
40 #include "lpfc_compat.h"
41 #include "lpfc_debugfs.h"
44 * Define macro to log: Mailbox command x%x cannot issue Data
45 * This allows multiple uses of lpfc_msgBlk0311
46 * w/o perturbing log msg utility.
48 #define LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag) \
49 lpfc_printf_log(phba, \
52 "(%d):0311 Mailbox command x%x cannot " \
53 "issue Data: x%x x%x x%x\n", \
54 pmbox->vport ? pmbox->vport->vpi : 0, \
55 pmbox->mb.mbxCommand, \
56 phba->pport->port_state, \
61 /* There are only four IOCB completion types. */
62 typedef enum _lpfc_iocb_type {
70 * lpfc_cmd_iocb: Get next command iocb entry in the ring.
71 * @phba: Pointer to HBA context object.
72 * @pring: Pointer to driver SLI ring object.
74 * This function returns pointer to next command iocb entry
75 * in the command ring. The caller must hold hbalock to prevent
76 * other threads consume the next command iocb.
77 * SLI-2/SLI-3 provide different sized iocbs.
79 static inline IOCB_t *
80 lpfc_cmd_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
82 return (IOCB_t *) (((char *) pring->cmdringaddr) +
83 pring->cmdidx * phba->iocb_cmd_size);
87 * lpfc_resp_iocb: Get next response iocb entry in the ring.
88 * @phba: Pointer to HBA context object.
89 * @pring: Pointer to driver SLI ring object.
91 * This function returns pointer to next response iocb entry
92 * in the response ring. The caller must hold hbalock to make sure
93 * that no other thread consume the next response iocb.
94 * SLI-2/SLI-3 provide different sized iocbs.
96 static inline IOCB_t *
97 lpfc_resp_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
99 return (IOCB_t *) (((char *) pring->rspringaddr) +
100 pring->rspidx * phba->iocb_rsp_size);
104 * __lpfc_sli_get_iocbq: Allocates an iocb object from iocb pool.
105 * @phba: Pointer to HBA context object.
107 * This function is called with hbalock held. This function
108 * allocates a new driver iocb object from the iocb pool. If the
109 * allocation is successful, it returns pointer to the newly
110 * allocated iocb object else it returns NULL.
112 static struct lpfc_iocbq *
113 __lpfc_sli_get_iocbq(struct lpfc_hba *phba)
115 struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
116 struct lpfc_iocbq * iocbq = NULL;
118 list_remove_head(lpfc_iocb_list, iocbq, struct lpfc_iocbq, list);
123 * lpfc_sli_get_iocbq: Allocates an iocb object from iocb pool.
124 * @phba: Pointer to HBA context object.
126 * This function is called with no lock held. This function
127 * allocates a new driver iocb object from the iocb pool. If the
128 * allocation is successful, it returns pointer to the newly
129 * allocated iocb object else it returns NULL.
132 lpfc_sli_get_iocbq(struct lpfc_hba *phba)
134 struct lpfc_iocbq * iocbq = NULL;
135 unsigned long iflags;
137 spin_lock_irqsave(&phba->hbalock, iflags);
138 iocbq = __lpfc_sli_get_iocbq(phba);
139 spin_unlock_irqrestore(&phba->hbalock, iflags);
144 * __lpfc_sli_release_iocbq: Release iocb to the iocb pool.
145 * @phba: Pointer to HBA context object.
146 * @iocbq: Pointer to driver iocb object.
148 * This function is called with hbalock held to release driver
149 * iocb object to the iocb pool. The iotag in the iocb object
150 * does not change for each use of the iocb object. This function
151 * clears all other fields of the iocb object when it is freed.
154 __lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
156 size_t start_clean = offsetof(struct lpfc_iocbq, iocb);
159 * Clean all volatile data fields, preserve iotag and node struct.
161 memset((char*)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean);
162 list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
166 * lpfc_sli_release_iocbq: Release iocb to the iocb pool.
167 * @phba: Pointer to HBA context object.
168 * @iocbq: Pointer to driver iocb object.
170 * This function is called with no lock held to release the iocb to
174 lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
176 unsigned long iflags;
179 * Clean all volatile data fields, preserve iotag and node struct.
181 spin_lock_irqsave(&phba->hbalock, iflags);
182 __lpfc_sli_release_iocbq(phba, iocbq);
183 spin_unlock_irqrestore(&phba->hbalock, iflags);
187 * lpfc_sli_iocb_cmd_type: Get the iocb type.
188 * @iocb_cmnd : iocb command code.
190 * This function is called by ring event handler function to get the iocb type.
191 * This function translates the iocb command to an iocb command type used to
192 * decide the final disposition of each completed IOCB.
193 * The function returns
194 * LPFC_UNKNOWN_IOCB if it is an unsupported iocb
195 * LPFC_SOL_IOCB if it is a solicited iocb completion
196 * LPFC_ABORT_IOCB if it is an abort iocb
197 * LPFC_UNSOL_IOCB if it is an unsolicited iocb
199 * The caller is not required to hold any lock.
201 static lpfc_iocb_type
202 lpfc_sli_iocb_cmd_type(uint8_t iocb_cmnd)
204 lpfc_iocb_type type = LPFC_UNKNOWN_IOCB;
206 if (iocb_cmnd > CMD_MAX_IOCB_CMD)
210 case CMD_XMIT_SEQUENCE_CR:
211 case CMD_XMIT_SEQUENCE_CX:
212 case CMD_XMIT_BCAST_CN:
213 case CMD_XMIT_BCAST_CX:
214 case CMD_ELS_REQUEST_CR:
215 case CMD_ELS_REQUEST_CX:
216 case CMD_CREATE_XRI_CR:
217 case CMD_CREATE_XRI_CX:
219 case CMD_XMIT_ELS_RSP_CX:
221 case CMD_FCP_IWRITE_CR:
222 case CMD_FCP_IWRITE_CX:
223 case CMD_FCP_IREAD_CR:
224 case CMD_FCP_IREAD_CX:
225 case CMD_FCP_ICMND_CR:
226 case CMD_FCP_ICMND_CX:
227 case CMD_FCP_TSEND_CX:
228 case CMD_FCP_TRSP_CX:
229 case CMD_FCP_TRECEIVE_CX:
230 case CMD_FCP_AUTO_TRSP_CX:
231 case CMD_ADAPTER_MSG:
232 case CMD_ADAPTER_DUMP:
233 case CMD_XMIT_SEQUENCE64_CR:
234 case CMD_XMIT_SEQUENCE64_CX:
235 case CMD_XMIT_BCAST64_CN:
236 case CMD_XMIT_BCAST64_CX:
237 case CMD_ELS_REQUEST64_CR:
238 case CMD_ELS_REQUEST64_CX:
239 case CMD_FCP_IWRITE64_CR:
240 case CMD_FCP_IWRITE64_CX:
241 case CMD_FCP_IREAD64_CR:
242 case CMD_FCP_IREAD64_CX:
243 case CMD_FCP_ICMND64_CR:
244 case CMD_FCP_ICMND64_CX:
245 case CMD_FCP_TSEND64_CX:
246 case CMD_FCP_TRSP64_CX:
247 case CMD_FCP_TRECEIVE64_CX:
248 case CMD_GEN_REQUEST64_CR:
249 case CMD_GEN_REQUEST64_CX:
250 case CMD_XMIT_ELS_RSP64_CX:
251 type = LPFC_SOL_IOCB;
253 case CMD_ABORT_XRI_CN:
254 case CMD_ABORT_XRI_CX:
255 case CMD_CLOSE_XRI_CN:
256 case CMD_CLOSE_XRI_CX:
257 case CMD_XRI_ABORTED_CX:
258 case CMD_ABORT_MXRI64_CN:
259 type = LPFC_ABORT_IOCB;
261 case CMD_RCV_SEQUENCE_CX:
262 case CMD_RCV_ELS_REQ_CX:
263 case CMD_RCV_SEQUENCE64_CX:
264 case CMD_RCV_ELS_REQ64_CX:
265 case CMD_ASYNC_STATUS:
266 case CMD_IOCB_RCV_SEQ64_CX:
267 case CMD_IOCB_RCV_ELS64_CX:
268 case CMD_IOCB_RCV_CONT64_CX:
269 case CMD_IOCB_RET_XRI64_CX:
270 type = LPFC_UNSOL_IOCB;
272 case CMD_IOCB_XMIT_MSEQ64_CR:
273 case CMD_IOCB_XMIT_MSEQ64_CX:
274 case CMD_IOCB_RCV_SEQ_LIST64_CX:
275 case CMD_IOCB_RCV_ELS_LIST64_CX:
276 case CMD_IOCB_CLOSE_EXTENDED_CN:
277 case CMD_IOCB_ABORT_EXTENDED_CN:
278 case CMD_IOCB_RET_HBQE64_CN:
279 case CMD_IOCB_FCP_IBIDIR64_CR:
280 case CMD_IOCB_FCP_IBIDIR64_CX:
281 case CMD_IOCB_FCP_ITASKMGT64_CX:
282 case CMD_IOCB_LOGENTRY_CN:
283 case CMD_IOCB_LOGENTRY_ASYNC_CN:
284 printk("%s - Unhandled SLI-3 Command x%x\n",
285 __func__, iocb_cmnd);
286 type = LPFC_UNKNOWN_IOCB;
289 type = LPFC_UNKNOWN_IOCB;
297 * lpfc_sli_ring_map: Issue config_ring mbox for all rings.
298 * @phba: Pointer to HBA context object.
300 * This function is called from SLI initialization code
301 * to configure every ring of the HBA's SLI interface. The
302 * caller is not required to hold any lock. This function issues
303 * a config_ring mailbox command for each ring.
304 * This function returns zero if successful else returns a negative
308 lpfc_sli_ring_map(struct lpfc_hba *phba)
310 struct lpfc_sli *psli = &phba->sli;
315 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
319 phba->link_state = LPFC_INIT_MBX_CMDS;
320 for (i = 0; i < psli->num_rings; i++) {
321 lpfc_config_ring(phba, i, pmb);
322 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
323 if (rc != MBX_SUCCESS) {
324 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
325 "0446 Adapter failed to init (%d), "
326 "mbxCmd x%x CFG_RING, mbxStatus x%x, "
328 rc, pmbox->mbxCommand,
329 pmbox->mbxStatus, i);
330 phba->link_state = LPFC_HBA_ERROR;
335 mempool_free(pmb, phba->mbox_mem_pool);
340 * lpfc_sli_ringtxcmpl_put: Adds new iocb to the txcmplq.
341 * @phba: Pointer to HBA context object.
342 * @pring: Pointer to driver SLI ring object.
343 * @piocb: Pointer to the driver iocb object.
345 * This function is called with hbalock held. The function adds the
346 * new iocb to txcmplq of the given ring. This function always returns
347 * 0. If this function is called for ELS ring, this function checks if
348 * there is a vport associated with the ELS command. This function also
349 * starts els_tmofunc timer if this is an ELS command.
352 lpfc_sli_ringtxcmpl_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
353 struct lpfc_iocbq *piocb)
355 list_add_tail(&piocb->list, &pring->txcmplq);
356 pring->txcmplq_cnt++;
357 if ((unlikely(pring->ringno == LPFC_ELS_RING)) &&
358 (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
359 (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN)) {
363 mod_timer(&piocb->vport->els_tmofunc,
364 jiffies + HZ * (phba->fc_ratov << 1));
372 * lpfc_sli_ringtx_get: Get first element of the txq.
373 * @phba: Pointer to HBA context object.
374 * @pring: Pointer to driver SLI ring object.
376 * This function is called with hbalock held to get next
377 * iocb in txq of the given ring. If there is any iocb in
378 * the txq, the function returns first iocb in the list after
379 * removing the iocb from the list, else it returns NULL.
381 static struct lpfc_iocbq *
382 lpfc_sli_ringtx_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
384 struct lpfc_iocbq *cmd_iocb;
386 list_remove_head((&pring->txq), cmd_iocb, struct lpfc_iocbq, list);
387 if (cmd_iocb != NULL)
393 * lpfc_sli_next_iocb_slot: Get next iocb slot in the ring.
394 * @phba: Pointer to HBA context object.
395 * @pring: Pointer to driver SLI ring object.
397 * This function is called with hbalock held and the caller must post the
398 * iocb without releasing the lock. If the caller releases the lock,
399 * iocb slot returned by the function is not guaranteed to be available.
400 * The function returns pointer to the next available iocb slot if there
401 * is available slot in the ring, else it returns NULL.
402 * If the get index of the ring is ahead of the put index, the function
403 * will post an error attention event to the worker thread to take the
404 * HBA to offline state.
407 lpfc_sli_next_iocb_slot (struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
409 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
410 uint32_t max_cmd_idx = pring->numCiocb;
411 if ((pring->next_cmdidx == pring->cmdidx) &&
412 (++pring->next_cmdidx >= max_cmd_idx))
413 pring->next_cmdidx = 0;
415 if (unlikely(pring->local_getidx == pring->next_cmdidx)) {
417 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
419 if (unlikely(pring->local_getidx >= max_cmd_idx)) {
420 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
421 "0315 Ring %d issue: portCmdGet %d "
422 "is bigger then cmd ring %d\n",
424 pring->local_getidx, max_cmd_idx);
426 phba->link_state = LPFC_HBA_ERROR;
428 * All error attention handlers are posted to
431 phba->work_ha |= HA_ERATT;
432 phba->work_hs = HS_FFER3;
434 lpfc_worker_wake_up(phba);
439 if (pring->local_getidx == pring->next_cmdidx)
443 return lpfc_cmd_iocb(phba, pring);
447 * lpfc_sli_next_iotag: Get an iotag for the iocb.
448 * @phba: Pointer to HBA context object.
449 * @iocbq: Pointer to driver iocb object.
451 * This function gets an iotag for the iocb. If there is no unused iotag and
452 * the iocbq_lookup_len < 0xffff, this function allocates a bigger iotag_lookup
453 * array and assigns a new iotag.
454 * The function returns the allocated iotag if successful, else returns zero.
455 * Zero is not a valid iotag.
456 * The caller is not required to hold any lock.
459 lpfc_sli_next_iotag(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
461 struct lpfc_iocbq **new_arr;
462 struct lpfc_iocbq **old_arr;
464 struct lpfc_sli *psli = &phba->sli;
467 spin_lock_irq(&phba->hbalock);
468 iotag = psli->last_iotag;
469 if(++iotag < psli->iocbq_lookup_len) {
470 psli->last_iotag = iotag;
471 psli->iocbq_lookup[iotag] = iocbq;
472 spin_unlock_irq(&phba->hbalock);
473 iocbq->iotag = iotag;
475 } else if (psli->iocbq_lookup_len < (0xffff
476 - LPFC_IOCBQ_LOOKUP_INCREMENT)) {
477 new_len = psli->iocbq_lookup_len + LPFC_IOCBQ_LOOKUP_INCREMENT;
478 spin_unlock_irq(&phba->hbalock);
479 new_arr = kzalloc(new_len * sizeof (struct lpfc_iocbq *),
482 spin_lock_irq(&phba->hbalock);
483 old_arr = psli->iocbq_lookup;
484 if (new_len <= psli->iocbq_lookup_len) {
485 /* highly unprobable case */
487 iotag = psli->last_iotag;
488 if(++iotag < psli->iocbq_lookup_len) {
489 psli->last_iotag = iotag;
490 psli->iocbq_lookup[iotag] = iocbq;
491 spin_unlock_irq(&phba->hbalock);
492 iocbq->iotag = iotag;
495 spin_unlock_irq(&phba->hbalock);
498 if (psli->iocbq_lookup)
499 memcpy(new_arr, old_arr,
500 ((psli->last_iotag + 1) *
501 sizeof (struct lpfc_iocbq *)));
502 psli->iocbq_lookup = new_arr;
503 psli->iocbq_lookup_len = new_len;
504 psli->last_iotag = iotag;
505 psli->iocbq_lookup[iotag] = iocbq;
506 spin_unlock_irq(&phba->hbalock);
507 iocbq->iotag = iotag;
512 spin_unlock_irq(&phba->hbalock);
514 lpfc_printf_log(phba, KERN_ERR,LOG_SLI,
515 "0318 Failed to allocate IOTAG.last IOTAG is %d\n",
522 * lpfc_sli_submit_iocb: Submit an iocb to the firmware.
523 * @phba: Pointer to HBA context object.
524 * @pring: Pointer to driver SLI ring object.
525 * @iocb: Pointer to iocb slot in the ring.
526 * @nextiocb: Pointer to driver iocb object which need to be
527 * posted to firmware.
529 * This function is called with hbalock held to post a new iocb to
530 * the firmware. This function copies the new iocb to ring iocb slot and
531 * updates the ring pointers. It adds the new iocb to txcmplq if there is
532 * a completion call back for this iocb else the function will free the
536 lpfc_sli_submit_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
537 IOCB_t *iocb, struct lpfc_iocbq *nextiocb)
542 nextiocb->iocb.ulpIoTag = (nextiocb->iocb_cmpl) ? nextiocb->iotag : 0;
544 if (pring->ringno == LPFC_ELS_RING) {
545 lpfc_debugfs_slow_ring_trc(phba,
546 "IOCB cmd ring: wd4:x%08x wd6:x%08x wd7:x%08x",
547 *(((uint32_t *) &nextiocb->iocb) + 4),
548 *(((uint32_t *) &nextiocb->iocb) + 6),
549 *(((uint32_t *) &nextiocb->iocb) + 7));
553 * Issue iocb command to adapter
555 lpfc_sli_pcimem_bcopy(&nextiocb->iocb, iocb, phba->iocb_cmd_size);
557 pring->stats.iocb_cmd++;
560 * If there is no completion routine to call, we can release the
561 * IOCB buffer back right now. For IOCBs, like QUE_RING_BUF,
562 * that have no rsp ring completion, iocb_cmpl MUST be NULL.
564 if (nextiocb->iocb_cmpl)
565 lpfc_sli_ringtxcmpl_put(phba, pring, nextiocb);
567 __lpfc_sli_release_iocbq(phba, nextiocb);
570 * Let the HBA know what IOCB slot will be the next one the
571 * driver will put a command into.
573 pring->cmdidx = pring->next_cmdidx;
574 writel(pring->cmdidx, &phba->host_gp[pring->ringno].cmdPutInx);
578 * lpfc_sli_update_full_ring: Update the chip attention register.
579 * @phba: Pointer to HBA context object.
580 * @pring: Pointer to driver SLI ring object.
582 * The caller is not required to hold any lock for calling this function.
583 * This function updates the chip attention bits for the ring to inform firmware
584 * that there are pending work to be done for this ring and requests an
585 * interrupt when there is space available in the ring. This function is
586 * called when the driver is unable to post more iocbs to the ring due
587 * to unavailability of space in the ring.
590 lpfc_sli_update_full_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
592 int ringno = pring->ringno;
594 pring->flag |= LPFC_CALL_RING_AVAILABLE;
599 * Set ring 'ringno' to SET R0CE_REQ in Chip Att register.
600 * The HBA will tell us when an IOCB entry is available.
602 writel((CA_R0ATT|CA_R0CE_REQ) << (ringno*4), phba->CAregaddr);
603 readl(phba->CAregaddr); /* flush */
605 pring->stats.iocb_cmd_full++;
609 * lpfc_sli_update_ring: Update chip attention register.
610 * @phba: Pointer to HBA context object.
611 * @pring: Pointer to driver SLI ring object.
613 * This function updates the chip attention register bit for the
614 * given ring to inform HBA that there is more work to be done
615 * in this ring. The caller is not required to hold any lock.
618 lpfc_sli_update_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
620 int ringno = pring->ringno;
623 * Tell the HBA that there is work to do in this ring.
625 if (!(phba->sli3_options & LPFC_SLI3_CRP_ENABLED)) {
627 writel(CA_R0ATT << (ringno * 4), phba->CAregaddr);
628 readl(phba->CAregaddr); /* flush */
633 * lpfc_sli_resume_iocb: Process iocbs in the txq.
634 * @phba: Pointer to HBA context object.
635 * @pring: Pointer to driver SLI ring object.
637 * This function is called with hbalock held to post pending iocbs
638 * in the txq to the firmware. This function is called when driver
639 * detects space available in the ring.
642 lpfc_sli_resume_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
645 struct lpfc_iocbq *nextiocb;
649 * (a) there is anything on the txq to send
651 * (c) link attention events can be processed (fcp ring only)
652 * (d) IOCB processing is not blocked by the outstanding mbox command.
654 if (pring->txq_cnt &&
655 lpfc_is_link_up(phba) &&
656 (pring->ringno != phba->sli.fcp_ring ||
657 phba->sli.sli_flag & LPFC_PROCESS_LA)) {
659 while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
660 (nextiocb = lpfc_sli_ringtx_get(phba, pring)))
661 lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
664 lpfc_sli_update_ring(phba, pring);
666 lpfc_sli_update_full_ring(phba, pring);
673 * lpfc_sli_next_hbq_slot: Get next hbq entry for the HBQ.
674 * @phba: Pointer to HBA context object.
675 * @hbqno: HBQ number.
677 * This function is called with hbalock held to get the next
678 * available slot for the given HBQ. If there is free slot
679 * available for the HBQ it will return pointer to the next available
680 * HBQ entry else it will return NULL.
682 static struct lpfc_hbq_entry *
683 lpfc_sli_next_hbq_slot(struct lpfc_hba *phba, uint32_t hbqno)
685 struct hbq_s *hbqp = &phba->hbqs[hbqno];
687 if (hbqp->next_hbqPutIdx == hbqp->hbqPutIdx &&
688 ++hbqp->next_hbqPutIdx >= hbqp->entry_count)
689 hbqp->next_hbqPutIdx = 0;
691 if (unlikely(hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)) {
692 uint32_t raw_index = phba->hbq_get[hbqno];
693 uint32_t getidx = le32_to_cpu(raw_index);
695 hbqp->local_hbqGetIdx = getidx;
697 if (unlikely(hbqp->local_hbqGetIdx >= hbqp->entry_count)) {
698 lpfc_printf_log(phba, KERN_ERR,
700 "1802 HBQ %d: local_hbqGetIdx "
701 "%u is > than hbqp->entry_count %u\n",
702 hbqno, hbqp->local_hbqGetIdx,
705 phba->link_state = LPFC_HBA_ERROR;
709 if (hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)
713 return (struct lpfc_hbq_entry *) phba->hbqs[hbqno].hbq_virt +
718 * lpfc_sli_hbqbuf_free_all: Free all the hbq buffers.
719 * @phba: Pointer to HBA context object.
721 * This function is called with no lock held to free all the
722 * hbq buffers while uninitializing the SLI interface. It also
723 * frees the HBQ buffers returned by the firmware but not yet
724 * processed by the upper layers.
727 lpfc_sli_hbqbuf_free_all(struct lpfc_hba *phba)
729 struct lpfc_dmabuf *dmabuf, *next_dmabuf;
730 struct hbq_dmabuf *hbq_buf;
735 hbq_count = lpfc_sli_hbq_count();
736 /* Return all memory used by all HBQs */
737 spin_lock_irqsave(&phba->hbalock, flags);
738 for (i = 0; i < hbq_count; ++i) {
739 list_for_each_entry_safe(dmabuf, next_dmabuf,
740 &phba->hbqs[i].hbq_buffer_list, list) {
741 hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
742 list_del(&hbq_buf->dbuf.list);
743 (phba->hbqs[i].hbq_free_buffer)(phba, hbq_buf);
745 phba->hbqs[i].buffer_count = 0;
747 /* Return all HBQ buffer that are in-fly */
748 list_for_each_entry_safe(dmabuf, next_dmabuf,
749 &phba->hbqbuf_in_list, list) {
750 hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
751 list_del(&hbq_buf->dbuf.list);
752 if (hbq_buf->tag == -1) {
753 (phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
756 hbqno = hbq_buf->tag >> 16;
757 if (hbqno >= LPFC_MAX_HBQS)
758 (phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
761 (phba->hbqs[hbqno].hbq_free_buffer)(phba,
766 /* Mark the HBQs not in use */
767 phba->hbq_in_use = 0;
768 spin_unlock_irqrestore(&phba->hbalock, flags);
772 * lpfc_sli_hbq_to_firmware: Post the hbq buffer to firmware.
773 * @phba: Pointer to HBA context object.
774 * @hbqno: HBQ number.
775 * @hbq_buf: Pointer to HBQ buffer.
777 * This function is called with the hbalock held to post a
778 * hbq buffer to the firmware. If the function finds an empty
779 * slot in the HBQ, it will post the buffer. The function will return
780 * pointer to the hbq entry if it successfully post the buffer
781 * else it will return NULL.
783 static struct lpfc_hbq_entry *
784 lpfc_sli_hbq_to_firmware(struct lpfc_hba *phba, uint32_t hbqno,
785 struct hbq_dmabuf *hbq_buf)
787 struct lpfc_hbq_entry *hbqe;
788 dma_addr_t physaddr = hbq_buf->dbuf.phys;
790 /* Get next HBQ entry slot to use */
791 hbqe = lpfc_sli_next_hbq_slot(phba, hbqno);
793 struct hbq_s *hbqp = &phba->hbqs[hbqno];
795 hbqe->bde.addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
796 hbqe->bde.addrLow = le32_to_cpu(putPaddrLow(physaddr));
797 hbqe->bde.tus.f.bdeSize = hbq_buf->size;
798 hbqe->bde.tus.f.bdeFlags = 0;
799 hbqe->bde.tus.w = le32_to_cpu(hbqe->bde.tus.w);
800 hbqe->buffer_tag = le32_to_cpu(hbq_buf->tag);
802 hbqp->hbqPutIdx = hbqp->next_hbqPutIdx;
803 writel(hbqp->hbqPutIdx, phba->hbq_put + hbqno);
805 readl(phba->hbq_put + hbqno);
806 list_add_tail(&hbq_buf->dbuf.list, &hbqp->hbq_buffer_list);
811 /* HBQ for ELS and CT traffic. */
812 static struct lpfc_hbq_init lpfc_els_hbq = {
817 .ring_mask = (1 << LPFC_ELS_RING),
823 /* HBQ for the extra ring if needed */
824 static struct lpfc_hbq_init lpfc_extra_hbq = {
829 .ring_mask = (1 << LPFC_EXTRA_RING),
836 struct lpfc_hbq_init *lpfc_hbq_defs[] = {
842 * lpfc_sli_hbqbuf_fill_hbqs: Post more hbq buffers to HBQ.
843 * @phba: Pointer to HBA context object.
844 * @hbqno: HBQ number.
845 * @count: Number of HBQ buffers to be posted.
847 * This function is called with no lock held to post more hbq buffers to the
848 * given HBQ. The function returns the number of HBQ buffers successfully
852 lpfc_sli_hbqbuf_fill_hbqs(struct lpfc_hba *phba, uint32_t hbqno, uint32_t count)
854 uint32_t i, posted = 0;
856 struct hbq_dmabuf *hbq_buffer;
857 LIST_HEAD(hbq_buf_list);
858 if (!phba->hbqs[hbqno].hbq_alloc_buffer)
861 if ((phba->hbqs[hbqno].buffer_count + count) >
862 lpfc_hbq_defs[hbqno]->entry_count)
863 count = lpfc_hbq_defs[hbqno]->entry_count -
864 phba->hbqs[hbqno].buffer_count;
867 /* Allocate HBQ entries */
868 for (i = 0; i < count; i++) {
869 hbq_buffer = (phba->hbqs[hbqno].hbq_alloc_buffer)(phba);
872 list_add_tail(&hbq_buffer->dbuf.list, &hbq_buf_list);
874 /* Check whether HBQ is still in use */
875 spin_lock_irqsave(&phba->hbalock, flags);
876 if (!phba->hbq_in_use)
878 while (!list_empty(&hbq_buf_list)) {
879 list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
881 hbq_buffer->tag = (phba->hbqs[hbqno].buffer_count |
883 if (lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {
884 phba->hbqs[hbqno].buffer_count++;
887 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
889 spin_unlock_irqrestore(&phba->hbalock, flags);
892 spin_unlock_irqrestore(&phba->hbalock, flags);
893 while (!list_empty(&hbq_buf_list)) {
894 list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
896 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
902 * lpfc_sli_hbqbuf_add_hbqs: Post more HBQ buffers to firmware.
903 * @phba: Pointer to HBA context object.
906 * This function posts more buffers to the HBQ. This function
907 * is called with no lock held. The function returns the number of HBQ entries
908 * successfully allocated.
911 lpfc_sli_hbqbuf_add_hbqs(struct lpfc_hba *phba, uint32_t qno)
913 return(lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
914 lpfc_hbq_defs[qno]->add_count));
918 * lpfc_sli_hbqbuf_init_hbqs: Post initial buffers to the HBQ.
919 * @phba: Pointer to HBA context object.
920 * @qno: HBQ queue number.
922 * This function is called from SLI initialization code path with
923 * no lock held to post initial HBQ buffers to firmware. The
924 * function returns the number of HBQ entries successfully allocated.
927 lpfc_sli_hbqbuf_init_hbqs(struct lpfc_hba *phba, uint32_t qno)
929 return(lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
930 lpfc_hbq_defs[qno]->init_count));
934 * lpfc_sli_hbqbuf_find: Find the hbq buffer associated with a tag.
935 * @phba: Pointer to HBA context object.
936 * @tag: Tag of the hbq buffer.
938 * This function is called with hbalock held. This function searches
939 * for the hbq buffer associated with the given tag in the hbq buffer
940 * list. If it finds the hbq buffer, it returns the hbq_buffer other wise
943 static struct hbq_dmabuf *
944 lpfc_sli_hbqbuf_find(struct lpfc_hba *phba, uint32_t tag)
946 struct lpfc_dmabuf *d_buf;
947 struct hbq_dmabuf *hbq_buf;
951 if (hbqno >= LPFC_MAX_HBQS)
954 list_for_each_entry(d_buf, &phba->hbqs[hbqno].hbq_buffer_list, list) {
955 hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
956 if (hbq_buf->tag == tag) {
960 lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_VPORT,
961 "1803 Bad hbq tag. Data: x%x x%x\n",
962 tag, phba->hbqs[tag >> 16].buffer_count);
967 * lpfc_sli_free_hbq: Give back the hbq buffer to firmware.
968 * @phba: Pointer to HBA context object.
969 * @hbq_buffer: Pointer to HBQ buffer.
971 * This function is called with hbalock. This function gives back
972 * the hbq buffer to firmware. If the HBQ does not have space to
973 * post the buffer, it will free the buffer.
976 lpfc_sli_free_hbq(struct lpfc_hba *phba, struct hbq_dmabuf *hbq_buffer)
981 hbqno = hbq_buffer->tag >> 16;
982 if (!lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {
983 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
989 * lpfc_sli_chk_mbx_command: Check if the mailbox is a legitimate mailbox.
990 * @mbxCommand: mailbox command code.
992 * This function is called by the mailbox event handler function to verify
993 * that the completed mailbox command is a legitimate mailbox command. If the
994 * completed mailbox is not known to the function, it will return MBX_SHUTDOWN
995 * and the mailbox event handler will take the HBA offline.
998 lpfc_sli_chk_mbx_command(uint8_t mbxCommand)
1002 switch (mbxCommand) {
1006 case MBX_WRITE_VPARMS:
1007 case MBX_RUN_BIU_DIAG:
1010 case MBX_CONFIG_LINK:
1011 case MBX_CONFIG_RING:
1012 case MBX_RESET_RING:
1013 case MBX_READ_CONFIG:
1014 case MBX_READ_RCONFIG:
1015 case MBX_READ_SPARM:
1016 case MBX_READ_STATUS:
1020 case MBX_READ_LNK_STAT:
1022 case MBX_UNREG_LOGIN:
1025 case MBX_DUMP_MEMORY:
1026 case MBX_DUMP_CONTEXT:
1029 case MBX_UPDATE_CFG:
1031 case MBX_DEL_LD_ENTRY:
1032 case MBX_RUN_PROGRAM:
1034 case MBX_SET_VARIABLE:
1035 case MBX_UNREG_D_ID:
1036 case MBX_KILL_BOARD:
1037 case MBX_CONFIG_FARP:
1040 case MBX_RUN_BIU_DIAG64:
1041 case MBX_CONFIG_PORT:
1042 case MBX_READ_SPARM64:
1043 case MBX_READ_RPI64:
1044 case MBX_REG_LOGIN64:
1048 case MBX_LOAD_EXP_ROM:
1049 case MBX_ASYNCEVT_ENABLE:
1053 case MBX_PORT_CAPABILITIES:
1054 case MBX_PORT_IOV_CONTROL:
1065 * lpfc_sli_wake_mbox_wait: Completion handler for mbox issued from
1066 * lpfc_sli_issue_mbox_wait.
1067 * @phba: Pointer to HBA context object.
1068 * @pmboxq: Pointer to mailbox command.
1070 * This is completion handler function for mailbox commands issued from
1071 * lpfc_sli_issue_mbox_wait function. This function is called by the
1072 * mailbox event handler function with no lock held. This function
1073 * will wake up thread waiting on the wait queue pointed by context1
1077 lpfc_sli_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
1079 wait_queue_head_t *pdone_q;
1080 unsigned long drvr_flag;
1083 * If pdone_q is empty, the driver thread gave up waiting and
1084 * continued running.
1086 pmboxq->mbox_flag |= LPFC_MBX_WAKE;
1087 spin_lock_irqsave(&phba->hbalock, drvr_flag);
1088 pdone_q = (wait_queue_head_t *) pmboxq->context1;
1090 wake_up_interruptible(pdone_q);
1091 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
1097 * lpfc_sli_def_mbox_cmpl: Default mailbox completion handler.
1098 * @phba: Pointer to HBA context object.
1099 * @pmb: Pointer to mailbox object.
1101 * This function is the default mailbox completion handler. It
1102 * frees the memory resources associated with the completed mailbox
1103 * command. If the completed command is a REG_LOGIN mailbox command,
1104 * this function will issue a UREG_LOGIN to re-claim the RPI.
1107 lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1109 struct lpfc_dmabuf *mp;
1113 mp = (struct lpfc_dmabuf *) (pmb->context1);
1116 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1121 * If a REG_LOGIN succeeded after node is destroyed or node
1122 * is in re-discovery driver need to cleanup the RPI.
1124 if (!(phba->pport->load_flag & FC_UNLOADING) &&
1125 pmb->mb.mbxCommand == MBX_REG_LOGIN64 &&
1126 !pmb->mb.mbxStatus) {
1128 rpi = pmb->mb.un.varWords[0];
1129 lpfc_unreg_login(phba, pmb->mb.un.varRegLogin.vpi, rpi, pmb);
1130 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
1131 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
1132 if (rc != MBX_NOT_FINISHED)
1136 mempool_free(pmb, phba->mbox_mem_pool);
1141 * lpfc_sli_handle_mb_event: Handle mailbox completions from firmware.
1142 * @phba: Pointer to HBA context object.
1144 * This function is called with no lock held. This function processes all
1145 * the completed mailbox commands and gives it to upper layers. The interrupt
1146 * service routine processes mailbox completion interrupt and adds completed
1147 * mailbox commands to the mboxq_cmpl queue and signals the worker thread.
1148 * Worker thread call lpfc_sli_handle_mb_event, which will return the
1149 * completed mailbox commands in mboxq_cmpl queue to the upper layers. This
1150 * function returns the mailbox commands to the upper layer by calling the
1151 * completion handler function of each mailbox.
1154 lpfc_sli_handle_mb_event(struct lpfc_hba *phba)
1161 phba->sli.slistat.mbox_event++;
1163 /* Get all completed mailboxe buffers into the cmplq */
1164 spin_lock_irq(&phba->hbalock);
1165 list_splice_init(&phba->sli.mboxq_cmpl, &cmplq);
1166 spin_unlock_irq(&phba->hbalock);
1168 /* Get a Mailbox buffer to setup mailbox commands for callback */
1170 list_remove_head(&cmplq, pmb, LPFC_MBOXQ_t, list);
1176 if (pmbox->mbxCommand != MBX_HEARTBEAT) {
1178 lpfc_debugfs_disc_trc(pmb->vport,
1179 LPFC_DISC_TRC_MBOX_VPORT,
1180 "MBOX cmpl vport: cmd:x%x mb:x%x x%x",
1181 (uint32_t)pmbox->mbxCommand,
1182 pmbox->un.varWords[0],
1183 pmbox->un.varWords[1]);
1186 lpfc_debugfs_disc_trc(phba->pport,
1188 "MBOX cmpl: cmd:x%x mb:x%x x%x",
1189 (uint32_t)pmbox->mbxCommand,
1190 pmbox->un.varWords[0],
1191 pmbox->un.varWords[1]);
1196 * It is a fatal error if unknown mbox command completion.
1198 if (lpfc_sli_chk_mbx_command(pmbox->mbxCommand) ==
1200 /* Unknow mailbox command compl */
1201 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
1202 "(%d):0323 Unknown Mailbox command "
1204 pmb->vport ? pmb->vport->vpi : 0,
1206 phba->link_state = LPFC_HBA_ERROR;
1207 phba->work_hs = HS_FFER3;
1208 lpfc_handle_eratt(phba);
1212 if (pmbox->mbxStatus) {
1213 phba->sli.slistat.mbox_stat_err++;
1214 if (pmbox->mbxStatus == MBXERR_NO_RESOURCES) {
1215 /* Mbox cmd cmpl error - RETRYing */
1216 lpfc_printf_log(phba, KERN_INFO,
1218 "(%d):0305 Mbox cmd cmpl "
1219 "error - RETRYing Data: x%x "
1221 pmb->vport ? pmb->vport->vpi :0,
1224 pmbox->un.varWords[0],
1225 pmb->vport->port_state);
1226 pmbox->mbxStatus = 0;
1227 pmbox->mbxOwner = OWN_HOST;
1228 spin_lock_irq(&phba->hbalock);
1229 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
1230 spin_unlock_irq(&phba->hbalock);
1231 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
1232 if (rc == MBX_SUCCESS)
1237 /* Mailbox cmd <cmd> Cmpl <cmpl> */
1238 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
1239 "(%d):0307 Mailbox cmd x%x Cmpl x%p "
1240 "Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x\n",
1241 pmb->vport ? pmb->vport->vpi : 0,
1244 *((uint32_t *) pmbox),
1245 pmbox->un.varWords[0],
1246 pmbox->un.varWords[1],
1247 pmbox->un.varWords[2],
1248 pmbox->un.varWords[3],
1249 pmbox->un.varWords[4],
1250 pmbox->un.varWords[5],
1251 pmbox->un.varWords[6],
1252 pmbox->un.varWords[7]);
1255 pmb->mbox_cmpl(phba,pmb);
1261 * lpfc_sli_replace_hbqbuff: Replace the HBQ buffer with a new buffer.
1262 * @phba: Pointer to HBA context object.
1263 * @tag: Tag for the HBQ buffer.
1265 * This function is called from unsolicited event handler code path to get the
1266 * HBQ buffer associated with an unsolicited iocb. This function is called with
1267 * no lock held. It returns the buffer associated with the given tag and posts
1268 * another buffer to the firmware. Note that the new buffer must be allocated
1269 * before taking the hbalock and that the hba lock must be held until it is
1270 * finished with the hbq entry swap.
1272 static struct lpfc_dmabuf *
1273 lpfc_sli_replace_hbqbuff(struct lpfc_hba *phba, uint32_t tag)
1275 struct hbq_dmabuf *hbq_entry, *new_hbq_entry;
1277 void *virt; /* virtual address ptr */
1278 dma_addr_t phys; /* mapped address */
1279 unsigned long flags;
1282 new_hbq_entry = (phba->hbqs[hbqno].hbq_alloc_buffer)(phba);
1283 /* Check whether HBQ is still in use */
1284 spin_lock_irqsave(&phba->hbalock, flags);
1285 if (!phba->hbq_in_use) {
1287 (phba->hbqs[hbqno].hbq_free_buffer)(phba,
1289 spin_unlock_irqrestore(&phba->hbalock, flags);
1293 hbq_entry = lpfc_sli_hbqbuf_find(phba, tag);
1294 if (hbq_entry == NULL) {
1296 (phba->hbqs[hbqno].hbq_free_buffer)(phba,
1298 spin_unlock_irqrestore(&phba->hbalock, flags);
1301 list_del(&hbq_entry->dbuf.list);
1303 if (new_hbq_entry == NULL) {
1304 list_add_tail(&hbq_entry->dbuf.list, &phba->hbqbuf_in_list);
1305 spin_unlock_irqrestore(&phba->hbalock, flags);
1306 return &hbq_entry->dbuf;
1308 new_hbq_entry->tag = -1;
1309 phys = new_hbq_entry->dbuf.phys;
1310 virt = new_hbq_entry->dbuf.virt;
1311 new_hbq_entry->dbuf.phys = hbq_entry->dbuf.phys;
1312 new_hbq_entry->dbuf.virt = hbq_entry->dbuf.virt;
1313 hbq_entry->dbuf.phys = phys;
1314 hbq_entry->dbuf.virt = virt;
1315 lpfc_sli_free_hbq(phba, hbq_entry);
1316 list_add_tail(&new_hbq_entry->dbuf.list, &phba->hbqbuf_in_list);
1317 spin_unlock_irqrestore(&phba->hbalock, flags);
1319 return &new_hbq_entry->dbuf;
1323 * lpfc_sli_get_buff: Get the buffer associated with the buffer tag.
1324 * @phba: Pointer to HBA context object.
1325 * @pring: Pointer to driver SLI ring object.
1328 * This function is called with no lock held. When QUE_BUFTAG_BIT bit
1329 * is set in the tag the buffer is posted for a particular exchange,
1330 * the function will return the buffer without replacing the buffer.
1331 * If the buffer is for unsolicited ELS or CT traffic, this function
1332 * returns the buffer and also posts another buffer to the firmware.
1334 static struct lpfc_dmabuf *
1335 lpfc_sli_get_buff(struct lpfc_hba *phba,
1336 struct lpfc_sli_ring *pring,
1339 if (tag & QUE_BUFTAG_BIT)
1340 return lpfc_sli_ring_taggedbuf_get(phba, pring, tag);
1342 return lpfc_sli_replace_hbqbuff(phba, tag);
1347 * lpfc_sli_process_unsol_iocb: Unsolicited iocb handler.
1348 * @phba: Pointer to HBA context object.
1349 * @pring: Pointer to driver SLI ring object.
1350 * @saveq: Pointer to the unsolicited iocb.
1352 * This function is called with no lock held by the ring event handler
1353 * when there is an unsolicited iocb posted to the response ring by the
1354 * firmware. This function gets the buffer associated with the iocbs
1355 * and calls the event handler for the ring. This function handles both
1356 * qring buffers and hbq buffers.
1357 * When the function returns 1 the caller can free the iocb object otherwise
1358 * upper layer functions will free the iocb objects.
1361 lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1362 struct lpfc_iocbq *saveq)
1366 uint32_t Rctl, Type;
1368 struct lpfc_iocbq *iocbq;
1369 struct lpfc_dmabuf *dmzbuf;
1372 irsp = &(saveq->iocb);
1374 if (irsp->ulpStatus == IOSTAT_NEED_BUFFER)
1376 if (irsp->ulpCommand == CMD_ASYNC_STATUS) {
1377 if (pring->lpfc_sli_rcv_async_status)
1378 pring->lpfc_sli_rcv_async_status(phba, pring, saveq);
1380 lpfc_printf_log(phba,
1383 "0316 Ring %d handler: unexpected "
1384 "ASYNC_STATUS iocb received evt_code "
1387 irsp->un.asyncstat.evt_code);
1391 if ((irsp->ulpCommand == CMD_IOCB_RET_XRI64_CX) &&
1392 (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)) {
1393 if (irsp->ulpBdeCount > 0) {
1394 dmzbuf = lpfc_sli_get_buff(phba, pring,
1395 irsp->un.ulpWord[3]);
1396 lpfc_in_buf_free(phba, dmzbuf);
1399 if (irsp->ulpBdeCount > 1) {
1400 dmzbuf = lpfc_sli_get_buff(phba, pring,
1401 irsp->unsli3.sli3Words[3]);
1402 lpfc_in_buf_free(phba, dmzbuf);
1405 if (irsp->ulpBdeCount > 2) {
1406 dmzbuf = lpfc_sli_get_buff(phba, pring,
1407 irsp->unsli3.sli3Words[7]);
1408 lpfc_in_buf_free(phba, dmzbuf);
1414 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
1415 if (irsp->ulpBdeCount != 0) {
1416 saveq->context2 = lpfc_sli_get_buff(phba, pring,
1417 irsp->un.ulpWord[3]);
1418 if (!saveq->context2)
1419 lpfc_printf_log(phba,
1422 "0341 Ring %d Cannot find buffer for "
1423 "an unsolicited iocb. tag 0x%x\n",
1425 irsp->un.ulpWord[3]);
1427 if (irsp->ulpBdeCount == 2) {
1428 saveq->context3 = lpfc_sli_get_buff(phba, pring,
1429 irsp->unsli3.sli3Words[7]);
1430 if (!saveq->context3)
1431 lpfc_printf_log(phba,
1434 "0342 Ring %d Cannot find buffer for an"
1435 " unsolicited iocb. tag 0x%x\n",
1437 irsp->unsli3.sli3Words[7]);
1439 list_for_each_entry(iocbq, &saveq->list, list) {
1440 irsp = &(iocbq->iocb);
1441 if (irsp->ulpBdeCount != 0) {
1442 iocbq->context2 = lpfc_sli_get_buff(phba, pring,
1443 irsp->un.ulpWord[3]);
1444 if (!iocbq->context2)
1445 lpfc_printf_log(phba,
1448 "0343 Ring %d Cannot find "
1449 "buffer for an unsolicited iocb"
1450 ". tag 0x%x\n", pring->ringno,
1451 irsp->un.ulpWord[3]);
1453 if (irsp->ulpBdeCount == 2) {
1454 iocbq->context3 = lpfc_sli_get_buff(phba, pring,
1455 irsp->unsli3.sli3Words[7]);
1456 if (!iocbq->context3)
1457 lpfc_printf_log(phba,
1460 "0344 Ring %d Cannot find "
1461 "buffer for an unsolicited "
1464 irsp->unsli3.sli3Words[7]);
1468 if (irsp->ulpBdeCount != 0 &&
1469 (irsp->ulpCommand == CMD_IOCB_RCV_CONT64_CX ||
1470 irsp->ulpStatus == IOSTAT_INTERMED_RSP)) {
1473 /* search continue save q for same XRI */
1474 list_for_each_entry(iocbq, &pring->iocb_continue_saveq, clist) {
1475 if (iocbq->iocb.ulpContext == saveq->iocb.ulpContext) {
1476 list_add_tail(&saveq->list, &iocbq->list);
1482 list_add_tail(&saveq->clist,
1483 &pring->iocb_continue_saveq);
1484 if (saveq->iocb.ulpStatus != IOSTAT_INTERMED_RSP) {
1485 list_del_init(&iocbq->clist);
1487 irsp = &(saveq->iocb);
1491 if ((irsp->ulpCommand == CMD_RCV_ELS_REQ64_CX) ||
1492 (irsp->ulpCommand == CMD_RCV_ELS_REQ_CX) ||
1493 (irsp->ulpCommand == CMD_IOCB_RCV_ELS64_CX)) {
1497 w5p = (WORD5 *)&(saveq->iocb.un.ulpWord[5]);
1498 Rctl = w5p->hcsw.Rctl;
1499 Type = w5p->hcsw.Type;
1501 /* Firmware Workaround */
1502 if ((Rctl == 0) && (pring->ringno == LPFC_ELS_RING) &&
1503 (irsp->ulpCommand == CMD_RCV_SEQUENCE64_CX ||
1504 irsp->ulpCommand == CMD_IOCB_RCV_SEQ64_CX)) {
1507 w5p->hcsw.Rctl = Rctl;
1508 w5p->hcsw.Type = Type;
1512 /* unSolicited Responses */
1513 if (pring->prt[0].profile) {
1514 if (pring->prt[0].lpfc_sli_rcv_unsol_event)
1515 (pring->prt[0].lpfc_sli_rcv_unsol_event) (phba, pring,
1519 /* We must search, based on rctl / type
1520 for the right routine */
1521 for (i = 0; i < pring->num_mask; i++) {
1522 if ((pring->prt[i].rctl == Rctl)
1523 && (pring->prt[i].type == Type)) {
1524 if (pring->prt[i].lpfc_sli_rcv_unsol_event)
1525 (pring->prt[i].lpfc_sli_rcv_unsol_event)
1526 (phba, pring, saveq);
1533 /* Unexpected Rctl / Type received */
1534 /* Ring <ringno> handler: unexpected
1535 Rctl <Rctl> Type <Type> received */
1536 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1537 "0313 Ring %d handler: unexpected Rctl x%x "
1538 "Type x%x received\n",
1539 pring->ringno, Rctl, Type);
1545 * lpfc_sli_iocbq_lookup: Find command iocb for the given response iocb.
1546 * @phba: Pointer to HBA context object.
1547 * @pring: Pointer to driver SLI ring object.
1548 * @prspiocb: Pointer to response iocb object.
1550 * This function looks up the iocb_lookup table to get the command iocb
1551 * corresponding to the given response iocb using the iotag of the
1552 * response iocb. This function is called with the hbalock held.
1553 * This function returns the command iocb object if it finds the command
1554 * iocb else returns NULL.
1556 static struct lpfc_iocbq *
1557 lpfc_sli_iocbq_lookup(struct lpfc_hba *phba,
1558 struct lpfc_sli_ring *pring,
1559 struct lpfc_iocbq *prspiocb)
1561 struct lpfc_iocbq *cmd_iocb = NULL;
1564 iotag = prspiocb->iocb.ulpIoTag;
1566 if (iotag != 0 && iotag <= phba->sli.last_iotag) {
1567 cmd_iocb = phba->sli.iocbq_lookup[iotag];
1568 list_del_init(&cmd_iocb->list);
1569 pring->txcmplq_cnt--;
1573 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1574 "0317 iotag x%x is out off "
1575 "range: max iotag x%x wd0 x%x\n",
1576 iotag, phba->sli.last_iotag,
1577 *(((uint32_t *) &prspiocb->iocb) + 7));
1582 * lpfc_sli_process_sol_iocb: process solicited iocb completion.
1583 * @phba: Pointer to HBA context object.
1584 * @pring: Pointer to driver SLI ring object.
1585 * @saveq: Pointer to the response iocb to be processed.
1587 * This function is called by the ring event handler for non-fcp
1588 * rings when there is a new response iocb in the response ring.
1589 * The caller is not required to hold any locks. This function
1590 * gets the command iocb associated with the response iocb and
1591 * calls the completion handler for the command iocb. If there
1592 * is no completion handler, the function will free the resources
1593 * associated with command iocb. If the response iocb is for
1594 * an already aborted command iocb, the status of the completion
1595 * is changed to IOSTAT_LOCAL_REJECT/IOERR_SLI_ABORTED.
1596 * This function always returns 1.
1599 lpfc_sli_process_sol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1600 struct lpfc_iocbq *saveq)
1602 struct lpfc_iocbq *cmdiocbp;
1604 unsigned long iflag;
1606 /* Based on the iotag field, get the cmd IOCB from the txcmplq */
1607 spin_lock_irqsave(&phba->hbalock, iflag);
1608 cmdiocbp = lpfc_sli_iocbq_lookup(phba, pring, saveq);
1609 spin_unlock_irqrestore(&phba->hbalock, iflag);
1612 if (cmdiocbp->iocb_cmpl) {
1614 * Post all ELS completions to the worker thread.
1615 * All other are passed to the completion callback.
1617 if (pring->ringno == LPFC_ELS_RING) {
1618 if (cmdiocbp->iocb_flag & LPFC_DRIVER_ABORTED) {
1619 cmdiocbp->iocb_flag &=
1620 ~LPFC_DRIVER_ABORTED;
1621 saveq->iocb.ulpStatus =
1622 IOSTAT_LOCAL_REJECT;
1623 saveq->iocb.un.ulpWord[4] =
1626 /* Firmware could still be in progress
1627 * of DMAing payload, so don't free data
1628 * buffer till after a hbeat.
1630 saveq->iocb_flag |= LPFC_DELAY_MEM_FREE;
1633 (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
1635 lpfc_sli_release_iocbq(phba, cmdiocbp);
1638 * Unknown initiating command based on the response iotag.
1639 * This could be the case on the ELS ring because of
1642 if (pring->ringno != LPFC_ELS_RING) {
1644 * Ring <ringno> handler: unexpected completion IoTag
1647 lpfc_printf_vlog(cmdiocbp->vport, KERN_WARNING, LOG_SLI,
1648 "0322 Ring %d handler: "
1649 "unexpected completion IoTag x%x "
1650 "Data: x%x x%x x%x x%x\n",
1652 saveq->iocb.ulpIoTag,
1653 saveq->iocb.ulpStatus,
1654 saveq->iocb.un.ulpWord[4],
1655 saveq->iocb.ulpCommand,
1656 saveq->iocb.ulpContext);
1664 * lpfc_sli_rsp_pointers_error: Response ring pointer error handler.
1665 * @phba: Pointer to HBA context object.
1666 * @pring: Pointer to driver SLI ring object.
1668 * This function is called from the iocb ring event handlers when
1669 * put pointer is ahead of the get pointer for a ring. This function signal
1670 * an error attention condition to the worker thread and the worker
1671 * thread will transition the HBA to offline state.
1674 lpfc_sli_rsp_pointers_error(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1676 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1678 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1679 * rsp ring <portRspMax>
1681 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1682 "0312 Ring %d handler: portRspPut %d "
1683 "is bigger then rsp ring %d\n",
1684 pring->ringno, le32_to_cpu(pgp->rspPutInx),
1687 phba->link_state = LPFC_HBA_ERROR;
1690 * All error attention handlers are posted to
1693 phba->work_ha |= HA_ERATT;
1694 phba->work_hs = HS_FFER3;
1696 lpfc_worker_wake_up(phba);
1702 * lpfc_sli_poll_fcp_ring: Handle FCP ring completion in polling mode.
1703 * @phba: Pointer to HBA context object.
1705 * This function is called from lpfc_queuecommand, lpfc_poll_timeout,
1706 * lpfc_abort_handler and lpfc_slave_configure when FCP_RING_POLLING
1709 * The caller does not hold any lock.
1710 * The function processes each response iocb in the response ring until it
1711 * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
1712 * LE bit set. The function will call the completion handler of the command iocb
1713 * if the response iocb indicates a completion for a command iocb or it is
1714 * an abort completion.
1716 void lpfc_sli_poll_fcp_ring(struct lpfc_hba *phba)
1718 struct lpfc_sli *psli = &phba->sli;
1719 struct lpfc_sli_ring *pring = &psli->ring[LPFC_FCP_RING];
1720 IOCB_t *irsp = NULL;
1721 IOCB_t *entry = NULL;
1722 struct lpfc_iocbq *cmdiocbq = NULL;
1723 struct lpfc_iocbq rspiocbq;
1724 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1726 uint32_t portRspPut, portRspMax;
1728 uint32_t rsp_cmpl = 0;
1730 unsigned long iflags;
1732 pring->stats.iocb_event++;
1735 * The next available response entry should never exceed the maximum
1736 * entries. If it does, treat it as an adapter hardware error.
1738 portRspMax = pring->numRiocb;
1739 portRspPut = le32_to_cpu(pgp->rspPutInx);
1740 if (unlikely(portRspPut >= portRspMax)) {
1741 lpfc_sli_rsp_pointers_error(phba, pring);
1746 while (pring->rspidx != portRspPut) {
1747 entry = lpfc_resp_iocb(phba, pring);
1748 if (++pring->rspidx >= portRspMax)
1751 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
1752 (uint32_t *) &rspiocbq.iocb,
1753 phba->iocb_rsp_size);
1754 irsp = &rspiocbq.iocb;
1755 type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
1756 pring->stats.iocb_rsp++;
1759 if (unlikely(irsp->ulpStatus)) {
1760 /* Rsp ring <ringno> error: IOCB */
1761 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1762 "0326 Rsp Ring %d error: IOCB Data: "
1763 "x%x x%x x%x x%x x%x x%x x%x x%x\n",
1765 irsp->un.ulpWord[0],
1766 irsp->un.ulpWord[1],
1767 irsp->un.ulpWord[2],
1768 irsp->un.ulpWord[3],
1769 irsp->un.ulpWord[4],
1770 irsp->un.ulpWord[5],
1771 *(uint32_t *)&irsp->un1,
1772 *((uint32_t *)&irsp->un1 + 1));
1776 case LPFC_ABORT_IOCB:
1779 * Idle exchange closed via ABTS from port. No iocb
1780 * resources need to be recovered.
1782 if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
1783 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1784 "0314 IOCB cmd 0x%x "
1785 "processed. Skipping "
1791 spin_lock_irqsave(&phba->hbalock, iflags);
1792 cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1794 spin_unlock_irqrestore(&phba->hbalock, iflags);
1795 if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
1796 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1801 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
1802 char adaptermsg[LPFC_MAX_ADPTMSG];
1803 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
1804 memcpy(&adaptermsg[0], (uint8_t *) irsp,
1806 dev_warn(&((phba->pcidev)->dev),
1808 phba->brd_no, adaptermsg);
1810 /* Unknown IOCB command */
1811 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1812 "0321 Unknown IOCB command "
1813 "Data: x%x, x%x x%x x%x x%x\n",
1814 type, irsp->ulpCommand,
1823 * The response IOCB has been processed. Update the ring
1824 * pointer in SLIM. If the port response put pointer has not
1825 * been updated, sync the pgp->rspPutInx and fetch the new port
1826 * response put pointer.
1828 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
1830 if (pring->rspidx == portRspPut)
1831 portRspPut = le32_to_cpu(pgp->rspPutInx);
1834 ha_copy = readl(phba->HAregaddr);
1835 ha_copy >>= (LPFC_FCP_RING * 4);
1837 if ((rsp_cmpl > 0) && (ha_copy & HA_R0RE_REQ)) {
1838 spin_lock_irqsave(&phba->hbalock, iflags);
1839 pring->stats.iocb_rsp_full++;
1840 status = ((CA_R0ATT | CA_R0RE_RSP) << (LPFC_FCP_RING * 4));
1841 writel(status, phba->CAregaddr);
1842 readl(phba->CAregaddr);
1843 spin_unlock_irqrestore(&phba->hbalock, iflags);
1845 if ((ha_copy & HA_R0CE_RSP) &&
1846 (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
1847 spin_lock_irqsave(&phba->hbalock, iflags);
1848 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
1849 pring->stats.iocb_cmd_empty++;
1851 /* Force update of the local copy of cmdGetInx */
1852 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
1853 lpfc_sli_resume_iocb(phba, pring);
1855 if ((pring->lpfc_sli_cmd_available))
1856 (pring->lpfc_sli_cmd_available) (phba, pring);
1858 spin_unlock_irqrestore(&phba->hbalock, iflags);
1865 * lpfc_sli_handle_fast_ring_event: Handle ring events on FCP ring.
1866 * @phba: Pointer to HBA context object.
1867 * @pring: Pointer to driver SLI ring object.
1868 * @mask: Host attention register mask for this ring.
1870 * This function is called from the interrupt context when there is a ring
1871 * event for the fcp ring. The caller does not hold any lock.
1872 * The function processes each response iocb in the response ring until it
1873 * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
1874 * LE bit set. The function will call the completion handler of the command iocb
1875 * if the response iocb indicates a completion for a command iocb or it is
1876 * an abort completion. The function will call lpfc_sli_process_unsol_iocb
1877 * function if this is an unsolicited iocb.
1878 * This routine presumes LPFC_FCP_RING handling and doesn't bother
1879 * to check it explicitly. This function always returns 1.
1882 lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
1883 struct lpfc_sli_ring *pring, uint32_t mask)
1885 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1886 IOCB_t *irsp = NULL;
1887 IOCB_t *entry = NULL;
1888 struct lpfc_iocbq *cmdiocbq = NULL;
1889 struct lpfc_iocbq rspiocbq;
1891 uint32_t portRspPut, portRspMax;
1893 lpfc_iocb_type type;
1894 unsigned long iflag;
1895 uint32_t rsp_cmpl = 0;
1897 spin_lock_irqsave(&phba->hbalock, iflag);
1898 pring->stats.iocb_event++;
1901 * The next available response entry should never exceed the maximum
1902 * entries. If it does, treat it as an adapter hardware error.
1904 portRspMax = pring->numRiocb;
1905 portRspPut = le32_to_cpu(pgp->rspPutInx);
1906 if (unlikely(portRspPut >= portRspMax)) {
1907 lpfc_sli_rsp_pointers_error(phba, pring);
1908 spin_unlock_irqrestore(&phba->hbalock, iflag);
1913 while (pring->rspidx != portRspPut) {
1915 * Fetch an entry off the ring and copy it into a local data
1916 * structure. The copy involves a byte-swap since the
1917 * network byte order and pci byte orders are different.
1919 entry = lpfc_resp_iocb(phba, pring);
1920 phba->last_completion_time = jiffies;
1922 if (++pring->rspidx >= portRspMax)
1925 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
1926 (uint32_t *) &rspiocbq.iocb,
1927 phba->iocb_rsp_size);
1928 INIT_LIST_HEAD(&(rspiocbq.list));
1929 irsp = &rspiocbq.iocb;
1931 type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
1932 pring->stats.iocb_rsp++;
1935 if (unlikely(irsp->ulpStatus)) {
1937 * If resource errors reported from HBA, reduce
1938 * queuedepths of the SCSI device.
1940 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1941 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
1942 spin_unlock_irqrestore(&phba->hbalock, iflag);
1943 lpfc_adjust_queue_depth(phba);
1944 spin_lock_irqsave(&phba->hbalock, iflag);
1947 /* Rsp ring <ringno> error: IOCB */
1948 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1949 "0336 Rsp Ring %d error: IOCB Data: "
1950 "x%x x%x x%x x%x x%x x%x x%x x%x\n",
1952 irsp->un.ulpWord[0],
1953 irsp->un.ulpWord[1],
1954 irsp->un.ulpWord[2],
1955 irsp->un.ulpWord[3],
1956 irsp->un.ulpWord[4],
1957 irsp->un.ulpWord[5],
1958 *(uint32_t *)&irsp->un1,
1959 *((uint32_t *)&irsp->un1 + 1));
1963 case LPFC_ABORT_IOCB:
1966 * Idle exchange closed via ABTS from port. No iocb
1967 * resources need to be recovered.
1969 if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
1970 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1971 "0333 IOCB cmd 0x%x"
1972 " processed. Skipping"
1978 cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1980 if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
1981 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
1982 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1985 spin_unlock_irqrestore(&phba->hbalock,
1987 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1989 spin_lock_irqsave(&phba->hbalock,
1994 case LPFC_UNSOL_IOCB:
1995 spin_unlock_irqrestore(&phba->hbalock, iflag);
1996 lpfc_sli_process_unsol_iocb(phba, pring, &rspiocbq);
1997 spin_lock_irqsave(&phba->hbalock, iflag);
2000 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
2001 char adaptermsg[LPFC_MAX_ADPTMSG];
2002 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
2003 memcpy(&adaptermsg[0], (uint8_t *) irsp,
2005 dev_warn(&((phba->pcidev)->dev),
2007 phba->brd_no, adaptermsg);
2009 /* Unknown IOCB command */
2010 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2011 "0334 Unknown IOCB command "
2012 "Data: x%x, x%x x%x x%x x%x\n",
2013 type, irsp->ulpCommand,
2022 * The response IOCB has been processed. Update the ring
2023 * pointer in SLIM. If the port response put pointer has not
2024 * been updated, sync the pgp->rspPutInx and fetch the new port
2025 * response put pointer.
2027 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
2029 if (pring->rspidx == portRspPut)
2030 portRspPut = le32_to_cpu(pgp->rspPutInx);
2033 if ((rsp_cmpl > 0) && (mask & HA_R0RE_REQ)) {
2034 pring->stats.iocb_rsp_full++;
2035 status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
2036 writel(status, phba->CAregaddr);
2037 readl(phba->CAregaddr);
2039 if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
2040 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
2041 pring->stats.iocb_cmd_empty++;
2043 /* Force update of the local copy of cmdGetInx */
2044 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
2045 lpfc_sli_resume_iocb(phba, pring);
2047 if ((pring->lpfc_sli_cmd_available))
2048 (pring->lpfc_sli_cmd_available) (phba, pring);
2052 spin_unlock_irqrestore(&phba->hbalock, iflag);
2057 * lpfc_sli_handle_slow_ring_event: Handle ring events for non-FCP rings.
2058 * @phba: Pointer to HBA context object.
2059 * @pring: Pointer to driver SLI ring object.
2060 * @mask: Host attention register mask for this ring.
2062 * This function is called from the worker thread when there is a ring
2063 * event for non-fcp rings. The caller does not hold any lock .
2064 * The function processes each response iocb in the response ring until it
2065 * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
2066 * LE bit set. The function will call lpfc_sli_process_sol_iocb function if the
2067 * response iocb indicates a completion of a command iocb. The function
2068 * will call lpfc_sli_process_unsol_iocb function if this is an unsolicited
2069 * iocb. The function frees the resources or calls the completion handler if
2070 * this iocb is an abort completion. The function returns 0 when the allocated
2071 * iocbs are not freed, otherwise returns 1.
2074 lpfc_sli_handle_slow_ring_event(struct lpfc_hba *phba,
2075 struct lpfc_sli_ring *pring, uint32_t mask)
2077 struct lpfc_pgp *pgp;
2079 IOCB_t *irsp = NULL;
2080 struct lpfc_iocbq *rspiocbp = NULL;
2081 struct lpfc_iocbq *next_iocb;
2082 struct lpfc_iocbq *cmdiocbp;
2083 struct lpfc_iocbq *saveq;
2084 uint8_t iocb_cmd_type;
2085 lpfc_iocb_type type;
2086 uint32_t status, free_saveq;
2087 uint32_t portRspPut, portRspMax;
2089 unsigned long iflag;
2091 pgp = &phba->port_gp[pring->ringno];
2092 spin_lock_irqsave(&phba->hbalock, iflag);
2093 pring->stats.iocb_event++;
2096 * The next available response entry should never exceed the maximum
2097 * entries. If it does, treat it as an adapter hardware error.
2099 portRspMax = pring->numRiocb;
2100 portRspPut = le32_to_cpu(pgp->rspPutInx);
2101 if (portRspPut >= portRspMax) {
2103 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
2104 * rsp ring <portRspMax>
2106 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2107 "0303 Ring %d handler: portRspPut %d "
2108 "is bigger then rsp ring %d\n",
2109 pring->ringno, portRspPut, portRspMax);
2111 phba->link_state = LPFC_HBA_ERROR;
2112 spin_unlock_irqrestore(&phba->hbalock, iflag);
2114 phba->work_hs = HS_FFER3;
2115 lpfc_handle_eratt(phba);
2121 while (pring->rspidx != portRspPut) {
2123 * Build a completion list and call the appropriate handler.
2124 * The process is to get the next available response iocb, get
2125 * a free iocb from the list, copy the response data into the
2126 * free iocb, insert to the continuation list, and update the
2127 * next response index to slim. This process makes response
2128 * iocb's in the ring available to DMA as fast as possible but
2129 * pays a penalty for a copy operation. Since the iocb is
2130 * only 32 bytes, this penalty is considered small relative to
2131 * the PCI reads for register values and a slim write. When
2132 * the ulpLe field is set, the entire Command has been
2135 entry = lpfc_resp_iocb(phba, pring);
2137 phba->last_completion_time = jiffies;
2138 rspiocbp = __lpfc_sli_get_iocbq(phba);
2139 if (rspiocbp == NULL) {
2140 printk(KERN_ERR "%s: out of buffers! Failing "
2141 "completion.\n", __func__);
2145 lpfc_sli_pcimem_bcopy(entry, &rspiocbp->iocb,
2146 phba->iocb_rsp_size);
2147 irsp = &rspiocbp->iocb;
2149 if (++pring->rspidx >= portRspMax)
2152 if (pring->ringno == LPFC_ELS_RING) {
2153 lpfc_debugfs_slow_ring_trc(phba,
2154 "IOCB rsp ring: wd4:x%08x wd6:x%08x wd7:x%08x",
2155 *(((uint32_t *) irsp) + 4),
2156 *(((uint32_t *) irsp) + 6),
2157 *(((uint32_t *) irsp) + 7));
2160 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
2162 list_add_tail(&rspiocbp->list, &(pring->iocb_continueq));
2164 pring->iocb_continueq_cnt++;
2167 * By default, the driver expects to free all resources
2168 * associated with this iocb completion.
2171 saveq = list_get_first(&pring->iocb_continueq,
2172 struct lpfc_iocbq, list);
2173 irsp = &(saveq->iocb);
2174 list_del_init(&pring->iocb_continueq);
2175 pring->iocb_continueq_cnt = 0;
2177 pring->stats.iocb_rsp++;
2180 * If resource errors reported from HBA, reduce
2181 * queuedepths of the SCSI device.
2183 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
2184 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
2185 spin_unlock_irqrestore(&phba->hbalock, iflag);
2186 lpfc_adjust_queue_depth(phba);
2187 spin_lock_irqsave(&phba->hbalock, iflag);
2190 if (irsp->ulpStatus) {
2191 /* Rsp ring <ringno> error: IOCB */
2192 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
2193 "0328 Rsp Ring %d error: "
2198 "x%x x%x x%x x%x\n",
2200 irsp->un.ulpWord[0],
2201 irsp->un.ulpWord[1],
2202 irsp->un.ulpWord[2],
2203 irsp->un.ulpWord[3],
2204 irsp->un.ulpWord[4],
2205 irsp->un.ulpWord[5],
2206 *(((uint32_t *) irsp) + 6),
2207 *(((uint32_t *) irsp) + 7),
2208 *(((uint32_t *) irsp) + 8),
2209 *(((uint32_t *) irsp) + 9),
2210 *(((uint32_t *) irsp) + 10),
2211 *(((uint32_t *) irsp) + 11),
2212 *(((uint32_t *) irsp) + 12),
2213 *(((uint32_t *) irsp) + 13),
2214 *(((uint32_t *) irsp) + 14),
2215 *(((uint32_t *) irsp) + 15));
2219 * Fetch the IOCB command type and call the correct
2220 * completion routine. Solicited and Unsolicited
2221 * IOCBs on the ELS ring get freed back to the
2222 * lpfc_iocb_list by the discovery kernel thread.
2224 iocb_cmd_type = irsp->ulpCommand & CMD_IOCB_MASK;
2225 type = lpfc_sli_iocb_cmd_type(iocb_cmd_type);
2226 if (type == LPFC_SOL_IOCB) {
2227 spin_unlock_irqrestore(&phba->hbalock, iflag);
2228 rc = lpfc_sli_process_sol_iocb(phba, pring,
2230 spin_lock_irqsave(&phba->hbalock, iflag);
2231 } else if (type == LPFC_UNSOL_IOCB) {
2232 spin_unlock_irqrestore(&phba->hbalock, iflag);
2233 rc = lpfc_sli_process_unsol_iocb(phba, pring,
2235 spin_lock_irqsave(&phba->hbalock, iflag);
2238 } else if (type == LPFC_ABORT_IOCB) {
2239 if ((irsp->ulpCommand != CMD_XRI_ABORTED_CX) &&
2241 lpfc_sli_iocbq_lookup(phba, pring,
2243 /* Call the specified completion
2245 if (cmdiocbp->iocb_cmpl) {
2246 spin_unlock_irqrestore(
2249 (cmdiocbp->iocb_cmpl) (phba,
2255 __lpfc_sli_release_iocbq(phba,
2258 } else if (type == LPFC_UNKNOWN_IOCB) {
2259 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
2261 char adaptermsg[LPFC_MAX_ADPTMSG];
2263 memset(adaptermsg, 0,
2265 memcpy(&adaptermsg[0], (uint8_t *) irsp,
2267 dev_warn(&((phba->pcidev)->dev),
2269 phba->brd_no, adaptermsg);
2271 /* Unknown IOCB command */
2272 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2273 "0335 Unknown IOCB "
2274 "command Data: x%x "
2284 list_for_each_entry_safe(rspiocbp, next_iocb,
2285 &saveq->list, list) {
2286 list_del(&rspiocbp->list);
2287 __lpfc_sli_release_iocbq(phba,
2290 __lpfc_sli_release_iocbq(phba, saveq);
2296 * If the port response put pointer has not been updated, sync
2297 * the pgp->rspPutInx in the MAILBOX_tand fetch the new port
2298 * response put pointer.
2300 if (pring->rspidx == portRspPut) {
2301 portRspPut = le32_to_cpu(pgp->rspPutInx);
2303 } /* while (pring->rspidx != portRspPut) */
2305 if ((rspiocbp != NULL) && (mask & HA_R0RE_REQ)) {
2306 /* At least one response entry has been freed */
2307 pring->stats.iocb_rsp_full++;
2308 /* SET RxRE_RSP in Chip Att register */
2309 status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
2310 writel(status, phba->CAregaddr);
2311 readl(phba->CAregaddr); /* flush */
2313 if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
2314 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
2315 pring->stats.iocb_cmd_empty++;
2317 /* Force update of the local copy of cmdGetInx */
2318 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
2319 lpfc_sli_resume_iocb(phba, pring);
2321 if ((pring->lpfc_sli_cmd_available))
2322 (pring->lpfc_sli_cmd_available) (phba, pring);
2326 spin_unlock_irqrestore(&phba->hbalock, iflag);
2331 * lpfc_sli_abort_iocb_ring: Abort all iocbs in the ring.
2332 * @phba: Pointer to HBA context object.
2333 * @pring: Pointer to driver SLI ring object.
2335 * This function aborts all iocbs in the given ring and frees all the iocb
2336 * objects in txq. This function issues an abort iocb for all the iocb commands
2337 * in txcmplq. The iocbs in the txcmplq is not guaranteed to complete before
2338 * the return of this function. The caller is not required to hold any locks.
2341 lpfc_sli_abort_iocb_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
2343 LIST_HEAD(completions);
2344 struct lpfc_iocbq *iocb, *next_iocb;
2347 if (pring->ringno == LPFC_ELS_RING) {
2348 lpfc_fabric_abort_hba(phba);
2351 /* Error everything on txq and txcmplq
2354 spin_lock_irq(&phba->hbalock);
2355 list_splice_init(&pring->txq, &completions);
2358 /* Next issue ABTS for everything on the txcmplq */
2359 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list)
2360 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
2362 spin_unlock_irq(&phba->hbalock);
2364 while (!list_empty(&completions)) {
2365 iocb = list_get_first(&completions, struct lpfc_iocbq, list);
2367 list_del_init(&iocb->list);
2369 if (!iocb->iocb_cmpl)
2370 lpfc_sli_release_iocbq(phba, iocb);
2372 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
2373 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
2374 (iocb->iocb_cmpl) (phba, iocb, iocb);
2380 * lpfc_sli_brdready: Check for host status bits.
2381 * @phba: Pointer to HBA context object.
2382 * @mask: Bit mask to be checked.
2384 * This function reads the host status register and compares
2385 * with the provided bit mask to check if HBA completed
2386 * the restart. This function will wait in a loop for the
2387 * HBA to complete restart. If the HBA does not restart within
2388 * 15 iterations, the function will reset the HBA again. The
2389 * function returns 1 when HBA fail to restart otherwise returns
2393 lpfc_sli_brdready(struct lpfc_hba *phba, uint32_t mask)
2399 /* Read the HBA Host Status Register */
2400 status = readl(phba->HSregaddr);
2403 * Check status register every 100ms for 5 retries, then every
2404 * 500ms for 5, then every 2.5 sec for 5, then reset board and
2405 * every 2.5 sec for 4.
2406 * Break our of the loop if errors occurred during init.
2408 while (((status & mask) != mask) &&
2409 !(status & HS_FFERM) &&
2421 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
2422 lpfc_sli_brdrestart(phba);
2424 /* Read the HBA Host Status Register */
2425 status = readl(phba->HSregaddr);
2428 /* Check to see if any errors occurred during init */
2429 if ((status & HS_FFERM) || (i >= 20)) {
2430 phba->link_state = LPFC_HBA_ERROR;
2437 #define BARRIER_TEST_PATTERN (0xdeadbeef)
2440 * lpfc_reset_barrier: Make HBA ready for HBA reset.
2441 * @phba: Pointer to HBA context object.
2443 * This function is called before resetting an HBA. This
2444 * function requests HBA to quiesce DMAs before a reset.
2446 void lpfc_reset_barrier(struct lpfc_hba *phba)
2448 uint32_t __iomem *resp_buf;
2449 uint32_t __iomem *mbox_buf;
2450 volatile uint32_t mbox;
2455 pci_read_config_byte(phba->pcidev, PCI_HEADER_TYPE, &hdrtype);
2456 if (hdrtype != 0x80 ||
2457 (FC_JEDEC_ID(phba->vpd.rev.biuRev) != HELIOS_JEDEC_ID &&
2458 FC_JEDEC_ID(phba->vpd.rev.biuRev) != THOR_JEDEC_ID))
2462 * Tell the other part of the chip to suspend temporarily all
2465 resp_buf = phba->MBslimaddr;
2467 /* Disable the error attention */
2468 hc_copy = readl(phba->HCregaddr);
2469 writel((hc_copy & ~HC_ERINT_ENA), phba->HCregaddr);
2470 readl(phba->HCregaddr); /* flush */
2471 phba->link_flag |= LS_IGNORE_ERATT;
2473 if (readl(phba->HAregaddr) & HA_ERATT) {
2474 /* Clear Chip error bit */
2475 writel(HA_ERATT, phba->HAregaddr);
2476 phba->pport->stopped = 1;
2480 ((MAILBOX_t *)&mbox)->mbxCommand = MBX_KILL_BOARD;
2481 ((MAILBOX_t *)&mbox)->mbxOwner = OWN_CHIP;
2483 writel(BARRIER_TEST_PATTERN, (resp_buf + 1));
2484 mbox_buf = phba->MBslimaddr;
2485 writel(mbox, mbox_buf);
2488 readl(resp_buf + 1) != ~(BARRIER_TEST_PATTERN) && i < 50; i++)
2491 if (readl(resp_buf + 1) != ~(BARRIER_TEST_PATTERN)) {
2492 if (phba->sli.sli_flag & LPFC_SLI2_ACTIVE ||
2493 phba->pport->stopped)
2499 ((MAILBOX_t *)&mbox)->mbxOwner = OWN_HOST;
2500 for (i = 0; readl(resp_buf) != mbox && i < 500; i++)
2505 while (!(readl(phba->HAregaddr) & HA_ERATT) && ++i < 500)
2508 if (readl(phba->HAregaddr) & HA_ERATT) {
2509 writel(HA_ERATT, phba->HAregaddr);
2510 phba->pport->stopped = 1;
2514 phba->link_flag &= ~LS_IGNORE_ERATT;
2515 writel(hc_copy, phba->HCregaddr);
2516 readl(phba->HCregaddr); /* flush */
2520 * lpfc_sli_brdkill: Issue a kill_board mailbox command.
2521 * @phba: Pointer to HBA context object.
2523 * This function issues a kill_board mailbox command and waits for
2524 * the error attention interrupt. This function is called for stopping
2525 * the firmware processing. The caller is not required to hold any
2526 * locks. This function calls lpfc_hba_down_post function to free
2527 * any pending commands after the kill. The function will return 1 when it
2528 * fails to kill the board else will return 0.
2531 lpfc_sli_brdkill(struct lpfc_hba *phba)
2533 struct lpfc_sli *psli;
2543 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2544 "0329 Kill HBA Data: x%x x%x\n",
2545 phba->pport->port_state, psli->sli_flag);
2547 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2551 /* Disable the error attention */
2552 spin_lock_irq(&phba->hbalock);
2553 status = readl(phba->HCregaddr);
2554 status &= ~HC_ERINT_ENA;
2555 writel(status, phba->HCregaddr);
2556 readl(phba->HCregaddr); /* flush */
2557 phba->link_flag |= LS_IGNORE_ERATT;
2558 spin_unlock_irq(&phba->hbalock);
2560 lpfc_kill_board(phba, pmb);
2561 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2562 retval = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
2564 if (retval != MBX_SUCCESS) {
2565 if (retval != MBX_BUSY)
2566 mempool_free(pmb, phba->mbox_mem_pool);
2567 spin_lock_irq(&phba->hbalock);
2568 phba->link_flag &= ~LS_IGNORE_ERATT;
2569 spin_unlock_irq(&phba->hbalock);
2573 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
2575 mempool_free(pmb, phba->mbox_mem_pool);
2577 /* There is no completion for a KILL_BOARD mbox cmd. Check for an error
2578 * attention every 100ms for 3 seconds. If we don't get ERATT after
2579 * 3 seconds we still set HBA_ERROR state because the status of the
2580 * board is now undefined.
2582 ha_copy = readl(phba->HAregaddr);
2584 while ((i++ < 30) && !(ha_copy & HA_ERATT)) {
2586 ha_copy = readl(phba->HAregaddr);
2589 del_timer_sync(&psli->mbox_tmo);
2590 if (ha_copy & HA_ERATT) {
2591 writel(HA_ERATT, phba->HAregaddr);
2592 phba->pport->stopped = 1;
2594 spin_lock_irq(&phba->hbalock);
2595 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
2596 phba->link_flag &= ~LS_IGNORE_ERATT;
2597 spin_unlock_irq(&phba->hbalock);
2599 psli->mbox_active = NULL;
2600 lpfc_hba_down_post(phba);
2601 phba->link_state = LPFC_HBA_ERROR;
2603 return ha_copy & HA_ERATT ? 0 : 1;
2607 * lpfc_sli_brdreset: Reset the HBA.
2608 * @phba: Pointer to HBA context object.
2610 * This function resets the HBA by writing HC_INITFF to the control
2611 * register. After the HBA resets, this function resets all the iocb ring
2612 * indices. This function disables PCI layer parity checking during
2614 * This function returns 0 always.
2615 * The caller is not required to hold any locks.
2618 lpfc_sli_brdreset(struct lpfc_hba *phba)
2620 struct lpfc_sli *psli;
2621 struct lpfc_sli_ring *pring;
2628 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2629 "0325 Reset HBA Data: x%x x%x\n",
2630 phba->pport->port_state, psli->sli_flag);
2632 /* perform board reset */
2633 phba->fc_eventTag = 0;
2634 phba->pport->fc_myDID = 0;
2635 phba->pport->fc_prevDID = 0;
2637 /* Turn off parity checking and serr during the physical reset */
2638 pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value);
2639 pci_write_config_word(phba->pcidev, PCI_COMMAND,
2641 ~(PCI_COMMAND_PARITY | PCI_COMMAND_SERR)));
2643 psli->sli_flag &= ~(LPFC_SLI2_ACTIVE | LPFC_PROCESS_LA);
2644 /* Now toggle INITFF bit in the Host Control Register */
2645 writel(HC_INITFF, phba->HCregaddr);
2647 readl(phba->HCregaddr); /* flush */
2648 writel(0, phba->HCregaddr);
2649 readl(phba->HCregaddr); /* flush */
2651 /* Restore PCI cmd register */
2652 pci_write_config_word(phba->pcidev, PCI_COMMAND, cfg_value);
2654 /* Initialize relevant SLI info */
2655 for (i = 0; i < psli->num_rings; i++) {
2656 pring = &psli->ring[i];
2659 pring->next_cmdidx = 0;
2660 pring->local_getidx = 0;
2662 pring->missbufcnt = 0;
2665 phba->link_state = LPFC_WARM_START;
2670 * lpfc_sli_brdrestart: Restart the HBA.
2671 * @phba: Pointer to HBA context object.
2673 * This function is called in the SLI initialization code path to
2674 * restart the HBA. The caller is not required to hold any lock.
2675 * This function writes MBX_RESTART mailbox command to the SLIM and
2676 * resets the HBA. At the end of the function, it calls lpfc_hba_down_post
2677 * function to free any pending commands. The function enables
2678 * POST only during the first initialization. The function returns zero.
2679 * The function does not guarantee completion of MBX_RESTART mailbox
2680 * command before the return of this function.
2683 lpfc_sli_brdrestart(struct lpfc_hba *phba)
2686 struct lpfc_sli *psli;
2688 volatile uint32_t word0;
2689 void __iomem *to_slim;
2691 spin_lock_irq(&phba->hbalock);
2696 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2697 "0337 Restart HBA Data: x%x x%x\n",
2698 phba->pport->port_state, psli->sli_flag);
2701 mb = (MAILBOX_t *) &word0;
2702 mb->mbxCommand = MBX_RESTART;
2705 lpfc_reset_barrier(phba);
2707 to_slim = phba->MBslimaddr;
2708 writel(*(uint32_t *) mb, to_slim);
2709 readl(to_slim); /* flush */
2711 /* Only skip post after fc_ffinit is completed */
2712 if (phba->pport->port_state) {
2714 word0 = 1; /* This is really setting up word1 */
2717 word0 = 0; /* This is really setting up word1 */
2719 to_slim = phba->MBslimaddr + sizeof (uint32_t);
2720 writel(*(uint32_t *) mb, to_slim);
2721 readl(to_slim); /* flush */
2723 lpfc_sli_brdreset(phba);
2724 phba->pport->stopped = 0;
2725 phba->link_state = LPFC_INIT_START;
2727 spin_unlock_irq(&phba->hbalock);
2729 memset(&psli->lnk_stat_offsets, 0, sizeof(psli->lnk_stat_offsets));
2730 psli->stats_start = get_seconds();
2737 lpfc_hba_down_post(phba);
2743 * lpfc_sli_chipset_init: Wait for the restart of the HBA after a restart.
2744 * @phba: Pointer to HBA context object.
2746 * This function is called after a HBA restart to wait for successful
2747 * restart of the HBA. Successful restart of the HBA is indicated by
2748 * HS_FFRDY and HS_MBRDY bits. If the HBA fails to restart even after 15
2749 * iteration, the function will restart the HBA again. The function returns
2750 * zero if HBA successfully restarted else returns negative error code.
2753 lpfc_sli_chipset_init(struct lpfc_hba *phba)
2755 uint32_t status, i = 0;
2757 /* Read the HBA Host Status Register */
2758 status = readl(phba->HSregaddr);
2760 /* Check status register to see what current state is */
2762 while ((status & (HS_FFRDY | HS_MBRDY)) != (HS_FFRDY | HS_MBRDY)) {
2764 /* Check every 100ms for 5 retries, then every 500ms for 5, then
2765 * every 2.5 sec for 5, then reset board and every 2.5 sec for
2769 /* Adapter failed to init, timeout, status reg
2771 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2772 "0436 Adapter failed to init, "
2773 "timeout, status reg x%x, "
2774 "FW Data: A8 x%x AC x%x\n", status,
2775 readl(phba->MBslimaddr + 0xa8),
2776 readl(phba->MBslimaddr + 0xac));
2777 phba->link_state = LPFC_HBA_ERROR;
2781 /* Check to see if any errors occurred during init */
2782 if (status & HS_FFERM) {
2783 /* ERROR: During chipset initialization */
2784 /* Adapter failed to init, chipset, status reg
2786 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2787 "0437 Adapter failed to init, "
2788 "chipset, status reg x%x, "
2789 "FW Data: A8 x%x AC x%x\n", status,
2790 readl(phba->MBslimaddr + 0xa8),
2791 readl(phba->MBslimaddr + 0xac));
2792 phba->link_state = LPFC_HBA_ERROR;
2798 } else if (i <= 10) {
2806 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
2807 lpfc_sli_brdrestart(phba);
2809 /* Read the HBA Host Status Register */
2810 status = readl(phba->HSregaddr);
2813 /* Check to see if any errors occurred during init */
2814 if (status & HS_FFERM) {
2815 /* ERROR: During chipset initialization */
2816 /* Adapter failed to init, chipset, status reg <status> */
2817 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2818 "0438 Adapter failed to init, chipset, "
2820 "FW Data: A8 x%x AC x%x\n", status,
2821 readl(phba->MBslimaddr + 0xa8),
2822 readl(phba->MBslimaddr + 0xac));
2823 phba->link_state = LPFC_HBA_ERROR;
2827 /* Clear all interrupt enable conditions */
2828 writel(0, phba->HCregaddr);
2829 readl(phba->HCregaddr); /* flush */
2831 /* setup host attn register */
2832 writel(0xffffffff, phba->HAregaddr);
2833 readl(phba->HAregaddr); /* flush */
2838 * lpfc_sli_hbq_count: Get the number of HBQs to be configured.
2840 * This function calculates and returns the number of HBQs required to be
2844 lpfc_sli_hbq_count(void)
2846 return ARRAY_SIZE(lpfc_hbq_defs);
2850 * lpfc_sli_hbq_entry_count: Calculate total number of hbq entries.
2852 * This function adds the number of hbq entries in every HBQ to get
2853 * the total number of hbq entries required for the HBA and returns
2857 lpfc_sli_hbq_entry_count(void)
2859 int hbq_count = lpfc_sli_hbq_count();
2863 for (i = 0; i < hbq_count; ++i)
2864 count += lpfc_hbq_defs[i]->entry_count;
2869 * lpfc_sli_hbq_size: Calculate memory required for all hbq entries.
2871 * This function calculates amount of memory required for all hbq entries
2872 * to be configured and returns the total memory required.
2875 lpfc_sli_hbq_size(void)
2877 return lpfc_sli_hbq_entry_count() * sizeof(struct lpfc_hbq_entry);
2881 * lpfc_sli_hbq_setup: configure and initialize HBQs.
2882 * @phba: Pointer to HBA context object.
2884 * This function is called during the SLI initialization to configure
2885 * all the HBQs and post buffers to the HBQ. The caller is not
2886 * required to hold any locks. This function will return zero if successful
2887 * else it will return negative error code.
2890 lpfc_sli_hbq_setup(struct lpfc_hba *phba)
2892 int hbq_count = lpfc_sli_hbq_count();
2896 uint32_t hbq_entry_index;
2898 /* Get a Mailbox buffer to setup mailbox
2899 * commands for HBA initialization
2901 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2908 /* Initialize the struct lpfc_sli_hbq structure for each hbq */
2909 phba->link_state = LPFC_INIT_MBX_CMDS;
2910 phba->hbq_in_use = 1;
2912 hbq_entry_index = 0;
2913 for (hbqno = 0; hbqno < hbq_count; ++hbqno) {
2914 phba->hbqs[hbqno].next_hbqPutIdx = 0;
2915 phba->hbqs[hbqno].hbqPutIdx = 0;
2916 phba->hbqs[hbqno].local_hbqGetIdx = 0;
2917 phba->hbqs[hbqno].entry_count =
2918 lpfc_hbq_defs[hbqno]->entry_count;
2919 lpfc_config_hbq(phba, hbqno, lpfc_hbq_defs[hbqno],
2920 hbq_entry_index, pmb);
2921 hbq_entry_index += phba->hbqs[hbqno].entry_count;
2923 if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
2924 /* Adapter failed to init, mbxCmd <cmd> CFG_RING,
2925 mbxStatus <status>, ring <num> */
2927 lpfc_printf_log(phba, KERN_ERR,
2928 LOG_SLI | LOG_VPORT,
2929 "1805 Adapter failed to init. "
2930 "Data: x%x x%x x%x\n",
2932 pmbox->mbxStatus, hbqno);
2934 phba->link_state = LPFC_HBA_ERROR;
2935 mempool_free(pmb, phba->mbox_mem_pool);
2939 phba->hbq_count = hbq_count;
2941 mempool_free(pmb, phba->mbox_mem_pool);
2943 /* Initially populate or replenish the HBQs */
2944 for (hbqno = 0; hbqno < hbq_count; ++hbqno)
2945 lpfc_sli_hbqbuf_init_hbqs(phba, hbqno);
2950 * lpfc_do_config_port: Issue config port mailbox command.
2951 * @phba: Pointer to HBA context object.
2952 * @sli_mode: sli mode - 2/3
2954 * This function is called by the sli intialization code path
2955 * to issue config_port mailbox command. This function restarts the
2956 * HBA firmware and issues a config_port mailbox command to configure
2957 * the SLI interface in the sli mode specified by sli_mode
2958 * variable. The caller is not required to hold any locks.
2959 * The function returns 0 if successful, else returns negative error
2963 lpfc_do_config_port(struct lpfc_hba *phba, int sli_mode)
2966 uint32_t resetcount = 0, rc = 0, done = 0;
2968 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2970 phba->link_state = LPFC_HBA_ERROR;
2974 phba->sli_rev = sli_mode;
2975 while (resetcount < 2 && !done) {
2976 spin_lock_irq(&phba->hbalock);
2977 phba->sli.sli_flag |= LPFC_SLI_MBOX_ACTIVE;
2978 spin_unlock_irq(&phba->hbalock);
2979 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
2980 lpfc_sli_brdrestart(phba);
2982 rc = lpfc_sli_chipset_init(phba);
2986 spin_lock_irq(&phba->hbalock);
2987 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
2988 spin_unlock_irq(&phba->hbalock);
2991 /* Call pre CONFIG_PORT mailbox command initialization. A
2992 * value of 0 means the call was successful. Any other
2993 * nonzero value is a failure, but if ERESTART is returned,
2994 * the driver may reset the HBA and try again.
2996 rc = lpfc_config_port_prep(phba);
2997 if (rc == -ERESTART) {
2998 phba->link_state = LPFC_LINK_UNKNOWN;
3002 phba->link_state = LPFC_INIT_MBX_CMDS;
3003 lpfc_config_port(phba, pmb);
3004 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
3005 phba->sli3_options &= ~(LPFC_SLI3_NPIV_ENABLED |
3006 LPFC_SLI3_HBQ_ENABLED |
3007 LPFC_SLI3_CRP_ENABLED |
3008 LPFC_SLI3_INB_ENABLED);
3009 if (rc != MBX_SUCCESS) {
3010 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3011 "0442 Adapter failed to init, mbxCmd x%x "
3012 "CONFIG_PORT, mbxStatus x%x Data: x%x\n",
3013 pmb->mb.mbxCommand, pmb->mb.mbxStatus, 0);
3014 spin_lock_irq(&phba->hbalock);
3015 phba->sli.sli_flag &= ~LPFC_SLI2_ACTIVE;
3016 spin_unlock_irq(&phba->hbalock);
3023 goto do_prep_failed;
3025 if (pmb->mb.un.varCfgPort.sli_mode == 3) {
3026 if (!pmb->mb.un.varCfgPort.cMA) {
3028 goto do_prep_failed;
3030 if (phba->max_vpi && pmb->mb.un.varCfgPort.gmv) {
3031 phba->sli3_options |= LPFC_SLI3_NPIV_ENABLED;
3032 phba->max_vpi = pmb->mb.un.varCfgPort.max_vpi;
3035 if (pmb->mb.un.varCfgPort.gerbm)
3036 phba->sli3_options |= LPFC_SLI3_HBQ_ENABLED;
3037 if (pmb->mb.un.varCfgPort.gcrp)
3038 phba->sli3_options |= LPFC_SLI3_CRP_ENABLED;
3039 if (pmb->mb.un.varCfgPort.ginb) {
3040 phba->sli3_options |= LPFC_SLI3_INB_ENABLED;
3041 phba->port_gp = phba->mbox->us.s3_inb_pgp.port;
3042 phba->inb_ha_copy = &phba->mbox->us.s3_inb_pgp.ha_copy;
3043 phba->inb_counter = &phba->mbox->us.s3_inb_pgp.counter;
3044 phba->inb_last_counter =
3045 phba->mbox->us.s3_inb_pgp.counter;
3047 phba->port_gp = phba->mbox->us.s3_pgp.port;
3048 phba->inb_ha_copy = NULL;
3049 phba->inb_counter = NULL;
3052 phba->port_gp = phba->mbox->us.s2.port;
3053 phba->inb_ha_copy = NULL;
3054 phba->inb_counter = NULL;
3058 mempool_free(pmb, phba->mbox_mem_pool);
3064 * lpfc_sli_hba_setup: SLI intialization function.
3065 * @phba: Pointer to HBA context object.
3067 * This function is the main SLI intialization function. This function
3068 * is called by the HBA intialization code, HBA reset code and HBA
3069 * error attention handler code. Caller is not required to hold any
3070 * locks. This function issues config_port mailbox command to configure
3071 * the SLI, setup iocb rings and HBQ rings. In the end the function
3072 * calls the config_port_post function to issue init_link mailbox
3073 * command and to start the discovery. The function will return zero
3074 * if successful, else it will return negative error code.
3077 lpfc_sli_hba_setup(struct lpfc_hba *phba)
3082 switch (lpfc_sli_mode) {
3084 if (phba->cfg_enable_npiv) {
3085 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3086 "1824 NPIV enabled: Override lpfc_sli_mode "
3087 "parameter (%d) to auto (0).\n",
3097 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3098 "1819 Unrecognized lpfc_sli_mode "
3099 "parameter: %d.\n", lpfc_sli_mode);
3104 rc = lpfc_do_config_port(phba, mode);
3105 if (rc && lpfc_sli_mode == 3)
3106 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3107 "1820 Unable to select SLI-3. "
3108 "Not supported by adapter.\n");
3109 if (rc && mode != 2)
3110 rc = lpfc_do_config_port(phba, 2);
3112 goto lpfc_sli_hba_setup_error;
3114 if (phba->sli_rev == 3) {
3115 phba->iocb_cmd_size = SLI3_IOCB_CMD_SIZE;
3116 phba->iocb_rsp_size = SLI3_IOCB_RSP_SIZE;
3118 phba->iocb_cmd_size = SLI2_IOCB_CMD_SIZE;
3119 phba->iocb_rsp_size = SLI2_IOCB_RSP_SIZE;
3120 phba->sli3_options = 0;
3123 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3124 "0444 Firmware in SLI %x mode. Max_vpi %d\n",
3125 phba->sli_rev, phba->max_vpi);
3126 rc = lpfc_sli_ring_map(phba);
3129 goto lpfc_sli_hba_setup_error;
3133 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
3134 rc = lpfc_sli_hbq_setup(phba);
3136 goto lpfc_sli_hba_setup_error;
3139 phba->sli.sli_flag |= LPFC_PROCESS_LA;
3141 rc = lpfc_config_port_post(phba);
3143 goto lpfc_sli_hba_setup_error;
3147 lpfc_sli_hba_setup_error:
3148 phba->link_state = LPFC_HBA_ERROR;
3149 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3150 "0445 Firmware initialization failed\n");
3156 * lpfc_mbox_timeout: Timeout call back function for mbox timer.
3157 * @ptr: context object - pointer to hba structure.
3159 * This is the callback function for mailbox timer. The mailbox
3160 * timer is armed when a new mailbox command is issued and the timer
3161 * is deleted when the mailbox complete. The function is called by
3162 * the kernel timer code when a mailbox does not complete within
3163 * expected time. This function wakes up the worker thread to
3164 * process the mailbox timeout and returns. All the processing is
3165 * done by the worker thread function lpfc_mbox_timeout_handler.
3168 lpfc_mbox_timeout(unsigned long ptr)
3170 struct lpfc_hba *phba = (struct lpfc_hba *) ptr;
3171 unsigned long iflag;
3172 uint32_t tmo_posted;
3174 spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
3175 tmo_posted = phba->pport->work_port_events & WORKER_MBOX_TMO;
3177 phba->pport->work_port_events |= WORKER_MBOX_TMO;
3178 spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
3181 lpfc_worker_wake_up(phba);
3187 * lpfc_mbox_timeout_handler: Worker thread function to handle mailbox timeout.
3188 * @phba: Pointer to HBA context object.
3190 * This function is called from worker thread when a mailbox command times out.
3191 * The caller is not required to hold any locks. This function will reset the
3192 * HBA and recover all the pending commands.
3195 lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
3197 LPFC_MBOXQ_t *pmbox = phba->sli.mbox_active;
3198 MAILBOX_t *mb = &pmbox->mb;
3199 struct lpfc_sli *psli = &phba->sli;
3200 struct lpfc_sli_ring *pring;
3202 if (!(phba->pport->work_port_events & WORKER_MBOX_TMO)) {
3206 /* Mbox cmd <mbxCommand> timeout */
3207 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3208 "0310 Mailbox command x%x timeout Data: x%x x%x x%p\n",
3210 phba->pport->port_state,
3212 phba->sli.mbox_active);
3214 /* Setting state unknown so lpfc_sli_abort_iocb_ring
3215 * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
3216 * it to fail all oustanding SCSI IO.
3218 spin_lock_irq(&phba->pport->work_port_lock);
3219 phba->pport->work_port_events &= ~WORKER_MBOX_TMO;
3220 spin_unlock_irq(&phba->pport->work_port_lock);
3221 spin_lock_irq(&phba->hbalock);
3222 phba->link_state = LPFC_LINK_UNKNOWN;
3223 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
3224 spin_unlock_irq(&phba->hbalock);
3226 pring = &psli->ring[psli->fcp_ring];
3227 lpfc_sli_abort_iocb_ring(phba, pring);
3229 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3230 "0345 Resetting board due to mailbox timeout\n");
3232 * lpfc_offline calls lpfc_sli_hba_down which will clean up
3233 * on oustanding mailbox commands.
3235 /* If resets are disabled then set error state and return. */
3236 if (!phba->cfg_enable_hba_reset) {
3237 phba->link_state = LPFC_HBA_ERROR;
3240 lpfc_offline_prep(phba);
3242 lpfc_sli_brdrestart(phba);
3244 lpfc_unblock_mgmt_io(phba);
3249 * lpfc_sli_issue_mbox: Issue a mailbox command to firmware.
3250 * @phba: Pointer to HBA context object.
3251 * @pmbox: Pointer to mailbox object.
3252 * @flag: Flag indicating how the mailbox need to be processed.
3254 * This function is called by discovery code and HBA management code
3255 * to submit a mailbox command to firmware. This function gets the
3256 * hbalock to protect the data structures.
3257 * The mailbox command can be submitted in polling mode, in which case
3258 * this function will wait in a polling loop for the completion of the
3260 * If the mailbox is submitted in no_wait mode (not polling) the
3261 * function will submit the command and returns immediately without waiting
3262 * for the mailbox completion. The no_wait is supported only when HBA
3263 * is in SLI2/SLI3 mode - interrupts are enabled.
3264 * The SLI interface allows only one mailbox pending at a time. If the
3265 * mailbox is issued in polling mode and there is already a mailbox
3266 * pending, then the function will return an error. If the mailbox is issued
3267 * in NO_WAIT mode and there is a mailbox pending already, the function
3268 * will return MBX_BUSY after queuing the mailbox into mailbox queue.
3269 * The sli layer owns the mailbox object until the completion of mailbox
3270 * command if this function return MBX_BUSY or MBX_SUCCESS. For all other
3271 * return codes the caller owns the mailbox command after the return of
3275 lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3278 struct lpfc_sli *psli = &phba->sli;
3279 uint32_t status, evtctr;
3282 unsigned long timeout;
3283 unsigned long drvr_flag = 0;
3284 uint32_t word0, ldata;
3285 void __iomem *to_slim;
3286 int processing_queue = 0;
3288 spin_lock_irqsave(&phba->hbalock, drvr_flag);
3290 /* processing mbox queue from intr_handler */
3291 processing_queue = 1;
3292 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3293 pmbox = lpfc_mbox_get(phba);
3295 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3300 if (pmbox->mbox_cmpl && pmbox->mbox_cmpl != lpfc_sli_def_mbox_cmpl &&
3301 pmbox->mbox_cmpl != lpfc_sli_wake_mbox_wait) {
3303 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3304 lpfc_printf_log(phba, KERN_ERR,
3305 LOG_MBOX | LOG_VPORT,
3306 "1806 Mbox x%x failed. No vport\n",
3307 pmbox->mb.mbxCommand);
3309 goto out_not_finished;
3313 /* If the PCI channel is in offline state, do not post mbox. */
3314 if (unlikely(pci_channel_offline(phba->pcidev))) {
3315 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3316 goto out_not_finished;
3322 status = MBX_SUCCESS;
3324 if (phba->link_state == LPFC_HBA_ERROR) {
3325 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3327 /* Mbox command <mbxCommand> cannot issue */
3328 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3329 goto out_not_finished;
3332 if (mb->mbxCommand != MBX_KILL_BOARD && flag & MBX_NOWAIT &&
3333 !(readl(phba->HCregaddr) & HC_MBINT_ENA)) {
3334 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3335 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3336 goto out_not_finished;
3339 if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {
3340 /* Polling for a mbox command when another one is already active
3341 * is not allowed in SLI. Also, the driver must have established
3342 * SLI2 mode to queue and process multiple mbox commands.
3345 if (flag & MBX_POLL) {
3346 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3348 /* Mbox command <mbxCommand> cannot issue */
3349 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3350 goto out_not_finished;
3353 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE)) {
3354 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3355 /* Mbox command <mbxCommand> cannot issue */
3356 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3357 goto out_not_finished;
3360 /* Another mailbox command is still being processed, queue this
3361 * command to be processed later.
3363 lpfc_mbox_put(phba, pmbox);
3365 /* Mbox cmd issue - BUSY */
3366 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
3367 "(%d):0308 Mbox cmd issue - BUSY Data: "
3368 "x%x x%x x%x x%x\n",
3369 pmbox->vport ? pmbox->vport->vpi : 0xffffff,
3370 mb->mbxCommand, phba->pport->port_state,
3371 psli->sli_flag, flag);
3373 psli->slistat.mbox_busy++;
3374 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3377 lpfc_debugfs_disc_trc(pmbox->vport,
3378 LPFC_DISC_TRC_MBOX_VPORT,
3379 "MBOX Bsy vport: cmd:x%x mb:x%x x%x",
3380 (uint32_t)mb->mbxCommand,
3381 mb->un.varWords[0], mb->un.varWords[1]);
3384 lpfc_debugfs_disc_trc(phba->pport,
3386 "MBOX Bsy: cmd:x%x mb:x%x x%x",
3387 (uint32_t)mb->mbxCommand,
3388 mb->un.varWords[0], mb->un.varWords[1]);
3394 psli->sli_flag |= LPFC_SLI_MBOX_ACTIVE;
3396 /* If we are not polling, we MUST be in SLI2 mode */
3397 if (flag != MBX_POLL) {
3398 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE) &&
3399 (mb->mbxCommand != MBX_KILL_BOARD)) {
3400 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3401 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3402 /* Mbox command <mbxCommand> cannot issue */
3403 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3404 goto out_not_finished;
3406 /* timeout active mbox command */
3407 mod_timer(&psli->mbox_tmo, (jiffies +
3408 (HZ * lpfc_mbox_tmo_val(phba, mb->mbxCommand))));
3411 /* Mailbox cmd <cmd> issue */
3412 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
3413 "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
3415 pmbox->vport ? pmbox->vport->vpi : 0,
3416 mb->mbxCommand, phba->pport->port_state,
3417 psli->sli_flag, flag);
3419 if (mb->mbxCommand != MBX_HEARTBEAT) {
3421 lpfc_debugfs_disc_trc(pmbox->vport,
3422 LPFC_DISC_TRC_MBOX_VPORT,
3423 "MBOX Send vport: cmd:x%x mb:x%x x%x",
3424 (uint32_t)mb->mbxCommand,
3425 mb->un.varWords[0], mb->un.varWords[1]);
3428 lpfc_debugfs_disc_trc(phba->pport,
3430 "MBOX Send: cmd:x%x mb:x%x x%x",
3431 (uint32_t)mb->mbxCommand,
3432 mb->un.varWords[0], mb->un.varWords[1]);
3436 psli->slistat.mbox_cmd++;
3437 evtctr = psli->slistat.mbox_event;
3439 /* next set own bit for the adapter and copy over command word */
3440 mb->mbxOwner = OWN_CHIP;
3442 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3443 /* First copy command data to host SLIM area */
3444 lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE);
3446 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3447 /* copy command data into host mbox for cmpl */
3448 lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE);
3451 /* First copy mbox command data to HBA SLIM, skip past first
3453 to_slim = phba->MBslimaddr + sizeof (uint32_t);
3454 lpfc_memcpy_to_slim(to_slim, &mb->un.varWords[0],
3455 MAILBOX_CMD_SIZE - sizeof (uint32_t));
3457 /* Next copy over first word, with mbxOwner set */
3458 ldata = *((uint32_t *)mb);
3459 to_slim = phba->MBslimaddr;
3460 writel(ldata, to_slim);
3461 readl(to_slim); /* flush */
3463 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3464 /* switch over to host mailbox */
3465 psli->sli_flag |= LPFC_SLI2_ACTIVE;
3473 /* Set up reference to mailbox command */
3474 psli->mbox_active = pmbox;
3475 /* Interrupt board to do it */
3476 writel(CA_MBATT, phba->CAregaddr);
3477 readl(phba->CAregaddr); /* flush */
3478 /* Don't wait for it to finish, just return */
3482 /* Set up null reference to mailbox command */
3483 psli->mbox_active = NULL;
3484 /* Interrupt board to do it */
3485 writel(CA_MBATT, phba->CAregaddr);
3486 readl(phba->CAregaddr); /* flush */
3488 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3489 /* First read mbox status word */
3490 word0 = *((uint32_t *)phba->mbox);
3491 word0 = le32_to_cpu(word0);
3493 /* First read mbox status word */
3494 word0 = readl(phba->MBslimaddr);
3497 /* Read the HBA Host Attention Register */
3498 ha_copy = readl(phba->HAregaddr);
3499 timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba,
3503 /* Wait for command to complete */
3504 while (((word0 & OWN_CHIP) == OWN_CHIP) ||
3505 (!(ha_copy & HA_MBATT) &&
3506 (phba->link_state > LPFC_WARM_START))) {
3507 if (time_after(jiffies, timeout)) {
3508 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3509 spin_unlock_irqrestore(&phba->hbalock,
3511 goto out_not_finished;
3514 /* Check if we took a mbox interrupt while we were
3516 if (((word0 & OWN_CHIP) != OWN_CHIP)
3517 && (evtctr != psli->slistat.mbox_event))
3521 spin_unlock_irqrestore(&phba->hbalock,
3524 spin_lock_irqsave(&phba->hbalock, drvr_flag);
3527 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3528 /* First copy command data */
3529 word0 = *((uint32_t *)phba->mbox);
3530 word0 = le32_to_cpu(word0);
3531 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3534 /* Check real SLIM for any errors */
3535 slimword0 = readl(phba->MBslimaddr);
3536 slimmb = (MAILBOX_t *) & slimword0;
3537 if (((slimword0 & OWN_CHIP) != OWN_CHIP)
3538 && slimmb->mbxStatus) {
3545 /* First copy command data */
3546 word0 = readl(phba->MBslimaddr);
3548 /* Read the HBA Host Attention Register */
3549 ha_copy = readl(phba->HAregaddr);
3552 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3553 /* copy results back to user */
3554 lpfc_sli_pcimem_bcopy(phba->mbox, mb, MAILBOX_CMD_SIZE);
3556 /* First copy command data */
3557 lpfc_memcpy_from_slim(mb, phba->MBslimaddr,
3559 if ((mb->mbxCommand == MBX_DUMP_MEMORY) &&
3561 lpfc_memcpy_from_slim((void *)pmbox->context2,
3562 phba->MBslimaddr + DMP_RSP_OFFSET,
3563 mb->un.varDmp.word_cnt);
3567 writel(HA_MBATT, phba->HAregaddr);
3568 readl(phba->HAregaddr); /* flush */
3570 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3571 status = mb->mbxStatus;
3574 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3578 if (processing_queue) {
3579 pmbox->mb.mbxStatus = MBX_NOT_FINISHED;
3580 lpfc_mbox_cmpl_put(phba, pmbox);
3582 return MBX_NOT_FINISHED;
3586 * __lpfc_sli_ringtx_put: Add an iocb to the txq.
3587 * @phba: Pointer to HBA context object.
3588 * @pring: Pointer to driver SLI ring object.
3589 * @piocb: Pointer to address of newly added command iocb.
3591 * This function is called with hbalock held to add a command
3592 * iocb to the txq when SLI layer cannot submit the command iocb
3596 __lpfc_sli_ringtx_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3597 struct lpfc_iocbq *piocb)
3599 /* Insert the caller's iocb in the txq tail for later processing. */
3600 list_add_tail(&piocb->list, &pring->txq);
3605 * lpfc_sli_next_iocb: Get the next iocb in the txq.
3606 * @phba: Pointer to HBA context object.
3607 * @pring: Pointer to driver SLI ring object.
3608 * @piocb: Pointer to address of newly added command iocb.
3610 * This function is called with hbalock held before a new
3611 * iocb is submitted to the firmware. This function checks
3612 * txq to flush the iocbs in txq to Firmware before
3613 * submitting new iocbs to the Firmware.
3614 * If there are iocbs in the txq which need to be submitted
3615 * to firmware, lpfc_sli_next_iocb returns the first element
3616 * of the txq after dequeuing it from txq.
3617 * If there is no iocb in the txq then the function will return
3618 * *piocb and *piocb is set to NULL. Caller needs to check
3619 * *piocb to find if there are more commands in the txq.
3621 static struct lpfc_iocbq *
3622 lpfc_sli_next_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3623 struct lpfc_iocbq **piocb)
3625 struct lpfc_iocbq * nextiocb;
3627 nextiocb = lpfc_sli_ringtx_get(phba, pring);
3637 * __lpfc_sli_issue_iocb: Lockless version of lpfc_sli_issue_iocb.
3638 * @phba: Pointer to HBA context object.
3639 * @pring: Pointer to driver SLI ring object.
3640 * @piocb: Pointer to command iocb.
3641 * @flag: Flag indicating if this command can be put into txq.
3643 * __lpfc_sli_issue_iocb is used by other functions in the driver
3644 * to issue an iocb command to the HBA. If the PCI slot is recovering
3645 * from error state or if HBA is resetting or if LPFC_STOP_IOCB_EVENT
3646 * flag is turned on, the function returns IOCB_ERROR.
3647 * When the link is down, this function allows only iocbs for
3649 * This function finds next available slot in the command ring and
3650 * posts the command to the available slot and writes the port
3651 * attention register to request HBA start processing new iocb.
3652 * If there is no slot available in the ring and
3653 * flag & SLI_IOCB_RET_IOCB is set, the new iocb is added to the
3654 * txq, otherwise the function returns IOCB_BUSY.
3656 * This function is called with hbalock held.
3657 * The function will return success after it successfully submit the
3658 * iocb to firmware or after adding to the txq.
3661 __lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3662 struct lpfc_iocbq *piocb, uint32_t flag)
3664 struct lpfc_iocbq *nextiocb;
3667 if (piocb->iocb_cmpl && (!piocb->vport) &&
3668 (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
3669 (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN)) {
3670 lpfc_printf_log(phba, KERN_ERR,
3671 LOG_SLI | LOG_VPORT,
3672 "1807 IOCB x%x failed. No vport\n",
3673 piocb->iocb.ulpCommand);
3679 /* If the PCI channel is in offline state, do not post iocbs. */
3680 if (unlikely(pci_channel_offline(phba->pcidev)))
3684 * We should never get an IOCB if we are in a < LINK_DOWN state
3686 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
3690 * Check to see if we are blocking IOCB processing because of a
3691 * outstanding event.
3693 if (unlikely(pring->flag & LPFC_STOP_IOCB_EVENT))
3696 if (unlikely(phba->link_state == LPFC_LINK_DOWN)) {
3698 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
3699 * can be issued if the link is not up.
3701 switch (piocb->iocb.ulpCommand) {
3702 case CMD_GEN_REQUEST64_CR:
3703 case CMD_GEN_REQUEST64_CX:
3704 if (!(phba->sli.sli_flag & LPFC_MENLO_MAINT) ||
3705 (piocb->iocb.un.genreq64.w5.hcsw.Rctl !=
3707 (piocb->iocb.un.genreq64.w5.hcsw.Type !=
3708 MENLO_TRANSPORT_TYPE))
3712 case CMD_QUE_RING_BUF_CN:
3713 case CMD_QUE_RING_BUF64_CN:
3715 * For IOCBs, like QUE_RING_BUF, that have no rsp ring
3716 * completion, iocb_cmpl MUST be 0.
3718 if (piocb->iocb_cmpl)
3719 piocb->iocb_cmpl = NULL;
3721 case CMD_CREATE_XRI_CR:
3722 case CMD_CLOSE_XRI_CN:
3723 case CMD_CLOSE_XRI_CX:
3730 * For FCP commands, we must be in a state where we can process link
3733 } else if (unlikely(pring->ringno == phba->sli.fcp_ring &&
3734 !(phba->sli.sli_flag & LPFC_PROCESS_LA))) {
3738 while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
3739 (nextiocb = lpfc_sli_next_iocb(phba, pring, &piocb)))
3740 lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
3743 lpfc_sli_update_ring(phba, pring);
3745 lpfc_sli_update_full_ring(phba, pring);
3748 return IOCB_SUCCESS;
3753 pring->stats.iocb_cmd_delay++;
3757 if (!(flag & SLI_IOCB_RET_IOCB)) {
3758 __lpfc_sli_ringtx_put(phba, pring, piocb);
3759 return IOCB_SUCCESS;
3767 * lpfc_sli_issue_iocb: Wrapper function for __lpfc_sli_issue_iocb.
3768 * @phba: Pointer to HBA context object.
3769 * @pring: Pointer to driver SLI ring object.
3770 * @piocb: Pointer to command iocb.
3771 * @flag: Flag indicating if this command can be put into txq.
3773 * lpfc_sli_issue_iocb is a wrapper around __lpfc_sli_issue_iocb
3774 * function. This function gets the hbalock and calls
3775 * __lpfc_sli_issue_iocb function and will return the error returned
3776 * by __lpfc_sli_issue_iocb function. This wrapper is used by
3777 * functions which do not hold hbalock.
3780 lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3781 struct lpfc_iocbq *piocb, uint32_t flag)
3783 unsigned long iflags;
3786 spin_lock_irqsave(&phba->hbalock, iflags);
3787 rc = __lpfc_sli_issue_iocb(phba, pring, piocb, flag);
3788 spin_unlock_irqrestore(&phba->hbalock, iflags);
3794 * lpfc_extra_ring_setup: Extra ring setup function.
3795 * @phba: Pointer to HBA context object.
3797 * This function is called while driver attaches with the
3798 * HBA to setup the extra ring. The extra ring is used
3799 * only when driver needs to support target mode functionality
3800 * or IP over FC functionalities.
3802 * This function is called with no lock held.
3805 lpfc_extra_ring_setup( struct lpfc_hba *phba)
3807 struct lpfc_sli *psli;
3808 struct lpfc_sli_ring *pring;
3812 /* Adjust cmd/rsp ring iocb entries more evenly */
3814 /* Take some away from the FCP ring */
3815 pring = &psli->ring[psli->fcp_ring];
3816 pring->numCiocb -= SLI2_IOCB_CMD_R1XTRA_ENTRIES;
3817 pring->numRiocb -= SLI2_IOCB_RSP_R1XTRA_ENTRIES;
3818 pring->numCiocb -= SLI2_IOCB_CMD_R3XTRA_ENTRIES;
3819 pring->numRiocb -= SLI2_IOCB_RSP_R3XTRA_ENTRIES;
3821 /* and give them to the extra ring */
3822 pring = &psli->ring[psli->extra_ring];
3824 pring->numCiocb += SLI2_IOCB_CMD_R1XTRA_ENTRIES;
3825 pring->numRiocb += SLI2_IOCB_RSP_R1XTRA_ENTRIES;
3826 pring->numCiocb += SLI2_IOCB_CMD_R3XTRA_ENTRIES;
3827 pring->numRiocb += SLI2_IOCB_RSP_R3XTRA_ENTRIES;
3829 /* Setup default profile for this ring */
3830 pring->iotag_max = 4096;
3831 pring->num_mask = 1;
3832 pring->prt[0].profile = 0; /* Mask 0 */
3833 pring->prt[0].rctl = phba->cfg_multi_ring_rctl;
3834 pring->prt[0].type = phba->cfg_multi_ring_type;
3835 pring->prt[0].lpfc_sli_rcv_unsol_event = NULL;
3840 * lpfc_sli_async_event_handler: ASYNC iocb handler function.
3841 * @phba: Pointer to HBA context object.
3842 * @pring: Pointer to driver SLI ring object.
3843 * @iocbq: Pointer to iocb object.
3845 * This function is called by the slow ring event handler
3846 * function when there is an ASYNC event iocb in the ring.
3847 * This function is called with no lock held.
3848 * Currently this function handles only temperature related
3849 * ASYNC events. The function decodes the temperature sensor
3850 * event message and posts events for the management applications.
3853 lpfc_sli_async_event_handler(struct lpfc_hba * phba,
3854 struct lpfc_sli_ring * pring, struct lpfc_iocbq * iocbq)
3859 struct temp_event temp_event_data;
3860 struct Scsi_Host *shost;
3862 icmd = &iocbq->iocb;
3863 evt_code = icmd->un.asyncstat.evt_code;
3864 temp = icmd->ulpContext;
3866 if ((evt_code != ASYNC_TEMP_WARN) &&
3867 (evt_code != ASYNC_TEMP_SAFE)) {
3868 lpfc_printf_log(phba,
3871 "0346 Ring %d handler: unexpected ASYNC_STATUS"
3874 icmd->un.asyncstat.evt_code);
3877 temp_event_data.data = (uint32_t)temp;
3878 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
3879 if (evt_code == ASYNC_TEMP_WARN) {
3880 temp_event_data.event_code = LPFC_THRESHOLD_TEMP;
3881 lpfc_printf_log(phba,
3884 "0347 Adapter is very hot, please take "
3885 "corrective action. temperature : %d Celsius\n",
3888 if (evt_code == ASYNC_TEMP_SAFE) {
3889 temp_event_data.event_code = LPFC_NORMAL_TEMP;
3890 lpfc_printf_log(phba,
3893 "0340 Adapter temperature is OK now. "
3894 "temperature : %d Celsius\n",
3898 /* Send temperature change event to applications */
3899 shost = lpfc_shost_from_vport(phba->pport);
3900 fc_host_post_vendor_event(shost, fc_get_event_number(),
3901 sizeof(temp_event_data), (char *) &temp_event_data,
3902 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
3908 * lpfc_sli_setup: SLI ring setup function.
3909 * @phba: Pointer to HBA context object.
3911 * lpfc_sli_setup sets up rings of the SLI interface with
3912 * number of iocbs per ring and iotags. This function is
3913 * called while driver attach to the HBA and before the
3914 * interrupts are enabled. So there is no need for locking.
3916 * This function always returns 0.
3919 lpfc_sli_setup(struct lpfc_hba *phba)
3921 int i, totiocbsize = 0;
3922 struct lpfc_sli *psli = &phba->sli;
3923 struct lpfc_sli_ring *pring;
3925 psli->num_rings = MAX_CONFIGURED_RINGS;
3927 psli->fcp_ring = LPFC_FCP_RING;
3928 psli->next_ring = LPFC_FCP_NEXT_RING;
3929 psli->extra_ring = LPFC_EXTRA_RING;
3931 psli->iocbq_lookup = NULL;
3932 psli->iocbq_lookup_len = 0;
3933 psli->last_iotag = 0;
3935 for (i = 0; i < psli->num_rings; i++) {
3936 pring = &psli->ring[i];
3938 case LPFC_FCP_RING: /* ring 0 - FCP */
3939 /* numCiocb and numRiocb are used in config_port */
3940 pring->numCiocb = SLI2_IOCB_CMD_R0_ENTRIES;
3941 pring->numRiocb = SLI2_IOCB_RSP_R0_ENTRIES;
3942 pring->numCiocb += SLI2_IOCB_CMD_R1XTRA_ENTRIES;
3943 pring->numRiocb += SLI2_IOCB_RSP_R1XTRA_ENTRIES;
3944 pring->numCiocb += SLI2_IOCB_CMD_R3XTRA_ENTRIES;
3945 pring->numRiocb += SLI2_IOCB_RSP_R3XTRA_ENTRIES;
3946 pring->sizeCiocb = (phba->sli_rev == 3) ?
3947 SLI3_IOCB_CMD_SIZE :
3949 pring->sizeRiocb = (phba->sli_rev == 3) ?
3950 SLI3_IOCB_RSP_SIZE :
3952 pring->iotag_ctr = 0;
3954 (phba->cfg_hba_queue_depth * 2);
3955 pring->fast_iotag = pring->iotag_max;
3956 pring->num_mask = 0;
3958 case LPFC_EXTRA_RING: /* ring 1 - EXTRA */
3959 /* numCiocb and numRiocb are used in config_port */
3960 pring->numCiocb = SLI2_IOCB_CMD_R1_ENTRIES;
3961 pring->numRiocb = SLI2_IOCB_RSP_R1_ENTRIES;
3962 pring->sizeCiocb = (phba->sli_rev == 3) ?
3963 SLI3_IOCB_CMD_SIZE :
3965 pring->sizeRiocb = (phba->sli_rev == 3) ?
3966 SLI3_IOCB_RSP_SIZE :
3968 pring->iotag_max = phba->cfg_hba_queue_depth;
3969 pring->num_mask = 0;
3971 case LPFC_ELS_RING: /* ring 2 - ELS / CT */
3972 /* numCiocb and numRiocb are used in config_port */
3973 pring->numCiocb = SLI2_IOCB_CMD_R2_ENTRIES;
3974 pring->numRiocb = SLI2_IOCB_RSP_R2_ENTRIES;
3975 pring->sizeCiocb = (phba->sli_rev == 3) ?
3976 SLI3_IOCB_CMD_SIZE :
3978 pring->sizeRiocb = (phba->sli_rev == 3) ?
3979 SLI3_IOCB_RSP_SIZE :
3981 pring->fast_iotag = 0;
3982 pring->iotag_ctr = 0;
3983 pring->iotag_max = 4096;
3984 pring->lpfc_sli_rcv_async_status =
3985 lpfc_sli_async_event_handler;
3986 pring->num_mask = 4;
3987 pring->prt[0].profile = 0; /* Mask 0 */
3988 pring->prt[0].rctl = FC_ELS_REQ;
3989 pring->prt[0].type = FC_ELS_DATA;
3990 pring->prt[0].lpfc_sli_rcv_unsol_event =
3991 lpfc_els_unsol_event;
3992 pring->prt[1].profile = 0; /* Mask 1 */
3993 pring->prt[1].rctl = FC_ELS_RSP;
3994 pring->prt[1].type = FC_ELS_DATA;
3995 pring->prt[1].lpfc_sli_rcv_unsol_event =
3996 lpfc_els_unsol_event;
3997 pring->prt[2].profile = 0; /* Mask 2 */
3998 /* NameServer Inquiry */
3999 pring->prt[2].rctl = FC_UNSOL_CTL;
4001 pring->prt[2].type = FC_COMMON_TRANSPORT_ULP;
4002 pring->prt[2].lpfc_sli_rcv_unsol_event =
4003 lpfc_ct_unsol_event;
4004 pring->prt[3].profile = 0; /* Mask 3 */
4005 /* NameServer response */
4006 pring->prt[3].rctl = FC_SOL_CTL;
4008 pring->prt[3].type = FC_COMMON_TRANSPORT_ULP;
4009 pring->prt[3].lpfc_sli_rcv_unsol_event =
4010 lpfc_ct_unsol_event;
4013 totiocbsize += (pring->numCiocb * pring->sizeCiocb) +
4014 (pring->numRiocb * pring->sizeRiocb);
4016 if (totiocbsize > MAX_SLIM_IOCB_SIZE) {
4017 /* Too many cmd / rsp ring entries in SLI2 SLIM */
4018 printk(KERN_ERR "%d:0462 Too many cmd / rsp ring entries in "
4019 "SLI2 SLIM Data: x%x x%lx\n",
4020 phba->brd_no, totiocbsize,
4021 (unsigned long) MAX_SLIM_IOCB_SIZE);
4023 if (phba->cfg_multi_ring_support == 2)
4024 lpfc_extra_ring_setup(phba);
4030 * lpfc_sli_queue_setup: Queue initialization function.
4031 * @phba: Pointer to HBA context object.
4033 * lpfc_sli_queue_setup sets up mailbox queues and iocb queues for each
4034 * ring. This function also initializes ring indices of each ring.
4035 * This function is called during the initialization of the SLI
4036 * interface of an HBA.
4037 * This function is called with no lock held and always returns
4041 lpfc_sli_queue_setup(struct lpfc_hba *phba)
4043 struct lpfc_sli *psli;
4044 struct lpfc_sli_ring *pring;
4048 spin_lock_irq(&phba->hbalock);
4049 INIT_LIST_HEAD(&psli->mboxq);
4050 INIT_LIST_HEAD(&psli->mboxq_cmpl);
4051 /* Initialize list headers for txq and txcmplq as double linked lists */
4052 for (i = 0; i < psli->num_rings; i++) {
4053 pring = &psli->ring[i];
4055 pring->next_cmdidx = 0;
4056 pring->local_getidx = 0;
4058 INIT_LIST_HEAD(&pring->txq);
4059 INIT_LIST_HEAD(&pring->txcmplq);
4060 INIT_LIST_HEAD(&pring->iocb_continueq);
4061 INIT_LIST_HEAD(&pring->iocb_continue_saveq);
4062 INIT_LIST_HEAD(&pring->postbufq);
4064 spin_unlock_irq(&phba->hbalock);
4069 * lpfc_sli_host_down: Vport cleanup function.
4070 * @vport: Pointer to virtual port object.
4072 * lpfc_sli_host_down is called to clean up the resources
4073 * associated with a vport before destroying virtual
4074 * port data structures.
4075 * This function does following operations:
4076 * - Free discovery resources associated with this virtual
4078 * - Free iocbs associated with this virtual port in
4080 * - Send abort for all iocb commands associated with this
4083 * This function is called with no lock held and always returns 1.
4086 lpfc_sli_host_down(struct lpfc_vport *vport)
4088 LIST_HEAD(completions);
4089 struct lpfc_hba *phba = vport->phba;
4090 struct lpfc_sli *psli = &phba->sli;
4091 struct lpfc_sli_ring *pring;
4092 struct lpfc_iocbq *iocb, *next_iocb;
4094 unsigned long flags = 0;
4095 uint16_t prev_pring_flag;
4097 lpfc_cleanup_discovery_resources(vport);
4099 spin_lock_irqsave(&phba->hbalock, flags);
4100 for (i = 0; i < psli->num_rings; i++) {
4101 pring = &psli->ring[i];
4102 prev_pring_flag = pring->flag;
4103 /* Only slow rings */
4104 if (pring->ringno == LPFC_ELS_RING) {
4105 pring->flag |= LPFC_DEFERRED_RING_EVENT;
4106 /* Set the lpfc data pending flag */
4107 set_bit(LPFC_DATA_READY, &phba->data_flags);
4110 * Error everything on the txq since these iocbs have not been
4111 * given to the FW yet.
4113 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
4114 if (iocb->vport != vport)
4116 list_move_tail(&iocb->list, &completions);
4120 /* Next issue ABTS for everything on the txcmplq */
4121 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq,
4123 if (iocb->vport != vport)
4125 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
4128 pring->flag = prev_pring_flag;
4131 spin_unlock_irqrestore(&phba->hbalock, flags);
4133 while (!list_empty(&completions)) {
4134 list_remove_head(&completions, iocb, struct lpfc_iocbq, list);
4136 if (!iocb->iocb_cmpl)
4137 lpfc_sli_release_iocbq(phba, iocb);
4139 iocb->iocb.ulpStatus = IOSTAT_LOCAL_REJECT;
4140 iocb->iocb.un.ulpWord[4] = IOERR_SLI_DOWN;
4141 (iocb->iocb_cmpl) (phba, iocb, iocb);
4148 * lpfc_sli_hba_down: Resource cleanup function for the HBA.
4149 * @phba: Pointer to HBA context object.
4151 * This function cleans up all iocb, buffers, mailbox commands
4152 * while shutting down the HBA. This function is called with no
4153 * lock held and always returns 1.
4154 * This function does the following to cleanup driver resources:
4155 * - Free discovery resources for each virtual port
4156 * - Cleanup any pending fabric iocbs
4157 * - Iterate through the iocb txq and free each entry
4159 * - Free up any buffer posted to the HBA
4160 * - Free mailbox commands in the mailbox queue.
4163 lpfc_sli_hba_down(struct lpfc_hba *phba)
4165 LIST_HEAD(completions);
4166 struct lpfc_sli *psli = &phba->sli;
4167 struct lpfc_sli_ring *pring;
4168 struct lpfc_dmabuf *buf_ptr;
4170 struct lpfc_iocbq *iocb;
4173 unsigned long flags = 0;
4175 lpfc_hba_down_prep(phba);
4177 lpfc_fabric_abort_hba(phba);
4179 spin_lock_irqsave(&phba->hbalock, flags);
4180 for (i = 0; i < psli->num_rings; i++) {
4181 pring = &psli->ring[i];
4182 /* Only slow rings */
4183 if (pring->ringno == LPFC_ELS_RING) {
4184 pring->flag |= LPFC_DEFERRED_RING_EVENT;
4185 /* Set the lpfc data pending flag */
4186 set_bit(LPFC_DATA_READY, &phba->data_flags);
4190 * Error everything on the txq since these iocbs have not been
4191 * given to the FW yet.
4193 list_splice_init(&pring->txq, &completions);
4197 spin_unlock_irqrestore(&phba->hbalock, flags);
4199 while (!list_empty(&completions)) {
4200 list_remove_head(&completions, iocb, struct lpfc_iocbq, list);
4203 if (!iocb->iocb_cmpl)
4204 lpfc_sli_release_iocbq(phba, iocb);
4206 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4207 cmd->un.ulpWord[4] = IOERR_SLI_DOWN;
4208 (iocb->iocb_cmpl) (phba, iocb, iocb);
4212 spin_lock_irqsave(&phba->hbalock, flags);
4213 list_splice_init(&phba->elsbuf, &completions);
4214 phba->elsbuf_cnt = 0;
4215 phba->elsbuf_prev_cnt = 0;
4216 spin_unlock_irqrestore(&phba->hbalock, flags);
4218 while (!list_empty(&completions)) {
4219 list_remove_head(&completions, buf_ptr,
4220 struct lpfc_dmabuf, list);
4221 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
4225 /* Return any active mbox cmds */
4226 del_timer_sync(&psli->mbox_tmo);
4227 spin_lock_irqsave(&phba->hbalock, flags);
4229 spin_lock(&phba->pport->work_port_lock);
4230 phba->pport->work_port_events &= ~WORKER_MBOX_TMO;
4231 spin_unlock(&phba->pport->work_port_lock);
4233 /* Return any pending or completed mbox cmds */
4234 list_splice_init(&phba->sli.mboxq, &completions);
4235 if (psli->mbox_active) {
4236 list_add_tail(&psli->mbox_active->list, &completions);
4237 psli->mbox_active = NULL;
4238 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
4240 list_splice_init(&phba->sli.mboxq_cmpl, &completions);
4241 spin_unlock_irqrestore(&phba->hbalock, flags);
4243 while (!list_empty(&completions)) {
4244 list_remove_head(&completions, pmb, LPFC_MBOXQ_t, list);
4245 pmb->mb.mbxStatus = MBX_NOT_FINISHED;
4247 pmb->mbox_cmpl(phba,pmb);
4253 * lpfc_sli_pcimem_bcopy: SLI memory copy function.
4254 * @srcp: Source memory pointer.
4255 * @destp: Destination memory pointer.
4256 * @cnt: Number of words required to be copied.
4258 * This function is used for copying data between driver memory
4259 * and the SLI memory. This function also changes the endianness
4260 * of each word if native endianness is different from SLI
4261 * endianness. This function can be called with or without
4265 lpfc_sli_pcimem_bcopy(void *srcp, void *destp, uint32_t cnt)
4267 uint32_t *src = srcp;
4268 uint32_t *dest = destp;
4272 for (i = 0; i < (int)cnt; i += sizeof (uint32_t)) {
4274 ldata = le32_to_cpu(ldata);
4283 * lpfc_sli_ringpostbuf_put: Function to add a buffer to postbufq.
4284 * @phba: Pointer to HBA context object.
4285 * @pring: Pointer to driver SLI ring object.
4286 * @mp: Pointer to driver buffer object.
4288 * This function is called with no lock held.
4289 * It always return zero after adding the buffer to the postbufq
4293 lpfc_sli_ringpostbuf_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4294 struct lpfc_dmabuf *mp)
4296 /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
4298 spin_lock_irq(&phba->hbalock);
4299 list_add_tail(&mp->list, &pring->postbufq);
4300 pring->postbufq_cnt++;
4301 spin_unlock_irq(&phba->hbalock);
4306 * lpfc_sli_get_buffer_tag: Tag allocation function for a buffer posted
4307 * using CMD_QUE_XRI64_CX iocb.
4308 * @phba: Pointer to HBA context object.
4310 * When HBQ is enabled, buffers are searched based on tags. This function
4311 * allocates a tag for buffer posted using CMD_QUE_XRI64_CX iocb. The
4312 * tag is bit wise or-ed with QUE_BUFTAG_BIT to make sure that the tag
4313 * does not conflict with tags of buffer posted for unsolicited events.
4314 * The function returns the allocated tag. The function is called with
4318 lpfc_sli_get_buffer_tag(struct lpfc_hba *phba)
4320 spin_lock_irq(&phba->hbalock);
4321 phba->buffer_tag_count++;
4323 * Always set the QUE_BUFTAG_BIT to distiguish between
4324 * a tag assigned by HBQ.
4326 phba->buffer_tag_count |= QUE_BUFTAG_BIT;
4327 spin_unlock_irq(&phba->hbalock);
4328 return phba->buffer_tag_count;
4332 * lpfc_sli_ring_taggedbuf_get: Search HBQ buffer associated with
4333 * posted using CMD_QUE_XRI64_CX iocb.
4334 * @phba: Pointer to HBA context object.
4335 * @pring: Pointer to driver SLI ring object.
4338 * Buffers posted using CMD_QUE_XRI64_CX iocb are in pring->postbufq
4339 * list. After HBA DMA data to these buffers, CMD_IOCB_RET_XRI64_CX
4340 * iocb is posted to the response ring with the tag of the buffer.
4341 * This function searches the pring->postbufq list using the tag
4342 * to find buffer associated with CMD_IOCB_RET_XRI64_CX
4343 * iocb. If the buffer is found then lpfc_dmabuf object of the
4344 * buffer is returned to the caller else NULL is returned.
4345 * This function is called with no lock held.
4347 struct lpfc_dmabuf *
4348 lpfc_sli_ring_taggedbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4351 struct lpfc_dmabuf *mp, *next_mp;
4352 struct list_head *slp = &pring->postbufq;
4354 /* Search postbufq, from the begining, looking for a match on tag */
4355 spin_lock_irq(&phba->hbalock);
4356 list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
4357 if (mp->buffer_tag == tag) {
4358 list_del_init(&mp->list);
4359 pring->postbufq_cnt--;
4360 spin_unlock_irq(&phba->hbalock);
4365 spin_unlock_irq(&phba->hbalock);
4366 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4367 "0402 Cannot find virtual addr for buffer tag on "
4368 "ring %d Data x%lx x%p x%p x%x\n",
4369 pring->ringno, (unsigned long) tag,
4370 slp->next, slp->prev, pring->postbufq_cnt);
4376 * lpfc_sli_ringpostbuf_get: SLI2 buffer search function for
4377 * unsolicited ct and els events.
4378 * @phba: Pointer to HBA context object.
4379 * @pring: Pointer to driver SLI ring object.
4380 * @phys: DMA address of the buffer.
4382 * This function searches the buffer list using the dma_address
4383 * of unsolicited event to find the driver's lpfc_dmabuf object
4384 * corresponding to the dma_address. The function returns the
4385 * lpfc_dmabuf object if a buffer is found else it returns NULL.
4386 * This function is called by the ct and els unsolicited event
4387 * handlers to get the buffer associated with the unsolicited
4390 * This function is called with no lock held.
4392 struct lpfc_dmabuf *
4393 lpfc_sli_ringpostbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4396 struct lpfc_dmabuf *mp, *next_mp;
4397 struct list_head *slp = &pring->postbufq;
4399 /* Search postbufq, from the begining, looking for a match on phys */
4400 spin_lock_irq(&phba->hbalock);
4401 list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
4402 if (mp->phys == phys) {
4403 list_del_init(&mp->list);
4404 pring->postbufq_cnt--;
4405 spin_unlock_irq(&phba->hbalock);
4410 spin_unlock_irq(&phba->hbalock);
4411 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4412 "0410 Cannot find virtual addr for mapped buf on "
4413 "ring %d Data x%llx x%p x%p x%x\n",
4414 pring->ringno, (unsigned long long)phys,
4415 slp->next, slp->prev, pring->postbufq_cnt);
4420 * lpfc_sli_abort_els_cmpl: Completion handler for the els abort iocbs.
4421 * @phba: Pointer to HBA context object.
4422 * @cmdiocb: Pointer to driver command iocb object.
4423 * @rspiocb: Pointer to driver response iocb object.
4425 * This function is the completion handler for the abort iocbs for
4426 * ELS commands. This function is called from the ELS ring event
4427 * handler with no lock held. This function frees memory resources
4428 * associated with the abort iocb.
4431 lpfc_sli_abort_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4432 struct lpfc_iocbq *rspiocb)
4434 IOCB_t *irsp = &rspiocb->iocb;
4435 uint16_t abort_iotag, abort_context;
4436 struct lpfc_iocbq *abort_iocb;
4437 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4441 if (irsp->ulpStatus) {
4442 abort_context = cmdiocb->iocb.un.acxri.abortContextTag;
4443 abort_iotag = cmdiocb->iocb.un.acxri.abortIoTag;
4445 spin_lock_irq(&phba->hbalock);
4446 if (abort_iotag != 0 && abort_iotag <= phba->sli.last_iotag)
4447 abort_iocb = phba->sli.iocbq_lookup[abort_iotag];
4449 lpfc_printf_log(phba, KERN_INFO, LOG_ELS | LOG_SLI,
4450 "0327 Cannot abort els iocb %p "
4451 "with tag %x context %x, abort status %x, "
4453 abort_iocb, abort_iotag, abort_context,
4454 irsp->ulpStatus, irsp->un.ulpWord[4]);
4457 * If the iocb is not found in Firmware queue the iocb
4458 * might have completed already. Do not free it again.
4460 if (irsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
4461 spin_unlock_irq(&phba->hbalock);
4462 lpfc_sli_release_iocbq(phba, cmdiocb);
4466 * make sure we have the right iocbq before taking it
4467 * off the txcmplq and try to call completion routine.
4470 abort_iocb->iocb.ulpContext != abort_context ||
4471 (abort_iocb->iocb_flag & LPFC_DRIVER_ABORTED) == 0)
4472 spin_unlock_irq(&phba->hbalock);
4474 list_del_init(&abort_iocb->list);
4475 pring->txcmplq_cnt--;
4476 spin_unlock_irq(&phba->hbalock);
4478 /* Firmware could still be in progress of DMAing
4479 * payload, so don't free data buffer till after
4482 abort_iocb->iocb_flag |= LPFC_DELAY_MEM_FREE;
4484 abort_iocb->iocb_flag &= ~LPFC_DRIVER_ABORTED;
4485 abort_iocb->iocb.ulpStatus = IOSTAT_LOCAL_REJECT;
4486 abort_iocb->iocb.un.ulpWord[4] = IOERR_SLI_ABORTED;
4487 (abort_iocb->iocb_cmpl)(phba, abort_iocb, abort_iocb);
4491 lpfc_sli_release_iocbq(phba, cmdiocb);
4496 * lpfc_ignore_els_cmpl: Completion handler for aborted ELS command.
4497 * @phba: Pointer to HBA context object.
4498 * @cmdiocb: Pointer to driver command iocb object.
4499 * @rspiocb: Pointer to driver response iocb object.
4501 * The function is called from SLI ring event handler with no
4502 * lock held. This function is the completion handler for ELS commands
4503 * which are aborted. The function frees memory resources used for
4504 * the aborted ELS commands.
4507 lpfc_ignore_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4508 struct lpfc_iocbq *rspiocb)
4510 IOCB_t *irsp = &rspiocb->iocb;
4512 /* ELS cmd tag <ulpIoTag> completes */
4513 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
4514 "0139 Ignoring ELS cmd tag x%x completion Data: "
4516 irsp->ulpIoTag, irsp->ulpStatus,
4517 irsp->un.ulpWord[4], irsp->ulpTimeout);
4518 if (cmdiocb->iocb.ulpCommand == CMD_GEN_REQUEST64_CR)
4519 lpfc_ct_free_iocb(phba, cmdiocb);
4521 lpfc_els_free_iocb(phba, cmdiocb);
4526 * lpfc_sli_issue_abort_iotag: Abort function for a command iocb.
4527 * @phba: Pointer to HBA context object.
4528 * @pring: Pointer to driver SLI ring object.
4529 * @cmdiocb: Pointer to driver command iocb object.
4531 * This function issues an abort iocb for the provided command
4532 * iocb. This function is called with hbalock held.
4533 * The function returns 0 when it fails due to memory allocation
4534 * failure or when the command iocb is an abort request.
4537 lpfc_sli_issue_abort_iotag(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4538 struct lpfc_iocbq *cmdiocb)
4540 struct lpfc_vport *vport = cmdiocb->vport;
4541 struct lpfc_iocbq *abtsiocbp;
4542 IOCB_t *icmd = NULL;
4543 IOCB_t *iabt = NULL;
4544 int retval = IOCB_ERROR;
4547 * There are certain command types we don't want to abort. And we
4548 * don't want to abort commands that are already in the process of
4551 icmd = &cmdiocb->iocb;
4552 if (icmd->ulpCommand == CMD_ABORT_XRI_CN ||
4553 icmd->ulpCommand == CMD_CLOSE_XRI_CN ||
4554 (cmdiocb->iocb_flag & LPFC_DRIVER_ABORTED) != 0)
4557 /* If we're unloading, don't abort iocb on the ELS ring, but change the
4558 * callback so that nothing happens when it finishes.
4560 if ((vport->load_flag & FC_UNLOADING) &&
4561 (pring->ringno == LPFC_ELS_RING)) {
4562 if (cmdiocb->iocb_flag & LPFC_IO_FABRIC)
4563 cmdiocb->fabric_iocb_cmpl = lpfc_ignore_els_cmpl;
4565 cmdiocb->iocb_cmpl = lpfc_ignore_els_cmpl;
4566 goto abort_iotag_exit;
4569 /* issue ABTS for this IOCB based on iotag */
4570 abtsiocbp = __lpfc_sli_get_iocbq(phba);
4571 if (abtsiocbp == NULL)
4574 /* This signals the response to set the correct status
4575 * before calling the completion handler.
4577 cmdiocb->iocb_flag |= LPFC_DRIVER_ABORTED;
4579 iabt = &abtsiocbp->iocb;
4580 iabt->un.acxri.abortType = ABORT_TYPE_ABTS;
4581 iabt->un.acxri.abortContextTag = icmd->ulpContext;
4582 iabt->un.acxri.abortIoTag = icmd->ulpIoTag;
4584 iabt->ulpClass = icmd->ulpClass;
4586 if (phba->link_state >= LPFC_LINK_UP)
4587 iabt->ulpCommand = CMD_ABORT_XRI_CN;
4589 iabt->ulpCommand = CMD_CLOSE_XRI_CN;
4591 abtsiocbp->iocb_cmpl = lpfc_sli_abort_els_cmpl;
4593 lpfc_printf_vlog(vport, KERN_INFO, LOG_SLI,
4594 "0339 Abort xri x%x, original iotag x%x, "
4595 "abort cmd iotag x%x\n",
4596 iabt->un.acxri.abortContextTag,
4597 iabt->un.acxri.abortIoTag, abtsiocbp->iotag);
4598 retval = __lpfc_sli_issue_iocb(phba, pring, abtsiocbp, 0);
4601 __lpfc_sli_release_iocbq(phba, abtsiocbp);
4604 * Caller to this routine should check for IOCB_ERROR
4605 * and handle it properly. This routine no longer removes
4606 * iocb off txcmplq and call compl in case of IOCB_ERROR.
4612 * lpfc_sli_validate_fcp_iocb: Filtering function, used to find commands
4613 * associated with a vport/SCSI target/lun.
4614 * @iocbq: Pointer to driver iocb object.
4615 * @vport: Pointer to driver virtual port object.
4616 * @tgt_id: SCSI ID of the target.
4617 * @lun_id: LUN ID of the scsi device.
4618 * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST
4620 * This function acts as iocb filter for functions which abort or count
4621 * all FCP iocbs pending on a lun/SCSI target/SCSI host. It will return
4622 * 0 if the filtering criteria is met for the given iocb and will return
4623 * 1 if the filtering criteria is not met.
4624 * If ctx_cmd == LPFC_CTX_LUN, the function returns 0 only if the
4625 * given iocb is for the SCSI device specified by vport, tgt_id and
4627 * If ctx_cmd == LPFC_CTX_TGT, the function returns 0 only if the
4628 * given iocb is for the SCSI target specified by vport and tgt_id
4630 * If ctx_cmd == LPFC_CTX_HOST, the function returns 0 only if the
4631 * given iocb is for the SCSI host associated with the given vport.
4632 * This function is called with no locks held.
4635 lpfc_sli_validate_fcp_iocb(struct lpfc_iocbq *iocbq, struct lpfc_vport *vport,
4636 uint16_t tgt_id, uint64_t lun_id,
4637 lpfc_ctx_cmd ctx_cmd)
4639 struct lpfc_scsi_buf *lpfc_cmd;
4642 if (!(iocbq->iocb_flag & LPFC_IO_FCP))
4645 if (iocbq->vport != vport)
4648 lpfc_cmd = container_of(iocbq, struct lpfc_scsi_buf, cur_iocbq);
4650 if (lpfc_cmd->pCmd == NULL)
4655 if ((lpfc_cmd->rdata->pnode) &&
4656 (lpfc_cmd->rdata->pnode->nlp_sid == tgt_id) &&
4657 (scsilun_to_int(&lpfc_cmd->fcp_cmnd->fcp_lun) == lun_id))
4661 if ((lpfc_cmd->rdata->pnode) &&
4662 (lpfc_cmd->rdata->pnode->nlp_sid == tgt_id))
4669 printk(KERN_ERR "%s: Unknown context cmd type, value %d\n",
4678 * lpfc_sli_sum_iocb: Function to count the number of FCP iocbs pending.
4679 * @vport: Pointer to virtual port.
4680 * @tgt_id: SCSI ID of the target.
4681 * @lun_id: LUN ID of the scsi device.
4682 * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
4684 * This function returns number of FCP commands pending for the vport.
4685 * When ctx_cmd == LPFC_CTX_LUN, the function returns number of FCP
4686 * commands pending on the vport associated with SCSI device specified
4687 * by tgt_id and lun_id parameters.
4688 * When ctx_cmd == LPFC_CTX_TGT, the function returns number of FCP
4689 * commands pending on the vport associated with SCSI target specified
4690 * by tgt_id parameter.
4691 * When ctx_cmd == LPFC_CTX_HOST, the function returns number of FCP
4692 * commands pending on the vport.
4693 * This function returns the number of iocbs which satisfy the filter.
4694 * This function is called without any lock held.
4697 lpfc_sli_sum_iocb(struct lpfc_vport *vport, uint16_t tgt_id, uint64_t lun_id,
4698 lpfc_ctx_cmd ctx_cmd)
4700 struct lpfc_hba *phba = vport->phba;
4701 struct lpfc_iocbq *iocbq;
4704 for (i = 1, sum = 0; i <= phba->sli.last_iotag; i++) {
4705 iocbq = phba->sli.iocbq_lookup[i];
4707 if (lpfc_sli_validate_fcp_iocb (iocbq, vport, tgt_id, lun_id,
4716 * lpfc_sli_abort_fcp_cmpl: Completion handler function for an aborted
4718 * @phba: Pointer to HBA context object
4719 * @cmdiocb: Pointer to command iocb object.
4720 * @rspiocb: Pointer to response iocb object.
4722 * This function is called when an aborted FCP iocb completes. This
4723 * function is called by the ring event handler with no lock held.
4724 * This function frees the iocb.
4727 lpfc_sli_abort_fcp_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4728 struct lpfc_iocbq *rspiocb)
4730 lpfc_sli_release_iocbq(phba, cmdiocb);
4735 * lpfc_sli_abort_iocb: This function issue abort for all SCSI commands
4736 * pending on a SCSI host(vport)/target/lun.
4737 * @vport: Pointer to virtual port.
4738 * @pring: Pointer to driver SLI ring object.
4739 * @tgt_id: SCSI ID of the target.
4740 * @lun_id: LUN ID of the scsi device.
4741 * @abort_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
4743 * This function sends an abort command for every SCSI command
4744 * associated with the given virtual port pending on the ring
4745 * filtered by lpfc_sli_validate_fcp_iocb function.
4746 * When abort_cmd == LPFC_CTX_LUN, the function sends abort only to the
4747 * FCP iocbs associated with lun specified by tgt_id and lun_id
4749 * When abort_cmd == LPFC_CTX_TGT, the function sends abort only to the
4750 * FCP iocbs associated with SCSI target specified by tgt_id parameter.
4751 * When abort_cmd == LPFC_CTX_HOST, the function sends abort to all
4752 * FCP iocbs associated with virtual port.
4753 * This function returns number of iocbs it failed to abort.
4754 * This function is called with no locks held.
4757 lpfc_sli_abort_iocb(struct lpfc_vport *vport, struct lpfc_sli_ring *pring,
4758 uint16_t tgt_id, uint64_t lun_id, lpfc_ctx_cmd abort_cmd)
4760 struct lpfc_hba *phba = vport->phba;
4761 struct lpfc_iocbq *iocbq;
4762 struct lpfc_iocbq *abtsiocb;
4764 int errcnt = 0, ret_val = 0;
4767 for (i = 1; i <= phba->sli.last_iotag; i++) {
4768 iocbq = phba->sli.iocbq_lookup[i];
4770 if (lpfc_sli_validate_fcp_iocb(iocbq, vport, tgt_id, lun_id,
4774 /* issue ABTS for this IOCB based on iotag */
4775 abtsiocb = lpfc_sli_get_iocbq(phba);
4776 if (abtsiocb == NULL) {
4782 abtsiocb->iocb.un.acxri.abortType = ABORT_TYPE_ABTS;
4783 abtsiocb->iocb.un.acxri.abortContextTag = cmd->ulpContext;
4784 abtsiocb->iocb.un.acxri.abortIoTag = cmd->ulpIoTag;
4785 abtsiocb->iocb.ulpLe = 1;
4786 abtsiocb->iocb.ulpClass = cmd->ulpClass;
4787 abtsiocb->vport = phba->pport;
4789 if (lpfc_is_link_up(phba))
4790 abtsiocb->iocb.ulpCommand = CMD_ABORT_XRI_CN;
4792 abtsiocb->iocb.ulpCommand = CMD_CLOSE_XRI_CN;
4794 /* Setup callback routine and issue the command. */
4795 abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
4796 ret_val = lpfc_sli_issue_iocb(phba, pring, abtsiocb, 0);
4797 if (ret_val == IOCB_ERROR) {
4798 lpfc_sli_release_iocbq(phba, abtsiocb);
4808 * lpfc_sli_wake_iocb_wait: iocb completion handler for iocb issued using
4809 * lpfc_sli_issue_iocb_wait.
4810 * @phba: Pointer to HBA context object.
4811 * @cmdiocbq: Pointer to command iocb.
4812 * @rspiocbq: Pointer to response iocb.
4814 * This function is the completion handler for iocbs issued using
4815 * lpfc_sli_issue_iocb_wait function. This function is called by the
4816 * ring event handler function without any lock held. This function
4817 * can be called from both worker thread context and interrupt
4818 * context. This function also can be called from other thread which
4819 * cleans up the SLI layer objects.
4820 * This function copy the contents of the response iocb to the
4821 * response iocb memory object provided by the caller of
4822 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
4823 * sleeps for the iocb completion.
4826 lpfc_sli_wake_iocb_wait(struct lpfc_hba *phba,
4827 struct lpfc_iocbq *cmdiocbq,
4828 struct lpfc_iocbq *rspiocbq)
4830 wait_queue_head_t *pdone_q;
4831 unsigned long iflags;
4833 spin_lock_irqsave(&phba->hbalock, iflags);
4834 cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
4835 if (cmdiocbq->context2 && rspiocbq)
4836 memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
4837 &rspiocbq->iocb, sizeof(IOCB_t));
4839 pdone_q = cmdiocbq->context_un.wait_queue;
4842 spin_unlock_irqrestore(&phba->hbalock, iflags);
4847 * lpfc_sli_issue_iocb_wait: Synchronous function to issue iocb commands.
4848 * @phba: Pointer to HBA context object..
4849 * @pring: Pointer to sli ring.
4850 * @piocb: Pointer to command iocb.
4851 * @prspiocbq: Pointer to response iocb.
4852 * @timeout: Timeout in number of seconds.
4854 * This function issues the iocb to firmware and waits for the
4855 * iocb to complete. If the iocb command is not
4856 * completed within timeout seconds, it returns IOCB_TIMEDOUT.
4857 * Caller should not free the iocb resources if this function
4858 * returns IOCB_TIMEDOUT.
4859 * The function waits for the iocb completion using an
4860 * non-interruptible wait.
4861 * This function will sleep while waiting for iocb completion.
4862 * So, this function should not be called from any context which
4863 * does not allow sleeping. Due to the same reason, this function
4864 * cannot be called with interrupt disabled.
4865 * This function assumes that the iocb completions occur while
4866 * this function sleep. So, this function cannot be called from
4867 * the thread which process iocb completion for this ring.
4868 * This function clears the iocb_flag of the iocb object before
4869 * issuing the iocb and the iocb completion handler sets this
4870 * flag and wakes this thread when the iocb completes.
4871 * The contents of the response iocb will be copied to prspiocbq
4872 * by the completion handler when the command completes.
4873 * This function returns IOCB_SUCCESS when success.
4874 * This function is called with no lock held.
4877 lpfc_sli_issue_iocb_wait(struct lpfc_hba *phba,
4878 struct lpfc_sli_ring *pring,
4879 struct lpfc_iocbq *piocb,
4880 struct lpfc_iocbq *prspiocbq,
4883 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q);
4884 long timeleft, timeout_req = 0;
4885 int retval = IOCB_SUCCESS;
4889 * If the caller has provided a response iocbq buffer, then context2
4890 * is NULL or its an error.
4893 if (piocb->context2)
4895 piocb->context2 = prspiocbq;
4898 piocb->iocb_cmpl = lpfc_sli_wake_iocb_wait;
4899 piocb->context_un.wait_queue = &done_q;
4900 piocb->iocb_flag &= ~LPFC_IO_WAKE;
4902 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
4903 creg_val = readl(phba->HCregaddr);
4904 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
4905 writel(creg_val, phba->HCregaddr);
4906 readl(phba->HCregaddr); /* flush */
4909 retval = lpfc_sli_issue_iocb(phba, pring, piocb, 0);
4910 if (retval == IOCB_SUCCESS) {
4911 timeout_req = timeout * HZ;
4912 timeleft = wait_event_timeout(done_q,
4913 piocb->iocb_flag & LPFC_IO_WAKE,
4916 if (piocb->iocb_flag & LPFC_IO_WAKE) {
4917 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4918 "0331 IOCB wake signaled\n");
4919 } else if (timeleft == 0) {
4920 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4921 "0338 IOCB wait timeout error - no "
4922 "wake response Data x%x\n", timeout);
4923 retval = IOCB_TIMEDOUT;
4925 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4926 "0330 IOCB wake NOT set, "
4928 timeout, (timeleft / jiffies));
4929 retval = IOCB_TIMEDOUT;
4932 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4933 "0332 IOCB wait issue failed, Data x%x\n",
4935 retval = IOCB_ERROR;
4938 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
4939 creg_val = readl(phba->HCregaddr);
4940 creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
4941 writel(creg_val, phba->HCregaddr);
4942 readl(phba->HCregaddr); /* flush */
4946 piocb->context2 = NULL;
4948 piocb->context_un.wait_queue = NULL;
4949 piocb->iocb_cmpl = NULL;
4954 * lpfc_sli_issue_mbox_wait: Synchronous function to issue mailbox.
4955 * @phba: Pointer to HBA context object.
4956 * @pmboxq: Pointer to driver mailbox object.
4957 * @timeout: Timeout in number of seconds.
4959 * This function issues the mailbox to firmware and waits for the
4960 * mailbox command to complete. If the mailbox command is not
4961 * completed within timeout seconds, it returns MBX_TIMEOUT.
4962 * The function waits for the mailbox completion using an
4963 * interruptible wait. If the thread is woken up due to a
4964 * signal, MBX_TIMEOUT error is returned to the caller. Caller
4965 * should not free the mailbox resources, if this function returns
4967 * This function will sleep while waiting for mailbox completion.
4968 * So, this function should not be called from any context which
4969 * does not allow sleeping. Due to the same reason, this function
4970 * cannot be called with interrupt disabled.
4971 * This function assumes that the mailbox completion occurs while
4972 * this function sleep. So, this function cannot be called from
4973 * the worker thread which processes mailbox completion.
4974 * This function is called in the context of HBA management
4976 * This function returns MBX_SUCCESS when successful.
4977 * This function is called with no lock held.
4980 lpfc_sli_issue_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq,
4983 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q);
4987 /* The caller must leave context1 empty. */
4988 if (pmboxq->context1)
4989 return MBX_NOT_FINISHED;
4991 pmboxq->mbox_flag &= ~LPFC_MBX_WAKE;
4992 /* setup wake call as IOCB callback */
4993 pmboxq->mbox_cmpl = lpfc_sli_wake_mbox_wait;
4994 /* setup context field to pass wait_queue pointer to wake function */
4995 pmboxq->context1 = &done_q;
4997 /* now issue the command */
4998 retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
5000 if (retval == MBX_BUSY || retval == MBX_SUCCESS) {
5001 wait_event_interruptible_timeout(done_q,
5002 pmboxq->mbox_flag & LPFC_MBX_WAKE,
5005 spin_lock_irqsave(&phba->hbalock, flag);
5006 pmboxq->context1 = NULL;
5008 * if LPFC_MBX_WAKE flag is set the mailbox is completed
5009 * else do not free the resources.
5011 if (pmboxq->mbox_flag & LPFC_MBX_WAKE)
5012 retval = MBX_SUCCESS;
5014 retval = MBX_TIMEOUT;
5015 pmboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
5017 spin_unlock_irqrestore(&phba->hbalock, flag);
5024 * lpfc_sli_flush_mbox_queue: mailbox queue cleanup function.
5025 * @phba: Pointer to HBA context.
5027 * This function is called to cleanup any pending mailbox
5028 * objects in the driver queue before bringing the HBA offline.
5029 * This function is called while resetting the HBA.
5030 * The function is called without any lock held. The function
5031 * takes hbalock to update SLI data structure.
5032 * This function returns 1 when there is an active mailbox
5033 * command pending else returns 0.
5036 lpfc_sli_flush_mbox_queue(struct lpfc_hba * phba)
5038 struct lpfc_vport *vport = phba->pport;
5042 while (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE && !vport->stopped) {
5043 if (i++ > LPFC_MBOX_TMO * 1000)
5047 * Call lpfc_sli_handle_mb_event only if a mailbox cmd
5048 * did finish. This way we won't get the misleading
5049 * "Stray Mailbox Interrupt" message.
5051 spin_lock_irq(&phba->hbalock);
5052 ha_copy = phba->work_ha;
5053 phba->work_ha &= ~HA_MBATT;
5054 spin_unlock_irq(&phba->hbalock);
5056 if (ha_copy & HA_MBATT)
5057 if (lpfc_sli_handle_mb_event(phba) == 0)
5063 return (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) ? 1 : 0;
5067 * lpfc_intr_handler: The interrupt handler of lpfc driver.
5068 * @irq: Interrupt number.
5069 * @dev_id: The device context pointer.
5071 * This function is called from the PCI layer when there is
5072 * an event in the HBA which requires driver attention. When
5073 * the PCI slot is in error recovery or the HBA is undergoing
5074 * initialization the interrupt handler will not process the
5076 * The error attention, link attention and els ring attention
5077 * events are handled by the worker thread. The interrupt
5078 * handler signals the worker thread and returns for these
5080 * The SCSI ring event and mailbox events are handled in the
5081 * interrupt context.
5082 * This function is called without any lock held. It gets the
5083 * hbalock to access and update SLI data structures.
5084 * This function returns IRQ_HANDLED when interrupt is handled
5085 * else it returns IRQ_NONE.
5088 lpfc_intr_handler(int irq, void *dev_id)
5090 struct lpfc_hba *phba;
5092 uint32_t work_ha_copy;
5093 unsigned long status;
5096 MAILBOX_t *mbox, *pmbox;
5097 struct lpfc_vport *vport;
5098 struct lpfc_nodelist *ndlp;
5099 struct lpfc_dmabuf *mp;
5104 * Get the driver's phba structure from the dev_id and
5105 * assume the HBA is not interrupting.
5107 phba = (struct lpfc_hba *) dev_id;
5109 if (unlikely(!phba))
5112 /* If the pci channel is offline, ignore all the interrupts. */
5113 if (unlikely(pci_channel_offline(phba->pcidev)))
5116 phba->sli.slistat.sli_intr++;
5119 * Call the HBA to see if it is interrupting. If not, don't claim
5123 /* Ignore all interrupts during initialization. */
5124 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5128 * Read host attention register to determine interrupt source
5129 * Clear Attention Sources, except Error Attention (to
5130 * preserve status) and Link Attention
5132 spin_lock(&phba->hbalock);
5133 if (phba->sli3_options & LPFC_SLI3_INB_ENABLED &&
5134 (phba->inb_last_counter != *phba->inb_counter)) {
5135 phba->inb_last_counter = *phba->inb_counter;
5136 ha_copy = le32_to_cpu(*phba->inb_ha_copy);
5138 ha_copy = readl(phba->HAregaddr);
5139 if (unlikely(!ha_copy)) {
5140 spin_unlock(&phba->hbalock);
5143 /* If somebody is waiting to handle an eratt don't process it
5144 * here. The brdkill function will do this.
5146 if (phba->link_flag & LS_IGNORE_ERATT)
5147 ha_copy &= ~HA_ERATT;
5148 writel((ha_copy & ~(HA_LATT | HA_ERATT)), phba->HAregaddr);
5149 readl(phba->HAregaddr); /* flush */
5150 spin_unlock(&phba->hbalock);
5152 work_ha_copy = ha_copy & phba->work_ha_mask;
5154 if (unlikely(work_ha_copy)) {
5155 if (work_ha_copy & HA_LATT) {
5156 if (phba->sli.sli_flag & LPFC_PROCESS_LA) {
5158 * Turn off Link Attention interrupts
5159 * until CLEAR_LA done
5161 spin_lock(&phba->hbalock);
5162 phba->sli.sli_flag &= ~LPFC_PROCESS_LA;
5163 control = readl(phba->HCregaddr);
5164 control &= ~HC_LAINT_ENA;
5165 writel(control, phba->HCregaddr);
5166 readl(phba->HCregaddr); /* flush */
5167 spin_unlock(&phba->hbalock);
5170 work_ha_copy &= ~HA_LATT;
5173 if (work_ha_copy & ~(HA_ERATT|HA_MBATT|HA_LATT)) {
5175 * Turn off Slow Rings interrupts, LPFC_ELS_RING is
5176 * the only slow ring.
5178 status = (work_ha_copy &
5179 (HA_RXMASK << (4*LPFC_ELS_RING)));
5180 status >>= (4*LPFC_ELS_RING);
5181 if (status & HA_RXMASK) {
5182 spin_lock(&phba->hbalock);
5183 control = readl(phba->HCregaddr);
5185 lpfc_debugfs_slow_ring_trc(phba,
5186 "ISR slow ring: ctl:x%x stat:x%x isrcnt:x%x",
5188 (uint32_t)phba->sli.slistat.sli_intr);
5190 if (control & (HC_R0INT_ENA << LPFC_ELS_RING)) {
5191 lpfc_debugfs_slow_ring_trc(phba,
5193 "pwork:x%x hawork:x%x wait:x%x",
5194 phba->work_ha, work_ha_copy,
5195 (uint32_t)((unsigned long)
5196 &phba->work_waitq));
5199 ~(HC_R0INT_ENA << LPFC_ELS_RING);
5200 writel(control, phba->HCregaddr);
5201 readl(phba->HCregaddr); /* flush */
5204 lpfc_debugfs_slow_ring_trc(phba,
5205 "ISR slow ring: pwork:"
5206 "x%x hawork:x%x wait:x%x",
5207 phba->work_ha, work_ha_copy,
5208 (uint32_t)((unsigned long)
5209 &phba->work_waitq));
5211 spin_unlock(&phba->hbalock);
5215 if (work_ha_copy & HA_ERATT) {
5217 * There was a link/board error. Read the
5218 * status register to retrieve the error event
5221 phba->sli.slistat.err_attn_event++;
5222 /* Save status info */
5223 phba->work_hs = readl(phba->HSregaddr);
5224 phba->work_status[0] = readl(phba->MBslimaddr + 0xa8);
5225 phba->work_status[1] = readl(phba->MBslimaddr + 0xac);
5227 /* Clear Chip error bit */
5228 writel(HA_ERATT, phba->HAregaddr);
5229 readl(phba->HAregaddr); /* flush */
5230 phba->pport->stopped = 1;
5233 spin_lock(&phba->hbalock);
5234 if ((work_ha_copy & HA_MBATT) &&
5235 (phba->sli.mbox_active)) {
5236 pmb = phba->sli.mbox_active;
5241 /* First check out the status word */
5242 lpfc_sli_pcimem_bcopy(mbox, pmbox, sizeof(uint32_t));
5243 if (pmbox->mbxOwner != OWN_HOST) {
5244 spin_unlock(&phba->hbalock);
5246 * Stray Mailbox Interrupt, mbxCommand <cmd>
5247 * mbxStatus <status>
5249 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
5251 "(%d):0304 Stray Mailbox "
5252 "Interrupt mbxCommand x%x "
5254 (vport ? vport->vpi : 0),
5257 /* clear mailbox attention bit */
5258 work_ha_copy &= ~HA_MBATT;
5260 phba->sli.mbox_active = NULL;
5261 spin_unlock(&phba->hbalock);
5262 phba->last_completion_time = jiffies;
5263 del_timer(&phba->sli.mbox_tmo);
5264 if (pmb->mbox_cmpl) {
5265 lpfc_sli_pcimem_bcopy(mbox, pmbox,
5268 if (pmb->mbox_flag & LPFC_MBX_IMED_UNREG) {
5269 pmb->mbox_flag &= ~LPFC_MBX_IMED_UNREG;
5271 lpfc_debugfs_disc_trc(vport,
5272 LPFC_DISC_TRC_MBOX_VPORT,
5274 "status:x%x rpi:x%x",
5275 (uint32_t)pmbox->mbxStatus,
5276 pmbox->un.varWords[0], 0);
5278 if (!pmbox->mbxStatus) {
5279 mp = (struct lpfc_dmabuf *)
5281 ndlp = (struct lpfc_nodelist *)
5284 /* Reg_LOGIN of dflt RPI was
5285 * successful. new lets get
5286 * rid of the RPI using the
5289 lpfc_unreg_login(phba,
5291 pmbox->un.varWords[0],
5294 lpfc_mbx_cmpl_dflt_rpi;
5296 pmb->context2 = ndlp;
5298 rc = lpfc_sli_issue_mbox(phba,
5302 lpfc_printf_log(phba,
5305 "0350 rc should have"
5307 goto send_current_mbox;
5310 spin_lock(&phba->pport->work_port_lock);
5311 phba->pport->work_port_events &=
5313 spin_unlock(&phba->pport->work_port_lock);
5314 lpfc_mbox_cmpl_put(phba, pmb);
5317 spin_unlock(&phba->hbalock);
5318 if ((work_ha_copy & HA_MBATT) &&
5319 (phba->sli.mbox_active == NULL)) {
5321 /* Process next mailbox command if there is one */
5323 rc = lpfc_sli_issue_mbox(phba, NULL,
5325 } while (rc == MBX_NOT_FINISHED);
5326 if (rc != MBX_SUCCESS)
5327 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
5328 LOG_SLI, "0349 rc should be "
5332 spin_lock(&phba->hbalock);
5333 phba->work_ha |= work_ha_copy;
5334 spin_unlock(&phba->hbalock);
5335 lpfc_worker_wake_up(phba);
5338 ha_copy &= ~(phba->work_ha_mask);
5341 * Process all events on FCP ring. Take the optimized path for
5342 * FCP IO. Any other IO is slow path and is handled by
5343 * the worker thread.
5345 status = (ha_copy & (HA_RXMASK << (4*LPFC_FCP_RING)));
5346 status >>= (4*LPFC_FCP_RING);
5347 if (status & HA_RXMASK)
5348 lpfc_sli_handle_fast_ring_event(phba,
5349 &phba->sli.ring[LPFC_FCP_RING],
5352 if (phba->cfg_multi_ring_support == 2) {
5354 * Process all events on extra ring. Take the optimized path
5355 * for extra ring IO. Any other IO is slow path and is handled
5356 * by the worker thread.
5358 status = (ha_copy & (HA_RXMASK << (4*LPFC_EXTRA_RING)));
5359 status >>= (4*LPFC_EXTRA_RING);
5360 if (status & HA_RXMASK) {
5361 lpfc_sli_handle_fast_ring_event(phba,
5362 &phba->sli.ring[LPFC_EXTRA_RING],
5368 } /* lpfc_intr_handler */