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