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 Logic PCI chip/adapter(s)
   6  *      running LSI Logic Fusion MPT (Message Passing Technology) firmware.
   7  *
   8  *  Copyright (c) 1999-2007 LSI Logic 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;
  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 #ifdef MFCNT
  91 static int mfcounter = 0;
  92 #define PRINT_MF_COUNT 20000
  93 #endif
  94
  95 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  96 /*
  97  *  Public data...
  98  */
  99 int mpt_lan_index = -1;
 100 int mpt_stm_index = -1;
 101
 102 struct proc_dir_entry *mpt_proc_root_dir;
 103
 104 #define WHOINIT_UNKNOWN         0xAA
 105
 106 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 107 /*
 108  *  Private data...
 109  */
 110                                         /* Adapter link list */
 111 LIST_HEAD(ioc_list);
 112                                         /* Callback lookup table */
 113 static MPT_CALLBACK              MptCallbacks[MPT_MAX_PROTOCOL_DRIVERS];
 114                                         /* Protocol driver class lookup table */
 115 static int                       MptDriverClass[MPT_MAX_PROTOCOL_DRIVERS];
 116                                         /* Event handler lookup table */
 117 static MPT_EVHANDLER             MptEvHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 118                                         /* Reset handler lookup table */
 119 static MPT_RESETHANDLER          MptResetHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 120 static struct mpt_pci_driver    *MptDeviceDriverHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 121
 122 static int      mpt_base_index = -1;
 123 static int      last_drv_idx = -1;
 124
 125 static DECLARE_WAIT_QUEUE_HEAD(mpt_waitq);
 126
 127 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 128 /*
 129  *  Forward protos...
 130  */
 131 static irqreturn_t mpt_interrupt(int irq, void *bus_id);
 132 static int      mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
 133 static int      mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes,
 134                         u32 *req, int replyBytes, u16 *u16reply, int maxwait,
 135                         int sleepFlag);
 136 static int      mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag);
 137 static void     mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev);
 138 static void     mpt_adapter_disable(MPT_ADAPTER *ioc);
 139 static void     mpt_adapter_dispose(MPT_ADAPTER *ioc);
 140
 141 static void     MptDisplayIocCapabilities(MPT_ADAPTER *ioc);
 142 static int      MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag);
 143 static int      GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason);
 144 static int      GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
 145 static int      SendIocInit(MPT_ADAPTER *ioc, int sleepFlag);
 146 static int      SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
 147 static int      mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag);
 148 static int      mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag);
 149 static int      mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
 150 static int      KickStart(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
 151 static int      SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag);
 152 static int      PrimeIocFifos(MPT_ADAPTER *ioc);
 153 static int      WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
 154 static int      WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
 155 static int      WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
 156 static int      GetLanConfigPages(MPT_ADAPTER *ioc);
 157 static int      GetIoUnitPage2(MPT_ADAPTER *ioc);
 158 int             mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
 159 static int      mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum);
 160 static int      mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum);
 161 static void     mpt_read_ioc_pg_1(MPT_ADAPTER *ioc);
 162 static void     mpt_read_ioc_pg_4(MPT_ADAPTER *ioc);
 163 static void     mpt_timer_expired(unsigned long data);
 164 static void     mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc);
 165 static int      SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch);
 166 static int      SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp);
 167 static int      mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag);
 168 static int      mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init);
 169
 170 #ifdef CONFIG_PROC_FS
 171 static int      procmpt_summary_read(char *buf, char **start, off_t offset,
 172                                 int request, int *eof, void *data);
 173 static int      procmpt_version_read(char *buf, char **start, off_t offset,
 174                                 int request, int *eof, void *data);
 175 static int      procmpt_iocinfo_read(char *buf, char **start, off_t offset,
 176                                 int request, int *eof, void *data);
 177 #endif
 178 static void     mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc);
 179
 180 //int           mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
 181 static int      ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *evReply, int *evHandlers);
 182 #ifdef MPT_DEBUG_REPLY
 183 static void     mpt_iocstatus_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf);
 184 #endif
 185 static void     mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info);
 186 static void     mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info);
 187 static void     mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info);
 188 static int      mpt_read_ioc_pg_3(MPT_ADAPTER *ioc);
 189 static void     mpt_inactive_raid_list_free(MPT_ADAPTER *ioc);
 190
 191 /* module entry point */
 192 static int  __init    fusion_init  (void);
 193 static void __exit    fusion_exit  (void);
 194
 195 #define CHIPREG_READ32(addr)            readl_relaxed(addr)
 196 #define CHIPREG_READ32_dmasync(addr)    readl(addr)
 197 #define CHIPREG_WRITE32(addr,val)       writel(val, addr)
 198 #define CHIPREG_PIO_WRITE32(addr,val)   outl(val, (unsigned long)addr)
 199 #define CHIPREG_PIO_READ32(addr)        inl((unsigned long)addr)
 200
 201 static void
 202 pci_disable_io_access(struct pci_dev *pdev)
 203 {
 204         u16 command_reg;
 205
 206         pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
 207         command_reg &= ~1;
 208         pci_write_config_word(pdev, PCI_COMMAND, command_reg);
 209 }
 210
 211 static void
 212 pci_enable_io_access(struct pci_dev *pdev)
 213 {
 214         u16 command_reg;
 215
 216         pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
 217         command_reg |= 1;
 218         pci_write_config_word(pdev, PCI_COMMAND, command_reg);
 219 }
 220
 221 /*
 222  *  Process turbo (context) reply...
 223  */
 224 static void
 225 mpt_turbo_reply(MPT_ADAPTER *ioc, u32 pa)
 226 {
 227         MPT_FRAME_HDR *mf = NULL;
 228         MPT_FRAME_HDR *mr = NULL;
 229         int req_idx = 0;
 230         int cb_idx;
 231
 232         dmfprintk((MYIOC_s_INFO_FMT "Got TURBO reply req_idx=%08x\n",
 233                                 ioc->name, pa));
 234
 235         switch (pa >> MPI_CONTEXT_REPLY_TYPE_SHIFT) {
 236         case MPI_CONTEXT_REPLY_TYPE_SCSI_INIT:
 237                 req_idx = pa & 0x0000FFFF;
 238                 cb_idx = (pa & 0x00FF0000) >> 16;
 239                 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
 240                 break;
 241         case MPI_CONTEXT_REPLY_TYPE_LAN:
 242                 cb_idx = mpt_lan_index;
 243                 /*
 244                  *  Blind set of mf to NULL here was fatal
 245                  *  after lan_reply says "freeme"
 246                  *  Fix sort of combined with an optimization here;
 247                  *  added explicit check for case where lan_reply
 248                  *  was just returning 1 and doing nothing else.
 249                  *  For this case skip the callback, but set up
 250                  *  proper mf value first here:-)
 251                  */
 252                 if ((pa & 0x58000000) == 0x58000000) {
 253                         req_idx = pa & 0x0000FFFF;
 254                         mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
 255                         mpt_free_msg_frame(ioc, mf);
 256                         mb();
 257                         return;
 258                         break;
 259                 }
 260                 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
 261                 break;
 262         case MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET:
 263                 cb_idx = mpt_stm_index;
 264                 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
 265                 break;
 266         default:
 267                 cb_idx = 0;
 268                 BUG();
 269         }
 270
 271         /*  Check for (valid) IO callback!  */
 272         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
 273                         MptCallbacks[cb_idx] == NULL) {
 274                 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
 275                                 __FUNCTION__, ioc->name, cb_idx);
 276                 goto out;
 277         }
 278
 279         if (MptCallbacks[cb_idx](ioc, mf, mr))
 280                 mpt_free_msg_frame(ioc, mf);
 281  out:
 282         mb();
 283 }
 284
 285 static void
 286 mpt_reply(MPT_ADAPTER *ioc, u32 pa)
 287 {
 288         MPT_FRAME_HDR   *mf;
 289         MPT_FRAME_HDR   *mr;
 290         int              req_idx;
 291         int              cb_idx;
 292         int              freeme;
 293
 294         u32 reply_dma_low;
 295         u16 ioc_stat;
 296
 297         /* non-TURBO reply!  Hmmm, something may be up...
 298          *  Newest turbo reply mechanism; get address
 299          *  via left shift 1 (get rid of MPI_ADDRESS_REPLY_A_BIT)!
 300          */
 301
 302         /* Map DMA address of reply header to cpu address.
 303          * pa is 32 bits - but the dma address may be 32 or 64 bits
 304          * get offset based only only the low addresses
 305          */
 306
 307         reply_dma_low = (pa <<= 1);
 308         mr = (MPT_FRAME_HDR *)((u8 *)ioc->reply_frames +
 309                          (reply_dma_low - ioc->reply_frames_low_dma));
 310
 311         req_idx = le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx);
 312         cb_idx = mr->u.frame.hwhdr.msgctxu.fld.cb_idx;
 313         mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
 314
 315         dmfprintk((MYIOC_s_INFO_FMT "Got non-TURBO reply=%p req_idx=%x cb_idx=%x Function=%x\n",
 316                         ioc->name, mr, req_idx, cb_idx, mr->u.hdr.Function));
 317         DBG_DUMP_REPLY_FRAME(mr)
 318
 319          /*  Check/log IOC log info
 320          */
 321         ioc_stat = le16_to_cpu(mr->u.reply.IOCStatus);
 322         if (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) {
 323                 u32      log_info = le32_to_cpu(mr->u.reply.IOCLogInfo);
 324                 if (ioc->bus_type == FC)
 325                         mpt_fc_log_info(ioc, log_info);
 326                 else if (ioc->bus_type == SPI)
 327                         mpt_spi_log_info(ioc, log_info);
 328                 else if (ioc->bus_type == SAS)
 329                         mpt_sas_log_info(ioc, log_info);
 330         }
 331
 332 #ifdef MPT_DEBUG_REPLY
 333         if (ioc_stat & MPI_IOCSTATUS_MASK)
 334                 mpt_iocstatus_info(ioc, (u32)ioc_stat, mf);
 335 #endif
 336
 337         /*  Check for (valid) IO callback!  */
 338         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
 339                         MptCallbacks[cb_idx] == NULL) {
 340                 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
 341                                 __FUNCTION__, ioc->name, cb_idx);
 342                 freeme = 0;
 343                 goto out;
 344         }
 345
 346         freeme = MptCallbacks[cb_idx](ioc, mf, mr);
 347
 348  out:
 349         /*  Flush (non-TURBO) reply with a WRITE!  */
 350         CHIPREG_WRITE32(&ioc->chip->ReplyFifo, pa);
 351
 352         if (freeme)
 353                 mpt_free_msg_frame(ioc, mf);
 354         mb();
 355 }
 356
 357 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 358 /**
 359  *      mpt_interrupt - MPT adapter (IOC) specific interrupt handler.
 360  *      @irq: irq number (not used)
 361  *      @bus_id: bus identifier cookie == pointer to MPT_ADAPTER structure
 362  *
 363  *      This routine is registered via the request_irq() kernel API call,
 364  *      and handles all interrupts generated from a specific MPT adapter
 365  *      (also referred to as a IO Controller or IOC).
 366  *      This routine must clear the interrupt from the adapter and does
 367  *      so by reading the reply FIFO.  Multiple replies may be processed
 368  *      per single call to this routine.
 369  *
 370  *      This routine handles register-level access of the adapter but
 371  *      dispatches (calls) a protocol-specific callback routine to handle
 372  *      the protocol-specific details of the MPT request completion.
 373  */
 374 static irqreturn_t
 375 mpt_interrupt(int irq, void *bus_id)
 376 {
 377         MPT_ADAPTER *ioc = bus_id;
 378         u32 pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
 379
 380         if (pa == 0xFFFFFFFF)
 381                 return IRQ_NONE;
 382
 383         /*
 384          *  Drain the reply FIFO!
 385          */
 386         do {
 387                 if (pa & MPI_ADDRESS_REPLY_A_BIT)
 388                         mpt_reply(ioc, pa);
 389                 else
 390                         mpt_turbo_reply(ioc, pa);
 391                 pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
 392         } while (pa != 0xFFFFFFFF);
 393
 394         return IRQ_HANDLED;
 395 }
 396
 397 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 398 /**
 399  *      mpt_base_reply - MPT base driver's callback routine
 400  *      @ioc: Pointer to MPT_ADAPTER structure
 401  *      @mf: Pointer to original MPT request frame
 402  *      @reply: Pointer to MPT reply frame (NULL if TurboReply)
 403  *
 404  *      MPT base driver's callback routine; all base driver
 405  *      "internal" request/reply processing is routed here.
 406  *      Currently used for EventNotification and EventAck handling.
 407  *
 408  *      Returns 1 indicating original alloc'd request frame ptr
 409  *      should be freed, or 0 if it shouldn't.
 410  */
 411 static int
 412 mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
 413 {
 414         int freereq = 1;
 415         u8 func;
 416
 417         dmfprintk((MYIOC_s_INFO_FMT "mpt_base_reply() called\n", ioc->name));
 418
 419 #if defined(MPT_DEBUG_MSG_FRAME)
 420         if (!(reply->u.hdr.MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)) {
 421                 dmfprintk((KERN_INFO MYNAM ": Original request frame (@%p) header\n", mf));
 422                 DBG_DUMP_REQUEST_FRAME_HDR(mf)
 423         }
 424 #endif
 425
 426         func = reply->u.hdr.Function;
 427         dmfprintk((MYIOC_s_INFO_FMT "mpt_base_reply, Function=%02Xh\n",
 428                         ioc->name, func));
 429
 430         if (func == MPI_FUNCTION_EVENT_NOTIFICATION) {
 431                 EventNotificationReply_t *pEvReply = (EventNotificationReply_t *) reply;
 432                 int evHandlers = 0;
 433                 int results;
 434
 435                 results = ProcessEventNotification(ioc, pEvReply, &evHandlers);
 436                 if (results != evHandlers) {
 437                         /* CHECKME! Any special handling needed here? */
 438                         devtverboseprintk((MYIOC_s_WARN_FMT "Called %d event handlers, sum results = %d\n",
 439                                         ioc->name, evHandlers, results));
 440                 }
 441
 442                 /*
 443                  *      Hmmm...  It seems that EventNotificationReply is an exception
 444                  *      to the rule of one reply per request.
 445                  */
 446                 if (pEvReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) {
 447                         freereq = 0;
 448                 } else {
 449                         devtverboseprintk((MYIOC_s_WARN_FMT "EVENT_NOTIFICATION reply %p returns Request frame\n",
 450                                 ioc->name, pEvReply));
 451                 }
 452
 453 #ifdef CONFIG_PROC_FS
 454 //              LogEvent(ioc, pEvReply);
 455 #endif
 456
 457         } else if (func == MPI_FUNCTION_EVENT_ACK) {
 458                 dprintk((MYIOC_s_INFO_FMT "mpt_base_reply, EventAck reply received\n",
 459                                 ioc->name));
 460         } else if (func == MPI_FUNCTION_CONFIG) {
 461                 CONFIGPARMS *pCfg;
 462                 unsigned long flags;
 463
 464                 dcprintk((MYIOC_s_INFO_FMT "config_complete (mf=%p,mr=%p)\n",
 465                                 ioc->name, mf, reply));
 466
 467                 pCfg = * ((CONFIGPARMS **)((u8 *) mf + ioc->req_sz - sizeof(void *)));
 468
 469                 if (pCfg) {
 470                         /* disable timer and remove from linked list */
 471                         del_timer(&pCfg->timer);
 472
 473                         spin_lock_irqsave(&ioc->FreeQlock, flags);
 474                         list_del(&pCfg->linkage);
 475                         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
 476
 477                         /*
 478                          *      If IOC Status is SUCCESS, save the header
 479                          *      and set the status code to GOOD.
 480                          */
 481                         pCfg->status = MPT_CONFIG_ERROR;
 482                         if (reply) {
 483                                 ConfigReply_t   *pReply = (ConfigReply_t *)reply;
 484                                 u16              status;
 485
 486                                 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
 487                                 dcprintk((KERN_NOTICE "  IOCStatus=%04xh, IOCLogInfo=%08xh\n",
 488                                      status, le32_to_cpu(pReply->IOCLogInfo)));
 489
 490                                 pCfg->status = status;
 491                                 if (status == MPI_IOCSTATUS_SUCCESS) {
 492                                         if ((pReply->Header.PageType &
 493                                             MPI_CONFIG_PAGETYPE_MASK) ==
 494                                             MPI_CONFIG_PAGETYPE_EXTENDED) {
 495                                                 pCfg->cfghdr.ehdr->ExtPageLength =
 496                                                     le16_to_cpu(pReply->ExtPageLength);
 497                                                 pCfg->cfghdr.ehdr->ExtPageType =
 498                                                     pReply->ExtPageType;
 499                                         }
 500                                         pCfg->cfghdr.hdr->PageVersion = pReply->Header.PageVersion;
 501
 502                                         /* If this is a regular header, save PageLength. */
 503                                         /* LMP Do this better so not using a reserved field! */
 504                                         pCfg->cfghdr.hdr->PageLength = pReply->Header.PageLength;
 505                                         pCfg->cfghdr.hdr->PageNumber = pReply->Header.PageNumber;
 506                                         pCfg->cfghdr.hdr->PageType = pReply->Header.PageType;
 507                                 }
 508                         }
 509
 510                         /*
 511                          *      Wake up the original calling thread
 512                          */
 513                         pCfg->wait_done = 1;
 514                         wake_up(&mpt_waitq);
 515                 }
 516         } else if (func == MPI_FUNCTION_SAS_IO_UNIT_CONTROL) {
 517                 /* we should be always getting a reply frame */
 518                 memcpy(ioc->persist_reply_frame, reply,
 519                     min(MPT_DEFAULT_FRAME_SIZE,
 520                     4*reply->u.reply.MsgLength));
 521                 del_timer(&ioc->persist_timer);
 522                 ioc->persist_wait_done = 1;
 523                 wake_up(&mpt_waitq);
 524         } else {
 525                 printk(MYIOC_s_ERR_FMT "Unexpected msg function (=%02Xh) reply received!\n",
 526                                 ioc->name, func);
 527         }
 528
 529         /*
 530          *      Conditionally tell caller to free the original
 531          *      EventNotification/EventAck/unexpected request frame!
 532          */
 533         return freereq;
 534 }
 535
 536 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 537 /**
 538  *      mpt_register - Register protocol-specific main callback handler.
 539  *      @cbfunc: callback function pointer
 540  *      @dclass: Protocol driver's class (%MPT_DRIVER_CLASS enum value)
 541  *
 542  *      This routine is called by a protocol-specific driver (SCSI host,
 543  *      LAN, SCSI target) to register its reply callback routine.  Each
 544  *      protocol-specific driver must do this before it will be able to
 545  *      use any IOC resources, such as obtaining request frames.
 546  *
 547  *      NOTES: The SCSI protocol driver currently calls this routine thrice
 548  *      in order to register separate callbacks; one for "normal" SCSI IO;
 549  *      one for MptScsiTaskMgmt requests; one for Scan/DV requests.
 550  *
 551  *      Returns a positive integer valued "handle" in the
 552  *      range (and S.O.D. order) {N,...,7,6,5,...,1} if successful.
 553  *      Any non-positive return value (including zero!) should be considered
 554  *      an error by the caller.
 555  */
 556 int
 557 mpt_register(MPT_CALLBACK cbfunc, MPT_DRIVER_CLASS dclass)
 558 {
 559         int i;
 560
 561         last_drv_idx = -1;
 562
 563         /*
 564          *  Search for empty callback slot in this order: {N,...,7,6,5,...,1}
 565          *  (slot/handle 0 is reserved!)
 566          */
 567         for (i = MPT_MAX_PROTOCOL_DRIVERS-1; i; i--) {
 568                 if (MptCallbacks[i] == NULL) {
 569                         MptCallbacks[i] = cbfunc;
 570                         MptDriverClass[i] = dclass;
 571                         MptEvHandlers[i] = NULL;
 572                         last_drv_idx = i;
 573                         break;
 574                 }
 575         }
 576
 577         return last_drv_idx;
 578 }
 579
 580 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 581 /**
 582  *      mpt_deregister - Deregister a protocol drivers resources.
 583  *      @cb_idx: previously registered callback handle
 584  *
 585  *      Each protocol-specific driver should call this routine when its
 586  *      module is unloaded.
 587  */
 588 void
 589 mpt_deregister(int cb_idx)
 590 {
 591         if ((cb_idx >= 0) && (cb_idx < MPT_MAX_PROTOCOL_DRIVERS)) {
 592                 MptCallbacks[cb_idx] = NULL;
 593                 MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
 594                 MptEvHandlers[cb_idx] = NULL;
 595
 596                 last_drv_idx++;
 597         }
 598 }
 599
 600 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 601 /**
 602  *      mpt_event_register - Register protocol-specific event callback
 603  *      handler.
 604  *      @cb_idx: previously registered (via mpt_register) callback handle
 605  *      @ev_cbfunc: callback function
 606  *
 607  *      This routine can be called by one or more protocol-specific drivers
 608  *      if/when they choose to be notified of MPT events.
 609  *
 610  *      Returns 0 for success.
 611  */
 612 int
 613 mpt_event_register(int cb_idx, MPT_EVHANDLER ev_cbfunc)
 614 {
 615         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 616                 return -1;
 617
 618         MptEvHandlers[cb_idx] = ev_cbfunc;
 619         return 0;
 620 }
 621
 622 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 623 /**
 624  *      mpt_event_deregister - Deregister protocol-specific event callback
 625  *      handler.
 626  *      @cb_idx: previously registered callback handle
 627  *
 628  *      Each protocol-specific driver should call this routine
 629  *      when it does not (or can no longer) handle events,
 630  *      or when its module is unloaded.
 631  */
 632 void
 633 mpt_event_deregister(int cb_idx)
 634 {
 635         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 636                 return;
 637
 638         MptEvHandlers[cb_idx] = NULL;
 639 }
 640
 641 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 642 /**
 643  *      mpt_reset_register - Register protocol-specific IOC reset handler.
 644  *      @cb_idx: previously registered (via mpt_register) callback handle
 645  *      @reset_func: reset function
 646  *
 647  *      This routine can be called by one or more protocol-specific drivers
 648  *      if/when they choose to be notified of IOC resets.
 649  *
 650  *      Returns 0 for success.
 651  */
 652 int
 653 mpt_reset_register(int cb_idx, MPT_RESETHANDLER reset_func)
 654 {
 655         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 656                 return -1;
 657
 658         MptResetHandlers[cb_idx] = reset_func;
 659         return 0;
 660 }
 661
 662 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 663 /**
 664  *      mpt_reset_deregister - Deregister protocol-specific IOC reset handler.
 665  *      @cb_idx: previously registered callback handle
 666  *
 667  *      Each protocol-specific driver should call this routine
 668  *      when it does not (or can no longer) handle IOC reset handling,
 669  *      or when its module is unloaded.
 670  */
 671 void
 672 mpt_reset_deregister(int cb_idx)
 673 {
 674         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 675                 return;
 676
 677         MptResetHandlers[cb_idx] = NULL;
 678 }
 679
 680 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 681 /**
 682  *      mpt_device_driver_register - Register device driver hooks
 683  *      @dd_cbfunc: driver callbacks struct
 684  *      @cb_idx: MPT protocol driver index
 685  */
 686 int
 687 mpt_device_driver_register(struct mpt_pci_driver * dd_cbfunc, int cb_idx)
 688 {
 689         MPT_ADAPTER     *ioc;
 690         const struct pci_device_id *id;
 691
 692         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 693                 return -EINVAL;
 694
 695         MptDeviceDriverHandlers[cb_idx] = dd_cbfunc;
 696
 697         /* call per pci device probe entry point */
 698         list_for_each_entry(ioc, &ioc_list, list) {
 699                 id = ioc->pcidev->driver ?
 700                     ioc->pcidev->driver->id_table : NULL;
 701                 if (dd_cbfunc->probe)
 702                         dd_cbfunc->probe(ioc->pcidev, id);
 703          }
 704
 705         return 0;
 706 }
 707
 708 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 709 /**
 710  *      mpt_device_driver_deregister - DeRegister device driver hooks
 711  *      @cb_idx: MPT protocol driver index
 712  */
 713 void
 714 mpt_device_driver_deregister(int cb_idx)
 715 {
 716         struct mpt_pci_driver *dd_cbfunc;
 717         MPT_ADAPTER     *ioc;
 718
 719         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
 720                 return;
 721
 722         dd_cbfunc = MptDeviceDriverHandlers[cb_idx];
 723
 724         list_for_each_entry(ioc, &ioc_list, list) {
 725                 if (dd_cbfunc->remove)
 726                         dd_cbfunc->remove(ioc->pcidev);
 727         }
 728
 729         MptDeviceDriverHandlers[cb_idx] = NULL;
 730 }
 731
 732
 733 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 734 /**
 735  *      mpt_get_msg_frame - Obtain a MPT request frame from the pool (of 1024)
 736  *      allocated per MPT adapter.
 737  *      @handle: Handle of registered MPT protocol driver
 738  *      @ioc: Pointer to MPT adapter structure
 739  *
 740  *      Returns pointer to a MPT request frame or %NULL if none are available
 741  *      or IOC is not active.
 742  */
 743 MPT_FRAME_HDR*
 744 mpt_get_msg_frame(int handle, MPT_ADAPTER *ioc)
 745 {
 746         MPT_FRAME_HDR *mf;
 747         unsigned long flags;
 748         u16      req_idx;       /* Request index */
 749
 750         /* validate handle and ioc identifier */
 751
 752 #ifdef MFCNT
 753         if (!ioc->active)
 754                 printk(KERN_WARNING "IOC Not Active! mpt_get_msg_frame returning NULL!\n");
 755 #endif
 756
 757         /* If interrupts are not attached, do not return a request frame */
 758         if (!ioc->active)
 759                 return NULL;
 760
 761         spin_lock_irqsave(&ioc->FreeQlock, flags);
 762         if (!list_empty(&ioc->FreeQ)) {
 763                 int req_offset;
 764
 765                 mf = list_entry(ioc->FreeQ.next, MPT_FRAME_HDR,
 766                                 u.frame.linkage.list);
 767                 list_del(&mf->u.frame.linkage.list);
 768                 mf->u.frame.linkage.arg1 = 0;
 769                 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle;  /* byte */
 770                 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
 771                                                                 /* u16! */
 772                 req_idx = req_offset / ioc->req_sz;
 773                 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
 774                 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
 775                 ioc->RequestNB[req_idx] = ioc->NB_for_64_byte_frame; /* Default, will be changed if necessary in SG generation */
 776 #ifdef MFCNT
 777                 ioc->mfcnt++;
 778 #endif
 779         }
 780         else
 781                 mf = NULL;
 782         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
 783
 784 #ifdef MFCNT
 785         if (mf == NULL)
 786                 printk(KERN_WARNING "IOC Active. No free Msg Frames! Count 0x%x Max 0x%x\n", ioc->mfcnt, ioc->req_depth);
 787         mfcounter++;
 788         if (mfcounter == PRINT_MF_COUNT)
 789                 printk(KERN_INFO "MF Count 0x%x Max 0x%x \n", ioc->mfcnt, ioc->req_depth);
 790 #endif
 791
 792         dmfprintk((KERN_INFO MYNAM ": %s: mpt_get_msg_frame(%d,%d), got mf=%p\n",
 793                         ioc->name, handle, ioc->id, mf));
 794         return mf;
 795 }
 796
 797 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 798 /**
 799  *      mpt_put_msg_frame - Send a protocol specific MPT request frame
 800  *      to a IOC.
 801  *      @handle: Handle of registered MPT protocol driver
 802  *      @ioc: Pointer to MPT adapter structure
 803  *      @mf: Pointer to MPT request frame
 804  *
 805  *      This routine posts a MPT request frame to the request post FIFO of a
 806  *      specific MPT adapter.
 807  */
 808 void
 809 mpt_put_msg_frame(int handle, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
 810 {
 811         u32 mf_dma_addr;
 812         int req_offset;
 813         u16      req_idx;       /* Request index */
 814
 815         /* ensure values are reset properly! */
 816         mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle;          /* byte */
 817         req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
 818                                                                 /* u16! */
 819         req_idx = req_offset / ioc->req_sz;
 820         mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
 821         mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
 822
 823 #ifdef MPT_DEBUG_MSG_FRAME
 824         {
 825                 u32     *m = mf->u.frame.hwhdr.__hdr;
 826                 int      ii, n;
 827
 828                 printk(KERN_INFO MYNAM ": %s: About to Put msg frame @ %p:\n" KERN_INFO " ",
 829                                 ioc->name, m);
 830                 n = ioc->req_sz/4 - 1;
 831                 while (m[n] == 0)
 832                         n--;
 833                 for (ii=0; ii<=n; ii++) {
 834                         if (ii && ((ii%8)==0))
 835                                 printk("\n" KERN_INFO " ");
 836                         printk(" %08x", le32_to_cpu(m[ii]));
 837                 }
 838                 printk("\n");
 839         }
 840 #endif
 841
 842         mf_dma_addr = (ioc->req_frames_low_dma + req_offset) | ioc->RequestNB[req_idx];
 843         dsgprintk((MYIOC_s_INFO_FMT "mf_dma_addr=%x req_idx=%d RequestNB=%x\n", ioc->name, mf_dma_addr, req_idx, ioc->RequestNB[req_idx]));
 844         CHIPREG_WRITE32(&ioc->chip->RequestFifo, mf_dma_addr);
 845 }
 846
 847 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 848 /**
 849  *      mpt_free_msg_frame - Place MPT request frame back on FreeQ.
 850  *      @handle: Handle of registered MPT protocol driver
 851  *      @ioc: Pointer to MPT adapter structure
 852  *      @mf: Pointer to MPT request frame
 853  *
 854  *      This routine places a MPT request frame back on the MPT adapter's
 855  *      FreeQ.
 856  */
 857 void
 858 mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
 859 {
 860         unsigned long flags;
 861
 862         /*  Put Request back on FreeQ!  */
 863         spin_lock_irqsave(&ioc->FreeQlock, flags);
 864         mf->u.frame.linkage.arg1 = 0xdeadbeaf; /* signature to know if this mf is freed */
 865         list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
 866 #ifdef MFCNT
 867         ioc->mfcnt--;
 868 #endif
 869         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
 870 }
 871
 872 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 873 /**
 874  *      mpt_add_sge - Place a simple SGE at address pAddr.
 875  *      @pAddr: virtual address for SGE
 876  *      @flagslength: SGE flags and data transfer length
 877  *      @dma_addr: Physical address
 878  *
 879  *      This routine places a MPT request frame back on the MPT adapter's
 880  *      FreeQ.
 881  */
 882 void
 883 mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
 884 {
 885         if (sizeof(dma_addr_t) == sizeof(u64)) {
 886                 SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
 887                 u32 tmp = dma_addr & 0xFFFFFFFF;
 888
 889                 pSge->FlagsLength = cpu_to_le32(flagslength);
 890                 pSge->Address.Low = cpu_to_le32(tmp);
 891                 tmp = (u32) ((u64)dma_addr >> 32);
 892                 pSge->Address.High = cpu_to_le32(tmp);
 893
 894         } else {
 895                 SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
 896                 pSge->FlagsLength = cpu_to_le32(flagslength);
 897                 pSge->Address = cpu_to_le32(dma_addr);
 898         }
 899 }
 900
 901 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 902 /**
 903  *      mpt_send_handshake_request - Send MPT request via doorbell handshake method.
 904  *      @handle: Handle of registered MPT protocol driver
 905  *      @ioc: Pointer to MPT adapter structure
 906  *      @reqBytes: Size of the request in bytes
 907  *      @req: Pointer to MPT request frame
 908  *      @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
 909  *
 910  *      This routine is used exclusively to send MptScsiTaskMgmt
 911  *      requests since they are required to be sent via doorbell handshake.
 912  *
 913  *      NOTE: It is the callers responsibility to byte-swap fields in the
 914  *      request which are greater than 1 byte in size.
 915  *
 916  *      Returns 0 for success, non-zero for failure.
 917  */
 918 int
 919 mpt_send_handshake_request(int handle, MPT_ADAPTER *ioc, int reqBytes, u32 *req, int sleepFlag)
 920 {
 921         int     r = 0;
 922         u8      *req_as_bytes;
 923         int      ii;
 924
 925         /* State is known to be good upon entering
 926          * this function so issue the bus reset
 927          * request.
 928          */
 929
 930         /*
 931          * Emulate what mpt_put_msg_frame() does /wrt to sanity
 932          * setting cb_idx/req_idx.  But ONLY if this request
 933          * is in proper (pre-alloc'd) request buffer range...
 934          */
 935         ii = MFPTR_2_MPT_INDEX(ioc,(MPT_FRAME_HDR*)req);
 936         if (reqBytes >= 12 && ii >= 0 && ii < ioc->req_depth) {
 937                 MPT_FRAME_HDR *mf = (MPT_FRAME_HDR*)req;
 938                 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(ii);
 939                 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle;
 940         }
 941
 942         /* Make sure there are no doorbells */
 943         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
 944
 945         CHIPREG_WRITE32(&ioc->chip->Doorbell,
 946                         ((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
 947                          ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
 948
 949         /* Wait for IOC doorbell int */
 950         if ((ii = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0) {
 951                 return ii;
 952         }
 953
 954         /* Read doorbell and check for active bit */
 955         if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
 956                 return -5;
 957
 958         dhsprintk((KERN_INFO MYNAM ": %s: mpt_send_handshake_request start, WaitCnt=%d\n",
 959                 ioc->name, ii));
 960
 961         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
 962
 963         if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
 964                 return -2;
 965         }
 966
 967         /* Send request via doorbell handshake */
 968         req_as_bytes = (u8 *) req;
 969         for (ii = 0; ii < reqBytes/4; ii++) {
 970                 u32 word;
 971
 972                 word = ((req_as_bytes[(ii*4) + 0] <<  0) |
 973                         (req_as_bytes[(ii*4) + 1] <<  8) |
 974                         (req_as_bytes[(ii*4) + 2] << 16) |
 975                         (req_as_bytes[(ii*4) + 3] << 24));
 976                 CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
 977                 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
 978                         r = -3;
 979                         break;
 980                 }
 981         }
 982
 983         if (r >= 0 && WaitForDoorbellInt(ioc, 10, sleepFlag) >= 0)
 984                 r = 0;
 985         else
 986                 r = -4;
 987
 988         /* Make sure there are no doorbells */
 989         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
 990
 991         return r;
 992 }
 993
 994 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 995 /**
 996  * mpt_host_page_access_control - control the IOC's Host Page Buffer access
 997  * @ioc: Pointer to MPT adapter structure
 998  * @access_control_value: define bits below
 999  * @sleepFlag: Specifies whether the process can sleep
1000  *
1001  * Provides mechanism for the host driver to control the IOC's
1002  * Host Page Buffer access.
1003  *
1004  * Access Control Value - bits[15:12]
1005  * 0h Reserved
1006  * 1h Enable Access { MPI_DB_HPBAC_ENABLE_ACCESS }
1007  * 2h Disable Access { MPI_DB_HPBAC_DISABLE_ACCESS }
1008  * 3h Free Buffer { MPI_DB_HPBAC_FREE_BUFFER }
1009  *
1010  * Returns 0 for success, non-zero for failure.
1011  */
1012
1013 static int
1014 mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag)
1015 {
1016         int      r = 0;
1017
1018         /* return if in use */
1019         if (CHIPREG_READ32(&ioc->chip->Doorbell)
1020             & MPI_DOORBELL_ACTIVE)
1021             return -1;
1022
1023         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1024
1025         CHIPREG_WRITE32(&ioc->chip->Doorbell,
1026                 ((MPI_FUNCTION_HOST_PAGEBUF_ACCESS_CONTROL
1027                  <<MPI_DOORBELL_FUNCTION_SHIFT) |
1028                  (access_control_value<<12)));
1029
1030         /* Wait for IOC to clear Doorbell Status bit */
1031         if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1032                 return -2;
1033         }else
1034                 return 0;
1035 }
1036
1037 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1038 /**
1039  *      mpt_host_page_alloc - allocate system memory for the fw
1040  *      @ioc: Pointer to pointer to IOC adapter
1041  *      @ioc_init: Pointer to ioc init config page
1042  *
1043  *      If we already allocated memory in past, then resend the same pointer.
1044  *      Returns 0 for success, non-zero for failure.
1045  */
1046 static int
1047 mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init)
1048 {
1049         char    *psge;
1050         int     flags_length;
1051         u32     host_page_buffer_sz=0;
1052
1053         if(!ioc->HostPageBuffer) {
1054
1055                 host_page_buffer_sz =
1056                     le32_to_cpu(ioc->facts.HostPageBufferSGE.FlagsLength) & 0xFFFFFF;
1057
1058                 if(!host_page_buffer_sz)
1059                         return 0; /* fw doesn't need any host buffers */
1060
1061                 /* spin till we get enough memory */
1062                 while(host_page_buffer_sz > 0) {
1063
1064                         if((ioc->HostPageBuffer = pci_alloc_consistent(
1065                             ioc->pcidev,
1066                             host_page_buffer_sz,
1067                             &ioc->HostPageBuffer_dma)) != NULL) {
1068
1069                                 dinitprintk((MYIOC_s_INFO_FMT
1070                                     "host_page_buffer @ %p, dma @ %x, sz=%d bytes\n",
1071                                     ioc->name, ioc->HostPageBuffer,
1072                                     (u32)ioc->HostPageBuffer_dma,
1073                                     host_page_buffer_sz));
1074                                 ioc->alloc_total += host_page_buffer_sz;
1075                                 ioc->HostPageBuffer_sz = host_page_buffer_sz;
1076                                 break;
1077                         }
1078
1079                         host_page_buffer_sz -= (4*1024);
1080                 }
1081         }
1082
1083         if(!ioc->HostPageBuffer) {
1084                 printk(MYIOC_s_ERR_FMT
1085                     "Failed to alloc memory for host_page_buffer!\n",
1086                     ioc->name);
1087                 return -999;
1088         }
1089
1090         psge = (char *)&ioc_init->HostPageBufferSGE;
1091         flags_length = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1092             MPI_SGE_FLAGS_SYSTEM_ADDRESS |
1093             MPI_SGE_FLAGS_32_BIT_ADDRESSING |
1094             MPI_SGE_FLAGS_HOST_TO_IOC |
1095             MPI_SGE_FLAGS_END_OF_BUFFER;
1096         if (sizeof(dma_addr_t) == sizeof(u64)) {
1097             flags_length |= MPI_SGE_FLAGS_64_BIT_ADDRESSING;
1098         }
1099         flags_length = flags_length << MPI_SGE_FLAGS_SHIFT;
1100         flags_length |= ioc->HostPageBuffer_sz;
1101         mpt_add_sge(psge, flags_length, ioc->HostPageBuffer_dma);
1102         ioc->facts.HostPageBufferSGE = ioc_init->HostPageBufferSGE;
1103
1104 return 0;
1105 }
1106
1107 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1108 /**
1109  *      mpt_verify_adapter - Given IOC identifier, set pointer to its adapter structure.
1110  *      @iocid: IOC unique identifier (integer)
1111  *      @iocpp: Pointer to pointer to IOC adapter
1112  *
1113  *      Given a unique IOC identifier, set pointer to the associated MPT
1114  *      adapter structure.
1115  *
1116  *      Returns iocid and sets iocpp if iocid is found.
1117  *      Returns -1 if iocid is not found.
1118  */
1119 int
1120 mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp)
1121 {
1122         MPT_ADAPTER *ioc;
1123
1124         list_for_each_entry(ioc,&ioc_list,list) {
1125                 if (ioc->id == iocid) {
1126                         *iocpp =ioc;
1127                         return iocid;
1128                 }
1129         }
1130
1131         *iocpp = NULL;
1132         return -1;
1133 }
1134
1135 /**
1136  *      mpt_get_product_name - returns product string
1137  *      @vendor: pci vendor id
1138  *      @device: pci device id
1139  *      @revision: pci revision id
1140  *      @prod_name: string returned
1141  *
1142  *      Returns product string displayed when driver loads,
1143  *      in /proc/mpt/summary and /sysfs/class/scsi_host/host<X>/version_product
1144  *
1145  **/
1146 static void
1147 mpt_get_product_name(u16 vendor, u16 device, u8 revision, char *prod_name)
1148 {
1149         char *product_str = NULL;
1150
1151         if (vendor == PCI_VENDOR_ID_BROCADE) {
1152                 switch (device)
1153                 {
1154                 case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1155                         switch (revision)
1156                         {
1157                         case 0x00:
1158                                 product_str = "BRE040 A0";
1159                                 break;
1160                         case 0x01:
1161                                 product_str = "BRE040 A1";
1162                                 break;
1163                         default:
1164                                 product_str = "BRE040";
1165                                 break;
1166                         }
1167                         break;
1168                 }
1169                 goto out;
1170         }
1171
1172         switch (device)
1173         {
1174         case MPI_MANUFACTPAGE_DEVICEID_FC909:
1175                 product_str = "LSIFC909 B1";
1176                 break;
1177         case MPI_MANUFACTPAGE_DEVICEID_FC919:
1178                 product_str = "LSIFC919 B0";
1179                 break;
1180         case MPI_MANUFACTPAGE_DEVICEID_FC929:
1181                 product_str = "LSIFC929 B0";
1182                 break;
1183         case MPI_MANUFACTPAGE_DEVICEID_FC919X:
1184                 if (revision < 0x80)
1185                         product_str = "LSIFC919X A0";
1186                 else
1187                         product_str = "LSIFC919XL A1";
1188                 break;
1189         case MPI_MANUFACTPAGE_DEVICEID_FC929X:
1190                 if (revision < 0x80)
1191                         product_str = "LSIFC929X A0";
1192                 else
1193                         product_str = "LSIFC929XL A1";
1194                 break;
1195         case MPI_MANUFACTPAGE_DEVICEID_FC939X:
1196                 product_str = "LSIFC939X A1";
1197                 break;
1198         case MPI_MANUFACTPAGE_DEVICEID_FC949X:
1199                 product_str = "LSIFC949X A1";
1200                 break;
1201         case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1202                 switch (revision)
1203                 {
1204                 case 0x00:
1205                         product_str = "LSIFC949E A0";
1206                         break;
1207                 case 0x01:
1208                         product_str = "LSIFC949E A1";
1209                         break;
1210                 default:
1211                         product_str = "LSIFC949E";
1212                         break;
1213                 }
1214                 break;
1215         case MPI_MANUFACTPAGE_DEVID_53C1030:
1216                 switch (revision)
1217                 {
1218                 case 0x00:
1219                         product_str = "LSI53C1030 A0";
1220                         break;
1221                 case 0x01:
1222                         product_str = "LSI53C1030 B0";
1223                         break;
1224                 case 0x03:
1225                         product_str = "LSI53C1030 B1";
1226                         break;
1227                 case 0x07:
1228                         product_str = "LSI53C1030 B2";
1229                         break;
1230                 case 0x08:
1231                         product_str = "LSI53C1030 C0";
1232                         break;
1233                 case 0x80:
1234                         product_str = "LSI53C1030T A0";
1235                         break;
1236                 case 0x83:
1237                         product_str = "LSI53C1030T A2";
1238                         break;
1239                 case 0x87:
1240                         product_str = "LSI53C1030T A3";
1241                         break;
1242                 case 0xc1:
1243                         product_str = "LSI53C1020A A1";
1244                         break;
1245                 default:
1246                         product_str = "LSI53C1030";
1247                         break;
1248                 }
1249                 break;
1250         case MPI_MANUFACTPAGE_DEVID_1030_53C1035:
1251                 switch (revision)
1252                 {
1253                 case 0x03:
1254                         product_str = "LSI53C1035 A2";
1255                         break;
1256                 case 0x04:
1257                         product_str = "LSI53C1035 B0";
1258                         break;
1259                 default:
1260                         product_str = "LSI53C1035";
1261                         break;
1262                 }
1263                 break;
1264         case MPI_MANUFACTPAGE_DEVID_SAS1064:
1265                 switch (revision)
1266                 {
1267                 case 0x00:
1268                         product_str = "LSISAS1064 A1";
1269                         break;
1270                 case 0x01:
1271                         product_str = "LSISAS1064 A2";
1272                         break;
1273                 case 0x02:
1274                         product_str = "LSISAS1064 A3";
1275                         break;
1276                 case 0x03:
1277                         product_str = "LSISAS1064 A4";
1278                         break;
1279                 default:
1280                         product_str = "LSISAS1064";
1281                         break;
1282                 }
1283                 break;
1284         case MPI_MANUFACTPAGE_DEVID_SAS1064E:
1285                 switch (revision)
1286                 {
1287                 case 0x00:
1288                         product_str = "LSISAS1064E A0";
1289                         break;
1290                 case 0x01:
1291                         product_str = "LSISAS1064E B0";
1292                         break;
1293                 case 0x02:
1294                         product_str = "LSISAS1064E B1";
1295                         break;
1296                 case 0x04:
1297                         product_str = "LSISAS1064E B2";
1298                         break;
1299                 case 0x08:
1300                         product_str = "LSISAS1064E B3";
1301                         break;
1302                 default:
1303                         product_str = "LSISAS1064E";
1304                         break;
1305                 }
1306                 break;
1307         case MPI_MANUFACTPAGE_DEVID_SAS1068:
1308                 switch (revision)
1309                 {
1310                 case 0x00:
1311                         product_str = "LSISAS1068 A0";
1312                         break;
1313                 case 0x01:
1314                         product_str = "LSISAS1068 B0";
1315                         break;
1316                 case 0x02:
1317                         product_str = "LSISAS1068 B1";
1318                         break;
1319                 default:
1320                         product_str = "LSISAS1068";
1321                         break;
1322                 }
1323                 break;
1324         case MPI_MANUFACTPAGE_DEVID_SAS1068E:
1325                 switch (revision)
1326                 {
1327                 case 0x00:
1328                         product_str = "LSISAS1068E A0";
1329                         break;
1330                 case 0x01:
1331                         product_str = "LSISAS1068E B0";
1332                         break;
1333                 case 0x02:
1334                         product_str = "LSISAS1068E B1";
1335                         break;
1336                 case 0x04:
1337                         product_str = "LSISAS1068E B2";
1338                         break;
1339                 case 0x08:
1340                         product_str = "LSISAS1068E B3";
1341                         break;
1342                 default:
1343                         product_str = "LSISAS1068E";
1344                         break;
1345                 }
1346                 break;
1347         case MPI_MANUFACTPAGE_DEVID_SAS1078:
1348                 switch (revision)
1349                 {
1350                 case 0x00:
1351                         product_str = "LSISAS1078 A0";
1352                         break;
1353                 case 0x01:
1354                         product_str = "LSISAS1078 B0";
1355                         break;
1356                 case 0x02:
1357                         product_str = "LSISAS1078 C0";
1358                         break;
1359                 case 0x03:
1360                         product_str = "LSISAS1078 C1";
1361                         break;
1362                 case 0x04:
1363                         product_str = "LSISAS1078 C2";
1364                         break;
1365                 default:
1366                         product_str = "LSISAS1078";
1367                         break;
1368                 }
1369                 break;
1370         }
1371
1372  out:
1373         if (product_str)
1374                 sprintf(prod_name, "%s", product_str);
1375 }
1376
1377 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1378 /**
1379  *      mpt_attach - Install a PCI intelligent MPT adapter.
1380  *      @pdev: Pointer to pci_dev structure
1381  *      @id: PCI device ID information
1382  *
1383  *      This routine performs all the steps necessary to bring the IOC of
1384  *      a MPT adapter to a OPERATIONAL state.  This includes registering
1385  *      memory regions, registering the interrupt, and allocating request
1386  *      and reply memory pools.
1387  *
1388  *      This routine also pre-fetches the LAN MAC address of a Fibre Channel
1389  *      MPT adapter.
1390  *
1391  *      Returns 0 for success, non-zero for failure.
1392  *
1393  *      TODO: Add support for polled controllers
1394  */
1395 int
1396 mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
1397 {
1398         MPT_ADAPTER     *ioc;
1399         u8              __iomem *mem;
1400         unsigned long    mem_phys;
1401         unsigned long    port;
1402         u32              msize;
1403         u32              psize;
1404         int              ii;
1405         int              r = -ENODEV;
1406         u8               revision;
1407         u8               pcixcmd;
1408         static int       mpt_ids = 0;
1409 #ifdef CONFIG_PROC_FS
1410         struct proc_dir_entry *dent, *ent;
1411 #endif
1412
1413         if (pci_enable_device(pdev))
1414                 return r;
1415
1416         dinitprintk((KERN_WARNING MYNAM ": mpt_adapter_install\n"));
1417
1418         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
1419                 dprintk((KERN_INFO MYNAM
1420                         ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n"));
1421         } else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
1422                 printk(KERN_WARNING MYNAM ": 32 BIT PCI BUS DMA ADDRESSING NOT SUPPORTED\n");
1423                 return r;
1424         }
1425
1426         if (!pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))
1427                 dprintk((KERN_INFO MYNAM
1428                         ": Using 64 bit consistent mask\n"));
1429         else
1430                 dprintk((KERN_INFO MYNAM
1431                         ": Not using 64 bit consistent mask\n"));
1432
1433         ioc = kzalloc(sizeof(MPT_ADAPTER), GFP_ATOMIC);
1434         if (ioc == NULL) {
1435                 printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
1436                 return -ENOMEM;
1437         }
1438         ioc->alloc_total = sizeof(MPT_ADAPTER);
1439         ioc->req_sz = MPT_DEFAULT_FRAME_SIZE;           /* avoid div by zero! */
1440         ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
1441
1442         ioc->pcidev = pdev;
1443         ioc->diagPending = 0;
1444         spin_lock_init(&ioc->diagLock);
1445         spin_lock_init(&ioc->initializing_hba_lock);
1446
1447         /* Initialize the event logging.
1448          */
1449         ioc->eventTypes = 0;    /* None */
1450         ioc->eventContext = 0;
1451         ioc->eventLogSize = 0;
1452         ioc->events = NULL;
1453
1454 #ifdef MFCNT
1455         ioc->mfcnt = 0;
1456 #endif
1457
1458         ioc->cached_fw = NULL;
1459
1460         /* Initilize SCSI Config Data structure
1461          */
1462         memset(&ioc->spi_data, 0, sizeof(SpiCfgData));
1463
1464         /* Initialize the running configQ head.
1465          */
1466         INIT_LIST_HEAD(&ioc->configQ);
1467
1468         /* Initialize the fc rport list head.
1469          */
1470         INIT_LIST_HEAD(&ioc->fc_rports);
1471
1472         /* Find lookup slot. */
1473         INIT_LIST_HEAD(&ioc->list);
1474         ioc->id = mpt_ids++;
1475
1476         mem_phys = msize = 0;
1477         port = psize = 0;
1478         for (ii=0; ii < DEVICE_COUNT_RESOURCE; ii++) {
1479                 if (pci_resource_flags(pdev, ii) & PCI_BASE_ADDRESS_SPACE_IO) {
1480                         if (psize)
1481                                 continue;
1482                         /* Get I/O space! */
1483                         port = pci_resource_start(pdev, ii);
1484                         psize = pci_resource_len(pdev,ii);
1485                 } else {
1486                         if (msize)
1487                                 continue;
1488                         /* Get memmap */
1489                         mem_phys = pci_resource_start(pdev, ii);
1490                         msize = pci_resource_len(pdev,ii);
1491                 }
1492         }
1493         ioc->mem_size = msize;
1494
1495         mem = NULL;
1496         /* Get logical ptr for PciMem0 space */
1497         /*mem = ioremap(mem_phys, msize);*/
1498         mem = ioremap(mem_phys, msize);
1499         if (mem == NULL) {
1500                 printk(KERN_ERR MYNAM ": ERROR - Unable to map adapter memory!\n");
1501                 kfree(ioc);
1502                 return -EINVAL;
1503         }
1504         ioc->memmap = mem;
1505         dinitprintk((KERN_INFO MYNAM ": mem = %p, mem_phys = %lx\n", mem, mem_phys));
1506
1507         dinitprintk((KERN_INFO MYNAM ": facts @ %p, pfacts[0] @ %p\n",
1508                         &ioc->facts, &ioc->pfacts[0]));
1509
1510         ioc->mem_phys = mem_phys;
1511         ioc->chip = (SYSIF_REGS __iomem *)mem;
1512
1513         /* Save Port IO values in case we need to do downloadboot */
1514         {
1515                 u8 *pmem = (u8*)port;
1516                 ioc->pio_mem_phys = port;
1517                 ioc->pio_chip = (SYSIF_REGS __iomem *)pmem;
1518         }
1519
1520         pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1521         mpt_get_product_name(pdev->vendor, pdev->device, revision, ioc->prod_name);
1522
1523         switch (pdev->device)
1524         {
1525         case MPI_MANUFACTPAGE_DEVICEID_FC939X:
1526         case MPI_MANUFACTPAGE_DEVICEID_FC949X:
1527                 ioc->errata_flag_1064 = 1;
1528         case MPI_MANUFACTPAGE_DEVICEID_FC909:
1529         case MPI_MANUFACTPAGE_DEVICEID_FC929:
1530         case MPI_MANUFACTPAGE_DEVICEID_FC919:
1531         case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1532                 ioc->bus_type = FC;
1533                 break;
1534
1535         case MPI_MANUFACTPAGE_DEVICEID_FC929X:
1536                 if (revision < XL_929) {
1537                         /* 929X Chip Fix. Set Split transactions level
1538                         * for PCIX. Set MOST bits to zero.
1539                         */
1540                         pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1541                         pcixcmd &= 0x8F;
1542                         pci_write_config_byte(pdev, 0x6a, pcixcmd);
1543                 } else {
1544                         /* 929XL Chip Fix. Set MMRBC to 0x08.
1545                         */
1546                         pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1547                         pcixcmd |= 0x08;
1548                         pci_write_config_byte(pdev, 0x6a, pcixcmd);
1549                 }
1550                 ioc->bus_type = FC;
1551                 break;
1552
1553         case MPI_MANUFACTPAGE_DEVICEID_FC919X:
1554                 /* 919X Chip Fix. Set Split transactions level
1555                  * for PCIX. Set MOST bits to zero.
1556                  */
1557                 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1558                 pcixcmd &= 0x8F;
1559                 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1560                 ioc->bus_type = FC;
1561                 break;
1562
1563         case MPI_MANUFACTPAGE_DEVID_53C1030:
1564                 /* 1030 Chip Fix. Disable Split transactions
1565                  * for PCIX. Set MOST bits to zero if Rev < C0( = 8).
1566                  */
1567                 if (revision < C0_1030) {
1568                         pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1569                         pcixcmd &= 0x8F;
1570                         pci_write_config_byte(pdev, 0x6a, pcixcmd);
1571                 }
1572
1573         case MPI_MANUFACTPAGE_DEVID_1030_53C1035:
1574                 ioc->bus_type = SPI;
1575                 break;
1576
1577         case MPI_MANUFACTPAGE_DEVID_SAS1064:
1578         case MPI_MANUFACTPAGE_DEVID_SAS1068:
1579                 ioc->errata_flag_1064 = 1;
1580
1581         case MPI_MANUFACTPAGE_DEVID_SAS1064E:
1582         case MPI_MANUFACTPAGE_DEVID_SAS1068E:
1583         case MPI_MANUFACTPAGE_DEVID_SAS1078:
1584                 ioc->bus_type = SAS;
1585         }
1586
1587         if (ioc->errata_flag_1064)
1588                 pci_disable_io_access(pdev);
1589
1590         sprintf(ioc->name, "ioc%d", ioc->id);
1591
1592         spin_lock_init(&ioc->FreeQlock);
1593
1594         /* Disable all! */
1595         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1596         ioc->active = 0;
1597         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1598
1599         /* Set lookup ptr. */
1600         list_add_tail(&ioc->list, &ioc_list);
1601
1602         /* Check for "bound ports" (929, 929X, 1030, 1035) to reduce redundant resets.
1603          */
1604         mpt_detect_bound_ports(ioc, pdev);
1605
1606         if ((r = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
1607             CAN_SLEEP)) != 0){
1608                 printk(KERN_WARNING MYNAM
1609                   ": WARNING - %s did not initialize properly! (%d)\n",
1610                   ioc->name, r);
1611
1612                 list_del(&ioc->list);
1613                 if (ioc->alt_ioc)
1614                         ioc->alt_ioc->alt_ioc = NULL;
1615                 iounmap(mem);
1616                 kfree(ioc);
1617                 pci_set_drvdata(pdev, NULL);
1618                 return r;
1619         }
1620
1621         /* call per device driver probe entry point */
1622         for(ii=0; ii<MPT_MAX_PROTOCOL_DRIVERS; ii++) {
1623                 if(MptDeviceDriverHandlers[ii] &&
1624                   MptDeviceDriverHandlers[ii]->probe) {
1625                         MptDeviceDriverHandlers[ii]->probe(pdev,id);
1626                 }
1627         }
1628
1629 #ifdef CONFIG_PROC_FS
1630         /*
1631          *  Create "/proc/mpt/iocN" subdirectory entry for each MPT adapter.
1632          */
1633         dent = proc_mkdir(ioc->name, mpt_proc_root_dir);
1634         if (dent) {
1635                 ent = create_proc_entry("info", S_IFREG|S_IRUGO, dent);
1636                 if (ent) {
1637                         ent->read_proc = procmpt_iocinfo_read;
1638                         ent->data = ioc;
1639                 }
1640                 ent = create_proc_entry("summary", S_IFREG|S_IRUGO, dent);
1641                 if (ent) {
1642                         ent->read_proc = procmpt_summary_read;
1643                         ent->data = ioc;
1644                 }
1645         }
1646 #endif
1647
1648         return 0;
1649 }
1650
1651 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1652 /**
1653  *      mpt_detach - Remove a PCI intelligent MPT adapter.
1654  *      @pdev: Pointer to pci_dev structure
1655  */
1656
1657 void
1658 mpt_detach(struct pci_dev *pdev)
1659 {
1660         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1661         char pname[32];
1662         int ii;
1663
1664         sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/summary", ioc->name);
1665         remove_proc_entry(pname, NULL);
1666         sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/info", ioc->name);
1667         remove_proc_entry(pname, NULL);
1668         sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s", ioc->name);
1669         remove_proc_entry(pname, NULL);
1670
1671         /* call per device driver remove entry point */
1672         for(ii=0; ii<MPT_MAX_PROTOCOL_DRIVERS; ii++) {
1673                 if(MptDeviceDriverHandlers[ii] &&
1674                   MptDeviceDriverHandlers[ii]->remove) {
1675                         MptDeviceDriverHandlers[ii]->remove(pdev);
1676                 }
1677         }
1678
1679         /* Disable interrupts! */
1680         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1681
1682         ioc->active = 0;
1683         synchronize_irq(pdev->irq);
1684
1685         /* Clear any lingering interrupt */
1686         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1687
1688         CHIPREG_READ32(&ioc->chip->IntStatus);
1689
1690         mpt_adapter_dispose(ioc);
1691
1692         pci_set_drvdata(pdev, NULL);
1693 }
1694
1695 /**************************************************************************
1696  * Power Management
1697  */
1698 #ifdef CONFIG_PM
1699 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1700 /**
1701  *      mpt_suspend - Fusion MPT base driver suspend routine.
1702  *      @pdev: Pointer to pci_dev structure
1703  *      @state: new state to enter
1704  */
1705 int
1706 mpt_suspend(struct pci_dev *pdev, pm_message_t state)
1707 {
1708         u32 device_state;
1709         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1710
1711         device_state=pci_choose_state(pdev, state);
1712
1713         printk(MYIOC_s_INFO_FMT
1714         "pci-suspend: pdev=0x%p, slot=%s, Entering operating state [D%d]\n",
1715                 ioc->name, pdev, pci_name(pdev), device_state);
1716
1717         pci_save_state(pdev);
1718
1719         /* put ioc into READY_STATE */
1720         if(SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, CAN_SLEEP)) {
1721                 printk(MYIOC_s_ERR_FMT
1722                 "pci-suspend:  IOC msg unit reset failed!\n", ioc->name);
1723         }
1724
1725         /* disable interrupts */
1726         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1727         ioc->active = 0;
1728
1729         /* Clear any lingering interrupt */
1730         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1731
1732         pci_disable_device(pdev);
1733         pci_set_power_state(pdev, device_state);
1734
1735         return 0;
1736 }
1737
1738 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1739 /**
1740  *      mpt_resume - Fusion MPT base driver resume routine.
1741  *      @pdev: Pointer to pci_dev structure
1742  */
1743 int
1744 mpt_resume(struct pci_dev *pdev)
1745 {
1746         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1747         u32 device_state = pdev->current_state;
1748         int recovery_state;
1749         int err;
1750
1751         printk(MYIOC_s_INFO_FMT
1752         "pci-resume: pdev=0x%p, slot=%s, Previous operating state [D%d]\n",
1753                 ioc->name, pdev, pci_name(pdev), device_state);
1754
1755         pci_set_power_state(pdev, 0);
1756         pci_restore_state(pdev);
1757         err = pci_enable_device(pdev);
1758         if (err)
1759                 return err;
1760
1761         /* enable interrupts */
1762         CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
1763         ioc->active = 1;
1764
1765         printk(MYIOC_s_INFO_FMT
1766                 "pci-resume: ioc-state=0x%x,doorbell=0x%x\n",
1767                 ioc->name,
1768                 (mpt_GetIocState(ioc, 1) >> MPI_IOC_STATE_SHIFT),
1769                 CHIPREG_READ32(&ioc->chip->Doorbell));
1770
1771         /* bring ioc to operational state */
1772         if ((recovery_state = mpt_do_ioc_recovery(ioc,
1773             MPT_HOSTEVENT_IOC_RECOVER, CAN_SLEEP)) != 0) {
1774                 printk(MYIOC_s_INFO_FMT
1775                         "pci-resume: Cannot recover, error:[%x]\n",
1776                         ioc->name, recovery_state);
1777         } else {
1778                 printk(MYIOC_s_INFO_FMT
1779                         "pci-resume: success\n", ioc->name);
1780         }
1781
1782         return 0;
1783 }
1784 #endif
1785
1786 static int
1787 mpt_signal_reset(int index, MPT_ADAPTER *ioc, int reset_phase)
1788 {
1789         if ((MptDriverClass[index] == MPTSPI_DRIVER &&
1790              ioc->bus_type != SPI) ||
1791             (MptDriverClass[index] == MPTFC_DRIVER &&
1792              ioc->bus_type != FC) ||
1793             (MptDriverClass[index] == MPTSAS_DRIVER &&
1794              ioc->bus_type != SAS))
1795                 /* make sure we only call the relevant reset handler
1796                  * for the bus */
1797                 return 0;
1798         return (MptResetHandlers[index])(ioc, reset_phase);
1799 }
1800
1801 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1802 /**
1803  *      mpt_do_ioc_recovery - Initialize or recover MPT adapter.
1804  *      @ioc: Pointer to MPT adapter structure
1805  *      @reason: Event word / reason
1806  *      @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
1807  *
1808  *      This routine performs all the steps necessary to bring the IOC
1809  *      to a OPERATIONAL state.
1810  *
1811  *      This routine also pre-fetches the LAN MAC address of a Fibre Channel
1812  *      MPT adapter.
1813  *
1814  *      Returns:
1815  *               0 for success
1816  *              -1 if failed to get board READY
1817  *              -2 if READY but IOCFacts Failed
1818  *              -3 if READY but PrimeIOCFifos Failed
1819  *              -4 if READY but IOCInit Failed
1820  */
1821 static int
1822 mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
1823 {
1824         int      hard_reset_done = 0;
1825         int      alt_ioc_ready = 0;
1826         int      hard;
1827         int      rc=0;
1828         int      ii;
1829         int      handlers;
1830         int      ret = 0;
1831         int      reset_alt_ioc_active = 0;
1832         int      irq_allocated = 0;
1833
1834         printk(KERN_INFO MYNAM ": Initiating %s %s\n",
1835                         ioc->name, reason==MPT_HOSTEVENT_IOC_BRINGUP ? "bringup" : "recovery");
1836
1837         /* Disable reply interrupts (also blocks FreeQ) */
1838         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1839         ioc->active = 0;
1840
1841         if (ioc->alt_ioc) {
1842                 if (ioc->alt_ioc->active)
1843                         reset_alt_ioc_active = 1;
1844
1845                 /* Disable alt-IOC's reply interrupts (and FreeQ) for a bit ... */
1846                 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, 0xFFFFFFFF);
1847                 ioc->alt_ioc->active = 0;
1848         }
1849
1850         hard = 1;
1851         if (reason == MPT_HOSTEVENT_IOC_BRINGUP)
1852                 hard = 0;
1853
1854         if ((hard_reset_done = MakeIocReady(ioc, hard, sleepFlag)) < 0) {
1855                 if (hard_reset_done == -4) {
1856                         printk(KERN_WARNING MYNAM ": %s Owned by PEER..skipping!\n",
1857                                         ioc->name);
1858
1859                         if (reset_alt_ioc_active && ioc->alt_ioc) {
1860                                 /* (re)Enable alt-IOC! (reply interrupt, FreeQ) */
1861                                 dprintk((KERN_INFO MYNAM ": alt-%s reply irq re-enabled\n",
1862                                                 ioc->alt_ioc->name));
1863                                 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
1864                                 ioc->alt_ioc->active = 1;
1865                         }
1866
1867                 } else {
1868                         printk(KERN_WARNING MYNAM ": %s NOT READY WARNING!\n",
1869                                         ioc->name);
1870                 }
1871                 return -1;
1872         }
1873
1874         /* hard_reset_done = 0 if a soft reset was performed
1875          * and 1 if a hard reset was performed.
1876          */
1877         if (hard_reset_done && reset_alt_ioc_active && ioc->alt_ioc) {
1878                 if ((rc = MakeIocReady(ioc->alt_ioc, 0, sleepFlag)) == 0)
1879                         alt_ioc_ready = 1;
1880                 else
1881                         printk(KERN_WARNING MYNAM
1882                                         ": alt-%s: Not ready WARNING!\n",
1883                                         ioc->alt_ioc->name);
1884         }
1885
1886         for (ii=0; ii<5; ii++) {
1887                 /* Get IOC facts! Allow 5 retries */
1888                 if ((rc = GetIocFacts(ioc, sleepFlag, reason)) == 0)
1889                         break;
1890         }
1891
1892
1893         if (ii == 5) {
1894                 dinitprintk((MYIOC_s_INFO_FMT "Retry IocFacts failed rc=%x\n", ioc->name, rc));
1895                 ret = -2;
1896         } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
1897                 MptDisplayIocCapabilities(ioc);
1898         }
1899
1900         if (alt_ioc_ready) {
1901                 if ((rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason)) != 0) {
1902                         dinitprintk((MYIOC_s_INFO_FMT "Initial Alt IocFacts failed rc=%x\n", ioc->name, rc));
1903                         /* Retry - alt IOC was initialized once
1904                          */
1905                         rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason);
1906                 }
1907                 if (rc) {
1908                         dinitprintk((MYIOC_s_INFO_FMT "Retry Alt IocFacts failed rc=%x\n", ioc->name, rc));
1909                         alt_ioc_ready = 0;
1910                         reset_alt_ioc_active = 0;
1911                 } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
1912                         MptDisplayIocCapabilities(ioc->alt_ioc);
1913                 }
1914         }
1915
1916         /*
1917          * Device is reset now. It must have de-asserted the interrupt line
1918          * (if it was asserted) and it should be safe to register for the
1919          * interrupt now.
1920          */
1921         if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
1922                 ioc->pci_irq = -1;
1923                 if (ioc->pcidev->irq) {
1924                         if (mpt_msi_enable && !pci_enable_msi(ioc->pcidev))
1925                                 printk(MYIOC_s_INFO_FMT "PCI-MSI enabled\n",
1926                                         ioc->name);
1927                         rc = request_irq(ioc->pcidev->irq, mpt_interrupt,
1928                                         IRQF_SHARED, ioc->name, ioc);
1929                         if (rc < 0) {
1930                                 printk(MYIOC_s_ERR_FMT "Unable to allocate "
1931                                         "interrupt %d!\n", ioc->name,
1932                                         ioc->pcidev->irq);
1933                                 if (mpt_msi_enable)
1934                                         pci_disable_msi(ioc->pcidev);
1935                                 return -EBUSY;
1936                         }
1937                         irq_allocated = 1;
1938                         ioc->pci_irq = ioc->pcidev->irq;
1939                         pci_set_master(ioc->pcidev);            /* ?? */
1940                         pci_set_drvdata(ioc->pcidev, ioc);
1941                         dprintk((KERN_INFO MYNAM ": %s installed at interrupt "
1942                                 "%d\n", ioc->name, ioc->pcidev->irq));
1943                 }
1944         }
1945
1946         /* Prime reply & request queues!
1947          * (mucho alloc's) Must be done prior to
1948          * init as upper addresses are needed for init.
1949          * If fails, continue with alt-ioc processing
1950          */
1951         if ((ret == 0) && ((rc = PrimeIocFifos(ioc)) != 0))
1952                 ret = -3;
1953
1954         /* May need to check/upload firmware & data here!
1955          * If fails, continue with alt-ioc processing
1956          */
1957         if ((ret == 0) && ((rc = SendIocInit(ioc, sleepFlag)) != 0))
1958                 ret = -4;
1959 // NEW!
1960         if (alt_ioc_ready && ((rc = PrimeIocFifos(ioc->alt_ioc)) != 0)) {
1961                 printk(KERN_WARNING MYNAM ": alt-%s: (%d) FIFO mgmt alloc WARNING!\n",
1962                                 ioc->alt_ioc->name, rc);
1963                 alt_ioc_ready = 0;
1964                 reset_alt_ioc_active = 0;
1965         }
1966
1967         if (alt_ioc_ready) {
1968                 if ((rc = SendIocInit(ioc->alt_ioc, sleepFlag)) != 0) {
1969                         alt_ioc_ready = 0;
1970                         reset_alt_ioc_active = 0;
1971                         printk(KERN_WARNING MYNAM
1972                                 ": alt-%s: (%d) init failure WARNING!\n",
1973                                         ioc->alt_ioc->name, rc);
1974                 }
1975         }
1976
1977         if (reason == MPT_HOSTEVENT_IOC_BRINGUP){
1978                 if (ioc->upload_fw) {
1979                         ddlprintk((MYIOC_s_INFO_FMT
1980                                 "firmware upload required!\n", ioc->name));
1981
1982                         /* Controller is not operational, cannot do upload
1983                          */
1984                         if (ret == 0) {
1985                                 rc = mpt_do_upload(ioc, sleepFlag);
1986                                 if (rc == 0) {
1987                                         if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
1988                                                 /*
1989                                                  * Maintain only one pointer to FW memory
1990                                                  * so there will not be two attempt to
1991                                                  * downloadboot onboard dual function
1992                                                  * chips (mpt_adapter_disable,
1993                                                  * mpt_diag_reset)
1994                                                  */
1995                                                 ddlprintk((MYIOC_s_INFO_FMT ": mpt_upload:  alt_%s has cached_fw=%p \n",
1996                                                         ioc->name, ioc->alt_ioc->name, ioc->alt_ioc->cached_fw));
1997                                                 ioc->alt_ioc->cached_fw = NULL;
1998                                         }
1999                                 } else {
2000                                         printk(KERN_WARNING MYNAM ": firmware upload failure!\n");
2001                                         ret = -5;
2002                                 }
2003                         }
2004                 }
2005         }
2006
2007         if (ret == 0) {
2008                 /* Enable! (reply interrupt) */
2009                 CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
2010                 ioc->active = 1;
2011         }
2012
2013         if (reset_alt_ioc_active && ioc->alt_ioc) {
2014                 /* (re)Enable alt-IOC! (reply interrupt) */
2015                 dinitprintk((KERN_INFO MYNAM ": alt-%s reply irq re-enabled\n",
2016                                 ioc->alt_ioc->name));
2017                 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
2018                 ioc->alt_ioc->active = 1;
2019         }
2020
2021         /*  Enable MPT base driver management of EventNotification
2022          *  and EventAck handling.
2023          */
2024         if ((ret == 0) && (!ioc->facts.EventState))
2025                 (void) SendEventNotification(ioc, 1);   /* 1=Enable EventNotification */
2026
2027         if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
2028                 (void) SendEventNotification(ioc->alt_ioc, 1);  /* 1=Enable EventNotification */
2029
2030         /*      Add additional "reason" check before call to GetLanConfigPages
2031          *      (combined with GetIoUnitPage2 call).  This prevents a somewhat
2032          *      recursive scenario; GetLanConfigPages times out, timer expired
2033          *      routine calls HardResetHandler, which calls into here again,
2034          *      and we try GetLanConfigPages again...
2035          */
2036         if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
2037
2038                 /*
2039                  * Initalize link list for inactive raid volumes.
2040                  */
2041                 init_MUTEX(&ioc->raid_data.inactive_list_mutex);
2042                 INIT_LIST_HEAD(&ioc->raid_data.inactive_list);
2043
2044                 if (ioc->bus_type == SAS) {
2045
2046                         /* clear persistency table */
2047                         if(ioc->facts.IOCExceptions &
2048                             MPI_IOCFACTS_EXCEPT_PERSISTENT_TABLE_FULL) {
2049                                 ret = mptbase_sas_persist_operation(ioc,
2050                                     MPI_SAS_OP_CLEAR_NOT_PRESENT);
2051                                 if(ret != 0)
2052                                         goto out;
2053                         }
2054
2055                         /* Find IM volumes
2056                          */
2057                         mpt_findImVolumes(ioc);
2058
2059                 } else if (ioc->bus_type == FC) {
2060                         if ((ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) &&
2061                             (ioc->lan_cnfg_page0.Header.PageLength == 0)) {
2062                                 /*
2063                                  *  Pre-fetch the ports LAN MAC address!
2064                                  *  (LANPage1_t stuff)
2065                                  */
2066                                 (void) GetLanConfigPages(ioc);
2067 #ifdef MPT_DEBUG
2068                                 {
2069                                         u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
2070                                         dprintk((MYIOC_s_INFO_FMT "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
2071                                                         ioc->name, a[5], a[4], a[3], a[2], a[1], a[0] ));
2072                                 }
2073 #endif
2074                         }
2075                 } else {
2076                         /* Get NVRAM and adapter maximums from SPP 0 and 2
2077                          */
2078                         mpt_GetScsiPortSettings(ioc, 0);
2079
2080                         /* Get version and length of SDP 1
2081                          */
2082                         mpt_readScsiDevicePageHeaders(ioc, 0);
2083
2084                         /* Find IM volumes
2085                          */
2086                         if (ioc->facts.MsgVersion >= MPI_VERSION_01_02)
2087                                 mpt_findImVolumes(ioc);
2088
2089                         /* Check, and possibly reset, the coalescing value
2090                          */
2091                         mpt_read_ioc_pg_1(ioc);
2092
2093                         mpt_read_ioc_pg_4(ioc);
2094                 }
2095
2096                 GetIoUnitPage2(ioc);
2097                 mpt_get_manufacturing_pg_0(ioc);
2098         }
2099
2100         /*
2101          * Call each currently registered protocol IOC reset handler
2102          * with post-reset indication.
2103          * NOTE: If we're doing _IOC_BRINGUP, there can be no
2104          * MptResetHandlers[] registered yet.
2105          */
2106         if (hard_reset_done) {
2107                 rc = handlers = 0;
2108                 for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
2109                         if ((ret == 0) && MptResetHandlers[ii]) {
2110                                 dprintk((MYIOC_s_INFO_FMT "Calling IOC post_reset handler #%d\n",
2111                                                 ioc->name, ii));
2112                                 rc += mpt_signal_reset(ii, ioc, MPT_IOC_POST_RESET);
2113                                 handlers++;
2114                         }
2115
2116                         if (alt_ioc_ready && MptResetHandlers[ii]) {
2117                                 drsprintk((MYIOC_s_INFO_FMT "Calling alt-%s post_reset handler #%d\n",
2118                                                 ioc->name, ioc->alt_ioc->name, ii));
2119                                 rc += mpt_signal_reset(ii, ioc->alt_ioc, MPT_IOC_POST_RESET);
2120                                 handlers++;
2121                         }
2122                 }
2123                 /* FIXME?  Examine results here? */
2124         }
2125
2126  out:
2127         if ((ret != 0) && irq_allocated) {
2128                 free_irq(ioc->pci_irq, ioc);
2129                 if (mpt_msi_enable)
2130                         pci_disable_msi(ioc->pcidev);
2131         }
2132         return ret;
2133 }
2134
2135 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2136 /**
2137  *      mpt_detect_bound_ports - Search for matching PCI bus/dev_function
2138  *      @ioc: Pointer to MPT adapter structure
2139  *      @pdev: Pointer to (struct pci_dev) structure
2140  *
2141  *      Search for PCI bus/dev_function which matches
2142  *      PCI bus/dev_function (+/-1) for newly discovered 929,
2143  *      929X, 1030 or 1035.
2144  *
2145  *      If match on PCI dev_function +/-1 is found, bind the two MPT adapters
2146  *      using alt_ioc pointer fields in their %MPT_ADAPTER structures.
2147  */
2148 static void
2149 mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev)
2150 {
2151         struct pci_dev *peer=NULL;
2152         unsigned int slot = PCI_SLOT(pdev->devfn);
2153         unsigned int func = PCI_FUNC(pdev->devfn);
2154         MPT_ADAPTER *ioc_srch;
2155
2156         dprintk((MYIOC_s_INFO_FMT "PCI device %s devfn=%x/%x,"
2157             " searching for devfn match on %x or %x\n",
2158                 ioc->name, pci_name(pdev), pdev->bus->number,
2159                 pdev->devfn, func-1, func+1));
2160
2161         peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func-1));
2162         if (!peer) {
2163                 peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func+1));
2164                 if (!peer)
2165                         return;
2166         }
2167
2168         list_for_each_entry(ioc_srch, &ioc_list, list) {
2169                 struct pci_dev *_pcidev = ioc_srch->pcidev;
2170                 if (_pcidev == peer) {
2171                         /* Paranoia checks */
2172                         if (ioc->alt_ioc != NULL) {
2173                                 printk(KERN_WARNING MYNAM ": Oops, already bound (%s <==> %s)!\n",
2174                                         ioc->name, ioc->alt_ioc->name);
2175                                 break;
2176                         } else if (ioc_srch->alt_ioc != NULL) {
2177                                 printk(KERN_WARNING MYNAM ": Oops, already bound (%s <==> %s)!\n",
2178                                         ioc_srch->name, ioc_srch->alt_ioc->name);
2179                                 break;
2180                         }
2181                         dprintk((KERN_INFO MYNAM ": FOUND! binding %s <==> %s\n",
2182                                 ioc->name, ioc_srch->name));
2183                         ioc_srch->alt_ioc = ioc;
2184                         ioc->alt_ioc = ioc_srch;
2185                 }
2186         }
2187         pci_dev_put(peer);
2188 }
2189
2190 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2191 /**
2192  *      mpt_adapter_disable - Disable misbehaving MPT adapter.
2193  *      @ioc: Pointer to MPT adapter structure
2194  */
2195 static void
2196 mpt_adapter_disable(MPT_ADAPTER *ioc)
2197 {
2198         int sz;
2199         int ret;
2200
2201         if (ioc->cached_fw != NULL) {
2202                 ddlprintk((KERN_INFO MYNAM ": mpt_adapter_disable: Pushing FW onto adapter\n"));
2203                 if ((ret = mpt_downloadboot(ioc, (MpiFwHeader_t *)ioc->cached_fw, NO_SLEEP)) < 0) {
2204                         printk(KERN_WARNING MYNAM
2205                                 ": firmware downloadboot failure (%d)!\n", ret);
2206                 }
2207         }
2208
2209         /* Disable adapter interrupts! */
2210         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
2211         ioc->active = 0;
2212         /* Clear any lingering interrupt */
2213         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
2214
2215         if (ioc->alloc != NULL) {
2216                 sz = ioc->alloc_sz;
2217                 dexitprintk((KERN_INFO MYNAM ": %s.free  @ %p, sz=%d bytes\n",
2218                         ioc->name, ioc->alloc, ioc->alloc_sz));
2219                 pci_free_consistent(ioc->pcidev, sz,
2220                                 ioc->alloc, ioc->alloc_dma);
2221                 ioc->reply_frames = NULL;
2222                 ioc->req_frames = NULL;
2223                 ioc->alloc = NULL;
2224                 ioc->alloc_total -= sz;
2225         }
2226
2227         if (ioc->sense_buf_pool != NULL) {
2228                 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
2229                 pci_free_consistent(ioc->pcidev, sz,
2230                                 ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
2231                 ioc->sense_buf_pool = NULL;
2232                 ioc->alloc_total -= sz;
2233         }
2234
2235         if (ioc->events != NULL){
2236                 sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
2237                 kfree(ioc->events);
2238                 ioc->events = NULL;
2239                 ioc->alloc_total -= sz;
2240         }
2241
2242         if (ioc->cached_fw != NULL) {
2243                 sz = ioc->facts.FWImageSize;
2244                 pci_free_consistent(ioc->pcidev, sz,
2245                         ioc->cached_fw, ioc->cached_fw_dma);
2246                 ioc->cached_fw = NULL;
2247                 ioc->alloc_total -= sz;
2248         }
2249
2250         kfree(ioc->spi_data.nvram);
2251         mpt_inactive_raid_list_free(ioc);
2252         kfree(ioc->raid_data.pIocPg2);
2253         kfree(ioc->raid_data.pIocPg3);
2254         ioc->spi_data.nvram = NULL;
2255         ioc->raid_data.pIocPg3 = NULL;
2256
2257         if (ioc->spi_data.pIocPg4 != NULL) {
2258                 sz = ioc->spi_data.IocPg4Sz;
2259                 pci_free_consistent(ioc->pcidev, sz,
2260                         ioc->spi_data.pIocPg4,
2261                         ioc->spi_data.IocPg4_dma);
2262                 ioc->spi_data.pIocPg4 = NULL;
2263                 ioc->alloc_total -= sz;
2264         }
2265
2266         if (ioc->ReqToChain != NULL) {
2267                 kfree(ioc->ReqToChain);
2268                 kfree(ioc->RequestNB);
2269                 ioc->ReqToChain = NULL;
2270         }
2271
2272         kfree(ioc->ChainToChain);
2273         ioc->ChainToChain = NULL;
2274
2275         if (ioc->HostPageBuffer != NULL) {
2276                 if((ret = mpt_host_page_access_control(ioc,
2277                     MPI_DB_HPBAC_FREE_BUFFER, NO_SLEEP)) != 0) {
2278                         printk(KERN_ERR MYNAM
2279                            ": %s: host page buffers free failed (%d)!\n",
2280                             __FUNCTION__, ret);
2281                 }
2282                 dexitprintk((KERN_INFO MYNAM ": %s HostPageBuffer free  @ %p, sz=%d bytes\n",
2283                         ioc->name, ioc->HostPageBuffer, ioc->HostPageBuffer_sz));
2284                 pci_free_consistent(ioc->pcidev, ioc->HostPageBuffer_sz,
2285                                 ioc->HostPageBuffer,
2286                                 ioc->HostPageBuffer_dma);
2287                 ioc->HostPageBuffer = NULL;
2288                 ioc->HostPageBuffer_sz = 0;
2289                 ioc->alloc_total -= ioc->HostPageBuffer_sz;
2290         }
2291 }
2292
2293 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2294 /**
2295  *      mpt_adapter_dispose - Free all resources associated with an MPT adapter
2296  *      @ioc: Pointer to MPT adapter structure
2297  *
2298  *      This routine unregisters h/w resources and frees all alloc'd memory
2299  *      associated with a MPT adapter structure.
2300  */
2301 static void
2302 mpt_adapter_dispose(MPT_ADAPTER *ioc)
2303 {
2304         int sz_first, sz_last;
2305
2306         if (ioc == NULL)
2307                 return;
2308
2309         sz_first = ioc->alloc_total;
2310
2311         mpt_adapter_disable(ioc);
2312
2313         if (ioc->pci_irq != -1) {
2314                 free_irq(ioc->pci_irq, ioc);
2315                 if (mpt_msi_enable)
2316                         pci_disable_msi(ioc->pcidev);
2317                 ioc->pci_irq = -1;
2318         }
2319
2320         if (ioc->memmap != NULL) {
2321                 iounmap(ioc->memmap);
2322                 ioc->memmap = NULL;
2323         }
2324
2325 #if defined(CONFIG_MTRR) && 0
2326         if (ioc->mtrr_reg > 0) {
2327                 mtrr_del(ioc->mtrr_reg, 0, 0);
2328                 dprintk((KERN_INFO MYNAM ": %s: MTRR region de-registered\n", ioc->name));
2329         }
2330 #endif
2331
2332         /*  Zap the adapter lookup ptr!  */
2333         list_del(&ioc->list);
2334
2335         sz_last = ioc->alloc_total;
2336         dprintk((KERN_INFO MYNAM ": %s: free'd %d of %d bytes\n",
2337                         ioc->name, sz_first-sz_last+(int)sizeof(*ioc), sz_first));
2338
2339         if (ioc->alt_ioc)
2340                 ioc->alt_ioc->alt_ioc = NULL;
2341
2342         kfree(ioc);
2343 }
2344
2345 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2346 /**
2347  *      MptDisplayIocCapabilities - Disply IOC's capabilities.
2348  *      @ioc: Pointer to MPT adapter structure
2349  */
2350 static void
2351 MptDisplayIocCapabilities(MPT_ADAPTER *ioc)
2352 {
2353         int i = 0;
2354
2355         printk(KERN_INFO "%s: ", ioc->name);
2356         if (ioc->prod_name)
2357                 printk("%s: ", ioc->prod_name);
2358         printk("Capabilities={");
2359
2360         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) {
2361                 printk("Initiator");
2362                 i++;
2363         }
2364
2365         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2366                 printk("%sTarget", i ? "," : "");
2367                 i++;
2368         }
2369
2370         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
2371                 printk("%sLAN", i ? "," : "");
2372                 i++;
2373         }
2374
2375 #if 0
2376         /*
2377          *  This would probably evoke more questions than it's worth
2378          */
2379         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2380                 printk("%sLogBusAddr", i ? "," : "");
2381                 i++;
2382         }
2383 #endif
2384
2385         printk("}\n");
2386 }
2387
2388 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2389 /**
2390  *      MakeIocReady - Get IOC to a READY state, using KickStart if needed.
2391  *      @ioc: Pointer to MPT_ADAPTER structure
2392  *      @force: Force hard KickStart of IOC
2393  *      @sleepFlag: Specifies whether the process can sleep
2394  *
2395  *      Returns:
2396  *               1 - DIAG reset and READY
2397  *               0 - READY initially OR soft reset and READY
2398  *              -1 - Any failure on KickStart
2399  *              -2 - Msg Unit Reset Failed
2400  *              -3 - IO Unit Reset Failed
2401  *              -4 - IOC owned by a PEER
2402  */
2403 static int
2404 MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag)
2405 {
2406         u32      ioc_state;
2407         int      statefault = 0;
2408         int      cntdn;
2409         int      hard_reset_done = 0;
2410         int      r;
2411         int      ii;
2412         int      whoinit;
2413
2414         /* Get current [raw] IOC state  */
2415         ioc_state = mpt_GetIocState(ioc, 0);
2416         dhsprintk((KERN_INFO MYNAM "::MakeIocReady, %s [raw] state=%08x\n", ioc->name, ioc_state));
2417
2418         /*
2419          *      Check to see if IOC got left/stuck in doorbell handshake
2420          *      grip of death.  If so, hard reset the IOC.
2421          */
2422         if (ioc_state & MPI_DOORBELL_ACTIVE) {
2423                 statefault = 1;
2424                 printk(MYIOC_s_WARN_FMT "Unexpected doorbell active!\n",
2425                                 ioc->name);
2426         }
2427
2428         /* Is it already READY? */
2429         if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY)
2430                 return 0;
2431
2432         /*
2433          *      Check to see if IOC is in FAULT state.
2434          */
2435         if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
2436                 statefault = 2;
2437                 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state!!!\n",
2438                                 ioc->name);
2439                 printk(KERN_WARNING "           FAULT code = %04xh\n",
2440                                 ioc_state & MPI_DOORBELL_DATA_MASK);
2441         }
2442
2443         /*
2444          *      Hmmm...  Did it get left operational?
2445          */
2446         if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_OPERATIONAL) {
2447                 dinitprintk((MYIOC_s_INFO_FMT "IOC operational unexpected\n",
2448                                 ioc->name));
2449
2450                 /* Check WhoInit.
2451                  * If PCI Peer, exit.
2452                  * Else, if no fault conditions are present, issue a MessageUnitReset
2453                  * Else, fall through to KickStart case
2454                  */
2455                 whoinit = (ioc_state & MPI_DOORBELL_WHO_INIT_MASK) >> MPI_DOORBELL_WHO_INIT_SHIFT;
2456                 dinitprintk((KERN_INFO MYNAM
2457                         ": whoinit 0x%x statefault %d force %d\n",
2458                         whoinit, statefault, force));
2459                 if (whoinit == MPI_WHOINIT_PCI_PEER)
2460                         return -4;
2461                 else {
2462                         if ((statefault == 0 ) && (force == 0)) {
2463                                 if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) == 0)
2464                                         return 0;
2465                         }
2466                         statefault = 3;
2467                 }
2468         }
2469
2470         hard_reset_done = KickStart(ioc, statefault||force, sleepFlag);
2471         if (hard_reset_done < 0)
2472                 return -1;
2473
2474         /*
2475          *  Loop here waiting for IOC to come READY.
2476          */
2477         ii = 0;
2478         cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 5;     /* 5 seconds */
2479
2480         while ((ioc_state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
2481                 if (ioc_state == MPI_IOC_STATE_OPERATIONAL) {
2482                         /*
2483                          *  BIOS or previous driver load left IOC in OP state.
2484                          *  Reset messaging FIFOs.
2485                          */
2486                         if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) != 0) {
2487                                 printk(MYIOC_s_ERR_FMT "IOC msg unit reset failed!\n", ioc->name);
2488                                 return -2;
2489                         }
2490                 } else if (ioc_state == MPI_IOC_STATE_RESET) {
2491                         /*
2492                          *  Something is wrong.  Try to get IOC back
2493                          *  to a known state.
2494                          */
2495                         if ((r = SendIocReset(ioc, MPI_FUNCTION_IO_UNIT_RESET, sleepFlag)) != 0) {
2496                                 printk(MYIOC_s_ERR_FMT "IO unit reset failed!\n", ioc->name);
2497                                 return -3;
2498                         }
2499                 }
2500
2501                 ii++; cntdn--;
2502                 if (!cntdn) {
2503                         printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
2504                                         ioc->name, (int)((ii+5)/HZ));
2505                         return -ETIME;
2506                 }
2507
2508                 if (sleepFlag == CAN_SLEEP) {
2509                         msleep(1);
2510                 } else {
2511                         mdelay (1);     /* 1 msec delay */
2512                 }
2513
2514         }
2515
2516         if (statefault < 3) {
2517                 printk(MYIOC_s_INFO_FMT "Recovered from %s\n",
2518                                 ioc->name,
2519                                 statefault==1 ? "stuck handshake" : "IOC FAULT");
2520         }
2521
2522         return hard_reset_done;
2523 }
2524
2525 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2526 /**
2527  *      mpt_GetIocState - Get the current state of a MPT adapter.
2528  *      @ioc: Pointer to MPT_ADAPTER structure
2529  *      @cooked: Request raw or cooked IOC state
2530  *
2531  *      Returns all IOC Doorbell register bits if cooked==0, else just the
2532  *      Doorbell bits in MPI_IOC_STATE_MASK.
2533  */
2534 u32
2535 mpt_GetIocState(MPT_ADAPTER *ioc, int cooked)
2536 {
2537         u32 s, sc;
2538
2539         /*  Get!  */
2540         s = CHIPREG_READ32(&ioc->chip->Doorbell);
2541 //      dprintk((MYIOC_s_INFO_FMT "raw state = %08x\n", ioc->name, s));
2542         sc = s & MPI_IOC_STATE_MASK;
2543
2544         /*  Save!  */
2545         ioc->last_state = sc;
2546
2547         return cooked ? sc : s;
2548 }
2549
2550 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2551 /**
2552  *      GetIocFacts - Send IOCFacts request to MPT adapter.
2553  *      @ioc: Pointer to MPT_ADAPTER structure
2554  *      @sleepFlag: Specifies whether the process can sleep
2555  *      @reason: If recovery, only update facts.
2556  *
2557  *      Returns 0 for success, non-zero for failure.
2558  */
2559 static int
2560 GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason)
2561 {
2562         IOCFacts_t               get_facts;
2563         IOCFactsReply_t         *facts;
2564         int                      r;
2565         int                      req_sz;
2566         int                      reply_sz;
2567         int                      sz;
2568         u32                      status, vv;
2569         u8                       shiftFactor=1;
2570
2571         /* IOC *must* NOT be in RESET state! */
2572         if (ioc->last_state == MPI_IOC_STATE_RESET) {
2573                 printk(KERN_ERR MYNAM ": ERROR - Can't get IOCFacts, %s NOT READY! (%08x)\n",
2574                                 ioc->name,
2575                                 ioc->last_state );
2576                 return -44;
2577         }
2578
2579         facts = &ioc->facts;
2580
2581         /* Destination (reply area)... */
2582         reply_sz = sizeof(*facts);
2583         memset(facts, 0, reply_sz);
2584
2585         /* Request area (get_facts on the stack right now!) */
2586         req_sz = sizeof(get_facts);
2587         memset(&get_facts, 0, req_sz);
2588
2589         get_facts.Function = MPI_FUNCTION_IOC_FACTS;
2590         /* Assert: All other get_facts fields are zero! */
2591
2592         dinitprintk((MYIOC_s_INFO_FMT
2593             "Sending get IocFacts request req_sz=%d reply_sz=%d\n",
2594             ioc->name, req_sz, reply_sz));
2595
2596         /* No non-zero fields in the get_facts request are greater than
2597          * 1 byte in size, so we can just fire it off as is.
2598          */
2599         r = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_facts,
2600                         reply_sz, (u16*)facts, 5 /*seconds*/, sleepFlag);
2601         if (r != 0)
2602                 return r;
2603
2604         /*
2605          * Now byte swap (GRRR) the necessary fields before any further
2606          * inspection of reply contents.
2607          *
2608          * But need to do some sanity checks on MsgLength (byte) field
2609          * to make sure we don't zero IOC's req_sz!
2610          */
2611         /* Did we get a valid reply? */
2612         if (facts->MsgLength > offsetof(IOCFactsReply_t, RequestFrameSize)/sizeof(u32)) {
2613                 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2614                         /*
2615                          * If not been here, done that, save off first WhoInit value
2616                          */
2617                         if (ioc->FirstWhoInit == WHOINIT_UNKNOWN)
2618                                 ioc->FirstWhoInit = facts->WhoInit;
2619                 }
2620
2621                 facts->MsgVersion = le16_to_cpu(facts->MsgVersion);
2622                 facts->MsgContext = le32_to_cpu(facts->MsgContext);
2623                 facts->IOCExceptions = le16_to_cpu(facts->IOCExceptions);
2624                 facts->IOCStatus = le16_to_cpu(facts->IOCStatus);
2625                 facts->IOCLogInfo = le32_to_cpu(facts->IOCLogInfo);
2626                 status = le16_to_cpu(facts->IOCStatus) & MPI_IOCSTATUS_MASK;
2627                 /* CHECKME! IOCStatus, IOCLogInfo */
2628
2629                 facts->ReplyQueueDepth = le16_to_cpu(facts->ReplyQueueDepth);
2630                 facts->RequestFrameSize = le16_to_cpu(facts->RequestFrameSize);
2631
2632                 /*
2633                  * FC f/w version changed between 1.1 and 1.2
2634                  *      Old: u16{Major(4),Minor(4),SubMinor(8)}
2635                  *      New: u32{Major(8),Minor(8),Unit(8),Dev(8)}
2636                  */
2637                 if (facts->MsgVersion < 0x0102) {
2638                         /*
2639                          *      Handle old FC f/w style, convert to new...
2640                          */
2641                         u16      oldv = le16_to_cpu(facts->Reserved_0101_FWVersion);
2642                         facts->FWVersion.Word =
2643                                         ((oldv<<12) & 0xFF000000) |
2644                                         ((oldv<<8)  & 0x000FFF00);
2645                 } else
2646                         facts->FWVersion.Word = le32_to_cpu(facts->FWVersion.Word);
2647
2648                 facts->ProductID = le16_to_cpu(facts->ProductID);
2649                 if ((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
2650                     > MPI_FW_HEADER_PID_PROD_TARGET_SCSI)
2651                         ioc->ir_firmware = 1;
2652                 facts->CurrentHostMfaHighAddr =
2653                                 le32_to_cpu(facts->CurrentHostMfaHighAddr);
2654                 facts->GlobalCredits = le16_to_cpu(facts->GlobalCredits);
2655                 facts->CurrentSenseBufferHighAddr =
2656                                 le32_to_cpu(facts->CurrentSenseBufferHighAddr);
2657                 facts->CurReplyFrameSize =
2658                                 le16_to_cpu(facts->CurReplyFrameSize);
2659                 facts->IOCCapabilities = le32_to_cpu(facts->IOCCapabilities);
2660
2661                 /*
2662                  * Handle NEW (!) IOCFactsReply fields in MPI-1.01.xx
2663                  * Older MPI-1.00.xx struct had 13 dwords, and enlarged
2664                  * to 14 in MPI-1.01.0x.
2665                  */
2666                 if (facts->MsgLength >= (offsetof(IOCFactsReply_t,FWImageSize) + 7)/4 &&
2667                     facts->MsgVersion > 0x0100) {
2668                         facts->FWImageSize = le32_to_cpu(facts->FWImageSize);
2669                 }
2670
2671                 sz = facts->FWImageSize;
2672                 if ( sz & 0x01 )
2673                         sz += 1;
2674                 if ( sz & 0x02 )
2675                         sz += 2;
2676                 facts->FWImageSize = sz;
2677
2678                 if (!facts->RequestFrameSize) {
2679                         /*  Something is wrong!  */
2680                         printk(MYIOC_s_ERR_FMT "IOC reported invalid 0 request size!\n",
2681                                         ioc->name);
2682                         return -55;
2683                 }
2684
2685                 r = sz = facts->BlockSize;
2686                 vv = ((63 / (sz * 4)) + 1) & 0x03;
2687                 ioc->NB_for_64_byte_frame = vv;
2688                 while ( sz )
2689                 {
2690                         shiftFactor++;
2691                         sz = sz >> 1;
2692                 }
2693                 ioc->NBShiftFactor  = shiftFactor;
2694                 dinitprintk((MYIOC_s_INFO_FMT "NB_for_64_byte_frame=%x NBShiftFactor=%x BlockSize=%x\n",
2695                                         ioc->name, vv, shiftFactor, r));
2696
2697                 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2698                         /*
2699                          * Set values for this IOC's request & reply frame sizes,
2700                          * and request & reply queue depths...
2701                          */
2702                         ioc->req_sz = min(MPT_DEFAULT_FRAME_SIZE, facts->RequestFrameSize * 4);
2703                         ioc->req_depth = min_t(int, MPT_MAX_REQ_DEPTH, facts->GlobalCredits);
2704                         ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
2705                         ioc->reply_depth = min_t(int, MPT_DEFAULT_REPLY_DEPTH, facts->ReplyQueueDepth);
2706
2707                         dinitprintk((MYIOC_s_INFO_FMT "reply_sz=%3d, reply_depth=%4d\n",
2708                                 ioc->name, ioc->reply_sz, ioc->reply_depth));
2709                         dinitprintk((MYIOC_s_INFO_FMT "req_sz  =%3d, req_depth  =%4d\n",
2710                                 ioc->name, ioc->req_sz, ioc->req_depth));
2711
2712                         /* Get port facts! */
2713                         if ( (r = GetPortFacts(ioc, 0, sleepFlag)) != 0 )
2714                                 return r;
2715                 }
2716         } else {
2717                 printk(MYIOC_s_ERR_FMT
2718                      "Invalid IOC facts reply, msgLength=%d offsetof=%zd!\n",
2719                      ioc->name, facts->MsgLength, (offsetof(IOCFactsReply_t,
2720                      RequestFrameSize)/sizeof(u32)));
2721                 return -66;
2722         }
2723
2724         return 0;
2725 }
2726
2727 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2728 /**
2729  *      GetPortFacts - Send PortFacts request to MPT adapter.
2730  *      @ioc: Pointer to MPT_ADAPTER structure
2731  *      @portnum: Port number
2732  *      @sleepFlag: Specifies whether the process can sleep
2733  *
2734  *      Returns 0 for success, non-zero for failure.
2735  */
2736 static int
2737 GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
2738 {
2739         PortFacts_t              get_pfacts;
2740         PortFactsReply_t        *pfacts;
2741         int                      ii;
2742         int                      req_sz;
2743         int                      reply_sz;
2744         int                      max_id;
2745
2746         /* IOC *must* NOT be in RESET state! */
2747         if (ioc->last_state == MPI_IOC_STATE_RESET) {
2748                 printk(KERN_ERR MYNAM ": ERROR - Can't get PortFacts, %s NOT READY! (%08x)\n",
2749                                 ioc->name,
2750                                 ioc->last_state );
2751                 return -4;
2752         }
2753
2754         pfacts = &ioc->pfacts[portnum];
2755
2756         /* Destination (reply area)...  */
2757         reply_sz = sizeof(*pfacts);
2758         memset(pfacts, 0, reply_sz);
2759
2760         /* Request area (get_pfacts on the stack right now!) */
2761         req_sz = sizeof(get_pfacts);
2762         memset(&get_pfacts, 0, req_sz);
2763
2764         get_pfacts.Function = MPI_FUNCTION_PORT_FACTS;
2765         get_pfacts.PortNumber = portnum;
2766         /* Assert: All other get_pfacts fields are zero! */
2767
2768         dinitprintk((MYIOC_s_INFO_FMT "Sending get PortFacts(%d) request\n",
2769                         ioc->name, portnum));
2770
2771         /* No non-zero fields in the get_pfacts request are greater than
2772          * 1 byte in size, so we can just fire it off as is.
2773          */
2774         ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_pfacts,
2775                                 reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
2776         if (ii != 0)
2777                 return ii;
2778
2779         /* Did we get a valid reply? */
2780
2781         /* Now byte swap the necessary fields in the response. */
2782         pfacts->MsgContext = le32_to_cpu(pfacts->MsgContext);
2783         pfacts->IOCStatus = le16_to_cpu(pfacts->IOCStatus);
2784         pfacts->IOCLogInfo = le32_to_cpu(pfacts->IOCLogInfo);
2785         pfacts->MaxDevices = le16_to_cpu(pfacts->MaxDevices);
2786         pfacts->PortSCSIID = le16_to_cpu(pfacts->PortSCSIID);
2787         pfacts->ProtocolFlags = le16_to_cpu(pfacts->ProtocolFlags);
2788         pfacts->MaxPostedCmdBuffers = le16_to_cpu(pfacts->MaxPostedCmdBuffers);
2789         pfacts->MaxPersistentIDs = le16_to_cpu(pfacts->MaxPersistentIDs);
2790         pfacts->MaxLanBuckets = le16_to_cpu(pfacts->MaxLanBuckets);
2791
2792         max_id = (ioc->bus_type == SAS) ? pfacts->PortSCSIID :
2793             pfacts->MaxDevices;
2794         ioc->devices_per_bus = (max_id > 255) ? 256 : max_id;
2795         ioc->number_of_buses = (ioc->devices_per_bus < 256) ? 1 : max_id/256;
2796
2797         /*
2798          * Place all the devices on channels
2799          *
2800          * (for debuging)
2801          */
2802         if (mpt_channel_mapping) {
2803                 ioc->devices_per_bus = 1;
2804                 ioc->number_of_buses = (max_id > 255) ? 255 : max_id;
2805         }
2806
2807         return 0;
2808 }
2809
2810 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2811 /**
2812  *      SendIocInit - Send IOCInit request to MPT adapter.
2813  *      @ioc: Pointer to MPT_ADAPTER structure
2814  *      @sleepFlag: Specifies whether the process can sleep
2815  *
2816  *      Send IOCInit followed by PortEnable to bring IOC to OPERATIONAL state.
2817  *
2818  *      Returns 0 for success, non-zero for failure.
2819  */
2820 static int
2821 SendIocInit(MPT_ADAPTER *ioc, int sleepFlag)
2822 {
2823         IOCInit_t                ioc_init;
2824         MPIDefaultReply_t        init_reply;
2825         u32                      state;
2826         int                      r;
2827         int                      count;
2828         int                      cntdn;
2829
2830         memset(&ioc_init, 0, sizeof(ioc_init));
2831         memset(&init_reply, 0, sizeof(init_reply));
2832
2833         ioc_init.WhoInit = MPI_WHOINIT_HOST_DRIVER;
2834         ioc_init.Function = MPI_FUNCTION_IOC_INIT;
2835
2836         /* If we are in a recovery mode and we uploaded the FW image,
2837          * then this pointer is not NULL. Skip the upload a second time.
2838          * Set this flag if cached_fw set for either IOC.
2839          */
2840         if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
2841                 ioc->upload_fw = 1;
2842         else
2843                 ioc->upload_fw = 0;
2844         ddlprintk((MYIOC_s_INFO_FMT "upload_fw %d facts.Flags=%x\n",
2845                    ioc->name, ioc->upload_fw, ioc->facts.Flags));
2846
2847         ioc_init.MaxDevices = (U8)ioc->devices_per_bus;
2848         ioc_init.MaxBuses = (U8)ioc->number_of_buses;
2849         dinitprintk((MYIOC_s_INFO_FMT "facts.MsgVersion=%x\n",
2850                    ioc->name, ioc->facts.MsgVersion));
2851         if (ioc->facts.MsgVersion >= MPI_VERSION_01_05) {
2852                 // set MsgVersion and HeaderVersion host driver was built with
2853                 ioc_init.MsgVersion = cpu_to_le16(MPI_VERSION);
2854                 ioc_init.HeaderVersion = cpu_to_le16(MPI_HEADER_VERSION);
2855
2856                 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_HOST_PAGE_BUFFER_PERSISTENT) {
2857                         ioc_init.HostPageBufferSGE = ioc->facts.HostPageBufferSGE;
2858                 } else if(mpt_host_page_alloc(ioc, &ioc_init))
2859                         return -99;
2860         }
2861         ioc_init.ReplyFrameSize = cpu_to_le16(ioc->reply_sz);   /* in BYTES */
2862
2863         if (sizeof(dma_addr_t) == sizeof(u64)) {
2864                 /* Save the upper 32-bits of the request
2865                  * (reply) and sense buffers.
2866                  */
2867                 ioc_init.HostMfaHighAddr = cpu_to_le32((u32)((u64)ioc->alloc_dma >> 32));
2868                 ioc_init.SenseBufferHighAddr = cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2869         } else {
2870                 /* Force 32-bit addressing */
2871                 ioc_init.HostMfaHighAddr = cpu_to_le32(0);
2872                 ioc_init.SenseBufferHighAddr = cpu_to_le32(0);
2873         }
2874
2875         ioc->facts.CurrentHostMfaHighAddr = ioc_init.HostMfaHighAddr;
2876         ioc->facts.CurrentSenseBufferHighAddr = ioc_init.SenseBufferHighAddr;
2877         ioc->facts.MaxDevices = ioc_init.MaxDevices;
2878         ioc->facts.MaxBuses = ioc_init.MaxBuses;
2879
2880         dhsprintk((MYIOC_s_INFO_FMT "Sending IOCInit (req @ %p)\n",
2881                         ioc->name, &ioc_init));
2882
2883         r = mpt_handshake_req_reply_wait(ioc, sizeof(IOCInit_t), (u32*)&ioc_init,
2884                                 sizeof(MPIDefaultReply_t), (u16*)&init_reply, 10 /*seconds*/, sleepFlag);
2885         if (r != 0) {
2886                 printk(MYIOC_s_ERR_FMT "Sending IOCInit failed(%d)!\n",ioc->name, r);
2887                 return r;
2888         }
2889
2890         /* No need to byte swap the multibyte fields in the reply
2891          * since we don't even look at its contents.
2892          */
2893
2894         dhsprintk((MYIOC_s_INFO_FMT "Sending PortEnable (req @ %p)\n",
2895                         ioc->name, &ioc_init));
2896
2897         if ((r = SendPortEnable(ioc, 0, sleepFlag)) != 0) {
2898                 printk(MYIOC_s_ERR_FMT "Sending PortEnable failed(%d)!\n",ioc->name, r);
2899                 return r;
2900         }
2901
2902         /* YIKES!  SUPER IMPORTANT!!!
2903          *  Poll IocState until _OPERATIONAL while IOC is doing
2904          *  LoopInit and TargetDiscovery!
2905          */
2906         count = 0;
2907         cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 60;    /* 60 seconds */
2908         state = mpt_GetIocState(ioc, 1);
2909         while (state != MPI_IOC_STATE_OPERATIONAL && --cntdn) {
2910                 if (sleepFlag == CAN_SLEEP) {
2911                         msleep(1);
2912                 } else {
2913                         mdelay(1);
2914                 }
2915
2916                 if (!cntdn) {
2917                         printk(MYIOC_s_ERR_FMT "Wait IOC_OP state timeout(%d)!\n",
2918                                         ioc->name, (int)((count+5)/HZ));
2919                         return -9;
2920                 }
2921
2922                 state = mpt_GetIocState(ioc, 1);
2923                 count++;
2924         }
2925         dinitprintk((MYIOC_s_INFO_FMT "INFO - Wait IOC_OPERATIONAL state (cnt=%d)\n",
2926                         ioc->name, count));
2927
2928         ioc->aen_event_read_flag=0;
2929         return r;
2930 }
2931
2932 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2933 /**
2934  *      SendPortEnable - Send PortEnable request to MPT adapter port.
2935  *      @ioc: Pointer to MPT_ADAPTER structure
2936  *      @portnum: Port number to enable
2937  *      @sleepFlag: Specifies whether the process can sleep
2938  *
2939  *      Send PortEnable to bring IOC to OPERATIONAL state.
2940  *
2941  *      Returns 0 for success, non-zero for failure.
2942  */
2943 static int
2944 SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
2945 {
2946         PortEnable_t             port_enable;
2947         MPIDefaultReply_t        reply_buf;
2948         int      rc;
2949         int      req_sz;
2950         int      reply_sz;
2951
2952         /*  Destination...  */
2953         reply_sz = sizeof(MPIDefaultReply_t);
2954         memset(&reply_buf, 0, reply_sz);
2955
2956         req_sz = sizeof(PortEnable_t);
2957         memset(&port_enable, 0, req_sz);
2958
2959         port_enable.Function = MPI_FUNCTION_PORT_ENABLE;
2960         port_enable.PortNumber = portnum;
2961 /*      port_enable.ChainOffset = 0;            */
2962 /*      port_enable.MsgFlags = 0;               */
2963 /*      port_enable.MsgContext = 0;             */
2964
2965         dinitprintk((MYIOC_s_INFO_FMT "Sending Port(%d)Enable (req @ %p)\n",
2966                         ioc->name, portnum, &port_enable));
2967
2968         /* RAID FW may take a long time to enable
2969          */
2970         if (ioc->ir_firmware || ioc->bus_type == SAS) {
2971                 rc = mpt_handshake_req_reply_wait(ioc, req_sz,
2972                 (u32*)&port_enable, reply_sz, (u16*)&reply_buf,
2973                 300 /*seconds*/, sleepFlag);
2974         } else {
2975                 rc = mpt_handshake_req_reply_wait(ioc, req_sz,
2976                 (u32*)&port_enable, reply_sz, (u16*)&reply_buf,
2977                 30 /*seconds*/, sleepFlag);
2978         }
2979         return rc;
2980 }
2981
2982 /**
2983  *      mpt_alloc_fw_memory - allocate firmware memory
2984  *      @ioc: Pointer to MPT_ADAPTER structure
2985  *      @size: total FW bytes
2986  *
2987  *      If memory has already been allocated, the same (cached) value
2988  *      is returned.
2989  */
2990 void
2991 mpt_alloc_fw_memory(MPT_ADAPTER *ioc, int size)
2992 {
2993         if (ioc->cached_fw)
2994                 return;  /* use already allocated memory */
2995         if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
2996                 ioc->cached_fw = ioc->alt_ioc->cached_fw;  /* use alt_ioc's memory */
2997                 ioc->cached_fw_dma = ioc->alt_ioc->cached_fw_dma;
2998                 ioc->alloc_total += size;
2999                 ioc->alt_ioc->alloc_total -= size;
3000         } else {
3001                 if ( (ioc->cached_fw = pci_alloc_consistent(ioc->pcidev, size, &ioc->cached_fw_dma) ) )
3002                         ioc->alloc_total += size;
3003         }
3004 }
3005 /**
3006  *      mpt_free_fw_memory - free firmware memory
3007  *      @ioc: Pointer to MPT_ADAPTER structure
3008  *
3009  *      If alt_img is NULL, delete from ioc structure.
3010  *      Else, delete a secondary image in same format.
3011  */
3012 void
3013 mpt_free_fw_memory(MPT_ADAPTER *ioc)
3014 {
3015         int sz;
3016
3017         sz = ioc->facts.FWImageSize;
3018         dinitprintk((KERN_INFO MYNAM "free_fw_memory: FW Image  @ %p[%p], sz=%d[%x] bytes\n",
3019                  ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
3020         pci_free_consistent(ioc->pcidev, sz,
3021                         ioc->cached_fw, ioc->cached_fw_dma);
3022         ioc->cached_fw = NULL;
3023
3024         return;
3025 }
3026
3027
3028 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3029 /**
3030  *      mpt_do_upload - Construct and Send FWUpload request to MPT adapter port.
3031  *      @ioc: Pointer to MPT_ADAPTER structure
3032  *      @sleepFlag: Specifies whether the process can sleep
3033  *
3034  *      Returns 0 for success, >0 for handshake failure
3035  *              <0 for fw upload failure.
3036  *
3037  *      Remark: If bound IOC and a successful FWUpload was performed
3038  *      on the bound IOC, the second image is discarded
3039  *      and memory is free'd. Both channels must upload to prevent
3040  *      IOC from running in degraded mode.
3041  */
3042 static int
3043 mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag)
3044 {
3045         u8                       request[ioc->req_sz];
3046         u8                       reply[sizeof(FWUploadReply_t)];
3047         FWUpload_t              *prequest;
3048         FWUploadReply_t         *preply;
3049         FWUploadTCSGE_t         *ptcsge;
3050         int                      sgeoffset;
3051         u32                      flagsLength;
3052         int                      ii, sz, reply_sz;
3053         int                      cmdStatus;
3054
3055         /* If the image size is 0, we are done.
3056          */
3057         if ((sz = ioc->facts.FWImageSize) == 0)
3058                 return 0;
3059
3060         mpt_alloc_fw_memory(ioc, sz);
3061
3062         dinitprintk((KERN_INFO MYNAM ": FW Image  @ %p[%p], sz=%d[%x] bytes\n",
3063                  ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
3064
3065         if (ioc->cached_fw == NULL) {
3066                 /* Major Failure.
3067                  */
3068                 return -ENOMEM;
3069         }
3070
3071         prequest = (FWUpload_t *)&request;
3072         preply = (FWUploadReply_t *)&reply;
3073
3074         /*  Destination...  */
3075         memset(prequest, 0, ioc->req_sz);
3076
3077         reply_sz = sizeof(reply);
3078         memset(preply, 0, reply_sz);
3079
3080         prequest->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
3081         prequest->Function = MPI_FUNCTION_FW_UPLOAD;
3082
3083         ptcsge = (FWUploadTCSGE_t *) &prequest->SGL;
3084         ptcsge->DetailsLength = 12;
3085         ptcsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
3086         ptcsge->ImageSize = cpu_to_le32(sz);
3087
3088         sgeoffset = sizeof(FWUpload_t) - sizeof(SGE_MPI_UNION) + sizeof(FWUploadTCSGE_t);
3089
3090         flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | sz;
3091         mpt_add_sge(&request[sgeoffset], flagsLength, ioc->cached_fw_dma);
3092
3093         sgeoffset += sizeof(u32) + sizeof(dma_addr_t);
3094         dinitprintk((KERN_INFO MYNAM ": Sending FW Upload (req @ %p) sgeoffset=%d \n",
3095                         prequest, sgeoffset));
3096         DBG_DUMP_FW_REQUEST_FRAME(prequest)
3097
3098         ii = mpt_handshake_req_reply_wait(ioc, sgeoffset, (u32*)prequest,
3099                                 reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);
3100
3101         dinitprintk((KERN_INFO MYNAM ": FW Upload completed rc=%x \n", ii));
3102
3103         cmdStatus = -EFAULT;
3104         if (ii == 0) {
3105                 /* Handshake transfer was complete and successful.
3106                  * Check the Reply Frame.
3107                  */
3108                 int status, transfer_sz;
3109                 status = le16_to_cpu(preply->IOCStatus);
3110                 if (status == MPI_IOCSTATUS_SUCCESS) {
3111                         transfer_sz = le32_to_cpu(preply->ActualImageSize);
3112                         if (transfer_sz == sz)
3113                                 cmdStatus = 0;
3114                 }
3115         }
3116         dinitprintk((MYIOC_s_INFO_FMT ": do_upload cmdStatus=%d \n",
3117                         ioc->name, cmdStatus));
3118