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 then 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;
545 if (pring
->ringno
== LPFC_ELS_RING
) {
546 lpfc_debugfs_slow_ring_trc(phba
,
547 "IOCB cmd ring: wd4:x%08x wd6:x%08x wd7:x%08x",
548 *(((uint32_t *) &nextiocb
->iocb
) + 4),
549 *(((uint32_t *) &nextiocb
->iocb
) + 6),
550 *(((uint32_t *) &nextiocb
->iocb
) + 7));
554 * Issue iocb command to adapter
556 lpfc_sli_pcimem_bcopy(&nextiocb
->iocb
, iocb
, phba
->iocb_cmd_size
);
558 pring
->stats
.iocb_cmd
++;
561 * If there is no completion routine to call, we can release the
562 * IOCB buffer back right now. For IOCBs, like QUE_RING_BUF,
563 * that have no rsp ring completion, iocb_cmpl MUST be NULL.
565 if (nextiocb
->iocb_cmpl
)
566 lpfc_sli_ringtxcmpl_put(phba
, pring
, nextiocb
);
568 __lpfc_sli_release_iocbq(phba
, nextiocb
);
571 * Let the HBA know what IOCB slot will be the next one the
572 * driver will put a command into.
574 pring
->cmdidx
= pring
->next_cmdidx
;
575 writel(pring
->cmdidx
, &phba
->host_gp
[pring
->ringno
].cmdPutInx
);
579 * lpfc_sli_update_full_ring: Update the chip attention register.
580 * @phba: Pointer to HBA context object.
581 * @pring: Pointer to driver SLI ring object.
583 * The caller is not required to hold any lock for calling this function.
584 * This function updates the chip attention bits for the ring to inform firmware
585 * that there are pending work to be done for this ring and requests an
586 * interrupt when there is space available in the ring. This function is
587 * called when the driver is unable to post more iocbs to the ring due
588 * to unavailability of space in the ring.
591 lpfc_sli_update_full_ring(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
)
593 int ringno
= pring
->ringno
;
595 pring
->flag
|= LPFC_CALL_RING_AVAILABLE
;
600 * Set ring 'ringno' to SET R0CE_REQ in Chip Att register.
601 * The HBA will tell us when an IOCB entry is available.
603 writel((CA_R0ATT
|CA_R0CE_REQ
) << (ringno
*4), phba
->CAregaddr
);
604 readl(phba
->CAregaddr
); /* flush */
606 pring
->stats
.iocb_cmd_full
++;
610 * lpfc_sli_update_ring: Update chip attention register.
611 * @phba: Pointer to HBA context object.
612 * @pring: Pointer to driver SLI ring object.
614 * This function updates the chip attention register bit for the
615 * given ring to inform HBA that there is more work to be done
616 * in this ring. The caller is not required to hold any lock.
619 lpfc_sli_update_ring(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
)
621 int ringno
= pring
->ringno
;
624 * Tell the HBA that there is work to do in this ring.
626 if (!(phba
->sli3_options
& LPFC_SLI3_CRP_ENABLED
)) {
628 writel(CA_R0ATT
<< (ringno
* 4), phba
->CAregaddr
);
629 readl(phba
->CAregaddr
); /* flush */
634 * lpfc_sli_resume_iocb: Process iocbs in the txq.
635 * @phba: Pointer to HBA context object.
636 * @pring: Pointer to driver SLI ring object.
638 * This function is called with hbalock held to post pending iocbs
639 * in the txq to the firmware. This function is called when driver
640 * detects space available in the ring.
643 lpfc_sli_resume_iocb(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
)
646 struct lpfc_iocbq
*nextiocb
;
650 * (a) there is anything on the txq to send
652 * (c) link attention events can be processed (fcp ring only)
653 * (d) IOCB processing is not blocked by the outstanding mbox command.
655 if (pring
->txq_cnt
&&
656 lpfc_is_link_up(phba
) &&
657 (pring
->ringno
!= phba
->sli
.fcp_ring
||
658 phba
->sli
.sli_flag
& LPFC_PROCESS_LA
)) {
660 while ((iocb
= lpfc_sli_next_iocb_slot(phba
, pring
)) &&
661 (nextiocb
= lpfc_sli_ringtx_get(phba
, pring
)))
662 lpfc_sli_submit_iocb(phba
, pring
, iocb
, nextiocb
);
665 lpfc_sli_update_ring(phba
, pring
);
667 lpfc_sli_update_full_ring(phba
, pring
);
674 * lpfc_sli_next_hbq_slot: Get next hbq entry for the HBQ.
675 * @phba: Pointer to HBA context object.
676 * @hbqno: HBQ number.
678 * This function is called with hbalock held to get the next
679 * available slot for the given HBQ. If there is free slot
680 * available for the HBQ it will return pointer to the next available
681 * HBQ entry else it will return NULL.
683 static struct lpfc_hbq_entry
*
684 lpfc_sli_next_hbq_slot(struct lpfc_hba
*phba
, uint32_t hbqno
)
686 struct hbq_s
*hbqp
= &phba
->hbqs
[hbqno
];
688 if (hbqp
->next_hbqPutIdx
== hbqp
->hbqPutIdx
&&
689 ++hbqp
->next_hbqPutIdx
>= hbqp
->entry_count
)
690 hbqp
->next_hbqPutIdx
= 0;
692 if (unlikely(hbqp
->local_hbqGetIdx
== hbqp
->next_hbqPutIdx
)) {
693 uint32_t raw_index
= phba
->hbq_get
[hbqno
];
694 uint32_t getidx
= le32_to_cpu(raw_index
);
696 hbqp
->local_hbqGetIdx
= getidx
;
698 if (unlikely(hbqp
->local_hbqGetIdx
>= hbqp
->entry_count
)) {
699 lpfc_printf_log(phba
, KERN_ERR
,
701 "1802 HBQ %d: local_hbqGetIdx "
702 "%u is > than hbqp->entry_count %u\n",
703 hbqno
, hbqp
->local_hbqGetIdx
,
706 phba
->link_state
= LPFC_HBA_ERROR
;
710 if (hbqp
->local_hbqGetIdx
== hbqp
->next_hbqPutIdx
)
714 return (struct lpfc_hbq_entry
*) phba
->hbqs
[hbqno
].hbq_virt
+
719 * lpfc_sli_hbqbuf_free_all: Free all the hbq buffers.
720 * @phba: Pointer to HBA context object.
722 * This function is called with no lock held to free all the
723 * hbq buffers while uninitializing the SLI interface. It also
724 * frees the HBQ buffers returned by the firmware but not yet
725 * processed by the upper layers.
728 lpfc_sli_hbqbuf_free_all(struct lpfc_hba
*phba
)
730 struct lpfc_dmabuf
*dmabuf
, *next_dmabuf
;
731 struct hbq_dmabuf
*hbq_buf
;
736 hbq_count
= lpfc_sli_hbq_count();
737 /* Return all memory used by all HBQs */
738 spin_lock_irqsave(&phba
->hbalock
, flags
);
739 for (i
= 0; i
< hbq_count
; ++i
) {
740 list_for_each_entry_safe(dmabuf
, next_dmabuf
,
741 &phba
->hbqs
[i
].hbq_buffer_list
, list
) {
742 hbq_buf
= container_of(dmabuf
, struct hbq_dmabuf
, dbuf
);
743 list_del(&hbq_buf
->dbuf
.list
);
744 (phba
->hbqs
[i
].hbq_free_buffer
)(phba
, hbq_buf
);
746 phba
->hbqs
[i
].buffer_count
= 0;
748 /* Return all HBQ buffer that are in-fly */
749 list_for_each_entry_safe(dmabuf
, next_dmabuf
,
750 &phba
->hbqbuf_in_list
, list
) {
751 hbq_buf
= container_of(dmabuf
, struct hbq_dmabuf
, dbuf
);
752 list_del(&hbq_buf
->dbuf
.list
);
753 if (hbq_buf
->tag
== -1) {
754 (phba
->hbqs
[LPFC_ELS_HBQ
].hbq_free_buffer
)
757 hbqno
= hbq_buf
->tag
>> 16;
758 if (hbqno
>= LPFC_MAX_HBQS
)
759 (phba
->hbqs
[LPFC_ELS_HBQ
].hbq_free_buffer
)
762 (phba
->hbqs
[hbqno
].hbq_free_buffer
)(phba
,
767 /* Mark the HBQs not in use */
768 phba
->hbq_in_use
= 0;
769 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
773 * lpfc_sli_hbq_to_firmware: Post the hbq buffer to firmware.
774 * @phba: Pointer to HBA context object.
775 * @hbqno: HBQ number.
776 * @hbq_buf: Pointer to HBQ buffer.
778 * This function is called with the hbalock held to post a
779 * hbq buffer to the firmware. If the function finds an empty
780 * slot in the HBQ, it will post the buffer. The function will return
781 * pointer to the hbq entry if it successfully post the buffer
782 * else it will return NULL.
784 static struct lpfc_hbq_entry
*
785 lpfc_sli_hbq_to_firmware(struct lpfc_hba
*phba
, uint32_t hbqno
,
786 struct hbq_dmabuf
*hbq_buf
)
788 struct lpfc_hbq_entry
*hbqe
;
789 dma_addr_t physaddr
= hbq_buf
->dbuf
.phys
;
791 /* Get next HBQ entry slot to use */
792 hbqe
= lpfc_sli_next_hbq_slot(phba
, hbqno
);
794 struct hbq_s
*hbqp
= &phba
->hbqs
[hbqno
];
796 hbqe
->bde
.addrHigh
= le32_to_cpu(putPaddrHigh(physaddr
));
797 hbqe
->bde
.addrLow
= le32_to_cpu(putPaddrLow(physaddr
));
798 hbqe
->bde
.tus
.f
.bdeSize
= hbq_buf
->size
;
799 hbqe
->bde
.tus
.f
.bdeFlags
= 0;
800 hbqe
->bde
.tus
.w
= le32_to_cpu(hbqe
->bde
.tus
.w
);
801 hbqe
->buffer_tag
= le32_to_cpu(hbq_buf
->tag
);
803 hbqp
->hbqPutIdx
= hbqp
->next_hbqPutIdx
;
804 writel(hbqp
->hbqPutIdx
, phba
->hbq_put
+ hbqno
);
806 readl(phba
->hbq_put
+ hbqno
);
807 list_add_tail(&hbq_buf
->dbuf
.list
, &hbqp
->hbq_buffer_list
);
812 /* HBQ for ELS and CT traffic. */
813 static struct lpfc_hbq_init lpfc_els_hbq
= {
818 .ring_mask
= (1 << LPFC_ELS_RING
),
824 /* HBQ for the extra ring if needed */
825 static struct lpfc_hbq_init lpfc_extra_hbq
= {
830 .ring_mask
= (1 << LPFC_EXTRA_RING
),
837 struct lpfc_hbq_init
*lpfc_hbq_defs
[] = {
843 * lpfc_sli_hbqbuf_fill_hbqs: Post more hbq buffers to HBQ.
844 * @phba: Pointer to HBA context object.
845 * @hbqno: HBQ number.
846 * @count: Number of HBQ buffers to be posted.
848 * This function is called with no lock held to post more hbq buffers to the
849 * given HBQ. The function returns the number of HBQ buffers successfully
853 lpfc_sli_hbqbuf_fill_hbqs(struct lpfc_hba
*phba
, uint32_t hbqno
, uint32_t count
)
855 uint32_t i
, posted
= 0;
857 struct hbq_dmabuf
*hbq_buffer
;
858 LIST_HEAD(hbq_buf_list
);
859 if (!phba
->hbqs
[hbqno
].hbq_alloc_buffer
)
862 if ((phba
->hbqs
[hbqno
].buffer_count
+ count
) >
863 lpfc_hbq_defs
[hbqno
]->entry_count
)
864 count
= lpfc_hbq_defs
[hbqno
]->entry_count
-
865 phba
->hbqs
[hbqno
].buffer_count
;
868 /* Allocate HBQ entries */
869 for (i
= 0; i
< count
; i
++) {
870 hbq_buffer
= (phba
->hbqs
[hbqno
].hbq_alloc_buffer
)(phba
);
873 list_add_tail(&hbq_buffer
->dbuf
.list
, &hbq_buf_list
);
875 /* Check whether HBQ is still in use */
876 spin_lock_irqsave(&phba
->hbalock
, flags
);
877 if (!phba
->hbq_in_use
)
879 while (!list_empty(&hbq_buf_list
)) {
880 list_remove_head(&hbq_buf_list
, hbq_buffer
, struct hbq_dmabuf
,
882 hbq_buffer
->tag
= (phba
->hbqs
[hbqno
].buffer_count
|
884 if (lpfc_sli_hbq_to_firmware(phba
, hbqno
, hbq_buffer
)) {
885 phba
->hbqs
[hbqno
].buffer_count
++;
888 (phba
->hbqs
[hbqno
].hbq_free_buffer
)(phba
, hbq_buffer
);
890 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
893 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
894 while (!list_empty(&hbq_buf_list
)) {
895 list_remove_head(&hbq_buf_list
, hbq_buffer
, struct hbq_dmabuf
,
897 (phba
->hbqs
[hbqno
].hbq_free_buffer
)(phba
, hbq_buffer
);
903 * lpfc_sli_hbqbuf_add_hbqs: Post more HBQ buffers to firmware.
904 * @phba: Pointer to HBA context object.
907 * This function posts more buffers to the HBQ. This function
908 * is called with no lock held. The function returns the number of HBQ entries
909 * successfully allocated.
912 lpfc_sli_hbqbuf_add_hbqs(struct lpfc_hba
*phba
, uint32_t qno
)
914 return(lpfc_sli_hbqbuf_fill_hbqs(phba
, qno
,
915 lpfc_hbq_defs
[qno
]->add_count
));
919 * lpfc_sli_hbqbuf_init_hbqs: Post initial buffers to the HBQ.
920 * @phba: Pointer to HBA context object.
921 * @qno: HBQ queue number.
923 * This function is called from SLI initialization code path with
924 * no lock held to post initial HBQ buffers to firmware. The
925 * function returns the number of HBQ entries successfully allocated.
928 lpfc_sli_hbqbuf_init_hbqs(struct lpfc_hba
*phba
, uint32_t qno
)
930 return(lpfc_sli_hbqbuf_fill_hbqs(phba
, qno
,
931 lpfc_hbq_defs
[qno
]->init_count
));
935 * lpfc_sli_hbqbuf_find: Find the hbq buffer associated with a tag.
936 * @phba: Pointer to HBA context object.
937 * @tag: Tag of the hbq buffer.
939 * This function is called with hbalock held. This function searches
940 * for the hbq buffer associated with the given tag in the hbq buffer
941 * list. If it finds the hbq buffer, it returns the hbq_buffer other wise
944 static struct hbq_dmabuf
*
945 lpfc_sli_hbqbuf_find(struct lpfc_hba
*phba
, uint32_t tag
)
947 struct lpfc_dmabuf
*d_buf
;
948 struct hbq_dmabuf
*hbq_buf
;
952 if (hbqno
>= LPFC_MAX_HBQS
)
955 list_for_each_entry(d_buf
, &phba
->hbqs
[hbqno
].hbq_buffer_list
, list
) {
956 hbq_buf
= container_of(d_buf
, struct hbq_dmabuf
, dbuf
);
957 if (hbq_buf
->tag
== tag
) {
961 lpfc_printf_log(phba
, KERN_ERR
, LOG_SLI
| LOG_VPORT
,
962 "1803 Bad hbq tag. Data: x%x x%x\n",
963 tag
, phba
->hbqs
[tag
>> 16].buffer_count
);
968 * lpfc_sli_free_hbq: Give back the hbq buffer to firmware.
969 * @phba: Pointer to HBA context object.
970 * @hbq_buffer: Pointer to HBQ buffer.
972 * This function is called with hbalock. This function gives back
973 * the hbq buffer to firmware. If the HBQ does not have space to
974 * post the buffer, it will free the buffer.
977 lpfc_sli_free_hbq(struct lpfc_hba
*phba
, struct hbq_dmabuf
*hbq_buffer
)
982 hbqno
= hbq_buffer
->tag
>> 16;
983 if (!lpfc_sli_hbq_to_firmware(phba
, hbqno
, hbq_buffer
)) {
984 (phba
->hbqs
[hbqno
].hbq_free_buffer
)(phba
, hbq_buffer
);
990 * lpfc_sli_chk_mbx_command: Check if the mailbox is a legitimate mailbox.
991 * @mbxCommand: mailbox command code.
993 * This function is called by the mailbox event handler function to verify
994 * that the completed mailbox command is a legitimate mailbox command. If the
995 * completed mailbox is not known to the function, it will return MBX_SHUTDOWN
996 * and the mailbox event handler will take the HBA offline.
999 lpfc_sli_chk_mbx_command(uint8_t mbxCommand
)
1003 switch (mbxCommand
) {
1007 case MBX_WRITE_VPARMS
:
1008 case MBX_RUN_BIU_DIAG
:
1011 case MBX_CONFIG_LINK
:
1012 case MBX_CONFIG_RING
:
1013 case MBX_RESET_RING
:
1014 case MBX_READ_CONFIG
:
1015 case MBX_READ_RCONFIG
:
1016 case MBX_READ_SPARM
:
1017 case MBX_READ_STATUS
:
1021 case MBX_READ_LNK_STAT
:
1023 case MBX_UNREG_LOGIN
:
1026 case MBX_DUMP_MEMORY
:
1027 case MBX_DUMP_CONTEXT
:
1030 case MBX_UPDATE_CFG
:
1032 case MBX_DEL_LD_ENTRY
:
1033 case MBX_RUN_PROGRAM
:
1035 case MBX_SET_VARIABLE
:
1036 case MBX_UNREG_D_ID
:
1037 case MBX_KILL_BOARD
:
1038 case MBX_CONFIG_FARP
:
1041 case MBX_RUN_BIU_DIAG64
:
1042 case MBX_CONFIG_PORT
:
1043 case MBX_READ_SPARM64
:
1044 case MBX_READ_RPI64
:
1045 case MBX_REG_LOGIN64
:
1049 case MBX_LOAD_EXP_ROM
:
1050 case MBX_ASYNCEVT_ENABLE
:
1054 case MBX_PORT_CAPABILITIES
:
1055 case MBX_PORT_IOV_CONTROL
:
1066 * lpfc_sli_wake_mbox_wait: Completion handler for mbox issued from
1067 * lpfc_sli_issue_mbox_wait.
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 then
1631 * rsp ring <portRspMax>
1633 lpfc_printf_log(phba
, KERN_ERR
, LOG_SLI
,
1634 "0312 Ring %d handler: portRspPut %d "
1635 "is bigger then 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 then
2086 * rsp ring <portRspMax>
2088 lpfc_printf_log(phba
, KERN_ERR
, LOG_SLI
,
2089 "0303 Ring %d handler: portRspPut %d "
2090 "is bigger then 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 if (rc
!= MBX_SUCCESS
) {
3049 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
3050 "0442 Adapter failed to init, mbxCmd x%x "
3051 "CONFIG_PORT, mbxStatus x%x Data: x%x\n",
3052 pmb
->mb
.mbxCommand
, pmb
->mb
.mbxStatus
, 0);
3053 spin_lock_irq(&phba
->hbalock
);
3054 phba
->sli
.sli_flag
&= ~LPFC_SLI2_ACTIVE
;
3055 spin_unlock_irq(&phba
->hbalock
);
3062 goto do_prep_failed
;
3064 if (pmb
->mb
.un
.varCfgPort
.sli_mode
== 3) {
3065 if (!pmb
->mb
.un
.varCfgPort
.cMA
) {
3067 goto do_prep_failed
;
3069 if (phba
->max_vpi
&& pmb
->mb
.un
.varCfgPort
.gmv
) {
3070 phba
->sli3_options
|= LPFC_SLI3_NPIV_ENABLED
;
3071 phba
->max_vpi
= pmb
->mb
.un
.varCfgPort
.max_vpi
;
3074 if (pmb
->mb
.un
.varCfgPort
.gerbm
)
3075 phba
->sli3_options
|= LPFC_SLI3_HBQ_ENABLED
;
3076 if (pmb
->mb
.un
.varCfgPort
.gcrp
)
3077 phba
->sli3_options
|= LPFC_SLI3_CRP_ENABLED
;
3078 if (pmb
->mb
.un
.varCfgPort
.ginb
) {
3079 phba
->sli3_options
|= LPFC_SLI3_INB_ENABLED
;
3080 phba
->hbq_get
= phba
->mbox
->us
.s3_inb_pgp
.hbq_get
;
3081 phba
->port_gp
= phba
->mbox
->us
.s3_inb_pgp
.port
;
3082 phba
->inb_ha_copy
= &phba
->mbox
->us
.s3_inb_pgp
.ha_copy
;
3083 phba
->inb_counter
= &phba
->mbox
->us
.s3_inb_pgp
.counter
;
3084 phba
->inb_last_counter
=
3085 phba
->mbox
->us
.s3_inb_pgp
.counter
;
3087 phba
->hbq_get
= phba
->mbox
->us
.s3_pgp
.hbq_get
;
3088 phba
->port_gp
= phba
->mbox
->us
.s3_pgp
.port
;
3089 phba
->inb_ha_copy
= NULL
;
3090 phba
->inb_counter
= NULL
;
3093 phba
->hbq_get
= NULL
;
3094 phba
->port_gp
= phba
->mbox
->us
.s2
.port
;
3095 phba
->inb_ha_copy
= NULL
;
3096 phba
->inb_counter
= NULL
;
3100 mempool_free(pmb
, phba
->mbox_mem_pool
);
3106 * lpfc_sli_hba_setup: SLI intialization function.
3107 * @phba: Pointer to HBA context object.
3109 * This function is the main SLI intialization function. This function
3110 * is called by the HBA intialization code, HBA reset code and HBA
3111 * error attention handler code. Caller is not required to hold any
3112 * locks. This function issues config_port mailbox command to configure
3113 * the SLI, setup iocb rings and HBQ rings. In the end the function
3114 * calls the config_port_post function to issue init_link mailbox
3115 * command and to start the discovery. The function will return zero
3116 * if successful, else it will return negative error code.
3119 lpfc_sli_hba_setup(struct lpfc_hba
*phba
)
3124 switch (lpfc_sli_mode
) {
3126 if (phba
->cfg_enable_npiv
) {
3127 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
| LOG_VPORT
,
3128 "1824 NPIV enabled: Override lpfc_sli_mode "
3129 "parameter (%d) to auto (0).\n",
3139 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
| LOG_VPORT
,
3140 "1819 Unrecognized lpfc_sli_mode "
3141 "parameter: %d.\n", lpfc_sli_mode
);
3146 rc
= lpfc_sli_config_port(phba
, mode
);
3148 if (rc
&& lpfc_sli_mode
== 3)
3149 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
| LOG_VPORT
,
3150 "1820 Unable to select SLI-3. "
3151 "Not supported by adapter.\n");
3152 if (rc
&& mode
!= 2)
3153 rc
= lpfc_sli_config_port(phba
, 2);
3155 goto lpfc_sli_hba_setup_error
;
3157 if (phba
->sli_rev
== 3) {
3158 phba
->iocb_cmd_size
= SLI3_IOCB_CMD_SIZE
;
3159 phba
->iocb_rsp_size
= SLI3_IOCB_RSP_SIZE
;
3161 phba
->iocb_cmd_size
= SLI2_IOCB_CMD_SIZE
;
3162 phba
->iocb_rsp_size
= SLI2_IOCB_RSP_SIZE
;
3163 phba
->sli3_options
= 0;
3166 lpfc_printf_log(phba
, KERN_INFO
, LOG_INIT
,
3167 "0444 Firmware in SLI %x mode. Max_vpi %d\n",
3168 phba
->sli_rev
, phba
->max_vpi
);
3169 rc
= lpfc_sli_ring_map(phba
);
3172 goto lpfc_sli_hba_setup_error
;
3175 if (phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
) {
3176 rc
= lpfc_sli_hbq_setup(phba
);
3178 goto lpfc_sli_hba_setup_error
;
3181 phba
->sli
.sli_flag
|= LPFC_PROCESS_LA
;
3183 rc
= lpfc_config_port_post(phba
);
3185 goto lpfc_sli_hba_setup_error
;
3189 lpfc_sli_hba_setup_error
:
3190 phba
->link_state
= LPFC_HBA_ERROR
;
3191 lpfc_printf_log(phba
, KERN_INFO
, LOG_INIT
,
3192 "0445 Firmware initialization failed\n");
3198 * lpfc_mbox_timeout: Timeout call back function for mbox timer.
3199 * @ptr: context object - pointer to hba structure.
3201 * This is the callback function for mailbox timer. The mailbox
3202 * timer is armed when a new mailbox command is issued and the timer
3203 * is deleted when the mailbox complete. The function is called by
3204 * the kernel timer code when a mailbox does not complete within
3205 * expected time. This function wakes up the worker thread to
3206 * process the mailbox timeout and returns. All the processing is
3207 * done by the worker thread function lpfc_mbox_timeout_handler.
3210 lpfc_mbox_timeout(unsigned long ptr
)
3212 struct lpfc_hba
*phba
= (struct lpfc_hba
*) ptr
;
3213 unsigned long iflag
;
3214 uint32_t tmo_posted
;
3216 spin_lock_irqsave(&phba
->pport
->work_port_lock
, iflag
);
3217 tmo_posted
= phba
->pport
->work_port_events
& WORKER_MBOX_TMO
;
3219 phba
->pport
->work_port_events
|= WORKER_MBOX_TMO
;
3220 spin_unlock_irqrestore(&phba
->pport
->work_port_lock
, iflag
);
3223 lpfc_worker_wake_up(phba
);
3229 * lpfc_mbox_timeout_handler: Worker thread function to handle mailbox timeout.
3230 * @phba: Pointer to HBA context object.
3232 * This function is called from worker thread when a mailbox command times out.
3233 * The caller is not required to hold any locks. This function will reset the
3234 * HBA and recover all the pending commands.
3237 lpfc_mbox_timeout_handler(struct lpfc_hba
*phba
)
3239 LPFC_MBOXQ_t
*pmbox
= phba
->sli
.mbox_active
;
3240 MAILBOX_t
*mb
= &pmbox
->mb
;
3241 struct lpfc_sli
*psli
= &phba
->sli
;
3242 struct lpfc_sli_ring
*pring
;
3244 /* Mbox cmd <mbxCommand> timeout */
3245 lpfc_printf_log(phba
, KERN_ERR
, LOG_MBOX
| LOG_SLI
,
3246 "0310 Mailbox command x%x timeout Data: x%x x%x x%p\n",
3248 phba
->pport
->port_state
,
3250 phba
->sli
.mbox_active
);
3252 /* Setting state unknown so lpfc_sli_abort_iocb_ring
3253 * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
3254 * it to fail all oustanding SCSI IO.
3256 spin_lock_irq(&phba
->pport
->work_port_lock
);
3257 phba
->pport
->work_port_events
&= ~WORKER_MBOX_TMO
;
3258 spin_unlock_irq(&phba
->pport
->work_port_lock
);
3259 spin_lock_irq(&phba
->hbalock
);
3260 phba
->link_state
= LPFC_LINK_UNKNOWN
;
3261 psli
->sli_flag
&= ~LPFC_SLI2_ACTIVE
;
3262 spin_unlock_irq(&phba
->hbalock
);
3264 pring
= &psli
->ring
[psli
->fcp_ring
];
3265 lpfc_sli_abort_iocb_ring(phba
, pring
);
3267 lpfc_printf_log(phba
, KERN_ERR
, LOG_MBOX
| LOG_SLI
,
3268 "0345 Resetting board due to mailbox timeout\n");
3270 * lpfc_offline calls lpfc_sli_hba_down which will clean up
3271 * on oustanding mailbox commands.
3273 /* If resets are disabled then set error state and return. */
3274 if (!phba
->cfg_enable_hba_reset
) {
3275 phba
->link_state
= LPFC_HBA_ERROR
;
3278 lpfc_offline_prep(phba
);
3280 lpfc_sli_brdrestart(phba
);
3282 lpfc_unblock_mgmt_io(phba
);
3287 * lpfc_sli_issue_mbox: Issue a mailbox command to firmware.
3288 * @phba: Pointer to HBA context object.
3289 * @pmbox: Pointer to mailbox object.
3290 * @flag: Flag indicating how the mailbox need to be processed.
3292 * This function is called by discovery code and HBA management code
3293 * to submit a mailbox command to firmware. This function gets the
3294 * hbalock to protect the data structures.
3295 * The mailbox command can be submitted in polling mode, in which case
3296 * this function will wait in a polling loop for the completion of the
3298 * If the mailbox is submitted in no_wait mode (not polling) the
3299 * function will submit the command and returns immediately without waiting
3300 * for the mailbox completion. The no_wait is supported only when HBA
3301 * is in SLI2/SLI3 mode - interrupts are enabled.
3302 * The SLI interface allows only one mailbox pending at a time. If the
3303 * mailbox is issued in polling mode and there is already a mailbox
3304 * pending, then the function will return an error. If the mailbox is issued
3305 * in NO_WAIT mode and there is a mailbox pending already, the function
3306 * will return MBX_BUSY after queuing the mailbox into mailbox queue.
3307 * The sli layer owns the mailbox object until the completion of mailbox
3308 * command if this function return MBX_BUSY or MBX_SUCCESS. For all other
3309 * return codes the caller owns the mailbox command after the return of
3313 lpfc_sli_issue_mbox(struct lpfc_hba
*phba
, LPFC_MBOXQ_t
*pmbox
, uint32_t flag
)
3316 struct lpfc_sli
*psli
= &phba
->sli
;
3317 uint32_t status
, evtctr
;
3320 unsigned long timeout
;
3321 unsigned long drvr_flag
= 0;
3322 uint32_t word0
, ldata
;
3323 void __iomem
*to_slim
;
3324 int processing_queue
= 0;
3326 spin_lock_irqsave(&phba
->hbalock
, drvr_flag
);
3328 /* processing mbox queue from intr_handler */
3329 processing_queue
= 1;
3330 phba
->sli
.sli_flag
&= ~LPFC_SLI_MBOX_ACTIVE
;
3331 pmbox
= lpfc_mbox_get(phba
);
3333 spin_unlock_irqrestore(&phba
->hbalock
, drvr_flag
);
3338 if (pmbox
->mbox_cmpl
&& pmbox
->mbox_cmpl
!= lpfc_sli_def_mbox_cmpl
&&
3339 pmbox
->mbox_cmpl
!= lpfc_sli_wake_mbox_wait
) {
3341 spin_unlock_irqrestore(&phba
->hbalock
, drvr_flag
);
3342 lpfc_printf_log(phba
, KERN_ERR
,
3343 LOG_MBOX
| LOG_VPORT
,
3344 "1806 Mbox x%x failed. No vport\n",
3345 pmbox
->mb
.mbxCommand
);
3347 goto out_not_finished
;
3351 /* If the PCI channel is in offline state, do not post mbox. */
3352 if (unlikely(pci_channel_offline(phba
->pcidev
))) {
3353 spin_unlock_irqrestore(&phba
->hbalock
, drvr_flag
);
3354 goto out_not_finished
;
3360 status
= MBX_SUCCESS
;
3362 if (phba
->link_state
== LPFC_HBA_ERROR
) {
3363 spin_unlock_irqrestore(&phba
->hbalock
, drvr_flag
);
3365 /* Mbox command <mbxCommand> cannot issue */
3366 LOG_MBOX_CANNOT_ISSUE_DATA(phba
, pmbox
, psli
, flag
);
3367 goto out_not_finished
;
3370 if (mb
->mbxCommand
!= MBX_KILL_BOARD
&& flag
& MBX_NOWAIT
&&
3371 !(readl(phba
->HCregaddr
) & HC_MBINT_ENA
)) {
3372 spin_unlock_irqrestore(&phba
->hbalock
, drvr_flag
);
3373 LOG_MBOX_CANNOT_ISSUE_DATA(phba
, pmbox
, psli
, flag
);
3374 goto out_not_finished
;
3377 if (psli
->sli_flag
& LPFC_SLI_MBOX_ACTIVE
) {
3378 /* Polling for a mbox command when another one is already active
3379 * is not allowed in SLI. Also, the driver must have established
3380 * SLI2 mode to queue and process multiple mbox commands.
3383 if (flag
& MBX_POLL
) {
3384 spin_unlock_irqrestore(&phba
->hbalock
, drvr_flag
);
3386 /* Mbox command <mbxCommand> cannot issue */
3387 LOG_MBOX_CANNOT_ISSUE_DATA(phba
, pmbox
, psli
, flag
);
3388 goto out_not_finished
;
3391 if (!(psli
->sli_flag
& LPFC_SLI2_ACTIVE
)) {
3392 spin_unlock_irqrestore(&phba
->hbalock
, drvr_flag
);
3393 /* Mbox command <mbxCommand> cannot issue */
3394 LOG_MBOX_CANNOT_ISSUE_DATA(phba
, pmbox
, psli
, flag
);
3395 goto out_not_finished
;
3398 /* Another mailbox command is still being processed, queue this
3399 * command to be processed later.
3401 lpfc_mbox_put(phba
, pmbox
);
3403 /* Mbox cmd issue - BUSY */
3404 lpfc_printf_log(phba
, KERN_INFO
, LOG_MBOX
| LOG_SLI
,
3405 "(%d):0308 Mbox cmd issue - BUSY Data: "
3406 "x%x x%x x%x x%x\n",
3407 pmbox
->vport
? pmbox
->vport
->vpi
: 0xffffff,
3408 mb
->mbxCommand
, phba
->pport
->port_state
,
3409 psli
->sli_flag
, flag
);
3411 psli
->slistat
.mbox_busy
++;
3412 spin_unlock_irqrestore(&phba
->hbalock
, drvr_flag
);
3415 lpfc_debugfs_disc_trc(pmbox
->vport
,
3416 LPFC_DISC_TRC_MBOX_VPORT
,
3417 "MBOX Bsy vport: cmd:x%x mb:x%x x%x",
3418 (uint32_t)mb
->mbxCommand
,
3419 mb
->un
.varWords
[0], mb
->un
.varWords
[1]);
3422 lpfc_debugfs_disc_trc(phba
->pport
,
3424 "MBOX Bsy: cmd:x%x mb:x%x x%x",
3425 (uint32_t)mb
->mbxCommand
,
3426 mb
->un
.varWords
[0], mb
->un
.varWords
[1]);
3432 psli
->sli_flag
|= LPFC_SLI_MBOX_ACTIVE
;
3434 /* If we are not polling, we MUST be in SLI2 mode */
3435 if (flag
!= MBX_POLL
) {
3436 if (!(psli
->sli_flag
& LPFC_SLI2_ACTIVE
) &&
3437 (mb
->mbxCommand
!= MBX_KILL_BOARD
)) {
3438 psli
->sli_flag
&= ~LPFC_SLI_MBOX_ACTIVE
;
3439 spin_unlock_irqrestore(&phba
->hbalock
, drvr_flag
);
3440 /* Mbox command <mbxCommand> cannot issue */
3441 LOG_MBOX_CANNOT_ISSUE_DATA(phba
, pmbox
, psli
, flag
);
3442 goto out_not_finished
;
3444 /* timeout active mbox command */
3445 mod_timer(&psli
->mbox_tmo
, (jiffies
+
3446 (HZ
* lpfc_mbox_tmo_val(phba
, mb
->mbxCommand
))));
3449 /* Mailbox cmd <cmd> issue */
3450 lpfc_printf_log(phba
, KERN_INFO
, LOG_MBOX
| LOG_SLI
,
3451 "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
3453 pmbox
->vport
? pmbox
->vport
->vpi
: 0,
3454 mb
->mbxCommand
, phba
->pport
->port_state
,
3455 psli
->sli_flag
, flag
);
3457 if (mb
->mbxCommand
!= MBX_HEARTBEAT
) {
3459 lpfc_debugfs_disc_trc(pmbox
->vport
,
3460 LPFC_DISC_TRC_MBOX_VPORT
,
3461 "MBOX Send vport: cmd:x%x mb:x%x x%x",
3462 (uint32_t)mb
->mbxCommand
,
3463 mb
->un
.varWords
[0], mb
->un
.varWords
[1]);
3466 lpfc_debugfs_disc_trc(phba
->pport
,
3468 "MBOX Send: cmd:x%x mb:x%x x%x",
3469 (uint32_t)mb
->mbxCommand
,
3470 mb
->un
.varWords
[0], mb
->un
.varWords
[1]);
3474 psli
->slistat
.mbox_cmd
++;
3475 evtctr
= psli
->slistat
.mbox_event
;
3477 /* next set own bit for the adapter and copy over command word */
3478 mb
->mbxOwner
= OWN_CHIP
;
3480 if (psli
->sli_flag
& LPFC_SLI2_ACTIVE
) {
3481 /* First copy command data to host SLIM area */
3482 lpfc_sli_pcimem_bcopy(mb
, phba
->mbox
, MAILBOX_CMD_SIZE
);
3484 if (mb
->mbxCommand
== MBX_CONFIG_PORT
) {
3485 /* copy command data into host mbox for cmpl */
3486 lpfc_sli_pcimem_bcopy(mb
, phba
->mbox
, MAILBOX_CMD_SIZE
);
3489 /* First copy mbox command data to HBA SLIM, skip past first
3491 to_slim
= phba
->MBslimaddr
+ sizeof (uint32_t);
3492 lpfc_memcpy_to_slim(to_slim
, &mb
->un
.varWords
[0],
3493 MAILBOX_CMD_SIZE
- sizeof (uint32_t));
3495 /* Next copy over first word, with mbxOwner set */
3496 ldata
= *((uint32_t *)mb
);
3497 to_slim
= phba
->MBslimaddr
;
3498 writel(ldata
, to_slim
);
3499 readl(to_slim
); /* flush */
3501 if (mb
->mbxCommand
== MBX_CONFIG_PORT
) {
3502 /* switch over to host mailbox */
3503 psli
->sli_flag
|= LPFC_SLI2_ACTIVE
;
3511 /* Set up reference to mailbox command */
3512 psli
->mbox_active
= pmbox
;
3513 /* Interrupt board to do it */
3514 writel(CA_MBATT
, phba
->CAregaddr
);
3515 readl(phba
->CAregaddr
); /* flush */
3516 /* Don't wait for it to finish, just return */
3520 /* Set up null reference to mailbox command */
3521 psli
->mbox_active
= NULL
;
3522 /* Interrupt board to do it */
3523 writel(CA_MBATT
, phba
->CAregaddr
);
3524 readl(phba
->CAregaddr
); /* flush */
3526 if (psli
->sli_flag
& LPFC_SLI2_ACTIVE
) {
3527 /* First read mbox status word */
3528 word0
= *((uint32_t *)phba
->mbox
);
3529 word0
= le32_to_cpu(word0
);
3531 /* First read mbox status word */
3532 word0
= readl(phba
->MBslimaddr
);
3535 /* Read the HBA Host Attention Register */
3536 ha_copy
= readl(phba
->HAregaddr
);
3537 timeout
= msecs_to_jiffies(lpfc_mbox_tmo_val(phba
,
3541 /* Wait for command to complete */
3542 while (((word0
& OWN_CHIP
) == OWN_CHIP
) ||
3543 (!(ha_copy
& HA_MBATT
) &&
3544 (phba
->link_state
> LPFC_WARM_START
))) {
3545 if (time_after(jiffies
, timeout
)) {
3546 psli
->sli_flag
&= ~LPFC_SLI_MBOX_ACTIVE
;
3547 spin_unlock_irqrestore(&phba
->hbalock
,
3549 goto out_not_finished
;
3552 /* Check if we took a mbox interrupt while we were
3554 if (((word0
& OWN_CHIP
) != OWN_CHIP
)
3555 && (evtctr
!= psli
->slistat
.mbox_event
))
3559 spin_unlock_irqrestore(&phba
->hbalock
,
3562 spin_lock_irqsave(&phba
->hbalock
, drvr_flag
);
3565 if (psli
->sli_flag
& LPFC_SLI2_ACTIVE
) {
3566 /* First copy command data */
3567 word0
= *((uint32_t *)phba
->mbox
);
3568 word0
= le32_to_cpu(word0
);
3569 if (mb
->mbxCommand
== MBX_CONFIG_PORT
) {
3572 /* Check real SLIM for any errors */
3573 slimword0
= readl(phba
->MBslimaddr
);
3574 slimmb
= (MAILBOX_t
*) & slimword0
;
3575 if (((slimword0
& OWN_CHIP
) != OWN_CHIP
)
3576 && slimmb
->mbxStatus
) {
3583 /* First copy command data */
3584 word0
= readl(phba
->MBslimaddr
);
3586 /* Read the HBA Host Attention Register */
3587 ha_copy
= readl(phba
->HAregaddr
);
3590 if (psli
->sli_flag
& LPFC_SLI2_ACTIVE
) {
3591 /* copy results back to user */
3592 lpfc_sli_pcimem_bcopy(phba
->mbox
, mb
, MAILBOX_CMD_SIZE
);
3594 /* First copy command data */
3595 lpfc_memcpy_from_slim(mb
, phba
->MBslimaddr
,
3597 if ((mb
->mbxCommand
== MBX_DUMP_MEMORY
) &&
3599 lpfc_memcpy_from_slim((void *)pmbox
->context2
,
3600 phba
->MBslimaddr
+ DMP_RSP_OFFSET
,
3601 mb
->un
.varDmp
.word_cnt
);
3605 writel(HA_MBATT
, phba
->HAregaddr
);
3606 readl(phba
->HAregaddr
); /* flush */
3608 psli
->sli_flag
&= ~LPFC_SLI_MBOX_ACTIVE
;
3609 status
= mb
->mbxStatus
;
3612 spin_unlock_irqrestore(&phba
->hbalock
, drvr_flag
);
3616 if (processing_queue
) {
3617 pmbox
->mb
.mbxStatus
= MBX_NOT_FINISHED
;
3618 lpfc_mbox_cmpl_put(phba
, pmbox
);
3620 return MBX_NOT_FINISHED
;
3624 * __lpfc_sli_ringtx_put: Add an iocb to the txq.
3625 * @phba: Pointer to HBA context object.
3626 * @pring: Pointer to driver SLI ring object.
3627 * @piocb: Pointer to address of newly added command iocb.
3629 * This function is called with hbalock held to add a command
3630 * iocb to the txq when SLI layer cannot submit the command iocb
3634 __lpfc_sli_ringtx_put(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
3635 struct lpfc_iocbq
*piocb
)
3637 /* Insert the caller's iocb in the txq tail for later processing. */
3638 list_add_tail(&piocb
->list
, &pring
->txq
);
3643 * lpfc_sli_next_iocb: Get the next iocb in the txq.
3644 * @phba: Pointer to HBA context object.
3645 * @pring: Pointer to driver SLI ring object.
3646 * @piocb: Pointer to address of newly added command iocb.
3648 * This function is called with hbalock held before a new
3649 * iocb is submitted to the firmware. This function checks
3650 * txq to flush the iocbs in txq to Firmware before
3651 * submitting new iocbs to the Firmware.
3652 * If there are iocbs in the txq which need to be submitted
3653 * to firmware, lpfc_sli_next_iocb returns the first element
3654 * of the txq after dequeuing it from txq.
3655 * If there is no iocb in the txq then the function will return
3656 * *piocb and *piocb is set to NULL. Caller needs to check
3657 * *piocb to find if there are more commands in the txq.
3659 static struct lpfc_iocbq
*
3660 lpfc_sli_next_iocb(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
3661 struct lpfc_iocbq
**piocb
)
3663 struct lpfc_iocbq
* nextiocb
;
3665 nextiocb
= lpfc_sli_ringtx_get(phba
, pring
);
3675 * __lpfc_sli_issue_iocb: Lockless version of lpfc_sli_issue_iocb.
3676 * @phba: Pointer to HBA context object.
3677 * @pring: Pointer to driver SLI ring object.
3678 * @piocb: Pointer to command iocb.
3679 * @flag: Flag indicating if this command can be put into txq.
3681 * __lpfc_sli_issue_iocb is used by other functions in the driver
3682 * to issue an iocb command to the HBA. If the PCI slot is recovering
3683 * from error state or if HBA is resetting or if LPFC_STOP_IOCB_EVENT
3684 * flag is turned on, the function returns IOCB_ERROR.
3685 * When the link is down, this function allows only iocbs for
3687 * This function finds next available slot in the command ring and
3688 * posts the command to the available slot and writes the port
3689 * attention register to request HBA start processing new iocb.
3690 * If there is no slot available in the ring and
3691 * flag & SLI_IOCB_RET_IOCB is set, the new iocb is added to the
3692 * txq, otherwise the function returns IOCB_BUSY.
3694 * This function is called with hbalock held.
3695 * The function will return success after it successfully submit the
3696 * iocb to firmware or after adding to the txq.
3699 __lpfc_sli_issue_iocb(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
3700 struct lpfc_iocbq
*piocb
, uint32_t flag
)
3702 struct lpfc_iocbq
*nextiocb
;
3705 if (piocb
->iocb_cmpl
&& (!piocb
->vport
) &&
3706 (piocb
->iocb
.ulpCommand
!= CMD_ABORT_XRI_CN
) &&
3707 (piocb
->iocb
.ulpCommand
!= CMD_CLOSE_XRI_CN
)) {
3708 lpfc_printf_log(phba
, KERN_ERR
,
3709 LOG_SLI
| LOG_VPORT
,
3710 "1807 IOCB x%x failed. No vport\n",
3711 piocb
->iocb
.ulpCommand
);
3717 /* If the PCI channel is in offline state, do not post iocbs. */
3718 if (unlikely(pci_channel_offline(phba
->pcidev
)))
3722 * We should never get an IOCB if we are in a < LINK_DOWN state
3724 if (unlikely(phba
->link_state
< LPFC_LINK_DOWN
))
3728 * Check to see if we are blocking IOCB processing because of a
3729 * outstanding event.
3731 if (unlikely(pring
->flag
& LPFC_STOP_IOCB_EVENT
))
3734 if (unlikely(phba
->link_state
== LPFC_LINK_DOWN
)) {
3736 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
3737 * can be issued if the link is not up.
3739 switch (piocb
->iocb
.ulpCommand
) {
3740 case CMD_GEN_REQUEST64_CR
:
3741 case CMD_GEN_REQUEST64_CX
:
3742 if (!(phba
->sli
.sli_flag
& LPFC_MENLO_MAINT
) ||
3743 (piocb
->iocb
.un
.genreq64
.w5
.hcsw
.Rctl
!=
3745 (piocb
->iocb
.un
.genreq64
.w5
.hcsw
.Type
!=
3746 MENLO_TRANSPORT_TYPE
))
3750 case CMD_QUE_RING_BUF_CN
:
3751 case CMD_QUE_RING_BUF64_CN
:
3753 * For IOCBs, like QUE_RING_BUF, that have no rsp ring
3754 * completion, iocb_cmpl MUST be 0.
3756 if (piocb
->iocb_cmpl
)
3757 piocb
->iocb_cmpl
= NULL
;
3759 case CMD_CREATE_XRI_CR
:
3760 case CMD_CLOSE_XRI_CN
:
3761 case CMD_CLOSE_XRI_CX
:
3768 * For FCP commands, we must be in a state where we can process link
3771 } else if (unlikely(pring
->ringno
== phba
->sli
.fcp_ring
&&
3772 !(phba
->sli
.sli_flag
& LPFC_PROCESS_LA
))) {
3776 while ((iocb
= lpfc_sli_next_iocb_slot(phba
, pring
)) &&
3777 (nextiocb
= lpfc_sli_next_iocb(phba
, pring
, &piocb
)))
3778 lpfc_sli_submit_iocb(phba
, pring
, iocb
, nextiocb
);
3781 lpfc_sli_update_ring(phba
, pring
);
3783 lpfc_sli_update_full_ring(phba
, pring
);
3786 return IOCB_SUCCESS
;
3791 pring
->stats
.iocb_cmd_delay
++;
3795 if (!(flag
& SLI_IOCB_RET_IOCB
)) {
3796 __lpfc_sli_ringtx_put(phba
, pring
, piocb
);
3797 return IOCB_SUCCESS
;
3805 * lpfc_sli_issue_iocb: Wrapper function for __lpfc_sli_issue_iocb.
3806 * @phba: Pointer to HBA context object.
3807 * @pring: Pointer to driver SLI ring object.
3808 * @piocb: Pointer to command iocb.
3809 * @flag: Flag indicating if this command can be put into txq.
3811 * lpfc_sli_issue_iocb is a wrapper around __lpfc_sli_issue_iocb
3812 * function. This function gets the hbalock and calls
3813 * __lpfc_sli_issue_iocb function and will return the error returned
3814 * by __lpfc_sli_issue_iocb function. This wrapper is used by
3815 * functions which do not hold hbalock.
3818 lpfc_sli_issue_iocb(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
3819 struct lpfc_iocbq
*piocb
, uint32_t flag
)
3821 unsigned long iflags
;
3824 spin_lock_irqsave(&phba
->hbalock
, iflags
);
3825 rc
= __lpfc_sli_issue_iocb(phba
, pring
, piocb
, flag
);
3826 spin_unlock_irqrestore(&phba
->hbalock
, iflags
);
3832 * lpfc_extra_ring_setup: Extra ring setup function.
3833 * @phba: Pointer to HBA context object.
3835 * This function is called while driver attaches with the
3836 * HBA to setup the extra ring. The extra ring is used
3837 * only when driver needs to support target mode functionality
3838 * or IP over FC functionalities.
3840 * This function is called with no lock held.
3843 lpfc_extra_ring_setup( struct lpfc_hba
*phba
)
3845 struct lpfc_sli
*psli
;
3846 struct lpfc_sli_ring
*pring
;
3850 /* Adjust cmd/rsp ring iocb entries more evenly */
3852 /* Take some away from the FCP ring */
3853 pring
= &psli
->ring
[psli
->fcp_ring
];
3854 pring
->numCiocb
-= SLI2_IOCB_CMD_R1XTRA_ENTRIES
;
3855 pring
->numRiocb
-= SLI2_IOCB_RSP_R1XTRA_ENTRIES
;
3856 pring
->numCiocb
-= SLI2_IOCB_CMD_R3XTRA_ENTRIES
;
3857 pring
->numRiocb
-= SLI2_IOCB_RSP_R3XTRA_ENTRIES
;
3859 /* and give them to the extra ring */
3860 pring
= &psli
->ring
[psli
->extra_ring
];
3862 pring
->numCiocb
+= SLI2_IOCB_CMD_R1XTRA_ENTRIES
;
3863 pring
->numRiocb
+= SLI2_IOCB_RSP_R1XTRA_ENTRIES
;
3864 pring
->numCiocb
+= SLI2_IOCB_CMD_R3XTRA_ENTRIES
;
3865 pring
->numRiocb
+= SLI2_IOCB_RSP_R3XTRA_ENTRIES
;
3867 /* Setup default profile for this ring */
3868 pring
->iotag_max
= 4096;
3869 pring
->num_mask
= 1;
3870 pring
->prt
[0].profile
= 0; /* Mask 0 */
3871 pring
->prt
[0].rctl
= phba
->cfg_multi_ring_rctl
;
3872 pring
->prt
[0].type
= phba
->cfg_multi_ring_type
;
3873 pring
->prt
[0].lpfc_sli_rcv_unsol_event
= NULL
;
3878 * lpfc_sli_async_event_handler: ASYNC iocb handler function.
3879 * @phba: Pointer to HBA context object.
3880 * @pring: Pointer to driver SLI ring object.
3881 * @iocbq: Pointer to iocb object.
3883 * This function is called by the slow ring event handler
3884 * function when there is an ASYNC event iocb in the ring.
3885 * This function is called with no lock held.
3886 * Currently this function handles only temperature related
3887 * ASYNC events. The function decodes the temperature sensor
3888 * event message and posts events for the management applications.
3891 lpfc_sli_async_event_handler(struct lpfc_hba
* phba
,
3892 struct lpfc_sli_ring
* pring
, struct lpfc_iocbq
* iocbq
)
3897 struct temp_event temp_event_data
;
3898 struct Scsi_Host
*shost
;
3900 icmd
= &iocbq
->iocb
;
3901 evt_code
= icmd
->un
.asyncstat
.evt_code
;
3902 temp
= icmd
->ulpContext
;
3904 if ((evt_code
!= ASYNC_TEMP_WARN
) &&
3905 (evt_code
!= ASYNC_TEMP_SAFE
)) {
3906 lpfc_printf_log(phba
,
3909 "0346 Ring %d handler: unexpected ASYNC_STATUS"
3912 icmd
->un
.asyncstat
.evt_code
);
3915 temp_event_data
.data
= (uint32_t)temp
;
3916 temp_event_data
.event_type
= FC_REG_TEMPERATURE_EVENT
;
3917 if (evt_code
== ASYNC_TEMP_WARN
) {
3918 temp_event_data
.event_code
= LPFC_THRESHOLD_TEMP
;
3919 lpfc_printf_log(phba
,
3922 "0347 Adapter is very hot, please take "
3923 "corrective action. temperature : %d Celsius\n",
3926 if (evt_code
== ASYNC_TEMP_SAFE
) {
3927 temp_event_data
.event_code
= LPFC_NORMAL_TEMP
;
3928 lpfc_printf_log(phba
,
3931 "0340 Adapter temperature is OK now. "
3932 "temperature : %d Celsius\n",
3936 /* Send temperature change event to applications */
3937 shost
= lpfc_shost_from_vport(phba
->pport
);
3938 fc_host_post_vendor_event(shost
, fc_get_event_number(),
3939 sizeof(temp_event_data
), (char *) &temp_event_data
,
3946 * lpfc_sli_setup: SLI ring setup function.
3947 * @phba: Pointer to HBA context object.
3949 * lpfc_sli_setup sets up rings of the SLI interface with
3950 * number of iocbs per ring and iotags. This function is
3951 * called while driver attach to the HBA and before the
3952 * interrupts are enabled. So there is no need for locking.
3954 * This function always returns 0.
3957 lpfc_sli_setup(struct lpfc_hba
*phba
)
3959 int i
, totiocbsize
= 0;
3960 struct lpfc_sli
*psli
= &phba
->sli
;
3961 struct lpfc_sli_ring
*pring
;
3963 psli
->num_rings
= MAX_CONFIGURED_RINGS
;
3965 psli
->fcp_ring
= LPFC_FCP_RING
;
3966 psli
->next_ring
= LPFC_FCP_NEXT_RING
;
3967 psli
->extra_ring
= LPFC_EXTRA_RING
;
3969 psli
->iocbq_lookup
= NULL
;
3970 psli
->iocbq_lookup_len
= 0;
3971 psli
->last_iotag
= 0;
3973 for (i
= 0; i
< psli
->num_rings
; i
++) {
3974 pring
= &psli
->ring
[i
];
3976 case LPFC_FCP_RING
: /* ring 0 - FCP */
3977 /* numCiocb and numRiocb are used in config_port */
3978 pring
->numCiocb
= SLI2_IOCB_CMD_R0_ENTRIES
;
3979 pring
->numRiocb
= SLI2_IOCB_RSP_R0_ENTRIES
;
3980 pring
->numCiocb
+= SLI2_IOCB_CMD_R1XTRA_ENTRIES
;
3981 pring
->numRiocb
+= SLI2_IOCB_RSP_R1XTRA_ENTRIES
;
3982 pring
->numCiocb
+= SLI2_IOCB_CMD_R3XTRA_ENTRIES
;
3983 pring
->numRiocb
+= SLI2_IOCB_RSP_R3XTRA_ENTRIES
;
3984 pring
->sizeCiocb
= (phba
->sli_rev
== 3) ?
3985 SLI3_IOCB_CMD_SIZE
:
3987 pring
->sizeRiocb
= (phba
->sli_rev
== 3) ?
3988 SLI3_IOCB_RSP_SIZE
:
3990 pring
->iotag_ctr
= 0;
3992 (phba
->cfg_hba_queue_depth
* 2);
3993 pring
->fast_iotag
= pring
->iotag_max
;
3994 pring
->num_mask
= 0;
3996 case LPFC_EXTRA_RING
: /* ring 1 - EXTRA */
3997 /* numCiocb and numRiocb are used in config_port */
3998 pring
->numCiocb
= SLI2_IOCB_CMD_R1_ENTRIES
;
3999 pring
->numRiocb
= SLI2_IOCB_RSP_R1_ENTRIES
;
4000 pring
->sizeCiocb
= (phba
->sli_rev
== 3) ?
4001 SLI3_IOCB_CMD_SIZE
:
4003 pring
->sizeRiocb
= (phba
->sli_rev
== 3) ?
4004 SLI3_IOCB_RSP_SIZE
:
4006 pring
->iotag_max
= phba
->cfg_hba_queue_depth
;
4007 pring
->num_mask
= 0;
4009 case LPFC_ELS_RING
: /* ring 2 - ELS / CT */
4010 /* numCiocb and numRiocb are used in config_port */
4011 pring
->numCiocb
= SLI2_IOCB_CMD_R2_ENTRIES
;
4012 pring
->numRiocb
= SLI2_IOCB_RSP_R2_ENTRIES
;
4013 pring
->sizeCiocb
= (phba
->sli_rev
== 3) ?
4014 SLI3_IOCB_CMD_SIZE
:
4016 pring
->sizeRiocb
= (phba
->sli_rev
== 3) ?
4017 SLI3_IOCB_RSP_SIZE
:
4019 pring
->fast_iotag
= 0;
4020 pring
->iotag_ctr
= 0;
4021 pring
->iotag_max
= 4096;
4022 pring
->lpfc_sli_rcv_async_status
=
4023 lpfc_sli_async_event_handler
;
4024 pring
->num_mask
= 4;
4025 pring
->prt
[0].profile
= 0; /* Mask 0 */
4026 pring
->prt
[0].rctl
= FC_ELS_REQ
;
4027 pring
->prt
[0].type
= FC_ELS_DATA
;
4028 pring
->prt
[0].lpfc_sli_rcv_unsol_event
=
4029 lpfc_els_unsol_event
;
4030 pring
->prt
[1].profile
= 0; /* Mask 1 */
4031 pring
->prt
[1].rctl
= FC_ELS_RSP
;
4032 pring
->prt
[1].type
= FC_ELS_DATA
;
4033 pring
->prt
[1].lpfc_sli_rcv_unsol_event
=
4034 lpfc_els_unsol_event
;
4035 pring
->prt
[2].profile
= 0; /* Mask 2 */
4036 /* NameServer Inquiry */
4037 pring
->prt
[2].rctl
= FC_UNSOL_CTL
;
4039 pring
->prt
[2].type
= FC_COMMON_TRANSPORT_ULP
;
4040 pring
->prt
[2].lpfc_sli_rcv_unsol_event
=
4041 lpfc_ct_unsol_event
;
4042 pring
->prt
[3].profile
= 0; /* Mask 3 */
4043 /* NameServer response */
4044 pring
->prt
[3].rctl
= FC_SOL_CTL
;
4046 pring
->prt
[3].type
= FC_COMMON_TRANSPORT_ULP
;
4047 pring
->prt
[3].lpfc_sli_rcv_unsol_event
=
4048 lpfc_ct_unsol_event
;
4051 totiocbsize
+= (pring
->numCiocb
* pring
->sizeCiocb
) +
4052 (pring
->numRiocb
* pring
->sizeRiocb
);
4054 if (totiocbsize
> MAX_SLIM_IOCB_SIZE
) {
4055 /* Too many cmd / rsp ring entries in SLI2 SLIM */
4056 printk(KERN_ERR
"%d:0462 Too many cmd / rsp ring entries in "
4057 "SLI2 SLIM Data: x%x x%lx\n",
4058 phba
->brd_no
, totiocbsize
,
4059 (unsigned long) MAX_SLIM_IOCB_SIZE
);
4061 if (phba
->cfg_multi_ring_support
== 2)
4062 lpfc_extra_ring_setup(phba
);
4068 * lpfc_sli_queue_setup: Queue initialization function.
4069 * @phba: Pointer to HBA context object.
4071 * lpfc_sli_queue_setup sets up mailbox queues and iocb queues for each
4072 * ring. This function also initializes ring indices of each ring.
4073 * This function is called during the initialization of the SLI
4074 * interface of an HBA.
4075 * This function is called with no lock held and always returns
4079 lpfc_sli_queue_setup(struct lpfc_hba
*phba
)
4081 struct lpfc_sli
*psli
;
4082 struct lpfc_sli_ring
*pring
;
4086 spin_lock_irq(&phba
->hbalock
);
4087 INIT_LIST_HEAD(&psli
->mboxq
);
4088 INIT_LIST_HEAD(&psli
->mboxq_cmpl
);
4089 /* Initialize list headers for txq and txcmplq as double linked lists */
4090 for (i
= 0; i
< psli
->num_rings
; i
++) {
4091 pring
= &psli
->ring
[i
];
4093 pring
->next_cmdidx
= 0;
4094 pring
->local_getidx
= 0;
4096 INIT_LIST_HEAD(&pring
->txq
);
4097 INIT_LIST_HEAD(&pring
->txcmplq
);
4098 INIT_LIST_HEAD(&pring
->iocb_continueq
);
4099 INIT_LIST_HEAD(&pring
->iocb_continue_saveq
);
4100 INIT_LIST_HEAD(&pring
->postbufq
);
4102 spin_unlock_irq(&phba
->hbalock
);
4107 * lpfc_sli_host_down: Vport cleanup function.
4108 * @vport: Pointer to virtual port object.
4110 * lpfc_sli_host_down is called to clean up the resources
4111 * associated with a vport before destroying virtual
4112 * port data structures.
4113 * This function does following operations:
4114 * - Free discovery resources associated with this virtual
4116 * - Free iocbs associated with this virtual port in
4118 * - Send abort for all iocb commands associated with this
4121 * This function is called with no lock held and always returns 1.
4124 lpfc_sli_host_down(struct lpfc_vport
*vport
)
4126 LIST_HEAD(completions
);
4127 struct lpfc_hba
*phba
= vport
->phba
;
4128 struct lpfc_sli
*psli
= &phba
->sli
;
4129 struct lpfc_sli_ring
*pring
;
4130 struct lpfc_iocbq
*iocb
, *next_iocb
;
4132 unsigned long flags
= 0;
4133 uint16_t prev_pring_flag
;
4135 lpfc_cleanup_discovery_resources(vport
);
4137 spin_lock_irqsave(&phba
->hbalock
, flags
);
4138 for (i
= 0; i
< psli
->num_rings
; i
++) {
4139 pring
= &psli
->ring
[i
];
4140 prev_pring_flag
= pring
->flag
;
4141 /* Only slow rings */
4142 if (pring
->ringno
== LPFC_ELS_RING
) {
4143 pring
->flag
|= LPFC_DEFERRED_RING_EVENT
;
4144 /* Set the lpfc data pending flag */
4145 set_bit(LPFC_DATA_READY
, &phba
->data_flags
);
4148 * Error everything on the txq since these iocbs have not been
4149 * given to the FW yet.
4151 list_for_each_entry_safe(iocb
, next_iocb
, &pring
->txq
, list
) {
4152 if (iocb
->vport
!= vport
)
4154 list_move_tail(&iocb
->list
, &completions
);
4158 /* Next issue ABTS for everything on the txcmplq */
4159 list_for_each_entry_safe(iocb
, next_iocb
, &pring
->txcmplq
,
4161 if (iocb
->vport
!= vport
)
4163 lpfc_sli_issue_abort_iotag(phba
, pring
, iocb
);
4166 pring
->flag
= prev_pring_flag
;
4169 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
4171 while (!list_empty(&completions
)) {
4172 list_remove_head(&completions
, iocb
, struct lpfc_iocbq
, list
);
4174 if (!iocb
->iocb_cmpl
)
4175 lpfc_sli_release_iocbq(phba
, iocb
);
4177 iocb
->iocb
.ulpStatus
= IOSTAT_LOCAL_REJECT
;
4178 iocb
->iocb
.un
.ulpWord
[4] = IOERR_SLI_DOWN
;
4179 (iocb
->iocb_cmpl
) (phba
, iocb
, iocb
);
4186 * lpfc_sli_hba_down: Resource cleanup function for the HBA.
4187 * @phba: Pointer to HBA context object.
4189 * This function cleans up all iocb, buffers, mailbox commands
4190 * while shutting down the HBA. This function is called with no
4191 * lock held and always returns 1.
4192 * This function does the following to cleanup driver resources:
4193 * - Free discovery resources for each virtual port
4194 * - Cleanup any pending fabric iocbs
4195 * - Iterate through the iocb txq and free each entry
4197 * - Free up any buffer posted to the HBA
4198 * - Free mailbox commands in the mailbox queue.
4201 lpfc_sli_hba_down(struct lpfc_hba
*phba
)
4203 LIST_HEAD(completions
);
4204 struct lpfc_sli
*psli
= &phba
->sli
;
4205 struct lpfc_sli_ring
*pring
;
4206 struct lpfc_dmabuf
*buf_ptr
;
4208 struct lpfc_iocbq
*iocb
;
4211 unsigned long flags
= 0;
4213 lpfc_hba_down_prep(phba
);
4215 lpfc_fabric_abort_hba(phba
);
4217 spin_lock_irqsave(&phba
->hbalock
, flags
);
4218 for (i
= 0; i
< psli
->num_rings
; i
++) {
4219 pring
= &psli
->ring
[i
];
4220 /* Only slow rings */
4221 if (pring
->ringno
== LPFC_ELS_RING
) {
4222 pring
->flag
|= LPFC_DEFERRED_RING_EVENT
;
4223 /* Set the lpfc data pending flag */
4224 set_bit(LPFC_DATA_READY
, &phba
->data_flags
);
4228 * Error everything on the txq since these iocbs have not been
4229 * given to the FW yet.
4231 list_splice_init(&pring
->txq
, &completions
);
4235 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
4237 while (!list_empty(&completions
)) {
4238 list_remove_head(&completions
, iocb
, struct lpfc_iocbq
, list
);
4241 if (!iocb
->iocb_cmpl
)
4242 lpfc_sli_release_iocbq(phba
, iocb
);
4244 cmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
4245 cmd
->un
.ulpWord
[4] = IOERR_SLI_DOWN
;
4246 (iocb
->iocb_cmpl
) (phba
, iocb
, iocb
);
4250 spin_lock_irqsave(&phba
->hbalock
, flags
);
4251 list_splice_init(&phba
->elsbuf
, &completions
);
4252 phba
->elsbuf_cnt
= 0;
4253 phba
->elsbuf_prev_cnt
= 0;
4254 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
4256 while (!list_empty(&completions
)) {
4257 list_remove_head(&completions
, buf_ptr
,
4258 struct lpfc_dmabuf
, list
);
4259 lpfc_mbuf_free(phba
, buf_ptr
->virt
, buf_ptr
->phys
);
4263 /* Return any active mbox cmds */
4264 del_timer_sync(&psli
->mbox_tmo
);
4265 spin_lock_irqsave(&phba
->hbalock
, flags
);
4267 spin_lock(&phba
->pport
->work_port_lock
);
4268 phba
->pport
->work_port_events
&= ~WORKER_MBOX_TMO
;
4269 spin_unlock(&phba
->pport
->work_port_lock
);
4271 /* Return any pending or completed mbox cmds */
4272 list_splice_init(&phba
->sli
.mboxq
, &completions
);
4273 if (psli
->mbox_active
) {
4274 list_add_tail(&psli
->mbox_active
->list
, &completions
);
4275 psli
->mbox_active
= NULL
;
4276 psli
->sli_flag
&= ~LPFC_SLI_MBOX_ACTIVE
;
4278 list_splice_init(&phba
->sli
.mboxq_cmpl
, &completions
);
4279 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
4281 while (!list_empty(&completions
)) {
4282 list_remove_head(&completions
, pmb
, LPFC_MBOXQ_t
, list
);
4283 pmb
->mb
.mbxStatus
= MBX_NOT_FINISHED
;
4285 pmb
->mbox_cmpl(phba
,pmb
);
4291 * lpfc_sli_pcimem_bcopy: SLI memory copy function.
4292 * @srcp: Source memory pointer.
4293 * @destp: Destination memory pointer.
4294 * @cnt: Number of words required to be copied.
4296 * This function is used for copying data between driver memory
4297 * and the SLI memory. This function also changes the endianness
4298 * of each word if native endianness is different from SLI
4299 * endianness. This function can be called with or without
4303 lpfc_sli_pcimem_bcopy(void *srcp
, void *destp
, uint32_t cnt
)
4305 uint32_t *src
= srcp
;
4306 uint32_t *dest
= destp
;
4310 for (i
= 0; i
< (int)cnt
; i
+= sizeof (uint32_t)) {
4312 ldata
= le32_to_cpu(ldata
);
4321 * lpfc_sli_ringpostbuf_put: Function to add a buffer to postbufq.
4322 * @phba: Pointer to HBA context object.
4323 * @pring: Pointer to driver SLI ring object.
4324 * @mp: Pointer to driver buffer object.
4326 * This function is called with no lock held.
4327 * It always return zero after adding the buffer to the postbufq
4331 lpfc_sli_ringpostbuf_put(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
4332 struct lpfc_dmabuf
*mp
)
4334 /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
4336 spin_lock_irq(&phba
->hbalock
);
4337 list_add_tail(&mp
->list
, &pring
->postbufq
);
4338 pring
->postbufq_cnt
++;
4339 spin_unlock_irq(&phba
->hbalock
);
4344 * lpfc_sli_get_buffer_tag: Tag allocation function for a buffer posted
4345 * using CMD_QUE_XRI64_CX iocb.
4346 * @phba: Pointer to HBA context object.
4348 * When HBQ is enabled, buffers are searched based on tags. This function
4349 * allocates a tag for buffer posted using CMD_QUE_XRI64_CX iocb. The
4350 * tag is bit wise or-ed with QUE_BUFTAG_BIT to make sure that the tag
4351 * does not conflict with tags of buffer posted for unsolicited events.
4352 * The function returns the allocated tag. The function is called with
4356 lpfc_sli_get_buffer_tag(struct lpfc_hba
*phba
)
4358 spin_lock_irq(&phba
->hbalock
);
4359 phba
->buffer_tag_count
++;
4361 * Always set the QUE_BUFTAG_BIT to distiguish between
4362 * a tag assigned by HBQ.
4364 phba
->buffer_tag_count
|= QUE_BUFTAG_BIT
;
4365 spin_unlock_irq(&phba
->hbalock
);
4366 return phba
->buffer_tag_count
;
4370 * lpfc_sli_ring_taggedbuf_get: Search HBQ buffer associated with
4371 * posted using CMD_QUE_XRI64_CX iocb.
4372 * @phba: Pointer to HBA context object.
4373 * @pring: Pointer to driver SLI ring object.
4376 * Buffers posted using CMD_QUE_XRI64_CX iocb are in pring->postbufq
4377 * list. After HBA DMA data to these buffers, CMD_IOCB_RET_XRI64_CX
4378 * iocb is posted to the response ring with the tag of the buffer.
4379 * This function searches the pring->postbufq list using the tag
4380 * to find buffer associated with CMD_IOCB_RET_XRI64_CX
4381 * iocb. If the buffer is found then lpfc_dmabuf object of the
4382 * buffer is returned to the caller else NULL is returned.
4383 * This function is called with no lock held.
4385 struct lpfc_dmabuf
*
4386 lpfc_sli_ring_taggedbuf_get(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
4389 struct lpfc_dmabuf
*mp
, *next_mp
;
4390 struct list_head
*slp
= &pring
->postbufq
;
4392 /* Search postbufq, from the begining, looking for a match on tag */
4393 spin_lock_irq(&phba
->hbalock
);
4394 list_for_each_entry_safe(mp
, next_mp
, &pring
->postbufq
, list
) {
4395 if (mp
->buffer_tag
== tag
) {
4396 list_del_init(&mp
->list
);
4397 pring
->postbufq_cnt
--;
4398 spin_unlock_irq(&phba
->hbalock
);
4403 spin_unlock_irq(&phba
->hbalock
);
4404 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
4405 "0402 Cannot find virtual addr for buffer tag on "
4406 "ring %d Data x%lx x%p x%p x%x\n",
4407 pring
->ringno
, (unsigned long) tag
,
4408 slp
->next
, slp
->prev
, pring
->postbufq_cnt
);
4414 * lpfc_sli_ringpostbuf_get: SLI2 buffer search function for
4415 * unsolicited ct and els events.
4416 * @phba: Pointer to HBA context object.
4417 * @pring: Pointer to driver SLI ring object.
4418 * @phys: DMA address of the buffer.
4420 * This function searches the buffer list using the dma_address
4421 * of unsolicited event to find the driver's lpfc_dmabuf object
4422 * corresponding to the dma_address. The function returns the
4423 * lpfc_dmabuf object if a buffer is found else it returns NULL.
4424 * This function is called by the ct and els unsolicited event
4425 * handlers to get the buffer associated with the unsolicited
4428 * This function is called with no lock held.
4430 struct lpfc_dmabuf
*
4431 lpfc_sli_ringpostbuf_get(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
4434 struct lpfc_dmabuf
*mp
, *next_mp
;
4435 struct list_head
*slp
= &pring
->postbufq
;
4437 /* Search postbufq, from the begining, looking for a match on phys */
4438 spin_lock_irq(&phba
->hbalock
);
4439 list_for_each_entry_safe(mp
, next_mp
, &pring
->postbufq
, list
) {
4440 if (mp
->phys
== phys
) {
4441 list_del_init(&mp
->list
);
4442 pring
->postbufq_cnt
--;
4443 spin_unlock_irq(&phba
->hbalock
);
4448 spin_unlock_irq(&phba
->hbalock
);
4449 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
4450 "0410 Cannot find virtual addr for mapped buf on "
4451 "ring %d Data x%llx x%p x%p x%x\n",
4452 pring
->ringno
, (unsigned long long)phys
,
4453 slp
->next
, slp
->prev
, pring
->postbufq_cnt
);
4458 * lpfc_sli_abort_els_cmpl: Completion handler for the els abort iocbs.
4459 * @phba: Pointer to HBA context object.
4460 * @cmdiocb: Pointer to driver command iocb object.
4461 * @rspiocb: Pointer to driver response iocb object.
4463 * This function is the completion handler for the abort iocbs for
4464 * ELS commands. This function is called from the ELS ring event
4465 * handler with no lock held. This function frees memory resources
4466 * associated with the abort iocb.
4469 lpfc_sli_abort_els_cmpl(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
4470 struct lpfc_iocbq
*rspiocb
)
4472 IOCB_t
*irsp
= &rspiocb
->iocb
;
4473 uint16_t abort_iotag
, abort_context
;
4474 struct lpfc_iocbq
*abort_iocb
;
4475 struct lpfc_sli_ring
*pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
4479 if (irsp
->ulpStatus
) {
4480 abort_context
= cmdiocb
->iocb
.un
.acxri
.abortContextTag
;
4481 abort_iotag
= cmdiocb
->iocb
.un
.acxri
.abortIoTag
;
4483 spin_lock_irq(&phba
->hbalock
);
4484 if (abort_iotag
!= 0 && abort_iotag
<= phba
->sli
.last_iotag
)
4485 abort_iocb
= phba
->sli
.iocbq_lookup
[abort_iotag
];
4487 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
| LOG_SLI
,
4488 "0327 Cannot abort els iocb %p "
4489 "with tag %x context %x, abort status %x, "
4491 abort_iocb
, abort_iotag
, abort_context
,
4492 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4]);
4495 * If the iocb is not found in Firmware queue the iocb
4496 * might have completed already. Do not free it again.
4498 if (irsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) {
4499 spin_unlock_irq(&phba
->hbalock
);
4500 lpfc_sli_release_iocbq(phba
, cmdiocb
);
4504 * make sure we have the right iocbq before taking it
4505 * off the txcmplq and try to call completion routine.
4508 abort_iocb
->iocb
.ulpContext
!= abort_context
||
4509 (abort_iocb
->iocb_flag
& LPFC_DRIVER_ABORTED
) == 0)
4510 spin_unlock_irq(&phba
->hbalock
);
4512 list_del_init(&abort_iocb
->list
);
4513 pring
->txcmplq_cnt
--;
4514 spin_unlock_irq(&phba
->hbalock
);
4516 /* Firmware could still be in progress of DMAing
4517 * payload, so don't free data buffer till after
4520 abort_iocb
->iocb_flag
|= LPFC_DELAY_MEM_FREE
;
4522 abort_iocb
->iocb_flag
&= ~LPFC_DRIVER_ABORTED
;
4523 abort_iocb
->iocb
.ulpStatus
= IOSTAT_LOCAL_REJECT
;
4524 abort_iocb
->iocb
.un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
4525 (abort_iocb
->iocb_cmpl
)(phba
, abort_iocb
, abort_iocb
);
4529 lpfc_sli_release_iocbq(phba
, cmdiocb
);
4534 * lpfc_ignore_els_cmpl: Completion handler for aborted ELS command.
4535 * @phba: Pointer to HBA context object.
4536 * @cmdiocb: Pointer to driver command iocb object.
4537 * @rspiocb: Pointer to driver response iocb object.
4539 * The function is called from SLI ring event handler with no
4540 * lock held. This function is the completion handler for ELS commands
4541 * which are aborted. The function frees memory resources used for
4542 * the aborted ELS commands.
4545 lpfc_ignore_els_cmpl(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
4546 struct lpfc_iocbq
*rspiocb
)
4548 IOCB_t
*irsp
= &rspiocb
->iocb
;
4550 /* ELS cmd tag <ulpIoTag> completes */
4551 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
4552 "0139 Ignoring ELS cmd tag x%x completion Data: "
4554 irsp
->ulpIoTag
, irsp
->ulpStatus
,
4555 irsp
->un
.ulpWord
[4], irsp
->ulpTimeout
);
4556 if (cmdiocb
->iocb
.ulpCommand
== CMD_GEN_REQUEST64_CR
)
4557 lpfc_ct_free_iocb(phba
, cmdiocb
);
4559 lpfc_els_free_iocb(phba
, cmdiocb
);
4564 * lpfc_sli_issue_abort_iotag: Abort function for a command iocb.
4565 * @phba: Pointer to HBA context object.
4566 * @pring: Pointer to driver SLI ring object.
4567 * @cmdiocb: Pointer to driver command iocb object.
4569 * This function issues an abort iocb for the provided command
4570 * iocb. This function is called with hbalock held.
4571 * The function returns 0 when it fails due to memory allocation
4572 * failure or when the command iocb is an abort request.
4575 lpfc_sli_issue_abort_iotag(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
4576 struct lpfc_iocbq
*cmdiocb
)
4578 struct lpfc_vport
*vport
= cmdiocb
->vport
;
4579 struct lpfc_iocbq
*abtsiocbp
;
4580 IOCB_t
*icmd
= NULL
;
4581 IOCB_t
*iabt
= NULL
;
4582 int retval
= IOCB_ERROR
;
4585 * There are certain command types we don't want to abort. And we
4586 * don't want to abort commands that are already in the process of
4589 icmd
= &cmdiocb
->iocb
;
4590 if (icmd
->ulpCommand
== CMD_ABORT_XRI_CN
||
4591 icmd
->ulpCommand
== CMD_CLOSE_XRI_CN
||
4592 (cmdiocb
->iocb_flag
& LPFC_DRIVER_ABORTED
) != 0)
4595 /* If we're unloading, don't abort iocb on the ELS ring, but change the
4596 * callback so that nothing happens when it finishes.
4598 if ((vport
->load_flag
& FC_UNLOADING
) &&
4599 (pring
->ringno
== LPFC_ELS_RING
)) {
4600 if (cmdiocb
->iocb_flag
& LPFC_IO_FABRIC
)
4601 cmdiocb
->fabric_iocb_cmpl
= lpfc_ignore_els_cmpl
;
4603 cmdiocb
->iocb_cmpl
= lpfc_ignore_els_cmpl
;
4604 goto abort_iotag_exit
;
4607 /* issue ABTS for this IOCB based on iotag */
4608 abtsiocbp
= __lpfc_sli_get_iocbq(phba
);
4609 if (abtsiocbp
== NULL
)
4612 /* This signals the response to set the correct status
4613 * before calling the completion handler.
4615 cmdiocb
->iocb_flag
|= LPFC_DRIVER_ABORTED
;
4617 iabt
= &abtsiocbp
->iocb
;
4618 iabt
->un
.acxri
.abortType
= ABORT_TYPE_ABTS
;
4619 iabt
->un
.acxri
.abortContextTag
= icmd
->ulpContext
;
4620 iabt
->un
.acxri
.abortIoTag
= icmd
->ulpIoTag
;
4622 iabt
->ulpClass
= icmd
->ulpClass
;
4624 if (phba
->link_state
>= LPFC_LINK_UP
)
4625 iabt
->ulpCommand
= CMD_ABORT_XRI_CN
;
4627 iabt
->ulpCommand
= CMD_CLOSE_XRI_CN
;
4629 abtsiocbp
->iocb_cmpl
= lpfc_sli_abort_els_cmpl
;
4631 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_SLI
,
4632 "0339 Abort xri x%x, original iotag x%x, "
4633 "abort cmd iotag x%x\n",
4634 iabt
->un
.acxri
.abortContextTag
,
4635 iabt
->un
.acxri
.abortIoTag
, abtsiocbp
->iotag
);
4636 retval
= __lpfc_sli_issue_iocb(phba
, pring
, abtsiocbp
, 0);
4639 __lpfc_sli_release_iocbq(phba
, abtsiocbp
);
4642 * Caller to this routine should check for IOCB_ERROR
4643 * and handle it properly. This routine no longer removes
4644 * iocb off txcmplq and call compl in case of IOCB_ERROR.
4650 * lpfc_sli_validate_fcp_iocb: Filtering function, used to find commands
4651 * associated with a vport/SCSI target/lun.
4652 * @iocbq: Pointer to driver iocb object.
4653 * @vport: Pointer to driver virtual port object.
4654 * @tgt_id: SCSI ID of the target.
4655 * @lun_id: LUN ID of the scsi device.
4656 * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST
4658 * This function acts as iocb filter for functions which abort or count
4659 * all FCP iocbs pending on a lun/SCSI target/SCSI host. It will return
4660 * 0 if the filtering criteria is met for the given iocb and will return
4661 * 1 if the filtering criteria is not met.
4662 * If ctx_cmd == LPFC_CTX_LUN, the function returns 0 only if the
4663 * given iocb is for the SCSI device specified by vport, tgt_id and
4665 * If ctx_cmd == LPFC_CTX_TGT, the function returns 0 only if the
4666 * given iocb is for the SCSI target specified by vport and tgt_id
4668 * If ctx_cmd == LPFC_CTX_HOST, the function returns 0 only if the
4669 * given iocb is for the SCSI host associated with the given vport.
4670 * This function is called with no locks held.
4673 lpfc_sli_validate_fcp_iocb(struct lpfc_iocbq
*iocbq
, struct lpfc_vport
*vport
,
4674 uint16_t tgt_id
, uint64_t lun_id
,
4675 lpfc_ctx_cmd ctx_cmd
)
4677 struct lpfc_scsi_buf
*lpfc_cmd
;
4680 if (!(iocbq
->iocb_flag
& LPFC_IO_FCP
))
4683 if (iocbq
->vport
!= vport
)
4686 lpfc_cmd
= container_of(iocbq
, struct lpfc_scsi_buf
, cur_iocbq
);
4688 if (lpfc_cmd
->pCmd
== NULL
)
4693 if ((lpfc_cmd
->rdata
->pnode
) &&
4694 (lpfc_cmd
->rdata
->pnode
->nlp_sid
== tgt_id
) &&
4695 (scsilun_to_int(&lpfc_cmd
->fcp_cmnd
->fcp_lun
) == lun_id
))
4699 if ((lpfc_cmd
->rdata
->pnode
) &&
4700 (lpfc_cmd
->rdata
->pnode
->nlp_sid
== tgt_id
))
4707 printk(KERN_ERR
"%s: Unknown context cmd type, value %d\n",
4716 * lpfc_sli_sum_iocb: Function to count the number of FCP iocbs pending.
4717 * @vport: Pointer to virtual port.
4718 * @tgt_id: SCSI ID of the target.
4719 * @lun_id: LUN ID of the scsi device.
4720 * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
4722 * This function returns number of FCP commands pending for the vport.
4723 * When ctx_cmd == LPFC_CTX_LUN, the function returns number of FCP
4724 * commands pending on the vport associated with SCSI device specified
4725 * by tgt_id and lun_id parameters.
4726 * When ctx_cmd == LPFC_CTX_TGT, the function returns number of FCP
4727 * commands pending on the vport associated with SCSI target specified
4728 * by tgt_id parameter.
4729 * When ctx_cmd == LPFC_CTX_HOST, the function returns number of FCP
4730 * commands pending on the vport.
4731 * This function returns the number of iocbs which satisfy the filter.
4732 * This function is called without any lock held.
4735 lpfc_sli_sum_iocb(struct lpfc_vport
*vport
, uint16_t tgt_id
, uint64_t lun_id
,
4736 lpfc_ctx_cmd ctx_cmd
)
4738 struct lpfc_hba
*phba
= vport
->phba
;
4739 struct lpfc_iocbq
*iocbq
;
4742 for (i
= 1, sum
= 0; i
<= phba
->sli
.last_iotag
; i
++) {
4743 iocbq
= phba
->sli
.iocbq_lookup
[i
];
4745 if (lpfc_sli_validate_fcp_iocb (iocbq
, vport
, tgt_id
, lun_id
,
4754 * lpfc_sli_abort_fcp_cmpl: Completion handler function for an aborted
4756 * @phba: Pointer to HBA context object
4757 * @cmdiocb: Pointer to command iocb object.
4758 * @rspiocb: Pointer to response iocb object.
4760 * This function is called when an aborted FCP iocb completes. This
4761 * function is called by the ring event handler with no lock held.
4762 * This function frees the iocb.
4765 lpfc_sli_abort_fcp_cmpl(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
4766 struct lpfc_iocbq
*rspiocb
)
4768 lpfc_sli_release_iocbq(phba
, cmdiocb
);
4773 * lpfc_sli_abort_iocb: This function issue abort for all SCSI commands
4774 * pending on a SCSI host(vport)/target/lun.
4775 * @vport: Pointer to virtual port.
4776 * @pring: Pointer to driver SLI ring object.
4777 * @tgt_id: SCSI ID of the target.
4778 * @lun_id: LUN ID of the scsi device.
4779 * @abort_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
4781 * This function sends an abort command for every SCSI command
4782 * associated with the given virtual port pending on the ring
4783 * filtered by lpfc_sli_validate_fcp_iocb function.
4784 * When abort_cmd == LPFC_CTX_LUN, the function sends abort only to the
4785 * FCP iocbs associated with lun specified by tgt_id and lun_id
4787 * When abort_cmd == LPFC_CTX_TGT, the function sends abort only to the
4788 * FCP iocbs associated with SCSI target specified by tgt_id parameter.
4789 * When abort_cmd == LPFC_CTX_HOST, the function sends abort to all
4790 * FCP iocbs associated with virtual port.
4791 * This function returns number of iocbs it failed to abort.
4792 * This function is called with no locks held.
4795 lpfc_sli_abort_iocb(struct lpfc_vport
*vport
, struct lpfc_sli_ring
*pring
,
4796 uint16_t tgt_id
, uint64_t lun_id
, lpfc_ctx_cmd abort_cmd
)
4798 struct lpfc_hba
*phba
= vport
->phba
;
4799 struct lpfc_iocbq
*iocbq
;
4800 struct lpfc_iocbq
*abtsiocb
;
4802 int errcnt
= 0, ret_val
= 0;
4805 for (i
= 1; i
<= phba
->sli
.last_iotag
; i
++) {
4806 iocbq
= phba
->sli
.iocbq_lookup
[i
];
4808 if (lpfc_sli_validate_fcp_iocb(iocbq
, vport
, tgt_id
, lun_id
,
4812 /* issue ABTS for this IOCB based on iotag */
4813 abtsiocb
= lpfc_sli_get_iocbq(phba
);
4814 if (abtsiocb
== NULL
) {
4820 abtsiocb
->iocb
.un
.acxri
.abortType
= ABORT_TYPE_ABTS
;
4821 abtsiocb
->iocb
.un
.acxri
.abortContextTag
= cmd
->ulpContext
;
4822 abtsiocb
->iocb
.un
.acxri
.abortIoTag
= cmd
->ulpIoTag
;
4823 abtsiocb
->iocb
.ulpLe
= 1;
4824 abtsiocb
->iocb
.ulpClass
= cmd
->ulpClass
;
4825 abtsiocb
->vport
= phba
->pport
;
4827 if (lpfc_is_link_up(phba
))
4828 abtsiocb
->iocb
.ulpCommand
= CMD_ABORT_XRI_CN
;
4830 abtsiocb
->iocb
.ulpCommand
= CMD_CLOSE_XRI_CN
;
4832 /* Setup callback routine and issue the command. */
4833 abtsiocb
->iocb_cmpl
= lpfc_sli_abort_fcp_cmpl
;
4834 ret_val
= lpfc_sli_issue_iocb(phba
, pring
, abtsiocb
, 0);
4835 if (ret_val
== IOCB_ERROR
) {
4836 lpfc_sli_release_iocbq(phba
, abtsiocb
);
4846 * lpfc_sli_wake_iocb_wait: iocb completion handler for iocb issued using
4847 * lpfc_sli_issue_iocb_wait.
4848 * @phba: Pointer to HBA context object.
4849 * @cmdiocbq: Pointer to command iocb.
4850 * @rspiocbq: Pointer to response iocb.
4852 * This function is the completion handler for iocbs issued using
4853 * lpfc_sli_issue_iocb_wait function. This function is called by the
4854 * ring event handler function without any lock held. This function
4855 * can be called from both worker thread context and interrupt
4856 * context. This function also can be called from other thread which
4857 * cleans up the SLI layer objects.
4858 * This function copy the contents of the response iocb to the
4859 * response iocb memory object provided by the caller of
4860 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
4861 * sleeps for the iocb completion.
4864 lpfc_sli_wake_iocb_wait(struct lpfc_hba
*phba
,
4865 struct lpfc_iocbq
*cmdiocbq
,
4866 struct lpfc_iocbq
*rspiocbq
)
4868 wait_queue_head_t
*pdone_q
;
4869 unsigned long iflags
;
4871 spin_lock_irqsave(&phba
->hbalock
, iflags
);
4872 cmdiocbq
->iocb_flag
|= LPFC_IO_WAKE
;
4873 if (cmdiocbq
->context2
&& rspiocbq
)
4874 memcpy(&((struct lpfc_iocbq
*)cmdiocbq
->context2
)->iocb
,
4875 &rspiocbq
->iocb
, sizeof(IOCB_t
));
4877 pdone_q
= cmdiocbq
->context_un
.wait_queue
;
4880 spin_unlock_irqrestore(&phba
->hbalock
, iflags
);
4885 * lpfc_sli_issue_iocb_wait: Synchronous function to issue iocb commands.
4886 * @phba: Pointer to HBA context object..
4887 * @pring: Pointer to sli ring.
4888 * @piocb: Pointer to command iocb.
4889 * @prspiocbq: Pointer to response iocb.
4890 * @timeout: Timeout in number of seconds.
4892 * This function issues the iocb to firmware and waits for the
4893 * iocb to complete. If the iocb command is not
4894 * completed within timeout seconds, it returns IOCB_TIMEDOUT.
4895 * Caller should not free the iocb resources if this function
4896 * returns IOCB_TIMEDOUT.
4897 * The function waits for the iocb completion using an
4898 * non-interruptible wait.
4899 * This function will sleep while waiting for iocb completion.
4900 * So, this function should not be called from any context which
4901 * does not allow sleeping. Due to the same reason, this function
4902 * cannot be called with interrupt disabled.
4903 * This function assumes that the iocb completions occur while
4904 * this function sleep. So, this function cannot be called from
4905 * the thread which process iocb completion for this ring.
4906 * This function clears the iocb_flag of the iocb object before
4907 * issuing the iocb and the iocb completion handler sets this
4908 * flag and wakes this thread when the iocb completes.
4909 * The contents of the response iocb will be copied to prspiocbq
4910 * by the completion handler when the command completes.
4911 * This function returns IOCB_SUCCESS when success.
4912 * This function is called with no lock held.
4915 lpfc_sli_issue_iocb_wait(struct lpfc_hba
*phba
,
4916 struct lpfc_sli_ring
*pring
,
4917 struct lpfc_iocbq
*piocb
,
4918 struct lpfc_iocbq
*prspiocbq
,
4921 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q
);
4922 long timeleft
, timeout_req
= 0;
4923 int retval
= IOCB_SUCCESS
;
4927 * If the caller has provided a response iocbq buffer, then context2
4928 * is NULL or its an error.
4931 if (piocb
->context2
)
4933 piocb
->context2
= prspiocbq
;
4936 piocb
->iocb_cmpl
= lpfc_sli_wake_iocb_wait
;
4937 piocb
->context_un
.wait_queue
= &done_q
;
4938 piocb
->iocb_flag
&= ~LPFC_IO_WAKE
;
4940 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
) {
4941 creg_val
= readl(phba
->HCregaddr
);
4942 creg_val
|= (HC_R0INT_ENA
<< LPFC_FCP_RING
);
4943 writel(creg_val
, phba
->HCregaddr
);
4944 readl(phba
->HCregaddr
); /* flush */
4947 retval
= lpfc_sli_issue_iocb(phba
, pring
, piocb
, 0);
4948 if (retval
== IOCB_SUCCESS
) {
4949 timeout_req
= timeout
* HZ
;
4950 timeleft
= wait_event_timeout(done_q
,
4951 piocb
->iocb_flag
& LPFC_IO_WAKE
,
4954 if (piocb
->iocb_flag
& LPFC_IO_WAKE
) {
4955 lpfc_printf_log(phba
, KERN_INFO
, LOG_SLI
,
4956 "0331 IOCB wake signaled\n");
4957 } else if (timeleft
== 0) {
4958 lpfc_printf_log(phba
, KERN_ERR
, LOG_SLI
,
4959 "0338 IOCB wait timeout error - no "
4960 "wake response Data x%x\n", timeout
);
4961 retval
= IOCB_TIMEDOUT
;
4963 lpfc_printf_log(phba
, KERN_ERR
, LOG_SLI
,
4964 "0330 IOCB wake NOT set, "
4966 timeout
, (timeleft
/ jiffies
));
4967 retval
= IOCB_TIMEDOUT
;
4970 lpfc_printf_log(phba
, KERN_INFO
, LOG_SLI
,
4971 "0332 IOCB wait issue failed, Data x%x\n",
4973 retval
= IOCB_ERROR
;
4976 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
) {
4977 creg_val
= readl(phba
->HCregaddr
);
4978 creg_val
&= ~(HC_R0INT_ENA
<< LPFC_FCP_RING
);
4979 writel(creg_val
, phba
->HCregaddr
);
4980 readl(phba
->HCregaddr
); /* flush */
4984 piocb
->context2
= NULL
;
4986 piocb
->context_un
.wait_queue
= NULL
;
4987 piocb
->iocb_cmpl
= NULL
;
4992 * lpfc_sli_issue_mbox_wait: Synchronous function to issue mailbox.
4993 * @phba: Pointer to HBA context object.
4994 * @pmboxq: Pointer to driver mailbox object.
4995 * @timeout: Timeout in number of seconds.
4997 * This function issues the mailbox to firmware and waits for the
4998 * mailbox command to complete. If the mailbox command is not
4999 * completed within timeout seconds, it returns MBX_TIMEOUT.
5000 * The function waits for the mailbox completion using an
5001 * interruptible wait. If the thread is woken up due to a
5002 * signal, MBX_TIMEOUT error is returned to the caller. Caller
5003 * should not free the mailbox resources, if this function returns
5005 * This function will sleep while waiting for mailbox completion.
5006 * So, this function should not be called from any context which
5007 * does not allow sleeping. Due to the same reason, this function
5008 * cannot be called with interrupt disabled.
5009 * This function assumes that the mailbox completion occurs while
5010 * this function sleep. So, this function cannot be called from
5011 * the worker thread which processes mailbox completion.
5012 * This function is called in the context of HBA management
5014 * This function returns MBX_SUCCESS when successful.
5015 * This function is called with no lock held.
5018 lpfc_sli_issue_mbox_wait(struct lpfc_hba
*phba
, LPFC_MBOXQ_t
*pmboxq
,
5021 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q
);
5025 /* The caller must leave context1 empty. */
5026 if (pmboxq
->context1
)
5027 return MBX_NOT_FINISHED
;
5029 pmboxq
->mbox_flag
&= ~LPFC_MBX_WAKE
;
5030 /* setup wake call as IOCB callback */
5031 pmboxq
->mbox_cmpl
= lpfc_sli_wake_mbox_wait
;
5032 /* setup context field to pass wait_queue pointer to wake function */
5033 pmboxq
->context1
= &done_q
;
5035 /* now issue the command */
5036 retval
= lpfc_sli_issue_mbox(phba
, pmboxq
, MBX_NOWAIT
);
5038 if (retval
== MBX_BUSY
|| retval
== MBX_SUCCESS
) {
5039 wait_event_interruptible_timeout(done_q
,
5040 pmboxq
->mbox_flag
& LPFC_MBX_WAKE
,
5043 spin_lock_irqsave(&phba
->hbalock
, flag
);
5044 pmboxq
->context1
= NULL
;
5046 * if LPFC_MBX_WAKE flag is set the mailbox is completed
5047 * else do not free the resources.
5049 if (pmboxq
->mbox_flag
& LPFC_MBX_WAKE
)
5050 retval
= MBX_SUCCESS
;
5052 retval
= MBX_TIMEOUT
;
5053 pmboxq
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
5055 spin_unlock_irqrestore(&phba
->hbalock
, flag
);
5062 * lpfc_sli_flush_mbox_queue: mailbox queue cleanup function.
5063 * @phba: Pointer to HBA context.
5065 * This function is called to cleanup any pending mailbox
5066 * objects in the driver queue before bringing the HBA offline.
5067 * This function is called while resetting the HBA.
5068 * The function is called without any lock held. The function
5069 * takes hbalock to update SLI data structure.
5070 * This function returns 1 when there is an active mailbox
5071 * command pending else returns 0.
5074 lpfc_sli_flush_mbox_queue(struct lpfc_hba
* phba
)
5076 struct lpfc_vport
*vport
= phba
->pport
;
5080 while (phba
->sli
.sli_flag
& LPFC_SLI_MBOX_ACTIVE
&& !vport
->stopped
) {
5081 if (i
++ > LPFC_MBOX_TMO
* 1000)
5085 * Call lpfc_sli_handle_mb_event only if a mailbox cmd
5086 * did finish. This way we won't get the misleading
5087 * "Stray Mailbox Interrupt" message.
5089 spin_lock_irq(&phba
->hbalock
);
5090 ha_copy
= phba
->work_ha
;
5091 phba
->work_ha
&= ~HA_MBATT
;
5092 spin_unlock_irq(&phba
->hbalock
);
5094 if (ha_copy
& HA_MBATT
)
5095 if (lpfc_sli_handle_mb_event(phba
) == 0)
5101 return (phba
->sli
.sli_flag
& LPFC_SLI_MBOX_ACTIVE
) ? 1 : 0;
5105 * lpfc_sli_check_eratt: check error attention events
5106 * @phba: Pointer to HBA context.
5108 * This function is called form timer soft interrupt context to check HBA's
5109 * error attention register bit for error attention events.
5111 * This fucntion returns 1 when there is Error Attention in the Host Attention
5112 * Register and returns 0 otherwise.
5115 lpfc_sli_check_eratt(struct lpfc_hba
*phba
)
5119 /* If PCI channel is offline, don't process it */
5120 if (unlikely(pci_channel_offline(phba
->pcidev
)))
5123 /* If somebody is waiting to handle an eratt, don't process it
5124 * here. The brdkill function will do this.
5126 if (phba
->link_flag
& LS_IGNORE_ERATT
)
5129 /* Check if interrupt handler handles this ERATT */
5130 spin_lock_irq(&phba
->hbalock
);
5131 if (phba
->hba_flag
& HBA_ERATT_HANDLED
) {
5132 /* Interrupt handler has handled ERATT */
5133 spin_unlock_irq(&phba
->hbalock
);
5137 /* Read chip Host Attention (HA) register */
5138 ha_copy
= readl(phba
->HAregaddr
);
5139 if (ha_copy
& HA_ERATT
) {
5140 /* Read host status register to retrieve error event */
5141 lpfc_sli_read_hs(phba
);
5142 /* Set the driver HA work bitmap */
5143 phba
->work_ha
|= HA_ERATT
;
5144 /* Indicate polling handles this ERATT */
5145 phba
->hba_flag
|= HBA_ERATT_HANDLED
;
5146 spin_unlock_irq(&phba
->hbalock
);
5149 spin_unlock_irq(&phba
->hbalock
);
5154 * lpfc_sp_intr_handler: The slow-path interrupt handler of lpfc driver.
5155 * @irq: Interrupt number.
5156 * @dev_id: The device context pointer.
5158 * This function is directly called from the PCI layer as an interrupt
5159 * service routine when the device is enabled with MSI-X multi-message
5160 * interrupt mode and there are slow-path events in the HBA. However,
5161 * when the device is enabled with either MSI or Pin-IRQ interrupt mode,
5162 * this function is called as part of the device-level interrupt handler.
5163 * When the PCI slot is in error recovery or the HBA is undergoing
5164 * initialization, the interrupt handler will not process the interrupt.
5165 * The link attention and ELS ring attention events are handled by the
5166 * worker thread. The interrupt handler signals the worker thread and
5167 * and returns for these events. This function is called without any
5168 * lock held. It gets the hbalock to access and update SLI data
5171 * This function returns IRQ_HANDLED when interrupt is handled else it
5175 lpfc_sp_intr_handler(int irq
, void *dev_id
)
5177 struct lpfc_hba
*phba
;
5179 uint32_t work_ha_copy
;
5180 unsigned long status
;
5181 unsigned long iflag
;
5184 MAILBOX_t
*mbox
, *pmbox
;
5185 struct lpfc_vport
*vport
;
5186 struct lpfc_nodelist
*ndlp
;
5187 struct lpfc_dmabuf
*mp
;
5192 * Get the driver's phba structure from the dev_id and
5193 * assume the HBA is not interrupting.
5195 phba
= (struct lpfc_hba
*)dev_id
;
5197 if (unlikely(!phba
))
5201 * Stuff needs to be attented to when this function is invoked as an
5202 * individual interrupt handler in MSI-X multi-message interrupt mode
5204 if (phba
->intr_type
== MSIX
) {
5205 /* If the pci channel is offline, ignore all the interrupts */
5206 if (unlikely(pci_channel_offline(phba
->pcidev
)))
5208 /* Update device-level interrupt statistics */
5209 phba
->sli
.slistat
.sli_intr
++;
5210 /* Ignore all interrupts during initialization. */
5211 if (unlikely(phba
->link_state
< LPFC_LINK_DOWN
))
5213 /* Need to read HA REG for slow-path events */
5214 spin_lock_irqsave(&phba
->hbalock
, iflag
);
5215 ha_copy
= readl(phba
->HAregaddr
);
5216 /* If somebody is waiting to handle an eratt don't process it
5217 * here. The brdkill function will do this.
5219 if (phba
->link_flag
& LS_IGNORE_ERATT
)
5220 ha_copy
&= ~HA_ERATT
;
5221 /* Check the need for handling ERATT in interrupt handler */
5222 if (ha_copy
& HA_ERATT
) {
5223 if (phba
->hba_flag
& HBA_ERATT_HANDLED
)
5224 /* ERATT polling has handled ERATT */
5225 ha_copy
&= ~HA_ERATT
;
5227 /* Indicate interrupt handler handles ERATT */
5228 phba
->hba_flag
|= HBA_ERATT_HANDLED
;
5230 /* Clear up only attention source related to slow-path */
5231 writel((ha_copy
& (HA_MBATT
| HA_R2_CLR_MSK
)),
5233 readl(phba
->HAregaddr
); /* flush */
5234 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
5236 ha_copy
= phba
->ha_copy
;
5238 work_ha_copy
= ha_copy
& phba
->work_ha_mask
;
5241 if (work_ha_copy
& HA_LATT
) {
5242 if (phba
->sli
.sli_flag
& LPFC_PROCESS_LA
) {
5244 * Turn off Link Attention interrupts
5245 * until CLEAR_LA done
5247 spin_lock_irqsave(&phba
->hbalock
, iflag
);
5248 phba
->sli
.sli_flag
&= ~LPFC_PROCESS_LA
;
5249 control
= readl(phba
->HCregaddr
);
5250 control
&= ~HC_LAINT_ENA
;
5251 writel(control
, phba
->HCregaddr
);
5252 readl(phba
->HCregaddr
); /* flush */
5253 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
5256 work_ha_copy
&= ~HA_LATT
;
5259 if (work_ha_copy
& ~(HA_ERATT
| HA_MBATT
| HA_LATT
)) {
5261 * Turn off Slow Rings interrupts, LPFC_ELS_RING is
5262 * the only slow ring.
5264 status
= (work_ha_copy
&
5265 (HA_RXMASK
<< (4*LPFC_ELS_RING
)));
5266 status
>>= (4*LPFC_ELS_RING
);
5267 if (status
& HA_RXMASK
) {
5268 spin_lock_irqsave(&phba
->hbalock
, iflag
);
5269 control
= readl(phba
->HCregaddr
);
5271 lpfc_debugfs_slow_ring_trc(phba
,
5272 "ISR slow ring: ctl:x%x stat:x%x isrcnt:x%x",
5274 (uint32_t)phba
->sli
.slistat
.sli_intr
);
5276 if (control
& (HC_R0INT_ENA
<< LPFC_ELS_RING
)) {
5277 lpfc_debugfs_slow_ring_trc(phba
,
5279 "pwork:x%x hawork:x%x wait:x%x",
5280 phba
->work_ha
, work_ha_copy
,
5281 (uint32_t)((unsigned long)
5282 &phba
->work_waitq
));
5285 ~(HC_R0INT_ENA
<< LPFC_ELS_RING
);
5286 writel(control
, phba
->HCregaddr
);
5287 readl(phba
->HCregaddr
); /* flush */
5290 lpfc_debugfs_slow_ring_trc(phba
,
5291 "ISR slow ring: pwork:"
5292 "x%x hawork:x%x wait:x%x",
5293 phba
->work_ha
, work_ha_copy
,
5294 (uint32_t)((unsigned long)
5295 &phba
->work_waitq
));
5297 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
5300 spin_lock_irqsave(&phba
->hbalock
, iflag
);
5301 if (work_ha_copy
& HA_ERATT
)
5302 lpfc_sli_read_hs(phba
);
5303 if ((work_ha_copy
& HA_MBATT
) && (phba
->sli
.mbox_active
)) {
5304 pmb
= phba
->sli
.mbox_active
;
5309 /* First check out the status word */
5310 lpfc_sli_pcimem_bcopy(mbox
, pmbox
, sizeof(uint32_t));
5311 if (pmbox
->mbxOwner
!= OWN_HOST
) {
5312 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
5314 * Stray Mailbox Interrupt, mbxCommand <cmd>
5315 * mbxStatus <status>
5317 lpfc_printf_log(phba
, KERN_ERR
, LOG_MBOX
|
5319 "(%d):0304 Stray Mailbox "
5320 "Interrupt mbxCommand x%x "
5322 (vport
? vport
->vpi
: 0),
5325 /* clear mailbox attention bit */
5326 work_ha_copy
&= ~HA_MBATT
;
5328 phba
->sli
.mbox_active
= NULL
;
5329 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
5330 phba
->last_completion_time
= jiffies
;
5331 del_timer(&phba
->sli
.mbox_tmo
);
5332 if (pmb
->mbox_cmpl
) {
5333 lpfc_sli_pcimem_bcopy(mbox
, pmbox
,
5336 if (pmb
->mbox_flag
& LPFC_MBX_IMED_UNREG
) {
5337 pmb
->mbox_flag
&= ~LPFC_MBX_IMED_UNREG
;
5339 lpfc_debugfs_disc_trc(vport
,
5340 LPFC_DISC_TRC_MBOX_VPORT
,
5342 "status:x%x rpi:x%x",
5343 (uint32_t)pmbox
->mbxStatus
,
5344 pmbox
->un
.varWords
[0], 0);
5346 if (!pmbox
->mbxStatus
) {
5347 mp
= (struct lpfc_dmabuf
*)
5349 ndlp
= (struct lpfc_nodelist
*)
5352 /* Reg_LOGIN of dflt RPI was
5353 * successful. new lets get
5354 * rid of the RPI using the
5357 lpfc_unreg_login(phba
,
5359 pmbox
->un
.varWords
[0],
5362 lpfc_mbx_cmpl_dflt_rpi
;
5364 pmb
->context2
= ndlp
;
5366 rc
= lpfc_sli_issue_mbox(phba
,
5370 lpfc_printf_log(phba
,
5373 "0350 rc should have"
5375 goto send_current_mbox
;
5379 &phba
->pport
->work_port_lock
,
5381 phba
->pport
->work_port_events
&=
5383 spin_unlock_irqrestore(
5384 &phba
->pport
->work_port_lock
,
5386 lpfc_mbox_cmpl_put(phba
, pmb
);
5389 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
5391 if ((work_ha_copy
& HA_MBATT
) &&
5392 (phba
->sli
.mbox_active
== NULL
)) {
5394 /* Process next mailbox command if there is one */
5396 rc
= lpfc_sli_issue_mbox(phba
, NULL
,
5398 } while (rc
== MBX_NOT_FINISHED
);
5399 if (rc
!= MBX_SUCCESS
)
5400 lpfc_printf_log(phba
, KERN_ERR
, LOG_MBOX
|
5401 LOG_SLI
, "0349 rc should be "
5405 spin_lock_irqsave(&phba
->hbalock
, iflag
);
5406 phba
->work_ha
|= work_ha_copy
;
5407 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
5408 lpfc_worker_wake_up(phba
);
5412 } /* lpfc_sp_intr_handler */
5415 * lpfc_fp_intr_handler: The fast-path interrupt handler of lpfc driver.
5416 * @irq: Interrupt number.
5417 * @dev_id: The device context pointer.
5419 * This function is directly called from the PCI layer as an interrupt
5420 * service routine when the device is enabled with MSI-X multi-message
5421 * interrupt mode and there is a fast-path FCP IOCB ring event in the
5422 * HBA. However, when the device is enabled with either MSI or Pin-IRQ
5423 * interrupt mode, this function is called as part of the device-level
5424 * interrupt handler. When the PCI slot is in error recovery or the HBA
5425 * is undergoing initialization, the interrupt handler will not process
5426 * the interrupt. The SCSI FCP fast-path ring event are handled in the
5427 * intrrupt context. This function is called without any lock held. It
5428 * gets the hbalock to access and update SLI data structures.
5430 * This function returns IRQ_HANDLED when interrupt is handled else it
5434 lpfc_fp_intr_handler(int irq
, void *dev_id
)
5436 struct lpfc_hba
*phba
;
5438 unsigned long status
;
5439 unsigned long iflag
;
5441 /* Get the driver's phba structure from the dev_id and
5442 * assume the HBA is not interrupting.
5444 phba
= (struct lpfc_hba
*) dev_id
;
5446 if (unlikely(!phba
))
5450 * Stuff needs to be attented to when this function is invoked as an
5451 * individual interrupt handler in MSI-X multi-message interrupt mode
5453 if (phba
->intr_type
== MSIX
) {
5454 /* If pci channel is offline, ignore all the interrupts */
5455 if (unlikely(pci_channel_offline(phba
->pcidev
)))
5457 /* Update device-level interrupt statistics */
5458 phba
->sli
.slistat
.sli_intr
++;
5459 /* Ignore all interrupts during initialization. */
5460 if (unlikely(phba
->link_state
< LPFC_LINK_DOWN
))
5462 /* Need to read HA REG for FCP ring and other ring events */
5463 ha_copy
= readl(phba
->HAregaddr
);
5464 /* Clear up only attention source related to fast-path */
5465 spin_lock_irqsave(&phba
->hbalock
, iflag
);
5466 writel((ha_copy
& (HA_R0_CLR_MSK
| HA_R1_CLR_MSK
)),
5468 readl(phba
->HAregaddr
); /* flush */
5469 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
5471 ha_copy
= phba
->ha_copy
;
5474 * Process all events on FCP ring. Take the optimized path for FCP IO.
5476 ha_copy
&= ~(phba
->work_ha_mask
);
5478 status
= (ha_copy
& (HA_RXMASK
<< (4*LPFC_FCP_RING
)));
5479 status
>>= (4*LPFC_FCP_RING
);
5480 if (status
& HA_RXMASK
)
5481 lpfc_sli_handle_fast_ring_event(phba
,
5482 &phba
->sli
.ring
[LPFC_FCP_RING
],
5485 if (phba
->cfg_multi_ring_support
== 2) {
5487 * Process all events on extra ring. Take the optimized path
5488 * for extra ring IO.
5490 status
= (ha_copy
& (HA_RXMASK
<< (4*LPFC_EXTRA_RING
)));
5491 status
>>= (4*LPFC_EXTRA_RING
);
5492 if (status
& HA_RXMASK
) {
5493 lpfc_sli_handle_fast_ring_event(phba
,
5494 &phba
->sli
.ring
[LPFC_EXTRA_RING
],
5499 } /* lpfc_fp_intr_handler */
5502 * lpfc_intr_handler: The device-level interrupt handler of lpfc driver.
5503 * @irq: Interrupt number.
5504 * @dev_id: The device context pointer.
5506 * This function is the device-level interrupt handler called from the PCI
5507 * layer when either MSI or Pin-IRQ interrupt mode is enabled and there is
5508 * an event in the HBA which requires driver attention. This function
5509 * invokes the slow-path interrupt attention handling function and fast-path
5510 * interrupt attention handling function in turn to process the relevant
5511 * HBA attention events. This function is called without any lock held. It
5512 * gets the hbalock to access and update SLI data structures.
5514 * This function returns IRQ_HANDLED when interrupt is handled, else it
5518 lpfc_intr_handler(int irq
, void *dev_id
)
5520 struct lpfc_hba
*phba
;
5521 irqreturn_t sp_irq_rc
, fp_irq_rc
;
5522 unsigned long status1
, status2
;
5525 * Get the driver's phba structure from the dev_id and
5526 * assume the HBA is not interrupting.
5528 phba
= (struct lpfc_hba
*) dev_id
;
5530 if (unlikely(!phba
))
5533 /* If the pci channel is offline, ignore all the interrupts. */
5534 if (unlikely(pci_channel_offline(phba
->pcidev
)))
5537 /* Update device level interrupt statistics */
5538 phba
->sli
.slistat
.sli_intr
++;
5540 /* Ignore all interrupts during initialization. */
5541 if (unlikely(phba
->link_state
< LPFC_LINK_DOWN
))
5544 spin_lock(&phba
->hbalock
);
5545 phba
->ha_copy
= readl(phba
->HAregaddr
);
5546 if (unlikely(!phba
->ha_copy
)) {
5547 spin_unlock(&phba
->hbalock
);
5549 } else if (phba
->ha_copy
& HA_ERATT
) {
5550 if (phba
->hba_flag
& HBA_ERATT_HANDLED
)
5551 /* ERATT polling has handled ERATT */
5552 phba
->ha_copy
&= ~HA_ERATT
;
5554 /* Indicate interrupt handler handles ERATT */
5555 phba
->hba_flag
|= HBA_ERATT_HANDLED
;
5558 /* Clear attention sources except link and error attentions */
5559 writel((phba
->ha_copy
& ~(HA_LATT
| HA_ERATT
)), phba
->HAregaddr
);
5560 readl(phba
->HAregaddr
); /* flush */
5561 spin_unlock(&phba
->hbalock
);
5564 * Invokes slow-path host attention interrupt handling as appropriate.
5567 /* status of events with mailbox and link attention */
5568 status1
= phba
->ha_copy
& (HA_MBATT
| HA_LATT
| HA_ERATT
);
5570 /* status of events with ELS ring */
5571 status2
= (phba
->ha_copy
& (HA_RXMASK
<< (4*LPFC_ELS_RING
)));
5572 status2
>>= (4*LPFC_ELS_RING
);
5574 if (status1
|| (status2
& HA_RXMASK
))
5575 sp_irq_rc
= lpfc_sp_intr_handler(irq
, dev_id
);
5577 sp_irq_rc
= IRQ_NONE
;
5580 * Invoke fast-path host attention interrupt handling as appropriate.
5583 /* status of events with FCP ring */
5584 status1
= (phba
->ha_copy
& (HA_RXMASK
<< (4*LPFC_FCP_RING
)));
5585 status1
>>= (4*LPFC_FCP_RING
);
5587 /* status of events with extra ring */
5588 if (phba
->cfg_multi_ring_support
== 2) {
5589 status2
= (phba
->ha_copy
& (HA_RXMASK
<< (4*LPFC_EXTRA_RING
)));
5590 status2
>>= (4*LPFC_EXTRA_RING
);
5594 if ((status1
& HA_RXMASK
) || (status2
& HA_RXMASK
))
5595 fp_irq_rc
= lpfc_fp_intr_handler(irq
, dev_id
);
5597 fp_irq_rc
= IRQ_NONE
;
5599 /* Return device-level interrupt handling status */
5600 return (sp_irq_rc
== IRQ_HANDLED
) ? sp_irq_rc
: fp_irq_rc
;
5601 } /* lpfc_intr_handler */