Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jwessel...
[pandora-kernel.git] / drivers / scsi / lpfc / lpfc_sli.c
1 /*******************************************************************
2  * This file is part of the Emulex Linux Device Driver for         *
3  * Fibre Channel Host Bus Adapters.                                *
4  * Copyright (C) 2004-2009 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 IOCB_t *
69 lpfc_get_iocb_from_iocbq(struct lpfc_iocbq *iocbq)
70 {
71         return &iocbq->iocb;
72 }
73
74 /**
75  * lpfc_sli4_wq_put - Put a Work Queue Entry on an Work Queue
76  * @q: The Work Queue to operate on.
77  * @wqe: The work Queue Entry to put on the Work queue.
78  *
79  * This routine will copy the contents of @wqe to the next available entry on
80  * the @q. This function will then ring the Work Queue Doorbell to signal the
81  * HBA to start processing the Work Queue Entry. This function returns 0 if
82  * successful. If no entries are available on @q then this function will return
83  * -ENOMEM.
84  * The caller is expected to hold the hbalock when calling this routine.
85  **/
86 static uint32_t
87 lpfc_sli4_wq_put(struct lpfc_queue *q, union lpfc_wqe *wqe)
88 {
89         union lpfc_wqe *temp_wqe = q->qe[q->host_index].wqe;
90         struct lpfc_register doorbell;
91         uint32_t host_index;
92
93         /* If the host has not yet processed the next entry then we are done */
94         if (((q->host_index + 1) % q->entry_count) == q->hba_index)
95                 return -ENOMEM;
96         /* set consumption flag every once in a while */
97         if (!((q->host_index + 1) % LPFC_RELEASE_NOTIFICATION_INTERVAL))
98                 bf_set(wqe_wqec, &wqe->generic.wqe_com, 1);
99         if (q->phba->sli3_options & LPFC_SLI4_PHWQ_ENABLED)
100                 bf_set(wqe_wqid, &wqe->generic.wqe_com, q->queue_id);
101         lpfc_sli_pcimem_bcopy(wqe, temp_wqe, q->entry_size);
102
103         /* Update the host index before invoking device */
104         host_index = q->host_index;
105         q->host_index = ((q->host_index + 1) % q->entry_count);
106
107         /* Ring Doorbell */
108         doorbell.word0 = 0;
109         bf_set(lpfc_wq_doorbell_num_posted, &doorbell, 1);
110         bf_set(lpfc_wq_doorbell_index, &doorbell, host_index);
111         bf_set(lpfc_wq_doorbell_id, &doorbell, q->queue_id);
112         writel(doorbell.word0, q->phba->sli4_hba.WQDBregaddr);
113         readl(q->phba->sli4_hba.WQDBregaddr); /* Flush */
114
115         return 0;
116 }
117
118 /**
119  * lpfc_sli4_wq_release - Updates internal hba index for WQ
120  * @q: The Work Queue to operate on.
121  * @index: The index to advance the hba index to.
122  *
123  * This routine will update the HBA index of a queue to reflect consumption of
124  * Work Queue Entries by the HBA. When the HBA indicates that it has consumed
125  * an entry the host calls this function to update the queue's internal
126  * pointers. This routine returns the number of entries that were consumed by
127  * the HBA.
128  **/
129 static uint32_t
130 lpfc_sli4_wq_release(struct lpfc_queue *q, uint32_t index)
131 {
132         uint32_t released = 0;
133
134         if (q->hba_index == index)
135                 return 0;
136         do {
137                 q->hba_index = ((q->hba_index + 1) % q->entry_count);
138                 released++;
139         } while (q->hba_index != index);
140         return released;
141 }
142
143 /**
144  * lpfc_sli4_mq_put - Put a Mailbox Queue Entry on an Mailbox Queue
145  * @q: The Mailbox Queue to operate on.
146  * @wqe: The Mailbox Queue Entry to put on the Work queue.
147  *
148  * This routine will copy the contents of @mqe to the next available entry on
149  * the @q. This function will then ring the Work Queue Doorbell to signal the
150  * HBA to start processing the Work Queue Entry. This function returns 0 if
151  * successful. If no entries are available on @q then this function will return
152  * -ENOMEM.
153  * The caller is expected to hold the hbalock when calling this routine.
154  **/
155 static uint32_t
156 lpfc_sli4_mq_put(struct lpfc_queue *q, struct lpfc_mqe *mqe)
157 {
158         struct lpfc_mqe *temp_mqe = q->qe[q->host_index].mqe;
159         struct lpfc_register doorbell;
160         uint32_t host_index;
161
162         /* If the host has not yet processed the next entry then we are done */
163         if (((q->host_index + 1) % q->entry_count) == q->hba_index)
164                 return -ENOMEM;
165         lpfc_sli_pcimem_bcopy(mqe, temp_mqe, q->entry_size);
166         /* Save off the mailbox pointer for completion */
167         q->phba->mbox = (MAILBOX_t *)temp_mqe;
168
169         /* Update the host index before invoking device */
170         host_index = q->host_index;
171         q->host_index = ((q->host_index + 1) % q->entry_count);
172
173         /* Ring Doorbell */
174         doorbell.word0 = 0;
175         bf_set(lpfc_mq_doorbell_num_posted, &doorbell, 1);
176         bf_set(lpfc_mq_doorbell_id, &doorbell, q->queue_id);
177         writel(doorbell.word0, q->phba->sli4_hba.MQDBregaddr);
178         readl(q->phba->sli4_hba.MQDBregaddr); /* Flush */
179         return 0;
180 }
181
182 /**
183  * lpfc_sli4_mq_release - Updates internal hba index for MQ
184  * @q: The Mailbox Queue to operate on.
185  *
186  * This routine will update the HBA index of a queue to reflect consumption of
187  * a Mailbox Queue Entry by the HBA. When the HBA indicates that it has consumed
188  * an entry the host calls this function to update the queue's internal
189  * pointers. This routine returns the number of entries that were consumed by
190  * the HBA.
191  **/
192 static uint32_t
193 lpfc_sli4_mq_release(struct lpfc_queue *q)
194 {
195         /* Clear the mailbox pointer for completion */
196         q->phba->mbox = NULL;
197         q->hba_index = ((q->hba_index + 1) % q->entry_count);
198         return 1;
199 }
200
201 /**
202  * lpfc_sli4_eq_get - Gets the next valid EQE from a EQ
203  * @q: The Event Queue to get the first valid EQE from
204  *
205  * This routine will get the first valid Event Queue Entry from @q, update
206  * the queue's internal hba index, and return the EQE. If no valid EQEs are in
207  * the Queue (no more work to do), or the Queue is full of EQEs that have been
208  * processed, but not popped back to the HBA then this routine will return NULL.
209  **/
210 static struct lpfc_eqe *
211 lpfc_sli4_eq_get(struct lpfc_queue *q)
212 {
213         struct lpfc_eqe *eqe = q->qe[q->hba_index].eqe;
214
215         /* If the next EQE is not valid then we are done */
216         if (!bf_get_le32(lpfc_eqe_valid, eqe))
217                 return NULL;
218         /* If the host has not yet processed the next entry then we are done */
219         if (((q->hba_index + 1) % q->entry_count) == q->host_index)
220                 return NULL;
221
222         q->hba_index = ((q->hba_index + 1) % q->entry_count);
223         return eqe;
224 }
225
226 /**
227  * lpfc_sli4_eq_release - Indicates the host has finished processing an EQ
228  * @q: The Event Queue that the host has completed processing for.
229  * @arm: Indicates whether the host wants to arms this CQ.
230  *
231  * This routine will mark all Event Queue Entries on @q, from the last
232  * known completed entry to the last entry that was processed, as completed
233  * by clearing the valid bit for each completion queue entry. Then it will
234  * notify the HBA, by ringing the doorbell, that the EQEs have been processed.
235  * The internal host index in the @q will be updated by this routine to indicate
236  * that the host has finished processing the entries. The @arm parameter
237  * indicates that the queue should be rearmed when ringing the doorbell.
238  *
239  * This function will return the number of EQEs that were popped.
240  **/
241 uint32_t
242 lpfc_sli4_eq_release(struct lpfc_queue *q, bool arm)
243 {
244         uint32_t released = 0;
245         struct lpfc_eqe *temp_eqe;
246         struct lpfc_register doorbell;
247
248         /* while there are valid entries */
249         while (q->hba_index != q->host_index) {
250                 temp_eqe = q->qe[q->host_index].eqe;
251                 bf_set_le32(lpfc_eqe_valid, temp_eqe, 0);
252                 released++;
253                 q->host_index = ((q->host_index + 1) % q->entry_count);
254         }
255         if (unlikely(released == 0 && !arm))
256                 return 0;
257
258         /* ring doorbell for number popped */
259         doorbell.word0 = 0;
260         if (arm) {
261                 bf_set(lpfc_eqcq_doorbell_arm, &doorbell, 1);
262                 bf_set(lpfc_eqcq_doorbell_eqci, &doorbell, 1);
263         }
264         bf_set(lpfc_eqcq_doorbell_num_released, &doorbell, released);
265         bf_set(lpfc_eqcq_doorbell_qt, &doorbell, LPFC_QUEUE_TYPE_EVENT);
266         bf_set(lpfc_eqcq_doorbell_eqid, &doorbell, q->queue_id);
267         writel(doorbell.word0, q->phba->sli4_hba.EQCQDBregaddr);
268         /* PCI read to flush PCI pipeline on re-arming for INTx mode */
269         if ((q->phba->intr_type == INTx) && (arm == LPFC_QUEUE_REARM))
270                 readl(q->phba->sli4_hba.EQCQDBregaddr);
271         return released;
272 }
273
274 /**
275  * lpfc_sli4_cq_get - Gets the next valid CQE from a CQ
276  * @q: The Completion Queue to get the first valid CQE from
277  *
278  * This routine will get the first valid Completion Queue Entry from @q, update
279  * the queue's internal hba index, and return the CQE. If no valid CQEs are in
280  * the Queue (no more work to do), or the Queue is full of CQEs that have been
281  * processed, but not popped back to the HBA then this routine will return NULL.
282  **/
283 static struct lpfc_cqe *
284 lpfc_sli4_cq_get(struct lpfc_queue *q)
285 {
286         struct lpfc_cqe *cqe;
287
288         /* If the next CQE is not valid then we are done */
289         if (!bf_get_le32(lpfc_cqe_valid, q->qe[q->hba_index].cqe))
290                 return NULL;
291         /* If the host has not yet processed the next entry then we are done */
292         if (((q->hba_index + 1) % q->entry_count) == q->host_index)
293                 return NULL;
294
295         cqe = q->qe[q->hba_index].cqe;
296         q->hba_index = ((q->hba_index + 1) % q->entry_count);
297         return cqe;
298 }
299
300 /**
301  * lpfc_sli4_cq_release - Indicates the host has finished processing a CQ
302  * @q: The Completion Queue that the host has completed processing for.
303  * @arm: Indicates whether the host wants to arms this CQ.
304  *
305  * This routine will mark all Completion queue entries on @q, from the last
306  * known completed entry to the last entry that was processed, as completed
307  * by clearing the valid bit for each completion queue entry. Then it will
308  * notify the HBA, by ringing the doorbell, that the CQEs have been processed.
309  * The internal host index in the @q will be updated by this routine to indicate
310  * that the host has finished processing the entries. The @arm parameter
311  * indicates that the queue should be rearmed when ringing the doorbell.
312  *
313  * This function will return the number of CQEs that were released.
314  **/
315 uint32_t
316 lpfc_sli4_cq_release(struct lpfc_queue *q, bool arm)
317 {
318         uint32_t released = 0;
319         struct lpfc_cqe *temp_qe;
320         struct lpfc_register doorbell;
321
322         /* while there are valid entries */
323         while (q->hba_index != q->host_index) {
324                 temp_qe = q->qe[q->host_index].cqe;
325                 bf_set_le32(lpfc_cqe_valid, temp_qe, 0);
326                 released++;
327                 q->host_index = ((q->host_index + 1) % q->entry_count);
328         }
329         if (unlikely(released == 0 && !arm))
330                 return 0;
331
332         /* ring doorbell for number popped */
333         doorbell.word0 = 0;
334         if (arm)
335                 bf_set(lpfc_eqcq_doorbell_arm, &doorbell, 1);
336         bf_set(lpfc_eqcq_doorbell_num_released, &doorbell, released);
337         bf_set(lpfc_eqcq_doorbell_qt, &doorbell, LPFC_QUEUE_TYPE_COMPLETION);
338         bf_set(lpfc_eqcq_doorbell_cqid, &doorbell, q->queue_id);
339         writel(doorbell.word0, q->phba->sli4_hba.EQCQDBregaddr);
340         return released;
341 }
342
343 /**
344  * lpfc_sli4_rq_put - Put a Receive Buffer Queue Entry on a Receive Queue
345  * @q: The Header Receive Queue to operate on.
346  * @wqe: The Receive Queue Entry to put on the Receive queue.
347  *
348  * This routine will copy the contents of @wqe to the next available entry on
349  * the @q. This function will then ring the Receive Queue Doorbell to signal the
350  * HBA to start processing the Receive Queue Entry. This function returns the
351  * index that the rqe was copied to if successful. If no entries are available
352  * on @q then this function will return -ENOMEM.
353  * The caller is expected to hold the hbalock when calling this routine.
354  **/
355 static int
356 lpfc_sli4_rq_put(struct lpfc_queue *hq, struct lpfc_queue *dq,
357                  struct lpfc_rqe *hrqe, struct lpfc_rqe *drqe)
358 {
359         struct lpfc_rqe *temp_hrqe = hq->qe[hq->host_index].rqe;
360         struct lpfc_rqe *temp_drqe = dq->qe[dq->host_index].rqe;
361         struct lpfc_register doorbell;
362         int put_index = hq->host_index;
363
364         if (hq->type != LPFC_HRQ || dq->type != LPFC_DRQ)
365                 return -EINVAL;
366         if (hq->host_index != dq->host_index)
367                 return -EINVAL;
368         /* If the host has not yet processed the next entry then we are done */
369         if (((hq->host_index + 1) % hq->entry_count) == hq->hba_index)
370                 return -EBUSY;
371         lpfc_sli_pcimem_bcopy(hrqe, temp_hrqe, hq->entry_size);
372         lpfc_sli_pcimem_bcopy(drqe, temp_drqe, dq->entry_size);
373
374         /* Update the host index to point to the next slot */
375         hq->host_index = ((hq->host_index + 1) % hq->entry_count);
376         dq->host_index = ((dq->host_index + 1) % dq->entry_count);
377
378         /* Ring The Header Receive Queue Doorbell */
379         if (!(hq->host_index % LPFC_RQ_POST_BATCH)) {
380                 doorbell.word0 = 0;
381                 bf_set(lpfc_rq_doorbell_num_posted, &doorbell,
382                        LPFC_RQ_POST_BATCH);
383                 bf_set(lpfc_rq_doorbell_id, &doorbell, hq->queue_id);
384                 writel(doorbell.word0, hq->phba->sli4_hba.RQDBregaddr);
385         }
386         return put_index;
387 }
388
389 /**
390  * lpfc_sli4_rq_release - Updates internal hba index for RQ
391  * @q: The Header Receive Queue to operate on.
392  *
393  * This routine will update the HBA index of a queue to reflect consumption of
394  * one Receive Queue Entry by the HBA. When the HBA indicates that it has
395  * consumed an entry the host calls this function to update the queue's
396  * internal pointers. This routine returns the number of entries that were
397  * consumed by the HBA.
398  **/
399 static uint32_t
400 lpfc_sli4_rq_release(struct lpfc_queue *hq, struct lpfc_queue *dq)
401 {
402         if ((hq->type != LPFC_HRQ) || (dq->type != LPFC_DRQ))
403                 return 0;
404         hq->hba_index = ((hq->hba_index + 1) % hq->entry_count);
405         dq->hba_index = ((dq->hba_index + 1) % dq->entry_count);
406         return 1;
407 }
408
409 /**
410  * lpfc_cmd_iocb - Get next command iocb entry in the ring
411  * @phba: Pointer to HBA context object.
412  * @pring: Pointer to driver SLI ring object.
413  *
414  * This function returns pointer to next command iocb entry
415  * in the command ring. The caller must hold hbalock to prevent
416  * other threads consume the next command iocb.
417  * SLI-2/SLI-3 provide different sized iocbs.
418  **/
419 static inline IOCB_t *
420 lpfc_cmd_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
421 {
422         return (IOCB_t *) (((char *) pring->cmdringaddr) +
423                            pring->cmdidx * phba->iocb_cmd_size);
424 }
425
426 /**
427  * lpfc_resp_iocb - Get next response iocb entry in the ring
428  * @phba: Pointer to HBA context object.
429  * @pring: Pointer to driver SLI ring object.
430  *
431  * This function returns pointer to next response iocb entry
432  * in the response ring. The caller must hold hbalock to make sure
433  * that no other thread consume the next response iocb.
434  * SLI-2/SLI-3 provide different sized iocbs.
435  **/
436 static inline IOCB_t *
437 lpfc_resp_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
438 {
439         return (IOCB_t *) (((char *) pring->rspringaddr) +
440                            pring->rspidx * phba->iocb_rsp_size);
441 }
442
443 /**
444  * __lpfc_sli_get_iocbq - Allocates an iocb object from iocb pool
445  * @phba: Pointer to HBA context object.
446  *
447  * This function is called with hbalock held. This function
448  * allocates a new driver iocb object from the iocb pool. If the
449  * allocation is successful, it returns pointer to the newly
450  * allocated iocb object else it returns NULL.
451  **/
452 static struct lpfc_iocbq *
453 __lpfc_sli_get_iocbq(struct lpfc_hba *phba)
454 {
455         struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
456         struct lpfc_iocbq * iocbq = NULL;
457
458         list_remove_head(lpfc_iocb_list, iocbq, struct lpfc_iocbq, list);
459
460         if (iocbq)
461                 phba->iocb_cnt++;
462         if (phba->iocb_cnt > phba->iocb_max)
463                 phba->iocb_max = phba->iocb_cnt;
464         return iocbq;
465 }
466
467 /**
468  * __lpfc_clear_active_sglq - Remove the active sglq for this XRI.
469  * @phba: Pointer to HBA context object.
470  * @xritag: XRI value.
471  *
472  * This function clears the sglq pointer from the array of acive
473  * sglq's. The xritag that is passed in is used to index into the
474  * array. Before the xritag can be used it needs to be adjusted
475  * by subtracting the xribase.
476  *
477  * Returns sglq ponter = success, NULL = Failure.
478  **/
479 static struct lpfc_sglq *
480 __lpfc_clear_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
481 {
482         uint16_t adj_xri;
483         struct lpfc_sglq *sglq;
484         adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
485         if (adj_xri > phba->sli4_hba.max_cfg_param.max_xri)
486                 return NULL;
487         sglq = phba->sli4_hba.lpfc_sglq_active_list[adj_xri];
488         phba->sli4_hba.lpfc_sglq_active_list[adj_xri] = NULL;
489         return sglq;
490 }
491
492 /**
493  * __lpfc_get_active_sglq - Get the active sglq for this XRI.
494  * @phba: Pointer to HBA context object.
495  * @xritag: XRI value.
496  *
497  * This function returns the sglq pointer from the array of acive
498  * sglq's. The xritag that is passed in is used to index into the
499  * array. Before the xritag can be used it needs to be adjusted
500  * by subtracting the xribase.
501  *
502  * Returns sglq ponter = success, NULL = Failure.
503  **/
504 struct lpfc_sglq *
505 __lpfc_get_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
506 {
507         uint16_t adj_xri;
508         struct lpfc_sglq *sglq;
509         adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
510         if (adj_xri > phba->sli4_hba.max_cfg_param.max_xri)
511                 return NULL;
512         sglq =  phba->sli4_hba.lpfc_sglq_active_list[adj_xri];
513         return sglq;
514 }
515
516 /**
517  * __lpfc_set_rrq_active - set RRQ active bit in the ndlp's xri_bitmap.
518  * @phba: Pointer to HBA context object.
519  * @ndlp: nodelist pointer for this target.
520  * @xritag: xri used in this exchange.
521  * @rxid: Remote Exchange ID.
522  * @send_rrq: Flag used to determine if we should send rrq els cmd.
523  *
524  * This function is called with hbalock held.
525  * The active bit is set in the ndlp's active rrq xri_bitmap. Allocates an
526  * rrq struct and adds it to the active_rrq_list.
527  *
528  * returns  0 for rrq slot for this xri
529  *         < 0  Were not able to get rrq mem or invalid parameter.
530  **/
531 static int
532 __lpfc_set_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
533                 uint16_t xritag, uint16_t rxid, uint16_t send_rrq)
534 {
535         uint16_t adj_xri;
536         struct lpfc_node_rrq *rrq;
537         int empty;
538         uint32_t did = 0;
539
540
541         if (!ndlp)
542                 return -EINVAL;
543
544         if (!phba->cfg_enable_rrq)
545                 return -EINVAL;
546
547         if (phba->pport->load_flag & FC_UNLOADING) {
548                 phba->hba_flag &= ~HBA_RRQ_ACTIVE;
549                 goto out;
550         }
551         did = ndlp->nlp_DID;
552
553         /*
554          * set the active bit even if there is no mem available.
555          */
556         adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
557
558         if (NLP_CHK_FREE_REQ(ndlp))
559                 goto out;
560
561         if (ndlp->vport && (ndlp->vport->load_flag & FC_UNLOADING))
562                 goto out;
563
564         if (test_and_set_bit(adj_xri, ndlp->active_rrqs.xri_bitmap))
565                 goto out;
566
567         rrq = mempool_alloc(phba->rrq_pool, GFP_KERNEL);
568         if (rrq) {
569                 rrq->send_rrq = send_rrq;
570                 rrq->xritag = xritag;
571                 rrq->rrq_stop_time = jiffies + HZ * (phba->fc_ratov + 1);
572                 rrq->ndlp = ndlp;
573                 rrq->nlp_DID = ndlp->nlp_DID;
574                 rrq->vport = ndlp->vport;
575                 rrq->rxid = rxid;
576                 empty = list_empty(&phba->active_rrq_list);
577                 rrq->send_rrq = send_rrq;
578                 list_add_tail(&rrq->list, &phba->active_rrq_list);
579                 if (!(phba->hba_flag & HBA_RRQ_ACTIVE)) {
580                         phba->hba_flag |= HBA_RRQ_ACTIVE;
581                         if (empty)
582                                 lpfc_worker_wake_up(phba);
583                 }
584                 return 0;
585         }
586 out:
587         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
588                         "2921 Can't set rrq active xri:0x%x rxid:0x%x"
589                         " DID:0x%x Send:%d\n",
590                         xritag, rxid, did, send_rrq);
591         return -EINVAL;
592 }
593
594 /**
595  * lpfc_clr_rrq_active - Clears RRQ active bit in xri_bitmap.
596  * @phba: Pointer to HBA context object.
597  * @xritag: xri used in this exchange.
598  * @rrq: The RRQ to be cleared.
599  *
600  **/
601 void
602 lpfc_clr_rrq_active(struct lpfc_hba *phba,
603                     uint16_t xritag,
604                     struct lpfc_node_rrq *rrq)
605 {
606         uint16_t adj_xri;
607         struct lpfc_nodelist *ndlp = NULL;
608
609         if ((rrq->vport) && NLP_CHK_NODE_ACT(rrq->ndlp))
610                 ndlp = lpfc_findnode_did(rrq->vport, rrq->nlp_DID);
611
612         /* The target DID could have been swapped (cable swap)
613          * we should use the ndlp from the findnode if it is
614          * available.
615          */
616         if ((!ndlp) && rrq->ndlp)
617                 ndlp = rrq->ndlp;
618
619         if (!ndlp)
620                 goto out;
621
622         adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
623         if (test_and_clear_bit(adj_xri, ndlp->active_rrqs.xri_bitmap)) {
624                 rrq->send_rrq = 0;
625                 rrq->xritag = 0;
626                 rrq->rrq_stop_time = 0;
627         }
628 out:
629         mempool_free(rrq, phba->rrq_pool);
630 }
631
632 /**
633  * lpfc_handle_rrq_active - Checks if RRQ has waithed RATOV.
634  * @phba: Pointer to HBA context object.
635  *
636  * This function is called with hbalock held. This function
637  * Checks if stop_time (ratov from setting rrq active) has
638  * been reached, if it has and the send_rrq flag is set then
639  * it will call lpfc_send_rrq. If the send_rrq flag is not set
640  * then it will just call the routine to clear the rrq and
641  * free the rrq resource.
642  * The timer is set to the next rrq that is going to expire before
643  * leaving the routine.
644  *
645  **/
646 void
647 lpfc_handle_rrq_active(struct lpfc_hba *phba)
648 {
649         struct lpfc_node_rrq *rrq;
650         struct lpfc_node_rrq *nextrrq;
651         unsigned long next_time;
652         unsigned long iflags;
653         LIST_HEAD(send_rrq);
654
655         spin_lock_irqsave(&phba->hbalock, iflags);
656         phba->hba_flag &= ~HBA_RRQ_ACTIVE;
657         next_time = jiffies + HZ * (phba->fc_ratov + 1);
658         list_for_each_entry_safe(rrq, nextrrq,
659                                  &phba->active_rrq_list, list) {
660                 if (time_after(jiffies, rrq->rrq_stop_time))
661                         list_move(&rrq->list, &send_rrq);
662                 else if (time_before(rrq->rrq_stop_time, next_time))
663                         next_time = rrq->rrq_stop_time;
664         }
665         spin_unlock_irqrestore(&phba->hbalock, iflags);
666         if (!list_empty(&phba->active_rrq_list))
667                 mod_timer(&phba->rrq_tmr, next_time);
668         list_for_each_entry_safe(rrq, nextrrq, &send_rrq, list) {
669                 list_del(&rrq->list);
670                 if (!rrq->send_rrq)
671                         /* this call will free the rrq */
672                 lpfc_clr_rrq_active(phba, rrq->xritag, rrq);
673                 else if (lpfc_send_rrq(phba, rrq)) {
674                         /* if we send the rrq then the completion handler
675                         *  will clear the bit in the xribitmap.
676                         */
677                         lpfc_clr_rrq_active(phba, rrq->xritag,
678                                             rrq);
679                 }
680         }
681 }
682
683 /**
684  * lpfc_get_active_rrq - Get the active RRQ for this exchange.
685  * @vport: Pointer to vport context object.
686  * @xri: The xri used in the exchange.
687  * @did: The targets DID for this exchange.
688  *
689  * returns NULL = rrq not found in the phba->active_rrq_list.
690  *         rrq = rrq for this xri and target.
691  **/
692 struct lpfc_node_rrq *
693 lpfc_get_active_rrq(struct lpfc_vport *vport, uint16_t xri, uint32_t did)
694 {
695         struct lpfc_hba *phba = vport->phba;
696         struct lpfc_node_rrq *rrq;
697         struct lpfc_node_rrq *nextrrq;
698         unsigned long iflags;
699
700         if (phba->sli_rev != LPFC_SLI_REV4)
701                 return NULL;
702         spin_lock_irqsave(&phba->hbalock, iflags);
703         list_for_each_entry_safe(rrq, nextrrq, &phba->active_rrq_list, list) {
704                 if (rrq->vport == vport && rrq->xritag == xri &&
705                                 rrq->nlp_DID == did){
706                         list_del(&rrq->list);
707                         spin_unlock_irqrestore(&phba->hbalock, iflags);
708                         return rrq;
709                 }
710         }
711         spin_unlock_irqrestore(&phba->hbalock, iflags);
712         return NULL;
713 }
714
715 /**
716  * lpfc_cleanup_vports_rrqs - Remove and clear the active RRQ for this vport.
717  * @vport: Pointer to vport context object.
718  * @ndlp: Pointer to the lpfc_node_list structure.
719  * If ndlp is NULL Remove all active RRQs for this vport from the
720  * phba->active_rrq_list and clear the rrq.
721  * If ndlp is not NULL then only remove rrqs for this vport & this ndlp.
722  **/
723 void
724 lpfc_cleanup_vports_rrqs(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
725
726 {
727         struct lpfc_hba *phba = vport->phba;
728         struct lpfc_node_rrq *rrq;
729         struct lpfc_node_rrq *nextrrq;
730         unsigned long iflags;
731         LIST_HEAD(rrq_list);
732
733         if (phba->sli_rev != LPFC_SLI_REV4)
734                 return;
735         if (!ndlp) {
736                 lpfc_sli4_vport_delete_els_xri_aborted(vport);
737                 lpfc_sli4_vport_delete_fcp_xri_aborted(vport);
738         }
739         spin_lock_irqsave(&phba->hbalock, iflags);
740         list_for_each_entry_safe(rrq, nextrrq, &phba->active_rrq_list, list)
741                 if ((rrq->vport == vport) && (!ndlp  || rrq->ndlp == ndlp))
742                         list_move(&rrq->list, &rrq_list);
743         spin_unlock_irqrestore(&phba->hbalock, iflags);
744
745         list_for_each_entry_safe(rrq, nextrrq, &rrq_list, list) {
746                 list_del(&rrq->list);
747                 lpfc_clr_rrq_active(phba, rrq->xritag, rrq);
748         }
749 }
750
751 /**
752  * lpfc_cleanup_wt_rrqs - Remove all rrq's from the active list.
753  * @phba: Pointer to HBA context object.
754  *
755  * Remove all rrqs from the phba->active_rrq_list and free them by
756  * calling __lpfc_clr_active_rrq
757  *
758  **/
759 void
760 lpfc_cleanup_wt_rrqs(struct lpfc_hba *phba)
761 {
762         struct lpfc_node_rrq *rrq;
763         struct lpfc_node_rrq *nextrrq;
764         unsigned long next_time;
765         unsigned long iflags;
766         LIST_HEAD(rrq_list);
767
768         if (phba->sli_rev != LPFC_SLI_REV4)
769                 return;
770         spin_lock_irqsave(&phba->hbalock, iflags);
771         phba->hba_flag &= ~HBA_RRQ_ACTIVE;
772         next_time = jiffies + HZ * (phba->fc_ratov * 2);
773         list_splice_init(&phba->active_rrq_list, &rrq_list);
774         spin_unlock_irqrestore(&phba->hbalock, iflags);
775
776         list_for_each_entry_safe(rrq, nextrrq, &rrq_list, list) {
777                 list_del(&rrq->list);
778                 lpfc_clr_rrq_active(phba, rrq->xritag, rrq);
779         }
780         if (!list_empty(&phba->active_rrq_list))
781                 mod_timer(&phba->rrq_tmr, next_time);
782 }
783
784
785 /**
786  * lpfc_test_rrq_active - Test RRQ bit in xri_bitmap.
787  * @phba: Pointer to HBA context object.
788  * @ndlp: Targets nodelist pointer for this exchange.
789  * @xritag the xri in the bitmap to test.
790  *
791  * This function is called with hbalock held. This function
792  * returns 0 = rrq not active for this xri
793  *         1 = rrq is valid for this xri.
794  **/
795 int
796 lpfc_test_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
797                         uint16_t  xritag)
798 {
799         uint16_t adj_xri;
800
801         adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
802         if (!ndlp)
803                 return 0;
804         if (test_bit(adj_xri, 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         int ret;
830         unsigned long iflags;
831
832         spin_lock_irqsave(&phba->hbalock, iflags);
833         ret = __lpfc_set_rrq_active(phba, ndlp, xritag, rxid, send_rrq);
834         spin_unlock_irqrestore(&phba->hbalock, iflags);
835         return ret;
836 }
837
838 /**
839  * __lpfc_sli_get_sglq - Allocates an iocb object from sgl pool
840  * @phba: Pointer to HBA context object.
841  * @piocb: Pointer to the iocbq.
842  *
843  * This function is called with hbalock held. This function
844  * Gets a new driver sglq object from the sglq list. If the
845  * list is not empty then it is successful, it returns pointer to the newly
846  * allocated sglq object else it returns NULL.
847  **/
848 static struct lpfc_sglq *
849 __lpfc_sli_get_sglq(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq)
850 {
851         struct list_head *lpfc_sgl_list = &phba->sli4_hba.lpfc_sgl_list;
852         struct lpfc_sglq *sglq = NULL;
853         struct lpfc_sglq *start_sglq = NULL;
854         uint16_t adj_xri;
855         struct lpfc_scsi_buf *lpfc_cmd;
856         struct lpfc_nodelist *ndlp;
857         int found = 0;
858
859         if (piocbq->iocb_flag &  LPFC_IO_FCP) {
860                 lpfc_cmd = (struct lpfc_scsi_buf *) piocbq->context1;
861                 ndlp = lpfc_cmd->rdata->pnode;
862         } else  if ((piocbq->iocb.ulpCommand == CMD_GEN_REQUEST64_CR) &&
863                         !(piocbq->iocb_flag & LPFC_IO_LIBDFC))
864                 ndlp = piocbq->context_un.ndlp;
865         else
866                 ndlp = piocbq->context1;
867
868         list_remove_head(lpfc_sgl_list, sglq, struct lpfc_sglq, list);
869         start_sglq = sglq;
870         while (!found) {
871                 if (!sglq)
872                         return NULL;
873                 adj_xri = sglq->sli4_xritag -
874                                 phba->sli4_hba.max_cfg_param.xri_base;
875                 if (lpfc_test_rrq_active(phba, ndlp, sglq->sli4_xritag)) {
876                         /* This xri has an rrq outstanding for this DID.
877                          * put it back in the list and get another xri.
878                          */
879                         list_add_tail(&sglq->list, lpfc_sgl_list);
880                         sglq = NULL;
881                         list_remove_head(lpfc_sgl_list, sglq,
882                                                 struct lpfc_sglq, list);
883                         if (sglq == start_sglq) {
884                                 sglq = NULL;
885                                 break;
886                         } else
887                                 continue;
888                 }
889                 sglq->ndlp = ndlp;
890                 found = 1;
891                 phba->sli4_hba.lpfc_sglq_active_list[adj_xri] = sglq;
892                 sglq->state = SGL_ALLOCATED;
893         }
894         return sglq;
895 }
896
897 /**
898  * lpfc_sli_get_iocbq - Allocates an iocb object from iocb pool
899  * @phba: Pointer to HBA context object.
900  *
901  * This function is called with no lock held. This function
902  * allocates a new driver iocb object from the iocb pool. If the
903  * allocation is successful, it returns pointer to the newly
904  * allocated iocb object else it returns NULL.
905  **/
906 struct lpfc_iocbq *
907 lpfc_sli_get_iocbq(struct lpfc_hba *phba)
908 {
909         struct lpfc_iocbq * iocbq = NULL;
910         unsigned long iflags;
911
912         spin_lock_irqsave(&phba->hbalock, iflags);
913         iocbq = __lpfc_sli_get_iocbq(phba);
914         spin_unlock_irqrestore(&phba->hbalock, iflags);
915         return iocbq;
916 }
917
918 /**
919  * __lpfc_sli_release_iocbq_s4 - Release iocb to the iocb pool
920  * @phba: Pointer to HBA context object.
921  * @iocbq: Pointer to driver iocb object.
922  *
923  * This function is called with hbalock held to release driver
924  * iocb object to the iocb pool. The iotag in the iocb object
925  * does not change for each use of the iocb object. This function
926  * clears all other fields of the iocb object when it is freed.
927  * The sqlq structure that holds the xritag and phys and virtual
928  * mappings for the scatter gather list is retrieved from the
929  * active array of sglq. The get of the sglq pointer also clears
930  * the entry in the array. If the status of the IO indiactes that
931  * this IO was aborted then the sglq entry it put on the
932  * lpfc_abts_els_sgl_list until the CQ_ABORTED_XRI is received. If the
933  * IO has good status or fails for any other reason then the sglq
934  * entry is added to the free list (lpfc_sgl_list).
935  **/
936 static void
937 __lpfc_sli_release_iocbq_s4(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
938 {
939         struct lpfc_sglq *sglq;
940         size_t start_clean = offsetof(struct lpfc_iocbq, iocb);
941         unsigned long iflag = 0;
942         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
943
944         if (iocbq->sli4_xritag == NO_XRI)
945                 sglq = NULL;
946         else
947                 sglq = __lpfc_clear_active_sglq(phba, iocbq->sli4_xritag);
948         if (sglq)  {
949                 if ((iocbq->iocb_flag & LPFC_EXCHANGE_BUSY) &&
950                         (sglq->state != SGL_XRI_ABORTED)) {
951                         spin_lock_irqsave(&phba->sli4_hba.abts_sgl_list_lock,
952                                         iflag);
953                         list_add(&sglq->list,
954                                 &phba->sli4_hba.lpfc_abts_els_sgl_list);
955                         spin_unlock_irqrestore(
956                                 &phba->sli4_hba.abts_sgl_list_lock, iflag);
957                 } else {
958                         sglq->state = SGL_FREED;
959                         sglq->ndlp = NULL;
960                         list_add_tail(&sglq->list,
961                                 &phba->sli4_hba.lpfc_sgl_list);
962
963                         /* Check if TXQ queue needs to be serviced */
964                         if (pring->txq_cnt)
965                                 lpfc_worker_wake_up(phba);
966                 }
967         }
968
969
970         /*
971          * Clean all volatile data fields, preserve iotag and node struct.
972          */
973         memset((char *)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean);
974         iocbq->sli4_xritag = NO_XRI;
975         list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
976 }
977
978
979 /**
980  * __lpfc_sli_release_iocbq_s3 - Release iocb to the iocb pool
981  * @phba: Pointer to HBA context object.
982  * @iocbq: Pointer to driver iocb object.
983  *
984  * This function is called with hbalock held to release driver
985  * iocb object to the iocb pool. The iotag in the iocb object
986  * does not change for each use of the iocb object. This function
987  * clears all other fields of the iocb object when it is freed.
988  **/
989 static void
990 __lpfc_sli_release_iocbq_s3(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
991 {
992         size_t start_clean = offsetof(struct lpfc_iocbq, iocb);
993
994         /*
995          * Clean all volatile data fields, preserve iotag and node struct.
996          */
997         memset((char*)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean);
998         iocbq->sli4_xritag = NO_XRI;
999         list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
1000 }
1001
1002 /**
1003  * __lpfc_sli_release_iocbq - Release iocb to the iocb pool
1004  * @phba: Pointer to HBA context object.
1005  * @iocbq: Pointer to driver iocb object.
1006  *
1007  * This function is called with hbalock held to release driver
1008  * iocb object to the iocb pool. The iotag in the iocb object
1009  * does not change for each use of the iocb object. This function
1010  * clears all other fields of the iocb object when it is freed.
1011  **/
1012 static void
1013 __lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
1014 {
1015         phba->__lpfc_sli_release_iocbq(phba, iocbq);
1016         phba->iocb_cnt--;
1017 }
1018
1019 /**
1020  * lpfc_sli_release_iocbq - Release iocb to the iocb pool
1021  * @phba: Pointer to HBA context object.
1022  * @iocbq: Pointer to driver iocb object.
1023  *
1024  * This function is called with no lock held to release the iocb to
1025  * iocb pool.
1026  **/
1027 void
1028 lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
1029 {
1030         unsigned long iflags;
1031
1032         /*
1033          * Clean all volatile data fields, preserve iotag and node struct.
1034          */
1035         spin_lock_irqsave(&phba->hbalock, iflags);
1036         __lpfc_sli_release_iocbq(phba, iocbq);
1037         spin_unlock_irqrestore(&phba->hbalock, iflags);
1038 }
1039
1040 /**
1041  * lpfc_sli_cancel_iocbs - Cancel all iocbs from a list.
1042  * @phba: Pointer to HBA context object.
1043  * @iocblist: List of IOCBs.
1044  * @ulpstatus: ULP status in IOCB command field.
1045  * @ulpWord4: ULP word-4 in IOCB command field.
1046  *
1047  * This function is called with a list of IOCBs to cancel. It cancels the IOCB
1048  * on the list by invoking the complete callback function associated with the
1049  * IOCB with the provided @ulpstatus and @ulpword4 set to the IOCB commond
1050  * fields.
1051  **/
1052 void
1053 lpfc_sli_cancel_iocbs(struct lpfc_hba *phba, struct list_head *iocblist,
1054                       uint32_t ulpstatus, uint32_t ulpWord4)
1055 {
1056         struct lpfc_iocbq *piocb;
1057
1058         while (!list_empty(iocblist)) {
1059                 list_remove_head(iocblist, piocb, struct lpfc_iocbq, list);
1060
1061                 if (!piocb->iocb_cmpl)
1062                         lpfc_sli_release_iocbq(phba, piocb);
1063                 else {
1064                         piocb->iocb.ulpStatus = ulpstatus;
1065                         piocb->iocb.un.ulpWord[4] = ulpWord4;
1066                         (piocb->iocb_cmpl) (phba, piocb, piocb);
1067                 }
1068         }
1069         return;
1070 }
1071
1072 /**
1073  * lpfc_sli_iocb_cmd_type - Get the iocb type
1074  * @iocb_cmnd: iocb command code.
1075  *
1076  * This function is called by ring event handler function to get the iocb type.
1077  * This function translates the iocb command to an iocb command type used to
1078  * decide the final disposition of each completed IOCB.
1079  * The function returns
1080  * LPFC_UNKNOWN_IOCB if it is an unsupported iocb
1081  * LPFC_SOL_IOCB     if it is a solicited iocb completion
1082  * LPFC_ABORT_IOCB   if it is an abort iocb
1083  * LPFC_UNSOL_IOCB   if it is an unsolicited iocb
1084  *
1085  * The caller is not required to hold any lock.
1086  **/
1087 static lpfc_iocb_type
1088 lpfc_sli_iocb_cmd_type(uint8_t iocb_cmnd)
1089 {
1090         lpfc_iocb_type type = LPFC_UNKNOWN_IOCB;
1091
1092         if (iocb_cmnd > CMD_MAX_IOCB_CMD)
1093                 return 0;
1094
1095         switch (iocb_cmnd) {
1096         case CMD_XMIT_SEQUENCE_CR:
1097         case CMD_XMIT_SEQUENCE_CX:
1098         case CMD_XMIT_BCAST_CN:
1099         case CMD_XMIT_BCAST_CX:
1100         case CMD_ELS_REQUEST_CR:
1101         case CMD_ELS_REQUEST_CX:
1102         case CMD_CREATE_XRI_CR:
1103         case CMD_CREATE_XRI_CX:
1104         case CMD_GET_RPI_CN:
1105         case CMD_XMIT_ELS_RSP_CX:
1106         case CMD_GET_RPI_CR:
1107         case CMD_FCP_IWRITE_CR:
1108         case CMD_FCP_IWRITE_CX:
1109         case CMD_FCP_IREAD_CR:
1110         case CMD_FCP_IREAD_CX:
1111         case CMD_FCP_ICMND_CR:
1112         case CMD_FCP_ICMND_CX:
1113         case CMD_FCP_TSEND_CX:
1114         case CMD_FCP_TRSP_CX:
1115         case CMD_FCP_TRECEIVE_CX:
1116         case CMD_FCP_AUTO_TRSP_CX:
1117         case CMD_ADAPTER_MSG:
1118         case CMD_ADAPTER_DUMP:
1119         case CMD_XMIT_SEQUENCE64_CR:
1120         case CMD_XMIT_SEQUENCE64_CX:
1121         case CMD_XMIT_BCAST64_CN:
1122         case CMD_XMIT_BCAST64_CX:
1123         case CMD_ELS_REQUEST64_CR:
1124         case CMD_ELS_REQUEST64_CX:
1125         case CMD_FCP_IWRITE64_CR:
1126         case CMD_FCP_IWRITE64_CX:
1127         case CMD_FCP_IREAD64_CR:
1128         case CMD_FCP_IREAD64_CX:
1129         case CMD_FCP_ICMND64_CR:
1130         case CMD_FCP_ICMND64_CX:
1131         case CMD_FCP_TSEND64_CX:
1132         case CMD_FCP_TRSP64_CX:
1133         case CMD_FCP_TRECEIVE64_CX:
1134         case CMD_GEN_REQUEST64_CR:
1135         case CMD_GEN_REQUEST64_CX:
1136         case CMD_XMIT_ELS_RSP64_CX:
1137         case DSSCMD_IWRITE64_CR:
1138         case DSSCMD_IWRITE64_CX:
1139         case DSSCMD_IREAD64_CR:
1140         case DSSCMD_IREAD64_CX:
1141                 type = LPFC_SOL_IOCB;
1142                 break;
1143         case CMD_ABORT_XRI_CN:
1144         case CMD_ABORT_XRI_CX:
1145         case CMD_CLOSE_XRI_CN:
1146         case CMD_CLOSE_XRI_CX:
1147         case CMD_XRI_ABORTED_CX:
1148         case CMD_ABORT_MXRI64_CN:
1149         case CMD_XMIT_BLS_RSP64_CX:
1150                 type = LPFC_ABORT_IOCB;
1151                 break;
1152         case CMD_RCV_SEQUENCE_CX:
1153         case CMD_RCV_ELS_REQ_CX:
1154         case CMD_RCV_SEQUENCE64_CX:
1155         case CMD_RCV_ELS_REQ64_CX:
1156         case CMD_ASYNC_STATUS:
1157         case CMD_IOCB_RCV_SEQ64_CX:
1158         case CMD_IOCB_RCV_ELS64_CX:
1159         case CMD_IOCB_RCV_CONT64_CX:
1160         case CMD_IOCB_RET_XRI64_CX:
1161                 type = LPFC_UNSOL_IOCB;
1162                 break;
1163         case CMD_IOCB_XMIT_MSEQ64_CR:
1164         case CMD_IOCB_XMIT_MSEQ64_CX:
1165         case CMD_IOCB_RCV_SEQ_LIST64_CX:
1166         case CMD_IOCB_RCV_ELS_LIST64_CX:
1167         case CMD_IOCB_CLOSE_EXTENDED_CN:
1168         case CMD_IOCB_ABORT_EXTENDED_CN:
1169         case CMD_IOCB_RET_HBQE64_CN:
1170         case CMD_IOCB_FCP_IBIDIR64_CR:
1171         case CMD_IOCB_FCP_IBIDIR64_CX:
1172         case CMD_IOCB_FCP_ITASKMGT64_CX:
1173         case CMD_IOCB_LOGENTRY_CN:
1174         case CMD_IOCB_LOGENTRY_ASYNC_CN:
1175                 printk("%s - Unhandled SLI-3 Command x%x\n",
1176                                 __func__, iocb_cmnd);
1177                 type = LPFC_UNKNOWN_IOCB;
1178                 break;
1179         default:
1180                 type = LPFC_UNKNOWN_IOCB;
1181                 break;
1182         }
1183
1184         return type;
1185 }
1186
1187 /**
1188  * lpfc_sli_ring_map - Issue config_ring mbox for all rings
1189  * @phba: Pointer to HBA context object.
1190  *
1191  * This function is called from SLI initialization code
1192  * to configure every ring of the HBA's SLI interface. The
1193  * caller is not required to hold any lock. This function issues
1194  * a config_ring mailbox command for each ring.
1195  * This function returns zero if successful else returns a negative
1196  * error code.
1197  **/
1198 static int
1199 lpfc_sli_ring_map(struct lpfc_hba *phba)
1200 {
1201         struct lpfc_sli *psli = &phba->sli;
1202         LPFC_MBOXQ_t *pmb;
1203         MAILBOX_t *pmbox;
1204         int i, rc, ret = 0;
1205
1206         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1207         if (!pmb)
1208                 return -ENOMEM;
1209         pmbox = &pmb->u.mb;
1210         phba->link_state = LPFC_INIT_MBX_CMDS;
1211         for (i = 0; i < psli->num_rings; i++) {
1212                 lpfc_config_ring(phba, i, pmb);
1213                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
1214                 if (rc != MBX_SUCCESS) {
1215                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1216                                         "0446 Adapter failed to init (%d), "
1217                                         "mbxCmd x%x CFG_RING, mbxStatus x%x, "
1218                                         "ring %d\n",
1219                                         rc, pmbox->mbxCommand,
1220                                         pmbox->mbxStatus, i);
1221                         phba->link_state = LPFC_HBA_ERROR;
1222                         ret = -ENXIO;
1223                         break;
1224                 }
1225         }
1226         mempool_free(pmb, phba->mbox_mem_pool);
1227         return ret;
1228 }
1229
1230 /**
1231  * lpfc_sli_ringtxcmpl_put - Adds new iocb to the txcmplq
1232  * @phba: Pointer to HBA context object.
1233  * @pring: Pointer to driver SLI ring object.
1234  * @piocb: Pointer to the driver iocb object.
1235  *
1236  * This function is called with hbalock held. The function adds the
1237  * new iocb to txcmplq of the given ring. This function always returns
1238  * 0. If this function is called for ELS ring, this function checks if
1239  * there is a vport associated with the ELS command. This function also
1240  * starts els_tmofunc timer if this is an ELS command.
1241  **/
1242 static int
1243 lpfc_sli_ringtxcmpl_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1244                         struct lpfc_iocbq *piocb)
1245 {
1246         list_add_tail(&piocb->list, &pring->txcmplq);
1247         piocb->iocb_flag |= LPFC_IO_ON_Q;
1248         pring->txcmplq_cnt++;
1249         if (pring->txcmplq_cnt > pring->txcmplq_max)
1250                 pring->txcmplq_max = pring->txcmplq_cnt;
1251
1252         if ((unlikely(pring->ringno == LPFC_ELS_RING)) &&
1253            (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
1254            (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN)) {
1255                 if (!piocb->vport)
1256                         BUG();
1257                 else
1258                         mod_timer(&piocb->vport->els_tmofunc,
1259                                   jiffies + HZ * (phba->fc_ratov << 1));
1260         }
1261
1262
1263         return 0;
1264 }
1265
1266 /**
1267  * lpfc_sli_ringtx_get - Get first element of the txq
1268  * @phba: Pointer to HBA context object.
1269  * @pring: Pointer to driver SLI ring object.
1270  *
1271  * This function is called with hbalock held to get next
1272  * iocb in txq of the given ring. If there is any iocb in
1273  * the txq, the function returns first iocb in the list after
1274  * removing the iocb from the list, else it returns NULL.
1275  **/
1276 struct lpfc_iocbq *
1277 lpfc_sli_ringtx_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1278 {
1279         struct lpfc_iocbq *cmd_iocb;
1280
1281         list_remove_head((&pring->txq), cmd_iocb, struct lpfc_iocbq, list);
1282         if (cmd_iocb != NULL)
1283                 pring->txq_cnt--;
1284         return cmd_iocb;
1285 }
1286
1287 /**
1288  * lpfc_sli_next_iocb_slot - Get next iocb slot in the ring
1289  * @phba: Pointer to HBA context object.
1290  * @pring: Pointer to driver SLI ring object.
1291  *
1292  * This function is called with hbalock held and the caller must post the
1293  * iocb without releasing the lock. If the caller releases the lock,
1294  * iocb slot returned by the function is not guaranteed to be available.
1295  * The function returns pointer to the next available iocb slot if there
1296  * is available slot in the ring, else it returns NULL.
1297  * If the get index of the ring is ahead of the put index, the function
1298  * will post an error attention event to the worker thread to take the
1299  * HBA to offline state.
1300  **/
1301 static IOCB_t *
1302 lpfc_sli_next_iocb_slot (struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1303 {
1304         struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1305         uint32_t  max_cmd_idx = pring->numCiocb;
1306         if ((pring->next_cmdidx == pring->cmdidx) &&
1307            (++pring->next_cmdidx >= max_cmd_idx))
1308                 pring->next_cmdidx = 0;
1309
1310         if (unlikely(pring->local_getidx == pring->next_cmdidx)) {
1311
1312                 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
1313
1314                 if (unlikely(pring->local_getidx >= max_cmd_idx)) {
1315                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1316                                         "0315 Ring %d issue: portCmdGet %d "
1317                                         "is bigger than cmd ring %d\n",
1318                                         pring->ringno,
1319                                         pring->local_getidx, max_cmd_idx);
1320
1321                         phba->link_state = LPFC_HBA_ERROR;
1322                         /*
1323                          * All error attention handlers are posted to
1324                          * worker thread
1325                          */
1326                         phba->work_ha |= HA_ERATT;
1327                         phba->work_hs = HS_FFER3;
1328
1329                         lpfc_worker_wake_up(phba);
1330
1331                         return NULL;
1332                 }
1333
1334                 if (pring->local_getidx == pring->next_cmdidx)
1335                         return NULL;
1336         }
1337
1338         return lpfc_cmd_iocb(phba, pring);
1339 }
1340
1341 /**
1342  * lpfc_sli_next_iotag - Get an iotag for the iocb
1343  * @phba: Pointer to HBA context object.
1344  * @iocbq: Pointer to driver iocb object.
1345  *
1346  * This function gets an iotag for the iocb. If there is no unused iotag and
1347  * the iocbq_lookup_len < 0xffff, this function allocates a bigger iotag_lookup
1348  * array and assigns a new iotag.
1349  * The function returns the allocated iotag if successful, else returns zero.
1350  * Zero is not a valid iotag.
1351  * The caller is not required to hold any lock.
1352  **/
1353 uint16_t
1354 lpfc_sli_next_iotag(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
1355 {
1356         struct lpfc_iocbq **new_arr;
1357         struct lpfc_iocbq **old_arr;
1358         size_t new_len;
1359         struct lpfc_sli *psli = &phba->sli;
1360         uint16_t iotag;
1361
1362         spin_lock_irq(&phba->hbalock);
1363         iotag = psli->last_iotag;
1364         if(++iotag < psli->iocbq_lookup_len) {
1365                 psli->last_iotag = iotag;
1366                 psli->iocbq_lookup[iotag] = iocbq;
1367                 spin_unlock_irq(&phba->hbalock);
1368                 iocbq->iotag = iotag;
1369                 return iotag;
1370         } else if (psli->iocbq_lookup_len < (0xffff
1371                                            - LPFC_IOCBQ_LOOKUP_INCREMENT)) {
1372                 new_len = psli->iocbq_lookup_len + LPFC_IOCBQ_LOOKUP_INCREMENT;
1373                 spin_unlock_irq(&phba->hbalock);
1374                 new_arr = kzalloc(new_len * sizeof (struct lpfc_iocbq *),
1375                                   GFP_KERNEL);
1376                 if (new_arr) {
1377                         spin_lock_irq(&phba->hbalock);
1378                         old_arr = psli->iocbq_lookup;
1379                         if (new_len <= psli->iocbq_lookup_len) {
1380                                 /* highly unprobable case */
1381                                 kfree(new_arr);
1382                                 iotag = psli->last_iotag;
1383                                 if(++iotag < psli->iocbq_lookup_len) {
1384                                         psli->last_iotag = iotag;
1385                                         psli->iocbq_lookup[iotag] = iocbq;
1386                                         spin_unlock_irq(&phba->hbalock);
1387                                         iocbq->iotag = iotag;
1388                                         return iotag;
1389                                 }
1390                                 spin_unlock_irq(&phba->hbalock);
1391                                 return 0;
1392                         }
1393                         if (psli->iocbq_lookup)
1394                                 memcpy(new_arr, old_arr,
1395                                        ((psli->last_iotag  + 1) *
1396                                         sizeof (struct lpfc_iocbq *)));
1397                         psli->iocbq_lookup = new_arr;
1398                         psli->iocbq_lookup_len = new_len;
1399                         psli->last_iotag = iotag;
1400                         psli->iocbq_lookup[iotag] = iocbq;
1401                         spin_unlock_irq(&phba->hbalock);
1402                         iocbq->iotag = iotag;
1403                         kfree(old_arr);
1404                         return iotag;
1405                 }
1406         } else
1407                 spin_unlock_irq(&phba->hbalock);
1408
1409         lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1410                         "0318 Failed to allocate IOTAG.last IOTAG is %d\n",
1411                         psli->last_iotag);
1412
1413         return 0;
1414 }
1415
1416 /**
1417  * lpfc_sli_submit_iocb - Submit an iocb to the firmware
1418  * @phba: Pointer to HBA context object.
1419  * @pring: Pointer to driver SLI ring object.
1420  * @iocb: Pointer to iocb slot in the ring.
1421  * @nextiocb: Pointer to driver iocb object which need to be
1422  *            posted to firmware.
1423  *
1424  * This function is called with hbalock held to post a new iocb to
1425  * the firmware. This function copies the new iocb to ring iocb slot and
1426  * updates the ring pointers. It adds the new iocb to txcmplq if there is
1427  * a completion call back for this iocb else the function will free the
1428  * iocb object.
1429  **/
1430 static void
1431 lpfc_sli_submit_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1432                 IOCB_t *iocb, struct lpfc_iocbq *nextiocb)
1433 {
1434         /*
1435          * Set up an iotag
1436          */
1437         nextiocb->iocb.ulpIoTag = (nextiocb->iocb_cmpl) ? nextiocb->iotag : 0;
1438
1439
1440         if (pring->ringno == LPFC_ELS_RING) {
1441                 lpfc_debugfs_slow_ring_trc(phba,
1442                         "IOCB cmd ring:   wd4:x%08x wd6:x%08x wd7:x%08x",
1443                         *(((uint32_t *) &nextiocb->iocb) + 4),
1444                         *(((uint32_t *) &nextiocb->iocb) + 6),
1445                         *(((uint32_t *) &nextiocb->iocb) + 7));
1446         }
1447
1448         /*
1449          * Issue iocb command to adapter
1450          */
1451         lpfc_sli_pcimem_bcopy(&nextiocb->iocb, iocb, phba->iocb_cmd_size);
1452         wmb();
1453         pring->stats.iocb_cmd++;
1454
1455         /*
1456          * If there is no completion routine to call, we can release the
1457          * IOCB buffer back right now. For IOCBs, like QUE_RING_BUF,
1458          * that have no rsp ring completion, iocb_cmpl MUST be NULL.
1459          */
1460         if (nextiocb->iocb_cmpl)
1461                 lpfc_sli_ringtxcmpl_put(phba, pring, nextiocb);
1462         else
1463                 __lpfc_sli_release_iocbq(phba, nextiocb);
1464
1465         /*
1466          * Let the HBA know what IOCB slot will be the next one the
1467          * driver will put a command into.
1468          */
1469         pring->cmdidx = pring->next_cmdidx;
1470         writel(pring->cmdidx, &phba->host_gp[pring->ringno].cmdPutInx);
1471 }
1472
1473 /**
1474  * lpfc_sli_update_full_ring - Update the chip attention register
1475  * @phba: Pointer to HBA context object.
1476  * @pring: Pointer to driver SLI ring object.
1477  *
1478  * The caller is not required to hold any lock for calling this function.
1479  * This function updates the chip attention bits for the ring to inform firmware
1480  * that there are pending work to be done for this ring and requests an
1481  * interrupt when there is space available in the ring. This function is
1482  * called when the driver is unable to post more iocbs to the ring due
1483  * to unavailability of space in the ring.
1484  **/
1485 static void
1486 lpfc_sli_update_full_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1487 {
1488         int ringno = pring->ringno;
1489
1490         pring->flag |= LPFC_CALL_RING_AVAILABLE;
1491
1492         wmb();
1493
1494         /*
1495          * Set ring 'ringno' to SET R0CE_REQ in Chip Att register.
1496          * The HBA will tell us when an IOCB entry is available.
1497          */
1498         writel((CA_R0ATT|CA_R0CE_REQ) << (ringno*4), phba->CAregaddr);
1499         readl(phba->CAregaddr); /* flush */
1500
1501         pring->stats.iocb_cmd_full++;
1502 }
1503
1504 /**
1505  * lpfc_sli_update_ring - Update chip attention register
1506  * @phba: Pointer to HBA context object.
1507  * @pring: Pointer to driver SLI ring object.
1508  *
1509  * This function updates the chip attention register bit for the
1510  * given ring to inform HBA that there is more work to be done
1511  * in this ring. The caller is not required to hold any lock.
1512  **/
1513 static void
1514 lpfc_sli_update_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1515 {
1516         int ringno = pring->ringno;
1517
1518         /*
1519          * Tell the HBA that there is work to do in this ring.
1520          */
1521         if (!(phba->sli3_options & LPFC_SLI3_CRP_ENABLED)) {
1522                 wmb();
1523                 writel(CA_R0ATT << (ringno * 4), phba->CAregaddr);
1524                 readl(phba->CAregaddr); /* flush */
1525         }
1526 }
1527
1528 /**
1529  * lpfc_sli_resume_iocb - Process iocbs in the txq
1530  * @phba: Pointer to HBA context object.
1531  * @pring: Pointer to driver SLI ring object.
1532  *
1533  * This function is called with hbalock held to post pending iocbs
1534  * in the txq to the firmware. This function is called when driver
1535  * detects space available in the ring.
1536  **/
1537 static void
1538 lpfc_sli_resume_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1539 {
1540         IOCB_t *iocb;
1541         struct lpfc_iocbq *nextiocb;
1542
1543         /*
1544          * Check to see if:
1545          *  (a) there is anything on the txq to send
1546          *  (b) link is up
1547          *  (c) link attention events can be processed (fcp ring only)
1548          *  (d) IOCB processing is not blocked by the outstanding mbox command.
1549          */
1550         if (pring->txq_cnt &&
1551             lpfc_is_link_up(phba) &&
1552             (pring->ringno != phba->sli.fcp_ring ||
1553              phba->sli.sli_flag & LPFC_PROCESS_LA)) {
1554
1555                 while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
1556                        (nextiocb = lpfc_sli_ringtx_get(phba, pring)))
1557                         lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
1558
1559                 if (iocb)
1560                         lpfc_sli_update_ring(phba, pring);
1561                 else
1562                         lpfc_sli_update_full_ring(phba, pring);
1563         }
1564
1565         return;
1566 }
1567
1568 /**
1569  * lpfc_sli_next_hbq_slot - Get next hbq entry for the HBQ
1570  * @phba: Pointer to HBA context object.
1571  * @hbqno: HBQ number.
1572  *
1573  * This function is called with hbalock held to get the next
1574  * available slot for the given HBQ. If there is free slot
1575  * available for the HBQ it will return pointer to the next available
1576  * HBQ entry else it will return NULL.
1577  **/
1578 static struct lpfc_hbq_entry *
1579 lpfc_sli_next_hbq_slot(struct lpfc_hba *phba, uint32_t hbqno)
1580 {
1581         struct hbq_s *hbqp = &phba->hbqs[hbqno];
1582
1583         if (hbqp->next_hbqPutIdx == hbqp->hbqPutIdx &&
1584             ++hbqp->next_hbqPutIdx >= hbqp->entry_count)
1585                 hbqp->next_hbqPutIdx = 0;
1586
1587         if (unlikely(hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)) {
1588                 uint32_t raw_index = phba->hbq_get[hbqno];
1589                 uint32_t getidx = le32_to_cpu(raw_index);
1590
1591                 hbqp->local_hbqGetIdx = getidx;
1592
1593                 if (unlikely(hbqp->local_hbqGetIdx >= hbqp->entry_count)) {
1594                         lpfc_printf_log(phba, KERN_ERR,
1595                                         LOG_SLI | LOG_VPORT,
1596                                         "1802 HBQ %d: local_hbqGetIdx "
1597                                         "%u is > than hbqp->entry_count %u\n",
1598                                         hbqno, hbqp->local_hbqGetIdx,
1599                                         hbqp->entry_count);
1600
1601                         phba->link_state = LPFC_HBA_ERROR;
1602                         return NULL;
1603                 }
1604
1605                 if (hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)
1606                         return NULL;
1607         }
1608
1609         return (struct lpfc_hbq_entry *) phba->hbqs[hbqno].hbq_virt +
1610                         hbqp->hbqPutIdx;
1611 }
1612
1613 /**
1614  * lpfc_sli_hbqbuf_free_all - Free all the hbq buffers
1615  * @phba: Pointer to HBA context object.
1616  *
1617  * This function is called with no lock held to free all the
1618  * hbq buffers while uninitializing the SLI interface. It also
1619  * frees the HBQ buffers returned by the firmware but not yet
1620  * processed by the upper layers.
1621  **/
1622 void
1623 lpfc_sli_hbqbuf_free_all(struct lpfc_hba *phba)
1624 {
1625         struct lpfc_dmabuf *dmabuf, *next_dmabuf;
1626         struct hbq_dmabuf *hbq_buf;
1627         unsigned long flags;
1628         int i, hbq_count;
1629         uint32_t hbqno;
1630
1631         hbq_count = lpfc_sli_hbq_count();
1632         /* Return all memory used by all HBQs */
1633         spin_lock_irqsave(&phba->hbalock, flags);
1634         for (i = 0; i < hbq_count; ++i) {
1635                 list_for_each_entry_safe(dmabuf, next_dmabuf,
1636                                 &phba->hbqs[i].hbq_buffer_list, list) {
1637                         hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
1638                         list_del(&hbq_buf->dbuf.list);
1639                         (phba->hbqs[i].hbq_free_buffer)(phba, hbq_buf);
1640                 }
1641                 phba->hbqs[i].buffer_count = 0;
1642         }
1643         /* Return all HBQ buffer that are in-fly */
1644         list_for_each_entry_safe(dmabuf, next_dmabuf, &phba->rb_pend_list,
1645                                  list) {
1646                 hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
1647                 list_del(&hbq_buf->dbuf.list);
1648                 if (hbq_buf->tag == -1) {
1649                         (phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
1650                                 (phba, hbq_buf);
1651                 } else {
1652                         hbqno = hbq_buf->tag >> 16;
1653                         if (hbqno >= LPFC_MAX_HBQS)
1654                                 (phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
1655                                         (phba, hbq_buf);
1656                         else
1657                                 (phba->hbqs[hbqno].hbq_free_buffer)(phba,
1658                                         hbq_buf);
1659                 }
1660         }
1661
1662         /* Mark the HBQs not in use */
1663         phba->hbq_in_use = 0;
1664         spin_unlock_irqrestore(&phba->hbalock, flags);
1665 }
1666
1667 /**
1668  * lpfc_sli_hbq_to_firmware - Post the hbq buffer to firmware
1669  * @phba: Pointer to HBA context object.
1670  * @hbqno: HBQ number.
1671  * @hbq_buf: Pointer to HBQ buffer.
1672  *
1673  * This function is called with the hbalock held to post a
1674  * hbq buffer to the firmware. If the function finds an empty
1675  * slot in the HBQ, it will post the buffer. The function will return
1676  * pointer to the hbq entry if it successfully post the buffer
1677  * else it will return NULL.
1678  **/
1679 static int
1680 lpfc_sli_hbq_to_firmware(struct lpfc_hba *phba, uint32_t hbqno,
1681                          struct hbq_dmabuf *hbq_buf)
1682 {
1683         return phba->lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buf);
1684 }
1685
1686 /**
1687  * lpfc_sli_hbq_to_firmware_s3 - Post the hbq buffer to SLI3 firmware
1688  * @phba: Pointer to HBA context object.
1689  * @hbqno: HBQ number.
1690  * @hbq_buf: Pointer to HBQ buffer.
1691  *
1692  * This function is called with the hbalock held to post a hbq buffer to the
1693  * firmware. If the function finds an empty slot in the HBQ, it will post the
1694  * buffer and place it on the hbq_buffer_list. The function will return zero if
1695  * it successfully post the buffer else it will return an error.
1696  **/
1697 static int
1698 lpfc_sli_hbq_to_firmware_s3(struct lpfc_hba *phba, uint32_t hbqno,
1699                             struct hbq_dmabuf *hbq_buf)
1700 {
1701         struct lpfc_hbq_entry *hbqe;
1702         dma_addr_t physaddr = hbq_buf->dbuf.phys;
1703
1704         /* Get next HBQ entry slot to use */
1705         hbqe = lpfc_sli_next_hbq_slot(phba, hbqno);
1706         if (hbqe) {
1707                 struct hbq_s *hbqp = &phba->hbqs[hbqno];
1708
1709                 hbqe->bde.addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
1710                 hbqe->bde.addrLow  = le32_to_cpu(putPaddrLow(physaddr));
1711                 hbqe->bde.tus.f.bdeSize = hbq_buf->size;
1712                 hbqe->bde.tus.f.bdeFlags = 0;
1713                 hbqe->bde.tus.w = le32_to_cpu(hbqe->bde.tus.w);
1714                 hbqe->buffer_tag = le32_to_cpu(hbq_buf->tag);
1715                                 /* Sync SLIM */
1716                 hbqp->hbqPutIdx = hbqp->next_hbqPutIdx;
1717                 writel(hbqp->hbqPutIdx, phba->hbq_put + hbqno);
1718                                 /* flush */
1719                 readl(phba->hbq_put + hbqno);
1720                 list_add_tail(&hbq_buf->dbuf.list, &hbqp->hbq_buffer_list);
1721                 return 0;
1722         } else
1723                 return -ENOMEM;
1724 }
1725
1726 /**
1727  * lpfc_sli_hbq_to_firmware_s4 - Post the hbq buffer to SLI4 firmware
1728  * @phba: Pointer to HBA context object.
1729  * @hbqno: HBQ number.
1730  * @hbq_buf: Pointer to HBQ buffer.
1731  *
1732  * This function is called with the hbalock held to post an RQE to the SLI4
1733  * firmware. If able to post the RQE to the RQ it will queue the hbq entry to
1734  * the hbq_buffer_list and return zero, otherwise it will return an error.
1735  **/
1736 static int
1737 lpfc_sli_hbq_to_firmware_s4(struct lpfc_hba *phba, uint32_t hbqno,
1738                             struct hbq_dmabuf *hbq_buf)
1739 {
1740         int rc;
1741         struct lpfc_rqe hrqe;
1742         struct lpfc_rqe drqe;
1743
1744         hrqe.address_lo = putPaddrLow(hbq_buf->hbuf.phys);
1745         hrqe.address_hi = putPaddrHigh(hbq_buf->hbuf.phys);
1746         drqe.address_lo = putPaddrLow(hbq_buf->dbuf.phys);
1747         drqe.address_hi = putPaddrHigh(hbq_buf->dbuf.phys);
1748         rc = lpfc_sli4_rq_put(phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq,
1749                               &hrqe, &drqe);
1750         if (rc < 0)
1751                 return rc;
1752         hbq_buf->tag = rc;
1753         list_add_tail(&hbq_buf->dbuf.list, &phba->hbqs[hbqno].hbq_buffer_list);
1754         return 0;
1755 }
1756
1757 /* HBQ for ELS and CT traffic. */
1758 static struct lpfc_hbq_init lpfc_els_hbq = {
1759         .rn = 1,
1760         .entry_count = 256,
1761         .mask_count = 0,
1762         .profile = 0,
1763         .ring_mask = (1 << LPFC_ELS_RING),
1764         .buffer_count = 0,
1765         .init_count = 40,
1766         .add_count = 40,
1767 };
1768
1769 /* HBQ for the extra ring if needed */
1770 static struct lpfc_hbq_init lpfc_extra_hbq = {
1771         .rn = 1,
1772         .entry_count = 200,
1773         .mask_count = 0,
1774         .profile = 0,
1775         .ring_mask = (1 << LPFC_EXTRA_RING),
1776         .buffer_count = 0,
1777         .init_count = 0,
1778         .add_count = 5,
1779 };
1780
1781 /* Array of HBQs */
1782 struct lpfc_hbq_init *lpfc_hbq_defs[] = {
1783         &lpfc_els_hbq,
1784         &lpfc_extra_hbq,
1785 };
1786
1787 /**
1788  * lpfc_sli_hbqbuf_fill_hbqs - Post more hbq buffers to HBQ
1789  * @phba: Pointer to HBA context object.
1790  * @hbqno: HBQ number.
1791  * @count: Number of HBQ buffers to be posted.
1792  *
1793  * This function is called with no lock held to post more hbq buffers to the
1794  * given HBQ. The function returns the number of HBQ buffers successfully
1795  * posted.
1796  **/
1797 static int
1798 lpfc_sli_hbqbuf_fill_hbqs(struct lpfc_hba *phba, uint32_t hbqno, uint32_t count)
1799 {
1800         uint32_t i, posted = 0;
1801         unsigned long flags;
1802         struct hbq_dmabuf *hbq_buffer;
1803         LIST_HEAD(hbq_buf_list);
1804         if (!phba->hbqs[hbqno].hbq_alloc_buffer)
1805                 return 0;
1806
1807         if ((phba->hbqs[hbqno].buffer_count + count) >
1808             lpfc_hbq_defs[hbqno]->entry_count)
1809                 count = lpfc_hbq_defs[hbqno]->entry_count -
1810                                         phba->hbqs[hbqno].buffer_count;
1811         if (!count)
1812                 return 0;
1813         /* Allocate HBQ entries */
1814         for (i = 0; i < count; i++) {
1815                 hbq_buffer = (phba->hbqs[hbqno].hbq_alloc_buffer)(phba);
1816                 if (!hbq_buffer)
1817                         break;
1818                 list_add_tail(&hbq_buffer->dbuf.list, &hbq_buf_list);
1819         }
1820         /* Check whether HBQ is still in use */
1821         spin_lock_irqsave(&phba->hbalock, flags);
1822         if (!phba->hbq_in_use)
1823                 goto err;
1824         while (!list_empty(&hbq_buf_list)) {
1825                 list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
1826                                  dbuf.list);
1827                 hbq_buffer->tag = (phba->hbqs[hbqno].buffer_count |
1828                                       (hbqno << 16));
1829                 if (!lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {
1830                         phba->hbqs[hbqno].buffer_count++;
1831                         posted++;
1832                 } else
1833                         (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
1834         }
1835         spin_unlock_irqrestore(&phba->hbalock, flags);
1836         return posted;
1837 err:
1838         spin_unlock_irqrestore(&phba->hbalock, flags);
1839         while (!list_empty(&hbq_buf_list)) {
1840                 list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
1841                                  dbuf.list);
1842                 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
1843         }
1844         return 0;
1845 }
1846
1847 /**
1848  * lpfc_sli_hbqbuf_add_hbqs - Post more HBQ buffers to firmware
1849  * @phba: Pointer to HBA context object.
1850  * @qno: HBQ number.
1851  *
1852  * This function posts more buffers to the HBQ. This function
1853  * is called with no lock held. The function returns the number of HBQ entries
1854  * successfully allocated.
1855  **/
1856 int
1857 lpfc_sli_hbqbuf_add_hbqs(struct lpfc_hba *phba, uint32_t qno)
1858 {
1859         if (phba->sli_rev == LPFC_SLI_REV4)
1860                 return 0;
1861         else
1862                 return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
1863                                          lpfc_hbq_defs[qno]->add_count);
1864 }
1865
1866 /**
1867  * lpfc_sli_hbqbuf_init_hbqs - Post initial buffers to the HBQ
1868  * @phba: Pointer to HBA context object.
1869  * @qno:  HBQ queue number.
1870  *
1871  * This function is called from SLI initialization code path with
1872  * no lock held to post initial HBQ buffers to firmware. The
1873  * function returns the number of HBQ entries successfully allocated.
1874  **/
1875 static int
1876 lpfc_sli_hbqbuf_init_hbqs(struct lpfc_hba *phba, uint32_t qno)
1877 {
1878         if (phba->sli_rev == LPFC_SLI_REV4)
1879                 return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
1880                                          lpfc_hbq_defs[qno]->entry_count);
1881         else
1882                 return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
1883                                          lpfc_hbq_defs[qno]->init_count);
1884 }
1885
1886 /**
1887  * lpfc_sli_hbqbuf_get - Remove the first hbq off of an hbq list
1888  * @phba: Pointer to HBA context object.
1889  * @hbqno: HBQ number.
1890  *
1891  * This function removes the first hbq buffer on an hbq list and returns a
1892  * pointer to that buffer. If it finds no buffers on the list it returns NULL.
1893  **/
1894 static struct hbq_dmabuf *
1895 lpfc_sli_hbqbuf_get(struct list_head *rb_list)
1896 {
1897         struct lpfc_dmabuf *d_buf;
1898
1899         list_remove_head(rb_list, d_buf, struct lpfc_dmabuf, list);
1900         if (!d_buf)
1901                 return NULL;
1902         return container_of(d_buf, struct hbq_dmabuf, dbuf);
1903 }
1904
1905 /**
1906  * lpfc_sli_hbqbuf_find - Find the hbq buffer associated with a tag
1907  * @phba: Pointer to HBA context object.
1908  * @tag: Tag of the hbq buffer.
1909  *
1910  * This function is called with hbalock held. This function searches
1911  * for the hbq buffer associated with the given tag in the hbq buffer
1912  * list. If it finds the hbq buffer, it returns the hbq_buffer other wise
1913  * it returns NULL.
1914  **/
1915 static struct hbq_dmabuf *
1916 lpfc_sli_hbqbuf_find(struct lpfc_hba *phba, uint32_t tag)
1917 {
1918         struct lpfc_dmabuf *d_buf;
1919         struct hbq_dmabuf *hbq_buf;
1920         uint32_t hbqno;
1921
1922         hbqno = tag >> 16;
1923         if (hbqno >= LPFC_MAX_HBQS)
1924                 return NULL;
1925
1926         spin_lock_irq(&phba->hbalock);
1927         list_for_each_entry(d_buf, &phba->hbqs[hbqno].hbq_buffer_list, list) {
1928                 hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
1929                 if (hbq_buf->tag == tag) {
1930                         spin_unlock_irq(&phba->hbalock);
1931                         return hbq_buf;
1932                 }
1933         }
1934         spin_unlock_irq(&phba->hbalock);
1935         lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_VPORT,
1936                         "1803 Bad hbq tag. Data: x%x x%x\n",
1937                         tag, phba->hbqs[tag >> 16].buffer_count);
1938         return NULL;
1939 }
1940
1941 /**
1942  * lpfc_sli_free_hbq - Give back the hbq buffer to firmware
1943  * @phba: Pointer to HBA context object.
1944  * @hbq_buffer: Pointer to HBQ buffer.
1945  *
1946  * This function is called with hbalock. This function gives back
1947  * the hbq buffer to firmware. If the HBQ does not have space to
1948  * post the buffer, it will free the buffer.
1949  **/
1950 void
1951 lpfc_sli_free_hbq(struct lpfc_hba *phba, struct hbq_dmabuf *hbq_buffer)
1952 {
1953         uint32_t hbqno;
1954
1955         if (hbq_buffer) {
1956                 hbqno = hbq_buffer->tag >> 16;
1957                 if (lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer))
1958                         (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
1959         }
1960 }
1961
1962 /**
1963  * lpfc_sli_chk_mbx_command - Check if the mailbox is a legitimate mailbox
1964  * @mbxCommand: mailbox command code.
1965  *
1966  * This function is called by the mailbox event handler function to verify
1967  * that the completed mailbox command is a legitimate mailbox command. If the
1968  * completed mailbox is not known to the function, it will return MBX_SHUTDOWN
1969  * and the mailbox event handler will take the HBA offline.
1970  **/
1971 static int
1972 lpfc_sli_chk_mbx_command(uint8_t mbxCommand)
1973 {
1974         uint8_t ret;
1975
1976         switch (mbxCommand) {
1977         case MBX_LOAD_SM:
1978         case MBX_READ_NV:
1979         case MBX_WRITE_NV:
1980         case MBX_WRITE_VPARMS:
1981         case MBX_RUN_BIU_DIAG:
1982         case MBX_INIT_LINK:
1983         case MBX_DOWN_LINK:
1984         case MBX_CONFIG_LINK:
1985         case MBX_CONFIG_RING:
1986         case MBX_RESET_RING:
1987         case MBX_READ_CONFIG:
1988         case MBX_READ_RCONFIG:
1989         case MBX_READ_SPARM:
1990         case MBX_READ_STATUS:
1991         case MBX_READ_RPI:
1992         case MBX_READ_XRI:
1993         case MBX_READ_REV:
1994         case MBX_READ_LNK_STAT:
1995         case MBX_REG_LOGIN:
1996         case MBX_UNREG_LOGIN:
1997         case MBX_CLEAR_LA:
1998         case MBX_DUMP_MEMORY:
1999         case MBX_DUMP_CONTEXT:
2000         case MBX_RUN_DIAGS:
2001         case MBX_RESTART:
2002         case MBX_UPDATE_CFG:
2003         case MBX_DOWN_LOAD:
2004         case MBX_DEL_LD_ENTRY:
2005         case MBX_RUN_PROGRAM:
2006         case MBX_SET_MASK:
2007         case MBX_SET_VARIABLE:
2008         case MBX_UNREG_D_ID:
2009         case MBX_KILL_BOARD:
2010         case MBX_CONFIG_FARP:
2011         case MBX_BEACON:
2012         case MBX_LOAD_AREA:
2013         case MBX_RUN_BIU_DIAG64:
2014         case MBX_CONFIG_PORT:
2015         case MBX_READ_SPARM64:
2016         case MBX_READ_RPI64:
2017         case MBX_REG_LOGIN64:
2018         case MBX_READ_TOPOLOGY:
2019         case MBX_WRITE_WWN:
2020         case MBX_SET_DEBUG:
2021         case MBX_LOAD_EXP_ROM:
2022         case MBX_ASYNCEVT_ENABLE:
2023         case MBX_REG_VPI:
2024         case MBX_UNREG_VPI:
2025         case MBX_HEARTBEAT:
2026         case MBX_PORT_CAPABILITIES:
2027         case MBX_PORT_IOV_CONTROL:
2028         case MBX_SLI4_CONFIG:
2029         case MBX_SLI4_REQ_FTRS:
2030         case MBX_REG_FCFI:
2031         case MBX_UNREG_FCFI:
2032         case MBX_REG_VFI:
2033         case MBX_UNREG_VFI:
2034         case MBX_INIT_VPI:
2035         case MBX_INIT_VFI:
2036         case MBX_RESUME_RPI:
2037         case MBX_READ_EVENT_LOG_STATUS:
2038         case MBX_READ_EVENT_LOG:
2039         case MBX_SECURITY_MGMT:
2040         case MBX_AUTH_PORT:
2041                 ret = mbxCommand;
2042                 break;
2043         default:
2044                 ret = MBX_SHUTDOWN;
2045                 break;
2046         }
2047         return ret;
2048 }
2049
2050 /**
2051  * lpfc_sli_wake_mbox_wait - lpfc_sli_issue_mbox_wait mbox completion handler
2052  * @phba: Pointer to HBA context object.
2053  * @pmboxq: Pointer to mailbox command.
2054  *
2055  * This is completion handler function for mailbox commands issued from
2056  * lpfc_sli_issue_mbox_wait function. This function is called by the
2057  * mailbox event handler function with no lock held. This function
2058  * will wake up thread waiting on the wait queue pointed by context1
2059  * of the mailbox.
2060  **/
2061 void
2062 lpfc_sli_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
2063 {
2064         wait_queue_head_t *pdone_q;
2065         unsigned long drvr_flag;
2066
2067         /*
2068          * If pdone_q is empty, the driver thread gave up waiting and
2069          * continued running.
2070          */
2071         pmboxq->mbox_flag |= LPFC_MBX_WAKE;
2072         spin_lock_irqsave(&phba->hbalock, drvr_flag);
2073         pdone_q = (wait_queue_head_t *) pmboxq->context1;
2074         if (pdone_q)
2075                 wake_up_interruptible(pdone_q);
2076         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
2077         return;
2078 }
2079
2080
2081 /**
2082  * lpfc_sli_def_mbox_cmpl - Default mailbox completion handler
2083  * @phba: Pointer to HBA context object.
2084  * @pmb: Pointer to mailbox object.
2085  *
2086  * This function is the default mailbox completion handler. It
2087  * frees the memory resources associated with the completed mailbox
2088  * command. If the completed command is a REG_LOGIN mailbox command,
2089  * this function will issue a UREG_LOGIN to re-claim the RPI.
2090  **/
2091 void
2092 lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2093 {
2094         struct lpfc_vport  *vport = pmb->vport;
2095         struct lpfc_dmabuf *mp;
2096         struct lpfc_nodelist *ndlp;
2097         struct Scsi_Host *shost;
2098         uint16_t rpi, vpi;
2099         int rc;
2100
2101         mp = (struct lpfc_dmabuf *) (pmb->context1);
2102
2103         if (mp) {
2104                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2105                 kfree(mp);
2106         }
2107
2108         /*
2109          * If a REG_LOGIN succeeded  after node is destroyed or node
2110          * is in re-discovery driver need to cleanup the RPI.
2111          */
2112         if (!(phba->pport->load_flag & FC_UNLOADING) &&
2113             pmb->u.mb.mbxCommand == MBX_REG_LOGIN64 &&
2114             !pmb->u.mb.mbxStatus) {
2115                 rpi = pmb->u.mb.un.varWords[0];
2116                 vpi = pmb->u.mb.un.varRegLogin.vpi - phba->vpi_base;
2117                 lpfc_unreg_login(phba, vpi, rpi, pmb);
2118                 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2119                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
2120                 if (rc != MBX_NOT_FINISHED)
2121                         return;
2122         }
2123
2124         if ((pmb->u.mb.mbxCommand == MBX_REG_VPI) &&
2125                 !(phba->pport->load_flag & FC_UNLOADING) &&
2126                 !pmb->u.mb.mbxStatus) {
2127                 shost = lpfc_shost_from_vport(vport);
2128                 spin_lock_irq(shost->host_lock);
2129                 vport->vpi_state |= LPFC_VPI_REGISTERED;
2130                 vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
2131                 spin_unlock_irq(shost->host_lock);
2132         }
2133
2134         if (pmb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
2135                 ndlp = (struct lpfc_nodelist *)pmb->context2;
2136                 lpfc_nlp_put(ndlp);
2137                 pmb->context2 = NULL;
2138         }
2139
2140         /* Check security permission status on INIT_LINK mailbox command */
2141         if ((pmb->u.mb.mbxCommand == MBX_INIT_LINK) &&
2142             (pmb->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION))
2143                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
2144                                 "2860 SLI authentication is required "
2145                                 "for INIT_LINK but has not done yet\n");
2146
2147         if (bf_get(lpfc_mqe_command, &pmb->u.mqe) == MBX_SLI4_CONFIG)
2148                 lpfc_sli4_mbox_cmd_free(phba, pmb);
2149         else
2150                 mempool_free(pmb, phba->mbox_mem_pool);
2151 }
2152
2153 /**
2154  * lpfc_sli_handle_mb_event - Handle mailbox completions from firmware
2155  * @phba: Pointer to HBA context object.
2156  *
2157  * This function is called with no lock held. This function processes all
2158  * the completed mailbox commands and gives it to upper layers. The interrupt
2159  * service routine processes mailbox completion interrupt and adds completed
2160  * mailbox commands to the mboxq_cmpl queue and signals the worker thread.
2161  * Worker thread call lpfc_sli_handle_mb_event, which will return the
2162  * completed mailbox commands in mboxq_cmpl queue to the upper layers. This
2163  * function returns the mailbox commands to the upper layer by calling the
2164  * completion handler function of each mailbox.
2165  **/
2166 int
2167 lpfc_sli_handle_mb_event(struct lpfc_hba *phba)
2168 {
2169         MAILBOX_t *pmbox;
2170         LPFC_MBOXQ_t *pmb;
2171         int rc;
2172         LIST_HEAD(cmplq);
2173
2174         phba->sli.slistat.mbox_event++;
2175
2176         /* Get all completed mailboxe buffers into the cmplq */
2177         spin_lock_irq(&phba->hbalock);
2178         list_splice_init(&phba->sli.mboxq_cmpl, &cmplq);
2179         spin_unlock_irq(&phba->hbalock);
2180
2181         /* Get a Mailbox buffer to setup mailbox commands for callback */
2182         do {
2183                 list_remove_head(&cmplq, pmb, LPFC_MBOXQ_t, list);
2184                 if (pmb == NULL)
2185                         break;
2186
2187                 pmbox = &pmb->u.mb;
2188
2189                 if (pmbox->mbxCommand != MBX_HEARTBEAT) {
2190                         if (pmb->vport) {
2191                                 lpfc_debugfs_disc_trc(pmb->vport,
2192                                         LPFC_DISC_TRC_MBOX_VPORT,
2193                                         "MBOX cmpl vport: cmd:x%x mb:x%x x%x",
2194                                         (uint32_t)pmbox->mbxCommand,
2195                                         pmbox->un.varWords[0],
2196                                         pmbox->un.varWords[1]);
2197                         }
2198                         else {
2199                                 lpfc_debugfs_disc_trc(phba->pport,
2200                                         LPFC_DISC_TRC_MBOX,
2201                                         "MBOX cmpl:       cmd:x%x mb:x%x x%x",
2202                                         (uint32_t)pmbox->mbxCommand,
2203                                         pmbox->un.varWords[0],
2204                                         pmbox->un.varWords[1]);
2205                         }
2206                 }
2207
2208                 /*
2209                  * It is a fatal error if unknown mbox command completion.
2210                  */
2211                 if (lpfc_sli_chk_mbx_command(pmbox->mbxCommand) ==
2212                     MBX_SHUTDOWN) {
2213                         /* Unknown mailbox command compl */
2214                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
2215                                         "(%d):0323 Unknown Mailbox command "
2216                                         "x%x (x%x) Cmpl\n",
2217                                         pmb->vport ? pmb->vport->vpi : 0,
2218                                         pmbox->mbxCommand,
2219                                         lpfc_sli4_mbox_opcode_get(phba, pmb));
2220                         phba->link_state = LPFC_HBA_ERROR;
2221                         phba->work_hs = HS_FFER3;
2222                         lpfc_handle_eratt(phba);
2223                         continue;
2224                 }
2225
2226                 if (pmbox->mbxStatus) {
2227                         phba->sli.slistat.mbox_stat_err++;
2228                         if (pmbox->mbxStatus == MBXERR_NO_RESOURCES) {
2229                                 /* Mbox cmd cmpl error - RETRYing */
2230                                 lpfc_printf_log(phba, KERN_INFO,
2231                                                 LOG_MBOX | LOG_SLI,
2232                                                 "(%d):0305 Mbox cmd cmpl "
2233                                                 "error - RETRYing Data: x%x "
2234                                                 "(x%x) x%x x%x x%x\n",
2235                                                 pmb->vport ? pmb->vport->vpi :0,
2236                                                 pmbox->mbxCommand,
2237                                                 lpfc_sli4_mbox_opcode_get(phba,
2238                                                                           pmb),
2239                                                 pmbox->mbxStatus,
2240                                                 pmbox->un.varWords[0],
2241                                                 pmb->vport->port_state);
2242                                 pmbox->mbxStatus = 0;
2243                                 pmbox->mbxOwner = OWN_HOST;
2244                                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
2245                                 if (rc != MBX_NOT_FINISHED)
2246                                         continue;
2247                         }
2248                 }
2249
2250                 /* Mailbox cmd <cmd> Cmpl <cmpl> */
2251                 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
2252                                 "(%d):0307 Mailbox cmd x%x (x%x) Cmpl x%p "
2253                                 "Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x\n",
2254                                 pmb->vport ? pmb->vport->vpi : 0,
2255                                 pmbox->mbxCommand,
2256                                 lpfc_sli4_mbox_opcode_get(phba, pmb),
2257                                 pmb->mbox_cmpl,
2258                                 *((uint32_t *) pmbox),
2259                                 pmbox->un.varWords[0],
2260                                 pmbox->un.varWords[1],
2261                                 pmbox->un.varWords[2],
2262                                 pmbox->un.varWords[3],
2263                                 pmbox->un.varWords[4],
2264                                 pmbox->un.varWords[5],
2265                                 pmbox->un.varWords[6],
2266                                 pmbox->un.varWords[7]);
2267
2268                 if (pmb->mbox_cmpl)
2269                         pmb->mbox_cmpl(phba,pmb);
2270         } while (1);
2271         return 0;
2272 }
2273
2274 /**
2275  * lpfc_sli_get_buff - Get the buffer associated with the buffer tag
2276  * @phba: Pointer to HBA context object.
2277  * @pring: Pointer to driver SLI ring object.
2278  * @tag: buffer tag.
2279  *
2280  * This function is called with no lock held. When QUE_BUFTAG_BIT bit
2281  * is set in the tag the buffer is posted for a particular exchange,
2282  * the function will return the buffer without replacing the buffer.
2283  * If the buffer is for unsolicited ELS or CT traffic, this function
2284  * returns the buffer and also posts another buffer to the firmware.
2285  **/
2286 static struct lpfc_dmabuf *
2287 lpfc_sli_get_buff(struct lpfc_hba *phba,
2288                   struct lpfc_sli_ring *pring,
2289                   uint32_t tag)
2290 {
2291         struct hbq_dmabuf *hbq_entry;
2292
2293         if (tag & QUE_BUFTAG_BIT)
2294                 return lpfc_sli_ring_taggedbuf_get(phba, pring, tag);
2295         hbq_entry = lpfc_sli_hbqbuf_find(phba, tag);
2296         if (!hbq_entry)
2297                 return NULL;
2298         return &hbq_entry->dbuf;
2299 }
2300
2301 /**
2302  * lpfc_complete_unsol_iocb - Complete an unsolicited sequence
2303  * @phba: Pointer to HBA context object.
2304  * @pring: Pointer to driver SLI ring object.
2305  * @saveq: Pointer to the iocbq struct representing the sequence starting frame.
2306  * @fch_r_ctl: the r_ctl for the first frame of the sequence.
2307  * @fch_type: the type for the first frame of the sequence.
2308  *
2309  * This function is called with no lock held. This function uses the r_ctl and
2310  * type of the received sequence to find the correct callback function to call
2311  * to process the sequence.
2312  **/
2313 static int
2314 lpfc_complete_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2315                          struct lpfc_iocbq *saveq, uint32_t fch_r_ctl,
2316                          uint32_t fch_type)
2317 {
2318         int i;
2319
2320         /* unSolicited Responses */
2321         if (pring->prt[0].profile) {
2322                 if (pring->prt[0].lpfc_sli_rcv_unsol_event)
2323                         (pring->prt[0].lpfc_sli_rcv_unsol_event) (phba, pring,
2324                                                                         saveq);
2325                 return 1;
2326         }
2327         /* We must search, based on rctl / type
2328            for the right routine */
2329         for (i = 0; i < pring->num_mask; i++) {
2330                 if ((pring->prt[i].rctl == fch_r_ctl) &&
2331                     (pring->prt[i].type == fch_type)) {
2332                         if (pring->prt[i].lpfc_sli_rcv_unsol_event)
2333                                 (pring->prt[i].lpfc_sli_rcv_unsol_event)
2334                                                 (phba, pring, saveq);
2335                         return 1;
2336                 }
2337         }
2338         return 0;
2339 }
2340
2341 /**
2342  * lpfc_sli_process_unsol_iocb - Unsolicited iocb handler
2343  * @phba: Pointer to HBA context object.
2344  * @pring: Pointer to driver SLI ring object.
2345  * @saveq: Pointer to the unsolicited iocb.
2346  *
2347  * This function is called with no lock held by the ring event handler
2348  * when there is an unsolicited iocb posted to the response ring by the
2349  * firmware. This function gets the buffer associated with the iocbs
2350  * and calls the event handler for the ring. This function handles both
2351  * qring buffers and hbq buffers.
2352  * When the function returns 1 the caller can free the iocb object otherwise
2353  * upper layer functions will free the iocb objects.
2354  **/
2355 static int
2356 lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2357                             struct lpfc_iocbq *saveq)
2358 {
2359         IOCB_t           * irsp;
2360         WORD5            * w5p;
2361         uint32_t           Rctl, Type;
2362         uint32_t           match;
2363         struct lpfc_iocbq *iocbq;
2364         struct lpfc_dmabuf *dmzbuf;
2365
2366         match = 0;
2367         irsp = &(saveq->iocb);
2368
2369         if (irsp->ulpCommand == CMD_ASYNC_STATUS) {
2370                 if (pring->lpfc_sli_rcv_async_status)
2371                         pring->lpfc_sli_rcv_async_status(phba, pring, saveq);
2372                 else
2373                         lpfc_printf_log(phba,
2374                                         KERN_WARNING,
2375                                         LOG_SLI,
2376                                         "0316 Ring %d handler: unexpected "
2377                                         "ASYNC_STATUS iocb received evt_code "
2378                                         "0x%x\n",
2379                                         pring->ringno,
2380                                         irsp->un.asyncstat.evt_code);
2381                 return 1;
2382         }
2383
2384         if ((irsp->ulpCommand == CMD_IOCB_RET_XRI64_CX) &&
2385                 (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)) {
2386                 if (irsp->ulpBdeCount > 0) {
2387                         dmzbuf = lpfc_sli_get_buff(phba, pring,
2388                                         irsp->un.ulpWord[3]);
2389                         lpfc_in_buf_free(phba, dmzbuf);
2390                 }
2391
2392                 if (irsp->ulpBdeCount > 1) {
2393                         dmzbuf = lpfc_sli_get_buff(phba, pring,
2394                                         irsp->unsli3.sli3Words[3]);
2395                         lpfc_in_buf_free(phba, dmzbuf);
2396                 }
2397
2398                 if (irsp->ulpBdeCount > 2) {
2399                         dmzbuf = lpfc_sli_get_buff(phba, pring,
2400                                 irsp->unsli3.sli3Words[7]);
2401                         lpfc_in_buf_free(phba, dmzbuf);
2402                 }
2403
2404                 return 1;
2405         }
2406
2407         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
2408                 if (irsp->ulpBdeCount != 0) {
2409                         saveq->context2 = lpfc_sli_get_buff(phba, pring,
2410                                                 irsp->un.ulpWord[3]);
2411                         if (!saveq->context2)
2412                                 lpfc_printf_log(phba,
2413                                         KERN_ERR,
2414                                         LOG_SLI,
2415                                         "0341 Ring %d Cannot find buffer for "
2416                                         "an unsolicited iocb. tag 0x%x\n",
2417                                         pring->ringno,
2418                                         irsp->un.ulpWord[3]);
2419                 }
2420                 if (irsp->ulpBdeCount == 2) {
2421                         saveq->context3 = lpfc_sli_get_buff(phba, pring,
2422                                                 irsp->unsli3.sli3Words[7]);
2423                         if (!saveq->context3)
2424                                 lpfc_printf_log(phba,
2425                                         KERN_ERR,
2426                                         LOG_SLI,
2427                                         "0342 Ring %d Cannot find buffer for an"
2428                                         " unsolicited iocb. tag 0x%x\n",
2429                                         pring->ringno,
2430                                         irsp->unsli3.sli3Words[7]);
2431                 }
2432                 list_for_each_entry(iocbq, &saveq->list, list) {
2433                         irsp = &(iocbq->iocb);
2434                         if (irsp->ulpBdeCount != 0) {
2435                                 iocbq->context2 = lpfc_sli_get_buff(phba, pring,
2436                                                         irsp->un.ulpWord[3]);
2437                                 if (!iocbq->context2)
2438                                         lpfc_printf_log(phba,
2439                                                 KERN_ERR,
2440                                                 LOG_SLI,
2441                                                 "0343 Ring %d Cannot find "
2442                                                 "buffer for an unsolicited iocb"
2443                                                 ". tag 0x%x\n", pring->ringno,
2444                                                 irsp->un.ulpWord[3]);
2445                         }
2446                         if (irsp->ulpBdeCount == 2) {
2447                                 iocbq->context3 = lpfc_sli_get_buff(phba, pring,
2448                                                 irsp->unsli3.sli3Words[7]);
2449                                 if (!iocbq->context3)
2450                                         lpfc_printf_log(phba,
2451                                                 KERN_ERR,
2452                                                 LOG_SLI,
2453                                                 "0344 Ring %d Cannot find "
2454                                                 "buffer for an unsolicited "
2455                                                 "iocb. tag 0x%x\n",
2456                                                 pring->ringno,
2457                                                 irsp->unsli3.sli3Words[7]);
2458                         }
2459                 }
2460         }
2461         if (irsp->ulpBdeCount != 0 &&
2462             (irsp->ulpCommand == CMD_IOCB_RCV_CONT64_CX ||
2463              irsp->ulpStatus == IOSTAT_INTERMED_RSP)) {
2464                 int found = 0;
2465
2466                 /* search continue save q for same XRI */
2467                 list_for_each_entry(iocbq, &pring->iocb_continue_saveq, clist) {
2468                         if (iocbq->iocb.ulpContext == saveq->iocb.ulpContext) {
2469                                 list_add_tail(&saveq->list, &iocbq->list);
2470                                 found = 1;
2471                                 break;
2472                         }
2473                 }
2474                 if (!found)
2475                         list_add_tail(&saveq->clist,
2476                                       &pring->iocb_continue_saveq);
2477                 if (saveq->iocb.ulpStatus != IOSTAT_INTERMED_RSP) {
2478                         list_del_init(&iocbq->clist);
2479                         saveq = iocbq;
2480                         irsp = &(saveq->iocb);
2481                 } else
2482                         return 0;
2483         }
2484         if ((irsp->ulpCommand == CMD_RCV_ELS_REQ64_CX) ||
2485             (irsp->ulpCommand == CMD_RCV_ELS_REQ_CX) ||
2486             (irsp->ulpCommand == CMD_IOCB_RCV_ELS64_CX)) {
2487                 Rctl = FC_RCTL_ELS_REQ;
2488                 Type = FC_TYPE_ELS;
2489         } else {
2490                 w5p = (WORD5 *)&(saveq->iocb.un.ulpWord[5]);
2491                 Rctl = w5p->hcsw.Rctl;
2492                 Type = w5p->hcsw.Type;
2493
2494                 /* Firmware Workaround */
2495                 if ((Rctl == 0) && (pring->ringno == LPFC_ELS_RING) &&
2496                         (irsp->ulpCommand == CMD_RCV_SEQUENCE64_CX ||
2497                          irsp->ulpCommand == CMD_IOCB_RCV_SEQ64_CX)) {
2498                         Rctl = FC_RCTL_ELS_REQ;
2499                         Type = FC_TYPE_ELS;
2500                         w5p->hcsw.Rctl = Rctl;
2501                         w5p->hcsw.Type = Type;
2502                 }
2503         }
2504
2505         if (!lpfc_complete_unsol_iocb(phba, pring, saveq, Rctl, Type))
2506                 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
2507                                 "0313 Ring %d handler: unexpected Rctl x%x "
2508                                 "Type x%x received\n",
2509                                 pring->ringno, Rctl, Type);
2510
2511         return 1;
2512 }
2513
2514 /**
2515  * lpfc_sli_iocbq_lookup - Find command iocb for the given response iocb
2516  * @phba: Pointer to HBA context object.
2517  * @pring: Pointer to driver SLI ring object.
2518  * @prspiocb: Pointer to response iocb object.
2519  *
2520  * This function looks up the iocb_lookup table to get the command iocb
2521  * corresponding to the given response iocb using the iotag of the
2522  * response iocb. This function is called with the hbalock held.
2523  * This function returns the command iocb object if it finds the command
2524  * iocb else returns NULL.
2525  **/
2526 static struct lpfc_iocbq *
2527 lpfc_sli_iocbq_lookup(struct lpfc_hba *phba,
2528                       struct lpfc_sli_ring *pring,
2529                       struct lpfc_iocbq *prspiocb)
2530 {
2531         struct lpfc_iocbq *cmd_iocb = NULL;
2532         uint16_t iotag;
2533
2534         iotag = prspiocb->iocb.ulpIoTag;
2535
2536         if (iotag != 0 && iotag <= phba->sli.last_iotag) {
2537                 cmd_iocb = phba->sli.iocbq_lookup[iotag];
2538                 list_del_init(&cmd_iocb->list);
2539                 if (cmd_iocb->iocb_flag & LPFC_IO_ON_Q) {
2540                         pring->txcmplq_cnt--;
2541                         cmd_iocb->iocb_flag &= ~LPFC_IO_ON_Q;
2542                 }
2543                 return cmd_iocb;
2544         }
2545
2546         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2547                         "0317 iotag x%x is out off "
2548                         "range: max iotag x%x wd0 x%x\n",
2549                         iotag, phba->sli.last_iotag,
2550                         *(((uint32_t *) &prspiocb->iocb) + 7));
2551         return NULL;
2552 }
2553
2554 /**
2555  * lpfc_sli_iocbq_lookup_by_tag - Find command iocb for the iotag
2556  * @phba: Pointer to HBA context object.
2557  * @pring: Pointer to driver SLI ring object.
2558  * @iotag: IOCB tag.
2559  *
2560  * This function looks up the iocb_lookup table to get the command iocb
2561  * corresponding to the given iotag. This function is called with the
2562  * hbalock held.
2563  * This function returns the command iocb object if it finds the command
2564  * iocb else returns NULL.
2565  **/
2566 static struct lpfc_iocbq *
2567 lpfc_sli_iocbq_lookup_by_tag(struct lpfc_hba *phba,
2568                              struct lpfc_sli_ring *pring, uint16_t iotag)
2569 {
2570         struct lpfc_iocbq *cmd_iocb;
2571
2572         if (iotag != 0 && iotag <= phba->sli.last_iotag) {
2573                 cmd_iocb = phba->sli.iocbq_lookup[iotag];
2574                 list_del_init(&cmd_iocb->list);
2575                 if (cmd_iocb->iocb_flag & LPFC_IO_ON_Q) {
2576                         cmd_iocb->iocb_flag &= ~LPFC_IO_ON_Q;
2577                         pring->txcmplq_cnt--;
2578                 }
2579                 return cmd_iocb;
2580         }
2581
2582         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2583                         "0372 iotag x%x is out off range: max iotag (x%x)\n",
2584                         iotag, phba->sli.last_iotag);
2585         return NULL;
2586 }
2587
2588 /**
2589  * lpfc_sli_process_sol_iocb - process solicited iocb completion
2590  * @phba: Pointer to HBA context object.
2591  * @pring: Pointer to driver SLI ring object.
2592  * @saveq: Pointer to the response iocb to be processed.
2593  *
2594  * This function is called by the ring event handler for non-fcp
2595  * rings when there is a new response iocb in the response ring.
2596  * The caller is not required to hold any locks. This function
2597  * gets the command iocb associated with the response iocb and
2598  * calls the completion handler for the command iocb. If there
2599  * is no completion handler, the function will free the resources
2600  * associated with command iocb. If the response iocb is for
2601  * an already aborted command iocb, the status of the completion
2602  * is changed to IOSTAT_LOCAL_REJECT/IOERR_SLI_ABORTED.
2603  * This function always returns 1.
2604  **/
2605 static int
2606 lpfc_sli_process_sol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2607                           struct lpfc_iocbq *saveq)
2608 {
2609         struct lpfc_iocbq *cmdiocbp;
2610         int rc = 1;
2611         unsigned long iflag;
2612
2613         /* Based on the iotag field, get the cmd IOCB from the txcmplq */
2614         spin_lock_irqsave(&phba->hbalock, iflag);
2615         cmdiocbp = lpfc_sli_iocbq_lookup(phba, pring, saveq);
2616         spin_unlock_irqrestore(&phba->hbalock, iflag);
2617
2618         if (cmdiocbp) {
2619                 if (cmdiocbp->iocb_cmpl) {
2620                         /*
2621                          * If an ELS command failed send an event to mgmt
2622                          * application.
2623                          */
2624                         if (saveq->iocb.ulpStatus &&
2625                              (pring->ringno == LPFC_ELS_RING) &&
2626                              (cmdiocbp->iocb.ulpCommand ==
2627                                 CMD_ELS_REQUEST64_CR))
2628                                 lpfc_send_els_failure_event(phba,
2629                                         cmdiocbp, saveq);
2630
2631                         /*
2632                          * Post all ELS completions to the worker thread.
2633                          * All other are passed to the completion callback.
2634                          */
2635                         if (pring->ringno == LPFC_ELS_RING) {
2636                                 if ((phba->sli_rev < LPFC_SLI_REV4) &&
2637                                     (cmdiocbp->iocb_flag &
2638                                                         LPFC_DRIVER_ABORTED)) {
2639                                         spin_lock_irqsave(&phba->hbalock,
2640                                                           iflag);
2641                                         cmdiocbp->iocb_flag &=
2642                                                 ~LPFC_DRIVER_ABORTED;
2643                                         spin_unlock_irqrestore(&phba->hbalock,
2644                                                                iflag);
2645                                         saveq->iocb.ulpStatus =
2646                                                 IOSTAT_LOCAL_REJECT;
2647                                         saveq->iocb.un.ulpWord[4] =
2648                                                 IOERR_SLI_ABORTED;
2649
2650                                         /* Firmware could still be in progress
2651                                          * of DMAing payload, so don't free data
2652                                          * buffer till after a hbeat.
2653                                          */
2654                                         spin_lock_irqsave(&phba->hbalock,
2655                                                           iflag);
2656                                         saveq->iocb_flag |= LPFC_DELAY_MEM_FREE;
2657                                         spin_unlock_irqrestore(&phba->hbalock,
2658                                                                iflag);
2659                                 }
2660                                 if (phba->sli_rev == LPFC_SLI_REV4) {
2661                                         if (saveq->iocb_flag &
2662                                             LPFC_EXCHANGE_BUSY) {
2663                                                 /* Set cmdiocb flag for the
2664                                                  * exchange busy so sgl (xri)
2665                                                  * will not be released until
2666                                                  * the abort xri is received
2667                                                  * from hba.
2668                                                  */
2669                                                 spin_lock_irqsave(
2670                                                         &phba->hbalock, iflag);
2671                                                 cmdiocbp->iocb_flag |=
2672                                                         LPFC_EXCHANGE_BUSY;
2673                                                 spin_unlock_irqrestore(
2674                                                         &phba->hbalock, iflag);
2675                                         }
2676                                         if (cmdiocbp->iocb_flag &
2677                                             LPFC_DRIVER_ABORTED) {
2678                                                 /*
2679                                                  * Clear LPFC_DRIVER_ABORTED
2680                                                  * bit in case it was driver
2681                                                  * initiated abort.
2682                                                  */
2683                                                 spin_lock_irqsave(
2684                                                         &phba->hbalock, iflag);
2685                                                 cmdiocbp->iocb_flag &=
2686                                                         ~LPFC_DRIVER_ABORTED;
2687                                                 spin_unlock_irqrestore(
2688                                                         &phba->hbalock, iflag);
2689                                                 cmdiocbp->iocb.ulpStatus =
2690                                                         IOSTAT_LOCAL_REJECT;
2691                                                 cmdiocbp->iocb.un.ulpWord[4] =
2692                                                         IOERR_ABORT_REQUESTED;
2693                                                 /*
2694                                                  * For SLI4, irsiocb contains
2695                                                  * NO_XRI in sli_xritag, it
2696                                                  * shall not affect releasing
2697                                                  * sgl (xri) process.
2698                                                  */
2699                                                 saveq->iocb.ulpStatus =
2700                                                         IOSTAT_LOCAL_REJECT;
2701                                                 saveq->iocb.un.ulpWord[4] =
2702                                                         IOERR_SLI_ABORTED;
2703                                                 spin_lock_irqsave(
2704                                                         &phba->hbalock, iflag);
2705                                                 saveq->iocb_flag |=
2706                                                         LPFC_DELAY_MEM_FREE;
2707                                                 spin_unlock_irqrestore(
2708                                                         &phba->hbalock, iflag);
2709                                         }
2710                                 }
2711                         }
2712                         (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
2713                 } else
2714                         lpfc_sli_release_iocbq(phba, cmdiocbp);
2715         } else {
2716                 /*
2717                  * Unknown initiating command based on the response iotag.
2718                  * This could be the case on the ELS ring because of
2719                  * lpfc_els_abort().
2720                  */
2721                 if (pring->ringno != LPFC_ELS_RING) {
2722                         /*
2723                          * Ring <ringno> handler: unexpected completion IoTag
2724                          * <IoTag>
2725                          */
2726                         lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
2727                                          "0322 Ring %d handler: "
2728                                          "unexpected completion IoTag x%x "
2729                                          "Data: x%x x%x x%x x%x\n",
2730                                          pring->ringno,
2731                                          saveq->iocb.ulpIoTag,
2732                                          saveq->iocb.ulpStatus,
2733                                          saveq->iocb.un.ulpWord[4],
2734                                          saveq->iocb.ulpCommand,
2735                                          saveq->iocb.ulpContext);
2736                 }
2737         }
2738
2739         return rc;
2740 }
2741
2742 /**
2743  * lpfc_sli_rsp_pointers_error - Response ring pointer error handler
2744  * @phba: Pointer to HBA context object.
2745  * @pring: Pointer to driver SLI ring object.
2746  *
2747  * This function is called from the iocb ring event handlers when
2748  * put pointer is ahead of the get pointer for a ring. This function signal
2749  * an error attention condition to the worker thread and the worker
2750  * thread will transition the HBA to offline state.
2751  **/
2752 static void
2753 lpfc_sli_rsp_pointers_error(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
2754 {
2755         struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
2756         /*
2757          * Ring <ringno> handler: portRspPut <portRspPut> is bigger than
2758          * rsp ring <portRspMax>
2759          */
2760         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2761                         "0312 Ring %d handler: portRspPut %d "
2762                         "is bigger than rsp ring %d\n",
2763                         pring->ringno, le32_to_cpu(pgp->rspPutInx),
2764                         pring->numRiocb);
2765
2766         phba->link_state = LPFC_HBA_ERROR;
2767
2768         /*
2769          * All error attention handlers are posted to
2770          * worker thread
2771          */
2772         phba->work_ha |= HA_ERATT;
2773         phba->work_hs = HS_FFER3;
2774
2775         lpfc_worker_wake_up(phba);
2776
2777         return;
2778 }
2779
2780 /**
2781  * lpfc_poll_eratt - Error attention polling timer timeout handler
2782  * @ptr: Pointer to address of HBA context object.
2783  *
2784  * This function is invoked by the Error Attention polling timer when the
2785  * timer times out. It will check the SLI Error Attention register for
2786  * possible attention events. If so, it will post an Error Attention event
2787  * and wake up worker thread to process it. Otherwise, it will set up the
2788  * Error Attention polling timer for the next poll.
2789  **/
2790 void lpfc_poll_eratt(unsigned long ptr)
2791 {
2792         struct lpfc_hba *phba;
2793         uint32_t eratt = 0;
2794
2795         phba = (struct lpfc_hba *)ptr;
2796
2797         /* Check chip HA register for error event */
2798         eratt = lpfc_sli_check_eratt(phba);
2799
2800         if (eratt)
2801                 /* Tell the worker thread there is work to do */
2802                 lpfc_worker_wake_up(phba);
2803         else
2804                 /* Restart the timer for next eratt poll */
2805                 mod_timer(&phba->eratt_poll, jiffies +
2806                                         HZ * LPFC_ERATT_POLL_INTERVAL);
2807         return;
2808 }
2809
2810
2811 /**
2812  * lpfc_sli_handle_fast_ring_event - Handle ring events on FCP ring
2813  * @phba: Pointer to HBA context object.
2814  * @pring: Pointer to driver SLI ring object.
2815  * @mask: Host attention register mask for this ring.
2816  *
2817  * This function is called from the interrupt context when there is a ring
2818  * event for the fcp ring. The caller does not hold any lock.
2819  * The function processes each response iocb in the response ring until it
2820  * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
2821  * LE bit set. The function will call the completion handler of the command iocb
2822  * if the response iocb indicates a completion for a command iocb or it is
2823  * an abort completion. The function will call lpfc_sli_process_unsol_iocb
2824  * function if this is an unsolicited iocb.
2825  * This routine presumes LPFC_FCP_RING handling and doesn't bother
2826  * to check it explicitly.
2827  */
2828 int
2829 lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
2830                                 struct lpfc_sli_ring *pring, uint32_t mask)
2831 {
2832         struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
2833         IOCB_t *irsp = NULL;
2834         IOCB_t *entry = NULL;
2835         struct lpfc_iocbq *cmdiocbq = NULL;
2836         struct lpfc_iocbq rspiocbq;
2837         uint32_t status;
2838         uint32_t portRspPut, portRspMax;
2839         int rc = 1;
2840         lpfc_iocb_type type;
2841         unsigned long iflag;
2842         uint32_t rsp_cmpl = 0;
2843
2844         spin_lock_irqsave(&phba->hbalock, iflag);
2845         pring->stats.iocb_event++;
2846
2847         /*
2848          * The next available response entry should never exceed the maximum
2849          * entries.  If it does, treat it as an adapter hardware error.
2850          */
2851         portRspMax = pring->numRiocb;
2852         portRspPut = le32_to_cpu(pgp->rspPutInx);
2853         if (unlikely(portRspPut >= portRspMax)) {
2854                 lpfc_sli_rsp_pointers_error(phba, pring);
2855                 spin_unlock_irqrestore(&phba->hbalock, iflag);
2856                 return 1;
2857         }
2858         if (phba->fcp_ring_in_use) {
2859                 spin_unlock_irqrestore(&phba->hbalock, iflag);
2860                 return 1;
2861         } else
2862                 phba->fcp_ring_in_use = 1;
2863
2864         rmb();
2865         while (pring->rspidx != portRspPut) {
2866                 /*
2867                  * Fetch an entry off the ring and copy it into a local data
2868                  * structure.  The copy involves a byte-swap since the
2869                  * network byte order and pci byte orders are different.
2870                  */
2871                 entry = lpfc_resp_iocb(phba, pring);
2872                 phba->last_completion_time = jiffies;
2873
2874                 if (++pring->rspidx >= portRspMax)
2875                         pring->rspidx = 0;
2876
2877                 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
2878                                       (uint32_t *) &rspiocbq.iocb,
2879                                       phba->iocb_rsp_size);
2880                 INIT_LIST_HEAD(&(rspiocbq.list));
2881                 irsp = &rspiocbq.iocb;
2882
2883                 type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
2884                 pring->stats.iocb_rsp++;
2885                 rsp_cmpl++;
2886
2887                 if (unlikely(irsp->ulpStatus)) {
2888                         /*
2889                          * If resource errors reported from HBA, reduce
2890                          * queuedepths of the SCSI device.
2891                          */
2892                         if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
2893                                 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
2894                                 spin_unlock_irqrestore(&phba->hbalock, iflag);
2895                                 phba->lpfc_rampdown_queue_depth(phba);
2896                                 spin_lock_irqsave(&phba->hbalock, iflag);
2897                         }
2898
2899                         /* Rsp ring <ringno> error: IOCB */
2900                         lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
2901                                         "0336 Rsp Ring %d error: IOCB Data: "
2902                                         "x%x x%x x%x x%x x%x x%x x%x x%x\n",
2903                                         pring->ringno,
2904                                         irsp->un.ulpWord[0],
2905                                         irsp->un.ulpWord[1],
2906                                         irsp->un.ulpWord[2],
2907                                         irsp->un.ulpWord[3],
2908                                         irsp->un.ulpWord[4],
2909                                         irsp->un.ulpWord[5],
2910                                         *(uint32_t *)&irsp->un1,
2911                                         *((uint32_t *)&irsp->un1 + 1));
2912                 }
2913
2914                 switch (type) {
2915                 case LPFC_ABORT_IOCB:
2916                 case LPFC_SOL_IOCB:
2917                         /*
2918                          * Idle exchange closed via ABTS from port.  No iocb
2919                          * resources need to be recovered.
2920                          */
2921                         if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
2922                                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2923                                                 "0333 IOCB cmd 0x%x"
2924                                                 " processed. Skipping"
2925                                                 " completion\n",
2926                                                 irsp->ulpCommand);
2927                                 break;
2928                         }
2929
2930                         cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
2931                                                          &rspiocbq);
2932                         if (unlikely(!cmdiocbq))
2933                                 break;
2934                         if (cmdiocbq->iocb_flag & LPFC_DRIVER_ABORTED)
2935                                 cmdiocbq->iocb_flag &= ~LPFC_DRIVER_ABORTED;
2936                         if (cmdiocbq->iocb_cmpl) {
2937                                 spin_unlock_irqrestore(&phba->hbalock, iflag);
2938                                 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
2939                                                       &rspiocbq);
2940                                 spin_lock_irqsave(&phba->hbalock, iflag);
2941                         }
2942                         break;
2943                 case LPFC_UNSOL_IOCB:
2944                         spin_unlock_irqrestore(&phba->hbalock, iflag);
2945                         lpfc_sli_process_unsol_iocb(phba, pring, &rspiocbq);
2946                         spin_lock_irqsave(&phba->hbalock, iflag);
2947                         break;
2948                 default:
2949                         if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
2950                                 char adaptermsg[LPFC_MAX_ADPTMSG];
2951                                 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
2952                                 memcpy(&adaptermsg[0], (uint8_t *) irsp,
2953                                        MAX_MSG_DATA);
2954                                 dev_warn(&((phba->pcidev)->dev),
2955                                          "lpfc%d: %s\n",
2956                                          phba->brd_no, adaptermsg);
2957                         } else {
2958                                 /* Unknown IOCB command */
2959                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2960                                                 "0334 Unknown IOCB command "
2961                                                 "Data: x%x, x%x x%x x%x x%x\n",
2962                                                 type, irsp->ulpCommand,
2963                                                 irsp->ulpStatus,
2964                                                 irsp->ulpIoTag,
2965                                                 irsp->ulpContext);
2966                         }
2967                         break;
2968                 }
2969
2970                 /*
2971                  * The response IOCB has been processed.  Update the ring
2972                  * pointer in SLIM.  If the port response put pointer has not
2973                  * been updated, sync the pgp->rspPutInx and fetch the new port
2974                  * response put pointer.
2975                  */
2976                 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
2977
2978                 if (pring->rspidx == portRspPut)
2979                         portRspPut = le32_to_cpu(pgp->rspPutInx);
2980         }
2981
2982         if ((rsp_cmpl > 0) && (mask & HA_R0RE_REQ)) {
2983                 pring->stats.iocb_rsp_full++;
2984                 status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
2985                 writel(status, phba->CAregaddr);
2986                 readl(phba->CAregaddr);
2987         }
2988         if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
2989                 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
2990                 pring->stats.iocb_cmd_empty++;
2991
2992                 /* Force update of the local copy of cmdGetInx */
2993                 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
2994                 lpfc_sli_resume_iocb(phba, pring);
2995
2996                 if ((pring->lpfc_sli_cmd_available))
2997                         (pring->lpfc_sli_cmd_available) (phba, pring);
2998