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