xref: /openbmc/linux/drivers/scsi/lpfc/lpfc_sli.c (revision 4f3db074) 
1 /*******************************************************************
2  * This file is part of the Emulex Linux Device Driver for         *
3  * Fibre Channel Host Bus Adapters.                                *
4  * Copyright (C) 2004-2015 Emulex.  All rights reserved.           *
5  * EMULEX and SLI are trademarks of Emulex.                        *
6  * www.emulex.com                                                  *
7  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
8  *                                                                 *
9  * This program is free software; you can redistribute it and/or   *
10  * modify it under the terms of version 2 of the GNU General       *
11  * Public License as published by the Free Software Foundation.    *
12  * This program is distributed in the hope that it will be useful. *
13  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
14  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
15  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
16  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
18  * more details, a copy of which can be found in the file COPYING  *
19  * included with this package.                                     *
20  *******************************************************************/
21 
22 #include <linux/blkdev.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
25 #include <linux/delay.h>
26 #include <linux/slab.h>
27 
28 #include <scsi/scsi.h>
29 #include <scsi/scsi_cmnd.h>
30 #include <scsi/scsi_device.h>
31 #include <scsi/scsi_host.h>
32 #include <scsi/scsi_transport_fc.h>
33 #include <scsi/fc/fc_fs.h>
34 #include <linux/aer.h>
35 
36 #include "lpfc_hw4.h"
37 #include "lpfc_hw.h"
38 #include "lpfc_sli.h"
39 #include "lpfc_sli4.h"
40 #include "lpfc_nl.h"
41 #include "lpfc_disc.h"
42 #include "lpfc_scsi.h"
43 #include "lpfc.h"
44 #include "lpfc_crtn.h"
45 #include "lpfc_logmsg.h"
46 #include "lpfc_compat.h"
47 #include "lpfc_debugfs.h"
48 #include "lpfc_vport.h"
49 
50 /* There are only four IOCB completion types. */
51 typedef enum _lpfc_iocb_type {
52 	LPFC_UNKNOWN_IOCB,
53 	LPFC_UNSOL_IOCB,
54 	LPFC_SOL_IOCB,
55 	LPFC_ABORT_IOCB
56 } lpfc_iocb_type;
57 
58 
59 /* Provide function prototypes local to this module. */
60 static int lpfc_sli_issue_mbox_s4(struct lpfc_hba *, LPFC_MBOXQ_t *,
61 				  uint32_t);
62 static int lpfc_sli4_read_rev(struct lpfc_hba *, LPFC_MBOXQ_t *,
63 			      uint8_t *, uint32_t *);
64 static struct lpfc_iocbq *lpfc_sli4_els_wcqe_to_rspiocbq(struct lpfc_hba *,
65 							 struct lpfc_iocbq *);
66 static void lpfc_sli4_send_seq_to_ulp(struct lpfc_vport *,
67 				      struct hbq_dmabuf *);
68 static int lpfc_sli4_fp_handle_wcqe(struct lpfc_hba *, struct lpfc_queue *,
69 				    struct lpfc_cqe *);
70 static int lpfc_sli4_post_els_sgl_list(struct lpfc_hba *, struct list_head *,
71 				       int);
72 static void lpfc_sli4_hba_handle_eqe(struct lpfc_hba *, struct lpfc_eqe *,
73 			uint32_t);
74 static bool lpfc_sli4_mbox_completions_pending(struct lpfc_hba *phba);
75 static bool lpfc_sli4_process_missed_mbox_completions(struct lpfc_hba *phba);
76 
77 static IOCB_t *
78 lpfc_get_iocb_from_iocbq(struct lpfc_iocbq *iocbq)
79 {
80 	return &iocbq->iocb;
81 }
82 
83 /**
84  * lpfc_sli4_wq_put - Put a Work Queue Entry on an Work Queue
85  * @q: The Work Queue to operate on.
86  * @wqe: The work Queue Entry to put on the Work queue.
87  *
88  * This routine will copy the contents of @wqe to the next available entry on
89  * the @q. This function will then ring the Work Queue Doorbell to signal the
90  * HBA to start processing the Work Queue Entry. This function returns 0 if
91  * successful. If no entries are available on @q then this function will return
92  * -ENOMEM.
93  * The caller is expected to hold the hbalock when calling this routine.
94  **/
95 static uint32_t
96 lpfc_sli4_wq_put(struct lpfc_queue *q, union lpfc_wqe *wqe)
97 {
98 	union lpfc_wqe *temp_wqe;
99 	struct lpfc_register doorbell;
100 	uint32_t host_index;
101 	uint32_t idx;
102 
103 	/* sanity check on queue memory */
104 	if (unlikely(!q))
105 		return -ENOMEM;
106 	temp_wqe = q->qe[q->host_index].wqe;
107 
108 	/* If the host has not yet processed the next entry then we are done */
109 	idx = ((q->host_index + 1) % q->entry_count);
110 	if (idx == q->hba_index) {
111 		q->WQ_overflow++;
112 		return -ENOMEM;
113 	}
114 	q->WQ_posted++;
115 	/* set consumption flag every once in a while */
116 	if (!((q->host_index + 1) % q->entry_repost))
117 		bf_set(wqe_wqec, &wqe->generic.wqe_com, 1);
118 	if (q->phba->sli3_options & LPFC_SLI4_PHWQ_ENABLED)
119 		bf_set(wqe_wqid, &wqe->generic.wqe_com, q->queue_id);
120 	lpfc_sli_pcimem_bcopy(wqe, temp_wqe, q->entry_size);
121 
122 	/* Update the host index before invoking device */
123 	host_index = q->host_index;
124 
125 	q->host_index = idx;
126 
127 	/* Ring Doorbell */
128 	doorbell.word0 = 0;
129 	if (q->db_format == LPFC_DB_LIST_FORMAT) {
130 		bf_set(lpfc_wq_db_list_fm_num_posted, &doorbell, 1);
131 		bf_set(lpfc_wq_db_list_fm_index, &doorbell, host_index);
132 		bf_set(lpfc_wq_db_list_fm_id, &doorbell, q->queue_id);
133 	} else if (q->db_format == LPFC_DB_RING_FORMAT) {
134 		bf_set(lpfc_wq_db_ring_fm_num_posted, &doorbell, 1);
135 		bf_set(lpfc_wq_db_ring_fm_id, &doorbell, q->queue_id);
136 	} else {
137 		return -EINVAL;
138 	}
139 	writel(doorbell.word0, q->db_regaddr);
140 
141 	return 0;
142 }
143 
144 /**
145  * lpfc_sli4_wq_release - Updates internal hba index for WQ
146  * @q: The Work Queue to operate on.
147  * @index: The index to advance the hba index to.
148  *
149  * This routine will update the HBA index of a queue to reflect consumption of
150  * Work Queue Entries by the HBA. When the HBA indicates that it has consumed
151  * an entry the host calls this function to update the queue's internal
152  * pointers. This routine returns the number of entries that were consumed by
153  * the HBA.
154  **/
155 static uint32_t
156 lpfc_sli4_wq_release(struct lpfc_queue *q, uint32_t index)
157 {
158 	uint32_t released = 0;
159 
160 	/* sanity check on queue memory */
161 	if (unlikely(!q))
162 		return 0;
163 
164 	if (q->hba_index == index)
165 		return 0;
166 	do {
167 		q->hba_index = ((q->hba_index + 1) % q->entry_count);
168 		released++;
169 	} while (q->hba_index != index);
170 	return released;
171 }
172 
173 /**
174  * lpfc_sli4_mq_put - Put a Mailbox Queue Entry on an Mailbox Queue
175  * @q: The Mailbox Queue to operate on.
176  * @wqe: The Mailbox Queue Entry to put on the Work queue.
177  *
178  * This routine will copy the contents of @mqe to the next available entry on
179  * the @q. This function will then ring the Work Queue Doorbell to signal the
180  * HBA to start processing the Work Queue Entry. This function returns 0 if
181  * successful. If no entries are available on @q then this function will return
182  * -ENOMEM.
183  * The caller is expected to hold the hbalock when calling this routine.
184  **/
185 static uint32_t
186 lpfc_sli4_mq_put(struct lpfc_queue *q, struct lpfc_mqe *mqe)
187 {
188 	struct lpfc_mqe *temp_mqe;
189 	struct lpfc_register doorbell;
190 
191 	/* sanity check on queue memory */
192 	if (unlikely(!q))
193 		return -ENOMEM;
194 	temp_mqe = q->qe[q->host_index].mqe;
195 
196 	/* If the host has not yet processed the next entry then we are done */
197 	if (((q->host_index + 1) % q->entry_count) == q->hba_index)
198 		return -ENOMEM;
199 	lpfc_sli_pcimem_bcopy(mqe, temp_mqe, q->entry_size);
200 	/* Save off the mailbox pointer for completion */
201 	q->phba->mbox = (MAILBOX_t *)temp_mqe;
202 
203 	/* Update the host index before invoking device */
204 	q->host_index = ((q->host_index + 1) % q->entry_count);
205 
206 	/* Ring Doorbell */
207 	doorbell.word0 = 0;
208 	bf_set(lpfc_mq_doorbell_num_posted, &doorbell, 1);
209 	bf_set(lpfc_mq_doorbell_id, &doorbell, q->queue_id);
210 	writel(doorbell.word0, q->phba->sli4_hba.MQDBregaddr);
211 	return 0;
212 }
213 
214 /**
215  * lpfc_sli4_mq_release - Updates internal hba index for MQ
216  * @q: The Mailbox Queue to operate on.
217  *
218  * This routine will update the HBA index of a queue to reflect consumption of
219  * a Mailbox Queue Entry by the HBA. When the HBA indicates that it has consumed
220  * an entry the host calls this function to update the queue's internal
221  * pointers. This routine returns the number of entries that were consumed by
222  * the HBA.
223  **/
224 static uint32_t
225 lpfc_sli4_mq_release(struct lpfc_queue *q)
226 {
227 	/* sanity check on queue memory */
228 	if (unlikely(!q))
229 		return 0;
230 
231 	/* Clear the mailbox pointer for completion */
232 	q->phba->mbox = NULL;
233 	q->hba_index = ((q->hba_index + 1) % q->entry_count);
234 	return 1;
235 }
236 
237 /**
238  * lpfc_sli4_eq_get - Gets the next valid EQE from a EQ
239  * @q: The Event Queue to get the first valid EQE from
240  *
241  * This routine will get the first valid Event Queue Entry from @q, update
242  * the queue's internal hba index, and return the EQE. If no valid EQEs are in
243  * the Queue (no more work to do), or the Queue is full of EQEs that have been
244  * processed, but not popped back to the HBA then this routine will return NULL.
245  **/
246 static struct lpfc_eqe *
247 lpfc_sli4_eq_get(struct lpfc_queue *q)
248 {
249 	struct lpfc_eqe *eqe;
250 	uint32_t idx;
251 
252 	/* sanity check on queue memory */
253 	if (unlikely(!q))
254 		return NULL;
255 	eqe = q->qe[q->hba_index].eqe;
256 
257 	/* If the next EQE is not valid then we are done */
258 	if (!bf_get_le32(lpfc_eqe_valid, eqe))
259 		return NULL;
260 	/* If the host has not yet processed the next entry then we are done */
261 	idx = ((q->hba_index + 1) % q->entry_count);
262 	if (idx == q->host_index)
263 		return NULL;
264 
265 	q->hba_index = idx;
266 
267 	/*
268 	 * insert barrier for instruction interlock : data from the hardware
269 	 * must have the valid bit checked before it can be copied and acted
270 	 * upon. Given what was seen in lpfc_sli4_cq_get() of speculative
271 	 * instructions allowing action on content before valid bit checked,
272 	 * add barrier here as well. May not be needed as "content" is a
273 	 * single 32-bit entity here (vs multi word structure for cq's).
274 	 */
275 	mb();
276 	return eqe;
277 }
278 
279 /**
280  * lpfc_sli4_eq_clr_intr - Turn off interrupts from this EQ
281  * @q: The Event Queue to disable interrupts
282  *
283  **/
284 static inline void
285 lpfc_sli4_eq_clr_intr(struct lpfc_queue *q)
286 {
287 	struct lpfc_register doorbell;
288 
289 	doorbell.word0 = 0;
290 	bf_set(lpfc_eqcq_doorbell_eqci, &doorbell, 1);
291 	bf_set(lpfc_eqcq_doorbell_qt, &doorbell, LPFC_QUEUE_TYPE_EVENT);
292 	bf_set(lpfc_eqcq_doorbell_eqid_hi, &doorbell,
293 		(q->queue_id >> LPFC_EQID_HI_FIELD_SHIFT));
294 	bf_set(lpfc_eqcq_doorbell_eqid_lo, &doorbell, q->queue_id);
295 	writel(doorbell.word0, q->phba->sli4_hba.EQCQDBregaddr);
296 }
297 
298 /**
299  * lpfc_sli4_eq_release - Indicates the host has finished processing an EQ
300  * @q: The Event Queue that the host has completed processing for.
301  * @arm: Indicates whether the host wants to arms this CQ.
302  *
303  * This routine will mark all Event Queue Entries on @q, from the last
304  * known completed entry to the last entry that was processed, as completed
305  * by clearing the valid bit for each completion queue entry. Then it will
306  * notify the HBA, by ringing the doorbell, that the EQEs have been processed.
307  * The internal host index in the @q will be updated by this routine to indicate
308  * that the host has finished processing the entries. The @arm parameter
309  * indicates that the queue should be rearmed when ringing the doorbell.
310  *
311  * This function will return the number of EQEs that were popped.
312  **/
313 uint32_t
314 lpfc_sli4_eq_release(struct lpfc_queue *q, bool arm)
315 {
316 	uint32_t released = 0;
317 	struct lpfc_eqe *temp_eqe;
318 	struct lpfc_register doorbell;
319 
320 	/* sanity check on queue memory */
321 	if (unlikely(!q))
322 		return 0;
323 
324 	/* while there are valid entries */
325 	while (q->hba_index != q->host_index) {
326 		temp_eqe = q->qe[q->host_index].eqe;
327 		bf_set_le32(lpfc_eqe_valid, temp_eqe, 0);
328 		released++;
329 		q->host_index = ((q->host_index + 1) % q->entry_count);
330 	}
331 	if (unlikely(released == 0 && !arm))
332 		return 0;
333 
334 	/* ring doorbell for number popped */
335 	doorbell.word0 = 0;
336 	if (arm) {
337 		bf_set(lpfc_eqcq_doorbell_arm, &doorbell, 1);
338 		bf_set(lpfc_eqcq_doorbell_eqci, &doorbell, 1);
339 	}
340 	bf_set(lpfc_eqcq_doorbell_num_released, &doorbell, released);
341 	bf_set(lpfc_eqcq_doorbell_qt, &doorbell, LPFC_QUEUE_TYPE_EVENT);
342 	bf_set(lpfc_eqcq_doorbell_eqid_hi, &doorbell,
343 			(q->queue_id >> LPFC_EQID_HI_FIELD_SHIFT));
344 	bf_set(lpfc_eqcq_doorbell_eqid_lo, &doorbell, q->queue_id);
345 	writel(doorbell.word0, q->phba->sli4_hba.EQCQDBregaddr);
346 	/* PCI read to flush PCI pipeline on re-arming for INTx mode */
347 	if ((q->phba->intr_type == INTx) && (arm == LPFC_QUEUE_REARM))
348 		readl(q->phba->sli4_hba.EQCQDBregaddr);
349 	return released;
350 }
351 
352 /**
353  * lpfc_sli4_cq_get - Gets the next valid CQE from a CQ
354  * @q: The Completion Queue to get the first valid CQE from
355  *
356  * This routine will get the first valid Completion Queue Entry from @q, update
357  * the queue's internal hba index, and return the CQE. If no valid CQEs are in
358  * the Queue (no more work to do), or the Queue is full of CQEs that have been
359  * processed, but not popped back to the HBA then this routine will return NULL.
360  **/
361 static struct lpfc_cqe *
362 lpfc_sli4_cq_get(struct lpfc_queue *q)
363 {
364 	struct lpfc_cqe *cqe;
365 	uint32_t idx;
366 
367 	/* sanity check on queue memory */
368 	if (unlikely(!q))
369 		return NULL;
370 
371 	/* If the next CQE is not valid then we are done */
372 	if (!bf_get_le32(lpfc_cqe_valid, q->qe[q->hba_index].cqe))
373 		return NULL;
374 	/* If the host has not yet processed the next entry then we are done */
375 	idx = ((q->hba_index + 1) % q->entry_count);
376 	if (idx == q->host_index)
377 		return NULL;
378 
379 	cqe = q->qe[q->hba_index].cqe;
380 	q->hba_index = idx;
381 
382 	/*
383 	 * insert barrier for instruction interlock : data from the hardware
384 	 * must have the valid bit checked before it can be copied and acted
385 	 * upon. Speculative instructions were allowing a bcopy at the start
386 	 * of lpfc_sli4_fp_handle_wcqe(), which is called immediately
387 	 * after our return, to copy data before the valid bit check above
388 	 * was done. As such, some of the copied data was stale. The barrier
389 	 * ensures the check is before any data is copied.
390 	 */
391 	mb();
392 	return cqe;
393 }
394 
395 /**
396  * lpfc_sli4_cq_release - Indicates the host has finished processing a CQ
397  * @q: The Completion Queue that the host has completed processing for.
398  * @arm: Indicates whether the host wants to arms this CQ.
399  *
400  * This routine will mark all Completion queue entries on @q, from the last
401  * known completed entry to the last entry that was processed, as completed
402  * by clearing the valid bit for each completion queue entry. Then it will
403  * notify the HBA, by ringing the doorbell, that the CQEs have been processed.
404  * The internal host index in the @q will be updated by this routine to indicate
405  * that the host has finished processing the entries. The @arm parameter
406  * indicates that the queue should be rearmed when ringing the doorbell.
407  *
408  * This function will return the number of CQEs that were released.
409  **/
410 uint32_t
411 lpfc_sli4_cq_release(struct lpfc_queue *q, bool arm)
412 {
413 	uint32_t released = 0;
414 	struct lpfc_cqe *temp_qe;
415 	struct lpfc_register doorbell;
416 
417 	/* sanity check on queue memory */
418 	if (unlikely(!q))
419 		return 0;
420 	/* while there are valid entries */
421 	while (q->hba_index != q->host_index) {
422 		temp_qe = q->qe[q->host_index].cqe;
423 		bf_set_le32(lpfc_cqe_valid, temp_qe, 0);
424 		released++;
425 		q->host_index = ((q->host_index + 1) % q->entry_count);
426 	}
427 	if (unlikely(released == 0 && !arm))
428 		return 0;
429 
430 	/* ring doorbell for number popped */
431 	doorbell.word0 = 0;
432 	if (arm)
433 		bf_set(lpfc_eqcq_doorbell_arm, &doorbell, 1);
434 	bf_set(lpfc_eqcq_doorbell_num_released, &doorbell, released);
435 	bf_set(lpfc_eqcq_doorbell_qt, &doorbell, LPFC_QUEUE_TYPE_COMPLETION);
436 	bf_set(lpfc_eqcq_doorbell_cqid_hi, &doorbell,
437 			(q->queue_id >> LPFC_CQID_HI_FIELD_SHIFT));
438 	bf_set(lpfc_eqcq_doorbell_cqid_lo, &doorbell, q->queue_id);
439 	writel(doorbell.word0, q->phba->sli4_hba.EQCQDBregaddr);
440 	return released;
441 }
442 
443 /**
444  * lpfc_sli4_rq_put - Put a Receive Buffer Queue Entry on a Receive Queue
445  * @q: The Header Receive Queue to operate on.
446  * @wqe: The Receive Queue Entry to put on the Receive queue.
447  *
448  * This routine will copy the contents of @wqe to the next available entry on
449  * the @q. This function will then ring the Receive Queue Doorbell to signal the
450  * HBA to start processing the Receive Queue Entry. This function returns the
451  * index that the rqe was copied to if successful. If no entries are available
452  * on @q then this function will return -ENOMEM.
453  * The caller is expected to hold the hbalock when calling this routine.
454  **/
455 static int
456 lpfc_sli4_rq_put(struct lpfc_queue *hq, struct lpfc_queue *dq,
457 		 struct lpfc_rqe *hrqe, struct lpfc_rqe *drqe)
458 {
459 	struct lpfc_rqe *temp_hrqe;
460 	struct lpfc_rqe *temp_drqe;
461 	struct lpfc_register doorbell;
462 	int put_index;
463 
464 	/* sanity check on queue memory */
465 	if (unlikely(!hq) || unlikely(!dq))
466 		return -ENOMEM;
467 	put_index = hq->host_index;
468 	temp_hrqe = hq->qe[hq->host_index].rqe;
469 	temp_drqe = dq->qe[dq->host_index].rqe;
470 
471 	if (hq->type != LPFC_HRQ || dq->type != LPFC_DRQ)
472 		return -EINVAL;
473 	if (hq->host_index != dq->host_index)
474 		return -EINVAL;
475 	/* If the host has not yet processed the next entry then we are done */
476 	if (((hq->host_index + 1) % hq->entry_count) == hq->hba_index)
477 		return -EBUSY;
478 	lpfc_sli_pcimem_bcopy(hrqe, temp_hrqe, hq->entry_size);
479 	lpfc_sli_pcimem_bcopy(drqe, temp_drqe, dq->entry_size);
480 
481 	/* Update the host index to point to the next slot */
482 	hq->host_index = ((hq->host_index + 1) % hq->entry_count);
483 	dq->host_index = ((dq->host_index + 1) % dq->entry_count);
484 
485 	/* Ring The Header Receive Queue Doorbell */
486 	if (!(hq->host_index % hq->entry_repost)) {
487 		doorbell.word0 = 0;
488 		if (hq->db_format == LPFC_DB_RING_FORMAT) {
489 			bf_set(lpfc_rq_db_ring_fm_num_posted, &doorbell,
490 			       hq->entry_repost);
491 			bf_set(lpfc_rq_db_ring_fm_id, &doorbell, hq->queue_id);
492 		} else if (hq->db_format == LPFC_DB_LIST_FORMAT) {
493 			bf_set(lpfc_rq_db_list_fm_num_posted, &doorbell,
494 			       hq->entry_repost);
495 			bf_set(lpfc_rq_db_list_fm_index, &doorbell,
496 			       hq->host_index);
497 			bf_set(lpfc_rq_db_list_fm_id, &doorbell, hq->queue_id);
498 		} else {
499 			return -EINVAL;
500 		}
501 		writel(doorbell.word0, hq->db_regaddr);
502 	}
503 	return put_index;
504 }
505 
506 /**
507  * lpfc_sli4_rq_release - Updates internal hba index for RQ
508  * @q: The Header Receive Queue to operate on.
509  *
510  * This routine will update the HBA index of a queue to reflect consumption of
511  * one Receive Queue Entry by the HBA. When the HBA indicates that it has
512  * consumed an entry the host calls this function to update the queue's
513  * internal pointers. This routine returns the number of entries that were
514  * consumed by the HBA.
515  **/
516 static uint32_t
517 lpfc_sli4_rq_release(struct lpfc_queue *hq, struct lpfc_queue *dq)
518 {
519 	/* sanity check on queue memory */
520 	if (unlikely(!hq) || unlikely(!dq))
521 		return 0;
522 
523 	if ((hq->type != LPFC_HRQ) || (dq->type != LPFC_DRQ))
524 		return 0;
525 	hq->hba_index = ((hq->hba_index + 1) % hq->entry_count);
526 	dq->hba_index = ((dq->hba_index + 1) % dq->entry_count);
527 	return 1;
528 }
529 
530 /**
531  * lpfc_cmd_iocb - Get next command iocb entry in the ring
532  * @phba: Pointer to HBA context object.
533  * @pring: Pointer to driver SLI ring object.
534  *
535  * This function returns pointer to next command iocb entry
536  * in the command ring. The caller must hold hbalock to prevent
537  * other threads consume the next command iocb.
538  * SLI-2/SLI-3 provide different sized iocbs.
539  **/
540 static inline IOCB_t *
541 lpfc_cmd_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
542 {
543 	return (IOCB_t *) (((char *) pring->sli.sli3.cmdringaddr) +
544 			   pring->sli.sli3.cmdidx * phba->iocb_cmd_size);
545 }
546 
547 /**
548  * lpfc_resp_iocb - Get next response iocb entry in the ring
549  * @phba: Pointer to HBA context object.
550  * @pring: Pointer to driver SLI ring object.
551  *
552  * This function returns pointer to next response iocb entry
553  * in the response ring. The caller must hold hbalock to make sure
554  * that no other thread consume the next response iocb.
555  * SLI-2/SLI-3 provide different sized iocbs.
556  **/
557 static inline IOCB_t *
558 lpfc_resp_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
559 {
560 	return (IOCB_t *) (((char *) pring->sli.sli3.rspringaddr) +
561 			   pring->sli.sli3.rspidx * phba->iocb_rsp_size);
562 }
563 
564 /**
565  * __lpfc_sli_get_iocbq - Allocates an iocb object from iocb pool
566  * @phba: Pointer to HBA context object.
567  *
568  * This function is called with hbalock held. This function
569  * allocates a new driver iocb object from the iocb pool. If the
570  * allocation is successful, it returns pointer to the newly
571  * allocated iocb object else it returns NULL.
572  **/
573 struct lpfc_iocbq *
574 __lpfc_sli_get_iocbq(struct lpfc_hba *phba)
575 {
576 	struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
577 	struct lpfc_iocbq * iocbq = NULL;
578 
579 	list_remove_head(lpfc_iocb_list, iocbq, struct lpfc_iocbq, list);
580 	if (iocbq)
581 		phba->iocb_cnt++;
582 	if (phba->iocb_cnt > phba->iocb_max)
583 		phba->iocb_max = phba->iocb_cnt;
584 	return iocbq;
585 }
586 
587 /**
588  * __lpfc_clear_active_sglq - Remove the active sglq for this XRI.
589  * @phba: Pointer to HBA context object.
590  * @xritag: XRI value.
591  *
592  * This function clears the sglq pointer from the array of acive
593  * sglq's. The xritag that is passed in is used to index into the
594  * array. Before the xritag can be used it needs to be adjusted
595  * by subtracting the xribase.
596  *
597  * Returns sglq ponter = success, NULL = Failure.
598  **/
599 static struct lpfc_sglq *
600 __lpfc_clear_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
601 {
602 	struct lpfc_sglq *sglq;
603 
604 	sglq = phba->sli4_hba.lpfc_sglq_active_list[xritag];
605 	phba->sli4_hba.lpfc_sglq_active_list[xritag] = NULL;
606 	return sglq;
607 }
608 
609 /**
610  * __lpfc_get_active_sglq - Get the active sglq for this XRI.
611  * @phba: Pointer to HBA context object.
612  * @xritag: XRI value.
613  *
614  * This function returns the sglq pointer from the array of acive
615  * sglq's. The xritag that is passed in is used to index into the
616  * array. Before the xritag can be used it needs to be adjusted
617  * by subtracting the xribase.
618  *
619  * Returns sglq ponter = success, NULL = Failure.
620  **/
621 struct lpfc_sglq *
622 __lpfc_get_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
623 {
624 	struct lpfc_sglq *sglq;
625 
626 	sglq =  phba->sli4_hba.lpfc_sglq_active_list[xritag];
627 	return sglq;
628 }
629 
630 /**
631  * lpfc_clr_rrq_active - Clears RRQ active bit in xri_bitmap.
632  * @phba: Pointer to HBA context object.
633  * @xritag: xri used in this exchange.
634  * @rrq: The RRQ to be cleared.
635  *
636  **/
637 void
638 lpfc_clr_rrq_active(struct lpfc_hba *phba,
639 		    uint16_t xritag,
640 		    struct lpfc_node_rrq *rrq)
641 {
642 	struct lpfc_nodelist *ndlp = NULL;
643 
644 	if ((rrq->vport) && NLP_CHK_NODE_ACT(rrq->ndlp))
645 		ndlp = lpfc_findnode_did(rrq->vport, rrq->nlp_DID);
646 
647 	/* The target DID could have been swapped (cable swap)
648 	 * we should use the ndlp from the findnode if it is
649 	 * available.
650 	 */
651 	if ((!ndlp) && rrq->ndlp)
652 		ndlp = rrq->ndlp;
653 
654 	if (!ndlp)
655 		goto out;
656 
657 	if (test_and_clear_bit(xritag, ndlp->active_rrqs_xri_bitmap)) {
658 		rrq->send_rrq = 0;
659 		rrq->xritag = 0;
660 		rrq->rrq_stop_time = 0;
661 	}
662 out:
663 	mempool_free(rrq, phba->rrq_pool);
664 }
665 
666 /**
667  * lpfc_handle_rrq_active - Checks if RRQ has waithed RATOV.
668  * @phba: Pointer to HBA context object.
669  *
670  * This function is called with hbalock held. This function
671  * Checks if stop_time (ratov from setting rrq active) has
672  * been reached, if it has and the send_rrq flag is set then
673  * it will call lpfc_send_rrq. If the send_rrq flag is not set
674  * then it will just call the routine to clear the rrq and
675  * free the rrq resource.
676  * The timer is set to the next rrq that is going to expire before
677  * leaving the routine.
678  *
679  **/
680 void
681 lpfc_handle_rrq_active(struct lpfc_hba *phba)
682 {
683 	struct lpfc_node_rrq *rrq;
684 	struct lpfc_node_rrq *nextrrq;
685 	unsigned long next_time;
686 	unsigned long iflags;
687 	LIST_HEAD(send_rrq);
688 
689 	spin_lock_irqsave(&phba->hbalock, iflags);
690 	phba->hba_flag &= ~HBA_RRQ_ACTIVE;
691 	next_time = jiffies + msecs_to_jiffies(1000 * (phba->fc_ratov + 1));
692 	list_for_each_entry_safe(rrq, nextrrq,
693 				 &phba->active_rrq_list, list) {
694 		if (time_after(jiffies, rrq->rrq_stop_time))
695 			list_move(&rrq->list, &send_rrq);
696 		else if (time_before(rrq->rrq_stop_time, next_time))
697 			next_time = rrq->rrq_stop_time;
698 	}
699 	spin_unlock_irqrestore(&phba->hbalock, iflags);
700 	if ((!list_empty(&phba->active_rrq_list)) &&
701 	    (!(phba->pport->load_flag & FC_UNLOADING)))
702 		mod_timer(&phba->rrq_tmr, next_time);
703 	list_for_each_entry_safe(rrq, nextrrq, &send_rrq, list) {
704 		list_del(&rrq->list);
705 		if (!rrq->send_rrq)
706 			/* this call will free the rrq */
707 		lpfc_clr_rrq_active(phba, rrq->xritag, rrq);
708 		else if (lpfc_send_rrq(phba, rrq)) {
709 			/* if we send the rrq then the completion handler
710 			*  will clear the bit in the xribitmap.
711 			*/
712 			lpfc_clr_rrq_active(phba, rrq->xritag,
713 					    rrq);
714 		}
715 	}
716 }
717 
718 /**
719  * lpfc_get_active_rrq - Get the active RRQ for this exchange.
720  * @vport: Pointer to vport context object.
721  * @xri: The xri used in the exchange.
722  * @did: The targets DID for this exchange.
723  *
724  * returns NULL = rrq not found in the phba->active_rrq_list.
725  *         rrq = rrq for this xri and target.
726  **/
727 struct lpfc_node_rrq *
728 lpfc_get_active_rrq(struct lpfc_vport *vport, uint16_t xri, uint32_t did)
729 {
730 	struct lpfc_hba *phba = vport->phba;
731 	struct lpfc_node_rrq *rrq;
732 	struct lpfc_node_rrq *nextrrq;
733 	unsigned long iflags;
734 
735 	if (phba->sli_rev != LPFC_SLI_REV4)
736 		return NULL;
737 	spin_lock_irqsave(&phba->hbalock, iflags);
738 	list_for_each_entry_safe(rrq, nextrrq, &phba->active_rrq_list, list) {
739 		if (rrq->vport == vport && rrq->xritag == xri &&
740 				rrq->nlp_DID == did){
741 			list_del(&rrq->list);
742 			spin_unlock_irqrestore(&phba->hbalock, iflags);
743 			return rrq;
744 		}
745 	}
746 	spin_unlock_irqrestore(&phba->hbalock, iflags);
747 	return NULL;
748 }
749 
750 /**
751  * lpfc_cleanup_vports_rrqs - Remove and clear the active RRQ for this vport.
752  * @vport: Pointer to vport context object.
753  * @ndlp: Pointer to the lpfc_node_list structure.
754  * If ndlp is NULL Remove all active RRQs for this vport from the
755  * phba->active_rrq_list and clear the rrq.
756  * If ndlp is not NULL then only remove rrqs for this vport & this ndlp.
757  **/
758 void
759 lpfc_cleanup_vports_rrqs(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
760 
761 {
762 	struct lpfc_hba *phba = vport->phba;
763 	struct lpfc_node_rrq *rrq;
764 	struct lpfc_node_rrq *nextrrq;
765 	unsigned long iflags;
766 	LIST_HEAD(rrq_list);
767 
768 	if (phba->sli_rev != LPFC_SLI_REV4)
769 		return;
770 	if (!ndlp) {
771 		lpfc_sli4_vport_delete_els_xri_aborted(vport);
772 		lpfc_sli4_vport_delete_fcp_xri_aborted(vport);
773 	}
774 	spin_lock_irqsave(&phba->hbalock, iflags);
775 	list_for_each_entry_safe(rrq, nextrrq, &phba->active_rrq_list, list)
776 		if ((rrq->vport == vport) && (!ndlp  || rrq->ndlp == ndlp))
777 			list_move(&rrq->list, &rrq_list);
778 	spin_unlock_irqrestore(&phba->hbalock, iflags);
779 
780 	list_for_each_entry_safe(rrq, nextrrq, &rrq_list, list) {
781 		list_del(&rrq->list);
782 		lpfc_clr_rrq_active(phba, rrq->xritag, rrq);
783 	}
784 }
785 
786 /**
787  * lpfc_test_rrq_active - Test RRQ bit in xri_bitmap.
788  * @phba: Pointer to HBA context object.
789  * @ndlp: Targets nodelist pointer for this exchange.
790  * @xritag the xri in the bitmap to test.
791  *
792  * This function is called with hbalock held. This function
793  * returns 0 = rrq not active for this xri
794  *         1 = rrq is valid for this xri.
795  **/
796 int
797 lpfc_test_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
798 			uint16_t  xritag)
799 {
800 	if (!ndlp)
801 		return 0;
802 	if (!ndlp->active_rrqs_xri_bitmap)
803 		return 0;
804 	if (test_bit(xritag, ndlp->active_rrqs_xri_bitmap))
805 			return 1;
806 	else
807 		return 0;
808 }
809 
810 /**
811  * lpfc_set_rrq_active - set RRQ active bit in xri_bitmap.
812  * @phba: Pointer to HBA context object.
813  * @ndlp: nodelist pointer for this target.
814  * @xritag: xri used in this exchange.
815  * @rxid: Remote Exchange ID.
816  * @send_rrq: Flag used to determine if we should send rrq els cmd.
817  *
818  * This function takes the hbalock.
819  * The active bit is always set in the active rrq xri_bitmap even
820  * if there is no slot avaiable for the other rrq information.
821  *
822  * returns 0 rrq actived for this xri
823  *         < 0 No memory or invalid ndlp.
824  **/
825 int
826 lpfc_set_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
827 		    uint16_t xritag, uint16_t rxid, uint16_t send_rrq)
828 {
829 	unsigned long iflags;
830 	struct lpfc_node_rrq *rrq;
831 	int empty;
832 
833 	if (!ndlp)
834 		return -EINVAL;
835 
836 	if (!phba->cfg_enable_rrq)
837 		return -EINVAL;
838 
839 	spin_lock_irqsave(&phba->hbalock, iflags);
840 	if (phba->pport->load_flag & FC_UNLOADING) {
841 		phba->hba_flag &= ~HBA_RRQ_ACTIVE;
842 		goto out;
843 	}
844 
845 	/*
846 	 * set the active bit even if there is no mem available.
847 	 */
848 	if (NLP_CHK_FREE_REQ(ndlp))
849 		goto out;
850 
851 	if (ndlp->vport && (ndlp->vport->load_flag & FC_UNLOADING))
852 		goto out;
853 
854 	if (!ndlp->active_rrqs_xri_bitmap)
855 		goto out;
856 
857 	if (test_and_set_bit(xritag, ndlp->active_rrqs_xri_bitmap))
858 		goto out;
859 
860 	spin_unlock_irqrestore(&phba->hbalock, iflags);
861 	rrq = mempool_alloc(phba->rrq_pool, GFP_KERNEL);
862 	if (!rrq) {
863 		lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
864 				"3155 Unable to allocate RRQ xri:0x%x rxid:0x%x"
865 				" DID:0x%x Send:%d\n",
866 				xritag, rxid, ndlp->nlp_DID, send_rrq);
867 		return -EINVAL;
868 	}
869 	if (phba->cfg_enable_rrq == 1)
870 		rrq->send_rrq = send_rrq;
871 	else
872 		rrq->send_rrq = 0;
873 	rrq->xritag = xritag;
874 	rrq->rrq_stop_time = jiffies +
875 				msecs_to_jiffies(1000 * (phba->fc_ratov + 1));
876 	rrq->ndlp = ndlp;
877 	rrq->nlp_DID = ndlp->nlp_DID;
878 	rrq->vport = ndlp->vport;
879 	rrq->rxid = rxid;
880 	spin_lock_irqsave(&phba->hbalock, iflags);
881 	empty = list_empty(&phba->active_rrq_list);
882 	list_add_tail(&rrq->list, &phba->active_rrq_list);
883 	phba->hba_flag |= HBA_RRQ_ACTIVE;
884 	if (empty)
885 		lpfc_worker_wake_up(phba);
886 	spin_unlock_irqrestore(&phba->hbalock, iflags);
887 	return 0;
888 out:
889 	spin_unlock_irqrestore(&phba->hbalock, iflags);
890 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
891 			"2921 Can't set rrq active xri:0x%x rxid:0x%x"
892 			" DID:0x%x Send:%d\n",
893 			xritag, rxid, ndlp->nlp_DID, send_rrq);
894 	return -EINVAL;
895 }
896 
897 /**
898  * __lpfc_sli_get_sglq - Allocates an iocb object from sgl pool
899  * @phba: Pointer to HBA context object.
900  * @piocb: Pointer to the iocbq.
901  *
902  * This function is called with the ring lock held. This function
903  * gets a new driver sglq object from the sglq list. If the
904  * list is not empty then it is successful, it returns pointer to the newly
905  * allocated sglq object else it returns NULL.
906  **/
907 static struct lpfc_sglq *
908 __lpfc_sli_get_sglq(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq)
909 {
910 	struct list_head *lpfc_sgl_list = &phba->sli4_hba.lpfc_sgl_list;
911 	struct lpfc_sglq *sglq = NULL;
912 	struct lpfc_sglq *start_sglq = NULL;
913 	struct lpfc_scsi_buf *lpfc_cmd;
914 	struct lpfc_nodelist *ndlp;
915 	int found = 0;
916 
917 	if (piocbq->iocb_flag &  LPFC_IO_FCP) {
918 		lpfc_cmd = (struct lpfc_scsi_buf *) piocbq->context1;
919 		ndlp = lpfc_cmd->rdata->pnode;
920 	} else  if ((piocbq->iocb.ulpCommand == CMD_GEN_REQUEST64_CR) &&
921 			!(piocbq->iocb_flag & LPFC_IO_LIBDFC)) {
922 		ndlp = piocbq->context_un.ndlp;
923 	} else  if (piocbq->iocb_flag & LPFC_IO_LIBDFC) {
924 		if (piocbq->iocb_flag & LPFC_IO_LOOPBACK)
925 			ndlp = NULL;
926 		else
927 			ndlp = piocbq->context_un.ndlp;
928 	} else {
929 		ndlp = piocbq->context1;
930 	}
931 
932 	list_remove_head(lpfc_sgl_list, sglq, struct lpfc_sglq, list);
933 	start_sglq = sglq;
934 	while (!found) {
935 		if (!sglq)
936 			return NULL;
937 		if (lpfc_test_rrq_active(phba, ndlp, sglq->sli4_lxritag)) {
938 			/* This xri has an rrq outstanding for this DID.
939 			 * put it back in the list and get another xri.
940 			 */
941 			list_add_tail(&sglq->list, lpfc_sgl_list);
942 			sglq = NULL;
943 			list_remove_head(lpfc_sgl_list, sglq,
944 						struct lpfc_sglq, list);
945 			if (sglq == start_sglq) {
946 				sglq = NULL;
947 				break;
948 			} else
949 				continue;
950 		}
951 		sglq->ndlp = ndlp;
952 		found = 1;
953 		phba->sli4_hba.lpfc_sglq_active_list[sglq->sli4_lxritag] = sglq;
954 		sglq->state = SGL_ALLOCATED;
955 	}
956 	return sglq;
957 }
958 
959 /**
960  * lpfc_sli_get_iocbq - Allocates an iocb object from iocb pool
961  * @phba: Pointer to HBA context object.
962  *
963  * This function is called with no lock held. This function
964  * allocates a new driver iocb object from the iocb pool. If the
965  * allocation is successful, it returns pointer to the newly
966  * allocated iocb object else it returns NULL.
967  **/
968 struct lpfc_iocbq *
969 lpfc_sli_get_iocbq(struct lpfc_hba *phba)
970 {
971 	struct lpfc_iocbq * iocbq = NULL;
972 	unsigned long iflags;
973 
974 	spin_lock_irqsave(&phba->hbalock, iflags);
975 	iocbq = __lpfc_sli_get_iocbq(phba);
976 	spin_unlock_irqrestore(&phba->hbalock, iflags);
977 	return iocbq;
978 }
979 
980 /**
981  * __lpfc_sli_release_iocbq_s4 - Release iocb to the iocb pool
982  * @phba: Pointer to HBA context object.
983  * @iocbq: Pointer to driver iocb object.
984  *
985  * This function is called with hbalock held to release driver
986  * iocb object to the iocb pool. The iotag in the iocb object
987  * does not change for each use of the iocb object. This function
988  * clears all other fields of the iocb object when it is freed.
989  * The sqlq structure that holds the xritag and phys and virtual
990  * mappings for the scatter gather list is retrieved from the
991  * active array of sglq. The get of the sglq pointer also clears
992  * the entry in the array. If the status of the IO indiactes that
993  * this IO was aborted then the sglq entry it put on the
994  * lpfc_abts_els_sgl_list until the CQ_ABORTED_XRI is received. If the
995  * IO has good status or fails for any other reason then the sglq
996  * entry is added to the free list (lpfc_sgl_list).
997  **/
998 static void
999 __lpfc_sli_release_iocbq_s4(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
1000 {
1001 	struct lpfc_sglq *sglq;
1002 	size_t start_clean = offsetof(struct lpfc_iocbq, iocb);
1003 	unsigned long iflag = 0;
1004 	struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
1005 
1006 	if (iocbq->sli4_xritag == NO_XRI)
1007 		sglq = NULL;
1008 	else
1009 		sglq = __lpfc_clear_active_sglq(phba, iocbq->sli4_lxritag);
1010 
1011 
1012 	if (sglq)  {
1013 		if ((iocbq->iocb_flag & LPFC_EXCHANGE_BUSY) &&
1014 			(sglq->state != SGL_XRI_ABORTED)) {
1015 			spin_lock_irqsave(&phba->sli4_hba.abts_sgl_list_lock,
1016 					iflag);
1017 			list_add(&sglq->list,
1018 				&phba->sli4_hba.lpfc_abts_els_sgl_list);
1019 			spin_unlock_irqrestore(
1020 				&phba->sli4_hba.abts_sgl_list_lock, iflag);
1021 		} else {
1022 			spin_lock_irqsave(&pring->ring_lock, iflag);
1023 			sglq->state = SGL_FREED;
1024 			sglq->ndlp = NULL;
1025 			list_add_tail(&sglq->list,
1026 				&phba->sli4_hba.lpfc_sgl_list);
1027 			spin_unlock_irqrestore(&pring->ring_lock, iflag);
1028 
1029 			/* Check if TXQ queue needs to be serviced */
1030 			if (!list_empty(&pring->txq))
1031 				lpfc_worker_wake_up(phba);
1032 		}
1033 	}
1034 
1035 
1036 	/*
1037 	 * Clean all volatile data fields, preserve iotag and node struct.
1038 	 */
1039 	memset((char *)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean);
1040 	iocbq->sli4_lxritag = NO_XRI;
1041 	iocbq->sli4_xritag = NO_XRI;
1042 	list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
1043 }
1044 
1045 
1046 /**
1047  * __lpfc_sli_release_iocbq_s3 - Release iocb to the iocb pool
1048  * @phba: Pointer to HBA context object.
1049  * @iocbq: Pointer to driver iocb object.
1050  *
1051  * This function is called with hbalock held to release driver
1052  * iocb object to the iocb pool. The iotag in the iocb object
1053  * does not change for each use of the iocb object. This function
1054  * clears all other fields of the iocb object when it is freed.
1055  **/
1056 static void
1057 __lpfc_sli_release_iocbq_s3(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
1058 {
1059 	size_t start_clean = offsetof(struct lpfc_iocbq, iocb);
1060 
1061 
1062 	/*
1063 	 * Clean all volatile data fields, preserve iotag and node struct.
1064 	 */
1065 	memset((char*)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean);
1066 	iocbq->sli4_xritag = NO_XRI;
1067 	list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
1068 }
1069 
1070 /**
1071  * __lpfc_sli_release_iocbq - Release iocb to the iocb pool
1072  * @phba: Pointer to HBA context object.
1073  * @iocbq: Pointer to driver iocb object.
1074  *
1075  * This function is called with hbalock held to release driver
1076  * iocb object to the iocb pool. The iotag in the iocb object
1077  * does not change for each use of the iocb object. This function
1078  * clears all other fields of the iocb object when it is freed.
1079  **/
1080 static void
1081 __lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
1082 {
1083 	phba->__lpfc_sli_release_iocbq(phba, iocbq);
1084 	phba->iocb_cnt--;
1085 }
1086 
1087 /**
1088  * lpfc_sli_release_iocbq - Release iocb to the iocb pool
1089  * @phba: Pointer to HBA context object.
1090  * @iocbq: Pointer to driver iocb object.
1091  *
1092  * This function is called with no lock held to release the iocb to
1093  * iocb pool.
1094  **/
1095 void
1096 lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
1097 {
1098 	unsigned long iflags;
1099 
1100 	/*
1101 	 * Clean all volatile data fields, preserve iotag and node struct.
1102 	 */
1103 	spin_lock_irqsave(&phba->hbalock, iflags);
1104 	__lpfc_sli_release_iocbq(phba, iocbq);
1105 	spin_unlock_irqrestore(&phba->hbalock, iflags);
1106 }
1107 
1108 /**
1109  * lpfc_sli_cancel_iocbs - Cancel all iocbs from a list.
1110  * @phba: Pointer to HBA context object.
1111  * @iocblist: List of IOCBs.
1112  * @ulpstatus: ULP status in IOCB command field.
1113  * @ulpWord4: ULP word-4 in IOCB command field.
1114  *
1115  * This function is called with a list of IOCBs to cancel. It cancels the IOCB
1116  * on the list by invoking the complete callback function associated with the
1117  * IOCB with the provided @ulpstatus and @ulpword4 set to the IOCB commond
1118  * fields.
1119  **/
1120 void
1121 lpfc_sli_cancel_iocbs(struct lpfc_hba *phba, struct list_head *iocblist,
1122 		      uint32_t ulpstatus, uint32_t ulpWord4)
1123 {
1124 	struct lpfc_iocbq *piocb;
1125 
1126 	while (!list_empty(iocblist)) {
1127 		list_remove_head(iocblist, piocb, struct lpfc_iocbq, list);
1128 		if (!piocb->iocb_cmpl)
1129 			lpfc_sli_release_iocbq(phba, piocb);
1130 		else {
1131 			piocb->iocb.ulpStatus = ulpstatus;
1132 			piocb->iocb.un.ulpWord[4] = ulpWord4;
1133 			(piocb->iocb_cmpl) (phba, piocb, piocb);
1134 		}
1135 	}
1136 	return;
1137 }
1138 
1139 /**
1140  * lpfc_sli_iocb_cmd_type - Get the iocb type
1141  * @iocb_cmnd: iocb command code.
1142  *
1143  * This function is called by ring event handler function to get the iocb type.
1144  * This function translates the iocb command to an iocb command type used to
1145  * decide the final disposition of each completed IOCB.
1146  * The function returns
1147  * LPFC_UNKNOWN_IOCB if it is an unsupported iocb
1148  * LPFC_SOL_IOCB     if it is a solicited iocb completion
1149  * LPFC_ABORT_IOCB   if it is an abort iocb
1150  * LPFC_UNSOL_IOCB   if it is an unsolicited iocb
1151  *
1152  * The caller is not required to hold any lock.
1153  **/
1154 static lpfc_iocb_type
1155 lpfc_sli_iocb_cmd_type(uint8_t iocb_cmnd)
1156 {
1157 	lpfc_iocb_type type = LPFC_UNKNOWN_IOCB;
1158 
1159 	if (iocb_cmnd > CMD_MAX_IOCB_CMD)
1160 		return 0;
1161 
1162 	switch (iocb_cmnd) {
1163 	case CMD_XMIT_SEQUENCE_CR:
1164 	case CMD_XMIT_SEQUENCE_CX:
1165 	case CMD_XMIT_BCAST_CN:
1166 	case CMD_XMIT_BCAST_CX:
1167 	case CMD_ELS_REQUEST_CR:
1168 	case CMD_ELS_REQUEST_CX:
1169 	case CMD_CREATE_XRI_CR:
1170 	case CMD_CREATE_XRI_CX:
1171 	case CMD_GET_RPI_CN:
1172 	case CMD_XMIT_ELS_RSP_CX:
1173 	case CMD_GET_RPI_CR:
1174 	case CMD_FCP_IWRITE_CR:
1175 	case CMD_FCP_IWRITE_CX:
1176 	case CMD_FCP_IREAD_CR:
1177 	case CMD_FCP_IREAD_CX:
1178 	case CMD_FCP_ICMND_CR:
1179 	case CMD_FCP_ICMND_CX:
1180 	case CMD_FCP_TSEND_CX:
1181 	case CMD_FCP_TRSP_CX:
1182 	case CMD_FCP_TRECEIVE_CX:
1183 	case CMD_FCP_AUTO_TRSP_CX:
1184 	case CMD_ADAPTER_MSG:
1185 	case CMD_ADAPTER_DUMP:
1186 	case CMD_XMIT_SEQUENCE64_CR:
1187 	case CMD_XMIT_SEQUENCE64_CX:
1188 	case CMD_XMIT_BCAST64_CN:
1189 	case CMD_XMIT_BCAST64_CX:
1190 	case CMD_ELS_REQUEST64_CR:
1191 	case CMD_ELS_REQUEST64_CX:
1192 	case CMD_FCP_IWRITE64_CR:
1193 	case CMD_FCP_IWRITE64_CX:
1194 	case CMD_FCP_IREAD64_CR:
1195 	case CMD_FCP_IREAD64_CX:
1196 	case CMD_FCP_ICMND64_CR:
1197 	case CMD_FCP_ICMND64_CX:
1198 	case CMD_FCP_TSEND64_CX:
1199 	case CMD_FCP_TRSP64_CX:
1200 	case CMD_FCP_TRECEIVE64_CX:
1201 	case CMD_GEN_REQUEST64_CR:
1202 	case CMD_GEN_REQUEST64_CX:
1203 	case CMD_XMIT_ELS_RSP64_CX:
1204 	case DSSCMD_IWRITE64_CR:
1205 	case DSSCMD_IWRITE64_CX:
1206 	case DSSCMD_IREAD64_CR:
1207 	case DSSCMD_IREAD64_CX:
1208 		type = LPFC_SOL_IOCB;
1209 		break;
1210 	case CMD_ABORT_XRI_CN:
1211 	case CMD_ABORT_XRI_CX:
1212 	case CMD_CLOSE_XRI_CN:
1213 	case CMD_CLOSE_XRI_CX:
1214 	case CMD_XRI_ABORTED_CX:
1215 	case CMD_ABORT_MXRI64_CN:
1216 	case CMD_XMIT_BLS_RSP64_CX:
1217 		type = LPFC_ABORT_IOCB;
1218 		break;
1219 	case CMD_RCV_SEQUENCE_CX:
1220 	case CMD_RCV_ELS_REQ_CX:
1221 	case CMD_RCV_SEQUENCE64_CX:
1222 	case CMD_RCV_ELS_REQ64_CX:
1223 	case CMD_ASYNC_STATUS:
1224 	case CMD_IOCB_RCV_SEQ64_CX:
1225 	case CMD_IOCB_RCV_ELS64_CX:
1226 	case CMD_IOCB_RCV_CONT64_CX:
1227 	case CMD_IOCB_RET_XRI64_CX:
1228 		type = LPFC_UNSOL_IOCB;
1229 		break;
1230 	case CMD_IOCB_XMIT_MSEQ64_CR:
1231 	case CMD_IOCB_XMIT_MSEQ64_CX:
1232 	case CMD_IOCB_RCV_SEQ_LIST64_CX:
1233 	case CMD_IOCB_RCV_ELS_LIST64_CX:
1234 	case CMD_IOCB_CLOSE_EXTENDED_CN:
1235 	case CMD_IOCB_ABORT_EXTENDED_CN:
1236 	case CMD_IOCB_RET_HBQE64_CN:
1237 	case CMD_IOCB_FCP_IBIDIR64_CR:
1238 	case CMD_IOCB_FCP_IBIDIR64_CX:
1239 	case CMD_IOCB_FCP_ITASKMGT64_CX:
1240 	case CMD_IOCB_LOGENTRY_CN:
1241 	case CMD_IOCB_LOGENTRY_ASYNC_CN:
1242 		printk("%s - Unhandled SLI-3 Command x%x\n",
1243 				__func__, iocb_cmnd);
1244 		type = LPFC_UNKNOWN_IOCB;
1245 		break;
1246 	default:
1247 		type = LPFC_UNKNOWN_IOCB;
1248 		break;
1249 	}
1250 
1251 	return type;
1252 }
1253 
1254 /**
1255  * lpfc_sli_ring_map - Issue config_ring mbox for all rings
1256  * @phba: Pointer to HBA context object.
1257  *
1258  * This function is called from SLI initialization code
1259  * to configure every ring of the HBA's SLI interface. The
1260  * caller is not required to hold any lock. This function issues
1261  * a config_ring mailbox command for each ring.
1262  * This function returns zero if successful else returns a negative
1263  * error code.
1264  **/
1265 static int
1266 lpfc_sli_ring_map(struct lpfc_hba *phba)
1267 {
1268 	struct lpfc_sli *psli = &phba->sli;
1269 	LPFC_MBOXQ_t *pmb;
1270 	MAILBOX_t *pmbox;
1271 	int i, rc, ret = 0;
1272 
1273 	pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1274 	if (!pmb)
1275 		return -ENOMEM;
1276 	pmbox = &pmb->u.mb;
1277 	phba->link_state = LPFC_INIT_MBX_CMDS;
1278 	for (i = 0; i < psli->num_rings; i++) {
1279 		lpfc_config_ring(phba, i, pmb);
1280 		rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
1281 		if (rc != MBX_SUCCESS) {
1282 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1283 					"0446 Adapter failed to init (%d), "
1284 					"mbxCmd x%x CFG_RING, mbxStatus x%x, "
1285 					"ring %d\n",
1286 					rc, pmbox->mbxCommand,
1287 					pmbox->mbxStatus, i);
1288 			phba->link_state = LPFC_HBA_ERROR;
1289 			ret = -ENXIO;
1290 			break;
1291 		}
1292 	}
1293 	mempool_free(pmb, phba->mbox_mem_pool);
1294 	return ret;
1295 }
1296 
1297 /**
1298  * lpfc_sli_ringtxcmpl_put - Adds new iocb to the txcmplq
1299  * @phba: Pointer to HBA context object.
1300  * @pring: Pointer to driver SLI ring object.
1301  * @piocb: Pointer to the driver iocb object.
1302  *
1303  * This function is called with hbalock held. The function adds the
1304  * new iocb to txcmplq of the given ring. This function always returns
1305  * 0. If this function is called for ELS ring, this function checks if
1306  * there is a vport associated with the ELS command. This function also
1307  * starts els_tmofunc timer if this is an ELS command.
1308  **/
1309 static int
1310 lpfc_sli_ringtxcmpl_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1311 			struct lpfc_iocbq *piocb)
1312 {
1313 	list_add_tail(&piocb->list, &pring->txcmplq);
1314 	piocb->iocb_flag |= LPFC_IO_ON_TXCMPLQ;
1315 
1316 	if ((unlikely(pring->ringno == LPFC_ELS_RING)) &&
1317 	   (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
1318 	   (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN) &&
1319 	 (!(piocb->vport->load_flag & FC_UNLOADING))) {
1320 		if (!piocb->vport)
1321 			BUG();
1322 		else
1323 			mod_timer(&piocb->vport->els_tmofunc,
1324 				jiffies +
1325 				msecs_to_jiffies(1000 * (phba->fc_ratov << 1)));
1326 	}
1327 
1328 
1329 	return 0;
1330 }
1331 
1332 /**
1333  * lpfc_sli_ringtx_get - Get first element of the txq
1334  * @phba: Pointer to HBA context object.
1335  * @pring: Pointer to driver SLI ring object.
1336  *
1337  * This function is called with hbalock held to get next
1338  * iocb in txq of the given ring. If there is any iocb in
1339  * the txq, the function returns first iocb in the list after
1340  * removing the iocb from the list, else it returns NULL.
1341  **/
1342 struct lpfc_iocbq *
1343 lpfc_sli_ringtx_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1344 {
1345 	struct lpfc_iocbq *cmd_iocb;
1346 
1347 	list_remove_head((&pring->txq), cmd_iocb, struct lpfc_iocbq, list);
1348 	return cmd_iocb;
1349 }
1350 
1351 /**
1352  * lpfc_sli_next_iocb_slot - Get next iocb slot in the ring
1353  * @phba: Pointer to HBA context object.
1354  * @pring: Pointer to driver SLI ring object.
1355  *
1356  * This function is called with hbalock held and the caller must post the
1357  * iocb without releasing the lock. If the caller releases the lock,
1358  * iocb slot returned by the function is not guaranteed to be available.
1359  * The function returns pointer to the next available iocb slot if there
1360  * is available slot in the ring, else it returns NULL.
1361  * If the get index of the ring is ahead of the put index, the function
1362  * will post an error attention event to the worker thread to take the
1363  * HBA to offline state.
1364  **/
1365 static IOCB_t *
1366 lpfc_sli_next_iocb_slot (struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1367 {
1368 	struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1369 	uint32_t  max_cmd_idx = pring->sli.sli3.numCiocb;
1370 	if ((pring->sli.sli3.next_cmdidx == pring->sli.sli3.cmdidx) &&
1371 	   (++pring->sli.sli3.next_cmdidx >= max_cmd_idx))
1372 		pring->sli.sli3.next_cmdidx = 0;
1373 
1374 	if (unlikely(pring->sli.sli3.local_getidx ==
1375 		pring->sli.sli3.next_cmdidx)) {
1376 
1377 		pring->sli.sli3.local_getidx = le32_to_cpu(pgp->cmdGetInx);
1378 
1379 		if (unlikely(pring->sli.sli3.local_getidx >= max_cmd_idx)) {
1380 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1381 					"0315 Ring %d issue: portCmdGet %d "
1382 					"is bigger than cmd ring %d\n",
1383 					pring->ringno,
1384 					pring->sli.sli3.local_getidx,
1385 					max_cmd_idx);
1386 
1387 			phba->link_state = LPFC_HBA_ERROR;
1388 			/*
1389 			 * All error attention handlers are posted to
1390 			 * worker thread
1391 			 */
1392 			phba->work_ha |= HA_ERATT;
1393 			phba->work_hs = HS_FFER3;
1394 
1395 			lpfc_worker_wake_up(phba);
1396 
1397 			return NULL;
1398 		}
1399 
1400 		if (pring->sli.sli3.local_getidx == pring->sli.sli3.next_cmdidx)
1401 			return NULL;
1402 	}
1403 
1404 	return lpfc_cmd_iocb(phba, pring);
1405 }
1406 
1407 /**
1408  * lpfc_sli_next_iotag - Get an iotag for the iocb
1409  * @phba: Pointer to HBA context object.
1410  * @iocbq: Pointer to driver iocb object.
1411  *
1412  * This function gets an iotag for the iocb. If there is no unused iotag and
1413  * the iocbq_lookup_len < 0xffff, this function allocates a bigger iotag_lookup
1414  * array and assigns a new iotag.
1415  * The function returns the allocated iotag if successful, else returns zero.
1416  * Zero is not a valid iotag.
1417  * The caller is not required to hold any lock.
1418  **/
1419 uint16_t
1420 lpfc_sli_next_iotag(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
1421 {
1422 	struct lpfc_iocbq **new_arr;
1423 	struct lpfc_iocbq **old_arr;
1424 	size_t new_len;
1425 	struct lpfc_sli *psli = &phba->sli;
1426 	uint16_t iotag;
1427 
1428 	spin_lock_irq(&phba->hbalock);
1429 	iotag = psli->last_iotag;
1430 	if(++iotag < psli->iocbq_lookup_len) {
1431 		psli->last_iotag = iotag;
1432 		psli->iocbq_lookup[iotag] = iocbq;
1433 		spin_unlock_irq(&phba->hbalock);
1434 		iocbq->iotag = iotag;
1435 		return iotag;
1436 	} else if (psli->iocbq_lookup_len < (0xffff
1437 					   - LPFC_IOCBQ_LOOKUP_INCREMENT)) {
1438 		new_len = psli->iocbq_lookup_len + LPFC_IOCBQ_LOOKUP_INCREMENT;
1439 		spin_unlock_irq(&phba->hbalock);
1440 		new_arr = kzalloc(new_len * sizeof (struct lpfc_iocbq *),
1441 				  GFP_KERNEL);
1442 		if (new_arr) {
1443 			spin_lock_irq(&phba->hbalock);
1444 			old_arr = psli->iocbq_lookup;
1445 			if (new_len <= psli->iocbq_lookup_len) {
1446 				/* highly unprobable case */
1447 				kfree(new_arr);
1448 				iotag = psli->last_iotag;
1449 				if(++iotag < psli->iocbq_lookup_len) {
1450 					psli->last_iotag = iotag;
1451 					psli->iocbq_lookup[iotag] = iocbq;
1452 					spin_unlock_irq(&phba->hbalock);
1453 					iocbq->iotag = iotag;
1454 					return iotag;
1455 				}
1456 				spin_unlock_irq(&phba->hbalock);
1457 				return 0;
1458 			}
1459 			if (psli->iocbq_lookup)
1460 				memcpy(new_arr, old_arr,
1461 				       ((psli->last_iotag  + 1) *
1462 					sizeof (struct lpfc_iocbq *)));
1463 			psli->iocbq_lookup = new_arr;
1464 			psli->iocbq_lookup_len = new_len;
1465 			psli->last_iotag = iotag;
1466 			psli->iocbq_lookup[iotag] = iocbq;
1467 			spin_unlock_irq(&phba->hbalock);
1468 			iocbq->iotag = iotag;
1469 			kfree(old_arr);
1470 			return iotag;
1471 		}
1472 	} else
1473 		spin_unlock_irq(&phba->hbalock);
1474 
1475 	lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1476 			"0318 Failed to allocate IOTAG.last IOTAG is %d\n",
1477 			psli->last_iotag);
1478 
1479 	return 0;
1480 }
1481 
1482 /**
1483  * lpfc_sli_submit_iocb - Submit an iocb to the firmware
1484  * @phba: Pointer to HBA context object.
1485  * @pring: Pointer to driver SLI ring object.
1486  * @iocb: Pointer to iocb slot in the ring.
1487  * @nextiocb: Pointer to driver iocb object which need to be
1488  *            posted to firmware.
1489  *
1490  * This function is called with hbalock held to post a new iocb to
1491  * the firmware. This function copies the new iocb to ring iocb slot and
1492  * updates the ring pointers. It adds the new iocb to txcmplq if there is
1493  * a completion call back for this iocb else the function will free the
1494  * iocb object.
1495  **/
1496 static void
1497 lpfc_sli_submit_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1498 		IOCB_t *iocb, struct lpfc_iocbq *nextiocb)
1499 {
1500 	/*
1501 	 * Set up an iotag
1502 	 */
1503 	nextiocb->iocb.ulpIoTag = (nextiocb->iocb_cmpl) ? nextiocb->iotag : 0;
1504 
1505 
1506 	if (pring->ringno == LPFC_ELS_RING) {
1507 		lpfc_debugfs_slow_ring_trc(phba,
1508 			"IOCB cmd ring:   wd4:x%08x wd6:x%08x wd7:x%08x",
1509 			*(((uint32_t *) &nextiocb->iocb) + 4),
1510 			*(((uint32_t *) &nextiocb->iocb) + 6),
1511 			*(((uint32_t *) &nextiocb->iocb) + 7));
1512 	}
1513 
1514 	/*
1515 	 * Issue iocb command to adapter
1516 	 */
1517 	lpfc_sli_pcimem_bcopy(&nextiocb->iocb, iocb, phba->iocb_cmd_size);
1518 	wmb();
1519 	pring->stats.iocb_cmd++;
1520 
1521 	/*
1522 	 * If there is no completion routine to call, we can release the
1523 	 * IOCB buffer back right now. For IOCBs, like QUE_RING_BUF,
1524 	 * that have no rsp ring completion, iocb_cmpl MUST be NULL.
1525 	 */
1526 	if (nextiocb->iocb_cmpl)
1527 		lpfc_sli_ringtxcmpl_put(phba, pring, nextiocb);
1528 	else
1529 		__lpfc_sli_release_iocbq(phba, nextiocb);
1530 
1531 	/*
1532 	 * Let the HBA know what IOCB slot will be the next one the
1533 	 * driver will put a command into.
1534 	 */
1535 	pring->sli.sli3.cmdidx = pring->sli.sli3.next_cmdidx;
1536 	writel(pring->sli.sli3.cmdidx, &phba->host_gp[pring->ringno].cmdPutInx);
1537 }
1538 
1539 /**
1540  * lpfc_sli_update_full_ring - Update the chip attention register
1541  * @phba: Pointer to HBA context object.
1542  * @pring: Pointer to driver SLI ring object.
1543  *
1544  * The caller is not required to hold any lock for calling this function.
1545  * This function updates the chip attention bits for the ring to inform firmware
1546  * that there are pending work to be done for this ring and requests an
1547  * interrupt when there is space available in the ring. This function is
1548  * called when the driver is unable to post more iocbs to the ring due
1549  * to unavailability of space in the ring.
1550  **/
1551 static void
1552 lpfc_sli_update_full_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1553 {
1554 	int ringno = pring->ringno;
1555 
1556 	pring->flag |= LPFC_CALL_RING_AVAILABLE;
1557 
1558 	wmb();
1559 
1560 	/*
1561 	 * Set ring 'ringno' to SET R0CE_REQ in Chip Att register.
1562 	 * The HBA will tell us when an IOCB entry is available.
1563 	 */
1564 	writel((CA_R0ATT|CA_R0CE_REQ) << (ringno*4), phba->CAregaddr);
1565 	readl(phba->CAregaddr); /* flush */
1566 
1567 	pring->stats.iocb_cmd_full++;
1568 }
1569 
1570 /**
1571  * lpfc_sli_update_ring - Update chip attention register
1572  * @phba: Pointer to HBA context object.
1573  * @pring: Pointer to driver SLI ring object.
1574  *
1575  * This function updates the chip attention register bit for the
1576  * given ring to inform HBA that there is more work to be done
1577  * in this ring. The caller is not required to hold any lock.
1578  **/
1579 static void
1580 lpfc_sli_update_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1581 {
1582 	int ringno = pring->ringno;
1583 
1584 	/*
1585 	 * Tell the HBA that there is work to do in this ring.
1586 	 */
1587 	if (!(phba->sli3_options & LPFC_SLI3_CRP_ENABLED)) {
1588 		wmb();
1589 		writel(CA_R0ATT << (ringno * 4), phba->CAregaddr);
1590 		readl(phba->CAregaddr); /* flush */
1591 	}
1592 }
1593 
1594 /**
1595  * lpfc_sli_resume_iocb - Process iocbs in the txq
1596  * @phba: Pointer to HBA context object.
1597  * @pring: Pointer to driver SLI ring object.
1598  *
1599  * This function is called with hbalock held to post pending iocbs
1600  * in the txq to the firmware. This function is called when driver
1601  * detects space available in the ring.
1602  **/
1603 static void
1604 lpfc_sli_resume_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1605 {
1606 	IOCB_t *iocb;
1607 	struct lpfc_iocbq *nextiocb;
1608 
1609 	/*
1610 	 * Check to see if:
1611 	 *  (a) there is anything on the txq to send
1612 	 *  (b) link is up
1613 	 *  (c) link attention events can be processed (fcp ring only)
1614 	 *  (d) IOCB processing is not blocked by the outstanding mbox command.
1615 	 */
1616 
1617 	if (lpfc_is_link_up(phba) &&
1618 	    (!list_empty(&pring->txq)) &&
1619 	    (pring->ringno != phba->sli.fcp_ring ||
1620 	     phba->sli.sli_flag & LPFC_PROCESS_LA)) {
1621 
1622 		while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
1623 		       (nextiocb = lpfc_sli_ringtx_get(phba, pring)))
1624 			lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
1625 
1626 		if (iocb)
1627 			lpfc_sli_update_ring(phba, pring);
1628 		else
1629 			lpfc_sli_update_full_ring(phba, pring);
1630 	}
1631 
1632 	return;
1633 }
1634 
1635 /**
1636  * lpfc_sli_next_hbq_slot - Get next hbq entry for the HBQ
1637  * @phba: Pointer to HBA context object.
1638  * @hbqno: HBQ number.
1639  *
1640  * This function is called with hbalock held to get the next
1641  * available slot for the given HBQ. If there is free slot
1642  * available for the HBQ it will return pointer to the next available
1643  * HBQ entry else it will return NULL.
1644  **/
1645 static struct lpfc_hbq_entry *
1646 lpfc_sli_next_hbq_slot(struct lpfc_hba *phba, uint32_t hbqno)
1647 {
1648 	struct hbq_s *hbqp = &phba->hbqs[hbqno];
1649 
1650 	if (hbqp->next_hbqPutIdx == hbqp->hbqPutIdx &&
1651 	    ++hbqp->next_hbqPutIdx >= hbqp->entry_count)
1652 		hbqp->next_hbqPutIdx = 0;
1653 
1654 	if (unlikely(hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)) {
1655 		uint32_t raw_index = phba->hbq_get[hbqno];
1656 		uint32_t getidx = le32_to_cpu(raw_index);
1657 
1658 		hbqp->local_hbqGetIdx = getidx;
1659 
1660 		if (unlikely(hbqp->local_hbqGetIdx >= hbqp->entry_count)) {
1661 			lpfc_printf_log(phba, KERN_ERR,
1662 					LOG_SLI | LOG_VPORT,
1663 					"1802 HBQ %d: local_hbqGetIdx "
1664 					"%u is > than hbqp->entry_count %u\n",
1665 					hbqno, hbqp->local_hbqGetIdx,
1666 					hbqp->entry_count);
1667 
1668 			phba->link_state = LPFC_HBA_ERROR;
1669 			return NULL;
1670 		}
1671 
1672 		if (hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)
1673 			return NULL;
1674 	}
1675 
1676 	return (struct lpfc_hbq_entry *) phba->hbqs[hbqno].hbq_virt +
1677 			hbqp->hbqPutIdx;
1678 }
1679 
1680 /**
1681  * lpfc_sli_hbqbuf_free_all - Free all the hbq buffers
1682  * @phba: Pointer to HBA context object.
1683  *
1684  * This function is called with no lock held to free all the
1685  * hbq buffers while uninitializing the SLI interface. It also
1686  * frees the HBQ buffers returned by the firmware but not yet
1687  * processed by the upper layers.
1688  **/
1689 void
1690 lpfc_sli_hbqbuf_free_all(struct lpfc_hba *phba)
1691 {
1692 	struct lpfc_dmabuf *dmabuf, *next_dmabuf;
1693 	struct hbq_dmabuf *hbq_buf;
1694 	unsigned long flags;
1695 	int i, hbq_count;
1696 	uint32_t hbqno;
1697 
1698 	hbq_count = lpfc_sli_hbq_count();
1699 	/* Return all memory used by all HBQs */
1700 	spin_lock_irqsave(&phba->hbalock, flags);
1701 	for (i = 0; i < hbq_count; ++i) {
1702 		list_for_each_entry_safe(dmabuf, next_dmabuf,
1703 				&phba->hbqs[i].hbq_buffer_list, list) {
1704 			hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
1705 			list_del(&hbq_buf->dbuf.list);
1706 			(phba->hbqs[i].hbq_free_buffer)(phba, hbq_buf);
1707 		}
1708 		phba->hbqs[i].buffer_count = 0;
1709 	}
1710 	/* Return all HBQ buffer that are in-fly */
1711 	list_for_each_entry_safe(dmabuf, next_dmabuf, &phba->rb_pend_list,
1712 				 list) {
1713 		hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
1714 		list_del(&hbq_buf->dbuf.list);
1715 		if (hbq_buf->tag == -1) {
1716 			(phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
1717 				(phba, hbq_buf);
1718 		} else {
1719 			hbqno = hbq_buf->tag >> 16;
1720 			if (hbqno >= LPFC_MAX_HBQS)
1721 				(phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
1722 					(phba, hbq_buf);
1723 			else
1724 				(phba->hbqs[hbqno].hbq_free_buffer)(phba,
1725 					hbq_buf);
1726 		}
1727 	}
1728 
1729 	/* Mark the HBQs not in use */
1730 	phba->hbq_in_use = 0;
1731 	spin_unlock_irqrestore(&phba->hbalock, flags);
1732 }
1733 
1734 /**
1735  * lpfc_sli_hbq_to_firmware - Post the hbq buffer to firmware
1736  * @phba: Pointer to HBA context object.
1737  * @hbqno: HBQ number.
1738  * @hbq_buf: Pointer to HBQ buffer.
1739  *
1740  * This function is called with the hbalock held to post a
1741  * hbq buffer to the firmware. If the function finds an empty
1742  * slot in the HBQ, it will post the buffer. The function will return
1743  * pointer to the hbq entry if it successfully post the buffer
1744  * else it will return NULL.
1745  **/
1746 static int
1747 lpfc_sli_hbq_to_firmware(struct lpfc_hba *phba, uint32_t hbqno,
1748 			 struct hbq_dmabuf *hbq_buf)
1749 {
1750 	return phba->lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buf);
1751 }
1752 
1753 /**
1754  * lpfc_sli_hbq_to_firmware_s3 - Post the hbq buffer to SLI3 firmware
1755  * @phba: Pointer to HBA context object.
1756  * @hbqno: HBQ number.
1757  * @hbq_buf: Pointer to HBQ buffer.
1758  *
1759  * This function is called with the hbalock held to post a hbq buffer to the
1760  * firmware. If the function finds an empty slot in the HBQ, it will post the
1761  * buffer and place it on the hbq_buffer_list. The function will return zero if
1762  * it successfully post the buffer else it will return an error.
1763  **/
1764 static int
1765 lpfc_sli_hbq_to_firmware_s3(struct lpfc_hba *phba, uint32_t hbqno,
1766 			    struct hbq_dmabuf *hbq_buf)
1767 {
1768 	struct lpfc_hbq_entry *hbqe;
1769 	dma_addr_t physaddr = hbq_buf->dbuf.phys;
1770 
1771 	/* Get next HBQ entry slot to use */
1772 	hbqe = lpfc_sli_next_hbq_slot(phba, hbqno);
1773 	if (hbqe) {
1774 		struct hbq_s *hbqp = &phba->hbqs[hbqno];
1775 
1776 		hbqe->bde.addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
1777 		hbqe->bde.addrLow  = le32_to_cpu(putPaddrLow(physaddr));
1778 		hbqe->bde.tus.f.bdeSize = hbq_buf->size;
1779 		hbqe->bde.tus.f.bdeFlags = 0;
1780 		hbqe->bde.tus.w = le32_to_cpu(hbqe->bde.tus.w);
1781 		hbqe->buffer_tag = le32_to_cpu(hbq_buf->tag);
1782 				/* Sync SLIM */
1783 		hbqp->hbqPutIdx = hbqp->next_hbqPutIdx;
1784 		writel(hbqp->hbqPutIdx, phba->hbq_put + hbqno);
1785 				/* flush */
1786 		readl(phba->hbq_put + hbqno);
1787 		list_add_tail(&hbq_buf->dbuf.list, &hbqp->hbq_buffer_list);
1788 		return 0;
1789 	} else
1790 		return -ENOMEM;
1791 }
1792 
1793 /**
1794  * lpfc_sli_hbq_to_firmware_s4 - Post the hbq buffer to SLI4 firmware
1795  * @phba: Pointer to HBA context object.
1796  * @hbqno: HBQ number.
1797  * @hbq_buf: Pointer to HBQ buffer.
1798  *
1799  * This function is called with the hbalock held to post an RQE to the SLI4
1800  * firmware. If able to post the RQE to the RQ it will queue the hbq entry to
1801  * the hbq_buffer_list and return zero, otherwise it will return an error.
1802  **/
1803 static int
1804 lpfc_sli_hbq_to_firmware_s4(struct lpfc_hba *phba, uint32_t hbqno,
1805 			    struct hbq_dmabuf *hbq_buf)
1806 {
1807 	int rc;
1808 	struct lpfc_rqe hrqe;
1809 	struct lpfc_rqe drqe;
1810 
1811 	hrqe.address_lo = putPaddrLow(hbq_buf->hbuf.phys);
1812 	hrqe.address_hi = putPaddrHigh(hbq_buf->hbuf.phys);
1813 	drqe.address_lo = putPaddrLow(hbq_buf->dbuf.phys);
1814 	drqe.address_hi = putPaddrHigh(hbq_buf->dbuf.phys);
1815 	rc = lpfc_sli4_rq_put(phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq,
1816 			      &hrqe, &drqe);
1817 	if (rc < 0)
1818 		return rc;
1819 	hbq_buf->tag = rc;
1820 	list_add_tail(&hbq_buf->dbuf.list, &phba->hbqs[hbqno].hbq_buffer_list);
1821 	return 0;
1822 }
1823 
1824 /* HBQ for ELS and CT traffic. */
1825 static struct lpfc_hbq_init lpfc_els_hbq = {
1826 	.rn = 1,
1827 	.entry_count = 256,
1828 	.mask_count = 0,
1829 	.profile = 0,
1830 	.ring_mask = (1 << LPFC_ELS_RING),
1831 	.buffer_count = 0,
1832 	.init_count = 40,
1833 	.add_count = 40,
1834 };
1835 
1836 /* HBQ for the extra ring if needed */
1837 static struct lpfc_hbq_init lpfc_extra_hbq = {
1838 	.rn = 1,
1839 	.entry_count = 200,
1840 	.mask_count = 0,
1841 	.profile = 0,
1842 	.ring_mask = (1 << LPFC_EXTRA_RING),
1843 	.buffer_count = 0,
1844 	.init_count = 0,
1845 	.add_count = 5,
1846 };
1847 
1848 /* Array of HBQs */
1849 struct lpfc_hbq_init *lpfc_hbq_defs[] = {
1850 	&lpfc_els_hbq,
1851 	&lpfc_extra_hbq,
1852 };
1853 
1854 /**
1855  * lpfc_sli_hbqbuf_fill_hbqs - Post more hbq buffers to HBQ
1856  * @phba: Pointer to HBA context object.
1857  * @hbqno: HBQ number.
1858  * @count: Number of HBQ buffers to be posted.
1859  *
1860  * This function is called with no lock held to post more hbq buffers to the
1861  * given HBQ. The function returns the number of HBQ buffers successfully
1862  * posted.
1863  **/
1864 static int
1865 lpfc_sli_hbqbuf_fill_hbqs(struct lpfc_hba *phba, uint32_t hbqno, uint32_t count)
1866 {
1867 	uint32_t i, posted = 0;
1868 	unsigned long flags;
1869 	struct hbq_dmabuf *hbq_buffer;
1870 	LIST_HEAD(hbq_buf_list);
1871 	if (!phba->hbqs[hbqno].hbq_alloc_buffer)
1872 		return 0;
1873 
1874 	if ((phba->hbqs[hbqno].buffer_count + count) >
1875 	    lpfc_hbq_defs[hbqno]->entry_count)
1876 		count = lpfc_hbq_defs[hbqno]->entry_count -
1877 					phba->hbqs[hbqno].buffer_count;
1878 	if (!count)
1879 		return 0;
1880 	/* Allocate HBQ entries */
1881 	for (i = 0; i < count; i++) {
1882 		hbq_buffer = (phba->hbqs[hbqno].hbq_alloc_buffer)(phba);
1883 		if (!hbq_buffer)
1884 			break;
1885 		list_add_tail(&hbq_buffer->dbuf.list, &hbq_buf_list);
1886 	}
1887 	/* Check whether HBQ is still in use */
1888 	spin_lock_irqsave(&phba->hbalock, flags);
1889 	if (!phba->hbq_in_use)
1890 		goto err;
1891 	while (!list_empty(&hbq_buf_list)) {
1892 		list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
1893 				 dbuf.list);
1894 		hbq_buffer->tag = (phba->hbqs[hbqno].buffer_count |
1895 				      (hbqno << 16));
1896 		if (!lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {
1897 			phba->hbqs[hbqno].buffer_count++;
1898 			posted++;
1899 		} else
1900 			(phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
1901 	}
1902 	spin_unlock_irqrestore(&phba->hbalock, flags);
1903 	return posted;
1904 err:
1905 	spin_unlock_irqrestore(&phba->hbalock, flags);
1906 	while (!list_empty(&hbq_buf_list)) {
1907 		list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
1908 				 dbuf.list);
1909 		(phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
1910 	}
1911 	return 0;
1912 }
1913 
1914 /**
1915  * lpfc_sli_hbqbuf_add_hbqs - Post more HBQ buffers to firmware
1916  * @phba: Pointer to HBA context object.
1917  * @qno: HBQ number.
1918  *
1919  * This function posts more buffers to the HBQ. This function
1920  * is called with no lock held. The function returns the number of HBQ entries
1921  * successfully allocated.
1922  **/
1923 int
1924 lpfc_sli_hbqbuf_add_hbqs(struct lpfc_hba *phba, uint32_t qno)
1925 {
1926 	if (phba->sli_rev == LPFC_SLI_REV4)
1927 		return 0;
1928 	else
1929 		return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
1930 					 lpfc_hbq_defs[qno]->add_count);
1931 }
1932 
1933 /**
1934  * lpfc_sli_hbqbuf_init_hbqs - Post initial buffers to the HBQ
1935  * @phba: Pointer to HBA context object.
1936  * @qno:  HBQ queue number.
1937  *
1938  * This function is called from SLI initialization code path with
1939  * no lock held to post initial HBQ buffers to firmware. The
1940  * function returns the number of HBQ entries successfully allocated.
1941  **/
1942 static int
1943 lpfc_sli_hbqbuf_init_hbqs(struct lpfc_hba *phba, uint32_t qno)
1944 {
1945 	if (phba->sli_rev == LPFC_SLI_REV4)
1946 		return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
1947 					lpfc_hbq_defs[qno]->entry_count);
1948 	else
1949 		return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
1950 					 lpfc_hbq_defs[qno]->init_count);
1951 }
1952 
1953 /**
1954  * lpfc_sli_hbqbuf_get - Remove the first hbq off of an hbq list
1955  * @phba: Pointer to HBA context object.
1956  * @hbqno: HBQ number.
1957  *
1958  * This function removes the first hbq buffer on an hbq list and returns a
1959  * pointer to that buffer. If it finds no buffers on the list it returns NULL.
1960  **/
1961 static struct hbq_dmabuf *
1962 lpfc_sli_hbqbuf_get(struct list_head *rb_list)
1963 {
1964 	struct lpfc_dmabuf *d_buf;
1965 
1966 	list_remove_head(rb_list, d_buf, struct lpfc_dmabuf, list);
1967 	if (!d_buf)
1968 		return NULL;
1969 	return container_of(d_buf, struct hbq_dmabuf, dbuf);
1970 }
1971 
1972 /**
1973  * lpfc_sli_hbqbuf_find - Find the hbq buffer associated with a tag
1974  * @phba: Pointer to HBA context object.
1975  * @tag: Tag of the hbq buffer.
1976  *
1977  * This function is called with hbalock held. This function searches
1978  * for the hbq buffer associated with the given tag in the hbq buffer
1979  * list. If it finds the hbq buffer, it returns the hbq_buffer other wise
1980  * it returns NULL.
1981  **/
1982 static struct hbq_dmabuf *
1983 lpfc_sli_hbqbuf_find(struct lpfc_hba *phba, uint32_t tag)
1984 {
1985 	struct lpfc_dmabuf *d_buf;
1986 	struct hbq_dmabuf *hbq_buf;
1987 	uint32_t hbqno;
1988 
1989 	hbqno = tag >> 16;
1990 	if (hbqno >= LPFC_MAX_HBQS)
1991 		return NULL;
1992 
1993 	spin_lock_irq(&phba->hbalock);
1994 	list_for_each_entry(d_buf, &phba->hbqs[hbqno].hbq_buffer_list, list) {
1995 		hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
1996 		if (hbq_buf->tag == tag) {
1997 			spin_unlock_irq(&phba->hbalock);
1998 			return hbq_buf;
1999 		}
2000 	}
2001 	spin_unlock_irq(&phba->hbalock);
2002 	lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_VPORT,
2003 			"1803 Bad hbq tag. Data: x%x x%x\n",
2004 			tag, phba->hbqs[tag >> 16].buffer_count);
2005 	return NULL;
2006 }
2007 
2008 /**
2009  * lpfc_sli_free_hbq - Give back the hbq buffer to firmware
2010  * @phba: Pointer to HBA context object.
2011  * @hbq_buffer: Pointer to HBQ buffer.
2012  *
2013  * This function is called with hbalock. This function gives back
2014  * the hbq buffer to firmware. If the HBQ does not have space to
2015  * post the buffer, it will free the buffer.
2016  **/
2017 void
2018 lpfc_sli_free_hbq(struct lpfc_hba *phba, struct hbq_dmabuf *hbq_buffer)
2019 {
2020 	uint32_t hbqno;
2021 
2022 	if (hbq_buffer) {
2023 		hbqno = hbq_buffer->tag >> 16;
2024 		if (lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer))
2025 			(phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
2026 	}
2027 }
2028 
2029 /**
2030  * lpfc_sli_chk_mbx_command - Check if the mailbox is a legitimate mailbox
2031  * @mbxCommand: mailbox command code.
2032  *
2033  * This function is called by the mailbox event handler function to verify
2034  * that the completed mailbox command is a legitimate mailbox command. If the
2035  * completed mailbox is not known to the function, it will return MBX_SHUTDOWN
2036  * and the mailbox event handler will take the HBA offline.
2037  **/
2038 static int
2039 lpfc_sli_chk_mbx_command(uint8_t mbxCommand)
2040 {
2041 	uint8_t ret;
2042 
2043 	switch (mbxCommand) {
2044 	case MBX_LOAD_SM:
2045 	case MBX_READ_NV:
2046 	case MBX_WRITE_NV:
2047 	case MBX_WRITE_VPARMS:
2048 	case MBX_RUN_BIU_DIAG:
2049 	case MBX_INIT_LINK:
2050 	case MBX_DOWN_LINK:
2051 	case MBX_CONFIG_LINK:
2052 	case MBX_CONFIG_RING:
2053 	case MBX_RESET_RING:
2054 	case MBX_READ_CONFIG:
2055 	case MBX_READ_RCONFIG:
2056 	case MBX_READ_SPARM:
2057 	case MBX_READ_STATUS:
2058 	case MBX_READ_RPI:
2059 	case MBX_READ_XRI:
2060 	case MBX_READ_REV:
2061 	case MBX_READ_LNK_STAT:
2062 	case MBX_REG_LOGIN:
2063 	case MBX_UNREG_LOGIN:
2064 	case MBX_CLEAR_LA:
2065 	case MBX_DUMP_MEMORY:
2066 	case MBX_DUMP_CONTEXT:
2067 	case MBX_RUN_DIAGS:
2068 	case MBX_RESTART:
2069 	case MBX_UPDATE_CFG:
2070 	case MBX_DOWN_LOAD:
2071 	case MBX_DEL_LD_ENTRY:
2072 	case MBX_RUN_PROGRAM:
2073 	case MBX_SET_MASK:
2074 	case MBX_SET_VARIABLE:
2075 	case MBX_UNREG_D_ID:
2076 	case MBX_KILL_BOARD:
2077 	case MBX_CONFIG_FARP:
2078 	case MBX_BEACON:
2079 	case MBX_LOAD_AREA:
2080 	case MBX_RUN_BIU_DIAG64:
2081 	case MBX_CONFIG_PORT:
2082 	case MBX_READ_SPARM64:
2083 	case MBX_READ_RPI64:
2084 	case MBX_REG_LOGIN64:
2085 	case MBX_READ_TOPOLOGY:
2086 	case MBX_WRITE_WWN:
2087 	case MBX_SET_DEBUG:
2088 	case MBX_LOAD_EXP_ROM:
2089 	case MBX_ASYNCEVT_ENABLE:
2090 	case MBX_REG_VPI:
2091 	case MBX_UNREG_VPI:
2092 	case MBX_HEARTBEAT:
2093 	case MBX_PORT_CAPABILITIES:
2094 	case MBX_PORT_IOV_CONTROL:
2095 	case MBX_SLI4_CONFIG:
2096 	case MBX_SLI4_REQ_FTRS:
2097 	case MBX_REG_FCFI:
2098 	case MBX_UNREG_FCFI:
2099 	case MBX_REG_VFI:
2100 	case MBX_UNREG_VFI:
2101 	case MBX_INIT_VPI:
2102 	case MBX_INIT_VFI:
2103 	case MBX_RESUME_RPI:
2104 	case MBX_READ_EVENT_LOG_STATUS:
2105 	case MBX_READ_EVENT_LOG:
2106 	case MBX_SECURITY_MGMT:
2107 	case MBX_AUTH_PORT:
2108 	case MBX_ACCESS_VDATA:
2109 		ret = mbxCommand;
2110 		break;
2111 	default:
2112 		ret = MBX_SHUTDOWN;
2113 		break;
2114 	}
2115 	return ret;
2116 }
2117 
2118 /**
2119  * lpfc_sli_wake_mbox_wait - lpfc_sli_issue_mbox_wait mbox completion handler
2120  * @phba: Pointer to HBA context object.
2121  * @pmboxq: Pointer to mailbox command.
2122  *
2123  * This is completion handler function for mailbox commands issued from
2124  * lpfc_sli_issue_mbox_wait function. This function is called by the
2125  * mailbox event handler function with no lock held. This function
2126  * will wake up thread waiting on the wait queue pointed by context1
2127  * of the mailbox.
2128  **/
2129 void
2130 lpfc_sli_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
2131 {
2132 	wait_queue_head_t *pdone_q;
2133 	unsigned long drvr_flag;
2134 
2135 	/*
2136 	 * If pdone_q is empty, the driver thread gave up waiting and
2137 	 * continued running.
2138 	 */
2139 	pmboxq->mbox_flag |= LPFC_MBX_WAKE;
2140 	spin_lock_irqsave(&phba->hbalock, drvr_flag);
2141 	pdone_q = (wait_queue_head_t *) pmboxq->context1;
2142 	if (pdone_q)
2143 		wake_up_interruptible(pdone_q);
2144 	spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
2145 	return;
2146 }
2147 
2148 
2149 /**
2150  * lpfc_sli_def_mbox_cmpl - Default mailbox completion handler
2151  * @phba: Pointer to HBA context object.
2152  * @pmb: Pointer to mailbox object.
2153  *
2154  * This function is the default mailbox completion handler. It
2155  * frees the memory resources associated with the completed mailbox
2156  * command. If the completed command is a REG_LOGIN mailbox command,
2157  * this function will issue a UREG_LOGIN to re-claim the RPI.
2158  **/
2159 void
2160 lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2161 {
2162 	struct lpfc_vport  *vport = pmb->vport;
2163 	struct lpfc_dmabuf *mp;
2164 	struct lpfc_nodelist *ndlp;
2165 	struct Scsi_Host *shost;
2166 	uint16_t rpi, vpi;
2167 	int rc;
2168 
2169 	mp = (struct lpfc_dmabuf *) (pmb->context1);
2170 
2171 	if (mp) {
2172 		lpfc_mbuf_free(phba, mp->virt, mp->phys);
2173 		kfree(mp);
2174 	}
2175 
2176 	/*
2177 	 * If a REG_LOGIN succeeded  after node is destroyed or node
2178 	 * is in re-discovery driver need to cleanup the RPI.
2179 	 */
2180 	if (!(phba->pport->load_flag & FC_UNLOADING) &&
2181 	    pmb->u.mb.mbxCommand == MBX_REG_LOGIN64 &&
2182 	    !pmb->u.mb.mbxStatus) {
2183 		rpi = pmb->u.mb.un.varWords[0];
2184 		vpi = pmb->u.mb.un.varRegLogin.vpi;
2185 		lpfc_unreg_login(phba, vpi, rpi, pmb);
2186 		pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2187 		rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
2188 		if (rc != MBX_NOT_FINISHED)
2189 			return;
2190 	}
2191 
2192 	if ((pmb->u.mb.mbxCommand == MBX_REG_VPI) &&
2193 		!(phba->pport->load_flag & FC_UNLOADING) &&
2194 		!pmb->u.mb.mbxStatus) {
2195 		shost = lpfc_shost_from_vport(vport);
2196 		spin_lock_irq(shost->host_lock);
2197 		vport->vpi_state |= LPFC_VPI_REGISTERED;
2198 		vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
2199 		spin_unlock_irq(shost->host_lock);
2200 	}
2201 
2202 	if (pmb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
2203 		ndlp = (struct lpfc_nodelist *)pmb->context2;
2204 		lpfc_nlp_put(ndlp);
2205 		pmb->context2 = NULL;
2206 	}
2207 
2208 	/* Check security permission status on INIT_LINK mailbox command */
2209 	if ((pmb->u.mb.mbxCommand == MBX_INIT_LINK) &&
2210 	    (pmb->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION))
2211 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
2212 				"2860 SLI authentication is required "
2213 				"for INIT_LINK but has not done yet\n");
2214 
2215 	if (bf_get(lpfc_mqe_command, &pmb->u.mqe) == MBX_SLI4_CONFIG)
2216 		lpfc_sli4_mbox_cmd_free(phba, pmb);
2217 	else
2218 		mempool_free(pmb, phba->mbox_mem_pool);
2219 }
2220  /**
2221  * lpfc_sli4_unreg_rpi_cmpl_clr - mailbox completion handler
2222  * @phba: Pointer to HBA context object.
2223  * @pmb: Pointer to mailbox object.
2224  *
2225  * This function is the unreg rpi mailbox completion handler. It
2226  * frees the memory resources associated with the completed mailbox
2227  * command. An additional refrenece is put on the ndlp to prevent
2228  * lpfc_nlp_release from freeing the rpi bit in the bitmask before
2229  * the unreg mailbox command completes, this routine puts the
2230  * reference back.
2231  *
2232  **/
2233 void
2234 lpfc_sli4_unreg_rpi_cmpl_clr(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2235 {
2236 	struct lpfc_vport  *vport = pmb->vport;
2237 	struct lpfc_nodelist *ndlp;
2238 
2239 	ndlp = pmb->context1;
2240 	if (pmb->u.mb.mbxCommand == MBX_UNREG_LOGIN) {
2241 		if (phba->sli_rev == LPFC_SLI_REV4 &&
2242 		    (bf_get(lpfc_sli_intf_if_type,
2243 		     &phba->sli4_hba.sli_intf) ==
2244 		     LPFC_SLI_INTF_IF_TYPE_2)) {
2245 			if (ndlp) {
2246 				lpfc_printf_vlog(vport, KERN_INFO, LOG_SLI,
2247 						 "0010 UNREG_LOGIN vpi:%x "
2248 						 "rpi:%x DID:%x map:%x %p\n",
2249 						 vport->vpi, ndlp->nlp_rpi,
2250 						 ndlp->nlp_DID,
2251 						 ndlp->nlp_usg_map, ndlp);
2252 
2253 				lpfc_nlp_put(ndlp);
2254 			}
2255 		}
2256 	}
2257 
2258 	mempool_free(pmb, phba->mbox_mem_pool);
2259 }
2260 
2261 /**
2262  * lpfc_sli_handle_mb_event - Handle mailbox completions from firmware
2263  * @phba: Pointer to HBA context object.
2264  *
2265  * This function is called with no lock held. This function processes all
2266  * the completed mailbox commands and gives it to upper layers. The interrupt
2267  * service routine processes mailbox completion interrupt and adds completed
2268  * mailbox commands to the mboxq_cmpl queue and signals the worker thread.
2269  * Worker thread call lpfc_sli_handle_mb_event, which will return the
2270  * completed mailbox commands in mboxq_cmpl queue to the upper layers. This
2271  * function returns the mailbox commands to the upper layer by calling the
2272  * completion handler function of each mailbox.
2273  **/
2274 int
2275 lpfc_sli_handle_mb_event(struct lpfc_hba *phba)
2276 {
2277 	MAILBOX_t *pmbox;
2278 	LPFC_MBOXQ_t *pmb;
2279 	int rc;
2280 	LIST_HEAD(cmplq);
2281 
2282 	phba->sli.slistat.mbox_event++;
2283 
2284 	/* Get all completed mailboxe buffers into the cmplq */
2285 	spin_lock_irq(&phba->hbalock);
2286 	list_splice_init(&phba->sli.mboxq_cmpl, &cmplq);
2287 	spin_unlock_irq(&phba->hbalock);
2288 
2289 	/* Get a Mailbox buffer to setup mailbox commands for callback */
2290 	do {
2291 		list_remove_head(&cmplq, pmb, LPFC_MBOXQ_t, list);
2292 		if (pmb == NULL)
2293 			break;
2294 
2295 		pmbox = &pmb->u.mb;
2296 
2297 		if (pmbox->mbxCommand != MBX_HEARTBEAT) {
2298 			if (pmb->vport) {
2299 				lpfc_debugfs_disc_trc(pmb->vport,
2300 					LPFC_DISC_TRC_MBOX_VPORT,
2301 					"MBOX cmpl vport: cmd:x%x mb:x%x x%x",
2302 					(uint32_t)pmbox->mbxCommand,
2303 					pmbox->un.varWords[0],
2304 					pmbox->un.varWords[1]);
2305 			}
2306 			else {
2307 				lpfc_debugfs_disc_trc(phba->pport,
2308 					LPFC_DISC_TRC_MBOX,
2309 					"MBOX cmpl:       cmd:x%x mb:x%x x%x",
2310 					(uint32_t)pmbox->mbxCommand,
2311 					pmbox->un.varWords[0],
2312 					pmbox->un.varWords[1]);
2313 			}
2314 		}
2315 
2316 		/*
2317 		 * It is a fatal error if unknown mbox command completion.
2318 		 */
2319 		if (lpfc_sli_chk_mbx_command(pmbox->mbxCommand) ==
2320 		    MBX_SHUTDOWN) {
2321 			/* Unknown mailbox command compl */
2322 			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
2323 					"(%d):0323 Unknown Mailbox command "
2324 					"x%x (x%x/x%x) Cmpl\n",
2325 					pmb->vport ? pmb->vport->vpi : 0,
2326 					pmbox->mbxCommand,
2327 					lpfc_sli_config_mbox_subsys_get(phba,
2328 									pmb),
2329 					lpfc_sli_config_mbox_opcode_get(phba,
2330 									pmb));
2331 			phba->link_state = LPFC_HBA_ERROR;
2332 			phba->work_hs = HS_FFER3;
2333 			lpfc_handle_eratt(phba);
2334 			continue;
2335 		}
2336 
2337 		if (pmbox->mbxStatus) {
2338 			phba->sli.slistat.mbox_stat_err++;
2339 			if (pmbox->mbxStatus == MBXERR_NO_RESOURCES) {
2340 				/* Mbox cmd cmpl error - RETRYing */
2341 				lpfc_printf_log(phba, KERN_INFO,
2342 					LOG_MBOX | LOG_SLI,
2343 					"(%d):0305 Mbox cmd cmpl "
2344 					"error - RETRYing Data: x%x "
2345 					"(x%x/x%x) x%x x%x x%x\n",
2346 					pmb->vport ? pmb->vport->vpi : 0,
2347 					pmbox->mbxCommand,
2348 					lpfc_sli_config_mbox_subsys_get(phba,
2349 									pmb),
2350 					lpfc_sli_config_mbox_opcode_get(phba,
2351 									pmb),
2352 					pmbox->mbxStatus,
2353 					pmbox->un.varWords[0],
2354 					pmb->vport->port_state);
2355 				pmbox->mbxStatus = 0;
2356 				pmbox->mbxOwner = OWN_HOST;
2357 				rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
2358 				if (rc != MBX_NOT_FINISHED)
2359 					continue;
2360 			}
2361 		}
2362 
2363 		/* Mailbox cmd <cmd> Cmpl <cmpl> */
2364 		lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
2365 				"(%d):0307 Mailbox cmd x%x (x%x/x%x) Cmpl x%p "
2366 				"Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x "
2367 				"x%x x%x x%x\n",
2368 				pmb->vport ? pmb->vport->vpi : 0,
2369 				pmbox->mbxCommand,
2370 				lpfc_sli_config_mbox_subsys_get(phba, pmb),
2371 				lpfc_sli_config_mbox_opcode_get(phba, pmb),
2372 				pmb->mbox_cmpl,
2373 				*((uint32_t *) pmbox),
2374 				pmbox->un.varWords[0],
2375 				pmbox->un.varWords[1],
2376 				pmbox->un.varWords[2],
2377 				pmbox->un.varWords[3],
2378 				pmbox->un.varWords[4],
2379 				pmbox->un.varWords[5],
2380 				pmbox->un.varWords[6],
2381 				pmbox->un.varWords[7],
2382 				pmbox->un.varWords[8],
2383 				pmbox->un.varWords[9],
2384 				pmbox->un.varWords[10]);
2385 
2386 		if (pmb->mbox_cmpl)
2387 			pmb->mbox_cmpl(phba,pmb);
2388 	} while (1);
2389 	return 0;
2390 }
2391 
2392 /**
2393  * lpfc_sli_get_buff - Get the buffer associated with the buffer tag
2394  * @phba: Pointer to HBA context object.
2395  * @pring: Pointer to driver SLI ring object.
2396  * @tag: buffer tag.
2397  *
2398  * This function is called with no lock held. When QUE_BUFTAG_BIT bit
2399  * is set in the tag the buffer is posted for a particular exchange,
2400  * the function will return the buffer without replacing the buffer.
2401  * If the buffer is for unsolicited ELS or CT traffic, this function
2402  * returns the buffer and also posts another buffer to the firmware.
2403  **/
2404 static struct lpfc_dmabuf *
2405 lpfc_sli_get_buff(struct lpfc_hba *phba,
2406 		  struct lpfc_sli_ring *pring,
2407 		  uint32_t tag)
2408 {
2409 	struct hbq_dmabuf *hbq_entry;
2410 
2411 	if (tag & QUE_BUFTAG_BIT)
2412 		return lpfc_sli_ring_taggedbuf_get(phba, pring, tag);
2413 	hbq_entry = lpfc_sli_hbqbuf_find(phba, tag);
2414 	if (!hbq_entry)
2415 		return NULL;
2416 	return &hbq_entry->dbuf;
2417 }
2418 
2419 /**
2420  * lpfc_complete_unsol_iocb - Complete an unsolicited sequence
2421  * @phba: Pointer to HBA context object.
2422  * @pring: Pointer to driver SLI ring object.
2423  * @saveq: Pointer to the iocbq struct representing the sequence starting frame.
2424  * @fch_r_ctl: the r_ctl for the first frame of the sequence.
2425  * @fch_type: the type for the first frame of the sequence.
2426  *
2427  * This function is called with no lock held. This function uses the r_ctl and
2428  * type of the received sequence to find the correct callback function to call
2429  * to process the sequence.
2430  **/
2431 static int
2432 lpfc_complete_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2433 			 struct lpfc_iocbq *saveq, uint32_t fch_r_ctl,
2434 			 uint32_t fch_type)
2435 {
2436 	int i;
2437 
2438 	/* unSolicited Responses */
2439 	if (pring->prt[0].profile) {
2440 		if (pring->prt[0].lpfc_sli_rcv_unsol_event)
2441 			(pring->prt[0].lpfc_sli_rcv_unsol_event) (phba, pring,
2442 									saveq);
2443 		return 1;
2444 	}
2445 	/* We must search, based on rctl / type
2446 	   for the right routine */
2447 	for (i = 0; i < pring->num_mask; i++) {
2448 		if ((pring->prt[i].rctl == fch_r_ctl) &&
2449 		    (pring->prt[i].type == fch_type)) {
2450 			if (pring->prt[i].lpfc_sli_rcv_unsol_event)
2451 				(pring->prt[i].lpfc_sli_rcv_unsol_event)
2452 						(phba, pring, saveq);
2453 			return 1;
2454 		}
2455 	}
2456 	return 0;
2457 }
2458 
2459 /**
2460  * lpfc_sli_process_unsol_iocb - Unsolicited iocb handler
2461  * @phba: Pointer to HBA context object.
2462  * @pring: Pointer to driver SLI ring object.
2463  * @saveq: Pointer to the unsolicited iocb.
2464  *
2465  * This function is called with no lock held by the ring event handler
2466  * when there is an unsolicited iocb posted to the response ring by the
2467  * firmware. This function gets the buffer associated with the iocbs
2468  * and calls the event handler for the ring. This function handles both
2469  * qring buffers and hbq buffers.
2470  * When the function returns 1 the caller can free the iocb object otherwise
2471  * upper layer functions will free the iocb objects.
2472  **/
2473 static int
2474 lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2475 			    struct lpfc_iocbq *saveq)
2476 {
2477 	IOCB_t           * irsp;
2478 	WORD5            * w5p;
2479 	uint32_t           Rctl, Type;
2480 	struct lpfc_iocbq *iocbq;
2481 	struct lpfc_dmabuf *dmzbuf;
2482 
2483 	irsp = &(saveq->iocb);
2484 
2485 	if (irsp->ulpCommand == CMD_ASYNC_STATUS) {
2486 		if (pring->lpfc_sli_rcv_async_status)
2487 			pring->lpfc_sli_rcv_async_status(phba, pring, saveq);
2488 		else
2489 			lpfc_printf_log(phba,
2490 					KERN_WARNING,
2491 					LOG_SLI,
2492 					"0316 Ring %d handler: unexpected "
2493 					"ASYNC_STATUS iocb received evt_code "
2494 					"0x%x\n",
2495 					pring->ringno,
2496 					irsp->un.asyncstat.evt_code);
2497 		return 1;
2498 	}
2499 
2500 	if ((irsp->ulpCommand == CMD_IOCB_RET_XRI64_CX) &&
2501 		(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)) {
2502 		if (irsp->ulpBdeCount > 0) {
2503 			dmzbuf = lpfc_sli_get_buff(phba, pring,
2504 					irsp->un.ulpWord[3]);
2505 			lpfc_in_buf_free(phba, dmzbuf);
2506 		}
2507 
2508 		if (irsp->ulpBdeCount > 1) {
2509 			dmzbuf = lpfc_sli_get_buff(phba, pring,
2510 					irsp->unsli3.sli3Words[3]);
2511 			lpfc_in_buf_free(phba, dmzbuf);
2512 		}
2513 
2514 		if (irsp->ulpBdeCount > 2) {
2515 			dmzbuf = lpfc_sli_get_buff(phba, pring,
2516 				irsp->unsli3.sli3Words[7]);
2517 			lpfc_in_buf_free(phba, dmzbuf);
2518 		}
2519 
2520 		return 1;
2521 	}
2522 
2523 	if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
2524 		if (irsp->ulpBdeCount != 0) {
2525 			saveq->context2 = lpfc_sli_get_buff(phba, pring,
2526 						irsp->un.ulpWord[3]);
2527 			if (!saveq->context2)
2528 				lpfc_printf_log(phba,
2529 					KERN_ERR,
2530 					LOG_SLI,
2531 					"0341 Ring %d Cannot find buffer for "
2532 					"an unsolicited iocb. tag 0x%x\n",
2533 					pring->ringno,
2534 					irsp->un.ulpWord[3]);
2535 		}
2536 		if (irsp->ulpBdeCount == 2) {
2537 			saveq->context3 = lpfc_sli_get_buff(phba, pring,
2538 						irsp->unsli3.sli3Words[7]);
2539 			if (!saveq->context3)
2540 				lpfc_printf_log(phba,
2541 					KERN_ERR,
2542 					LOG_SLI,
2543 					"0342 Ring %d Cannot find buffer for an"
2544 					" unsolicited iocb. tag 0x%x\n",
2545 					pring->ringno,
2546 					irsp->unsli3.sli3Words[7]);
2547 		}
2548 		list_for_each_entry(iocbq, &saveq->list, list) {
2549 			irsp = &(iocbq->iocb);
2550 			if (irsp->ulpBdeCount != 0) {
2551 				iocbq->context2 = lpfc_sli_get_buff(phba, pring,
2552 							irsp->un.ulpWord[3]);
2553 				if (!iocbq->context2)
2554 					lpfc_printf_log(phba,
2555 						KERN_ERR,
2556 						LOG_SLI,
2557 						"0343 Ring %d Cannot find "
2558 						"buffer for an unsolicited iocb"
2559 						". tag 0x%x\n", pring->ringno,
2560 						irsp->un.ulpWord[3]);
2561 			}
2562 			if (irsp->ulpBdeCount == 2) {
2563 				iocbq->context3 = lpfc_sli_get_buff(phba, pring,
2564 						irsp->unsli3.sli3Words[7]);
2565 				if (!iocbq->context3)
2566 					lpfc_printf_log(phba,
2567 						KERN_ERR,
2568 						LOG_SLI,
2569 						"0344 Ring %d Cannot find "
2570 						"buffer for an unsolicited "
2571 						"iocb. tag 0x%x\n",
2572 						pring->ringno,
2573 						irsp->unsli3.sli3Words[7]);
2574 			}
2575 		}
2576 	}
2577 	if (irsp->ulpBdeCount != 0 &&
2578 	    (irsp->ulpCommand == CMD_IOCB_RCV_CONT64_CX ||
2579 	     irsp->ulpStatus == IOSTAT_INTERMED_RSP)) {
2580 		int found = 0;
2581 
2582 		/* search continue save q for same XRI */
2583 		list_for_each_entry(iocbq, &pring->iocb_continue_saveq, clist) {
2584 			if (iocbq->iocb.unsli3.rcvsli3.ox_id ==
2585 				saveq->iocb.unsli3.rcvsli3.ox_id) {
2586 				list_add_tail(&saveq->list, &iocbq->list);
2587 				found = 1;
2588 				break;
2589 			}
2590 		}
2591 		if (!found)
2592 			list_add_tail(&saveq->clist,
2593 				      &pring->iocb_continue_saveq);
2594 		if (saveq->iocb.ulpStatus != IOSTAT_INTERMED_RSP) {
2595 			list_del_init(&iocbq->clist);
2596 			saveq = iocbq;
2597 			irsp = &(saveq->iocb);
2598 		} else
2599 			return 0;
2600 	}
2601 	if ((irsp->ulpCommand == CMD_RCV_ELS_REQ64_CX) ||
2602 	    (irsp->ulpCommand == CMD_RCV_ELS_REQ_CX) ||
2603 	    (irsp->ulpCommand == CMD_IOCB_RCV_ELS64_CX)) {
2604 		Rctl = FC_RCTL_ELS_REQ;
2605 		Type = FC_TYPE_ELS;
2606 	} else {
2607 		w5p = (WORD5 *)&(saveq->iocb.un.ulpWord[5]);
2608 		Rctl = w5p->hcsw.Rctl;
2609 		Type = w5p->hcsw.Type;
2610 
2611 		/* Firmware Workaround */
2612 		if ((Rctl == 0) && (pring->ringno == LPFC_ELS_RING) &&
2613 			(irsp->ulpCommand == CMD_RCV_SEQUENCE64_CX ||
2614 			 irsp->ulpCommand == CMD_IOCB_RCV_SEQ64_CX)) {
2615 			Rctl = FC_RCTL_ELS_REQ;
2616 			Type = FC_TYPE_ELS;
2617 			w5p->hcsw.Rctl = Rctl;
2618 			w5p->hcsw.Type = Type;
2619 		}
2620 	}
2621 
2622 	if (!lpfc_complete_unsol_iocb(phba, pring, saveq, Rctl, Type))
2623 		lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
2624 				"0313 Ring %d handler: unexpected Rctl x%x "
2625 				"Type x%x received\n",
2626 				pring->ringno, Rctl, Type);
2627 
2628 	return 1;
2629 }
2630 
2631 /**
2632  * lpfc_sli_iocbq_lookup - Find command iocb for the given response iocb
2633  * @phba: Pointer to HBA context object.
2634  * @pring: Pointer to driver SLI ring object.
2635  * @prspiocb: Pointer to response iocb object.
2636  *
2637  * This function looks up the iocb_lookup table to get the command iocb
2638  * corresponding to the given response iocb using the iotag of the
2639  * response iocb. This function is called with the hbalock held.
2640  * This function returns the command iocb object if it finds the command
2641  * iocb else returns NULL.
2642  **/
2643 static struct lpfc_iocbq *
2644 lpfc_sli_iocbq_lookup(struct lpfc_hba *phba,
2645 		      struct lpfc_sli_ring *pring,
2646 		      struct lpfc_iocbq *prspiocb)
2647 {
2648 	struct lpfc_iocbq *cmd_iocb = NULL;
2649 	uint16_t iotag;
2650 
2651 	iotag = prspiocb->iocb.ulpIoTag;
2652 
2653 	if (iotag != 0 && iotag <= phba->sli.last_iotag) {
2654 		cmd_iocb = phba->sli.iocbq_lookup[iotag];
2655 		list_del_init(&cmd_iocb->list);
2656 		if (cmd_iocb->iocb_flag & LPFC_IO_ON_TXCMPLQ) {
2657 			cmd_iocb->iocb_flag &= ~LPFC_IO_ON_TXCMPLQ;
2658 		}
2659 		return cmd_iocb;
2660 	}
2661 
2662 	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2663 			"0317 iotag x%x is out off "
2664 			"range: max iotag x%x wd0 x%x\n",
2665 			iotag, phba->sli.last_iotag,
2666 			*(((uint32_t *) &prspiocb->iocb) + 7));
2667 	return NULL;
2668 }
2669 
2670 /**
2671  * lpfc_sli_iocbq_lookup_by_tag - Find command iocb for the iotag
2672  * @phba: Pointer to HBA context object.
2673  * @pring: Pointer to driver SLI ring object.
2674  * @iotag: IOCB tag.
2675  *
2676  * This function looks up the iocb_lookup table to get the command iocb
2677  * corresponding to the given iotag. This function is called with the
2678  * hbalock held.
2679  * This function returns the command iocb object if it finds the command
2680  * iocb else returns NULL.
2681  **/
2682 static struct lpfc_iocbq *
2683 lpfc_sli_iocbq_lookup_by_tag(struct lpfc_hba *phba,
2684 			     struct lpfc_sli_ring *pring, uint16_t iotag)
2685 {
2686 	struct lpfc_iocbq *cmd_iocb;
2687 
2688 	if (iotag != 0 && iotag <= phba->sli.last_iotag) {
2689 		cmd_iocb = phba->sli.iocbq_lookup[iotag];
2690 		if (cmd_iocb->iocb_flag & LPFC_IO_ON_TXCMPLQ) {
2691 			/* remove from txcmpl queue list */
2692 			list_del_init(&cmd_iocb->list);
2693 			cmd_iocb->iocb_flag &= ~LPFC_IO_ON_TXCMPLQ;
2694 			return cmd_iocb;
2695 		}
2696 	}
2697 	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2698 			"0372 iotag x%x is out off range: max iotag (x%x)\n",
2699 			iotag, phba->sli.last_iotag);
2700 	return NULL;
2701 }
2702 
2703 /**
2704  * lpfc_sli_process_sol_iocb - process solicited iocb completion
2705  * @phba: Pointer to HBA context object.
2706  * @pring: Pointer to driver SLI ring object.
2707  * @saveq: Pointer to the response iocb to be processed.
2708  *
2709  * This function is called by the ring event handler for non-fcp
2710  * rings when there is a new response iocb in the response ring.
2711  * The caller is not required to hold any locks. This function
2712  * gets the command iocb associated with the response iocb and
2713  * calls the completion handler for the command iocb. If there
2714  * is no completion handler, the function will free the resources
2715  * associated with command iocb. If the response iocb is for
2716  * an already aborted command iocb, the status of the completion
2717  * is changed to IOSTAT_LOCAL_REJECT/IOERR_SLI_ABORTED.
2718  * This function always returns 1.
2719  **/
2720 static int
2721 lpfc_sli_process_sol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2722 			  struct lpfc_iocbq *saveq)
2723 {
2724 	struct lpfc_iocbq *cmdiocbp;
2725 	int rc = 1;
2726 	unsigned long iflag;
2727 
2728 	/* Based on the iotag field, get the cmd IOCB from the txcmplq */
2729 	spin_lock_irqsave(&phba->hbalock, iflag);
2730 	cmdiocbp = lpfc_sli_iocbq_lookup(phba, pring, saveq);
2731 	spin_unlock_irqrestore(&phba->hbalock, iflag);
2732 
2733 	if (cmdiocbp) {
2734 		if (cmdiocbp->iocb_cmpl) {
2735 			/*
2736 			 * If an ELS command failed send an event to mgmt
2737 			 * application.
2738 			 */
2739 			if (saveq->iocb.ulpStatus &&
2740 			     (pring->ringno == LPFC_ELS_RING) &&
2741 			     (cmdiocbp->iocb.ulpCommand ==
2742 				CMD_ELS_REQUEST64_CR))
2743 				lpfc_send_els_failure_event(phba,
2744 					cmdiocbp, saveq);
2745 
2746 			/*
2747 			 * Post all ELS completions to the worker thread.
2748 			 * All other are passed to the completion callback.
2749 			 */
2750 			if (pring->ringno == LPFC_ELS_RING) {
2751 				if ((phba->sli_rev < LPFC_SLI_REV4) &&
2752 				    (cmdiocbp->iocb_flag &
2753 							LPFC_DRIVER_ABORTED)) {
2754 					spin_lock_irqsave(&phba->hbalock,
2755 							  iflag);
2756 					cmdiocbp->iocb_flag &=
2757 						~LPFC_DRIVER_ABORTED;
2758 					spin_unlock_irqrestore(&phba->hbalock,
2759 							       iflag);
2760 					saveq->iocb.ulpStatus =
2761 						IOSTAT_LOCAL_REJECT;
2762 					saveq->iocb.un.ulpWord[4] =
2763 						IOERR_SLI_ABORTED;
2764 
2765 					/* Firmware could still be in progress
2766 					 * of DMAing payload, so don't free data
2767 					 * buffer till after a hbeat.
2768 					 */
2769 					spin_lock_irqsave(&phba->hbalock,
2770 							  iflag);
2771 					saveq->iocb_flag |= LPFC_DELAY_MEM_FREE;
2772 					spin_unlock_irqrestore(&phba->hbalock,
2773 							       iflag);
2774 				}
2775 				if (phba->sli_rev == LPFC_SLI_REV4) {
2776 					if (saveq->iocb_flag &
2777 					    LPFC_EXCHANGE_BUSY) {
2778 						/* Set cmdiocb flag for the
2779 						 * exchange busy so sgl (xri)
2780 						 * will not be released until
2781 						 * the abort xri is received
2782 						 * from hba.
2783 						 */
2784 						spin_lock_irqsave(
2785 							&phba->hbalock, iflag);
2786 						cmdiocbp->iocb_flag |=
2787 							LPFC_EXCHANGE_BUSY;
2788 						spin_unlock_irqrestore(
2789 							&phba->hbalock, iflag);
2790 					}
2791 					if (cmdiocbp->iocb_flag &
2792 					    LPFC_DRIVER_ABORTED) {
2793 						/*
2794 						 * Clear LPFC_DRIVER_ABORTED
2795 						 * bit in case it was driver
2796 						 * initiated abort.
2797 						 */
2798 						spin_lock_irqsave(
2799 							&phba->hbalock, iflag);
2800 						cmdiocbp->iocb_flag &=
2801 							~LPFC_DRIVER_ABORTED;
2802 						spin_unlock_irqrestore(
2803 							&phba->hbalock, iflag);
2804 						cmdiocbp->iocb.ulpStatus =
2805 							IOSTAT_LOCAL_REJECT;
2806 						cmdiocbp->iocb.un.ulpWord[4] =
2807 							IOERR_ABORT_REQUESTED;
2808 						/*
2809 						 * For SLI4, irsiocb contains
2810 						 * NO_XRI in sli_xritag, it
2811 						 * shall not affect releasing
2812 						 * sgl (xri) process.
2813 						 */
2814 						saveq->iocb.ulpStatus =
2815 							IOSTAT_LOCAL_REJECT;
2816 						saveq->iocb.un.ulpWord[4] =
2817 							IOERR_SLI_ABORTED;
2818 						spin_lock_irqsave(
2819 							&phba->hbalock, iflag);
2820 						saveq->iocb_flag |=
2821 							LPFC_DELAY_MEM_FREE;
2822 						spin_unlock_irqrestore(
2823 							&phba->hbalock, iflag);
2824 					}
2825 				}
2826 			}
2827 			(cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
2828 		} else
2829 			lpfc_sli_release_iocbq(phba, cmdiocbp);
2830 	} else {
2831 		/*
2832 		 * Unknown initiating command based on the response iotag.
2833 		 * This could be the case on the ELS ring because of
2834 		 * lpfc_els_abort().
2835 		 */
2836 		if (pring->ringno != LPFC_ELS_RING) {
2837 			/*
2838 			 * Ring <ringno> handler: unexpected completion IoTag
2839 			 * <IoTag>
2840 			 */
2841 			lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
2842 					 "0322 Ring %d handler: "
2843 					 "unexpected completion IoTag x%x "
2844 					 "Data: x%x x%x x%x x%x\n",
2845 					 pring->ringno,
2846 					 saveq->iocb.ulpIoTag,
2847 					 saveq->iocb.ulpStatus,
2848 					 saveq->iocb.un.ulpWord[4],
2849 					 saveq->iocb.ulpCommand,
2850 					 saveq->iocb.ulpContext);
2851 		}
2852 	}
2853 
2854 	return rc;
2855 }
2856 
2857 /**
2858  * lpfc_sli_rsp_pointers_error - Response ring pointer error handler
2859  * @phba: Pointer to HBA context object.
2860  * @pring: Pointer to driver SLI ring object.
2861  *
2862  * This function is called from the iocb ring event handlers when
2863  * put pointer is ahead of the get pointer for a ring. This function signal
2864  * an error attention condition to the worker thread and the worker
2865  * thread will transition the HBA to offline state.
2866  **/
2867 static void
2868 lpfc_sli_rsp_pointers_error(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
2869 {
2870 	struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
2871 	/*
2872 	 * Ring <ringno> handler: portRspPut <portRspPut> is bigger than
2873 	 * rsp ring <portRspMax>
2874 	 */
2875 	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2876 			"0312 Ring %d handler: portRspPut %d "
2877 			"is bigger than rsp ring %d\n",
2878 			pring->ringno, le32_to_cpu(pgp->rspPutInx),
2879 			pring->sli.sli3.numRiocb);
2880 
2881 	phba->link_state = LPFC_HBA_ERROR;
2882 
2883 	/*
2884 	 * All error attention handlers are posted to
2885 	 * worker thread
2886 	 */
2887 	phba->work_ha |= HA_ERATT;
2888 	phba->work_hs = HS_FFER3;
2889 
2890 	lpfc_worker_wake_up(phba);
2891 
2892 	return;
2893 }
2894 
2895 /**
2896  * lpfc_poll_eratt - Error attention polling timer timeout handler
2897  * @ptr: Pointer to address of HBA context object.
2898  *
2899  * This function is invoked by the Error Attention polling timer when the
2900  * timer times out. It will check the SLI Error Attention register for
2901  * possible attention events. If so, it will post an Error Attention event
2902  * and wake up worker thread to process it. Otherwise, it will set up the
2903  * Error Attention polling timer for the next poll.
2904  **/
2905 void lpfc_poll_eratt(unsigned long ptr)
2906 {
2907 	struct lpfc_hba *phba;
2908 	uint32_t eratt = 0;
2909 	uint64_t sli_intr, cnt;
2910 
2911 	phba = (struct lpfc_hba *)ptr;
2912 
2913 	/* Here we will also keep track of interrupts per sec of the hba */
2914 	sli_intr = phba->sli.slistat.sli_intr;
2915 
2916 	if (phba->sli.slistat.sli_prev_intr > sli_intr)
2917 		cnt = (((uint64_t)(-1) - phba->sli.slistat.sli_prev_intr) +
2918 			sli_intr);
2919 	else
2920 		cnt = (sli_intr - phba->sli.slistat.sli_prev_intr);
2921 
2922 	/* 64-bit integer division not supporte on 32-bit x86 - use do_div */
2923 	do_div(cnt, LPFC_ERATT_POLL_INTERVAL);
2924 	phba->sli.slistat.sli_ips = cnt;
2925 
2926 	phba->sli.slistat.sli_prev_intr = sli_intr;
2927 
2928 	/* Check chip HA register for error event */
2929 	eratt = lpfc_sli_check_eratt(phba);
2930 
2931 	if (eratt)
2932 		/* Tell the worker thread there is work to do */
2933 		lpfc_worker_wake_up(phba);
2934 	else
2935 		/* Restart the timer for next eratt poll */
2936 		mod_timer(&phba->eratt_poll,
2937 			  jiffies +
2938 			  msecs_to_jiffies(1000 * LPFC_ERATT_POLL_INTERVAL));
2939 	return;
2940 }
2941 
2942 
2943 /**
2944  * lpfc_sli_handle_fast_ring_event - Handle ring events on FCP ring
2945  * @phba: Pointer to HBA context object.
2946  * @pring: Pointer to driver SLI ring object.
2947  * @mask: Host attention register mask for this ring.
2948  *
2949  * This function is called from the interrupt context when there is a ring
2950  * event for the fcp ring. The caller does not hold any lock.
2951  * The function processes each response iocb in the response ring until it
2952  * finds an iocb with LE bit set and chains all the iocbs up to the iocb with
2953  * LE bit set. The function will call the completion handler of the command iocb
2954  * if the response iocb indicates a completion for a command iocb or it is
2955  * an abort completion. The function will call lpfc_sli_process_unsol_iocb
2956  * function if this is an unsolicited iocb.
2957  * This routine presumes LPFC_FCP_RING handling and doesn't bother
2958  * to check it explicitly.
2959  */
2960 int
2961 lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
2962 				struct lpfc_sli_ring *pring, uint32_t mask)
2963 {
2964 	struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
2965 	IOCB_t *irsp = NULL;
2966 	IOCB_t *entry = NULL;
2967 	struct lpfc_iocbq *cmdiocbq = NULL;
2968 	struct lpfc_iocbq rspiocbq;
2969 	uint32_t status;
2970 	uint32_t portRspPut, portRspMax;
2971 	int rc = 1;
2972 	lpfc_iocb_type type;
2973 	unsigned long iflag;
2974 	uint32_t rsp_cmpl = 0;
2975 
2976 	spin_lock_irqsave(&phba->hbalock, iflag);
2977 	pring->stats.iocb_event++;
2978 
2979 	/*
2980 	 * The next available response entry should never exceed the maximum
2981 	 * entries.  If it does, treat it as an adapter hardware error.
2982 	 */
2983 	portRspMax = pring->sli.sli3.numRiocb;
2984 	portRspPut = le32_to_cpu(pgp->rspPutInx);
2985 	if (unlikely(portRspPut >= portRspMax)) {
2986 		lpfc_sli_rsp_pointers_error(phba, pring);
2987 		spin_unlock_irqrestore(&phba->hbalock, iflag);
2988 		return 1;
2989 	}
2990 	if (phba->fcp_ring_in_use) {
2991 		spin_unlock_irqrestore(&phba->hbalock, iflag);
2992 		return 1;
2993 	} else
2994 		phba->fcp_ring_in_use = 1;
2995 
2996 	rmb();
2997 	while (pring->sli.sli3.rspidx != portRspPut) {
2998 		/*
2999 		 * Fetch an entry off the ring and copy it into a local data
3000 		 * structure.  The copy involves a byte-swap since the
3001 		 * network byte order and pci byte orders are different.
3002 		 */
3003 		entry = lpfc_resp_iocb(phba, pring);
3004 		phba->last_completion_time = jiffies;
3005 
3006 		if (++pring->sli.sli3.rspidx >= portRspMax)
3007 			pring->sli.sli3.rspidx = 0;
3008 
3009 		lpfc_sli_pcimem_bcopy((uint32_t *) entry,
3010 				      (uint32_t *) &rspiocbq.iocb,
3011 				      phba->iocb_rsp_size);
3012 		INIT_LIST_HEAD(&(rspiocbq.list));
3013 		irsp = &rspiocbq.iocb;
3014 
3015 		type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
3016 		pring->stats.iocb_rsp++;
3017 		rsp_cmpl++;
3018 
3019 		if (unlikely(irsp->ulpStatus)) {
3020 			/*
3021 			 * If resource errors reported from HBA, reduce
3022 			 * queuedepths of the SCSI device.
3023 			 */
3024 			if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
3025 			    ((irsp->un.ulpWord[4] & IOERR_PARAM_MASK) ==
3026 			     IOERR_NO_RESOURCES)) {
3027 				spin_unlock_irqrestore(&phba->hbalock, iflag);
3028 				phba->lpfc_rampdown_queue_depth(phba);
3029 				spin_lock_irqsave(&phba->hbalock, iflag);
3030 			}
3031 
3032 			/* Rsp ring <ringno> error: IOCB */
3033 			lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
3034 					"0336 Rsp Ring %d error: IOCB Data: "
3035 					"x%x x%x x%x x%x x%x x%x x%x x%x\n",
3036 					pring->ringno,
3037 					irsp->un.ulpWord[0],
3038 					irsp->un.ulpWord[1],
3039 					irsp->un.ulpWord[2],
3040 					irsp->un.ulpWord[3],
3041 					irsp->un.ulpWord[4],
3042 					irsp->un.ulpWord[5],
3043 					*(uint32_t *)&irsp->un1,
3044 					*((uint32_t *)&irsp->un1 + 1));
3045 		}
3046 
3047 		switch (type) {
3048 		case LPFC_ABORT_IOCB:
3049 		case LPFC_SOL_IOCB:
3050 			/*
3051 			 * Idle exchange closed via ABTS from port.  No iocb
3052 			 * resources need to be recovered.
3053 			 */
3054 			if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
3055 				lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3056 						"0333 IOCB cmd 0x%x"
3057 						" processed. Skipping"
3058 						" completion\n",
3059 						irsp->ulpCommand);
3060 				break;
3061 			}
3062 
3063 			cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
3064 							 &rspiocbq);
3065 			if (unlikely(!cmdiocbq))
3066 				break;
3067 			if (cmdiocbq->iocb_flag & LPFC_DRIVER_ABORTED)
3068 				cmdiocbq->iocb_flag &= ~LPFC_DRIVER_ABORTED;
3069 			if (cmdiocbq->iocb_cmpl) {
3070 				spin_unlock_irqrestore(&phba->hbalock, iflag);
3071 				(cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
3072 						      &rspiocbq);
3073 				spin_lock_irqsave(&phba->hbalock, iflag);
3074 			}
3075 			break;
3076 		case LPFC_UNSOL_IOCB:
3077 			spin_unlock_irqrestore(&phba->hbalock, iflag);
3078 			lpfc_sli_process_unsol_iocb(phba, pring, &rspiocbq);
3079 			spin_lock_irqsave(&phba->hbalock, iflag);
3080 			break;
3081 		default:
3082 			if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
3083 				char adaptermsg[LPFC_MAX_ADPTMSG];
3084 				memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
3085 				memcpy(&adaptermsg[0], (uint8_t *) irsp,
3086 				       MAX_MSG_DATA);
3087 				dev_warn(&((phba->pcidev)->dev),
3088 					 "lpfc%d: %s\n",
3089 					 phba->brd_no, adaptermsg);
3090 			} else {
3091 				/* Unknown IOCB command */
3092 				lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3093 						"0334 Unknown IOCB command "
3094 						"Data: x%x, x%x x%x x%x x%x\n",
3095 						type, irsp->ulpCommand,
3096 						irsp->ulpStatus,
3097 						irsp->ulpIoTag,
3098 						irsp->ulpContext);
3099 			}
3100 			break;
3101 		}
3102 
3103 		/*
3104 		 * The response IOCB has been processed.  Update the ring
3105 		 * pointer in SLIM.  If the port response put pointer has not
3106 		 * been updated, sync the pgp->rspPutInx and fetch the new port
3107 		 * response put pointer.
3108 		 */
3109 		writel(pring->sli.sli3.rspidx,
3110 			&phba->host_gp[pring->ringno].rspGetInx);
3111 
3112 		if (pring->sli.sli3.rspidx == portRspPut)
3113 			portRspPut = le32_to_cpu(pgp->rspPutInx);
3114 	}
3115 
3116 	if ((rsp_cmpl > 0) && (mask & HA_R0RE_REQ)) {
3117 		pring->stats.iocb_rsp_full++;
3118 		status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
3119 		writel(status, phba->CAregaddr);
3120 		readl(phba->CAregaddr);
3121 	}
3122 	if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
3123 		pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
3124 		pring->stats.iocb_cmd_empty++;
3125 
3126 		/* Force update of the local copy of cmdGetInx */
3127 		pring->sli.sli3.local_getidx = le32_to_cpu(pgp->cmdGetInx);
3128 		lpfc_sli_resume_iocb(phba, pring);
3129 
3130 		if ((pring->lpfc_sli_cmd_available))
3131 			(pring->lpfc_sli_cmd_available) (phba, pring);
3132 
3133 	}
3134 
3135 	phba->fcp_ring_in_use = 0;
3136 	spin_unlock_irqrestore(&phba->hbalock, iflag);
3137 	return rc;
3138 }
3139 
3140 /**
3141  * lpfc_sli_sp_handle_rspiocb - Handle slow-path response iocb
3142  * @phba: Pointer to HBA context object.
3143  * @pring: Pointer to driver SLI ring object.
3144  * @rspiocbp: Pointer to driver response IOCB object.
3145  *
3146  * This function is called from the worker thread when there is a slow-path
3147  * response IOCB to process. This function chains all the response iocbs until
3148  * seeing the iocb with the LE bit set. The function will call
3149  * lpfc_sli_process_sol_iocb function if the response iocb indicates a
3150  * completion of a command iocb. The function will call the
3151  * lpfc_sli_process_unsol_iocb function if this is an unsolicited iocb.
3152  * The function frees the resources or calls the completion handler if this
3153  * iocb is an abort completion. The function returns NULL when the response
3154  * iocb has the LE bit set and all the chained iocbs are processed, otherwise
3155  * this function shall chain the iocb on to the iocb_continueq and return the
3156  * response iocb passed in.
3157  **/
3158 static struct lpfc_iocbq *
3159 lpfc_sli_sp_handle_rspiocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3160 			struct lpfc_iocbq *rspiocbp)
3161 {
3162 	struct lpfc_iocbq *saveq;
3163 	struct lpfc_iocbq *cmdiocbp;
3164 	struct lpfc_iocbq *next_iocb;
3165 	IOCB_t *irsp = NULL;
3166 	uint32_t free_saveq;
3167 	uint8_t iocb_cmd_type;
3168 	lpfc_iocb_type type;
3169 	unsigned long iflag;
3170 	int rc;
3171 
3172 	spin_lock_irqsave(&phba->hbalock, iflag);
3173 	/* First add the response iocb to the countinueq list */
3174 	list_add_tail(&rspiocbp->list, &(pring->iocb_continueq));
3175 	pring->iocb_continueq_cnt++;
3176 
3177 	/* Now, determine whether the list is completed for processing */
3178 	irsp = &rspiocbp->iocb;
3179 	if (irsp->ulpLe) {
3180 		/*
3181 		 * By default, the driver expects to free all resources
3182 		 * associated with this iocb completion.
3183 		 */
3184 		free_saveq = 1;
3185 		saveq = list_get_first(&pring->iocb_continueq,
3186 				       struct lpfc_iocbq, list);
3187 		irsp = &(saveq->iocb);
3188 		list_del_init(&pring->iocb_continueq);
3189 		pring->iocb_continueq_cnt = 0;
3190 
3191 		pring->stats.iocb_rsp++;
3192 
3193 		/*
3194 		 * If resource errors reported from HBA, reduce
3195 		 * queuedepths of the SCSI device.
3196 		 */
3197 		if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
3198 		    ((irsp->un.ulpWord[4] & IOERR_PARAM_MASK) ==
3199 		     IOERR_NO_RESOURCES)) {
3200 			spin_unlock_irqrestore(&phba->hbalock, iflag);
3201 			phba->lpfc_rampdown_queue_depth(phba);
3202 			spin_lock_irqsave(&phba->hbalock, iflag);
3203 		}
3204 
3205 		if (irsp->ulpStatus) {
3206 			/* Rsp ring <ringno> error: IOCB */
3207 			lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
3208 					"0328 Rsp Ring %d error: "
3209 					"IOCB Data: "
3210 					"x%x x%x x%x x%x "
3211 					"x%x x%x x%x x%x "
3212 					"x%x x%x x%x x%x "
3213 					"x%x x%x x%x x%x\n",
3214 					pring->ringno,
3215 					irsp->un.ulpWord[0],
3216 					irsp->un.ulpWord[1],
3217 					irsp->un.ulpWord[2],
3218 					irsp->un.ulpWord[3],
3219 					irsp->un.ulpWord[4],
3220 					irsp->un.ulpWord[5],
3221 					*(((uint32_t *) irsp) + 6),
3222 					*(((uint32_t *) irsp) + 7),
3223 					*(((uint32_t *) irsp) + 8),
3224 					*(((uint32_t *) irsp) + 9),
3225 					*(((uint32_t *) irsp) + 10),
3226 					*(((uint32_t *) irsp) + 11),
3227 					*(((uint32_t *) irsp) + 12),
3228 					*(((uint32_t *) irsp) + 13),
3229 					*(((uint32_t *) irsp) + 14),
3230 					*(((uint32_t *) irsp) + 15));
3231 		}
3232 
3233 		/*
3234 		 * Fetch the IOCB command type and call the correct completion
3235 		 * routine. Solicited and Unsolicited IOCBs on the ELS ring
3236 		 * get freed back to the lpfc_iocb_list by the discovery
3237 		 * kernel thread.
3238 		 */
3239 		iocb_cmd_type = irsp->ulpCommand & CMD_IOCB_MASK;
3240 		type = lpfc_sli_iocb_cmd_type(iocb_cmd_type);
3241 		switch (type) {
3242 		case LPFC_SOL_IOCB:
3243 			spin_unlock_irqrestore(&phba->hbalock, iflag);
3244 			rc = lpfc_sli_process_sol_iocb(phba, pring, saveq);
3245 			spin_lock_irqsave(&phba->hbalock, iflag);
3246 			break;
3247 
3248 		case LPFC_UNSOL_IOCB:
3249 			spin_unlock_irqrestore(&phba->hbalock, iflag);
3250 			rc = lpfc_sli_process_unsol_iocb(phba, pring, saveq);
3251 			spin_lock_irqsave(&phba->hbalock, iflag);
3252 			if (!rc)
3253 				free_saveq = 0;
3254 			break;
3255 
3256 		case LPFC_ABORT_IOCB:
3257 			cmdiocbp = NULL;
3258 			if (irsp->ulpCommand != CMD_XRI_ABORTED_CX)
3259 				cmdiocbp = lpfc_sli_iocbq_lookup(phba, pring,
3260 								 saveq);
3261 			if (cmdiocbp) {
3262 				/* Call the specified completion routine */
3263 				if (cmdiocbp->iocb_cmpl) {
3264 					spin_unlock_irqrestore(&phba->hbalock,
3265 							       iflag);
3266 					(cmdiocbp->iocb_cmpl)(phba, cmdiocbp,
3267 							      saveq);
3268 					spin_lock_irqsave(&phba->hbalock,
3269 							  iflag);
3270 				} else
3271 					__lpfc_sli_release_iocbq(phba,
3272 								 cmdiocbp);
3273 			}
3274 			break;
3275 
3276 		case LPFC_UNKNOWN_IOCB:
3277 			if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
3278 				char adaptermsg[LPFC_MAX_ADPTMSG];
3279 				memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
3280 				memcpy(&adaptermsg[0], (uint8_t *)irsp,
3281 				       MAX_MSG_DATA);
3282 				dev_warn(&((phba->pcidev)->dev),
3283 					 "lpfc%d: %s\n",
3284 					 phba->brd_no, adaptermsg);
3285 			} else {
3286 				/* Unknown IOCB command */
3287 				lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3288 						"0335 Unknown IOCB "
3289 						"command Data: x%x "
3290 						"x%x x%x x%x\n",
3291 						irsp->ulpCommand,
3292 						irsp->ulpStatus,
3293 						irsp->ulpIoTag,
3294 						irsp->ulpContext);
3295 			}
3296 			break;
3297 		}
3298 
3299 		if (free_saveq) {
3300 			list_for_each_entry_safe(rspiocbp, next_iocb,
3301 						 &saveq->list, list) {
3302 				list_del_init(&rspiocbp->list);
3303 				__lpfc_sli_release_iocbq(phba, rspiocbp);
3304 			}
3305 			__lpfc_sli_release_iocbq(phba, saveq);
3306 		}
3307 		rspiocbp = NULL;
3308 	}
3309 	spin_unlock_irqrestore(&phba->hbalock, iflag);
3310 	return rspiocbp;
3311 }
3312 
3313 /**
3314  * lpfc_sli_handle_slow_ring_event - Wrapper func for handling slow-path iocbs
3315  * @phba: Pointer to HBA context object.
3316  * @pring: Pointer to driver SLI ring object.
3317  * @mask: Host attention register mask for this ring.
3318  *
3319  * This routine wraps the actual slow_ring event process routine from the
3320  * API jump table function pointer from the lpfc_hba struct.
3321  **/
3322 void
3323 lpfc_sli_handle_slow_ring_event(struct lpfc_hba *phba,
3324 				struct lpfc_sli_ring *pring, uint32_t mask)
3325 {
3326 	phba->lpfc_sli_handle_slow_ring_event(phba, pring, mask);
3327 }
3328 
3329 /**
3330  * lpfc_sli_handle_slow_ring_event_s3 - Handle SLI3 ring event for non-FCP rings
3331  * @phba: Pointer to HBA context object.
3332  * @pring: Pointer to driver SLI ring object.
3333  * @mask: Host attention register mask for this ring.
3334  *
3335  * This function is called from the worker thread when there is a ring event
3336  * for non-fcp rings. The caller does not hold any lock. The function will
3337  * remove each response iocb in the response ring and calls the handle
3338  * response iocb routine (lpfc_sli_sp_handle_rspiocb) to process it.
3339  **/
3340 static void
3341 lpfc_sli_handle_slow_ring_event_s3(struct lpfc_hba *phba,
3342 				   struct lpfc_sli_ring *pring, uint32_t mask)
3343 {
3344 	struct lpfc_pgp *pgp;
3345 	IOCB_t *entry;
3346 	IOCB_t *irsp = NULL;
3347 	struct lpfc_iocbq *rspiocbp = NULL;
3348 	uint32_t portRspPut, portRspMax;
3349 	unsigned long iflag;
3350 	uint32_t status;
3351 
3352 	pgp = &phba->port_gp[pring->ringno];
3353 	spin_lock_irqsave(&phba->hbalock, iflag);
3354 	pring->stats.iocb_event++;
3355 
3356 	/*
3357 	 * The next available response entry should never exceed the maximum
3358 	 * entries.  If it does, treat it as an adapter hardware error.
3359 	 */
3360 	portRspMax = pring->sli.sli3.numRiocb;
3361 	portRspPut = le32_to_cpu(pgp->rspPutInx);
3362 	if (portRspPut >= portRspMax) {
3363 		/*
3364 		 * Ring <ringno> handler: portRspPut <portRspPut> is bigger than
3365 		 * rsp ring <portRspMax>
3366 		 */
3367 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3368 				"0303 Ring %d handler: portRspPut %d "
3369 				"is bigger than rsp ring %d\n",
3370 				pring->ringno, portRspPut, portRspMax);
3371 
3372 		phba->link_state = LPFC_HBA_ERROR;
3373 		spin_unlock_irqrestore(&phba->hbalock, iflag);
3374 
3375 		phba->work_hs = HS_FFER3;
3376 		lpfc_handle_eratt(phba);
3377 
3378 		return;
3379 	}
3380 
3381 	rmb();
3382 	while (pring->sli.sli3.rspidx != portRspPut) {
3383 		/*
3384 		 * Build a completion list and call the appropriate handler.
3385 		 * The process is to get the next available response iocb, get
3386 		 * a free iocb from the list, copy the response data into the
3387 		 * free iocb, insert to the continuation list, and update the
3388 		 * next response index to slim.  This process makes response
3389 		 * iocb's in the ring available to DMA as fast as possible but
3390 		 * pays a penalty for a copy operation.  Since the iocb is
3391 		 * only 32 bytes, this penalty is considered small relative to
3392 		 * the PCI reads for register values and a slim write.  When
3393 		 * the ulpLe field is set, the entire Command has been
3394 		 * received.
3395 		 */
3396 		entry = lpfc_resp_iocb(phba, pring);
3397 
3398 		phba->last_completion_time = jiffies;
3399 		rspiocbp = __lpfc_sli_get_iocbq(phba);
3400 		if (rspiocbp == NULL) {
3401 			printk(KERN_ERR "%s: out of buffers! Failing "
3402 			       "completion.\n", __func__);
3403 			break;
3404 		}
3405 
3406 		lpfc_sli_pcimem_bcopy(entry, &rspiocbp->iocb,
3407 				      phba->iocb_rsp_size);
3408 		irsp = &rspiocbp->iocb;
3409 
3410 		if (++pring->sli.sli3.rspidx >= portRspMax)
3411 			pring->sli.sli3.rspidx = 0;
3412 
3413 		if (pring->ringno == LPFC_ELS_RING) {
3414 			lpfc_debugfs_slow_ring_trc(phba,
3415 			"IOCB rsp ring:   wd4:x%08x wd6:x%08x wd7:x%08x",
3416 				*(((uint32_t *) irsp) + 4),
3417 				*(((uint32_t *) irsp) + 6),
3418 				*(((uint32_t *) irsp) + 7));
3419 		}
3420 
3421 		writel(pring->sli.sli3.rspidx,
3422 			&phba->host_gp[pring->ringno].rspGetInx);
3423 
3424 		spin_unlock_irqrestore(&phba->hbalock, iflag);
3425 		/* Handle the response IOCB */
3426 		rspiocbp = lpfc_sli_sp_handle_rspiocb(phba, pring, rspiocbp);
3427 		spin_lock_irqsave(&phba->hbalock, iflag);
3428 
3429 		/*
3430 		 * If the port response put pointer has not been updated, sync
3431 		 * the pgp->rspPutInx in the MAILBOX_tand fetch the new port
3432 		 * response put pointer.
3433 		 */
3434 		if (pring->sli.sli3.rspidx == portRspPut) {
3435 			portRspPut = le32_to_cpu(pgp->rspPutInx);
3436 		}
3437 	} /* while (pring->sli.sli3.rspidx != portRspPut) */
3438 
3439 	if ((rspiocbp != NULL) && (mask & HA_R0RE_REQ)) {
3440 		/* At least one response entry has been freed */
3441 		pring->stats.iocb_rsp_full++;
3442 		/* SET RxRE_RSP in Chip Att register */
3443 		status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
3444 		writel(status, phba->CAregaddr);
3445 		readl(phba->CAregaddr); /* flush */
3446 	}
3447 	if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
3448 		pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
3449 		pring->stats.iocb_cmd_empty++;
3450 
3451 		/* Force update of the local copy of cmdGetInx */
3452 		pring->sli.sli3.local_getidx = le32_to_cpu(pgp->cmdGetInx);
3453 		lpfc_sli_resume_iocb(phba, pring);
3454 
3455 		if ((pring->lpfc_sli_cmd_available))
3456 			(pring->lpfc_sli_cmd_available) (phba, pring);
3457 
3458 	}
3459 
3460 	spin_unlock_irqrestore(&phba->hbalock, iflag);
3461 	return;
3462 }
3463 
3464 /**
3465  * lpfc_sli_handle_slow_ring_event_s4 - Handle SLI4 slow-path els events
3466  * @phba: Pointer to HBA context object.
3467  * @pring: Pointer to driver SLI ring object.
3468  * @mask: Host attention register mask for this ring.
3469  *
3470  * This function is called from the worker thread when there is a pending
3471  * ELS response iocb on the driver internal slow-path response iocb worker
3472  * queue. The caller does not hold any lock. The function will remove each
3473  * response iocb from the response worker queue and calls the handle
3474  * response iocb routine (lpfc_sli_sp_handle_rspiocb) to process it.
3475  **/
3476 static void
3477 lpfc_sli_handle_slow_ring_event_s4(struct lpfc_hba *phba,
3478 				   struct lpfc_sli_ring *pring, uint32_t mask)
3479 {
3480 	struct lpfc_iocbq *irspiocbq;
3481 	struct hbq_dmabuf *dmabuf;
3482 	struct lpfc_cq_event *cq_event;
3483 	unsigned long iflag;
3484 
3485 	spin_lock_irqsave(&phba->hbalock, iflag);
3486 	phba->hba_flag &= ~HBA_SP_QUEUE_EVT;
3487 	spin_unlock_irqrestore(&phba->hbalock, iflag);
3488 	while (!list_empty(&phba->sli4_hba.sp_queue_event)) {
3489 		/* Get the response iocb from the head of work queue */
3490 		spin_lock_irqsave(&phba->hbalock, iflag);
3491 		list_remove_head(&phba->sli4_hba.sp_queue_event,
3492 				 cq_event, struct lpfc_cq_event, list);
3493 		spin_unlock_irqrestore(&phba->hbalock, iflag);
3494 
3495 		switch (bf_get(lpfc_wcqe_c_code, &cq_event->cqe.wcqe_cmpl)) {
3496 		case CQE_CODE_COMPL_WQE:
3497 			irspiocbq = container_of(cq_event, struct lpfc_iocbq,
3498 						 cq_event);
3499 			/* Translate ELS WCQE to response IOCBQ */
3500 			irspiocbq = lpfc_sli4_els_wcqe_to_rspiocbq(phba,
3501 								   irspiocbq);
3502 			if (irspiocbq)
3503 				lpfc_sli_sp_handle_rspiocb(phba, pring,
3504 							   irspiocbq);
3505 			break;
3506 		case CQE_CODE_RECEIVE:
3507 		case CQE_CODE_RECEIVE_V1:
3508 			dmabuf = container_of(cq_event, struct hbq_dmabuf,
3509 					      cq_event);
3510 			lpfc_sli4_handle_received_buffer(phba, dmabuf);
3511 			break;
3512 		default:
3513 			break;
3514 		}
3515 	}
3516 }
3517 
3518 /**
3519  * lpfc_sli_abort_iocb_ring - Abort all iocbs in the ring
3520  * @phba: Pointer to HBA context object.
3521  * @pring: Pointer to driver SLI ring object.
3522  *
3523  * This function aborts all iocbs in the given ring and frees all the iocb
3524  * objects in txq. This function issues an abort iocb for all the iocb commands
3525  * in txcmplq. The iocbs in the txcmplq is not guaranteed to complete before
3526  * the return of this function. The caller is not required to hold any locks.
3527  **/
3528 void
3529 lpfc_sli_abort_iocb_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
3530 {
3531 	LIST_HEAD(completions);
3532 	struct lpfc_iocbq *iocb, *next_iocb;
3533 
3534 	if (pring->ringno == LPFC_ELS_RING) {
3535 		lpfc_fabric_abort_hba(phba);
3536 	}
3537 
3538 	/* Error everything on txq and txcmplq
3539 	 * First do the txq.
3540 	 */
3541 	if (phba->sli_rev >= LPFC_SLI_REV4) {
3542 		spin_lock_irq(&pring->ring_lock);
3543 		list_splice_init(&pring->txq, &completions);
3544 		pring->txq_cnt = 0;
3545 		spin_unlock_irq(&pring->ring_lock);
3546 
3547 		spin_lock_irq(&phba->hbalock);
3548 		/* Next issue ABTS for everything on the txcmplq */
3549 		list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list)
3550 			lpfc_sli_issue_abort_iotag(phba, pring, iocb);
3551 		spin_unlock_irq(&phba->hbalock);
3552 	} else {
3553 		spin_lock_irq(&phba->hbalock);
3554 		list_splice_init(&pring->txq, &completions);
3555 		pring->txq_cnt = 0;
3556 
3557 		/* Next issue ABTS for everything on the txcmplq */
3558 		list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list)
3559 			lpfc_sli_issue_abort_iotag(phba, pring, iocb);
3560 		spin_unlock_irq(&phba->hbalock);
3561 	}
3562 
3563 	/* Cancel all the IOCBs from the completions list */
3564 	lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
3565 			      IOERR_SLI_ABORTED);
3566 }
3567 
3568 /**
3569  * lpfc_sli_abort_fcp_rings - Abort all iocbs in all FCP rings
3570  * @phba: Pointer to HBA context object.
3571  * @pring: Pointer to driver SLI ring object.
3572  *
3573  * This function aborts all iocbs in FCP rings and frees all the iocb
3574  * objects in txq. This function issues an abort iocb for all the iocb commands
3575  * in txcmplq. The iocbs in the txcmplq is not guaranteed to complete before
3576  * the return of this function. The caller is not required to hold any locks.
3577  **/
3578 void
3579 lpfc_sli_abort_fcp_rings(struct lpfc_hba *phba)
3580 {
3581 	struct lpfc_sli *psli = &phba->sli;
3582 	struct lpfc_sli_ring  *pring;
3583 	uint32_t i;
3584 
3585 	/* Look on all the FCP Rings for the iotag */
3586 	if (phba->sli_rev >= LPFC_SLI_REV4) {
3587 		for (i = 0; i < phba->cfg_fcp_io_channel; i++) {
3588 			pring = &psli->ring[i + MAX_SLI3_CONFIGURED_RINGS];
3589 			lpfc_sli_abort_iocb_ring(phba, pring);
3590 		}
3591 	} else {
3592 		pring = &psli->ring[psli->fcp_ring];
3593 		lpfc_sli_abort_iocb_ring(phba, pring);
3594 	}
3595 }
3596 
3597 
3598 /**
3599  * lpfc_sli_flush_fcp_rings - flush all iocbs in the fcp ring
3600  * @phba: Pointer to HBA context object.
3601  *
3602  * This function flushes all iocbs in the fcp ring and frees all the iocb
3603  * objects in txq and txcmplq. This function will not issue abort iocbs
3604  * for all the iocb commands in txcmplq, they will just be returned with
3605  * IOERR_SLI_DOWN. This function is invoked with EEH when device's PCI
3606  * slot has been permanently disabled.
3607  **/
3608 void
3609 lpfc_sli_flush_fcp_rings(struct lpfc_hba *phba)
3610 {
3611 	LIST_HEAD(txq);
3612 	LIST_HEAD(txcmplq);
3613 	struct lpfc_sli *psli = &phba->sli;
3614 	struct lpfc_sli_ring  *pring;
3615 	uint32_t i;
3616 
3617 	spin_lock_irq(&phba->hbalock);
3618 	/* Indicate the I/O queues are flushed */
3619 	phba->hba_flag |= HBA_FCP_IOQ_FLUSH;
3620 	spin_unlock_irq(&phba->hbalock);
3621 
3622 	/* Look on all the FCP Rings for the iotag */
3623 	if (phba->sli_rev >= LPFC_SLI_REV4) {
3624 		for (i = 0; i < phba->cfg_fcp_io_channel; i++) {
3625 			pring = &psli->ring[i + MAX_SLI3_CONFIGURED_RINGS];
3626 
3627 			spin_lock_irq(&pring->ring_lock);
3628 			/* Retrieve everything on txq */
3629 			list_splice_init(&pring->txq, &txq);
3630 			/* Retrieve everything on the txcmplq */
3631 			list_splice_init(&pring->txcmplq, &txcmplq);
3632 			pring->txq_cnt = 0;
3633 			pring->txcmplq_cnt = 0;
3634 			spin_unlock_irq(&pring->ring_lock);
3635 
3636 			/* Flush the txq */
3637 			lpfc_sli_cancel_iocbs(phba, &txq,
3638 					      IOSTAT_LOCAL_REJECT,
3639 					      IOERR_SLI_DOWN);
3640 			/* Flush the txcmpq */
3641 			lpfc_sli_cancel_iocbs(phba, &txcmplq,
3642 					      IOSTAT_LOCAL_REJECT,
3643 					      IOERR_SLI_DOWN);
3644 		}
3645 	} else {
3646 		pring = &psli->ring[psli->fcp_ring];
3647 
3648 		spin_lock_irq(&phba->hbalock);
3649 		/* Retrieve everything on txq */
3650 		list_splice_init(&pring->txq, &txq);
3651 		/* Retrieve everything on the txcmplq */
3652 		list_splice_init(&pring->txcmplq, &txcmplq);
3653 		pring->txq_cnt = 0;
3654 		pring->txcmplq_cnt = 0;
3655 		spin_unlock_irq(&phba->hbalock);
3656 
3657 		/* Flush the txq */
3658 		lpfc_sli_cancel_iocbs(phba, &txq, IOSTAT_LOCAL_REJECT,
3659 				      IOERR_SLI_DOWN);
3660 		/* Flush the txcmpq */
3661 		lpfc_sli_cancel_iocbs(phba, &txcmplq, IOSTAT_LOCAL_REJECT,
3662 				      IOERR_SLI_DOWN);
3663 	}
3664 }
3665 
3666 /**
3667  * lpfc_sli_brdready_s3 - Check for sli3 host ready status
3668  * @phba: Pointer to HBA context object.
3669  * @mask: Bit mask to be checked.
3670  *
3671  * This function reads the host status register and compares
3672  * with the provided bit mask to check if HBA completed
3673  * the restart. This function will wait in a loop for the
3674  * HBA to complete restart. If the HBA does not restart within
3675  * 15 iterations, the function will reset the HBA again. The
3676  * function returns 1 when HBA fail to restart otherwise returns
3677  * zero.
3678  **/
3679 static int
3680 lpfc_sli_brdready_s3(struct lpfc_hba *phba, uint32_t mask)
3681 {
3682 	uint32_t status;
3683 	int i = 0;
3684 	int retval = 0;
3685 
3686 	/* Read the HBA Host Status Register */
3687 	if (lpfc_readl(phba->HSregaddr, &status))
3688 		return 1;
3689 
3690 	/*
3691 	 * Check status register every 100ms for 5 retries, then every
3692 	 * 500ms for 5, then every 2.5 sec for 5, then reset board and
3693 	 * every 2.5 sec for 4.
3694 	 * Break our of the loop if errors occurred during init.
3695 	 */
3696 	while (((status & mask) != mask) &&
3697 	       !(status & HS_FFERM) &&
3698 	       i++ < 20) {
3699 
3700 		if (i <= 5)
3701 			msleep(10);
3702 		else if (i <= 10)
3703 			msleep(500);
3704 		else
3705 			msleep(2500);
3706 
3707 		if (i == 15) {
3708 				/* Do post */
3709 			phba->pport->port_state = LPFC_VPORT_UNKNOWN;
3710 			lpfc_sli_brdrestart(phba);
3711 		}
3712 		/* Read the HBA Host Status Register */
3713 		if (lpfc_readl(phba->HSregaddr, &status)) {
3714 			retval = 1;
3715 			break;
3716 		}
3717 	}
3718 
3719 	/* Check to see if any errors occurred during init */
3720 	if ((status & HS_FFERM) || (i >= 20)) {
3721 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3722 				"2751 Adapter failed to restart, "
3723 				"status reg x%x, FW Data: A8 x%x AC x%x\n",
3724 				status,
3725 				readl(phba->MBslimaddr + 0xa8),
3726 				readl(phba->MBslimaddr + 0xac));
3727 		phba->link_state = LPFC_HBA_ERROR;
3728 		retval = 1;
3729 	}
3730 
3731 	return retval;
3732 }
3733 
3734 /**
3735  * lpfc_sli_brdready_s4 - Check for sli4 host ready status
3736  * @phba: Pointer to HBA context object.
3737  * @mask: Bit mask to be checked.
3738  *
3739  * This function checks the host status register to check if HBA is
3740  * ready. This function will wait in a loop for the HBA to be ready
3741  * If the HBA is not ready , the function will will reset the HBA PCI
3742  * function again. The function returns 1 when HBA fail to be ready
3743  * otherwise returns zero.
3744  **/
3745 static int
3746 lpfc_sli_brdready_s4(struct lpfc_hba *phba, uint32_t mask)
3747 {
3748 	uint32_t status;
3749 	int retval = 0;
3750 
3751 	/* Read the HBA Host Status Register */
3752 	status = lpfc_sli4_post_status_check(phba);
3753 
3754 	if (status) {
3755 		phba->pport->port_state = LPFC_VPORT_UNKNOWN;
3756 		lpfc_sli_brdrestart(phba);
3757 		status = lpfc_sli4_post_status_check(phba);
3758 	}
3759 
3760 	/* Check to see if any errors occurred during init */
3761 	if (status) {
3762 		phba->link_state = LPFC_HBA_ERROR;
3763 		retval = 1;
3764 	} else
3765 		phba->sli4_hba.intr_enable = 0;
3766 
3767 	return retval;
3768 }
3769 
3770 /**
3771  * lpfc_sli_brdready - Wrapper func for checking the hba readyness
3772  * @phba: Pointer to HBA context object.
3773  * @mask: Bit mask to be checked.
3774  *
3775  * This routine wraps the actual SLI3 or SLI4 hba readyness check routine
3776  * from the API jump table function pointer from the lpfc_hba struct.
3777  **/
3778 int
3779 lpfc_sli_brdready(struct lpfc_hba *phba, uint32_t mask)
3780 {
3781 	return phba->lpfc_sli_brdready(phba, mask);
3782 }
3783 
3784 #define BARRIER_TEST_PATTERN (0xdeadbeef)
3785 
3786 /**
3787  * lpfc_reset_barrier - Make HBA ready for HBA reset
3788  * @phba: Pointer to HBA context object.
3789  *
3790  * This function is called before resetting an HBA. This function is called
3791  * with hbalock held and requests HBA to quiesce DMAs before a reset.
3792  **/
3793 void lpfc_reset_barrier(struct lpfc_hba *phba)
3794 {
3795 	uint32_t __iomem *resp_buf;
3796 	uint32_t __iomem *mbox_buf;
3797 	volatile uint32_t mbox;
3798 	uint32_t hc_copy, ha_copy, resp_data;
3799 	int  i;
3800 	uint8_t hdrtype;
3801 
3802 	pci_read_config_byte(phba->pcidev, PCI_HEADER_TYPE, &hdrtype);
3803 	if (hdrtype != 0x80 ||
3804 	    (FC_JEDEC_ID(phba->vpd.rev.biuRev) != HELIOS_JEDEC_ID &&
3805 	     FC_JEDEC_ID(phba->vpd.rev.biuRev) != THOR_JEDEC_ID))
3806 		return;
3807 
3808 	/*
3809 	 * Tell the other part of the chip to suspend temporarily all
3810 	 * its DMA activity.
3811 	 */
3812 	resp_buf = phba->MBslimaddr;
3813 
3814 	/* Disable the error attention */
3815 	if (lpfc_readl(phba->HCregaddr, &hc_copy))
3816 		return;
3817 	writel((hc_copy & ~HC_ERINT_ENA), phba->HCregaddr);
3818 	readl(phba->HCregaddr); /* flush */
3819 	phba->link_flag |= LS_IGNORE_ERATT;
3820 
3821 	if (lpfc_readl(phba->HAregaddr, &ha_copy))
3822 		return;
3823 	if (ha_copy & HA_ERATT) {
3824 		/* Clear Chip error bit */
3825 		writel(HA_ERATT, phba->HAregaddr);
3826 		phba->pport->stopped = 1;
3827 	}
3828 
3829 	mbox = 0;
3830 	((MAILBOX_t *)&mbox)->mbxCommand = MBX_KILL_BOARD;
3831 	((MAILBOX_t *)&mbox)->mbxOwner = OWN_CHIP;
3832 
3833 	writel(BARRIER_TEST_PATTERN, (resp_buf + 1));
3834 	mbox_buf = phba->MBslimaddr;
3835 	writel(mbox, mbox_buf);
3836 
3837 	for (i = 0; i < 50; i++) {
3838 		if (lpfc_readl((resp_buf + 1), &resp_data))
3839 			return;
3840 		if (resp_data != ~(BARRIER_TEST_PATTERN))
3841 			mdelay(1);
3842 		else
3843 			break;
3844 	}
3845 	resp_data = 0;
3846 	if (lpfc_readl((resp_buf + 1), &resp_data))
3847 		return;
3848 	if (resp_data  != ~(BARRIER_TEST_PATTERN)) {
3849 		if (phba->sli.sli_flag & LPFC_SLI_ACTIVE ||
3850 		    phba->pport->stopped)
3851 			goto restore_hc;
3852 		else
3853 			goto clear_errat;
3854 	}
3855 
3856 	((MAILBOX_t *)&mbox)->mbxOwner = OWN_HOST;
3857 	resp_data = 0;
3858 	for (i = 0; i < 500; i++) {
3859 		if (lpfc_readl(resp_buf, &resp_data))
3860 			return;
3861 		if (resp_data != mbox)
3862 			mdelay(1);
3863 		else
3864 			break;
3865 	}
3866 
3867 clear_errat:
3868 
3869 	while (++i < 500) {
3870 		if (lpfc_readl(phba->HAregaddr, &ha_copy))
3871 			return;
3872 		if (!(ha_copy & HA_ERATT))
3873 			mdelay(1);
3874 		else
3875 			break;
3876 	}
3877 
3878 	if (readl(phba->HAregaddr) & HA_ERATT) {
3879 		writel(HA_ERATT, phba->HAregaddr);
3880 		phba->pport->stopped = 1;
3881 	}
3882 
3883 restore_hc:
3884 	phba->link_flag &= ~LS_IGNORE_ERATT;
3885 	writel(hc_copy, phba->HCregaddr);
3886 	readl(phba->HCregaddr); /* flush */
3887 }
3888 
3889 /**
3890  * lpfc_sli_brdkill - Issue a kill_board mailbox command
3891  * @phba: Pointer to HBA context object.
3892  *
3893  * This function issues a kill_board mailbox command and waits for
3894  * the error attention interrupt. This function is called for stopping
3895  * the firmware processing. The caller is not required to hold any
3896  * locks. This function calls lpfc_hba_down_post function to free
3897  * any pending commands after the kill. The function will return 1 when it
3898  * fails to kill the board else will return 0.
3899  **/
3900 int
3901 lpfc_sli_brdkill(struct lpfc_hba *phba)
3902 {
3903 	struct lpfc_sli *psli;
3904 	LPFC_MBOXQ_t *pmb;
3905 	uint32_t status;
3906 	uint32_t ha_copy;
3907 	int retval;
3908 	int i = 0;
3909 
3910 	psli = &phba->sli;
3911 
3912 	/* Kill HBA */
3913 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3914 			"0329 Kill HBA Data: x%x x%x\n",
3915 			phba->pport->port_state, psli->sli_flag);
3916 
3917 	pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3918 	if (!pmb)
3919 		return 1;
3920 
3921 	/* Disable the error attention */
3922 	spin_lock_irq(&phba->hbalock);
3923 	if (lpfc_readl(phba->HCregaddr, &status)) {
3924 		spin_unlock_irq(&phba->hbalock);
3925 		mempool_free(pmb, phba->mbox_mem_pool);
3926 		return 1;
3927 	}
3928 	status &= ~HC_ERINT_ENA;
3929 	writel(status, phba->HCregaddr);
3930 	readl(phba->HCregaddr); /* flush */
3931 	phba->link_flag |= LS_IGNORE_ERATT;
3932 	spin_unlock_irq(&phba->hbalock);
3933 
3934 	lpfc_kill_board(phba, pmb);
3935 	pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
3936 	retval = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
3937 
3938 	if (retval != MBX_SUCCESS) {
3939 		if (retval != MBX_BUSY)
3940 			mempool_free(pmb, phba->mbox_mem_pool);
3941 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3942 				"2752 KILL_BOARD command failed retval %d\n",
3943 				retval);
3944 		spin_lock_irq(&phba->hbalock);
3945 		phba->link_flag &= ~LS_IGNORE_ERATT;
3946 		spin_unlock_irq(&phba->hbalock);
3947 		return 1;
3948 	}
3949 
3950 	spin_lock_irq(&phba->hbalock);
3951 	psli->sli_flag &= ~LPFC_SLI_ACTIVE;
3952 	spin_unlock_irq(&phba->hbalock);
3953 
3954 	mempool_free(pmb, phba->mbox_mem_pool);
3955 
3956 	/* There is no completion for a KILL_BOARD mbox cmd. Check for an error
3957 	 * attention every 100ms for 3 seconds. If we don't get ERATT after
3958 	 * 3 seconds we still set HBA_ERROR state because the status of the
3959 	 * board is now undefined.
3960 	 */
3961 	if (lpfc_readl(phba->HAregaddr, &ha_copy))
3962 		return 1;
3963 	while ((i++ < 30) && !(ha_copy & HA_ERATT)) {
3964 		mdelay(100);
3965 		if (lpfc_readl(phba->HAregaddr, &ha_copy))
3966 			return 1;
3967 	}
3968 
3969 	del_timer_sync(&psli->mbox_tmo);
3970 	if (ha_copy & HA_ERATT) {
3971 		writel(HA_ERATT, phba->HAregaddr);
3972 		phba->pport->stopped = 1;
3973 	}
3974 	spin_lock_irq(&phba->hbalock);
3975 	psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3976 	psli->mbox_active = NULL;
3977 	phba->link_flag &= ~LS_IGNORE_ERATT;
3978 	spin_unlock_irq(&phba->hbalock);
3979 
3980 	lpfc_hba_down_post(phba);
3981 	phba->link_state = LPFC_HBA_ERROR;
3982 
3983 	return ha_copy & HA_ERATT ? 0 : 1;
3984 }
3985 
3986 /**
3987  * lpfc_sli_brdreset - Reset a sli-2 or sli-3 HBA
3988  * @phba: Pointer to HBA context object.
3989  *
3990  * This function resets the HBA by writing HC_INITFF to the control
3991  * register. After the HBA resets, this function resets all the iocb ring
3992  * indices. This function disables PCI layer parity checking during
3993  * the reset.
3994  * This function returns 0 always.
3995  * The caller is not required to hold any locks.
3996  **/
3997 int
3998 lpfc_sli_brdreset(struct lpfc_hba *phba)
3999 {
4000 	struct lpfc_sli *psli;
4001 	struct lpfc_sli_ring *pring;
4002 	uint16_t cfg_value;
4003 	int i;
4004 
4005 	psli = &phba->sli;
4006 
4007 	/* Reset HBA */
4008 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4009 			"0325 Reset HBA Data: x%x x%x\n",
4010 			phba->pport->port_state, psli->sli_flag);
4011 
4012 	/* perform board reset */
4013 	phba->fc_eventTag = 0;
4014 	phba->link_events = 0;
4015 	phba->pport->fc_myDID = 0;
4016 	phba->pport->fc_prevDID = 0;
4017 
4018 	/* Turn off parity checking and serr during the physical reset */
4019 	pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value);
4020 	pci_write_config_word(phba->pcidev, PCI_COMMAND,
4021 			      (cfg_value &
4022 			       ~(PCI_COMMAND_PARITY | PCI_COMMAND_SERR)));
4023 
4024 	psli->sli_flag &= ~(LPFC_SLI_ACTIVE | LPFC_PROCESS_LA);
4025 
4026 	/* Now toggle INITFF bit in the Host Control Register */
4027 	writel(HC_INITFF, phba->HCregaddr);
4028 	mdelay(1);
4029 	readl(phba->HCregaddr); /* flush */
4030 	writel(0, phba->HCregaddr);
4031 	readl(phba->HCregaddr); /* flush */
4032 
4033 	/* Restore PCI cmd register */
4034 	pci_write_config_word(phba->pcidev, PCI_COMMAND, cfg_value);
4035 
4036 	/* Initialize relevant SLI info */
4037 	for (i = 0; i < psli->num_rings; i++) {
4038 		pring = &psli->ring[i];
4039 		pring->flag = 0;
4040 		pring->sli.sli3.rspidx = 0;
4041 		pring->sli.sli3.next_cmdidx  = 0;
4042 		pring->sli.sli3.local_getidx = 0;
4043 		pring->sli.sli3.cmdidx = 0;
4044 		pring->missbufcnt = 0;
4045 	}
4046 
4047 	phba->link_state = LPFC_WARM_START;
4048 	return 0;
4049 }
4050 
4051 /**
4052  * lpfc_sli4_brdreset - Reset a sli-4 HBA
4053  * @phba: Pointer to HBA context object.
4054  *
4055  * This function resets a SLI4 HBA. This function disables PCI layer parity
4056  * checking during resets the device. The caller is not required to hold
4057  * any locks.
4058  *
4059  * This function returns 0 always.
4060  **/
4061 int
4062 lpfc_sli4_brdreset(struct lpfc_hba *phba)
4063 {
4064 	struct lpfc_sli *psli = &phba->sli;
4065 	uint16_t cfg_value;
4066 	int rc = 0;
4067 
4068 	/* Reset HBA */
4069 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4070 			"0295 Reset HBA Data: x%x x%x x%x\n",
4071 			phba->pport->port_state, psli->sli_flag,
4072 			phba->hba_flag);
4073 
4074 	/* perform board reset */
4075 	phba->fc_eventTag = 0;
4076 	phba->link_events = 0;
4077 	phba->pport->fc_myDID = 0;
4078 	phba->pport->fc_prevDID = 0;
4079 
4080 	spin_lock_irq(&phba->hbalock);
4081 	psli->sli_flag &= ~(LPFC_PROCESS_LA);
4082 	phba->fcf.fcf_flag = 0;
4083 	spin_unlock_irq(&phba->hbalock);
4084 
4085 	/* SLI4 INTF 2: if FW dump is being taken skip INIT_PORT */
4086 	if (phba->hba_flag & HBA_FW_DUMP_OP) {
4087 		phba->hba_flag &= ~HBA_FW_DUMP_OP;
4088 		return rc;
4089 	}
4090 
4091 	/* Now physically reset the device */
4092 	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4093 			"0389 Performing PCI function reset!\n");
4094 
4095 	/* Turn off parity checking and serr during the physical reset */
4096 	pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value);
4097 	pci_write_config_word(phba->pcidev, PCI_COMMAND, (cfg_value &
4098 			      ~(PCI_COMMAND_PARITY | PCI_COMMAND_SERR)));
4099 
4100 	/* Perform FCoE PCI function reset before freeing queue memory */
4101 	rc = lpfc_pci_function_reset(phba);
4102 	lpfc_sli4_queue_destroy(phba);
4103 
4104 	/* Restore PCI cmd register */
4105 	pci_write_config_word(phba->pcidev, PCI_COMMAND, cfg_value);
4106 
4107 	return rc;
4108 }
4109 
4110 /**
4111  * lpfc_sli_brdrestart_s3 - Restart a sli-3 hba
4112  * @phba: Pointer to HBA context object.
4113  *
4114  * This function is called in the SLI initialization code path to
4115  * restart the HBA. The caller is not required to hold any lock.
4116  * This function writes MBX_RESTART mailbox command to the SLIM and
4117  * resets the HBA. At the end of the function, it calls lpfc_hba_down_post
4118  * function to free any pending commands. The function enables
4119  * POST only during the first initialization. The function returns zero.
4120  * The function does not guarantee completion of MBX_RESTART mailbox
4121  * command before the return of this function.
4122  **/
4123 static int
4124 lpfc_sli_brdrestart_s3(struct lpfc_hba *phba)
4125 {
4126 	MAILBOX_t *mb;
4127 	struct lpfc_sli *psli;
4128 	volatile uint32_t word0;
4129 	void __iomem *to_slim;
4130 	uint32_t hba_aer_enabled;
4131 
4132 	spin_lock_irq(&phba->hbalock);
4133 
4134 	/* Take PCIe device Advanced Error Reporting (AER) state */
4135 	hba_aer_enabled = phba->hba_flag & HBA_AER_ENABLED;
4136 
4137 	psli = &phba->sli;
4138 
4139 	/* Restart HBA */
4140 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4141 			"0337 Restart HBA Data: x%x x%x\n",
4142 			phba->pport->port_state, psli->sli_flag);
4143 
4144 	word0 = 0;
4145 	mb = (MAILBOX_t *) &word0;
4146 	mb->mbxCommand = MBX_RESTART;
4147 	mb->mbxHc = 1;
4148 
4149 	lpfc_reset_barrier(phba);
4150 
4151 	to_slim = phba->MBslimaddr;
4152 	writel(*(uint32_t *) mb, to_slim);
4153 	readl(to_slim); /* flush */
4154 
4155 	/* Only skip post after fc_ffinit is completed */
4156 	if (phba->pport->port_state)
4157 		word0 = 1;	/* This is really setting up word1 */
4158 	else
4159 		word0 = 0;	/* This is really setting up word1 */
4160 	to_slim = phba->MBslimaddr + sizeof (uint32_t);
4161 	writel(*(uint32_t *) mb, to_slim);
4162 	readl(to_slim); /* flush */
4163 
4164 	lpfc_sli_brdreset(phba);
4165 	phba->pport->stopped = 0;
4166 	phba->link_state = LPFC_INIT_START;
4167 	phba->hba_flag = 0;
4168 	spin_unlock_irq(&phba->hbalock);
4169 
4170 	memset(&psli->lnk_stat_offsets, 0, sizeof(psli->lnk_stat_offsets));
4171 	psli->stats_start = get_seconds();
4172 
4173 	/* Give the INITFF and Post time to settle. */
4174 	mdelay(100);
4175 
4176 	/* Reset HBA AER if it was enabled, note hba_flag was reset above */
4177 	if (hba_aer_enabled)
4178 		pci_disable_pcie_error_reporting(phba->pcidev);
4179 
4180 	lpfc_hba_down_post(phba);
4181 
4182 	return 0;
4183 }
4184 
4185 /**
4186  * lpfc_sli_brdrestart_s4 - Restart the sli-4 hba
4187  * @phba: Pointer to HBA context object.
4188  *
4189  * This function is called in the SLI initialization code path to restart
4190  * a SLI4 HBA. The caller is not required to hold any lock.
4191  * At the end of the function, it calls lpfc_hba_down_post function to
4192  * free any pending commands.
4193  **/
4194 static int
4195 lpfc_sli_brdrestart_s4(struct lpfc_hba *phba)
4196 {
4197 	struct lpfc_sli *psli = &phba->sli;
4198 	uint32_t hba_aer_enabled;
4199 	int rc;
4200 
4201 	/* Restart HBA */
4202 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4203 			"0296 Restart HBA Data: x%x x%x\n",
4204 			phba->pport->port_state, psli->sli_flag);
4205 
4206 	/* Take PCIe device Advanced Error Reporting (AER) state */
4207 	hba_aer_enabled = phba->hba_flag & HBA_AER_ENABLED;
4208 
4209 	rc = lpfc_sli4_brdreset(phba);
4210 
4211 	spin_lock_irq(&phba->hbalock);
4212 	phba->pport->stopped = 0;
4213 	phba->link_state = LPFC_INIT_START;
4214 	phba->hba_flag = 0;
4215 	spin_unlock_irq(&phba->hbalock);
4216 
4217 	memset(&psli->lnk_stat_offsets, 0, sizeof(psli->lnk_stat_offsets));
4218 	psli->stats_start = get_seconds();
4219 
4220 	/* Reset HBA AER if it was enabled, note hba_flag was reset above */
4221 	if (hba_aer_enabled)
4222 		pci_disable_pcie_error_reporting(phba->pcidev);
4223 
4224 	lpfc_hba_down_post(phba);
4225 
4226 	return rc;
4227 }
4228 
4229 /**
4230  * lpfc_sli_brdrestart - Wrapper func for restarting hba
4231  * @phba: Pointer to HBA context object.
4232  *
4233  * This routine wraps the actual SLI3 or SLI4 hba restart routine from the
4234  * API jump table function pointer from the lpfc_hba struct.
4235 **/
4236 int
4237 lpfc_sli_brdrestart(struct lpfc_hba *phba)
4238 {
4239 	return phba->lpfc_sli_brdrestart(phba);
4240 }
4241 
4242 /**
4243  * lpfc_sli_chipset_init - Wait for the restart of the HBA after a restart
4244  * @phba: Pointer to HBA context object.
4245  *
4246  * This function is called after a HBA restart to wait for successful
4247  * restart of the HBA. Successful restart of the HBA is indicated by
4248  * HS_FFRDY and HS_MBRDY bits. If the HBA fails to restart even after 15
4249  * iteration, the function will restart the HBA again. The function returns
4250  * zero if HBA successfully restarted else returns negative error code.
4251  **/
4252 static int
4253 lpfc_sli_chipset_init(struct lpfc_hba *phba)
4254 {
4255 	uint32_t status, i = 0;
4256 
4257 	/* Read the HBA Host Status Register */
4258 	if (lpfc_readl(phba->HSregaddr, &status))
4259 		return -EIO;
4260 
4261 	/* Check status register to see what current state is */
4262 	i = 0;
4263 	while ((status & (HS_FFRDY | HS_MBRDY)) != (HS_FFRDY | HS_MBRDY)) {
4264 
4265 		/* Check every 10ms for 10 retries, then every 100ms for 90
4266 		 * retries, then every 1 sec for 50 retires for a total of
4267 		 * ~60 seconds before reset the board again and check every
4268 		 * 1 sec for 50 retries. The up to 60 seconds before the
4269 		 * board ready is required by the Falcon FIPS zeroization
4270 		 * complete, and any reset the board in between shall cause
4271 		 * restart of zeroization, further delay the board ready.
4272 		 */
4273 		if (i++ >= 200) {
4274 			/* Adapter failed to init, timeout, status reg
4275 			   <status> */
4276 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4277 					"0436 Adapter failed to init, "
4278 					"timeout, status reg x%x, "
4279 					"FW Data: A8 x%x AC x%x\n", status,
4280 					readl(phba->MBslimaddr + 0xa8),
4281 					readl(phba->MBslimaddr + 0xac));
4282 			phba->link_state = LPFC_HBA_ERROR;
4283 			return -ETIMEDOUT;
4284 		}
4285 
4286 		/* Check to see if any errors occurred during init */
4287 		if (status & HS_FFERM) {
4288 			/* ERROR: During chipset initialization */
4289 			/* Adapter failed to init, chipset, status reg
4290 			   <status> */
4291 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4292 					"0437 Adapter failed to init, "
4293 					"chipset, status reg x%x, "
4294 					"FW Data: A8 x%x AC x%x\n", status,
4295 					readl(phba->MBslimaddr + 0xa8),
4296 					readl(phba->MBslimaddr + 0xac));
4297 			phba->link_state = LPFC_HBA_ERROR;
4298 			return -EIO;
4299 		}
4300 
4301 		if (i <= 10)
4302 			msleep(10);
4303 		else if (i <= 100)
4304 			msleep(100);
4305 		else
4306 			msleep(1000);
4307 
4308 		if (i == 150) {
4309 			/* Do post */
4310 			phba->pport->port_state = LPFC_VPORT_UNKNOWN;
4311 			lpfc_sli_brdrestart(phba);
4312 		}
4313 		/* Read the HBA Host Status Register */
4314 		if (lpfc_readl(phba->HSregaddr, &status))
4315 			return -EIO;
4316 	}
4317 
4318 	/* Check to see if any errors occurred during init */
4319 	if (status & HS_FFERM) {
4320 		/* ERROR: During chipset initialization */
4321 		/* Adapter failed to init, chipset, status reg <status> */
4322 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4323 				"0438 Adapter failed to init, chipset, "
4324 				"status reg x%x, "
4325 				"FW Data: A8 x%x AC x%x\n", status,
4326 				readl(phba->MBslimaddr + 0xa8),
4327 				readl(phba->MBslimaddr + 0xac));
4328 		phba->link_state = LPFC_HBA_ERROR;
4329 		return -EIO;
4330 	}
4331 
4332 	/* Clear all interrupt enable conditions */
4333 	writel(0, phba->HCregaddr);
4334 	readl(phba->HCregaddr); /* flush */
4335 
4336 	/* setup host attn register */
4337 	writel(0xffffffff, phba->HAregaddr);
4338 	readl(phba->HAregaddr); /* flush */
4339 	return 0;
4340 }
4341 
4342 /**
4343  * lpfc_sli_hbq_count - Get the number of HBQs to be configured
4344  *
4345  * This function calculates and returns the number of HBQs required to be
4346  * configured.
4347  **/
4348 int
4349 lpfc_sli_hbq_count(void)
4350 {
4351 	return ARRAY_SIZE(lpfc_hbq_defs);
4352 }
4353 
4354 /**
4355  * lpfc_sli_hbq_entry_count - Calculate total number of hbq entries
4356  *
4357  * This function adds the number of hbq entries in every HBQ to get
4358  * the total number of hbq entries required for the HBA and returns
4359  * the total count.
4360  **/
4361 static int
4362 lpfc_sli_hbq_entry_count(void)
4363 {
4364 	int  hbq_count = lpfc_sli_hbq_count();
4365 	int  count = 0;
4366 	int  i;
4367 
4368 	for (i = 0; i < hbq_count; ++i)
4369 		count += lpfc_hbq_defs[i]->entry_count;
4370 	return count;
4371 }
4372 
4373 /**
4374  * lpfc_sli_hbq_size - Calculate memory required for all hbq entries
4375  *
4376  * This function calculates amount of memory required for all hbq entries
4377  * to be configured and returns the total memory required.
4378  **/
4379 int
4380 lpfc_sli_hbq_size(void)
4381 {
4382 	return lpfc_sli_hbq_entry_count() * sizeof(struct lpfc_hbq_entry);
4383 }
4384 
4385 /**
4386  * lpfc_sli_hbq_setup - configure and initialize HBQs
4387  * @phba: Pointer to HBA context object.
4388  *
4389  * This function is called during the SLI initialization to configure
4390  * all the HBQs and post buffers to the HBQ. The caller is not
4391  * required to hold any locks. This function will return zero if successful
4392  * else it will return negative error code.
4393  **/
4394 static int
4395 lpfc_sli_hbq_setup(struct lpfc_hba *phba)
4396 {
4397 	int  hbq_count = lpfc_sli_hbq_count();
4398 	LPFC_MBOXQ_t *pmb;
4399 	MAILBOX_t *pmbox;
4400 	uint32_t hbqno;
4401 	uint32_t hbq_entry_index;
4402 
4403 				/* Get a Mailbox buffer to setup mailbox
4404 				 * commands for HBA initialization
4405 				 */
4406 	pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4407 
4408 	if (!pmb)
4409 		return -ENOMEM;
4410 
4411 	pmbox = &pmb->u.mb;
4412 
4413 	/* Initialize the struct lpfc_sli_hbq structure for each hbq */
4414 	phba->link_state = LPFC_INIT_MBX_CMDS;
4415 	phba->hbq_in_use = 1;
4416 
4417 	hbq_entry_index = 0;
4418 	for (hbqno = 0; hbqno < hbq_count; ++hbqno) {
4419 		phba->hbqs[hbqno].next_hbqPutIdx = 0;
4420 		phba->hbqs[hbqno].hbqPutIdx      = 0;
4421 		phba->hbqs[hbqno].local_hbqGetIdx   = 0;
4422 		phba->hbqs[hbqno].entry_count =
4423 			lpfc_hbq_defs[hbqno]->entry_count;
4424 		lpfc_config_hbq(phba, hbqno, lpfc_hbq_defs[hbqno],
4425 			hbq_entry_index, pmb);
4426 		hbq_entry_index += phba->hbqs[hbqno].entry_count;
4427 
4428 		if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
4429 			/* Adapter failed to init, mbxCmd <cmd> CFG_RING,
4430 			   mbxStatus <status>, ring <num> */
4431 
4432 			lpfc_printf_log(phba, KERN_ERR,
4433 					LOG_SLI | LOG_VPORT,
4434 					"1805 Adapter failed to init. "
4435 					"Data: x%x x%x x%x\n",
4436 					pmbox->mbxCommand,
4437 					pmbox->mbxStatus, hbqno);
4438 
4439 			phba->link_state = LPFC_HBA_ERROR;
4440 			mempool_free(pmb, phba->mbox_mem_pool);
4441 			return -ENXIO;
4442 		}
4443 	}
4444 	phba->hbq_count = hbq_count;
4445 
4446 	mempool_free(pmb, phba->mbox_mem_pool);
4447 
4448 	/* Initially populate or replenish the HBQs */
4449 	for (hbqno = 0; hbqno < hbq_count; ++hbqno)
4450 		lpfc_sli_hbqbuf_init_hbqs(phba, hbqno);
4451 	return 0;
4452 }
4453 
4454 /**
4455  * lpfc_sli4_rb_setup - Initialize and post RBs to HBA
4456  * @phba: Pointer to HBA context object.
4457  *
4458  * This function is called during the SLI initialization to configure
4459  * all the HBQs and post buffers to the HBQ. The caller is not
4460  * required to hold any locks. This function will return zero if successful
4461  * else it will return negative error code.
4462  **/
4463 static int
4464 lpfc_sli4_rb_setup(struct lpfc_hba *phba)
4465 {
4466 	phba->hbq_in_use = 1;
4467 	phba->hbqs[0].entry_count = lpfc_hbq_defs[0]->entry_count;
4468 	phba->hbq_count = 1;
4469 	/* Initially populate or replenish the HBQs */
4470 	lpfc_sli_hbqbuf_init_hbqs(phba, 0);
4471 	return 0;
4472 }
4473 
4474 /**
4475  * lpfc_sli_config_port - Issue config port mailbox command
4476  * @phba: Pointer to HBA context object.
4477  * @sli_mode: sli mode - 2/3
4478  *
4479  * This function is called by the sli intialization code path
4480  * to issue config_port mailbox command. This function restarts the
4481  * HBA firmware and issues a config_port mailbox command to configure
4482  * the SLI interface in the sli mode specified by sli_mode
4483  * variable. The caller is not required to hold any locks.
4484  * The function returns 0 if successful, else returns negative error
4485  * code.
4486  **/
4487 int
4488 lpfc_sli_config_port(struct lpfc_hba *phba, int sli_mode)
4489 {
4490 	LPFC_MBOXQ_t *pmb;
4491 	uint32_t resetcount = 0, rc = 0, done = 0;
4492 
4493 	pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4494 	if (!pmb) {
4495 		phba->link_state = LPFC_HBA_ERROR;
4496 		return -ENOMEM;
4497 	}
4498 
4499 	phba->sli_rev = sli_mode;
4500 	while (resetcount < 2 && !done) {
4501 		spin_lock_irq(&phba->hbalock);
4502 		phba->sli.sli_flag |= LPFC_SLI_MBOX_ACTIVE;
4503 		spin_unlock_irq(&phba->hbalock);
4504 		phba->pport->port_state = LPFC_VPORT_UNKNOWN;
4505 		lpfc_sli_brdrestart(phba);
4506 		rc = lpfc_sli_chipset_init(phba);
4507 		if (rc)
4508 			break;
4509 
4510 		spin_lock_irq(&phba->hbalock);
4511 		phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
4512 		spin_unlock_irq(&phba->hbalock);
4513 		resetcount++;
4514 
4515 		/* Call pre CONFIG_PORT mailbox command initialization.  A
4516 		 * value of 0 means the call was successful.  Any other
4517 		 * nonzero value is a failure, but if ERESTART is returned,
4518 		 * the driver may reset the HBA and try again.
4519 		 */
4520 		rc = lpfc_config_port_prep(phba);
4521 		if (rc == -ERESTART) {
4522 			phba->link_state = LPFC_LINK_UNKNOWN;
4523 			continue;
4524 		} else if (rc)
4525 			break;
4526 
4527 		phba->link_state = LPFC_INIT_MBX_CMDS;
4528 		lpfc_config_port(phba, pmb);
4529 		rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
4530 		phba->sli3_options &= ~(LPFC_SLI3_NPIV_ENABLED |
4531 					LPFC_SLI3_HBQ_ENABLED |
4532 					LPFC_SLI3_CRP_ENABLED |
4533 					LPFC_SLI3_BG_ENABLED |
4534 					LPFC_SLI3_DSS_ENABLED);
4535 		if (rc != MBX_SUCCESS) {
4536 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4537 				"0442 Adapter failed to init, mbxCmd x%x "
4538 				"CONFIG_PORT, mbxStatus x%x Data: x%x\n",
4539 				pmb->u.mb.mbxCommand, pmb->u.mb.mbxStatus, 0);
4540 			spin_lock_irq(&phba->hbalock);
4541 			phba->sli.sli_flag &= ~LPFC_SLI_ACTIVE;
4542 			spin_unlock_irq(&phba->hbalock);
4543 			rc = -ENXIO;
4544 		} else {
4545 			/* Allow asynchronous mailbox command to go through */
4546 			spin_lock_irq(&phba->hbalock);
4547 			phba->sli.sli_flag &= ~LPFC_SLI_ASYNC_MBX_BLK;
4548 			spin_unlock_irq(&phba->hbalock);
4549 			done = 1;
4550 
4551 			if ((pmb->u.mb.un.varCfgPort.casabt == 1) &&
4552 			    (pmb->u.mb.un.varCfgPort.gasabt == 0))
4553 				lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
4554 					"3110 Port did not grant ASABT\n");
4555 		}
4556 	}
4557 	if (!done) {
4558 		rc = -EINVAL;
4559 		goto do_prep_failed;
4560 	}
4561 	if (pmb->u.mb.un.varCfgPort.sli_mode == 3) {
4562 		if (!pmb->u.mb.un.varCfgPort.cMA) {
4563 			rc = -ENXIO;
4564 			goto do_prep_failed;
4565 		}
4566 		if (phba->max_vpi && pmb->u.mb.un.varCfgPort.gmv) {
4567 			phba->sli3_options |= LPFC_SLI3_NPIV_ENABLED;
4568 			phba->max_vpi = pmb->u.mb.un.varCfgPort.max_vpi;
4569 			phba->max_vports = (phba->max_vpi > phba->max_vports) ?
4570 				phba->max_vpi : phba->max_vports;
4571 
4572 		} else
4573 			phba->max_vpi = 0;
4574 		phba->fips_level = 0;
4575 		phba->fips_spec_rev = 0;
4576 		if (pmb->u.mb.un.varCfgPort.gdss) {
4577 			phba->sli3_options |= LPFC_SLI3_DSS_ENABLED;
4578 			phba->fips_level = pmb->u.mb.un.varCfgPort.fips_level;
4579 			phba->fips_spec_rev = pmb->u.mb.un.varCfgPort.fips_rev;
4580 			lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4581 					"2850 Security Crypto Active. FIPS x%d "
4582 					"(Spec Rev: x%d)",
4583 					phba->fips_level, phba->fips_spec_rev);
4584 		}
4585 		if (pmb->u.mb.un.varCfgPort.sec_err) {
4586 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4587 					"2856 Config Port Security Crypto "
4588 					"Error: x%x ",
4589 					pmb->u.mb.un.varCfgPort.sec_err);
4590 		}
4591 		if (pmb->u.mb.un.varCfgPort.gerbm)
4592 			phba->sli3_options |= LPFC_SLI3_HBQ_ENABLED;
4593 		if (pmb->u.mb.un.varCfgPort.gcrp)
4594 			phba->sli3_options |= LPFC_SLI3_CRP_ENABLED;
4595 
4596 		phba->hbq_get = phba->mbox->us.s3_pgp.hbq_get;
4597 		phba->port_gp = phba->mbox->us.s3_pgp.port;
4598 
4599 		if (phba->cfg_enable_bg) {
4600 			if (pmb->u.mb.un.varCfgPort.gbg)
4601 				phba->sli3_options |= LPFC_SLI3_BG_ENABLED;
4602 			else
4603 				lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4604 						"0443 Adapter did not grant "
4605 						"BlockGuard\n");
4606 		}
4607 	} else {
4608 		phba->hbq_get = NULL;
4609 		phba->port_gp = phba->mbox->us.s2.port;
4610 		phba->max_vpi = 0;
4611 	}
4612 do_prep_failed:
4613 	mempool_free(pmb, phba->mbox_mem_pool);
4614 	return rc;
4615 }
4616 
4617 
4618 /**
4619  * lpfc_sli_hba_setup - SLI intialization function
4620  * @phba: Pointer to HBA context object.
4621  *
4622  * This function is the main SLI intialization function. This function
4623  * is called by the HBA intialization code, HBA reset code and HBA
4624  * error attention handler code. Caller is not required to hold any
4625  * locks. This function issues config_port mailbox command to configure
4626  * the SLI, setup iocb rings and HBQ rings. In the end the function
4627  * calls the config_port_post function to issue init_link mailbox
4628  * command and to start the discovery. The function will return zero
4629  * if successful, else it will return negative error code.
4630  **/
4631 int
4632 lpfc_sli_hba_setup(struct lpfc_hba *phba)
4633 {
4634 	uint32_t rc;
4635 	int  mode = 3, i;
4636 	int longs;
4637 
4638 	switch (lpfc_sli_mode) {
4639 	case 2:
4640 		if (phba->cfg_enable_npiv) {
4641 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
4642 				"1824 NPIV enabled: Override lpfc_sli_mode "
4643 				"parameter (%d) to auto (0).\n",
4644 				lpfc_sli_mode);
4645 			break;
4646 		}
4647 		mode = 2;
4648 		break;
4649 	case 0:
4650 	case 3:
4651 		break;
4652 	default:
4653 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
4654 				"1819 Unrecognized lpfc_sli_mode "
4655 				"parameter: %d.\n", lpfc_sli_mode);
4656 
4657 		break;
4658 	}
4659 
4660 	rc = lpfc_sli_config_port(phba, mode);
4661 
4662 	if (rc && lpfc_sli_mode == 3)
4663 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
4664 				"1820 Unable to select SLI-3.  "
4665 				"Not supported by adapter.\n");
4666 	if (rc && mode != 2)
4667 		rc = lpfc_sli_config_port(phba, 2);
4668 	if (rc)
4669 		goto lpfc_sli_hba_setup_error;
4670 
4671 	/* Enable PCIe device Advanced Error Reporting (AER) if configured */
4672 	if (phba->cfg_aer_support == 1 && !(phba->hba_flag & HBA_AER_ENABLED)) {
4673 		rc = pci_enable_pcie_error_reporting(phba->pcidev);
4674 		if (!rc) {
4675 			lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4676 					"2709 This device supports "
4677 					"Advanced Error Reporting (AER)\n");
4678 			spin_lock_irq(&phba->hbalock);
4679 			phba->hba_flag |= HBA_AER_ENABLED;
4680 			spin_unlock_irq(&phba->hbalock);
4681 		} else {
4682 			lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4683 					"2708 This device does not support "
4684 					"Advanced Error Reporting (AER): %d\n",
4685 					rc);
4686 			phba->cfg_aer_support = 0;
4687 		}
4688 	}
4689 
4690 	if (phba->sli_rev == 3) {
4691 		phba->iocb_cmd_size = SLI3_IOCB_CMD_SIZE;
4692 		phba->iocb_rsp_size = SLI3_IOCB_RSP_SIZE;
4693 	} else {
4694 		phba->iocb_cmd_size = SLI2_IOCB_CMD_SIZE;
4695 		phba->iocb_rsp_size = SLI2_IOCB_RSP_SIZE;
4696 		phba->sli3_options = 0;
4697 	}
4698 
4699 	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4700 			"0444 Firmware in SLI %x mode. Max_vpi %d\n",
4701 			phba->sli_rev, phba->max_vpi);
4702 	rc = lpfc_sli_ring_map(phba);
4703 
4704 	if (rc)
4705 		goto lpfc_sli_hba_setup_error;
4706 
4707 	/* Initialize VPIs. */
4708 	if (phba->sli_rev == LPFC_SLI_REV3) {
4709 		/*
4710 		 * The VPI bitmask and physical ID array are allocated
4711 		 * and initialized once only - at driver load.  A port
4712 		 * reset doesn't need to reinitialize this memory.
4713 		 */
4714 		if ((phba->vpi_bmask == NULL) && (phba->vpi_ids == NULL)) {
4715 			longs = (phba->max_vpi + BITS_PER_LONG) / BITS_PER_LONG;
4716 			phba->vpi_bmask = kzalloc(longs * sizeof(unsigned long),
4717 						  GFP_KERNEL);
4718 			if (!phba->vpi_bmask) {
4719 				rc = -ENOMEM;
4720 				goto lpfc_sli_hba_setup_error;
4721 			}
4722 
4723 			phba->vpi_ids = kzalloc(
4724 					(phba->max_vpi+1) * sizeof(uint16_t),
4725 					GFP_KERNEL);
4726 			if (!phba->vpi_ids) {
4727 				kfree(phba->vpi_bmask);
4728 				rc = -ENOMEM;
4729 				goto lpfc_sli_hba_setup_error;
4730 			}
4731 			for (i = 0; i < phba->max_vpi; i++)
4732 				phba->vpi_ids[i] = i;
4733 		}
4734 	}
4735 
4736 	/* Init HBQs */
4737 	if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
4738 		rc = lpfc_sli_hbq_setup(phba);
4739 		if (rc)
4740 			goto lpfc_sli_hba_setup_error;
4741 	}
4742 	spin_lock_irq(&phba->hbalock);
4743 	phba->sli.sli_flag |= LPFC_PROCESS_LA;
4744 	spin_unlock_irq(&phba->hbalock);
4745 
4746 	rc = lpfc_config_port_post(phba);
4747 	if (rc)
4748 		goto lpfc_sli_hba_setup_error;
4749 
4750 	return rc;
4751 
4752 lpfc_sli_hba_setup_error:
4753 	phba->link_state = LPFC_HBA_ERROR;
4754 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4755 			"0445 Firmware initialization failed\n");
4756 	return rc;
4757 }
4758 
4759 /**
4760  * lpfc_sli4_read_fcoe_params - Read fcoe params from conf region
4761  * @phba: Pointer to HBA context object.
4762  * @mboxq: mailbox pointer.
4763  * This function issue a dump mailbox command to read config region
4764  * 23 and parse the records in the region and populate driver
4765  * data structure.
4766  **/
4767 static int
4768 lpfc_sli4_read_fcoe_params(struct lpfc_hba *phba)
4769 {
4770 	LPFC_MBOXQ_t *mboxq;
4771 	struct lpfc_dmabuf *mp;
4772 	struct lpfc_mqe *mqe;
4773 	uint32_t data_length;
4774 	int rc;
4775 
4776 	/* Program the default value of vlan_id and fc_map */
4777 	phba->valid_vlan = 0;
4778 	phba->fc_map[0] = LPFC_FCOE_FCF_MAP0;
4779 	phba->fc_map[1] = LPFC_FCOE_FCF_MAP1;
4780 	phba->fc_map[2] = LPFC_FCOE_FCF_MAP2;
4781 
4782 	mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4783 	if (!mboxq)
4784 		return -ENOMEM;
4785 
4786 	mqe = &mboxq->u.mqe;
4787 	if (lpfc_sli4_dump_cfg_rg23(phba, mboxq)) {
4788 		rc = -ENOMEM;
4789 		goto out_free_mboxq;
4790 	}
4791 
4792 	mp = (struct lpfc_dmabuf *) mboxq->context1;
4793 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
4794 
4795 	lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
4796 			"(%d):2571 Mailbox cmd x%x Status x%x "
4797 			"Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x "
4798 			"x%x x%x x%x x%x x%x x%x x%x x%x x%x "
4799 			"CQ: x%x x%x x%x x%x\n",
4800 			mboxq->vport ? mboxq->vport->vpi : 0,
4801 			bf_get(lpfc_mqe_command, mqe),
4802 			bf_get(lpfc_mqe_status, mqe),
4803 			mqe->un.mb_words[0], mqe->un.mb_words[1],
4804 			mqe->un.mb_words[2], mqe->un.mb_words[3],
4805 			mqe->un.mb_words[4], mqe->un.mb_words[5],
4806 			mqe->un.mb_words[6], mqe->un.mb_words[7],
4807 			mqe->un.mb_words[8], mqe->un.mb_words[9],
4808 			mqe->un.mb_words[10], mqe->un.mb_words[11],
4809 			mqe->un.mb_words[12], mqe->un.mb_words[13],
4810 			mqe->un.mb_words[14], mqe->un.mb_words[15],
4811 			mqe->un.mb_words[16], mqe->un.mb_words[50],
4812 			mboxq->mcqe.word0,
4813 			mboxq->mcqe.mcqe_tag0, 	mboxq->mcqe.mcqe_tag1,
4814 			mboxq->mcqe.trailer);
4815 
4816 	if (rc) {
4817 		lpfc_mbuf_free(phba, mp->virt, mp->phys);
4818 		kfree(mp);
4819 		rc = -EIO;
4820 		goto out_free_mboxq;
4821 	}
4822 	data_length = mqe->un.mb_words[5];
4823 	if (data_length > DMP_RGN23_SIZE) {
4824 		lpfc_mbuf_free(phba, mp->virt, mp->phys);
4825 		kfree(mp);
4826 		rc = -EIO;
4827 		goto out_free_mboxq;
4828 	}
4829 
4830 	lpfc_parse_fcoe_conf(phba, mp->virt, data_length);
4831 	lpfc_mbuf_free(phba, mp->virt, mp->phys);
4832 	kfree(mp);
4833 	rc = 0;
4834 
4835 out_free_mboxq:
4836 	mempool_free(mboxq, phba->mbox_mem_pool);
4837 	return rc;
4838 }
4839 
4840 /**
4841  * lpfc_sli4_read_rev - Issue READ_REV and collect vpd data
4842  * @phba: pointer to lpfc hba data structure.
4843  * @mboxq: pointer to the LPFC_MBOXQ_t structure.
4844  * @vpd: pointer to the memory to hold resulting port vpd data.
4845  * @vpd_size: On input, the number of bytes allocated to @vpd.
4846  *	      On output, the number of data bytes in @vpd.
4847  *
4848  * This routine executes a READ_REV SLI4 mailbox command.  In
4849  * addition, this routine gets the port vpd data.
4850  *
4851  * Return codes
4852  * 	0 - successful
4853  * 	-ENOMEM - could not allocated memory.
4854  **/
4855 static int
4856 lpfc_sli4_read_rev(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,
4857 		    uint8_t *vpd, uint32_t *vpd_size)
4858 {
4859 	int rc = 0;
4860 	uint32_t dma_size;
4861 	struct lpfc_dmabuf *dmabuf;
4862 	struct lpfc_mqe *mqe;
4863 
4864 	dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
4865 	if (!dmabuf)
4866 		return -ENOMEM;
4867 
4868 	/*
4869 	 * Get a DMA buffer for the vpd data resulting from the READ_REV
4870 	 * mailbox command.
4871 	 */
4872 	dma_size = *vpd_size;
4873 	dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev, dma_size,
4874 					   &dmabuf->phys, GFP_KERNEL);
4875 	if (!dmabuf->virt) {
4876 		kfree(dmabuf);
4877 		return -ENOMEM;
4878 	}
4879 
4880 	/*
4881 	 * The SLI4 implementation of READ_REV conflicts at word1,
4882 	 * bits 31:16 and SLI4 adds vpd functionality not present
4883 	 * in SLI3.  This code corrects the conflicts.
4884 	 */
4885 	lpfc_read_rev(phba, mboxq);
4886 	mqe = &mboxq->u.mqe;
4887 	mqe->un.read_rev.vpd_paddr_high = putPaddrHigh(dmabuf->phys);
4888 	mqe->un.read_rev.vpd_paddr_low = putPaddrLow(dmabuf->phys);
4889 	mqe->un.read_rev.word1 &= 0x0000FFFF;
4890 	bf_set(lpfc_mbx_rd_rev_vpd, &mqe->un.read_rev, 1);
4891 	bf_set(lpfc_mbx_rd_rev_avail_len, &mqe->un.read_rev, dma_size);
4892 
4893 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
4894 	if (rc) {
4895 		dma_free_coherent(&phba->pcidev->dev, dma_size,
4896 				  dmabuf->virt, dmabuf->phys);
4897 		kfree(dmabuf);
4898 		return -EIO;
4899 	}
4900 
4901 	/*
4902 	 * The available vpd length cannot be bigger than the
4903 	 * DMA buffer passed to the port.  Catch the less than
4904 	 * case and update the caller's size.
4905 	 */
4906 	if (mqe->un.read_rev.avail_vpd_len < *vpd_size)
4907 		*vpd_size = mqe->un.read_rev.avail_vpd_len;
4908 
4909 	memcpy(vpd, dmabuf->virt, *vpd_size);
4910 
4911 	dma_free_coherent(&phba->pcidev->dev, dma_size,
4912 			  dmabuf->virt, dmabuf->phys);
4913 	kfree(dmabuf);
4914 	return 0;
4915 }
4916 
4917 /**
4918  * lpfc_sli4_retrieve_pport_name - Retrieve SLI4 device physical port name
4919  * @phba: pointer to lpfc hba data structure.
4920  *
4921  * This routine retrieves SLI4 device physical port name this PCI function
4922  * is attached to.
4923  *
4924  * Return codes
4925  *      0 - successful
4926  *      otherwise - failed to retrieve physical port name
4927  **/
4928 static int
4929 lpfc_sli4_retrieve_pport_name(struct lpfc_hba *phba)
4930 {
4931 	LPFC_MBOXQ_t *mboxq;
4932 	struct lpfc_mbx_get_cntl_attributes *mbx_cntl_attr;
4933 	struct lpfc_controller_attribute *cntl_attr;
4934 	struct lpfc_mbx_get_port_name *get_port_name;
4935 	void *virtaddr = NULL;
4936 	uint32_t alloclen, reqlen;
4937 	uint32_t shdr_status, shdr_add_status;
4938 	union lpfc_sli4_cfg_shdr *shdr;
4939 	char cport_name = 0;
4940 	int rc;
4941 
4942 	/* We assume nothing at this point */
4943 	phba->sli4_hba.lnk_info.lnk_dv = LPFC_LNK_DAT_INVAL;
4944 	phba->sli4_hba.pport_name_sta = LPFC_SLI4_PPNAME_NON;
4945 
4946 	mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4947 	if (!mboxq)
4948 		return -ENOMEM;
4949 	/* obtain link type and link number via READ_CONFIG */
4950 	phba->sli4_hba.lnk_info.lnk_dv = LPFC_LNK_DAT_INVAL;
4951 	lpfc_sli4_read_config(phba);
4952 	if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL)
4953 		goto retrieve_ppname;
4954 
4955 	/* obtain link type and link number via COMMON_GET_CNTL_ATTRIBUTES */
4956 	reqlen = sizeof(struct lpfc_mbx_get_cntl_attributes);
4957 	alloclen = lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
4958 			LPFC_MBOX_OPCODE_GET_CNTL_ATTRIBUTES, reqlen,
4959 			LPFC_SLI4_MBX_NEMBED);
4960 	if (alloclen < reqlen) {
4961 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4962 				"3084 Allocated DMA memory size (%d) is "
4963 				"less than the requested DMA memory size "
4964 				"(%d)\n", alloclen, reqlen);
4965 		rc = -ENOMEM;
4966 		goto out_free_mboxq;
4967 	}
4968 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
4969 	virtaddr = mboxq->sge_array->addr[0];
4970 	mbx_cntl_attr = (struct lpfc_mbx_get_cntl_attributes *)virtaddr;
4971 	shdr = &mbx_cntl_attr->cfg_shdr;
4972 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
4973 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
4974 	if (shdr_status || shdr_add_status || rc) {
4975 		lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
4976 				"3085 Mailbox x%x (x%x/x%x) failed, "
4977 				"rc:x%x, status:x%x, add_status:x%x\n",
4978 				bf_get(lpfc_mqe_command, &mboxq->u.mqe),
4979 				lpfc_sli_config_mbox_subsys_get(phba, mboxq),
4980 				lpfc_sli_config_mbox_opcode_get(phba, mboxq),
4981 				rc, shdr_status, shdr_add_status);
4982 		rc = -ENXIO;
4983 		goto out_free_mboxq;
4984 	}
4985 	cntl_attr = &mbx_cntl_attr->cntl_attr;
4986 	phba->sli4_hba.lnk_info.lnk_dv = LPFC_LNK_DAT_VAL;
4987 	phba->sli4_hba.lnk_info.lnk_tp =
4988 		bf_get(lpfc_cntl_attr_lnk_type, cntl_attr);
4989 	phba->sli4_hba.lnk_info.lnk_no =
4990 		bf_get(lpfc_cntl_attr_lnk_numb, cntl_attr);
4991 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4992 			"3086 lnk_type:%d, lnk_numb:%d\n",
4993 			phba->sli4_hba.lnk_info.lnk_tp,
4994 			phba->sli4_hba.lnk_info.lnk_no);
4995 
4996 retrieve_ppname:
4997 	lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
4998 		LPFC_MBOX_OPCODE_GET_PORT_NAME,
4999 		sizeof(struct lpfc_mbx_get_port_name) -
5000 		sizeof(struct lpfc_sli4_cfg_mhdr),
5001 		LPFC_SLI4_MBX_EMBED);
5002 	get_port_name = &mboxq->u.mqe.un.get_port_name;
5003 	shdr = (union lpfc_sli4_cfg_shdr *)&get_port_name->header.cfg_shdr;
5004 	bf_set(lpfc_mbox_hdr_version, &shdr->request, LPFC_OPCODE_VERSION_1);
5005 	bf_set(lpfc_mbx_get_port_name_lnk_type, &get_port_name->u.request,
5006 		phba->sli4_hba.lnk_info.lnk_tp);
5007 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
5008 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
5009 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
5010 	if (shdr_status || shdr_add_status || rc) {
5011 		lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
5012 				"3087 Mailbox x%x (x%x/x%x) failed: "
5013 				"rc:x%x, status:x%x, add_status:x%x\n",
5014 				bf_get(lpfc_mqe_command, &mboxq->u.mqe),
5015 				lpfc_sli_config_mbox_subsys_get(phba, mboxq),
5016 				lpfc_sli_config_mbox_opcode_get(phba, mboxq),
5017 				rc, shdr_status, shdr_add_status);
5018 		rc = -ENXIO;
5019 		goto out_free_mboxq;
5020 	}
5021 	switch (phba->sli4_hba.lnk_info.lnk_no) {
5022 	case LPFC_LINK_NUMBER_0:
5023 		cport_name = bf_get(lpfc_mbx_get_port_name_name0,
5024 				&get_port_name->u.response);
5025 		phba->sli4_hba.pport_name_sta = LPFC_SLI4_PPNAME_GET;
5026 		break;
5027 	case LPFC_LINK_NUMBER_1:
5028 		cport_name = bf_get(lpfc_mbx_get_port_name_name1,
5029 				&get_port_name->u.response);
5030 		phba->sli4_hba.pport_name_sta = LPFC_SLI4_PPNAME_GET;
5031 		break;
5032 	case LPFC_LINK_NUMBER_2:
5033 		cport_name = bf_get(lpfc_mbx_get_port_name_name2,
5034 				&get_port_name->u.response);
5035 		phba->sli4_hba.pport_name_sta = LPFC_SLI4_PPNAME_GET;
5036 		break;
5037 	case LPFC_LINK_NUMBER_3:
5038 		cport_name = bf_get(lpfc_mbx_get_port_name_name3,
5039 				&get_port_name->u.response);
5040 		phba->sli4_hba.pport_name_sta = LPFC_SLI4_PPNAME_GET;
5041 		break;
5042 	default:
5043 		break;
5044 	}
5045 
5046 	if (phba->sli4_hba.pport_name_sta == LPFC_SLI4_PPNAME_GET) {
5047 		phba->Port[0] = cport_name;
5048 		phba->Port[1] = '\0';
5049 		lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
5050 				"3091 SLI get port name: %s\n", phba->Port);
5051 	}
5052 
5053 out_free_mboxq:
5054 	if (rc != MBX_TIMEOUT) {
5055 		if (bf_get(lpfc_mqe_command, &mboxq->u.mqe) == MBX_SLI4_CONFIG)
5056 			lpfc_sli4_mbox_cmd_free(phba, mboxq);
5057 		else
5058 			mempool_free(mboxq, phba->mbox_mem_pool);
5059 	}
5060 	return rc;
5061 }
5062 
5063 /**
5064  * lpfc_sli4_arm_cqeq_intr - Arm sli-4 device completion and event queues
5065  * @phba: pointer to lpfc hba data structure.
5066  *
5067  * This routine is called to explicitly arm the SLI4 device's completion and
5068  * event queues
5069  **/
5070 static void
5071 lpfc_sli4_arm_cqeq_intr(struct lpfc_hba *phba)
5072 {
5073 	int fcp_eqidx;
5074 
5075 	lpfc_sli4_cq_release(phba->sli4_hba.mbx_cq, LPFC_QUEUE_REARM);
5076 	lpfc_sli4_cq_release(phba->sli4_hba.els_cq, LPFC_QUEUE_REARM);
5077 	fcp_eqidx = 0;
5078 	if (phba->sli4_hba.fcp_cq) {
5079 		do {
5080 			lpfc_sli4_cq_release(phba->sli4_hba.fcp_cq[fcp_eqidx],
5081 					     LPFC_QUEUE_REARM);
5082 		} while (++fcp_eqidx < phba->cfg_fcp_io_channel);
5083 	}
5084 
5085 	if (phba->cfg_fof)
5086 		lpfc_sli4_cq_release(phba->sli4_hba.oas_cq, LPFC_QUEUE_REARM);
5087 
5088 	if (phba->sli4_hba.hba_eq) {
5089 		for (fcp_eqidx = 0; fcp_eqidx < phba->cfg_fcp_io_channel;
5090 		     fcp_eqidx++)
5091 			lpfc_sli4_eq_release(phba->sli4_hba.hba_eq[fcp_eqidx],
5092 					     LPFC_QUEUE_REARM);
5093 	}
5094 
5095 	if (phba->cfg_fof)
5096 		lpfc_sli4_eq_release(phba->sli4_hba.fof_eq, LPFC_QUEUE_REARM);
5097 }
5098 
5099 /**
5100  * lpfc_sli4_get_avail_extnt_rsrc - Get available resource extent count.
5101  * @phba: Pointer to HBA context object.
5102  * @type: The resource extent type.
5103  * @extnt_count: buffer to hold port available extent count.
5104  * @extnt_size: buffer to hold element count per extent.
5105  *
5106  * This function calls the port and retrievs the number of available
5107  * extents and their size for a particular extent type.
5108  *
5109  * Returns: 0 if successful.  Nonzero otherwise.
5110  **/
5111 int
5112 lpfc_sli4_get_avail_extnt_rsrc(struct lpfc_hba *phba, uint16_t type,
5113 			       uint16_t *extnt_count, uint16_t *extnt_size)
5114 {
5115 	int rc = 0;
5116 	uint32_t length;
5117 	uint32_t mbox_tmo;
5118 	struct lpfc_mbx_get_rsrc_extent_info *rsrc_info;
5119 	LPFC_MBOXQ_t *mbox;
5120 
5121 	mbox = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5122 	if (!mbox)
5123 		return -ENOMEM;
5124 
5125 	/* Find out how many extents are available for this resource type */
5126 	length = (sizeof(struct lpfc_mbx_get_rsrc_extent_info) -
5127 		  sizeof(struct lpfc_sli4_cfg_mhdr));
5128 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
5129 			 LPFC_MBOX_OPCODE_GET_RSRC_EXTENT_INFO,
5130 			 length, LPFC_SLI4_MBX_EMBED);
5131 
5132 	/* Send an extents count of 0 - the GET doesn't use it. */
5133 	rc = lpfc_sli4_mbox_rsrc_extent(phba, mbox, 0, type,
5134 					LPFC_SLI4_MBX_EMBED);
5135 	if (unlikely(rc)) {
5136 		rc = -EIO;
5137 		goto err_exit;
5138 	}
5139 
5140 	if (!phba->sli4_hba.intr_enable)
5141 		rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
5142 	else {
5143 		mbox_tmo = lpfc_mbox_tmo_val(phba, mbox);
5144 		rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
5145 	}
5146 	if (unlikely(rc)) {
5147 		rc = -EIO;
5148 		goto err_exit;
5149 	}
5150 
5151 	rsrc_info = &mbox->u.mqe.un.rsrc_extent_info;
5152 	if (bf_get(lpfc_mbox_hdr_status,
5153 		   &rsrc_info->header.cfg_shdr.response)) {
5154 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
5155 				"2930 Failed to get resource extents "
5156 				"Status 0x%x Add'l Status 0x%x\n",
5157 				bf_get(lpfc_mbox_hdr_status,
5158 				       &rsrc_info->header.cfg_shdr.response),
5159 				bf_get(lpfc_mbox_hdr_add_status,
5160 				       &rsrc_info->header.cfg_shdr.response));
5161 		rc = -EIO;
5162 		goto err_exit;
5163 	}
5164 
5165 	*extnt_count = bf_get(lpfc_mbx_get_rsrc_extent_info_cnt,
5166 			      &rsrc_info->u.rsp);
5167 	*extnt_size = bf_get(lpfc_mbx_get_rsrc_extent_info_size,
5168 			     &rsrc_info->u.rsp);
5169 
5170 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
5171 			"3162 Retrieved extents type-%d from port: count:%d, "
5172 			"size:%d\n", type, *extnt_count, *extnt_size);
5173 
5174 err_exit:
5175 	mempool_free(mbox, phba->mbox_mem_pool);
5176 	return rc;
5177 }
5178 
5179 /**
5180  * lpfc_sli4_chk_avail_extnt_rsrc - Check for available SLI4 resource extents.
5181  * @phba: Pointer to HBA context object.
5182  * @type: The extent type to check.
5183  *
5184  * This function reads the current available extents from the port and checks
5185  * if the extent count or extent size has changed since the last access.
5186  * Callers use this routine post port reset to understand if there is a
5187  * extent reprovisioning requirement.
5188  *
5189  * Returns:
5190  *   -Error: error indicates problem.
5191  *   1: Extent count or size has changed.
5192  *   0: No changes.
5193  **/
5194 static int
5195 lpfc_sli4_chk_avail_extnt_rsrc(struct lpfc_hba *phba, uint16_t type)
5196 {
5197 	uint16_t curr_ext_cnt, rsrc_ext_cnt;
5198 	uint16_t size_diff, rsrc_ext_size;
5199 	int rc = 0;
5200 	struct lpfc_rsrc_blks *rsrc_entry;
5201 	struct list_head *rsrc_blk_list = NULL;
5202 
5203 	size_diff = 0;
5204 	curr_ext_cnt = 0;
5205 	rc = lpfc_sli4_get_avail_extnt_rsrc(phba, type,
5206 					    &rsrc_ext_cnt,
5207 					    &rsrc_ext_size);
5208 	if (unlikely(rc))
5209 		return -EIO;
5210 
5211 	switch (type) {
5212 	case LPFC_RSC_TYPE_FCOE_RPI:
5213 		rsrc_blk_list = &phba->sli4_hba.lpfc_rpi_blk_list;
5214 		break;
5215 	case LPFC_RSC_TYPE_FCOE_VPI:
5216 		rsrc_blk_list = &phba->lpfc_vpi_blk_list;
5217 		break;
5218 	case LPFC_RSC_TYPE_FCOE_XRI:
5219 		rsrc_blk_list = &phba->sli4_hba.lpfc_xri_blk_list;
5220 		break;
5221 	case LPFC_RSC_TYPE_FCOE_VFI:
5222 		rsrc_blk_list = &phba->sli4_hba.lpfc_vfi_blk_list;
5223 		break;
5224 	default:
5225 		break;
5226 	}
5227 
5228 	list_for_each_entry(rsrc_entry, rsrc_blk_list, list) {
5229 		curr_ext_cnt++;
5230 		if (rsrc_entry->rsrc_size != rsrc_ext_size)
5231 			size_diff++;
5232 	}
5233 
5234 	if (curr_ext_cnt != rsrc_ext_cnt || size_diff != 0)
5235 		rc = 1;
5236 
5237 	return rc;
5238 }
5239 
5240 /**
5241  * lpfc_sli4_cfg_post_extnts -
5242  * @phba: Pointer to HBA context object.
5243  * @extnt_cnt - number of available extents.
5244  * @type - the extent type (rpi, xri, vfi, vpi).
5245  * @emb - buffer to hold either MBX_EMBED or MBX_NEMBED operation.
5246  * @mbox - pointer to the caller's allocated mailbox structure.
5247  *
5248  * This function executes the extents allocation request.  It also
5249  * takes care of the amount of memory needed to allocate or get the
5250  * allocated extents. It is the caller's responsibility to evaluate
5251  * the response.
5252  *
5253  * Returns:
5254  *   -Error:  Error value describes the condition found.
5255  *   0: if successful
5256  **/
5257 static int
5258 lpfc_sli4_cfg_post_extnts(struct lpfc_hba *phba, uint16_t extnt_cnt,
5259 			  uint16_t type, bool *emb, LPFC_MBOXQ_t *mbox)
5260 {
5261 	int rc = 0;
5262 	uint32_t req_len;
5263 	uint32_t emb_len;
5264 	uint32_t alloc_len, mbox_tmo;
5265 
5266 	/* Calculate the total requested length of the dma memory */
5267 	req_len = extnt_cnt * sizeof(uint16_t);
5268 
5269 	/*
5270 	 * Calculate the size of an embedded mailbox.  The uint32_t
5271 	 * accounts for extents-specific word.
5272 	 */
5273 	emb_len = sizeof(MAILBOX_t) - sizeof(struct mbox_header) -
5274 		sizeof(uint32_t);
5275 
5276 	/*
5277 	 * Presume the allocation and response will fit into an embedded
5278 	 * mailbox.  If not true, reconfigure to a non-embedded mailbox.
5279 	 */
5280 	*emb = LPFC_SLI4_MBX_EMBED;
5281 	if (req_len > emb_len) {
5282 		req_len = extnt_cnt * sizeof(uint16_t) +
5283 			sizeof(union lpfc_sli4_cfg_shdr) +
5284 			sizeof(uint32_t);
5285 		*emb = LPFC_SLI4_MBX_NEMBED;
5286 	}
5287 
5288 	alloc_len = lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
5289 				     LPFC_MBOX_OPCODE_ALLOC_RSRC_EXTENT,
5290 				     req_len, *emb);
5291 	if (alloc_len < req_len) {
5292 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5293 			"2982 Allocated DMA memory size (x%x) is "
5294 			"less than the requested DMA memory "
5295 			"size (x%x)\n", alloc_len, req_len);
5296 		return -ENOMEM;
5297 	}
5298 	rc = lpfc_sli4_mbox_rsrc_extent(phba, mbox, extnt_cnt, type, *emb);
5299 	if (unlikely(rc))
5300 		return -EIO;
5301 
5302 	if (!phba->sli4_hba.intr_enable)
5303 		rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
5304 	else {
5305 		mbox_tmo = lpfc_mbox_tmo_val(phba, mbox);
5306 		rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
5307 	}
5308 
5309 	if (unlikely(rc))
5310 		rc = -EIO;
5311 	return rc;
5312 }
5313 
5314 /**
5315  * lpfc_sli4_alloc_extent - Allocate an SLI4 resource extent.
5316  * @phba: Pointer to HBA context object.
5317  * @type:  The resource extent type to allocate.
5318  *
5319  * This function allocates the number of elements for the specified
5320  * resource type.
5321  **/
5322 static int
5323 lpfc_sli4_alloc_extent(struct lpfc_hba *phba, uint16_t type)
5324 {
5325 	bool emb = false;
5326 	uint16_t rsrc_id_cnt, rsrc_cnt, rsrc_size;
5327 	uint16_t rsrc_id, rsrc_start, j, k;
5328 	uint16_t *ids;
5329 	int i, rc;
5330 	unsigned long longs;
5331 	unsigned long *bmask;
5332 	struct lpfc_rsrc_blks *rsrc_blks;
5333 	LPFC_MBOXQ_t *mbox;
5334 	uint32_t length;
5335 	struct lpfc_id_range *id_array = NULL;
5336 	void *virtaddr = NULL;
5337 	struct lpfc_mbx_nembed_rsrc_extent *n_rsrc;
5338 	struct lpfc_mbx_alloc_rsrc_extents *rsrc_ext;
5339 	struct list_head *ext_blk_list;
5340 
5341 	rc = lpfc_sli4_get_avail_extnt_rsrc(phba, type,
5342 					    &rsrc_cnt,
5343 					    &rsrc_size);
5344 	if (unlikely(rc))
5345 		return -EIO;
5346 
5347 	if ((rsrc_cnt == 0) || (rsrc_size == 0)) {
5348 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
5349 			"3009 No available Resource Extents "
5350 			"for resource type 0x%x: Count: 0x%x, "
5351 			"Size 0x%x\n", type, rsrc_cnt,
5352 			rsrc_size);
5353 		return -ENOMEM;
5354 	}
5355 
5356 	lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_INIT | LOG_SLI,
5357 			"2903 Post resource extents type-0x%x: "
5358 			"count:%d, size %d\n", type, rsrc_cnt, rsrc_size);
5359 
5360 	mbox = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5361 	if (!mbox)
5362 		return -ENOMEM;
5363 
5364 	rc = lpfc_sli4_cfg_post_extnts(phba, rsrc_cnt, type, &emb, mbox);
5365 	if (unlikely(rc)) {
5366 		rc = -EIO;
5367 		goto err_exit;
5368 	}
5369 
5370 	/*
5371 	 * Figure out where the response is located.  Then get local pointers
5372 	 * to the response data.  The port does not guarantee to respond to
5373 	 * all extents counts request so update the local variable with the
5374 	 * allocated count from the port.
5375 	 */
5376 	if (emb == LPFC_SLI4_MBX_EMBED) {
5377 		rsrc_ext = &mbox->u.mqe.un.alloc_rsrc_extents;
5378 		id_array = &rsrc_ext->u.rsp.id[0];
5379 		rsrc_cnt = bf_get(lpfc_mbx_rsrc_cnt, &rsrc_ext->u.rsp);
5380 	} else {
5381 		virtaddr = mbox->sge_array->addr[0];
5382 		n_rsrc = (struct lpfc_mbx_nembed_rsrc_extent *) virtaddr;
5383 		rsrc_cnt = bf_get(lpfc_mbx_rsrc_cnt, n_rsrc);
5384 		id_array = &n_rsrc->id;
5385 	}
5386 
5387 	longs = ((rsrc_cnt * rsrc_size) + BITS_PER_LONG - 1) / BITS_PER_LONG;
5388 	rsrc_id_cnt = rsrc_cnt * rsrc_size;
5389 
5390 	/*
5391 	 * Based on the resource size and count, correct the base and max
5392 	 * resource values.
5393 	 */
5394 	length = sizeof(struct lpfc_rsrc_blks);
5395 	switch (type) {
5396 	case LPFC_RSC_TYPE_FCOE_RPI:
5397 		phba->sli4_hba.rpi_bmask = kzalloc(longs *
5398 						   sizeof(unsigned long),
5399 						   GFP_KERNEL);
5400 		if (unlikely(!phba->sli4_hba.rpi_bmask)) {
5401 			rc = -ENOMEM;
5402 			goto err_exit;
5403 		}
5404 		phba->sli4_hba.rpi_ids = kzalloc(rsrc_id_cnt *
5405 						 sizeof(uint16_t),
5406 						 GFP_KERNEL);
5407 		if (unlikely(!phba->sli4_hba.rpi_ids)) {
5408 			kfree(phba->sli4_hba.rpi_bmask);
5409 			rc = -ENOMEM;
5410 			goto err_exit;
5411 		}
5412 
5413 		/*
5414 		 * The next_rpi was initialized with the maximum available
5415 		 * count but the port may allocate a smaller number.  Catch
5416 		 * that case and update the next_rpi.
5417 		 */
5418 		phba->sli4_hba.next_rpi = rsrc_id_cnt;
5419 
5420 		/* Initialize local ptrs for common extent processing later. */
5421 		bmask = phba->sli4_hba.rpi_bmask;
5422 		ids = phba->sli4_hba.rpi_ids;
5423 		ext_blk_list = &phba->sli4_hba.lpfc_rpi_blk_list;
5424 		break;
5425 	case LPFC_RSC_TYPE_FCOE_VPI:
5426 		phba->vpi_bmask = kzalloc(longs *
5427 					  sizeof(unsigned long),
5428 					  GFP_KERNEL);
5429 		if (unlikely(!phba->vpi_bmask)) {
5430 			rc = -ENOMEM;
5431 			goto err_exit;
5432 		}
5433 		phba->vpi_ids = kzalloc(rsrc_id_cnt *
5434 					 sizeof(uint16_t),
5435 					 GFP_KERNEL);
5436 		if (unlikely(!phba->vpi_ids)) {
5437 			kfree(phba->vpi_bmask);
5438 			rc = -ENOMEM;
5439 			goto err_exit;
5440 		}
5441 
5442 		/* Initialize local ptrs for common extent processing later. */
5443 		bmask = phba->vpi_bmask;
5444 		ids = phba->vpi_ids;
5445 		ext_blk_list = &phba->lpfc_vpi_blk_list;
5446 		break;
5447 	case LPFC_RSC_TYPE_FCOE_XRI:
5448 		phba->sli4_hba.xri_bmask = kzalloc(longs *
5449 						   sizeof(unsigned long),
5450 						   GFP_KERNEL);
5451 		if (unlikely(!phba->sli4_hba.xri_bmask)) {
5452 			rc = -ENOMEM;
5453 			goto err_exit;
5454 		}
5455 		phba->sli4_hba.max_cfg_param.xri_used = 0;
5456 		phba->sli4_hba.xri_ids = kzalloc(rsrc_id_cnt *
5457 						 sizeof(uint16_t),
5458 						 GFP_KERNEL);
5459 		if (unlikely(!phba->sli4_hba.xri_ids)) {
5460 			kfree(phba->sli4_hba.xri_bmask);
5461 			rc = -ENOMEM;
5462 			goto err_exit;
5463 		}
5464 
5465 		/* Initialize local ptrs for common extent processing later. */
5466 		bmask = phba->sli4_hba.xri_bmask;
5467 		ids = phba->sli4_hba.xri_ids;
5468 		ext_blk_list = &phba->sli4_hba.lpfc_xri_blk_list;
5469 		break;
5470 	case LPFC_RSC_TYPE_FCOE_VFI:
5471 		phba->sli4_hba.vfi_bmask = kzalloc(longs *
5472 						   sizeof(unsigned long),
5473 						   GFP_KERNEL);
5474 		if (unlikely(!phba->sli4_hba.vfi_bmask)) {
5475 			rc = -ENOMEM;
5476 			goto err_exit;
5477 		}
5478 		phba->sli4_hba.vfi_ids = kzalloc(rsrc_id_cnt *
5479 						 sizeof(uint16_t),
5480 						 GFP_KERNEL);
5481 		if (unlikely(!phba->sli4_hba.vfi_ids)) {
5482 			kfree(phba->sli4_hba.vfi_bmask);
5483 			rc = -ENOMEM;
5484 			goto err_exit;
5485 		}
5486 
5487 		/* Initialize local ptrs for common extent processing later. */
5488 		bmask = phba->sli4_hba.vfi_bmask;
5489 		ids = phba->sli4_hba.vfi_ids;
5490 		ext_blk_list = &phba->sli4_hba.lpfc_vfi_blk_list;
5491 		break;
5492 	default:
5493 		/* Unsupported Opcode.  Fail call. */
5494 		id_array = NULL;
5495 		bmask = NULL;
5496 		ids = NULL;
5497 		ext_blk_list = NULL;
5498 		goto err_exit;
5499 	}
5500 
5501 	/*
5502 	 * Complete initializing the extent configuration with the
5503 	 * allocated ids assigned to this function.  The bitmask serves
5504 	 * as an index into the array and manages the available ids.  The
5505 	 * array just stores the ids communicated to the port via the wqes.
5506 	 */
5507 	for (i = 0, j = 0, k = 0; i < rsrc_cnt; i++) {
5508 		if ((i % 2) == 0)
5509 			rsrc_id = bf_get(lpfc_mbx_rsrc_id_word4_0,
5510 					 &id_array[k]);
5511 		else
5512 			rsrc_id = bf_get(lpfc_mbx_rsrc_id_word4_1,
5513 					 &id_array[k]);
5514 
5515 		rsrc_blks = kzalloc(length, GFP_KERNEL);
5516 		if (unlikely(!rsrc_blks)) {
5517 			rc = -ENOMEM;
5518 			kfree(bmask);
5519 			kfree(ids);
5520 			goto err_exit;
5521 		}
5522 		rsrc_blks->rsrc_start = rsrc_id;
5523 		rsrc_blks->rsrc_size = rsrc_size;
5524 		list_add_tail(&rsrc_blks->list, ext_blk_list);
5525 		rsrc_start = rsrc_id;
5526 		if ((type == LPFC_RSC_TYPE_FCOE_XRI) && (j == 0))
5527 			phba->sli4_hba.scsi_xri_start = rsrc_start +
5528 				lpfc_sli4_get_els_iocb_cnt(phba);
5529 
5530 		while (rsrc_id < (rsrc_start + rsrc_size)) {
5531 			ids[j] = rsrc_id;
5532 			rsrc_id++;
5533 			j++;
5534 		}
5535 		/* Entire word processed.  Get next word.*/
5536 		if ((i % 2) == 1)
5537 			k++;
5538 	}
5539  err_exit:
5540 	lpfc_sli4_mbox_cmd_free(phba, mbox);
5541 	return rc;
5542 }
5543 
5544 /**
5545  * lpfc_sli4_dealloc_extent - Deallocate an SLI4 resource extent.
5546  * @phba: Pointer to HBA context object.
5547  * @type: the extent's type.
5548  *
5549  * This function deallocates all extents of a particular resource type.
5550  * SLI4 does not allow for deallocating a particular extent range.  It
5551  * is the caller's responsibility to release all kernel memory resources.
5552  **/
5553 static int
5554 lpfc_sli4_dealloc_extent(struct lpfc_hba *phba, uint16_t type)
5555 {
5556 	int rc;
5557 	uint32_t length, mbox_tmo = 0;
5558 	LPFC_MBOXQ_t *mbox;
5559 	struct lpfc_mbx_dealloc_rsrc_extents *dealloc_rsrc;
5560 	struct lpfc_rsrc_blks *rsrc_blk, *rsrc_blk_next;
5561 
5562 	mbox = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5563 	if (!mbox)
5564 		return -ENOMEM;
5565 
5566 	/*
5567 	 * This function sends an embedded mailbox because it only sends the
5568 	 * the resource type.  All extents of this type are released by the
5569 	 * port.
5570 	 */
5571 	length = (sizeof(struct lpfc_mbx_dealloc_rsrc_extents) -
5572 		  sizeof(struct lpfc_sli4_cfg_mhdr));
5573 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
5574 			 LPFC_MBOX_OPCODE_DEALLOC_RSRC_EXTENT,
5575 			 length, LPFC_SLI4_MBX_EMBED);
5576 
5577 	/* Send an extents count of 0 - the dealloc doesn't use it. */
5578 	rc = lpfc_sli4_mbox_rsrc_extent(phba, mbox, 0, type,
5579 					LPFC_SLI4_MBX_EMBED);
5580 	if (unlikely(rc)) {
5581 		rc = -EIO;
5582 		goto out_free_mbox;
5583 	}
5584 	if (!phba->sli4_hba.intr_enable)
5585 		rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
5586 	else {
5587 		mbox_tmo = lpfc_mbox_tmo_val(phba, mbox);
5588 		rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
5589 	}
5590 	if (unlikely(rc)) {
5591 		rc = -EIO;
5592 		goto out_free_mbox;
5593 	}
5594 
5595 	dealloc_rsrc = &mbox->u.mqe.un.dealloc_rsrc_extents;
5596 	if (bf_get(lpfc_mbox_hdr_status,
5597 		   &dealloc_rsrc->header.cfg_shdr.response)) {
5598 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
5599 				"2919 Failed to release resource extents "
5600 				"for type %d - Status 0x%x Add'l Status 0x%x. "
5601 				"Resource memory not released.\n",
5602 				type,
5603 				bf_get(lpfc_mbox_hdr_status,
5604 				    &dealloc_rsrc->header.cfg_shdr.response),
5605 				bf_get(lpfc_mbox_hdr_add_status,
5606 				    &dealloc_rsrc->header.cfg_shdr.response));
5607 		rc = -EIO;
5608 		goto out_free_mbox;
5609 	}
5610 
5611 	/* Release kernel memory resources for the specific type. */
5612 	switch (type) {
5613 	case LPFC_RSC_TYPE_FCOE_VPI:
5614 		kfree(phba->vpi_bmask);
5615 		kfree(phba->vpi_ids);
5616 		bf_set(lpfc_vpi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
5617 		list_for_each_entry_safe(rsrc_blk, rsrc_blk_next,
5618 				    &phba->lpfc_vpi_blk_list, list) {
5619 			list_del_init(&rsrc_blk->list);
5620 			kfree(rsrc_blk);
5621 		}
5622 		phba->sli4_hba.max_cfg_param.vpi_used = 0;
5623 		break;
5624 	case LPFC_RSC_TYPE_FCOE_XRI:
5625 		kfree(phba->sli4_hba.xri_bmask);
5626 		kfree(phba->sli4_hba.xri_ids);
5627 		list_for_each_entry_safe(rsrc_blk, rsrc_blk_next,
5628 				    &phba->sli4_hba.lpfc_xri_blk_list, list) {
5629 			list_del_init(&rsrc_blk->list);
5630 			kfree(rsrc_blk);
5631 		}
5632 		break;
5633 	case LPFC_RSC_TYPE_FCOE_VFI:
5634 		kfree(phba->sli4_hba.vfi_bmask);
5635 		kfree(phba->sli4_hba.vfi_ids);
5636 		bf_set(lpfc_vfi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
5637 		list_for_each_entry_safe(rsrc_blk, rsrc_blk_next,
5638 				    &phba->sli4_hba.lpfc_vfi_blk_list, list) {
5639 			list_del_init(&rsrc_blk->list);
5640 			kfree(rsrc_blk);
5641 		}
5642 		break;
5643 	case LPFC_RSC_TYPE_FCOE_RPI:
5644 		/* RPI bitmask and physical id array are cleaned up earlier. */
5645 		list_for_each_entry_safe(rsrc_blk, rsrc_blk_next,
5646 				    &phba->sli4_hba.lpfc_rpi_blk_list, list) {
5647 			list_del_init(&rsrc_blk->list);
5648 			kfree(rsrc_blk);
5649 		}
5650 		break;
5651 	default:
5652 		break;
5653 	}
5654 
5655 	bf_set(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
5656 
5657  out_free_mbox:
5658 	mempool_free(mbox, phba->mbox_mem_pool);
5659 	return rc;
5660 }
5661 
5662 /**
5663  * lpfc_sli4_alloc_resource_identifiers - Allocate all SLI4 resource extents.
5664  * @phba: Pointer to HBA context object.
5665  *
5666  * This function allocates all SLI4 resource identifiers.
5667  **/
5668 int
5669 lpfc_sli4_alloc_resource_identifiers(struct lpfc_hba *phba)
5670 {
5671 	int i, rc, error = 0;
5672 	uint16_t count, base;
5673 	unsigned long longs;
5674 
5675 	if (!phba->sli4_hba.rpi_hdrs_in_use)
5676 		phba->sli4_hba.next_rpi = phba->sli4_hba.max_cfg_param.max_rpi;
5677 	if (phba->sli4_hba.extents_in_use) {
5678 		/*
5679 		 * The port supports resource extents. The XRI, VPI, VFI, RPI
5680 		 * resource extent count must be read and allocated before
5681 		 * provisioning the resource id arrays.
5682 		 */
5683 		if (bf_get(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags) ==
5684 		    LPFC_IDX_RSRC_RDY) {
5685 			/*
5686 			 * Extent-based resources are set - the driver could
5687 			 * be in a port reset. Figure out if any corrective
5688 			 * actions need to be taken.
5689 			 */
5690 			rc = lpfc_sli4_chk_avail_extnt_rsrc(phba,
5691 						 LPFC_RSC_TYPE_FCOE_VFI);
5692 			if (rc != 0)
5693 				error++;
5694 			rc = lpfc_sli4_chk_avail_extnt_rsrc(phba,
5695 						 LPFC_RSC_TYPE_FCOE_VPI);
5696 			if (rc != 0)
5697 				error++;
5698 			rc = lpfc_sli4_chk_avail_extnt_rsrc(phba,
5699 						 LPFC_RSC_TYPE_FCOE_XRI);
5700 			if (rc != 0)
5701 				error++;
5702 			rc = lpfc_sli4_chk_avail_extnt_rsrc(phba,
5703 						 LPFC_RSC_TYPE_FCOE_RPI);
5704 			if (rc != 0)
5705 				error++;
5706 
5707 			/*
5708 			 * It's possible that the number of resources
5709 			 * provided to this port instance changed between
5710 			 * resets.  Detect this condition and reallocate
5711 			 * resources.  Otherwise, there is no action.
5712 			 */
5713 			if (error) {
5714 				lpfc_printf_log(phba, KERN_INFO,
5715 						LOG_MBOX | LOG_INIT,
5716 						"2931 Detected extent resource "
5717 						"change.  Reallocating all "
5718 						"extents.\n");
5719 				rc = lpfc_sli4_dealloc_extent(phba,
5720 						 LPFC_RSC_TYPE_FCOE_VFI);
5721 				rc = lpfc_sli4_dealloc_extent(phba,
5722 						 LPFC_RSC_TYPE_FCOE_VPI);
5723 				rc = lpfc_sli4_dealloc_extent(phba,
5724 						 LPFC_RSC_TYPE_FCOE_XRI);
5725 				rc = lpfc_sli4_dealloc_extent(phba,
5726 						 LPFC_RSC_TYPE_FCOE_RPI);
5727 			} else
5728 				return 0;
5729 		}
5730 
5731 		rc = lpfc_sli4_alloc_extent(phba, LPFC_RSC_TYPE_FCOE_VFI);
5732 		if (unlikely(rc))
5733 			goto err_exit;
5734 
5735 		rc = lpfc_sli4_alloc_extent(phba, LPFC_RSC_TYPE_FCOE_VPI);
5736 		if (unlikely(rc))
5737 			goto err_exit;
5738 
5739 		rc = lpfc_sli4_alloc_extent(phba, LPFC_RSC_TYPE_FCOE_RPI);
5740 		if (unlikely(rc))
5741 			goto err_exit;
5742 
5743 		rc = lpfc_sli4_alloc_extent(phba, LPFC_RSC_TYPE_FCOE_XRI);
5744 		if (unlikely(rc))
5745 			goto err_exit;
5746 		bf_set(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags,
5747 		       LPFC_IDX_RSRC_RDY);
5748 		return rc;
5749 	} else {
5750 		/*
5751 		 * The port does not support resource extents.  The XRI, VPI,
5752 		 * VFI, RPI resource ids were determined from READ_CONFIG.
5753 		 * Just allocate the bitmasks and provision the resource id
5754 		 * arrays.  If a port reset is active, the resources don't
5755 		 * need any action - just exit.
5756 		 */
5757 		if (bf_get(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags) ==
5758 		    LPFC_IDX_RSRC_RDY) {
5759 			lpfc_sli4_dealloc_resource_identifiers(phba);
5760 			lpfc_sli4_remove_rpis(phba);
5761 		}
5762 		/* RPIs. */
5763 		count = phba->sli4_hba.max_cfg_param.max_rpi;
5764 		if (count <= 0) {
5765 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5766 					"3279 Invalid provisioning of "
5767 					"rpi:%d\n", count);
5768 			rc = -EINVAL;
5769 			goto err_exit;
5770 		}
5771 		base = phba->sli4_hba.max_cfg_param.rpi_base;
5772 		longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;
5773 		phba->sli4_hba.rpi_bmask = kzalloc(longs *
5774 						   sizeof(unsigned long),
5775 						   GFP_KERNEL);
5776 		if (unlikely(!phba->sli4_hba.rpi_bmask)) {
5777 			rc = -ENOMEM;
5778 			goto err_exit;
5779 		}
5780 		phba->sli4_hba.rpi_ids = kzalloc(count *
5781 						 sizeof(uint16_t),
5782 						 GFP_KERNEL);
5783 		if (unlikely(!phba->sli4_hba.rpi_ids)) {
5784 			rc = -ENOMEM;
5785 			goto free_rpi_bmask;
5786 		}
5787 
5788 		for (i = 0; i < count; i++)
5789 			phba->sli4_hba.rpi_ids[i] = base + i;
5790 
5791 		/* VPIs. */
5792 		count = phba->sli4_hba.max_cfg_param.max_vpi;
5793 		if (count <= 0) {
5794 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5795 					"3280 Invalid provisioning of "
5796 					"vpi:%d\n", count);
5797 			rc = -EINVAL;
5798 			goto free_rpi_ids;
5799 		}
5800 		base = phba->sli4_hba.max_cfg_param.vpi_base;
5801 		longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;
5802 		phba->vpi_bmask = kzalloc(longs *
5803 					  sizeof(unsigned long),
5804 					  GFP_KERNEL);
5805 		if (unlikely(!phba->vpi_bmask)) {
5806 			rc = -ENOMEM;
5807 			goto free_rpi_ids;
5808 		}
5809 		phba->vpi_ids = kzalloc(count *
5810 					sizeof(uint16_t),
5811 					GFP_KERNEL);
5812 		if (unlikely(!phba->vpi_ids)) {
5813 			rc = -ENOMEM;
5814 			goto free_vpi_bmask;
5815 		}
5816 
5817 		for (i = 0; i < count; i++)
5818 			phba->vpi_ids[i] = base + i;
5819 
5820 		/* XRIs. */
5821 		count = phba->sli4_hba.max_cfg_param.max_xri;
5822 		if (count <= 0) {
5823 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5824 					"3281 Invalid provisioning of "
5825 					"xri:%d\n", count);
5826 			rc = -EINVAL;
5827 			goto free_vpi_ids;
5828 		}
5829 		base = phba->sli4_hba.max_cfg_param.xri_base;
5830 		longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;
5831 		phba->sli4_hba.xri_bmask = kzalloc(longs *
5832 						   sizeof(unsigned long),
5833 						   GFP_KERNEL);
5834 		if (unlikely(!phba->sli4_hba.xri_bmask)) {
5835 			rc = -ENOMEM;
5836 			goto free_vpi_ids;
5837 		}
5838 		phba->sli4_hba.max_cfg_param.xri_used = 0;
5839 		phba->sli4_hba.xri_ids = kzalloc(count *
5840 						 sizeof(uint16_t),
5841 						 GFP_KERNEL);
5842 		if (unlikely(!phba->sli4_hba.xri_ids)) {
5843 			rc = -ENOMEM;
5844 			goto free_xri_bmask;
5845 		}
5846 
5847 		for (i = 0; i < count; i++)
5848 			phba->sli4_hba.xri_ids[i] = base + i;
5849 
5850 		/* VFIs. */
5851 		count = phba->sli4_hba.max_cfg_param.max_vfi;
5852 		if (count <= 0) {
5853 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5854 					"3282 Invalid provisioning of "
5855 					"vfi:%d\n", count);
5856 			rc = -EINVAL;
5857 			goto free_xri_ids;
5858 		}
5859 		base = phba->sli4_hba.max_cfg_param.vfi_base;
5860 		longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;
5861 		phba->sli4_hba.vfi_bmask = kzalloc(longs *
5862 						   sizeof(unsigned long),
5863 						   GFP_KERNEL);
5864 		if (unlikely(!phba->sli4_hba.vfi_bmask)) {
5865 			rc = -ENOMEM;
5866 			goto free_xri_ids;
5867 		}
5868 		phba->sli4_hba.vfi_ids = kzalloc(count *
5869 						 sizeof(uint16_t),
5870 						 GFP_KERNEL);
5871 		if (unlikely(!phba->sli4_hba.vfi_ids)) {
5872 			rc = -ENOMEM;
5873 			goto free_vfi_bmask;
5874 		}
5875 
5876 		for (i = 0; i < count; i++)
5877 			phba->sli4_hba.vfi_ids[i] = base + i;
5878 
5879 		/*
5880 		 * Mark all resources ready.  An HBA reset doesn't need
5881 		 * to reset the initialization.
5882 		 */
5883 		bf_set(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags,
5884 		       LPFC_IDX_RSRC_RDY);
5885 		return 0;
5886 	}
5887 
5888  free_vfi_bmask:
5889 	kfree(phba->sli4_hba.vfi_bmask);
5890  free_xri_ids:
5891 	kfree(phba->sli4_hba.xri_ids);
5892  free_xri_bmask:
5893 	kfree(phba->sli4_hba.xri_bmask);
5894  free_vpi_ids:
5895 	kfree(phba->vpi_ids);
5896  free_vpi_bmask:
5897 	kfree(phba->vpi_bmask);
5898  free_rpi_ids:
5899 	kfree(phba->sli4_hba.rpi_ids);
5900  free_rpi_bmask:
5901 	kfree(phba->sli4_hba.rpi_bmask);
5902  err_exit:
5903 	return rc;
5904 }
5905 
5906 /**
5907  * lpfc_sli4_dealloc_resource_identifiers - Deallocate all SLI4 resource extents.
5908  * @phba: Pointer to HBA context object.
5909  *
5910  * This function allocates the number of elements for the specified
5911  * resource type.
5912  **/
5913 int
5914 lpfc_sli4_dealloc_resource_identifiers(struct lpfc_hba *phba)
5915 {
5916 	if (phba->sli4_hba.extents_in_use) {
5917 		lpfc_sli4_dealloc_extent(phba, LPFC_RSC_TYPE_FCOE_VPI);
5918 		lpfc_sli4_dealloc_extent(phba, LPFC_RSC_TYPE_FCOE_RPI);
5919 		lpfc_sli4_dealloc_extent(phba, LPFC_RSC_TYPE_FCOE_XRI);
5920 		lpfc_sli4_dealloc_extent(phba, LPFC_RSC_TYPE_FCOE_VFI);
5921 	} else {
5922 		kfree(phba->vpi_bmask);
5923 		phba->sli4_hba.max_cfg_param.vpi_used = 0;
5924 		kfree(phba->vpi_ids);
5925 		bf_set(lpfc_vpi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
5926 		kfree(phba->sli4_hba.xri_bmask);
5927 		kfree(phba->sli4_hba.xri_ids);
5928 		kfree(phba->sli4_hba.vfi_bmask);
5929 		kfree(phba->sli4_hba.vfi_ids);
5930 		bf_set(lpfc_vfi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
5931 		bf_set(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
5932 	}
5933 
5934 	return 0;
5935 }
5936 
5937 /**
5938  * lpfc_sli4_get_allocated_extnts - Get the port's allocated extents.
5939  * @phba: Pointer to HBA context object.
5940  * @type: The resource extent type.
5941  * @extnt_count: buffer to hold port extent count response
5942  * @extnt_size: buffer to hold port extent size response.
5943  *
5944  * This function calls the port to read the host allocated extents
5945  * for a particular type.
5946  **/
5947 int
5948 lpfc_sli4_get_allocated_extnts(struct lpfc_hba *phba, uint16_t type,
5949 			       uint16_t *extnt_cnt, uint16_t *extnt_size)
5950 {
5951 	bool emb;
5952 	int rc = 0;
5953 	uint16_t curr_blks = 0;
5954 	uint32_t req_len, emb_len;
5955 	uint32_t alloc_len, mbox_tmo;
5956 	struct list_head *blk_list_head;
5957 	struct lpfc_rsrc_blks *rsrc_blk;
5958 	LPFC_MBOXQ_t *mbox;
5959 	void *virtaddr = NULL;
5960 	struct lpfc_mbx_nembed_rsrc_extent *n_rsrc;
5961 	struct lpfc_mbx_alloc_rsrc_extents *rsrc_ext;
5962 	union  lpfc_sli4_cfg_shdr *shdr;
5963 
5964 	switch (type) {
5965 	case LPFC_RSC_TYPE_FCOE_VPI:
5966 		blk_list_head = &phba->lpfc_vpi_blk_list;
5967 		break;
5968 	case LPFC_RSC_TYPE_FCOE_XRI:
5969 		blk_list_head = &phba->sli4_hba.lpfc_xri_blk_list;
5970 		break;
5971 	case LPFC_RSC_TYPE_FCOE_VFI:
5972 		blk_list_head = &phba->sli4_hba.lpfc_vfi_blk_list;
5973 		break;
5974 	case LPFC_RSC_TYPE_FCOE_RPI:
5975 		blk_list_head = &phba->sli4_hba.lpfc_rpi_blk_list;
5976 		break;
5977 	default:
5978 		return -EIO;
5979 	}
5980 
5981 	/* Count the number of extents currently allocatd for this type. */
5982 	list_for_each_entry(rsrc_blk, blk_list_head, list) {
5983 		if (curr_blks == 0) {
5984 			/*
5985 			 * The GET_ALLOCATED mailbox does not return the size,
5986 			 * just the count.  The size should be just the size
5987 			 * stored in the current allocated block and all sizes
5988 			 * for an extent type are the same so set the return
5989 			 * value now.
5990 			 */
5991 			*extnt_size = rsrc_blk->rsrc_size;
5992 		}
5993 		curr_blks++;
5994 	}
5995 
5996 	/*
5997 	 * Calculate the size of an embedded mailbox.  The uint32_t
5998 	 * accounts for extents-specific word.
5999 	 */
6000 	emb_len = sizeof(MAILBOX_t) - sizeof(struct mbox_header) -
6001 		sizeof(uint32_t);
6002 
6003 	/*
6004 	 * Presume the allocation and response will fit into an embedded
6005 	 * mailbox.  If not true, reconfigure to a non-embedded mailbox.
6006 	 */
6007 	emb = LPFC_SLI4_MBX_EMBED;
6008 	req_len = emb_len;
6009 	if (req_len > emb_len) {
6010 		req_len = curr_blks * sizeof(uint16_t) +
6011 			sizeof(union lpfc_sli4_cfg_shdr) +
6012 			sizeof(uint32_t);
6013 		emb = LPFC_SLI4_MBX_NEMBED;
6014 	}
6015 
6016 	mbox = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6017 	if (!mbox)
6018 		return -ENOMEM;
6019 	memset(mbox, 0, sizeof(LPFC_MBOXQ_t));
6020 
6021 	alloc_len = lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
6022 				     LPFC_MBOX_OPCODE_GET_ALLOC_RSRC_EXTENT,
6023 				     req_len, emb);
6024 	if (alloc_len < req_len) {
6025 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6026 			"2983 Allocated DMA memory size (x%x) is "
6027 			"less than the requested DMA memory "
6028 			"size (x%x)\n", alloc_len, req_len);
6029 		rc = -ENOMEM;
6030 		goto err_exit;
6031 	}
6032 	rc = lpfc_sli4_mbox_rsrc_extent(phba, mbox, curr_blks, type, emb);
6033 	if (unlikely(rc)) {
6034 		rc = -EIO;
6035 		goto err_exit;
6036 	}
6037 
6038 	if (!phba->sli4_hba.intr_enable)
6039 		rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
6040 	else {
6041 		mbox_tmo = lpfc_mbox_tmo_val(phba, mbox);
6042 		rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
6043 	}
6044 
6045 	if (unlikely(rc)) {
6046 		rc = -EIO;
6047 		goto err_exit;
6048 	}
6049 
6050 	/*
6051 	 * Figure out where the response is located.  Then get local pointers
6052 	 * to the response data.  The port does not guarantee to respond to
6053 	 * all extents counts request so update the local variable with the
6054 	 * allocated count from the port.
6055 	 */
6056 	if (emb == LPFC_SLI4_MBX_EMBED) {
6057 		rsrc_ext = &mbox->u.mqe.un.alloc_rsrc_extents;
6058 		shdr = &rsrc_ext->header.cfg_shdr;
6059 		*extnt_cnt = bf_get(lpfc_mbx_rsrc_cnt, &rsrc_ext->u.rsp);
6060 	} else {
6061 		virtaddr = mbox->sge_array->addr[0];
6062 		n_rsrc = (struct lpfc_mbx_nembed_rsrc_extent *) virtaddr;
6063 		shdr = &n_rsrc->cfg_shdr;
6064 		*extnt_cnt = bf_get(lpfc_mbx_rsrc_cnt, n_rsrc);
6065 	}
6066 
6067 	if (bf_get(lpfc_mbox_hdr_status, &shdr->response)) {
6068 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
6069 			"2984 Failed to read allocated resources "
6070 			"for type %d - Status 0x%x Add'l Status 0x%x.\n",
6071 			type,
6072 			bf_get(lpfc_mbox_hdr_status, &shdr->response),
6073 			bf_get(lpfc_mbox_hdr_add_status, &shdr->response));
6074 		rc = -EIO;
6075 		goto err_exit;
6076 	}
6077  err_exit:
6078 	lpfc_sli4_mbox_cmd_free(phba, mbox);
6079 	return rc;
6080 }
6081 
6082 /**
6083  * lpfc_sli4_repost_els_sgl_list - Repsot the els buffers sgl pages as block
6084  * @phba: pointer to lpfc hba data structure.
6085  *
6086  * This routine walks the list of els buffers that have been allocated and
6087  * repost them to the port by using SGL block post. This is needed after a
6088  * pci_function_reset/warm_start or start. It attempts to construct blocks
6089  * of els buffer sgls which contains contiguous xris and uses the non-embedded
6090  * SGL block post mailbox commands to post them to the port. For single els
6091  * buffer sgl with non-contiguous xri, if any, it shall use embedded SGL post
6092  * mailbox command for posting.
6093  *
6094  * Returns: 0 = success, non-zero failure.
6095  **/
6096 static int
6097 lpfc_sli4_repost_els_sgl_list(struct lpfc_hba *phba)
6098 {
6099 	struct lpfc_sglq *sglq_entry = NULL;
6100 	struct lpfc_sglq *sglq_entry_next = NULL;
6101 	struct lpfc_sglq *sglq_entry_first = NULL;
6102 	int status, total_cnt, post_cnt = 0, num_posted = 0, block_cnt = 0;
6103 	int last_xritag = NO_XRI;
6104 	struct lpfc_sli_ring *pring;
6105 	LIST_HEAD(prep_sgl_list);
6106 	LIST_HEAD(blck_sgl_list);
6107 	LIST_HEAD(allc_sgl_list);
6108 	LIST_HEAD(post_sgl_list);
6109 	LIST_HEAD(free_sgl_list);
6110 
6111 	pring = &phba->sli.ring[LPFC_ELS_RING];
6112 	spin_lock_irq(&phba->hbalock);
6113 	spin_lock(&pring->ring_lock);
6114 	list_splice_init(&phba->sli4_hba.lpfc_sgl_list, &allc_sgl_list);
6115 	spin_unlock(&pring->ring_lock);
6116 	spin_unlock_irq(&phba->hbalock);
6117 
6118 	total_cnt = phba->sli4_hba.els_xri_cnt;
6119 	list_for_each_entry_safe(sglq_entry, sglq_entry_next,
6120 				 &allc_sgl_list, list) {
6121 		list_del_init(&sglq_entry->list);
6122 		block_cnt++;
6123 		if ((last_xritag != NO_XRI) &&
6124 		    (sglq_entry->sli4_xritag != last_xritag + 1)) {
6125 			/* a hole in xri block, form a sgl posting block */
6126 			list_splice_init(&prep_sgl_list, &blck_sgl_list);
6127 			post_cnt = block_cnt - 1;
6128 			/* prepare list for next posting block */
6129 			list_add_tail(&sglq_entry->list, &prep_sgl_list);
6130 			block_cnt = 1;
6131 		} else {
6132 			/* prepare list for next posting block */
6133 			list_add_tail(&sglq_entry->list, &prep_sgl_list);
6134 			/* enough sgls for non-embed sgl mbox command */
6135 			if (block_cnt == LPFC_NEMBED_MBOX_SGL_CNT) {
6136 				list_splice_init(&prep_sgl_list,
6137 						 &blck_sgl_list);
6138 				post_cnt = block_cnt;
6139 				block_cnt = 0;
6140 			}
6141 		}
6142 		num_posted++;
6143 
6144 		/* keep track of last sgl's xritag */
6145 		last_xritag = sglq_entry->sli4_xritag;
6146 
6147 		/* end of repost sgl list condition for els buffers */
6148 		if (num_posted == phba->sli4_hba.els_xri_cnt) {
6149 			if (post_cnt == 0) {
6150 				list_splice_init(&prep_sgl_list,
6151 						 &blck_sgl_list);
6152 				post_cnt = block_cnt;
6153 			} else if (block_cnt == 1) {
6154 				status = lpfc_sli4_post_sgl(phba,
6155 						sglq_entry->phys, 0,
6156 						sglq_entry->sli4_xritag);
6157 				if (!status) {
6158 					/* successful, put sgl to posted list */
6159 					list_add_tail(&sglq_entry->list,
6160 						      &post_sgl_list);
6161 				} else {
6162 					/* Failure, put sgl to free list */
6163 					lpfc_printf_log(phba, KERN_WARNING,
6164 						LOG_SLI,
6165 						"3159 Failed to post els "
6166 						"sgl, xritag:x%x\n",
6167 						sglq_entry->sli4_xritag);
6168 					list_add_tail(&sglq_entry->list,
6169 						      &free_sgl_list);
6170 					total_cnt--;
6171 				}
6172 			}
6173 		}
6174 
6175 		/* continue until a nembed page worth of sgls */
6176 		if (post_cnt == 0)
6177 			continue;
6178 
6179 		/* post the els buffer list sgls as a block */
6180 		status = lpfc_sli4_post_els_sgl_list(phba, &blck_sgl_list,
6181 						     post_cnt);
6182 
6183 		if (!status) {
6184 			/* success, put sgl list to posted sgl list */
6185 			list_splice_init(&blck_sgl_list, &post_sgl_list);
6186 		} else {
6187 			/* Failure, put sgl list to free sgl list */
6188 			sglq_entry_first = list_first_entry(&blck_sgl_list,
6189 							    struct lpfc_sglq,
6190 							    list);
6191 			lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
6192 					"3160 Failed to post els sgl-list, "
6193 					"xritag:x%x-x%x\n",
6194 					sglq_entry_first->sli4_xritag,
6195 					(sglq_entry_first->sli4_xritag +
6196 					 post_cnt - 1));
6197 			list_splice_init(&blck_sgl_list, &free_sgl_list);
6198 			total_cnt -= post_cnt;
6199 		}
6200 
6201 		/* don't reset xirtag due to hole in xri block */
6202 		if (block_cnt == 0)
6203 			last_xritag = NO_XRI;
6204 
6205 		/* reset els sgl post count for next round of posting */
6206 		post_cnt = 0;
6207 	}
6208 	/* update the number of XRIs posted for ELS */
6209 	phba->sli4_hba.els_xri_cnt = total_cnt;
6210 
6211 	/* free the els sgls failed to post */
6212 	lpfc_free_sgl_list(phba, &free_sgl_list);
6213 
6214 	/* push els sgls posted to the availble list */
6215 	if (!list_empty(&post_sgl_list)) {
6216 		spin_lock_irq(&phba->hbalock);
6217 		spin_lock(&pring->ring_lock);
6218 		list_splice_init(&post_sgl_list,
6219 				 &phba->sli4_hba.lpfc_sgl_list);
6220 		spin_unlock(&pring->ring_lock);
6221 		spin_unlock_irq(&phba->hbalock);
6222 	} else {
6223 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
6224 				"3161 Failure to post els sgl to port.\n");
6225 		return -EIO;
6226 	}
6227 	return 0;
6228 }
6229 
6230 /**
6231  * lpfc_sli4_hba_setup - SLI4 device intialization PCI function
6232  * @phba: Pointer to HBA context object.
6233  *
6234  * This function is the main SLI4 device intialization PCI function. This
6235  * function is called by the HBA intialization code, HBA reset code and
6236  * HBA error attention handler code. Caller is not required to hold any
6237  * locks.
6238  **/
6239 int
6240 lpfc_sli4_hba_setup(struct lpfc_hba *phba)
6241 {
6242 	int rc;
6243 	LPFC_MBOXQ_t *mboxq;
6244 	struct lpfc_mqe *mqe;
6245 	uint8_t *vpd;
6246 	uint32_t vpd_size;
6247 	uint32_t ftr_rsp = 0;
6248 	struct Scsi_Host *shost = lpfc_shost_from_vport(phba->pport);
6249 	struct lpfc_vport *vport = phba->pport;
6250 	struct lpfc_dmabuf *mp;
6251 
6252 	/* Perform a PCI function reset to start from clean */
6253 	rc = lpfc_pci_function_reset(phba);
6254 	if (unlikely(rc))
6255 		return -ENODEV;
6256 
6257 	/* Check the HBA Host Status Register for readyness */
6258 	rc = lpfc_sli4_post_status_check(phba);
6259 	if (unlikely(rc))
6260 		return -ENODEV;
6261 	else {
6262 		spin_lock_irq(&phba->hbalock);
6263 		phba->sli.sli_flag |= LPFC_SLI_ACTIVE;
6264 		spin_unlock_irq(&phba->hbalock);
6265 	}
6266 
6267 	/*
6268 	 * Allocate a single mailbox container for initializing the
6269 	 * port.
6270 	 */
6271 	mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6272 	if (!mboxq)
6273 		return -ENOMEM;
6274 
6275 	/* Issue READ_REV to collect vpd and FW information. */
6276 	vpd_size = SLI4_PAGE_SIZE;
6277 	vpd = kzalloc(vpd_size, GFP_KERNEL);
6278 	if (!vpd) {
6279 		rc = -ENOMEM;
6280 		goto out_free_mbox;
6281 	}
6282 
6283 	rc = lpfc_sli4_read_rev(phba, mboxq, vpd, &vpd_size);
6284 	if (unlikely(rc)) {
6285 		kfree(vpd);
6286 		goto out_free_mbox;
6287 	}
6288 
6289 	mqe = &mboxq->u.mqe;
6290 	phba->sli_rev = bf_get(lpfc_mbx_rd_rev_sli_lvl, &mqe->un.read_rev);
6291 	if (bf_get(lpfc_mbx_rd_rev_fcoe, &mqe->un.read_rev))
6292 		phba->hba_flag |= HBA_FCOE_MODE;
6293 	else
6294 		phba->hba_flag &= ~HBA_FCOE_MODE;
6295 
6296 	if (bf_get(lpfc_mbx_rd_rev_cee_ver, &mqe->un.read_rev) ==
6297 		LPFC_DCBX_CEE_MODE)
6298 		phba->hba_flag |= HBA_FIP_SUPPORT;
6299 	else
6300 		phba->hba_flag &= ~HBA_FIP_SUPPORT;
6301 
6302 	phba->hba_flag &= ~HBA_FCP_IOQ_FLUSH;
6303 
6304 	if (phba->sli_rev != LPFC_SLI_REV4) {
6305 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6306 			"0376 READ_REV Error. SLI Level %d "
6307 			"FCoE enabled %d\n",
6308 			phba->sli_rev, phba->hba_flag & HBA_FCOE_MODE);
6309 		rc = -EIO;
6310 		kfree(vpd);
6311 		goto out_free_mbox;
6312 	}
6313 
6314 	/*
6315 	 * Continue initialization with default values even if driver failed
6316 	 * to read FCoE param config regions, only read parameters if the
6317 	 * board is FCoE
6318 	 */
6319 	if (phba->hba_flag & HBA_FCOE_MODE &&
6320 	    lpfc_sli4_read_fcoe_params(phba))
6321 		lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_INIT,
6322 			"2570 Failed to read FCoE parameters\n");
6323 
6324 	/*
6325 	 * Retrieve sli4 device physical port name, failure of doing it
6326 	 * is considered as non-fatal.
6327 	 */
6328 	rc = lpfc_sli4_retrieve_pport_name(phba);
6329 	if (!rc)
6330 		lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
6331 				"3080 Successful retrieving SLI4 device "
6332 				"physical port name: %s.\n", phba->Port);
6333 
6334 	/*
6335 	 * Evaluate the read rev and vpd data. Populate the driver
6336 	 * state with the results. If this routine fails, the failure
6337 	 * is not fatal as the driver will use generic values.
6338 	 */
6339 	rc = lpfc_parse_vpd(phba, vpd, vpd_size);
6340 	if (unlikely(!rc)) {
6341 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6342 				"0377 Error %d parsing vpd. "
6343 				"Using defaults.\n", rc);
6344 		rc = 0;
6345 	}
6346 	kfree(vpd);
6347 
6348 	/* Save information as VPD data */
6349 	phba->vpd.rev.biuRev = mqe->un.read_rev.first_hw_rev;
6350 	phba->vpd.rev.smRev = mqe->un.read_rev.second_hw_rev;
6351 	phba->vpd.rev.endecRev = mqe->un.read_rev.third_hw_rev;
6352 	phba->vpd.rev.fcphHigh = bf_get(lpfc_mbx_rd_rev_fcph_high,
6353 					 &mqe->un.read_rev);
6354 	phba->vpd.rev.fcphLow = bf_get(lpfc_mbx_rd_rev_fcph_low,
6355 				       &mqe->un.read_rev);
6356 	phba->vpd.rev.feaLevelHigh = bf_get(lpfc_mbx_rd_rev_ftr_lvl_high,
6357 					    &mqe->un.read_rev);
6358 	phba->vpd.rev.feaLevelLow = bf_get(lpfc_mbx_rd_rev_ftr_lvl_low,
6359 					   &mqe->un.read_rev);
6360 	phba->vpd.rev.sli1FwRev = mqe->un.read_rev.fw_id_rev;
6361 	memcpy(phba->vpd.rev.sli1FwName, mqe->un.read_rev.fw_name, 16);
6362 	phba->vpd.rev.sli2FwRev = mqe->un.read_rev.ulp_fw_id_rev;
6363 	memcpy(phba->vpd.rev.sli2FwName, mqe->un.read_rev.ulp_fw_name, 16);
6364 	phba->vpd.rev.opFwRev = mqe->un.read_rev.fw_id_rev;
6365 	memcpy(phba->vpd.rev.opFwName, mqe->un.read_rev.fw_name, 16);
6366 	lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
6367 			"(%d):0380 READ_REV Status x%x "
6368 			"fw_rev:%s fcphHi:%x fcphLo:%x flHi:%x flLo:%x\n",
6369 			mboxq->vport ? mboxq->vport->vpi : 0,
6370 			bf_get(lpfc_mqe_status, mqe),
6371 			phba->vpd.rev.opFwName,
6372 			phba->vpd.rev.fcphHigh, phba->vpd.rev.fcphLow,
6373 			phba->vpd.rev.feaLevelHigh, phba->vpd.rev.feaLevelLow);
6374 
6375 	/* Reset the DFT_LUN_Q_DEPTH to (max xri >> 3)  */
6376 	rc = (phba->sli4_hba.max_cfg_param.max_xri >> 3);
6377 	if (phba->pport->cfg_lun_queue_depth > rc) {
6378 		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6379 				"3362 LUN queue depth changed from %d to %d\n",
6380 				phba->pport->cfg_lun_queue_depth, rc);
6381 		phba->pport->cfg_lun_queue_depth = rc;
6382 	}
6383 
6384 
6385 	/*
6386 	 * Discover the port's supported feature set and match it against the
6387 	 * hosts requests.
6388 	 */
6389 	lpfc_request_features(phba, mboxq);
6390 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
6391 	if (unlikely(rc)) {
6392 		rc = -EIO;
6393 		goto out_free_mbox;
6394 	}
6395 
6396 	/*
6397 	 * The port must support FCP initiator mode as this is the
6398 	 * only mode running in the host.
6399 	 */
6400 	if (!(bf_get(lpfc_mbx_rq_ftr_rsp_fcpi, &mqe->un.req_ftrs))) {
6401 		lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_SLI,
6402 				"0378 No support for fcpi mode.\n");
6403 		ftr_rsp++;
6404 	}
6405 	if (bf_get(lpfc_mbx_rq_ftr_rsp_perfh, &mqe->un.req_ftrs))
6406 		phba->sli3_options |= LPFC_SLI4_PERFH_ENABLED;
6407 	else
6408 		phba->sli3_options &= ~LPFC_SLI4_PERFH_ENABLED;
6409 	/*
6410 	 * If the port cannot support the host's requested features
6411 	 * then turn off the global config parameters to disable the
6412 	 * feature in the driver.  This is not a fatal error.
6413 	 */
6414 	phba->sli3_options &= ~LPFC_SLI3_BG_ENABLED;
6415 	if (phba->cfg_enable_bg) {
6416 		if (bf_get(lpfc_mbx_rq_ftr_rsp_dif, &mqe->un.req_ftrs))
6417 			phba->sli3_options |= LPFC_SLI3_BG_ENABLED;
6418 		else
6419 			ftr_rsp++;
6420 	}
6421 
6422 	if (phba->max_vpi && phba->cfg_enable_npiv &&
6423 	    !(bf_get(lpfc_mbx_rq_ftr_rsp_npiv, &mqe->un.req_ftrs)))
6424 		ftr_rsp++;
6425 
6426 	if (ftr_rsp) {
6427 		lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_SLI,
6428 				"0379 Feature Mismatch Data: x%08x %08x "
6429 				"x%x x%x x%x\n", mqe->un.req_ftrs.word2,
6430 				mqe->un.req_ftrs.word3, phba->cfg_enable_bg,
6431 				phba->cfg_enable_npiv, phba->max_vpi);
6432 		if (!(bf_get(lpfc_mbx_rq_ftr_rsp_dif, &mqe->un.req_ftrs)))
6433 			phba->cfg_enable_bg = 0;
6434 		if (!(bf_get(lpfc_mbx_rq_ftr_rsp_npiv, &mqe->un.req_ftrs)))
6435 			phba->cfg_enable_npiv = 0;
6436 	}
6437 
6438 	/* These SLI3 features are assumed in SLI4 */
6439 	spin_lock_irq(&phba->hbalock);
6440 	phba->sli3_options |= (LPFC_SLI3_NPIV_ENABLED | LPFC_SLI3_HBQ_ENABLED);
6441 	spin_unlock_irq(&phba->hbalock);
6442 
6443 	/*
6444 	 * Allocate all resources (xri,rpi,vpi,vfi) now.  Subsequent
6445 	 * calls depends on these resources to complete port setup.
6446 	 */
6447 	rc = lpfc_sli4_alloc_resource_identifiers(phba);
6448 	if (rc) {
6449 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6450 				"2920 Failed to alloc Resource IDs "
6451 				"rc = x%x\n", rc);
6452 		goto out_free_mbox;
6453 	}
6454 
6455 	/* Read the port's service parameters. */
6456 	rc = lpfc_read_sparam(phba, mboxq, vport->vpi);
6457 	if (rc) {
6458 		phba->link_state = LPFC_HBA_ERROR;
6459 		rc = -ENOMEM;
6460 		goto out_free_mbox;
6461 	}
6462 
6463 	mboxq->vport = vport;
6464 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
6465 	mp = (struct lpfc_dmabuf *) mboxq->context1;
6466 	if (rc == MBX_SUCCESS) {
6467 		memcpy(&vport->fc_sparam, mp->virt, sizeof(struct serv_parm));
6468 		rc = 0;
6469 	}
6470 
6471 	/*
6472 	 * This memory was allocated by the lpfc_read_sparam routine. Release
6473 	 * it to the mbuf pool.
6474 	 */
6475 	lpfc_mbuf_free(phba, mp->virt, mp->phys);
6476 	kfree(mp);
6477 	mboxq->context1 = NULL;
6478 	if (unlikely(rc)) {
6479 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6480 				"0382 READ_SPARAM command failed "
6481 				"status %d, mbxStatus x%x\n",
6482 				rc, bf_get(lpfc_mqe_status, mqe));
6483 		phba->link_state = LPFC_HBA_ERROR;
6484 		rc = -EIO;
6485 		goto out_free_mbox;
6486 	}
6487 
6488 	lpfc_update_vport_wwn(vport);
6489 
6490 	/* Update the fc_host data structures with new wwn. */
6491 	fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
6492 	fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
6493 
6494 	/* update host els and scsi xri-sgl sizes and mappings */
6495 	rc = lpfc_sli4_xri_sgl_update(phba);
6496 	if (unlikely(rc)) {
6497 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6498 				"1400 Failed to update xri-sgl size and "
6499 				"mapping: %d\n", rc);
6500 		goto out_free_mbox;
6501 	}
6502 
6503 	/* register the els sgl pool to the port */
6504 	rc = lpfc_sli4_repost_els_sgl_list(phba);
6505 	if (unlikely(rc)) {
6506 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6507 				"0582 Error %d during els sgl post "
6508 				"operation\n", rc);
6509 		rc = -ENODEV;
6510 		goto out_free_mbox;
6511 	}
6512 
6513 	/* register the allocated scsi sgl pool to the port */
6514 	rc = lpfc_sli4_repost_scsi_sgl_list(phba);
6515 	if (unlikely(rc)) {
6516 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6517 				"0383 Error %d during scsi sgl post "
6518 				"operation\n", rc);
6519 		/* Some Scsi buffers were moved to the abort scsi list */
6520 		/* A pci function reset will repost them */
6521 		rc = -ENODEV;
6522 		goto out_free_mbox;
6523 	}
6524 
6525 	/* Post the rpi header region to the device. */
6526 	rc = lpfc_sli4_post_all_rpi_hdrs(phba);
6527 	if (unlikely(rc)) {
6528 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6529 				"0393 Error %d during rpi post operation\n",
6530 				rc);
6531 		rc = -ENODEV;
6532 		goto out_free_mbox;
6533 	}
6534 	lpfc_sli4_node_prep(phba);
6535 
6536 	/* Create all the SLI4 queues */
6537 	rc = lpfc_sli4_queue_create(phba);
6538 	if (rc) {
6539 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6540 				"3089 Failed to allocate queues\n");
6541 		rc = -ENODEV;
6542 		goto out_stop_timers;
6543 	}
6544 	/* Set up all the queues to the device */
6545 	rc = lpfc_sli4_queue_setup(phba);
6546 	if (unlikely(rc)) {
6547 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6548 				"0381 Error %d during queue setup.\n ", rc);
6549 		goto out_destroy_queue;
6550 	}
6551 
6552 	/* Arm the CQs and then EQs on device */
6553 	lpfc_sli4_arm_cqeq_intr(phba);
6554 
6555 	/* Indicate device interrupt mode */
6556 	phba->sli4_hba.intr_enable = 1;
6557 
6558 	/* Allow asynchronous mailbox command to go through */
6559 	spin_lock_irq(&phba->hbalock);
6560 	phba->sli.sli_flag &= ~LPFC_SLI_ASYNC_MBX_BLK;
6561 	spin_unlock_irq(&phba->hbalock);
6562 
6563 	/* Post receive buffers to the device */
6564 	lpfc_sli4_rb_setup(phba);
6565 
6566 	/* Reset HBA FCF states after HBA reset */
6567 	phba->fcf.fcf_flag = 0;
6568 	phba->fcf.current_rec.flag = 0;
6569 
6570 	/* Start the ELS watchdog timer */
6571 	mod_timer(&vport->els_tmofunc,
6572 		  jiffies + msecs_to_jiffies(1000 * (phba->fc_ratov * 2)));
6573 
6574 	/* Start heart beat timer */
6575 	mod_timer(&phba->hb_tmofunc,
6576 		  jiffies + msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
6577 	phba->hb_outstanding = 0;
6578 	phba->last_completion_time = jiffies;
6579 
6580 	/* Start error attention (ERATT) polling timer */
6581 	mod_timer(&phba->eratt_poll,
6582 		  jiffies + msecs_to_jiffies(1000 * LPFC_ERATT_POLL_INTERVAL));
6583 
6584 	/* Enable PCIe device Advanced Error Reporting (AER) if configured */
6585 	if (phba->cfg_aer_support == 1 && !(phba->hba_flag & HBA_AER_ENABLED)) {
6586 		rc = pci_enable_pcie_error_reporting(phba->pcidev);
6587 		if (!rc) {
6588 			lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6589 					"2829 This device supports "
6590 					"Advanced Error Reporting (AER)\n");
6591 			spin_lock_irq(&phba->hbalock);
6592 			phba->hba_flag |= HBA_AER_ENABLED;
6593 			spin_unlock_irq(&phba->hbalock);
6594 		} else {
6595 			lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6596 					"2830 This device does not support "
6597 					"Advanced Error Reporting (AER)\n");
6598 			phba->cfg_aer_support = 0;
6599 		}
6600 		rc = 0;
6601 	}
6602 
6603 	if (!(phba->hba_flag & HBA_FCOE_MODE)) {
6604 		/*
6605 		 * The FC Port needs to register FCFI (index 0)
6606 		 */
6607 		lpfc_reg_fcfi(phba, mboxq);
6608 		mboxq->vport = phba->pport;
6609 		rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
6610 		if (rc != MBX_SUCCESS)
6611 			goto out_unset_queue;
6612 		rc = 0;
6613 		phba->fcf.fcfi = bf_get(lpfc_reg_fcfi_fcfi,
6614 					&mboxq->u.mqe.un.reg_fcfi);
6615 
6616 		/* Check if the port is configured to be disabled */
6617 		lpfc_sli_read_link_ste(phba);
6618 	}
6619 
6620 	/*
6621 	 * The port is ready, set the host's link state to LINK_DOWN
6622 	 * in preparation for link interrupts.
6623 	 */
6624 	spin_lock_irq(&phba->hbalock);
6625 	phba->link_state = LPFC_LINK_DOWN;
6626 	spin_unlock_irq(&phba->hbalock);
6627 	if (!(phba->hba_flag & HBA_FCOE_MODE) &&
6628 	    (phba->hba_flag & LINK_DISABLED)) {
6629 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_SLI,
6630 				"3103 Adapter Link is disabled.\n");
6631 		lpfc_down_link(phba, mboxq);
6632 		rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
6633 		if (rc != MBX_SUCCESS) {
6634 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_SLI,
6635 					"3104 Adapter failed to issue "
6636 					"DOWN_LINK mbox cmd, rc:x%x\n", rc);
6637 			goto out_unset_queue;
6638 		}
6639 	} else if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) {
6640 		/* don't perform init_link on SLI4 FC port loopback test */
6641 		if (!(phba->link_flag & LS_LOOPBACK_MODE)) {
6642 			rc = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
6643 			if (rc)
6644 				goto out_unset_queue;
6645 		}
6646 	}
6647 	mempool_free(mboxq, phba->mbox_mem_pool);
6648 	return rc;
6649 out_unset_queue:
6650 	/* Unset all the queues set up in this routine when error out */
6651 	lpfc_sli4_queue_unset(phba);
6652 out_destroy_queue:
6653 	lpfc_sli4_queue_destroy(phba);
6654 out_stop_timers:
6655 	lpfc_stop_hba_timers(phba);
6656 out_free_mbox:
6657 	mempool_free(mboxq, phba->mbox_mem_pool);
6658 	return rc;
6659 }
6660 
6661 /**
6662  * lpfc_mbox_timeout - Timeout call back function for mbox timer
6663  * @ptr: context object - pointer to hba structure.
6664  *
6665  * This is the callback function for mailbox timer. The mailbox
6666  * timer is armed when a new mailbox command is issued and the timer
6667  * is deleted when the mailbox complete. The function is called by
6668  * the kernel timer code when a mailbox does not complete within
6669  * expected time. This function wakes up the worker thread to
6670  * process the mailbox timeout and returns. All the processing is
6671  * done by the worker thread function lpfc_mbox_timeout_handler.
6672  **/
6673 void
6674 lpfc_mbox_timeout(unsigned long ptr)
6675 {
6676 	struct lpfc_hba  *phba = (struct lpfc_hba *) ptr;
6677 	unsigned long iflag;
6678 	uint32_t tmo_posted;
6679 
6680 	spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
6681 	tmo_posted = phba->pport->work_port_events & WORKER_MBOX_TMO;
6682 	if (!tmo_posted)
6683 		phba->pport->work_port_events |= WORKER_MBOX_TMO;
6684 	spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
6685 
6686 	if (!tmo_posted)
6687 		lpfc_worker_wake_up(phba);
6688 	return;
6689 }
6690 
6691 /**
6692  * lpfc_sli4_mbox_completions_pending - check to see if any mailbox completions
6693  *                                    are pending
6694  * @phba: Pointer to HBA context object.
6695  *
6696  * This function checks if any mailbox completions are present on the mailbox
6697  * completion queue.
6698  **/
6699 bool
6700 lpfc_sli4_mbox_completions_pending(struct lpfc_hba *phba)
6701 {
6702 
6703 	uint32_t idx;
6704 	struct lpfc_queue *mcq;
6705 	struct lpfc_mcqe *mcqe;
6706 	bool pending_completions = false;
6707 
6708 	if (unlikely(!phba) || (phba->sli_rev != LPFC_SLI_REV4))
6709 		return false;
6710 
6711 	/* Check for completions on mailbox completion queue */
6712 
6713 	mcq = phba->sli4_hba.mbx_cq;
6714 	idx = mcq->hba_index;
6715 	while (bf_get_le32(lpfc_cqe_valid, mcq->qe[idx].cqe)) {
6716 		mcqe = (struct lpfc_mcqe *)mcq->qe[idx].cqe;
6717 		if (bf_get_le32(lpfc_trailer_completed, mcqe) &&
6718 		    (!bf_get_le32(lpfc_trailer_async, mcqe))) {
6719 			pending_completions = true;
6720 			break;
6721 		}
6722 		idx = (idx + 1) % mcq->entry_count;
6723 		if (mcq->hba_index == idx)
6724 			break;
6725 	}
6726 	return pending_completions;
6727 
6728 }
6729 
6730 /**
6731  * lpfc_sli4_process_missed_mbox_completions - process mbox completions
6732  *					      that were missed.
6733  * @phba: Pointer to HBA context object.
6734  *
6735  * For sli4, it is possible to miss an interrupt. As such mbox completions
6736  * maybe missed causing erroneous mailbox timeouts to occur. This function
6737  * checks to see if mbox completions are on the mailbox completion queue
6738  * and will process all the completions associated with the eq for the
6739  * mailbox completion queue.
6740  **/
6741 bool
6742 lpfc_sli4_process_missed_mbox_completions(struct lpfc_hba *phba)
6743 {
6744 
6745 	uint32_t eqidx;
6746 	struct lpfc_queue *fpeq = NULL;
6747 	struct lpfc_eqe *eqe;
6748 	bool mbox_pending;
6749 
6750 	if (unlikely(!phba) || (phba->sli_rev != LPFC_SLI_REV4))
6751 		return false;
6752 
6753 	/* Find the eq associated with the mcq */
6754 
6755 	if (phba->sli4_hba.hba_eq)
6756 		for (eqidx = 0; eqidx < phba->cfg_fcp_io_channel; eqidx++)
6757 			if (phba->sli4_hba.hba_eq[eqidx]->queue_id ==
6758 			    phba->sli4_hba.mbx_cq->assoc_qid) {
6759 				fpeq = phba->sli4_hba.hba_eq[eqidx];
6760 				break;
6761 			}
6762 	if (!fpeq)
6763 		return false;
6764 
6765 	/* Turn off interrupts from this EQ */
6766 
6767 	lpfc_sli4_eq_clr_intr(fpeq);
6768 
6769 	/* Check to see if a mbox completion is pending */
6770 
6771 	mbox_pending = lpfc_sli4_mbox_completions_pending(phba);
6772 
6773 	/*
6774 	 * If a mbox completion is pending, process all the events on EQ
6775 	 * associated with the mbox completion queue (this could include
6776 	 * mailbox commands, async events, els commands, receive queue data
6777 	 * and fcp commands)
6778 	 */
6779 
6780 	if (mbox_pending)
6781 		while ((eqe = lpfc_sli4_eq_get(fpeq))) {
6782 			lpfc_sli4_hba_handle_eqe(phba, eqe, eqidx);
6783 			fpeq->EQ_processed++;
6784 		}
6785 
6786 	/* Always clear and re-arm the EQ */
6787 
6788 	lpfc_sli4_eq_release(fpeq, LPFC_QUEUE_REARM);
6789 
6790 	return mbox_pending;
6791 
6792 }
6793 
6794 /**
6795  * lpfc_mbox_timeout_handler - Worker thread function to handle mailbox timeout
6796  * @phba: Pointer to HBA context object.
6797  *
6798  * This function is called from worker thread when a mailbox command times out.
6799  * The caller is not required to hold any locks. This function will reset the
6800  * HBA and recover all the pending commands.
6801  **/
6802 void
6803 lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
6804 {
6805 	LPFC_MBOXQ_t *pmbox = phba->sli.mbox_active;
6806 	MAILBOX_t *mb = NULL;
6807 
6808 	struct lpfc_sli *psli = &phba->sli;
6809 
6810 	/* If the mailbox completed, process the completion and return */
6811 	if (lpfc_sli4_process_missed_mbox_completions(phba))
6812 		return;
6813 
6814 	if (pmbox != NULL)
6815 		mb = &pmbox->u.mb;
6816 	/* Check the pmbox pointer first.  There is a race condition
6817 	 * between the mbox timeout handler getting executed in the
6818 	 * worklist and the mailbox actually completing. When this
6819 	 * race condition occurs, the mbox_active will be NULL.
6820 	 */
6821 	spin_lock_irq(&phba->hbalock);
6822 	if (pmbox == NULL) {
6823 		lpfc_printf_log(phba, KERN_WARNING,
6824 				LOG_MBOX | LOG_SLI,
6825 				"0353 Active Mailbox cleared - mailbox timeout "
6826 				"exiting\n");
6827 		spin_unlock_irq(&phba->hbalock);
6828 		return;
6829 	}
6830 
6831 	/* Mbox cmd <mbxCommand> timeout */
6832 	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6833 			"0310 Mailbox command x%x timeout Data: x%x x%x x%p\n",
6834 			mb->mbxCommand,
6835 			phba->pport->port_state,
6836 			phba->sli.sli_flag,
6837 			phba->sli.mbox_active);
6838 	spin_unlock_irq(&phba->hbalock);
6839 
6840 	/* Setting state unknown so lpfc_sli_abort_iocb_ring
6841 	 * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
6842 	 * it to fail all outstanding SCSI IO.
6843 	 */
6844 	spin_lock_irq(&phba->pport->work_port_lock);
6845 	phba->pport->work_port_events &= ~WORKER_MBOX_TMO;
6846 	spin_unlock_irq(&phba->pport->work_port_lock);
6847 	spin_lock_irq(&phba->hbalock);
6848 	phba->link_state = LPFC_LINK_UNKNOWN;
6849 	psli->sli_flag &= ~LPFC_SLI_ACTIVE;
6850 	spin_unlock_irq(&phba->hbalock);
6851 
6852 	lpfc_sli_abort_fcp_rings(phba);
6853 
6854 	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6855 			"0345 Resetting board due to mailbox timeout\n");
6856 
6857 	/* Reset the HBA device */
6858 	lpfc_reset_hba(phba);
6859 }
6860 
6861 /**
6862  * lpfc_sli_issue_mbox_s3 - Issue an SLI3 mailbox command to firmware
6863  * @phba: Pointer to HBA context object.
6864  * @pmbox: Pointer to mailbox object.
6865  * @flag: Flag indicating how the mailbox need to be processed.
6866  *
6867  * This function is called by discovery code and HBA management code
6868  * to submit a mailbox command to firmware with SLI-3 interface spec. This
6869  * function gets the hbalock to protect the data structures.
6870  * The mailbox command can be submitted in polling mode, in which case
6871  * this function will wait in a polling loop for the completion of the
6872  * mailbox.
6873  * If the mailbox is submitted in no_wait mode (not polling) the
6874  * function will submit the command and returns immediately without waiting
6875  * for the mailbox completion. The no_wait is supported only when HBA
6876  * is in SLI2/SLI3 mode - interrupts are enabled.
6877  * The SLI interface allows only one mailbox pending at a time. If the
6878  * mailbox is issued in polling mode and there is already a mailbox
6879  * pending, then the function will return an error. If the mailbox is issued
6880  * in NO_WAIT mode and there is a mailbox pending already, the function
6881  * will return MBX_BUSY after queuing the mailbox into mailbox queue.
6882  * The sli layer owns the mailbox object until the completion of mailbox
6883  * command if this function return MBX_BUSY or MBX_SUCCESS. For all other
6884  * return codes the caller owns the mailbox command after the return of
6885  * the function.
6886  **/
6887 static int
6888 lpfc_sli_issue_mbox_s3(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox,
6889 		       uint32_t flag)
6890 {
6891 	MAILBOX_t *mbx;
6892 	struct lpfc_sli *psli = &phba->sli;
6893 	uint32_t status, evtctr;
6894 	uint32_t ha_copy, hc_copy;
6895 	int i;
6896 	unsigned long timeout;
6897 	unsigned long drvr_flag = 0;
6898 	uint32_t word0, ldata;
6899 	void __iomem *to_slim;
6900 	int processing_queue = 0;
6901 
6902 	spin_lock_irqsave(&phba->hbalock, drvr_flag);
6903 	if (!pmbox) {
6904 		phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
6905 		/* processing mbox queue from intr_handler */
6906 		if (unlikely(psli->sli_flag & LPFC_SLI_ASYNC_MBX_BLK)) {
6907 			spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
6908 			return MBX_SUCCESS;
6909 		}
6910 		processing_queue = 1;
6911 		pmbox = lpfc_mbox_get(phba);
6912 		if (!pmbox) {
6913 			spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
6914 			return MBX_SUCCESS;
6915 		}
6916 	}
6917 
6918 	if (pmbox->mbox_cmpl && pmbox->mbox_cmpl != lpfc_sli_def_mbox_cmpl &&
6919 		pmbox->mbox_cmpl != lpfc_sli_wake_mbox_wait) {
6920 		if(!pmbox->vport) {
6921 			spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
6922 			lpfc_printf_log(phba, KERN_ERR,
6923 					LOG_MBOX | LOG_VPORT,
6924 					"1806 Mbox x%x failed. No vport\n",
6925 					pmbox->u.mb.mbxCommand);
6926 			dump_stack();
6927 			goto out_not_finished;
6928 		}
6929 	}
6930 
6931 	/* If the PCI channel is in offline state, do not post mbox. */
6932 	if (unlikely(pci_channel_offline(phba->pcidev))) {
6933 		spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
6934 		goto out_not_finished;
6935 	}
6936 
6937 	/* If HBA has a deferred error attention, fail the iocb. */
6938 	if (unlikely(phba->hba_flag & DEFER_ERATT)) {
6939 		spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
6940 		goto out_not_finished;
6941 	}
6942 
6943 	psli = &phba->sli;
6944 
6945 	mbx = &pmbox->u.mb;
6946 	status = MBX_SUCCESS;
6947 
6948 	if (phba->link_state == LPFC_HBA_ERROR) {
6949 		spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
6950 
6951 		/* Mbox command <mbxCommand> cannot issue */
6952 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6953 				"(%d):0311 Mailbox command x%x cannot "
6954 				"issue Data: x%x x%x\n",
6955 				pmbox->vport ? pmbox->vport->vpi : 0,
6956 				pmbox->u.mb.mbxCommand, psli->sli_flag, flag);
6957 		goto out_not_finished;
6958 	}
6959 
6960 	if (mbx->mbxCommand != MBX_KILL_BOARD && flag & MBX_NOWAIT) {
6961 		if (lpfc_readl(phba->HCregaddr, &hc_copy) ||
6962 			!(hc_copy & HC_MBINT_ENA)) {
6963 			spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
6964 			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6965 				"(%d):2528 Mailbox command x%x cannot "
6966 				"issue Data: x%x x%x\n",
6967 				pmbox->vport ? pmbox->vport->vpi : 0,
6968 				pmbox->u.mb.mbxCommand, psli->sli_flag, flag);
6969 			goto out_not_finished;
6970 		}
6971 	}
6972 
6973 	if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {
6974 		/* Polling for a mbox command when another one is already active
6975 		 * is not allowed in SLI. Also, the driver must have established
6976 		 * SLI2 mode to queue and process multiple mbox commands.
6977 		 */
6978 
6979 		if (flag & MBX_POLL) {
6980 			spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
6981 
6982 			/* Mbox command <mbxCommand> cannot issue */
6983 			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6984 					"(%d):2529 Mailbox command x%x "
6985 					"cannot issue Data: x%x x%x\n",
6986 					pmbox->vport ? pmbox->vport->vpi : 0,
6987 					pmbox->u.mb.mbxCommand,
6988 					psli->sli_flag, flag);
6989 			goto out_not_finished;
6990 		}
6991 
6992 		if (!(psli->sli_flag & LPFC_SLI_ACTIVE)) {
6993 			spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
6994 			/* Mbox command <mbxCommand> cannot issue */
6995 			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6996 					"(%d):2530 Mailbox command x%x "
6997 					"cannot issue Data: x%x x%x\n",
6998 					pmbox->vport ? pmbox->vport->vpi : 0,
6999 					pmbox->u.mb.mbxCommand,
7000 					psli->sli_flag, flag);
7001 			goto out_not_finished;
7002 		}
7003 
7004 		/* Another mailbox command is still being processed, queue this
7005 		 * command to be processed later.
7006 		 */
7007 		lpfc_mbox_put(phba, pmbox);
7008 
7009 		/* Mbox cmd issue - BUSY */
7010 		lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
7011 				"(%d):0308 Mbox cmd issue - BUSY Data: "
7012 				"x%x x%x x%x x%x\n",
7013 				pmbox->vport ? pmbox->vport->vpi : 0xffffff,
7014 				mbx->mbxCommand, phba->pport->port_state,
7015 				psli->sli_flag, flag);
7016 
7017 		psli->slistat.mbox_busy++;
7018 		spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
7019 
7020 		if (pmbox->vport) {
7021 			lpfc_debugfs_disc_trc(pmbox->vport,
7022 				LPFC_DISC_TRC_MBOX_VPORT,
7023 				"MBOX Bsy vport:  cmd:x%x mb:x%x x%x",
7024 				(uint32_t)mbx->mbxCommand,
7025 				mbx->un.varWords[0], mbx->un.varWords[1]);
7026 		}
7027 		else {
7028 			lpfc_debugfs_disc_trc(phba->pport,
7029 				LPFC_DISC_TRC_MBOX,
7030 				"MBOX Bsy:        cmd:x%x mb:x%x x%x",
7031 				(uint32_t)mbx->mbxCommand,
7032 				mbx->un.varWords[0], mbx->un.varWords[1]);
7033 		}
7034 
7035 		return MBX_BUSY;
7036 	}
7037 
7038 	psli->sli_flag |= LPFC_SLI_MBOX_ACTIVE;
7039 
7040 	/* If we are not polling, we MUST be in SLI2 mode */
7041 	if (flag != MBX_POLL) {
7042 		if (!(psli->sli_flag & LPFC_SLI_ACTIVE) &&
7043 		    (mbx->mbxCommand != MBX_KILL_BOARD)) {
7044 			psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
7045 			spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
7046 			/* Mbox command <mbxCommand> cannot issue */
7047 			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
7048 					"(%d):2531 Mailbox command x%x "
7049 					"cannot issue Data: x%x x%x\n",
7050 					pmbox->vport ? pmbox->vport->vpi : 0,
7051 					pmbox->u.mb.mbxCommand,
7052 					psli->sli_flag, flag);
7053 			goto out_not_finished;
7054 		}
7055 		/* timeout active mbox command */
7056 		timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba, pmbox) *
7057 					   1000);
7058 		mod_timer(&psli->mbox_tmo, jiffies + timeout);
7059 	}
7060 
7061 	/* Mailbox cmd <cmd> issue */
7062 	lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
7063 			"(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
7064 			"x%x\n",
7065 			pmbox->vport ? pmbox->vport->vpi : 0,
7066 			mbx->mbxCommand, phba->pport->port_state,
7067 			psli->sli_flag, flag);
7068 
7069 	if (mbx->mbxCommand != MBX_HEARTBEAT) {
7070 		if (pmbox->vport) {
7071 			lpfc_debugfs_disc_trc(pmbox->vport,
7072 				LPFC_DISC_TRC_MBOX_VPORT,
7073 				"MBOX Send vport: cmd:x%x mb:x%x x%x",
7074 				(uint32_t)mbx->mbxCommand,
7075 				mbx->un.varWords[0], mbx->un.varWords[1]);
7076 		}
7077 		else {
7078 			lpfc_debugfs_disc_trc(phba->pport,
7079 				LPFC_DISC_TRC_MBOX,
7080 				"MBOX Send:       cmd:x%x mb:x%x x%x",
7081 				(uint32_t)mbx->mbxCommand,
7082 				mbx->un.varWords[0], mbx->un.varWords[1]);
7083 		}
7084 	}
7085 
7086 	psli->slistat.mbox_cmd++;
7087 	evtctr = psli->slistat.mbox_event;
7088 
7089 	/* next set own bit for the adapter and copy over command word */
7090 	mbx->mbxOwner = OWN_CHIP;
7091 
7092 	if (psli->sli_flag & LPFC_SLI_ACTIVE) {
7093 		/* Populate mbox extension offset word. */
7094 		if (pmbox->in_ext_byte_len || pmbox->out_ext_byte_len) {
7095 			*(((uint32_t *)mbx) + pmbox->mbox_offset_word)
7096 				= (uint8_t *)phba->mbox_ext
7097 				  - (uint8_t *)phba->mbox;
7098 		}
7099 
7100 		/* Copy the mailbox extension data */
7101 		if (pmbox->in_ext_byte_len && pmbox->context2) {
7102 			lpfc_sli_pcimem_bcopy(pmbox->context2,
7103 				(uint8_t *)phba->mbox_ext,
7104 				pmbox->in_ext_byte_len);
7105 		}
7106 		/* Copy command data to host SLIM area */
7107 		lpfc_sli_pcimem_bcopy(mbx, phba->mbox, MAILBOX_CMD_SIZE);
7108 	} else {
7109 		/* Populate mbox extension offset word. */
7110 		if (pmbox->in_ext_byte_len || pmbox->out_ext_byte_len)
7111 			*(((uint32_t *)mbx) + pmbox->mbox_offset_word)
7112 				= MAILBOX_HBA_EXT_OFFSET;
7113 
7114 		/* Copy the mailbox extension data */
7115 		if (pmbox->in_ext_byte_len && pmbox->context2) {
7116 			lpfc_memcpy_to_slim(phba->MBslimaddr +
7117 				MAILBOX_HBA_EXT_OFFSET,
7118 				pmbox->context2, pmbox->in_ext_byte_len);
7119 
7120 		}
7121 		if (mbx->mbxCommand == MBX_CONFIG_PORT) {
7122 			/* copy command data into host mbox for cmpl */
7123 			lpfc_sli_pcimem_bcopy(mbx, phba->mbox, MAILBOX_CMD_SIZE);
7124 		}
7125 
7126 		/* First copy mbox command data to HBA SLIM, skip past first
7127 		   word */
7128 		to_slim = phba->MBslimaddr + sizeof (uint32_t);
7129 		lpfc_memcpy_to_slim(to_slim, &mbx->un.varWords[0],
7130 			    MAILBOX_CMD_SIZE - sizeof (uint32_t));
7131 
7132 		/* Next copy over first word, with mbxOwner set */
7133 		ldata = *((uint32_t *)mbx);
7134 		to_slim = phba->MBslimaddr;
7135 		writel(ldata, to_slim);
7136 		readl(to_slim); /* flush */
7137 
7138 		if (mbx->mbxCommand == MBX_CONFIG_PORT) {
7139 			/* switch over to host mailbox */
7140 			psli->sli_flag |= LPFC_SLI_ACTIVE;
7141 		}
7142 	}
7143 
7144 	wmb();
7145 
7146 	switch (flag) {
7147 	case MBX_NOWAIT:
7148 		/* Set up reference to mailbox command */
7149 		psli->mbox_active = pmbox;
7150 		/* Interrupt board to do it */
7151 		writel(CA_MBATT, phba->CAregaddr);
7152 		readl(phba->CAregaddr); /* flush */
7153 		/* Don't wait for it to finish, just return */
7154 		break;
7155 
7156 	case MBX_POLL:
7157 		/* Set up null reference to mailbox command */
7158 		psli->mbox_active = NULL;
7159 		/* Interrupt board to do it */
7160 		writel(CA_MBATT, phba->CAregaddr);
7161 		readl(phba->CAregaddr); /* flush */
7162 
7163 		if (psli->sli_flag & LPFC_SLI_ACTIVE) {
7164 			/* First read mbox status word */
7165 			word0 = *((uint32_t *)phba->mbox);
7166 			word0 = le32_to_cpu(word0);
7167 		} else {
7168 			/* First read mbox status word */
7169 			if (lpfc_readl(phba->MBslimaddr, &word0)) {
7170 				spin_unlock_irqrestore(&phba->hbalock,
7171 						       drvr_flag);
7172 				goto out_not_finished;
7173 			}
7174 		}
7175 
7176 		/* Read the HBA Host Attention Register */
7177 		if (lpfc_readl(phba->HAregaddr, &ha_copy)) {
7178 			spin_unlock_irqrestore(&phba->hbalock,
7179 						       drvr_flag);
7180 			goto out_not_finished;
7181 		}
7182 		timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba, pmbox) *
7183 							1000) + jiffies;
7184 		i = 0;
7185 		/* Wait for command to complete */
7186 		while (((word0 & OWN_CHIP) == OWN_CHIP) ||
7187 		       (!(ha_copy & HA_MBATT) &&
7188 			(phba->link_state > LPFC_WARM_START))) {
7189 			if (time_after(jiffies, timeout)) {
7190 				psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
7191 				spin_unlock_irqrestore(&phba->hbalock,
7192 						       drvr_flag);
7193 				goto out_not_finished;
7194 			}
7195 
7196 			/* Check if we took a mbox interrupt while we were
7197 			   polling */
7198 			if (((word0 & OWN_CHIP) != OWN_CHIP)
7199 			    && (evtctr != psli->slistat.mbox_event))
7200 				break;
7201 
7202 			if (i++ > 10) {
7203 				spin_unlock_irqrestore(&phba->hbalock,
7204 						       drvr_flag);
7205 				msleep(1);
7206 				spin_lock_irqsave(&phba->hbalock, drvr_flag);
7207 			}
7208 
7209 			if (psli->sli_flag & LPFC_SLI_ACTIVE) {
7210 				/* First copy command data */
7211 				word0 = *((uint32_t *)phba->mbox);
7212 				word0 = le32_to_cpu(word0);
7213 				if (mbx->mbxCommand == MBX_CONFIG_PORT) {
7214 					MAILBOX_t *slimmb;
7215 					uint32_t slimword0;
7216 					/* Check real SLIM for any errors */
7217 					slimword0 = readl(phba->MBslimaddr);
7218 					slimmb = (MAILBOX_t *) & slimword0;
7219 					if (((slimword0 & OWN_CHIP) != OWN_CHIP)
7220 					    && slimmb->mbxStatus) {
7221 						psli->sli_flag &=
7222 						    ~LPFC_SLI_ACTIVE;
7223 						word0 = slimword0;
7224 					}
7225 				}
7226 			} else {
7227 				/* First copy command data */
7228 				word0 = readl(phba->MBslimaddr);
7229 			}
7230 			/* Read the HBA Host Attention Register */
7231 			if (lpfc_readl(phba->HAregaddr, &ha_copy)) {
7232 				spin_unlock_irqrestore(&phba->hbalock,
7233 						       drvr_flag);
7234 				goto out_not_finished;
7235 			}
7236 		}
7237 
7238 		if (psli->sli_flag & LPFC_SLI_ACTIVE) {
7239 			/* copy results back to user */
7240 			lpfc_sli_pcimem_bcopy(phba->mbox, mbx, MAILBOX_CMD_SIZE);
7241 			/* Copy the mailbox extension data */
7242 			if (pmbox->out_ext_byte_len && pmbox->context2) {
7243 				lpfc_sli_pcimem_bcopy(phba->mbox_ext,
7244 						      pmbox->context2,
7245 						      pmbox->out_ext_byte_len);
7246 			}
7247 		} else {
7248 			/* First copy command data */
7249 			lpfc_memcpy_from_slim(mbx, phba->MBslimaddr,
7250 							MAILBOX_CMD_SIZE);
7251 			/* Copy the mailbox extension data */
7252 			if (pmbox->out_ext_byte_len && pmbox->context2) {
7253 				lpfc_memcpy_from_slim(pmbox->context2,
7254 					phba->MBslimaddr +
7255 					MAILBOX_HBA_EXT_OFFSET,
7256 					pmbox->out_ext_byte_len);
7257 			}
7258 		}
7259 
7260 		writel(HA_MBATT, phba->HAregaddr);
7261 		readl(phba->HAregaddr); /* flush */
7262 
7263 		psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
7264 		status = mbx->mbxStatus;
7265 	}
7266 
7267 	spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
7268 	return status;
7269 
7270 out_not_finished:
7271 	if (processing_queue) {
7272 		pmbox->u.mb.mbxStatus = MBX_NOT_FINISHED;
7273 		lpfc_mbox_cmpl_put(phba, pmbox);
7274 	}
7275 	return MBX_NOT_FINISHED;
7276 }
7277 
7278 /**
7279  * lpfc_sli4_async_mbox_block - Block posting SLI4 asynchronous mailbox command
7280  * @phba: Pointer to HBA context object.
7281  *
7282  * The function blocks the posting of SLI4 asynchronous mailbox commands from
7283  * the driver internal pending mailbox queue. It will then try to wait out the
7284  * possible outstanding mailbox command before return.
7285  *
7286  * Returns:
7287  * 	0 - the outstanding mailbox command completed; otherwise, the wait for
7288  * 	the outstanding mailbox command timed out.
7289  **/
7290 static int
7291 lpfc_sli4_async_mbox_block(struct lpfc_hba *phba)
7292 {
7293 	struct lpfc_sli *psli = &phba->sli;
7294 	int rc = 0;
7295 	unsigned long timeout = 0;
7296 
7297 	/* Mark the asynchronous mailbox command posting as blocked */
7298 	spin_lock_irq(&phba->hbalock);
7299 	psli->sli_flag |= LPFC_SLI_ASYNC_MBX_BLK;
7300 	/* Determine how long we might wait for the active mailbox
7301 	 * command to be gracefully completed by firmware.
7302 	 */
7303 	if (phba->sli.mbox_active)
7304 		timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba,
7305 						phba->sli.mbox_active) *
7306 						1000) + jiffies;
7307 	spin_unlock_irq(&phba->hbalock);
7308 
7309 	/* Make sure the mailbox is really active */
7310 	if (timeout)
7311 		lpfc_sli4_process_missed_mbox_completions(phba);
7312 
7313 	/* Wait for the outstnading mailbox command to complete */
7314 	while (phba->sli.mbox_active) {
7315 		/* Check active mailbox complete status every 2ms */
7316 		msleep(2);
7317 		if (time_after(jiffies, timeout)) {
7318 			/* Timeout, marked the outstanding cmd not complete */
7319 			rc = 1;
7320 			break;
7321 		}
7322 	}
7323 
7324 	/* Can not cleanly block async mailbox command, fails it */
7325 	if (rc) {
7326 		spin_lock_irq(&phba->hbalock);
7327 		psli->sli_flag &= ~LPFC_SLI_ASYNC_MBX_BLK;
7328 		spin_unlock_irq(&phba->hbalock);
7329 	}
7330 	return rc;
7331 }
7332 
7333 /**
7334  * lpfc_sli4_async_mbox_unblock - Block posting SLI4 async mailbox command
7335  * @phba: Pointer to HBA context object.
7336  *
7337  * The function unblocks and resume posting of SLI4 asynchronous mailbox
7338  * commands from the driver internal pending mailbox queue. It makes sure
7339  * that there is no outstanding mailbox command before resuming posting
7340  * asynchronous mailbox commands. If, for any reason, there is outstanding
7341  * mailbox command, it will try to wait it out before resuming asynchronous
7342  * mailbox command posting.
7343  **/
7344 static void
7345 lpfc_sli4_async_mbox_unblock(struct lpfc_hba *phba)
7346 {
7347 	struct lpfc_sli *psli = &phba->sli;
7348 
7349 	spin_lock_irq(&phba->hbalock);
7350 	if (!(psli->sli_flag & LPFC_SLI_ASYNC_MBX_BLK)) {
7351 		/* Asynchronous mailbox posting is not blocked, do nothing */
7352 		spin_unlock_irq(&phba->hbalock);
7353 		return;
7354 	}
7355 
7356 	/* Outstanding synchronous mailbox command is guaranteed to be done,
7357 	 * successful or timeout, after timing-out the outstanding mailbox
7358 	 * command shall always be removed, so just unblock posting async
7359 	 * mailbox command and resume
7360 	 */
7361 	psli->sli_flag &= ~LPFC_SLI_ASYNC_MBX_BLK;
7362 	spin_unlock_irq(&phba->hbalock);
7363 
7364 	/* wake up worker thread to post asynchronlous mailbox command */
7365 	lpfc_worker_wake_up(phba);
7366 }
7367 
7368 /**
7369  * lpfc_sli4_wait_bmbx_ready - Wait for bootstrap mailbox register ready
7370  * @phba: Pointer to HBA context object.
7371  * @mboxq: Pointer to mailbox object.
7372  *
7373  * The function waits for the bootstrap mailbox register ready bit from
7374  * port for twice the regular mailbox command timeout value.
7375  *
7376  *      0 - no timeout on waiting for bootstrap mailbox register ready.
7377  *      MBXERR_ERROR - wait for bootstrap mailbox register timed out.
7378  **/
7379 static int
7380 lpfc_sli4_wait_bmbx_ready(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
7381 {
7382 	uint32_t db_ready;
7383 	unsigned long timeout;
7384 	struct lpfc_register bmbx_reg;
7385 
7386 	timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba, mboxq)
7387 				   * 1000) + jiffies;
7388 
7389 	do {
7390 		bmbx_reg.word0 = readl(phba->sli4_hba.BMBXregaddr);
7391 		db_ready = bf_get(lpfc_bmbx_rdy, &bmbx_reg);
7392 		if (!db_ready)
7393 			msleep(2);
7394 
7395 		if (time_after(jiffies, timeout))
7396 			return MBXERR_ERROR;
7397 	} while (!db_ready);
7398 
7399 	return 0;
7400 }
7401 
7402 /**
7403  * lpfc_sli4_post_sync_mbox - Post an SLI4 mailbox to the bootstrap mailbox
7404  * @phba: Pointer to HBA context object.
7405  * @mboxq: Pointer to mailbox object.
7406  *
7407  * The function posts a mailbox to the port.  The mailbox is expected
7408  * to be comletely filled in and ready for the port to operate on it.
7409  * This routine executes a synchronous completion operation on the
7410  * mailbox by polling for its completion.
7411  *
7412  * The caller must not be holding any locks when calling this routine.
7413  *
7414  * Returns:
7415  *	MBX_SUCCESS - mailbox posted successfully
7416  *	Any of the MBX error values.
7417  **/
7418 static int
7419 lpfc_sli4_post_sync_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
7420 {
7421 	int rc = MBX_SUCCESS;
7422 	unsigned long iflag;
7423 	uint32_t mcqe_status;
7424 	uint32_t mbx_cmnd;
7425 	struct lpfc_sli *psli = &phba->sli;
7426 	struct lpfc_mqe *mb = &mboxq->u.mqe;
7427 	struct lpfc_bmbx_create *mbox_rgn;
7428 	struct dma_address *dma_address;
7429 
7430 	/*
7431 	 * Only one mailbox can be active to the bootstrap mailbox region
7432 	 * at a time and there is no queueing provided.
7433 	 */
7434 	spin_lock_irqsave(&phba->hbalock, iflag);
7435 	if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {
7436 		spin_unlock_irqrestore(&phba->hbalock, iflag);
7437 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
7438 				"(%d):2532 Mailbox command x%x (x%x/x%x) "
7439 				"cannot issue Data: x%x x%x\n",
7440 				mboxq->vport ? mboxq->vport->vpi : 0,
7441 				mboxq->u.mb.mbxCommand,
7442 				lpfc_sli_config_mbox_subsys_get(phba, mboxq),
7443 				lpfc_sli_config_mbox_opcode_get(phba, mboxq),
7444 				psli->sli_flag, MBX_POLL);
7445 		return MBXERR_ERROR;
7446 	}
7447 	/* The server grabs the token and owns it until release */
7448 	psli->sli_flag |= LPFC_SLI_MBOX_ACTIVE;
7449 	phba->sli.mbox_active = mboxq;
7450 	spin_unlock_irqrestore(&phba->hbalock, iflag);
7451 
7452 	/* wait for bootstrap mbox register for readyness */
7453 	rc = lpfc_sli4_wait_bmbx_ready(phba, mboxq);
7454 	if (rc)
7455 		goto exit;
7456 
7457 	/*
7458 	 * Initialize the bootstrap memory region to avoid stale data areas
7459 	 * in the mailbox post.  Then copy the caller's mailbox contents to
7460 	 * the bmbx mailbox region.
7461 	 */
7462 	mbx_cmnd = bf_get(lpfc_mqe_command, mb);
7463 	memset(phba->sli4_hba.bmbx.avirt, 0, sizeof(struct lpfc_bmbx_create));
7464 	lpfc_sli_pcimem_bcopy(mb, phba->sli4_hba.bmbx.avirt,
7465 			      sizeof(struct lpfc_mqe));
7466 
7467 	/* Post the high mailbox dma address to the port and wait for ready. */
7468 	dma_address = &phba->sli4_hba.bmbx.dma_address;
7469 	writel(dma_address->addr_hi, phba->sli4_hba.BMBXregaddr);
7470 
7471 	/* wait for bootstrap mbox register for hi-address write done */
7472 	rc = lpfc_sli4_wait_bmbx_ready(phba, mboxq);
7473 	if (rc)
7474 		goto exit;
7475 
7476 	/* Post the low mailbox dma address to the port. */
7477 	writel(dma_address->addr_lo, phba->sli4_hba.BMBXregaddr);
7478 
7479 	/* wait for bootstrap mbox register for low address write done */
7480 	rc = lpfc_sli4_wait_bmbx_ready(phba, mboxq);
7481 	if (rc)
7482 		goto exit;
7483 
7484 	/*
7485 	 * Read the CQ to ensure the mailbox has completed.
7486 	 * If so, update the mailbox status so that the upper layers
7487 	 * can complete the request normally.
7488 	 */
7489 	lpfc_sli_pcimem_bcopy(phba->sli4_hba.bmbx.avirt, mb,
7490 			      sizeof(struct lpfc_mqe));
7491 	mbox_rgn = (struct lpfc_bmbx_create *) phba->sli4_hba.bmbx.avirt;
7492 	lpfc_sli_pcimem_bcopy(&mbox_rgn->mcqe, &mboxq->mcqe,
7493 			      sizeof(struct lpfc_mcqe));
7494 	mcqe_status = bf_get(lpfc_mcqe_status, &mbox_rgn->mcqe);
7495 	/*
7496 	 * When the CQE status indicates a failure and the mailbox status
7497 	 * indicates success then copy the CQE status into the mailbox status
7498 	 * (and prefix it with x4000).
7499 	 */
7500 	if (mcqe_status != MB_CQE_STATUS_SUCCESS) {
7501 		if (bf_get(lpfc_mqe_status, mb) == MBX_SUCCESS)
7502 			bf_set(lpfc_mqe_status, mb,
7503 			       (LPFC_MBX_ERROR_RANGE | mcqe_status));
7504 		rc = MBXERR_ERROR;
7505 	} else
7506 		lpfc_sli4_swap_str(phba, mboxq);
7507 
7508 	lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
7509 			"(%d):0356 Mailbox cmd x%x (x%x/x%x) Status x%x "
7510 			"Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x x%x x%x"
7511 			" x%x x%x CQ: x%x x%x x%x x%x\n",
7512 			mboxq->vport ? mboxq->vport->vpi : 0, mbx_cmnd,
7513 			lpfc_sli_config_mbox_subsys_get(phba, mboxq),
7514 			lpfc_sli_config_mbox_opcode_get(phba, mboxq),
7515 			bf_get(lpfc_mqe_status, mb),
7516 			mb->un.mb_words[0], mb->un.mb_words[1],
7517 			mb->un.mb_words[2], mb->un.mb_words[3],
7518 			mb->un.mb_words[4], mb->un.mb_words[5],
7519 			mb->un.mb_words[6], mb->un.mb_words[7],
7520 			mb->un.mb_words[8], mb->un.mb_words[9],
7521 			mb->un.mb_words[10], mb->un.mb_words[11],
7522 			mb->un.mb_words[12], mboxq->mcqe.word0,
7523 			mboxq->mcqe.mcqe_tag0, 	mboxq->mcqe.mcqe_tag1,
7524 			mboxq->mcqe.trailer);
7525 exit:
7526 	/* We are holding the token, no needed for lock when release */
7527 	spin_lock_irqsave(&phba->hbalock, iflag);
7528 	psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
7529 	phba->sli.mbox_active = NULL;
7530 	spin_unlock_irqrestore(&phba->hbalock, iflag);
7531 	return rc;
7532 }
7533 
7534 /**
7535  * lpfc_sli_issue_mbox_s4 - Issue an SLI4 mailbox command to firmware
7536  * @phba: Pointer to HBA context object.
7537  * @pmbox: Pointer to mailbox object.
7538  * @flag: Flag indicating how the mailbox need to be processed.
7539  *
7540  * This function is called by discovery code and HBA management code to submit
7541  * a mailbox command to firmware with SLI-4 interface spec.
7542  *
7543  * Return codes the caller owns the mailbox command after the return of the
7544  * function.
7545  **/
7546 static int
7547 lpfc_sli_issue_mbox_s4(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,
7548 		       uint32_t flag)
7549 {
7550 	struct lpfc_sli *psli = &phba->sli;
7551 	unsigned long iflags;
7552 	int rc;
7553 
7554 	/* dump from issue mailbox command if setup */
7555 	lpfc_idiag_mbxacc_dump_issue_mbox(phba, &mboxq->u.mb);
7556 
7557 	rc = lpfc_mbox_dev_check(phba);
7558 	if (unlikely(rc)) {
7559 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
7560 				"(%d):2544 Mailbox command x%x (x%x/x%x) "
7561 				"cannot issue Data: x%x x%x\n",
7562 				mboxq->vport ? mboxq->vport->vpi : 0,
7563 				mboxq->u.mb.mbxCommand,
7564 				lpfc_sli_config_mbox_subsys_get(phba, mboxq),
7565 				lpfc_sli_config_mbox_opcode_get(phba, mboxq),
7566 				psli->sli_flag, flag);
7567 		goto out_not_finished;
7568 	}
7569 
7570 	/* Detect polling mode and jump to a handler */
7571 	if (!phba->sli4_hba.intr_enable) {
7572 		if (flag == MBX_POLL)
7573 			rc = lpfc_sli4_post_sync_mbox(phba, mboxq);
7574 		else
7575 			rc = -EIO;
7576 		if (rc != MBX_SUCCESS)
7577 			lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_SLI,
7578 					"(%d):2541 Mailbox command x%x "
7579 					"(x%x/x%x) failure: "
7580 					"mqe_sta: x%x mcqe_sta: x%x/x%x "
7581 					"Data: x%x x%x\n,",
7582 					mboxq->vport ? mboxq->vport->vpi : 0,
7583 					mboxq->u.mb.mbxCommand,
7584 					lpfc_sli_config_mbox_subsys_get(phba,
7585 									mboxq),
7586 					lpfc_sli_config_mbox_opcode_get(phba,
7587 									mboxq),
7588 					bf_get(lpfc_mqe_status, &mboxq->u.mqe),
7589 					bf_get(lpfc_mcqe_status, &mboxq->mcqe),
7590 					bf_get(lpfc_mcqe_ext_status,
7591 					       &mboxq->mcqe),
7592 					psli->sli_flag, flag);
7593 		return rc;
7594 	} else if (flag == MBX_POLL) {
7595 		lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_SLI,
7596 				"(%d):2542 Try to issue mailbox command "
7597 				"x%x (x%x/x%x) synchronously ahead of async"
7598 				"mailbox command queue: x%x x%x\n",
7599 				mboxq->vport ? mboxq->vport->vpi : 0,
7600 				mboxq->u.mb.mbxCommand,
7601 				lpfc_sli_config_mbox_subsys_get(phba, mboxq),
7602 				lpfc_sli_config_mbox_opcode_get(phba, mboxq),
7603 				psli->sli_flag, flag);
7604 		/* Try to block the asynchronous mailbox posting */
7605 		rc = lpfc_sli4_async_mbox_block(phba);
7606 		if (!rc) {
7607 			/* Successfully blocked, now issue sync mbox cmd */
7608 			rc = lpfc_sli4_post_sync_mbox(phba, mboxq);
7609 			if (rc != MBX_SUCCESS)
7610 				lpfc_printf_log(phba, KERN_WARNING,
7611 					LOG_MBOX | LOG_SLI,
7612 					"(%d):2597 Sync Mailbox command "
7613 					"x%x (x%x/x%x) failure: "
7614 					"mqe_sta: x%x mcqe_sta: x%x/x%x "
7615 					"Data: x%x x%x\n,",
7616 					mboxq->vport ? mboxq->vport->vpi : 0,
7617 					mboxq->u.mb.mbxCommand,
7618 					lpfc_sli_config_mbox_subsys_get(phba,
7619 									mboxq),
7620 					lpfc_sli_config_mbox_opcode_get(phba,
7621 									mboxq),
7622 					bf_get(lpfc_mqe_status, &mboxq->u.mqe),
7623 					bf_get(lpfc_mcqe_status, &mboxq->mcqe),
7624 					bf_get(lpfc_mcqe_ext_status,
7625 					       &mboxq->mcqe),
7626 					psli->sli_flag, flag);
7627 			/* Unblock the async mailbox posting afterward */
7628 			lpfc_sli4_async_mbox_unblock(phba);
7629 		}
7630 		return rc;
7631 	}
7632 
7633 	/* Now, interrupt mode asynchrous mailbox command */
7634 	rc = lpfc_mbox_cmd_check(phba, mboxq);
7635 	if (rc) {
7636 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
7637 				"(%d):2543 Mailbox command x%x (x%x/x%x) "
7638 				"cannot issue Data: x%x x%x\n",
7639 				mboxq->vport ? mboxq->vport->vpi : 0,
7640 				mboxq->u.mb.mbxCommand,
7641 				lpfc_sli_config_mbox_subsys_get(phba, mboxq),
7642 				lpfc_sli_config_mbox_opcode_get(phba, mboxq),
7643 				psli->sli_flag, flag);
7644 		goto out_not_finished;
7645 	}
7646 
7647 	/* Put the mailbox command to the driver internal FIFO */
7648 	psli->slistat.mbox_busy++;
7649 	spin_lock_irqsave(&phba->hbalock, iflags);
7650 	lpfc_mbox_put(phba, mboxq);
7651 	spin_unlock_irqrestore(&phba->hbalock, iflags);
7652 	lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
7653 			"(%d):0354 Mbox cmd issue - Enqueue Data: "
7654 			"x%x (x%x/x%x) x%x x%x x%x\n",
7655 			mboxq->vport ? mboxq->vport->vpi : 0xffffff,
7656 			bf_get(lpfc_mqe_command, &mboxq->u.mqe),
7657 			lpfc_sli_config_mbox_subsys_get(phba, mboxq),
7658 			lpfc_sli_config_mbox_opcode_get(phba, mboxq),
7659 			phba->pport->port_state,
7660 			psli->sli_flag, MBX_NOWAIT);
7661 	/* Wake up worker thread to transport mailbox command from head */
7662 	lpfc_worker_wake_up(phba);
7663 
7664 	return MBX_BUSY;
7665 
7666 out_not_finished:
7667 	return MBX_NOT_FINISHED;
7668 }
7669 
7670 /**
7671  * lpfc_sli4_post_async_mbox - Post an SLI4 mailbox command to device
7672  * @phba: Pointer to HBA context object.
7673  *
7674  * This function is called by worker thread to send a mailbox command to
7675  * SLI4 HBA firmware.
7676  *
7677  **/
7678 int
7679 lpfc_sli4_post_async_mbox(struct lpfc_hba *phba)
7680 {
7681 	struct lpfc_sli *psli = &phba->sli;
7682 	LPFC_MBOXQ_t *mboxq;
7683 	int rc = MBX_SUCCESS;
7684 	unsigned long iflags;
7685 	struct lpfc_mqe *mqe;
7686 	uint32_t mbx_cmnd;
7687 
7688 	/* Check interrupt mode before post async mailbox command */
7689 	if (unlikely(!phba->sli4_hba.intr_enable))
7690 		return MBX_NOT_FINISHED;
7691 
7692 	/* Check for mailbox command service token */
7693 	spin_lock_irqsave(&phba->hbalock, iflags);
7694 	if (unlikely(psli->sli_flag & LPFC_SLI_ASYNC_MBX_BLK)) {
7695 		spin_unlock_irqrestore(&phba->hbalock, iflags);
7696 		return MBX_NOT_FINISHED;
7697 	}
7698 	if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {
7699 		spin_unlock_irqrestore(&phba->hbalock, iflags);
7700 		return MBX_NOT_FINISHED;
7701 	}
7702 	if (unlikely(phba->sli.mbox_active)) {
7703 		spin_unlock_irqrestore(&phba->hbalock, iflags);
7704 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
7705 				"0384 There is pending active mailbox cmd\n");
7706 		return MBX_NOT_FINISHED;
7707 	}
7708 	/* Take the mailbox command service token */
7709 	psli->sli_flag |= LPFC_SLI_MBOX_ACTIVE;
7710 
7711 	/* Get the next mailbox command from head of queue */
7712 	mboxq = lpfc_mbox_get(phba);
7713 
7714 	/* If no more mailbox command waiting for post, we're done */
7715 	if (!mboxq) {
7716 		psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
7717 		spin_unlock_irqrestore(&phba->hbalock, iflags);
7718 		return MBX_SUCCESS;
7719 	}
7720 	phba->sli.mbox_active = mboxq;
7721 	spin_unlock_irqrestore(&phba->hbalock, iflags);
7722 
7723 	/* Check device readiness for posting mailbox command */
7724 	rc = lpfc_mbox_dev_check(phba);
7725 	if (unlikely(rc))
7726 		/* Driver clean routine will clean up pending mailbox */
7727 		goto out_not_finished;
7728 
7729 	/* Prepare the mbox command to be posted */
7730 	mqe = &mboxq->u.mqe;
7731 	mbx_cmnd = bf_get(lpfc_mqe_command, mqe);
7732 
7733 	/* Start timer for the mbox_tmo and log some mailbox post messages */
7734 	mod_timer(&psli->mbox_tmo, (jiffies +
7735 		  msecs_to_jiffies(1000 * lpfc_mbox_tmo_val(phba, mboxq))));
7736 
7737 	lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
7738 			"(%d):0355 Mailbox cmd x%x (x%x/x%x) issue Data: "
7739 			"x%x x%x\n",
7740 			mboxq->vport ? mboxq->vport->vpi : 0, mbx_cmnd,
7741 			lpfc_sli_config_mbox_subsys_get(phba, mboxq),
7742 			lpfc_sli_config_mbox_opcode_get(phba, mboxq),
7743 			phba->pport->port_state, psli->sli_flag);
7744 
7745 	if (mbx_cmnd != MBX_HEARTBEAT) {
7746 		if (mboxq->vport) {
7747 			lpfc_debugfs_disc_trc(mboxq->vport,
7748 				LPFC_DISC_TRC_MBOX_VPORT,
7749 				"MBOX Send vport: cmd:x%x mb:x%x x%x",
7750 				mbx_cmnd, mqe->un.mb_words[0],
7751 				mqe->un.mb_words[1]);
7752 		} else {
7753 			lpfc_debugfs_disc_trc(phba->pport,
7754 				LPFC_DISC_TRC_MBOX,
7755 				"MBOX Send: cmd:x%x mb:x%x x%x",
7756 				mbx_cmnd, mqe->un.mb_words[0],
7757 				mqe->un.mb_words[1]);
7758 		}
7759 	}
7760 	psli->slistat.mbox_cmd++;
7761 
7762 	/* Post the mailbox command to the port */
7763 	rc = lpfc_sli4_mq_put(phba->sli4_hba.mbx_wq, mqe);
7764 	if (rc != MBX_SUCCESS) {
7765 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
7766 				"(%d):2533 Mailbox command x%x (x%x/x%x) "
7767 				"cannot issue Data: x%x x%x\n",
7768 				mboxq->vport ? mboxq->vport->vpi : 0,
7769 				mboxq->u.mb.mbxCommand,
7770 				lpfc_sli_config_mbox_subsys_get(phba, mboxq),
7771 				lpfc_sli_config_mbox_opcode_get(phba, mboxq),
7772 				psli->sli_flag, MBX_NOWAIT);
7773 		goto out_not_finished;
7774 	}
7775 
7776 	return rc;
7777 
7778 out_not_finished:
7779 	spin_lock_irqsave(&phba->hbalock, iflags);
7780 	if (phba->sli.mbox_active) {
7781 		mboxq->u.mb.mbxStatus = MBX_NOT_FINISHED;
7782 		__lpfc_mbox_cmpl_put(phba, mboxq);
7783 		/* Release the token */
7784 		psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
7785 		phba->sli.mbox_active = NULL;
7786 	}
7787 	spin_unlock_irqrestore(&phba->hbalock, iflags);
7788 
7789 	return MBX_NOT_FINISHED;
7790 }
7791 
7792 /**
7793  * lpfc_sli_issue_mbox - Wrapper func for issuing mailbox command
7794  * @phba: Pointer to HBA context object.
7795  * @pmbox: Pointer to mailbox object.
7796  * @flag: Flag indicating how the mailbox need to be processed.
7797  *
7798  * This routine wraps the actual SLI3 or SLI4 mailbox issuing routine from
7799  * the API jump table function pointer from the lpfc_hba struct.
7800  *
7801  * Return codes the caller owns the mailbox command after the return of the
7802  * function.
7803  **/
7804 int
7805 lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
7806 {
7807 	return phba->lpfc_sli_issue_mbox(phba, pmbox, flag);
7808 }
7809 
7810 /**
7811  * lpfc_mbox_api_table_setup - Set up mbox api function jump table
7812  * @phba: The hba struct for which this call is being executed.
7813  * @dev_grp: The HBA PCI-Device group number.
7814  *
7815  * This routine sets up the mbox interface API function jump table in @phba
7816  * struct.
7817  * Returns: 0 - success, -ENODEV - failure.
7818  **/
7819 int
7820 lpfc_mbox_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
7821 {
7822 
7823 	switch (dev_grp) {
7824 	case LPFC_PCI_DEV_LP:
7825 		phba->lpfc_sli_issue_mbox = lpfc_sli_issue_mbox_s3;
7826 		phba->lpfc_sli_handle_slow_ring_event =
7827 				lpfc_sli_handle_slow_ring_event_s3;
7828 		phba->lpfc_sli_hbq_to_firmware = lpfc_sli_hbq_to_firmware_s3;
7829 		phba->lpfc_sli_brdrestart = lpfc_sli_brdrestart_s3;
7830 		phba->lpfc_sli_brdready = lpfc_sli_brdready_s3;
7831 		break;
7832 	case LPFC_PCI_DEV_OC:
7833 		phba->lpfc_sli_issue_mbox = lpfc_sli_issue_mbox_s4;
7834 		phba->lpfc_sli_handle_slow_ring_event =
7835 				lpfc_sli_handle_slow_ring_event_s4;
7836 		phba->lpfc_sli_hbq_to_firmware = lpfc_sli_hbq_to_firmware_s4;
7837 		phba->lpfc_sli_brdrestart = lpfc_sli_brdrestart_s4;
7838 		phba->lpfc_sli_brdready = lpfc_sli_brdready_s4;
7839 		break;
7840 	default:
7841 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7842 				"1420 Invalid HBA PCI-device group: 0x%x\n",
7843 				dev_grp);
7844 		return -ENODEV;
7845 		break;
7846 	}
7847 	return 0;
7848 }
7849 
7850 /**
7851  * __lpfc_sli_ringtx_put - Add an iocb to the txq
7852  * @phba: Pointer to HBA context object.
7853  * @pring: Pointer to driver SLI ring object.
7854  * @piocb: Pointer to address of newly added command iocb.
7855  *
7856  * This function is called with hbalock held to add a command
7857  * iocb to the txq when SLI layer cannot submit the command iocb
7858  * to the ring.
7859  **/
7860 void
7861 __lpfc_sli_ringtx_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
7862 		    struct lpfc_iocbq *piocb)
7863 {
7864 	/* Insert the caller's iocb in the txq tail for later processing. */
7865 	list_add_tail(&piocb->list, &pring->txq);
7866 }
7867 
7868 /**
7869  * lpfc_sli_next_iocb - Get the next iocb in the txq
7870  * @phba: Pointer to HBA context object.
7871  * @pring: Pointer to driver SLI ring object.
7872  * @piocb: Pointer to address of newly added command iocb.
7873  *
7874  * This function is called with hbalock held before a new
7875  * iocb is submitted to the firmware. This function checks
7876  * txq to flush the iocbs in txq to Firmware before
7877  * submitting new iocbs to the Firmware.
7878  * If there are iocbs in the txq which need to be submitted
7879  * to firmware, lpfc_sli_next_iocb returns the first element
7880  * of the txq after dequeuing it from txq.
7881  * If there is no iocb in the txq then the function will return
7882  * *piocb and *piocb is set to NULL. Caller needs to check
7883  * *piocb to find if there are more commands in the txq.
7884  **/
7885 static struct lpfc_iocbq *
7886 lpfc_sli_next_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
7887 		   struct lpfc_iocbq **piocb)
7888 {
7889 	struct lpfc_iocbq * nextiocb;
7890 
7891 	nextiocb = lpfc_sli_ringtx_get(phba, pring);
7892 	if (!nextiocb) {
7893 		nextiocb = *piocb;
7894 		*piocb = NULL;
7895 	}
7896 
7897 	return nextiocb;
7898 }
7899 
7900 /**
7901  * __lpfc_sli_issue_iocb_s3 - SLI3 device lockless ver of lpfc_sli_issue_iocb
7902  * @phba: Pointer to HBA context object.
7903  * @ring_number: SLI ring number to issue iocb on.
7904  * @piocb: Pointer to command iocb.
7905  * @flag: Flag indicating if this command can be put into txq.
7906  *
7907  * __lpfc_sli_issue_iocb_s3 is used by other functions in the driver to issue
7908  * an iocb command to an HBA with SLI-3 interface spec. If the PCI slot is
7909  * recovering from error state, if HBA is resetting or if LPFC_STOP_IOCB_EVENT
7910  * flag is turned on, the function returns IOCB_ERROR. When the link is down,
7911  * this function allows only iocbs for posting buffers. This function finds
7912  * next available slot in the command ring and posts the command to the
7913  * available slot and writes the port attention register to request HBA start
7914  * processing new iocb. If there is no slot available in the ring and
7915  * flag & SLI_IOCB_RET_IOCB is set, the new iocb is added to the txq, otherwise
7916  * the function returns IOCB_BUSY.
7917  *
7918  * This function is called with hbalock held. The function will return success
7919  * after it successfully submit the iocb to firmware or after adding to the
7920  * txq.
7921  **/
7922 static int
7923 __lpfc_sli_issue_iocb_s3(struct lpfc_hba *phba, uint32_t ring_number,
7924 		    struct lpfc_iocbq *piocb, uint32_t flag)
7925 {
7926 	struct lpfc_iocbq *nextiocb;
7927 	IOCB_t *iocb;
7928 	struct lpfc_sli_ring *pring = &phba->sli.ring[ring_number];
7929 
7930 	if (piocb->iocb_cmpl && (!piocb->vport) &&
7931 	   (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
7932 	   (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN)) {
7933 		lpfc_printf_log(phba, KERN_ERR,
7934 				LOG_SLI | LOG_VPORT,
7935 				"1807 IOCB x%x failed. No vport\n",
7936 				piocb->iocb.ulpCommand);
7937 		dump_stack();
7938 		return IOCB_ERROR;
7939 	}
7940 
7941 
7942 	/* If the PCI channel is in offline state, do not post iocbs. */
7943 	if (unlikely(pci_channel_offline(phba->pcidev)))
7944 		return IOCB_ERROR;
7945 
7946 	/* If HBA has a deferred error attention, fail the iocb. */
7947 	if (unlikely(phba->hba_flag & DEFER_ERATT))
7948 		return IOCB_ERROR;
7949 
7950 	/*
7951 	 * We should never get an IOCB if we are in a < LINK_DOWN state
7952 	 */
7953 	if (unlikely(phba->link_state < LPFC_LINK_DOWN))
7954 		return IOCB_ERROR;
7955 
7956 	/*
7957 	 * Check to see if we are blocking IOCB processing because of a
7958 	 * outstanding event.
7959 	 */
7960 	if (unlikely(pring->flag & LPFC_STOP_IOCB_EVENT))
7961 		goto iocb_busy;
7962 
7963 	if (unlikely(phba->link_state == LPFC_LINK_DOWN)) {
7964 		/*
7965 		 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
7966 		 * can be issued if the link is not up.
7967 		 */
7968 		switch (piocb->iocb.ulpCommand) {
7969 		case CMD_GEN_REQUEST64_CR:
7970 		case CMD_GEN_REQUEST64_CX:
7971 			if (!(phba->sli.sli_flag & LPFC_MENLO_MAINT) ||
7972 				(piocb->iocb.un.genreq64.w5.hcsw.Rctl !=
7973 					FC_RCTL_DD_UNSOL_CMD) ||
7974 				(piocb->iocb.un.genreq64.w5.hcsw.Type !=
7975 					MENLO_TRANSPORT_TYPE))
7976 
7977 				goto iocb_busy;
7978 			break;
7979 		case CMD_QUE_RING_BUF_CN:
7980 		case CMD_QUE_RING_BUF64_CN:
7981 			/*
7982 			 * For IOCBs, like QUE_RING_BUF, that have no rsp ring
7983 			 * completion, iocb_cmpl MUST be 0.
7984 			 */
7985 			if (piocb->iocb_cmpl)
7986 				piocb->iocb_cmpl = NULL;
7987 			/*FALLTHROUGH*/
7988 		case CMD_CREATE_XRI_CR:
7989 		case CMD_CLOSE_XRI_CN:
7990 		case CMD_CLOSE_XRI_CX:
7991 			break;
7992 		default:
7993 			goto iocb_busy;
7994 		}
7995 
7996 	/*
7997 	 * For FCP commands, we must be in a state where we can process link
7998 	 * attention events.
7999 	 */
8000 	} else if (unlikely(pring->ringno == phba->sli.fcp_ring &&
8001 			    !(phba->sli.sli_flag & LPFC_PROCESS_LA))) {
8002 		goto iocb_busy;
8003 	}
8004 
8005 	while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
8006 	       (nextiocb = lpfc_sli_next_iocb(phba, pring, &piocb)))
8007 		lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
8008 
8009 	if (iocb)
8010 		lpfc_sli_update_ring(phba, pring);
8011 	else
8012 		lpfc_sli_update_full_ring(phba, pring);
8013 
8014 	if (!piocb)
8015 		return IOCB_SUCCESS;
8016 
8017 	goto out_busy;
8018 
8019  iocb_busy:
8020 	pring->stats.iocb_cmd_delay++;
8021 
8022  out_busy:
8023 
8024 	if (!(flag & SLI_IOCB_RET_IOCB)) {
8025 		__lpfc_sli_ringtx_put(phba, pring, piocb);
8026 		return IOCB_SUCCESS;
8027 	}
8028 
8029 	return IOCB_BUSY;
8030 }
8031 
8032 /**
8033  * lpfc_sli4_bpl2sgl - Convert the bpl/bde to a sgl.
8034  * @phba: Pointer to HBA context object.
8035  * @piocb: Pointer to command iocb.
8036  * @sglq: Pointer to the scatter gather queue object.
8037  *
8038  * This routine converts the bpl or bde that is in the IOCB
8039  * to a sgl list for the sli4 hardware. The physical address
8040  * of the bpl/bde is converted back to a virtual address.
8041  * If the IOCB contains a BPL then the list of BDE's is
8042  * converted to sli4_sge's. If the IOCB contains a single
8043  * BDE then it is converted to a single sli_sge.
8044  * The IOCB is still in cpu endianess so the contents of
8045  * the bpl can be used without byte swapping.
8046  *
8047  * Returns valid XRI = Success, NO_XRI = Failure.
8048 **/
8049 static uint16_t
8050 lpfc_sli4_bpl2sgl(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
8051 		struct lpfc_sglq *sglq)
8052 {
8053 	uint16_t xritag = NO_XRI;
8054 	struct ulp_bde64 *bpl = NULL;
8055 	struct ulp_bde64 bde;
8056 	struct sli4_sge *sgl  = NULL;
8057 	struct lpfc_dmabuf *dmabuf;
8058 	IOCB_t *icmd;
8059 	int numBdes = 0;
8060 	int i = 0;
8061 	uint32_t offset = 0; /* accumulated offset in the sg request list */
8062 	int inbound = 0; /* number of sg reply entries inbound from firmware */
8063 
8064 	if (!piocbq || !sglq)
8065 		return xritag;
8066 
8067 	sgl  = (struct sli4_sge *)sglq->sgl;
8068 	icmd = &piocbq->iocb;
8069 	if (icmd->ulpCommand == CMD_XMIT_BLS_RSP64_CX)
8070 		return sglq->sli4_xritag;
8071 	if (icmd->un.genreq64.bdl.bdeFlags == BUFF_TYPE_BLP_64) {
8072 		numBdes = icmd->un.genreq64.bdl.bdeSize /
8073 				sizeof(struct ulp_bde64);
8074 		/* The addrHigh and addrLow fields within the IOCB
8075 		 * have not been byteswapped yet so there is no
8076 		 * need to swap them back.
8077 		 */
8078 		if (piocbq->context3)
8079 			dmabuf = (struct lpfc_dmabuf *)piocbq->context3;
8080 		else
8081 			return xritag;
8082 
8083 		bpl  = (struct ulp_bde64 *)dmabuf->virt;
8084 		if (!bpl)
8085 			return xritag;
8086 
8087 		for (i = 0; i < numBdes; i++) {
8088 			/* Should already be byte swapped. */
8089 			sgl->addr_hi = bpl->addrHigh;
8090 			sgl->addr_lo = bpl->addrLow;
8091 
8092 			sgl->word2 = le32_to_cpu(sgl->word2);
8093 			if ((i+1) == numBdes)
8094 				bf_set(lpfc_sli4_sge_last, sgl, 1);
8095 			else
8096 				bf_set(lpfc_sli4_sge_last, sgl, 0);
8097 			/* swap the size field back to the cpu so we
8098 			 * can assign it to the sgl.
8099 			 */
8100 			bde.tus.w = le32_to_cpu(bpl->tus.w);
8101 			sgl->sge_len = cpu_to_le32(bde.tus.f.bdeSize);
8102 			/* The offsets in the sgl need to be accumulated
8103 			 * separately for the request and reply lists.
8104 			 * The request is always first, the reply follows.
8105 			 */
8106 			if (piocbq->iocb.ulpCommand == CMD_GEN_REQUEST64_CR) {
8107 				/* add up the reply sg entries */
8108 				if (bpl->tus.f.bdeFlags == BUFF_TYPE_BDE_64I)
8109 					inbound++;
8110 				/* first inbound? reset the offset */
8111 				if (inbound == 1)
8112 					offset = 0;
8113 				bf_set(lpfc_sli4_sge_offset, sgl, offset);
8114 				bf_set(lpfc_sli4_sge_type, sgl,
8115 					LPFC_SGE_TYPE_DATA);
8116 				offset += bde.tus.f.bdeSize;
8117 			}
8118 			sgl->word2 = cpu_to_le32(sgl->word2);
8119 			bpl++;
8120 			sgl++;
8121 		}
8122 	} else if (icmd->un.genreq64.bdl.bdeFlags == BUFF_TYPE_BDE_64) {
8123 			/* The addrHigh and addrLow fields of the BDE have not
8124 			 * been byteswapped yet so they need to be swapped
8125 			 * before putting them in the sgl.
8126 			 */
8127 			sgl->addr_hi =
8128 				cpu_to_le32(icmd->un.genreq64.bdl.addrHigh);
8129 			sgl->addr_lo =
8130 				cpu_to_le32(icmd->un.genreq64.bdl.addrLow);
8131 			sgl->word2 = le32_to_cpu(sgl->word2);
8132 			bf_set(lpfc_sli4_sge_last, sgl, 1);
8133 			sgl->word2 = cpu_to_le32(sgl->word2);
8134 			sgl->sge_len =
8135 				cpu_to_le32(icmd->un.genreq64.bdl.bdeSize);
8136 	}
8137 	return sglq->sli4_xritag;
8138 }
8139 
8140 /**
8141  * lpfc_sli4_scmd_to_wqidx_distr - scsi command to SLI4 WQ index distribution
8142  * @phba: Pointer to HBA context object.
8143  *
8144  * This routine performs a roundrobin SCSI command to SLI4 FCP WQ index
8145  * distribution.  This is called by __lpfc_sli_issue_iocb_s4() with the hbalock
8146  * held.
8147  *
8148  * Return: index into SLI4 fast-path FCP queue index.
8149  **/
8150 static inline int
8151 lpfc_sli4_scmd_to_wqidx_distr(struct lpfc_hba *phba)
8152 {
8153 	struct lpfc_vector_map_info *cpup;
8154 	int chann, cpu;
8155 
8156 	if (phba->cfg_fcp_io_sched == LPFC_FCP_SCHED_BY_CPU
8157 	    && phba->cfg_fcp_io_channel > 1) {
8158 		cpu = smp_processor_id();
8159 		if (cpu < phba->sli4_hba.num_present_cpu) {
8160 			cpup = phba->sli4_hba.cpu_map;
8161 			cpup += cpu;
8162 			return cpup->channel_id;
8163 		}
8164 	}
8165 	chann = atomic_add_return(1, &phba->fcp_qidx);
8166 	chann = (chann % phba->cfg_fcp_io_channel);
8167 	return chann;
8168 }
8169 
8170 /**
8171  * lpfc_sli_iocb2wqe - Convert the IOCB to a work queue entry.
8172  * @phba: Pointer to HBA context object.
8173  * @piocb: Pointer to command iocb.
8174  * @wqe: Pointer to the work queue entry.
8175  *
8176  * This routine converts the iocb command to its Work Queue Entry
8177  * equivalent. The wqe pointer should not have any fields set when
8178  * this routine is called because it will memcpy over them.
8179  * This routine does not set the CQ_ID or the WQEC bits in the
8180  * wqe.
8181  *
8182  * Returns: 0 = Success, IOCB_ERROR = Failure.
8183  **/
8184 static int
8185 lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
8186 		union lpfc_wqe *wqe)
8187 {
8188 	uint32_t xmit_len = 0, total_len = 0;
8189 	uint8_t ct = 0;
8190 	uint32_t fip;
8191 	uint32_t abort_tag;
8192 	uint8_t command_type = ELS_COMMAND_NON_FIP;
8193 	uint8_t cmnd;
8194 	uint16_t xritag;
8195 	uint16_t abrt_iotag;
8196 	struct lpfc_iocbq *abrtiocbq;
8197 	struct ulp_bde64 *bpl = NULL;
8198 	uint32_t els_id = LPFC_ELS_ID_DEFAULT;
8199 	int numBdes, i;
8200 	struct ulp_bde64 bde;
8201 	struct lpfc_nodelist *ndlp;
8202 	uint32_t *pcmd;
8203 	uint32_t if_type;
8204 
8205 	fip = phba->hba_flag & HBA_FIP_SUPPORT;
8206 	/* The fcp commands will set command type */
8207 	if (iocbq->iocb_flag &  LPFC_IO_FCP)
8208 		command_type = FCP_COMMAND;
8209 	else if (fip && (iocbq->iocb_flag & LPFC_FIP_ELS_ID_MASK))
8210 		command_type = ELS_COMMAND_FIP;
8211 	else
8212 		command_type = ELS_COMMAND_NON_FIP;
8213 
8214 	/* Some of the fields are in the right position already */
8215 	memcpy(wqe, &iocbq->iocb, sizeof(union lpfc_wqe));
8216 	abort_tag = (uint32_t) iocbq->iotag;
8217 	xritag = iocbq->sli4_xritag;
8218 	wqe->generic.wqe_com.word7 = 0; /* The ct field has moved so reset */
8219 	wqe->generic.wqe_com.word10 = 0;
8220 	/* words0-2 bpl convert bde */
8221 	if (iocbq->iocb.un.genreq64.bdl.bdeFlags == BUFF_TYPE_BLP_64) {
8222 		numBdes = iocbq->iocb.un.genreq64.bdl.bdeSize /
8223 				sizeof(struct ulp_bde64);
8224 		bpl  = (struct ulp_bde64 *)
8225 			((struct lpfc_dmabuf *)iocbq->context3)->virt;
8226 		if (!bpl)
8227 			return IOCB_ERROR;
8228 
8229 		/* Should already be byte swapped. */
8230 		wqe->generic.bde.addrHigh =  le32_to_cpu(bpl->addrHigh);
8231 		wqe->generic.bde.addrLow =  le32_to_cpu(bpl->addrLow);
8232 		/* swap the size field back to the cpu so we
8233 		 * can assign it to the sgl.
8234 		 */
8235 		wqe->generic.bde.tus.w  = le32_to_cpu(bpl->tus.w);
8236 		xmit_len = wqe->generic.bde.tus.f.bdeSize;
8237 		total_len = 0;
8238 		for (i = 0; i < numBdes; i++) {
8239 			bde.tus.w  = le32_to_cpu(bpl[i].tus.w);
8240 			total_len += bde.tus.f.bdeSize;
8241 		}
8242 	} else
8243 		xmit_len = iocbq->iocb.un.fcpi64.bdl.bdeSize;
8244 
8245 	iocbq->iocb.ulpIoTag = iocbq->iotag;
8246 	cmnd = iocbq->iocb.ulpCommand;
8247 
8248 	switch (iocbq->iocb.ulpCommand) {
8249 	case CMD_ELS_REQUEST64_CR:
8250 		if (iocbq->iocb_flag & LPFC_IO_LIBDFC)
8251 			ndlp = iocbq->context_un.ndlp;
8252 		else
8253 			ndlp = (struct lpfc_nodelist *)iocbq->context1;
8254 		if (!iocbq->iocb.ulpLe) {
8255 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
8256 				"2007 Only Limited Edition cmd Format"
8257 				" supported 0x%x\n",
8258 				iocbq->iocb.ulpCommand);
8259 			return IOCB_ERROR;
8260 		}
8261 
8262 		wqe->els_req.payload_len = xmit_len;
8263 		/* Els_reguest64 has a TMO */
8264 		bf_set(wqe_tmo, &wqe->els_req.wqe_com,
8265 			iocbq->iocb.ulpTimeout);
8266 		/* Need a VF for word 4 set the vf bit*/
8267 		bf_set(els_req64_vf, &wqe->els_req, 0);
8268 		/* And a VFID for word 12 */
8269 		bf_set(els_req64_vfid, &wqe->els_req, 0);
8270 		ct = ((iocbq->iocb.ulpCt_h << 1) | iocbq->iocb.ulpCt_l);
8271 		bf_set(wqe_ctxt_tag, &wqe->els_req.wqe_com,
8272 		       iocbq->iocb.ulpContext);
8273 		bf_set(wqe_ct, &wqe->els_req.wqe_com, ct);
8274 		bf_set(wqe_pu, &wqe->els_req.wqe_com, 0);
8275 		/* CCP CCPE PV PRI in word10 were set in the memcpy */
8276 		if (command_type == ELS_COMMAND_FIP)
8277 			els_id = ((iocbq->iocb_flag & LPFC_FIP_ELS_ID_MASK)
8278 					>> LPFC_FIP_ELS_ID_SHIFT);
8279 		pcmd = (uint32_t *) (((struct lpfc_dmabuf *)
8280 					iocbq->context2)->virt);
8281 		if_type = bf_get(lpfc_sli_intf_if_type,
8282 					&phba->sli4_hba.sli_intf);
8283 		if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
8284 			if (pcmd && (*pcmd == ELS_CMD_FLOGI ||
8285 				*pcmd == ELS_CMD_SCR ||
8286 				*pcmd == ELS_CMD_FDISC ||
8287 				*pcmd == ELS_CMD_LOGO ||
8288 				*pcmd == ELS_CMD_PLOGI)) {
8289 				bf_set(els_req64_sp, &wqe->els_req, 1);
8290 				bf_set(els_req64_sid, &wqe->els_req,
8291 					iocbq->vport->fc_myDID);
8292 				if ((*pcmd == ELS_CMD_FLOGI) &&
8293 					!(phba->fc_topology ==
8294 						LPFC_TOPOLOGY_LOOP))
8295 					bf_set(els_req64_sid, &wqe->els_req, 0);
8296 				bf_set(wqe_ct, &wqe->els_req.wqe_com, 1);
8297 				bf_set(wqe_ctxt_tag, &wqe->els_req.wqe_com,
8298 					phba->vpi_ids[iocbq->vport->vpi]);
8299 			} else if (pcmd && iocbq->context1) {
8300 				bf_set(wqe_ct, &wqe->els_req.wqe_com, 0);
8301 				bf_set(wqe_ctxt_tag, &wqe->els_req.wqe_com,
8302 					phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]);
8303 			}
8304 		}
8305 		bf_set(wqe_temp_rpi, &wqe->els_req.wqe_com,
8306 		       phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]);
8307 		bf_set(wqe_els_id, &wqe->els_req.wqe_com, els_id);
8308 		bf_set(wqe_dbde, &wqe->els_req.wqe_com, 1);
8309 		bf_set(wqe_iod, &wqe->els_req.wqe_com, LPFC_WQE_IOD_READ);
8310 		bf_set(wqe_qosd, &wqe->els_req.wqe_com, 1);
8311 		bf_set(wqe_lenloc, &wqe->els_req.wqe_com, LPFC_WQE_LENLOC_NONE);
8312 		bf_set(wqe_ebde_cnt, &wqe->els_req.wqe_com, 0);
8313 		wqe->els_req.max_response_payload_len = total_len - xmit_len;
8314 		break;
8315 	case CMD_XMIT_SEQUENCE64_CX:
8316 		bf_set(wqe_ctxt_tag, &wqe->xmit_sequence.wqe_com,
8317 		       iocbq->iocb.un.ulpWord[3]);
8318 		bf_set(wqe_rcvoxid, &wqe->xmit_sequence.wqe_com,
8319 		       iocbq->iocb.unsli3.rcvsli3.ox_id);
8320 		/* The entire sequence is transmitted for this IOCB */
8321 		xmit_len = total_len;
8322 		cmnd = CMD_XMIT_SEQUENCE64_CR;
8323 		if (phba->link_flag & LS_LOOPBACK_MODE)
8324 			bf_set(wqe_xo, &wqe->xmit_sequence.wge_ctl, 1);
8325 	case CMD_XMIT_SEQUENCE64_CR:
8326 		/* word3 iocb=io_tag32 wqe=reserved */
8327 		wqe->xmit_sequence.rsvd3 = 0;
8328 		/* word4 relative_offset memcpy */
8329 		/* word5 r_ctl/df_ctl memcpy */
8330 		bf_set(wqe_pu, &wqe->xmit_sequence.wqe_com, 0);
8331 		bf_set(wqe_dbde, &wqe->xmit_sequence.wqe_com, 1);
8332 		bf_set(wqe_iod, &wqe->xmit_sequence.wqe_com,
8333 		       LPFC_WQE_IOD_WRITE);
8334 		bf_set(wqe_lenloc, &wqe->xmit_sequence.wqe_com,
8335 		       LPFC_WQE_LENLOC_WORD12);
8336 		bf_set(wqe_ebde_cnt, &wqe->xmit_sequence.wqe_com, 0);
8337 		wqe->xmit_sequence.xmit_len = xmit_len;
8338 		command_type = OTHER_COMMAND;
8339 		break;
8340 	case CMD_XMIT_BCAST64_CN:
8341 		/* word3 iocb=iotag32 wqe=seq_payload_len */
8342 		wqe->xmit_bcast64.seq_payload_len = xmit_len;
8343 		/* word4 iocb=rsvd wqe=rsvd */
8344 		/* word5 iocb=rctl/type/df_ctl wqe=rctl/type/df_ctl memcpy */
8345 		/* word6 iocb=ctxt_tag/io_tag wqe=ctxt_tag/xri */
8346 		bf_set(wqe_ct, &wqe->xmit_bcast64.wqe_com,
8347 			((iocbq->iocb.ulpCt_h << 1) | iocbq->iocb.ulpCt_l));
8348 		bf_set(wqe_dbde, &wqe->xmit_bcast64.wqe_com, 1);
8349 		bf_set(wqe_iod, &wqe->xmit_bcast64.wqe_com, LPFC_WQE_IOD_WRITE);
8350 		bf_set(wqe_lenloc, &wqe->xmit_bcast64.wqe_com,
8351 		       LPFC_WQE_LENLOC_WORD3);
8352 		bf_set(wqe_ebde_cnt, &wqe->xmit_bcast64.wqe_com, 0);
8353 		break;
8354 	case CMD_FCP_IWRITE64_CR:
8355 		command_type = FCP_COMMAND_DATA_OUT;
8356 		/* word3 iocb=iotag wqe=payload_offset_len */
8357 		/* Add the FCP_CMD and FCP_RSP sizes to get the offset */
8358 		bf_set(payload_offset_len, &wqe->fcp_iwrite,
8359 		       xmit_len + sizeof(struct fcp_rsp));
8360 		bf_set(cmd_buff_len, &wqe->fcp_iwrite,
8361 		       0);
8362 		/* word4 iocb=parameter wqe=total_xfer_length memcpy */
8363 		/* word5 iocb=initial_xfer_len wqe=initial_xfer_len memcpy */
8364 		bf_set(wqe_erp, &wqe->fcp_iwrite.wqe_com,
8365 		       iocbq->iocb.ulpFCP2Rcvy);
8366 		bf_set(wqe_lnk, &wqe->fcp_iwrite.wqe_com, iocbq->iocb.ulpXS);
8367 		/* Always open the exchange */
8368 		bf_set(wqe_xc, &wqe->fcp_iwrite.wqe_com, 0);
8369 		bf_set(wqe_iod, &wqe->fcp_iwrite.wqe_com, LPFC_WQE_IOD_WRITE);
8370 		bf_set(wqe_lenloc, &wqe->fcp_iwrite.wqe_com,
8371 		       LPFC_WQE_LENLOC_WORD4);
8372 		bf_set(wqe_ebde_cnt, &wqe->fcp_iwrite.wqe_com, 0);
8373 		bf_set(wqe_pu, &wqe->fcp_iwrite.wqe_com, iocbq->iocb.ulpPU);
8374 		bf_set(wqe_dbde, &wqe->fcp_iwrite.wqe_com, 1);
8375 		if (iocbq->iocb_flag & LPFC_IO_OAS) {
8376 			bf_set(wqe_oas, &wqe->fcp_iwrite.wqe_com, 1);
8377 			if (phba->cfg_XLanePriority) {
8378 				bf_set(wqe_ccpe, &wqe->fcp_iwrite.wqe_com, 1);
8379 				bf_set(wqe_ccp, &wqe->fcp_iwrite.wqe_com,
8380 				       (phba->cfg_XLanePriority << 1));
8381 			}
8382 		}
8383 		break;
8384 	case CMD_FCP_IREAD64_CR:
8385 		/* word3 iocb=iotag wqe=payload_offset_len */
8386 		/* Add the FCP_CMD and FCP_RSP sizes to get the offset */
8387 		bf_set(payload_offset_len, &wqe->fcp_iread,
8388 		       xmit_len + sizeof(struct fcp_rsp));
8389 		bf_set(cmd_buff_len, &wqe->fcp_iread,
8390 		       0);
8391 		/* word4 iocb=parameter wqe=total_xfer_length memcpy */
8392 		/* word5 iocb=initial_xfer_len wqe=initial_xfer_len memcpy */
8393 		bf_set(wqe_erp, &wqe->fcp_iread.wqe_com,
8394 		       iocbq->iocb.ulpFCP2Rcvy);
8395 		bf_set(wqe_lnk, &wqe->fcp_iread.wqe_com, iocbq->iocb.ulpXS);
8396 		/* Always open the exchange */
8397 		bf_set(wqe_xc, &wqe->fcp_iread.wqe_com, 0);
8398 		bf_set(wqe_iod, &wqe->fcp_iread.wqe_com, LPFC_WQE_IOD_READ);
8399 		bf_set(wqe_lenloc, &wqe->fcp_iread.wqe_com,
8400 		       LPFC_WQE_LENLOC_WORD4);
8401 		bf_set(wqe_ebde_cnt, &wqe->fcp_iread.wqe_com, 0);
8402 		bf_set(wqe_pu, &wqe->fcp_iread.wqe_com, iocbq->iocb.ulpPU);
8403 		bf_set(wqe_dbde, &wqe->fcp_iread.wqe_com, 1);
8404 		if (iocbq->iocb_flag & LPFC_IO_OAS) {
8405 			bf_set(wqe_oas, &wqe->fcp_iread.wqe_com, 1);
8406 			if (phba->cfg_XLanePriority) {
8407 				bf_set(wqe_ccpe, &wqe->fcp_iread.wqe_com, 1);
8408 				bf_set(wqe_ccp, &wqe->fcp_iread.wqe_com,
8409 				       (phba->cfg_XLanePriority << 1));
8410 			}
8411 		}
8412 		break;
8413 	case CMD_FCP_ICMND64_CR:
8414 		/* word3 iocb=iotag wqe=payload_offset_len */
8415 		/* Add the FCP_CMD and FCP_RSP sizes to get the offset */
8416 		bf_set(payload_offset_len, &wqe->fcp_icmd,
8417 		       xmit_len + sizeof(struct fcp_rsp));
8418 		bf_set(cmd_buff_len, &wqe->fcp_icmd,
8419 		       0);
8420 		/* word3 iocb=IO_TAG wqe=reserved */
8421 		bf_set(wqe_pu, &wqe->fcp_icmd.wqe_com, 0);
8422 		/* Always open the exchange */
8423 		bf_set(wqe_xc, &wqe->fcp_icmd.wqe_com, 0);
8424 		bf_set(wqe_dbde, &wqe->fcp_icmd.wqe_com, 1);
8425 		bf_set(wqe_iod, &wqe->fcp_icmd.wqe_com, LPFC_WQE_IOD_WRITE);
8426 		bf_set(wqe_qosd, &wqe->fcp_icmd.wqe_com, 1);
8427 		bf_set(wqe_lenloc, &wqe->fcp_icmd.wqe_com,
8428 		       LPFC_WQE_LENLOC_NONE);
8429 		bf_set(wqe_ebde_cnt, &wqe->fcp_icmd.wqe_com, 0);
8430 		bf_set(wqe_erp, &wqe->fcp_icmd.wqe_com,
8431 		       iocbq->iocb.ulpFCP2Rcvy);
8432 		if (iocbq->iocb_flag & LPFC_IO_OAS) {
8433 			bf_set(wqe_oas, &wqe->fcp_icmd.wqe_com, 1);
8434 			if (phba->cfg_XLanePriority) {
8435 				bf_set(wqe_ccpe, &wqe->fcp_icmd.wqe_com, 1);
8436 				bf_set(wqe_ccp, &wqe->fcp_icmd.wqe_com,
8437 				       (phba->cfg_XLanePriority << 1));
8438 			}
8439 		}
8440 		break;
8441 	case CMD_GEN_REQUEST64_CR:
8442 		/* For this command calculate the xmit length of the
8443 		 * request bde.
8444 		 */
8445 		xmit_len = 0;
8446 		numBdes = iocbq->iocb.un.genreq64.bdl.bdeSize /
8447 			sizeof(struct ulp_bde64);
8448 		for (i = 0; i < numBdes; i++) {
8449 			bde.tus.w = le32_to_cpu(bpl[i].tus.w);
8450 			if (bde.tus.f.bdeFlags != BUFF_TYPE_BDE_64)
8451 				break;
8452 			xmit_len += bde.tus.f.bdeSize;
8453 		}
8454 		/* word3 iocb=IO_TAG wqe=request_payload_len */
8455 		wqe->gen_req.request_payload_len = xmit_len;
8456 		/* word4 iocb=parameter wqe=relative_offset memcpy */
8457 		/* word5 [rctl, type, df_ctl, la] copied in memcpy */
8458 		/* word6 context tag copied in memcpy */
8459 		if (iocbq->iocb.ulpCt_h  || iocbq->iocb.ulpCt_l) {
8460 			ct = ((iocbq->iocb.ulpCt_h << 1) | iocbq->iocb.ulpCt_l);
8461 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
8462 				"2015 Invalid CT %x command 0x%x\n",
8463 				ct, iocbq->iocb.ulpCommand);
8464 			return IOCB_ERROR;
8465 		}
8466 		bf_set(wqe_ct, &wqe->gen_req.wqe_com, 0);
8467 		bf_set(wqe_tmo, &wqe->gen_req.wqe_com, iocbq->iocb.ulpTimeout);
8468 		bf_set(wqe_pu, &wqe->gen_req.wqe_com, iocbq->iocb.ulpPU);
8469 		bf_set(wqe_dbde, &wqe->gen_req.wqe_com, 1);
8470 		bf_set(wqe_iod, &wqe->gen_req.wqe_com, LPFC_WQE_IOD_READ);
8471 		bf_set(wqe_qosd, &wqe->gen_req.wqe_com, 1);
8472 		bf_set(wqe_lenloc, &wqe->gen_req.wqe_com, LPFC_WQE_LENLOC_NONE);
8473 		bf_set(wqe_ebde_cnt, &wqe->gen_req.wqe_com, 0);
8474 		wqe->gen_req.max_response_payload_len = total_len - xmit_len;
8475 		command_type = OTHER_COMMAND;
8476 		break;
8477 	case CMD_XMIT_ELS_RSP64_CX:
8478 		ndlp = (struct lpfc_nodelist *)iocbq->context1;
8479 		/* words0-2 BDE memcpy */
8480 		/* word3 iocb=iotag32 wqe=response_payload_len */
8481 		wqe->xmit_els_rsp.response_payload_len = xmit_len;
8482 		/* word4 */
8483 		wqe->xmit_els_rsp.word4 = 0;
8484 		/* word5 iocb=rsvd wge=did */
8485 		bf_set(wqe_els_did, &wqe->xmit_els_rsp.wqe_dest,
8486 			 iocbq->iocb.un.xseq64.xmit_els_remoteID);
8487 
8488 		if_type = bf_get(lpfc_sli_intf_if_type,
8489 					&phba->sli4_hba.sli_intf);
8490 		if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
8491 			if (iocbq->vport->fc_flag & FC_PT2PT) {
8492 				bf_set(els_rsp64_sp, &wqe->xmit_els_rsp, 1);
8493 				bf_set(els_rsp64_sid, &wqe->xmit_els_rsp,
8494 					iocbq->vport->fc_myDID);
8495 				if (iocbq->vport->fc_myDID == Fabric_DID) {
8496 					bf_set(wqe_els_did,
8497 						&wqe->xmit_els_rsp.wqe_dest, 0);
8498 				}
8499 			}
8500 		}
8501 		bf_set(wqe_ct, &wqe->xmit_els_rsp.wqe_com,
8502 		       ((iocbq->iocb.ulpCt_h << 1) | iocbq->iocb.ulpCt_l));
8503 		bf_set(wqe_pu, &wqe->xmit_els_rsp.wqe_com, iocbq->iocb.ulpPU);
8504 		bf_set(wqe_rcvoxid, &wqe->xmit_els_rsp.wqe_com,
8505 		       iocbq->iocb.unsli3.rcvsli3.ox_id);
8506 		if (!iocbq->iocb.ulpCt_h && iocbq->iocb.ulpCt_l)
8507 			bf_set(wqe_ctxt_tag, &wqe->xmit_els_rsp.wqe_com,
8508 			       phba->vpi_ids[iocbq->vport->vpi]);
8509 		bf_set(wqe_dbde, &wqe->xmit_els_rsp.wqe_com, 1);
8510 		bf_set(wqe_iod, &wqe->xmit_els_rsp.wqe_com, LPFC_WQE_IOD_WRITE);
8511 		bf_set(wqe_qosd, &wqe->xmit_els_rsp.wqe_com, 1);
8512 		bf_set(wqe_lenloc, &wqe->xmit_els_rsp.wqe_com,
8513 		       LPFC_WQE_LENLOC_WORD3);
8514 		bf_set(wqe_ebde_cnt, &wqe->xmit_els_rsp.wqe_com, 0);
8515 		bf_set(wqe_rsp_temp_rpi, &wqe->xmit_els_rsp,
8516 		       phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]);
8517 		pcmd = (uint32_t *) (((struct lpfc_dmabuf *)
8518 					iocbq->context2)->virt);
8519 		if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
8520 				bf_set(els_rsp64_sp, &wqe->xmit_els_rsp, 1);
8521 				bf_set(els_rsp64_sid, &wqe->xmit_els_rsp,
8522 					iocbq->vport->fc_myDID);
8523 				bf_set(wqe_ct, &wqe->xmit_els_rsp.wqe_com, 1);
8524 				bf_set(wqe_ctxt_tag, &wqe->xmit_els_rsp.wqe_com,
8525 					phba->vpi_ids[phba->pport->vpi]);
8526 		}
8527 		command_type = OTHER_COMMAND;
8528 		break;
8529 	case CMD_CLOSE_XRI_CN:
8530 	case CMD_ABORT_XRI_CN:
8531 	case CMD_ABORT_XRI_CX:
8532 		/* words 0-2 memcpy should be 0 rserved */
8533 		/* port will send abts */
8534 		abrt_iotag = iocbq->iocb.un.acxri.abortContextTag;
8535 		if (abrt_iotag != 0 && abrt_iotag <= phba->sli.last_iotag) {
8536 			abrtiocbq = phba->sli.iocbq_lookup[abrt_iotag];
8537 			fip = abrtiocbq->iocb_flag & LPFC_FIP_ELS_ID_MASK;
8538 		} else
8539 			fip = 0;
8540 
8541 		if ((iocbq->iocb.ulpCommand == CMD_CLOSE_XRI_CN) || fip)
8542 			/*
8543 			 * The link is down, or the command was ELS_FIP
8544 			 * so the fw does not need to send abts
8545 			 * on the wire.
8546 			 */
8547 			bf_set(abort_cmd_ia, &wqe->abort_cmd, 1);
8548 		else
8549 			bf_set(abort_cmd_ia, &wqe->abort_cmd, 0);
8550 		bf_set(abort_cmd_criteria, &wqe->abort_cmd, T_XRI_TAG);
8551 		/* word5 iocb=CONTEXT_TAG|IO_TAG wqe=reserved */
8552 		wqe->abort_cmd.rsrvd5 = 0;
8553 		bf_set(wqe_ct, &wqe->abort_cmd.wqe_com,
8554 			((iocbq->iocb.ulpCt_h << 1) | iocbq->iocb.ulpCt_l));
8555 		abort_tag = iocbq->iocb.un.acxri.abortIoTag;
8556 		/*
8557 		 * The abort handler will send us CMD_ABORT_XRI_CN or
8558 		 * CMD_CLOSE_XRI_CN and the fw only accepts CMD_ABORT_XRI_CX
8559 		 */
8560 		bf_set(wqe_cmnd, &wqe->abort_cmd.wqe_com, CMD_ABORT_XRI_CX);
8561 		bf_set(wqe_qosd, &wqe->abort_cmd.wqe_com, 1);
8562 		bf_set(wqe_lenloc, &wqe->abort_cmd.wqe_com,
8563 		       LPFC_WQE_LENLOC_NONE);
8564 		cmnd = CMD_ABORT_XRI_CX;
8565 		command_type = OTHER_COMMAND;
8566 		xritag = 0;
8567 		break;
8568 	case CMD_XMIT_BLS_RSP64_CX:
8569 		ndlp = (struct lpfc_nodelist *)iocbq->context1;
8570 		/* As BLS ABTS RSP WQE is very different from other WQEs,
8571 		 * we re-construct this WQE here based on information in
8572 		 * iocbq from scratch.
8573 		 */
8574 		memset(wqe, 0, sizeof(union lpfc_wqe));
8575 		/* OX_ID is invariable to who sent ABTS to CT exchange */
8576 		bf_set(xmit_bls_rsp64_oxid, &wqe->xmit_bls_rsp,
8577 		       bf_get(lpfc_abts_oxid, &iocbq->iocb.un.bls_rsp));
8578 		if (bf_get(lpfc_abts_orig, &iocbq->iocb.un.bls_rsp) ==
8579 		    LPFC_ABTS_UNSOL_INT) {
8580 			/* ABTS sent by initiator to CT exchange, the
8581 			 * RX_ID field will be filled with the newly
8582 			 * allocated responder XRI.
8583 			 */
8584 			bf_set(xmit_bls_rsp64_rxid, &wqe->xmit_bls_rsp,
8585 			       iocbq->sli4_xritag);
8586 		} else {
8587 			/* ABTS sent by responder to CT exchange, the
8588 			 * RX_ID field will be filled with the responder
8589 			 * RX_ID from ABTS.
8590 			 */
8591 			bf_set(xmit_bls_rsp64_rxid, &wqe->xmit_bls_rsp,
8592 			       bf_get(lpfc_abts_rxid, &iocbq->iocb.un.bls_rsp));
8593 		}
8594 		bf_set(xmit_bls_rsp64_seqcnthi, &wqe->xmit_bls_rsp, 0xffff);
8595 		bf_set(wqe_xmit_bls_pt, &wqe->xmit_bls_rsp.wqe_dest, 0x1);
8596 
8597 		/* Use CT=VPI */
8598 		bf_set(wqe_els_did, &wqe->xmit_bls_rsp.wqe_dest,
8599 			ndlp->nlp_DID);
8600 		bf_set(xmit_bls_rsp64_temprpi, &wqe->xmit_bls_rsp,
8601 			iocbq->iocb.ulpContext);
8602 		bf_set(wqe_ct, &wqe->xmit_bls_rsp.wqe_com, 1);
8603 		bf_set(wqe_ctxt_tag, &wqe->xmit_bls_rsp.wqe_com,
8604 			phba->vpi_ids[phba->pport->vpi]);
8605 		bf_set(wqe_qosd, &wqe->xmit_bls_rsp.wqe_com, 1);
8606 		bf_set(wqe_lenloc, &wqe->xmit_bls_rsp.wqe_com,
8607 		       LPFC_WQE_LENLOC_NONE);
8608 		/* Overwrite the pre-set comnd type with OTHER_COMMAND */
8609 		command_type = OTHER_COMMAND;
8610 		if (iocbq->iocb.un.xseq64.w5.hcsw.Rctl == FC_RCTL_BA_RJT) {
8611 			bf_set(xmit_bls_rsp64_rjt_vspec, &wqe->xmit_bls_rsp,
8612 			       bf_get(lpfc_vndr_code, &iocbq->iocb.un.bls_rsp));
8613 			bf_set(xmit_bls_rsp64_rjt_expc, &wqe->xmit_bls_rsp,
8614 			       bf_get(lpfc_rsn_expln, &iocbq->iocb.un.bls_rsp));
8615 			bf_set(xmit_bls_rsp64_rjt_rsnc, &wqe->xmit_bls_rsp,
8616 			       bf_get(lpfc_rsn_code, &iocbq->iocb.un.bls_rsp));
8617 		}
8618 
8619 		break;
8620 	case CMD_XRI_ABORTED_CX:
8621 	case CMD_CREATE_XRI_CR: /* Do we expect to use this? */
8622 	case CMD_IOCB_FCP_IBIDIR64_CR: /* bidirectional xfer */
8623 	case CMD_FCP_TSEND64_CX: /* Target mode send xfer-ready */
8624 	case CMD_FCP_TRSP64_CX: /* Target mode rcv */
8625 	case CMD_FCP_AUTO_TRSP_CX: /* Auto target rsp */
8626 	default:
8627 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
8628 				"2014 Invalid command 0x%x\n",
8629 				iocbq->iocb.ulpCommand);
8630 		return IOCB_ERROR;
8631 		break;
8632 	}
8633 
8634 	if (iocbq->iocb_flag & LPFC_IO_DIF_PASS)
8635 		bf_set(wqe_dif, &wqe->generic.wqe_com, LPFC_WQE_DIF_PASSTHRU);
8636 	else if (iocbq->iocb_flag & LPFC_IO_DIF_STRIP)
8637 		bf_set(wqe_dif, &wqe->generic.wqe_com, LPFC_WQE_DIF_STRIP);
8638 	else if (iocbq->iocb_flag & LPFC_IO_DIF_INSERT)
8639 		bf_set(wqe_dif, &wqe->generic.wqe_com, LPFC_WQE_DIF_INSERT);
8640 	iocbq->iocb_flag &= ~(LPFC_IO_DIF_PASS | LPFC_IO_DIF_STRIP |
8641 			      LPFC_IO_DIF_INSERT);
8642 	bf_set(wqe_xri_tag, &wqe->generic.wqe_com, xritag);
8643 	bf_set(wqe_reqtag, &wqe->generic.wqe_com, iocbq->iotag);
8644 	wqe->generic.wqe_com.abort_tag = abort_tag;
8645 	bf_set(wqe_cmd_type, &wqe->generic.wqe_com, command_type);
8646 	bf_set(wqe_cmnd, &wqe->generic.wqe_com, cmnd);
8647 	bf_set(wqe_class, &wqe->generic.wqe_com, iocbq->iocb.ulpClass);
8648 	bf_set(wqe_cqid, &wqe->generic.wqe_com, LPFC_WQE_CQ_ID_DEFAULT);
8649 	return 0;
8650 }
8651 
8652 /**
8653  * __lpfc_sli_issue_iocb_s4 - SLI4 device lockless ver of lpfc_sli_issue_iocb
8654  * @phba: Pointer to HBA context object.
8655  * @ring_number: SLI ring number to issue iocb on.
8656  * @piocb: Pointer to command iocb.
8657  * @flag: Flag indicating if this command can be put into txq.
8658  *
8659  * __lpfc_sli_issue_iocb_s4 is used by other functions in the driver to issue
8660  * an iocb command to an HBA with SLI-4 interface spec.
8661  *
8662  * This function is called with hbalock held. The function will return success
8663  * after it successfully submit the iocb to firmware or after adding to the
8664  * txq.
8665  **/
8666 static int
8667 __lpfc_sli_issue_iocb_s4(struct lpfc_hba *phba, uint32_t ring_number,
8668 			 struct lpfc_iocbq *piocb, uint32_t flag)
8669 {
8670 	struct lpfc_sglq *sglq;
8671 	union lpfc_wqe wqe;
8672 	struct lpfc_queue *wq;
8673 	struct lpfc_sli_ring *pring = &phba->sli.ring[ring_number];
8674 
8675 	if (piocb->sli4_xritag == NO_XRI) {
8676 		if (piocb->iocb.ulpCommand == CMD_ABORT_XRI_CN ||
8677 		    piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN)
8678 			sglq = NULL;
8679 		else {
8680 			if (!list_empty(&pring->txq)) {
8681 				if (!(flag & SLI_IOCB_RET_IOCB)) {
8682 					__lpfc_sli_ringtx_put(phba,
8683 						pring, piocb);
8684 					return IOCB_SUCCESS;
8685 				} else {
8686 					return IOCB_BUSY;
8687 				}
8688 			} else {
8689 				sglq = __lpfc_sli_get_sglq(phba, piocb);
8690 				if (!sglq) {
8691 					if (!(flag & SLI_IOCB_RET_IOCB)) {
8692 						__lpfc_sli_ringtx_put(phba,
8693 								pring,
8694 								piocb);
8695 						return IOCB_SUCCESS;
8696 					} else
8697 						return IOCB_BUSY;
8698 				}
8699 			}
8700 		}
8701 	} else if (piocb->iocb_flag &  LPFC_IO_FCP) {
8702 		/* These IO's already have an XRI and a mapped sgl. */
8703 		sglq = NULL;
8704 	} else {
8705 		/*
8706 		 * This is a continuation of a commandi,(CX) so this
8707 		 * sglq is on the active list
8708 		 */
8709 		sglq = __lpfc_get_active_sglq(phba, piocb->sli4_lxritag);
8710 		if (!sglq)
8711 			return IOCB_ERROR;
8712 	}
8713 
8714 	if (sglq) {
8715 		piocb->sli4_lxritag = sglq->sli4_lxritag;
8716 		piocb->sli4_xritag = sglq->sli4_xritag;
8717 		if (NO_XRI == lpfc_sli4_bpl2sgl(phba, piocb, sglq))
8718 			return IOCB_ERROR;
8719 	}
8720 
8721 	if (lpfc_sli4_iocb2wqe(phba, piocb, &wqe))
8722 		return IOCB_ERROR;
8723 
8724 	if ((piocb->iocb_flag & LPFC_IO_FCP) ||
8725 	    (piocb->iocb_flag & LPFC_USE_FCPWQIDX)) {
8726 		if (!phba->cfg_fof || (!(piocb->iocb_flag & LPFC_IO_OAS))) {
8727 			wq = phba->sli4_hba.fcp_wq[piocb->fcp_wqidx];
8728 		} else {
8729 			wq = phba->sli4_hba.oas_wq;
8730 		}
8731 		if (lpfc_sli4_wq_put(wq, &wqe))
8732 			return IOCB_ERROR;
8733 	} else {
8734 		if (unlikely(!phba->sli4_hba.els_wq))
8735 			return IOCB_ERROR;
8736 		if (lpfc_sli4_wq_put(phba->sli4_hba.els_wq, &wqe))
8737 			return IOCB_ERROR;
8738 	}
8739 	lpfc_sli_ringtxcmpl_put(phba, pring, piocb);
8740 
8741 	return 0;
8742 }
8743 
8744 /**
8745  * __lpfc_sli_issue_iocb - Wrapper func of lockless version for issuing iocb
8746  *
8747  * This routine wraps the actual lockless version for issusing IOCB function
8748  * pointer from the lpfc_hba struct.
8749  *
8750  * Return codes:
8751  * 	IOCB_ERROR - Error
8752  * 	IOCB_SUCCESS - Success
8753  * 	IOCB_BUSY - Busy
8754  **/
8755 int
8756 __lpfc_sli_issue_iocb(struct lpfc_hba *phba, uint32_t ring_number,
8757 		struct lpfc_iocbq *piocb, uint32_t flag)
8758 {
8759 	return phba->__lpfc_sli_issue_iocb(phba, ring_number, piocb, flag);
8760 }
8761 
8762 /**
8763  * lpfc_sli_api_table_setup - Set up sli api function jump table
8764  * @phba: The hba struct for which this call is being executed.
8765  * @dev_grp: The HBA PCI-Device group number.
8766  *
8767  * This routine sets up the SLI interface API function jump table in @phba
8768  * struct.
8769  * Returns: 0 - success, -ENODEV - failure.
8770  **/
8771 int
8772 lpfc_sli_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
8773 {
8774 
8775 	switch (dev_grp) {
8776 	case LPFC_PCI_DEV_LP:
8777 		phba->__lpfc_sli_issue_iocb = __lpfc_sli_issue_iocb_s3;
8778 		phba->__lpfc_sli_release_iocbq = __lpfc_sli_release_iocbq_s3;
8779 		break;
8780 	case LPFC_PCI_DEV_OC:
8781 		phba->__lpfc_sli_issue_iocb = __lpfc_sli_issue_iocb_s4;
8782 		phba->__lpfc_sli_release_iocbq = __lpfc_sli_release_iocbq_s4;
8783 		break;
8784 	default:
8785 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8786 				"1419 Invalid HBA PCI-device group: 0x%x\n",
8787 				dev_grp);
8788 		return -ENODEV;
8789 		break;
8790 	}
8791 	phba->lpfc_get_iocb_from_iocbq = lpfc_get_iocb_from_iocbq;
8792 	return 0;
8793 }
8794 
8795 int
8796 lpfc_sli_calc_ring(struct lpfc_hba *phba, uint32_t ring_number,
8797 		    struct lpfc_iocbq *piocb)
8798 {
8799 	uint32_t idx;
8800 
8801 	if (phba->sli_rev == LPFC_SLI_REV4) {
8802 		if (piocb->iocb_flag &  (LPFC_IO_FCP | LPFC_USE_FCPWQIDX)) {
8803 			/*
8804 			 * fcp_wqidx should already be setup based on what
8805 			 * completion queue we want to use.
8806 			 */
8807 			if (!(phba->cfg_fof) ||
8808 			    (!(piocb->iocb_flag & LPFC_IO_FOF))) {
8809 				if (unlikely(!phba->sli4_hba.fcp_wq))
8810 					return LPFC_HBA_ERROR;
8811 				idx = lpfc_sli4_scmd_to_wqidx_distr(phba);
8812 				piocb->fcp_wqidx = idx;
8813 				ring_number = MAX_SLI3_CONFIGURED_RINGS + idx;
8814 			} else {
8815 				if (unlikely(!phba->sli4_hba.oas_wq))
8816 					return LPFC_HBA_ERROR;
8817 				idx = 0;
8818 				piocb->fcp_wqidx = idx;
8819 				ring_number =  LPFC_FCP_OAS_RING;
8820 			}
8821 		}
8822 	}
8823 	return ring_number;
8824 }
8825 
8826 /**
8827  * lpfc_sli_issue_iocb - Wrapper function for __lpfc_sli_issue_iocb
8828  * @phba: Pointer to HBA context object.
8829  * @pring: Pointer to driver SLI ring object.
8830  * @piocb: Pointer to command iocb.
8831  * @flag: Flag indicating if this command can be put into txq.
8832  *
8833  * lpfc_sli_issue_iocb is a wrapper around __lpfc_sli_issue_iocb
8834  * function. This function gets the hbalock and calls
8835  * __lpfc_sli_issue_iocb function and will return the error returned
8836  * by __lpfc_sli_issue_iocb function. This wrapper is used by
8837  * functions which do not hold hbalock.
8838  **/
8839 int
8840 lpfc_sli_issue_iocb(struct lpfc_hba *phba, uint32_t ring_number,
8841 		    struct lpfc_iocbq *piocb, uint32_t flag)
8842 {
8843 	struct lpfc_fcp_eq_hdl *fcp_eq_hdl;
8844 	struct lpfc_sli_ring *pring;
8845 	struct lpfc_queue *fpeq;
8846 	struct lpfc_eqe *eqe;
8847 	unsigned long iflags;
8848 	int rc, idx;
8849 
8850 	if (phba->sli_rev == LPFC_SLI_REV4) {
8851 		ring_number = lpfc_sli_calc_ring(phba, ring_number, piocb);
8852 		if (unlikely(ring_number == LPFC_HBA_ERROR))
8853 			return IOCB_ERROR;
8854 		idx = piocb->fcp_wqidx;
8855 
8856 		pring = &phba->sli.ring[ring_number];
8857 		spin_lock_irqsave(&pring->ring_lock, iflags);
8858 		rc = __lpfc_sli_issue_iocb(phba, ring_number, piocb, flag);
8859 		spin_unlock_irqrestore(&pring->ring_lock, iflags);
8860 
8861 		if (lpfc_fcp_look_ahead && (piocb->iocb_flag &  LPFC_IO_FCP)) {
8862 			fcp_eq_hdl = &phba->sli4_hba.fcp_eq_hdl[idx];
8863 
8864 			if (atomic_dec_and_test(&fcp_eq_hdl->
8865 				fcp_eq_in_use)) {
8866 
8867 				/* Get associated EQ with this index */
8868 				fpeq = phba->sli4_hba.hba_eq[idx];
8869 
8870 				/* Turn off interrupts from this EQ */
8871 				lpfc_sli4_eq_clr_intr(fpeq);
8872 
8873 				/*
8874 				 * Process all the events on FCP EQ
8875 				 */
8876 				while ((eqe = lpfc_sli4_eq_get(fpeq))) {
8877 					lpfc_sli4_hba_handle_eqe(phba,
8878 						eqe, idx);
8879 					fpeq->EQ_processed++;
8880 				}
8881 
8882 				/* Always clear and re-arm the EQ */
8883 				lpfc_sli4_eq_release(fpeq,
8884 					LPFC_QUEUE_REARM);
8885 			}
8886 			atomic_inc(&fcp_eq_hdl->fcp_eq_in_use);
8887 		}
8888 	} else {
8889 		/* For now, SLI2/3 will still use hbalock */
8890 		spin_lock_irqsave(&phba->hbalock, iflags);
8891 		rc = __lpfc_sli_issue_iocb(phba, ring_number, piocb, flag);
8892 		spin_unlock_irqrestore(&phba->hbalock, iflags);
8893 	}
8894 	return rc;
8895 }
8896 
8897 /**
8898  * lpfc_extra_ring_setup - Extra ring setup function
8899  * @phba: Pointer to HBA context object.
8900  *
8901  * This function is called while driver attaches with the
8902  * HBA to setup the extra ring. The extra ring is used
8903  * only when driver needs to support target mode functionality
8904  * or IP over FC functionalities.
8905  *
8906  * This function is called with no lock held.
8907  **/
8908 static int
8909 lpfc_extra_ring_setup( struct lpfc_hba *phba)
8910 {
8911 	struct lpfc_sli *psli;
8912 	struct lpfc_sli_ring *pring;
8913 
8914 	psli = &phba->sli;
8915 
8916 	/* Adjust cmd/rsp ring iocb entries more evenly */
8917 
8918 	/* Take some away from the FCP ring */
8919 	pring = &psli->ring[psli->fcp_ring];
8920 	pring->sli.sli3.numCiocb -= SLI2_IOCB_CMD_R1XTRA_ENTRIES;
8921 	pring->sli.sli3.numRiocb -= SLI2_IOCB_RSP_R1XTRA_ENTRIES;
8922 	pring->sli.sli3.numCiocb -= SLI2_IOCB_CMD_R3XTRA_ENTRIES;
8923 	pring->sli.sli3.numRiocb -= SLI2_IOCB_RSP_R3XTRA_ENTRIES;
8924 
8925 	/* and give them to the extra ring */
8926 	pring = &psli->ring[psli->extra_ring];
8927 
8928 	pring->sli.sli3.numCiocb += SLI2_IOCB_CMD_R1XTRA_ENTRIES;
8929 	pring->sli.sli3.numRiocb += SLI2_IOCB_RSP_R1XTRA_ENTRIES;
8930 	pring->sli.sli3.numCiocb += SLI2_IOCB_CMD_R3XTRA_ENTRIES;
8931 	pring->sli.sli3.numRiocb += SLI2_IOCB_RSP_R3XTRA_ENTRIES;
8932 
8933 	/* Setup default profile for this ring */
8934 	pring->iotag_max = 4096;
8935 	pring->num_mask = 1;
8936 	pring->prt[0].profile = 0;      /* Mask 0 */
8937 	pring->prt[0].rctl = phba->cfg_multi_ring_rctl;
8938 	pring->prt[0].type = phba->cfg_multi_ring_type;
8939 	pring->prt[0].lpfc_sli_rcv_unsol_event = NULL;
8940 	return 0;
8941 }
8942 
8943 /* lpfc_sli_abts_err_handler - handle a failed ABTS request from an SLI3 port.
8944  * @phba: Pointer to HBA context object.
8945  * @iocbq: Pointer to iocb object.
8946  *
8947  * The async_event handler calls this routine when it receives
8948  * an ASYNC_STATUS_CN event from the port.  The port generates
8949  * this event when an Abort Sequence request to an rport fails
8950  * twice in succession.  The abort could be originated by the
8951  * driver or by the port.  The ABTS could have been for an ELS
8952  * or FCP IO.  The port only generates this event when an ABTS
8953  * fails to complete after one retry.
8954  */
8955 static void
8956 lpfc_sli_abts_err_handler(struct lpfc_hba *phba,
8957 			  struct lpfc_iocbq *iocbq)
8958 {
8959 	struct lpfc_nodelist *ndlp = NULL;
8960 	uint16_t rpi = 0, vpi = 0;
8961 	struct lpfc_vport *vport = NULL;
8962 
8963 	/* The rpi in the ulpContext is vport-sensitive. */
8964 	vpi = iocbq->iocb.un.asyncstat.sub_ctxt_tag;
8965 	rpi = iocbq->iocb.ulpContext;
8966 
8967 	lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
8968 			"3092 Port generated ABTS async event "
8969 			"on vpi %d rpi %d status 0x%x\n",
8970 			vpi, rpi, iocbq->iocb.ulpStatus);
8971 
8972 	vport = lpfc_find_vport_by_vpid(phba, vpi);
8973 	if (!vport)
8974 		goto err_exit;
8975 	ndlp = lpfc_findnode_rpi(vport, rpi);
8976 	if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
8977 		goto err_exit;
8978 
8979 	if (iocbq->iocb.ulpStatus == IOSTAT_LOCAL_REJECT)
8980 		lpfc_sli_abts_recover_port(vport, ndlp);
8981 	return;
8982 
8983  err_exit:
8984 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
8985 			"3095 Event Context not found, no "
8986 			"action on vpi %d rpi %d status 0x%x, reason 0x%x\n",
8987 			iocbq->iocb.ulpContext, iocbq->iocb.ulpStatus,
8988 			vpi, rpi);
8989 }
8990 
8991 /* lpfc_sli4_abts_err_handler - handle a failed ABTS request from an SLI4 port.
8992  * @phba: pointer to HBA context object.
8993  * @ndlp: nodelist pointer for the impacted rport.
8994  * @axri: pointer to the wcqe containing the failed exchange.
8995  *
8996  * The driver calls this routine when it receives an ABORT_XRI_FCP CQE from the
8997  * port.  The port generates this event when an abort exchange request to an
8998  * rport fails twice in succession with no reply.  The abort could be originated
8999  * by the driver or by the port.  The ABTS could have been for an ELS or FCP IO.
9000  */
9001 void
9002 lpfc_sli4_abts_err_handler(struct lpfc_hba *phba,
9003 			   struct lpfc_nodelist *ndlp,
9004 			   struct sli4_wcqe_xri_aborted *axri)
9005 {
9006 	struct lpfc_vport *vport;
9007 	uint32_t ext_status = 0;
9008 
9009 	if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
9010 		lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
9011 				"3115 Node Context not found, driver "
9012 				"ignoring abts err event\n");
9013 		return;
9014 	}
9015 
9016 	vport = ndlp->vport;
9017 	lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
9018 			"3116 Port generated FCP XRI ABORT event on "
9019 			"vpi %d rpi %d xri x%x status 0x%x parameter x%x\n",
9020 			ndlp->vport->vpi, phba->sli4_hba.rpi_ids[ndlp->nlp_rpi],
9021 			bf_get(lpfc_wcqe_xa_xri, axri),
9022 			bf_get(lpfc_wcqe_xa_status, axri),
9023 			axri->parameter);
9024 
9025 	/*
9026 	 * Catch the ABTS protocol failure case.  Older OCe FW releases returned
9027 	 * LOCAL_REJECT and 0 for a failed ABTS exchange and later OCe and
9028 	 * LPe FW releases returned LOCAL_REJECT and SEQUENCE_TIMEOUT.
9029 	 */
9030 	ext_status = axri->parameter & IOERR_PARAM_MASK;
9031 	if ((bf_get(lpfc_wcqe_xa_status, axri) == IOSTAT_LOCAL_REJECT) &&
9032 	    ((ext_status == IOERR_SEQUENCE_TIMEOUT) || (ext_status == 0)))
9033 		lpfc_sli_abts_recover_port(vport, ndlp);
9034 }
9035 
9036 /**
9037  * lpfc_sli_async_event_handler - ASYNC iocb handler function
9038  * @phba: Pointer to HBA context object.
9039  * @pring: Pointer to driver SLI ring object.
9040  * @iocbq: Pointer to iocb object.
9041  *
9042  * This function is called by the slow ring event handler
9043  * function when there is an ASYNC event iocb in the ring.
9044  * This function is called with no lock held.
9045  * Currently this function handles only temperature related
9046  * ASYNC events. The function decodes the temperature sensor
9047  * event message and posts events for the management applications.
9048  **/
9049 static void
9050 lpfc_sli_async_event_handler(struct lpfc_hba * phba,
9051 	struct lpfc_sli_ring * pring, struct lpfc_iocbq * iocbq)
9052 {
9053 	IOCB_t *icmd;
9054 	uint16_t evt_code;
9055 	struct temp_event temp_event_data;
9056 	struct Scsi_Host *shost;
9057 	uint32_t *iocb_w;
9058 
9059 	icmd = &iocbq->iocb;
9060 	evt_code = icmd->un.asyncstat.evt_code;
9061 
9062 	switch (evt_code) {
9063 	case ASYNC_TEMP_WARN:
9064 	case ASYNC_TEMP_SAFE:
9065 		temp_event_data.data = (uint32_t) icmd->ulpContext;
9066 		temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
9067 		if (evt_code == ASYNC_TEMP_WARN) {
9068 			temp_event_data.event_code = LPFC_THRESHOLD_TEMP;
9069 			lpfc_printf_log(phba, KERN_ERR, LOG_TEMP,
9070 				"0347 Adapter is very hot, please take "
9071 				"corrective action. temperature : %d Celsius\n",
9072 				(uint32_t) icmd->ulpContext);
9073 		} else {
9074 			temp_event_data.event_code = LPFC_NORMAL_TEMP;
9075 			lpfc_printf_log(phba, KERN_ERR, LOG_TEMP,
9076 				"0340 Adapter temperature is OK now. "
9077 				"temperature : %d Celsius\n",
9078 				(uint32_t) icmd->ulpContext);
9079 		}
9080 
9081 		/* Send temperature change event to applications */
9082 		shost = lpfc_shost_from_vport(phba->pport);
9083 		fc_host_post_vendor_event(shost, fc_get_event_number(),
9084 			sizeof(temp_event_data), (char *) &temp_event_data,
9085 			LPFC_NL_VENDOR_ID);
9086 		break;
9087 	case ASYNC_STATUS_CN:
9088 		lpfc_sli_abts_err_handler(phba, iocbq);
9089 		break;
9090 	default:
9091 		iocb_w = (uint32_t *) icmd;
9092 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
9093 			"0346 Ring %d handler: unexpected ASYNC_STATUS"
9094 			" evt_code 0x%x\n"
9095 			"W0  0x%08x W1  0x%08x W2  0x%08x W3  0x%08x\n"
9096 			"W4  0x%08x W5  0x%08x W6  0x%08x W7  0x%08x\n"
9097 			"W8  0x%08x W9  0x%08x W10 0x%08x W11 0x%08x\n"
9098 			"W12 0x%08x W13 0x%08x W14 0x%08x W15 0x%08x\n",
9099 			pring->ringno, icmd->un.asyncstat.evt_code,
9100 			iocb_w[0], iocb_w[1], iocb_w[2], iocb_w[3],
9101 			iocb_w[4], iocb_w[5], iocb_w[6], iocb_w[7],
9102 			iocb_w[8], iocb_w[9], iocb_w[10], iocb_w[11],
9103 			iocb_w[12], iocb_w[13], iocb_w[14], iocb_w[15]);
9104 
9105 		break;
9106 	}
9107 }
9108 
9109 
9110 /**
9111  * lpfc_sli_setup - SLI ring setup function
9112  * @phba: Pointer to HBA context object.
9113  *
9114  * lpfc_sli_setup sets up rings of the SLI interface with
9115  * number of iocbs per ring and iotags. This function is
9116  * called while driver attach to the HBA and before the
9117  * interrupts are enabled. So there is no need for locking.
9118  *
9119  * This function always returns 0.
9120  **/
9121 int
9122 lpfc_sli_setup(struct lpfc_hba *phba)
9123 {
9124 	int i, totiocbsize = 0;
9125 	struct lpfc_sli *psli = &phba->sli;
9126 	struct lpfc_sli_ring *pring;
9127 
9128 	psli->num_rings = MAX_SLI3_CONFIGURED_RINGS;
9129 	if (phba->sli_rev == LPFC_SLI_REV4)
9130 		psli->num_rings += phba->cfg_fcp_io_channel;
9131 	psli->sli_flag = 0;
9132 	psli->fcp_ring = LPFC_FCP_RING;
9133 	psli->next_ring = LPFC_FCP_NEXT_RING;
9134 	psli->extra_ring = LPFC_EXTRA_RING;
9135 
9136 	psli->iocbq_lookup = NULL;
9137 	psli->iocbq_lookup_len = 0;
9138 	psli->last_iotag = 0;
9139 
9140 	for (i = 0; i < psli->num_rings; i++) {
9141 		pring = &psli->ring[i];
9142 		switch (i) {
9143 		case LPFC_FCP_RING:	/* ring 0 - FCP */
9144 			/* numCiocb and numRiocb are used in config_port */
9145 			pring->sli.sli3.numCiocb = SLI2_IOCB_CMD_R0_ENTRIES;
9146 			pring->sli.sli3.numRiocb = SLI2_IOCB_RSP_R0_ENTRIES;
9147 			pring->sli.sli3.numCiocb +=
9148 				SLI2_IOCB_CMD_R1XTRA_ENTRIES;
9149 			pring->sli.sli3.numRiocb +=
9150 				SLI2_IOCB_RSP_R1XTRA_ENTRIES;
9151 			pring->sli.sli3.numCiocb +=
9152 				SLI2_IOCB_CMD_R3XTRA_ENTRIES;
9153 			pring->sli.sli3.numRiocb +=
9154 				SLI2_IOCB_RSP_R3XTRA_ENTRIES;
9155 			pring->sli.sli3.sizeCiocb = (phba->sli_rev == 3) ?
9156 							SLI3_IOCB_CMD_SIZE :
9157 							SLI2_IOCB_CMD_SIZE;
9158 			pring->sli.sli3.sizeRiocb = (phba->sli_rev == 3) ?
9159 							SLI3_IOCB_RSP_SIZE :
9160 							SLI2_IOCB_RSP_SIZE;
9161 			pring->iotag_ctr = 0;
9162 			pring->iotag_max =
9163 			    (phba->cfg_hba_queue_depth * 2);
9164 			pring->fast_iotag = pring->iotag_max;
9165 			pring->num_mask = 0;
9166 			break;
9167 		case LPFC_EXTRA_RING:	/* ring 1 - EXTRA */
9168 			/* numCiocb and numRiocb are used in config_port */
9169 			pring->sli.sli3.numCiocb = SLI2_IOCB_CMD_R1_ENTRIES;
9170 			pring->sli.sli3.numRiocb = SLI2_IOCB_RSP_R1_ENTRIES;
9171 			pring->sli.sli3.sizeCiocb = (phba->sli_rev == 3) ?
9172 							SLI3_IOCB_CMD_SIZE :
9173 							SLI2_IOCB_CMD_SIZE;
9174 			pring->sli.sli3.sizeRiocb = (phba->sli_rev == 3) ?
9175 							SLI3_IOCB_RSP_SIZE :
9176 							SLI2_IOCB_RSP_SIZE;
9177 			pring->iotag_max = phba->cfg_hba_queue_depth;
9178 			pring->num_mask = 0;
9179 			break;
9180 		case LPFC_ELS_RING:	/* ring 2 - ELS / CT */
9181 			/* numCiocb and numRiocb are used in config_port */
9182 			pring->sli.sli3.numCiocb = SLI2_IOCB_CMD_R2_ENTRIES;
9183 			pring->sli.sli3.numRiocb = SLI2_IOCB_RSP_R2_ENTRIES;
9184 			pring->sli.sli3.sizeCiocb = (phba->sli_rev == 3) ?
9185 							SLI3_IOCB_CMD_SIZE :
9186 							SLI2_IOCB_CMD_SIZE;
9187 			pring->sli.sli3.sizeRiocb = (phba->sli_rev == 3) ?
9188 							SLI3_IOCB_RSP_SIZE :
9189 							SLI2_IOCB_RSP_SIZE;
9190 			pring->fast_iotag = 0;
9191 			pring->iotag_ctr = 0;
9192 			pring->iotag_max = 4096;
9193 			pring->lpfc_sli_rcv_async_status =
9194 				lpfc_sli_async_event_handler;
9195 			pring->num_mask = LPFC_MAX_RING_MASK;
9196 			pring->prt[0].profile = 0;	/* Mask 0 */
9197 			pring->prt[0].rctl = FC_RCTL_ELS_REQ;
9198 			pring->prt[0].type = FC_TYPE_ELS;
9199 			pring->prt[0].lpfc_sli_rcv_unsol_event =
9200 			    lpfc_els_unsol_event;
9201 			pring->prt[1].profile = 0;	/* Mask 1 */
9202 			pring->prt[1].rctl = FC_RCTL_ELS_REP;
9203 			pring->prt[1].type = FC_TYPE_ELS;
9204 			pring->prt[1].lpfc_sli_rcv_unsol_event =
9205 			    lpfc_els_unsol_event;
9206 			pring->prt[2].profile = 0;	/* Mask 2 */
9207 			/* NameServer Inquiry */
9208 			pring->prt[2].rctl = FC_RCTL_DD_UNSOL_CTL;
9209 			/* NameServer */
9210 			pring->prt[2].type = FC_TYPE_CT;
9211 			pring->prt[2].lpfc_sli_rcv_unsol_event =
9212 			    lpfc_ct_unsol_event;
9213 			pring->prt[3].profile = 0;	/* Mask 3 */
9214 			/* NameServer response */
9215 			pring->prt[3].rctl = FC_RCTL_DD_SOL_CTL;
9216 			/* NameServer */
9217 			pring->prt[3].type = FC_TYPE_CT;
9218 			pring->prt[3].lpfc_sli_rcv_unsol_event =
9219 			    lpfc_ct_unsol_event;
9220 			break;
9221 		}
9222 		totiocbsize += (pring->sli.sli3.numCiocb *
9223 			pring->sli.sli3.sizeCiocb) +
9224 			(pring->sli.sli3.numRiocb * pring->sli.sli3.sizeRiocb);
9225 	}
9226 	if (totiocbsize > MAX_SLIM_IOCB_SIZE) {
9227 		/* Too many cmd / rsp ring entries in SLI2 SLIM */
9228 		printk(KERN_ERR "%d:0462 Too many cmd / rsp ring entries in "
9229 		       "SLI2 SLIM Data: x%x x%lx\n",
9230 		       phba->brd_no, totiocbsize,
9231 		       (unsigned long) MAX_SLIM_IOCB_SIZE);
9232 	}
9233 	if (phba->cfg_multi_ring_support == 2)
9234 		lpfc_extra_ring_setup(phba);
9235 
9236 	return 0;
9237 }
9238 
9239 /**
9240  * lpfc_sli_queue_setup - Queue initialization function
9241  * @phba: Pointer to HBA context object.
9242  *
9243  * lpfc_sli_queue_setup sets up mailbox queues and iocb queues for each
9244  * ring. This function also initializes ring indices of each ring.
9245  * This function is called during the initialization of the SLI
9246  * interface of an HBA.
9247  * This function is called with no lock held and always returns
9248  * 1.
9249  **/
9250 int
9251 lpfc_sli_queue_setup(struct lpfc_hba *phba)
9252 {
9253 	struct lpfc_sli *psli;
9254 	struct lpfc_sli_ring *pring;
9255 	int i;
9256 
9257 	psli = &phba->sli;
9258 	spin_lock_irq(&phba->hbalock);
9259 	INIT_LIST_HEAD(&psli->mboxq);
9260 	INIT_LIST_HEAD(&psli->mboxq_cmpl);
9261 	/* Initialize list headers for txq and txcmplq as double linked lists */
9262 	for (i = 0; i < psli->num_rings; i++) {
9263 		pring = &psli->ring[i];
9264 		pring->ringno = i;
9265 		pring->sli.sli3.next_cmdidx  = 0;
9266 		pring->sli.sli3.local_getidx = 0;
9267 		pring->sli.sli3.cmdidx = 0;
9268 		pring->flag = 0;
9269 		INIT_LIST_HEAD(&pring->txq);
9270 		INIT_LIST_HEAD(&pring->txcmplq);
9271 		INIT_LIST_HEAD(&pring->iocb_continueq);
9272 		INIT_LIST_HEAD(&pring->iocb_continue_saveq);
9273 		INIT_LIST_HEAD(&pring->postbufq);
9274 		spin_lock_init(&pring->ring_lock);
9275 	}
9276 	spin_unlock_irq(&phba->hbalock);
9277 	return 1;
9278 }
9279 
9280 /**
9281  * lpfc_sli_mbox_sys_flush - Flush mailbox command sub-system
9282  * @phba: Pointer to HBA context object.
9283  *
9284  * This routine flushes the mailbox command subsystem. It will unconditionally
9285  * flush all the mailbox commands in the three possible stages in the mailbox
9286  * command sub-system: pending mailbox command queue; the outstanding mailbox
9287  * command; and completed mailbox command queue. It is caller's responsibility
9288  * to make sure that the driver is in the proper state to flush the mailbox
9289  * command sub-system. Namely, the posting of mailbox commands into the
9290  * pending mailbox command queue from the various clients must be stopped;
9291  * either the HBA is in a state that it will never works on the outstanding
9292  * mailbox command (such as in EEH or ERATT conditions) or the outstanding
9293  * mailbox command has been completed.
9294  **/
9295 static void
9296 lpfc_sli_mbox_sys_flush(struct lpfc_hba *phba)
9297 {
9298 	LIST_HEAD(completions);
9299 	struct lpfc_sli *psli = &phba->sli;
9300 	LPFC_MBOXQ_t *pmb;
9301 	unsigned long iflag;
9302 
9303 	/* Flush all the mailbox commands in the mbox system */
9304 	spin_lock_irqsave(&phba->hbalock, iflag);
9305 	/* The pending mailbox command queue */
9306 	list_splice_init(&phba->sli.mboxq, &completions);
9307 	/* The outstanding active mailbox command */
9308 	if (psli->mbox_active) {
9309 		list_add_tail(&psli->mbox_active->list, &completions);
9310 		psli->mbox_active = NULL;
9311 		psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
9312 	}
9313 	/* The completed mailbox command queue */
9314 	list_splice_init(&phba->sli.mboxq_cmpl, &completions);
9315 	spin_unlock_irqrestore(&phba->hbalock, iflag);
9316 
9317 	/* Return all flushed mailbox commands with MBX_NOT_FINISHED status */
9318 	while (!list_empty(&completions)) {
9319 		list_remove_head(&completions, pmb, LPFC_MBOXQ_t, list);
9320 		pmb->u.mb.mbxStatus = MBX_NOT_FINISHED;
9321 		if (pmb->mbox_cmpl)
9322 			pmb->mbox_cmpl(phba, pmb);
9323 	}
9324 }
9325 
9326 /**
9327  * lpfc_sli_host_down - Vport cleanup function
9328  * @vport: Pointer to virtual port object.
9329  *
9330  * lpfc_sli_host_down is called to clean up the resources
9331  * associated with a vport before destroying virtual
9332  * port data structures.
9333  * This function does following operations:
9334  * - Free discovery resources associated with this virtual
9335  *   port.
9336  * - Free iocbs associated with this virtual port in
9337  *   the txq.
9338  * - Send abort for all iocb commands associated with this
9339  *   vport in txcmplq.
9340  *
9341  * This function is called with no lock held and always returns 1.
9342  **/
9343 int
9344 lpfc_sli_host_down(struct lpfc_vport *vport)
9345 {
9346 	LIST_HEAD(completions);
9347 	struct lpfc_hba *phba = vport->phba;
9348 	struct lpfc_sli *psli = &phba->sli;
9349 	struct lpfc_sli_ring *pring;
9350 	struct lpfc_iocbq *iocb, *next_iocb;
9351 	int i;
9352 	unsigned long flags = 0;
9353 	uint16_t prev_pring_flag;
9354 
9355 	lpfc_cleanup_discovery_resources(vport);
9356 
9357 	spin_lock_irqsave(&phba->hbalock, flags);
9358 	for (i = 0; i < psli->num_rings; i++) {
9359 		pring = &psli->ring[i];
9360 		prev_pring_flag = pring->flag;
9361 		/* Only slow rings */
9362 		if (pring->ringno == LPFC_ELS_RING) {
9363 			pring->flag |= LPFC_DEFERRED_RING_EVENT;
9364 			/* Set the lpfc data pending flag */
9365 			set_bit(LPFC_DATA_READY, &phba->data_flags);
9366 		}
9367 		/*
9368 		 * Error everything on the txq since these iocbs have not been
9369 		 * given to the FW yet.
9370 		 */
9371 		list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
9372 			if (iocb->vport != vport)
9373 				continue;
9374 			list_move_tail(&iocb->list, &completions);
9375 		}
9376 
9377 		/* Next issue ABTS for everything on the txcmplq */
9378 		list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq,
9379 									list) {
9380 			if (iocb->vport != vport)
9381 				continue;
9382 			lpfc_sli_issue_abort_iotag(phba, pring, iocb);
9383 		}
9384 
9385 		pring->flag = prev_pring_flag;
9386 	}
9387 
9388 	spin_unlock_irqrestore(&phba->hbalock, flags);
9389 
9390 	/* Cancel all the IOCBs from the completions list */
9391 	lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
9392 			      IOERR_SLI_DOWN);
9393 	return 1;
9394 }
9395 
9396 /**
9397  * lpfc_sli_hba_down - Resource cleanup function for the HBA
9398  * @phba: Pointer to HBA context object.
9399  *
9400  * This function cleans up all iocb, buffers, mailbox commands
9401  * while shutting down the HBA. This function is called with no
9402  * lock held and always returns 1.
9403  * This function does the following to cleanup driver resources:
9404  * - Free discovery resources for each virtual port
9405  * - Cleanup any pending fabric iocbs
9406  * - Iterate through the iocb txq and free each entry
9407  *   in the list.
9408  * - Free up any buffer posted to the HBA
9409  * - Free mailbox commands in the mailbox queue.
9410  **/
9411 int
9412 lpfc_sli_hba_down(struct lpfc_hba *phba)
9413 {
9414 	LIST_HEAD(completions);
9415 	struct lpfc_sli *psli = &phba->sli;
9416 	struct lpfc_sli_ring *pring;
9417 	struct lpfc_dmabuf *buf_ptr;
9418 	unsigned long flags = 0;
9419 	int i;
9420 
9421 	/* Shutdown the mailbox command sub-system */
9422 	lpfc_sli_mbox_sys_shutdown(phba, LPFC_MBX_WAIT);
9423 
9424 	lpfc_hba_down_prep(phba);
9425 
9426 	lpfc_fabric_abort_hba(phba);
9427 
9428 	spin_lock_irqsave(&phba->hbalock, flags);
9429 	for (i = 0; i < psli->num_rings; i++) {
9430 		pring = &psli->ring[i];
9431 		/* Only slow rings */
9432 		if (pring->ringno == LPFC_ELS_RING) {
9433 			pring->flag |= LPFC_DEFERRED_RING_EVENT;
9434 			/* Set the lpfc data pending flag */
9435 			set_bit(LPFC_DATA_READY, &phba->data_flags);
9436 		}
9437 
9438 		/*
9439 		 * Error everything on the txq since these iocbs have not been
9440 		 * given to the FW yet.
9441 		 */
9442 		list_splice_init(&pring->txq, &completions);
9443 	}
9444 	spin_unlock_irqrestore(&phba->hbalock, flags);
9445 
9446 	/* Cancel all the IOCBs from the completions list */
9447 	lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
9448 			      IOERR_SLI_DOWN);
9449 
9450 	spin_lock_irqsave(&phba->hbalock, flags);
9451 	list_splice_init(&phba->elsbuf, &completions);
9452 	phba->elsbuf_cnt = 0;
9453 	phba->elsbuf_prev_cnt = 0;
9454 	spin_unlock_irqrestore(&phba->hbalock, flags);
9455 
9456 	while (!list_empty(&completions)) {
9457 		list_remove_head(&completions, buf_ptr,
9458 			struct lpfc_dmabuf, list);
9459 		lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
9460 		kfree(buf_ptr);
9461 	}
9462 
9463 	/* Return any active mbox cmds */
9464 	del_timer_sync(&psli->mbox_tmo);
9465 
9466 	spin_lock_irqsave(&phba->pport->work_port_lock, flags);
9467 	phba->pport->work_port_events &= ~WORKER_MBOX_TMO;
9468 	spin_unlock_irqrestore(&phba->pport->work_port_lock, flags);
9469 
9470 	return 1;
9471 }
9472 
9473 /**
9474  * lpfc_sli_pcimem_bcopy - SLI memory copy function
9475  * @srcp: Source memory pointer.
9476  * @destp: Destination memory pointer.
9477  * @cnt: Number of words required to be copied.
9478  *
9479  * This function is used for copying data between driver memory
9480  * and the SLI memory. This function also changes the endianness
9481  * of each word if native endianness is different from SLI
9482  * endianness. This function can be called with or without
9483  * lock.
9484  **/
9485 void
9486 lpfc_sli_pcimem_bcopy(void *srcp, void *destp, uint32_t cnt)
9487 {
9488 	uint32_t *src = srcp;
9489 	uint32_t *dest = destp;
9490 	uint32_t ldata;
9491 	int i;
9492 
9493 	for (i = 0; i < (int)cnt; i += sizeof (uint32_t)) {
9494 		ldata = *src;
9495 		ldata = le32_to_cpu(ldata);
9496 		*dest = ldata;
9497 		src++;
9498 		dest++;
9499 	}
9500 }
9501 
9502 
9503 /**
9504  * lpfc_sli_bemem_bcopy - SLI memory copy function
9505  * @srcp: Source memory pointer.
9506  * @destp: Destination memory pointer.
9507  * @cnt: Number of words required to be copied.
9508  *
9509  * This function is used for copying data between a data structure
9510  * with big endian representation to local endianness.
9511  * This function can be called with or without lock.
9512  **/
9513 void
9514 lpfc_sli_bemem_bcopy(void *srcp, void *destp, uint32_t cnt)
9515 {
9516 	uint32_t *src = srcp;
9517 	uint32_t *dest = destp;
9518 	uint32_t ldata;
9519 	int i;
9520 
9521 	for (i = 0; i < (int)cnt; i += sizeof(uint32_t)) {
9522 		ldata = *src;
9523 		ldata = be32_to_cpu(ldata);
9524 		*dest = ldata;
9525 		src++;
9526 		dest++;
9527 	}
9528 }
9529 
9530 /**
9531  * lpfc_sli_ringpostbuf_put - Function to add a buffer to postbufq
9532  * @phba: Pointer to HBA context object.
9533  * @pring: Pointer to driver SLI ring object.
9534  * @mp: Pointer to driver buffer object.
9535  *
9536  * This function is called with no lock held.
9537  * It always return zero after adding the buffer to the postbufq
9538  * buffer list.
9539  **/
9540 int
9541 lpfc_sli_ringpostbuf_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
9542 			 struct lpfc_dmabuf *mp)
9543 {
9544 	/* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
9545 	   later */
9546 	spin_lock_irq(&phba->hbalock);
9547 	list_add_tail(&mp->list, &pring->postbufq);
9548 	pring->postbufq_cnt++;
9549 	spin_unlock_irq(&phba->hbalock);
9550 	return 0;
9551 }
9552 
9553 /**
9554  * lpfc_sli_get_buffer_tag - allocates a tag for a CMD_QUE_XRI64_CX buffer
9555  * @phba: Pointer to HBA context object.
9556  *
9557  * When HBQ is enabled, buffers are searched based on tags. This function
9558  * allocates a tag for buffer posted using CMD_QUE_XRI64_CX iocb. The
9559  * tag is bit wise or-ed with QUE_BUFTAG_BIT to make sure that the tag
9560  * does not conflict with tags of buffer posted for unsolicited events.
9561  * The function returns the allocated tag. The function is called with
9562  * no locks held.
9563  **/
9564 uint32_t
9565 lpfc_sli_get_buffer_tag(struct lpfc_hba *phba)
9566 {
9567 	spin_lock_irq(&phba->hbalock);
9568 	phba->buffer_tag_count++;
9569 	/*
9570 	 * Always set the QUE_BUFTAG_BIT to distiguish between
9571 	 * a tag assigned by HBQ.
9572 	 */
9573 	phba->buffer_tag_count |= QUE_BUFTAG_BIT;
9574 	spin_unlock_irq(&phba->hbalock);
9575 	return phba->buffer_tag_count;
9576 }
9577 
9578 /**
9579  * lpfc_sli_ring_taggedbuf_get - find HBQ buffer associated with given tag
9580  * @phba: Pointer to HBA context object.
9581  * @pring: Pointer to driver SLI ring object.
9582  * @tag: Buffer tag.
9583  *
9584  * Buffers posted using CMD_QUE_XRI64_CX iocb are in pring->postbufq
9585  * list. After HBA DMA data to these buffers, CMD_IOCB_RET_XRI64_CX
9586  * iocb is posted to the response ring with the tag of the buffer.
9587  * This function searches the pring->postbufq list using the tag
9588  * to find buffer associated with CMD_IOCB_RET_XRI64_CX
9589  * iocb. If the buffer is found then lpfc_dmabuf object of the
9590  * buffer is returned to the caller else NULL is returned.
9591  * This function is called with no lock held.
9592  **/
9593 struct lpfc_dmabuf *
9594 lpfc_sli_ring_taggedbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
9595 			uint32_t tag)
9596 {
9597 	struct lpfc_dmabuf *mp, *next_mp;
9598 	struct list_head *slp = &pring->postbufq;
9599 
9600 	/* Search postbufq, from the beginning, looking for a match on tag */
9601 	spin_lock_irq(&phba->hbalock);
9602 	list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
9603 		if (mp->buffer_tag == tag) {
9604 			list_del_init(&mp->list);
9605 			pring->postbufq_cnt--;
9606 			spin_unlock_irq(&phba->hbalock);
9607 			return mp;
9608 		}
9609 	}
9610 
9611 	spin_unlock_irq(&phba->hbalock);
9612 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9613 			"0402 Cannot find virtual addr for buffer tag on "
9614 			"ring %d Data x%lx x%p x%p x%x\n",
9615 			pring->ringno, (unsigned long) tag,
9616 			slp->next, slp->prev, pring->postbufq_cnt);
9617 
9618 	return NULL;
9619 }
9620 
9621 /**
9622  * lpfc_sli_ringpostbuf_get - search buffers for unsolicited CT and ELS events
9623  * @phba: Pointer to HBA context object.
9624  * @pring: Pointer to driver SLI ring object.
9625  * @phys: DMA address of the buffer.
9626  *
9627  * This function searches the buffer list using the dma_address
9628  * of unsolicited event to find the driver's lpfc_dmabuf object
9629  * corresponding to the dma_address. The function returns the
9630  * lpfc_dmabuf object if a buffer is found else it returns NULL.
9631  * This function is called by the ct and els unsolicited event
9632  * handlers to get the buffer associated with the unsolicited
9633  * event.
9634  *
9635  * This function is called with no lock held.
9636  **/
9637 struct lpfc_dmabuf *
9638 lpfc_sli_ringpostbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
9639 			 dma_addr_t phys)
9640 {
9641 	struct lpfc_dmabuf *mp, *next_mp;
9642 	struct list_head *slp = &pring->postbufq;
9643 
9644 	/* Search postbufq, from the beginning, looking for a match on phys */
9645 	spin_lock_irq(&phba->hbalock);
9646 	list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
9647 		if (mp->phys == phys) {
9648 			list_del_init(&mp->list);
9649 			pring->postbufq_cnt--;
9650 			spin_unlock_irq(&phba->hbalock);
9651 			return mp;
9652 		}
9653 	}
9654 
9655 	spin_unlock_irq(&phba->hbalock);
9656 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9657 			"0410 Cannot find virtual addr for mapped buf on "
9658 			"ring %d Data x%llx x%p x%p x%x\n",
9659 			pring->ringno, (unsigned long long)phys,
9660 			slp->next, slp->prev, pring->postbufq_cnt);
9661 	return NULL;
9662 }
9663 
9664 /**
9665  * lpfc_sli_abort_els_cmpl - Completion handler for the els abort iocbs
9666  * @phba: Pointer to HBA context object.
9667  * @cmdiocb: Pointer to driver command iocb object.
9668  * @rspiocb: Pointer to driver response iocb object.
9669  *
9670  * This function is the completion handler for the abort iocbs for
9671  * ELS commands. This function is called from the ELS ring event
9672  * handler with no lock held. This function frees memory resources
9673  * associated with the abort iocb.
9674  **/
9675 static void
9676 lpfc_sli_abort_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
9677 			struct lpfc_iocbq *rspiocb)
9678 {
9679 	IOCB_t *irsp = &rspiocb->iocb;
9680 	uint16_t abort_iotag, abort_context;
9681 	struct lpfc_iocbq *abort_iocb = NULL;
9682 
9683 	if (irsp->ulpStatus) {
9684 
9685 		/*
9686 		 * Assume that the port already completed and returned, or
9687 		 * will return the iocb. Just Log the message.
9688 		 */
9689 		abort_context = cmdiocb->iocb.un.acxri.abortContextTag;
9690 		abort_iotag = cmdiocb->iocb.un.acxri.abortIoTag;
9691 
9692 		spin_lock_irq(&phba->hbalock);
9693 		if (phba->sli_rev < LPFC_SLI_REV4) {
9694 			if (abort_iotag != 0 &&
9695 				abort_iotag <= phba->sli.last_iotag)
9696 				abort_iocb =
9697 					phba->sli.iocbq_lookup[abort_iotag];
9698 		} else
9699 			/* For sli4 the abort_tag is the XRI,
9700 			 * so the abort routine puts the iotag  of the iocb
9701 			 * being aborted in the context field of the abort
9702 			 * IOCB.
9703 			 */
9704 			abort_iocb = phba->sli.iocbq_lookup[abort_context];
9705 
9706 		lpfc_printf_log(phba, KERN_WARNING, LOG_ELS | LOG_SLI,
9707 				"0327 Cannot abort els iocb %p "
9708 				"with tag %x context %x, abort status %x, "
9709 				"abort code %x\n",
9710 				abort_iocb, abort_iotag, abort_context,
9711 				irsp->ulpStatus, irsp->un.ulpWord[4]);
9712 
9713 		spin_unlock_irq(&phba->hbalock);
9714 	}
9715 	lpfc_sli_release_iocbq(phba, cmdiocb);
9716 	return;
9717 }
9718 
9719 /**
9720  * lpfc_ignore_els_cmpl - Completion handler for aborted ELS command
9721  * @phba: Pointer to HBA context object.
9722  * @cmdiocb: Pointer to driver command iocb object.
9723  * @rspiocb: Pointer to driver response iocb object.
9724  *
9725  * The function is called from SLI ring event handler with no
9726  * lock held. This function is the completion handler for ELS commands
9727  * which are aborted. The function frees memory resources used for
9728  * the aborted ELS commands.
9729  **/
9730 static void
9731 lpfc_ignore_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
9732 		     struct lpfc_iocbq *rspiocb)
9733 {
9734 	IOCB_t *irsp = &rspiocb->iocb;
9735 
9736 	/* ELS cmd tag <ulpIoTag> completes */
9737 	lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
9738 			"0139 Ignoring ELS cmd tag x%x completion Data: "
9739 			"x%x x%x x%x\n",
9740 			irsp->ulpIoTag, irsp->ulpStatus,
9741 			irsp->un.ulpWord[4], irsp->ulpTimeout);
9742 	if (cmdiocb->iocb.ulpCommand == CMD_GEN_REQUEST64_CR)
9743 		lpfc_ct_free_iocb(phba, cmdiocb);
9744 	else
9745 		lpfc_els_free_iocb(phba, cmdiocb);
9746 	return;
9747 }
9748 
9749 /**
9750  * lpfc_sli_abort_iotag_issue - Issue abort for a command iocb
9751  * @phba: Pointer to HBA context object.
9752  * @pring: Pointer to driver SLI ring object.
9753  * @cmdiocb: Pointer to driver command iocb object.
9754  *
9755  * This function issues an abort iocb for the provided command iocb down to
9756  * the port. Other than the case the outstanding command iocb is an abort
9757  * request, this function issues abort out unconditionally. This function is
9758  * called with hbalock held. The function returns 0 when it fails due to
9759  * memory allocation failure or when the command iocb is an abort request.
9760  **/
9761 static int
9762 lpfc_sli_abort_iotag_issue(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
9763 			   struct lpfc_iocbq *cmdiocb)
9764 {
9765 	struct lpfc_vport *vport = cmdiocb->vport;
9766 	struct lpfc_iocbq *abtsiocbp;
9767 	IOCB_t *icmd = NULL;
9768 	IOCB_t *iabt = NULL;
9769 	int ring_number;
9770 	int retval;
9771 	unsigned long iflags;
9772 
9773 	/*
9774 	 * There are certain command types we don't want to abort.  And we
9775 	 * don't want to abort commands that are already in the process of
9776 	 * being aborted.
9777 	 */
9778 	icmd = &cmdiocb->iocb;
9779 	if (icmd->ulpCommand == CMD_ABORT_XRI_CN ||
9780 	    icmd->ulpCommand == CMD_CLOSE_XRI_CN ||
9781 	    (cmdiocb->iocb_flag & LPFC_DRIVER_ABORTED) != 0)
9782 		return 0;
9783 
9784 	/* issue ABTS for this IOCB based on iotag */
9785 	abtsiocbp = __lpfc_sli_get_iocbq(phba);
9786 	if (abtsiocbp == NULL)
9787 		return 0;
9788 
9789 	/* This signals the response to set the correct status
9790 	 * before calling the completion handler
9791 	 */
9792 	cmdiocb->iocb_flag |= LPFC_DRIVER_ABORTED;
9793 
9794 	iabt = &abtsiocbp->iocb;
9795 	iabt->un.acxri.abortType = ABORT_TYPE_ABTS;
9796 	iabt->un.acxri.abortContextTag = icmd->ulpContext;
9797 	if (phba->sli_rev == LPFC_SLI_REV4) {
9798 		iabt->un.acxri.abortIoTag = cmdiocb->sli4_xritag;
9799 		iabt->un.acxri.abortContextTag = cmdiocb->iotag;
9800 	}
9801 	else
9802 		iabt->un.acxri.abortIoTag = icmd->ulpIoTag;
9803 	iabt->ulpLe = 1;
9804 	iabt->ulpClass = icmd->ulpClass;
9805 
9806 	/* ABTS WQE must go to the same WQ as the WQE to be aborted */
9807 	abtsiocbp->fcp_wqidx = cmdiocb->fcp_wqidx;
9808 	if (cmdiocb->iocb_flag & LPFC_IO_FCP)
9809 		abtsiocbp->iocb_flag |= LPFC_USE_FCPWQIDX;
9810 	if (cmdiocb->iocb_flag & LPFC_IO_FOF)
9811 		abtsiocbp->iocb_flag |= LPFC_IO_FOF;
9812 
9813 	if (phba->link_state >= LPFC_LINK_UP)
9814 		iabt->ulpCommand = CMD_ABORT_XRI_CN;
9815 	else
9816 		iabt->ulpCommand = CMD_CLOSE_XRI_CN;
9817 
9818 	abtsiocbp->iocb_cmpl = lpfc_sli_abort_els_cmpl;
9819 
9820 	lpfc_printf_vlog(vport, KERN_INFO, LOG_SLI,
9821 			 "0339 Abort xri x%x, original iotag x%x, "
9822 			 "abort cmd iotag x%x\n",
9823 			 iabt->un.acxri.abortIoTag,
9824 			 iabt->un.acxri.abortContextTag,
9825 			 abtsiocbp->iotag);
9826 
9827 	if (phba->sli_rev == LPFC_SLI_REV4) {
9828 		ring_number =
9829 			lpfc_sli_calc_ring(phba, pring->ringno, abtsiocbp);
9830 		if (unlikely(ring_number == LPFC_HBA_ERROR))
9831 			return 0;
9832 		pring = &phba->sli.ring[ring_number];
9833 		/* Note: both hbalock and ring_lock need to be set here */
9834 		spin_lock_irqsave(&pring->ring_lock, iflags);
9835 		retval = __lpfc_sli_issue_iocb(phba, pring->ringno,
9836 			abtsiocbp, 0);
9837 		spin_unlock_irqrestore(&pring->ring_lock, iflags);
9838 	} else {
9839 		retval = __lpfc_sli_issue_iocb(phba, pring->ringno,
9840 			abtsiocbp, 0);
9841 	}
9842 
9843 	if (retval)
9844 		__lpfc_sli_release_iocbq(phba, abtsiocbp);
9845 
9846 	/*
9847 	 * Caller to this routine should check for IOCB_ERROR
9848 	 * and handle it properly.  This routine no longer removes
9849 	 * iocb off txcmplq and call compl in case of IOCB_ERROR.
9850 	 */
9851 	return retval;
9852 }
9853 
9854 /**
9855  * lpfc_sli_issue_abort_iotag - Abort function for a command iocb
9856  * @phba: Pointer to HBA context object.
9857  * @pring: Pointer to driver SLI ring object.
9858  * @cmdiocb: Pointer to driver command iocb object.
9859  *
9860  * This function issues an abort iocb for the provided command iocb. In case
9861  * of unloading, the abort iocb will not be issued to commands on the ELS
9862  * ring. Instead, the callback function shall be changed to those commands
9863  * so that nothing happens when them finishes. This function is called with
9864  * hbalock held. The function returns 0 when the command iocb is an abort
9865  * request.
9866  **/
9867 int
9868 lpfc_sli_issue_abort_iotag(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
9869 			   struct lpfc_iocbq *cmdiocb)
9870 {
9871 	struct lpfc_vport *vport = cmdiocb->vport;
9872 	int retval = IOCB_ERROR;
9873 	IOCB_t *icmd = NULL;
9874 
9875 	/*
9876 	 * There are certain command types we don't want to abort.  And we
9877 	 * don't want to abort commands that are already in the process of
9878 	 * being aborted.
9879 	 */
9880 	icmd = &cmdiocb->iocb;
9881 	if (icmd->ulpCommand == CMD_ABORT_XRI_CN ||
9882 	    icmd->ulpCommand == CMD_CLOSE_XRI_CN ||
9883 	    (cmdiocb->iocb_flag & LPFC_DRIVER_ABORTED) != 0)
9884 		return 0;
9885 
9886 	/*
9887 	 * If we're unloading, don't abort iocb on the ELS ring, but change
9888 	 * the callback so that nothing happens when it finishes.
9889 	 */
9890 	if ((vport->load_flag & FC_UNLOADING) &&
9891 	    (pring->ringno == LPFC_ELS_RING)) {
9892 		if (cmdiocb->iocb_flag & LPFC_IO_FABRIC)
9893 			cmdiocb->fabric_iocb_cmpl = lpfc_ignore_els_cmpl;
9894 		else
9895 			cmdiocb->iocb_cmpl = lpfc_ignore_els_cmpl;
9896 		goto abort_iotag_exit;
9897 	}
9898 
9899 	/* Now, we try to issue the abort to the cmdiocb out */
9900 	retval = lpfc_sli_abort_iotag_issue(phba, pring, cmdiocb);
9901 
9902 abort_iotag_exit:
9903 	/*
9904 	 * Caller to this routine should check for IOCB_ERROR
9905 	 * and handle it properly.  This routine no longer removes
9906 	 * iocb off txcmplq and call compl in case of IOCB_ERROR.
9907 	 */
9908 	return retval;
9909 }
9910 
9911 /**
9912  * lpfc_sli_hba_iocb_abort - Abort all iocbs to an hba.
9913  * @phba: pointer to lpfc HBA data structure.
9914  *
9915  * This routine will abort all pending and outstanding iocbs to an HBA.
9916  **/
9917 void
9918 lpfc_sli_hba_iocb_abort(struct lpfc_hba *phba)
9919 {
9920 	struct lpfc_sli *psli = &phba->sli;
9921 	struct lpfc_sli_ring *pring;
9922 	int i;
9923 
9924 	for (i = 0; i < psli->num_rings; i++) {
9925 		pring = &psli->ring[i];
9926 		lpfc_sli_abort_iocb_ring(phba, pring);
9927 	}
9928 }
9929 
9930 /**
9931  * lpfc_sli_validate_fcp_iocb - find commands associated with a vport or LUN
9932  * @iocbq: Pointer to driver iocb object.
9933  * @vport: Pointer to driver virtual port object.
9934  * @tgt_id: SCSI ID of the target.
9935  * @lun_id: LUN ID of the scsi device.
9936  * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST
9937  *
9938  * This function acts as an iocb filter for functions which abort or count
9939  * all FCP iocbs pending on a lun/SCSI target/SCSI host. It will return
9940  * 0 if the filtering criteria is met for the given iocb and will return
9941  * 1 if the filtering criteria is not met.
9942  * If ctx_cmd == LPFC_CTX_LUN, the function returns 0 only if the
9943  * given iocb is for the SCSI device specified by vport, tgt_id and
9944  * lun_id parameter.
9945  * If ctx_cmd == LPFC_CTX_TGT,  the function returns 0 only if the
9946  * given iocb is for the SCSI target specified by vport and tgt_id
9947  * parameters.
9948  * If ctx_cmd == LPFC_CTX_HOST, the function returns 0 only if the
9949  * given iocb is for the SCSI host associated with the given vport.
9950  * This function is called with no locks held.
9951  **/
9952 static int
9953 lpfc_sli_validate_fcp_iocb(struct lpfc_iocbq *iocbq, struct lpfc_vport *vport,
9954 			   uint16_t tgt_id, uint64_t lun_id,
9955 			   lpfc_ctx_cmd ctx_cmd)
9956 {
9957 	struct lpfc_scsi_buf *lpfc_cmd;
9958 	int rc = 1;
9959 
9960 	if (!(iocbq->iocb_flag &  LPFC_IO_FCP))
9961 		return rc;
9962 
9963 	if (iocbq->vport != vport)
9964 		return rc;
9965 
9966 	lpfc_cmd = container_of(iocbq, struct lpfc_scsi_buf, cur_iocbq);
9967 
9968 	if (lpfc_cmd->pCmd == NULL)
9969 		return rc;
9970 
9971 	switch (ctx_cmd) {
9972 	case LPFC_CTX_LUN:
9973 		if ((lpfc_cmd->rdata->pnode) &&
9974 		    (lpfc_cmd->rdata->pnode->nlp_sid == tgt_id) &&
9975 		    (scsilun_to_int(&lpfc_cmd->fcp_cmnd->fcp_lun) == lun_id))
9976 			rc = 0;
9977 		break;
9978 	case LPFC_CTX_TGT:
9979 		if ((lpfc_cmd->rdata->pnode) &&
9980 		    (lpfc_cmd->rdata->pnode->nlp_sid == tgt_id))
9981 			rc = 0;
9982 		break;
9983 	case LPFC_CTX_HOST:
9984 		rc = 0;
9985 		break;
9986 	default:
9987 		printk(KERN_ERR "%s: Unknown context cmd type, value %d\n",
9988 			__func__, ctx_cmd);
9989 		break;
9990 	}
9991 
9992 	return rc;
9993 }
9994 
9995 /**
9996  * lpfc_sli_sum_iocb - Function to count the number of FCP iocbs pending
9997  * @vport: Pointer to virtual port.
9998  * @tgt_id: SCSI ID of the target.
9999  * @lun_id: LUN ID of the scsi device.
10000  * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
10001  *
10002  * This function returns number of FCP commands pending for the vport.
10003  * When ctx_cmd == LPFC_CTX_LUN, the function returns number of FCP
10004  * commands pending on the vport associated with SCSI device specified
10005  * by tgt_id and lun_id parameters.
10006  * When ctx_cmd == LPFC_CTX_TGT, the function returns number of FCP
10007  * commands pending on the vport associated with SCSI target specified
10008  * by tgt_id parameter.
10009  * When ctx_cmd == LPFC_CTX_HOST, the function returns number of FCP
10010  * commands pending on the vport.
10011  * This function returns the number of iocbs which satisfy the filter.
10012  * This function is called without any lock held.
10013  **/
10014 int
10015 lpfc_sli_sum_iocb(struct lpfc_vport *vport, uint16_t tgt_id, uint64_t lun_id,
10016 		  lpfc_ctx_cmd ctx_cmd)
10017 {
10018 	struct lpfc_hba *phba = vport->phba;
10019 	struct lpfc_iocbq *iocbq;
10020 	int sum, i;
10021 
10022 	for (i = 1, sum = 0; i <= phba->sli.last_iotag; i++) {
10023 		iocbq = phba->sli.iocbq_lookup[i];
10024 
10025 		if (lpfc_sli_validate_fcp_iocb (iocbq, vport, tgt_id, lun_id,
10026 						ctx_cmd) == 0)
10027 			sum++;
10028 	}
10029 
10030 	return sum;
10031 }
10032 
10033 /**
10034  * lpfc_sli_abort_fcp_cmpl - Completion handler function for aborted FCP IOCBs
10035  * @phba: Pointer to HBA context object
10036  * @cmdiocb: Pointer to command iocb object.
10037  * @rspiocb: Pointer to response iocb object.
10038  *
10039  * This function is called when an aborted FCP iocb completes. This
10040  * function is called by the ring event handler with no lock held.
10041  * This function frees the iocb.
10042  **/
10043 void
10044 lpfc_sli_abort_fcp_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
10045 			struct lpfc_iocbq *rspiocb)
10046 {
10047 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
10048 			"3096 ABORT_XRI_CN completing on rpi x%x "
10049 			"original iotag x%x, abort cmd iotag x%x "
10050 			"status 0x%x, reason 0x%x\n",
10051 			cmdiocb->iocb.un.acxri.abortContextTag,
10052 			cmdiocb->iocb.un.acxri.abortIoTag,
10053 			cmdiocb->iotag, rspiocb->iocb.ulpStatus,
10054 			rspiocb->iocb.un.ulpWord[4]);
10055 	lpfc_sli_release_iocbq(phba, cmdiocb);
10056 	return;
10057 }
10058 
10059 /**
10060  * lpfc_sli_abort_iocb - issue abort for all commands on a host/target/LUN
10061  * @vport: Pointer to virtual port.
10062  * @pring: Pointer to driver SLI ring object.
10063  * @tgt_id: SCSI ID of the target.
10064  * @lun_id: LUN ID of the scsi device.
10065  * @abort_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
10066  *
10067  * This function sends an abort command for every SCSI command
10068  * associated with the given virtual port pending on the ring
10069  * filtered by lpfc_sli_validate_fcp_iocb function.
10070  * When abort_cmd == LPFC_CTX_LUN, the function sends abort only to the
10071  * FCP iocbs associated with lun specified by tgt_id and lun_id
10072  * parameters
10073  * When abort_cmd == LPFC_CTX_TGT, the function sends abort only to the
10074  * FCP iocbs associated with SCSI target specified by tgt_id parameter.
10075  * When abort_cmd == LPFC_CTX_HOST, the function sends abort to all
10076  * FCP iocbs associated with virtual port.
10077  * This function returns number of iocbs it failed to abort.
10078  * This function is called with no locks held.
10079  **/
10080 int
10081 lpfc_sli_abort_iocb(struct lpfc_vport *vport, struct lpfc_sli_ring *pring,
10082 		    uint16_t tgt_id, uint64_t lun_id, lpfc_ctx_cmd abort_cmd)
10083 {
10084 	struct lpfc_hba *phba = vport->phba;
10085 	struct lpfc_iocbq *iocbq;
10086 	struct lpfc_iocbq *abtsiocb;
10087 	IOCB_t *cmd = NULL;
10088 	int errcnt = 0, ret_val = 0;
10089 	int i;
10090 
10091 	for (i = 1; i <= phba->sli.last_iotag; i++) {
10092 		iocbq = phba->sli.iocbq_lookup[i];
10093 
10094 		if (lpfc_sli_validate_fcp_iocb(iocbq, vport, tgt_id, lun_id,
10095 					       abort_cmd) != 0)
10096 			continue;
10097 
10098 		/*
10099 		 * If the iocbq is already being aborted, don't take a second
10100 		 * action, but do count it.
10101 		 */
10102 		if (iocbq->iocb_flag & LPFC_DRIVER_ABORTED)
10103 			continue;
10104 
10105 		/* issue ABTS for this IOCB based on iotag */
10106 		abtsiocb = lpfc_sli_get_iocbq(phba);
10107 		if (abtsiocb == NULL) {
10108 			errcnt++;
10109 			continue;
10110 		}
10111 
10112 		/* indicate the IO is being aborted by the driver. */
10113 		iocbq->iocb_flag |= LPFC_DRIVER_ABORTED;
10114 
10115 		cmd = &iocbq->iocb;
10116 		abtsiocb->iocb.un.acxri.abortType = ABORT_TYPE_ABTS;
10117 		abtsiocb->iocb.un.acxri.abortContextTag = cmd->ulpContext;
10118 		if (phba->sli_rev == LPFC_SLI_REV4)
10119 			abtsiocb->iocb.un.acxri.abortIoTag = iocbq->sli4_xritag;
10120 		else
10121 			abtsiocb->iocb.un.acxri.abortIoTag = cmd->ulpIoTag;
10122 		abtsiocb->iocb.ulpLe = 1;
10123 		abtsiocb->iocb.ulpClass = cmd->ulpClass;
10124 		abtsiocb->vport = vport;
10125 
10126 		/* ABTS WQE must go to the same WQ as the WQE to be aborted */
10127 		abtsiocb->fcp_wqidx = iocbq->fcp_wqidx;
10128 		if (iocbq->iocb_flag & LPFC_IO_FCP)
10129 			abtsiocb->iocb_flag |= LPFC_USE_FCPWQIDX;
10130 		if (iocbq->iocb_flag & LPFC_IO_FOF)
10131 			abtsiocb->iocb_flag |= LPFC_IO_FOF;
10132 
10133 		if (lpfc_is_link_up(phba))
10134 			abtsiocb->iocb.ulpCommand = CMD_ABORT_XRI_CN;
10135 		else
10136 			abtsiocb->iocb.ulpCommand = CMD_CLOSE_XRI_CN;
10137 
10138 		/* Setup callback routine and issue the command. */
10139 		abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
10140 		ret_val = lpfc_sli_issue_iocb(phba, pring->ringno,
10141 					      abtsiocb, 0);
10142 		if (ret_val == IOCB_ERROR) {
10143 			lpfc_sli_release_iocbq(phba, abtsiocb);
10144 			errcnt++;
10145 			continue;
10146 		}
10147 	}
10148 
10149 	return errcnt;
10150 }
10151 
10152 /**
10153  * lpfc_sli_abort_taskmgmt - issue abort for all commands on a host/target/LUN
10154  * @vport: Pointer to virtual port.
10155  * @pring: Pointer to driver SLI ring object.
10156  * @tgt_id: SCSI ID of the target.
10157  * @lun_id: LUN ID of the scsi device.
10158  * @taskmgmt_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
10159  *
10160  * This function sends an abort command for every SCSI command
10161  * associated with the given virtual port pending on the ring
10162  * filtered by lpfc_sli_validate_fcp_iocb function.
10163  * When taskmgmt_cmd == LPFC_CTX_LUN, the function sends abort only to the
10164  * FCP iocbs associated with lun specified by tgt_id and lun_id
10165  * parameters
10166  * When taskmgmt_cmd == LPFC_CTX_TGT, the function sends abort only to the
10167  * FCP iocbs associated with SCSI target specified by tgt_id parameter.
10168  * When taskmgmt_cmd == LPFC_CTX_HOST, the function sends abort to all
10169  * FCP iocbs associated with virtual port.
10170  * This function returns number of iocbs it aborted .
10171  * This function is called with no locks held right after a taskmgmt
10172  * command is sent.
10173  **/
10174 int
10175 lpfc_sli_abort_taskmgmt(struct lpfc_vport *vport, struct lpfc_sli_ring *pring,
10176 			uint16_t tgt_id, uint64_t lun_id, lpfc_ctx_cmd cmd)
10177 {
10178 	struct lpfc_hba *phba = vport->phba;
10179 	struct lpfc_scsi_buf *lpfc_cmd;
10180 	struct lpfc_iocbq *abtsiocbq;
10181 	struct lpfc_nodelist *ndlp;
10182 	struct lpfc_iocbq *iocbq;
10183 	IOCB_t *icmd;
10184 	int sum, i, ret_val;
10185 	unsigned long iflags;
10186 	struct lpfc_sli_ring *pring_s4;
10187 	uint32_t ring_number;
10188 
10189 	spin_lock_irq(&phba->hbalock);
10190 
10191 	/* all I/Os are in process of being flushed */
10192 	if (phba->hba_flag & HBA_FCP_IOQ_FLUSH) {
10193 		spin_unlock_irq(&phba->hbalock);
10194 		return 0;
10195 	}
10196 	sum = 0;
10197 
10198 	for (i = 1; i <= phba->sli.last_iotag; i++) {
10199 		iocbq = phba->sli.iocbq_lookup[i];
10200 
10201 		if (lpfc_sli_validate_fcp_iocb(iocbq, vport, tgt_id, lun_id,
10202 					       cmd) != 0)
10203 			continue;
10204 
10205 		/*
10206 		 * If the iocbq is already being aborted, don't take a second
10207 		 * action, but do count it.
10208 		 */
10209 		if (iocbq->iocb_flag & LPFC_DRIVER_ABORTED)
10210 			continue;
10211 
10212 		/* issue ABTS for this IOCB based on iotag */
10213 		abtsiocbq = __lpfc_sli_get_iocbq(phba);
10214 		if (abtsiocbq == NULL)
10215 			continue;
10216 
10217 		icmd = &iocbq->iocb;
10218 		abtsiocbq->iocb.un.acxri.abortType = ABORT_TYPE_ABTS;
10219 		abtsiocbq->iocb.un.acxri.abortContextTag = icmd->ulpContext;
10220 		if (phba->sli_rev == LPFC_SLI_REV4)
10221 			abtsiocbq->iocb.un.acxri.abortIoTag =
10222 							 iocbq->sli4_xritag;
10223 		else
10224 			abtsiocbq->iocb.un.acxri.abortIoTag = icmd->ulpIoTag;
10225 		abtsiocbq->iocb.ulpLe = 1;
10226 		abtsiocbq->iocb.ulpClass = icmd->ulpClass;
10227 		abtsiocbq->vport = vport;
10228 
10229 		/* ABTS WQE must go to the same WQ as the WQE to be aborted */
10230 		abtsiocbq->fcp_wqidx = iocbq->fcp_wqidx;
10231 		if (iocbq->iocb_flag & LPFC_IO_FCP)
10232 			abtsiocbq->iocb_flag |= LPFC_USE_FCPWQIDX;
10233 		if (iocbq->iocb_flag & LPFC_IO_FOF)
10234 			abtsiocbq->iocb_flag |= LPFC_IO_FOF;
10235 
10236 		lpfc_cmd = container_of(iocbq, struct lpfc_scsi_buf, cur_iocbq);
10237 		ndlp = lpfc_cmd->rdata->pnode;
10238 
10239 		if (lpfc_is_link_up(phba) &&
10240 		    (ndlp && ndlp->nlp_state == NLP_STE_MAPPED_NODE))
10241 			abtsiocbq->iocb.ulpCommand = CMD_ABORT_XRI_CN;
10242 		else
10243 			abtsiocbq->iocb.ulpCommand = CMD_CLOSE_XRI_CN;
10244 
10245 		/* Setup callback routine and issue the command. */
10246 		abtsiocbq->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
10247 
10248 		/*
10249 		 * Indicate the IO is being aborted by the driver and set
10250 		 * the caller's flag into the aborted IO.
10251 		 */
10252 		iocbq->iocb_flag |= LPFC_DRIVER_ABORTED;
10253 
10254 		if (phba->sli_rev == LPFC_SLI_REV4) {
10255 			ring_number = MAX_SLI3_CONFIGURED_RINGS +
10256 					 iocbq->fcp_wqidx;
10257 			pring_s4 = &phba->sli.ring[ring_number];
10258 			/* Note: both hbalock and ring_lock must be set here */
10259 			spin_lock_irqsave(&pring_s4->ring_lock, iflags);
10260 			ret_val = __lpfc_sli_issue_iocb(phba, pring_s4->ringno,
10261 							abtsiocbq, 0);
10262 			spin_unlock_irqrestore(&pring_s4->ring_lock, iflags);
10263 		} else {
10264 			ret_val = __lpfc_sli_issue_iocb(phba, pring->ringno,
10265 							abtsiocbq, 0);
10266 		}
10267 
10268 
10269 		if (ret_val == IOCB_ERROR)
10270 			__lpfc_sli_release_iocbq(phba, abtsiocbq);
10271 		else
10272 			sum++;
10273 	}
10274 	spin_unlock_irq(&phba->hbalock);
10275 	return sum;
10276 }
10277 
10278 /**
10279  * lpfc_sli_wake_iocb_wait - lpfc_sli_issue_iocb_wait's completion handler
10280  * @phba: Pointer to HBA context object.
10281  * @cmdiocbq: Pointer to command iocb.
10282  * @rspiocbq: Pointer to response iocb.
10283  *
10284  * This function is the completion handler for iocbs issued using
10285  * lpfc_sli_issue_iocb_wait function. This function is called by the
10286  * ring event handler function without any lock held. This function
10287  * can be called from both worker thread context and interrupt
10288  * context. This function also can be called from other thread which
10289  * cleans up the SLI layer objects.
10290  * This function copy the contents of the response iocb to the
10291  * response iocb memory object provided by the caller of
10292  * lpfc_sli_issue_iocb_wait and then wakes up the thread which
10293  * sleeps for the iocb completion.
10294  **/
10295 static void
10296 lpfc_sli_wake_iocb_wait(struct lpfc_hba *phba,
10297 			struct lpfc_iocbq *cmdiocbq,
10298 			struct lpfc_iocbq *rspiocbq)
10299 {
10300 	wait_queue_head_t *pdone_q;
10301 	unsigned long iflags;
10302 	struct lpfc_scsi_buf *lpfc_cmd;
10303 
10304 	spin_lock_irqsave(&phba->hbalock, iflags);
10305 	if (cmdiocbq->iocb_flag & LPFC_IO_WAKE_TMO) {
10306 
10307 		/*
10308 		 * A time out has occurred for the iocb.  If a time out
10309 		 * completion handler has been supplied, call it.  Otherwise,
10310 		 * just free the iocbq.
10311 		 */
10312 
10313 		spin_unlock_irqrestore(&phba->hbalock, iflags);
10314 		cmdiocbq->iocb_cmpl = cmdiocbq->wait_iocb_cmpl;
10315 		cmdiocbq->wait_iocb_cmpl = NULL;
10316 		if (cmdiocbq->iocb_cmpl)
10317 			(cmdiocbq->iocb_cmpl)(phba, cmdiocbq, NULL);
10318 		else
10319 			lpfc_sli_release_iocbq(phba, cmdiocbq);
10320 		return;
10321 	}
10322 
10323 	cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
10324 	if (cmdiocbq->context2 && rspiocbq)
10325 		memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
10326 		       &rspiocbq->iocb, sizeof(IOCB_t));
10327 
10328 	/* Set the exchange busy flag for task management commands */
10329 	if ((cmdiocbq->iocb_flag & LPFC_IO_FCP) &&
10330 		!(cmdiocbq->iocb_flag & LPFC_IO_LIBDFC)) {
10331 		lpfc_cmd = container_of(cmdiocbq, struct lpfc_scsi_buf,
10332 			cur_iocbq);
10333 		lpfc_cmd->exch_busy = rspiocbq->iocb_flag & LPFC_EXCHANGE_BUSY;
10334 	}
10335 
10336 	pdone_q = cmdiocbq->context_un.wait_queue;
10337 	if (pdone_q)
10338 		wake_up(pdone_q);
10339 	spin_unlock_irqrestore(&phba->hbalock, iflags);
10340 	return;
10341 }
10342 
10343 /**
10344  * lpfc_chk_iocb_flg - Test IOCB flag with lock held.
10345  * @phba: Pointer to HBA context object..
10346  * @piocbq: Pointer to command iocb.
10347  * @flag: Flag to test.
10348  *
10349  * This routine grabs the hbalock and then test the iocb_flag to
10350  * see if the passed in flag is set.
10351  * Returns:
10352  * 1 if flag is set.
10353  * 0 if flag is not set.
10354  **/
10355 static int
10356 lpfc_chk_iocb_flg(struct lpfc_hba *phba,
10357 		 struct lpfc_iocbq *piocbq, uint32_t flag)
10358 {
10359 	unsigned long iflags;
10360 	int ret;
10361 
10362 	spin_lock_irqsave(&phba->hbalock, iflags);
10363 	ret = piocbq->iocb_flag & flag;
10364 	spin_unlock_irqrestore(&phba->hbalock, iflags);
10365 	return ret;
10366 
10367 }
10368 
10369 /**
10370  * lpfc_sli_issue_iocb_wait - Synchronous function to issue iocb commands
10371  * @phba: Pointer to HBA context object..
10372  * @pring: Pointer to sli ring.
10373  * @piocb: Pointer to command iocb.
10374  * @prspiocbq: Pointer to response iocb.
10375  * @timeout: Timeout in number of seconds.
10376  *
10377  * This function issues the iocb to firmware and waits for the
10378  * iocb to complete. The iocb_cmpl field of the shall be used
10379  * to handle iocbs which time out. If the field is NULL, the
10380  * function shall free the iocbq structure.  If more clean up is
10381  * needed, the caller is expected to provide a completion function
10382  * that will provide the needed clean up.  If the iocb command is
10383  * not completed within timeout seconds, the function will either
10384  * free the iocbq structure (if iocb_cmpl == NULL) or execute the
10385  * completion function set in the iocb_cmpl field and then return
10386  * a status of IOCB_TIMEDOUT.  The caller should not free the iocb
10387  * resources if this function returns IOCB_TIMEDOUT.
10388  * The function waits for the iocb completion using an
10389  * non-interruptible wait.
10390  * This function will sleep while waiting for iocb completion.
10391  * So, this function should not be called from any context which
10392  * does not allow sleeping. Due to the same reason, this function
10393  * cannot be called with interrupt disabled.
10394  * This function assumes that the iocb completions occur while
10395  * this function sleep. So, this function cannot be called from
10396  * the thread which process iocb completion for this ring.
10397  * This function clears the iocb_flag of the iocb object before
10398  * issuing the iocb and the iocb completion handler sets this
10399  * flag and wakes this thread when the iocb completes.
10400  * The contents of the response iocb will be copied to prspiocbq
10401  * by the completion handler when the command completes.
10402  * This function returns IOCB_SUCCESS when success.
10403  * This function is called with no lock held.
10404  **/
10405 int
10406 lpfc_sli_issue_iocb_wait(struct lpfc_hba *phba,
10407 			 uint32_t ring_number,
10408 			 struct lpfc_iocbq *piocb,
10409 			 struct lpfc_iocbq *prspiocbq,
10410 			 uint32_t timeout)
10411 {
10412 	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q);
10413 	long timeleft, timeout_req = 0;
10414 	int retval = IOCB_SUCCESS;
10415 	uint32_t creg_val;
10416 	struct lpfc_iocbq *iocb;
10417 	int txq_cnt = 0;
10418 	int txcmplq_cnt = 0;
10419 	struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
10420 	unsigned long iflags;
10421 	bool iocb_completed = true;
10422 
10423 	/*
10424 	 * If the caller has provided a response iocbq buffer, then context2
10425 	 * is NULL or its an error.
10426 	 */
10427 	if (prspiocbq) {
10428 		if (piocb->context2)
10429 			return IOCB_ERROR;
10430 		piocb->context2 = prspiocbq;
10431 	}
10432 
10433 	piocb->wait_iocb_cmpl = piocb->iocb_cmpl;
10434 	piocb->iocb_cmpl = lpfc_sli_wake_iocb_wait;
10435 	piocb->context_un.wait_queue = &done_q;
10436 	piocb->iocb_flag &= ~(LPFC_IO_WAKE | LPFC_IO_WAKE_TMO);
10437 
10438 	if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
10439 		if (lpfc_readl(phba->HCregaddr, &creg_val))
10440 			return IOCB_ERROR;
10441 		creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
10442 		writel(creg_val, phba->HCregaddr);
10443 		readl(phba->HCregaddr); /* flush */
10444 	}
10445 
10446 	retval = lpfc_sli_issue_iocb(phba, ring_number, piocb,
10447 				     SLI_IOCB_RET_IOCB);
10448 	if (retval == IOCB_SUCCESS) {
10449 		timeout_req = msecs_to_jiffies(timeout * 1000);
10450 		timeleft = wait_event_timeout(done_q,
10451 				lpfc_chk_iocb_flg(phba, piocb, LPFC_IO_WAKE),
10452 				timeout_req);
10453 		spin_lock_irqsave(&phba->hbalock, iflags);
10454 		if (!(piocb->iocb_flag & LPFC_IO_WAKE)) {
10455 
10456 			/*
10457 			 * IOCB timed out.  Inform the wake iocb wait
10458 			 * completion function and set local status
10459 			 */
10460 
10461 			iocb_completed = false;
10462 			piocb->iocb_flag |= LPFC_IO_WAKE_TMO;
10463 		}
10464 		spin_unlock_irqrestore(&phba->hbalock, iflags);
10465 		if (iocb_completed) {
10466 			lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
10467 					"0331 IOCB wake signaled\n");
10468 			/* Note: we are not indicating if the IOCB has a success
10469 			 * status or not - that's for the caller to check.
10470 			 * IOCB_SUCCESS means just that the command was sent and
10471 			 * completed. Not that it completed successfully.
10472 			 * */
10473 		} else if (timeleft == 0) {
10474 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
10475 					"0338 IOCB wait timeout error - no "
10476 					"wake response Data x%x\n", timeout);
10477 			retval = IOCB_TIMEDOUT;
10478 		} else {
10479 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
10480 					"0330 IOCB wake NOT set, "
10481 					"Data x%x x%lx\n",
10482 					timeout, (timeleft / jiffies));
10483 			retval = IOCB_TIMEDOUT;
10484 		}
10485 	} else if (retval == IOCB_BUSY) {
10486 		if (phba->cfg_log_verbose & LOG_SLI) {
10487 			list_for_each_entry(iocb, &pring->txq, list) {
10488 				txq_cnt++;
10489 			}
10490 			list_for_each_entry(iocb, &pring->txcmplq, list) {
10491 				txcmplq_cnt++;
10492 			}
10493 			lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
10494 				"2818 Max IOCBs %d txq cnt %d txcmplq cnt %d\n",
10495 				phba->iocb_cnt, txq_cnt, txcmplq_cnt);
10496 		}
10497 		return retval;
10498 	} else {
10499 		lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
10500 				"0332 IOCB wait issue failed, Data x%x\n",
10501 				retval);
10502 		retval = IOCB_ERROR;
10503 	}
10504 
10505 	if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
10506 		if (lpfc_readl(phba->HCregaddr, &creg_val))
10507 			return IOCB_ERROR;
10508 		creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
10509 		writel(creg_val, phba->HCregaddr);
10510 		readl(phba->HCregaddr); /* flush */
10511 	}
10512 
10513 	if (prspiocbq)
10514 		piocb->context2 = NULL;
10515 
10516 	piocb->context_un.wait_queue = NULL;
10517 	piocb->iocb_cmpl = NULL;
10518 	return retval;
10519 }
10520 
10521 /**
10522  * lpfc_sli_issue_mbox_wait - Synchronous function to issue mailbox
10523  * @phba: Pointer to HBA context object.
10524  * @pmboxq: Pointer to driver mailbox object.
10525  * @timeout: Timeout in number of seconds.
10526  *
10527  * This function issues the mailbox to firmware and waits for the
10528  * mailbox command to complete. If the mailbox command is not
10529  * completed within timeout seconds, it returns MBX_TIMEOUT.
10530  * The function waits for the mailbox completion using an
10531  * interruptible wait. If the thread is woken up due to a
10532  * signal, MBX_TIMEOUT error is returned to the caller. Caller
10533  * should not free the mailbox resources, if this function returns
10534  * MBX_TIMEOUT.
10535  * This function will sleep while waiting for mailbox completion.
10536  * So, this function should not be called from any context which
10537  * does not allow sleeping. Due to the same reason, this function
10538  * cannot be called with interrupt disabled.
10539  * This function assumes that the mailbox completion occurs while
10540  * this function sleep. So, this function cannot be called from
10541  * the worker thread which processes mailbox completion.
10542  * This function is called in the context of HBA management
10543  * applications.
10544  * This function returns MBX_SUCCESS when successful.
10545  * This function is called with no lock held.
10546  **/
10547 int
10548 lpfc_sli_issue_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq,
10549 			 uint32_t timeout)
10550 {
10551 	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q);
10552 	MAILBOX_t *mb = NULL;
10553 	int retval;
10554 	unsigned long flag;
10555 
10556 	/* The caller might set context1 for extended buffer */
10557 	if (pmboxq->context1)
10558 		mb = (MAILBOX_t *)pmboxq->context1;
10559 
10560 	pmboxq->mbox_flag &= ~LPFC_MBX_WAKE;
10561 	/* setup wake call as IOCB callback */
10562 	pmboxq->mbox_cmpl = lpfc_sli_wake_mbox_wait;
10563 	/* setup context field to pass wait_queue pointer to wake function  */
10564 	pmboxq->context1 = &done_q;
10565 
10566 	/* now issue the command */
10567 	retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
10568 	if (retval == MBX_BUSY || retval == MBX_SUCCESS) {
10569 		wait_event_interruptible_timeout(done_q,
10570 				pmboxq->mbox_flag & LPFC_MBX_WAKE,
10571 				msecs_to_jiffies(timeout * 1000));
10572 
10573 		spin_lock_irqsave(&phba->hbalock, flag);
10574 		/* restore the possible extended buffer for free resource */
10575 		pmboxq->context1 = (uint8_t *)mb;
10576 		/*
10577 		 * if LPFC_MBX_WAKE flag is set the mailbox is completed
10578 		 * else do not free the resources.
10579 		 */
10580 		if (pmboxq->mbox_flag & LPFC_MBX_WAKE) {
10581 			retval = MBX_SUCCESS;
10582 		} else {
10583 			retval = MBX_TIMEOUT;
10584 			pmboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
10585 		}
10586 		spin_unlock_irqrestore(&phba->hbalock, flag);
10587 	} else {
10588 		/* restore the possible extended buffer for free resource */
10589 		pmboxq->context1 = (uint8_t *)mb;
10590 	}
10591 
10592 	return retval;
10593 }
10594 
10595 /**
10596  * lpfc_sli_mbox_sys_shutdown - shutdown mailbox command sub-system
10597  * @phba: Pointer to HBA context.
10598  *
10599  * This function is called to shutdown the driver's mailbox sub-system.
10600  * It first marks the mailbox sub-system is in a block state to prevent
10601  * the asynchronous mailbox command from issued off the pending mailbox
10602  * command queue. If the mailbox command sub-system shutdown is due to
10603  * HBA error conditions such as EEH or ERATT, this routine shall invoke
10604  * the mailbox sub-system flush routine to forcefully bring down the
10605  * mailbox sub-system. Otherwise, if it is due to normal condition (such
10606  * as with offline or HBA function reset), this routine will wait for the
10607  * outstanding mailbox command to complete before invoking the mailbox
10608  * sub-system flush routine to gracefully bring down mailbox sub-system.
10609  **/
10610 void
10611 lpfc_sli_mbox_sys_shutdown(struct lpfc_hba *phba, int mbx_action)
10612 {
10613 	struct lpfc_sli *psli = &phba->sli;
10614 	unsigned long timeout;
10615 
10616 	if (mbx_action == LPFC_MBX_NO_WAIT) {
10617 		/* delay 100ms for port state */
10618 		msleep(100);
10619 		lpfc_sli_mbox_sys_flush(phba);
10620 		return;
10621 	}
10622 	timeout = msecs_to_jiffies(LPFC_MBOX_TMO * 1000) + jiffies;
10623 
10624 	spin_lock_irq(&phba->hbalock);
10625 	psli->sli_flag |= LPFC_SLI_ASYNC_MBX_BLK;
10626 
10627 	if (psli->sli_flag & LPFC_SLI_ACTIVE) {
10628 		/* Determine how long we might wait for the active mailbox
10629 		 * command to be gracefully completed by firmware.
10630 		 */
10631 		if (phba->sli.mbox_active)
10632 			timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba,
10633 						phba->sli.mbox_active) *
10634 						1000) + jiffies;
10635 		spin_unlock_irq(&phba->hbalock);
10636 
10637 		while (phba->sli.mbox_active) {
10638 			/* Check active mailbox complete status every 2ms */
10639 			msleep(2);
10640 			if (time_after(jiffies, timeout))
10641 				/* Timeout, let the mailbox flush routine to
10642 				 * forcefully release active mailbox command
10643 				 */
10644 				break;
10645 		}
10646 	} else
10647 		spin_unlock_irq(&phba->hbalock);
10648 
10649 	lpfc_sli_mbox_sys_flush(phba);
10650 }
10651 
10652 /**
10653  * lpfc_sli_eratt_read - read sli-3 error attention events
10654  * @phba: Pointer to HBA context.
10655  *
10656  * This function is called to read the SLI3 device error attention registers
10657  * for possible error attention events. The caller must hold the hostlock
10658  * with spin_lock_irq().
10659  *
10660  * This function returns 1 when there is Error Attention in the Host Attention
10661  * Register and returns 0 otherwise.
10662  **/
10663 static int
10664 lpfc_sli_eratt_read(struct lpfc_hba *phba)
10665 {
10666 	uint32_t ha_copy;
10667 
10668 	/* Read chip Host Attention (HA) register */
10669 	if (lpfc_readl(phba->HAregaddr, &ha_copy))
10670 		goto unplug_err;
10671 
10672 	if (ha_copy & HA_ERATT) {
10673 		/* Read host status register to retrieve error event */
10674 		if (lpfc_sli_read_hs(phba))
10675 			goto unplug_err;
10676 
10677 		/* Check if there is a deferred error condition is active */
10678 		if ((HS_FFER1 & phba->work_hs) &&
10679 		    ((HS_FFER2 | HS_FFER3 | HS_FFER4 | HS_FFER5 |
10680 		      HS_FFER6 | HS_FFER7 | HS_FFER8) & phba->work_hs)) {
10681 			phba->hba_flag |= DEFER_ERATT;
10682 			/* Clear all interrupt enable conditions */
10683 			writel(0, phba->HCregaddr);
10684 			readl(phba->HCregaddr);
10685 		}
10686 
10687 		/* Set the driver HA work bitmap */
10688 		phba->work_ha |= HA_ERATT;
10689 		/* Indicate polling handles this ERATT */
10690 		phba->hba_flag |= HBA_ERATT_HANDLED;
10691 		return 1;
10692 	}
10693 	return 0;
10694 
10695 unplug_err:
10696 	/* Set the driver HS work bitmap */
10697 	phba->work_hs |= UNPLUG_ERR;
10698 	/* Set the driver HA work bitmap */
10699 	phba->work_ha |= HA_ERATT;
10700 	/* Indicate polling handles this ERATT */
10701 	phba->hba_flag |= HBA_ERATT_HANDLED;
10702 	return 1;
10703 }
10704 
10705 /**
10706  * lpfc_sli4_eratt_read - read sli-4 error attention events
10707  * @phba: Pointer to HBA context.
10708  *
10709  * This function is called to read the SLI4 device error attention registers
10710  * for possible error attention events. The caller must hold the hostlock
10711  * with spin_lock_irq().
10712  *
10713  * This function returns 1 when there is Error Attention in the Host Attention
10714  * Register and returns 0 otherwise.
10715  **/
10716 static int
10717 lpfc_sli4_eratt_read(struct lpfc_hba *phba)
10718 {
10719 	uint32_t uerr_sta_hi, uerr_sta_lo;
10720 	uint32_t if_type, portsmphr;
10721 	struct lpfc_register portstat_reg;
10722 
10723 	/*
10724 	 * For now, use the SLI4 device internal unrecoverable error
10725 	 * registers for error attention. This can be changed later.
10726 	 */
10727 	if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
10728 	switch (if_type) {
10729 	case LPFC_SLI_INTF_IF_TYPE_0:
10730 		if (lpfc_readl(phba->sli4_hba.u.if_type0.UERRLOregaddr,
10731 			&uerr_sta_lo) ||
10732 			lpfc_readl(phba->sli4_hba.u.if_type0.UERRHIregaddr,
10733 			&uerr_sta_hi)) {
10734 			phba->work_hs |= UNPLUG_ERR;
10735 			phba->work_ha |= HA_ERATT;
10736 			phba->hba_flag |= HBA_ERATT_HANDLED;
10737 			return 1;
10738 		}
10739 		if ((~phba->sli4_hba.ue_mask_lo & uerr_sta_lo) ||
10740 		    (~phba->sli4_hba.ue_mask_hi & uerr_sta_hi)) {
10741 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10742 					"1423 HBA Unrecoverable error: "
10743 					"uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, "
10744 					"ue_mask_lo_reg=0x%x, "
10745 					"ue_mask_hi_reg=0x%x\n",
10746 					uerr_sta_lo, uerr_sta_hi,
10747 					phba->sli4_hba.ue_mask_lo,
10748 					phba->sli4_hba.ue_mask_hi);
10749 			phba->work_status[0] = uerr_sta_lo;
10750 			phba->work_status[1] = uerr_sta_hi;
10751 			phba->work_ha |= HA_ERATT;
10752 			phba->hba_flag |= HBA_ERATT_HANDLED;
10753 			return 1;
10754 		}
10755 		break;
10756 	case LPFC_SLI_INTF_IF_TYPE_2:
10757 		if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
10758 			&portstat_reg.word0) ||
10759 			lpfc_readl(phba->sli4_hba.PSMPHRregaddr,
10760 			&portsmphr)){
10761 			phba->work_hs |= UNPLUG_ERR;
10762 			phba->work_ha |= HA_ERATT;
10763 			phba->hba_flag |= HBA_ERATT_HANDLED;
10764 			return 1;
10765 		}
10766 		if (bf_get(lpfc_sliport_status_err, &portstat_reg)) {
10767 			phba->work_status[0] =
10768 				readl(phba->sli4_hba.u.if_type2.ERR1regaddr);
10769 			phba->work_status[1] =
10770 				readl(phba->sli4_hba.u.if_type2.ERR2regaddr);
10771 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10772 					"2885 Port Status Event: "
10773 					"port status reg 0x%x, "
10774 					"port smphr reg 0x%x, "
10775 					"error 1=0x%x, error 2=0x%x\n",
10776 					portstat_reg.word0,
10777 					portsmphr,
10778 					phba->work_status[0],
10779 					phba->work_status[1]);
10780 			phba->work_ha |= HA_ERATT;
10781 			phba->hba_flag |= HBA_ERATT_HANDLED;
10782 			return 1;
10783 		}
10784 		break;
10785 	case LPFC_SLI_INTF_IF_TYPE_1:
10786 	default:
10787 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10788 				"2886 HBA Error Attention on unsupported "
10789 				"if type %d.", if_type);
10790 		return 1;
10791 	}
10792 
10793 	return 0;
10794 }
10795 
10796 /**
10797  * lpfc_sli_check_eratt - check error attention events
10798  * @phba: Pointer to HBA context.
10799  *
10800  * This function is called from timer soft interrupt context to check HBA's
10801  * error attention register bit for error attention events.
10802  *
10803  * This function returns 1 when there is Error Attention in the Host Attention
10804  * Register and returns 0 otherwise.
10805  **/
10806 int
10807 lpfc_sli_check_eratt(struct lpfc_hba *phba)
10808 {
10809 	uint32_t ha_copy;
10810 
10811 	/* If somebody is waiting to handle an eratt, don't process it
10812 	 * here. The brdkill function will do this.
10813 	 */
10814 	if (phba->link_flag & LS_IGNORE_ERATT)
10815 		return 0;
10816 
10817 	/* Check if interrupt handler handles this ERATT */
10818 	spin_lock_irq(&phba->hbalock);
10819 	if (phba->hba_flag & HBA_ERATT_HANDLED) {
10820 		/* Interrupt handler has handled ERATT */
10821 		spin_unlock_irq(&phba->hbalock);
10822 		return 0;
10823 	}
10824 
10825 	/*
10826 	 * If there is deferred error attention, do not check for error
10827 	 * attention
10828 	 */
10829 	if (unlikely(phba->hba_flag & DEFER_ERATT)) {
10830 		spin_unlock_irq(&phba->hbalock);
10831 		return 0;
10832 	}
10833 
10834 	/* If PCI channel is offline, don't process it */
10835 	if (unlikely(pci_channel_offline(phba->pcidev))) {
10836 		spin_unlock_irq(&phba->hbalock);
10837 		return 0;
10838 	}
10839 
10840 	switch (phba->sli_rev) {
10841 	case LPFC_SLI_REV2:
10842 	case LPFC_SLI_REV3:
10843 		/* Read chip Host Attention (HA) register */
10844 		ha_copy = lpfc_sli_eratt_read(phba);
10845 		break;
10846 	case LPFC_SLI_REV4:
10847 		/* Read device Uncoverable Error (UERR) registers */
10848 		ha_copy = lpfc_sli4_eratt_read(phba);
10849 		break;
10850 	default:
10851 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10852 				"0299 Invalid SLI revision (%d)\n",
10853 				phba->sli_rev);
10854 		ha_copy = 0;
10855 		break;
10856 	}
10857 	spin_unlock_irq(&phba->hbalock);
10858 
10859 	return ha_copy;
10860 }
10861 
10862 /**
10863  * lpfc_intr_state_check - Check device state for interrupt handling
10864  * @phba: Pointer to HBA context.
10865  *
10866  * This inline routine checks whether a device or its PCI slot is in a state
10867  * that the interrupt should be handled.
10868  *
10869  * This function returns 0 if the device or the PCI slot is in a state that
10870  * interrupt should be handled, otherwise -EIO.
10871  */
10872 static inline int
10873 lpfc_intr_state_check(struct lpfc_hba *phba)
10874 {
10875 	/* If the pci channel is offline, ignore all the interrupts */
10876 	if (unlikely(pci_channel_offline(phba->pcidev)))
10877 		return -EIO;
10878 
10879 	/* Update device level interrupt statistics */
10880 	phba->sli.slistat.sli_intr++;
10881 
10882 	/* Ignore all interrupts during initialization. */
10883 	if (unlikely(phba->link_state < LPFC_LINK_DOWN))
10884 		return -EIO;
10885 
10886 	return 0;
10887 }
10888 
10889 /**
10890  * lpfc_sli_sp_intr_handler - Slow-path interrupt handler to SLI-3 device
10891  * @irq: Interrupt number.
10892  * @dev_id: The device context pointer.
10893  *
10894  * This function is directly called from the PCI layer as an interrupt
10895  * service routine when device with SLI-3 interface spec is enabled with
10896  * MSI-X multi-message interrupt mode and there are slow-path events in
10897  * the HBA. However, when the device is enabled with either MSI or Pin-IRQ
10898  * interrupt mode, this function is called as part of the device-level
10899  * interrupt handler. When the PCI slot is in error recovery or the HBA
10900  * is undergoing initialization, the interrupt handler will not process
10901  * the interrupt. The link attention and ELS ring attention events are
10902  * handled by the worker thread. The interrupt handler signals the worker
10903  * thread and returns for these events. This function is called without
10904  * any lock held. It gets the hbalock to access and update SLI data
10905  * structures.
10906  *
10907  * This function returns IRQ_HANDLED when interrupt is handled else it
10908  * returns IRQ_NONE.
10909  **/
10910 irqreturn_t
10911 lpfc_sli_sp_intr_handler(int irq, void *dev_id)
10912 {
10913 	struct lpfc_hba  *phba;
10914 	uint32_t ha_copy, hc_copy;
10915 	uint32_t work_ha_copy;
10916 	unsigned long status;
10917 	unsigned long iflag;
10918 	uint32_t control;
10919 
10920 	MAILBOX_t *mbox, *pmbox;
10921 	struct lpfc_vport *vport;
10922 	struct lpfc_nodelist *ndlp;
10923 	struct lpfc_dmabuf *mp;
10924 	LPFC_MBOXQ_t *pmb;
10925 	int rc;
10926 
10927 	/*
10928 	 * Get the driver's phba structure from the dev_id and
10929 	 * assume the HBA is not interrupting.
10930 	 */
10931 	phba = (struct lpfc_hba *)dev_id;
10932 
10933 	if (unlikely(!phba))
10934 		return IRQ_NONE;
10935 
10936 	/*
10937 	 * Stuff needs to be attented to when this function is invoked as an
10938 	 * individual interrupt handler in MSI-X multi-message interrupt mode
10939 	 */
10940 	if (phba->intr_type == MSIX) {
10941 		/* Check device state for handling interrupt */
10942 		if (lpfc_intr_state_check(phba))
10943 			return IRQ_NONE;
10944 		/* Need to read HA REG for slow-path events */
10945 		spin_lock_irqsave(&phba->hbalock, iflag);
10946 		if (lpfc_readl(phba->HAregaddr, &ha_copy))
10947 			goto unplug_error;
10948 		/* If somebody is waiting to handle an eratt don't process it
10949 		 * here. The brdkill function will do this.
10950 		 */
10951 		if (phba->link_flag & LS_IGNORE_ERATT)
10952 			ha_copy &= ~HA_ERATT;
10953 		/* Check the need for handling ERATT in interrupt handler */
10954 		if (ha_copy & HA_ERATT) {
10955 			if (phba->hba_flag & HBA_ERATT_HANDLED)
10956 				/* ERATT polling has handled ERATT */
10957 				ha_copy &= ~HA_ERATT;
10958 			else
10959 				/* Indicate interrupt handler handles ERATT */
10960 				phba->hba_flag |= HBA_ERATT_HANDLED;
10961 		}
10962 
10963 		/*
10964 		 * If there is deferred error attention, do not check for any
10965 		 * interrupt.
10966 		 */
10967 		if (unlikely(phba->hba_flag & DEFER_ERATT)) {
10968 			spin_unlock_irqrestore(&phba->hbalock, iflag);
10969 			return IRQ_NONE;
10970 		}
10971 
10972 		/* Clear up only attention source related to slow-path */
10973 		if (lpfc_readl(phba->HCregaddr, &hc_copy))
10974 			goto unplug_error;
10975 
10976 		writel(hc_copy & ~(HC_MBINT_ENA | HC_R2INT_ENA |
10977 			HC_LAINT_ENA | HC_ERINT_ENA),
10978 			phba->HCregaddr);
10979 		writel((ha_copy & (HA_MBATT | HA_R2_CLR_MSK)),
10980 			phba->HAregaddr);
10981 		writel(hc_copy, phba->HCregaddr);
10982 		readl(phba->HAregaddr); /* flush */
10983 		spin_unlock_irqrestore(&phba->hbalock, iflag);
10984 	} else
10985 		ha_copy = phba->ha_copy;
10986 
10987 	work_ha_copy = ha_copy & phba->work_ha_mask;
10988 
10989 	if (work_ha_copy) {
10990 		if (work_ha_copy & HA_LATT) {
10991 			if (phba->sli.sli_flag & LPFC_PROCESS_LA) {
10992 				/*
10993 				 * Turn off Link Attention interrupts
10994 				 * until CLEAR_LA done
10995 				 */
10996 				spin_lock_irqsave(&phba->hbalock, iflag);
10997 				phba->sli.sli_flag &= ~LPFC_PROCESS_LA;
10998 				if (lpfc_readl(phba->HCregaddr, &control))
10999 					goto unplug_error;
11000 				control &= ~HC_LAINT_ENA;
11001 				writel(control, phba->HCregaddr);
11002 				readl(phba->HCregaddr); /* flush */
11003 				spin_unlock_irqrestore(&phba->hbalock, iflag);
11004 			}
11005 			else
11006 				work_ha_copy &= ~HA_LATT;
11007 		}
11008 
11009 		if (work_ha_copy & ~(HA_ERATT | HA_MBATT | HA_LATT)) {
11010 			/*
11011 			 * Turn off Slow Rings interrupts, LPFC_ELS_RING is
11012 			 * the only slow ring.
11013 			 */
11014 			status = (work_ha_copy &
11015 				(HA_RXMASK  << (4*LPFC_ELS_RING)));
11016 			status >>= (4*LPFC_ELS_RING);
11017 			if (status & HA_RXMASK) {
11018 				spin_lock_irqsave(&phba->hbalock, iflag);
11019 				if (lpfc_readl(phba->HCregaddr, &control))
11020 					goto unplug_error;
11021 
11022 				lpfc_debugfs_slow_ring_trc(phba,
11023 				"ISR slow ring:   ctl:x%x stat:x%x isrcnt:x%x",
11024 				control, status,
11025 				(uint32_t)phba->sli.slistat.sli_intr);
11026 
11027 				if (control & (HC_R0INT_ENA << LPFC_ELS_RING)) {
11028 					lpfc_debugfs_slow_ring_trc(phba,
11029 						"ISR Disable ring:"
11030 						"pwork:x%x hawork:x%x wait:x%x",
11031 						phba->work_ha, work_ha_copy,
11032 						(uint32_t)((unsigned long)
11033 						&phba->work_waitq));
11034 
11035 					control &=
11036 					    ~(HC_R0INT_ENA << LPFC_ELS_RING);
11037 					writel(control, phba->HCregaddr);
11038 					readl(phba->HCregaddr); /* flush */
11039 				}
11040 				else {
11041 					lpfc_debugfs_slow_ring_trc(phba,
11042 						"ISR slow ring:   pwork:"
11043 						"x%x hawork:x%x wait:x%x",
11044 						phba->work_ha, work_ha_copy,
11045 						(uint32_t)((unsigned long)
11046 						&phba->work_waitq));
11047 				}
11048 				spin_unlock_irqrestore(&phba->hbalock, iflag);
11049 			}
11050 		}
11051 		spin_lock_irqsave(&phba->hbalock, iflag);
11052 		if (work_ha_copy & HA_ERATT) {
11053 			if (lpfc_sli_read_hs(phba))
11054 				goto unplug_error;
11055 			/*
11056 			 * Check if there is a deferred error condition
11057 			 * is active
11058 			 */
11059 			if ((HS_FFER1 & phba->work_hs) &&
11060 				((HS_FFER2 | HS_FFER3 | HS_FFER4 | HS_FFER5 |
11061 				  HS_FFER6 | HS_FFER7 | HS_FFER8) &
11062 				  phba->work_hs)) {
11063 				phba->hba_flag |= DEFER_ERATT;
11064 				/* Clear all interrupt enable conditions */
11065 				writel(0, phba->HCregaddr);
11066 				readl(phba->HCregaddr);
11067 			}
11068 		}
11069 
11070 		if ((work_ha_copy & HA_MBATT) && (phba->sli.mbox_active)) {
11071 			pmb = phba->sli.mbox_active;
11072 			pmbox = &pmb->u.mb;
11073 			mbox = phba->mbox;
11074 			vport = pmb->vport;
11075 
11076 			/* First check out the status word */
11077 			lpfc_sli_pcimem_bcopy(mbox, pmbox, sizeof(uint32_t));
11078 			if (pmbox->mbxOwner != OWN_HOST) {
11079 				spin_unlock_irqrestore(&phba->hbalock, iflag);
11080 				/*
11081 				 * Stray Mailbox Interrupt, mbxCommand <cmd>
11082 				 * mbxStatus <status>
11083 				 */
11084 				lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
11085 						LOG_SLI,
11086 						"(%d):0304 Stray Mailbox "
11087 						"Interrupt mbxCommand x%x "
11088 						"mbxStatus x%x\n",
11089 						(vport ? vport->vpi : 0),
11090 						pmbox->mbxCommand,
11091 						pmbox->mbxStatus);
11092 				/* clear mailbox attention bit */
11093 				work_ha_copy &= ~HA_MBATT;
11094 			} else {
11095 				phba->sli.mbox_active = NULL;
11096 				spin_unlock_irqrestore(&phba->hbalock, iflag);
11097 				phba->last_completion_time = jiffies;
11098 				del_timer(&phba->sli.mbox_tmo);
11099 				if (pmb->mbox_cmpl) {
11100 					lpfc_sli_pcimem_bcopy(mbox, pmbox,
11101 							MAILBOX_CMD_SIZE);
11102 					if (pmb->out_ext_byte_len &&
11103 						pmb->context2)
11104 						lpfc_sli_pcimem_bcopy(
11105 						phba->mbox_ext,
11106 						pmb->context2,
11107 						pmb->out_ext_byte_len);
11108 				}
11109 				if (pmb->mbox_flag & LPFC_MBX_IMED_UNREG) {
11110 					pmb->mbox_flag &= ~LPFC_MBX_IMED_UNREG;
11111 
11112 					lpfc_debugfs_disc_trc(vport,
11113 						LPFC_DISC_TRC_MBOX_VPORT,
11114 						"MBOX dflt rpi: : "
11115 						"status:x%x rpi:x%x",
11116 						(uint32_t)pmbox->mbxStatus,
11117 						pmbox->un.varWords[0], 0);
11118 
11119 					if (!pmbox->mbxStatus) {
11120 						mp = (struct lpfc_dmabuf *)
11121 							(pmb->context1);
11122 						ndlp = (struct lpfc_nodelist *)
11123 							pmb->context2;
11124 
11125 						/* Reg_LOGIN of dflt RPI was
11126 						 * successful. new lets get
11127 						 * rid of the RPI using the
11128 						 * same mbox buffer.
11129 						 */
11130 						lpfc_unreg_login(phba,
11131 							vport->vpi,
11132 							pmbox->un.varWords[0],
11133 							pmb);
11134 						pmb->mbox_cmpl =
11135 							lpfc_mbx_cmpl_dflt_rpi;
11136 						pmb->context1 = mp;
11137 						pmb->context2 = ndlp;
11138 						pmb->vport = vport;
11139 						rc = lpfc_sli_issue_mbox(phba,
11140 								pmb,
11141 								MBX_NOWAIT);
11142 						if (rc != MBX_BUSY)
11143 							lpfc_printf_log(phba,
11144 							KERN_ERR,
11145 							LOG_MBOX | LOG_SLI,
11146 							"0350 rc should have"
11147 							"been MBX_BUSY\n");
11148 						if (rc != MBX_NOT_FINISHED)
11149 							goto send_current_mbox;
11150 					}
11151 				}
11152 				spin_lock_irqsave(
11153 						&phba->pport->work_port_lock,
11154 						iflag);
11155 				phba->pport->work_port_events &=
11156 					~WORKER_MBOX_TMO;
11157 				spin_unlock_irqrestore(
11158 						&phba->pport->work_port_lock,
11159 						iflag);
11160 				lpfc_mbox_cmpl_put(phba, pmb);
11161 			}
11162 		} else
11163 			spin_unlock_irqrestore(&phba->hbalock, iflag);
11164 
11165 		if ((work_ha_copy & HA_MBATT) &&
11166 		    (phba->sli.mbox_active == NULL)) {
11167 send_current_mbox:
11168 			/* Process next mailbox command if there is one */
11169 			do {
11170 				rc = lpfc_sli_issue_mbox(phba, NULL,
11171 							 MBX_NOWAIT);
11172 			} while (rc == MBX_NOT_FINISHED);
11173 			if (rc != MBX_SUCCESS)
11174 				lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
11175 						LOG_SLI, "0349 rc should be "
11176 						"MBX_SUCCESS\n");
11177 		}
11178 
11179 		spin_lock_irqsave(&phba->hbalock, iflag);
11180 		phba->work_ha |= work_ha_copy;
11181 		spin_unlock_irqrestore(&phba->hbalock, iflag);
11182 		lpfc_worker_wake_up(phba);
11183 	}
11184 	return IRQ_HANDLED;
11185 unplug_error:
11186 	spin_unlock_irqrestore(&phba->hbalock, iflag);
11187 	return IRQ_HANDLED;
11188 
11189 } /* lpfc_sli_sp_intr_handler */
11190 
11191 /**
11192  * lpfc_sli_fp_intr_handler - Fast-path interrupt handler to SLI-3 device.
11193  * @irq: Interrupt number.
11194  * @dev_id: The device context pointer.
11195  *
11196  * This function is directly called from the PCI layer as an interrupt
11197  * service routine when device with SLI-3 interface spec is enabled with
11198  * MSI-X multi-message interrupt mode and there is a fast-path FCP IOCB
11199  * ring event in the HBA. However, when the device is enabled with either
11200  * MSI or Pin-IRQ interrupt mode, this function is called as part of the
11201  * device-level interrupt handler. When the PCI slot is in error recovery
11202  * or the HBA is undergoing initialization, the interrupt handler will not
11203  * process the interrupt. The SCSI FCP fast-path ring event are handled in
11204  * the intrrupt context. This function is called without any lock held.
11205  * It gets the hbalock to access and update SLI data structures.
11206  *
11207  * This function returns IRQ_HANDLED when interrupt is handled else it
11208  * returns IRQ_NONE.
11209  **/
11210 irqreturn_t
11211 lpfc_sli_fp_intr_handler(int irq, void *dev_id)
11212 {
11213 	struct lpfc_hba  *phba;
11214 	uint32_t ha_copy;
11215 	unsigned long status;
11216 	unsigned long iflag;
11217 
11218 	/* Get the driver's phba structure from the dev_id and
11219 	 * assume the HBA is not interrupting.
11220 	 */
11221 	phba = (struct lpfc_hba *) dev_id;
11222 
11223 	if (unlikely(!phba))
11224 		return IRQ_NONE;
11225 
11226 	/*
11227 	 * Stuff needs to be attented to when this function is invoked as an
11228 	 * individual interrupt handler in MSI-X multi-message interrupt mode
11229 	 */
11230 	if (phba->intr_type == MSIX) {
11231 		/* Check device state for handling interrupt */
11232 		if (lpfc_intr_state_check(phba))
11233 			return IRQ_NONE;
11234 		/* Need to read HA REG for FCP ring and other ring events */
11235 		if (lpfc_readl(phba->HAregaddr, &ha_copy))
11236 			return IRQ_HANDLED;
11237 		/* Clear up only attention source related to fast-path */
11238 		spin_lock_irqsave(&phba->hbalock, iflag);
11239 		/*
11240 		 * If there is deferred error attention, do not check for
11241 		 * any interrupt.
11242 		 */
11243 		if (unlikely(phba->hba_flag & DEFER_ERATT)) {
11244 			spin_unlock_irqrestore(&phba->hbalock, iflag);
11245 			return IRQ_NONE;
11246 		}
11247 		writel((ha_copy & (HA_R0_CLR_MSK | HA_R1_CLR_MSK)),
11248 			phba->HAregaddr);
11249 		readl(phba->HAregaddr); /* flush */
11250 		spin_unlock_irqrestore(&phba->hbalock, iflag);
11251 	} else
11252 		ha_copy = phba->ha_copy;
11253 
11254 	/*
11255 	 * Process all events on FCP ring. Take the optimized path for FCP IO.
11256 	 */
11257 	ha_copy &= ~(phba->work_ha_mask);
11258 
11259 	status = (ha_copy & (HA_RXMASK << (4*LPFC_FCP_RING)));
11260 	status >>= (4*LPFC_FCP_RING);
11261 	if (status & HA_RXMASK)
11262 		lpfc_sli_handle_fast_ring_event(phba,
11263 						&phba->sli.ring[LPFC_FCP_RING],
11264 						status);
11265 
11266 	if (phba->cfg_multi_ring_support == 2) {
11267 		/*
11268 		 * Process all events on extra ring. Take the optimized path
11269 		 * for extra ring IO.
11270 		 */
11271 		status = (ha_copy & (HA_RXMASK << (4*LPFC_EXTRA_RING)));
11272 		status >>= (4*LPFC_EXTRA_RING);
11273 		if (status & HA_RXMASK) {
11274 			lpfc_sli_handle_fast_ring_event(phba,
11275 					&phba->sli.ring[LPFC_EXTRA_RING],
11276 					status);
11277 		}
11278 	}
11279 	return IRQ_HANDLED;
11280 }  /* lpfc_sli_fp_intr_handler */
11281 
11282 /**
11283  * lpfc_sli_intr_handler - Device-level interrupt handler to SLI-3 device
11284  * @irq: Interrupt number.
11285  * @dev_id: The device context pointer.
11286  *
11287  * This function is the HBA device-level interrupt handler to device with
11288  * SLI-3 interface spec, called from the PCI layer when either MSI or
11289  * Pin-IRQ interrupt mode is enabled and there is an event in the HBA which
11290  * requires driver attention. This function invokes the slow-path interrupt
11291  * attention handling function and fast-path interrupt attention handling
11292  * function in turn to process the relevant HBA attention events. This
11293  * function is called without any lock held. It gets the hbalock to access
11294  * and update SLI data structures.
11295  *
11296  * This function returns IRQ_HANDLED when interrupt is handled, else it
11297  * returns IRQ_NONE.
11298  **/
11299 irqreturn_t
11300 lpfc_sli_intr_handler(int irq, void *dev_id)
11301 {
11302 	struct lpfc_hba  *phba;
11303 	irqreturn_t sp_irq_rc, fp_irq_rc;
11304 	unsigned long status1, status2;
11305 	uint32_t hc_copy;
11306 
11307 	/*
11308 	 * Get the driver's phba structure from the dev_id and
11309 	 * assume the HBA is not interrupting.
11310 	 */
11311 	phba = (struct lpfc_hba *) dev_id;
11312 
11313 	if (unlikely(!phba))
11314 		return IRQ_NONE;
11315 
11316 	/* Check device state for handling interrupt */
11317 	if (lpfc_intr_state_check(phba))
11318 		return IRQ_NONE;
11319 
11320 	spin_lock(&phba->hbalock);
11321 	if (lpfc_readl(phba->HAregaddr, &phba->ha_copy)) {
11322 		spin_unlock(&phba->hbalock);
11323 		return IRQ_HANDLED;
11324 	}
11325 
11326 	if (unlikely(!phba->ha_copy)) {
11327 		spin_unlock(&phba->hbalock);
11328 		return IRQ_NONE;
11329 	} else if (phba->ha_copy & HA_ERATT) {
11330 		if (phba->hba_flag & HBA_ERATT_HANDLED)
11331 			/* ERATT polling has handled ERATT */
11332 			phba->ha_copy &= ~HA_ERATT;
11333 		else
11334 			/* Indicate interrupt handler handles ERATT */
11335 			phba->hba_flag |= HBA_ERATT_HANDLED;
11336 	}
11337 
11338 	/*
11339 	 * If there is deferred error attention, do not check for any interrupt.
11340 	 */
11341 	if (unlikely(phba->hba_flag & DEFER_ERATT)) {
11342 		spin_unlock(&phba->hbalock);
11343 		return IRQ_NONE;
11344 	}
11345 
11346 	/* Clear attention sources except link and error attentions */
11347 	if (lpfc_readl(phba->HCregaddr, &hc_copy)) {
11348 		spin_unlock(&phba->hbalock);
11349 		return IRQ_HANDLED;
11350 	}
11351 	writel(hc_copy & ~(HC_MBINT_ENA | HC_R0INT_ENA | HC_R1INT_ENA
11352 		| HC_R2INT_ENA | HC_LAINT_ENA | HC_ERINT_ENA),
11353 		phba->HCregaddr);
11354 	writel((phba->ha_copy & ~(HA_LATT | HA_ERATT)), phba->HAregaddr);
11355 	writel(hc_copy, phba->HCregaddr);
11356 	readl(phba->HAregaddr); /* flush */
11357 	spin_unlock(&phba->hbalock);
11358 
11359 	/*
11360 	 * Invokes slow-path host attention interrupt handling as appropriate.
11361 	 */
11362 
11363 	/* status of events with mailbox and link attention */
11364 	status1 = phba->ha_copy & (HA_MBATT | HA_LATT | HA_ERATT);
11365 
11366 	/* status of events with ELS ring */
11367 	status2 = (phba->ha_copy & (HA_RXMASK  << (4*LPFC_ELS_RING)));
11368 	status2 >>= (4*LPFC_ELS_RING);
11369 
11370 	if (status1 || (status2 & HA_RXMASK))
11371 		sp_irq_rc = lpfc_sli_sp_intr_handler(irq, dev_id);
11372 	else
11373 		sp_irq_rc = IRQ_NONE;
11374 
11375 	/*
11376 	 * Invoke fast-path host attention interrupt handling as appropriate.
11377 	 */
11378 
11379 	/* status of events with FCP ring */
11380 	status1 = (phba->ha_copy & (HA_RXMASK << (4*LPFC_FCP_RING)));
11381 	status1 >>= (4*LPFC_FCP_RING);
11382 
11383 	/* status of events with extra ring */
11384 	if (phba->cfg_multi_ring_support == 2) {
11385 		status2 = (phba->ha_copy & (HA_RXMASK << (4*LPFC_EXTRA_RING)));
11386 		status2 >>= (4*LPFC_EXTRA_RING);
11387 	} else
11388 		status2 = 0;
11389 
11390 	if ((status1 & HA_RXMASK) || (status2 & HA_RXMASK))
11391 		fp_irq_rc = lpfc_sli_fp_intr_handler(irq, dev_id);
11392 	else
11393 		fp_irq_rc = IRQ_NONE;
11394 
11395 	/* Return device-level interrupt handling status */
11396 	return (sp_irq_rc == IRQ_HANDLED) ? sp_irq_rc : fp_irq_rc;
11397 }  /* lpfc_sli_intr_handler */
11398 
11399 /**
11400  * lpfc_sli4_fcp_xri_abort_event_proc - Process fcp xri abort event
11401  * @phba: pointer to lpfc hba data structure.
11402  *
11403  * This routine is invoked by the worker thread to process all the pending
11404  * SLI4 FCP abort XRI events.
11405  **/
11406 void lpfc_sli4_fcp_xri_abort_event_proc(struct lpfc_hba *phba)
11407 {
11408 	struct lpfc_cq_event *cq_event;
11409 
11410 	/* First, declare the fcp xri abort event has been handled */
11411 	spin_lock_irq(&phba->hbalock);
11412 	phba->hba_flag &= ~FCP_XRI_ABORT_EVENT;
11413 	spin_unlock_irq(&phba->hbalock);
11414 	/* Now, handle all the fcp xri abort events */
11415 	while (!list_empty(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue)) {
11416 		/* Get the first event from the head of the event queue */
11417 		spin_lock_irq(&phba->hbalock);
11418 		list_remove_head(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue,
11419 				 cq_event, struct lpfc_cq_event, list);
11420 		spin_unlock_irq(&phba->hbalock);
11421 		/* Notify aborted XRI for FCP work queue */
11422 		lpfc_sli4_fcp_xri_aborted(phba, &cq_event->cqe.wcqe_axri);
11423 		/* Free the event processed back to the free pool */
11424 		lpfc_sli4_cq_event_release(phba, cq_event);
11425 	}
11426 }
11427 
11428 /**
11429  * lpfc_sli4_els_xri_abort_event_proc - Process els xri abort event
11430  * @phba: pointer to lpfc hba data structure.
11431  *
11432  * This routine is invoked by the worker thread to process all the pending
11433  * SLI4 els abort xri events.
11434  **/
11435 void lpfc_sli4_els_xri_abort_event_proc(struct lpfc_hba *phba)
11436 {
11437 	struct lpfc_cq_event *cq_event;
11438 
11439 	/* First, declare the els xri abort event has been handled */
11440 	spin_lock_irq(&phba->hbalock);
11441 	phba->hba_flag &= ~ELS_XRI_ABORT_EVENT;
11442 	spin_unlock_irq(&phba->hbalock);
11443 	/* Now, handle all the els xri abort events */
11444 	while (!list_empty(&phba->sli4_hba.sp_els_xri_aborted_work_queue)) {
11445 		/* Get the first event from the head of the event queue */
11446 		spin_lock_irq(&phba->hbalock);
11447 		list_remove_head(&phba->sli4_hba.sp_els_xri_aborted_work_queue,
11448 				 cq_event, struct lpfc_cq_event, list);
11449 		spin_unlock_irq(&phba->hbalock);
11450 		/* Notify aborted XRI for ELS work queue */
11451 		lpfc_sli4_els_xri_aborted(phba, &cq_event->cqe.wcqe_axri);
11452 		/* Free the event processed back to the free pool */
11453 		lpfc_sli4_cq_event_release(phba, cq_event);
11454 	}
11455 }
11456 
11457 /**
11458  * lpfc_sli4_iocb_param_transfer - Transfer pIocbOut and cmpl status to pIocbIn
11459  * @phba: pointer to lpfc hba data structure
11460  * @pIocbIn: pointer to the rspiocbq
11461  * @pIocbOut: pointer to the cmdiocbq
11462  * @wcqe: pointer to the complete wcqe
11463  *
11464  * This routine transfers the fields of a command iocbq to a response iocbq
11465  * by copying all the IOCB fields from command iocbq and transferring the
11466  * completion status information from the complete wcqe.
11467  **/
11468 static void
11469 lpfc_sli4_iocb_param_transfer(struct lpfc_hba *phba,
11470 			      struct lpfc_iocbq *pIocbIn,
11471 			      struct lpfc_iocbq *pIocbOut,
11472 			      struct lpfc_wcqe_complete *wcqe)
11473 {
11474 	int numBdes, i;
11475 	unsigned long iflags;
11476 	uint32_t status, max_response;
11477 	struct lpfc_dmabuf *dmabuf;
11478 	struct ulp_bde64 *bpl, bde;
11479 	size_t offset = offsetof(struct lpfc_iocbq, iocb);
11480 
11481 	memcpy((char *)pIocbIn + offset, (char *)pIocbOut + offset,
11482 	       sizeof(struct lpfc_iocbq) - offset);
11483 	/* Map WCQE parameters into irspiocb parameters */
11484 	status = bf_get(lpfc_wcqe_c_status, wcqe);
11485 	pIocbIn->iocb.ulpStatus = (status & LPFC_IOCB_STATUS_MASK);
11486 	if (pIocbOut->iocb_flag & LPFC_IO_FCP)
11487 		if (pIocbIn->iocb.ulpStatus == IOSTAT_FCP_RSP_ERROR)
11488 			pIocbIn->iocb.un.fcpi.fcpi_parm =
11489 					pIocbOut->iocb.un.fcpi.fcpi_parm -
11490 					wcqe->total_data_placed;
11491 		else
11492 			pIocbIn->iocb.un.ulpWord[4] = wcqe->parameter;
11493 	else {
11494 		pIocbIn->iocb.un.ulpWord[4] = wcqe->parameter;
11495 		switch (pIocbOut->iocb.ulpCommand) {
11496 		case CMD_ELS_REQUEST64_CR:
11497 			dmabuf = (struct lpfc_dmabuf *)pIocbOut->context3;
11498 			bpl  = (struct ulp_bde64 *)dmabuf->virt;
11499 			bde.tus.w = le32_to_cpu(bpl[1].tus.w);
11500 			max_response = bde.tus.f.bdeSize;
11501 			break;
11502 		case CMD_GEN_REQUEST64_CR:
11503 			max_response = 0;
11504 			if (!pIocbOut->context3)
11505 				break;
11506 			numBdes = pIocbOut->iocb.un.genreq64.bdl.bdeSize/
11507 					sizeof(struct ulp_bde64);
11508 			dmabuf = (struct lpfc_dmabuf *)pIocbOut->context3;
11509 			bpl = (struct ulp_bde64 *)dmabuf->virt;
11510 			for (i = 0; i < numBdes; i++) {
11511 				bde.tus.w = le32_to_cpu(bpl[i].tus.w);
11512 				if (bde.tus.f.bdeFlags != BUFF_TYPE_BDE_64)
11513 					max_response += bde.tus.f.bdeSize;
11514 			}
11515 			break;
11516 		default:
11517 			max_response = wcqe->total_data_placed;
11518 			break;
11519 		}
11520 		if (max_response < wcqe->total_data_placed)
11521 			pIocbIn->iocb.un.genreq64.bdl.bdeSize = max_response;
11522 		else
11523 			pIocbIn->iocb.un.genreq64.bdl.bdeSize =
11524 				wcqe->total_data_placed;
11525 	}
11526 
11527 	/* Convert BG errors for completion status */
11528 	if (status == CQE_STATUS_DI_ERROR) {
11529 		pIocbIn->iocb.ulpStatus = IOSTAT_LOCAL_REJECT;
11530 
11531 		if (bf_get(lpfc_wcqe_c_bg_edir, wcqe))
11532 			pIocbIn->iocb.un.ulpWord[4] = IOERR_RX_DMA_FAILED;
11533 		else
11534 			pIocbIn->iocb.un.ulpWord[4] = IOERR_TX_DMA_FAILED;
11535 
11536 		pIocbIn->iocb.unsli3.sli3_bg.bgstat = 0;
11537 		if (bf_get(lpfc_wcqe_c_bg_ge, wcqe)) /* Guard Check failed */
11538 			pIocbIn->iocb.unsli3.sli3_bg.bgstat |=
11539 				BGS_GUARD_ERR_MASK;
11540 		if (bf_get(lpfc_wcqe_c_bg_ae, wcqe)) /* App Tag Check failed */
11541 			pIocbIn->iocb.unsli3.sli3_bg.bgstat |=
11542 				BGS_APPTAG_ERR_MASK;
11543 		if (bf_get(lpfc_wcqe_c_bg_re, wcqe)) /* Ref Tag Check failed */
11544 			pIocbIn->iocb.unsli3.sli3_bg.bgstat |=
11545 				BGS_REFTAG_ERR_MASK;
11546 
11547 		/* Check to see if there was any good data before the error */
11548 		if (bf_get(lpfc_wcqe_c_bg_tdpv, wcqe)) {
11549 			pIocbIn->iocb.unsli3.sli3_bg.bgstat |=
11550 				BGS_HI_WATER_MARK_PRESENT_MASK;
11551 			pIocbIn->iocb.unsli3.sli3_bg.bghm =
11552 				wcqe->total_data_placed;
11553 		}
11554 
11555 		/*
11556 		* Set ALL the error bits to indicate we don't know what
11557 		* type of error it is.
11558 		*/
11559 		if (!pIocbIn->iocb.unsli3.sli3_bg.bgstat)
11560 			pIocbIn->iocb.unsli3.sli3_bg.bgstat |=
11561 				(BGS_REFTAG_ERR_MASK | BGS_APPTAG_ERR_MASK |
11562 				BGS_GUARD_ERR_MASK);
11563 	}
11564 
11565 	/* Pick up HBA exchange busy condition */
11566 	if (bf_get(lpfc_wcqe_c_xb, wcqe)) {
11567 		spin_lock_irqsave(&phba->hbalock, iflags);
11568 		pIocbIn->iocb_flag |= LPFC_EXCHANGE_BUSY;
11569 		spin_unlock_irqrestore(&phba->hbalock, iflags);
11570 	}
11571 }
11572 
11573 /**
11574  * lpfc_sli4_els_wcqe_to_rspiocbq - Get response iocbq from els wcqe
11575  * @phba: Pointer to HBA context object.
11576  * @wcqe: Pointer to work-queue completion queue entry.
11577  *
11578  * This routine handles an ELS work-queue completion event and construct
11579  * a pseudo response ELS IODBQ from the SLI4 ELS WCQE for the common
11580  * discovery engine to handle.
11581  *
11582  * Return: Pointer to the receive IOCBQ, NULL otherwise.
11583  **/
11584 static struct lpfc_iocbq *
11585 lpfc_sli4_els_wcqe_to_rspiocbq(struct lpfc_hba *phba,
11586 			       struct lpfc_iocbq *irspiocbq)
11587 {
11588 	struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
11589 	struct lpfc_iocbq *cmdiocbq;
11590 	struct lpfc_wcqe_complete *wcqe;
11591 	unsigned long iflags;
11592 
11593 	wcqe = &irspiocbq->cq_event.cqe.wcqe_cmpl;
11594 	spin_lock_irqsave(&pring->ring_lock, iflags);
11595 	pring->stats.iocb_event++;
11596 	/* Look up the ELS command IOCB and create pseudo response IOCB */
11597 	cmdiocbq = lpfc_sli_iocbq_lookup_by_tag(phba, pring,
11598 				bf_get(lpfc_wcqe_c_request_tag, wcqe));
11599 	spin_unlock_irqrestore(&pring->ring_lock, iflags);
11600 
11601 	if (unlikely(!cmdiocbq)) {
11602 		lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
11603 				"0386 ELS complete with no corresponding "
11604 				"cmdiocb: iotag (%d)\n",
11605 				bf_get(lpfc_wcqe_c_request_tag, wcqe));
11606 		lpfc_sli_release_iocbq(phba, irspiocbq);
11607 		return NULL;
11608 	}
11609 
11610 	/* Fake the irspiocbq and copy necessary response information */
11611 	lpfc_sli4_iocb_param_transfer(phba, irspiocbq, cmdiocbq, wcqe);
11612 
11613 	return irspiocbq;
11614 }
11615 
11616 /**
11617  * lpfc_sli4_sp_handle_async_event - Handle an asynchroous event
11618  * @phba: Pointer to HBA context object.
11619  * @cqe: Pointer to mailbox completion queue entry.
11620  *
11621  * This routine process a mailbox completion queue entry with asynchrous
11622  * event.
11623  *
11624  * Return: true if work posted to worker thread, otherwise false.
11625  **/
11626 static bool
11627 lpfc_sli4_sp_handle_async_event(struct lpfc_hba *phba, struct lpfc_mcqe *mcqe)
11628 {
11629 	struct lpfc_cq_event *cq_event;
11630 	unsigned long iflags;
11631 
11632 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
11633 			"0392 Async Event: word0:x%x, word1:x%x, "
11634 			"word2:x%x, word3:x%x\n", mcqe->word0,
11635 			mcqe->mcqe_tag0, mcqe->mcqe_tag1, mcqe->trailer);
11636 
11637 	/* Allocate a new internal CQ_EVENT entry */
11638 	cq_event = lpfc_sli4_cq_event_alloc(phba);
11639 	if (!cq_event) {
11640 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
11641 				"0394 Failed to allocate CQ_EVENT entry\n");
11642 		return false;
11643 	}
11644 
11645 	/* Move the CQE into an asynchronous event entry */
11646 	memcpy(&cq_event->cqe, mcqe, sizeof(struct lpfc_mcqe));
11647 	spin_lock_irqsave(&phba->hbalock, iflags);
11648 	list_add_tail(&cq_event->list, &phba->sli4_hba.sp_asynce_work_queue);
11649 	/* Set the async event flag */
11650 	phba->hba_flag |= ASYNC_EVENT;
11651 	spin_unlock_irqrestore(&phba->hbalock, iflags);
11652 
11653 	return true;
11654 }
11655 
11656 /**
11657  * lpfc_sli4_sp_handle_mbox_event - Handle a mailbox completion event
11658  * @phba: Pointer to HBA context object.
11659  * @cqe: Pointer to mailbox completion queue entry.
11660  *
11661  * This routine process a mailbox completion queue entry with mailbox
11662  * completion event.
11663  *
11664  * Return: true if work posted to worker thread, otherwise false.
11665  **/
11666 static bool
11667 lpfc_sli4_sp_handle_mbox_event(struct lpfc_hba *phba, struct lpfc_mcqe *mcqe)
11668 {
11669 	uint32_t mcqe_status;
11670 	MAILBOX_t *mbox, *pmbox;
11671 	struct lpfc_mqe *mqe;
11672 	struct lpfc_vport *vport;
11673 	struct lpfc_nodelist *ndlp;
11674 	struct lpfc_dmabuf *mp;
11675 	unsigned long iflags;
11676 	LPFC_MBOXQ_t *pmb;
11677 	bool workposted = false;
11678 	int rc;
11679 
11680 	/* If not a mailbox complete MCQE, out by checking mailbox consume */
11681 	if (!bf_get(lpfc_trailer_completed, mcqe))
11682 		goto out_no_mqe_complete;
11683 
11684 	/* Get the reference to the active mbox command */
11685 	spin_lock_irqsave(&phba->hbalock, iflags);
11686 	pmb = phba->sli.mbox_active;
11687 	if (unlikely(!pmb)) {
11688 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
11689 				"1832 No pending MBOX command to handle\n");
11690 		spin_unlock_irqrestore(&phba->hbalock, iflags);
11691 		goto out_no_mqe_complete;
11692 	}
11693 	spin_unlock_irqrestore(&phba->hbalock, iflags);
11694 	mqe = &pmb->u.mqe;
11695 	pmbox = (MAILBOX_t *)&pmb->u.mqe;
11696 	mbox = phba->mbox;
11697 	vport = pmb->vport;
11698 
11699 	/* Reset heartbeat timer */
11700 	phba->last_completion_time = jiffies;
11701 	del_timer(&phba->sli.mbox_tmo);
11702 
11703 	/* Move mbox data to caller's mailbox region, do endian swapping */
11704 	if (pmb->mbox_cmpl && mbox)
11705 		lpfc_sli_pcimem_bcopy(mbox, mqe, sizeof(struct lpfc_mqe));
11706 
11707 	/*
11708 	 * For mcqe errors, conditionally move a modified error code to
11709 	 * the mbox so that the error will not be missed.
11710 	 */
11711 	mcqe_status = bf_get(lpfc_mcqe_status, mcqe);
11712 	if (mcqe_status != MB_CQE_STATUS_SUCCESS) {
11713 		if (bf_get(lpfc_mqe_status, mqe) == MBX_SUCCESS)
11714 			bf_set(lpfc_mqe_status, mqe,
11715 			       (LPFC_MBX_ERROR_RANGE | mcqe_status));
11716 	}
11717 	if (pmb->mbox_flag & LPFC_MBX_IMED_UNREG) {
11718 		pmb->mbox_flag &= ~LPFC_MBX_IMED_UNREG;
11719 		lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_MBOX_VPORT,
11720 				      "MBOX dflt rpi: status:x%x rpi:x%x",
11721 				      mcqe_status,
11722 				      pmbox->un.varWords[0], 0);
11723 		if (mcqe_status == MB_CQE_STATUS_SUCCESS) {
11724 			mp = (struct lpfc_dmabuf *)(pmb->context1);
11725 			ndlp = (struct lpfc_nodelist *)pmb->context2;
11726 			/* Reg_LOGIN of dflt RPI was successful. Now lets get
11727 			 * RID of the PPI using the same mbox buffer.
11728 			 */
11729 			lpfc_unreg_login(phba, vport->vpi,
11730 					 pmbox->un.varWords[0], pmb);
11731 			pmb->mbox_cmpl = lpfc_mbx_cmpl_dflt_rpi;
11732 			pmb->context1 = mp;
11733 			pmb->context2 = ndlp;
11734 			pmb->vport = vport;
11735 			rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
11736 			if (rc != MBX_BUSY)
11737 				lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
11738 						LOG_SLI, "0385 rc should "
11739 						"have been MBX_BUSY\n");
11740 			if (rc != MBX_NOT_FINISHED)
11741 				goto send_current_mbox;
11742 		}
11743 	}
11744 	spin_lock_irqsave(&phba->pport->work_port_lock, iflags);
11745 	phba->pport->work_port_events &= ~WORKER_MBOX_TMO;
11746 	spin_unlock_irqrestore(&phba->pport->work_port_lock, iflags);
11747 
11748 	/* There is mailbox completion work to do */
11749 	spin_lock_irqsave(&phba->hbalock, iflags);
11750 	__lpfc_mbox_cmpl_put(phba, pmb);
11751 	phba->work_ha |= HA_MBATT;
11752 	spin_unlock_irqrestore(&phba->hbalock, iflags);
11753 	workposted = true;
11754 
11755 send_current_mbox:
11756 	spin_lock_irqsave(&phba->hbalock, iflags);
11757 	/* Release the mailbox command posting token */
11758 	phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
11759 	/* Setting active mailbox pointer need to be in sync to flag clear */
11760 	phba->sli.mbox_active = NULL;
11761 	spin_unlock_irqrestore(&phba->hbalock, iflags);
11762 	/* Wake up worker thread to post the next pending mailbox command */
11763 	lpfc_worker_wake_up(phba);
11764 out_no_mqe_complete:
11765 	if (bf_get(lpfc_trailer_consumed, mcqe))
11766 		lpfc_sli4_mq_release(phba->sli4_hba.mbx_wq);
11767 	return workposted;
11768 }
11769 
11770 /**
11771  * lpfc_sli4_sp_handle_mcqe - Process a mailbox completion queue entry
11772  * @phba: Pointer to HBA context object.
11773  * @cqe: Pointer to mailbox completion queue entry.
11774  *
11775  * This routine process a mailbox completion queue entry, it invokes the
11776  * proper mailbox complete handling or asynchrous event handling routine
11777  * according to the MCQE's async bit.
11778  *
11779  * Return: true if work posted to worker thread, otherwise false.
11780  **/
11781 static bool
11782 lpfc_sli4_sp_handle_mcqe(struct lpfc_hba *phba, struct lpfc_cqe *cqe)
11783 {
11784 	struct lpfc_mcqe mcqe;
11785 	bool workposted;
11786 
11787 	/* Copy the mailbox MCQE and convert endian order as needed */
11788 	lpfc_sli_pcimem_bcopy(cqe, &mcqe, sizeof(struct lpfc_mcqe));
11789 
11790 	/* Invoke the proper event handling routine */
11791 	if (!bf_get(lpfc_trailer_async, &mcqe))
11792 		workposted = lpfc_sli4_sp_handle_mbox_event(phba, &mcqe);
11793 	else
11794 		workposted = lpfc_sli4_sp_handle_async_event(phba, &mcqe);
11795 	return workposted;
11796 }
11797 
11798 /**
11799  * lpfc_sli4_sp_handle_els_wcqe - Handle els work-queue completion event
11800  * @phba: Pointer to HBA context object.
11801  * @cq: Pointer to associated CQ
11802  * @wcqe: Pointer to work-queue completion queue entry.
11803  *
11804  * This routine handles an ELS work-queue completion event.
11805  *
11806  * Return: true if work posted to worker thread, otherwise false.
11807  **/
11808 static bool
11809 lpfc_sli4_sp_handle_els_wcqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
11810 			     struct lpfc_wcqe_complete *wcqe)
11811 {
11812 	struct lpfc_iocbq *irspiocbq;
11813 	unsigned long iflags;
11814 	struct lpfc_sli_ring *pring = cq->pring;
11815 	int txq_cnt = 0;
11816 	int txcmplq_cnt = 0;
11817 	int fcp_txcmplq_cnt = 0;
11818 
11819 	/* Get an irspiocbq for later ELS response processing use */
11820 	irspiocbq = lpfc_sli_get_iocbq(phba);
11821 	if (!irspiocbq) {
11822 		if (!list_empty(&pring->txq))
11823 			txq_cnt++;
11824 		if (!list_empty(&pring->txcmplq))
11825 			txcmplq_cnt++;
11826 		if (!list_empty(&phba->sli.ring[LPFC_FCP_RING].txcmplq))
11827 			fcp_txcmplq_cnt++;
11828 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
11829 			"0387 NO IOCBQ data: txq_cnt=%d iocb_cnt=%d "
11830 			"fcp_txcmplq_cnt=%d, els_txcmplq_cnt=%d\n",
11831 			txq_cnt, phba->iocb_cnt,
11832 			fcp_txcmplq_cnt,
11833 			txcmplq_cnt);
11834 		return false;
11835 	}
11836 
11837 	/* Save off the slow-path queue event for work thread to process */
11838 	memcpy(&irspiocbq->cq_event.cqe.wcqe_cmpl, wcqe, sizeof(*wcqe));
11839 	spin_lock_irqsave(&phba->hbalock, iflags);
11840 	list_add_tail(&irspiocbq->cq_event.list,
11841 		      &phba->sli4_hba.sp_queue_event);
11842 	phba->hba_flag |= HBA_SP_QUEUE_EVT;
11843 	spin_unlock_irqrestore(&phba->hbalock, iflags);
11844 
11845 	return true;
11846 }
11847 
11848 /**
11849  * lpfc_sli4_sp_handle_rel_wcqe - Handle slow-path WQ entry consumed event
11850  * @phba: Pointer to HBA context object.
11851  * @wcqe: Pointer to work-queue completion queue entry.
11852  *
11853  * This routine handles slow-path WQ entry comsumed event by invoking the
11854  * proper WQ release routine to the slow-path WQ.
11855  **/
11856 static void
11857 lpfc_sli4_sp_handle_rel_wcqe(struct lpfc_hba *phba,
11858 			     struct lpfc_wcqe_release *wcqe)
11859 {
11860 	/* sanity check on queue memory */
11861 	if (unlikely(!phba->sli4_hba.els_wq))
11862 		return;
11863 	/* Check for the slow-path ELS work queue */
11864 	if (bf_get(lpfc_wcqe_r_wq_id, wcqe) == phba->sli4_hba.els_wq->queue_id)
11865 		lpfc_sli4_wq_release(phba->sli4_hba.els_wq,
11866 				     bf_get(lpfc_wcqe_r_wqe_index, wcqe));
11867 	else
11868 		lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
11869 				"2579 Slow-path wqe consume event carries "
11870 				"miss-matched qid: wcqe-qid=x%x, sp-qid=x%x\n",
11871 				bf_get(lpfc_wcqe_r_wqe_index, wcqe),
11872 				phba->sli4_hba.els_wq->queue_id);
11873 }
11874 
11875 /**
11876  * lpfc_sli4_sp_handle_abort_xri_wcqe - Handle a xri abort event
11877  * @phba: Pointer to HBA context object.
11878  * @cq: Pointer to a WQ completion queue.
11879  * @wcqe: Pointer to work-queue completion queue entry.
11880  *
11881  * This routine handles an XRI abort event.
11882  *
11883  * Return: true if work posted to worker thread, otherwise false.
11884  **/
11885 static bool
11886 lpfc_sli4_sp_handle_abort_xri_wcqe(struct lpfc_hba *phba,
11887 				   struct lpfc_queue *cq,
11888 				   struct sli4_wcqe_xri_aborted *wcqe)
11889 {
11890 	bool workposted = false;
11891 	struct lpfc_cq_event *cq_event;
11892 	unsigned long iflags;
11893 
11894 	/* Allocate a new internal CQ_EVENT entry */
11895 	cq_event = lpfc_sli4_cq_event_alloc(phba);
11896 	if (!cq_event) {
11897 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
11898 				"0602 Failed to allocate CQ_EVENT entry\n");
11899 		return false;
11900 	}
11901 
11902 	/* Move the CQE into the proper xri abort event list */
11903 	memcpy(&cq_event->cqe, wcqe, sizeof(struct sli4_wcqe_xri_aborted));
11904 	switch (cq->subtype) {
11905 	case LPFC_FCP:
11906 		spin_lock_irqsave(&phba->hbalock, iflags);
11907 		list_add_tail(&cq_event->list,
11908 			      &phba->sli4_hba.sp_fcp_xri_aborted_work_queue);
11909 		/* Set the fcp xri abort event flag */
11910 		phba->hba_flag |= FCP_XRI_ABORT_EVENT;
11911 		spin_unlock_irqrestore(&phba->hbalock, iflags);
11912 		workposted = true;
11913 		break;
11914 	case LPFC_ELS:
11915 		spin_lock_irqsave(&phba->hbalock, iflags);
11916 		list_add_tail(&cq_event->list,
11917 			      &phba->sli4_hba.sp_els_xri_aborted_work_queue);
11918 		/* Set the els xri abort event flag */
11919 		phba->hba_flag |= ELS_XRI_ABORT_EVENT;
11920 		spin_unlock_irqrestore(&phba->hbalock, iflags);
11921 		workposted = true;
11922 		break;
11923 	default:
11924 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
11925 				"0603 Invalid work queue CQE subtype (x%x)\n",
11926 				cq->subtype);
11927 		workposted = false;
11928 		break;
11929 	}
11930 	return workposted;
11931 }
11932 
11933 /**
11934  * lpfc_sli4_sp_handle_rcqe - Process a receive-queue completion queue entry
11935  * @phba: Pointer to HBA context object.
11936  * @rcqe: Pointer to receive-queue completion queue entry.
11937  *
11938  * This routine process a receive-queue completion queue entry.
11939  *
11940  * Return: true if work posted to worker thread, otherwise false.
11941  **/
11942 static bool
11943 lpfc_sli4_sp_handle_rcqe(struct lpfc_hba *phba, struct lpfc_rcqe *rcqe)
11944 {
11945 	bool workposted = false;
11946 	struct lpfc_queue *hrq = phba->sli4_hba.hdr_rq;
11947 	struct lpfc_queue *drq = phba->sli4_hba.dat_rq;
11948 	struct hbq_dmabuf *dma_buf;
11949 	uint32_t status, rq_id;
11950 	unsigned long iflags;
11951 
11952 	/* sanity check on queue memory */
11953 	if (unlikely(!hrq) || unlikely(!drq))
11954 		return workposted;
11955 
11956 	if (bf_get(lpfc_cqe_code, rcqe) == CQE_CODE_RECEIVE_V1)
11957 		rq_id = bf_get(lpfc_rcqe_rq_id_v1, rcqe);
11958 	else
11959 		rq_id = bf_get(lpfc_rcqe_rq_id, rcqe);
11960 	if (rq_id != hrq->queue_id)
11961 		goto out;
11962 
11963 	status = bf_get(lpfc_rcqe_status, rcqe);
11964 	switch (status) {
11965 	case FC_STATUS_RQ_BUF_LEN_EXCEEDED:
11966 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
11967 				"2537 Receive Frame Truncated!!\n");
11968 		hrq->RQ_buf_trunc++;
11969 	case FC_STATUS_RQ_SUCCESS:
11970 		lpfc_sli4_rq_release(hrq, drq);
11971 		spin_lock_irqsave(&phba->hbalock, iflags);
11972 		dma_buf = lpfc_sli_hbqbuf_get(&phba->hbqs[0].hbq_buffer_list);
11973 		if (!dma_buf) {
11974 			hrq->RQ_no_buf_found++;
11975 			spin_unlock_irqrestore(&phba->hbalock, iflags);
11976 			goto out;
11977 		}
11978 		hrq->RQ_rcv_buf++;
11979 		memcpy(&dma_buf->cq_event.cqe.rcqe_cmpl, rcqe, sizeof(*rcqe));
11980 		/* save off the frame for the word thread to process */
11981 		list_add_tail(&dma_buf->cq_event.list,
11982 			      &phba->sli4_hba.sp_queue_event);
11983 		/* Frame received */
11984 		phba->hba_flag |= HBA_SP_QUEUE_EVT;
11985 		spin_unlock_irqrestore(&phba->hbalock, iflags);
11986 		workposted = true;
11987 		break;
11988 	case FC_STATUS_INSUFF_BUF_NEED_BUF:
11989 	case FC_STATUS_INSUFF_BUF_FRM_DISC:
11990 		hrq->RQ_no_posted_buf++;
11991 		/* Post more buffers if possible */
11992 		spin_lock_irqsave(&phba->hbalock, iflags);
11993 		phba->hba_flag |= HBA_POST_RECEIVE_BUFFER;
11994 		spin_unlock_irqrestore(&phba->hbalock, iflags);
11995 		workposted = true;
11996 		break;
11997 	}
11998 out:
11999 	return workposted;
12000 }
12001 
12002 /**
12003  * lpfc_sli4_sp_handle_cqe - Process a slow path completion queue entry
12004  * @phba: Pointer to HBA context object.
12005  * @cq: Pointer to the completion queue.
12006  * @wcqe: Pointer to a completion queue entry.
12007  *
12008  * This routine process a slow-path work-queue or receive queue completion queue
12009  * entry.
12010  *
12011  * Return: true if work posted to worker thread, otherwise false.
12012  **/
12013 static bool
12014 lpfc_sli4_sp_handle_cqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
12015 			 struct lpfc_cqe *cqe)
12016 {
12017 	struct lpfc_cqe cqevt;
12018 	bool workposted = false;
12019 
12020 	/* Copy the work queue CQE and convert endian order if needed */
12021 	lpfc_sli_pcimem_bcopy(cqe, &cqevt, sizeof(struct lpfc_cqe));
12022 
12023 	/* Check and process for different type of WCQE and dispatch */
12024 	switch (bf_get(lpfc_cqe_code, &cqevt)) {
12025 	case CQE_CODE_COMPL_WQE:
12026 		/* Process the WQ/RQ complete event */
12027 		phba->last_completion_time = jiffies;
12028 		workposted = lpfc_sli4_sp_handle_els_wcqe(phba, cq,
12029 				(struct lpfc_wcqe_complete *)&cqevt);
12030 		break;
12031 	case CQE_CODE_RELEASE_WQE:
12032 		/* Process the WQ release event */
12033 		lpfc_sli4_sp_handle_rel_wcqe(phba,
12034 				(struct lpfc_wcqe_release *)&cqevt);
12035 		break;
12036 	case CQE_CODE_XRI_ABORTED:
12037 		/* Process the WQ XRI abort event */
12038 		phba->last_completion_time = jiffies;
12039 		workposted = lpfc_sli4_sp_handle_abort_xri_wcqe(phba, cq,
12040 				(struct sli4_wcqe_xri_aborted *)&cqevt);
12041 		break;
12042 	case CQE_CODE_RECEIVE:
12043 	case CQE_CODE_RECEIVE_V1:
12044 		/* Process the RQ event */
12045 		phba->last_completion_time = jiffies;
12046 		workposted = lpfc_sli4_sp_handle_rcqe(phba,
12047 				(struct lpfc_rcqe *)&cqevt);
12048 		break;
12049 	default:
12050 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12051 				"0388 Not a valid WCQE code: x%x\n",
12052 				bf_get(lpfc_cqe_code, &cqevt));
12053 		break;
12054 	}
12055 	return workposted;
12056 }
12057 
12058 /**
12059  * lpfc_sli4_sp_handle_eqe - Process a slow-path event queue entry
12060  * @phba: Pointer to HBA context object.
12061  * @eqe: Pointer to fast-path event queue entry.
12062  *
12063  * This routine process a event queue entry from the slow-path event queue.
12064  * It will check the MajorCode and MinorCode to determine this is for a
12065  * completion event on a completion queue, if not, an error shall be logged
12066  * and just return. Otherwise, it will get to the corresponding completion
12067  * queue and process all the entries on that completion queue, rearm the
12068  * completion queue, and then return.
12069  *
12070  **/
12071 static void
12072 lpfc_sli4_sp_handle_eqe(struct lpfc_hba *phba, struct lpfc_eqe *eqe,
12073 	struct lpfc_queue *speq)
12074 {
12075 	struct lpfc_queue *cq = NULL, *childq;
12076 	struct lpfc_cqe *cqe;
12077 	bool workposted = false;
12078 	int ecount = 0;
12079 	uint16_t cqid;
12080 
12081 	/* Get the reference to the corresponding CQ */
12082 	cqid = bf_get_le32(lpfc_eqe_resource_id, eqe);
12083 
12084 	list_for_each_entry(childq, &speq->child_list, list) {
12085 		if (childq->queue_id == cqid) {
12086 			cq = childq;
12087 			break;
12088 		}
12089 	}
12090 	if (unlikely(!cq)) {
12091 		if (phba->sli.sli_flag & LPFC_SLI_ACTIVE)
12092 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12093 					"0365 Slow-path CQ identifier "
12094 					"(%d) does not exist\n", cqid);
12095 		return;
12096 	}
12097 
12098 	/* Process all the entries to the CQ */
12099 	switch (cq->type) {
12100 	case LPFC_MCQ:
12101 		while ((cqe = lpfc_sli4_cq_get(cq))) {
12102 			workposted |= lpfc_sli4_sp_handle_mcqe(phba, cqe);
12103 			if (!(++ecount % cq->entry_repost))
12104 				lpfc_sli4_cq_release(cq, LPFC_QUEUE_NOARM);
12105 			cq->CQ_mbox++;
12106 		}
12107 		break;
12108 	case LPFC_WCQ:
12109 		while ((cqe = lpfc_sli4_cq_get(cq))) {
12110 			if (cq->subtype == LPFC_FCP)
12111 				workposted |= lpfc_sli4_fp_handle_wcqe(phba, cq,
12112 								       cqe);
12113 			else
12114 				workposted |= lpfc_sli4_sp_handle_cqe(phba, cq,
12115 								      cqe);
12116 			if (!(++ecount % cq->entry_repost))
12117 				lpfc_sli4_cq_release(cq, LPFC_QUEUE_NOARM);
12118 		}
12119 
12120 		/* Track the max number of CQEs processed in 1 EQ */
12121 		if (ecount > cq->CQ_max_cqe)
12122 			cq->CQ_max_cqe = ecount;
12123 		break;
12124 	default:
12125 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12126 				"0370 Invalid completion queue type (%d)\n",
12127 				cq->type);
12128 		return;
12129 	}
12130 
12131 	/* Catch the no cq entry condition, log an error */
12132 	if (unlikely(ecount == 0))
12133 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12134 				"0371 No entry from the CQ: identifier "
12135 				"(x%x), type (%d)\n", cq->queue_id, cq->type);
12136 
12137 	/* In any case, flash and re-arm the RCQ */
12138 	lpfc_sli4_cq_release(cq, LPFC_QUEUE_REARM);
12139 
12140 	/* wake up worker thread if there are works to be done */
12141 	if (workposted)
12142 		lpfc_worker_wake_up(phba);
12143 }
12144 
12145 /**
12146  * lpfc_sli4_fp_handle_fcp_wcqe - Process fast-path work queue completion entry
12147  * @phba: Pointer to HBA context object.
12148  * @cq: Pointer to associated CQ
12149  * @wcqe: Pointer to work-queue completion queue entry.
12150  *
12151  * This routine process a fast-path work queue completion entry from fast-path
12152  * event queue for FCP command response completion.
12153  **/
12154 static void
12155 lpfc_sli4_fp_handle_fcp_wcqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
12156 			     struct lpfc_wcqe_complete *wcqe)
12157 {
12158 	struct lpfc_sli_ring *pring = cq->pring;
12159 	struct lpfc_iocbq *cmdiocbq;
12160 	struct lpfc_iocbq irspiocbq;
12161 	unsigned long iflags;
12162 
12163 	/* Check for response status */
12164 	if (unlikely(bf_get(lpfc_wcqe_c_status, wcqe))) {
12165 		/* If resource errors reported from HBA, reduce queue
12166 		 * depth of the SCSI device.
12167 		 */
12168 		if (((bf_get(lpfc_wcqe_c_status, wcqe) ==
12169 		     IOSTAT_LOCAL_REJECT)) &&
12170 		    ((wcqe->parameter & IOERR_PARAM_MASK) ==
12171 		     IOERR_NO_RESOURCES))
12172 			phba->lpfc_rampdown_queue_depth(phba);
12173 
12174 		/* Log the error status */
12175 		lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
12176 				"0373 FCP complete error: status=x%x, "
12177 				"hw_status=x%x, total_data_specified=%d, "
12178 				"parameter=x%x, word3=x%x\n",
12179 				bf_get(lpfc_wcqe_c_status, wcqe),
12180 				bf_get(lpfc_wcqe_c_hw_status, wcqe),
12181 				wcqe->total_data_placed, wcqe->parameter,
12182 				wcqe->word3);
12183 	}
12184 
12185 	/* Look up the FCP command IOCB and create pseudo response IOCB */
12186 	spin_lock_irqsave(&pring->ring_lock, iflags);
12187 	pring->stats.iocb_event++;
12188 	cmdiocbq = lpfc_sli_iocbq_lookup_by_tag(phba, pring,
12189 				bf_get(lpfc_wcqe_c_request_tag, wcqe));
12190 	spin_unlock_irqrestore(&pring->ring_lock, iflags);
12191 	if (unlikely(!cmdiocbq)) {
12192 		lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
12193 				"0374 FCP complete with no corresponding "
12194 				"cmdiocb: iotag (%d)\n",
12195 				bf_get(lpfc_wcqe_c_request_tag, wcqe));
12196 		return;
12197 	}
12198 	if (unlikely(!cmdiocbq->iocb_cmpl)) {
12199 		lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
12200 				"0375 FCP cmdiocb not callback function "
12201 				"iotag: (%d)\n",
12202 				bf_get(lpfc_wcqe_c_request_tag, wcqe));
12203 		return;
12204 	}
12205 
12206 	/* Fake the irspiocb and copy necessary response information */
12207 	lpfc_sli4_iocb_param_transfer(phba, &irspiocbq, cmdiocbq, wcqe);
12208 
12209 	if (cmdiocbq->iocb_flag & LPFC_DRIVER_ABORTED) {
12210 		spin_lock_irqsave(&phba->hbalock, iflags);
12211 		cmdiocbq->iocb_flag &= ~LPFC_DRIVER_ABORTED;
12212 		spin_unlock_irqrestore(&phba->hbalock, iflags);
12213 	}
12214 
12215 	/* Pass the cmd_iocb and the rsp state to the upper layer */
12216 	(cmdiocbq->iocb_cmpl)(phba, cmdiocbq, &irspiocbq);
12217 }
12218 
12219 /**
12220  * lpfc_sli4_fp_handle_rel_wcqe - Handle fast-path WQ entry consumed event
12221  * @phba: Pointer to HBA context object.
12222  * @cq: Pointer to completion queue.
12223  * @wcqe: Pointer to work-queue completion queue entry.
12224  *
12225  * This routine handles an fast-path WQ entry comsumed event by invoking the
12226  * proper WQ release routine to the slow-path WQ.
12227  **/
12228 static void
12229 lpfc_sli4_fp_handle_rel_wcqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
12230 			     struct lpfc_wcqe_release *wcqe)
12231 {
12232 	struct lpfc_queue *childwq;
12233 	bool wqid_matched = false;
12234 	uint16_t fcp_wqid;
12235 
12236 	/* Check for fast-path FCP work queue release */
12237 	fcp_wqid = bf_get(lpfc_wcqe_r_wq_id, wcqe);
12238 	list_for_each_entry(childwq, &cq->child_list, list) {
12239 		if (childwq->queue_id == fcp_wqid) {
12240 			lpfc_sli4_wq_release(childwq,
12241 					bf_get(lpfc_wcqe_r_wqe_index, wcqe));
12242 			wqid_matched = true;
12243 			break;
12244 		}
12245 	}
12246 	/* Report warning log message if no match found */
12247 	if (wqid_matched != true)
12248 		lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
12249 				"2580 Fast-path wqe consume event carries "
12250 				"miss-matched qid: wcqe-qid=x%x\n", fcp_wqid);
12251 }
12252 
12253 /**
12254  * lpfc_sli4_fp_handle_wcqe - Process fast-path work queue completion entry
12255  * @cq: Pointer to the completion queue.
12256  * @eqe: Pointer to fast-path completion queue entry.
12257  *
12258  * This routine process a fast-path work queue completion entry from fast-path
12259  * event queue for FCP command response completion.
12260  **/
12261 static int
12262 lpfc_sli4_fp_handle_wcqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
12263 			 struct lpfc_cqe *cqe)
12264 {
12265 	struct lpfc_wcqe_release wcqe;
12266 	bool workposted = false;
12267 
12268 	/* Copy the work queue CQE and convert endian order if needed */
12269 	lpfc_sli_pcimem_bcopy(cqe, &wcqe, sizeof(struct lpfc_cqe));
12270 
12271 	/* Check and process for different type of WCQE and dispatch */
12272 	switch (bf_get(lpfc_wcqe_c_code, &wcqe)) {
12273 	case CQE_CODE_COMPL_WQE:
12274 		cq->CQ_wq++;
12275 		/* Process the WQ complete event */
12276 		phba->last_completion_time = jiffies;
12277 		lpfc_sli4_fp_handle_fcp_wcqe(phba, cq,
12278 				(struct lpfc_wcqe_complete *)&wcqe);
12279 		break;
12280 	case CQE_CODE_RELEASE_WQE:
12281 		cq->CQ_release_wqe++;
12282 		/* Process the WQ release event */
12283 		lpfc_sli4_fp_handle_rel_wcqe(phba, cq,
12284 				(struct lpfc_wcqe_release *)&wcqe);
12285 		break;
12286 	case CQE_CODE_XRI_ABORTED:
12287 		cq->CQ_xri_aborted++;
12288 		/* Process the WQ XRI abort event */
12289 		phba->last_completion_time = jiffies;
12290 		workposted = lpfc_sli4_sp_handle_abort_xri_wcqe(phba, cq,
12291 				(struct sli4_wcqe_xri_aborted *)&wcqe);
12292 		break;
12293 	default:
12294 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12295 				"0144 Not a valid WCQE code: x%x\n",
12296 				bf_get(lpfc_wcqe_c_code, &wcqe));
12297 		break;
12298 	}
12299 	return workposted;
12300 }
12301 
12302 /**
12303  * lpfc_sli4_hba_handle_eqe - Process a fast-path event queue entry
12304  * @phba: Pointer to HBA context object.
12305  * @eqe: Pointer to fast-path event queue entry.
12306  *
12307  * This routine process a event queue entry from the fast-path event queue.
12308  * It will check the MajorCode and MinorCode to determine this is for a
12309  * completion event on a completion queue, if not, an error shall be logged
12310  * and just return. Otherwise, it will get to the corresponding completion
12311  * queue and process all the entries on the completion queue, rearm the
12312  * completion queue, and then return.
12313  **/
12314 static void
12315 lpfc_sli4_hba_handle_eqe(struct lpfc_hba *phba, struct lpfc_eqe *eqe,
12316 			uint32_t qidx)
12317 {
12318 	struct lpfc_queue *cq;
12319 	struct lpfc_cqe *cqe;
12320 	bool workposted = false;
12321 	uint16_t cqid;
12322 	int ecount = 0;
12323 
12324 	if (unlikely(bf_get_le32(lpfc_eqe_major_code, eqe) != 0)) {
12325 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12326 				"0366 Not a valid completion "
12327 				"event: majorcode=x%x, minorcode=x%x\n",
12328 				bf_get_le32(lpfc_eqe_major_code, eqe),
12329 				bf_get_le32(lpfc_eqe_minor_code, eqe));
12330 		return;
12331 	}
12332 
12333 	/* Get the reference to the corresponding CQ */
12334 	cqid = bf_get_le32(lpfc_eqe_resource_id, eqe);
12335 
12336 	/* Check if this is a Slow path event */
12337 	if (unlikely(cqid != phba->sli4_hba.fcp_cq_map[qidx])) {
12338 		lpfc_sli4_sp_handle_eqe(phba, eqe,
12339 			phba->sli4_hba.hba_eq[qidx]);
12340 		return;
12341 	}
12342 
12343 	if (unlikely(!phba->sli4_hba.fcp_cq)) {
12344 		lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
12345 				"3146 Fast-path completion queues "
12346 				"does not exist\n");
12347 		return;
12348 	}
12349 	cq = phba->sli4_hba.fcp_cq[qidx];
12350 	if (unlikely(!cq)) {
12351 		if (phba->sli.sli_flag & LPFC_SLI_ACTIVE)
12352 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12353 					"0367 Fast-path completion queue "
12354 					"(%d) does not exist\n", qidx);
12355 		return;
12356 	}
12357 
12358 	if (unlikely(cqid != cq->queue_id)) {
12359 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12360 				"0368 Miss-matched fast-path completion "
12361 				"queue identifier: eqcqid=%d, fcpcqid=%d\n",
12362 				cqid, cq->queue_id);
12363 		return;
12364 	}
12365 
12366 	/* Process all the entries to the CQ */
12367 	while ((cqe = lpfc_sli4_cq_get(cq))) {
12368 		workposted |= lpfc_sli4_fp_handle_wcqe(phba, cq, cqe);
12369 		if (!(++ecount % cq->entry_repost))
12370 			lpfc_sli4_cq_release(cq, LPFC_QUEUE_NOARM);
12371 	}
12372 
12373 	/* Track the max number of CQEs processed in 1 EQ */
12374 	if (ecount > cq->CQ_max_cqe)
12375 		cq->CQ_max_cqe = ecount;
12376 
12377 	/* Catch the no cq entry condition */
12378 	if (unlikely(ecount == 0))
12379 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12380 				"0369 No entry from fast-path completion "
12381 				"queue fcpcqid=%d\n", cq->queue_id);
12382 
12383 	/* In any case, flash and re-arm the CQ */
12384 	lpfc_sli4_cq_release(cq, LPFC_QUEUE_REARM);
12385 
12386 	/* wake up worker thread if there are works to be done */
12387 	if (workposted)
12388 		lpfc_worker_wake_up(phba);
12389 }
12390 
12391 static void
12392 lpfc_sli4_eq_flush(struct lpfc_hba *phba, struct lpfc_queue *eq)
12393 {
12394 	struct lpfc_eqe *eqe;
12395 
12396 	/* walk all the EQ entries and drop on the floor */
12397 	while ((eqe = lpfc_sli4_eq_get(eq)))
12398 		;
12399 
12400 	/* Clear and re-arm the EQ */
12401 	lpfc_sli4_eq_release(eq, LPFC_QUEUE_REARM);
12402 }
12403 
12404 
12405 /**
12406  * lpfc_sli4_fof_handle_eqe - Process a Flash Optimized Fabric event queue
12407  *			     entry
12408  * @phba: Pointer to HBA context object.
12409  * @eqe: Pointer to fast-path event queue entry.
12410  *
12411  * This routine process a event queue entry from the Flash Optimized Fabric
12412  * event queue.  It will check the MajorCode and MinorCode to determine this
12413  * is for a completion event on a completion queue, if not, an error shall be
12414  * logged and just return. Otherwise, it will get to the corresponding
12415  * completion queue and process all the entries on the completion queue, rearm
12416  * the completion queue, and then return.
12417  **/
12418 static void
12419 lpfc_sli4_fof_handle_eqe(struct lpfc_hba *phba, struct lpfc_eqe *eqe)
12420 {
12421 	struct lpfc_queue *cq;
12422 	struct lpfc_cqe *cqe;
12423 	bool workposted = false;
12424 	uint16_t cqid;
12425 	int ecount = 0;
12426 
12427 	if (unlikely(bf_get_le32(lpfc_eqe_major_code, eqe) != 0)) {
12428 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12429 				"9147 Not a valid completion "
12430 				"event: majorcode=x%x, minorcode=x%x\n",
12431 				bf_get_le32(lpfc_eqe_major_code, eqe),
12432 				bf_get_le32(lpfc_eqe_minor_code, eqe));
12433 		return;
12434 	}
12435 
12436 	/* Get the reference to the corresponding CQ */
12437 	cqid = bf_get_le32(lpfc_eqe_resource_id, eqe);
12438 
12439 	/* Next check for OAS */
12440 	cq = phba->sli4_hba.oas_cq;
12441 	if (unlikely(!cq)) {
12442 		if (phba->sli.sli_flag & LPFC_SLI_ACTIVE)
12443 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12444 					"9148 OAS completion queue "
12445 					"does not exist\n");
12446 		return;
12447 	}
12448 
12449 	if (unlikely(cqid != cq->queue_id)) {
12450 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12451 				"9149 Miss-matched fast-path compl "
12452 				"queue id: eqcqid=%d, fcpcqid=%d\n",
12453 				cqid, cq->queue_id);
12454 		return;
12455 	}
12456 
12457 	/* Process all the entries to the OAS CQ */
12458 	while ((cqe = lpfc_sli4_cq_get(cq))) {
12459 		workposted |= lpfc_sli4_fp_handle_wcqe(phba, cq, cqe);
12460 		if (!(++ecount % cq->entry_repost))
12461 			lpfc_sli4_cq_release(cq, LPFC_QUEUE_NOARM);
12462 	}
12463 
12464 	/* Track the max number of CQEs processed in 1 EQ */
12465 	if (ecount > cq->CQ_max_cqe)
12466 		cq->CQ_max_cqe = ecount;
12467 
12468 	/* Catch the no cq entry condition */
12469 	if (unlikely(ecount == 0))
12470 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12471 				"9153 No entry from fast-path completion "
12472 				"queue fcpcqid=%d\n", cq->queue_id);
12473 
12474 	/* In any case, flash and re-arm the CQ */
12475 	lpfc_sli4_cq_release(cq, LPFC_QUEUE_REARM);
12476 
12477 	/* wake up worker thread if there are works to be done */
12478 	if (workposted)
12479 		lpfc_worker_wake_up(phba);
12480 }
12481 
12482 /**
12483  * lpfc_sli4_fof_intr_handler - HBA interrupt handler to SLI-4 device
12484  * @irq: Interrupt number.
12485  * @dev_id: The device context pointer.
12486  *
12487  * This function is directly called from the PCI layer as an interrupt
12488  * service routine when device with SLI-4 interface spec is enabled with
12489  * MSI-X multi-message interrupt mode and there is a Flash Optimized Fabric
12490  * IOCB ring event in the HBA. However, when the device is enabled with either
12491  * MSI or Pin-IRQ interrupt mode, this function is called as part of the
12492  * device-level interrupt handler. When the PCI slot is in error recovery
12493  * or the HBA is undergoing initialization, the interrupt handler will not
12494  * process the interrupt. The Flash Optimized Fabric ring event are handled in
12495  * the intrrupt context. This function is called without any lock held.
12496  * It gets the hbalock to access and update SLI data structures. Note that,
12497  * the EQ to CQ are one-to-one map such that the EQ index is
12498  * equal to that of CQ index.
12499  *
12500  * This function returns IRQ_HANDLED when interrupt is handled else it
12501  * returns IRQ_NONE.
12502  **/
12503 irqreturn_t
12504 lpfc_sli4_fof_intr_handler(int irq, void *dev_id)
12505 {
12506 	struct lpfc_hba *phba;
12507 	struct lpfc_fcp_eq_hdl *fcp_eq_hdl;
12508 	struct lpfc_queue *eq;
12509 	struct lpfc_eqe *eqe;
12510 	unsigned long iflag;
12511 	int ecount = 0;
12512 	uint32_t eqidx;
12513 
12514 	/* Get the driver's phba structure from the dev_id */
12515 	fcp_eq_hdl = (struct lpfc_fcp_eq_hdl *)dev_id;
12516 	phba = fcp_eq_hdl->phba;
12517 	eqidx = fcp_eq_hdl->idx;
12518 
12519 	if (unlikely(!phba))
12520 		return IRQ_NONE;
12521 
12522 	/* Get to the EQ struct associated with this vector */
12523 	eq = phba->sli4_hba.fof_eq;
12524 	if (unlikely(!eq))
12525 		return IRQ_NONE;
12526 
12527 	/* Check device state for handling interrupt */
12528 	if (unlikely(lpfc_intr_state_check(phba))) {
12529 		eq->EQ_badstate++;
12530 		/* Check again for link_state with lock held */
12531 		spin_lock_irqsave(&phba->hbalock, iflag);
12532 		if (phba->link_state < LPFC_LINK_DOWN)
12533 			/* Flush, clear interrupt, and rearm the EQ */
12534 			lpfc_sli4_eq_flush(phba, eq);
12535 		spin_unlock_irqrestore(&phba->hbalock, iflag);
12536 		return IRQ_NONE;
12537 	}
12538 
12539 	/*
12540 	 * Process all the event on FCP fast-path EQ
12541 	 */
12542 	while ((eqe = lpfc_sli4_eq_get(eq))) {
12543 		lpfc_sli4_fof_handle_eqe(phba, eqe);
12544 		if (!(++ecount % eq->entry_repost))
12545 			lpfc_sli4_eq_release(eq, LPFC_QUEUE_NOARM);
12546 		eq->EQ_processed++;
12547 	}
12548 
12549 	/* Track the max number of EQEs processed in 1 intr */
12550 	if (ecount > eq->EQ_max_eqe)
12551 		eq->EQ_max_eqe = ecount;
12552 
12553 
12554 	if (unlikely(ecount == 0)) {
12555 		eq->EQ_no_entry++;
12556 
12557 		if (phba->intr_type == MSIX)
12558 			/* MSI-X treated interrupt served as no EQ share INT */
12559 			lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
12560 					"9145 MSI-X interrupt with no EQE\n");
12561 		else {
12562 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
12563 					"9146 ISR interrupt with no EQE\n");
12564 			/* Non MSI-X treated on interrupt as EQ share INT */
12565 			return IRQ_NONE;
12566 		}
12567 	}
12568 	/* Always clear and re-arm the fast-path EQ */
12569 	lpfc_sli4_eq_release(eq, LPFC_QUEUE_REARM);
12570 	return IRQ_HANDLED;
12571 }
12572 
12573 /**
12574  * lpfc_sli4_hba_intr_handler - HBA interrupt handler to SLI-4 device
12575  * @irq: Interrupt number.
12576  * @dev_id: The device context pointer.
12577  *
12578  * This function is directly called from the PCI layer as an interrupt
12579  * service routine when device with SLI-4 interface spec is enabled with
12580  * MSI-X multi-message interrupt mode and there is a fast-path FCP IOCB
12581  * ring event in the HBA. However, when the device is enabled with either
12582  * MSI or Pin-IRQ interrupt mode, this function is called as part of the
12583  * device-level interrupt handler. When the PCI slot is in error recovery
12584  * or the HBA is undergoing initialization, the interrupt handler will not
12585  * process the interrupt. The SCSI FCP fast-path ring event are handled in
12586  * the intrrupt context. This function is called without any lock held.
12587  * It gets the hbalock to access and update SLI data structures. Note that,
12588  * the FCP EQ to FCP CQ are one-to-one map such that the FCP EQ index is
12589  * equal to that of FCP CQ index.
12590  *
12591  * The link attention and ELS ring attention events are handled
12592  * by the worker thread. The interrupt handler signals the worker thread
12593  * and returns for these events. This function is called without any lock
12594  * held. It gets the hbalock to access and update SLI data structures.
12595  *
12596  * This function returns IRQ_HANDLED when interrupt is handled else it
12597  * returns IRQ_NONE.
12598  **/
12599 irqreturn_t
12600 lpfc_sli4_hba_intr_handler(int irq, void *dev_id)
12601 {
12602 	struct lpfc_hba *phba;
12603 	struct lpfc_fcp_eq_hdl *fcp_eq_hdl;
12604 	struct lpfc_queue *fpeq;
12605 	struct lpfc_eqe *eqe;
12606 	unsigned long iflag;
12607 	int ecount = 0;
12608 	int fcp_eqidx;
12609 
12610 	/* Get the driver's phba structure from the dev_id */
12611 	fcp_eq_hdl = (struct lpfc_fcp_eq_hdl *)dev_id;
12612 	phba = fcp_eq_hdl->phba;
12613 	fcp_eqidx = fcp_eq_hdl->idx;
12614 
12615 	if (unlikely(!phba))
12616 		return IRQ_NONE;
12617 	if (unlikely(!phba->sli4_hba.hba_eq))
12618 		return IRQ_NONE;
12619 
12620 	/* Get to the EQ struct associated with this vector */
12621 	fpeq = phba->sli4_hba.hba_eq[fcp_eqidx];
12622 	if (unlikely(!fpeq))
12623 		return IRQ_NONE;
12624 
12625 	if (lpfc_fcp_look_ahead) {
12626 		if (atomic_dec_and_test(&fcp_eq_hdl->fcp_eq_in_use))
12627 			lpfc_sli4_eq_clr_intr(fpeq);
12628 		else {
12629 			atomic_inc(&fcp_eq_hdl->fcp_eq_in_use);
12630 			return IRQ_NONE;
12631 		}
12632 	}
12633 
12634 	/* Check device state for handling interrupt */
12635 	if (unlikely(lpfc_intr_state_check(phba))) {
12636 		fpeq->EQ_badstate++;
12637 		/* Check again for link_state with lock held */
12638 		spin_lock_irqsave(&phba->hbalock, iflag);
12639 		if (phba->link_state < LPFC_LINK_DOWN)
12640 			/* Flush, clear interrupt, and rearm the EQ */
12641 			lpfc_sli4_eq_flush(phba, fpeq);
12642 		spin_unlock_irqrestore(&phba->hbalock, iflag);
12643 		if (lpfc_fcp_look_ahead)
12644 			atomic_inc(&fcp_eq_hdl->fcp_eq_in_use);
12645 		return IRQ_NONE;
12646 	}
12647 
12648 	/*
12649 	 * Process all the event on FCP fast-path EQ
12650 	 */
12651 	while ((eqe = lpfc_sli4_eq_get(fpeq))) {
12652 		if (eqe == NULL)
12653 			break;
12654 
12655 		lpfc_sli4_hba_handle_eqe(phba, eqe, fcp_eqidx);
12656 		if (!(++ecount % fpeq->entry_repost))
12657 			lpfc_sli4_eq_release(fpeq, LPFC_QUEUE_NOARM);
12658 		fpeq->EQ_processed++;
12659 	}
12660 
12661 	/* Track the max number of EQEs processed in 1 intr */
12662 	if (ecount > fpeq->EQ_max_eqe)
12663 		fpeq->EQ_max_eqe = ecount;
12664 
12665 	/* Always clear and re-arm the fast-path EQ */
12666 	lpfc_sli4_eq_release(fpeq, LPFC_QUEUE_REARM);
12667 
12668 	if (unlikely(ecount == 0)) {
12669 		fpeq->EQ_no_entry++;
12670 
12671 		if (lpfc_fcp_look_ahead) {
12672 			atomic_inc(&fcp_eq_hdl->fcp_eq_in_use);
12673 			return IRQ_NONE;
12674 		}
12675 
12676 		if (phba->intr_type == MSIX)
12677 			/* MSI-X treated interrupt served as no EQ share INT */
12678 			lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
12679 					"0358 MSI-X interrupt with no EQE\n");
12680 		else
12681 			/* Non MSI-X treated on interrupt as EQ share INT */
12682 			return IRQ_NONE;
12683 	}
12684 
12685 	if (lpfc_fcp_look_ahead)
12686 		atomic_inc(&fcp_eq_hdl->fcp_eq_in_use);
12687 	return IRQ_HANDLED;
12688 } /* lpfc_sli4_fp_intr_handler */
12689 
12690 /**
12691  * lpfc_sli4_intr_handler - Device-level interrupt handler for SLI-4 device
12692  * @irq: Interrupt number.
12693  * @dev_id: The device context pointer.
12694  *
12695  * This function is the device-level interrupt handler to device with SLI-4
12696  * interface spec, called from the PCI layer when either MSI or Pin-IRQ
12697  * interrupt mode is enabled and there is an event in the HBA which requires
12698  * driver attention. This function invokes the slow-path interrupt attention
12699  * handling function and fast-path interrupt attention handling function in
12700  * turn to process the relevant HBA attention events. This function is called
12701  * without any lock held. It gets the hbalock to access and update SLI data
12702  * structures.
12703  *
12704  * This function returns IRQ_HANDLED when interrupt is handled, else it
12705  * returns IRQ_NONE.
12706  **/
12707 irqreturn_t
12708 lpfc_sli4_intr_handler(int irq, void *dev_id)
12709 {
12710 	struct lpfc_hba  *phba;
12711 	irqreturn_t hba_irq_rc;
12712 	bool hba_handled = false;
12713 	int fcp_eqidx;
12714 
12715 	/* Get the driver's phba structure from the dev_id */
12716 	phba = (struct lpfc_hba *)dev_id;
12717 
12718 	if (unlikely(!phba))
12719 		return IRQ_NONE;
12720 
12721 	/*
12722 	 * Invoke fast-path host attention interrupt handling as appropriate.
12723 	 */
12724 	for (fcp_eqidx = 0; fcp_eqidx < phba->cfg_fcp_io_channel; fcp_eqidx++) {
12725 		hba_irq_rc = lpfc_sli4_hba_intr_handler(irq,
12726 					&phba->sli4_hba.fcp_eq_hdl[fcp_eqidx]);
12727 		if (hba_irq_rc == IRQ_HANDLED)
12728 			hba_handled |= true;
12729 	}
12730 
12731 	if (phba->cfg_fof) {
12732 		hba_irq_rc = lpfc_sli4_fof_intr_handler(irq,
12733 					&phba->sli4_hba.fcp_eq_hdl[0]);
12734 		if (hba_irq_rc == IRQ_HANDLED)
12735 			hba_handled |= true;
12736 	}
12737 
12738 	return (hba_handled == true) ? IRQ_HANDLED : IRQ_NONE;
12739 } /* lpfc_sli4_intr_handler */
12740 
12741 /**
12742  * lpfc_sli4_queue_free - free a queue structure and associated memory
12743  * @queue: The queue structure to free.
12744  *
12745  * This function frees a queue structure and the DMAable memory used for
12746  * the host resident queue. This function must be called after destroying the
12747  * queue on the HBA.
12748  **/
12749 void
12750 lpfc_sli4_queue_free(struct lpfc_queue *queue)
12751 {
12752 	struct lpfc_dmabuf *dmabuf;
12753 
12754 	if (!queue)
12755 		return;
12756 
12757 	while (!list_empty(&queue->page_list)) {
12758 		list_remove_head(&queue->page_list, dmabuf, struct lpfc_dmabuf,
12759 				 list);
12760 		dma_free_coherent(&queue->phba->pcidev->dev, SLI4_PAGE_SIZE,
12761 				  dmabuf->virt, dmabuf->phys);
12762 		kfree(dmabuf);
12763 	}
12764 	kfree(queue);
12765 	return;
12766 }
12767 
12768 /**
12769  * lpfc_sli4_queue_alloc - Allocate and initialize a queue structure
12770  * @phba: The HBA that this queue is being created on.
12771  * @entry_size: The size of each queue entry for this queue.
12772  * @entry count: The number of entries that this queue will handle.
12773  *
12774  * This function allocates a queue structure and the DMAable memory used for
12775  * the host resident queue. This function must be called before creating the
12776  * queue on the HBA.
12777  **/
12778 struct lpfc_queue *
12779 lpfc_sli4_queue_alloc(struct lpfc_hba *phba, uint32_t entry_size,
12780 		      uint32_t entry_count)
12781 {
12782 	struct lpfc_queue *queue;
12783 	struct lpfc_dmabuf *dmabuf;
12784 	int x, total_qe_count;
12785 	void *dma_pointer;
12786 	uint32_t hw_page_size = phba->sli4_hba.pc_sli4_params.if_page_sz;
12787 
12788 	if (!phba->sli4_hba.pc_sli4_params.supported)
12789 		hw_page_size = SLI4_PAGE_SIZE;
12790 
12791 	queue = kzalloc(sizeof(struct lpfc_queue) +
12792 			(sizeof(union sli4_qe) * entry_count), GFP_KERNEL);
12793 	if (!queue)
12794 		return NULL;
12795 	queue->page_count = (ALIGN(entry_size * entry_count,
12796 			hw_page_size))/hw_page_size;
12797 	INIT_LIST_HEAD(&queue->list);
12798 	INIT_LIST_HEAD(&queue->page_list);
12799 	INIT_LIST_HEAD(&queue->child_list);
12800 	for (x = 0, total_qe_count = 0; x < queue->page_count; x++) {
12801 		dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
12802 		if (!dmabuf)
12803 			goto out_fail;
12804 		dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev,
12805 						   hw_page_size, &dmabuf->phys,
12806 						   GFP_KERNEL);
12807 		if (!dmabuf->virt) {
12808 			kfree(dmabuf);
12809 			goto out_fail;
12810 		}
12811 		dmabuf->buffer_tag = x;
12812 		list_add_tail(&dmabuf->list, &queue->page_list);
12813 		/* initialize queue's entry array */
12814 		dma_pointer = dmabuf->virt;
12815 		for (; total_qe_count < entry_count &&
12816 		     dma_pointer < (hw_page_size + dmabuf->virt);
12817 		     total_qe_count++, dma_pointer += entry_size) {
12818 			queue->qe[total_qe_count].address = dma_pointer;
12819 		}
12820 	}
12821 	queue->entry_size = entry_size;
12822 	queue->entry_count = entry_count;
12823 
12824 	/*
12825 	 * entry_repost is calculated based on the number of entries in the
12826 	 * queue. This works out except for RQs. If buffers are NOT initially
12827 	 * posted for every RQE, entry_repost should be adjusted accordingly.
12828 	 */
12829 	queue->entry_repost = (entry_count >> 3);
12830 	if (queue->entry_repost < LPFC_QUEUE_MIN_REPOST)
12831 		queue->entry_repost = LPFC_QUEUE_MIN_REPOST;
12832 	queue->phba = phba;
12833 
12834 	return queue;
12835 out_fail:
12836 	lpfc_sli4_queue_free(queue);
12837 	return NULL;
12838 }
12839 
12840 /**
12841  * lpfc_dual_chute_pci_bar_map - Map pci base address register to host memory
12842  * @phba: HBA structure that indicates port to create a queue on.
12843  * @pci_barset: PCI BAR set flag.
12844  *
12845  * This function shall perform iomap of the specified PCI BAR address to host
12846  * memory address if not already done so and return it. The returned host
12847  * memory address can be NULL.
12848  */
12849 static void __iomem *
12850 lpfc_dual_chute_pci_bar_map(struct lpfc_hba *phba, uint16_t pci_barset)
12851 {
12852 	struct pci_dev *pdev;
12853 
12854 	if (!phba->pcidev)
12855 		return NULL;
12856 	else
12857 		pdev = phba->pcidev;
12858 
12859 	switch (pci_barset) {
12860 	case WQ_PCI_BAR_0_AND_1:
12861 		return phba->pci_bar0_memmap_p;
12862 	case WQ_PCI_BAR_2_AND_3:
12863 		return phba->pci_bar2_memmap_p;
12864 	case WQ_PCI_BAR_4_AND_5:
12865 		return phba->pci_bar4_memmap_p;
12866 	default:
12867 		break;
12868 	}
12869 	return NULL;
12870 }
12871 
12872 /**
12873  * lpfc_modify_fcp_eq_delay - Modify Delay Multiplier on FCP EQs
12874  * @phba: HBA structure that indicates port to create a queue on.
12875  * @startq: The starting FCP EQ to modify
12876  *
12877  * This function sends an MODIFY_EQ_DELAY mailbox command to the HBA.
12878  *
12879  * The @phba struct is used to send mailbox command to HBA. The @startq
12880  * is used to get the starting FCP EQ to change.
12881  * This function is asynchronous and will wait for the mailbox
12882  * command to finish before continuing.
12883  *
12884  * On success this function will return a zero. If unable to allocate enough
12885  * memory this function will return -ENOMEM. If the queue create mailbox command
12886  * fails this function will return -ENXIO.
12887  **/
12888 int
12889 lpfc_modify_fcp_eq_delay(struct lpfc_hba *phba, uint32_t startq)
12890 {
12891 	struct lpfc_mbx_modify_eq_delay *eq_delay;
12892 	LPFC_MBOXQ_t *mbox;
12893 	struct lpfc_queue *eq;
12894 	int cnt, rc, length, status = 0;
12895 	uint32_t shdr_status, shdr_add_status;
12896 	uint32_t result;
12897 	int fcp_eqidx;
12898 	union lpfc_sli4_cfg_shdr *shdr;
12899 	uint16_t dmult;
12900 
12901 	if (startq >= phba->cfg_fcp_io_channel)
12902 		return 0;
12903 
12904 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
12905 	if (!mbox)
12906 		return -ENOMEM;
12907 	length = (sizeof(struct lpfc_mbx_modify_eq_delay) -
12908 		  sizeof(struct lpfc_sli4_cfg_mhdr));
12909 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
12910 			 LPFC_MBOX_OPCODE_MODIFY_EQ_DELAY,
12911 			 length, LPFC_SLI4_MBX_EMBED);
12912 	eq_delay = &mbox->u.mqe.un.eq_delay;
12913 
12914 	/* Calculate delay multiper from maximum interrupt per second */
12915 	result = phba->cfg_fcp_imax / phba->cfg_fcp_io_channel;
12916 	if (result > LPFC_DMULT_CONST)
12917 		dmult = 0;
12918 	else
12919 		dmult = LPFC_DMULT_CONST/result - 1;
12920 
12921 	cnt = 0;
12922 	for (fcp_eqidx = startq; fcp_eqidx < phba->cfg_fcp_io_channel;
12923 	    fcp_eqidx++) {
12924 		eq = phba->sli4_hba.hba_eq[fcp_eqidx];
12925 		if (!eq)
12926 			continue;
12927 		eq_delay->u.request.eq[cnt].eq_id = eq->queue_id;
12928 		eq_delay->u.request.eq[cnt].phase = 0;
12929 		eq_delay->u.request.eq[cnt].delay_multi = dmult;
12930 		cnt++;
12931 		if (cnt >= LPFC_MAX_EQ_DELAY)
12932 			break;
12933 	}
12934 	eq_delay->u.request.num_eq = cnt;
12935 
12936 	mbox->vport = phba->pport;
12937 	mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
12938 	mbox->context1 = NULL;
12939 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
12940 	shdr = (union lpfc_sli4_cfg_shdr *) &eq_delay->header.cfg_shdr;
12941 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
12942 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
12943 	if (shdr_status || shdr_add_status || rc) {
12944 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
12945 				"2512 MODIFY_EQ_DELAY mailbox failed with "
12946 				"status x%x add_status x%x, mbx status x%x\n",
12947 				shdr_status, shdr_add_status, rc);
12948 		status = -ENXIO;
12949 	}
12950 	mempool_free(mbox, phba->mbox_mem_pool);
12951 	return status;
12952 }
12953 
12954 /**
12955  * lpfc_eq_create - Create an Event Queue on the HBA
12956  * @phba: HBA structure that indicates port to create a queue on.
12957  * @eq: The queue structure to use to create the event queue.
12958  * @imax: The maximum interrupt per second limit.
12959  *
12960  * This function creates an event queue, as detailed in @eq, on a port,
12961  * described by @phba by sending an EQ_CREATE mailbox command to the HBA.
12962  *
12963  * The @phba struct is used to send mailbox command to HBA. The @eq struct
12964  * is used to get the entry count and entry size that are necessary to
12965  * determine the number of pages to allocate and use for this queue. This
12966  * function will send the EQ_CREATE mailbox command to the HBA to setup the
12967  * event queue. This function is asynchronous and will wait for the mailbox
12968  * command to finish before continuing.
12969  *
12970  * On success this function will return a zero. If unable to allocate enough
12971  * memory this function will return -ENOMEM. If the queue create mailbox command
12972  * fails this function will return -ENXIO.
12973  **/
12974 int
12975 lpfc_eq_create(struct lpfc_hba *phba, struct lpfc_queue *eq, uint32_t imax)
12976 {
12977 	struct lpfc_mbx_eq_create *eq_create;
12978 	LPFC_MBOXQ_t *mbox;
12979 	int rc, length, status = 0;
12980 	struct lpfc_dmabuf *dmabuf;
12981 	uint32_t shdr_status, shdr_add_status;
12982 	union lpfc_sli4_cfg_shdr *shdr;
12983 	uint16_t dmult;
12984 	uint32_t hw_page_size = phba->sli4_hba.pc_sli4_params.if_page_sz;
12985 
12986 	/* sanity check on queue memory */
12987 	if (!eq)
12988 		return -ENODEV;
12989 	if (!phba->sli4_hba.pc_sli4_params.supported)
12990 		hw_page_size = SLI4_PAGE_SIZE;
12991 
12992 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
12993 	if (!mbox)
12994 		return -ENOMEM;
12995 	length = (sizeof(struct lpfc_mbx_eq_create) -
12996 		  sizeof(struct lpfc_sli4_cfg_mhdr));
12997 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
12998 			 LPFC_MBOX_OPCODE_EQ_CREATE,
12999 			 length, LPFC_SLI4_MBX_EMBED);
13000 	eq_create = &mbox->u.mqe.un.eq_create;
13001 	bf_set(lpfc_mbx_eq_create_num_pages, &eq_create->u.request,
13002 	       eq->page_count);
13003 	bf_set(lpfc_eq_context_size, &eq_create->u.request.context,
13004 	       LPFC_EQE_SIZE);
13005 	bf_set(lpfc_eq_context_valid, &eq_create->u.request.context, 1);
13006 	/* don't setup delay multiplier using EQ_CREATE */
13007 	dmult = 0;
13008 	bf_set(lpfc_eq_context_delay_multi, &eq_create->u.request.context,
13009 	       dmult);
13010 	switch (eq->entry_count) {
13011 	default:
13012 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
13013 				"0360 Unsupported EQ count. (%d)\n",
13014 				eq->entry_count);
13015 		if (eq->entry_count < 256)
13016 			return -EINVAL;
13017 		/* otherwise default to smallest count (drop through) */
13018 	case 256:
13019 		bf_set(lpfc_eq_context_count, &eq_create->u.request.context,
13020 		       LPFC_EQ_CNT_256);
13021 		break;
13022 	case 512:
13023 		bf_set(lpfc_eq_context_count, &eq_create->u.request.context,
13024 		       LPFC_EQ_CNT_512);
13025 		break;
13026 	case 1024:
13027 		bf_set(lpfc_eq_context_count, &eq_create->u.request.context,
13028 		       LPFC_EQ_CNT_1024);
13029 		break;
13030 	case 2048:
13031 		bf_set(lpfc_eq_context_count, &eq_create->u.request.context,
13032 		       LPFC_EQ_CNT_2048);
13033 		break;
13034 	case 4096:
13035 		bf_set(lpfc_eq_context_count, &eq_create->u.request.context,
13036 		       LPFC_EQ_CNT_4096);
13037 		break;
13038 	}
13039 	list_for_each_entry(dmabuf, &eq->page_list, list) {
13040 		memset(dmabuf->virt, 0, hw_page_size);
13041 		eq_create->u.request.page[dmabuf->buffer_tag].addr_lo =
13042 					putPaddrLow(dmabuf->phys);
13043 		eq_create->u.request.page[dmabuf->buffer_tag].addr_hi =
13044 					putPaddrHigh(dmabuf->phys);
13045 	}
13046 	mbox->vport = phba->pport;
13047 	mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
13048 	mbox->context1 = NULL;
13049 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
13050 	shdr = (union lpfc_sli4_cfg_shdr *) &eq_create->header.cfg_shdr;
13051 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
13052 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
13053 	if (shdr_status || shdr_add_status || rc) {
13054 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13055 				"2500 EQ_CREATE mailbox failed with "
13056 				"status x%x add_status x%x, mbx status x%x\n",
13057 				shdr_status, shdr_add_status, rc);
13058 		status = -ENXIO;
13059 	}
13060 	eq->type = LPFC_EQ;
13061 	eq->subtype = LPFC_NONE;
13062 	eq->queue_id = bf_get(lpfc_mbx_eq_create_q_id, &eq_create->u.response);
13063 	if (eq->queue_id == 0xFFFF)
13064 		status = -ENXIO;
13065 	eq->host_index = 0;
13066 	eq->hba_index = 0;
13067 
13068 	mempool_free(mbox, phba->mbox_mem_pool);
13069 	return status;
13070 }
13071 
13072 /**
13073  * lpfc_cq_create - Create a Completion Queue on the HBA
13074  * @phba: HBA structure that indicates port to create a queue on.
13075  * @cq: The queue structure to use to create the completion queue.
13076  * @eq: The event queue to bind this completion queue to.
13077  *
13078  * This function creates a completion queue, as detailed in @wq, on a port,
13079  * described by @phba by sending a CQ_CREATE mailbox command to the HBA.
13080  *
13081  * The @phba struct is used to send mailbox command to HBA. The @cq struct
13082  * is used to get the entry count and entry size that are necessary to
13083  * determine the number of pages to allocate and use for this queue. The @eq
13084  * is used to indicate which event queue to bind this completion queue to. This
13085  * function will send the CQ_CREATE mailbox command to the HBA to setup the
13086  * completion queue. This function is asynchronous and will wait for the mailbox
13087  * command to finish before continuing.
13088  *
13089  * On success this function will return a zero. If unable to allocate enough
13090  * memory this function will return -ENOMEM. If the queue create mailbox command
13091  * fails this function will return -ENXIO.
13092  **/
13093 int
13094 lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
13095 	       struct lpfc_queue *eq, uint32_t type, uint32_t subtype)
13096 {
13097 	struct lpfc_mbx_cq_create *cq_create;
13098 	struct lpfc_dmabuf *dmabuf;
13099 	LPFC_MBOXQ_t *mbox;
13100 	int rc, length, status = 0;
13101 	uint32_t shdr_status, shdr_add_status;
13102 	union lpfc_sli4_cfg_shdr *shdr;
13103 	uint32_t hw_page_size = phba->sli4_hba.pc_sli4_params.if_page_sz;
13104 
13105 	/* sanity check on queue memory */
13106 	if (!cq || !eq)
13107 		return -ENODEV;
13108 	if (!phba->sli4_hba.pc_sli4_params.supported)
13109 		hw_page_size = SLI4_PAGE_SIZE;
13110 
13111 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
13112 	if (!mbox)
13113 		return -ENOMEM;
13114 	length = (sizeof(struct lpfc_mbx_cq_create) -
13115 		  sizeof(struct lpfc_sli4_cfg_mhdr));
13116 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
13117 			 LPFC_MBOX_OPCODE_CQ_CREATE,
13118 			 length, LPFC_SLI4_MBX_EMBED);
13119 	cq_create = &mbox->u.mqe.un.cq_create;
13120 	shdr = (union lpfc_sli4_cfg_shdr *) &cq_create->header.cfg_shdr;
13121 	bf_set(lpfc_mbx_cq_create_num_pages, &cq_create->u.request,
13122 		    cq->page_count);
13123 	bf_set(lpfc_cq_context_event, &cq_create->u.request.context, 1);
13124 	bf_set(lpfc_cq_context_valid, &cq_create->u.request.context, 1);
13125 	bf_set(lpfc_mbox_hdr_version, &shdr->request,
13126 	       phba->sli4_hba.pc_sli4_params.cqv);
13127 	if (phba->sli4_hba.pc_sli4_params.cqv == LPFC_Q_CREATE_VERSION_2) {
13128 		/* FW only supports 1. Should be PAGE_SIZE/SLI4_PAGE_SIZE */
13129 		bf_set(lpfc_mbx_cq_create_page_size, &cq_create->u.request, 1);
13130 		bf_set(lpfc_cq_eq_id_2, &cq_create->u.request.context,
13131 		       eq->queue_id);
13132 	} else {
13133 		bf_set(lpfc_cq_eq_id, &cq_create->u.request.context,
13134 		       eq->queue_id);
13135 	}
13136 	switch (cq->entry_count) {
13137 	default:
13138 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
13139 				"0361 Unsupported CQ count. (%d)\n",
13140 				cq->entry_count);
13141 		if (cq->entry_count < 256) {
13142 			status = -EINVAL;
13143 			goto out;
13144 		}
13145 		/* otherwise default to smallest count (drop through) */
13146 	case 256:
13147 		bf_set(lpfc_cq_context_count, &cq_create->u.request.context,
13148 		       LPFC_CQ_CNT_256);
13149 		break;
13150 	case 512:
13151 		bf_set(lpfc_cq_context_count, &cq_create->u.request.context,
13152 		       LPFC_CQ_CNT_512);
13153 		break;
13154 	case 1024:
13155 		bf_set(lpfc_cq_context_count, &cq_create->u.request.context,
13156 		       LPFC_CQ_CNT_1024);
13157 		break;
13158 	}
13159 	list_for_each_entry(dmabuf, &cq->page_list, list) {
13160 		memset(dmabuf->virt, 0, hw_page_size);
13161 		cq_create->u.request.page[dmabuf->buffer_tag].addr_lo =
13162 					putPaddrLow(dmabuf->phys);
13163 		cq_create->u.request.page[dmabuf->buffer_tag].addr_hi =
13164 					putPaddrHigh(dmabuf->phys);
13165 	}
13166 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
13167 
13168 	/* The IOCTL status is embedded in the mailbox subheader. */
13169 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
13170 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
13171 	if (shdr_status || shdr_add_status || rc) {
13172 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13173 				"2501 CQ_CREATE mailbox failed with "
13174 				"status x%x add_status x%x, mbx status x%x\n",
13175 				shdr_status, shdr_add_status, rc);
13176 		status = -ENXIO;
13177 		goto out;
13178 	}
13179 	cq->queue_id = bf_get(lpfc_mbx_cq_create_q_id, &cq_create->u.response);
13180 	if (cq->queue_id == 0xFFFF) {
13181 		status = -ENXIO;
13182 		goto out;
13183 	}
13184 	/* link the cq onto the parent eq child list */
13185 	list_add_tail(&cq->list, &eq->child_list);
13186 	/* Set up completion queue's type and subtype */
13187 	cq->type = type;
13188 	cq->subtype = subtype;
13189 	cq->queue_id = bf_get(lpfc_mbx_cq_create_q_id, &cq_create->u.response);
13190 	cq->assoc_qid = eq->queue_id;
13191 	cq->host_index = 0;
13192 	cq->hba_index = 0;
13193 
13194 out:
13195 	mempool_free(mbox, phba->mbox_mem_pool);
13196 	return status;
13197 }
13198 
13199 /**
13200  * lpfc_mq_create_fb_init - Send MCC_CREATE without async events registration
13201  * @phba: HBA structure that indicates port to create a queue on.
13202  * @mq: The queue structure to use to create the mailbox queue.
13203  * @mbox: An allocated pointer to type LPFC_MBOXQ_t
13204  * @cq: The completion queue to associate with this cq.
13205  *
13206  * This function provides failback (fb) functionality when the
13207  * mq_create_ext fails on older FW generations.  It's purpose is identical
13208  * to mq_create_ext otherwise.
13209  *
13210  * This routine cannot fail as all attributes were previously accessed and
13211  * initialized in mq_create_ext.
13212  **/
13213 static void
13214 lpfc_mq_create_fb_init(struct lpfc_hba *phba, struct lpfc_queue *mq,
13215 		       LPFC_MBOXQ_t *mbox, struct lpfc_queue *cq)
13216 {
13217 	struct lpfc_mbx_mq_create *mq_create;
13218 	struct lpfc_dmabuf *dmabuf;
13219 	int length;
13220 
13221 	length = (sizeof(struct lpfc_mbx_mq_create) -
13222 		  sizeof(struct lpfc_sli4_cfg_mhdr));
13223 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
13224 			 LPFC_MBOX_OPCODE_MQ_CREATE,
13225 			 length, LPFC_SLI4_MBX_EMBED);
13226 	mq_create = &mbox->u.mqe.un.mq_create;
13227 	bf_set(lpfc_mbx_mq_create_num_pages, &mq_create->u.request,
13228 	       mq->page_count);
13229 	bf_set(lpfc_mq_context_cq_id, &mq_create->u.request.context,
13230 	       cq->queue_id);
13231 	bf_set(lpfc_mq_context_valid, &mq_create->u.request.context, 1);
13232 	switch (mq->entry_count) {
13233 	case 16:
13234 		bf_set(lpfc_mq_context_ring_size, &mq_create->u.request.context,
13235 		       LPFC_MQ_RING_SIZE_16);
13236 		break;
13237 	case 32:
13238 		bf_set(lpfc_mq_context_ring_size, &mq_create->u.request.context,
13239 		       LPFC_MQ_RING_SIZE_32);
13240 		break;
13241 	case 64:
13242 		bf_set(lpfc_mq_context_ring_size, &mq_create->u.request.context,
13243 		       LPFC_MQ_RING_SIZE_64);
13244 		break;
13245 	case 128:
13246 		bf_set(lpfc_mq_context_ring_size, &mq_create->u.request.context,
13247 		       LPFC_MQ_RING_SIZE_128);
13248 		break;
13249 	}
13250 	list_for_each_entry(dmabuf, &mq->page_list, list) {
13251 		mq_create->u.request.page[dmabuf->buffer_tag].addr_lo =
13252 			putPaddrLow(dmabuf->phys);
13253 		mq_create->u.request.page[dmabuf->buffer_tag].addr_hi =
13254 			putPaddrHigh(dmabuf->phys);
13255 	}
13256 }
13257 
13258 /**
13259  * lpfc_mq_create - Create a mailbox Queue on the HBA
13260  * @phba: HBA structure that indicates port to create a queue on.
13261  * @mq: The queue structure to use to create the mailbox queue.
13262  * @cq: The completion queue to associate with this cq.
13263  * @subtype: The queue's subtype.
13264  *
13265  * This function creates a mailbox queue, as detailed in @mq, on a port,
13266  * described by @phba by sending a MQ_CREATE mailbox command to the HBA.
13267  *
13268  * The @phba struct is used to send mailbox command to HBA. The @cq struct
13269  * is used to get the entry count and entry size that are necessary to
13270  * determine the number of pages to allocate and use for this queue. This
13271  * function will send the MQ_CREATE mailbox command to the HBA to setup the
13272  * mailbox queue. This function is asynchronous and will wait for the mailbox
13273  * command to finish before continuing.
13274  *
13275  * On success this function will return a zero. If unable to allocate enough
13276  * memory this function will return -ENOMEM. If the queue create mailbox command
13277  * fails this function will return -ENXIO.
13278  **/
13279 int32_t
13280 lpfc_mq_create(struct lpfc_hba *phba, struct lpfc_queue *mq,
13281 	       struct lpfc_queue *cq, uint32_t subtype)
13282 {
13283 	struct lpfc_mbx_mq_create *mq_create;
13284 	struct lpfc_mbx_mq_create_ext *mq_create_ext;
13285 	struct lpfc_dmabuf *dmabuf;
13286 	LPFC_MBOXQ_t *mbox;
13287 	int rc, length, status = 0;
13288 	uint32_t shdr_status, shdr_add_status;
13289 	union lpfc_sli4_cfg_shdr *shdr;
13290 	uint32_t hw_page_size = phba->sli4_hba.pc_sli4_params.if_page_sz;
13291 
13292 	/* sanity check on queue memory */
13293 	if (!mq || !cq)
13294 		return -ENODEV;
13295 	if (!phba->sli4_hba.pc_sli4_params.supported)
13296 		hw_page_size = SLI4_PAGE_SIZE;
13297 
13298 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
13299 	if (!mbox)
13300 		return -ENOMEM;
13301 	length = (sizeof(struct lpfc_mbx_mq_create_ext) -
13302 		  sizeof(struct lpfc_sli4_cfg_mhdr));
13303 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
13304 			 LPFC_MBOX_OPCODE_MQ_CREATE_EXT,
13305 			 length, LPFC_SLI4_MBX_EMBED);
13306 
13307 	mq_create_ext = &mbox->u.mqe.un.mq_create_ext;
13308 	shdr = (union lpfc_sli4_cfg_shdr *) &mq_create_ext->header.cfg_shdr;
13309 	bf_set(lpfc_mbx_mq_create_ext_num_pages,
13310 	       &mq_create_ext->u.request, mq->page_count);
13311 	bf_set(lpfc_mbx_mq_create_ext_async_evt_link,
13312 	       &mq_create_ext->u.request, 1);
13313 	bf_set(lpfc_mbx_mq_create_ext_async_evt_fip,
13314 	       &mq_create_ext->u.request, 1);
13315 	bf_set(lpfc_mbx_mq_create_ext_async_evt_group5,
13316 	       &mq_create_ext->u.request, 1);
13317 	bf_set(lpfc_mbx_mq_create_ext_async_evt_fc,
13318 	       &mq_create_ext->u.request, 1);
13319 	bf_set(lpfc_mbx_mq_create_ext_async_evt_sli,
13320 	       &mq_create_ext->u.request, 1);
13321 	bf_set(lpfc_mq_context_valid, &mq_create_ext->u.request.context, 1);
13322 	bf_set(lpfc_mbox_hdr_version, &shdr->request,
13323 	       phba->sli4_hba.pc_sli4_params.mqv);
13324 	if (phba->sli4_hba.pc_sli4_params.mqv == LPFC_Q_CREATE_VERSION_1)
13325 		bf_set(lpfc_mbx_mq_create_ext_cq_id, &mq_create_ext->u.request,
13326 		       cq->queue_id);
13327 	else
13328 		bf_set(lpfc_mq_context_cq_id, &mq_create_ext->u.request.context,
13329 		       cq->queue_id);
13330 	switch (mq->entry_count) {
13331 	default:
13332 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
13333 				"0362 Unsupported MQ count. (%d)\n",
13334 				mq->entry_count);
13335 		if (mq->entry_count < 16) {
13336 			status = -EINVAL;
13337 			goto out;
13338 		}
13339 		/* otherwise default to smallest count (drop through) */
13340 	case 16:
13341 		bf_set(lpfc_mq_context_ring_size,
13342 		       &mq_create_ext->u.request.context,
13343 		       LPFC_MQ_RING_SIZE_16);
13344 		break;
13345 	case 32:
13346 		bf_set(lpfc_mq_context_ring_size,
13347 		       &mq_create_ext->u.request.context,
13348 		       LPFC_MQ_RING_SIZE_32);
13349 		break;
13350 	case 64:
13351 		bf_set(lpfc_mq_context_ring_size,
13352 		       &mq_create_ext->u.request.context,
13353 		       LPFC_MQ_RING_SIZE_64);
13354 		break;
13355 	case 128:
13356 		bf_set(lpfc_mq_context_ring_size,
13357 		       &mq_create_ext->u.request.context,
13358 		       LPFC_MQ_RING_SIZE_128);
13359 		break;
13360 	}
13361 	list_for_each_entry(dmabuf, &mq->page_list, list) {
13362 		memset(dmabuf->virt, 0, hw_page_size);
13363 		mq_create_ext->u.request.page[dmabuf->buffer_tag].addr_lo =
13364 					putPaddrLow(dmabuf->phys);
13365 		mq_create_ext->u.request.page[dmabuf->buffer_tag].addr_hi =
13366 					putPaddrHigh(dmabuf->phys);
13367 	}
13368 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
13369 	mq->queue_id = bf_get(lpfc_mbx_mq_create_q_id,
13370 			      &mq_create_ext->u.response);
13371 	if (rc != MBX_SUCCESS) {
13372 		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
13373 				"2795 MQ_CREATE_EXT failed with "
13374 				"status x%x. Failback to MQ_CREATE.\n",
13375 				rc);
13376 		lpfc_mq_create_fb_init(phba, mq, mbox, cq);
13377 		mq_create = &mbox->u.mqe.un.mq_create;
13378 		rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
13379 		shdr = (union lpfc_sli4_cfg_shdr *) &mq_create->header.cfg_shdr;
13380 		mq->queue_id = bf_get(lpfc_mbx_mq_create_q_id,
13381 				      &mq_create->u.response);
13382 	}
13383 
13384 	/* The IOCTL status is embedded in the mailbox subheader. */
13385 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
13386 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
13387 	if (shdr_status || shdr_add_status || rc) {
13388 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13389 				"2502 MQ_CREATE mailbox failed with "
13390 				"status x%x add_status x%x, mbx status x%x\n",
13391 				shdr_status, shdr_add_status, rc);
13392 		status = -ENXIO;
13393 		goto out;
13394 	}
13395 	if (mq->queue_id == 0xFFFF) {
13396 		status = -ENXIO;
13397 		goto out;
13398 	}
13399 	mq->type = LPFC_MQ;
13400 	mq->assoc_qid = cq->queue_id;
13401 	mq->subtype = subtype;
13402 	mq->host_index = 0;
13403 	mq->hba_index = 0;
13404 
13405 	/* link the mq onto the parent cq child list */
13406 	list_add_tail(&mq->list, &cq->child_list);
13407 out:
13408 	mempool_free(mbox, phba->mbox_mem_pool);
13409 	return status;
13410 }
13411 
13412 /**
13413  * lpfc_wq_create - Create a Work Queue on the HBA
13414  * @phba: HBA structure that indicates port to create a queue on.
13415  * @wq: The queue structure to use to create the work queue.
13416  * @cq: The completion queue to bind this work queue to.
13417  * @subtype: The subtype of the work queue indicating its functionality.
13418  *
13419  * This function creates a work queue, as detailed in @wq, on a port, described
13420  * by @phba by sending a WQ_CREATE mailbox command to the HBA.
13421  *
13422  * The @phba struct is used to send mailbox command to HBA. The @wq struct
13423  * is used to get the entry count and entry size that are necessary to
13424  * determine the number of pages to allocate and use for this queue. The @cq
13425  * is used to indicate which completion queue to bind this work queue to. This
13426  * function will send the WQ_CREATE mailbox command to the HBA to setup the
13427  * work queue. This function is asynchronous and will wait for the mailbox
13428  * command to finish before continuing.
13429  *
13430  * On success this function will return a zero. If unable to allocate enough
13431  * memory this function will return -ENOMEM. If the queue create mailbox command
13432  * fails this function will return -ENXIO.
13433  **/
13434 int
13435 lpfc_wq_create(struct lpfc_hba *phba, struct lpfc_queue *wq,
13436 	       struct lpfc_queue *cq, uint32_t subtype)
13437 {
13438 	struct lpfc_mbx_wq_create *wq_create;
13439 	struct lpfc_dmabuf *dmabuf;
13440 	LPFC_MBOXQ_t *mbox;
13441 	int rc, length, status = 0;
13442 	uint32_t shdr_status, shdr_add_status;
13443 	union lpfc_sli4_cfg_shdr *shdr;
13444 	uint32_t hw_page_size = phba->sli4_hba.pc_sli4_params.if_page_sz;
13445 	struct dma_address *page;
13446 	void __iomem *bar_memmap_p;
13447 	uint32_t db_offset;
13448 	uint16_t pci_barset;
13449 
13450 	/* sanity check on queue memory */
13451 	if (!wq || !cq)
13452 		return -ENODEV;
13453 	if (!phba->sli4_hba.pc_sli4_params.supported)
13454 		hw_page_size = SLI4_PAGE_SIZE;
13455 
13456 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
13457 	if (!mbox)
13458 		return -ENOMEM;
13459 	length = (sizeof(struct lpfc_mbx_wq_create) -
13460 		  sizeof(struct lpfc_sli4_cfg_mhdr));
13461 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
13462 			 LPFC_MBOX_OPCODE_FCOE_WQ_CREATE,
13463 			 length, LPFC_SLI4_MBX_EMBED);
13464 	wq_create = &mbox->u.mqe.un.wq_create;
13465 	shdr = (union lpfc_sli4_cfg_shdr *) &wq_create->header.cfg_shdr;
13466 	bf_set(lpfc_mbx_wq_create_num_pages, &wq_create->u.request,
13467 		    wq->page_count);
13468 	bf_set(lpfc_mbx_wq_create_cq_id, &wq_create->u.request,
13469 		    cq->queue_id);
13470 
13471 	/* wqv is the earliest version supported, NOT the latest */
13472 	bf_set(lpfc_mbox_hdr_version, &shdr->request,
13473 	       phba->sli4_hba.pc_sli4_params.wqv);
13474 
13475 	switch (phba->sli4_hba.pc_sli4_params.wqv) {
13476 	case LPFC_Q_CREATE_VERSION_0:
13477 		switch (wq->entry_size) {
13478 		default:
13479 		case 64:
13480 			/* Nothing to do, version 0 ONLY supports 64 byte */
13481 			page = wq_create->u.request.page;
13482 			break;
13483 		case 128:
13484 			if (!(phba->sli4_hba.pc_sli4_params.wqsize &
13485 			    LPFC_WQ_SZ128_SUPPORT)) {
13486 				status = -ERANGE;
13487 				goto out;
13488 			}
13489 			/* If we get here the HBA MUST also support V1 and
13490 			 * we MUST use it
13491 			 */
13492 			bf_set(lpfc_mbox_hdr_version, &shdr->request,
13493 			       LPFC_Q_CREATE_VERSION_1);
13494 
13495 			bf_set(lpfc_mbx_wq_create_wqe_count,
13496 			       &wq_create->u.request_1, wq->entry_count);
13497 			bf_set(lpfc_mbx_wq_create_wqe_size,
13498 			       &wq_create->u.request_1,
13499 			       LPFC_WQ_WQE_SIZE_128);
13500 			bf_set(lpfc_mbx_wq_create_page_size,
13501 			       &wq_create->u.request_1,
13502 			       (PAGE_SIZE/SLI4_PAGE_SIZE));
13503 			page = wq_create->u.request_1.page;
13504 			break;
13505 		}
13506 		break;
13507 	case LPFC_Q_CREATE_VERSION_1:
13508 		bf_set(lpfc_mbx_wq_create_wqe_count, &wq_create->u.request_1,
13509 		       wq->entry_count);
13510 		switch (wq->entry_size) {
13511 		default:
13512 		case 64:
13513 			bf_set(lpfc_mbx_wq_create_wqe_size,
13514 			       &wq_create->u.request_1,
13515 			       LPFC_WQ_WQE_SIZE_64);
13516 			break;
13517 		case 128:
13518 			if (!(phba->sli4_hba.pc_sli4_params.wqsize &
13519 				LPFC_WQ_SZ128_SUPPORT)) {
13520 				status = -ERANGE;
13521 				goto out;
13522 			}
13523 			bf_set(lpfc_mbx_wq_create_wqe_size,
13524 			       &wq_create->u.request_1,
13525 			       LPFC_WQ_WQE_SIZE_128);
13526 			break;
13527 		}
13528 		bf_set(lpfc_mbx_wq_create_page_size, &wq_create->u.request_1,
13529 		       (PAGE_SIZE/SLI4_PAGE_SIZE));
13530 		page = wq_create->u.request_1.page;
13531 		break;
13532 	default:
13533 		status = -ERANGE;
13534 		goto out;
13535 	}
13536 
13537 	list_for_each_entry(dmabuf, &wq->page_list, list) {
13538 		memset(dmabuf->virt, 0, hw_page_size);
13539 		page[dmabuf->buffer_tag].addr_lo = putPaddrLow(dmabuf->phys);
13540 		page[dmabuf->buffer_tag].addr_hi = putPaddrHigh(dmabuf->phys);
13541 	}
13542 
13543 	if (phba->sli4_hba.fw_func_mode & LPFC_DUA_MODE)
13544 		bf_set(lpfc_mbx_wq_create_dua, &wq_create->u.request, 1);
13545 
13546 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
13547 	/* The IOCTL status is embedded in the mailbox subheader. */
13548 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
13549 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
13550 	if (shdr_status || shdr_add_status || rc) {
13551 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13552 				"2503 WQ_CREATE mailbox failed with "
13553 				"status x%x add_status x%x, mbx status x%x\n",
13554 				shdr_status, shdr_add_status, rc);
13555 		status = -ENXIO;
13556 		goto out;
13557 	}
13558 	wq->queue_id = bf_get(lpfc_mbx_wq_create_q_id, &wq_create->u.response);
13559 	if (wq->queue_id == 0xFFFF) {
13560 		status = -ENXIO;
13561 		goto out;
13562 	}
13563 	if (phba->sli4_hba.fw_func_mode & LPFC_DUA_MODE) {
13564 		wq->db_format = bf_get(lpfc_mbx_wq_create_db_format,
13565 				       &wq_create->u.response);
13566 		if ((wq->db_format != LPFC_DB_LIST_FORMAT) &&
13567 		    (wq->db_format != LPFC_DB_RING_FORMAT)) {
13568 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13569 					"3265 WQ[%d] doorbell format not "
13570 					"supported: x%x\n", wq->queue_id,
13571 					wq->db_format);
13572 			status = -EINVAL;
13573 			goto out;
13574 		}
13575 		pci_barset = bf_get(lpfc_mbx_wq_create_bar_set,
13576 				    &wq_create->u.response);
13577 		bar_memmap_p = lpfc_dual_chute_pci_bar_map(phba, pci_barset);
13578 		if (!bar_memmap_p) {
13579 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13580 					"3263 WQ[%d] failed to memmap pci "
13581 					"barset:x%x\n", wq->queue_id,
13582 					pci_barset);
13583 			status = -ENOMEM;
13584 			goto out;
13585 		}
13586 		db_offset = wq_create->u.response.doorbell_offset;
13587 		if ((db_offset != LPFC_ULP0_WQ_DOORBELL) &&
13588 		    (db_offset != LPFC_ULP1_WQ_DOORBELL)) {
13589 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13590 					"3252 WQ[%d] doorbell offset not "
13591 					"supported: x%x\n", wq->queue_id,
13592 					db_offset);
13593 			status = -EINVAL;
13594 			goto out;
13595 		}
13596 		wq->db_regaddr = bar_memmap_p + db_offset;
13597 		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
13598 				"3264 WQ[%d]: barset:x%x, offset:x%x, "
13599 				"format:x%x\n", wq->queue_id, pci_barset,
13600 				db_offset, wq->db_format);
13601 	} else {
13602 		wq->db_format = LPFC_DB_LIST_FORMAT;
13603 		wq->db_regaddr = phba->sli4_hba.WQDBregaddr;
13604 	}
13605 	wq->type = LPFC_WQ;
13606 	wq->assoc_qid = cq->queue_id;
13607 	wq->subtype = subtype;
13608 	wq->host_index = 0;
13609 	wq->hba_index = 0;
13610 	wq->entry_repost = LPFC_RELEASE_NOTIFICATION_INTERVAL;
13611 
13612 	/* link the wq onto the parent cq child list */
13613 	list_add_tail(&wq->list, &cq->child_list);
13614 out:
13615 	mempool_free(mbox, phba->mbox_mem_pool);
13616 	return status;
13617 }
13618 
13619 /**
13620  * lpfc_rq_adjust_repost - Adjust entry_repost for an RQ
13621  * @phba: HBA structure that indicates port to create a queue on.
13622  * @rq:   The queue structure to use for the receive queue.
13623  * @qno:  The associated HBQ number
13624  *
13625  *
13626  * For SLI4 we need to adjust the RQ repost value based on
13627  * the number of buffers that are initially posted to the RQ.
13628  */
13629 void
13630 lpfc_rq_adjust_repost(struct lpfc_hba *phba, struct lpfc_queue *rq, int qno)
13631 {
13632 	uint32_t cnt;
13633 
13634 	/* sanity check on queue memory */
13635 	if (!rq)
13636 		return;
13637 	cnt = lpfc_hbq_defs[qno]->entry_count;
13638 
13639 	/* Recalc repost for RQs based on buffers initially posted */
13640 	cnt = (cnt >> 3);
13641 	if (cnt < LPFC_QUEUE_MIN_REPOST)
13642 		cnt = LPFC_QUEUE_MIN_REPOST;
13643 
13644 	rq->entry_repost = cnt;
13645 }
13646 
13647 /**
13648  * lpfc_rq_create - Create a Receive Queue on the HBA
13649  * @phba: HBA structure that indicates port to create a queue on.
13650  * @hrq: The queue structure to use to create the header receive queue.
13651  * @drq: The queue structure to use to create the data receive queue.
13652  * @cq: The completion queue to bind this work queue to.
13653  *
13654  * This function creates a receive buffer queue pair , as detailed in @hrq and
13655  * @drq, on a port, described by @phba by sending a RQ_CREATE mailbox command
13656  * to the HBA.
13657  *
13658  * The @phba struct is used to send mailbox command to HBA. The @drq and @hrq
13659  * struct is used to get the entry count that is necessary to determine the
13660  * number of pages to use for this queue. The @cq is used to indicate which
13661  * completion queue to bind received buffers that are posted to these queues to.
13662  * This function will send the RQ_CREATE mailbox command to the HBA to setup the
13663  * receive queue pair. This function is asynchronous and will wait for the
13664  * mailbox command to finish before continuing.
13665  *
13666  * On success this function will return a zero. If unable to allocate enough
13667  * memory this function will return -ENOMEM. If the queue create mailbox command
13668  * fails this function will return -ENXIO.
13669  **/
13670 int
13671 lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
13672 	       struct lpfc_queue *drq, struct lpfc_queue *cq, uint32_t subtype)
13673 {
13674 	struct lpfc_mbx_rq_create *rq_create;
13675 	struct lpfc_dmabuf *dmabuf;
13676 	LPFC_MBOXQ_t *mbox;
13677 	int rc, length, status = 0;
13678 	uint32_t shdr_status, shdr_add_status;
13679 	union lpfc_sli4_cfg_shdr *shdr;
13680 	uint32_t hw_page_size = phba->sli4_hba.pc_sli4_params.if_page_sz;
13681 	void __iomem *bar_memmap_p;
13682 	uint32_t db_offset;
13683 	uint16_t pci_barset;
13684 
13685 	/* sanity check on queue memory */
13686 	if (!hrq || !drq || !cq)
13687 		return -ENODEV;
13688 	if (!phba->sli4_hba.pc_sli4_params.supported)
13689 		hw_page_size = SLI4_PAGE_SIZE;
13690 
13691 	if (hrq->entry_count != drq->entry_count)
13692 		return -EINVAL;
13693 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
13694 	if (!mbox)
13695 		return -ENOMEM;
13696 	length = (sizeof(struct lpfc_mbx_rq_create) -
13697 		  sizeof(struct lpfc_sli4_cfg_mhdr));
13698 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
13699 			 LPFC_MBOX_OPCODE_FCOE_RQ_CREATE,
13700 			 length, LPFC_SLI4_MBX_EMBED);
13701 	rq_create = &mbox->u.mqe.un.rq_create;
13702 	shdr = (union lpfc_sli4_cfg_shdr *) &rq_create->header.cfg_shdr;
13703 	bf_set(lpfc_mbox_hdr_version, &shdr->request,
13704 	       phba->sli4_hba.pc_sli4_params.rqv);
13705 	if (phba->sli4_hba.pc_sli4_params.rqv == LPFC_Q_CREATE_VERSION_1) {
13706 		bf_set(lpfc_rq_context_rqe_count_1,
13707 		       &rq_create->u.request.context,
13708 		       hrq->entry_count);
13709 		rq_create->u.request.context.buffer_size = LPFC_HDR_BUF_SIZE;
13710 		bf_set(lpfc_rq_context_rqe_size,
13711 		       &rq_create->u.request.context,
13712 		       LPFC_RQE_SIZE_8);
13713 		bf_set(lpfc_rq_context_page_size,
13714 		       &rq_create->u.request.context,
13715 		       (PAGE_SIZE/SLI4_PAGE_SIZE));
13716 	} else {
13717 		switch (hrq->entry_count) {
13718 		default:
13719 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
13720 					"2535 Unsupported RQ count. (%d)\n",
13721 					hrq->entry_count);
13722 			if (hrq->entry_count < 512) {
13723 				status = -EINVAL;
13724 				goto out;
13725 			}
13726 			/* otherwise default to smallest count (drop through) */
13727 		case 512:
13728 			bf_set(lpfc_rq_context_rqe_count,
13729 			       &rq_create->u.request.context,
13730 			       LPFC_RQ_RING_SIZE_512);
13731 			break;
13732 		case 1024:
13733 			bf_set(lpfc_rq_context_rqe_count,
13734 			       &rq_create->u.request.context,
13735 			       LPFC_RQ_RING_SIZE_1024);
13736 			break;
13737 		case 2048:
13738 			bf_set(lpfc_rq_context_rqe_count,
13739 			       &rq_create->u.request.context,
13740 			       LPFC_RQ_RING_SIZE_2048);
13741 			break;
13742 		case 4096:
13743 			bf_set(lpfc_rq_context_rqe_count,
13744 			       &rq_create->u.request.context,
13745 			       LPFC_RQ_RING_SIZE_4096);
13746 			break;
13747 		}
13748 		bf_set(lpfc_rq_context_buf_size, &rq_create->u.request.context,
13749 		       LPFC_HDR_BUF_SIZE);
13750 	}
13751 	bf_set(lpfc_rq_context_cq_id, &rq_create->u.request.context,
13752 	       cq->queue_id);
13753 	bf_set(lpfc_mbx_rq_create_num_pages, &rq_create->u.request,
13754 	       hrq->page_count);
13755 	list_for_each_entry(dmabuf, &hrq->page_list, list) {
13756 		memset(dmabuf->virt, 0, hw_page_size);
13757 		rq_create->u.request.page[dmabuf->buffer_tag].addr_lo =
13758 					putPaddrLow(dmabuf->phys);
13759 		rq_create->u.request.page[dmabuf->buffer_tag].addr_hi =
13760 					putPaddrHigh(dmabuf->phys);
13761 	}
13762 	if (phba->sli4_hba.fw_func_mode & LPFC_DUA_MODE)
13763 		bf_set(lpfc_mbx_rq_create_dua, &rq_create->u.request, 1);
13764 
13765 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
13766 	/* The IOCTL status is embedded in the mailbox subheader. */
13767 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
13768 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
13769 	if (shdr_status || shdr_add_status || rc) {
13770 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13771 				"2504 RQ_CREATE mailbox failed with "
13772 				"status x%x add_status x%x, mbx status x%x\n",
13773 				shdr_status, shdr_add_status, rc);
13774 		status = -ENXIO;
13775 		goto out;
13776 	}
13777 	hrq->queue_id = bf_get(lpfc_mbx_rq_create_q_id, &rq_create->u.response);
13778 	if (hrq->queue_id == 0xFFFF) {
13779 		status = -ENXIO;
13780 		goto out;
13781 	}
13782 
13783 	if (phba->sli4_hba.fw_func_mode & LPFC_DUA_MODE) {
13784 		hrq->db_format = bf_get(lpfc_mbx_rq_create_db_format,
13785 					&rq_create->u.response);
13786 		if ((hrq->db_format != LPFC_DB_LIST_FORMAT) &&
13787 		    (hrq->db_format != LPFC_DB_RING_FORMAT)) {
13788 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13789 					"3262 RQ [%d] doorbell format not "
13790 					"supported: x%x\n", hrq->queue_id,
13791 					hrq->db_format);
13792 			status = -EINVAL;
13793 			goto out;
13794 		}
13795 
13796 		pci_barset = bf_get(lpfc_mbx_rq_create_bar_set,
13797 				    &rq_create->u.response);
13798 		bar_memmap_p = lpfc_dual_chute_pci_bar_map(phba, pci_barset);
13799 		if (!bar_memmap_p) {
13800 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13801 					"3269 RQ[%d] failed to memmap pci "
13802 					"barset:x%x\n", hrq->queue_id,
13803 					pci_barset);
13804 			status = -ENOMEM;
13805 			goto out;
13806 		}
13807 
13808 		db_offset = rq_create->u.response.doorbell_offset;
13809 		if ((db_offset != LPFC_ULP0_RQ_DOORBELL) &&
13810 		    (db_offset != LPFC_ULP1_RQ_DOORBELL)) {
13811 			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13812 					"3270 RQ[%d] doorbell offset not "
13813 					"supported: x%x\n", hrq->queue_id,
13814 					db_offset);
13815 			status = -EINVAL;
13816 			goto out;
13817 		}
13818 		hrq->db_regaddr = bar_memmap_p + db_offset;
13819 		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
13820 				"3266 RQ[qid:%d]: barset:x%x, offset:x%x, "
13821 				"format:x%x\n", hrq->queue_id, pci_barset,
13822 				db_offset, hrq->db_format);
13823 	} else {
13824 		hrq->db_format = LPFC_DB_RING_FORMAT;
13825 		hrq->db_regaddr = phba->sli4_hba.RQDBregaddr;
13826 	}
13827 	hrq->type = LPFC_HRQ;
13828 	hrq->assoc_qid = cq->queue_id;
13829 	hrq->subtype = subtype;
13830 	hrq->host_index = 0;
13831 	hrq->hba_index = 0;
13832 
13833 	/* now create the data queue */
13834 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
13835 			 LPFC_MBOX_OPCODE_FCOE_RQ_CREATE,
13836 			 length, LPFC_SLI4_MBX_EMBED);
13837 	bf_set(lpfc_mbox_hdr_version, &shdr->request,
13838 	       phba->sli4_hba.pc_sli4_params.rqv);
13839 	if (phba->sli4_hba.pc_sli4_params.rqv == LPFC_Q_CREATE_VERSION_1) {
13840 		bf_set(lpfc_rq_context_rqe_count_1,
13841 		       &rq_create->u.request.context, hrq->entry_count);
13842 		rq_create->u.request.context.buffer_size = LPFC_DATA_BUF_SIZE;
13843 		bf_set(lpfc_rq_context_rqe_size, &rq_create->u.request.context,
13844 		       LPFC_RQE_SIZE_8);
13845 		bf_set(lpfc_rq_context_page_size, &rq_create->u.request.context,
13846 		       (PAGE_SIZE/SLI4_PAGE_SIZE));
13847 	} else {
13848 		switch (drq->entry_count) {
13849 		default:
13850 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
13851 					"2536 Unsupported RQ count. (%d)\n",
13852 					drq->entry_count);
13853 			if (drq->entry_count < 512) {
13854 				status = -EINVAL;
13855 				goto out;
13856 			}
13857 			/* otherwise default to smallest count (drop through) */
13858 		case 512:
13859 			bf_set(lpfc_rq_context_rqe_count,
13860 			       &rq_create->u.request.context,
13861 			       LPFC_RQ_RING_SIZE_512);
13862 			break;
13863 		case 1024:
13864 			bf_set(lpfc_rq_context_rqe_count,
13865 			       &rq_create->u.request.context,
13866 			       LPFC_RQ_RING_SIZE_1024);
13867 			break;
13868 		case 2048:
13869 			bf_set(lpfc_rq_context_rqe_count,
13870 			       &rq_create->u.request.context,
13871 			       LPFC_RQ_RING_SIZE_2048);
13872 			break;
13873 		case 4096:
13874 			bf_set(lpfc_rq_context_rqe_count,
13875 			       &rq_create->u.request.context,
13876 			       LPFC_RQ_RING_SIZE_4096);
13877 			break;
13878 		}
13879 		bf_set(lpfc_rq_context_buf_size, &rq_create->u.request.context,
13880 		       LPFC_DATA_BUF_SIZE);
13881 	}
13882 	bf_set(lpfc_rq_context_cq_id, &rq_create->u.request.context,
13883 	       cq->queue_id);
13884 	bf_set(lpfc_mbx_rq_create_num_pages, &rq_create->u.request,
13885 	       drq->page_count);
13886 	list_for_each_entry(dmabuf, &drq->page_list, list) {
13887 		rq_create->u.request.page[dmabuf->buffer_tag].addr_lo =
13888 					putPaddrLow(dmabuf->phys);
13889 		rq_create->u.request.page[dmabuf->buffer_tag].addr_hi =
13890 					putPaddrHigh(dmabuf->phys);
13891 	}
13892 	if (phba->sli4_hba.fw_func_mode & LPFC_DUA_MODE)
13893 		bf_set(lpfc_mbx_rq_create_dua, &rq_create->u.request, 1);
13894 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
13895 	/* The IOCTL status is embedded in the mailbox subheader. */
13896 	shdr = (union lpfc_sli4_cfg_shdr *) &rq_create->header.cfg_shdr;
13897 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
13898 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
13899 	if (shdr_status || shdr_add_status || rc) {
13900 		status = -ENXIO;
13901 		goto out;
13902 	}
13903 	drq->queue_id = bf_get(lpfc_mbx_rq_create_q_id, &rq_create->u.response);
13904 	if (drq->queue_id == 0xFFFF) {
13905 		status = -ENXIO;
13906 		goto out;
13907 	}
13908 	drq->type = LPFC_DRQ;
13909 	drq->assoc_qid = cq->queue_id;
13910 	drq->subtype = subtype;
13911 	drq->host_index = 0;
13912 	drq->hba_index = 0;
13913 
13914 	/* link the header and data RQs onto the parent cq child list */
13915 	list_add_tail(&hrq->list, &cq->child_list);
13916 	list_add_tail(&drq->list, &cq->child_list);
13917 
13918 out:
13919 	mempool_free(mbox, phba->mbox_mem_pool);
13920 	return status;
13921 }
13922 
13923 /**
13924  * lpfc_eq_destroy - Destroy an event Queue on the HBA
13925  * @eq: The queue structure associated with the queue to destroy.
13926  *
13927  * This function destroys a queue, as detailed in @eq by sending an mailbox
13928  * command, specific to the type of queue, to the HBA.
13929  *
13930  * The @eq struct is used to get the queue ID of the queue to destroy.
13931  *
13932  * On success this function will return a zero. If the queue destroy mailbox
13933  * command fails this function will return -ENXIO.
13934  **/
13935 int
13936 lpfc_eq_destroy(struct lpfc_hba *phba, struct lpfc_queue *eq)
13937 {
13938 	LPFC_MBOXQ_t *mbox;
13939 	int rc, length, status = 0;
13940 	uint32_t shdr_status, shdr_add_status;
13941 	union lpfc_sli4_cfg_shdr *shdr;
13942 
13943 	/* sanity check on queue memory */
13944 	if (!eq)
13945 		return -ENODEV;
13946 	mbox = mempool_alloc(eq->phba->mbox_mem_pool, GFP_KERNEL);
13947 	if (!mbox)
13948 		return -ENOMEM;
13949 	length = (sizeof(struct lpfc_mbx_eq_destroy) -
13950 		  sizeof(struct lpfc_sli4_cfg_mhdr));
13951 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
13952 			 LPFC_MBOX_OPCODE_EQ_DESTROY,
13953 			 length, LPFC_SLI4_MBX_EMBED);
13954 	bf_set(lpfc_mbx_eq_destroy_q_id, &mbox->u.mqe.un.eq_destroy.u.request,
13955 	       eq->queue_id);
13956 	mbox->vport = eq->phba->pport;
13957 	mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
13958 
13959 	rc = lpfc_sli_issue_mbox(eq->phba, mbox, MBX_POLL);
13960 	/* The IOCTL status is embedded in the mailbox subheader. */
13961 	shdr = (union lpfc_sli4_cfg_shdr *)
13962 		&mbox->u.mqe.un.eq_destroy.header.cfg_shdr;
13963 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
13964 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
13965 	if (shdr_status || shdr_add_status || rc) {
13966 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
13967 				"2505 EQ_DESTROY mailbox failed with "
13968 				"status x%x add_status x%x, mbx status x%x\n",
13969 				shdr_status, shdr_add_status, rc);
13970 		status = -ENXIO;
13971 	}
13972 
13973 	/* Remove eq from any list */
13974 	list_del_init(&eq->list);
13975 	mempool_free(mbox, eq->phba->mbox_mem_pool);
13976 	return status;
13977 }
13978 
13979 /**
13980  * lpfc_cq_destroy - Destroy a Completion Queue on the HBA
13981  * @cq: The queue structure associated with the queue to destroy.
13982  *
13983  * This function destroys a queue, as detailed in @cq by sending an mailbox
13984  * command, specific to the type of queue, to the HBA.
13985  *
13986  * The @cq struct is used to get the queue ID of the queue to destroy.
13987  *
13988  * On success this function will return a zero. If the queue destroy mailbox
13989  * command fails this function will return -ENXIO.
13990  **/
13991 int
13992 lpfc_cq_destroy(struct lpfc_hba *phba, struct lpfc_queue *cq)
13993 {
13994 	LPFC_MBOXQ_t *mbox;
13995 	int rc, length, status = 0;
13996 	uint32_t shdr_status, shdr_add_status;
13997 	union lpfc_sli4_cfg_shdr *shdr;
13998 
13999 	/* sanity check on queue memory */
14000 	if (!cq)
14001 		return -ENODEV;
14002 	mbox = mempool_alloc(cq->phba->mbox_mem_pool, GFP_KERNEL);
14003 	if (!mbox)
14004 		return -ENOMEM;
14005 	length = (sizeof(struct lpfc_mbx_cq_destroy) -
14006 		  sizeof(struct lpfc_sli4_cfg_mhdr));
14007 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
14008 			 LPFC_MBOX_OPCODE_CQ_DESTROY,
14009 			 length, LPFC_SLI4_MBX_EMBED);
14010 	bf_set(lpfc_mbx_cq_destroy_q_id, &mbox->u.mqe.un.cq_destroy.u.request,
14011 	       cq->queue_id);
14012 	mbox->vport = cq->phba->pport;
14013 	mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
14014 	rc = lpfc_sli_issue_mbox(cq->phba, mbox, MBX_POLL);
14015 	/* The IOCTL status is embedded in the mailbox subheader. */
14016 	shdr = (union lpfc_sli4_cfg_shdr *)
14017 		&mbox->u.mqe.un.wq_create.header.cfg_shdr;
14018 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
14019 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
14020 	if (shdr_status || shdr_add_status || rc) {
14021 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
14022 				"2506 CQ_DESTROY mailbox failed with "
14023 				"status x%x add_status x%x, mbx status x%x\n",
14024 				shdr_status, shdr_add_status, rc);
14025 		status = -ENXIO;
14026 	}
14027 	/* Remove cq from any list */
14028 	list_del_init(&cq->list);
14029 	mempool_free(mbox, cq->phba->mbox_mem_pool);
14030 	return status;
14031 }
14032 
14033 /**
14034  * lpfc_mq_destroy - Destroy a Mailbox Queue on the HBA
14035  * @qm: The queue structure associated with the queue to destroy.
14036  *
14037  * This function destroys a queue, as detailed in @mq by sending an mailbox
14038  * command, specific to the type of queue, to the HBA.
14039  *
14040  * The @mq struct is used to get the queue ID of the queue to destroy.
14041  *
14042  * On success this function will return a zero. If the queue destroy mailbox
14043  * command fails this function will return -ENXIO.
14044  **/
14045 int
14046 lpfc_mq_destroy(struct lpfc_hba *phba, struct lpfc_queue *mq)
14047 {
14048 	LPFC_MBOXQ_t *mbox;
14049 	int rc, length, status = 0;
14050 	uint32_t shdr_status, shdr_add_status;
14051 	union lpfc_sli4_cfg_shdr *shdr;
14052 
14053 	/* sanity check on queue memory */
14054 	if (!mq)
14055 		return -ENODEV;
14056 	mbox = mempool_alloc(mq->phba->mbox_mem_pool, GFP_KERNEL);
14057 	if (!mbox)
14058 		return -ENOMEM;
14059 	length = (sizeof(struct lpfc_mbx_mq_destroy) -
14060 		  sizeof(struct lpfc_sli4_cfg_mhdr));
14061 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
14062 			 LPFC_MBOX_OPCODE_MQ_DESTROY,
14063 			 length, LPFC_SLI4_MBX_EMBED);
14064 	bf_set(lpfc_mbx_mq_destroy_q_id, &mbox->u.mqe.un.mq_destroy.u.request,
14065 	       mq->queue_id);
14066 	mbox->vport = mq->phba->pport;
14067 	mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
14068 	rc = lpfc_sli_issue_mbox(mq->phba, mbox, MBX_POLL);
14069 	/* The IOCTL status is embedded in the mailbox subheader. */
14070 	shdr = (union lpfc_sli4_cfg_shdr *)
14071 		&mbox->u.mqe.un.mq_destroy.header.cfg_shdr;
14072 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
14073 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
14074 	if (shdr_status || shdr_add_status || rc) {
14075 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
14076 				"2507 MQ_DESTROY mailbox failed with "
14077 				"status x%x add_status x%x, mbx status x%x\n",
14078 				shdr_status, shdr_add_status, rc);
14079 		status = -ENXIO;
14080 	}
14081 	/* Remove mq from any list */
14082 	list_del_init(&mq->list);
14083 	mempool_free(mbox, mq->phba->mbox_mem_pool);
14084 	return status;
14085 }
14086 
14087 /**
14088  * lpfc_wq_destroy - Destroy a Work Queue on the HBA
14089  * @wq: The queue structure associated with the queue to destroy.
14090  *
14091  * This function destroys a queue, as detailed in @wq by sending an mailbox
14092  * command, specific to the type of queue, to the HBA.
14093  *
14094  * The @wq struct is used to get the queue ID of the queue to destroy.
14095  *
14096  * On success this function will return a zero. If the queue destroy mailbox
14097  * command fails this function will return -ENXIO.
14098  **/
14099 int
14100 lpfc_wq_destroy(struct lpfc_hba *phba, struct lpfc_queue *wq)
14101 {
14102 	LPFC_MBOXQ_t *mbox;
14103 	int rc, length, status = 0;
14104 	uint32_t shdr_status, shdr_add_status;
14105 	union lpfc_sli4_cfg_shdr *shdr;
14106 
14107 	/* sanity check on queue memory */
14108 	if (!wq)
14109 		return -ENODEV;
14110 	mbox = mempool_alloc(wq->phba->mbox_mem_pool, GFP_KERNEL);
14111 	if (!mbox)
14112 		return -ENOMEM;
14113 	length = (sizeof(struct lpfc_mbx_wq_destroy) -
14114 		  sizeof(struct lpfc_sli4_cfg_mhdr));
14115 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
14116 			 LPFC_MBOX_OPCODE_FCOE_WQ_DESTROY,
14117 			 length, LPFC_SLI4_MBX_EMBED);
14118 	bf_set(lpfc_mbx_wq_destroy_q_id, &mbox->u.mqe.un.wq_destroy.u.request,
14119 	       wq->queue_id);
14120 	mbox->vport = wq->phba->pport;
14121 	mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
14122 	rc = lpfc_sli_issue_mbox(wq->phba, mbox, MBX_POLL);
14123 	shdr = (union lpfc_sli4_cfg_shdr *)
14124 		&mbox->u.mqe.un.wq_destroy.header.cfg_shdr;
14125 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
14126 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
14127 	if (shdr_status || shdr_add_status || rc) {
14128 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
14129 				"2508 WQ_DESTROY mailbox failed with "
14130 				"status x%x add_status x%x, mbx status x%x\n",
14131 				shdr_status, shdr_add_status, rc);
14132 		status = -ENXIO;
14133 	}
14134 	/* Remove wq from any list */
14135 	list_del_init(&wq->list);
14136 	mempool_free(mbox, wq->phba->mbox_mem_pool);
14137 	return status;
14138 }
14139 
14140 /**
14141  * lpfc_rq_destroy - Destroy a Receive Queue on the HBA
14142  * @rq: The queue structure associated with the queue to destroy.
14143  *
14144  * This function destroys a queue, as detailed in @rq by sending an mailbox
14145  * command, specific to the type of queue, to the HBA.
14146  *
14147  * The @rq struct is used to get the queue ID of the queue to destroy.
14148  *
14149  * On success this function will return a zero. If the queue destroy mailbox
14150  * command fails this function will return -ENXIO.
14151  **/
14152 int
14153 lpfc_rq_destroy(struct lpfc_hba *phba, struct lpfc_queue *hrq,
14154 		struct lpfc_queue *drq)
14155 {
14156 	LPFC_MBOXQ_t *mbox;
14157 	int rc, length, status = 0;
14158 	uint32_t shdr_status, shdr_add_status;
14159 	union lpfc_sli4_cfg_shdr *shdr;
14160 
14161 	/* sanity check on queue memory */
14162 	if (!hrq || !drq)
14163 		return -ENODEV;
14164 	mbox = mempool_alloc(hrq->phba->mbox_mem_pool, GFP_KERNEL);
14165 	if (!mbox)
14166 		return -ENOMEM;
14167 	length = (sizeof(struct lpfc_mbx_rq_destroy) -
14168 		  sizeof(struct lpfc_sli4_cfg_mhdr));
14169 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
14170 			 LPFC_MBOX_OPCODE_FCOE_RQ_DESTROY,
14171 			 length, LPFC_SLI4_MBX_EMBED);
14172 	bf_set(lpfc_mbx_rq_destroy_q_id, &mbox->u.mqe.un.rq_destroy.u.request,
14173 	       hrq->queue_id);
14174 	mbox->vport = hrq->phba->pport;
14175 	mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
14176 	rc = lpfc_sli_issue_mbox(hrq->phba, mbox, MBX_POLL);
14177 	/* The IOCTL status is embedded in the mailbox subheader. */
14178 	shdr = (union lpfc_sli4_cfg_shdr *)
14179 		&mbox->u.mqe.un.rq_destroy.header.cfg_shdr;
14180 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
14181 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
14182 	if (shdr_status || shdr_add_status || rc) {
14183 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
14184 				"2509 RQ_DESTROY mailbox failed with "
14185 				"status x%x add_status x%x, mbx status x%x\n",
14186 				shdr_status, shdr_add_status, rc);
14187 		if (rc != MBX_TIMEOUT)
14188 			mempool_free(mbox, hrq->phba->mbox_mem_pool);
14189 		return -ENXIO;
14190 	}
14191 	bf_set(lpfc_mbx_rq_destroy_q_id, &mbox->u.mqe.un.rq_destroy.u.request,
14192 	       drq->queue_id);
14193 	rc = lpfc_sli_issue_mbox(drq->phba, mbox, MBX_POLL);
14194 	shdr = (union lpfc_sli4_cfg_shdr *)
14195 		&mbox->u.mqe.un.rq_destroy.header.cfg_shdr;
14196 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
14197 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
14198 	if (shdr_status || shdr_add_status || rc) {
14199 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
14200 				"2510 RQ_DESTROY mailbox failed with "
14201 				"status x%x add_status x%x, mbx status x%x\n",
14202 				shdr_status, shdr_add_status, rc);
14203 		status = -ENXIO;
14204 	}
14205 	list_del_init(&hrq->list);
14206 	list_del_init(&drq->list);
14207 	mempool_free(mbox, hrq->phba->mbox_mem_pool);
14208 	return status;
14209 }
14210 
14211 /**
14212  * lpfc_sli4_post_sgl - Post scatter gather list for an XRI to HBA
14213  * @phba: The virtual port for which this call being executed.
14214  * @pdma_phys_addr0: Physical address of the 1st SGL page.
14215  * @pdma_phys_addr1: Physical address of the 2nd SGL page.
14216  * @xritag: the xritag that ties this io to the SGL pages.
14217  *
14218  * This routine will post the sgl pages for the IO that has the xritag
14219  * that is in the iocbq structure. The xritag is assigned during iocbq
14220  * creation and persists for as long as the driver is loaded.
14221  * if the caller has fewer than 256 scatter gather segments to map then
14222  * pdma_phys_addr1 should be 0.
14223  * If the caller needs to map more than 256 scatter gather segment then
14224  * pdma_phys_addr1 should be a valid physical address.
14225  * physical address for SGLs must be 64 byte aligned.
14226  * If you are going to map 2 SGL's then the first one must have 256 entries
14227  * the second sgl can have between 1 and 256 entries.
14228  *
14229  * Return codes:
14230  * 	0 - Success
14231  * 	-ENXIO, -ENOMEM - Failure
14232  **/
14233 int
14234 lpfc_sli4_post_sgl(struct lpfc_hba *phba,
14235 		dma_addr_t pdma_phys_addr0,
14236 		dma_addr_t pdma_phys_addr1,
14237 		uint16_t xritag)
14238 {
14239 	struct lpfc_mbx_post_sgl_pages *post_sgl_pages;
14240 	LPFC_MBOXQ_t *mbox;
14241 	int rc;
14242 	uint32_t shdr_status, shdr_add_status;
14243 	uint32_t mbox_tmo;
14244 	union lpfc_sli4_cfg_shdr *shdr;
14245 
14246 	if (xritag == NO_XRI) {
14247 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
14248 				"0364 Invalid param:\n");
14249 		return -EINVAL;
14250 	}
14251 
14252 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
14253 	if (!mbox)
14254 		return -ENOMEM;
14255 
14256 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
14257 			LPFC_MBOX_OPCODE_FCOE_POST_SGL_PAGES,
14258 			sizeof(struct lpfc_mbx_post_sgl_pages) -
14259 			sizeof(struct lpfc_sli4_cfg_mhdr), LPFC_SLI4_MBX_EMBED);
14260 
14261 	post_sgl_pages = (struct lpfc_mbx_post_sgl_pages *)
14262 				&mbox->u.mqe.un.post_sgl_pages;
14263 	bf_set(lpfc_post_sgl_pages_xri, post_sgl_pages, xritag);
14264 	bf_set(lpfc_post_sgl_pages_xricnt, post_sgl_pages, 1);
14265 
14266 	post_sgl_pages->sgl_pg_pairs[0].sgl_pg0_addr_lo	=
14267 				cpu_to_le32(putPaddrLow(pdma_phys_addr0));
14268 	post_sgl_pages->sgl_pg_pairs[0].sgl_pg0_addr_hi =
14269 				cpu_to_le32(putPaddrHigh(pdma_phys_addr0));
14270 
14271 	post_sgl_pages->sgl_pg_pairs[0].sgl_pg1_addr_lo	=
14272 				cpu_to_le32(putPaddrLow(pdma_phys_addr1));
14273 	post_sgl_pages->sgl_pg_pairs[0].sgl_pg1_addr_hi =
14274 				cpu_to_le32(putPaddrHigh(pdma_phys_addr1));
14275 	if (!phba->sli4_hba.intr_enable)
14276 		rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
14277 	else {
14278 		mbox_tmo = lpfc_mbox_tmo_val(phba, mbox);
14279 		rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
14280 	}
14281 	/* The IOCTL status is embedded in the mailbox subheader. */
14282 	shdr = (union lpfc_sli4_cfg_shdr *) &post_sgl_pages->header.cfg_shdr;
14283 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
14284 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
14285 	if (rc != MBX_TIMEOUT)
14286 		mempool_free(mbox, phba->mbox_mem_pool);
14287 	if (shdr_status || shdr_add_status || rc) {
14288 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
14289 				"2511 POST_SGL mailbox failed with "
14290 				"status x%x add_status x%x, mbx status x%x\n",
14291 				shdr_status, shdr_add_status, rc);
14292 	}
14293 	return 0;
14294 }
14295 
14296 /**
14297  * lpfc_sli4_alloc_xri - Get an available rpi in the device's range
14298  * @phba: pointer to lpfc hba data structure.
14299  *
14300  * This routine is invoked to post rpi header templates to the
14301  * HBA consistent with the SLI-4 interface spec.  This routine
14302  * posts a SLI4_PAGE_SIZE memory region to the port to hold up to
14303  * SLI4_PAGE_SIZE modulo 64 rpi context headers.
14304  *
14305  * Returns
14306  *	A nonzero rpi defined as rpi_base <= rpi < max_rpi if successful
14307  *	LPFC_RPI_ALLOC_ERROR if no rpis are available.
14308  **/
14309 static uint16_t
14310 lpfc_sli4_alloc_xri(struct lpfc_hba *phba)
14311 {
14312 	unsigned long xri;
14313 
14314 	/*
14315 	 * Fetch the next logical xri.  Because this index is logical,
14316 	 * the driver starts at 0 each time.
14317 	 */
14318 	spin_lock_irq(&phba->hbalock);
14319 	xri = find_next_zero_bit(phba->sli4_hba.xri_bmask,
14320 				 phba->sli4_hba.max_cfg_param.max_xri, 0);
14321 	if (xri >= phba->sli4_hba.max_cfg_param.max_xri) {
14322 		spin_unlock_irq(&phba->hbalock);
14323 		return NO_XRI;
14324 	} else {
14325 		set_bit(xri, phba->sli4_hba.xri_bmask);
14326 		phba->sli4_hba.max_cfg_param.xri_used++;
14327 	}
14328 	spin_unlock_irq(&phba->hbalock);
14329 	return xri;
14330 }
14331 
14332 /**
14333  * lpfc_sli4_free_xri - Release an xri for reuse.
14334  * @phba: pointer to lpfc hba data structure.
14335  *
14336  * This routine is invoked to release an xri to the pool of
14337  * available rpis maintained by the driver.
14338  **/
14339 static void
14340 __lpfc_sli4_free_xri(struct lpfc_hba *phba, int xri)
14341 {
14342 	if (test_and_clear_bit(xri, phba->sli4_hba.xri_bmask)) {
14343 		phba->sli4_hba.max_cfg_param.xri_used--;
14344 	}
14345 }
14346 
14347 /**
14348  * lpfc_sli4_free_xri - Release an xri for reuse.
14349  * @phba: pointer to lpfc hba data structure.
14350  *
14351  * This routine is invoked to release an xri to the pool of
14352  * available rpis maintained by the driver.
14353  **/
14354 void
14355 lpfc_sli4_free_xri(struct lpfc_hba *phba, int xri)
14356 {
14357 	spin_lock_irq(&phba->hbalock);
14358 	__lpfc_sli4_free_xri(phba, xri);
14359 	spin_unlock_irq(&phba->hbalock);
14360 }
14361 
14362 /**
14363  * lpfc_sli4_next_xritag - Get an xritag for the io
14364  * @phba: Pointer to HBA context object.
14365  *
14366  * This function gets an xritag for the iocb. If there is no unused xritag
14367  * it will return 0xffff.
14368  * The function returns the allocated xritag if successful, else returns zero.
14369  * Zero is not a valid xritag.
14370  * The caller is not required to hold any lock.
14371  **/
14372 uint16_t
14373 lpfc_sli4_next_xritag(struct lpfc_hba *phba)
14374 {
14375 	uint16_t xri_index;
14376 
14377 	xri_index = lpfc_sli4_alloc_xri(phba);
14378 	if (xri_index == NO_XRI)
14379 		lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
14380 				"2004 Failed to allocate XRI.last XRITAG is %d"
14381 				" Max XRI is %d, Used XRI is %d\n",
14382 				xri_index,
14383 				phba->sli4_hba.max_cfg_param.max_xri,
14384 				phba->sli4_hba.max_cfg_param.xri_used);
14385 	return xri_index;
14386 }
14387 
14388 /**
14389  * lpfc_sli4_post_els_sgl_list - post a block of ELS sgls to the port.
14390  * @phba: pointer to lpfc hba data structure.
14391  * @post_sgl_list: pointer to els sgl entry list.
14392  * @count: number of els sgl entries on the list.
14393  *
14394  * This routine is invoked to post a block of driver's sgl pages to the
14395  * HBA using non-embedded mailbox command. No Lock is held. This routine
14396  * is only called when the driver is loading and after all IO has been
14397  * stopped.
14398  **/
14399 static int
14400 lpfc_sli4_post_els_sgl_list(struct lpfc_hba *phba,
14401 			    struct list_head *post_sgl_list,
14402 			    int post_cnt)
14403 {
14404 	struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
14405 	struct lpfc_mbx_post_uembed_sgl_page1 *sgl;
14406 	struct sgl_page_pairs *sgl_pg_pairs;
14407 	void *viraddr;
14408 	LPFC_MBOXQ_t *mbox;
14409 	uint32_t reqlen, alloclen, pg_pairs;
14410 	uint32_t mbox_tmo;
14411 	uint16_t xritag_start = 0;
14412 	int rc = 0;
14413 	uint32_t shdr_status, shdr_add_status;
14414 	union lpfc_sli4_cfg_shdr *shdr;
14415 
14416 	reqlen = phba->sli4_hba.els_xri_cnt * sizeof(struct sgl_page_pairs) +
14417 		 sizeof(union lpfc_sli4_cfg_shdr) + sizeof(uint32_t);
14418 	if (reqlen > SLI4_PAGE_SIZE) {
14419 		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
14420 				"2559 Block sgl registration required DMA "
14421 				"size (%d) great than a page\n", reqlen);
14422 		return -ENOMEM;
14423 	}
14424 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
14425 	if (!mbox)
14426 		return -ENOMEM;
14427 
14428 	/* Allocate DMA memory and set up the non-embedded mailbox command */
14429 	alloclen = lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
14430 			 LPFC_MBOX_OPCODE_FCOE_POST_SGL_PAGES, reqlen,
14431 			 LPFC_SLI4_MBX_NEMBED);
14432 
14433 	if (alloclen < reqlen) {
14434 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
14435 				"0285 Allocated DMA memory size (%d) is "
14436 				"less than the requested DMA memory "
14437 				"size (%d)\n", alloclen, reqlen);
14438 		lpfc_sli4_mbox_cmd_free(phba, mbox);
14439 		return -ENOMEM;
14440 	}
14441 	/* Set up the SGL pages in the non-embedded DMA pages */
14442 	viraddr = mbox->sge_array->addr[0];
14443 	sgl = (struct lpfc_mbx_post_uembed_sgl_page1 *)viraddr;
14444 	sgl_pg_pairs = &sgl->sgl_pg_pairs;
14445 
14446 	pg_pairs = 0;
14447 	list_for_each_entry_safe(sglq_entry, sglq_next, post_sgl_list, list) {
14448 		/* Set up the sge entry */
14449 		sgl_pg_pairs->sgl_pg0_addr_lo =
14450 				cpu_to_le32(putPaddrLow(sglq_entry->phys));
14451 		sgl_pg_pairs->sgl_pg0_addr_hi =
14452 				cpu_to_le32(putPaddrHigh(sglq_entry->phys));
14453 		sgl_pg_pairs->sgl_pg1_addr_lo =
14454 				cpu_to_le32(putPaddrLow(0));
14455 		sgl_pg_pairs->sgl_pg1_addr_hi =
14456 				cpu_to_le32(putPaddrHigh(0));
14457 
14458 		/* Keep the first xritag on the list */
14459 		if (pg_pairs == 0)
14460 			xritag_start = sglq_entry->sli4_xritag;
14461 		sgl_pg_pairs++;
14462 		pg_pairs++;
14463 	}
14464 
14465 	/* Complete initialization and perform endian conversion. */
14466 	bf_set(lpfc_post_sgl_pages_xri, sgl, xritag_start);
14467 	bf_set(lpfc_post_sgl_pages_xricnt, sgl, phba->sli4_hba.els_xri_cnt);
14468 	sgl->word0 = cpu_to_le32(sgl->word0);
14469 	if (!phba->sli4_hba.intr_enable)
14470 		rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
14471 	else {
14472 		mbox_tmo = lpfc_mbox_tmo_val(phba, mbox);
14473 		rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
14474 	}
14475 	shdr = (union lpfc_sli4_cfg_shdr *) &sgl->cfg_shdr;
14476 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
14477 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
14478 	if (rc != MBX_TIMEOUT)
14479 		lpfc_sli4_mbox_cmd_free(phba, mbox);
14480 	if (shdr_status || shdr_add_status || rc) {
14481 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
14482 				"2513 POST_SGL_BLOCK mailbox command failed "
14483 				"status x%x add_status x%x mbx status x%x\n",
14484 				shdr_status, shdr_add_status, rc);
14485 		rc = -ENXIO;
14486 	}
14487 	return rc;
14488 }
14489 
14490 /**
14491  * lpfc_sli4_post_scsi_sgl_block - post a block of scsi sgl list to firmware
14492  * @phba: pointer to lpfc hba data structure.
14493  * @sblist: pointer to scsi buffer list.
14494  * @count: number of scsi buffers on the list.
14495  *
14496  * This routine is invoked to post a block of @count scsi sgl pages from a
14497  * SCSI buffer list @sblist to the HBA using non-embedded mailbox command.
14498  * No Lock is held.
14499  *
14500  **/
14501 int
14502 lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *phba,
14503 			      struct list_head *sblist,
14504 			      int count)
14505 {
14506 	struct lpfc_scsi_buf *psb;
14507 	struct lpfc_mbx_post_uembed_sgl_page1 *sgl;
14508 	struct sgl_page_pairs *sgl_pg_pairs;
14509 	void *viraddr;
14510 	LPFC_MBOXQ_t *mbox;
14511 	uint32_t reqlen, alloclen, pg_pairs;
14512 	uint32_t mbox_tmo;
14513 	uint16_t xritag_start = 0;
14514 	int rc = 0;
14515 	uint32_t shdr_status, shdr_add_status;
14516 	dma_addr_t pdma_phys_bpl1;
14517 	union lpfc_sli4_cfg_shdr *shdr;
14518 
14519 	/* Calculate the requested length of the dma memory */
14520 	reqlen = count * sizeof(struct sgl_page_pairs) +
14521 		 sizeof(union lpfc_sli4_cfg_shdr) + sizeof(uint32_t);
14522 	if (reqlen > SLI4_PAGE_SIZE) {
14523 		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
14524 				"0217 Block sgl registration required DMA "
14525 				"size (%d) great than a page\n", reqlen);
14526 		return -ENOMEM;
14527 	}
14528 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
14529 	if (!mbox) {
14530 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
14531 				"0283 Failed to allocate mbox cmd memory\n");
14532 		return -ENOMEM;
14533 	}
14534 
14535 	/* Allocate DMA memory and set up the non-embedded mailbox command */
14536 	alloclen = lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
14537 				LPFC_MBOX_OPCODE_FCOE_POST_SGL_PAGES, reqlen,
14538 				LPFC_SLI4_MBX_NEMBED);
14539 
14540 	if (alloclen < reqlen) {
14541 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
14542 				"2561 Allocated DMA memory size (%d) is "
14543 				"less than the requested DMA memory "
14544 				"size (%d)\n", alloclen, reqlen);
14545 		lpfc_sli4_mbox_cmd_free(phba, mbox);
14546 		return -ENOMEM;
14547 	}
14548 
14549 	/* Get the first SGE entry from the non-embedded DMA memory */
14550 	viraddr = mbox->sge_array->addr[0];
14551 
14552 	/* Set up the SGL pages in the non-embedded DMA pages */
14553 	sgl = (struct lpfc_mbx_post_uembed_sgl_page1 *)viraddr;
14554 	sgl_pg_pairs = &sgl->sgl_pg_pairs;
14555 
14556 	pg_pairs = 0;
14557 	list_for_each_entry(psb, sblist, list) {
14558 		/* Set up the sge entry */
14559 		sgl_pg_pairs->sgl_pg0_addr_lo =
14560 			cpu_to_le32(putPaddrLow(psb->dma_phys_bpl));
14561 		sgl_pg_pairs->sgl_pg0_addr_hi =
14562 			cpu_to_le32(putPaddrHigh(psb->dma_phys_bpl));
14563 		if (phba->cfg_sg_dma_buf_size > SGL_PAGE_SIZE)
14564 			pdma_phys_bpl1 = psb->dma_phys_bpl + SGL_PAGE_SIZE;
14565 		else
14566 			pdma_phys_bpl1 = 0;
14567 		sgl_pg_pairs->sgl_pg1_addr_lo =
14568 			cpu_to_le32(putPaddrLow(pdma_phys_bpl1));
14569 		sgl_pg_pairs->sgl_pg1_addr_hi =
14570 			cpu_to_le32(putPaddrHigh(pdma_phys_bpl1));
14571 		/* Keep the first xritag on the list */
14572 		if (pg_pairs == 0)
14573 			xritag_start = psb->cur_iocbq.sli4_xritag;
14574 		sgl_pg_pairs++;
14575 		pg_pairs++;
14576 	}
14577 	bf_set(lpfc_post_sgl_pages_xri, sgl, xritag_start);
14578 	bf_set(lpfc_post_sgl_pages_xricnt, sgl, pg_pairs);
14579 	/* Perform endian conversion if necessary */
14580 	sgl->word0 = cpu_to_le32(sgl->word0);
14581 
14582 	if (!phba->sli4_hba.intr_enable)
14583 		rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
14584 	else {
14585 		mbox_tmo = lpfc_mbox_tmo_val(phba, mbox);
14586 		rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
14587 	}
14588 	shdr = (union lpfc_sli4_cfg_shdr *) &sgl->cfg_shdr;
14589 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
14590 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
14591 	if (rc != MBX_TIMEOUT)
14592 		lpfc_sli4_mbox_cmd_free(phba, mbox);
14593 	if (shdr_status || shdr_add_status || rc) {
14594 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
14595 				"2564 POST_SGL_BLOCK mailbox command failed "
14596 				"status x%x add_status x%x mbx status x%x\n",
14597 				shdr_status, shdr_add_status, rc);
14598 		rc = -ENXIO;
14599 	}
14600 	return rc;
14601 }
14602 
14603 /**
14604  * lpfc_fc_frame_check - Check that this frame is a valid frame to handle
14605  * @phba: pointer to lpfc_hba struct that the frame was received on
14606  * @fc_hdr: A pointer to the FC Header data (In Big Endian Format)
14607  *
14608  * This function checks the fields in the @fc_hdr to see if the FC frame is a
14609  * valid type of frame that the LPFC driver will handle. This function will
14610  * return a zero if the frame is a valid frame or a non zero value when the
14611  * frame does not pass the check.
14612  **/
14613 static int
14614 lpfc_fc_frame_check(struct lpfc_hba *phba, struct fc_frame_header *fc_hdr)
14615 {
14616 	/*  make rctl_names static to save stack space */
14617 	static char *rctl_names[] = FC_RCTL_NAMES_INIT;
14618 	char *type_names[] = FC_TYPE_NAMES_INIT;
14619 	struct fc_vft_header *fc_vft_hdr;
14620 	uint32_t *header = (uint32_t *) fc_hdr;
14621 
14622 	switch (fc_hdr->fh_r_ctl) {
14623 	case FC_RCTL_DD_UNCAT:		/* uncategorized information */
14624 	case FC_RCTL_DD_SOL_DATA:	/* solicited data */
14625 	case FC_RCTL_DD_UNSOL_CTL:	/* unsolicited control */
14626 	case FC_RCTL_DD_SOL_CTL:	/* solicited control or reply */
14627 	case FC_RCTL_DD_UNSOL_DATA:	/* unsolicited data */
14628 	case FC_RCTL_DD_DATA_DESC:	/* data descriptor */
14629 	case FC_RCTL_DD_UNSOL_CMD:	/* unsolicited command */
14630 	case FC_RCTL_DD_CMD_STATUS:	/* command status */
14631 	case FC_RCTL_ELS_REQ:	/* extended link services request */
14632 	case FC_RCTL_ELS_REP:	/* extended link services reply */
14633 	case FC_RCTL_ELS4_REQ:	/* FC-4 ELS request */
14634 	case FC_RCTL_ELS4_REP:	/* FC-4 ELS reply */
14635 	case FC_RCTL_BA_NOP:  	/* basic link service NOP */
14636 	case FC_RCTL_BA_ABTS: 	/* basic link service abort */
14637 	case FC_RCTL_BA_RMC: 	/* remove connection */
14638 	case FC_RCTL_BA_ACC:	/* basic accept */
14639 	case FC_RCTL_BA_RJT:	/* basic reject */
14640 	case FC_RCTL_BA_PRMT:
14641 	case FC_RCTL_ACK_1:	/* acknowledge_1 */
14642 	case FC_RCTL_ACK_0:	/* acknowledge_0 */
14643 	case FC_RCTL_P_RJT:	/* port reject */
14644 	case FC_RCTL_F_RJT:	/* fabric reject */
14645 	case FC_RCTL_P_BSY:	/* port busy */
14646 	case FC_RCTL_F_BSY:	/* fabric busy to data frame */
14647 	case FC_RCTL_F_BSYL:	/* fabric busy to link control frame */
14648 	case FC_RCTL_LCR:	/* link credit reset */
14649 	case FC_RCTL_END:	/* end */
14650 		break;
14651 	case FC_RCTL_VFTH:	/* Virtual Fabric tagging Header */
14652 		fc_vft_hdr = (struct fc_vft_header *)fc_hdr;
14653 		fc_hdr = &((struct fc_frame_header *)fc_vft_hdr)[1];
14654 		return lpfc_fc_frame_check(phba, fc_hdr);
14655 	default:
14656 		goto drop;
14657 	}
14658 	switch (fc_hdr->fh_type) {
14659 	case FC_TYPE_BLS:
14660 	case FC_TYPE_ELS:
14661 	case FC_TYPE_FCP:
14662 	case FC_TYPE_CT:
14663 		break;
14664 	case FC_TYPE_IP:
14665 	case FC_TYPE_ILS:
14666 	default:
14667 		goto drop;
14668 	}
14669 
14670 	lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
14671 			"2538 Received frame rctl:%s (x%x), type:%s (x%x), "
14672 			"frame Data:%08x %08x %08x %08x %08x %08x %08x\n",
14673 			rctl_names[fc_hdr->fh_r_ctl], fc_hdr->fh_r_ctl,
14674 			type_names[fc_hdr->fh_type], fc_hdr->fh_type,
14675 			be32_to_cpu(header[0]), be32_to_cpu(header[1]),
14676 			be32_to_cpu(header[2]), be32_to_cpu(header[3]),
14677 			be32_to_cpu(header[4]), be32_to_cpu(header[5]),
14678 			be32_to_cpu(header[6]));
14679 	return 0;
14680 drop:
14681 	lpfc_printf_log(phba, KERN_WARNING, LOG_ELS,
14682 			"2539 Dropped frame rctl:%s type:%s\n",
14683 			rctl_names[fc_hdr->fh_r_ctl],
14684 			type_names[fc_hdr->fh_type]);
14685 	return 1;
14686 }
14687 
14688 /**
14689  * lpfc_fc_hdr_get_vfi - Get the VFI from an FC frame
14690  * @fc_hdr: A pointer to the FC Header data (In Big Endian Format)
14691  *
14692  * This function processes the FC header to retrieve the VFI from the VF
14693  * header, if one exists. This function will return the VFI if one exists
14694  * or 0 if no VSAN Header exists.
14695  **/
14696 static uint32_t
14697 lpfc_fc_hdr_get_vfi(struct fc_frame_header *fc_hdr)
14698 {
14699 	struct fc_vft_header *fc_vft_hdr = (struct fc_vft_header *)fc_hdr;
14700 
14701 	if (fc_hdr->fh_r_ctl != FC_RCTL_VFTH)
14702 		return 0;
14703 	return bf_get(fc_vft_hdr_vf_id, fc_vft_hdr);
14704 }
14705 
14706 /**
14707  * lpfc_fc_frame_to_vport - Finds the vport that a frame is destined to
14708  * @phba: Pointer to the HBA structure to search for the vport on
14709  * @fc_hdr: A pointer to the FC Header data (In Big Endian Format)
14710  * @fcfi: The FC Fabric ID that the frame came from
14711  *
14712  * This function searches the @phba for a vport that matches the content of the
14713  * @fc_hdr passed in and the @fcfi. This function uses the @fc_hdr to fetch the
14714  * VFI, if the Virtual Fabric Tagging Header exists, and the DID. This function
14715  * returns the matching vport pointer or NULL if unable to match frame to a
14716  * vport.
14717  **/
14718 static struct lpfc_vport *
14719 lpfc_fc_frame_to_vport(struct lpfc_hba *phba, struct fc_frame_header *fc_hdr,
14720 		       uint16_t fcfi)
14721 {
14722 	struct lpfc_vport **vports;
14723 	struct lpfc_vport *vport = NULL;
14724 	int i;
14725 	uint32_t did = (fc_hdr->fh_d_id[0] << 16 |
14726 			fc_hdr->fh_d_id[1] << 8 |
14727 			fc_hdr->fh_d_id[2]);
14728 
14729 	if (did == Fabric_DID)
14730 		return phba->pport;
14731 	if ((phba->pport->fc_flag & FC_PT2PT) &&
14732 		!(phba->link_state == LPFC_HBA_READY))
14733 		return phba->pport;
14734 
14735 	vports = lpfc_create_vport_work_array(phba);
14736 	if (vports != NULL)
14737 		for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
14738 			if (phba->fcf.fcfi == fcfi &&
14739 			    vports[i]->vfi == lpfc_fc_hdr_get_vfi(fc_hdr) &&
14740 			    vports[i]->fc_myDID == did) {
14741 				vport = vports[i];
14742 				break;
14743 			}
14744 		}
14745 	lpfc_destroy_vport_work_array(phba, vports);
14746 	return vport;
14747 }
14748 
14749 /**
14750  * lpfc_update_rcv_time_stamp - Update vport's rcv seq time stamp
14751  * @vport: The vport to work on.
14752  *
14753  * This function updates the receive sequence time stamp for this vport. The
14754  * receive sequence time stamp indicates the time that the last frame of the
14755  * the sequence that has been idle for the longest amount of time was received.
14756  * the driver uses this time stamp to indicate if any received sequences have
14757  * timed out.
14758  **/
14759 static void
14760 lpfc_update_rcv_time_stamp(struct lpfc_vport *vport)
14761 {
14762 	struct lpfc_dmabuf *h_buf;
14763 	struct hbq_dmabuf *dmabuf = NULL;
14764 
14765 	/* get the oldest sequence on the rcv list */
14766 	h_buf = list_get_first(&vport->rcv_buffer_list,
14767 			       struct lpfc_dmabuf, list);
14768 	if (!h_buf)
14769 		return;
14770 	dmabuf = container_of(h_buf, struct hbq_dmabuf, hbuf);
14771 	vport->rcv_buffer_time_stamp = dmabuf->time_stamp;
14772 }
14773 
14774 /**
14775  * lpfc_cleanup_rcv_buffers - Cleans up all outstanding receive sequences.
14776  * @vport: The vport that the received sequences were sent to.
14777  *
14778  * This function cleans up all outstanding received sequences. This is called
14779  * by the driver when a link event or user action invalidates all the received
14780  * sequences.
14781  **/
14782 void
14783 lpfc_cleanup_rcv_buffers(struct lpfc_vport *vport)
14784 {
14785 	struct lpfc_dmabuf *h_buf, *hnext;
14786 	struct lpfc_dmabuf *d_buf, *dnext;
14787 	struct hbq_dmabuf *dmabuf = NULL;
14788 
14789 	/* start with the oldest sequence on the rcv list */
14790 	list_for_each_entry_safe(h_buf, hnext, &vport->rcv_buffer_list, list) {
14791 		dmabuf = container_of(h_buf, struct hbq_dmabuf, hbuf);
14792 		list_del_init(&dmabuf->hbuf.list);
14793 		list_for_each_entry_safe(d_buf, dnext,
14794 					 &dmabuf->dbuf.list, list) {
14795 			list_del_init(&d_buf->list);
14796 			lpfc_in_buf_free(vport->phba, d_buf);
14797 		}
14798 		lpfc_in_buf_free(vport->phba, &dmabuf->dbuf);
14799 	}
14800 }
14801 
14802 /**
14803  * lpfc_rcv_seq_check_edtov - Cleans up timed out receive sequences.
14804  * @vport: The vport that the received sequences were sent to.
14805  *
14806  * This function determines whether any received sequences have timed out by
14807  * first checking the vport's rcv_buffer_time_stamp. If this time_stamp
14808  * indicates that there is at least one timed out sequence this routine will
14809  * go through the received sequences one at a time from most inactive to most
14810  * active to determine which ones need to be cleaned up. Once it has determined
14811  * that a sequence needs to be cleaned up it will simply free up the resources
14812  * without sending an abort.
14813  **/
14814 void
14815 lpfc_rcv_seq_check_edtov(struct lpfc_vport *vport)
14816 {
14817 	struct lpfc_dmabuf *h_buf, *hnext;
14818 	struct lpfc_dmabuf *d_buf, *dnext;
14819 	struct hbq_dmabuf *dmabuf = NULL;
14820 	unsigned long timeout;
14821 	int abort_count = 0;
14822 
14823 	timeout = (msecs_to_jiffies(vport->phba->fc_edtov) +
14824 		   vport->rcv_buffer_time_stamp);
14825 	if (list_empty(&vport->rcv_buffer_list) ||
14826 	    time_before(jiffies, timeout))
14827 		return;
14828 	/* start with the oldest sequence on the rcv list */
14829 	list_for_each_entry_safe(h_buf, hnext, &vport->rcv_buffer_list, list) {
14830 		dmabuf = container_of(h_buf, struct hbq_dmabuf, hbuf);
14831 		timeout = (msecs_to_jiffies(vport->phba->fc_edtov) +
14832 			   dmabuf->time_stamp);
14833 		if (time_before(jiffies, timeout))
14834 			break;
14835 		abort_count++;
14836 		list_del_init(&dmabuf->hbuf.list);
14837 		list_for_each_entry_safe(d_buf, dnext,
14838 					 &dmabuf->dbuf.list, list) {
14839 			list_del_init(&d_buf->list);
14840 			lpfc_in_buf_free(vport->phba, d_buf);
14841 		}
14842 		lpfc_in_buf_free(vport->phba, &dmabuf->dbuf);
14843 	}
14844 	if (abort_count)
14845 		lpfc_update_rcv_time_stamp(vport);
14846 }
14847 
14848 /**
14849  * lpfc_fc_frame_add - Adds a frame to the vport's list of received sequences
14850  * @dmabuf: pointer to a dmabuf that describes the hdr and data of the FC frame
14851  *
14852  * This function searches through the existing incomplete sequences that have
14853  * been sent to this @vport. If the frame matches one of the incomplete
14854  * sequences then the dbuf in the @dmabuf is added to the list of frames that
14855  * make up that sequence. If no sequence is found that matches this frame then
14856  * the function will add the hbuf in the @dmabuf to the @vport's rcv_buffer_list
14857  * This function returns a pointer to the first dmabuf in the sequence list that
14858  * the frame was linked to.
14859  **/
14860 static struct hbq_dmabuf *
14861 lpfc_fc_frame_add(struct lpfc_vport *vport, struct hbq_dmabuf *dmabuf)
14862 {
14863 	struct fc_frame_header *new_hdr;
14864 	struct fc_frame_header *temp_hdr;
14865 	struct lpfc_dmabuf *d_buf;
14866 	struct lpfc_dmabuf *h_buf;
14867 	struct hbq_dmabuf *seq_dmabuf = NULL;
14868 	struct hbq_dmabuf *temp_dmabuf = NULL;
14869 
14870 	INIT_LIST_HEAD(&dmabuf->dbuf.list);
14871 	dmabuf->time_stamp = jiffies;
14872 	new_hdr = (struct fc_frame_header *)dmabuf->hbuf.virt;
14873 	/* Use the hdr_buf to find the sequence that this frame belongs to */
14874 	list_for_each_entry(h_buf, &vport->rcv_buffer_list, list) {
14875 		temp_hdr = (struct fc_frame_header *)h_buf->virt;
14876 		if ((temp_hdr->fh_seq_id != new_hdr->fh_seq_id) ||
14877 		    (temp_hdr->fh_ox_id != new_hdr->fh_ox_id) ||
14878 		    (memcmp(&temp_hdr->fh_s_id, &new_hdr->fh_s_id, 3)))
14879 			continue;
14880 		/* found a pending sequence that matches this frame */
14881 		seq_dmabuf = container_of(h_buf, struct hbq_dmabuf, hbuf);
14882 		break;
14883 	}
14884 	if (!seq_dmabuf) {
14885 		/*
14886 		 * This indicates first frame received for this sequence.
14887 		 * Queue the buffer on the vport's rcv_buffer_list.
14888 		 */
14889 		list_add_tail(&dmabuf->hbuf.list, &vport->rcv_buffer_list);
14890 		lpfc_update_rcv_time_stamp(vport);
14891 		return dmabuf;
14892 	}
14893 	temp_hdr = seq_dmabuf->hbuf.virt;
14894 	if (be16_to_cpu(new_hdr->fh_seq_cnt) <
14895 		be16_to_cpu(temp_hdr->fh_seq_cnt)) {
14896 		list_del_init(&seq_dmabuf->hbuf.list);
14897 		list_add_tail(&dmabuf->hbuf.list, &vport->rcv_buffer_list);
14898 		list_add_tail(&dmabuf->dbuf.list, &seq_dmabuf->dbuf.list);
14899 		lpfc_update_rcv_time_stamp(vport);
14900 		return dmabuf;
14901 	}
14902 	/* move this sequence to the tail to indicate a young sequence */
14903 	list_move_tail(&seq_dmabuf->hbuf.list, &vport->rcv_buffer_list);
14904 	seq_dmabuf->time_stamp = jiffies;
14905 	lpfc_update_rcv_time_stamp(vport);
14906 	if (list_empty(&seq_dmabuf->dbuf.list)) {
14907 		temp_hdr = dmabuf->hbuf.virt;
14908 		list_add_tail(&dmabuf->dbuf.list, &seq_dmabuf->dbuf.list);
14909 		return seq_dmabuf;
14910 	}
14911 	/* find the correct place in the sequence to insert this frame */
14912 	list_for_each_entry_reverse(d_buf, &seq_dmabuf->dbuf.list, list) {
14913 		temp_dmabuf = container_of(d_buf, struct hbq_dmabuf, dbuf);
14914 		temp_hdr = (struct fc_frame_header *)temp_dmabuf->hbuf.virt;
14915 		/*
14916 		 * If the frame's sequence count is greater than the frame on
14917 		 * the list then insert the frame right after this frame
14918 		 */
14919 		if (be16_to_cpu(new_hdr->fh_seq_cnt) >
14920 			be16_to_cpu(temp_hdr->fh_seq_cnt)) {
14921 			list_add(&dmabuf->dbuf.list, &temp_dmabuf->dbuf.list);
14922 			return seq_dmabuf;
14923 		}
14924 	}
14925 	return NULL;
14926 }
14927 
14928 /**
14929  * lpfc_sli4_abort_partial_seq - Abort partially assembled unsol sequence
14930  * @vport: pointer to a vitural port
14931  * @dmabuf: pointer to a dmabuf that describes the FC sequence
14932  *
14933  * This function tries to abort from the partially assembed sequence, described
14934  * by the information from basic abbort @dmabuf. It checks to see whether such
14935  * partially assembled sequence held by the driver. If so, it shall free up all
14936  * the frames from the partially assembled sequence.
14937  *
14938  * Return
14939  * true  -- if there is matching partially assembled sequence present and all
14940  *          the frames freed with the sequence;
14941  * false -- if there is no matching partially assembled sequence present so
14942  *          nothing got aborted in the lower layer driver
14943  **/
14944 static bool
14945 lpfc_sli4_abort_partial_seq(struct lpfc_vport *vport,
14946 			    struct hbq_dmabuf *dmabuf)
14947 {
14948 	struct fc_frame_header *new_hdr;
14949 	struct fc_frame_header *temp_hdr;
14950 	struct lpfc_dmabuf *d_buf, *n_buf, *h_buf;
14951 	struct hbq_dmabuf *seq_dmabuf = NULL;
14952 
14953 	/* Use the hdr_buf to find the sequence that matches this frame */
14954 	INIT_LIST_HEAD(&dmabuf->dbuf.list);
14955 	INIT_LIST_HEAD(&dmabuf->hbuf.list);
14956 	new_hdr = (struct fc_frame_header *)dmabuf->hbuf.virt;
14957 	list_for_each_entry(h_buf, &vport->rcv_buffer_list, list) {
14958 		temp_hdr = (struct fc_frame_header *)h_buf->virt;
14959 		if ((temp_hdr->fh_seq_id != new_hdr->fh_seq_id) ||
14960 		    (temp_hdr->fh_ox_id != new_hdr->fh_ox_id) ||
14961 		    (memcmp(&temp_hdr->fh_s_id, &new_hdr->fh_s_id, 3)))
14962 			continue;
14963 		/* found a pending sequence that matches this frame */
14964 		seq_dmabuf = container_of(h_buf, struct hbq_dmabuf, hbuf);
14965 		break;
14966 	}
14967 
14968 	/* Free up all the frames from the partially assembled sequence */
14969 	if (seq_dmabuf) {
14970 		list_for_each_entry_safe(d_buf, n_buf,
14971 					 &seq_dmabuf->dbuf.list, list) {
14972 			list_del_init(&d_buf->list);
14973 			lpfc_in_buf_free(vport->phba, d_buf);
14974 		}
14975 		return true;
14976 	}
14977 	return false;
14978 }
14979 
14980 /**
14981  * lpfc_sli4_abort_ulp_seq - Abort assembled unsol sequence from ulp
14982  * @vport: pointer to a vitural port
14983  * @dmabuf: pointer to a dmabuf that describes the FC sequence
14984  *
14985  * This function tries to abort from the assembed sequence from upper level
14986  * protocol, described by the information from basic abbort @dmabuf. It
14987  * checks to see whether such pending context exists at upper level protocol.
14988  * If so, it shall clean up the pending context.
14989  *
14990  * Return
14991  * true  -- if there is matching pending context of the sequence cleaned
14992  *          at ulp;
14993  * false -- if there is no matching pending context of the sequence present
14994  *          at ulp.
14995  **/
14996 static bool
14997 lpfc_sli4_abort_ulp_seq(struct lpfc_vport *vport, struct hbq_dmabuf *dmabuf)
14998 {
14999 	struct lpfc_hba *phba = vport->phba;
15000 	int handled;
15001 
15002 	/* Accepting abort at ulp with SLI4 only */
15003 	if (phba->sli_rev < LPFC_SLI_REV4)
15004 		return false;
15005 
15006 	/* Register all caring upper level protocols to attend abort */
15007 	handled = lpfc_ct_handle_unsol_abort(phba, dmabuf);
15008 	if (handled)
15009 		return true;
15010 
15011 	return false;
15012 }
15013 
15014 /**
15015  * lpfc_sli4_seq_abort_rsp_cmpl - BLS ABORT RSP seq abort iocb complete handler
15016  * @phba: Pointer to HBA context object.
15017  * @cmd_iocbq: pointer to the command iocbq structure.
15018  * @rsp_iocbq: pointer to the response iocbq structure.
15019  *
15020  * This function handles the sequence abort response iocb command complete
15021  * event. It properly releases the memory allocated to the sequence abort
15022  * accept iocb.
15023  **/
15024 static void
15025 lpfc_sli4_seq_abort_rsp_cmpl(struct lpfc_hba *phba,
15026 			     struct lpfc_iocbq *cmd_iocbq,
15027 			     struct lpfc_iocbq *rsp_iocbq)
15028 {
15029 	struct lpfc_nodelist *ndlp;
15030 
15031 	if (cmd_iocbq) {
15032 		ndlp = (struct lpfc_nodelist *)cmd_iocbq->context1;
15033 		lpfc_nlp_put(ndlp);
15034 		lpfc_nlp_not_used(ndlp);
15035 		lpfc_sli_release_iocbq(phba, cmd_iocbq);
15036 	}
15037 
15038 	/* Failure means BLS ABORT RSP did not get delivered to remote node*/
15039 	if (rsp_iocbq && rsp_iocbq->iocb.ulpStatus)
15040 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
15041 			"3154 BLS ABORT RSP failed, data:  x%x/x%x\n",
15042 			rsp_iocbq->iocb.ulpStatus,
15043 			rsp_iocbq->iocb.un.ulpWord[4]);
15044 }
15045 
15046 /**
15047  * lpfc_sli4_xri_inrange - check xri is in range of xris owned by driver.
15048  * @phba: Pointer to HBA context object.
15049  * @xri: xri id in transaction.
15050  *
15051  * This function validates the xri maps to the known range of XRIs allocated an
15052  * used by the driver.
15053  **/
15054 uint16_t
15055 lpfc_sli4_xri_inrange(struct lpfc_hba *phba,
15056 		      uint16_t xri)
15057 {
15058 	uint16_t i;
15059 
15060 	for (i = 0; i < phba->sli4_hba.max_cfg_param.max_xri; i++) {
15061 		if (xri == phba->sli4_hba.xri_ids[i])
15062 			return i;
15063 	}
15064 	return NO_XRI;
15065 }
15066 
15067 /**
15068  * lpfc_sli4_seq_abort_rsp - bls rsp to sequence abort
15069  * @phba: Pointer to HBA context object.
15070  * @fc_hdr: pointer to a FC frame header.
15071  *
15072  * This function sends a basic response to a previous unsol sequence abort
15073  * event after aborting the sequence handling.
15074  **/
15075 static void
15076 lpfc_sli4_seq_abort_rsp(struct lpfc_vport *vport,
15077 			struct fc_frame_header *fc_hdr, bool aborted)
15078 {
15079 	struct lpfc_hba *phba = vport->phba;
15080 	struct lpfc_iocbq *ctiocb = NULL;
15081 	struct lpfc_nodelist *ndlp;
15082 	uint16_t oxid, rxid, xri, lxri;
15083 	uint32_t sid, fctl;
15084 	IOCB_t *icmd;
15085 	int rc;
15086 
15087 	if (!lpfc_is_link_up(phba))
15088 		return;
15089 
15090 	sid = sli4_sid_from_fc_hdr(fc_hdr);
15091 	oxid = be16_to_cpu(fc_hdr->fh_ox_id);
15092 	rxid = be16_to_cpu(fc_hdr->fh_rx_id);
15093 
15094 	ndlp = lpfc_findnode_did(vport, sid);
15095 	if (!ndlp) {
15096 		ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
15097 		if (!ndlp) {
15098 			lpfc_printf_vlog(vport, KERN_WARNING, LOG_ELS,
15099 					 "1268 Failed to allocate ndlp for "
15100 					 "oxid:x%x SID:x%x\n", oxid, sid);
15101 			return;
15102 		}
15103 		lpfc_nlp_init(vport, ndlp, sid);
15104 		/* Put ndlp onto pport node list */
15105 		lpfc_enqueue_node(vport, ndlp);
15106 	} else if (!NLP_CHK_NODE_ACT(ndlp)) {
15107 		/* re-setup ndlp without removing from node list */
15108 		ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE);
15109 		if (!ndlp) {
15110 			lpfc_printf_vlog(vport, KERN_WARNING, LOG_ELS,
15111 					 "3275 Failed to active ndlp found "
15112 					 "for oxid:x%x SID:x%x\n", oxid, sid);
15113 			return;
15114 		}
15115 	}
15116 
15117 	/* Allocate buffer for rsp iocb */
15118 	ctiocb = lpfc_sli_get_iocbq(phba);
15119 	if (!ctiocb)
15120 		return;
15121 
15122 	/* Extract the F_CTL field from FC_HDR */
15123 	fctl = sli4_fctl_from_fc_hdr(fc_hdr);
15124 
15125 	icmd = &ctiocb->iocb;
15126 	icmd->un.xseq64.bdl.bdeSize = 0;
15127 	icmd->un.xseq64.bdl.ulpIoTag32 = 0;
15128 	icmd->un.xseq64.w5.hcsw.Dfctl = 0;
15129 	icmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_BA_ACC;
15130 	icmd->un.xseq64.w5.hcsw.Type = FC_TYPE_BLS;
15131 
15132 	/* Fill in the rest of iocb fields */
15133 	icmd->ulpCommand = CMD_XMIT_BLS_RSP64_CX;
15134 	icmd->ulpBdeCount = 0;
15135 	icmd->ulpLe = 1;
15136 	icmd->ulpClass = CLASS3;
15137 	icmd->ulpContext = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
15138 	ctiocb->context1 = lpfc_nlp_get(ndlp);
15139 
15140 	ctiocb->iocb_cmpl = NULL;
15141 	ctiocb->vport = phba->pport;
15142 	ctiocb->iocb_cmpl = lpfc_sli4_seq_abort_rsp_cmpl;
15143 	ctiocb->sli4_lxritag = NO_XRI;
15144 	ctiocb->sli4_xritag = NO_XRI;
15145 
15146 	if (fctl & FC_FC_EX_CTX)
15147 		/* Exchange responder sent the abort so we
15148 		 * own the oxid.
15149 		 */
15150 		xri = oxid;
15151 	else
15152 		xri = rxid;
15153 	lxri = lpfc_sli4_xri_inrange(phba, xri);
15154 	if (lxri != NO_XRI)
15155 		lpfc_set_rrq_active(phba, ndlp, lxri,
15156 			(xri == oxid) ? rxid : oxid, 0);
15157 	/* For BA_ABTS from exchange responder, if the logical xri with
15158 	 * the oxid maps to the FCP XRI range, the port no longer has
15159 	 * that exchange context, send a BLS_RJT. Override the IOCB for
15160 	 * a BA_RJT.
15161 	 */
15162 	if ((fctl & FC_FC_EX_CTX) &&
15163 	    (lxri > lpfc_sli4_get_els_iocb_cnt(phba))) {
15164 		icmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_BA_RJT;
15165 		bf_set(lpfc_vndr_code, &icmd->un.bls_rsp, 0);
15166 		bf_set(lpfc_rsn_expln, &icmd->un.bls_rsp, FC_BA_RJT_INV_XID);
15167 		bf_set(lpfc_rsn_code, &icmd->un.bls_rsp, FC_BA_RJT_UNABLE);
15168 	}
15169 
15170 	/* If BA_ABTS failed to abort a partially assembled receive sequence,
15171 	 * the driver no longer has that exchange, send a BLS_RJT. Override
15172 	 * the IOCB for a BA_RJT.
15173 	 */
15174 	if (aborted == false) {
15175 		icmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_BA_RJT;
15176 		bf_set(lpfc_vndr_code, &icmd->un.bls_rsp, 0);
15177 		bf_set(lpfc_rsn_expln, &icmd->un.bls_rsp, FC_BA_RJT_INV_XID);
15178 		bf_set(lpfc_rsn_code, &icmd->un.bls_rsp, FC_BA_RJT_UNABLE);
15179 	}
15180 
15181 	if (fctl & FC_FC_EX_CTX) {
15182 		/* ABTS sent by responder to CT exchange, construction
15183 		 * of BA_ACC will use OX_ID from ABTS for the XRI_TAG
15184 		 * field and RX_ID from ABTS for RX_ID field.
15185 		 */
15186 		bf_set(lpfc_abts_orig, &icmd->un.bls_rsp, LPFC_ABTS_UNSOL_RSP);
15187 	} else {
15188 		/* ABTS sent by initiator to CT exchange, construction
15189 		 * of BA_ACC will need to allocate a new XRI as for the
15190 		 * XRI_TAG field.
15191 		 */
15192 		bf_set(lpfc_abts_orig, &icmd->un.bls_rsp, LPFC_ABTS_UNSOL_INT);
15193 	}
15194 	bf_set(lpfc_abts_rxid, &icmd->un.bls_rsp, rxid);
15195 	bf_set(lpfc_abts_oxid, &icmd->un.bls_rsp, oxid);
15196 
15197 	/* Xmit CT abts response on exchange <xid> */
15198 	lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
15199 			 "1200 Send BLS cmd x%x on oxid x%x Data: x%x\n",
15200 			 icmd->un.xseq64.w5.hcsw.Rctl, oxid, phba->link_state);
15201 
15202 	rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, ctiocb, 0);
15203 	if (rc == IOCB_ERROR) {
15204 		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
15205 				 "2925 Failed to issue CT ABTS RSP x%x on "
15206 				 "xri x%x, Data x%x\n",
15207 				 icmd->un.xseq64.w5.hcsw.Rctl, oxid,
15208 				 phba->link_state);
15209 		lpfc_nlp_put(ndlp);
15210 		ctiocb->context1 = NULL;
15211 		lpfc_sli_release_iocbq(phba, ctiocb);
15212 	}
15213 }
15214 
15215 /**
15216  * lpfc_sli4_handle_unsol_abort - Handle sli-4 unsolicited abort event
15217  * @vport: Pointer to the vport on which this sequence was received
15218  * @dmabuf: pointer to a dmabuf that describes the FC sequence
15219  *
15220  * This function handles an SLI-4 unsolicited abort event. If the unsolicited
15221  * receive sequence is only partially assembed by the driver, it shall abort
15222  * the partially assembled frames for the sequence. Otherwise, if the
15223  * unsolicited receive sequence has been completely assembled and passed to
15224  * the Upper Layer Protocol (UPL), it then mark the per oxid status for the
15225  * unsolicited sequence has been aborted. After that, it will issue a basic
15226  * accept to accept the abort.
15227  **/
15228 static void
15229 lpfc_sli4_handle_unsol_abort(struct lpfc_vport *vport,
15230 			     struct hbq_dmabuf *dmabuf)
15231 {
15232 	struct lpfc_hba *phba = vport->phba;
15233 	struct fc_frame_header fc_hdr;
15234 	uint32_t fctl;
15235 	bool aborted;
15236 
15237 	/* Make a copy of fc_hdr before the dmabuf being released */
15238 	memcpy(&fc_hdr, dmabuf->hbuf.virt, sizeof(struct fc_frame_header));
15239 	fctl = sli4_fctl_from_fc_hdr(&fc_hdr);
15240 
15241 	if (fctl & FC_FC_EX_CTX) {
15242 		/* ABTS by responder to exchange, no cleanup needed */
15243 		aborted = true;
15244 	} else {
15245 		/* ABTS by initiator to exchange, need to do cleanup */
15246 		aborted = lpfc_sli4_abort_partial_seq(vport, dmabuf);
15247 		if (aborted == false)
15248 			aborted = lpfc_sli4_abort_ulp_seq(vport, dmabuf);
15249 	}
15250 	lpfc_in_buf_free(phba, &dmabuf->dbuf);
15251 
15252 	/* Respond with BA_ACC or BA_RJT accordingly */
15253 	lpfc_sli4_seq_abort_rsp(vport, &fc_hdr, aborted);
15254 }
15255 
15256 /**
15257  * lpfc_seq_complete - Indicates if a sequence is complete
15258  * @dmabuf: pointer to a dmabuf that describes the FC sequence
15259  *
15260  * This function checks the sequence, starting with the frame described by
15261  * @dmabuf, to see if all the frames associated with this sequence are present.
15262  * the frames associated with this sequence are linked to the @dmabuf using the
15263  * dbuf list. This function looks for two major things. 1) That the first frame
15264  * has a sequence count of zero. 2) There is a frame with last frame of sequence
15265  * set. 3) That there are no holes in the sequence count. The function will
15266  * return 1 when the sequence is complete, otherwise it will return 0.
15267  **/
15268 static int
15269 lpfc_seq_complete(struct hbq_dmabuf *dmabuf)
15270 {
15271 	struct fc_frame_header *hdr;
15272 	struct lpfc_dmabuf *d_buf;
15273 	struct hbq_dmabuf *seq_dmabuf;
15274 	uint32_t fctl;
15275 	int seq_count = 0;
15276 
15277 	hdr = (struct fc_frame_header *)dmabuf->hbuf.virt;
15278 	/* make sure first fame of sequence has a sequence count of zero */
15279 	if (hdr->fh_seq_cnt != seq_count)
15280 		return 0;
15281 	fctl = (hdr->fh_f_ctl[0] << 16 |
15282 		hdr->fh_f_ctl[1] << 8 |
15283 		hdr->fh_f_ctl[2]);
15284 	/* If last frame of sequence we can return success. */
15285 	if (fctl & FC_FC_END_SEQ)
15286 		return 1;
15287 	list_for_each_entry(d_buf, &dmabuf->dbuf.list, list) {
15288 		seq_dmabuf = container_of(d_buf, struct hbq_dmabuf, dbuf);
15289 		hdr = (struct fc_frame_header *)seq_dmabuf->hbuf.virt;
15290 		/* If there is a hole in the sequence count then fail. */
15291 		if (++seq_count != be16_to_cpu(hdr->fh_seq_cnt))
15292 			return 0;
15293 		fctl = (hdr->fh_f_ctl[0] << 16 |
15294 			hdr->fh_f_ctl[1] << 8 |
15295 			hdr->fh_f_ctl[2]);
15296 		/* If last frame of sequence we can return success. */
15297 		if (fctl & FC_FC_END_SEQ)
15298 			return 1;
15299 	}
15300 	return 0;
15301 }
15302 
15303 /**
15304  * lpfc_prep_seq - Prep sequence for ULP processing
15305  * @vport: Pointer to the vport on which this sequence was received
15306  * @dmabuf: pointer to a dmabuf that describes the FC sequence
15307  *
15308  * This function takes a sequence, described by a list of frames, and creates
15309  * a list of iocbq structures to describe the sequence. This iocbq list will be
15310  * used to issue to the generic unsolicited sequence handler. This routine
15311  * returns a pointer to the first iocbq in the list. If the function is unable
15312  * to allocate an iocbq then it throw out the received frames that were not
15313  * able to be described and return a pointer to the first iocbq. If unable to
15314  * allocate any iocbqs (including the first) this function will return NULL.
15315  **/
15316 static struct lpfc_iocbq *
15317 lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
15318 {
15319 	struct hbq_dmabuf *hbq_buf;
15320 	struct lpfc_dmabuf *d_buf, *n_buf;
15321 	struct lpfc_iocbq *first_iocbq, *iocbq;
15322 	struct fc_frame_header *fc_hdr;
15323 	uint32_t sid;
15324 	uint32_t len, tot_len;
15325 	struct ulp_bde64 *pbde;
15326 
15327 	fc_hdr = (struct fc_frame_header *)seq_dmabuf->hbuf.virt;
15328 	/* remove from receive buffer list */
15329 	list_del_init(&seq_dmabuf->hbuf.list);
15330 	lpfc_update_rcv_time_stamp(vport);
15331 	/* get the Remote Port's SID */
15332 	sid = sli4_sid_from_fc_hdr(fc_hdr);
15333 	tot_len = 0;
15334 	/* Get an iocbq struct to fill in. */
15335 	first_iocbq = lpfc_sli_get_iocbq(vport->phba);
15336 	if (first_iocbq) {
15337 		/* Initialize the first IOCB. */
15338 		first_iocbq->iocb.unsli3.rcvsli3.acc_len = 0;
15339 		first_iocbq->iocb.ulpStatus = IOSTAT_SUCCESS;
15340 
15341 		/* Check FC Header to see what TYPE of frame we are rcv'ing */
15342 		if (sli4_type_from_fc_hdr(fc_hdr) == FC_TYPE_ELS) {
15343 			first_iocbq->iocb.ulpCommand = CMD_IOCB_RCV_ELS64_CX;
15344 			first_iocbq->iocb.un.rcvels.parmRo =
15345 				sli4_did_from_fc_hdr(fc_hdr);
15346 			first_iocbq->iocb.ulpPU = PARM_NPIV_DID;
15347 		} else
15348 			first_iocbq->iocb.ulpCommand = CMD_IOCB_RCV_SEQ64_CX;
15349 		first_iocbq->iocb.ulpContext = NO_XRI;
15350 		first_iocbq->iocb.unsli3.rcvsli3.ox_id =
15351 			be16_to_cpu(fc_hdr->fh_ox_id);
15352 		/* iocbq is prepped for internal consumption.  Physical vpi. */
15353 		first_iocbq->iocb.unsli3.rcvsli3.vpi =
15354 			vport->phba->vpi_ids[vport->vpi];
15355 		/* put the first buffer into the first IOCBq */
15356 		tot_len = bf_get(lpfc_rcqe_length,
15357 				       &seq_dmabuf->cq_event.cqe.rcqe_cmpl);
15358 
15359 		first_iocbq->context2 = &seq_dmabuf->dbuf;
15360 		first_iocbq->context3 = NULL;
15361 		first_iocbq->iocb.ulpBdeCount = 1;
15362 		if (tot_len > LPFC_DATA_BUF_SIZE)
15363 			first_iocbq->iocb.un.cont64[0].tus.f.bdeSize =
15364 							LPFC_DATA_BUF_SIZE;
15365 		else
15366 			first_iocbq->iocb.un.cont64[0].tus.f.bdeSize = tot_len;
15367 
15368 		first_iocbq->iocb.un.rcvels.remoteID = sid;
15369 
15370 		first_iocbq->iocb.unsli3.rcvsli3.acc_len = tot_len;
15371 	}
15372 	iocbq = first_iocbq;
15373 	/*
15374 	 * Each IOCBq can have two Buffers assigned, so go through the list
15375 	 * of buffers for this sequence and save two buffers in each IOCBq
15376 	 */
15377 	list_for_each_entry_safe(d_buf, n_buf, &seq_dmabuf->dbuf.list, list) {
15378 		if (!iocbq) {
15379 			lpfc_in_buf_free(vport->phba, d_buf);
15380 			continue;
15381 		}
15382 		if (!iocbq->context3) {
15383 			iocbq->context3 = d_buf;
15384 			iocbq->iocb.ulpBdeCount++;
15385 			/* We need to get the size out of the right CQE */
15386 			hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
15387 			len = bf_get(lpfc_rcqe_length,
15388 				       &hbq_buf->cq_event.cqe.rcqe_cmpl);
15389 			pbde = (struct ulp_bde64 *)
15390 					&iocbq->iocb.unsli3.sli3Words[4];
15391 			if (len > LPFC_DATA_BUF_SIZE)
15392 				pbde->tus.f.bdeSize = LPFC_DATA_BUF_SIZE;
15393 			else
15394 				pbde->tus.f.bdeSize = len;
15395 
15396 			iocbq->iocb.unsli3.rcvsli3.acc_len += len;
15397 			tot_len += len;
15398 		} else {
15399 			iocbq = lpfc_sli_get_iocbq(vport->phba);
15400 			if (!iocbq) {
15401 				if (first_iocbq) {
15402 					first_iocbq->iocb.ulpStatus =
15403 							IOSTAT_FCP_RSP_ERROR;
15404 					first_iocbq->iocb.un.ulpWord[4] =
15405 							IOERR_NO_RESOURCES;
15406 				}
15407 				lpfc_in_buf_free(vport->phba, d_buf);
15408 				continue;
15409 			}
15410 			/* We need to get the size out of the right CQE */
15411 			hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
15412 			len = bf_get(lpfc_rcqe_length,
15413 				       &hbq_buf->cq_event.cqe.rcqe_cmpl);
15414 			iocbq->context2 = d_buf;
15415 			iocbq->context3 = NULL;
15416 			iocbq->iocb.ulpBdeCount = 1;
15417 			if (len > LPFC_DATA_BUF_SIZE)
15418 				iocbq->iocb.un.cont64[0].tus.f.bdeSize =
15419 							LPFC_DATA_BUF_SIZE;
15420 			else
15421 				iocbq->iocb.un.cont64[0].tus.f.bdeSize = len;
15422 
15423 			tot_len += len;
15424 			iocbq->iocb.unsli3.rcvsli3.acc_len = tot_len;
15425 
15426 			iocbq->iocb.un.rcvels.remoteID = sid;
15427 			list_add_tail(&iocbq->list, &first_iocbq->list);
15428 		}
15429 	}
15430 	return first_iocbq;
15431 }
15432 
15433 static void
15434 lpfc_sli4_send_seq_to_ulp(struct lpfc_vport *vport,
15435 			  struct hbq_dmabuf *seq_dmabuf)
15436 {
15437 	struct fc_frame_header *fc_hdr;
15438 	struct lpfc_iocbq *iocbq, *curr_iocb, *next_iocb;
15439 	struct lpfc_hba *phba = vport->phba;
15440 
15441 	fc_hdr = (struct fc_frame_header *)seq_dmabuf->hbuf.virt;
15442 	iocbq = lpfc_prep_seq(vport, seq_dmabuf);
15443 	if (!iocbq) {
15444 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
15445 				"2707 Ring %d handler: Failed to allocate "
15446 				"iocb Rctl x%x Type x%x received\n",
15447 				LPFC_ELS_RING,
15448 				fc_hdr->fh_r_ctl, fc_hdr->fh_type);
15449 		return;
15450 	}
15451 	if (!lpfc_complete_unsol_iocb(phba,
15452 				      &phba->sli.ring[LPFC_ELS_RING],
15453 				      iocbq, fc_hdr->fh_r_ctl,
15454 				      fc_hdr->fh_type))
15455 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
15456 				"2540 Ring %d handler: unexpected Rctl "
15457 				"x%x Type x%x received\n",
15458 				LPFC_ELS_RING,
15459 				fc_hdr->fh_r_ctl, fc_hdr->fh_type);
15460 
15461 	/* Free iocb created in lpfc_prep_seq */
15462 	list_for_each_entry_safe(curr_iocb, next_iocb,
15463 		&iocbq->list, list) {
15464 		list_del_init(&curr_iocb->list);
15465 		lpfc_sli_release_iocbq(phba, curr_iocb);
15466 	}
15467 	lpfc_sli_release_iocbq(phba, iocbq);
15468 }
15469 
15470 /**
15471  * lpfc_sli4_handle_received_buffer - Handle received buffers from firmware
15472  * @phba: Pointer to HBA context object.
15473  *
15474  * This function is called with no lock held. This function processes all
15475  * the received buffers and gives it to upper layers when a received buffer
15476  * indicates that it is the final frame in the sequence. The interrupt
15477  * service routine processes received buffers at interrupt contexts and adds
15478  * received dma buffers to the rb_pend_list queue and signals the worker thread.
15479  * Worker thread calls lpfc_sli4_handle_received_buffer, which will call the
15480  * appropriate receive function when the final frame in a sequence is received.
15481  **/
15482 void
15483 lpfc_sli4_handle_received_buffer(struct lpfc_hba *phba,
15484 				 struct hbq_dmabuf *dmabuf)
15485 {
15486 	struct hbq_dmabuf *seq_dmabuf;
15487 	struct fc_frame_header *fc_hdr;
15488 	struct lpfc_vport *vport;
15489 	uint32_t fcfi;
15490 	uint32_t did;
15491 
15492 	/* Process each received buffer */
15493 	fc_hdr = (struct fc_frame_header *)dmabuf->hbuf.virt;
15494 	/* check to see if this a valid type of frame */
15495 	if (lpfc_fc_frame_check(phba, fc_hdr)) {
15496 		lpfc_in_buf_free(phba, &dmabuf->dbuf);
15497 		return;
15498 	}
15499 	if ((bf_get(lpfc_cqe_code,
15500 		    &dmabuf->cq_event.cqe.rcqe_cmpl) == CQE_CODE_RECEIVE_V1))
15501 		fcfi = bf_get(lpfc_rcqe_fcf_id_v1,
15502 			      &dmabuf->cq_event.cqe.rcqe_cmpl);
15503 	else
15504 		fcfi = bf_get(lpfc_rcqe_fcf_id,
15505 			      &dmabuf->cq_event.cqe.rcqe_cmpl);
15506 
15507 	vport = lpfc_fc_frame_to_vport(phba, fc_hdr, fcfi);
15508 	if (!vport) {
15509 		/* throw out the frame */
15510 		lpfc_in_buf_free(phba, &dmabuf->dbuf);
15511 		return;
15512 	}
15513 
15514 	/* d_id this frame is directed to */
15515 	did = sli4_did_from_fc_hdr(fc_hdr);
15516 
15517 	/* vport is registered unless we rcv a FLOGI directed to Fabric_DID */
15518 	if (!(vport->vpi_state & LPFC_VPI_REGISTERED) &&
15519 		(did != Fabric_DID)) {
15520 		/*
15521 		 * Throw out the frame if we are not pt2pt.
15522 		 * The pt2pt protocol allows for discovery frames
15523 		 * to be received without a registered VPI.
15524 		 */
15525 		if (!(vport->fc_flag & FC_PT2PT) ||
15526 			(phba->link_state == LPFC_HBA_READY)) {
15527 			lpfc_in_buf_free(phba, &dmabuf->dbuf);
15528 			return;
15529 		}
15530 	}
15531 
15532 	/* Handle the basic abort sequence (BA_ABTS) event */
15533 	if (fc_hdr->fh_r_ctl == FC_RCTL_BA_ABTS) {
15534 		lpfc_sli4_handle_unsol_abort(vport, dmabuf);
15535 		return;
15536 	}
15537 
15538 	/* Link this frame */
15539 	seq_dmabuf = lpfc_fc_frame_add(vport, dmabuf);
15540 	if (!seq_dmabuf) {
15541 		/* unable to add frame to vport - throw it out */
15542 		lpfc_in_buf_free(phba, &dmabuf->dbuf);
15543 		return;
15544 	}
15545 	/* If not last frame in sequence continue processing frames. */
15546 	if (!lpfc_seq_complete(seq_dmabuf))
15547 		return;
15548 
15549 	/* Send the complete sequence to the upper layer protocol */
15550 	lpfc_sli4_send_seq_to_ulp(vport, seq_dmabuf);
15551 }
15552 
15553 /**
15554  * lpfc_sli4_post_all_rpi_hdrs - Post the rpi header memory region to the port
15555  * @phba: pointer to lpfc hba data structure.
15556  *
15557  * This routine is invoked to post rpi header templates to the
15558  * HBA consistent with the SLI-4 interface spec.  This routine
15559  * posts a SLI4_PAGE_SIZE memory region to the port to hold up to
15560  * SLI4_PAGE_SIZE modulo 64 rpi context headers.
15561  *
15562  * This routine does not require any locks.  It's usage is expected
15563  * to be driver load or reset recovery when the driver is
15564  * sequential.
15565  *
15566  * Return codes
15567  * 	0 - successful
15568  *      -EIO - The mailbox failed to complete successfully.
15569  * 	When this error occurs, the driver is not guaranteed
15570  *	to have any rpi regions posted to the device and
15571  *	must either attempt to repost the regions or take a
15572  *	fatal error.
15573  **/
15574 int
15575 lpfc_sli4_post_all_rpi_hdrs(struct lpfc_hba *phba)
15576 {
15577 	struct lpfc_rpi_hdr *rpi_page;
15578 	uint32_t rc = 0;
15579 	uint16_t lrpi = 0;
15580 
15581 	/* SLI4 ports that support extents do not require RPI headers. */
15582 	if (!phba->sli4_hba.rpi_hdrs_in_use)
15583 		goto exit;
15584 	if (phba->sli4_hba.extents_in_use)
15585 		return -EIO;
15586 
15587 	list_for_each_entry(rpi_page, &phba->sli4_hba.lpfc_rpi_hdr_list, list) {
15588 		/*
15589 		 * Assign the rpi headers a physical rpi only if the driver
15590 		 * has not initialized those resources.  A port reset only
15591 		 * needs the headers posted.
15592 		 */
15593 		if (bf_get(lpfc_rpi_rsrc_rdy, &phba->sli4_hba.sli4_flags) !=
15594 		    LPFC_RPI_RSRC_RDY)
15595 			rpi_page->start_rpi = phba->sli4_hba.rpi_ids[lrpi];
15596 
15597 		rc = lpfc_sli4_post_rpi_hdr(phba, rpi_page);
15598 		if (rc != MBX_SUCCESS) {
15599 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
15600 					"2008 Error %d posting all rpi "
15601 					"headers\n", rc);
15602 			rc = -EIO;
15603 			break;
15604 		}
15605 	}
15606 
15607  exit:
15608 	bf_set(lpfc_rpi_rsrc_rdy, &phba->sli4_hba.sli4_flags,
15609 	       LPFC_RPI_RSRC_RDY);
15610 	return rc;
15611 }
15612 
15613 /**
15614  * lpfc_sli4_post_rpi_hdr - Post an rpi header memory region to the port
15615  * @phba: pointer to lpfc hba data structure.
15616  * @rpi_page:  pointer to the rpi memory region.
15617  *
15618  * This routine is invoked to post a single rpi header to the
15619  * HBA consistent with the SLI-4 interface spec.  This memory region
15620  * maps up to 64 rpi context regions.
15621  *
15622  * Return codes
15623  * 	0 - successful
15624  * 	-ENOMEM - No available memory
15625  *      -EIO - The mailbox failed to complete successfully.
15626  **/
15627 int
15628 lpfc_sli4_post_rpi_hdr(struct lpfc_hba *phba, struct lpfc_rpi_hdr *rpi_page)
15629 {
15630 	LPFC_MBOXQ_t *mboxq;
15631 	struct lpfc_mbx_post_hdr_tmpl *hdr_tmpl;
15632 	uint32_t rc = 0;
15633 	uint32_t shdr_status, shdr_add_status;
15634 	union lpfc_sli4_cfg_shdr *shdr;
15635 
15636 	/* SLI4 ports that support extents do not require RPI headers. */
15637 	if (!phba->sli4_hba.rpi_hdrs_in_use)
15638 		return rc;
15639 	if (phba->sli4_hba.extents_in_use)
15640 		return -EIO;
15641 
15642 	/* The port is notified of the header region via a mailbox command. */
15643 	mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
15644 	if (!mboxq) {
15645 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
15646 				"2001 Unable to allocate memory for issuing "
15647 				"SLI_CONFIG_SPECIAL mailbox command\n");
15648 		return -ENOMEM;
15649 	}
15650 
15651 	/* Post all rpi memory regions to the port. */
15652 	hdr_tmpl = &mboxq->u.mqe.un.hdr_tmpl;
15653 	lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
15654 			 LPFC_MBOX_OPCODE_FCOE_POST_HDR_TEMPLATE,
15655 			 sizeof(struct lpfc_mbx_post_hdr_tmpl) -
15656 			 sizeof(struct lpfc_sli4_cfg_mhdr),
15657 			 LPFC_SLI4_MBX_EMBED);
15658 
15659 
15660 	/* Post the physical rpi to the port for this rpi header. */
15661 	bf_set(lpfc_mbx_post_hdr_tmpl_rpi_offset, hdr_tmpl,
15662 	       rpi_page->start_rpi);
15663 	bf_set(lpfc_mbx_post_hdr_tmpl_page_cnt,
15664 	       hdr_tmpl, rpi_page->page_count);
15665 
15666 	hdr_tmpl->rpi_paddr_lo = putPaddrLow(rpi_page->dmabuf->phys);
15667 	hdr_tmpl->rpi_paddr_hi = putPaddrHigh(rpi_page->dmabuf->phys);
15668 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
15669 	shdr = (union lpfc_sli4_cfg_shdr *) &hdr_tmpl->header.cfg_shdr;
15670 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
15671 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
15672 	if (rc != MBX_TIMEOUT)
15673 		mempool_free(mboxq, phba->mbox_mem_pool);
15674 	if (shdr_status || shdr_add_status || rc) {
15675 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
15676 				"2514 POST_RPI_HDR mailbox failed with "
15677 				"status x%x add_status x%x, mbx status x%x\n",
15678 				shdr_status, shdr_add_status, rc);
15679 		rc = -ENXIO;
15680 	}
15681 	return rc;
15682 }
15683 
15684 /**
15685  * lpfc_sli4_alloc_rpi - Get an available rpi in the device's range
15686  * @phba: pointer to lpfc hba data structure.
15687  *
15688  * This routine is invoked to post rpi header templates to the
15689  * HBA consistent with the SLI-4 interface spec.  This routine
15690  * posts a SLI4_PAGE_SIZE memory region to the port to hold up to
15691  * SLI4_PAGE_SIZE modulo 64 rpi context headers.
15692  *
15693  * Returns
15694  * 	A nonzero rpi defined as rpi_base <= rpi < max_rpi if successful
15695  * 	LPFC_RPI_ALLOC_ERROR if no rpis are available.
15696  **/
15697 int
15698 lpfc_sli4_alloc_rpi(struct lpfc_hba *phba)
15699 {
15700 	unsigned long rpi;
15701 	uint16_t max_rpi, rpi_limit;
15702 	uint16_t rpi_remaining, lrpi = 0;
15703 	struct lpfc_rpi_hdr *rpi_hdr;
15704 	unsigned long iflag;
15705 
15706 	/*
15707 	 * Fetch the next logical rpi.  Because this index is logical,
15708 	 * the  driver starts at 0 each time.
15709 	 */
15710 	spin_lock_irqsave(&phba->hbalock, iflag);
15711 	max_rpi = phba->sli4_hba.max_cfg_param.max_rpi;
15712 	rpi_limit = phba->sli4_hba.next_rpi;
15713 
15714 	rpi = find_next_zero_bit(phba->sli4_hba.rpi_bmask, rpi_limit, 0);
15715 	if (rpi >= rpi_limit)
15716 		rpi = LPFC_RPI_ALLOC_ERROR;
15717 	else {
15718 		set_bit(rpi, phba->sli4_hba.rpi_bmask);
15719 		phba->sli4_hba.max_cfg_param.rpi_used++;
15720 		phba->sli4_hba.rpi_count++;
15721 	}
15722 	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
15723 			"0001 rpi:%x max:%x lim:%x\n",
15724 			(int) rpi, max_rpi, rpi_limit);
15725 
15726 	/*
15727 	 * Don't try to allocate more rpi header regions if the device limit
15728 	 * has been exhausted.
15729 	 */
15730 	if ((rpi == LPFC_RPI_ALLOC_ERROR) &&
15731 	    (phba->sli4_hba.rpi_count >= max_rpi)) {
15732 		spin_unlock_irqrestore(&phba->hbalock, iflag);
15733 		return rpi;
15734 	}
15735 
15736 	/*
15737 	 * RPI header postings are not required for SLI4 ports capable of
15738 	 * extents.
15739 	 */
15740 	if (!phba->sli4_hba.rpi_hdrs_in_use) {
15741 		spin_unlock_irqrestore(&phba->hbalock, iflag);
15742 		return rpi;
15743 	}
15744 
15745 	/*
15746 	 * If the driver is running low on rpi resources, allocate another
15747 	 * page now.  Note that the next_rpi value is used because
15748 	 * it represents how many are actually in use whereas max_rpi notes
15749 	 * how many are supported max by the device.
15750 	 */
15751 	rpi_remaining = phba->sli4_hba.next_rpi - phba->sli4_hba.rpi_count;
15752 	spin_unlock_irqrestore(&phba->hbalock, iflag);
15753 	if (rpi_remaining < LPFC_RPI_LOW_WATER_MARK) {
15754 		rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);
15755 		if (!rpi_hdr) {
15756 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
15757 					"2002 Error Could not grow rpi "
15758 					"count\n");
15759 		} else {
15760 			lrpi = rpi_hdr->start_rpi;
15761 			rpi_hdr->start_rpi = phba->sli4_hba.rpi_ids[lrpi];
15762 			lpfc_sli4_post_rpi_hdr(phba, rpi_hdr);
15763 		}
15764 	}
15765 
15766 	return rpi;
15767 }
15768 
15769 /**
15770  * lpfc_sli4_free_rpi - Release an rpi for reuse.
15771  * @phba: pointer to lpfc hba data structure.
15772  *
15773  * This routine is invoked to release an rpi to the pool of
15774  * available rpis maintained by the driver.
15775  **/
15776 static void
15777 __lpfc_sli4_free_rpi(struct lpfc_hba *phba, int rpi)
15778 {
15779 	if (test_and_clear_bit(rpi, phba->sli4_hba.rpi_bmask)) {
15780 		phba->sli4_hba.rpi_count--;
15781 		phba->sli4_hba.max_cfg_param.rpi_used--;
15782 	}
15783 }
15784 
15785 /**
15786  * lpfc_sli4_free_rpi - Release an rpi for reuse.
15787  * @phba: pointer to lpfc hba data structure.
15788  *
15789  * This routine is invoked to release an rpi to the pool of
15790  * available rpis maintained by the driver.
15791  **/
15792 void
15793 lpfc_sli4_free_rpi(struct lpfc_hba *phba, int rpi)
15794 {
15795 	spin_lock_irq(&phba->hbalock);
15796 	__lpfc_sli4_free_rpi(phba, rpi);
15797 	spin_unlock_irq(&phba->hbalock);
15798 }
15799 
15800 /**
15801  * lpfc_sli4_remove_rpis - Remove the rpi bitmask region
15802  * @phba: pointer to lpfc hba data structure.
15803  *
15804  * This routine is invoked to remove the memory region that
15805  * provided rpi via a bitmask.
15806  **/
15807 void
15808 lpfc_sli4_remove_rpis(struct lpfc_hba *phba)
15809 {
15810 	kfree(phba->sli4_hba.rpi_bmask);
15811 	kfree(phba->sli4_hba.rpi_ids);
15812 	bf_set(lpfc_rpi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
15813 }
15814 
15815 /**
15816  * lpfc_sli4_resume_rpi - Remove the rpi bitmask region
15817  * @phba: pointer to lpfc hba data structure.
15818  *
15819  * This routine is invoked to remove the memory region that
15820  * provided rpi via a bitmask.
15821  **/
15822 int
15823 lpfc_sli4_resume_rpi(struct lpfc_nodelist *ndlp,
15824 	void (*cmpl)(struct lpfc_hba *, LPFC_MBOXQ_t *), void *arg)
15825 {
15826 	LPFC_MBOXQ_t *mboxq;
15827 	struct lpfc_hba *phba = ndlp->phba;
15828 	int rc;
15829 
15830 	/* The port is notified of the header region via a mailbox command. */
15831 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
15832 	if (!mboxq)
15833 		return -ENOMEM;
15834 
15835 	/* Post all rpi memory regions to the port. */
15836 	lpfc_resume_rpi(mboxq, ndlp);
15837 	if (cmpl) {
15838 		mboxq->mbox_cmpl = cmpl;
15839 		mboxq->context1 = arg;
15840 		mboxq->context2 = ndlp;
15841 	} else
15842 		mboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
15843 	mboxq->vport = ndlp->vport;
15844 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
15845 	if (rc == MBX_NOT_FINISHED) {
15846 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
15847 				"2010 Resume RPI Mailbox failed "
15848 				"status %d, mbxStatus x%x\n", rc,
15849 				bf_get(lpfc_mqe_status, &mboxq->u.mqe));
15850 		mempool_free(mboxq, phba->mbox_mem_pool);
15851 		return -EIO;
15852 	}
15853 	return 0;
15854 }
15855 
15856 /**
15857  * lpfc_sli4_init_vpi - Initialize a vpi with the port
15858  * @vport: Pointer to the vport for which the vpi is being initialized
15859  *
15860  * This routine is invoked to activate a vpi with the port.
15861  *
15862  * Returns:
15863  *    0 success
15864  *    -Evalue otherwise
15865  **/
15866 int
15867 lpfc_sli4_init_vpi(struct lpfc_vport *vport)
15868 {
15869 	LPFC_MBOXQ_t *mboxq;
15870 	int rc = 0;
15871 	int retval = MBX_SUCCESS;
15872 	uint32_t mbox_tmo;
15873 	struct lpfc_hba *phba = vport->phba;
15874 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
15875 	if (!mboxq)
15876 		return -ENOMEM;
15877 	lpfc_init_vpi(phba, mboxq, vport->vpi);
15878 	mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq);
15879 	rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
15880 	if (rc != MBX_SUCCESS) {
15881 		lpfc_printf_vlog(vport, KERN_ERR, LOG_SLI,
15882 				"2022 INIT VPI Mailbox failed "
15883 				"status %d, mbxStatus x%x\n", rc,
15884 				bf_get(lpfc_mqe_status, &mboxq->u.mqe));
15885 		retval = -EIO;
15886 	}
15887 	if (rc != MBX_TIMEOUT)
15888 		mempool_free(mboxq, vport->phba->mbox_mem_pool);
15889 
15890 	return retval;
15891 }
15892 
15893 /**
15894  * lpfc_mbx_cmpl_add_fcf_record - add fcf mbox completion handler.
15895  * @phba: pointer to lpfc hba data structure.
15896  * @mboxq: Pointer to mailbox object.
15897  *
15898  * This routine is invoked to manually add a single FCF record. The caller
15899  * must pass a completely initialized FCF_Record.  This routine takes
15900  * care of the nonembedded mailbox operations.
15901  **/
15902 static void
15903 lpfc_mbx_cmpl_add_fcf_record(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
15904 {
15905 	void *virt_addr;
15906 	union lpfc_sli4_cfg_shdr *shdr;
15907 	uint32_t shdr_status, shdr_add_status;
15908 
15909 	virt_addr = mboxq->sge_array->addr[0];
15910 	/* The IOCTL status is embedded in the mailbox subheader. */
15911 	shdr = (union lpfc_sli4_cfg_shdr *) virt_addr;
15912 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
15913 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
15914 
15915 	if ((shdr_status || shdr_add_status) &&
15916 		(shdr_status != STATUS_FCF_IN_USE))
15917 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
15918 			"2558 ADD_FCF_RECORD mailbox failed with "
15919 			"status x%x add_status x%x\n",
15920 			shdr_status, shdr_add_status);
15921 
15922 	lpfc_sli4_mbox_cmd_free(phba, mboxq);
15923 }
15924 
15925 /**
15926  * lpfc_sli4_add_fcf_record - Manually add an FCF Record.
15927  * @phba: pointer to lpfc hba data structure.
15928  * @fcf_record:  pointer to the initialized fcf record to add.
15929  *
15930  * This routine is invoked to manually add a single FCF record. The caller
15931  * must pass a completely initialized FCF_Record.  This routine takes
15932  * care of the nonembedded mailbox operations.
15933  **/
15934 int
15935 lpfc_sli4_add_fcf_record(struct lpfc_hba *phba, struct fcf_record *fcf_record)
15936 {
15937 	int rc = 0;
15938 	LPFC_MBOXQ_t *mboxq;
15939 	uint8_t *bytep;
15940 	void *virt_addr;
15941 	dma_addr_t phys_addr;
15942 	struct lpfc_mbx_sge sge;
15943 	uint32_t alloc_len, req_len;
15944 	uint32_t fcfindex;
15945 
15946 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
15947 	if (!mboxq) {
15948 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
15949 			"2009 Failed to allocate mbox for ADD_FCF cmd\n");
15950 		return -ENOMEM;
15951 	}
15952 
15953 	req_len = sizeof(struct fcf_record) + sizeof(union lpfc_sli4_cfg_shdr) +
15954 		  sizeof(uint32_t);
15955 
15956 	/* Allocate DMA memory and set up the non-embedded mailbox command */
15957 	alloc_len = lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
15958 				     LPFC_MBOX_OPCODE_FCOE_ADD_FCF,
15959 				     req_len, LPFC_SLI4_MBX_NEMBED);
15960 	if (alloc_len < req_len) {
15961 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
15962 			"2523 Allocated DMA memory size (x%x) is "
15963 			"less than the requested DMA memory "
15964 			"size (x%x)\n", alloc_len, req_len);
15965 		lpfc_sli4_mbox_cmd_free(phba, mboxq);
15966 		return -ENOMEM;
15967 	}
15968 
15969 	/*
15970 	 * Get the first SGE entry from the non-embedded DMA memory.  This
15971 	 * routine only uses a single SGE.
15972 	 */
15973 	lpfc_sli4_mbx_sge_get(mboxq, 0, &sge);
15974 	phys_addr = getPaddr(sge.pa_hi, sge.pa_lo);
15975 	virt_addr = mboxq->sge_array->addr[0];
15976 	/*
15977 	 * Configure the FCF record for FCFI 0.  This is the driver's
15978 	 * hardcoded default and gets used in nonFIP mode.
15979 	 */
15980 	fcfindex = bf_get(lpfc_fcf_record_fcf_index, fcf_record);
15981 	bytep = virt_addr + sizeof(union lpfc_sli4_cfg_shdr);
15982 	lpfc_sli_pcimem_bcopy(&fcfindex, bytep, sizeof(uint32_t));
15983 
15984 	/*
15985 	 * Copy the fcf_index and the FCF Record Data. The data starts after
15986 	 * the FCoE header plus word10. The data copy needs to be endian
15987 	 * correct.
15988 	 */
15989 	bytep += sizeof(uint32_t);
15990 	lpfc_sli_pcimem_bcopy(fcf_record, bytep, sizeof(struct fcf_record));
15991 	mboxq->vport = phba->pport;
15992 	mboxq->mbox_cmpl = lpfc_mbx_cmpl_add_fcf_record;
15993 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
15994 	if (rc == MBX_NOT_FINISHED) {
15995 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
15996 			"2515 ADD_FCF_RECORD mailbox failed with "
15997 			"status 0x%x\n", rc);
15998 		lpfc_sli4_mbox_cmd_free(phba, mboxq);
15999 		rc = -EIO;
16000 	} else
16001 		rc = 0;
16002 
16003 	return rc;
16004 }
16005 
16006 /**
16007  * lpfc_sli4_build_dflt_fcf_record - Build the driver's default FCF Record.
16008  * @phba: pointer to lpfc hba data structure.
16009  * @fcf_record:  pointer to the fcf record to write the default data.
16010  * @fcf_index: FCF table entry index.
16011  *
16012  * This routine is invoked to build the driver's default FCF record.  The
16013  * values used are hardcoded.  This routine handles memory initialization.
16014  *
16015  **/
16016 void
16017 lpfc_sli4_build_dflt_fcf_record(struct lpfc_hba *phba,
16018 				struct fcf_record *fcf_record,
16019 				uint16_t fcf_index)
16020 {
16021 	memset(fcf_record, 0, sizeof(struct fcf_record));
16022 	fcf_record->max_rcv_size = LPFC_FCOE_MAX_RCV_SIZE;
16023 	fcf_record->fka_adv_period = LPFC_FCOE_FKA_ADV_PER;
16024 	fcf_record->fip_priority = LPFC_FCOE_FIP_PRIORITY;
16025 	bf_set(lpfc_fcf_record_mac_0, fcf_record, phba->fc_map[0]);
16026 	bf_set(lpfc_fcf_record_mac_1, fcf_record, phba->fc_map[1]);
16027 	bf_set(lpfc_fcf_record_mac_2, fcf_record, phba->fc_map[2]);
16028 	bf_set(lpfc_fcf_record_mac_3, fcf_record, LPFC_FCOE_FCF_MAC3);
16029 	bf_set(lpfc_fcf_record_mac_4, fcf_record, LPFC_FCOE_FCF_MAC4);
16030 	bf_set(lpfc_fcf_record_mac_5, fcf_record, LPFC_FCOE_FCF_MAC5);
16031 	bf_set(lpfc_fcf_record_fc_map_0, fcf_record, phba->fc_map[0]);
16032 	bf_set(lpfc_fcf_record_fc_map_1, fcf_record, phba->fc_map[1]);
16033 	bf_set(lpfc_fcf_record_fc_map_2, fcf_record, phba->fc_map[2]);
16034 	bf_set(lpfc_fcf_record_fcf_valid, fcf_record, 1);
16035 	bf_set(lpfc_fcf_record_fcf_avail, fcf_record, 1);
16036 	bf_set(lpfc_fcf_record_fcf_index, fcf_record, fcf_index);
16037 	bf_set(lpfc_fcf_record_mac_addr_prov, fcf_record,
16038 		LPFC_FCF_FPMA | LPFC_FCF_SPMA);
16039 	/* Set the VLAN bit map */
16040 	if (phba->valid_vlan) {
16041 		fcf_record->vlan_bitmap[phba->vlan_id / 8]
16042 			= 1 << (phba->vlan_id % 8);
16043 	}
16044 }
16045 
16046 /**
16047  * lpfc_sli4_fcf_scan_read_fcf_rec - Read hba fcf record for fcf scan.
16048  * @phba: pointer to lpfc hba data structure.
16049  * @fcf_index: FCF table entry offset.
16050  *
16051  * This routine is invoked to scan the entire FCF table by reading FCF
16052  * record and processing it one at a time starting from the @fcf_index
16053  * for initial FCF discovery or fast FCF failover rediscovery.
16054  *
16055  * Return 0 if the mailbox command is submitted successfully, none 0
16056  * otherwise.
16057  **/
16058 int
16059 lpfc_sli4_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, uint16_t fcf_index)
16060 {
16061 	int rc = 0, error;
16062 	LPFC_MBOXQ_t *mboxq;
16063 
16064 	phba->fcoe_eventtag_at_fcf_scan = phba->fcoe_eventtag;
16065 	phba->fcoe_cvl_eventtag_attn = phba->fcoe_cvl_eventtag;
16066 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
16067 	if (!mboxq) {
16068 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
16069 				"2000 Failed to allocate mbox for "
16070 				"READ_FCF cmd\n");
16071 		error = -ENOMEM;
16072 		goto fail_fcf_scan;
16073 	}
16074 	/* Construct the read FCF record mailbox command */
16075 	rc = lpfc_sli4_mbx_read_fcf_rec(phba, mboxq, fcf_index);
16076 	if (rc) {
16077 		error = -EINVAL;
16078 		goto fail_fcf_scan;
16079 	}
16080 	/* Issue the mailbox command asynchronously */
16081 	mboxq->vport = phba->pport;
16082 	mboxq->mbox_cmpl = lpfc_mbx_cmpl_fcf_scan_read_fcf_rec;
16083 
16084 	spin_lock_irq(&phba->hbalock);
16085 	phba->hba_flag |= FCF_TS_INPROG;
16086 	spin_unlock_irq(&phba->hbalock);
16087 
16088 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
16089 	if (rc == MBX_NOT_FINISHED)
16090 		error = -EIO;
16091 	else {
16092 		/* Reset eligible FCF count for new scan */
16093 		if (fcf_index == LPFC_FCOE_FCF_GET_FIRST)
16094 			phba->fcf.eligible_fcf_cnt = 0;
16095 		error = 0;
16096 	}
16097 fail_fcf_scan:
16098 	if (error) {
16099 		if (mboxq)
16100 			lpfc_sli4_mbox_cmd_free(phba, mboxq);
16101 		/* FCF scan failed, clear FCF_TS_INPROG flag */
16102 		spin_lock_irq(&phba->hbalock);
16103 		phba->hba_flag &= ~FCF_TS_INPROG;
16104 		spin_unlock_irq(&phba->hbalock);
16105 	}
16106 	return error;
16107 }
16108 
16109 /**
16110  * lpfc_sli4_fcf_rr_read_fcf_rec - Read hba fcf record for roundrobin fcf.
16111  * @phba: pointer to lpfc hba data structure.
16112  * @fcf_index: FCF table entry offset.
16113  *
16114  * This routine is invoked to read an FCF record indicated by @fcf_index
16115  * and to use it for FLOGI roundrobin FCF failover.
16116  *
16117  * Return 0 if the mailbox command is submitted successfully, none 0
16118  * otherwise.
16119  **/
16120 int
16121 lpfc_sli4_fcf_rr_read_fcf_rec(struct lpfc_hba *phba, uint16_t fcf_index)
16122 {
16123 	int rc = 0, error;
16124 	LPFC_MBOXQ_t *mboxq;
16125 
16126 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
16127 	if (!mboxq) {
16128 		lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_INIT,
16129 				"2763 Failed to allocate mbox for "
16130 				"READ_FCF cmd\n");
16131 		error = -ENOMEM;
16132 		goto fail_fcf_read;
16133 	}
16134 	/* Construct the read FCF record mailbox command */
16135 	rc = lpfc_sli4_mbx_read_fcf_rec(phba, mboxq, fcf_index);
16136 	if (rc) {
16137 		error = -EINVAL;
16138 		goto fail_fcf_read;
16139 	}
16140 	/* Issue the mailbox command asynchronously */
16141 	mboxq->vport = phba->pport;
16142 	mboxq->mbox_cmpl = lpfc_mbx_cmpl_fcf_rr_read_fcf_rec;
16143 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
16144 	if (rc == MBX_NOT_FINISHED)
16145 		error = -EIO;
16146 	else
16147 		error = 0;
16148 
16149 fail_fcf_read:
16150 	if (error && mboxq)
16151 		lpfc_sli4_mbox_cmd_free(phba, mboxq);
16152 	return error;
16153 }
16154 
16155 /**
16156  * lpfc_sli4_read_fcf_rec - Read hba fcf record for update eligible fcf bmask.
16157  * @phba: pointer to lpfc hba data structure.
16158  * @fcf_index: FCF table entry offset.
16159  *
16160  * This routine is invoked to read an FCF record indicated by @fcf_index to
16161  * determine whether it's eligible for FLOGI roundrobin failover list.
16162  *
16163  * Return 0 if the mailbox command is submitted successfully, none 0
16164  * otherwise.
16165  **/
16166 int
16167 lpfc_sli4_read_fcf_rec(struct lpfc_hba *phba, uint16_t fcf_index)
16168 {
16169 	int rc = 0, error;
16170 	LPFC_MBOXQ_t *mboxq;
16171 
16172 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
16173 	if (!mboxq) {
16174 		lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_INIT,
16175 				"2758 Failed to allocate mbox for "
16176 				"READ_FCF cmd\n");
16177 				error = -ENOMEM;
16178 				goto fail_fcf_read;
16179 	}
16180 	/* Construct the read FCF record mailbox command */
16181 	rc = lpfc_sli4_mbx_read_fcf_rec(phba, mboxq, fcf_index);
16182 	if (rc) {
16183 		error = -EINVAL;
16184 		goto fail_fcf_read;
16185 	}
16186 	/* Issue the mailbox command asynchronously */
16187 	mboxq->vport = phba->pport;
16188 	mboxq->mbox_cmpl = lpfc_mbx_cmpl_read_fcf_rec;
16189 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
16190 	if (rc == MBX_NOT_FINISHED)
16191 		error = -EIO;
16192 	else
16193 		error = 0;
16194 
16195 fail_fcf_read:
16196 	if (error && mboxq)
16197 		lpfc_sli4_mbox_cmd_free(phba, mboxq);
16198 	return error;
16199 }
16200 
16201 /**
16202  * lpfc_check_next_fcf_pri
16203  * phba pointer to the lpfc_hba struct for this port.
16204  * This routine is called from the lpfc_sli4_fcf_rr_next_index_get
16205  * routine when the rr_bmask is empty. The FCF indecies are put into the
16206  * rr_bmask based on their priority level. Starting from the highest priority
16207  * to the lowest. The most likely FCF candidate will be in the highest
16208  * priority group. When this routine is called it searches the fcf_pri list for
16209  * next lowest priority group and repopulates the rr_bmask with only those
16210  * fcf_indexes.
16211  * returns:
16212  * 1=success 0=failure
16213  **/
16214 static int
16215 lpfc_check_next_fcf_pri_level(struct lpfc_hba *phba)
16216 {
16217 	uint16_t next_fcf_pri;
16218 	uint16_t last_index;
16219 	struct lpfc_fcf_pri *fcf_pri;
16220 	int rc;
16221 	int ret = 0;
16222 
16223 	last_index = find_first_bit(phba->fcf.fcf_rr_bmask,
16224 			LPFC_SLI4_FCF_TBL_INDX_MAX);
16225 	lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
16226 			"3060 Last IDX %d\n", last_index);
16227 
16228 	/* Verify the priority list has 2 or more entries */
16229 	spin_lock_irq(&phba->hbalock);
16230 	if (list_empty(&phba->fcf.fcf_pri_list) ||
16231 	    list_is_singular(&phba->fcf.fcf_pri_list)) {
16232 		spin_unlock_irq(&phba->hbalock);
16233 		lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
16234 			"3061 Last IDX %d\n", last_index);
16235 		return 0; /* Empty rr list */
16236 	}
16237 	spin_unlock_irq(&phba->hbalock);
16238 
16239 	next_fcf_pri = 0;
16240 	/*
16241 	 * Clear the rr_bmask and set all of the bits that are at this
16242 	 * priority.
16243 	 */
16244 	memset(phba->fcf.fcf_rr_bmask, 0,
16245 			sizeof(*phba->fcf.fcf_rr_bmask));
16246 	spin_lock_irq(&phba->hbalock);
16247 	list_for_each_entry(fcf_pri, &phba->fcf.fcf_pri_list, list) {
16248 		if (fcf_pri->fcf_rec.flag & LPFC_FCF_FLOGI_FAILED)
16249 			continue;
16250 		/*
16251 		 * the 1st priority that has not FLOGI failed
16252 		 * will be the highest.
16253 		 */
16254 		if (!next_fcf_pri)
16255 			next_fcf_pri = fcf_pri->fcf_rec.priority;
16256 		spin_unlock_irq(&phba->hbalock);
16257 		if (fcf_pri->fcf_rec.priority == next_fcf_pri) {
16258 			rc = lpfc_sli4_fcf_rr_index_set(phba,
16259 						fcf_pri->fcf_rec.fcf_index);
16260 			if (rc)
16261 				return 0;
16262 		}
16263 		spin_lock_irq(&phba->hbalock);
16264 	}
16265 	/*
16266 	 * if next_fcf_pri was not set above and the list is not empty then
16267 	 * we have failed flogis on all of them. So reset flogi failed
16268 	 * and start at the beginning.
16269 	 */
16270 	if (!next_fcf_pri && !list_empty(&phba->fcf.fcf_pri_list)) {
16271 		list_for_each_entry(fcf_pri, &phba->fcf.fcf_pri_list, list) {
16272 			fcf_pri->fcf_rec.flag &= ~LPFC_FCF_FLOGI_FAILED;
16273 			/*
16274 			 * the 1st priority that has not FLOGI failed
16275 			 * will be the highest.
16276 			 */
16277 			if (!next_fcf_pri)
16278 				next_fcf_pri = fcf_pri->fcf_rec.priority;
16279 			spin_unlock_irq(&phba->hbalock);
16280 			if (fcf_pri->fcf_rec.priority == next_fcf_pri) {
16281 				rc = lpfc_sli4_fcf_rr_index_set(phba,
16282 						fcf_pri->fcf_rec.fcf_index);
16283 				if (rc)
16284 					return 0;
16285 			}
16286 			spin_lock_irq(&phba->hbalock);
16287 		}
16288 	} else
16289 		ret = 1;
16290 	spin_unlock_irq(&phba->hbalock);
16291 
16292 	return ret;
16293 }
16294 /**
16295  * lpfc_sli4_fcf_rr_next_index_get - Get next eligible fcf record index
16296  * @phba: pointer to lpfc hba data structure.
16297  *
16298  * This routine is to get the next eligible FCF record index in a round
16299  * robin fashion. If the next eligible FCF record index equals to the
16300  * initial roundrobin FCF record index, LPFC_FCOE_FCF_NEXT_NONE (0xFFFF)
16301  * shall be returned, otherwise, the next eligible FCF record's index
16302  * shall be returned.
16303  **/
16304 uint16_t
16305 lpfc_sli4_fcf_rr_next_index_get(struct lpfc_hba *phba)
16306 {
16307 	uint16_t next_fcf_index;
16308 
16309 initial_priority:
16310 	/* Search start from next bit of currently registered FCF index */
16311 	next_fcf_index = phba->fcf.current_rec.fcf_indx;
16312 
16313 next_priority:
16314 	/* Determine the next fcf index to check */
16315 	next_fcf_index = (next_fcf_index + 1) % LPFC_SLI4_FCF_TBL_INDX_MAX;
16316 	next_fcf_index = find_next_bit(phba->fcf.fcf_rr_bmask,
16317 				       LPFC_SLI4_FCF_TBL_INDX_MAX,
16318 				       next_fcf_index);
16319 
16320 	/* Wrap around condition on phba->fcf.fcf_rr_bmask */
16321 	if (next_fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX) {
16322 		/*
16323 		 * If we have wrapped then we need to clear the bits that
16324 		 * have been tested so that we can detect when we should
16325 		 * change the priority level.
16326 		 */
16327 		next_fcf_index = find_next_bit(phba->fcf.fcf_rr_bmask,
16328 					       LPFC_SLI4_FCF_TBL_INDX_MAX, 0);
16329 	}
16330 
16331 
16332 	/* Check roundrobin failover list empty condition */
16333 	if (next_fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX ||
16334 		next_fcf_index == phba->fcf.current_rec.fcf_indx) {
16335 		/*
16336 		 * If next fcf index is not found check if there are lower
16337 		 * Priority level fcf's in the fcf_priority list.
16338 		 * Set up the rr_bmask with all of the avaiable fcf bits
16339 		 * at that level and continue the selection process.
16340 		 */
16341 		if (lpfc_check_next_fcf_pri_level(phba))
16342 			goto initial_priority;
16343 		lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
16344 				"2844 No roundrobin failover FCF available\n");
16345 		if (next_fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX)
16346 			return LPFC_FCOE_FCF_NEXT_NONE;
16347 		else {
16348 			lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
16349 				"3063 Only FCF available idx %d, flag %x\n",
16350 				next_fcf_index,
16351 			phba->fcf.fcf_pri[next_fcf_index].fcf_rec.flag);
16352 			return next_fcf_index;
16353 		}
16354 	}
16355 
16356 	if (next_fcf_index < LPFC_SLI4_FCF_TBL_INDX_MAX &&
16357 		phba->fcf.fcf_pri[next_fcf_index].fcf_rec.flag &
16358 		LPFC_FCF_FLOGI_FAILED)
16359 		goto next_priority;
16360 
16361 	lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
16362 			"2845 Get next roundrobin failover FCF (x%x)\n",
16363 			next_fcf_index);
16364 
16365 	return next_fcf_index;
16366 }
16367 
16368 /**
16369  * lpfc_sli4_fcf_rr_index_set - Set bmask with eligible fcf record index
16370  * @phba: pointer to lpfc hba data structure.
16371  *
16372  * This routine sets the FCF record index in to the eligible bmask for
16373  * roundrobin failover search. It checks to make sure that the index
16374  * does not go beyond the range of the driver allocated bmask dimension
16375  * before setting the bit.
16376  *
16377  * Returns 0 if the index bit successfully set, otherwise, it returns
16378  * -EINVAL.
16379  **/
16380 int
16381 lpfc_sli4_fcf_rr_index_set(struct lpfc_hba *phba, uint16_t fcf_index)
16382 {
16383 	if (fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX) {
16384 		lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
16385 				"2610 FCF (x%x) reached driver's book "
16386 				"keeping dimension:x%x\n",
16387 				fcf_index, LPFC_SLI4_FCF_TBL_INDX_MAX);
16388 		return -EINVAL;
16389 	}
16390 	/* Set the eligible FCF record index bmask */
16391 	set_bit(fcf_index, phba->fcf.fcf_rr_bmask);
16392 
16393 	lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
16394 			"2790 Set FCF (x%x) to roundrobin FCF failover "
16395 			"bmask\n", fcf_index);
16396 
16397 	return 0;
16398 }
16399 
16400 /**
16401  * lpfc_sli4_fcf_rr_index_clear - Clear bmask from eligible fcf record index
16402  * @phba: pointer to lpfc hba data structure.
16403  *
16404  * This routine clears the FCF record index from the eligible bmask for
16405  * roundrobin failover search. It checks to make sure that the index
16406  * does not go beyond the range of the driver allocated bmask dimension
16407  * before clearing the bit.
16408  **/
16409 void
16410 lpfc_sli4_fcf_rr_index_clear(struct lpfc_hba *phba, uint16_t fcf_index)
16411 {
16412 	struct lpfc_fcf_pri *fcf_pri, *fcf_pri_next;
16413 	if (fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX) {
16414 		lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
16415 				"2762 FCF (x%x) reached driver's book "
16416 				"keeping dimension:x%x\n",
16417 				fcf_index, LPFC_SLI4_FCF_TBL_INDX_MAX);
16418 		return;
16419 	}
16420 	/* Clear the eligible FCF record index bmask */
16421 	spin_lock_irq(&phba->hbalock);
16422 	list_for_each_entry_safe(fcf_pri, fcf_pri_next, &phba->fcf.fcf_pri_list,
16423 				 list) {
16424 		if (fcf_pri->fcf_rec.fcf_index == fcf_index) {
16425 			list_del_init(&fcf_pri->list);
16426 			break;
16427 		}
16428 	}
16429 	spin_unlock_irq(&phba->hbalock);
16430 	clear_bit(fcf_index, phba->fcf.fcf_rr_bmask);
16431 
16432 	lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
16433 			"2791 Clear FCF (x%x) from roundrobin failover "
16434 			"bmask\n", fcf_index);
16435 }
16436 
16437 /**
16438  * lpfc_mbx_cmpl_redisc_fcf_table - completion routine for rediscover FCF table
16439  * @phba: pointer to lpfc hba data structure.
16440  *
16441  * This routine is the completion routine for the rediscover FCF table mailbox
16442  * command. If the mailbox command returned failure, it will try to stop the
16443  * FCF rediscover wait timer.
16444  **/
16445 static void
16446 lpfc_mbx_cmpl_redisc_fcf_table(struct lpfc_hba *phba, LPFC_MBOXQ_t *mbox)
16447 {
16448 	struct lpfc_mbx_redisc_fcf_tbl *redisc_fcf;
16449 	uint32_t shdr_status, shdr_add_status;
16450 
16451 	redisc_fcf = &mbox->u.mqe.un.redisc_fcf_tbl;
16452 
16453 	shdr_status = bf_get(lpfc_mbox_hdr_status,
16454 			     &redisc_fcf->header.cfg_shdr.response);
16455 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
16456 			     &redisc_fcf->header.cfg_shdr.response);
16457 	if (shdr_status || shdr_add_status) {
16458 		lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
16459 				"2746 Requesting for FCF rediscovery failed "
16460 				"status x%x add_status x%x\n",
16461 				shdr_status, shdr_add_status);
16462 		if (phba->fcf.fcf_flag & FCF_ACVL_DISC) {
16463 			spin_lock_irq(&phba->hbalock);
16464 			phba->fcf.fcf_flag &= ~FCF_ACVL_DISC;
16465 			spin_unlock_irq(&phba->hbalock);
16466 			/*
16467 			 * CVL event triggered FCF rediscover request failed,
16468 			 * last resort to re-try current registered FCF entry.
16469 			 */
16470 			lpfc_retry_pport_discovery(phba);
16471 		} else {
16472 			spin_lock_irq(&phba->hbalock);
16473 			phba->fcf.fcf_flag &= ~FCF_DEAD_DISC;
16474 			spin_unlock_irq(&phba->hbalock);
16475 			/*
16476 			 * DEAD FCF event triggered FCF rediscover request
16477 			 * failed, last resort to fail over as a link down
16478 			 * to FCF registration.
16479 			 */
16480 			lpfc_sli4_fcf_dead_failthrough(phba);
16481 		}
16482 	} else {
16483 		lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
16484 				"2775 Start FCF rediscover quiescent timer\n");
16485 		/*
16486 		 * Start FCF rediscovery wait timer for pending FCF
16487 		 * before rescan FCF record table.
16488 		 */
16489 		lpfc_fcf_redisc_wait_start_timer(phba);
16490 	}
16491 
16492 	mempool_free(mbox, phba->mbox_mem_pool);
16493 }
16494 
16495 /**
16496  * lpfc_sli4_redisc_fcf_table - Request to rediscover entire FCF table by port.
16497  * @phba: pointer to lpfc hba data structure.
16498  *
16499  * This routine is invoked to request for rediscovery of the entire FCF table
16500  * by the port.
16501  **/
16502 int
16503 lpfc_sli4_redisc_fcf_table(struct lpfc_hba *phba)
16504 {
16505 	LPFC_MBOXQ_t *mbox;
16506 	struct lpfc_mbx_redisc_fcf_tbl *redisc_fcf;
16507 	int rc, length;
16508 
16509 	/* Cancel retry delay timers to all vports before FCF rediscover */
16510 	lpfc_cancel_all_vport_retry_delay_timer(phba);
16511 
16512 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
16513 	if (!mbox) {
16514 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
16515 				"2745 Failed to allocate mbox for "
16516 				"requesting FCF rediscover.\n");
16517 		return -ENOMEM;
16518 	}
16519 
16520 	length = (sizeof(struct lpfc_mbx_redisc_fcf_tbl) -
16521 		  sizeof(struct lpfc_sli4_cfg_mhdr));
16522 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
16523 			 LPFC_MBOX_OPCODE_FCOE_REDISCOVER_FCF,
16524 			 length, LPFC_SLI4_MBX_EMBED);
16525 
16526 	redisc_fcf = &mbox->u.mqe.un.redisc_fcf_tbl;
16527 	/* Set count to 0 for invalidating the entire FCF database */
16528 	bf_set(lpfc_mbx_redisc_fcf_count, redisc_fcf, 0);
16529 
16530 	/* Issue the mailbox command asynchronously */
16531 	mbox->vport = phba->pport;
16532 	mbox->mbox_cmpl = lpfc_mbx_cmpl_redisc_fcf_table;
16533 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
16534 
16535 	if (rc == MBX_NOT_FINISHED) {
16536 		mempool_free(mbox, phba->mbox_mem_pool);
16537 		return -EIO;
16538 	}
16539 	return 0;
16540 }
16541 
16542 /**
16543  * lpfc_sli4_fcf_dead_failthrough - Failthrough routine to fcf dead event
16544  * @phba: pointer to lpfc hba data structure.
16545  *
16546  * This function is the failover routine as a last resort to the FCF DEAD
16547  * event when driver failed to perform fast FCF failover.
16548  **/
16549 void
16550 lpfc_sli4_fcf_dead_failthrough(struct lpfc_hba *phba)
16551 {
16552 	uint32_t link_state;
16553 
16554 	/*
16555 	 * Last resort as FCF DEAD event failover will treat this as
16556 	 * a link down, but save the link state because we don't want
16557 	 * it to be changed to Link Down unless it is already down.
16558 	 */
16559 	link_state = phba->link_state;
16560 	lpfc_linkdown(phba);
16561 	phba->link_state = link_state;
16562 
16563 	/* Unregister FCF if no devices connected to it */
16564 	lpfc_unregister_unused_fcf(phba);
16565 }
16566 
16567 /**
16568  * lpfc_sli_get_config_region23 - Get sli3 port region 23 data.
16569  * @phba: pointer to lpfc hba data structure.
16570  * @rgn23_data: pointer to configure region 23 data.
16571  *
16572  * This function gets SLI3 port configure region 23 data through memory dump
16573  * mailbox command. When it successfully retrieves data, the size of the data
16574  * will be returned, otherwise, 0 will be returned.
16575  **/
16576 static uint32_t
16577 lpfc_sli_get_config_region23(struct lpfc_hba *phba, char *rgn23_data)
16578 {
16579 	LPFC_MBOXQ_t *pmb = NULL;
16580 	MAILBOX_t *mb;
16581 	uint32_t offset = 0;
16582 	int rc;
16583 
16584 	if (!rgn23_data)
16585 		return 0;
16586 
16587 	pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
16588 	if (!pmb) {
16589 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
16590 				"2600 failed to allocate mailbox memory\n");
16591 		return 0;
16592 	}
16593 	mb = &pmb->u.mb;
16594 
16595 	do {
16596 		lpfc_dump_mem(phba, pmb, offset, DMP_REGION_23);
16597 		rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
16598 
16599 		if (rc != MBX_SUCCESS) {
16600 			lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
16601 					"2601 failed to read config "
16602 					"region 23, rc 0x%x Status 0x%x\n",
16603 					rc, mb->mbxStatus);
16604 			mb->un.varDmp.word_cnt = 0;
16605 		}
16606 		/*
16607 		 * dump mem may return a zero when finished or we got a
16608 		 * mailbox error, either way we are done.
16609 		 */
16610 		if (mb->un.varDmp.word_cnt == 0)
16611 			break;
16612 		if (mb->un.varDmp.word_cnt > DMP_RGN23_SIZE - offset)
16613 			mb->un.varDmp.word_cnt = DMP_RGN23_SIZE - offset;
16614 
16615 		lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,
16616 				       rgn23_data + offset,
16617 				       mb->un.varDmp.word_cnt);
16618 		offset += mb->un.varDmp.word_cnt;
16619 	} while (mb->un.varDmp.word_cnt && offset < DMP_RGN23_SIZE);
16620 
16621 	mempool_free(pmb, phba->mbox_mem_pool);
16622 	return offset;
16623 }
16624 
16625 /**
16626  * lpfc_sli4_get_config_region23 - Get sli4 port region 23 data.
16627  * @phba: pointer to lpfc hba data structure.
16628  * @rgn23_data: pointer to configure region 23 data.
16629  *
16630  * This function gets SLI4 port configure region 23 data through memory dump
16631  * mailbox command. When it successfully retrieves data, the size of the data
16632  * will be returned, otherwise, 0 will be returned.
16633  **/
16634 static uint32_t
16635 lpfc_sli4_get_config_region23(struct lpfc_hba *phba, char *rgn23_data)
16636 {
16637 	LPFC_MBOXQ_t *mboxq = NULL;
16638 	struct lpfc_dmabuf *mp = NULL;
16639 	struct lpfc_mqe *mqe;
16640 	uint32_t data_length = 0;
16641 	int rc;
16642 
16643 	if (!rgn23_data)
16644 		return 0;
16645 
16646 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
16647 	if (!mboxq) {
16648 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
16649 				"3105 failed to allocate mailbox memory\n");
16650 		return 0;
16651 	}
16652 
16653 	if (lpfc_sli4_dump_cfg_rg23(phba, mboxq))
16654 		goto out;
16655 	mqe = &mboxq->u.mqe;
16656 	mp = (struct lpfc_dmabuf *) mboxq->context1;
16657 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
16658 	if (rc)
16659 		goto out;
16660 	data_length = mqe->un.mb_words[5];
16661 	if (data_length == 0)
16662 		goto out;
16663 	if (data_length > DMP_RGN23_SIZE) {
16664 		data_length = 0;
16665 		goto out;
16666 	}
16667 	lpfc_sli_pcimem_bcopy((char *)mp->virt, rgn23_data, data_length);
16668 out:
16669 	mempool_free(mboxq, phba->mbox_mem_pool);
16670 	if (mp) {
16671 		lpfc_mbuf_free(phba, mp->virt, mp->phys);
16672 		kfree(mp);
16673 	}
16674 	return data_length;
16675 }
16676 
16677 /**
16678  * lpfc_sli_read_link_ste - Read region 23 to decide if link is disabled.
16679  * @phba: pointer to lpfc hba data structure.
16680  *
16681  * This function read region 23 and parse TLV for port status to
16682  * decide if the user disaled the port. If the TLV indicates the
16683  * port is disabled, the hba_flag is set accordingly.
16684  **/
16685 void
16686 lpfc_sli_read_link_ste(struct lpfc_hba *phba)
16687 {
16688 	uint8_t *rgn23_data = NULL;
16689 	uint32_t if_type, data_size, sub_tlv_len, tlv_offset;
16690 	uint32_t offset = 0;
16691 
16692 	/* Get adapter Region 23 data */
16693 	rgn23_data = kzalloc(DMP_RGN23_SIZE, GFP_KERNEL);
16694 	if (!rgn23_data)
16695 		goto out;
16696 
16697 	if (phba->sli_rev < LPFC_SLI_REV4)
16698 		data_size = lpfc_sli_get_config_region23(phba, rgn23_data);
16699 	else {
16700 		if_type = bf_get(lpfc_sli_intf_if_type,
16701 				 &phba->sli4_hba.sli_intf);
16702 		if (if_type == LPFC_SLI_INTF_IF_TYPE_0)
16703 			goto out;
16704 		data_size = lpfc_sli4_get_config_region23(phba, rgn23_data);
16705 	}
16706 
16707 	if (!data_size)
16708 		goto out;
16709 
16710 	/* Check the region signature first */
16711 	if (memcmp(&rgn23_data[offset], LPFC_REGION23_SIGNATURE, 4)) {
16712 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
16713 			"2619 Config region 23 has bad signature\n");
16714 			goto out;
16715 	}
16716 	offset += 4;
16717 
16718 	/* Check the data structure version */
16719 	if (rgn23_data[offset] != LPFC_REGION23_VERSION) {
16720 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
16721 			"2620 Config region 23 has bad version\n");
16722 		goto out;
16723 	}
16724 	offset += 4;
16725 
16726 	/* Parse TLV entries in the region */
16727 	while (offset < data_size) {
16728 		if (rgn23_data[offset] == LPFC_REGION23_LAST_REC)
16729 			break;
16730 		/*
16731 		 * If the TLV is not driver specific TLV or driver id is
16732 		 * not linux driver id, skip the record.
16733 		 */
16734 		if ((rgn23_data[offset] != DRIVER_SPECIFIC_TYPE) ||
16735 		    (rgn23_data[offset + 2] != LINUX_DRIVER_ID) ||
16736 		    (rgn23_data[offset + 3] != 0)) {
16737 			offset += rgn23_data[offset + 1] * 4 + 4;
16738 			continue;
16739 		}
16740 
16741 		/* Driver found a driver specific TLV in the config region */
16742 		sub_tlv_len = rgn23_data[offset + 1] * 4;
16743 		offset += 4;
16744 		tlv_offset = 0;
16745 
16746 		/*
16747 		 * Search for configured port state sub-TLV.
16748 		 */
16749 		while ((offset < data_size) &&
16750 			(tlv_offset < sub_tlv_len)) {
16751 			if (rgn23_data[offset] == LPFC_REGION23_LAST_REC) {
16752 				offset += 4;
16753 				tlv_offset += 4;
16754 				break;
16755 			}
16756 			if (rgn23_data[offset] != PORT_STE_TYPE) {
16757 				offset += rgn23_data[offset + 1] * 4 + 4;
16758 				tlv_offset += rgn23_data[offset + 1] * 4 + 4;
16759 				continue;
16760 			}
16761 
16762 			/* This HBA contains PORT_STE configured */
16763 			if (!rgn23_data[offset + 2])
16764 				phba->hba_flag |= LINK_DISABLED;
16765 
16766 			goto out;
16767 		}
16768 	}
16769 
16770 out:
16771 	kfree(rgn23_data);
16772 	return;
16773 }
16774 
16775 /**
16776  * lpfc_wr_object - write an object to the firmware
16777  * @phba: HBA structure that indicates port to create a queue on.
16778  * @dmabuf_list: list of dmabufs to write to the port.
16779  * @size: the total byte value of the objects to write to the port.
16780  * @offset: the current offset to be used to start the transfer.
16781  *
16782  * This routine will create a wr_object mailbox command to send to the port.
16783  * the mailbox command will be constructed using the dma buffers described in
16784  * @dmabuf_list to create a list of BDEs. This routine will fill in as many
16785  * BDEs that the imbedded mailbox can support. The @offset variable will be
16786  * used to indicate the starting offset of the transfer and will also return
16787  * the offset after the write object mailbox has completed. @size is used to
16788  * determine the end of the object and whether the eof bit should be set.
16789  *
16790  * Return 0 is successful and offset will contain the the new offset to use
16791  * for the next write.
16792  * Return negative value for error cases.
16793  **/
16794 int
16795 lpfc_wr_object(struct lpfc_hba *phba, struct list_head *dmabuf_list,
16796 	       uint32_t size, uint32_t *offset)
16797 {
16798 	struct lpfc_mbx_wr_object *wr_object;
16799 	LPFC_MBOXQ_t *mbox;
16800 	int rc = 0, i = 0;
16801 	uint32_t shdr_status, shdr_add_status;
16802 	uint32_t mbox_tmo;
16803 	union lpfc_sli4_cfg_shdr *shdr;
16804 	struct lpfc_dmabuf *dmabuf;
16805 	uint32_t written = 0;
16806 
16807 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
16808 	if (!mbox)
16809 		return -ENOMEM;
16810 
16811 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
16812 			LPFC_MBOX_OPCODE_WRITE_OBJECT,
16813 			sizeof(struct lpfc_mbx_wr_object) -
16814 			sizeof(struct lpfc_sli4_cfg_mhdr), LPFC_SLI4_MBX_EMBED);
16815 
16816 	wr_object = (struct lpfc_mbx_wr_object *)&mbox->u.mqe.un.wr_object;
16817 	wr_object->u.request.write_offset = *offset;
16818 	sprintf((uint8_t *)wr_object->u.request.object_name, "/");
16819 	wr_object->u.request.object_name[0] =
16820 		cpu_to_le32(wr_object->u.request.object_name[0]);
16821 	bf_set(lpfc_wr_object_eof, &wr_object->u.request, 0);
16822 	list_for_each_entry(dmabuf, dmabuf_list, list) {
16823 		if (i >= LPFC_MBX_WR_CONFIG_MAX_BDE || written >= size)
16824 			break;
16825 		wr_object->u.request.bde[i].addrLow = putPaddrLow(dmabuf->phys);
16826 		wr_object->u.request.bde[i].addrHigh =
16827 			putPaddrHigh(dmabuf->phys);
16828 		if (written + SLI4_PAGE_SIZE >= size) {
16829 			wr_object->u.request.bde[i].tus.f.bdeSize =
16830 				(size - written);
16831 			written += (size - written);
16832 			bf_set(lpfc_wr_object_eof, &wr_object->u.request, 1);
16833 		} else {
16834 			wr_object->u.request.bde[i].tus.f.bdeSize =
16835 				SLI4_PAGE_SIZE;
16836 			written += SLI4_PAGE_SIZE;
16837 		}
16838 		i++;
16839 	}
16840 	wr_object->u.request.bde_count = i;
16841 	bf_set(lpfc_wr_object_write_length, &wr_object->u.request, written);
16842 	if (!phba->sli4_hba.intr_enable)
16843 		rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
16844 	else {
16845 		mbox_tmo = lpfc_mbox_tmo_val(phba, mbox);
16846 		rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
16847 	}
16848 	/* The IOCTL status is embedded in the mailbox subheader. */
16849 	shdr = (union lpfc_sli4_cfg_shdr *) &wr_object->header.cfg_shdr;
16850 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
16851 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
16852 	if (rc != MBX_TIMEOUT)
16853 		mempool_free(mbox, phba->mbox_mem_pool);
16854 	if (shdr_status || shdr_add_status || rc) {
16855 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
16856 				"3025 Write Object mailbox failed with "
16857 				"status x%x add_status x%x, mbx status x%x\n",
16858 				shdr_status, shdr_add_status, rc);
16859 		rc = -ENXIO;
16860 	} else
16861 		*offset += wr_object->u.response.actual_write_length;
16862 	return rc;
16863 }
16864 
16865 /**
16866  * lpfc_cleanup_pending_mbox - Free up vport discovery mailbox commands.
16867  * @vport: pointer to vport data structure.
16868  *
16869  * This function iterate through the mailboxq and clean up all REG_LOGIN
16870  * and REG_VPI mailbox commands associated with the vport. This function
16871  * is called when driver want to restart discovery of the vport due to
16872  * a Clear Virtual Link event.
16873  **/
16874 void
16875 lpfc_cleanup_pending_mbox(struct lpfc_vport *vport)
16876 {
16877 	struct lpfc_hba *phba = vport->phba;
16878 	LPFC_MBOXQ_t *mb, *nextmb;
16879 	struct lpfc_dmabuf *mp;
16880 	struct lpfc_nodelist *ndlp;
16881 	struct lpfc_nodelist *act_mbx_ndlp = NULL;
16882 	struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
16883 	LIST_HEAD(mbox_cmd_list);
16884 	uint8_t restart_loop;
16885 
16886 	/* Clean up internally queued mailbox commands with the vport */
16887 	spin_lock_irq(&phba->hbalock);
16888 	list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {
16889 		if (mb->vport != vport)
16890 			continue;
16891 
16892 		if ((mb->u.mb.mbxCommand != MBX_REG_LOGIN64) &&
16893 			(mb->u.mb.mbxCommand != MBX_REG_VPI))
16894 			continue;
16895 
16896 		list_del(&mb->list);
16897 		list_add_tail(&mb->list, &mbox_cmd_list);
16898 	}
16899 	/* Clean up active mailbox command with the vport */
16900 	mb = phba->sli.mbox_active;
16901 	if (mb && (mb->vport == vport)) {
16902 		if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) ||
16903 			(mb->u.mb.mbxCommand == MBX_REG_VPI))
16904 			mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
16905 		if (mb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
16906 			act_mbx_ndlp = (struct lpfc_nodelist *)mb->context2;
16907 			/* Put reference count for delayed processing */
16908 			act_mbx_ndlp = lpfc_nlp_get(act_mbx_ndlp);
16909 			/* Unregister the RPI when mailbox complete */
16910 			mb->mbox_flag |= LPFC_MBX_IMED_UNREG;
16911 		}
16912 	}
16913 	/* Cleanup any mailbox completions which are not yet processed */
16914 	do {
16915 		restart_loop = 0;
16916 		list_for_each_entry(mb, &phba->sli.mboxq_cmpl, list) {
16917 			/*
16918 			 * If this mailox is already processed or it is
16919 			 * for another vport ignore it.
16920 			 */
16921 			if ((mb->vport != vport) ||
16922 				(mb->mbox_flag & LPFC_MBX_IMED_UNREG))
16923 				continue;
16924 
16925 			if ((mb->u.mb.mbxCommand != MBX_REG_LOGIN64) &&
16926 				(mb->u.mb.mbxCommand != MBX_REG_VPI))
16927 				continue;
16928 
16929 			mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
16930 			if (mb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
16931 				ndlp = (struct lpfc_nodelist *)mb->context2;
16932 				/* Unregister the RPI when mailbox complete */
16933 				mb->mbox_flag |= LPFC_MBX_IMED_UNREG;
16934 				restart_loop = 1;
16935 				spin_unlock_irq(&phba->hbalock);
16936 				spin_lock(shost->host_lock);
16937 				ndlp->nlp_flag &= ~NLP_IGNR_REG_CMPL;
16938 				spin_unlock(shost->host_lock);
16939 				spin_lock_irq(&phba->hbalock);
16940 				break;
16941 			}
16942 		}
16943 	} while (restart_loop);
16944 
16945 	spin_unlock_irq(&phba->hbalock);
16946 
16947 	/* Release the cleaned-up mailbox commands */
16948 	while (!list_empty(&mbox_cmd_list)) {
16949 		list_remove_head(&mbox_cmd_list, mb, LPFC_MBOXQ_t, list);
16950 		if (mb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
16951 			mp = (struct lpfc_dmabuf *) (mb->context1);
16952 			if (mp) {
16953 				__lpfc_mbuf_free(phba, mp->virt, mp->phys);
16954 				kfree(mp);
16955 			}
16956 			ndlp = (struct lpfc_nodelist *) mb->context2;
16957 			mb->context2 = NULL;
16958 			if (ndlp) {
16959 				spin_lock(shost->host_lock);
16960 				ndlp->nlp_flag &= ~NLP_IGNR_REG_CMPL;
16961 				spin_unlock(shost->host_lock);
16962 				lpfc_nlp_put(ndlp);
16963 			}
16964 		}
16965 		mempool_free(mb, phba->mbox_mem_pool);
16966 	}
16967 
16968 	/* Release the ndlp with the cleaned-up active mailbox command */
16969 	if (act_mbx_ndlp) {
16970 		spin_lock(shost->host_lock);
16971 		act_mbx_ndlp->nlp_flag &= ~NLP_IGNR_REG_CMPL;
16972 		spin_unlock(shost->host_lock);
16973 		lpfc_nlp_put(act_mbx_ndlp);
16974 	}
16975 }
16976 
16977 /**
16978  * lpfc_drain_txq - Drain the txq
16979  * @phba: Pointer to HBA context object.
16980  *
16981  * This function attempt to submit IOCBs on the txq
16982  * to the adapter.  For SLI4 adapters, the txq contains
16983  * ELS IOCBs that have been deferred because the there
16984  * are no SGLs.  This congestion can occur with large
16985  * vport counts during node discovery.
16986  **/
16987 
16988 uint32_t
16989 lpfc_drain_txq(struct lpfc_hba *phba)
16990 {
16991 	LIST_HEAD(completions);
16992 	struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
16993 	struct lpfc_iocbq *piocbq = NULL;
16994 	unsigned long iflags = 0;
16995 	char *fail_msg = NULL;
16996 	struct lpfc_sglq *sglq;
16997 	union lpfc_wqe wqe;
16998 	uint32_t txq_cnt = 0;
16999 
17000 	spin_lock_irqsave(&pring->ring_lock, iflags);
17001 	list_for_each_entry(piocbq, &pring->txq, list) {
17002 		txq_cnt++;
17003 	}
17004 
17005 	if (txq_cnt > pring->txq_max)
17006 		pring->txq_max = txq_cnt;
17007 
17008 	spin_unlock_irqrestore(&pring->ring_lock, iflags);
17009 
17010 	while (!list_empty(&pring->txq)) {
17011 		spin_lock_irqsave(&pring->ring_lock, iflags);
17012 
17013 		piocbq = lpfc_sli_ringtx_get(phba, pring);
17014 		if (!piocbq) {
17015 			spin_unlock_irqrestore(&pring->ring_lock, iflags);
17016 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
17017 				"2823 txq empty and txq_cnt is %d\n ",
17018 				txq_cnt);
17019 			break;
17020 		}
17021 		sglq = __lpfc_sli_get_sglq(phba, piocbq);
17022 		if (!sglq) {
17023 			__lpfc_sli_ringtx_put(phba, pring, piocbq);
17024 			spin_unlock_irqrestore(&pring->ring_lock, iflags);
17025 			break;
17026 		}
17027 		txq_cnt--;
17028 
17029 		/* The xri and iocb resources secured,
17030 		 * attempt to issue request
17031 		 */
17032 		piocbq->sli4_lxritag = sglq->sli4_lxritag;
17033 		piocbq->sli4_xritag = sglq->sli4_xritag;
17034 		if (NO_XRI == lpfc_sli4_bpl2sgl(phba, piocbq, sglq))
17035 			fail_msg = "to convert bpl to sgl";
17036 		else if (lpfc_sli4_iocb2wqe(phba, piocbq, &wqe))
17037 			fail_msg = "to convert iocb to wqe";
17038 		else if (lpfc_sli4_wq_put(phba->sli4_hba.els_wq, &wqe))
17039 			fail_msg = " - Wq is full";
17040 		else
17041 			lpfc_sli_ringtxcmpl_put(phba, pring, piocbq);
17042 
17043 		if (fail_msg) {
17044 			/* Failed means we can't issue and need to cancel */
17045 			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
17046 					"2822 IOCB failed %s iotag 0x%x "
17047 					"xri 0x%x\n",
17048 					fail_msg,
17049 					piocbq->iotag, piocbq->sli4_xritag);
17050 			list_add_tail(&piocbq->list, &completions);
17051 		}
17052 		spin_unlock_irqrestore(&pring->ring_lock, iflags);
17053 	}
17054 
17055 	/* Cancel all the IOCBs that cannot be issued */
17056 	lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
17057 				IOERR_SLI_ABORTED);
17058 
17059 	return txq_cnt;
17060 }
17061