sys/dev/mfi/mfi.c

   1 /*-
   2  * Copyright (c) 2006 IronPort Systems
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26 /*-
  27  * Copyright (c) 2007 LSI Corp.
  28  * Copyright (c) 2007 Rajesh Prabhakaran.
  29  * All rights reserved.
  30  *
  31  * Redistribution and use in source and binary forms, with or without
  32  * modification, are permitted provided that the following conditions
  33  * are met:
  34  * 1. Redistributions of source code must retain the above copyright
  35  *    notice, this list of conditions and the following disclaimer.
  36  * 2. Redistributions in binary form must reproduce the above copyright
  37  *    notice, this list of conditions and the following disclaimer in the
  38  *    documentation and/or other materials provided with the distribution.
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  50  * SUCH DAMAGE.
  51  */
  52
  53 #include <sys/cdefs.h>
  54 __FBSDID("$FreeBSD$");
  55
  56 #include "opt_compat.h"
  57 #include "opt_mfi.h"
  58
  59 #include <sys/param.h>
  60 #include <sys/systm.h>
  61 #include <sys/sysctl.h>
  62 #include <sys/malloc.h>
  63 #include <sys/kernel.h>
  64 #include <sys/poll.h>
  65 #include <sys/selinfo.h>
  66 #include <sys/bus.h>
  67 #include <sys/conf.h>
  68 #include <sys/eventhandler.h>
  69 #include <sys/rman.h>
  70 #include <sys/bus_dma.h>
  71 #include <sys/bio.h>
  72 #include <sys/ioccom.h>
  73 #include <sys/uio.h>
  74 #include <sys/proc.h>
  75 #include <sys/signalvar.h>
  76 #include <sys/sysent.h>
  77 #include <sys/taskqueue.h>
  78
  79 #include <machine/bus.h>
  80 #include <machine/resource.h>
  81
  82 #include <dev/mfi/mfireg.h>
  83 #include <dev/mfi/mfi_ioctl.h>
  84 #include <dev/mfi/mfivar.h>
  85 #include <sys/interrupt.h>
  86 #include <sys/priority.h>
  87
  88 static int      mfi_alloc_commands(struct mfi_softc *);
  89 static int      mfi_comms_init(struct mfi_softc *);
  90 static int      mfi_get_controller_info(struct mfi_softc *);
  91 static int      mfi_get_log_state(struct mfi_softc *,
  92                     struct mfi_evt_log_state **);
  93 static int      mfi_parse_entries(struct mfi_softc *, int, int);
  94 static void     mfi_data_cb(void *, bus_dma_segment_t *, int, int);
  95 static void     mfi_startup(void *arg);
  96 static void     mfi_intr(void *arg);
  97 static void     mfi_ldprobe(struct mfi_softc *sc);
  98 static void     mfi_syspdprobe(struct mfi_softc *sc);
  99 static void     mfi_handle_evt(void *context, int pending);
 100 static int      mfi_aen_register(struct mfi_softc *sc, int seq, int locale);
 101 static void     mfi_aen_complete(struct mfi_command *);
 102 static int      mfi_add_ld(struct mfi_softc *sc, int);
 103 static void     mfi_add_ld_complete(struct mfi_command *);
 104 static int      mfi_add_sys_pd(struct mfi_softc *sc, int);
 105 static void     mfi_add_sys_pd_complete(struct mfi_command *);
 106 static struct mfi_command * mfi_bio_command(struct mfi_softc *);
 107 static void     mfi_bio_complete(struct mfi_command *);
 108 static struct mfi_command *mfi_build_ldio(struct mfi_softc *,struct bio*);
 109 static struct mfi_command *mfi_build_syspdio(struct mfi_softc *,struct bio*);
 110 static int      mfi_send_frame(struct mfi_softc *, struct mfi_command *);
 111 static int      mfi_std_send_frame(struct mfi_softc *, struct mfi_command *);
 112 static int      mfi_abort(struct mfi_softc *, struct mfi_command **);
 113 static int      mfi_linux_ioctl_int(struct cdev *, u_long, caddr_t, int, struct thread *);
 114 static void     mfi_timeout(void *);
 115 static int      mfi_user_command(struct mfi_softc *,
 116                     struct mfi_ioc_passthru *);
 117 static void     mfi_enable_intr_xscale(struct mfi_softc *sc);
 118 static void     mfi_enable_intr_ppc(struct mfi_softc *sc);
 119 static int32_t  mfi_read_fw_status_xscale(struct mfi_softc *sc);
 120 static int32_t  mfi_read_fw_status_ppc(struct mfi_softc *sc);
 121 static int      mfi_check_clear_intr_xscale(struct mfi_softc *sc);
 122 static int      mfi_check_clear_intr_ppc(struct mfi_softc *sc);
 123 static void     mfi_issue_cmd_xscale(struct mfi_softc *sc, bus_addr_t bus_add,
 124                     uint32_t frame_cnt);
 125 static void     mfi_issue_cmd_ppc(struct mfi_softc *sc, bus_addr_t bus_add,
 126                     uint32_t frame_cnt);
 127 static int mfi_config_lock(struct mfi_softc *sc, uint32_t opcode);
 128 static void mfi_config_unlock(struct mfi_softc *sc, int locked);
 129 static int mfi_check_command_pre(struct mfi_softc *sc, struct mfi_command *cm);
 130 static void mfi_check_command_post(struct mfi_softc *sc, struct mfi_command *cm);
 131 static int mfi_check_for_sscd(struct mfi_softc *sc, struct mfi_command *cm);
 132
 133 SYSCTL_NODE(_hw, OID_AUTO, mfi, CTLFLAG_RD, 0, "MFI driver parameters");
 134 static int      mfi_event_locale = MFI_EVT_LOCALE_ALL;
 135 TUNABLE_INT("hw.mfi.event_locale", &mfi_event_locale);
 136 SYSCTL_INT(_hw_mfi, OID_AUTO, event_locale, CTLFLAG_RWTUN, &mfi_event_locale,
 137            0, "event message locale");
 138
 139 static int      mfi_event_class = MFI_EVT_CLASS_INFO;
 140 TUNABLE_INT("hw.mfi.event_class", &mfi_event_class);
 141 SYSCTL_INT(_hw_mfi, OID_AUTO, event_class, CTLFLAG_RWTUN, &mfi_event_class,
 142            0, "event message class");
 143
 144 static int      mfi_max_cmds = 128;
 145 TUNABLE_INT("hw.mfi.max_cmds", &mfi_max_cmds);
 146 SYSCTL_INT(_hw_mfi, OID_AUTO, max_cmds, CTLFLAG_RDTUN, &mfi_max_cmds,
 147            0, "Max commands limit (-1 = controller limit)");
 148
 149 static int      mfi_detect_jbod_change = 1;
 150 TUNABLE_INT("hw.mfi.detect_jbod_change", &mfi_detect_jbod_change);
 151 SYSCTL_INT(_hw_mfi, OID_AUTO, detect_jbod_change, CTLFLAG_RWTUN,
 152            &mfi_detect_jbod_change, 0, "Detect a change to a JBOD");
 153
 154 int             mfi_polled_cmd_timeout = MFI_POLL_TIMEOUT_SECS;
 155 TUNABLE_INT("hw.mfi.polled_cmd_timeout", &mfi_polled_cmd_timeout);
 156 SYSCTL_INT(_hw_mfi, OID_AUTO, polled_cmd_timeout, CTLFLAG_RWTUN,
 157            &mfi_polled_cmd_timeout, 0,
 158            "Polled command timeout - used for firmware flash etc (in seconds)");
 159
 160 static int      mfi_cmd_timeout = MFI_CMD_TIMEOUT;
 161 TUNABLE_INT("hw.mfi.cmd_timeout", &mfi_cmd_timeout);
 162 SYSCTL_INT(_hw_mfi, OID_AUTO, cmd_timeout, CTLFLAG_RWTUN, &mfi_cmd_timeout,
 163            0, "Command timeout (in seconds)");
 164
 165 /* Management interface */
 166 static d_open_t         mfi_open;
 167 static d_close_t        mfi_close;
 168 static d_ioctl_t        mfi_ioctl;
 169 static d_poll_t         mfi_poll;
 170
 171 static struct cdevsw mfi_cdevsw = {
 172         .d_version =    D_VERSION,
 173         .d_flags =      0,
 174         .d_open =       mfi_open,
 175         .d_close =      mfi_close,
 176         .d_ioctl =      mfi_ioctl,
 177         .d_poll =       mfi_poll,
 178         .d_name =       "mfi",
 179 };
 180
 181 MALLOC_DEFINE(M_MFIBUF, "mfibuf", "Buffers for the MFI driver");
 182
 183 #define MFI_INQ_LENGTH SHORT_INQUIRY_LENGTH
 184 struct mfi_skinny_dma_info mfi_skinny;
 185
 186 static void
 187 mfi_enable_intr_xscale(struct mfi_softc *sc)
 188 {
 189         MFI_WRITE4(sc, MFI_OMSK, 0x01);
 190 }
 191
 192 static void
 193 mfi_enable_intr_ppc(struct mfi_softc *sc)
 194 {
 195         if (sc->mfi_flags & MFI_FLAGS_1078) {
 196                 MFI_WRITE4(sc, MFI_ODCR0, 0xFFFFFFFF);
 197                 MFI_WRITE4(sc, MFI_OMSK, ~MFI_1078_EIM);
 198         }
 199         else if (sc->mfi_flags & MFI_FLAGS_GEN2) {
 200                 MFI_WRITE4(sc, MFI_ODCR0, 0xFFFFFFFF);
 201                 MFI_WRITE4(sc, MFI_OMSK, ~MFI_GEN2_EIM);
 202         }
 203         else if (sc->mfi_flags & MFI_FLAGS_SKINNY) {
 204                 MFI_WRITE4(sc, MFI_OMSK, ~0x00000001);
 205         }
 206 }
 207
 208 static int32_t
 209 mfi_read_fw_status_xscale(struct mfi_softc *sc)
 210 {
 211         return MFI_READ4(sc, MFI_OMSG0);
 212 }
 213
 214 static int32_t
 215 mfi_read_fw_status_ppc(struct mfi_softc *sc)
 216 {
 217         return MFI_READ4(sc, MFI_OSP0);
 218 }
 219
 220 static int
 221 mfi_check_clear_intr_xscale(struct mfi_softc *sc)
 222 {
 223         int32_t status;
 224
 225         status = MFI_READ4(sc, MFI_OSTS);
 226         if ((status & MFI_OSTS_INTR_VALID) == 0)
 227                 return 1;
 228
 229         MFI_WRITE4(sc, MFI_OSTS, status);
 230         return 0;
 231 }
 232
 233 static int
 234 mfi_check_clear_intr_ppc(struct mfi_softc *sc)
 235 {
 236         int32_t status;
 237
 238         status = MFI_READ4(sc, MFI_OSTS);
 239         if (sc->mfi_flags & MFI_FLAGS_1078) {
 240                 if (!(status & MFI_1078_RM)) {
 241                         return 1;
 242                 }
 243         }
 244         else if (sc->mfi_flags & MFI_FLAGS_GEN2) {
 245                 if (!(status & MFI_GEN2_RM)) {
 246                         return 1;
 247                 }
 248         }
 249         else if (sc->mfi_flags & MFI_FLAGS_SKINNY) {
 250                 if (!(status & MFI_SKINNY_RM)) {
 251                         return 1;
 252                 }
 253         }
 254         if (sc->mfi_flags & MFI_FLAGS_SKINNY)
 255                 MFI_WRITE4(sc, MFI_OSTS, status);
 256         else
 257                 MFI_WRITE4(sc, MFI_ODCR0, status);
 258         return 0;
 259 }
 260
 261 static void
 262 mfi_issue_cmd_xscale(struct mfi_softc *sc, bus_addr_t bus_add, uint32_t frame_cnt)
 263 {
 264         MFI_WRITE4(sc, MFI_IQP,(bus_add >>3)|frame_cnt);
 265 }
 266
 267 static void
 268 mfi_issue_cmd_ppc(struct mfi_softc *sc, bus_addr_t bus_add, uint32_t frame_cnt)
 269 {
 270         if (sc->mfi_flags & MFI_FLAGS_SKINNY) {
 271             MFI_WRITE4(sc, MFI_IQPL, (bus_add | frame_cnt <<1)|1 );
 272             MFI_WRITE4(sc, MFI_IQPH, 0x00000000);
 273         } else {
 274             MFI_WRITE4(sc, MFI_IQP, (bus_add | frame_cnt <<1)|1 );
 275         }
 276 }
 277
 278 int
 279 mfi_transition_firmware(struct mfi_softc *sc)
 280 {
 281         uint32_t fw_state, cur_state;
 282         int max_wait, i;
 283         uint32_t cur_abs_reg_val = 0;
 284         uint32_t prev_abs_reg_val = 0;
 285
 286         cur_abs_reg_val = sc->mfi_read_fw_status(sc);
 287         fw_state = cur_abs_reg_val & MFI_FWSTATE_MASK;
 288         while (fw_state != MFI_FWSTATE_READY) {
 289                 if (bootverbose)
 290                         device_printf(sc->mfi_dev, "Waiting for firmware to "
 291                         "become ready\n");
 292                 cur_state = fw_state;
 293                 switch (fw_state) {
 294                 case MFI_FWSTATE_FAULT:
 295                         device_printf(sc->mfi_dev, "Firmware fault\n");
 296                         return (ENXIO);
 297                 case MFI_FWSTATE_WAIT_HANDSHAKE:
 298                         if (sc->mfi_flags & MFI_FLAGS_SKINNY || sc->mfi_flags & MFI_FLAGS_TBOLT)
 299                             MFI_WRITE4(sc, MFI_SKINNY_IDB, MFI_FWINIT_CLEAR_HANDSHAKE);
 300                         else
 301                             MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_CLEAR_HANDSHAKE);
 302                         max_wait = MFI_RESET_WAIT_TIME;
 303                         break;
 304                 case MFI_FWSTATE_OPERATIONAL:
 305                         if (sc->mfi_flags & MFI_FLAGS_SKINNY || sc->mfi_flags & MFI_FLAGS_TBOLT)
 306                             MFI_WRITE4(sc, MFI_SKINNY_IDB, 7);
 307                         else
 308                             MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_READY);
 309                         max_wait = MFI_RESET_WAIT_TIME;
 310                         break;
 311                 case MFI_FWSTATE_UNDEFINED:
 312                 case MFI_FWSTATE_BB_INIT:
 313                         max_wait = MFI_RESET_WAIT_TIME;
 314                         break;
 315                 case MFI_FWSTATE_FW_INIT_2:
 316                         max_wait = MFI_RESET_WAIT_TIME;
 317                         break;
 318                 case MFI_FWSTATE_FW_INIT:
 319                 case MFI_FWSTATE_FLUSH_CACHE:
 320                         max_wait = MFI_RESET_WAIT_TIME;
 321                         break;
 322                 case MFI_FWSTATE_DEVICE_SCAN:
 323                         max_wait = MFI_RESET_WAIT_TIME; /* wait for 180 seconds */
 324                         prev_abs_reg_val = cur_abs_reg_val;
 325                         break;
 326                 case MFI_FWSTATE_BOOT_MESSAGE_PENDING:
 327                         if (sc->mfi_flags & MFI_FLAGS_SKINNY || sc->mfi_flags & MFI_FLAGS_TBOLT)
 328                             MFI_WRITE4(sc, MFI_SKINNY_IDB, MFI_FWINIT_HOTPLUG);
 329                         else
 330                             MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_HOTPLUG);
 331                         max_wait = MFI_RESET_WAIT_TIME;
 332                         break;
 333                 default:
 334                         device_printf(sc->mfi_dev, "Unknown firmware state %#x\n",
 335                             fw_state);
 336                         return (ENXIO);
 337                 }
 338                 for (i = 0; i < (max_wait * 10); i++) {
 339                         cur_abs_reg_val = sc->mfi_read_fw_status(sc);
 340                         fw_state = cur_abs_reg_val & MFI_FWSTATE_MASK;
 341                         if (fw_state == cur_state)
 342                                 DELAY(100000);
 343                         else
 344                                 break;
 345                 }
 346                 if (fw_state == MFI_FWSTATE_DEVICE_SCAN) {
 347                         /* Check the device scanning progress */
 348                         if (prev_abs_reg_val != cur_abs_reg_val) {
 349                                 continue;
 350                         }
 351                 }
 352                 if (fw_state == cur_state) {
 353                         device_printf(sc->mfi_dev, "Firmware stuck in state "
 354                             "%#x\n", fw_state);
 355                         return (ENXIO);
 356                 }
 357         }
 358         return (0);
 359 }
 360
 361 static void
 362 mfi_addr_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
 363 {
 364         bus_addr_t *addr;
 365
 366         addr = arg;
 367         *addr = segs[0].ds_addr;
 368 }
 369
 370
 371 int
 372 mfi_attach(struct mfi_softc *sc)
 373 {
 374         uint32_t status;
 375         int error, commsz, framessz, sensesz;
 376         int frames, unit, max_fw_sge, max_fw_cmds;
 377         uint32_t tb_mem_size = 0;
 378
 379         if (sc == NULL)
 380                 return EINVAL;
 381
 382         device_printf(sc->mfi_dev, "Megaraid SAS driver Ver %s \n",
 383             MEGASAS_VERSION);
 384
 385         mtx_init(&sc->mfi_io_lock, "MFI I/O lock", NULL, MTX_DEF);
 386         sx_init(&sc->mfi_config_lock, "MFI config");
 387         TAILQ_INIT(&sc->mfi_ld_tqh);
 388         TAILQ_INIT(&sc->mfi_syspd_tqh);
 389         TAILQ_INIT(&sc->mfi_ld_pend_tqh);
 390         TAILQ_INIT(&sc->mfi_syspd_pend_tqh);
 391         TAILQ_INIT(&sc->mfi_evt_queue);
 392         TASK_INIT(&sc->mfi_evt_task, 0, mfi_handle_evt, sc);
 393         TASK_INIT(&sc->mfi_map_sync_task, 0, mfi_handle_map_sync, sc);
 394         TAILQ_INIT(&sc->mfi_aen_pids);
 395         TAILQ_INIT(&sc->mfi_cam_ccbq);
 396
 397         mfi_initq_free(sc);
 398         mfi_initq_ready(sc);
 399         mfi_initq_busy(sc);
 400         mfi_initq_bio(sc);
 401
 402         sc->adpreset = 0;
 403         sc->last_seq_num = 0;
 404         sc->disableOnlineCtrlReset = 1;
 405         sc->issuepend_done = 1;
 406         sc->hw_crit_error = 0;
 407
 408         if (sc->mfi_flags & MFI_FLAGS_1064R) {
 409                 sc->mfi_enable_intr = mfi_enable_intr_xscale;
 410                 sc->mfi_read_fw_status = mfi_read_fw_status_xscale;
 411                 sc->mfi_check_clear_intr = mfi_check_clear_intr_xscale;
 412                 sc->mfi_issue_cmd = mfi_issue_cmd_xscale;
 413         } else if (sc->mfi_flags & MFI_FLAGS_TBOLT) {
 414                 sc->mfi_enable_intr = mfi_tbolt_enable_intr_ppc;
 415                 sc->mfi_disable_intr = mfi_tbolt_disable_intr_ppc;
 416                 sc->mfi_read_fw_status = mfi_tbolt_read_fw_status_ppc;
 417                 sc->mfi_check_clear_intr = mfi_tbolt_check_clear_intr_ppc;
 418                 sc->mfi_issue_cmd = mfi_tbolt_issue_cmd_ppc;
 419                 sc->mfi_adp_reset = mfi_tbolt_adp_reset;
 420                 sc->mfi_tbolt = 1;
 421                 TAILQ_INIT(&sc->mfi_cmd_tbolt_tqh);
 422         } else {
 423                 sc->mfi_enable_intr =  mfi_enable_intr_ppc;
 424                 sc->mfi_read_fw_status = mfi_read_fw_status_ppc;
 425                 sc->mfi_check_clear_intr = mfi_check_clear_intr_ppc;
 426                 sc->mfi_issue_cmd = mfi_issue_cmd_ppc;
 427         }
 428
 429
 430         /* Before we get too far, see if the firmware is working */
 431         if ((error = mfi_transition_firmware(sc)) != 0) {
 432                 device_printf(sc->mfi_dev, "Firmware not in READY state, "
 433                     "error %d\n", error);
 434                 return (ENXIO);
 435         }
 436
 437         /* Start: LSIP200113393 */
 438         if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 439                                 1, 0,                   /* algnmnt, boundary */
 440                                 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
 441                                 BUS_SPACE_MAXADDR,      /* highaddr */
 442                                 NULL, NULL,             /* filter, filterarg */
 443                                 MEGASAS_MAX_NAME*sizeof(bus_addr_t),                    /* maxsize */
 444                                 1,                      /* msegments */
 445                                 MEGASAS_MAX_NAME*sizeof(bus_addr_t),                    /* maxsegsize */
 446                                 0,                      /* flags */
 447                                 NULL, NULL,             /* lockfunc, lockarg */
 448                                 &sc->verbuf_h_dmat)) {
 449                 device_printf(sc->mfi_dev, "Cannot allocate verbuf_h_dmat DMA tag\n");
 450                 return (ENOMEM);
 451         }
 452         if (bus_dmamem_alloc(sc->verbuf_h_dmat, (void **)&sc->verbuf,
 453             BUS_DMA_NOWAIT, &sc->verbuf_h_dmamap)) {
 454                 device_printf(sc->mfi_dev, "Cannot allocate verbuf_h_dmamap memory\n");
 455                 return (ENOMEM);
 456         }
 457         bzero(sc->verbuf, MEGASAS_MAX_NAME*sizeof(bus_addr_t));
 458         bus_dmamap_load(sc->verbuf_h_dmat, sc->verbuf_h_dmamap,
 459             sc->verbuf, MEGASAS_MAX_NAME*sizeof(bus_addr_t),
 460             mfi_addr_cb, &sc->verbuf_h_busaddr, 0);
 461         /* End: LSIP200113393 */
 462
 463         /*
 464          * Get information needed for sizing the contiguous memory for the
 465          * frame pool.  Size down the sgl parameter since we know that
 466          * we will never need more than what's required for MAXPHYS.
 467          * It would be nice if these constants were available at runtime
 468          * instead of compile time.
 469          */
 470         status = sc->mfi_read_fw_status(sc);
 471         max_fw_cmds = status & MFI_FWSTATE_MAXCMD_MASK;
 472         if (mfi_max_cmds > 0 && mfi_max_cmds < max_fw_cmds) {
 473                 device_printf(sc->mfi_dev, "FW MaxCmds = %d, limiting to %d\n",
 474                     max_fw_cmds, mfi_max_cmds);
 475                 sc->mfi_max_fw_cmds = mfi_max_cmds;
 476         } else {
 477                 sc->mfi_max_fw_cmds = max_fw_cmds;
 478         }
 479         max_fw_sge = (status & MFI_FWSTATE_MAXSGL_MASK) >> 16;
 480         sc->mfi_max_sge = min(max_fw_sge, ((MFI_MAXPHYS / PAGE_SIZE) + 1));
 481
 482         /* ThunderBolt Support get the contiguous memory */
 483
 484         if (sc->mfi_flags & MFI_FLAGS_TBOLT) {
 485                 mfi_tbolt_init_globals(sc);
 486                 device_printf(sc->mfi_dev, "MaxCmd = %d, Drv MaxCmd = %d, "
 487                     "MaxSgl = %d, state = %#x\n", max_fw_cmds,
 488                     sc->mfi_max_fw_cmds, sc->mfi_max_sge, status);
 489                 tb_mem_size = mfi_tbolt_get_memory_requirement(sc);
 490
 491                 if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 492                                 1, 0,                   /* algnmnt, boundary */
 493                                 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
 494                                 BUS_SPACE_MAXADDR,      /* highaddr */
 495                                 NULL, NULL,             /* filter, filterarg */
 496                                 tb_mem_size,            /* maxsize */
 497                                 1,                      /* msegments */
 498                                 tb_mem_size,            /* maxsegsize */
 499                                 0,                      /* flags */
 500                                 NULL, NULL,             /* lockfunc, lockarg */
 501                                 &sc->mfi_tb_dmat)) {
 502                         device_printf(sc->mfi_dev, "Cannot allocate comms DMA tag\n");
 503                         return (ENOMEM);
 504                 }
 505                 if (bus_dmamem_alloc(sc->mfi_tb_dmat, (void **)&sc->request_message_pool,
 506                 BUS_DMA_NOWAIT, &sc->mfi_tb_dmamap)) {
 507                         device_printf(sc->mfi_dev, "Cannot allocate comms memory\n");
 508                         return (ENOMEM);
 509                 }
 510                 bzero(sc->request_message_pool, tb_mem_size);
 511                 bus_dmamap_load(sc->mfi_tb_dmat, sc->mfi_tb_dmamap,
 512                 sc->request_message_pool, tb_mem_size, mfi_addr_cb, &sc->mfi_tb_busaddr, 0);
 513
 514                 /* For ThunderBolt memory init */
 515                 if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 516                                 0x100, 0,               /* alignmnt, boundary */
 517                                 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
 518                                 BUS_SPACE_MAXADDR,      /* highaddr */
 519                                 NULL, NULL,             /* filter, filterarg */
 520                                 MFI_FRAME_SIZE,         /* maxsize */
 521                                 1,                      /* msegments */
 522                                 MFI_FRAME_SIZE,         /* maxsegsize */
 523                                 0,                      /* flags */
 524                                 NULL, NULL,             /* lockfunc, lockarg */
 525                                 &sc->mfi_tb_init_dmat)) {
 526                         device_printf(sc->mfi_dev, "Cannot allocate init DMA tag\n");
 527                         return (ENOMEM);
 528                 }
 529                 if (bus_dmamem_alloc(sc->mfi_tb_init_dmat, (void **)&sc->mfi_tb_init,
 530                     BUS_DMA_NOWAIT, &sc->mfi_tb_init_dmamap)) {
 531                         device_printf(sc->mfi_dev, "Cannot allocate init memory\n");
 532                         return (ENOMEM);
 533                 }
 534                 bzero(sc->mfi_tb_init, MFI_FRAME_SIZE);
 535                 bus_dmamap_load(sc->mfi_tb_init_dmat, sc->mfi_tb_init_dmamap,
 536                 sc->mfi_tb_init, MFI_FRAME_SIZE, mfi_addr_cb,
 537                     &sc->mfi_tb_init_busaddr, 0);
 538                 if (mfi_tbolt_init_desc_pool(sc, sc->request_message_pool,
 539                     tb_mem_size)) {
 540                         device_printf(sc->mfi_dev,
 541                             "Thunderbolt pool preparation error\n");
 542                         return 0;
 543                 }
 544
 545                 /*
 546                   Allocate DMA memory mapping for MPI2 IOC Init descriptor,
 547                   we are taking it diffrent from what we have allocated for Request
 548                   and reply descriptors to avoid confusion later
 549                 */
 550                 tb_mem_size = sizeof(struct MPI2_IOC_INIT_REQUEST);
 551                 if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 552                                 1, 0,                   /* algnmnt, boundary */
 553                                 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
 554                                 BUS_SPACE_MAXADDR,      /* highaddr */
 555                                 NULL, NULL,             /* filter, filterarg */
 556                                 tb_mem_size,            /* maxsize */
 557                                 1,                      /* msegments */
 558                                 tb_mem_size,            /* maxsegsize */
 559                                 0,                      /* flags */
 560                                 NULL, NULL,             /* lockfunc, lockarg */
 561                                 &sc->mfi_tb_ioc_init_dmat)) {
 562                         device_printf(sc->mfi_dev,
 563                             "Cannot allocate comms DMA tag\n");
 564                         return (ENOMEM);
 565                 }
 566                 if (bus_dmamem_alloc(sc->mfi_tb_ioc_init_dmat,
 567                     (void **)&sc->mfi_tb_ioc_init_desc,
 568                     BUS_DMA_NOWAIT, &sc->mfi_tb_ioc_init_dmamap)) {
 569                         device_printf(sc->mfi_dev, "Cannot allocate comms memory\n");
 570                         return (ENOMEM);
 571                 }
 572                 bzero(sc->mfi_tb_ioc_init_desc, tb_mem_size);
 573                 bus_dmamap_load(sc->mfi_tb_ioc_init_dmat, sc->mfi_tb_ioc_init_dmamap,
 574                 sc->mfi_tb_ioc_init_desc, tb_mem_size, mfi_addr_cb,
 575                     &sc->mfi_tb_ioc_init_busaddr, 0);
 576         }
 577         /*
 578          * Create the dma tag for data buffers.  Used both for block I/O
 579          * and for various internal data queries.
 580          */
 581         if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 582                                 1, 0,                   /* algnmnt, boundary */
 583                                 BUS_SPACE_MAXADDR,      /* lowaddr */
 584                                 BUS_SPACE_MAXADDR,      /* highaddr */
 585                                 NULL, NULL,             /* filter, filterarg */
 586                                 BUS_SPACE_MAXSIZE_32BIT,/* maxsize */
 587                                 sc->mfi_max_sge,        /* nsegments */
 588                                 BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */
 589                                 BUS_DMA_ALLOCNOW,       /* flags */
 590                                 busdma_lock_mutex,      /* lockfunc */
 591                                 &sc->mfi_io_lock,       /* lockfuncarg */
 592                                 &sc->mfi_buffer_dmat)) {
 593                 device_printf(sc->mfi_dev, "Cannot allocate buffer DMA tag\n");
 594                 return (ENOMEM);
 595         }
 596
 597         /*
 598          * Allocate DMA memory for the comms queues.  Keep it under 4GB for
 599          * efficiency.  The mfi_hwcomms struct includes space for 1 reply queue
 600          * entry, so the calculated size here will be will be 1 more than
 601          * mfi_max_fw_cmds.  This is apparently a requirement of the hardware.
 602          */
 603         commsz = (sizeof(uint32_t) * sc->mfi_max_fw_cmds) +
 604             sizeof(struct mfi_hwcomms);
 605         if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 606                                 1, 0,                   /* algnmnt, boundary */
 607                                 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
 608                                 BUS_SPACE_MAXADDR,      /* highaddr */
 609                                 NULL, NULL,             /* filter, filterarg */
 610                                 commsz,                 /* maxsize */
 611                                 1,                      /* msegments */
 612                                 commsz,                 /* maxsegsize */
 613                                 0,                      /* flags */
 614                                 NULL, NULL,             /* lockfunc, lockarg */
 615                                 &sc->mfi_comms_dmat)) {
 616                 device_printf(sc->mfi_dev, "Cannot allocate comms DMA tag\n");
 617                 return (ENOMEM);
 618         }
 619         if (bus_dmamem_alloc(sc->mfi_comms_dmat, (void **)&sc->mfi_comms,
 620             BUS_DMA_NOWAIT, &sc->mfi_comms_dmamap)) {
 621                 device_printf(sc->mfi_dev, "Cannot allocate comms memory\n");
 622                 return (ENOMEM);
 623         }
 624         bzero(sc->mfi_comms, commsz);
 625         bus_dmamap_load(sc->mfi_comms_dmat, sc->mfi_comms_dmamap,
 626             sc->mfi_comms, commsz, mfi_addr_cb, &sc->mfi_comms_busaddr, 0);
 627         /*
 628          * Allocate DMA memory for the command frames.  Keep them in the
 629          * lower 4GB for efficiency.  Calculate the size of the commands at
 630          * the same time; each command is one 64 byte frame plus a set of
 631          * additional frames for holding sg lists or other data.
 632          * The assumption here is that the SG list will start at the second
 633          * frame and not use the unused bytes in the first frame.  While this
 634          * isn't technically correct, it simplifies the calculation and allows
 635          * for command frames that might be larger than an mfi_io_frame.
 636          */
 637         if (sizeof(bus_addr_t) == 8) {
 638                 sc->mfi_sge_size = sizeof(struct mfi_sg64);
 639                 sc->mfi_flags |= MFI_FLAGS_SG64;
 640         } else {
 641                 sc->mfi_sge_size = sizeof(struct mfi_sg32);
 642         }
 643         if (sc->mfi_flags & MFI_FLAGS_SKINNY)
 644                 sc->mfi_sge_size = sizeof(struct mfi_sg_skinny);
 645         frames = (sc->mfi_sge_size * sc->mfi_max_sge - 1) / MFI_FRAME_SIZE + 2;
 646         sc->mfi_cmd_size = frames * MFI_FRAME_SIZE;
 647         framessz = sc->mfi_cmd_size * sc->mfi_max_fw_cmds;
 648         if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 649                                 64, 0,                  /* algnmnt, boundary */
 650                                 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
 651                                 BUS_SPACE_MAXADDR,      /* highaddr */
 652                                 NULL, NULL,             /* filter, filterarg */
 653                                 framessz,               /* maxsize */
 654                                 1,                      /* nsegments */
 655                                 framessz,               /* maxsegsize */
 656                                 0,                      /* flags */
 657                                 NULL, NULL,             /* lockfunc, lockarg */
 658                                 &sc->mfi_frames_dmat)) {
 659                 device_printf(sc->mfi_dev, "Cannot allocate frame DMA tag\n");
 660                 return (ENOMEM);
 661         }
 662         if (bus_dmamem_alloc(sc->mfi_frames_dmat, (void **)&sc->mfi_frames,
 663             BUS_DMA_NOWAIT, &sc->mfi_frames_dmamap)) {
 664                 device_printf(sc->mfi_dev, "Cannot allocate frames memory\n");
 665                 return (ENOMEM);
 666         }
 667         bzero(sc->mfi_frames, framessz);
 668         bus_dmamap_load(sc->mfi_frames_dmat, sc->mfi_frames_dmamap,
 669             sc->mfi_frames, framessz, mfi_addr_cb, &sc->mfi_frames_busaddr,0);
 670         /*
 671          * Allocate DMA memory for the frame sense data.  Keep them in the
 672          * lower 4GB for efficiency
 673          */
 674         sensesz = sc->mfi_max_fw_cmds * MFI_SENSE_LEN;
 675         if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 676                                 4, 0,                   /* algnmnt, boundary */
 677                                 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
 678                                 BUS_SPACE_MAXADDR,      /* highaddr */
 679                                 NULL, NULL,             /* filter, filterarg */
 680                                 sensesz,                /* maxsize */
 681                                 1,                      /* nsegments */
 682                                 sensesz,                /* maxsegsize */
 683                                 0,                      /* flags */
 684                                 NULL, NULL,             /* lockfunc, lockarg */
 685                                 &sc->mfi_sense_dmat)) {
 686                 device_printf(sc->mfi_dev, "Cannot allocate sense DMA tag\n");
 687                 return (ENOMEM);
 688         }
 689         if (bus_dmamem_alloc(sc->mfi_sense_dmat, (void **)&sc->mfi_sense,
 690             BUS_DMA_NOWAIT, &sc->mfi_sense_dmamap)) {
 691                 device_printf(sc->mfi_dev, "Cannot allocate sense memory\n");
 692                 return (ENOMEM);
 693         }
 694         bus_dmamap_load(sc->mfi_sense_dmat, sc->mfi_sense_dmamap,
 695             sc->mfi_sense, sensesz, mfi_addr_cb, &sc->mfi_sense_busaddr, 0);
 696         if ((error = mfi_alloc_commands(sc)) != 0)
 697                 return (error);
 698
 699         /* Before moving the FW to operational state, check whether
 700          * hostmemory is required by the FW or not
 701          */
 702
 703         /* ThunderBolt MFI_IOC2 INIT */
 704         if (sc->mfi_flags & MFI_FLAGS_TBOLT) {
 705                 sc->mfi_disable_intr(sc);
 706                 mtx_lock(&sc->mfi_io_lock);
 707                 if ((error = mfi_tbolt_init_MFI_queue(sc)) != 0) {
 708                         device_printf(sc->mfi_dev,
 709                             "TB Init has failed with error %d\n",error);
 710                         mtx_unlock(&sc->mfi_io_lock);
 711                         return error;
 712                 }
 713                 mtx_unlock(&sc->mfi_io_lock);
 714
 715                 if ((error = mfi_tbolt_alloc_cmd(sc)) != 0)
 716                         return error;
 717                 if (bus_setup_intr(sc->mfi_dev, sc->mfi_irq,
 718                     INTR_MPSAFE|INTR_TYPE_BIO, NULL, mfi_intr_tbolt, sc,
 719                     &sc->mfi_intr)) {
 720                         device_printf(sc->mfi_dev, "Cannot set up interrupt\n");
 721                         return (EINVAL);
 722                 }
 723                 sc->mfi_intr_ptr = mfi_intr_tbolt;
 724                 sc->mfi_enable_intr(sc);
 725         } else {
 726                 if ((error = mfi_comms_init(sc)) != 0)
 727                         return (error);
 728
 729                 if (bus_setup_intr(sc->mfi_dev, sc->mfi_irq,
 730                     INTR_MPSAFE|INTR_TYPE_BIO, NULL, mfi_intr, sc, &sc->mfi_intr)) {
 731                         device_printf(sc->mfi_dev, "Cannot set up interrupt\n");
 732                         return (EINVAL);
 733                 }
 734                 sc->mfi_intr_ptr = mfi_intr;
 735                 sc->mfi_enable_intr(sc);
 736         }
 737         if ((error = mfi_get_controller_info(sc)) != 0)
 738                 return (error);
 739         sc->disableOnlineCtrlReset = 0;
 740
 741         /* Register a config hook to probe the bus for arrays */
 742         sc->mfi_ich.ich_func = mfi_startup;
 743         sc->mfi_ich.ich_arg = sc;
 744         if (config_intrhook_establish(&sc->mfi_ich) != 0) {
 745                 device_printf(sc->mfi_dev, "Cannot establish configuration "
 746                     "hook\n");
 747                 return (EINVAL);
 748         }
 749         mtx_lock(&sc->mfi_io_lock);
 750         if ((error = mfi_aen_setup(sc, 0), 0) != 0) {
 751                 mtx_unlock(&sc->mfi_io_lock);
 752                 return (error);
 753         }
 754         mtx_unlock(&sc->mfi_io_lock);
 755
 756         /*
 757          * Register a shutdown handler.
 758          */
 759         if ((sc->mfi_eh = EVENTHANDLER_REGISTER(shutdown_final, mfi_shutdown,
 760             sc, SHUTDOWN_PRI_DEFAULT)) == NULL) {
 761                 device_printf(sc->mfi_dev, "Warning: shutdown event "
 762                     "registration failed\n");
 763         }
 764
 765         /*
 766          * Create the control device for doing management
 767          */
 768         unit = device_get_unit(sc->mfi_dev);
 769         sc->mfi_cdev = make_dev(&mfi_cdevsw, unit, UID_ROOT, GID_OPERATOR,
 770             0640, "mfi%d", unit);
 771         if (unit == 0)
 772                 make_dev_alias(sc->mfi_cdev, "megaraid_sas_ioctl_node");
 773         if (sc->mfi_cdev != NULL)
 774                 sc->mfi_cdev->si_drv1 = sc;
 775         SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->mfi_dev),
 776             SYSCTL_CHILDREN(device_get_sysctl_tree(sc->mfi_dev)),
 777             OID_AUTO, "delete_busy_volumes", CTLFLAG_RW,
 778             &sc->mfi_delete_busy_volumes, 0, "Allow removal of busy volumes");
 779         SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->mfi_dev),
 780             SYSCTL_CHILDREN(device_get_sysctl_tree(sc->mfi_dev)),
 781             OID_AUTO, "keep_deleted_volumes", CTLFLAG_RW,
 782             &sc->mfi_keep_deleted_volumes, 0,
 783             "Don't detach the mfid device for a busy volume that is deleted");
 784
 785         device_add_child(sc->mfi_dev, "mfip", -1);
 786         bus_generic_attach(sc->mfi_dev);
 787
 788         /* Start the timeout watchdog */
 789         callout_init(&sc->mfi_watchdog_callout, CALLOUT_MPSAFE);
 790         callout_reset(&sc->mfi_watchdog_callout, mfi_cmd_timeout * hz,
 791             mfi_timeout, sc);
 792
 793         if (sc->mfi_flags & MFI_FLAGS_TBOLT) {
 794                 mtx_lock(&sc->mfi_io_lock);
 795                 mfi_tbolt_sync_map_info(sc);
 796                 mtx_unlock(&sc->mfi_io_lock);
 797         }
 798
 799         return (0);
 800 }
 801
 802 static int
 803 mfi_alloc_commands(struct mfi_softc *sc)
 804 {
 805         struct mfi_command *cm;
 806         int i, j;
 807
 808         /*
 809          * XXX Should we allocate all the commands up front, or allocate on
 810          * demand later like 'aac' does?
 811          */
 812         sc->mfi_commands = malloc(sizeof(sc->mfi_commands[0]) *
 813             sc->mfi_max_fw_cmds, M_MFIBUF, M_WAITOK | M_ZERO);
 814
 815         for (i = 0; i < sc->mfi_max_fw_cmds; i++) {
 816                 cm = &sc->mfi_commands[i];
 817                 cm->cm_frame = (union mfi_frame *)((uintptr_t)sc->mfi_frames +
 818                     sc->mfi_cmd_size * i);
 819                 cm->cm_frame_busaddr = sc->mfi_frames_busaddr +
 820                     sc->mfi_cmd_size * i;
 821                 cm->cm_frame->header.context = i;
 822                 cm->cm_sense = &sc->mfi_sense[i];
 823                 cm->cm_sense_busaddr= sc->mfi_sense_busaddr + MFI_SENSE_LEN * i;
 824                 cm->cm_sc = sc;
 825                 cm->cm_index = i;
 826                 if (bus_dmamap_create(sc->mfi_buffer_dmat, 0,
 827                     &cm->cm_dmamap) == 0) {
 828                         mtx_lock(&sc->mfi_io_lock);
 829                         mfi_release_command(cm);
 830                         mtx_unlock(&sc->mfi_io_lock);
 831                 } else {
 832                         device_printf(sc->mfi_dev, "Failed to allocate %d "
 833                            "command blocks, only allocated %d\n",
 834                             sc->mfi_max_fw_cmds, i - 1);
 835                         for (j = 0; j < i; j++) {
 836                                 cm = &sc->mfi_commands[i];
 837                                 bus_dmamap_destroy(sc->mfi_buffer_dmat,
 838                                     cm->cm_dmamap);
 839                         }
 840                         free(sc->mfi_commands, M_MFIBUF);
 841                         sc->mfi_commands = NULL;
 842
 843                         return (ENOMEM);
 844                 }
 845         }
 846
 847         return (0);
 848 }
 849
 850 void
 851 mfi_release_command(struct mfi_command *cm)
 852 {
 853         struct mfi_frame_header *hdr;
 854         uint32_t *hdr_data;
 855
 856         mtx_assert(&cm->cm_sc->mfi_io_lock, MA_OWNED);
 857
 858         /*
 859          * Zero out the important fields of the frame, but make sure the
 860          * context field is preserved.  For efficiency, handle the fields
 861          * as 32 bit words.  Clear out the first S/G entry too for safety.
 862          */
 863         hdr = &cm->cm_frame->header;
 864         if (cm->cm_data != NULL && hdr->sg_count) {
 865                 cm->cm_sg->sg32[0].len = 0;
 866                 cm->cm_sg->sg32[0].addr = 0;
 867         }
 868
 869         /*
 870          * Command may be on other queues e.g. busy queue depending on the
 871          * flow of a previous call to mfi_mapcmd, so ensure its dequeued
 872          * properly
 873          */
 874         if ((cm->cm_flags & MFI_ON_MFIQ_BUSY) != 0)
 875                 mfi_remove_busy(cm);
 876         if ((cm->cm_flags & MFI_ON_MFIQ_READY) != 0)
 877                 mfi_remove_ready(cm);
 878
 879         /* We're not expecting it to be on any other queue but check */
 880         if ((cm->cm_flags & MFI_ON_MFIQ_MASK) != 0) {
 881                 panic("Command %p is still on another queue, flags = %#x",
 882                     cm, cm->cm_flags);
 883         }
 884
 885         /* tbolt cleanup */
 886         if ((cm->cm_flags & MFI_CMD_TBOLT) != 0) {
 887                 mfi_tbolt_return_cmd(cm->cm_sc,
 888                     cm->cm_sc->mfi_cmd_pool_tbolt[cm->cm_extra_frames - 1],
 889                     cm);
 890         }
 891
 892         hdr_data = (uint32_t *)cm->cm_frame;
 893         hdr_data[0] = 0;        /* cmd, sense_len, cmd_status, scsi_status */
 894         hdr_data[1] = 0;        /* target_id, lun_id, cdb_len, sg_count */
 895         hdr_data[4] = 0;        /* flags, timeout */
 896         hdr_data[5] = 0;        /* data_len */
 897
 898         cm->cm_extra_frames = 0;
 899         cm->cm_flags = 0;
 900         cm->cm_complete = NULL;
 901         cm->cm_private = NULL;
 902         cm->cm_data = NULL;
 903         cm->cm_sg = 0;
 904         cm->cm_total_frame_size = 0;
 905         cm->retry_for_fw_reset = 0;
 906
 907         mfi_enqueue_free(cm);
 908 }
 909
 910 int
 911 mfi_dcmd_command(struct mfi_softc *sc, struct mfi_command **cmp,
 912     uint32_t opcode, void **bufp, size_t bufsize)
 913 {
 914         struct mfi_command *cm;
 915         struct mfi_dcmd_frame *dcmd;
 916         void *buf = NULL;
 917         uint32_t context = 0;
 918
 919         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
 920
 921         cm = mfi_dequeue_free(sc);
 922         if (cm == NULL)
 923                 return (EBUSY);
 924
 925         /* Zero out the MFI frame */
 926         context = cm->cm_frame->header.context;
 927         bzero(cm->cm_frame, sizeof(union mfi_frame));
 928         cm->cm_frame->header.context = context;
 929
 930         if ((bufsize > 0) && (bufp != NULL)) {
 931                 if (*bufp == NULL) {
 932                         buf = malloc(bufsize, M_MFIBUF, M_NOWAIT|M_ZERO);
 933                         if (buf == NULL) {
 934                                 mfi_release_command(cm);
 935                                 return (ENOMEM);
 936                         }
 937                         *bufp = buf;
 938                 } else {
 939                         buf = *bufp;
 940                 }
 941         }
 942
 943         dcmd =  &cm->cm_frame->dcmd;
 944         bzero(dcmd->mbox, MFI_MBOX_SIZE);
 945         dcmd->header.cmd = MFI_CMD_DCMD;
 946         dcmd->header.timeout = 0;
 947         dcmd->header.flags = 0;
 948         dcmd->header.data_len = bufsize;
 949         dcmd->header.scsi_status = 0;
 950         dcmd->opcode = opcode;
 951         cm->cm_sg = &dcmd->sgl;
 952         cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE;
 953         cm->cm_flags = 0;
 954         cm->cm_data = buf;
 955         cm->cm_private = buf;
 956         cm->cm_len = bufsize;
 957
 958         *cmp = cm;
 959         if ((bufp != NULL) && (*bufp == NULL) && (buf != NULL))
 960                 *bufp = buf;
 961         return (0);
 962 }
 963
 964 static int
 965 mfi_comms_init(struct mfi_softc *sc)
 966 {
 967         struct mfi_command *cm;
 968         struct mfi_init_frame *init;
 969         struct mfi_init_qinfo *qinfo;
 970         int error;
 971         uint32_t context = 0;
 972
 973         mtx_lock(&sc->mfi_io_lock);
 974         if ((cm = mfi_dequeue_free(sc)) == NULL) {
 975                 mtx_unlock(&sc->mfi_io_lock);
 976                 return (EBUSY);
 977         }
 978
 979         /* Zero out the MFI frame */
 980         context = cm->cm_frame->header.context;
 981         bzero(cm->cm_frame, sizeof(union mfi_frame));
 982         cm->cm_frame->header.context = context;
 983
 984         /*
 985          * Abuse the SG list area of the frame to hold the init_qinfo
 986          * object;
 987          */
 988         init = &cm->cm_frame->init;
 989         qinfo = (struct mfi_init_qinfo *)((uintptr_t)init + MFI_FRAME_SIZE);
 990
 991         bzero(qinfo, sizeof(struct mfi_init_qinfo));
 992         qinfo->rq_entries = sc->mfi_max_fw_cmds + 1;
 993         qinfo->rq_addr_lo = sc->mfi_comms_busaddr +
 994             offsetof(struct mfi_hwcomms, hw_reply_q);
 995         qinfo->pi_addr_lo = sc->mfi_comms_busaddr +
 996             offsetof(struct mfi_hwcomms, hw_pi);
 997         qinfo->ci_addr_lo = sc->mfi_comms_busaddr +
 998             offsetof(struct mfi_hwcomms, hw_ci);
 999
1000         init->header.cmd = MFI_CMD_INIT;
1001         init->header.data_len = sizeof(struct mfi_init_qinfo);
1002         init->qinfo_new_addr_lo = cm->cm_frame_busaddr + MFI_FRAME_SIZE;
1003         cm->cm_data = NULL;
1004         cm->cm_flags = MFI_CMD_POLLED;
1005
1006         if ((error = mfi_mapcmd(sc, cm)) != 0)
1007                 device_printf(sc->mfi_dev, "failed to send init command\n");
1008         mfi_release_command(cm);
1009         mtx_unlock(&sc->mfi_io_lock);
1010
1011         return (error);
1012 }
1013
1014 static int
1015 mfi_get_controller_info(struct mfi_softc *sc)
1016 {
1017         struct mfi_command *cm = NULL;
1018         struct mfi_ctrl_info *ci = NULL;
1019         uint32_t max_sectors_1, max_sectors_2;
1020         int error;
1021
1022         mtx_lock(&sc->mfi_io_lock);
1023         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_GETINFO,
1024             (void **)&ci, sizeof(*ci));
1025         if (error)
1026                 goto out;
1027         cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
1028
1029         if ((error = mfi_mapcmd(sc, cm)) != 0) {
1030                 device_printf(sc->mfi_dev, "Failed to get controller info\n");
1031                 sc->mfi_max_io = (sc->mfi_max_sge - 1) * PAGE_SIZE /
1032                     MFI_SECTOR_LEN;
1033                 error = 0;
1034                 goto out;
1035         }
1036
1037         bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
1038             BUS_DMASYNC_POSTREAD);
1039         bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1040
1041         max_sectors_1 = (1 << ci->stripe_sz_ops.max) * ci->max_strips_per_io;
1042         max_sectors_2 = ci->max_request_size;
1043         sc->mfi_max_io = min(max_sectors_1, max_sectors_2);
1044         sc->disableOnlineCtrlReset =
1045             ci->properties.OnOffProperties.disableOnlineCtrlReset;
1046
1047 out:
1048         if (ci)
1049                 free(ci, M_MFIBUF);
1050         if (cm)
1051                 mfi_release_command(cm);
1052         mtx_unlock(&sc->mfi_io_lock);
1053         return (error);
1054 }
1055
1056 static int
1057 mfi_get_log_state(struct mfi_softc *sc, struct mfi_evt_log_state **log_state)
1058 {
1059         struct mfi_command *cm = NULL;
1060         int error;
1061
1062         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1063         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_EVENT_GETINFO,
1064             (void **)log_state, sizeof(**log_state));
1065         if (error)
1066                 goto out;
1067         cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
1068
1069         if ((error = mfi_mapcmd(sc, cm)) != 0) {
1070                 device_printf(sc->mfi_dev, "Failed to get log state\n");
1071                 goto out;
1072         }
1073
1074         bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
1075             BUS_DMASYNC_POSTREAD);
1076         bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1077
1078 out:
1079         if (cm)
1080                 mfi_release_command(cm);
1081
1082         return (error);
1083 }
1084
1085 int
1086 mfi_aen_setup(struct mfi_softc *sc, uint32_t seq_start)
1087 {
1088         struct mfi_evt_log_state *log_state = NULL;
1089         union mfi_evt class_locale;
1090         int error = 0;
1091         uint32_t seq;
1092
1093         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1094
1095         class_locale.members.reserved = 0;
1096         class_locale.members.locale = mfi_event_locale;
1097         class_locale.members.evt_class  = mfi_event_class;
1098
1099         if (seq_start == 0) {
1100                 if ((error = mfi_get_log_state(sc, &log_state)) != 0)
1101                         goto out;
1102                 sc->mfi_boot_seq_num = log_state->boot_seq_num;
1103
1104                 /*
1105                  * Walk through any events that fired since the last
1106                  * shutdown.
1107                  */
1108                 if ((error = mfi_parse_entries(sc, log_state->shutdown_seq_num,
1109                     log_state->newest_seq_num)) != 0)
1110                         goto out;
1111                 seq = log_state->newest_seq_num;
1112         } else
1113                 seq = seq_start;
1114         error = mfi_aen_register(sc, seq, class_locale.word);
1115 out:
1116         free(log_state, M_MFIBUF);
1117
1118         return (error);
1119 }
1120
1121 int
1122 mfi_wait_command(struct mfi_softc *sc, struct mfi_command *cm)
1123 {
1124
1125         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1126         cm->cm_complete = NULL;
1127
1128         /*
1129          * MegaCli can issue a DCMD of 0.  In this case do nothing
1130          * and return 0 to it as status
1131          */
1132         if (cm->cm_frame->dcmd.opcode == 0) {
1133                 cm->cm_frame->header.cmd_status = MFI_STAT_OK;
1134                 cm->cm_error = 0;
1135                 return (cm->cm_error);
1136         }
1137         mfi_enqueue_ready(cm);
1138         mfi_startio(sc);
1139         if ((cm->cm_flags & MFI_CMD_COMPLETED) == 0)
1140                 msleep(cm, &sc->mfi_io_lock, PRIBIO, "mfiwait", 0);
1141         return (cm->cm_error);
1142 }
1143
1144 void
1145 mfi_free(struct mfi_softc *sc)
1146 {
1147         struct mfi_command *cm;
1148         int i;
1149
1150         callout_drain(&sc->mfi_watchdog_callout);
1151
1152         if (sc->mfi_cdev != NULL)
1153                 destroy_dev(sc->mfi_cdev);
1154
1155         if (sc->mfi_commands != NULL) {
1156                 for (i = 0; i < sc->mfi_max_fw_cmds; i++) {
1157                         cm = &sc->mfi_commands[i];
1158                         bus_dmamap_destroy(sc->mfi_buffer_dmat, cm->cm_dmamap);
1159                 }
1160                 free(sc->mfi_commands, M_MFIBUF);
1161                 sc->mfi_commands = NULL;
1162         }
1163
1164         if (sc->mfi_intr)
1165                 bus_teardown_intr(sc->mfi_dev, sc->mfi_irq, sc->mfi_intr);
1166         if (sc->mfi_irq != NULL)
1167                 bus_release_resource(sc->mfi_dev, SYS_RES_IRQ, sc->mfi_irq_rid,
1168                     sc->mfi_irq);
1169
1170         if (sc->mfi_sense_busaddr != 0)
1171                 bus_dmamap_unload(sc->mfi_sense_dmat, sc->mfi_sense_dmamap);
1172         if (sc->mfi_sense != NULL)
1173                 bus_dmamem_free(sc->mfi_sense_dmat, sc->mfi_sense,
1174                     sc->mfi_sense_dmamap);
1175         if (sc->mfi_sense_dmat != NULL)
1176                 bus_dma_tag_destroy(sc->mfi_sense_dmat);
1177
1178         if (sc->mfi_frames_busaddr != 0)
1179                 bus_dmamap_unload(sc->mfi_frames_dmat, sc->mfi_frames_dmamap);
1180         if (sc->mfi_frames != NULL)
1181                 bus_dmamem_free(sc->mfi_frames_dmat, sc->mfi_frames,
1182                     sc->mfi_frames_dmamap);
1183         if (sc->mfi_frames_dmat != NULL)
1184                 bus_dma_tag_destroy(sc->mfi_frames_dmat);
1185
1186         if (sc->mfi_comms_busaddr != 0)
1187                 bus_dmamap_unload(sc->mfi_comms_dmat, sc->mfi_comms_dmamap);
1188         if (sc->mfi_comms != NULL)
1189                 bus_dmamem_free(sc->mfi_comms_dmat, sc->mfi_comms,
1190                     sc->mfi_comms_dmamap);
1191         if (sc->mfi_comms_dmat != NULL)
1192                 bus_dma_tag_destroy(sc->mfi_comms_dmat);
1193
1194         /* ThunderBolt contiguous memory free here */
1195         if (sc->mfi_flags & MFI_FLAGS_TBOLT) {
1196                 if (sc->mfi_tb_busaddr != 0)
1197                         bus_dmamap_unload(sc->mfi_tb_dmat, sc->mfi_tb_dmamap);
1198                 if (sc->request_message_pool != NULL)
1199                         bus_dmamem_free(sc->mfi_tb_dmat, sc->request_message_pool,
1200                             sc->mfi_tb_dmamap);
1201                 if (sc->mfi_tb_dmat != NULL)
1202                         bus_dma_tag_destroy(sc->mfi_tb_dmat);
1203
1204                 /* Version buffer memory free */
1205                 /* Start LSIP200113393 */
1206                 if (sc->verbuf_h_busaddr != 0)
1207                         bus_dmamap_unload(sc->verbuf_h_dmat, sc->verbuf_h_dmamap);
1208                 if (sc->verbuf != NULL)
1209                         bus_dmamem_free(sc->verbuf_h_dmat, sc->verbuf,
1210                             sc->verbuf_h_dmamap);
1211                 if (sc->verbuf_h_dmat != NULL)
1212                         bus_dma_tag_destroy(sc->verbuf_h_dmat);
1213
1214                 /* End LSIP200113393 */
1215                 /* ThunderBolt INIT packet memory Free */
1216                 if (sc->mfi_tb_init_busaddr != 0)
1217                         bus_dmamap_unload(sc->mfi_tb_init_dmat,
1218                             sc->mfi_tb_init_dmamap);
1219                 if (sc->mfi_tb_init != NULL)
1220                         bus_dmamem_free(sc->mfi_tb_init_dmat, sc->mfi_tb_init,
1221                             sc->mfi_tb_init_dmamap);
1222                 if (sc->mfi_tb_init_dmat != NULL)
1223                         bus_dma_tag_destroy(sc->mfi_tb_init_dmat);
1224
1225                 /* ThunderBolt IOC Init Desc memory free here */
1226                 if (sc->mfi_tb_ioc_init_busaddr != 0)
1227                         bus_dmamap_unload(sc->mfi_tb_ioc_init_dmat,
1228                             sc->mfi_tb_ioc_init_dmamap);
1229                 if (sc->mfi_tb_ioc_init_desc != NULL)
1230                         bus_dmamem_free(sc->mfi_tb_ioc_init_dmat,
1231                             sc->mfi_tb_ioc_init_desc,
1232                             sc->mfi_tb_ioc_init_dmamap);
1233                 if (sc->mfi_tb_ioc_init_dmat != NULL)
1234                         bus_dma_tag_destroy(sc->mfi_tb_ioc_init_dmat);
1235                 if (sc->mfi_cmd_pool_tbolt != NULL) {
1236                         for (int i = 0; i < sc->mfi_max_fw_cmds; i++) {
1237                                 if (sc->mfi_cmd_pool_tbolt[i] != NULL) {
1238                                         free(sc->mfi_cmd_pool_tbolt[i],
1239                                             M_MFIBUF);
1240                                         sc->mfi_cmd_pool_tbolt[i] = NULL;
1241                                 }
1242                         }
1243                         free(sc->mfi_cmd_pool_tbolt, M_MFIBUF);
1244                         sc->mfi_cmd_pool_tbolt = NULL;
1245                 }
1246                 if (sc->request_desc_pool != NULL) {
1247                         free(sc->request_desc_pool, M_MFIBUF);
1248                         sc->request_desc_pool = NULL;
1249                 }
1250         }
1251         if (sc->mfi_buffer_dmat != NULL)
1252                 bus_dma_tag_destroy(sc->mfi_buffer_dmat);
1253         if (sc->mfi_parent_dmat != NULL)
1254                 bus_dma_tag_destroy(sc->mfi_parent_dmat);
1255
1256         if (mtx_initialized(&sc->mfi_io_lock)) {
1257                 mtx_destroy(&sc->mfi_io_lock);
1258                 sx_destroy(&sc->mfi_config_lock);
1259         }
1260
1261         return;
1262 }
1263
1264 static void
1265 mfi_startup(void *arg)
1266 {
1267         struct mfi_softc *sc;
1268
1269         sc = (struct mfi_softc *)arg;
1270
1271         config_intrhook_disestablish(&sc->mfi_ich);
1272
1273         sc->mfi_enable_intr(sc);
1274         sx_xlock(&sc->mfi_config_lock);
1275         mtx_lock(&sc->mfi_io_lock);
1276         mfi_ldprobe(sc);
1277         if (sc->mfi_flags & MFI_FLAGS_SKINNY)
1278             mfi_syspdprobe(sc);
1279         mtx_unlock(&sc->mfi_io_lock);
1280         sx_xunlock(&sc->mfi_config_lock);
1281 }
1282
1283 static void
1284 mfi_intr(void *arg)
1285 {
1286         struct mfi_softc *sc;
1287         struct mfi_command *cm;
1288         uint32_t pi, ci, context;
1289
1290         sc = (struct mfi_softc *)arg;
1291
1292         if (sc->mfi_check_clear_intr(sc))
1293                 return;
1294
1295 restart:
1296         pi = sc->mfi_comms->hw_pi;
1297         ci = sc->mfi_comms->hw_ci;
1298         mtx_lock(&sc->mfi_io_lock);
1299         while (ci != pi) {
1300                 context = sc->mfi_comms->hw_reply_q[ci];
1301                 if (context < sc->mfi_max_fw_cmds) {
1302                         cm = &sc->mfi_commands[context];
1303                         mfi_remove_busy(cm);
1304                         cm->cm_error = 0;
1305                         mfi_complete(sc, cm);
1306                 }
1307                 if (++ci == (sc->mfi_max_fw_cmds + 1))
1308                         ci = 0;
1309         }
1310
1311         sc->mfi_comms->hw_ci = ci;
1312
1313         /* Give defered I/O a chance to run */
1314         sc->mfi_flags &= ~MFI_FLAGS_QFRZN;
1315         mfi_startio(sc);
1316         mtx_unlock(&sc->mfi_io_lock);
1317
1318         /*
1319          * Dummy read to flush the bus; this ensures that the indexes are up
1320          * to date.  Restart processing if more commands have come it.
1321          */
1322         (void)sc->mfi_read_fw_status(sc);
1323         if (pi != sc->mfi_comms->hw_pi)
1324                 goto restart;
1325
1326         return;
1327 }
1328
1329 int
1330 mfi_shutdown(struct mfi_softc *sc)
1331 {
1332         struct mfi_dcmd_frame *dcmd;
1333         struct mfi_command *cm;
1334         int error;
1335
1336
1337         if (sc->mfi_aen_cm != NULL) {
1338                 sc->cm_aen_abort = 1;
1339                 mfi_abort(sc, &sc->mfi_aen_cm);
1340         }
1341
1342         if (sc->mfi_map_sync_cm != NULL) {
1343                 sc->cm_map_abort = 1;
1344                 mfi_abort(sc, &sc->mfi_map_sync_cm);
1345         }
1346
1347         mtx_lock(&sc->mfi_io_lock);
1348         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_SHUTDOWN, NULL, 0);
1349         if (error) {
1350                 mtx_unlock(&sc->mfi_io_lock);
1351                 return (error);
1352         }
1353
1354         dcmd = &cm->cm_frame->dcmd;
1355         dcmd->header.flags = MFI_FRAME_DIR_NONE;
1356         cm->cm_flags = MFI_CMD_POLLED;
1357         cm->cm_data = NULL;
1358
1359         if ((error = mfi_mapcmd(sc, cm)) != 0)
1360                 device_printf(sc->mfi_dev, "Failed to shutdown controller\n");
1361
1362         mfi_release_command(cm);
1363         mtx_unlock(&sc->mfi_io_lock);
1364         return (error);
1365 }
1366
1367 static void
1368 mfi_syspdprobe(struct mfi_softc *sc)
1369 {
1370         struct mfi_frame_header *hdr;
1371         struct mfi_command *cm = NULL;
1372         struct mfi_pd_list *pdlist = NULL;
1373         struct mfi_system_pd *syspd, *tmp;
1374         struct mfi_system_pending *syspd_pend;
1375         int error, i, found;
1376
1377         sx_assert(&sc->mfi_config_lock, SA_XLOCKED);
1378         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1379         /* Add SYSTEM PD's */
1380         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_PD_LIST_QUERY,
1381             (void **)&pdlist, sizeof(*pdlist));
1382         if (error) {
1383                 device_printf(sc->mfi_dev,
1384                     "Error while forming SYSTEM PD list\n");
1385                 goto out;
1386         }
1387
1388         cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
1389         cm->cm_frame->dcmd.mbox[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
1390         cm->cm_frame->dcmd.mbox[1] = 0;
1391         if (mfi_mapcmd(sc, cm) != 0) {
1392                 device_printf(sc->mfi_dev,
1393                     "Failed to get syspd device listing\n");
1394                 goto out;
1395         }
1396         bus_dmamap_sync(sc->mfi_buffer_dmat,cm->cm_dmamap,
1397             BUS_DMASYNC_POSTREAD);
1398         bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1399         hdr = &cm->cm_frame->header;
1400         if (hdr->cmd_status != MFI_STAT_OK) {
1401                 device_printf(sc->mfi_dev,
1402                     "MFI_DCMD_PD_LIST_QUERY failed %x\n", hdr->cmd_status);
1403                 goto out;
1404         }
1405         /* Get each PD and add it to the system */
1406         for (i = 0; i < pdlist->count; i++) {
1407                 if (pdlist->addr[i].device_id ==
1408                     pdlist->addr[i].encl_device_id)
1409                         continue;
1410                 found = 0;
1411                 TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh, pd_link) {
1412                         if (syspd->pd_id == pdlist->addr[i].device_id)
1413                                 found = 1;
1414                 }
1415                 TAILQ_FOREACH(syspd_pend, &sc->mfi_syspd_pend_tqh, pd_link) {
1416                         if (syspd_pend->pd_id == pdlist->addr[i].device_id)
1417                                 found = 1;
1418                 }
1419                 if (found == 0)
1420                         mfi_add_sys_pd(sc, pdlist->addr[i].device_id);
1421         }
1422         /* Delete SYSPD's whose state has been changed */
1423         TAILQ_FOREACH_SAFE(syspd, &sc->mfi_syspd_tqh, pd_link, tmp) {
1424                 found = 0;
1425                 for (i = 0; i < pdlist->count; i++) {
1426                         if (syspd->pd_id == pdlist->addr[i].device_id) {
1427                                 found = 1;
1428                                 break;
1429                         }
1430                 }
1431                 if (found == 0) {
1432                         printf("DELETE\n");
1433                         mtx_unlock(&sc->mfi_io_lock);
1434                         mtx_lock(&Giant);
1435                         device_delete_child(sc->mfi_dev, syspd->pd_dev);
1436                         mtx_unlock(&Giant);
1437                         mtx_lock(&sc->mfi_io_lock);
1438                 }
1439         }
1440 out:
1441         if (pdlist)
1442             free(pdlist, M_MFIBUF);
1443         if (cm)
1444             mfi_release_command(cm);
1445
1446         return;
1447 }
1448
1449 static void
1450 mfi_ldprobe(struct mfi_softc *sc)
1451 {
1452         struct mfi_frame_header *hdr;
1453         struct mfi_command *cm = NULL;
1454         struct mfi_ld_list *list = NULL;
1455         struct mfi_disk *ld;
1456         struct mfi_disk_pending *ld_pend;
1457         int error, i;
1458
1459         sx_assert(&sc->mfi_config_lock, SA_XLOCKED);
1460         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1461
1462         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_LIST,
1463             (void **)&list, sizeof(*list));
1464         if (error)
1465                 goto out;
1466
1467         cm->cm_flags = MFI_CMD_DATAIN;
1468         if (mfi_wait_command(sc, cm) != 0) {
1469                 device_printf(sc->mfi_dev, "Failed to get device listing\n");
1470                 goto out;
1471         }
1472
1473         hdr = &cm->cm_frame->header;
1474         if (hdr->cmd_status != MFI_STAT_OK) {
1475                 device_printf(sc->mfi_dev, "MFI_DCMD_LD_GET_LIST failed %x\n",
1476                     hdr->cmd_status);
1477                 goto out;
1478         }
1479
1480         for (i = 0; i < list->ld_count; i++) {
1481                 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
1482                         if (ld->ld_id == list->ld_list[i].ld.v.target_id)
1483                                 goto skip_add;
1484                 }
1485                 TAILQ_FOREACH(ld_pend, &sc->mfi_ld_pend_tqh, ld_link) {
1486                         if (ld_pend->ld_id == list->ld_list[i].ld.v.target_id)
1487                                 goto skip_add;
1488                 }
1489                 mfi_add_ld(sc, list->ld_list[i].ld.v.target_id);
1490         skip_add:;
1491         }
1492 out:
1493         if (list)
1494                 free(list, M_MFIBUF);
1495         if (cm)
1496                 mfi_release_command(cm);
1497
1498         return;
1499 }
1500
1501 /*
1502  * The timestamp is the number of seconds since 00:00 Jan 1, 2000.  If
1503  * the bits in 24-31 are all set, then it is the number of seconds since
1504  * boot.
1505  */
1506 static const char *
1507 format_timestamp(uint32_t timestamp)
1508 {
1509         static char buffer[32];
1510
1511         if ((timestamp & 0xff000000) == 0xff000000)
1512                 snprintf(buffer, sizeof(buffer), "boot + %us", timestamp &
1513                     0x00ffffff);
1514         else
1515                 snprintf(buffer, sizeof(buffer), "%us", timestamp);
1516         return (buffer);
1517 }
1518
1519 static const char *
1520 format_class(int8_t class)
1521 {
1522         static char buffer[6];
1523
1524         switch (class) {
1525         case MFI_EVT_CLASS_DEBUG:
1526                 return ("debug");
1527         case MFI_EVT_CLASS_PROGRESS:
1528                 return ("progress");
1529         case MFI_EVT_CLASS_INFO:
1530                 return ("info");
1531         case MFI_EVT_CLASS_WARNING:
1532                 return ("WARN");
1533         case MFI_EVT_CLASS_CRITICAL:
1534                 return ("CRIT");
1535         case MFI_EVT_CLASS_FATAL:
1536                 return ("FATAL");
1537         case MFI_EVT_CLASS_DEAD:
1538                 return ("DEAD");
1539         default:
1540                 snprintf(buffer, sizeof(buffer), "%d", class);
1541                 return (buffer);
1542         }
1543 }
1544
1545 static void
1546 mfi_decode_evt(struct mfi_softc *sc, struct mfi_evt_detail *detail)
1547 {
1548         struct mfi_system_pd *syspd = NULL;
1549
1550         device_printf(sc->mfi_dev, "%d (%s/0x%04x/%s) - %s\n", detail->seq,
1551             format_timestamp(detail->time), detail->evt_class.members.locale,
1552             format_class(detail->evt_class.members.evt_class),
1553             detail->description);
1554
1555         /* Don't act on old AEN's or while shutting down */
1556         if (detail->seq < sc->mfi_boot_seq_num || sc->mfi_detaching)
1557                 return;
1558
1559         switch (detail->arg_type) {
1560         case MR_EVT_ARGS_NONE:
1561                 if (detail->code == MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED) {
1562                     device_printf(sc->mfi_dev, "HostBus scan raised\n");
1563                         if (mfi_detect_jbod_change) {
1564                                 /*
1565                                  * Probe for new SYSPD's and Delete
1566                                  * invalid SYSPD's
1567                                  */
1568                                 sx_xlock(&sc->mfi_config_lock);
1569                                 mtx_lock(&sc->mfi_io_lock);
1570                                 mfi_syspdprobe(sc);
1571                                 mtx_unlock(&sc->mfi_io_lock);
1572                                 sx_xunlock(&sc->mfi_config_lock);
1573                         }
1574                 }
1575                 break;
1576         case MR_EVT_ARGS_LD_STATE:
1577                 /* During load time driver reads all the events starting
1578                  * from the one that has been logged after shutdown. Avoid
1579                  * these old events.
1580                  */
1581                 if (detail->args.ld_state.new_state == MFI_LD_STATE_OFFLINE ) {
1582                         /* Remove the LD */
1583                         struct mfi_disk *ld;
1584                         TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
1585                                 if (ld->ld_id ==
1586                                     detail->args.ld_state.ld.target_id)
1587                                         break;
1588                         }
1589                         /*
1590                         Fix: for kernel panics when SSCD is removed
1591                         KASSERT(ld != NULL, ("volume dissappeared"));
1592                         */
1593                         if (ld != NULL) {
1594                                 mtx_lock(&Giant);
1595                                 device_delete_child(sc->mfi_dev, ld->ld_dev);
1596                                 mtx_unlock(&Giant);
1597                         }
1598                 }
1599                 break;
1600         case MR_EVT_ARGS_PD:
1601                 if (detail->code == MR_EVT_PD_REMOVED) {
1602                         if (mfi_detect_jbod_change) {
1603                                 /*
1604                                  * If the removed device is a SYSPD then
1605                                  * delete it
1606                                  */
1607                                 TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh,
1608                                     pd_link) {
1609                                         if (syspd->pd_id ==
1610                                             detail->args.pd.device_id) {
1611                                                 mtx_lock(&Giant);
1612                                                 device_delete_child(
1613                                                     sc->mfi_dev,
1614                                                     syspd->pd_dev);
1615                                                 mtx_unlock(&Giant);
1616                                                 break;
1617                                         }
1618                                 }
1619                         }
1620                 }
1621                 if (detail->code == MR_EVT_PD_INSERTED) {
1622                         if (mfi_detect_jbod_change) {
1623                                 /* Probe for new SYSPD's */
1624                                 sx_xlock(&sc->mfi_config_lock);
1625                                 mtx_lock(&sc->mfi_io_lock);
1626                                 mfi_syspdprobe(sc);
1627                                 mtx_unlock(&sc->mfi_io_lock);
1628                                 sx_xunlock(&sc->mfi_config_lock);
1629                         }
1630                 }
1631                 if (sc->mfi_cam_rescan_cb != NULL &&
1632                     (detail->code == MR_EVT_PD_INSERTED ||
1633                     detail->code == MR_EVT_PD_REMOVED)) {
1634                         sc->mfi_cam_rescan_cb(sc, detail->args.pd.device_id);
1635                 }
1636                 break;
1637         }
1638 }
1639
1640 static void
1641 mfi_queue_evt(struct mfi_softc *sc, struct mfi_evt_detail *detail)
1642 {
1643         struct mfi_evt_queue_elm *elm;
1644
1645         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1646         elm = malloc(sizeof(*elm), M_MFIBUF, M_NOWAIT|M_ZERO);
1647         if (elm == NULL)
1648                 return;
1649         memcpy(&elm->detail, detail, sizeof(*detail));
1650         TAILQ_INSERT_TAIL(&sc->mfi_evt_queue, elm, link);
1651         taskqueue_enqueue(taskqueue_swi, &sc->mfi_evt_task);
1652 }
1653
1654 static void
1655 mfi_handle_evt(void *context, int pending)
1656 {
1657         TAILQ_HEAD(,mfi_evt_queue_elm) queue;
1658         struct mfi_softc *sc;
1659         struct mfi_evt_queue_elm *elm;
1660
1661         sc = context;
1662         TAILQ_INIT(&queue);
1663         mtx_lock(&sc->mfi_io_lock);
1664         TAILQ_CONCAT(&queue, &sc->mfi_evt_queue, link);
1665         mtx_unlock(&sc->mfi_io_lock);
1666         while ((elm = TAILQ_FIRST(&queue)) != NULL) {
1667                 TAILQ_REMOVE(&queue, elm, link);
1668                 mfi_decode_evt(sc, &elm->detail);
1669                 free(elm, M_MFIBUF);
1670         }
1671 }
1672
1673 static int
1674 mfi_aen_register(struct mfi_softc *sc, int seq, int locale)
1675 {
1676         struct mfi_command *cm;
1677         struct mfi_dcmd_frame *dcmd;
1678         union mfi_evt current_aen, prior_aen;
1679         struct mfi_evt_detail *ed = NULL;
1680         int error = 0;
1681
1682         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1683
1684         current_aen.word = locale;
1685         if (sc->mfi_aen_cm != NULL) {
1686                 prior_aen.word =
1687                     ((uint32_t *)&sc->mfi_aen_cm->cm_frame->dcmd.mbox)[1];
1688                 if (prior_aen.members.evt_class <= current_aen.members.evt_class &&
1689                     !((prior_aen.members.locale & current_aen.members.locale)
1690                     ^current_aen.members.locale)) {
1691                         return (0);
1692                 } else {
1693                         prior_aen.members.locale |= current_aen.members.locale;
1694                         if (prior_aen.members.evt_class
1695                             < current_aen.members.evt_class)
1696                                 current_aen.members.evt_class =
1697                                     prior_aen.members.evt_class;
1698                         mfi_abort(sc, &sc->mfi_aen_cm);
1699                 }
1700         }
1701
1702         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_EVENT_WAIT,
1703             (void **)&ed, sizeof(*ed));
1704         if (error)
1705                 goto out;
1706
1707         dcmd = &cm->cm_frame->dcmd;
1708         ((uint32_t *)&dcmd->mbox)[0] = seq;
1709         ((uint32_t *)&dcmd->mbox)[1] = locale;
1710         cm->cm_flags = MFI_CMD_DATAIN;
1711         cm->cm_complete = mfi_aen_complete;
1712
1713         sc->last_seq_num = seq;
1714         sc->mfi_aen_cm = cm;
1715
1716         mfi_enqueue_ready(cm);
1717         mfi_startio(sc);
1718
1719 out:
1720         return (error);
1721 }
1722
1723 static void
1724 mfi_aen_complete(struct mfi_command *cm)
1725 {
1726         struct mfi_frame_header *hdr;
1727         struct mfi_softc *sc;
1728         struct mfi_evt_detail *detail;
1729         struct mfi_aen *mfi_aen_entry, *tmp;
1730         int seq = 0, aborted = 0;
1731
1732         sc = cm->cm_sc;
1733         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1734
1735         if (sc->mfi_aen_cm == NULL)
1736                 return;
1737
1738         hdr = &cm->cm_frame->header;
1739
1740         if (sc->cm_aen_abort ||
1741             hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
1742                 sc->cm_aen_abort = 0;
1743                 aborted = 1;
1744         } else {
1745                 sc->mfi_aen_triggered = 1;
1746                 if (sc->mfi_poll_waiting) {
1747                         sc->mfi_poll_waiting = 0;
1748                         selwakeup(&sc->mfi_select);
1749                 }
1750                 detail = cm->cm_data;
1751                 mfi_queue_evt(sc, detail);
1752                 seq = detail->seq + 1;
1753                 TAILQ_FOREACH_SAFE(mfi_aen_entry, &sc->mfi_aen_pids, aen_link,
1754                     tmp) {
1755                         TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry,
1756                             aen_link);
1757                         PROC_LOCK(mfi_aen_entry->p);
1758                         kern_psignal(mfi_aen_entry->p, SIGIO);
1759                         PROC_UNLOCK(mfi_aen_entry->p);
1760                         free(mfi_aen_entry, M_MFIBUF);
1761                 }
1762         }
1763
1764         free(cm->cm_data, M_MFIBUF);
1765         wakeup(&sc->mfi_aen_cm);
1766         sc->mfi_aen_cm = NULL;
1767         mfi_release_command(cm);
1768
1769         /* set it up again so the driver can catch more events */
1770         if (!aborted)
1771                 mfi_aen_setup(sc, seq);
1772 }
1773
1774 #define MAX_EVENTS 15
1775
1776 static int
1777 mfi_parse_entries(struct mfi_softc *sc, int start_seq, int stop_seq)
1778 {
1779         struct mfi_command *cm;
1780         struct mfi_dcmd_frame *dcmd;
1781         struct mfi_evt_list *el;
1782         union mfi_evt class_locale;
1783         int error, i, seq, size;
1784
1785         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1786
1787         class_locale.members.reserved = 0;
1788         class_locale.members.locale = mfi_event_locale;
1789         class_locale.members.evt_class  = mfi_event_class;
1790
1791         size = sizeof(struct mfi_evt_list) + sizeof(struct mfi_evt_detail)
1792                 * (MAX_EVENTS - 1);
1793         el = malloc(size, M_MFIBUF, M_NOWAIT | M_ZERO);
1794         if (el == NULL)
1795                 return (ENOMEM);
1796
1797         for (seq = start_seq;;) {
1798                 if ((cm = mfi_dequeue_free(sc)) == NULL) {
1799                         free(el, M_MFIBUF);
1800                         return (EBUSY);
1801                 }
1802
1803                 dcmd = &cm->cm_frame->dcmd;
1804                 bzero(dcmd->mbox, MFI_MBOX_SIZE);
1805                 dcmd->header.cmd = MFI_CMD_DCMD;
1806                 dcmd->header.timeout = 0;
1807                 dcmd->header.data_len = size;
1808                 dcmd->opcode = MFI_DCMD_CTRL_EVENT_GET;
1809                 ((uint32_t *)&dcmd->mbox)[0] = seq;
1810                 ((uint32_t *)&dcmd->mbox)[1] = class_locale.word;
1811                 cm->cm_sg = &dcmd->sgl;
1812                 cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE;
1813                 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
1814                 cm->cm_data = el;
1815                 cm->cm_len = size;
1816
1817                 if ((error = mfi_mapcmd(sc, cm)) != 0) {
1818                         device_printf(sc->mfi_dev,
1819                             "Failed to get controller entries\n");
1820                         mfi_release_command(cm);
1821                         break;
1822                 }
1823
1824                 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
1825                     BUS_DMASYNC_POSTREAD);
1826                 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1827
1828                 if (dcmd->header.cmd_status == MFI_STAT_NOT_FOUND) {
1829                         mfi_release_command(cm);
1830                         break;
1831                 }
1832                 if (dcmd->header.cmd_status != MFI_STAT_OK) {
1833                         device_printf(sc->mfi_dev,
1834                             "Error %d fetching controller entries\n",
1835                             dcmd->header.cmd_status);
1836                         mfi_release_command(cm);
1837                         error = EIO;
1838                         break;
1839                 }
1840                 mfi_release_command(cm);
1841
1842                 for (i = 0; i < el->count; i++) {
1843                         /*
1844                          * If this event is newer than 'stop_seq' then
1845                          * break out of the loop.  Note that the log
1846                          * is a circular buffer so we have to handle
1847                          * the case that our stop point is earlier in
1848                          * the buffer than our start point.
1849                          */
1850                         if (el->event[i].seq >= stop_seq) {
1851                                 if (start_seq <= stop_seq)
1852                                         break;
1853                                 else if (el->event[i].seq < start_seq)
1854                                         break;
1855                         }
1856                         mfi_queue_evt(sc, &el->event[i]);
1857                 }
1858                 seq = el->event[el->count - 1].seq + 1;
1859         }
1860
1861         free(el, M_MFIBUF);
1862         return (error);
1863 }
1864
1865 static int
1866 mfi_add_ld(struct mfi_softc *sc, int id)
1867 {
1868         struct mfi_command *cm;
1869         struct mfi_dcmd_frame *dcmd = NULL;
1870         struct mfi_ld_info *ld_info = NULL;
1871         struct mfi_disk_pending *ld_pend;
1872         int error;
1873
1874         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1875
1876         ld_pend = malloc(sizeof(*ld_pend), M_MFIBUF, M_NOWAIT | M_ZERO);
1877         if (ld_pend != NULL) {
1878                 ld_pend->ld_id = id;
1879                 TAILQ_INSERT_TAIL(&sc->mfi_ld_pend_tqh, ld_pend, ld_link);
1880         }
1881
1882         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_INFO,
1883             (void **)&ld_info, sizeof(*ld_info));
1884         if (error) {
1885                 device_printf(sc->mfi_dev,
1886                     "Failed to allocate for MFI_DCMD_LD_GET_INFO %d\n", error);
1887                 if (ld_info)
1888                         free(ld_info, M_MFIBUF);
1889                 return (error);
1890         }
1891         cm->cm_flags = MFI_CMD_DATAIN;
1892         dcmd = &cm->cm_frame->dcmd;
1893         dcmd->mbox[0] = id;
1894         if (mfi_wait_command(sc, cm) != 0) {
1895                 device_printf(sc->mfi_dev,
1896                     "Failed to get logical drive: %d\n", id);
1897                 free(ld_info, M_MFIBUF);
1898                 return (0);
1899         }
1900         if (ld_info->ld_config.params.isSSCD != 1)
1901                 mfi_add_ld_complete(cm);
1902         else {
1903                 mfi_release_command(cm);
1904                 if (ld_info)            /* SSCD drives ld_info free here */
1905                         free(ld_info, M_MFIBUF);
1906         }
1907         return (0);
1908 }
1909
1910 static void
1911 mfi_add_ld_complete(struct mfi_command *cm)
1912 {
1913         struct mfi_frame_header *hdr;
1914         struct mfi_ld_info *ld_info;
1915         struct mfi_softc *sc;
1916         device_t child;
1917
1918         sc = cm->cm_sc;
1919         hdr = &cm->cm_frame->header;
1920         ld_info = cm->cm_private;
1921
1922         if (sc->cm_map_abort || hdr->cmd_status != MFI_STAT_OK) {
1923                 free(ld_info, M_MFIBUF);
1924                 wakeup(&sc->mfi_map_sync_cm);
1925                 mfi_release_command(cm);
1926                 return;
1927         }
1928         wakeup(&sc->mfi_map_sync_cm);
1929         mfi_release_command(cm);
1930
1931         mtx_unlock(&sc->mfi_io_lock);
1932         mtx_lock(&Giant);
1933         if ((child = device_add_child(sc->mfi_dev, "mfid", -1)) == NULL) {
1934                 device_printf(sc->mfi_dev, "Failed to add logical disk\n");
1935                 free(ld_info, M_MFIBUF);
1936                 mtx_unlock(&Giant);
1937                 mtx_lock(&sc->mfi_io_lock);
1938                 return;
1939         }
1940
1941         device_set_ivars(child, ld_info);
1942         device_set_desc(child, "MFI Logical Disk");
1943         bus_generic_attach(sc->mfi_dev);
1944         mtx_unlock(&Giant);
1945         mtx_lock(&sc->mfi_io_lock);
1946 }
1947
1948 static int mfi_add_sys_pd(struct mfi_softc *sc, int id)
1949 {
1950         struct mfi_command *cm;
1951         struct mfi_dcmd_frame *dcmd = NULL;
1952         struct mfi_pd_info *pd_info = NULL;
1953         struct mfi_system_pending *syspd_pend;
1954         int error;
1955
1956         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1957
1958         syspd_pend = malloc(sizeof(*syspd_pend), M_MFIBUF, M_NOWAIT | M_ZERO);
1959         if (syspd_pend != NULL) {
1960                 syspd_pend->pd_id = id;
1961                 TAILQ_INSERT_TAIL(&sc->mfi_syspd_pend_tqh, syspd_pend, pd_link);
1962         }
1963
1964         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_PD_GET_INFO,
1965                 (void **)&pd_info, sizeof(*pd_info));
1966         if (error) {
1967                 device_printf(sc->mfi_dev,
1968                     "Failed to allocated for MFI_DCMD_PD_GET_INFO %d\n",
1969                     error);
1970                 if (pd_info)
1971                         free(pd_info, M_MFIBUF);
1972                 return (error);
1973         }
1974         cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
1975         dcmd = &cm->cm_frame->dcmd;
1976         dcmd->mbox[0]=id;
1977         dcmd->header.scsi_status = 0;
1978         dcmd->header.pad0 = 0;
1979         if ((error = mfi_mapcmd(sc, cm)) != 0) {
1980                 device_printf(sc->mfi_dev,
1981                     "Failed to get physical drive info %d\n", id);
1982                 free(pd_info, M_MFIBUF);
1983                 mfi_release_command(cm);
1984                 return (error);
1985         }
1986         bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
1987             BUS_DMASYNC_POSTREAD);
1988         bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1989         mfi_add_sys_pd_complete(cm);
1990         return (0);
1991 }
1992
1993 static void
1994 mfi_add_sys_pd_complete(struct mfi_command *cm)
1995 {
1996         struct mfi_frame_header *hdr;
1997         struct mfi_pd_info *pd_info;
1998         struct mfi_softc *sc;
1999         device_t child;
2000
2001         sc = cm->cm_sc;
2002         hdr = &cm->cm_frame->header;
2003         pd_info = cm->cm_private;
2004
2005         if (hdr->cmd_status != MFI_STAT_OK) {
2006                 free(pd_info, M_MFIBUF);
2007                 mfi_release_command(cm);
2008                 return;
2009         }
2010         if (pd_info->fw_state != MFI_PD_STATE_SYSTEM) {
2011                 device_printf(sc->mfi_dev, "PD=%x is not SYSTEM PD\n",
2012                     pd_info->ref.v.device_id);
2013                 free(pd_info, M_MFIBUF);
2014                 mfi_release_command(cm);
2015                 return;
2016         }
2017         mfi_release_command(cm);
2018
2019         mtx_unlock(&sc->mfi_io_lock);
2020         mtx_lock(&Giant);
2021         if ((child = device_add_child(sc->mfi_dev, "mfisyspd", -1)) == NULL) {
2022                 device_printf(sc->mfi_dev, "Failed to add system pd\n");
2023                 free(pd_info, M_MFIBUF);
2024                 mtx_unlock(&Giant);
2025                 mtx_lock(&sc->mfi_io_lock);
2026                 return;
2027         }
2028
2029         device_set_ivars(child, pd_info);
2030         device_set_desc(child, "MFI System PD");
2031         bus_generic_attach(sc->mfi_dev);
2032         mtx_unlock(&Giant);
2033         mtx_lock(&sc->mfi_io_lock);
2034 }
2035
2036 static struct mfi_command *
2037 mfi_bio_command(struct mfi_softc *sc)
2038 {
2039         struct bio *bio;
2040         struct mfi_command *cm = NULL;
2041
2042         /*reserving two commands to avoid starvation for IOCTL*/
2043         if (sc->mfi_qstat[MFIQ_FREE].q_length < 2) {
2044                 return (NULL);
2045         }
2046         if ((bio = mfi_dequeue_bio(sc)) == NULL) {
2047                 return (NULL);
2048         }
2049         if ((uintptr_t)bio->bio_driver2 == MFI_LD_IO) {
2050                 cm = mfi_build_ldio(sc, bio);
2051         } else if ((uintptr_t) bio->bio_driver2 == MFI_SYS_PD_IO) {
2052                 cm = mfi_build_syspdio(sc, bio);
2053         }
2054         if (!cm)
2055             mfi_enqueue_bio(sc, bio);
2056         return cm;
2057 }
2058
2059 /*
2060  * mostly copied from cam/scsi/scsi_all.c:scsi_read_write
2061  */
2062
2063 int
2064 mfi_build_cdb(int readop, uint8_t byte2, u_int64_t lba, u_int32_t block_count, uint8_t *cdb)
2065 {
2066         int cdb_len;
2067
2068         if (((lba & 0x1fffff) == lba)
2069          && ((block_count & 0xff) == block_count)
2070          && (byte2 == 0)) {
2071                 /* We can fit in a 6 byte cdb */
2072                 struct scsi_rw_6 *scsi_cmd;
2073
2074                 scsi_cmd = (struct scsi_rw_6 *)cdb;
2075                 scsi_cmd->opcode = readop ? READ_6 : WRITE_6;
2076                 scsi_ulto3b(lba, scsi_cmd->addr);
2077                 scsi_cmd->length = block_count & 0xff;
2078                 scsi_cmd->control = 0;
2079                 cdb_len = sizeof(*scsi_cmd);
2080         } else if (((block_count & 0xffff) == block_count) && ((lba & 0xffffffff) == lba)) {
2081                 /* Need a 10 byte CDB */
2082                 struct scsi_rw_10 *scsi_cmd;
2083
2084                 scsi_cmd = (struct scsi_rw_10 *)cdb;
2085                 scsi_cmd->opcode = readop ? READ_10 : WRITE_10;
2086                 scsi_cmd->byte2 = byte2;
2087                 scsi_ulto4b(lba, scsi_cmd->addr);
2088                 scsi_cmd->reserved = 0;
2089                 scsi_ulto2b(block_count, scsi_cmd->length);
2090                 scsi_cmd->control = 0;
2091                 cdb_len = sizeof(*scsi_cmd);
2092         } else if (((block_count & 0xffffffff) == block_count) &&
2093             ((lba & 0xffffffff) == lba)) {
2094                 /* Block count is too big for 10 byte CDB use a 12 byte CDB */
2095                 struct scsi_rw_12 *scsi_cmd;
2096
2097                 scsi_cmd = (struct scsi_rw_12 *)cdb;
2098                 scsi_cmd->opcode = readop ? READ_12 : WRITE_12;
2099                 scsi_cmd->byte2 = byte2;
2100                 scsi_ulto4b(lba, scsi_cmd->addr);
2101                 scsi_cmd->reserved = 0;
2102                 scsi_ulto4b(block_count, scsi_cmd->length);
2103                 scsi_cmd->control = 0;
2104                 cdb_len = sizeof(*scsi_cmd);
2105         } else {
2106                 /*
2107                  * 16 byte CDB.  We'll only get here if the LBA is larger
2108                  * than 2^32
2109                  */
2110                 struct scsi_rw_16 *scsi_cmd;
2111
2112                 scsi_cmd = (struct scsi_rw_16 *)cdb;
2113                 scsi_cmd->opcode = readop ? READ_16 : WRITE_16;
2114                 scsi_cmd->byte2 = byte2;
2115                 scsi_u64to8b(lba, scsi_cmd->addr);
2116                 scsi_cmd->reserved = 0;
2117                 scsi_ulto4b(block_count, scsi_cmd->length);
2118                 scsi_cmd->control = 0;
2119                 cdb_len = sizeof(*scsi_cmd);
2120         }
2121
2122         return cdb_len;
2123 }
2124
2125 extern char *unmapped_buf;
2126
2127 static struct mfi_command *
2128 mfi_build_syspdio(struct mfi_softc *sc, struct bio *bio)
2129 {
2130         struct mfi_command *cm;
2131         struct mfi_pass_frame *pass;
2132         uint32_t context = 0;
2133         int flags = 0, blkcount = 0, readop;
2134         uint8_t cdb_len;
2135
2136         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
2137
2138         if ((cm = mfi_dequeue_free(sc)) == NULL)
2139             return (NULL);
2140
2141         /* Zero out the MFI frame */
2142         context = cm->cm_frame->header.context;
2143         bzero(cm->cm_frame, sizeof(union mfi_frame));
2144         cm->cm_frame->header.context = context;
2145         pass = &cm->cm_frame->pass;
2146         bzero(pass->cdb, 16);
2147         pass->header.cmd = MFI_CMD_PD_SCSI_IO;
2148         switch (bio->bio_cmd & 0x03) {
2149         case BIO_READ:
2150                 flags = MFI_CMD_DATAIN | MFI_CMD_BIO;
2151                 readop = 1;
2152                 break;
2153         case BIO_WRITE:
2154                 flags = MFI_CMD_DATAOUT | MFI_CMD_BIO;
2155                 readop = 0;
2156                 break;
2157         default:
2158                 /* TODO: what about BIO_DELETE??? */
2159                 panic("Unsupported bio command %x\n", bio->bio_cmd);
2160         }
2161
2162         /* Cheat with the sector length to avoid a non-constant division */
2163         blkcount = (bio->bio_bcount + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN;
2164         /* Fill the LBA and Transfer length in CDB */
2165         cdb_len = mfi_build_cdb(readop, 0, bio->bio_pblkno, blkcount,
2166             pass->cdb);
2167         pass->header.target_id = (uintptr_t)bio->bio_driver1;
2168         pass->header.lun_id = 0;
2169         pass->header.timeout = 0;
2170         pass->header.flags = 0;
2171         pass->header.scsi_status = 0;
2172         pass->header.sense_len = MFI_SENSE_LEN;
2173         pass->header.data_len = bio->bio_bcount;
2174         pass->header.cdb_len = cdb_len;
2175         pass->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr;
2176         pass->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
2177         cm->cm_complete = mfi_bio_complete;
2178         cm->cm_private = bio;
2179         cm->cm_data = unmapped_buf;
2180         cm->cm_len = bio->bio_bcount;
2181         cm->cm_sg = &pass->sgl;
2182         cm->cm_total_frame_size = MFI_PASS_FRAME_SIZE;
2183         cm->cm_flags = flags;
2184
2185         return (cm);
2186 }
2187
2188 static struct mfi_command *
2189 mfi_build_ldio(struct mfi_softc *sc, struct bio *bio)
2190 {
2191         struct mfi_io_frame *io;
2192         struct mfi_command *cm;
2193         int flags;
2194         uint32_t blkcount;
2195         uint32_t context = 0;
2196
2197         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
2198
2199         if ((cm = mfi_dequeue_free(sc)) == NULL)
2200             return (NULL);
2201
2202         /* Zero out the MFI frame */
2203         context = cm->cm_frame->header.context;
2204         bzero(cm->cm_frame, sizeof(union mfi_frame));
2205         cm->cm_frame->header.context = context;
2206         io = &cm->cm_frame->io;
2207         switch (bio->bio_cmd & 0x03) {
2208         case BIO_READ:
2209                 io->header.cmd = MFI_CMD_LD_READ;
2210                 flags = MFI_CMD_DATAIN | MFI_CMD_BIO;
2211                 break;
2212         case BIO_WRITE:
2213                 io->header.cmd = MFI_CMD_LD_WRITE;
2214                 flags = MFI_CMD_DATAOUT | MFI_CMD_BIO;
2215                 break;
2216         default:
2217                 /* TODO: what about BIO_DELETE??? */
2218                 panic("Unsupported bio command %x\n", bio->bio_cmd);
2219         }
2220
2221         /* Cheat with the sector length to avoid a non-constant division */
2222         blkcount = (bio->bio_bcount + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN;
2223         io->header.target_id = (uintptr_t)bio->bio_driver1;
2224         io->header.timeout = 0;
2225         io->header.flags = 0;
2226         io->header.scsi_status = 0;
2227         io->header.sense_len = MFI_SENSE_LEN;
2228         io->header.data_len = blkcount;
2229         io->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr;
2230         io->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
2231         io->lba_hi = (bio->bio_pblkno & 0xffffffff00000000) >> 32;
2232         io->lba_lo = bio->bio_pblkno & 0xffffffff;
2233         cm->cm_complete = mfi_bio_complete;
2234         cm->cm_private = bio;
2235         cm->cm_data = unmapped_buf;
2236         cm->cm_len = bio->bio_bcount;
2237         cm->cm_sg = &io->sgl;
2238         cm->cm_total_frame_size = MFI_IO_FRAME_SIZE;
2239         cm->cm_flags = flags;
2240
2241         return (cm);
2242 }
2243
2244 static void
2245 mfi_bio_complete(struct mfi_command *cm)
2246 {
2247         struct bio *bio;
2248         struct mfi_frame_header *hdr;
2249         struct mfi_softc *sc;
2250
2251         bio = cm->cm_private;
2252         hdr = &cm->cm_frame->header;
2253         sc = cm->cm_sc;
2254
2255         if ((hdr->cmd_status != MFI_STAT_OK) || (hdr->scsi_status != 0)) {
2256                 bio->bio_flags |= BIO_ERROR;
2257                 bio->bio_error = EIO;
2258                 device_printf(sc->mfi_dev, "I/O error, cmd=%p, status=%#x, "
2259                     "scsi_status=%#x\n", cm, hdr->cmd_status, hdr->scsi_status);
2260                 mfi_print_sense(cm->cm_sc, cm->cm_sense);
2261         } else if (cm->cm_error != 0) {
2262                 bio->bio_flags |= BIO_ERROR;
2263                 bio->bio_error = cm->cm_error;
2264                 device_printf(sc->mfi_dev, "I/O error, cmd=%p, error=%#x\n",
2265                     cm, cm->cm_error);
2266         }
2267
2268         mfi_release_command(cm);
2269         mfi_disk_complete(bio);
2270 }
2271
2272 void
2273 mfi_startio(struct mfi_softc *sc)
2274 {
2275         struct mfi_command *cm;
2276         struct ccb_hdr *ccbh;
2277
2278         for (;;) {
2279                 /* Don't bother if we're short on resources */
2280                 if (sc->mfi_flags & MFI_FLAGS_QFRZN)
2281                         break;
2282
2283                 /* Try a command that has already been prepared */
2284                 cm = mfi_dequeue_ready(sc);
2285
2286                 if (cm == NULL) {
2287                         if ((ccbh = TAILQ_FIRST(&sc->mfi_cam_ccbq)) != NULL)
2288                                 cm = sc->mfi_cam_start(ccbh);
2289                 }
2290
2291                 /* Nope, so look for work on the bioq */
2292                 if (cm == NULL)
2293                         cm = mfi_bio_command(sc);
2294
2295                 /* No work available, so exit */
2296                 if (cm == NULL)
2297                         break;
2298
2299                 /* Send the command to the controller */
2300                 if (mfi_mapcmd(sc, cm) != 0) {
2301                         device_printf(sc->mfi_dev, "Failed to startio\n");
2302                         mfi_requeue_ready(cm);
2303                         break;
2304                 }
2305         }
2306 }
2307
2308 int
2309 mfi_mapcmd(struct mfi_softc *sc, struct mfi_command *cm)
2310 {
2311         int error, polled;
2312
2313         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
2314
2315         if ((cm->cm_data != NULL) && (cm->cm_frame->header.cmd != MFI_CMD_STP )) {
2316                 polled = (cm->cm_flags & MFI_CMD_POLLED) ? BUS_DMA_NOWAIT : 0;
2317                 if (cm->cm_flags & MFI_CMD_CCB)
2318                         error = bus_dmamap_load_ccb(sc->mfi_buffer_dmat,
2319                             cm->cm_dmamap, cm->cm_data, mfi_data_cb, cm,
2320                             polled);
2321                 else if (cm->cm_flags & MFI_CMD_BIO)
2322                         error = bus_dmamap_load_bio(sc->mfi_buffer_dmat,
2323                             cm->cm_dmamap, cm->cm_private, mfi_data_cb, cm,
2324                             polled);
2325                 else
2326                         error = bus_dmamap_load(sc->mfi_buffer_dmat,
2327                             cm->cm_dmamap, cm->cm_data, cm->cm_len,
2328                             mfi_data_cb, cm, polled);
2329                 if (error == EINPROGRESS) {
2330                         sc->mfi_flags |= MFI_FLAGS_QFRZN;
2331                         return (0);
2332                 }
2333         } else {
2334                 error = mfi_send_frame(sc, cm);
2335         }
2336
2337         return (error);
2338 }
2339
2340 static void
2341 mfi_data_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
2342 {
2343         struct mfi_frame_header *hdr;
2344         struct mfi_command *cm;
2345         union mfi_sgl *sgl;
2346         struct mfi_softc *sc;
2347         int i, j, first, dir;
2348         int sge_size, locked;
2349
2350         cm = (struct mfi_command *)arg;
2351         sc = cm->cm_sc;
2352         hdr = &cm->cm_frame->header;
2353         sgl = cm->cm_sg;
2354
2355         /*
2356          * We need to check if we have the lock as this is async
2357          * callback so even though our caller mfi_mapcmd asserts
2358          * it has the lock, there is no garantee that hasn't been
2359          * dropped if bus_dmamap_load returned prior to our
2360          * completion.
2361          */
2362         if ((locked = mtx_owned(&sc->mfi_io_lock)) == 0)
2363                 mtx_lock(&sc->mfi_io_lock);
2364
2365         if (error) {
2366                 printf("error %d in callback\n", error);
2367                 cm->cm_error = error;
2368                 mfi_complete(sc, cm);
2369                 goto out;
2370         }
2371         /* Use IEEE sgl only for IO's on a SKINNY controller
2372          * For other commands on a SKINNY controller use either
2373          * sg32 or sg64 based on the sizeof(bus_addr_t).
2374          * Also calculate the total frame size based on the type
2375          * of SGL used.
2376          */
2377         if (((cm->cm_frame->header.cmd == MFI_CMD_PD_SCSI_IO) ||
2378             (cm->cm_frame->header.cmd == MFI_CMD_LD_READ) ||
2379             (cm->cm_frame->header.cmd == MFI_CMD_LD_WRITE)) &&
2380             (sc->mfi_flags & MFI_FLAGS_SKINNY)) {
2381                 for (i = 0; i < nsegs; i++) {
2382                         sgl->sg_skinny[i].addr = segs[i].ds_addr;
2383                         sgl->sg_skinny[i].len = segs[i].ds_len;
2384                         sgl->sg_skinny[i].flag = 0;
2385                 }
2386                 hdr->flags |= MFI_FRAME_IEEE_SGL | MFI_FRAME_SGL64;
2387                 sge_size = sizeof(struct mfi_sg_skinny);
2388                 hdr->sg_count = nsegs;
2389         } else {
2390                 j = 0;
2391                 if (cm->cm_frame->header.cmd == MFI_CMD_STP) {
2392                         first = cm->cm_stp_len;
2393                         if ((sc->mfi_flags & MFI_FLAGS_SG64) == 0) {
2394                                 sgl->sg32[j].addr = segs[0].ds_addr;
2395                                 sgl->sg32[j++].len = first;
2396                         } else {
2397                                 sgl->sg64[j].addr = segs[0].ds_addr;
2398                                 sgl->sg64[j++].len = first;
2399                         }
2400                 } else
2401                         first = 0;
2402                 if ((sc->mfi_flags & MFI_FLAGS_SG64) == 0) {
2403                         for (i = 0; i < nsegs; i++) {
2404                                 sgl->sg32[j].addr = segs[i].ds_addr + first;
2405                                 sgl->sg32[j++].len = segs[i].ds_len - first;
2406                                 first = 0;
2407                         }
2408                 } else {
2409                         for (i = 0; i < nsegs; i++) {
2410                                 sgl->sg64[j].addr = segs[i].ds_addr + first;
2411                                 sgl->sg64[j++].len = segs[i].ds_len - first;
2412                                 first = 0;
2413                         }
2414                         hdr->flags |= MFI_FRAME_SGL64;
2415                 }
2416                 hdr->sg_count = j;
2417                 sge_size = sc->mfi_sge_size;
2418         }
2419
2420         dir = 0;
2421         if (cm->cm_flags & MFI_CMD_DATAIN) {
2422                 dir |= BUS_DMASYNC_PREREAD;
2423                 hdr->flags |= MFI_FRAME_DIR_READ;
2424         }
2425         if (cm->cm_flags & MFI_CMD_DATAOUT) {
2426                 dir |= BUS_DMASYNC_PREWRITE;
2427                 hdr->flags |= MFI_FRAME_DIR_WRITE;
2428         }
2429         bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, dir);
2430         cm->cm_flags |= MFI_CMD_MAPPED;
2431
2432         /*
2433          * Instead of calculating the total number of frames in the
2434          * compound frame, it's already assumed that there will be at
2435          * least 1 frame, so don't compensate for the modulo of the
2436          * following division.
2437          */
2438         cm->cm_total_frame_size += (sc->mfi_sge_size * nsegs);
2439         cm->cm_extra_frames = (cm->cm_total_frame_size - 1) / MFI_FRAME_SIZE;
2440
2441         if ((error = mfi_send_frame(sc, cm)) != 0) {
2442                 printf("error %d in callback from mfi_send_frame\n", error);
2443                 cm->cm_error = error;
2444                 mfi_complete(sc, cm);
2445                 goto out;
2446         }
2447
2448 out:
2449         /* leave the lock in the state we found it */
2450         if (locked == 0)
2451                 mtx_unlock(&sc->mfi_io_lock);
2452
2453         return;
2454 }
2455
2456 static int
2457 mfi_send_frame(struct mfi_softc *sc, struct mfi_command *cm)
2458 {
2459         int error;
2460
2461         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
2462
2463         if (sc->MFA_enabled)
2464                 error = mfi_tbolt_send_frame(sc, cm);
2465         else
2466                 error = mfi_std_send_frame(sc, cm);
2467
2468         if (error != 0 && (cm->cm_flags & MFI_ON_MFIQ_BUSY) != 0)
2469                 mfi_remove_busy(cm);
2470
2471         return (error);
2472 }
2473
2474 static int
2475 mfi_std_send_frame(struct mfi_softc *sc, struct mfi_command *cm)
2476 {
2477         struct mfi_frame_header *hdr;
2478         int tm = mfi_polled_cmd_timeout * 1000;
2479
2480         hdr = &cm->cm_frame->header;
2481
2482         if ((cm->cm_flags & MFI_CMD_POLLED) == 0) {
2483                 cm->cm_timestamp = time_uptime;
2484                 mfi_enqueue_busy(cm);
2485         } else {
2486                 hdr->cmd_status = MFI_STAT_INVALID_STATUS;
2487                 hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
2488         }
2489
2490         /*
2491          * The bus address of the command is aligned on a 64 byte boundary,
2492          * leaving the least 6 bits as zero.  For whatever reason, the
2493          * hardware wants the address shifted right by three, leaving just
2494          * 3 zero bits.  These three bits are then used as a prefetching
2495          * hint for the hardware to predict how many frames need to be
2496          * fetched across the bus.  If a command has more than 8 frames
2497          * then the 3 bits are set to 0x7 and the firmware uses other
2498          * information in the command to determine the total amount to fetch.
2499          * However, FreeBSD doesn't support I/O larger than 128K, so 8 frames
2500          * is enough for both 32bit and 64bit systems.
2501          */
2502         if (cm->cm_extra_frames > 7)
2503                 cm->cm_extra_frames = 7;
2504
2505         sc->mfi_issue_cmd(sc, cm->cm_frame_busaddr, cm->cm_extra_frames);
2506
2507         if ((cm->cm_flags & MFI_CMD_POLLED) == 0)
2508                 return (0);
2509
2510         /* This is a polled command, so busy-wait for it to complete. */
2511         while (hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
2512                 DELAY(1000);
2513                 tm -= 1;
2514                 if (tm <= 0)
2515                         break;
2516         }
2517
2518         if (hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
2519                 device_printf(sc->mfi_dev, "Frame %p timed out "
2520                     "command 0x%X\n", hdr, cm->cm_frame->dcmd.opcode);
2521                 return (ETIMEDOUT);
2522         }
2523
2524         return (0);
2525 }
2526
2527
2528 void
2529 mfi_complete(struct mfi_softc *sc, struct mfi_command *cm)
2530 {
2531         int dir;
2532         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
2533
2534         if ((cm->cm_flags & MFI_CMD_MAPPED) != 0) {
2535                 dir = 0;
2536                 if ((cm->cm_flags & MFI_CMD_DATAIN) ||
2537                     (cm->cm_frame->header.cmd == MFI_CMD_STP))
2538                         dir |= BUS_DMASYNC_POSTREAD;
2539                 if (cm->cm_flags & MFI_CMD_DATAOUT)
2540                         dir |= BUS_DMASYNC_POSTWRITE;
2541
2542                 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, dir);
2543                 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
2544                 cm->cm_flags &= ~MFI_CMD_MAPPED;
2545         }
2546
2547         cm->cm_flags |= MFI_CMD_COMPLETED;
2548
2549         if (cm->cm_complete != NULL)
2550                 cm->cm_complete(cm);
2551         else
2552                 wakeup(cm);
2553 }
2554
2555 static int
2556 mfi_abort(struct mfi_softc *sc, struct mfi_command **cm_abort)
2557 {
2558         struct mfi_command *cm;
2559         struct mfi_abort_frame *abort;
2560         int i = 0, error;
2561         uint32_t context = 0;
2562
2563         mtx_lock(&sc->mfi_io_lock);
2564         if ((cm = mfi_dequeue_free(sc)) == NULL) {
2565                 mtx_unlock(&sc->mfi_io_lock);
2566                 return (EBUSY);
2567         }
2568
2569         /* Zero out the MFI frame */
2570         context = cm->cm_frame->header.context;
2571         bzero(cm->cm_frame, sizeof(union mfi_frame));
2572         cm->cm_frame->header.context = context;
2573
2574         abort = &cm->cm_frame->abort;
2575         abort->header.cmd = MFI_CMD_ABORT;
2576         abort->header.flags = 0;
2577         abort->header.scsi_status = 0;
2578         abort->abort_context = (*cm_abort)->cm_frame->header.context;
2579         abort->abort_mfi_addr_lo = (uint32_t)(*cm_abort)->cm_frame_busaddr;
2580         abort->abort_mfi_addr_hi =
2581                 (uint32_t)((uint64_t)(*cm_abort)->cm_frame_busaddr >> 32);
2582         cm->cm_data = NULL;
2583         cm->cm_flags = MFI_CMD_POLLED;
2584
2585         if ((error = mfi_mapcmd(sc, cm)) != 0)
2586                 device_printf(sc->mfi_dev, "failed to abort command\n");
2587         mfi_release_command(cm);
2588
2589         mtx_unlock(&sc->mfi_io_lock);
2590         while (i < 5 && *cm_abort != NULL) {
2591                 tsleep(cm_abort, 0, "mfiabort",
2592                     5 * hz);
2593                 i++;
2594         }
2595         if (*cm_abort != NULL) {
2596                 /* Force a complete if command didn't abort */
2597                 mtx_lock(&sc->mfi_io_lock);
2598                 (*cm_abort)->cm_complete(*cm_abort);
2599                 mtx_unlock(&sc->mfi_io_lock);
2600         }
2601
2602         return (error);
2603 }
2604
2605 int
2606 mfi_dump_blocks(struct mfi_softc *sc, int id, uint64_t lba, void *virt,
2607      int len)
2608 {
2609         struct mfi_command *cm;
2610         struct mfi_io_frame *io;
2611         int error;
2612         uint32_t context = 0;
2613
2614         if ((cm = mfi_dequeue_free(sc)) == NULL)
2615                 return (EBUSY);
2616
2617         /* Zero out the MFI frame */
2618         context = cm->cm_frame->header.context;
2619         bzero(cm->cm_frame, sizeof(union mfi_frame));
2620         cm->cm_frame->header.context = context;
2621
2622         io = &cm->cm_frame->io;
2623         io->header.cmd = MFI_CMD_LD_WRITE;
2624         io->header.target_id = id;
2625         io->header.timeout = 0;
2626         io->header.flags = 0;
2627         io->header.scsi_status = 0;
2628         io->header.sense_len = MFI_SENSE_LEN;
2629         io->header.data_len = (len + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN;
2630         io->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr;
2631         io->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
2632         io->lba_hi = (lba & 0xffffffff00000000) >> 32;
2633         io->lba_lo = lba & 0xffffffff;
2634         cm->cm_data = virt;
2635         cm->cm_len = len;
2636         cm->cm_sg = &io->sgl;
2637         cm->cm_total_frame_size = MFI_IO_FRAME_SIZE;
2638         cm->cm_flags = MFI_CMD_POLLED | MFI_CMD_DATAOUT;
2639
2640         if ((error = mfi_mapcmd(sc, cm)) != 0)
2641                 device_printf(sc->mfi_dev, "failed dump blocks\n");
2642         bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
2643             BUS_DMASYNC_POSTWRITE);
2644         bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
2645         mfi_release_command(cm);
2646
2647         return (error);
2648 }
2649
2650 int
2651 mfi_dump_syspd_blocks(struct mfi_softc *sc, int id, uint64_t lba, void *virt,
2652     int len)
2653 {
2654         struct mfi_command *cm;
2655         struct mfi_pass_frame *pass;
2656         int error, readop, cdb_len;
2657         uint32_t blkcount;
2658
2659         if ((cm = mfi_dequeue_free(sc)) == NULL)
2660                 return (EBUSY);
2661
2662         pass = &cm->cm_frame->pass;
2663         bzero(pass->cdb, 16);
2664         pass->header.cmd = MFI_CMD_PD_SCSI_IO;
2665
2666         readop = 0;
2667         blkcount = (len + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN;
2668         cdb_len = mfi_build_cdb(readop, 0, lba, blkcount, pass->cdb);
2669         pass->header.target_id = id;
2670         pass->header.timeout = 0;
2671         pass->header.flags = 0;
2672         pass->header.scsi_status = 0;
2673         pass->header.sense_len = MFI_SENSE_LEN;
2674         pass->header.data_len = len;
2675         pass->header.cdb_len = cdb_len;
2676         pass->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr;
2677         pass->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
2678         cm->cm_data = virt;
2679         cm->cm_len = len;
2680         cm->cm_sg = &pass->sgl;
2681         cm->cm_total_frame_size = MFI_PASS_FRAME_SIZE;
2682         cm->cm_flags = MFI_CMD_POLLED | MFI_CMD_DATAOUT | MFI_CMD_SCSI;
2683
2684         if ((error = mfi_mapcmd(sc, cm)) != 0)
2685                 device_printf(sc->mfi_dev, "failed dump blocks\n");
2686         bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
2687             BUS_DMASYNC_POSTWRITE);
2688         bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
2689         mfi_release_command(cm);
2690
2691         return (error);
2692 }
2693
2694 static int
2695 mfi_open(struct cdev *dev, int flags, int fmt, struct thread *td)
2696 {
2697         struct mfi_softc *sc;
2698         int error;
2699
2700         sc = dev->si_drv1;
2701
2702         mtx_lock(&sc->mfi_io_lock);
2703         if (sc->mfi_detaching)
2704                 error = ENXIO;
2705         else {
2706                 sc->mfi_flags |= MFI_FLAGS_OPEN;
2707                 error = 0;
2708         }
2709         mtx_unlock(&sc->mfi_io_lock);
2710
2711         return (error);
2712 }
2713
2714 static int
2715 mfi_close(struct cdev *dev, int flags, int fmt, struct thread *td)
2716 {
2717         struct mfi_softc *sc;
2718         struct mfi_aen *mfi_aen_entry, *tmp;
2719
2720         sc = dev->si_drv1;
2721
2722         mtx_lock(&sc->mfi_io_lock);
2723         sc->mfi_flags &= ~MFI_FLAGS_OPEN;
2724
2725         TAILQ_FOREACH_SAFE(mfi_aen_entry, &sc->mfi_aen_pids, aen_link, tmp) {
2726                 if (mfi_aen_entry->p == curproc) {
2727                         TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry,
2728                             aen_link);
2729                         free(mfi_aen_entry, M_MFIBUF);
2730                 }
2731         }
2732         mtx_unlock(&sc->mfi_io_lock);
2733         return (0);
2734 }
2735
2736 static int
2737 mfi_config_lock(struct mfi_softc *sc, uint32_t opcode)
2738 {
2739
2740         switch (opcode) {
2741         case MFI_DCMD_LD_DELETE:
2742         case MFI_DCMD_CFG_ADD:
2743         case MFI_DCMD_CFG_CLEAR:
2744         case MFI_DCMD_CFG_FOREIGN_IMPORT:
2745                 sx_xlock(&sc->mfi_config_lock);
2746                 return (1);
2747         default:
2748                 return (0);
2749         }
2750 }
2751
2752 static void
2753 mfi_config_unlock(struct mfi_softc *sc, int locked)
2754 {
2755
2756         if (locked)
2757                 sx_xunlock(&sc->mfi_config_lock);
2758 }
2759
2760 /*
2761  * Perform pre-issue checks on commands from userland and possibly veto
2762  * them.
2763  */
2764 static int
2765 mfi_check_command_pre(struct mfi_softc *sc, struct mfi_command *cm)
2766 {
2767         struct mfi_disk *ld, *ld2;
2768         int error;
2769         struct mfi_system_pd *syspd = NULL;
2770         uint16_t syspd_id;
2771         uint16_t *mbox;
2772
2773         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
2774         error = 0;
2775         switch (cm->cm_frame->dcmd.opcode) {
2776         case MFI_DCMD_LD_DELETE:
2777                 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
2778                         if (ld->ld_id == cm->cm_frame->dcmd.mbox[0])
2779                                 break;
2780                 }
2781                 if (ld == NULL)
2782                         error = ENOENT;
2783                 else
2784                         error = mfi_disk_disable(ld);
2785                 break;
2786         case MFI_DCMD_CFG_CLEAR:
2787                 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
2788                         error = mfi_disk_disable(ld);
2789                         if (error)
2790                                 break;
2791                 }
2792                 if (error) {
2793                         TAILQ_FOREACH(ld2, &sc->mfi_ld_tqh, ld_link) {
2794                                 if (ld2 == ld)
2795                                         break;
2796                                 mfi_disk_enable(ld2);
2797                         }
2798                 }
2799                 break;
2800         case MFI_DCMD_PD_STATE_SET:
2801                 mbox = (uint16_t *) cm->cm_frame->dcmd.mbox;
2802                 syspd_id = mbox[0];
2803                 if (mbox[2] == MFI_PD_STATE_UNCONFIGURED_GOOD) {
2804                         TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh, pd_link) {
2805                                 if (syspd->pd_id == syspd_id)
2806                                         break;
2807                         }
2808                 }
2809                 else
2810                         break;
2811                 if (syspd)
2812                         error = mfi_syspd_disable(syspd);
2813                 break;
2814         default:
2815                 break;
2816         }
2817         return (error);
2818 }
2819
2820 /* Perform post-issue checks on commands from userland. */
2821 static void
2822 mfi_check_command_post(struct mfi_softc *sc, struct mfi_command *cm)
2823 {
2824         struct mfi_disk *ld, *ldn;
2825         struct mfi_system_pd *syspd = NULL;
2826         uint16_t syspd_id;
2827         uint16_t *mbox;
2828
2829         switch (cm->cm_frame->dcmd.opcode) {
2830         case MFI_DCMD_LD_DELETE:
2831                 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
2832                         if (ld->ld_id == cm->cm_frame->dcmd.mbox[0])
2833                                 break;
2834                 }
2835                 KASSERT(ld != NULL, ("volume dissappeared"));
2836                 if (cm->cm_frame->header.cmd_status == MFI_STAT_OK) {
2837                         mtx_unlock(&sc->mfi_io_lock);
2838                         mtx_lock(&Giant);
2839                         device_delete_child(sc->mfi_dev, ld->ld_dev);
2840                         mtx_unlock(&Giant);
2841                         mtx_lock(&sc->mfi_io_lock);
2842                 } else
2843                         mfi_disk_enable(ld);
2844                 break;
2845         case MFI_DCMD_CFG_CLEAR:
2846                 if (cm->cm_frame->header.cmd_status == MFI_STAT_OK) {
2847                         mtx_unlock(&sc->mfi_io_lock);
2848                         mtx_lock(&Giant);
2849                         TAILQ_FOREACH_SAFE(ld, &sc->mfi_ld_tqh, ld_link, ldn) {
2850                                 device_delete_child(sc->mfi_dev, ld->ld_dev);
2851                         }
2852                         mtx_unlock(&Giant);
2853                         mtx_lock(&sc->mfi_io_lock);
2854                 } else {
2855                         TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link)
2856                                 mfi_disk_enable(ld);
2857                 }
2858                 break;
2859         case MFI_DCMD_CFG_ADD:
2860                 mfi_ldprobe(sc);
2861                 break;
2862         case MFI_DCMD_CFG_FOREIGN_IMPORT:
2863                 mfi_ldprobe(sc);
2864                 break;
2865         case MFI_DCMD_PD_STATE_SET:
2866                 mbox = (uint16_t *) cm->cm_frame->dcmd.mbox;
2867                 syspd_id = mbox[0];
2868                 if (mbox[2] == MFI_PD_STATE_UNCONFIGURED_GOOD) {
2869                         TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh,pd_link) {
2870                                 if (syspd->pd_id == syspd_id)
2871                                         break;
2872                         }
2873                 }
2874                 else
2875                         break;
2876                 /* If the transition fails then enable the syspd again */
2877                 if (syspd && cm->cm_frame->header.cmd_status != MFI_STAT_OK)
2878                         mfi_syspd_enable(syspd);
2879                 break;
2880         }
2881 }
2882
2883 static int
2884 mfi_check_for_sscd(struct mfi_softc *sc, struct mfi_command *cm)
2885 {
2886         struct mfi_config_data *conf_data;
2887         struct mfi_command *ld_cm = NULL;
2888         struct mfi_ld_info *ld_info = NULL;
2889         struct mfi_ld_config *ld;
2890         char *p;
2891         int error = 0;
2892
2893         conf_data = (struct mfi_config_data *)cm->cm_data;
2894
2895         if (cm->cm_frame->dcmd.opcode == MFI_DCMD_CFG_ADD) {
2896                 p = (char *)conf_data->array;
2897                 p += conf_data->array_size * conf_data->array_count;
2898                 ld = (struct mfi_ld_config *)p;
2899                 if (ld->params.isSSCD == 1)
2900                         error = 1;
2901         } else if (cm->cm_frame->dcmd.opcode == MFI_DCMD_LD_DELETE) {
2902                 error = mfi_dcmd_command (sc, &ld_cm, MFI_DCMD_LD_GET_INFO,
2903                     (void **)&ld_info, sizeof(*ld_info));
2904                 if (error) {
2905                         device_printf(sc->mfi_dev, "Failed to allocate"
2906                             "MFI_DCMD_LD_GET_INFO %d", error);
2907                         if (ld_info)
2908                                 free(ld_info, M_MFIBUF);
2909                         return 0;
2910                 }
2911                 ld_cm->cm_flags = MFI_CMD_DATAIN;
2912                 ld_cm->cm_frame->dcmd.mbox[0]= cm->cm_frame->dcmd.mbox[0];
2913                 ld_cm->cm_frame->header.target_id = cm->cm_frame->dcmd.mbox[0];
2914                 if (mfi_wait_command(sc, ld_cm) != 0) {
2915                         device_printf(sc->mfi_dev, "failed to get log drv\n");
2916                         mfi_release_command(ld_cm);
2917                         free(ld_info, M_MFIBUF);
2918                         return 0;
2919                 }
2920
2921                 if (ld_cm->cm_frame->header.cmd_status != MFI_STAT_OK) {
2922                         free(ld_info, M_MFIBUF);
2923                         mfi_release_command(ld_cm);
2924                         return 0;
2925                 }
2926                 else
2927                         ld_info = (struct mfi_ld_info *)ld_cm->cm_private;
2928
2929                 if (ld_info->ld_config.params.isSSCD == 1)
2930                         error = 1;
2931
2932                 mfi_release_command(ld_cm);
2933                 free(ld_info, M_MFIBUF);
2934
2935         }
2936         return error;
2937 }
2938
2939 static int
2940 mfi_stp_cmd(struct mfi_softc *sc, struct mfi_command *cm,caddr_t arg)
2941 {
2942         uint8_t i;
2943         struct mfi_ioc_packet *ioc;
2944         ioc = (struct mfi_ioc_packet *)arg;
2945         int sge_size, error;
2946         struct megasas_sge *kern_sge;
2947
2948         memset(sc->kbuff_arr, 0, sizeof(sc->kbuff_arr));
2949         kern_sge =(struct megasas_sge *) ((uintptr_t)cm->cm_frame + ioc->mfi_sgl_off);
2950         cm->cm_frame->header.sg_count = ioc->mfi_sge_count;
2951
2952         if (sizeof(bus_addr_t) == 8) {
2953                 cm->cm_frame->header.flags |= MFI_FRAME_SGL64;
2954                 cm->cm_extra_frames = 2;
2955                 sge_size = sizeof(struct mfi_sg64);
2956         } else {
2957                 cm->cm_extra_frames =  (cm->cm_total_frame_size - 1) / MFI_FRAME_SIZE;
2958                 sge_size = sizeof(struct mfi_sg32);
2959         }
2960
2961         cm->cm_total_frame_size += (sge_size * ioc->mfi_sge_count);
2962         for (i = 0; i < ioc->mfi_sge_count; i++) {
2963                         if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
2964                         1, 0,                   /* algnmnt, boundary */
2965                         BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
2966                         BUS_SPACE_MAXADDR,      /* highaddr */
2967                         NULL, NULL,             /* filter, filterarg */
2968                         ioc->mfi_sgl[i].iov_len,/* maxsize */
2969                         2,                      /* nsegments */
2970                         ioc->mfi_sgl[i].iov_len,/* maxsegsize */
2971                         BUS_DMA_ALLOCNOW,       /* flags */
2972                         NULL, NULL,             /* lockfunc, lockarg */
2973                         &sc->mfi_kbuff_arr_dmat[i])) {
2974                         device_printf(sc->mfi_dev,
2975                             "Cannot allocate mfi_kbuff_arr_dmat tag\n");
2976                         return (ENOMEM);
2977                 }
2978
2979                 if (bus_dmamem_alloc(sc->mfi_kbuff_arr_dmat[i],
2980                     (void **)&sc->kbuff_arr[i], BUS_DMA_NOWAIT,
2981                     &sc->mfi_kbuff_arr_dmamap[i])) {
2982                         device_printf(sc->mfi_dev,
2983                             "Cannot allocate mfi_kbuff_arr_dmamap memory\n");
2984                         return (ENOMEM);
2985                 }
2986
2987                 bus_dmamap_load(sc->mfi_kbuff_arr_dmat[i],
2988                     sc->mfi_kbuff_arr_dmamap[i], sc->kbuff_arr[i],
2989                     ioc->mfi_sgl[i].iov_len, mfi_addr_cb,
2990                     &sc->mfi_kbuff_arr_busaddr[i], 0);
2991
2992                 if (!sc->kbuff_arr[i]) {
2993                         device_printf(sc->mfi_dev,
2994                             "Could not allocate memory for kbuff_arr info\n");
2995                         return -1;
2996                 }
2997                 kern_sge[i].phys_addr = sc->mfi_kbuff_arr_busaddr[i];
2998                 kern_sge[i].length = ioc->mfi_sgl[i].iov_len;
2999
3000                 if (sizeof(bus_addr_t) == 8) {
3001                         cm->cm_frame->stp.sgl.sg64[i].addr =
3002                             kern_sge[i].phys_addr;
3003                         cm->cm_frame->stp.sgl.sg64[i].len =
3004                             ioc->mfi_sgl[i].iov_len;
3005                 } else {
3006                         cm->cm_frame->stp.sgl.sg32[i].addr =
3007                             kern_sge[i].phys_addr;
3008                         cm->cm_frame->stp.sgl.sg32[i].len =
3009                             ioc->mfi_sgl[i].iov_len;
3010                 }
3011
3012                 error = copyin(ioc->mfi_sgl[i].iov_base,
3013                     sc->kbuff_arr[i],
3014                     ioc->mfi_sgl[i].iov_len);
3015                 if (error != 0) {
3016                         device_printf(sc->mfi_dev, "Copy in failed\n");
3017                         return error;
3018                 }
3019         }
3020
3021         cm->cm_flags |=MFI_CMD_MAPPED;
3022         return 0;
3023 }
3024
3025 static int
3026 mfi_user_command(struct mfi_softc *sc, struct mfi_ioc_passthru *ioc)
3027 {
3028         struct mfi_command *cm;
3029         struct mfi_dcmd_frame *dcmd;
3030         void *ioc_buf = NULL;
3031         uint32_t context;
3032         int error = 0, locked;
3033
3034
3035         if (ioc->buf_size > 0) {
3036                 if (ioc->buf_size > 1024 * 1024)
3037                         return (ENOMEM);
3038                 ioc_buf = malloc(ioc->buf_size, M_MFIBUF, M_WAITOK);
3039                 error = copyin(ioc->buf, ioc_buf, ioc->buf_size);
3040                 if (error) {
3041                         device_printf(sc->mfi_dev, "failed to copyin\n");
3042                         free(ioc_buf, M_MFIBUF);
3043                         return (error);
3044                 }
3045         }
3046
3047         locked = mfi_config_lock(sc, ioc->ioc_frame.opcode);
3048
3049         mtx_lock(&sc->mfi_io_lock);
3050         while ((cm = mfi_dequeue_free(sc)) == NULL)
3051                 msleep(mfi_user_command, &sc->mfi_io_lock, 0, "mfiioc", hz);
3052
3053         /* Save context for later */
3054         context = cm->cm_frame->header.context;
3055
3056         dcmd = &cm->cm_frame->dcmd;
3057         bcopy(&ioc->ioc_frame, dcmd, sizeof(struct mfi_dcmd_frame));
3058
3059         cm->cm_sg = &dcmd->sgl;
3060         cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE;
3061         cm->cm_data = ioc_buf;
3062         cm->cm_len = ioc->buf_size;
3063
3064         /* restore context */
3065         cm->cm_frame->header.context = context;
3066
3067         /* Cheat since we don't know if we're writing or reading */
3068         cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_DATAOUT;
3069
3070         error = mfi_check_command_pre(sc, cm);
3071         if (error)
3072                 goto out;
3073
3074         error = mfi_wait_command(sc, cm);
3075         if (error) {
3076                 device_printf(sc->mfi_dev, "ioctl failed %d\n", error);
3077                 goto out;
3078         }
3079         bcopy(dcmd, &ioc->ioc_frame, sizeof(struct mfi_dcmd_frame));
3080         mfi_check_command_post(sc, cm);
3081 out:
3082         mfi_release_command(cm);
3083         mtx_unlock(&sc->mfi_io_lock);
3084         mfi_config_unlock(sc, locked);
3085         if (ioc->buf_size > 0)
3086                 error = copyout(ioc_buf, ioc->buf, ioc->buf_size);
3087         if (ioc_buf)
3088                 free(ioc_buf, M_MFIBUF);
3089         return (error);
3090 }
3091
3092 #define PTRIN(p)                ((void *)(uintptr_t)(p))
3093
3094 static int
3095 mfi_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int flag, struct thread *td)
3096 {
3097         struct mfi_softc *sc;
3098         union mfi_statrequest *ms;
3099         struct mfi_ioc_packet *ioc;
3100 #ifdef COMPAT_FREEBSD32
3101         struct mfi_ioc_packet32 *ioc32;
3102 #endif
3103         struct mfi_ioc_aen *aen;
3104         struct mfi_command *cm = NULL;
3105         uint32_t context = 0;
3106         union mfi_sense_ptr sense_ptr;
3107         uint8_t *data = NULL, *temp, *addr, skip_pre_post = 0;
3108         size_t len;
3109         int i, res;
3110         struct mfi_ioc_passthru *iop = (struct mfi_ioc_passthru *)arg;
3111 #ifdef COMPAT_FREEBSD32
3112         struct mfi_ioc_passthru32 *iop32 = (struct mfi_ioc_passthru32 *)arg;
3113         struct mfi_ioc_passthru iop_swab;
3114 #endif
3115         int error, locked;
3116         union mfi_sgl *sgl;
3117         sc = dev->si_drv1;
3118         error = 0;
3119
3120         if (sc->adpreset)
3121                 return EBUSY;
3122
3123         if (sc->hw_crit_error)
3124                 return EBUSY;
3125
3126         if (sc->issuepend_done == 0)
3127                 return EBUSY;
3128
3129         switch (cmd) {
3130         case MFIIO_STATS:
3131                 ms = (union mfi_statrequest *)arg;
3132                 switch (ms->ms_item) {
3133                 case MFIQ_FREE:
3134                 case MFIQ_BIO:
3135                 case MFIQ_READY:
3136                 case MFIQ_BUSY:
3137                         bcopy(&sc->mfi_qstat[ms->ms_item], &ms->ms_qstat,
3138                             sizeof(struct mfi_qstat));
3139                         break;
3140                 default:
3141                         error = ENOIOCTL;
3142                         break;
3143                 }
3144                 break;
3145         case MFIIO_QUERY_DISK:
3146         {
3147                 struct mfi_query_disk *qd;
3148                 struct mfi_disk *ld;
3149
3150                 qd = (struct mfi_query_disk *)arg;
3151                 mtx_lock(&sc->mfi_io_lock);
3152                 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
3153                         if (ld->ld_id == qd->array_id)
3154                                 break;
3155                 }
3156                 if (ld == NULL) {
3157                         qd->present = 0;
3158                         mtx_unlock(&sc->mfi_io_lock);
3159                         return (0);
3160                 }
3161                 qd->present = 1;
3162                 if (ld->ld_flags & MFI_DISK_FLAGS_OPEN)
3163                         qd->open = 1;
3164                 bzero(qd->devname, SPECNAMELEN + 1);
3165                 snprintf(qd->devname, SPECNAMELEN, "mfid%d", ld->ld_unit);
3166                 mtx_unlock(&sc->mfi_io_lock);
3167                 break;
3168         }
3169         case MFI_CMD:
3170 #ifdef COMPAT_FREEBSD32
3171         case MFI_CMD32:
3172 #endif
3173                 {
3174                 devclass_t devclass;
3175                 ioc = (struct mfi_ioc_packet *)arg;
3176                 int adapter;
3177
3178                 adapter = ioc->mfi_adapter_no;
3179                 if (device_get_unit(sc->mfi_dev) == 0 && adapter != 0) {
3180                         devclass = devclass_find("mfi");
3181                         sc = devclass_get_softc(devclass, adapter);
3182                 }
3183                 mtx_lock(&sc->mfi_io_lock);
3184                 if ((cm = mfi_dequeue_free(sc)) == NULL) {
3185                         mtx_unlock(&sc->mfi_io_lock);
3186                         return (EBUSY);
3187                 }
3188                 mtx_unlock(&sc->mfi_io_lock);
3189                 locked = 0;
3190
3191                 /*
3192                  * save off original context since copying from user
3193                  * will clobber some data
3194                  */
3195                 context = cm->cm_frame->header.context;
3196                 cm->cm_frame->header.context = cm->cm_index;
3197
3198                 bcopy(ioc->mfi_frame.raw, cm->cm_frame,
3199                     2 * MEGAMFI_FRAME_SIZE);
3200                 cm->cm_total_frame_size = (sizeof(union mfi_sgl)
3201                     * ioc->mfi_sge_count) + ioc->mfi_sgl_off;
3202                 cm->cm_frame->header.scsi_status = 0;
3203                 cm->cm_frame->header.pad0 = 0;
3204                 if (ioc->mfi_sge_count) {
3205                         cm->cm_sg =
3206                             (union mfi_sgl *)&cm->cm_frame->bytes[ioc->mfi_sgl_off];
3207                 }
3208                 sgl = cm->cm_sg;
3209                 cm->cm_flags = 0;
3210                 if (cm->cm_frame->header.flags & MFI_FRAME_DATAIN)
3211                         cm->cm_flags |= MFI_CMD_DATAIN;
3212                 if (cm->cm_frame->header.flags & MFI_FRAME_DATAOUT)
3213                         cm->cm_flags |= MFI_CMD_DATAOUT;
3214                 /* Legacy app shim */
3215                 if (cm->cm_flags == 0)
3216                         cm->cm_flags |= MFI_CMD_DATAIN | MFI_CMD_DATAOUT;
3217                 cm->cm_len = cm->cm_frame->header.data_len;
3218                 if (cm->cm_frame->header.cmd == MFI_CMD_STP) {
3219 #ifdef COMPAT_FREEBSD32
3220                         if (cmd == MFI_CMD) {
3221 #endif
3222                                 /* Native */
3223                                 cm->cm_stp_len = ioc->mfi_sgl[0].iov_len;
3224 #ifdef COMPAT_FREEBSD32
3225                         } else {
3226                                 /* 32bit on 64bit */
3227                                 ioc32 = (struct mfi_ioc_packet32 *)ioc;
3228                                 cm->cm_stp_len = ioc32->mfi_sgl[0].iov_len;
3229                         }
3230 #endif
3231                         cm->cm_len += cm->cm_stp_len;
3232                 }
3233                 if (cm->cm_len &&
3234                     (cm->cm_flags & (MFI_CMD_DATAIN | MFI_CMD_DATAOUT))) {
3235                         cm->cm_data = data = malloc(cm->cm_len, M_MFIBUF,
3236                             M_WAITOK | M_ZERO);
3237                         if (cm->cm_data == NULL) {
3238                                 device_printf(sc->mfi_dev, "Malloc failed\n");
3239                                 goto out;
3240                         }
3241                 } else {
3242                         cm->cm_data = 0;
3243                 }
3244
3245                 /* restore header context */
3246                 cm->cm_frame->header.context = context;
3247
3248                 if (cm->cm_frame->header.cmd == MFI_CMD_STP) {
3249                         res = mfi_stp_cmd(sc, cm, arg);
3250                         if (res != 0)
3251                                 goto out;
3252                 } else {
3253                         temp = data;
3254                         if ((cm->cm_flags & MFI_CMD_DATAOUT) ||
3255                             (cm->cm_frame->header.cmd == MFI_CMD_STP)) {
3256                                 for (i = 0; i < ioc->mfi_sge_count; i++) {
3257 #ifdef COMPAT_FREEBSD32
3258                                         if (cmd == MFI_CMD) {
3259 #endif
3260                                                 /* Native */
3261                                                 addr = ioc->mfi_sgl[i].iov_base;
3262                                                 len = ioc->mfi_sgl[i].iov_len;
3263 #ifdef COMPAT_FREEBSD32
3264                                         } else {
3265                                                 /* 32bit on 64bit */
3266                                                 ioc32 = (struct mfi_ioc_packet32 *)ioc;
3267                                                 addr = PTRIN(ioc32->mfi_sgl[i].iov_base);
3268                                                 len = ioc32->mfi_sgl[i].iov_len;
3269                                         }
3270 #endif
3271                                         error = copyin(addr, temp, len);
3272                                         if (error != 0) {
3273                                                 device_printf(sc->mfi_dev,
3274                                                     "Copy in failed\n");
3275                                                 goto out;
3276                                         }
3277                                         temp = &temp[len];
3278                                 }
3279                         }
3280                 }
3281
3282                 if (cm->cm_frame->header.cmd == MFI_CMD_DCMD)
3283                         locked = mfi_config_lock(sc,
3284                              cm->cm_frame->dcmd.opcode);
3285
3286                 if (cm->cm_frame->header.cmd == MFI_CMD_PD_SCSI_IO) {
3287                         cm->cm_frame->pass.sense_addr_lo =
3288                             (uint32_t)cm->cm_sense_busaddr;
3289                         cm->cm_frame->pass.sense_addr_hi =
3290                             (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
3291                 }
3292                 mtx_lock(&sc->mfi_io_lock);
3293                 skip_pre_post = mfi_check_for_sscd (sc, cm);
3294                 if (!skip_pre_post) {
3295                         error = mfi_check_command_pre(sc, cm);
3296                         if (error) {
3297                                 mtx_unlock(&sc->mfi_io_lock);
3298                                 goto out;
3299                         }
3300                 }
3301                 if ((error = mfi_wait_command(sc, cm)) != 0) {
3302                         device_printf(sc->mfi_dev,
3303                             "Controller polled failed\n");
3304                         mtx_unlock(&sc->mfi_io_lock);
3305                         goto out;
3306                 }
3307                 if (!skip_pre_post) {
3308                         mfi_check_command_post(sc, cm);
3309                 }
3310                 mtx_unlock(&sc->mfi_io_lock);
3311
3312                 if (cm->cm_frame->header.cmd != MFI_CMD_STP) {
3313                         temp = data;
3314                         if ((cm->cm_flags & MFI_CMD_DATAIN) ||
3315                             (cm->cm_frame->header.cmd == MFI_CMD_STP)) {
3316                                 for (i = 0; i < ioc->mfi_sge_count; i++) {
3317 #ifdef COMPAT_FREEBSD32
3318                                         if (cmd == MFI_CMD) {
3319 #endif
3320                                                 /* Native */
3321                                                 addr = ioc->mfi_sgl[i].iov_base;
3322                                                 len = ioc->mfi_sgl[i].iov_len;
3323 #ifdef COMPAT_FREEBSD32
3324                                         } else {
3325                                                 /* 32bit on 64bit */
3326                                                 ioc32 = (struct mfi_ioc_packet32 *)ioc;
3327                                                 addr = PTRIN(ioc32->mfi_sgl[i].iov_base);
3328                                                 len = ioc32->mfi_sgl[i].iov_len;
3329                                         }
3330 #endif
3331                                         error = copyout(temp, addr, len);
3332                                         if (error != 0) {
3333                                                 device_printf(sc->mfi_dev,
3334                                                     "Copy out failed\n");
3335                                                 goto out;
3336                                         }
3337                                         temp = &temp[len];
3338                                 }
3339                         }
3340                 }
3341
3342                 if (ioc->mfi_sense_len) {
3343                         /* get user-space sense ptr then copy out sense */
3344                         bcopy(&ioc->mfi_frame.raw[ioc->mfi_sense_off],
3345                             &sense_ptr.sense_ptr_data[0],
3346                             sizeof(sense_ptr.sense_ptr_data));
3347 #ifdef COMPAT_FREEBSD32
3348                         if (cmd != MFI_CMD) {
3349                                 /*
3350                                  * not 64bit native so zero out any address
3351                                  * over 32bit */
3352                                 sense_ptr.addr.high = 0;
3353                         }
3354 #endif
3355                         error = copyout(cm->cm_sense, sense_ptr.user_space,
3356                             ioc->mfi_sense_len);
3357                         if (error != 0) {
3358                                 device_printf(sc->mfi_dev,
3359                                     "Copy out failed\n");
3360                                 goto out;
3361                         }
3362                 }
3363
3364                 ioc->mfi_frame.hdr.cmd_status = cm->cm_frame->header.cmd_status;
3365 out:
3366                 mfi_config_unlock(sc, locked);
3367                 if (data)
3368                         free(data, M_MFIBUF);
3369                 if (cm->cm_frame->header.cmd == MFI_CMD_STP) {
3370                         for (i = 0; i < 2; i++) {
3371                                 if (sc->kbuff_arr[i]) {
3372                                         if (sc->mfi_kbuff_arr_busaddr != 0)
3373                                                 bus_dmamap_unload(
3374                                                     sc->mfi_kbuff_arr_dmat[i],
3375                                                     sc->mfi_kbuff_arr_dmamap[i]
3376                                                     );
3377                                         if (sc->kbuff_arr[i] != NULL)
3378                                                 bus_dmamem_free(
3379                                                     sc->mfi_kbuff_arr_dmat[i],
3380                                                     sc->kbuff_arr[i],
3381                                                     sc->mfi_kbuff_arr_dmamap[i]
3382                                                     );
3383                                         if (sc->mfi_kbuff_arr_dmat[i] != NULL)
3384                                                 bus_dma_tag_destroy(
3385                                                     sc->mfi_kbuff_arr_dmat[i]);
3386                                 }
3387                         }
3388                 }
3389                 if (cm) {
3390                         mtx_lock(&sc->mfi_io_lock);
3391                         mfi_release_command(cm);
3392                         mtx_unlock(&sc->mfi_io_lock);
3393                 }
3394
3395                 break;
3396                 }
3397         case MFI_SET_AEN:
3398                 aen = (struct mfi_ioc_aen *)arg;
3399                 mtx_lock(&sc->mfi_io_lock);
3400                 error = mfi_aen_register(sc, aen->aen_seq_num,
3401                     aen->aen_class_locale);
3402                 mtx_unlock(&sc->mfi_io_lock);
3403
3404                 break;
3405         case MFI_LINUX_CMD_2: /* Firmware Linux ioctl shim */
3406                 {
3407                         devclass_t devclass;
3408                         struct mfi_linux_ioc_packet l_ioc;
3409                         int adapter;
3410
3411                         devclass = devclass_find("mfi");
3412                         if (devclass == NULL)
3413                                 return (ENOENT);
3414
3415                         error = copyin(arg, &l_ioc, sizeof(l_ioc));
3416                         if (error)
3417                                 return (error);
3418                         adapter = l_ioc.lioc_adapter_no;
3419                         sc = devclass_get_softc(devclass, adapter);
3420                         if (sc == NULL)
3421                                 return (ENOENT);
3422                         return (mfi_linux_ioctl_int(sc->mfi_cdev,
3423                             cmd, arg, flag, td));
3424                         break;
3425                 }
3426         case MFI_LINUX_SET_AEN_2: /* AEN Linux ioctl shim */
3427                 {
3428                         devclass_t devclass;
3429                         struct mfi_linux_ioc_aen l_aen;
3430                         int adapter;
3431
3432                         devclass = devclass_find("mfi");
3433                         if (devclass == NULL)
3434                                 return (ENOENT);
3435
3436                         error = copyin(arg, &l_aen, sizeof(l_aen));
3437                         if (error)
3438                                 return (error);
3439                         adapter = l_aen.laen_adapter_no;
3440                         sc = devclass_get_softc(devclass, adapter);
3441                         if (sc == NULL)
3442                                 return (ENOENT);
3443                         return (mfi_linux_ioctl_int(sc->mfi_cdev,
3444                             cmd, arg, flag, td));
3445                         break;
3446                 }
3447 #ifdef COMPAT_FREEBSD32
3448         case MFIIO_PASSTHRU32:
3449                 if (!SV_CURPROC_FLAG(SV_ILP32)) {
3450                         error = ENOTTY;
3451                         break;
3452                 }
3453                 iop_swab.ioc_frame      = iop32->ioc_frame;
3454                 iop_swab.buf_size       = iop32->buf_size;
3455                 iop_swab.buf            = PTRIN(iop32->buf);
3456                 iop                     = &iop_swab;
3457                 /* FALLTHROUGH */
3458 #endif
3459         case MFIIO_PASSTHRU:
3460                 error = mfi_user_command(sc, iop);
3461 #ifdef COMPAT_FREEBSD32
3462                 if (cmd == MFIIO_PASSTHRU32)
3463                         iop32->ioc_frame = iop_swab.ioc_frame;
3464 #endif
3465                 break;
3466         default:
3467                 device_printf(sc->mfi_dev, "IOCTL 0x%lx not handled\n", cmd);
3468                 error = ENOTTY;
3469                 break;
3470         }
3471
3472         return (error);
3473 }
3474
3475 static int
3476 mfi_linux_ioctl_int(struct cdev *dev, u_long cmd, caddr_t arg, int flag, struct thread *td)
3477 {
3478         struct mfi_softc *sc;
3479         struct mfi_linux_ioc_packet l_ioc;
3480         struct mfi_linux_ioc_aen l_aen;
3481         struct mfi_command *cm = NULL;
3482         struct mfi_aen *mfi_aen_entry;
3483         union mfi_sense_ptr sense_ptr;
3484         uint32_t context = 0;
3485         uint8_t *data = NULL, *temp;
3486         int i;
3487         int error, locked;
3488
3489         sc = dev->si_drv1;
3490         error = 0;
3491         switch (cmd) {
3492         case MFI_LINUX_CMD_2: /* Firmware Linux ioctl shim */
3493                 error = copyin(arg, &l_ioc, sizeof(l_ioc));
3494                 if (error != 0)
3495                         return (error);
3496
3497                 if (l_ioc.lioc_sge_count > MAX_LINUX_IOCTL_SGE) {
3498                         return (EINVAL);
3499                 }
3500
3501                 mtx_lock(&sc->mfi_io_lock);
3502                 if ((cm = mfi_dequeue_free(sc)) == NULL) {
3503                         mtx_unlock(&sc->mfi_io_lock);
3504                         return (EBUSY);
3505                 }
3506                 mtx_unlock(&sc->mfi_io_lock);
3507                 locked = 0;
3508
3509                 /*
3510                  * save off original context since copying from user
3511                  * will clobber some data
3512                  */
3513                 context = cm->cm_frame->header.context;
3514
3515                 bcopy(l_ioc.lioc_frame.raw, cm->cm_frame,
3516                       2 * MFI_DCMD_FRAME_SIZE); /* this isn't quite right */
3517                 cm->cm_total_frame_size = (sizeof(union mfi_sgl)
3518                       * l_ioc.lioc_sge_count) + l_ioc.lioc_sgl_off;
3519                 cm->cm_frame->header.scsi_status = 0;
3520                 cm->cm_frame->header.pad0 = 0;
3521                 if (l_ioc.lioc_sge_count)
3522                         cm->cm_sg =
3523                             (union mfi_sgl *)&cm->cm_frame->bytes[l_ioc.lioc_sgl_off];
3524                 cm->cm_flags = 0;
3525                 if (cm->cm_frame->header.flags & MFI_FRAME_DATAIN)
3526                         cm->cm_flags |= MFI_CMD_DATAIN;
3527                 if (cm->cm_frame->header.flags & MFI_FRAME_DATAOUT)
3528                         cm->cm_flags |= MFI_CMD_DATAOUT;
3529                 cm->cm_len = cm->cm_frame->header.data_len;
3530                 if (cm->cm_len &&
3531                       (cm->cm_flags & (MFI_CMD_DATAIN | MFI_CMD_DATAOUT))) {
3532                         cm->cm_data = data = malloc(cm->cm_len, M_MFIBUF,
3533                             M_WAITOK | M_ZERO);
3534                         if (cm->cm_data == NULL) {
3535                                 device_printf(sc->mfi_dev, "Malloc failed\n");
3536                                 goto out;
3537                         }
3538                 } else {
3539                         cm->cm_data = 0;
3540                 }
3541
3542                 /* restore header context */
3543                 cm->cm_frame->header.context = context;
3544
3545                 temp = data;
3546                 if (cm->cm_flags & MFI_CMD_DATAOUT) {
3547                         for (i = 0; i < l_ioc.lioc_sge_count; i++) {
3548                                 error = copyin(PTRIN(l_ioc.lioc_sgl[i].iov_base),
3549                                        temp,
3550                                        l_ioc.lioc_sgl[i].iov_len);
3551                                 if (error != 0) {
3552                                         device_printf(sc->mfi_dev,
3553                                             "Copy in failed\n");
3554                                         goto out;
3555                                 }
3556                                 temp = &temp[l_ioc.lioc_sgl[i].iov_len];
3557                         }
3558                 }
3559
3560                 if (cm->cm_frame->header.cmd == MFI_CMD_DCMD)
3561                         locked = mfi_config_lock(sc, cm->cm_frame->dcmd.opcode);
3562
3563                 if (cm->cm_frame->header.cmd == MFI_CMD_PD_SCSI_IO) {
3564                         cm->cm_frame->pass.sense_addr_lo =
3565                             (uint32_t)cm->cm_sense_busaddr;
3566                         cm->cm_frame->pass.sense_addr_hi =
3567                             (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32);
3568                 }
3569
3570                 mtx_lock(&sc->mfi_io_lock);
3571                 error = mfi_check_command_pre(sc, cm);
3572                 if (error) {
3573                         mtx_unlock(&sc->mfi_io_lock);
3574                         goto out;
3575                 }
3576
3577                 if ((error = mfi_wait_command(sc, cm)) != 0) {
3578                         device_printf(sc->mfi_dev,
3579                             "Controller polled failed\n");
3580                         mtx_unlock(&sc->mfi_io_lock);
3581                         goto out;
3582                 }
3583
3584                 mfi_check_command_post(sc, cm);
3585                 mtx_unlock(&sc->mfi_io_lock);
3586
3587                 temp = data;
3588                 if (cm->cm_flags & MFI_CMD_DATAIN) {
3589                         for (i = 0; i < l_ioc.lioc_sge_count; i++) {
3590                                 error = copyout(temp,
3591                                         PTRIN(l_ioc.lioc_sgl[i].iov_base),
3592                                         l_ioc.lioc_sgl[i].iov_len);
3593                                 if (error != 0) {
3594                                         device_printf(sc->mfi_dev,
3595                                             "Copy out failed\n");
3596                                         goto out;
3597                                 }
3598                                 temp = &temp[l_ioc.lioc_sgl[i].iov_len];
3599                         }
3600                 }
3601
3602                 if (l_ioc.lioc_sense_len) {
3603                         /* get user-space sense ptr then copy out sense */
3604                         bcopy(&((struct mfi_linux_ioc_packet*)arg)
3605                             ->lioc_frame.raw[l_ioc.lioc_sense_off],
3606                             &sense_ptr.sense_ptr_data[0],
3607                             sizeof(sense_ptr.sense_ptr_data));
3608 #ifdef __amd64__
3609                         /*
3610                          * only 32bit Linux support so zero out any
3611                          * address over 32bit
3612                          */
3613                         sense_ptr.addr.high = 0;
3614 #endif
3615                         error = copyout(cm->cm_sense, sense_ptr.user_space,
3616                             l_ioc.lioc_sense_len);
3617                         if (error != 0) {
3618                                 device_printf(sc->mfi_dev,
3619                                     "Copy out failed\n");
3620                                 goto out;
3621                         }
3622                 }
3623
3624                 error = copyout(&cm->cm_frame->header.cmd_status,
3625                         &((struct mfi_linux_ioc_packet*)arg)
3626                         ->lioc_frame.hdr.cmd_status,
3627                         1);
3628                 if (error != 0) {
3629                         device_printf(sc->mfi_dev,
3630                                       "Copy out failed\n");
3631                         goto out;
3632                 }
3633
3634 out:
3635                 mfi_config_unlock(sc, locked);
3636                 if (data)
3637                         free(data, M_MFIBUF);
3638                 if (cm) {
3639                         mtx_lock(&sc->mfi_io_lock);
3640                         mfi_release_command(cm);
3641                         mtx_unlock(&sc->mfi_io_lock);
3642                 }
3643
3644                 return (error);
3645         case MFI_LINUX_SET_AEN_2: /* AEN Linux ioctl shim */
3646                 error = copyin(arg, &l_aen, sizeof(l_aen));
3647                 if (error != 0)
3648                         return (error);
3649                 printf("AEN IMPLEMENTED for pid %d\n", curproc->p_pid);
3650                 mfi_aen_entry = malloc(sizeof(struct mfi_aen), M_MFIBUF,
3651                     M_WAITOK);
3652                 mtx_lock(&sc->mfi_io_lock);
3653                 if (mfi_aen_entry != NULL) {
3654                         mfi_aen_entry->p = curproc;
3655                         TAILQ_INSERT_TAIL(&sc->mfi_aen_pids, mfi_aen_entry,
3656                             aen_link);
3657                 }
3658                 error = mfi_aen_register(sc, l_aen.laen_seq_num,
3659                     l_aen.laen_class_locale);
3660
3661                 if (error != 0) {
3662                         TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry,
3663                             aen_link);
3664                         free(mfi_aen_entry, M_MFIBUF);
3665                 }
3666                 mtx_unlock(&sc->mfi_io_lock);
3667
3668                 return (error);
3669         default:
3670                 device_printf(sc->mfi_dev, "IOCTL 0x%lx not handled\n", cmd);
3671                 error = ENOENT;
3672                 break;
3673         }
3674
3675         return (error);
3676 }
3677
3678 static int
3679 mfi_poll(struct cdev *dev, int poll_events, struct thread *td)
3680 {
3681         struct mfi_softc *sc;
3682         int revents = 0;
3683
3684         sc = dev->si_drv1;
3685
3686         if (poll_events & (POLLIN | POLLRDNORM)) {
3687                 if (sc->mfi_aen_triggered != 0) {
3688                         revents |= poll_events & (POLLIN | POLLRDNORM);
3689                         sc->mfi_aen_triggered = 0;
3690                 }
3691                 if (sc->mfi_aen_triggered == 0 && sc->mfi_aen_cm == NULL) {
3692                         revents |= POLLERR;
3693                 }
3694         }
3695
3696         if (revents == 0) {
3697                 if (poll_events & (POLLIN | POLLRDNORM)) {
3698                         sc->mfi_poll_waiting = 1;
3699                         selrecord(td, &sc->mfi_select);
3700                 }
3701         }
3702
3703         return revents;
3704 }
3705
3706 static void
3707 mfi_dump_all(void)
3708 {
3709         struct mfi_softc *sc;
3710         struct mfi_command *cm;
3711         devclass_t dc;
3712         time_t deadline;
3713         int timedout;
3714         int i;
3715
3716         dc = devclass_find("mfi");
3717         if (dc == NULL) {
3718                 printf("No mfi dev class\n");
3719                 return;
3720         }
3721
3722         for (i = 0; ; i++) {
3723                 sc = devclass_get_softc(dc, i);
3724                 if (sc == NULL)
3725                         break;
3726                 device_printf(sc->mfi_dev, "Dumping\n\n");
3727                 timedout = 0;
3728                 deadline = time_uptime - mfi_cmd_timeout;
3729                 mtx_lock(&sc->mfi_io_lock);
3730                 TAILQ_FOREACH(cm, &sc->mfi_busy, cm_link) {
3731                         if (cm->cm_timestamp <= deadline) {
3732                                 device_printf(sc->mfi_dev,
3733                                     "COMMAND %p TIMEOUT AFTER %d SECONDS\n",
3734                                     cm, (int)(time_uptime - cm->cm_timestamp));
3735                                 MFI_PRINT_CMD(cm);
3736                                 timedout++;
3737                         }
3738                 }
3739
3740 #if 0
3741                 if (timedout)
3742                         MFI_DUMP_CMDS(sc);
3743 #endif
3744
3745                 mtx_unlock(&sc->mfi_io_lock);
3746         }
3747
3748         return;
3749 }
3750
3751 static void
3752 mfi_timeout(void *data)
3753 {
3754         struct mfi_softc *sc = (struct mfi_softc *)data;
3755         struct mfi_command *cm, *tmp;
3756         time_t deadline;
3757         int timedout = 0;
3758
3759         deadline = time_uptime - mfi_cmd_timeout;
3760         if (sc->adpreset == 0) {
3761                 if (!mfi_tbolt_reset(sc)) {
3762                         callout_reset(&sc->mfi_watchdog_callout,
3763                             mfi_cmd_timeout * hz, mfi_timeout, sc);
3764                         return;
3765                 }
3766         }
3767         mtx_lock(&sc->mfi_io_lock);
3768         TAILQ_FOREACH_SAFE(cm, &sc->mfi_busy, cm_link, tmp) {
3769                 if (sc->mfi_aen_cm == cm || sc->mfi_map_sync_cm == cm)
3770                         continue;
3771                 if (cm->cm_timestamp <= deadline) {
3772                         if (sc->adpreset != 0 && sc->issuepend_done == 0) {
3773                                 cm->cm_timestamp = time_uptime;
3774                         } else {
3775                                 device_printf(sc->mfi_dev,
3776                                     "COMMAND %p TIMEOUT AFTER %d SECONDS\n",
3777                                      cm, (int)(time_uptime - cm->cm_timestamp)
3778                                      );
3779                                 MFI_PRINT_CMD(cm);
3780                                 MFI_VALIDATE_CMD(sc, cm);
3781                                 /*
3782                                  * While commands can get stuck forever we do
3783                                  * not fail them as there is no way to tell if
3784                                  * the controller has actually processed them
3785                                  * or not.
3786                                  *
3787                                  * In addition its very likely that force
3788                                  * failing a command here would cause a panic
3789                                  * e.g. in UFS.
3790                                  */
3791                                 timedout++;
3792                         }
3793                 }
3794         }
3795
3796 #if 0
3797         if (timedout)
3798                 MFI_DUMP_CMDS(sc);
3799 #endif
3800
3801         mtx_unlock(&sc->mfi_io_lock);
3802
3803         callout_reset(&sc->mfi_watchdog_callout, mfi_cmd_timeout * hz,
3804             mfi_timeout, sc);
3805
3806         if (0)
3807                 mfi_dump_all();
3808         return;
3809 }