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