1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2008 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
22 #include <linux/blkdev.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
25 #include <linux/delay.h>
27 #include <scsi/scsi.h>
28 #include <scsi/scsi_cmnd.h>
29 #include <scsi/scsi_device.h>
30 #include <scsi/scsi_host.h>
31 #include <scsi/scsi_transport_fc.h>
35 #include "lpfc_disc.h"
36 #include "lpfc_scsi.h"
38 #include "lpfc_crtn.h"
39 #include "lpfc_logmsg.h"
40 #include "lpfc_compat.h"
41 #include "lpfc_debugfs.h"
44 * Define macro to log: Mailbox command x%x cannot issue Data
45 * This allows multiple uses of lpfc_msgBlk0311
46 * w/o perturbing log msg utility.
48 #define LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag) \
49 lpfc_printf_log(phba, \
52 "(%d):0311 Mailbox command x%x cannot " \
53 "issue Data: x%x x%x x%x\n", \
54 pmbox->vport ? pmbox->vport->vpi : 0, \
55 pmbox->mb.mbxCommand, \
56 phba->pport->port_state, \
61 /* There are only four IOCB completion types. */
62 typedef enum _lpfc_iocb_type {
70 * lpfc_cmd_iocb: Get next command iocb entry in the ring.
71 * @phba: Pointer to HBA context object.
72 * @pring: Pointer to driver SLI ring object.
74 * This function returns pointer to next command iocb entry
75 * in the command ring. The caller must hold hbalock to prevent
76 * other threads consume the next command iocb.
77 * SLI-2/SLI-3 provide different sized iocbs.
79 static inline IOCB_t *
80 lpfc_cmd_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
82 return (IOCB_t *) (((char *) pring->cmdringaddr) +
83 pring->cmdidx * phba->iocb_cmd_size);
87 * lpfc_resp_iocb: Get next response iocb entry in the ring.
88 * @phba: Pointer to HBA context object.
89 * @pring: Pointer to driver SLI ring object.
91 * This function returns pointer to next response iocb entry
92 * in the response ring. The caller must hold hbalock to make sure
93 * that no other thread consume the next response iocb.
94 * SLI-2/SLI-3 provide different sized iocbs.
96 static inline IOCB_t *
97 lpfc_resp_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
99 return (IOCB_t *) (((char *) pring->rspringaddr) +
100 pring->rspidx * phba->iocb_rsp_size);
104 * __lpfc_sli_get_iocbq: Allocates an iocb object from iocb pool.
105 * @phba: Pointer to HBA context object.
107 * This function is called with hbalock held. This function
108 * allocates a new driver iocb object from the iocb pool. If the
109 * allocation is successful, it returns pointer to the newly
110 * allocated iocb object else it returns NULL.
112 static struct lpfc_iocbq *
113 __lpfc_sli_get_iocbq(struct lpfc_hba *phba)
115 struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
116 struct lpfc_iocbq * iocbq = NULL;
118 list_remove_head(lpfc_iocb_list, iocbq, struct lpfc_iocbq, list);
123 * lpfc_sli_get_iocbq: Allocates an iocb object from iocb pool.
124 * @phba: Pointer to HBA context object.
126 * This function is called with no lock held. This function
127 * allocates a new driver iocb object from the iocb pool. If the
128 * allocation is successful, it returns pointer to the newly
129 * allocated iocb object else it returns NULL.
132 lpfc_sli_get_iocbq(struct lpfc_hba *phba)
134 struct lpfc_iocbq * iocbq = NULL;
135 unsigned long iflags;
137 spin_lock_irqsave(&phba->hbalock, iflags);
138 iocbq = __lpfc_sli_get_iocbq(phba);
139 spin_unlock_irqrestore(&phba->hbalock, iflags);
144 * __lpfc_sli_release_iocbq: Release iocb to the iocb pool.
145 * @phba: Pointer to HBA context object.
146 * @iocbq: Pointer to driver iocb object.
148 * This function is called with hbalock held to release driver
149 * iocb object to the iocb pool. The iotag in the iocb object
150 * does not change for each use of the iocb object. This function
151 * clears all other fields of the iocb object when it is freed.
154 __lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
156 size_t start_clean = offsetof(struct lpfc_iocbq, iocb);
159 * Clean all volatile data fields, preserve iotag and node struct.
161 memset((char*)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean);
162 list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
166 * lpfc_sli_release_iocbq: Release iocb to the iocb pool.
167 * @phba: Pointer to HBA context object.
168 * @iocbq: Pointer to driver iocb object.
170 * This function is called with no lock held to release the iocb to
174 lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
176 unsigned long iflags;
179 * Clean all volatile data fields, preserve iotag and node struct.
181 spin_lock_irqsave(&phba->hbalock, iflags);
182 __lpfc_sli_release_iocbq(phba, iocbq);
183 spin_unlock_irqrestore(&phba->hbalock, iflags);
187 * lpfc_sli_iocb_cmd_type: Get the iocb type.
188 * @iocb_cmnd : iocb command code.
190 * This function is called by ring event handler function to get the iocb type.
191 * This function translates the iocb command to an iocb command type used to
192 * decide the final disposition of each completed IOCB.
193 * The function returns
194 * LPFC_UNKNOWN_IOCB if it is an unsupported iocb
195 * LPFC_SOL_IOCB if it is a solicited iocb completion
196 * LPFC_ABORT_IOCB if it is an abort iocb
197 * LPFC_UNSOL_IOCB if it is an unsolicited iocb
199 * The caller is not required to hold any lock.
201 static lpfc_iocb_type
202 lpfc_sli_iocb_cmd_type(uint8_t iocb_cmnd)
204 lpfc_iocb_type type = LPFC_UNKNOWN_IOCB;
206 if (iocb_cmnd > CMD_MAX_IOCB_CMD)
210 case CMD_XMIT_SEQUENCE_CR:
211 case CMD_XMIT_SEQUENCE_CX:
212 case CMD_XMIT_BCAST_CN:
213 case CMD_XMIT_BCAST_CX:
214 case CMD_ELS_REQUEST_CR:
215 case CMD_ELS_REQUEST_CX:
216 case CMD_CREATE_XRI_CR:
217 case CMD_CREATE_XRI_CX:
219 case CMD_XMIT_ELS_RSP_CX:
221 case CMD_FCP_IWRITE_CR:
222 case CMD_FCP_IWRITE_CX:
223 case CMD_FCP_IREAD_CR:
224 case CMD_FCP_IREAD_CX:
225 case CMD_FCP_ICMND_CR:
226 case CMD_FCP_ICMND_CX:
227 case CMD_FCP_TSEND_CX:
228 case CMD_FCP_TRSP_CX:
229 case CMD_FCP_TRECEIVE_CX:
230 case CMD_FCP_AUTO_TRSP_CX:
231 case CMD_ADAPTER_MSG:
232 case CMD_ADAPTER_DUMP:
233 case CMD_XMIT_SEQUENCE64_CR:
234 case CMD_XMIT_SEQUENCE64_CX:
235 case CMD_XMIT_BCAST64_CN:
236 case CMD_XMIT_BCAST64_CX:
237 case CMD_ELS_REQUEST64_CR:
238 case CMD_ELS_REQUEST64_CX:
239 case CMD_FCP_IWRITE64_CR:
240 case CMD_FCP_IWRITE64_CX:
241 case CMD_FCP_IREAD64_CR:
242 case CMD_FCP_IREAD64_CX:
243 case CMD_FCP_ICMND64_CR:
244 case CMD_FCP_ICMND64_CX:
245 case CMD_FCP_TSEND64_CX:
246 case CMD_FCP_TRSP64_CX:
247 case CMD_FCP_TRECEIVE64_CX:
248 case CMD_GEN_REQUEST64_CR:
249 case CMD_GEN_REQUEST64_CX:
250 case CMD_XMIT_ELS_RSP64_CX:
251 type = LPFC_SOL_IOCB;
253 case CMD_ABORT_XRI_CN:
254 case CMD_ABORT_XRI_CX:
255 case CMD_CLOSE_XRI_CN:
256 case CMD_CLOSE_XRI_CX:
257 case CMD_XRI_ABORTED_CX:
258 case CMD_ABORT_MXRI64_CN:
259 type = LPFC_ABORT_IOCB;
261 case CMD_RCV_SEQUENCE_CX:
262 case CMD_RCV_ELS_REQ_CX:
263 case CMD_RCV_SEQUENCE64_CX:
264 case CMD_RCV_ELS_REQ64_CX:
265 case CMD_ASYNC_STATUS:
266 case CMD_IOCB_RCV_SEQ64_CX:
267 case CMD_IOCB_RCV_ELS64_CX:
268 case CMD_IOCB_RCV_CONT64_CX:
269 case CMD_IOCB_RET_XRI64_CX:
270 type = LPFC_UNSOL_IOCB;
272 case CMD_IOCB_XMIT_MSEQ64_CR:
273 case CMD_IOCB_XMIT_MSEQ64_CX:
274 case CMD_IOCB_RCV_SEQ_LIST64_CX:
275 case CMD_IOCB_RCV_ELS_LIST64_CX:
276 case CMD_IOCB_CLOSE_EXTENDED_CN:
277 case CMD_IOCB_ABORT_EXTENDED_CN:
278 case CMD_IOCB_RET_HBQE64_CN:
279 case CMD_IOCB_FCP_IBIDIR64_CR:
280 case CMD_IOCB_FCP_IBIDIR64_CX:
281 case CMD_IOCB_FCP_ITASKMGT64_CX:
282 case CMD_IOCB_LOGENTRY_CN:
283 case CMD_IOCB_LOGENTRY_ASYNC_CN:
284 printk("%s - Unhandled SLI-3 Command x%x\n",
285 __func__, iocb_cmnd);
286 type = LPFC_UNKNOWN_IOCB;
289 type = LPFC_UNKNOWN_IOCB;
297 * lpfc_sli_ring_map: Issue config_ring mbox for all rings.
298 * @phba: Pointer to HBA context object.
300 * This function is called from SLI initialization code
301 * to configure every ring of the HBA's SLI interface. The
302 * caller is not required to hold any lock. This function issues
303 * a config_ring mailbox command for each ring.
304 * This function returns zero if successful else returns a negative
308 lpfc_sli_ring_map(struct lpfc_hba *phba)
310 struct lpfc_sli *psli = &phba->sli;
315 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
319 phba->link_state = LPFC_INIT_MBX_CMDS;
320 for (i = 0; i < psli->num_rings; i++) {
321 lpfc_config_ring(phba, i, pmb);
322 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
323 if (rc != MBX_SUCCESS) {
324 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
325 "0446 Adapter failed to init (%d), "
326 "mbxCmd x%x CFG_RING, mbxStatus x%x, "
328 rc, pmbox->mbxCommand,
329 pmbox->mbxStatus, i);
330 phba->link_state = LPFC_HBA_ERROR;
335 mempool_free(pmb, phba->mbox_mem_pool);
340 * lpfc_sli_ringtxcmpl_put: Adds new iocb to the txcmplq.
341 * @phba: Pointer to HBA context object.
342 * @pring: Pointer to driver SLI ring object.
343 * @piocb: Pointer to the driver iocb object.
345 * This function is called with hbalock held. The function adds the
346 * new iocb to txcmplq of the given ring. This function always returns
347 * 0. If this function is called for ELS ring, this function checks if
348 * there is a vport associated with the ELS command. This function also
349 * starts els_tmofunc timer if this is an ELS command.
352 lpfc_sli_ringtxcmpl_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
353 struct lpfc_iocbq *piocb)
355 list_add_tail(&piocb->list, &pring->txcmplq);
356 pring->txcmplq_cnt++;
357 if ((unlikely(pring->ringno == LPFC_ELS_RING)) &&
358 (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
359 (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN)) {
363 mod_timer(&piocb->vport->els_tmofunc,
364 jiffies + HZ * (phba->fc_ratov << 1));
372 * lpfc_sli_ringtx_get: Get first element of the txq.
373 * @phba: Pointer to HBA context object.
374 * @pring: Pointer to driver SLI ring object.
376 * This function is called with hbalock held to get next
377 * iocb in txq of the given ring. If there is any iocb in
378 * the txq, the function returns first iocb in the list after
379 * removing the iocb from the list, else it returns NULL.
381 static struct lpfc_iocbq *
382 lpfc_sli_ringtx_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
384 struct lpfc_iocbq *cmd_iocb;
386 list_remove_head((&pring->txq), cmd_iocb, struct lpfc_iocbq, list);
387 if (cmd_iocb != NULL)
393 * lpfc_sli_next_iocb_slot: Get next iocb slot in the ring.
394 * @phba: Pointer to HBA context object.
395 * @pring: Pointer to driver SLI ring object.
397 * This function is called with hbalock held and the caller must post the
398 * iocb without releasing the lock. If the caller releases the lock,
399 * iocb slot returned by the function is not guaranteed to be available.
400 * The function returns pointer to the next available iocb slot if there
401 * is available slot in the ring, else it returns NULL.
402 * If the get index of the ring is ahead of the put index, the function
403 * will post an error attention event to the worker thread to take the
404 * HBA to offline state.
407 lpfc_sli_next_iocb_slot (struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
409 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
410 uint32_t max_cmd_idx = pring->numCiocb;
411 if ((pring->next_cmdidx == pring->cmdidx) &&
412 (++pring->next_cmdidx >= max_cmd_idx))
413 pring->next_cmdidx = 0;
415 if (unlikely(pring->local_getidx == pring->next_cmdidx)) {
417 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
419 if (unlikely(pring->local_getidx >= max_cmd_idx)) {
420 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
421 "0315 Ring %d issue: portCmdGet %d "
422 "is bigger then cmd ring %d\n",
424 pring->local_getidx, max_cmd_idx);
426 phba->link_state = LPFC_HBA_ERROR;
428 * All error attention handlers are posted to
431 phba->work_ha |= HA_ERATT;
432 phba->work_hs = HS_FFER3;
434 lpfc_worker_wake_up(phba);
439 if (pring->local_getidx == pring->next_cmdidx)
443 return lpfc_cmd_iocb(phba, pring);
447 * lpfc_sli_next_iotag: Get an iotag for the iocb.
448 * @phba: Pointer to HBA context object.
449 * @iocbq: Pointer to driver iocb object.
451 * This function gets an iotag for the iocb. If there is no unused iotag and
452 * the iocbq_lookup_len < 0xffff, this function allocates a bigger iotag_lookup
453 * array and assigns a new iotag.
454 * The function returns the allocated iotag if successful, else returns zero.
455 * Zero is not a valid iotag.
456 * The caller is not required to hold any lock.
459 lpfc_sli_next_iotag(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
461 struct lpfc_iocbq **new_arr;
462 struct lpfc_iocbq **old_arr;
464 struct lpfc_sli *psli = &phba->sli;
467 spin_lock_irq(&phba->hbalock);
468 iotag = psli->last_iotag;
469 if(++iotag < psli->iocbq_lookup_len) {
470 psli->last_iotag = iotag;
471 psli->iocbq_lookup[iotag] = iocbq;
472 spin_unlock_irq(&phba->hbalock);
473 iocbq->iotag = iotag;
475 } else if (psli->iocbq_lookup_len < (0xffff
476 - LPFC_IOCBQ_LOOKUP_INCREMENT)) {
477 new_len = psli->iocbq_lookup_len + LPFC_IOCBQ_LOOKUP_INCREMENT;
478 spin_unlock_irq(&phba->hbalock);
479 new_arr = kzalloc(new_len * sizeof (struct lpfc_iocbq *),
482 spin_lock_irq(&phba->hbalock);
483 old_arr = psli->iocbq_lookup;
484 if (new_len <= psli->iocbq_lookup_len) {
485 /* highly unprobable case */
487 iotag = psli->last_iotag;
488 if(++iotag < psli->iocbq_lookup_len) {
489 psli->last_iotag = iotag;
490 psli->iocbq_lookup[iotag] = iocbq;
491 spin_unlock_irq(&phba->hbalock);
492 iocbq->iotag = iotag;
495 spin_unlock_irq(&phba->hbalock);
498 if (psli->iocbq_lookup)
499 memcpy(new_arr, old_arr,
500 ((psli->last_iotag + 1) *
501 sizeof (struct lpfc_iocbq *)));
502 psli->iocbq_lookup = new_arr;
503 psli->iocbq_lookup_len = new_len;
504 psli->last_iotag = iotag;
505 psli->iocbq_lookup[iotag] = iocbq;
506 spin_unlock_irq(&phba->hbalock);
507 iocbq->iotag = iotag;
512 spin_unlock_irq(&phba->hbalock);
514 lpfc_printf_log(phba, KERN_ERR,LOG_SLI,
515 "0318 Failed to allocate IOTAG.last IOTAG is %d\n",
522 * lpfc_sli_submit_iocb: Submit an iocb to the firmware.
523 * @phba: Pointer to HBA context object.
524 * @pring: Pointer to driver SLI ring object.
525 * @iocb: Pointer to iocb slot in the ring.
526 * @nextiocb: Pointer to driver iocb object which need to be
527 * posted to firmware.
529 * This function is called with hbalock held to post a new iocb to
530 * the firmware. This function copies the new iocb to ring iocb slot and
531 * updates the ring pointers. It adds the new iocb to txcmplq if there is
532 * a completion call back for this iocb else the function will free the
536 lpfc_sli_submit_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
537 IOCB_t *iocb, struct lpfc_iocbq *nextiocb)
542 nextiocb->iocb.ulpIoTag = (nextiocb->iocb_cmpl) ? nextiocb->iotag : 0;
544 if (pring->ringno == LPFC_ELS_RING) {
545 lpfc_debugfs_slow_ring_trc(phba,
546 "IOCB cmd ring: wd4:x%08x wd6:x%08x wd7:x%08x",
547 *(((uint32_t *) &nextiocb->iocb) + 4),
548 *(((uint32_t *) &nextiocb->iocb) + 6),
549 *(((uint32_t *) &nextiocb->iocb) + 7));
553 * Issue iocb command to adapter
555 lpfc_sli_pcimem_bcopy(&nextiocb->iocb, iocb, phba->iocb_cmd_size);
557 pring->stats.iocb_cmd++;
560 * If there is no completion routine to call, we can release the
561 * IOCB buffer back right now. For IOCBs, like QUE_RING_BUF,
562 * that have no rsp ring completion, iocb_cmpl MUST be NULL.
564 if (nextiocb->iocb_cmpl)
565 lpfc_sli_ringtxcmpl_put(phba, pring, nextiocb);
567 __lpfc_sli_release_iocbq(phba, nextiocb);
570 * Let the HBA know what IOCB slot will be the next one the
571 * driver will put a command into.
573 pring->cmdidx = pring->next_cmdidx;
574 writel(pring->cmdidx, &phba->host_gp[pring->ringno].cmdPutInx);
578 * lpfc_sli_update_full_ring: Update the chip attention register.
579 * @phba: Pointer to HBA context object.
580 * @pring: Pointer to driver SLI ring object.
582 * The caller is not required to hold any lock for calling this function.
583 * This function updates the chip attention bits for the ring to inform firmware
584 * that there are pending work to be done for this ring and requests an
585 * interrupt when there is space available in the ring. This function is
586 * called when the driver is unable to post more iocbs to the ring due
587 * to unavailability of space in the ring.
590 lpfc_sli_update_full_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
592 int ringno = pring->ringno;
594 pring->flag |= LPFC_CALL_RING_AVAILABLE;
599 * Set ring 'ringno' to SET R0CE_REQ in Chip Att register.
600 * The HBA will tell us when an IOCB entry is available.
602 writel((CA_R0ATT|CA_R0CE_REQ) << (ringno*4), phba->CAregaddr);
603 readl(phba->CAregaddr); /* flush */
605 pring->stats.iocb_cmd_full++;
609 * lpfc_sli_update_ring: Update chip attention register.
610 * @phba: Pointer to HBA context object.
611 * @pring: Pointer to driver SLI ring object.
613 * This function updates the chip attention register bit for the
614 * given ring to inform HBA that there is more work to be done
615 * in this ring. The caller is not required to hold any lock.
618 lpfc_sli_update_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
620 int ringno = pring->ringno;
623 * Tell the HBA that there is work to do in this ring.
625 if (!(phba->sli3_options & LPFC_SLI3_CRP_ENABLED)) {
627 writel(CA_R0ATT << (ringno * 4), phba->CAregaddr);
628 readl(phba->CAregaddr); /* flush */
633 * lpfc_sli_resume_iocb: Process iocbs in the txq.
634 * @phba: Pointer to HBA context object.
635 * @pring: Pointer to driver SLI ring object.
637 * This function is called with hbalock held to post pending iocbs
638 * in the txq to the firmware. This function is called when driver
639 * detects space available in the ring.
642 lpfc_sli_resume_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
645 struct lpfc_iocbq *nextiocb;
649 * (a) there is anything on the txq to send
651 * (c) link attention events can be processed (fcp ring only)
652 * (d) IOCB processing is not blocked by the outstanding mbox command.
654 if (pring->txq_cnt &&
655 lpfc_is_link_up(phba) &&
656 (pring->ringno != phba->sli.fcp_ring ||
657 phba->sli.sli_flag & LPFC_PROCESS_LA)) {
659 while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
660 (nextiocb = lpfc_sli_ringtx_get(phba, pring)))
661 lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
664 lpfc_sli_update_ring(phba, pring);
666 lpfc_sli_update_full_ring(phba, pring);
673 * lpfc_sli_next_hbq_slot: Get next hbq entry for the HBQ.
674 * @phba: Pointer to HBA context object.
675 * @hbqno: HBQ number.
677 * This function is called with hbalock held to get the next
678 * available slot for the given HBQ. If there is free slot
679 * available for the HBQ it will return pointer to the next available
680 * HBQ entry else it will return NULL.
682 static struct lpfc_hbq_entry *
683 lpfc_sli_next_hbq_slot(struct lpfc_hba *phba, uint32_t hbqno)
685 struct hbq_s *hbqp = &phba->hbqs[hbqno];
687 if (hbqp->next_hbqPutIdx == hbqp->hbqPutIdx &&
688 ++hbqp->next_hbqPutIdx >= hbqp->entry_count)
689 hbqp->next_hbqPutIdx = 0;
691 if (unlikely(hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)) {
692 uint32_t raw_index = phba->hbq_get[hbqno];
693 uint32_t getidx = le32_to_cpu(raw_index);
695 hbqp->local_hbqGetIdx = getidx;
697 if (unlikely(hbqp->local_hbqGetIdx >= hbqp->entry_count)) {
698 lpfc_printf_log(phba, KERN_ERR,
700 "1802 HBQ %d: local_hbqGetIdx "
701 "%u is > than hbqp->entry_count %u\n",
702 hbqno, hbqp->local_hbqGetIdx,
705 phba->link_state = LPFC_HBA_ERROR;
709 if (hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)
713 return (struct lpfc_hbq_entry *) phba->hbqs[hbqno].hbq_virt +
718 * lpfc_sli_hbqbuf_free_all: Free all the hbq buffers.
719 * @phba: Pointer to HBA context object.
721 * This function is called with no lock held to free all the
722 * hbq buffers while uninitializing the SLI interface. It also
723 * frees the HBQ buffers returned by the firmware but not yet
724 * processed by the upper layers.
727 lpfc_sli_hbqbuf_free_all(struct lpfc_hba *phba)
729 struct lpfc_dmabuf *dmabuf, *next_dmabuf;
730 struct hbq_dmabuf *hbq_buf;
735 hbq_count = lpfc_sli_hbq_count();
736 /* Return all memory used by all HBQs */
737 spin_lock_irqsave(&phba->hbalock, flags);
738 for (i = 0; i < hbq_count; ++i) {
739 list_for_each_entry_safe(dmabuf, next_dmabuf,
740 &phba->hbqs[i].hbq_buffer_list, list) {
741 hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
742 list_del(&hbq_buf->dbuf.list);
743 (phba->hbqs[i].hbq_free_buffer)(phba, hbq_buf);
745 phba->hbqs[i].buffer_count = 0;
747 /* Return all HBQ buffer that are in-fly */
748 list_for_each_entry_safe(dmabuf, next_dmabuf,
749 &phba->hbqbuf_in_list, list) {
750 hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
751 list_del(&hbq_buf->dbuf.list);
752 if (hbq_buf->tag == -1) {
753 (phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
756 hbqno = hbq_buf->tag >> 16;
757 if (hbqno >= LPFC_MAX_HBQS)
758 (phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
761 (phba->hbqs[hbqno].hbq_free_buffer)(phba,
766 /* Mark the HBQs not in use */
767 phba->hbq_in_use = 0;
768 spin_unlock_irqrestore(&phba->hbalock, flags);
772 * lpfc_sli_hbq_to_firmware: Post the hbq buffer to firmware.
773 * @phba: Pointer to HBA context object.
774 * @hbqno: HBQ number.
775 * @hbq_buf: Pointer to HBQ buffer.
777 * This function is called with the hbalock held to post a
778 * hbq buffer to the firmware. If the function finds an empty
779 * slot in the HBQ, it will post the buffer. The function will return
780 * pointer to the hbq entry if it successfully post the buffer
781 * else it will return NULL.
783 static struct lpfc_hbq_entry *
784 lpfc_sli_hbq_to_firmware(struct lpfc_hba *phba, uint32_t hbqno,
785 struct hbq_dmabuf *hbq_buf)
787 struct lpfc_hbq_entry *hbqe;
788 dma_addr_t physaddr = hbq_buf->dbuf.phys;
790 /* Get next HBQ entry slot to use */
791 hbqe = lpfc_sli_next_hbq_slot(phba, hbqno);
793 struct hbq_s *hbqp = &phba->hbqs[hbqno];
795 hbqe->bde.addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
796 hbqe->bde.addrLow = le32_to_cpu(putPaddrLow(physaddr));
797 hbqe->bde.tus.f.bdeSize = hbq_buf->size;
798 hbqe->bde.tus.f.bdeFlags = 0;
799 hbqe->bde.tus.w = le32_to_cpu(hbqe->bde.tus.w);
800 hbqe->buffer_tag = le32_to_cpu(hbq_buf->tag);
802 hbqp->hbqPutIdx = hbqp->next_hbqPutIdx;
803 writel(hbqp->hbqPutIdx, phba->hbq_put + hbqno);
805 readl(phba->hbq_put + hbqno);
806 list_add_tail(&hbq_buf->dbuf.list, &hbqp->hbq_buffer_list);
811 /* HBQ for ELS and CT traffic. */
812 static struct lpfc_hbq_init lpfc_els_hbq = {
817 .ring_mask = (1 << LPFC_ELS_RING),
823 /* HBQ for the extra ring if needed */
824 static struct lpfc_hbq_init lpfc_extra_hbq = {
829 .ring_mask = (1 << LPFC_EXTRA_RING),
836 struct lpfc_hbq_init *lpfc_hbq_defs[] = {
842 * lpfc_sli_hbqbuf_fill_hbqs: Post more hbq buffers to HBQ.
843 * @phba: Pointer to HBA context object.
844 * @hbqno: HBQ number.
845 * @count: Number of HBQ buffers to be posted.
847 * This function is called with no lock held to post more hbq buffers to the
848 * given HBQ. The function returns the number of HBQ buffers successfully
852 lpfc_sli_hbqbuf_fill_hbqs(struct lpfc_hba *phba, uint32_t hbqno, uint32_t count)
854 uint32_t i, posted = 0;
856 struct hbq_dmabuf *hbq_buffer;
857 LIST_HEAD(hbq_buf_list);
858 if (!phba->hbqs[hbqno].hbq_alloc_buffer)
861 if ((phba->hbqs[hbqno].buffer_count + count) >
862 lpfc_hbq_defs[hbqno]->entry_count)
863 count = lpfc_hbq_defs[hbqno]->entry_count -
864 phba->hbqs[hbqno].buffer_count;
867 /* Allocate HBQ entries */
868 for (i = 0; i < count; i++) {
869 hbq_buffer = (phba->hbqs[hbqno].hbq_alloc_buffer)(phba);
872 list_add_tail(&hbq_buffer->dbuf.list, &hbq_buf_list);
874 /* Check whether HBQ is still in use */
875 spin_lock_irqsave(&phba->hbalock, flags);
876 if (!phba->hbq_in_use)
878 while (!list_empty(&hbq_buf_list)) {
879 list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
881 hbq_buffer->tag = (phba->hbqs[hbqno].buffer_count |
883 if (lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {
884 phba->hbqs[hbqno].buffer_count++;
887 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
889 spin_unlock_irqrestore(&phba->hbalock, flags);
892 spin_unlock_irqrestore(&phba->hbalock, flags);
893 while (!list_empty(&hbq_buf_list)) {
894 list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
896 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
902 * lpfc_sli_hbqbuf_add_hbqs: Post more HBQ buffers to firmware.
903 * @phba: Pointer to HBA context object.
906 * This function posts more buffers to the HBQ. This function
907 * is called with no lock held. The function returns the number of HBQ entries
908 * successfully allocated.
911 lpfc_sli_hbqbuf_add_hbqs(struct lpfc_hba *phba, uint32_t qno)
913 return(lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
914 lpfc_hbq_defs[qno]->add_count));
918 * lpfc_sli_hbqbuf_init_hbqs: Post initial buffers to the HBQ.
919 * @phba: Pointer to HBA context object.
920 * @qno: HBQ queue number.
922 * This function is called from SLI initialization code path with
923 * no lock held to post initial HBQ buffers to firmware. The
924 * function returns the number of HBQ entries successfully allocated.
927 lpfc_sli_hbqbuf_init_hbqs(struct lpfc_hba *phba, uint32_t qno)
929 return(lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
930 lpfc_hbq_defs[qno]->init_count));
934 * lpfc_sli_hbqbuf_find: Find the hbq buffer associated with a tag.
935 * @phba: Pointer to HBA context object.
936 * @tag: Tag of the hbq buffer.
938 * This function is called with hbalock held. This function searches
939 * for the hbq buffer associated with the given tag in the hbq buffer
940 * list. If it finds the hbq buffer, it returns the hbq_buffer other wise
943 static struct hbq_dmabuf *
944 lpfc_sli_hbqbuf_find(struct lpfc_hba *phba, uint32_t tag)
946 struct lpfc_dmabuf *d_buf;
947 struct hbq_dmabuf *hbq_buf;
951 if (hbqno >= LPFC_MAX_HBQS)
954 list_for_each_entry(d_buf, &phba->hbqs[hbqno].hbq_buffer_list, list) {
955 hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
956 if (hbq_buf->tag == tag) {
960 lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_VPORT,
961 "1803 Bad hbq tag. Data: x%x x%x\n",
962 tag, phba->hbqs[tag >> 16].buffer_count);
967 * lpfc_sli_free_hbq: Give back the hbq buffer to firmware.
968 * @phba: Pointer to HBA context object.
969 * @hbq_buffer: Pointer to HBQ buffer.
971 * This function is called with hbalock. This function gives back
972 * the hbq buffer to firmware. If the HBQ does not have space to
973 * post the buffer, it will free the buffer.
976 lpfc_sli_free_hbq(struct lpfc_hba *phba, struct hbq_dmabuf *hbq_buffer)
981 hbqno = hbq_buffer->tag >> 16;
982 if (!lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {
983 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
989 * lpfc_sli_chk_mbx_command: Check if the mailbox is a legitimate mailbox.
990 * @mbxCommand: mailbox command code.
992 * This function is called by the mailbox event handler function to verify
993 * that the completed mailbox command is a legitimate mailbox command. If the
994 * completed mailbox is not known to the function, it will return MBX_SHUTDOWN
995 * and the mailbox event handler will take the HBA offline.
998 lpfc_sli_chk_mbx_command(uint8_t mbxCommand)
1002 switch (mbxCommand) {
1006 case MBX_WRITE_VPARMS:
1007 case MBX_RUN_BIU_DIAG:
1010 case MBX_CONFIG_LINK:
1011 case MBX_CONFIG_RING:
1012 case MBX_RESET_RING:
1013 case MBX_READ_CONFIG:
1014 case MBX_READ_RCONFIG:
1015 case MBX_READ_SPARM:
1016 case MBX_READ_STATUS:
1020 case MBX_READ_LNK_STAT:
1022 case MBX_UNREG_LOGIN:
1025 case MBX_DUMP_MEMORY:
1026 case MBX_DUMP_CONTEXT:
1029 case MBX_UPDATE_CFG:
1031 case MBX_DEL_LD_ENTRY:
1032 case MBX_RUN_PROGRAM:
1034 case MBX_SET_VARIABLE:
1035 case MBX_UNREG_D_ID:
1036 case MBX_KILL_BOARD:
1037 case MBX_CONFIG_FARP:
1040 case MBX_RUN_BIU_DIAG64:
1041 case MBX_CONFIG_PORT:
1042 case MBX_READ_SPARM64:
1043 case MBX_READ_RPI64:
1044 case MBX_REG_LOGIN64:
1048 case MBX_LOAD_EXP_ROM:
1049 case MBX_ASYNCEVT_ENABLE:
1063 * lpfc_sli_wake_mbox_wait: Completion handler for mbox issued from
1064 * lpfc_sli_issue_mbox_wait.
1065 * @phba: Pointer to HBA context object.
1066 * @pmboxq: Pointer to mailbox command.
1068 * This is completion handler function for mailbox commands issued from
1069 * lpfc_sli_issue_mbox_wait function. This function is called by the
1070 * mailbox event handler function with no lock held. This function
1071 * will wake up thread waiting on the wait queue pointed by context1
1075 lpfc_sli_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
1077 wait_queue_head_t *pdone_q;
1078 unsigned long drvr_flag;
1081 * If pdone_q is empty, the driver thread gave up waiting and
1082 * continued running.
1084 pmboxq->mbox_flag |= LPFC_MBX_WAKE;
1085 spin_lock_irqsave(&phba->hbalock, drvr_flag);
1086 pdone_q = (wait_queue_head_t *) pmboxq->context1;
1088 wake_up_interruptible(pdone_q);
1089 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
1095 * lpfc_sli_def_mbox_cmpl: Default mailbox completion handler.
1096 * @phba: Pointer to HBA context object.
1097 * @pmb: Pointer to mailbox object.
1099 * This function is the default mailbox completion handler. It
1100 * frees the memory resources associated with the completed mailbox
1101 * command. If the completed command is a REG_LOGIN mailbox command,
1102 * this function will issue a UREG_LOGIN to re-claim the RPI.
1105 lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1107 struct lpfc_dmabuf *mp;
1111 mp = (struct lpfc_dmabuf *) (pmb->context1);
1114 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1119 * If a REG_LOGIN succeeded after node is destroyed or node
1120 * is in re-discovery driver need to cleanup the RPI.
1122 if (!(phba->pport->load_flag & FC_UNLOADING) &&
1123 pmb->mb.mbxCommand == MBX_REG_LOGIN64 &&
1124 !pmb->mb.mbxStatus) {
1126 rpi = pmb->mb.un.varWords[0];
1127 lpfc_unreg_login(phba, pmb->mb.un.varRegLogin.vpi, rpi, pmb);
1128 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
1129 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
1130 if (rc != MBX_NOT_FINISHED)
1134 mempool_free(pmb, phba->mbox_mem_pool);
1139 * lpfc_sli_handle_mb_event: Handle mailbox completions from firmware.
1140 * @phba: Pointer to HBA context object.
1142 * This function is called with no lock held. This function processes all
1143 * the completed mailbox commands and gives it to upper layers. The interrupt
1144 * service routine processes mailbox completion interrupt and adds completed
1145 * mailbox commands to the mboxq_cmpl queue and signals the worker thread.
1146 * Worker thread call lpfc_sli_handle_mb_event, which will return the
1147 * completed mailbox commands in mboxq_cmpl queue to the upper layers. This
1148 * function returns the mailbox commands to the upper layer by calling the
1149 * completion handler function of each mailbox.
1152 lpfc_sli_handle_mb_event(struct lpfc_hba *phba)
1159 phba->sli.slistat.mbox_event++;
1161 /* Get all completed mailboxe buffers into the cmplq */
1162 spin_lock_irq(&phba->hbalock);
1163 list_splice_init(&phba->sli.mboxq_cmpl, &cmplq);
1164 spin_unlock_irq(&phba->hbalock);
1166 /* Get a Mailbox buffer to setup mailbox commands for callback */
1168 list_remove_head(&cmplq, pmb, LPFC_MBOXQ_t, list);
1174 if (pmbox->mbxCommand != MBX_HEARTBEAT) {
1176 lpfc_debugfs_disc_trc(pmb->vport,
1177 LPFC_DISC_TRC_MBOX_VPORT,
1178 "MBOX cmpl vport: cmd:x%x mb:x%x x%x",
1179 (uint32_t)pmbox->mbxCommand,
1180 pmbox->un.varWords[0],
1181 pmbox->un.varWords[1]);
1184 lpfc_debugfs_disc_trc(phba->pport,
1186 "MBOX cmpl: cmd:x%x mb:x%x x%x",
1187 (uint32_t)pmbox->mbxCommand,
1188 pmbox->un.varWords[0],
1189 pmbox->un.varWords[1]);
1194 * It is a fatal error if unknown mbox command completion.
1196 if (lpfc_sli_chk_mbx_command(pmbox->mbxCommand) ==
1198 /* Unknow mailbox command compl */
1199 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
1200 "(%d):0323 Unknown Mailbox command "
1202 pmb->vport ? pmb->vport->vpi : 0,
1204 phba->link_state = LPFC_HBA_ERROR;
1205 phba->work_hs = HS_FFER3;
1206 lpfc_handle_eratt(phba);
1210 if (pmbox->mbxStatus) {
1211 phba->sli.slistat.mbox_stat_err++;
1212 if (pmbox->mbxStatus == MBXERR_NO_RESOURCES) {
1213 /* Mbox cmd cmpl error - RETRYing */
1214 lpfc_printf_log(phba, KERN_INFO,
1216 "(%d):0305 Mbox cmd cmpl "
1217 "error - RETRYing Data: x%x "
1219 pmb->vport ? pmb->vport->vpi :0,
1222 pmbox->un.varWords[0],
1223 pmb->vport->port_state);
1224 pmbox->mbxStatus = 0;
1225 pmbox->mbxOwner = OWN_HOST;
1226 spin_lock_irq(&phba->hbalock);
1227 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
1228 spin_unlock_irq(&phba->hbalock);
1229 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
1230 if (rc == MBX_SUCCESS)
1235 /* Mailbox cmd <cmd> Cmpl <cmpl> */
1236 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
1237 "(%d):0307 Mailbox cmd x%x Cmpl x%p "
1238 "Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x\n",
1239 pmb->vport ? pmb->vport->vpi : 0,
1242 *((uint32_t *) pmbox),
1243 pmbox->un.varWords[0],
1244 pmbox->un.varWords[1],
1245 pmbox->un.varWords[2],
1246 pmbox->un.varWords[3],
1247 pmbox->un.varWords[4],
1248 pmbox->un.varWords[5],
1249 pmbox->un.varWords[6],
1250 pmbox->un.varWords[7]);
1253 pmb->mbox_cmpl(phba,pmb);
1259 * lpfc_sli_replace_hbqbuff: Replace the HBQ buffer with a new buffer.
1260 * @phba: Pointer to HBA context object.
1261 * @tag: Tag for the HBQ buffer.
1263 * This function is called from unsolicited event handler code path to get the
1264 * HBQ buffer associated with an unsolicited iocb. This function is called with
1265 * no lock held. It returns the buffer associated with the given tag and posts
1266 * another buffer to the firmware. Note that the new buffer must be allocated
1267 * before taking the hbalock and that the hba lock must be held until it is
1268 * finished with the hbq entry swap.
1270 static struct lpfc_dmabuf *
1271 lpfc_sli_replace_hbqbuff(struct lpfc_hba *phba, uint32_t tag)
1273 struct hbq_dmabuf *hbq_entry, *new_hbq_entry;
1275 void *virt; /* virtual address ptr */
1276 dma_addr_t phys; /* mapped address */
1277 unsigned long flags;
1280 new_hbq_entry = (phba->hbqs[hbqno].hbq_alloc_buffer)(phba);
1281 /* Check whether HBQ is still in use */
1282 spin_lock_irqsave(&phba->hbalock, flags);
1283 if (!phba->hbq_in_use) {
1285 (phba->hbqs[hbqno].hbq_free_buffer)(phba,
1287 spin_unlock_irqrestore(&phba->hbalock, flags);
1291 hbq_entry = lpfc_sli_hbqbuf_find(phba, tag);
1292 if (hbq_entry == NULL) {
1294 (phba->hbqs[hbqno].hbq_free_buffer)(phba,
1296 spin_unlock_irqrestore(&phba->hbalock, flags);
1299 list_del(&hbq_entry->dbuf.list);
1301 if (new_hbq_entry == NULL) {
1302 list_add_tail(&hbq_entry->dbuf.list, &phba->hbqbuf_in_list);
1303 spin_unlock_irqrestore(&phba->hbalock, flags);
1304 return &hbq_entry->dbuf;
1306 new_hbq_entry->tag = -1;
1307 phys = new_hbq_entry->dbuf.phys;
1308 virt = new_hbq_entry->dbuf.virt;
1309 new_hbq_entry->dbuf.phys = hbq_entry->dbuf.phys;
1310 new_hbq_entry->dbuf.virt = hbq_entry->dbuf.virt;
1311 hbq_entry->dbuf.phys = phys;
1312 hbq_entry->dbuf.virt = virt;
1313 lpfc_sli_free_hbq(phba, hbq_entry);
1314 list_add_tail(&new_hbq_entry->dbuf.list, &phba->hbqbuf_in_list);
1315 spin_unlock_irqrestore(&phba->hbalock, flags);
1317 return &new_hbq_entry->dbuf;
1321 * lpfc_sli_get_buff: Get the buffer associated with the buffer tag.
1322 * @phba: Pointer to HBA context object.
1323 * @pring: Pointer to driver SLI ring object.
1326 * This function is called with no lock held. When QUE_BUFTAG_BIT bit
1327 * is set in the tag the buffer is posted for a particular exchange,
1328 * the function will return the buffer without replacing the buffer.
1329 * If the buffer is for unsolicited ELS or CT traffic, this function
1330 * returns the buffer and also posts another buffer to the firmware.
1332 static struct lpfc_dmabuf *
1333 lpfc_sli_get_buff(struct lpfc_hba *phba,
1334 struct lpfc_sli_ring *pring,
1337 if (tag & QUE_BUFTAG_BIT)
1338 return lpfc_sli_ring_taggedbuf_get(phba, pring, tag);
1340 return lpfc_sli_replace_hbqbuff(phba, tag);
1345 * lpfc_sli_process_unsol_iocb: Unsolicited iocb handler.
1346 * @phba: Pointer to HBA context object.
1347 * @pring: Pointer to driver SLI ring object.
1348 * @saveq: Pointer to the unsolicited iocb.
1350 * This function is called with no lock held by the ring event handler
1351 * when there is an unsolicited iocb posted to the response ring by the
1352 * firmware. This function gets the buffer associated with the iocbs
1353 * and calls the event handler for the ring. This function handles both
1354 * qring buffers and hbq buffers.
1355 * When the function returns 1 the caller can free the iocb object otherwise
1356 * upper layer functions will free the iocb objects.
1359 lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1360 struct lpfc_iocbq *saveq)
1364 uint32_t Rctl, Type;
1366 struct lpfc_iocbq *iocbq;
1367 struct lpfc_dmabuf *dmzbuf;
1370 irsp = &(saveq->iocb);
1372 if (irsp->ulpStatus == IOSTAT_NEED_BUFFER)
1374 if (irsp->ulpCommand == CMD_ASYNC_STATUS) {
1375 if (pring->lpfc_sli_rcv_async_status)
1376 pring->lpfc_sli_rcv_async_status(phba, pring, saveq);
1378 lpfc_printf_log(phba,
1381 "0316 Ring %d handler: unexpected "
1382 "ASYNC_STATUS iocb received evt_code "
1385 irsp->un.asyncstat.evt_code);
1389 if ((irsp->ulpCommand == CMD_IOCB_RET_XRI64_CX) &&
1390 (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)) {
1391 if (irsp->ulpBdeCount > 0) {
1392 dmzbuf = lpfc_sli_get_buff(phba, pring,
1393 irsp->un.ulpWord[3]);
1394 lpfc_in_buf_free(phba, dmzbuf);
1397 if (irsp->ulpBdeCount > 1) {
1398 dmzbuf = lpfc_sli_get_buff(phba, pring,
1399 irsp->unsli3.sli3Words[3]);
1400 lpfc_in_buf_free(phba, dmzbuf);
1403 if (irsp->ulpBdeCount > 2) {
1404 dmzbuf = lpfc_sli_get_buff(phba, pring,
1405 irsp->unsli3.sli3Words[7]);
1406 lpfc_in_buf_free(phba, dmzbuf);
1412 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
1413 if (irsp->ulpBdeCount != 0) {
1414 saveq->context2 = lpfc_sli_get_buff(phba, pring,
1415 irsp->un.ulpWord[3]);
1416 if (!saveq->context2)
1417 lpfc_printf_log(phba,
1420 "0341 Ring %d Cannot find buffer for "
1421 "an unsolicited iocb. tag 0x%x\n",
1423 irsp->un.ulpWord[3]);
1425 if (irsp->ulpBdeCount == 2) {
1426 saveq->context3 = lpfc_sli_get_buff(phba, pring,
1427 irsp->unsli3.sli3Words[7]);
1428 if (!saveq->context3)
1429 lpfc_printf_log(phba,
1432 "0342 Ring %d Cannot find buffer for an"
1433 " unsolicited iocb. tag 0x%x\n",
1435 irsp->unsli3.sli3Words[7]);
1437 list_for_each_entry(iocbq, &saveq->list, list) {
1438 irsp = &(iocbq->iocb);
1439 if (irsp->ulpBdeCount != 0) {
1440 iocbq->context2 = lpfc_sli_get_buff(phba, pring,
1441 irsp->un.ulpWord[3]);
1442 if (!iocbq->context2)
1443 lpfc_printf_log(phba,
1446 "0343 Ring %d Cannot find "
1447 "buffer for an unsolicited iocb"
1448 ". tag 0x%x\n", pring->ringno,
1449 irsp->un.ulpWord[3]);
1451 if (irsp->ulpBdeCount == 2) {
1452 iocbq->context3 = lpfc_sli_get_buff(phba, pring,
1453 irsp->unsli3.sli3Words[7]);
1454 if (!iocbq->context3)
1455 lpfc_printf_log(phba,
1458 "0344 Ring %d Cannot find "
1459 "buffer for an unsolicited "
1462 irsp->unsli3.sli3Words[7]);
1466 if (irsp->ulpBdeCount != 0 &&
1467 (irsp->ulpCommand == CMD_IOCB_RCV_CONT64_CX ||
1468 irsp->ulpStatus == IOSTAT_INTERMED_RSP)) {
1471 /* search continue save q for same XRI */
1472 list_for_each_entry(iocbq, &pring->iocb_continue_saveq, clist) {
1473 if (iocbq->iocb.ulpContext == saveq->iocb.ulpContext) {
1474 list_add_tail(&saveq->list, &iocbq->list);
1480 list_add_tail(&saveq->clist,
1481 &pring->iocb_continue_saveq);
1482 if (saveq->iocb.ulpStatus != IOSTAT_INTERMED_RSP) {
1483 list_del_init(&iocbq->clist);
1485 irsp = &(saveq->iocb);
1489 if ((irsp->ulpCommand == CMD_RCV_ELS_REQ64_CX) ||
1490 (irsp->ulpCommand == CMD_RCV_ELS_REQ_CX) ||
1491 (irsp->ulpCommand == CMD_IOCB_RCV_ELS64_CX)) {
1495 w5p = (WORD5 *)&(saveq->iocb.un.ulpWord[5]);
1496 Rctl = w5p->hcsw.Rctl;
1497 Type = w5p->hcsw.Type;
1499 /* Firmware Workaround */
1500 if ((Rctl == 0) && (pring->ringno == LPFC_ELS_RING) &&
1501 (irsp->ulpCommand == CMD_RCV_SEQUENCE64_CX ||
1502 irsp->ulpCommand == CMD_IOCB_RCV_SEQ64_CX)) {
1505 w5p->hcsw.Rctl = Rctl;
1506 w5p->hcsw.Type = Type;
1510 /* unSolicited Responses */
1511 if (pring->prt[0].profile) {
1512 if (pring->prt[0].lpfc_sli_rcv_unsol_event)
1513 (pring->prt[0].lpfc_sli_rcv_unsol_event) (phba, pring,
1517 /* We must search, based on rctl / type
1518 for the right routine */
1519 for (i = 0; i < pring->num_mask; i++) {
1520 if ((pring->prt[i].rctl == Rctl)
1521 && (pring->prt[i].type == Type)) {
1522 if (pring->prt[i].lpfc_sli_rcv_unsol_event)
1523 (pring->prt[i].lpfc_sli_rcv_unsol_event)
1524 (phba, pring, saveq);
1531 /* Unexpected Rctl / Type received */
1532 /* Ring <ringno> handler: unexpected
1533 Rctl <Rctl> Type <Type> received */
1534 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1535 "0313 Ring %d handler: unexpected Rctl x%x "
1536 "Type x%x received\n",
1537 pring->ringno, Rctl, Type);
1543 * lpfc_sli_iocbq_lookup: Find command iocb for the given response iocb.
1544 * @phba: Pointer to HBA context object.
1545 * @pring: Pointer to driver SLI ring object.
1546 * @prspiocb: Pointer to response iocb object.
1548 * This function looks up the iocb_lookup table to get the command iocb
1549 * corresponding to the given response iocb using the iotag of the
1550 * response iocb. This function is called with the hbalock held.
1551 * This function returns the command iocb object if it finds the command
1552 * iocb else returns NULL.
1554 static struct lpfc_iocbq *
1555 lpfc_sli_iocbq_lookup(struct lpfc_hba *phba,
1556 struct lpfc_sli_ring *pring,
1557 struct lpfc_iocbq *prspiocb)
1559 struct lpfc_iocbq *cmd_iocb = NULL;
1562 iotag = prspiocb->iocb.ulpIoTag;
1564 if (iotag != 0 && iotag <= phba->sli.last_iotag) {
1565 cmd_iocb = phba->sli.iocbq_lookup[iotag];
1566 list_del_init(&cmd_iocb->list);
1567 pring->txcmplq_cnt--;
1571 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1572 "0317 iotag x%x is out off "
1573 "range: max iotag x%x wd0 x%x\n",
1574 iotag, phba->sli.last_iotag,
1575 *(((uint32_t *) &prspiocb->iocb) + 7));
1580 * lpfc_sli_process_sol_iocb: process solicited iocb completion.
1581 * @phba: Pointer to HBA context object.
1582 * @pring: Pointer to driver SLI ring object.
1583 * @saveq: Pointer to the response iocb to be processed.
1585 * This function is called by the ring event handler for non-fcp
1586 * rings when there is a new response iocb in the response ring.
1587 * The caller is not required to hold any locks. This function
1588 * gets the command iocb associated with the response iocb and
1589 * calls the completion handler for the command iocb. If there
1590 * is no completion handler, the function will free the resources
1591 * associated with command iocb. If the response iocb is for
1592 * an already aborted command iocb, the status of the completion
1593 * is changed to IOSTAT_LOCAL_REJECT/IOERR_SLI_ABORTED.
1594 * This function always returns 1.
1597 lpfc_sli_process_sol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1598 struct lpfc_iocbq *saveq)
1600 struct lpfc_iocbq *cmdiocbp;
1602 unsigned long iflag;
1604 /* Based on the iotag field, get the cmd IOCB from the txcmplq */
1605 spin_lock_irqsave(&phba->hbalock, iflag);
1606 cmdiocbp = lpfc_sli_iocbq_lookup(phba, pring, saveq);
1607 spin_unlock_irqrestore(&phba->hbalock, iflag);
1610 if (cmdiocbp->iocb_cmpl) {
1612 * Post all ELS completions to the worker thread.
1613 * All other are passed to the completion callback.
1615 if (pring->ringno == LPFC_ELS_RING) {
1616 if (cmdiocbp->iocb_flag & LPFC_DRIVER_ABORTED) {
1617 cmdiocbp->iocb_flag &=
1618 ~LPFC_DRIVER_ABORTED;
1619 saveq->iocb.ulpStatus =
1620 IOSTAT_LOCAL_REJECT;
1621 saveq->iocb.un.ulpWord[4] =
1624 /* Firmware could still be in progress
1625 * of DMAing payload, so don't free data
1626 * buffer till after a hbeat.
1628 saveq->iocb_flag |= LPFC_DELAY_MEM_FREE;
1631 (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
1633 lpfc_sli_release_iocbq(phba, cmdiocbp);
1636 * Unknown initiating command based on the response iotag.
1637 * This could be the case on the ELS ring because of
1640 if (pring->ringno != LPFC_ELS_RING) {
1642 * Ring <ringno> handler: unexpected completion IoTag
1645 lpfc_printf_vlog(cmdiocbp->vport, KERN_WARNING, LOG_SLI,
1646 "0322 Ring %d handler: "
1647 "unexpected completion IoTag x%x "
1648 "Data: x%x x%x x%x x%x\n",
1650 saveq->iocb.ulpIoTag,
1651 saveq->iocb.ulpStatus,
1652 saveq->iocb.un.ulpWord[4],
1653 saveq->iocb.ulpCommand,
1654 saveq->iocb.ulpContext);
1662 * lpfc_sli_rsp_pointers_error: Response ring pointer error handler.
1663 * @phba: Pointer to HBA context object.
1664 * @pring: Pointer to driver SLI ring object.
1666 * This function is called from the iocb ring event handlers when
1667 * put pointer is ahead of the get pointer for a ring. This function signal
1668 * an error attention condition to the worker thread and the worker
1669 * thread will transition the HBA to offline state.
1672 lpfc_sli_rsp_pointers_error(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1674 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1676 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1677 * rsp ring <portRspMax>
1679 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1680 "0312 Ring %d handler: portRspPut %d "
1681 "is bigger then rsp ring %d\n",
1682 pring->ringno, le32_to_cpu(pgp->rspPutInx),
1685 phba->link_state = LPFC_HBA_ERROR;
1688 * All error attention handlers are posted to
1691 phba->work_ha |= HA_ERATT;
1692 phba->work_hs = HS_FFER3;
1694 lpfc_worker_wake_up(phba);
1700 * lpfc_sli_poll_fcp_ring: Handle FCP ring completion in polling mode.
1701 * @phba: Pointer to HBA context object.
1703 * This function is called from lpfc_queuecommand, lpfc_poll_timeout,
1704 * lpfc_abort_handler and lpfc_slave_configure when FCP_RING_POLLING
1707 * The caller does not hold any lock.
1708 * The function processes each response iocb in the response ring until it
1709 * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
1710 * LE bit set. The function will call the completion handler of the command iocb
1711 * if the response iocb indicates a completion for a command iocb or it is
1712 * an abort completion.
1714 void lpfc_sli_poll_fcp_ring(struct lpfc_hba *phba)
1716 struct lpfc_sli *psli = &phba->sli;
1717 struct lpfc_sli_ring *pring = &psli->ring[LPFC_FCP_RING];
1718 IOCB_t *irsp = NULL;
1719 IOCB_t *entry = NULL;
1720 struct lpfc_iocbq *cmdiocbq = NULL;
1721 struct lpfc_iocbq rspiocbq;
1722 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1724 uint32_t portRspPut, portRspMax;
1726 uint32_t rsp_cmpl = 0;
1728 unsigned long iflags;
1730 pring->stats.iocb_event++;
1733 * The next available response entry should never exceed the maximum
1734 * entries. If it does, treat it as an adapter hardware error.
1736 portRspMax = pring->numRiocb;
1737 portRspPut = le32_to_cpu(pgp->rspPutInx);
1738 if (unlikely(portRspPut >= portRspMax)) {
1739 lpfc_sli_rsp_pointers_error(phba, pring);
1744 while (pring->rspidx != portRspPut) {
1745 entry = lpfc_resp_iocb(phba, pring);
1746 if (++pring->rspidx >= portRspMax)
1749 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
1750 (uint32_t *) &rspiocbq.iocb,
1751 phba->iocb_rsp_size);
1752 irsp = &rspiocbq.iocb;
1753 type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
1754 pring->stats.iocb_rsp++;
1757 if (unlikely(irsp->ulpStatus)) {
1758 /* Rsp ring <ringno> error: IOCB */
1759 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1760 "0326 Rsp Ring %d error: IOCB Data: "
1761 "x%x x%x x%x x%x x%x x%x x%x x%x\n",
1763 irsp->un.ulpWord[0],
1764 irsp->un.ulpWord[1],
1765 irsp->un.ulpWord[2],
1766 irsp->un.ulpWord[3],
1767 irsp->un.ulpWord[4],
1768 irsp->un.ulpWord[5],
1769 *(uint32_t *)&irsp->un1,
1770 *((uint32_t *)&irsp->un1 + 1));
1774 case LPFC_ABORT_IOCB:
1777 * Idle exchange closed via ABTS from port. No iocb
1778 * resources need to be recovered.
1780 if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
1781 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1782 "0314 IOCB cmd 0x%x "
1783 "processed. Skipping "
1789 spin_lock_irqsave(&phba->hbalock, iflags);
1790 cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1792 spin_unlock_irqrestore(&phba->hbalock, iflags);
1793 if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
1794 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1799 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
1800 char adaptermsg[LPFC_MAX_ADPTMSG];
1801 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
1802 memcpy(&adaptermsg[0], (uint8_t *) irsp,
1804 dev_warn(&((phba->pcidev)->dev),
1806 phba->brd_no, adaptermsg);
1808 /* Unknown IOCB command */
1809 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1810 "0321 Unknown IOCB command "
1811 "Data: x%x, x%x x%x x%x x%x\n",
1812 type, irsp->ulpCommand,
1821 * The response IOCB has been processed. Update the ring
1822 * pointer in SLIM. If the port response put pointer has not
1823 * been updated, sync the pgp->rspPutInx and fetch the new port
1824 * response put pointer.
1826 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
1828 if (pring->rspidx == portRspPut)
1829 portRspPut = le32_to_cpu(pgp->rspPutInx);
1832 ha_copy = readl(phba->HAregaddr);
1833 ha_copy >>= (LPFC_FCP_RING * 4);
1835 if ((rsp_cmpl > 0) && (ha_copy & HA_R0RE_REQ)) {
1836 spin_lock_irqsave(&phba->hbalock, iflags);
1837 pring->stats.iocb_rsp_full++;
1838 status = ((CA_R0ATT | CA_R0RE_RSP) << (LPFC_FCP_RING * 4));
1839 writel(status, phba->CAregaddr);
1840 readl(phba->CAregaddr);
1841 spin_unlock_irqrestore(&phba->hbalock, iflags);
1843 if ((ha_copy & HA_R0CE_RSP) &&
1844 (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
1845 spin_lock_irqsave(&phba->hbalock, iflags);
1846 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
1847 pring->stats.iocb_cmd_empty++;
1849 /* Force update of the local copy of cmdGetInx */
1850 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
1851 lpfc_sli_resume_iocb(phba, pring);
1853 if ((pring->lpfc_sli_cmd_available))
1854 (pring->lpfc_sli_cmd_available) (phba, pring);
1856 spin_unlock_irqrestore(&phba->hbalock, iflags);
1863 * lpfc_sli_handle_fast_ring_event: Handle ring events on FCP ring.
1864 * @phba: Pointer to HBA context object.
1865 * @pring: Pointer to driver SLI ring object.
1866 * @mask: Host attention register mask for this ring.
1868 * This function is called from the interrupt context when there is a ring
1869 * event for the fcp ring. The caller does not hold any lock.
1870 * The function processes each response iocb in the response ring until it
1871 * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
1872 * LE bit set. The function will call the completion handler of the command iocb
1873 * if the response iocb indicates a completion for a command iocb or it is
1874 * an abort completion. The function will call lpfc_sli_process_unsol_iocb
1875 * function if this is an unsolicited iocb.
1876 * This routine presumes LPFC_FCP_RING handling and doesn't bother
1877 * to check it explicitly. This function always returns 1.
1880 lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
1881 struct lpfc_sli_ring *pring, uint32_t mask)
1883 struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1884 IOCB_t *irsp = NULL;
1885 IOCB_t *entry = NULL;
1886 struct lpfc_iocbq *cmdiocbq = NULL;
1887 struct lpfc_iocbq rspiocbq;
1889 uint32_t portRspPut, portRspMax;
1891 lpfc_iocb_type type;
1892 unsigned long iflag;
1893 uint32_t rsp_cmpl = 0;
1895 spin_lock_irqsave(&phba->hbalock, iflag);
1896 pring->stats.iocb_event++;
1899 * The next available response entry should never exceed the maximum
1900 * entries. If it does, treat it as an adapter hardware error.
1902 portRspMax = pring->numRiocb;
1903 portRspPut = le32_to_cpu(pgp->rspPutInx);
1904 if (unlikely(portRspPut >= portRspMax)) {
1905 lpfc_sli_rsp_pointers_error(phba, pring);
1906 spin_unlock_irqrestore(&phba->hbalock, iflag);
1911 while (pring->rspidx != portRspPut) {
1913 * Fetch an entry off the ring and copy it into a local data
1914 * structure. The copy involves a byte-swap since the
1915 * network byte order and pci byte orders are different.
1917 entry = lpfc_resp_iocb(phba, pring);
1918 phba->last_completion_time = jiffies;
1920 if (++pring->rspidx >= portRspMax)
1923 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
1924 (uint32_t *) &rspiocbq.iocb,
1925 phba->iocb_rsp_size);
1926 INIT_LIST_HEAD(&(rspiocbq.list));
1927 irsp = &rspiocbq.iocb;
1929 type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
1930 pring->stats.iocb_rsp++;
1933 if (unlikely(irsp->ulpStatus)) {
1935 * If resource errors reported from HBA, reduce
1936 * queuedepths of the SCSI device.
1938 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1939 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
1940 spin_unlock_irqrestore(&phba->hbalock, iflag);
1941 lpfc_adjust_queue_depth(phba);
1942 spin_lock_irqsave(&phba->hbalock, iflag);
1945 /* Rsp ring <ringno> error: IOCB */
1946 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1947 "0336 Rsp Ring %d error: IOCB Data: "
1948 "x%x x%x x%x x%x x%x x%x x%x x%x\n",
1950 irsp->un.ulpWord[0],
1951 irsp->un.ulpWord[1],
1952 irsp->un.ulpWord[2],
1953 irsp->un.ulpWord[3],
1954 irsp->un.ulpWord[4],
1955 irsp->un.ulpWord[5],
1956 *(uint32_t *)&irsp->un1,
1957 *((uint32_t *)&irsp->un1 + 1));
1961 case LPFC_ABORT_IOCB:
1964 * Idle exchange closed via ABTS from port. No iocb
1965 * resources need to be recovered.
1967 if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
1968 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1969 "0333 IOCB cmd 0x%x"
1970 " processed. Skipping"
1976 cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1978 if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
1979 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
1980 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1983 spin_unlock_irqrestore(&phba->hbalock,
1985 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1987 spin_lock_irqsave(&phba->hbalock,
1992 case LPFC_UNSOL_IOCB:
1993 spin_unlock_irqrestore(&phba->hbalock, iflag);
1994 lpfc_sli_process_unsol_iocb(phba, pring, &rspiocbq);
1995 spin_lock_irqsave(&phba->hbalock, iflag);
1998 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
1999 char adaptermsg[LPFC_MAX_ADPTMSG];
2000 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
2001 memcpy(&adaptermsg[0], (uint8_t *) irsp,
2003 dev_warn(&((phba->pcidev)->dev),
2005 phba->brd_no, adaptermsg);
2007 /* Unknown IOCB command */
2008 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2009 "0334 Unknown IOCB command "
2010 "Data: x%x, x%x x%x x%x x%x\n",
2011 type, irsp->ulpCommand,
2020 * The response IOCB has been processed. Update the ring
2021 * pointer in SLIM. If the port response put pointer has not
2022 * been updated, sync the pgp->rspPutInx and fetch the new port
2023 * response put pointer.
2025 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
2027 if (pring->rspidx == portRspPut)
2028 portRspPut = le32_to_cpu(pgp->rspPutInx);
2031 if ((rsp_cmpl > 0) && (mask & HA_R0RE_REQ)) {
2032 pring->stats.iocb_rsp_full++;
2033 status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
2034 writel(status, phba->CAregaddr);
2035 readl(phba->CAregaddr);
2037 if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
2038 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
2039 pring->stats.iocb_cmd_empty++;
2041 /* Force update of the local copy of cmdGetInx */
2042 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
2043 lpfc_sli_resume_iocb(phba, pring);
2045 if ((pring->lpfc_sli_cmd_available))
2046 (pring->lpfc_sli_cmd_available) (phba, pring);
2050 spin_unlock_irqrestore(&phba->hbalock, iflag);
2055 * lpfc_sli_handle_slow_ring_event: Handle ring events for non-FCP rings.
2056 * @phba: Pointer to HBA context object.
2057 * @pring: Pointer to driver SLI ring object.
2058 * @mask: Host attention register mask for this ring.
2060 * This function is called from the worker thread when there is a ring
2061 * event for non-fcp rings. The caller does not hold any lock .
2062 * The function processes each response iocb in the response ring until it
2063 * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
2064 * LE bit set. The function will call lpfc_sli_process_sol_iocb function if the
2065 * response iocb indicates a completion of a command iocb. The function
2066 * will call lpfc_sli_process_unsol_iocb function if this is an unsolicited
2067 * iocb. The function frees the resources or calls the completion handler if
2068 * this iocb is an abort completion. The function returns 0 when the allocated
2069 * iocbs are not freed, otherwise returns 1.
2072 lpfc_sli_handle_slow_ring_event(struct lpfc_hba *phba,
2073 struct lpfc_sli_ring *pring, uint32_t mask)
2075 struct lpfc_pgp *pgp;
2077 IOCB_t *irsp = NULL;
2078 struct lpfc_iocbq *rspiocbp = NULL;
2079 struct lpfc_iocbq *next_iocb;
2080 struct lpfc_iocbq *cmdiocbp;
2081 struct lpfc_iocbq *saveq;
2082 uint8_t iocb_cmd_type;
2083 lpfc_iocb_type type;
2084 uint32_t status, free_saveq;
2085 uint32_t portRspPut, portRspMax;
2087 unsigned long iflag;
2089 pgp = &phba->port_gp[pring->ringno];
2090 spin_lock_irqsave(&phba->hbalock, iflag);
2091 pring->stats.iocb_event++;
2094 * The next available response entry should never exceed the maximum
2095 * entries. If it does, treat it as an adapter hardware error.
2097 portRspMax = pring->numRiocb;
2098 portRspPut = le32_to_cpu(pgp->rspPutInx);
2099 if (portRspPut >= portRspMax) {
2101 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
2102 * rsp ring <portRspMax>
2104 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2105 "0303 Ring %d handler: portRspPut %d "
2106 "is bigger then rsp ring %d\n",
2107 pring->ringno, portRspPut, portRspMax);
2109 phba->link_state = LPFC_HBA_ERROR;
2110 spin_unlock_irqrestore(&phba->hbalock, iflag);
2112 phba->work_hs = HS_FFER3;
2113 lpfc_handle_eratt(phba);
2119 while (pring->rspidx != portRspPut) {
2121 * Build a completion list and call the appropriate handler.
2122 * The process is to get the next available response iocb, get
2123 * a free iocb from the list, copy the response data into the
2124 * free iocb, insert to the continuation list, and update the
2125 * next response index to slim. This process makes response
2126 * iocb's in the ring available to DMA as fast as possible but
2127 * pays a penalty for a copy operation. Since the iocb is
2128 * only 32 bytes, this penalty is considered small relative to
2129 * the PCI reads for register values and a slim write. When
2130 * the ulpLe field is set, the entire Command has been
2133 entry = lpfc_resp_iocb(phba, pring);
2135 phba->last_completion_time = jiffies;
2136 rspiocbp = __lpfc_sli_get_iocbq(phba);
2137 if (rspiocbp == NULL) {
2138 printk(KERN_ERR "%s: out of buffers! Failing "
2139 "completion.\n", __func__);
2143 lpfc_sli_pcimem_bcopy(entry, &rspiocbp->iocb,
2144 phba->iocb_rsp_size);
2145 irsp = &rspiocbp->iocb;
2147 if (++pring->rspidx >= portRspMax)
2150 if (pring->ringno == LPFC_ELS_RING) {
2151 lpfc_debugfs_slow_ring_trc(phba,
2152 "IOCB rsp ring: wd4:x%08x wd6:x%08x wd7:x%08x",
2153 *(((uint32_t *) irsp) + 4),
2154 *(((uint32_t *) irsp) + 6),
2155 *(((uint32_t *) irsp) + 7));
2158 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
2160 list_add_tail(&rspiocbp->list, &(pring->iocb_continueq));
2162 pring->iocb_continueq_cnt++;
2165 * By default, the driver expects to free all resources
2166 * associated with this iocb completion.
2169 saveq = list_get_first(&pring->iocb_continueq,
2170 struct lpfc_iocbq, list);
2171 irsp = &(saveq->iocb);
2172 list_del_init(&pring->iocb_continueq);
2173 pring->iocb_continueq_cnt = 0;
2175 pring->stats.iocb_rsp++;
2178 * If resource errors reported from HBA, reduce
2179 * queuedepths of the SCSI device.
2181 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
2182 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
2183 spin_unlock_irqrestore(&phba->hbalock, iflag);
2184 lpfc_adjust_queue_depth(phba);
2185 spin_lock_irqsave(&phba->hbalock, iflag);
2188 if (irsp->ulpStatus) {
2189 /* Rsp ring <ringno> error: IOCB */
2190 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
2191 "0328 Rsp Ring %d error: "
2196 "x%x x%x x%x x%x\n",
2198 irsp->un.ulpWord[0],
2199 irsp->un.ulpWord[1],
2200 irsp->un.ulpWord[2],
2201 irsp->un.ulpWord[3],
2202 irsp->un.ulpWord[4],
2203 irsp->un.ulpWord[5],
2204 *(((uint32_t *) irsp) + 6),
2205 *(((uint32_t *) irsp) + 7),
2206 *(((uint32_t *) irsp) + 8),
2207 *(((uint32_t *) irsp) + 9),
2208 *(((uint32_t *) irsp) + 10),
2209 *(((uint32_t *) irsp) + 11),
2210 *(((uint32_t *) irsp) + 12),
2211 *(((uint32_t *) irsp) + 13),
2212 *(((uint32_t *) irsp) + 14),
2213 *(((uint32_t *) irsp) + 15));
2217 * Fetch the IOCB command type and call the correct
2218 * completion routine. Solicited and Unsolicited
2219 * IOCBs on the ELS ring get freed back to the
2220 * lpfc_iocb_list by the discovery kernel thread.
2222 iocb_cmd_type = irsp->ulpCommand & CMD_IOCB_MASK;
2223 type = lpfc_sli_iocb_cmd_type(iocb_cmd_type);
2224 if (type == LPFC_SOL_IOCB) {
2225 spin_unlock_irqrestore(&phba->hbalock, iflag);
2226 rc = lpfc_sli_process_sol_iocb(phba, pring,
2228 spin_lock_irqsave(&phba->hbalock, iflag);
2229 } else if (type == LPFC_UNSOL_IOCB) {
2230 spin_unlock_irqrestore(&phba->hbalock, iflag);
2231 rc = lpfc_sli_process_unsol_iocb(phba, pring,
2233 spin_lock_irqsave(&phba->hbalock, iflag);
2236 } else if (type == LPFC_ABORT_IOCB) {
2237 if ((irsp->ulpCommand != CMD_XRI_ABORTED_CX) &&
2239 lpfc_sli_iocbq_lookup(phba, pring,
2241 /* Call the specified completion
2243 if (cmdiocbp->iocb_cmpl) {
2244 spin_unlock_irqrestore(
2247 (cmdiocbp->iocb_cmpl) (phba,
2253 __lpfc_sli_release_iocbq(phba,
2256 } else if (type == LPFC_UNKNOWN_IOCB) {
2257 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
2259 char adaptermsg[LPFC_MAX_ADPTMSG];
2261 memset(adaptermsg, 0,
2263 memcpy(&adaptermsg[0], (uint8_t *) irsp,
2265 dev_warn(&((phba->pcidev)->dev),
2267 phba->brd_no, adaptermsg);
2269 /* Unknown IOCB command */
2270 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2271 "0335 Unknown IOCB "
2272 "command Data: x%x "
2282 list_for_each_entry_safe(rspiocbp, next_iocb,
2283 &saveq->list, list) {
2284 list_del(&rspiocbp->list);
2285 __lpfc_sli_release_iocbq(phba,
2288 __lpfc_sli_release_iocbq(phba, saveq);
2294 * If the port response put pointer has not been updated, sync
2295 * the pgp->rspPutInx in the MAILBOX_tand fetch the new port
2296 * response put pointer.
2298 if (pring->rspidx == portRspPut) {
2299 portRspPut = le32_to_cpu(pgp->rspPutInx);
2301 } /* while (pring->rspidx != portRspPut) */
2303 if ((rspiocbp != NULL) && (mask & HA_R0RE_REQ)) {
2304 /* At least one response entry has been freed */
2305 pring->stats.iocb_rsp_full++;
2306 /* SET RxRE_RSP in Chip Att register */
2307 status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
2308 writel(status, phba->CAregaddr);
2309 readl(phba->CAregaddr); /* flush */
2311 if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
2312 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
2313 pring->stats.iocb_cmd_empty++;
2315 /* Force update of the local copy of cmdGetInx */
2316 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
2317 lpfc_sli_resume_iocb(phba, pring);
2319 if ((pring->lpfc_sli_cmd_available))
2320 (pring->lpfc_sli_cmd_available) (phba, pring);
2324 spin_unlock_irqrestore(&phba->hbalock, iflag);
2329 * lpfc_sli_abort_iocb_ring: Abort all iocbs in the ring.
2330 * @phba: Pointer to HBA context object.
2331 * @pring: Pointer to driver SLI ring object.
2333 * This function aborts all iocbs in the given ring and frees all the iocb
2334 * objects in txq. This function issues an abort iocb for all the iocb commands
2335 * in txcmplq. The iocbs in the txcmplq is not guaranteed to complete before
2336 * the return of this function. The caller is not required to hold any locks.
2339 lpfc_sli_abort_iocb_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
2341 LIST_HEAD(completions);
2342 struct lpfc_iocbq *iocb, *next_iocb;
2345 if (pring->ringno == LPFC_ELS_RING) {
2346 lpfc_fabric_abort_hba(phba);
2349 /* Error everything on txq and txcmplq
2352 spin_lock_irq(&phba->hbalock);
2353 list_splice_init(&pring->txq, &completions);
2356 /* Next issue ABTS for everything on the txcmplq */
2357 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list)
2358 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
2360 spin_unlock_irq(&phba->hbalock);
2362 while (!list_empty(&completions)) {
2363 iocb = list_get_first(&completions, struct lpfc_iocbq, list);
2365 list_del_init(&iocb->list);
2367 if (!iocb->iocb_cmpl)
2368 lpfc_sli_release_iocbq(phba, iocb);
2370 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
2371 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
2372 (iocb->iocb_cmpl) (phba, iocb, iocb);
2378 * lpfc_sli_brdready: Check for host status bits.
2379 * @phba: Pointer to HBA context object.
2380 * @mask: Bit mask to be checked.
2382 * This function reads the host status register and compares
2383 * with the provided bit mask to check if HBA completed
2384 * the restart. This function will wait in a loop for the
2385 * HBA to complete restart. If the HBA does not restart within
2386 * 15 iterations, the function will reset the HBA again. The
2387 * function returns 1 when HBA fail to restart otherwise returns
2391 lpfc_sli_brdready(struct lpfc_hba *phba, uint32_t mask)
2397 /* Read the HBA Host Status Register */
2398 status = readl(phba->HSregaddr);
2401 * Check status register every 100ms for 5 retries, then every
2402 * 500ms for 5, then every 2.5 sec for 5, then reset board and
2403 * every 2.5 sec for 4.
2404 * Break our of the loop if errors occurred during init.
2406 while (((status & mask) != mask) &&
2407 !(status & HS_FFERM) &&
2419 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
2420 lpfc_sli_brdrestart(phba);
2422 /* Read the HBA Host Status Register */
2423 status = readl(phba->HSregaddr);
2426 /* Check to see if any errors occurred during init */
2427 if ((status & HS_FFERM) || (i >= 20)) {
2428 phba->link_state = LPFC_HBA_ERROR;
2435 #define BARRIER_TEST_PATTERN (0xdeadbeef)
2438 * lpfc_reset_barrier: Make HBA ready for HBA reset.
2439 * @phba: Pointer to HBA context object.
2441 * This function is called before resetting an HBA. This
2442 * function requests HBA to quiesce DMAs before a reset.
2444 void lpfc_reset_barrier(struct lpfc_hba *phba)
2446 uint32_t __iomem *resp_buf;
2447 uint32_t __iomem *mbox_buf;
2448 volatile uint32_t mbox;
2453 pci_read_config_byte(phba->pcidev, PCI_HEADER_TYPE, &hdrtype);
2454 if (hdrtype != 0x80 ||
2455 (FC_JEDEC_ID(phba->vpd.rev.biuRev) != HELIOS_JEDEC_ID &&
2456 FC_JEDEC_ID(phba->vpd.rev.biuRev) != THOR_JEDEC_ID))
2460 * Tell the other part of the chip to suspend temporarily all
2463 resp_buf = phba->MBslimaddr;
2465 /* Disable the error attention */
2466 hc_copy = readl(phba->HCregaddr);
2467 writel((hc_copy & ~HC_ERINT_ENA), phba->HCregaddr);
2468 readl(phba->HCregaddr); /* flush */
2469 phba->link_flag |= LS_IGNORE_ERATT;
2471 if (readl(phba->HAregaddr) & HA_ERATT) {
2472 /* Clear Chip error bit */
2473 writel(HA_ERATT, phba->HAregaddr);
2474 phba->pport->stopped = 1;
2478 ((MAILBOX_t *)&mbox)->mbxCommand = MBX_KILL_BOARD;
2479 ((MAILBOX_t *)&mbox)->mbxOwner = OWN_CHIP;
2481 writel(BARRIER_TEST_PATTERN, (resp_buf + 1));
2482 mbox_buf = phba->MBslimaddr;
2483 writel(mbox, mbox_buf);
2486 readl(resp_buf + 1) != ~(BARRIER_TEST_PATTERN) && i < 50; i++)
2489 if (readl(resp_buf + 1) != ~(BARRIER_TEST_PATTERN)) {
2490 if (phba->sli.sli_flag & LPFC_SLI2_ACTIVE ||
2491 phba->pport->stopped)
2497 ((MAILBOX_t *)&mbox)->mbxOwner = OWN_HOST;
2498 for (i = 0; readl(resp_buf) != mbox && i < 500; i++)
2503 while (!(readl(phba->HAregaddr) & HA_ERATT) && ++i < 500)
2506 if (readl(phba->HAregaddr) & HA_ERATT) {
2507 writel(HA_ERATT, phba->HAregaddr);
2508 phba->pport->stopped = 1;
2512 phba->link_flag &= ~LS_IGNORE_ERATT;
2513 writel(hc_copy, phba->HCregaddr);
2514 readl(phba->HCregaddr); /* flush */
2518 * lpfc_sli_brdkill: Issue a kill_board mailbox command.
2519 * @phba: Pointer to HBA context object.
2521 * This function issues a kill_board mailbox command and waits for
2522 * the error attention interrupt. This function is called for stopping
2523 * the firmware processing. The caller is not required to hold any
2524 * locks. This function calls lpfc_hba_down_post function to free
2525 * any pending commands after the kill. The function will return 1 when it
2526 * fails to kill the board else will return 0.
2529 lpfc_sli_brdkill(struct lpfc_hba *phba)
2531 struct lpfc_sli *psli;
2541 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2542 "0329 Kill HBA Data: x%x x%x\n",
2543 phba->pport->port_state, psli->sli_flag);
2545 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2549 /* Disable the error attention */
2550 spin_lock_irq(&phba->hbalock);
2551 status = readl(phba->HCregaddr);
2552 status &= ~HC_ERINT_ENA;
2553 writel(status, phba->HCregaddr);
2554 readl(phba->HCregaddr); /* flush */
2555 phba->link_flag |= LS_IGNORE_ERATT;
2556 spin_unlock_irq(&phba->hbalock);
2558 lpfc_kill_board(phba, pmb);
2559 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2560 retval = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
2562 if (retval != MBX_SUCCESS) {
2563 if (retval != MBX_BUSY)
2564 mempool_free(pmb, phba->mbox_mem_pool);
2565 spin_lock_irq(&phba->hbalock);
2566 phba->link_flag &= ~LS_IGNORE_ERATT;
2567 spin_unlock_irq(&phba->hbalock);
2571 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
2573 mempool_free(pmb, phba->mbox_mem_pool);
2575 /* There is no completion for a KILL_BOARD mbox cmd. Check for an error
2576 * attention every 100ms for 3 seconds. If we don't get ERATT after
2577 * 3 seconds we still set HBA_ERROR state because the status of the
2578 * board is now undefined.
2580 ha_copy = readl(phba->HAregaddr);
2582 while ((i++ < 30) && !(ha_copy & HA_ERATT)) {
2584 ha_copy = readl(phba->HAregaddr);
2587 del_timer_sync(&psli->mbox_tmo);
2588 if (ha_copy & HA_ERATT) {
2589 writel(HA_ERATT, phba->HAregaddr);
2590 phba->pport->stopped = 1;
2592 spin_lock_irq(&phba->hbalock);
2593 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
2594 phba->link_flag &= ~LS_IGNORE_ERATT;
2595 spin_unlock_irq(&phba->hbalock);
2597 psli->mbox_active = NULL;
2598 lpfc_hba_down_post(phba);
2599 phba->link_state = LPFC_HBA_ERROR;
2601 return ha_copy & HA_ERATT ? 0 : 1;
2605 * lpfc_sli_brdreset: Reset the HBA.
2606 * @phba: Pointer to HBA context object.
2608 * This function resets the HBA by writing HC_INITFF to the control
2609 * register. After the HBA resets, this function resets all the iocb ring
2610 * indices. This function disables PCI layer parity checking during
2612 * This function returns 0 always.
2613 * The caller is not required to hold any locks.
2616 lpfc_sli_brdreset(struct lpfc_hba *phba)
2618 struct lpfc_sli *psli;
2619 struct lpfc_sli_ring *pring;
2626 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2627 "0325 Reset HBA Data: x%x x%x\n",
2628 phba->pport->port_state, psli->sli_flag);
2630 /* perform board reset */
2631 phba->fc_eventTag = 0;
2632 phba->pport->fc_myDID = 0;
2633 phba->pport->fc_prevDID = 0;
2635 /* Turn off parity checking and serr during the physical reset */
2636 pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value);
2637 pci_write_config_word(phba->pcidev, PCI_COMMAND,
2639 ~(PCI_COMMAND_PARITY | PCI_COMMAND_SERR)));
2641 psli->sli_flag &= ~(LPFC_SLI2_ACTIVE | LPFC_PROCESS_LA);
2642 /* Now toggle INITFF bit in the Host Control Register */
2643 writel(HC_INITFF, phba->HCregaddr);
2645 readl(phba->HCregaddr); /* flush */
2646 writel(0, phba->HCregaddr);
2647 readl(phba->HCregaddr); /* flush */
2649 /* Restore PCI cmd register */
2650 pci_write_config_word(phba->pcidev, PCI_COMMAND, cfg_value);
2652 /* Initialize relevant SLI info */
2653 for (i = 0; i < psli->num_rings; i++) {
2654 pring = &psli->ring[i];
2657 pring->next_cmdidx = 0;
2658 pring->local_getidx = 0;
2660 pring->missbufcnt = 0;
2663 phba->link_state = LPFC_WARM_START;
2668 * lpfc_sli_brdrestart: Restart the HBA.
2669 * @phba: Pointer to HBA context object.
2671 * This function is called in the SLI initialization code path to
2672 * restart the HBA. The caller is not required to hold any lock.
2673 * This function writes MBX_RESTART mailbox command to the SLIM and
2674 * resets the HBA. At the end of the function, it calls lpfc_hba_down_post
2675 * function to free any pending commands. The function enables
2676 * POST only during the first initialization. The function returns zero.
2677 * The function does not guarantee completion of MBX_RESTART mailbox
2678 * command before the return of this function.
2681 lpfc_sli_brdrestart(struct lpfc_hba *phba)
2684 struct lpfc_sli *psli;
2686 volatile uint32_t word0;
2687 void __iomem *to_slim;
2689 spin_lock_irq(&phba->hbalock);
2694 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2695 "0337 Restart HBA Data: x%x x%x\n",
2696 phba->pport->port_state, psli->sli_flag);
2699 mb = (MAILBOX_t *) &word0;
2700 mb->mbxCommand = MBX_RESTART;
2703 lpfc_reset_barrier(phba);
2705 to_slim = phba->MBslimaddr;
2706 writel(*(uint32_t *) mb, to_slim);
2707 readl(to_slim); /* flush */
2709 /* Only skip post after fc_ffinit is completed */
2710 if (phba->pport->port_state) {
2712 word0 = 1; /* This is really setting up word1 */
2715 word0 = 0; /* This is really setting up word1 */
2717 to_slim = phba->MBslimaddr + sizeof (uint32_t);
2718 writel(*(uint32_t *) mb, to_slim);
2719 readl(to_slim); /* flush */
2721 lpfc_sli_brdreset(phba);
2722 phba->pport->stopped = 0;
2723 phba->link_state = LPFC_INIT_START;
2725 spin_unlock_irq(&phba->hbalock);
2727 memset(&psli->lnk_stat_offsets, 0, sizeof(psli->lnk_stat_offsets));
2728 psli->stats_start = get_seconds();
2735 lpfc_hba_down_post(phba);
2741 * lpfc_sli_chipset_init: Wait for the restart of the HBA after a restart.
2742 * @phba: Pointer to HBA context object.
2744 * This function is called after a HBA restart to wait for successful
2745 * restart of the HBA. Successful restart of the HBA is indicated by
2746 * HS_FFRDY and HS_MBRDY bits. If the HBA fails to restart even after 15
2747 * iteration, the function will restart the HBA again. The function returns
2748 * zero if HBA successfully restarted else returns negative error code.
2751 lpfc_sli_chipset_init(struct lpfc_hba *phba)
2753 uint32_t status, i = 0;
2755 /* Read the HBA Host Status Register */
2756 status = readl(phba->HSregaddr);
2758 /* Check status register to see what current state is */
2760 while ((status & (HS_FFRDY | HS_MBRDY)) != (HS_FFRDY | HS_MBRDY)) {
2762 /* Check every 100ms for 5 retries, then every 500ms for 5, then
2763 * every 2.5 sec for 5, then reset board and every 2.5 sec for
2767 /* Adapter failed to init, timeout, status reg
2769 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2770 "0436 Adapter failed to init, "
2771 "timeout, status reg x%x, "
2772 "FW Data: A8 x%x AC x%x\n", status,
2773 readl(phba->MBslimaddr + 0xa8),
2774 readl(phba->MBslimaddr + 0xac));
2775 phba->link_state = LPFC_HBA_ERROR;
2779 /* Check to see if any errors occurred during init */
2780 if (status & HS_FFERM) {
2781 /* ERROR: During chipset initialization */
2782 /* Adapter failed to init, chipset, status reg
2784 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2785 "0437 Adapter failed to init, "
2786 "chipset, status reg x%x, "
2787 "FW Data: A8 x%x AC x%x\n", status,
2788 readl(phba->MBslimaddr + 0xa8),
2789 readl(phba->MBslimaddr + 0xac));
2790 phba->link_state = LPFC_HBA_ERROR;
2796 } else if (i <= 10) {
2804 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
2805 lpfc_sli_brdrestart(phba);
2807 /* Read the HBA Host Status Register */
2808 status = readl(phba->HSregaddr);
2811 /* Check to see if any errors occurred during init */
2812 if (status & HS_FFERM) {
2813 /* ERROR: During chipset initialization */
2814 /* Adapter failed to init, chipset, status reg <status> */
2815 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2816 "0438 Adapter failed to init, chipset, "
2818 "FW Data: A8 x%x AC x%x\n", status,
2819 readl(phba->MBslimaddr + 0xa8),
2820 readl(phba->MBslimaddr + 0xac));
2821 phba->link_state = LPFC_HBA_ERROR;
2825 /* Clear all interrupt enable conditions */
2826 writel(0, phba->HCregaddr);
2827 readl(phba->HCregaddr); /* flush */
2829 /* setup host attn register */
2830 writel(0xffffffff, phba->HAregaddr);
2831 readl(phba->HAregaddr); /* flush */
2836 * lpfc_sli_hbq_count: Get the number of HBQs to be configured.
2838 * This function calculates and returns the number of HBQs required to be
2842 lpfc_sli_hbq_count(void)
2844 return ARRAY_SIZE(lpfc_hbq_defs);
2848 * lpfc_sli_hbq_entry_count: Calculate total number of hbq entries.
2850 * This function adds the number of hbq entries in every HBQ to get
2851 * the total number of hbq entries required for the HBA and returns
2855 lpfc_sli_hbq_entry_count(void)
2857 int hbq_count = lpfc_sli_hbq_count();
2861 for (i = 0; i < hbq_count; ++i)
2862 count += lpfc_hbq_defs[i]->entry_count;
2867 * lpfc_sli_hbq_size: Calculate memory required for all hbq entries.
2869 * This function calculates amount of memory required for all hbq entries
2870 * to be configured and returns the total memory required.
2873 lpfc_sli_hbq_size(void)
2875 return lpfc_sli_hbq_entry_count() * sizeof(struct lpfc_hbq_entry);
2879 * lpfc_sli_hbq_setup: configure and initialize HBQs.
2880 * @phba: Pointer to HBA context object.
2882 * This function is called during the SLI initialization to configure
2883 * all the HBQs and post buffers to the HBQ. The caller is not
2884 * required to hold any locks. This function will return zero if successful
2885 * else it will return negative error code.
2888 lpfc_sli_hbq_setup(struct lpfc_hba *phba)
2890 int hbq_count = lpfc_sli_hbq_count();
2894 uint32_t hbq_entry_index;
2896 /* Get a Mailbox buffer to setup mailbox
2897 * commands for HBA initialization
2899 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2906 /* Initialize the struct lpfc_sli_hbq structure for each hbq */
2907 phba->link_state = LPFC_INIT_MBX_CMDS;
2908 phba->hbq_in_use = 1;
2910 hbq_entry_index = 0;
2911 for (hbqno = 0; hbqno < hbq_count; ++hbqno) {
2912 phba->hbqs[hbqno].next_hbqPutIdx = 0;
2913 phba->hbqs[hbqno].hbqPutIdx = 0;
2914 phba->hbqs[hbqno].local_hbqGetIdx = 0;
2915 phba->hbqs[hbqno].entry_count =
2916 lpfc_hbq_defs[hbqno]->entry_count;
2917 lpfc_config_hbq(phba, hbqno, lpfc_hbq_defs[hbqno],
2918 hbq_entry_index, pmb);
2919 hbq_entry_index += phba->hbqs[hbqno].entry_count;
2921 if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
2922 /* Adapter failed to init, mbxCmd <cmd> CFG_RING,
2923 mbxStatus <status>, ring <num> */
2925 lpfc_printf_log(phba, KERN_ERR,
2926 LOG_SLI | LOG_VPORT,
2927 "1805 Adapter failed to init. "
2928 "Data: x%x x%x x%x\n",
2930 pmbox->mbxStatus, hbqno);
2932 phba->link_state = LPFC_HBA_ERROR;
2933 mempool_free(pmb, phba->mbox_mem_pool);
2937 phba->hbq_count = hbq_count;
2939 mempool_free(pmb, phba->mbox_mem_pool);
2941 /* Initially populate or replenish the HBQs */
2942 for (hbqno = 0; hbqno < hbq_count; ++hbqno)
2943 lpfc_sli_hbqbuf_init_hbqs(phba, hbqno);
2948 * lpfc_do_config_port: Issue config port mailbox command.
2949 * @phba: Pointer to HBA context object.
2950 * @sli_mode: sli mode - 2/3
2952 * This function is called by the sli intialization code path
2953 * to issue config_port mailbox command. This function restarts the
2954 * HBA firmware and issues a config_port mailbox command to configure
2955 * the SLI interface in the sli mode specified by sli_mode
2956 * variable. The caller is not required to hold any locks.
2957 * The function returns 0 if successful, else returns negative error
2961 lpfc_do_config_port(struct lpfc_hba *phba, int sli_mode)
2964 uint32_t resetcount = 0, rc = 0, done = 0;
2966 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2968 phba->link_state = LPFC_HBA_ERROR;
2972 phba->sli_rev = sli_mode;
2973 while (resetcount < 2 && !done) {
2974 spin_lock_irq(&phba->hbalock);
2975 phba->sli.sli_flag |= LPFC_SLI_MBOX_ACTIVE;
2976 spin_unlock_irq(&phba->hbalock);
2977 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
2978 lpfc_sli_brdrestart(phba);
2980 rc = lpfc_sli_chipset_init(phba);
2984 spin_lock_irq(&phba->hbalock);
2985 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
2986 spin_unlock_irq(&phba->hbalock);
2989 /* Call pre CONFIG_PORT mailbox command initialization. A
2990 * value of 0 means the call was successful. Any other
2991 * nonzero value is a failure, but if ERESTART is returned,
2992 * the driver may reset the HBA and try again.
2994 rc = lpfc_config_port_prep(phba);
2995 if (rc == -ERESTART) {
2996 phba->link_state = LPFC_LINK_UNKNOWN;
3000 phba->link_state = LPFC_INIT_MBX_CMDS;
3001 lpfc_config_port(phba, pmb);
3002 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
3003 phba->sli3_options &= ~(LPFC_SLI3_NPIV_ENABLED |
3004 LPFC_SLI3_HBQ_ENABLED |
3005 LPFC_SLI3_CRP_ENABLED |
3006 LPFC_SLI3_INB_ENABLED);
3007 if (rc != MBX_SUCCESS) {
3008 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3009 "0442 Adapter failed to init, mbxCmd x%x "
3010 "CONFIG_PORT, mbxStatus x%x Data: x%x\n",
3011 pmb->mb.mbxCommand, pmb->mb.mbxStatus, 0);
3012 spin_lock_irq(&phba->hbalock);
3013 phba->sli.sli_flag &= ~LPFC_SLI2_ACTIVE;
3014 spin_unlock_irq(&phba->hbalock);
3021 goto do_prep_failed;
3023 if (pmb->mb.un.varCfgPort.sli_mode == 3) {
3024 if (!pmb->mb.un.varCfgPort.cMA) {
3026 goto do_prep_failed;
3028 if (phba->max_vpi && pmb->mb.un.varCfgPort.gmv) {
3029 phba->sli3_options |= LPFC_SLI3_NPIV_ENABLED;
3030 phba->max_vpi = pmb->mb.un.varCfgPort.max_vpi;
3033 if (pmb->mb.un.varCfgPort.gerbm)
3034 phba->sli3_options |= LPFC_SLI3_HBQ_ENABLED;
3035 if (pmb->mb.un.varCfgPort.gcrp)
3036 phba->sli3_options |= LPFC_SLI3_CRP_ENABLED;
3037 if (pmb->mb.un.varCfgPort.ginb) {
3038 phba->sli3_options |= LPFC_SLI3_INB_ENABLED;
3039 phba->port_gp = phba->mbox->us.s3_inb_pgp.port;
3040 phba->inb_ha_copy = &phba->mbox->us.s3_inb_pgp.ha_copy;
3041 phba->inb_counter = &phba->mbox->us.s3_inb_pgp.counter;
3042 phba->inb_last_counter =
3043 phba->mbox->us.s3_inb_pgp.counter;
3045 phba->port_gp = phba->mbox->us.s3_pgp.port;
3046 phba->inb_ha_copy = NULL;
3047 phba->inb_counter = NULL;
3050 phba->port_gp = phba->mbox->us.s2.port;
3051 phba->inb_ha_copy = NULL;
3052 phba->inb_counter = NULL;
3056 mempool_free(pmb, phba->mbox_mem_pool);
3062 * lpfc_sli_hba_setup: SLI intialization function.
3063 * @phba: Pointer to HBA context object.
3065 * This function is the main SLI intialization function. This function
3066 * is called by the HBA intialization code, HBA reset code and HBA
3067 * error attention handler code. Caller is not required to hold any
3068 * locks. This function issues config_port mailbox command to configure
3069 * the SLI, setup iocb rings and HBQ rings. In the end the function
3070 * calls the config_port_post function to issue init_link mailbox
3071 * command and to start the discovery. The function will return zero
3072 * if successful, else it will return negative error code.
3075 lpfc_sli_hba_setup(struct lpfc_hba *phba)
3080 switch (lpfc_sli_mode) {
3082 if (phba->cfg_enable_npiv) {
3083 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3084 "1824 NPIV enabled: Override lpfc_sli_mode "
3085 "parameter (%d) to auto (0).\n",
3095 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3096 "1819 Unrecognized lpfc_sli_mode "
3097 "parameter: %d.\n", lpfc_sli_mode);
3102 rc = lpfc_do_config_port(phba, mode);
3103 if (rc && lpfc_sli_mode == 3)
3104 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3105 "1820 Unable to select SLI-3. "
3106 "Not supported by adapter.\n");
3107 if (rc && mode != 2)
3108 rc = lpfc_do_config_port(phba, 2);
3110 goto lpfc_sli_hba_setup_error;
3112 if (phba->sli_rev == 3) {
3113 phba->iocb_cmd_size = SLI3_IOCB_CMD_SIZE;
3114 phba->iocb_rsp_size = SLI3_IOCB_RSP_SIZE;
3116 phba->iocb_cmd_size = SLI2_IOCB_CMD_SIZE;
3117 phba->iocb_rsp_size = SLI2_IOCB_RSP_SIZE;
3118 phba->sli3_options = 0;
3121 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3122 "0444 Firmware in SLI %x mode. Max_vpi %d\n",
3123 phba->sli_rev, phba->max_vpi);
3124 rc = lpfc_sli_ring_map(phba);
3127 goto lpfc_sli_hba_setup_error;
3131 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
3132 rc = lpfc_sli_hbq_setup(phba);
3134 goto lpfc_sli_hba_setup_error;
3137 phba->sli.sli_flag |= LPFC_PROCESS_LA;
3139 rc = lpfc_config_port_post(phba);
3141 goto lpfc_sli_hba_setup_error;
3145 lpfc_sli_hba_setup_error:
3146 phba->link_state = LPFC_HBA_ERROR;
3147 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3148 "0445 Firmware initialization failed\n");
3154 * lpfc_mbox_timeout: Timeout call back function for mbox timer.
3155 * @ptr: context object - pointer to hba structure.
3157 * This is the callback function for mailbox timer. The mailbox
3158 * timer is armed when a new mailbox command is issued and the timer
3159 * is deleted when the mailbox complete. The function is called by
3160 * the kernel timer code when a mailbox does not complete within
3161 * expected time. This function wakes up the worker thread to
3162 * process the mailbox timeout and returns. All the processing is
3163 * done by the worker thread function lpfc_mbox_timeout_handler.
3166 lpfc_mbox_timeout(unsigned long ptr)
3168 struct lpfc_hba *phba = (struct lpfc_hba *) ptr;
3169 unsigned long iflag;
3170 uint32_t tmo_posted;
3172 spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
3173 tmo_posted = phba->pport->work_port_events & WORKER_MBOX_TMO;
3175 phba->pport->work_port_events |= WORKER_MBOX_TMO;
3176 spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
3179 lpfc_worker_wake_up(phba);
3185 * lpfc_mbox_timeout_handler: Worker thread function to handle mailbox timeout.
3186 * @phba: Pointer to HBA context object.
3188 * This function is called from worker thread when a mailbox command times out.
3189 * The caller is not required to hold any locks. This function will reset the
3190 * HBA and recover all the pending commands.
3193 lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
3195 LPFC_MBOXQ_t *pmbox = phba->sli.mbox_active;
3196 MAILBOX_t *mb = &pmbox->mb;
3197 struct lpfc_sli *psli = &phba->sli;
3198 struct lpfc_sli_ring *pring;
3200 if (!(phba->pport->work_port_events & WORKER_MBOX_TMO)) {
3204 /* Mbox cmd <mbxCommand> timeout */
3205 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3206 "0310 Mailbox command x%x timeout Data: x%x x%x x%p\n",
3208 phba->pport->port_state,
3210 phba->sli.mbox_active);
3212 /* Setting state unknown so lpfc_sli_abort_iocb_ring
3213 * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
3214 * it to fail all oustanding SCSI IO.
3216 spin_lock_irq(&phba->pport->work_port_lock);
3217 phba->pport->work_port_events &= ~WORKER_MBOX_TMO;
3218 spin_unlock_irq(&phba->pport->work_port_lock);
3219 spin_lock_irq(&phba->hbalock);
3220 phba->link_state = LPFC_LINK_UNKNOWN;
3221 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
3222 spin_unlock_irq(&phba->hbalock);
3224 pring = &psli->ring[psli->fcp_ring];
3225 lpfc_sli_abort_iocb_ring(phba, pring);
3227 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3228 "0345 Resetting board due to mailbox timeout\n");
3230 * lpfc_offline calls lpfc_sli_hba_down which will clean up
3231 * on oustanding mailbox commands.
3233 /* If resets are disabled then set error state and return. */
3234 if (!phba->cfg_enable_hba_reset) {
3235 phba->link_state = LPFC_HBA_ERROR;
3238 lpfc_offline_prep(phba);
3240 lpfc_sli_brdrestart(phba);
3242 lpfc_unblock_mgmt_io(phba);
3247 * lpfc_sli_issue_mbox: Issue a mailbox command to firmware.
3248 * @phba: Pointer to HBA context object.
3249 * @pmbox: Pointer to mailbox object.
3250 * @flag: Flag indicating how the mailbox need to be processed.
3252 * This function is called by discovery code and HBA management code
3253 * to submit a mailbox command to firmware. This function gets the
3254 * hbalock to protect the data structures.
3255 * The mailbox command can be submitted in polling mode, in which case
3256 * this function will wait in a polling loop for the completion of the
3258 * If the mailbox is submitted in no_wait mode (not polling) the
3259 * function will submit the command and returns immediately without waiting
3260 * for the mailbox completion. The no_wait is supported only when HBA
3261 * is in SLI2/SLI3 mode - interrupts are enabled.
3262 * The SLI interface allows only one mailbox pending at a time. If the
3263 * mailbox is issued in polling mode and there is already a mailbox
3264 * pending, then the function will return an error. If the mailbox is issued
3265 * in NO_WAIT mode and there is a mailbox pending already, the function
3266 * will return MBX_BUSY after queuing the mailbox into mailbox queue.
3267 * The sli layer owns the mailbox object until the completion of mailbox
3268 * command if this function return MBX_BUSY or MBX_SUCCESS. For all other
3269 * return codes the caller owns the mailbox command after the return of
3273 lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3276 struct lpfc_sli *psli = &phba->sli;
3277 uint32_t status, evtctr;
3280 unsigned long timeout;
3281 unsigned long drvr_flag = 0;
3282 uint32_t word0, ldata;
3283 void __iomem *to_slim;
3284 int processing_queue = 0;
3286 spin_lock_irqsave(&phba->hbalock, drvr_flag);
3288 /* processing mbox queue from intr_handler */
3289 processing_queue = 1;
3290 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3291 pmbox = lpfc_mbox_get(phba);
3293 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3298 if (pmbox->mbox_cmpl && pmbox->mbox_cmpl != lpfc_sli_def_mbox_cmpl &&
3299 pmbox->mbox_cmpl != lpfc_sli_wake_mbox_wait) {
3301 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3302 lpfc_printf_log(phba, KERN_ERR,
3303 LOG_MBOX | LOG_VPORT,
3304 "1806 Mbox x%x failed. No vport\n",
3305 pmbox->mb.mbxCommand);
3307 goto out_not_finished;
3311 /* If the PCI channel is in offline state, do not post mbox. */
3312 if (unlikely(pci_channel_offline(phba->pcidev))) {
3313 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3314 goto out_not_finished;
3320 status = MBX_SUCCESS;
3322 if (phba->link_state == LPFC_HBA_ERROR) {
3323 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3325 /* Mbox command <mbxCommand> cannot issue */
3326 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3327 goto out_not_finished;
3330 if (mb->mbxCommand != MBX_KILL_BOARD && flag & MBX_NOWAIT &&
3331 !(readl(phba->HCregaddr) & HC_MBINT_ENA)) {
3332 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3333 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3334 goto out_not_finished;
3337 if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {
3338 /* Polling for a mbox command when another one is already active
3339 * is not allowed in SLI. Also, the driver must have established
3340 * SLI2 mode to queue and process multiple mbox commands.
3343 if (flag & MBX_POLL) {
3344 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3346 /* Mbox command <mbxCommand> cannot issue */
3347 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3348 goto out_not_finished;
3351 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE)) {
3352 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3353 /* Mbox command <mbxCommand> cannot issue */
3354 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3355 goto out_not_finished;
3358 /* Another mailbox command is still being processed, queue this
3359 * command to be processed later.
3361 lpfc_mbox_put(phba, pmbox);
3363 /* Mbox cmd issue - BUSY */
3364 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
3365 "(%d):0308 Mbox cmd issue - BUSY Data: "
3366 "x%x x%x x%x x%x\n",
3367 pmbox->vport ? pmbox->vport->vpi : 0xffffff,
3368 mb->mbxCommand, phba->pport->port_state,
3369 psli->sli_flag, flag);
3371 psli->slistat.mbox_busy++;
3372 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3375 lpfc_debugfs_disc_trc(pmbox->vport,
3376 LPFC_DISC_TRC_MBOX_VPORT,
3377 "MBOX Bsy vport: cmd:x%x mb:x%x x%x",
3378 (uint32_t)mb->mbxCommand,
3379 mb->un.varWords[0], mb->un.varWords[1]);
3382 lpfc_debugfs_disc_trc(phba->pport,
3384 "MBOX Bsy: cmd:x%x mb:x%x x%x",
3385 (uint32_t)mb->mbxCommand,
3386 mb->un.varWords[0], mb->un.varWords[1]);
3392 psli->sli_flag |= LPFC_SLI_MBOX_ACTIVE;
3394 /* If we are not polling, we MUST be in SLI2 mode */
3395 if (flag != MBX_POLL) {
3396 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE) &&
3397 (mb->mbxCommand != MBX_KILL_BOARD)) {
3398 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3399 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3400 /* Mbox command <mbxCommand> cannot issue */
3401 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3402 goto out_not_finished;
3404 /* timeout active mbox command */
3405 mod_timer(&psli->mbox_tmo, (jiffies +
3406 (HZ * lpfc_mbox_tmo_val(phba, mb->mbxCommand))));
3409 /* Mailbox cmd <cmd> issue */
3410 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
3411 "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
3413 pmbox->vport ? pmbox->vport->vpi : 0,
3414 mb->mbxCommand, phba->pport->port_state,
3415 psli->sli_flag, flag);
3417 if (mb->mbxCommand != MBX_HEARTBEAT) {
3419 lpfc_debugfs_disc_trc(pmbox->vport,
3420 LPFC_DISC_TRC_MBOX_VPORT,
3421 "MBOX Send vport: cmd:x%x mb:x%x x%x",
3422 (uint32_t)mb->mbxCommand,
3423 mb->un.varWords[0], mb->un.varWords[1]);
3426 lpfc_debugfs_disc_trc(phba->pport,
3428 "MBOX Send: cmd:x%x mb:x%x x%x",
3429 (uint32_t)mb->mbxCommand,
3430 mb->un.varWords[0], mb->un.varWords[1]);
3434 psli->slistat.mbox_cmd++;
3435 evtctr = psli->slistat.mbox_event;
3437 /* next set own bit for the adapter and copy over command word */
3438 mb->mbxOwner = OWN_CHIP;
3440 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3441 /* First copy command data to host SLIM area */
3442 lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE);
3444 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3445 /* copy command data into host mbox for cmpl */
3446 lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE);
3449 /* First copy mbox command data to HBA SLIM, skip past first
3451 to_slim = phba->MBslimaddr + sizeof (uint32_t);
3452 lpfc_memcpy_to_slim(to_slim, &mb->un.varWords[0],
3453 MAILBOX_CMD_SIZE - sizeof (uint32_t));
3455 /* Next copy over first word, with mbxOwner set */
3456 ldata = *((uint32_t *)mb);
3457 to_slim = phba->MBslimaddr;
3458 writel(ldata, to_slim);
3459 readl(to_slim); /* flush */
3461 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3462 /* switch over to host mailbox */
3463 psli->sli_flag |= LPFC_SLI2_ACTIVE;
3471 /* Set up reference to mailbox command */
3472 psli->mbox_active = pmbox;
3473 /* Interrupt board to do it */
3474 writel(CA_MBATT, phba->CAregaddr);
3475 readl(phba->CAregaddr); /* flush */
3476 /* Don't wait for it to finish, just return */
3480 /* Set up null reference to mailbox command */
3481 psli->mbox_active = NULL;
3482 /* Interrupt board to do it */
3483 writel(CA_MBATT, phba->CAregaddr);
3484 readl(phba->CAregaddr); /* flush */
3486 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3487 /* First read mbox status word */
3488 word0 = *((uint32_t *)phba->mbox);
3489 word0 = le32_to_cpu(word0);
3491 /* First read mbox status word */
3492 word0 = readl(phba->MBslimaddr);
3495 /* Read the HBA Host Attention Register */
3496 ha_copy = readl(phba->HAregaddr);
3497 timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba,
3501 /* Wait for command to complete */
3502 while (((word0 & OWN_CHIP) == OWN_CHIP) ||
3503 (!(ha_copy & HA_MBATT) &&
3504 (phba->link_state > LPFC_WARM_START))) {
3505 if (time_after(jiffies, timeout)) {
3506 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3507 spin_unlock_irqrestore(&phba->hbalock,
3509 goto out_not_finished;
3512 /* Check if we took a mbox interrupt while we were
3514 if (((word0 & OWN_CHIP) != OWN_CHIP)
3515 && (evtctr != psli->slistat.mbox_event))
3519 spin_unlock_irqrestore(&phba->hbalock,
3522 spin_lock_irqsave(&phba->hbalock, drvr_flag);
3525 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3526 /* First copy command data */
3527 word0 = *((uint32_t *)phba->mbox);
3528 word0 = le32_to_cpu(word0);
3529 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3532 /* Check real SLIM for any errors */
3533 slimword0 = readl(phba->MBslimaddr);
3534 slimmb = (MAILBOX_t *) & slimword0;
3535 if (((slimword0 & OWN_CHIP) != OWN_CHIP)
3536 && slimmb->mbxStatus) {
3543 /* First copy command data */
3544 word0 = readl(phba->MBslimaddr);
3546 /* Read the HBA Host Attention Register */
3547 ha_copy = readl(phba->HAregaddr);
3550 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3551 /* copy results back to user */
3552 lpfc_sli_pcimem_bcopy(phba->mbox, mb, MAILBOX_CMD_SIZE);
3554 /* First copy command data */
3555 lpfc_memcpy_from_slim(mb, phba->MBslimaddr,
3557 if ((mb->mbxCommand == MBX_DUMP_MEMORY) &&
3559 lpfc_memcpy_from_slim((void *)pmbox->context2,
3560 phba->MBslimaddr + DMP_RSP_OFFSET,
3561 mb->un.varDmp.word_cnt);
3565 writel(HA_MBATT, phba->HAregaddr);
3566 readl(phba->HAregaddr); /* flush */
3568 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3569 status = mb->mbxStatus;
3572 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3576 if (processing_queue) {
3577 pmbox->mb.mbxStatus = MBX_NOT_FINISHED;
3578 lpfc_mbox_cmpl_put(phba, pmbox);
3580 return MBX_NOT_FINISHED;
3584 * __lpfc_sli_ringtx_put: Add an iocb to the txq.
3585 * @phba: Pointer to HBA context object.
3586 * @pring: Pointer to driver SLI ring object.
3587 * @piocb: Pointer to address of newly added command iocb.
3589 * This function is called with hbalock held to add a command
3590 * iocb to the txq when SLI layer cannot submit the command iocb
3594 __lpfc_sli_ringtx_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3595 struct lpfc_iocbq *piocb)
3597 /* Insert the caller's iocb in the txq tail for later processing. */
3598 list_add_tail(&piocb->list, &pring->txq);
3603 * lpfc_sli_next_iocb: Get the next iocb in the txq.
3604 * @phba: Pointer to HBA context object.
3605 * @pring: Pointer to driver SLI ring object.
3606 * @piocb: Pointer to address of newly added command iocb.
3608 * This function is called with hbalock held before a new
3609 * iocb is submitted to the firmware. This function checks
3610 * txq to flush the iocbs in txq to Firmware before
3611 * submitting new iocbs to the Firmware.
3612 * If there are iocbs in the txq which need to be submitted
3613 * to firmware, lpfc_sli_next_iocb returns the first element
3614 * of the txq after dequeuing it from txq.
3615 * If there is no iocb in the txq then the function will return
3616 * *piocb and *piocb is set to NULL. Caller needs to check
3617 * *piocb to find if there are more commands in the txq.
3619 static struct lpfc_iocbq *
3620 lpfc_sli_next_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3621 struct lpfc_iocbq **piocb)
3623 struct lpfc_iocbq * nextiocb;
3625 nextiocb = lpfc_sli_ringtx_get(phba, pring);
3635 * __lpfc_sli_issue_iocb: Lockless version of lpfc_sli_issue_iocb.
3636 * @phba: Pointer to HBA context object.
3637 * @pring: Pointer to driver SLI ring object.
3638 * @piocb: Pointer to command iocb.
3639 * @flag: Flag indicating if this command can be put into txq.
3641 * __lpfc_sli_issue_iocb is used by other functions in the driver
3642 * to issue an iocb command to the HBA. If the PCI slot is recovering
3643 * from error state or if HBA is resetting or if LPFC_STOP_IOCB_EVENT
3644 * flag is turned on, the function returns IOCB_ERROR.
3645 * When the link is down, this function allows only iocbs for
3647 * This function finds next available slot in the command ring and
3648 * posts the command to the available slot and writes the port
3649 * attention register to request HBA start processing new iocb.
3650 * If there is no slot available in the ring and
3651 * flag & SLI_IOCB_RET_IOCB is set, the new iocb is added to the
3652 * txq, otherwise the function returns IOCB_BUSY.
3654 * This function is called with hbalock held.
3655 * The function will return success after it successfully submit the
3656 * iocb to firmware or after adding to the txq.
3659 __lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3660 struct lpfc_iocbq *piocb, uint32_t flag)
3662 struct lpfc_iocbq *nextiocb;
3665 if (piocb->iocb_cmpl && (!piocb->vport) &&
3666 (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
3667 (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN)) {
3668 lpfc_printf_log(phba, KERN_ERR,
3669 LOG_SLI | LOG_VPORT,
3670 "1807 IOCB x%x failed. No vport\n",
3671 piocb->iocb.ulpCommand);
3677 /* If the PCI channel is in offline state, do not post iocbs. */
3678 if (unlikely(pci_channel_offline(phba->pcidev)))
3682 * We should never get an IOCB if we are in a < LINK_DOWN state
3684 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
3688 * Check to see if we are blocking IOCB processing because of a
3689 * outstanding event.
3691 if (unlikely(pring->flag & LPFC_STOP_IOCB_EVENT))
3694 if (unlikely(phba->link_state == LPFC_LINK_DOWN)) {
3696 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
3697 * can be issued if the link is not up.
3699 switch (piocb->iocb.ulpCommand) {
3700 case CMD_QUE_RING_BUF_CN:
3701 case CMD_QUE_RING_BUF64_CN:
3703 * For IOCBs, like QUE_RING_BUF, that have no rsp ring
3704 * completion, iocb_cmpl MUST be 0.
3706 if (piocb->iocb_cmpl)
3707 piocb->iocb_cmpl = NULL;
3709 case CMD_CREATE_XRI_CR:
3710 case CMD_CLOSE_XRI_CN:
3711 case CMD_CLOSE_XRI_CX:
3718 * For FCP commands, we must be in a state where we can process link
3721 } else if (unlikely(pring->ringno == phba->sli.fcp_ring &&
3722 !(phba->sli.sli_flag & LPFC_PROCESS_LA))) {
3726 while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
3727 (nextiocb = lpfc_sli_next_iocb(phba, pring, &piocb)))
3728 lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
3731 lpfc_sli_update_ring(phba, pring);
3733 lpfc_sli_update_full_ring(phba, pring);
3736 return IOCB_SUCCESS;
3741 pring->stats.iocb_cmd_delay++;
3745 if (!(flag & SLI_IOCB_RET_IOCB)) {
3746 __lpfc_sli_ringtx_put(phba, pring, piocb);
3747 return IOCB_SUCCESS;
3755 * lpfc_sli_issue_iocb: Wrapper function for __lpfc_sli_issue_iocb.
3756 * @phba: Pointer to HBA context object.
3757 * @pring: Pointer to driver SLI ring object.
3758 * @piocb: Pointer to command iocb.
3759 * @flag: Flag indicating if this command can be put into txq.
3761 * lpfc_sli_issue_iocb is a wrapper around __lpfc_sli_issue_iocb
3762 * function. This function gets the hbalock and calls
3763 * __lpfc_sli_issue_iocb function and will return the error returned
3764 * by __lpfc_sli_issue_iocb function. This wrapper is used by
3765 * functions which do not hold hbalock.
3768 lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3769 struct lpfc_iocbq *piocb, uint32_t flag)
3771 unsigned long iflags;
3774 spin_lock_irqsave(&phba->hbalock, iflags);
3775 rc = __lpfc_sli_issue_iocb(phba, pring, piocb, flag);
3776 spin_unlock_irqrestore(&phba->hbalock, iflags);
3782 * lpfc_extra_ring_setup: Extra ring setup function.
3783 * @phba: Pointer to HBA context object.
3785 * This function is called while driver attaches with the
3786 * HBA to setup the extra ring. The extra ring is used
3787 * only when driver needs to support target mode functionality
3788 * or IP over FC functionalities.
3790 * This function is called with no lock held.
3793 lpfc_extra_ring_setup( struct lpfc_hba *phba)
3795 struct lpfc_sli *psli;
3796 struct lpfc_sli_ring *pring;
3800 /* Adjust cmd/rsp ring iocb entries more evenly */
3802 /* Take some away from the FCP ring */
3803 pring = &psli->ring[psli->fcp_ring];
3804 pring->numCiocb -= SLI2_IOCB_CMD_R1XTRA_ENTRIES;
3805 pring->numRiocb -= SLI2_IOCB_RSP_R1XTRA_ENTRIES;
3806 pring->numCiocb -= SLI2_IOCB_CMD_R3XTRA_ENTRIES;
3807 pring->numRiocb -= SLI2_IOCB_RSP_R3XTRA_ENTRIES;
3809 /* and give them to the extra ring */
3810 pring = &psli->ring[psli->extra_ring];
3812 pring->numCiocb += SLI2_IOCB_CMD_R1XTRA_ENTRIES;
3813 pring->numRiocb += SLI2_IOCB_RSP_R1XTRA_ENTRIES;
3814 pring->numCiocb += SLI2_IOCB_CMD_R3XTRA_ENTRIES;
3815 pring->numRiocb += SLI2_IOCB_RSP_R3XTRA_ENTRIES;
3817 /* Setup default profile for this ring */
3818 pring->iotag_max = 4096;
3819 pring->num_mask = 1;
3820 pring->prt[0].profile = 0; /* Mask 0 */
3821 pring->prt[0].rctl = phba->cfg_multi_ring_rctl;
3822 pring->prt[0].type = phba->cfg_multi_ring_type;
3823 pring->prt[0].lpfc_sli_rcv_unsol_event = NULL;
3828 * lpfc_sli_async_event_handler: ASYNC iocb handler function.
3829 * @phba: Pointer to HBA context object.
3830 * @pring: Pointer to driver SLI ring object.
3831 * @iocbq: Pointer to iocb object.
3833 * This function is called by the slow ring event handler
3834 * function when there is an ASYNC event iocb in the ring.
3835 * This function is called with no lock held.
3836 * Currently this function handles only temperature related
3837 * ASYNC events. The function decodes the temperature sensor
3838 * event message and posts events for the management applications.
3841 lpfc_sli_async_event_handler(struct lpfc_hba * phba,
3842 struct lpfc_sli_ring * pring, struct lpfc_iocbq * iocbq)
3847 struct temp_event temp_event_data;
3848 struct Scsi_Host *shost;
3850 icmd = &iocbq->iocb;
3851 evt_code = icmd->un.asyncstat.evt_code;
3852 temp = icmd->ulpContext;
3854 if ((evt_code != ASYNC_TEMP_WARN) &&
3855 (evt_code != ASYNC_TEMP_SAFE)) {
3856 lpfc_printf_log(phba,
3859 "0346 Ring %d handler: unexpected ASYNC_STATUS"
3862 icmd->un.asyncstat.evt_code);
3865 temp_event_data.data = (uint32_t)temp;
3866 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
3867 if (evt_code == ASYNC_TEMP_WARN) {
3868 temp_event_data.event_code = LPFC_THRESHOLD_TEMP;
3869 lpfc_printf_log(phba,
3872 "0347 Adapter is very hot, please take "
3873 "corrective action. temperature : %d Celsius\n",
3876 if (evt_code == ASYNC_TEMP_SAFE) {
3877 temp_event_data.event_code = LPFC_NORMAL_TEMP;
3878 lpfc_printf_log(phba,
3881 "0340 Adapter temperature is OK now. "
3882 "temperature : %d Celsius\n",
3886 /* Send temperature change event to applications */
3887 shost = lpfc_shost_from_vport(phba->pport);
3888 fc_host_post_vendor_event(shost, fc_get_event_number(),
3889 sizeof(temp_event_data), (char *) &temp_event_data,
3890 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
3896 * lpfc_sli_setup: SLI ring setup function.
3897 * @phba: Pointer to HBA context object.
3899 * lpfc_sli_setup sets up rings of the SLI interface with
3900 * number of iocbs per ring and iotags. This function is
3901 * called while driver attach to the HBA and before the
3902 * interrupts are enabled. So there is no need for locking.
3904 * This function always returns 0.
3907 lpfc_sli_setup(struct lpfc_hba *phba)
3909 int i, totiocbsize = 0;
3910 struct lpfc_sli *psli = &phba->sli;
3911 struct lpfc_sli_ring *pring;
3913 psli->num_rings = MAX_CONFIGURED_RINGS;
3915 psli->fcp_ring = LPFC_FCP_RING;
3916 psli->next_ring = LPFC_FCP_NEXT_RING;
3917 psli->extra_ring = LPFC_EXTRA_RING;
3919 psli->iocbq_lookup = NULL;
3920 psli->iocbq_lookup_len = 0;
3921 psli->last_iotag = 0;
3923 for (i = 0; i < psli->num_rings; i++) {
3924 pring = &psli->ring[i];
3926 case LPFC_FCP_RING: /* ring 0 - FCP */
3927 /* numCiocb and numRiocb are used in config_port */
3928 pring->numCiocb = SLI2_IOCB_CMD_R0_ENTRIES;
3929 pring->numRiocb = SLI2_IOCB_RSP_R0_ENTRIES;
3930 pring->numCiocb += SLI2_IOCB_CMD_R1XTRA_ENTRIES;
3931 pring->numRiocb += SLI2_IOCB_RSP_R1XTRA_ENTRIES;
3932 pring->numCiocb += SLI2_IOCB_CMD_R3XTRA_ENTRIES;
3933 pring->numRiocb += SLI2_IOCB_RSP_R3XTRA_ENTRIES;
3934 pring->sizeCiocb = (phba->sli_rev == 3) ?
3935 SLI3_IOCB_CMD_SIZE :
3937 pring->sizeRiocb = (phba->sli_rev == 3) ?
3938 SLI3_IOCB_RSP_SIZE :
3940 pring->iotag_ctr = 0;
3942 (phba->cfg_hba_queue_depth * 2);
3943 pring->fast_iotag = pring->iotag_max;
3944 pring->num_mask = 0;
3946 case LPFC_EXTRA_RING: /* ring 1 - EXTRA */
3947 /* numCiocb and numRiocb are used in config_port */
3948 pring->numCiocb = SLI2_IOCB_CMD_R1_ENTRIES;
3949 pring->numRiocb = SLI2_IOCB_RSP_R1_ENTRIES;
3950 pring->sizeCiocb = (phba->sli_rev == 3) ?
3951 SLI3_IOCB_CMD_SIZE :
3953 pring->sizeRiocb = (phba->sli_rev == 3) ?
3954 SLI3_IOCB_RSP_SIZE :
3956 pring->iotag_max = phba->cfg_hba_queue_depth;
3957 pring->num_mask = 0;
3959 case LPFC_ELS_RING: /* ring 2 - ELS / CT */
3960 /* numCiocb and numRiocb are used in config_port */
3961 pring->numCiocb = SLI2_IOCB_CMD_R2_ENTRIES;
3962 pring->numRiocb = SLI2_IOCB_RSP_R2_ENTRIES;
3963 pring->sizeCiocb = (phba->sli_rev == 3) ?
3964 SLI3_IOCB_CMD_SIZE :
3966 pring->sizeRiocb = (phba->sli_rev == 3) ?
3967 SLI3_IOCB_RSP_SIZE :
3969 pring->fast_iotag = 0;
3970 pring->iotag_ctr = 0;
3971 pring->iotag_max = 4096;
3972 pring->lpfc_sli_rcv_async_status =
3973 lpfc_sli_async_event_handler;
3974 pring->num_mask = 4;
3975 pring->prt[0].profile = 0; /* Mask 0 */
3976 pring->prt[0].rctl = FC_ELS_REQ;
3977 pring->prt[0].type = FC_ELS_DATA;
3978 pring->prt[0].lpfc_sli_rcv_unsol_event =
3979 lpfc_els_unsol_event;
3980 pring->prt[1].profile = 0; /* Mask 1 */
3981 pring->prt[1].rctl = FC_ELS_RSP;
3982 pring->prt[1].type = FC_ELS_DATA;
3983 pring->prt[1].lpfc_sli_rcv_unsol_event =
3984 lpfc_els_unsol_event;
3985 pring->prt[2].profile = 0; /* Mask 2 */
3986 /* NameServer Inquiry */
3987 pring->prt[2].rctl = FC_UNSOL_CTL;
3989 pring->prt[2].type = FC_COMMON_TRANSPORT_ULP;
3990 pring->prt[2].lpfc_sli_rcv_unsol_event =
3991 lpfc_ct_unsol_event;
3992 pring->prt[3].profile = 0; /* Mask 3 */
3993 /* NameServer response */
3994 pring->prt[3].rctl = FC_SOL_CTL;
3996 pring->prt[3].type = FC_COMMON_TRANSPORT_ULP;
3997 pring->prt[3].lpfc_sli_rcv_unsol_event =
3998 lpfc_ct_unsol_event;
4001 totiocbsize += (pring->numCiocb * pring->sizeCiocb) +
4002 (pring->numRiocb * pring->sizeRiocb);
4004 if (totiocbsize > MAX_SLIM_IOCB_SIZE) {
4005 /* Too many cmd / rsp ring entries in SLI2 SLIM */
4006 printk(KERN_ERR "%d:0462 Too many cmd / rsp ring entries in "
4007 "SLI2 SLIM Data: x%x x%lx\n",
4008 phba->brd_no, totiocbsize,
4009 (unsigned long) MAX_SLIM_IOCB_SIZE);
4011 if (phba->cfg_multi_ring_support == 2)
4012 lpfc_extra_ring_setup(phba);
4018 * lpfc_sli_queue_setup: Queue initialization function.
4019 * @phba: Pointer to HBA context object.
4021 * lpfc_sli_queue_setup sets up mailbox queues and iocb queues for each
4022 * ring. This function also initializes ring indices of each ring.
4023 * This function is called during the initialization of the SLI
4024 * interface of an HBA.
4025 * This function is called with no lock held and always returns
4029 lpfc_sli_queue_setup(struct lpfc_hba *phba)
4031 struct lpfc_sli *psli;
4032 struct lpfc_sli_ring *pring;
4036 spin_lock_irq(&phba->hbalock);
4037 INIT_LIST_HEAD(&psli->mboxq);
4038 INIT_LIST_HEAD(&psli->mboxq_cmpl);
4039 /* Initialize list headers for txq and txcmplq as double linked lists */
4040 for (i = 0; i < psli->num_rings; i++) {
4041 pring = &psli->ring[i];
4043 pring->next_cmdidx = 0;
4044 pring->local_getidx = 0;
4046 INIT_LIST_HEAD(&pring->txq);
4047 INIT_LIST_HEAD(&pring->txcmplq);
4048 INIT_LIST_HEAD(&pring->iocb_continueq);
4049 INIT_LIST_HEAD(&pring->iocb_continue_saveq);
4050 INIT_LIST_HEAD(&pring->postbufq);
4052 spin_unlock_irq(&phba->hbalock);
4057 * lpfc_sli_host_down: Vport cleanup function.
4058 * @vport: Pointer to virtual port object.
4060 * lpfc_sli_host_down is called to clean up the resources
4061 * associated with a vport before destroying virtual
4062 * port data structures.
4063 * This function does following operations:
4064 * - Free discovery resources associated with this virtual
4066 * - Free iocbs associated with this virtual port in
4068 * - Send abort for all iocb commands associated with this
4071 * This function is called with no lock held and always returns 1.
4074 lpfc_sli_host_down(struct lpfc_vport *vport)
4076 LIST_HEAD(completions);
4077 struct lpfc_hba *phba = vport->phba;
4078 struct lpfc_sli *psli = &phba->sli;
4079 struct lpfc_sli_ring *pring;
4080 struct lpfc_iocbq *iocb, *next_iocb;
4082 unsigned long flags = 0;
4083 uint16_t prev_pring_flag;
4085 lpfc_cleanup_discovery_resources(vport);
4087 spin_lock_irqsave(&phba->hbalock, flags);
4088 for (i = 0; i < psli->num_rings; i++) {
4089 pring = &psli->ring[i];
4090 prev_pring_flag = pring->flag;
4091 /* Only slow rings */
4092 if (pring->ringno == LPFC_ELS_RING) {
4093 pring->flag |= LPFC_DEFERRED_RING_EVENT;
4094 /* Set the lpfc data pending flag */
4095 set_bit(LPFC_DATA_READY, &phba->data_flags);
4098 * Error everything on the txq since these iocbs have not been
4099 * given to the FW yet.
4101 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
4102 if (iocb->vport != vport)
4104 list_move_tail(&iocb->list, &completions);
4108 /* Next issue ABTS for everything on the txcmplq */
4109 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq,
4111 if (iocb->vport != vport)
4113 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
4116 pring->flag = prev_pring_flag;
4119 spin_unlock_irqrestore(&phba->hbalock, flags);
4121 while (!list_empty(&completions)) {
4122 list_remove_head(&completions, iocb, struct lpfc_iocbq, list);
4124 if (!iocb->iocb_cmpl)
4125 lpfc_sli_release_iocbq(phba, iocb);
4127 iocb->iocb.ulpStatus = IOSTAT_LOCAL_REJECT;
4128 iocb->iocb.un.ulpWord[4] = IOERR_SLI_DOWN;
4129 (iocb->iocb_cmpl) (phba, iocb, iocb);
4136 * lpfc_sli_hba_down: Resource cleanup function for the HBA.
4137 * @phba: Pointer to HBA context object.
4139 * This function cleans up all iocb, buffers, mailbox commands
4140 * while shutting down the HBA. This function is called with no
4141 * lock held and always returns 1.
4142 * This function does the following to cleanup driver resources:
4143 * - Free discovery resources for each virtual port
4144 * - Cleanup any pending fabric iocbs
4145 * - Iterate through the iocb txq and free each entry
4147 * - Free up any buffer posted to the HBA
4148 * - Free mailbox commands in the mailbox queue.
4151 lpfc_sli_hba_down(struct lpfc_hba *phba)
4153 LIST_HEAD(completions);
4154 struct lpfc_sli *psli = &phba->sli;
4155 struct lpfc_sli_ring *pring;
4156 struct lpfc_dmabuf *buf_ptr;
4158 struct lpfc_iocbq *iocb;
4161 unsigned long flags = 0;
4163 lpfc_hba_down_prep(phba);
4165 lpfc_fabric_abort_hba(phba);
4167 spin_lock_irqsave(&phba->hbalock, flags);
4168 for (i = 0; i < psli->num_rings; i++) {
4169 pring = &psli->ring[i];
4170 /* Only slow rings */
4171 if (pring->ringno == LPFC_ELS_RING) {
4172 pring->flag |= LPFC_DEFERRED_RING_EVENT;
4173 /* Set the lpfc data pending flag */
4174 set_bit(LPFC_DATA_READY, &phba->data_flags);
4178 * Error everything on the txq since these iocbs have not been
4179 * given to the FW yet.
4181 list_splice_init(&pring->txq, &completions);
4185 spin_unlock_irqrestore(&phba->hbalock, flags);
4187 while (!list_empty(&completions)) {
4188 list_remove_head(&completions, iocb, struct lpfc_iocbq, list);
4191 if (!iocb->iocb_cmpl)
4192 lpfc_sli_release_iocbq(phba, iocb);
4194 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4195 cmd->un.ulpWord[4] = IOERR_SLI_DOWN;
4196 (iocb->iocb_cmpl) (phba, iocb, iocb);
4200 spin_lock_irqsave(&phba->hbalock, flags);
4201 list_splice_init(&phba->elsbuf, &completions);
4202 phba->elsbuf_cnt = 0;
4203 phba->elsbuf_prev_cnt = 0;
4204 spin_unlock_irqrestore(&phba->hbalock, flags);
4206 while (!list_empty(&completions)) {
4207 list_remove_head(&completions, buf_ptr,
4208 struct lpfc_dmabuf, list);
4209 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
4213 /* Return any active mbox cmds */
4214 del_timer_sync(&psli->mbox_tmo);
4215 spin_lock_irqsave(&phba->hbalock, flags);
4217 spin_lock(&phba->pport->work_port_lock);
4218 phba->pport->work_port_events &= ~WORKER_MBOX_TMO;
4219 spin_unlock(&phba->pport->work_port_lock);
4221 /* Return any pending or completed mbox cmds */
4222 list_splice_init(&phba->sli.mboxq, &completions);
4223 if (psli->mbox_active) {
4224 list_add_tail(&psli->mbox_active->list, &completions);
4225 psli->mbox_active = NULL;
4226 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
4228 list_splice_init(&phba->sli.mboxq_cmpl, &completions);
4229 spin_unlock_irqrestore(&phba->hbalock, flags);
4231 while (!list_empty(&completions)) {
4232 list_remove_head(&completions, pmb, LPFC_MBOXQ_t, list);
4233 pmb->mb.mbxStatus = MBX_NOT_FINISHED;
4235 pmb->mbox_cmpl(phba,pmb);
4241 * lpfc_sli_pcimem_bcopy: SLI memory copy function.
4242 * @srcp: Source memory pointer.
4243 * @destp: Destination memory pointer.
4244 * @cnt: Number of words required to be copied.
4246 * This function is used for copying data between driver memory
4247 * and the SLI memory. This function also changes the endianness
4248 * of each word if native endianness is different from SLI
4249 * endianness. This function can be called with or without
4253 lpfc_sli_pcimem_bcopy(void *srcp, void *destp, uint32_t cnt)
4255 uint32_t *src = srcp;
4256 uint32_t *dest = destp;
4260 for (i = 0; i < (int)cnt; i += sizeof (uint32_t)) {
4262 ldata = le32_to_cpu(ldata);
4271 * lpfc_sli_ringpostbuf_put: Function to add a buffer to postbufq.
4272 * @phba: Pointer to HBA context object.
4273 * @pring: Pointer to driver SLI ring object.
4274 * @mp: Pointer to driver buffer object.
4276 * This function is called with no lock held.
4277 * It always return zero after adding the buffer to the postbufq
4281 lpfc_sli_ringpostbuf_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4282 struct lpfc_dmabuf *mp)
4284 /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
4286 spin_lock_irq(&phba->hbalock);
4287 list_add_tail(&mp->list, &pring->postbufq);
4288 pring->postbufq_cnt++;
4289 spin_unlock_irq(&phba->hbalock);
4294 * lpfc_sli_get_buffer_tag: Tag allocation function for a buffer posted
4295 * using CMD_QUE_XRI64_CX iocb.
4296 * @phba: Pointer to HBA context object.
4298 * When HBQ is enabled, buffers are searched based on tags. This function
4299 * allocates a tag for buffer posted using CMD_QUE_XRI64_CX iocb. The
4300 * tag is bit wise or-ed with QUE_BUFTAG_BIT to make sure that the tag
4301 * does not conflict with tags of buffer posted for unsolicited events.
4302 * The function returns the allocated tag. The function is called with
4306 lpfc_sli_get_buffer_tag(struct lpfc_hba *phba)
4308 spin_lock_irq(&phba->hbalock);
4309 phba->buffer_tag_count++;
4311 * Always set the QUE_BUFTAG_BIT to distiguish between
4312 * a tag assigned by HBQ.
4314 phba->buffer_tag_count |= QUE_BUFTAG_BIT;
4315 spin_unlock_irq(&phba->hbalock);
4316 return phba->buffer_tag_count;
4320 * lpfc_sli_ring_taggedbuf_get: Search HBQ buffer associated with
4321 * posted using CMD_QUE_XRI64_CX iocb.
4322 * @phba: Pointer to HBA context object.
4323 * @pring: Pointer to driver SLI ring object.
4326 * Buffers posted using CMD_QUE_XRI64_CX iocb are in pring->postbufq
4327 * list. After HBA DMA data to these buffers, CMD_IOCB_RET_XRI64_CX
4328 * iocb is posted to the response ring with the tag of the buffer.
4329 * This function searches the pring->postbufq list using the tag
4330 * to find buffer associated with CMD_IOCB_RET_XRI64_CX
4331 * iocb. If the buffer is found then lpfc_dmabuf object of the
4332 * buffer is returned to the caller else NULL is returned.
4333 * This function is called with no lock held.
4335 struct lpfc_dmabuf *
4336 lpfc_sli_ring_taggedbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4339 struct lpfc_dmabuf *mp, *next_mp;
4340 struct list_head *slp = &pring->postbufq;
4342 /* Search postbufq, from the begining, looking for a match on tag */
4343 spin_lock_irq(&phba->hbalock);
4344 list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
4345 if (mp->buffer_tag == tag) {
4346 list_del_init(&mp->list);
4347 pring->postbufq_cnt--;
4348 spin_unlock_irq(&phba->hbalock);
4353 spin_unlock_irq(&phba->hbalock);
4354 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4355 "0402 Cannot find virtual addr for buffer tag on "
4356 "ring %d Data x%lx x%p x%p x%x\n",
4357 pring->ringno, (unsigned long) tag,
4358 slp->next, slp->prev, pring->postbufq_cnt);
4364 * lpfc_sli_ringpostbuf_get: SLI2 buffer search function for
4365 * unsolicited ct and els events.
4366 * @phba: Pointer to HBA context object.
4367 * @pring: Pointer to driver SLI ring object.
4368 * @phys: DMA address of the buffer.
4370 * This function searches the buffer list using the dma_address
4371 * of unsolicited event to find the driver's lpfc_dmabuf object
4372 * corresponding to the dma_address. The function returns the
4373 * lpfc_dmabuf object if a buffer is found else it returns NULL.
4374 * This function is called by the ct and els unsolicited event
4375 * handlers to get the buffer associated with the unsolicited
4378 * This function is called with no lock held.
4380 struct lpfc_dmabuf *
4381 lpfc_sli_ringpostbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4384 struct lpfc_dmabuf *mp, *next_mp;
4385 struct list_head *slp = &pring->postbufq;
4387 /* Search postbufq, from the begining, looking for a match on phys */
4388 spin_lock_irq(&phba->hbalock);
4389 list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
4390 if (mp->phys == phys) {
4391 list_del_init(&mp->list);
4392 pring->postbufq_cnt--;
4393 spin_unlock_irq(&phba->hbalock);
4398 spin_unlock_irq(&phba->hbalock);
4399 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4400 "0410 Cannot find virtual addr for mapped buf on "
4401 "ring %d Data x%llx x%p x%p x%x\n",
4402 pring->ringno, (unsigned long long)phys,
4403 slp->next, slp->prev, pring->postbufq_cnt);
4408 * lpfc_sli_abort_els_cmpl: Completion handler for the els abort iocbs.
4409 * @phba: Pointer to HBA context object.
4410 * @cmdiocb: Pointer to driver command iocb object.
4411 * @rspiocb: Pointer to driver response iocb object.
4413 * This function is the completion handler for the abort iocbs for
4414 * ELS commands. This function is called from the ELS ring event
4415 * handler with no lock held. This function frees memory resources
4416 * associated with the abort iocb.
4419 lpfc_sli_abort_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4420 struct lpfc_iocbq *rspiocb)
4422 IOCB_t *irsp = &rspiocb->iocb;
4423 uint16_t abort_iotag, abort_context;
4424 struct lpfc_iocbq *abort_iocb;
4425 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4429 if (irsp->ulpStatus) {
4430 abort_context = cmdiocb->iocb.un.acxri.abortContextTag;
4431 abort_iotag = cmdiocb->iocb.un.acxri.abortIoTag;
4433 spin_lock_irq(&phba->hbalock);
4434 if (abort_iotag != 0 && abort_iotag <= phba->sli.last_iotag)
4435 abort_iocb = phba->sli.iocbq_lookup[abort_iotag];
4437 lpfc_printf_log(phba, KERN_INFO, LOG_ELS | LOG_SLI,
4438 "0327 Cannot abort els iocb %p "
4439 "with tag %x context %x, abort status %x, "
4441 abort_iocb, abort_iotag, abort_context,
4442 irsp->ulpStatus, irsp->un.ulpWord[4]);
4445 * If the iocb is not found in Firmware queue the iocb
4446 * might have completed already. Do not free it again.
4448 if (irsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
4449 spin_unlock_irq(&phba->hbalock);
4450 lpfc_sli_release_iocbq(phba, cmdiocb);
4454 * make sure we have the right iocbq before taking it
4455 * off the txcmplq and try to call completion routine.
4458 abort_iocb->iocb.ulpContext != abort_context ||
4459 (abort_iocb->iocb_flag & LPFC_DRIVER_ABORTED) == 0)
4460 spin_unlock_irq(&phba->hbalock);
4462 list_del_init(&abort_iocb->list);
4463 pring->txcmplq_cnt--;
4464 spin_unlock_irq(&phba->hbalock);
4466 /* Firmware could still be in progress of DMAing
4467 * payload, so don't free data buffer till after
4470 abort_iocb->iocb_flag |= LPFC_DELAY_MEM_FREE;
4472 abort_iocb->iocb_flag &= ~LPFC_DRIVER_ABORTED;
4473 abort_iocb->iocb.ulpStatus = IOSTAT_LOCAL_REJECT;
4474 abort_iocb->iocb.un.ulpWord[4] = IOERR_SLI_ABORTED;
4475 (abort_iocb->iocb_cmpl)(phba, abort_iocb, abort_iocb);
4479 lpfc_sli_release_iocbq(phba, cmdiocb);
4484 * lpfc_ignore_els_cmpl: Completion handler for aborted ELS command.
4485 * @phba: Pointer to HBA context object.
4486 * @cmdiocb: Pointer to driver command iocb object.
4487 * @rspiocb: Pointer to driver response iocb object.
4489 * The function is called from SLI ring event handler with no
4490 * lock held. This function is the completion handler for ELS commands
4491 * which are aborted. The function frees memory resources used for
4492 * the aborted ELS commands.
4495 lpfc_ignore_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4496 struct lpfc_iocbq *rspiocb)
4498 IOCB_t *irsp = &rspiocb->iocb;
4500 /* ELS cmd tag <ulpIoTag> completes */
4501 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
4502 "0139 Ignoring ELS cmd tag x%x completion Data: "
4504 irsp->ulpIoTag, irsp->ulpStatus,
4505 irsp->un.ulpWord[4], irsp->ulpTimeout);
4506 if (cmdiocb->iocb.ulpCommand == CMD_GEN_REQUEST64_CR)
4507 lpfc_ct_free_iocb(phba, cmdiocb);
4509 lpfc_els_free_iocb(phba, cmdiocb);
4514 * lpfc_sli_issue_abort_iotag: Abort function for a command iocb.
4515 * @phba: Pointer to HBA context object.
4516 * @pring: Pointer to driver SLI ring object.
4517 * @cmdiocb: Pointer to driver command iocb object.
4519 * This function issues an abort iocb for the provided command
4520 * iocb. This function is called with hbalock held.
4521 * The function returns 0 when it fails due to memory allocation
4522 * failure or when the command iocb is an abort request.
4525 lpfc_sli_issue_abort_iotag(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4526 struct lpfc_iocbq *cmdiocb)
4528 struct lpfc_vport *vport = cmdiocb->vport;
4529 struct lpfc_iocbq *abtsiocbp;
4530 IOCB_t *icmd = NULL;
4531 IOCB_t *iabt = NULL;
4532 int retval = IOCB_ERROR;
4535 * There are certain command types we don't want to abort. And we
4536 * don't want to abort commands that are already in the process of
4539 icmd = &cmdiocb->iocb;
4540 if (icmd->ulpCommand == CMD_ABORT_XRI_CN ||
4541 icmd->ulpCommand == CMD_CLOSE_XRI_CN ||
4542 (cmdiocb->iocb_flag & LPFC_DRIVER_ABORTED) != 0)
4545 /* If we're unloading, don't abort iocb on the ELS ring, but change the
4546 * callback so that nothing happens when it finishes.
4548 if ((vport->load_flag & FC_UNLOADING) &&
4549 (pring->ringno == LPFC_ELS_RING)) {
4550 if (cmdiocb->iocb_flag & LPFC_IO_FABRIC)
4551 cmdiocb->fabric_iocb_cmpl = lpfc_ignore_els_cmpl;
4553 cmdiocb->iocb_cmpl = lpfc_ignore_els_cmpl;
4554 goto abort_iotag_exit;
4557 /* issue ABTS for this IOCB based on iotag */
4558 abtsiocbp = __lpfc_sli_get_iocbq(phba);
4559 if (abtsiocbp == NULL)
4562 /* This signals the response to set the correct status
4563 * before calling the completion handler.
4565 cmdiocb->iocb_flag |= LPFC_DRIVER_ABORTED;
4567 iabt = &abtsiocbp->iocb;
4568 iabt->un.acxri.abortType = ABORT_TYPE_ABTS;
4569 iabt->un.acxri.abortContextTag = icmd->ulpContext;
4570 iabt->un.acxri.abortIoTag = icmd->ulpIoTag;
4572 iabt->ulpClass = icmd->ulpClass;
4574 if (phba->link_state >= LPFC_LINK_UP)
4575 iabt->ulpCommand = CMD_ABORT_XRI_CN;
4577 iabt->ulpCommand = CMD_CLOSE_XRI_CN;
4579 abtsiocbp->iocb_cmpl = lpfc_sli_abort_els_cmpl;
4581 lpfc_printf_vlog(vport, KERN_INFO, LOG_SLI,
4582 "0339 Abort xri x%x, original iotag x%x, "
4583 "abort cmd iotag x%x\n",
4584 iabt->un.acxri.abortContextTag,
4585 iabt->un.acxri.abortIoTag, abtsiocbp->iotag);
4586 retval = __lpfc_sli_issue_iocb(phba, pring, abtsiocbp, 0);
4589 __lpfc_sli_release_iocbq(phba, abtsiocbp);
4592 * Caller to this routine should check for IOCB_ERROR
4593 * and handle it properly. This routine no longer removes
4594 * iocb off txcmplq and call compl in case of IOCB_ERROR.
4600 * lpfc_sli_validate_fcp_iocb: Filtering function, used to find commands
4601 * associated with a vport/SCSI target/lun.
4602 * @iocbq: Pointer to driver iocb object.
4603 * @vport: Pointer to driver virtual port object.
4604 * @tgt_id: SCSI ID of the target.
4605 * @lun_id: LUN ID of the scsi device.
4606 * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST
4608 * This function acts as iocb filter for functions which abort or count
4609 * all FCP iocbs pending on a lun/SCSI target/SCSI host. It will return
4610 * 0 if the filtering criteria is met for the given iocb and will return
4611 * 1 if the filtering criteria is not met.
4612 * If ctx_cmd == LPFC_CTX_LUN, the function returns 0 only if the
4613 * given iocb is for the SCSI device specified by vport, tgt_id and
4615 * If ctx_cmd == LPFC_CTX_TGT, the function returns 0 only if the
4616 * given iocb is for the SCSI target specified by vport and tgt_id
4618 * If ctx_cmd == LPFC_CTX_HOST, the function returns 0 only if the
4619 * given iocb is for the SCSI host associated with the given vport.
4620 * This function is called with no locks held.
4623 lpfc_sli_validate_fcp_iocb(struct lpfc_iocbq *iocbq, struct lpfc_vport *vport,
4624 uint16_t tgt_id, uint64_t lun_id,
4625 lpfc_ctx_cmd ctx_cmd)
4627 struct lpfc_scsi_buf *lpfc_cmd;
4630 if (!(iocbq->iocb_flag & LPFC_IO_FCP))
4633 if (iocbq->vport != vport)
4636 lpfc_cmd = container_of(iocbq, struct lpfc_scsi_buf, cur_iocbq);
4638 if (lpfc_cmd->pCmd == NULL)
4643 if ((lpfc_cmd->rdata->pnode) &&
4644 (lpfc_cmd->rdata->pnode->nlp_sid == tgt_id) &&
4645 (scsilun_to_int(&lpfc_cmd->fcp_cmnd->fcp_lun) == lun_id))
4649 if ((lpfc_cmd->rdata->pnode) &&
4650 (lpfc_cmd->rdata->pnode->nlp_sid == tgt_id))
4657 printk(KERN_ERR "%s: Unknown context cmd type, value %d\n",
4666 * lpfc_sli_sum_iocb: Function to count the number of FCP iocbs pending.
4667 * @vport: Pointer to virtual port.
4668 * @tgt_id: SCSI ID of the target.
4669 * @lun_id: LUN ID of the scsi device.
4670 * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
4672 * This function returns number of FCP commands pending for the vport.
4673 * When ctx_cmd == LPFC_CTX_LUN, the function returns number of FCP
4674 * commands pending on the vport associated with SCSI device specified
4675 * by tgt_id and lun_id parameters.
4676 * When ctx_cmd == LPFC_CTX_TGT, the function returns number of FCP
4677 * commands pending on the vport associated with SCSI target specified
4678 * by tgt_id parameter.
4679 * When ctx_cmd == LPFC_CTX_HOST, the function returns number of FCP
4680 * commands pending on the vport.
4681 * This function returns the number of iocbs which satisfy the filter.
4682 * This function is called without any lock held.
4685 lpfc_sli_sum_iocb(struct lpfc_vport *vport, uint16_t tgt_id, uint64_t lun_id,
4686 lpfc_ctx_cmd ctx_cmd)
4688 struct lpfc_hba *phba = vport->phba;
4689 struct lpfc_iocbq *iocbq;
4692 for (i = 1, sum = 0; i <= phba->sli.last_iotag; i++) {
4693 iocbq = phba->sli.iocbq_lookup[i];
4695 if (lpfc_sli_validate_fcp_iocb (iocbq, vport, tgt_id, lun_id,
4704 * lpfc_sli_abort_fcp_cmpl: Completion handler function for an aborted
4706 * @phba: Pointer to HBA context object
4707 * @cmdiocb: Pointer to command iocb object.
4708 * @rspiocb: Pointer to response iocb object.
4710 * This function is called when an aborted FCP iocb completes. This
4711 * function is called by the ring event handler with no lock held.
4712 * This function frees the iocb.
4715 lpfc_sli_abort_fcp_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4716 struct lpfc_iocbq *rspiocb)
4718 lpfc_sli_release_iocbq(phba, cmdiocb);
4723 * lpfc_sli_abort_iocb: This function issue abort for all SCSI commands
4724 * pending on a SCSI host(vport)/target/lun.
4725 * @vport: Pointer to virtual port.
4726 * @pring: Pointer to driver SLI ring object.
4727 * @tgt_id: SCSI ID of the target.
4728 * @lun_id: LUN ID of the scsi device.
4729 * @abort_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
4731 * This function sends an abort command for every SCSI command
4732 * associated with the given virtual port pending on the ring
4733 * filtered by lpfc_sli_validate_fcp_iocb function.
4734 * When abort_cmd == LPFC_CTX_LUN, the function sends abort only to the
4735 * FCP iocbs associated with lun specified by tgt_id and lun_id
4737 * When abort_cmd == LPFC_CTX_TGT, the function sends abort only to the
4738 * FCP iocbs associated with SCSI target specified by tgt_id parameter.
4739 * When abort_cmd == LPFC_CTX_HOST, the function sends abort to all
4740 * FCP iocbs associated with virtual port.
4741 * This function returns number of iocbs it failed to abort.
4742 * This function is called with no locks held.
4745 lpfc_sli_abort_iocb(struct lpfc_vport *vport, struct lpfc_sli_ring *pring,
4746 uint16_t tgt_id, uint64_t lun_id, lpfc_ctx_cmd abort_cmd)
4748 struct lpfc_hba *phba = vport->phba;
4749 struct lpfc_iocbq *iocbq;
4750 struct lpfc_iocbq *abtsiocb;
4752 int errcnt = 0, ret_val = 0;
4755 for (i = 1; i <= phba->sli.last_iotag; i++) {
4756 iocbq = phba->sli.iocbq_lookup[i];
4758 if (lpfc_sli_validate_fcp_iocb(iocbq, vport, tgt_id, lun_id,
4762 /* issue ABTS for this IOCB based on iotag */
4763 abtsiocb = lpfc_sli_get_iocbq(phba);
4764 if (abtsiocb == NULL) {
4770 abtsiocb->iocb.un.acxri.abortType = ABORT_TYPE_ABTS;
4771 abtsiocb->iocb.un.acxri.abortContextTag = cmd->ulpContext;
4772 abtsiocb->iocb.un.acxri.abortIoTag = cmd->ulpIoTag;
4773 abtsiocb->iocb.ulpLe = 1;
4774 abtsiocb->iocb.ulpClass = cmd->ulpClass;
4775 abtsiocb->vport = phba->pport;
4777 if (lpfc_is_link_up(phba))
4778 abtsiocb->iocb.ulpCommand = CMD_ABORT_XRI_CN;
4780 abtsiocb->iocb.ulpCommand = CMD_CLOSE_XRI_CN;
4782 /* Setup callback routine and issue the command. */
4783 abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
4784 ret_val = lpfc_sli_issue_iocb(phba, pring, abtsiocb, 0);
4785 if (ret_val == IOCB_ERROR) {
4786 lpfc_sli_release_iocbq(phba, abtsiocb);
4796 * lpfc_sli_wake_iocb_wait: iocb completion handler for iocb issued using
4797 * lpfc_sli_issue_iocb_wait.
4798 * @phba: Pointer to HBA context object.
4799 * @cmdiocbq: Pointer to command iocb.
4800 * @rspiocbq: Pointer to response iocb.
4802 * This function is the completion handler for iocbs issued using
4803 * lpfc_sli_issue_iocb_wait function. This function is called by the
4804 * ring event handler function without any lock held. This function
4805 * can be called from both worker thread context and interrupt
4806 * context. This function also can be called from other thread which
4807 * cleans up the SLI layer objects.
4808 * This function copy the contents of the response iocb to the
4809 * response iocb memory object provided by the caller of
4810 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
4811 * sleeps for the iocb completion.
4814 lpfc_sli_wake_iocb_wait(struct lpfc_hba *phba,
4815 struct lpfc_iocbq *cmdiocbq,
4816 struct lpfc_iocbq *rspiocbq)
4818 wait_queue_head_t *pdone_q;
4819 unsigned long iflags;
4821 spin_lock_irqsave(&phba->hbalock, iflags);
4822 cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
4823 if (cmdiocbq->context2 && rspiocbq)
4824 memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
4825 &rspiocbq->iocb, sizeof(IOCB_t));
4827 pdone_q = cmdiocbq->context_un.wait_queue;
4830 spin_unlock_irqrestore(&phba->hbalock, iflags);
4835 * lpfc_sli_issue_iocb_wait: Synchronous function to issue iocb commands.
4836 * @phba: Pointer to HBA context object..
4837 * @pring: Pointer to sli ring.
4838 * @piocb: Pointer to command iocb.
4839 * @prspiocbq: Pointer to response iocb.
4840 * @timeout: Timeout in number of seconds.
4842 * This function issues the iocb to firmware and waits for the
4843 * iocb to complete. If the iocb command is not
4844 * completed within timeout seconds, it returns IOCB_TIMEDOUT.
4845 * Caller should not free the iocb resources if this function
4846 * returns IOCB_TIMEDOUT.
4847 * The function waits for the iocb completion using an
4848 * non-interruptible wait.
4849 * This function will sleep while waiting for iocb completion.
4850 * So, this function should not be called from any context which
4851 * does not allow sleeping. Due to the same reason, this function
4852 * cannot be called with interrupt disabled.
4853 * This function assumes that the iocb completions occur while
4854 * this function sleep. So, this function cannot be called from
4855 * the thread which process iocb completion for this ring.
4856 * This function clears the iocb_flag of the iocb object before
4857 * issuing the iocb and the iocb completion handler sets this
4858 * flag and wakes this thread when the iocb completes.
4859 * The contents of the response iocb will be copied to prspiocbq
4860 * by the completion handler when the command completes.
4861 * This function returns IOCB_SUCCESS when success.
4862 * This function is called with no lock held.
4865 lpfc_sli_issue_iocb_wait(struct lpfc_hba *phba,
4866 struct lpfc_sli_ring *pring,
4867 struct lpfc_iocbq *piocb,
4868 struct lpfc_iocbq *prspiocbq,
4871 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q);
4872 long timeleft, timeout_req = 0;
4873 int retval = IOCB_SUCCESS;
4877 * If the caller has provided a response iocbq buffer, then context2
4878 * is NULL or its an error.
4881 if (piocb->context2)
4883 piocb->context2 = prspiocbq;
4886 piocb->iocb_cmpl = lpfc_sli_wake_iocb_wait;
4887 piocb->context_un.wait_queue = &done_q;
4888 piocb->iocb_flag &= ~LPFC_IO_WAKE;
4890 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
4891 creg_val = readl(phba->HCregaddr);
4892 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
4893 writel(creg_val, phba->HCregaddr);
4894 readl(phba->HCregaddr); /* flush */
4897 retval = lpfc_sli_issue_iocb(phba, pring, piocb, 0);
4898 if (retval == IOCB_SUCCESS) {
4899 timeout_req = timeout * HZ;
4900 timeleft = wait_event_timeout(done_q,
4901 piocb->iocb_flag & LPFC_IO_WAKE,
4904 if (piocb->iocb_flag & LPFC_IO_WAKE) {
4905 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4906 "0331 IOCB wake signaled\n");
4907 } else if (timeleft == 0) {
4908 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4909 "0338 IOCB wait timeout error - no "
4910 "wake response Data x%x\n", timeout);
4911 retval = IOCB_TIMEDOUT;
4913 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4914 "0330 IOCB wake NOT set, "
4916 timeout, (timeleft / jiffies));
4917 retval = IOCB_TIMEDOUT;
4920 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4921 "0332 IOCB wait issue failed, Data x%x\n",
4923 retval = IOCB_ERROR;
4926 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
4927 creg_val = readl(phba->HCregaddr);
4928 creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
4929 writel(creg_val, phba->HCregaddr);
4930 readl(phba->HCregaddr); /* flush */
4934 piocb->context2 = NULL;
4936 piocb->context_un.wait_queue = NULL;
4937 piocb->iocb_cmpl = NULL;
4942 * lpfc_sli_issue_mbox_wait: Synchronous function to issue mailbox.
4943 * @phba: Pointer to HBA context object.
4944 * @pmboxq: Pointer to driver mailbox object.
4945 * @timeout: Timeout in number of seconds.
4947 * This function issues the mailbox to firmware and waits for the
4948 * mailbox command to complete. If the mailbox command is not
4949 * completed within timeout seconds, it returns MBX_TIMEOUT.
4950 * The function waits for the mailbox completion using an
4951 * interruptible wait. If the thread is woken up due to a
4952 * signal, MBX_TIMEOUT error is returned to the caller. Caller
4953 * should not free the mailbox resources, if this function returns
4955 * This function will sleep while waiting for mailbox completion.
4956 * So, this function should not be called from any context which
4957 * does not allow sleeping. Due to the same reason, this function
4958 * cannot be called with interrupt disabled.
4959 * This function assumes that the mailbox completion occurs while
4960 * this function sleep. So, this function cannot be called from
4961 * the worker thread which processes mailbox completion.
4962 * This function is called in the context of HBA management
4964 * This function returns MBX_SUCCESS when successful.
4965 * This function is called with no lock held.
4968 lpfc_sli_issue_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq,
4971 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q);
4975 /* The caller must leave context1 empty. */
4976 if (pmboxq->context1)
4977 return MBX_NOT_FINISHED;
4979 pmboxq->mbox_flag &= ~LPFC_MBX_WAKE;
4980 /* setup wake call as IOCB callback */
4981 pmboxq->mbox_cmpl = lpfc_sli_wake_mbox_wait;
4982 /* setup context field to pass wait_queue pointer to wake function */
4983 pmboxq->context1 = &done_q;
4985 /* now issue the command */
4986 retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
4988 if (retval == MBX_BUSY || retval == MBX_SUCCESS) {
4989 wait_event_interruptible_timeout(done_q,
4990 pmboxq->mbox_flag & LPFC_MBX_WAKE,
4993 spin_lock_irqsave(&phba->hbalock, flag);
4994 pmboxq->context1 = NULL;
4996 * if LPFC_MBX_WAKE flag is set the mailbox is completed
4997 * else do not free the resources.
4999 if (pmboxq->mbox_flag & LPFC_MBX_WAKE)
5000 retval = MBX_SUCCESS;
5002 retval = MBX_TIMEOUT;
5003 pmboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
5005 spin_unlock_irqrestore(&phba->hbalock, flag);
5012 * lpfc_sli_flush_mbox_queue: mailbox queue cleanup function.
5013 * @phba: Pointer to HBA context.
5015 * This function is called to cleanup any pending mailbox
5016 * objects in the driver queue before bringing the HBA offline.
5017 * This function is called while resetting the HBA.
5018 * The function is called without any lock held. The function
5019 * takes hbalock to update SLI data structure.
5020 * This function returns 1 when there is an active mailbox
5021 * command pending else returns 0.
5024 lpfc_sli_flush_mbox_queue(struct lpfc_hba * phba)
5026 struct lpfc_vport *vport = phba->pport;
5030 while (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE && !vport->stopped) {
5031 if (i++ > LPFC_MBOX_TMO * 1000)
5035 * Call lpfc_sli_handle_mb_event only if a mailbox cmd
5036 * did finish. This way we won't get the misleading
5037 * "Stray Mailbox Interrupt" message.
5039 spin_lock_irq(&phba->hbalock);
5040 ha_copy = phba->work_ha;
5041 phba->work_ha &= ~HA_MBATT;
5042 spin_unlock_irq(&phba->hbalock);
5044 if (ha_copy & HA_MBATT)
5045 if (lpfc_sli_handle_mb_event(phba) == 0)
5051 return (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) ? 1 : 0;
5055 * lpfc_intr_handler: The interrupt handler of lpfc driver.
5056 * @irq: Interrupt number.
5057 * @dev_id: The device context pointer.
5059 * This function is called from the PCI layer when there is
5060 * an event in the HBA which requires driver attention. When
5061 * the PCI slot is in error recovery or the HBA is undergoing
5062 * initialization the interrupt handler will not process the
5064 * The error attention, link attention and els ring attention
5065 * events are handled by the worker thread. The interrupt
5066 * handler signals the worker thread and returns for these
5068 * The SCSI ring event and mailbox events are handled in the
5069 * interrupt context.
5070 * This function is called without any lock held. It gets the
5071 * hbalock to access and update SLI data structures.
5072 * This function returns IRQ_HANDLED when interrupt is handled
5073 * else it returns IRQ_NONE.
5076 lpfc_intr_handler(int irq, void *dev_id)
5078 struct lpfc_hba *phba;
5080 uint32_t work_ha_copy;
5081 unsigned long status;
5084 MAILBOX_t *mbox, *pmbox;
5085 struct lpfc_vport *vport;
5086 struct lpfc_nodelist *ndlp;
5087 struct lpfc_dmabuf *mp;
5092 * Get the driver's phba structure from the dev_id and
5093 * assume the HBA is not interrupting.
5095 phba = (struct lpfc_hba *) dev_id;
5097 if (unlikely(!phba))
5100 /* If the pci channel is offline, ignore all the interrupts. */
5101 if (unlikely(pci_channel_offline(phba->pcidev)))
5104 phba->sli.slistat.sli_intr++;
5107 * Call the HBA to see if it is interrupting. If not, don't claim
5111 /* Ignore all interrupts during initialization. */
5112 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5116 * Read host attention register to determine interrupt source
5117 * Clear Attention Sources, except Error Attention (to
5118 * preserve status) and Link Attention
5120 spin_lock(&phba->hbalock);
5121 if (phba->sli3_options & LPFC_SLI3_INB_ENABLED &&
5122 (phba->inb_last_counter != *phba->inb_counter)) {
5123 phba->inb_last_counter = *phba->inb_counter;
5124 ha_copy = le32_to_cpu(*phba->inb_ha_copy);
5126 ha_copy = readl(phba->HAregaddr);
5127 if (unlikely(!ha_copy)) {
5128 spin_unlock(&phba->hbalock);
5131 /* If somebody is waiting to handle an eratt don't process it
5132 * here. The brdkill function will do this.
5134 if (phba->link_flag & LS_IGNORE_ERATT)
5135 ha_copy &= ~HA_ERATT;
5136 writel((ha_copy & ~(HA_LATT | HA_ERATT)), phba->HAregaddr);
5137 readl(phba->HAregaddr); /* flush */
5138 spin_unlock(&phba->hbalock);
5140 work_ha_copy = ha_copy & phba->work_ha_mask;
5142 if (unlikely(work_ha_copy)) {
5143 if (work_ha_copy & HA_LATT) {
5144 if (phba->sli.sli_flag & LPFC_PROCESS_LA) {
5146 * Turn off Link Attention interrupts
5147 * until CLEAR_LA done
5149 spin_lock(&phba->hbalock);
5150 phba->sli.sli_flag &= ~LPFC_PROCESS_LA;
5151 control = readl(phba->HCregaddr);
5152 control &= ~HC_LAINT_ENA;
5153 writel(control, phba->HCregaddr);
5154 readl(phba->HCregaddr); /* flush */
5155 spin_unlock(&phba->hbalock);
5158 work_ha_copy &= ~HA_LATT;
5161 if (work_ha_copy & ~(HA_ERATT|HA_MBATT|HA_LATT)) {
5163 * Turn off Slow Rings interrupts, LPFC_ELS_RING is
5164 * the only slow ring.
5166 status = (work_ha_copy &
5167 (HA_RXMASK << (4*LPFC_ELS_RING)));
5168 status >>= (4*LPFC_ELS_RING);
5169 if (status & HA_RXMASK) {
5170 spin_lock(&phba->hbalock);
5171 control = readl(phba->HCregaddr);
5173 lpfc_debugfs_slow_ring_trc(phba,
5174 "ISR slow ring: ctl:x%x stat:x%x isrcnt:x%x",
5176 (uint32_t)phba->sli.slistat.sli_intr);
5178 if (control & (HC_R0INT_ENA << LPFC_ELS_RING)) {
5179 lpfc_debugfs_slow_ring_trc(phba,
5181 "pwork:x%x hawork:x%x wait:x%x",
5182 phba->work_ha, work_ha_copy,
5183 (uint32_t)((unsigned long)
5184 &phba->work_waitq));
5187 ~(HC_R0INT_ENA << LPFC_ELS_RING);
5188 writel(control, phba->HCregaddr);
5189 readl(phba->HCregaddr); /* flush */
5192 lpfc_debugfs_slow_ring_trc(phba,
5193 "ISR slow ring: pwork:"
5194 "x%x hawork:x%x wait:x%x",
5195 phba->work_ha, work_ha_copy,
5196 (uint32_t)((unsigned long)
5197 &phba->work_waitq));
5199 spin_unlock(&phba->hbalock);
5203 if (work_ha_copy & HA_ERATT) {
5205 * There was a link/board error. Read the
5206 * status register to retrieve the error event
5209 phba->sli.slistat.err_attn_event++;
5210 /* Save status info */
5211 phba->work_hs = readl(phba->HSregaddr);
5212 phba->work_status[0] = readl(phba->MBslimaddr + 0xa8);
5213 phba->work_status[1] = readl(phba->MBslimaddr + 0xac);
5215 /* Clear Chip error bit */
5216 writel(HA_ERATT, phba->HAregaddr);
5217 readl(phba->HAregaddr); /* flush */
5218 phba->pport->stopped = 1;
5221 spin_lock(&phba->hbalock);
5222 if ((work_ha_copy & HA_MBATT) &&
5223 (phba->sli.mbox_active)) {
5224 pmb = phba->sli.mbox_active;
5229 /* First check out the status word */
5230 lpfc_sli_pcimem_bcopy(mbox, pmbox, sizeof(uint32_t));
5231 if (pmbox->mbxOwner != OWN_HOST) {
5232 spin_unlock(&phba->hbalock);
5234 * Stray Mailbox Interrupt, mbxCommand <cmd>
5235 * mbxStatus <status>
5237 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
5239 "(%d):0304 Stray Mailbox "
5240 "Interrupt mbxCommand x%x "
5242 (vport ? vport->vpi : 0),
5245 /* clear mailbox attention bit */
5246 work_ha_copy &= ~HA_MBATT;
5248 phba->sli.mbox_active = NULL;
5249 spin_unlock(&phba->hbalock);
5250 phba->last_completion_time = jiffies;
5251 del_timer(&phba->sli.mbox_tmo);
5252 if (pmb->mbox_cmpl) {
5253 lpfc_sli_pcimem_bcopy(mbox, pmbox,
5256 if (pmb->mbox_flag & LPFC_MBX_IMED_UNREG) {
5257 pmb->mbox_flag &= ~LPFC_MBX_IMED_UNREG;
5259 lpfc_debugfs_disc_trc(vport,
5260 LPFC_DISC_TRC_MBOX_VPORT,
5262 "status:x%x rpi:x%x",
5263 (uint32_t)pmbox->mbxStatus,
5264 pmbox->un.varWords[0], 0);
5266 if (!pmbox->mbxStatus) {
5267 mp = (struct lpfc_dmabuf *)
5269 ndlp = (struct lpfc_nodelist *)
5272 /* Reg_LOGIN of dflt RPI was
5273 * successful. new lets get
5274 * rid of the RPI using the
5277 lpfc_unreg_login(phba,
5279 pmbox->un.varWords[0],
5282 lpfc_mbx_cmpl_dflt_rpi;
5284 pmb->context2 = ndlp;
5286 rc = lpfc_sli_issue_mbox(phba,
5290 lpfc_printf_log(phba,
5293 "0350 rc should have"
5295 goto send_current_mbox;
5298 spin_lock(&phba->pport->work_port_lock);
5299 phba->pport->work_port_events &=
5301 spin_unlock(&phba->pport->work_port_lock);
5302 lpfc_mbox_cmpl_put(phba, pmb);
5305 spin_unlock(&phba->hbalock);
5306 if ((work_ha_copy & HA_MBATT) &&
5307 (phba->sli.mbox_active == NULL)) {
5309 /* Process next mailbox command if there is one */
5311 rc = lpfc_sli_issue_mbox(phba, NULL,
5313 } while (rc == MBX_NOT_FINISHED);
5314 if (rc != MBX_SUCCESS)
5315 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
5316 LOG_SLI, "0349 rc should be "
5320 spin_lock(&phba->hbalock);
5321 phba->work_ha |= work_ha_copy;
5322 spin_unlock(&phba->hbalock);
5323 lpfc_worker_wake_up(phba);
5326 ha_copy &= ~(phba->work_ha_mask);
5329 * Process all events on FCP ring. Take the optimized path for
5330 * FCP IO. Any other IO is slow path and is handled by
5331 * the worker thread.
5333 status = (ha_copy & (HA_RXMASK << (4*LPFC_FCP_RING)));
5334 status >>= (4*LPFC_FCP_RING);
5335 if (status & HA_RXMASK)
5336 lpfc_sli_handle_fast_ring_event(phba,
5337 &phba->sli.ring[LPFC_FCP_RING],
5340 if (phba->cfg_multi_ring_support == 2) {
5342 * Process all events on extra ring. Take the optimized path
5343 * for extra ring IO. Any other IO is slow path and is handled
5344 * by the worker thread.
5346 status = (ha_copy & (HA_RXMASK << (4*LPFC_EXTRA_RING)));
5347 status >>= (4*LPFC_EXTRA_RING);
5348 if (status & HA_RXMASK) {
5349 lpfc_sli_handle_fast_ring_event(phba,
5350 &phba->sli.ring[LPFC_EXTRA_RING],
5356 } /* lpfc_intr_handler */