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>
36 #include "lpfc_disc.h"
37 #include "lpfc_scsi.h"
39 #include "lpfc_crtn.h"
40 #include "lpfc_logmsg.h"
41 #include "lpfc_compat.h"
42 #include "lpfc_debugfs.h"
45 * Define macro to log: Mailbox command x%x cannot issue Data
46 * This allows multiple uses of lpfc_msgBlk0311
47 * w/o perturbing log msg utility.
49 #define LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag) \
50 lpfc_printf_log(phba, \
53 "(%d):0311 Mailbox command x%x cannot " \
54 "issue Data: x%x x%x x%x\n", \
55 pmbox->vport ? pmbox->vport->vpi : 0, \
56 pmbox->mb.mbxCommand, \
57 phba->pport->port_state, \
62 /* There are only four IOCB completion types. */
63 typedef enum _lpfc_iocb_type {
71 * lpfc_cmd_iocb - Get next command iocb entry in the ring
72 * @phba: Pointer to HBA context object.
73 * @pring: Pointer to driver SLI ring object.
75 * This function returns pointer to next command iocb entry
76 * in the command ring. The caller must hold hbalock to prevent
77 * other threads consume the next command iocb.
78 * SLI-2/SLI-3 provide different sized iocbs.
80 static inline IOCB_t *
81 lpfc_cmd_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
83 return (IOCB_t *) (((char *) pring->cmdringaddr) +
84 pring->cmdidx * phba->iocb_cmd_size);
88 * lpfc_resp_iocb - Get next response iocb entry in the ring
89 * @phba: Pointer to HBA context object.
90 * @pring: Pointer to driver SLI ring object.
92 * This function returns pointer to next response iocb entry
93 * in the response ring. The caller must hold hbalock to make sure
94 * that no other thread consume the next response iocb.
95 * SLI-2/SLI-3 provide different sized iocbs.
97 static inline IOCB_t *
98 lpfc_resp_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
100 return (IOCB_t *) (((char *) pring->rspringaddr) +
101 pring->rspidx * phba->iocb_rsp_size);
105 * __lpfc_sli_get_iocbq - Allocates an iocb object from iocb pool
106 * @phba: Pointer to HBA context object.
108 * This function is called with hbalock held. This function
109 * allocates a new driver iocb object from the iocb pool. If the
110 * allocation is successful, it returns pointer to the newly
111 * allocated iocb object else it returns NULL.
113 static struct lpfc_iocbq *
114 __lpfc_sli_get_iocbq(struct lpfc_hba *phba)
116 struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
117 struct lpfc_iocbq * iocbq = NULL;
119 list_remove_head(lpfc_iocb_list, iocbq, struct lpfc_iocbq, list);
124 * lpfc_sli_get_iocbq - Allocates an iocb object from iocb pool
125 * @phba: Pointer to HBA context object.
127 * This function is called with no lock held. This function
128 * allocates a new driver iocb object from the iocb pool. If the
129 * allocation is successful, it returns pointer to the newly
130 * allocated iocb object else it returns NULL.
133 lpfc_sli_get_iocbq(struct lpfc_hba *phba)
135 struct lpfc_iocbq * iocbq = NULL;
136 unsigned long iflags;
138 spin_lock_irqsave(&phba->hbalock, iflags);
139 iocbq = __lpfc_sli_get_iocbq(phba);
140 spin_unlock_irqrestore(&phba->hbalock, iflags);
145 * __lpfc_sli_release_iocbq - Release iocb to the iocb pool
146 * @phba: Pointer to HBA context object.
147 * @iocbq: Pointer to driver iocb object.
149 * This function is called with hbalock held to release driver
150 * iocb object to the iocb pool. The iotag in the iocb object
151 * does not change for each use of the iocb object. This function
152 * clears all other fields of the iocb object when it is freed.
155 __lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
157 size_t start_clean = offsetof(struct lpfc_iocbq, iocb);
160 * Clean all volatile data fields, preserve iotag and node struct.
162 memset((char*)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean);
163 list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
167 * lpfc_sli_release_iocbq - Release iocb to the iocb pool
168 * @phba: Pointer to HBA context object.
169 * @iocbq: Pointer to driver iocb object.
171 * This function is called with no lock held to release the iocb to
175 lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
177 unsigned long iflags;
180 * Clean all volatile data fields, preserve iotag and node struct.
182 spin_lock_irqsave(&phba->hbalock, iflags);
183 __lpfc_sli_release_iocbq(phba, iocbq);
184 spin_unlock_irqrestore(&phba->hbalock, iflags);
188 * lpfc_sli_iocb_cmd_type - Get the iocb type
189 * @iocb_cmnd: iocb command code.
191 * This function is called by ring event handler function to get the iocb type.
192 * This function translates the iocb command to an iocb command type used to
193 * decide the final disposition of each completed IOCB.
194 * The function returns
195 * LPFC_UNKNOWN_IOCB if it is an unsupported iocb
196 * LPFC_SOL_IOCB if it is a solicited iocb completion
197 * LPFC_ABORT_IOCB if it is an abort iocb
198 * LPFC_UNSOL_IOCB if it is an unsolicited iocb
200 * The caller is not required to hold any lock.
202 static lpfc_iocb_type
203 lpfc_sli_iocb_cmd_type(uint8_t iocb_cmnd)
205 lpfc_iocb_type type = LPFC_UNKNOWN_IOCB;
207 if (iocb_cmnd > CMD_MAX_IOCB_CMD)
211 case CMD_XMIT_SEQUENCE_CR:
212 case CMD_XMIT_SEQUENCE_CX:
213 case CMD_XMIT_BCAST_CN:
214 case CMD_XMIT_BCAST_CX:
215 case CMD_ELS_REQUEST_CR:
216 case CMD_ELS_REQUEST_CX:
217 case CMD_CREATE_XRI_CR:
218 case CMD_CREATE_XRI_CX:
220 case CMD_XMIT_ELS_RSP_CX:
222 case CMD_FCP_IWRITE_CR:
223 case CMD_FCP_IWRITE_CX:
224 case CMD_FCP_IREAD_CR:
225 case CMD_FCP_IREAD_CX:
226 case CMD_FCP_ICMND_CR:
227 case CMD_FCP_ICMND_CX:
228 case CMD_FCP_TSEND_CX:
229 case CMD_FCP_TRSP_CX:
230 case CMD_FCP_TRECEIVE_CX:
231 case CMD_FCP_AUTO_TRSP_CX:
232 case CMD_ADAPTER_MSG:
233 case CMD_ADAPTER_DUMP:
234 case CMD_XMIT_SEQUENCE64_CR:
235 case CMD_XMIT_SEQUENCE64_CX:
236 case CMD_XMIT_BCAST64_CN:
237 case CMD_XMIT_BCAST64_CX:
238 case CMD_ELS_REQUEST64_CR:
239 case CMD_ELS_REQUEST64_CX:
240 case CMD_FCP_IWRITE64_CR:
241 case CMD_FCP_IWRITE64_CX:
242 case CMD_FCP_IREAD64_CR:
243 case CMD_FCP_IREAD64_CX:
244 case CMD_FCP_ICMND64_CR:
245 case CMD_FCP_ICMND64_CX:
246 case CMD_FCP_TSEND64_CX:
247 case CMD_FCP_TRSP64_CX:
248 case CMD_FCP_TRECEIVE64_CX:
249 case CMD_GEN_REQUEST64_CR:
250 case CMD_GEN_REQUEST64_CX:
251 case CMD_XMIT_ELS_RSP64_CX:
252 type = LPFC_SOL_IOCB;
254 case CMD_ABORT_XRI_CN:
255 case CMD_ABORT_XRI_CX:
256 case CMD_CLOSE_XRI_CN:
257 case CMD_CLOSE_XRI_CX:
258 case CMD_XRI_ABORTED_CX:
259 case CMD_ABORT_MXRI64_CN:
260 type = LPFC_ABORT_IOCB;
262 case CMD_RCV_SEQUENCE_CX:
263 case CMD_RCV_ELS_REQ_CX:
264 case CMD_RCV_SEQUENCE64_CX:
265 case CMD_RCV_ELS_REQ64_CX:
266 case CMD_ASYNC_STATUS:
267 case CMD_IOCB_RCV_SEQ64_CX:
268 case CMD_IOCB_RCV_ELS64_CX:
269 case CMD_IOCB_RCV_CONT64_CX:
270 case CMD_IOCB_RET_XRI64_CX:
271 type = LPFC_UNSOL_IOCB;
273 case CMD_IOCB_XMIT_MSEQ64_CR:
274 case CMD_IOCB_XMIT_MSEQ64_CX:
275 case CMD_IOCB_RCV_SEQ_LIST64_CX:
276 case CMD_IOCB_RCV_ELS_LIST64_CX:
277 case CMD_IOCB_CLOSE_EXTENDED_CN:
278 case CMD_IOCB_ABORT_EXTENDED_CN:
279 case CMD_IOCB_RET_HBQE64_CN:
280 case CMD_IOCB_FCP_IBIDIR64_CR:
281 case CMD_IOCB_FCP_IBIDIR64_CX:
282 case CMD_IOCB_FCP_ITASKMGT64_CX:
283 case CMD_IOCB_LOGENTRY_CN:
284 case CMD_IOCB_LOGENTRY_ASYNC_CN:
285 printk("%s - Unhandled SLI-3 Command x%x\n",
286 __func__, iocb_cmnd);
287 type = LPFC_UNKNOWN_IOCB;
290 type = LPFC_UNKNOWN_IOCB;
298 * lpfc_sli_ring_map - Issue config_ring mbox for all rings
299 * @phba: Pointer to HBA context object.
301 * This function is called from SLI initialization code
302 * to configure every ring of the HBA's SLI interface. The
303 * caller is not required to hold any lock. This function issues
304 * a config_ring mailbox command for each ring.
305 * This function returns zero if successful else returns a negative
309 lpfc_sli_ring_map(struct lpfc_hba *phba)
311 struct lpfc_sli *psli = &phba->sli;
316 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
320 phba->link_state = LPFC_INIT_MBX_CMDS;
321 for (i = 0; i < psli->num_rings; i++) {
322 lpfc_config_ring(phba, i, pmb);
323 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
324 if (rc != MBX_SUCCESS) {
325 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
326 "0446 Adapter failed to init (%d), "
327 "mbxCmd x%x CFG_RING, mbxStatus x%x, "
329 rc, pmbox->mbxCommand,
330 pmbox->mbxStatus, i);
331 phba->link_state = LPFC_HBA_ERROR;
336 mempool_free(pmb, phba->mbox_mem_pool);
341 * lpfc_sli_ringtxcmpl_put - Adds new iocb to the txcmplq
342 * @phba: Pointer to HBA context object.
343 * @pring: Pointer to driver SLI ring object.
344 * @piocb: Pointer to the driver iocb object.
346 * This function is called with hbalock held. The function adds the
347 * new iocb to txcmplq of the given ring. This function always returns
348 * 0. If this function is called for ELS ring, this function checks if
349 * there is a vport associated with the ELS command. This function also
350 * starts els_tmofunc timer if this is an ELS command.
353 lpfc_sli_ringtxcmpl_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
354 struct lpfc_iocbq *piocb)
356 list_add_tail(&piocb->list, &pring->txcmplq);
357 pring->txcmplq_cnt++;
358 if ((unlikely(pring->ringno == LPFC_ELS_RING)) &&
359 (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
360 (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN)) {
364 mod_timer(&piocb->vport->els_tmofunc,
365 jiffies + HZ * (phba->fc_ratov << 1));
373 * lpfc_sli_ringtx_get - Get first element of the txq
374 * @phba: Pointer to HBA context object.
375 * @pring: Pointer to driver SLI ring object.
377 * This function is called with hbalock held to get next
378 * iocb in txq of the given ring. If there is any iocb in
379 * the txq, the function returns first iocb in the list after
380 * removing the iocb from the list, else it returns NULL.
382 static struct lpfc_iocbq *
383 lpfc_sli_ringtx_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
385 struct lpfc_iocbq *cmd_iocb;
387 list_remove_head((&pring->txq), cmd_iocb, struct lpfc_iocbq, list);
388 if (cmd_iocb != NULL)
394 * lpfc_sli_next_iocb_slot - Get next iocb slot in the ring
395 * @phba: Pointer to HBA context object.
396 * @pring: Pointer to driver SLI ring object.
398 * This function is called with hbalock held and the caller must post the
399 * iocb without releasing the lock. If the caller releases the lock,
400 * iocb slot returned by the function is not guaranteed to be available.
401 * The function returns pointer to the next available iocb slot if there
402 * is available slot in the ring, else it returns NULL.
403 * If the get index of the ring is ahead of the put index, the function
404 * will post an error attention event to the worker thread to take the
405 * HBA to offline state.
408 lpfc_sli_next_iocb_slot (struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
410 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
411 uint32_t max_cmd_idx = pring->numCiocb;
412 if ((pring->next_cmdidx == pring->cmdidx) &&
413 (++pring->next_cmdidx >= max_cmd_idx))
414 pring->next_cmdidx = 0;
416 if (unlikely(pring->local_getidx == pring->next_cmdidx)) {
418 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
420 if (unlikely(pring->local_getidx >= max_cmd_idx)) {
421 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
422 "0315 Ring %d issue: portCmdGet %d "
423 "is bigger than cmd ring %d\n",
425 pring->local_getidx, max_cmd_idx);
427 phba->link_state = LPFC_HBA_ERROR;
429 * All error attention handlers are posted to
432 phba->work_ha |= HA_ERATT;
433 phba->work_hs = HS_FFER3;
435 lpfc_worker_wake_up(phba);
440 if (pring->local_getidx == pring->next_cmdidx)
444 return lpfc_cmd_iocb(phba, pring);
448 * lpfc_sli_next_iotag - Get an iotag for the iocb
449 * @phba: Pointer to HBA context object.
450 * @iocbq: Pointer to driver iocb object.
452 * This function gets an iotag for the iocb. If there is no unused iotag and
453 * the iocbq_lookup_len < 0xffff, this function allocates a bigger iotag_lookup
454 * array and assigns a new iotag.
455 * The function returns the allocated iotag if successful, else returns zero.
456 * Zero is not a valid iotag.
457 * The caller is not required to hold any lock.
460 lpfc_sli_next_iotag(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
462 struct lpfc_iocbq **new_arr;
463 struct lpfc_iocbq **old_arr;
465 struct lpfc_sli *psli = &phba->sli;
468 spin_lock_irq(&phba->hbalock);
469 iotag = psli->last_iotag;
470 if(++iotag < psli->iocbq_lookup_len) {
471 psli->last_iotag = iotag;
472 psli->iocbq_lookup[iotag] = iocbq;
473 spin_unlock_irq(&phba->hbalock);
474 iocbq->iotag = iotag;
476 } else if (psli->iocbq_lookup_len < (0xffff
477 - LPFC_IOCBQ_LOOKUP_INCREMENT)) {
478 new_len = psli->iocbq_lookup_len + LPFC_IOCBQ_LOOKUP_INCREMENT;
479 spin_unlock_irq(&phba->hbalock);
480 new_arr = kzalloc(new_len * sizeof (struct lpfc_iocbq *),
483 spin_lock_irq(&phba->hbalock);
484 old_arr = psli->iocbq_lookup;
485 if (new_len <= psli->iocbq_lookup_len) {
486 /* highly unprobable case */
488 iotag = psli->last_iotag;
489 if(++iotag < psli->iocbq_lookup_len) {
490 psli->last_iotag = iotag;
491 psli->iocbq_lookup[iotag] = iocbq;
492 spin_unlock_irq(&phba->hbalock);
493 iocbq->iotag = iotag;
496 spin_unlock_irq(&phba->hbalock);
499 if (psli->iocbq_lookup)
500 memcpy(new_arr, old_arr,
501 ((psli->last_iotag + 1) *
502 sizeof (struct lpfc_iocbq *)));
503 psli->iocbq_lookup = new_arr;
504 psli->iocbq_lookup_len = new_len;
505 psli->last_iotag = iotag;
506 psli->iocbq_lookup[iotag] = iocbq;
507 spin_unlock_irq(&phba->hbalock);
508 iocbq->iotag = iotag;
513 spin_unlock_irq(&phba->hbalock);
515 lpfc_printf_log(phba, KERN_ERR,LOG_SLI,
516 "0318 Failed to allocate IOTAG.last IOTAG is %d\n",
523 * lpfc_sli_submit_iocb - Submit an iocb to the firmware
524 * @phba: Pointer to HBA context object.
525 * @pring: Pointer to driver SLI ring object.
526 * @iocb: Pointer to iocb slot in the ring.
527 * @nextiocb: Pointer to driver iocb object which need to be
528 * posted to firmware.
530 * This function is called with hbalock held to post a new iocb to
531 * the firmware. This function copies the new iocb to ring iocb slot and
532 * updates the ring pointers. It adds the new iocb to txcmplq if there is
533 * a completion call back for this iocb else the function will free the
537 lpfc_sli_submit_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
538 IOCB_t *iocb, struct lpfc_iocbq *nextiocb)
543 nextiocb->iocb.ulpIoTag = (nextiocb->iocb_cmpl) ? nextiocb->iotag : 0;
546 if (pring->ringno == LPFC_ELS_RING) {
547 lpfc_debugfs_slow_ring_trc(phba,
548 "IOCB cmd ring: wd4:x%08x wd6:x%08x wd7:x%08x",
549 *(((uint32_t *) &nextiocb->iocb) + 4),
550 *(((uint32_t *) &nextiocb->iocb) + 6),
551 *(((uint32_t *) &nextiocb->iocb) + 7));
555 * Issue iocb command to adapter
557 lpfc_sli_pcimem_bcopy(&nextiocb->iocb, iocb, phba->iocb_cmd_size);
559 pring->stats.iocb_cmd++;
562 * If there is no completion routine to call, we can release the
563 * IOCB buffer back right now. For IOCBs, like QUE_RING_BUF,
564 * that have no rsp ring completion, iocb_cmpl MUST be NULL.
566 if (nextiocb->iocb_cmpl)
567 lpfc_sli_ringtxcmpl_put(phba, pring, nextiocb);
569 __lpfc_sli_release_iocbq(phba, nextiocb);
572 * Let the HBA know what IOCB slot will be the next one the
573 * driver will put a command into.
575 pring->cmdidx = pring->next_cmdidx;
576 writel(pring->cmdidx, &phba->host_gp[pring->ringno].cmdPutInx);
580 * lpfc_sli_update_full_ring - Update the chip attention register
581 * @phba: Pointer to HBA context object.
582 * @pring: Pointer to driver SLI ring object.
584 * The caller is not required to hold any lock for calling this function.
585 * This function updates the chip attention bits for the ring to inform firmware
586 * that there are pending work to be done for this ring and requests an
587 * interrupt when there is space available in the ring. This function is
588 * called when the driver is unable to post more iocbs to the ring due
589 * to unavailability of space in the ring.
592 lpfc_sli_update_full_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
594 int ringno = pring->ringno;
596 pring->flag |= LPFC_CALL_RING_AVAILABLE;
601 * Set ring 'ringno' to SET R0CE_REQ in Chip Att register.
602 * The HBA will tell us when an IOCB entry is available.
604 writel((CA_R0ATT|CA_R0CE_REQ) << (ringno*4), phba->CAregaddr);
605 readl(phba->CAregaddr); /* flush */
607 pring->stats.iocb_cmd_full++;
611 * lpfc_sli_update_ring - Update chip attention register
612 * @phba: Pointer to HBA context object.
613 * @pring: Pointer to driver SLI ring object.
615 * This function updates the chip attention register bit for the
616 * given ring to inform HBA that there is more work to be done
617 * in this ring. The caller is not required to hold any lock.
620 lpfc_sli_update_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
622 int ringno = pring->ringno;
625 * Tell the HBA that there is work to do in this ring.
627 if (!(phba->sli3_options & LPFC_SLI3_CRP_ENABLED)) {
629 writel(CA_R0ATT << (ringno * 4), phba->CAregaddr);
630 readl(phba->CAregaddr); /* flush */
635 * lpfc_sli_resume_iocb - Process iocbs in the txq
636 * @phba: Pointer to HBA context object.
637 * @pring: Pointer to driver SLI ring object.
639 * This function is called with hbalock held to post pending iocbs
640 * in the txq to the firmware. This function is called when driver
641 * detects space available in the ring.
644 lpfc_sli_resume_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
647 struct lpfc_iocbq *nextiocb;
651 * (a) there is anything on the txq to send
653 * (c) link attention events can be processed (fcp ring only)
654 * (d) IOCB processing is not blocked by the outstanding mbox command.
656 if (pring->txq_cnt &&
657 lpfc_is_link_up(phba) &&
658 (pring->ringno != phba->sli.fcp_ring ||
659 phba->sli.sli_flag & LPFC_PROCESS_LA)) {
661 while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
662 (nextiocb = lpfc_sli_ringtx_get(phba, pring)))
663 lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
666 lpfc_sli_update_ring(phba, pring);
668 lpfc_sli_update_full_ring(phba, pring);
675 * lpfc_sli_next_hbq_slot - Get next hbq entry for the HBQ
676 * @phba: Pointer to HBA context object.
677 * @hbqno: HBQ number.
679 * This function is called with hbalock held to get the next
680 * available slot for the given HBQ. If there is free slot
681 * available for the HBQ it will return pointer to the next available
682 * HBQ entry else it will return NULL.
684 static struct lpfc_hbq_entry *
685 lpfc_sli_next_hbq_slot(struct lpfc_hba *phba, uint32_t hbqno)
687 struct hbq_s *hbqp = &phba->hbqs[hbqno];
689 if (hbqp->next_hbqPutIdx == hbqp->hbqPutIdx &&
690 ++hbqp->next_hbqPutIdx >= hbqp->entry_count)
691 hbqp->next_hbqPutIdx = 0;
693 if (unlikely(hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)) {
694 uint32_t raw_index = phba->hbq_get[hbqno];
695 uint32_t getidx = le32_to_cpu(raw_index);
697 hbqp->local_hbqGetIdx = getidx;
699 if (unlikely(hbqp->local_hbqGetIdx >= hbqp->entry_count)) {
700 lpfc_printf_log(phba, KERN_ERR,
702 "1802 HBQ %d: local_hbqGetIdx "
703 "%u is > than hbqp->entry_count %u\n",
704 hbqno, hbqp->local_hbqGetIdx,
707 phba->link_state = LPFC_HBA_ERROR;
711 if (hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)
715 return (struct lpfc_hbq_entry *) phba->hbqs[hbqno].hbq_virt +
720 * lpfc_sli_hbqbuf_free_all - Free all the hbq buffers
721 * @phba: Pointer to HBA context object.
723 * This function is called with no lock held to free all the
724 * hbq buffers while uninitializing the SLI interface. It also
725 * frees the HBQ buffers returned by the firmware but not yet
726 * processed by the upper layers.
729 lpfc_sli_hbqbuf_free_all(struct lpfc_hba *phba)
731 struct lpfc_dmabuf *dmabuf, *next_dmabuf;
732 struct hbq_dmabuf *hbq_buf;
737 hbq_count = lpfc_sli_hbq_count();
738 /* Return all memory used by all HBQs */
739 spin_lock_irqsave(&phba->hbalock, flags);
740 for (i = 0; i < hbq_count; ++i) {
741 list_for_each_entry_safe(dmabuf, next_dmabuf,
742 &phba->hbqs[i].hbq_buffer_list, list) {
743 hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
744 list_del(&hbq_buf->dbuf.list);
745 (phba->hbqs[i].hbq_free_buffer)(phba, hbq_buf);
747 phba->hbqs[i].buffer_count = 0;
749 /* Return all HBQ buffer that are in-fly */
750 list_for_each_entry_safe(dmabuf, next_dmabuf,
751 &phba->hbqbuf_in_list, list) {
752 hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
753 list_del(&hbq_buf->dbuf.list);
754 if (hbq_buf->tag == -1) {
755 (phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
758 hbqno = hbq_buf->tag >> 16;
759 if (hbqno >= LPFC_MAX_HBQS)
760 (phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
763 (phba->hbqs[hbqno].hbq_free_buffer)(phba,
768 /* Mark the HBQs not in use */
769 phba->hbq_in_use = 0;
770 spin_unlock_irqrestore(&phba->hbalock, flags);
774 * lpfc_sli_hbq_to_firmware - Post the hbq buffer to firmware
775 * @phba: Pointer to HBA context object.
776 * @hbqno: HBQ number.
777 * @hbq_buf: Pointer to HBQ buffer.
779 * This function is called with the hbalock held to post a
780 * hbq buffer to the firmware. If the function finds an empty
781 * slot in the HBQ, it will post the buffer. The function will return
782 * pointer to the hbq entry if it successfully post the buffer
783 * else it will return NULL.
785 static struct lpfc_hbq_entry *
786 lpfc_sli_hbq_to_firmware(struct lpfc_hba *phba, uint32_t hbqno,
787 struct hbq_dmabuf *hbq_buf)
789 struct lpfc_hbq_entry *hbqe;
790 dma_addr_t physaddr = hbq_buf->dbuf.phys;
792 /* Get next HBQ entry slot to use */
793 hbqe = lpfc_sli_next_hbq_slot(phba, hbqno);
795 struct hbq_s *hbqp = &phba->hbqs[hbqno];
797 hbqe->bde.addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
798 hbqe->bde.addrLow = le32_to_cpu(putPaddrLow(physaddr));
799 hbqe->bde.tus.f.bdeSize = hbq_buf->size;
800 hbqe->bde.tus.f.bdeFlags = 0;
801 hbqe->bde.tus.w = le32_to_cpu(hbqe->bde.tus.w);
802 hbqe->buffer_tag = le32_to_cpu(hbq_buf->tag);
804 hbqp->hbqPutIdx = hbqp->next_hbqPutIdx;
805 writel(hbqp->hbqPutIdx, phba->hbq_put + hbqno);
807 readl(phba->hbq_put + hbqno);
808 list_add_tail(&hbq_buf->dbuf.list, &hbqp->hbq_buffer_list);
813 /* HBQ for ELS and CT traffic. */
814 static struct lpfc_hbq_init lpfc_els_hbq = {
819 .ring_mask = (1 << LPFC_ELS_RING),
825 /* HBQ for the extra ring if needed */
826 static struct lpfc_hbq_init lpfc_extra_hbq = {
831 .ring_mask = (1 << LPFC_EXTRA_RING),
838 struct lpfc_hbq_init *lpfc_hbq_defs[] = {
844 * lpfc_sli_hbqbuf_fill_hbqs - Post more hbq buffers to HBQ
845 * @phba: Pointer to HBA context object.
846 * @hbqno: HBQ number.
847 * @count: Number of HBQ buffers to be posted.
849 * This function is called with no lock held to post more hbq buffers to the
850 * given HBQ. The function returns the number of HBQ buffers successfully
854 lpfc_sli_hbqbuf_fill_hbqs(struct lpfc_hba *phba, uint32_t hbqno, uint32_t count)
856 uint32_t i, posted = 0;
858 struct hbq_dmabuf *hbq_buffer;
859 LIST_HEAD(hbq_buf_list);
860 if (!phba->hbqs[hbqno].hbq_alloc_buffer)
863 if ((phba->hbqs[hbqno].buffer_count + count) >
864 lpfc_hbq_defs[hbqno]->entry_count)
865 count = lpfc_hbq_defs[hbqno]->entry_count -
866 phba->hbqs[hbqno].buffer_count;
869 /* Allocate HBQ entries */
870 for (i = 0; i < count; i++) {
871 hbq_buffer = (phba->hbqs[hbqno].hbq_alloc_buffer)(phba);
874 list_add_tail(&hbq_buffer->dbuf.list, &hbq_buf_list);
876 /* Check whether HBQ is still in use */
877 spin_lock_irqsave(&phba->hbalock, flags);
878 if (!phba->hbq_in_use)
880 while (!list_empty(&hbq_buf_list)) {
881 list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
883 hbq_buffer->tag = (phba->hbqs[hbqno].buffer_count |
885 if (lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {
886 phba->hbqs[hbqno].buffer_count++;
889 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
891 spin_unlock_irqrestore(&phba->hbalock, flags);
894 spin_unlock_irqrestore(&phba->hbalock, flags);
895 while (!list_empty(&hbq_buf_list)) {
896 list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
898 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
904 * lpfc_sli_hbqbuf_add_hbqs - Post more HBQ buffers to firmware
905 * @phba: Pointer to HBA context object.
908 * This function posts more buffers to the HBQ. This function
909 * is called with no lock held. The function returns the number of HBQ entries
910 * successfully allocated.
913 lpfc_sli_hbqbuf_add_hbqs(struct lpfc_hba *phba, uint32_t qno)
915 return(lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
916 lpfc_hbq_defs[qno]->add_count));
920 * lpfc_sli_hbqbuf_init_hbqs - Post initial buffers to the HBQ
921 * @phba: Pointer to HBA context object.
922 * @qno: HBQ queue number.
924 * This function is called from SLI initialization code path with
925 * no lock held to post initial HBQ buffers to firmware. The
926 * function returns the number of HBQ entries successfully allocated.
929 lpfc_sli_hbqbuf_init_hbqs(struct lpfc_hba *phba, uint32_t qno)
931 return(lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
932 lpfc_hbq_defs[qno]->init_count));
936 * lpfc_sli_hbqbuf_find - Find the hbq buffer associated with a tag
937 * @phba: Pointer to HBA context object.
938 * @tag: Tag of the hbq buffer.
940 * This function is called with hbalock held. This function searches
941 * for the hbq buffer associated with the given tag in the hbq buffer
942 * list. If it finds the hbq buffer, it returns the hbq_buffer other wise
945 static struct hbq_dmabuf *
946 lpfc_sli_hbqbuf_find(struct lpfc_hba *phba, uint32_t tag)
948 struct lpfc_dmabuf *d_buf;
949 struct hbq_dmabuf *hbq_buf;
953 if (hbqno >= LPFC_MAX_HBQS)
956 list_for_each_entry(d_buf, &phba->hbqs[hbqno].hbq_buffer_list, list) {
957 hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
958 if (hbq_buf->tag == tag) {
962 lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_VPORT,
963 "1803 Bad hbq tag. Data: x%x x%x\n",
964 tag, phba->hbqs[tag >> 16].buffer_count);
969 * lpfc_sli_free_hbq - Give back the hbq buffer to firmware
970 * @phba: Pointer to HBA context object.
971 * @hbq_buffer: Pointer to HBQ buffer.
973 * This function is called with hbalock. This function gives back
974 * the hbq buffer to firmware. If the HBQ does not have space to
975 * post the buffer, it will free the buffer.
978 lpfc_sli_free_hbq(struct lpfc_hba *phba, struct hbq_dmabuf *hbq_buffer)
983 hbqno = hbq_buffer->tag >> 16;
984 if (!lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {
985 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
991 * lpfc_sli_chk_mbx_command - Check if the mailbox is a legitimate mailbox
992 * @mbxCommand: mailbox command code.
994 * This function is called by the mailbox event handler function to verify
995 * that the completed mailbox command is a legitimate mailbox command. If the
996 * completed mailbox is not known to the function, it will return MBX_SHUTDOWN
997 * and the mailbox event handler will take the HBA offline.
1000 lpfc_sli_chk_mbx_command(uint8_t mbxCommand)
1004 switch (mbxCommand) {
1008 case MBX_WRITE_VPARMS:
1009 case MBX_RUN_BIU_DIAG:
1012 case MBX_CONFIG_LINK:
1013 case MBX_CONFIG_RING:
1014 case MBX_RESET_RING:
1015 case MBX_READ_CONFIG:
1016 case MBX_READ_RCONFIG:
1017 case MBX_READ_SPARM:
1018 case MBX_READ_STATUS:
1022 case MBX_READ_LNK_STAT:
1024 case MBX_UNREG_LOGIN:
1027 case MBX_DUMP_MEMORY:
1028 case MBX_DUMP_CONTEXT:
1031 case MBX_UPDATE_CFG:
1033 case MBX_DEL_LD_ENTRY:
1034 case MBX_RUN_PROGRAM:
1036 case MBX_SET_VARIABLE:
1037 case MBX_UNREG_D_ID:
1038 case MBX_KILL_BOARD:
1039 case MBX_CONFIG_FARP:
1042 case MBX_RUN_BIU_DIAG64:
1043 case MBX_CONFIG_PORT:
1044 case MBX_READ_SPARM64:
1045 case MBX_READ_RPI64:
1046 case MBX_REG_LOGIN64:
1050 case MBX_LOAD_EXP_ROM:
1051 case MBX_ASYNCEVT_ENABLE:
1055 case MBX_PORT_CAPABILITIES:
1056 case MBX_PORT_IOV_CONTROL:
1067 * lpfc_sli_wake_mbox_wait - lpfc_sli_issue_mbox_wait mbox completion handler
1068 * @phba: Pointer to HBA context object.
1069 * @pmboxq: Pointer to mailbox command.
1071 * This is completion handler function for mailbox commands issued from
1072 * lpfc_sli_issue_mbox_wait function. This function is called by the
1073 * mailbox event handler function with no lock held. This function
1074 * will wake up thread waiting on the wait queue pointed by context1
1078 lpfc_sli_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
1080 wait_queue_head_t *pdone_q;
1081 unsigned long drvr_flag;
1084 * If pdone_q is empty, the driver thread gave up waiting and
1085 * continued running.
1087 pmboxq->mbox_flag |= LPFC_MBX_WAKE;
1088 spin_lock_irqsave(&phba->hbalock, drvr_flag);
1089 pdone_q = (wait_queue_head_t *) pmboxq->context1;
1091 wake_up_interruptible(pdone_q);
1092 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
1098 * lpfc_sli_def_mbox_cmpl - Default mailbox completion handler
1099 * @phba: Pointer to HBA context object.
1100 * @pmb: Pointer to mailbox object.
1102 * This function is the default mailbox completion handler. It
1103 * frees the memory resources associated with the completed mailbox
1104 * command. If the completed command is a REG_LOGIN mailbox command,
1105 * this function will issue a UREG_LOGIN to re-claim the RPI.
1108 lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1110 struct lpfc_dmabuf *mp;
1114 mp = (struct lpfc_dmabuf *) (pmb->context1);
1117 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1122 * If a REG_LOGIN succeeded after node is destroyed or node
1123 * is in re-discovery driver need to cleanup the RPI.
1125 if (!(phba->pport->load_flag & FC_UNLOADING) &&
1126 pmb->mb.mbxCommand == MBX_REG_LOGIN64 &&
1127 !pmb->mb.mbxStatus) {
1129 rpi = pmb->mb.un.varWords[0];
1130 lpfc_unreg_login(phba, pmb->mb.un.varRegLogin.vpi, rpi, pmb);
1131 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
1132 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
1133 if (rc != MBX_NOT_FINISHED)
1137 mempool_free(pmb, phba->mbox_mem_pool);
1142 * lpfc_sli_handle_mb_event - Handle mailbox completions from firmware
1143 * @phba: Pointer to HBA context object.
1145 * This function is called with no lock held. This function processes all
1146 * the completed mailbox commands and gives it to upper layers. The interrupt
1147 * service routine processes mailbox completion interrupt and adds completed
1148 * mailbox commands to the mboxq_cmpl queue and signals the worker thread.
1149 * Worker thread call lpfc_sli_handle_mb_event, which will return the
1150 * completed mailbox commands in mboxq_cmpl queue to the upper layers. This
1151 * function returns the mailbox commands to the upper layer by calling the
1152 * completion handler function of each mailbox.
1155 lpfc_sli_handle_mb_event(struct lpfc_hba *phba)
1162 phba->sli.slistat.mbox_event++;
1164 /* Get all completed mailboxe buffers into the cmplq */
1165 spin_lock_irq(&phba->hbalock);
1166 list_splice_init(&phba->sli.mboxq_cmpl, &cmplq);
1167 spin_unlock_irq(&phba->hbalock);
1169 /* Get a Mailbox buffer to setup mailbox commands for callback */
1171 list_remove_head(&cmplq, pmb, LPFC_MBOXQ_t, list);
1177 if (pmbox->mbxCommand != MBX_HEARTBEAT) {
1179 lpfc_debugfs_disc_trc(pmb->vport,
1180 LPFC_DISC_TRC_MBOX_VPORT,
1181 "MBOX cmpl vport: cmd:x%x mb:x%x x%x",
1182 (uint32_t)pmbox->mbxCommand,
1183 pmbox->un.varWords[0],
1184 pmbox->un.varWords[1]);
1187 lpfc_debugfs_disc_trc(phba->pport,
1189 "MBOX cmpl: cmd:x%x mb:x%x x%x",
1190 (uint32_t)pmbox->mbxCommand,
1191 pmbox->un.varWords[0],
1192 pmbox->un.varWords[1]);
1197 * It is a fatal error if unknown mbox command completion.
1199 if (lpfc_sli_chk_mbx_command(pmbox->mbxCommand) ==
1201 /* Unknow mailbox command compl */
1202 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
1203 "(%d):0323 Unknown Mailbox command "
1205 pmb->vport ? pmb->vport->vpi : 0,
1207 phba->link_state = LPFC_HBA_ERROR;
1208 phba->work_hs = HS_FFER3;
1209 lpfc_handle_eratt(phba);
1213 if (pmbox->mbxStatus) {
1214 phba->sli.slistat.mbox_stat_err++;
1215 if (pmbox->mbxStatus == MBXERR_NO_RESOURCES) {
1216 /* Mbox cmd cmpl error - RETRYing */
1217 lpfc_printf_log(phba, KERN_INFO,
1219 "(%d):0305 Mbox cmd cmpl "
1220 "error - RETRYing Data: x%x "
1222 pmb->vport ? pmb->vport->vpi :0,
1225 pmbox->un.varWords[0],
1226 pmb->vport->port_state);
1227 pmbox->mbxStatus = 0;
1228 pmbox->mbxOwner = OWN_HOST;
1229 spin_lock_irq(&phba->hbalock);
1230 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
1231 spin_unlock_irq(&phba->hbalock);
1232 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
1233 if (rc == MBX_SUCCESS)
1238 /* Mailbox cmd <cmd> Cmpl <cmpl> */
1239 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
1240 "(%d):0307 Mailbox cmd x%x Cmpl x%p "
1241 "Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x\n",
1242 pmb->vport ? pmb->vport->vpi : 0,
1245 *((uint32_t *) pmbox),
1246 pmbox->un.varWords[0],
1247 pmbox->un.varWords[1],
1248 pmbox->un.varWords[2],
1249 pmbox->un.varWords[3],
1250 pmbox->un.varWords[4],
1251 pmbox->un.varWords[5],
1252 pmbox->un.varWords[6],
1253 pmbox->un.varWords[7]);
1256 pmb->mbox_cmpl(phba,pmb);
1262 * lpfc_sli_get_buff - Get the buffer associated with the buffer tag
1263 * @phba: Pointer to HBA context object.
1264 * @pring: Pointer to driver SLI ring object.
1267 * This function is called with no lock held. When QUE_BUFTAG_BIT bit
1268 * is set in the tag the buffer is posted for a particular exchange,
1269 * the function will return the buffer without replacing the buffer.
1270 * If the buffer is for unsolicited ELS or CT traffic, this function
1271 * returns the buffer and also posts another buffer to the firmware.
1273 static struct lpfc_dmabuf *
1274 lpfc_sli_get_buff(struct lpfc_hba *phba,
1275 struct lpfc_sli_ring *pring,
1278 struct hbq_dmabuf *hbq_entry;
1280 if (tag & QUE_BUFTAG_BIT)
1281 return lpfc_sli_ring_taggedbuf_get(phba, pring, tag);
1282 hbq_entry = lpfc_sli_hbqbuf_find(phba, tag);
1285 return &hbq_entry->dbuf;
1290 * lpfc_sli_process_unsol_iocb - Unsolicited iocb handler
1291 * @phba: Pointer to HBA context object.
1292 * @pring: Pointer to driver SLI ring object.
1293 * @saveq: Pointer to the unsolicited iocb.
1295 * This function is called with no lock held by the ring event handler
1296 * when there is an unsolicited iocb posted to the response ring by the
1297 * firmware. This function gets the buffer associated with the iocbs
1298 * and calls the event handler for the ring. This function handles both
1299 * qring buffers and hbq buffers.
1300 * When the function returns 1 the caller can free the iocb object otherwise
1301 * upper layer functions will free the iocb objects.
1304 lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1305 struct lpfc_iocbq *saveq)
1309 uint32_t Rctl, Type;
1311 struct lpfc_iocbq *iocbq;
1312 struct lpfc_dmabuf *dmzbuf;
1315 irsp = &(saveq->iocb);
1317 if (irsp->ulpCommand == CMD_ASYNC_STATUS) {
1318 if (pring->lpfc_sli_rcv_async_status)
1319 pring->lpfc_sli_rcv_async_status(phba, pring, saveq);
1321 lpfc_printf_log(phba,
1324 "0316 Ring %d handler: unexpected "
1325 "ASYNC_STATUS iocb received evt_code "
1328 irsp->un.asyncstat.evt_code);
1332 if ((irsp->ulpCommand == CMD_IOCB_RET_XRI64_CX) &&
1333 (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)) {
1334 if (irsp->ulpBdeCount > 0) {
1335 dmzbuf = lpfc_sli_get_buff(phba, pring,
1336 irsp->un.ulpWord[3]);
1337 lpfc_in_buf_free(phba, dmzbuf);
1340 if (irsp->ulpBdeCount > 1) {
1341 dmzbuf = lpfc_sli_get_buff(phba, pring,
1342 irsp->unsli3.sli3Words[3]);
1343 lpfc_in_buf_free(phba, dmzbuf);
1346 if (irsp->ulpBdeCount > 2) {
1347 dmzbuf = lpfc_sli_get_buff(phba, pring,
1348 irsp->unsli3.sli3Words[7]);
1349 lpfc_in_buf_free(phba, dmzbuf);
1355 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
1356 if (irsp->ulpBdeCount != 0) {
1357 saveq->context2 = lpfc_sli_get_buff(phba, pring,
1358 irsp->un.ulpWord[3]);
1359 if (!saveq->context2)
1360 lpfc_printf_log(phba,
1363 "0341 Ring %d Cannot find buffer for "
1364 "an unsolicited iocb. tag 0x%x\n",
1366 irsp->un.ulpWord[3]);
1368 if (irsp->ulpBdeCount == 2) {
1369 saveq->context3 = lpfc_sli_get_buff(phba, pring,
1370 irsp->unsli3.sli3Words[7]);
1371 if (!saveq->context3)
1372 lpfc_printf_log(phba,
1375 "0342 Ring %d Cannot find buffer for an"
1376 " unsolicited iocb. tag 0x%x\n",
1378 irsp->unsli3.sli3Words[7]);
1380 list_for_each_entry(iocbq, &saveq->list, list) {
1381 irsp = &(iocbq->iocb);
1382 if (irsp->ulpBdeCount != 0) {
1383 iocbq->context2 = lpfc_sli_get_buff(phba, pring,
1384 irsp->un.ulpWord[3]);
1385 if (!iocbq->context2)
1386 lpfc_printf_log(phba,
1389 "0343 Ring %d Cannot find "
1390 "buffer for an unsolicited iocb"
1391 ". tag 0x%x\n", pring->ringno,
1392 irsp->un.ulpWord[3]);
1394 if (irsp->ulpBdeCount == 2) {
1395 iocbq->context3 = lpfc_sli_get_buff(phba, pring,
1396 irsp->unsli3.sli3Words[7]);
1397 if (!iocbq->context3)
1398 lpfc_printf_log(phba,
1401 "0344 Ring %d Cannot find "
1402 "buffer for an unsolicited "
1405 irsp->unsli3.sli3Words[7]);
1409 if (irsp->ulpBdeCount != 0 &&
1410 (irsp->ulpCommand == CMD_IOCB_RCV_CONT64_CX ||
1411 irsp->ulpStatus == IOSTAT_INTERMED_RSP)) {
1414 /* search continue save q for same XRI */
1415 list_for_each_entry(iocbq, &pring->iocb_continue_saveq, clist) {
1416 if (iocbq->iocb.ulpContext == saveq->iocb.ulpContext) {
1417 list_add_tail(&saveq->list, &iocbq->list);
1423 list_add_tail(&saveq->clist,
1424 &pring->iocb_continue_saveq);
1425 if (saveq->iocb.ulpStatus != IOSTAT_INTERMED_RSP) {
1426 list_del_init(&iocbq->clist);
1428 irsp = &(saveq->iocb);
1432 if ((irsp->ulpCommand == CMD_RCV_ELS_REQ64_CX) ||
1433 (irsp->ulpCommand == CMD_RCV_ELS_REQ_CX) ||
1434 (irsp->ulpCommand == CMD_IOCB_RCV_ELS64_CX)) {
1438 w5p = (WORD5 *)&(saveq->iocb.un.ulpWord[5]);
1439 Rctl = w5p->hcsw.Rctl;
1440 Type = w5p->hcsw.Type;
1442 /* Firmware Workaround */
1443 if ((Rctl == 0) && (pring->ringno == LPFC_ELS_RING) &&
1444 (irsp->ulpCommand == CMD_RCV_SEQUENCE64_CX ||
1445 irsp->ulpCommand == CMD_IOCB_RCV_SEQ64_CX)) {
1448 w5p->hcsw.Rctl = Rctl;
1449 w5p->hcsw.Type = Type;
1453 /* unSolicited Responses */
1454 if (pring->prt[0].profile) {
1455 if (pring->prt[0].lpfc_sli_rcv_unsol_event)
1456 (pring->prt[0].lpfc_sli_rcv_unsol_event) (phba, pring,
1460 /* We must search, based on rctl / type
1461 for the right routine */
1462 for (i = 0; i < pring->num_mask; i++) {
1463 if ((pring->prt[i].rctl == Rctl)
1464 && (pring->prt[i].type == Type)) {
1465 if (pring->prt[i].lpfc_sli_rcv_unsol_event)
1466 (pring->prt[i].lpfc_sli_rcv_unsol_event)
1467 (phba, pring, saveq);
1474 /* Unexpected Rctl / Type received */
1475 /* Ring <ringno> handler: unexpected
1476 Rctl <Rctl> Type <Type> received */
1477 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1478 "0313 Ring %d handler: unexpected Rctl x%x "
1479 "Type x%x received\n",
1480 pring->ringno, Rctl, Type);
1486 * lpfc_sli_iocbq_lookup - Find command iocb for the given response iocb
1487 * @phba: Pointer to HBA context object.
1488 * @pring: Pointer to driver SLI ring object.
1489 * @prspiocb: Pointer to response iocb object.
1491 * This function looks up the iocb_lookup table to get the command iocb
1492 * corresponding to the given response iocb using the iotag of the
1493 * response iocb. This function is called with the hbalock held.
1494 * This function returns the command iocb object if it finds the command
1495 * iocb else returns NULL.
1497 static struct lpfc_iocbq *
1498 lpfc_sli_iocbq_lookup(struct lpfc_hba *phba,
1499 struct lpfc_sli_ring *pring,
1500 struct lpfc_iocbq *prspiocb)
1502 struct lpfc_iocbq *cmd_iocb = NULL;
1505 iotag = prspiocb->iocb.ulpIoTag;
1507 if (iotag != 0 && iotag <= phba->sli.last_iotag) {
1508 cmd_iocb = phba->sli.iocbq_lookup[iotag];
1509 list_del_init(&cmd_iocb->list);
1510 pring->txcmplq_cnt--;
1514 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1515 "0317 iotag x%x is out off "
1516 "range: max iotag x%x wd0 x%x\n",
1517 iotag, phba->sli.last_iotag,
1518 *(((uint32_t *) &prspiocb->iocb) + 7));
1523 * lpfc_sli_process_sol_iocb - process solicited iocb completion
1524 * @phba: Pointer to HBA context object.
1525 * @pring: Pointer to driver SLI ring object.
1526 * @saveq: Pointer to the response iocb to be processed.
1528 * This function is called by the ring event handler for non-fcp
1529 * rings when there is a new response iocb in the response ring.
1530 * The caller is not required to hold any locks. This function
1531 * gets the command iocb associated with the response iocb and
1532 * calls the completion handler for the command iocb. If there
1533 * is no completion handler, the function will free the resources
1534 * associated with command iocb. If the response iocb is for
1535 * an already aborted command iocb, the status of the completion
1536 * is changed to IOSTAT_LOCAL_REJECT/IOERR_SLI_ABORTED.
1537 * This function always returns 1.
1540 lpfc_sli_process_sol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1541 struct lpfc_iocbq *saveq)
1543 struct lpfc_iocbq *cmdiocbp;
1545 unsigned long iflag;
1547 /* Based on the iotag field, get the cmd IOCB from the txcmplq */
1548 spin_lock_irqsave(&phba->hbalock, iflag);
1549 cmdiocbp = lpfc_sli_iocbq_lookup(phba, pring, saveq);
1550 spin_unlock_irqrestore(&phba->hbalock, iflag);
1553 if (cmdiocbp->iocb_cmpl) {
1555 * If an ELS command failed send an event to mgmt
1558 if (saveq->iocb.ulpStatus &&
1559 (pring->ringno == LPFC_ELS_RING) &&
1560 (cmdiocbp->iocb.ulpCommand ==
1561 CMD_ELS_REQUEST64_CR))
1562 lpfc_send_els_failure_event(phba,
1566 * Post all ELS completions to the worker thread.
1567 * All other are passed to the completion callback.
1569 if (pring->ringno == LPFC_ELS_RING) {
1570 if (cmdiocbp->iocb_flag & LPFC_DRIVER_ABORTED) {
1571 cmdiocbp->iocb_flag &=
1572 ~LPFC_DRIVER_ABORTED;
1573 saveq->iocb.ulpStatus =
1574 IOSTAT_LOCAL_REJECT;
1575 saveq->iocb.un.ulpWord[4] =
1578 /* Firmware could still be in progress
1579 * of DMAing payload, so don't free data
1580 * buffer till after a hbeat.
1582 saveq->iocb_flag |= LPFC_DELAY_MEM_FREE;
1585 (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
1587 lpfc_sli_release_iocbq(phba, cmdiocbp);
1590 * Unknown initiating command based on the response iotag.
1591 * This could be the case on the ELS ring because of
1594 if (pring->ringno != LPFC_ELS_RING) {
1596 * Ring <ringno> handler: unexpected completion IoTag
1599 lpfc_printf_vlog(cmdiocbp->vport, KERN_WARNING, LOG_SLI,
1600 "0322 Ring %d handler: "
1601 "unexpected completion IoTag x%x "
1602 "Data: x%x x%x x%x x%x\n",
1604 saveq->iocb.ulpIoTag,
1605 saveq->iocb.ulpStatus,
1606 saveq->iocb.un.ulpWord[4],
1607 saveq->iocb.ulpCommand,
1608 saveq->iocb.ulpContext);
1616 * lpfc_sli_rsp_pointers_error - Response ring pointer error handler
1617 * @phba: Pointer to HBA context object.
1618 * @pring: Pointer to driver SLI ring object.
1620 * This function is called from the iocb ring event handlers when
1621 * put pointer is ahead of the get pointer for a ring. This function signal
1622 * an error attention condition to the worker thread and the worker
1623 * thread will transition the HBA to offline state.
1626 lpfc_sli_rsp_pointers_error(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1628 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1630 * Ring <ringno> handler: portRspPut <portRspPut> is bigger than
1631 * rsp ring <portRspMax>
1633 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1634 "0312 Ring %d handler: portRspPut %d "
1635 "is bigger than rsp ring %d\n",
1636 pring->ringno, le32_to_cpu(pgp->rspPutInx),
1639 phba->link_state = LPFC_HBA_ERROR;
1642 * All error attention handlers are posted to
1645 phba->work_ha |= HA_ERATT;
1646 phba->work_hs = HS_FFER3;
1648 lpfc_worker_wake_up(phba);
1654 * lpfc_poll_eratt - Error attention polling timer timeout handler
1655 * @ptr: Pointer to address of HBA context object.
1657 * This function is invoked by the Error Attention polling timer when the
1658 * timer times out. It will check the SLI Error Attention register for
1659 * possible attention events. If so, it will post an Error Attention event
1660 * and wake up worker thread to process it. Otherwise, it will set up the
1661 * Error Attention polling timer for the next poll.
1663 void lpfc_poll_eratt(unsigned long ptr)
1665 struct lpfc_hba *phba;
1668 phba = (struct lpfc_hba *)ptr;
1670 /* Check chip HA register for error event */
1671 eratt = lpfc_sli_check_eratt(phba);
1674 /* Tell the worker thread there is work to do */
1675 lpfc_worker_wake_up(phba);
1677 /* Restart the timer for next eratt poll */
1678 mod_timer(&phba->eratt_poll, jiffies +
1679 HZ * LPFC_ERATT_POLL_INTERVAL);
1684 * lpfc_sli_poll_fcp_ring - Handle FCP ring completion in polling mode
1685 * @phba: Pointer to HBA context object.
1687 * This function is called from lpfc_queuecommand, lpfc_poll_timeout,
1688 * lpfc_abort_handler and lpfc_slave_configure when FCP_RING_POLLING
1691 * The caller does not hold any lock.
1692 * The function processes each response iocb in the response ring until it
1693 * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
1694 * LE bit set. The function will call the completion handler of the command iocb
1695 * if the response iocb indicates a completion for a command iocb or it is
1696 * an abort completion.
1698 void lpfc_sli_poll_fcp_ring(struct lpfc_hba *phba)
1700 struct lpfc_sli *psli = &phba->sli;
1701 struct lpfc_sli_ring *pring = &psli->ring[LPFC_FCP_RING];
1702 IOCB_t *irsp = NULL;
1703 IOCB_t *entry = NULL;
1704 struct lpfc_iocbq *cmdiocbq = NULL;
1705 struct lpfc_iocbq rspiocbq;
1706 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1708 uint32_t portRspPut, portRspMax;
1710 uint32_t rsp_cmpl = 0;
1712 unsigned long iflags;
1714 pring->stats.iocb_event++;
1717 * The next available response entry should never exceed the maximum
1718 * entries. If it does, treat it as an adapter hardware error.
1720 portRspMax = pring->numRiocb;
1721 portRspPut = le32_to_cpu(pgp->rspPutInx);
1722 if (unlikely(portRspPut >= portRspMax)) {
1723 lpfc_sli_rsp_pointers_error(phba, pring);
1728 while (pring->rspidx != portRspPut) {
1729 entry = lpfc_resp_iocb(phba, pring);
1730 if (++pring->rspidx >= portRspMax)
1733 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
1734 (uint32_t *) &rspiocbq.iocb,
1735 phba->iocb_rsp_size);
1736 irsp = &rspiocbq.iocb;
1737 type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
1738 pring->stats.iocb_rsp++;
1741 if (unlikely(irsp->ulpStatus)) {
1742 /* Rsp ring <ringno> error: IOCB */
1743 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1744 "0326 Rsp Ring %d error: IOCB Data: "
1745 "x%x x%x x%x x%x x%x x%x x%x x%x\n",
1747 irsp->un.ulpWord[0],
1748 irsp->un.ulpWord[1],
1749 irsp->un.ulpWord[2],
1750 irsp->un.ulpWord[3],
1751 irsp->un.ulpWord[4],
1752 irsp->un.ulpWord[5],
1753 *(uint32_t *)&irsp->un1,
1754 *((uint32_t *)&irsp->un1 + 1));
1758 case LPFC_ABORT_IOCB:
1761 * Idle exchange closed via ABTS from port. No iocb
1762 * resources need to be recovered.
1764 if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
1765 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1766 "0314 IOCB cmd 0x%x "
1767 "processed. Skipping "
1773 spin_lock_irqsave(&phba->hbalock, iflags);
1774 cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1776 spin_unlock_irqrestore(&phba->hbalock, iflags);
1777 if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
1778 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1783 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
1784 char adaptermsg[LPFC_MAX_ADPTMSG];
1785 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
1786 memcpy(&adaptermsg[0], (uint8_t *) irsp,
1788 dev_warn(&((phba->pcidev)->dev),
1790 phba->brd_no, adaptermsg);
1792 /* Unknown IOCB command */
1793 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1794 "0321 Unknown IOCB command "
1795 "Data: x%x, x%x x%x x%x x%x\n",
1796 type, irsp->ulpCommand,
1805 * The response IOCB has been processed. Update the ring
1806 * pointer in SLIM. If the port response put pointer has not
1807 * been updated, sync the pgp->rspPutInx and fetch the new port
1808 * response put pointer.
1810 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
1812 if (pring->rspidx == portRspPut)
1813 portRspPut = le32_to_cpu(pgp->rspPutInx);
1816 ha_copy = readl(phba->HAregaddr);
1817 ha_copy >>= (LPFC_FCP_RING * 4);
1819 if ((rsp_cmpl > 0) && (ha_copy & HA_R0RE_REQ)) {
1820 spin_lock_irqsave(&phba->hbalock, iflags);
1821 pring->stats.iocb_rsp_full++;
1822 status = ((CA_R0ATT | CA_R0RE_RSP) << (LPFC_FCP_RING * 4));
1823 writel(status, phba->CAregaddr);
1824 readl(phba->CAregaddr);
1825 spin_unlock_irqrestore(&phba->hbalock, iflags);
1827 if ((ha_copy & HA_R0CE_RSP) &&
1828 (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
1829 spin_lock_irqsave(&phba->hbalock, iflags);
1830 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
1831 pring->stats.iocb_cmd_empty++;
1833 /* Force update of the local copy of cmdGetInx */
1834 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
1835 lpfc_sli_resume_iocb(phba, pring);
1837 if ((pring->lpfc_sli_cmd_available))
1838 (pring->lpfc_sli_cmd_available) (phba, pring);
1840 spin_unlock_irqrestore(&phba->hbalock, iflags);
1847 * lpfc_sli_handle_fast_ring_event - Handle ring events on FCP ring
1848 * @phba: Pointer to HBA context object.
1849 * @pring: Pointer to driver SLI ring object.
1850 * @mask: Host attention register mask for this ring.
1852 * This function is called from the interrupt context when there is a ring
1853 * event for the fcp ring. The caller does not hold any lock.
1854 * The function processes each response iocb in the response ring until it
1855 * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
1856 * LE bit set. The function will call the completion handler of the command iocb
1857 * if the response iocb indicates a completion for a command iocb or it is
1858 * an abort completion. The function will call lpfc_sli_process_unsol_iocb
1859 * function if this is an unsolicited iocb.
1860 * This routine presumes LPFC_FCP_RING handling and doesn't bother
1861 * to check it explicitly. This function always returns 1.
1864 lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
1865 struct lpfc_sli_ring *pring, uint32_t mask)
1867 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1868 IOCB_t *irsp = NULL;
1869 IOCB_t *entry = NULL;
1870 struct lpfc_iocbq *cmdiocbq = NULL;
1871 struct lpfc_iocbq rspiocbq;
1873 uint32_t portRspPut, portRspMax;
1875 lpfc_iocb_type type;
1876 unsigned long iflag;
1877 uint32_t rsp_cmpl = 0;
1879 spin_lock_irqsave(&phba->hbalock, iflag);
1880 pring->stats.iocb_event++;
1883 * The next available response entry should never exceed the maximum
1884 * entries. If it does, treat it as an adapter hardware error.
1886 portRspMax = pring->numRiocb;
1887 portRspPut = le32_to_cpu(pgp->rspPutInx);
1888 if (unlikely(portRspPut >= portRspMax)) {
1889 lpfc_sli_rsp_pointers_error(phba, pring);
1890 spin_unlock_irqrestore(&phba->hbalock, iflag);
1895 while (pring->rspidx != portRspPut) {
1897 * Fetch an entry off the ring and copy it into a local data
1898 * structure. The copy involves a byte-swap since the
1899 * network byte order and pci byte orders are different.
1901 entry = lpfc_resp_iocb(phba, pring);
1902 phba->last_completion_time = jiffies;
1904 if (++pring->rspidx >= portRspMax)
1907 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
1908 (uint32_t *) &rspiocbq.iocb,
1909 phba->iocb_rsp_size);
1910 INIT_LIST_HEAD(&(rspiocbq.list));
1911 irsp = &rspiocbq.iocb;
1913 type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
1914 pring->stats.iocb_rsp++;
1917 if (unlikely(irsp->ulpStatus)) {
1919 * If resource errors reported from HBA, reduce
1920 * queuedepths of the SCSI device.
1922 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1923 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
1924 spin_unlock_irqrestore(&phba->hbalock, iflag);
1925 lpfc_rampdown_queue_depth(phba);
1926 spin_lock_irqsave(&phba->hbalock, iflag);
1929 /* Rsp ring <ringno> error: IOCB */
1930 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1931 "0336 Rsp Ring %d error: IOCB Data: "
1932 "x%x x%x x%x x%x x%x x%x x%x x%x\n",
1934 irsp->un.ulpWord[0],
1935 irsp->un.ulpWord[1],
1936 irsp->un.ulpWord[2],
1937 irsp->un.ulpWord[3],
1938 irsp->un.ulpWord[4],
1939 irsp->un.ulpWord[5],
1940 *(uint32_t *)&irsp->un1,
1941 *((uint32_t *)&irsp->un1 + 1));
1945 case LPFC_ABORT_IOCB:
1948 * Idle exchange closed via ABTS from port. No iocb
1949 * resources need to be recovered.
1951 if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
1952 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1953 "0333 IOCB cmd 0x%x"
1954 " processed. Skipping"
1960 cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1962 if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
1963 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
1964 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1967 spin_unlock_irqrestore(&phba->hbalock,
1969 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1971 spin_lock_irqsave(&phba->hbalock,
1976 case LPFC_UNSOL_IOCB:
1977 spin_unlock_irqrestore(&phba->hbalock, iflag);
1978 lpfc_sli_process_unsol_iocb(phba, pring, &rspiocbq);
1979 spin_lock_irqsave(&phba->hbalock, iflag);
1982 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
1983 char adaptermsg[LPFC_MAX_ADPTMSG];
1984 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
1985 memcpy(&adaptermsg[0], (uint8_t *) irsp,
1987 dev_warn(&((phba->pcidev)->dev),
1989 phba->brd_no, adaptermsg);
1991 /* Unknown IOCB command */
1992 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1993 "0334 Unknown IOCB command "
1994 "Data: x%x, x%x x%x x%x x%x\n",
1995 type, irsp->ulpCommand,
2004 * The response IOCB has been processed. Update the ring
2005 * pointer in SLIM. If the port response put pointer has not
2006 * been updated, sync the pgp->rspPutInx and fetch the new port
2007 * response put pointer.
2009 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
2011 if (pring->rspidx == portRspPut)
2012 portRspPut = le32_to_cpu(pgp->rspPutInx);
2015 if ((rsp_cmpl > 0) && (mask & HA_R0RE_REQ)) {
2016 pring->stats.iocb_rsp_full++;
2017 status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
2018 writel(status, phba->CAregaddr);
2019 readl(phba->CAregaddr);
2021 if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
2022 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
2023 pring->stats.iocb_cmd_empty++;
2025 /* Force update of the local copy of cmdGetInx */
2026 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
2027 lpfc_sli_resume_iocb(phba, pring);
2029 if ((pring->lpfc_sli_cmd_available))
2030 (pring->lpfc_sli_cmd_available) (phba, pring);
2034 spin_unlock_irqrestore(&phba->hbalock, iflag);
2039 * lpfc_sli_handle_slow_ring_event - Handle ring events for non-FCP rings
2040 * @phba: Pointer to HBA context object.
2041 * @pring: Pointer to driver SLI ring object.
2042 * @mask: Host attention register mask for this ring.
2044 * This function is called from the worker thread when there is a ring
2045 * event for non-fcp rings. The caller does not hold any lock .
2046 * The function processes each response iocb in the response ring until it
2047 * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
2048 * LE bit set. The function will call lpfc_sli_process_sol_iocb function if the
2049 * response iocb indicates a completion of a command iocb. The function
2050 * will call lpfc_sli_process_unsol_iocb function if this is an unsolicited
2051 * iocb. The function frees the resources or calls the completion handler if
2052 * this iocb is an abort completion. The function returns 0 when the allocated
2053 * iocbs are not freed, otherwise returns 1.
2056 lpfc_sli_handle_slow_ring_event(struct lpfc_hba *phba,
2057 struct lpfc_sli_ring *pring, uint32_t mask)
2059 struct lpfc_pgp *pgp;
2061 IOCB_t *irsp = NULL;
2062 struct lpfc_iocbq *rspiocbp = NULL;
2063 struct lpfc_iocbq *next_iocb;
2064 struct lpfc_iocbq *cmdiocbp;
2065 struct lpfc_iocbq *saveq;
2066 uint8_t iocb_cmd_type;
2067 lpfc_iocb_type type;
2068 uint32_t status, free_saveq;
2069 uint32_t portRspPut, portRspMax;
2071 unsigned long iflag;
2073 pgp = &phba->port_gp[pring->ringno];
2074 spin_lock_irqsave(&phba->hbalock, iflag);
2075 pring->stats.iocb_event++;
2078 * The next available response entry should never exceed the maximum
2079 * entries. If it does, treat it as an adapter hardware error.
2081 portRspMax = pring->numRiocb;
2082 portRspPut = le32_to_cpu(pgp->rspPutInx);
2083 if (portRspPut >= portRspMax) {
2085 * Ring <ringno> handler: portRspPut <portRspPut> is bigger than
2086 * rsp ring <portRspMax>
2088 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2089 "0303 Ring %d handler: portRspPut %d "
2090 "is bigger than rsp ring %d\n",
2091 pring->ringno, portRspPut, portRspMax);
2093 phba->link_state = LPFC_HBA_ERROR;
2094 spin_unlock_irqrestore(&phba->hbalock, iflag);
2096 phba->work_hs = HS_FFER3;
2097 lpfc_handle_eratt(phba);
2103 while (pring->rspidx != portRspPut) {
2105 * Build a completion list and call the appropriate handler.
2106 * The process is to get the next available response iocb, get
2107 * a free iocb from the list, copy the response data into the
2108 * free iocb, insert to the continuation list, and update the
2109 * next response index to slim. This process makes response
2110 * iocb's in the ring available to DMA as fast as possible but
2111 * pays a penalty for a copy operation. Since the iocb is
2112 * only 32 bytes, this penalty is considered small relative to
2113 * the PCI reads for register values and a slim write. When
2114 * the ulpLe field is set, the entire Command has been
2117 entry = lpfc_resp_iocb(phba, pring);
2119 phba->last_completion_time = jiffies;
2120 rspiocbp = __lpfc_sli_get_iocbq(phba);
2121 if (rspiocbp == NULL) {
2122 printk(KERN_ERR "%s: out of buffers! Failing "
2123 "completion.\n", __func__);
2127 lpfc_sli_pcimem_bcopy(entry, &rspiocbp->iocb,
2128 phba->iocb_rsp_size);
2129 irsp = &rspiocbp->iocb;
2131 if (++pring->rspidx >= portRspMax)
2134 if (pring->ringno == LPFC_ELS_RING) {
2135 lpfc_debugfs_slow_ring_trc(phba,
2136 "IOCB rsp ring: wd4:x%08x wd6:x%08x wd7:x%08x",
2137 *(((uint32_t *) irsp) + 4),
2138 *(((uint32_t *) irsp) + 6),
2139 *(((uint32_t *) irsp) + 7));
2142 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
2144 list_add_tail(&rspiocbp->list, &(pring->iocb_continueq));
2146 pring->iocb_continueq_cnt++;
2149 * By default, the driver expects to free all resources
2150 * associated with this iocb completion.
2153 saveq = list_get_first(&pring->iocb_continueq,
2154 struct lpfc_iocbq, list);
2155 irsp = &(saveq->iocb);
2156 list_del_init(&pring->iocb_continueq);
2157 pring->iocb_continueq_cnt = 0;
2159 pring->stats.iocb_rsp++;
2162 * If resource errors reported from HBA, reduce
2163 * queuedepths of the SCSI device.
2165 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
2166 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
2167 spin_unlock_irqrestore(&phba->hbalock, iflag);
2168 lpfc_rampdown_queue_depth(phba);
2169 spin_lock_irqsave(&phba->hbalock, iflag);
2172 if (irsp->ulpStatus) {
2173 /* Rsp ring <ringno> error: IOCB */
2174 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
2175 "0328 Rsp Ring %d error: "
2180 "x%x x%x x%x x%x\n",
2182 irsp->un.ulpWord[0],
2183 irsp->un.ulpWord[1],
2184 irsp->un.ulpWord[2],
2185 irsp->un.ulpWord[3],
2186 irsp->un.ulpWord[4],
2187 irsp->un.ulpWord[5],
2188 *(((uint32_t *) irsp) + 6),
2189 *(((uint32_t *) irsp) + 7),
2190 *(((uint32_t *) irsp) + 8),
2191 *(((uint32_t *) irsp) + 9),
2192 *(((uint32_t *) irsp) + 10),
2193 *(((uint32_t *) irsp) + 11),
2194 *(((uint32_t *) irsp) + 12),
2195 *(((uint32_t *) irsp) + 13),
2196 *(((uint32_t *) irsp) + 14),
2197 *(((uint32_t *) irsp) + 15));
2201 * Fetch the IOCB command type and call the correct
2202 * completion routine. Solicited and Unsolicited
2203 * IOCBs on the ELS ring get freed back to the
2204 * lpfc_iocb_list by the discovery kernel thread.
2206 iocb_cmd_type = irsp->ulpCommand & CMD_IOCB_MASK;
2207 type = lpfc_sli_iocb_cmd_type(iocb_cmd_type);
2208 if (type == LPFC_SOL_IOCB) {
2209 spin_unlock_irqrestore(&phba->hbalock, iflag);
2210 rc = lpfc_sli_process_sol_iocb(phba, pring,
2212 spin_lock_irqsave(&phba->hbalock, iflag);
2213 } else if (type == LPFC_UNSOL_IOCB) {
2214 spin_unlock_irqrestore(&phba->hbalock, iflag);
2215 rc = lpfc_sli_process_unsol_iocb(phba, pring,
2217 spin_lock_irqsave(&phba->hbalock, iflag);
2220 } else if (type == LPFC_ABORT_IOCB) {
2221 if ((irsp->ulpCommand != CMD_XRI_ABORTED_CX) &&
2223 lpfc_sli_iocbq_lookup(phba, pring,
2225 /* Call the specified completion
2227 if (cmdiocbp->iocb_cmpl) {
2228 spin_unlock_irqrestore(
2231 (cmdiocbp->iocb_cmpl) (phba,
2237 __lpfc_sli_release_iocbq(phba,
2240 } else if (type == LPFC_UNKNOWN_IOCB) {
2241 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
2243 char adaptermsg[LPFC_MAX_ADPTMSG];
2245 memset(adaptermsg, 0,
2247 memcpy(&adaptermsg[0], (uint8_t *) irsp,
2249 dev_warn(&((phba->pcidev)->dev),
2251 phba->brd_no, adaptermsg);
2253 /* Unknown IOCB command */
2254 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2255 "0335 Unknown IOCB "
2256 "command Data: x%x "
2266 list_for_each_entry_safe(rspiocbp, next_iocb,
2267 &saveq->list, list) {
2268 list_del(&rspiocbp->list);
2269 __lpfc_sli_release_iocbq(phba,
2272 __lpfc_sli_release_iocbq(phba, saveq);
2278 * If the port response put pointer has not been updated, sync
2279 * the pgp->rspPutInx in the MAILBOX_tand fetch the new port
2280 * response put pointer.
2282 if (pring->rspidx == portRspPut) {
2283 portRspPut = le32_to_cpu(pgp->rspPutInx);
2285 } /* while (pring->rspidx != portRspPut) */
2287 if ((rspiocbp != NULL) && (mask & HA_R0RE_REQ)) {
2288 /* At least one response entry has been freed */
2289 pring->stats.iocb_rsp_full++;
2290 /* SET RxRE_RSP in Chip Att register */
2291 status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
2292 writel(status, phba->CAregaddr);
2293 readl(phba->CAregaddr); /* flush */
2295 if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
2296 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
2297 pring->stats.iocb_cmd_empty++;
2299 /* Force update of the local copy of cmdGetInx */
2300 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
2301 lpfc_sli_resume_iocb(phba, pring);
2303 if ((pring->lpfc_sli_cmd_available))
2304 (pring->lpfc_sli_cmd_available) (phba, pring);
2308 spin_unlock_irqrestore(&phba->hbalock, iflag);
2313 * lpfc_sli_abort_iocb_ring - Abort all iocbs in the ring
2314 * @phba: Pointer to HBA context object.
2315 * @pring: Pointer to driver SLI ring object.
2317 * This function aborts all iocbs in the given ring and frees all the iocb
2318 * objects in txq. This function issues an abort iocb for all the iocb commands
2319 * in txcmplq. The iocbs in the txcmplq is not guaranteed to complete before
2320 * the return of this function. The caller is not required to hold any locks.
2323 lpfc_sli_abort_iocb_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
2325 LIST_HEAD(completions);
2326 struct lpfc_iocbq *iocb, *next_iocb;
2329 if (pring->ringno == LPFC_ELS_RING) {
2330 lpfc_fabric_abort_hba(phba);
2333 /* Error everything on txq and txcmplq
2336 spin_lock_irq(&phba->hbalock);
2337 list_splice_init(&pring->txq, &completions);
2340 /* Next issue ABTS for everything on the txcmplq */
2341 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list)
2342 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
2344 spin_unlock_irq(&phba->hbalock);
2346 while (!list_empty(&completions)) {
2347 iocb = list_get_first(&completions, struct lpfc_iocbq, list);
2349 list_del_init(&iocb->list);
2351 if (!iocb->iocb_cmpl)
2352 lpfc_sli_release_iocbq(phba, iocb);
2354 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
2355 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
2356 (iocb->iocb_cmpl) (phba, iocb, iocb);
2362 * lpfc_sli_flush_fcp_rings - flush all iocbs in the fcp ring
2363 * @phba: Pointer to HBA context object.
2365 * This function flushes all iocbs in the fcp ring and frees all the iocb
2366 * objects in txq and txcmplq. This function will not issue abort iocbs
2367 * for all the iocb commands in txcmplq, they will just be returned with
2368 * IOERR_SLI_DOWN. This function is invoked with EEH when device's PCI
2369 * slot has been permanently disabled.
2372 lpfc_sli_flush_fcp_rings(struct lpfc_hba *phba)
2376 struct lpfc_iocbq *iocb;
2378 struct lpfc_sli *psli = &phba->sli;
2379 struct lpfc_sli_ring *pring;
2381 /* Currently, only one fcp ring */
2382 pring = &psli->ring[psli->fcp_ring];
2384 spin_lock_irq(&phba->hbalock);
2385 /* Retrieve everything on txq */
2386 list_splice_init(&pring->txq, &txq);
2389 /* Retrieve everything on the txcmplq */
2390 list_splice_init(&pring->txcmplq, &txcmplq);
2391 pring->txcmplq_cnt = 0;
2392 spin_unlock_irq(&phba->hbalock);
2395 while (!list_empty(&txq)) {
2396 iocb = list_get_first(&txq, struct lpfc_iocbq, list);
2398 list_del_init(&iocb->list);
2400 if (!iocb->iocb_cmpl)
2401 lpfc_sli_release_iocbq(phba, iocb);
2403 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
2404 cmd->un.ulpWord[4] = IOERR_SLI_DOWN;
2405 (iocb->iocb_cmpl) (phba, iocb, iocb);
2409 /* Flush the txcmpq */
2410 while (!list_empty(&txcmplq)) {
2411 iocb = list_get_first(&txcmplq, struct lpfc_iocbq, list);
2413 list_del_init(&iocb->list);
2415 if (!iocb->iocb_cmpl)
2416 lpfc_sli_release_iocbq(phba, iocb);
2418 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
2419 cmd->un.ulpWord[4] = IOERR_SLI_DOWN;
2420 (iocb->iocb_cmpl) (phba, iocb, iocb);
2426 * lpfc_sli_brdready - Check for host status bits
2427 * @phba: Pointer to HBA context object.
2428 * @mask: Bit mask to be checked.
2430 * This function reads the host status register and compares
2431 * with the provided bit mask to check if HBA completed
2432 * the restart. This function will wait in a loop for the
2433 * HBA to complete restart. If the HBA does not restart within
2434 * 15 iterations, the function will reset the HBA again. The
2435 * function returns 1 when HBA fail to restart otherwise returns
2439 lpfc_sli_brdready(struct lpfc_hba *phba, uint32_t mask)
2445 /* Read the HBA Host Status Register */
2446 status = readl(phba->HSregaddr);
2449 * Check status register every 100ms for 5 retries, then every
2450 * 500ms for 5, then every 2.5 sec for 5, then reset board and
2451 * every 2.5 sec for 4.
2452 * Break our of the loop if errors occurred during init.
2454 while (((status & mask) != mask) &&
2455 !(status & HS_FFERM) &&
2467 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
2468 lpfc_sli_brdrestart(phba);
2470 /* Read the HBA Host Status Register */
2471 status = readl(phba->HSregaddr);
2474 /* Check to see if any errors occurred during init */
2475 if ((status & HS_FFERM) || (i >= 20)) {
2476 phba->link_state = LPFC_HBA_ERROR;
2483 #define BARRIER_TEST_PATTERN (0xdeadbeef)
2486 * lpfc_reset_barrier - Make HBA ready for HBA reset
2487 * @phba: Pointer to HBA context object.
2489 * This function is called before resetting an HBA. This
2490 * function requests HBA to quiesce DMAs before a reset.
2492 void lpfc_reset_barrier(struct lpfc_hba *phba)
2494 uint32_t __iomem *resp_buf;
2495 uint32_t __iomem *mbox_buf;
2496 volatile uint32_t mbox;
2501 pci_read_config_byte(phba->pcidev, PCI_HEADER_TYPE, &hdrtype);
2502 if (hdrtype != 0x80 ||
2503 (FC_JEDEC_ID(phba->vpd.rev.biuRev) != HELIOS_JEDEC_ID &&
2504 FC_JEDEC_ID(phba->vpd.rev.biuRev) != THOR_JEDEC_ID))
2508 * Tell the other part of the chip to suspend temporarily all
2511 resp_buf = phba->MBslimaddr;
2513 /* Disable the error attention */
2514 hc_copy = readl(phba->HCregaddr);
2515 writel((hc_copy & ~HC_ERINT_ENA), phba->HCregaddr);
2516 readl(phba->HCregaddr); /* flush */
2517 phba->link_flag |= LS_IGNORE_ERATT;
2519 if (readl(phba->HAregaddr) & HA_ERATT) {
2520 /* Clear Chip error bit */
2521 writel(HA_ERATT, phba->HAregaddr);
2522 phba->pport->stopped = 1;
2526 ((MAILBOX_t *)&mbox)->mbxCommand = MBX_KILL_BOARD;
2527 ((MAILBOX_t *)&mbox)->mbxOwner = OWN_CHIP;
2529 writel(BARRIER_TEST_PATTERN, (resp_buf + 1));
2530 mbox_buf = phba->MBslimaddr;
2531 writel(mbox, mbox_buf);
2534 readl(resp_buf + 1) != ~(BARRIER_TEST_PATTERN) && i < 50; i++)
2537 if (readl(resp_buf + 1) != ~(BARRIER_TEST_PATTERN)) {
2538 if (phba->sli.sli_flag & LPFC_SLI2_ACTIVE ||
2539 phba->pport->stopped)
2545 ((MAILBOX_t *)&mbox)->mbxOwner = OWN_HOST;
2546 for (i = 0; readl(resp_buf) != mbox && i < 500; i++)
2551 while (!(readl(phba->HAregaddr) & HA_ERATT) && ++i < 500)
2554 if (readl(phba->HAregaddr) & HA_ERATT) {
2555 writel(HA_ERATT, phba->HAregaddr);
2556 phba->pport->stopped = 1;
2560 phba->link_flag &= ~LS_IGNORE_ERATT;
2561 writel(hc_copy, phba->HCregaddr);
2562 readl(phba->HCregaddr); /* flush */
2566 * lpfc_sli_brdkill - Issue a kill_board mailbox command
2567 * @phba: Pointer to HBA context object.
2569 * This function issues a kill_board mailbox command and waits for
2570 * the error attention interrupt. This function is called for stopping
2571 * the firmware processing. The caller is not required to hold any
2572 * locks. This function calls lpfc_hba_down_post function to free
2573 * any pending commands after the kill. The function will return 1 when it
2574 * fails to kill the board else will return 0.
2577 lpfc_sli_brdkill(struct lpfc_hba *phba)
2579 struct lpfc_sli *psli;
2589 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2590 "0329 Kill HBA Data: x%x x%x\n",
2591 phba->pport->port_state, psli->sli_flag);
2593 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2597 /* Disable the error attention */
2598 spin_lock_irq(&phba->hbalock);
2599 status = readl(phba->HCregaddr);
2600 status &= ~HC_ERINT_ENA;
2601 writel(status, phba->HCregaddr);
2602 readl(phba->HCregaddr); /* flush */
2603 phba->link_flag |= LS_IGNORE_ERATT;
2604 spin_unlock_irq(&phba->hbalock);
2606 lpfc_kill_board(phba, pmb);
2607 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2608 retval = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
2610 if (retval != MBX_SUCCESS) {
2611 if (retval != MBX_BUSY)
2612 mempool_free(pmb, phba->mbox_mem_pool);
2613 spin_lock_irq(&phba->hbalock);
2614 phba->link_flag &= ~LS_IGNORE_ERATT;
2615 spin_unlock_irq(&phba->hbalock);
2619 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
2621 mempool_free(pmb, phba->mbox_mem_pool);
2623 /* There is no completion for a KILL_BOARD mbox cmd. Check for an error
2624 * attention every 100ms for 3 seconds. If we don't get ERATT after
2625 * 3 seconds we still set HBA_ERROR state because the status of the
2626 * board is now undefined.
2628 ha_copy = readl(phba->HAregaddr);
2630 while ((i++ < 30) && !(ha_copy & HA_ERATT)) {
2632 ha_copy = readl(phba->HAregaddr);
2635 del_timer_sync(&psli->mbox_tmo);
2636 if (ha_copy & HA_ERATT) {
2637 writel(HA_ERATT, phba->HAregaddr);
2638 phba->pport->stopped = 1;
2640 spin_lock_irq(&phba->hbalock);
2641 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
2642 phba->link_flag &= ~LS_IGNORE_ERATT;
2643 spin_unlock_irq(&phba->hbalock);
2645 psli->mbox_active = NULL;
2646 lpfc_hba_down_post(phba);
2647 phba->link_state = LPFC_HBA_ERROR;
2649 return ha_copy & HA_ERATT ? 0 : 1;
2653 * lpfc_sli_brdreset - Reset the HBA
2654 * @phba: Pointer to HBA context object.
2656 * This function resets the HBA by writing HC_INITFF to the control
2657 * register. After the HBA resets, this function resets all the iocb ring
2658 * indices. This function disables PCI layer parity checking during
2660 * This function returns 0 always.
2661 * The caller is not required to hold any locks.
2664 lpfc_sli_brdreset(struct lpfc_hba *phba)
2666 struct lpfc_sli *psli;
2667 struct lpfc_sli_ring *pring;
2674 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2675 "0325 Reset HBA Data: x%x x%x\n",
2676 phba->pport->port_state, psli->sli_flag);
2678 /* perform board reset */
2679 phba->fc_eventTag = 0;
2680 phba->pport->fc_myDID = 0;
2681 phba->pport->fc_prevDID = 0;
2683 /* Turn off parity checking and serr during the physical reset */
2684 pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value);
2685 pci_write_config_word(phba->pcidev, PCI_COMMAND,
2687 ~(PCI_COMMAND_PARITY | PCI_COMMAND_SERR)));
2689 psli->sli_flag &= ~(LPFC_SLI2_ACTIVE | LPFC_PROCESS_LA);
2690 /* Now toggle INITFF bit in the Host Control Register */
2691 writel(HC_INITFF, phba->HCregaddr);
2693 readl(phba->HCregaddr); /* flush */
2694 writel(0, phba->HCregaddr);
2695 readl(phba->HCregaddr); /* flush */
2697 /* Restore PCI cmd register */
2698 pci_write_config_word(phba->pcidev, PCI_COMMAND, cfg_value);
2700 /* Initialize relevant SLI info */
2701 for (i = 0; i < psli->num_rings; i++) {
2702 pring = &psli->ring[i];
2705 pring->next_cmdidx = 0;
2706 pring->local_getidx = 0;
2708 pring->missbufcnt = 0;
2711 phba->link_state = LPFC_WARM_START;
2716 * lpfc_sli_brdrestart - Restart the HBA
2717 * @phba: Pointer to HBA context object.
2719 * This function is called in the SLI initialization code path to
2720 * restart the HBA. The caller is not required to hold any lock.
2721 * This function writes MBX_RESTART mailbox command to the SLIM and
2722 * resets the HBA. At the end of the function, it calls lpfc_hba_down_post
2723 * function to free any pending commands. The function enables
2724 * POST only during the first initialization. The function returns zero.
2725 * The function does not guarantee completion of MBX_RESTART mailbox
2726 * command before the return of this function.
2729 lpfc_sli_brdrestart(struct lpfc_hba *phba)
2732 struct lpfc_sli *psli;
2733 volatile uint32_t word0;
2734 void __iomem *to_slim;
2736 spin_lock_irq(&phba->hbalock);
2741 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2742 "0337 Restart HBA Data: x%x x%x\n",
2743 phba->pport->port_state, psli->sli_flag);
2746 mb = (MAILBOX_t *) &word0;
2747 mb->mbxCommand = MBX_RESTART;
2750 lpfc_reset_barrier(phba);
2752 to_slim = phba->MBslimaddr;
2753 writel(*(uint32_t *) mb, to_slim);
2754 readl(to_slim); /* flush */
2756 /* Only skip post after fc_ffinit is completed */
2757 if (phba->pport->port_state)
2758 word0 = 1; /* This is really setting up word1 */
2760 word0 = 0; /* This is really setting up word1 */
2761 to_slim = phba->MBslimaddr + sizeof (uint32_t);
2762 writel(*(uint32_t *) mb, to_slim);
2763 readl(to_slim); /* flush */
2765 lpfc_sli_brdreset(phba);
2766 phba->pport->stopped = 0;
2767 phba->link_state = LPFC_INIT_START;
2769 spin_unlock_irq(&phba->hbalock);
2771 memset(&psli->lnk_stat_offsets, 0, sizeof(psli->lnk_stat_offsets));
2772 psli->stats_start = get_seconds();
2774 /* Give the INITFF and Post time to settle. */
2777 lpfc_hba_down_post(phba);
2783 * lpfc_sli_chipset_init - Wait for the restart of the HBA after a restart
2784 * @phba: Pointer to HBA context object.
2786 * This function is called after a HBA restart to wait for successful
2787 * restart of the HBA. Successful restart of the HBA is indicated by
2788 * HS_FFRDY and HS_MBRDY bits. If the HBA fails to restart even after 15
2789 * iteration, the function will restart the HBA again. The function returns
2790 * zero if HBA successfully restarted else returns negative error code.
2793 lpfc_sli_chipset_init(struct lpfc_hba *phba)
2795 uint32_t status, i = 0;
2797 /* Read the HBA Host Status Register */
2798 status = readl(phba->HSregaddr);
2800 /* Check status register to see what current state is */
2802 while ((status & (HS_FFRDY | HS_MBRDY)) != (HS_FFRDY | HS_MBRDY)) {
2804 /* Check every 100ms for 5 retries, then every 500ms for 5, then
2805 * every 2.5 sec for 5, then reset board and every 2.5 sec for
2809 /* Adapter failed to init, timeout, status reg
2811 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2812 "0436 Adapter failed to init, "
2813 "timeout, status reg x%x, "
2814 "FW Data: A8 x%x AC x%x\n", status,
2815 readl(phba->MBslimaddr + 0xa8),
2816 readl(phba->MBslimaddr + 0xac));
2817 phba->link_state = LPFC_HBA_ERROR;
2821 /* Check to see if any errors occurred during init */
2822 if (status & HS_FFERM) {
2823 /* ERROR: During chipset initialization */
2824 /* Adapter failed to init, chipset, status reg
2826 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2827 "0437 Adapter failed to init, "
2828 "chipset, status reg x%x, "
2829 "FW Data: A8 x%x AC x%x\n", status,
2830 readl(phba->MBslimaddr + 0xa8),
2831 readl(phba->MBslimaddr + 0xac));
2832 phba->link_state = LPFC_HBA_ERROR;
2838 } else if (i <= 10) {
2846 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
2847 lpfc_sli_brdrestart(phba);
2849 /* Read the HBA Host Status Register */
2850 status = readl(phba->HSregaddr);
2853 /* Check to see if any errors occurred during init */
2854 if (status & HS_FFERM) {
2855 /* ERROR: During chipset initialization */
2856 /* Adapter failed to init, chipset, status reg <status> */
2857 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2858 "0438 Adapter failed to init, chipset, "
2860 "FW Data: A8 x%x AC x%x\n", status,
2861 readl(phba->MBslimaddr + 0xa8),
2862 readl(phba->MBslimaddr + 0xac));
2863 phba->link_state = LPFC_HBA_ERROR;
2867 /* Clear all interrupt enable conditions */
2868 writel(0, phba->HCregaddr);
2869 readl(phba->HCregaddr); /* flush */
2871 /* setup host attn register */
2872 writel(0xffffffff, phba->HAregaddr);
2873 readl(phba->HAregaddr); /* flush */
2878 * lpfc_sli_hbq_count - Get the number of HBQs to be configured
2880 * This function calculates and returns the number of HBQs required to be
2884 lpfc_sli_hbq_count(void)
2886 return ARRAY_SIZE(lpfc_hbq_defs);
2890 * lpfc_sli_hbq_entry_count - Calculate total number of hbq entries
2892 * This function adds the number of hbq entries in every HBQ to get
2893 * the total number of hbq entries required for the HBA and returns
2897 lpfc_sli_hbq_entry_count(void)
2899 int hbq_count = lpfc_sli_hbq_count();
2903 for (i = 0; i < hbq_count; ++i)
2904 count += lpfc_hbq_defs[i]->entry_count;
2909 * lpfc_sli_hbq_size - Calculate memory required for all hbq entries
2911 * This function calculates amount of memory required for all hbq entries
2912 * to be configured and returns the total memory required.
2915 lpfc_sli_hbq_size(void)
2917 return lpfc_sli_hbq_entry_count() * sizeof(struct lpfc_hbq_entry);
2921 * lpfc_sli_hbq_setup - configure and initialize HBQs
2922 * @phba: Pointer to HBA context object.
2924 * This function is called during the SLI initialization to configure
2925 * all the HBQs and post buffers to the HBQ. The caller is not
2926 * required to hold any locks. This function will return zero if successful
2927 * else it will return negative error code.
2930 lpfc_sli_hbq_setup(struct lpfc_hba *phba)
2932 int hbq_count = lpfc_sli_hbq_count();
2936 uint32_t hbq_entry_index;
2938 /* Get a Mailbox buffer to setup mailbox
2939 * commands for HBA initialization
2941 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2948 /* Initialize the struct lpfc_sli_hbq structure for each hbq */
2949 phba->link_state = LPFC_INIT_MBX_CMDS;
2950 phba->hbq_in_use = 1;
2952 hbq_entry_index = 0;
2953 for (hbqno = 0; hbqno < hbq_count; ++hbqno) {
2954 phba->hbqs[hbqno].next_hbqPutIdx = 0;
2955 phba->hbqs[hbqno].hbqPutIdx = 0;
2956 phba->hbqs[hbqno].local_hbqGetIdx = 0;
2957 phba->hbqs[hbqno].entry_count =
2958 lpfc_hbq_defs[hbqno]->entry_count;
2959 lpfc_config_hbq(phba, hbqno, lpfc_hbq_defs[hbqno],
2960 hbq_entry_index, pmb);
2961 hbq_entry_index += phba->hbqs[hbqno].entry_count;
2963 if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
2964 /* Adapter failed to init, mbxCmd <cmd> CFG_RING,
2965 mbxStatus <status>, ring <num> */
2967 lpfc_printf_log(phba, KERN_ERR,
2968 LOG_SLI | LOG_VPORT,
2969 "1805 Adapter failed to init. "
2970 "Data: x%x x%x x%x\n",
2972 pmbox->mbxStatus, hbqno);
2974 phba->link_state = LPFC_HBA_ERROR;
2975 mempool_free(pmb, phba->mbox_mem_pool);
2979 phba->hbq_count = hbq_count;
2981 mempool_free(pmb, phba->mbox_mem_pool);
2983 /* Initially populate or replenish the HBQs */
2984 for (hbqno = 0; hbqno < hbq_count; ++hbqno)
2985 lpfc_sli_hbqbuf_init_hbqs(phba, hbqno);
2990 * lpfc_sli_config_port - Issue config port mailbox command
2991 * @phba: Pointer to HBA context object.
2992 * @sli_mode: sli mode - 2/3
2994 * This function is called by the sli intialization code path
2995 * to issue config_port mailbox command. This function restarts the
2996 * HBA firmware and issues a config_port mailbox command to configure
2997 * the SLI interface in the sli mode specified by sli_mode
2998 * variable. The caller is not required to hold any locks.
2999 * The function returns 0 if successful, else returns negative error
3003 lpfc_sli_config_port(struct lpfc_hba *phba, int sli_mode)
3006 uint32_t resetcount = 0, rc = 0, done = 0;
3008 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3010 phba->link_state = LPFC_HBA_ERROR;
3014 phba->sli_rev = sli_mode;
3015 while (resetcount < 2 && !done) {
3016 spin_lock_irq(&phba->hbalock);
3017 phba->sli.sli_flag |= LPFC_SLI_MBOX_ACTIVE;
3018 spin_unlock_irq(&phba->hbalock);
3019 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
3020 lpfc_sli_brdrestart(phba);
3021 rc = lpfc_sli_chipset_init(phba);
3025 spin_lock_irq(&phba->hbalock);
3026 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3027 spin_unlock_irq(&phba->hbalock);
3030 /* Call pre CONFIG_PORT mailbox command initialization. A
3031 * value of 0 means the call was successful. Any other
3032 * nonzero value is a failure, but if ERESTART is returned,
3033 * the driver may reset the HBA and try again.
3035 rc = lpfc_config_port_prep(phba);
3036 if (rc == -ERESTART) {
3037 phba->link_state = LPFC_LINK_UNKNOWN;
3041 phba->link_state = LPFC_INIT_MBX_CMDS;
3042 lpfc_config_port(phba, pmb);
3043 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
3044 phba->sli3_options &= ~(LPFC_SLI3_NPIV_ENABLED |
3045 LPFC_SLI3_HBQ_ENABLED |
3046 LPFC_SLI3_CRP_ENABLED |
3047 LPFC_SLI3_INB_ENABLED |
3048 LPFC_SLI3_BG_ENABLED);
3049 if (rc != MBX_SUCCESS) {
3050 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3051 "0442 Adapter failed to init, mbxCmd x%x "
3052 "CONFIG_PORT, mbxStatus x%x Data: x%x\n",
3053 pmb->mb.mbxCommand, pmb->mb.mbxStatus, 0);
3054 spin_lock_irq(&phba->hbalock);
3055 phba->sli.sli_flag &= ~LPFC_SLI2_ACTIVE;
3056 spin_unlock_irq(&phba->hbalock);
3063 goto do_prep_failed;
3065 if (pmb->mb.un.varCfgPort.sli_mode == 3) {
3066 if (!pmb->mb.un.varCfgPort.cMA) {
3068 goto do_prep_failed;
3070 if (phba->max_vpi && pmb->mb.un.varCfgPort.gmv) {
3071 phba->sli3_options |= LPFC_SLI3_NPIV_ENABLED;
3072 phba->max_vpi = pmb->mb.un.varCfgPort.max_vpi;
3075 if (pmb->mb.un.varCfgPort.gerbm)
3076 phba->sli3_options |= LPFC_SLI3_HBQ_ENABLED;
3077 if (pmb->mb.un.varCfgPort.gcrp)
3078 phba->sli3_options |= LPFC_SLI3_CRP_ENABLED;
3079 if (pmb->mb.un.varCfgPort.ginb) {
3080 phba->sli3_options |= LPFC_SLI3_INB_ENABLED;
3081 phba->hbq_get = phba->mbox->us.s3_inb_pgp.hbq_get;
3082 phba->port_gp = phba->mbox->us.s3_inb_pgp.port;
3083 phba->inb_ha_copy = &phba->mbox->us.s3_inb_pgp.ha_copy;
3084 phba->inb_counter = &phba->mbox->us.s3_inb_pgp.counter;
3085 phba->inb_last_counter =
3086 phba->mbox->us.s3_inb_pgp.counter;
3088 phba->hbq_get = phba->mbox->us.s3_pgp.hbq_get;
3089 phba->port_gp = phba->mbox->us.s3_pgp.port;
3090 phba->inb_ha_copy = NULL;
3091 phba->inb_counter = NULL;
3094 if (phba->cfg_enable_bg) {
3095 if (pmb->mb.un.varCfgPort.gbg)
3096 phba->sli3_options |= LPFC_SLI3_BG_ENABLED;
3098 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3099 "0443 Adapter did not grant "
3103 phba->hbq_get = NULL;
3104 phba->port_gp = phba->mbox->us.s2.port;
3105 phba->inb_ha_copy = NULL;
3106 phba->inb_counter = NULL;
3110 mempool_free(pmb, phba->mbox_mem_pool);
3116 * lpfc_sli_hba_setup - SLI intialization function
3117 * @phba: Pointer to HBA context object.
3119 * This function is the main SLI intialization function. This function
3120 * is called by the HBA intialization code, HBA reset code and HBA
3121 * error attention handler code. Caller is not required to hold any
3122 * locks. This function issues config_port mailbox command to configure
3123 * the SLI, setup iocb rings and HBQ rings. In the end the function
3124 * calls the config_port_post function to issue init_link mailbox
3125 * command and to start the discovery. The function will return zero
3126 * if successful, else it will return negative error code.
3129 lpfc_sli_hba_setup(struct lpfc_hba *phba)
3134 switch (lpfc_sli_mode) {
3136 if (phba->cfg_enable_npiv) {
3137 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3138 "1824 NPIV enabled: Override lpfc_sli_mode "
3139 "parameter (%d) to auto (0).\n",
3149 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3150 "1819 Unrecognized lpfc_sli_mode "
3151 "parameter: %d.\n", lpfc_sli_mode);
3156 rc = lpfc_sli_config_port(phba, mode);
3158 if (rc && lpfc_sli_mode == 3)
3159 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3160 "1820 Unable to select SLI-3. "
3161 "Not supported by adapter.\n");
3162 if (rc && mode != 2)
3163 rc = lpfc_sli_config_port(phba, 2);
3165 goto lpfc_sli_hba_setup_error;
3167 if (phba->sli_rev == 3) {
3168 phba->iocb_cmd_size = SLI3_IOCB_CMD_SIZE;
3169 phba->iocb_rsp_size = SLI3_IOCB_RSP_SIZE;
3171 phba->iocb_cmd_size = SLI2_IOCB_CMD_SIZE;
3172 phba->iocb_rsp_size = SLI2_IOCB_RSP_SIZE;
3173 phba->sli3_options = 0;
3176 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3177 "0444 Firmware in SLI %x mode. Max_vpi %d\n",
3178 phba->sli_rev, phba->max_vpi);
3179 rc = lpfc_sli_ring_map(phba);
3182 goto lpfc_sli_hba_setup_error;
3185 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
3186 rc = lpfc_sli_hbq_setup(phba);
3188 goto lpfc_sli_hba_setup_error;
3191 phba->sli.sli_flag |= LPFC_PROCESS_LA;
3193 rc = lpfc_config_port_post(phba);
3195 goto lpfc_sli_hba_setup_error;
3199 lpfc_sli_hba_setup_error:
3200 phba->link_state = LPFC_HBA_ERROR;
3201 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3202 "0445 Firmware initialization failed\n");
3208 * lpfc_mbox_timeout - Timeout call back function for mbox timer
3209 * @ptr: context object - pointer to hba structure.
3211 * This is the callback function for mailbox timer. The mailbox
3212 * timer is armed when a new mailbox command is issued and the timer
3213 * is deleted when the mailbox complete. The function is called by
3214 * the kernel timer code when a mailbox does not complete within
3215 * expected time. This function wakes up the worker thread to
3216 * process the mailbox timeout and returns. All the processing is
3217 * done by the worker thread function lpfc_mbox_timeout_handler.
3220 lpfc_mbox_timeout(unsigned long ptr)
3222 struct lpfc_hba *phba = (struct lpfc_hba *) ptr;
3223 unsigned long iflag;
3224 uint32_t tmo_posted;
3226 spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
3227 tmo_posted = phba->pport->work_port_events & WORKER_MBOX_TMO;
3229 phba->pport->work_port_events |= WORKER_MBOX_TMO;
3230 spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
3233 lpfc_worker_wake_up(phba);
3239 * lpfc_mbox_timeout_handler - Worker thread function to handle mailbox timeout
3240 * @phba: Pointer to HBA context object.
3242 * This function is called from worker thread when a mailbox command times out.
3243 * The caller is not required to hold any locks. This function will reset the
3244 * HBA and recover all the pending commands.
3247 lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
3249 LPFC_MBOXQ_t *pmbox = phba->sli.mbox_active;
3250 MAILBOX_t *mb = &pmbox->mb;
3251 struct lpfc_sli *psli = &phba->sli;
3252 struct lpfc_sli_ring *pring;
3254 /* Mbox cmd <mbxCommand> timeout */
3255 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3256 "0310 Mailbox command x%x timeout Data: x%x x%x x%p\n",
3258 phba->pport->port_state,
3260 phba->sli.mbox_active);
3262 /* Setting state unknown so lpfc_sli_abort_iocb_ring
3263 * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
3264 * it to fail all oustanding SCSI IO.
3266 spin_lock_irq(&phba->pport->work_port_lock);
3267 phba->pport->work_port_events &= ~WORKER_MBOX_TMO;
3268 spin_unlock_irq(&phba->pport->work_port_lock);
3269 spin_lock_irq(&phba->hbalock);
3270 phba->link_state = LPFC_LINK_UNKNOWN;
3271 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
3272 spin_unlock_irq(&phba->hbalock);
3274 pring = &psli->ring[psli->fcp_ring];
3275 lpfc_sli_abort_iocb_ring(phba, pring);
3277 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3278 "0345 Resetting board due to mailbox timeout\n");
3280 * lpfc_offline calls lpfc_sli_hba_down which will clean up
3281 * on oustanding mailbox commands.
3283 /* If resets are disabled then set error state and return. */
3284 if (!phba->cfg_enable_hba_reset) {
3285 phba->link_state = LPFC_HBA_ERROR;
3288 lpfc_offline_prep(phba);
3290 lpfc_sli_brdrestart(phba);
3292 lpfc_unblock_mgmt_io(phba);
3297 * lpfc_sli_issue_mbox - Issue a mailbox command to firmware
3298 * @phba: Pointer to HBA context object.
3299 * @pmbox: Pointer to mailbox object.
3300 * @flag: Flag indicating how the mailbox need to be processed.
3302 * This function is called by discovery code and HBA management code
3303 * to submit a mailbox command to firmware. This function gets the
3304 * hbalock to protect the data structures.
3305 * The mailbox command can be submitted in polling mode, in which case
3306 * this function will wait in a polling loop for the completion of the
3308 * If the mailbox is submitted in no_wait mode (not polling) the
3309 * function will submit the command and returns immediately without waiting
3310 * for the mailbox completion. The no_wait is supported only when HBA
3311 * is in SLI2/SLI3 mode - interrupts are enabled.
3312 * The SLI interface allows only one mailbox pending at a time. If the
3313 * mailbox is issued in polling mode and there is already a mailbox
3314 * pending, then the function will return an error. If the mailbox is issued
3315 * in NO_WAIT mode and there is a mailbox pending already, the function
3316 * will return MBX_BUSY after queuing the mailbox into mailbox queue.
3317 * The sli layer owns the mailbox object until the completion of mailbox
3318 * command if this function return MBX_BUSY or MBX_SUCCESS. For all other
3319 * return codes the caller owns the mailbox command after the return of
3323 lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3326 struct lpfc_sli *psli = &phba->sli;
3327 uint32_t status, evtctr;
3330 unsigned long timeout;
3331 unsigned long drvr_flag = 0;
3332 uint32_t word0, ldata;
3333 void __iomem *to_slim;
3334 int processing_queue = 0;
3336 spin_lock_irqsave(&phba->hbalock, drvr_flag);
3338 /* processing mbox queue from intr_handler */
3339 processing_queue = 1;
3340 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3341 pmbox = lpfc_mbox_get(phba);
3343 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3348 if (pmbox->mbox_cmpl && pmbox->mbox_cmpl != lpfc_sli_def_mbox_cmpl &&
3349 pmbox->mbox_cmpl != lpfc_sli_wake_mbox_wait) {
3351 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3352 lpfc_printf_log(phba, KERN_ERR,
3353 LOG_MBOX | LOG_VPORT,
3354 "1806 Mbox x%x failed. No vport\n",
3355 pmbox->mb.mbxCommand);
3357 goto out_not_finished;
3361 /* If the PCI channel is in offline state, do not post mbox. */
3362 if (unlikely(pci_channel_offline(phba->pcidev))) {
3363 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3364 goto out_not_finished;
3370 status = MBX_SUCCESS;
3372 if (phba->link_state == LPFC_HBA_ERROR) {
3373 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3375 /* Mbox command <mbxCommand> cannot issue */
3376 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3377 goto out_not_finished;
3380 if (mb->mbxCommand != MBX_KILL_BOARD && flag & MBX_NOWAIT &&
3381 !(readl(phba->HCregaddr) & HC_MBINT_ENA)) {
3382 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3383 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3384 goto out_not_finished;
3387 if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {
3388 /* Polling for a mbox command when another one is already active
3389 * is not allowed in SLI. Also, the driver must have established
3390 * SLI2 mode to queue and process multiple mbox commands.
3393 if (flag & MBX_POLL) {
3394 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3396 /* Mbox command <mbxCommand> cannot issue */
3397 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3398 goto out_not_finished;
3401 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE)) {
3402 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3403 /* Mbox command <mbxCommand> cannot issue */
3404 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3405 goto out_not_finished;
3408 /* Another mailbox command is still being processed, queue this
3409 * command to be processed later.
3411 lpfc_mbox_put(phba, pmbox);
3413 /* Mbox cmd issue - BUSY */
3414 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
3415 "(%d):0308 Mbox cmd issue - BUSY Data: "
3416 "x%x x%x x%x x%x\n",
3417 pmbox->vport ? pmbox->vport->vpi : 0xffffff,
3418 mb->mbxCommand, phba->pport->port_state,
3419 psli->sli_flag, flag);
3421 psli->slistat.mbox_busy++;
3422 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3425 lpfc_debugfs_disc_trc(pmbox->vport,
3426 LPFC_DISC_TRC_MBOX_VPORT,
3427 "MBOX Bsy vport: cmd:x%x mb:x%x x%x",
3428 (uint32_t)mb->mbxCommand,
3429 mb->un.varWords[0], mb->un.varWords[1]);
3432 lpfc_debugfs_disc_trc(phba->pport,
3434 "MBOX Bsy: cmd:x%x mb:x%x x%x",
3435 (uint32_t)mb->mbxCommand,
3436 mb->un.varWords[0], mb->un.varWords[1]);
3442 psli->sli_flag |= LPFC_SLI_MBOX_ACTIVE;
3444 /* If we are not polling, we MUST be in SLI2 mode */
3445 if (flag != MBX_POLL) {
3446 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE) &&
3447 (mb->mbxCommand != MBX_KILL_BOARD)) {
3448 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3449 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3450 /* Mbox command <mbxCommand> cannot issue */
3451 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3452 goto out_not_finished;
3454 /* timeout active mbox command */
3455 mod_timer(&psli->mbox_tmo, (jiffies +
3456 (HZ * lpfc_mbox_tmo_val(phba, mb->mbxCommand))));
3459 /* Mailbox cmd <cmd> issue */
3460 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
3461 "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
3463 pmbox->vport ? pmbox->vport->vpi : 0,
3464 mb->mbxCommand, phba->pport->port_state,
3465 psli->sli_flag, flag);
3467 if (mb->mbxCommand != MBX_HEARTBEAT) {
3469 lpfc_debugfs_disc_trc(pmbox->vport,
3470 LPFC_DISC_TRC_MBOX_VPORT,
3471 "MBOX Send vport: cmd:x%x mb:x%x x%x",
3472 (uint32_t)mb->mbxCommand,
3473 mb->un.varWords[0], mb->un.varWords[1]);
3476 lpfc_debugfs_disc_trc(phba->pport,
3478 "MBOX Send: cmd:x%x mb:x%x x%x",
3479 (uint32_t)mb->mbxCommand,
3480 mb->un.varWords[0], mb->un.varWords[1]);
3484 psli->slistat.mbox_cmd++;
3485 evtctr = psli->slistat.mbox_event;
3487 /* next set own bit for the adapter and copy over command word */
3488 mb->mbxOwner = OWN_CHIP;
3490 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3491 /* First copy command data to host SLIM area */
3492 lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE);
3494 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3495 /* copy command data into host mbox for cmpl */
3496 lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE);
3499 /* First copy mbox command data to HBA SLIM, skip past first
3501 to_slim = phba->MBslimaddr + sizeof (uint32_t);
3502 lpfc_memcpy_to_slim(to_slim, &mb->un.varWords[0],
3503 MAILBOX_CMD_SIZE - sizeof (uint32_t));
3505 /* Next copy over first word, with mbxOwner set */
3506 ldata = *((uint32_t *)mb);
3507 to_slim = phba->MBslimaddr;
3508 writel(ldata, to_slim);
3509 readl(to_slim); /* flush */
3511 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3512 /* switch over to host mailbox */
3513 psli->sli_flag |= LPFC_SLI2_ACTIVE;
3521 /* Set up reference to mailbox command */
3522 psli->mbox_active = pmbox;
3523 /* Interrupt board to do it */
3524 writel(CA_MBATT, phba->CAregaddr);
3525 readl(phba->CAregaddr); /* flush */
3526 /* Don't wait for it to finish, just return */
3530 /* Set up null reference to mailbox command */
3531 psli->mbox_active = NULL;
3532 /* Interrupt board to do it */
3533 writel(CA_MBATT, phba->CAregaddr);
3534 readl(phba->CAregaddr); /* flush */
3536 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3537 /* First read mbox status word */
3538 word0 = *((uint32_t *)phba->mbox);
3539 word0 = le32_to_cpu(word0);
3541 /* First read mbox status word */
3542 word0 = readl(phba->MBslimaddr);
3545 /* Read the HBA Host Attention Register */
3546 ha_copy = readl(phba->HAregaddr);
3547 timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba,
3551 /* Wait for command to complete */
3552 while (((word0 & OWN_CHIP) == OWN_CHIP) ||
3553 (!(ha_copy & HA_MBATT) &&
3554 (phba->link_state > LPFC_WARM_START))) {
3555 if (time_after(jiffies, timeout)) {
3556 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3557 spin_unlock_irqrestore(&phba->hbalock,
3559 goto out_not_finished;
3562 /* Check if we took a mbox interrupt while we were
3564 if (((word0 & OWN_CHIP) != OWN_CHIP)
3565 && (evtctr != psli->slistat.mbox_event))
3569 spin_unlock_irqrestore(&phba->hbalock,
3572 spin_lock_irqsave(&phba->hbalock, drvr_flag);
3575 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3576 /* First copy command data */
3577 word0 = *((uint32_t *)phba->mbox);
3578 word0 = le32_to_cpu(word0);
3579 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3582 /* Check real SLIM for any errors */
3583 slimword0 = readl(phba->MBslimaddr);
3584 slimmb = (MAILBOX_t *) & slimword0;
3585 if (((slimword0 & OWN_CHIP) != OWN_CHIP)
3586 && slimmb->mbxStatus) {
3593 /* First copy command data */
3594 word0 = readl(phba->MBslimaddr);
3596 /* Read the HBA Host Attention Register */
3597 ha_copy = readl(phba->HAregaddr);
3600 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3601 /* copy results back to user */
3602 lpfc_sli_pcimem_bcopy(phba->mbox, mb, MAILBOX_CMD_SIZE);
3604 /* First copy command data */
3605 lpfc_memcpy_from_slim(mb, phba->MBslimaddr,
3607 if ((mb->mbxCommand == MBX_DUMP_MEMORY) &&
3609 lpfc_memcpy_from_slim((void *)pmbox->context2,
3610 phba->MBslimaddr + DMP_RSP_OFFSET,
3611 mb->un.varDmp.word_cnt);
3615 writel(HA_MBATT, phba->HAregaddr);
3616 readl(phba->HAregaddr); /* flush */
3618 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3619 status = mb->mbxStatus;
3622 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3626 if (processing_queue) {
3627 pmbox->mb.mbxStatus = MBX_NOT_FINISHED;
3628 lpfc_mbox_cmpl_put(phba, pmbox);
3630 return MBX_NOT_FINISHED;
3634 * __lpfc_sli_ringtx_put - Add an iocb to the txq
3635 * @phba: Pointer to HBA context object.
3636 * @pring: Pointer to driver SLI ring object.
3637 * @piocb: Pointer to address of newly added command iocb.
3639 * This function is called with hbalock held to add a command
3640 * iocb to the txq when SLI layer cannot submit the command iocb
3644 __lpfc_sli_ringtx_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3645 struct lpfc_iocbq *piocb)
3647 /* Insert the caller's iocb in the txq tail for later processing. */
3648 list_add_tail(&piocb->list, &pring->txq);
3653 * lpfc_sli_next_iocb - Get the next iocb in the txq
3654 * @phba: Pointer to HBA context object.
3655 * @pring: Pointer to driver SLI ring object.
3656 * @piocb: Pointer to address of newly added command iocb.
3658 * This function is called with hbalock held before a new
3659 * iocb is submitted to the firmware. This function checks
3660 * txq to flush the iocbs in txq to Firmware before
3661 * submitting new iocbs to the Firmware.
3662 * If there are iocbs in the txq which need to be submitted
3663 * to firmware, lpfc_sli_next_iocb returns the first element
3664 * of the txq after dequeuing it from txq.
3665 * If there is no iocb in the txq then the function will return
3666 * *piocb and *piocb is set to NULL. Caller needs to check
3667 * *piocb to find if there are more commands in the txq.
3669 static struct lpfc_iocbq *
3670 lpfc_sli_next_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3671 struct lpfc_iocbq **piocb)
3673 struct lpfc_iocbq * nextiocb;
3675 nextiocb = lpfc_sli_ringtx_get(phba, pring);
3685 * __lpfc_sli_issue_iocb - Lockless version of lpfc_sli_issue_iocb
3686 * @phba: Pointer to HBA context object.
3687 * @pring: Pointer to driver SLI ring object.
3688 * @piocb: Pointer to command iocb.
3689 * @flag: Flag indicating if this command can be put into txq.
3691 * __lpfc_sli_issue_iocb is used by other functions in the driver
3692 * to issue an iocb command to the HBA. If the PCI slot is recovering
3693 * from error state or if HBA is resetting or if LPFC_STOP_IOCB_EVENT
3694 * flag is turned on, the function returns IOCB_ERROR.
3695 * When the link is down, this function allows only iocbs for
3697 * This function finds next available slot in the command ring and
3698 * posts the command to the available slot and writes the port
3699 * attention register to request HBA start processing new iocb.
3700 * If there is no slot available in the ring and
3701 * flag & SLI_IOCB_RET_IOCB is set, the new iocb is added to the
3702 * txq, otherwise the function returns IOCB_BUSY.
3704 * This function is called with hbalock held.
3705 * The function will return success after it successfully submit the
3706 * iocb to firmware or after adding to the txq.
3709 __lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3710 struct lpfc_iocbq *piocb, uint32_t flag)
3712 struct lpfc_iocbq *nextiocb;
3715 if (piocb->iocb_cmpl && (!piocb->vport) &&
3716 (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
3717 (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN)) {
3718 lpfc_printf_log(phba, KERN_ERR,
3719 LOG_SLI | LOG_VPORT,
3720 "1807 IOCB x%x failed. No vport\n",
3721 piocb->iocb.ulpCommand);
3727 /* If the PCI channel is in offline state, do not post iocbs. */
3728 if (unlikely(pci_channel_offline(phba->pcidev)))
3732 * We should never get an IOCB if we are in a < LINK_DOWN state
3734 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
3738 * Check to see if we are blocking IOCB processing because of a
3739 * outstanding event.
3741 if (unlikely(pring->flag & LPFC_STOP_IOCB_EVENT))
3744 if (unlikely(phba->link_state == LPFC_LINK_DOWN)) {
3746 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
3747 * can be issued if the link is not up.
3749 switch (piocb->iocb.ulpCommand) {
3750 case CMD_GEN_REQUEST64_CR:
3751 case CMD_GEN_REQUEST64_CX:
3752 if (!(phba->sli.sli_flag & LPFC_MENLO_MAINT) ||
3753 (piocb->iocb.un.genreq64.w5.hcsw.Rctl !=
3755 (piocb->iocb.un.genreq64.w5.hcsw.Type !=
3756 MENLO_TRANSPORT_TYPE))
3760 case CMD_QUE_RING_BUF_CN:
3761 case CMD_QUE_RING_BUF64_CN:
3763 * For IOCBs, like QUE_RING_BUF, that have no rsp ring
3764 * completion, iocb_cmpl MUST be 0.
3766 if (piocb->iocb_cmpl)
3767 piocb->iocb_cmpl = NULL;
3769 case CMD_CREATE_XRI_CR:
3770 case CMD_CLOSE_XRI_CN:
3771 case CMD_CLOSE_XRI_CX:
3778 * For FCP commands, we must be in a state where we can process link
3781 } else if (unlikely(pring->ringno == phba->sli.fcp_ring &&
3782 !(phba->sli.sli_flag & LPFC_PROCESS_LA))) {
3786 while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
3787 (nextiocb = lpfc_sli_next_iocb(phba, pring, &piocb)))
3788 lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
3791 lpfc_sli_update_ring(phba, pring);
3793 lpfc_sli_update_full_ring(phba, pring);
3796 return IOCB_SUCCESS;
3801 pring->stats.iocb_cmd_delay++;
3805 if (!(flag & SLI_IOCB_RET_IOCB)) {
3806 __lpfc_sli_ringtx_put(phba, pring, piocb);
3807 return IOCB_SUCCESS;
3815 * lpfc_sli_issue_iocb - Wrapper function for __lpfc_sli_issue_iocb
3816 * @phba: Pointer to HBA context object.
3817 * @pring: Pointer to driver SLI ring object.
3818 * @piocb: Pointer to command iocb.
3819 * @flag: Flag indicating if this command can be put into txq.
3821 * lpfc_sli_issue_iocb is a wrapper around __lpfc_sli_issue_iocb
3822 * function. This function gets the hbalock and calls
3823 * __lpfc_sli_issue_iocb function and will return the error returned
3824 * by __lpfc_sli_issue_iocb function. This wrapper is used by
3825 * functions which do not hold hbalock.
3828 lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3829 struct lpfc_iocbq *piocb, uint32_t flag)
3831 unsigned long iflags;
3834 spin_lock_irqsave(&phba->hbalock, iflags);
3835 rc = __lpfc_sli_issue_iocb(phba, pring, piocb, flag);
3836 spin_unlock_irqrestore(&phba->hbalock, iflags);
3842 * lpfc_extra_ring_setup - Extra ring setup function
3843 * @phba: Pointer to HBA context object.
3845 * This function is called while driver attaches with the
3846 * HBA to setup the extra ring. The extra ring is used
3847 * only when driver needs to support target mode functionality
3848 * or IP over FC functionalities.
3850 * This function is called with no lock held.
3853 lpfc_extra_ring_setup( struct lpfc_hba *phba)
3855 struct lpfc_sli *psli;
3856 struct lpfc_sli_ring *pring;
3860 /* Adjust cmd/rsp ring iocb entries more evenly */
3862 /* Take some away from the FCP ring */
3863 pring = &psli->ring[psli->fcp_ring];
3864 pring->numCiocb -= SLI2_IOCB_CMD_R1XTRA_ENTRIES;
3865 pring->numRiocb -= SLI2_IOCB_RSP_R1XTRA_ENTRIES;
3866 pring->numCiocb -= SLI2_IOCB_CMD_R3XTRA_ENTRIES;
3867 pring->numRiocb -= SLI2_IOCB_RSP_R3XTRA_ENTRIES;
3869 /* and give them to the extra ring */
3870 pring = &psli->ring[psli->extra_ring];
3872 pring->numCiocb += SLI2_IOCB_CMD_R1XTRA_ENTRIES;
3873 pring->numRiocb += SLI2_IOCB_RSP_R1XTRA_ENTRIES;
3874 pring->numCiocb += SLI2_IOCB_CMD_R3XTRA_ENTRIES;
3875 pring->numRiocb += SLI2_IOCB_RSP_R3XTRA_ENTRIES;
3877 /* Setup default profile for this ring */
3878 pring->iotag_max = 4096;
3879 pring->num_mask = 1;
3880 pring->prt[0].profile = 0; /* Mask 0 */
3881 pring->prt[0].rctl = phba->cfg_multi_ring_rctl;
3882 pring->prt[0].type = phba->cfg_multi_ring_type;
3883 pring->prt[0].lpfc_sli_rcv_unsol_event = NULL;
3888 * lpfc_sli_async_event_handler - ASYNC iocb handler function
3889 * @phba: Pointer to HBA context object.
3890 * @pring: Pointer to driver SLI ring object.
3891 * @iocbq: Pointer to iocb object.
3893 * This function is called by the slow ring event handler
3894 * function when there is an ASYNC event iocb in the ring.
3895 * This function is called with no lock held.
3896 * Currently this function handles only temperature related
3897 * ASYNC events. The function decodes the temperature sensor
3898 * event message and posts events for the management applications.
3901 lpfc_sli_async_event_handler(struct lpfc_hba * phba,
3902 struct lpfc_sli_ring * pring, struct lpfc_iocbq * iocbq)
3907 struct temp_event temp_event_data;
3908 struct Scsi_Host *shost;
3910 icmd = &iocbq->iocb;
3911 evt_code = icmd->un.asyncstat.evt_code;
3912 temp = icmd->ulpContext;
3914 if ((evt_code != ASYNC_TEMP_WARN) &&
3915 (evt_code != ASYNC_TEMP_SAFE)) {
3916 lpfc_printf_log(phba,
3919 "0346 Ring %d handler: unexpected ASYNC_STATUS"
3922 icmd->un.asyncstat.evt_code);
3925 temp_event_data.data = (uint32_t)temp;
3926 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
3927 if (evt_code == ASYNC_TEMP_WARN) {
3928 temp_event_data.event_code = LPFC_THRESHOLD_TEMP;
3929 lpfc_printf_log(phba,
3932 "0347 Adapter is very hot, please take "
3933 "corrective action. temperature : %d Celsius\n",
3936 if (evt_code == ASYNC_TEMP_SAFE) {
3937 temp_event_data.event_code = LPFC_NORMAL_TEMP;
3938 lpfc_printf_log(phba,
3941 "0340 Adapter temperature is OK now. "
3942 "temperature : %d Celsius\n",
3946 /* Send temperature change event to applications */
3947 shost = lpfc_shost_from_vport(phba->pport);
3948 fc_host_post_vendor_event(shost, fc_get_event_number(),
3949 sizeof(temp_event_data), (char *) &temp_event_data,
3956 * lpfc_sli_setup - SLI ring setup function
3957 * @phba: Pointer to HBA context object.
3959 * lpfc_sli_setup sets up rings of the SLI interface with
3960 * number of iocbs per ring and iotags. This function is
3961 * called while driver attach to the HBA and before the
3962 * interrupts are enabled. So there is no need for locking.
3964 * This function always returns 0.
3967 lpfc_sli_setup(struct lpfc_hba *phba)
3969 int i, totiocbsize = 0;
3970 struct lpfc_sli *psli = &phba->sli;
3971 struct lpfc_sli_ring *pring;
3973 psli->num_rings = MAX_CONFIGURED_RINGS;
3975 psli->fcp_ring = LPFC_FCP_RING;
3976 psli->next_ring = LPFC_FCP_NEXT_RING;
3977 psli->extra_ring = LPFC_EXTRA_RING;
3979 psli->iocbq_lookup = NULL;
3980 psli->iocbq_lookup_len = 0;
3981 psli->last_iotag = 0;
3983 for (i = 0; i < psli->num_rings; i++) {
3984 pring = &psli->ring[i];
3986 case LPFC_FCP_RING: /* ring 0 - FCP */
3987 /* numCiocb and numRiocb are used in config_port */
3988 pring->numCiocb = SLI2_IOCB_CMD_R0_ENTRIES;
3989 pring->numRiocb = SLI2_IOCB_RSP_R0_ENTRIES;
3990 pring->numCiocb += SLI2_IOCB_CMD_R1XTRA_ENTRIES;
3991 pring->numRiocb += SLI2_IOCB_RSP_R1XTRA_ENTRIES;
3992 pring->numCiocb += SLI2_IOCB_CMD_R3XTRA_ENTRIES;
3993 pring->numRiocb += SLI2_IOCB_RSP_R3XTRA_ENTRIES;
3994 pring->sizeCiocb = (phba->sli_rev == 3) ?
3995 SLI3_IOCB_CMD_SIZE :
3997 pring->sizeRiocb = (phba->sli_rev == 3) ?
3998 SLI3_IOCB_RSP_SIZE :
4000 pring->iotag_ctr = 0;
4002 (phba->cfg_hba_queue_depth * 2);
4003 pring->fast_iotag = pring->iotag_max;
4004 pring->num_mask = 0;
4006 case LPFC_EXTRA_RING: /* ring 1 - EXTRA */
4007 /* numCiocb and numRiocb are used in config_port */
4008 pring->numCiocb = SLI2_IOCB_CMD_R1_ENTRIES;
4009 pring->numRiocb = SLI2_IOCB_RSP_R1_ENTRIES;
4010 pring->sizeCiocb = (phba->sli_rev == 3) ?
4011 SLI3_IOCB_CMD_SIZE :
4013 pring->sizeRiocb = (phba->sli_rev == 3) ?
4014 SLI3_IOCB_RSP_SIZE :
4016 pring->iotag_max = phba->cfg_hba_queue_depth;
4017 pring->num_mask = 0;
4019 case LPFC_ELS_RING: /* ring 2 - ELS / CT */
4020 /* numCiocb and numRiocb are used in config_port */
4021 pring->numCiocb = SLI2_IOCB_CMD_R2_ENTRIES;
4022 pring->numRiocb = SLI2_IOCB_RSP_R2_ENTRIES;
4023 pring->sizeCiocb = (phba->sli_rev == 3) ?
4024 SLI3_IOCB_CMD_SIZE :
4026 pring->sizeRiocb = (phba->sli_rev == 3) ?
4027 SLI3_IOCB_RSP_SIZE :
4029 pring->fast_iotag = 0;
4030 pring->iotag_ctr = 0;
4031 pring->iotag_max = 4096;
4032 pring->lpfc_sli_rcv_async_status =
4033 lpfc_sli_async_event_handler;
4034 pring->num_mask = 4;
4035 pring->prt[0].profile = 0; /* Mask 0 */
4036 pring->prt[0].rctl = FC_ELS_REQ;
4037 pring->prt[0].type = FC_ELS_DATA;
4038 pring->prt[0].lpfc_sli_rcv_unsol_event =
4039 lpfc_els_unsol_event;
4040 pring->prt[1].profile = 0; /* Mask 1 */
4041 pring->prt[1].rctl = FC_ELS_RSP;
4042 pring->prt[1].type = FC_ELS_DATA;
4043 pring->prt[1].lpfc_sli_rcv_unsol_event =
4044 lpfc_els_unsol_event;
4045 pring->prt[2].profile = 0; /* Mask 2 */
4046 /* NameServer Inquiry */
4047 pring->prt[2].rctl = FC_UNSOL_CTL;
4049 pring->prt[2].type = FC_COMMON_TRANSPORT_ULP;
4050 pring->prt[2].lpfc_sli_rcv_unsol_event =
4051 lpfc_ct_unsol_event;
4052 pring->prt[3].profile = 0; /* Mask 3 */
4053 /* NameServer response */
4054 pring->prt[3].rctl = FC_SOL_CTL;
4056 pring->prt[3].type = FC_COMMON_TRANSPORT_ULP;
4057 pring->prt[3].lpfc_sli_rcv_unsol_event =
4058 lpfc_ct_unsol_event;
4061 totiocbsize += (pring->numCiocb * pring->sizeCiocb) +
4062 (pring->numRiocb * pring->sizeRiocb);
4064 if (totiocbsize > MAX_SLIM_IOCB_SIZE) {
4065 /* Too many cmd / rsp ring entries in SLI2 SLIM */
4066 printk(KERN_ERR "%d:0462 Too many cmd / rsp ring entries in "
4067 "SLI2 SLIM Data: x%x x%lx\n",
4068 phba->brd_no, totiocbsize,
4069 (unsigned long) MAX_SLIM_IOCB_SIZE);
4071 if (phba->cfg_multi_ring_support == 2)
4072 lpfc_extra_ring_setup(phba);
4078 * lpfc_sli_queue_setup - Queue initialization function
4079 * @phba: Pointer to HBA context object.
4081 * lpfc_sli_queue_setup sets up mailbox queues and iocb queues for each
4082 * ring. This function also initializes ring indices of each ring.
4083 * This function is called during the initialization of the SLI
4084 * interface of an HBA.
4085 * This function is called with no lock held and always returns
4089 lpfc_sli_queue_setup(struct lpfc_hba *phba)
4091 struct lpfc_sli *psli;
4092 struct lpfc_sli_ring *pring;
4096 spin_lock_irq(&phba->hbalock);
4097 INIT_LIST_HEAD(&psli->mboxq);
4098 INIT_LIST_HEAD(&psli->mboxq_cmpl);
4099 /* Initialize list headers for txq and txcmplq as double linked lists */
4100 for (i = 0; i < psli->num_rings; i++) {
4101 pring = &psli->ring[i];
4103 pring->next_cmdidx = 0;
4104 pring->local_getidx = 0;
4106 INIT_LIST_HEAD(&pring->txq);
4107 INIT_LIST_HEAD(&pring->txcmplq);
4108 INIT_LIST_HEAD(&pring->iocb_continueq);
4109 INIT_LIST_HEAD(&pring->iocb_continue_saveq);
4110 INIT_LIST_HEAD(&pring->postbufq);
4112 spin_unlock_irq(&phba->hbalock);
4117 * lpfc_sli_host_down - Vport cleanup function
4118 * @vport: Pointer to virtual port object.
4120 * lpfc_sli_host_down is called to clean up the resources
4121 * associated with a vport before destroying virtual
4122 * port data structures.
4123 * This function does following operations:
4124 * - Free discovery resources associated with this virtual
4126 * - Free iocbs associated with this virtual port in
4128 * - Send abort for all iocb commands associated with this
4131 * This function is called with no lock held and always returns 1.
4134 lpfc_sli_host_down(struct lpfc_vport *vport)
4136 LIST_HEAD(completions);
4137 struct lpfc_hba *phba = vport->phba;
4138 struct lpfc_sli *psli = &phba->sli;
4139 struct lpfc_sli_ring *pring;
4140 struct lpfc_iocbq *iocb, *next_iocb;
4142 unsigned long flags = 0;
4143 uint16_t prev_pring_flag;
4145 lpfc_cleanup_discovery_resources(vport);
4147 spin_lock_irqsave(&phba->hbalock, flags);
4148 for (i = 0; i < psli->num_rings; i++) {
4149 pring = &psli->ring[i];
4150 prev_pring_flag = pring->flag;
4151 /* Only slow rings */
4152 if (pring->ringno == LPFC_ELS_RING) {
4153 pring->flag |= LPFC_DEFERRED_RING_EVENT;
4154 /* Set the lpfc data pending flag */
4155 set_bit(LPFC_DATA_READY, &phba->data_flags);
4158 * Error everything on the txq since these iocbs have not been
4159 * given to the FW yet.
4161 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
4162 if (iocb->vport != vport)
4164 list_move_tail(&iocb->list, &completions);
4168 /* Next issue ABTS for everything on the txcmplq */
4169 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq,
4171 if (iocb->vport != vport)
4173 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
4176 pring->flag = prev_pring_flag;
4179 spin_unlock_irqrestore(&phba->hbalock, flags);
4181 while (!list_empty(&completions)) {
4182 list_remove_head(&completions, iocb, struct lpfc_iocbq, list);
4184 if (!iocb->iocb_cmpl)
4185 lpfc_sli_release_iocbq(phba, iocb);
4187 iocb->iocb.ulpStatus = IOSTAT_LOCAL_REJECT;
4188 iocb->iocb.un.ulpWord[4] = IOERR_SLI_DOWN;
4189 (iocb->iocb_cmpl) (phba, iocb, iocb);
4196 * lpfc_sli_hba_down - Resource cleanup function for the HBA
4197 * @phba: Pointer to HBA context object.
4199 * This function cleans up all iocb, buffers, mailbox commands
4200 * while shutting down the HBA. This function is called with no
4201 * lock held and always returns 1.
4202 * This function does the following to cleanup driver resources:
4203 * - Free discovery resources for each virtual port
4204 * - Cleanup any pending fabric iocbs
4205 * - Iterate through the iocb txq and free each entry
4207 * - Free up any buffer posted to the HBA
4208 * - Free mailbox commands in the mailbox queue.
4211 lpfc_sli_hba_down(struct lpfc_hba *phba)
4213 LIST_HEAD(completions);
4214 struct lpfc_sli *psli = &phba->sli;
4215 struct lpfc_sli_ring *pring;
4216 struct lpfc_dmabuf *buf_ptr;
4218 struct lpfc_iocbq *iocb;
4221 unsigned long flags = 0;
4223 lpfc_hba_down_prep(phba);
4225 lpfc_fabric_abort_hba(phba);
4227 spin_lock_irqsave(&phba->hbalock, flags);
4228 for (i = 0; i < psli->num_rings; i++) {
4229 pring = &psli->ring[i];
4230 /* Only slow rings */
4231 if (pring->ringno == LPFC_ELS_RING) {
4232 pring->flag |= LPFC_DEFERRED_RING_EVENT;
4233 /* Set the lpfc data pending flag */
4234 set_bit(LPFC_DATA_READY, &phba->data_flags);
4238 * Error everything on the txq since these iocbs have not been
4239 * given to the FW yet.
4241 list_splice_init(&pring->txq, &completions);
4245 spin_unlock_irqrestore(&phba->hbalock, flags);
4247 while (!list_empty(&completions)) {
4248 list_remove_head(&completions, iocb, struct lpfc_iocbq, list);
4251 if (!iocb->iocb_cmpl)
4252 lpfc_sli_release_iocbq(phba, iocb);
4254 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4255 cmd->un.ulpWord[4] = IOERR_SLI_DOWN;
4256 (iocb->iocb_cmpl) (phba, iocb, iocb);
4260 spin_lock_irqsave(&phba->hbalock, flags);
4261 list_splice_init(&phba->elsbuf, &completions);
4262 phba->elsbuf_cnt = 0;
4263 phba->elsbuf_prev_cnt = 0;
4264 spin_unlock_irqrestore(&phba->hbalock, flags);
4266 while (!list_empty(&completions)) {
4267 list_remove_head(&completions, buf_ptr,
4268 struct lpfc_dmabuf, list);
4269 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
4273 /* Return any active mbox cmds */
4274 del_timer_sync(&psli->mbox_tmo);
4275 spin_lock_irqsave(&phba->hbalock, flags);
4277 spin_lock(&phba->pport->work_port_lock);
4278 phba->pport->work_port_events &= ~WORKER_MBOX_TMO;
4279 spin_unlock(&phba->pport->work_port_lock);
4281 /* Return any pending or completed mbox cmds */
4282 list_splice_init(&phba->sli.mboxq, &completions);
4283 if (psli->mbox_active) {
4284 list_add_tail(&psli->mbox_active->list, &completions);
4285 psli->mbox_active = NULL;
4286 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
4288 list_splice_init(&phba->sli.mboxq_cmpl, &completions);
4289 spin_unlock_irqrestore(&phba->hbalock, flags);
4291 while (!list_empty(&completions)) {
4292 list_remove_head(&completions, pmb, LPFC_MBOXQ_t, list);
4293 pmb->mb.mbxStatus = MBX_NOT_FINISHED;
4295 pmb->mbox_cmpl(phba,pmb);
4301 * lpfc_sli_pcimem_bcopy - SLI memory copy function
4302 * @srcp: Source memory pointer.
4303 * @destp: Destination memory pointer.
4304 * @cnt: Number of words required to be copied.
4306 * This function is used for copying data between driver memory
4307 * and the SLI memory. This function also changes the endianness
4308 * of each word if native endianness is different from SLI
4309 * endianness. This function can be called with or without
4313 lpfc_sli_pcimem_bcopy(void *srcp, void *destp, uint32_t cnt)
4315 uint32_t *src = srcp;
4316 uint32_t *dest = destp;
4320 for (i = 0; i < (int)cnt; i += sizeof (uint32_t)) {
4322 ldata = le32_to_cpu(ldata);
4331 * lpfc_sli_ringpostbuf_put - Function to add a buffer to postbufq
4332 * @phba: Pointer to HBA context object.
4333 * @pring: Pointer to driver SLI ring object.
4334 * @mp: Pointer to driver buffer object.
4336 * This function is called with no lock held.
4337 * It always return zero after adding the buffer to the postbufq
4341 lpfc_sli_ringpostbuf_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4342 struct lpfc_dmabuf *mp)
4344 /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
4346 spin_lock_irq(&phba->hbalock);
4347 list_add_tail(&mp->list, &pring->postbufq);
4348 pring->postbufq_cnt++;
4349 spin_unlock_irq(&phba->hbalock);
4354 * lpfc_sli_get_buffer_tag - allocates a tag for a CMD_QUE_XRI64_CX buffer
4355 * @phba: Pointer to HBA context object.
4357 * When HBQ is enabled, buffers are searched based on tags. This function
4358 * allocates a tag for buffer posted using CMD_QUE_XRI64_CX iocb. The
4359 * tag is bit wise or-ed with QUE_BUFTAG_BIT to make sure that the tag
4360 * does not conflict with tags of buffer posted for unsolicited events.
4361 * The function returns the allocated tag. The function is called with
4365 lpfc_sli_get_buffer_tag(struct lpfc_hba *phba)
4367 spin_lock_irq(&phba->hbalock);
4368 phba->buffer_tag_count++;
4370 * Always set the QUE_BUFTAG_BIT to distiguish between
4371 * a tag assigned by HBQ.
4373 phba->buffer_tag_count |= QUE_BUFTAG_BIT;
4374 spin_unlock_irq(&phba->hbalock);
4375 return phba->buffer_tag_count;
4379 * lpfc_sli_ring_taggedbuf_get - find HBQ buffer associated with given tag
4380 * @phba: Pointer to HBA context object.
4381 * @pring: Pointer to driver SLI ring object.
4384 * Buffers posted using CMD_QUE_XRI64_CX iocb are in pring->postbufq
4385 * list. After HBA DMA data to these buffers, CMD_IOCB_RET_XRI64_CX
4386 * iocb is posted to the response ring with the tag of the buffer.
4387 * This function searches the pring->postbufq list using the tag
4388 * to find buffer associated with CMD_IOCB_RET_XRI64_CX
4389 * iocb. If the buffer is found then lpfc_dmabuf object of the
4390 * buffer is returned to the caller else NULL is returned.
4391 * This function is called with no lock held.
4393 struct lpfc_dmabuf *
4394 lpfc_sli_ring_taggedbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4397 struct lpfc_dmabuf *mp, *next_mp;
4398 struct list_head *slp = &pring->postbufq;
4400 /* Search postbufq, from the begining, looking for a match on tag */
4401 spin_lock_irq(&phba->hbalock);
4402 list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
4403 if (mp->buffer_tag == tag) {
4404 list_del_init(&mp->list);
4405 pring->postbufq_cnt--;
4406 spin_unlock_irq(&phba->hbalock);
4411 spin_unlock_irq(&phba->hbalock);
4412 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4413 "0402 Cannot find virtual addr for buffer tag on "
4414 "ring %d Data x%lx x%p x%p x%x\n",
4415 pring->ringno, (unsigned long) tag,
4416 slp->next, slp->prev, pring->postbufq_cnt);
4422 * lpfc_sli_ringpostbuf_get - search buffers for unsolicited CT and ELS events
4423 * @phba: Pointer to HBA context object.
4424 * @pring: Pointer to driver SLI ring object.
4425 * @phys: DMA address of the buffer.
4427 * This function searches the buffer list using the dma_address
4428 * of unsolicited event to find the driver's lpfc_dmabuf object
4429 * corresponding to the dma_address. The function returns the
4430 * lpfc_dmabuf object if a buffer is found else it returns NULL.
4431 * This function is called by the ct and els unsolicited event
4432 * handlers to get the buffer associated with the unsolicited
4435 * This function is called with no lock held.
4437 struct lpfc_dmabuf *
4438 lpfc_sli_ringpostbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4441 struct lpfc_dmabuf *mp, *next_mp;
4442 struct list_head *slp = &pring->postbufq;
4444 /* Search postbufq, from the begining, looking for a match on phys */
4445 spin_lock_irq(&phba->hbalock);
4446 list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
4447 if (mp->phys == phys) {
4448 list_del_init(&mp->list);
4449 pring->postbufq_cnt--;
4450 spin_unlock_irq(&phba->hbalock);
4455 spin_unlock_irq(&phba->hbalock);
4456 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4457 "0410 Cannot find virtual addr for mapped buf on "
4458 "ring %d Data x%llx x%p x%p x%x\n",
4459 pring->ringno, (unsigned long long)phys,
4460 slp->next, slp->prev, pring->postbufq_cnt);
4465 * lpfc_sli_abort_els_cmpl - Completion handler for the els abort iocbs
4466 * @phba: Pointer to HBA context object.
4467 * @cmdiocb: Pointer to driver command iocb object.
4468 * @rspiocb: Pointer to driver response iocb object.
4470 * This function is the completion handler for the abort iocbs for
4471 * ELS commands. This function is called from the ELS ring event
4472 * handler with no lock held. This function frees memory resources
4473 * associated with the abort iocb.
4476 lpfc_sli_abort_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4477 struct lpfc_iocbq *rspiocb)
4479 IOCB_t *irsp = &rspiocb->iocb;
4480 uint16_t abort_iotag, abort_context;
4481 struct lpfc_iocbq *abort_iocb;
4482 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4486 if (irsp->ulpStatus) {
4487 abort_context = cmdiocb->iocb.un.acxri.abortContextTag;
4488 abort_iotag = cmdiocb->iocb.un.acxri.abortIoTag;
4490 spin_lock_irq(&phba->hbalock);
4491 if (abort_iotag != 0 && abort_iotag <= phba->sli.last_iotag)
4492 abort_iocb = phba->sli.iocbq_lookup[abort_iotag];
4494 lpfc_printf_log(phba, KERN_INFO, LOG_ELS | LOG_SLI,
4495 "0327 Cannot abort els iocb %p "
4496 "with tag %x context %x, abort status %x, "
4498 abort_iocb, abort_iotag, abort_context,
4499 irsp->ulpStatus, irsp->un.ulpWord[4]);
4502 * If the iocb is not found in Firmware queue the iocb
4503 * might have completed already. Do not free it again.
4505 if (irsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
4506 spin_unlock_irq(&phba->hbalock);
4507 lpfc_sli_release_iocbq(phba, cmdiocb);
4511 * make sure we have the right iocbq before taking it
4512 * off the txcmplq and try to call completion routine.
4515 abort_iocb->iocb.ulpContext != abort_context ||
4516 (abort_iocb->iocb_flag & LPFC_DRIVER_ABORTED) == 0)
4517 spin_unlock_irq(&phba->hbalock);
4519 list_del_init(&abort_iocb->list);
4520 pring->txcmplq_cnt--;
4521 spin_unlock_irq(&phba->hbalock);
4523 /* Firmware could still be in progress of DMAing
4524 * payload, so don't free data buffer till after
4527 abort_iocb->iocb_flag |= LPFC_DELAY_MEM_FREE;
4529 abort_iocb->iocb_flag &= ~LPFC_DRIVER_ABORTED;
4530 abort_iocb->iocb.ulpStatus = IOSTAT_LOCAL_REJECT;
4531 abort_iocb->iocb.un.ulpWord[4] = IOERR_SLI_ABORTED;
4532 (abort_iocb->iocb_cmpl)(phba, abort_iocb, abort_iocb);
4536 lpfc_sli_release_iocbq(phba, cmdiocb);
4541 * lpfc_ignore_els_cmpl - Completion handler for aborted ELS command
4542 * @phba: Pointer to HBA context object.
4543 * @cmdiocb: Pointer to driver command iocb object.
4544 * @rspiocb: Pointer to driver response iocb object.
4546 * The function is called from SLI ring event handler with no
4547 * lock held. This function is the completion handler for ELS commands
4548 * which are aborted. The function frees memory resources used for
4549 * the aborted ELS commands.
4552 lpfc_ignore_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4553 struct lpfc_iocbq *rspiocb)
4555 IOCB_t *irsp = &rspiocb->iocb;
4557 /* ELS cmd tag <ulpIoTag> completes */
4558 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
4559 "0139 Ignoring ELS cmd tag x%x completion Data: "
4561 irsp->ulpIoTag, irsp->ulpStatus,
4562 irsp->un.ulpWord[4], irsp->ulpTimeout);
4563 if (cmdiocb->iocb.ulpCommand == CMD_GEN_REQUEST64_CR)
4564 lpfc_ct_free_iocb(phba, cmdiocb);
4566 lpfc_els_free_iocb(phba, cmdiocb);
4571 * lpfc_sli_issue_abort_iotag - Abort function for a command iocb
4572 * @phba: Pointer to HBA context object.
4573 * @pring: Pointer to driver SLI ring object.
4574 * @cmdiocb: Pointer to driver command iocb object.
4576 * This function issues an abort iocb for the provided command
4577 * iocb. This function is called with hbalock held.
4578 * The function returns 0 when it fails due to memory allocation
4579 * failure or when the command iocb is an abort request.
4582 lpfc_sli_issue_abort_iotag(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4583 struct lpfc_iocbq *cmdiocb)
4585 struct lpfc_vport *vport = cmdiocb->vport;
4586 struct lpfc_iocbq *abtsiocbp;
4587 IOCB_t *icmd = NULL;
4588 IOCB_t *iabt = NULL;
4589 int retval = IOCB_ERROR;
4592 * There are certain command types we don't want to abort. And we
4593 * don't want to abort commands that are already in the process of
4596 icmd = &cmdiocb->iocb;
4597 if (icmd->ulpCommand == CMD_ABORT_XRI_CN ||
4598 icmd->ulpCommand == CMD_CLOSE_XRI_CN ||
4599 (cmdiocb->iocb_flag & LPFC_DRIVER_ABORTED) != 0)
4602 /* If we're unloading, don't abort iocb on the ELS ring, but change the
4603 * callback so that nothing happens when it finishes.
4605 if ((vport->load_flag & FC_UNLOADING) &&
4606 (pring->ringno == LPFC_ELS_RING)) {
4607 if (cmdiocb->iocb_flag & LPFC_IO_FABRIC)
4608 cmdiocb->fabric_iocb_cmpl = lpfc_ignore_els_cmpl;
4610 cmdiocb->iocb_cmpl = lpfc_ignore_els_cmpl;
4611 goto abort_iotag_exit;
4614 /* issue ABTS for this IOCB based on iotag */
4615 abtsiocbp = __lpfc_sli_get_iocbq(phba);
4616 if (abtsiocbp == NULL)
4619 /* This signals the response to set the correct status
4620 * before calling the completion handler.
4622 cmdiocb->iocb_flag |= LPFC_DRIVER_ABORTED;
4624 iabt = &abtsiocbp->iocb;
4625 iabt->un.acxri.abortType = ABORT_TYPE_ABTS;
4626 iabt->un.acxri.abortContextTag = icmd->ulpContext;
4627 iabt->un.acxri.abortIoTag = icmd->ulpIoTag;
4629 iabt->ulpClass = icmd->ulpClass;
4631 if (phba->link_state >= LPFC_LINK_UP)
4632 iabt->ulpCommand = CMD_ABORT_XRI_CN;
4634 iabt->ulpCommand = CMD_CLOSE_XRI_CN;
4636 abtsiocbp->iocb_cmpl = lpfc_sli_abort_els_cmpl;
4638 lpfc_printf_vlog(vport, KERN_INFO, LOG_SLI,
4639 "0339 Abort xri x%x, original iotag x%x, "
4640 "abort cmd iotag x%x\n",
4641 iabt->un.acxri.abortContextTag,
4642 iabt->un.acxri.abortIoTag, abtsiocbp->iotag);
4643 retval = __lpfc_sli_issue_iocb(phba, pring, abtsiocbp, 0);
4646 __lpfc_sli_release_iocbq(phba, abtsiocbp);
4649 * Caller to this routine should check for IOCB_ERROR
4650 * and handle it properly. This routine no longer removes
4651 * iocb off txcmplq and call compl in case of IOCB_ERROR.
4657 * lpfc_sli_validate_fcp_iocb - find commands associated with a vport or LUN
4658 * @iocbq: Pointer to driver iocb object.
4659 * @vport: Pointer to driver virtual port object.
4660 * @tgt_id: SCSI ID of the target.
4661 * @lun_id: LUN ID of the scsi device.
4662 * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST
4664 * This function acts as an iocb filter for functions which abort or count
4665 * all FCP iocbs pending on a lun/SCSI target/SCSI host. It will return
4666 * 0 if the filtering criteria is met for the given iocb and will return
4667 * 1 if the filtering criteria is not met.
4668 * If ctx_cmd == LPFC_CTX_LUN, the function returns 0 only if the
4669 * given iocb is for the SCSI device specified by vport, tgt_id and
4671 * If ctx_cmd == LPFC_CTX_TGT, the function returns 0 only if the
4672 * given iocb is for the SCSI target specified by vport and tgt_id
4674 * If ctx_cmd == LPFC_CTX_HOST, the function returns 0 only if the
4675 * given iocb is for the SCSI host associated with the given vport.
4676 * This function is called with no locks held.
4679 lpfc_sli_validate_fcp_iocb(struct lpfc_iocbq *iocbq, struct lpfc_vport *vport,
4680 uint16_t tgt_id, uint64_t lun_id,
4681 lpfc_ctx_cmd ctx_cmd)
4683 struct lpfc_scsi_buf *lpfc_cmd;
4686 if (!(iocbq->iocb_flag & LPFC_IO_FCP))
4689 if (iocbq->vport != vport)
4692 lpfc_cmd = container_of(iocbq, struct lpfc_scsi_buf, cur_iocbq);
4694 if (lpfc_cmd->pCmd == NULL)
4699 if ((lpfc_cmd->rdata->pnode) &&
4700 (lpfc_cmd->rdata->pnode->nlp_sid == tgt_id) &&
4701 (scsilun_to_int(&lpfc_cmd->fcp_cmnd->fcp_lun) == lun_id))
4705 if ((lpfc_cmd->rdata->pnode) &&
4706 (lpfc_cmd->rdata->pnode->nlp_sid == tgt_id))
4713 printk(KERN_ERR "%s: Unknown context cmd type, value %d\n",
4722 * lpfc_sli_sum_iocb - Function to count the number of FCP iocbs pending
4723 * @vport: Pointer to virtual port.
4724 * @tgt_id: SCSI ID of the target.
4725 * @lun_id: LUN ID of the scsi device.
4726 * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
4728 * This function returns number of FCP commands pending for the vport.
4729 * When ctx_cmd == LPFC_CTX_LUN, the function returns number of FCP
4730 * commands pending on the vport associated with SCSI device specified
4731 * by tgt_id and lun_id parameters.
4732 * When ctx_cmd == LPFC_CTX_TGT, the function returns number of FCP
4733 * commands pending on the vport associated with SCSI target specified
4734 * by tgt_id parameter.
4735 * When ctx_cmd == LPFC_CTX_HOST, the function returns number of FCP
4736 * commands pending on the vport.
4737 * This function returns the number of iocbs which satisfy the filter.
4738 * This function is called without any lock held.
4741 lpfc_sli_sum_iocb(struct lpfc_vport *vport, uint16_t tgt_id, uint64_t lun_id,
4742 lpfc_ctx_cmd ctx_cmd)
4744 struct lpfc_hba *phba = vport->phba;
4745 struct lpfc_iocbq *iocbq;
4748 for (i = 1, sum = 0; i <= phba->sli.last_iotag; i++) {
4749 iocbq = phba->sli.iocbq_lookup[i];
4751 if (lpfc_sli_validate_fcp_iocb (iocbq, vport, tgt_id, lun_id,
4760 * lpfc_sli_abort_fcp_cmpl - Completion handler function for aborted FCP IOCBs
4761 * @phba: Pointer to HBA context object
4762 * @cmdiocb: Pointer to command iocb object.
4763 * @rspiocb: Pointer to response iocb object.
4765 * This function is called when an aborted FCP iocb completes. This
4766 * function is called by the ring event handler with no lock held.
4767 * This function frees the iocb.
4770 lpfc_sli_abort_fcp_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4771 struct lpfc_iocbq *rspiocb)
4773 lpfc_sli_release_iocbq(phba, cmdiocb);
4778 * lpfc_sli_abort_iocb - issue abort for all commands on a host/target/LUN
4779 * @vport: Pointer to virtual port.
4780 * @pring: Pointer to driver SLI ring object.
4781 * @tgt_id: SCSI ID of the target.
4782 * @lun_id: LUN ID of the scsi device.
4783 * @abort_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
4785 * This function sends an abort command for every SCSI command
4786 * associated with the given virtual port pending on the ring
4787 * filtered by lpfc_sli_validate_fcp_iocb function.
4788 * When abort_cmd == LPFC_CTX_LUN, the function sends abort only to the
4789 * FCP iocbs associated with lun specified by tgt_id and lun_id
4791 * When abort_cmd == LPFC_CTX_TGT, the function sends abort only to the
4792 * FCP iocbs associated with SCSI target specified by tgt_id parameter.
4793 * When abort_cmd == LPFC_CTX_HOST, the function sends abort to all
4794 * FCP iocbs associated with virtual port.
4795 * This function returns number of iocbs it failed to abort.
4796 * This function is called with no locks held.
4799 lpfc_sli_abort_iocb(struct lpfc_vport *vport, struct lpfc_sli_ring *pring,
4800 uint16_t tgt_id, uint64_t lun_id, lpfc_ctx_cmd abort_cmd)
4802 struct lpfc_hba *phba = vport->phba;
4803 struct lpfc_iocbq *iocbq;
4804 struct lpfc_iocbq *abtsiocb;
4806 int errcnt = 0, ret_val = 0;
4809 for (i = 1; i <= phba->sli.last_iotag; i++) {
4810 iocbq = phba->sli.iocbq_lookup[i];
4812 if (lpfc_sli_validate_fcp_iocb(iocbq, vport, tgt_id, lun_id,
4816 /* issue ABTS for this IOCB based on iotag */
4817 abtsiocb = lpfc_sli_get_iocbq(phba);
4818 if (abtsiocb == NULL) {
4824 abtsiocb->iocb.un.acxri.abortType = ABORT_TYPE_ABTS;
4825 abtsiocb->iocb.un.acxri.abortContextTag = cmd->ulpContext;
4826 abtsiocb->iocb.un.acxri.abortIoTag = cmd->ulpIoTag;
4827 abtsiocb->iocb.ulpLe = 1;
4828 abtsiocb->iocb.ulpClass = cmd->ulpClass;
4829 abtsiocb->vport = phba->pport;
4831 if (lpfc_is_link_up(phba))
4832 abtsiocb->iocb.ulpCommand = CMD_ABORT_XRI_CN;
4834 abtsiocb->iocb.ulpCommand = CMD_CLOSE_XRI_CN;
4836 /* Setup callback routine and issue the command. */
4837 abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
4838 ret_val = lpfc_sli_issue_iocb(phba, pring, abtsiocb, 0);
4839 if (ret_val == IOCB_ERROR) {
4840 lpfc_sli_release_iocbq(phba, abtsiocb);
4850 * lpfc_sli_wake_iocb_wait - lpfc_sli_issue_iocb_wait's completion handler
4851 * @phba: Pointer to HBA context object.
4852 * @cmdiocbq: Pointer to command iocb.
4853 * @rspiocbq: Pointer to response iocb.
4855 * This function is the completion handler for iocbs issued using
4856 * lpfc_sli_issue_iocb_wait function. This function is called by the
4857 * ring event handler function without any lock held. This function
4858 * can be called from both worker thread context and interrupt
4859 * context. This function also can be called from other thread which
4860 * cleans up the SLI layer objects.
4861 * This function copy the contents of the response iocb to the
4862 * response iocb memory object provided by the caller of
4863 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
4864 * sleeps for the iocb completion.
4867 lpfc_sli_wake_iocb_wait(struct lpfc_hba *phba,
4868 struct lpfc_iocbq *cmdiocbq,
4869 struct lpfc_iocbq *rspiocbq)
4871 wait_queue_head_t *pdone_q;
4872 unsigned long iflags;
4874 spin_lock_irqsave(&phba->hbalock, iflags);
4875 cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
4876 if (cmdiocbq->context2 && rspiocbq)
4877 memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
4878 &rspiocbq->iocb, sizeof(IOCB_t));
4880 pdone_q = cmdiocbq->context_un.wait_queue;
4883 spin_unlock_irqrestore(&phba->hbalock, iflags);
4888 * lpfc_sli_issue_iocb_wait - Synchronous function to issue iocb commands
4889 * @phba: Pointer to HBA context object..
4890 * @pring: Pointer to sli ring.
4891 * @piocb: Pointer to command iocb.
4892 * @prspiocbq: Pointer to response iocb.
4893 * @timeout: Timeout in number of seconds.
4895 * This function issues the iocb to firmware and waits for the
4896 * iocb to complete. If the iocb command is not
4897 * completed within timeout seconds, it returns IOCB_TIMEDOUT.
4898 * Caller should not free the iocb resources if this function
4899 * returns IOCB_TIMEDOUT.
4900 * The function waits for the iocb completion using an
4901 * non-interruptible wait.
4902 * This function will sleep while waiting for iocb completion.
4903 * So, this function should not be called from any context which
4904 * does not allow sleeping. Due to the same reason, this function
4905 * cannot be called with interrupt disabled.
4906 * This function assumes that the iocb completions occur while
4907 * this function sleep. So, this function cannot be called from
4908 * the thread which process iocb completion for this ring.
4909 * This function clears the iocb_flag of the iocb object before
4910 * issuing the iocb and the iocb completion handler sets this
4911 * flag and wakes this thread when the iocb completes.
4912 * The contents of the response iocb will be copied to prspiocbq
4913 * by the completion handler when the command completes.
4914 * This function returns IOCB_SUCCESS when success.
4915 * This function is called with no lock held.
4918 lpfc_sli_issue_iocb_wait(struct lpfc_hba *phba,
4919 struct lpfc_sli_ring *pring,
4920 struct lpfc_iocbq *piocb,
4921 struct lpfc_iocbq *prspiocbq,
4924 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q);
4925 long timeleft, timeout_req = 0;
4926 int retval = IOCB_SUCCESS;
4930 * If the caller has provided a response iocbq buffer, then context2
4931 * is NULL or its an error.
4934 if (piocb->context2)
4936 piocb->context2 = prspiocbq;
4939 piocb->iocb_cmpl = lpfc_sli_wake_iocb_wait;
4940 piocb->context_un.wait_queue = &done_q;
4941 piocb->iocb_flag &= ~LPFC_IO_WAKE;
4943 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
4944 creg_val = readl(phba->HCregaddr);
4945 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
4946 writel(creg_val, phba->HCregaddr);
4947 readl(phba->HCregaddr); /* flush */
4950 retval = lpfc_sli_issue_iocb(phba, pring, piocb, 0);
4951 if (retval == IOCB_SUCCESS) {
4952 timeout_req = timeout * HZ;
4953 timeleft = wait_event_timeout(done_q,
4954 piocb->iocb_flag & LPFC_IO_WAKE,
4957 if (piocb->iocb_flag & LPFC_IO_WAKE) {
4958 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4959 "0331 IOCB wake signaled\n");
4960 } else if (timeleft == 0) {
4961 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4962 "0338 IOCB wait timeout error - no "
4963 "wake response Data x%x\n", timeout);
4964 retval = IOCB_TIMEDOUT;
4966 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4967 "0330 IOCB wake NOT set, "
4969 timeout, (timeleft / jiffies));
4970 retval = IOCB_TIMEDOUT;
4973 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4974 "0332 IOCB wait issue failed, Data x%x\n",
4976 retval = IOCB_ERROR;
4979 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
4980 creg_val = readl(phba->HCregaddr);
4981 creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
4982 writel(creg_val, phba->HCregaddr);
4983 readl(phba->HCregaddr); /* flush */
4987 piocb->context2 = NULL;
4989 piocb->context_un.wait_queue = NULL;
4990 piocb->iocb_cmpl = NULL;
4995 * lpfc_sli_issue_mbox_wait - Synchronous function to issue mailbox
4996 * @phba: Pointer to HBA context object.
4997 * @pmboxq: Pointer to driver mailbox object.
4998 * @timeout: Timeout in number of seconds.
5000 * This function issues the mailbox to firmware and waits for the
5001 * mailbox command to complete. If the mailbox command is not
5002 * completed within timeout seconds, it returns MBX_TIMEOUT.
5003 * The function waits for the mailbox completion using an
5004 * interruptible wait. If the thread is woken up due to a
5005 * signal, MBX_TIMEOUT error is returned to the caller. Caller
5006 * should not free the mailbox resources, if this function returns
5008 * This function will sleep while waiting for mailbox completion.
5009 * So, this function should not be called from any context which
5010 * does not allow sleeping. Due to the same reason, this function
5011 * cannot be called with interrupt disabled.
5012 * This function assumes that the mailbox completion occurs while
5013 * this function sleep. So, this function cannot be called from
5014 * the worker thread which processes mailbox completion.
5015 * This function is called in the context of HBA management
5017 * This function returns MBX_SUCCESS when successful.
5018 * This function is called with no lock held.
5021 lpfc_sli_issue_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq,
5024 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q);
5028 /* The caller must leave context1 empty. */
5029 if (pmboxq->context1)
5030 return MBX_NOT_FINISHED;
5032 pmboxq->mbox_flag &= ~LPFC_MBX_WAKE;
5033 /* setup wake call as IOCB callback */
5034 pmboxq->mbox_cmpl = lpfc_sli_wake_mbox_wait;
5035 /* setup context field to pass wait_queue pointer to wake function */
5036 pmboxq->context1 = &done_q;
5038 /* now issue the command */
5039 retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
5041 if (retval == MBX_BUSY || retval == MBX_SUCCESS) {
5042 wait_event_interruptible_timeout(done_q,
5043 pmboxq->mbox_flag & LPFC_MBX_WAKE,
5046 spin_lock_irqsave(&phba->hbalock, flag);
5047 pmboxq->context1 = NULL;
5049 * if LPFC_MBX_WAKE flag is set the mailbox is completed
5050 * else do not free the resources.
5052 if (pmboxq->mbox_flag & LPFC_MBX_WAKE)
5053 retval = MBX_SUCCESS;
5055 retval = MBX_TIMEOUT;
5056 pmboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
5058 spin_unlock_irqrestore(&phba->hbalock, flag);
5065 * lpfc_sli_flush_mbox_queue - mailbox queue cleanup function
5066 * @phba: Pointer to HBA context.
5068 * This function is called to cleanup any pending mailbox
5069 * objects in the driver queue before bringing the HBA offline.
5070 * This function is called while resetting the HBA.
5071 * The function is called without any lock held. The function
5072 * takes hbalock to update SLI data structure.
5073 * This function returns 1 when there is an active mailbox
5074 * command pending else returns 0.
5077 lpfc_sli_flush_mbox_queue(struct lpfc_hba * phba)
5079 struct lpfc_vport *vport = phba->pport;
5083 while (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE && !vport->stopped) {
5084 if (i++ > LPFC_MBOX_TMO * 1000)
5088 * Call lpfc_sli_handle_mb_event only if a mailbox cmd
5089 * did finish. This way we won't get the misleading
5090 * "Stray Mailbox Interrupt" message.
5092 spin_lock_irq(&phba->hbalock);
5093 ha_copy = phba->work_ha;
5094 phba->work_ha &= ~HA_MBATT;
5095 spin_unlock_irq(&phba->hbalock);
5097 if (ha_copy & HA_MBATT)
5098 if (lpfc_sli_handle_mb_event(phba) == 0)
5104 return (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) ? 1 : 0;
5108 * lpfc_sli_check_eratt - check error attention events
5109 * @phba: Pointer to HBA context.
5111 * This function is called form timer soft interrupt context to check HBA's
5112 * error attention register bit for error attention events.
5114 * This fucntion returns 1 when there is Error Attention in the Host Attention
5115 * Register and returns 0 otherwise.
5118 lpfc_sli_check_eratt(struct lpfc_hba *phba)
5122 /* If PCI channel is offline, don't process it */
5123 if (unlikely(pci_channel_offline(phba->pcidev)))
5126 /* If somebody is waiting to handle an eratt, don't process it
5127 * here. The brdkill function will do this.
5129 if (phba->link_flag & LS_IGNORE_ERATT)
5132 /* Check if interrupt handler handles this ERATT */
5133 spin_lock_irq(&phba->hbalock);
5134 if (phba->hba_flag & HBA_ERATT_HANDLED) {
5135 /* Interrupt handler has handled ERATT */
5136 spin_unlock_irq(&phba->hbalock);
5140 /* Read chip Host Attention (HA) register */
5141 ha_copy = readl(phba->HAregaddr);
5142 if (ha_copy & HA_ERATT) {
5143 /* Read host status register to retrieve error event */
5144 lpfc_sli_read_hs(phba);
5145 /* Set the driver HA work bitmap */
5146 phba->work_ha |= HA_ERATT;
5147 /* Indicate polling handles this ERATT */
5148 phba->hba_flag |= HBA_ERATT_HANDLED;
5149 spin_unlock_irq(&phba->hbalock);
5152 spin_unlock_irq(&phba->hbalock);
5157 * lpfc_sp_intr_handler - The slow-path interrupt handler of lpfc driver
5158 * @irq: Interrupt number.
5159 * @dev_id: The device context pointer.
5161 * This function is directly called from the PCI layer as an interrupt
5162 * service routine when the device is enabled with MSI-X multi-message
5163 * interrupt mode and there are slow-path events in the HBA. However,
5164 * when the device is enabled with either MSI or Pin-IRQ interrupt mode,
5165 * this function is called as part of the device-level interrupt handler.
5166 * When the PCI slot is in error recovery or the HBA is undergoing
5167 * initialization, the interrupt handler will not process the interrupt.
5168 * The link attention and ELS ring attention events are handled by the
5169 * worker thread. The interrupt handler signals the worker thread and
5170 * and returns for these events. This function is called without any
5171 * lock held. It gets the hbalock to access and update SLI data
5174 * This function returns IRQ_HANDLED when interrupt is handled else it
5178 lpfc_sp_intr_handler(int irq, void *dev_id)
5180 struct lpfc_hba *phba;
5182 uint32_t work_ha_copy;
5183 unsigned long status;
5184 unsigned long iflag;
5187 MAILBOX_t *mbox, *pmbox;
5188 struct lpfc_vport *vport;
5189 struct lpfc_nodelist *ndlp;
5190 struct lpfc_dmabuf *mp;
5195 * Get the driver's phba structure from the dev_id and
5196 * assume the HBA is not interrupting.
5198 phba = (struct lpfc_hba *)dev_id;
5200 if (unlikely(!phba))
5204 * Stuff needs to be attented to when this function is invoked as an
5205 * individual interrupt handler in MSI-X multi-message interrupt mode
5207 if (phba->intr_type == MSIX) {
5208 /* If the pci channel is offline, ignore all the interrupts */
5209 if (unlikely(pci_channel_offline(phba->pcidev)))
5211 /* Update device-level interrupt statistics */
5212 phba->sli.slistat.sli_intr++;
5213 /* Ignore all interrupts during initialization. */
5214 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5216 /* Need to read HA REG for slow-path events */
5217 spin_lock_irqsave(&phba->hbalock, iflag);
5218 ha_copy = readl(phba->HAregaddr);
5219 /* If somebody is waiting to handle an eratt don't process it
5220 * here. The brdkill function will do this.
5222 if (phba->link_flag & LS_IGNORE_ERATT)
5223 ha_copy &= ~HA_ERATT;
5224 /* Check the need for handling ERATT in interrupt handler */
5225 if (ha_copy & HA_ERATT) {
5226 if (phba->hba_flag & HBA_ERATT_HANDLED)
5227 /* ERATT polling has handled ERATT */
5228 ha_copy &= ~HA_ERATT;
5230 /* Indicate interrupt handler handles ERATT */
5231 phba->hba_flag |= HBA_ERATT_HANDLED;
5233 /* Clear up only attention source related to slow-path */
5234 writel((ha_copy & (HA_MBATT | HA_R2_CLR_MSK)),
5236 readl(phba->HAregaddr); /* flush */
5237 spin_unlock_irqrestore(&phba->hbalock, iflag);
5239 ha_copy = phba->ha_copy;
5241 work_ha_copy = ha_copy & phba->work_ha_mask;
5244 if (work_ha_copy & HA_LATT) {
5245 if (phba->sli.sli_flag & LPFC_PROCESS_LA) {
5247 * Turn off Link Attention interrupts
5248 * until CLEAR_LA done
5250 spin_lock_irqsave(&phba->hbalock, iflag);
5251 phba->sli.sli_flag &= ~LPFC_PROCESS_LA;
5252 control = readl(phba->HCregaddr);
5253 control &= ~HC_LAINT_ENA;
5254 writel(control, phba->HCregaddr);
5255 readl(phba->HCregaddr); /* flush */
5256 spin_unlock_irqrestore(&phba->hbalock, iflag);
5259 work_ha_copy &= ~HA_LATT;
5262 if (work_ha_copy & ~(HA_ERATT | HA_MBATT | HA_LATT)) {
5264 * Turn off Slow Rings interrupts, LPFC_ELS_RING is
5265 * the only slow ring.
5267 status = (work_ha_copy &
5268 (HA_RXMASK << (4*LPFC_ELS_RING)));
5269 status >>= (4*LPFC_ELS_RING);
5270 if (status & HA_RXMASK) {
5271 spin_lock_irqsave(&phba->hbalock, iflag);
5272 control = readl(phba->HCregaddr);
5274 lpfc_debugfs_slow_ring_trc(phba,
5275 "ISR slow ring: ctl:x%x stat:x%x isrcnt:x%x",
5277 (uint32_t)phba->sli.slistat.sli_intr);
5279 if (control & (HC_R0INT_ENA << LPFC_ELS_RING)) {
5280 lpfc_debugfs_slow_ring_trc(phba,
5282 "pwork:x%x hawork:x%x wait:x%x",
5283 phba->work_ha, work_ha_copy,
5284 (uint32_t)((unsigned long)
5285 &phba->work_waitq));
5288 ~(HC_R0INT_ENA << LPFC_ELS_RING);
5289 writel(control, phba->HCregaddr);
5290 readl(phba->HCregaddr); /* flush */
5293 lpfc_debugfs_slow_ring_trc(phba,
5294 "ISR slow ring: pwork:"
5295 "x%x hawork:x%x wait:x%x",
5296 phba->work_ha, work_ha_copy,
5297 (uint32_t)((unsigned long)
5298 &phba->work_waitq));
5300 spin_unlock_irqrestore(&phba->hbalock, iflag);
5303 spin_lock_irqsave(&phba->hbalock, iflag);
5304 if (work_ha_copy & HA_ERATT)
5305 lpfc_sli_read_hs(phba);
5306 if ((work_ha_copy & HA_MBATT) && (phba->sli.mbox_active)) {
5307 pmb = phba->sli.mbox_active;
5312 /* First check out the status word */
5313 lpfc_sli_pcimem_bcopy(mbox, pmbox, sizeof(uint32_t));
5314 if (pmbox->mbxOwner != OWN_HOST) {
5315 spin_unlock_irqrestore(&phba->hbalock, iflag);
5317 * Stray Mailbox Interrupt, mbxCommand <cmd>
5318 * mbxStatus <status>
5320 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
5322 "(%d):0304 Stray Mailbox "
5323 "Interrupt mbxCommand x%x "
5325 (vport ? vport->vpi : 0),
5328 /* clear mailbox attention bit */
5329 work_ha_copy &= ~HA_MBATT;
5331 phba->sli.mbox_active = NULL;
5332 spin_unlock_irqrestore(&phba->hbalock, iflag);
5333 phba->last_completion_time = jiffies;
5334 del_timer(&phba->sli.mbox_tmo);
5335 if (pmb->mbox_cmpl) {
5336 lpfc_sli_pcimem_bcopy(mbox, pmbox,
5339 if (pmb->mbox_flag & LPFC_MBX_IMED_UNREG) {
5340 pmb->mbox_flag &= ~LPFC_MBX_IMED_UNREG;
5342 lpfc_debugfs_disc_trc(vport,
5343 LPFC_DISC_TRC_MBOX_VPORT,
5345 "status:x%x rpi:x%x",
5346 (uint32_t)pmbox->mbxStatus,
5347 pmbox->un.varWords[0], 0);
5349 if (!pmbox->mbxStatus) {
5350 mp = (struct lpfc_dmabuf *)
5352 ndlp = (struct lpfc_nodelist *)
5355 /* Reg_LOGIN of dflt RPI was
5356 * successful. new lets get
5357 * rid of the RPI using the
5360 lpfc_unreg_login(phba,
5362 pmbox->un.varWords[0],
5365 lpfc_mbx_cmpl_dflt_rpi;
5367 pmb->context2 = ndlp;
5369 rc = lpfc_sli_issue_mbox(phba,
5373 lpfc_printf_log(phba,
5376 "0350 rc should have"
5378 goto send_current_mbox;
5382 &phba->pport->work_port_lock,
5384 phba->pport->work_port_events &=
5386 spin_unlock_irqrestore(
5387 &phba->pport->work_port_lock,
5389 lpfc_mbox_cmpl_put(phba, pmb);
5392 spin_unlock_irqrestore(&phba->hbalock, iflag);
5394 if ((work_ha_copy & HA_MBATT) &&
5395 (phba->sli.mbox_active == NULL)) {
5397 /* Process next mailbox command if there is one */
5399 rc = lpfc_sli_issue_mbox(phba, NULL,
5401 } while (rc == MBX_NOT_FINISHED);
5402 if (rc != MBX_SUCCESS)
5403 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
5404 LOG_SLI, "0349 rc should be "
5408 spin_lock_irqsave(&phba->hbalock, iflag);
5409 phba->work_ha |= work_ha_copy;
5410 spin_unlock_irqrestore(&phba->hbalock, iflag);
5411 lpfc_worker_wake_up(phba);
5415 } /* lpfc_sp_intr_handler */
5418 * lpfc_fp_intr_handler - The fast-path interrupt handler of lpfc driver
5419 * @irq: Interrupt number.
5420 * @dev_id: The device context pointer.
5422 * This function is directly called from the PCI layer as an interrupt
5423 * service routine when the device is enabled with MSI-X multi-message
5424 * interrupt mode and there is a fast-path FCP IOCB ring event in the
5425 * HBA. However, when the device is enabled with either MSI or Pin-IRQ
5426 * interrupt mode, this function is called as part of the device-level
5427 * interrupt handler. When the PCI slot is in error recovery or the HBA
5428 * is undergoing initialization, the interrupt handler will not process
5429 * the interrupt. The SCSI FCP fast-path ring event are handled in the
5430 * intrrupt context. This function is called without any lock held. It
5431 * gets the hbalock to access and update SLI data structures.
5433 * This function returns IRQ_HANDLED when interrupt is handled else it
5437 lpfc_fp_intr_handler(int irq, void *dev_id)
5439 struct lpfc_hba *phba;
5441 unsigned long status;
5442 unsigned long iflag;
5444 /* Get the driver's phba structure from the dev_id and
5445 * assume the HBA is not interrupting.
5447 phba = (struct lpfc_hba *) dev_id;
5449 if (unlikely(!phba))
5453 * Stuff needs to be attented to when this function is invoked as an
5454 * individual interrupt handler in MSI-X multi-message interrupt mode
5456 if (phba->intr_type == MSIX) {
5457 /* If pci channel is offline, ignore all the interrupts */
5458 if (unlikely(pci_channel_offline(phba->pcidev)))
5460 /* Update device-level interrupt statistics */
5461 phba->sli.slistat.sli_intr++;
5462 /* Ignore all interrupts during initialization. */
5463 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5465 /* Need to read HA REG for FCP ring and other ring events */
5466 ha_copy = readl(phba->HAregaddr);
5467 /* Clear up only attention source related to fast-path */
5468 spin_lock_irqsave(&phba->hbalock, iflag);
5469 writel((ha_copy & (HA_R0_CLR_MSK | HA_R1_CLR_MSK)),
5471 readl(phba->HAregaddr); /* flush */
5472 spin_unlock_irqrestore(&phba->hbalock, iflag);
5474 ha_copy = phba->ha_copy;
5477 * Process all events on FCP ring. Take the optimized path for FCP IO.
5479 ha_copy &= ~(phba->work_ha_mask);
5481 status = (ha_copy & (HA_RXMASK << (4*LPFC_FCP_RING)));
5482 status >>= (4*LPFC_FCP_RING);
5483 if (status & HA_RXMASK)
5484 lpfc_sli_handle_fast_ring_event(phba,
5485 &phba->sli.ring[LPFC_FCP_RING],
5488 if (phba->cfg_multi_ring_support == 2) {
5490 * Process all events on extra ring. Take the optimized path
5491 * for extra ring IO.
5493 status = (ha_copy & (HA_RXMASK << (4*LPFC_EXTRA_RING)));
5494 status >>= (4*LPFC_EXTRA_RING);
5495 if (status & HA_RXMASK) {
5496 lpfc_sli_handle_fast_ring_event(phba,
5497 &phba->sli.ring[LPFC_EXTRA_RING],
5502 } /* lpfc_fp_intr_handler */
5505 * lpfc_intr_handler - The device-level interrupt handler of lpfc driver
5506 * @irq: Interrupt number.
5507 * @dev_id: The device context pointer.
5509 * This function is the device-level interrupt handler called from the PCI
5510 * layer when either MSI or Pin-IRQ interrupt mode is enabled and there is
5511 * an event in the HBA which requires driver attention. This function
5512 * invokes the slow-path interrupt attention handling function and fast-path
5513 * interrupt attention handling function in turn to process the relevant
5514 * HBA attention events. This function is called without any lock held. It
5515 * gets the hbalock to access and update SLI data structures.
5517 * This function returns IRQ_HANDLED when interrupt is handled, else it
5521 lpfc_intr_handler(int irq, void *dev_id)
5523 struct lpfc_hba *phba;
5524 irqreturn_t sp_irq_rc, fp_irq_rc;
5525 unsigned long status1, status2;
5528 * Get the driver's phba structure from the dev_id and
5529 * assume the HBA is not interrupting.
5531 phba = (struct lpfc_hba *) dev_id;
5533 if (unlikely(!phba))
5536 /* If the pci channel is offline, ignore all the interrupts. */
5537 if (unlikely(pci_channel_offline(phba->pcidev)))
5540 /* Update device level interrupt statistics */
5541 phba->sli.slistat.sli_intr++;
5543 /* Ignore all interrupts during initialization. */
5544 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5547 spin_lock(&phba->hbalock);
5548 phba->ha_copy = readl(phba->HAregaddr);
5549 if (unlikely(!phba->ha_copy)) {
5550 spin_unlock(&phba->hbalock);
5552 } else if (phba->ha_copy & HA_ERATT) {
5553 if (phba->hba_flag & HBA_ERATT_HANDLED)
5554 /* ERATT polling has handled ERATT */
5555 phba->ha_copy &= ~HA_ERATT;
5557 /* Indicate interrupt handler handles ERATT */
5558 phba->hba_flag |= HBA_ERATT_HANDLED;
5561 /* Clear attention sources except link and error attentions */
5562 writel((phba->ha_copy & ~(HA_LATT | HA_ERATT)), phba->HAregaddr);
5563 readl(phba->HAregaddr); /* flush */
5564 spin_unlock(&phba->hbalock);
5567 * Invokes slow-path host attention interrupt handling as appropriate.
5570 /* status of events with mailbox and link attention */
5571 status1 = phba->ha_copy & (HA_MBATT | HA_LATT | HA_ERATT);
5573 /* status of events with ELS ring */
5574 status2 = (phba->ha_copy & (HA_RXMASK << (4*LPFC_ELS_RING)));
5575 status2 >>= (4*LPFC_ELS_RING);
5577 if (status1 || (status2 & HA_RXMASK))
5578 sp_irq_rc = lpfc_sp_intr_handler(irq, dev_id);
5580 sp_irq_rc = IRQ_NONE;
5583 * Invoke fast-path host attention interrupt handling as appropriate.
5586 /* status of events with FCP ring */
5587 status1 = (phba->ha_copy & (HA_RXMASK << (4*LPFC_FCP_RING)));
5588 status1 >>= (4*LPFC_FCP_RING);
5590 /* status of events with extra ring */
5591 if (phba->cfg_multi_ring_support == 2) {
5592 status2 = (phba->ha_copy & (HA_RXMASK << (4*LPFC_EXTRA_RING)));
5593 status2 >>= (4*LPFC_EXTRA_RING);
5597 if ((status1 & HA_RXMASK) || (status2 & HA_RXMASK))
5598 fp_irq_rc = lpfc_fp_intr_handler(irq, dev_id);
5600 fp_irq_rc = IRQ_NONE;
5602 /* Return device-level interrupt handling status */
5603 return (sp_irq_rc == IRQ_HANDLED) ? sp_irq_rc : fp_irq_rc;
5604 } /* lpfc_intr_handler */