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