sys/dev/mfi/mfi.c

   1 /*-
   2  * Copyright (c) 2006 IronPort Systems
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26 /*-
  27  * Copyright (c) 2007 LSI Corp.
  28  * Copyright (c) 2007 Rajesh Prabhakaran.
  29  * All rights reserved.
  30  *
  31  * Redistribution and use in source and binary forms, with or without
  32  * modification, are permitted provided that the following conditions
  33  * are met:
  34  * 1. Redistributions of source code must retain the above copyright
  35  *    notice, this list of conditions and the following disclaimer.
  36  * 2. Redistributions in binary form must reproduce the above copyright
  37  *    notice, this list of conditions and the following disclaimer in the
  38  *    documentation and/or other materials provided with the distribution.
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  50  * SUCH DAMAGE.
  51  */
  52
  53 #include <sys/cdefs.h>
  54 __FBSDID("$FreeBSD$");
  55
  56 #include "opt_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/poll.h>
  64 #include <sys/selinfo.h>
  65 #include <sys/bus.h>
  66 #include <sys/conf.h>
  67 #include <sys/eventhandler.h>
  68 #include <sys/rman.h>
  69 #include <sys/bus_dma.h>
  70 #include <sys/bio.h>
  71 #include <sys/ioccom.h>
  72 #include <sys/uio.h>
  73 #include <sys/proc.h>
  74 #include <sys/signalvar.h>
  75
  76 #include <machine/bus.h>
  77 #include <machine/resource.h>
  78
  79 #include <dev/mfi/mfireg.h>
  80 #include <dev/mfi/mfi_ioctl.h>
  81 #include <dev/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_wait_command(struct mfi_softc *, struct mfi_command *);
  86 static int      mfi_get_controller_info(struct mfi_softc *);
  87 static int      mfi_get_log_state(struct mfi_softc *,
  88                     struct mfi_evt_log_state **);
  89 static int      mfi_parse_entries(struct mfi_softc *, int, int);
  90 static int      mfi_dcmd_command(struct mfi_softc *, struct mfi_command **,
  91                     uint32_t, void **, size_t);
  92 static void     mfi_data_cb(void *, bus_dma_segment_t *, int, int);
  93 static void     mfi_startup(void *arg);
  94 static void     mfi_intr(void *arg);
  95 static void     mfi_ldprobe(struct mfi_softc *sc);
  96 static int      mfi_aen_register(struct mfi_softc *sc, int seq, int locale);
  97 static void     mfi_aen_complete(struct mfi_command *);
  98 static int      mfi_aen_setup(struct mfi_softc *, uint32_t);
  99 static int      mfi_add_ld(struct mfi_softc *sc, int);
 100 static void     mfi_add_ld_complete(struct mfi_command *);
 101 static struct mfi_command * mfi_bio_command(struct mfi_softc *);
 102 static void     mfi_bio_complete(struct mfi_command *);
 103 static int      mfi_mapcmd(struct mfi_softc *, struct mfi_command *);
 104 static int      mfi_send_frame(struct mfi_softc *, struct mfi_command *);
 105 static void     mfi_complete(struct mfi_softc *, struct mfi_command *);
 106 static int      mfi_abort(struct mfi_softc *, struct mfi_command *);
 107 static int      mfi_linux_ioctl_int(struct cdev *, u_long, caddr_t, int, struct thread *);
 108 static void     mfi_timeout(void *);
 109 static int      mfi_user_command(struct mfi_softc *,
 110                     struct mfi_ioc_passthru *);
 111 static void     mfi_enable_intr_xscale(struct mfi_softc *sc);
 112 static void     mfi_enable_intr_ppc(struct mfi_softc *sc);
 113 static int32_t  mfi_read_fw_status_xscale(struct mfi_softc *sc);
 114 static int32_t  mfi_read_fw_status_ppc(struct mfi_softc *sc);
 115 static int      mfi_check_clear_intr_xscale(struct mfi_softc *sc);
 116 static int      mfi_check_clear_intr_ppc(struct mfi_softc *sc);
 117 static void     mfi_issue_cmd_xscale(struct mfi_softc *sc,uint32_t bus_add,uint32_t frame_cnt);
 118 static void     mfi_issue_cmd_ppc(struct mfi_softc *sc,uint32_t bus_add,uint32_t frame_cnt);
 119
 120 SYSCTL_NODE(_hw, OID_AUTO, mfi, CTLFLAG_RD, 0, "MFI driver parameters");
 121 static int      mfi_event_locale = MFI_EVT_LOCALE_ALL;
 122 TUNABLE_INT("hw.mfi.event_locale", &mfi_event_locale);
 123 SYSCTL_INT(_hw_mfi, OID_AUTO, event_locale, CTLFLAG_RW, &mfi_event_locale,
 124             0, "event message locale");
 125
 126 static int      mfi_event_class = MFI_EVT_CLASS_INFO;
 127 TUNABLE_INT("hw.mfi.event_class", &mfi_event_class);
 128 SYSCTL_INT(_hw_mfi, OID_AUTO, event_class, CTLFLAG_RW, &mfi_event_class,
 129           0, "event message class");
 130
 131 static int      mfi_max_cmds = 128;
 132 TUNABLE_INT("hw.mfi.max_cmds", &mfi_max_cmds);
 133 SYSCTL_INT(_hw_mfi, OID_AUTO, max_cmds, CTLFLAG_RD, &mfi_max_cmds,
 134            0, "Max commands");
 135
 136 /* Management interface */
 137 static d_open_t         mfi_open;
 138 static d_close_t        mfi_close;
 139 static d_ioctl_t        mfi_ioctl;
 140 static d_poll_t         mfi_poll;
 141
 142 static struct cdevsw mfi_cdevsw = {
 143         .d_version =    D_VERSION,
 144         .d_flags =      0,
 145         .d_open =       mfi_open,
 146         .d_close =      mfi_close,
 147         .d_ioctl =      mfi_ioctl,
 148         .d_poll =       mfi_poll,
 149         .d_name =       "mfi",
 150 };
 151
 152 MALLOC_DEFINE(M_MFIBUF, "mfibuf", "Buffers for the MFI driver");
 153
 154 #define MFI_INQ_LENGTH SHORT_INQUIRY_LENGTH
 155
 156 static void
 157 mfi_enable_intr_xscale(struct mfi_softc *sc)
 158 {
 159         MFI_WRITE4(sc, MFI_OMSK, 0x01);
 160 }
 161
 162 static void
 163 mfi_enable_intr_ppc(struct mfi_softc *sc)
 164 {
 165         MFI_WRITE4(sc, MFI_ODCR0, 0xFFFFFFFF);
 166         if (sc->mfi_flags & MFI_FLAGS_1078) {
 167                 MFI_WRITE4(sc, MFI_OMSK, ~MFI_1078_EIM);
 168         } else if (sc->mfi_flags & MFI_FLAGS_GEN2) {
 169                 MFI_WRITE4(sc, MFI_OMSK, ~MFI_GEN2_EIM);
 170         }
 171 }
 172
 173 static int32_t
 174 mfi_read_fw_status_xscale(struct mfi_softc *sc)
 175 {
 176         return MFI_READ4(sc, MFI_OMSG0);
 177 }
 178
 179 static int32_t
 180 mfi_read_fw_status_ppc(struct mfi_softc *sc)
 181 {
 182         return MFI_READ4(sc, MFI_OSP0);
 183 }
 184
 185 static int
 186 mfi_check_clear_intr_xscale(struct mfi_softc *sc)
 187 {
 188         int32_t status;
 189
 190         status = MFI_READ4(sc, MFI_OSTS);
 191         if ((status & MFI_OSTS_INTR_VALID) == 0)
 192                 return 1;
 193
 194         MFI_WRITE4(sc, MFI_OSTS, status);
 195         return 0;
 196 }
 197
 198 static int
 199 mfi_check_clear_intr_ppc(struct mfi_softc *sc)
 200 {
 201         int32_t status;
 202
 203         status = MFI_READ4(sc, MFI_OSTS);
 204         if (sc->mfi_flags & MFI_FLAGS_1078) {
 205                 if (!(status & MFI_1078_RM)) {
 206                         return 1;
 207                 }
 208         } else if (sc->mfi_flags & MFI_FLAGS_GEN2) {
 209                 if (!(status & MFI_GEN2_RM)) {
 210                         return 1;
 211                 }
 212         }
 213
 214         MFI_WRITE4(sc, MFI_ODCR0, status);
 215         return 0;
 216 }
 217
 218 static void
 219 mfi_issue_cmd_xscale(struct mfi_softc *sc,uint32_t bus_add,uint32_t frame_cnt)
 220 {
 221         MFI_WRITE4(sc, MFI_IQP,(bus_add >>3)|frame_cnt);
 222 }
 223
 224 static void
 225 mfi_issue_cmd_ppc(struct mfi_softc *sc,uint32_t bus_add,uint32_t frame_cnt)
 226 {
 227         MFI_WRITE4(sc, MFI_IQP, (bus_add |frame_cnt <<1)|1 );
 228 }
 229
 230 static int
 231 mfi_transition_firmware(struct mfi_softc *sc)
 232 {
 233         uint32_t fw_state, cur_state;
 234         int max_wait, i;
 235
 236         fw_state = sc->mfi_read_fw_status(sc)& MFI_FWSTATE_MASK;
 237         while (fw_state != MFI_FWSTATE_READY) {
 238                 if (bootverbose)
 239                         device_printf(sc->mfi_dev, "Waiting for firmware to "
 240                         "become ready\n");
 241                 cur_state = fw_state;
 242                 switch (fw_state) {
 243                 case MFI_FWSTATE_FAULT:
 244                         device_printf(sc->mfi_dev, "Firmware fault\n");
 245                         return (ENXIO);
 246                 case MFI_FWSTATE_WAIT_HANDSHAKE:
 247                         MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_CLEAR_HANDSHAKE);
 248                         max_wait = 2;
 249                         break;
 250                 case MFI_FWSTATE_OPERATIONAL:
 251                         MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_READY);
 252                         max_wait = 10;
 253                         break;
 254                 case MFI_FWSTATE_UNDEFINED:
 255                 case MFI_FWSTATE_BB_INIT:
 256                         max_wait = 2;
 257                         break;
 258                 case MFI_FWSTATE_FW_INIT:
 259                 case MFI_FWSTATE_DEVICE_SCAN:
 260                 case MFI_FWSTATE_FLUSH_CACHE:
 261                         max_wait = 20;
 262                         break;
 263                 case MFI_FWSTATE_BOOT_MESSAGE_PENDING:
 264                         MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_HOTPLUG);
 265                         max_wait = 10;
 266                         break;
 267                 default:
 268                         device_printf(sc->mfi_dev,"Unknown firmware state %#x\n",
 269                             fw_state);
 270                         return (ENXIO);
 271                 }
 272                 for (i = 0; i < (max_wait * 10); i++) {
 273                         fw_state = sc->mfi_read_fw_status(sc) & MFI_FWSTATE_MASK;
 274                         if (fw_state == cur_state)
 275                                 DELAY(100000);
 276                         else
 277                                 break;
 278                 }
 279                 if (fw_state == cur_state) {
 280                         device_printf(sc->mfi_dev, "Firmware stuck in state "
 281                             "%#x\n", fw_state);
 282                         return (ENXIO);
 283                 }
 284         }
 285         return (0);
 286 }
 287
 288 static void
 289 mfi_addr32_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
 290 {
 291         uint32_t *addr;
 292
 293         addr = arg;
 294         *addr = segs[0].ds_addr;
 295 }
 296
 297 int
 298 mfi_attach(struct mfi_softc *sc)
 299 {
 300         uint32_t status;
 301         int error, commsz, framessz, sensesz;
 302         int frames, unit, max_fw_sge;
 303
 304         device_printf(sc->mfi_dev, "Megaraid SAS driver Ver 3.00 \n");
 305
 306         mtx_init(&sc->mfi_io_lock, "MFI I/O lock", NULL, MTX_DEF);
 307         sx_init(&sc->mfi_config_lock, "MFI config");
 308         TAILQ_INIT(&sc->mfi_ld_tqh);
 309         TAILQ_INIT(&sc->mfi_aen_pids);
 310         TAILQ_INIT(&sc->mfi_cam_ccbq);
 311
 312         mfi_initq_free(sc);
 313         mfi_initq_ready(sc);
 314         mfi_initq_busy(sc);
 315         mfi_initq_bio(sc);
 316
 317         if (sc->mfi_flags & MFI_FLAGS_1064R) {
 318                 sc->mfi_enable_intr = mfi_enable_intr_xscale;
 319                 sc->mfi_read_fw_status = mfi_read_fw_status_xscale;
 320                 sc->mfi_check_clear_intr = mfi_check_clear_intr_xscale;
 321                 sc->mfi_issue_cmd = mfi_issue_cmd_xscale;
 322         }
 323         else {
 324                 sc->mfi_enable_intr =  mfi_enable_intr_ppc;
 325                 sc->mfi_read_fw_status = mfi_read_fw_status_ppc;
 326                 sc->mfi_check_clear_intr = mfi_check_clear_intr_ppc;
 327                 sc->mfi_issue_cmd = mfi_issue_cmd_ppc;
 328         }
 329
 330
 331         /* Before we get too far, see if the firmware is working */
 332         if ((error = mfi_transition_firmware(sc)) != 0) {
 333                 device_printf(sc->mfi_dev, "Firmware not in READY state, "
 334                     "error %d\n", error);
 335                 return (ENXIO);
 336         }
 337
 338         /*
 339          * Get information needed for sizing the contiguous memory for the
 340          * frame pool.  Size down the sgl parameter since we know that
 341          * we will never need more than what's required for MAXPHYS.
 342          * It would be nice if these constants were available at runtime
 343          * instead of compile time.
 344          */
 345         status = sc->mfi_read_fw_status(sc);
 346         sc->mfi_max_fw_cmds = status & MFI_FWSTATE_MAXCMD_MASK;
 347         max_fw_sge = (status & MFI_FWSTATE_MAXSGL_MASK) >> 16;
 348         sc->mfi_max_sge = min(max_fw_sge, ((MFI_MAXPHYS / PAGE_SIZE) + 1));
 349
 350         /*
 351          * Create the dma tag for data buffers.  Used both for block I/O
 352          * and for various internal data queries.
 353          */
 354         if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 355                                 1, 0,                   /* algnmnt, boundary */
 356                                 BUS_SPACE_MAXADDR,      /* lowaddr */
 357                                 BUS_SPACE_MAXADDR,      /* highaddr */
 358                                 NULL, NULL,             /* filter, filterarg */
 359                                 BUS_SPACE_MAXSIZE_32BIT,/* maxsize */
 360                                 sc->mfi_max_sge,        /* nsegments */
 361                                 BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */
 362                                 BUS_DMA_ALLOCNOW,       /* flags */
 363                                 busdma_lock_mutex,      /* lockfunc */
 364                                 &sc->mfi_io_lock,       /* lockfuncarg */
 365                                 &sc->mfi_buffer_dmat)) {
 366                 device_printf(sc->mfi_dev, "Cannot allocate buffer DMA tag\n");
 367                 return (ENOMEM);
 368         }
 369
 370         /*
 371          * Allocate DMA memory for the comms queues.  Keep it under 4GB for
 372          * efficiency.  The mfi_hwcomms struct includes space for 1 reply queue
 373          * entry, so the calculated size here will be will be 1 more than
 374          * mfi_max_fw_cmds.  This is apparently a requirement of the hardware.
 375          */
 376         commsz = (sizeof(uint32_t) * sc->mfi_max_fw_cmds) +
 377             sizeof(struct mfi_hwcomms);
 378         if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 379                                 1, 0,                   /* algnmnt, boundary */
 380                                 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
 381                                 BUS_SPACE_MAXADDR,      /* highaddr */
 382                                 NULL, NULL,             /* filter, filterarg */
 383                                 commsz,                 /* maxsize */
 384                                 1,                      /* msegments */
 385                                 commsz,                 /* maxsegsize */
 386                                 0,                      /* flags */
 387                                 NULL, NULL,             /* lockfunc, lockarg */
 388                                 &sc->mfi_comms_dmat)) {
 389                 device_printf(sc->mfi_dev, "Cannot allocate comms DMA tag\n");
 390                 return (ENOMEM);
 391         }
 392         if (bus_dmamem_alloc(sc->mfi_comms_dmat, (void **)&sc->mfi_comms,
 393             BUS_DMA_NOWAIT, &sc->mfi_comms_dmamap)) {
 394                 device_printf(sc->mfi_dev, "Cannot allocate comms memory\n");
 395                 return (ENOMEM);
 396         }
 397         bzero(sc->mfi_comms, commsz);
 398         bus_dmamap_load(sc->mfi_comms_dmat, sc->mfi_comms_dmamap,
 399             sc->mfi_comms, commsz, mfi_addr32_cb, &sc->mfi_comms_busaddr, 0);
 400
 401         /*
 402          * Allocate DMA memory for the command frames.  Keep them in the
 403          * lower 4GB for efficiency.  Calculate the size of the commands at
 404          * the same time; each command is one 64 byte frame plus a set of
 405          * additional frames for holding sg lists or other data.
 406          * The assumption here is that the SG list will start at the second
 407          * frame and not use the unused bytes in the first frame.  While this
 408          * isn't technically correct, it simplifies the calculation and allows
 409          * for command frames that might be larger than an mfi_io_frame.
 410          */
 411         if (sizeof(bus_addr_t) == 8) {
 412                 sc->mfi_sge_size = sizeof(struct mfi_sg64);
 413                 sc->mfi_flags |= MFI_FLAGS_SG64;
 414         } else {
 415                 sc->mfi_sge_size = sizeof(struct mfi_sg32);
 416         }
 417         frames = (sc->mfi_sge_size * sc->mfi_max_sge - 1) / MFI_FRAME_SIZE + 2;
 418         sc->mfi_cmd_size = frames * MFI_FRAME_SIZE;
 419         framessz = sc->mfi_cmd_size * sc->mfi_max_fw_cmds;
 420         if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 421                                 64, 0,                  /* algnmnt, boundary */
 422                                 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
 423                                 BUS_SPACE_MAXADDR,      /* highaddr */
 424                                 NULL, NULL,             /* filter, filterarg */
 425                                 framessz,               /* maxsize */
 426                                 1,                      /* nsegments */
 427                                 framessz,               /* maxsegsize */
 428                                 0,                      /* flags */
 429                                 NULL, NULL,             /* lockfunc, lockarg */
 430                                 &sc->mfi_frames_dmat)) {
 431                 device_printf(sc->mfi_dev, "Cannot allocate frame DMA tag\n");
 432                 return (ENOMEM);
 433         }
 434         if (bus_dmamem_alloc(sc->mfi_frames_dmat, (void **)&sc->mfi_frames,
 435             BUS_DMA_NOWAIT, &sc->mfi_frames_dmamap)) {
 436                 device_printf(sc->mfi_dev, "Cannot allocate frames memory\n");
 437                 return (ENOMEM);
 438         }
 439         bzero(sc->mfi_frames, framessz);
 440         bus_dmamap_load(sc->mfi_frames_dmat, sc->mfi_frames_dmamap,
 441             sc->mfi_frames, framessz, mfi_addr32_cb, &sc->mfi_frames_busaddr,0);
 442
 443         /*
 444          * Allocate DMA memory for the frame sense data.  Keep them in the
 445          * lower 4GB for efficiency
 446          */
 447         sensesz = sc->mfi_max_fw_cmds * MFI_SENSE_LEN;
 448         if (bus_dma_tag_create( sc->mfi_parent_dmat,    /* parent */
 449                                 4, 0,                   /* algnmnt, boundary */
 450                                 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
 451                                 BUS_SPACE_MAXADDR,      /* highaddr */
 452                                 NULL, NULL,             /* filter, filterarg */
 453                                 sensesz,                /* maxsize */
 454                                 1,                      /* nsegments */
 455                                 sensesz,                /* maxsegsize */
 456                                 0,                      /* flags */
 457                                 NULL, NULL,             /* lockfunc, lockarg */
 458                                 &sc->mfi_sense_dmat)) {
 459                 device_printf(sc->mfi_dev, "Cannot allocate sense DMA tag\n");
 460                 return (ENOMEM);
 461         }
 462         if (bus_dmamem_alloc(sc->mfi_sense_dmat, (void **)&sc->mfi_sense,
 463             BUS_DMA_NOWAIT, &sc->mfi_sense_dmamap)) {
 464                 device_printf(sc->mfi_dev, "Cannot allocate sense memory\n");
 465                 return (ENOMEM);
 466         }
 467         bus_dmamap_load(sc->mfi_sense_dmat, sc->mfi_sense_dmamap,
 468             sc->mfi_sense, sensesz, mfi_addr32_cb, &sc->mfi_sense_busaddr, 0);
 469
 470         if ((error = mfi_alloc_commands(sc)) != 0)
 471                 return (error);
 472
 473         if ((error = mfi_comms_init(sc)) != 0)
 474                 return (error);
 475
 476         if ((error = mfi_get_controller_info(sc)) != 0)
 477                 return (error);
 478
 479         mtx_lock(&sc->mfi_io_lock);
 480         if ((error = mfi_aen_setup(sc, 0), 0) != 0) {
 481                 mtx_unlock(&sc->mfi_io_lock);
 482                 return (error);
 483         }
 484         mtx_unlock(&sc->mfi_io_lock);
 485
 486         /*
 487          * Set up the interrupt handler.  XXX This should happen in
 488          * mfi_pci.c
 489          */
 490         sc->mfi_irq_rid = 0;
 491         if ((sc->mfi_irq = bus_alloc_resource_any(sc->mfi_dev, SYS_RES_IRQ,
 492             &sc->mfi_irq_rid, RF_SHAREABLE | RF_ACTIVE)) == NULL) {
 493                 device_printf(sc->mfi_dev, "Cannot allocate interrupt\n");
 494                 return (EINVAL);
 495         }
 496         if (bus_setup_intr(sc->mfi_dev, sc->mfi_irq, INTR_MPSAFE|INTR_TYPE_BIO,
 497             NULL, mfi_intr, sc, &sc->mfi_intr)) {
 498                 device_printf(sc->mfi_dev, "Cannot set up interrupt\n");
 499                 return (EINVAL);
 500         }
 501
 502         /* Register a config hook to probe the bus for arrays */
 503         sc->mfi_ich.ich_func = mfi_startup;
 504         sc->mfi_ich.ich_arg = sc;
 505         if (config_intrhook_establish(&sc->mfi_ich) != 0) {
 506                 device_printf(sc->mfi_dev, "Cannot establish configuration "
 507                     "hook\n");
 508                 return (EINVAL);
 509         }
 510
 511         /*
 512          * Register a shutdown handler.
 513          */
 514         if ((sc->mfi_eh = EVENTHANDLER_REGISTER(shutdown_final, mfi_shutdown,
 515             sc, SHUTDOWN_PRI_DEFAULT)) == NULL) {
 516                 device_printf(sc->mfi_dev, "Warning: shutdown event "
 517                     "registration failed\n");
 518         }
 519
 520         /*
 521          * Create the control device for doing management
 522          */
 523         unit = device_get_unit(sc->mfi_dev);
 524         sc->mfi_cdev = make_dev(&mfi_cdevsw, unit, UID_ROOT, GID_OPERATOR,
 525             0640, "mfi%d", unit);
 526         if (unit == 0)
 527                 make_dev_alias(sc->mfi_cdev, "megaraid_sas_ioctl_node");
 528         if (sc->mfi_cdev != NULL)
 529                 sc->mfi_cdev->si_drv1 = sc;
 530         SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->mfi_dev),
 531             SYSCTL_CHILDREN(device_get_sysctl_tree(sc->mfi_dev)),
 532             OID_AUTO, "delete_busy_volumes", CTLFLAG_RW,
 533             &sc->mfi_delete_busy_volumes, 0, "Allow removal of busy volumes");
 534         SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->mfi_dev),
 535             SYSCTL_CHILDREN(device_get_sysctl_tree(sc->mfi_dev)),
 536             OID_AUTO, "keep_deleted_volumes", CTLFLAG_RW,
 537             &sc->mfi_keep_deleted_volumes, 0,
 538             "Don't detach the mfid device for a busy volume that is deleted");
 539
 540         device_add_child(sc->mfi_dev, "mfip", -1);
 541         bus_generic_attach(sc->mfi_dev);
 542
 543         /* Start the timeout watchdog */
 544         callout_init(&sc->mfi_watchdog_callout, CALLOUT_MPSAFE);
 545         callout_reset(&sc->mfi_watchdog_callout, MFI_CMD_TIMEOUT * hz,
 546             mfi_timeout, sc);
 547
 548         return (0);
 549 }
 550
 551 static int
 552 mfi_alloc_commands(struct mfi_softc *sc)
 553 {
 554         struct mfi_command *cm;
 555         int i, ncmds;
 556
 557         /*
 558          * XXX Should we allocate all the commands up front, or allocate on
 559          * demand later like 'aac' does?
 560          */
 561         ncmds = MIN(mfi_max_cmds, sc->mfi_max_fw_cmds);
 562         if (bootverbose)
 563                 device_printf(sc->mfi_dev, "Max fw cmds= %d, sizing driver "
 564                    "pool to %d\n", sc->mfi_max_fw_cmds, ncmds);
 565
 566         sc->mfi_commands = malloc(sizeof(struct mfi_command) * ncmds, M_MFIBUF,
 567             M_WAITOK | M_ZERO);
 568
 569         for (i = 0; i < ncmds; i++) {
 570                 cm = &sc->mfi_commands[i];
 571                 cm->cm_frame = (union mfi_frame *)((uintptr_t)sc->mfi_frames +
 572                     sc->mfi_cmd_size * i);
 573                 cm->cm_frame_busaddr = sc->mfi_frames_busaddr +
 574                     sc->mfi_cmd_size * i;
 575                 cm->cm_frame->header.context = i;
 576                 cm->cm_sense = &sc->mfi_sense[i];
 577                 cm->cm_sense_busaddr= sc->mfi_sense_busaddr + MFI_SENSE_LEN * i;
 578                 cm->cm_sc = sc;
 579                 cm->cm_index = i;
 580                 if (bus_dmamap_create(sc->mfi_buffer_dmat, 0,
 581                     &cm->cm_dmamap) == 0)
 582                         mfi_release_command(cm);
 583                 else
 584                         break;
 585                 sc->mfi_total_cmds++;
 586         }
 587
 588         return (0);
 589 }
 590
 591 void
 592 mfi_release_command(struct mfi_command *cm)
 593 {
 594         struct mfi_frame_header *hdr;
 595         uint32_t *hdr_data;
 596
 597         /*
 598          * Zero out the important fields of the frame, but make sure the
 599          * context field is preserved.  For efficiency, handle the fields
 600          * as 32 bit words.  Clear out the first S/G entry too for safety.
 601          */
 602         hdr = &cm->cm_frame->header;
 603         if (cm->cm_data != NULL && hdr->sg_count) {
 604                 cm->cm_sg->sg32[0].len = 0;
 605                 cm->cm_sg->sg32[0].addr = 0;
 606         }
 607
 608         hdr_data = (uint32_t *)cm->cm_frame;
 609         hdr_data[0] = 0;        /* cmd, sense_len, cmd_status, scsi_status */
 610         hdr_data[1] = 0;        /* target_id, lun_id, cdb_len, sg_count */
 611         hdr_data[4] = 0;        /* flags, timeout */
 612         hdr_data[5] = 0;        /* data_len */
 613
 614         cm->cm_extra_frames = 0;
 615         cm->cm_flags = 0;
 616         cm->cm_complete = NULL;
 617         cm->cm_private = NULL;
 618         cm->cm_data = NULL;
 619         cm->cm_sg = 0;
 620         cm->cm_total_frame_size = 0;
 621
 622         mfi_enqueue_free(cm);
 623 }
 624
 625 static int
 626 mfi_dcmd_command(struct mfi_softc *sc, struct mfi_command **cmp, uint32_t opcode,
 627     void **bufp, size_t bufsize)
 628 {
 629         struct mfi_command *cm;
 630         struct mfi_dcmd_frame *dcmd;
 631         void *buf = NULL;
 632
 633         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
 634
 635         cm = mfi_dequeue_free(sc);
 636         if (cm == NULL)
 637                 return (EBUSY);
 638
 639         if ((bufsize > 0) && (bufp != NULL)) {
 640                 if (*bufp == NULL) {
 641                         buf = malloc(bufsize, M_MFIBUF, M_NOWAIT|M_ZERO);
 642                         if (buf == NULL) {
 643                                 mfi_release_command(cm);
 644                                 return (ENOMEM);
 645                         }
 646                         *bufp = buf;
 647                 } else {
 648                         buf = *bufp;
 649                 }
 650         }
 651
 652         dcmd =  &cm->cm_frame->dcmd;
 653         bzero(dcmd->mbox, MFI_MBOX_SIZE);
 654         dcmd->header.cmd = MFI_CMD_DCMD;
 655         dcmd->header.timeout = 0;
 656         dcmd->header.flags = 0;
 657         dcmd->header.data_len = bufsize;
 658         dcmd->opcode = opcode;
 659         cm->cm_sg = &dcmd->sgl;
 660         cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE;
 661         cm->cm_flags = 0;
 662         cm->cm_data = buf;
 663         cm->cm_private = buf;
 664         cm->cm_len = bufsize;
 665
 666         *cmp = cm;
 667         if ((bufp != NULL) && (*bufp == NULL) && (buf != NULL))
 668                 *bufp = buf;
 669         return (0);
 670 }
 671
 672 static int
 673 mfi_comms_init(struct mfi_softc *sc)
 674 {
 675         struct mfi_command *cm;
 676         struct mfi_init_frame *init;
 677         struct mfi_init_qinfo *qinfo;
 678         int error;
 679
 680         mtx_lock(&sc->mfi_io_lock);
 681         if ((cm = mfi_dequeue_free(sc)) == NULL)
 682                 return (EBUSY);
 683
 684         /*
 685          * Abuse the SG list area of the frame to hold the init_qinfo
 686          * object;
 687          */
 688         init = &cm->cm_frame->init;
 689         qinfo = (struct mfi_init_qinfo *)((uintptr_t)init + MFI_FRAME_SIZE);
 690
 691         bzero(qinfo, sizeof(struct mfi_init_qinfo));
 692         qinfo->rq_entries = sc->mfi_max_fw_cmds + 1;
 693         qinfo->rq_addr_lo = sc->mfi_comms_busaddr +
 694             offsetof(struct mfi_hwcomms, hw_reply_q);
 695         qinfo->pi_addr_lo = sc->mfi_comms_busaddr +
 696             offsetof(struct mfi_hwcomms, hw_pi);
 697         qinfo->ci_addr_lo = sc->mfi_comms_busaddr +
 698             offsetof(struct mfi_hwcomms, hw_ci);
 699
 700         init->header.cmd = MFI_CMD_INIT;
 701         init->header.data_len = sizeof(struct mfi_init_qinfo);
 702         init->qinfo_new_addr_lo = cm->cm_frame_busaddr + MFI_FRAME_SIZE;
 703         cm->cm_data = NULL;
 704         cm->cm_flags = MFI_CMD_POLLED;
 705
 706         if ((error = mfi_mapcmd(sc, cm)) != 0) {
 707                 device_printf(sc->mfi_dev, "failed to send init command\n");
 708                 mtx_unlock(&sc->mfi_io_lock);
 709                 return (error);
 710         }
 711         mfi_release_command(cm);
 712         mtx_unlock(&sc->mfi_io_lock);
 713
 714         return (0);
 715 }
 716
 717 static int
 718 mfi_get_controller_info(struct mfi_softc *sc)
 719 {
 720         struct mfi_command *cm = NULL;
 721         struct mfi_ctrl_info *ci = NULL;
 722         uint32_t max_sectors_1, max_sectors_2;
 723         int error;
 724
 725         mtx_lock(&sc->mfi_io_lock);
 726         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_GETINFO,
 727             (void **)&ci, sizeof(*ci));
 728         if (error)
 729                 goto out;
 730         cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
 731
 732         if ((error = mfi_mapcmd(sc, cm)) != 0) {
 733                 device_printf(sc->mfi_dev, "Failed to get controller info\n");
 734                 sc->mfi_max_io = (sc->mfi_max_sge - 1) * PAGE_SIZE /
 735                     MFI_SECTOR_LEN;
 736                 error = 0;
 737                 goto out;
 738         }
 739
 740         bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
 741             BUS_DMASYNC_POSTREAD);
 742         bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
 743
 744         max_sectors_1 = (1 << ci->stripe_sz_ops.min) * ci->max_strips_per_io;
 745         max_sectors_2 = ci->max_request_size;
 746         sc->mfi_max_io = min(max_sectors_1, max_sectors_2);
 747
 748 out:
 749         if (ci)
 750                 free(ci, M_MFIBUF);
 751         if (cm)
 752                 mfi_release_command(cm);
 753         mtx_unlock(&sc->mfi_io_lock);
 754         return (error);
 755 }
 756
 757 static int
 758 mfi_get_log_state(struct mfi_softc *sc, struct mfi_evt_log_state **log_state)
 759 {
 760         struct mfi_command *cm = NULL;
 761         int error;
 762
 763         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_EVENT_GETINFO,
 764             (void **)log_state, sizeof(**log_state));
 765         if (error)
 766                 goto out;
 767         cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
 768
 769         if ((error = mfi_mapcmd(sc, cm)) != 0) {
 770                 device_printf(sc->mfi_dev, "Failed to get log state\n");
 771                 goto out;
 772         }
 773
 774         bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
 775             BUS_DMASYNC_POSTREAD);
 776         bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
 777
 778 out:
 779         if (cm)
 780                 mfi_release_command(cm);
 781
 782         return (error);
 783 }
 784
 785 static int
 786 mfi_aen_setup(struct mfi_softc *sc, uint32_t seq_start)
 787 {
 788         struct mfi_evt_log_state *log_state = NULL;
 789         union mfi_evt class_locale;
 790         int error = 0;
 791         uint32_t seq;
 792
 793         class_locale.members.reserved = 0;
 794         class_locale.members.locale = mfi_event_locale;
 795         class_locale.members.evt_class  = mfi_event_class;
 796
 797         if (seq_start == 0) {
 798                 error = mfi_get_log_state(sc, &log_state);
 799                 if (error) {
 800                         if (log_state)
 801                                 free(log_state, M_MFIBUF);
 802                         return (error);
 803                 }
 804
 805                 /*
 806                  * Walk through any events that fired since the last
 807                  * shutdown.
 808                  */
 809                 mfi_parse_entries(sc, log_state->shutdown_seq_num,
 810                     log_state->newest_seq_num);
 811                 seq = log_state->newest_seq_num;
 812         } else
 813                 seq = seq_start;
 814         mfi_aen_register(sc, seq, class_locale.word);
 815         free(log_state, M_MFIBUF);
 816
 817         return 0;
 818 }
 819
 820 static int
 821 mfi_wait_command(struct mfi_softc *sc, struct mfi_command *cm)
 822 {
 823
 824         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
 825         cm->cm_complete = NULL;
 826
 827
 828         /*
 829          * MegaCli can issue a DCMD of 0.  In this case do nothing
 830          * and return 0 to it as status
 831          */
 832         if (cm->cm_frame->dcmd.opcode == 0) {
 833                 cm->cm_frame->header.cmd_status = MFI_STAT_OK;
 834                 cm->cm_error = 0;
 835                 return (cm->cm_error);
 836         }
 837         mfi_enqueue_ready(cm);
 838         mfi_startio(sc);
 839         if ((cm->cm_flags & MFI_CMD_COMPLETED) == 0)
 840                 msleep(cm, &sc->mfi_io_lock, PRIBIO, "mfiwait", 0);
 841         return (cm->cm_error);
 842 }
 843
 844 void
 845 mfi_free(struct mfi_softc *sc)
 846 {
 847         struct mfi_command *cm;
 848         int i;
 849
 850         callout_drain(&sc->mfi_watchdog_callout);
 851
 852         if (sc->mfi_cdev != NULL)
 853                 destroy_dev(sc->mfi_cdev);
 854
 855         if (sc->mfi_total_cmds != 0) {
 856                 for (i = 0; i < sc->mfi_total_cmds; i++) {
 857                         cm = &sc->mfi_commands[i];
 858                         bus_dmamap_destroy(sc->mfi_buffer_dmat, cm->cm_dmamap);
 859                 }
 860                 free(sc->mfi_commands, M_MFIBUF);
 861         }
 862
 863         if (sc->mfi_intr)
 864                 bus_teardown_intr(sc->mfi_dev, sc->mfi_irq, sc->mfi_intr);
 865         if (sc->mfi_irq != NULL)
 866                 bus_release_resource(sc->mfi_dev, SYS_RES_IRQ, sc->mfi_irq_rid,
 867                     sc->mfi_irq);
 868
 869         if (sc->mfi_sense_busaddr != 0)
 870                 bus_dmamap_unload(sc->mfi_sense_dmat, sc->mfi_sense_dmamap);
 871         if (sc->mfi_sense != NULL)
 872                 bus_dmamem_free(sc->mfi_sense_dmat, sc->mfi_sense,
 873                     sc->mfi_sense_dmamap);
 874         if (sc->mfi_sense_dmat != NULL)
 875                 bus_dma_tag_destroy(sc->mfi_sense_dmat);
 876
 877         if (sc->mfi_frames_busaddr != 0)
 878                 bus_dmamap_unload(sc->mfi_frames_dmat, sc->mfi_frames_dmamap);
 879         if (sc->mfi_frames != NULL)
 880                 bus_dmamem_free(sc->mfi_frames_dmat, sc->mfi_frames,
 881                     sc->mfi_frames_dmamap);
 882         if (sc->mfi_frames_dmat != NULL)
 883                 bus_dma_tag_destroy(sc->mfi_frames_dmat);
 884
 885         if (sc->mfi_comms_busaddr != 0)
 886                 bus_dmamap_unload(sc->mfi_comms_dmat, sc->mfi_comms_dmamap);
 887         if (sc->mfi_comms != NULL)
 888                 bus_dmamem_free(sc->mfi_comms_dmat, sc->mfi_comms,
 889                     sc->mfi_comms_dmamap);
 890         if (sc->mfi_comms_dmat != NULL)
 891                 bus_dma_tag_destroy(sc->mfi_comms_dmat);
 892
 893         if (sc->mfi_buffer_dmat != NULL)
 894                 bus_dma_tag_destroy(sc->mfi_buffer_dmat);
 895         if (sc->mfi_parent_dmat != NULL)
 896                 bus_dma_tag_destroy(sc->mfi_parent_dmat);
 897
 898         if (mtx_initialized(&sc->mfi_io_lock)) {
 899                 mtx_destroy(&sc->mfi_io_lock);
 900                 sx_destroy(&sc->mfi_config_lock);
 901         }
 902
 903         return;
 904 }
 905
 906 static void
 907 mfi_startup(void *arg)
 908 {
 909         struct mfi_softc *sc;
 910
 911         sc = (struct mfi_softc *)arg;
 912
 913         config_intrhook_disestablish(&sc->mfi_ich);
 914
 915         sc->mfi_enable_intr(sc);
 916         sx_xlock(&sc->mfi_config_lock);
 917         mtx_lock(&sc->mfi_io_lock);
 918         mfi_ldprobe(sc);
 919         mtx_unlock(&sc->mfi_io_lock);
 920         sx_xunlock(&sc->mfi_config_lock);
 921 }
 922
 923 static void
 924 mfi_intr(void *arg)
 925 {
 926         struct mfi_softc *sc;
 927         struct mfi_command *cm;
 928         uint32_t pi, ci, context;
 929
 930         sc = (struct mfi_softc *)arg;
 931
 932         if (sc->mfi_check_clear_intr(sc))
 933                 return;
 934
 935         /*
 936          * Do a dummy read to flush the interrupt ACK that we just performed,
 937          * ensuring that everything is really, truly consistent.
 938          */
 939         (void)sc->mfi_read_fw_status(sc);
 940
 941         pi = sc->mfi_comms->hw_pi;
 942         ci = sc->mfi_comms->hw_ci;
 943         mtx_lock(&sc->mfi_io_lock);
 944         while (ci != pi) {
 945                 context = sc->mfi_comms->hw_reply_q[ci];
 946                 if (context < sc->mfi_max_fw_cmds) {
 947                         cm = &sc->mfi_commands[context];
 948                         mfi_remove_busy(cm);
 949                         cm->cm_error = 0;
 950                         mfi_complete(sc, cm);
 951                 }
 952                 if (++ci == (sc->mfi_max_fw_cmds + 1)) {
 953                         ci = 0;
 954                 }
 955         }
 956
 957         sc->mfi_comms->hw_ci = ci;
 958
 959         /* Give defered I/O a chance to run */
 960         if (sc->mfi_flags & MFI_FLAGS_QFRZN)
 961                 sc->mfi_flags &= ~MFI_FLAGS_QFRZN;
 962         mfi_startio(sc);
 963         mtx_unlock(&sc->mfi_io_lock);
 964
 965         return;
 966 }
 967
 968 int
 969 mfi_shutdown(struct mfi_softc *sc)
 970 {
 971         struct mfi_dcmd_frame *dcmd;
 972         struct mfi_command *cm;
 973         int error;
 974
 975         mtx_lock(&sc->mfi_io_lock);
 976         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_SHUTDOWN, NULL, 0);
 977         if (error) {
 978                 mtx_unlock(&sc->mfi_io_lock);
 979                 return (error);
 980         }
 981
 982         if (sc->mfi_aen_cm != NULL)
 983                 mfi_abort(sc, sc->mfi_aen_cm);
 984
 985         dcmd = &cm->cm_frame->dcmd;
 986         dcmd->header.flags = MFI_FRAME_DIR_NONE;
 987         cm->cm_flags = MFI_CMD_POLLED;
 988         cm->cm_data = NULL;
 989
 990         if ((error = mfi_mapcmd(sc, cm)) != 0) {
 991                 device_printf(sc->mfi_dev, "Failed to shutdown controller\n");
 992         }
 993
 994         mfi_release_command(cm);
 995         mtx_unlock(&sc->mfi_io_lock);
 996         return (error);
 997 }
 998
 999 static void
