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-2008 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_nl.h"
  36 #include "lpfc_disc.h"
  37 #include "lpfc_scsi.h"
  38 #include "lpfc.h"
  39 #include "lpfc_crtn.h"
  40 #include "lpfc_logmsg.h"
  41 #include "lpfc_compat.h"
  42 #include "lpfc_debugfs.h"
  43
  44 /*
  45  * Define macro to log: Mailbox command x%x cannot issue Data
  46  * This allows multiple uses of lpfc_msgBlk0311
  47  * w/o perturbing log msg utility.
  48  */
  49 #define LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag) \
  50                         lpfc_printf_log(phba, \
  51                                 KERN_INFO, \
  52                                 LOG_MBOX | LOG_SLI, \
  53                                 "(%d):0311 Mailbox command x%x cannot " \
  54                                 "issue Data: x%x x%x x%x\n", \
  55                                 pmbox->vport ? pmbox->vport->vpi : 0, \
  56                                 pmbox->mb.mbxCommand,           \
  57                                 phba->pport->port_state,        \
  58                                 psli->sli_flag, \
  59                                 flag)
  60
  61
  62 /* There are only four IOCB completion types. */
  63 typedef enum _lpfc_iocb_type {
  64         LPFC_UNKNOWN_IOCB,
  65         LPFC_UNSOL_IOCB,
  66         LPFC_SOL_IOCB,
  67         LPFC_ABORT_IOCB
  68 } lpfc_iocb_type;
  69
  70 /**
  71  * lpfc_cmd_iocb - Get next command iocb entry in the ring
  72  * @phba: Pointer to HBA context object.
  73  * @pring: Pointer to driver SLI ring object.
  74  *
  75  * This function returns pointer to next command iocb entry
  76  * in the command ring. The caller must hold hbalock to prevent
  77  * other threads consume the next command iocb.
  78  * SLI-2/SLI-3 provide different sized iocbs.
  79  **/
  80 static inline IOCB_t *
  81 lpfc_cmd_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
  82 {
  83         return (IOCB_t *) (((char *) pring->cmdringaddr) +
  84                            pring->cmdidx * phba->iocb_cmd_size);
  85 }
  86
  87 /**
  88  * lpfc_resp_iocb - Get next response iocb entry in the ring
  89  * @phba: Pointer to HBA context object.
  90  * @pring: Pointer to driver SLI ring object.
  91  *
  92  * This function returns pointer to next response iocb entry
  93  * in the response ring. The caller must hold hbalock to make sure
  94  * that no other thread consume the next response iocb.
  95  * SLI-2/SLI-3 provide different sized iocbs.
  96  **/
  97 static inline IOCB_t *
  98 lpfc_resp_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
  99 {
 100         return (IOCB_t *) (((char *) pring->rspringaddr) +
 101                            pring->rspidx * phba->iocb_rsp_size);
 102 }
 103
 104 /**
 105  * __lpfc_sli_get_iocbq - Allocates an iocb object from iocb pool
 106  * @phba: Pointer to HBA context object.
 107  *
 108  * This function is called with hbalock held. This function
 109  * allocates a new driver iocb object from the iocb pool. If the
 110  * allocation is successful, it returns pointer to the newly
 111  * allocated iocb object else it returns NULL.
 112  **/
 113 static struct lpfc_iocbq *
 114 __lpfc_sli_get_iocbq(struct lpfc_hba *phba)
 115 {
 116         struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
 117         struct lpfc_iocbq * iocbq = NULL;
 118
 119         list_remove_head(lpfc_iocb_list, iocbq, struct lpfc_iocbq, list);
 120         return iocbq;
 121 }
 122
 123 /**
 124  * lpfc_sli_get_iocbq - Allocates an iocb object from iocb pool
 125  * @phba: Pointer to HBA context object.
 126  *
 127  * This function is called with no lock held. This function
 128  * allocates a new driver iocb object from the iocb pool. If the
 129  * allocation is successful, it returns pointer to the newly
 130  * allocated iocb object else it returns NULL.
 131  **/
 132 struct lpfc_iocbq *
 133 lpfc_sli_get_iocbq(struct lpfc_hba *phba)
 134 {
 135         struct lpfc_iocbq * iocbq = NULL;
 136         unsigned long iflags;
 137
 138         spin_lock_irqsave(&phba->hbalock, iflags);
 139         iocbq = __lpfc_sli_get_iocbq(phba);
 140         spin_unlock_irqrestore(&phba->hbalock, iflags);
 141         return iocbq;
 142 }
 143
 144 /**
 145  * __lpfc_sli_release_iocbq - Release iocb to the iocb pool
 146  * @phba: Pointer to HBA context object.
 147  * @iocbq: Pointer to driver iocb object.
 148  *
 149  * This function is called with hbalock held to release driver
 150  * iocb object to the iocb pool. The iotag in the iocb object
 151  * does not change for each use of the iocb object. This function
 152  * clears all other fields of the iocb object when it is freed.
 153  **/
 154 static void
 155 __lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
 156 {
 157         size_t start_clean = offsetof(struct lpfc_iocbq, iocb);
 158
 159         /*
 160          * Clean all volatile data fields, preserve iotag and node struct.
 161          */
 162         memset((char*)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean);
 163         list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
 164 }
 165
 166 /**
 167  * lpfc_sli_release_iocbq - Release iocb to the iocb pool
 168  * @phba: Pointer to HBA context object.
 169  * @iocbq: Pointer to driver iocb object.
 170  *
 171  * This function is called with no lock held to release the iocb to
 172  * iocb pool.
 173  **/
 174 void
 175 lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
 176 {
 177         unsigned long iflags;
 178
 179         /*
 180          * Clean all volatile data fields, preserve iotag and node struct.
 181          */
 182         spin_lock_irqsave(&phba->hbalock, iflags);
 183         __lpfc_sli_release_iocbq(phba, iocbq);
 184         spin_unlock_irqrestore(&phba->hbalock, iflags);
 185 }
 186
 187 /**
 188  * lpfc_sli_cancel_iocbs - Cancel all iocbs from a list.
 189  * @phba: Pointer to HBA context object.
 190  * @iocblist: List of IOCBs.
 191  * @ulpstatus: ULP status in IOCB command field.
 192  * @ulpWord4: ULP word-4 in IOCB command field.
 193  *
 194  * This function is called with a list of IOCBs to cancel. It cancels the IOCB
 195  * on the list by invoking the complete callback function associated with the
 196  * IOCB with the provided @ulpstatus and @ulpword4 set to the IOCB commond
 197  * fields.
 198  **/
 199 void
 200 lpfc_sli_cancel_iocbs(struct lpfc_hba *phba, struct list_head *iocblist,
 201                       uint32_t ulpstatus, uint32_t ulpWord4)
 202 {
 203         struct lpfc_iocbq *piocb;
 204
 205         while (!list_empty(iocblist)) {
 206                 list_remove_head(iocblist, piocb, struct lpfc_iocbq, list);
 207
 208                 if (!piocb->iocb_cmpl)
 209                         lpfc_sli_release_iocbq(phba, piocb);
 210                 else {
 211                         piocb->iocb.ulpStatus = ulpstatus;
 212                         piocb->iocb.un.ulpWord[4] = ulpWord4;
 213                         (piocb->iocb_cmpl) (phba, piocb, piocb);
 214                 }
 215         }
 216         return;
 217 }
 218
 219 /**
 220  * lpfc_sli_iocb_cmd_type - Get the iocb type
 221  * @iocb_cmnd: iocb command code.
 222  *
 223  * This function is called by ring event handler function to get the iocb type.
 224  * This function translates the iocb command to an iocb command type used to
 225  * decide the final disposition of each completed IOCB.
 226  * The function returns
 227  * LPFC_UNKNOWN_IOCB if it is an unsupported iocb
 228  * LPFC_SOL_IOCB     if it is a solicited iocb completion
 229  * LPFC_ABORT_IOCB   if it is an abort iocb
 230  * LPFC_UNSOL_IOCB   if it is an unsolicited iocb
 231  *
 232  * The caller is not required to hold any lock.
 233  **/
 234 static lpfc_iocb_type
 235 lpfc_sli_iocb_cmd_type(uint8_t iocb_cmnd)
 236 {
 237         lpfc_iocb_type type = LPFC_UNKNOWN_IOCB;
 238
 239         if (iocb_cmnd > CMD_MAX_IOCB_CMD)
 240                 return 0;
 241
 242         switch (iocb_cmnd) {
 243         case CMD_XMIT_SEQUENCE_CR:
 244         case CMD_XMIT_SEQUENCE_CX:
 245         case CMD_XMIT_BCAST_CN:
 246         case CMD_XMIT_BCAST_CX:
 247         case CMD_ELS_REQUEST_CR:
 248         case CMD_ELS_REQUEST_CX:
 249         case CMD_CREATE_XRI_CR:
 250         case CMD_CREATE_XRI_CX:
 251         case CMD_GET_RPI_CN:
 252         case CMD_XMIT_ELS_RSP_CX:
 253         case CMD_GET_RPI_CR:
 254         case CMD_FCP_IWRITE_CR:
 255         case CMD_FCP_IWRITE_CX:
 256         case CMD_FCP_IREAD_CR:
 257         case CMD_FCP_IREAD_CX:
 258         case CMD_FCP_ICMND_CR:
 259         case CMD_FCP_ICMND_CX:
 260         case CMD_FCP_TSEND_CX:
 261         case CMD_FCP_TRSP_CX:
 262         case CMD_FCP_TRECEIVE_CX:
 263         case CMD_FCP_AUTO_TRSP_CX:
 264         case CMD_ADAPTER_MSG:
 265         case CMD_ADAPTER_DUMP:
 266         case CMD_XMIT_SEQUENCE64_CR:
 267         case CMD_XMIT_SEQUENCE64_CX:
 268         case CMD_XMIT_BCAST64_CN:
 269         case CMD_XMIT_BCAST64_CX:
 270         case CMD_ELS_REQUEST64_CR:
 271         case CMD_ELS_REQUEST64_CX:
 272         case CMD_FCP_IWRITE64_CR:
 273         case CMD_FCP_IWRITE64_CX:
 274         case CMD_FCP_IREAD64_CR:
 275         case CMD_FCP_IREAD64_CX:
 276         case CMD_FCP_ICMND64_CR:
 277         case CMD_FCP_ICMND64_CX:
 278         case CMD_FCP_TSEND64_CX:
 279         case CMD_FCP_TRSP64_CX:
 280         case CMD_FCP_TRECEIVE64_CX:
 281         case CMD_GEN_REQUEST64_CR:
 282         case CMD_GEN_REQUEST64_CX:
 283         case CMD_XMIT_ELS_RSP64_CX:
 284                 type = LPFC_SOL_IOCB;
 285                 break;
 286         case CMD_ABORT_XRI_CN:
 287         case CMD_ABORT_XRI_CX:
 288         case CMD_CLOSE_XRI_CN:
 289         case CMD_CLOSE_XRI_CX:
 290         case CMD_XRI_ABORTED_CX:
 291         case CMD_ABORT_MXRI64_CN:
 292                 type = LPFC_ABORT_IOCB;
 293                 break;
 294         case CMD_RCV_SEQUENCE_CX:
 295         case CMD_RCV_ELS_REQ_CX:
 296         case CMD_RCV_SEQUENCE64_CX:
 297         case CMD_RCV_ELS_REQ64_CX:
 298         case CMD_ASYNC_STATUS:
 299         case CMD_IOCB_RCV_SEQ64_CX:
 300         case CMD_IOCB_RCV_ELS64_CX:
 301         case CMD_IOCB_RCV_CONT64_CX:
 302         case CMD_IOCB_RET_XRI64_CX:
 303                 type = LPFC_UNSOL_IOCB;
 304                 break;
 305         case CMD_IOCB_XMIT_MSEQ64_CR:
 306         case CMD_IOCB_XMIT_MSEQ64_CX:
 307         case CMD_IOCB_RCV_SEQ_LIST64_CX:
 308         case CMD_IOCB_RCV_ELS_LIST64_CX:
 309         case CMD_IOCB_CLOSE_EXTENDED_CN:
 310         case CMD_IOCB_ABORT_EXTENDED_CN:
 311         case CMD_IOCB_RET_HBQE64_CN:
 312         case CMD_IOCB_FCP_IBIDIR64_CR:
 313         case CMD_IOCB_FCP_IBIDIR64_CX:
 314         case CMD_IOCB_FCP_ITASKMGT64_CX:
 315         case CMD_IOCB_LOGENTRY_CN:
 316         case CMD_IOCB_LOGENTRY_ASYNC_CN:
 317                 printk("%s - Unhandled SLI-3 Command x%x\n",
 318                                 __func__, iocb_cmnd);
 319                 type = LPFC_UNKNOWN_IOCB;
 320                 break;
 321         default:
 322                 type = LPFC_UNKNOWN_IOCB;
 323                 break;
 324         }
 325
 326         return type;
 327 }
 328
 329 /**
 330  * lpfc_sli_ring_map - Issue config_ring mbox for all rings
 331  * @phba: Pointer to HBA context object.
 332  *
 333  * This function is called from SLI initialization code
 334  * to configure every ring of the HBA's SLI interface. The
 335  * caller is not required to hold any lock. This function issues
 336  * a config_ring mailbox command for each ring.
 337  * This function returns zero if successful else returns a negative
 338  * error code.
 339  **/
 340 static int
 341 lpfc_sli_ring_map(struct lpfc_hba *phba)
 342 {
 343         struct lpfc_sli *psli = &phba->sli;
 344         LPFC_MBOXQ_t *pmb;
 345         MAILBOX_t *pmbox;
 346         int i, rc, ret = 0;
 347
 348         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 349         if (!pmb)
 350                 return -ENOMEM;
 351         pmbox = &pmb->mb;
 352         phba->link_state = LPFC_INIT_MBX_CMDS;
 353         for (i = 0; i < psli->num_rings; i++) {
 354                 lpfc_config_ring(phba, i, pmb);
 355                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 356                 if (rc != MBX_SUCCESS) {
 357                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 358                                         "0446 Adapter failed to init (%d), "
 359                                         "mbxCmd x%x CFG_RING, mbxStatus x%x, "
 360                                         "ring %d\n",
 361                                         rc, pmbox->mbxCommand,
 362                                         pmbox->mbxStatus, i);
 363                         phba->link_state = LPFC_HBA_ERROR;
 364                         ret = -ENXIO;
 365                         break;
 366                 }
 367         }
 368         mempool_free(pmb, phba->mbox_mem_pool);
 369         return ret;
 370 }
 371
 372 /**
 373  * lpfc_sli_ringtxcmpl_put - Adds new iocb to the txcmplq
 374  * @phba: Pointer to HBA context object.
 375  * @pring: Pointer to driver SLI ring object.
 376  * @piocb: Pointer to the driver iocb object.
 377  *
 378  * This function is called with hbalock held. The function adds the
 379  * new iocb to txcmplq of the given ring. This function always returns
 380  * 0. If this function is called for ELS ring, this function checks if
 381  * there is a vport associated with the ELS command. This function also
 382  * starts els_tmofunc timer if this is an ELS command.
 383  **/
 384 static int
 385 lpfc_sli_ringtxcmpl_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
 386                         struct lpfc_iocbq *piocb)
 387 {
 388         list_add_tail(&piocb->list, &pring->txcmplq);
 389         pring->txcmplq_cnt++;
 390         if ((unlikely(pring->ringno == LPFC_ELS_RING)) &&
 391            (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
 392            (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN)) {
 393                 if (!piocb->vport)
 394                         BUG();
 395                 else
 396                         mod_timer(&piocb->vport->els_tmofunc,
 397                                   jiffies + HZ * (phba->fc_ratov << 1));
 398         }
 399
 400
 401         return 0;
 402 }
 403
 404 /**
 405  * lpfc_sli_ringtx_get - Get first element of the txq
 406  * @phba: Pointer to HBA context object.
 407  * @pring: Pointer to driver SLI ring object.
 408  *
 409  * This function is called with hbalock held to get next
 410  * iocb in txq of the given ring. If there is any iocb in
 411  * the txq, the function returns first iocb in the list after
 412  * removing the iocb from the list, else it returns NULL.
 413  **/
 414 static struct lpfc_iocbq *
 415 lpfc_sli_ringtx_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
 416 {
 417         struct lpfc_iocbq *cmd_iocb;
 418
 419         list_remove_head((&pring->txq), cmd_iocb, struct lpfc_iocbq, list);
 420         if (cmd_iocb != NULL)
 421                 pring->txq_cnt--;
 422         return cmd_iocb;
 423 }
 424
 425 /**
 426  * lpfc_sli_next_iocb_slot - Get next iocb slot in the ring
 427  * @phba: Pointer to HBA context object.
 428  * @pring: Pointer to driver SLI ring object.
 429  *
 430  * This function is called with hbalock held and the caller must post the
 431  * iocb without releasing the lock. If the caller releases the lock,
 432  * iocb slot returned by the function is not guaranteed to be available.
 433  * The function returns pointer to the next available iocb slot if there
 434  * is available slot in the ring, else it returns NULL.
 435  * If the get index of the ring is ahead of the put index, the function
 436  * will post an error attention event to the worker thread to take the
 437  * HBA to offline state.
 438  **/
 439 static IOCB_t *
 440 lpfc_sli_next_iocb_slot (struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
 441 {
 442         struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
 443         uint32_t  max_cmd_idx = pring->numCiocb;
 444         if ((pring->next_cmdidx == pring->cmdidx) &&
 445            (++pring->next_cmdidx >= max_cmd_idx))
 446                 pring->next_cmdidx = 0;
 447
 448         if (unlikely(pring->local_getidx == pring->next_cmdidx)) {
 449
 450                 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
 451
 452                 if (unlikely(pring->local_getidx >= max_cmd_idx)) {
 453                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
 454                                         "0315 Ring %d issue: portCmdGet %d "
 455                                         "is bigger than cmd ring %d\n",
 456                                         pring->ringno,
 457                                         pring->local_getidx, max_cmd_idx);
 458
 459                         phba->link_state = LPFC_HBA_ERROR;
 460                         /*
 461                          * All error attention handlers are posted to
 462                          * worker thread
 463                          */
 464                         phba->work_ha |= HA_ERATT;
 465                         phba->work_hs = HS_FFER3;
 466
 467                         lpfc_worker_wake_up(phba);
 468
 469                         return NULL;
 470                 }
 471
 472                 if (pring->local_getidx == pring->next_cmdidx)
 473                         return NULL;
 474         }
 475
 476         return lpfc_cmd_iocb(phba, pring);
 477 }
 478
 479 /**
 480  * lpfc_sli_next_iotag - Get an iotag for the iocb
 481  * @phba: Pointer to HBA context object.
 482  * @iocbq: Pointer to driver iocb object.
 483  *
 484  * This function gets an iotag for the iocb. If there is no unused iotag and
 485  * the iocbq_lookup_len < 0xffff, this function allocates a bigger iotag_lookup
 486  * array and assigns a new iotag.
 487  * The function returns the allocated iotag if successful, else returns zero.
 488  * Zero is not a valid iotag.
 489  * The caller is not required to hold any lock.
 490  **/
 491 uint16_t
 492 lpfc_sli_next_iotag(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
 493 {
 494         struct lpfc_iocbq **new_arr;
 495         struct lpfc_iocbq **old_arr;
 496         size_t new_len;
 497         struct lpfc_sli *psli = &phba->sli;
 498         uint16_t iotag;
 499
 500         spin_lock_irq(&phba->hbalock);
 501         iotag = psli->last_iotag;
 502         if(++iotag < psli->iocbq_lookup_len) {
 503                 psli->last_iotag = iotag;
 504                 psli->iocbq_lookup[iotag] = iocbq;
 505                 spin_unlock_irq(&phba->hbalock);
 506                 iocbq->iotag = iotag;
 507                 return iotag;
 508         } else if (psli->iocbq_lookup_len < (0xffff
 509                                            - LPFC_IOCBQ_LOOKUP_INCREMENT)) {
 510                 new_len = psli->iocbq_lookup_len + LPFC_IOCBQ_LOOKUP_INCREMENT;
 511                 spin_unlock_irq(&phba->hbalock);
 512                 new_arr = kzalloc(new_len * sizeof (struct lpfc_iocbq *),
 513                                   GFP_KERNEL);
 514                 if (new_arr) {
 515                         spin_lock_irq(&phba->hbalock);
 516                         old_arr = psli->iocbq_lookup;
 517                         if (new_len <= psli->iocbq_lookup_len) {
 518                                 /* highly unprobable case */
 519                                 kfree(new_arr);
 520                                 iotag = psli->last_iotag;
 521                                 if(++iotag < psli->iocbq_lookup_len) {
 522                                         psli->last_iotag = iotag;
 523                                         psli->iocbq_lookup[iotag] = iocbq;
 524                                         spin_unlock_irq(&phba->hbalock);
 525                                         iocbq->iotag = iotag;
 526                                         return iotag;
 527                                 }
 528                                 spin_unlock_irq(&phba->hbalock);
 529                                 return 0;
 530                         }
 531                         if (psli->iocbq_lookup)
 532                                 memcpy(new_arr, old_arr,
 533                                        ((psli->last_iotag  + 1) *
 534                                         sizeof (struct lpfc_iocbq *)));
 535                         psli->iocbq_lookup = new_arr;
 536                         psli->iocbq_lookup_len = new_len;
 537                         psli->last_iotag = iotag;
 538                         psli->iocbq_lookup[iotag] = iocbq;
 539                         spin_unlock_irq(&phba->hbalock);
 540                         iocbq->iotag = iotag;
 541                         kfree(old_arr);
 542                         return iotag;
 543                 }
 544         } else
 545                 spin_unlock_irq(&phba->hbalock);
 546
 547         lpfc_printf_log(phba, KERN_ERR,LOG_SLI,
 548                         "0318 Failed to allocate IOTAG.last IOTAG is %d\n",
 549                         psli->last_iotag);
 550
 551         return 0;
 552 }
 553
 554 /**
 555  * lpfc_sli_submit_iocb - Submit an iocb to the firmware
 556  * @phba: Pointer to HBA context object.
 557  * @pring: Pointer to driver SLI ring object.
 558  * @iocb: Pointer to iocb slot in the ring.
 559  * @nextiocb: Pointer to driver iocb object which need to be
 560  *            posted to firmware.
 561  *
 562  * This function is called with hbalock held to post a new iocb to
 563  * the firmware. This function copies the new iocb to ring iocb slot and
 564  * updates the ring pointers. It adds the new iocb to txcmplq if there is
 565  * a completion call back for this iocb else the function will free the
 566  * iocb object.
 567  **/
 568 static void
 569 lpfc_sli_submit_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
 570                 IOCB_t *iocb, struct lpfc_iocbq *nextiocb)
 571 {
 572         /*
 573          * Set up an iotag
 574          */
 575         nextiocb->iocb.ulpIoTag = (nextiocb->iocb_cmpl) ? nextiocb->iotag : 0;
 576
 577
 578         if (pring->ringno == LPFC_ELS_RING) {
 579                 lpfc_debugfs_slow_ring_trc(phba,
 580                         "IOCB cmd ring:   wd4:x%08x wd6:x%08x wd7:x%08x",
 581                         *(((uint32_t *) &nextiocb->iocb) + 4),
 582                         *(((uint32_t *) &nextiocb->iocb) + 6),
 583                         *(((uint32_t *) &nextiocb->iocb) + 7));
 584         }
 585
 586         /*
 587          * Issue iocb command to adapter
 588          */
 589         lpfc_sli_pcimem_bcopy(&nextiocb->iocb, iocb, phba->iocb_cmd_size);
 590         wmb();
 591         pring->stats.iocb_cmd++;
 592
 593         /*
 594          * If there is no completion routine to call, we can release the
 595          * IOCB buffer back right now. For IOCBs, like QUE_RING_BUF,
 596          * that have no rsp ring completion, iocb_cmpl MUST be NULL.
 597          */
 598         if (nextiocb->iocb_cmpl)
 599                 lpfc_sli_ringtxcmpl_put(phba, pring, nextiocb);
 600         else
 601                 __lpfc_sli_release_iocbq(phba, nextiocb);
 602
 603         /*
 604          * Let the HBA know what IOCB slot will be the next one the
 605          * driver will put a command into.
 606          */
 607         pring->cmdidx = pring->next_cmdidx;
 608         writel(pring->cmdidx, &phba->host_gp[pring->ringno].cmdPutInx);
 609 }
 610
 611 /**
 612  * lpfc_sli_update_full_ring - Update the chip attention register
 613  * @phba: Pointer to HBA context object.
 614  * @pring: Pointer to driver SLI ring object.
 615  *
 616  * The caller is not required to hold any lock for calling this function.
 617  * This function updates the chip attention bits for the ring to inform firmware
 618  * that there are pending work to be done for this ring and requests an
 619  * interrupt when there is space available in the ring. This function is
 620  * called when the driver is unable to post more iocbs to the ring due
 621  * to unavailability of space in the ring.
 622  **/
 623 static void
 624 lpfc_sli_update_full_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
 625 {
 626         int ringno = pring->ringno;
 627
 628         pring->flag |= LPFC_CALL_RING_AVAILABLE;
 629
 630         wmb();
 631
 632         /*
 633          * Set ring 'ringno' to SET R0CE_REQ in Chip Att register.
 634          * The HBA will tell us when an IOCB entry is available.
 635          */
 636         writel((CA_R0ATT|CA_R0CE_REQ) << (ringno*4), phba->CAregaddr);
 637         readl(phba->CAregaddr); /* flush */
 638
 639         pring->stats.iocb_cmd_full++;
 640 }
 641
 642 /**
 643  * lpfc_sli_update_ring - Update chip attention register
 644  * @phba: Pointer to HBA context object.
 645  * @pring: Pointer to driver SLI ring object.
 646  *
 647  * This function updates the chip attention register bit for the
 648  * given ring to inform HBA that there is more work to be done
 649  * in this ring. The caller is not required to hold any lock.
 650  **/
 651 static void
 652 lpfc_sli_update_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
 653 {
 654         int ringno = pring->ringno;
 655
 656         /*
 657          * Tell the HBA that there is work to do in this ring.
 658          */
 659         if (!(phba->sli3_options & LPFC_SLI3_CRP_ENABLED)) {
 660                 wmb();
 661                 writel(CA_R0ATT << (ringno * 4), phba->CAregaddr);
 662                 readl(phba->CAregaddr); /* flush */
 663         }
 664 }
 665
 666 /**
 667  * lpfc_sli_resume_iocb - Process iocbs in the txq
 668  * @phba: Pointer to HBA context object.
 669  * @pring: Pointer to driver SLI ring object.
 670  *
 671  * This function is called with hbalock held to post pending iocbs
 672  * in the txq to the firmware. This function is called when driver
 673  * detects space available in the ring.
 674  **/
 675 static void
 676 lpfc_sli_resume_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
 677 {
 678         IOCB_t *iocb;
 679         struct lpfc_iocbq *nextiocb;
 680
 681         /*
 682          * Check to see if:
 683          *  (a) there is anything on the txq to send
 684          *  (b) link is up
 685          *  (c) link attention events can be processed (fcp ring only)
 686          *  (d) IOCB processing is not blocked by the outstanding mbox command.
 687          */
 688         if (pring->txq_cnt &&
 689             lpfc_is_link_up(phba) &&
 690             (pring->ringno != phba->sli.fcp_ring ||
 691              phba->sli.sli_flag & LPFC_PROCESS_LA)) {
 692
 693                 while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
 694                        (nextiocb = lpfc_sli_ringtx_get(phba, pring)))
 695                         lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
 696
 697                 if (iocb)
 698                         lpfc_sli_update_ring(phba, pring);
 699                 else
 700                         lpfc_sli_update_full_ring(phba, pring);
 701         }
 702
 703         return;
 704 }
 705
 706 /**
 707  * lpfc_sli_next_hbq_slot - Get next hbq entry for the HBQ
 708  * @phba: Pointer to HBA context object.
 709  * @hbqno: HBQ number.
 710  *
 711  * This function is called with hbalock held to get the next
 712  * available slot for the given HBQ. If there is free slot
 713  * available for the HBQ it will return pointer to the next available
 714  * HBQ entry else it will return NULL.
 715  **/
 716 static struct lpfc_hbq_entry *
 717 lpfc_sli_next_hbq_slot(struct lpfc_hba *phba, uint32_t hbqno)
 718 {
 719         struct hbq_s *hbqp = &phba->hbqs[hbqno];
 720
 721         if (hbqp->next_hbqPutIdx == hbqp->hbqPutIdx &&
 722             ++hbqp->next_hbqPutIdx >= hbqp->entry_count)
 723                 hbqp->next_hbqPutIdx = 0;
 724
 725         if (unlikely(hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)) {
 726                 uint32_t raw_index = phba->hbq_get[hbqno];
 727                 uint32_t getidx = le32_to_cpu(raw_index);
 728
 729                 hbqp->local_hbqGetIdx = getidx;
 730
 731                 if (unlikely(hbqp->local_hbqGetIdx >= hbqp->entry_count)) {
 732                         lpfc_printf_log(phba, KERN_ERR,
 733                                         LOG_SLI | LOG_VPORT,
 734                                         "1802 HBQ %d: local_hbqGetIdx "
 735                                         "%u is > than hbqp->entry_count %u\n",
 736                                         hbqno, hbqp->local_hbqGetIdx,
 737                                         hbqp->entry_count);
 738
 739                         phba->link_state = LPFC_HBA_ERROR;
 740                         return NULL;
 741                 }
 742
 743                 if (hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)
 744                         return NULL;
 745         }
 746
 747         return (struct lpfc_hbq_entry *) phba->hbqs[hbqno].hbq_virt +
 748                         hbqp->hbqPutIdx;
 749 }
 750
 751 /**
 752  * lpfc_sli_hbqbuf_free_all - Free all the hbq buffers
 753  * @phba: Pointer to HBA context object.
 754  *
 755  * This function is called with no lock held to free all the
 756  * hbq buffers while uninitializing the SLI interface. It also
 757  * frees the HBQ buffers returned by the firmware but not yet
 758  * processed by the upper layers.
 759  **/
 760 void
 761 lpfc_sli_hbqbuf_free_all(struct lpfc_hba *phba)
 762 {
 763         struct lpfc_dmabuf *dmabuf, *next_dmabuf;
 764         struct hbq_dmabuf *hbq_buf;
 765         unsigned long flags;
 766         int i, hbq_count;
 767         uint32_t hbqno;
 768
 769         hbq_count = lpfc_sli_hbq_count();
 770         /* Return all memory used by all HBQs */
 771         spin_lock_irqsave(&phba->hbalock, flags);
 772         for (i = 0; i < hbq_count; ++i) {
 773                 list_for_each_entry_safe(dmabuf, next_dmabuf,
 774                                 &phba->hbqs[i].hbq_buffer_list, list) {
 775                         hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
 776                         list_del(&hbq_buf->dbuf.list);
 777                         (phba->hbqs[i].hbq_free_buffer)(phba, hbq_buf);
 778                 }
 779                 phba->hbqs[i].buffer_count = 0;
 780         }
 781         /* Return all HBQ buffer that are in-fly */
 782         list_for_each_entry_safe(dmabuf, next_dmabuf,
 783                         &phba->hbqbuf_in_list, list) {
 784                 hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
 785                 list_del(&hbq_buf->dbuf.list);
 786                 if (hbq_buf->tag == -1) {
 787                         (phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
 788                                 (phba, hbq_buf);
 789                 } else {
 790                         hbqno = hbq_buf->tag >> 16;
 791                         if (hbqno >= LPFC_MAX_HBQS)
 792                                 (phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer)
 793                                         (phba, hbq_buf);
 794                         else
 795                                 (phba->hbqs[hbqno].hbq_free_buffer)(phba,
 796                                         hbq_buf);
 797                 }
 798         }
 799
 800         /* Mark the HBQs not in use */
 801         phba->hbq_in_use = 0;
 802         spin_unlock_irqrestore(&phba->hbalock, flags);
 803 }
 804
 805 /**
 806  * lpfc_sli_hbq_to_firmware - Post the hbq buffer to firmware
 807  * @phba: Pointer to HBA context object.
 808  * @hbqno: HBQ number.
 809  * @hbq_buf: Pointer to HBQ buffer.
 810  *
 811  * This function is called with the hbalock held to post a
 812  * hbq buffer to the firmware. If the function finds an empty
 813  * slot in the HBQ, it will post the buffer. The function will return
 814  * pointer to the hbq entry if it successfully post the buffer
 815  * else it will return NULL.
 816  **/
 817 static struct lpfc_hbq_entry *
 818 lpfc_sli_hbq_to_firmware(struct lpfc_hba *phba, uint32_t hbqno,
 819                          struct hbq_dmabuf *hbq_buf)
 820 {
 821         struct lpfc_hbq_entry *hbqe;
 822         dma_addr_t physaddr = hbq_buf->dbuf.phys;
 823
 824         /* Get next HBQ entry slot to use */
 825         hbqe = lpfc_sli_next_hbq_slot(phba, hbqno);
 826         if (hbqe) {
 827                 struct hbq_s *hbqp = &phba->hbqs[hbqno];
 828
 829                 hbqe->bde.addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
 830                 hbqe->bde.addrLow  = le32_to_cpu(putPaddrLow(physaddr));
 831                 hbqe->bde.tus.f.bdeSize = hbq_buf->size;
 832                 hbqe->bde.tus.f.bdeFlags = 0;
 833                 hbqe->bde.tus.w = le32_to_cpu(hbqe->bde.tus.w);
 834                 hbqe->buffer_tag = le32_to_cpu(hbq_buf->tag);
 835                                 /* Sync SLIM */
 836                 hbqp->hbqPutIdx = hbqp->next_hbqPutIdx;
 837                 writel(hbqp->hbqPutIdx, phba->hbq_put + hbqno);
 838                                 /* flush */
 839                 readl(phba->hbq_put + hbqno);
 840                 list_add_tail(&hbq_buf->dbuf.list, &hbqp->hbq_buffer_list);
 841         }
 842         return hbqe;
 843 }
 844
 845 /* HBQ for ELS and CT traffic. */
 846 static struct lpfc_hbq_init lpfc_els_hbq = {
 847         .rn = 1,
 848         .entry_count = 200,
 849         .mask_count = 0,
 850         .profile = 0,
 851         .ring_mask = (1 << LPFC_ELS_RING),
 852         .buffer_count = 0,
 853         .init_count = 40,
 854         .add_count = 40,
 855 };
 856
 857 /* HBQ for the extra ring if needed */
 858 static struct lpfc_hbq_init lpfc_extra_hbq = {
 859         .rn = 1,
 860         .entry_count = 200,
 861         .mask_count = 0,
 862         .profile = 0,
 863         .ring_mask = (1 << LPFC_EXTRA_RING),
 864         .buffer_count = 0,
 865         .init_count = 0,
 866         .add_count = 5,
 867 };
 868
 869 /* Array of HBQs */
 870 struct lpfc_hbq_init *lpfc_hbq_defs[] = {
 871         &lpfc_els_hbq,
 872         &lpfc_extra_hbq,
 873 };
 874
 875 /**
 876  * lpfc_sli_hbqbuf_fill_hbqs - Post more hbq buffers to HBQ
 877  * @phba: Pointer to HBA context object.
 878  * @hbqno: HBQ number.
 879  * @count: Number of HBQ buffers to be posted.
 880  *
 881  * This function is called with no lock held to post more hbq buffers to the
 882  * given HBQ. The function returns the number of HBQ buffers successfully
 883  * posted.
 884  **/
 885 static int
 886 lpfc_sli_hbqbuf_fill_hbqs(struct lpfc_hba *phba, uint32_t hbqno, uint32_t count)
 887 {
 888         uint32_t i, posted = 0;
 889         unsigned long flags;
 890         struct hbq_dmabuf *hbq_buffer;
 891         LIST_HEAD(hbq_buf_list);
 892         if (!phba->hbqs[hbqno].hbq_alloc_buffer)
 893                 return 0;
 894
 895         if ((phba->hbqs[hbqno].buffer_count + count) >
 896             lpfc_hbq_defs[hbqno]->entry_count)
 897                 count = lpfc_hbq_defs[hbqno]->entry_count -
 898                                         phba->hbqs[hbqno].buffer_count;
 899         if (!count)
 900                 return 0;
 901         /* Allocate HBQ entries */
 902         for (i = 0; i < count; i++) {
 903                 hbq_buffer = (phba->hbqs[hbqno].hbq_alloc_buffer)(phba);
 904                 if (!hbq_buffer)
 905                         break;
 906                 list_add_tail(&hbq_buffer->dbuf.list, &hbq_buf_list);
 907         }
 908         /* Check whether HBQ is still in use */
 909         spin_lock_irqsave(&phba->hbalock, flags);
 910         if (!phba->hbq_in_use)
 911                 goto err;
 912         while (!list_empty(&hbq_buf_list)) {
 913                 list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
 914                                  dbuf.list);
 915                 hbq_buffer->tag = (phba->hbqs[hbqno].buffer_count |
 916                                       (hbqno << 16));
 917                 if (lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {
 918                         phba->hbqs[hbqno].buffer_count++;
 919                         posted++;
 920                 } else
 921                         (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
 922         }
 923         spin_unlock_irqrestore(&phba->hbalock, flags);
 924         return posted;
 925 err:
 926         spin_unlock_irqrestore(&phba->hbalock, flags);
 927         while (!list_empty(&hbq_buf_list)) {
 928                 list_remove_head(&hbq_buf_list, hbq_buffer, struct hbq_dmabuf,
 929                                  dbuf.list);
 930                 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
 931         }
 932         return 0;
 933 }
 934
 935 /**
 936  * lpfc_sli_hbqbuf_add_hbqs - Post more HBQ buffers to firmware
 937  * @phba: Pointer to HBA context object.
 938  * @qno: HBQ number.
 939  *
 940  * This function posts more buffers to the HBQ. This function
 941  * is called with no lock held. The function returns the number of HBQ entries
 942  * successfully allocated.
 943  **/
 944 int
 945 lpfc_sli_hbqbuf_add_hbqs(struct lpfc_hba *phba, uint32_t qno)
 946 {
 947         return(lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
 948                                          lpfc_hbq_defs[qno]->add_count));
 949 }
 950
 951 /**
 952  * lpfc_sli_hbqbuf_init_hbqs - Post initial buffers to the HBQ
 953  * @phba: Pointer to HBA context object.
 954  * @qno:  HBQ queue number.
 955  *
 956  * This function is called from SLI initialization code path with
 957  * no lock held to post initial HBQ buffers to firmware. The
 958  * function returns the number of HBQ entries successfully allocated.
 959  **/
 960 static int
 961 lpfc_sli_hbqbuf_init_hbqs(struct lpfc_hba *phba, uint32_t qno)
 962 {
 963         return(lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
 964                                          lpfc_hbq_defs[qno]->init_count));
 965 }
 966
 967 /**
 968  * lpfc_sli_hbqbuf_find - Find the hbq buffer associated with a tag
 969  * @phba: Pointer to HBA context object.
 970  * @tag: Tag of the hbq buffer.
 971  *
 972  * This function is called with hbalock held. This function searches
 973  * for the hbq buffer associated with the given tag in the hbq buffer
 974  * list. If it finds the hbq buffer, it returns the hbq_buffer other wise
 975  * it returns NULL.
 976  **/
 977 static struct hbq_dmabuf *
 978 lpfc_sli_hbqbuf_find(struct lpfc_hba *phba, uint32_t tag)
 979 {
 980         struct lpfc_dmabuf *d_buf;
 981         struct hbq_dmabuf *hbq_buf;
 982         uint32_t hbqno;
 983
 984         hbqno = tag >> 16;
 985         if (hbqno >= LPFC_MAX_HBQS)
 986                 return NULL;
 987
 988         list_for_each_entry(d_buf, &phba->hbqs[hbqno].hbq_buffer_list, list) {
 989                 hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
 990                 if (hbq_buf->tag == tag) {
 991                         return hbq_buf;
 992                 }
 993         }
 994         lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_VPORT,
 995                         "1803 Bad hbq tag. Data: x%x x%x\n",
 996                         tag, phba->hbqs[tag >> 16].buffer_count);
 997         return NULL;
 998 }
 999
