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