1000 mfi_ldprobe(struct mfi_softc *sc)
1001 {
1002         struct mfi_frame_header *hdr;
1003         struct mfi_command *cm = NULL;
1004         struct mfi_ld_list *list = NULL;
1005         struct mfi_disk *ld;
1006         int error, i;
1007
1008         sx_assert(&sc->mfi_config_lock, SA_XLOCKED);
1009         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1010
1011         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_LIST,
1012             (void **)&list, sizeof(*list));
1013         if (error)
1014                 goto out;
1015
1016         cm->cm_flags = MFI_CMD_DATAIN;
1017         if (mfi_wait_command(sc, cm) != 0) {
1018                 device_printf(sc->mfi_dev, "Failed to get device listing\n");
1019                 goto out;
1020         }
1021
1022         hdr = &cm->cm_frame->header;
1023         if (hdr->cmd_status != MFI_STAT_OK) {
1024                 device_printf(sc->mfi_dev, "MFI_DCMD_LD_GET_LIST failed %x\n",
1025                     hdr->cmd_status);
1026                 goto out;
1027         }
1028
1029         for (i = 0; i < list->ld_count; i++) {
1030                 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
1031                         if (ld->ld_id == list->ld_list[i].ld.v.target_id)
1032                                 goto skip_add;
1033                 }
1034                 mfi_add_ld(sc, list->ld_list[i].ld.v.target_id);
1035         skip_add:;
1036         }
1037 out:
1038         if (list)
1039                 free(list, M_MFIBUF);
1040         if (cm)
1041                 mfi_release_command(cm);
1042
1043         return;
1044 }
1045
1046 /*
1047  * The timestamp is the number of seconds since 00:00 Jan 1, 2000.  If
1048  * the bits in 24-31 are all set, then it is the number of seconds since
1049  * boot.
1050  */
1051 static const char *
1052 format_timestamp(uint32_t timestamp)
1053 {
1054         static char buffer[32];
1055
1056         if ((timestamp & 0xff000000) == 0xff000000)
1057                 snprintf(buffer, sizeof(buffer), "boot + %us", timestamp &
1058                     0x00ffffff);
1059         else
1060                 snprintf(buffer, sizeof(buffer), "%us", timestamp);
1061         return (buffer);
1062 }
1063
1064 static const char *
1065 format_class(int8_t class)
1066 {
1067         static char buffer[6];
1068
1069         switch (class) {
1070         case MFI_EVT_CLASS_DEBUG:
1071                 return ("debug");
1072         case MFI_EVT_CLASS_PROGRESS:
1073                 return ("progress");
1074         case MFI_EVT_CLASS_INFO:
1075                 return ("info");
1076         case MFI_EVT_CLASS_WARNING:
1077                 return ("WARN");
1078         case MFI_EVT_CLASS_CRITICAL:
1079                 return ("CRIT");
1080         case MFI_EVT_CLASS_FATAL:
1081                 return ("FATAL");
1082         case MFI_EVT_CLASS_DEAD:
1083                 return ("DEAD");
1084         default:
1085                 snprintf(buffer, sizeof(buffer), "%d", class);
1086                 return (buffer);
1087         }
1088 }
1089
1090 static void
1091 mfi_decode_evt(struct mfi_softc *sc, struct mfi_evt_detail *detail)
1092 {
1093
1094         device_printf(sc->mfi_dev, "%d (%s/0x%04x/%s) - %s\n", detail->seq,
1095             format_timestamp(detail->time), detail->evt_class.members.locale,
1096             format_class(detail->evt_class.members.evt_class), detail->description);
1097 }
1098
1099 static int
1100 mfi_aen_register(struct mfi_softc *sc, int seq, int locale)
1101 {
1102         struct mfi_command *cm;
1103         struct mfi_dcmd_frame *dcmd;
1104         union mfi_evt current_aen, prior_aen;
1105         struct mfi_evt_detail *ed = NULL;
1106         int error = 0;
1107
1108         current_aen.word = locale;
1109         if (sc->mfi_aen_cm != NULL) {
1110                 prior_aen.word =
1111                     ((uint32_t *)&sc->mfi_aen_cm->cm_frame->dcmd.mbox)[1];
1112                 if (prior_aen.members.evt_class <= current_aen.members.evt_class &&
1113                     !((prior_aen.members.locale & current_aen.members.locale)
1114                     ^current_aen.members.locale)) {
1115                         return (0);
1116                 } else {
1117                         prior_aen.members.locale |= current_aen.members.locale;
1118                         if (prior_aen.members.evt_class
1119                             < current_aen.members.evt_class)
1120                                 current_aen.members.evt_class =
1121                                     prior_aen.members.evt_class;
1122                         mfi_abort(sc, sc->mfi_aen_cm);
1123                 }
1124         }
1125
1126         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_EVENT_WAIT,
1127             (void **)&ed, sizeof(*ed));
1128         if (error) {
1129                 goto out;
1130         }
1131
1132         dcmd = &cm->cm_frame->dcmd;
1133         ((uint32_t *)&dcmd->mbox)[0] = seq;
1134         ((uint32_t *)&dcmd->mbox)[1] = locale;
1135         cm->cm_flags = MFI_CMD_DATAIN;
1136         cm->cm_complete = mfi_aen_complete;
1137
1138         sc->mfi_aen_cm = cm;
1139
1140         mfi_enqueue_ready(cm);
1141         mfi_startio(sc);
1142
1143 out:
1144         return (error);
1145 }
1146
1147 static void
1148 mfi_aen_complete(struct mfi_command *cm)
1149 {
1150         struct mfi_frame_header *hdr;
1151         struct mfi_softc *sc;
1152         struct mfi_evt_detail *detail;
1153         struct mfi_aen *mfi_aen_entry, *tmp;
1154         int seq = 0, aborted = 0;
1155
1156         sc = cm->cm_sc;
1157         hdr = &cm->cm_frame->header;
1158
1159         if (sc->mfi_aen_cm == NULL)
1160                 return;
1161
1162         if (sc->mfi_aen_cm->cm_aen_abort ||
1163             hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
1164                 sc->mfi_aen_cm->cm_aen_abort = 0;
1165                 aborted = 1;
1166         } else {
1167                 sc->mfi_aen_triggered = 1;
1168                 if (sc->mfi_poll_waiting) {
1169                         sc->mfi_poll_waiting = 0;
1170                         selwakeup(&sc->mfi_select);
1171                 }
1172                 detail = cm->cm_data;
1173                 /*
1174                  * XXX If this function is too expensive or is recursive, then
1175                  * events should be put onto a queue and processed later.
1176                  */
1177                 mfi_decode_evt(sc, detail);
1178                 seq = detail->seq + 1;
1179                 TAILQ_FOREACH_SAFE(mfi_aen_entry, &sc->mfi_aen_pids, aen_link, tmp) {
1180                         TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry,
1181                             aen_link);
1182                         PROC_LOCK(mfi_aen_entry->p);
1183                         kern_psignal(mfi_aen_entry->p, SIGIO);
1184                         PROC_UNLOCK(mfi_aen_entry->p);
1185                         free(mfi_aen_entry, M_MFIBUF);
1186                 }
1187         }
1188
1189         free(cm->cm_data, M_MFIBUF);
1190         sc->mfi_aen_cm = NULL;
1191         wakeup(&sc->mfi_aen_cm);
1192         mfi_release_command(cm);
1193
1194         /* set it up again so the driver can catch more events */
1195         if (!aborted) {
1196                 mfi_aen_setup(sc, seq);
1197         }
1198 }
1199
1200 #define MAX_EVENTS 15
1201
1202 static int
1203 mfi_parse_entries(struct mfi_softc *sc, int start_seq, int stop_seq)
1204 {
1205         struct mfi_command *cm;
1206         struct mfi_dcmd_frame *dcmd;
1207         struct mfi_evt_list *el;
1208         union mfi_evt class_locale;
1209         int error, i, seq, size;
1210
1211         class_locale.members.reserved = 0;
1212         class_locale.members.locale = mfi_event_locale;
1213         class_locale.members.evt_class  = mfi_event_class;
1214
1215         size = sizeof(struct mfi_evt_list) + sizeof(struct mfi_evt_detail)
1216                 * (MAX_EVENTS - 1);
1217         el = malloc(size, M_MFIBUF, M_NOWAIT | M_ZERO);
1218         if (el == NULL)
1219                 return (ENOMEM);
1220
1221         for (seq = start_seq;;) {
1222                 if ((cm = mfi_dequeue_free(sc)) == NULL) {
1223                         free(el, M_MFIBUF);
1224                         return (EBUSY);
1225                 }
1226
1227                 dcmd = &cm->cm_frame->dcmd;
1228                 bzero(dcmd->mbox, MFI_MBOX_SIZE);
1229                 dcmd->header.cmd = MFI_CMD_DCMD;
1230                 dcmd->header.timeout = 0;
1231                 dcmd->header.data_len = size;
1232                 dcmd->opcode = MFI_DCMD_CTRL_EVENT_GET;
1233                 ((uint32_t *)&dcmd->mbox)[0] = seq;
1234                 ((uint32_t *)&dcmd->mbox)[1] = class_locale.word;
1235                 cm->cm_sg = &dcmd->sgl;
1236                 cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE;
1237                 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED;
1238                 cm->cm_data = el;
1239                 cm->cm_len = size;
1240
1241                 if ((error = mfi_mapcmd(sc, cm)) != 0) {
1242                         device_printf(sc->mfi_dev,
1243                             "Failed to get controller entries\n");
1244                         mfi_release_command(cm);
1245                         break;
1246                 }
1247
1248                 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
1249                     BUS_DMASYNC_POSTREAD);
1250                 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1251
1252                 if (dcmd->header.cmd_status == MFI_STAT_NOT_FOUND) {
1253                         mfi_release_command(cm);
1254                         break;
1255                 }
1256                 if (dcmd->header.cmd_status != MFI_STAT_OK) {
1257                         device_printf(sc->mfi_dev,
1258                             "Error %d fetching controller entries\n",
1259                             dcmd->header.cmd_status);
1260                         mfi_release_command(cm);
1261                         break;
1262                 }
1263                 mfi_release_command(cm);
1264
1265                 for (i = 0; i < el->count; i++) {
1266                         /*
1267                          * If this event is newer than 'stop_seq' then
1268                          * break out of the loop.  Note that the log
1269                          * is a circular buffer so we have to handle
1270                          * the case that our stop point is earlier in
1271                          * the buffer than our start point.
1272                          */
1273                         if (el->event[i].seq >= stop_seq) {
1274                                 if (start_seq <= stop_seq)
1275                                         break;
1276                                 else if (el->event[i].seq < start_seq)
1277                                         break;
1278                         }
1279                         mfi_decode_evt(sc, &el->event[i]);
1280                 }
1281                 seq = el->event[el->count - 1].seq + 1;
1282         }
1283
1284         free(el, M_MFIBUF);
1285         return (0);
1286 }
1287
1288 static int
1289 mfi_add_ld(struct mfi_softc *sc, int id)
1290 {
1291         struct mfi_command *cm;
1292         struct mfi_dcmd_frame *dcmd = NULL;
1293         struct mfi_ld_info *ld_info = NULL;
1294         int error;
1295
1296         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1297
1298         error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_INFO,
1299             (void **)&ld_info, sizeof(*ld_info));
1300         if (error) {
1301                 device_printf(sc->mfi_dev,
1302                     "Failed to allocate for MFI_DCMD_LD_GET_INFO %d\n", error);
1303                 if (ld_info)
1304                         free(ld_info, M_MFIBUF);
1305                 return (error);
1306         }
1307         cm->cm_flags = MFI_CMD_DATAIN;
1308         dcmd = &cm->cm_frame->dcmd;
1309         dcmd->mbox[0] = id;
1310         if (mfi_wait_command(sc, cm) != 0) {
1311                 device_printf(sc->mfi_dev,
1312                     "Failed to get logical drive: %d\n", id);
1313                 free(ld_info, M_MFIBUF);
1314                 return (0);
1315         }
1316
1317         mfi_add_ld_complete(cm);
1318         return (0);
1319 }
1320
1321 static void
1322 mfi_add_ld_complete(struct mfi_command *cm)
1323 {
1324         struct mfi_frame_header *hdr;
1325         struct mfi_ld_info *ld_info;
1326         struct mfi_softc *sc;
1327         device_t child;
1328
1329         sc = cm->cm_sc;
1330         hdr = &cm->cm_frame->header;
1331         ld_info = cm->cm_private;
1332
1333         if (hdr->cmd_status != MFI_STAT_OK) {
1334                 free(ld_info, M_MFIBUF);
1335                 mfi_release_command(cm);
1336                 return;
1337         }
1338         mfi_release_command(cm);
1339
1340         mtx_unlock(&sc->mfi_io_lock);
1341         mtx_lock(&Giant);
1342         if ((child = device_add_child(sc->mfi_dev, "mfid", -1)) == NULL) {
1343                 device_printf(sc->mfi_dev, "Failed to add logical disk\n");
1344                 free(ld_info, M_MFIBUF);
1345                 mtx_unlock(&Giant);
1346                 mtx_lock(&sc->mfi_io_lock);
1347                 return;
1348         }
1349
1350         device_set_ivars(child, ld_info);
1351         device_set_desc(child, "MFI Logical Disk");
1352         bus_generic_attach(sc->mfi_dev);
1353         mtx_unlock(&Giant);
1354         mtx_lock(&sc->mfi_io_lock);
1355 }
1356
1357 static struct mfi_command *
1358 mfi_bio_command(struct mfi_softc *sc)
1359 {
1360         struct mfi_io_frame *io;
1361         struct mfi_command *cm;
1362         struct bio *bio;
1363         int flags, blkcount;
1364
1365         if ((cm = mfi_dequeue_free(sc)) == NULL)
1366                 return (NULL);
1367
1368         if ((bio = mfi_dequeue_bio(sc)) == NULL) {
1369                 mfi_release_command(cm);
1370                 return (NULL);
1371         }
1372
1373         io = &cm->cm_frame->io;
1374         switch (bio->bio_cmd & 0x03) {
1375         case BIO_READ:
1376                 io->header.cmd = MFI_CMD_LD_READ;
1377                 flags = MFI_CMD_DATAIN;
1378                 break;
1379         case BIO_WRITE:
1380                 io->header.cmd = MFI_CMD_LD_WRITE;
1381                 flags = MFI_CMD_DATAOUT;
1382                 break;
1383         default:
1384                 panic("Invalid bio command");
1385         }
1386
1387         /* Cheat with the sector length to avoid a non-constant division */
1388         blkcount = (bio->bio_bcount + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN;
1389         io->header.target_id = (uintptr_t)bio->bio_driver1;
1390         io->header.timeout = 0;
1391         io->header.flags = 0;
1392         io->header.sense_len = MFI_SENSE_LEN;
1393         io->header.data_len = blkcount;
1394         io->sense_addr_lo = cm->cm_sense_busaddr;
1395         io->sense_addr_hi = 0;
1396         io->lba_hi = (bio->bio_pblkno & 0xffffffff00000000) >> 32;
1397         io->lba_lo = bio->bio_pblkno & 0xffffffff;
1398         cm->cm_complete = mfi_bio_complete;
1399         cm->cm_private = bio;
1400         cm->cm_data = bio->bio_data;
1401         cm->cm_len = bio->bio_bcount;
1402         cm->cm_sg = &io->sgl;
1403         cm->cm_total_frame_size = MFI_IO_FRAME_SIZE;
1404         cm->cm_flags = flags;
1405         return (cm);
1406 }
1407
1408 static void
1409 mfi_bio_complete(struct mfi_command *cm)
1410 {
1411         struct bio *bio;
1412         struct mfi_frame_header *hdr;
1413         struct mfi_softc *sc;
1414
1415         bio = cm->cm_private;
1416         hdr = &cm->cm_frame->header;
1417         sc = cm->cm_sc;
1418
1419         if ((hdr->cmd_status != MFI_STAT_OK) || (hdr->scsi_status != 0)) {
1420                 bio->bio_flags |= BIO_ERROR;
1421                 bio->bio_error = EIO;
1422                 device_printf(sc->mfi_dev, "I/O error, status= %d "
1423                     "scsi_status= %d\n", hdr->cmd_status, hdr->scsi_status);
1424                 mfi_print_sense(cm->cm_sc, cm->cm_sense);
1425         } else if (cm->cm_error != 0) {
1426                 bio->bio_flags |= BIO_ERROR;
1427         }
1428
1429         mfi_release_command(cm);
1430         mfi_disk_complete(bio);
1431 }
1432
1433 void
1434 mfi_startio(struct mfi_softc *sc)
1435 {
1436         struct mfi_command *cm;
1437         struct ccb_hdr *ccbh;
1438
1439         for (;;) {
1440                 /* Don't bother if we're short on resources */
1441                 if (sc->mfi_flags & MFI_FLAGS_QFRZN)
1442                         break;
1443
1444                 /* Try a command that has already been prepared */
1445                 cm = mfi_dequeue_ready(sc);
1446
1447                 if (cm == NULL) {
1448                         if ((ccbh = TAILQ_FIRST(&sc->mfi_cam_ccbq)) != NULL)
1449                                 cm = sc->mfi_cam_start(ccbh);
1450                 }
1451
1452                 /* Nope, so look for work on the bioq */
1453                 if (cm == NULL)
1454                         cm = mfi_bio_command(sc);
1455
1456                 /* No work available, so exit */
1457                 if (cm == NULL)
1458                         break;
1459
1460                 /* Send the command to the controller */
1461                 if (mfi_mapcmd(sc, cm) != 0) {
1462                         mfi_requeue_ready(cm);
1463                         break;
1464                 }
1465         }
1466 }
1467
1468 static int
1469 mfi_mapcmd(struct mfi_softc *sc, struct mfi_command *cm)
1470 {
1471         int error, polled;
1472
1473         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1474
1475         if (cm->cm_data != NULL) {
1476                 polled = (cm->cm_flags & MFI_CMD_POLLED) ? BUS_DMA_NOWAIT : 0;
1477                 error = bus_dmamap_load(sc->mfi_buffer_dmat, cm->cm_dmamap,
1478                     cm->cm_data, cm->cm_len, mfi_data_cb, cm, polled);
1479                 if (error == EINPROGRESS) {
1480                         sc->mfi_flags |= MFI_FLAGS_QFRZN;
1481                         return (0);
1482                 }
1483         } else {
1484                 error = mfi_send_frame(sc, cm);
1485         }
1486
1487         return (error);
1488 }
1489
1490 static void
1491 mfi_data_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
1492 {
1493         struct mfi_frame_header *hdr;
1494         struct mfi_command *cm;
1495         union mfi_sgl *sgl;
1496         struct mfi_softc *sc;
1497         int i, j, first, dir;
1498
1499         cm = (struct mfi_command *)arg;
1500         sc = cm->cm_sc;
1501         hdr = &cm->cm_frame->header;
1502         sgl = cm->cm_sg;
1503
1504         if (error) {
1505                 printf("error %d in callback\n", error);
1506                 cm->cm_error = error;
1507                 mfi_complete(sc, cm);
1508                 return;
1509         }
1510
1511         j = 0;
1512         if (cm->cm_frame->header.cmd == MFI_CMD_STP) {
1513                 first = cm->cm_stp_len;
1514                 if ((sc->mfi_flags & MFI_FLAGS_SG64) == 0) {
1515                         sgl->sg32[j].addr = segs[0].ds_addr;
1516                         sgl->sg32[j++].len = first;
1517                 } else {
1518                         sgl->sg64[j].addr = segs[0].ds_addr;
1519                         sgl->sg64[j++].len = first;
1520                 }
1521         } else
1522                 first = 0;
1523         if ((sc->mfi_flags & MFI_FLAGS_SG64) == 0) {
1524                 for (i = 0; i < nsegs; i++) {
1525                         sgl->sg32[j].addr = segs[i].ds_addr + first;
1526                         sgl->sg32[j++].len = segs[i].ds_len - first;
1527                         first = 0;
1528                 }
1529         } else {
1530                 for (i = 0; i < nsegs; i++) {
1531                         sgl->sg64[j].addr = segs[i].ds_addr + first;
1532                         sgl->sg64[j++].len = segs[i].ds_len - first;
1533                         first = 0;
1534                 }
1535                 hdr->flags |= MFI_FRAME_SGL64;
1536         }
1537         hdr->sg_count = j;
1538
1539         dir = 0;
1540         if (cm->cm_flags & MFI_CMD_DATAIN) {
1541                 dir |= BUS_DMASYNC_PREREAD;
1542                 hdr->flags |= MFI_FRAME_DIR_READ;
1543         }
1544         if (cm->cm_flags & MFI_CMD_DATAOUT) {
1545                 dir |= BUS_DMASYNC_PREWRITE;
1546                 hdr->flags |= MFI_FRAME_DIR_WRITE;
1547         }
1548         if (cm->cm_frame->header.cmd == MFI_CMD_STP)
1549                 dir |= BUS_DMASYNC_PREWRITE;
1550         bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, dir);
1551         cm->cm_flags |= MFI_CMD_MAPPED;
1552
1553         /*
1554          * Instead of calculating the total number of frames in the
1555          * compound frame, it's already assumed that there will be at
1556          * least 1 frame, so don't compensate for the modulo of the
1557          * following division.
1558          */
1559         cm->cm_total_frame_size += (sc->mfi_sge_size * nsegs);
1560         cm->cm_extra_frames = (cm->cm_total_frame_size - 1) / MFI_FRAME_SIZE;
1561
1562         mfi_send_frame(sc, cm);
1563
1564         return;
1565 }
1566
1567 static int
1568 mfi_send_frame(struct mfi_softc *sc, struct mfi_command *cm)
1569 {
1570         struct mfi_frame_header *hdr;
1571         int tm = MFI_POLL_TIMEOUT_SECS * 1000;
1572
1573         hdr = &cm->cm_frame->header;
1574
1575         if ((cm->cm_flags & MFI_CMD_POLLED) == 0) {
1576                 cm->cm_timestamp = time_uptime;
1577                 mfi_enqueue_busy(cm);
1578         } else {
1579                 hdr->cmd_status = MFI_STAT_INVALID_STATUS;
1580                 hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
1581         }
1582
1583         /*
1584          * The bus address of the command is aligned on a 64 byte boundary,
1585          * leaving the least 6 bits as zero.  For whatever reason, the
1586          * hardware wants the address shifted right by three, leaving just
1587          * 3 zero bits.  These three bits are then used as a prefetching
1588          * hint for the hardware to predict how many frames need to be
1589          * fetched across the bus.  If a command has more than 8 frames
1590          * then the 3 bits are set to 0x7 and the firmware uses other
1591          * information in the command to determine the total amount to fetch.
1592          * However, FreeBSD doesn't support I/O larger than 128K, so 8 frames
1593          * is enough for both 32bit and 64bit systems.
1594          */
1595         if (cm->cm_extra_frames > 7)
1596                 cm->cm_extra_frames = 7;
1597
1598         sc->mfi_issue_cmd(sc,cm->cm_frame_busaddr,cm->cm_extra_frames);
1599
1600         if ((cm->cm_flags & MFI_CMD_POLLED) == 0)
1601                 return (0);
1602
1603         /* This is a polled command, so busy-wait for it to complete. */
1604         while (hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
1605                 DELAY(1000);
1606                 tm -= 1;
1607                 if (tm <= 0)
1608                         break;
1609         }
1610
1611         if (hdr->cmd_status == MFI_STAT_INVALID_STATUS) {
1612                 device_printf(sc->mfi_dev, "Frame %p timed out "
1613                               "command 0x%X\n", hdr, cm->cm_frame->dcmd.opcode);
1614                 return (ETIMEDOUT);
1615         }
1616
1617         return (0);
1618 }
1619
1620 static void
1621 mfi_complete(struct mfi_softc *sc, struct mfi_command *cm)
1622 {
1623         int dir;
1624
1625         if ((cm->cm_flags & MFI_CMD_MAPPED) != 0) {
1626                 dir = 0;
1627                 if ((cm->cm_flags & MFI_CMD_DATAIN) ||
1628                     (cm->cm_frame->header.cmd == MFI_CMD_STP))
1629                         dir |= BUS_DMASYNC_POSTREAD;
1630                 if (cm->cm_flags & MFI_CMD_DATAOUT)
1631                         dir |= BUS_DMASYNC_POSTWRITE;
1632
1633                 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, dir);
1634                 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1635                 cm->cm_flags &= ~MFI_CMD_MAPPED;
1636         }
1637
1638         cm->cm_flags |= MFI_CMD_COMPLETED;
1639
1640         if (cm->cm_complete != NULL)
1641                 cm->cm_complete(cm);
1642         else
1643                 wakeup(cm);
1644 }
1645
1646 static int
1647 mfi_abort(struct mfi_softc *sc, struct mfi_command *cm_abort)
1648 {
1649         struct mfi_command *cm;
1650         struct mfi_abort_frame *abort;
1651         int i = 0;
1652
1653         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1654
1655         if ((cm = mfi_dequeue_free(sc)) == NULL) {
1656                 return (EBUSY);
1657         }
1658
1659         abort = &cm->cm_frame->abort;
1660         abort->header.cmd = MFI_CMD_ABORT;
1661         abort->header.flags = 0;
1662         abort->abort_context = cm_abort->cm_frame->header.context;
1663         abort->abort_mfi_addr_lo = cm_abort->cm_frame_busaddr;
1664         abort->abort_mfi_addr_hi = 0;
1665         cm->cm_data = NULL;
1666         cm->cm_flags = MFI_CMD_POLLED;
1667
1668         sc->mfi_aen_cm->cm_aen_abort = 1;
1669         mfi_mapcmd(sc, cm);
1670         mfi_release_command(cm);
1671
1672         while (i < 5 && sc->mfi_aen_cm != NULL) {
1673                 msleep(&sc->mfi_aen_cm, &sc->mfi_io_lock, 0, "mfiabort", 5 * hz);
1674                 i++;
1675         }
1676
1677         return (0);
1678 }
1679
1680 int
1681 mfi_dump_blocks(struct mfi_softc *sc, int id, uint64_t lba, void *virt, int len)
1682 {
1683         struct mfi_command *cm;
1684         struct mfi_io_frame *io;
1685         int error;
1686
1687         if ((cm = mfi_dequeue_free(sc)) == NULL)
1688                 return (EBUSY);
1689
1690         io = &cm->cm_frame->io;
1691         io->header.cmd = MFI_CMD_LD_WRITE;
1692         io->header.target_id = id;
1693         io->header.timeout = 0;
1694         io->header.flags = 0;
1695         io->header.sense_len = MFI_SENSE_LEN;
1696         io->header.data_len = (len + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN;
1697         io->sense_addr_lo = cm->cm_sense_busaddr;
1698         io->sense_addr_hi = 0;
1699         io->lba_hi = (lba & 0xffffffff00000000) >> 32;
1700         io->lba_lo = lba & 0xffffffff;
1701         cm->cm_data = virt;
1702         cm->cm_len = len;
1703         cm->cm_sg = &io->sgl;
1704         cm->cm_total_frame_size = MFI_IO_FRAME_SIZE;
1705         cm->cm_flags = MFI_CMD_POLLED | MFI_CMD_DATAOUT;
1706
1707         error = mfi_mapcmd(sc, cm);
1708         bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap,
1709             BUS_DMASYNC_POSTWRITE);
1710         bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap);
1711         mfi_release_command(cm);
1712
1713         return (error);
1714 }
1715
1716 static int
1717 mfi_open(struct cdev *dev, int flags, int fmt, struct thread *td)
1718 {
1719         struct mfi_softc *sc;
1720         int error;
1721
1722         sc = dev->si_drv1;
1723
1724         mtx_lock(&sc->mfi_io_lock);
1725         if (sc->mfi_detaching)
1726                 error = ENXIO;
1727         else {
1728                 sc->mfi_flags |= MFI_FLAGS_OPEN;
1729                 error = 0;
1730         }
1731         mtx_unlock(&sc->mfi_io_lock);
1732
1733         return (error);
1734 }
1735
1736 static int
1737 mfi_close(struct cdev *dev, int flags, int fmt, struct thread *td)
1738 {
1739         struct mfi_softc *sc;
1740         struct mfi_aen *mfi_aen_entry, *tmp;
1741
1742         sc = dev->si_drv1;
1743
1744         mtx_lock(&sc->mfi_io_lock);
1745         sc->mfi_flags &= ~MFI_FLAGS_OPEN;
1746
1747         TAILQ_FOREACH_SAFE(mfi_aen_entry, &sc->mfi_aen_pids, aen_link, tmp) {
1748                 if (mfi_aen_entry->p == curproc) {
1749                         TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry,
1750                             aen_link);
1751                         free(mfi_aen_entry, M_MFIBUF);
1752                 }
1753         }
1754         mtx_unlock(&sc->mfi_io_lock);
1755         return (0);
1756 }
1757
1758 static int
1759 mfi_config_lock(struct mfi_softc *sc, uint32_t opcode)
1760 {
1761
1762         switch (opcode) {
1763         case MFI_DCMD_LD_DELETE:
1764         case MFI_DCMD_CFG_ADD:
1765         case MFI_DCMD_CFG_CLEAR:
1766                 sx_xlock(&sc->mfi_config_lock);
1767                 return (1);
1768         default:
1769                 return (0);
1770         }
1771 }
1772
1773 static void
1774 mfi_config_unlock(struct mfi_softc *sc, int locked)
1775 {
1776
1777         if (locked)
1778                 sx_xunlock(&sc->mfi_config_lock);
1779 }
1780
1781 /* Perform pre-issue checks on commands from userland and possibly veto them. */
1782 static int
1783 mfi_check_command_pre(struct mfi_softc *sc, struct mfi_command *cm)
1784 {
1785         struct mfi_disk *ld, *ld2;
1786         int error;
1787
1788         mtx_assert(&sc->mfi_io_lock, MA_OWNED);
1789         error = 0;
1790         switch (cm->cm_frame->dcmd.opcode) {
1791         case MFI_DCMD_LD_DELETE:
1792                 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
1793                         if (ld->ld_id == cm->cm_frame->dcmd.mbox[0])
1794                                 break;
1795                 }
1796                 if (ld == NULL)
1797                         error = ENOENT;
1798                 else
1799                         error = mfi_disk_disable(ld);
1800                 break;
1801         case MFI_DCMD_CFG_CLEAR:
1802                 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
1803                         error = mfi_disk_disable(ld);
1804                         if (error)
1805                                 break;
1806                 }
1807                 if (error) {
1808                         TAILQ_FOREACH(ld2, &sc->mfi_ld_tqh, ld_link) {
1809                                 if (ld2 == ld)
1810                                         break;
1811                                 mfi_disk_enable(ld2);
1812                         }
1813                 }
1814                 break;
1815         default:
1816                 break;
1817         }
1818         return (error);
1819 }
1820
1821 /* Perform post-issue checks on commands from userland. */
1822 static void
1823 mfi_check_command_post(struct mfi_softc *sc, struct mfi_command *cm)
1824 {
1825         struct mfi_disk *ld, *ldn;
1826
1827         switch (cm->cm_frame->dcmd.opcode) {
1828         case MFI_DCMD_LD_DELETE:
1829                 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
1830                         if (ld->ld_id == cm->cm_frame->dcmd.mbox[0])
1831                                 break;
1832                 }
1833                 KASSERT(ld != NULL, ("volume dissappeared"));
1834                 if (cm->cm_frame->header.cmd_status == MFI_STAT_OK) {
1835                         mtx_unlock(&sc->mfi_io_lock);
1836                         mtx_lock(&Giant);
1837                         device_delete_child(sc->mfi_dev, ld->ld_dev);
1838                         mtx_unlock(&Giant);
1839                         mtx_lock(&sc->mfi_io_lock);
1840                 } else
1841                         mfi_disk_enable(ld);
1842                 break;
1843         case MFI_DCMD_CFG_CLEAR:
1844                 if (cm->cm_frame->header.cmd_status == MFI_STAT_OK) {
1845                         mtx_unlock(&sc->mfi_io_lock);
1846                         mtx_lock(&Giant);
1847                         TAILQ_FOREACH_SAFE(ld, &sc->mfi_ld_tqh, ld_link, ldn) {
1848                                 device_delete_child(sc->mfi_dev, ld->ld_dev);
1849                         }
1850                         mtx_unlock(&Giant);
1851                         mtx_lock(&sc->mfi_io_lock);
1852                 } else {
1853                         TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link)
1854                                 mfi_disk_enable(ld);
1855                 }
1856                 break;
1857         case MFI_DCMD_CFG_ADD:
1858                 mfi_ldprobe(sc);
1859                 break;
1860         case MFI_DCMD_CFG_FOREIGN_IMPORT:
1861                 mfi_ldprobe(sc);
1862                 break;
1863         }
1864 }
1865
1866 static int
1867 mfi_user_command(struct mfi_softc *sc, struct mfi_ioc_passthru *ioc)
1868 {
1869         struct mfi_command *cm;
1870         struct mfi_dcmd_frame *dcmd;
1871         void *ioc_buf = NULL;
1872         uint32_t context;
1873         int error = 0, locked;
1874
1875
1876         if (ioc->buf_size > 0) {
1877                 ioc_buf = malloc(ioc->buf_size, M_MFIBUF, M_WAITOK);
1878                 if (ioc_buf == NULL) {
1879                         return (ENOMEM);
1880                 }
1881                 error = copyin(ioc->buf, ioc_buf, ioc->buf_size);
1882                 if (error) {
1883                         device_printf(sc->mfi_dev, "failed to copyin\n");
1884                         free(ioc_buf, M_MFIBUF);
1885                         return (error);
1886                 }
1887         }
1888
1889         locked = mfi_config_lock(sc, ioc->ioc_frame.opcode);
1890
1891         mtx_lock(&sc->mfi_io_lock);
1892         while ((cm = mfi_dequeue_free(sc)) == NULL)
1893                 msleep(mfi_user_command, &sc->mfi_io_lock, 0, "mfiioc", hz);
1894
1895         /* Save context for later */
1896         context = cm->cm_frame->header.context;
1897
1898         dcmd = &cm->cm_frame->dcmd;
1899         bcopy(&ioc->ioc_frame, dcmd, sizeof(struct mfi_dcmd_frame));
1900
1901         cm->cm_sg = &dcmd->sgl;
1902         cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE;
1903         cm->cm_data = ioc_buf;
1904         cm->cm_len = ioc->buf_size;
1905
1906         /* restore context */
1907         cm->cm_frame->header.context = context;
1908
1909         /* Cheat since we don't know if we're writing or reading */
1910         cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_DATAOUT;
1911
1912         error = mfi_check_command_pre(sc, cm);
1913         if (error)
1914                 goto out;
1915
1916         error = mfi_wait_command(sc, cm);
1917         if (error) {
1918                 device_printf(sc->mfi_dev, "ioctl failed %d\n", error);
1919                 goto out;
1920         }
1921         bcopy(dcmd, &ioc->ioc_frame, sizeof(struct mfi_dcmd_frame));
1922         mfi_check_command_post(sc, cm);
1923 out:
1924         mfi_release_command(cm);
1925         mtx_unlock(&sc->mfi_io_lock);
1926         mfi_config_unlock(sc, locked);
1927         if (ioc->buf_size > 0)
1928                 error = copyout(ioc_buf, ioc->buf, ioc->buf_size);
1929         if (ioc_buf)
1930                 free(ioc_buf, M_MFIBUF);
1931         return (error);
1932 }
1933
1934 #ifdef __amd64__
1935 #define PTRIN(p)                ((void *)(uintptr_t)(p))
1936 #else
1937 #define PTRIN(p)                (p)
1938 #endif
1939
1940 static int
1941 mfi_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int flag, struct thread *td)
1942 {
1943         struct mfi_softc *sc;
1944         union mfi_statrequest *ms;
1945         struct mfi_ioc_packet *ioc;
1946 #ifdef __amd64__
1947         struct mfi_ioc_packet32 *ioc32;
1948 #endif
1949         struct mfi_ioc_aen *aen;
1950         struct mfi_command *cm = NULL;
1951         uint32_t context;
1952         union mfi_sense_ptr sense_ptr;
1953         uint8_t *data = NULL, *temp, *addr;
1954         size_t len;
1955         int i;
1956         struct mfi_ioc_passthru *iop = (struct mfi_ioc_passthru *)arg;
1957 #ifdef __amd64__
1958         struct mfi_ioc_passthru32 *iop32 = (struct mfi_ioc_passthru32 *)arg;
1959         struct mfi_ioc_passthru iop_swab;
1960 #endif
1961         int error, locked;
1962
1963         sc = dev->si_drv1;
1964         error = 0;
1965
1966         switch (cmd) {
1967         case MFIIO_STATS:
1968                 ms = (union mfi_statrequest *)arg;
1969                 switch (ms->ms_item) {
1970                 case MFIQ_FREE:
1971                 case MFIQ_BIO:
1972                 case MFIQ_READY:
1973                 case MFIQ_BUSY:
1974                         bcopy(&sc->mfi_qstat[ms->ms_item], &ms->ms_qstat,
1975                             sizeof(struct mfi_qstat));
1976                         break;
1977                 default:
1978                         error = ENOIOCTL;
1979                         break;
1980                 }
1981                 break;
1982         case MFIIO_QUERY_DISK:
1983         {
1984                 struct mfi_query_disk *qd;
1985                 struct mfi_disk *ld;
1986
1987                 qd = (struct mfi_query_disk *)arg;
1988                 mtx_lock(&sc->mfi_io_lock);
1989                 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) {
1990                         if (ld->ld_id == qd->array_id)
1991                                 break;
1992                 }
1993                 if (ld == NULL) {
1994                         qd->present = 0;
1995                         mtx_unlock(&sc->mfi_io_lock);
1996                         return (0);
1997                 }
1998                 qd->present = 1;
1999                 if (ld->ld_flags & MFI_DISK_FLAGS_OPEN)
2000                         qd->open = 1;
2001                 bzero(qd->devname, SPECNAMELEN + 1);
2002                 snprintf(qd->devname, SPECNAMELEN, "mfid%d", ld->ld_unit);
2003                 mtx_unlock(&sc->mfi_io_lock);
2004                 break;
2005         }
2006         case MFI_CMD:
2007 #ifdef __amd64__
2008         case MFI_CMD32:
2009 #endif
2010                 {
2011                 devclass_t devclass;
2012                 ioc = (struct mfi_ioc_packet *)arg;
2013                 int adapter;
2014
2015                 adapter = ioc->mfi_adapter_no;
2016                 if (device_get_unit(sc->mfi_dev) == 0 && adapter != 0) {
2017                         devclass = devclass_find("mfi");
2018                         sc = devclass_get_softc(devclass, adapter);
2019                 }
2020                 mtx_lock(&sc->mfi_io_lock);
2021                 if ((cm = mfi_dequeue_free(sc)) == NULL) {
2022                         mtx_unlock(&sc->mfi_io_lock);
2023                         return (EBUSY);
2024                 }
2025                 mtx_unlock(&sc->mfi_io_lock);
2026                 locked = 0;
2027
2028                 /*
2029                  * save off original context since copying from user
2030                  * will clobber some data
2031                  */
2032                 context = cm->cm_frame->header.context;
2033
2034                 bcopy(ioc->mfi_frame.raw, cm->cm_frame,
2035                     2 * MFI_DCMD_FRAME_SIZE);  /* this isn't quite right */
2036                 cm->cm_total_frame_size = (sizeof(union mfi_sgl)
2037                     * ioc->mfi_sge_count) + ioc->mfi_sgl_off;
2038                 if (ioc->mfi_sge_count) {
2039                         cm->cm_sg =
2040                             (union mfi_sgl *)&cm->cm_frame->bytes[ioc->mfi_sgl_off];
2041                 }
2042                 cm->cm_flags = 0;
2043                 if (cm->cm_frame->header.flags & MFI_FRAME_DATAIN)
2044                         cm->cm_flags |= MFI_CMD_DATAIN;
2045                 if (cm->cm_frame->header.flags & MFI_FRAME_DATAOUT)
2046                         cm->cm_flags |= MFI_CMD_DATAOUT;
2047                 /* Legacy app shim */
2048                 if (cm->cm_flags == 0)
2049                         cm->cm_flags |= MFI_CMD_DATAIN | MFI_CMD_DATAOUT;
2050                 cm->cm_len = cm->cm_frame->header.data_len;
2051                 if (cm->cm_frame->header.cmd == MFI_CMD_STP) {
2052 #ifdef __amd64__
2053                         if (cmd == MFI_CMD) {
2054 #endif
2055                                 /* Native */
2056                                 cm->cm_stp_len = ioc->mfi_sgl[0].iov_len;
2057 #ifdef __amd64__
2058                         } else {
2059                                 /* 32bit on 64bit */
2060                                 ioc32 = (struct mfi_ioc_packet32 *)ioc;
2061                                 cm->cm_stp_len = ioc32->mfi_sgl[0].iov_len;
2062                         }
2063 #endif
2064                         cm->cm_len += cm->cm_stp_len;
2065                 }
2066                 if (cm->cm_len &&
2067                     (cm->cm_flags & (MFI_CMD_DATAIN | MFI_CMD_DATAOUT))) {
2068                         cm->cm_data = data = malloc(cm->cm_len, M_MFIBUF,
2069                             M_WAITOK | M_ZERO);
2070                         if (cm->cm_data == NULL) {
2071                                 device_printf(sc->mfi_dev, "Malloc failed\n");
2072                                 goto out;
2073                         }
2074                 } else {
2075                         cm->cm_data = 0;
2076                 }
2077
2078                 /* restore header context */
2079                 cm->cm_frame->header.context = context;
2080
2081                 temp = data;
2082                 if ((cm->cm_flags & MFI_CMD_DATAOUT) ||
2083                     (cm->cm_frame->header.cmd == MFI_CMD_STP)) {
2084                         for (i = 0; i < ioc->mfi_sge_count; i++) {
2085 #ifdef __amd64__
2086                                 if (cmd == MFI_CMD) {
2087 #endif
2088                                         /* Native */
2089                                         addr = ioc->mfi_sgl[i].iov_base;
2090                                         len = ioc->mfi_sgl[i].iov_len;
2091 #ifdef __amd64__
2092                                 } else {
2093                                         /* 32bit on 64bit */
2094                                         ioc32 = (struct mfi_ioc_packet32 *)ioc;
2095                                         addr = PTRIN(ioc32->mfi_sgl[i].iov_base);
2096                                         len = ioc32->mfi_sgl[i].iov_len;
2097                                 }
2098 #endif
2099                                 error = copyin(addr, temp, len);
2100                                 if (error != 0) {
2101                                         device_printf(sc->mfi_dev,
2102                                             "Copy in failed\n");
2103                                         goto out;
2104                                 }
2105                                 temp = &temp[len];
2106                         }
2107                 }
2108
2109                 if (cm->cm_frame->header.cmd == MFI_CMD_DCMD)
2110                         locked = mfi_config_lock(sc, cm->cm_frame->dcmd.opcode);
2111
2112                 if (cm->cm_frame->header.cmd == MFI_CMD_PD_SCSI_IO) {
2113                         cm->cm_frame->pass.sense_addr_lo = cm->cm_sense_busaddr;
2114                         cm->cm_frame->pass.sense_addr_hi = 0;
2115                 }
2116
2117                 mtx_lock(&sc->mfi_io_lock);
2118                 error = mfi_check_command_pre(sc, cm);
2119                 if (error) {
2120                         mtx_unlock(&sc->mfi_io_lock);
2121                         goto out;
2122                 }
2123
2124                 if ((error = mfi_wait_command(sc, cm)) != 0) {
2125                         device_printf(sc->mfi_dev,
2126                             "Controller polled failed\n");
2127                         mtx_unlock(&sc->mfi_io_lock);
2128                         goto out;
2129                 }
2130
2131                 mfi_check_command_post(sc, cm);
2132                 mtx_unlock(&sc->mfi_io_lock);
2133
2134                 temp = data;
2135                 if ((cm->cm_flags & MFI_CMD_DATAIN) ||
2136                     (cm->cm_frame->header.cmd == MFI_CMD_STP)) {
2137                         for (i = 0; i < ioc->mfi_sge_count; i++) {
2138 #ifdef __amd64__
2139                                 if (cmd == MFI_CMD) {
2140 #endif
2141                                         /* Native */
2142                                         addr = ioc->mfi_sgl[i].iov_base;
2143                                         len = ioc->mfi_sgl[i].iov_len;
2144 #ifdef __amd64__
2145                                 } else {
2146                                         /* 32bit on 64bit */
2147                                         ioc32 = (struct mfi_ioc_packet32 *)ioc;
2148                                         addr = PTRIN(ioc32->mfi_sgl[i].iov_base);
2149                                         len = ioc32->mfi_sgl[i].iov_len;
2150                                 }
2151 #endif
2152                                 error = copyout(temp, addr, len);
2153                                 if (error != 0) {
2154                                         device_printf(sc->mfi_dev,
2155                                             "Copy out failed\n");
2156                                         goto out;
2157                                 }
2158                                 temp = &temp[len];
2159                         }
2160                 }
2161
2162                 if (ioc->mfi_sense_len) {
2163                         /* get user-space sense ptr then copy out sense */
2164                         bcopy(&ioc->mfi_frame.raw[ioc->mfi_sense_off],
2165                             &sense_ptr.sense_ptr_data[0],
2166                             sizeof(sense_ptr.sense_ptr_data));
2167 #ifdef __amd64__
2168                         if (cmd != MFI_CMD) {
2169                                 /*
2170                                  * not 64bit native so zero out any address
2171                                  * over 32bit */
2172                                 sense_ptr.addr.high = 0;
2173                         }
2174 #endif
2175                         error = copyout(cm->cm_sense, sense_ptr.user_space,
2176                             ioc->mfi_sense_len);
2177                         if (error != 0) {
2178                                 device_printf(sc->mfi_dev,
2179                                     "Copy out failed\n");
2180                                 goto out;
2181                         }
2182                 }
2183
2184                 ioc->mfi_frame.hdr.cmd_status = cm->cm_frame->header.cmd_status;
2185 out:
2186                 mfi_config_unlock(sc, locked);
2187                 if (data)
2188                         free(data, M_MFIBUF);
2189                 if (cm) {
2190                         mtx_lock(&sc->mfi_io_lock);
2191                         mfi_release_command(cm);
2192                         mtx_unlock(&sc->mfi_io_lock);
2193                 }
2194
2195                 break;
2196                 }
2197         case MFI_SET_AEN:
2198                 aen = (struct mfi_ioc_aen *)arg;
2199                 error = mfi_aen_register(sc, aen->aen_seq_num,
2200                     aen->aen_class_locale);
2201
2202                 break;
2203         case MFI_LINUX_CMD_2: /* Firmware Linux ioctl shim */
2204                 {
2205                         devclass_t devclass;
2206                         struct mfi_linux_ioc_packet l_ioc;
2207                         int adapter;
2208
2209                         devclass = devclass_find("mfi");
2210                         if (devclass == NULL)
2211                                 return (ENOENT);
2212
2213                         error = copyin(arg, &l_ioc, sizeof(l_ioc));
2214                         if (error)
2215                                 return (error);
2216                         adapter = l_ioc.lioc_adapter_no;
2217                         sc = devclass_get_softc(devclass, adapter);
2218                         if (sc == NULL)
2219                                 return (ENOENT);
2220                         return (mfi_linux_ioctl_int(sc->mfi_cdev,
2221                             cmd, arg, flag, td));
2222                         break;
2223                 }
2224         case MFI_LINUX_SET_AEN_2: /* AEN Linux ioctl shim */
2225                 {
2226                         devclass_t devclass;
2227                         struct mfi_linux_ioc_aen l_aen;
2228                         int adapter;
2229
2230                         devclass = devclass_find("mfi");
2231                         if (devclass == NULL)
2232                                 return (ENOENT);
2233
2234                         error = copyin(arg, &l_aen, sizeof(l_aen));
2235                         if (error)
2236                                 return (error);
2237                         adapter = l_aen.laen_adapter_no;
2238                         sc = devclass_get_softc(devclass, adapter);
2239                         if (sc == NULL)
2240                                 return (ENOENT);
2241                         return (mfi_linux_ioctl_int(sc->mfi_cdev,
2242                             cmd, arg, flag, td));
2243                         break;
2244                 }
2245 #ifdef __amd64__
2246         case MFIIO_PASSTHRU32:
2247                 iop_swab.ioc_frame      = iop32->ioc_frame;
2248                 iop_swab.buf_size       = iop32->buf_size;
2249                 iop_swab.buf            = PTRIN(iop32->buf);
2250                 iop                     = &iop_swab;
2251                 /* FALLTHROUGH */
2252 #endif
2253         case MFIIO_PASSTHRU:
2254                 error = mfi_user_command(sc, iop);
2255 #ifdef __amd64__
2256                 if (cmd == MFIIO_PASSTHRU32)
2257                         iop32->ioc_frame = iop_swab.ioc_frame;
2258 #endif
2259                 break;
2260         default:
2261                 device_printf(sc->mfi_dev, "IOCTL 0x%lx not handled\n", cmd);
2262                 error = ENOENT;
2263                 break;
2264         }
2265
2266         return (error);
2267 }
2268
2269 static int
2270 mfi_linux_ioctl_int(struct cdev *dev, u_long cmd, caddr_t arg, int flag, struct thread *td)
2271 {
2272         struct mfi_softc *sc;
2273         struct mfi_linux_ioc_packet l_ioc;
2274         struct mfi_linux_ioc_aen l_aen;
2275         struct mfi_command *cm = NULL;
2276         struct mfi_aen *mfi_aen_entry;
2277         union mfi_sense_ptr sense_ptr;
2278         uint32_t context;
2279         uint8_t *data = NULL, *temp;
2280         int i;
2281         int error, locked;
2282
2283         sc = dev->si_drv1;
2284         error = 0;
2285         switch (cmd) {
2286         case MFI_LINUX_CMD_2: /* Firmware Linux ioctl shim */
2287                 error = copyin(arg, &l_ioc, sizeof(l_ioc));
2288                 if (error != 0)
2289                         return (error);
2290
2291                 if (l_ioc.lioc_sge_count > MAX_LINUX_IOCTL_SGE) {
2292                         return (EINVAL);
2293                 }
2294
2295                 mtx_lock(&sc->mfi_io_lock);
2296                 if ((cm = mfi_dequeue_free(sc)) == NULL) {
2297                         mtx_unlock(&sc->mfi_io_lock);
2298                         return (EBUSY);
2299                 }
2300                 mtx_unlock(&sc->mfi_io_lock);
2301                 locked = 0;
2302
2303                 /*
2304                  * save off original context since copying from user
2305                  * will clobber some data
2306                  */
2307                 context = cm->cm_frame->header.context;
2308
2309                 bcopy(l_ioc.lioc_frame.raw, cm->cm_frame,
2310                       2 * MFI_DCMD_FRAME_SIZE); /* this isn't quite right */
2311                 cm->cm_total_frame_size = (sizeof(union mfi_sgl)
2312                       * l_ioc.lioc_sge_count) + l_ioc.lioc_sgl_off;
2313                 if (l_ioc.lioc_sge_count)
2314                         cm->cm_sg =
2315                             (union mfi_sgl *)&cm->cm_frame->bytes[l_ioc.lioc_sgl_off];
2316                 cm->cm_flags = 0;
2317                 if (cm->cm_frame->header.flags & MFI_FRAME_DATAIN)
2318                         cm->cm_flags |= MFI_CMD_DATAIN;
2319                 if (cm->cm_frame->header.flags & MFI_FRAME_DATAOUT)
2320                         cm->cm_flags |= MFI_CMD_DATAOUT;
2321                 cm->cm_len = cm->cm_frame->header.data_len;
2322                 if (cm->cm_len &&
2323                       (cm->cm_flags & (MFI_CMD_DATAIN | MFI_CMD_DATAOUT))) {
2324                         cm->cm_data = data = malloc(cm->cm_len, M_MFIBUF,
2325                             M_WAITOK | M_ZERO);
2326                         if (cm->cm_data == NULL) {
2327                                 device_printf(sc->mfi_dev, "Malloc failed\n");
2328                                 goto out;
2329                         }
2330                 } else {
2331                         cm->cm_data = 0;
2332                 }
2333
2334                 /* restore header context */
2335                 cm->cm_frame->header.context = context;
2336
2337                 temp = data;
2338                 if (cm->cm_flags & MFI_CMD_DATAOUT) {
2339                         for (i = 0; i < l_ioc.lioc_sge_count; i++) {
2340                                 error = copyin(PTRIN(l_ioc.lioc_sgl[i].iov_base),
2341                                        temp,
2342                                        l_ioc.lioc_sgl[i].iov_len);
2343                                 if (error != 0) {
2344                                         device_printf(sc->mfi_dev,
2345                                             "Copy in failed\n");
2346                                         goto out;
2347                                 }
2348                                 temp = &temp[l_ioc.lioc_sgl[i].iov_len];
2349                         }
2350                 }
2351
2352                 if (cm->cm_frame->header.cmd == MFI_CMD_DCMD)
2353                         locked = mfi_config_lock(sc, cm->cm_frame->dcmd.opcode);
2354
2355                 if (cm->cm_frame->header.cmd == MFI_CMD_PD_SCSI_IO) {
2356                         cm->cm_frame->pass.sense_addr_lo = cm->cm_sense_busaddr;
2357                         cm->cm_frame->pass.sense_addr_hi = 0;
2358                 }
2359
2360                 mtx_lock(&sc->mfi_io_lock);
2361                 error = mfi_check_command_pre(sc, cm);
2362                 if (error) {
2363                         mtx_unlock(&sc->mfi_io_lock);
2364                         goto out;
2365                 }
2366
2367                 if ((error = mfi_wait_command(sc, cm)) != 0) {
2368                         device_printf(sc->mfi_dev,
2369                             "Controller polled failed\n");
2370                         mtx_unlock(&sc->mfi_io_lock);
2371                         goto out;
2372                 }
2373
2374                 mfi_check_command_post(sc, cm);
2375                 mtx_unlock(&sc->mfi_io_lock);
2376
2377                 temp = data;
2378                 if (cm->cm_flags & MFI_CMD_DATAIN) {
2379                         for (i = 0; i < l_ioc.lioc_sge_count; i++) {
2380                                 error = copyout(temp,
2381                                         PTRIN(l_ioc.lioc_sgl[i].iov_base),
2382                                         l_ioc.lioc_sgl[i].iov_len);
2383                                 if (error != 0) {
2384                                         device_printf(sc->mfi_dev,
2385                                             "Copy out failed\n");
2386                                         goto out;
2387                                 }
2388                                 temp = &temp[l_ioc.lioc_sgl[i].iov_len];
2389                         }
2390                 }
2391
2392                 if (l_ioc.lioc_sense_len) {
2393                         /* get user-space sense ptr then copy out sense */
2394                         bcopy(&((struct mfi_linux_ioc_packet*)arg)
2395                             ->lioc_frame.raw[l_ioc.lioc_sense_off],
2396                             &sense_ptr.sense_ptr_data[0],
2397                             sizeof(sense_ptr.sense_ptr_data));
2398 #ifdef __amd64__
2399                         /*
2400                          * only 32bit Linux support so zero out any
2401                          * address over 32bit
2402                          */
2403                         sense_ptr.addr.high = 0;
2404 #endif
2405                         error = copyout(cm->cm_sense, sense_ptr.user_space,
2406                             l_ioc.lioc_sense_len);
2407                         if (error != 0) {
2408                                 device_printf(sc->mfi_dev,
2409                                     "Copy out failed\n");
2410                                 goto out;
2411                         }
2412                 }
2413
2414                 error = copyout(&cm->cm_frame->header.cmd_status,
2415                         &((struct mfi_linux_ioc_packet*)arg)
2416                         ->lioc_frame.hdr.cmd_status,
2417                         1);
2418                 if (error != 0) {
2419                         device_printf(sc->mfi_dev,
2420                                       "Copy out failed\n");
2421                         goto out;
2422                 }
2423
2424 out:
2425                 mfi_config_unlock(sc, locked);
2426                 if (data)
2427                         free(data, M_MFIBUF);
2428                 if (cm) {
2429                         mtx_lock(&sc->mfi_io_lock);
2430                         mfi_release_command(cm);
2431                         mtx_unlock(&sc->mfi_io_lock);
2432                 }
2433
2434                 return (error);
2435         case MFI_LINUX_SET_AEN_2: /* AEN Linux ioctl shim */
2436                 error = copyin(arg, &l_aen, sizeof(l_aen));
2437                 if (error != 0)
2438                         return (error);
2439                 printf("AEN IMPLEMENTED for pid %d\n", curproc->p_pid);
2440                 mfi_aen_entry = malloc(sizeof(struct mfi_aen), M_MFIBUF,
2441                     M_WAITOK);
2442                 mtx_lock(&sc->mfi_io_lock);
2443                 if (mfi_aen_entry != NULL) {
2444                         mfi_aen_entry->p = curproc;
2445                         TAILQ_INSERT_TAIL(&sc->mfi_aen_pids, mfi_aen_entry,
2446                             aen_link);
2447                 }
2448                 error = mfi_aen_register(sc, l_aen.laen_seq_num,
2449                     l_aen.laen_class_locale);
2450
2451                 if (error != 0) {
2452                         TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry,
2453                             aen_link);
2454                         free(mfi_aen_entry, M_MFIBUF);
2455                 }
2456                 mtx_unlock(&sc->mfi_io_lock);
2457
2458                 return (error);
2459         default:
2460                 device_printf(sc->mfi_dev, "IOCTL 0x%lx not handled\n", cmd);
2461                 error = ENOENT;
2462                 break;
2463         }
2464
2465         return (error);
2466 }
2467
2468 static int
2469 mfi_poll(struct cdev *dev, int poll_events, struct thread *td)
2470 {
2471         struct mfi_softc *sc;
2472         int revents = 0;
2473
2474         sc = dev->si_drv1;
2475
2476         if (poll_events & (POLLIN | POLLRDNORM)) {
2477                 if (sc->mfi_aen_triggered != 0) {
2478                         revents |= poll_events & (POLLIN | POLLRDNORM);
2479                         sc->mfi_aen_triggered = 0;
2480                 }
2481                 if (sc->mfi_aen_triggered == 0 && sc->mfi_aen_cm == NULL) {
2482                         revents |= POLLERR;
2483                 }
2484         }
2485
2486         if (revents == 0) {
2487                 if (poll_events & (POLLIN | POLLRDNORM)) {
2488                         sc->mfi_poll_waiting = 1;
2489                         selrecord(td, &sc->mfi_select);
2490                 }
2491         }
2492
2493         return revents;
2494 }
2495
2496
2497 static void
2498 mfi_dump_all(void)
2499 {
2500         struct mfi_softc *sc;
2501         struct mfi_command *cm;
2502         devclass_t dc;
2503         time_t deadline;
2504         int timedout;
2505         int i;
2506
2507         dc = devclass_find("mfi");
2508         if (dc == NULL) {
2509                 printf("No mfi dev class\n");
2510                 return;
2511         }
2512
2513         for (i = 0; ; i++) {
2514                 sc = devclass_get_softc(dc, i);
2515                 if (sc == NULL)
2516                         break;
2517                 device_printf(sc->mfi_dev, "Dumping\n\n");
2518                 timedout = 0;
2519                 deadline = time_uptime - MFI_CMD_TIMEOUT;
2520                 mtx_lock(&sc->mfi_io_lock);
2521                 TAILQ_FOREACH(cm, &sc->mfi_busy, cm_link) {
2522                         if (cm->cm_timestamp < deadline) {
2523                                 device_printf(sc->mfi_dev,
2524                                     "COMMAND %p TIMEOUT AFTER %d SECONDS\n", cm,
2525                                     (int)(time_uptime - cm->cm_timestamp));
2526                                 MFI_PRINT_CMD(cm);
2527                                 timedout++;
2528                         }
2529                 }
2530
2531 #if 0
2532                 if (timedout)
2533                         MFI_DUMP_CMDS(SC);
2534 #endif
2535
2536                 mtx_unlock(&sc->mfi_io_lock);
2537         }
2538
2539         return;
2540 }
2541
2542 static void
2543 mfi_timeout(void *data)
2544 {
2545         struct mfi_softc *sc = (struct mfi_softc *)data;
2546         struct mfi_command *cm;
2547         time_t deadline;
2548         int timedout = 0;
2549
2550         deadline = time_uptime - MFI_CMD_TIMEOUT;
2551         mtx_lock(&sc->mfi_io_lock);
2552         TAILQ_FOREACH(cm, &sc->mfi_busy, cm_link) {
2553                 if (sc->mfi_aen_cm == cm)
2554                         continue;
2555                 if ((sc->mfi_aen_cm != cm) && (cm->cm_timestamp < deadline)) {
2556                         device_printf(sc->mfi_dev,
2557                             "COMMAND %p TIMEOUT AFTER %d SECONDS\n", cm,
2558                             (int)(time_uptime - cm->cm_timestamp));
2559                         MFI_PRINT_CMD(cm);
2560                         MFI_VALIDATE_CMD(sc, cm);
2561                         timedout++;
2562                 }
2563         }
2564
2565 #if 0
2566         if (timedout)
2567                 MFI_DUMP_CMDS(SC);
2568 #endif
2569
2570         mtx_unlock(&sc->mfi_io_lock);
2571
2572         callout_reset(&sc->mfi_watchdog_callout, MFI_CMD_TIMEOUT * hz,
2573             mfi_timeout, sc);
2574
2575         if (0)
2576                 mfi_dump_all();
2577         return;
2578 }