1000 /**
1001  * lpfc_sli_free_hbq - Give back the hbq buffer to firmware
1002  * @phba: Pointer to HBA context object.
1003  * @hbq_buffer: Pointer to HBQ buffer.
1004  *
1005  * This function is called with hbalock. This function gives back
1006  * the hbq buffer to firmware. If the HBQ does not have space to
1007  * post the buffer, it will free the buffer.
1008  **/
1009 void
1010 lpfc_sli_free_hbq(struct lpfc_hba *phba, struct hbq_dmabuf *hbq_buffer)
1011 {
1012         uint32_t hbqno;
1013
1014         if (hbq_buffer) {
1015                 hbqno = hbq_buffer->tag >> 16;
1016                 if (!lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {
1017                         (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
1018                 }
1019         }
1020 }
1021
1022 /**
1023  * lpfc_sli_chk_mbx_command - Check if the mailbox is a legitimate mailbox
1024  * @mbxCommand: mailbox command code.
1025  *
1026  * This function is called by the mailbox event handler function to verify
1027  * that the completed mailbox command is a legitimate mailbox command. If the
1028  * completed mailbox is not known to the function, it will return MBX_SHUTDOWN
1029  * and the mailbox event handler will take the HBA offline.
1030  **/
1031 static int
1032 lpfc_sli_chk_mbx_command(uint8_t mbxCommand)
1033 {
1034         uint8_t ret;
1035
1036         switch (mbxCommand) {
1037         case MBX_LOAD_SM:
1038         case MBX_READ_NV:
1039         case MBX_WRITE_NV:
1040         case MBX_WRITE_VPARMS:
1041         case MBX_RUN_BIU_DIAG:
1042         case MBX_INIT_LINK:
1043         case MBX_DOWN_LINK:
1044         case MBX_CONFIG_LINK:
1045         case MBX_CONFIG_RING:
1046         case MBX_RESET_RING:
1047         case MBX_READ_CONFIG:
1048         case MBX_READ_RCONFIG:
1049         case MBX_READ_SPARM:
1050         case MBX_READ_STATUS:
1051         case MBX_READ_RPI:
1052         case MBX_READ_XRI:
1053         case MBX_READ_REV:
1054         case MBX_READ_LNK_STAT:
1055         case MBX_REG_LOGIN:
1056         case MBX_UNREG_LOGIN:
1057         case MBX_READ_LA:
1058         case MBX_CLEAR_LA:
1059         case MBX_DUMP_MEMORY:
1060         case MBX_DUMP_CONTEXT:
1061         case MBX_RUN_DIAGS:
1062         case MBX_RESTART:
1063         case MBX_UPDATE_CFG:
1064         case MBX_DOWN_LOAD:
1065         case MBX_DEL_LD_ENTRY:
1066         case MBX_RUN_PROGRAM:
1067         case MBX_SET_MASK:
1068         case MBX_SET_VARIABLE:
1069         case MBX_UNREG_D_ID:
1070         case MBX_KILL_BOARD:
1071         case MBX_CONFIG_FARP:
1072         case MBX_BEACON:
1073         case MBX_LOAD_AREA:
1074         case MBX_RUN_BIU_DIAG64:
1075         case MBX_CONFIG_PORT:
1076         case MBX_READ_SPARM64:
1077         case MBX_READ_RPI64:
1078         case MBX_REG_LOGIN64:
1079         case MBX_READ_LA64:
1080         case MBX_WRITE_WWN:
1081         case MBX_SET_DEBUG:
1082         case MBX_LOAD_EXP_ROM:
1083         case MBX_ASYNCEVT_ENABLE:
1084         case MBX_REG_VPI:
1085         case MBX_UNREG_VPI:
1086         case MBX_HEARTBEAT:
1087         case MBX_PORT_CAPABILITIES:
1088         case MBX_PORT_IOV_CONTROL:
1089                 ret = mbxCommand;
1090                 break;
1091         default:
1092                 ret = MBX_SHUTDOWN;
1093                 break;
1094         }
1095         return ret;
1096 }
1097
1098 /**
1099  * lpfc_sli_wake_mbox_wait - lpfc_sli_issue_mbox_wait mbox completion handler
1100  * @phba: Pointer to HBA context object.
1101  * @pmboxq: Pointer to mailbox command.
1102  *
1103  * This is completion handler function for mailbox commands issued from
1104  * lpfc_sli_issue_mbox_wait function. This function is called by the
1105  * mailbox event handler function with no lock held. This function
1106  * will wake up thread waiting on the wait queue pointed by context1
1107  * of the mailbox.
1108  **/
1109 static void
1110 lpfc_sli_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
1111 {
1112         wait_queue_head_t *pdone_q;
1113         unsigned long drvr_flag;
1114
1115         /*
1116          * If pdone_q is empty, the driver thread gave up waiting and
1117          * continued running.
1118          */
1119         pmboxq->mbox_flag |= LPFC_MBX_WAKE;
1120         spin_lock_irqsave(&phba->hbalock, drvr_flag);
1121         pdone_q = (wait_queue_head_t *) pmboxq->context1;
1122         if (pdone_q)
1123                 wake_up_interruptible(pdone_q);
1124         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
1125         return;
1126 }
1127
1128
1129 /**
1130  * lpfc_sli_def_mbox_cmpl - Default mailbox completion handler
1131  * @phba: Pointer to HBA context object.
1132  * @pmb: Pointer to mailbox object.
1133  *
1134  * This function is the default mailbox completion handler. It
1135  * frees the memory resources associated with the completed mailbox
1136  * command. If the completed command is a REG_LOGIN mailbox command,
1137  * this function will issue a UREG_LOGIN to re-claim the RPI.
1138  **/
1139 void
1140 lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1141 {
1142         struct lpfc_dmabuf *mp;
1143         uint16_t rpi;
1144         int rc;
1145
1146         mp = (struct lpfc_dmabuf *) (pmb->context1);
1147
1148         if (mp) {
1149                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1150                 kfree(mp);
1151         }
1152
1153         /*
1154          * If a REG_LOGIN succeeded  after node is destroyed or node
1155          * is in re-discovery driver need to cleanup the RPI.
1156          */
1157         if (!(phba->pport->load_flag & FC_UNLOADING) &&
1158             pmb->mb.mbxCommand == MBX_REG_LOGIN64 &&
1159             !pmb->mb.mbxStatus) {
1160
1161                 rpi = pmb->mb.un.varWords[0];
1162                 lpfc_unreg_login(phba, pmb->mb.un.varRegLogin.vpi, rpi, pmb);
1163                 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
1164                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
1165                 if (rc != MBX_NOT_FINISHED)
1166                         return;
1167         }
1168
1169         mempool_free(pmb, phba->mbox_mem_pool);
1170         return;
1171 }
1172
1173 /**
1174  * lpfc_sli_handle_mb_event - Handle mailbox completions from firmware
1175  * @phba: Pointer to HBA context object.
1176  *
1177  * This function is called with no lock held. This function processes all
1178  * the completed mailbox commands and gives it to upper layers. The interrupt
1179  * service routine processes mailbox completion interrupt and adds completed
1180  * mailbox commands to the mboxq_cmpl queue and signals the worker thread.
1181  * Worker thread call lpfc_sli_handle_mb_event, which will return the
1182  * completed mailbox commands in mboxq_cmpl queue to the upper layers. This
1183  * function returns the mailbox commands to the upper layer by calling the
1184  * completion handler function of each mailbox.
1185  **/
1186 int
1187 lpfc_sli_handle_mb_event(struct lpfc_hba *phba)
1188 {
1189         MAILBOX_t *pmbox;
1190         LPFC_MBOXQ_t *pmb;
1191         int rc;
1192         LIST_HEAD(cmplq);
1193
1194         phba->sli.slistat.mbox_event++;
1195
1196         /* Get all completed mailboxe buffers into the cmplq */
1197         spin_lock_irq(&phba->hbalock);
1198         list_splice_init(&phba->sli.mboxq_cmpl, &cmplq);
1199         spin_unlock_irq(&phba->hbalock);
1200
1201         /* Get a Mailbox buffer to setup mailbox commands for callback */
1202         do {
1203                 list_remove_head(&cmplq, pmb, LPFC_MBOXQ_t, list);
1204                 if (pmb == NULL)
1205                         break;
1206
1207                 pmbox = &pmb->mb;
1208
1209                 if (pmbox->mbxCommand != MBX_HEARTBEAT) {
1210                         if (pmb->vport) {
1211                                 lpfc_debugfs_disc_trc(pmb->vport,
1212                                         LPFC_DISC_TRC_MBOX_VPORT,
1213                                         "MBOX cmpl vport: cmd:x%x mb:x%x x%x",
1214                                         (uint32_t)pmbox->mbxCommand,
1215                                         pmbox->un.varWords[0],
1216                                         pmbox->un.varWords[1]);
1217                         }
1218                         else {
1219                                 lpfc_debugfs_disc_trc(phba->pport,
1220                                         LPFC_DISC_TRC_MBOX,
1221                                         "MBOX cmpl:       cmd:x%x mb:x%x x%x",
1222                                         (uint32_t)pmbox->mbxCommand,
1223                                         pmbox->un.varWords[0],
1224                                         pmbox->un.varWords[1]);
1225                         }
1226                 }
1227
1228                 /*
1229                  * It is a fatal error if unknown mbox command completion.
1230                  */
1231                 if (lpfc_sli_chk_mbx_command(pmbox->mbxCommand) ==
1232                     MBX_SHUTDOWN) {
1233                         /* Unknow mailbox command compl */
1234                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
1235                                         "(%d):0323 Unknown Mailbox command "
1236                                         "%x Cmpl\n",
1237                                         pmb->vport ? pmb->vport->vpi : 0,
1238                                         pmbox->mbxCommand);
1239                         phba->link_state = LPFC_HBA_ERROR;
1240                         phba->work_hs = HS_FFER3;
1241                         lpfc_handle_eratt(phba);
1242                         continue;
1243                 }
1244
1245                 if (pmbox->mbxStatus) {
1246                         phba->sli.slistat.mbox_stat_err++;
1247                         if (pmbox->mbxStatus == MBXERR_NO_RESOURCES) {
1248                                 /* Mbox cmd cmpl error - RETRYing */
1249                                 lpfc_printf_log(phba, KERN_INFO,
1250                                                 LOG_MBOX | LOG_SLI,
1251                                                 "(%d):0305 Mbox cmd cmpl "
1252                                                 "error - RETRYing Data: x%x "
1253                                                 "x%x x%x x%x\n",
1254                                                 pmb->vport ? pmb->vport->vpi :0,
1255                                                 pmbox->mbxCommand,
1256                                                 pmbox->mbxStatus,
1257                                                 pmbox->un.varWords[0],
1258                                                 pmb->vport->port_state);
1259                                 pmbox->mbxStatus = 0;
1260                                 pmbox->mbxOwner = OWN_HOST;
1261                                 spin_lock_irq(&phba->hbalock);
1262                                 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
1263                                 spin_unlock_irq(&phba->hbalock);
1264                                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
1265                                 if (rc == MBX_SUCCESS)
1266                                         continue;
1267                         }
1268                 }
1269
1270                 /* Mailbox cmd <cmd> Cmpl <cmpl> */
1271                 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
1272                                 "(%d):0307 Mailbox cmd x%x Cmpl x%p "
1273                                 "Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x\n",
1274                                 pmb->vport ? pmb->vport->vpi : 0,
1275                                 pmbox->mbxCommand,
1276                                 pmb->mbox_cmpl,
1277                                 *((uint32_t *) pmbox),
1278                                 pmbox->un.varWords[0],
1279                                 pmbox->un.varWords[1],
1280                                 pmbox->un.varWords[2],
1281                                 pmbox->un.varWords[3],
1282                                 pmbox->un.varWords[4],
1283                                 pmbox->un.varWords[5],
1284                                 pmbox->un.varWords[6],
1285                                 pmbox->un.varWords[7]);
1286
1287                 if (pmb->mbox_cmpl)
1288                         pmb->mbox_cmpl(phba,pmb);
1289         } while (1);
1290         return 0;
1291 }
1292
1293 /**
1294  * lpfc_sli_get_buff - Get the buffer associated with the buffer tag
1295  * @phba: Pointer to HBA context object.
1296  * @pring: Pointer to driver SLI ring object.
1297  * @tag: buffer tag.
1298  *
1299  * This function is called with no lock held. When QUE_BUFTAG_BIT bit
1300  * is set in the tag the buffer is posted for a particular exchange,
1301  * the function will return the buffer without replacing the buffer.
1302  * If the buffer is for unsolicited ELS or CT traffic, this function
1303  * returns the buffer and also posts another buffer to the firmware.
1304  **/
1305 static struct lpfc_dmabuf *
1306 lpfc_sli_get_buff(struct lpfc_hba *phba,
1307                   struct lpfc_sli_ring *pring,
1308                   uint32_t tag)
1309 {
1310         struct hbq_dmabuf *hbq_entry;
1311
1312         if (tag & QUE_BUFTAG_BIT)
1313                 return lpfc_sli_ring_taggedbuf_get(phba, pring, tag);
1314         hbq_entry = lpfc_sli_hbqbuf_find(phba, tag);
1315         if (!hbq_entry)
1316                 return NULL;
1317         return &hbq_entry->dbuf;
1318 }
1319
1320
1321 /**
1322  * lpfc_sli_process_unsol_iocb - Unsolicited iocb handler
1323  * @phba: Pointer to HBA context object.
1324  * @pring: Pointer to driver SLI ring object.
1325  * @saveq: Pointer to the unsolicited iocb.
1326  *
1327  * This function is called with no lock held by the ring event handler
1328  * when there is an unsolicited iocb posted to the response ring by the
1329  * firmware. This function gets the buffer associated with the iocbs
1330  * and calls the event handler for the ring. This function handles both
1331  * qring buffers and hbq buffers.
1332  * When the function returns 1 the caller can free the iocb object otherwise
1333  * upper layer functions will free the iocb objects.
1334  **/
1335 static int
1336 lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1337                             struct lpfc_iocbq *saveq)
1338 {
1339         IOCB_t           * irsp;
1340         WORD5            * w5p;
1341         uint32_t           Rctl, Type;
1342         uint32_t           match, i;
1343         struct lpfc_iocbq *iocbq;
1344         struct lpfc_dmabuf *dmzbuf;
1345
1346         match = 0;
1347         irsp = &(saveq->iocb);
1348
1349         if (irsp->ulpCommand == CMD_ASYNC_STATUS) {
1350                 if (pring->lpfc_sli_rcv_async_status)
1351                         pring->lpfc_sli_rcv_async_status(phba, pring, saveq);
1352                 else
1353                         lpfc_printf_log(phba,
1354                                         KERN_WARNING,
1355                                         LOG_SLI,
1356                                         "0316 Ring %d handler: unexpected "
1357                                         "ASYNC_STATUS iocb received evt_code "
1358                                         "0x%x\n",
1359                                         pring->ringno,
1360                                         irsp->un.asyncstat.evt_code);
1361                 return 1;
1362         }
1363
1364         if ((irsp->ulpCommand == CMD_IOCB_RET_XRI64_CX) &&
1365                 (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)) {
1366                 if (irsp->ulpBdeCount > 0) {
1367                         dmzbuf = lpfc_sli_get_buff(phba, pring,
1368                                         irsp->un.ulpWord[3]);
1369                         lpfc_in_buf_free(phba, dmzbuf);
1370                 }
1371
1372                 if (irsp->ulpBdeCount > 1) {
1373                         dmzbuf = lpfc_sli_get_buff(phba, pring,
1374                                         irsp->unsli3.sli3Words[3]);
1375                         lpfc_in_buf_free(phba, dmzbuf);
1376                 }
1377
1378                 if (irsp->ulpBdeCount > 2) {
1379                         dmzbuf = lpfc_sli_get_buff(phba, pring,
1380                                 irsp->unsli3.sli3Words[7]);
1381                         lpfc_in_buf_free(phba, dmzbuf);
1382                 }
1383
1384                 return 1;
1385         }
1386
1387         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
1388                 if (irsp->ulpBdeCount != 0) {
1389                         saveq->context2 = lpfc_sli_get_buff(phba, pring,
1390                                                 irsp->un.ulpWord[3]);
1391                         if (!saveq->context2)
1392                                 lpfc_printf_log(phba,
1393                                         KERN_ERR,
1394                                         LOG_SLI,
1395                                         "0341 Ring %d Cannot find buffer for "
1396                                         "an unsolicited iocb. tag 0x%x\n",
1397                                         pring->ringno,
1398                                         irsp->un.ulpWord[3]);
1399                 }
1400                 if (irsp->ulpBdeCount == 2) {
1401                         saveq->context3 = lpfc_sli_get_buff(phba, pring,
1402                                                 irsp->unsli3.sli3Words[7]);
1403                         if (!saveq->context3)
1404                                 lpfc_printf_log(phba,
1405                                         KERN_ERR,
1406                                         LOG_SLI,
1407                                         "0342 Ring %d Cannot find buffer for an"
1408                                         " unsolicited iocb. tag 0x%x\n",
1409                                         pring->ringno,
1410                                         irsp->unsli3.sli3Words[7]);
1411                 }
1412                 list_for_each_entry(iocbq, &saveq->list, list) {
1413                         irsp = &(iocbq->iocb);
1414                         if (irsp->ulpBdeCount != 0) {
1415                                 iocbq->context2 = lpfc_sli_get_buff(phba, pring,
1416                                                         irsp->un.ulpWord[3]);
1417                                 if (!iocbq->context2)
1418                                         lpfc_printf_log(phba,
1419                                                 KERN_ERR,
1420                                                 LOG_SLI,
1421                                                 "0343 Ring %d Cannot find "
1422                                                 "buffer for an unsolicited iocb"
1423                                                 ". tag 0x%x\n", pring->ringno,
1424                                                 irsp->un.ulpWord[3]);
1425                         }
1426                         if (irsp->ulpBdeCount == 2) {
1427                                 iocbq->context3 = lpfc_sli_get_buff(phba, pring,
1428                                                 irsp->unsli3.sli3Words[7]);
1429                                 if (!iocbq->context3)
1430                                         lpfc_printf_log(phba,
1431                                                 KERN_ERR,
1432                                                 LOG_SLI,
1433                                                 "0344 Ring %d Cannot find "
1434                                                 "buffer for an unsolicited "
1435                                                 "iocb. tag 0x%x\n",
1436                                                 pring->ringno,
1437                                                 irsp->unsli3.sli3Words[7]);
1438                         }
1439                 }
1440         }
1441         if (irsp->ulpBdeCount != 0 &&
1442             (irsp->ulpCommand == CMD_IOCB_RCV_CONT64_CX ||
1443              irsp->ulpStatus == IOSTAT_INTERMED_RSP)) {
1444                 int found = 0;
1445
1446                 /* search continue save q for same XRI */
1447                 list_for_each_entry(iocbq, &pring->iocb_continue_saveq, clist) {
1448                         if (iocbq->iocb.ulpContext == saveq->iocb.ulpContext) {
1449                                 list_add_tail(&saveq->list, &iocbq->list);
1450                                 found = 1;
1451                                 break;
1452                         }
1453                 }
1454                 if (!found)
1455                         list_add_tail(&saveq->clist,
1456                                       &pring->iocb_continue_saveq);
1457                 if (saveq->iocb.ulpStatus != IOSTAT_INTERMED_RSP) {
1458                         list_del_init(&iocbq->clist);
1459                         saveq = iocbq;
1460                         irsp = &(saveq->iocb);
1461                 } else
1462                         return 0;
1463         }
1464         if ((irsp->ulpCommand == CMD_RCV_ELS_REQ64_CX) ||
1465             (irsp->ulpCommand == CMD_RCV_ELS_REQ_CX) ||
1466             (irsp->ulpCommand == CMD_IOCB_RCV_ELS64_CX)) {
1467                 Rctl = FC_ELS_REQ;
1468                 Type = FC_ELS_DATA;
1469         } else {
1470                 w5p = (WORD5 *)&(saveq->iocb.un.ulpWord[5]);
1471                 Rctl = w5p->hcsw.Rctl;
1472                 Type = w5p->hcsw.Type;
1473
1474                 /* Firmware Workaround */
1475                 if ((Rctl == 0) && (pring->ringno == LPFC_ELS_RING) &&
1476                         (irsp->ulpCommand == CMD_RCV_SEQUENCE64_CX ||
1477                          irsp->ulpCommand == CMD_IOCB_RCV_SEQ64_CX)) {
1478                         Rctl = FC_ELS_REQ;
1479                         Type = FC_ELS_DATA;
1480                         w5p->hcsw.Rctl = Rctl;
1481                         w5p->hcsw.Type = Type;
1482                 }
1483         }
1484
1485         /* unSolicited Responses */
1486         if (pring->prt[0].profile) {
1487                 if (pring->prt[0].lpfc_sli_rcv_unsol_event)
1488                         (pring->prt[0].lpfc_sli_rcv_unsol_event) (phba, pring,
1489                                                                         saveq);
1490                 match = 1;
1491         } else {
1492                 /* We must search, based on rctl / type
1493                    for the right routine */
1494                 for (i = 0; i < pring->num_mask; i++) {
1495                         if ((pring->prt[i].rctl == Rctl)
1496                             && (pring->prt[i].type == Type)) {
1497                                 if (pring->prt[i].lpfc_sli_rcv_unsol_event)
1498                                         (pring->prt[i].lpfc_sli_rcv_unsol_event)
1499                                                         (phba, pring, saveq);
1500                                 match = 1;
1501                                 break;
1502                         }
1503                 }
1504         }
1505         if (match == 0) {
1506                 /* Unexpected Rctl / Type received */
1507                 /* Ring <ringno> handler: unexpected
1508                    Rctl <Rctl> Type <Type> received */
1509                 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1510                                 "0313 Ring %d handler: unexpected Rctl x%x "
1511                                 "Type x%x received\n",
1512                                 pring->ringno, Rctl, Type);
1513         }
1514         return 1;
1515 }
1516
1517 /**
1518  * lpfc_sli_iocbq_lookup - Find command iocb for the given response iocb
1519  * @phba: Pointer to HBA context object.
1520  * @pring: Pointer to driver SLI ring object.
1521  * @prspiocb: Pointer to response iocb object.
1522  *
1523  * This function looks up the iocb_lookup table to get the command iocb
1524  * corresponding to the given response iocb using the iotag of the
1525  * response iocb. This function is called with the hbalock held.
1526  * This function returns the command iocb object if it finds the command
1527  * iocb else returns NULL.
1528  **/
1529 static struct lpfc_iocbq *
1530 lpfc_sli_iocbq_lookup(struct lpfc_hba *phba,
1531                       struct lpfc_sli_ring *pring,
1532                       struct lpfc_iocbq *prspiocb)
1533 {
1534         struct lpfc_iocbq *cmd_iocb = NULL;
1535         uint16_t iotag;
1536
1537         iotag = prspiocb->iocb.ulpIoTag;
1538
1539         if (iotag != 0 && iotag <= phba->sli.last_iotag) {
1540                 cmd_iocb = phba->sli.iocbq_lookup[iotag];
1541                 list_del_init(&cmd_iocb->list);
1542                 pring->txcmplq_cnt--;
1543                 return cmd_iocb;
1544         }
1545
1546         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1547                         "0317 iotag x%x is out off "
1548                         "range: max iotag x%x wd0 x%x\n",
1549                         iotag, phba->sli.last_iotag,
1550                         *(((uint32_t *) &prspiocb->iocb) + 7));
1551         return NULL;
1552 }
1553
1554 /**
1555  * lpfc_sli_process_sol_iocb - process solicited iocb completion
1556  * @phba: Pointer to HBA context object.
1557  * @pring: Pointer to driver SLI ring object.
1558  * @saveq: Pointer to the response iocb to be processed.
1559  *
1560  * This function is called by the ring event handler for non-fcp
1561  * rings when there is a new response iocb in the response ring.
1562  * The caller is not required to hold any locks. This function
1563  * gets the command iocb associated with the response iocb and
1564  * calls the completion handler for the command iocb. If there
1565  * is no completion handler, the function will free the resources
1566  * associated with command iocb. If the response iocb is for
1567  * an already aborted command iocb, the status of the completion
1568  * is changed to IOSTAT_LOCAL_REJECT/IOERR_SLI_ABORTED.
1569  * This function always returns 1.
1570  **/
1571 static int
1572 lpfc_sli_process_sol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1573                           struct lpfc_iocbq *saveq)
1574 {
1575         struct lpfc_iocbq *cmdiocbp;
1576         int rc = 1;
1577         unsigned long iflag;
1578
1579         /* Based on the iotag field, get the cmd IOCB from the txcmplq */
1580         spin_lock_irqsave(&phba->hbalock, iflag);
1581         cmdiocbp = lpfc_sli_iocbq_lookup(phba, pring, saveq);
1582         spin_unlock_irqrestore(&phba->hbalock, iflag);
1583
1584         if (cmdiocbp) {
1585                 if (cmdiocbp->iocb_cmpl) {
1586                         /*
1587                          * If an ELS command failed send an event to mgmt
1588                          * application.
1589                          */
1590                         if (saveq->iocb.ulpStatus &&
1591                              (pring->ringno == LPFC_ELS_RING) &&
1592                              (cmdiocbp->iocb.ulpCommand ==
1593                                 CMD_ELS_REQUEST64_CR))
1594                                 lpfc_send_els_failure_event(phba,
1595                                         cmdiocbp, saveq);
1596
1597                         /*
1598                          * Post all ELS completions to the worker thread.
1599                          * All other are passed to the completion callback.
1600                          */
1601                         if (pring->ringno == LPFC_ELS_RING) {
1602                                 if (cmdiocbp->iocb_flag & LPFC_DRIVER_ABORTED) {
1603                                         cmdiocbp->iocb_flag &=
1604                                                 ~LPFC_DRIVER_ABORTED;
1605                                         saveq->iocb.ulpStatus =
1606                                                 IOSTAT_LOCAL_REJECT;
1607                                         saveq->iocb.un.ulpWord[4] =
1608                                                 IOERR_SLI_ABORTED;
1609
1610                                         /* Firmware could still be in progress
1611                                          * of DMAing payload, so don't free data
1612                                          * buffer till after a hbeat.
1613                                          */
1614                                         saveq->iocb_flag |= LPFC_DELAY_MEM_FREE;
1615                                 }
1616                         }
1617                         (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
1618                 } else
1619                         lpfc_sli_release_iocbq(phba, cmdiocbp);
1620         } else {
1621                 /*
1622                  * Unknown initiating command based on the response iotag.
1623                  * This could be the case on the ELS ring because of
1624                  * lpfc_els_abort().
1625                  */
1626                 if (pring->ringno != LPFC_ELS_RING) {
1627                         /*
1628                          * Ring <ringno> handler: unexpected completion IoTag
1629                          * <IoTag>
1630                          */
1631                         lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1632                                          "0322 Ring %d handler: "
1633                                          "unexpected completion IoTag x%x "
1634                                          "Data: x%x x%x x%x x%x\n",
1635                                          pring->ringno,
1636                                          saveq->iocb.ulpIoTag,
1637                                          saveq->iocb.ulpStatus,
1638                                          saveq->iocb.un.ulpWord[4],
1639                                          saveq->iocb.ulpCommand,
1640                                          saveq->iocb.ulpContext);
1641                 }
1642         }
1643
1644         return rc;
1645 }
1646
1647 /**
1648  * lpfc_sli_rsp_pointers_error - Response ring pointer error handler
1649  * @phba: Pointer to HBA context object.
1650  * @pring: Pointer to driver SLI ring object.
1651  *
1652  * This function is called from the iocb ring event handlers when
1653  * put pointer is ahead of the get pointer for a ring. This function signal
1654  * an error attention condition to the worker thread and the worker
1655  * thread will transition the HBA to offline state.
1656  **/
1657 static void
1658 lpfc_sli_rsp_pointers_error(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1659 {
1660         struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1661         /*
1662          * Ring <ringno> handler: portRspPut <portRspPut> is bigger than
1663          * rsp ring <portRspMax>
1664          */
1665         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1666                         "0312 Ring %d handler: portRspPut %d "
1667                         "is bigger than rsp ring %d\n",
1668                         pring->ringno, le32_to_cpu(pgp->rspPutInx),
1669                         pring->numRiocb);
1670
1671         phba->link_state = LPFC_HBA_ERROR;
1672
1673         /*
1674          * All error attention handlers are posted to
1675          * worker thread
1676          */
1677         phba->work_ha |= HA_ERATT;
1678         phba->work_hs = HS_FFER3;
1679
1680         lpfc_worker_wake_up(phba);
1681
1682         return;
1683 }
1684
1685 /**
1686  * lpfc_poll_eratt - Error attention polling timer timeout handler
1687  * @ptr: Pointer to address of HBA context object.
1688  *
1689  * This function is invoked by the Error Attention polling timer when the
1690  * timer times out. It will check the SLI Error Attention register for
1691  * possible attention events. If so, it will post an Error Attention event
1692  * and wake up worker thread to process it. Otherwise, it will set up the
1693  * Error Attention polling timer for the next poll.
1694  **/
1695 void lpfc_poll_eratt(unsigned long ptr)
1696 {
1697         struct lpfc_hba *phba;
1698         uint32_t eratt = 0;
1699
1700         phba = (struct lpfc_hba *)ptr;
1701
1702         /* Check chip HA register for error event */
1703         eratt = lpfc_sli_check_eratt(phba);
1704
1705         if (eratt)
1706                 /* Tell the worker thread there is work to do */
1707                 lpfc_worker_wake_up(phba);
1708         else
1709                 /* Restart the timer for next eratt poll */
1710                 mod_timer(&phba->eratt_poll, jiffies +
1711                                         HZ * LPFC_ERATT_POLL_INTERVAL);
1712         return;
1713 }
1714
1715 /**
1716  * lpfc_sli_poll_fcp_ring - Handle FCP ring completion in polling mode
1717  * @phba: Pointer to HBA context object.
1718  *
1719  * This function is called from lpfc_queuecommand, lpfc_poll_timeout,
1720  * lpfc_abort_handler and lpfc_slave_configure when FCP_RING_POLLING
1721  * is enabled.
1722  *
1723  * The caller does not hold any lock.
1724  * The function processes each response iocb in the response ring until it
1725  * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
1726  * LE bit set. The function will call the completion handler of the command iocb
1727  * if the response iocb indicates a completion for a command iocb or it is
1728  * an abort completion.
1729  **/
1730 void lpfc_sli_poll_fcp_ring(struct lpfc_hba *phba)
1731 {
1732         struct lpfc_sli      *psli  = &phba->sli;
1733         struct lpfc_sli_ring *pring = &psli->ring[LPFC_FCP_RING];
1734         IOCB_t *irsp = NULL;
1735         IOCB_t *entry = NULL;
1736         struct lpfc_iocbq *cmdiocbq = NULL;
1737         struct lpfc_iocbq rspiocbq;
1738         struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1739         uint32_t status;
1740         uint32_t portRspPut, portRspMax;
1741         int type;
1742         uint32_t rsp_cmpl = 0;
1743         uint32_t ha_copy;
1744         unsigned long iflags;
1745
1746         pring->stats.iocb_event++;
1747
1748         /*
1749          * The next available response entry should never exceed the maximum
1750          * entries.  If it does, treat it as an adapter hardware error.
1751          */
1752         portRspMax = pring->numRiocb;
1753         portRspPut = le32_to_cpu(pgp->rspPutInx);
1754         if (unlikely(portRspPut >= portRspMax)) {
1755                 lpfc_sli_rsp_pointers_error(phba, pring);
1756                 return;
1757         }
1758
1759         rmb();
1760         while (pring->rspidx != portRspPut) {
1761                 entry = lpfc_resp_iocb(phba, pring);
1762                 if (++pring->rspidx >= portRspMax)
1763                         pring->rspidx = 0;
1764
1765                 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
1766                                       (uint32_t *) &rspiocbq.iocb,
1767                                       phba->iocb_rsp_size);
1768                 irsp = &rspiocbq.iocb;
1769                 type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
1770                 pring->stats.iocb_rsp++;
1771                 rsp_cmpl++;
1772
1773                 if (unlikely(irsp->ulpStatus)) {
1774                         /* Rsp ring <ringno> error: IOCB */
1775                         lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1776                                         "0326 Rsp Ring %d error: IOCB Data: "
1777                                         "x%x x%x x%x x%x x%x x%x x%x x%x\n",
1778                                         pring->ringno,
1779                                         irsp->un.ulpWord[0],
1780                                         irsp->un.ulpWord[1],
1781                                         irsp->un.ulpWord[2],
1782                                         irsp->un.ulpWord[3],
1783                                         irsp->un.ulpWord[4],
1784                                         irsp->un.ulpWord[5],
1785                                         *(uint32_t *)&irsp->un1,
1786                                         *((uint32_t *)&irsp->un1 + 1));
1787                 }
1788
1789                 switch (type) {
1790                 case LPFC_ABORT_IOCB:
1791                 case LPFC_SOL_IOCB:
1792                         /*
1793                          * Idle exchange closed via ABTS from port.  No iocb
1794                          * resources need to be recovered.
1795                          */
1796                         if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
1797                                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1798                                                 "0314 IOCB cmd 0x%x "
1799                                                 "processed. Skipping "
1800                                                 "completion",
1801                                                 irsp->ulpCommand);
1802                                 break;
1803                         }
1804
1805                         spin_lock_irqsave(&phba->hbalock, iflags);
1806                         cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1807                                                          &rspiocbq);
1808                         spin_unlock_irqrestore(&phba->hbalock, iflags);
1809                         if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
1810                                 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1811                                                       &rspiocbq);
1812                         }
1813                         break;
1814                 default:
1815                         if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
1816                                 char adaptermsg[LPFC_MAX_ADPTMSG];
1817                                 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
1818                                 memcpy(&adaptermsg[0], (uint8_t *) irsp,
1819                                        MAX_MSG_DATA);
1820                                 dev_warn(&((phba->pcidev)->dev),
1821                                          "lpfc%d: %s\n",
1822                                          phba->brd_no, adaptermsg);
1823                         } else {
1824                                 /* Unknown IOCB command */
1825                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1826                                                 "0321 Unknown IOCB command "
1827                                                 "Data: x%x, x%x x%x x%x x%x\n",
1828                                                 type, irsp->ulpCommand,
1829                                                 irsp->ulpStatus,
1830                                                 irsp->ulpIoTag,
1831                                                 irsp->ulpContext);
1832                         }
1833                         break;
1834                 }
1835
1836                 /*
1837                  * The response IOCB has been processed.  Update the ring
1838                  * pointer in SLIM.  If the port response put pointer has not
1839                  * been updated, sync the pgp->rspPutInx and fetch the new port
1840                  * response put pointer.
1841                  */
1842                 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
1843
1844                 if (pring->rspidx == portRspPut)
1845                         portRspPut = le32_to_cpu(pgp->rspPutInx);
1846         }
1847
1848         ha_copy = readl(phba->HAregaddr);
1849         ha_copy >>= (LPFC_FCP_RING * 4);
1850
1851         if ((rsp_cmpl > 0) && (ha_copy & HA_R0RE_REQ)) {
1852                 spin_lock_irqsave(&phba->hbalock, iflags);
1853                 pring->stats.iocb_rsp_full++;
1854                 status = ((CA_R0ATT | CA_R0RE_RSP) << (LPFC_FCP_RING * 4));
1855                 writel(status, phba->CAregaddr);
1856                 readl(phba->CAregaddr);
1857                 spin_unlock_irqrestore(&phba->hbalock, iflags);
1858         }
1859         if ((ha_copy & HA_R0CE_RSP) &&
1860             (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
1861                 spin_lock_irqsave(&phba->hbalock, iflags);
1862                 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
1863                 pring->stats.iocb_cmd_empty++;
1864
1865                 /* Force update of the local copy of cmdGetInx */
1866                 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
1867                 lpfc_sli_resume_iocb(phba, pring);
1868
1869                 if ((pring->lpfc_sli_cmd_available))
1870                         (pring->lpfc_sli_cmd_available) (phba, pring);
1871
1872                 spin_unlock_irqrestore(&phba->hbalock, iflags);
1873         }
1874
1875         return;
1876 }
1877
1878 /**
1879  * lpfc_sli_handle_fast_ring_event - Handle ring events on FCP ring
1880  * @phba: Pointer to HBA context object.
1881  * @pring: Pointer to driver SLI ring object.
1882  * @mask: Host attention register mask for this ring.
1883  *
1884  * This function is called from the interrupt context when there is a ring
1885  * event for the fcp ring. The caller does not hold any lock.
1886  * The function processes each response iocb in the response ring until it
1887  * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
1888  * LE bit set. The function will call the completion handler of the command iocb
1889  * if the response iocb indicates a completion for a command iocb or it is
1890  * an abort completion. The function will call lpfc_sli_process_unsol_iocb
1891  * function if this is an unsolicited iocb.
1892  * This routine presumes LPFC_FCP_RING handling and doesn't bother
1893  * to check it explicitly. This function always returns 1.
1894  **/
1895 static int
1896 lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
1897                                 struct lpfc_sli_ring *pring, uint32_t mask)
1898 {
1899         struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
1900         IOCB_t *irsp = NULL;
1901         IOCB_t *entry = NULL;
1902         struct lpfc_iocbq *cmdiocbq = NULL;
1903         struct lpfc_iocbq rspiocbq;
1904         uint32_t status;
1905         uint32_t portRspPut, portRspMax;
1906         int rc = 1;
1907         lpfc_iocb_type type;
1908         unsigned long iflag;
1909         uint32_t rsp_cmpl = 0;
1910
1911         spin_lock_irqsave(&phba->hbalock, iflag);
1912         pring->stats.iocb_event++;
1913
1914         /*
1915          * The next available response entry should never exceed the maximum
1916          * entries.  If it does, treat it as an adapter hardware error.
1917          */
1918         portRspMax = pring->numRiocb;
1919         portRspPut = le32_to_cpu(pgp->rspPutInx);
1920         if (unlikely(portRspPut >= portRspMax)) {
1921                 lpfc_sli_rsp_pointers_error(phba, pring);
1922                 spin_unlock_irqrestore(&phba->hbalock, iflag);
1923                 return 1;
1924         }
1925
1926         rmb();
1927         while (pring->rspidx != portRspPut) {
1928                 /*
1929                  * Fetch an entry off the ring and copy it into a local data
1930                  * structure.  The copy involves a byte-swap since the
1931                  * network byte order and pci byte orders are different.
1932                  */
1933                 entry = lpfc_resp_iocb(phba, pring);
1934                 phba->last_completion_time = jiffies;
1935
1936                 if (++pring->rspidx >= portRspMax)
1937                         pring->rspidx = 0;
1938
1939                 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
1940                                       (uint32_t *) &rspiocbq.iocb,
1941                                       phba->iocb_rsp_size);
1942                 INIT_LIST_HEAD(&(rspiocbq.list));
1943                 irsp = &rspiocbq.iocb;
1944
1945                 type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
1946                 pring->stats.iocb_rsp++;
1947                 rsp_cmpl++;
1948
1949                 if (unlikely(irsp->ulpStatus)) {
1950                         /*
1951                          * If resource errors reported from HBA, reduce
1952                          * queuedepths of the SCSI device.
1953                          */
1954                         if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1955                                 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
1956                                 spin_unlock_irqrestore(&phba->hbalock, iflag);
1957                                 lpfc_rampdown_queue_depth(phba);
1958                                 spin_lock_irqsave(&phba->hbalock, iflag);
1959                         }
1960
1961                         /* Rsp ring <ringno> error: IOCB */
1962                         lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1963                                         "0336 Rsp Ring %d error: IOCB Data: "
1964                                         "x%x x%x x%x x%x x%x x%x x%x x%x\n",
1965                                         pring->ringno,
1966                                         irsp->un.ulpWord[0],
1967                                         irsp->un.ulpWord[1],
1968                                         irsp->un.ulpWord[2],
1969                                         irsp->un.ulpWord[3],
1970                                         irsp->un.ulpWord[4],
1971                                         irsp->un.ulpWord[5],
1972                                         *(uint32_t *)&irsp->un1,
1973                                         *((uint32_t *)&irsp->un1 + 1));
1974                 }
1975
1976                 switch (type) {
1977                 case LPFC_ABORT_IOCB:
1978                 case LPFC_SOL_IOCB:
1979                         /*
1980                          * Idle exchange closed via ABTS from port.  No iocb
1981                          * resources need to be recovered.
1982                          */
1983                         if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
1984                                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1985                                                 "0333 IOCB cmd 0x%x"
1986                                                 " processed. Skipping"
1987                                                 " completion\n",
1988                                                 irsp->ulpCommand);
1989                                 break;
1990                         }
1991
1992                         cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1993                                                          &rspiocbq);
1994                         if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
1995                                 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
1996                                         (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1997                                                               &rspiocbq);
1998                                 } else {
1999                                         spin_unlock_irqrestore(&phba->hbalock,
2000                                                                iflag);
2001                                         (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
2002                                                               &rspiocbq);
2003                                         spin_lock_irqsave(&phba->hbalock,
2004                                                           iflag);
2005                                 }
2006                         }
2007                         break;
2008                 case LPFC_UNSOL_IOCB:
2009                         spin_unlock_irqrestore(&phba->hbalock, iflag);
2010                         lpfc_sli_process_unsol_iocb(phba, pring, &rspiocbq);
2011                         spin_lock_irqsave(&phba->hbalock, iflag);
2012                         break;
2013                 default:
2014                         if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
2015                                 char adaptermsg[LPFC_MAX_ADPTMSG];
2016                                 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
2017                                 memcpy(&adaptermsg[0], (uint8_t *) irsp,
2018                                        MAX_MSG_DATA);
2019                                 dev_warn(&((phba->pcidev)->dev),
2020                                          "lpfc%d: %s\n",
2021                                          phba->brd_no, adaptermsg);
2022                         } else {
2023                                 /* Unknown IOCB command */
2024                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2025                                                 "0334 Unknown IOCB command "
2026                                                 "Data: x%x, x%x x%x x%x x%x\n",
2027                                                 type, irsp->ulpCommand,
2028                                                 irsp->ulpStatus,
2029                                                 irsp->ulpIoTag,
2030                                                 irsp->ulpContext);
2031                         }
2032                         break;
2033                 }
2034
2035                 /*
2036                  * The response IOCB has been processed.  Update the ring
2037                  * pointer in SLIM.  If the port response put pointer has not
2038                  * been updated, sync the pgp->rspPutInx and fetch the new port
2039                  * response put pointer.
2040                  */
2041                 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
2042
2043                 if (pring->rspidx == portRspPut)
2044                         portRspPut = le32_to_cpu(pgp->rspPutInx);
2045         }
2046
2047         if ((rsp_cmpl > 0) && (mask & HA_R0RE_REQ)) {
2048                 pring->stats.iocb_rsp_full++;
2049                 status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
2050                 writel(status, phba->CAregaddr);
2051                 readl(phba->CAregaddr);
2052         }
2053         if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
2054                 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
2055                 pring->stats.iocb_cmd_empty++;
2056
2057                 /* Force update of the local copy of cmdGetInx */
2058                 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
2059                 lpfc_sli_resume_iocb(phba, pring);
2060
2061                 if ((pring->lpfc_sli_cmd_available))
2062                         (pring->lpfc_sli_cmd_available) (phba, pring);
2063
2064         }
2065
2066         spin_unlock_irqrestore(&phba->hbalock, iflag);
2067         return rc;
2068 }
2069
2070 /**
2071  * lpfc_sli_handle_slow_ring_event - Handle ring events for non-FCP rings
2072  * @phba: Pointer to HBA context object.
2073  * @pring: Pointer to driver SLI ring object.
2074  * @mask: Host attention register mask for this ring.
2075  *
2076  * This function is called from the worker thread when there is a ring
2077  * event for non-fcp rings. The caller does not hold any lock .
2078  * The function processes each response iocb in the response ring until it
2079  * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
2080  * LE bit set. The function will call lpfc_sli_process_sol_iocb function if the
2081  * response iocb indicates a completion of a command iocb. The function
2082  * will call lpfc_sli_process_unsol_iocb function if this is an unsolicited
2083  * iocb. The function frees the resources or calls the completion handler if
2084  * this iocb is an abort completion. The function returns 0 when the allocated
2085  * iocbs are not freed, otherwise returns 1.
2086  **/
2087 int
2088 lpfc_sli_handle_slow_ring_event(struct lpfc_hba *phba,
2089                                 struct lpfc_sli_ring *pring, uint32_t mask)
2090 {
2091         struct lpfc_pgp *pgp;
2092         IOCB_t *entry;
2093         IOCB_t *irsp = NULL;
2094         struct lpfc_iocbq *rspiocbp = NULL;
2095         struct lpfc_iocbq *next_iocb;
2096         struct lpfc_iocbq *cmdiocbp;
2097         struct lpfc_iocbq *saveq;
2098         uint8_t iocb_cmd_type;
2099         lpfc_iocb_type type;
2100         uint32_t status, free_saveq;
2101         uint32_t portRspPut, portRspMax;
2102         int rc = 1;
2103         unsigned long iflag;
2104
2105         pgp = &phba->port_gp[pring->ringno];
2106         spin_lock_irqsave(&phba->hbalock, iflag);
2107         pring->stats.iocb_event++;
2108
2109         /*
2110          * The next available response entry should never exceed the maximum
2111          * entries.  If it does, treat it as an adapter hardware error.
2112          */
2113         portRspMax = pring->numRiocb;
2114         portRspPut = le32_to_cpu(pgp->rspPutInx);
2115         if (portRspPut >= portRspMax) {
2116                 /*
2117                  * Ring <ringno> handler: portRspPut <portRspPut> is bigger than
2118                  * rsp ring <portRspMax>
2119                  */
2120                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2121                                 "0303 Ring %d handler: portRspPut %d "
2122                                 "is bigger than rsp ring %d\n",
2123                                 pring->ringno, portRspPut, portRspMax);
2124
2125                 phba->link_state = LPFC_HBA_ERROR;
2126                 spin_unlock_irqrestore(&phba->hbalock, iflag);
2127
2128                 phba->work_hs = HS_FFER3;
2129                 lpfc_handle_eratt(phba);
2130
2131                 return 1;
2132         }
2133
2134         rmb();
2135         while (pring->rspidx != portRspPut) {
2136                 /*
2137                  * Build a completion list and call the appropriate handler.
2138                  * The process is to get the next available response iocb, get
2139                  * a free iocb from the list, copy the response data into the
2140                  * free iocb, insert to the continuation list, and update the
2141                  * next response index to slim.  This process makes response
2142                  * iocb's in the ring available to DMA as fast as possible but
2143                  * pays a penalty for a copy operation.  Since the iocb is
2144                  * only 32 bytes, this penalty is considered small relative to
2145                  * the PCI reads for register values and a slim write.  When
2146                  * the ulpLe field is set, the entire Command has been
2147                  * received.
2148                  */
2149                 entry = lpfc_resp_iocb(phba, pring);
2150
2151                 phba->last_completion_time = jiffies;
2152                 rspiocbp = __lpfc_sli_get_iocbq(phba);
2153                 if (rspiocbp == NULL) {
2154                         printk(KERN_ERR "%s: out of buffers! Failing "
2155                                "completion.\n", __func__);
2156                         break;
2157                 }
2158
2159                 lpfc_sli_pcimem_bcopy(entry, &rspiocbp->iocb,
2160                                       phba->iocb_rsp_size);
2161                 irsp = &rspiocbp->iocb;
2162
2163                 if (++pring->rspidx >= portRspMax)
2164                         pring->rspidx = 0;
2165
2166                 if (pring->ringno == LPFC_ELS_RING) {
2167                         lpfc_debugfs_slow_ring_trc(phba,
2168                         "IOCB rsp ring:   wd4:x%08x wd6:x%08x wd7:x%08x",
2169                                 *(((uint32_t *) irsp) + 4),
2170                                 *(((uint32_t *) irsp) + 6),
2171                                 *(((uint32_t *) irsp) + 7));
2172                 }
2173
2174                 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
2175
2176                 list_add_tail(&rspiocbp->list, &(pring->iocb_continueq));
2177
2178                 pring->iocb_continueq_cnt++;
2179                 if (irsp->ulpLe) {
2180                         /*
2181                          * By default, the driver expects to free all resources
2182                          * associated with this iocb completion.
2183                          */
2184                         free_saveq = 1;
2185                         saveq = list_get_first(&pring->iocb_continueq,
2186                                                struct lpfc_iocbq, list);
2187                         irsp = &(saveq->iocb);
2188                         list_del_init(&pring->iocb_continueq);
2189                         pring->iocb_continueq_cnt = 0;
2190
2191                         pring->stats.iocb_rsp++;
2192
2193                         /*
2194                          * If resource errors reported from HBA, reduce
2195                          * queuedepths of the SCSI device.
2196                          */
2197                         if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
2198                              (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
2199                                 spin_unlock_irqrestore(&phba->hbalock, iflag);
2200                                 lpfc_rampdown_queue_depth(phba);
2201                                 spin_lock_irqsave(&phba->hbalock, iflag);
2202                         }
2203
2204                         if (irsp->ulpStatus) {
2205                                 /* Rsp ring <ringno> error: IOCB */
2206                                 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
2207                                                 "0328 Rsp Ring %d error: "
2208                                                 "IOCB Data: "
2209                                                 "x%x x%x x%x x%x "
2210                                                 "x%x x%x x%x x%x "
2211                                                 "x%x x%x x%x x%x "
2212                                                 "x%x x%x x%x x%x\n",
2213                                                 pring->ringno,
2214                                                 irsp->un.ulpWord[0],
2215                                                 irsp->un.ulpWord[1],
2216                                                 irsp->un.ulpWord[2],
2217                                                 irsp->un.ulpWord[3],
2218                                                 irsp->un.ulpWord[4],
2219                                                 irsp->un.ulpWord[5],
2220                                                 *(((uint32_t *) irsp) + 6),
2221                                                 *(((uint32_t *) irsp) + 7),
2222                                                 *(((uint32_t *) irsp) + 8),
2223                                                 *(((uint32_t *) irsp) + 9),
2224                                                 *(((uint32_t *) irsp) + 10),
2225                                                 *(((uint32_t *) irsp) + 11),
2226                                                 *(((uint32_t *) irsp) + 12),
2227                                                 *(((uint32_t *) irsp) + 13),
2228                                                 *(((uint32_t *) irsp) + 14),
2229                                                 *(((uint32_t *) irsp) + 15));
2230                         }
2231
2232                         /*
2233                          * Fetch the IOCB command type and call the correct
2234                          * completion routine.  Solicited and Unsolicited
2235                          * IOCBs on the ELS ring get freed back to the
2236                          * lpfc_iocb_list by the discovery kernel thread.
2237                          */
2238                         iocb_cmd_type = irsp->ulpCommand & CMD_IOCB_MASK;
2239                         type = lpfc_sli_iocb_cmd_type(iocb_cmd_type);
2240                         if (type == LPFC_SOL_IOCB) {
2241                                 spin_unlock_irqrestore(&phba->hbalock, iflag);
2242                                 rc = lpfc_sli_process_sol_iocb(phba, pring,
2243                                                                saveq);
2244                                 spin_lock_irqsave(&phba->hbalock, iflag);
2245                         } else if (type == LPFC_UNSOL_IOCB) {
2246                                 spin_unlock_irqrestore(&phba->hbalock, iflag);
2247                                 rc = lpfc_sli_process_unsol_iocb(phba, pring,
2248                                                                  saveq);
2249                                 spin_lock_irqsave(&phba->hbalock, iflag);
2250                                 if (!rc)
2251                                         free_saveq = 0;
2252                         } else if (type == LPFC_ABORT_IOCB) {
2253                                 if ((irsp->ulpCommand != CMD_XRI_ABORTED_CX) &&
2254                                     ((cmdiocbp =
2255                                       lpfc_sli_iocbq_lookup(phba, pring,
2256                                                             saveq)))) {
2257                                         /* Call the specified completion
2258                                            routine */
2259                                         if (cmdiocbp->iocb_cmpl) {
2260                                                 spin_unlock_irqrestore(
2261                                                        &phba->hbalock,
2262                                                        iflag);
2263                                                 (cmdiocbp->iocb_cmpl) (phba,
2264                                                              cmdiocbp, saveq);
2265                                                 spin_lock_irqsave(
2266                                                           &phba->hbalock,
2267                                                           iflag);
2268                                         } else
2269                                                 __lpfc_sli_release_iocbq(phba,
2270                                                                       cmdiocbp);
2271                                 }
2272                         } else if (type == LPFC_UNKNOWN_IOCB) {
2273                                 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
2274
2275                                         char adaptermsg[LPFC_MAX_ADPTMSG];
2276
2277                                         memset(adaptermsg, 0,
2278                                                LPFC_MAX_ADPTMSG);
2279                                         memcpy(&adaptermsg[0], (uint8_t *) irsp,
2280                                                MAX_MSG_DATA);
2281                                         dev_warn(&((phba->pcidev)->dev),
2282                                                  "lpfc%d: %s\n",
2283                                                  phba->brd_no, adaptermsg);
2284                                 } else {
2285                                         /* Unknown IOCB command */
2286                                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2287                                                         "0335 Unknown IOCB "
2288                                                         "command Data: x%x "
2289                                                         "x%x x%x x%x\n",
2290                                                         irsp->ulpCommand,
2291                                                         irsp->ulpStatus,
2292                                                         irsp->ulpIoTag,
2293                                                         irsp->ulpContext);
2294                                 }
2295                         }
2296
2297                         if (free_saveq) {
2298                                 list_for_each_entry_safe(rspiocbp, next_iocb,
2299                                                          &saveq->list, list) {
2300                                         list_del(&rspiocbp->list);
2301                                         __lpfc_sli_release_iocbq(phba,
2302                                                                  rspiocbp);
2303                                 }
2304                                 __lpfc_sli_release_iocbq(phba, saveq);
2305                         }
2306                         rspiocbp = NULL;
2307                 }
2308
2309                 /*
2310                  * If the port response put pointer has not been updated, sync
2311                  * the pgp->rspPutInx in the MAILBOX_tand fetch the new port
2312                  * response put pointer.
2313                  */
2314                 if (pring->rspidx == portRspPut) {
2315                         portRspPut = le32_to_cpu(pgp->rspPutInx);
2316                 }
2317         } /* while (pring->rspidx != portRspPut) */
2318
2319         if ((rspiocbp != NULL) && (mask & HA_R0RE_REQ)) {
2320                 /* At least one response entry has been freed */
2321                 pring->stats.iocb_rsp_full++;
2322                 /* SET RxRE_RSP in Chip Att register */
2323                 status = ((CA_R0ATT | CA_R0RE_RSP) << (pring->ringno * 4));
2324                 writel(status, phba->CAregaddr);
2325                 readl(phba->CAregaddr); /* flush */
2326         }
2327         if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
2328                 pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
2329                 pring->stats.iocb_cmd_empty++;
2330
2331                 /* Force update of the local copy of cmdGetInx */
2332                 pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
2333                 lpfc_sli_resume_iocb(phba, pring);
2334
2335                 if ((pring->lpfc_sli_cmd_available))
2336                         (pring->lpfc_sli_cmd_available) (phba, pring);
2337
2338         }
2339
2340         spin_unlock_irqrestore(&phba->hbalock, iflag);
2341         return rc;
2342 }
2343
2344 /**
2345  * lpfc_sli_abort_iocb_ring - Abort all iocbs in the ring
2346  * @phba: Pointer to HBA context object.
2347  * @pring: Pointer to driver SLI ring object.
2348  *
2349  * This function aborts all iocbs in the given ring and frees all the iocb
2350  * objects in txq. This function issues an abort iocb for all the iocb commands
2351  * in txcmplq. The iocbs in the txcmplq is not guaranteed to complete before
2352  * the return of this function. The caller is not required to hold any locks.
2353  **/
2354 void
2355 lpfc_sli_abort_iocb_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
2356 {
2357         LIST_HEAD(completions);
2358         struct lpfc_iocbq *iocb, *next_iocb;
2359
2360         if (pring->ringno == LPFC_ELS_RING) {
2361                 lpfc_fabric_abort_hba(phba);
2362         }
2363
2364         /* Error everything on txq and txcmplq
2365          * First do the txq.
2366          */
2367         spin_lock_irq(&phba->hbalock);
2368         list_splice_init(&pring->txq, &completions);
2369         pring->txq_cnt = 0;
2370
2371         /* Next issue ABTS for everything on the txcmplq */
2372         list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list)
2373                 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
2374
2375         spin_unlock_irq(&phba->hbalock);
2376
2377         /* Cancel all the IOCBs from the completions list */
2378         lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
2379                               IOERR_SLI_ABORTED);
2380 }
2381
2382 /**
2383  * lpfc_sli_flush_fcp_rings - flush all iocbs in the fcp ring
2384  * @phba: Pointer to HBA context object.
2385  *
2386  * This function flushes all iocbs in the fcp ring and frees all the iocb
2387  * objects in txq and txcmplq. This function will not issue abort iocbs
2388  * for all the iocb commands in txcmplq, they will just be returned with
2389  * IOERR_SLI_DOWN. This function is invoked with EEH when device's PCI
2390  * slot has been permanently disabled.
2391  **/
2392 void
2393 lpfc_sli_flush_fcp_rings(struct lpfc_hba *phba)
2394 {
2395         LIST_HEAD(txq);
2396         LIST_HEAD(txcmplq);
2397         struct lpfc_sli *psli = &phba->sli;
2398         struct lpfc_sli_ring  *pring;
2399
2400         /* Currently, only one fcp ring */
2401         pring = &psli->ring[psli->fcp_ring];
2402
2403         spin_lock_irq(&phba->hbalock);
2404         /* Retrieve everything on txq */
2405         list_splice_init(&pring->txq, &txq);
2406         pring->txq_cnt = 0;
2407
2408         /* Retrieve everything on the txcmplq */
2409         list_splice_init(&pring->txcmplq, &txcmplq);
2410         pring->txcmplq_cnt = 0;
2411         spin_unlock_irq(&phba->hbalock);
2412
2413         /* Flush the txq */
2414         lpfc_sli_cancel_iocbs(phba, &txq, IOSTAT_LOCAL_REJECT,
2415                               IOERR_SLI_DOWN);
2416
2417         /* Flush the txcmpq */
2418         lpfc_sli_cancel_iocbs(phba, &txcmplq, IOSTAT_LOCAL_REJECT,
2419                               IOERR_SLI_DOWN);
2420 }
2421
2422 /**
2423  * lpfc_sli_brdready - Check for host status bits
2424  * @phba: Pointer to HBA context object.
2425  * @mask: Bit mask to be checked.
2426  *
2427  * This function reads the host status register and compares
2428  * with the provided bit mask to check if HBA completed
2429  * the restart. This function will wait in a loop for the
2430  * HBA to complete restart. If the HBA does not restart within
2431  * 15 iterations, the function will reset the HBA again. The
2432  * function returns 1 when HBA fail to restart otherwise returns
2433  * zero.
2434  **/
2435 int
2436 lpfc_sli_brdready(struct lpfc_hba *phba, uint32_t mask)
2437 {
2438         uint32_t status;
2439         int i = 0;
2440         int retval = 0;
2441
2442         /* Read the HBA Host Status Register */
2443         status = readl(phba->HSregaddr);
2444
2445         /*
2446          * Check status register every 100ms for 5 retries, then every
2447          * 500ms for 5, then every 2.5 sec for 5, then reset board and
2448          * every 2.5 sec for 4.
2449          * Break our of the loop if errors occurred during init.
2450          */
2451         while (((status & mask) != mask) &&
2452                !(status & HS_FFERM) &&
2453                i++ < 20) {
2454
2455                 if (i <= 5)
2456                         msleep(10);
2457                 else if (i <= 10)
2458                         msleep(500);
2459                 else
2460                         msleep(2500);
2461
2462                 if (i == 15) {
2463                                 /* Do post */
2464                         phba->pport->port_state = LPFC_VPORT_UNKNOWN;
2465                         lpfc_sli_brdrestart(phba);
2466                 }
2467                 /* Read the HBA Host Status Register */
2468                 status = readl(phba->HSregaddr);
2469         }
2470
2471         /* Check to see if any errors occurred during init */
2472         if ((status & HS_FFERM) || (i >= 20)) {
2473                 phba->link_state = LPFC_HBA_ERROR;
2474                 retval = 1;
2475         }
2476
2477         return retval;
2478 }
2479
2480 #define BARRIER_TEST_PATTERN (0xdeadbeef)
2481
2482 /**
2483  * lpfc_reset_barrier - Make HBA ready for HBA reset
2484  * @phba: Pointer to HBA context object.
2485  *
2486  * This function is called before resetting an HBA. This
2487  * function requests HBA to quiesce DMAs before a reset.
2488  **/
2489 void lpfc_reset_barrier(struct lpfc_hba *phba)
2490 {
2491         uint32_t __iomem *resp_buf;
2492         uint32_t __iomem *mbox_buf;
2493         volatile uint32_t mbox;
2494         uint32_t hc_copy;
2495         int  i;
2496         uint8_t hdrtype;
2497
2498         pci_read_config_byte(phba->pcidev, PCI_HEADER_TYPE, &hdrtype);
2499         if (hdrtype != 0x80 ||
2500             (FC_JEDEC_ID(phba->vpd.rev.biuRev) != HELIOS_JEDEC_ID &&
2501              FC_JEDEC_ID(phba->vpd.rev.biuRev) != THOR_JEDEC_ID))
2502                 return;
2503
2504         /*
2505          * Tell the other part of the chip to suspend temporarily all
2506          * its DMA activity.
2507          */
2508         resp_buf = phba->MBslimaddr;
2509
2510         /* Disable the error attention */
2511         hc_copy = readl(phba->HCregaddr);
2512         writel((hc_copy & ~HC_ERINT_ENA), phba->HCregaddr);
2513         readl(phba->HCregaddr); /* flush */
2514         phba->link_flag |= LS_IGNORE_ERATT;
2515
2516         if (readl(phba->HAregaddr) & HA_ERATT) {
2517                 /* Clear Chip error bit */
2518                 writel(HA_ERATT, phba->HAregaddr);
2519                 phba->pport->stopped = 1;
2520         }
2521
2522         mbox = 0;
2523         ((MAILBOX_t *)&mbox)->mbxCommand = MBX_KILL_BOARD;
2524         ((MAILBOX_t *)&mbox)->mbxOwner = OWN_CHIP;
2525
2526         writel(BARRIER_TEST_PATTERN, (resp_buf + 1));
2527         mbox_buf = phba->MBslimaddr;
2528         writel(mbox, mbox_buf);
2529
2530         for (i = 0;
2531              readl(resp_buf + 1) != ~(BARRIER_TEST_PATTERN) && i < 50; i++)
2532                 mdelay(1);
2533
2534         if (readl(resp_buf + 1) != ~(BARRIER_TEST_PATTERN)) {
2535                 if (phba->sli.sli_flag & LPFC_SLI2_ACTIVE ||
2536                     phba->pport->stopped)
2537                         goto restore_hc;
2538                 else
2539                         goto clear_errat;
2540         }
2541
2542         ((MAILBOX_t *)&mbox)->mbxOwner = OWN_HOST;
2543         for (i = 0; readl(resp_buf) != mbox &&  i < 500; i++)
2544                 mdelay(1);
2545
2546 clear_errat:
2547
2548         while (!(readl(phba->HAregaddr) & HA_ERATT) && ++i < 500)
2549                 mdelay(1);
2550
2551         if (readl(phba->HAregaddr) & HA_ERATT) {
2552                 writel(HA_ERATT, phba->HAregaddr);
2553                 phba->pport->stopped = 1;
2554         }
2555
2556 restore_hc:
2557         phba->link_flag &= ~LS_IGNORE_ERATT;
2558         writel(hc_copy, phba->HCregaddr);
2559         readl(phba->HCregaddr); /* flush */
2560 }
2561
2562 /**
2563  * lpfc_sli_brdkill - Issue a kill_board mailbox command
2564  * @phba: Pointer to HBA context object.
2565  *
2566  * This function issues a kill_board mailbox command and waits for
2567  * the error attention interrupt. This function is called for stopping
2568  * the firmware processing. The caller is not required to hold any
2569  * locks. This function calls lpfc_hba_down_post function to free
2570  * any pending commands after the kill. The function will return 1 when it
2571  * fails to kill the board else will return 0.
2572  **/
2573 int
2574 lpfc_sli_brdkill(struct lpfc_hba *phba)
2575 {
2576         struct lpfc_sli *psli;
2577         LPFC_MBOXQ_t *pmb;
2578         uint32_t status;
2579         uint32_t ha_copy;
2580         int retval;
2581         int i = 0;
2582
2583         psli = &phba->sli;
2584
2585         /* Kill HBA */
2586         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2587                         "0329 Kill HBA Data: x%x x%x\n",
2588                         phba->pport->port_state, psli->sli_flag);
2589
2590         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2591         if (!pmb)
2592                 return 1;
2593
2594         /* Disable the error attention */
2595         spin_lock_irq(&phba->hbalock);
2596         status = readl(phba->HCregaddr);
2597         status &= ~HC_ERINT_ENA;
2598         writel(status, phba->HCregaddr);
2599         readl(phba->HCregaddr); /* flush */
2600         phba->link_flag |= LS_IGNORE_ERATT;
2601         spin_unlock_irq(&phba->hbalock);
2602
2603         lpfc_kill_board(phba, pmb);
2604         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2605         retval = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
2606
2607         if (retval != MBX_SUCCESS) {
2608                 if (retval != MBX_BUSY)
2609                         mempool_free(pmb, phba->mbox_mem_pool);
2610                 spin_lock_irq(&phba->hbalock);
2611                 phba->link_flag &= ~LS_IGNORE_ERATT;
2612                 spin_unlock_irq(&phba->hbalock);
2613                 return 1;
2614         }
2615
2616         psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
2617
2618         mempool_free(pmb, phba->mbox_mem_pool);
2619
2620         /* There is no completion for a KILL_BOARD mbox cmd. Check for an error
2621          * attention every 100ms for 3 seconds. If we don't get ERATT after
2622          * 3 seconds we still set HBA_ERROR state because the status of the
2623          * board is now undefined.
2624          */
2625         ha_copy = readl(phba->HAregaddr);
2626
2627         while ((i++ < 30) && !(ha_copy & HA_ERATT)) {
2628                 mdelay(100);
2629                 ha_copy = readl(phba->HAregaddr);
2630         }
2631
2632         del_timer_sync(&psli->mbox_tmo);
2633         if (ha_copy & HA_ERATT) {
2634                 writel(HA_ERATT, phba->HAregaddr);
2635                 phba->pport->stopped = 1;
2636         }
2637         spin_lock_irq(&phba->hbalock);
2638         psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
2639         phba->link_flag &= ~LS_IGNORE_ERATT;
2640         spin_unlock_irq(&phba->hbalock);
2641
2642         psli->mbox_active = NULL;
2643         lpfc_hba_down_post(phba);
2644         phba->link_state = LPFC_HBA_ERROR;
2645
2646         return ha_copy & HA_ERATT ? 0 : 1;
2647 }
2648
2649 /**
2650  * lpfc_sli_brdreset - Reset the HBA
2651  * @phba: Pointer to HBA context object.
2652  *
2653  * This function resets the HBA by writing HC_INITFF to the control
2654  * register. After the HBA resets, this function resets all the iocb ring
2655  * indices. This function disables PCI layer parity checking during
2656  * the reset.
2657  * This function returns 0 always.
2658  * The caller is not required to hold any locks.
2659  **/
2660 int
2661 lpfc_sli_brdreset(struct lpfc_hba *phba)
2662 {
2663         struct lpfc_sli *psli;
2664         struct lpfc_sli_ring *pring;
2665         uint16_t cfg_value;
2666         int i;
2667
2668         psli = &phba->sli;
2669
2670         /* Reset HBA */
2671         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2672                         "0325 Reset HBA Data: x%x x%x\n",
2673                         phba->pport->port_state, psli->sli_flag);
2674
2675         /* perform board reset */
2676         phba->fc_eventTag = 0;
2677         phba->pport->fc_myDID = 0;
2678         phba->pport->fc_prevDID = 0;
2679
2680         /* Turn off parity checking and serr during the physical reset */
2681         pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value);
2682         pci_write_config_word(phba->pcidev, PCI_COMMAND,
2683                               (cfg_value &
2684                                ~(PCI_COMMAND_PARITY | PCI_COMMAND_SERR)));
2685
2686         psli->sli_flag &= ~(LPFC_SLI2_ACTIVE | LPFC_PROCESS_LA);
2687         /* Now toggle INITFF bit in the Host Control Register */
2688         writel(HC_INITFF, phba->HCregaddr);
2689         mdelay(1);
2690         readl(phba->HCregaddr); /* flush */
2691         writel(0, phba->HCregaddr);
2692         readl(phba->HCregaddr); /* flush */
2693
2694         /* Restore PCI cmd register */
2695         pci_write_config_word(phba->pcidev, PCI_COMMAND, cfg_value);
2696
2697         /* Initialize relevant SLI info */
2698         for (i = 0; i < psli->num_rings; i++) {
2699                 pring = &psli->ring[i];
2700                 pring->flag = 0;
2701                 pring->rspidx = 0;
2702                 pring->next_cmdidx  = 0;
2703                 pring->local_getidx = 0;
2704                 pring->cmdidx = 0;
2705                 pring->missbufcnt = 0;
2706         }
2707
2708         phba->link_state = LPFC_WARM_START;
2709         return 0;
2710 }
2711
2712 /**
2713  * lpfc_sli_brdrestart - Restart the HBA
2714  * @phba: Pointer to HBA context object.
2715  *
2716  * This function is called in the SLI initialization code path to
2717  * restart the HBA. The caller is not required to hold any lock.
2718  * This function writes MBX_RESTART mailbox command to the SLIM and
2719  * resets the HBA. At the end of the function, it calls lpfc_hba_down_post
2720  * function to free any pending commands. The function enables
2721  * POST only during the first initialization. The function returns zero.
2722  * The function does not guarantee completion of MBX_RESTART mailbox
2723  * command before the return of this function.
2724  **/
2725 int
2726 lpfc_sli_brdrestart(struct lpfc_hba *phba)
2727 {
2728         MAILBOX_t *mb;
2729         struct lpfc_sli *psli;
2730         volatile uint32_t word0;
2731         void __iomem *to_slim;
2732
2733         spin_lock_irq(&phba->hbalock);
2734
2735         psli = &phba->sli;
2736
2737         /* Restart HBA */
2738         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2739                         "0337 Restart HBA Data: x%x x%x\n",
2740                         phba->pport->port_state, psli->sli_flag);
2741
2742         word0 = 0;
2743         mb = (MAILBOX_t *) &word0;
2744         mb->mbxCommand = MBX_RESTART;
2745         mb->mbxHc = 1;
2746
2747         lpfc_reset_barrier(phba);
2748
2749         to_slim = phba->MBslimaddr;
2750         writel(*(uint32_t *) mb, to_slim);
2751         readl(to_slim); /* flush */
2752
2753         /* Only skip post after fc_ffinit is completed */
2754         if (phba->pport->port_state)
2755                 word0 = 1;      /* This is really setting up word1 */
2756         else
2757                 word0 = 0;      /* This is really setting up word1 */
2758         to_slim = phba->MBslimaddr + sizeof (uint32_t);
2759         writel(*(uint32_t *) mb, to_slim);
2760         readl(to_slim); /* flush */
2761
2762         lpfc_sli_brdreset(phba);
2763         phba->pport->stopped = 0;
2764         phba->link_state = LPFC_INIT_START;
2765
2766         spin_unlock_irq(&phba->hbalock);
2767
2768         memset(&psli->lnk_stat_offsets, 0, sizeof(psli->lnk_stat_offsets));
2769         psli->stats_start = get_seconds();
2770
2771         /* Give the INITFF and Post time to settle. */
2772         mdelay(100);
2773
2774         lpfc_hba_down_post(phba);
2775
2776         return 0;
2777 }
2778
2779 /**
2780  * lpfc_sli_chipset_init - Wait for the restart of the HBA after a restart
2781  * @phba: Pointer to HBA context object.
2782  *
2783  * This function is called after a HBA restart to wait for successful
2784  * restart of the HBA. Successful restart of the HBA is indicated by
2785  * HS_FFRDY and HS_MBRDY bits. If the HBA fails to restart even after 15
2786  * iteration, the function will restart the HBA again. The function returns
2787  * zero if HBA successfully restarted else returns negative error code.
2788  **/
2789 static int
2790 lpfc_sli_chipset_init(struct lpfc_hba *phba)
2791 {
2792         uint32_t status, i = 0;
2793
2794         /* Read the HBA Host Status Register */
2795         status = readl(phba->HSregaddr);
2796
2797         /* Check status register to see what current state is */
2798         i = 0;
2799         while ((status & (HS_FFRDY | HS_MBRDY)) != (HS_FFRDY | HS_MBRDY)) {
2800
2801                 /* Check every 100ms for 5 retries, then every 500ms for 5, then
2802                  * every 2.5 sec for 5, then reset board and every 2.5 sec for
2803                  * 4.
2804                  */
2805                 if (i++ >= 20) {
2806                         /* Adapter failed to init, timeout, status reg
2807                            <status> */
2808                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2809                                         "0436 Adapter failed to init, "
2810                                         "timeout, status reg x%x, "
2811                                         "FW Data: A8 x%x AC x%x\n", status,
2812                                         readl(phba->MBslimaddr + 0xa8),
2813                                         readl(phba->MBslimaddr + 0xac));
2814                         phba->link_state = LPFC_HBA_ERROR;
2815                         return -ETIMEDOUT;
2816                 }
2817
2818                 /* Check to see if any errors occurred during init */
2819                 if (status & HS_FFERM) {
2820                         /* ERROR: During chipset initialization */
2821                         /* Adapter failed to init, chipset, status reg
2822                            <status> */
2823                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2824                                         "0437 Adapter failed to init, "
2825                                         "chipset, status reg x%x, "
2826                                         "FW Data: A8 x%x AC x%x\n", status,
2827                                         readl(phba->MBslimaddr + 0xa8),
2828                                         readl(phba->MBslimaddr + 0xac));
2829                         phba->link_state = LPFC_HBA_ERROR;
2830                         return -EIO;
2831                 }
2832
2833                 if (i <= 5) {
2834                         msleep(10);
2835                 } else if (i <= 10) {
2836                         msleep(500);
2837                 } else {
2838                         msleep(2500);
2839                 }
2840
2841                 if (i == 15) {
2842                                 /* Do post */
2843                         phba->pport->port_state = LPFC_VPORT_UNKNOWN;
2844                         lpfc_sli_brdrestart(phba);
2845                 }
2846                 /* Read the HBA Host Status Register */
2847                 status = readl(phba->HSregaddr);
2848         }
2849
2850         /* Check to see if any errors occurred during init */
2851         if (status & HS_FFERM) {
2852                 /* ERROR: During chipset initialization */
2853                 /* Adapter failed to init, chipset, status reg <status> */
2854                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2855                                 "0438 Adapter failed to init, chipset, "
2856                                 "status reg x%x, "
2857                                 "FW Data: A8 x%x AC x%x\n", status,
2858                                 readl(phba->MBslimaddr + 0xa8),
2859                                 readl(phba->MBslimaddr + 0xac));
2860                 phba->link_state = LPFC_HBA_ERROR;
2861                 return -EIO;
2862         }
2863
2864         /* Clear all interrupt enable conditions */
2865         writel(0, phba->HCregaddr);
2866         readl(phba->HCregaddr); /* flush */
2867
2868         /* setup host attn register */
2869         writel(0xffffffff, phba->HAregaddr);
2870         readl(phba->HAregaddr); /* flush */
2871         return 0;
2872 }
2873
2874 /**
2875  * lpfc_sli_hbq_count - Get the number of HBQs to be configured
2876  *
2877  * This function calculates and returns the number of HBQs required to be
2878  * configured.
2879  **/
2880 int
2881 lpfc_sli_hbq_count(void)
2882 {
2883         return ARRAY_SIZE(lpfc_hbq_defs);
2884 }
2885
2886 /**
2887  * lpfc_sli_hbq_entry_count - Calculate total number of hbq entries
2888  *
2889  * This function adds the number of hbq entries in every HBQ to get
2890  * the total number of hbq entries required for the HBA and returns
2891  * the total count.
2892  **/
2893 static int
2894 lpfc_sli_hbq_entry_count(void)
2895 {
2896         int  hbq_count = lpfc_sli_hbq_count();
2897         int  count = 0;
2898         int  i;
2899
2900         for (i = 0; i < hbq_count; ++i)
2901                 count += lpfc_hbq_defs[i]->entry_count;
2902         return count;
2903 }
2904
2905 /**
2906  * lpfc_sli_hbq_size - Calculate memory required for all hbq entries
2907  *
2908  * This function calculates amount of memory required for all hbq entries
2909  * to be configured and returns the total memory required.
2910  **/
2911 int
2912 lpfc_sli_hbq_size(void)
2913 {
2914         return lpfc_sli_hbq_entry_count() * sizeof(struct lpfc_hbq_entry);
2915 }
2916
2917 /**
2918  * lpfc_sli_hbq_setup - configure and initialize HBQs
2919  * @phba: Pointer to HBA context object.
2920  *
2921  * This function is called during the SLI initialization to configure
2922  * all the HBQs and post buffers to the HBQ. The caller is not
2923  * required to hold any locks. This function will return zero if successful
2924  * else it will return negative error code.
2925  **/
2926 static int
2927 lpfc_sli_hbq_setup(struct lpfc_hba *phba)
2928 {
2929         int  hbq_count = lpfc_sli_hbq_count();
2930         LPFC_MBOXQ_t *pmb;
2931         MAILBOX_t *pmbox;
2932         uint32_t hbqno;
2933         uint32_t hbq_entry_index;
2934
2935                                 /* Get a Mailbox buffer to setup mailbox
2936                                  * commands for HBA initialization
2937                                  */
2938         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2939
2940         if (!pmb)
2941                 return -ENOMEM;
2942
2943         pmbox = &pmb->mb;
2944
2945         /* Initialize the struct lpfc_sli_hbq structure for each hbq */
2946         phba->link_state = LPFC_INIT_MBX_CMDS;
2947         phba->hbq_in_use = 1;
2948
2949         hbq_entry_index = 0;
2950         for (hbqno = 0; hbqno < hbq_count; ++hbqno) {
2951                 phba->hbqs[hbqno].next_hbqPutIdx = 0;
2952                 phba->hbqs[hbqno].hbqPutIdx      = 0;
2953                 phba->hbqs[hbqno].local_hbqGetIdx   = 0;
2954                 phba->hbqs[hbqno].entry_count =
2955                         lpfc_hbq_defs[hbqno]->entry_count;
2956                 lpfc_config_hbq(phba, hbqno, lpfc_hbq_defs[hbqno],
2957                         hbq_entry_index, pmb);
2958                 hbq_entry_index += phba->hbqs[hbqno].entry_count;
2959
2960                 if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
2961                         /* Adapter failed to init, mbxCmd <cmd> CFG_RING,
2962                            mbxStatus <status>, ring <num> */
2963
2964                         lpfc_printf_log(phba, KERN_ERR,
2965                                         LOG_SLI | LOG_VPORT,
2966                                         "1805 Adapter failed to init. "
2967                                         "Data: x%x x%x x%x\n",
2968                                         pmbox->mbxCommand,
2969                                         pmbox->mbxStatus, hbqno);
2970
2971                         phba->link_state = LPFC_HBA_ERROR;
2972                         mempool_free(pmb, phba->mbox_mem_pool);
2973                         return ENXIO;
2974                 }
2975         }
2976         phba->hbq_count = hbq_count;
2977
2978         mempool_free(pmb, phba->mbox_mem_pool);
2979
2980         /* Initially populate or replenish the HBQs */
2981         for (hbqno = 0; hbqno < hbq_count; ++hbqno)
2982                 lpfc_sli_hbqbuf_init_hbqs(phba, hbqno);
2983         return 0;
2984 }
2985
2986 /**
2987  * lpfc_sli_config_port - Issue config port mailbox command
2988  * @phba: Pointer to HBA context object.
2989  * @sli_mode: sli mode - 2/3
2990  *
2991  * This function is called by the sli intialization code path
2992  * to issue config_port mailbox command. This function restarts the
2993  * HBA firmware and issues a config_port mailbox command to configure
2994  * the SLI interface in the sli mode specified by sli_mode
2995  * variable. The caller is not required to hold any locks.
2996  * The function returns 0 if successful, else returns negative error
2997  * code.
2998  **/
2999 int
3000 lpfc_sli_config_port(struct lpfc_hba *phba, int sli_mode)
3001 {
3002         LPFC_MBOXQ_t *pmb;
3003         uint32_t resetcount = 0, rc = 0, done = 0;
3004
3005         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3006         if (!pmb) {
3007                 phba->link_state = LPFC_HBA_ERROR;
3008                 return -ENOMEM;
3009         }
3010
3011         phba->sli_rev = sli_mode;
3012         while (resetcount < 2 && !done) {
3013                 spin_lock_irq(&phba->hbalock);
3014                 phba->sli.sli_flag |= LPFC_SLI_MBOX_ACTIVE;
3015                 spin_unlock_irq(&phba->hbalock);
3016                 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
3017                 lpfc_sli_brdrestart(phba);
3018                 rc = lpfc_sli_chipset_init(phba);
3019                 if (rc)
3020                         break;
3021
3022                 spin_lock_irq(&phba->hbalock);
3023                 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3024                 spin_unlock_irq(&phba->hbalock);
3025                 resetcount++;
3026
3027                 /* Call pre CONFIG_PORT mailbox command initialization.  A
3028                  * value of 0 means the call was successful.  Any other
3029                  * nonzero value is a failure, but if ERESTART is returned,
3030                  * the driver may reset the HBA and try again.
3031                  */
3032                 rc = lpfc_config_port_prep(phba);
3033                 if (rc == -ERESTART) {
3034                         phba->link_state = LPFC_LINK_UNKNOWN;
3035                         continue;
3036                 } else if (rc)
3037                         break;
3038                 phba->link_state = LPFC_INIT_MBX_CMDS;
3039                 lpfc_config_port(phba, pmb);
3040                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
3041                 phba->sli3_options &= ~(LPFC_SLI3_NPIV_ENABLED |
3042                                         LPFC_SLI3_HBQ_ENABLED |
3043                                         LPFC_SLI3_CRP_ENABLED |
3044                                         LPFC_SLI3_INB_ENABLED |
3045                                         LPFC_SLI3_BG_ENABLED);
3046                 if (rc != MBX_SUCCESS) {
3047                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3048                                 "0442 Adapter failed to init, mbxCmd x%x "
3049                                 "CONFIG_PORT, mbxStatus x%x Data: x%x\n",
3050                                 pmb->mb.mbxCommand, pmb->mb.mbxStatus, 0);
3051                         spin_lock_irq(&phba->hbalock);
3052                         phba->sli.sli_flag &= ~LPFC_SLI2_ACTIVE;
3053                         spin_unlock_irq(&phba->hbalock);
3054                         rc = -ENXIO;
3055                 } else
3056                         done = 1;
3057         }
3058         if (!done) {
3059                 rc = -EINVAL;
3060                 goto do_prep_failed;
3061         }
3062         if (pmb->mb.un.varCfgPort.sli_mode == 3) {
3063                 if (!pmb->mb.un.varCfgPort.cMA) {
3064                         rc = -ENXIO;
3065                         goto do_prep_failed;
3066                 }
3067                 if (phba->max_vpi && pmb->mb.un.varCfgPort.gmv) {
3068                         phba->sli3_options |= LPFC_SLI3_NPIV_ENABLED;
3069                         phba->max_vpi = pmb->mb.un.varCfgPort.max_vpi;
3070                 } else
3071                         phba->max_vpi = 0;
3072                 if (pmb->mb.un.varCfgPort.gerbm)
3073                         phba->sli3_options |= LPFC_SLI3_HBQ_ENABLED;
3074                 if (pmb->mb.un.varCfgPort.gcrp)
3075                         phba->sli3_options |= LPFC_SLI3_CRP_ENABLED;
3076                 if (pmb->mb.un.varCfgPort.ginb) {
3077                         phba->sli3_options |= LPFC_SLI3_INB_ENABLED;
3078                         phba->hbq_get = phba->mbox->us.s3_inb_pgp.hbq_get;
3079                         phba->port_gp = phba->mbox->us.s3_inb_pgp.port;
3080                         phba->inb_ha_copy = &phba->mbox->us.s3_inb_pgp.ha_copy;
3081                         phba->inb_counter = &phba->mbox->us.s3_inb_pgp.counter;
3082                         phba->inb_last_counter =
3083                                         phba->mbox->us.s3_inb_pgp.counter;
3084                 } else {
3085                         phba->hbq_get = phba->mbox->us.s3_pgp.hbq_get;
3086                         phba->port_gp = phba->mbox->us.s3_pgp.port;
3087                         phba->inb_ha_copy = NULL;
3088                         phba->inb_counter = NULL;
3089                 }
3090
3091                 if (phba->cfg_enable_bg) {
3092                         if (pmb->mb.un.varCfgPort.gbg)
3093                                 phba->sli3_options |= LPFC_SLI3_BG_ENABLED;
3094                         else
3095                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3096                                                 "0443 Adapter did not grant "
3097                                                 "BlockGuard\n");
3098                 }
3099         } else {
3100                 phba->hbq_get = NULL;
3101                 phba->port_gp = phba->mbox->us.s2.port;
3102                 phba->inb_ha_copy = NULL;
3103                 phba->inb_counter = NULL;
3104                 phba->max_vpi = 0;
3105         }
3106 do_prep_failed:
3107         mempool_free(pmb, phba->mbox_mem_pool);
3108         return rc;
3109 }
3110
3111
3112 /**
3113  * lpfc_sli_hba_setup - SLI intialization function
3114  * @phba: Pointer to HBA context object.
3115  *
3116  * This function is the main SLI intialization function. This function
3117  * is called by the HBA intialization code, HBA reset code and HBA
3118  * error attention handler code. Caller is not required to hold any
3119  * locks. This function issues config_port mailbox command to configure
3120  * the SLI, setup iocb rings and HBQ rings. In the end the function
3121  * calls the config_port_post function to issue init_link mailbox
3122  * command and to start the discovery. The function will return zero
3123  * if successful, else it will return negative error code.
3124  **/
3125 int
3126 lpfc_sli_hba_setup(struct lpfc_hba *phba)
3127 {
3128         uint32_t rc;
3129         int  mode = 3;
3130
3131         switch (lpfc_sli_mode) {
3132         case 2:
3133                 if (phba->cfg_enable_npiv) {
3134                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3135                                 "1824 NPIV enabled: Override lpfc_sli_mode "
3136                                 "parameter (%d) to auto (0).\n",
3137                                 lpfc_sli_mode);
3138                         break;
3139                 }
3140                 mode = 2;
3141                 break;
3142         case 0:
3143         case 3:
3144                 break;
3145         default:
3146                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3147                                 "1819 Unrecognized lpfc_sli_mode "
3148                                 "parameter: %d.\n", lpfc_sli_mode);
3149
3150                 break;
3151         }
3152
3153         rc = lpfc_sli_config_port(phba, mode);
3154
3155         if (rc && lpfc_sli_mode == 3)
3156                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
3157                                 "1820 Unable to select SLI-3.  "
3158                                 "Not supported by adapter.\n");
3159         if (rc && mode != 2)
3160                 rc = lpfc_sli_config_port(phba, 2);
3161         if (rc)
3162                 goto lpfc_sli_hba_setup_error;
3163
3164         if (phba->sli_rev == 3) {
3165                 phba->iocb_cmd_size = SLI3_IOCB_CMD_SIZE;
3166                 phba->iocb_rsp_size = SLI3_IOCB_RSP_SIZE;
3167         } else {
3168                 phba->iocb_cmd_size = SLI2_IOCB_CMD_SIZE;
3169                 phba->iocb_rsp_size = SLI2_IOCB_RSP_SIZE;
3170                 phba->sli3_options = 0;
3171         }
3172
3173         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3174                         "0444 Firmware in SLI %x mode. Max_vpi %d\n",
3175                         phba->sli_rev, phba->max_vpi);
3176         rc = lpfc_sli_ring_map(phba);
3177
3178         if (rc)
3179                 goto lpfc_sli_hba_setup_error;
3180
3181         /* Init HBQs */
3182         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
3183                 rc = lpfc_sli_hbq_setup(phba);
3184                 if (rc)
3185                         goto lpfc_sli_hba_setup_error;
3186         }
3187
3188         phba->sli.sli_flag |= LPFC_PROCESS_LA;
3189
3190         rc = lpfc_config_port_post(phba);
3191         if (rc)
3192                 goto lpfc_sli_hba_setup_error;
3193
3194         return rc;
3195
3196 lpfc_sli_hba_setup_error:
3197         phba->link_state = LPFC_HBA_ERROR;
3198         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3199                         "0445 Firmware initialization failed\n");
3200         return rc;
3201 }
3202
3203
3204 /**
3205  * lpfc_mbox_timeout - Timeout call back function for mbox timer
3206  * @ptr: context object - pointer to hba structure.
3207  *
3208  * This is the callback function for mailbox timer. The mailbox
3209  * timer is armed when a new mailbox command is issued and the timer
3210  * is deleted when the mailbox complete. The function is called by
3211  * the kernel timer code when a mailbox does not complete within
3212  * expected time. This function wakes up the worker thread to
3213  * process the mailbox timeout and returns. All the processing is
3214  * done by the worker thread function lpfc_mbox_timeout_handler.
3215  **/
3216 void
3217 lpfc_mbox_timeout(unsigned long ptr)
3218 {
3219         struct lpfc_hba  *phba = (struct lpfc_hba *) ptr;
3220         unsigned long iflag;
3221         uint32_t tmo_posted;
3222
3223         spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
3224         tmo_posted = phba->pport->work_port_events & WORKER_MBOX_TMO;
3225         if (!tmo_posted)
3226                 phba->pport->work_port_events |= WORKER_MBOX_TMO;
3227         spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
3228
3229         if (!tmo_posted)
3230                 lpfc_worker_wake_up(phba);
3231         return;
3232 }
3233
3234
3235 /**
3236  * lpfc_mbox_timeout_handler - Worker thread function to handle mailbox timeout
3237  * @phba: Pointer to HBA context object.
3238  *
3239  * This function is called from worker thread when a mailbox command times out.
3240  * The caller is not required to hold any locks. This function will reset the
3241  * HBA and recover all the pending commands.
3242  **/
3243 void
3244 lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
3245 {
3246         LPFC_MBOXQ_t *pmbox = phba->sli.mbox_active;
3247         MAILBOX_t *mb = &pmbox->mb;
3248         struct lpfc_sli *psli = &phba->sli;
3249         struct lpfc_sli_ring *pring;
3250
3251         /* Check the pmbox pointer first.  There is a race condition
3252          * between the mbox timeout handler getting executed in the
3253          * worklist and the mailbox actually completing. When this
3254          * race condition occurs, the mbox_active will be NULL.
3255          */
3256         spin_lock_irq(&phba->hbalock);
3257         if (pmbox == NULL) {
3258                 lpfc_printf_log(phba, KERN_WARNING,
3259                                 LOG_MBOX | LOG_SLI,
3260                                 "0353 Active Mailbox cleared - mailbox timeout "
3261                                 "exiting\n");
3262                 spin_unlock_irq(&phba->hbalock);
3263                 return;
3264         }
3265
3266         /* Mbox cmd <mbxCommand> timeout */
3267         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3268                         "0310 Mailbox command x%x timeout Data: x%x x%x x%p\n",
3269                         mb->mbxCommand,
3270                         phba->pport->port_state,
3271                         phba->sli.sli_flag,
3272                         phba->sli.mbox_active);
3273         spin_unlock_irq(&phba->hbalock);
3274
3275         /* Setting state unknown so lpfc_sli_abort_iocb_ring
3276          * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
3277          * it to fail all oustanding SCSI IO.
3278          */
3279         spin_lock_irq(&phba->pport->work_port_lock);
3280         phba->pport->work_port_events &= ~WORKER_MBOX_TMO;
3281         spin_unlock_irq(&phba->pport->work_port_lock);
3282         spin_lock_irq(&phba->hbalock);
3283         phba->link_state = LPFC_LINK_UNKNOWN;
3284         psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
3285         spin_unlock_irq(&phba->hbalock);
3286
3287         pring = &psli->ring[psli->fcp_ring];
3288         lpfc_sli_abort_iocb_ring(phba, pring);
3289
3290         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3291                         "0345 Resetting board due to mailbox timeout\n");
3292         /*
3293          * lpfc_offline calls lpfc_sli_hba_down which will clean up
3294          * on oustanding mailbox commands.
3295          */
3296         /* If resets are disabled then set error state and return. */
3297         if (!phba->cfg_enable_hba_reset) {
3298                 phba->link_state = LPFC_HBA_ERROR;
3299                 return;
3300         }
3301         lpfc_offline_prep(phba);
3302         lpfc_offline(phba);
3303         lpfc_sli_brdrestart(phba);
3304         lpfc_online(phba);
3305         lpfc_unblock_mgmt_io(phba);
3306         return;
3307 }
3308
3309 /**
3310  * lpfc_sli_issue_mbox - Issue a mailbox command to firmware
3311  * @phba: Pointer to HBA context object.
3312  * @pmbox: Pointer to mailbox object.
3313  * @flag: Flag indicating how the mailbox need to be processed.
3314  *
3315  * This function is called by discovery code and HBA management code
3316  * to submit a mailbox command to firmware. This function gets the
3317  * hbalock to protect the data structures.
3318  * The mailbox command can be submitted in polling mode, in which case
3319  * this function will wait in a polling loop for the completion of the
3320  * mailbox.
3321  * If the mailbox is submitted in no_wait mode (not polling) the
3322  * function will submit the command and returns immediately without waiting
3323  * for the mailbox completion. The no_wait is supported only when HBA
3324  * is in SLI2/SLI3 mode - interrupts are enabled.
3325  * The SLI interface allows only one mailbox pending at a time. If the
3326  * mailbox is issued in polling mode and there is already a mailbox
3327  * pending, then the function will return an error. If the mailbox is issued
3328  * in NO_WAIT mode and there is a mailbox pending already, the function
3329  * will return MBX_BUSY after queuing the mailbox into mailbox queue.
3330  * The sli layer owns the mailbox object until the completion of mailbox
3331  * command if this function return MBX_BUSY or MBX_SUCCESS. For all other
3332  * return codes the caller owns the mailbox command after the return of
3333  * the function.
3334  **/
3335 int
3336 lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3337 {
3338         MAILBOX_t *mb;
3339         struct lpfc_sli *psli = &phba->sli;
3340         uint32_t status, evtctr;
3341         uint32_t ha_copy;
3342         int i;
3343         unsigned long timeout;
3344         unsigned long drvr_flag = 0;
3345         uint32_t word0, ldata;
3346         void __iomem *to_slim;
3347         int processing_queue = 0;
3348
3349         spin_lock_irqsave(&phba->hbalock, drvr_flag);
3350         if (!pmbox) {
3351                 /* processing mbox queue from intr_handler */
3352                 processing_queue = 1;
3353                 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3354                 pmbox = lpfc_mbox_get(phba);
3355                 if (!pmbox) {
3356                         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3357                         return MBX_SUCCESS;
3358                 }
3359         }
3360
3361         if (pmbox->mbox_cmpl && pmbox->mbox_cmpl != lpfc_sli_def_mbox_cmpl &&
3362                 pmbox->mbox_cmpl != lpfc_sli_wake_mbox_wait) {
3363                 if(!pmbox->vport) {
3364                         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3365                         lpfc_printf_log(phba, KERN_ERR,
3366                                         LOG_MBOX | LOG_VPORT,
3367                                         "1806 Mbox x%x failed. No vport\n",
3368                                         pmbox->mb.mbxCommand);
3369                         dump_stack();
3370                         goto out_not_finished;
3371                 }
3372         }
3373
3374         /* If the PCI channel is in offline state, do not post mbox. */
3375         if (unlikely(pci_channel_offline(phba->pcidev))) {
3376                 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3377                 goto out_not_finished;
3378         }
3379
3380         /* If HBA has a deferred error attention, fail the iocb. */
3381         if (unlikely(phba->hba_flag & DEFER_ERATT)) {
3382                 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3383                 goto out_not_finished;
3384         }
3385
3386         psli = &phba->sli;
3387
3388         mb = &pmbox->mb;
3389         status = MBX_SUCCESS;
3390
3391         if (phba->link_state == LPFC_HBA_ERROR) {
3392                 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3393
3394                 /* Mbox command <mbxCommand> cannot issue */
3395                 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3396                 goto out_not_finished;
3397         }
3398
3399         if (mb->mbxCommand != MBX_KILL_BOARD && flag & MBX_NOWAIT &&
3400             !(readl(phba->HCregaddr) & HC_MBINT_ENA)) {
3401                 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3402                 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3403                 goto out_not_finished;
3404         }
3405
3406         if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {
3407                 /* Polling for a mbox command when another one is already active
3408                  * is not allowed in SLI. Also, the driver must have established
3409                  * SLI2 mode to queue and process multiple mbox commands.
3410                  */
3411
3412                 if (flag & MBX_POLL) {
3413                         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3414
3415                         /* Mbox command <mbxCommand> cannot issue */
3416                         LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3417                         goto out_not_finished;
3418                 }
3419
3420                 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE)) {
3421                         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3422                         /* Mbox command <mbxCommand> cannot issue */
3423                         LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3424                         goto out_not_finished;
3425                 }
3426
3427                 /* Another mailbox command is still being processed, queue this
3428                  * command to be processed later.
3429                  */
3430                 lpfc_mbox_put(phba, pmbox);
3431
3432                 /* Mbox cmd issue - BUSY */
3433                 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
3434                                 "(%d):0308 Mbox cmd issue - BUSY Data: "
3435                                 "x%x x%x x%x x%x\n",
3436                                 pmbox->vport ? pmbox->vport->vpi : 0xffffff,
3437                                 mb->mbxCommand, phba->pport->port_state,
3438                                 psli->sli_flag, flag);
3439
3440                 psli->slistat.mbox_busy++;
3441                 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3442
3443                 if (pmbox->vport) {
3444                         lpfc_debugfs_disc_trc(pmbox->vport,
3445                                 LPFC_DISC_TRC_MBOX_VPORT,
3446                                 "MBOX Bsy vport:  cmd:x%x mb:x%x x%x",
3447                                 (uint32_t)mb->mbxCommand,
3448                                 mb->un.varWords[0], mb->un.varWords[1]);
3449                 }
3450                 else {
3451                         lpfc_debugfs_disc_trc(phba->pport,
3452                                 LPFC_DISC_TRC_MBOX,
3453                                 "MBOX Bsy:        cmd:x%x mb:x%x x%x",
3454                                 (uint32_t)mb->mbxCommand,
3455                                 mb->un.varWords[0], mb->un.varWords[1]);
3456                 }
3457
3458                 return MBX_BUSY;
3459         }
3460
3461         psli->sli_flag |= LPFC_SLI_MBOX_ACTIVE;
3462
3463         /* If we are not polling, we MUST be in SLI2 mode */
3464         if (flag != MBX_POLL) {
3465                 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE) &&
3466                     (mb->mbxCommand != MBX_KILL_BOARD)) {
3467                         psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3468                         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3469                         /* Mbox command <mbxCommand> cannot issue */
3470                         LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag);
3471                         goto out_not_finished;
3472                 }
3473                 /* timeout active mbox command */
3474                 mod_timer(&psli->mbox_tmo, (jiffies +
3475                                (HZ * lpfc_mbox_tmo_val(phba, mb->mbxCommand))));
3476         }
3477
3478         /* Mailbox cmd <cmd> issue */
3479         lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
3480                         "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
3481                         "x%x\n",
3482                         pmbox->vport ? pmbox->vport->vpi : 0,
3483                         mb->mbxCommand, phba->pport->port_state,
3484                         psli->sli_flag, flag);
3485
3486         if (mb->mbxCommand != MBX_HEARTBEAT) {
3487                 if (pmbox->vport) {
3488                         lpfc_debugfs_disc_trc(pmbox->vport,
3489                                 LPFC_DISC_TRC_MBOX_VPORT,
3490                                 "MBOX Send vport: cmd:x%x mb:x%x x%x",
3491                                 (uint32_t)mb->mbxCommand,
3492                                 mb->un.varWords[0], mb->un.varWords[1]);
3493                 }
3494                 else {
3495                         lpfc_debugfs_disc_trc(phba->pport,
3496                                 LPFC_DISC_TRC_MBOX,
3497                                 "MBOX Send:       cmd:x%x mb:x%x x%x",
3498                                 (uint32_t)mb->mbxCommand,
3499                                 mb->un.varWords[0], mb->un.varWords[1]);
3500                 }
3501         }
3502
3503         psli->slistat.mbox_cmd++;
3504         evtctr = psli->slistat.mbox_event;
3505
3506         /* next set own bit for the adapter and copy over command word */
3507         mb->mbxOwner = OWN_CHIP;
3508
3509         if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3510                 /* First copy command data to host SLIM area */
3511                 lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE);
3512         } else {
3513                 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3514                         /* copy command data into host mbox for cmpl */
3515                         lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE);
3516                 }
3517
3518                 /* First copy mbox command data to HBA SLIM, skip past first
3519                    word */
3520                 to_slim = phba->MBslimaddr + sizeof (uint32_t);
3521                 lpfc_memcpy_to_slim(to_slim, &mb->un.varWords[0],
3522                             MAILBOX_CMD_SIZE - sizeof (uint32_t));
3523
3524                 /* Next copy over first word, with mbxOwner set */
3525                 ldata = *((uint32_t *)mb);
3526                 to_slim = phba->MBslimaddr;
3527                 writel(ldata, to_slim);
3528                 readl(to_slim); /* flush */
3529
3530                 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3531                         /* switch over to host mailbox */
3532                         psli->sli_flag |= LPFC_SLI2_ACTIVE;
3533                 }
3534         }
3535
3536         wmb();
3537
3538         switch (flag) {
3539         case MBX_NOWAIT:
3540                 /* Set up reference to mailbox command */
3541                 psli->mbox_active = pmbox;
3542                 /* Interrupt board to do it */
3543                 writel(CA_MBATT, phba->CAregaddr);
3544                 readl(phba->CAregaddr); /* flush */
3545                 /* Don't wait for it to finish, just return */
3546                 break;
3547
3548         case MBX_POLL:
3549                 /* Set up null reference to mailbox command */
3550                 psli->mbox_active = NULL;
3551                 /* Interrupt board to do it */
3552                 writel(CA_MBATT, phba->CAregaddr);
3553                 readl(phba->CAregaddr); /* flush */
3554
3555                 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3556                         /* First read mbox status word */
3557                         word0 = *((uint32_t *)phba->mbox);
3558                         word0 = le32_to_cpu(word0);
3559                 } else {
3560                         /* First read mbox status word */
3561                         word0 = readl(phba->MBslimaddr);
3562                 }
3563
3564                 /* Read the HBA Host Attention Register */
3565                 ha_copy = readl(phba->HAregaddr);
3566                 timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba,
3567                                                              mb->mbxCommand) *
3568                                            1000) + jiffies;
3569                 i = 0;
3570                 /* Wait for command to complete */
3571                 while (((word0 & OWN_CHIP) == OWN_CHIP) ||
3572                        (!(ha_copy & HA_MBATT) &&
3573                         (phba->link_state > LPFC_WARM_START))) {
3574                         if (time_after(jiffies, timeout)) {
3575                                 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3576                                 spin_unlock_irqrestore(&phba->hbalock,
3577                                                        drvr_flag);
3578                                 goto out_not_finished;
3579                         }
3580
3581                         /* Check if we took a mbox interrupt while we were
3582                            polling */
3583                         if (((word0 & OWN_CHIP) != OWN_CHIP)
3584                             && (evtctr != psli->slistat.mbox_event))
3585                                 break;
3586
3587                         if (i++ > 10) {
3588                                 spin_unlock_irqrestore(&phba->hbalock,
3589                                                        drvr_flag);
3590                                 msleep(1);
3591                                 spin_lock_irqsave(&phba->hbalock, drvr_flag);
3592                         }
3593
3594                         if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3595                                 /* First copy command data */
3596                                 word0 = *((uint32_t *)phba->mbox);
3597                                 word0 = le32_to_cpu(word0);
3598                                 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3599                                         MAILBOX_t *slimmb;
3600                                         uint32_t slimword0;
3601                                         /* Check real SLIM for any errors */
3602                                         slimword0 = readl(phba->MBslimaddr);
3603                                         slimmb = (MAILBOX_t *) & slimword0;
3604                                         if (((slimword0 & OWN_CHIP) != OWN_CHIP)
3605                                             && slimmb->mbxStatus) {
3606                                                 psli->sli_flag &=
3607                                                     ~LPFC_SLI2_ACTIVE;
3608                                                 word0 = slimword0;
3609                                         }
3610                                 }
3611                         } else {
3612                                 /* First copy command data */
3613                                 word0 = readl(phba->MBslimaddr);
3614                         }
3615                         /* Read the HBA Host Attention Register */
3616                         ha_copy = readl(phba->HAregaddr);
3617                 }
3618
3619                 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
3620                         /* copy results back to user */
3621                         lpfc_sli_pcimem_bcopy(phba->mbox, mb, MAILBOX_CMD_SIZE);
3622                 } else {
3623                         /* First copy command data */
3624                         lpfc_memcpy_from_slim(mb, phba->MBslimaddr,
3625                                                         MAILBOX_CMD_SIZE);
3626                         if ((mb->mbxCommand == MBX_DUMP_MEMORY) &&
3627                                 pmbox->context2) {
3628                                 lpfc_memcpy_from_slim((void *)pmbox->context2,
3629                                       phba->MBslimaddr + DMP_RSP_OFFSET,
3630                                                       mb->un.varDmp.word_cnt);
3631                         }
3632                 }
3633
3634                 writel(HA_MBATT, phba->HAregaddr);
3635                 readl(phba->HAregaddr); /* flush */
3636
3637                 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3638                 status = mb->mbxStatus;
3639         }
3640
3641         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3642         return status;
3643
3644 out_not_finished:
3645         if (processing_queue) {
3646                 pmbox->mb.mbxStatus = MBX_NOT_FINISHED;
3647                 lpfc_mbox_cmpl_put(phba, pmbox);
3648         }
3649         return MBX_NOT_FINISHED;
3650 }
3651
3652 /**
3653  * __lpfc_sli_ringtx_put - Add an iocb to the txq
3654  * @phba: Pointer to HBA context object.
3655  * @pring: Pointer to driver SLI ring object.
3656  * @piocb: Pointer to address of newly added command iocb.
3657  *
3658  * This function is called with hbalock held to add a command
3659  * iocb to the txq when SLI layer cannot submit the command iocb
3660  * to the ring.
3661  **/
3662 static void
3663 __lpfc_sli_ringtx_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3664                     struct lpfc_iocbq *piocb)
3665 {
3666         /* Insert the caller's iocb in the txq tail for later processing. */
3667         list_add_tail(&piocb->list, &pring->txq);
3668         pring->txq_cnt++;
3669 }
3670
3671 /**
3672  * lpfc_sli_next_iocb - Get the next iocb in the txq
3673  * @phba: Pointer to HBA context object.
3674  * @pring: Pointer to driver SLI ring object.
3675  * @piocb: Pointer to address of newly added command iocb.
3676  *
3677  * This function is called with hbalock held before a new
3678  * iocb is submitted to the firmware. This function checks
3679  * txq to flush the iocbs in txq to Firmware before
3680  * submitting new iocbs to the Firmware.
3681  * If there are iocbs in the txq which need to be submitted
3682  * to firmware, lpfc_sli_next_iocb returns the first element
3683  * of the txq after dequeuing it from txq.
3684  * If there is no iocb in the txq then the function will return
3685  * *piocb and *piocb is set to NULL. Caller needs to check
3686  * *piocb to find if there are more commands in the txq.
3687  **/
3688 static struct lpfc_iocbq *
3689 lpfc_sli_next_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3690                    struct lpfc_iocbq **piocb)
3691 {
3692         struct lpfc_iocbq * nextiocb;
3693
3694         nextiocb = lpfc_sli_ringtx_get(phba, pring);
3695         if (!nextiocb) {
3696                 nextiocb = *piocb;
3697                 *piocb = NULL;
3698         }
3699
3700         return nextiocb;
3701 }
3702
3703 /**
3704  * __lpfc_sli_issue_iocb - Lockless version of lpfc_sli_issue_iocb
3705  * @phba: Pointer to HBA context object.
3706  * @pring: Pointer to driver SLI ring object.
3707  * @piocb: Pointer to command iocb.
3708  * @flag: Flag indicating if this command can be put into txq.
3709  *
3710  * __lpfc_sli_issue_iocb is used by other functions in the driver
3711  * to issue an iocb command to the HBA. If the PCI slot is recovering
3712  * from error state or if HBA is resetting or if LPFC_STOP_IOCB_EVENT
3713  * flag is turned on, the function returns IOCB_ERROR.
3714  * When the link is down, this function allows only iocbs for
3715  * posting buffers.
3716  * This function finds next available slot in the command ring and
3717  * posts the command to the available slot and writes the port
3718  * attention register to request HBA start processing new iocb.
3719  * If there is no slot available in the ring and
3720  * flag & SLI_IOCB_RET_IOCB is set, the new iocb is added to the
3721  * txq, otherwise the function returns IOCB_BUSY.
3722  *
3723  * This function is called with hbalock held.
3724  * The function will return success after it successfully submit the
3725  * iocb to firmware or after adding to the txq.
3726  **/
3727 static int
3728 __lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3729                     struct lpfc_iocbq *piocb, uint32_t flag)
3730 {
3731         struct lpfc_iocbq *nextiocb;
3732         IOCB_t *iocb;
3733
3734         if (piocb->iocb_cmpl && (!piocb->vport) &&
3735            (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
3736            (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN)) {
3737                 lpfc_printf_log(phba, KERN_ERR,
3738                                 LOG_SLI | LOG_VPORT,
3739                                 "1807 IOCB x%x failed. No vport\n",
3740                                 piocb->iocb.ulpCommand);
3741                 dump_stack();
3742                 return IOCB_ERROR;
3743         }
3744
3745
3746         /* If the PCI channel is in offline state, do not post iocbs. */
3747         if (unlikely(pci_channel_offline(phba->pcidev)))
3748                 return IOCB_ERROR;
3749
3750         /* If HBA has a deferred error attention, fail the iocb. */
3751         if (unlikely(phba->hba_flag & DEFER_ERATT))
3752                 return IOCB_ERROR;
3753
3754         /*
3755          * We should never get an IOCB if we are in a < LINK_DOWN state
3756          */
3757         if (unlikely(phba->link_state < LPFC_LINK_DOWN))
3758                 return IOCB_ERROR;
3759
3760         /*
3761          * Check to see if we are blocking IOCB processing because of a
3762          * outstanding event.
3763          */
3764         if (unlikely(pring->flag & LPFC_STOP_IOCB_EVENT))
3765                 goto iocb_busy;
3766
3767         if (unlikely(phba->link_state == LPFC_LINK_DOWN)) {
3768                 /*
3769                  * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
3770                  * can be issued if the link is not up.
3771                  */
3772                 switch (piocb->iocb.ulpCommand) {
3773                 case CMD_GEN_REQUEST64_CR:
3774                 case CMD_GEN_REQUEST64_CX:
3775                         if (!(phba->sli.sli_flag & LPFC_MENLO_MAINT) ||
3776                                 (piocb->iocb.un.genreq64.w5.hcsw.Rctl !=
3777                                         FC_FCP_CMND) ||
3778                                 (piocb->iocb.un.genreq64.w5.hcsw.Type !=
3779                                         MENLO_TRANSPORT_TYPE))
3780
3781                                 goto iocb_busy;
3782                         break;
3783                 case CMD_QUE_RING_BUF_CN:
3784                 case CMD_QUE_RING_BUF64_CN:
3785                         /*
3786                          * For IOCBs, like QUE_RING_BUF, that have no rsp ring
3787                          * completion, iocb_cmpl MUST be 0.
3788                          */
3789                         if (piocb->iocb_cmpl)
3790                                 piocb->iocb_cmpl = NULL;
3791                         /*FALLTHROUGH*/
3792                 case CMD_CREATE_XRI_CR:
3793                 case CMD_CLOSE_XRI_CN:
3794                 case CMD_CLOSE_XRI_CX:
3795                         break;
3796                 default:
3797                         goto iocb_busy;
3798                 }
3799
3800         /*
3801          * For FCP commands, we must be in a state where we can process link
3802          * attention events.
3803          */
3804         } else if (unlikely(pring->ringno == phba->sli.fcp_ring &&
3805                             !(phba->sli.sli_flag & LPFC_PROCESS_LA))) {
3806                 goto iocb_busy;
3807         }
3808
3809         while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
3810                (nextiocb = lpfc_sli_next_iocb(phba, pring, &piocb)))
3811                 lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
3812
3813         if (iocb)
3814                 lpfc_sli_update_ring(phba, pring);
3815         else
3816                 lpfc_sli_update_full_ring(phba, pring);
3817
3818         if (!piocb)
3819                 return IOCB_SUCCESS;
3820
3821         goto out_busy;
3822
3823  iocb_busy:
3824         pring->stats.iocb_cmd_delay++;
3825
3826  out_busy:
3827
3828         if (!(flag & SLI_IOCB_RET_IOCB)) {
3829                 __lpfc_sli_ringtx_put(phba, pring, piocb);
3830                 return IOCB_SUCCESS;
3831         }
3832
3833         return IOCB_BUSY;
3834 }
3835
3836
3837 /**
3838  * lpfc_sli_issue_iocb - Wrapper function for __lpfc_sli_issue_iocb
3839  * @phba: Pointer to HBA context object.
3840  * @pring: Pointer to driver SLI ring object.
3841  * @piocb: Pointer to command iocb.
3842  * @flag: Flag indicating if this command can be put into txq.
3843  *
3844  * lpfc_sli_issue_iocb is a wrapper around __lpfc_sli_issue_iocb
3845  * function. This function gets the hbalock and calls
3846  * __lpfc_sli_issue_iocb function and will return the error returned
3847  * by __lpfc_sli_issue_iocb function. This wrapper is used by
3848  * functions which do not hold hbalock.
3849  **/
3850 int
3851 lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3852                     struct lpfc_iocbq *piocb, uint32_t flag)
3853 {
3854         unsigned long iflags;
3855         int rc;
3856
3857         spin_lock_irqsave(&phba->hbalock, iflags);
3858         rc = __lpfc_sli_issue_iocb(phba, pring, piocb, flag);
3859         spin_unlock_irqrestore(&phba->hbalock, iflags);
3860
3861         return rc;
3862 }
3863
3864 /**
3865  * lpfc_extra_ring_setup - Extra ring setup function
3866  * @phba: Pointer to HBA context object.
3867  *
3868  * This function is called while driver attaches with the
3869  * HBA to setup the extra ring. The extra ring is used
3870  * only when driver needs to support target mode functionality
3871  * or IP over FC functionalities.
3872  *
3873  * This function is called with no lock held.
3874  **/
3875 static int
3876 lpfc_extra_ring_setup( struct lpfc_hba *phba)
3877 {
3878         struct lpfc_sli *psli;
3879         struct lpfc_sli_ring *pring;
3880
3881         psli = &phba->sli;
3882
3883         /* Adjust cmd/rsp ring iocb entries more evenly */
3884
3885         /* Take some away from the FCP ring */
3886         pring = &psli->ring[psli->fcp_ring];
3887         pring->numCiocb -= SLI2_IOCB_CMD_R1XTRA_ENTRIES;
3888         pring->numRiocb -= SLI2_IOCB_RSP_R1XTRA_ENTRIES;
3889         pring->numCiocb -= SLI2_IOCB_CMD_R3XTRA_ENTRIES;
3890         pring->numRiocb -= SLI2_IOCB_RSP_R3XTRA_ENTRIES;
3891
3892         /* and give them to the extra ring */
3893         pring = &psli->ring[psli->extra_ring];
3894
3895         pring->numCiocb += SLI2_IOCB_CMD_R1XTRA_ENTRIES;
3896         pring->numRiocb += SLI2_IOCB_RSP_R1XTRA_ENTRIES;
3897         pring->numCiocb += SLI2_IOCB_CMD_R3XTRA_ENTRIES;
3898         pring->numRiocb += SLI2_IOCB_RSP_R3XTRA_ENTRIES;
3899
3900         /* Setup default profile for this ring */
3901         pring->iotag_max = 4096;
3902         pring->num_mask = 1;
3903         pring->prt[0].profile = 0;      /* Mask 0 */
3904         pring->prt[0].rctl = phba->cfg_multi_ring_rctl;
3905         pring->prt[0].type = phba->cfg_multi_ring_type;
3906         pring->prt[0].lpfc_sli_rcv_unsol_event = NULL;
3907         return 0;
3908 }
3909
3910 /**
3911  * lpfc_sli_async_event_handler - ASYNC iocb handler function
3912  * @phba: Pointer to HBA context object.
3913  * @pring: Pointer to driver SLI ring object.
3914  * @iocbq: Pointer to iocb object.
3915  *
3916  * This function is called by the slow ring event handler
3917  * function when there is an ASYNC event iocb in the ring.
3918  * This function is called with no lock held.
3919  * Currently this function handles only temperature related
3920  * ASYNC events. The function decodes the temperature sensor
3921  * event message and posts events for the management applications.
3922  **/
3923 static void
3924 lpfc_sli_async_event_handler(struct lpfc_hba * phba,
3925         struct lpfc_sli_ring * pring, struct lpfc_iocbq * iocbq)
3926 {
3927         IOCB_t *icmd;
3928         uint16_t evt_code;
3929         uint16_t temp;
3930         struct temp_event temp_event_data;
3931         struct Scsi_Host *shost;
3932         uint32_t *iocb_w;
3933
3934         icmd = &iocbq->iocb;
3935         evt_code = icmd->un.asyncstat.evt_code;
3936         temp = icmd->ulpContext;
3937
3938         if ((evt_code != ASYNC_TEMP_WARN) &&
3939                 (evt_code != ASYNC_TEMP_SAFE)) {
3940                 iocb_w = (uint32_t *) icmd;
3941                 lpfc_printf_log(phba,
3942                         KERN_ERR,
3943                         LOG_SLI,
3944                         "0346 Ring %d handler: unexpected ASYNC_STATUS"
3945                         " evt_code 0x%x \n"
3946                         "W0  0x%08x W1  0x%08x W2  0x%08x W3  0x%08x\n"
3947                         "W4  0x%08x W5  0x%08x W6  0x%08x W7  0x%08x\n"
3948                         "W8  0x%08x W9  0x%08x W10 0x%08x W11 0x%08x\n"
3949                         "W12 0x%08x W13 0x%08x W14 0x%08x W15 0x%08x\n",
3950                         pring->ringno,
3951                         icmd->un.asyncstat.evt_code,
3952                         iocb_w[0], iocb_w[1], iocb_w[2], iocb_w[3],
3953                         iocb_w[4], iocb_w[5], iocb_w[6], iocb_w[7],
3954                         iocb_w[8], iocb_w[9], iocb_w[10], iocb_w[11],
3955                         iocb_w[12], iocb_w[13], iocb_w[14], iocb_w[15]);
3956
3957                 return;
3958         }
3959         temp_event_data.data = (uint32_t)temp;
3960         temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
3961         if (evt_code == ASYNC_TEMP_WARN) {
3962                 temp_event_data.event_code = LPFC_THRESHOLD_TEMP;
3963                 lpfc_printf_log(phba,
3964                                 KERN_ERR,
3965                                 LOG_TEMP,
3966                                 "0347 Adapter is very hot, please take "
3967                                 "corrective action. temperature : %d Celsius\n",
3968                                 temp);
3969         }
3970         if (evt_code == ASYNC_TEMP_SAFE) {
3971                 temp_event_data.event_code = LPFC_NORMAL_TEMP;
3972                 lpfc_printf_log(phba,
3973                                 KERN_ERR,
3974                                 LOG_TEMP,
3975                                 "0340 Adapter temperature is OK now. "
3976                                 "temperature : %d Celsius\n",
3977                                 temp);
3978         }
3979
3980         /* Send temperature change event to applications */
3981         shost = lpfc_shost_from_vport(phba->pport);
3982         fc_host_post_vendor_event(shost, fc_get_event_number(),
3983                 sizeof(temp_event_data), (char *) &temp_event_data,
3984                 LPFC_NL_VENDOR_ID);
3985
3986 }
3987
3988
3989 /**
3990  * lpfc_sli_setup - SLI ring setup function
3991  * @phba: Pointer to HBA context object.
3992  *
3993  * lpfc_sli_setup sets up rings of the SLI interface with
3994  * number of iocbs per ring and iotags. This function is
3995  * called while driver attach to the HBA and before the
3996  * interrupts are enabled. So there is no need for locking.
3997  *
3998  * This function always returns 0.
3999  **/
4000 int
4001 lpfc_sli_setup(struct lpfc_hba *phba)
4002 {
4003         int i, totiocbsize = 0;
4004         struct lpfc_sli *psli = &phba->sli;
4005         struct lpfc_sli_ring *pring;
4006
4007         psli->num_rings = MAX_CONFIGURED_RINGS;
4008         psli->sli_flag = 0;
4009         psli->fcp_ring = LPFC_FCP_RING;
4010         psli->next_ring = LPFC_FCP_NEXT_RING;
4011         psli->extra_ring = LPFC_EXTRA_RING;
4012
4013         psli->iocbq_lookup = NULL;
4014         psli->iocbq_lookup_len = 0;
4015         psli->last_iotag = 0;
4016
4017         for (i = 0; i < psli->num_rings; i++) {
4018                 pring = &psli->ring[i];
4019                 switch (i) {
4020                 case LPFC_FCP_RING:     /* ring 0 - FCP */
4021                         /* numCiocb and numRiocb are used in config_port */
4022                         pring->numCiocb = SLI2_IOCB_CMD_R0_ENTRIES;
4023                         pring->numRiocb = SLI2_IOCB_RSP_R0_ENTRIES;
4024                         pring->numCiocb += SLI2_IOCB_CMD_R1XTRA_ENTRIES;
4025                         pring->numRiocb += SLI2_IOCB_RSP_R1XTRA_ENTRIES;
4026                         pring->numCiocb += SLI2_IOCB_CMD_R3XTRA_ENTRIES;
4027                         pring->numRiocb += SLI2_IOCB_RSP_R3XTRA_ENTRIES;
4028                         pring->sizeCiocb = (phba->sli_rev == 3) ?
4029                                                         SLI3_IOCB_CMD_SIZE :
4030                                                         SLI2_IOCB_CMD_SIZE;
4031                         pring->sizeRiocb = (phba->sli_rev == 3) ?
4032                                                         SLI3_IOCB_RSP_SIZE :
4033                                                         SLI2_IOCB_RSP_SIZE;
4034                         pring->iotag_ctr = 0;
4035                         pring->iotag_max =
4036                             (phba->cfg_hba_queue_depth * 2);
4037                         pring->fast_iotag = pring->iotag_max;
4038                         pring->num_mask = 0;
4039                         break;
4040                 case LPFC_EXTRA_RING:   /* ring 1 - EXTRA */
4041                         /* numCiocb and numRiocb are used in config_port */
4042                         pring->numCiocb = SLI2_IOCB_CMD_R1_ENTRIES;
4043                         pring->numRiocb = SLI2_IOCB_RSP_R1_ENTRIES;
4044                         pring->sizeCiocb = (phba->sli_rev == 3) ?
4045                                                         SLI3_IOCB_CMD_SIZE :
4046                                                         SLI2_IOCB_CMD_SIZE;
4047                         pring->sizeRiocb = (phba->sli_rev == 3) ?
4048                                                         SLI3_IOCB_RSP_SIZE :
4049                                                         SLI2_IOCB_RSP_SIZE;
4050                         pring->iotag_max = phba->cfg_hba_queue_depth;
4051                         pring->num_mask = 0;
4052                         break;
4053                 case LPFC_ELS_RING:     /* ring 2 - ELS / CT */
4054                         /* numCiocb and numRiocb are used in config_port */
4055                         pring->numCiocb = SLI2_IOCB_CMD_R2_ENTRIES;
4056                         pring->numRiocb = SLI2_IOCB_RSP_R2_ENTRIES;
4057                         pring->sizeCiocb = (phba->sli_rev == 3) ?
4058                                                         SLI3_IOCB_CMD_SIZE :
4059                                                         SLI2_IOCB_CMD_SIZE;
4060                         pring->sizeRiocb = (phba->sli_rev == 3) ?
4061                                                         SLI3_IOCB_RSP_SIZE :
4062                                                         SLI2_IOCB_RSP_SIZE;
4063                         pring->fast_iotag = 0;
4064                         pring->iotag_ctr = 0;
4065                         pring->iotag_max = 4096;
4066                         pring->lpfc_sli_rcv_async_status =
4067                                 lpfc_sli_async_event_handler;
4068                         pring->num_mask = 4;
4069                         pring->prt[0].profile = 0;      /* Mask 0 */
4070                         pring->prt[0].rctl = FC_ELS_REQ;
4071                         pring->prt[0].type = FC_ELS_DATA;
4072                         pring->prt[0].lpfc_sli_rcv_unsol_event =
4073                             lpfc_els_unsol_event;
4074                         pring->prt[1].profile = 0;      /* Mask 1 */
4075                         pring->prt[1].rctl = FC_ELS_RSP;
4076                         pring->prt[1].type = FC_ELS_DATA;
4077                         pring->prt[1].lpfc_sli_rcv_unsol_event =
4078                             lpfc_els_unsol_event;
4079                         pring->prt[2].profile = 0;      /* Mask 2 */
4080                         /* NameServer Inquiry */
4081                         pring->prt[2].rctl = FC_UNSOL_CTL;
4082                         /* NameServer */
4083                         pring->prt[2].type = FC_COMMON_TRANSPORT_ULP;
4084                         pring->prt[2].lpfc_sli_rcv_unsol_event =
4085                             lpfc_ct_unsol_event;
4086                         pring->prt[3].profile = 0;      /* Mask 3 */
4087                         /* NameServer response */
4088                         pring->prt[3].rctl = FC_SOL_CTL;
4089                         /* NameServer */
4090                         pring->prt[3].type = FC_COMMON_TRANSPORT_ULP;
4091                         pring->prt[3].lpfc_sli_rcv_unsol_event =
4092                             lpfc_ct_unsol_event;
4093                         break;
4094                 }
4095                 totiocbsize += (pring->numCiocb * pring->sizeCiocb) +
4096                                 (pring->numRiocb * pring->sizeRiocb);
4097         }
4098         if (totiocbsize > MAX_SLIM_IOCB_SIZE) {
4099                 /* Too many cmd / rsp ring entries in SLI2 SLIM */
4100                 printk(KERN_ERR "%d:0462 Too many cmd / rsp ring entries in "
4101                        "SLI2 SLIM Data: x%x x%lx\n",
4102                        phba->brd_no, totiocbsize,
4103                        (unsigned long) MAX_SLIM_IOCB_SIZE);
4104         }
4105         if (phba->cfg_multi_ring_support == 2)
4106                 lpfc_extra_ring_setup(phba);
4107
4108         return 0;
4109 }
4110
4111 /**
4112  * lpfc_sli_queue_setup - Queue initialization function
4113  * @phba: Pointer to HBA context object.
4114  *
4115  * lpfc_sli_queue_setup sets up mailbox queues and iocb queues for each
4116  * ring. This function also initializes ring indices of each ring.
4117  * This function is called during the initialization of the SLI
4118  * interface of an HBA.
4119  * This function is called with no lock held and always returns
4120  * 1.
4121  **/
4122 int
4123 lpfc_sli_queue_setup(struct lpfc_hba *phba)
4124 {
4125         struct lpfc_sli *psli;
4126         struct lpfc_sli_ring *pring;
4127         int i;
4128
4129         psli = &phba->sli;
4130         spin_lock_irq(&phba->hbalock);
4131         INIT_LIST_HEAD(&psli->mboxq);
4132         INIT_LIST_HEAD(&psli->mboxq_cmpl);
4133         /* Initialize list headers for txq and txcmplq as double linked lists */
4134         for (i = 0; i < psli->num_rings; i++) {
4135                 pring = &psli->ring[i];
4136                 pring->ringno = i;
4137                 pring->next_cmdidx  = 0;
4138                 pring->local_getidx = 0;
4139                 pring->cmdidx = 0;
4140                 INIT_LIST_HEAD(&pring->txq);
4141                 INIT_LIST_HEAD(&pring->txcmplq);
4142                 INIT_LIST_HEAD(&pring->iocb_continueq);
4143                 INIT_LIST_HEAD(&pring->iocb_continue_saveq);
4144                 INIT_LIST_HEAD(&pring->postbufq);
4145         }
4146         spin_unlock_irq(&phba->hbalock);
4147         return 1;
4148 }
4149
4150 /**
4151  * lpfc_sli_host_down - Vport cleanup function
4152  * @vport: Pointer to virtual port object.
4153  *
4154  * lpfc_sli_host_down is called to clean up the resources
4155  * associated with a vport before destroying virtual
4156  * port data structures.
4157  * This function does following operations:
4158  * - Free discovery resources associated with this virtual
4159  *   port.
4160  * - Free iocbs associated with this virtual port in
4161  *   the txq.
4162  * - Send abort for all iocb commands associated with this
4163  *   vport in txcmplq.
4164  *
4165  * This function is called with no lock held and always returns 1.
4166  **/
4167 int
4168 lpfc_sli_host_down(struct lpfc_vport *vport)
4169 {
4170         LIST_HEAD(completions);
4171         struct lpfc_hba *phba = vport->phba;
4172         struct lpfc_sli *psli = &phba->sli;
4173         struct lpfc_sli_ring *pring;
4174         struct lpfc_iocbq *iocb, *next_iocb;
4175         int i;
4176         unsigned long flags = 0;
4177         uint16_t prev_pring_flag;
4178
4179         lpfc_cleanup_discovery_resources(vport);
4180
4181         spin_lock_irqsave(&phba->hbalock, flags);
4182         for (i = 0; i < psli->num_rings; i++) {
4183                 pring = &psli->ring[i];
4184                 prev_pring_flag = pring->flag;
4185                 /* Only slow rings */
4186                 if (pring->ringno == LPFC_ELS_RING) {
4187                         pring->flag |= LPFC_DEFERRED_RING_EVENT;
4188                         /* Set the lpfc data pending flag */
4189                         set_bit(LPFC_DATA_READY, &phba->data_flags);
4190                 }
4191                 /*
4192                  * Error everything on the txq since these iocbs have not been
4193                  * given to the FW yet.
4194                  */
4195                 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
4196                         if (iocb->vport != vport)
4197                                 continue;
4198                         list_move_tail(&iocb->list, &completions);
4199                         pring->txq_cnt--;
4200                 }
4201
4202                 /* Next issue ABTS for everything on the txcmplq */
4203                 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq,
4204                                                                         list) {
4205                         if (iocb->vport != vport)
4206                                 continue;
4207                         lpfc_sli_issue_abort_iotag(phba, pring, iocb);
4208                 }
4209
4210                 pring->flag = prev_pring_flag;
4211         }
4212
4213         spin_unlock_irqrestore(&phba->hbalock, flags);
4214
4215         /* Cancel all the IOCBs from the completions list */
4216         lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
4217                               IOERR_SLI_DOWN);
4218         return 1;
4219 }
4220
4221 /**
4222  * lpfc_sli_hba_down - Resource cleanup function for the HBA
4223  * @phba: Pointer to HBA context object.
4224  *
4225  * This function cleans up all iocb, buffers, mailbox commands
4226  * while shutting down the HBA. This function is called with no
4227  * lock held and always returns 1.
4228  * This function does the following to cleanup driver resources:
4229  * - Free discovery resources for each virtual port
4230  * - Cleanup any pending fabric iocbs
4231  * - Iterate through the iocb txq and free each entry
4232  *   in the list.
4233  * - Free up any buffer posted to the HBA
4234  * - Free mailbox commands in the mailbox queue.
4235  **/
4236 int
4237 lpfc_sli_hba_down(struct lpfc_hba *phba)
4238 {
4239         LIST_HEAD(completions);
4240         struct lpfc_sli *psli = &phba->sli;
4241         struct lpfc_sli_ring *pring;
4242         struct lpfc_dmabuf *buf_ptr;
4243         LPFC_MBOXQ_t *pmb;
4244         int i;
4245         unsigned long flags = 0;
4246
4247         lpfc_hba_down_prep(phba);
4248
4249         lpfc_fabric_abort_hba(phba);
4250
4251         spin_lock_irqsave(&phba->hbalock, flags);
4252         for (i = 0; i < psli->num_rings; i++) {
4253                 pring = &psli->ring[i];
4254                 /* Only slow rings */
4255                 if (pring->ringno == LPFC_ELS_RING) {
4256                         pring->flag |= LPFC_DEFERRED_RING_EVENT;
4257                         /* Set the lpfc data pending flag */
4258                         set_bit(LPFC_DATA_READY, &phba->data_flags);
4259                 }
4260
4261                 /*
4262                  * Error everything on the txq since these iocbs have not been
4263                  * given to the FW yet.
4264                  */
4265                 list_splice_init(&pring->txq, &completions);
4266                 pring->txq_cnt = 0;
4267
4268         }
4269         spin_unlock_irqrestore(&phba->hbalock, flags);
4270
4271         /* Cancel all the IOCBs from the completions list */
4272         lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
4273                               IOERR_SLI_DOWN);
4274
4275         spin_lock_irqsave(&phba->hbalock, flags);
4276         list_splice_init(&phba->elsbuf, &completions);
4277         phba->elsbuf_cnt = 0;
4278         phba->elsbuf_prev_cnt = 0;
4279         spin_unlock_irqrestore(&phba->hbalock, flags);
4280
4281         while (!list_empty(&completions)) {
4282                 list_remove_head(&completions, buf_ptr,
4283                         struct lpfc_dmabuf, list);
4284                 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
4285                 kfree(buf_ptr);
4286         }
4287
4288         /* Return any active mbox cmds */
4289         del_timer_sync(&psli->mbox_tmo);
4290         spin_lock_irqsave(&phba->hbalock, flags);
4291
4292         spin_lock(&phba->pport->work_port_lock);
4293         phba->pport->work_port_events &= ~WORKER_MBOX_TMO;
4294         spin_unlock(&phba->pport->work_port_lock);
4295
4296         /* Return any pending or completed mbox cmds */
4297         list_splice_init(&phba->sli.mboxq, &completions);
4298         if (psli->mbox_active) {
4299                 list_add_tail(&psli->mbox_active->list, &completions);
4300                 psli->mbox_active = NULL;
4301                 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
4302         }
4303         list_splice_init(&phba->sli.mboxq_cmpl, &completions);
4304         spin_unlock_irqrestore(&phba->hbalock, flags);
4305
4306         while (!list_empty(&completions)) {
4307                 list_remove_head(&completions, pmb, LPFC_MBOXQ_t, list);
4308                 pmb->mb.mbxStatus = MBX_NOT_FINISHED;
4309                 if (pmb->mbox_cmpl)
4310                         pmb->mbox_cmpl(phba,pmb);
4311         }
4312         return 1;
4313 }
4314
4315 /**
4316  * lpfc_sli_pcimem_bcopy - SLI memory copy function
4317  * @srcp: Source memory pointer.
4318  * @destp: Destination memory pointer.
4319  * @cnt: Number of words required to be copied.
4320  *
4321  * This function is used for copying data between driver memory
4322  * and the SLI memory. This function also changes the endianness
4323  * of each word if native endianness is different from SLI
4324  * endianness. This function can be called with or without
4325  * lock.
4326  **/
4327 void
4328 lpfc_sli_pcimem_bcopy(void *srcp, void *destp, uint32_t cnt)
4329 {
4330         uint32_t *src = srcp;
4331         uint32_t *dest = destp;
4332         uint32_t ldata;
4333         int i;
4334
4335         for (i = 0; i < (int)cnt; i += sizeof (uint32_t)) {
4336                 ldata = *src;
4337                 ldata = le32_to_cpu(ldata);
4338                 *dest = ldata;
4339                 src++;
4340                 dest++;
4341         }
4342 }
4343
4344
4345 /**
4346  * lpfc_sli_ringpostbuf_put - Function to add a buffer to postbufq
4347  * @phba: Pointer to HBA context object.
4348  * @pring: Pointer to driver SLI ring object.
4349  * @mp: Pointer to driver buffer object.
4350  *
4351  * This function is called with no lock held.
4352  * It always return zero after adding the buffer to the postbufq
4353  * buffer list.
4354  **/
4355 int
4356 lpfc_sli_ringpostbuf_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4357                          struct lpfc_dmabuf *mp)
4358 {
4359         /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
4360            later */
4361         spin_lock_irq(&phba->hbalock);
4362         list_add_tail(&mp->list, &pring->postbufq);
4363         pring->postbufq_cnt++;
4364         spin_unlock_irq(&phba->hbalock);
4365         return 0;
4366 }
4367
4368 /**
4369  * lpfc_sli_get_buffer_tag - allocates a tag for a CMD_QUE_XRI64_CX buffer
4370  * @phba: Pointer to HBA context object.
4371  *
4372  * When HBQ is enabled, buffers are searched based on tags. This function
4373  * allocates a tag for buffer posted using CMD_QUE_XRI64_CX iocb. The
4374  * tag is bit wise or-ed with QUE_BUFTAG_BIT to make sure that the tag
4375  * does not conflict with tags of buffer posted for unsolicited events.
4376  * The function returns the allocated tag. The function is called with
4377  * no locks held.
4378  **/
4379 uint32_t
4380 lpfc_sli_get_buffer_tag(struct lpfc_hba *phba)
4381 {
4382         spin_lock_irq(&phba->hbalock);
4383         phba->buffer_tag_count++;
4384         /*
4385          * Always set the QUE_BUFTAG_BIT to distiguish between
4386          * a tag assigned by HBQ.
4387          */
4388         phba->buffer_tag_count |= QUE_BUFTAG_BIT;
4389         spin_unlock_irq(&phba->hbalock);
4390         return phba->buffer_tag_count;
4391 }
4392
4393 /**
4394  * lpfc_sli_ring_taggedbuf_get - find HBQ buffer associated with given tag
4395  * @phba: Pointer to HBA context object.
4396  * @pring: Pointer to driver SLI ring object.
4397  * @tag: Buffer tag.
4398  *
4399  * Buffers posted using CMD_QUE_XRI64_CX iocb are in pring->postbufq
4400  * list. After HBA DMA data to these buffers, CMD_IOCB_RET_XRI64_CX
4401  * iocb is posted to the response ring with the tag of the buffer.
4402  * This function searches the pring->postbufq list using the tag
4403  * to find buffer associated with CMD_IOCB_RET_XRI64_CX
4404  * iocb. If the buffer is found then lpfc_dmabuf object of the
4405  * buffer is returned to the caller else NULL is returned.
4406  * This function is called with no lock held.
4407  **/
4408 struct lpfc_dmabuf *
4409 lpfc_sli_ring_taggedbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4410                         uint32_t tag)
4411 {
4412         struct lpfc_dmabuf *mp, *next_mp;
4413         struct list_head *slp = &pring->postbufq;
4414
4415         /* Search postbufq, from the begining, looking for a match on tag */
4416         spin_lock_irq(&phba->hbalock);
4417         list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
4418                 if (mp->buffer_tag == tag) {
4419                         list_del_init(&mp->list);
4420                         pring->postbufq_cnt--;
4421                         spin_unlock_irq(&phba->hbalock);
4422                         return mp;
4423                 }
4424         }
4425
4426         spin_unlock_irq(&phba->hbalock);
4427         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4428                         "0402 Cannot find virtual addr for buffer tag on "
4429                         "ring %d Data x%lx x%p x%p x%x\n",
4430                         pring->ringno, (unsigned long) tag,
4431                         slp->next, slp->prev, pring->postbufq_cnt);
4432
4433         return NULL;
4434 }
4435
4436 /**
4437  * lpfc_sli_ringpostbuf_get - search buffers for unsolicited CT and ELS events
4438  * @phba: Pointer to HBA context object.
4439  * @pring: Pointer to driver SLI ring object.
4440  * @phys: DMA address of the buffer.
4441  *
4442  * This function searches the buffer list using the dma_address
4443  * of unsolicited event to find the driver's lpfc_dmabuf object
4444  * corresponding to the dma_address. The function returns the
4445  * lpfc_dmabuf object if a buffer is found else it returns NULL.
4446  * This function is called by the ct and els unsolicited event
4447  * handlers to get the buffer associated with the unsolicited
4448  * event.
4449  *
4450  * This function is called with no lock held.
4451  **/
4452 struct lpfc_dmabuf *
4453 lpfc_sli_ringpostbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4454                          dma_addr_t phys)
4455 {
4456         struct lpfc_dmabuf *mp, *next_mp;
4457         struct list_head *slp = &pring->postbufq;
4458
4459         /* Search postbufq, from the begining, looking for a match on phys */
4460         spin_lock_irq(&phba->hbalock);
4461         list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
4462                 if (mp->phys == phys) {
4463                         list_del_init(&mp->list);
4464                         pring->postbufq_cnt--;
4465                         spin_unlock_irq(&phba->hbalock);
4466                         return mp;
4467                 }
4468         }
4469
4470         spin_unlock_irq(&phba->hbalock);
4471         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4472                         "0410 Cannot find virtual addr for mapped buf on "
4473                         "ring %d Data x%llx x%p x%p x%x\n",
4474                         pring->ringno, (unsigned long long)phys,
4475                         slp->next, slp->prev, pring->postbufq_cnt);
4476         return NULL;
4477 }
4478
4479 /**
4480  * lpfc_sli_abort_els_cmpl - Completion handler for the els abort iocbs
4481  * @phba: Pointer to HBA context object.
4482  * @cmdiocb: Pointer to driver command iocb object.
4483  * @rspiocb: Pointer to driver response iocb object.
4484  *
4485  * This function is the completion handler for the abort iocbs for
4486  * ELS commands. This function is called from the ELS ring event
4487  * handler with no lock held. This function frees memory resources
4488  * associated with the abort iocb.
4489  **/
4490 static void
4491 lpfc_sli_abort_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4492                         struct lpfc_iocbq *rspiocb)
4493 {
4494         IOCB_t *irsp = &rspiocb->iocb;
4495         uint16_t abort_iotag, abort_context;
4496         struct lpfc_iocbq *abort_iocb;
4497         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4498
4499         abort_iocb = NULL;
4500
4501         if (irsp->ulpStatus) {
4502                 abort_context = cmdiocb->iocb.un.acxri.abortContextTag;
4503                 abort_iotag = cmdiocb->iocb.un.acxri.abortIoTag;
4504
4505                 spin_lock_irq(&phba->hbalock);
4506                 if (abort_iotag != 0 && abort_iotag <= phba->sli.last_iotag)
4507                         abort_iocb = phba->sli.iocbq_lookup[abort_iotag];
4508
4509                 lpfc_printf_log(phba, KERN_INFO, LOG_ELS | LOG_SLI,
4510                                 "0327 Cannot abort els iocb %p "
4511                                 "with tag %x context %x, abort status %x, "
4512                                 "abort code %x\n",
4513                                 abort_iocb, abort_iotag, abort_context,
4514                                 irsp->ulpStatus, irsp->un.ulpWord[4]);
4515
4516                 /*
4517                  *  If the iocb is not found in Firmware queue the iocb
4518                  *  might have completed already. Do not free it again.
4519                  */
4520                 if (irsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
4521                         spin_unlock_irq(&phba->hbalock);
4522                         lpfc_sli_release_iocbq(phba, cmdiocb);
4523                         return;
4524                 }
4525                 /*
4526                  * make sure we have the right iocbq before taking it
4527                  * off the txcmplq and try to call completion routine.
4528                  */
4529                 if (!abort_iocb ||
4530                     abort_iocb->iocb.ulpContext != abort_context ||
4531                     (abort_iocb->iocb_flag & LPFC_DRIVER_ABORTED) == 0)
4532                         spin_unlock_irq(&phba->hbalock);
4533                 else {
4534                         list_del_init(&abort_iocb->list);
4535                         pring->txcmplq_cnt--;
4536                         spin_unlock_irq(&phba->hbalock);
4537
4538                         /* Firmware could still be in progress of DMAing
4539                          * payload, so don't free data buffer till after
4540                          * a hbeat.
4541                          */
4542                         abort_iocb->iocb_flag |= LPFC_DELAY_MEM_FREE;
4543
4544                         abort_iocb->iocb_flag &= ~LPFC_DRIVER_ABORTED;
4545                         abort_iocb->iocb.ulpStatus = IOSTAT_LOCAL_REJECT;
4546                         abort_iocb->iocb.un.ulpWord[4] = IOERR_SLI_ABORTED;
4547                         (abort_iocb->iocb_cmpl)(phba, abort_iocb, abort_iocb);
4548                 }
4549         }
4550
4551         lpfc_sli_release_iocbq(phba, cmdiocb);
4552         return;
4553 }
4554
4555 /**
4556  * lpfc_ignore_els_cmpl - Completion handler for aborted ELS command
4557  * @phba: Pointer to HBA context object.
4558  * @cmdiocb: Pointer to driver command iocb object.
4559  * @rspiocb: Pointer to driver response iocb object.
4560  *
4561  * The function is called from SLI ring event handler with no
4562  * lock held. This function is the completion handler for ELS commands
4563  * which are aborted. The function frees memory resources used for
4564  * the aborted ELS commands.
4565  **/
4566 static void
4567 lpfc_ignore_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4568                      struct lpfc_iocbq *rspiocb)
4569 {
4570         IOCB_t *irsp = &rspiocb->iocb;
4571
4572         /* ELS cmd tag <ulpIoTag> completes */
4573         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
4574                         "0139 Ignoring ELS cmd tag x%x completion Data: "
4575                         "x%x x%x x%x\n",
4576                         irsp->ulpIoTag, irsp->ulpStatus,
4577                         irsp->un.ulpWord[4], irsp->ulpTimeout);
4578         if (cmdiocb->iocb.ulpCommand == CMD_GEN_REQUEST64_CR)
4579                 lpfc_ct_free_iocb(phba, cmdiocb);
4580         else
4581                 lpfc_els_free_iocb(phba, cmdiocb);
4582         return;
4583 }
4584
4585 /**
4586  * lpfc_sli_issue_abort_iotag - Abort function for a command iocb
4587  * @phba: Pointer to HBA context object.
4588  * @pring: Pointer to driver SLI ring object.
4589  * @cmdiocb: Pointer to driver command iocb object.
4590  *
4591  * This function issues an abort iocb for the provided command
4592  * iocb. This function is called with hbalock held.
4593  * The function returns 0 when it fails due to memory allocation
4594  * failure or when the command iocb is an abort request.
4595  **/
4596 int
4597 lpfc_sli_issue_abort_iotag(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4598                            struct lpfc_iocbq *cmdiocb)
4599 {
4600         struct lpfc_vport *vport = cmdiocb->vport;
4601         struct lpfc_iocbq *abtsiocbp;
4602         IOCB_t *icmd = NULL;
4603         IOCB_t *iabt = NULL;
4604         int retval = IOCB_ERROR;
4605
4606         /*
4607          * There are certain command types we don't want to abort.  And we
4608          * don't want to abort commands that are already in the process of
4609          * being aborted.
4610          */
4611         icmd = &cmdiocb->iocb;
4612         if (icmd->ulpCommand == CMD_ABORT_XRI_CN ||
4613             icmd->ulpCommand == CMD_CLOSE_XRI_CN ||
4614             (cmdiocb->iocb_flag & LPFC_DRIVER_ABORTED) != 0)
4615                 return 0;
4616
4617         /* If we're unloading, don't abort iocb on the ELS ring, but change the
4618          * callback so that nothing happens when it finishes.
4619          */
4620         if ((vport->load_flag & FC_UNLOADING) &&
4621             (pring->ringno == LPFC_ELS_RING)) {
4622                 if (cmdiocb->iocb_flag & LPFC_IO_FABRIC)
4623                         cmdiocb->fabric_iocb_cmpl = lpfc_ignore_els_cmpl;
4624                 else
4625                         cmdiocb->iocb_cmpl = lpfc_ignore_els_cmpl;
4626                 goto abort_iotag_exit;
4627         }
4628
4629         /* issue ABTS for this IOCB based on iotag */
4630         abtsiocbp = __lpfc_sli_get_iocbq(phba);
4631         if (abtsiocbp == NULL)
4632                 return 0;
4633
4634         /* This signals the response to set the correct status
4635          * before calling the completion handler.
4636          */
4637         cmdiocb->iocb_flag |= LPFC_DRIVER_ABORTED;
4638
4639         iabt = &abtsiocbp->iocb;
4640         iabt->un.acxri.abortType = ABORT_TYPE_ABTS;
4641         iabt->un.acxri.abortContextTag = icmd->ulpContext;
4642         iabt->un.acxri.abortIoTag = icmd->ulpIoTag;
4643         iabt->ulpLe = 1;
4644         iabt->ulpClass = icmd->ulpClass;
4645
4646         if (phba->link_state >= LPFC_LINK_UP)
4647                 iabt->ulpCommand = CMD_ABORT_XRI_CN;
4648         else
4649                 iabt->ulpCommand = CMD_CLOSE_XRI_CN;
4650
4651         abtsiocbp->iocb_cmpl = lpfc_sli_abort_els_cmpl;
4652
4653         lpfc_printf_vlog(vport, KERN_INFO, LOG_SLI,
4654                          "0339 Abort xri x%x, original iotag x%x, "
4655                          "abort cmd iotag x%x\n",
4656                          iabt->un.acxri.abortContextTag,
4657                          iabt->un.acxri.abortIoTag, abtsiocbp->iotag);
4658         retval = __lpfc_sli_issue_iocb(phba, pring, abtsiocbp, 0);
4659
4660         if (retval)
4661                 __lpfc_sli_release_iocbq(phba, abtsiocbp);
4662 abort_iotag_exit:
4663         /*
4664          * Caller to this routine should check for IOCB_ERROR
4665          * and handle it properly.  This routine no longer removes
4666          * iocb off txcmplq and call compl in case of IOCB_ERROR.
4667          */
4668         return retval;
4669 }
4670
4671 /**
4672  * lpfc_sli_validate_fcp_iocb - find commands associated with a vport or LUN
4673  * @iocbq: Pointer to driver iocb object.
4674  * @vport: Pointer to driver virtual port object.
4675  * @tgt_id: SCSI ID of the target.
4676  * @lun_id: LUN ID of the scsi device.
4677  * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST
4678  *
4679  * This function acts as an iocb filter for functions which abort or count
4680  * all FCP iocbs pending on a lun/SCSI target/SCSI host. It will return
4681  * 0 if the filtering criteria is met for the given iocb and will return
4682  * 1 if the filtering criteria is not met.
4683  * If ctx_cmd == LPFC_CTX_LUN, the function returns 0 only if the
4684  * given iocb is for the SCSI device specified by vport, tgt_id and
4685  * lun_id parameter.
4686  * If ctx_cmd == LPFC_CTX_TGT,  the function returns 0 only if the
4687  * given iocb is for the SCSI target specified by vport and tgt_id
4688  * parameters.
4689  * If ctx_cmd == LPFC_CTX_HOST, the function returns 0 only if the
4690  * given iocb is for the SCSI host associated with the given vport.
4691  * This function is called with no locks held.
4692  **/
4693 static int
4694 lpfc_sli_validate_fcp_iocb(struct lpfc_iocbq *iocbq, struct lpfc_vport *vport,
4695                            uint16_t tgt_id, uint64_t lun_id,
4696                            lpfc_ctx_cmd ctx_cmd)
4697 {
4698         struct lpfc_scsi_buf *lpfc_cmd;
4699         int rc = 1;
4700
4701         if (!(iocbq->iocb_flag &  LPFC_IO_FCP))
4702                 return rc;
4703
4704         if (iocbq->vport != vport)
4705                 return rc;
4706
4707         lpfc_cmd = container_of(iocbq, struct lpfc_scsi_buf, cur_iocbq);
4708
4709         if (lpfc_cmd->pCmd == NULL)
4710                 return rc;
4711
4712         switch (ctx_cmd) {
4713         case LPFC_CTX_LUN:
4714                 if ((lpfc_cmd->rdata->pnode) &&
4715                     (lpfc_cmd->rdata->pnode->nlp_sid == tgt_id) &&
4716                     (scsilun_to_int(&lpfc_cmd->fcp_cmnd->fcp_lun) == lun_id))
4717                         rc = 0;
4718                 break;
4719         case LPFC_CTX_TGT:
4720                 if ((lpfc_cmd->rdata->pnode) &&
4721                     (lpfc_cmd->rdata->pnode->nlp_sid == tgt_id))
4722                         rc = 0;
4723                 break;
4724         case LPFC_CTX_HOST:
4725                 rc = 0;
4726                 break;
4727         default:
4728                 printk(KERN_ERR "%s: Unknown context cmd type, value %d\n",
4729                         __func__, ctx_cmd);
4730                 break;
4731         }
4732
4733         return rc;
4734 }
4735
4736 /**
4737  * lpfc_sli_sum_iocb - Function to count the number of FCP iocbs pending
4738  * @vport: Pointer to virtual port.
4739  * @tgt_id: SCSI ID of the target.
4740  * @lun_id: LUN ID of the scsi device.
4741  * @ctx_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
4742  *
4743  * This function returns number of FCP commands pending for the vport.
4744  * When ctx_cmd == LPFC_CTX_LUN, the function returns number of FCP
4745  * commands pending on the vport associated with SCSI device specified
4746  * by tgt_id and lun_id parameters.
4747  * When ctx_cmd == LPFC_CTX_TGT, the function returns number of FCP
4748  * commands pending on the vport associated with SCSI target specified
4749  * by tgt_id parameter.
4750  * When ctx_cmd == LPFC_CTX_HOST, the function returns number of FCP
4751  * commands pending on the vport.
4752  * This function returns the number of iocbs which satisfy the filter.
4753  * This function is called without any lock held.
4754  **/
4755 int
4756 lpfc_sli_sum_iocb(struct lpfc_vport *vport, uint16_t tgt_id, uint64_t lun_id,
4757                   lpfc_ctx_cmd ctx_cmd)
4758 {
4759         struct lpfc_hba *phba = vport->phba;
4760         struct lpfc_iocbq *iocbq;
4761         int sum, i;
4762
4763         for (i = 1, sum = 0; i <= phba->sli.last_iotag; i++) {
4764                 iocbq = phba->sli.iocbq_lookup[i];
4765
4766                 if (lpfc_sli_validate_fcp_iocb (iocbq, vport, tgt_id, lun_id,
4767                                                 ctx_cmd) == 0)
4768                         sum++;
4769         }
4770
4771         return sum;
4772 }
4773
4774 /**
4775  * lpfc_sli_abort_fcp_cmpl - Completion handler function for aborted FCP IOCBs
4776  * @phba: Pointer to HBA context object
4777  * @cmdiocb: Pointer to command iocb object.
4778  * @rspiocb: Pointer to response iocb object.
4779  *
4780  * This function is called when an aborted FCP iocb completes. This
4781  * function is called by the ring event handler with no lock held.
4782  * This function frees the iocb.
4783  **/
4784 void
4785 lpfc_sli_abort_fcp_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4786                         struct lpfc_iocbq *rspiocb)
4787 {
4788         lpfc_sli_release_iocbq(phba, cmdiocb);
4789         return;
4790 }
4791
4792 /**
4793  * lpfc_sli_abort_iocb - issue abort for all commands on a host/target/LUN
4794  * @vport: Pointer to virtual port.
4795  * @pring: Pointer to driver SLI ring object.
4796  * @tgt_id: SCSI ID of the target.
4797  * @lun_id: LUN ID of the scsi device.
4798  * @abort_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
4799  *
4800  * This function sends an abort command for every SCSI command
4801  * associated with the given virtual port pending on the ring
4802  * filtered by lpfc_sli_validate_fcp_iocb function.
4803  * When abort_cmd == LPFC_CTX_LUN, the function sends abort only to the
4804  * FCP iocbs associated with lun specified by tgt_id and lun_id
4805  * parameters
4806  * When abort_cmd == LPFC_CTX_TGT, the function sends abort only to the
4807  * FCP iocbs associated with SCSI target specified by tgt_id parameter.
4808  * When abort_cmd == LPFC_CTX_HOST, the function sends abort to all
4809  * FCP iocbs associated with virtual port.
4810  * This function returns number of iocbs it failed to abort.
4811  * This function is called with no locks held.
4812  **/
4813 int
4814 lpfc_sli_abort_iocb(struct lpfc_vport *vport, struct lpfc_sli_ring *pring,
4815                     uint16_t tgt_id, uint64_t lun_id, lpfc_ctx_cmd abort_cmd)
4816 {
4817         struct lpfc_hba *phba = vport->phba;
4818         struct lpfc_iocbq *iocbq;
4819         struct lpfc_iocbq *abtsiocb;
4820         IOCB_t *cmd = NULL;
4821         int errcnt = 0, ret_val = 0;
4822         int i;
4823
4824         for (i = 1; i <= phba->sli.last_iotag; i++) {
4825                 iocbq = phba->sli.iocbq_lookup[i];
4826
4827                 if (lpfc_sli_validate_fcp_iocb(iocbq, vport, tgt_id, lun_id,
4828                                                abort_cmd) != 0)
4829                         continue;
4830
4831                 /* issue ABTS for this IOCB based on iotag */
4832                 abtsiocb = lpfc_sli_get_iocbq(phba);
4833                 if (abtsiocb == NULL) {
4834                         errcnt++;
4835                         continue;
4836                 }
4837
4838                 cmd = &iocbq->iocb;
4839                 abtsiocb->iocb.un.acxri.abortType = ABORT_TYPE_ABTS;
4840                 abtsiocb->iocb.un.acxri.abortContextTag = cmd->ulpContext;
4841                 abtsiocb->iocb.un.acxri.abortIoTag = cmd->ulpIoTag;
4842                 abtsiocb->iocb.ulpLe = 1;
4843                 abtsiocb->iocb.ulpClass = cmd->ulpClass;
4844                 abtsiocb->vport = phba->pport;
4845
4846                 if (lpfc_is_link_up(phba))
4847                         abtsiocb->iocb.ulpCommand = CMD_ABORT_XRI_CN;
4848                 else
4849                         abtsiocb->iocb.ulpCommand = CMD_CLOSE_XRI_CN;
4850
4851                 /* Setup callback routine and issue the command. */
4852                 abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
4853                 ret_val = lpfc_sli_issue_iocb(phba, pring, abtsiocb, 0);
4854                 if (ret_val == IOCB_ERROR) {
4855                         lpfc_sli_release_iocbq(phba, abtsiocb);
4856                         errcnt++;
4857                         continue;
4858                 }
4859         }
4860
4861         return errcnt;
4862 }
4863
4864 /**
4865  * lpfc_sli_wake_iocb_wait - lpfc_sli_issue_iocb_wait's completion handler
4866  * @phba: Pointer to HBA context object.
4867  * @cmdiocbq: Pointer to command iocb.
4868  * @rspiocbq: Pointer to response iocb.
4869  *
4870  * This function is the completion handler for iocbs issued using
4871  * lpfc_sli_issue_iocb_wait function. This function is called by the
4872  * ring event handler function without any lock held. This function
4873  * can be called from both worker thread context and interrupt
4874  * context. This function also can be called from other thread which
4875  * cleans up the SLI layer objects.
4876  * This function copy the contents of the response iocb to the
4877  * response iocb memory object provided by the caller of
4878  * lpfc_sli_issue_iocb_wait and then wakes up the thread which
4879  * sleeps for the iocb completion.
4880  **/
4881 static void
4882 lpfc_sli_wake_iocb_wait(struct lpfc_hba *phba,
4883                         struct lpfc_iocbq *cmdiocbq,
4884                         struct lpfc_iocbq *rspiocbq)
4885 {
4886         wait_queue_head_t *pdone_q;
4887         unsigned long iflags;
4888
4889         spin_lock_irqsave(&phba->hbalock, iflags);
4890         cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
4891         if (cmdiocbq->context2 && rspiocbq)
4892                 memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
4893                        &rspiocbq->iocb, sizeof(IOCB_t));
4894
4895         pdone_q = cmdiocbq->context_un.wait_queue;
4896         if (pdone_q)
4897                 wake_up(pdone_q);
4898         spin_unlock_irqrestore(&phba->hbalock, iflags);
4899         return;
4900 }
4901
4902 /**
4903  * lpfc_sli_issue_iocb_wait - Synchronous function to issue iocb commands
4904  * @phba: Pointer to HBA context object..
4905  * @pring: Pointer to sli ring.
4906  * @piocb: Pointer to command iocb.
4907  * @prspiocbq: Pointer to response iocb.
4908  * @timeout: Timeout in number of seconds.
4909  *
4910  * This function issues the iocb to firmware and waits for the
4911  * iocb to complete. If the iocb command is not
4912  * completed within timeout seconds, it returns IOCB_TIMEDOUT.
4913  * Caller should not free the iocb resources if this function
4914  * returns IOCB_TIMEDOUT.
4915  * The function waits for the iocb completion using an
4916  * non-interruptible wait.
4917  * This function will sleep while waiting for iocb completion.
4918  * So, this function should not be called from any context which
4919  * does not allow sleeping. Due to the same reason, this function
4920  * cannot be called with interrupt disabled.
4921  * This function assumes that the iocb completions occur while
4922  * this function sleep. So, this function cannot be called from
4923  * the thread which process iocb completion for this ring.
4924  * This function clears the iocb_flag of the iocb object before
4925  * issuing the iocb and the iocb completion handler sets this
4926  * flag and wakes this thread when the iocb completes.
4927  * The contents of the response iocb will be copied to prspiocbq
4928  * by the completion handler when the command completes.
4929  * This function returns IOCB_SUCCESS when success.
4930  * This function is called with no lock held.
4931  **/
4932 int
4933 lpfc_sli_issue_iocb_wait(struct lpfc_hba *phba,
4934                          struct lpfc_sli_ring *pring,
4935                          struct lpfc_iocbq *piocb,
4936                          struct lpfc_iocbq *prspiocbq,
4937                          uint32_t timeout)
4938 {
4939         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q);
4940         long timeleft, timeout_req = 0;
4941         int retval = IOCB_SUCCESS;
4942         uint32_t creg_val;
4943
4944         /*
4945          * If the caller has provided a response iocbq buffer, then context2
4946          * is NULL or its an error.
4947          */
4948         if (prspiocbq) {
4949                 if (piocb->context2)
4950                         return IOCB_ERROR;
4951                 piocb->context2 = prspiocbq;
4952         }
4953
4954         piocb->iocb_cmpl = lpfc_sli_wake_iocb_wait;
4955         piocb->context_un.wait_queue = &done_q;
4956         piocb->iocb_flag &= ~LPFC_IO_WAKE;
4957
4958         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
4959                 creg_val = readl(phba->HCregaddr);
4960                 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
4961                 writel(creg_val, phba->HCregaddr);
4962                 readl(phba->HCregaddr); /* flush */
4963         }
4964
4965         retval = lpfc_sli_issue_iocb(phba, pring, piocb, 0);
4966         if (retval == IOCB_SUCCESS) {
4967                 timeout_req = timeout * HZ;
4968                 timeleft = wait_event_timeout(done_q,
4969                                 piocb->iocb_flag & LPFC_IO_WAKE,
4970                                 timeout_req);
4971
4972                 if (piocb->iocb_flag & LPFC_IO_WAKE) {
4973                         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4974                                         "0331 IOCB wake signaled\n");
4975                 } else if (timeleft == 0) {
4976                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4977                                         "0338 IOCB wait timeout error - no "
4978                                         "wake response Data x%x\n", timeout);
4979                         retval = IOCB_TIMEDOUT;
4980                 } else {
4981                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4982                                         "0330 IOCB wake NOT set, "
4983                                         "Data x%x x%lx\n",
4984                                         timeout, (timeleft / jiffies));
4985                         retval = IOCB_TIMEDOUT;
4986                 }
4987         } else {
4988                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4989                                 "0332 IOCB wait issue failed, Data x%x\n",
4990                                 retval);
4991                 retval = IOCB_ERROR;
4992         }
4993
4994         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
4995                 creg_val = readl(phba->HCregaddr);
4996                 creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
4997                 writel(creg_val, phba->HCregaddr);
4998                 readl(phba->HCregaddr); /* flush */
4999         }
5000
5001         if (prspiocbq)
5002                 piocb->context2 = NULL;
5003
5004         piocb->context_un.wait_queue = NULL;
5005         piocb->iocb_cmpl = NULL;
5006         return retval;
5007 }
5008
5009 /**
5010  * lpfc_sli_issue_mbox_wait - Synchronous function to issue mailbox
5011  * @phba: Pointer to HBA context object.
5012  * @pmboxq: Pointer to driver mailbox object.
5013  * @timeout: Timeout in number of seconds.
5014  *
5015  * This function issues the mailbox to firmware and waits for the
5016  * mailbox command to complete. If the mailbox command is not
5017  * completed within timeout seconds, it returns MBX_TIMEOUT.
5018  * The function waits for the mailbox completion using an
5019  * interruptible wait. If the thread is woken up due to a
5020  * signal, MBX_TIMEOUT error is returned to the caller. Caller
5021  * should not free the mailbox resources, if this function returns
5022  * MBX_TIMEOUT.
5023  * This function will sleep while waiting for mailbox completion.
5024  * So, this function should not be called from any context which
5025  * does not allow sleeping. Due to the same reason, this function
5026  * cannot be called with interrupt disabled.
5027  * This function assumes that the mailbox completion occurs while
5028  * this function sleep. So, this function cannot be called from
5029  * the worker thread which processes mailbox completion.
5030  * This function is called in the context of HBA management
5031  * applications.
5032  * This function returns MBX_SUCCESS when successful.
5033  * This function is called with no lock held.
5034  **/
5035 int
5036 lpfc_sli_issue_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq,
5037                          uint32_t timeout)
5038 {
5039         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q);
5040         int retval;
5041         unsigned long flag;
5042
5043         /* The caller must leave context1 empty. */
5044         if (pmboxq->context1)
5045                 return MBX_NOT_FINISHED;
5046
5047         pmboxq->mbox_flag &= ~LPFC_MBX_WAKE;
5048         /* setup wake call as IOCB callback */
5049         pmboxq->mbox_cmpl = lpfc_sli_wake_mbox_wait;
5050         /* setup context field to pass wait_queue pointer to wake function  */
5051         pmboxq->context1 = &done_q;
5052
5053         /* now issue the command */
5054         retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
5055
5056         if (retval == MBX_BUSY || retval == MBX_SUCCESS) {
5057                 wait_event_interruptible_timeout(done_q,
5058                                 pmboxq->mbox_flag & LPFC_MBX_WAKE,
5059                                 timeout * HZ);
5060
5061                 spin_lock_irqsave(&phba->hbalock, flag);
5062                 pmboxq->context1 = NULL;
5063                 /*
5064                  * if LPFC_MBX_WAKE flag is set the mailbox is completed
5065                  * else do not free the resources.
5066                  */
5067                 if (pmboxq->mbox_flag & LPFC_MBX_WAKE)
5068                         retval = MBX_SUCCESS;
5069                 else {
5070                         retval = MBX_TIMEOUT;
5071                         pmboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
5072                 }
5073                 spin_unlock_irqrestore(&phba->hbalock, flag);
5074         }
5075
5076         return retval;
5077 }
5078
5079 /**
5080  * lpfc_sli_flush_mbox_queue - mailbox queue cleanup function
5081  * @phba: Pointer to HBA context.
5082  *
5083  * This function is called to cleanup any pending mailbox
5084  * objects in the driver queue before bringing the HBA offline.
5085  * This function is called while resetting the HBA.
5086  * The function is called without any lock held. The function
5087  * takes hbalock to update SLI data structure.
5088  * This function returns 1 when there is an active mailbox
5089  * command pending else returns 0.
5090  **/
5091 int
5092 lpfc_sli_flush_mbox_queue(struct lpfc_hba * phba)
5093 {
5094         struct lpfc_vport *vport = phba->pport;
5095         int i = 0;
5096         uint32_t ha_copy;
5097
5098         while (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE && !vport->stopped) {
5099                 if (i++ > LPFC_MBOX_TMO * 1000)
5100                         return 1;
5101
5102                 /*
5103                  * Call lpfc_sli_handle_mb_event only if a mailbox cmd
5104                  * did finish. This way we won't get the misleading
5105                  * "Stray Mailbox Interrupt" message.
5106                  */
5107                 spin_lock_irq(&phba->hbalock);
5108                 ha_copy = phba->work_ha;
5109                 phba->work_ha &= ~HA_MBATT;
5110                 spin_unlock_irq(&phba->hbalock);
5111
5112                 if (ha_copy & HA_MBATT)
5113                         if (lpfc_sli_handle_mb_event(phba) == 0)
5114                                 i = 0;
5115
5116                 msleep(1);
5117         }
5118
5119         return (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) ? 1 : 0;
5120 }
5121
5122 /**
5123  * lpfc_sli_check_eratt - check error attention events
5124  * @phba: Pointer to HBA context.
5125  *
5126  * This function is called form timer soft interrupt context to check HBA's
5127  * error attention register bit for error attention events.
5128  *
5129  * This fucntion returns 1 when there is Error Attention in the Host Attention
5130  * Register and returns 0 otherwise.
5131  **/
5132 int
5133 lpfc_sli_check_eratt(struct lpfc_hba *phba)
5134 {
5135         uint32_t ha_copy;
5136
5137         /* If PCI channel is offline, don't process it */
5138         if (unlikely(pci_channel_offline(phba->pcidev)))
5139                 return 0;
5140
5141         /* If somebody is waiting to handle an eratt, don't process it
5142          * here. The brdkill function will do this.
5143          */
5144         if (phba->link_flag & LS_IGNORE_ERATT)
5145                 return 0;
5146
5147         /* Check if interrupt handler handles this ERATT */
5148         spin_lock_irq(&phba->hbalock);
5149         if (phba->hba_flag & HBA_ERATT_HANDLED) {
5150                 /* Interrupt handler has handled ERATT */
5151                 spin_unlock_irq(&phba->hbalock);
5152                 return 0;
5153         }
5154
5155         /*
5156          * If there is deferred error attention, do not check for error
5157          * attention
5158          */
5159         if (unlikely(phba->hba_flag & DEFER_ERATT)) {
5160                 spin_unlock_irq(&phba->hbalock);
5161                 return 0;
5162         }
5163
5164         /* Read chip Host Attention (HA) register */
5165         ha_copy = readl(phba->HAregaddr);
5166         if (ha_copy & HA_ERATT) {
5167                 /* Read host status register to retrieve error event */
5168                 lpfc_sli_read_hs(phba);
5169
5170                 /* Check if there is a deferred error condition is active */
5171                 if ((HS_FFER1 & phba->work_hs) &&
5172                         ((HS_FFER2 | HS_FFER3 | HS_FFER4 | HS_FFER5 |
5173                         HS_FFER6 | HS_FFER7) & phba->work_hs)) {
5174                         phba->hba_flag |= DEFER_ERATT;
5175                         /* Clear all interrupt enable conditions */
5176                         writel(0, phba->HCregaddr);
5177                         readl(phba->HCregaddr);
5178                 }
5179
5180                 /* Set the driver HA work bitmap */
5181                 phba->work_ha |= HA_ERATT;
5182                 /* Indicate polling handles this ERATT */
5183                 phba->hba_flag |= HBA_ERATT_HANDLED;
5184                 spin_unlock_irq(&phba->hbalock);
5185                 return 1;
5186         }
5187         spin_unlock_irq(&phba->hbalock);
5188         return 0;
5189 }
5190
5191 /**
5192  * lpfc_sp_intr_handler - The slow-path interrupt handler of lpfc driver
5193  * @irq: Interrupt number.
5194  * @dev_id: The device context pointer.
5195  *
5196  * This function is directly called from the PCI layer as an interrupt
5197  * service routine when the device is enabled with MSI-X multi-message
5198  * interrupt mode and there are slow-path events in the HBA. However,
5199  * when the device is enabled with either MSI or Pin-IRQ interrupt mode,
5200  * this function is called as part of the device-level interrupt handler.
5201  * When the PCI slot is in error recovery or the HBA is undergoing
5202  * initialization, the interrupt handler will not process the interrupt.
5203  * The link attention and ELS ring attention events are handled by the
5204  * worker thread. The interrupt handler signals the worker thread and
5205  * and returns for these events. This function is called without any
5206  * lock held. It gets the hbalock to access and update SLI data
5207  * structures.
5208  *
5209  * This function returns IRQ_HANDLED when interrupt is handled else it
5210  * returns IRQ_NONE.
5211  **/
5212 irqreturn_t
5213 lpfc_sp_intr_handler(int irq, void *dev_id)
5214 {
5215         struct lpfc_hba  *phba;
5216         uint32_t ha_copy;
5217         uint32_t work_ha_copy;
5218         unsigned long status;
5219         unsigned long iflag;
5220         uint32_t control;
5221
5222         MAILBOX_t *mbox, *pmbox;
5223         struct lpfc_vport *vport;
5224         struct lpfc_nodelist *ndlp;
5225         struct lpfc_dmabuf *mp;
5226         LPFC_MBOXQ_t *pmb;
5227         int rc;
5228
5229         /*
5230          * Get the driver's phba structure from the dev_id and
5231          * assume the HBA is not interrupting.
5232          */
5233         phba = (struct lpfc_hba *)dev_id;
5234
5235         if (unlikely(!phba))
5236                 return IRQ_NONE;
5237
5238         /*
5239          * Stuff needs to be attented to when this function is invoked as an
5240          * individual interrupt handler in MSI-X multi-message interrupt mode
5241          */
5242         if (phba->intr_type == MSIX) {
5243                 /* If the pci channel is offline, ignore all the interrupts */
5244                 if (unlikely(pci_channel_offline(phba->pcidev)))
5245                         return IRQ_NONE;
5246                 /* Update device-level interrupt statistics */
5247                 phba->sli.slistat.sli_intr++;
5248                 /* Ignore all interrupts during initialization. */
5249                 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5250                         return IRQ_NONE;
5251                 /* Need to read HA REG for slow-path events */
5252                 spin_lock_irqsave(&phba->hbalock, iflag);
5253                 ha_copy = readl(phba->HAregaddr);
5254                 /* If somebody is waiting to handle an eratt don't process it
5255                  * here. The brdkill function will do this.
5256                  */
5257                 if (phba->link_flag & LS_IGNORE_ERATT)
5258                         ha_copy &= ~HA_ERATT;
5259                 /* Check the need for handling ERATT in interrupt handler */
5260                 if (ha_copy & HA_ERATT) {
5261                         if (phba->hba_flag & HBA_ERATT_HANDLED)
5262                                 /* ERATT polling has handled ERATT */
5263                                 ha_copy &= ~HA_ERATT;
5264                         else
5265                                 /* Indicate interrupt handler handles ERATT */
5266                                 phba->hba_flag |= HBA_ERATT_HANDLED;
5267                 }
5268
5269                 /*
5270                  * If there is deferred error attention, do not check for any
5271                  * interrupt.
5272                  */
5273                 if (unlikely(phba->hba_flag & DEFER_ERATT)) {
5274                         spin_unlock_irq(&phba->hbalock);
5275                         return IRQ_NONE;
5276                 }
5277
5278                 /* Clear up only attention source related to slow-path */
5279                 writel((ha_copy & (HA_MBATT | HA_R2_CLR_MSK)),
5280                         phba->HAregaddr);
5281                 readl(phba->HAregaddr); /* flush */
5282                 spin_unlock_irqrestore(&phba->hbalock, iflag);
5283         } else
5284                 ha_copy = phba->ha_copy;
5285
5286         work_ha_copy = ha_copy & phba->work_ha_mask;
5287
5288         if (work_ha_copy) {
5289                 if (work_ha_copy & HA_LATT) {
5290                         if (phba->sli.sli_flag & LPFC_PROCESS_LA) {
5291                                 /*
5292                                  * Turn off Link Attention interrupts
5293                                  * until CLEAR_LA done
5294                                  */
5295                                 spin_lock_irqsave(&phba->hbalock, iflag);
5296                                 phba->sli.sli_flag &= ~LPFC_PROCESS_LA;
5297                                 control = readl(phba->HCregaddr);
5298                                 control &= ~HC_LAINT_ENA;
5299                                 writel(control, phba->HCregaddr);
5300                                 readl(phba->HCregaddr); /* flush */
5301                                 spin_unlock_irqrestore(&phba->hbalock, iflag);
5302                         }
5303                         else
5304                                 work_ha_copy &= ~HA_LATT;
5305                 }
5306
5307                 if (work_ha_copy & ~(HA_ERATT | HA_MBATT | HA_LATT)) {
5308                         /*
5309                          * Turn off Slow Rings interrupts, LPFC_ELS_RING is
5310                          * the only slow ring.
5311                          */
5312                         status = (work_ha_copy &
5313                                 (HA_RXMASK  << (4*LPFC_ELS_RING)));
5314                         status >>= (4*LPFC_ELS_RING);
5315                         if (status & HA_RXMASK) {
5316                                 spin_lock_irqsave(&phba->hbalock, iflag);
5317                                 control = readl(phba->HCregaddr);
5318
5319                                 lpfc_debugfs_slow_ring_trc(phba,
5320                                 "ISR slow ring:   ctl:x%x stat:x%x isrcnt:x%x",
5321                                 control, status,
5322                                 (uint32_t)phba->sli.slistat.sli_intr);
5323
5324                                 if (control & (HC_R0INT_ENA << LPFC_ELS_RING)) {
5325                                         lpfc_debugfs_slow_ring_trc(phba,
5326                                                 "ISR Disable ring:"
5327                                                 "pwork:x%x hawork:x%x wait:x%x",
5328                                                 phba->work_ha, work_ha_copy,
5329                                                 (uint32_t)((unsigned long)
5330                                                 &phba->work_waitq));
5331
5332                                         control &=
5333                                             ~(HC_R0INT_ENA << LPFC_ELS_RING);
5334                                         writel(control, phba->HCregaddr);
5335                                         readl(phba->HCregaddr); /* flush */
5336                                 }
5337                                 else {
5338                                         lpfc_debugfs_slow_ring_trc(phba,
5339                                                 "ISR slow ring:   pwork:"
5340                                                 "x%x hawork:x%x wait:x%x",
5341                                                 phba->work_ha, work_ha_copy,
5342                                                 (uint32_t)((unsigned long)
5343                                                 &phba->work_waitq));
5344                                 }
5345                                 spin_unlock_irqrestore(&phba->hbalock, iflag);
5346                         }
5347                 }
5348                 spin_lock_irqsave(&phba->hbalock, iflag);
5349                 if (work_ha_copy & HA_ERATT) {
5350                         lpfc_sli_read_hs(phba);
5351                         /*
5352                          * Check if there is a deferred error condition
5353                          * is active
5354                          */
5355                         if ((HS_FFER1 & phba->work_hs) &&
5356                                 ((HS_FFER2 | HS_FFER3 | HS_FFER4 | HS_FFER5 |
5357                                 HS_FFER6 | HS_FFER7) & phba->work_hs)) {
5358                                 phba->hba_flag |= DEFER_ERATT;
5359                                 /* Clear all interrupt enable conditions */
5360                                 writel(0, phba->HCregaddr);
5361                                 readl(phba->HCregaddr);
5362                         }
5363                 }
5364
5365                 if ((work_ha_copy & HA_MBATT) && (phba->sli.mbox_active)) {
5366                         pmb = phba->sli.mbox_active;
5367                         pmbox = &pmb->mb;
5368                         mbox = phba->mbox;
5369                         vport = pmb->vport;
5370
5371                         /* First check out the status word */
5372                         lpfc_sli_pcimem_bcopy(mbox, pmbox, sizeof(uint32_t));
5373                         if (pmbox->mbxOwner != OWN_HOST) {
5374                                 spin_unlock_irqrestore(&phba->hbalock, iflag);
5375                                 /*
5376                                  * Stray Mailbox Interrupt, mbxCommand <cmd>
5377                                  * mbxStatus <status>
5378                                  */
5379                                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
5380                                                 LOG_SLI,
5381                                                 "(%d):0304 Stray Mailbox "
5382                                                 "Interrupt mbxCommand x%x "
5383                                                 "mbxStatus x%x\n",
5384                                                 (vport ? vport->vpi : 0),
5385                                                 pmbox->mbxCommand,
5386                                                 pmbox->mbxStatus);
5387                                 /* clear mailbox attention bit */
5388                                 work_ha_copy &= ~HA_MBATT;
5389                         } else {
5390                                 phba->sli.mbox_active = NULL;
5391                                 spin_unlock_irqrestore(&phba->hbalock, iflag);
5392                                 phba->last_completion_time = jiffies;
5393                                 del_timer(&phba->sli.mbox_tmo);
5394                                 if (pmb->mbox_cmpl) {
5395                                         lpfc_sli_pcimem_bcopy(mbox, pmbox,
5396                                                         MAILBOX_CMD_SIZE);
5397                                 }
5398                                 if (pmb->mbox_flag & LPFC_MBX_IMED_UNREG) {
5399                                         pmb->mbox_flag &= ~LPFC_MBX_IMED_UNREG;
5400
5401                                         lpfc_debugfs_disc_trc(vport,
5402                                                 LPFC_DISC_TRC_MBOX_VPORT,
5403                                                 "MBOX dflt rpi: : "
5404                                                 "status:x%x rpi:x%x",
5405                                                 (uint32_t)pmbox->mbxStatus,
5406                                                 pmbox->un.varWords[0], 0);
5407
5408                                         if (!pmbox->mbxStatus) {
5409                                                 mp = (struct lpfc_dmabuf *)
5410                                                         (pmb->context1);
5411                                                 ndlp = (struct lpfc_nodelist *)
5412                                                         pmb->context2;
5413
5414                                                 /* Reg_LOGIN of dflt RPI was
5415                                                  * successful. new lets get
5416                                                  * rid of the RPI using the
5417                                                  * same mbox buffer.
5418                                                  */
5419                                                 lpfc_unreg_login(phba,
5420                                                         vport->vpi,
5421                                                         pmbox->un.varWords[0],
5422                                                         pmb);
5423                                                 pmb->mbox_cmpl =
5424                                                         lpfc_mbx_cmpl_dflt_rpi;
5425                                                 pmb->context1 = mp;
5426                                                 pmb->context2 = ndlp;
5427                                                 pmb->vport = vport;
5428                                                 rc = lpfc_sli_issue_mbox(phba,
5429                                                                 pmb,
5430                                                                 MBX_NOWAIT);
5431                                                 if (rc != MBX_BUSY)
5432                                                         lpfc_printf_log(phba,
5433                                                         KERN_ERR,
5434                                                         LOG_MBOX | LOG_SLI,
5435                                                         "0350 rc should have"
5436                                                         "been MBX_BUSY");
5437                                                 goto send_current_mbox;
5438                                         }
5439                                 }
5440                                 spin_lock_irqsave(
5441                                                 &phba->pport->work_port_lock,
5442                                                 iflag);
5443                                 phba->pport->work_port_events &=
5444                                         ~WORKER_MBOX_TMO;
5445                                 spin_unlock_irqrestore(
5446                                                 &phba->pport->work_port_lock,
5447                                                 iflag);
5448                                 lpfc_mbox_cmpl_put(phba, pmb);
5449                         }
5450                 } else
5451                         spin_unlock_irqrestore(&phba->hbalock, iflag);
5452
5453                 if ((work_ha_copy & HA_MBATT) &&
5454                     (phba->sli.mbox_active == NULL)) {
5455 send_current_mbox:
5456                         /* Process next mailbox command if there is one */
5457                         do {
5458                                 rc = lpfc_sli_issue_mbox(phba, NULL,
5459                                                          MBX_NOWAIT);
5460                         } while (rc == MBX_NOT_FINISHED);
5461                         if (rc != MBX_SUCCESS)
5462                                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
5463                                                 LOG_SLI, "0349 rc should be "
5464                                                 "MBX_SUCCESS");
5465                 }
5466
5467                 spin_lock_irqsave(&phba->hbalock, iflag);
5468                 phba->work_ha |= work_ha_copy;
5469                 spin_unlock_irqrestore(&phba->hbalock, iflag);
5470                 lpfc_worker_wake_up(phba);
5471         }
5472         return IRQ_HANDLED;
5473
5474 } /* lpfc_sp_intr_handler */
5475
5476 /**
5477  * lpfc_fp_intr_handler - The fast-path interrupt handler of lpfc driver
5478  * @irq: Interrupt number.
5479  * @dev_id: The device context pointer.
5480  *
5481  * This function is directly called from the PCI layer as an interrupt
5482  * service routine when the device is enabled with MSI-X multi-message
5483  * interrupt mode and there is a fast-path FCP IOCB ring event in the
5484  * HBA. However, when the device is enabled with either MSI or Pin-IRQ
5485  * interrupt mode, this function is called as part of the device-level
5486  * interrupt handler. When the PCI slot is in error recovery or the HBA
5487  * is undergoing initialization, the interrupt handler will not process
5488  * the interrupt. The SCSI FCP fast-path ring event are handled in the
5489  * intrrupt context. This function is called without any lock held. It
5490  * gets the hbalock to access and update SLI data structures.
5491  *
5492  * This function returns IRQ_HANDLED when interrupt is handled else it
5493  * returns IRQ_NONE.
5494  **/
5495 irqreturn_t
5496 lpfc_fp_intr_handler(int irq, void *dev_id)
5497 {
5498         struct lpfc_hba  *phba;
5499         uint32_t ha_copy;
5500         unsigned long status;
5501         unsigned long iflag;
5502
5503         /* Get the driver's phba structure from the dev_id and
5504          * assume the HBA is not interrupting.
5505          */
5506         phba = (struct lpfc_hba *) dev_id;
5507
5508         if (unlikely(!phba))
5509                 return IRQ_NONE;
5510
5511         /*
5512          * Stuff needs to be attented to when this function is invoked as an
5513          * individual interrupt handler in MSI-X multi-message interrupt mode
5514          */
5515         if (phba->intr_type == MSIX) {
5516                 /* If pci channel is offline, ignore all the interrupts */
5517                 if (unlikely(pci_channel_offline(phba->pcidev)))
5518                         return IRQ_NONE;
5519                 /* Update device-level interrupt statistics */
5520                 phba->sli.slistat.sli_intr++;
5521                 /* Ignore all interrupts during initialization. */
5522                 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5523                         return IRQ_NONE;
5524                 /* Need to read HA REG for FCP ring and other ring events */
5525                 ha_copy = readl(phba->HAregaddr);
5526                 /* Clear up only attention source related to fast-path */
5527                 spin_lock_irqsave(&phba->hbalock, iflag);
5528                 /*
5529                  * If there is deferred error attention, do not check for
5530                  * any interrupt.
5531                  */
5532                 if (unlikely(phba->hba_flag & DEFER_ERATT)) {
5533                         spin_unlock_irq(&phba->hbalock);
5534                         return IRQ_NONE;
5535                 }
5536                 writel((ha_copy & (HA_R0_CLR_MSK | HA_R1_CLR_MSK)),
5537                         phba->HAregaddr);
5538                 readl(phba->HAregaddr); /* flush */
5539                 spin_unlock_irqrestore(&phba->hbalock, iflag);
5540         } else
5541                 ha_copy = phba->ha_copy;
5542
5543         /*
5544          * Process all events on FCP ring. Take the optimized path for FCP IO.
5545          */
5546         ha_copy &= ~(phba->work_ha_mask);
5547
5548         status = (ha_copy & (HA_RXMASK << (4*LPFC_FCP_RING)));
5549         status >>= (4*LPFC_FCP_RING);
5550         if (status & HA_RXMASK)
5551                 lpfc_sli_handle_fast_ring_event(phba,
5552                                                 &phba->sli.ring[LPFC_FCP_RING],
5553                                                 status);
5554
5555         if (phba->cfg_multi_ring_support == 2) {
5556                 /*
5557                  * Process all events on extra ring. Take the optimized path
5558                  * for extra ring IO.
5559                  */
5560                 status = (ha_copy & (HA_RXMASK << (4*LPFC_EXTRA_RING)));
5561                 status >>= (4*LPFC_EXTRA_RING);
5562                 if (status & HA_RXMASK) {
5563                         lpfc_sli_handle_fast_ring_event(phba,
5564                                         &phba->sli.ring[LPFC_EXTRA_RING],
5565                                         status);
5566                 }
5567         }
5568         return IRQ_HANDLED;
5569 }  /* lpfc_fp_intr_handler */
5570
5571 /**
5572  * lpfc_intr_handler - The device-level interrupt handler of lpfc driver
5573  * @irq: Interrupt number.
5574  * @dev_id: The device context pointer.
5575  *
5576  * This function is the device-level interrupt handler called from the PCI
5577  * layer when either MSI or Pin-IRQ interrupt mode is enabled and there is
5578  * an event in the HBA which requires driver attention. This function
5579  * invokes the slow-path interrupt attention handling function and fast-path
5580  * interrupt attention handling function in turn to process the relevant
5581  * HBA attention events. This function is called without any lock held. It
5582  * gets the hbalock to access and update SLI data structures.
5583  *
5584  * This function returns IRQ_HANDLED when interrupt is handled, else it
5585  * returns IRQ_NONE.
5586  **/
5587 irqreturn_t
5588 lpfc_intr_handler(int irq, void *dev_id)
5589 {
5590         struct lpfc_hba  *phba;
5591         irqreturn_t sp_irq_rc, fp_irq_rc;
5592         unsigned long status1, status2;
5593
5594         /*
5595          * Get the driver's phba structure from the dev_id and
5596          * assume the HBA is not interrupting.
5597          */
5598         phba = (struct lpfc_hba *) dev_id;
5599
5600         if (unlikely(!phba))
5601                 return IRQ_NONE;
5602
5603         /* If the pci channel is offline, ignore all the interrupts. */
5604         if (unlikely(pci_channel_offline(phba->pcidev)))
5605                 return IRQ_NONE;
5606
5607         /* Update device level interrupt statistics */
5608         phba->sli.slistat.sli_intr++;
5609
5610         /* Ignore all interrupts during initialization. */
5611         if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5612                 return IRQ_NONE;
5613
5614         spin_lock(&phba->hbalock);
5615         phba->ha_copy = readl(phba->HAregaddr);
5616         if (unlikely(!phba->ha_copy)) {
5617                 spin_unlock(&phba->hbalock);
5618                 return IRQ_NONE;
5619         } else if (phba->ha_copy & HA_ERATT) {
5620                 if (phba->hba_flag & HBA_ERATT_HANDLED)
5621                         /* ERATT polling has handled ERATT */
5622                         phba->ha_copy &= ~HA_ERATT;
5623                 else
5624                         /* Indicate interrupt handler handles ERATT */
5625                         phba->hba_flag |= HBA_ERATT_HANDLED;
5626         }
5627
5628         /*
5629          * If there is deferred error attention, do not check for any interrupt.
5630          */
5631         if (unlikely(phba->hba_flag & DEFER_ERATT)) {
5632                 spin_unlock_irq(&phba->hbalock);
5633                 return IRQ_NONE;
5634         }
5635
5636         /* Clear attention sources except link and error attentions */
5637         writel((phba->ha_copy & ~(HA_LATT | HA_ERATT)), phba->HAregaddr);
5638         readl(phba->HAregaddr); /* flush */
5639         spin_unlock(&phba->hbalock);
5640
5641         /*
5642          * Invokes slow-path host attention interrupt handling as appropriate.
5643          */
5644
5645         /* status of events with mailbox and link attention */
5646         status1 = phba->ha_copy & (HA_MBATT | HA_LATT | HA_ERATT);
5647
5648         /* status of events with ELS ring */
5649         status2 = (phba->ha_copy & (HA_RXMASK  << (4*LPFC_ELS_RING)));
5650         status2 >>= (4*LPFC_ELS_RING);
5651
5652         if (status1 || (status2 & HA_RXMASK))
5653                 sp_irq_rc = lpfc_sp_intr_handler(irq, dev_id);
5654         else
5655                 sp_irq_rc = IRQ_NONE;
5656
5657         /*
5658          * Invoke fast-path host attention interrupt handling as appropriate.
5659          */
5660
5661         /* status of events with FCP ring */
5662         status1 = (phba->ha_copy & (HA_RXMASK << (4*LPFC_FCP_RING)));
5663         status1 >>= (4*LPFC_FCP_RING);
5664
5665         /* status of events with extra ring */
5666         if (phba->cfg_multi_ring_support == 2) {
5667                 status2 = (phba->ha_copy & (HA_RXMASK << (4*LPFC_EXTRA_RING)));
5668                 status2 >>= (4*LPFC_EXTRA_RING);
5669         } else
5670                 status2 = 0;
5671
5672         if ((status1 & HA_RXMASK) || (status2 & HA_RXMASK))
5673                 fp_irq_rc = lpfc_fp_intr_handler(irq, dev_id);
5674         else
5675                 fp_irq_rc = IRQ_NONE;
5676
5677         /* Return device-level interrupt handling status */
5678         return (sp_irq_rc == IRQ_HANDLED) ? sp_irq_rc : fp_irq_rc;
5679 }  /* lpfc_intr_handler */