SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/message/fusion/mptbase.c

   1 /*
   2  *  linux/drivers/message/fusion/mptbase.c
   3  *      This is the Fusion MPT base driver which supports multiple
   4  *      (SCSI + LAN) specialized protocol drivers.
   5  *      For use with LSI PCI chip/adapter(s)
   6  *      running LSI Fusion MPT (Message Passing Technology) firmware.
   7  *
   8  *  Copyright (c) 1999-2008 LSI Corporation
   9  *  (mailto:DL-MPTFusionLinux@lsi.com)
  10  *
  11  */
  12 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  13 /*
  14     This program is free software; you can redistribute it and/or modify
  15     it under the terms of the GNU General Public License as published by
  16     the Free Software Foundation; version 2 of the License.
  17
  18     This program is distributed in the hope that it will be useful,
  19     but WITHOUT ANY WARRANTY; without even the implied warranty of
  20     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21     GNU General Public License for more details.
  22
  23     NO WARRANTY
  24     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  25     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  26     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  27     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  28     solely responsible for determining the appropriateness of using and
  29     distributing the Program and assumes all risks associated with its
  30     exercise of rights under this Agreement, including but not limited to
  31     the risks and costs of program errors, damage to or loss of data,
  32     programs or equipment, and unavailability or interruption of operations.
  33
  34     DISCLAIMER OF LIABILITY
  35     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  36     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  37     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  38     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  39     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  40     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  41     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  42
  43     You should have received a copy of the GNU General Public License
  44     along with this program; if not, write to the Free Software
  45     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  46 */
  47 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  48
  49 #include <linux/kernel.h>
  50 #include <linux/module.h>
  51 #include <linux/errno.h>
  52 #include <linux/init.h>
  53 #include <linux/slab.h>
  54 #include <linux/types.h>
  55 #include <linux/pci.h>
  56 #include <linux/kdev_t.h>
  57 #include <linux/blkdev.h>
  58 #include <linux/delay.h>
  59 #include <linux/interrupt.h>            /* needed for in_interrupt() proto */
  60 #include <linux/dma-mapping.h>
  61 #include <asm/io.h>
  62 #ifdef CONFIG_MTRR
  63 #include <asm/mtrr.h>
  64 #endif
  65
  66 #include "mptbase.h"
  67 #include "lsi/mpi_log_fc.h"
  68
  69 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  70 #define my_NAME         "Fusion MPT base driver"
  71 #define my_VERSION      MPT_LINUX_VERSION_COMMON
  72 #define MYNAM           "mptbase"
  73
  74 MODULE_AUTHOR(MODULEAUTHOR);
  75 MODULE_DESCRIPTION(my_NAME);
  76 MODULE_LICENSE("GPL");
  77 MODULE_VERSION(my_VERSION);
  78
  79 /*
  80  *  cmd line parameters
  81  */
  82 static int mpt_msi_enable = -1;
  83 module_param(mpt_msi_enable, int, 0);
  84 MODULE_PARM_DESC(mpt_msi_enable, " MSI Support Enable (default=0)");
  85
  86 static int mpt_channel_mapping;
  87 module_param(mpt_channel_mapping, int, 0);
  88 MODULE_PARM_DESC(mpt_channel_mapping, " Mapping id's to channels (default=0)");
  89
  90 static int mpt_debug_level;
  91 static int mpt_set_debug_level(const char *val, struct kernel_param *kp);
  92 module_param_call(mpt_debug_level, mpt_set_debug_level, param_get_int,
  93                   &mpt_debug_level, 0600);
  94 MODULE_PARM_DESC(mpt_debug_level, " debug level - refer to mptdebug.h - (default=0)");
  95
  96 #ifdef MFCNT
  97 static int mfcounter = 0;
  98 #define PRINT_MF_COUNT 20000
  99 #endif
 100
 101 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 102 /*
 103  *  Public data...
 104  */
 105
 106 static struct proc_dir_entry *mpt_proc_root_dir;
 107
 108 #define WHOINIT_UNKNOWN         0xAA
 109
 110 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 111 /*
 112  *  Private data...
 113  */
 114                                         /* Adapter link list */
 115 LIST_HEAD(ioc_list);
 116                                         /* Callback lookup table */
 117 static MPT_CALLBACK              MptCallbacks[MPT_MAX_PROTOCOL_DRIVERS];
 118                                         /* Protocol driver class lookup table */
 119 static int                       MptDriverClass[MPT_MAX_PROTOCOL_DRIVERS];
 120                                         /* Event handler lookup table */
 121 static MPT_EVHANDLER             MptEvHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 122                                         /* Reset handler lookup table */
 123 static MPT_RESETHANDLER          MptResetHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 124 static struct mpt_pci_driver    *MptDeviceDriverHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 125
 126 static DECLARE_WAIT_QUEUE_HEAD(mpt_waitq);
 127
 128 /*
 129  *  Driver Callback Index's
 130  */
 131 static u8 mpt_base_index = MPT_MAX_PROTOCOL_DRIVERS;
 132 static u8 last_drv_idx;
 133
 134 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 135 /*
 136  *  Forward protos...
 137  */
 138 static irqreturn_t mpt_interrupt(int irq, void *bus_id);
 139 static int      mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
 140 static int      mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes,
 141                         u32 *req, int replyBytes, u16 *u16reply, int maxwait,
 142                         int sleepFlag);
 143 static int      mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag);
 144 static void     mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev);
 145 static void     mpt_adapter_disable(MPT_ADAPTER *ioc);
 146 static void     mpt_adapter_dispose(MPT_ADAPTER *ioc);
 147
 148 static void     MptDisplayIocCapabilities(MPT_ADAPTER *ioc);
 149 static int      MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag);
 150 static int      GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason);
 151 static int      GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
 152 static int      SendIocInit(MPT_ADAPTER *ioc, int sleepFlag);
 153 static int      SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
 154 static int      mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag);
 155 static int      mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag);
 156 static int      mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
 157 static int      KickStart(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
 158 static int      SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag);
 159 static int      PrimeIocFifos(MPT_ADAPTER *ioc);
 160 static int      WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
 161 static int      WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
 162 static int      WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
 163 static int      GetLanConfigPages(MPT_ADAPTER *ioc);
 164 static int      GetIoUnitPage2(MPT_ADAPTER *ioc);
 165 int             mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
 166 static int      mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum);
 167 static int      mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum);
 168 static void     mpt_read_ioc_pg_1(MPT_ADAPTER *ioc);
 169 static void     mpt_read_ioc_pg_4(MPT_ADAPTER *ioc);
 170 static void     mpt_timer_expired(unsigned long data);
 171 static void     mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc);
 172 static int      SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch);
 173 static int      SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp);
 174 static int      mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag);
 175 static int      mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init);
 176
 177 #ifdef CONFIG_PROC_FS
 178 static int      procmpt_summary_read(char *buf, char **start, off_t offset,
 179                                 int request, int *eof, void *data);
 180 static int      procmpt_version_read(char *buf, char **start, off_t offset,
 181                                 int request, int *eof, void *data);
 182 static int      procmpt_iocinfo_read(char *buf, char **start, off_t offset,
 183                                 int request, int *eof, void *data);
 184 #endif
 185 static void     mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc);
 186
 187 //int           mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
 188 static int      ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *evReply, int *evHandlers);
 189 static void     mpt_iocstatus_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf);
 190 static void     mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info);
 191 static void     mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info);
 192 static void     mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info);
 193 static int      mpt_read_ioc_pg_3(MPT_ADAPTER *ioc);
 194 static void     mpt_inactive_raid_list_free(MPT_ADAPTER *ioc);
 195
 196 /* module entry point */
 197 static int  __init    fusion_init  (void);
 198 static void __exit    fusion_exit  (void);
 199
 200 #define CHIPREG_READ32(addr)            readl_relaxed(addr)
 201 #define CHIPREG_READ32_dmasync(addr)    readl(addr)
 202 #define CHIPREG_WRITE32(addr,val)       writel(val, addr)
 203 #define CHIPREG_PIO_WRITE32(addr,val)   outl(val, (unsigned long)addr)
 204 #define CHIPREG_PIO_READ32(addr)        inl((unsigned long)addr)
 205
 206 static void
 207 pci_disable_io_access(struct pci_dev *pdev)
 208 {
 209         u16 command_reg;
 210
 211         pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
 212         command_reg &= ~1;
 213         pci_write_config_word(pdev, PCI_COMMAND, command_reg);
 214 }
 215
 216 static void
 217 pci_enable_io_access(struct pci_dev *pdev)
 218 {
 219         u16 command_reg;
 220
 221         pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
 222         command_reg |= 1;
 223         pci_write_config_word(pdev, PCI_COMMAND, command_reg);
 224 }
 225
 226 static int mpt_set_debug_level(const char *val, struct kernel_param *kp)
 227 {
 228         int ret = param_set_int(val, kp);
 229         MPT_ADAPTER *ioc;
 230
 231         if (ret)
 232                 return ret;
 233
 234         list_for_each_entry(ioc, &ioc_list, list)
 235                 ioc->debug_level = mpt_debug_level;
 236         return 0;
 237 }
 238
 239 /**
 240  *      mpt_get_cb_idx - obtain cb_idx for registered driver
 241  *      @dclass: class driver enum
 242  *
 243  *      Returns cb_idx, or zero means it wasn't found
 244  **/
 245 static u8
 246 mpt_get_cb_idx(MPT_DRIVER_CLASS dclass)
 247 {
 248         u8 cb_idx;
 249
 250         for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--)
 251                 if (MptDriverClass[cb_idx] == dclass)
 252                         return cb_idx;
 253         return 0;
 254 }
 255
 256 /**
 257  *      mpt_fault_reset_work - work performed on workq after ioc fault
 258  *      @work: input argument, used to derive ioc
 259  *
 260 **/
 261 static void
 262 mpt_fault_reset_work(struct work_struct *work)
 263 {
 264         MPT_ADAPTER     *ioc =
 265             container_of(work, MPT_ADAPTER, fault_reset_work.work);
 266         u32              ioc_raw_state;
 267         int              rc;
 268         unsigned long    flags;
 269
 270         if (ioc->diagPending || !ioc->active)
 271                 goto out;
 272
 273         ioc_raw_state = mpt_GetIocState(ioc, 0);
 274         if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
 275                 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state (%04xh)!!!\n",
 276                        ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
 277                 printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
 278                        ioc->name, __func__);
 279                 rc = mpt_HardResetHandler(ioc, CAN_SLEEP);
 280                 printk(MYIOC_s_WARN_FMT "%s: HardReset: %s\n", ioc->name,
 281                        __func__, (rc == 0) ? "success" : "failed");
 282                 ioc_raw_state = mpt_GetIocState(ioc, 0);
 283                 if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT)
 284                         printk(MYIOC_s_WARN_FMT "IOC is in FAULT state after "
 285                             "reset (%04xh)\n", ioc->name, ioc_raw_state &
 286                             MPI_DOORBELL_DATA_MASK);
 287         }
 288
 289  out:
 290         /*
 291          * Take turns polling alternate controller
 292          */
 293         if (ioc->alt_ioc)
 294                 ioc = ioc->alt_ioc;
 295
 296         /* rearm the timer */
 297         spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
 298         if (ioc->reset_work_q)
 299                 queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
 300                         msecs_to_jiffies(MPT_POLLING_INTERVAL));
 301         spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
 302 }
 303
 304
 305 /*
 306  *  Process turbo (context) reply...
 307  */
 308 static void
 309 mpt_turbo_reply(MPT_ADAPTER *ioc, u32 pa)
 310 {
 311         MPT_FRAME_HDR *mf = NULL;
 312         MPT_FRAME_HDR *mr = NULL;
 313         u16 req_idx = 0;
 314         u8 cb_idx;
 315
 316         dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got TURBO reply req_idx=%08x\n",
 317                                 ioc->name, pa));
 318
 319         switch (pa >> MPI_CONTEXT_REPLY_TYPE_SHIFT) {
 320         case MPI_CONTEXT_REPLY_TYPE_SCSI_INIT:
 321                 req_idx = pa & 0x0000FFFF;
 322                 cb_idx = (pa & 0x00FF0000) >> 16;
 323                 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
 324                 break;
 325         case MPI_CONTEXT_REPLY_TYPE_LAN:
 326                 cb_idx = mpt_get_cb_idx(MPTLAN_DRIVER);
 327                 /*
 328                  *  Blind set of mf to NULL here was fatal
 329                  *  after lan_reply says "freeme"
 330                  *  Fix sort of combined with an optimization here;
 331                  *  added explicit check for case where lan_reply
 332                  *  was just returning 1 and doing nothing else.
 333                  *  For this case skip the callback, but set up
 334                  *  proper mf value first here:-)
 335                  */
 336                 if ((pa & 0x58000000) == 0x58000000) {
 337                         req_idx = pa & 0x0000FFFF;
 338                         mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
 339                         mpt_free_msg_frame(ioc, mf);
 340                         mb();
 341                         return;
 342                         break;
 343                 }
 344                 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
 345                 break;
 346         case MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET:
 347                 cb_idx = mpt_get_cb_idx(MPTSTM_DRIVER);
 348                 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
 349                 break;
 350         default:
 351                 cb_idx = 0;
 352                 BUG();
 353         }
 354
 355         /*  Check for (valid) IO callback!  */
 356         if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
 357                 MptCallbacks[cb_idx] == NULL) {
 358                 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
 359                                 __func__, ioc->name, cb_idx);
 360                 goto out;
 361         }
 362
 363         if (MptCallbacks[cb_idx](ioc, mf, mr))
 364                 mpt_free_msg_frame(ioc, mf);
 365  out:
 366         mb();
 367 }
 368
 369 static void
 370 mpt_reply(MPT_ADAPTER *ioc, u32 pa)
 371 {
 372         MPT_FRAME_HDR   *mf;
 373         MPT_FRAME_HDR   *mr;
 374         u16              req_idx;
 375         u8               cb_idx;
 376         int              freeme;
 377
 378         u32 reply_dma_low;
 379         u16 ioc_stat;
 380
 381         /* non-TURBO reply!  Hmmm, something may be up...
 382          *  Newest turbo reply mechanism; get address
 383          *  via left shift 1 (get rid of MPI_ADDRESS_REPLY_A_BIT)!
 384          */
 385
 386         /* Map DMA address of reply header to cpu address.
 387          * pa is 32 bits - but the dma address may be 32 or 64 bits
 388          * get offset based only only the low addresses
 389          */
 390
 391         reply_dma_low = (pa <<= 1);
 392         mr = (MPT_FRAME_HDR *)((u8 *)ioc->reply_frames +
 393                          (reply_dma_low - ioc->reply_frames_low_dma));
 394
 395         req_idx = le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx);
 396         cb_idx = mr->u.frame.hwhdr.msgctxu.fld.cb_idx;
 397         mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
 398
 399         dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got non-TURBO reply=%p req_idx=%x cb_idx=%x Function=%x\n",
 400                         ioc->name, mr, req_idx, cb_idx, mr->u.hdr.Function));
 401         DBG_DUMP_REPLY_FRAME(ioc, (u32 *)mr);
 402
 403          /*  Check/log IOC log info
 404          */
 405         ioc_stat = le16_to_cpu(mr->u.reply.IOCStatus);
 406         if (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) {
 407                 u32      log_info = le32_to_cpu(mr->u.reply.IOCLogInfo);
 408                 if (ioc->bus_type == FC)
 409                         mpt_fc_log_info(ioc, log_info);
 410                 else if (ioc->bus_type == SPI)
 411                         mpt_spi_log_info(ioc, log_info);
 412                 else if (ioc->bus_type == SAS)
 413                         mpt_sas_log_info(ioc, log_info);
 414         }
 415
 416         if (ioc_stat & MPI_IOCSTATUS_MASK)
 417                 mpt_iocstatus_info(ioc, (u32)ioc_stat, mf);
 418
 419         /*  Check for (valid) IO callback!  */
 420         if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
 421                 MptCallbacks[cb_idx] == NULL) {
 422                 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
 423                                 __func__, ioc->name, cb_idx);
 424                 freeme = 0;
 425                 goto out;
 426         }
 427
 428         freeme = MptCallbacks[cb_idx](ioc, mf, mr);
 429
 430  out:
 431         /*  Flush (non-TURBO) reply with a WRITE!  */
 432         CHIPREG_WRITE32(&ioc->chip->ReplyFifo, pa);
 433
 434         if (freeme)
 435                 mpt_free_msg_frame(ioc, mf);
 436         mb();
 437 }
 438
 439 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 440 /**
 441  *      mpt_interrupt - MPT adapter (IOC) specific interrupt handler.
 442  *      @irq: irq number (not used)
 443  *      @bus_id: bus identifier cookie == pointer to MPT_ADAPTER structure
 444  *
 445  *      This routine is registered via the request_irq() kernel API call,
 446  *      and handles all interrupts generated from a specific MPT adapter
 447  *      (also referred to as a IO Controller or IOC).
 448  *      This routine must clear the interrupt from the adapter and does
 449  *      so by reading the reply FIFO.  Multiple replies may be processed
 450  *      per single call to this routine.
 451  *
 452  *      This routine handles register-level access of the adapter but
 453  *      dispatches (calls) a protocol-specific callback routine to handle
 454  *      the protocol-specific details of the MPT request completion.
 455  */
 456 static irqreturn_t
 457 mpt_interrupt(int irq, void *bus_id)
 458 {
 459         MPT_ADAPTER *ioc = bus_id;
 460         u32 pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
 461
 462         if (pa == 0xFFFFFFFF)
 463                 return IRQ_NONE;
 464
 465         /*
 466          *  Drain the reply FIFO!
 467          */
 468         do {
 469                 if (pa & MPI_ADDRESS_REPLY_A_BIT)
 470                         mpt_reply(ioc, pa);
 471                 else
 472                         mpt_turbo_reply(ioc, pa);
 473                 pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
 474         } while (pa != 0xFFFFFFFF);
 475
 476         return IRQ_HANDLED;
 477 }
 478
 479 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 480 /**
 481  *      mpt_base_reply - MPT base driver's callback routine
 482  *      @ioc: Pointer to MPT_ADAPTER structure
 483  *      @mf: Pointer to original MPT request frame
 484  *      @reply: Pointer to MPT reply frame (NULL if TurboReply)
 485  *
 486  *      MPT base driver's callback routine; all base driver
 487  *      "internal" request/reply processing is routed here.
 488  *      Currently used for EventNotification and EventAck handling.
 489  *
 490  *      Returns 1 indicating original alloc'd request frame ptr
 491  *      should be freed, or 0 if it shouldn't.
 492  */
 493 static int
 494 mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
 495 {
 496         int freereq = 1;
 497         u8 func;
 498
 499         dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply() called\n", ioc->name));
 500 #ifdef CONFIG_FUSION_LOGGING
 501         if ((ioc->debug_level & MPT_DEBUG_MSG_FRAME) &&
 502                         !(reply->u.hdr.MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)) {
 503                 dmfprintk(ioc, printk(MYIOC_s_INFO_FMT ": Original request frame (@%p) header\n",
 504                     ioc->name, mf));
 505                 DBG_DUMP_REQUEST_FRAME_HDR(ioc, (u32 *)mf);
 506         }
 507 #endif
 508
 509         func = reply->u.hdr.Function;
 510         dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, Function=%02Xh\n",
 511                         ioc->name, func));
 512
 513         if (func == MPI_FUNCTION_EVENT_NOTIFICATION) {
 514                 EventNotificationReply_t *pEvReply = (EventNotificationReply_t *) reply;
 515                 int evHandlers = 0;
 516                 int results;
 517
 518                 results = ProcessEventNotification(ioc, pEvReply, &evHandlers);
 519                 if (results != evHandlers) {
 520                         /* CHECKME! Any special handling needed here? */
 521                         devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Called %d event handlers, sum results = %d\n",
 522                                         ioc->name, evHandlers, results));
 523                 }
 524
 525                 /*
 526                  *      Hmmm...  It seems that EventNotificationReply is an exception
 527                  *      to the rule of one reply per request.
 528                  */
 529                 if (pEvReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) {
 530                         freereq = 0;
 531                 } else {
 532                         devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "EVENT_NOTIFICATION reply %p returns Request frame\n",
 533                                 ioc->name, pEvReply));
 534                 }
 535
 536 #ifdef CONFIG_PROC_FS
 537 //              LogEvent(ioc, pEvReply);
 538 #endif
 539
 540         } else if (func == MPI_FUNCTION_EVENT_ACK) {
 541                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, EventAck reply received\n",
 542                                 ioc->name));
 543         } else if (func == MPI_FUNCTION_CONFIG) {
 544                 CONFIGPARMS *pCfg;
 545                 unsigned long flags;
 546
 547                 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "config_complete (mf=%p,mr=%p)\n",
 548                                 ioc->name, mf, reply));
 549
 550                 pCfg = * ((CONFIGPARMS **)((u8 *) mf + ioc->req_sz - sizeof(void *)));
 551
 552                 if (pCfg) {
 553                         /* disable timer and remove from linked list */
 554                         del_timer(&pCfg->timer);
 555
 556                         spin_lock_irqsave(&ioc->FreeQlock, flags);
 557                         list_del(&pCfg->linkage);
 558                         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
 559
 560                         /*
 561                          *      If IOC Status is SUCCESS, save the header
 562                          *      and set the status code to GOOD.
 563                          */
 564                         pCfg->status = MPT_CONFIG_ERROR;
 565                         if (reply) {
 566                                 ConfigReply_t   *pReply = (ConfigReply_t *)reply;
 567                                 u16              status;
 568
 569                                 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
 570                                 dcprintk(ioc, printk(MYIOC_s_NOTE_FMT "  IOCStatus=%04xh, IOCLogInfo=%08xh\n",
 571                                      ioc->name, status, le32_to_cpu(pReply->IOCLogInfo)));
 572
 573                                 pCfg->status = status;
 574                                 if (status == MPI_IOCSTATUS_SUCCESS) {
 575                                         if ((pReply->Header.PageType &
 576                                             MPI_CONFIG_PAGETYPE_MASK) ==
 577                                             MPI_CONFIG_PAGETYPE_EXTENDED) {
 578                                                 pCfg->cfghdr.ehdr->ExtPageLength =
 579                                                     le16_to_cpu(pReply->ExtPageLength);
 580                                                 pCfg->cfghdr.ehdr->ExtPageType =
 581                                                     pReply->ExtPageType;
 582                                         }
 583                                         pCfg->cfghdr.hdr->PageVersion = pReply->Header.PageVersion;
 584
 585                                         /* If this is a regular header, save PageLength. */
 586                                         /* LMP Do this better so not using a reserved field! */
 587                                         pCfg->cfghdr.hdr->PageLength = pReply->Header.PageLength;
 588                                         pCfg->cfghdr.hdr->PageNumber = pReply->Header.PageNumber;
 589                                         pCfg->cfghdr.hdr->PageType = pReply->Header.PageType;
 590                                 }
 591                         }
 592
 593                         /*
 594                          *      Wake up the original calling thread
 595                          */
 596                         pCfg->wait_done = 1;
 597                         wake_up(&mpt_waitq);
 598                 }
 599         } else if (func == MPI_FUNCTION_SAS_IO_UNIT_CONTROL) {
 600                 /* we should be always getting a reply frame */
 601                 memcpy(ioc->persist_reply_frame, reply,
 602                     min(MPT_DEFAULT_FRAME_SIZE,
 603                     4*reply->u.reply.MsgLength));
 604                 del_timer(&ioc->persist_timer);
 605                 ioc->persist_wait_done = 1;
 606                 wake_up(&mpt_waitq);
 607         } else {
 608                 printk(MYIOC_s_ERR_FMT "Unexpected msg function (=%02Xh) reply received!\n",
 609                                 ioc->name, func);
 610         }
 611
 612         /*
 613          *      Conditionally tell caller to free the original
 614          *      EventNotification/EventAck/unexpected request frame!
 615          */
 616         return freereq;
 617 }
 618
 619 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 620 /**
 621  *      mpt_register - Register protocol-specific main callback handler.
 622  *      @cbfunc: callback function pointer
 623  *      @dclass: Protocol driver's class (%MPT_DRIVER_CLASS enum value)
 624  *
 625  *      This routine is called by a protocol-specific driver (SCSI host,
 626  *      LAN, SCSI target) to register its reply callback routine.  Each
 627  *      protocol-specific driver must do this before it will be able to
 628  *      use any IOC resources, such as obtaining request frames.
 629  *
 630  *      NOTES: The SCSI protocol driver currently calls this routine thrice
 631  *      in order to register separate callbacks; one for "normal" SCSI IO;
 632  *      one for MptScsiTaskMgmt requests; one for Scan/DV requests.
 633  *
 634  *      Returns u8 valued "handle" in the range (and S.O.D. order)
 635  *      {N,...,7,6,5,...,1} if successful.
 636  *      A return value of MPT_MAX_PROTOCOL_DRIVERS (including zero!) should be
 637  *      considered an error by the caller.
 638  */
 639 u8
 640 mpt_register(MPT_CALLBACK cbfunc, MPT_DRIVER_CLASS dclass)
 641 {
 642         u8 cb_idx;
 643         last_drv_idx = MPT_MAX_PROTOCOL_DRIVERS;
 644
 645         /*
 646          *  Search for empty callback slot in this order: {N,...,7,6,5,...,1}
 647          *  (slot/handle 0 is reserved!)
 648          */
 649         for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
 650                 if (MptCallbacks[cb_idx] == NULL) {
 651                         MptCallbacks[cb_idx] = cbfunc;
 652                         MptDriverClass[cb_idx] = dclass;
 653                         MptEvHandlers[cb_idx] = NULL;
 654                         last_drv_idx = cb_idx;
 655                         break;
 656                 }
 657         }
 658
 659         return last_drv_idx;
 660 }
 661
 662 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 663 /**
 664  *      mpt_deregister - Deregister a protocol drivers resources.
 665  *      @cb_idx: previously registered callback handle
 666  *
 667  *      Each protocol-specific driver should call this routine when its
 668  *      module is unloaded.
 669  */
 670 void
 671 mpt_deregister(u8 cb_idx)
 672 {
 673         if (cb_idx && (cb_idx < MPT_MAX_PROTOCOL_DRIVERS)) {
 674                 MptCallbacks[cb_idx] = NULL;
 675                 MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
 676                 MptEvHandlers[cb_idx] = NULL;
 677
 678                 last_drv_idx++;
 679         }
 680 }
 681
 682 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 683 /**
 684  *      mpt_event_register - Register protocol-specific event callback handler.
 685  *      @cb_idx: previously registered (via mpt_register) callback handle
 686  *      @ev_cbfunc: callback function
 687  *
 688  *      This routine can be called by one or more protocol-specific drivers
 689  *      if/when they choose to be notified of MPT events.
 690  *
 691  *      Returns 0 for success.
 692  */
 693 int
 694 mpt_event_register(u8 cb_idx, MPT_EVHANDLER ev_cbfunc)
 695 {
 696         if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 697                 return -1;
 698
 699         MptEvHandlers[cb_idx] = ev_cbfunc;
 700         return 0;
 701 }
 702
 703 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 704 /**
 705  *      mpt_event_deregister - Deregister protocol-specific event callback handler
 706  *      @cb_idx: previously registered callback handle
 707  *
 708  *      Each protocol-specific driver should call this routine
 709  *      when it does not (or can no longer) handle events,
 710  *      or when its module is unloaded.
 711  */
 712 void
 713 mpt_event_deregister(u8 cb_idx)
 714 {
 715         if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 716                 return;
 717
 718         MptEvHandlers[cb_idx] = NULL;
 719 }
 720
 721 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 722 /**
 723  *      mpt_reset_register - Register protocol-specific IOC reset handler.
 724  *      @cb_idx: previously registered (via mpt_register) callback handle
 725  *      @reset_func: reset function
 726  *
 727  *      This routine can be called by one or more protocol-specific drivers
 728  *      if/when they choose to be notified of IOC resets.
 729  *
 730  *      Returns 0 for success.
 731  */
 732 int
 733 mpt_reset_register(u8 cb_idx, MPT_RESETHANDLER reset_func)
 734 {
 735         if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 736                 return -1;
 737
 738         MptResetHandlers[cb_idx] = reset_func;
 739         return 0;
 740 }
 741
 742 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 743 /**
 744  *      mpt_reset_deregister - Deregister protocol-specific IOC reset handler.
 745  *      @cb_idx: previously registered callback handle
 746  *
 747  *      Each protocol-specific driver should call this routine
 748  *      when it does not (or can no longer) handle IOC reset handling,
 749  *      or when its module is unloaded.
 750  */
 751 void
 752 mpt_reset_deregister(u8 cb_idx)
 753 {
 754         if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 755                 return;
 756
 757         MptResetHandlers[cb_idx] = NULL;
 758 }
 759
 760 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 761 /**
 762  *      mpt_device_driver_register - Register device driver hooks
 763  *      @dd_cbfunc: driver callbacks struct
 764  *      @cb_idx: MPT protocol driver index
 765  */
 766 int
 767 mpt_device_driver_register(struct mpt_pci_driver * dd_cbfunc, u8 cb_idx)
 768 {
 769         MPT_ADAPTER     *ioc;
 770         const struct pci_device_id *id;
 771
 772         if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 773                 return -EINVAL;
 774
 775         MptDeviceDriverHandlers[cb_idx] = dd_cbfunc;
 776
 777         /* call per pci device probe entry point */
 778         list_for_each_entry(ioc, &ioc_list, list) {
 779                 id = ioc->pcidev->driver ?
 780                     ioc->pcidev->driver->id_table : NULL;
 781                 if (dd_cbfunc->probe)
 782                         dd_cbfunc->probe(ioc->pcidev, id);
 783          }
 784
 785         return 0;
 786 }
 787
 788 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 789 /**
 790  *      mpt_device_driver_deregister - DeRegister device driver hooks
 791  *      @cb_idx: MPT protocol driver index
 792  */
 793 void
 794 mpt_device_driver_deregister(u8 cb_idx)
 795 {
 796         struct mpt_pci_driver *dd_cbfunc;
 797         MPT_ADAPTER     *ioc;
 798
 799         if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 800                 return;
 801
 802         dd_cbfunc = MptDeviceDriverHandlers[cb_idx];
 803
 804         list_for_each_entry(ioc, &ioc_list, list) {
 805                 if (dd_cbfunc->remove)
 806                         dd_cbfunc->remove(ioc->pcidev);
 807         }
 808
 809         MptDeviceDriverHandlers[cb_idx] = NULL;
 810 }
 811
 812
 813 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 814 /**
 815  *      mpt_get_msg_frame - Obtain an MPT request frame from the pool
 816  *      @cb_idx: Handle of registered MPT protocol driver
 817  *      @ioc: Pointer to MPT adapter structure
 818  *
 819  *      Obtain an MPT request frame from the pool (of 1024) that are
 820  *      allocated per MPT adapter.
 821  *
 822  *      Returns pointer to a MPT request frame or %NULL if none are available
 823  *      or IOC is not active.
 824  */
 825 MPT_FRAME_HDR*
 826 mpt_get_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc)
 827 {
 828         MPT_FRAME_HDR *mf;
 829         unsigned long flags;
 830         u16      req_idx;       /* Request index */
 831
 832         /* validate handle and ioc identifier */
 833
 834 #ifdef MFCNT
 835         if (!ioc->active)
 836                 printk(MYIOC_s_WARN_FMT "IOC Not Active! mpt_get_msg_frame "
 837                     "returning NULL!\n", ioc->name);
 838 #endif
 839
 840         /* If interrupts are not attached, do not return a request frame */
 841         if (!ioc->active)
 842                 return NULL;
 843
 844         spin_lock_irqsave(&ioc->FreeQlock, flags);
 845         if (!list_empty(&ioc->FreeQ)) {
 846                 int req_offset;
 847
 848                 mf = list_entry(ioc->FreeQ.next, MPT_FRAME_HDR,
 849                                 u.frame.linkage.list);
 850                 list_del(&mf->u.frame.linkage.list);
 851                 mf->u.frame.linkage.arg1 = 0;
 852                 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;  /* byte */
 853                 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
 854                                                                 /* u16! */
 855                 req_idx = req_offset / ioc->req_sz;
 856                 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
 857                 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
 858                 /* Default, will be changed if necessary in SG generation */
 859                 ioc->RequestNB[req_idx] = ioc->NB_for_64_byte_frame;
 860 #ifdef MFCNT
 861                 ioc->mfcnt++;
 862 #endif
 863         }
 864         else
 865                 mf = NULL;
 866         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
 867
 868 #ifdef MFCNT
 869         if (mf == NULL)
 870                 printk(MYIOC_s_WARN_FMT "IOC Active. No free Msg Frames! "
 871                     "Count 0x%x Max 0x%x\n", ioc->name, ioc->mfcnt,
 872                     ioc->req_depth);
 873         mfcounter++;
 874         if (mfcounter == PRINT_MF_COUNT)
 875                 printk(MYIOC_s_INFO_FMT "MF Count 0x%x Max 0x%x \n", ioc->name,
 876                     ioc->mfcnt, ioc->req_depth);
 877 #endif
 878
 879         dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_get_msg_frame(%d,%d), got mf=%p\n",
 880             ioc->name, cb_idx, ioc->id, mf));
 881         return mf;
 882 }
 883
 884 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 885 /**
 886  *      mpt_put_msg_frame - Send a protocol-specific MPT request frame to an IOC
 887  *      @cb_idx: Handle of registered MPT protocol driver
 888  *      @ioc: Pointer to MPT adapter structure
 889  *      @mf: Pointer to MPT request frame
 890  *
 891  *      This routine posts an MPT request frame to the request post FIFO of a
 892  *      specific MPT adapter.
 893  */
 894 void
 895 mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
 896 {
 897         u32 mf_dma_addr;
 898         int req_offset;
 899         u16      req_idx;       /* Request index */
 900
 901         /* ensure values are reset properly! */
 902         mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;          /* byte */
 903         req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
 904                                                                 /* u16! */
 905         req_idx = req_offset / ioc->req_sz;
 906         mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
 907         mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
 908
 909         DBG_DUMP_PUT_MSG_FRAME(ioc, (u32 *)mf);
 910
 911         mf_dma_addr = (ioc->req_frames_low_dma + req_offset) | ioc->RequestNB[req_idx];
 912         dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mf_dma_addr=%x req_idx=%d "
 913             "RequestNB=%x\n", ioc->name, mf_dma_addr, req_idx,
 914             ioc->RequestNB[req_idx]));
 915         CHIPREG_WRITE32(&ioc->chip->RequestFifo, mf_dma_addr);
 916 }
 917
 918 /**
 919  *      mpt_put_msg_frame_hi_pri - Send a hi-pri protocol-specific MPT request frame
 920  *      @cb_idx: Handle of registered MPT protocol driver
 921  *      @ioc: Pointer to MPT adapter structure
 922  *      @mf: Pointer to MPT request frame
 923  *
 924  *      Send a protocol-specific MPT request frame to an IOC using
 925  *      hi-priority request queue.
 926  *
 927  *      This routine posts an MPT request frame to the request post FIFO of a
 928  *      specific MPT adapter.
 929  **/
 930 void
 931 mpt_put_msg_frame_hi_pri(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
 932 {
 933         u32 mf_dma_addr;
 934         int req_offset;
 935         u16      req_idx;       /* Request index */
 936
 937         /* ensure values are reset properly! */
 938         mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;
 939         req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
 940         req_idx = req_offset / ioc->req_sz;
 941         mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
 942         mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
 943
 944         DBG_DUMP_PUT_MSG_FRAME(ioc, (u32 *)mf);
 945
 946         mf_dma_addr = (ioc->req_frames_low_dma + req_offset);
 947         dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mf_dma_addr=%x req_idx=%d\n",
 948                 ioc->name, mf_dma_addr, req_idx));
 949         CHIPREG_WRITE32(&ioc->chip->RequestHiPriFifo, mf_dma_addr);
 950 }
 951
 952 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 953 /**
 954  *      mpt_free_msg_frame - Place MPT request frame back on FreeQ.
 955  *      @handle: Handle of registered MPT protocol driver
 956  *      @ioc: Pointer to MPT adapter structure
 957  *      @mf: Pointer to MPT request frame
 958  *
 959  *      This routine places a MPT request frame back on the MPT adapter's
 960  *      FreeQ.
 961  */
 962 void
 963 mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
 964 {
 965         unsigned long flags;
 966
 967         /*  Put Request back on FreeQ!  */
 968         spin_lock_irqsave(&ioc->FreeQlock, flags);
 969         mf->u.frame.linkage.arg1 = 0xdeadbeaf; /* signature to know if this mf is freed */
 970         list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
 971 #ifdef MFCNT
 972         ioc->mfcnt--;
 973 #endif
 974         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
 975 }
 976
 977 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 978 /**
 979  *      mpt_add_sge - Place a simple SGE at address pAddr.
 980  *      @pAddr: virtual address for SGE
 981  *      @flagslength: SGE flags and data transfer length
 982  *      @dma_addr: Physical address
 983  *
 984  *      This routine places a MPT request frame back on the MPT adapter's
 985  *      FreeQ.
 986  */
 987 void
 988 mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
 989 {
 990         if (sizeof(dma_addr_t) == sizeof(u64)) {
 991                 SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
 992                 u32 tmp = dma_addr & 0xFFFFFFFF;
 993
 994                 pSge->FlagsLength = cpu_to_le32(flagslength);
 995                 pSge->Address.Low = cpu_to_le32(tmp);
 996                 tmp = (u32) ((u64)dma_addr >> 32);
 997                 pSge->Address.High = cpu_to_le32(tmp);
 998
 999         } else {
1000                 SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
1001                 pSge->FlagsLength = cpu_to_le32(flagslength);
1002                 pSge->Address = cpu_to_le32(dma_addr);
1003         }
1004 }
1005
1006 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1007 /**
1008  *      mpt_send_handshake_request - Send MPT request via doorbell handshake method.
1009  *      @cb_idx: Handle of registered MPT protocol driver
1010  *      @ioc: Pointer to MPT adapter structure
1011  *      @reqBytes: Size of the request in bytes
1012  *      @req: Pointer to MPT request frame
1013  *      @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
1014  *
1015  *      This routine is used exclusively to send MptScsiTaskMgmt
1016  *      requests since they are required to be sent via doorbell handshake.
1017  *
1018  *      NOTE: It is the callers responsibility to byte-swap fields in the
1019  *      request which are greater than 1 byte in size.
1020  *
1021  *      Returns 0 for success, non-zero for failure.
1022  */
1023 int
1024 mpt_send_handshake_request(u8 cb_idx, MPT_ADAPTER *ioc, int reqBytes, u32 *req, int sleepFlag)
1025 {
1026         int     r = 0;
1027         u8      *req_as_bytes;
1028         int      ii;
1029
1030         /* State is known to be good upon entering
1031          * this function so issue the bus reset
1032          * request.
1033          */
1034
1035         /*
1036          * Emulate what mpt_put_msg_frame() does /wrt to sanity
1037          * setting cb_idx/req_idx.  But ONLY if this request
1038          * is in proper (pre-alloc'd) request buffer range...
1039          */
1040         ii = MFPTR_2_MPT_INDEX(ioc,(MPT_FRAME_HDR*)req);
1041         if (reqBytes >= 12 && ii >= 0 && ii < ioc->req_depth) {
1042                 MPT_FRAME_HDR *mf = (MPT_FRAME_HDR*)req;
1043                 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(ii);
1044                 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;
1045         }
1046
1047         /* Make sure there are no doorbells */
1048         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1049
1050         CHIPREG_WRITE32(&ioc->chip->Doorbell,
1051                         ((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
1052                          ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
1053
1054         /* Wait for IOC doorbell int */
1055         if ((ii = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0) {
1056                 return ii;
1057         }
1058
1059         /* Read doorbell and check for active bit */
1060         if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
1061                 return -5;
1062
1063         dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_send_handshake_request start, WaitCnt=%d\n",
1064                 ioc->name, ii));
1065
1066         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1067
1068         if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1069                 return -2;
1070         }
1071
1072         /* Send request via doorbell handshake */
1073         req_as_bytes = (u8 *) req;
1074         for (ii = 0; ii < reqBytes/4; ii++) {
1075                 u32 word;
1076
1077                 word = ((req_as_bytes[(ii*4) + 0] <<  0) |
1078                         (req_as_bytes[(ii*4) + 1] <<  8) |
1079                         (req_as_bytes[(ii*4) + 2] << 16) |
1080                         (req_as_bytes[(ii*4) + 3] << 24));
1081                 CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
1082                 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1083                         r = -3;
1084                         break;
1085                 }
1086         }
1087
1088         if (r >= 0 && WaitForDoorbellInt(ioc, 10, sleepFlag) >= 0)
1089                 r = 0;
1090         else
1091                 r = -4;
1092
1093         /* Make sure there are no doorbells */
1094         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1095
1096         return r;
1097 }
1098
1099 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1100 /**
1101  * mpt_host_page_access_control - control the IOC's Host Page Buffer access
1102  * @ioc: Pointer to MPT adapter structure
1103  * @access_control_value: define bits below
1104  * @sleepFlag: Specifies whether the process can sleep
1105  *
1106  * Provides mechanism for the host driver to control the IOC's
1107  * Host Page Buffer access.
1108  *
1109  * Access Control Value - bits[15:12]
1110  * 0h Reserved
1111  * 1h Enable Access { MPI_DB_HPBAC_ENABLE_ACCESS }
1112  * 2h Disable Access { MPI_DB_HPBAC_DISABLE_ACCESS }
1113  * 3h Free Buffer { MPI_DB_HPBAC_FREE_BUFFER }
1114  *
1115  * Returns 0 for success, non-zero for failure.
1116  */
1117
1118 static int
1119 mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag)
1120 {
1121         int      r = 0;
1122
1123         /* return if in use */
1124         if (CHIPREG_READ32(&ioc->chip->Doorbell)
1125             & MPI_DOORBELL_ACTIVE)
1126             return -1;
1127
1128         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1129
1130         CHIPREG_WRITE32(&ioc->chip->Doorbell,
1131                 ((MPI_FUNCTION_HOST_PAGEBUF_ACCESS_CONTROL
1132                  <<MPI_DOORBELL_FUNCTION_SHIFT) |
1133                  (access_control_value<<12)));
1134
1135         /* Wait for IOC to clear Doorbell Status bit */
1136         if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1137                 return -2;
1138         }else
1139                 return 0;
1140 }
1141
1142 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1143 /**
1144  *      mpt_host_page_alloc - allocate system memory for the fw
1145  *      @ioc: Pointer to pointer to IOC adapter
1146  *      @ioc_init: Pointer to ioc init config page
1147  *
1148  *      If we already allocated memory in past, then resend the same pointer.
1149  *      Returns 0 for success, non-zero for failure.
1150  */
1151 static int
1152 mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init)
1153 {
1154         char    *psge;
1155         int     flags_length;
1156         u32     host_page_buffer_sz=0;
1157
1158         if(!ioc->HostPageBuffer) {
1159
1160                 host_page_buffer_sz =
1161                     le32_to_cpu(ioc->facts.HostPageBufferSGE.FlagsLength) & 0xFFFFFF;
1162
1163                 if(!host_page_buffer_sz)
1164                         return 0; /* fw doesn't need any host buffers */
1165
1166                 /* spin till we get enough memory */
1167                 while(host_page_buffer_sz > 0) {
1168
1169                         if((ioc->HostPageBuffer = pci_alloc_consistent(
1170                             ioc->pcidev,
1171                             host_page_buffer_sz,
1172                             &ioc->HostPageBuffer_dma)) != NULL) {
1173
1174                                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1175                                     "host_page_buffer @ %p, dma @ %x, sz=%d bytes\n",
1176                                     ioc->name, ioc->HostPageBuffer,
1177                                     (u32)ioc->HostPageBuffer_dma,
1178                                     host_page_buffer_sz));
1179                                 ioc->alloc_total += host_page_buffer_sz;
1180                                 ioc->HostPageBuffer_sz = host_page_buffer_sz;
1181                                 break;
1182                         }
1183
1184                         host_page_buffer_sz -= (4*1024);
1185                 }
1186         }
1187
1188         if(!ioc->HostPageBuffer) {
1189                 printk(MYIOC_s_ERR_FMT
1190                     "Failed to alloc memory for host_page_buffer!\n",
1191                     ioc->name);
1192                 return -999;
1193         }
1194
1195         psge = (char *)&ioc_init->HostPageBufferSGE;
1196         flags_length = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1197             MPI_SGE_FLAGS_SYSTEM_ADDRESS |
1198             MPI_SGE_FLAGS_32_BIT_ADDRESSING |
1199             MPI_SGE_FLAGS_HOST_TO_IOC |
1200             MPI_SGE_FLAGS_END_OF_BUFFER;
1201         if (sizeof(dma_addr_t) == sizeof(u64)) {
1202             flags_length |= MPI_SGE_FLAGS_64_BIT_ADDRESSING;
1203         }
1204         flags_length = flags_length << MPI_SGE_FLAGS_SHIFT;
1205         flags_length |= ioc->HostPageBuffer_sz;
1206         mpt_add_sge(psge, flags_length, ioc->HostPageBuffer_dma);
1207         ioc->facts.HostPageBufferSGE = ioc_init->HostPageBufferSGE;
1208
1209 return 0;
1210 }
1211
1212 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1213 /**
1214  *      mpt_verify_adapter - Given IOC identifier, set pointer to its adapter structure.
1215  *      @iocid: IOC unique identifier (integer)
1216  *      @iocpp: Pointer to pointer to IOC adapter
1217  *
1218  *      Given a unique IOC identifier, set pointer to the associated MPT
1219  *      adapter structure.
1220  *
1221  *      Returns iocid and sets iocpp if iocid is found.
1222  *      Returns -1 if iocid is not found.
1223  */
1224 int
1225 mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp)
1226 {
1227         MPT_ADAPTER *ioc;
1228
1229         list_for_each_entry(ioc,&ioc_list,list) {
1230                 if (ioc->id == iocid) {
1231                         *iocpp =ioc;
1232                         return iocid;
1233                 }
1234         }
1235
1236         *iocpp = NULL;
1237         return -1;
1238 }
1239
1240 /**
1241  *      mpt_get_product_name - returns product string
1242  *      @vendor: pci vendor id
1243  *      @device: pci device id
1244  *      @revision: pci revision id
1245  *      @prod_name: string returned
1246  *
1247  *      Returns product string displayed when driver loads,
1248  *      in /proc/mpt/summary and /sysfs/class/scsi_host/host<X>/version_product
1249  *
1250  **/
1251 static void
1252 mpt_get_product_name(u16 vendor, u16 device, u8 revision, char *prod_name)
1253 {
1254         char *product_str = NULL;
1255
1256         if (vendor == PCI_VENDOR_ID_BROCADE) {
1257                 switch (device)
1258                 {
1259                 case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1260                         switch (revision)
1261                         {
1262                         case 0x00:
1263                                 product_str = "BRE040 A0";
1264                                 break;
1265                         case 0x01:
1266                                 product_str = "BRE040 A1";
1267                                 break;
1268                         default:
1269                                 product_str = "BRE040";
1270                                 break;
1271                         }
1272                         break;
1273                 }
1274                 goto out;
1275         }
1276
1277         switch (device)
1278         {
1279         case MPI_MANUFACTPAGE_DEVICEID_FC909:
1280                 product_str = "LSIFC909 B1";
1281                 break;
1282         case MPI_MANUFACTPAGE_DEVICEID_FC919:
1283                 product_str = "LSIFC919 B0";
1284                 break;
1285         case MPI_MANUFACTPAGE_DEVICEID_FC929:
1286                 product_str = "LSIFC929 B0";
1287                 break;
1288         case MPI_MANUFACTPAGE_DEVICEID_FC919X:
1289                 if (revision < 0x80)
1290                         product_str = "LSIFC919X A0";
1291                 else
1292                         product_str = "LSIFC919XL A1";
1293                 break;
1294         case MPI_MANUFACTPAGE_DEVICEID_FC929X:
1295                 if (revision < 0x80)
1296                         product_str = "LSIFC929X A0";
1297                 else
1298                         product_str = "LSIFC929XL A1";
1299                 break;
1300         case MPI_MANUFACTPAGE_DEVICEID_FC939X:
1301                 product_str = "LSIFC939X A1";
1302                 break;
1303         case MPI_MANUFACTPAGE_DEVICEID_FC949X:
1304                 product_str = "LSIFC949X A1";
1305                 break;
1306         case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1307                 switch (revision)
1308                 {
1309                 case 0x00:
1310                         product_str = "LSIFC949E A0";
1311                         break;
1312                 case 0x01:
1313                         product_str = "LSIFC949E A1";
1314                         break;
1315                 default:
1316                         product_str = "LSIFC949E";
1317                         break;
1318                 }
1319                 break;
1320         case MPI_MANUFACTPAGE_DEVID_53C1030:
1321                 switch (revision)
1322                 {
1323                 case 0x00:
1324                         product_str = "LSI53C1030 A0";
1325                         break;
1326                 case 0x01:
1327                         product_str = "LSI53C1030 B0";
1328                         break;
1329                 case 0x03:
1330                         product_str = "LSI53C1030 B1";
1331                         break;
1332                 case 0x07:
1333                         product_str = "LSI53C1030 B2";
1334                         break;
1335                 case 0x08:
1336                         product_str = "LSI53C1030 C0";
1337                         break;
1338                 case 0x80:
1339                         product_str = "LSI53C1030T A0";
1340                         break;
1341                 case 0x83:
1342                         product_str = "LSI53C1030T A2";
1343                         break;
1344                 case 0x87:
1345                         product_str = "LSI53C1030T A3";
1346                         break;
1347                 case 0xc1:
1348                         product_str = "LSI53C1020A A1";
1349                         break;
1350                 default:
1351                         product_str = "LSI53C1030";
1352                         break;
1353                 }
1354                 break;
1355         case MPI_MANUFACTPAGE_DEVID_1030_53C1035:
1356                 switch (revision)
1357                 {
1358                 case 0x03:
1359                         product_str = "LSI53C1035 A2";
1360                         break;
1361                 case 0x04:
1362                         product_str = "LSI53C1035 B0";
1363                         break;
1364                 default:
1365                         product_str = "LSI53C1035";
1366                         break;
1367                 }
1368                 break;
1369         case MPI_MANUFACTPAGE_DEVID_SAS1064:
1370                 switch (revision)
1371                 {
1372                 case 0x00:
1373                         product_str = "LSISAS1064 A1";
1374                         break;
1375                 case 0x01:
1376                         product_str = "LSISAS1064 A2";
1377                         break;
1378                 case 0x02:
1379                         product_str = "LSISAS1064 A3";
1380                         break;
1381                 case 0x03:
1382                         product_str = "LSISAS1064 A4";
1383                         break;
1384                 default:
1385                         product_str = "LSISAS1064";
1386                         break;
1387                 }
1388                 break;
1389         case MPI_MANUFACTPAGE_DEVID_SAS1064E:
1390                 switch (revision)
1391                 {
1392                 case 0x00:
1393                         product_str = "LSISAS1064E A0";
1394                         break;
1395                 case 0x01:
1396                         product_str = "LSISAS1064E B0";
1397                         break;
1398                 case 0x02:
1399                         product_str = "LSISAS1064E B1";
1400                         break;
1401                 case 0x04:
1402                         product_str = "LSISAS1064E B2";
1403                         break;
1404                 case 0x08:
1405                         product_str = "LSISAS1064E B3";
1406                         break;
1407                 default:
1408                         product_str = "LSISAS1064E";
1409                         break;
1410                 }
1411                 break;
1412         case MPI_MANUFACTPAGE_DEVID_SAS1068:
1413                 switch (revision)
1414                 {
1415                 case 0x00:
1416                         product_str = "LSISAS1068 A0";
1417                         break;
1418                 case 0x01:
1419                         product_str = "LSISAS1068 B0";
1420                         break;
1421                 case 0x02:
1422                         product_str = "LSISAS1068 B1";
1423                         break;
1424                 default:
1425                         product_str = "LSISAS1068";
1426                         break;
1427                 }
1428                 break;
1429         case MPI_MANUFACTPAGE_DEVID_SAS1068E:
1430                 switch (revision)
1431                 {
1432                 case 0x00:
1433                         product_str = "LSISAS1068E A0";
1434                         break;
1435                 case 0x01:
1436                         product_str = "LSISAS1068E B0";
1437                         break;
1438                 case 0x02:
1439                         product_str = "LSISAS1068E B1";
1440                         break;
1441                 case 0x04:
1442                         product_str = "LSISAS1068E B2";
1443                         break;
1444                 case 0x08:
1445                         product_str = "LSISAS1068E B3";
1446                         break;
1447                 default:
1448                         product_str = "LSISAS1068E";
1449                         break;
1450                 }
1451                 break;
1452         case MPI_MANUFACTPAGE_DEVID_SAS1078:
1453                 switch (revision)
1454                 {
1455                 case 0x00:
1456                         product_str = "LSISAS1078 A0";
1457                         break;
1458                 case 0x01:
1459                         product_str = "LSISAS1078 B0";
1460                         break;
1461                 case 0x02:
1462                         product_str = "LSISAS1078 C0";
1463                         break;
1464                 case 0x03:
1465                         product_str = "LSISAS1078 C1";
1466                         break;
1467                 case 0x04:
1468                         product_str = "LSISAS1078 C2";
1469                         break;
1470                 default:
1471                         product_str = "LSISAS1078";
1472                         break;
1473                 }
1474                 break;
1475         }
1476
1477  out:
1478         if (product_str)
1479                 sprintf(prod_name, "%s", product_str);
1480 }
1481
1482 /**
1483  *      mpt_mapresources - map in memory mapped io
1484  *      @ioc: Pointer to pointer to IOC adapter
1485  *
1486  **/
1487 static int
1488 mpt_mapresources(MPT_ADAPTER *ioc)
1489 {
1490         u8              __iomem *mem;
1491         int              ii;
1492         unsigned long    mem_phys;
1493         unsigned long    port;
1494         u32              msize;
1495         u32              psize;
1496         u8               revision;
1497         int              r = -ENODEV;
1498         struct pci_dev *pdev;
1499
1500         pdev = ioc->pcidev;
1501         ioc->bars = pci_select_bars(pdev, IORESOURCE_MEM);
1502         if (pci_enable_device_mem(pdev)) {
1503                 printk(MYIOC_s_ERR_FMT "pci_enable_device_mem() "
1504                     "failed\n", ioc->name);
1505                 return r;
1506         }
1507         if (pci_request_selected_regions(pdev, ioc->bars, "mpt")) {
1508                 printk(MYIOC_s_ERR_FMT "pci_request_selected_regions() with "
1509                     "MEM failed\n", ioc->name);
1510                 return r;
1511         }
1512
1513         pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1514
1515         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)
1516             && !pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
1517                 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
1518                     ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
1519                     ioc->name));
1520         } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
1521             && !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
1522                 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
1523                     ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
1524                     ioc->name));
1525         } else {
1526                 printk(MYIOC_s_WARN_FMT "no suitable DMA mask for %s\n",
1527                     ioc->name, pci_name(pdev));
1528                 pci_release_selected_regions(pdev, ioc->bars);
1529                 return r;
1530         }
1531
1532         mem_phys = msize = 0;
1533         port = psize = 0;
1534         for (ii = 0; ii < DEVICE_COUNT_RESOURCE; ii++) {
1535                 if (pci_resource_flags(pdev, ii) & PCI_BASE_ADDRESS_SPACE_IO) {
1536                         if (psize)
1537                                 continue;
1538                         /* Get I/O space! */
1539                         port = pci_resource_start(pdev, ii);
1540                         psize = pci_resource_len(pdev, ii);
1541                 } else {
1542                         if (msize)
1543                                 continue;
1544                         /* Get memmap */
1545                         mem_phys = pci_resource_start(pdev, ii);
1546                         msize = pci_resource_len(pdev, ii);
1547                 }
1548         }
1549         ioc->mem_size = msize;
1550
1551         mem = NULL;
1552         /* Get logical ptr for PciMem0 space */
1553         /*mem = ioremap(mem_phys, msize);*/
1554         mem = ioremap(mem_phys, msize);
1555         if (mem == NULL) {
1556                 printk(MYIOC_s_ERR_FMT ": ERROR - Unable to map adapter"
1557                         " memory!\n", ioc->name);
1558                 return -EINVAL;
1559         }
1560         ioc->memmap = mem;
1561         dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "mem = %p, mem_phys = %lx\n",
1562             ioc->name, mem, mem_phys));
1563
1564         ioc->mem_phys = mem_phys;
1565         ioc->chip = (SYSIF_REGS __iomem *)mem;
1566
1567         /* Save Port IO values in case we need to do downloadboot */
1568         ioc->pio_mem_phys = port;
1569         ioc->pio_chip = (SYSIF_REGS __iomem *)port;
1570
1571         return 0;
1572 }
1573
1574 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1575 /**
1576  *      mpt_attach - Install a PCI intelligent MPT adapter.
1577  *      @pdev: Pointer to pci_dev structure
1578  *      @id: PCI device ID information
1579  *
1580  *      This routine performs all the steps necessary to bring the IOC of
1581  *      a MPT adapter to a OPERATIONAL state.  This includes registering
1582  *      memory regions, registering the interrupt, and allocating request
1583  *      and reply memory pools.
1584  *
1585  *      This routine also pre-fetches the LAN MAC address of a Fibre Channel
1586  *      MPT adapter.
1587  *
1588  *      Returns 0 for success, non-zero for failure.
1589  *
1590  *      TODO: Add support for polled controllers
1591  */
1592 int
1593 mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
1594 {
1595         MPT_ADAPTER     *ioc;
1596         u8               cb_idx;
1597         int              r = -ENODEV;
1598         u8               revision;
1599         u8               pcixcmd;
1600         static int       mpt_ids = 0;
1601 #ifdef CONFIG_PROC_FS
1602         struct proc_dir_entry *dent, *ent;
1603 #endif
1604
1605         ioc = kzalloc(sizeof(MPT_ADAPTER), GFP_ATOMIC);
1606         if (ioc == NULL) {
1607                 printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
1608                 return -ENOMEM;
1609         }
1610
1611         ioc->id = mpt_ids++;
1612         sprintf(ioc->name, "ioc%d", ioc->id);
1613
1614         /*
1615          * set initial debug level
1616          * (refer to mptdebug.h)
1617          *
1618          */
1619         ioc->debug_level = mpt_debug_level;
1620         if (mpt_debug_level)
1621                 printk(KERN_INFO "mpt_debug_level=%xh\n", mpt_debug_level);
1622
1623         dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": mpt_adapter_install\n", ioc->name));
1624
1625         ioc->pcidev = pdev;
1626         if (mpt_mapresources(ioc)) {
1627                 kfree(ioc);
1628                 return r;
1629         }
1630
1631         ioc->alloc_total = sizeof(MPT_ADAPTER);
1632         ioc->req_sz = MPT_DEFAULT_FRAME_SIZE;           /* avoid div by zero! */
1633         ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
1634
1635         ioc->pcidev = pdev;
1636         ioc->diagPending = 0;
1637         spin_lock_init(&ioc->diagLock);
1638         spin_lock_init(&ioc->initializing_hba_lock);
1639
1640         /* Initialize the event logging.
1641          */
1642         ioc->eventTypes = 0;    /* None */
1643         ioc->eventContext = 0;
1644         ioc->eventLogSize = 0;
1645         ioc->events = NULL;
1646
1647 #ifdef MFCNT
1648         ioc->mfcnt = 0;
1649 #endif
1650
1651         ioc->cached_fw = NULL;
1652
1653         /* Initilize SCSI Config Data structure
1654          */
1655         memset(&ioc->spi_data, 0, sizeof(SpiCfgData));
1656
1657         /* Initialize the running configQ head.
1658          */
1659         INIT_LIST_HEAD(&ioc->configQ);
1660
1661         /* Initialize the fc rport list head.
1662          */
1663         INIT_LIST_HEAD(&ioc->fc_rports);
1664
1665         /* Find lookup slot. */
1666         INIT_LIST_HEAD(&ioc->list);
1667
1668
1669         /* Initialize workqueue */
1670         INIT_DELAYED_WORK(&ioc->fault_reset_work, mpt_fault_reset_work);
1671         spin_lock_init(&ioc->fault_reset_work_lock);
1672
1673         snprintf(ioc->reset_work_q_name, sizeof(ioc->reset_work_q_name),
1674                  "mpt_poll_%d", ioc->id);
1675         ioc->reset_work_q =
1676                 create_singlethread_workqueue(ioc->reset_work_q_name);
1677         if (!ioc->reset_work_q) {
1678                 printk(MYIOC_s_ERR_FMT "Insufficient memory to add adapter!\n",
1679                     ioc->name);
1680                 pci_release_selected_regions(pdev, ioc->bars);
1681                 kfree(ioc);
1682                 return -ENOMEM;
1683         }
1684
1685         dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "facts @ %p, pfacts[0] @ %p\n",
1686             ioc->name, &ioc->facts, &ioc->pfacts[0]));
1687
1688         pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1689         mpt_get_product_name(pdev->vendor, pdev->device, revision, ioc->prod_name);
1690
1691         switch (pdev->device)
1692         {
1693         case MPI_MANUFACTPAGE_DEVICEID_FC939X:
1694         case MPI_MANUFACTPAGE_DEVICEID_FC949X:
1695                 ioc->errata_flag_1064 = 1;
1696         case MPI_MANUFACTPAGE_DEVICEID_FC909:
1697         case MPI_MANUFACTPAGE_DEVICEID_FC929:
1698         case MPI_MANUFACTPAGE_DEVICEID_FC919:
1699         case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1700                 ioc->bus_type = FC;
1701                 break;
1702
1703         case MPI_MANUFACTPAGE_DEVICEID_FC929X:
1704                 if (revision < XL_929) {
1705                         /* 929X Chip Fix. Set Split transactions level
1706                         * for PCIX. Set MOST bits to zero.
1707                         */
1708                         pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1709                         pcixcmd &= 0x8F;
1710                         pci_write_config_byte(pdev, 0x6a, pcixcmd);
1711                 } else {
1712                         /* 929XL Chip Fix. Set MMRBC to 0x08.
1713                         */
1714                         pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1715                         pcixcmd |= 0x08;
1716                         pci_write_config_byte(pdev, 0x6a, pcixcmd);
1717                 }
1718                 ioc->bus_type = FC;
1719                 break;
1720
1721         case MPI_MANUFACTPAGE_DEVICEID_FC919X:
1722                 /* 919X Chip Fix. Set Split transactions level
1723                  * for PCIX. Set MOST bits to zero.
1724                  */
1725                 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1726                 pcixcmd &= 0x8F;
1727                 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1728                 ioc->bus_type = FC;
1729                 break;
1730
1731         case MPI_MANUFACTPAGE_DEVID_53C1030:
1732                 /* 1030 Chip Fix. Disable Split transactions
1733                  * for PCIX. Set MOST bits to zero if Rev < C0( = 8).
1734                  */
1735                 if (revision < C0_1030) {
1736                         pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1737                         pcixcmd &= 0x8F;
1738                         pci_write_config_byte(pdev, 0x6a, pcixcmd);
1739                 }
1740
1741         case MPI_MANUFACTPAGE_DEVID_1030_53C1035:
1742                 ioc->bus_type = SPI;
1743                 break;
1744
1745         case MPI_MANUFACTPAGE_DEVID_SAS1064:
1746         case MPI_MANUFACTPAGE_DEVID_SAS1068:
1747                 ioc->errata_flag_1064 = 1;
1748
1749         case MPI_MANUFACTPAGE_DEVID_SAS1064E:
1750         case MPI_MANUFACTPAGE_DEVID_SAS1068E:
1751         case MPI_MANUFACTPAGE_DEVID_SAS1078:
1752                 ioc->bus_type = SAS;
1753         }
1754
1755         if (mpt_msi_enable == -1) {
1756                 /* Enable on SAS, disable on FC and SPI */
1757                 if (ioc->bus_type == SAS)
1758                         ioc->msi_enable = 1;
1759                 else
1760                         ioc->msi_enable = 0;
1761         } else
1762                 /* follow flag: 0 - disable; 1 - enable */
1763                 ioc->msi_enable = mpt_msi_enable;
1764
1765         if (ioc->errata_flag_1064)
1766                 pci_disable_io_access(pdev);
1767
1768         spin_lock_init(&ioc->FreeQlock);
1769
1770         /* Disable all! */
1771         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1772         ioc->active = 0;
1773         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1774
1775         /* Set IOC ptr in the pcidev's driver data. */
1776         pci_set_drvdata(ioc->pcidev, ioc);
1777
1778         /* Set lookup ptr. */
1779         list_add_tail(&ioc->list, &ioc_list);
1780
1781         /* Check for "bound ports" (929, 929X, 1030, 1035) to reduce redundant resets.
1782          */
1783         mpt_detect_bound_ports(ioc, pdev);
1784
1785         if ((r = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
1786             CAN_SLEEP)) != 0){
1787                 printk(MYIOC_s_ERR_FMT "didn't initialize properly! (%d)\n",
1788                     ioc->name, r);
1789
1790                 list_del(&ioc->list);
1791                 if (ioc->alt_ioc)
1792                         ioc->alt_ioc->alt_ioc = NULL;
1793                 iounmap(ioc->memmap);
1794                 if (r != -5)
1795                         pci_release_selected_regions(pdev, ioc->bars);
1796
1797                 destroy_workqueue(ioc->reset_work_q);
1798                 ioc->reset_work_q = NULL;
1799
1800                 kfree(ioc);
1801                 pci_set_drvdata(pdev, NULL);
1802                 return r;
1803         }
1804
1805         /* call per device driver probe entry point */
1806         for(cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
1807                 if(MptDeviceDriverHandlers[cb_idx] &&
1808                   MptDeviceDriverHandlers[cb_idx]->probe) {
1809                         MptDeviceDriverHandlers[cb_idx]->probe(pdev,id);
1810                 }
1811         }
1812
1813 #ifdef CONFIG_PROC_FS
1814         /*
1815          *  Create "/proc/mpt/iocN" subdirectory entry for each MPT adapter.
1816          */
1817         dent = proc_mkdir(ioc->name, mpt_proc_root_dir);
1818         if (dent) {
1819                 ent = create_proc_entry("info", S_IFREG|S_IRUGO, dent);
1820                 if (ent) {
1821                         ent->read_proc = procmpt_iocinfo_read;
1822                         ent->data = ioc;
1823                 }
1824                 ent = create_proc_entry("summary", S_IFREG|S_IRUGO, dent);
1825                 if (ent) {
1826                         ent->read_proc = procmpt_summary_read;
1827                         ent->data = ioc;
1828                 }
1829         }
1830 #endif
1831
1832         if (!ioc->alt_ioc)
1833                 queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
1834                         msecs_to_jiffies(MPT_POLLING_INTERVAL));
1835
1836         return 0;
1837 }
1838
1839 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1840 /**
1841  *      mpt_detach - Remove a PCI intelligent MPT adapter.
1842  *      @pdev: Pointer to pci_dev structure
1843  */
1844
1845 void
1846 mpt_detach(struct pci_dev *pdev)
1847 {
1848         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1849         char pname[32];
1850         u8 cb_idx;
1851         unsigned long flags;
1852         struct workqueue_struct *wq;
1853
1854         /*
1855          * Stop polling ioc for fault condition
1856          */
1857         spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
1858         wq = ioc->reset_work_q;
1859         ioc->reset_work_q = NULL;
1860         spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
1861         cancel_delayed_work(&ioc->fault_reset_work);
1862         destroy_workqueue(wq);
1863
1864
1865         sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/summary", ioc->name);
1866         remove_proc_entry(pname, NULL);
1867         sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/info", ioc->name);
1868         remove_proc_entry(pname, NULL);
1869         sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s", ioc->name);
1870         remove_proc_entry(pname, NULL);
1871
1872         /* call per device driver remove entry point */
1873         for(cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
1874                 if(MptDeviceDriverHandlers[cb_idx] &&
1875                   MptDeviceDriverHandlers[cb_idx]->remove) {
1876                         MptDeviceDriverHandlers[cb_idx]->remove(pdev);
1877                 }
1878         }
1879
1880         /* Disable interrupts! */
1881         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1882
1883         ioc->active = 0;
1884         synchronize_irq(pdev->irq);
1885
1886         /* Clear any lingering interrupt */
1887         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1888
1889         CHIPREG_READ32(&ioc->chip->IntStatus);
1890
1891         mpt_adapter_dispose(ioc);
1892
1893         pci_set_drvdata(pdev, NULL);
1894 }
1895
1896 /**************************************************************************
1897  * Power Management
1898  */
1899 #ifdef CONFIG_PM
1900 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1901 /**
1902  *      mpt_suspend - Fusion MPT base driver suspend routine.
1903  *      @pdev: Pointer to pci_dev structure
1904  *      @state: new state to enter
1905  */
1906 int
1907 mpt_suspend(struct pci_dev *pdev, pm_message_t state)
1908 {
1909         u32 device_state;
1910         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1911
1912         device_state = pci_choose_state(pdev, state);
1913         printk(MYIOC_s_INFO_FMT "pci-suspend: pdev=0x%p, slot=%s, Entering "
1914             "operating state [D%d]\n", ioc->name, pdev, pci_name(pdev),
1915             device_state);
1916
1917         /* put ioc into READY_STATE */
1918         if(SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, CAN_SLEEP)) {
1919                 printk(MYIOC_s_ERR_FMT
1920                 "pci-suspend:  IOC msg unit reset failed!\n", ioc->name);
1921         }
1922
1923         /* disable interrupts */
1924         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1925         ioc->active = 0;
1926
1927         /* Clear any lingering interrupt */
1928         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1929
1930         free_irq(ioc->pci_irq, ioc);
1931         if (ioc->msi_enable)
1932                 pci_disable_msi(ioc->pcidev);
1933         ioc->pci_irq = -1;
1934         pci_save_state(pdev);
1935         pci_disable_device(pdev);
1936         pci_release_selected_regions(pdev, ioc->bars);
1937         pci_set_power_state(pdev, device_state);
1938         return 0;
1939 }
1940
1941 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1942 /**
1943  *      mpt_resume - Fusion MPT base driver resume routine.
1944  *      @pdev: Pointer to pci_dev structure
1945  */
1946 int
1947 mpt_resume(struct pci_dev *pdev)
1948 {
1949         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1950         u32 device_state = pdev->current_state;
1951         int recovery_state;
1952         int err;
1953
1954         printk(MYIOC_s_INFO_FMT "pci-resume: pdev=0x%p, slot=%s, Previous "
1955             "operating state [D%d]\n", ioc->name, pdev, pci_name(pdev),
1956             device_state);
1957
1958         pci_set_power_state(pdev, PCI_D0);
1959         pci_enable_wake(pdev, PCI_D0, 0);
1960         pci_restore_state(pdev);
1961         ioc->pcidev = pdev;
1962         err = mpt_mapresources(ioc);
1963         if (err)
1964                 return err;
1965
1966         printk(MYIOC_s_INFO_FMT "pci-resume: ioc-state=0x%x,doorbell=0x%x\n",
1967             ioc->name, (mpt_GetIocState(ioc, 1) >> MPI_IOC_STATE_SHIFT),
1968             CHIPREG_READ32(&ioc->chip->Doorbell));
1969
1970         /*
1971          * Errata workaround for SAS pci express:
1972          * Upon returning to the D0 state, the contents of the doorbell will be
1973          * stale data, and this will incorrectly signal to the host driver that
1974          * the firmware is ready to process mpt commands.   The workaround is
1975          * to issue a diagnostic reset.
1976          */
1977         if (ioc->bus_type == SAS && (pdev->device ==
1978             MPI_MANUFACTPAGE_DEVID_SAS1068E || pdev->device ==
1979             MPI_MANUFACTPAGE_DEVID_SAS1064E)) {
1980                 if (KickStart(ioc, 1, CAN_SLEEP) < 0) {
1981                         printk(MYIOC_s_WARN_FMT "pci-resume: Cannot recover\n",
1982                             ioc->name);
1983                         goto out;
1984                 }
1985         }
1986
1987         /* bring ioc to operational state */
1988         printk(MYIOC_s_INFO_FMT "Sending mpt_do_ioc_recovery\n", ioc->name);
1989         recovery_state = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
1990                                                  CAN_SLEEP);
1991         if (recovery_state != 0)
1992                 printk(MYIOC_s_WARN_FMT "pci-resume: Cannot recover, "
1993                     "error:[%x]\n", ioc->name, recovery_state);
1994         else
1995                 printk(MYIOC_s_INFO_FMT
1996                     "pci-resume: success\n", ioc->name);
1997  out:
1998         return 0;
1999
2000 }
2001 #endif
2002
2003 static int
2004 mpt_signal_reset(u8 index, MPT_ADAPTER *ioc, int reset_phase)
2005 {
2006         if ((MptDriverClass[index] == MPTSPI_DRIVER &&
2007              ioc->bus_type != SPI) ||
2008             (MptDriverClass[index] == MPTFC_DRIVER &&
2009              ioc->bus_type != FC) ||
2010             (MptDriverClass[index] == MPTSAS_DRIVER &&
2011              ioc->bus_type != SAS))
2012                 /* make sure we only call the relevant reset handler
2013                  * for the bus */
2014                 return 0;
2015         return (MptResetHandlers[index])(ioc, reset_phase);
2016 }
2017
2018 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2019 /**
2020  *      mpt_do_ioc_recovery - Initialize or recover MPT adapter.
2021  *      @ioc: Pointer to MPT adapter structure
2022  *      @reason: Event word / reason
2023  *      @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
2024  *
2025  *      This routine performs all the steps necessary to bring the IOC
2026  *      to a OPERATIONAL state.
2027  *
2028  *      This routine also pre-fetches the LAN MAC address of a Fibre Channel
2029  *      MPT adapter.
2030  *
2031  *      Returns:
2032  *               0 for success
2033  *              -1 if failed to get board READY
2034  *              -2 if READY but IOCFacts Failed
2035  *              -3 if READY but PrimeIOCFifos Failed
2036  *              -4 if READY but IOCInit Failed
2037  *              -5 if failed to enable_device and/or request_selected_regions
2038  *              -6 if failed to upload firmware
2039  */
2040 static int
2041 mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
2042 {
2043         int      hard_reset_done = 0;
2044         int      alt_ioc_ready = 0;
2045         int      hard;
2046         int      rc=0;
2047         int      ii;
2048         u8       cb_idx;
2049         int      handlers;
2050         int      ret = 0;
2051         int      reset_alt_ioc_active = 0;
2052         int      irq_allocated = 0;
2053         u8      *a;
2054
2055         printk(MYIOC_s_INFO_FMT "Initiating %s\n", ioc->name,
2056             reason == MPT_HOSTEVENT_IOC_BRINGUP ? "bringup" : "recovery");
2057
2058         /* Disable reply interrupts (also blocks FreeQ) */
2059         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
2060         ioc->active = 0;
2061
2062         if (ioc->alt_ioc) {
2063                 if (ioc->alt_ioc->active)
2064                         reset_alt_ioc_active = 1;
2065
2066                 /* Disable alt-IOC's reply interrupts (and FreeQ) for a bit ... */
2067                 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, 0xFFFFFFFF);
2068                 ioc->alt_ioc->active = 0;
2069         }
2070
2071         hard = 1;
2072         if (reason == MPT_HOSTEVENT_IOC_BRINGUP)
2073                 hard = 0;
2074
2075         if ((hard_reset_done = MakeIocReady(ioc, hard, sleepFlag)) < 0) {
2076                 if (hard_reset_done == -4) {
2077                         printk(MYIOC_s_WARN_FMT "Owned by PEER..skipping!\n",
2078                             ioc->name);
2079
2080                         if (reset_alt_ioc_active && ioc->alt_ioc) {
2081                                 /* (re)Enable alt-IOC! (reply interrupt, FreeQ) */
2082                                 dprintk(ioc, printk(MYIOC_s_INFO_FMT
2083                                     "alt_ioc reply irq re-enabled\n", ioc->alt_ioc->name));
2084                                 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
2085                                 ioc->alt_ioc->active = 1;
2086                         }
2087
2088                 } else {
2089                         printk(MYIOC_s_WARN_FMT "NOT READY!\n", ioc->name);
2090                 }
2091                 return -1;
2092         }
2093
2094         /* hard_reset_done = 0 if a soft reset was performed
2095          * and 1 if a hard reset was performed.
2096          */
2097         if (hard_reset_done && reset_alt_ioc_active && ioc->alt_ioc) {
2098                 if ((rc = MakeIocReady(ioc->alt_ioc, 0, sleepFlag)) == 0)
2099                         alt_ioc_ready = 1;
2100                 else
2101                         printk(MYIOC_s_WARN_FMT "alt_ioc not ready!\n", ioc->alt_ioc->name);
2102         }
2103
2104         for (ii=0; ii<5; ii++) {
2105                 /* Get IOC facts! Allow 5 retries */
2106                 if ((rc = GetIocFacts(ioc, sleepFlag, reason)) == 0)
2107                         break;
2108         }
2109
2110
2111         if (ii == 5) {
2112                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2113                     "Retry IocFacts failed rc=%x\n", ioc->name, rc));
2114                 ret = -2;
2115         } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2116                 MptDisplayIocCapabilities(ioc);
2117         }
2118
2119         if (alt_ioc_ready) {
2120                 if ((rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason)) != 0) {
2121                         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2122                             "Initial Alt IocFacts failed rc=%x\n", ioc->name, rc));
2123                         /* Retry - alt IOC was initialized once
2124                          */
2125                         rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason);
2126                 }
2127                 if (rc) {
2128                         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2129                             "Retry Alt IocFacts failed rc=%x\n", ioc->name, rc));
2130                         alt_ioc_ready = 0;
2131                         reset_alt_ioc_active = 0;
2132                 } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2133                         MptDisplayIocCapabilities(ioc->alt_ioc);
2134                 }
2135         }
2136
2137         if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP) &&
2138             (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)) {
2139                 pci_release_selected_regions(ioc->pcidev, ioc->bars);
2140                 ioc->bars = pci_select_bars(ioc->pcidev, IORESOURCE_MEM |
2141                     IORESOURCE_IO);
2142                 if (pci_enable_device(ioc->pcidev))
2143                         return -5;
2144                 if (pci_request_selected_regions(ioc->pcidev, ioc->bars,
2145                         "mpt"))
2146                         return -5;
2147         }
2148
2149         /*
2150          * Device is reset now. It must have de-asserted the interrupt line
2151          * (if it was asserted) and it should be safe to register for the
2152          * interrupt now.
2153          */
2154         if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
2155                 ioc->pci_irq = -1;
2156                 if (ioc->pcidev->irq) {
2157                         if (ioc->msi_enable && !pci_enable_msi(ioc->pcidev))
2158                                 printk(MYIOC_s_INFO_FMT "PCI-MSI enabled\n",
2159                                     ioc->name);
2160                         else
2161                                 ioc->msi_enable = 0;
2162                         rc = request_irq(ioc->pcidev->irq, mpt_interrupt,
2163                             IRQF_SHARED, ioc->name, ioc);
2164                         if (rc < 0) {
2165                                 printk(MYIOC_s_ERR_FMT "Unable to allocate "
2166                                     "interrupt %d!\n", ioc->name, ioc->pcidev->irq);
2167                                 if (ioc->msi_enable)
2168                                         pci_disable_msi(ioc->pcidev);
2169                                 return -EBUSY;
2170                         }
2171                         irq_allocated = 1;
2172                         ioc->pci_irq = ioc->pcidev->irq;
2173                         pci_set_master(ioc->pcidev);            /* ?? */
2174                         dprintk(ioc, printk(MYIOC_s_INFO_FMT "installed at interrupt "
2175                             "%d\n", ioc->name, ioc->pcidev->irq));
2176                 }
2177         }
2178
2179         /* Prime reply & request queues!
2180          * (mucho alloc's) Must be done prior to
2181          * init as upper addresses are needed for init.
2182          * If fails, continue with alt-ioc processing
2183          */
2184         if ((ret == 0) && ((rc = PrimeIocFifos(ioc)) != 0))
2185                 ret = -3;
2186
2187         /* May need to check/upload firmware & data here!
2188          * If fails, continue with alt-ioc processing
2189          */
2190         if ((ret == 0) && ((rc = SendIocInit(ioc, sleepFlag)) != 0))
2191                 ret = -4;
2192 // NEW!
2193         if (alt_ioc_ready && ((rc = PrimeIocFifos(ioc->alt_ioc)) != 0)) {
2194                 printk(MYIOC_s_WARN_FMT ": alt_ioc (%d) FIFO mgmt alloc!\n",
2195                     ioc->alt_ioc->name, rc);
2196                 alt_ioc_ready = 0;
2197                 reset_alt_ioc_active = 0;
2198         }
2199
2200         if (alt_ioc_ready) {
2201                 if ((rc = SendIocInit(ioc->alt_ioc, sleepFlag)) != 0) {
2202                         alt_ioc_ready = 0;
2203                         reset_alt_ioc_active = 0;
2204                         printk(MYIOC_s_WARN_FMT "alt_ioc (%d) init failure!\n",
2205                             ioc->alt_ioc->name, rc);
2206                 }
2207         }
2208
2209         if (reason == MPT_HOSTEVENT_IOC_BRINGUP){
2210                 if (ioc->upload_fw) {
2211                         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2212                             "firmware upload required!\n", ioc->name));
2213
2214                         /* Controller is not operational, cannot do upload
2215                          */
2216                         if (ret == 0) {
2217                                 rc = mpt_do_upload(ioc, sleepFlag);
2218                                 if (rc == 0) {
2219                                         if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
2220                                                 /*
2221                                                  * Maintain only one pointer to FW memory
2222                                                  * so there will not be two attempt to
2223                                                  * downloadboot onboard dual function
2224                                                  * chips (mpt_adapter_disable,
2225                                                  * mpt_diag_reset)
2226                                                  */
2227                                                 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2228                                                     "mpt_upload:  alt_%s has cached_fw=%p \n",
2229                                                     ioc->name, ioc->alt_ioc->name, ioc->alt_ioc->cached_fw));
2230                                                 ioc->cached_fw = NULL;
2231                                         }
2232                                 } else {
2233                                         printk(MYIOC_s_WARN_FMT
2234                                             "firmware upload failure!\n", ioc->name);
2235                                         ret = -6;
2236                                 }
2237                         }
2238                 }
2239         }
2240
2241         if (ret == 0) {
2242                 /* Enable! (reply interrupt) */
2243                 CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
2244                 ioc->active = 1;
2245         }
2246
2247         if (reset_alt_ioc_active && ioc->alt_ioc) {
2248                 /* (re)Enable alt-IOC! (reply interrupt) */
2249                 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "alt_ioc reply irq re-enabled\n",
2250                     ioc->alt_ioc->name));
2251                 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
2252                 ioc->alt_ioc->active = 1;
2253         }
2254
2255         /*  Enable MPT base driver management of EventNotification
2256          *  and EventAck handling.
2257          */
2258         if ((ret == 0) && (!ioc->facts.EventState))
2259                 (void) SendEventNotification(ioc, 1);   /* 1=Enable EventNotification */
2260
2261         if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
2262                 (void) SendEventNotification(ioc->alt_ioc, 1);  /* 1=Enable EventNotification */
2263
2264         /*      Add additional "reason" check before call to GetLanConfigPages
2265          *      (combined with GetIoUnitPage2 call).  This prevents a somewhat
2266          *      recursive scenario; GetLanConfigPages times out, timer expired
2267          *      routine calls HardResetHandler, which calls into here again,
2268          *      and we try GetLanConfigPages again...
2269          */
2270         if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
2271
2272                 /*
2273                  * Initalize link list for inactive raid volumes.
2274                  */
2275                 mutex_init(&ioc->raid_data.inactive_list_mutex);
2276                 INIT_LIST_HEAD(&ioc->raid_data.inactive_list);
2277
2278                 if (ioc->bus_type == SAS) {
2279
2280                         /* clear persistency table */
2281                         if(ioc->facts.IOCExceptions &
2282                             MPI_IOCFACTS_EXCEPT_PERSISTENT_TABLE_FULL) {
2283                                 ret = mptbase_sas_persist_operation(ioc,
2284                                     MPI_SAS_OP_CLEAR_NOT_PRESENT);
2285                                 if(ret != 0)
2286                                         goto out;
2287                         }
2288
2289                         /* Find IM volumes
2290                          */
2291                         mpt_findImVolumes(ioc);
2292
2293                 } else if (ioc->bus_type == FC) {
2294                         if ((ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) &&
2295                             (ioc->lan_cnfg_page0.Header.PageLength == 0)) {
2296                                 /*
2297                                  *  Pre-fetch the ports LAN MAC address!
2298                                  *  (LANPage1_t stuff)
2299                                  */
2300                                 (void) GetLanConfigPages(ioc);
2301                                 a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
2302                                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2303                                     "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
2304                                     ioc->name, a[5], a[4], a[3], a[2], a[1], a[0]));
2305
2306                         }
2307                 } else {
2308                         /* Get NVRAM and adapter maximums from SPP 0 and 2
2309                          */
2310                         mpt_GetScsiPortSettings(ioc, 0);
2311
2312                         /* Get version and length of SDP 1
2313                          */
2314                         mpt_readScsiDevicePageHeaders(ioc, 0);
2315
2316                         /* Find IM volumes
2317                          */
2318                         if (ioc->facts.MsgVersion >= MPI_VERSION_01_02)
2319                                 mpt_findImVolumes(ioc);
2320
2321                         /* Check, and possibly reset, the coalescing value
2322                          */
2323                         mpt_read_ioc_pg_1(ioc);
2324
2325                         mpt_read_ioc_pg_4(ioc);
2326                 }
2327
2328                 GetIoUnitPage2(ioc);
2329                 mpt_get_manufacturing_pg_0(ioc);
2330         }
2331
2332         /*
2333          * Call each currently registered protocol IOC reset handler
2334          * with post-reset indication.
2335          * NOTE: If we're doing _IOC_BRINGUP, there can be no
2336          * MptResetHandlers[] registered yet.
2337          */
2338         if (hard_reset_done) {
2339                 rc = handlers = 0;
2340                 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
2341                         if ((ret == 0) && MptResetHandlers[cb_idx]) {
2342                                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2343                                     "Calling IOC post_reset handler #%d\n",
2344                                     ioc->name, cb_idx));
2345                                 rc += mpt_signal_reset(cb_idx, ioc, MPT_IOC_POST_RESET);
2346                                 handlers++;
2347                         }
2348
2349                         if (alt_ioc_ready && MptResetHandlers[cb_idx]) {
2350                                 drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2351                                     "Calling IOC post_reset handler #%d\n",
2352                                     ioc->alt_ioc->name, cb_idx));
2353                                 rc += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_POST_RESET);
2354                                 handlers++;
2355                         }
2356                 }
2357                 /* FIXME?  Examine results here? */
2358         }
2359
2360  out:
2361         if ((ret != 0) && irq_allocated) {
2362                 free_irq(ioc->pci_irq, ioc);
2363                 if (ioc->msi_enable)
2364                         pci_disable_msi(ioc->pcidev);
2365         }
2366         return ret;
2367 }
2368
2369 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2370 /**
2371  *      mpt_detect_bound_ports - Search for matching PCI bus/dev_function
2372  *      @ioc: Pointer to MPT adapter structure
2373  *      @pdev: Pointer to (struct pci_dev) structure
2374  *
2375  *      Search for PCI bus/dev_function which matches
2376  *      PCI bus/dev_function (+/-1) for newly discovered 929,
2377  *      929X, 1030 or 1035.
2378  *
2379  *      If match on PCI dev_function +/-1 is found, bind the two MPT adapters
2380  *      using alt_ioc pointer fields in their %MPT_ADAPTER structures.
2381  */
2382 static void
2383 mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev)
2384 {
2385         struct pci_dev *peer=NULL;
2386         unsigned int slot = PCI_SLOT(pdev->devfn);
2387         unsigned int func = PCI_FUNC(pdev->devfn);
2388         MPT_ADAPTER *ioc_srch;
2389
2390         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PCI device %s devfn=%x/%x,"
2391             " searching for devfn match on %x or %x\n",
2392             ioc->name, pci_name(pdev), pdev->bus->number,
2393             pdev->devfn, func-1, func+1));
2394
2395         peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func-1));
2396         if (!peer) {
2397                 peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func+1));
2398                 if (!peer)
2399                         return;
2400         }
2401
2402         list_for_each_entry(ioc_srch, &ioc_list, list) {
2403                 struct pci_dev *_pcidev = ioc_srch->pcidev;
2404                 if (_pcidev == peer) {
2405                         /* Paranoia checks */
2406                         if (ioc->alt_ioc != NULL) {
2407                                 printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
2408                                         ioc->name, ioc->alt_ioc->name);
2409                                 break;
2410                         } else if (ioc_srch->alt_ioc != NULL) {
2411                                 printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
2412                                         ioc_srch->name, ioc_srch->alt_ioc->name);
2413                                 break;
2414                         }
2415                         dprintk(ioc, printk(MYIOC_s_INFO_FMT "FOUND! binding to %s\n",
2416                                 ioc->name, ioc_srch->name));
2417                         ioc_srch->alt_ioc = ioc;
2418                         ioc->alt_ioc = ioc_srch;
2419                 }
2420         }
2421         pci_dev_put(peer);
2422 }
2423
2424 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2425 /**
2426  *      mpt_adapter_disable - Disable misbehaving MPT adapter.
2427  *      @ioc: Pointer to MPT adapter structure
2428  */
2429 static void
2430 mpt_adapter_disable(MPT_ADAPTER *ioc)
2431 {
2432         int sz;
2433         int ret;
2434
2435         if (ioc->cached_fw != NULL) {
2436                 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: Pushing FW onto "
2437                     "adapter\n", __func__, ioc->name));
2438                 if ((ret = mpt_downloadboot(ioc, (MpiFwHeader_t *)
2439                     ioc->cached_fw, CAN_SLEEP)) < 0) {
2440                         printk(MYIOC_s_WARN_FMT
2441                             ": firmware downloadboot failure (%d)!\n",
2442                             ioc->name, ret);
2443                 }
2444         }
2445
2446         /* Disable adapter interrupts! */
2447         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
2448         ioc->active = 0;
2449         /* Clear any lingering interrupt */
2450         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
2451
2452         if (ioc->alloc != NULL) {
2453                 sz = ioc->alloc_sz;
2454                 dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "free  @ %p, sz=%d bytes\n",
2455                     ioc->name, ioc->alloc, ioc->alloc_sz));
2456                 pci_free_consistent(ioc->pcidev, sz,
2457                                 ioc->alloc, ioc->alloc_dma);
2458                 ioc->reply_frames = NULL;
2459                 ioc->req_frames = NULL;
2460                 ioc->alloc = NULL;
2461                 ioc->alloc_total -= sz;
2462         }
2463
2464         if (ioc->sense_buf_pool != NULL) {
2465                 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
2466                 pci_free_consistent(ioc->pcidev, sz,
2467                                 ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
2468                 ioc->sense_buf_pool = NULL;
2469                 ioc->alloc_total -= sz;
2470         }
2471
2472         if (ioc->events != NULL){
2473                 sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
2474                 kfree(ioc->events);
2475                 ioc->events = NULL;
2476                 ioc->alloc_total -= sz;
2477         }
2478
2479         mpt_free_fw_memory(ioc);
2480
2481         kfree(ioc->spi_data.nvram);
2482         mpt_inactive_raid_list_free(ioc);
2483         kfree(ioc->raid_data.pIocPg2);
2484         kfree(ioc->raid_data.pIocPg3);
2485         ioc->spi_data.nvram = NULL;
2486         ioc->raid_data.pIocPg3 = NULL;
2487
2488         if (ioc->spi_data.pIocPg4 != NULL) {
2489                 sz = ioc->spi_data.IocPg4Sz;
2490                 pci_free_consistent(ioc->pcidev, sz,
2491                         ioc->spi_data.pIocPg4,
2492                         ioc->spi_data.IocPg4_dma);
2493                 ioc->spi_data.pIocPg4 = NULL;
2494                 ioc->alloc_total -= sz;
2495         }
2496
2497         if (ioc->ReqToChain != NULL) {
2498                 kfree(ioc->ReqToChain);
2499                 kfree(ioc->RequestNB);
2500                 ioc->ReqToChain = NULL;
2501         }
2502
2503         kfree(ioc->ChainToChain);
2504         ioc->ChainToChain = NULL;
2505
2506         if (ioc->HostPageBuffer != NULL) {
2507                 if((ret = mpt_host_page_access_control(ioc,
2508                     MPI_DB_HPBAC_FREE_BUFFER, NO_SLEEP)) != 0) {
2509                         printk(MYIOC_s_ERR_FMT
2510                            "host page buffers free failed (%d)!\n",
2511                             ioc->name, ret);
2512                 }
2513                 dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "HostPageBuffer free  @ %p, sz=%d bytes\n",
2514                         ioc->name, ioc->HostPageBuffer, ioc->HostPageBuffer_sz));
2515                 pci_free_consistent(ioc->pcidev, ioc->HostPageBuffer_sz,
2516                     ioc->HostPageBuffer, ioc->HostPageBuffer_dma);
2517                 ioc->HostPageBuffer = NULL;
2518                 ioc->HostPageBuffer_sz = 0;
2519                 ioc->alloc_total -= ioc->HostPageBuffer_sz;
2520         }
2521 }
2522
2523 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2524 /**
2525  *      mpt_adapter_dispose - Free all resources associated with an MPT adapter
2526  *      @ioc: Pointer to MPT adapter structure
2527  *
2528  *      This routine unregisters h/w resources and frees all alloc'd memory
2529  *      associated with a MPT adapter structure.
2530  */
2531 static void
2532 mpt_adapter_dispose(MPT_ADAPTER *ioc)
2533 {
2534         int sz_first, sz_last;
2535
2536         if (ioc == NULL)
2537                 return;
2538
2539         sz_first = ioc->alloc_total;
2540
2541         mpt_adapter_disable(ioc);
2542
2543         if (ioc->pci_irq != -1) {
2544                 free_irq(ioc->pci_irq, ioc);
2545                 if (ioc->msi_enable)
2546                         pci_disable_msi(ioc->pcidev);
2547                 ioc->pci_irq = -1;
2548         }
2549
2550         if (ioc->memmap != NULL) {
2551                 iounmap(ioc->memmap);
2552                 ioc->memmap = NULL;
2553         }
2554
2555         pci_disable_device(ioc->pcidev);
2556         pci_release_selected_regions(ioc->pcidev, ioc->bars);
2557
2558 #if defined(CONFIG_MTRR) && 0
2559         if (ioc->mtrr_reg > 0) {
2560                 mtrr_del(ioc->mtrr_reg, 0, 0);
2561                 dprintk(ioc, printk(MYIOC_s_INFO_FMT "MTRR region de-registered\n", ioc->name));
2562         }
2563 #endif
2564
2565         /*  Zap the adapter lookup ptr!  */
2566         list_del(&ioc->list);
2567
2568         sz_last = ioc->alloc_total;
2569         dprintk(ioc, printk(MYIOC_s_INFO_FMT "free'd %d of %d bytes\n",
2570             ioc->name, sz_first-sz_last+(int)sizeof(*ioc), sz_first));
2571
2572         if (ioc->alt_ioc)
2573                 ioc->alt_ioc->alt_ioc = NULL;
2574
2575         kfree(ioc);
2576 }
2577
2578 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2579 /**
2580  *      MptDisplayIocCapabilities - Disply IOC's capabilities.
2581  *      @ioc: Pointer to MPT adapter structure
2582  */
2583 static void
2584 MptDisplayIocCapabilities(MPT_ADAPTER *ioc)
2585 {
2586         int i = 0;
2587
2588         printk(KERN_INFO "%s: ", ioc->name);
2589         if (ioc->prod_name)
2590                 printk("%s: ", ioc->prod_name);
2591         printk("Capabilities={");
2592
2593         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) {
2594                 printk("Initiator");
2595                 i++;
2596         }
2597
2598         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2599                 printk("%sTarget", i ? "," : "");
2600                 i++;
2601         }
2602
2603         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
2604                 printk("%sLAN", i ? "," : "");
2605                 i++;
2606         }
2607
2608 #if 0
2609         /*
2610          *  This would probably evoke more questions than it's worth
2611          */
2612         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2613                 printk("%sLogBusAddr", i ? "," : "");
2614                 i++;
2615         }
2616 #endif
2617
2618         printk("}\n");
2619 }
2620
2621 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2622 /**
2623  *      MakeIocReady - Get IOC to a READY state, using KickStart if needed.
2624  *      @ioc: Pointer to MPT_ADAPTER structure
2625  *      @force: Force hard KickStart of IOC
2626  *      @sleepFlag: Specifies whether the process can sleep
2627  *
2628  *      Returns:
2629  *               1 - DIAG reset and READY
2630  *               0 - READY initially OR soft reset and READY
2631  *              -1 - Any failure on KickStart
2632  *              -2 - Msg Unit Reset Failed
2633  *              -3 - IO Unit Reset Failed
2634  *              -4 - IOC owned by a PEER
2635  */
2636 static int
2637 MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag)
2638 {
2639         u32      ioc_state;
2640         int      statefault = 0;
2641         int      cntdn;
2642         int      hard_reset_done = 0;
2643         int      r;
2644         int      ii;
2645         int      whoinit;
2646
2647         /* Get current [raw] IOC state  */
2648         ioc_state = mpt_GetIocState(ioc, 0);
2649         dhsprintk(ioc, printk(MYIOC_s_INFO_FMT "MakeIocReady [raw] state=%08x\n", ioc->name, ioc_state));
2650
2651         /*
2652          *      Check to see if IOC got left/stuck in doorbell handshake
2653          *      grip of death.  If so, hard reset the IOC.
2654          */
2655         if (ioc_state & MPI_DOORBELL_ACTIVE) {
2656                 statefault = 1;
2657                 printk(MYIOC_s_WARN_FMT "Unexpected doorbell active!\n",
2658                                 ioc->name);
2659         }
2660
2661         /* Is it already READY? */
2662         if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY)
2663                 return 0;
2664
2665         /*
2666          *      Check to see if IOC is in FAULT state.
2667          */
2668         if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
2669                 statefault = 2;
2670                 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state!!!\n",
2671                     ioc->name);
2672                 printk(MYIOC_s_WARN_FMT "           FAULT code = %04xh\n",
2673                     ioc->name, ioc_state & MPI_DOORBELL_DATA_MASK);
2674         }
2675
2676         /*
2677          *      Hmmm...  Did it get left operational?
2678          */
2679         if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_OPERATIONAL) {
2680                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOC operational unexpected\n",
2681                                 ioc->name));
2682
2683                 /* Check WhoInit.
2684                  * If PCI Peer, exit.
2685                  * Else, if no fault conditions are present, issue a MessageUnitReset
2686                  * Else, fall through to KickStart case
2687                  */
2688                 whoinit = (ioc_state & MPI_DOORBELL_WHO_INIT_MASK) >> MPI_DOORBELL_WHO_INIT_SHIFT;
2689                 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
2690                         "whoinit 0x%x statefault %d force %d\n",
2691                         ioc->name, whoinit, statefault, force));
2692                 if (whoinit == MPI_WHOINIT_PCI_PEER)
2693                         return -4;
2694                 else {
2695                         if ((statefault == 0 ) && (force == 0)) {
2696                                 if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) == 0)
2697                                         return 0;
2698                         }
2699                         statefault = 3;
2700                 }
2701         }
2702
2703         hard_reset_done = KickStart(ioc, statefault||force, sleepFlag);
2704         if (hard_reset_done < 0)
2705                 return -1;
2706
2707         /*
2708          *  Loop here waiting for IOC to come READY.
2709          */
2710         ii = 0;
2711         cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 5;     /* 5 seconds */
2712
2713         while ((ioc_state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
2714                 if (ioc_state == MPI_IOC_STATE_OPERATIONAL) {
2715                         /*
2716                          *  BIOS or previous driver load left IOC in OP state.
2717                          *  Reset messaging FIFOs.
2718                          */
2719                         if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) != 0) {
2720                                 printk(MYIOC_s_ERR_FMT "IOC msg unit reset failed!\n", ioc->name);
2721                                 return -2;
2722                         }
2723                 } else if (ioc_state == MPI_IOC_STATE_RESET) {
2724                         /*
2725                          *  Something is wrong.  Try to get IOC back
2726                          *  to a known state.
2727                          */
2728                         if ((r = SendIocReset(ioc, MPI_FUNCTION_IO_UNIT_RESET, sleepFlag)) != 0) {
2729                                 printk(MYIOC_s_ERR_FMT "IO unit reset failed!\n", ioc->name);
2730                                 return -3;
2731                         }
2732                 }
2733
2734                 ii++; cntdn--;
2735                 if (!cntdn) {
2736                         printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
2737                                         ioc->name, (int)((ii+5)/HZ));
2738                         return -ETIME;
2739                 }
2740
2741                 if (sleepFlag == CAN_SLEEP) {
2742                         msleep(1);
2743                 } else {
2744                         mdelay (1);     /* 1 msec delay */
2745                 }
2746
2747         }
2748
2749         if (statefault < 3) {
2750                 printk(MYIOC_s_INFO_FMT "Recovered from %s\n",
2751                                 ioc->name,
2752                                 statefault==1 ? "stuck handshake" : "IOC FAULT");
2753         }
2754
2755         return hard_reset_done;
2756 }
2757
2758 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2759 /**
2760  *      mpt_GetIocState - Get the current state of a MPT adapter.
2761  *      @ioc: Pointer to MPT_ADAPTER structure
2762  *      @cooked: Request raw or cooked IOC state
2763  *
2764  *      Returns all IOC Doorbell register bits if cooked==0, else just the
2765  *      Doorbell bits in MPI_IOC_STATE_MASK.
2766  */
2767 u32
2768 mpt_GetIocState(MPT_ADAPTER *ioc, int cooked)
2769 {
2770         u32 s, sc;
2771
2772         /*  Get!  */
2773         s = CHIPREG_READ32(&ioc->chip->Doorbell);
2774         sc = s & MPI_IOC_STATE_MASK;
2775
2776         /*  Save!  */
2777         ioc->last_state = sc;
2778
2779         return cooked ? sc : s;
2780 }
2781
2782 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2783 /**
2784  *      GetIocFacts - Send IOCFacts request to MPT adapter.
2785  *      @ioc: Pointer to MPT_ADAPTER structure
2786  *      @sleepFlag: Specifies whether the process can sleep
2787  *      @reason: If recovery, only update facts.
2788  *
2789  *      Returns 0 for success, non-zero for failure.
2790  */
2791 static int
2792 GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason)
2793 {
2794         IOCFacts_t               get_facts;
2795         IOCFactsReply_t         *facts;
2796         int                      r;
2797         int                      req_sz;
2798         int                      reply_sz;
2799         int                      sz;
2800         u32                      status, vv;
2801         u8                       shiftFactor=1;
2802
2803         /* IOC *must* NOT be in RESET state! */
2804         if (ioc->last_state == MPI_IOC_STATE_RESET) {
2805                 printk(MYIOC_s_ERR_FMT "Can't get IOCFacts NOT READY! (%08x)\n",
2806                     ioc->name, ioc->last_state );
2807                 return -44;
2808         }
2809
2810         facts = &ioc->facts;
2811
2812         /* Destination (reply area)... */
2813         reply_sz = sizeof(*facts);
2814         memset(facts, 0, reply_sz);
2815
2816         /* Request area (get_facts on the stack right now!) */
2817         req_sz = sizeof(get_facts);
2818         memset(&get_facts, 0, req_sz);
2819
2820         get_facts.Function = MPI_FUNCTION_IOC_FACTS;
2821         /* Assert: All other get_facts fields are zero! */
2822
2823         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2824             "Sending get IocFacts request req_sz=%d reply_sz=%d\n",
2825             ioc->name, req_sz, reply_sz));
2826
2827         /* No non-zero fields in the get_facts request are greater than
2828          * 1 byte in size, so we can just fire it off as is.
2829          */
2830         r = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_facts,
2831                         reply_sz, (u16*)facts, 5 /*seconds*/, sleepFlag);
2832         if (r != 0)
2833                 return r;
2834
2835         /*
2836          * Now byte swap (GRRR) the necessary fields before any further
2837          * inspection of reply contents.
2838          *
2839          * But need to do some sanity checks on MsgLength (byte) field
2840          * to make sure we don't zero IOC's req_sz!
2841          */
2842         /* Did we get a valid reply? */
2843         if (facts->MsgLength > offsetof(IOCFactsReply_t, RequestFrameSize)/sizeof(u32)) {
2844                 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2845                         /*
2846                          * If not been here, done that, save off first WhoInit value
2847                          */
2848                         if (ioc->FirstWhoInit == WHOINIT_UNKNOWN)
2849                                 ioc->FirstWhoInit = facts->WhoInit;
2850                 }
2851
2852                 facts->MsgVersion = le16_to_cpu(facts->MsgVersion);
2853                 facts->MsgContext = le32_to_cpu(facts->MsgContext);
2854                 facts->IOCExceptions = le16_to_cpu(facts->IOCExceptions);
2855                 facts->IOCStatus = le16_to_cpu(facts->IOCStatus);
2856                 facts->IOCLogInfo = le32_to_cpu(facts->IOCLogInfo);
2857                 status = le16_to_cpu(facts->IOCStatus) & MPI_IOCSTATUS_MASK;
2858                 /* CHECKME! IOCStatus, IOCLogInfo */
2859
2860                 facts->ReplyQueueDepth = le16_to_cpu(facts->ReplyQueueDepth);
2861                 facts->RequestFrameSize = le16_to_cpu(facts->RequestFrameSize);
2862
2863                 /*
2864                  * FC f/w version changed between 1.1 and 1.2
2865                  *      Old: u16{Major(4),Minor(4),SubMinor(8)}
2866                  *      New: u32{Major(8),Minor(8),Unit(8),Dev(8)}
2867                  */
2868                 if (facts->MsgVersion < 0x0102) {
2869                         /*
2870                          *      Handle old FC f/w style, convert to new...
2871                          */
2872                         u16      oldv = le16_to_cpu(facts->Reserved_0101_FWVersion);
2873                         facts->FWVersion.Word =
2874                                         ((oldv<<12) & 0xFF000000) |
2875                                         ((oldv<<8)  & 0x000FFF00);
2876                 } else
2877                         facts->FWVersion.Word = le32_to_cpu(facts->FWVersion.Word);
2878
2879                 facts->ProductID = le16_to_cpu(facts->ProductID);
2880                 if ((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
2881                     > MPI_FW_HEADER_PID_PROD_TARGET_SCSI)
2882                         ioc->ir_firmware = 1;
2883                 facts->CurrentHostMfaHighAddr =
2884                                 le32_to_cpu(facts->CurrentHostMfaHighAddr);
2885                 facts->GlobalCredits = le16_to_cpu(facts->GlobalCredits);
2886                 facts->CurrentSenseBufferHighAddr =
2887                                 le32_to_cpu(facts->CurrentSenseBufferHighAddr);
2888                 facts->CurReplyFrameSize =
2889                                 le16_to_cpu(facts->CurReplyFrameSize);
2890                 facts->IOCCapabilities = le32_to_cpu(facts->IOCCapabilities);
2891
2892                 /*
2893                  * Handle NEW (!) IOCFactsReply fields in MPI-1.01.xx
2894                  * Older MPI-1.00.xx struct had 13 dwords, and enlarged
2895                  * to 14 in MPI-1.01.0x.
2896                  */
2897                 if (facts->MsgLength >= (offsetof(IOCFactsReply_t,FWImageSize) + 7)/4 &&
2898                     facts->MsgVersion > 0x0100) {
2899                         facts->FWImageSize = le32_to_cpu(facts->FWImageSize);
2900                 }
2901
2902                 sz = facts->FWImageSize;
2903                 if ( sz & 0x01 )
2904                         sz += 1;
2905                 if ( sz & 0x02 )
2906                         sz += 2;
2907                 facts->FWImageSize = sz;
2908
2909                 if (!facts->RequestFrameSize) {
2910                         /*  Something is wrong!  */
2911                         printk(MYIOC_s_ERR_FMT "IOC reported invalid 0 request size!\n",
2912                                         ioc->name);
2913                         return -55;
2914                 }
2915
2916                 r = sz = facts->BlockSize;
2917                 vv = ((63 / (sz * 4)) + 1) & 0x03;
2918                 ioc->NB_for_64_byte_frame = vv;
2919                 while ( sz )
2920                 {
2921                         shiftFactor++;
2922                         sz = sz >> 1;
2923                 }
2924                 ioc->NBShiftFactor  = shiftFactor;
2925                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2926                     "NB_for_64_byte_frame=%x NBShiftFactor=%x BlockSize=%x\n",
2927                     ioc->name, vv, shiftFactor, r));
2928
2929                 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2930                         /*
2931                          * Set values for this IOC's request & reply frame sizes,
2932                          * and request & reply queue depths...
2933                          */
2934                         ioc->req_sz = min(MPT_DEFAULT_FRAME_SIZE, facts->RequestFrameSize * 4);
2935                         ioc->req_depth = min_t(int, MPT_MAX_REQ_DEPTH, facts->GlobalCredits);
2936                         ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
2937                         ioc->reply_depth = min_t(int, MPT_DEFAULT_REPLY_DEPTH, facts->ReplyQueueDepth);
2938
2939                         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "reply_sz=%3d, reply_depth=%4d\n",
2940                                 ioc->name, ioc->reply_sz, ioc->reply_depth));
2941                         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "req_sz  =%3d, req_depth  =%4d\n",
2942                                 ioc->name, ioc->req_sz, ioc->req_depth));
2943
2944                         /* Get port facts! */
2945                         if ( (r = GetPortFacts(ioc, 0, sleepFlag)) != 0 )
2946                                 return r;
2947                 }
2948         } else {
2949                 printk(MYIOC_s_ERR_FMT
2950                      "Invalid IOC facts reply, msgLength=%d offsetof=%zd!\n",
2951                      ioc->name, facts->MsgLength, (offsetof(IOCFactsReply_t,
2952                      RequestFrameSize)/sizeof(u32)));
2953                 return -66;
2954         }
2955
2956         return 0;
2957 }
2958
2959 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2960 /**
2961  *      GetPortFacts - Send PortFacts request to MPT adapter.
2962  *      @ioc: Pointer to MPT_ADAPTER structure
2963  *      @portnum: Port number
2964  *      @sleepFlag: Specifies whether the process can sleep
2965  *
2966  *      Returns 0 for success, non-zero for failure.
2967  */
2968 static int
2969 GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
2970 {
2971         PortFacts_t              get_pfacts;
2972         PortFactsReply_t        *pfacts;
2973         int                      ii;
2974         int                      req_sz;
2975         int                      reply_sz;
2976         int                      max_id;
2977
2978         /* IOC *must* NOT be in RESET state! */
2979         if (ioc->last_state == MPI_IOC_STATE_RESET) {
2980                 printk(MYIOC_s_ERR_FMT "Can't get PortFacts NOT READY! (%08x)\n",
2981                     ioc->name, ioc->last_state );
2982                 return -4;
2983         }
2984
2985         pfacts = &ioc->pfacts[portnum];
2986
2987         /* Destination (reply area)...  */
2988         reply_sz = sizeof(*pfacts);
2989         memset(pfacts, 0, reply_sz);
2990
2991         /* Request area (get_pfacts on the stack right now!) */
2992         req_sz = sizeof(get_pfacts);
2993         memset(&get_pfacts, 0, req_sz);
2994
2995         get_pfacts.Function = MPI_FUNCTION_PORT_FACTS;
2996         get_pfacts.PortNumber = portnum;
2997         /* Assert: All other get_pfacts fields are zero! */
2998
2999         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending get PortFacts(%d) request\n",
3000                         ioc->name, portnum));
3001
3002         /* No non-zero fields in the get_pfacts request are greater than
3003          * 1 byte in size, so we can just fire it off as is.
3004          */
3005         ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_pfacts,
3006                                 reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
3007         if (ii != 0)
3008                 return ii;
3009
3010         /* Did we get a valid reply? */
3011
3012         /* Now byte swap the necessary fields in the response. */
3013         pfacts->MsgContext = le32_to_cpu(pfacts->MsgContext);
3014         pfacts->IOCStatus = le16_to_cpu(pfacts->IOCStatus);
3015         pfacts->IOCLogInfo = le32_to_cpu(pfacts->IOCLogInfo);
3016         pfacts->MaxDevices = le16_to_cpu(pfacts->MaxDevices);
3017         pfacts->PortSCSIID = le16_to_cpu(pfacts->PortSCSIID);
3018         pfacts->ProtocolFlags = le16_to_cpu(pfacts->ProtocolFlags);
3019         pfacts->MaxPostedCmdBuffers = le16_to_cpu(pfacts->MaxPostedCmdBuffers);
3020         pfacts->MaxPersistentIDs = le16_to_cpu(pfacts->MaxPersistentIDs);
3021         pfacts->MaxLanBuckets = le16_to_cpu(pfacts->MaxLanBuckets);
3022
3023         max_id = (ioc->bus_type == SAS) ? pfacts->PortSCSIID :
3024             pfacts->MaxDevices;
3025         ioc->devices_per_bus = (max_id > 255) ? 256 : max_id;
3026         ioc->number_of_buses = (ioc->devices_per_bus < 256) ? 1 : max_id/256;
3027
3028         /*
3029          * Place all the devices on channels
3030          *
3031          * (for debuging)
3032          */
3033         if (mpt_channel_mapping) {
3034                 ioc->devices_per_bus = 1;
3035                 ioc->number_of_buses = (max_id > 255) ? 255 : max_id;
3036         }
3037
3038         return 0;
3039 }
3040
3041 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3042 /**
3043  *      SendIocInit - Send IOCInit request to MPT adapter.
3044  *      @ioc: Pointer to MPT_ADAPTER structure
3045  *      @sleepFlag: Specifies whether the process can sleep
3046  *
3047  *      Send IOCInit followed by PortEnable to bring IOC to OPERATIONAL state.
3048  *
3049  *      Returns 0 for success, non-zero for failure.
3050  */
3051 static int
3052 SendIocInit(MPT_ADAPTER *ioc, int sleepFlag)
3053 {
3054         IOCInit_t                ioc_init;
3055         MPIDefaultReply_t        init_reply;
3056         u32                      state;
3057         int                      r;
3058         int                      count;
3059         int                      cntdn;
3060
3061         memset(&ioc_init, 0, sizeof(ioc_init));
3062         memset(&init_reply, 0, sizeof(init_reply));
3063
3064         ioc_init.WhoInit = MPI_WHOINIT_HOST_DRIVER;
3065         ioc_init.Function = MPI_FUNCTION_IOC_INIT;
3066
3067         /* If we are in a recovery mode and we uploaded the FW image,
3068          * then this pointer is not NULL. Skip the upload a second time.
3069          * Set this flag if cached_fw set for either IOC.
3070          */
3071         if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
3072                 ioc->upload_fw = 1;
3073         else
3074                 ioc->upload_fw = 0;
3075         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "upload_fw %d facts.Flags=%x\n",
3076                    ioc->name, ioc->upload_fw, ioc->facts.Flags));
3077
3078         ioc_init.MaxDevices = (U8)ioc->devices_per_bus;
3079         ioc_init.MaxBuses = (U8)ioc->number_of_buses;
3080         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "facts.MsgVersion=%x\n",
3081                    ioc->name, ioc->facts.MsgVersion));
3082         if (ioc->facts.MsgVersion >= MPI_VERSION_01_05) {
3083                 // set MsgVersion and HeaderVersion host driver was built with
3084                 ioc_init.MsgVersion = cpu_to_le16(MPI_VERSION);
3085                 ioc_init.HeaderVersion = cpu_to_le16(MPI_HEADER_VERSION);
3086
3087                 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_HOST_PAGE_BUFFER_PERSISTENT) {
3088                         ioc_init.HostPageBufferSGE = ioc->facts.HostPageBufferSGE;
3089                 } else if(mpt_host_page_alloc(ioc, &ioc_init))
3090                         return -99;
3091         }
3092         ioc_init.ReplyFrameSize = cpu_to_le16(ioc->reply_sz);   /* in BYTES */
3093
3094         if (sizeof(dma_addr_t) == sizeof(u64)) {
3095                 /* Save the upper 32-bits of the request
3096                  * (reply) and sense buffers.
3097                  */
3098                 ioc_init.HostMfaHighAddr = cpu_to_le32((u32)((u64)ioc->alloc_dma >> 32));
3099                 ioc_init.SenseBufferHighAddr = cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
3100         } else {
3101                 /* Force 32-bit addressing */
3102                 ioc_init.HostMfaHighAddr = cpu_to_le32(0);
3103                 ioc_init.SenseBufferHighAddr = cpu_to_le32(0);
3104         }
3105
3106         ioc->facts.CurrentHostMfaHighAddr = ioc_init.HostMfaHighAddr;
3107         ioc->facts.CurrentSenseBufferHighAddr = ioc_init.SenseBufferHighAddr;
3108         ioc->facts.MaxDevices = ioc_init.MaxDevices;
3109         ioc->facts.MaxBuses = ioc_init.MaxBuses;
3110
3111         dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending IOCInit (req @ %p)\n",
3112                         ioc->name, &ioc_init));
3113
3114         r = mpt_handshake_req_reply_wait(ioc, sizeof(IOCInit_t), (u32*)&ioc_init,
3115                                 sizeof(MPIDefaultReply_t), (u16*)&init_reply, 10 /*seconds*/, sleepFlag);
3116         if (r != 0) {
3117                 printk(MYIOC_s_ERR_FMT "Sending IOCInit failed(%d)!\n",ioc->name, r);
3118                 return r;
3119         }
3120
3121         /* No need to byte swap the multibyte fields in the reply
3122          * since we don't even look at its contents.
3123          */
3124
3125         dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending PortEnable (req @ %p)\n",
3126                         ioc->name, &ioc_init));
3127
3128         if ((r = SendPortEnable(ioc, 0, sleepFlag)) != 0) {
3129                 printk(MYIOC_s_ERR_FMT "Sending PortEnable failed(%d)!\n",ioc->name, r);
3130                 return r;
3131         }
3132
3133         /* YIKES!  SUPER IMPORTANT!!!
3134          *  Poll IocState until _OPERATIONAL while IOC is doing
3135          *  LoopInit and TargetDiscovery!
3136          */
3137         count = 0;
3138         cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 60;    /* 60 seconds */
3139         state = mpt_GetIocState(ioc, 1);
3140         while (state != MPI_IOC_STATE_OPERATIONAL && --cntdn) {
3141                 if (sleepFlag == CAN_SLEEP) {
3142                         msleep(1);
3143                 } else {
3144                         mdelay(1);
3145                 }
3146
3147                 if (!cntdn) {
3148                         printk(MYIOC_s_ERR_FMT "Wait IOC_OP state timeout(%d)!\n",
3149                                         ioc->name, (int)((count+5)/HZ));
3150                         return -9;
3151                 }
3152
3153                 state = mpt_GetIocState(ioc, 1);
3154                 count++;
3155         }
3156         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wait IOC_OPERATIONAL state (cnt=%d)\n",
3157                         ioc->name, count));
3158
3159         ioc->aen_event_read_flag=0;
3160         return r;
3161 }
3162
3163 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3164 /**
3165  *      SendPortEnable - Send PortEnable request to MPT adapter port.
3166  *      @ioc: Pointer to MPT_ADAPTER structure
3167  *      @portnum: Port number to enable
3168  *      @sleepFlag: Specifies whether the process can sleep
3169  *
3170  *      Send PortEnable to bring IOC to OPERATIONAL state.
3171  *
3172  *      Returns 0 for success, non-zero for failure.
3173  */
3174 static int
3175 SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
3176 {
3177         PortEnable_t             port_enable;
3178         MPIDefaultReply_t        reply_buf;
3179         int      rc;
3180         int      req_sz;
3181         int      reply_sz;
3182
3183         /*  Destination...  */
3184         reply_sz = sizeof(MPIDefaultReply_t);
3185         memset(&reply_buf, 0, reply_sz);
3186
3187         req_sz = sizeof(PortEnable_t);
3188         memset(&port_enable, 0, req_sz);
3189
3190         port_enable.Function = MPI_FUNCTION_PORT_ENABLE;
3191         port_enable.PortNumber = portnum;
3192 /*      port_enable.ChainOffset = 0;            */
3193 /*      port_enable.MsgFlags = 0;               */
3194 /*      port_enable.MsgContext = 0;             */
3195
3196         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Port(%d)Enable (req @ %p)\n",
3197                         ioc->name, portnum, &port_enable));
3198
3199         /* RAID FW may take a long time to enable
3200          */
3201         if (ioc->ir_firmware || ioc->bus_type == SAS) {
3202                 rc = mpt_handshake_req_reply_wait(ioc, req_sz,
3203                 (u32*)&port_enable, reply_sz, (u16*)&reply_buf,
3204                 300 /*seconds*/, sleepFlag);
3205         } else {
3206                 rc = mpt_handshake_req_reply_wait(ioc, req_sz,
3207                 (u32*)&port_enable, reply_sz, (u16*)&reply_buf,
3208                 30 /*seconds*/, sleepFlag);
3209         }
3210         return rc;
3211 }
3212
3213 /**
3214  *      mpt_alloc_fw_memory - allocate firmware memory
3215  *      @ioc: Pointer to MPT_ADAPTER structure
3216  *      @size: total FW bytes
3217  *
3218  *      If memory has already been allocated, the same (cached) value
3219  *      is returned.
3220  *
3221  *      Return 0 if successfull, or non-zero for failure
3222  **/
3223 int
3224 mpt_alloc_fw_memory(MPT_ADAPTER *ioc, int size)
3225 {
3226         int rc;
3227
3228         if (ioc->cached_fw) {
3229                 rc = 0;  /* use already allocated memory */
3230                 goto out;
3231         }
3232         else if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
3233                 ioc->cached_fw = ioc->alt_ioc->cached_fw;  /* use alt_ioc's memory */
3234                 ioc->cached_fw_dma = ioc->alt_ioc->cached_fw_dma;
3235                 rc = 0;
3236                 goto out;
3237         }
3238         ioc->cached_fw = pci_alloc_consistent(ioc->pcidev, size, &ioc->cached_fw_dma);
3239         if (!ioc->cached_fw) {
3240                 printk(MYIOC_s_ERR_FMT "Unable to allocate memory for the cached firmware image!\n",
3241                     ioc->name);
3242                 rc = -1;
3243         } else {
3244                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FW Image  @ %p[%p], sz=%d[%x] bytes\n",
3245                     ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, size, size));
3246                 ioc->alloc_total += size;
3247                 rc = 0;
3248         }
3249  out:
3250         return rc;
3251 }
3252
3253 /**
3254  *      mpt_free_fw_memory - free firmware memory
3255  *      @ioc: Pointer to MPT_ADAPTER structure
3256  *
3257  *      If alt_img is NULL, delete from ioc structure.
3258  *      Else, delete a secondary image in same format.
3259  **/
3260 void
3261 mpt_free_fw_memory(MPT_ADAPTER *ioc)
3262 {
3263         int sz;
3264
3265         if (!ioc->cached_fw)
3266                 return;
3267
3268         sz = ioc->facts.FWImageSize;
3269         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "free_fw_memory: FW Image  @ %p[%p], sz=%d[%x] bytes\n",
3270                  ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
3271         pci_free_consistent(ioc->pcidev, sz, ioc->cached_fw, ioc->cached_fw_dma);
3272         ioc->alloc_total -= sz;
3273         ioc->cached_fw = NULL;
3274 }
3275
3276 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3277 /**
3278  *      mpt_do_upload - Construct and Send FWUpload request to MPT adapter port.
3279  *      @ioc: Pointer to MPT_ADAPTER structure
3280  *      @sleepFlag: Specifies whether the process can sleep
3281  *
3282  *      Returns 0 for success, >0 for handshake failure
3283  *              <0 for fw upload failure.
3284  *
3285  *      Remark: If bound IOC and a successful FWUpload was performed
3286  *      on the bound IOC, the second image is discarded
3287  *      and memory is free'd. Both channels must upload to prevent
3288  *      IOC from running in degraded mode.
3289  */
3290 static int
3291 mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag)
3292 {
3293         u8                       reply[sizeof(FWUploadReply_t)];
3294         FWUpload_t              *prequest;
3295         FWUploadReply_t         *preply;
3296         FWUploadTCSGE_t         *ptcsge;
3297         int                      sgeoffset;
3298         u32                      flagsLength;
3299         int                      ii, sz, reply_sz;
3300         int                      cmdStatus;
3301
3302         /* If the image size is 0, we are done.
3303          */
3304         if ((sz = ioc->facts.FWImageSize) == 0)
3305                 return 0;
3306
3307         if (mpt_alloc_fw_memory(ioc, ioc->facts.FWImageSize) != 0)
3308                 return -ENOMEM;
3309
3310         dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Image  @ %p[%p], sz=%d[%x] bytes\n",
3311             ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
3312
3313         prequest = (sleepFlag == NO_SLEEP) ? kzalloc(ioc->req_sz, GFP_ATOMIC) :
3314             kzalloc(ioc->req_sz, GFP_KERNEL);
3315         if (!prequest) {
3316                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "fw upload failed "
3317                     "while allocating memory \n", ioc->name));
3318                 mpt_free_fw_memory(ioc);
3319                 return -ENOMEM;
3320         }
3321
3322         preply = (FWUploadReply_t *)&reply;
3323
3324         reply_sz = sizeof(reply);
3325         memset(preply, 0, reply_sz);
3326
3327         prequest->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
3328         prequest->Function = MPI_FUNCTION_FW_UPLOAD;
3329
3330         ptcsge = (FWUploadTCSGE_t *) &prequest->SGL;
3331         ptcsge->DetailsLength = 12;
3332         ptcsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
3333         ptcsge->ImageSize = cpu_to_le32(sz);
3334         ptcsge++;
3335
3336         sgeoffset = sizeof(FWUpload_t) - sizeof(SGE_MPI_UNION) + sizeof(FWUploadTCSGE_t);
3337
3338         flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | sz;
3339         mpt_add_sge((char *)ptcsge, flagsLength, ioc->cached_fw_dma);
3340
3341         sgeoffset += sizeof(u32) + sizeof(dma_addr_t);
3342         dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": Sending FW Upload (req @ %p) sgeoffset=%d \n",
3343             ioc->name, prequest, sgeoffset));
3344         DBG_DUMP_FW_REQUEST_FRAME(ioc, (u32 *)prequest);
3345
3346         ii = mpt_handshake_req_reply_wait(ioc, sgeoffset, (u32*)prequest,
3347                                 reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);
3348
3349         dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Upload completed rc=%x \n", ioc->name, ii));
3350
3351         cmdStatus = -EFAULT;
3352         if (ii == 0) {
3353                 /* Handshake transfer was complete and successful.
3354                  * Check the Reply Frame.
3355                  */
3356                 int status, transfer_sz;
3357                 status = le16_to_cpu(preply->IOCStatus);
3358                 if (status == MPI_IOCSTATUS_SUCCESS) {
3359                         transfer_sz = le32_to_cpu(preply->ActualImageSize);
3360                         if (transfer_sz == sz)
3361                                 cmdStatus = 0;
3362                 }
3363         }
3364         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": do_upload cmdStatus=%d \n",
3365                         ioc->name, cmdStatus));
3366
3367
3368         if (cmdStatus) {
3369
3370                 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": fw upload failed, freeing image \n",
3371                         ioc->name));
3372                 mpt_free_fw_memory(ioc);
3373         }
3374         kfree(prequest);
3375
3376         return cmdStatus;
3377 }
3378
3379 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3380 /**
3381  *      mpt_downloadboot - DownloadBoot code
3382  *      @ioc: Pointer to MPT_ADAPTER structure
3383  *      @pFwHeader: Pointer to firmware header info
3384  *      @sleepFlag: Specifies whether the process can sleep
3385  *
3386  *      FwDownloadBoot requires Programmed IO access.
3387  *
3388  *      Returns 0 for success
3389  *              -1 FW Image size is 0
3390  *              -2 No valid cached_fw Pointer
3391  *              <0 for fw upload failure.
3392  */
3393 static int
3394 mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag)
3395 {
3396         MpiExtImageHeader_t     *pExtImage;
3397         u32                      fwSize;
3398         u32                      diag0val;
3399         int                      count;
3400         u32                     *ptrFw;
3401         u32                      diagRwData;
3402         u32                      nextImage;
3403         u32                      load_addr;
3404         u32                      ioc_state=0;
3405
3406         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot: fw size 0x%x (%d), FW Ptr %p\n",
3407                                 ioc->name, pFwHeader->ImageSize, pFwHeader->ImageSize, pFwHeader));
3408
3409         CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3410         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3411         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3412         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3413         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3414         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3415
3416         CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM));
3417
3418         /* wait 1 msec */
3419         if (sleepFlag == CAN_SLEEP) {
3420                 msleep(1);
3421         } else {
3422                 mdelay (1);
3423         }
3424
3425         diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3426         CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
3427
3428         for (count = 0; count < 30; count ++) {
3429                 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3430                 if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
3431                         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RESET_ADAPTER cleared, count=%d\n",
3432                                 ioc->name, count));
3433                         break;
3434                 }
3435                 /* wait .1 sec */
3436                 if (sleepFlag == CAN_SLEEP) {
3437                         msleep (100);
3438                 } else {
3439                         mdelay (100);
3440                 }
3441         }
3442
3443         if ( count == 30 ) {
3444                 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot failed! "
3445                 "Unable to get MPI_DIAG_DRWE mode, diag0val=%x\n",
3446                 ioc->name, diag0val));
3447                 return -3;
3448         }
3449
3450         CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3451         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3452         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3453         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3454         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3455         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3456
3457         /* Set the DiagRwEn and Disable ARM bits */
3458         CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_RW_ENABLE | MPI_DIAG_DISABLE_ARM));
3459
3460         fwSize = (pFwHeader->ImageSize + 3)/4;
3461         ptrFw = (u32 *) pFwHeader;
3462
3463         /* Write the LoadStartAddress to the DiagRw Address Register
3464          * using Programmed IO
3465          */
3466         if (ioc->errata_flag_1064)
3467                 pci_enable_io_access(ioc->pcidev);
3468
3469         CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->LoadStartAddress);
3470         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "LoadStart addr written 0x%x \n",
3471                 ioc->name, pFwHeader->LoadStartAddress));
3472
3473         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write FW Image: 0x%x bytes @ %p\n",
3474                                 ioc->name, fwSize*4, ptrFw));
3475         while (fwSize--) {
3476                 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
3477         }
3478
3479         nextImage = pFwHeader->NextImageHeaderOffset;
3480         while (nextImage) {
3481                 pExtImage = (MpiExtImageHeader_t *) ((char *)pFwHeader + nextImage);
3482
3483                 load_addr = pExtImage->LoadStartAddress;
3484
3485                 fwSize = (pExtImage->ImageSize + 3) >> 2;
3486                 ptrFw = (u32 *)pExtImage;
3487
3488                 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write Ext Image: 0x%x (%d) bytes @ %p load_addr=%x\n",
3489                                                 ioc->name, fwSize*4, fwSize*4, ptrFw, load_addr));
3490                 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, load_addr);
3491
3492                 while (fwSize--) {
3493                         CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
3494                 }
3495                 nextImage = pExtImage->NextImageHeaderOffset;
3496         }
3497
3498         /* Write the IopResetVectorRegAddr */
3499         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Addr=%x! \n", ioc->name,  pFwHeader->IopResetRegAddr));
3500         CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->IopResetRegAddr);
3501
3502         /* Write the IopResetVectorValue */
3503         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Value=%x! \n", ioc->name, pFwHeader->IopResetVectorValue));
3504         CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, pFwHeader->IopResetVectorValue);
3505
3506         /* Clear the internal flash bad bit - autoincrementing register,
3507          * so must do two writes.
3508          */
3509         if (ioc->bus_type == SPI) {
3510                 /*
3511                  * 1030 and 1035 H/W errata, workaround to access
3512                  * the ClearFlashBadSignatureBit
3513                  */
3514                 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
3515                 diagRwData = CHIPREG_PIO_READ32(&ioc->pio_chip->DiagRwData);
3516                 diagRwData |= 0x40000000;
3517                 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
3518                 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, diagRwData);
3519
3520         } else /* if((ioc->bus_type == SAS) || (ioc->bus_type == FC)) */ {
3521                 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3522                 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val |
3523                     MPI_DIAG_CLEAR_FLASH_BAD_SIG);
3524
3525                 /* wait 1 msec */
3526                 if (sleepFlag == CAN_SLEEP) {
3527                         msleep (1);
3528                 } else {
3529                         mdelay (1);
3530                 }
3531         }
3532
3533         if (ioc->errata_flag_1064)
3534                 pci_disable_io_access(ioc->pcidev);
3535
3536         diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3537         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot diag0val=%x, "
3538                 "turning off PREVENT_IOC_BOOT, DISABLE_ARM, RW_ENABLE\n",
3539                 ioc->name, diag0val));
3540         diag0val &= ~(MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM | MPI_DIAG_RW_ENABLE);
3541         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot now diag0val=%x\n",
3542                 ioc->name, diag0val));
3543         CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
3544
3545         /* Write 0xFF to reset the sequencer */
3546         CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3547
3548         if (ioc->bus_type == SAS) {
3549                 ioc_state = mpt_GetIocState(ioc, 0);
3550                 if ( (GetIocFacts(ioc, sleepFlag,
3551                                 MPT_HOSTEVENT_IOC_BRINGUP)) != 0 ) {
3552                         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "GetIocFacts failed: IocState=%x\n",
3553                                         ioc->name, ioc_state));
3554                         return -EFAULT;
3555                 }
3556         }
3557
3558         for (count=0; count<HZ*20; count++) {
3559                 if ((ioc_state = mpt_GetIocState(ioc, 0)) & MPI_IOC_STATE_READY) {
3560                         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3561                                 "downloadboot successful! (count=%d) IocState=%x\n",
3562                                 ioc->name, count, ioc_state));
3563                         if (ioc->bus_type == SAS) {
3564                                 return 0;
3565                         }
3566                         if ((SendIocInit(ioc, sleepFlag)) != 0) {
3567                                 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3568                                         "downloadboot: SendIocInit failed\n",
3569                                         ioc->name));
3570                                 return -EFAULT;
3571                         }
3572                         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3573                                         "downloadboot: SendIocInit successful\n",
3574                                         ioc->name));
3575                         return 0;
3576                 }
3577                 if (sleepFlag == CAN_SLEEP) {
3578                         msleep (10);
3579                 } else {
3580                         mdelay (10);
3581                 }
3582         }
3583         ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3584                 "downloadboot failed! IocState=%x\n",ioc->name, ioc_state));
3585         return -EFAULT;
3586 }
3587
3588 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3589 /**
3590  *      KickStart - Perform hard reset of MPT adapter.
3591  *      @ioc: Pointer to MPT_ADAPTER structure
3592  *      @force: Force hard reset
3593  *      @sleepFlag: Specifies whether the process can sleep
3594  *
3595  *      This routine places MPT adapter in diagnostic mode via the
3596  *      WriteSequence register, and then performs a hard reset of adapter
3597  *      via the Diagnostic register.
3598  *
3599  *      Inputs:   sleepflag - CAN_SLEEP (non-interrupt thread)
3600  *                      or NO_SLEEP (interrupt thread, use mdelay)
3601  *                force - 1 if doorbell active, board fault state
3602  *                              board operational, IOC_RECOVERY or
3603  *                              IOC_BRINGUP and there is an alt_ioc.
3604  *                        0 else
3605  *
3606  *      Returns:
3607  *               1 - hard reset, READY
3608  *               0 - no reset due to History bit, READY
3609  *              -1 - no reset due to History bit but not READY
3610  *                   OR reset but failed to come READY
3611  *              -2 - no reset, could not enter DIAG mode
3612  *              -3 - reset but bad FW bit
3613  */
3614 static int
3615 KickStart(MPT_ADAPTER *ioc, int force, int sleepFlag)
3616 {
3617         int hard_reset_done = 0;
3618         u32 ioc_state=0;
3619         int cnt,cntdn;
3620
3621         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStarting!\n", ioc->name));
3622         if (ioc->bus_type == SPI) {
3623                 /* Always issue a Msg Unit Reset first. This will clear some
3624                  * SCSI bus hang conditions.
3625                  */
3626                 SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag);
3627
3628                 if (sleepFlag == CAN_SLEEP) {
3629                         msleep (1000);
3630                 } else {
3631                         mdelay (1000);
3632                 }
3633         }
3634
3635         hard_reset_done = mpt_diag_reset(ioc, force, sleepFlag);
3636         if (hard_reset_done < 0)
3637                 return hard_reset_done;
3638
3639         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset successful!\n",
3640                 ioc->name));
3641
3642         cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 2;     /* 2 seconds */
3643         for (cnt=0; cnt<cntdn; cnt++) {
3644                 ioc_state = mpt_GetIocState(ioc, 1);
3645                 if ((ioc_state == MPI_IOC_STATE_READY) || (ioc_state == MPI_IOC_STATE_OPERATIONAL)) {
3646                         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStart successful! (cnt=%d)\n",
3647                                         ioc->name, cnt));
3648                         return hard_reset_done;
3649                 }
3650                 if (sleepFlag == CAN_SLEEP) {
3651                         msleep (10);
3652                 } else {
3653                         mdelay (10);
3654                 }
3655         }
3656
3657         dinitprintk(ioc, printk(MYIOC_s_ERR_FMT "Failed to come READY after reset! IocState=%x\n",
3658                 ioc->name, mpt_GetIocState(ioc, 0)));
3659         return -1;
3660 }
3661
3662 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3663 /**
3664  *      mpt_diag_reset - Perform hard reset of the adapter.
3665  *      @ioc: Pointer to MPT_ADAPTER structure
3666  *      @ignore: Set if to honor and clear to ignore
3667  *              the reset history bit
3668  *      @sleepFlag: CAN_SLEEP if called in a non-interrupt thread,
3669  *              else set to NO_SLEEP (use mdelay instead)
3670  *
3671  *      This routine places the adapter in diagnostic mode via the
3672  *      WriteSequence register and then performs a hard reset of adapter
3673  *      via the Diagnostic register. Adapter should be in ready state
3674  *      upon successful completion.
3675  *
3676  *      Returns:  1  hard reset successful
3677  *                0  no reset performed because reset history bit set
3678  *               -2  enabling diagnostic mode failed
3679  *               -3  diagnostic reset failed
3680  */
3681 static int
3682 mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag)
3683 {
3684         u32 diag0val;
3685         u32 doorbell;
3686         int hard_reset_done = 0;
3687         int count = 0;
3688         u32 diag1val = 0;
3689         MpiFwHeader_t *cached_fw;       /* Pointer to FW */
3690
3691         /* Clear any existing interrupts */
3692         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
3693
3694         if (ioc->pcidev->device == MPI_MANUFACTPAGE_DEVID_SAS1078) {
3695                 drsprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: Doorbell=%p; 1078 reset "
3696                         "address=%p\n",  ioc->name, __func__,
3697                         &ioc->chip->Doorbell, &ioc->chip->Reset_1078));
3698                 CHIPREG_WRITE32(&ioc->chip->Reset_1078, 0x07);
3699                 if (sleepFlag == CAN_SLEEP)
3700                         msleep(1);
3701                 else
3702                         mdelay(1);
3703
3704                 for (count = 0; count < 60; count ++) {
3705                         doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
3706                         doorbell &= MPI_IOC_STATE_MASK;
3707
3708                         drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3709                                 "looking for READY STATE: doorbell=%x"
3710                                 " count=%d\n",
3711                                 ioc->name, doorbell, count));
3712                         if (doorbell == MPI_IOC_STATE_READY) {
3713                                 return 1;
3714                         }
3715
3716                         /* wait 1 sec */
3717                         if (sleepFlag == CAN_SLEEP)
3718                                 msleep(1000);
3719                         else
3720                                 mdelay(1000);
3721                 }
3722                 return -1;
3723         }
3724
3725         /* Use "Diagnostic reset" method! (only thing available!) */
3726         diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3727
3728         if (ioc->debug_level & MPT_DEBUG) {
3729                 if (ioc->alt_ioc)
3730                         diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3731                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG1: diag0=%08x, diag1=%08x\n",
3732                         ioc->name, diag0val, diag1val));
3733         }
3734
3735         /* Do the reset if we are told to ignore the reset history
3736          * or if the reset history is 0
3737          */
3738         if (ignore || !(diag0val & MPI_DIAG_RESET_HISTORY)) {
3739                 while ((diag0val & MPI_DIAG_DRWE) == 0) {
3740                         /* Write magic sequence to WriteSequence register
3741                          * Loop until in diagnostic mode
3742                          */
3743                         CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3744                         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3745                         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3746                         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3747                         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3748                         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3749
3750                         /* wait 100 msec */
3751                         if (sleepFlag == CAN_SLEEP) {
3752                                 msleep (100);
3753                         } else {
3754                                 mdelay (100);
3755                         }
3756
3757                         count++;
3758                         if (count > 20) {
3759                                 printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
3760                                                 ioc->name, diag0val);
3761                                 return -2;
3762
3763                         }
3764
3765                         diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3766
3767                         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wrote magic DiagWriteEn sequence (%x)\n",
3768                                         ioc->name, diag0val));
3769                 }
3770
3771                 if (ioc->debug_level & MPT_DEBUG) {
3772                         if (ioc->alt_ioc)
3773                                 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3774                         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG2: diag0=%08x, diag1=%08x\n",
3775                                 ioc->name, diag0val, diag1val));
3776                 }
3777                 /*
3778                  * Disable the ARM (Bug fix)
3779                  *
3780                  */
3781                 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_DISABLE_ARM);
3782                 mdelay(1);
3783
3784                 /*
3785                  * Now hit the reset bit in the Diagnostic register
3786                  * (THE BIG HAMMER!) (Clears DRWE bit).
3787                  */
3788                 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
3789                 hard_reset_done = 1;
3790                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset performed\n",
3791                                 ioc->name));
3792
3793                 /*
3794                  * Call each currently registered protocol IOC reset handler
3795                  * with pre-reset indication.
3796                  * NOTE: If we're doing _IOC_BRINGUP, there can be no
3797                  * MptResetHandlers[] registered yet.
3798                  */
3799                 {
3800                         u8       cb_idx;
3801                         int      r = 0;
3802
3803                         for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
3804                                 if (MptResetHandlers[cb_idx]) {
3805                                         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3806                                                 "Calling IOC pre_reset handler #%d\n",
3807                                                 ioc->name, cb_idx));
3808                                         r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_PRE_RESET);
3809                                         if (ioc->alt_ioc) {
3810                                                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3811                                                         "Calling alt-%s pre_reset handler #%d\n",
3812                                                         ioc->name, ioc->alt_ioc->name, cb_idx));
3813                                                 r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_PRE_RESET);
3814                                         }
3815                                 }
3816                         }
3817                         /* FIXME?  Examine results here? */
3818                 }
3819
3820                 if (ioc->cached_fw)
3821                         cached_fw = (MpiFwHeader_t *)ioc->cached_fw;
3822                 else if (ioc->alt_ioc && ioc->alt_ioc->cached_fw)
3823                         cached_fw = (MpiFwHeader_t *)ioc->alt_ioc->cached_fw;
3824                 else
3825                         cached_fw = NULL;
3826                 if (cached_fw) {
3827                         /* If the DownloadBoot operation fails, the
3828                          * IOC will be left unusable. This is a fatal error
3829                          * case.  _diag_reset will return < 0
3830                          */
3831                         for (count = 0; count < 30; count ++) {
3832                                 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3833                                 if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
3834                                         break;
3835                                 }
3836
3837                                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "cached_fw: diag0val=%x count=%d\n",
3838                                         ioc->name, diag0val, count));
3839                                 /* wait 1 sec */
3840                                 if (sleepFlag == CAN_SLEEP) {
3841                                         msleep (1000);
3842                                 } else {
3843                                         mdelay (1000);
3844                                 }
3845                         }
3846                         if ((count = mpt_downloadboot(ioc, cached_fw, sleepFlag)) < 0) {
3847                                 printk(MYIOC_s_WARN_FMT
3848                                         "firmware downloadboot failure (%d)!\n", ioc->name, count);
3849                         }
3850
3851                 } else {
3852                         /* Wait for FW to reload and for board
3853                          * to go to the READY state.
3854                          * Maximum wait is 60 seconds.
3855                          * If fail, no error will check again
3856                          * with calling program.
3857                          */
3858                         for (count = 0; count < 60; count ++) {
3859                                 doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
3860                                 doorbell &= MPI_IOC_STATE_MASK;
3861
3862                                 if (doorbell == MPI_IOC_STATE_READY) {
3863                                         break;
3864                                 }
3865
3866                                 /* wait 1 sec */
3867                                 if (sleepFlag == CAN_SLEEP) {
3868                                         msleep (1000);
3869                                 } else {
3870                                         mdelay (1000);
3871                                 }
3872                         }
3873                 }
3874         }
3875
3876         diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3877         if (ioc->debug_level & MPT_DEBUG) {
3878                 if (ioc->alt_ioc)
3879                         diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3880                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG3: diag0=%08x, diag1=%08x\n",
3881                         ioc->name, diag0val, diag1val));
3882         }
3883
3884         /* Clear RESET_HISTORY bit!  Place board in the
3885          * diagnostic mode to update the diag register.
3886          */
3887         diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3888         count = 0;
3889         while ((diag0val & MPI_DIAG_DRWE) == 0) {
3890                 /* Write magic sequence to WriteSequence register
3891                  * Loop until in diagnostic mode
3892                  */
3893                 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3894                 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3895                 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3896                 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3897                 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3898                 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3899
3900                 /* wait 100 msec */
3901                 if (sleepFlag == CAN_SLEEP) {
3902                         msleep (100);
3903                 } else {
3904                         mdelay (100);
3905                 }
3906
3907                 count++;
3908                 if (count > 20) {
3909                         printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
3910                                         ioc->name, diag0val);
3911                         break;
3912                 }
3913                 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3914         }
3915         diag0val &= ~MPI_DIAG_RESET_HISTORY;
3916         CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
3917         diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3918         if (diag0val & MPI_DIAG_RESET_HISTORY) {
3919                 printk(MYIOC_s_WARN_FMT "ResetHistory bit failed to clear!\n",
3920                                 ioc->name);
3921         }
3922
3923         /* Disable Diagnostic Mode
3924          */
3925         CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFFFFFFFF);
3926
3927         /* Check FW reload status flags.
3928          */
3929         diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3930         if (diag0val & (MPI_DIAG_FLASH_BAD_SIG | MPI_DIAG_RESET_ADAPTER | MPI_DIAG_DISABLE_ARM)) {
3931                 printk(MYIOC_s_ERR_FMT "Diagnostic reset FAILED! (%02xh)\n",
3932                                 ioc->name, diag0val);
3933                 return -3;
3934         }
3935
3936         if (ioc->debug_level & MPT_DEBUG) {
3937                 if (ioc->alt_ioc)
3938                         diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3939                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG4: diag0=%08x, diag1=%08x\n",
3940                         ioc->name, diag0val, diag1val));
3941         }
3942
3943         /*
3944          * Reset flag that says we've enabled event notification
3945          */
3946         ioc->facts.EventState = 0;
3947
3948         if (ioc->alt_ioc)
3949                 ioc->alt_ioc->facts.EventState = 0;
3950
3951         return hard_reset_done;
3952 }
3953
3954 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3955 /**
3956  *      SendIocReset - Send IOCReset request to MPT adapter.
3957  *      @ioc: Pointer to MPT_ADAPTER structure
3958  *      @reset_type: reset type, expected values are
3959  *      %MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET or %MPI_FUNCTION_IO_UNIT_RESET
3960  *      @sleepFlag: Specifies whether the process can sleep
3961  *
3962  *      Send IOCReset request to the MPT adapter.
3963  *
3964  *      Returns 0 for success, non-zero for failure.
3965  */
3966 static int
3967 SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag)
3968 {
3969         int r;
3970         u32 state;
3971         int cntdn, count;
3972
3973         drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending IOC reset(0x%02x)!\n",
3974                         ioc->name, reset_type));
3975         CHIPREG_WRITE32(&ioc->chip->Doorbell, reset_type<<MPI_DOORBELL_FUNCTION_SHIFT);
3976         if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
3977                 return r;
3978
3979         /* FW ACK'd request, wait for READY state
3980          */
3981         count = 0;
3982         cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 15;    /* 15 seconds */
3983
3984         while ((state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
3985                 cntdn--;
3986                 count++;
3987                 if (!cntdn) {
3988                         if (sleepFlag != CAN_SLEEP)
3989                                 count *= 10;
3990
3991                         printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
3992                             ioc->name, (int)((count+5)/HZ));
3993                         return -ETIME;
3994                 }
3995
3996                 if (sleepFlag == CAN_SLEEP) {
3997                         msleep(1);
3998                 } else {
3999                         mdelay (1);     /* 1 msec delay */
4000                 }
4001         }
4002
4003         /* TODO!
4004          *  Cleanup all event stuff for this IOC; re-issue EventNotification
4005          *  request if needed.
4006          */
4007         if (ioc->facts.Function)
4008                 ioc->facts.EventState = 0;
4009
4010         return 0;
4011 }
4012
4013 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4014 /**
4015  *      initChainBuffers - Allocate memory for and initialize chain buffers
4016  *      @ioc: Pointer to MPT_ADAPTER structure
4017  *
4018  *      Allocates memory for and initializes chain buffers,
4019  *      chain buffer control arrays and spinlock.
4020  */
4021 static int
4022 initChainBuffers(MPT_ADAPTER *ioc)
4023 {
4024         u8              *mem;
4025         int             sz, ii, num_chain;
4026         int             scale, num_sge, numSGE;
4027
4028         /* ReqToChain size must equal the req_depth
4029          * index = req_idx
4030          */
4031         if (ioc->ReqToChain == NULL) {
4032                 sz = ioc->req_depth * sizeof(int);
4033                 mem = kmalloc(sz, GFP_ATOMIC);
4034                 if (mem == NULL)
4035                         return -1;
4036
4037                 ioc->ReqToChain = (int *) mem;
4038                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReqToChain alloc  @ %p, sz=%d bytes\n",
4039                                 ioc->name, mem, sz));
4040                 mem = kmalloc(sz, GFP_ATOMIC);
4041                 if (mem == NULL)
4042                         return -1;
4043
4044                 ioc->RequestNB = (int *) mem;
4045                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestNB alloc  @ %p, sz=%d bytes\n",
4046                                 ioc->name, mem, sz));
4047         }
4048         for (ii = 0; ii < ioc->req_depth; ii++) {
4049                 ioc->ReqToChain[ii] = MPT_HOST_NO_CHAIN;
4050         }
4051
4052         /* ChainToChain size must equal the total number
4053          * of chain buffers to be allocated.
4054          * index = chain_idx
4055          *
4056          * Calculate the number of chain buffers needed(plus 1) per I/O
4057          * then multiply the maximum number of simultaneous cmds
4058          *
4059          * num_sge = num sge in request frame + last chain buffer
4060          * scale = num sge per chain buffer if no chain element
4061          */
4062         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
4063         if (sizeof(dma_addr_t) == sizeof(u64))
4064                 num_sge =  scale + (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
4065         else
4066                 num_sge =  1+ scale + (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
4067
4068         if (sizeof(dma_addr_t) == sizeof(u64)) {
4069                 numSGE = (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
4070                         (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
4071         } else {
4072                 numSGE = 1 + (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
4073                         (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
4074         }
4075         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "num_sge=%d numSGE=%d\n",
4076                 ioc->name, num_sge, numSGE));
4077
4078         if ( numSGE > MPT_SCSI_SG_DEPTH )
4079                 numSGE = MPT_SCSI_SG_DEPTH;
4080
4081         num_chain = 1;
4082         while (numSGE - num_sge > 0) {
4083                 num_chain++;
4084                 num_sge += (scale - 1);
4085         }
4086         num_chain++;
4087
4088         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Now numSGE=%d num_sge=%d num_chain=%d\n",
4089                 ioc->name, numSGE, num_sge, num_chain));
4090
4091         if (ioc->bus_type == SPI)
4092                 num_chain *= MPT_SCSI_CAN_QUEUE;
4093         else
4094                 num_chain *= MPT_FC_CAN_QUEUE;
4095
4096         ioc->num_chain = num_chain;
4097
4098         sz = num_chain * sizeof(int);
4099         if (ioc->ChainToChain == NULL) {
4100                 mem = kmalloc(sz, GFP_ATOMIC);
4101                 if (mem == NULL)
4102                         return -1;
4103
4104                 ioc->ChainToChain = (int *) mem;
4105                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainToChain alloc @ %p, sz=%d bytes\n",
4106                                 ioc->name, mem, sz));
4107         } else {
4108                 mem = (u8 *) ioc->ChainToChain;
4109         }
4110         memset(mem, 0xFF, sz);
4111         return num_chain;
4112 }
4113
4114 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4115 /**
4116  *      PrimeIocFifos - Initialize IOC request and reply FIFOs.
4117  *      @ioc: Pointer to MPT_ADAPTER structure
4118  *
4119  *      This routine allocates memory for the MPT reply and request frame
4120  *      pools (if necessary), and primes the IOC reply FIFO with
4121  *      reply frames.
4122  *
4123  *      Returns 0 for success, non-zero for failure.
4124  */
4125 static int
4126 PrimeIocFifos(MPT_ADAPTER *ioc)
4127 {
4128         MPT_FRAME_HDR *mf;
4129         unsigned long flags;
4130         dma_addr_t alloc_dma;
4131         u8 *mem;
4132         int i, reply_sz, sz, total_size, num_chain;
4133
4134         /*  Prime reply FIFO...  */
4135
4136         if (ioc->reply_frames == NULL) {
4137                 if ( (num_chain = initChainBuffers(ioc)) < 0)
4138                         return -1;
4139
4140                 total_size = reply_sz = (ioc->reply_sz * ioc->reply_depth);
4141                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffer sz=%d bytes, ReplyDepth=%d\n",
4142                                 ioc->name, ioc->reply_sz, ioc->reply_depth));
4143                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffer sz=%d[%x] bytes\n",
4144                                 ioc->name, reply_sz, reply_sz));
4145
4146                 sz = (ioc->req_sz * ioc->req_depth);
4147                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffer sz=%d bytes, RequestDepth=%d\n",
4148                                 ioc->name, ioc->req_sz, ioc->req_depth));
4149                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffer sz=%d[%x] bytes\n",
4150                                 ioc->name, sz, sz));
4151                 total_size += sz;
4152
4153                 sz = num_chain * ioc->req_sz; /* chain buffer pool size */
4154                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffer sz=%d bytes, ChainDepth=%d\n",
4155                                 ioc->name, ioc->req_sz, num_chain));
4156                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffer sz=%d[%x] bytes num_chain=%d\n",
4157                                 ioc->name, sz, sz, num_chain));
4158
4159                 total_size += sz;
4160                 mem = pci_alloc_consistent(ioc->pcidev, total_size, &alloc_dma);
4161                 if (mem == NULL) {
4162                         printk(MYIOC_s_ERR_FMT "Unable to allocate Reply, Request, Chain Buffers!\n",
4163                                 ioc->name);
4164                         goto out_fail;
4165                 }
4166
4167                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Total alloc @ %p[%p], sz=%d[%x] bytes\n",
4168                                 ioc->name, mem, (void *)(ulong)alloc_dma, total_size, total_size));
4169
4170                 memset(mem, 0, total_size);
4171                 ioc->alloc_total += total_size;
4172                 ioc->alloc = mem;
4173                 ioc->alloc_dma = alloc_dma;
4174                 ioc->alloc_sz = total_size;
4175                 ioc->reply_frames = (MPT_FRAME_HDR *) mem;
4176                 ioc->reply_frames_low_dma = (u32) (alloc_dma & 0xFFFFFFFF);
4177
4178                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffers @ %p[%p]\n",
4179                         ioc->name, ioc->reply_frames, (void *)(ulong)alloc_dma));
4180
4181                 alloc_dma += reply_sz;
4182                 mem += reply_sz;
4183
4184                 /*  Request FIFO - WE manage this!  */
4185
4186                 ioc->req_frames = (MPT_FRAME_HDR *) mem;
4187                 ioc->req_frames_dma = alloc_dma;
4188
4189                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffers @ %p[%p]\n",
4190                                 ioc->name, mem, (void *)(ulong)alloc_dma));
4191
4192                 ioc->req_frames_low_dma = (u32) (alloc_dma & 0xFFFFFFFF);
4193
4194 #if defined(CONFIG_MTRR) && 0
4195                 /*
4196                  *  Enable Write Combining MTRR for IOC's memory region.
4197                  *  (at least as much as we can; "size and base must be
4198                  *  multiples of 4 kiB"
4199                  */
4200                 ioc->mtrr_reg = mtrr_add(ioc->req_frames_dma,
4201                                          sz,
4202                                          MTRR_TYPE_WRCOMB, 1);
4203                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MTRR region registered (base:size=%08x:%x)\n",
4204                                 ioc->name, ioc->req_frames_dma, sz));
4205 #endif
4206
4207                 for (i = 0; i < ioc->req_depth; i++) {
4208                         alloc_dma += ioc->req_sz;
4209                         mem += ioc->req_sz;
4210                 }
4211
4212                 ioc->ChainBuffer = mem;
4213                 ioc->ChainBufferDMA = alloc_dma;
4214
4215                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffers @ %p(%p)\n",
4216                         ioc->name, ioc->ChainBuffer, (void *)(ulong)ioc->ChainBufferDMA));
4217
4218                 /* Initialize the free chain Q.
4219                 */
4220
4221                 INIT_LIST_HEAD(&ioc->FreeChainQ);
4222
4223                 /* Post the chain buffers to the FreeChainQ.
4224                 */
4225                 mem = (u8 *)ioc->ChainBuffer;
4226                 for (i=0; i < num_chain; i++) {
4227                         mf = (MPT_FRAME_HDR *) mem;
4228                         list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeChainQ);
4229                         mem += ioc->req_sz;
4230                 }
4231
4232                 /* Initialize Request frames linked list
4233                  */
4234                 alloc_dma = ioc->req_frames_dma;
4235                 mem = (u8 *) ioc->req_frames;
4236
4237                 spin_lock_irqsave(&ioc->FreeQlock, flags);
4238                 INIT_LIST_HEAD(&ioc->FreeQ);
4239                 for (i = 0; i < ioc->req_depth; i++) {
4240                         mf = (MPT_FRAME_HDR *) mem;
4241
4242                         /*  Queue REQUESTs *internally*!  */
4243                         list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
4244
4245                         mem += ioc->req_sz;
4246                 }
4247                 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
4248
4249                 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
4250                 ioc->sense_buf_pool =
4251                         pci_alloc_consistent(ioc->pcidev, sz, &ioc->sense_buf_pool_dma);
4252                 if (ioc->sense_buf_pool == NULL) {
4253                         printk(MYIOC_s_ERR_FMT "Unable to allocate Sense Buffers!\n",
4254                                 ioc->name);
4255                         goto out_fail;
4256                 }
4257
4258                 ioc->sense_buf_low_dma = (u32) (ioc->sense_buf_pool_dma & 0xFFFFFFFF);
4259                 ioc->alloc_total += sz;
4260                 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SenseBuffers @ %p[%p]\n",
4261                         ioc->name, ioc->sense_buf_pool, (void *)(ulong)ioc->sense_buf_pool_dma));
4262
4263         }
4264
4265         /* Post Reply frames to FIFO
4266          */
4267         alloc_dma = ioc->alloc_dma;
4268         dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffers @ %p[%p]\n",
4269                 ioc->name, ioc->reply_frames, (void *)(ulong)alloc_dma));
4270
4271         for (i = 0; i < ioc->reply_depth; i++) {
4272                 /*  Write each address to the IOC!  */
4273                 CHIPREG_WRITE32(&ioc->chip->ReplyFifo, alloc_dma);
4274                 alloc_dma += ioc->reply_sz;
4275         }
4276
4277         return 0;
4278
4279 out_fail:
4280         if (ioc->alloc != NULL) {
4281                 sz = ioc->alloc_sz;
4282                 pci_free_consistent(ioc->pcidev,
4283                                 sz,
4284                                 ioc->alloc, ioc->alloc_dma);
4285                 ioc->reply_frames = NULL;
4286                 ioc->req_frames = NULL;
4287                 ioc->alloc_total -= sz;
4288         }
4289         if (ioc->sense_buf_pool != NULL) {
4290                 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
4291                 pci_free_consistent(ioc->pcidev,
4292                                 sz,
4293                                 ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
4294                 ioc->sense_buf_pool = NULL;
4295         }
4296         return -1;
4297 }
4298
4299 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4300 /**
4301  *      mpt_handshake_req_reply_wait - Send MPT request to and receive reply
4302  *      from IOC via doorbell handshake method.
4303  *      @ioc: Pointer to MPT_ADAPTER structure
4304  *      @reqBytes: Size of the request in bytes
4305  *      @req: Pointer to MPT request frame
4306  *      @replyBytes: Expected size of the reply in bytes
4307  *      @u16reply: Pointer to area where reply should be written
4308  *      @maxwait: Max wait time for a reply (in seconds)
4309  *      @sleepFlag: Specifies whether the process can sleep
4310  *
4311  *      NOTES: It is the callers responsibility to byte-swap fields in the
4312  *      request which are greater than 1 byte in size.  It is also the
4313  *      callers responsibility to byte-swap response fields which are
4314  *      greater than 1 byte in size.
4315  *
4316  *      Returns 0 for success, non-zero for failure.
4317  */
4318 static int
4319 mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes, u32 *req,
4320                 int replyBytes, u16 *u16reply, int maxwait, int sleepFlag)
4321 {
4322         MPIDefaultReply_t *mptReply;
4323         int failcnt = 0;
4324         int t;
4325
4326         /*
4327          * Get ready to cache a handshake reply
4328          */
4329         ioc->hs_reply_idx = 0;
4330         mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
4331         mptReply->MsgLength = 0;
4332
4333         /*
4334          * Make sure there are no doorbells (WRITE 0 to IntStatus reg),
4335          * then tell IOC that we want to handshake a request of N words.
4336          * (WRITE u32val to Doorbell reg).
4337          */
4338         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4339         CHIPREG_WRITE32(&ioc->chip->Doorbell,
4340                         ((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
4341                          ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
4342
4343         /*
4344          * Wait for IOC's doorbell handshake int
4345          */
4346         if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4347                 failcnt++;
4348
4349         dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake request start reqBytes=%d, WaitCnt=%d%s\n",
4350                         ioc->name, reqBytes, t, failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));
4351
4352         /* Read doorbell and check for active bit */
4353         if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
4354                         return -1;
4355
4356         /*
4357          * Clear doorbell int (WRITE 0 to IntStatus reg),
4358          * then wait for IOC to ACKnowledge that it's ready for
4359          * our handshake request.
4360          */
4361         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4362         if (!failcnt && (t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
4363                 failcnt++;
4364
4365         if (!failcnt) {
4366                 int      ii;
4367                 u8      *req_as_bytes = (u8 *) req;
4368
4369                 /*
4370                  * Stuff request words via doorbell handshake,
4371                  * with ACK from IOC for each.
4372                  */
4373                 for (ii = 0; !failcnt && ii < reqBytes/4; ii++) {
4374                         u32 word = ((req_as_bytes[(ii*4) + 0] <<  0) |
4375                                     (req_as_bytes[(ii*4) + 1] <<  8) |
4376                                     (req_as_bytes[(ii*4) + 2] << 16) |
4377                                     (req_as_bytes[(ii*4) + 3] << 24));
4378
4379                         CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
4380                         if ((t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
4381                                 failcnt++;
4382                 }
4383
4384                 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handshake request frame (@%p) header\n", ioc->name, req));
4385                 DBG_DUMP_REQUEST_FRAME_HDR(ioc, (u32 *)req);
4386
4387                 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake request post done, WaitCnt=%d%s\n",
4388                                 ioc->name, t, failcnt ? " - MISSING DOORBELL ACK!" : ""));
4389
4390                 /*
4391                  * Wait for completion of doorbell handshake reply from the IOC
4392                  */
4393                 if (!failcnt && (t = WaitForDoorbellReply(ioc, maxwait, sleepFlag)) < 0)
4394                         failcnt++;
4395
4396                 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake reply count=%d%s\n",
4397                                 ioc->name, t, failcnt ? " - MISSING DOORBELL REPLY!" : ""));
4398
4399                 /*
4400                  * Copy out the cached reply...
4401                  */
4402                 for (ii=0; ii < min(replyBytes/2,mptReply->MsgLength*2); ii++)
4403                         u16reply[ii] = ioc->hs_reply[ii];
4404         } else {
4405                 return -99;
4406         }
4407
4408         return -failcnt;
4409 }
4410
4411 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4412 /**
4413  *      WaitForDoorbellAck - Wait for IOC doorbell handshake acknowledge
4414  *      @ioc: Pointer to MPT_ADAPTER structure
4415  *      @howlong: How long to wait (in seconds)
4416  *      @sleepFlag: Specifies whether the process can sleep
4417  *
4418  *      This routine waits (up to ~2 seconds max) for IOC doorbell
4419  *      handshake ACKnowledge, indicated by the IOP_DOORBELL_STATUS
4420  *      bit in its IntStatus register being clear.
4421  *
4422  *      Returns a negative value on failure, else wait loop count.
4423  */
4424 static int
4425 WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
4426 {
4427         int cntdn;
4428         int count = 0;
4429         u32 intstat=0;
4430
4431         cntdn = 1000 * howlong;
4432
4433         if (sleepFlag == CAN_SLEEP) {
4434                 while (--cntdn) {
4435                         msleep (1);
4436                         intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4437                         if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
4438                                 break;
4439                         count++;
4440                 }
4441         } else {
4442                 while (--cntdn) {
4443                         udelay (1000);
4444                         intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4445                         if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
4446                                 break;
4447                         count++;
4448                 }
4449         }
4450
4451         if (cntdn) {
4452                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell ACK (count=%d)\n",
4453                                 ioc->name, count));
4454                 return count;
4455         }
4456
4457         printk(MYIOC_s_ERR_FMT "Doorbell ACK timeout (count=%d), IntStatus=%x!\n",
4458                         ioc->name, count, intstat);
4459         return -1;
4460 }
4461
4462 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4463 /**
4464  *      WaitForDoorbellInt - Wait for IOC to set its doorbell interrupt bit
4465  *      @ioc: Pointer to MPT_ADAPTER structure
4466  *      @howlong: How long to wait (in seconds)
4467  *      @sleepFlag: Specifies whether the process can sleep
4468  *
4469  *      This routine waits (up to ~2 seconds max) for IOC doorbell interrupt
4470  *      (MPI_HIS_DOORBELL_INTERRUPT) to be set in the IntStatus register.
4471  *
4472  *      Returns a negative value on failure, else wait loop count.
4473  */
4474 static int
4475 WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
4476 {
4477         int cntdn;
4478         int count = 0;
4479         u32 intstat=0;
4480
4481         cntdn = 1000 * howlong;
4482         if (sleepFlag == CAN_SLEEP) {
4483                 while (--cntdn) {
4484                         intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4485                         if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
4486                                 break;
4487                         msleep(1);
4488                         count++;
4489                 }
4490         } else {
4491                 while (--cntdn) {
4492                         intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4493                         if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
4494                                 break;
4495                         udelay (1000);
4496                         count++;
4497                 }
4498         }
4499
4500         if (cntdn) {
4501                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell INT (cnt=%d) howlong=%d\n",
4502                                 ioc->name, count, howlong));
4503                 return count;
4504         }
4505
4506         printk(MYIOC_s_ERR_FMT "Doorbell INT timeout (count=%d), IntStatus=%x!\n",
4507                         ioc->name, count, intstat);
4508         return -1;
4509 }
4510
4511 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4512 /**
4513  *      WaitForDoorbellReply - Wait for and capture an IOC handshake reply.
4514  *      @ioc: Pointer to MPT_ADAPTER structure
4515  *      @howlong: How long to wait (in seconds)
4516  *      @sleepFlag: Specifies whether the process can sleep
4517  *
4518  *      This routine polls the IOC for a handshake reply, 16 bits at a time.
4519  *      Reply is cached to IOC private area large enough to hold a maximum
4520  *      of 128 bytes of reply data.
4521  *
4522  *      Returns a negative value on failure, else size of reply in WORDS.
4523  */
4524 static int
4525 WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
4526 {
4527         int u16cnt = 0;
4528         int failcnt = 0;
4529         int t;
4530         u16 *hs_reply = ioc->hs_reply;
4531         volatile MPIDefaultReply_t *mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
4532         u16 hword;
4533
4534         hs_reply[0] = hs_reply[1] = hs_reply[7] = 0;
4535
4536         /*
4537          * Get first two u16's so we can look at IOC's intended reply MsgLength
4538          */
4539         u16cnt=0;
4540         if ((t = WaitForDoorbellInt(ioc, howlong, sleepFlag)) < 0) {
4541                 failcnt++;
4542         } else {
4543                 hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4544                 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4545                 if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4546                         failcnt++;
4547                 else {
4548                         hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4549                         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4550                 }
4551         }
4552
4553         dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitCnt=%d First handshake reply word=%08x%s\n",
4554                         ioc->name, t, le32_to_cpu(*(u32 *)hs_reply),
4555                         failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));
4556
4557         /*
4558          * If no error (and IOC said MsgLength is > 0), piece together
4559          * reply 16 bits at a time.
4560          */
4561         for (u16cnt=2; !failcnt && u16cnt < (2 * mptReply->MsgLength); u16cnt++) {
4562                 if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4563                         failcnt++;
4564                 hword = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4565                 /* don't overflow our IOC hs_reply[] buffer! */
4566                 if (u16cnt < sizeof(ioc->hs_reply) / sizeof(ioc->hs_reply[0]))
4567                         hs_reply[u16cnt] = hword;
4568                 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4569         }
4570
4571         if (!failcnt && (t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4572                 failcnt++;
4573         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4574
4575         if (failcnt) {
4576                 printk(MYIOC_s_ERR_FMT "Handshake reply failure!\n",
4577                                 ioc->name);
4578                 return -failcnt;
4579         }
4580 #if 0
4581         else if (u16cnt != (2 * mptReply->MsgLength)) {
4582                 return -101;
4583         }
4584         else if ((mptReply->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
4585                 return -102;
4586         }
4587 #endif
4588
4589         dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got Handshake reply:\n", ioc->name));
4590         DBG_DUMP_REPLY_FRAME(ioc, (u32 *)mptReply);
4591
4592         dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell REPLY WaitCnt=%d (sz=%d)\n",
4593                         ioc->name, t, u16cnt/2));
4594         return u16cnt/2;
4595 }
4596
4597 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4598 /**
4599  *      GetLanConfigPages - Fetch LANConfig pages.
4600  *      @ioc: Pointer to MPT_ADAPTER structure
4601  *
4602  *      Return: 0 for success
4603  *      -ENOMEM if no memory available
4604  *              -EPERM if not allowed due to ISR context
4605  *              -EAGAIN if no msg frames currently available
4606  *              -EFAULT for non-successful reply or no reply (timeout)
4607  */
4608 static int
4609 GetLanConfigPages(MPT_ADAPTER *ioc)
4610 {
4611         ConfigPageHeader_t       hdr;
4612         CONFIGPARMS              cfg;
4613         LANPage0_t              *ppage0_alloc;
4614         dma_addr_t               page0_dma;
4615         LANPage1_t              *ppage1_alloc;
4616         dma_addr_t               page1_dma;
4617         int                      rc = 0;
4618         int                      data_sz;
4619         int                      copy_sz;
4620
4621         /* Get LAN Page 0 header */
4622         hdr.PageVersion = 0;
4623         hdr.PageLength = 0;
4624         hdr.PageNumber = 0;
4625         hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
4626         cfg.cfghdr.hdr = &hdr;
4627         cfg.physAddr = -1;
4628         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4629         cfg.dir = 0;
4630         cfg.pageAddr = 0;
4631         cfg.timeout = 0;
4632
4633         if ((rc = mpt_config(ioc, &cfg)) != 0)
4634                 return rc;
4635
4636         if (hdr.PageLength > 0) {
4637                 data_sz = hdr.PageLength * 4;
4638                 ppage0_alloc = (LANPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
4639                 rc = -ENOMEM;
4640                 if (ppage0_alloc) {
4641                         memset((u8 *)ppage0_alloc, 0, data_sz);
4642                         cfg.physAddr = page0_dma;
4643                         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4644
4645                         if ((rc = mpt_config(ioc, &cfg)) == 0) {
4646                                 /* save the data */
4647                                 copy_sz = min_t(int, sizeof(LANPage0_t), data_sz);
4648                                 memcpy(&ioc->lan_cnfg_page0, ppage0_alloc, copy_sz);
4649
4650                         }
4651
4652                         pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);
4653
4654                         /* FIXME!
4655                          *      Normalize endianness of structure data,
4656                          *      by byte-swapping all > 1 byte fields!
4657                          */
4658
4659                 }
4660
4661                 if (rc)
4662                         return rc;
4663         }
4664
4665         /* Get LAN Page 1 header */
4666         hdr.PageVersion = 0;
4667         hdr.PageLength = 0;
4668         hdr.PageNumber = 1;
4669         hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
4670         cfg.cfghdr.hdr = &hdr;
4671         cfg.physAddr = -1;
4672         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4673         cfg.dir = 0;
4674         cfg.pageAddr = 0;
4675
4676         if ((rc = mpt_config(ioc, &cfg)) != 0)
4677                 return rc;
4678
4679         if (hdr.PageLength == 0)
4680                 return 0;
4681
4682         data_sz = hdr.PageLength * 4;
4683         rc = -ENOMEM;
4684         ppage1_alloc = (LANPage1_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page1_dma);
4685         if (ppage1_alloc) {
4686                 memset((u8 *)ppage1_alloc, 0, data_sz);
4687                 cfg.physAddr = page1_dma;
4688                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4689
4690                 if ((rc = mpt_config(ioc, &cfg)) == 0) {
4691                         /* save the data */
4692                         copy_sz = min_t(int, sizeof(LANPage1_t), data_sz);
4693                         memcpy(&ioc->lan_cnfg_page1, ppage1_alloc, copy_sz);
4694                 }
4695
4696                 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage1_alloc, page1_dma);
4697
4698                 /* FIXME!
4699                  *      Normalize endianness of structure data,
4700                  *      by byte-swapping all > 1 byte fields!
4701                  */
4702
4703         }
4704
4705         return rc;
4706 }
4707
4708 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4709 /**
4710  *      mptbase_sas_persist_operation - Perform operation on SAS Persistent Table
4711  *      @ioc: Pointer to MPT_ADAPTER structure
4712  *      @persist_opcode: see below
4713  *
4714  *      MPI_SAS_OP_CLEAR_NOT_PRESENT - Free all persist TargetID mappings for
4715  *              devices not currently present.
4716  *      MPI_SAS_OP_CLEAR_ALL_PERSISTENT - Clear al persist TargetID mappings
4717  *
4718  *      NOTE: Don't use not this function during interrupt time.
4719  *
4720  *      Returns 0 for success, non-zero error
4721  */
4722
4723 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4724 int
4725 mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode)
4726 {
4727         SasIoUnitControlRequest_t       *sasIoUnitCntrReq;
4728         SasIoUnitControlReply_t         *sasIoUnitCntrReply;
4729         MPT_FRAME_HDR                   *mf = NULL;
4730         MPIHeader_t                     *mpi_hdr;
4731
4732
4733         /* insure garbage is not sent to fw */
4734         switch(persist_opcode) {
4735
4736         case MPI_SAS_OP_CLEAR_NOT_PRESENT:
4737         case MPI_SAS_OP_CLEAR_ALL_PERSISTENT:
4738                 break;
4739
4740         default:
4741                 return -1;
4742                 break;
4743         }
4744
4745         printk("%s: persist_opcode=%x\n",__func__, persist_opcode);
4746
4747         /* Get a MF for this command.
4748          */
4749         if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
4750                 printk("%s: no msg frames!\n",__func__);
4751                 return -1;
4752         }
4753
4754         mpi_hdr = (MPIHeader_t *) mf;
4755         sasIoUnitCntrReq = (SasIoUnitControlRequest_t *)mf;
4756         memset(sasIoUnitCntrReq,0,sizeof(SasIoUnitControlRequest_t));
4757         sasIoUnitCntrReq->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
4758         sasIoUnitCntrReq->MsgContext = mpi_hdr->MsgContext;
4759         sasIoUnitCntrReq->Operation = persist_opcode;
4760
4761         init_timer(&ioc->persist_timer);
4762         ioc->persist_timer.data = (unsigned long) ioc;
4763         ioc->persist_timer.function = mpt_timer_expired;
4764         ioc->persist_timer.expires = jiffies + HZ*10 /* 10 sec */;
4765         ioc->persist_wait_done=0;
4766         add_timer(&ioc->persist_timer);
4767         mpt_put_msg_frame(mpt_base_index, ioc, mf);
4768         wait_event(mpt_waitq, ioc->persist_wait_done);
4769
4770         sasIoUnitCntrReply =
4771             (SasIoUnitControlReply_t *)ioc->persist_reply_frame;
4772         if (le16_to_cpu(sasIoUnitCntrReply->IOCStatus) != MPI_IOCSTATUS_SUCCESS) {
4773                 printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
4774                     __func__,
4775                     sasIoUnitCntrReply->IOCStatus,
4776                     sasIoUnitCntrReply->IOCLogInfo);
4777                 return -1;
4778         }
4779
4780         printk("%s: success\n",__func__);
4781         return 0;
4782 }
4783
4784 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4785
4786 static void
4787 mptbase_raid_process_event_data(MPT_ADAPTER *ioc,
4788     MpiEventDataRaid_t * pRaidEventData)
4789 {
4790         int     volume;
4791         int     reason;
4792         int     disk;
4793         int     status;
4794         int     flags;
4795         int     state;
4796
4797         volume  = pRaidEventData->VolumeID;
4798         reason  = pRaidEventData->ReasonCode;
4799         disk    = pRaidEventData->PhysDiskNum;
4800         status  = le32_to_cpu(pRaidEventData->SettingsStatus);
4801         flags   = (status >> 0) & 0xff;
4802         state   = (status >> 8) & 0xff;
4803
4804         if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
4805                 return;
4806         }
4807
4808         if ((reason >= MPI_EVENT_RAID_RC_PHYSDISK_CREATED &&
4809              reason <= MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED) ||
4810             (reason == MPI_EVENT_RAID_RC_SMART_DATA)) {
4811                 printk(MYIOC_s_INFO_FMT "RAID STATUS CHANGE for PhysDisk %d id=%d\n",
4812                         ioc->name, disk, volume);
4813         } else {
4814                 printk(MYIOC_s_INFO_FMT "RAID STATUS CHANGE for VolumeID %d\n",
4815                         ioc->name, volume);
4816         }
4817
4818         switch(reason) {
4819         case MPI_EVENT_RAID_RC_VOLUME_CREATED:
4820                 printk(MYIOC_s_INFO_FMT "  volume has been created\n",
4821                         ioc->name);
4822                 break;
4823
4824         case MPI_EVENT_RAID_RC_VOLUME_DELETED:
4825
4826                 printk(MYIOC_s_INFO_FMT "  volume has been deleted\n",
4827                         ioc->name);
4828                 break;
4829
4830         case MPI_EVENT_RAID_RC_VOLUME_SETTINGS_CHANGED:
4831                 printk(MYIOC_s_INFO_FMT "  volume settings have been changed\n",
4832                         ioc->name);
4833                 break;
4834
4835         case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
4836                 printk(MYIOC_s_INFO_FMT "  volume is now %s%s%s%s\n",
4837                         ioc->name,
4838                         state == MPI_RAIDVOL0_STATUS_STATE_OPTIMAL
4839                          ? "optimal"
4840                          : state == MPI_RAIDVOL0_STATUS_STATE_DEGRADED
4841                           ? "degraded"
4842                           : state == MPI_RAIDVOL0_STATUS_STATE_FAILED
4843                            ? "failed"
4844                            : "state unknown",
4845                         flags & MPI_RAIDVOL0_STATUS_FLAG_ENABLED
4846                          ? ", enabled" : "",
4847                         flags & MPI_RAIDVOL0_STATUS_FLAG_QUIESCED
4848                          ? ", quiesced" : "",
4849                         flags & MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS
4850                          ? ", resync in progress" : "" );
4851                 break;
4852
4853         case MPI_EVENT_RAID_RC_VOLUME_PHYSDISK_CHANGED:
4854                 printk(MYIOC_s_INFO_FMT "  volume membership of PhysDisk %d has changed\n",
4855                         ioc->name, disk);
4856                 break;
4857
4858         case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
4859                 printk(MYIOC_s_INFO_FMT "  PhysDisk has been created\n",
4860                         ioc->name);
4861                 break;
4862
4863         case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
4864                 printk(MYIOC_s_INFO_FMT "  PhysDisk has been deleted\n",
4865                         ioc->name);
4866                 break;
4867
4868         case MPI_EVENT_RAID_RC_PHYSDISK_SETTINGS_CHANGED:
4869                 printk(MYIOC_s_INFO_FMT "  PhysDisk settings have been changed\n",
4870                         ioc->name);
4871                 break;
4872
4873         case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
4874                 printk(MYIOC_s_INFO_FMT "  PhysDisk is now %s%s%s\n",
4875                         ioc->name,
4876                         state == MPI_PHYSDISK0_STATUS_ONLINE
4877                          ? "online"
4878                          : state == MPI_PHYSDISK0_STATUS_MISSING
4879                           ? "missing"
4880                           : state == MPI_PHYSDISK0_STATUS_NOT_COMPATIBLE
4881                            ? "not compatible"
4882                            : state == MPI_PHYSDISK0_STATUS_FAILED
4883                             ? "failed"
4884                             : state == MPI_PHYSDISK0_STATUS_INITIALIZING
4885                              ? "initializing"
4886                              : state == MPI_PHYSDISK0_STATUS_OFFLINE_REQUESTED
4887                               ? "offline requested"
4888                               : state == MPI_PHYSDISK0_STATUS_FAILED_REQUESTED
4889                                ? "failed requested"
4890                                : state == MPI_PHYSDISK0_STATUS_OTHER_OFFLINE
4891                                 ? "offline"
4892                                 : "state unknown",
4893                         flags & MPI_PHYSDISK0_STATUS_FLAG_OUT_OF_SYNC
4894                          ? ", out of sync" : "",
4895                         flags & MPI_PHYSDISK0_STATUS_FLAG_QUIESCED
4896                          ? ", quiesced" : "" );
4897                 break;
4898
4899         case MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED:
4900                 printk(MYIOC_s_INFO_FMT "  Domain Validation needed for PhysDisk %d\n",
4901                         ioc->name, disk);
4902                 break;
4903
4904         case MPI_EVENT_RAID_RC_SMART_DATA:
4905                 printk(MYIOC_s_INFO_FMT "  SMART data received, ASC/ASCQ = %02xh/%02xh\n",
4906                         ioc->name, pRaidEventData->ASC, pRaidEventData->ASCQ);
4907                 break;
4908
4909         case MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED:
4910                 printk(MYIOC_s_INFO_FMT "  replacement of PhysDisk %d has started\n",
4911                         ioc->name, disk);
4912                 break;
4913         }
4914 }
4915
4916 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4917 /**
4918  *      GetIoUnitPage2 - Retrieve BIOS version and boot order information.
4919  *      @ioc: Pointer to MPT_ADAPTER structure
4920  *
4921  *      Returns: 0 for success
4922  *      -ENOMEM if no memory available
4923  *              -EPERM if not allowed due to ISR context
4924  *              -EAGAIN if no msg frames currently available
4925  *              -EFAULT for non-successful reply or no reply (timeout)
4926  */
4927 static int
4928 GetIoUnitPage2(MPT_ADAPTER *ioc)
4929 {
4930         ConfigPageHeader_t       hdr;
4931         CONFIGPARMS              cfg;
4932         IOUnitPage2_t           *ppage_alloc;
4933         dma_addr_t               page_dma;
4934         int                      data_sz;
4935         int                      rc;
4936
4937         /* Get the page header */
4938         hdr.PageVersion = 0;
4939         hdr.PageLength = 0;
4940         hdr.PageNumber = 2;
4941         hdr.PageType = MPI_CONFIG_PAGETYPE_IO_UNIT;
4942         cfg.cfghdr.hdr = &hdr;
4943         cfg.physAddr = -1;
4944         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4945         cfg.dir = 0;
4946         cfg.pageAddr = 0;
4947         cfg.timeout = 0;
4948
4949         if ((rc = mpt_config(ioc, &cfg)) != 0)
4950                 return rc;
4951
4952         if (hdr.PageLength == 0)
4953                 return 0;
4954
4955         /* Read the config page */
4956         data_sz = hdr.PageLength * 4;
4957         rc = -ENOMEM;
4958         ppage_alloc = (IOUnitPage2_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
4959         if (ppage_alloc) {
4960                 memset((u8 *)ppage_alloc, 0, data_sz);
4961                 cfg.physAddr = page_dma;
4962                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4963
4964                 /* If Good, save data */
4965                 if ((rc = mpt_config(ioc, &cfg)) == 0)
4966                         ioc->biosVersion = le32_to_cpu(ppage_alloc->BiosVersion);
4967
4968                 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage_alloc, page_dma);
4969         }
4970
4971         return rc;
4972 }
4973
4974 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4975 /**
4976  *      mpt_GetScsiPortSettings - read SCSI Port Page 0 and 2
4977  *      @ioc: Pointer to a Adapter Strucutre
4978  *      @portnum: IOC port number
4979  *
4980  *      Return: -EFAULT if read of config page header fails
4981  *                      or if no nvram
4982  *      If read of SCSI Port Page 0 fails,
4983  *              NVRAM = MPT_HOST_NVRAM_INVALID  (0xFFFFFFFF)
4984  *              Adapter settings: async, narrow
4985  *              Return 1
4986  *      If read of SCSI Port Page 2 fails,
4987  *              Adapter settings valid
4988  *              NVRAM = MPT_HOST_NVRAM_INVALID  (0xFFFFFFFF)
4989  *              Return 1
4990  *      Else
4991  *              Both valid
4992  *              Return 0
4993  *      CHECK - what type of locking mechanisms should be used????
4994  */
4995 static int
4996 mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
4997 {
4998         u8                      *pbuf;
4999         dma_addr_t               buf_dma;
5000         CONFIGPARMS              cfg;
5001         ConfigPageHeader_t       header;
5002         int                      ii;
5003         int                      data, rc = 0;
5004
5005         /* Allocate memory
5006          */
5007         if (!ioc->spi_data.nvram) {
5008                 int      sz;
5009                 u8      *mem;
5010                 sz = MPT_MAX_SCSI_DEVICES * sizeof(int);
5011                 mem = kmalloc(sz, GFP_ATOMIC);
5012                 if (mem == NULL)
5013                         return -EFAULT;
5014
5015                 ioc->spi_data.nvram = (int *) mem;
5016
5017                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SCSI device NVRAM settings @ %p, sz=%d\n",
5018                         ioc->name, ioc->spi_data.nvram, sz));
5019         }
5020
5021         /* Invalidate NVRAM information
5022          */
5023         for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
5024                 ioc->spi_data.nvram[ii] = MPT_HOST_NVRAM_INVALID;
5025         }
5026
5027         /* Read SPP0 header, allocate memory, then read page.
5028          */
5029         header.PageVersion = 0;
5030         header.PageLength = 0;
5031         header.PageNumber = 0;
5032         header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
5033         cfg.cfghdr.hdr = &header;
5034         cfg.physAddr = -1;
5035         cfg.pageAddr = portnum;
5036         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5037         cfg.dir = 0;
5038         cfg.timeout = 0;        /* use default */
5039         if (mpt_config(ioc, &cfg) != 0)
5040                  return -EFAULT;
5041
5042         if (header.PageLength > 0) {
5043                 pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
5044                 if (pbuf) {
5045                         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5046                         cfg.physAddr = buf_dma;
5047                         if (mpt_config(ioc, &cfg) != 0) {
5048                                 ioc->spi_data.maxBusWidth = MPT_NARROW;
5049                                 ioc->spi_data.maxSyncOffset = 0;
5050                                 ioc->spi_data.minSyncFactor = MPT_ASYNC;
5051                                 ioc->spi_data.busType = MPT_HOST_BUS_UNKNOWN;
5052                                 rc = 1;
5053                                 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5054                                         "Unable to read PortPage0 minSyncFactor=%x\n",
5055                                         ioc->name, ioc->spi_data.minSyncFactor));
5056                         } else {
5057                                 /* Save the Port Page 0 data
5058                                  */
5059                                 SCSIPortPage0_t  *pPP0 = (SCSIPortPage0_t  *) pbuf;
5060                                 pPP0->Capabilities = le32_to_cpu(pPP0->Capabilities);
5061                                 pPP0->PhysicalInterface = le32_to_cpu(pPP0->PhysicalInterface);
5062
5063                                 if ( (pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_QAS) == 0 ) {
5064                                         ioc->spi_data.noQas |= MPT_TARGET_NO_NEGO_QAS;
5065                                         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5066                                                 "noQas due to Capabilities=%x\n",
5067                                                 ioc->name, pPP0->Capabilities));
5068                                 }
5069                                 ioc->spi_data.maxBusWidth = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_WIDE ? 1 : 0;
5070                                 data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MAX_SYNC_OFFSET_MASK;
5071                                 if (data) {
5072                                         ioc->spi_data.maxSyncOffset = (u8) (data >> 16);
5073                                         data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MIN_SYNC_PERIOD_MASK;
5074                                         ioc->spi_data.minSyncFactor = (u8) (data >> 8);
5075                                         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5076                                                 "PortPage0 minSyncFactor=%x\n",
5077                                                 ioc->name, ioc->spi_data.minSyncFactor));
5078                                 } else {
5079                                         ioc->spi_data.maxSyncOffset = 0;
5080                                         ioc->spi_data.minSyncFactor = MPT_ASYNC;
5081                                 }
5082
5083                                 ioc->spi_data.busType = pPP0->PhysicalInterface & MPI_SCSIPORTPAGE0_PHY_SIGNAL_TYPE_MASK;
5084
5085                                 /* Update the minSyncFactor based on bus type.
5086                                  */
5087                                 if ((ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_HVD) ||
5088                                         (ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_SE))  {
5089
5090                                         if (ioc->spi_data.minSyncFactor < MPT_ULTRA) {
5091                                                 ioc->spi_data.minSyncFactor = MPT_ULTRA;
5092                                                 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5093                                                         "HVD or SE detected, minSyncFactor=%x\n",
5094                                                         ioc->name, ioc->spi_data.minSyncFactor));
5095                                         }
5096                                 }
5097                         }
5098                         if (pbuf) {
5099                                 pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
5100                         }
5101                 }
5102         }
5103
5104         /* SCSI Port Page 2 - Read the header then the page.
5105          */
5106         header.PageVersion = 0;
5107         header.PageLength = 0;
5108         header.PageNumber = 2;
5109         header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
5110         cfg.cfghdr.hdr = &header;
5111         cfg.physAddr = -1;
5112         cfg.pageAddr = portnum;
5113         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5114         cfg.dir = 0;
5115         if (mpt_config(ioc, &cfg) != 0)
5116                 return -EFAULT;
5117
5118         if (header.PageLength > 0) {
5119                 /* Allocate memory and read SCSI Port Page 2
5120                  */
5121                 pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
5122                 if (pbuf) {
5123                         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_NVRAM;
5124                         cfg.physAddr = buf_dma;
5125                         if (mpt_config(ioc, &cfg) != 0) {
5126                                 /* Nvram data is left with INVALID mark
5127                                  */
5128                                 rc = 1;
5129                         } else if (ioc->pcidev->vendor == PCI_VENDOR_ID_ATTO) {
5130
5131                                 /* This is an ATTO adapter, read Page2 accordingly
5132                                 */
5133                                 ATTO_SCSIPortPage2_t *pPP2 = (ATTO_SCSIPortPage2_t  *) pbuf;
5134                                 ATTODeviceInfo_t *pdevice = NULL;
5135                                 u16 ATTOFlags;
5136
5137                                 /* Save the Port Page 2 data
5138                                  * (reformat into a 32bit quantity)
5139                                  */
5140                                 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
5141                                   pdevice = &pPP2->DeviceSettings[ii];
5142                                   ATTOFlags = le16_to_cpu(pdevice->ATTOFlags);
5143                                   data = 0;
5144
5145                                   /* Translate ATTO device flags to LSI format
5146                                    */
5147                                   if (ATTOFlags & ATTOFLAG_DISC)
5148                                     data |= (MPI_SCSIPORTPAGE2_DEVICE_DISCONNECT_ENABLE);
5149                                   if (ATTOFlags & ATTOFLAG_ID_ENB)
5150                                     data |= (MPI_SCSIPORTPAGE2_DEVICE_ID_SCAN_ENABLE);
5151                                   if (ATTOFlags & ATTOFLAG_LUN_ENB)
5152                                     data |= (MPI_SCSIPORTPAGE2_DEVICE_LUN_SCAN_ENABLE);
5153                                   if (ATTOFlags & ATTOFLAG_TAGGED)
5154                                     data |= (MPI_SCSIPORTPAGE2_DEVICE_TAG_QUEUE_ENABLE);
5155                                   if (!(ATTOFlags & ATTOFLAG_WIDE_ENB))
5156                                     data |= (MPI_SCSIPORTPAGE2_DEVICE_WIDE_DISABLE);
5157
5158                                   data = (data << 16) | (pdevice->Period << 8) | 10;
5159                                   ioc->spi_data.nvram[ii] = data;
5160                                 }
5161                         } else {
5162                                 SCSIPortPage2_t *pPP2 = (SCSIPortPage2_t  *) pbuf;
5163                                 MpiDeviceInfo_t *pdevice = NULL;
5164
5165                                 /*
5166                                  * Save "Set to Avoid SCSI Bus Resets" flag
5167                                  */
5168                                 ioc->spi_data.bus_reset =
5169                                     (le32_to_cpu(pPP2->PortFlags) &
5170                                 MPI_SCSIPORTPAGE2_PORT_FLAGS_AVOID_SCSI_RESET) ?
5171                                     0 : 1 ;
5172
5173                                 /* Save the Port Page 2 data
5174                                  * (reformat into a 32bit quantity)
5175                                  */
5176                                 data = le32_to_cpu(pPP2->PortFlags) & MPI_SCSIPORTPAGE2_PORT_FLAGS_DV_MASK;
5177                                 ioc->spi_data.PortFlags = data;
5178                                 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
5179                                         pdevice = &pPP2->DeviceSettings[ii];
5180                                         data = (le16_to_cpu(pdevice->DeviceFlags) << 16) |
5181                                                 (pdevice->SyncFactor << 8) | pdevice->Timeout;
5182                                         ioc->spi_data.nvram[ii] = data;
5183                                 }
5184                         }
5185
5186                         pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
5187                 }
5188         }
5189
5190         /* Update Adapter limits with those from NVRAM
5191          * Comment: Don't need to do this. Target performance
5192          * parameters will never exceed the adapters limits.
5193          */
5194
5195         return rc;
5196 }
5197
5198 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5199 /**
5200  *      mpt_readScsiDevicePageHeaders - save version and length of SDP1
5201  *      @ioc: Pointer to a Adapter Strucutre
5202  *      @portnum: IOC port number
5203  *
5204  *      Return: -EFAULT if read of config page header fails
5205  *              or 0 if success.
5206  */
5207 static int
5208 mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum)
5209 {
5210         CONFIGPARMS              cfg;
5211         ConfigPageHeader_t       header;
5212
5213         /* Read the SCSI Device Page 1 header
5214          */
5215         header.PageVersion = 0;
5216         header.PageLength = 0;
5217         header.PageNumber = 1;
5218         header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
5219         cfg.cfghdr.hdr = &header;
5220         cfg.physAddr = -1;
5221         cfg.pageAddr = portnum;
5222         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5223         cfg.dir = 0;
5224         cfg.timeout = 0;
5225         if (mpt_config(ioc, &cfg) != 0)
5226                  return -EFAULT;
5227
5228         ioc->spi_data.sdp1version = cfg.cfghdr.hdr->PageVersion;
5229         ioc->spi_data.sdp1length = cfg.cfghdr.hdr->PageLength;
5230
5231         header.PageVersion = 0;
5232         header.PageLength = 0;
5233         header.PageNumber = 0;
5234         header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
5235         if (mpt_config(ioc, &cfg) != 0)
5236                  return -EFAULT;
5237
5238         ioc->spi_data.sdp0version = cfg.cfghdr.hdr->PageVersion;
5239         ioc->spi_data.sdp0length = cfg.cfghdr.hdr->PageLength;
5240
5241         dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Headers: 0: version %d length %d\n",
5242                         ioc->name, ioc->spi_data.sdp0version, ioc->spi_data.sdp0length));
5243
5244         dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Headers: 1: version %d length %d\n",
5245                         ioc->name, ioc->spi_data.sdp1version, ioc->spi_data.sdp1length));
5246         return 0;
5247 }
5248
5249 /**
5250  * mpt_inactive_raid_list_free - This clears this link list.
5251  * @ioc : pointer to per adapter structure
5252  **/
5253 static void
5254 mpt_inactive_raid_list_free(MPT_ADAPTER *ioc)
5255 {
5256         struct inactive_raid_component_info *component_info, *pNext;
5257
5258         if (list_empty(&ioc->raid_data.inactive_list))
5259                 return;
5260
5261         mutex_lock(&ioc->raid_data.inactive_list_mutex);
5262         list_for_each_entry_safe(component_info, pNext,
5263             &ioc->raid_data.inactive_list, list) {
5264                 list_del(&component_info->list);
5265                 kfree(component_info);
5266         }
5267         mutex_unlock(&ioc->raid_data.inactive_list_mutex);
5268 }
5269
5270 /**
5271  * mpt_inactive_raid_volumes - sets up link list of phy_disk_nums for devices belonging in an inactive volume
5272  *
5273  * @ioc : pointer to per adapter structure
5274  * @channel : volume channel
5275  * @id : volume target id
5276  **/
5277 static void
5278 mpt_inactive_raid_volumes(MPT_ADAPTER *ioc, u8 channel, u8 id)
5279 {
5280         CONFIGPARMS                     cfg;
5281         ConfigPageHeader_t              hdr;
5282         dma_addr_t                      dma_handle;
5283         pRaidVolumePage0_t              buffer = NULL;
5284         int                             i;
5285         RaidPhysDiskPage0_t             phys_disk;
5286         struct inactive_raid_component_info *component_info;
5287         int                             handle_inactive_volumes;
5288
5289         memset(&cfg, 0 , sizeof(CONFIGPARMS));
5290         memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
5291         hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
5292         cfg.pageAddr = (channel << 8) + id;
5293         cfg.cfghdr.hdr = &hdr;
5294         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5295
5296         if (mpt_config(ioc, &cfg) != 0)
5297                 goto out;
5298
5299         if (!hdr.PageLength)
5300                 goto out;
5301
5302         buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
5303             &dma_handle);
5304
5305         if (!buffer)
5306                 goto out;
5307
5308         cfg.physAddr = dma_handle;
5309         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5310
5311         if (mpt_config(ioc, &cfg) != 0)
5312                 goto out;
5313
5314         if (!buffer->NumPhysDisks)
5315                 goto out;
5316
5317         handle_inactive_volumes =
5318            (buffer->VolumeStatus.Flags & MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE ||
5319            (buffer->VolumeStatus.Flags & MPI_RAIDVOL0_STATUS_FLAG_ENABLED) == 0 ||
5320             buffer->VolumeStatus.State == MPI_RAIDVOL0_STATUS_STATE_FAILED ||
5321             buffer->VolumeStatus.State == MPI_RAIDVOL0_STATUS_STATE_MISSING) ? 1 : 0;
5322
5323         if (!handle_inactive_volumes)
5324                 goto out;
5325
5326         mutex_lock(&ioc->raid_data.inactive_list_mutex);
5327         for (i = 0; i < buffer->NumPhysDisks; i++) {
5328                 if(mpt_raid_phys_disk_pg0(ioc,
5329                     buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
5330                         continue;
5331
5332                 if ((component_info = kmalloc(sizeof (*component_info),
5333                  GFP_KERNEL)) == NULL)
5334                         continue;
5335
5336                 component_info->volumeID = id;
5337                 component_info->volumeBus = channel;
5338                 component_info->d.PhysDiskNum = phys_disk.PhysDiskNum;
5339                 component_info->d.PhysDiskBus = phys_disk.PhysDiskBus;
5340                 component_info->d.PhysDiskID = phys_disk.PhysDiskID;
5341                 component_info->d.PhysDiskIOC = phys_disk.PhysDiskIOC;
5342
5343                 list_add_tail(&component_info->list,
5344                     &ioc->raid_data.inactive_list);
5345         }
5346         mutex_unlock(&ioc->raid_data.inactive_list_mutex);
5347
5348  out:
5349         if (buffer)
5350                 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
5351                     dma_handle);
5352 }
5353
5354 /**
5355  *      mpt_raid_phys_disk_pg0 - returns phys disk page zero
5356  *      @ioc: Pointer to a Adapter Structure
5357  *      @phys_disk_num: io unit unique phys disk num generated by the ioc
5358  *      @phys_disk: requested payload data returned
5359  *
5360  *      Return:
5361  *      0 on success
5362  *      -EFAULT if read of config page header fails or data pointer not NULL
5363  *      -ENOMEM if pci_alloc failed
5364  **/
5365 int
5366 mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num, pRaidPhysDiskPage0_t phys_disk)
5367 {
5368         CONFIGPARMS                     cfg;
5369         ConfigPageHeader_t              hdr;
5370         dma_addr_t                      dma_handle;
5371         pRaidPhysDiskPage0_t            buffer = NULL;
5372         int                             rc;
5373
5374         memset(&cfg, 0 , sizeof(CONFIGPARMS));
5375         memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
5376
5377         hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
5378         cfg.cfghdr.hdr = &hdr;
5379         cfg.physAddr = -1;
5380         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5381
5382         if (mpt_config(ioc, &cfg) != 0) {
5383                 rc = -EFAULT;
5384                 goto out;
5385         }
5386
5387         if (!hdr.PageLength) {
5388                 rc = -EFAULT;
5389                 goto out;
5390         }
5391
5392         buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
5393             &dma_handle);
5394
5395         if (!buffer) {
5396                 rc = -ENOMEM;
5397                 goto out;
5398         }
5399
5400         cfg.physAddr = dma_handle;
5401         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5402         cfg.pageAddr = phys_disk_num;
5403
5404         if (mpt_config(ioc, &cfg) != 0) {
5405                 rc = -EFAULT;
5406                 goto out;
5407         }
5408
5409         rc = 0;
5410         memcpy(phys_disk, buffer, sizeof(*buffer));
5411         phys_disk->MaxLBA = le32_to_cpu(buffer->MaxLBA);
5412
5413  out:
5414
5415         if (buffer)
5416                 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
5417                     dma_handle);
5418
5419         return rc;
5420 }
5421
5422 /**
5423  *      mpt_findImVolumes - Identify IDs of hidden disks and RAID Volumes
5424  *      @ioc: Pointer to a Adapter Strucutre
5425  *      @portnum: IOC port number
5426  *
5427  *      Return:
5428  *      0 on success
5429  *      -EFAULT if read of config page header fails or data pointer not NULL
5430  *      -ENOMEM if pci_alloc failed
5431  **/
5432 int
5433 mpt_findImVolumes(MPT_ADAPTER *ioc)
5434 {
5435         IOCPage2_t              *pIoc2;
5436         u8                      *mem;
5437         dma_addr_t               ioc2_dma;
5438         CONFIGPARMS              cfg;
5439         ConfigPageHeader_t       header;
5440         int                      rc = 0;
5441         int                      iocpage2sz;
5442         int                      i;
5443
5444         if (!ioc->ir_firmware)
5445                 return 0;
5446
5447         /* Free the old page
5448          */
5449         kfree(ioc->raid_data.pIocPg2);
5450         ioc->raid_data.pIocPg2 = NULL;
5451         mpt_inactive_raid_list_free(ioc);
5452
5453         /* Read IOCP2 header then the page.
5454          */
5455         header.PageVersion = 0;
5456         header.PageLength = 0;
5457         header.PageNumber = 2;
5458         header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5459         cfg.cfghdr.hdr = &header;
5460         cfg.physAddr = -1;
5461         cfg.pageAddr = 0;
5462         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5463         cfg.dir = 0;
5464         cfg.timeout = 0;
5465         if (mpt_config(ioc, &cfg) != 0)
5466                  return -EFAULT;
5467
5468         if (header.PageLength == 0)
5469                 return -EFAULT;
5470
5471         iocpage2sz = header.PageLength * 4;
5472         pIoc2 = pci_alloc_consistent(ioc->pcidev, iocpage2sz, &ioc2_dma);
5473         if (!pIoc2)
5474                 return -ENOMEM;
5475
5476         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5477         cfg.physAddr = ioc2_dma;
5478         if (mpt_config(ioc, &cfg) != 0)
5479                 goto out;
5480
5481         mem = kmalloc(iocpage2sz, GFP_KERNEL);
5482         if (!mem)
5483                 goto out;
5484
5485         memcpy(mem, (u8 *)pIoc2, iocpage2sz);
5486         ioc->raid_data.pIocPg2 = (IOCPage2_t *) mem;
5487
5488         mpt_read_ioc_pg_3(ioc);
5489
5490         for (i = 0; i < pIoc2->NumActiveVolumes ; i++)
5491                 mpt_inactive_raid_volumes(ioc,
5492                     pIoc2->RaidVolume[i].VolumeBus,
5493                     pIoc2->RaidVolume[i].VolumeID);
5494
5495  out:
5496         pci_free_consistent(ioc->pcidev, iocpage2sz, pIoc2, ioc2_dma);
5497
5498         return rc;
5499 }
5500
5501 static int
5502 mpt_read_ioc_pg_3(MPT_ADAPTER *ioc)
5503 {
5504         IOCPage3_t              *pIoc3;
5505         u8                      *mem;
5506         CONFIGPARMS              cfg;
5507         ConfigPageHeader_t       header;
5508         dma_addr_t               ioc3_dma;
5509         int                      iocpage3sz = 0;
5510
5511         /* Free the old page
5512          */
5513         kfree(ioc->raid_data.pIocPg3);
5514         ioc->raid_data.pIocPg3 = NULL;
5515
5516         /* There is at least one physical disk.
5517          * Read and save IOC Page 3
5518          */
5519         header.PageVersion = 0;
5520         header.PageLength = 0;
5521         header.PageNumber = 3;
5522         header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5523         cfg.cfghdr.hdr = &header;
5524         cfg.physAddr = -1;
5525         cfg.pageAddr = 0;
5526         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5527         cfg.dir = 0;
5528         cfg.timeout = 0;
5529         if (mpt_config(ioc, &cfg) != 0)
5530                 return 0;
5531
5532         if (header.PageLength == 0)
5533                 return 0;
5534
5535         /* Read Header good, alloc memory
5536          */
5537         iocpage3sz = header.PageLength * 4;
5538         pIoc3 = pci_alloc_consistent(ioc->pcidev, iocpage3sz, &ioc3_dma);
5539         if (!pIoc3)
5540                 return 0;
5541
5542         /* Read the Page and save the data
5543          * into malloc'd memory.
5544          */
5545         cfg.physAddr = ioc3_dma;
5546         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5547         if (mpt_config(ioc, &cfg) == 0) {
5548                 mem = kmalloc(iocpage3sz, GFP_KERNEL);
5549                 if (mem) {
5550                         memcpy(mem, (u8 *)pIoc3, iocpage3sz);
5551                         ioc->raid_data.pIocPg3 = (IOCPage3_t *) mem;
5552                 }
5553         }
5554
5555         pci_free_consistent(ioc->pcidev, iocpage3sz, pIoc3, ioc3_dma);
5556
5557         return 0;
5558 }
5559
5560 static void
5561 mpt_read_ioc_pg_4(MPT_ADAPTER *ioc)
5562 {
5563         IOCPage4_t              *pIoc4;
5564         CONFIGPARMS              cfg;
5565         ConfigPageHeader_t       header;
5566         dma_addr_t               ioc4_dma;
5567         int                      iocpage4sz;
5568
5569         /* Read and save IOC Page 4
5570          */
5571         header.PageVersion = 0;
5572         header.PageLength = 0;
5573         header.PageNumber = 4;
5574         header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5575         cfg.cfghdr.hdr = &header;
5576         cfg.physAddr = -1;
5577         cfg.pageAddr = 0;
5578         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5579         cfg.dir = 0;
5580         cfg.timeout = 0;
5581         if (mpt_config(ioc, &cfg) != 0)
5582                 return;
5583
5584         if (header.PageLength == 0)
5585                 return;
5586
5587         if ( (pIoc4 = ioc->spi_data.pIocPg4) == NULL ) {
5588                 iocpage4sz = (header.PageLength + 4) * 4; /* Allow 4 additional SEP's */
5589                 pIoc4 = pci_alloc_consistent(ioc->pcidev, iocpage4sz, &ioc4_dma);
5590                 if (!pIoc4)
5591                         return;
5592                 ioc->alloc_total += iocpage4sz;
5593         } else {
5594                 ioc4_dma = ioc->spi_data.IocPg4_dma;
5595                 iocpage4sz = ioc->spi_data.IocPg4Sz;
5596         }
5597
5598         /* Read the Page into dma memory.
5599          */
5600         cfg.physAddr = ioc4_dma;
5601         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5602         if (mpt_config(ioc, &cfg) == 0) {
5603                 ioc->spi_data.pIocPg4 = (IOCPage4_t *) pIoc4;
5604                 ioc->spi_data.IocPg4_dma = ioc4_dma;
5605                 ioc->spi_data.IocPg4Sz = iocpage4sz;
5606         } else {
5607                 pci_free_consistent(ioc->pcidev, iocpage4sz, pIoc4, ioc4_dma);
5608                 ioc->spi_data.pIocPg4 = NULL;
5609                 ioc->alloc_total -= iocpage4sz;
5610         }
5611 }
5612
5613 static void
5614 mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
5615 {
5616         IOCPage1_t              *pIoc1;
5617         CONFIGPARMS              cfg;
5618         ConfigPageHeader_t       header;
5619         dma_addr_t               ioc1_dma;
5620         int                      iocpage1sz = 0;
5621         u32                      tmp;
5622
5623         /* Check the Coalescing Timeout in IOC Page 1
5624          */
5625         header.PageVersion = 0;
5626         header.PageLength = 0;
5627         header.PageNumber = 1;
5628         header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5629         cfg.cfghdr.hdr = &header;
5630         cfg.physAddr = -1;
5631         cfg.pageAddr = 0;
5632         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5633         cfg.dir = 0;
5634         cfg.timeout = 0;
5635         if (mpt_config(ioc, &cfg) != 0)
5636                 return;
5637
5638         if (header.PageLength == 0)
5639                 return;
5640
5641         /* Read Header good, alloc memory
5642          */
5643         iocpage1sz = header.PageLength * 4;
5644         pIoc1 = pci_alloc_consistent(ioc->pcidev, iocpage1sz, &ioc1_dma);
5645         if (!pIoc1)
5646                 return;
5647
5648         /* Read the Page and check coalescing timeout
5649          */
5650         cfg.physAddr = ioc1_dma;
5651         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5652         if (mpt_config(ioc, &cfg) == 0) {
5653
5654                 tmp = le32_to_cpu(pIoc1->Flags) & MPI_IOCPAGE1_REPLY_COALESCING;
5655                 if (tmp == MPI_IOCPAGE1_REPLY_COALESCING) {
5656                         tmp = le32_to_cpu(pIoc1->CoalescingTimeout);
5657
5658                         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Coalescing Enabled Timeout = %d\n",
5659                                         ioc->name, tmp));
5660
5661                         if (tmp > MPT_COALESCING_TIMEOUT) {
5662                                 pIoc1->CoalescingTimeout = cpu_to_le32(MPT_COALESCING_TIMEOUT);
5663
5664                                 /* Write NVRAM and current
5665                                  */
5666                                 cfg.dir = 1;
5667                                 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
5668                                 if (mpt_config(ioc, &cfg) == 0) {
5669                                         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Reset Current Coalescing Timeout to = %d\n",
5670                                                         ioc->name, MPT_COALESCING_TIMEOUT));
5671
5672                                         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
5673                                         if (mpt_config(ioc, &cfg) == 0) {
5674                                                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5675                                                                 "Reset NVRAM Coalescing Timeout to = %d\n",
5676                                                                 ioc->name, MPT_COALESCING_TIMEOUT));
5677                                         } else {
5678                                                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5679                                                                 "Reset NVRAM Coalescing Timeout Failed\n",
5680                                                                 ioc->name));
5681                                         }
5682
5683                                 } else {
5684                                         dprintk(ioc, printk(MYIOC_s_WARN_FMT
5685                                                 "Reset of Current Coalescing Timeout Failed!\n",
5686                                                 ioc->name));
5687                                 }
5688                         }
5689
5690                 } else {
5691                         dprintk(ioc, printk(MYIOC_s_WARN_FMT "Coalescing Disabled\n", ioc->name));
5692                 }
5693         }
5694
5695         pci_free_consistent(ioc->pcidev, iocpage1sz, pIoc1, ioc1_dma);
5696
5697         return;
5698 }
5699
5700 static void
5701 mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc)
5702 {
5703         CONFIGPARMS             cfg;
5704         ConfigPageHeader_t      hdr;
5705         dma_addr_t              buf_dma;
5706         ManufacturingPage0_t    *pbuf = NULL;
5707
5708         memset(&cfg, 0 , sizeof(CONFIGPARMS));
5709         memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
5710
5711         hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
5712         cfg.cfghdr.hdr = &hdr;
5713         cfg.physAddr = -1;
5714         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5715         cfg.timeout = 10;
5716
5717         if (mpt_config(ioc, &cfg) != 0)
5718                 goto out;
5719
5720         if (!cfg.cfghdr.hdr->PageLength)
5721                 goto out;
5722
5723         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5724         pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
5725         if (!pbuf)
5726                 goto out;
5727
5728         cfg.physAddr = buf_dma;
5729
5730         if (mpt_config(ioc, &cfg) != 0)
5731                 goto out;
5732
5733         memcpy(ioc->board_name, pbuf->BoardName, sizeof(ioc->board_name));
5734         memcpy(ioc->board_assembly, pbuf->BoardAssembly, sizeof(ioc->board_assembly));
5735         memcpy(ioc->board_tracer, pbuf->BoardTracerNumber, sizeof(ioc->board_tracer));
5736
5737         out:
5738
5739         if (pbuf)
5740                 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
5741 }
5742
5743 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5744 /**
5745  *      SendEventNotification - Send EventNotification (on or off) request to adapter
5746  *      @ioc: Pointer to MPT_ADAPTER structure
5747  *      @EvSwitch: Event switch flags
5748  */
5749 static int
5750 SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch)
5751 {
5752         EventNotification_t     *evnp;
5753
5754         evnp = (EventNotification_t *) mpt_get_msg_frame(mpt_base_index, ioc);
5755         if (evnp == NULL) {
5756                 devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Unable to allocate event request frame!\n",
5757                                 ioc->name));
5758                 return 0;
5759         }
5760         memset(evnp, 0, sizeof(*evnp));
5761
5762         devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending EventNotification (%d) request %p\n", ioc->name, EvSwitch, evnp));
5763
5764         evnp->Function = MPI_FUNCTION_EVENT_NOTIFICATION;
5765         evnp->ChainOffset = 0;
5766         evnp->MsgFlags = 0;
5767         evnp->Switch = EvSwitch;
5768
5769         mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)evnp);
5770
5771         return 0;
5772 }
5773
5774 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5775 /**
5776  *      SendEventAck - Send EventAck request to MPT adapter.
5777  *      @ioc: Pointer to MPT_ADAPTER structure
5778  *      @evnp: Pointer to original EventNotification request
5779  */
5780 static int
5781 SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp)
5782 {
5783         EventAck_t      *pAck;
5784
5785         if ((pAck = (EventAck_t *) mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
5786                 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
5787                     ioc->name,__func__));
5788                 return -1;
5789         }
5790
5791         devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending EventAck\n", ioc->name));
5792
5793         pAck->Function     = MPI_FUNCTION_EVENT_ACK;
5794         pAck->ChainOffset  = 0;
5795         pAck->Reserved[0]  = pAck->Reserved[1] = 0;
5796         pAck->MsgFlags     = 0;
5797         pAck->Reserved1[0] = pAck->Reserved1[1] = pAck->Reserved1[2] = 0;
5798         pAck->Event        = evnp->Event;
5799         pAck->EventContext = evnp->EventContext;
5800
5801         mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)pAck);
5802
5803         return 0;
5804 }
5805
5806 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5807 /**
5808  *      mpt_config - Generic function to issue config message
5809  *      @ioc:   Pointer to an adapter structure
5810  *      @pCfg:  Pointer to a configuration structure. Struct contains
5811  *              action, page address, direction, physical address
5812  *              and pointer to a configuration page header
5813  *              Page header is updated.
5814  *
5815  *      Returns 0 for success
5816  *      -EPERM if not allowed due to ISR context
5817  *      -EAGAIN if no msg frames currently available
5818  *      -EFAULT for non-successful reply or no reply (timeout)
5819  */
5820 int
5821 mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS *pCfg)
5822 {
5823         Config_t        *pReq;
5824         ConfigExtendedPageHeader_t  *pExtHdr = NULL;
5825         MPT_FRAME_HDR   *mf;
5826         unsigned long    flags;
5827         int              ii, rc;
5828         int              flagsLength;
5829         int              in_isr;
5830
5831         /*      Prevent calling wait_event() (below), if caller happens
5832          *      to be in ISR context, because that is fatal!
5833          */
5834         in_isr = in_interrupt();
5835         if (in_isr) {
5836                 dcprintk(ioc, printk(MYIOC_s_WARN_FMT "Config request not allowed in ISR context!\n",
5837                                 ioc->name));
5838                 return -EPERM;
5839         }
5840
5841         /* Get and Populate a free Frame
5842          */
5843         if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
5844                 dcprintk(ioc, printk(MYIOC_s_WARN_FMT "mpt_config: no msg frames!\n",
5845                                 ioc->name));
5846                 return -EAGAIN;
5847         }
5848         pReq = (Config_t *)mf;
5849         pReq->Action = pCfg->action;
5850         pReq->Reserved = 0;
5851         pReq->ChainOffset = 0;
5852         pReq->Function = MPI_FUNCTION_CONFIG;
5853
5854         /* Assume page type is not extended and clear "reserved" fields. */
5855         pReq->ExtPageLength = 0;
5856         pReq->ExtPageType = 0;
5857         pReq->MsgFlags = 0;
5858
5859         for (ii=0; ii < 8; ii++)
5860                 pReq->Reserved2[ii] = 0;
5861
5862         pReq->Header.PageVersion = pCfg->cfghdr.hdr->PageVersion;
5863         pReq->Header.PageLength = pCfg->cfghdr.hdr->PageLength;
5864         pReq->Header.PageNumber = pCfg->cfghdr.hdr->PageNumber;
5865         pReq->Header.PageType = (pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK);
5866
5867         if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
5868                 pExtHdr = (ConfigExtendedPageHeader_t *)pCfg->cfghdr.ehdr;
5869                 pReq->ExtPageLength = cpu_to_le16(pExtHdr->ExtPageLength);
5870                 pReq->ExtPageType = pExtHdr->ExtPageType;
5871                 pReq->Header.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
5872
5873                 /* Page Length must be treated as a reserved field for the extended header. */
5874                 pReq->Header.PageLength = 0;
5875         }
5876
5877         pReq->PageAddress = cpu_to_le32(pCfg->pageAddr);
5878
5879         /* Add a SGE to the config request.
5880          */
5881         if (pCfg->dir)
5882                 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
5883         else
5884                 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
5885
5886         if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
5887                 flagsLength |= pExtHdr->ExtPageLength * 4;
5888
5889                 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
5890                         ioc->name, pReq->ExtPageType, pReq->Header.PageNumber, pReq->Action));
5891         }
5892         else {
5893                 flagsLength |= pCfg->cfghdr.hdr->PageLength * 4;
5894
5895                 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
5896                         ioc->name, pReq->Header.PageType, pReq->Header.PageNumber, pReq->Action));
5897         }
5898
5899         mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, pCfg->physAddr);
5900
5901         /* Append pCfg pointer to end of mf
5902          */
5903         *((void **) (((u8 *) mf) + (ioc->req_sz - sizeof(void *)))) =  (void *) pCfg;
5904
5905         /* Initalize the timer
5906          */
5907         init_timer(&pCfg->timer);
5908         pCfg->timer.data = (unsigned long) ioc;
5909         pCfg->timer.function = mpt_timer_expired;
5910         pCfg->wait_done = 0;
5911
5912         /* Set the timer; ensure 10 second minimum */
5913         if (pCfg->timeout < 10)
5914                 pCfg->timer.expires = jiffies + HZ*10;
5915         else
5916                 pCfg->timer.expires = jiffies + HZ*pCfg->timeout;
5917
5918         /* Add to end of Q, set timer and then issue this command */
5919         spin_lock_irqsave(&ioc->FreeQlock, flags);
5920         list_add_tail(&pCfg->linkage, &ioc->configQ);
5921         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5922
5923         add_timer(&pCfg->timer);
5924         mpt_put_msg_frame(mpt_base_index, ioc, mf);
5925         wait_event(mpt_waitq, pCfg->wait_done);
5926
5927         /* mf has been freed - do not access */
5928
5929         rc = pCfg->status;
5930
5931         return rc;
5932 }
5933
5934 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5935 /**
5936  *      mpt_timer_expired - Callback for timer process.
5937  *      Used only internal config functionality.
5938  *      @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
5939  */
5940 static void
5941 mpt_timer_expired(unsigned long data)
5942 {
5943         MPT_ADAPTER *ioc = (MPT_ADAPTER *) data;
5944
5945         dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired! \n", ioc->name));
5946
5947         /* Perform a FW reload */
5948         if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0)
5949                 printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", ioc->name);
5950
5951         /* No more processing.
5952          * Hard reset clean-up will wake up
5953          * process and free all resources.
5954          */
5955         dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired complete!\n", ioc->name));
5956
5957         return;
5958 }
5959
5960 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5961 /**
5962  *      mpt_ioc_reset - Base cleanup for hard reset
5963  *      @ioc: Pointer to the adapter structure
5964  *      @reset_phase: Indicates pre- or post-reset functionality
5965  *
5966  *      Remark: Frees resources with internally generated commands.
5967  */
5968 static int
5969 mpt_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
5970 {
5971         CONFIGPARMS *pCfg;
5972         unsigned long flags;
5973
5974         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5975             ": IOC %s_reset routed to MPT base driver!\n",
5976             ioc->name, reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
5977             reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
5978
5979         if (reset_phase == MPT_IOC_SETUP_RESET) {
5980                 ;
5981         } else if (reset_phase == MPT_IOC_PRE_RESET) {
5982                 /* If the internal config Q is not empty -
5983                  * delete timer. MF resources will be freed when
5984                  * the FIFO's are primed.
5985                  */
5986                 spin_lock_irqsave(&ioc->FreeQlock, flags);
5987                 list_for_each_entry(pCfg, &ioc->configQ, linkage)
5988                         del_timer(&pCfg->timer);
5989                 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5990
5991         } else {
5992                 CONFIGPARMS *pNext;
5993
5994                 /* Search the configQ for internal commands.
5995                  * Flush the Q, and wake up all suspended threads.
5996                  */
5997                 spin_lock_irqsave(&ioc->FreeQlock, flags);
5998                 list_for_each_entry_safe(pCfg, pNext, &ioc->configQ, linkage) {
5999                         list_del(&pCfg->linkage);
6000
6001                         pCfg->status = MPT_CONFIG_ERROR;
6002                         pCfg->wait_done = 1;
6003                         wake_up(&mpt_waitq);
6004                 }
6005                 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
6006         }
6007
6008         return 1;               /* currently means nothing really */
6009 }
6010
6011
6012 #ifdef CONFIG_PROC_FS           /* { */
6013 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6014 /*
6015  *      procfs (%MPT_PROCFS_MPTBASEDIR/...) support stuff...
6016  */
6017 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6018 /**
6019  *      procmpt_create - Create %MPT_PROCFS_MPTBASEDIR entries.
6020  *
6021  *      Returns 0 for success, non-zero for failure.
6022  */
6023 static int
6024 procmpt_create(void)
6025 {
6026         struct proc_dir_entry   *ent;
6027
6028         mpt_proc_root_dir = proc_mkdir(MPT_PROCFS_MPTBASEDIR, NULL);
6029         if (mpt_proc_root_dir == NULL)
6030                 return -ENOTDIR;
6031
6032         ent = create_proc_entry("summary", S_IFREG|S_IRUGO, mpt_proc_root_dir);
6033         if (ent)
6034                 ent->read_proc = procmpt_summary_read;
6035
6036         ent = create_proc_entry("version", S_IFREG|S_IRUGO, mpt_proc_root_dir);
6037         if (ent)
6038                 ent->read_proc = procmpt_version_read;
6039
6040         return 0;
6041 }
6042
6043 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6044 /**
6045  *      procmpt_destroy - Tear down %MPT_PROCFS_MPTBASEDIR entries.
6046  *
6047  *      Returns 0 for success, non-zero for failure.
6048  */
6049 static void
6050 procmpt_destroy(void)
6051 {
6052         remove_proc_entry("version", mpt_proc_root_dir);
6053         remove_proc_entry("summary", mpt_proc_root_dir);
6054         remove_proc_entry(MPT_PROCFS_MPTBASEDIR, NULL);
6055 }
6056
6057 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6058 /**
6059  *      procmpt_summary_read - Handle read request of a summary file
6060  *      @buf: Pointer to area to write information
6061  *      @start: Pointer to start pointer
6062  *      @offset: Offset to start writing
6063  *      @request: Amount of read data requested
6064  *      @eof: Pointer to EOF integer
6065  *      @data: Pointer
6066  *
6067  *      Handles read request from /proc/mpt/summary or /proc/mpt/iocN/summary.
6068  *      Returns number of characters written to process performing the read.
6069  */
6070 static int
6071 procmpt_summary_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
6072 {
6073         MPT_ADAPTER *ioc;
6074         char *out = buf;
6075         int len;
6076
6077         if (data) {
6078                 int more = 0;
6079
6080                 ioc = data;
6081                 mpt_print_ioc_summary(ioc, out, &more, 0, 1);
6082
6083                 out += more;
6084         } else {
6085                 list_for_each_entry(ioc, &ioc_list, list) {
6086                         int     more = 0;
6087
6088                         mpt_print_ioc_summary(ioc, out, &more, 0, 1);
6089
6090                         out += more;
6091                         if ((out-buf) >= request)
6092                                 break;
6093                 }
6094         }
6095
6096         len = out - buf;
6097
6098         MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
6099 }
6100
6101 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6102 /**
6103  *      procmpt_version_read - Handle read request from /proc/mpt/version.
6104  *      @buf: Pointer to area to write information
6105  *      @start: Pointer to start pointer
6106  *      @offset: Offset to start writing
6107  *      @request: Amount of read data requested
6108  *      @eof: Pointer to EOF integer
6109  *      @data: Pointer
6110  *
6111  *      Returns number of characters written to process performing the read.
6112  */
6113 static int
6114 procmpt_version_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
6115 {
6116         u8       cb_idx;
6117         int      scsi, fc, sas, lan, ctl, targ, dmp;
6118         char    *drvname;
6119         int      len;
6120
6121         len = sprintf(buf, "%s-%s\n", "mptlinux", MPT_LINUX_VERSION_COMMON);
6122         len += sprintf(buf+len, "  Fusion MPT base driver\n");
6123
6124         scsi = fc = sas = lan = ctl = targ = dmp = 0;
6125         for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
6126                 drvname = NULL;
6127                 if (MptCallbacks[cb_idx]) {
6128                         switch (MptDriverClass[cb_idx]) {
6129                         case MPTSPI_DRIVER:
6130                                 if (!scsi++) drvname = "SPI host";
6131                                 break;
6132                         case MPTFC_DRIVER:
6133                                 if (!fc++) drvname = "FC host";
6134                                 break;
6135                         case MPTSAS_DRIVER:
6136                                 if (!sas++) drvname = "SAS host";
6137                                 break;
6138                         case MPTLAN_DRIVER:
6139                                 if (!lan++) drvname = "LAN";
6140                                 break;
6141                         case MPTSTM_DRIVER:
6142                                 if (!targ++) drvname = "SCSI target";
6143                                 break;
6144                         case MPTCTL_DRIVER:
6145                                 if (!ctl++) drvname = "ioctl";
6146                                 break;
6147                         }
6148
6149                         if (drvname)
6150                                 len += sprintf(buf+len, "  Fusion MPT %s driver\n", drvname);
6151                 }
6152         }
6153
6154         MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
6155 }
6156
6157 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6158 /**
6159  *      procmpt_iocinfo_read - Handle read request from /proc/mpt/iocN/info.
6160  *      @buf: Pointer to area to write information
6161  *      @start: Pointer to start pointer
6162  *      @offset: Offset to start writing
6163  *      @request: Amount of read data requested
6164  *      @eof: Pointer to EOF integer
6165  *      @data: Pointer
6166  *
6167  *      Returns number of characters written to process performing the read.
6168  */
6169 static int
6170 procmpt_iocinfo_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
6171 {
6172         MPT_ADAPTER     *ioc = data;
6173         int              len;
6174         char             expVer[32];
6175         int              sz;
6176         int              p;
6177
6178         mpt_get_fw_exp_ver(expVer, ioc);
6179
6180         len = sprintf(buf, "%s:", ioc->name);
6181         if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
6182                 len += sprintf(buf+len, "  (f/w download boot flag set)");
6183 //      if (ioc->facts.IOCExceptions & MPI_IOCFACTS_EXCEPT_CONFIG_CHECKSUM_FAIL)
6184 //              len += sprintf(buf+len, "  CONFIG_CHECKSUM_FAIL!");
6185
6186         len += sprintf(buf+len, "\n  ProductID = 0x%04x (%s)\n",
6187                         ioc->facts.ProductID,
6188                         ioc->prod_name);
6189         len += sprintf(buf+len, "  FWVersion = 0x%08x%s", ioc->facts.FWVersion.Word, expVer);
6190         if (ioc->facts.FWImageSize)
6191                 len += sprintf(buf+len, " (fw_size=%d)", ioc->facts.FWImageSize);
6192         len += sprintf(buf+len, "\n  MsgVersion = 0x%04x\n", ioc->facts.MsgVersion);
6193         len += sprintf(buf+len, "  FirstWhoInit = 0x%02x\n", ioc->FirstWhoInit);
6194         len += sprintf(buf+len, "  EventState = 0x%02x\n", ioc->facts.EventState);
6195
6196         len += sprintf(buf+len, "  CurrentHostMfaHighAddr = 0x%08x\n",
6197                         ioc->facts.CurrentHostMfaHighAddr);
6198         len += sprintf(buf+len, "  CurrentSenseBufferHighAddr = 0x%08x\n",
6199                         ioc->facts.CurrentSenseBufferHighAddr);
6200
6201         len += sprintf(buf+len, "  MaxChainDepth = 0x%02x frames\n", ioc->facts.MaxChainDepth);
6202         len += sprintf(buf+len, "  MinBlockSize = 0x%02x bytes\n", 4*ioc->facts.BlockSize);
6203
6204         len += sprintf(buf+len, "  RequestFrames @ 0x%p (Dma @ 0x%p)\n",
6205                                         (void *)ioc->req_frames, (void *)(ulong)ioc->req_frames_dma);
6206         /*
6207          *  Rounding UP to nearest 4-kB boundary here...
6208          */
6209         sz = (ioc->req_sz * ioc->req_depth) + 128;
6210         sz = ((sz + 0x1000UL - 1UL) / 0x1000) * 0x1000;
6211         len += sprintf(buf+len, "    {CurReqSz=%d} x {CurReqDepth=%d} = %d bytes ^= 0x%x\n",
6212                                         ioc->req_sz, ioc->req_depth, ioc->req_sz*ioc->req_depth, sz);
6213         len += sprintf(buf+len, "    {MaxReqSz=%d}   {MaxReqDepth=%d}\n",
6214                                         4*ioc->facts.RequestFrameSize,
6215                                         ioc->facts.GlobalCredits);
6216
6217         len += sprintf(buf+len, "  Frames   @ 0x%p (Dma @ 0x%p)\n",
6218                                         (void *)ioc->alloc, (void *)(ulong)ioc->alloc_dma);
6219         sz = (ioc->reply_sz * ioc->reply_depth) + 128;
6220         len += sprintf(buf+len, "    {CurRepSz=%d} x {CurRepDepth=%d} = %d bytes ^= 0x%x\n",
6221                                         ioc->reply_sz, ioc->reply_depth, ioc->reply_sz*ioc->reply_depth, sz);
6222         len += sprintf(buf+len, "    {MaxRepSz=%d}   {MaxRepDepth=%d}\n",
6223                                         ioc->facts.CurReplyFrameSize,
6224                                         ioc->facts.ReplyQueueDepth);
6225
6226         len += sprintf(buf+len, "  MaxDevices = %d\n",
6227                         (ioc->facts.MaxDevices==0) ? 255 : ioc->facts.MaxDevices);
6228         len += sprintf(buf+len, "  MaxBuses = %d\n", ioc->facts.MaxBuses);
6229
6230         /* per-port info */
6231         for (p=0; p < ioc->facts.NumberOfPorts; p++) {
6232                 len += sprintf(buf+len, "  PortNumber = %d (of %d)\n",
6233                                 p+1,
6234                                 ioc->facts.NumberOfPorts);
6235                 if (ioc->bus_type == FC) {
6236                         if (ioc->pfacts[p].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
6237                                 u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
6238                                 len += sprintf(buf+len, "    LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
6239                                                 a[5], a[4], a[3], a[2], a[1], a[0]);
6240                         }
6241                         len += sprintf(buf+len, "    WWN = %08X%08X:%08X%08X\n",
6242                                         ioc->fc_port_page0[p].WWNN.High,
6243                                         ioc->fc_port_page0[p].WWNN.Low,
6244                                         ioc->fc_port_page0[p].WWPN.High,
6245                                         ioc->fc_port_page0[p].WWPN.Low);
6246                 }
6247         }
6248
6249         MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
6250 }
6251
6252 #endif          /* CONFIG_PROC_FS } */
6253
6254 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6255 static void
6256 mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc)
6257 {
6258         buf[0] ='\0';
6259         if ((ioc->facts.FWVersion.Word >> 24) == 0x0E) {
6260                 sprintf(buf, " (Exp %02d%02d)",
6261                         (ioc->facts.FWVersion.Word >> 16) & 0x00FF,     /* Month */
6262                         (ioc->facts.FWVersion.Word >> 8) & 0x1F);       /* Day */
6263
6264                 /* insider hack! */
6265                 if ((ioc->facts.FWVersion.Word >> 8) & 0x80)
6266                         strcat(buf, " [MDBG]");
6267         }
6268 }
6269
6270 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6271 /**
6272  *      mpt_print_ioc_summary - Write ASCII summary of IOC to a buffer.
6273  *      @ioc: Pointer to MPT_ADAPTER structure
6274  *      @buffer: Pointer to buffer where IOC summary info should be written
6275  *      @size: Pointer to number of bytes we wrote (set by this routine)
6276  *      @len: Offset at which to start writing in buffer
6277  *      @showlan: Display LAN stuff?
6278  *
6279  *      This routine writes (english readable) ASCII text, which represents
6280  *      a summary of IOC information, to a buffer.
6281  */
6282 void
6283 mpt_print_ioc_summary(MPT_ADAPTER *ioc, char *buffer, int *size, int len, int showlan)
6284 {
6285         char expVer[32];
6286         int y;
6287
6288         mpt_get_fw_exp_ver(expVer, ioc);
6289
6290         /*
6291          *  Shorter summary of attached ioc's...
6292          */
6293         y = sprintf(buffer+len, "%s: %s, %s%08xh%s, Ports=%d, MaxQ=%d",
6294                         ioc->name,
6295                         ioc->prod_name,
6296                         MPT_FW_REV_MAGIC_ID_STRING,     /* "FwRev=" or somesuch */
6297                         ioc->facts.FWVersion.Word,
6298                         expVer,
6299                         ioc->facts.NumberOfPorts,
6300                         ioc->req_depth);
6301
6302         if (showlan && (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN)) {
6303                 u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
6304                 y += sprintf(buffer+len+y, ", LanAddr=%02X:%02X:%02X:%02X:%02X:%02X",
6305                         a[5], a[4], a[3], a[2], a[1], a[0]);
6306         }
6307
6308         y += sprintf(buffer+len+y, ", IRQ=%d", ioc->pci_irq);
6309
6310         if (!ioc->active)
6311                 y += sprintf(buffer+len+y, " (disabled)");
6312
6313         y += sprintf(buffer+len+y, "\n");
6314
6315         *size = y;
6316 }
6317
6318 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6319 /*
6320  *      Reset Handling
6321  */
6322 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6323 /**
6324  *      mpt_HardResetHandler - Generic reset handler
6325  *      @ioc: Pointer to MPT_ADAPTER structure
6326  *      @sleepFlag: Indicates if sleep or schedule must be called.
6327  *
6328  *      Issues SCSI Task Management call based on input arg values.
6329  *      If TaskMgmt fails, returns associated SCSI request.
6330  *
6331  *      Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
6332  *      or a non-interrupt thread.  In the former, must not call schedule().
6333  *
6334  *      Note: A return of -1 is a FATAL error case, as it means a
6335  *      FW reload/initialization failed.
6336  *
6337  *      Returns 0 for SUCCESS or -1 if FAILED.
6338  */
6339 int
6340 mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag)
6341 {
6342         int              rc;
6343         unsigned long    flags;
6344
6345         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler Entered!\n", ioc->name));
6346 #ifdef MFCNT
6347         printk(MYIOC_s_INFO_FMT "HardResetHandler Entered!\n", ioc->name);
6348         printk("MF count 0x%x !\n", ioc->mfcnt);
6349 #endif
6350
6351         /* Reset the adapter. Prevent more than 1 call to
6352          * mpt_do_ioc_recovery at any instant in time.
6353          */
6354         spin_lock_irqsave(&ioc->diagLock, flags);
6355         if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)){
6356                 spin_unlock_irqrestore(&ioc->diagLock, flags);
6357                 return 0;
6358         } else {
6359                 ioc->diagPending = 1;
6360         }
6361         spin_unlock_irqrestore(&ioc->diagLock, flags);
6362
6363         /* FIXME: If do_ioc_recovery fails, repeat....
6364          */
6365
6366         /* The SCSI driver needs to adjust timeouts on all current
6367          * commands prior to the diagnostic reset being issued.
6368          * Prevents timeouts occurring during a diagnostic reset...very bad.
6369          * For all other protocol drivers, this is a no-op.
6370          */
6371         {
6372                 u8       cb_idx;
6373                 int      r = 0;
6374
6375                 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
6376                         if (MptResetHandlers[cb_idx]) {
6377                                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling IOC reset_setup handler #%d\n",
6378                                                 ioc->name, cb_idx));
6379                                 r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_SETUP_RESET);
6380                                 if (ioc->alt_ioc) {
6381                                         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling alt-%s setup reset handler #%d\n",
6382                                                         ioc->name, ioc->alt_ioc->name, cb_idx));
6383                                         r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_SETUP_RESET);
6384                                 }
6385                         }
6386                 }
6387         }
6388
6389         if ((rc = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_RECOVER, sleepFlag)) != 0) {
6390                 printk(MYIOC_s_WARN_FMT "Cannot recover rc = %d!\n", ioc->name, rc);
6391         }
6392         ioc->reload_fw = 0;
6393         if (ioc->alt_ioc)
6394                 ioc->alt_ioc->reload_fw = 0;
6395
6396         spin_lock_irqsave(&ioc->diagLock, flags);
6397         ioc->diagPending = 0;
6398         if (ioc->alt_ioc)
6399                 ioc->alt_ioc->diagPending = 0;
6400         spin_unlock_irqrestore(&ioc->diagLock, flags);
6401
6402         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler rc = %d!\n", ioc->name, rc));
6403
6404         return rc;
6405 }
6406
6407 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6408 static void
6409 EventDescriptionStr(u8 event, u32 evData0, char *evStr)
6410 {
6411         char *ds = NULL;
6412
6413         switch(event) {
6414         case MPI_EVENT_NONE:
6415                 ds = "None";
6416                 break;
6417         case MPI_EVENT_LOG_DATA:
6418                 ds = "Log Data";
6419                 break;
6420         case MPI_EVENT_STATE_CHANGE:
6421                 ds = "State Change";
6422                 break;
6423         case MPI_EVENT_UNIT_ATTENTION:
6424                 ds = "Unit Attention";
6425                 break;
6426         case MPI_EVENT_IOC_BUS_RESET:
6427                 ds = "IOC Bus Reset";
6428                 break;
6429         case MPI_EVENT_EXT_BUS_RESET:
6430                 ds = "External Bus Reset";
6431                 break;
6432         case MPI_EVENT_RESCAN:
6433                 ds = "Bus Rescan Event";
6434                 break;
6435         case MPI_EVENT_LINK_STATUS_CHANGE:
6436                 if (evData0 == MPI_EVENT_LINK_STATUS_FAILURE)
6437                         ds = "Link Status(FAILURE) Change";
6438                 else
6439                         ds = "Link Status(ACTIVE) Change";
6440                 break;
6441         case MPI_EVENT_LOOP_STATE_CHANGE:
6442                 if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LIP)
6443                         ds = "Loop State(LIP) Change";
6444                 else if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LPE)
6445                         ds = "Loop State(LPE) Change";          /* ??? */
6446                 else
6447                         ds = "Loop State(LPB) Change";          /* ??? */
6448                 break;
6449         case MPI_EVENT_LOGOUT:
6450                 ds = "Logout";
6451                 break;
6452         case MPI_EVENT_EVENT_CHANGE:
6453                 if (evData0)
6454                         ds = "Events ON";
6455                 else
6456                         ds = "Events OFF";
6457                 break;
6458         case MPI_EVENT_INTEGRATED_RAID:
6459         {
6460                 u8 ReasonCode = (u8)(evData0 >> 16);
6461                 switch (ReasonCode) {
6462                 case MPI_EVENT_RAID_RC_VOLUME_CREATED :
6463                         ds = "Integrated Raid: Volume Created";
6464                         break;
6465                 case MPI_EVENT_RAID_RC_VOLUME_DELETED :
6466                         ds = "Integrated Raid: Volume Deleted";
6467                         break;
6468                 case MPI_EVENT_RAID_RC_VOLUME_SETTINGS_CHANGED :
6469                         ds = "Integrated Raid: Volume Settings Changed";
6470                         break;
6471                 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED :
6472                         ds = "Integrated Raid: Volume Status Changed";
6473                         break;
6474                 case MPI_EVENT_RAID_RC_VOLUME_PHYSDISK_CHANGED :
6475                         ds = "Integrated Raid: Volume Physdisk Changed";
6476                         break;
6477                 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED :
6478                         ds = "Integrated Raid: Physdisk Created";
6479                         break;
6480                 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED :
6481                         ds = "Integrated Raid: Physdisk Deleted";
6482                         break;
6483                 case MPI_EVENT_RAID_RC_PHYSDISK_SETTINGS_CHANGED :
6484                         ds = "Integrated Raid: Physdisk Settings Changed";
6485                         break;
6486                 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED :
6487                         ds = "Integrated Raid: Physdisk Status Changed";
6488                         break;
6489                 case MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED :
6490                         ds = "Integrated Raid: Domain Validation Needed";
6491                         break;
6492                 case MPI_EVENT_RAID_RC_SMART_DATA :
6493                         ds = "Integrated Raid; Smart Data";
6494                         break;
6495                 case MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED :
6496                         ds = "Integrated Raid: Replace Action Started";
6497                         break;
6498                 default:
6499                         ds = "Integrated Raid";
6500                 break;
6501                 }
6502                 break;
6503         }
6504         case MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE:
6505                 ds = "SCSI Device Status Change";
6506                 break;
6507         case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
6508         {
6509                 u8 id = (u8)(evData0);
6510                 u8 channel = (u8)(evData0 >> 8);
6511                 u8 ReasonCode = (u8)(evData0 >> 16);
6512                 switch (ReasonCode) {
6513                 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
6514                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6515                             "SAS Device Status Change: Added: "
6516                             "id=%d channel=%d", id, channel);
6517                         break;
6518                 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
6519                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6520                             "SAS Device Status Change: Deleted: "
6521                             "id=%d channel=%d", id, channel);
6522                         break;
6523                 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
6524                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6525                             "SAS Device Status Change: SMART Data: "
6526                             "id=%d channel=%d", id, channel);
6527                         break;
6528                 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
6529                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6530                             "SAS Device Status Change: No Persistancy: "
6531                             "id=%d channel=%d", id, channel);
6532                         break;
6533                 case MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
6534                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6535                             "SAS Device Status Change: Unsupported Device "
6536                             "Discovered : id=%d channel=%d", id, channel);
6537                         break;
6538                 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
6539                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6540                             "SAS Device Status Change: Internal Device "
6541                             "Reset : id=%d channel=%d", id, channel);
6542                         break;
6543                 case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
6544                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6545                             "SAS Device Status Change: Internal Task "
6546                             "Abort : id=%d channel=%d", id, channel);
6547                         break;
6548                 case MPI_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
6549                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6550                             "SAS Device Status Change: Internal Abort "
6551                             "Task Set : id=%d channel=%d", id, channel);
6552                         break;
6553                 case MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
6554                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6555                             "SAS Device Status Change: Internal Clear "
6556                             "Task Set : id=%d channel=%d", id, channel);
6557                         break;
6558                 case MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
6559                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6560                             "SAS Device Status Change: Internal Query "
6561                             "Task : id=%d channel=%d", id, channel);
6562                         break;
6563                 default:
6564                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6565                             "SAS Device Status Change: Unknown: "
6566                             "id=%d channel=%d", id, channel);
6567                         break;
6568                 }
6569                 break;
6570         }
6571         case MPI_EVENT_ON_BUS_TIMER_EXPIRED:
6572                 ds = "Bus Timer Expired";
6573                 break;
6574         case MPI_EVENT_QUEUE_FULL:
6575         {
6576                 u16 curr_depth = (u16)(evData0 >> 16);
6577                 u8 channel = (u8)(evData0 >> 8);
6578                 u8 id = (u8)(evData0);
6579
6580                 snprintf(evStr, EVENT_DESCR_STR_SZ,
6581                    "Queue Full: channel=%d id=%d depth=%d",
6582                    channel, id, curr_depth);
6583                 break;
6584         }
6585         case MPI_EVENT_SAS_SES:
6586                 ds = "SAS SES Event";
6587                 break;
6588         case MPI_EVENT_PERSISTENT_TABLE_FULL:
6589                 ds = "Persistent Table Full";
6590                 break;
6591         case MPI_EVENT_SAS_PHY_LINK_STATUS:
6592         {
6593                 u8 LinkRates = (u8)(evData0 >> 8);
6594                 u8 PhyNumber = (u8)(evData0);
6595                 LinkRates = (LinkRates & MPI_EVENT_SAS_PLS_LR_CURRENT_MASK) >>
6596                         MPI_EVENT_SAS_PLS_LR_CURRENT_SHIFT;
6597                 switch (LinkRates) {
6598                 case MPI_EVENT_SAS_PLS_LR_RATE_UNKNOWN:
6599                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6600                            "SAS PHY Link Status: Phy=%d:"
6601                            " Rate Unknown",PhyNumber);
6602                         break;
6603                 case MPI_EVENT_SAS_PLS_LR_RATE_PHY_DISABLED:
6604                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6605                            "SAS PHY Link Status: Phy=%d:"
6606                            " Phy Disabled",PhyNumber);
6607                         break;
6608                 case MPI_EVENT_SAS_PLS_LR_RATE_FAILED_SPEED_NEGOTIATION:
6609                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6610                            "SAS PHY Link Status: Phy=%d:"
6611                            " Failed Speed Nego",PhyNumber);
6612                         break;
6613                 case MPI_EVENT_SAS_PLS_LR_RATE_SATA_OOB_COMPLETE:
6614                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6615                            "SAS PHY Link Status: Phy=%d:"
6616                            " Sata OOB Completed",PhyNumber);
6617                         break;
6618                 case MPI_EVENT_SAS_PLS_LR_RATE_1_5:
6619                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6620                            "SAS PHY Link Status: Phy=%d:"
6621                            " Rate 1.5 Gbps",PhyNumber);
6622                         break;
6623                 case MPI_EVENT_SAS_PLS_LR_RATE_3_0:
6624                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6625                            "SAS PHY Link Status: Phy=%d:"
6626                            " Rate 3.0 Gpbs",PhyNumber);
6627                         break;
6628                 default:
6629                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6630                            "SAS PHY Link Status: Phy=%d", PhyNumber);
6631                         break;
6632                 }
6633                 break;
6634         }
6635         case MPI_EVENT_SAS_DISCOVERY_ERROR:
6636                 ds = "SAS Discovery Error";
6637                 break;
6638         case MPI_EVENT_IR_RESYNC_UPDATE:
6639         {
6640                 u8 resync_complete = (u8)(evData0 >> 16);
6641                 snprintf(evStr, EVENT_DESCR_STR_SZ,
6642                     "IR Resync Update: Complete = %d:",resync_complete);
6643                 break;
6644         }
6645         case MPI_EVENT_IR2:
6646         {
6647                 u8 ReasonCode = (u8)(evData0 >> 16);
6648                 switch (ReasonCode) {
6649                 case MPI_EVENT_IR2_RC_LD_STATE_CHANGED:
6650                         ds = "IR2: LD State Changed";
6651                         break;
6652                 case MPI_EVENT_IR2_RC_PD_STATE_CHANGED:
6653                         ds = "IR2: PD State Changed";
6654                         break;
6655                 case MPI_EVENT_IR2_RC_BAD_BLOCK_TABLE_FULL:
6656                         ds = "IR2: Bad Block Table Full";
6657                         break;
6658                 case MPI_EVENT_IR2_RC_PD_INSERTED:
6659                         ds = "IR2: PD Inserted";
6660                         break;
6661                 case MPI_EVENT_IR2_RC_PD_REMOVED:
6662                         ds = "IR2: PD Removed";
6663                         break;
6664                 case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
6665                         ds = "IR2: Foreign CFG Detected";
6666                         break;
6667                 case MPI_EVENT_IR2_RC_REBUILD_MEDIUM_ERROR:
6668                         ds = "IR2: Rebuild Medium Error";
6669                         break;
6670                 default:
6671                         ds = "IR2";
6672                 break;
6673                 }
6674                 break;
6675         }
6676         case MPI_EVENT_SAS_DISCOVERY:
6677         {
6678                 if (evData0)
6679                         ds = "SAS Discovery: Start";
6680                 else
6681                         ds = "SAS Discovery: Stop";
6682                 break;
6683         }
6684         case MPI_EVENT_LOG_ENTRY_ADDED:
6685                 ds = "SAS Log Entry Added";
6686                 break;
6687
6688         case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
6689         {
6690                 u8 phy_num = (u8)(evData0);
6691                 u8 port_num = (u8)(evData0 >> 8);
6692                 u8 port_width = (u8)(evData0 >> 16);
6693                 u8 primative = (u8)(evData0 >> 24);
6694                 snprintf(evStr, EVENT_DESCR_STR_SZ,
6695                     "SAS Broadcase Primative: phy=%d port=%d "
6696                     "width=%d primative=0x%02x",
6697                     phy_num, port_num, port_width, primative);
6698                 break;
6699         }
6700
6701         case MPI_EVENT_SAS_INIT_DEVICE_STATUS_CHANGE:
6702         {
6703                 u8 reason = (u8)(evData0);
6704                 u8 port_num = (u8)(evData0 >> 8);
6705                 u16 handle = le16_to_cpu(evData0 >> 16);
6706
6707                 snprintf(evStr, EVENT_DESCR_STR_SZ,
6708                     "SAS Initiator Device Status Change: reason=0x%02x "
6709                     "port=%d handle=0x%04x",
6710                     reason, port_num, handle);
6711                 break;
6712         }
6713
6714         case MPI_EVENT_SAS_INIT_TABLE_OVERFLOW:
6715         {
6716                 u8 max_init = (u8)(evData0);
6717                 u8 current_init = (u8)(evData0 >> 8);
6718
6719                 snprintf(evStr, EVENT_DESCR_STR_SZ,
6720                     "SAS Initiator Device Table Overflow: max initiators=%02d "
6721                     "current initators=%02d",
6722                     max_init, current_init);
6723                 break;
6724         }
6725         case MPI_EVENT_SAS_SMP_ERROR:
6726         {
6727                 u8 status = (u8)(evData0);
6728                 u8 port_num = (u8)(evData0 >> 8);
6729                 u8 result = (u8)(evData0 >> 16);
6730
6731                 if (status == MPI_EVENT_SAS_SMP_FUNCTION_RESULT_VALID)
6732                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6733                             "SAS SMP Error: port=%d result=0x%02x",
6734                             port_num, result);
6735                 else if (status == MPI_EVENT_SAS_SMP_CRC_ERROR)
6736                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6737                             "SAS SMP Error: port=%d : CRC Error",
6738                             port_num);
6739                 else if (status == MPI_EVENT_SAS_SMP_TIMEOUT)
6740                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6741                             "SAS SMP Error: port=%d : Timeout",
6742                             port_num);
6743                 else if (status == MPI_EVENT_SAS_SMP_NO_DESTINATION)
6744                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6745                             "SAS SMP Error: port=%d : No Destination",
6746                             port_num);
6747                 else if (status == MPI_EVENT_SAS_SMP_BAD_DESTINATION)
6748                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6749                             "SAS SMP Error: port=%d : Bad Destination",
6750                             port_num);
6751                 else
6752                         snprintf(evStr, EVENT_DESCR_STR_SZ,
6753                             "SAS SMP Error: port=%d : status=0x%02x",
6754                             port_num, status);
6755                 break;
6756         }
6757
6758         /*
6759          *  MPT base "custom" events may be added here...
6760          */
6761         default:
6762                 ds = "Unknown";
6763                 break;
6764         }
6765         if (ds)
6766                 strncpy(evStr, ds, EVENT_DESCR_STR_SZ);
6767 }
6768
6769 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6770 /**
6771  *      ProcessEventNotification - Route EventNotificationReply to all event handlers
6772  *      @ioc: Pointer to MPT_ADAPTER structure
6773  *      @pEventReply: Pointer to EventNotification reply frame
6774  *      @evHandlers: Pointer to integer, number of event handlers
6775  *
6776  *      Routes a received EventNotificationReply to all currently registered
6777  *      event handlers.
6778  *      Returns sum of event handlers return values.
6779  */
6780 static int
6781 ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *pEventReply, int *evHandlers)
6782 {
6783         u16 evDataLen;
6784         u32 evData0 = 0;
6785 //      u32 evCtx;
6786         int ii;
6787         u8 cb_idx;
6788         int r = 0;
6789         int handlers = 0;
6790         char evStr[EVENT_DESCR_STR_SZ];
6791         u8 event;
6792
6793         /*
6794          *  Do platform normalization of values
6795          */
6796         event = le32_to_cpu(pEventReply->Event) & 0xFF;
6797 //      evCtx = le32_to_cpu(pEventReply->EventContext);
6798         evDataLen = le16_to_cpu(pEventReply->EventDataLength);
6799         if (evDataLen) {
6800                 evData0 = le32_to_cpu(pEventReply->Data[0]);
6801         }
6802
6803         EventDescriptionStr(event, evData0, evStr);
6804         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event:(%02Xh) : %s\n",
6805                         ioc->name,
6806                         event,
6807                         evStr));
6808
6809 #ifdef CONFIG_FUSION_LOGGING
6810         devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
6811             ": Event data:\n", ioc->name));
6812         for (ii = 0; ii < evDataLen; ii++)
6813                 devtverboseprintk(ioc, printk(" %08x",
6814                     le32_to_cpu(pEventReply->Data[ii])));
6815         devtverboseprintk(ioc, printk("\n"));
6816 #endif
6817
6818         /*
6819          *  Do general / base driver event processing
6820          */
6821         switch(event) {
6822         case MPI_EVENT_EVENT_CHANGE:            /* 0A */
6823                 if (evDataLen) {
6824                         u8 evState = evData0 & 0xFF;
6825
6826                         /* CHECKME! What if evState unexpectedly says OFF (0)? */
6827
6828                         /* Update EventState field in cached IocFacts */
6829                         if (ioc->facts.Function) {
6830                                 ioc->facts.EventState = evState;
6831                         }
6832                 }
6833                 break;
6834         case MPI_EVENT_INTEGRATED_RAID:
6835                 mptbase_raid_process_event_data(ioc,
6836                     (MpiEventDataRaid_t *)pEventReply->Data);
6837                 break;
6838         default:
6839                 break;
6840         }
6841
6842         /*
6843          * Should this event be logged? Events are written sequentially.
6844          * When buffer is full, start again at the top.
6845          */
6846         if (ioc->events && (ioc->eventTypes & ( 1 << event))) {
6847                 int idx;
6848
6849                 idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE;
6850
6851                 ioc->events[idx].event = event;
6852                 ioc->events[idx].eventContext = ioc->eventContext;
6853
6854                 for (ii = 0; ii < 2; ii++) {
6855                         if (ii < evDataLen)
6856                                 ioc->events[idx].data[ii] = le32_to_cpu(pEventReply->Data[ii]);
6857                         else
6858                                 ioc->events[idx].data[ii] =  0;
6859                 }
6860
6861                 ioc->eventContext++;
6862         }
6863
6864
6865         /*
6866          *  Call each currently registered protocol event handler.
6867          */
6868         for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
6869                 if (MptEvHandlers[cb_idx]) {
6870                         devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Routing Event to event handler #%d\n",
6871                                         ioc->name, cb_idx));
6872                         r += (*(MptEvHandlers[cb_idx]))(ioc, pEventReply);
6873                         handlers++;
6874                 }
6875         }
6876         /* FIXME?  Examine results here? */
6877
6878         /*
6879          *  If needed, send (a single) EventAck.
6880          */
6881         if (pEventReply->AckRequired == MPI_EVENT_NOTIFICATION_ACK_REQUIRED) {
6882                 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
6883                         "EventAck required\n",ioc->name));
6884                 if ((ii = SendEventAck(ioc, pEventReply)) != 0) {
6885                         devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SendEventAck returned %d\n",
6886                                         ioc->name, ii));
6887                 }
6888         }
6889
6890         *evHandlers = handlers;
6891         return r;
6892 }
6893
6894 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6895 /**
6896  *      mpt_fc_log_info - Log information returned from Fibre Channel IOC.
6897  *      @ioc: Pointer to MPT_ADAPTER structure
6898  *      @log_info: U32 LogInfo reply word from the IOC
6899  *
6900  *      Refer to lsi/mpi_log_fc.h.
6901  */
6902 static void
6903 mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info)
6904 {
6905         char *desc = "unknown";
6906
6907         switch (log_info & 0xFF000000) {
6908         case MPI_IOCLOGINFO_FC_INIT_BASE:
6909                 desc = "FCP Initiator";
6910                 break;
6911         case MPI_IOCLOGINFO_FC_TARGET_BASE:
6912                 desc = "FCP Target";
6913                 break;
6914         case MPI_IOCLOGINFO_FC_LAN_BASE:
6915                 desc = "LAN";
6916                 break;
6917         case MPI_IOCLOGINFO_FC_MSG_BASE:
6918                 desc = "MPI Message Layer";
6919                 break;
6920         case MPI_IOCLOGINFO_FC_LINK_BASE:
6921                 desc = "FC Link";
6922                 break;
6923         case MPI_IOCLOGINFO_FC_CTX_BASE:
6924                 desc = "Context Manager";
6925                 break;
6926         case MPI_IOCLOGINFO_FC_INVALID_FIELD_BYTE_OFFSET:
6927                 desc = "Invalid Field Offset";
6928                 break;
6929         case MPI_IOCLOGINFO_FC_STATE_CHANGE:
6930                 desc = "State Change Info";
6931                 break;
6932         }
6933
6934         printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): SubClass={%s}, Value=(0x%06x)\n",
6935                         ioc->name, log_info, desc, (log_info & 0xFFFFFF));
6936 }
6937
6938 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6939 /**
6940  *      mpt_spi_log_info - Log information returned from SCSI Parallel IOC.
6941  *      @ioc: Pointer to MPT_ADAPTER structure
6942  *      @mr: Pointer to MPT reply frame
6943  *      @log_info: U32 LogInfo word from the IOC
6944  *
6945  *      Refer to lsi/sp_log.h.
6946  */
6947 static void
6948 mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info)
6949 {
6950         u32 info = log_info & 0x00FF0000;
6951         char *desc = "unknown";
6952
6953         switch (info) {
6954         case 0x00010000:
6955                 desc = "bug! MID not found";
6956                 if (ioc->reload_fw == 0)
6957                         ioc->reload_fw++;
6958                 break;
6959
6960         case 0x00020000:
6961                 desc = "Parity Error";
6962                 break;
6963
6964         case 0x00030000:
6965                 desc = "ASYNC Outbound Overrun";
6966                 break;
6967
6968         case 0x00040000:
6969                 desc = "SYNC Offset Error";
6970                 break;
6971
6972         case 0x00050000:
6973                 desc = "BM Change";
6974                 break;
6975
6976         case 0x00060000:
6977                 desc = "Msg In Overflow";
6978                 break;
6979
6980         case 0x00070000:
6981                 desc = "DMA Error";
6982                 break;
6983
6984         case 0x00080000:
6985                 desc = "Outbound DMA Overrun";
6986                 break;
6987
6988         case 0x00090000:
6989                 desc = "Task Management";
6990                 break;
6991
6992         case 0x000A0000:
6993                 desc = "Device Problem";
6994                 break;
6995
6996         case 0x000B0000:
6997                 desc = "Invalid Phase Change";
6998                 break;
6999
7000         case 0x000C0000:
7001                 desc = "Untagged Table Size";
7002                 break;
7003
7004         }
7005
7006         printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): F/W: %s\n", ioc->name, log_info, desc);
7007 }
7008
7009 /* strings for sas loginfo */
7010         static char *originator_str[] = {
7011                 "IOP",                                          /* 00h */
7012                 "PL",                                           /* 01h */
7013                 "IR"                                            /* 02h */
7014         };
7015         static char *iop_code_str[] = {
7016                 NULL,                                           /* 00h */
7017                 "Invalid SAS Address",                          /* 01h */
7018                 NULL,                                           /* 02h */
7019                 "Invalid Page",                                 /* 03h */
7020                 "Diag Message Error",                           /* 04h */
7021                 "Task Terminated",                              /* 05h */
7022                 "Enclosure Management",                         /* 06h */
7023                 "Target Mode"                                   /* 07h */
7024         };
7025         static char *pl_code_str[] = {
7026                 NULL,                                           /* 00h */
7027                 "Open Failure",                                 /* 01h */
7028                 "Invalid Scatter Gather List",                  /* 02h */
7029                 "Wrong Relative Offset or Frame Length",        /* 03h */
7030                 "Frame Transfer Error",                         /* 04h */
7031                 "Transmit Frame Connected Low",                 /* 05h */
7032                 "SATA Non-NCQ RW Error Bit Set",                /* 06h */
7033                 "SATA Read Log Receive Data Error",             /* 07h */
7034                 "SATA NCQ Fail All Commands After Error",       /* 08h */
7035                 "SATA Error in Receive Set Device Bit FIS",     /* 09h */
7036                 "Receive Frame Invalid Message",                /* 0Ah */
7037                 "Receive Context Message Valid Error",          /* 0Bh */
7038                 "Receive Frame Current Frame Error",            /* 0Ch */
7039                 "SATA Link Down",                               /* 0Dh */
7040                 "Discovery SATA Init W IOS",                    /* 0Eh */
7041                 "Config Invalid Page",                          /* 0Fh */
7042                 "Discovery SATA Init Timeout",                  /* 10h */
7043                 "Reset",                                        /* 11h */
7044                 "Abort",                                        /* 12h */
7045                 "IO Not Yet Executed",                          /* 13h */
7046                 "IO Executed",                                  /* 14h */
7047                 "Persistent Reservation Out Not Affiliation "
7048                     "Owner",                                    /* 15h */
7049                 "Open Transmit DMA Abort",                      /* 16h */
7050                 "IO Device Missing Delay Retry",                /* 17h */
7051                 "IO Cancelled Due to Recieve Error",            /* 18h */
7052                 NULL,                                           /* 19h */
7053                 NULL,                                           /* 1Ah */
7054                 NULL,                                           /* 1Bh */
7055                 NULL,                                           /* 1Ch */
7056                 NULL,                                           /* 1Dh */
7057                 NULL,                                           /* 1Eh */
7058                 NULL,                                           /* 1Fh */
7059                 "Enclosure Management"                          /* 20h */
7060         };
7061         static char *ir_code_str[] = {
7062                 "Raid Action Error",                            /* 00h */
7063                 NULL,                                           /* 00h */
7064                 NULL,                                           /* 01h */
7065                 NULL,                                           /* 02h */
7066                 NULL,                                           /* 03h */
7067                 NULL,                                           /* 04h */
7068                 NULL,                                           /* 05h */
7069                 NULL,                                           /* 06h */
7070                 NULL                                            /* 07h */
7071         };
7072         static char *raid_sub_code_str[] = {
7073                 NULL,                                           /* 00h */
7074                 "Volume Creation Failed: Data Passed too "
7075                     "Large",                                    /* 01h */
7076                 "Volume Creation Failed: Duplicate Volumes "
7077                     "Attempted",                                /* 02h */
7078                 "Volume Creation Failed: Max Number "
7079                     "Supported Volumes Exceeded",               /* 03h */
7080                 "Volume Creation Failed: DMA Error",            /* 04h */
7081                 "Volume Creation Failed: Invalid Volume Type",  /* 05h */
7082                 "Volume Creation Failed: Error Reading "
7083                     "MFG Page 4",                               /* 06h */
7084                 "Volume Creation Failed: Creating Internal "
7085                     "Structures",                               /* 07h */
7086                 NULL,                                           /* 08h */
7087                 NULL,                                           /* 09h */
7088                 NULL,                                           /* 0Ah */
7089                 NULL,                                           /* 0Bh */
7090                 NULL,                                           /* 0Ch */
7091                 NULL,                                           /* 0Dh */
7092                 NULL,                                           /* 0Eh */
7093                 NULL,                                           /* 0Fh */
7094                 "Activation failed: Already Active Volume",     /* 10h */
7095                 "Activation failed: Unsupported Volume Type",   /* 11h */
7096                 "Activation failed: Too Many Active Volumes",   /* 12h */
7097                 "Activation failed: Volume ID in Use",          /* 13h */
7098                 "Activation failed: Reported Failure",          /* 14h */
7099                 "Activation failed: Importing a Volume",        /* 15h */
7100                 NULL,                                           /* 16h */
7101                 NULL,                                           /* 17h */
7102                 NULL,                                           /* 18h */
7103                 NULL,                                           /* 19h */
7104                 NULL,                                           /* 1Ah */
7105                 NULL,                                           /* 1Bh */
7106                 NULL,                                           /* 1Ch */
7107                 NULL,                                           /* 1Dh */
7108                 NULL,                                           /* 1Eh */
7109                 NULL,                                           /* 1Fh */
7110                 "Phys Disk failed: Too Many Phys Disks",        /* 20h */
7111                 "Phys Disk failed: Data Passed too Large",      /* 21h */
7112                 "Phys Disk failed: DMA Error",                  /* 22h */
7113                 "Phys Disk failed: Invalid <channel:id>",       /* 23h */
7114                 "Phys Disk failed: Creating Phys Disk Config "
7115                     "Page",                                     /* 24h */
7116                 NULL,                                           /* 25h */
7117                 NULL,                                           /* 26h */
7118                 NULL,                                           /* 27h */
7119                 NULL,                                           /* 28h */
7120                 NULL,                                           /* 29h */
7121                 NULL,                                           /* 2Ah */
7122                 NULL,                                           /* 2Bh */
7123                 NULL,                                           /* 2Ch */
7124                 NULL,                                           /* 2Dh */
7125                 NULL,                                           /* 2Eh */
7126                 NULL,                                           /* 2Fh */
7127                 "Compatibility Error: IR Disabled",             /* 30h */
7128                 "Compatibility Error: Inquiry Comand Failed",   /* 31h */
7129                 "Compatibility Error: Device not Direct Access "
7130                     "Device ",                                  /* 32h */
7131                 "Compatibility Error: Removable Device Found",  /* 33h */
7132                 "Compatibility Error: Device SCSI Version not "
7133                     "2 or Higher",                              /* 34h */
7134                 "Compatibility Error: SATA Device, 48 BIT LBA "
7135                     "not Supported",                            /* 35h */
7136                 "Compatibility Error: Device doesn't have "
7137                     "512 Byte Block Sizes",                     /* 36h */
7138                 "Compatibility Error: Volume Type Check Failed", /* 37h */
7139                 "Compatibility Error: Volume Type is "
7140                     "Unsupported by FW",                        /* 38h */
7141                 "Compatibility Error: Disk Drive too Small for "
7142                     "use in Volume",                            /* 39h */
7143                 "Compatibility Error: Phys Disk for Create "
7144                     "Volume not Found",                         /* 3Ah */
7145                 "Compatibility Error: Too Many or too Few "
7146                     "Disks for Volume Type",                    /* 3Bh */
7147                 "Compatibility Error: Disk stripe Sizes "
7148                     "Must be 64KB",                             /* 3Ch */
7149                 "Compatibility Error: IME Size Limited to < 2TB", /* 3Dh */
7150         };
7151
7152 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7153 /**
7154  *      mpt_sas_log_info - Log information returned from SAS IOC.
7155  *      @ioc: Pointer to MPT_ADAPTER structure
7156  *      @log_info: U32 LogInfo reply word from the IOC
7157  *
7158  *      Refer to lsi/mpi_log_sas.h.
7159  **/
7160 static void
7161 mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info)
7162 {
7163 union loginfo_type {
7164         u32     loginfo;
7165         struct {
7166                 u32     subcode:16;
7167                 u32     code:8;
7168                 u32     originator:4;
7169                 u32     bus_type:4;
7170         }dw;
7171 };
7172         union loginfo_type sas_loginfo;
7173         char *originator_desc = NULL;
7174         char *code_desc = NULL;
7175         char *sub_code_desc = NULL;
7176
7177         sas_loginfo.loginfo = log_info;
7178         if ((sas_loginfo.dw.bus_type != 3 /*SAS*/) &&
7179             (sas_loginfo.dw.originator < sizeof(originator_str)/sizeof(char*)))
7180                 return;
7181
7182         originator_desc = originator_str[sas_loginfo.dw.originator];
7183
7184         switch (sas_loginfo.dw.originator) {
7185
7186                 case 0:  /* IOP */
7187                         if (sas_loginfo.dw.code <
7188                             sizeof(iop_code_str)/sizeof(char*))
7189                                 code_desc = iop_code_str[sas_loginfo.dw.code];
7190                         break;
7191                 case 1:  /* PL */
7192                         if (sas_loginfo.dw.code <
7193                             sizeof(pl_code_str)/sizeof(char*))
7194                                 code_desc = pl_code_str[sas_loginfo.dw.code];
7195                         break;
7196                 case 2:  /* IR */
7197                         if (sas_loginfo.dw.code >=
7198                             sizeof(ir_code_str)/sizeof(char*))
7199                                 break;
7200                         code_desc = ir_code_str[sas_loginfo.dw.code];
7201                         if (sas_loginfo.dw.subcode >=
7202                             sizeof(raid_sub_code_str)/sizeof(char*))
7203                         break;
7204                         if (sas_loginfo.dw.code == 0)
7205                                 sub_code_desc =
7206                                     raid_sub_code_str[sas_loginfo.dw.subcode];
7207                         break;
7208                 default:
7209                         return;
7210         }
7211
7212         if (sub_code_desc != NULL)
7213                 printk(MYIOC_s_INFO_FMT
7214                         "LogInfo(0x%08x): Originator={%s}, Code={%s},"
7215                         " SubCode={%s}\n",
7216                         ioc->name, log_info, originator_desc, code_desc,
7217                         sub_code_desc);
7218         else if (code_desc != NULL)
7219                 printk(MYIOC_s_INFO_FMT
7220                         "LogInfo(0x%08x): Originator={%s}, Code={%s},"
7221                         " SubCode(0x%04x)\n",
7222                         ioc->name, log_info, originator_desc, code_desc,
7223                         sas_loginfo.dw.subcode);
7224         else
7225                 printk(MYIOC_s_INFO_FMT
7226                         "LogInfo(0x%08x): Originator={%s}, Code=(0x%02x),"
7227                         " SubCode(0x%04x)\n",
7228                         ioc->name, log_info, originator_desc,
7229                         sas_loginfo.dw.code, sas_loginfo.dw.subcode);
7230 }
7231
7232 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7233 /**
7234  *      mpt_iocstatus_info_config - IOCSTATUS information for config pages
7235  *      @ioc: Pointer to MPT_ADAPTER structure
7236  *      @ioc_status: U32 IOCStatus word from IOC
7237  *      @mf: Pointer to MPT request frame
7238  *
7239  *      Refer to lsi/mpi.h.
7240  **/
7241 static void
7242 mpt_iocstatus_info_config(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf)
7243 {
7244         Config_t *pReq = (Config_t *)mf;
7245         char extend_desc[EVENT_DESCR_STR_SZ];
7246         char *desc = NULL;
7247         u32 form;
7248         u8 page_type;
7249
7250         if (pReq->Header.PageType == MPI_CONFIG_PAGETYPE_EXTENDED)
7251                 page_type = pReq->ExtPageType;
7252         else
7253                 page_type = pReq->Header.PageType;
7254
7255         /*
7256          * ignore invalid page messages for GET_NEXT_HANDLE
7257          */
7258         form = le32_to_cpu(pReq->PageAddress);
7259         if (ioc_status == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
7260                 if (page_type == MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE ||
7261                     page_type == MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER ||
7262                     page_type == MPI_CONFIG_EXTPAGETYPE_ENCLOSURE) {
7263                         if ((form >> MPI_SAS_DEVICE_PGAD_FORM_SHIFT) ==
7264                                 MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE)
7265                                 return;
7266                 }
7267                 if (page_type == MPI_CONFIG_PAGETYPE_FC_DEVICE)
7268                         if ((form & MPI_FC_DEVICE_PGAD_FORM_MASK) ==
7269                                 MPI_FC_DEVICE_PGAD_FORM_NEXT_DID)
7270                                 return;
7271         }
7272
7273         snprintf(extend_desc, EVENT_DESCR_STR_SZ,
7274             "type=%02Xh, page=%02Xh, action=%02Xh, form=%08Xh",
7275             page_type, pReq->Header.PageNumber, pReq->Action, form);
7276
7277         switch (ioc_status) {
7278
7279         case MPI_IOCSTATUS_CONFIG_INVALID_ACTION: /* 0x0020 */
7280                 desc = "Config Page Invalid Action";
7281                 break;
7282
7283         case MPI_IOCSTATUS_CONFIG_INVALID_TYPE:   /* 0x0021 */
7284                 desc = "Config Page Invalid Type";
7285                 break;
7286
7287         case MPI_IOCSTATUS_CONFIG_INVALID_PAGE:   /* 0x0022 */
7288                 desc = "Config Page Invalid Page";
7289                 break;
7290
7291         case MPI_IOCSTATUS_CONFIG_INVALID_DATA:   /* 0x0023 */
7292                 desc = "Config Page Invalid Data";
7293                 break;
7294
7295         case MPI_IOCSTATUS_CONFIG_NO_DEFAULTS:    /* 0x0024 */
7296                 desc = "Config Page No Defaults";
7297                 break;
7298
7299         case MPI_IOCSTATUS_CONFIG_CANT_COMMIT:    /* 0x0025 */
7300                 desc = "Config Page Can't Commit";
7301                 break;
7302         }
7303
7304         if (!desc)
7305                 return;
7306
7307         dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s: %s\n",
7308             ioc->name, ioc_status, desc, extend_desc));
7309 }
7310
7311 /**
7312  *      mpt_iocstatus_info - IOCSTATUS information returned from IOC.
7313  *      @ioc: Pointer to MPT_ADAPTER structure
7314  *      @ioc_status: U32 IOCStatus word from IOC
7315  *      @mf: Pointer to MPT request frame
7316  *
7317  *      Refer to lsi/mpi.h.
7318  **/
7319 static void
7320 mpt_iocstatus_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf)
7321 {
7322         u32 status = ioc_status & MPI_IOCSTATUS_MASK;
7323         char *desc = NULL;
7324
7325         switch (status) {
7326
7327 /****************************************************************************/
7328 /*  Common IOCStatus values for all replies                                 */
7329 /****************************************************************************/
7330
7331         case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */
7332                 desc = "Invalid Function";
7333                 break;
7334
7335         case MPI_IOCSTATUS_BUSY: /* 0x0002 */
7336                 desc = "Busy";
7337                 break;
7338
7339         case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
7340                 desc = "Invalid SGL";
7341                 break;
7342
7343         case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
7344                 desc = "Internal Error";
7345                 break;
7346
7347         case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
7348                 desc = "Reserved";
7349                 break;
7350
7351         case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
7352                 desc = "Insufficient Resources";
7353                 break;
7354
7355         case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
7356                 desc = "Invalid Field";
7357                 break;
7358
7359         case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
7360                 desc = "Invalid State";
7361                 break;
7362
7363 /****************************************************************************/
7364 /*  Config IOCStatus values                                                 */
7365 /****************************************************************************/
7366
7367         case MPI_IOCSTATUS_CONFIG_INVALID_ACTION: /* 0x0020 */
7368         case MPI_IOCSTATUS_CONFIG_INVALID_TYPE:   /* 0x0021 */
7369         case MPI_IOCSTATUS_CONFIG_INVALID_PAGE:   /* 0x0022 */
7370         case MPI_IOCSTATUS_CONFIG_INVALID_DATA:   /* 0x0023 */
7371         case MPI_IOCSTATUS_CONFIG_NO_DEFAULTS:    /* 0x0024 */
7372         case MPI_IOCSTATUS_CONFIG_CANT_COMMIT:    /* 0x0025 */
7373                 mpt_iocstatus_info_config(ioc, status, mf);
7374                 break;
7375
7376 /****************************************************************************/
7377 /*  SCSIIO Reply (SPI, FCP, SAS) initiator values                           */
7378 /*                                                                          */
7379 /*  Look at mptscsih_iocstatus_info_scsiio in mptscsih.c */
7380 /*                                                                          */
7381 /****************************************************************************/
7382
7383         case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
7384         case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
7385         case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */
7386         case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */
7387         case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
7388         case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
7389         case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
7390         case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
7391         case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
7392         case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
7393         case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */
7394         case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
7395         case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
7396                 break;
7397
7398 /****************************************************************************/
7399 /*  SCSI Target values                                                      */
7400 /****************************************************************************/
7401
7402         case MPI_IOCSTATUS_TARGET_PRIORITY_IO: /* 0x0060 */
7403                 desc = "Target: Priority IO";
7404                 break;
7405
7406         case MPI_IOCSTATUS_TARGET_INVALID_PORT: /* 0x0061 */
7407                 desc = "Target: Invalid Port";
7408                 break;
7409
7410         case MPI_IOCSTATUS_TARGET_INVALID_IO_INDEX: /* 0x0062 */
7411                 desc = "Target Invalid IO Index:";
7412                 break;
7413
7414         case MPI_IOCSTATUS_TARGET_ABORTED: /* 0x0063 */
7415                 desc = "Target: Aborted";
7416                 break;
7417
7418         case MPI_IOCSTATUS_TARGET_NO_CONN_RETRYABLE: /* 0x0064 */
7419                 desc = "Target: No Conn Retryable";
7420                 break;
7421
7422         case MPI_IOCSTATUS_TARGET_NO_CONNECTION: /* 0x0065 */
7423                 desc = "Target: No Connection";
7424                 break;
7425
7426         case MPI_IOCSTATUS_TARGET_XFER_COUNT_MISMATCH: /* 0x006A */
7427                 desc = "Target: Transfer Count Mismatch";
7428                 break;
7429
7430         case MPI_IOCSTATUS_TARGET_STS_DATA_NOT_SENT: /* 0x006B */
7431                 desc = "Target: STS Data not Sent";
7432                 break;
7433
7434         case MPI_IOCSTATUS_TARGET_DATA_OFFSET_ERROR: /* 0x006D */
7435                 desc = "Target: Data Offset Error";
7436                 break;
7437
7438         case MPI_IOCSTATUS_TARGET_TOO_MUCH_WRITE_DATA: /* 0x006E */
7439                 desc = "Target: Too Much Write Data";
7440                 break;
7441
7442         case MPI_IOCSTATUS_TARGET_IU_TOO_SHORT: /* 0x006F */
7443                 desc = "Target: IU Too Short";
7444                 break;
7445
7446         case MPI_IOCSTATUS_TARGET_ACK_NAK_TIMEOUT: /* 0x0070 */
7447                 desc = "Target: ACK NAK Timeout";
7448                 break;
7449
7450         case MPI_IOCSTATUS_TARGET_NAK_RECEIVED: /* 0x0071 */
7451                 desc = "Target: Nak Received";
7452                 break;
7453
7454 /****************************************************************************/
7455 /*  Fibre Channel Direct Access values                                      */
7456 /****************************************************************************/
7457
7458         case MPI_IOCSTATUS_FC_ABORTED: /* 0x0066 */
7459                 desc = "FC: Aborted";
7460                 break;
7461
7462         case MPI_IOCSTATUS_FC_RX_ID_INVALID: /* 0x0067 */
7463                 desc = "FC: RX ID Invalid";
7464                 break;
7465
7466         case MPI_IOCSTATUS_FC_DID_INVALID: /* 0x0068 */
7467                 desc = "FC: DID Invalid";
7468                 break;
7469
7470         case MPI_IOCSTATUS_FC_NODE_LOGGED_OUT: /* 0x0069 */
7471                 desc = "FC: Node Logged Out";
7472                 break;
7473
7474         case MPI_IOCSTATUS_FC_EXCHANGE_CANCELED: /* 0x006C */
7475                 desc = "FC: Exchange Canceled";
7476                 break;
7477
7478 /****************************************************************************/
7479 /*  LAN values                                                              */
7480 /****************************************************************************/
7481
7482         case MPI_IOCSTATUS_LAN_DEVICE_NOT_FOUND: /* 0x0080 */
7483                 desc = "LAN: Device not Found";
7484                 break;
7485
7486         case MPI_IOCSTATUS_LAN_DEVICE_FAILURE: /* 0x0081 */
7487                 desc = "LAN: Device Failure";
7488                 break;
7489
7490         case MPI_IOCSTATUS_LAN_TRANSMIT_ERROR: /* 0x0082 */
7491                 desc = "LAN: Transmit Error";
7492                 break;
7493
7494         case MPI_IOCSTATUS_LAN_TRANSMIT_ABORTED: /* 0x0083 */
7495                 desc = "LAN: Transmit Aborted";
7496                 break;
7497
7498         case MPI_IOCSTATUS_LAN_RECEIVE_ERROR: /* 0x0084 */
7499                 desc = "LAN: Receive Error";
7500                 break;
7501
7502         case MPI_IOCSTATUS_LAN_RECEIVE_ABORTED: /* 0x0085 */
7503                 desc = "LAN: Receive Aborted";
7504                 break;
7505
7506         case MPI_IOCSTATUS_LAN_PARTIAL_PACKET: /* 0x0086 */
7507                 desc = "LAN: Partial Packet";
7508                 break;
7509
7510         case MPI_IOCSTATUS_LAN_CANCELED: /* 0x0087 */
7511                 desc = "LAN: Canceled";
7512                 break;
7513
7514 /****************************************************************************/
7515 /*  Serial Attached SCSI values                                             */
7516 /****************************************************************************/
7517
7518         case MPI_IOCSTATUS_SAS_SMP_REQUEST_FAILED: /* 0x0090 */
7519                 desc = "SAS: SMP Request Failed";
7520                 break;
7521
7522         case MPI_IOCSTATUS_SAS_SMP_DATA_OVERRUN: /* 0x0090 */
7523                 desc = "SAS: SMP Data Overrun";
7524                 break;
7525
7526         default:
7527                 desc = "Others";
7528                 break;
7529         }
7530
7531         if (!desc)
7532                 return;
7533
7534         dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s\n",
7535             ioc->name, status, desc));
7536 }
7537
7538 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7539 EXPORT_SYMBOL(mpt_attach);
7540 EXPORT_SYMBOL(mpt_detach);
7541 #ifdef CONFIG_PM
7542 EXPORT_SYMBOL(mpt_resume);
7543 EXPORT_SYMBOL(mpt_suspend);
7544 #endif
7545 EXPORT_SYMBOL(ioc_list);
7546 EXPORT_SYMBOL(mpt_register);
7547 EXPORT_SYMBOL(mpt_deregister);
7548 EXPORT_SYMBOL(mpt_event_register);
7549 EXPORT_SYMBOL(mpt_event_deregister);
7550 EXPORT_SYMBOL(mpt_reset_register);
7551 EXPORT_SYMBOL(mpt_reset_deregister);
7552 EXPORT_SYMBOL(mpt_device_driver_register);
7553 EXPORT_SYMBOL(mpt_device_driver_deregister);
7554 EXPORT_SYMBOL(mpt_get_msg_frame);
7555 EXPORT_SYMBOL(mpt_put_msg_frame);
7556 EXPORT_SYMBOL(mpt_put_msg_frame_hi_pri);
7557 EXPORT_SYMBOL(mpt_free_msg_frame);
7558 EXPORT_SYMBOL(mpt_add_sge);
7559 EXPORT_SYMBOL(mpt_send_handshake_request);
7560 EXPORT_SYMBOL(mpt_verify_adapter);
7561 EXPORT_SYMBOL(mpt_GetIocState);
7562 EXPORT_SYMBOL(mpt_print_ioc_summary);
7563 EXPORT_SYMBOL(mpt_HardResetHandler);
7564 EXPORT_SYMBOL(mpt_config);
7565 EXPORT_SYMBOL(mpt_findImVolumes);
7566 EXPORT_SYMBOL(mpt_alloc_fw_memory);
7567 EXPORT_SYMBOL(mpt_free_fw_memory);
7568 EXPORT_SYMBOL(mptbase_sas_persist_operation);
7569 EXPORT_SYMBOL(mpt_raid_phys_disk_pg0);
7570
7571 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7572 /**
7573  *      fusion_init - Fusion MPT base driver initialization routine.
7574  *
7575  *      Returns 0 for success, non-zero for failure.
7576  */
7577 static int __init
7578 fusion_init(void)
7579 {
7580         u8 cb_idx;
7581
7582         show_mptmod_ver(my_NAME, my_VERSION);
7583         printk(KERN_INFO COPYRIGHT "\n");
7584
7585         for (cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
7586                 MptCallbacks[cb_idx] = NULL;
7587                 MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
7588                 MptEvHandlers[cb_idx] = NULL;
7589                 MptResetHandlers[cb_idx] = NULL;
7590         }
7591
7592         /*  Register ourselves (mptbase) in order to facilitate
7593          *  EventNotification handling.
7594          */
7595         mpt_base_index = mpt_register(mpt_base_reply, MPTBASE_DRIVER);
7596
7597         /* Register for hard reset handling callbacks.
7598          */
7599         mpt_reset_register(mpt_base_index, mpt_ioc_reset);
7600
7601 #ifdef CONFIG_PROC_FS
7602         (void) procmpt_create();
7603 #endif
7604         return 0;
7605 }
7606
7607 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7608 /**
7609  *      fusion_exit - Perform driver unload cleanup.
7610  *
7611  *      This routine frees all resources associated with each MPT adapter
7612  *      and removes all %MPT_PROCFS_MPTBASEDIR entries.
7613  */
7614 static void __exit
7615 fusion_exit(void)
7616 {
7617
7618         mpt_reset_deregister(mpt_base_index);
7619
7620 #ifdef CONFIG_PROC_FS
7621         procmpt_destroy();
7622 #endif
7623 }
7624
7625 module_init(fusion_init);
7626 module_exit(fusion_exit);