]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - drivers/scsi/lpfc/lpfc_sli.c
764aadbec71b5096ea5320e0a35eef35b8c2b70e
[linux-2.6.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-2006 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
27 #include <scsi/scsi.h>
28 #include <scsi/scsi_cmnd.h>
29 #include <scsi/scsi_device.h>
30 #include <scsi/scsi_host.h>
31 #include <scsi/scsi_transport_fc.h>
32
33 #include "lpfc_hw.h"
34 #include "lpfc_sli.h"
35 #include "lpfc_disc.h"
36 #include "lpfc_scsi.h"
37 #include "lpfc.h"
38 #include "lpfc_crtn.h"
39 #include "lpfc_logmsg.h"
40 #include "lpfc_compat.h"
41
42 /*
43  * Define macro to log: Mailbox command x%x cannot issue Data
44  * This allows multiple uses of lpfc_msgBlk0311
45  * w/o perturbing log msg utility.
46  */
47 #define LOG_MBOX_CANNOT_ISSUE_DATA( phba, mb, psli, flag) \
48                         lpfc_printf_log(phba, \
49                                 KERN_INFO, \
50                                 LOG_MBOX | LOG_SLI, \
51                                 "%d:0311 Mailbox command x%x cannot issue " \
52                                 "Data: x%x x%x x%x\n", \
53                                 phba->brd_no, \
54                                 mb->mbxCommand,         \
55                                 phba->hba_state,        \
56                                 psli->sli_flag, \
57                                 flag);
58
59
60 /* There are only four IOCB completion types. */
61 typedef enum _lpfc_iocb_type {
62         LPFC_UNKNOWN_IOCB,
63         LPFC_UNSOL_IOCB,
64         LPFC_SOL_IOCB,
65         LPFC_ABORT_IOCB
66 } lpfc_iocb_type;
67
68 struct lpfc_iocbq *
69 lpfc_sli_get_iocbq(struct lpfc_hba * phba)
70 {
71         struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
72         struct lpfc_iocbq * iocbq = NULL;
73
74         list_remove_head(lpfc_iocb_list, iocbq, struct lpfc_iocbq, list);
75         return iocbq;
76 }
77
78 void
79 lpfc_sli_release_iocbq(struct lpfc_hba * phba, struct lpfc_iocbq * iocbq)
80 {
81         size_t start_clean = (size_t)(&((struct lpfc_iocbq *)NULL)->iocb);
82
83         /*
84          * Clean all volatile data fields, preserve iotag and node struct.
85          */
86         memset((char*)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean);
87         list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
88 }
89
90 /*
91  * Translate the iocb command to an iocb command type used to decide the final
92  * disposition of each completed IOCB.
93  */
94 static lpfc_iocb_type
95 lpfc_sli_iocb_cmd_type(uint8_t iocb_cmnd)
96 {
97         lpfc_iocb_type type = LPFC_UNKNOWN_IOCB;
98
99         if (iocb_cmnd > CMD_MAX_IOCB_CMD)
100                 return 0;
101
102         switch (iocb_cmnd) {
103         case CMD_XMIT_SEQUENCE_CR:
104         case CMD_XMIT_SEQUENCE_CX:
105         case CMD_XMIT_BCAST_CN:
106         case CMD_XMIT_BCAST_CX:
107         case CMD_ELS_REQUEST_CR:
108         case CMD_ELS_REQUEST_CX:
109         case CMD_CREATE_XRI_CR:
110         case CMD_CREATE_XRI_CX:
111         case CMD_GET_RPI_CN:
112         case CMD_XMIT_ELS_RSP_CX:
113         case CMD_GET_RPI_CR:
114         case CMD_FCP_IWRITE_CR:
115         case CMD_FCP_IWRITE_CX:
116         case CMD_FCP_IREAD_CR:
117         case CMD_FCP_IREAD_CX:
118         case CMD_FCP_ICMND_CR:
119         case CMD_FCP_ICMND_CX:
120         case CMD_ADAPTER_MSG:
121         case CMD_ADAPTER_DUMP:
122         case CMD_XMIT_SEQUENCE64_CR:
123         case CMD_XMIT_SEQUENCE64_CX:
124         case CMD_XMIT_BCAST64_CN:
125         case CMD_XMIT_BCAST64_CX:
126         case CMD_ELS_REQUEST64_CR:
127         case CMD_ELS_REQUEST64_CX:
128         case CMD_FCP_IWRITE64_CR:
129         case CMD_FCP_IWRITE64_CX:
130         case CMD_FCP_IREAD64_CR:
131         case CMD_FCP_IREAD64_CX:
132         case CMD_FCP_ICMND64_CR:
133         case CMD_FCP_ICMND64_CX:
134         case CMD_GEN_REQUEST64_CR:
135         case CMD_GEN_REQUEST64_CX:
136         case CMD_XMIT_ELS_RSP64_CX:
137                 type = LPFC_SOL_IOCB;
138                 break;
139         case CMD_ABORT_XRI_CN:
140         case CMD_ABORT_XRI_CX:
141         case CMD_CLOSE_XRI_CN:
142         case CMD_CLOSE_XRI_CX:
143         case CMD_XRI_ABORTED_CX:
144         case CMD_ABORT_MXRI64_CN:
145                 type = LPFC_ABORT_IOCB;
146                 break;
147         case CMD_RCV_SEQUENCE_CX:
148         case CMD_RCV_ELS_REQ_CX:
149         case CMD_RCV_SEQUENCE64_CX:
150         case CMD_RCV_ELS_REQ64_CX:
151                 type = LPFC_UNSOL_IOCB;
152                 break;
153         default:
154                 type = LPFC_UNKNOWN_IOCB;
155                 break;
156         }
157
158         return type;
159 }
160
161 static int
162 lpfc_sli_ring_map(struct lpfc_hba * phba, LPFC_MBOXQ_t *pmb)
163 {
164         struct lpfc_sli *psli = &phba->sli;
165         MAILBOX_t *pmbox = &pmb->mb;
166         int i, rc;
167
168         for (i = 0; i < psli->num_rings; i++) {
169                 phba->hba_state = LPFC_INIT_MBX_CMDS;
170                 lpfc_config_ring(phba, i, pmb);
171                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
172                 if (rc != MBX_SUCCESS) {
173                         lpfc_printf_log(phba,
174                                         KERN_ERR,
175                                         LOG_INIT,
176                                         "%d:0446 Adapter failed to init, "
177                                         "mbxCmd x%x CFG_RING, mbxStatus x%x, "
178                                         "ring %d\n",
179                                         phba->brd_no,
180                                         pmbox->mbxCommand,
181                                         pmbox->mbxStatus,
182                                         i);
183                         phba->hba_state = LPFC_HBA_ERROR;
184                         return -ENXIO;
185                 }
186         }
187         return 0;
188 }
189
190 static int
191 lpfc_sli_ringtxcmpl_put(struct lpfc_hba * phba,
192                         struct lpfc_sli_ring * pring, struct lpfc_iocbq * piocb)
193 {
194         uint16_t iotag;
195
196         list_add_tail(&piocb->list, &pring->txcmplq);
197         pring->txcmplq_cnt++;
198         if (unlikely(pring->ringno == LPFC_ELS_RING))
199                 mod_timer(&phba->els_tmofunc,
200                                         jiffies + HZ * (phba->fc_ratov << 1));
201
202         if (pring->fast_lookup) {
203                 /* Setup fast lookup based on iotag for completion */
204                 iotag = piocb->iocb.ulpIoTag;
205                 if (iotag && (iotag < pring->fast_iotag))
206                         *(pring->fast_lookup + iotag) = piocb;
207                 else {
208
209                         /* Cmd ring <ringno> put: iotag <iotag> greater then
210                            configured max <fast_iotag> wd0 <icmd> */
211                         lpfc_printf_log(phba,
212                                         KERN_ERR,
213                                         LOG_SLI,
214                                         "%d:0316 Cmd ring %d put: iotag x%x "
215                                         "greater then configured max x%x "
216                                         "wd0 x%x\n",
217                                         phba->brd_no,
218                                         pring->ringno, iotag,
219                                         pring->fast_iotag,
220                                         *(((uint32_t *)(&piocb->iocb)) + 7));
221                 }
222         }
223         return (0);
224 }
225
226 static struct lpfc_iocbq *
227 lpfc_sli_ringtx_get(struct lpfc_hba * phba, struct lpfc_sli_ring * pring)
228 {
229         struct list_head *dlp;
230         struct lpfc_iocbq *cmd_iocb;
231
232         dlp = &pring->txq;
233         cmd_iocb = NULL;
234         list_remove_head((&pring->txq), cmd_iocb,
235                          struct lpfc_iocbq,
236                          list);
237         if (cmd_iocb) {
238                 /* If the first ptr is not equal to the list header,
239                  * deque the IOCBQ_t and return it.
240                  */
241                 pring->txq_cnt--;
242         }
243         return (cmd_iocb);
244 }
245
246 static IOCB_t *
247 lpfc_sli_next_iocb_slot (struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
248 {
249         struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno];
250         uint32_t  max_cmd_idx = pring->numCiocb;
251         IOCB_t *iocb = NULL;
252
253         if ((pring->next_cmdidx == pring->cmdidx) &&
254            (++pring->next_cmdidx >= max_cmd_idx))
255                 pring->next_cmdidx = 0;
256
257         if (unlikely(pring->local_getidx == pring->next_cmdidx)) {
258
259                 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
260
261                 if (unlikely(pring->local_getidx >= max_cmd_idx)) {
262                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
263                                         "%d:0315 Ring %d issue: portCmdGet %d "
264                                         "is bigger then cmd ring %d\n",
265                                         phba->brd_no, pring->ringno,
266                                         pring->local_getidx, max_cmd_idx);
267
268                         phba->hba_state = LPFC_HBA_ERROR;
269                         /*
270                          * All error attention handlers are posted to
271                          * worker thread
272                          */
273                         phba->work_ha |= HA_ERATT;
274                         phba->work_hs = HS_FFER3;
275                         if (phba->work_wait)
276                                 wake_up(phba->work_wait);
277
278                         return NULL;
279                 }
280
281                 if (pring->local_getidx == pring->next_cmdidx)
282                         return NULL;
283         }
284
285         iocb = IOCB_ENTRY(pring->cmdringaddr, pring->cmdidx);
286
287         return iocb;
288 }
289
290 uint16_t
291 lpfc_sli_next_iotag(struct lpfc_hba * phba, struct lpfc_iocbq * iocbq)
292 {
293         struct lpfc_iocbq ** new_arr;
294         struct lpfc_iocbq ** old_arr;
295         size_t new_len;
296         struct lpfc_sli *psli = &phba->sli;
297         uint16_t iotag;
298
299         spin_lock_irq(phba->host->host_lock);
300         iotag = psli->last_iotag;
301         if(++iotag < psli->iocbq_lookup_len) {
302                 psli->last_iotag = iotag;
303                 psli->iocbq_lookup[iotag] = iocbq;
304                 spin_unlock_irq(phba->host->host_lock);
305                 iocbq->iotag = iotag;
306                 return iotag;
307         }
308         else if (psli->iocbq_lookup_len < (0xffff
309                                            - LPFC_IOCBQ_LOOKUP_INCREMENT)) {
310                 new_len = psli->iocbq_lookup_len + LPFC_IOCBQ_LOOKUP_INCREMENT;
311                 spin_unlock_irq(phba->host->host_lock);
312                 new_arr = kmalloc(new_len * sizeof (struct lpfc_iocbq *),
313                                   GFP_KERNEL);
314                 if (new_arr) {
315                         memset((char *)new_arr, 0,
316                                new_len * sizeof (struct lpfc_iocbq *));
317                         spin_lock_irq(phba->host->host_lock);
318                         old_arr = psli->iocbq_lookup;
319                         if (new_len <= psli->iocbq_lookup_len) {
320                                 /* highly unprobable case */
321                                 kfree(new_arr);
322                                 iotag = psli->last_iotag;
323                                 if(++iotag < psli->iocbq_lookup_len) {
324                                         psli->last_iotag = iotag;
325                                         psli->iocbq_lookup[iotag] = iocbq;
326                                         spin_unlock_irq(phba->host->host_lock);
327                                         iocbq->iotag = iotag;
328                                         return iotag;
329                                 }
330                                 spin_unlock_irq(phba->host->host_lock);
331                                 return 0;
332                         }
333                         if (psli->iocbq_lookup)
334                                 memcpy(new_arr, old_arr,
335                                        ((psli->last_iotag  + 1) *
336                                         sizeof (struct lpfc_iocbq *)));
337                         psli->iocbq_lookup = new_arr;
338                         psli->iocbq_lookup_len = new_len;
339                         psli->last_iotag = iotag;
340                         psli->iocbq_lookup[iotag] = iocbq;
341                         spin_unlock_irq(phba->host->host_lock);
342                         iocbq->iotag = iotag;
343                         kfree(old_arr);
344                         return iotag;
345                 }
346         }
347
348         lpfc_printf_log(phba, KERN_ERR,LOG_SLI,
349                         "%d:0318 Failed to allocate IOTAG.last IOTAG is %d\n",
350                         phba->brd_no, psli->last_iotag);
351
352         return 0;
353 }
354
355 static void
356 lpfc_sli_submit_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
357                 IOCB_t *iocb, struct lpfc_iocbq *nextiocb)
358 {
359         /*
360          * Set up an iotag
361          */
362         nextiocb->iocb.ulpIoTag = (nextiocb->iocb_cmpl) ? nextiocb->iotag : 0;
363
364         /*
365          * Issue iocb command to adapter
366          */
367         lpfc_sli_pcimem_bcopy(&nextiocb->iocb, iocb, sizeof (IOCB_t));
368         wmb();
369         pring->stats.iocb_cmd++;
370
371         /*
372          * If there is no completion routine to call, we can release the
373          * IOCB buffer back right now. For IOCBs, like QUE_RING_BUF,
374          * that have no rsp ring completion, iocb_cmpl MUST be NULL.
375          */
376         if (nextiocb->iocb_cmpl)
377                 lpfc_sli_ringtxcmpl_put(phba, pring, nextiocb);
378         else
379                 lpfc_sli_release_iocbq(phba, nextiocb);
380
381         /*
382          * Let the HBA know what IOCB slot will be the next one the
383          * driver will put a command into.
384          */
385         pring->cmdidx = pring->next_cmdidx;
386         writel(pring->cmdidx, phba->MBslimaddr
387                + (SLIMOFF + (pring->ringno * 2)) * 4);
388 }
389
390 static void
391 lpfc_sli_update_full_ring(struct lpfc_hba * phba,
392                           struct lpfc_sli_ring *pring)
393 {
394         int ringno = pring->ringno;
395
396         pring->flag |= LPFC_CALL_RING_AVAILABLE;
397
398         wmb();
399
400         /*
401          * Set ring 'ringno' to SET R0CE_REQ in Chip Att register.
402          * The HBA will tell us when an IOCB entry is available.
403          */
404         writel((CA_R0ATT|CA_R0CE_REQ) << (ringno*4), phba->CAregaddr);
405         readl(phba->CAregaddr); /* flush */
406
407         pring->stats.iocb_cmd_full++;
408 }
409
410 static void
411 lpfc_sli_update_ring(struct lpfc_hba * phba,
412                      struct lpfc_sli_ring *pring)
413 {
414         int ringno = pring->ringno;
415
416         /*
417          * Tell the HBA that there is work to do in this ring.
418          */
419         wmb();
420         writel(CA_R0ATT << (ringno * 4), phba->CAregaddr);
421         readl(phba->CAregaddr); /* flush */
422 }
423
424 static void
425 lpfc_sli_resume_iocb(struct lpfc_hba * phba, struct lpfc_sli_ring * pring)
426 {
427         IOCB_t *iocb;
428         struct lpfc_iocbq *nextiocb;
429
430         /*
431          * Check to see if:
432          *  (a) there is anything on the txq to send
433          *  (b) link is up
434          *  (c) link attention events can be processed (fcp ring only)
435          *  (d) IOCB processing is not blocked by the outstanding mbox command.
436          */
437         if (pring->txq_cnt &&
438             (phba->hba_state > LPFC_LINK_DOWN) &&
439             (pring->ringno != phba->sli.fcp_ring ||
440              phba->sli.sli_flag & LPFC_PROCESS_LA) &&
441             !(pring->flag & LPFC_STOP_IOCB_MBX)) {
442
443                 while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
444                        (nextiocb = lpfc_sli_ringtx_get(phba, pring)))
445                         lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
446
447                 if (iocb)
448                         lpfc_sli_update_ring(phba, pring);
449                 else
450                         lpfc_sli_update_full_ring(phba, pring);
451         }
452
453         return;
454 }
455
456 /* lpfc_sli_turn_on_ring is only called by lpfc_sli_handle_mb_event below */
457 static void
458 lpfc_sli_turn_on_ring(struct lpfc_hba * phba, int ringno)
459 {
460         struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[ringno];
461
462         /* If the ring is active, flag it */
463         if (phba->sli.ring[ringno].cmdringaddr) {
464                 if (phba->sli.ring[ringno].flag & LPFC_STOP_IOCB_MBX) {
465                         phba->sli.ring[ringno].flag &= ~LPFC_STOP_IOCB_MBX;
466                         /*
467                          * Force update of the local copy of cmdGetInx
468                          */
469                         phba->sli.ring[ringno].local_getidx
470                                 = le32_to_cpu(pgp->cmdGetInx);
471                         spin_lock_irq(phba->host->host_lock);
472                         lpfc_sli_resume_iocb(phba, &phba->sli.ring[ringno]);
473                         spin_unlock_irq(phba->host->host_lock);
474                 }
475         }
476 }
477
478 static int
479 lpfc_sli_chk_mbx_command(uint8_t mbxCommand)
480 {
481         uint8_t ret;
482
483         switch (mbxCommand) {
484         case MBX_LOAD_SM:
485         case MBX_READ_NV:
486         case MBX_WRITE_NV:
487         case MBX_RUN_BIU_DIAG:
488         case MBX_INIT_LINK:
489         case MBX_DOWN_LINK:
490         case MBX_CONFIG_LINK:
491         case MBX_CONFIG_RING:
492         case MBX_RESET_RING:
493         case MBX_READ_CONFIG:
494         case MBX_READ_RCONFIG:
495         case MBX_READ_SPARM:
496         case MBX_READ_STATUS:
497         case MBX_READ_RPI:
498         case MBX_READ_XRI:
499         case MBX_READ_REV:
500         case MBX_READ_LNK_STAT:
501         case MBX_REG_LOGIN:
502         case MBX_UNREG_LOGIN:
503         case MBX_READ_LA:
504         case MBX_CLEAR_LA:
505         case MBX_DUMP_MEMORY:
506         case MBX_DUMP_CONTEXT:
507         case MBX_RUN_DIAGS:
508         case MBX_RESTART:
509         case MBX_UPDATE_CFG:
510         case MBX_DOWN_LOAD:
511         case MBX_DEL_LD_ENTRY:
512         case MBX_RUN_PROGRAM:
513         case MBX_SET_MASK:
514         case MBX_SET_SLIM:
515         case MBX_UNREG_D_ID:
516         case MBX_KILL_BOARD:
517         case MBX_CONFIG_FARP:
518         case MBX_BEACON:
519         case MBX_LOAD_AREA:
520         case MBX_RUN_BIU_DIAG64:
521         case MBX_CONFIG_PORT:
522         case MBX_READ_SPARM64:
523         case MBX_READ_RPI64:
524         case MBX_REG_LOGIN64:
525         case MBX_READ_LA64:
526         case MBX_FLASH_WR_ULA:
527         case MBX_SET_DEBUG:
528         case MBX_LOAD_EXP_ROM:
529                 ret = mbxCommand;
530                 break;
531         default:
532                 ret = MBX_SHUTDOWN;
533                 break;
534         }
535         return (ret);
536 }
537 static void
538 lpfc_sli_wake_mbox_wait(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
539 {
540         wait_queue_head_t *pdone_q;
541
542         /*
543          * If pdone_q is empty, the driver thread gave up waiting and
544          * continued running.
545          */
546         pdone_q = (wait_queue_head_t *) pmboxq->context1;
547         if (pdone_q)
548                 wake_up_interruptible(pdone_q);
549         return;
550 }
551
552 void
553 lpfc_sli_def_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
554 {
555         struct lpfc_dmabuf *mp;
556         mp = (struct lpfc_dmabuf *) (pmb->context1);
557         if (mp) {
558                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
559                 kfree(mp);
560         }
561         mempool_free( pmb, phba->mbox_mem_pool);
562         return;
563 }
564
565 int
566 lpfc_sli_handle_mb_event(struct lpfc_hba * phba)
567 {
568         MAILBOX_t *mbox;
569         MAILBOX_t *pmbox;
570         LPFC_MBOXQ_t *pmb;
571         struct lpfc_sli *psli;
572         int i, rc;
573         uint32_t process_next;
574
575         psli = &phba->sli;
576         /* We should only get here if we are in SLI2 mode */
577         if (!(phba->sli.sli_flag & LPFC_SLI2_ACTIVE)) {
578                 return (1);
579         }
580
581         phba->sli.slistat.mbox_event++;
582
583         /* Get a Mailbox buffer to setup mailbox commands for callback */
584         if ((pmb = phba->sli.mbox_active)) {
585                 pmbox = &pmb->mb;
586                 mbox = &phba->slim2p->mbx;
587
588                 /* First check out the status word */
589                 lpfc_sli_pcimem_bcopy(mbox, pmbox, sizeof (uint32_t));
590
591                 /* Sanity check to ensure the host owns the mailbox */
592                 if (pmbox->mbxOwner != OWN_HOST) {
593                         /* Lets try for a while */
594                         for (i = 0; i < 10240; i++) {
595                                 /* First copy command data */
596                                 lpfc_sli_pcimem_bcopy(mbox, pmbox,
597                                                         sizeof (uint32_t));
598                                 if (pmbox->mbxOwner == OWN_HOST)
599                                         goto mbout;
600                         }
601                         /* Stray Mailbox Interrupt, mbxCommand <cmd> mbxStatus
602                            <status> */
603                         lpfc_printf_log(phba,
604                                         KERN_ERR,
605                                         LOG_MBOX | LOG_SLI,
606                                         "%d:0304 Stray Mailbox Interrupt "
607                                         "mbxCommand x%x mbxStatus x%x\n",
608                                         phba->brd_no,
609                                         pmbox->mbxCommand,
610                                         pmbox->mbxStatus);
611
612                         spin_lock_irq(phba->host->host_lock);
613                         phba->sli.sli_flag |= LPFC_SLI_MBOX_ACTIVE;
614                         spin_unlock_irq(phba->host->host_lock);
615                         return (1);
616                 }
617
618               mbout:
619                 del_timer_sync(&phba->sli.mbox_tmo);
620                 phba->work_hba_events &= ~WORKER_MBOX_TMO;
621
622                 /*
623                  * It is a fatal error if unknown mbox command completion.
624                  */
625                 if (lpfc_sli_chk_mbx_command(pmbox->mbxCommand) ==
626                     MBX_SHUTDOWN) {
627
628                         /* Unknow mailbox command compl */
629                         lpfc_printf_log(phba,
630                                 KERN_ERR,
631                                 LOG_MBOX | LOG_SLI,
632                                 "%d:0323 Unknown Mailbox command %x Cmpl\n",
633                                 phba->brd_no,
634                                 pmbox->mbxCommand);
635                         phba->hba_state = LPFC_HBA_ERROR;
636                         phba->work_hs = HS_FFER3;
637                         lpfc_handle_eratt(phba);
638                         return (0);
639                 }
640
641                 phba->sli.mbox_active = NULL;
642                 if (pmbox->mbxStatus) {
643                         phba->sli.slistat.mbox_stat_err++;
644                         if (pmbox->mbxStatus == MBXERR_NO_RESOURCES) {
645                                 /* Mbox cmd cmpl error - RETRYing */
646                                 lpfc_printf_log(phba,
647                                         KERN_INFO,
648                                         LOG_MBOX | LOG_SLI,
649                                         "%d:0305 Mbox cmd cmpl error - "
650                                         "RETRYing Data: x%x x%x x%x x%x\n",
651                                         phba->brd_no,
652                                         pmbox->mbxCommand,
653                                         pmbox->mbxStatus,
654                                         pmbox->un.varWords[0],
655                                         phba->hba_state);
656                                 pmbox->mbxStatus = 0;
657                                 pmbox->mbxOwner = OWN_HOST;
658                                 spin_lock_irq(phba->host->host_lock);
659                                 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
660                                 spin_unlock_irq(phba->host->host_lock);
661                                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
662                                 if (rc == MBX_SUCCESS)
663                                         return (0);
664                         }
665                 }
666
667                 /* Mailbox cmd <cmd> Cmpl <cmpl> */
668                 lpfc_printf_log(phba,
669                                 KERN_INFO,
670                                 LOG_MBOX | LOG_SLI,
671                                 "%d:0307 Mailbox cmd x%x Cmpl x%p "
672                                 "Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x\n",
673                                 phba->brd_no,
674                                 pmbox->mbxCommand,
675                                 pmb->mbox_cmpl,
676                                 *((uint32_t *) pmbox),
677                                 pmbox->un.varWords[0],
678                                 pmbox->un.varWords[1],
679                                 pmbox->un.varWords[2],
680                                 pmbox->un.varWords[3],
681                                 pmbox->un.varWords[4],
682                                 pmbox->un.varWords[5],
683                                 pmbox->un.varWords[6],
684                                 pmbox->un.varWords[7]);
685
686                 if (pmb->mbox_cmpl) {
687                         lpfc_sli_pcimem_bcopy(mbox, pmbox, MAILBOX_CMD_SIZE);
688                         pmb->mbox_cmpl(phba,pmb);
689                 }
690         }
691
692
693         do {
694                 process_next = 0;       /* by default don't loop */
695                 spin_lock_irq(phba->host->host_lock);
696                 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
697
698                 /* Process next mailbox command if there is one */
699                 if ((pmb = lpfc_mbox_get(phba))) {
700                         spin_unlock_irq(phba->host->host_lock);
701                         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
702                         if (rc == MBX_NOT_FINISHED) {
703                                 pmb->mb.mbxStatus = MBX_NOT_FINISHED;
704                                 pmb->mbox_cmpl(phba,pmb);
705                                 process_next = 1;
706                                 continue;       /* loop back */
707                         }
708                 } else {
709                         spin_unlock_irq(phba->host->host_lock);
710                         /* Turn on IOCB processing */
711                         for (i = 0; i < phba->sli.num_rings; i++) {
712                                 lpfc_sli_turn_on_ring(phba, i);
713                         }
714
715                         /* Free any lpfc_dmabuf's waiting for mbox cmd cmpls */
716                         while (!list_empty(&phba->freebufList)) {
717                                 struct lpfc_dmabuf *mp;
718
719                                 mp = NULL;
720                                 list_remove_head((&phba->freebufList),
721                                                  mp,
722                                                  struct lpfc_dmabuf,
723                                                  list);
724                                 if (mp) {
725                                         lpfc_mbuf_free(phba, mp->virt,
726                                                        mp->phys);
727                                         kfree(mp);
728                                 }
729                         }
730                 }
731
732         } while (process_next);
733
734         return (0);
735 }
736 static int
737 lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
738                             struct lpfc_iocbq *saveq)
739 {
740         IOCB_t           * irsp;
741         WORD5            * w5p;
742         uint32_t           Rctl, Type;
743         uint32_t           match, i;
744
745         match = 0;
746         irsp = &(saveq->iocb);
747         if ((irsp->ulpCommand == CMD_RCV_ELS_REQ64_CX)
748             || (irsp->ulpCommand == CMD_RCV_ELS_REQ_CX)) {
749                 Rctl = FC_ELS_REQ;
750                 Type = FC_ELS_DATA;
751         } else {
752                 w5p =
753                     (WORD5 *) & (saveq->iocb.un.
754                                  ulpWord[5]);
755                 Rctl = w5p->hcsw.Rctl;
756                 Type = w5p->hcsw.Type;
757
758                 /* Firmware Workaround */
759                 if ((Rctl == 0) && (pring->ringno == LPFC_ELS_RING) &&
760                         (irsp->ulpCommand == CMD_RCV_SEQUENCE64_CX)) {
761                         Rctl = FC_ELS_REQ;
762                         Type = FC_ELS_DATA;
763                         w5p->hcsw.Rctl = Rctl;
764                         w5p->hcsw.Type = Type;
765                 }
766         }
767         /* unSolicited Responses */
768         if (pring->prt[0].profile) {
769                 if (pring->prt[0].lpfc_sli_rcv_unsol_event)
770                         (pring->prt[0].lpfc_sli_rcv_unsol_event) (phba, pring,
771                                                                         saveq);
772                 match = 1;
773         } else {
774                 /* We must search, based on rctl / type
775                    for the right routine */
776                 for (i = 0; i < pring->num_mask;
777                      i++) {
778                         if ((pring->prt[i].rctl ==
779                              Rctl)
780                             && (pring->prt[i].
781                                 type == Type)) {
782                                 if (pring->prt[i].lpfc_sli_rcv_unsol_event)
783                                         (pring->prt[i].lpfc_sli_rcv_unsol_event)
784                                                         (phba, pring, saveq);
785                                 match = 1;
786                                 break;
787                         }
788                 }
789         }
790         if (match == 0) {
791                 /* Unexpected Rctl / Type received */
792                 /* Ring <ringno> handler: unexpected
793                    Rctl <Rctl> Type <Type> received */
794                 lpfc_printf_log(phba,
795                                 KERN_WARNING,
796                                 LOG_SLI,
797                                 "%d:0313 Ring %d handler: unexpected Rctl x%x "
798                                 "Type x%x received \n",
799                                 phba->brd_no,
800                                 pring->ringno,
801                                 Rctl,
802                                 Type);
803         }
804         return(1);
805 }
806
807 static struct lpfc_iocbq *
808 lpfc_sli_iocbq_lookup(struct lpfc_hba * phba,
809                       struct lpfc_sli_ring * pring,
810                       struct lpfc_iocbq * prspiocb)
811 {
812         struct lpfc_iocbq *cmd_iocb = NULL;
813         uint16_t iotag;
814
815         iotag = prspiocb->iocb.ulpIoTag;
816
817         if (iotag != 0 && iotag <= phba->sli.last_iotag) {
818                 cmd_iocb = phba->sli.iocbq_lookup[iotag];
819                 list_del(&cmd_iocb->list);
820                 pring->txcmplq_cnt--;
821                 return cmd_iocb;
822         }
823
824         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
825                         "%d:0317 iotag x%x is out off "
826                         "range: max iotag x%x wd0 x%x\n",
827                         phba->brd_no, iotag,
828                         phba->sli.last_iotag,
829                         *(((uint32_t *) &prspiocb->iocb) + 7));
830         return NULL;
831 }
832
833 static int
834 lpfc_sli_process_sol_iocb(struct lpfc_hba * phba, struct lpfc_sli_ring * pring,
835                           struct lpfc_iocbq *saveq)
836 {
837         struct lpfc_iocbq * cmdiocbp;
838         int rc = 1;
839         unsigned long iflag;
840
841         /* Based on the iotag field, get the cmd IOCB from the txcmplq */
842         spin_lock_irqsave(phba->host->host_lock, iflag);
843         cmdiocbp = lpfc_sli_iocbq_lookup(phba, pring, saveq);
844         if (cmdiocbp) {
845                 if (cmdiocbp->iocb_cmpl) {
846                         /*
847                          * Post all ELS completions to the worker thread.
848                          * All other are passed to the completion callback.
849                          */
850                         if (pring->ringno == LPFC_ELS_RING) {
851                                 spin_unlock_irqrestore(phba->host->host_lock,
852                                                        iflag);
853                                 (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
854                                 spin_lock_irqsave(phba->host->host_lock, iflag);
855                         }
856                         else {
857                                 spin_unlock_irqrestore(phba->host->host_lock,
858                                                        iflag);
859                                 (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
860                                 spin_lock_irqsave(phba->host->host_lock, iflag);
861                         }
862                 } else
863                         lpfc_sli_release_iocbq(phba, cmdiocbp);
864         } else {
865                 /*
866                  * Unknown initiating command based on the response iotag.
867                  * This could be the case on the ELS ring because of
868                  * lpfc_els_abort().
869                  */
870                 if (pring->ringno != LPFC_ELS_RING) {
871                         /*
872                          * Ring <ringno> handler: unexpected completion IoTag
873                          * <IoTag>
874                          */
875                         lpfc_printf_log(phba,
876                                 KERN_WARNING,
877                                 LOG_SLI,
878                                 "%d:0322 Ring %d handler: unexpected "
879                                 "completion IoTag x%x Data: x%x x%x x%x x%x\n",
880                                 phba->brd_no,
881                                 pring->ringno,
882                                 saveq->iocb.ulpIoTag,
883                                 saveq->iocb.ulpStatus,
884                                 saveq->iocb.un.ulpWord[4],
885                                 saveq->iocb.ulpCommand,
886                                 saveq->iocb.ulpContext);
887                 }
888         }
889
890         spin_unlock_irqrestore(phba->host->host_lock, iflag);
891         return rc;
892 }
893
894 static void lpfc_sli_rsp_pointers_error(struct lpfc_hba * phba,
895                                         struct lpfc_sli_ring * pring)
896 {
897         struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno];
898         /*
899          * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
900          * rsp ring <portRspMax>
901          */
902         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
903                         "%d:0312 Ring %d handler: portRspPut %d "
904                         "is bigger then rsp ring %d\n",
905                         phba->brd_no, pring->ringno,
906                         le32_to_cpu(pgp->rspPutInx),
907                         pring->numRiocb);
908
909         phba->hba_state = LPFC_HBA_ERROR;
910
911         /*
912          * All error attention handlers are posted to
913          * worker thread
914          */
915         phba->work_ha |= HA_ERATT;
916         phba->work_hs = HS_FFER3;
917         if (phba->work_wait)
918                 wake_up(phba->work_wait);
919
920         return;
921 }
922
923 void lpfc_sli_poll_fcp_ring(struct lpfc_hba * phba)
924 {
925         struct lpfc_sli      * psli   = &phba->sli;
926         struct lpfc_sli_ring * pring = &psli->ring[LPFC_FCP_RING];
927         IOCB_t *irsp = NULL;
928         IOCB_t *entry = NULL;
929         struct lpfc_iocbq *cmdiocbq = NULL;
930         struct lpfc_iocbq rspiocbq;
931         struct lpfc_pgp *pgp;
932         uint32_t status;
933         uint32_t portRspPut, portRspMax;
934         int type;
935         uint32_t rsp_cmpl = 0;
936         void __iomem *to_slim;
937         uint32_t ha_copy;
938
939         pring->stats.iocb_event++;
940
941         /* The driver assumes SLI-2 mode */
942         pgp =  &phba->slim2p->mbx.us.s2.port[pring->ringno];
943
944         /*
945          * The next available response entry should never exceed the maximum
946          * entries.  If it does, treat it as an adapter hardware error.
947          */
948         portRspMax = pring->numRiocb;
949         portRspPut = le32_to_cpu(pgp->rspPutInx);
950         if (unlikely(portRspPut >= portRspMax)) {
951                 lpfc_sli_rsp_pointers_error(phba, pring);
952                 return;
953         }
954
955         rmb();
956         while (pring->rspidx != portRspPut) {
957
958                 entry = IOCB_ENTRY(pring->rspringaddr, pring->rspidx);
959
960                 if (++pring->rspidx >= portRspMax)
961                         pring->rspidx = 0;
962
963                 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
964                                       (uint32_t *) &rspiocbq.iocb,
965                                       sizeof (IOCB_t));
966                 irsp = &rspiocbq.iocb;
967                 type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
968                 pring->stats.iocb_rsp++;
969                 rsp_cmpl++;
970
971                 if (unlikely(irsp->ulpStatus)) {
972                         /* Rsp ring <ringno> error: IOCB */
973                         lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
974                                         "%d:0326 Rsp Ring %d error: IOCB Data: "
975                                         "x%x x%x x%x x%x x%x x%x x%x x%x\n",
976                                         phba->brd_no, pring->ringno,
977                                         irsp->un.ulpWord[0],
978                                         irsp->un.ulpWord[1],
979                                         irsp->un.ulpWord[2],
980                                         irsp->un.ulpWord[3],
981                                         irsp->un.ulpWord[4],
982                                         irsp->un.ulpWord[5],
983                                         *(((uint32_t *) irsp) + 6),
984                                         *(((uint32_t *) irsp) + 7));
985                 }
986
987                 switch (type) {
988                 case LPFC_ABORT_IOCB:
989                 case LPFC_SOL_IOCB:
990                         /*
991                          * Idle exchange closed via ABTS from port.  No iocb
992                          * resources need to be recovered.
993                          */
994                         if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
995                                 printk(KERN_INFO "%s: IOCB cmd 0x%x processed."
996                                        " Skipping completion\n", __FUNCTION__,
997                                        irsp->ulpCommand);
998                                 break;
999                         }
1000
1001                         cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1002                                                          &rspiocbq);
1003                         if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
1004                                 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1005                                                       &rspiocbq);
1006                         }
1007                         break;
1008                 default:
1009                         if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
1010                                 char adaptermsg[LPFC_MAX_ADPTMSG];
1011                                 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
1012                                 memcpy(&adaptermsg[0], (uint8_t *) irsp,
1013                                        MAX_MSG_DATA);
1014                                 dev_warn(&((phba->pcidev)->dev), "lpfc%d: %s",
1015                                          phba->brd_no, adaptermsg);
1016                         } else {
1017                                 /* Unknown IOCB command */
1018                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1019                                                 "%d:0321 Unknown IOCB command "
1020                                                 "Data: x%x, x%x x%x x%x x%x\n",
1021                                                 phba->brd_no, type,
1022                                                 irsp->ulpCommand,
1023                                                 irsp->ulpStatus,
1024                                                 irsp->ulpIoTag,
1025                                                 irsp->ulpContext);
1026                         }
1027                         break;
1028                 }
1029
1030                 /*
1031                  * The response IOCB has been processed.  Update the ring
1032                  * pointer in SLIM.  If the port response put pointer has not
1033                  * been updated, sync the pgp->rspPutInx and fetch the new port
1034                  * response put pointer.
1035                  */
1036                 to_slim = phba->MBslimaddr +
1037                         (SLIMOFF + (pring->ringno * 2) + 1) * 4;
1038                 writeb(pring->rspidx, to_slim);
1039
1040                 if (pring->rspidx == portRspPut)
1041                         portRspPut = le32_to_cpu(pgp->rspPutInx);
1042         }
1043
1044         ha_copy = readl(phba->HAregaddr);
1045         ha_copy >>= (LPFC_FCP_RING * 4);
1046
1047         if ((rsp_cmpl > 0) && (ha_copy & HA_R0RE_REQ)) {
1048                 pring->stats.iocb_rsp_full++;
1049                 status = ((CA_R0ATT | CA_R0RE_RSP) << (LPFC_FCP_RING * 4));
1050                 writel(status, phba->CAregaddr);
1051                 readl(phba->CAregaddr);
1052         }
1053         if ((ha_copy & HA_R0CE_RSP) &&
1054             (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
1055                 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
1056                 pring->stats.iocb_cmd_empty++;
1057
1058                 /* Force update of the local copy of cmdGetInx */
1059                 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
1060                 lpfc_sli_resume_iocb(phba, pring);
1061
1062                 if ((pring->lpfc_sli_cmd_available))
1063                         (pring->lpfc_sli_cmd_available) (phba, pring);
1064
1065         }
1066
1067         return;
1068 }
1069
1070 /*
1071  * This routine presumes LPFC_FCP_RING handling and doesn't bother
1072  * to check it explicitly.
1073  */
1074 static int
1075 lpfc_sli_handle_fast_ring_event(struct lpfc_hba * phba,
1076                                 struct lpfc_sli_ring * pring, uint32_t mask)
1077 {
1078         struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno];
1079         IOCB_t *irsp = NULL;
1080         IOCB_t *entry = NULL;
1081         struct lpfc_iocbq *cmdiocbq = NULL;
1082         struct lpfc_iocbq rspiocbq;
1083         uint32_t status;
1084         uint32_t portRspPut, portRspMax;
1085         int rc = 1;
1086         lpfc_iocb_type type;
1087         unsigned long iflag;
1088         uint32_t rsp_cmpl = 0;
1089         void __iomem  *to_slim;
1090
1091         spin_lock_irqsave(phba->host->host_lock, iflag);
1092         pring->stats.iocb_event++;
1093
1094         /*
1095          * The next available response entry should never exceed the maximum
1096          * entries.  If it does, treat it as an adapter hardware error.
1097          */
1098         portRspMax = pring->numRiocb;
1099         portRspPut = le32_to_cpu(pgp->rspPutInx);
1100         if (unlikely(portRspPut >= portRspMax)) {
1101                 lpfc_sli_rsp_pointers_error(phba, pring);
1102                 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1103                 return 1;
1104         }
1105
1106         rmb();
1107         while (pring->rspidx != portRspPut) {
1108                 /*
1109                  * Fetch an entry off the ring and copy it into a local data
1110                  * structure.  The copy involves a byte-swap since the
1111                  * network byte order and pci byte orders are different.
1112                  */
1113                 entry = IOCB_ENTRY(pring->rspringaddr, pring->rspidx);
1114
1115                 if (++pring->rspidx >= portRspMax)
1116                         pring->rspidx = 0;
1117
1118                 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
1119                                       (uint32_t *) &rspiocbq.iocb,
1120                                       sizeof (IOCB_t));
1121                 irsp = &rspiocbq.iocb;
1122
1123                 type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
1124                 pring->stats.iocb_rsp++;
1125                 rsp_cmpl++;
1126
1127                 if (unlikely(irsp->ulpStatus)) {
1128                         /* Rsp ring <ringno> error: IOCB */
1129                         lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1130                                 "%d:0326 Rsp Ring %d error: IOCB Data: "
1131                                 "x%x x%x x%x x%x x%x x%x x%x x%x\n",
1132                                 phba->brd_no, pring->ringno,
1133                                 irsp->un.ulpWord[0], irsp->un.ulpWord[1],
1134                                 irsp->un.ulpWord[2], irsp->un.ulpWord[3],
1135                                 irsp->un.ulpWord[4], irsp->un.ulpWord[5],
1136                                 *(((uint32_t *) irsp) + 6),
1137                                 *(((uint32_t *) irsp) + 7));
1138                 }
1139
1140                 switch (type) {
1141                 case LPFC_ABORT_IOCB:
1142                 case LPFC_SOL_IOCB:
1143                         /*
1144                          * Idle exchange closed via ABTS from port.  No iocb
1145                          * resources need to be recovered.
1146                          */
1147                         if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
1148                                 printk(KERN_INFO "%s: IOCB cmd 0x%x processed. "
1149                                        "Skipping completion\n", __FUNCTION__,
1150                                        irsp->ulpCommand);
1151                                 break;
1152                         }
1153
1154                         cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1155                                                          &rspiocbq);
1156                         if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
1157                                 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
1158                                         (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1159                                                               &rspiocbq);
1160                                 } else {
1161                                         spin_unlock_irqrestore(
1162                                                 phba->host->host_lock, iflag);
1163                                         (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1164                                                               &rspiocbq);
1165                                         spin_lock_irqsave(phba->host->host_lock,
1166                                                           iflag);
1167                                 }
1168                         }
1169                         break;
1170                 default:
1171                         if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
1172                                 char adaptermsg[LPFC_MAX_ADPTMSG];
1173                                 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
1174                                 memcpy(&adaptermsg[0], (uint8_t *) irsp,
1175                                        MAX_MSG_DATA);
1176                                 dev_warn(&((phba->pcidev)->dev), "lpfc%d: %s",
1177                                          phba->brd_no, adaptermsg);
1178                         } else {
1179                                 /* Unknown IOCB command */
1180                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1181                                         "%d:0321 Unknown IOCB command "
1182                                         "Data: x%x, x%x x%x x%x x%x\n",
1183                                         phba->brd_no, type, irsp->ulpCommand,
1184                                         irsp->ulpStatus, irsp->ulpIoTag,
1185                                         irsp->ulpContext);
1186                         }
1187                         break;
1188                 }
1189
1190                 /*
1191                  * The response IOCB has been processed.  Update the ring
1192                  * pointer in SLIM.  If the port response put pointer has not
1193                  * been updated, sync the pgp->rspPutInx and fetch the new port
1194                  * response put pointer.
1195                  */
1196                 to_slim = phba->MBslimaddr +
1197                         (SLIMOFF + (pring->ringno * 2) + 1) * 4;
1198                 writel(pring->rspidx, to_slim);
1199
1200                 if (pring->rspidx == portRspPut)
1201                         portRspPut = le32_to_cpu(pgp->rspPutInx);
1202         }
1203
1204         if ((rsp_cmpl > 0) && (mask & HA_R0RE_REQ)) {
1205                 pring->stats.iocb_rsp_full++;
1206                 status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
1207                 writel(status, phba->CAregaddr);
1208                 readl(phba->CAregaddr);
1209         }
1210         if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
1211                 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
1212                 pring->stats.iocb_cmd_empty++;
1213
1214                 /* Force update of the local copy of cmdGetInx */
1215                 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
1216                 lpfc_sli_resume_iocb(phba, pring);
1217
1218                 if ((pring->lpfc_sli_cmd_available))
1219                         (pring->lpfc_sli_cmd_available) (phba, pring);
1220
1221         }
1222
1223         spin_unlock_irqrestore(phba->host->host_lock, iflag);
1224         return rc;
1225 }
1226
1227
1228 int
1229 lpfc_sli_handle_slow_ring_event(struct lpfc_hba * phba,
1230                            struct lpfc_sli_ring * pring, uint32_t mask)
1231 {
1232         IOCB_t *entry;
1233         IOCB_t *irsp = NULL;
1234         struct lpfc_iocbq *rspiocbp = NULL;
1235         struct lpfc_iocbq *next_iocb;
1236         struct lpfc_iocbq *cmdiocbp;
1237         struct lpfc_iocbq *saveq;
1238         struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno];
1239         uint8_t iocb_cmd_type;
1240         lpfc_iocb_type type;
1241         uint32_t status, free_saveq;
1242         uint32_t portRspPut, portRspMax;
1243         int rc = 1;
1244         unsigned long iflag;
1245         void __iomem  *to_slim;
1246
1247         spin_lock_irqsave(phba->host->host_lock, iflag);
1248         pring->stats.iocb_event++;
1249
1250         /*
1251          * The next available response entry should never exceed the maximum
1252          * entries.  If it does, treat it as an adapter hardware error.
1253          */
1254         portRspMax = pring->numRiocb;
1255         portRspPut = le32_to_cpu(pgp->rspPutInx);
1256         if (portRspPut >= portRspMax) {
1257                 /*
1258                  * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1259                  * rsp ring <portRspMax>
1260                  */
1261                 lpfc_printf_log(phba,
1262                                 KERN_ERR,
1263                                 LOG_SLI,
1264                                 "%d:0312 Ring %d handler: portRspPut %d "
1265                                 "is bigger then rsp ring %d\n",
1266                                 phba->brd_no,
1267                                 pring->ringno, portRspPut, portRspMax);
1268
1269                 phba->hba_state = LPFC_HBA_ERROR;
1270                 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1271
1272                 phba->work_hs = HS_FFER3;
1273                 lpfc_handle_eratt(phba);
1274
1275                 return 1;
1276         }
1277
1278         rmb();
1279         while (pring->rspidx != portRspPut) {
1280                 /*
1281                  * Build a completion list and call the appropriate handler.
1282                  * The process is to get the next available response iocb, get
1283                  * a free iocb from the list, copy the response data into the
1284                  * free iocb, insert to the continuation list, and update the
1285                  * next response index to slim.  This process makes response
1286                  * iocb's in the ring available to DMA as fast as possible but
1287                  * pays a penalty for a copy operation.  Since the iocb is
1288                  * only 32 bytes, this penalty is considered small relative to
1289                  * the PCI reads for register values and a slim write.  When
1290                  * the ulpLe field is set, the entire Command has been
1291                  * received.
1292                  */
1293                 entry = IOCB_ENTRY(pring->rspringaddr, pring->rspidx);
1294                 rspiocbp = lpfc_sli_get_iocbq(phba);
1295                 if (rspiocbp == NULL) {
1296                         printk(KERN_ERR "%s: out of buffers! Failing "
1297                                "completion.\n", __FUNCTION__);
1298                         break;
1299                 }
1300
1301                 lpfc_sli_pcimem_bcopy(entry, &rspiocbp->iocb, sizeof (IOCB_t));
1302                 irsp = &rspiocbp->iocb;
1303
1304                 if (++pring->rspidx >= portRspMax)
1305                         pring->rspidx = 0;
1306
1307                 to_slim = phba->MBslimaddr + (SLIMOFF + (pring->ringno * 2)
1308                                               + 1) * 4;
1309                 writel(pring->rspidx, to_slim);
1310
1311                 if (list_empty(&(pring->iocb_continueq))) {
1312                         list_add(&rspiocbp->list, &(pring->iocb_continueq));
1313                 } else {
1314                         list_add_tail(&rspiocbp->list,
1315                                       &(pring->iocb_continueq));
1316                 }
1317
1318                 pring->iocb_continueq_cnt++;
1319                 if (irsp->ulpLe) {
1320                         /*
1321                          * By default, the driver expects to free all resources
1322                          * associated with this iocb completion.
1323                          */
1324                         free_saveq = 1;
1325                         saveq = list_get_first(&pring->iocb_continueq,
1326                                                struct lpfc_iocbq, list);
1327                         irsp = &(saveq->iocb);
1328                         list_del_init(&pring->iocb_continueq);
1329                         pring->iocb_continueq_cnt = 0;
1330
1331                         pring->stats.iocb_rsp++;
1332
1333                         if (irsp->ulpStatus) {
1334                                 /* Rsp ring <ringno> error: IOCB */
1335                                 lpfc_printf_log(phba,
1336                                         KERN_WARNING,
1337                                         LOG_SLI,
1338                                         "%d:0328 Rsp Ring %d error: IOCB Data: "
1339                                         "x%x x%x x%x x%x x%x x%x x%x x%x\n",
1340                                         phba->brd_no,
1341                                         pring->ringno,
1342                                         irsp->un.ulpWord[0],
1343                                         irsp->un.ulpWord[1],
1344                                         irsp->un.ulpWord[2],
1345                                         irsp->un.ulpWord[3],
1346                                         irsp->un.ulpWord[4],
1347                                         irsp->un.ulpWord[5],
1348                                         *(((uint32_t *) irsp) + 6),
1349                                         *(((uint32_t *) irsp) + 7));
1350                         }
1351
1352                         /*
1353                          * Fetch the IOCB command type and call the correct
1354                          * completion routine.  Solicited and Unsolicited
1355                          * IOCBs on the ELS ring get freed back to the
1356                          * lpfc_iocb_list by the discovery kernel thread.
1357                          */
1358                         iocb_cmd_type = irsp->ulpCommand & CMD_IOCB_MASK;
1359                         type = lpfc_sli_iocb_cmd_type(iocb_cmd_type);
1360                         if (type == LPFC_SOL_IOCB) {
1361                                 spin_unlock_irqrestore(phba->host->host_lock,
1362                                                        iflag);
1363                                 rc = lpfc_sli_process_sol_iocb(phba, pring,
1364                                         saveq);
1365                                 spin_lock_irqsave(phba->host->host_lock, iflag);
1366                         } else if (type == LPFC_UNSOL_IOCB) {
1367                                 spin_unlock_irqrestore(phba->host->host_lock,
1368                                                        iflag);
1369                                 rc = lpfc_sli_process_unsol_iocb(phba, pring,
1370                                         saveq);
1371                                 spin_lock_irqsave(phba->host->host_lock, iflag);
1372                         } else if (type == LPFC_ABORT_IOCB) {
1373                                 if ((irsp->ulpCommand != CMD_XRI_ABORTED_CX) &&
1374                                     ((cmdiocbp =
1375                                       lpfc_sli_iocbq_lookup(phba, pring,
1376                                                             saveq)))) {
1377                                         /* Call the specified completion
1378                                            routine */
1379                                         if (cmdiocbp->iocb_cmpl) {
1380                                                 spin_unlock_irqrestore(
1381                                                        phba->host->host_lock,
1382                                                        iflag);
1383                                                 (cmdiocbp->iocb_cmpl) (phba,
1384                                                              cmdiocbp, saveq);
1385                                                 spin_lock_irqsave(
1386                                                           phba->host->host_lock,
1387                                                           iflag);
1388                                         } else
1389                                                 lpfc_sli_release_iocbq(phba,
1390                                                                       cmdiocbp);
1391                                 }
1392                         } else if (type == LPFC_UNKNOWN_IOCB) {
1393                                 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
1394
1395                                         char adaptermsg[LPFC_MAX_ADPTMSG];
1396
1397                                         memset(adaptermsg, 0,
1398                                                LPFC_MAX_ADPTMSG);
1399                                         memcpy(&adaptermsg[0], (uint8_t *) irsp,
1400                                                MAX_MSG_DATA);
1401                                         dev_warn(&((phba->pcidev)->dev),
1402                                                  "lpfc%d: %s",
1403                                                  phba->brd_no, adaptermsg);
1404                                 } else {
1405                                         /* Unknown IOCB command */
1406                                         lpfc_printf_log(phba,
1407                                                 KERN_ERR,
1408                                                 LOG_SLI,
1409                                                 "%d:0321 Unknown IOCB command "
1410                                                 "Data: x%x x%x x%x x%x\n",
1411                                                 phba->brd_no,
1412                                                 irsp->ulpCommand,
1413                                                 irsp->ulpStatus,
1414                                                 irsp->ulpIoTag,
1415                                                 irsp->ulpContext);
1416                                 }
1417                         }
1418
1419                         if (free_saveq) {
1420                                 if (!list_empty(&saveq->list)) {
1421                                         list_for_each_entry_safe(rspiocbp,
1422                                                                  next_iocb,
1423                                                                  &saveq->list,
1424                                                                  list) {
1425                                                 lpfc_sli_release_iocbq(phba,
1426                                                                      rspiocbp);
1427                                         }
1428                                 }
1429
1430                                 lpfc_sli_release_iocbq(phba, saveq);
1431                         }
1432                 }
1433
1434                 /*
1435                  * If the port response put pointer has not been updated, sync
1436                  * the pgp->rspPutInx in the MAILBOX_tand fetch the new port
1437                  * response put pointer.
1438                  */
1439                 if (pring->rspidx == portRspPut) {
1440                         portRspPut = le32_to_cpu(pgp->rspPutInx);
1441                 }
1442         } /* while (pring->rspidx != portRspPut) */
1443
1444         if ((rspiocbp != 0) && (mask & HA_R0RE_REQ)) {
1445                 /* At least one response entry has been freed */
1446                 pring->stats.iocb_rsp_full++;
1447                 /* SET RxRE_RSP in Chip Att register */
1448                 status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
1449                 writel(status, phba->CAregaddr);
1450                 readl(phba->CAregaddr); /* flush */
1451         }
1452         if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
1453                 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
1454                 pring->stats.iocb_cmd_empty++;
1455
1456                 /* Force update of the local copy of cmdGetInx */
1457                 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
1458                 lpfc_sli_resume_iocb(phba, pring);
1459
1460                 if ((pring->lpfc_sli_cmd_available))
1461                         (pring->lpfc_sli_cmd_available) (phba, pring);
1462
1463         }
1464
1465         spin_unlock_irqrestore(phba->host->host_lock, iflag);
1466         return rc;
1467 }
1468
1469 int
1470 lpfc_sli_abort_iocb_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1471 {
1472         struct lpfc_iocbq *iocb, *next_iocb;
1473         IOCB_t *icmd = NULL, *cmd = NULL;
1474         int errcnt;
1475
1476         errcnt = 0;
1477
1478         /* Error everything on txq and txcmplq
1479          * First do the txq.
1480          */
1481         spin_lock_irq(phba->host->host_lock);
1482         list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
1483                 list_del_init(&iocb->list);
1484                 if (iocb->iocb_cmpl) {
1485                         icmd = &iocb->iocb;
1486                         icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
1487                         icmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
1488                         spin_unlock_irq(phba->host->host_lock);
1489                         (iocb->iocb_cmpl) (phba, iocb, iocb);
1490                         spin_lock_irq(phba->host->host_lock);
1491                 } else
1492                         lpfc_sli_release_iocbq(phba, iocb);
1493         }
1494         pring->txq_cnt = 0;
1495         INIT_LIST_HEAD(&(pring->txq));
1496
1497         /* Next issue ABTS for everything on the txcmplq */
1498         list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
1499                 cmd = &iocb->iocb;
1500
1501                 /*
1502                  * Imediate abort of IOCB, deque and call compl
1503                  */
1504
1505                 list_del_init(&iocb->list);
1506                 pring->txcmplq_cnt--;
1507
1508                 if (iocb->iocb_cmpl) {
1509                         cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
1510                         cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
1511                         spin_unlock_irq(phba->host->host_lock);
1512                         (iocb->iocb_cmpl) (phba, iocb, iocb);
1513                         spin_lock_irq(phba->host->host_lock);
1514                 } else
1515                         lpfc_sli_release_iocbq(phba, iocb);
1516         }
1517
1518         INIT_LIST_HEAD(&pring->txcmplq);
1519         pring->txcmplq_cnt = 0;
1520         spin_unlock_irq(phba->host->host_lock);
1521
1522         return errcnt;
1523 }
1524
1525 int
1526 lpfc_sli_brdready(struct lpfc_hba * phba, uint32_t mask)
1527 {
1528         uint32_t status;
1529         int i = 0;
1530         int retval = 0;
1531
1532         /* Read the HBA Host Status Register */
1533         status = readl(phba->HSregaddr);
1534
1535         /*
1536          * Check status register every 100ms for 5 retries, then every
1537          * 500ms for 5, then every 2.5 sec for 5, then reset board and
1538          * every 2.5 sec for 4.
1539          * Break our of the loop if errors occurred during init.
1540          */
1541         while (((status & mask) != mask) &&
1542                !(status & HS_FFERM) &&
1543                i++ < 20) {
1544
1545                 if (i <= 5)
1546                         msleep(10);
1547                 else if (i <= 10)
1548                         msleep(500);
1549                 else
1550                         msleep(2500);
1551
1552                 if (i == 15) {
1553                         phba->hba_state = LPFC_STATE_UNKNOWN; /* Do post */
1554                         lpfc_sli_brdrestart(phba);
1555                 }
1556                 /* Read the HBA Host Status Register */
1557                 status = readl(phba->HSregaddr);
1558         }
1559
1560         /* Check to see if any errors occurred during init */
1561         if ((status & HS_FFERM) || (i >= 20)) {
1562                 phba->hba_state = LPFC_HBA_ERROR;
1563                 retval = 1;
1564         }
1565
1566         return retval;
1567 }
1568
1569 int
1570 lpfc_sli_brdkill(struct lpfc_hba * phba)
1571 {
1572         struct lpfc_sli *psli;
1573         LPFC_MBOXQ_t *pmb;
1574         uint32_t status;
1575         uint32_t ha_copy;
1576         int retval;
1577         int i = 0;
1578
1579         psli = &phba->sli;
1580
1581         /* Kill HBA */
1582         lpfc_printf_log(phba,
1583                 KERN_INFO,
1584                 LOG_SLI,
1585                 "%d:0329 Kill HBA Data: x%x x%x\n",
1586                 phba->brd_no,
1587                 phba->hba_state,
1588                 psli->sli_flag);
1589
1590         if ((pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
1591                                                   GFP_ATOMIC)) == 0) {
1592                 return 1;
1593         }
1594
1595         /* Disable the error attention */
1596         spin_lock_irq(phba->host->host_lock);
1597         status = readl(phba->HCregaddr);
1598         status &= ~HC_ERINT_ENA;
1599         writel(status, phba->HCregaddr);
1600         readl(phba->HCregaddr); /* flush */
1601         spin_unlock_irq(phba->host->host_lock);
1602
1603         lpfc_kill_board(phba, pmb);
1604         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
1605         retval = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
1606
1607         if (retval != MBX_SUCCESS) {
1608                 if (retval != MBX_BUSY)
1609                         mempool_free(pmb, phba->mbox_mem_pool);
1610                 return 1;
1611         }
1612
1613         mempool_free(pmb, phba->mbox_mem_pool);
1614
1615         /* There is no completion for a KILL_BOARD mbox cmd. Check for an error
1616          * attention every 100ms for 3 seconds. If we don't get ERATT after
1617          * 3 seconds we still set HBA_ERROR state because the status of the
1618          * board is now undefined.
1619          */
1620         ha_copy = readl(phba->HAregaddr);
1621
1622         while ((i++ < 30) && !(ha_copy & HA_ERATT)) {
1623                 mdelay(100);
1624                 ha_copy = readl(phba->HAregaddr);
1625         }
1626
1627         del_timer_sync(&psli->mbox_tmo);
1628
1629         spin_lock_irq(phba->host->host_lock);
1630         psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
1631         spin_unlock_irq(phba->host->host_lock);
1632
1633         psli->mbox_active = NULL;
1634         lpfc_hba_down_post(phba);
1635         phba->hba_state = LPFC_HBA_ERROR;
1636
1637         return (ha_copy & HA_ERATT ? 0 : 1);
1638 }
1639
1640 int
1641 lpfc_sli_brdreset(struct lpfc_hba * phba)
1642 {
1643         struct lpfc_sli *psli;
1644         struct lpfc_sli_ring *pring;
1645         uint16_t cfg_value;
1646         int i;
1647
1648         psli = &phba->sli;
1649
1650         /* Reset HBA */
1651         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1652                         "%d:0325 Reset HBA Data: x%x x%x\n", phba->brd_no,
1653                         phba->hba_state, psli->sli_flag);
1654
1655         /* perform board reset */
1656         phba->fc_eventTag = 0;
1657         phba->fc_myDID = 0;
1658         phba->fc_prevDID = 0;
1659
1660         psli->sli_flag = 0;
1661
1662         /* Turn off parity checking and serr during the physical reset */
1663         pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value);
1664         pci_write_config_word(phba->pcidev, PCI_COMMAND,
1665                               (cfg_value &
1666                                ~(PCI_COMMAND_PARITY | PCI_COMMAND_SERR)));
1667
1668         /* Now toggle INITFF bit in the Host Control Register */
1669         writel(HC_INITFF, phba->HCregaddr);
1670         mdelay(1);
1671         readl(phba->HCregaddr); /* flush */
1672         writel(0, phba->HCregaddr);
1673         readl(phba->HCregaddr); /* flush */
1674
1675         /* Restore PCI cmd register */
1676         pci_write_config_word(phba->pcidev, PCI_COMMAND, cfg_value);
1677
1678         /* Initialize relevant SLI info */
1679         for (i = 0; i < psli->num_rings; i++) {
1680                 pring = &psli->ring[i];
1681                 pring->flag = 0;
1682                 pring->rspidx = 0;
1683                 pring->next_cmdidx  = 0;
1684                 pring->local_getidx = 0;
1685                 pring->cmdidx = 0;
1686                 pring->missbufcnt = 0;
1687         }
1688
1689         phba->hba_state = LPFC_WARM_START;
1690         return 0;
1691 }
1692
1693 int
1694 lpfc_sli_brdrestart(struct lpfc_hba * phba)
1695 {
1696         MAILBOX_t *mb;
1697         struct lpfc_sli *psli;
1698         uint16_t skip_post;
1699         volatile uint32_t word0;
1700         void __iomem *to_slim;
1701
1702         spin_lock_irq(phba->host->host_lock);
1703
1704         psli = &phba->sli;
1705
1706         /* Restart HBA */
1707         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1708                         "%d:0328 Restart HBA Data: x%x x%x\n", phba->brd_no,
1709                         phba->hba_state, psli->sli_flag);
1710
1711         word0 = 0;
1712         mb = (MAILBOX_t *) &word0;
1713         mb->mbxCommand = MBX_RESTART;
1714         mb->mbxHc = 1;
1715
1716         to_slim = phba->MBslimaddr;
1717         writel(*(uint32_t *) mb, to_slim);
1718         readl(to_slim); /* flush */
1719
1720         /* Only skip post after fc_ffinit is completed */
1721         if (phba->hba_state) {
1722                 skip_post = 1;
1723                 word0 = 1;      /* This is really setting up word1 */
1724         } else {
1725                 skip_post = 0;
1726                 word0 = 0;      /* This is really setting up word1 */
1727         }
1728         to_slim = (uint8_t *) phba->MBslimaddr + sizeof (uint32_t);
1729         writel(*(uint32_t *) mb, to_slim);
1730         readl(to_slim); /* flush */
1731
1732         lpfc_sli_brdreset(phba);
1733
1734         phba->hba_state = LPFC_INIT_START;
1735
1736         spin_unlock_irq(phba->host->host_lock);
1737
1738         if (skip_post)
1739                 mdelay(100);
1740         else
1741                 mdelay(2000);
1742
1743         lpfc_hba_down_post(phba);
1744
1745         return 0;
1746 }
1747
1748 static int
1749 lpfc_sli_chipset_init(struct lpfc_hba *phba)
1750 {
1751         uint32_t status, i = 0;
1752
1753         /* Read the HBA Host Status Register */
1754         status = readl(phba->HSregaddr);
1755
1756         /* Check status register to see what current state is */
1757         i = 0;
1758         while ((status & (HS_FFRDY | HS_MBRDY)) != (HS_FFRDY | HS_MBRDY)) {
1759
1760                 /* Check every 100ms for 5 retries, then every 500ms for 5, then
1761                  * every 2.5 sec for 5, then reset board and every 2.5 sec for
1762                  * 4.
1763                  */
1764                 if (i++ >= 20) {
1765                         /* Adapter failed to init, timeout, status reg
1766                            <status> */
1767                         lpfc_printf_log(phba,
1768                                         KERN_ERR,
1769                                         LOG_INIT,
1770                                         "%d:0436 Adapter failed to init, "
1771                                         "timeout, status reg x%x\n",
1772                                         phba->brd_no,
1773                                         status);
1774                         phba->hba_state = LPFC_HBA_ERROR;
1775                         return -ETIMEDOUT;
1776                 }
1777
1778                 /* Check to see if any errors occurred during init */
1779                 if (status & HS_FFERM) {
1780                         /* ERROR: During chipset initialization */
1781                         /* Adapter failed to init, chipset, status reg
1782                            <status> */
1783                         lpfc_printf_log(phba,
1784                                         KERN_ERR,
1785                                         LOG_INIT,
1786                                         "%d:0437 Adapter failed to init, "
1787                                         "chipset, status reg x%x\n",
1788                                         phba->brd_no,
1789                                         status);
1790                         phba->hba_state = LPFC_HBA_ERROR;
1791                         return -EIO;
1792                 }
1793
1794                 if (i <= 5) {
1795                         msleep(10);
1796                 } else if (i <= 10) {
1797                         msleep(500);
1798                 } else {
1799                         msleep(2500);
1800                 }
1801
1802                 if (i == 15) {
1803                         phba->hba_state = LPFC_STATE_UNKNOWN; /* Do post */
1804                         lpfc_sli_brdrestart(phba);
1805                 }
1806                 /* Read the HBA Host Status Register */
1807                 status = readl(phba->HSregaddr);
1808         }
1809
1810         /* Check to see if any errors occurred during init */
1811         if (status & HS_FFERM) {
1812                 /* ERROR: During chipset initialization */
1813                 /* Adapter failed to init, chipset, status reg <status> */
1814                 lpfc_printf_log(phba,
1815                                 KERN_ERR,
1816                                 LOG_INIT,
1817                                 "%d:0438 Adapter failed to init, chipset, "
1818                                 "status reg x%x\n",
1819                                 phba->brd_no,
1820                                 status);
1821                 phba->hba_state = LPFC_HBA_ERROR;
1822                 return -EIO;
1823         }
1824
1825         /* Clear all interrupt enable conditions */
1826         writel(0, phba->HCregaddr);
1827         readl(phba->HCregaddr); /* flush */
1828
1829         /* setup host attn register */
1830         writel(0xffffffff, phba->HAregaddr);
1831         readl(phba->HAregaddr); /* flush */
1832         return 0;
1833 }
1834
1835 int
1836 lpfc_sli_hba_setup(struct lpfc_hba * phba)
1837 {
1838         LPFC_MBOXQ_t *pmb;
1839         uint32_t resetcount = 0, rc = 0, done = 0;
1840
1841         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1842         if (!pmb) {
1843                 phba->hba_state = LPFC_HBA_ERROR;
1844                 return -ENOMEM;
1845         }
1846
1847         while (resetcount < 2 && !done) {
1848                 phba->hba_state = LPFC_STATE_UNKNOWN;
1849                 lpfc_sli_brdrestart(phba);
1850                 msleep(2500);
1851                 rc = lpfc_sli_chipset_init(phba);
1852                 if (rc)
1853                         break;
1854
1855                 resetcount++;
1856
1857         /* Call pre CONFIG_PORT mailbox command initialization.  A value of 0
1858          * means the call was successful.  Any other nonzero value is a failure,
1859          * but if ERESTART is returned, the driver may reset the HBA and try
1860          * again.
1861          */
1862                 rc = lpfc_config_port_prep(phba);
1863                 if (rc == -ERESTART) {
1864                         phba->hba_state = 0;
1865                         continue;
1866                 } else if (rc) {
1867                         break;
1868                 }
1869
1870                 phba->hba_state = LPFC_INIT_MBX_CMDS;
1871                 lpfc_config_port(phba, pmb);
1872                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
1873                 if (rc == MBX_SUCCESS)
1874                         done = 1;
1875                 else {
1876                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1877                                 "%d:0442 Adapter failed to init, mbxCmd x%x "
1878                                 "CONFIG_PORT, mbxStatus x%x Data: x%x\n",
1879                                 phba->brd_no, pmb->mb.mbxCommand,
1880                                 pmb->mb.mbxStatus, 0);
1881                         phba->sli.sli_flag &= ~LPFC_SLI2_ACTIVE;
1882                 }
1883         }
1884         if (!done)
1885                 goto lpfc_sli_hba_setup_error;
1886
1887         rc = lpfc_sli_ring_map(phba, pmb);
1888
1889         if (rc)
1890                 goto lpfc_sli_hba_setup_error;
1891
1892         phba->sli.sli_flag |= LPFC_PROCESS_LA;
1893
1894         rc = lpfc_config_port_post(phba);
1895         if (rc)
1896                 goto lpfc_sli_hba_setup_error;
1897
1898         goto lpfc_sli_hba_setup_exit;
1899 lpfc_sli_hba_setup_error:
1900         phba->hba_state = LPFC_HBA_ERROR;
1901 lpfc_sli_hba_setup_exit:
1902         mempool_free(pmb, phba->mbox_mem_pool);
1903         return rc;
1904 }
1905
1906 static void
1907 lpfc_mbox_abort(struct lpfc_hba * phba)
1908 {
1909         LPFC_MBOXQ_t *pmbox;
1910         MAILBOX_t *mb;
1911
1912         if (phba->sli.mbox_active) {
1913                 del_timer_sync(&phba->sli.mbox_tmo);
1914                 phba->work_hba_events &= ~WORKER_MBOX_TMO;
1915                 pmbox = phba->sli.mbox_active;
1916                 mb = &pmbox->mb;
1917                 phba->sli.mbox_active = NULL;
1918                 if (pmbox->mbox_cmpl) {
1919                         mb->mbxStatus = MBX_NOT_FINISHED;
1920                         (pmbox->mbox_cmpl) (phba, pmbox);
1921                 }
1922                 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
1923         }
1924
1925         /* Abort all the non active mailbox commands. */
1926         spin_lock_irq(phba->host->host_lock);
1927         pmbox = lpfc_mbox_get(phba);
1928         while (pmbox) {
1929                 mb = &pmbox->mb;
1930                 if (pmbox->mbox_cmpl) {
1931                         mb->mbxStatus = MBX_NOT_FINISHED;
1932                         spin_unlock_irq(phba->host->host_lock);
1933                         (pmbox->mbox_cmpl) (phba, pmbox);
1934                         spin_lock_irq(phba->host->host_lock);
1935                 }
1936                 pmbox = lpfc_mbox_get(phba);
1937         }
1938         spin_unlock_irq(phba->host->host_lock);
1939         return;
1940 }
1941
1942 /*! lpfc_mbox_timeout
1943  *
1944  * \pre
1945  * \post
1946  * \param hba Pointer to per struct lpfc_hba structure
1947  * \param l1  Pointer to the driver's mailbox queue.
1948  * \return
1949  *   void
1950  *
1951  * \b Description:
1952  *
1953  * This routine handles mailbox timeout events at timer interrupt context.
1954  */
1955 void
1956 lpfc_mbox_timeout(unsigned long ptr)
1957 {
1958         struct lpfc_hba *phba;
1959         unsigned long iflag;
1960
1961         phba = (struct lpfc_hba *)ptr;
1962         spin_lock_irqsave(phba->host->host_lock, iflag);
1963         if (!(phba->work_hba_events & WORKER_MBOX_TMO)) {
1964                 phba->work_hba_events |= WORKER_MBOX_TMO;
1965                 if (phba->work_wait)
1966                         wake_up(phba->work_wait);
1967         }
1968         spin_unlock_irqrestore(phba->host->host_lock, iflag);
1969 }
1970
1971 void
1972 lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
1973 {
1974         LPFC_MBOXQ_t *pmbox;
1975         MAILBOX_t *mb;
1976
1977         spin_lock_irq(phba->host->host_lock);
1978         if (!(phba->work_hba_events & WORKER_MBOX_TMO)) {
1979                 spin_unlock_irq(phba->host->host_lock);
1980                 return;
1981         }
1982
1983         phba->work_hba_events &= ~WORKER_MBOX_TMO;
1984
1985         pmbox = phba->sli.mbox_active;
1986         mb = &pmbox->mb;
1987
1988         /* Mbox cmd <mbxCommand> timeout */
1989         lpfc_printf_log(phba,
1990                 KERN_ERR,
1991                 LOG_MBOX | LOG_SLI,
1992                 "%d:0310 Mailbox command x%x timeout Data: x%x x%x x%p\n",
1993                 phba->brd_no,
1994                 mb->mbxCommand,
1995                 phba->hba_state,
1996                 phba->sli.sli_flag,
1997                 phba->sli.mbox_active);
1998
1999         phba->sli.mbox_active = NULL;
2000         if (pmbox->mbox_cmpl) {
2001                 mb->mbxStatus = MBX_NOT_FINISHED;
2002                 spin_unlock_irq(phba->host->host_lock);
2003                 (pmbox->mbox_cmpl) (phba, pmbox);
2004                 spin_lock_irq(phba->host->host_lock);
2005         }
2006         phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
2007
2008         spin_unlock_irq(phba->host->host_lock);
2009         lpfc_mbox_abort(phba);
2010         return;
2011 }
2012
2013 int
2014 lpfc_sli_issue_mbox(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmbox, uint32_t flag)
2015 {
2016         MAILBOX_t *mb;
2017         struct lpfc_sli *psli;
2018         uint32_t status, evtctr;
2019         uint32_t ha_copy;
2020         int i;
2021         unsigned long drvr_flag = 0;
2022         volatile uint32_t word0, ldata;
2023         void __iomem *to_slim;
2024
2025         psli = &phba->sli;
2026
2027         spin_lock_irqsave(phba->host->host_lock, drvr_flag);
2028
2029
2030         mb = &pmbox->mb;
2031         status = MBX_SUCCESS;
2032
2033         if (phba->hba_state == LPFC_HBA_ERROR) {
2034                 spin_unlock_irqrestore(phba->host->host_lock, drvr_flag);
2035
2036                 /* Mbox command <mbxCommand> cannot issue */
2037                 LOG_MBOX_CANNOT_ISSUE_DATA( phba, mb, psli, flag)
2038                 return (MBX_NOT_FINISHED);
2039         }
2040
2041         if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {
2042                 /* Polling for a mbox command when another one is already active
2043                  * is not allowed in SLI. Also, the driver must have established
2044                  * SLI2 mode to queue and process multiple mbox commands.
2045                  */
2046
2047                 if (flag & MBX_POLL) {
2048                         spin_unlock_irqrestore(phba->host->host_lock,
2049                                                drvr_flag);
2050
2051                         /* Mbox command <mbxCommand> cannot issue */
2052                         LOG_MBOX_CANNOT_ISSUE_DATA( phba, mb, psli, flag)
2053                         return (MBX_NOT_FINISHED);
2054                 }
2055
2056                 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE)) {
2057                         spin_unlock_irqrestore(phba->host->host_lock,
2058                                                drvr_flag);
2059                         /* Mbox command <mbxCommand> cannot issue */
2060                         LOG_MBOX_CANNOT_ISSUE_DATA( phba, mb, psli, flag)
2061                         return (MBX_NOT_FINISHED);
2062                 }
2063
2064                 /* Handle STOP IOCB processing flag. This is only meaningful
2065                  * if we are not polling for mbox completion.
2066                  */
2067                 if (flag & MBX_STOP_IOCB) {
2068                         flag &= ~MBX_STOP_IOCB;
2069                         /* Now flag each ring */
2070                         for (i = 0; i < psli->num_rings; i++) {
2071                                 /* If the ring is active, flag it */
2072                                 if (psli->ring[i].cmdringaddr) {
2073                                         psli->ring[i].flag |=
2074                                             LPFC_STOP_IOCB_MBX;
2075                                 }
2076                         }
2077                 }
2078
2079                 /* Another mailbox command is still being processed, queue this
2080                  * command to be processed later.
2081                  */
2082                 lpfc_mbox_put(phba, pmbox);
2083
2084                 /* Mbox cmd issue - BUSY */
2085                 lpfc_printf_log(phba,
2086                         KERN_INFO,
2087                         LOG_MBOX | LOG_SLI,
2088                         "%d:0308 Mbox cmd issue - BUSY Data: x%x x%x x%x x%x\n",
2089                         phba->brd_no,
2090                         mb->mbxCommand,
2091                         phba->hba_state,
2092                         psli->sli_flag,
2093                         flag);
2094
2095                 psli->slistat.mbox_busy++;
2096                 spin_unlock_irqrestore(phba->host->host_lock,
2097                                        drvr_flag);
2098
2099                 return (MBX_BUSY);
2100         }
2101
2102         /* Handle STOP IOCB processing flag. This is only meaningful
2103          * if we are not polling for mbox completion.
2104          */
2105         if (flag & MBX_STOP_IOCB) {
2106                 flag &= ~MBX_STOP_IOCB;
2107                 if (flag == MBX_NOWAIT) {
2108                         /* Now flag each ring */
2109                         for (i = 0; i < psli->num_rings; i++) {
2110                                 /* If the ring is active, flag it */
2111                                 if (psli->ring[i].cmdringaddr) {
2112                                         psli->ring[i].flag |=
2113                                             LPFC_STOP_IOCB_MBX;
2114                                 }
2115                         }
2116                 }
2117         }
2118
2119         psli->sli_flag |= LPFC_SLI_MBOX_ACTIVE;
2120
2121         /* If we are not polling, we MUST be in SLI2 mode */
2122         if (flag != MBX_POLL) {
2123                 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE) &&
2124                     (mb->mbxCommand != MBX_KILL_BOARD)) {
2125                         psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
2126                         spin_unlock_irqrestore(phba->host->host_lock,
2127                                                drvr_flag);
2128                         /* Mbox command <mbxCommand> cannot issue */
2129                         LOG_MBOX_CANNOT_ISSUE_DATA( phba, mb, psli, flag);
2130                         return (MBX_NOT_FINISHED);
2131                 }
2132                 /* timeout active mbox command */
2133                 mod_timer(&psli->mbox_tmo, jiffies + HZ * LPFC_MBOX_TMO);
2134         }
2135
2136         /* Mailbox cmd <cmd> issue */
2137         lpfc_printf_log(phba,
2138                 KERN_INFO,
2139                 LOG_MBOX | LOG_SLI,
2140                 "%d:0309 Mailbox cmd x%x issue Data: x%x x%x x%x\n",
2141                 phba->brd_no,
2142                 mb->mbxCommand,
2143                 phba->hba_state,
2144                 psli->sli_flag,
2145                 flag);
2146
2147         psli->slistat.mbox_cmd++;
2148         evtctr = psli->slistat.mbox_event;
2149
2150         /* next set own bit for the adapter and copy over command word */
2151         mb->mbxOwner = OWN_CHIP;
2152
2153         if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
2154                 /* First copy command data to host SLIM area */
2155                 lpfc_sli_pcimem_bcopy(mb, &phba->slim2p->mbx, MAILBOX_CMD_SIZE);
2156         } else {
2157                 if (mb->mbxCommand == MBX_CONFIG_PORT ||
2158                     mb->mbxCommand == MBX_KILL_BOARD) {
2159                         /* copy command data into host mbox for cmpl */
2160                         lpfc_sli_pcimem_bcopy(mb, &phba->slim2p->mbx,
2161                                         MAILBOX_CMD_SIZE);
2162                 }
2163
2164                 /* First copy mbox command data to HBA SLIM, skip past first
2165                    word */
2166                 to_slim = phba->MBslimaddr + sizeof (uint32_t);
2167                 lpfc_memcpy_to_slim(to_slim, &mb->un.varWords[0],
2168                             MAILBOX_CMD_SIZE - sizeof (uint32_t));
2169
2170                 /* Next copy over first word, with mbxOwner set */
2171                 ldata = *((volatile uint32_t *)mb);
2172                 to_slim = phba->MBslimaddr;
2173                 writel(ldata, to_slim);
2174                 readl(to_slim); /* flush */
2175
2176                 if (mb->mbxCommand == MBX_CONFIG_PORT) {
2177                         /* switch over to host mailbox */
2178                         psli->sli_flag |= LPFC_SLI2_ACTIVE;
2179                 }
2180         }
2181
2182         wmb();
2183         /* interrupt board to doit right away */
2184         writel(CA_MBATT, phba->CAregaddr);
2185         readl(phba->CAregaddr); /* flush */
2186
2187         switch (flag) {
2188         case MBX_NOWAIT:
2189                 /* Don't wait for it to finish, just return */
2190                 psli->mbox_active = pmbox;
2191                 break;
2192
2193         case MBX_POLL:
2194                 i = 0;
2195                 psli->mbox_active = NULL;
2196                 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
2197                         /* First read mbox status word */
2198                         word0 = *((volatile uint32_t *)&phba->slim2p->mbx);
2199                         word0 = le32_to_cpu(word0);
2200                 } else {
2201                         /* First read mbox status word */
2202                         word0 = readl(phba->MBslimaddr);
2203                 }
2204
2205                 /* Read the HBA Host Attention Register */
2206                 ha_copy = readl(phba->HAregaddr);
2207
2208                 /* Wait for command to complete */
2209                 while (((word0 & OWN_CHIP) == OWN_CHIP) ||
2210                        (!(ha_copy & HA_MBATT) &&
2211                         (phba->hba_state > LPFC_WARM_START))) {
2212                         if (i++ >= 100) {
2213                                 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
2214                                 spin_unlock_irqrestore(phba->host->host_lock,
2215                                                        drvr_flag);
2216                                 return (MBX_NOT_FINISHED);
2217                         }
2218
2219                         /* Check if we took a mbox interrupt while we were
2220                            polling */
2221                         if (((word0 & OWN_CHIP) != OWN_CHIP)
2222                             && (evtctr != psli->slistat.mbox_event))
2223                                 break;
2224
2225                         spin_unlock_irqrestore(phba->host->host_lock,
2226                                                drvr_flag);
2227
2228                         /* Can be in interrupt context, do not sleep */
2229                         /* (or might be called with interrupts disabled) */
2230                         mdelay(i);
2231
2232                         spin_lock_irqsave(phba->host->host_lock, drvr_flag);
2233
2234                         if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
2235                                 /* First copy command data */
2236                                 word0 = *((volatile uint32_t *)
2237                                                 &phba->slim2p->mbx);
2238                                 word0 = le32_to_cpu(word0);
2239                                 if (mb->mbxCommand == MBX_CONFIG_PORT) {
2240                                         MAILBOX_t *slimmb;
2241                                         volatile uint32_t slimword0;
2242                                         /* Check real SLIM for any errors */
2243                                         slimword0 = readl(phba->MBslimaddr);
2244                                         slimmb = (MAILBOX_t *) & slimword0;
2245                                         if (((slimword0 & OWN_CHIP) != OWN_CHIP)
2246                                             && slimmb->mbxStatus) {
2247                                                 psli->sli_flag &=
2248                                                     ~LPFC_SLI2_ACTIVE;
2249                                                 word0 = slimword0;
2250                                         }
2251                                 }
2252                         } else {
2253                                 /* First copy command data */
2254                                 word0 = readl(phba->MBslimaddr);
2255                         }
2256                         /* Read the HBA Host Attention Register */
2257                         ha_copy = readl(phba->HAregaddr);
2258                 }
2259
2260                 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
2261                         /* copy results back to user */
2262                         lpfc_sli_pcimem_bcopy(&phba->slim2p->mbx, mb,
2263                                         MAILBOX_CMD_SIZE);
2264                 } else {
2265                         /* First copy command data */
2266                         lpfc_memcpy_from_slim(mb, phba->MBslimaddr,
2267                                                         MAILBOX_CMD_SIZE);
2268                         if ((mb->mbxCommand == MBX_DUMP_MEMORY) &&
2269                                 pmbox->context2) {
2270                                 lpfc_memcpy_from_slim((void *)pmbox->context2,
2271                                       phba->MBslimaddr + DMP_RSP_OFFSET,
2272                                                       mb->un.varDmp.word_cnt);
2273                         }
2274                 }
2275
2276                 writel(HA_MBATT, phba->HAregaddr);
2277                 readl(phba->HAregaddr); /* flush */
2278
2279                 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
2280                 status = mb->mbxStatus;
2281         }
2282
2283         spin_unlock_irqrestore(phba->host->host_lock, drvr_flag);
2284         return (status);
2285 }
2286
2287 static int
2288 lpfc_sli_ringtx_put(struct lpfc_hba * phba, struct lpfc_sli_ring * pring,
2289                     struct lpfc_iocbq * piocb)
2290 {
2291         /* Insert the caller's iocb in the txq tail for later processing. */
2292         list_add_tail(&piocb->list, &pring->txq);
2293         pring->txq_cnt++;
2294         return (0);
2295 }
2296
2297 static struct lpfc_iocbq *
2298 lpfc_sli_next_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2299                    struct lpfc_iocbq ** piocb)
2300 {
2301         struct lpfc_iocbq * nextiocb;
2302
2303         nextiocb = lpfc_sli_ringtx_get(phba, pring);
2304         if (!nextiocb) {
2305                 nextiocb = *piocb;
2306                 *piocb = NULL;
2307         }
2308
2309         return nextiocb;
2310 }
2311
2312 int
2313 lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2314                     struct lpfc_iocbq *piocb, uint32_t flag)
2315 {
2316         struct lpfc_iocbq *nextiocb;
2317         IOCB_t *iocb;
2318
2319         /*
2320          * We should never get an IOCB if we are in a < LINK_DOWN state
2321          */
2322         if (unlikely(phba->hba_state < LPFC_LINK_DOWN))
2323                 return IOCB_ERROR;
2324
2325         /*
2326          * Check to see if we are blocking IOCB processing because of a
2327          * outstanding mbox command.
2328          */
2329         if (unlikely(pring->flag & LPFC_STOP_IOCB_MBX))
2330                 goto iocb_busy;
2331
2332         if (unlikely(phba->hba_state == LPFC_LINK_DOWN)) {
2333                 /*
2334                  * Only CREATE_XRI, CLOSE_XRI, ABORT_XRI, and QUE_RING_BUF
2335                  * can be issued if the link is not up.
2336                  */
2337                 switch (piocb->iocb.ulpCommand) {
2338                 case CMD_QUE_RING_BUF_CN:
2339                 case CMD_QUE_RING_BUF64_CN:
2340                         /*
2341                          * For IOCBs, like QUE_RING_BUF, that have no rsp ring
2342                          * completion, iocb_cmpl MUST be 0.
2343                          */
2344                         if (piocb->iocb_cmpl)
2345                                 piocb->iocb_cmpl = NULL;
2346                         /*FALLTHROUGH*/
2347                 case CMD_CREATE_XRI_CR:
2348                         break;
2349                 default:
2350                         goto iocb_busy;
2351                 }
2352
2353         /*
2354          * For FCP commands, we must be in a state where we can process link
2355          * attention events.
2356          */
2357         } else if (unlikely(pring->ringno == phba->sli.fcp_ring &&
2358                    !(phba->sli.sli_flag & LPFC_PROCESS_LA)))
2359                 goto iocb_busy;
2360
2361         while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
2362                (nextiocb = lpfc_sli_next_iocb(phba, pring, &piocb)))
2363                 lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
2364
2365         if (iocb)
2366                 lpfc_sli_update_ring(phba, pring);
2367         else
2368                 lpfc_sli_update_full_ring(phba, pring);
2369
2370         if (!piocb)
2371                 return IOCB_SUCCESS;
2372
2373         goto out_busy;
2374
2375  iocb_busy:
2376         pring->stats.iocb_cmd_delay++;
2377
2378  out_busy:
2379
2380         if (!(flag & SLI_IOCB_RET_IOCB)) {
2381                 lpfc_sli_ringtx_put(phba, pring, piocb);
2382                 return IOCB_SUCCESS;
2383         }
2384
2385         return IOCB_BUSY;
2386 }
2387
2388 static int
2389 lpfc_extra_ring_setup( struct lpfc_hba *phba)
2390 {
2391         struct lpfc_sli *psli;
2392         struct lpfc_sli_ring *pring;
2393
2394         psli = &phba->sli;
2395
2396         /* Adjust cmd/rsp ring iocb entries more evenly */
2397         pring = &psli->ring[psli->fcp_ring];
2398         pring->numCiocb -= SLI2_IOCB_CMD_R1XTRA_ENTRIES;
2399         pring->numRiocb -= SLI2_IOCB_RSP_R1XTRA_ENTRIES;
2400         pring->numCiocb -= SLI2_IOCB_CMD_R3XTRA_ENTRIES;
2401         pring->numRiocb -= SLI2_IOCB_RSP_R3XTRA_ENTRIES;
2402
2403         pring = &psli->ring[1];
2404         pring->numCiocb += SLI2_IOCB_CMD_R1XTRA_ENTRIES;
2405         pring->numRiocb += SLI2_IOCB_RSP_R1XTRA_ENTRIES;
2406         pring->numCiocb += SLI2_IOCB_CMD_R3XTRA_ENTRIES;
2407         pring->numRiocb += SLI2_IOCB_RSP_R3XTRA_ENTRIES;
2408
2409         /* Setup default profile for this ring */
2410         pring->iotag_max = 4096;
2411         pring->num_mask = 1;
2412         pring->prt[0].profile = 0;      /* Mask 0 */
2413         pring->prt[0].rctl = FC_UNSOL_DATA;
2414         pring->prt[0].type = 5;
2415         pring->prt[0].lpfc_sli_rcv_unsol_event = NULL;
2416         return 0;
2417 }
2418
2419 int
2420 lpfc_sli_setup(struct lpfc_hba *phba)
2421 {
2422         int i, totiocb = 0;
2423         struct lpfc_sli *psli = &phba->sli;
2424         struct lpfc_sli_ring *pring;
2425
2426         psli->num_rings = MAX_CONFIGURED_RINGS;
2427         psli->sli_flag = 0;
2428         psli->fcp_ring = LPFC_FCP_RING;
2429         psli->next_ring = LPFC_FCP_NEXT_RING;
2430         psli->ip_ring = LPFC_IP_RING;
2431
2432         psli->iocbq_lookup = NULL;
2433         psli->iocbq_lookup_len = 0;
2434         psli->last_iotag = 0;
2435
2436         for (i = 0; i < psli->num_rings; i++) {
2437                 pring = &psli->ring[i];
2438                 switch (i) {
2439                 case LPFC_FCP_RING:     /* ring 0 - FCP */
2440                         /* numCiocb and numRiocb are used in config_port */
2441                         pring->numCiocb = SLI2_IOCB_CMD_R0_ENTRIES;
2442                         pring->numRiocb = SLI2_IOCB_RSP_R0_ENTRIES;
2443                         pring->numCiocb += SLI2_IOCB_CMD_R1XTRA_ENTRIES;
2444                         pring->numRiocb += SLI2_IOCB_RSP_R1XTRA_ENTRIES;
2445                         pring->numCiocb += SLI2_IOCB_CMD_R3XTRA_ENTRIES;
2446                         pring->numRiocb += SLI2_IOCB_RSP_R3XTRA_ENTRIES;
2447                         pring->iotag_ctr = 0;
2448                         pring->iotag_max =
2449                             (phba->cfg_hba_queue_depth * 2);
2450                         pring->fast_iotag = pring->iotag_max;
2451                         pring->num_mask = 0;
2452                         break;
2453                 case LPFC_IP_RING:      /* ring 1 - IP */
2454                         /* numCiocb and numRiocb are used in config_port */
2455                         pring->numCiocb = SLI2_IOCB_CMD_R1_ENTRIES;
2456                         pring->numRiocb = SLI2_IOCB_RSP_R1_ENTRIES;
2457                         pring->num_mask = 0;
2458                         break;
2459                 case LPFC_ELS_RING:     /* ring 2 - ELS / CT */
2460                         /* numCiocb and numRiocb are used in config_port */
2461                         pring->numCiocb = SLI2_IOCB_CMD_R2_ENTRIES;
2462                         pring->numRiocb = SLI2_IOCB_RSP_R2_ENTRIES;
2463                         pring->fast_iotag = 0;
2464                         pring->iotag_ctr = 0;
2465                         pring->iotag_max = 4096;
2466                         pring->num_mask = 4;
2467                         pring->prt[0].profile = 0;      /* Mask 0 */
2468                         pring->prt[0].rctl = FC_ELS_REQ;
2469                         pring->prt[0].type = FC_ELS_DATA;
2470                         pring->prt[0].lpfc_sli_rcv_unsol_event =
2471                             lpfc_els_unsol_event;
2472                         pring->prt[1].profile = 0;      /* Mask 1 */
2473                         pring->prt[1].rctl = FC_ELS_RSP;
2474                         pring->prt[1].type = FC_ELS_DATA;
2475                         pring->prt[1].lpfc_sli_rcv_unsol_event =
2476                             lpfc_els_unsol_event;
2477                         pring->prt[2].profile = 0;      /* Mask 2 */
2478                         /* NameServer Inquiry */
2479                         pring->prt[2].rctl = FC_UNSOL_CTL;
2480                         /* NameServer */
2481                         pring->prt[2].type = FC_COMMON_TRANSPORT_ULP;
2482                         pring->prt[2].lpfc_sli_rcv_unsol_event =
2483                             lpfc_ct_unsol_event;
2484                         pring->prt[3].profile = 0;      /* Mask 3 */
2485                         /* NameServer response */
2486                         pring->prt[3].rctl = FC_SOL_CTL;
2487                         /* NameServer */
2488                         pring->prt[3].type = FC_COMMON_TRANSPORT_ULP;
2489                         pring->prt[3].lpfc_sli_rcv_unsol_event =
2490                             lpfc_ct_unsol_event;
2491                         break;
2492                 }
2493                 totiocb += (pring->numCiocb + pring->numRiocb);
2494         }
2495         if (totiocb > MAX_SLI2_IOCB) {
2496                 /* Too many cmd / rsp ring entries in SLI2 SLIM */
2497                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2498                                 "%d:0462 Too many cmd / rsp ring entries in "
2499                                 "SLI2 SLIM Data: x%x x%x\n",
2500                                 phba->brd_no, totiocb, MAX_SLI2_IOCB);
2501         }
2502         if (phba->cfg_multi_ring_support == 2)
2503                 lpfc_extra_ring_setup(phba);
2504
2505         return 0;
2506 }
2507
2508 int
2509 lpfc_sli_queue_setup(struct lpfc_hba * phba)
2510 {
2511         struct lpfc_sli *psli;
2512         struct lpfc_sli_ring *pring;
2513         int i;
2514
2515         psli = &phba->sli;
2516         spin_lock_irq(phba->host->host_lock);
2517         INIT_LIST_HEAD(&psli->mboxq);
2518         /* Initialize list headers for txq and txcmplq as double linked lists */
2519         for (i = 0; i < psli->num_rings; i++) {
2520                 pring = &psli->ring[i];
2521                 pring->ringno = i;
2522                 pring->next_cmdidx  = 0;
2523                 pring->local_getidx = 0;
2524                 pring->cmdidx = 0;
2525                 INIT_LIST_HEAD(&pring->txq);
2526                 INIT_LIST_HEAD(&pring->txcmplq);
2527                 INIT_LIST_HEAD(&pring->iocb_continueq);
2528                 INIT_LIST_HEAD(&pring->postbufq);
2529         }
2530         spin_unlock_irq(phba->host->host_lock);
2531         return (1);
2532 }
2533
2534 int
2535 lpfc_sli_hba_down(struct lpfc_hba * phba)
2536 {
2537         struct lpfc_sli *psli;
2538         struct lpfc_sli_ring *pring;
2539         LPFC_MBOXQ_t *pmb;
2540         struct lpfc_iocbq *iocb, *next_iocb;
2541         IOCB_t *icmd = NULL;
2542         int i;
2543         unsigned long flags = 0;
2544
2545         psli = &phba->sli;
2546         lpfc_hba_down_prep(phba);
2547
2548         spin_lock_irqsave(phba->host->host_lock, flags);
2549
2550         for (i = 0; i < psli->num_rings; i++) {
2551                 pring = &psli->ring[i];
2552                 pring->flag |= LPFC_DEFERRED_RING_EVENT;
2553
2554                 /*
2555                  * Error everything on the txq since these iocbs have not been
2556                  * given to the FW yet.
2557                  */
2558                 pring->txq_cnt = 0;
2559
2560                 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
2561                         list_del_init(&iocb->list);
2562                         if (iocb->iocb_cmpl) {
2563                                 icmd = &iocb->iocb;
2564                                 icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
2565                                 icmd->un.ulpWord[4] = IOERR_SLI_DOWN;
2566                                 spin_unlock_irqrestore(phba->host->host_lock,
2567                                                        flags);
2568                                 (iocb->iocb_cmpl) (phba, iocb, iocb);
2569                                 spin_lock_irqsave(phba->host->host_lock, flags);
2570                         } else
2571                                 lpfc_sli_release_iocbq(phba, iocb);
2572                 }
2573
2574                 INIT_LIST_HEAD(&(pring->txq));
2575
2576                 kfree(pring->fast_lookup);
2577                 pring->fast_lookup = NULL;
2578         }
2579
2580         spin_unlock_irqrestore(phba->host->host_lock, flags);
2581
2582         /* Return any active mbox cmds */
2583         del_timer_sync(&psli->mbox_tmo);
2584         spin_lock_irqsave(phba->host->host_lock, flags);
2585         phba->work_hba_events &= ~WORKER_MBOX_TMO;
2586         if (psli->mbox_active) {
2587                 pmb = psli->mbox_active;
2588                 pmb->mb.mbxStatus = MBX_NOT_FINISHED;
2589                 if (pmb->mbox_cmpl) {
2590                         spin_unlock_irqrestore(phba->host->host_lock, flags);
2591                         pmb->mbox_cmpl(phba,pmb);
2592                         spin_lock_irqsave(phba->host->host_lock, flags);
2593                 }
2594         }
2595         psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
2596         psli->mbox_active = NULL;
2597
2598         /* Return any pending mbox cmds */
2599         while ((pmb = lpfc_mbox_get(phba)) != NULL) {
2600                 pmb->mb.mbxStatus = MBX_NOT_FINISHED;
2601                 if (pmb->mbox_cmpl) {
2602                         spin_unlock_irqrestore(phba->host->host_lock, flags);
2603                         pmb->mbox_cmpl(phba,pmb);
2604                         spin_lock_irqsave(phba->host->host_lock, flags);
2605                 }
2606         }
2607
2608         INIT_LIST_HEAD(&psli->mboxq);
2609
2610         spin_unlock_irqrestore(phba->host->host_lock, flags);
2611
2612         return 1;
2613 }
2614
2615 void
2616 lpfc_sli_pcimem_bcopy(void *srcp, void *destp, uint32_t cnt)
2617 {
2618         uint32_t *src = srcp;
2619         uint32_t *dest = destp;
2620         uint32_t ldata;
2621         int i;
2622
2623         for (i = 0; i < (int)cnt; i += sizeof (uint32_t)) {
2624                 ldata = *src;
2625                 ldata = le32_to_cpu(ldata);
2626                 *dest = ldata;
2627                 src++;
2628                 dest++;
2629         }
2630 }
2631
2632 int
2633 lpfc_sli_ringpostbuf_put(struct lpfc_hba * phba, struct lpfc_sli_ring * pring,
2634                          struct lpfc_dmabuf * mp)
2635 {
2636         /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
2637            later */
2638         list_add_tail(&mp->list, &pring->postbufq);
2639
2640         pring->postbufq_cnt++;
2641         return 0;
2642 }
2643
2644
2645 struct lpfc_dmabuf *
2646 lpfc_sli_ringpostbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2647                          dma_addr_t phys)
2648 {
2649         struct lpfc_dmabuf *mp, *next_mp;
2650         struct list_head *slp = &pring->postbufq;
2651
2652         /* Search postbufq, from the begining, looking for a match on phys */
2653         list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
2654                 if (mp->phys == phys) {
2655                         list_del_init(&mp->list);
2656                         pring->postbufq_cnt--;
2657                         return mp;
2658                 }
2659         }
2660
2661         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2662                         "%d:0410 Cannot find virtual addr for mapped buf on "
2663                         "ring %d Data x%llx x%p x%p x%x\n",
2664                         phba->brd_no, pring->ringno, (unsigned long long)phys,
2665                         slp->next, slp->prev, pring->postbufq_cnt);
2666         return NULL;
2667 }
2668
2669 static void
2670 lpfc_sli_abort_elsreq_cmpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2671                            struct lpfc_iocbq * rspiocb)
2672 {
2673         struct lpfc_dmabuf *buf_ptr, *buf_ptr1;
2674         /* Free the resources associated with the ELS_REQUEST64 IOCB the driver
2675          * just aborted.
2676          * In this case, context2  = cmd,  context2->next = rsp, context3 = bpl
2677          */
2678         if (cmdiocb->context2) {
2679                 buf_ptr1 = (struct lpfc_dmabuf *) cmdiocb->context2;
2680
2681                 /* Free the response IOCB before completing the abort
2682                    command.  */
2683                 buf_ptr = NULL;
2684                 list_remove_head((&buf_ptr1->list), buf_ptr,
2685                                  struct lpfc_dmabuf, list);
2686                 if (buf_ptr) {
2687                         lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
2688                         kfree(buf_ptr);
2689                 }
2690                 lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
2691                 kfree(buf_ptr1);
2692         }
2693
2694         if (cmdiocb->context3) {
2695                 buf_ptr = (struct lpfc_dmabuf *) cmdiocb->context3;
2696                 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
2697                 kfree(buf_ptr);
2698         }
2699
2700         lpfc_sli_release_iocbq(phba, cmdiocb);
2701         return;
2702 }
2703
2704 int
2705 lpfc_sli_issue_abort_iotag32(struct lpfc_hba * phba,
2706                              struct lpfc_sli_ring * pring,
2707                              struct lpfc_iocbq * cmdiocb)
2708 {
2709         struct lpfc_iocbq *abtsiocbp;
2710         IOCB_t *icmd = NULL;
2711         IOCB_t *iabt = NULL;
2712
2713         /* issue ABTS for this IOCB based on iotag */
2714         abtsiocbp = lpfc_sli_get_iocbq(phba);
2715         if (abtsiocbp == NULL)
2716                 return 0;
2717
2718         iabt = &abtsiocbp->iocb;
2719         icmd = &cmdiocb->iocb;
2720         switch (icmd->ulpCommand) {
2721         case CMD_ELS_REQUEST64_CR:
2722                 /* Even though we abort the ELS command, the firmware may access
2723                  * the BPL or other resources before it processes our
2724                  * ABORT_MXRI64. Thus we must delay reusing the cmdiocb
2725                  * resources till the actual abort request completes.
2726                  */
2727                 abtsiocbp->context1 = (void *)((unsigned long)icmd->ulpCommand);
2728                 abtsiocbp->context2 = cmdiocb->context2;
2729                 abtsiocbp->context3 = cmdiocb->context3;
2730                 cmdiocb->context2 = NULL;
2731                 cmdiocb->context3 = NULL;
2732                 abtsiocbp->iocb_cmpl = lpfc_sli_abort_elsreq_cmpl;
2733                 break;
2734         default:
2735                 lpfc_sli_release_iocbq(phba, abtsiocbp);
2736                 return 0;
2737         }
2738
2739         iabt->un.amxri.abortType = ABORT_TYPE_ABTS;
2740         iabt->un.amxri.iotag32 = icmd->un.elsreq64.bdl.ulpIoTag32;
2741
2742         iabt->ulpLe = 1;
2743         iabt->ulpClass = CLASS3;
2744         iabt->ulpCommand = CMD_ABORT_MXRI64_CN;
2745
2746         if (lpfc_sli_issue_iocb(phba, pring, abtsiocbp, 0) == IOCB_ERROR) {
2747                 lpfc_sli_release_iocbq(phba, abtsiocbp);
2748                 return 0;
2749         }
2750
2751         return 1;
2752 }
2753
2754 static int
2755 lpfc_sli_validate_fcp_iocb(struct lpfc_iocbq *iocbq, uint16_t tgt_id,
2756                            uint64_t lun_id, uint32_t ctx,
2757                            lpfc_ctx_cmd ctx_cmd)
2758 {
2759         struct lpfc_scsi_buf *lpfc_cmd;
2760         struct scsi_cmnd *cmnd;
2761         int rc = 1;
2762
2763         if (!(iocbq->iocb_flag &  LPFC_IO_FCP))
2764                 return rc;
2765
2766         lpfc_cmd = container_of(iocbq, struct lpfc_scsi_buf, cur_iocbq);
2767         cmnd = lpfc_cmd->pCmd;
2768
2769         if (cmnd == NULL)
2770                 return rc;
2771
2772         switch (ctx_cmd) {
2773         case LPFC_CTX_LUN:
2774                 if ((cmnd->device->id == tgt_id) &&
2775                     (cmnd->device->lun == lun_id))
2776                         rc = 0;
2777                 break;
2778         case LPFC_CTX_TGT:
2779                 if (cmnd->device->id == tgt_id)
2780                         rc = 0;
2781                 break;
2782         case LPFC_CTX_CTX:
2783                 if (iocbq->iocb.ulpContext == ctx)
2784                         rc = 0;
2785                 break;
2786         case LPFC_CTX_HOST:
2787                 rc = 0;
2788                 break;
2789         default:
2790                 printk(KERN_ERR "%s: Unknown context cmd type, value %d\n",
2791                         __FUNCTION__, ctx_cmd);
2792                 break;
2793         }
2794
2795         return rc;
2796 }
2797
2798 int
2799 lpfc_sli_sum_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2800                 uint16_t tgt_id, uint64_t lun_id, lpfc_ctx_cmd ctx_cmd)
2801 {
2802         struct lpfc_iocbq *iocbq;
2803         int sum, i;
2804
2805         for (i = 1, sum = 0; i <= phba->sli.last_iotag; i++) {
2806                 iocbq = phba->sli.iocbq_lookup[i];
2807
2808                 if (lpfc_sli_validate_fcp_iocb (iocbq, tgt_id, lun_id,
2809                                                 0, ctx_cmd) == 0)
2810                         sum++;
2811         }
2812
2813         return sum;
2814 }
2815
2816 void
2817 lpfc_sli_abort_fcp_cmpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2818                            struct lpfc_iocbq * rspiocb)
2819 {
2820         spin_lock_irq(phba->host->host_lock);
2821         lpfc_sli_release_iocbq(phba, cmdiocb);
2822         spin_unlock_irq(phba->host->host_lock);
2823         return;
2824 }
2825
2826 int
2827 lpfc_sli_abort_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2828                     uint16_t tgt_id, uint64_t lun_id, uint32_t ctx,
2829                     lpfc_ctx_cmd abort_cmd)
2830 {
2831         struct lpfc_iocbq *iocbq;
2832         struct lpfc_iocbq *abtsiocb;
2833         IOCB_t *cmd = NULL;
2834         int errcnt = 0, ret_val = 0;
2835         int i;
2836
2837         for (i = 1; i <= phba->sli.last_iotag; i++) {
2838                 iocbq = phba->sli.iocbq_lookup[i];
2839
2840                 if (lpfc_sli_validate_fcp_iocb (iocbq, tgt_id, lun_id,
2841                                                 0, abort_cmd) != 0)
2842                         continue;
2843
2844                 /* issue ABTS for this IOCB based on iotag */
2845                 abtsiocb = lpfc_sli_get_iocbq(phba);
2846                 if (abtsiocb == NULL) {
2847                         errcnt++;
2848                         continue;
2849                 }
2850
2851                 cmd = &iocbq->iocb;
2852                 abtsiocb->iocb.un.acxri.abortType = ABORT_TYPE_ABTS;
2853                 abtsiocb->iocb.un.acxri.abortContextTag = cmd->ulpContext;
2854                 abtsiocb->iocb.un.acxri.abortIoTag = cmd->ulpIoTag;
2855                 abtsiocb->iocb.ulpLe = 1;
2856                 abtsiocb->iocb.ulpClass = cmd->ulpClass;
2857
2858                 if (phba->hba_state >= LPFC_LINK_UP)
2859                         abtsiocb->iocb.ulpCommand = CMD_ABORT_XRI_CN;
2860                 else
2861                         abtsiocb->iocb.ulpCommand = CMD_CLOSE_XRI_CN;
2862
2863                 /* Setup callback routine and issue the command. */
2864                 abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
2865                 ret_val = lpfc_sli_issue_iocb(phba, pring, abtsiocb, 0);
2866                 if (ret_val == IOCB_ERROR) {
2867                         lpfc_sli_release_iocbq(phba, abtsiocb);
2868                         errcnt++;
2869                         continue;
2870                 }
2871         }
2872
2873         return errcnt;
2874 }
2875
2876 static void
2877 lpfc_sli_wake_iocb_wait(struct lpfc_hba *phba,
2878                         struct lpfc_iocbq *cmdiocbq,
2879                         struct lpfc_iocbq *rspiocbq)
2880 {
2881         wait_queue_head_t *pdone_q;
2882         unsigned long iflags;
2883
2884         spin_lock_irqsave(phba->host->host_lock, iflags);
2885         cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
2886         if (cmdiocbq->context2 && rspiocbq)
2887                 memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
2888                        &rspiocbq->iocb, sizeof(IOCB_t));
2889
2890         pdone_q = cmdiocbq->context_un.wait_queue;
2891         spin_unlock_irqrestore(phba->host->host_lock, iflags);
2892         if (pdone_q)
2893                 wake_up(pdone_q);
2894         return;
2895 }
2896
2897 /*
2898  * Issue the caller's iocb and wait for its completion, but no longer than the
2899  * caller's timeout.  Note that iocb_flags is cleared before the
2900  * lpfc_sli_issue_call since the wake routine sets a unique value and by
2901  * definition this is a wait function.
2902  */
2903 int
2904 lpfc_sli_issue_iocb_wait(struct lpfc_hba * phba,
2905                          struct lpfc_sli_ring * pring,
2906                          struct lpfc_iocbq * piocb,
2907                          struct lpfc_iocbq * prspiocbq,
2908                          uint32_t timeout)
2909 {
2910         DECLARE_WAIT_QUEUE_HEAD(done_q);
2911         long timeleft, timeout_req = 0;
2912         int retval = IOCB_SUCCESS;
2913         uint32_t creg_val;
2914
2915         /*
2916          * If the caller has provided a response iocbq buffer, then context2
2917          * is NULL or its an error.
2918          */
2919         if (prspiocbq) {
2920                 if (piocb->context2)
2921                         return IOCB_ERROR;
2922                 piocb->context2 = prspiocbq;
2923         }
2924
2925         piocb->iocb_cmpl = lpfc_sli_wake_iocb_wait;
2926         piocb->context_un.wait_queue = &done_q;
2927         piocb->iocb_flag &= ~LPFC_IO_WAKE;
2928
2929         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
2930                 creg_val = readl(phba->HCregaddr);
2931                 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
2932                 writel(creg_val, phba->HCregaddr);
2933                 readl(phba->HCregaddr); /* flush */
2934         }
2935
2936         retval = lpfc_sli_issue_iocb(phba, pring, piocb, 0);
2937         if (retval == IOCB_SUCCESS) {
2938                 timeout_req = timeout * HZ;
2939                 spin_unlock_irq(phba->host->host_lock);
2940                 timeleft = wait_event_timeout(done_q,
2941                                 piocb->iocb_flag & LPFC_IO_WAKE,
2942                                 timeout_req);
2943                 spin_lock_irq(phba->host->host_lock);
2944
2945                 if (timeleft == 0) {
2946                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2947                                         "%d:0329 IOCB wait timeout error - no "
2948                                         "wake response Data x%x\n",
2949                                         phba->brd_no, timeout);
2950                         retval = IOCB_TIMEDOUT;
2951                 } else if (!(piocb->iocb_flag & LPFC_IO_WAKE)) {
2952                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2953                                         "%d:0330 IOCB wake NOT set, "
2954                                         "Data x%x x%lx\n", phba->brd_no,
2955                                         timeout, (timeleft / jiffies));
2956                         retval = IOCB_TIMEDOUT;
2957                 } else {
2958                         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2959                                         "%d:0331 IOCB wake signaled\n",
2960                                         phba->brd_no);
2961                 }
2962         } else {
2963                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2964                                 "%d:0332 IOCB wait issue failed, Data x%x\n",
2965                                 phba->brd_no, retval);
2966                 retval = IOCB_ERROR;
2967         }
2968
2969         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
2970                 creg_val = readl(phba->HCregaddr);
2971                 creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
2972                 writel(creg_val, phba->HCregaddr);
2973                 readl(phba->HCregaddr); /* flush */
2974         }
2975
2976         if (prspiocbq)
2977                 piocb->context2 = NULL;
2978
2979         piocb->context_un.wait_queue = NULL;
2980         piocb->iocb_cmpl = NULL;
2981         return retval;
2982 }
2983
2984 int
2985 lpfc_sli_issue_mbox_wait(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq,
2986                          uint32_t timeout)
2987 {
2988         DECLARE_WAIT_QUEUE_HEAD(done_q);
2989         DECLARE_WAITQUEUE(wq_entry, current);
2990         uint32_t timeleft = 0;
2991         int retval;
2992
2993         /* The caller must leave context1 empty. */
2994         if (pmboxq->context1 != 0) {
2995                 return (MBX_NOT_FINISHED);
2996         }
2997
2998         /* setup wake call as IOCB callback */
2999         pmboxq->mbox_cmpl = lpfc_sli_wake_mbox_wait;
3000         /* setup context field to pass wait_queue pointer to wake function  */
3001         pmboxq->context1 = &done_q;
3002
3003         /* start to sleep before we wait, to avoid races */
3004         set_current_state(TASK_INTERRUPTIBLE);
3005         add_wait_queue(&done_q, &wq_entry);
3006
3007         /* now issue the command */
3008         retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
3009
3010         if (retval == MBX_BUSY || retval == MBX_SUCCESS) {