sys/dev/raid/mrsas/mrsas.c

   1 /*
   2  * Copyright (c) 2014, LSI Corp.
   3  * All rights reserved.
   4  * Author: Marian Choy
   5  * Support: freebsdraid@lsi.com
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of the <ORGANIZATION> nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  * The views and conclusions contained in the software and documentation
  35  * are those of the authors and should not be interpreted as representing
  36  * official policies,either expressed or implied, of the FreeBSD Project.
  37  *
  38  * Send feedback to: <megaraidfbsd@lsi.com>
  39  * Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
  40  *    ATTN: MegaRaid FreeBSD
  41  *
  42  * $FreeBSD: head/sys/dev/mrsas/mrsas.c 265555 2014-05-07 16:16:49Z ambrisko $
  43  */
  44
  45 #include <dev/raid/mrsas/mrsas.h>
  46 #include <dev/raid/mrsas/mrsas_ioctl.h>
  47
  48 #include <bus/cam/cam.h>
  49 #include <bus/cam/cam_ccb.h>
  50
  51 #include <sys/sysctl.h>
  52 #include <sys/types.h>
  53 #include <sys/kthread.h>
  54 #include <sys/taskqueue.h>
  55 #include <sys/device.h>
  56 #include <sys/spinlock2.h>
  57
  58
  59 /*
  60  * Function prototypes
  61  */
  62 static d_open_t     mrsas_open;
  63 static d_close_t    mrsas_close;
  64 static d_read_t     mrsas_read;
  65 static d_write_t    mrsas_write;
  66 static d_ioctl_t    mrsas_ioctl;
  67
  68 static struct mrsas_ident *mrsas_find_ident(device_t);
  69 static void mrsas_shutdown_ctlr(struct mrsas_softc *sc, u_int32_t opcode);
  70 static void mrsas_flush_cache(struct mrsas_softc *sc);
  71 static void mrsas_reset_reply_desc(struct mrsas_softc *sc);
  72 static void mrsas_ocr_thread(void *arg);
  73 static int mrsas_get_map_info(struct mrsas_softc *sc);
  74 static int mrsas_get_ld_map_info(struct mrsas_softc *sc);
  75 static int mrsas_sync_map_info(struct mrsas_softc *sc);
  76 static int mrsas_get_pd_list(struct mrsas_softc *sc);
  77 static int mrsas_get_ld_list(struct mrsas_softc *sc);
  78 static int mrsas_setup_irq(struct mrsas_softc *sc);
  79 static int mrsas_alloc_mem(struct mrsas_softc *sc);
  80 static int mrsas_init_fw(struct mrsas_softc *sc);
  81 static int mrsas_setup_raidmap(struct mrsas_softc *sc);
  82 static int mrsas_complete_cmd(struct mrsas_softc *sc);
  83 static int mrsas_clear_intr(struct mrsas_softc *sc);
  84 static int mrsas_get_ctrl_info(struct mrsas_softc *sc,
  85                           struct mrsas_ctrl_info *ctrl_info);
  86 static int mrsas_issue_blocked_abort_cmd(struct mrsas_softc *sc,
  87                          struct mrsas_mfi_cmd *cmd_to_abort);
  88 u_int32_t mrsas_read_reg(struct mrsas_softc *sc, int offset);
  89 u_int8_t mrsas_build_mptmfi_passthru(struct mrsas_softc *sc,
  90                          struct mrsas_mfi_cmd *mfi_cmd);
  91 int mrsas_transition_to_ready(struct mrsas_softc *sc, int ocr);
  92 int mrsas_init_adapter(struct mrsas_softc *sc);
  93 int mrsas_alloc_mpt_cmds(struct mrsas_softc *sc);
  94 int mrsas_alloc_ioc_cmd(struct mrsas_softc *sc);
  95 int mrsas_alloc_ctlr_info_cmd(struct mrsas_softc *sc);
  96 int mrsas_ioc_init(struct mrsas_softc *sc);
  97 int mrsas_bus_scan(struct mrsas_softc *sc);
  98 int mrsas_issue_dcmd(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd);
  99 int mrsas_issue_polled(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd);
 100 int mrsas_reset_ctrl(struct mrsas_softc *sc);
 101 int mrsas_wait_for_outstanding(struct mrsas_softc *sc);
 102 int mrsas_issue_blocked_cmd(struct mrsas_softc *sc,
 103                           struct mrsas_mfi_cmd *cmd);
 104 int mrsas_alloc_tmp_dcmd(struct mrsas_softc *sc, struct mrsas_tmp_dcmd *tcmd,
 105                           int size);
 106 void mrsas_release_mfi_cmd(struct mrsas_mfi_cmd *cmd);
 107 void mrsas_wakeup(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd);
 108 void mrsas_complete_aen(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd);
 109 void mrsas_complete_abort(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd);
 110 void mrsas_disable_intr(struct mrsas_softc *sc);
 111 void mrsas_enable_intr(struct mrsas_softc *sc);
 112 void mrsas_free_ioc_cmd(struct mrsas_softc *sc);
 113 void mrsas_free_mem(struct mrsas_softc *sc);
 114 void mrsas_free_tmp_dcmd(struct mrsas_tmp_dcmd *tmp);
 115 void mrsas_isr(void *arg);
 116 void mrsas_teardown_intr(struct mrsas_softc *sc);
 117 void mrsas_addr_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error);
 118 void mrsas_kill_hba (struct mrsas_softc *sc);
 119 void mrsas_aen_handler(struct mrsas_softc *sc);
 120 void mrsas_write_reg(struct mrsas_softc *sc, int offset,
 121                           u_int32_t value);
 122 void mrsas_fire_cmd(struct mrsas_softc *sc, u_int32_t req_desc_lo,
 123                           u_int32_t req_desc_hi);
 124 void mrsas_free_ctlr_info_cmd(struct mrsas_softc *sc);
 125 void mrsas_complete_mptmfi_passthru(struct mrsas_softc *sc,
 126                           struct mrsas_mfi_cmd *cmd, u_int8_t status);
 127 void mrsas_map_mpt_cmd_status(struct mrsas_mpt_cmd *cmd, u_int8_t status,
 128                           u_int8_t extStatus);
 129 struct mrsas_mfi_cmd* mrsas_get_mfi_cmd(struct mrsas_softc *sc);
 130 MRSAS_REQUEST_DESCRIPTOR_UNION * mrsas_build_mpt_cmd(struct mrsas_softc *sc,
 131                           struct mrsas_mfi_cmd *cmd);
 132
 133 extern int mrsas_cam_attach(struct mrsas_softc *sc);
 134 extern void mrsas_cam_detach(struct mrsas_softc *sc);
 135 extern void mrsas_cmd_done(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd);
 136 extern void mrsas_free_frame(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd);
 137 extern int mrsas_alloc_mfi_cmds(struct mrsas_softc *sc);
 138 extern void mrsas_release_mpt_cmd(struct mrsas_mpt_cmd *cmd);
 139 extern struct mrsas_mpt_cmd *mrsas_get_mpt_cmd(struct mrsas_softc *sc);
 140 extern int mrsas_passthru(struct mrsas_softc *sc, void *arg);
 141 extern uint8_t MR_ValidateMapInfo(struct mrsas_softc *sc);
 142 extern u_int16_t MR_GetLDTgtId(u_int32_t ld, MR_FW_RAID_MAP_ALL *map);
 143 extern MR_LD_RAID *MR_LdRaidGet(u_int32_t ld, MR_FW_RAID_MAP_ALL *map);
 144 extern void mrsas_xpt_freeze(struct mrsas_softc *sc);
 145 extern void mrsas_xpt_release(struct mrsas_softc *sc);
 146 extern MRSAS_REQUEST_DESCRIPTOR_UNION *mrsas_get_request_desc(struct mrsas_softc *sc,
 147                          u_int16_t index);
 148 extern int mrsas_bus_scan_sim(struct mrsas_softc *sc, struct cam_sim *sim);
 149 static int mrsas_alloc_evt_log_info_cmd(struct mrsas_softc *sc);
 150 static void mrsas_free_evt_log_info_cmd(struct mrsas_softc *sc);
 151 SYSCTL_NODE(_hw, OID_AUTO, mrsas, CTLFLAG_RD, 0, "MRSAS Driver Parameters");
 152
 153
 154 /**
 155  * PCI device struct and table
 156  *
 157  */
 158 typedef struct mrsas_ident {
 159     uint16_t    vendor;
 160     uint16_t    device;
 161     uint16_t    subvendor;
 162     uint16_t    subdevice;
 163     const char  *desc;
 164 } MRSAS_CTLR_ID;
 165
 166 MRSAS_CTLR_ID device_table[] = {
 167     {0x1000, MRSAS_TBOLT, 0xffff, 0xffff, "LSI Thunderbolt SAS Controller"},
 168     {0x1000, MRSAS_INVADER, 0xffff, 0xffff, "LSI Invader SAS Controller"},
 169     {0x1000, MRSAS_FURY, 0xffff, 0xffff, "LSI Fury SAS Controller"},
 170     {0, 0, 0, 0, NULL}
 171 };
 172
 173 /**
 174  * Character device entry points
 175  *
 176  */
 177 static struct dev_ops mrsas_ops = {
 178     { "mrsas", 0, D_MPSAFE },
 179     .d_open =   mrsas_open,
 180     .d_close =  mrsas_close,
 181     .d_read =   mrsas_read,
 182     .d_write =  mrsas_write,
 183     .d_ioctl =  mrsas_ioctl,
 184 };
 185
 186 MALLOC_DEFINE(M_MRSAS, "mrsasbuf", "Buffers for the MRSAS driver");
 187
 188 static int      mrsas_mfi_enable = 0;
 189 TUNABLE_INT("hw.mrsas.mfi_enable", &mrsas_mfi_enable);
 190
 191 static int      mrsas_msi_enable = 1;
 192 TUNABLE_INT("hw.mrsas.msi.enable", &mrsas_msi_enable);
 193
 194 /**
 195  * In the cdevsw routines, we find our softc by using the si_drv1 member
 196  * of struct cdev.  We set this variable to point to our softc in our
 197  * attach routine when we create the /dev entry.
 198  */
 199 int
 200 mrsas_open(struct dev_open_args *ap)
 201 {
 202     cdev_t dev = ap->a_head.a_dev;
 203     struct mrsas_softc *sc;
 204
 205     sc = dev->si_drv1;
 206     return (0);
 207 }
 208
 209 int
 210 mrsas_close(struct dev_close_args *ap)
 211 {
 212     cdev_t dev = ap->a_head.a_dev;
 213     struct mrsas_softc *sc;
 214
 215     sc = dev->si_drv1;
 216     return (0);
 217 }
 218
 219 int
 220 mrsas_read(struct dev_read_args *ap)
 221 {
 222     cdev_t dev = ap->a_head.a_dev;
 223     struct mrsas_softc *sc;
 224
 225     sc = dev->si_drv1;
 226     return (0);
 227 }
 228 int
 229 mrsas_write(struct dev_write_args *ap)
 230 {
 231     cdev_t dev = ap->a_head.a_dev;
 232     struct mrsas_softc *sc;
 233
 234     sc = dev->si_drv1;
 235     return (0);
 236 }
 237
 238 /**
 239  * Register Read/Write Functions
 240  *
 241  */
 242 void
 243 mrsas_write_reg(struct mrsas_softc *sc, int offset,
 244                   u_int32_t value)
 245 {
 246     bus_space_tag_t         bus_tag = sc->bus_tag;
 247     bus_space_handle_t      bus_handle = sc->bus_handle;
 248
 249     bus_space_write_4(bus_tag, bus_handle, offset, value);
 250 }
 251
 252 u_int32_t
 253 mrsas_read_reg(struct mrsas_softc *sc, int offset)
 254 {
 255     bus_space_tag_t bus_tag = sc->bus_tag;
 256     bus_space_handle_t bus_handle = sc->bus_handle;
 257
 258     return((u_int32_t)bus_space_read_4(bus_tag, bus_handle, offset));
 259 }
 260
 261
 262 /**
 263  * Interrupt Disable/Enable/Clear Functions
 264  *
 265  */
 266 void mrsas_disable_intr(struct mrsas_softc *sc)
 267 {
 268     u_int32_t mask = 0xFFFFFFFF;
 269     u_int32_t status;
 270
 271     mrsas_write_reg(sc, offsetof(mrsas_reg_set, outbound_intr_mask), mask);
 272     /* Dummy read to force pci flush */
 273     status = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_intr_mask));
 274 }
 275
 276 void mrsas_enable_intr(struct mrsas_softc *sc)
 277 {
 278     u_int32_t mask = MFI_FUSION_ENABLE_INTERRUPT_MASK;
 279     u_int32_t status;
 280
 281     mrsas_write_reg(sc, offsetof(mrsas_reg_set, outbound_intr_status), ~0);
 282     status = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_intr_status));
 283
 284     mrsas_write_reg(sc, offsetof(mrsas_reg_set, outbound_intr_mask), ~mask);
 285     status = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_intr_mask));
 286 }
 287
 288 static int mrsas_clear_intr(struct mrsas_softc *sc)
 289 {
 290     u_int32_t status, fw_status, fw_state;
 291
 292     /* Read received interrupt */
 293     status = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_intr_status));
 294
 295     /* If FW state change interrupt is received, write to it again to clear */
 296     if (status & MRSAS_FW_STATE_CHNG_INTERRUPT) {
 297         fw_status = mrsas_read_reg(sc, offsetof(mrsas_reg_set,
 298                                    outbound_scratch_pad));
 299         fw_state = fw_status & MFI_STATE_MASK;
 300         if (fw_state == MFI_STATE_FAULT) {
 301             device_printf(sc->mrsas_dev, "FW is in FAULT state!\n");
 302             if(sc->ocr_thread_active)
 303                 wakeup(&sc->ocr_chan);
 304         }
 305         mrsas_write_reg(sc, offsetof(mrsas_reg_set, outbound_intr_status), status);
 306         mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_intr_status));
 307         return(1);
 308     }
 309
 310     /* Not our interrupt, so just return */
 311     if (!(status & MFI_FUSION_ENABLE_INTERRUPT_MASK))
 312         return(0);
 313
 314     /* We got a reply interrupt */
 315     return(1);
 316 }
 317
 318 /**
 319  * PCI Support Functions
 320  *
 321  */
 322 static struct mrsas_ident * mrsas_find_ident(device_t dev)
 323 {
 324     struct mrsas_ident *pci_device;
 325
 326     for (pci_device=device_table; pci_device->vendor != 0; pci_device++)
 327     {
 328         if ((pci_device->vendor == pci_get_vendor(dev)) &&
 329             (pci_device->device == pci_get_device(dev)) &&
 330             ((pci_device->subvendor == pci_get_subvendor(dev)) ||
 331             (pci_device->subvendor == 0xffff)) &&
 332             ((pci_device->subdevice == pci_get_subdevice(dev)) ||
 333             (pci_device->subdevice == 0xffff)))
 334         return (pci_device);
 335     }
 336     return (NULL);
 337 }
 338
 339 static int mrsas_probe(device_t dev)
 340 {
 341     static u_int8_t first_ctrl = 1;
 342     struct mrsas_ident *id;
 343
 344     if ((id = mrsas_find_ident(dev)) != NULL) {
 345         /* give priority to mfi(4) if tunable set */
 346         TUNABLE_INT_FETCH("hw.mrsas.mfi_enable", &mrsas_mfi_enable);
 347         if ((id->device == MRSAS_TBOLT) && mrsas_mfi_enable) {
 348             return (ENXIO);
 349         } else {
 350             if (first_ctrl) {
 351                 kprintf("LSI MegaRAID SAS FreeBSD mrsas driver version: %s\n",
 352                     MRSAS_VERSION);
 353                 first_ctrl = 0;
 354             }
 355             device_set_desc(dev, id->desc);
 356             return (BUS_PROBE_DEFAULT);
 357         }
 358     }
 359     return (ENXIO);
 360 }
 361
 362 /**
 363  * mrsas_setup_sysctl:  setup sysctl values for mrsas
 364  * input:               Adapter instance soft state
 365  *
 366  * Setup sysctl entries for mrsas driver.
 367  */
 368 static void
 369 mrsas_setup_sysctl(struct mrsas_softc *sc)
 370 {
 371     struct sysctl_ctx_list  *sysctl_ctx = NULL;
 372     struct sysctl_oid       *sysctl_tree = NULL;
 373     char tmpstr[80], tmpstr2[80];
 374
 375     /*
 376      * Setup the sysctl variable so the user can change the debug level
 377      * on the fly.
 378      */
 379     ksnprintf(tmpstr, sizeof(tmpstr), "MRSAS controller %d",
 380         device_get_unit(sc->mrsas_dev));
 381     ksnprintf(tmpstr2, sizeof(tmpstr2), "mrsas%d", device_get_unit(sc->mrsas_dev));
 382
 383     sysctl_ctx = device_get_sysctl_ctx(sc->mrsas_dev);
 384     if (sysctl_ctx != NULL)
 385         sysctl_tree = device_get_sysctl_tree(sc->mrsas_dev);
 386
 387     if (sysctl_tree == NULL) {
 388         sysctl_ctx_init(&sc->sysctl_ctx);
 389         sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
 390             SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO, tmpstr2,
 391             CTLFLAG_RD, 0, tmpstr);
 392         if (sc->sysctl_tree == NULL)
 393              return;
 394         sysctl_ctx = &sc->sysctl_ctx;
 395         sysctl_tree = sc->sysctl_tree;
 396     }
 397     SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 398         OID_AUTO, "disable_ocr", CTLFLAG_RW, &sc->disableOnlineCtrlReset, 0,
 399         "Disable the use of OCR");
 400
 401     SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 402         OID_AUTO, "driver_version", CTLFLAG_RD, MRSAS_VERSION,
 403         strlen(MRSAS_VERSION), "driver version");
 404
 405     SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 406         OID_AUTO, "reset_count", CTLFLAG_RD,
 407         &sc->reset_count, 0, "number of ocr from start of the day");
 408
 409     SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 410         OID_AUTO, "fw_outstanding", CTLFLAG_RD,
 411         &sc->fw_outstanding, 0, "FW outstanding commands");
 412
 413         SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 414         OID_AUTO, "io_cmds_highwater", CTLFLAG_RD,
 415         &sc->io_cmds_highwater, 0, "Max FW outstanding commands");
 416
 417     SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 418         OID_AUTO, "mrsas_debug", CTLFLAG_RW, &sc->mrsas_debug, 0,
 419         "Driver debug level");
 420
 421     SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 422         OID_AUTO, "mrsas_io_timeout", CTLFLAG_RW, &sc->mrsas_io_timeout,
 423         0, "Driver IO timeout value in mili-second.");
 424
 425     SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 426         OID_AUTO, "mrsas_fw_fault_check_delay", CTLFLAG_RW,
 427         &sc->mrsas_fw_fault_check_delay,
 428         0, "FW fault check thread delay in seconds. <default is 1 sec>");
 429
 430     SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
 431         OID_AUTO, "reset_in_progress", CTLFLAG_RD,
 432         &sc->reset_in_progress, 0, "ocr in progress status");
 433
 434 }
 435
 436 /**
 437  * mrsas_get_tunables:  get tunable parameters.
 438  * input:               Adapter instance soft state
 439  *
 440  * Get tunable parameters. This will help to debug driver at boot time.
 441  */
 442 static void
 443 mrsas_get_tunables(struct mrsas_softc *sc)
 444 {
 445     char tmpstr[80];
 446
 447     /* XXX default to some debugging for now */
 448     sc->mrsas_debug = MRSAS_FAULT;
 449     sc->mrsas_io_timeout = MRSAS_IO_TIMEOUT;
 450     sc->mrsas_fw_fault_check_delay = 1;
 451     sc->reset_count = 0;
 452     sc->reset_in_progress = 0;
 453
 454     /*
 455      * Grab the global variables.
 456      */
 457     TUNABLE_INT_FETCH("hw.mrsas.debug_level", &sc->mrsas_debug);
 458
 459     /* Grab the unit-instance variables */
 460     ksnprintf(tmpstr, sizeof(tmpstr), "dev.mrsas.%d.debug_level",
 461         device_get_unit(sc->mrsas_dev));
 462     TUNABLE_INT_FETCH(tmpstr, &sc->mrsas_debug);
 463 }
 464
 465 /**
 466  * mrsas_alloc_evt_log_info cmd:        Allocates memory to get event log information.
 467  *                                                                      Used to get sequence number at driver load time.
 468  * input:                               Adapter soft state
 469  *
 470  * Allocates DMAable memory for the event log info internal command.
 471  */
 472 int mrsas_alloc_evt_log_info_cmd(struct mrsas_softc *sc)
 473 {
 474     int el_info_size;
 475
 476     /* Allocate get event log info command */
 477     el_info_size = sizeof(struct mrsas_evt_log_info);
 478     if (bus_dma_tag_create( sc->mrsas_parent_tag,   // parent
 479                             1, 0,                   // algnmnt, boundary
 480                             BUS_SPACE_MAXADDR_32BIT,// lowaddr
 481                             BUS_SPACE_MAXADDR,      // highaddr
 482                             NULL, NULL,             // filter, filterarg
 483                             el_info_size,          // maxsize
 484                             1,                      // msegments
 485                             el_info_size,          // maxsegsize
 486                             BUS_DMA_ALLOCNOW,       // flags
 487                             &sc->el_info_tag)) {
 488         device_printf(sc->mrsas_dev, "Cannot allocate event log info tag\n");
 489         return (ENOMEM);
 490     }
 491     if (bus_dmamem_alloc(sc->el_info_tag, (void **)&sc->el_info_mem,
 492             BUS_DMA_NOWAIT, &sc->el_info_dmamap)) {
 493         device_printf(sc->mrsas_dev, "Cannot allocate event log info cmd mem\n");
 494         return (ENOMEM);
 495     }
 496     if (bus_dmamap_load(sc->el_info_tag, sc->el_info_dmamap,
 497             sc->el_info_mem, el_info_size, mrsas_addr_cb,
 498             &sc->el_info_phys_addr, BUS_DMA_NOWAIT)) {
 499         device_printf(sc->mrsas_dev, "Cannot load event log info cmd mem\n");
 500         return (ENOMEM);
 501     }
 502
 503     memset(sc->el_info_mem, 0, el_info_size);
 504     return (0);
 505 }
 506
 507 /**
 508  * mrsas_free_evt_info_cmd:     Free memory for Event log info command
 509  * input:                       Adapter soft state
 510  *
 511  * Deallocates memory for the event log info internal command.
 512  */
 513 void mrsas_free_evt_log_info_cmd(struct mrsas_softc *sc)
 514 {
 515     if (sc->el_info_phys_addr)
 516         bus_dmamap_unload(sc->el_info_tag, sc->el_info_dmamap);
 517     if (sc->el_info_mem != NULL)
 518         bus_dmamem_free(sc->el_info_tag, sc->el_info_mem, sc->el_info_dmamap);
 519     if (sc->el_info_tag != NULL)
 520         bus_dma_tag_destroy(sc->el_info_tag);
 521 }
 522
 523 /**
 524  *  mrsas_get_seq_num:  Get latest event sequence number
 525  *  @sc:                                Adapter soft state
 526  *  @eli:                               Firmware event log sequence number information.
 527  *                                              Firmware maintains a log of all events in a non-volatile area.
 528  *                                              Driver get the sequence number using DCMD
 529  *                                              "MR_DCMD_CTRL_EVENT_GET_INFO" at driver load time.
 530  */
 531
 532 static int
 533 mrsas_get_seq_num(struct mrsas_softc *sc,
 534                     struct mrsas_evt_log_info *eli)
 535 {
 536         struct mrsas_mfi_cmd *cmd;
 537         struct mrsas_dcmd_frame *dcmd;
 538
 539         cmd =  mrsas_get_mfi_cmd(sc);
 540
 541         if (!cmd) {
 542                 device_printf(sc->mrsas_dev, "Failed to get a free cmd\n");
 543                 return -ENOMEM;
 544         }
 545
 546         dcmd = &cmd->frame->dcmd;
 547
 548         if (mrsas_alloc_evt_log_info_cmd(sc) != SUCCESS) {
 549                 device_printf(sc->mrsas_dev, "Cannot allocate evt log info cmd\n");
 550                 mrsas_release_mfi_cmd(cmd);
 551                 return -ENOMEM;
 552         }
 553
 554         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
 555
 556         dcmd->cmd = MFI_CMD_DCMD;
 557         dcmd->cmd_status = 0x0;
 558         dcmd->sge_count = 1;
 559         dcmd->flags = MFI_FRAME_DIR_READ;
 560         dcmd->timeout = 0;
 561         dcmd->pad_0 = 0;
 562         dcmd->data_xfer_len = sizeof(struct mrsas_evt_log_info);
 563         dcmd->opcode = MR_DCMD_CTRL_EVENT_GET_INFO;
 564         dcmd->sgl.sge32[0].phys_addr = sc->el_info_phys_addr;
 565         dcmd->sgl.sge32[0].length = sizeof(struct mrsas_evt_log_info);
 566
 567         mrsas_issue_blocked_cmd(sc, cmd);
 568
 569         /*
 570          * Copy the data back into callers buffer
 571          */
 572         memcpy(eli, sc->el_info_mem, sizeof(struct mrsas_evt_log_info));
 573         mrsas_free_evt_log_info_cmd(sc);
 574         mrsas_release_mfi_cmd(cmd);
 575
 576         return 0;
 577 }
 578
 579
 580 /**
 581  *  mrsas_register_aen:         Register for asynchronous event notification
 582  *  @sc:                                        Adapter soft state
 583  *  @seq_num:                           Starting sequence number
 584  *  @class_locale:                      Class of the event
 585  *                                              This function subscribes for events beyond the @seq_num
 586  *                                              and type @class_locale.
 587  *
 588  * */
 589 static int
 590 mrsas_register_aen(struct mrsas_softc *sc, u_int32_t seq_num,
 591                      u_int32_t class_locale_word)
 592 {
 593         int ret_val;
 594         struct mrsas_mfi_cmd *cmd;
 595         struct mrsas_dcmd_frame *dcmd;
 596         union mrsas_evt_class_locale curr_aen;
 597         union mrsas_evt_class_locale prev_aen;
 598
 599 /*
 600  *  If there an AEN pending already (aen_cmd), check if the
 601  *  class_locale of that pending AEN is inclusive of the new
 602  *  AEN request we currently have. If it is, then we don't have
 603  *  to do anything. In other words, whichever events the current
 604  *  AEN request is subscribing to, have already been subscribed
 605  *  to.
 606  *  If the old_cmd is _not_ inclusive, then we have to abort
 607  *  that command, form a class_locale that is superset of both
 608  *  old and current and re-issue to the FW
 609  * */
 610
 611         curr_aen.word = class_locale_word;
 612
 613         if (sc->aen_cmd) {
 614
 615                 prev_aen.word = sc->aen_cmd->frame->dcmd.mbox.w[1];
 616
 617 /*
 618  * A class whose enum value is smaller is inclusive of all
 619  * higher values. If a PROGRESS (= -1) was previously
 620  * registered, then a new registration requests for higher
 621  * classes need not be sent to FW. They are automatically
 622  * included.
 623  * Locale numbers don't have such hierarchy. They are bitmap values
 624  */
 625                 if ((prev_aen.members.class <= curr_aen.members.class) &&
 626                 !((prev_aen.members.locale & curr_aen.members.locale) ^
 627                 curr_aen.members.locale)) {
 628                         /*
 629                          * Previously issued event registration includes
 630                          * current request. Nothing to do.
 631                          */
 632                         return 0;
 633                 } else {
 634                         curr_aen.members.locale |= prev_aen.members.locale;
 635
 636                         if (prev_aen.members.class < curr_aen.members.class)
 637                                 curr_aen.members.class = prev_aen.members.class;
 638
 639                         sc->aen_cmd->abort_aen = 1;
 640                         ret_val = mrsas_issue_blocked_abort_cmd(sc,
 641                                   sc->aen_cmd);
 642
 643                         if (ret_val) {
 644                                 kprintf("mrsas: Failed to abort "
 645                                            "previous AEN command\n");
 646                                 return ret_val;
 647                         }
 648                 }
 649         }
 650
 651         cmd =  mrsas_get_mfi_cmd(sc);
 652
 653         if (!cmd)
 654                 return -ENOMEM;
 655
 656         dcmd = &cmd->frame->dcmd;
 657
 658         memset(sc->evt_detail_mem, 0, sizeof(struct mrsas_evt_detail));
 659
 660 /*
 661  * Prepare DCMD for aen registration
 662  */
 663         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
 664
 665         dcmd->cmd = MFI_CMD_DCMD;
 666         dcmd->cmd_status = 0x0;
 667         dcmd->sge_count = 1;
 668         dcmd->flags = MFI_FRAME_DIR_READ;
 669         dcmd->timeout = 0;
 670         dcmd->pad_0 = 0;
 671         dcmd->data_xfer_len = sizeof(struct mrsas_evt_detail);
 672         dcmd->opcode = MR_DCMD_CTRL_EVENT_WAIT;
 673         dcmd->mbox.w[0] = seq_num;
 674     sc->last_seq_num = seq_num;
 675         dcmd->mbox.w[1] = curr_aen.word;
 676         dcmd->sgl.sge32[0].phys_addr = (u_int32_t) sc->evt_detail_phys_addr;
 677         dcmd->sgl.sge32[0].length = sizeof(struct mrsas_evt_detail);
 678
 679         if (sc->aen_cmd != NULL) {
 680                 mrsas_release_mfi_cmd(cmd);
 681                 return 0;
 682         }
 683
 684         /*
 685          * Store reference to the cmd used to register for AEN. When an
 686          * application wants us to register for AEN, we have to abort this
 687          * cmd and re-register with a new EVENT LOCALE supplied by that app
 688          */
 689         sc->aen_cmd = cmd;
 690
 691         /*
 692           Issue the aen registration frame
 693         */
 694         if (mrsas_issue_dcmd(sc, cmd)){
 695         device_printf(sc->mrsas_dev, "Cannot issue AEN DCMD command.\n");
 696         return(1);
 697         }
 698
 699         return 0;
 700 }
 701 /**
 702  * mrsas_start_aen -  Subscribes to AEN during driver load time
 703  * @instance:           Adapter soft state
 704  */
 705 static int mrsas_start_aen(struct mrsas_softc *sc)
 706 {
 707         struct mrsas_evt_log_info eli;
 708         union mrsas_evt_class_locale class_locale;
 709
 710
 711         /* Get the latest sequence number from FW*/
 712
 713         memset(&eli, 0, sizeof(eli));
 714
 715         if (mrsas_get_seq_num(sc, &eli))
 716                 return -1;
 717
 718         /* Register AEN with FW for latest sequence number plus 1*/
 719         class_locale.members.reserved = 0;
 720         class_locale.members.locale = MR_EVT_LOCALE_ALL;
 721         class_locale.members.class = MR_EVT_CLASS_DEBUG;
 722
 723         return mrsas_register_aen(sc, eli.newest_seq_num + 1,
 724                                 class_locale.word);
 725 }
 726
 727 /**
 728  * mrsas_attach:            PCI entry point
 729  * input:                   device struct pointer
 730  *
 731  * Performs setup of PCI and registers, initializes mutexes and
 732  * linked lists, registers interrupts and CAM, and initializes
 733  * the adapter/controller to its proper state.
 734  */
 735 static int mrsas_attach(device_t dev)
 736 {
 737     struct mrsas_softc *sc = device_get_softc(dev);
 738     uint32_t cmd, bar, error;
 739
 740     /* Look up our softc and initialize its fields. */
 741     sc->mrsas_dev = dev;
 742     sc->device_id = pci_get_device(dev);
 743
 744     mrsas_get_tunables(sc);
 745
 746     /*
 747      * Set up PCI and registers
 748      */
 749     cmd = pci_read_config(dev, PCIR_COMMAND, 2);
 750     if ( (cmd & PCIM_CMD_PORTEN) == 0) {
 751         return (ENXIO);
 752     }
 753     /* Force the busmaster enable bit on. */
 754     cmd |= PCIM_CMD_BUSMASTEREN;
 755     pci_write_config(dev, PCIR_COMMAND, cmd, 2);
 756
 757     //bar = pci_read_config(dev, MRSAS_PCI_BAR0, 4);
 758     bar = pci_read_config(dev, MRSAS_PCI_BAR1, 4);
 759
 760     sc->reg_res_id = MRSAS_PCI_BAR1; /* BAR1 offset */
 761     if ((sc->reg_res = bus_alloc_resource(dev, SYS_RES_MEMORY,
 762                                 &(sc->reg_res_id), 0, ~0, 1, RF_ACTIVE))
 763                                 == NULL) {
 764         device_printf(dev, "Cannot allocate PCI registers\n");
 765         goto attach_fail;
 766     }
 767     sc->bus_tag = rman_get_bustag(sc->reg_res);
 768     sc->bus_handle = rman_get_bushandle(sc->reg_res);
 769
 770     /* Intialize mutexes */
 771     lockinit(&sc->sim_lock,  "mrsas_sim_lock", 0, LK_CANRECURSE);
 772     lockinit(&sc->pci_lock,  "mrsas_pci_lock", 0, LK_CANRECURSE);
 773     lockinit(&sc->io_lock,  "mrsas_io_lock", 0, LK_CANRECURSE);
 774     lockinit(&sc->aen_lock,  "mrsas_aen_lock", 0, LK_CANRECURSE);
 775     spin_init(&sc->ioctl_lock, "mrsasioctl");
 776     lockinit(&sc->mpt_cmd_pool_lock, "mrsas_mpt_cmd_pool_lock", 0,
 777         LK_CANRECURSE);
 778     lockinit(&sc->mfi_cmd_pool_lock, "mrsas_mfi_cmd_pool_lock", 0,
 779         LK_CANRECURSE);
 780     lockinit(&sc->raidmap_lock, "mrsas_raidmap_lock", 0, LK_CANRECURSE);
 781
 782     /* Intialize linked list */
 783     TAILQ_INIT(&sc->mrsas_mpt_cmd_list_head);
 784     TAILQ_INIT(&sc->mrsas_mfi_cmd_list_head);
 785
 786     atomic_set(&sc->fw_outstanding,0);
 787
 788         sc->io_cmds_highwater = 0;
 789
 790     /* Create a /dev entry for this device. */
 791     sc->mrsas_cdev = make_dev(&mrsas_ops, device_get_unit(dev), UID_ROOT,
 792         GID_OPERATOR, (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP), "mrsas%u",
 793         device_get_unit(dev));
 794     if (sc->mrsas_cdev)
 795         sc->mrsas_cdev->si_drv1 = sc;
 796
 797     sc->adprecovery = MRSAS_HBA_OPERATIONAL;
 798         sc->UnevenSpanSupport = 0;
 799
 800     /* Initialize Firmware */
 801     if (mrsas_init_fw(sc) != SUCCESS) {
 802         goto attach_fail_fw;
 803     }
 804
 805     /* Register SCSI mid-layer */
 806     if ((mrsas_cam_attach(sc) != SUCCESS)) {
 807         goto attach_fail_cam;
 808     }
 809
 810     /* Register IRQs */
 811     if (mrsas_setup_irq(sc) != SUCCESS) {
 812         goto attach_fail_irq;
 813     }
 814
 815     /* Enable Interrupts */
 816     mrsas_enable_intr(sc);
 817
 818     error = kthread_create(mrsas_ocr_thread, sc, &sc->ocr_thread, "mrsas_ocr%d",
 819         device_get_unit(sc->mrsas_dev));
 820     if (error) {
 821         kprintf("Error %d starting rescan thread\n", error);
 822         goto attach_fail_irq;
 823     }
 824
 825     mrsas_setup_sysctl(sc);
 826
 827         /* Initiate AEN (Asynchronous Event Notification)*/
 828
 829         if (mrsas_start_aen(sc)) {
 830                 kprintf("Error: start aen failed\n");
 831                 goto fail_start_aen;
 832         }
 833
 834     return (0);
 835
 836 fail_start_aen:
 837 attach_fail_irq:
 838     mrsas_teardown_intr(sc);
 839 attach_fail_cam:
 840     mrsas_cam_detach(sc);
 841 attach_fail_fw:
 842 //attach_fail_raidmap:
 843     mrsas_free_mem(sc);
 844     lockuninit(&sc->sim_lock);
 845     lockuninit(&sc->aen_lock);
 846     lockuninit(&sc->pci_lock);
 847     lockuninit(&sc->io_lock);
 848     spin_uninit(&sc->ioctl_lock);
 849     lockuninit(&sc->mpt_cmd_pool_lock);
 850     lockuninit(&sc->mfi_cmd_pool_lock);
 851     lockuninit(&sc->raidmap_lock);
 852 attach_fail:
 853     destroy_dev(sc->mrsas_cdev);
 854     if (sc->reg_res){
 855         bus_release_resource(sc->mrsas_dev, SYS_RES_MEMORY,
 856                              sc->reg_res_id, sc->reg_res);
 857     }
 858     return (ENXIO);
 859 }
 860
 861 /**
 862  * mrsas_detach:            De-allocates and teardown resources
 863  * input:                   device struct pointer
 864  *
 865  * This function is the entry point for device disconnect and detach.  It
 866  * performs memory de-allocations, shutdown of the controller and various
 867  * teardown and destroy resource functions.
 868  */
 869 static int mrsas_detach(device_t dev)
 870 {
 871     struct mrsas_softc *sc;
 872     int i = 0;
 873
 874     sc = device_get_softc(dev);
 875     sc->remove_in_progress = 1;
 876     if(sc->ocr_thread_active)
 877         wakeup(&sc->ocr_chan);
 878     while(sc->reset_in_progress){
 879         i++;
 880         if (!(i % MRSAS_RESET_NOTICE_INTERVAL)) {
 881             mrsas_dprint(sc, MRSAS_INFO,
 882                 "[%2d]waiting for ocr to be finished\n",i);
 883         }
 884         tsleep(mrsas_detach, 0, "mr_shutdown", hz);
 885     }
 886     i = 0;
 887     while(sc->ocr_thread_active){
 888         i++;
 889         if (!(i % MRSAS_RESET_NOTICE_INTERVAL)) {
 890             mrsas_dprint(sc, MRSAS_INFO,
 891                 "[%2d]waiting for "
 892                 "mrsas_ocr thread to quit ocr %d\n",i,
 893                  sc->ocr_thread_active);
 894         }
 895         tsleep(mrsas_detach, 0, "mr_shutdown", hz);
 896     }
 897     mrsas_flush_cache(sc);
 898     mrsas_shutdown_ctlr(sc, MR_DCMD_CTRL_SHUTDOWN);
 899     mrsas_disable_intr(sc);
 900     mrsas_cam_detach(sc);
 901     mrsas_teardown_intr(sc);
 902     mrsas_free_mem(sc);
 903     lockuninit(&sc->sim_lock);
 904     lockuninit(&sc->aen_lock);
 905     lockuninit(&sc->pci_lock);
 906     lockuninit(&sc->io_lock);
 907     spin_uninit(&sc->ioctl_lock);
 908     lockuninit(&sc->mpt_cmd_pool_lock);
 909     lockuninit(&sc->mfi_cmd_pool_lock);
 910     lockuninit(&sc->raidmap_lock);
 911     if (sc->reg_res){
 912         bus_release_resource(sc->mrsas_dev,
 913                  SYS_RES_MEMORY, sc->reg_res_id, sc->reg_res);
 914     }
 915     destroy_dev(sc->mrsas_cdev);
 916     if (sc->sysctl_tree != NULL)
 917         sysctl_ctx_free(&sc->sysctl_ctx);
 918     return (0);
 919 }
 920
 921 /**
 922  * mrsas_free_mem:          Frees allocated memory
 923  * input:                   Adapter instance soft state
 924  *
 925  * This function is called from mrsas_detach() to free previously allocated
 926  * memory.
 927  */
 928 void mrsas_free_mem(struct mrsas_softc *sc)
 929 {
 930     int i;
 931     u_int32_t max_cmd;
 932     struct mrsas_mfi_cmd *mfi_cmd;
 933     struct mrsas_mpt_cmd *mpt_cmd;
 934
 935         /*
 936      * Free RAID map memory
 937      */
 938     for (i=0; i < 2; i++)
 939     {
 940         if (sc->raidmap_phys_addr[i])
 941             bus_dmamap_unload(sc->raidmap_tag[i], sc->raidmap_dmamap[i]);
 942         if (sc->raidmap_mem[i] != NULL)
 943             bus_dmamem_free(sc->raidmap_tag[i], sc->raidmap_mem[i], sc->raidmap_dmamap[i]);
 944         if (sc->raidmap_tag[i] != NULL)
 945             bus_dma_tag_destroy(sc->raidmap_tag[i]);
 946     }
 947
 948     /*
 949      * Free version buffer memroy
 950      */
 951     if (sc->verbuf_phys_addr)
 952         bus_dmamap_unload(sc->verbuf_tag, sc->verbuf_dmamap);
 953     if (sc->verbuf_mem != NULL)
 954         bus_dmamem_free(sc->verbuf_tag, sc->verbuf_mem, sc->verbuf_dmamap);
 955     if (sc->verbuf_tag != NULL)
 956         bus_dma_tag_destroy(sc->verbuf_tag);
 957
 958
 959     /*
 960      * Free sense buffer memory
 961      */
 962     if (sc->sense_phys_addr)
 963         bus_dmamap_unload(sc->sense_tag, sc->sense_dmamap);
 964     if (sc->sense_mem != NULL)
 965         bus_dmamem_free(sc->sense_tag, sc->sense_mem, sc->sense_dmamap);
 966     if (sc->sense_tag != NULL)
 967         bus_dma_tag_destroy(sc->sense_tag);
 968
 969     /*
 970      * Free chain frame memory
 971      */
 972     if (sc->chain_frame_phys_addr)
 973         bus_dmamap_unload(sc->chain_frame_tag, sc->chain_frame_dmamap);
 974     if (sc->chain_frame_mem != NULL)
 975         bus_dmamem_free(sc->chain_frame_tag, sc->chain_frame_mem, sc->chain_frame_dmamap);
 976     if (sc->chain_frame_tag != NULL)
 977         bus_dma_tag_destroy(sc->chain_frame_tag);
 978
 979     /*
 980      * Free IO Request memory
 981      */
 982     if (sc->io_request_phys_addr)
 983         bus_dmamap_unload(sc->io_request_tag, sc->io_request_dmamap);
 984     if (sc->io_request_mem != NULL)
 985         bus_dmamem_free(sc->io_request_tag, sc->io_request_mem, sc->io_request_dmamap);
 986     if (sc->io_request_tag != NULL)
 987         bus_dma_tag_destroy(sc->io_request_tag);
 988
 989     /*
 990      * Free Reply Descriptor memory
 991      */
 992     if (sc->reply_desc_phys_addr)
 993         bus_dmamap_unload(sc->reply_desc_tag, sc->reply_desc_dmamap);
 994     if (sc->reply_desc_mem != NULL)
 995         bus_dmamem_free(sc->reply_desc_tag, sc->reply_desc_mem, sc->reply_desc_dmamap);
 996     if (sc->reply_desc_tag != NULL)
 997         bus_dma_tag_destroy(sc->reply_desc_tag);
 998
 999     /*
1000      * Free event detail memory
1001      */
1002     if (sc->evt_detail_phys_addr)
1003         bus_dmamap_unload(sc->evt_detail_tag, sc->evt_detail_dmamap);
1004     if (sc->evt_detail_mem != NULL)
1005         bus_dmamem_free(sc->evt_detail_tag, sc->evt_detail_mem, sc->evt_detail_dmamap);
1006     if (sc->evt_detail_tag != NULL)
1007         bus_dma_tag_destroy(sc->evt_detail_tag);
1008
1009     /*
1010      * Free MFI frames
1011      */
1012         if (sc->mfi_cmd_list) {
1013         for (i = 0; i < MRSAS_MAX_MFI_CMDS; i++) {
1014                 mfi_cmd = sc->mfi_cmd_list[i];
1015                 mrsas_free_frame(sc, mfi_cmd);
1016                 }
1017     }
1018     if (sc->mficmd_frame_tag != NULL)
1019         bus_dma_tag_destroy(sc->mficmd_frame_tag);
1020
1021     /*
1022      * Free MPT internal command list
1023      */
1024     max_cmd = sc->max_fw_cmds;
1025         if (sc->mpt_cmd_list) {
1026         for (i = 0; i < max_cmd; i++) {
1027                 mpt_cmd = sc->mpt_cmd_list[i];
1028                 bus_dmamap_destroy(sc->data_tag, mpt_cmd->data_dmamap);
1029                 kfree(sc->mpt_cmd_list[i], M_MRSAS);
1030         }
1031         kfree(sc->mpt_cmd_list, M_MRSAS);
1032         sc->mpt_cmd_list = NULL;
1033         }
1034
1035     /*
1036      * Free MFI internal command list
1037      */
1038
1039         if (sc->mfi_cmd_list) {
1040         for (i = 0; i < MRSAS_MAX_MFI_CMDS; i++) {
1041                 kfree(sc->mfi_cmd_list[i], M_MRSAS);
1042         }
1043         kfree(sc->mfi_cmd_list, M_MRSAS);
1044         sc->mfi_cmd_list = NULL;
1045         }
1046
1047     /*
1048      * Free request descriptor memory
1049      */
1050     kfree(sc->req_desc, M_MRSAS);
1051     sc->req_desc = NULL;
1052
1053     /*
1054      * Destroy parent tag
1055      */
1056     if (sc->mrsas_parent_tag != NULL)
1057         bus_dma_tag_destroy(sc->mrsas_parent_tag);
1058 }
1059
1060 /**
1061  * mrsas_teardown_intr:        Teardown interrupt
1062  * input:                      Adapter instance soft state
1063  *
1064  * This function is called from mrsas_detach() to teardown and release
1065  * bus interrupt resourse.
1066  */
1067 void mrsas_teardown_intr(struct mrsas_softc *sc)
1068 {
1069     if (sc->intr_handle)
1070         bus_teardown_intr(sc->mrsas_dev, sc->mrsas_irq, sc->intr_handle);
1071     if (sc->mrsas_irq != NULL)
1072         bus_release_resource(sc->mrsas_dev, SYS_RES_IRQ, sc->irq_id, sc->mrsas_irq);
1073     if (sc->irq_type == PCI_INTR_TYPE_MSI)
1074         pci_release_msi(sc->mrsas_dev);
1075     sc->intr_handle = NULL;
1076 }
1077
1078 /**
1079  * mrsas_suspend:          Suspend entry point
1080  * input:                  Device struct pointer
1081  *
1082  * This function is the entry point for system suspend from the OS.
1083  */
1084 static int mrsas_suspend(device_t dev)
1085 {
1086     struct mrsas_softc *sc;
1087
1088     sc = device_get_softc(dev);
1089     return (0);
1090 }
1091
1092 /**
1093  * mrsas_resume:           Resume entry point
1094  * input:                  Device struct pointer
1095  *
1096  * This function is the entry point for system resume from the OS.
1097  */
1098 static int mrsas_resume(device_t dev)
1099 {
1100     struct mrsas_softc *sc;
1101
1102     sc = device_get_softc(dev);
1103     return (0);
1104 }
1105
1106 /**
1107  * mrsas_ioctl:       IOCtl commands entry point.
1108  *
1109  * This function is the entry point for IOCtls from the OS.  It calls the
1110  * appropriate function for processing depending on the command received.
1111  */
1112 static int
1113 mrsas_ioctl(struct dev_ioctl_args *ap)
1114 {
1115     cdev_t dev = ap->a_head.a_dev;
1116     u_long cmd = ap->a_cmd;
1117     caddr_t arg = ap->a_data;
1118     struct mrsas_softc *sc;
1119     int ret = 0, i = 0;
1120
1121     sc = (struct mrsas_softc *)(dev->si_drv1);
1122
1123     if (sc->remove_in_progress) {
1124         mrsas_dprint(sc, MRSAS_INFO,
1125             "Driver remove or shutdown called.\n");
1126         return ENOENT;
1127     }
1128
1129     spin_lock(&sc->ioctl_lock);
1130     if (!sc->reset_in_progress) {
1131         spin_unlock(&sc->ioctl_lock);
1132         goto do_ioctl;
1133     }
1134
1135     /* Release ioclt_lock, and wait for OCR
1136      * to be finished */
1137     spin_unlock(&sc->ioctl_lock);
1138     while(sc->reset_in_progress){
1139         i++;
1140         if (!(i % MRSAS_RESET_NOTICE_INTERVAL)) {
1141             mrsas_dprint(sc, MRSAS_INFO,
1142                 "[%2d]waiting for "
1143                 "OCR to be finished %d\n",i,
1144                  sc->ocr_thread_active);
1145         }
1146         tsleep(mrsas_ioctl, 0, "mr_ioctl", hz);
1147     }
1148
1149 do_ioctl:
1150     switch (cmd) {
1151         case MRSAS_IOC_FIRMWARE_PASS_THROUGH:
1152             ret = mrsas_passthru(sc, (void *)arg);
1153             break;
1154         case MRSAS_IOC_SCAN_BUS:
1155             ret = mrsas_bus_scan(sc);
1156             break;
1157     }
1158
1159     return (ret);
1160 }
1161
1162 /**
1163  * mrsas_setup_irq:   Set up interrupt.
1164  * input:             Adapter instance soft state
1165  *
1166  * This function sets up interrupts as a bus resource, with flags indicating
1167  * resource permitting contemporaneous sharing and for resource to activate
1168  * atomically.
1169  */
1170 static int mrsas_setup_irq(struct mrsas_softc *sc)
1171 {
1172     u_int irq_flags;
1173
1174     sc->irq_id = 0;
1175     sc->irq_type = pci_alloc_1intr(sc->mrsas_dev, mrsas_msi_enable,
1176         &sc->irq_id, &irq_flags);
1177
1178     sc->mrsas_irq = bus_alloc_resource_any(sc->mrsas_dev, SYS_RES_IRQ,
1179         &sc->irq_id, irq_flags);
1180     if (sc->mrsas_irq == NULL){
1181         device_printf(sc->mrsas_dev, "Cannot allocate interrupt\n");
1182         return (FAIL);
1183     }
1184     if (bus_setup_intr(sc->mrsas_dev, sc->mrsas_irq, INTR_MPSAFE,
1185                        mrsas_isr, sc, &sc->intr_handle, NULL)) {
1186         device_printf(sc->mrsas_dev, "Cannot set up interrupt\n");
1187         return (FAIL);
1188     }
1189
1190     return (0);
1191 }
1192
1193 /*
1194  * mrsas_isr:        ISR entry point
1195  * input:            argument pointer
1196  *
1197  * This function is the interrupt service routine entry point.  There
1198  * are two types of interrupts, state change interrupt and response
1199  * interrupt.  If an interrupt is not ours, we just return.
1200  */
1201 void mrsas_isr(void *arg)
1202 {
1203     struct mrsas_softc *sc = (struct mrsas_softc *)arg;
1204     int status;
1205
1206     /* Clear FW state change interrupt */
1207     status = mrsas_clear_intr(sc);
1208
1209     /* Not our interrupt */
1210     if (!status)
1211         return;
1212
1213     /* If we are resetting, bail */
1214     if (test_bit(MRSAS_FUSION_IN_RESET, &sc->reset_flags)) {
1215         kprintf(" Entered into ISR when OCR is going active. \n");
1216         mrsas_clear_intr(sc);
1217         return;
1218     }
1219     /* Process for reply request and clear response interrupt */
1220     if (mrsas_complete_cmd(sc) != SUCCESS)
1221         mrsas_clear_intr(sc);
1222
1223     return;
1224 }
1225
1226 /*
1227  * mrsas_complete_cmd:        Process reply request
1228  * input:                     Adapter instance soft state
1229  *
1230  * This function is called from mrsas_isr() to process reply request and
1231  * clear response interrupt. Processing of the reply request entails
1232  * walking through the reply descriptor array for the command request
1233  * pended from Firmware.  We look at the Function field to determine
1234  * the command type and perform the appropriate action.  Before we
1235  * return, we clear the response interrupt.
1236  */
1237 static int mrsas_complete_cmd(struct mrsas_softc *sc)
1238 {
1239     Mpi2ReplyDescriptorsUnion_t *desc;
1240     MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *reply_desc;
1241     MRSAS_RAID_SCSI_IO_REQUEST  *scsi_io_req;
1242     struct mrsas_mpt_cmd *cmd_mpt;
1243     struct mrsas_mfi_cmd *cmd_mfi;
1244     u_int8_t arm, reply_descript_type;
1245     u_int16_t smid, num_completed;
1246     u_int8_t status, extStatus;
1247     union desc_value desc_val;
1248     PLD_LOAD_BALANCE_INFO lbinfo;
1249     u_int32_t device_id;
1250     int threshold_reply_count = 0;
1251
1252
1253     /* If we have a hardware error, not need to continue */
1254     if (sc->adprecovery == MRSAS_HW_CRITICAL_ERROR)
1255         return (DONE);
1256
1257     desc = sc->reply_desc_mem;
1258     desc += sc->last_reply_idx;
1259
1260     reply_desc = (MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
1261
1262     desc_val.word = desc->Words;
1263     num_completed = 0;
1264
1265     reply_descript_type = reply_desc->ReplyFlags & MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
1266
1267     /* Find our reply descriptor for the command and process */
1268     while((desc_val.u.low != 0xFFFFFFFF) && (desc_val.u.high != 0xFFFFFFFF))
1269     {
1270         smid = reply_desc->SMID;
1271         cmd_mpt = sc->mpt_cmd_list[smid -1];
1272         scsi_io_req = (MRSAS_RAID_SCSI_IO_REQUEST *)cmd_mpt->io_request;
1273
1274         status = scsi_io_req->RaidContext.status;
1275         extStatus = scsi_io_req->RaidContext.exStatus;
1276
1277         switch (scsi_io_req->Function)
1278         {
1279             case MPI2_FUNCTION_SCSI_IO_REQUEST :  /*Fast Path IO.*/
1280                 device_id = cmd_mpt->ccb_ptr->ccb_h.target_id;
1281                 lbinfo = &sc->load_balance_info[device_id];
1282                 if (cmd_mpt->load_balance == MRSAS_LOAD_BALANCE_FLAG) {
1283                     arm = lbinfo->raid1DevHandle[0] == scsi_io_req->DevHandle ? 0 : 1;
1284                     atomic_dec(&lbinfo->scsi_pending_cmds[arm]);
1285                     cmd_mpt->load_balance &= ~MRSAS_LOAD_BALANCE_FLAG;
1286                 }
1287                 //Fall thru and complete IO
1288             case MRSAS_MPI2_FUNCTION_LD_IO_REQUEST:
1289                 mrsas_map_mpt_cmd_status(cmd_mpt, status, extStatus);
1290                 mrsas_cmd_done(sc, cmd_mpt);
1291                 scsi_io_req->RaidContext.status = 0;
1292                 scsi_io_req->RaidContext.exStatus = 0;
1293                 atomic_dec(&sc->fw_outstanding);
1294                 break;
1295             case MRSAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST: /*MFI command */
1296                 cmd_mfi = sc->mfi_cmd_list[cmd_mpt->sync_cmd_idx];
1297                 mrsas_complete_mptmfi_passthru(sc, cmd_mfi, status);
1298                 cmd_mpt->flags = 0;
1299                 mrsas_release_mpt_cmd(cmd_mpt);
1300                 break;
1301         }
1302
1303         sc->last_reply_idx++;
1304         if (sc->last_reply_idx >= sc->reply_q_depth)
1305             sc->last_reply_idx = 0;
1306
1307         desc->Words = ~((uint64_t)0x00); /* set it back to all 0xFFFFFFFFs */
1308         num_completed++;
1309         threshold_reply_count++;
1310
1311         /* Get the next reply descriptor */
1312         if (!sc->last_reply_idx)
1313             desc = sc->reply_desc_mem;
1314         else
1315             desc++;
1316
1317         reply_desc = (MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
1318         desc_val.word = desc->Words;
1319
1320         reply_descript_type = reply_desc->ReplyFlags & MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
1321
1322         if(reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
1323             break;
1324
1325         /*
1326          * Write to reply post index after completing threshold reply count
1327          * and still there are more replies in reply queue pending to be
1328          * completed.
1329          */
1330         if (threshold_reply_count >= THRESHOLD_REPLY_COUNT) {
1331             mrsas_write_reg(sc, offsetof(mrsas_reg_set, reply_post_host_index),
1332                             sc->last_reply_idx);
1333             threshold_reply_count = 0;
1334         }
1335     }
1336
1337     /* No match, just return */
1338     if (num_completed == 0)
1339         return (DONE);
1340
1341     /* Clear response interrupt */
1342     mrsas_write_reg(sc, offsetof(mrsas_reg_set, reply_post_host_index),sc->last_reply_idx);
1343
1344     return(0);
1345 }
1346
1347 /*
1348  * mrsas_map_mpt_cmd_status:  Allocate DMAable memory.
1349  * input:                     Adapter instance soft state
1350  *
1351  * This function is called from mrsas_complete_cmd(), for LD IO and FastPath IO.
1352  * It checks the command status and maps the appropriate CAM status for the CCB.
1353  */
1354 void mrsas_map_mpt_cmd_status(struct mrsas_mpt_cmd *cmd, u_int8_t status, u_int8_t extStatus)
1355 {
1356     struct mrsas_softc *sc = cmd->sc;
1357     u_int8_t *sense_data;
1358
1359     switch (status) {
1360         case MFI_STAT_OK:
1361             cmd->ccb_ptr->ccb_h.status = CAM_REQ_CMP;
1362             break;
1363         case MFI_STAT_SCSI_IO_FAILED:
1364         case MFI_STAT_SCSI_DONE_WITH_ERROR:
1365             cmd->ccb_ptr->ccb_h.status = CAM_SCSI_STATUS_ERROR;
1366             sense_data = (u_int8_t *)&cmd->ccb_ptr->csio.sense_data;
1367             if (sense_data) {
1368                 /* For now just copy 18 bytes back */
1369                 memcpy(sense_data, cmd->sense, 18);
1370                 cmd->ccb_ptr->csio.sense_len = 18;
1371                 cmd->ccb_ptr->ccb_h.status |= CAM_AUTOSNS_VALID;
1372             }
1373             break;
1374         case MFI_STAT_LD_OFFLINE:
1375         case MFI_STAT_DEVICE_NOT_FOUND:
1376             if (cmd->ccb_ptr->ccb_h.target_lun)
1377                 cmd->ccb_ptr->ccb_h.status |= CAM_LUN_INVALID;
1378             else
1379                 cmd->ccb_ptr->ccb_h.status |= CAM_DEV_NOT_THERE;
1380             break;
1381         case MFI_STAT_CONFIG_SEQ_MISMATCH:
1382             /*send status to CAM layer to retry sending  command without
1383              * decrementing retry counter*/
1384             cmd->ccb_ptr->ccb_h.status |= CAM_REQUEUE_REQ;
1385             break;
1386         default:
1387             device_printf(sc->mrsas_dev, "FW cmd complete status %x\n", status);
1388             cmd->ccb_ptr->ccb_h.status = CAM_REQ_CMP_ERR;
1389             cmd->ccb_ptr->csio.scsi_status = status;
1390     }
1391     return;
1392 }
1393
1394 /*
1395  * mrsas_alloc_mem:  Allocate DMAable memory.
1396  * input:            Adapter instance soft state
1397  *
1398  * This function creates the parent DMA tag and allocates DMAable memory.
1399  * DMA tag describes constraints of DMA mapping. Memory allocated is mapped
1400  * into Kernel virtual address. Callback argument is physical memory address.
1401  */
1402 static int mrsas_alloc_mem(struct mrsas_softc *sc)
1403 {
1404     u_int32_t verbuf_size, io_req_size, reply_desc_size, sense_size,
1405               chain_frame_size, evt_detail_size;
1406
1407     /*
1408      * Allocate parent DMA tag
1409      */
1410     if (bus_dma_tag_create(NULL,                   /* parent */
1411                            1,         /* alignment */
1412                            0,                      /* boundary */
1413                            BUS_SPACE_MAXADDR,     /* lowaddr */
1414                            BUS_SPACE_MAXADDR,      /* highaddr */
1415                            NULL, NULL,             /* filter, filterarg */
1416                            MRSAS_MAX_IO_SIZE,/* maxsize */
1417                            MRSAS_MAX_SGL, /* nsegments */
1418                            MRSAS_MAX_IO_SIZE,/* maxsegsize */
1419                            0,                      /* flags */
1420                            &sc->mrsas_parent_tag   /* tag */
1421                            )) {
1422            device_printf(sc->mrsas_dev, "Cannot allocate parent DMA tag\n");
1423            return(ENOMEM);
1424     }
1425
1426     /*
1427      * Allocate for version buffer
1428      */
1429     verbuf_size = MRSAS_MAX_NAME_LENGTH*(sizeof(bus_addr_t));
1430     if (bus_dma_tag_create(sc->mrsas_parent_tag,   // parent
1431                            1, 0,                   // algnmnt, boundary
1432                            BUS_SPACE_MAXADDR_32BIT,// lowaddr
1433                            BUS_SPACE_MAXADDR,      // highaddr
1434                            NULL, NULL,             // filter, filterarg
1435                            verbuf_size,           // maxsize
1436                            1,                      // msegments
1437                            verbuf_size,           // maxsegsize
1438                            BUS_DMA_ALLOCNOW,       // flags
1439                            &sc->verbuf_tag)) {
1440             device_printf(sc->mrsas_dev, "Cannot allocate verbuf DMA tag\n");
1441             return (ENOMEM);
1442     }
1443     if (bus_dmamem_alloc(sc->verbuf_tag, (void **)&sc->verbuf_mem,
1444         BUS_DMA_NOWAIT, &sc->verbuf_dmamap)) {
1445             device_printf(sc->mrsas_dev, "Cannot allocate verbuf memory\n");
1446             return (ENOMEM);
1447     }
1448     bzero(sc->verbuf_mem, verbuf_size);
1449     if (bus_dmamap_load(sc->verbuf_tag, sc->verbuf_dmamap, sc->verbuf_mem,
1450         verbuf_size, mrsas_addr_cb, &sc->verbuf_phys_addr, BUS_DMA_NOWAIT)){
1451             device_printf(sc->mrsas_dev, "Cannot load verbuf DMA map\n");
1452             return(ENOMEM);
1453     }
1454
1455     /*
1456      * Allocate IO Request Frames
1457      */
1458     io_req_size = sc->io_frames_alloc_sz;
1459     if (bus_dma_tag_create( sc->mrsas_parent_tag,   // parent
1460                             16, 0,                   // algnmnt, boundary
1461                             BUS_SPACE_MAXADDR_32BIT,// lowaddr
1462                             BUS_SPACE_MAXADDR,      // highaddr
1463                             NULL, NULL,             // filter, filterarg
1464                             io_req_size,            // maxsize
1465                             1,                      // msegments
1466                             io_req_size,            // maxsegsize
1467                             BUS_DMA_ALLOCNOW,       // flags
1468                             &sc->io_request_tag)) {
1469         device_printf(sc->mrsas_dev, "Cannot create IO request tag\n");
1470         return (ENOMEM);
1471     }
1472     if (bus_dmamem_alloc(sc->io_request_tag, (void **)&sc->io_request_mem,
1473                     BUS_DMA_NOWAIT, &sc->io_request_dmamap)) {
1474         device_printf(sc->mrsas_dev, "Cannot alloc IO request memory\n");
1475         return (ENOMEM);
1476     }
1477     bzero(sc->io_request_mem, io_req_size);
1478     if (bus_dmamap_load(sc->io_request_tag, sc->io_request_dmamap,
1479                         sc->io_request_mem, io_req_size, mrsas_addr_cb,
1480                         &sc->io_request_phys_addr, BUS_DMA_NOWAIT)) {
1481         device_printf(sc->mrsas_dev, "Cannot load IO request memory\n");
1482         return (ENOMEM);
1483     }
1484
1485     /*
1486      * Allocate Chain Frames
1487      */
1488     chain_frame_size = sc->chain_frames_alloc_sz;
1489     if (bus_dma_tag_create( sc->mrsas_parent_tag,   // parent
1490                             4, 0,                   // algnmnt, boundary
1491                             BUS_SPACE_MAXADDR_32BIT,// lowaddr
1492                             BUS_SPACE_MAXADDR,      // highaddr
1493                             NULL, NULL,             // filter, filterarg
1494                             chain_frame_size,       // maxsize
1495                             1,                      // msegments
1496                             chain_frame_size,       // maxsegsize
1497                             BUS_DMA_ALLOCNOW,       // flags
1498                             &sc->chain_frame_tag)) {
1499         device_printf(sc->mrsas_dev, "Cannot create chain frame tag\n");
1500         return (ENOMEM);
1501     }
1502     if (bus_dmamem_alloc(sc->chain_frame_tag, (void **)&sc->chain_frame_mem,
1503                     BUS_DMA_NOWAIT, &sc->chain_frame_dmamap)) {
1504         device_printf(sc->mrsas_dev, "Cannot alloc chain frame memory\n");
1505         return (ENOMEM);
1506     }
1507     bzero(sc->chain_frame_mem, chain_frame_size);
1508     if (bus_dmamap_load(sc->chain_frame_tag, sc->chain_frame_dmamap,
1509                         sc->chain_frame_mem, chain_frame_size, mrsas_addr_cb,
1510                         &sc->chain_frame_phys_addr, BUS_DMA_NOWAIT)) {
1511         device_printf(sc->mrsas_dev, "Cannot load chain frame memory\n");
1512         return (ENOMEM);
1513     }
1514
1515     /*
1516      * Allocate Reply Descriptor Array
1517      */
1518     reply_desc_size = sc->reply_alloc_sz;
1519     if (bus_dma_tag_create( sc->mrsas_parent_tag,   // parent
1520                             16, 0,                   // algnmnt, boundary
1521                             BUS_SPACE_MAXADDR_32BIT,// lowaddr
1522                             BUS_SPACE_MAXADDR,      // highaddr
1523                             NULL, NULL,             // filter, filterarg
1524                             reply_desc_size,        // maxsize
1525                             1,                      // msegments
1526                             reply_desc_size,        // maxsegsize
1527                             BUS_DMA_ALLOCNOW,       // flags
1528                             &sc->reply_desc_tag)) {
1529         device_printf(sc->mrsas_dev, "Cannot create reply descriptor tag\n");
1530         return (ENOMEM);
1531     }
1532     if (bus_dmamem_alloc(sc->reply_desc_tag, (void **)&sc->reply_desc_mem,
1533                     BUS_DMA_NOWAIT, &sc->reply_desc_dmamap)) {
1534         device_printf(sc->mrsas_dev, "Cannot alloc reply descriptor memory\n");
1535         return (ENOMEM);
1536     }
1537     if (bus_dmamap_load(sc->reply_desc_tag, sc->reply_desc_dmamap,
1538                         sc->reply_desc_mem, reply_desc_size, mrsas_addr_cb,
1539                         &sc->reply_desc_phys_addr, BUS_DMA_NOWAIT)) {
1540         device_printf(sc->mrsas_dev, "Cannot load reply descriptor memory\n");
1541         return (ENOMEM);
1542     }
1543
1544     /*
1545      * Allocate Sense Buffer Array.  Keep in lower 4GB
1546      */
1547     sense_size = sc->max_fw_cmds * MRSAS_SENSE_LEN;
1548     if (bus_dma_tag_create(sc->mrsas_parent_tag,    // parent
1549                             64, 0,                   // algnmnt, boundary
1550                             BUS_SPACE_MAXADDR_32BIT,// lowaddr
1551                             BUS_SPACE_MAXADDR,      // highaddr
1552                             NULL, NULL,             // filter, filterarg
1553                             sense_size,             // maxsize
1554                             1,                      // nsegments
1555                             sense_size,             // maxsegsize
1556                             BUS_DMA_ALLOCNOW,       // flags
1557                             &sc->sense_tag)) {
1558         device_printf(sc->mrsas_dev, "Cannot allocate sense buf tag\n");
1559         return (ENOMEM);
1560     }
1561     if (bus_dmamem_alloc(sc->sense_tag, (void **)&sc->sense_mem,
1562             BUS_DMA_NOWAIT, &sc->sense_dmamap)) {
1563         device_printf(sc->mrsas_dev, "Cannot allocate sense buf memory\n");
1564         return (ENOMEM);
1565     }
1566     if (bus_dmamap_load(sc->sense_tag, sc->sense_dmamap,
1567             sc->sense_mem, sense_size, mrsas_addr_cb, &sc->sense_phys_addr,
1568             BUS_DMA_NOWAIT)){
1569         device_printf(sc->mrsas_dev, "Cannot load sense buf memory\n");
1570         return (ENOMEM);
1571     }
1572
1573     /*
1574      * Allocate for Event detail structure
1575      */
1576     evt_detail_size = sizeof(struct mrsas_evt_detail);
1577     if (bus_dma_tag_create( sc->mrsas_parent_tag,   // parent
1578                             1, 0,                   // algnmnt, boundary
1579                             BUS_SPACE_MAXADDR_32BIT,// lowaddr
1580                             BUS_SPACE_MAXADDR,      // highaddr
1581                             NULL, NULL,             // filter, filterarg
1582                             evt_detail_size,        // maxsize
1583                             1,                      // msegments
1584                             evt_detail_size,        // maxsegsize
1585                             BUS_DMA_ALLOCNOW,       // flags
1586                             &sc->evt_detail_tag)) {
1587         device_printf(sc->mrsas_dev, "Cannot create Event detail tag\n");
1588         return (ENOMEM);
1589     }
1590     if (bus_dmamem_alloc(sc->evt_detail_tag, (void **)&sc->evt_detail_mem,
1591                     BUS_DMA_NOWAIT, &sc->evt_detail_dmamap)) {
1592         device_printf(sc->mrsas_dev, "Cannot alloc Event detail buffer memory\n");
1593         return (ENOMEM);
1594     }
1595     bzero(sc->evt_detail_mem, evt_detail_size);
1596     if (bus_dmamap_load(sc->evt_detail_tag, sc->evt_detail_dmamap,
1597                         sc->evt_detail_mem, evt_detail_size, mrsas_addr_cb,
1598                         &sc->evt_detail_phys_addr, BUS_DMA_NOWAIT)) {
1599         device_printf(sc->mrsas_dev, "Cannot load Event detail buffer memory\n");
1600         return (ENOMEM);
1601     }
1602
1603
1604    /*
1605     * Create a dma tag for data buffers; size will be the maximum
1606     * possible I/O size (280kB).
1607     */
1608     if (bus_dma_tag_create(sc->mrsas_parent_tag,   // parent
1609                            1,         // alignment
1610                            0,                      // boundary
1611                            BUS_SPACE_MAXADDR,      // lowaddr
1612                            BUS_SPACE_MAXADDR,      // highaddr
1613                            NULL, NULL,             // filter, filterarg
1614                            MRSAS_MAX_IO_SIZE,      // maxsize
1615                            MRSAS_MAX_SGL,          // nsegments
1616                            MRSAS_MAX_IO_SIZE,      // maxsegsize
1617                            BUS_DMA_ALLOCNOW,       // flags
1618                            &sc->data_tag)) {
1619         device_printf(sc->mrsas_dev, "Cannot create data dma tag\n");
1620         return(ENOMEM);
1621     }
1622
1623     return(0);
1624 }
1625
1626 /*
1627  * mrsas_addr_cb:   Callback function of bus_dmamap_load()
1628  * input:           callback argument,
1629  *                  machine dependent type that describes DMA segments,
1630  *                  number of segments,
1631  *                  error code.
1632  *
1633  * This function is for the driver to receive mapping information resultant
1634  * of the bus_dmamap_load(). The information is actually not being used,
1635  * but the address is saved anyway.
1636  */
1637 void
1638 mrsas_addr_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
1639 {
1640     bus_addr_t *addr;
1641
1642     addr = arg;
1643     *addr = segs[0].ds_addr;
1644 }
1645
1646 /*
1647  * mrsas_setup_raidmap:  Set up RAID map.
1648  * input:                Adapter instance soft state
1649  *
1650  * Allocate DMA memory for the RAID maps and perform setup.
1651  */
1652 static int mrsas_setup_raidmap(struct mrsas_softc *sc)
1653 {
1654     sc->map_sz = sizeof(MR_FW_RAID_MAP) +
1655                 (sizeof(MR_LD_SPAN_MAP) * (MAX_LOGICAL_DRIVES - 1));
1656
1657     for (int i=0; i < 2; i++)
1658     {
1659         if (bus_dma_tag_create(sc->mrsas_parent_tag,    // parent
1660                             4, 0,                   // algnmnt, boundary
1661                             BUS_SPACE_MAXADDR_32BIT,// lowaddr
1662                             BUS_SPACE_MAXADDR,      // highaddr
1663                             NULL, NULL,             // filter, filterarg
1664                             sc->map_sz,             // maxsize
1665                             1,                      // nsegments
1666                             sc->map_sz,             // maxsegsize
1667                             BUS_DMA_ALLOCNOW,       // flags
1668                             &sc->raidmap_tag[i])) {
1669             device_printf(sc->mrsas_dev, "Cannot allocate raid map tag.\n");
1670             return (ENOMEM);
1671         }
1672         if (bus_dmamem_alloc(sc->raidmap_tag[i], (void **)&sc->raidmap_mem[i],
1673                 BUS_DMA_NOWAIT, &sc->raidmap_dmamap[i])) {
1674             device_printf(sc->mrsas_dev, "Cannot allocate raidmap memory.\n");
1675             return (ENOMEM);
1676         }
1677         if (bus_dmamap_load(sc->raidmap_tag[i], sc->raidmap_dmamap[i],
1678                 sc->raidmap_mem[i], sc->map_sz, mrsas_addr_cb, &sc->raidmap_phys_addr[i],
1679                 BUS_DMA_NOWAIT)){
1680             device_printf(sc->mrsas_dev, "Cannot load raidmap memory.\n");
1681             return (ENOMEM);
1682         }
1683         if (!sc->raidmap_mem[i]) {
1684             device_printf(sc->mrsas_dev, "Cannot allocate memory for raid map.\n");
1685             return (ENOMEM);
1686         }
1687     }
1688
1689     if (!mrsas_get_map_info(sc))
1690         mrsas_sync_map_info(sc);
1691
1692     return (0);
1693 }
1694
1695 /**
1696  * mrsas_init_fw:      Initialize Firmware
1697  * input:              Adapter soft state
1698  *
1699  * Calls transition_to_ready() to make sure Firmware is in operational
1700  * state and calls mrsas_init_adapter() to send IOC_INIT command to
1701  * Firmware.  It issues internal commands to get the controller info
1702  * after the IOC_INIT command response is received by Firmware.
1703  * Note:  code relating to get_pdlist, get_ld_list and max_sectors
1704  * are currently not being used, it is left here as placeholder.
1705  */
1706 static int mrsas_init_fw(struct mrsas_softc *sc)
1707 {
1708     u_int32_t max_sectors_1;
1709     u_int32_t max_sectors_2;
1710     u_int32_t tmp_sectors;
1711     struct mrsas_ctrl_info *ctrl_info;
1712
1713     int ret, ocr = 0;
1714
1715
1716     /* Make sure Firmware is ready */
1717     ret = mrsas_transition_to_ready(sc, ocr);
1718     if (ret != SUCCESS) {
1719         return(ret);
1720         }
1721
1722     /* Get operational params, sge flags, send init cmd to ctlr */
1723     if (mrsas_init_adapter(sc) != SUCCESS){
1724         device_printf(sc->mrsas_dev, "Adapter initialize Fail.\n");
1725         return(1);
1726     }
1727
1728     /* Allocate internal commands for pass-thru */
1729     if (mrsas_alloc_mfi_cmds(sc) != SUCCESS){
1730         device_printf(sc->mrsas_dev, "Allocate MFI cmd failed.\n");
1731         return(1);
1732     }
1733
1734     if (mrsas_setup_raidmap(sc) != SUCCESS) {
1735         device_printf(sc->mrsas_dev, "Set up RAID map failed.\n");
1736         return(1);
1737         }
1738
1739     /* For pass-thru, get PD/LD list and controller info */
1740     memset(sc->pd_list, 0, MRSAS_MAX_PD * sizeof(struct mrsas_pd_list));
1741     mrsas_get_pd_list(sc);
1742
1743     memset(sc->ld_ids, 0xff, MRSAS_MAX_LD);
1744     mrsas_get_ld_list(sc);
1745
1746         //memset(sc->log_to_span, 0, MRSAS_MAX_LD * sizeof(LD_SPAN_INFO));
1747
1748     ctrl_info = kmalloc(sizeof(struct mrsas_ctrl_info), M_MRSAS, M_NOWAIT);
1749
1750     /*
1751      * Compute the max allowed sectors per IO: The controller info has two
1752      * limits on max sectors. Driver should use the minimum of these two.
1753      *
1754      * 1 << stripe_sz_ops.min = max sectors per strip
1755      *
1756      * Note that older firmwares ( < FW ver 30) didn't report information
1757      * to calculate max_sectors_1. So the number ended up as zero always.
1758      */
1759     tmp_sectors = 0;
1760     if (ctrl_info && !mrsas_get_ctrl_info(sc, ctrl_info)) {
1761         max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) *
1762                     ctrl_info->max_strips_per_io;
1763         max_sectors_2 = ctrl_info->max_request_size;
1764         tmp_sectors = min(max_sectors_1 , max_sectors_2);
1765         sc->disableOnlineCtrlReset =
1766             ctrl_info->properties.OnOffProperties.disableOnlineCtrlReset;
1767         sc->UnevenSpanSupport =
1768             ctrl_info->adapterOperations2.supportUnevenSpans;
1769         if(sc->UnevenSpanSupport) {
1770             device_printf(sc->mrsas_dev, "FW supports: UnevenSpanSupport=%x\n",
1771                 sc->UnevenSpanSupport);
1772             if (MR_ValidateMapInfo(sc))
1773                     sc->fast_path_io = 1;
1774             else
1775                 sc->fast_path_io = 0;
1776
1777         }
1778     }
1779     sc->max_sectors_per_req = sc->max_num_sge * MRSAS_PAGE_SIZE / 512;
1780
1781     if (tmp_sectors && (sc->max_sectors_per_req > tmp_sectors))
1782         sc->max_sectors_per_req = tmp_sectors;
1783
1784     if (ctrl_info)
1785         kfree(ctrl_info, M_MRSAS);
1786
1787     return(0);
1788 }
1789
1790 /**
1791  * mrsas_init_adapter:     Initializes the adapter/controller
1792  * input:                  Adapter soft state
1793  *
1794  * Prepares for the issuing of the IOC Init cmd to FW for initializing the
1795  * ROC/controller.  The FW register is read to determined the number of
1796  * commands that is supported.  All memory allocations for IO is based on
1797  * max_cmd.  Appropriate calculations are performed in this function.
1798  */
1799 int mrsas_init_adapter(struct mrsas_softc *sc)
1800 {
1801     uint32_t status;
1802     u_int32_t max_cmd;
1803     int ret;
1804
1805     /* Read FW status register */
1806     status = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_scratch_pad));
1807
1808     /* Get operational params from status register */
1809     sc->max_fw_cmds = status & MRSAS_FWSTATE_MAXCMD_MASK;
1810
1811     /* Decrement the max supported by 1, to correlate with FW */
1812     sc->max_fw_cmds = sc->max_fw_cmds-1;
1813     max_cmd = sc->max_fw_cmds;
1814
1815     /* Determine allocation size of command frames */
1816     sc->reply_q_depth = ((max_cmd *2 +1 +15)/16*16);
1817     sc->request_alloc_sz = sizeof(MRSAS_REQUEST_DESCRIPTOR_UNION) * max_cmd;
1818     sc->reply_alloc_sz = sizeof(MPI2_REPLY_DESCRIPTORS_UNION) * (sc->reply_q_depth);
1819     sc->io_frames_alloc_sz = MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE + (MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * (max_cmd + 1));
1820     sc->chain_frames_alloc_sz = 1024 * max_cmd;
1821     sc->max_sge_in_main_msg = (MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE -
1822         offsetof(MRSAS_RAID_SCSI_IO_REQUEST, SGL))/16;
1823
1824     sc->max_sge_in_chain = MRSAS_MAX_SZ_CHAIN_FRAME / sizeof(MPI2_SGE_IO_UNION);
1825     sc->max_num_sge = sc->max_sge_in_main_msg + sc->max_sge_in_chain - 2;
1826
1827     /* Used for pass thru MFI frame (DCMD) */
1828     sc->chain_offset_mfi_pthru = offsetof(MRSAS_RAID_SCSI_IO_REQUEST, SGL)/16;
1829
1830     sc->chain_offset_io_request = (MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE -
1831         sizeof(MPI2_SGE_IO_UNION))/16;
1832
1833     sc->last_reply_idx = 0;
1834
1835     ret = mrsas_alloc_mem(sc);
1836     if (ret != SUCCESS)
1837         return(ret);
1838
1839     ret = mrsas_alloc_mpt_cmds(sc);
1840     if (ret != SUCCESS)
1841         return(ret);
1842
1843     ret = mrsas_ioc_init(sc);
1844     if (ret != SUCCESS)
1845         return(ret);
1846
1847
1848     return(0);
1849 }
1850
1851 /**
1852  * mrsas_alloc_ioc_cmd:   Allocates memory for IOC Init command
1853  * input:                 Adapter soft state
1854  *
1855  * Allocates for the IOC Init cmd to FW to initialize the ROC/controller.
1856  */
1857 int mrsas_alloc_ioc_cmd(struct mrsas_softc *sc)
1858 {
1859     int ioc_init_size;
1860
1861     /* Allocate IOC INIT command */
1862     ioc_init_size = 1024 + sizeof(MPI2_IOC_INIT_REQUEST);
1863     if (bus_dma_tag_create( sc->mrsas_parent_tag,   // parent
1864                             1, 0,                   // algnmnt, boundary
1865                             BUS_SPACE_MAXADDR_32BIT,// lowaddr
1866                             BUS_SPACE_MAXADDR,      // highaddr
1867                             NULL, NULL,             // filter, filterarg
1868                             ioc_init_size,          // maxsize
1869                             1,                      // msegments
1870                             ioc_init_size,          // maxsegsize
1871                             BUS_DMA_ALLOCNOW,       // flags
1872                             &sc->ioc_init_tag)) {
1873         device_printf(sc->mrsas_dev, "Cannot allocate ioc init tag\n");
1874         return (ENOMEM);
1875     }
1876     if (bus_dmamem_alloc(sc->ioc_init_tag, (void **)&sc->ioc_init_mem,
1877             BUS_DMA_NOWAIT, &sc->ioc_init_dmamap)) {
1878         device_printf(sc->mrsas_dev, "Cannot allocate ioc init cmd mem\n");
1879         return (ENOMEM);
1880     }
1881     bzero(sc->ioc_init_mem, ioc_init_size);
1882     if (bus_dmamap_load(sc->ioc_init_tag, sc->ioc_init_dmamap,
1883             sc->ioc_init_mem, ioc_init_size, mrsas_addr_cb,
1884             &sc->ioc_init_phys_mem, BUS_DMA_NOWAIT)) {
1885         device_printf(sc->mrsas_dev, "Cannot load ioc init cmd mem\n");
1886         return (ENOMEM);
1887     }
1888
1889     return (0);
1890 }
1891
1892 /**
1893  * mrsas_free_ioc_cmd:   Allocates memory for IOC Init command
1894  * input:                Adapter soft state
1895  *
1896  * Deallocates memory of the IOC Init cmd.
1897  */
1898 void mrsas_free_ioc_cmd(struct mrsas_softc *sc)
1899 {
1900     if (sc->ioc_init_phys_mem)
1901         bus_dmamap_unload(sc->ioc_init_tag, sc->ioc_init_dmamap);
1902     if (sc->ioc_init_mem != NULL)
1903         bus_dmamem_free(sc->ioc_init_tag, sc->ioc_init_mem, sc->ioc_init_dmamap);
1904     if (sc->ioc_init_tag != NULL)
1905         bus_dma_tag_destroy(sc->ioc_init_tag);
1906 }
1907
1908 /**
1909  * mrsas_ioc_init:     Sends IOC Init command to FW
1910  * input:              Adapter soft state
1911  *
1912  * Issues the IOC Init cmd to FW to initialize the ROC/controller.
1913  */
1914 int mrsas_ioc_init(struct mrsas_softc *sc)
1915 {
1916     struct mrsas_init_frame *init_frame;
1917     pMpi2IOCInitRequest_t   IOCInitMsg;
1918     MRSAS_REQUEST_DESCRIPTOR_UNION req_desc;
1919     u_int8_t max_wait = MRSAS_IOC_INIT_WAIT_TIME;
1920     bus_addr_t phys_addr;
1921     int i, retcode = 0;
1922
1923     /* Allocate memory for the IOC INIT command */
1924     if (mrsas_alloc_ioc_cmd(sc)) {
1925         device_printf(sc->mrsas_dev, "Cannot allocate IOC command.\n");
1926         return(1);
1927     }
1928
1929     IOCInitMsg = (pMpi2IOCInitRequest_t)(((char *)sc->ioc_init_mem) +1024);
1930     IOCInitMsg->Function = MPI2_FUNCTION_IOC_INIT;
1931     IOCInitMsg->WhoInit = MPI2_WHOINIT_HOST_DRIVER;
1932     IOCInitMsg->MsgVersion = MPI2_VERSION;
1933     IOCInitMsg->HeaderVersion = MPI2_HEADER_VERSION;
1934     IOCInitMsg->SystemRequestFrameSize = MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE / 4;
1935     IOCInitMsg->ReplyDescriptorPostQueueDepth = sc->reply_q_depth;
1936     IOCInitMsg->ReplyDescriptorPostQueueAddress = sc->reply_desc_phys_addr;
1937     IOCInitMsg->SystemRequestFrameBaseAddress = sc->io_request_phys_addr;
1938
1939     init_frame = (struct mrsas_init_frame *)sc->ioc_init_mem;
1940     init_frame->cmd = MFI_CMD_INIT;
1941     init_frame->cmd_status = 0xFF;
1942     init_frame->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
1943
1944     if (sc->verbuf_mem) {
1945         ksnprintf((char *)sc->verbuf_mem, strlen(MRSAS_VERSION)+2,"%s\n",
1946                 MRSAS_VERSION);
1947         init_frame->driver_ver_lo = (bus_addr_t)sc->verbuf_phys_addr;
1948         init_frame->driver_ver_hi = 0;
1949     }
1950
1951     phys_addr = (bus_addr_t)sc->ioc_init_phys_mem + 1024;
1952     init_frame->queue_info_new_phys_addr_lo = phys_addr;
1953     init_frame->data_xfer_len = sizeof(Mpi2IOCInitRequest_t);
1954
1955     req_desc.addr.Words = (bus_addr_t)sc->ioc_init_phys_mem;
1956     req_desc.MFAIo.RequestFlags =
1957         (MRSAS_REQ_DESCRIPT_FLAGS_MFA << MRSAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1958
1959     mrsas_disable_intr(sc);
1960     mrsas_dprint(sc, MRSAS_OCR, "Issuing IOC INIT command to FW.\n");
1961     //device_printf(sc->mrsas_dev, "Issuing IOC INIT command to FW.\n");del?
1962     mrsas_fire_cmd(sc, req_desc.addr.u.low, req_desc.addr.u.high);
1963
1964     /*
1965      * Poll response timer to wait for Firmware response.  While this
1966      * timer with the DELAY call could block CPU, the time interval for
1967      * this is only 1 millisecond.
1968      */
1969     if (init_frame->cmd_status == 0xFF) {
1970         for (i=0; i < (max_wait * 1000); i++){
1971             if (init_frame->cmd_status == 0xFF)
1972                 DELAY(1000);
1973             else
1974                 break;
1975         }
1976     }
1977
1978     if (init_frame->cmd_status == 0)
1979          mrsas_dprint(sc, MRSAS_OCR,
1980                "IOC INIT response received from FW.\n");
1981          //device_printf(sc->mrsas_dev, "IOC INIT response received from FW.\n");del?
1982     else
1983     {
1984         if (init_frame->cmd_status == 0xFF)
1985             device_printf(sc->mrsas_dev, "IOC Init timed out after %d seconds.\n", max_wait);
1986         else
1987             device_printf(sc->mrsas_dev, "IOC Init failed, status = 0x%x\n", init_frame->cmd_status);
1988         retcode = 1;
1989     }
1990
1991     mrsas_free_ioc_cmd(sc);
1992     return (retcode);
1993 }
1994
1995 /**
1996  * mrsas_alloc_mpt_cmds:  Allocates the command packets
1997  * input:                 Adapter instance soft state
1998  *
1999  * This function allocates the internal commands for IOs. Each command that is
2000  * issued to FW is wrapped in a local data structure called mrsas_mpt_cmd.
2001  * An array is allocated with mrsas_mpt_cmd context.  The free commands are
2002  * maintained in a linked list (cmd pool). SMID value range is from 1 to
2003  * max_fw_cmds.
2004  */
2005 int mrsas_alloc_mpt_cmds(struct mrsas_softc *sc)
2006 {
2007     int i, j;
2008     u_int32_t max_cmd;
2009     struct mrsas_mpt_cmd *cmd;
2010     pMpi2ReplyDescriptorsUnion_t reply_desc;
2011     u_int32_t offset, chain_offset, sense_offset;
2012     bus_addr_t io_req_base_phys, chain_frame_base_phys, sense_base_phys;
2013     u_int8_t *io_req_base, *chain_frame_base, *sense_base;
2014
2015     max_cmd = sc->max_fw_cmds;
2016
2017     sc->req_desc = kmalloc(sc->request_alloc_sz, M_MRSAS, M_NOWAIT);
2018     if (!sc->req_desc) {
2019         device_printf(sc->mrsas_dev, "Out of memory, cannot alloc req desc\n");
2020         return(ENOMEM);
2021     }
2022     memset(sc->req_desc, 0, sc->request_alloc_sz);
2023
2024     /*
2025      * sc->mpt_cmd_list is an array of struct mrsas_mpt_cmd pointers. Allocate the
2026      * dynamic array first and then allocate individual commands.
2027      */
2028     sc->mpt_cmd_list = kmalloc(sizeof(struct mrsas_mpt_cmd*)*max_cmd, M_MRSAS, M_NOWAIT);
2029     if (!sc->mpt_cmd_list) {
2030         device_printf(sc->mrsas_dev, "Cannot alloc memory for mpt_cmd_list.\n");
2031         return(ENOMEM);
2032     }
2033     memset(sc->mpt_cmd_list, 0, sizeof(struct mrsas_mpt_cmd *)*max_cmd);
2034     for (i = 0; i < max_cmd; i++) {
2035         sc->mpt_cmd_list[i] = kmalloc(sizeof(struct mrsas_mpt_cmd),
2036                                  M_MRSAS, M_NOWAIT);
2037         if (!sc->mpt_cmd_list[i]) {
2038             for (j = 0; j < i; j++)
2039                 kfree(sc->mpt_cmd_list[j],M_MRSAS);
2040             kfree(sc->mpt_cmd_list, M_MRSAS);
2041             sc->mpt_cmd_list = NULL;
2042             return(ENOMEM);
2043         }
2044     }
2045
2046     io_req_base = (u_int8_t*)sc->io_request_mem + MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
2047     io_req_base_phys = (bus_addr_t)sc->io_request_phys_addr + MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
2048     chain_frame_base = (u_int8_t*)sc->chain_frame_mem;
2049     chain_frame_base_phys = (bus_addr_t)sc->chain_frame_phys_addr;
2050     sense_base = (u_int8_t*)sc->sense_mem;
2051     sense_base_phys = (bus_addr_t)sc->sense_phys_addr;
2052     for (i = 0; i < max_cmd; i++) {
2053         cmd = sc->mpt_cmd_list[i];
2054         offset = MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * i;
2055         chain_offset = 1024 * i;
2056         sense_offset = MRSAS_SENSE_LEN * i;
2057         memset(cmd, 0, sizeof(struct mrsas_mpt_cmd));
2058         cmd->index = i + 1;
2059         cmd->ccb_ptr = NULL;
2060         callout_init(&cmd->cm_callout);
2061         cmd->sync_cmd_idx = (u_int32_t)MRSAS_ULONG_MAX;
2062         cmd->sc = sc;
2063         cmd->io_request = (MRSAS_RAID_SCSI_IO_REQUEST *) (io_req_base + offset);
2064         memset(cmd->io_request, 0, sizeof(MRSAS_RAID_SCSI_IO_REQUEST));
2065         cmd->io_request_phys_addr = io_req_base_phys + offset;
2066         cmd->chain_frame = (MPI2_SGE_IO_UNION *) (chain_frame_base + chain_offset);
2067         cmd->chain_frame_phys_addr = chain_frame_base_phys + chain_offset;
2068         cmd->sense = sense_base + sense_offset;
2069         cmd->sense_phys_addr = sense_base_phys + sense_offset;
2070         if (bus_dmamap_create(sc->data_tag, 0, &cmd->data_dmamap)) {
2071             return(FAIL);
2072         }
2073         TAILQ_INSERT_TAIL(&(sc->mrsas_mpt_cmd_list_head), cmd, next);
2074     }
2075
2076     /* Initialize reply descriptor array to 0xFFFFFFFF */
2077     reply_desc = sc->reply_desc_mem;
2078     for (i = 0; i < sc->reply_q_depth; i++, reply_desc++) {
2079         reply_desc->Words = MRSAS_ULONG_MAX;
2080     }
2081     return(0);
2082 }
2083
2084 /**
2085  * mrsas_fire_cmd:     Sends command to FW
2086  * input:              Adapter soft state
2087  *                     request descriptor address low
2088  *                     request descriptor address high
2089  *
2090  * This functions fires the command to Firmware by writing to the
2091  * inbound_low_queue_port and inbound_high_queue_port.
2092  */
2093 void mrsas_fire_cmd(struct mrsas_softc *sc, u_int32_t req_desc_lo,
2094                    u_int32_t req_desc_hi)
2095 {
2096     lockmgr(&sc->pci_lock, LK_EXCLUSIVE);
2097     mrsas_write_reg(sc, offsetof(mrsas_reg_set, inbound_low_queue_port),
2098                     req_desc_lo);
2099     mrsas_write_reg(sc, offsetof(mrsas_reg_set, inbound_high_queue_port),
2100                     req_desc_hi);
2101     lockmgr(&sc->pci_lock, LK_RELEASE);
2102 }
2103
2104 /**
2105  * mrsas_transition_to_ready:  Move FW to Ready state
2106  * input:                      Adapter instance soft state
2107  *
2108  * During the initialization, FW passes can potentially be in any one of
2109  * several possible states. If the FW in operational, waiting-for-handshake
2110  * states, driver must take steps to bring it to ready state. Otherwise, it
2111  * has to wait for the ready state.
2112  */
2113 int mrsas_transition_to_ready(struct mrsas_softc *sc, int ocr)
2114 {
2115     int i;
2116     u_int8_t max_wait;
2117     u_int32_t val, fw_state;
2118     u_int32_t cur_state;
2119     u_int32_t abs_state, curr_abs_state;
2120
2121     val = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_scratch_pad));
2122     fw_state = val & MFI_STATE_MASK;
2123     max_wait = MRSAS_RESET_WAIT_TIME;
2124
2125     if (fw_state != MFI_STATE_READY)
2126         device_printf(sc->mrsas_dev, "Waiting for FW to come to ready state\n");
2127
2128     while (fw_state != MFI_STATE_READY) {
2129         abs_state = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_scratch_pad));
2130         switch (fw_state) {
2131             case MFI_STATE_FAULT:
2132                 device_printf(sc->mrsas_dev, "FW is in FAULT state!!\n");
2133                 if (ocr) {
2134                     cur_state = MFI_STATE_FAULT;
2135                     break;
2136                 }
2137         else
2138                         return -ENODEV;
2139             case MFI_STATE_WAIT_HANDSHAKE:
2140                 /* Set the CLR bit in inbound doorbell */
2141                 mrsas_write_reg(sc, offsetof(mrsas_reg_set, doorbell),
2142                         MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG);
2143                 cur_state = MFI_STATE_WAIT_HANDSHAKE;
2144                 break;
2145             case MFI_STATE_BOOT_MESSAGE_PENDING:
2146                 mrsas_write_reg(sc, offsetof(mrsas_reg_set, doorbell),
2147                         MFI_INIT_HOTPLUG);
2148                 cur_state = MFI_STATE_BOOT_MESSAGE_PENDING;
2149                 break;
2150             case MFI_STATE_OPERATIONAL:
2151                 /* Bring it to READY state; assuming max wait 10 secs */
2152                 mrsas_disable_intr(sc);
2153                 mrsas_write_reg(sc, offsetof(mrsas_reg_set, doorbell), MFI_RESET_FLAGS);
2154                 for (i=0; i < max_wait * 1000; i++) {
2155                     if (mrsas_read_reg(sc, offsetof(mrsas_reg_set, doorbell)) & 1)
2156                         DELAY(1000);
2157                     else
2158                         break;
2159                 }
2160                 cur_state = MFI_STATE_OPERATIONAL;
2161                 break;
2162             case MFI_STATE_UNDEFINED:
2163                 /* This state should not last for more than 2 seconds */
2164                 cur_state = MFI_STATE_UNDEFINED;
2165                 break;
2166             case MFI_STATE_BB_INIT:
2167                 cur_state = MFI_STATE_BB_INIT;
2168                 break;
2169             case MFI_STATE_FW_INIT:
2170                 cur_state = MFI_STATE_FW_INIT;
2171                 break;
2172             case MFI_STATE_FW_INIT_2:
2173                 cur_state = MFI_STATE_FW_INIT_2;
2174                 break;
2175             case MFI_STATE_DEVICE_SCAN:
2176                 cur_state = MFI_STATE_DEVICE_SCAN;
2177                 break;
2178             case MFI_STATE_FLUSH_CACHE:
2179                 cur_state = MFI_STATE_FLUSH_CACHE;
2180                 break;
2181             default:
2182                 device_printf(sc->mrsas_dev, "Unknown state 0x%x\n", fw_state);
2183                 return -ENODEV;
2184         }
2185
2186         /*
2187          * The cur_state should not last for more than max_wait secs
2188          */
2189         for (i = 0; i < (max_wait * 1000); i++) {
2190             fw_state = (mrsas_read_reg(sc, offsetof(mrsas_reg_set,
2191                     outbound_scratch_pad))& MFI_STATE_MASK);
2192             curr_abs_state = mrsas_read_reg(sc, offsetof(mrsas_reg_set,
2193                     outbound_scratch_pad));
2194             if (abs_state == curr_abs_state)
2195                 DELAY(1000);
2196             else
2197                 break;
2198         }
2199
2200         /*
2201          * Return error if fw_state hasn't changed after max_wait
2202          */
2203         if (curr_abs_state == abs_state) {
2204             device_printf(sc->mrsas_dev, "FW state [%d] hasn't changed "
2205                        "in %d secs\n", fw_state, max_wait);
2206             return -ENODEV;
2207         }
2208     }
2209     mrsas_dprint(sc, MRSAS_OCR, "FW now in Ready state\n");
2210     //device_printf(sc->mrsas_dev, "FW now in Ready state\n");del?
2211     return 0;
2212 }
2213
2214 /**
2215  * mrsas_get_mfi_cmd:      Get a cmd from free command pool
2216  * input:                  Adapter soft state
2217  *
2218  * This function removes an MFI command from the command list.
2219  */
2220 struct mrsas_mfi_cmd* mrsas_get_mfi_cmd(struct mrsas_softc *sc)
2221 {
2222     struct mrsas_mfi_cmd *cmd = NULL;
2223
2224     lockmgr(&sc->mfi_cmd_pool_lock, LK_EXCLUSIVE);
2225     if (!TAILQ_EMPTY(&sc->mrsas_mfi_cmd_list_head)){
2226         cmd = TAILQ_FIRST(&sc->mrsas_mfi_cmd_list_head);
2227         TAILQ_REMOVE(&sc->mrsas_mfi_cmd_list_head, cmd, next);
2228     }
2229     lockmgr(&sc->mfi_cmd_pool_lock, LK_RELEASE);
2230
2231     return cmd;
2232 }
2233
2234 /**
2235  * mrsas_ocr_thread             Thread to handle OCR/Kill Adapter.
2236  * input:               Adapter Context.
2237  *
2238  * This function will check FW status register and flag
2239  * do_timeout_reset flag. It will do OCR/Kill adapter if
2240  * FW is in fault state or IO timed out has trigger reset.
2241  */
2242 static void
2243 mrsas_ocr_thread(void *arg)
2244 {
2245     struct mrsas_softc *sc;
2246     u_int32_t  fw_status, fw_state;
2247
2248     sc = (struct mrsas_softc *)arg;
2249
2250     mrsas_dprint(sc, MRSAS_TRACE, "%s\n", __func__);
2251
2252     sc->ocr_thread_active = 1;
2253     lockmgr(&sc->sim_lock, LK_EXCLUSIVE);
2254     for (;;) {
2255         /* Sleep for 1 second and check the queue status*/
2256         lksleep(&sc->ocr_chan, &sc->sim_lock, 0,
2257                "mrsas_ocr", sc->mrsas_fw_fault_check_delay * hz);
2258         if (sc->remove_in_progress) {
2259             mrsas_dprint(sc, MRSAS_OCR,
2260                                 "Exit due to shutdown from %s\n", __func__);
2261             break;
2262         }
2263         fw_status = mrsas_read_reg(sc,
2264                                 offsetof(mrsas_reg_set, outbound_scratch_pad));
2265         fw_state = fw_status & MFI_STATE_MASK;
2266         if (fw_state == MFI_STATE_FAULT || sc->do_timedout_reset) {
2267             device_printf(sc->mrsas_dev, "OCR started due to %s!\n",
2268                  sc->do_timedout_reset?"IO Timeout":
2269                  "FW fault detected");
2270             spin_lock(&sc->ioctl_lock);
2271             sc->reset_in_progress = 1;
2272             sc->reset_count++;
2273             spin_unlock(&sc->ioctl_lock);
2274             mrsas_xpt_freeze(sc);
2275             mrsas_reset_ctrl(sc);
2276             mrsas_xpt_release(sc);
2277             sc->reset_in_progress = 0;
2278             sc->do_timedout_reset = 0;
2279         }
2280     }
2281     lockmgr(&sc->sim_lock, LK_RELEASE);
2282     sc->ocr_thread_active = 0;
2283     kthread_exit();
2284 }
2285
2286 /**
2287  * mrsas_reset_reply_desc       Reset Reply descriptor as part of OCR.
2288  * input:                       Adapter Context.
2289  *
2290  * This function will clear reply descriptor so that post OCR
2291  * driver and FW will lost old history.
2292  */
2293 void  mrsas_reset_reply_desc(struct mrsas_softc *sc)
2294 {
2295     int i;
2296     pMpi2ReplyDescriptorsUnion_t reply_desc;
2297
2298     sc->last_reply_idx = 0;
2299     reply_desc = sc->reply_desc_mem;
2300     for (i = 0; i < sc->reply_q_depth; i++, reply_desc++) {
2301         reply_desc->Words = MRSAS_ULONG_MAX;
2302     }
2303 }
2304
2305 /**
2306  * mrsas_reset_ctrl     Core function to OCR/Kill adapter.
2307  * input:               Adapter Context.
2308  *
2309  * This function will run from thread context so that it can sleep.
2310  * 1. Do not handle OCR if FW is in HW critical error.
2311  * 2. Wait for outstanding command to complete for 180 seconds.
2312  * 3. If #2 does not find any outstanding command Controller is in working
2313  * state, so skip OCR.
2314  * Otherwise, do OCR/kill Adapter based on flag disableOnlineCtrlReset.
2315  * 4. Start of the OCR, return all SCSI command back to CAM layer which has
2316  * ccb_ptr.
2317  * 5. Post OCR, Re-fire Managment command and move Controller to Operation
2318  * state.
2319  */
2320 int mrsas_reset_ctrl(struct mrsas_softc *sc)
2321 {
2322     int retval = SUCCESS, i, j, retry = 0;
2323     u_int32_t       host_diag, abs_state, status_reg, reset_adapter;
2324     union ccb   *ccb;
2325     struct mrsas_mfi_cmd *mfi_cmd;
2326     struct mrsas_mpt_cmd *mpt_cmd;
2327     MRSAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2328
2329     if (sc->adprecovery == MRSAS_HW_CRITICAL_ERROR) {
2330         device_printf(sc->mrsas_dev,
2331                         "mrsas: Hardware critical error, returning FAIL.\n");
2332         return FAIL;
2333     }
2334
2335     set_bit(MRSAS_FUSION_IN_RESET, &sc->reset_flags);
2336     sc->adprecovery = MRSAS_ADPRESET_SM_INFAULT;
2337     mrsas_disable_intr(sc);
2338     DELAY(1000 * 1000);
2339
2340     /* First try waiting for commands to complete */
2341     if (mrsas_wait_for_outstanding(sc)) {
2342         mrsas_dprint(sc, MRSAS_OCR,
2343                      "resetting adapter from %s.\n",
2344                       __func__);
2345         /* Now return commands back to the CAM layer */
2346         for (i = 0 ; i < sc->max_fw_cmds; i++) {
2347             mpt_cmd = sc->mpt_cmd_list[i];
2348             if (mpt_cmd->ccb_ptr) {
2349                 ccb = (union ccb *)(mpt_cmd->ccb_ptr);
2350                 ccb->ccb_h.status = CAM_SCSI_BUS_RESET;
2351                 mrsas_cmd_done(sc, mpt_cmd);
2352                 atomic_dec(&sc->fw_outstanding);
2353             }
2354         }
2355
2356         status_reg = mrsas_read_reg(sc, offsetof(mrsas_reg_set,
2357                                                            outbound_scratch_pad));
2358         abs_state = status_reg & MFI_STATE_MASK;
2359         reset_adapter = status_reg & MFI_RESET_ADAPTER;
2360         if (sc->disableOnlineCtrlReset ||
2361                         (abs_state == MFI_STATE_FAULT && !reset_adapter)) {
2362             /* Reset not supported, kill adapter */
2363             mrsas_dprint(sc, MRSAS_OCR,"Reset not supported, killing adapter.\n");
2364             mrsas_kill_hba(sc);
2365             sc->adprecovery = MRSAS_HW_CRITICAL_ERROR;
2366             retval = FAIL;
2367              goto out;
2368         }
2369
2370         /* Now try to reset the chip */
2371         for (i = 0; i < MRSAS_FUSION_MAX_RESET_TRIES; i++) {
2372             mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset),
2373                 MPI2_WRSEQ_FLUSH_KEY_VALUE);
2374             mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset),
2375                 MPI2_WRSEQ_1ST_KEY_VALUE);
2376             mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset),
2377                 MPI2_WRSEQ_2ND_KEY_VALUE);
2378             mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset),
2379                 MPI2_WRSEQ_3RD_KEY_VALUE);
2380             mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset),
2381                 MPI2_WRSEQ_4TH_KEY_VALUE);
2382             mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset),
2383                 MPI2_WRSEQ_5TH_KEY_VALUE);
2384             mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset),
2385                 MPI2_WRSEQ_6TH_KEY_VALUE);
2386
2387             /* Check that the diag write enable (DRWE) bit is on */
2388             host_diag = mrsas_read_reg(sc, offsetof(mrsas_reg_set,
2389                                                         fusion_host_diag));
2390             retry = 0;
2391             while (!(host_diag & HOST_DIAG_WRITE_ENABLE)) {
2392                 DELAY(100 * 1000);
2393                 host_diag = mrsas_read_reg(sc, offsetof(mrsas_reg_set,
2394                                                         fusion_host_diag));
2395                 if (retry++ == 100) {
2396                     mrsas_dprint(sc, MRSAS_OCR,
2397                     "Host diag unlock failed!\n");
2398                     break;
2399                 }
2400             }
2401             if (!(host_diag & HOST_DIAG_WRITE_ENABLE))
2402                 continue;
2403
2404             /* Send chip reset command */
2405             mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_host_diag),
2406                host_diag | HOST_DIAG_RESET_ADAPTER);
2407             DELAY(3000 * 1000);
2408
2409             /* Make sure reset adapter bit is cleared */
2410             host_diag = mrsas_read_reg(sc, offsetof(mrsas_reg_set,
2411                                                         fusion_host_diag));
2412             retry = 0;
2413             while (host_diag & HOST_DIAG_RESET_ADAPTER) {
2414                 DELAY(100 * 1000);
2415                 host_diag = mrsas_read_reg(sc, offsetof(mrsas_reg_set,
2416                                                         fusion_host_diag));
2417                 if (retry++ == 1000) {
2418                     mrsas_dprint(sc, MRSAS_OCR,
2419                                         "Diag reset adapter never cleared!\n");
2420                     break;
2421                 }
2422             }
2423             if (host_diag & HOST_DIAG_RESET_ADAPTER)
2424                 continue;
2425
2426             abs_state = mrsas_read_reg(sc, offsetof(mrsas_reg_set,
2427                                     outbound_scratch_pad)) & MFI_STATE_MASK;
2428             retry = 0;
2429
2430             while ((abs_state <= MFI_STATE_FW_INIT) && (retry++ < 1000)) {
2431                 DELAY(100 * 1000);
2432                 abs_state = mrsas_read_reg(sc, offsetof(mrsas_reg_set,
2433                                      outbound_scratch_pad)) & MFI_STATE_MASK;
2434             }
2435             if (abs_state <= MFI_STATE_FW_INIT) {
2436                 mrsas_dprint(sc, MRSAS_OCR, "firmware state < MFI_STATE_FW_INIT,"
2437                                 " state = 0x%x\n", abs_state);
2438                 continue;
2439             }
2440
2441             /* Wait for FW to become ready */
2442             if (mrsas_transition_to_ready(sc, 1)) {
2443                 mrsas_dprint(sc, MRSAS_OCR,
2444                            "mrsas: Failed to transition controller to ready.\n");
2445                 continue;
2446             }
2447
2448             mrsas_reset_reply_desc(sc);
2449             if (mrsas_ioc_init(sc)) {
2450                 mrsas_dprint(sc, MRSAS_OCR, "mrsas_ioc_init() failed!\n");
2451                 continue;
2452             }
2453
2454             clear_bit(MRSAS_FUSION_IN_RESET, &sc->reset_flags);
2455             mrsas_enable_intr(sc);
2456             sc->adprecovery = MRSAS_HBA_OPERATIONAL;
2457
2458             /* Re-fire management commands */
2459             for (j = 0 ; j < sc->max_fw_cmds; j++) {
2460                 mpt_cmd = sc->mpt_cmd_list[j];
2461                 if (mpt_cmd->sync_cmd_idx != (u_int32_t)MRSAS_ULONG_MAX) {
2462                     mfi_cmd = sc->mfi_cmd_list[mpt_cmd->sync_cmd_idx];
2463                     if (mfi_cmd->frame->dcmd.opcode ==
2464                                           MR_DCMD_LD_MAP_GET_INFO) {
2465                         mrsas_release_mfi_cmd(mfi_cmd);
2466                         mrsas_release_mpt_cmd(mpt_cmd);
2467                     } else  {
2468                         req_desc = mrsas_get_request_desc(sc,
2469                             mfi_cmd->cmd_id.context.smid - 1);
2470                         mrsas_dprint(sc, MRSAS_OCR,
2471                             "Re-fire command DCMD opcode 0x%x index %d\n ",
2472                              mfi_cmd->frame->dcmd.opcode, j);
2473                         if (!req_desc)
2474                             device_printf(sc->mrsas_dev,
2475                                           "Cannot build MPT cmd.\n");
2476                         else
2477                             mrsas_fire_cmd(sc, req_desc->addr.u.low,
2478                                                      req_desc->addr.u.high);
2479                     }
2480                 }
2481             }
2482
2483             /* Reset load balance info */
2484             memset(sc->load_balance_info, 0,
2485                    sizeof(LD_LOAD_BALANCE_INFO) * MAX_LOGICAL_DRIVES);
2486
2487             if (!mrsas_get_map_info(sc))
2488                 mrsas_sync_map_info(sc);
2489
2490             /* Adapter reset completed successfully */
2491             device_printf(sc->mrsas_dev, "Reset successful\n");
2492             retval = SUCCESS;
2493             goto out;
2494         }
2495         /* Reset failed, kill the adapter */
2496         device_printf(sc->mrsas_dev, "Reset failed, killing adapter.\n");
2497         mrsas_kill_hba(sc);
2498         retval = FAIL;
2499     } else {
2500         clear_bit(MRSAS_FUSION_IN_RESET, &sc->reset_flags);
2501         mrsas_enable_intr(sc);
2502         sc->adprecovery = MRSAS_HBA_OPERATIONAL;
2503     }
2504 out:
2505     clear_bit(MRSAS_FUSION_IN_RESET, &sc->reset_flags);
2506     mrsas_dprint(sc, MRSAS_OCR,
2507             "Reset Exit with %d.\n", retval);
2508     return retval;
2509 }
2510
2511 /**
2512  * mrsas_kill_hba       Kill HBA when OCR is not supported.
2513  * input:               Adapter Context.
2514  *
2515  * This function will kill HBA when OCR is not supported.
2516  */
2517 void mrsas_kill_hba (struct mrsas_softc *sc)
2518 {
2519     mrsas_dprint(sc, MRSAS_OCR, "%s\n", __func__);
2520     mrsas_write_reg(sc, offsetof(mrsas_reg_set, doorbell),
2521                         MFI_STOP_ADP);
2522     /* Flush */
2523     mrsas_read_reg(sc, offsetof(mrsas_reg_set, doorbell));
2524 }
2525
2526 /**
2527  * mrsas_wait_for_outstanding           Wait for outstanding commands
2528  * input:                               Adapter Context.
2529  *
2530  * This function will wait for 180 seconds for outstanding
2531  * commands to be completed.
2532  */
2533 int mrsas_wait_for_outstanding(struct mrsas_softc *sc)
2534 {
2535     int i, outstanding, retval = 0;
2536     u_int32_t fw_state;
2537
2538     for (i = 0; i < MRSAS_RESET_WAIT_TIME; i++) {
2539         if (sc->remove_in_progress) {
2540             mrsas_dprint(sc, MRSAS_OCR,
2541                 "Driver remove or shutdown called.\n");
2542             retval = 1;
2543             goto out;
2544         }
2545         /* Check if firmware is in fault state */
2546         fw_state = mrsas_read_reg(sc, offsetof(mrsas_reg_set,
2547                                   outbound_scratch_pad)) & MFI_STATE_MASK;
2548         if (fw_state == MFI_STATE_FAULT) {
2549             mrsas_dprint(sc, MRSAS_OCR,
2550                          "Found FW in FAULT state, will reset adapter.\n");
2551             retval = 1;
2552             goto out;
2553         }
2554         outstanding = atomic_read(&sc->fw_outstanding);
2555         if (!outstanding)
2556             goto out;
2557
2558         if (!(i % MRSAS_RESET_NOTICE_INTERVAL)) {
2559             mrsas_dprint(sc, MRSAS_OCR, "[%2d]waiting for %d "
2560                                 "commands to complete\n",i,outstanding);
2561             mrsas_complete_cmd(sc);
2562         }
2563         DELAY(1000 * 1000);
2564     }
2565
2566     if (atomic_read(&sc->fw_outstanding)) {
2567         mrsas_dprint(sc, MRSAS_OCR,
2568                         " pending commands remain after waiting,"
2569                         " will reset adapter.\n");
2570         retval = 1;
2571     }
2572 out:
2573     return retval;
2574 }
2575
2576 /**
2577  * mrsas_release_mfi_cmd: Return a cmd to free command pool
2578  * input:                 Command packet for return to free cmd pool
2579  *
2580  * This function returns the MFI command to the command list.
2581  */
2582 void mrsas_release_mfi_cmd(struct mrsas_mfi_cmd *cmd)
2583 {
2584     struct mrsas_softc *sc = cmd->sc;
2585
2586     lockmgr(&sc->mfi_cmd_pool_lock, LK_EXCLUSIVE);
2587     cmd->ccb_ptr = NULL;
2588         cmd->cmd_id.frame_count = 0;
2589     TAILQ_INSERT_TAIL(&(sc->mrsas_mfi_cmd_list_head), cmd, next);
2590     lockmgr(&sc->mfi_cmd_pool_lock, LK_RELEASE);
2591
2592     return;
2593 }
2594
2595 /**
2596  * mrsas_get_controller_info -        Returns FW's controller structure
2597  * input:                             Adapter soft state
2598  *                                    Controller information structure
2599  *
2600  * Issues an internal command (DCMD) to get the FW's controller structure.
2601  * This information is mainly used to find out the maximum IO transfer per
2602  * command supported by the FW.
2603  */
2604 static int mrsas_get_ctrl_info(struct mrsas_softc *sc,
2605                       struct mrsas_ctrl_info *ctrl_info)
2606 {
2607     int retcode = 0;
2608     struct mrsas_mfi_cmd *cmd;
2609     struct mrsas_dcmd_frame *dcmd;
2610
2611     cmd = mrsas_get_mfi_cmd(sc);
2612
2613     if (!cmd) {
2614         device_printf(sc->mrsas_dev, "Failed to get a free cmd\n");
2615         return -ENOMEM;
2616     }
2617     dcmd = &cmd->frame->dcmd;
2618
2619     if (mrsas_alloc_ctlr_info_cmd(sc) != SUCCESS) {
2620         device_printf(sc->mrsas_dev, "Cannot allocate get ctlr info cmd\n");
2621         mrsas_release_mfi_cmd(cmd);
2622         return -ENOMEM;
2623     }
2624     memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2625
2626     dcmd->cmd = MFI_CMD_DCMD;
2627     dcmd->cmd_status = 0xFF;
2628     dcmd->sge_count = 1;
2629     dcmd->flags = MFI_FRAME_DIR_READ;
2630     dcmd->timeout = 0;
2631     dcmd->pad_0 = 0;
2632     dcmd->data_xfer_len = sizeof(struct mrsas_ctrl_info);
2633     dcmd->opcode = MR_DCMD_CTRL_GET_INFO;
2634     dcmd->sgl.sge32[0].phys_addr = sc->ctlr_info_phys_addr;
2635     dcmd->sgl.sge32[0].length = sizeof(struct mrsas_ctrl_info);
2636
2637     if (!mrsas_issue_polled(sc, cmd))
2638         memcpy(ctrl_info, sc->ctlr_info_mem, sizeof(struct mrsas_ctrl_info));
2639     else
2640         retcode = 1;
2641
2642     mrsas_free_ctlr_info_cmd(sc);
2643     mrsas_release_mfi_cmd(cmd);
2644     return(retcode);
2645 }
2646
2647 /**
2648  * mrsas_alloc_ctlr_info_cmd:  Allocates memory for controller info command
2649  * input:                      Adapter soft state
2650  *
2651  * Allocates DMAable memory for the controller info internal command.
2652  */
2653 int mrsas_alloc_ctlr_info_cmd(struct mrsas_softc *sc)
2654 {
2655     int ctlr_info_size;
2656
2657     /* Allocate get controller info command */
2658     ctlr_info_size = sizeof(struct mrsas_ctrl_info);
2659     if (bus_dma_tag_create( sc->mrsas_parent_tag,   // parent
2660                             1, 0,                   // algnmnt, boundary
2661                             BUS_SPACE_MAXADDR_32BIT,// lowaddr
2662                             BUS_SPACE_MAXADDR,      // highaddr
2663                             NULL, NULL,             // filter, filterarg
2664                             ctlr_info_size,          // maxsize
2665                             1,                      // msegments
2666                             ctlr_info_size,          // maxsegsize
2667                             BUS_DMA_ALLOCNOW,       // flags
2668                             &sc->ctlr_info_tag)) {
2669         device_printf(sc->mrsas_dev, "Cannot allocate ctlr info tag\n");
2670         return (ENOMEM);
2671     }
2672     if (bus_dmamem_alloc(sc->ctlr_info_tag, (void **)&sc->ctlr_info_mem,
2673             BUS_DMA_NOWAIT, &sc->ctlr_info_dmamap)) {
2674         device_printf(sc->mrsas_dev, "Cannot allocate ctlr info cmd mem\n");
2675         return (ENOMEM);
2676     }
2677     if (bus_dmamap_load(sc->ctlr_info_tag, sc->ctlr_info_dmamap,
2678             sc->ctlr_info_mem, ctlr_info_size, mrsas_addr_cb,
2679             &sc->ctlr_info_phys_addr, BUS_DMA_NOWAIT)) {
2680         device_printf(sc->mrsas_dev, "Cannot load ctlr info cmd mem\n");
2681         return (ENOMEM);
2682     }
2683
2684     memset(sc->ctlr_info_mem, 0, ctlr_info_size);
2685     return (0);
2686 }
2687
2688 /**
2689  * mrsas_free_ctlr_info_cmd: Free memory for controller info command
2690  * input:                    Adapter soft state
2691  *
2692  * Deallocates memory of the get controller info cmd.
2693  */
2694 void mrsas_free_ctlr_info_cmd(struct mrsas_softc *sc)
2695 {
2696     if (sc->ctlr_info_phys_addr)
2697         bus_dmamap_unload(sc->ctlr_info_tag, sc->ctlr_info_dmamap);
2698     if (sc->ctlr_info_mem != NULL)
2699         bus_dmamem_free(sc->ctlr_info_tag, sc->ctlr_info_mem, sc->ctlr_info_dmamap);
2700     if (sc->ctlr_info_tag != NULL)
2701         bus_dma_tag_destroy(sc->ctlr_info_tag);
2702 }
2703
2704 /**
2705  * mrsas_issue_polled:        Issues a polling command
2706  * inputs:                    Adapter soft state
2707  *                            Command packet to be issued
2708  *
2709  * This function is for posting of internal commands to Firmware.  MFI
2710  * requires the cmd_status to be set to 0xFF before posting.  The maximun
2711  * wait time of the poll response timer is 180 seconds.
2712  */
2713 int mrsas_issue_polled(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd)
2714 {
2715     struct mrsas_header *frame_hdr = &cmd->frame->hdr;
2716     u_int8_t max_wait = MRSAS_INTERNAL_CMD_WAIT_TIME;
2717     int i, retcode = 0;
2718
2719     frame_hdr->cmd_status = 0xFF;
2720     frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
2721
2722     /* Issue the frame using inbound queue port */
2723     if (mrsas_issue_dcmd(sc, cmd)) {
2724         device_printf(sc->mrsas_dev, "Cannot issue DCMD internal command.\n");
2725         return(1);
2726     }
2727
2728     /*
2729      * Poll response timer to wait for Firmware response.  While this
2730      * timer with the DELAY call could block CPU, the time interval for
2731      * this is only 1 millisecond.
2732      */
2733     if (frame_hdr->cmd_status == 0xFF) {
2734         for (i=0; i < (max_wait * 1000); i++){
2735             if (frame_hdr->cmd_status == 0xFF)
2736                 DELAY(1000);
2737             else
2738                 break;
2739         }
2740     }
2741     if (frame_hdr->cmd_status != 0)
2742     {
2743         if (frame_hdr->cmd_status == 0xFF)
2744             device_printf(sc->mrsas_dev, "DCMD timed out after %d seconds.\n", max_wait);
2745         else
2746             device_printf(sc->mrsas_dev, "DCMD failed, status = 0x%x\n", frame_hdr->cmd_status);
2747         retcode = 1;
2748     }
2749     return(retcode);
2750 }
2751
2752 /**
2753  * mrsas_issue_dcmd -     Issues a MFI Pass thru cmd
2754  * input:                 Adapter soft state
2755  *                        mfi cmd pointer
2756  *
2757  * This function is called by mrsas_issued_blocked_cmd() and
2758  * mrsas_issued_polled(), to build the MPT command and then fire the
2759  * command to Firmware.
2760  */
2761 int
2762 mrsas_issue_dcmd(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd)
2763 {
2764     MRSAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2765
2766     req_desc = mrsas_build_mpt_cmd(sc, cmd);
2767     if (!req_desc) {
2768         device_printf(sc->mrsas_dev, "Cannot build MPT cmd.\n");
2769         return(1);
2770     }
2771
2772     mrsas_fire_cmd(sc, req_desc->addr.u.low, req_desc->addr.u.high);
2773
2774     return(0);
2775 }
2776
2777 /**
2778  * mrsas_build_mpt_cmd - Calls helper function to build Passthru cmd
2779  * input:                Adapter soft state
2780  *                       mfi cmd to build
2781  *
2782  * This function is called by mrsas_issue_cmd() to build the MPT-MFI
2783  * passthru command and prepares the MPT command to send to Firmware.
2784  */
2785 MRSAS_REQUEST_DESCRIPTOR_UNION *
2786 mrsas_build_mpt_cmd(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd)
2787 {
2788     MRSAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2789     u_int16_t index;
2790
2791     if (mrsas_build_mptmfi_passthru(sc, cmd)) {
2792         device_printf(sc->mrsas_dev, "Cannot build MPT-MFI passthru cmd.\n");
2793         return NULL;
2794     }
2795
2796     index = cmd->cmd_id.context.smid;
2797
2798     req_desc = mrsas_get_request_desc(sc, index-1);
2799     if(!req_desc)
2800         return NULL;
2801
2802     req_desc->addr.Words = 0;
2803     req_desc->SCSIIO.RequestFlags = (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO << MRSAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2804
2805     req_desc->SCSIIO.SMID = index;
2806
2807     return(req_desc);
2808 }
2809
2810 /**
2811  * mrsas_build_mptmfi_passthru - Builds a MPT MFI Passthru command
2812  * input:                        Adapter soft state
2813  *                               mfi cmd pointer
2814  *
2815  * The MPT command and the io_request are setup as a passthru command.
2816  * The SGE chain address is set to frame_phys_addr of the MFI command.
2817  */
2818 u_int8_t
2819 mrsas_build_mptmfi_passthru(struct mrsas_softc *sc, struct mrsas_mfi_cmd *mfi_cmd)
2820 {
2821     MPI25_IEEE_SGE_CHAIN64 *mpi25_ieee_chain;
2822     PTR_MRSAS_RAID_SCSI_IO_REQUEST io_req;
2823     struct mrsas_mpt_cmd *mpt_cmd;
2824     struct mrsas_header *frame_hdr = &mfi_cmd->frame->hdr;
2825
2826     mpt_cmd = mrsas_get_mpt_cmd(sc);
2827     if (!mpt_cmd)
2828         return(1);
2829
2830     /* Save the smid. To be used for returning the cmd */
2831     mfi_cmd->cmd_id.context.smid = mpt_cmd->index;
2832
2833     mpt_cmd->sync_cmd_idx = mfi_cmd->index;
2834
2835     /*
2836      * For cmds where the flag is set, store the flag and check
2837      * on completion. For cmds with this flag, don't call
2838      * mrsas_complete_cmd.
2839      */
2840
2841     if (frame_hdr->flags & MFI_FRAME_DONT_POST_IN_REPLY_QUEUE)
2842         mpt_cmd->flags = MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
2843
2844     io_req = mpt_cmd->io_request;
2845
2846     if ((sc->device_id == MRSAS_INVADER) || (sc->device_id == MRSAS_FURY)) {
2847                 pMpi25IeeeSgeChain64_t sgl_ptr_end = (pMpi25IeeeSgeChain64_t) &io_req->SGL;
2848                 sgl_ptr_end += sc->max_sge_in_main_msg - 1;
2849                 sgl_ptr_end->Flags = 0;
2850     }
2851
2852     mpi25_ieee_chain = (MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL.IeeeChain;
2853
2854     io_req->Function    = MRSAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST;
2855     io_req->SGLOffset0  = offsetof(MRSAS_RAID_SCSI_IO_REQUEST, SGL) / 4;
2856     io_req->ChainOffset = sc->chain_offset_mfi_pthru;
2857
2858     mpi25_ieee_chain->Address = mfi_cmd->frame_phys_addr;
2859
2860     mpi25_ieee_chain->Flags= IEEE_SGE_FLAGS_CHAIN_ELEMENT |
2861               MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR;
2862
2863     mpi25_ieee_chain->Length = MRSAS_MAX_SZ_CHAIN_FRAME;
2864
2865     return(0);
2866 }
2867
2868 /**
2869  * mrsas_issue_blocked_cmd - Synchronous wrapper around regular FW cmds
2870  * input:                    Adapter soft state
2871  *                           Command to be issued
2872  *
2873  * This function waits on an event for the command to be returned
2874  * from the ISR. Max wait time is MRSAS_INTERNAL_CMD_WAIT_TIME secs.
2875  * Used for issuing internal and ioctl commands.
2876  */
2877 int mrsas_issue_blocked_cmd(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd)
2878 {
2879     u_int8_t max_wait = MRSAS_INTERNAL_CMD_WAIT_TIME;
2880     unsigned long total_time = 0;
2881     int retcode = 0;
2882
2883     /* Initialize cmd_status */
2884     cmd->cmd_status = ECONNREFUSED;
2885
2886     /* Build MPT-MFI command for issue to FW */
2887     if (mrsas_issue_dcmd(sc, cmd)){
2888         device_printf(sc->mrsas_dev, "Cannot issue DCMD internal command.\n");
2889         return(1);
2890     }
2891
2892     sc->chan = (void*)&cmd;
2893
2894     /* The following is for debug only... */
2895     //device_printf(sc->mrsas_dev,"DCMD issued to FW, about to sleep-wait...\n");
2896     //device_printf(sc->mrsas_dev,"sc->chan = %p\n", sc->chan);
2897
2898     while (1) {
2899        if (cmd->cmd_status == ECONNREFUSED){
2900            tsleep((void *)&sc->chan, 0, "mrsas_sleep", hz);
2901        }
2902        else
2903            break;
2904        total_time++;
2905        if (total_time >= max_wait) {
2906            device_printf(sc->mrsas_dev, "Internal command timed out after %d seconds.\n", max_wait);
2907            retcode = 1;
2908            break;
2909        }
2910     }
2911     return(retcode);
2912 }
2913
2914 /**
2915  * mrsas_complete_mptmfi_passthru - Completes a command
2916  * input:                           sc: Adapter soft state
2917  *                                  cmd: Command to be completed
2918  *                                  status: cmd completion status
2919  *
2920  * This function is called from mrsas_complete_cmd() after an interrupt
2921  * is received from Firmware, and io_request->Function is
2922  * MRSAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST.
2923  */
2924 void
2925 mrsas_complete_mptmfi_passthru(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd,
2926                      u_int8_t status)
2927 {
2928     struct mrsas_header *hdr = &cmd->frame->hdr;
2929     u_int8_t cmd_status = cmd->frame->hdr.cmd_status;
2930
2931     /* Reset the retry counter for future re-tries */
2932     cmd->retry_for_fw_reset = 0;
2933
2934     if (cmd->ccb_ptr)
2935         cmd->ccb_ptr = NULL;
2936
2937     switch (hdr->cmd) {
2938         case MFI_CMD_INVALID:
2939             device_printf(sc->mrsas_dev, "MFI_CMD_INVALID command.\n");
2940             break;
2941         case MFI_CMD_PD_SCSI_IO:
2942         case MFI_CMD_LD_SCSI_IO:
2943             /*
2944              * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
2945              * issued either through an IO path or an IOCTL path. If it
2946              * was via IOCTL, we will send it to internal completion.
2947              */
2948             if (cmd->sync_cmd) {
2949                 cmd->sync_cmd = 0;
2950                 mrsas_wakeup(sc, cmd);
2951                 break;
2952             }
2953         case MFI_CMD_SMP:
2954         case MFI_CMD_STP:
2955         case MFI_CMD_DCMD:
2956             /* Check for LD map update */
2957             if ((cmd->frame->dcmd.opcode == MR_DCMD_LD_MAP_GET_INFO) &&
2958                 (cmd->frame->dcmd.mbox.b[1] == 1)) {
2959                 sc->fast_path_io = 0;
2960                         lockmgr(&sc->raidmap_lock, LK_EXCLUSIVE);
2961                 if (cmd_status != 0) {
2962                     if (cmd_status != MFI_STAT_NOT_FOUND)
2963                         device_printf(sc->mrsas_dev, "map sync failed, status=%x\n",cmd_status);
2964                     else {
2965                         mrsas_release_mfi_cmd(cmd);
2966                         lockmgr(&sc->raidmap_lock, LK_RELEASE);
2967                         break;
2968                     }
2969                 }
2970                 else
2971                     sc->map_id++;
2972                 mrsas_release_mfi_cmd(cmd);
2973                 if (MR_ValidateMapInfo(sc))
2974                     sc->fast_path_io = 0;
2975                 else
2976                     sc->fast_path_io = 1;
2977                 mrsas_sync_map_info(sc);
2978                 lockmgr(&sc->raidmap_lock, LK_RELEASE);
2979                 break;
2980             }
2981 #if 0 //currently not supporting event handling, so commenting out
2982             if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
2983                     cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET) {
2984                 mrsas_poll_wait_aen = 0;
2985             }
2986 #endif
2987             /* See if got an event notification */
2988             if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_WAIT)
2989                 mrsas_complete_aen(sc, cmd);
2990             else
2991                 mrsas_wakeup(sc, cmd);
2992             break;
2993         case MFI_CMD_ABORT:
2994             /* Command issued to abort another cmd return */
2995             mrsas_complete_abort(sc, cmd);
2996             break;
2997         default:
2998             device_printf(sc->mrsas_dev,"Unknown command completed! [0x%X]\n", hdr->cmd);
2999             break;
3000     }
3001 }
3002
3003 /**
3004  * mrsas_wakeup -         Completes an internal command
3005  * input:                 Adapter soft state
3006  *                        Command to be completed
3007  *
3008  * In mrsas_issue_blocked_cmd(), after a command is issued to Firmware,
3009  * a wait timer is started.  This function is called from
3010  * mrsas_complete_mptmfi_passthru() as it completes the command,
3011  * to wake up from the command wait.
3012  */
3013 void mrsas_wakeup(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd)
3014 {
3015     cmd->cmd_status = cmd->frame->io.cmd_status;
3016
3017     if (cmd->cmd_status == ECONNREFUSED)
3018         cmd->cmd_status = 0;
3019
3020     /* For debug only ... */
3021     //device_printf(sc->mrsas_dev,"DCMD rec'd for wakeup, sc->chan=%p\n", sc->chan);
3022
3023     sc->chan = (void*)&cmd;
3024     wakeup_one((void *)&sc->chan);
3025     return;
3026 }
3027
3028 /**
3029  * mrsas_shutdown_ctlr:       Instructs FW to shutdown the controller
3030  * input:                     Adapter soft state
3031  *                            Shutdown/Hibernate
3032  *
3033  * This function issues a DCMD internal command to Firmware to initiate
3034  * shutdown of the controller.
3035  */
3036 static void mrsas_shutdown_ctlr(struct mrsas_softc *sc, u_int32_t opcode)
3037 {
3038     struct mrsas_mfi_cmd *cmd;
3039     struct mrsas_dcmd_frame *dcmd;
3040
3041     if (sc->adprecovery == MRSAS_HW_CRITICAL_ERROR)
3042         return;
3043
3044     cmd = mrsas_get_mfi_cmd(sc);
3045     if (!cmd) {
3046         device_printf(sc->mrsas_dev,"Cannot allocate for shutdown cmd.\n");
3047         return;
3048     }
3049
3050         if (sc->aen_cmd)
3051         mrsas_issue_blocked_abort_cmd(sc, sc->aen_cmd);
3052
3053         if (sc->map_update_cmd)
3054         mrsas_issue_blocked_abort_cmd(sc, sc->map_update_cmd);
3055
3056     dcmd = &cmd->frame->dcmd;
3057     memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3058
3059     dcmd->cmd = MFI_CMD_DCMD;
3060     dcmd->cmd_status = 0x0;
3061     dcmd->sge_count = 0;
3062     dcmd->flags = MFI_FRAME_DIR_NONE;
3063     dcmd->timeout = 0;
3064     dcmd->pad_0 = 0;
3065     dcmd->data_xfer_len = 0;
3066     dcmd->opcode = opcode;
3067
3068     device_printf(sc->mrsas_dev,"Preparing to shut down controller.\n");
3069
3070     mrsas_issue_blocked_cmd(sc, cmd);
3071     mrsas_release_mfi_cmd(cmd);
3072
3073     return;
3074 }
3075
3076 /**
3077  * mrsas_flush_cache:         Requests FW to flush all its caches
3078  * input:                     Adapter soft state
3079  *
3080  * This function is issues a DCMD internal command to Firmware to initiate
3081  * flushing of all caches.
3082  */
3083 static void mrsas_flush_cache(struct mrsas_softc *sc)
3084 {
3085     struct mrsas_mfi_cmd *cmd;
3086     struct mrsas_dcmd_frame *dcmd;
3087
3088     if (sc->adprecovery == MRSAS_HW_CRITICAL_ERROR)
3089         return;
3090
3091     cmd = mrsas_get_mfi_cmd(sc);
3092     if (!cmd) {
3093         device_printf(sc->mrsas_dev,"Cannot allocate for flush cache cmd.\n");
3094         return;
3095     }
3096
3097     dcmd = &cmd->frame->dcmd;
3098     memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3099
3100     dcmd->cmd = MFI_CMD_DCMD;
3101     dcmd->cmd_status = 0x0;
3102     dcmd->sge_count = 0;
3103     dcmd->flags = MFI_FRAME_DIR_NONE;
3104     dcmd->timeout = 0;
3105     dcmd->pad_0 = 0;
3106     dcmd->data_xfer_len = 0;
3107     dcmd->opcode = MR_DCMD_CTRL_CACHE_FLUSH;
3108     dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
3109
3110     mrsas_issue_blocked_cmd(sc, cmd);
3111     mrsas_release_mfi_cmd(cmd);
3112
3113     return;
3114 }
3115
3116 /**
3117  * mrsas_get_map_info:        Load and validate RAID map
3118  * input:                     Adapter instance soft state
3119  *
3120  * This function calls mrsas_get_ld_map_info() and MR_ValidateMapInfo()
3121  * to load and validate RAID map.  It returns 0 if successful, 1 other-
3122  * wise.
3123  */
3124 static int mrsas_get_map_info(struct mrsas_softc *sc)
3125 {
3126    uint8_t  retcode = 0;
3127
3128     sc->fast_path_io = 0;
3129     if (!mrsas_get_ld_map_info(sc)) {
3130         retcode = MR_ValidateMapInfo(sc);
3131         if (retcode == 0) {
3132             sc->fast_path_io = 1;
3133             return 0;
3134         }
3135     }
3136     return 1;
3137 }
3138
3139 /**
3140  * mrsas_get_ld_map_info:      Get FW's ld_map structure
3141  * input:                      Adapter instance soft state
3142  *
3143  * Issues an internal command (DCMD) to get the FW's controller PD
3144  * list structure.
3145  */
3146 static int mrsas_get_ld_map_info(struct mrsas_softc *sc)
3147 {
3148     int retcode = 0;
3149     struct mrsas_mfi_cmd *cmd;
3150     struct mrsas_dcmd_frame *dcmd;
3151     MR_FW_RAID_MAP_ALL *map;
3152     bus_addr_t map_phys_addr = 0;
3153
3154     cmd = mrsas_get_mfi_cmd(sc);
3155     if (!cmd) {
3156         device_printf(sc->mrsas_dev, "Cannot alloc for ld map info cmd.\n");
3157         return 1;
3158     }
3159
3160     dcmd = &cmd->frame->dcmd;
3161
3162     map = sc->raidmap_mem[(sc->map_id & 1)];
3163     map_phys_addr = sc->raidmap_phys_addr[(sc->map_id & 1)];
3164     if (!map) {
3165         device_printf(sc->mrsas_dev, "Failed to alloc mem for ld map info.\n");
3166         mrsas_release_mfi_cmd(cmd);
3167         return (ENOMEM);
3168     }
3169     memset(map, 0, sizeof(*map));
3170     memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3171
3172     dcmd->cmd = MFI_CMD_DCMD;
3173     dcmd->cmd_status = 0xFF;
3174     dcmd->sge_count = 1;
3175     dcmd->flags = MFI_FRAME_DIR_READ;
3176     dcmd->timeout = 0;
3177     dcmd->pad_0 = 0;
3178     dcmd->data_xfer_len = sc->map_sz;
3179     dcmd->opcode = MR_DCMD_LD_MAP_GET_INFO;
3180     dcmd->sgl.sge32[0].phys_addr = map_phys_addr;
3181     dcmd->sgl.sge32[0].length = sc->map_sz;
3182     if (!mrsas_issue_polled(sc, cmd))
3183         retcode = 0;
3184     else
3185     {
3186         device_printf(sc->mrsas_dev, "Fail to send get LD map info cmd.\n");
3187         retcode = 1;
3188     }
3189     mrsas_release_mfi_cmd(cmd);
3190     return(retcode);
3191 }
3192
3193 /**
3194  * mrsas_sync_map_info:        Get FW's ld_map structure
3195  * input:                      Adapter instance soft state
3196  *
3197  * Issues an internal command (DCMD) to get the FW's controller PD
3198  * list structure.
3199  */
3200 static int mrsas_sync_map_info(struct mrsas_softc *sc)
3201 {
3202     int retcode = 0, i;
3203     struct mrsas_mfi_cmd *cmd;
3204     struct mrsas_dcmd_frame *dcmd;
3205     uint32_t size_sync_info, num_lds;
3206     MR_LD_TARGET_SYNC *target_map = NULL;
3207     MR_FW_RAID_MAP_ALL *map;
3208     MR_LD_RAID  *raid;
3209     MR_LD_TARGET_SYNC *ld_sync;
3210     bus_addr_t map_phys_addr = 0;
3211
3212     cmd = mrsas_get_mfi_cmd(sc);
3213     if (!cmd) {
3214         device_printf(sc->mrsas_dev, "Cannot alloc for sync map info cmd\n");
3215         return 1;
3216     }
3217
3218     map = sc->raidmap_mem[sc->map_id & 1];
3219     num_lds = map->raidMap.ldCount;
3220
3221     dcmd = &cmd->frame->dcmd;
3222     size_sync_info = sizeof(MR_LD_TARGET_SYNC) * num_lds;
3223     memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3224
3225     target_map = (MR_LD_TARGET_SYNC *)sc->raidmap_mem[(sc->map_id - 1) & 1];
3226     memset(target_map, 0, sizeof(MR_FW_RAID_MAP_ALL));
3227
3228     map_phys_addr = sc->raidmap_phys_addr[(sc->map_id - 1) & 1];
3229
3230     ld_sync = (MR_LD_TARGET_SYNC *)target_map;
3231
3232     for (i = 0; i < num_lds; i++, ld_sync++) {
3233         raid = MR_LdRaidGet(i, map);
3234         ld_sync->targetId = MR_GetLDTgtId(i, map);
3235         ld_sync->seqNum = raid->seqNum;
3236     }
3237
3238     dcmd->cmd = MFI_CMD_DCMD;
3239     dcmd->cmd_status = 0xFF;
3240     dcmd->sge_count = 1;
3241     dcmd->flags = MFI_FRAME_DIR_WRITE;
3242     dcmd->timeout = 0;
3243     dcmd->pad_0 = 0;
3244     dcmd->data_xfer_len = sc->map_sz;
3245     dcmd->mbox.b[0] = num_lds;
3246     dcmd->mbox.b[1] = MRSAS_DCMD_MBOX_PEND_FLAG;
3247     dcmd->opcode = MR_DCMD_LD_MAP_GET_INFO;
3248     dcmd->sgl.sge32[0].phys_addr = map_phys_addr;
3249     dcmd->sgl.sge32[0].length = sc->map_sz;
3250
3251     sc->map_update_cmd = cmd;
3252     if (mrsas_issue_dcmd(sc, cmd)) {
3253         device_printf(sc->mrsas_dev, "Fail to send sync map info command.\n");
3254         return(1);
3255     }
3256     return(retcode);
3257 }
3258
3259 /**
3260  * mrsas_get_pd_list:           Returns FW's PD list structure
3261  * input:                       Adapter soft state
3262  *
3263  * Issues an internal command (DCMD) to get the FW's controller PD
3264  * list structure.  This information is mainly used to find out about
3265  * system supported by Firmware.
3266  */
3267 static int mrsas_get_pd_list(struct mrsas_softc *sc)
3268 {
3269     int retcode = 0, pd_index = 0, pd_count=0, pd_list_size;
3270     struct mrsas_mfi_cmd *cmd;
3271     struct mrsas_dcmd_frame *dcmd;
3272     struct MR_PD_LIST *pd_list_mem;
3273     struct MR_PD_ADDRESS *pd_addr;
3274     bus_addr_t pd_list_phys_addr = 0;
3275     struct mrsas_tmp_dcmd *tcmd;
3276
3277     cmd = mrsas_get_mfi_cmd(sc);
3278     if (!cmd) {
3279         device_printf(sc->mrsas_dev, "Cannot alloc for get PD list cmd\n");
3280         return 1;
3281     }
3282
3283     dcmd = &cmd->frame->dcmd;
3284
3285     tcmd = kmalloc(sizeof(struct mrsas_tmp_dcmd), M_MRSAS, M_NOWAIT);
3286     pd_list_size = MRSAS_MAX_PD * sizeof(struct MR_PD_LIST);
3287     if (mrsas_alloc_tmp_dcmd(sc, tcmd, pd_list_size) != SUCCESS) {
3288         device_printf(sc->mrsas_dev, "Cannot alloc dmamap for get PD list cmd\n");
3289         mrsas_release_mfi_cmd(cmd);
3290         return(ENOMEM);
3291     }
3292     else {
3293         pd_list_mem = tcmd->tmp_dcmd_mem;
3294         pd_list_phys_addr = tcmd->tmp_dcmd_phys_addr;
3295     }
3296     memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3297
3298     dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
3299     dcmd->mbox.b[1] = 0;
3300     dcmd->cmd = MFI_CMD_DCMD;
3301     dcmd->cmd_status = 0xFF;
3302     dcmd->sge_count = 1;
3303     dcmd->flags = MFI_FRAME_DIR_READ;
3304     dcmd->timeout = 0;
3305     dcmd->pad_0 = 0;
3306     dcmd->data_xfer_len = MRSAS_MAX_PD * sizeof(struct MR_PD_LIST);
3307     dcmd->opcode = MR_DCMD_PD_LIST_QUERY;
3308     dcmd->sgl.sge32[0].phys_addr = pd_list_phys_addr;
3309     dcmd->sgl.sge32[0].length = MRSAS_MAX_PD * sizeof(struct MR_PD_LIST);
3310
3311     if (!mrsas_issue_polled(sc, cmd))
3312         retcode = 0;
3313     else
3314         retcode = 1;
3315
3316     /* Get the instance PD list */
3317     pd_count = MRSAS_MAX_PD;
3318     pd_addr = pd_list_mem->addr;
3319     if (retcode == 0 && pd_list_mem->count < pd_count) {
3320         memset(sc->local_pd_list, 0, MRSAS_MAX_PD * sizeof(struct mrsas_pd_list));
3321         for (pd_index = 0; pd_index < pd_list_mem->count; pd_index++) {
3322             sc->local_pd_list[pd_addr->deviceId].tid = pd_addr->deviceId;
3323             sc->local_pd_list[pd_addr->deviceId].driveType = pd_addr->scsiDevType;
3324             sc->local_pd_list[pd_addr->deviceId].driveState = MR_PD_STATE_SYSTEM;
3325             pd_addr++;
3326         }
3327     }
3328
3329     /* Use mutext/spinlock if pd_list component size increase more than 32 bit. */
3330     memcpy(sc->pd_list, sc->local_pd_list, sizeof(sc->local_pd_list));
3331     mrsas_free_tmp_dcmd(tcmd);
3332     mrsas_release_mfi_cmd(cmd);
3333     kfree(tcmd, M_MRSAS);
3334     return(retcode);
3335 }
3336
3337 /**
3338  * mrsas_get_ld_list:           Returns FW's LD list structure
3339  * input:                       Adapter soft state
3340  *
3341  * Issues an internal command (DCMD) to get the FW's controller PD
3342  * list structure.  This information is mainly used to find out about
3343  * supported by the FW.
3344  */
3345 static int mrsas_get_ld_list(struct mrsas_softc *sc)
3346 {
3347     int ld_list_size, retcode = 0, ld_index = 0, ids = 0;
3348     struct mrsas_mfi_cmd *cmd;
3349     struct mrsas_dcmd_frame *dcmd;
3350     struct MR_LD_LIST *ld_list_mem;
3351     bus_addr_t ld_list_phys_addr = 0;
3352     struct mrsas_tmp_dcmd *tcmd;
3353
3354     cmd = mrsas_get_mfi_cmd(sc);
3355     if (!cmd) {
3356         device_printf(sc->mrsas_dev, "Cannot alloc for get LD list cmd\n");
3357         return 1;
3358     }
3359
3360     dcmd = &cmd->frame->dcmd;
3361
3362     tcmd = kmalloc(sizeof(struct mrsas_tmp_dcmd), M_MRSAS, M_NOWAIT);
3363     ld_list_size = sizeof(struct MR_LD_LIST);
3364     if (mrsas_alloc_tmp_dcmd(sc, tcmd, ld_list_size) != SUCCESS) {
3365         device_printf(sc->mrsas_dev, "Cannot alloc dmamap for get LD list cmd\n");
3366         mrsas_release_mfi_cmd(cmd);
3367         return(ENOMEM);
3368     }
3369     else {
3370         ld_list_mem = tcmd->tmp_dcmd_mem;
3371         ld_list_phys_addr = tcmd->tmp_dcmd_phys_addr;
3372     }
3373     memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3374
3375     dcmd->cmd = MFI_CMD_DCMD;
3376     dcmd->cmd_status = 0xFF;
3377     dcmd->sge_count = 1;
3378     dcmd->flags = MFI_FRAME_DIR_READ;
3379     dcmd->timeout = 0;
3380     dcmd->data_xfer_len = sizeof(struct MR_LD_LIST);
3381     dcmd->opcode = MR_DCMD_LD_GET_LIST;
3382     dcmd->sgl.sge32[0].phys_addr = ld_list_phys_addr;
3383     dcmd->sgl.sge32[0].length = sizeof(struct MR_LD_LIST);
3384     dcmd->pad_0  = 0;
3385
3386     if (!mrsas_issue_polled(sc, cmd))
3387         retcode = 0;
3388     else
3389         retcode = 1;
3390
3391      /* Get the instance LD list */
3392      if ((retcode == 0) && (ld_list_mem->ldCount <= (MAX_LOGICAL_DRIVES))){
3393         sc->CurLdCount = ld_list_mem->ldCount;
3394         memset(sc->ld_ids, 0xff, MRSAS_MAX_LD);
3395         for (ld_index = 0; ld_index < ld_list_mem->ldCount; ld_index++) {
3396             if (ld_list_mem->ldList[ld_index].state != 0) {
3397                 ids = ld_list_mem->ldList[ld_index].ref.ld_context.targetId;
3398                 sc->ld_ids[ids] = ld_list_mem->ldList[ld_index].ref.ld_context.targetId;
3399             }
3400         }
3401     }
3402
3403     mrsas_free_tmp_dcmd(tcmd);
3404     mrsas_release_mfi_cmd(cmd);
3405     kfree(tcmd, M_MRSAS);
3406     return(retcode);
3407 }
3408
3409 /**
3410  * mrsas_alloc_tmp_dcmd:       Allocates memory for temporary command
3411  * input:                      Adapter soft state
3412  *                             Temp command
3413  *                             Size of alloction
3414  *
3415  * Allocates DMAable memory for a temporary internal command. The allocated
3416  * memory is initialized to all zeros upon successful loading of the dma
3417  * mapped memory.
3418  */
3419 int mrsas_alloc_tmp_dcmd(struct mrsas_softc *sc, struct mrsas_tmp_dcmd *tcmd,
3420           int size)
3421 {
3422     if (bus_dma_tag_create( sc->mrsas_parent_tag,   // parent
3423                             1, 0,                   // algnmnt, boundary
3424                             BUS_SPACE_MAXADDR_32BIT,// lowaddr
3425                             BUS_SPACE_MAXADDR,      // highaddr
3426                             NULL, NULL,             // filter, filterarg
3427                             size,                   // maxsize
3428                             1,                      // msegments
3429                             size,                   // maxsegsize
3430                             BUS_DMA_ALLOCNOW,       // flags
3431                             &tcmd->tmp_dcmd_tag)) {
3432         device_printf(sc->mrsas_dev, "Cannot allocate tmp dcmd tag\n");
3433         return (ENOMEM);
3434     }
3435     if (bus_dmamem_alloc(tcmd->tmp_dcmd_tag, (void **)&tcmd->tmp_dcmd_mem,
3436             BUS_DMA_NOWAIT, &tcmd->tmp_dcmd_dmamap)) {
3437         device_printf(sc->mrsas_dev, "Cannot allocate tmp dcmd mem\n");
3438         return (ENOMEM);
3439     }
3440     if (bus_dmamap_load(tcmd->tmp_dcmd_tag, tcmd->tmp_dcmd_dmamap,
3441             tcmd->tmp_dcmd_mem, size, mrsas_addr_cb,
3442             &tcmd->tmp_dcmd_phys_addr, BUS_DMA_NOWAIT)) {
3443         device_printf(sc->mrsas_dev, "Cannot load tmp dcmd mem\n");
3444         return (ENOMEM);
3445     }
3446
3447     memset(tcmd->tmp_dcmd_mem, 0, size);
3448     return (0);
3449 }
3450
3451 /**
3452  * mrsas_free_tmp_dcmd:      Free memory for temporary command
3453  * input:                    temporary dcmd pointer
3454  *
3455  * Deallocates memory of the temporary command for use in the construction
3456  * of the internal DCMD.
3457  */
3458 void mrsas_free_tmp_dcmd(struct mrsas_tmp_dcmd *tmp)
3459 {
3460     if (tmp->tmp_dcmd_phys_addr)
3461         bus_dmamap_unload(tmp->tmp_dcmd_tag, tmp->tmp_dcmd_dmamap);
3462     if (tmp->tmp_dcmd_mem != NULL)
3463         bus_dmamem_free(tmp->tmp_dcmd_tag, tmp->tmp_dcmd_mem, tmp->tmp_dcmd_dmamap);
3464     if (tmp->tmp_dcmd_tag != NULL)
3465         bus_dma_tag_destroy(tmp->tmp_dcmd_tag);
3466 }
3467
3468 /**
3469  * mrsas_issue_blocked_abort_cmd:       Aborts previously issued cmd
3470  * input:                               Adapter soft state
3471  *                                      Previously issued cmd to be aborted
3472  *
3473  * This function is used to abort previously issued commands, such as AEN and
3474  * RAID map sync map commands.  The abort command is sent as a DCMD internal
3475  * command and subsequently the driver will wait for a return status.  The
3476  * max wait time is MRSAS_INTERNAL_CMD_WAIT_TIME seconds.
3477  */
3478 static int mrsas_issue_blocked_abort_cmd(struct mrsas_softc *sc,
3479                                          struct mrsas_mfi_cmd *cmd_to_abort)
3480 {
3481     struct mrsas_mfi_cmd *cmd;
3482     struct mrsas_abort_frame *abort_fr;
3483     u_int8_t retcode = 0;
3484     unsigned long total_time = 0;
3485     u_int8_t max_wait = MRSAS_INTERNAL_CMD_WAIT_TIME;
3486
3487     cmd = mrsas_get_mfi_cmd(sc);
3488     if (!cmd) {
3489         device_printf(sc->mrsas_dev, "Cannot alloc for abort cmd\n");
3490         return(1);
3491     }
3492
3493     abort_fr = &cmd->frame->abort;
3494
3495     /* Prepare and issue the abort frame */
3496     abort_fr->cmd = MFI_CMD_ABORT;
3497     abort_fr->cmd_status = 0xFF;
3498     abort_fr->flags = 0;
3499     abort_fr->abort_context = cmd_to_abort->index;
3500     abort_fr->abort_mfi_phys_addr_lo = cmd_to_abort->frame_phys_addr;
3501     abort_fr->abort_mfi_phys_addr_hi = 0;
3502
3503     cmd->sync_cmd = 1;
3504     cmd->cmd_status = 0xFF;
3505
3506     if (mrsas_issue_dcmd(sc, cmd)) {
3507         device_printf(sc->mrsas_dev, "Fail to send abort command.\n");
3508         return(1);
3509     }
3510
3511     /* Wait for this cmd to complete */
3512     sc->chan = (void*)&cmd;
3513     while (1) {
3514        if (cmd->cmd_status == 0xFF){
3515            tsleep((void *)&sc->chan, 0, "mrsas_sleep", hz);
3516        }
3517        else
3518            break;
3519        total_time++;
3520        if (total_time >= max_wait) {
3521            device_printf(sc->mrsas_dev, "Abort cmd timed out after %d sec.\n", max_wait);
3522            retcode = 1;
3523            break;
3524        }
3525     }
3526
3527     cmd->sync_cmd = 0;
3528     mrsas_release_mfi_cmd(cmd);
3529     return(retcode);
3530 }
3531
3532 /**
3533  * mrsas_complete_abort:      Completes aborting a command
3534  * input:                     Adapter soft state
3535  *                            Cmd that was issued to abort another cmd
3536  *
3537  * The mrsas_issue_blocked_abort_cmd() function waits for the command status
3538  * to change after sending the command.  This function is called from
3539  * mrsas_complete_mptmfi_passthru() to wake up the sleep thread associated.
3540  */
3541 void mrsas_complete_abort(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd)
3542 {
3543     if (cmd->sync_cmd) {
3544         cmd->sync_cmd = 0;
3545         cmd->cmd_status = 0;
3546         sc->chan = (void*)&cmd;
3547         wakeup_one((void *)&sc->chan);
3548     }
3549     return;
3550 }
3551
3552 /**
3553  * mrsas_aen_handler:           Callback function for AEN processing from thread context.
3554  * input:                                       Adapter soft state
3555  *
3556  */
3557 void mrsas_aen_handler(struct mrsas_softc *sc)
3558 {
3559         union mrsas_evt_class_locale class_locale;
3560         int     doscan = 0;
3561         u_int32_t seq_num;
3562         int error;
3563
3564         if (!sc) {
3565                 device_printf(sc->mrsas_dev, "invalid instance!\n");
3566                 return;
3567         }
3568
3569         if (sc->evt_detail_mem) {
3570                 switch (sc->evt_detail_mem->code) {
3571                         case MR_EVT_PD_INSERTED:
3572                                 mrsas_get_pd_list(sc);
3573                                 mrsas_bus_scan_sim(sc, sc->sim_1);
3574                                 doscan = 0;
3575                                 break;
3576                         case MR_EVT_PD_REMOVED:
3577                                 mrsas_get_pd_list(sc);
3578                                 mrsas_bus_scan_sim(sc, sc->sim_1);
3579                                 doscan = 0;
3580                                 break;
3581                         case MR_EVT_LD_OFFLINE:
3582                         case MR_EVT_CFG_CLEARED:
3583                         case MR_EVT_LD_DELETED:
3584                                 mrsas_bus_scan_sim(sc, sc->sim_0);
3585                                 doscan = 0;
3586                                 break;
3587                         case MR_EVT_LD_CREATED:
3588                                 mrsas_get_ld_list(sc);
3589                                 mrsas_bus_scan_sim(sc, sc->sim_0);
3590                                 doscan = 0;
3591                                 break;
3592                         case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
3593                         case MR_EVT_FOREIGN_CFG_IMPORTED:
3594                         case MR_EVT_LD_STATE_CHANGE:
3595                                 doscan = 1;
3596                                 break;
3597                         default:
3598                                 doscan = 0;
3599                                 break;
3600                 }
3601         } else {
3602                 device_printf(sc->mrsas_dev, "invalid evt_detail\n");
3603                 return;
3604         }
3605         if (doscan) {
3606                 mrsas_get_pd_list(sc);
3607                 mrsas_dprint(sc, MRSAS_AEN, "scanning ...sim 1\n");
3608                 mrsas_bus_scan_sim(sc, sc->sim_1);
3609                 mrsas_get_ld_list(sc);
3610                 mrsas_dprint(sc, MRSAS_AEN, "scanning ...sim 0\n");
3611                 mrsas_bus_scan_sim(sc, sc->sim_0);
3612         }
3613
3614         seq_num = sc->evt_detail_mem->seq_num + 1;
3615
3616         // Register AEN with FW for latest sequence number plus 1
3617         class_locale.members.reserved = 0;
3618         class_locale.members.locale = MR_EVT_LOCALE_ALL;
3619         class_locale.members.class = MR_EVT_CLASS_DEBUG;
3620
3621         if (sc->aen_cmd != NULL )
3622                 return ;
3623
3624         lockmgr(&sc->aen_lock, LK_EXCLUSIVE);
3625         error = mrsas_register_aen(sc, seq_num,
3626                                         class_locale.word);
3627         lockmgr(&sc->aen_lock, LK_RELEASE);
3628
3629         if (error)
3630                 device_printf(sc->mrsas_dev, "register aen failed error %x\n", error);
3631
3632 }
3633
3634
3635 /**
3636  * mrsas_complete_aen:          Completes AEN command
3637  * input:                       Adapter soft state
3638  *                              Cmd that was issued to abort another cmd
3639  *
3640  *                                                              This function will be called from ISR and will continue
3641  *                                                              event processing from thread context by enqueuing task
3642  *                                                              in ev_tq (callback function "mrsas_aen_handler").
3643  */
3644 void mrsas_complete_aen(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd)
3645 {
3646         /*
3647         * Don't signal app if it is just an aborted previously registered aen
3648         */
3649         if ((!cmd->abort_aen) && (sc->remove_in_progress == 0)) {
3650                 /* TO DO (?) */
3651         }
3652         else
3653                 cmd->abort_aen = 0;
3654
3655         sc->aen_cmd = NULL;
3656         mrsas_release_mfi_cmd(cmd);
3657
3658         if (!sc->remove_in_progress)
3659                 taskqueue_enqueue(sc->ev_tq, &sc->ev_task);
3660
3661         return;
3662 }
3663
3664 static device_method_t mrsas_methods[] = {
3665     DEVMETHOD(device_probe,     mrsas_probe),
3666     DEVMETHOD(device_attach,    mrsas_attach),
3667     DEVMETHOD(device_detach,    mrsas_detach),
3668     DEVMETHOD(device_suspend,   mrsas_suspend),
3669     DEVMETHOD(device_resume,    mrsas_resume),
3670     DEVMETHOD(bus_print_child,  bus_generic_print_child),
3671     DEVMETHOD(bus_driver_added, bus_generic_driver_added),
3672     { 0, 0 }
3673 };
3674
3675 static driver_t mrsas_driver = {
3676     "mrsas",
3677     mrsas_methods,
3678     sizeof(struct mrsas_softc)
3679 };
3680
3681 static devclass_t       mrsas_devclass;
3682 DRIVER_MODULE(mrsas, pci, mrsas_driver, mrsas_devclass, NULL, NULL);
3683 MODULE_VERSION(mrsas, 1);
3684 MODULE_DEPEND(mrsas, cam, 1, 1, 1);
3685